diff --git a/api/openapi-spec/swagger.json b/api/openapi-spec/swagger.json index f1489ad26214..36e4df788263 100644 --- a/api/openapi-spec/swagger.json +++ b/api/openapi-spec/swagger.json @@ -7767,7 +7767,7 @@ }, "resources": { "$ref": "#/definitions/io.k8s.api.core.v1.ResourceRequirements", - "description": "Resources represents the minimum resources the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources" + "description": "Resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources" }, "selector": { "$ref": "#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector", @@ -7798,6 +7798,13 @@ }, "type": "array" }, + "allocatedResources": { + "additionalProperties": { + "$ref": "#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "description": "The storage resource within AllocatedResources tracks the capacity allocated to a PVC. It may be larger than the actual capacity when a volume expansion operation is requested. For storage quota, the larger value from allocatedResources and PVC.spec.resources is used. If allocatedResources is not set, PVC.spec.resources alone is used for quota calculation. If a volume expansion capacity request is lowered, allocatedResources is only lowered if there are no expansion operations in progress and if the actual volume capacity is equal or lower than the requested capacity. This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature.", + "type": "object" + }, "capacity": { "additionalProperties": { "$ref": "#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity" @@ -7817,6 +7824,10 @@ "phase": { "description": "Phase represents the current phase of PersistentVolumeClaim.", "type": "string" + }, + "resizeStatus": { + "description": "ResizeStatus stores status of resize operation. ResizeStatus is not set by default but when expansion is complete resizeStatus is set to empty string by resize controller or kubelet. This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature.", + "type": "string" } }, "type": "object" diff --git a/pkg/api/persistentvolumeclaim/util.go b/pkg/api/persistentvolumeclaim/util.go index 1f55fcbd4607..f0ff70546de4 100644 --- a/pkg/api/persistentvolumeclaim/util.go +++ b/pkg/api/persistentvolumeclaim/util.go @@ -74,6 +74,21 @@ func EnforceDataSourceBackwardsCompatibility(pvcSpec, oldPVCSpec *core.Persisten } } +func DropDisabledFieldsFromStatus(pvc, oldPVC *core.PersistentVolumeClaim) { + if !utilfeature.DefaultFeatureGate.Enabled(features.ExpandPersistentVolumes) && oldPVC.Status.Conditions == nil { + pvc.Status.Conditions = nil + } + + if !utilfeature.DefaultFeatureGate.Enabled(features.RecoverVolumeExpansionFailure) { + if !allocatedResourcesInUse(oldPVC) { + pvc.Status.AllocatedResources = nil + } + if !resizeStatusInUse(oldPVC) { + pvc.Status.ResizeStatus = nil + } + } +} + func dataSourceInUse(oldPVCSpec *core.PersistentVolumeClaimSpec) bool { if oldPVCSpec == nil { return false @@ -118,3 +133,25 @@ func NormalizeDataSources(pvcSpec *core.PersistentVolumeClaimSpec) { pvcSpec.DataSource = pvcSpec.DataSourceRef.DeepCopy() } } + +func resizeStatusInUse(oldPVC *core.PersistentVolumeClaim) bool { + if oldPVC == nil { + return false + } + if oldPVC.Status.ResizeStatus != nil { + return true + } + return false +} + +func allocatedResourcesInUse(oldPVC *core.PersistentVolumeClaim) bool { + if oldPVC == nil { + return false + } + + if oldPVC.Status.AllocatedResources != nil { + return true + } + + return false +} diff --git a/pkg/api/persistentvolumeclaim/util_test.go b/pkg/api/persistentvolumeclaim/util_test.go index 9f3da4e945d1..8462cde39f96 100644 --- a/pkg/api/persistentvolumeclaim/util_test.go +++ b/pkg/api/persistentvolumeclaim/util_test.go @@ -22,6 +22,7 @@ import ( "testing" "github.com/google/go-cmp/cmp" + "k8s.io/apimachinery/pkg/api/resource" utilfeature "k8s.io/apiserver/pkg/util/feature" featuregatetesting "k8s.io/component-base/featuregate/testing" @@ -288,3 +289,111 @@ func TestDataSourceRef(t *testing.T) { }) } } + +func TestDropDisabledFieldsFromStatus(t *testing.T) { + tests := []struct { + name string + feature bool + pvc *core.PersistentVolumeClaim + oldPVC *core.PersistentVolumeClaim + expected *core.PersistentVolumeClaim + }{ + { + name: "for:newPVC=hasAllocatedResource,oldPVC=doesnot,featuregate=false; should drop field", + feature: false, + pvc: withAllocatedResource("5G"), + oldPVC: getPVC(), + expected: getPVC(), + }, + { + name: "for:newPVC=hasAllocatedResource,oldPVC=doesnot,featuregate=true; should keep field", + feature: true, + pvc: withAllocatedResource("5G"), + oldPVC: getPVC(), + expected: withAllocatedResource("5G"), + }, + { + name: "for:newPVC=hasAllocatedResource,oldPVC=hasAllocatedResource,featuregate=true; should keep field", + feature: true, + pvc: withAllocatedResource("5G"), + oldPVC: withAllocatedResource("5G"), + expected: withAllocatedResource("5G"), + }, + { + name: "for:newPVC=hasAllocatedResource,oldPVC=hasAllocatedResource,featuregate=false; should keep field", + feature: false, + pvc: withAllocatedResource("10G"), + oldPVC: withAllocatedResource("5G"), + expected: withAllocatedResource("10G"), + }, + { + name: "for:newPVC=hasAllocatedResource,oldPVC=nil,featuregate=false; should drop field", + feature: false, + pvc: withAllocatedResource("5G"), + oldPVC: nil, + expected: getPVC(), + }, + { + name: "for:newPVC=hasResizeStatus,oldPVC=nil, featuregate=false should drop field", + feature: false, + pvc: withResizeStatus(core.PersistentVolumeClaimNodeExpansionFailed), + oldPVC: nil, + expected: getPVC(), + }, + { + name: "for:newPVC=hasResizeStatus,oldPVC=doesnot,featuregate=true; should keep field", + feature: true, + pvc: withResizeStatus(core.PersistentVolumeClaimNodeExpansionFailed), + oldPVC: getPVC(), + expected: withResizeStatus(core.PersistentVolumeClaimNodeExpansionFailed), + }, + { + name: "for:newPVC=hasResizeStatus,oldPVC=hasResizeStatus,featuregate=true; should keep field", + feature: true, + pvc: withResizeStatus(core.PersistentVolumeClaimNodeExpansionFailed), + oldPVC: withResizeStatus(core.PersistentVolumeClaimNodeExpansionFailed), + expected: withResizeStatus(core.PersistentVolumeClaimNodeExpansionFailed), + }, + { + name: "for:newPVC=hasResizeStatus,oldPVC=hasResizeStatus,featuregate=false; should keep field", + feature: false, + pvc: withResizeStatus(core.PersistentVolumeClaimNodeExpansionFailed), + oldPVC: withResizeStatus(core.PersistentVolumeClaimNodeExpansionFailed), + expected: withResizeStatus(core.PersistentVolumeClaimNodeExpansionFailed), + }, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.RecoverVolumeExpansionFailure, test.feature)() + + DropDisabledFieldsFromStatus(test.pvc, test.oldPVC) + + if !reflect.DeepEqual(*test.expected, *test.pvc) { + t.Errorf("Unexpected change: %+v", cmp.Diff(test.expected, test.pvc)) + } + }) + } +} + +func getPVC() *core.PersistentVolumeClaim { + return &core.PersistentVolumeClaim{} +} + +func withAllocatedResource(q string) *core.PersistentVolumeClaim { + return &core.PersistentVolumeClaim{ + Status: core.PersistentVolumeClaimStatus{ + AllocatedResources: core.ResourceList{ + core.ResourceStorage: resource.MustParse(q), + }, + }, + } +} + +func withResizeStatus(status core.PersistentVolumeClaimResizeStatus) *core.PersistentVolumeClaim { + return &core.PersistentVolumeClaim{ + Status: core.PersistentVolumeClaimStatus{ + ResizeStatus: &status, + }, + } +} diff --git a/pkg/apis/apps/v1/zz_generated.defaults.go b/pkg/apis/apps/v1/zz_generated.defaults.go index 4870c8148418..9f8932624a11 100644 --- a/pkg/apis/apps/v1/zz_generated.defaults.go +++ b/pkg/apis/apps/v1/zz_generated.defaults.go @@ -924,6 +924,7 @@ func SetObjectDefaults_StatefulSet(in *v1.StatefulSet) { corev1.SetDefaults_ResourceList(&a.Spec.Resources.Limits) corev1.SetDefaults_ResourceList(&a.Spec.Resources.Requests) corev1.SetDefaults_ResourceList(&a.Status.Capacity) + corev1.SetDefaults_ResourceList(&a.Status.AllocatedResources) } } diff --git a/pkg/apis/apps/v1beta1/zz_generated.defaults.go b/pkg/apis/apps/v1beta1/zz_generated.defaults.go index 6d6bb34d1364..b345cc1af8ce 100644 --- a/pkg/apis/apps/v1beta1/zz_generated.defaults.go +++ b/pkg/apis/apps/v1beta1/zz_generated.defaults.go @@ -478,6 +478,7 @@ func SetObjectDefaults_StatefulSet(in *v1beta1.StatefulSet) { v1.SetDefaults_ResourceList(&a.Spec.Resources.Limits) v1.SetDefaults_ResourceList(&a.Spec.Resources.Requests) v1.SetDefaults_ResourceList(&a.Status.Capacity) + v1.SetDefaults_ResourceList(&a.Status.AllocatedResources) } } diff --git a/pkg/apis/apps/v1beta2/zz_generated.defaults.go b/pkg/apis/apps/v1beta2/zz_generated.defaults.go index fa9fee553e7a..f578bf2db98e 100644 --- a/pkg/apis/apps/v1beta2/zz_generated.defaults.go +++ b/pkg/apis/apps/v1beta2/zz_generated.defaults.go @@ -924,6 +924,7 @@ func SetObjectDefaults_StatefulSet(in *v1beta2.StatefulSet) { v1.SetDefaults_ResourceList(&a.Spec.Resources.Limits) v1.SetDefaults_ResourceList(&a.Spec.Resources.Requests) v1.SetDefaults_ResourceList(&a.Status.Capacity) + v1.SetDefaults_ResourceList(&a.Status.AllocatedResources) } } diff --git a/pkg/apis/core/types.go b/pkg/apis/core/types.go index 8a8612a552f3..a64b27c9e317 100644 --- a/pkg/apis/core/types.go +++ b/pkg/apis/core/types.go @@ -430,6 +430,9 @@ type PersistentVolumeClaimSpec struct { // +optional Selector *metav1.LabelSelector // Resources represents the minimum resources required + // If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements + // that are lower than previous value but must still be higher than capacity recorded in the + // status field of the claim. // +optional Resources ResourceRequirements // VolumeName is the binding reference to the PersistentVolume backing this @@ -486,6 +489,26 @@ const ( PersistentVolumeClaimFileSystemResizePending PersistentVolumeClaimConditionType = "FileSystemResizePending" ) +// +enum +type PersistentVolumeClaimResizeStatus string + +const ( + // When expansion is complete, the empty string is set by resize controller or kubelet. + PersistentVolumeClaimNoExpansionInProgress PersistentVolumeClaimResizeStatus = "" + // State set when resize controller starts expanding the volume in control-plane + PersistentVolumeClaimControllerExpansionInProgress PersistentVolumeClaimResizeStatus = "ControllerExpansionInProgress" + // State set when expansion has failed in resize controller with a terminal error. + // Transient errors such as timeout should not set this status and should leave ResizeStatus + // unmodified, so as resize controller can resume the volume expansion. + PersistentVolumeClaimControllerExpansionFailed PersistentVolumeClaimResizeStatus = "ControllerExpansionFailed" + // State set when resize controller has finished expanding the volume but further expansion is needed on the node. + PersistentVolumeClaimNodeExpansionPending PersistentVolumeClaimResizeStatus = "NodeExpansionPending" + // State set when kubelet starts expanding the volume. + PersistentVolumeClaimNodeExpansionInProgress PersistentVolumeClaimResizeStatus = "NodeExpansionInProgress" + // State set when expansion has failed in kubelet with a terminal error. Transient errors don't set NodeExpansionFailed. + PersistentVolumeClaimNodeExpansionFailed PersistentVolumeClaimResizeStatus = "NodeExpansionFailed" +) + // PersistentVolumeClaimCondition represents the current condition of PV claim type PersistentVolumeClaimCondition struct { Type PersistentVolumeClaimConditionType @@ -513,6 +536,24 @@ type PersistentVolumeClaimStatus struct { Capacity ResourceList // +optional Conditions []PersistentVolumeClaimCondition + // The storage resource within AllocatedResources tracks the capacity allocated to a PVC. It may + // be larger than the actual capacity when a volume expansion operation is requested. + // For storage quota, the larger value from allocatedResources and PVC.spec.resources is used. + // If allocatedResources is not set, PVC.spec.resources alone is used for quota calculation. + // If a volume expansion capacity request is lowered, allocatedResources is only + // lowered if there are no expansion operations in progress and if the actual volume capacity + // is equal or lower than the requested capacity. + // This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature. + // +featureGate=RecoverVolumeExpansionFailure + // +optional + AllocatedResources ResourceList + // ResizeStatus stores status of resize operation. + // ResizeStatus is not set by default but when expansion is complete resizeStatus is set to empty + // string by resize controller or kubelet. + // This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature. + // +featureGate=RecoverVolumeExpansionFailure + // +optional + ResizeStatus *PersistentVolumeClaimResizeStatus } // PersistentVolumeAccessMode defines various access modes for PV. diff --git a/pkg/apis/core/v1/zz_generated.conversion.go b/pkg/apis/core/v1/zz_generated.conversion.go index 4bf16fe8c5ad..678ff54acdec 100644 --- a/pkg/apis/core/v1/zz_generated.conversion.go +++ b/pkg/apis/core/v1/zz_generated.conversion.go @@ -5171,6 +5171,8 @@ func autoConvert_v1_PersistentVolumeClaimStatus_To_core_PersistentVolumeClaimSta out.AccessModes = *(*[]core.PersistentVolumeAccessMode)(unsafe.Pointer(&in.AccessModes)) out.Capacity = *(*core.ResourceList)(unsafe.Pointer(&in.Capacity)) out.Conditions = *(*[]core.PersistentVolumeClaimCondition)(unsafe.Pointer(&in.Conditions)) + out.AllocatedResources = *(*core.ResourceList)(unsafe.Pointer(&in.AllocatedResources)) + out.ResizeStatus = (*core.PersistentVolumeClaimResizeStatus)(unsafe.Pointer(in.ResizeStatus)) return nil } @@ -5184,6 +5186,8 @@ func autoConvert_core_PersistentVolumeClaimStatus_To_v1_PersistentVolumeClaimSta out.AccessModes = *(*[]v1.PersistentVolumeAccessMode)(unsafe.Pointer(&in.AccessModes)) out.Capacity = *(*v1.ResourceList)(unsafe.Pointer(&in.Capacity)) out.Conditions = *(*[]v1.PersistentVolumeClaimCondition)(unsafe.Pointer(&in.Conditions)) + out.AllocatedResources = *(*v1.ResourceList)(unsafe.Pointer(&in.AllocatedResources)) + out.ResizeStatus = (*v1.PersistentVolumeClaimResizeStatus)(unsafe.Pointer(in.ResizeStatus)) return nil } diff --git a/pkg/apis/core/v1/zz_generated.defaults.go b/pkg/apis/core/v1/zz_generated.defaults.go index 3897ad2e5c34..d6ed8ada1467 100644 --- a/pkg/apis/core/v1/zz_generated.defaults.go +++ b/pkg/apis/core/v1/zz_generated.defaults.go @@ -155,6 +155,7 @@ func SetObjectDefaults_PersistentVolumeClaim(in *v1.PersistentVolumeClaim) { SetDefaults_ResourceList(&in.Spec.Resources.Limits) SetDefaults_ResourceList(&in.Spec.Resources.Requests) SetDefaults_ResourceList(&in.Status.Capacity) + SetDefaults_ResourceList(&in.Status.AllocatedResources) } func SetObjectDefaults_PersistentVolumeClaimList(in *v1.PersistentVolumeClaimList) { diff --git a/pkg/apis/core/validation/validation.go b/pkg/apis/core/validation/validation.go index 707674bd64ee..236550c0a34c 100644 --- a/pkg/apis/core/validation/validation.go +++ b/pkg/apis/core/validation/validation.go @@ -2020,20 +2020,26 @@ func ValidatePersistentVolumeStatusUpdate(newPv, oldPv *core.PersistentVolume) f return allErrs } -// PersistentVolumeClaimSpecValidationOptions contains the different settings for PersistentVolumeClaim validation type PersistentVolumeClaimSpecValidationOptions struct { // Allow spec to contain the "ReadWiteOncePod" access mode AllowReadWriteOncePod bool + // Allow pvc expansion after PVC is created and bound to a PV + EnableExpansion bool + // Allow users to recover from previously failing expansion operation + EnableRecoverFromExpansionFailure bool } func ValidationOptionsForPersistentVolumeClaim(pvc, oldPvc *core.PersistentVolumeClaim) PersistentVolumeClaimSpecValidationOptions { opts := PersistentVolumeClaimSpecValidationOptions{ - AllowReadWriteOncePod: utilfeature.DefaultFeatureGate.Enabled(features.ReadWriteOncePod), + AllowReadWriteOncePod: utilfeature.DefaultFeatureGate.Enabled(features.ReadWriteOncePod), + EnableExpansion: utilfeature.DefaultFeatureGate.Enabled(features.ExpandPersistentVolumes), + EnableRecoverFromExpansionFailure: utilfeature.DefaultFeatureGate.Enabled(features.RecoverVolumeExpansionFailure), } if oldPvc == nil { // If there's no old PVC, use the options based solely on feature enablement return opts } + if helper.ContainsAccessMode(oldPvc.Spec.AccessModes, core.ReadWriteOncePod) { // If the old object allowed "ReadWriteOncePod", continue to allow it in the new object opts.AllowReadWriteOncePod = true @@ -2173,7 +2179,7 @@ func ValidatePersistentVolumeClaimUpdate(newPvc, oldPvc *core.PersistentVolumeCl allErrs = append(allErrs, ValidateImmutableAnnotation(newPvc.ObjectMeta.Annotations[v1.BetaStorageClassAnnotation], oldPvc.ObjectMeta.Annotations[v1.BetaStorageClassAnnotation], v1.BetaStorageClassAnnotation, field.NewPath("metadata"))...) } - if utilfeature.DefaultFeatureGate.Enabled(features.ExpandPersistentVolumes) { + if opts.EnableExpansion { // lets make sure storage values are same. if newPvc.Status.Phase == core.ClaimBound && newPvcClone.Spec.Resources.Requests != nil { newPvcClone.Spec.Resources.Requests["storage"] = oldPvc.Spec.Resources.Requests["storage"] // +k8s:verify-mutation:reason=clone @@ -2181,13 +2187,23 @@ func ValidatePersistentVolumeClaimUpdate(newPvc, oldPvc *core.PersistentVolumeCl oldSize := oldPvc.Spec.Resources.Requests["storage"] newSize := newPvc.Spec.Resources.Requests["storage"] + statusSize := oldPvc.Status.Capacity["storage"] if !apiequality.Semantic.DeepEqual(newPvcClone.Spec, oldPvcClone.Spec) { specDiff := diff.ObjectDiff(newPvcClone.Spec, oldPvcClone.Spec) allErrs = append(allErrs, field.Forbidden(field.NewPath("spec"), fmt.Sprintf("spec is immutable after creation except resources.requests for bound claims\n%v", specDiff))) } if newSize.Cmp(oldSize) < 0 { - allErrs = append(allErrs, field.Forbidden(field.NewPath("spec", "resources", "requests", "storage"), "field can not be less than previous value")) + if !opts.EnableRecoverFromExpansionFailure { + allErrs = append(allErrs, field.Forbidden(field.NewPath("spec", "resources", "requests", "storage"), "field can not be less than previous value")) + } else { + // This validation permits reducing pvc requested size up to capacity recorded in pvc.status + // so that users can recover from volume expansion failure, but Kubernetes does not actually + // support volume shrinking + if newSize.Cmp(statusSize) <= 0 { + allErrs = append(allErrs, field.Forbidden(field.NewPath("spec", "resources", "requests", "storage"), "field can not be less than status.capacity")) + } + } } } else { @@ -2220,8 +2236,15 @@ func validateStorageClassUpgrade(oldAnnotations, newAnnotations map[string]strin (!newAnnotationExist || newScInAnnotation == oldSc) /* condition 4 */ } +var resizeStatusSet = sets.NewString(string(core.PersistentVolumeClaimNoExpansionInProgress), + string(core.PersistentVolumeClaimControllerExpansionInProgress), + string(core.PersistentVolumeClaimControllerExpansionFailed), + string(core.PersistentVolumeClaimNodeExpansionPending), + string(core.PersistentVolumeClaimNodeExpansionInProgress), + string(core.PersistentVolumeClaimNodeExpansionFailed)) + // ValidatePersistentVolumeClaimStatusUpdate validates an update to status of a PersistentVolumeClaim -func ValidatePersistentVolumeClaimStatusUpdate(newPvc, oldPvc *core.PersistentVolumeClaim) field.ErrorList { +func ValidatePersistentVolumeClaimStatusUpdate(newPvc, oldPvc *core.PersistentVolumeClaim, validationOpts PersistentVolumeClaimSpecValidationOptions) field.ErrorList { allErrs := ValidateObjectMetaUpdate(&newPvc.ObjectMeta, &oldPvc.ObjectMeta, field.NewPath("metadata")) if len(newPvc.ResourceVersion) == 0 { allErrs = append(allErrs, field.Required(field.NewPath("resourceVersion"), "")) @@ -2229,10 +2252,32 @@ func ValidatePersistentVolumeClaimStatusUpdate(newPvc, oldPvc *core.PersistentVo if len(newPvc.Spec.AccessModes) == 0 { allErrs = append(allErrs, field.Required(field.NewPath("Spec", "accessModes"), "")) } + capPath := field.NewPath("status", "capacity") for r, qty := range newPvc.Status.Capacity { allErrs = append(allErrs, validateBasicResource(qty, capPath.Key(string(r)))...) } + if validationOpts.EnableRecoverFromExpansionFailure { + resizeStatusPath := field.NewPath("status", "resizeStatus") + if newPvc.Status.ResizeStatus != nil { + resizeStatus := *newPvc.Status.ResizeStatus + if !resizeStatusSet.Has(string(resizeStatus)) { + allErrs = append(allErrs, field.NotSupported(resizeStatusPath, resizeStatus, resizeStatusSet.List())) + } + } + allocPath := field.NewPath("status", "allocatedResources") + for r, qty := range newPvc.Status.AllocatedResources { + if r != core.ResourceStorage { + allErrs = append(allErrs, field.NotSupported(allocPath, r, []string{string(core.ResourceStorage)})) + continue + } + if errs := validateBasicResource(qty, allocPath.Key(string(r))); len(errs) > 0 { + allErrs = append(allErrs, errs...) + } else { + allErrs = append(allErrs, ValidateResourceQuantityValue(string(core.ResourceStorage), qty, allocPath.Key(string(r)))...) + } + } + } return allErrs } diff --git a/pkg/apis/core/validation/validation_test.go b/pkg/apis/core/validation/validation_test.go index a128cedb67ce..9b81c9b31528 100644 --- a/pkg/apis/core/validation/validation_test.go +++ b/pkg/apis/core/validation/validation_test.go @@ -1862,12 +1862,97 @@ func TestValidatePersistentVolumeClaimUpdate(t *testing.T) { }, VolumeName: "volume", }) + validClaimShrinkInitial := testVolumeClaimWithStatus("foo", "ns", core.PersistentVolumeClaimSpec{ + AccessModes: []core.PersistentVolumeAccessMode{ + core.ReadWriteOnce, + core.ReadOnlyMany, + }, + Resources: core.ResourceRequirements{ + Requests: core.ResourceList{ + core.ResourceName(core.ResourceStorage): resource.MustParse("15G"), + }, + }, + }, core.PersistentVolumeClaimStatus{ + Phase: core.ClaimBound, + Capacity: core.ResourceList{ + core.ResourceStorage: resource.MustParse("10G"), + }, + }) + + unboundShrink := testVolumeClaimWithStatus("foo", "ns", core.PersistentVolumeClaimSpec{ + AccessModes: []core.PersistentVolumeAccessMode{ + core.ReadWriteOnce, + core.ReadOnlyMany, + }, + Resources: core.ResourceRequirements{ + Requests: core.ResourceList{ + core.ResourceName(core.ResourceStorage): resource.MustParse("12G"), + }, + }, + }, core.PersistentVolumeClaimStatus{ + Phase: core.ClaimPending, + Capacity: core.ResourceList{ + core.ResourceStorage: resource.MustParse("10G"), + }, + }) + + validClaimShrink := testVolumeClaimWithStatus("foo", "ns", core.PersistentVolumeClaimSpec{ + AccessModes: []core.PersistentVolumeAccessMode{ + core.ReadWriteOnce, + core.ReadOnlyMany, + }, + Resources: core.ResourceRequirements{ + Requests: core.ResourceList{ + core.ResourceStorage: resource.MustParse("13G"), + }, + }, + }, core.PersistentVolumeClaimStatus{ + Phase: core.ClaimBound, + Capacity: core.ResourceList{ + core.ResourceStorage: resource.MustParse("10G"), + }, + }) + + invalidShrinkToStatus := testVolumeClaimWithStatus("foo", "ns", core.PersistentVolumeClaimSpec{ + AccessModes: []core.PersistentVolumeAccessMode{ + core.ReadWriteOnce, + core.ReadOnlyMany, + }, + Resources: core.ResourceRequirements{ + Requests: core.ResourceList{ + core.ResourceStorage: resource.MustParse("10G"), + }, + }, + }, core.PersistentVolumeClaimStatus{ + Phase: core.ClaimBound, + Capacity: core.ResourceList{ + core.ResourceStorage: resource.MustParse("10G"), + }, + }) + + invalidClaimShrink := testVolumeClaimWithStatus("foo", "ns", core.PersistentVolumeClaimSpec{ + AccessModes: []core.PersistentVolumeAccessMode{ + core.ReadWriteOnce, + core.ReadOnlyMany, + }, + Resources: core.ResourceRequirements{ + Requests: core.ResourceList{ + core.ResourceStorage: resource.MustParse("3G"), + }, + }, + }, core.PersistentVolumeClaimStatus{ + Phase: core.ClaimBound, + Capacity: core.ResourceList{ + core.ResourceStorage: resource.MustParse("10G"), + }, + }) scenarios := map[string]struct { - isExpectedFailure bool - oldClaim *core.PersistentVolumeClaim - newClaim *core.PersistentVolumeClaim - enableResize bool + isExpectedFailure bool + oldClaim *core.PersistentVolumeClaim + newClaim *core.PersistentVolumeClaim + enableResize bool + enableRecoverFromExpansion bool }{ "valid-update-volumeName-only": { isExpectedFailure: false, @@ -2037,12 +2122,53 @@ func TestValidatePersistentVolumeClaimUpdate(t *testing.T) { newClaim: validClaimRWOPAccessModeAddAnnotation, enableResize: false, }, + "valid-expand-shrink-resize-enabled": { + oldClaim: validClaimShrinkInitial, + newClaim: validClaimShrink, + enableResize: true, + enableRecoverFromExpansion: true, + }, + "invalid-expand-shrink-resize-enabled": { + oldClaim: validClaimShrinkInitial, + newClaim: invalidClaimShrink, + enableResize: true, + enableRecoverFromExpansion: true, + isExpectedFailure: true, + }, + "invalid-expand-shrink-to-status-resize-enabled": { + oldClaim: validClaimShrinkInitial, + newClaim: invalidShrinkToStatus, + enableResize: true, + enableRecoverFromExpansion: true, + isExpectedFailure: true, + }, + "invalid-expand-shrink-recover-disabled": { + oldClaim: validClaimShrinkInitial, + newClaim: validClaimShrink, + enableResize: true, + enableRecoverFromExpansion: false, + isExpectedFailure: true, + }, + "invalid-expand-shrink-resize-disabled": { + oldClaim: validClaimShrinkInitial, + newClaim: validClaimShrink, + enableResize: false, + enableRecoverFromExpansion: true, + isExpectedFailure: true, + }, + "unbound-size-shrink-resize-enabled": { + oldClaim: validClaimShrinkInitial, + newClaim: unboundShrink, + enableResize: true, + enableRecoverFromExpansion: true, + isExpectedFailure: true, + }, } for name, scenario := range scenarios { t.Run(name, func(t *testing.T) { - // ensure we have a resource version specified for updates defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.ExpandPersistentVolumes, scenario.enableResize)() + defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.RecoverVolumeExpansionFailure, scenario.enableRecoverFromExpansion)() scenario.oldClaim.ResourceVersion = "1" scenario.newClaim.ResourceVersion = "1" opts := ValidationOptionsForPersistentVolumeClaim(scenario.newClaim, scenario.oldClaim) @@ -2067,35 +2193,45 @@ func TestValidationOptionsForPersistentVolumeClaim(t *testing.T) { oldPvc: nil, enableReadWriteOncePod: true, expectValidationOpts: PersistentVolumeClaimSpecValidationOptions{ - AllowReadWriteOncePod: true, + AllowReadWriteOncePod: true, + EnableExpansion: true, + EnableRecoverFromExpansionFailure: false, }, }, "rwop allowed because feature enabled": { oldPvc: pvcWithAccessModes([]core.PersistentVolumeAccessMode{core.ReadWriteOnce}), enableReadWriteOncePod: true, expectValidationOpts: PersistentVolumeClaimSpecValidationOptions{ - AllowReadWriteOncePod: true, + AllowReadWriteOncePod: true, + EnableExpansion: true, + EnableRecoverFromExpansionFailure: false, }, }, "rwop not allowed because not used and feature disabled": { oldPvc: pvcWithAccessModes([]core.PersistentVolumeAccessMode{core.ReadWriteOnce}), enableReadWriteOncePod: false, expectValidationOpts: PersistentVolumeClaimSpecValidationOptions{ - AllowReadWriteOncePod: false, + AllowReadWriteOncePod: false, + EnableExpansion: true, + EnableRecoverFromExpansionFailure: false, }, }, "rwop allowed because used and feature enabled": { oldPvc: pvcWithAccessModes([]core.PersistentVolumeAccessMode{core.ReadWriteOncePod}), enableReadWriteOncePod: true, expectValidationOpts: PersistentVolumeClaimSpecValidationOptions{ - AllowReadWriteOncePod: true, + AllowReadWriteOncePod: true, + EnableExpansion: true, + EnableRecoverFromExpansionFailure: false, }, }, "rwop allowed because used and feature disabled": { oldPvc: pvcWithAccessModes([]core.PersistentVolumeAccessMode{core.ReadWriteOncePod}), enableReadWriteOncePod: false, expectValidationOpts: PersistentVolumeClaimSpecValidationOptions{ - AllowReadWriteOncePod: true, + AllowReadWriteOncePod: true, + EnableExpansion: true, + EnableRecoverFromExpansionFailure: false, }, }, } @@ -15771,11 +15907,86 @@ func TestValidatePersistentVolumeClaimStatusUpdate(t *testing.T) { {Type: core.PersistentVolumeClaimResizing, Status: core.ConditionTrue}, }, }) + validAllocatedResources := testVolumeClaimWithStatus("foo", "ns", core.PersistentVolumeClaimSpec{ + AccessModes: []core.PersistentVolumeAccessMode{ + core.ReadWriteOnce, + core.ReadOnlyMany, + }, + Resources: core.ResourceRequirements{ + Requests: core.ResourceList{ + core.ResourceName(core.ResourceStorage): resource.MustParse("10G"), + }, + }, + }, core.PersistentVolumeClaimStatus{ + Phase: core.ClaimPending, + Conditions: []core.PersistentVolumeClaimCondition{ + {Type: core.PersistentVolumeClaimResizing, Status: core.ConditionTrue}, + }, + AllocatedResources: core.ResourceList{ + core.ResourceName(core.ResourceStorage): resource.MustParse("10G"), + }, + }) + + invalidAllocatedResources := testVolumeClaimWithStatus("foo", "ns", core.PersistentVolumeClaimSpec{ + AccessModes: []core.PersistentVolumeAccessMode{ + core.ReadWriteOnce, + core.ReadOnlyMany, + }, + Resources: core.ResourceRequirements{ + Requests: core.ResourceList{ + core.ResourceName(core.ResourceStorage): resource.MustParse("10G"), + }, + }, + }, core.PersistentVolumeClaimStatus{ + Phase: core.ClaimPending, + Conditions: []core.PersistentVolumeClaimCondition{ + {Type: core.PersistentVolumeClaimResizing, Status: core.ConditionTrue}, + }, + AllocatedResources: core.ResourceList{ + core.ResourceName(core.ResourceStorage): resource.MustParse("-10G"), + }, + }) + + noStoraegeClaimStatus := testVolumeClaimWithStatus("foo", "ns", core.PersistentVolumeClaimSpec{ + AccessModes: []core.PersistentVolumeAccessMode{ + core.ReadWriteOnce, + }, + Resources: core.ResourceRequirements{ + Requests: core.ResourceList{ + core.ResourceName(core.ResourceStorage): resource.MustParse("10G"), + }, + }, + }, core.PersistentVolumeClaimStatus{ + Phase: core.ClaimPending, + AllocatedResources: core.ResourceList{ + core.ResourceName(core.ResourceCPU): resource.MustParse("10G"), + }, + }) + progressResizeStatus := core.PersistentVolumeClaimControllerExpansionInProgress + invalidResizeStatus := core.PersistentVolumeClaimResizeStatus("foo") + + validResizeStatusPVC := testVolumeClaimWithStatus("foo", "ns", core.PersistentVolumeClaimSpec{ + AccessModes: []core.PersistentVolumeAccessMode{ + core.ReadWriteOnce, + }, + }, core.PersistentVolumeClaimStatus{ + ResizeStatus: &progressResizeStatus, + }) + + invalidResizeStatusPVC := testVolumeClaimWithStatus("foo", "ns", core.PersistentVolumeClaimSpec{ + AccessModes: []core.PersistentVolumeAccessMode{ + core.ReadWriteOnce, + }, + }, core.PersistentVolumeClaimStatus{ + ResizeStatus: &invalidResizeStatus, + }) + scenarios := map[string]struct { - isExpectedFailure bool - oldClaim *core.PersistentVolumeClaim - newClaim *core.PersistentVolumeClaim - enableResize bool + isExpectedFailure bool + oldClaim *core.PersistentVolumeClaim + newClaim *core.PersistentVolumeClaim + enableResize bool + enableRecoverFromExpansion bool }{ "condition-update-with-enabled-feature-gate": { isExpectedFailure: false, @@ -15783,13 +15994,51 @@ func TestValidatePersistentVolumeClaimStatusUpdate(t *testing.T) { newClaim: validConditionUpdate, enableResize: true, }, + "status-update-with-valid-allocatedResources-feature-enabled": { + isExpectedFailure: false, + oldClaim: validClaim, + newClaim: validAllocatedResources, + enableResize: true, + enableRecoverFromExpansion: true, + }, + "status-update-with-invalid-allocatedResources-feature-enabled": { + isExpectedFailure: true, + oldClaim: validClaim, + newClaim: invalidAllocatedResources, + enableResize: true, + enableRecoverFromExpansion: true, + }, + "status-update-with-no-storage-update": { + isExpectedFailure: true, + oldClaim: validClaim, + newClaim: noStoraegeClaimStatus, + enableResize: true, + enableRecoverFromExpansion: true, + }, + "status-update-with-valid-pvc-resize-status": { + isExpectedFailure: false, + oldClaim: validClaim, + newClaim: validResizeStatusPVC, + enableResize: true, + enableRecoverFromExpansion: true, + }, + "status-update-with-invalid-pvc-resize-status": { + isExpectedFailure: true, + oldClaim: validClaim, + newClaim: invalidResizeStatusPVC, + enableResize: true, + enableRecoverFromExpansion: true, + }, } for name, scenario := range scenarios { t.Run(name, func(t *testing.T) { + validateOpts := PersistentVolumeClaimSpecValidationOptions{ + EnableRecoverFromExpansionFailure: scenario.enableRecoverFromExpansion, + } // ensure we have a resource version specified for updates scenario.oldClaim.ResourceVersion = "1" scenario.newClaim.ResourceVersion = "1" - errs := ValidatePersistentVolumeClaimStatusUpdate(scenario.newClaim, scenario.oldClaim) + errs := ValidatePersistentVolumeClaimStatusUpdate(scenario.newClaim, scenario.oldClaim, validateOpts) if len(errs) == 0 && scenario.isExpectedFailure { t.Errorf("Unexpected success for scenario: %s", name) } diff --git a/pkg/apis/core/zz_generated.deepcopy.go b/pkg/apis/core/zz_generated.deepcopy.go index 6c6112c0cd94..1114461f6dd9 100644 --- a/pkg/apis/core/zz_generated.deepcopy.go +++ b/pkg/apis/core/zz_generated.deepcopy.go @@ -2977,6 +2977,18 @@ func (in *PersistentVolumeClaimStatus) DeepCopyInto(out *PersistentVolumeClaimSt (*in)[i].DeepCopyInto(&(*out)[i]) } } + if in.AllocatedResources != nil { + in, out := &in.AllocatedResources, &out.AllocatedResources + *out = make(ResourceList, len(*in)) + for key, val := range *in { + (*out)[key] = val.DeepCopy() + } + } + if in.ResizeStatus != nil { + in, out := &in.ResizeStatus, &out.ResizeStatus + *out = new(PersistentVolumeClaimResizeStatus) + **out = **in + } return } diff --git a/pkg/controller/resourcequota/resource_quota_monitor.go b/pkg/controller/resourcequota/resource_quota_monitor.go index 1c5c15aab027..c42940b1c88f 100644 --- a/pkg/controller/resourcequota/resource_quota_monitor.go +++ b/pkg/controller/resourcequota/resource_quota_monitor.go @@ -23,7 +23,7 @@ import ( "k8s.io/klog/v2" - "k8s.io/api/core/v1" + v1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/api/meta" "k8s.io/apimachinery/pkg/runtime/schema" utilerrors "k8s.io/apimachinery/pkg/util/errors" @@ -148,6 +148,10 @@ func (qm *QuotaMonitor) controllerFor(resource schema.GroupVersionResource) (cac oldService := oldObj.(*v1.Service) newService := newObj.(*v1.Service) notifyUpdate = core.GetQuotaServiceType(oldService) != core.GetQuotaServiceType(newService) + case schema.GroupResource{Resource: "persistentvolumeclaims"}: + oldPVC := oldObj.(*v1.PersistentVolumeClaim) + newPVC := newObj.(*v1.PersistentVolumeClaim) + notifyUpdate = core.RequiresQuotaReplenish(newPVC, oldPVC) } if notifyUpdate { event := &event{ diff --git a/pkg/controller/volume/expand/expand_controller.go b/pkg/controller/volume/expand/expand_controller.go index b99e8b93d750..1d9bbde29f12 100644 --- a/pkg/controller/volume/expand/expand_controller.go +++ b/pkg/controller/volume/expand/expand_controller.go @@ -33,6 +33,7 @@ import ( "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/runtime" "k8s.io/apimachinery/pkg/util/wait" + utilfeature "k8s.io/apiserver/pkg/util/feature" coreinformers "k8s.io/client-go/informers/core/v1" clientset "k8s.io/client-go/kubernetes" "k8s.io/client-go/kubernetes/scheme" @@ -44,12 +45,14 @@ import ( "k8s.io/client-go/util/workqueue" cloudprovider "k8s.io/cloud-provider" "k8s.io/kubernetes/pkg/controller/volume/events" + "k8s.io/kubernetes/pkg/features" proxyutil "k8s.io/kubernetes/pkg/proxy/util" "k8s.io/kubernetes/pkg/volume" "k8s.io/kubernetes/pkg/volume/csimigration" "k8s.io/kubernetes/pkg/volume/util" "k8s.io/kubernetes/pkg/volume/util/operationexecutor" "k8s.io/kubernetes/pkg/volume/util/subpath" + volumetypes "k8s.io/kubernetes/pkg/volume/util/types" "k8s.io/kubernetes/pkg/volume/util/volumepathhandler" ) @@ -302,19 +305,31 @@ func (expc *expandController) expand(pvc *v1.PersistentVolumeClaim, pv *v1.Persi return util.DeleteAnnPreResizeCapacity(pv, expc.GetKubeClient()) } - pvc, err := util.MarkResizeInProgressWithResizer(pvc, resizerName, expc.kubeClient) - if err != nil { - klog.V(5).Infof("Error setting PVC %s in progress with error : %v", util.GetPersistentVolumeClaimQualifiedName(pvc), err) - return err - } + var generatedOptions volumetypes.GeneratedOperations + var err error - generatedOperations, err := expc.operationGenerator.GenerateExpandVolumeFunc(pvc, pv) - if err != nil { - klog.Errorf("Error starting ExpandVolume for pvc %s with %v", util.GetPersistentVolumeClaimQualifiedName(pvc), err) - return err + if utilfeature.DefaultFeatureGate.Enabled(features.RecoverVolumeExpansionFailure) { + generatedOptions, err = expc.operationGenerator.GenerateExpandAndRecoverVolumeFunc(pvc, pv, resizerName) + if err != nil { + klog.Errorf("Error starting ExpandVolume for pvc %s with %v", util.GetPersistentVolumeClaimQualifiedName(pvc), err) + return err + } + } else { + pvc, err := util.MarkResizeInProgressWithResizer(pvc, resizerName, expc.kubeClient) + if err != nil { + klog.Errorf("Error setting PVC %s in progress with error : %v", util.GetPersistentVolumeClaimQualifiedName(pvc), err) + return err + } + + generatedOptions, err = expc.operationGenerator.GenerateExpandVolumeFunc(pvc, pv) + if err != nil { + klog.Errorf("Error starting ExpandVolume for pvc %s with %v", util.GetPersistentVolumeClaimQualifiedName(pvc), err) + return err + } } + klog.V(5).Infof("Starting ExpandVolume for volume %s", util.GetPersistentVolumeClaimQualifiedName(pvc)) - _, detailedErr := generatedOperations.Run() + _, detailedErr := generatedOptions.Run() return detailedErr } @@ -357,8 +372,15 @@ func (expc *expandController) getPersistentVolume(ctx context.Context, pvc *v1.P // isNodeExpandComplete returns true if pvc.Status.Capacity >= pv.Spec.Capacity func (expc *expandController) isNodeExpandComplete(pvc *v1.PersistentVolumeClaim, pv *v1.PersistentVolume) bool { klog.V(4).Infof("pv %q capacity = %v, pvc %s capacity = %v", pv.Name, pv.Spec.Capacity[v1.ResourceStorage], pvc.ObjectMeta.Name, pvc.Status.Capacity[v1.ResourceStorage]) - pvcCap, pvCap := pvc.Status.Capacity[v1.ResourceStorage], pv.Spec.Capacity[v1.ResourceStorage] - return pvcCap.Cmp(pvCap) >= 0 + pvcSpecCap := pvc.Spec.Resources.Requests.Storage() + pvcStatusCap, pvCap := pvc.Status.Capacity[v1.ResourceStorage], pv.Spec.Capacity[v1.ResourceStorage] + + // since we allow shrinking volumes, we must compare both pvc status and capacity + // with pv spec capacity. + if pvcStatusCap.Cmp(*pvcSpecCap) >= 0 && pvcStatusCap.Cmp(pvCap) >= 0 { + return true + } + return false } // Implementing VolumeHost interface diff --git a/pkg/features/kube_features.go b/pkg/features/kube_features.go index 2c6f6571532e..8fa796e1448c 100644 --- a/pkg/features/kube_features.go +++ b/pkg/features/kube_features.go @@ -816,6 +816,13 @@ const ( // Honor Persistent Volume Reclaim Policy when it is "Delete" irrespective of PV-PVC // deletion ordering. HonorPVReclaimPolicy featuregate.Feature = "HonorPVReclaimPolicy" + + // owner: @gnufied + // kep: http://kep.k8s.io/1790 + // alpha: v1.23 + // + // Allow users to recover from volume expansion failure + RecoverVolumeExpansionFailure featuregate.Feature = "RecoverVolumeExpansionFailure" ) func init() { @@ -935,6 +942,7 @@ var defaultKubernetesFeatureGates = map[featuregate.Feature]featuregate.FeatureS IdentifyPodOS: {Default: false, PreRelease: featuregate.Alpha}, PodAndContainerStatsFromCRI: {Default: false, PreRelease: featuregate.Alpha}, HonorPVReclaimPolicy: {Default: false, PreRelease: featuregate.Alpha}, + RecoverVolumeExpansionFailure: {Default: false, PreRelease: featuregate.Alpha}, // inherited features from generic apiserver, relisted here to get a conflict if it is changed // unintentionally on either side: diff --git a/pkg/quota/v1/evaluator/core/persistent_volume_claims.go b/pkg/quota/v1/evaluator/core/persistent_volume_claims.go index 879c6c75566b..cbeb373fd02d 100644 --- a/pkg/quota/v1/evaluator/core/persistent_volume_claims.go +++ b/pkg/quota/v1/evaluator/core/persistent_volume_claims.go @@ -159,23 +159,48 @@ func (p *pvcEvaluator) Usage(item runtime.Object) (corev1.ResourceList, error) { result[storageClassClaim] = *(resource.NewQuantity(1, resource.DecimalSI)) } - // charge for storage - if request, found := pvc.Spec.Resources.Requests[corev1.ResourceStorage]; found { - roundedRequest := request.DeepCopy() + requestedStorage := p.getStorageUsage(pvc) + if requestedStorage != nil { + result[corev1.ResourceRequestsStorage] = *requestedStorage + // charge usage to the storage class (if present) + if len(storageClassRef) > 0 { + storageClassStorage := corev1.ResourceName(storageClassRef + storageClassSuffix + string(corev1.ResourceRequestsStorage)) + result[storageClassStorage] = *requestedStorage + } + } + + return result, nil +} + +func (p *pvcEvaluator) getStorageUsage(pvc *corev1.PersistentVolumeClaim) *resource.Quantity { + var result *resource.Quantity + roundUpFunc := func(i *resource.Quantity) *resource.Quantity { + roundedRequest := i.DeepCopy() if !roundedRequest.RoundUp(0) { // Ensure storage requests are counted as whole byte values, to pass resourcequota validation. // See http://issue.k8s.io/94313 - request = roundedRequest + return &roundedRequest } + return i + } - result[corev1.ResourceRequestsStorage] = request - // charge usage to the storage class (if present) - if len(storageClassRef) > 0 { - storageClassStorage := corev1.ResourceName(storageClassRef + storageClassSuffix + string(corev1.ResourceRequestsStorage)) - result[storageClassStorage] = request + if userRequest, ok := pvc.Spec.Resources.Requests[corev1.ResourceStorage]; ok { + result = roundUpFunc(&userRequest) + } + + if utilfeature.DefaultFeatureGate.Enabled(k8sfeatures.RecoverVolumeExpansionFailure) && result != nil { + if len(pvc.Status.AllocatedResources) == 0 { + return result + } + + // if AllocatedResources is set and is greater than user request, we should use it. + if allocatedRequest, ok := pvc.Status.AllocatedResources[corev1.ResourceStorage]; ok { + if allocatedRequest.Cmp(*result) > 0 { + result = roundUpFunc(&allocatedRequest) + } } } - return result, nil + return result } // UsageStats calculates aggregate usage for the object. @@ -200,3 +225,13 @@ func toExternalPersistentVolumeClaimOrError(obj runtime.Object) (*corev1.Persist } return pvc, nil } + +// RequiresQuotaReplenish enables quota monitoring for PVCs. +func RequiresQuotaReplenish(pvc, oldPVC *corev1.PersistentVolumeClaim) bool { + if utilfeature.DefaultFeatureGate.Enabled(k8sfeatures.RecoverVolumeExpansionFailure) { + if oldPVC.Status.AllocatedResources.Storage() != pvc.Status.AllocatedResources.Storage() { + return true + } + } + return false +} diff --git a/pkg/quota/v1/evaluator/core/persistent_volume_claims_test.go b/pkg/quota/v1/evaluator/core/persistent_volume_claims_test.go index 244af6059216..57a931244dfd 100644 --- a/pkg/quota/v1/evaluator/core/persistent_volume_claims_test.go +++ b/pkg/quota/v1/evaluator/core/persistent_volume_claims_test.go @@ -25,7 +25,11 @@ import ( "k8s.io/apimachinery/pkg/runtime/schema" quota "k8s.io/apiserver/pkg/quota/v1" "k8s.io/apiserver/pkg/quota/v1/generic" + utilfeature "k8s.io/apiserver/pkg/util/feature" + featuregatetesting "k8s.io/component-base/featuregate/testing" + "k8s.io/kubernetes/pkg/apis/core" api "k8s.io/kubernetes/pkg/apis/core" + "k8s.io/kubernetes/pkg/features" ) func testVolumeClaim(name string, namespace string, spec api.PersistentVolumeClaimSpec) *api.PersistentVolumeClaim { @@ -85,8 +89,9 @@ func TestPersistentVolumeClaimEvaluatorUsage(t *testing.T) { evaluator := NewPersistentVolumeClaimEvaluator(nil) testCases := map[string]struct { - pvc *api.PersistentVolumeClaim - usage corev1.ResourceList + pvc *api.PersistentVolumeClaim + usage corev1.ResourceList + enableRecoverFromExpansion bool }{ "pvc-usage": { pvc: validClaim, @@ -95,6 +100,7 @@ func TestPersistentVolumeClaimEvaluatorUsage(t *testing.T) { corev1.ResourcePersistentVolumeClaims: resource.MustParse("1"), generic.ObjectCountQuotaResourceNameFor(schema.GroupResource{Resource: "persistentvolumeclaims"}): resource.MustParse("1"), }, + enableRecoverFromExpansion: true, }, "pvc-usage-by-class": { pvc: validClaimByStorageClass, @@ -105,6 +111,7 @@ func TestPersistentVolumeClaimEvaluatorUsage(t *testing.T) { V1ResourceByStorageClass(classGold, corev1.ResourcePersistentVolumeClaims): resource.MustParse("1"), generic.ObjectCountQuotaResourceNameFor(schema.GroupResource{Resource: "persistentvolumeclaims"}): resource.MustParse("1"), }, + enableRecoverFromExpansion: true, }, "pvc-usage-rounded": { @@ -114,6 +121,7 @@ func TestPersistentVolumeClaimEvaluatorUsage(t *testing.T) { corev1.ResourcePersistentVolumeClaims: resource.MustParse("1"), generic.ObjectCountQuotaResourceNameFor(schema.GroupResource{Resource: "persistentvolumeclaims"}): resource.MustParse("1"), }, + enableRecoverFromExpansion: true, }, "pvc-usage-by-class-rounded": { pvc: validClaimByStorageClassWithNonIntegerStorage, @@ -124,15 +132,52 @@ func TestPersistentVolumeClaimEvaluatorUsage(t *testing.T) { V1ResourceByStorageClass(classGold, corev1.ResourcePersistentVolumeClaims): resource.MustParse("1"), generic.ObjectCountQuotaResourceNameFor(schema.GroupResource{Resource: "persistentvolumeclaims"}): resource.MustParse("1"), }, + enableRecoverFromExpansion: true, + }, + "pvc-usage-higher-allocated-resource": { + pvc: getPVCWithAllocatedResource("5G", "10G"), + usage: corev1.ResourceList{ + corev1.ResourceRequestsStorage: resource.MustParse("10G"), + corev1.ResourcePersistentVolumeClaims: resource.MustParse("1"), + generic.ObjectCountQuotaResourceNameFor(schema.GroupResource{Resource: "persistentvolumeclaims"}): resource.MustParse("1"), + }, + enableRecoverFromExpansion: true, + }, + "pvc-usage-lower-allocated-resource": { + pvc: getPVCWithAllocatedResource("10G", "5G"), + usage: corev1.ResourceList{ + corev1.ResourceRequestsStorage: resource.MustParse("10G"), + corev1.ResourcePersistentVolumeClaims: resource.MustParse("1"), + generic.ObjectCountQuotaResourceNameFor(schema.GroupResource{Resource: "persistentvolumeclaims"}): resource.MustParse("1"), + }, + enableRecoverFromExpansion: true, }, } for testName, testCase := range testCases { - actual, err := evaluator.Usage(testCase.pvc) - if err != nil { - t.Errorf("%s unexpected error: %v", testName, err) - } - if !quota.Equals(testCase.usage, actual) { - t.Errorf("%s expected:\n%v\n, actual:\n%v", testName, testCase.usage, actual) - } + t.Run(testName, func(t *testing.T) { + defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.RecoverVolumeExpansionFailure, testCase.enableRecoverFromExpansion)() + actual, err := evaluator.Usage(testCase.pvc) + if err != nil { + t.Errorf("%s unexpected error: %v", testName, err) + } + if !quota.Equals(testCase.usage, actual) { + t.Errorf("%s expected:\n%v\n, actual:\n%v", testName, testCase.usage, actual) + } + }) + + } +} + +func getPVCWithAllocatedResource(pvcSize, allocatedSize string) *api.PersistentVolumeClaim { + validPVCWithAllocatedResources := testVolumeClaim("foo", "ns", api.PersistentVolumeClaimSpec{ + Resources: api.ResourceRequirements{ + Requests: api.ResourceList{ + core.ResourceStorage: resource.MustParse(pvcSize), + }, + }, + }) + validPVCWithAllocatedResources.Status.AllocatedResources = api.ResourceList{ + api.ResourceName(api.ResourceStorage): resource.MustParse(allocatedSize), } + return validPVCWithAllocatedResources } diff --git a/pkg/registry/core/persistentvolumeclaim/strategy.go b/pkg/registry/core/persistentvolumeclaim/strategy.go index b9e975794b8e..afb78a68b8ce 100644 --- a/pkg/registry/core/persistentvolumeclaim/strategy.go +++ b/pkg/registry/core/persistentvolumeclaim/strategy.go @@ -27,12 +27,10 @@ import ( "k8s.io/apiserver/pkg/registry/generic" "k8s.io/apiserver/pkg/storage" "k8s.io/apiserver/pkg/storage/names" - utilfeature "k8s.io/apiserver/pkg/util/feature" "k8s.io/kubernetes/pkg/api/legacyscheme" pvcutil "k8s.io/kubernetes/pkg/api/persistentvolumeclaim" api "k8s.io/kubernetes/pkg/apis/core" "k8s.io/kubernetes/pkg/apis/core/validation" - "k8s.io/kubernetes/pkg/features" "sigs.k8s.io/structured-merge-diff/v4/fieldpath" ) @@ -66,7 +64,6 @@ func (persistentvolumeclaimStrategy) GetResetFields() map[fieldpath.APIVersion]* func (persistentvolumeclaimStrategy) PrepareForCreate(ctx context.Context, obj runtime.Object) { pvc := obj.(*api.PersistentVolumeClaim) pvc.Status = api.PersistentVolumeClaimStatus{} - pvcutil.DropDisabledFields(&pvc.Spec) // For data sources, we need to do 2 things to implement KEP 1495 @@ -153,16 +150,17 @@ func (persistentvolumeclaimStatusStrategy) GetResetFields() map[fieldpath.APIVer // PrepareForUpdate sets the Spec field which is not allowed to be changed when updating a PV's Status func (persistentvolumeclaimStatusStrategy) PrepareForUpdate(ctx context.Context, obj, old runtime.Object) { - newPv := obj.(*api.PersistentVolumeClaim) - oldPv := old.(*api.PersistentVolumeClaim) - newPv.Spec = oldPv.Spec - if !utilfeature.DefaultFeatureGate.Enabled(features.ExpandPersistentVolumes) && oldPv.Status.Conditions == nil { - newPv.Status.Conditions = nil - } + newPVC := obj.(*api.PersistentVolumeClaim) + oldPVC := old.(*api.PersistentVolumeClaim) + newPVC.Spec = oldPVC.Spec + pvcutil.DropDisabledFieldsFromStatus(newPVC, oldPVC) } func (persistentvolumeclaimStatusStrategy) ValidateUpdate(ctx context.Context, obj, old runtime.Object) field.ErrorList { - return validation.ValidatePersistentVolumeClaimStatusUpdate(obj.(*api.PersistentVolumeClaim), old.(*api.PersistentVolumeClaim)) + newPvc := obj.(*api.PersistentVolumeClaim) + oldPvc := old.(*api.PersistentVolumeClaim) + opts := validation.ValidationOptionsForPersistentVolumeClaim(newPvc, oldPvc) + return validation.ValidatePersistentVolumeClaimStatusUpdate(newPvc, oldPvc, opts) } // WarningsOnUpdate returns warnings for the given update. diff --git a/pkg/volume/csi/csi_client.go b/pkg/volume/csi/csi_client.go index cf4ba7a0d488..b5e0ff718d4a 100644 --- a/pkg/volume/csi/csi_client.go +++ b/pkg/volume/csi/csi_client.go @@ -347,8 +347,12 @@ func (c *csiDriverClient) NodeExpandVolume(ctx context.Context, opts csiResizeOp resp, err := nodeClient.NodeExpandVolume(ctx, req) if err != nil { + if !isFinalError(err) { + return opts.newSize, volumetypes.NewUncertainProgressError(err.Error()) + } return opts.newSize, err } + updatedQuantity := resource.NewQuantity(resp.CapacityBytes, resource.BinarySI) return *updatedQuantity, nil } diff --git a/pkg/volume/testing/testing.go b/pkg/volume/testing/testing.go index 55352fa9c748..b70d23ac6dd0 100644 --- a/pkg/volume/testing/testing.go +++ b/pkg/volume/testing/testing.go @@ -85,6 +85,8 @@ const ( FailVolumeExpansion = "fail-expansion-test" + AlwaysFailNodeExpansion = "always-fail-node-expansion" + deviceNotMounted = "deviceNotMounted" deviceMountUncertain = "deviceMountUncertain" deviceMounted = "deviceMounted" @@ -178,6 +180,7 @@ type FakeVolumePlugin struct { LimitKey string ProvisionDelaySeconds int SupportsRemount bool + DisableNodeExpansion bool // default to false which means it is attachable by default NonAttachable bool @@ -464,13 +467,17 @@ func (plugin *FakeVolumePlugin) ExpandVolumeDevice(spec *Spec, newSize resource. } func (plugin *FakeVolumePlugin) RequiresFSResize() bool { - return true + return !plugin.DisableNodeExpansion } func (plugin *FakeVolumePlugin) NodeExpand(resizeOptions NodeResizeOptions) (bool, error) { if resizeOptions.VolumeSpec.Name() == FailWithInUseVolumeName { return false, volumetypes.NewFailedPreconditionError("volume-in-use") } + if resizeOptions.VolumeSpec.Name() == AlwaysFailNodeExpansion { + return false, fmt.Errorf("Test failure: NodeExpand") + } + // Set up fakeVolumePlugin not support STAGE_UNSTAGE for testing the behavior // so as volume can be node published before we can resize if resizeOptions.CSIVolumePhase == volume.CSIVolumeStaged { diff --git a/pkg/volume/util/operationexecutor/fakegenerator.go b/pkg/volume/util/operationexecutor/fakegenerator.go index 5513dd60db9b..6d8e5a1b3d19 100644 --- a/pkg/volume/util/operationexecutor/fakegenerator.go +++ b/pkg/volume/util/operationexecutor/fakegenerator.go @@ -104,6 +104,10 @@ func (f *fakeOGCounter) GenerateExpandVolumeFunc(*v1.PersistentVolumeClaim, *v1. return f.recordFuncCall("GenerateExpandVolumeFunc"), nil } +func (f *fakeOGCounter) GenerateExpandAndRecoverVolumeFunc(*v1.PersistentVolumeClaim, *v1.PersistentVolume, string) (volumetypes.GeneratedOperations, error) { + return f.recordFuncCall("GenerateExpandVolumeFunc"), nil +} + func (f *fakeOGCounter) GenerateExpandInUseVolumeFunc(volumeToMount VolumeToMount, actualStateOfWorld ActualStateOfWorldMounterUpdater) (volumetypes.GeneratedOperations, error) { return f.recordFuncCall("GenerateExpandInUseVolumeFunc"), nil } diff --git a/pkg/volume/util/operationexecutor/operation_executor_test.go b/pkg/volume/util/operationexecutor/operation_executor_test.go index 0c33d347eb97..521cdf99ac0c 100644 --- a/pkg/volume/util/operationexecutor/operation_executor_test.go +++ b/pkg/volume/util/operationexecutor/operation_executor_test.go @@ -658,6 +658,16 @@ func (fopg *fakeOperationGenerator) GenerateExpandVolumeFunc(pvc *v1.PersistentV }, nil } +func (fopg *fakeOperationGenerator) GenerateExpandAndRecoverVolumeFunc(pvc *v1.PersistentVolumeClaim, pv *v1.PersistentVolume, resizerName string) (volumetypes.GeneratedOperations, error) { + opFunc := func() volumetypes.OperationContext { + startOperationAndBlock(fopg.ch, fopg.quit) + return volumetypes.NewOperationContext(nil, nil, false) + } + return volumetypes.GeneratedOperations{ + OperationFunc: opFunc, + }, nil +} + func (fopg *fakeOperationGenerator) GenerateExpandInUseVolumeFunc(volumeToMount VolumeToMount, actualStateOfWorld ActualStateOfWorldMounterUpdater) (volumetypes.GeneratedOperations, error) { opFunc := func() volumetypes.OperationContext { startOperationAndBlock(fopg.ch, fopg.quit) diff --git a/pkg/volume/util/operationexecutor/operation_generator.go b/pkg/volume/util/operationexecutor/operation_generator.go index 4eabca48927f..d7cb5121a6c7 100644 --- a/pkg/volume/util/operationexecutor/operation_generator.go +++ b/pkg/volume/util/operationexecutor/operation_generator.go @@ -25,6 +25,8 @@ import ( "strings" "time" + "k8s.io/apimachinery/pkg/api/resource" + v1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -150,10 +152,50 @@ type OperationGenerator interface { GenerateExpandVolumeFunc(*v1.PersistentVolumeClaim, *v1.PersistentVolume) (volumetypes.GeneratedOperations, error) + GenerateExpandAndRecoverVolumeFunc(*v1.PersistentVolumeClaim, *v1.PersistentVolume, string) (volumetypes.GeneratedOperations, error) + // Generates the volume file system resize function, which can resize volume's file system to expected size without unmounting the volume. GenerateExpandInUseVolumeFunc(volumeToMount VolumeToMount, actualStateOfWorld ActualStateOfWorldMounterUpdater) (volumetypes.GeneratedOperations, error) } +type inTreeResizeOpts struct { + resizerName string + pvc *v1.PersistentVolumeClaim + pv *v1.PersistentVolume + volumeSpec *volume.Spec + volumePlugin volume.ExpandableVolumePlugin +} + +type inTreeResizeResponse struct { + pvc *v1.PersistentVolumeClaim + pv *v1.PersistentVolume + err error + + // Indicates whether kubelet should assume resize operation as finished. + // For kubelet - resize operation could be assumed as finished even if + // actual resizing is *not* finished. This can happen, because certain prechecks + // are failing and kubelet should not retry expansion, or it could happen + // because resize operation is genuinely finished. + assumeResizeOpAsFinished bool + + // indicates that resize operation was called on underlying volume driver + // mainly useful for testing. + resizeCalled bool + + // indicates whether entire volume expansion is finished or not + // only used from nodeExpansion calls. Mainly used for testing. + resizeFinished bool +} + +type nodeResizeOperationOpts struct { + vmt VolumeToMount + pvc *v1.PersistentVolumeClaim + pv *v1.PersistentVolume + pluginResizeOpts volume.NodeResizeOptions + volumePlugin volume.NodeExpandableVolumePlugin + actualStateOfWorld ActualStateOfWorldMounterUpdater +} + func (og *operationGenerator) GenerateVolumesAreAttachedFunc( attachedVolumes []AttachedVolume, nodeName types.NodeName, @@ -1595,7 +1637,6 @@ func (og *operationGenerator) GenerateExpandVolumeFunc( } expandVolumeFunc := func() volumetypes.OperationContext { - migrated := false newSize := pvc.Spec.Resources.Requests[v1.ResourceStorage] @@ -1617,7 +1658,7 @@ func (og *operationGenerator) GenerateExpandVolumeFunc( // k8s doesn't have transactions, we can't guarantee that after updating PV - updating PVC will be // successful, that is why all PVCs for which pvc.Spec.Size > pvc.Status.Size must be reprocessed // until they reflect user requested size in pvc.Status.Size - updateErr := util.UpdatePVSize(pv, newSize, og.kubeClient) + _, updateErr := util.UpdatePVSize(pv, newSize, og.kubeClient) if updateErr != nil { detailedErr := fmt.Errorf("error updating PV spec capacity for volume %q with : %v", util.GetPersistentVolumeClaimQualifiedName(pvc), updateErr) return volumetypes.NewOperationContext(detailedErr, detailedErr, migrated) @@ -1632,7 +1673,7 @@ func (og *operationGenerator) GenerateExpandVolumeFunc( // reflects user requested size. if !volumePlugin.RequiresFSResize() || !fsVolume { klog.V(4).Infof("Controller resizing done for PVC %s", util.GetPersistentVolumeClaimQualifiedName(pvc)) - err := util.MarkResizeFinished(pvc, newSize, og.kubeClient) + _, err := util.MarkResizeFinished(pvc, newSize, og.kubeClient) if err != nil { detailedErr := fmt.Errorf("error marking pvc %s as resized : %v", util.GetPersistentVolumeClaimQualifiedName(pvc), err) return volumetypes.NewOperationContext(detailedErr, detailedErr, migrated) @@ -1640,7 +1681,7 @@ func (og *operationGenerator) GenerateExpandVolumeFunc( successMsg := fmt.Sprintf("ExpandVolume succeeded for volume %s", util.GetPersistentVolumeClaimQualifiedName(pvc)) og.recorder.Eventf(pvc, v1.EventTypeNormal, kevents.VolumeResizeSuccess, successMsg) } else { - err := util.MarkForFSResize(pvc, og.kubeClient) + _, err := util.MarkForFSResize(pvc, og.kubeClient) if err != nil { detailedErr := fmt.Errorf("error updating pvc %s condition for fs resize : %v", util.GetPersistentVolumeClaimQualifiedName(pvc), err) klog.Warning(detailedErr) @@ -1672,6 +1713,210 @@ func (og *operationGenerator) GenerateExpandVolumeFunc( }, nil } +func (og *operationGenerator) GenerateExpandAndRecoverVolumeFunc( + pvc *v1.PersistentVolumeClaim, + pv *v1.PersistentVolume, resizerName string) (volumetypes.GeneratedOperations, error) { + + volumeSpec := volume.NewSpecFromPersistentVolume(pv, false) + + volumePlugin, err := og.volumePluginMgr.FindExpandablePluginBySpec(volumeSpec) + if err != nil { + return volumetypes.GeneratedOperations{}, fmt.Errorf("error finding plugin for expanding volume: %q with error %v", util.GetPersistentVolumeClaimQualifiedName(pvc), err) + } + + if volumePlugin == nil { + return volumetypes.GeneratedOperations{}, fmt.Errorf("can not find plugin for expanding volume: %q", util.GetPersistentVolumeClaimQualifiedName(pvc)) + } + + expandVolumeFunc := func() volumetypes.OperationContext { + resizeOpts := inTreeResizeOpts{ + pvc: pvc, + pv: pv, + resizerName: resizerName, + volumePlugin: volumePlugin, + volumeSpec: volumeSpec, + } + migrated := false + resp := og.expandAndRecoverFunction(resizeOpts) + if resp.err != nil { + return volumetypes.NewOperationContext(resp.err, resp.err, migrated) + } + return volumetypes.NewOperationContext(nil, nil, migrated) + } + + eventRecorderFunc := func(err *error) { + if *err != nil { + og.recorder.Eventf(pvc, v1.EventTypeWarning, kevents.VolumeResizeFailed, (*err).Error()) + } + } + + return volumetypes.GeneratedOperations{ + OperationName: "expand_volume", + OperationFunc: expandVolumeFunc, + EventRecorderFunc: eventRecorderFunc, + CompleteFunc: util.OperationCompleteHook(util.GetFullQualifiedPluginNameForVolume(volumePlugin.GetPluginName(), volumeSpec), "expand_volume"), + }, nil +} + +func (og *operationGenerator) expandAndRecoverFunction(resizeOpts inTreeResizeOpts) inTreeResizeResponse { + pvc := resizeOpts.pvc + pv := resizeOpts.pv + resizerName := resizeOpts.resizerName + volumePlugin := resizeOpts.volumePlugin + volumeSpec := resizeOpts.volumeSpec + + pvcSpecSize := pvc.Spec.Resources.Requests[v1.ResourceStorage] + pvcStatusSize := pvc.Status.Capacity[v1.ResourceStorage] + pvSize := pv.Spec.Capacity[v1.ResourceStorage] + + resizeResponse := inTreeResizeResponse{ + pvc: pvc, + pv: pv, + resizeCalled: false, + } + + // by default we are expanding to full-fill size requested in pvc.Spec.Resources + newSize := pvcSpecSize + resizeStatus := v1.PersistentVolumeClaimNoExpansionInProgress + if pvc.Status.ResizeStatus != nil { + resizeStatus = *pvc.Status.ResizeStatus + } + var allocatedSize *resource.Quantity + t, ok := pvc.Status.AllocatedResources[v1.ResourceStorage] + if ok { + allocatedSize = &t + } + var err error + + if pvSize.Cmp(pvcSpecSize) < 0 { + // pv is not of requested size yet and hence will require expanding + + switch resizeStatus { + case v1.PersistentVolumeClaimControllerExpansionInProgress: + case v1.PersistentVolumeClaimNodeExpansionPending: + case v1.PersistentVolumeClaimNodeExpansionInProgress: + case v1.PersistentVolumeClaimNodeExpansionFailed: + if allocatedSize != nil { + newSize = *allocatedSize + } + default: + newSize = pvcSpecSize + } + } else { + // PV has already been expanded and hence we can be here for following reasons: + // 1. If expansion is pending on the node and this was just a spurious update event + // we don't need to do anything and let kubelet handle it. + // 2. It could be that - although we successfully expanded the volume, we failed to + // record our work in API objects, in which case - we should resume resizing operation + // and let API objects be updated. + // 3. Controller successfully expanded the volume, but expansion is failing on the node + // and before kubelet can retry failed node expansion - controller must verify if it is + // safe to do so. + // 4. While expansion was still pending on the node, user reduced the pvc size. + switch resizeStatus { + case v1.PersistentVolumeClaimNodeExpansionInProgress: + case v1.PersistentVolumeClaimNodeExpansionPending: + // we don't need to do any work. We could be here because of a spurious update event. + // This is case #1 + return resizeResponse + case v1.PersistentVolumeClaimNodeExpansionFailed: + // This is case#3 + pvc, err = og.markForPendingNodeExpansion(pvc, pv) + resizeResponse.pvc = pvc + resizeResponse.err = err + return resizeResponse + case v1.PersistentVolumeClaimControllerExpansionInProgress: + case v1.PersistentVolumeClaimControllerExpansionFailed: + case v1.PersistentVolumeClaimNoExpansionInProgress: + // This is case#2 or it could also be case#4 when user manually shrunk the PVC + // after expanding it. + if allocatedSize != nil { + newSize = *allocatedSize + } + default: + // It is impossible for ResizeStatus to be nil and allocatedSize to be not nil but somehow + // if we do end up in this state, it is safest to resume expansion to last recorded size in + // allocatedSize variable. + if pvc.Status.ResizeStatus == nil && allocatedSize != nil { + newSize = *allocatedSize + } else { + newSize = pvcSpecSize + } + } + } + + pvc, err = util.MarkControllerReisizeInProgress(pvc, resizerName, newSize, og.kubeClient) + if err != nil { + msg := fmt.Errorf("error updating pvc %s with resize in progress: %v", util.GetPersistentVolumeClaimQualifiedName(pvc), err) + resizeResponse.err = msg + resizeResponse.pvc = pvc + return resizeResponse + } + + updatedSize, err := volumePlugin.ExpandVolumeDevice(volumeSpec, newSize, pvcStatusSize) + resizeResponse.resizeCalled = true + + if err != nil { + msg := fmt.Errorf("error expanding pvc %s: %v", util.GetPersistentVolumeClaimQualifiedName(pvc), err) + resizeResponse.err = msg + resizeResponse.pvc = pvc + return resizeResponse + } + + // update PV size + var updateErr error + pv, updateErr = util.UpdatePVSize(pv, updatedSize, og.kubeClient) + // if updating PV failed, we are going to leave the PVC in ControllerExpansionInProgress state, so as expansion can be retried to previously set allocatedSize value. + if updateErr != nil { + msg := fmt.Errorf("error updating pv for pvc %s: %v", util.GetPersistentVolumeClaimQualifiedName(pvc), updateErr) + resizeResponse.err = msg + return resizeResponse + } + resizeResponse.pv = pv + + fsVolume, _ := util.CheckVolumeModeFilesystem(volumeSpec) + + if !volumePlugin.RequiresFSResize() || !fsVolume { + pvc, err = util.MarkResizeFinished(pvc, updatedSize, og.kubeClient) + if err != nil { + msg := fmt.Errorf("error marking pvc %s as resized: %v", util.GetPersistentVolumeClaimQualifiedName(pvc), err) + resizeResponse.err = msg + return resizeResponse + } + resizeResponse.pvc = pvc + successMsg := fmt.Sprintf("ExpandVolume succeeded for volume %s", util.GetPersistentVolumeClaimQualifiedName(pvc)) + og.recorder.Eventf(pvc, v1.EventTypeNormal, kevents.VolumeResizeSuccess, successMsg) + } else { + pvc, err = og.markForPendingNodeExpansion(pvc, pv) + resizeResponse.pvc = pvc + if err != nil { + msg := fmt.Errorf("error marking pvc %s for node expansion: %v", util.GetPersistentVolumeClaimQualifiedName(pvc), err) + resizeResponse.err = msg + return resizeResponse + } + } + return resizeResponse +} + +func (og *operationGenerator) markForPendingNodeExpansion(pvc *v1.PersistentVolumeClaim, pv *v1.PersistentVolume) (*v1.PersistentVolumeClaim, error) { + var err error + pvc, err = util.MarkForFSResize(pvc, og.kubeClient) + if err != nil { + msg := fmt.Errorf("error marking pvc %s for node expansion: %v", util.GetPersistentVolumeClaimQualifiedName(pvc), err) + return pvc, msg + } + // store old PVC capacity in pv, so as if PVC gets deleted while node expansion was pending + // we can restore size of pvc from PV annotation and still perform expansion on the node + oldCapacity := pvc.Status.Capacity[v1.ResourceStorage] + err = util.AddAnnPreResizeCapacity(pv, oldCapacity, og.kubeClient) + if err != nil { + detailedErr := fmt.Errorf("error updating pv %s annotation (%s) with pre-resize capacity %s: %v", pv.ObjectMeta.Name, util.AnnPreResizeCapacity, oldCapacity.String(), err) + klog.Warning(detailedErr) + return pvc, detailedErr + } + return pvc, nil +} + func (og *operationGenerator) GenerateExpandInUseVolumeFunc( volumeToMount VolumeToMount, actualStateOfWorld ActualStateOfWorldMounterUpdater) (volumetypes.GeneratedOperations, error) { @@ -1825,6 +2070,7 @@ func (og *operationGenerator) nodeExpandVolume( if expandableVolumePlugin != nil && expandableVolumePlugin.RequiresFSResize() && volumeToMount.VolumeSpec.PersistentVolume != nil { + pv := volumeToMount.VolumeSpec.PersistentVolume pvc, err := og.kubeClient.CoreV1().PersistentVolumeClaims(pv.Spec.ClaimRef.Namespace).Get(context.TODO(), pv.Spec.ClaimRef.Name, metav1.GetOptions{}) if err != nil { @@ -1832,56 +2078,200 @@ func (og *operationGenerator) nodeExpandVolume( return false, fmt.Errorf("mountVolume.NodeExpandVolume get PVC failed : %v", err) } - pvcStatusCap := pvc.Status.Capacity[v1.ResourceStorage] - pvSpecCap := pv.Spec.Capacity[v1.ResourceStorage] - if pvcStatusCap.Cmp(pvSpecCap) < 0 { - // File system resize was requested, proceed - klog.V(4).InfoS(volumeToMount.GenerateMsgDetailed("MountVolume.NodeExpandVolume entering", fmt.Sprintf("DevicePath %q", volumeToMount.DevicePath)), "pod", klog.KObj(volumeToMount.Pod)) + if volumeToMount.VolumeSpec.ReadOnly { + simpleMsg, detailedMsg := volumeToMount.GenerateMsg("MountVolume.NodeExpandVolume failed", "requested read-only file system") + klog.Warningf(detailedMsg) + og.recorder.Eventf(volumeToMount.Pod, v1.EventTypeWarning, kevents.FileSystemResizeFailed, simpleMsg) + og.recorder.Eventf(pvc, v1.EventTypeWarning, kevents.FileSystemResizeFailed, simpleMsg) + return true, nil + } + resizeOp := nodeResizeOperationOpts{ + vmt: volumeToMount, + pvc: pvc, + pv: pv, + pluginResizeOpts: rsOpts, + volumePlugin: expandableVolumePlugin, + actualStateOfWorld: actualStateOfWorld, + } + if utilfeature.DefaultFeatureGate.Enabled(features.RecoverVolumeExpansionFailure) { + resizeResponse := og.callNodeExpandOnPlugin(resizeOp) + return resizeResponse.assumeResizeOpAsFinished, resizeResponse.err + } else { + return og.legacyCallNodeExpandOnPlugin(resizeOp) + } + } + return true, nil +} - if volumeToMount.VolumeSpec.ReadOnly { - simpleMsg, detailedMsg := volumeToMount.GenerateMsg("MountVolume.NodeExpandVolume failed", "requested read-only file system") - klog.Warningf(detailedMsg) - og.recorder.Eventf(volumeToMount.Pod, v1.EventTypeWarning, kevents.FileSystemResizeFailed, simpleMsg) - og.recorder.Eventf(pvc, v1.EventTypeWarning, kevents.FileSystemResizeFailed, simpleMsg) - return true, nil - } - rsOpts.VolumeSpec = volumeToMount.VolumeSpec - rsOpts.NewSize = pvSpecCap - rsOpts.OldSize = pvcStatusCap - resizeDone, resizeErr := expandableVolumePlugin.NodeExpand(rsOpts) - if resizeErr != nil { - // if driver returned FailedPrecondition error that means - // volume expansion should not be retried on this node but - // expansion operation should not block mounting - if volumetypes.IsFailedPreconditionError(resizeErr) { - actualStateOfWorld.MarkForInUseExpansionError(volumeToMount.VolumeName) - klog.Errorf(volumeToMount.GenerateErrorDetailed("MountVolume.NodeExapndVolume failed with %v", resizeErr).Error()) - return true, nil +// callNodeExpandOnPlugin is newer version of calling node expansion on plugins, which does support +// recovery from volume expansion failure. +func (og *operationGenerator) callNodeExpandOnPlugin(resizeOp nodeResizeOperationOpts) inTreeResizeResponse { + pvc := resizeOp.pvc + pv := resizeOp.pv + volumeToMount := resizeOp.vmt + rsOpts := resizeOp.pluginResizeOpts + actualStateOfWorld := resizeOp.actualStateOfWorld + expandableVolumePlugin := resizeOp.volumePlugin + + var err error + pvcStatusCap := pvc.Status.Capacity[v1.ResourceStorage] + pvSpecCap := pv.Spec.Capacity[v1.ResourceStorage] + + resizeResponse := inTreeResizeResponse{ + pvc: pvc, + pv: pv, + } + + if permitNodeExpansion(pvc, pv) { + // File system resize was requested, proceed + klog.V(4).InfoS(volumeToMount.GenerateMsgDetailed("MountVolume.NodeExpandVolume entering", fmt.Sprintf("DevicePath %q", volumeToMount.DevicePath)), "pod", klog.KObj(volumeToMount.Pod)) + + rsOpts.VolumeSpec = volumeToMount.VolumeSpec + rsOpts.NewSize = pvSpecCap + rsOpts.OldSize = pvcStatusCap + pvc, err = util.MarkNodeExpansionInProgress(pvc, og.kubeClient) + + if err != nil { + msg := volumeToMount.GenerateErrorDetailed("MountVolume.NodeExpandVolume failed to mark node expansion in progress: %v", err) + klog.Errorf(msg.Error()) + resizeResponse.err = msg + return resizeResponse + } + + resizeDone, resizeErr := expandableVolumePlugin.NodeExpand(rsOpts) + resizeResponse.resizeCalled = true + + if resizeErr != nil { + if volumetypes.IsOperationFinishedError(resizeErr) { + var markFailedError error + pvc, markFailedError = util.MarkNodeExpansionFailed(pvc, og.kubeClient) + // update the pvc with node expansion object + resizeResponse.pvc = pvc + resizeResponse.assumeResizeOpAsFinished = true + if markFailedError != nil { + klog.Errorf(volumeToMount.GenerateErrorDetailed("MountMount.NodeExpandVolume failed to mark node expansion as failed: %v", err).Error()) } - return false, resizeErr } - // Volume resizing is not done but it did not error out. This could happen if a CSI volume - // does not have node stage_unstage capability but was asked to resize the volume before - // node publish. In which case - we must retry resizing after node publish. - if !resizeDone { - return false, nil + + // if driver returned FailedPrecondition error that means + // volume expansion should not be retried on this node but + // expansion operation should not block mounting + if volumetypes.IsFailedPreconditionError(resizeErr) { + actualStateOfWorld.MarkForInUseExpansionError(volumeToMount.VolumeName) + klog.Errorf(volumeToMount.GenerateErrorDetailed("MountVolume.NodeExapndVolume failed with %v", resizeErr).Error()) + resizeResponse.assumeResizeOpAsFinished = true + return resizeResponse } - simpleMsg, detailedMsg := volumeToMount.GenerateMsg("MountVolume.NodeExpandVolume succeeded", "") - og.recorder.Eventf(volumeToMount.Pod, v1.EventTypeNormal, kevents.FileSystemResizeSuccess, simpleMsg) - og.recorder.Eventf(pvc, v1.EventTypeNormal, kevents.FileSystemResizeSuccess, simpleMsg) - klog.InfoS(detailedMsg, "pod", klog.KObj(volumeToMount.Pod)) - // File system resize succeeded, now update the PVC's Capacity to match the PV's - err = util.MarkFSResizeFinished(pvc, pvSpecCap, og.kubeClient) - if err != nil { - // On retry, NodeExpandVolume will be called again but do nothing - return false, fmt.Errorf("mountVolume.NodeExpandVolume update PVC status failed : %v", err) + + resizeResponse.err = resizeErr + return resizeResponse + } + resizeResponse.resizeFinished = resizeDone + + // Volume resizing is not done but it did not error out. This could happen if a CSI volume + // does not have node stage_unstage capability but was asked to resize the volume before + // node publish. In which case - we must retry resizing after node publish. + if !resizeDone { + return resizeResponse + } + + simpleMsg, detailedMsg := volumeToMount.GenerateMsg("MountVolume.NodeExpandVolume succeeded", "") + og.recorder.Eventf(volumeToMount.Pod, v1.EventTypeNormal, kevents.FileSystemResizeSuccess, simpleMsg) + og.recorder.Eventf(pvc, v1.EventTypeNormal, kevents.FileSystemResizeSuccess, simpleMsg) + klog.InfoS(detailedMsg, "pod", klog.KObj(volumeToMount.Pod)) + + // File system resize succeeded, now update the PVC's Capacity to match the PV's + pvc, err = util.MarkFSResizeFinished(pvc, pvSpecCap, og.kubeClient) + resizeResponse.pvc = pvc + + if err != nil { + resizeResponse.err = fmt.Errorf("mountVolume.NodeExpandVolume update PVC status failed : %v", err) + // On retry, NodeExpandVolume will be called again but do nothing + return resizeResponse + } + resizeResponse.assumeResizeOpAsFinished = true + return resizeResponse + } + // somehow a resize operation was queued, but we can not perform any resizing because + // prechecks required for node expansion failed. Kubelet should not retry expanding the volume. + resizeResponse.assumeResizeOpAsFinished = true + return resizeResponse +} + +// legacyCallNodeExpandOnPlugin is old version of calling node expansion on plugin, which does not support +// recovery from volume expansion failure +func (og *operationGenerator) legacyCallNodeExpandOnPlugin(resizeOp nodeResizeOperationOpts) (bool, error) { + pvc := resizeOp.pvc + pv := resizeOp.pv + volumeToMount := resizeOp.vmt + rsOpts := resizeOp.pluginResizeOpts + actualStateOfWorld := resizeOp.actualStateOfWorld + expandableVolumePlugin := resizeOp.volumePlugin + + var err error + + pvcStatusCap := pvc.Status.Capacity[v1.ResourceStorage] + pvSpecCap := pv.Spec.Capacity[v1.ResourceStorage] + if pvcStatusCap.Cmp(pvSpecCap) < 0 { + // File system resize was requested, proceed + klog.V(4).InfoS(volumeToMount.GenerateMsgDetailed("MountVolume.NodeExpandVolume entering", fmt.Sprintf("DevicePath %q", volumeToMount.DevicePath)), "pod", klog.KObj(volumeToMount.Pod)) + + rsOpts.VolumeSpec = volumeToMount.VolumeSpec + rsOpts.NewSize = pvSpecCap + rsOpts.OldSize = pvcStatusCap + resizeDone, resizeErr := expandableVolumePlugin.NodeExpand(rsOpts) + if resizeErr != nil { + // if driver returned FailedPrecondition error that means + // volume expansion should not be retried on this node but + // expansion operation should not block mounting + if volumetypes.IsFailedPreconditionError(resizeErr) { + actualStateOfWorld.MarkForInUseExpansionError(volumeToMount.VolumeName) + klog.Errorf(volumeToMount.GenerateErrorDetailed("MountVolume.NodeExapndVolume failed with %v", resizeErr).Error()) + return true, nil } - return true, nil + return false, resizeErr + } + // Volume resizing is not done but it did not error out. This could happen if a CSI volume + // does not have node stage_unstage capability but was asked to resize the volume before + // node publish. In which case - we must retry resizing after node publish. + if !resizeDone { + return false, nil + } + simpleMsg, detailedMsg := volumeToMount.GenerateMsg("MountVolume.NodeExpandVolume succeeded", "") + og.recorder.Eventf(volumeToMount.Pod, v1.EventTypeNormal, kevents.FileSystemResizeSuccess, simpleMsg) + og.recorder.Eventf(pvc, v1.EventTypeNormal, kevents.FileSystemResizeSuccess, simpleMsg) + klog.InfoS(detailedMsg, "pod", klog.KObj(volumeToMount.Pod)) + // File system resize succeeded, now update the PVC's Capacity to match the PV's + _, err = util.MarkFSResizeFinished(pvc, pvSpecCap, og.kubeClient) + if err != nil { + // On retry, NodeExpandVolume will be called again but do nothing + return false, fmt.Errorf("mountVolume.NodeExpandVolume update PVC status failed : %v", err) } + return true, nil } return true, nil } +func permitNodeExpansion(pvc *v1.PersistentVolumeClaim, pv *v1.PersistentVolume) bool { + pvcStatusCap := pvc.Status.Capacity[v1.ResourceStorage] + pvSpecCap := pv.Spec.Capacity[v1.ResourceStorage] + // if pvc.Status.Cap is >= pv.Spec.Cap then volume is already expanded + if pvcStatusCap.Cmp(pvSpecCap) >= 0 { + return false + } + + resizeStatus := pvc.Status.ResizeStatus + // if resizestatus is nil or NodeExpansionInProgress or NodeExpansionPending then we should allow volume expansion on + // the node to proceed. We are making an exception for resizeStatus being nil because it will support use cases where + // resizeStatus may not be set (old control-plane expansion controller etc). + if resizeStatus == nil || *resizeStatus == v1.PersistentVolumeClaimNodeExpansionPending || *resizeStatus == v1.PersistentVolumeClaimNodeExpansionInProgress { + return true + } else { + klog.Infof("volume %s/%s can not be expanded because resizeStaus is: %s", pvc.Namespace, pvc.Name, *resizeStatus) + return false + } +} + func checkMountOptionSupport(og *operationGenerator, volumeToMount VolumeToMount, plugin volume.VolumePlugin) error { mountOptions := util.MountOptionFromSpec(volumeToMount.VolumeSpec) diff --git a/pkg/volume/util/operationexecutor/operation_generator_test.go b/pkg/volume/util/operationexecutor/operation_generator_test.go index 3353510a69f1..c7888ef09011 100644 --- a/pkg/volume/util/operationexecutor/operation_generator_test.go +++ b/pkg/volume/util/operationexecutor/operation_generator_test.go @@ -17,6 +17,12 @@ limitations under the License. package operationexecutor import ( + "k8s.io/apimachinery/pkg/api/resource" + "k8s.io/apimachinery/pkg/runtime" + utilfeature "k8s.io/apiserver/pkg/util/feature" + "k8s.io/client-go/tools/record" + featuregatetesting "k8s.io/component-base/featuregate/testing" + "k8s.io/kubernetes/pkg/features" "os" "testing" @@ -27,7 +33,6 @@ import ( "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/uuid" fakeclient "k8s.io/client-go/kubernetes/fake" - "k8s.io/client-go/tools/record" "k8s.io/component-base/metrics/legacyregistry" "k8s.io/csi-translation-lib/plugins" "k8s.io/kubernetes/pkg/volume" @@ -111,6 +116,267 @@ func TestOperationGenerator_GenerateUnmapVolumeFunc_PluginName(t *testing.T) { } } +func TestOperationGenerator_GenerateExpandAndRecoverVolumeFunc(t *testing.T) { + var tests = []struct { + name string + pvc *v1.PersistentVolumeClaim + pv *v1.PersistentVolume + recoverFeatureGate bool + disableNodeExpansion bool + // expectations of test + expectedResizeStatus v1.PersistentVolumeClaimResizeStatus + expectedAllocatedSize resource.Quantity + expectResizeCall bool + }{ + { + name: "pvc.spec.size > pv.spec.size, recover_expansion=on", + pvc: getTestPVC("test-vol0", "2G", "1G", "", v1.PersistentVolumeClaimNoExpansionInProgress), + pv: getTestPV("test-vol0", "1G"), + recoverFeatureGate: true, + expectedResizeStatus: v1.PersistentVolumeClaimNodeExpansionPending, + expectedAllocatedSize: resource.MustParse("2G"), + expectResizeCall: true, + }, + { + name: "pvc.spec.size = pv.spec.size, recover_expansion=on", + pvc: getTestPVC("test-vol0", "1G", "1G", "", v1.PersistentVolumeClaimNoExpansionInProgress), + pv: getTestPV("test-vol0", "1G"), + recoverFeatureGate: true, + expectedResizeStatus: v1.PersistentVolumeClaimNodeExpansionPending, + expectedAllocatedSize: resource.MustParse("1G"), + expectResizeCall: true, + }, + { + name: "pvc.spec.size = pv.spec.size, recover_expansion=on", + pvc: getTestPVC("test-vol0", "1G", "1G", "1G", v1.PersistentVolumeClaimNodeExpansionPending), + pv: getTestPV("test-vol0", "1G"), + recoverFeatureGate: true, + expectedResizeStatus: v1.PersistentVolumeClaimNodeExpansionPending, + expectedAllocatedSize: resource.MustParse("1G"), + expectResizeCall: false, + }, + { + name: "pvc.spec.size > pv.spec.size, recover_expansion=on, disable_node_expansion=true", + pvc: getTestPVC("test-vol0", "2G", "1G", "", v1.PersistentVolumeClaimNoExpansionInProgress), + pv: getTestPV("test-vol0", "1G"), + disableNodeExpansion: true, + recoverFeatureGate: true, + expectedResizeStatus: v1.PersistentVolumeClaimNoExpansionInProgress, + expectedAllocatedSize: resource.MustParse("2G"), + expectResizeCall: true, + }, + { + name: "pv.spec.size >= pvc.spec.size, recover_expansion=on, resize_status=node_expansion_failed", + pvc: getTestPVC("test-vol0", "2G", "1G", "2G", v1.PersistentVolumeClaimNodeExpansionFailed), + pv: getTestPV("test-vol0", "2G"), + recoverFeatureGate: true, + expectedResizeStatus: v1.PersistentVolumeClaimNodeExpansionPending, + expectedAllocatedSize: resource.MustParse("2G"), + expectResizeCall: false, + }, + } + for i := range tests { + test := tests[i] + t.Run(test.name, func(t *testing.T) { + defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.RecoverVolumeExpansionFailure, test.recoverFeatureGate)() + volumePluginMgr, fakePlugin := volumetesting.GetTestKubeletVolumePluginMgr(t) + fakePlugin.DisableNodeExpansion = test.disableNodeExpansion + pvc := test.pvc + pv := test.pv + og := getTestOperationGenerator(volumePluginMgr, pvc, pv) + rsOpts := inTreeResizeOpts{ + pvc: pvc, + pv: pv, + resizerName: fakePlugin.GetPluginName(), + volumePlugin: fakePlugin, + } + ogInstance, _ := og.(*operationGenerator) + + expansionResponse := ogInstance.expandAndRecoverFunction(rsOpts) + if expansionResponse.err != nil { + t.Fatalf("GenerateExpandAndRecoverVolumeFunc failed: %v", expansionResponse.err) + } + updatedPVC := expansionResponse.pvc + assert.Equal(t, *updatedPVC.Status.ResizeStatus, test.expectedResizeStatus) + actualAllocatedSize := updatedPVC.Status.AllocatedResources.Storage() + if test.expectedAllocatedSize.Cmp(*actualAllocatedSize) != 0 { + t.Fatalf("GenerateExpandAndRecoverVolumeFunc failed: expected allocated size %s, got %s", test.expectedAllocatedSize.String(), actualAllocatedSize.String()) + } + if test.expectResizeCall != expansionResponse.resizeCalled { + t.Fatalf("GenerateExpandAndRecoverVolumeFunc failed: expected resize called %t, got %t", test.expectResizeCall, expansionResponse.resizeCalled) + } + }) + } +} + +func TestOperationGenerator_callNodeExpansionOnPlugin(t *testing.T) { + var tests = []struct { + name string + pvc *v1.PersistentVolumeClaim + pv *v1.PersistentVolume + recoverFeatureGate bool + + // expectations of test + expectedResizeStatus v1.PersistentVolumeClaimResizeStatus + expectedStatusSize resource.Quantity + expectResizeCall bool + assumeResizeOpAsFinished bool + expectError bool + }{ + { + name: "pv.spec.cap > pvc.status.cap, resizeStatus=node_expansion_failed", + pvc: getTestPVC("test-vol0", "2G", "1G", "", v1.PersistentVolumeClaimNodeExpansionFailed), + pv: getTestPV("test-vol0", "2G"), + recoverFeatureGate: true, + + expectedResizeStatus: v1.PersistentVolumeClaimNodeExpansionFailed, + expectResizeCall: false, + assumeResizeOpAsFinished: true, + expectedStatusSize: resource.MustParse("1G"), + }, + { + name: "pv.spec.cap > pvc.status.cap, resizeStatus=node_expansion_pending", + pvc: getTestPVC("test-vol0", "2G", "1G", "2G", v1.PersistentVolumeClaimNodeExpansionPending), + pv: getTestPV("test-vol0", "2G"), + recoverFeatureGate: true, + expectedResizeStatus: v1.PersistentVolumeClaimNoExpansionInProgress, + expectResizeCall: true, + assumeResizeOpAsFinished: true, + expectedStatusSize: resource.MustParse("2G"), + }, + { + name: "pv.spec.cap > pvc.status.cap, resizeStatus=node_expansion_pending, reize_op=failing", + pvc: getTestPVC(volumetesting.AlwaysFailNodeExpansion, "2G", "1G", "2G", v1.PersistentVolumeClaimNodeExpansionPending), + pv: getTestPV(volumetesting.AlwaysFailNodeExpansion, "2G"), + recoverFeatureGate: true, + expectError: true, + expectedResizeStatus: v1.PersistentVolumeClaimNodeExpansionFailed, + expectResizeCall: true, + assumeResizeOpAsFinished: true, + expectedStatusSize: resource.MustParse("1G"), + }, + } + + for i := range tests { + test := tests[i] + t.Run(test.name, func(t *testing.T) { + defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.RecoverVolumeExpansionFailure, test.recoverFeatureGate)() + volumePluginMgr, fakePlugin := volumetesting.GetTestKubeletVolumePluginMgr(t) + + pvc := test.pvc + pv := test.pv + pod := getTestPod("test-pod", pvc.Name) + og := getTestOperationGenerator(volumePluginMgr, pvc, pv) + + vmt := VolumeToMount{ + Pod: pod, + VolumeName: v1.UniqueVolumeName(pv.Name), + VolumeSpec: volume.NewSpecFromPersistentVolume(pv, false), + } + resizeOp := nodeResizeOperationOpts{ + pvc: pvc, + pv: pv, + volumePlugin: fakePlugin, + vmt: vmt, + actualStateOfWorld: nil, + } + ogInstance, _ := og.(*operationGenerator) + expansionResponse := ogInstance.callNodeExpandOnPlugin(resizeOp) + + pvc = expansionResponse.pvc + pvcStatusCap := pvc.Status.Capacity[v1.ResourceStorage] + + if !test.expectError && expansionResponse.err != nil { + t.Errorf("For test %s, expected no error got: %v", test.name, expansionResponse.err) + } + if test.expectError && expansionResponse.err == nil { + t.Errorf("For test %s, expected error but got none", test.name) + } + + if test.expectResizeCall != expansionResponse.resizeCalled { + t.Errorf("For test %s, expected resize called %t, got %t", test.name, test.expectResizeCall, expansionResponse.resizeCalled) + } + if test.assumeResizeOpAsFinished != expansionResponse.assumeResizeOpAsFinished { + t.Errorf("For test %s, expected assumeResizeOpAsFinished %t, got %t", test.name, test.assumeResizeOpAsFinished, expansionResponse.assumeResizeOpAsFinished) + } + if test.expectedResizeStatus != *pvc.Status.ResizeStatus { + t.Errorf("For test %s, expected resizeStatus %v, got %v", test.name, test.expectedResizeStatus, *pvc.Status.ResizeStatus) + } + if pvcStatusCap.Cmp(test.expectedStatusSize) != 0 { + t.Errorf("For test %s, expected status size %s, got %s", test.name, test.expectedStatusSize.String(), pvcStatusCap.String()) + } + }) + } +} + +func getTestPod(podName, pvcName string) *v1.Pod { + return &v1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: podName, + UID: "test-pod-uid", + Namespace: "ns", + }, + Spec: v1.PodSpec{ + Volumes: []v1.Volume{ + { + Name: pvcName, + VolumeSource: v1.VolumeSource{ + PersistentVolumeClaim: &v1.PersistentVolumeClaimVolumeSource{ + ClaimName: pvcName, + }, + }, + }, + }, + }, + } +} + +func getTestPVC(volumeName string, specSize, statusSize, allocatedSize string, resizeStatus v1.PersistentVolumeClaimResizeStatus) *v1.PersistentVolumeClaim { + pvc := &v1.PersistentVolumeClaim{ + ObjectMeta: metav1.ObjectMeta{ + Name: "claim01", + Namespace: "ns", + UID: "test-uid", + }, + Spec: v1.PersistentVolumeClaimSpec{ + AccessModes: []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}, + Resources: v1.ResourceRequirements{Requests: v1.ResourceList{v1.ResourceStorage: resource.MustParse(specSize)}}, + VolumeName: volumeName, + }, + Status: v1.PersistentVolumeClaimStatus{ + Phase: v1.ClaimBound, + }, + } + if len(statusSize) > 0 { + pvc.Status.Capacity = v1.ResourceList{v1.ResourceStorage: resource.MustParse(statusSize)} + } + if len(allocatedSize) > 0 { + pvc.Status.AllocatedResources = v1.ResourceList{v1.ResourceStorage: resource.MustParse(allocatedSize)} + } + if len(resizeStatus) > 0 { + pvc.Status.ResizeStatus = &resizeStatus + } + return pvc +} + +func getTestPV(volumeName string, specSize string) *v1.PersistentVolume { + return &v1.PersistentVolume{ + ObjectMeta: metav1.ObjectMeta{ + Name: volumeName, + UID: "test-uid", + }, + Spec: v1.PersistentVolumeSpec{ + AccessModes: []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}, + Capacity: v1.ResourceList{ + v1.ResourceStorage: resource.MustParse(specSize), + }, + }, + Status: v1.PersistentVolumeStatus{ + Phase: v1.VolumeBound, + }, + } +} + func findMetricWithNameAndLabels(metricFamilyName string, labelFilter map[string]string) *io_prometheus_client.Metric { metricFamily := getMetricFamily(metricFamilyName) if metricFamily == nil { @@ -145,8 +411,8 @@ func isLabelsMatchWithMetric(labelFilter map[string]string, metric *io_prometheu return true } -func getTestOperationGenerator(volumePluginMgr *volume.VolumePluginMgr) OperationGenerator { - fakeKubeClient := fakeclient.NewSimpleClientset() +func getTestOperationGenerator(volumePluginMgr *volume.VolumePluginMgr, objects ...runtime.Object) OperationGenerator { + fakeKubeClient := fakeclient.NewSimpleClientset(objects...) fakeRecorder := &record.FakeRecorder{} fakeHandler := volumetesting.NewBlockVolumePathHandler() operationGenerator := NewOperationGenerator( diff --git a/pkg/volume/util/resize_util.go b/pkg/volume/util/resize_util.go index 195819d14087..4368b5fec7f3 100644 --- a/pkg/volume/util/resize_util.go +++ b/pkg/volume/util/resize_util.go @@ -28,7 +28,9 @@ import ( "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/strategicpatch" + utilfeature "k8s.io/apiserver/pkg/util/feature" clientset "k8s.io/client-go/kubernetes" + "k8s.io/kubernetes/pkg/features" "k8s.io/kubernetes/pkg/volume" volumetypes "k8s.io/kubernetes/pkg/volume/util/types" "k8s.io/mount-utils" @@ -61,7 +63,7 @@ func ClaimToClaimKey(claim *v1.PersistentVolumeClaim) string { func UpdatePVSize( pv *v1.PersistentVolume, newSize resource.Quantity, - kubeClient clientset.Interface) error { + kubeClient clientset.Interface) (*v1.PersistentVolume, error) { pvClone := pv.DeepCopy() pvClone.Spec.Capacity[v1.ResourceStorage] = newSize @@ -84,7 +86,8 @@ func AddAnnPreResizeCapacity( } pvClone.ObjectMeta.Annotations[AnnPreResizeCapacity] = oldCapacity.String() - return PatchPV(pv, pvClone, kubeClient) + _, err := PatchPV(pv, pvClone, kubeClient) + return err } // DeleteAnnPreResizeCapacity deletes volume.alpha.kubernetes.io/pre-resize-capacity from the pv @@ -97,35 +100,35 @@ func DeleteAnnPreResizeCapacity( } pvClone := pv.DeepCopy() delete(pvClone.ObjectMeta.Annotations, AnnPreResizeCapacity) - - return PatchPV(pv, pvClone, kubeClient) + _, err := PatchPV(pv, pvClone, kubeClient) + return err } // PatchPV creates and executes a patch for pv func PatchPV( oldPV *v1.PersistentVolume, newPV *v1.PersistentVolume, - kubeClient clientset.Interface) error { + kubeClient clientset.Interface) (*v1.PersistentVolume, error) { oldData, err := json.Marshal(oldPV) if err != nil { - return fmt.Errorf("unexpected error marshaling old PV %q with error : %v", oldPV.Name, err) + return oldPV, fmt.Errorf("unexpected error marshaling old PV %q with error : %v", oldPV.Name, err) } newData, err := json.Marshal(newPV) if err != nil { - return fmt.Errorf("unexpected error marshaling new PV %q with error : %v", newPV.Name, err) + return oldPV, fmt.Errorf("unexpected error marshaling new PV %q with error : %v", newPV.Name, err) } patchBytes, err := strategicpatch.CreateTwoWayMergePatch(oldData, newData, oldPV) if err != nil { - return fmt.Errorf("error Creating two way merge patch for PV %q with error : %v", oldPV.Name, err) + return oldPV, fmt.Errorf("error Creating two way merge patch for PV %q with error : %v", oldPV.Name, err) } - _, err = kubeClient.CoreV1().PersistentVolumes().Patch(context.TODO(), oldPV.Name, types.StrategicMergePatchType, patchBytes, metav1.PatchOptions{}) + updatedPV, err := kubeClient.CoreV1().PersistentVolumes().Patch(context.TODO(), oldPV.Name, types.StrategicMergePatchType, patchBytes, metav1.PatchOptions{}) if err != nil { - return fmt.Errorf("error Patching PV %q with error : %v", oldPV.Name, err) + return oldPV, fmt.Errorf("error Patching PV %q with error : %v", oldPV.Name, err) } - return nil + return updatedPV, nil } // MarkResizeInProgressWithResizer marks cloudprovider resizing as in progress @@ -147,6 +150,23 @@ func MarkResizeInProgressWithResizer( return PatchPVCStatus(pvc /*oldPVC*/, newPVC, kubeClient) } +func MarkControllerReisizeInProgress(pvc *v1.PersistentVolumeClaim, resizerName string, newSize resource.Quantity, kubeClient clientset.Interface) (*v1.PersistentVolumeClaim, error) { + // Mark PVC as Resize Started + progressCondition := v1.PersistentVolumeClaimCondition{ + Type: v1.PersistentVolumeClaimResizing, + Status: v1.ConditionTrue, + LastTransitionTime: metav1.Now(), + } + controllerExpansionInProgress := v1.PersistentVolumeClaimControllerExpansionInProgress + conditions := []v1.PersistentVolumeClaimCondition{progressCondition} + newPVC := pvc.DeepCopy() + newPVC = MergeResizeConditionOnPVC(newPVC, conditions) + newPVC.Status.ResizeStatus = &controllerExpansionInProgress + newPVC.Status.AllocatedResources = v1.ResourceList{v1.ResourceStorage: newSize} + newPVC = setResizer(newPVC, resizerName) + return PatchPVCStatus(pvc /*oldPVC*/, newPVC, kubeClient) +} + // SetClaimResizer sets resizer annotation on PVC func SetClaimResizer( pvc *v1.PersistentVolumeClaim, @@ -168,7 +188,7 @@ func setResizer(pvc *v1.PersistentVolumeClaim, resizerName string) *v1.Persisten // MarkForFSResize marks file system resizing as pending func MarkForFSResize( pvc *v1.PersistentVolumeClaim, - kubeClient clientset.Interface) error { + kubeClient clientset.Interface) (*v1.PersistentVolumeClaim, error) { pvcCondition := v1.PersistentVolumeClaimCondition{ Type: v1.PersistentVolumeClaimFileSystemResizePending, Status: v1.ConditionTrue, @@ -177,16 +197,20 @@ func MarkForFSResize( } conditions := []v1.PersistentVolumeClaimCondition{pvcCondition} newPVC := pvc.DeepCopy() + if utilfeature.DefaultFeatureGate.Enabled(features.RecoverVolumeExpansionFailure) { + expansionPendingOnNode := v1.PersistentVolumeClaimNodeExpansionPending + newPVC.Status.ResizeStatus = &expansionPendingOnNode + } newPVC = MergeResizeConditionOnPVC(newPVC, conditions) - _, err := PatchPVCStatus(pvc /*oldPVC*/, newPVC, kubeClient) - return err + updatedPVC, err := PatchPVCStatus(pvc /*oldPVC*/, newPVC, kubeClient) + return updatedPVC, err } // MarkResizeFinished marks all resizing as done func MarkResizeFinished( pvc *v1.PersistentVolumeClaim, newSize resource.Quantity, - kubeClient clientset.Interface) error { + kubeClient clientset.Interface) (*v1.PersistentVolumeClaim, error) { return MarkFSResizeFinished(pvc, newSize, kubeClient) } @@ -194,12 +218,65 @@ func MarkResizeFinished( func MarkFSResizeFinished( pvc *v1.PersistentVolumeClaim, newSize resource.Quantity, - kubeClient clientset.Interface) error { + kubeClient clientset.Interface) (*v1.PersistentVolumeClaim, error) { newPVC := pvc.DeepCopy() + newPVC.Status.Capacity[v1.ResourceStorage] = newSize + + // if RecoverVolumeExpansionFailure is enabled, we need to reset ResizeStatus back to nil + if utilfeature.DefaultFeatureGate.Enabled(features.RecoverVolumeExpansionFailure) { + expansionFinished := v1.PersistentVolumeClaimNoExpansionInProgress + newPVC.Status.ResizeStatus = &expansionFinished + } + newPVC = MergeResizeConditionOnPVC(newPVC, []v1.PersistentVolumeClaimCondition{}) - _, err := PatchPVCStatus(pvc /*oldPVC*/, newPVC, kubeClient) - return err + updatedPVC, err := PatchPVCStatus(pvc /*oldPVC*/, newPVC, kubeClient) + return updatedPVC, err +} + +func MarkControllerExpansionFailed(pvc *v1.PersistentVolumeClaim, kubeClient clientset.Interface) (*v1.PersistentVolumeClaim, error) { + expansionFailedOnController := v1.PersistentVolumeClaimControllerExpansionFailed + newPVC := pvc.DeepCopy() + newPVC.Status.ResizeStatus = &expansionFailedOnController + patchBytes, err := createPVCPatch(pvc, newPVC, false /* addResourceVersionCheck */) + if err != nil { + return pvc, fmt.Errorf("patchPVCStatus failed to patch PVC %q: %v", pvc.Name, err) + } + + updatedClaim, updateErr := kubeClient.CoreV1().PersistentVolumeClaims(pvc.Namespace). + Patch(context.TODO(), pvc.Name, types.StrategicMergePatchType, patchBytes, metav1.PatchOptions{}, "status") + if updateErr != nil { + return pvc, fmt.Errorf("patchPVCStatus failed to patch PVC %q: %v", pvc.Name, updateErr) + } + return updatedClaim, nil +} + +// MarkNodeExpansionFailed marks a PVC for node expansion as failed. Kubelet should not retry expansion +// of volumes which are in failed state. +func MarkNodeExpansionFailed(pvc *v1.PersistentVolumeClaim, kubeClient clientset.Interface) (*v1.PersistentVolumeClaim, error) { + expansionFailedOnNode := v1.PersistentVolumeClaimNodeExpansionFailed + newPVC := pvc.DeepCopy() + newPVC.Status.ResizeStatus = &expansionFailedOnNode + patchBytes, err := createPVCPatch(pvc, newPVC, false /* addResourceVersionCheck */) + if err != nil { + return pvc, fmt.Errorf("patchPVCStatus failed to patch PVC %q: %v", pvc.Name, err) + } + + updatedClaim, updateErr := kubeClient.CoreV1().PersistentVolumeClaims(pvc.Namespace). + Patch(context.TODO(), pvc.Name, types.StrategicMergePatchType, patchBytes, metav1.PatchOptions{}, "status") + if updateErr != nil { + return pvc, fmt.Errorf("patchPVCStatus failed to patch PVC %q: %v", pvc.Name, updateErr) + } + return updatedClaim, nil +} + +// MarkNodeExpansionInProgress marks pvc expansion in progress on node +func MarkNodeExpansionInProgress(pvc *v1.PersistentVolumeClaim, kubeClient clientset.Interface) (*v1.PersistentVolumeClaim, error) { + nodeExpansionInProgress := v1.PersistentVolumeClaimNodeExpansionInProgress + newPVC := pvc.DeepCopy() + newPVC.Status.ResizeStatus = &nodeExpansionInProgress + updatedPVC, err := PatchPVCStatus(pvc /* oldPVC */, newPVC, kubeClient) + return updatedPVC, err } // PatchPVCStatus updates PVC status using PATCH verb @@ -210,22 +287,22 @@ func PatchPVCStatus( oldPVC *v1.PersistentVolumeClaim, newPVC *v1.PersistentVolumeClaim, kubeClient clientset.Interface) (*v1.PersistentVolumeClaim, error) { - patchBytes, err := createPVCPatch(oldPVC, newPVC) + patchBytes, err := createPVCPatch(oldPVC, newPVC, true /* addResourceVersionCheck */) if err != nil { - return nil, fmt.Errorf("patchPVCStatus failed to patch PVC %q: %v", oldPVC.Name, err) + return oldPVC, fmt.Errorf("patchPVCStatus failed to patch PVC %q: %v", oldPVC.Name, err) } updatedClaim, updateErr := kubeClient.CoreV1().PersistentVolumeClaims(oldPVC.Namespace). Patch(context.TODO(), oldPVC.Name, types.StrategicMergePatchType, patchBytes, metav1.PatchOptions{}, "status") if updateErr != nil { - return nil, fmt.Errorf("patchPVCStatus failed to patch PVC %q: %v", oldPVC.Name, updateErr) + return oldPVC, fmt.Errorf("patchPVCStatus failed to patch PVC %q: %v", oldPVC.Name, updateErr) } return updatedClaim, nil } func createPVCPatch( oldPVC *v1.PersistentVolumeClaim, - newPVC *v1.PersistentVolumeClaim) ([]byte, error) { + newPVC *v1.PersistentVolumeClaim, addResourceVersionCheck bool) ([]byte, error) { oldData, err := json.Marshal(oldPVC) if err != nil { return nil, fmt.Errorf("failed to marshal old data: %v", err) @@ -241,9 +318,11 @@ func createPVCPatch( return nil, fmt.Errorf("failed to create 2 way merge patch: %v", err) } - patchBytes, err = addResourceVersion(patchBytes, oldPVC.ResourceVersion) - if err != nil { - return nil, fmt.Errorf("failed to add resource version: %v", err) + if addResourceVersionCheck { + patchBytes, err = addResourceVersion(patchBytes, oldPVC.ResourceVersion) + if err != nil { + return nil, fmt.Errorf("failed to add resource version: %v", err) + } } return patchBytes, nil diff --git a/pkg/volume/util/resize_util_test.go b/pkg/volume/util/resize_util_test.go index ee5fd46c9ed5..912673d1bc77 100644 --- a/pkg/volume/util/resize_util_test.go +++ b/pkg/volume/util/resize_util_test.go @@ -155,7 +155,7 @@ func TestCreatePVCPatch(t *testing.T) { pvc2.Status.Capacity = v1.ResourceList{ v1.ResourceName("size"): resource.MustParse("10G"), } - patchBytes, err := createPVCPatch(pvc1, pvc2) + patchBytes, err := createPVCPatch(pvc1, pvc2, true /* addResourceVersionCheck */) if err != nil { t.Errorf("error creating patch bytes %v", err) } diff --git a/staging/src/k8s.io/api/core/v1/generated.pb.go b/staging/src/k8s.io/api/core/v1/generated.pb.go index b4db26bb7960..4878881fdd0b 100644 --- a/staging/src/k8s.io/api/core/v1/generated.pb.go +++ b/staging/src/k8s.io/api/core/v1/generated.pb.go @@ -6027,6 +6027,7 @@ func init() { proto.RegisterType((*PersistentVolumeClaimList)(nil), "k8s.io.api.core.v1.PersistentVolumeClaimList") proto.RegisterType((*PersistentVolumeClaimSpec)(nil), "k8s.io.api.core.v1.PersistentVolumeClaimSpec") proto.RegisterType((*PersistentVolumeClaimStatus)(nil), "k8s.io.api.core.v1.PersistentVolumeClaimStatus") + proto.RegisterMapType((ResourceList)(nil), "k8s.io.api.core.v1.PersistentVolumeClaimStatus.AllocatedResourcesEntry") proto.RegisterMapType((ResourceList)(nil), "k8s.io.api.core.v1.PersistentVolumeClaimStatus.CapacityEntry") proto.RegisterType((*PersistentVolumeClaimTemplate)(nil), "k8s.io.api.core.v1.PersistentVolumeClaimTemplate") proto.RegisterType((*PersistentVolumeClaimVolumeSource)(nil), "k8s.io.api.core.v1.PersistentVolumeClaimVolumeSource") @@ -6145,890 +6146,895 @@ func init() { } var fileDescriptor_83c10c24ec417dc9 = []byte{ - // 14118 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0xbd, 0x79, 0x70, 0x1c, 0xd9, - 0x79, 0x18, 0xae, 0x9e, 0xc1, 0x35, 0x1f, 0xee, 0x07, 0x92, 0x0b, 0x62, 0x97, 0x04, 0xb7, 0x57, - 0xe2, 0x72, 0xb5, 0xbb, 0xa0, 0xb8, 0x87, 0xb4, 0xde, 0x95, 0xd6, 0x02, 0x30, 0x00, 0x39, 0x4b, - 0x02, 0x9c, 0x7d, 0x03, 0x92, 0x92, 0xbc, 0x52, 0xa9, 0x31, 0xf3, 0x00, 0xb4, 0x30, 0xd3, 0x3d, - 0xdb, 0xdd, 0x03, 0x12, 0xfb, 0x93, 0xeb, 0xe7, 0xc8, 0xa7, 0x7c, 0xa4, 0x54, 0x29, 0xe7, 0x28, - 0xc9, 0xe5, 0x4a, 0x39, 0x4e, 0xd9, 0x8a, 0x72, 0x39, 0x76, 0x6c, 0xc7, 0x72, 0x62, 0xe7, 0x76, - 0xf2, 0x87, 0xed, 0xb8, 0x12, 0xcb, 0x55, 0xae, 0x20, 0x36, 0x9d, 0x2a, 0x47, 0x55, 0x89, 0xed, - 0xc4, 0xc9, 0x1f, 0x41, 0x5c, 0x71, 0xea, 0x9d, 0xfd, 0x5e, 0x1f, 0x33, 0x03, 0x2e, 0x08, 0xad, - 0x54, 0xfb, 0xdf, 0xcc, 0xfb, 0xbe, 0xf7, 0xbd, 0xd7, 0xef, 0xfc, 0xde, 0x77, 0xc2, 0x2b, 0xbb, - 0x2f, 0x85, 0x0b, 0xae, 0x7f, 0x79, 0xb7, 0xb3, 0x49, 0x02, 0x8f, 0x44, 0x24, 0xbc, 0xbc, 0x47, - 0xbc, 0x86, 0x1f, 0x5c, 0x16, 0x00, 0xa7, 0xed, 0x5e, 0xae, 0xfb, 0x01, 0xb9, 0xbc, 0x77, 0xe5, - 0xf2, 0x36, 0xf1, 0x48, 0xe0, 0x44, 0xa4, 0xb1, 0xd0, 0x0e, 0xfc, 0xc8, 0x47, 0x88, 0xe3, 0x2c, - 0x38, 0x6d, 0x77, 0x81, 0xe2, 0x2c, 0xec, 0x5d, 0x99, 0x7b, 0x76, 0xdb, 0x8d, 0x76, 0x3a, 0x9b, - 0x0b, 0x75, 0xbf, 0x75, 0x79, 0xdb, 0xdf, 0xf6, 0x2f, 0x33, 0xd4, 0xcd, 0xce, 0x16, 0xfb, 0xc7, - 0xfe, 0xb0, 0x5f, 0x9c, 0xc4, 0xdc, 0x0b, 0x71, 0x33, 0x2d, 0xa7, 0xbe, 0xe3, 0x7a, 0x24, 0xd8, - 0xbf, 0xdc, 0xde, 0xdd, 0x66, 0xed, 0x06, 0x24, 0xf4, 0x3b, 0x41, 0x9d, 0x24, 0x1b, 0xee, 0x5a, - 0x2b, 0xbc, 0xdc, 0x22, 0x91, 0x93, 0xd1, 0xdd, 0xb9, 0xcb, 0x79, 0xb5, 0x82, 0x8e, 0x17, 0xb9, - 0xad, 0x74, 0x33, 0x1f, 0xec, 0x55, 0x21, 0xac, 0xef, 0x90, 0x96, 0x93, 0xaa, 0xf7, 0x7c, 0x5e, - 0xbd, 0x4e, 0xe4, 0x36, 0x2f, 0xbb, 0x5e, 0x14, 0x46, 0x41, 0xb2, 0x92, 0xfd, 0x35, 0x0b, 0x2e, - 0x2c, 0xde, 0xa9, 0xad, 0x34, 0x9d, 0x30, 0x72, 0xeb, 0x4b, 0x4d, 0xbf, 0xbe, 0x5b, 0x8b, 0xfc, - 0x80, 0xdc, 0xf6, 0x9b, 0x9d, 0x16, 0xa9, 0xb1, 0x81, 0x40, 0xcf, 0xc0, 0xc8, 0x1e, 0xfb, 0x5f, - 0x29, 0xcf, 0x5a, 0x17, 0xac, 0x4b, 0xa5, 0xa5, 0xa9, 0x5f, 0x3b, 0x98, 0x7f, 0xcf, 0xfd, 0x83, - 0xf9, 0x91, 0xdb, 0xa2, 0x1c, 0x2b, 0x0c, 0x74, 0x11, 0x86, 0xb6, 0xc2, 0x8d, 0xfd, 0x36, 0x99, - 0x2d, 0x30, 0xdc, 0x09, 0x81, 0x3b, 0xb4, 0x5a, 0xa3, 0xa5, 0x58, 0x40, 0xd1, 0x65, 0x28, 0xb5, - 0x9d, 0x20, 0x72, 0x23, 0xd7, 0xf7, 0x66, 0x8b, 0x17, 0xac, 0x4b, 0x83, 0x4b, 0xd3, 0x02, 0xb5, - 0x54, 0x95, 0x00, 0x1c, 0xe3, 0xd0, 0x6e, 0x04, 0xc4, 0x69, 0xdc, 0xf4, 0x9a, 0xfb, 0xb3, 0x03, - 0x17, 0xac, 0x4b, 0x23, 0x71, 0x37, 0xb0, 0x28, 0xc7, 0x0a, 0xc3, 0xfe, 0x62, 0x01, 0x46, 0x16, - 0xb7, 0xb6, 0x5c, 0xcf, 0x8d, 0xf6, 0xd1, 0x6d, 0x18, 0xf3, 0xfc, 0x06, 0x91, 0xff, 0xd9, 0x57, - 0x8c, 0x3e, 0x77, 0x61, 0x21, 0xbd, 0x94, 0x16, 0xd6, 0x35, 0xbc, 0xa5, 0xa9, 0xfb, 0x07, 0xf3, - 0x63, 0x7a, 0x09, 0x36, 0xe8, 0x20, 0x0c, 0xa3, 0x6d, 0xbf, 0xa1, 0xc8, 0x16, 0x18, 0xd9, 0xf9, - 0x2c, 0xb2, 0xd5, 0x18, 0x6d, 0x69, 0xf2, 0xfe, 0xc1, 0xfc, 0xa8, 0x56, 0x80, 0x75, 0x22, 0x68, - 0x13, 0x26, 0xe9, 0x5f, 0x2f, 0x72, 0x15, 0xdd, 0x22, 0xa3, 0xfb, 0x44, 0x1e, 0x5d, 0x0d, 0x75, - 0x69, 0xe6, 0xfe, 0xc1, 0xfc, 0x64, 0xa2, 0x10, 0x27, 0x09, 0xda, 0x6f, 0xc1, 0xc4, 0x62, 0x14, - 0x39, 0xf5, 0x1d, 0xd2, 0xe0, 0x33, 0x88, 0x5e, 0x80, 0x01, 0xcf, 0x69, 0x11, 0x31, 0xbf, 0x17, - 0xc4, 0xc0, 0x0e, 0xac, 0x3b, 0x2d, 0x72, 0x78, 0x30, 0x3f, 0x75, 0xcb, 0x73, 0xdf, 0xec, 0x88, - 0x55, 0x41, 0xcb, 0x30, 0xc3, 0x46, 0xcf, 0x01, 0x34, 0xc8, 0x9e, 0x5b, 0x27, 0x55, 0x27, 0xda, - 0x11, 0xf3, 0x8d, 0x44, 0x5d, 0x28, 0x2b, 0x08, 0xd6, 0xb0, 0xec, 0x7b, 0x50, 0x5a, 0xdc, 0xf3, - 0xdd, 0x46, 0xd5, 0x6f, 0x84, 0x68, 0x17, 0x26, 0xdb, 0x01, 0xd9, 0x22, 0x81, 0x2a, 0x9a, 0xb5, - 0x2e, 0x14, 0x2f, 0x8d, 0x3e, 0x77, 0x29, 0xf3, 0x63, 0x4d, 0xd4, 0x15, 0x2f, 0x0a, 0xf6, 0x97, - 0x1e, 0x11, 0xed, 0x4d, 0x26, 0xa0, 0x38, 0x49, 0xd9, 0xfe, 0x17, 0x05, 0x38, 0xbd, 0xf8, 0x56, - 0x27, 0x20, 0x65, 0x37, 0xdc, 0x4d, 0xae, 0xf0, 0x86, 0x1b, 0xee, 0xae, 0xc7, 0x23, 0xa0, 0x96, - 0x56, 0x59, 0x94, 0x63, 0x85, 0x81, 0x9e, 0x85, 0x61, 0xfa, 0xfb, 0x16, 0xae, 0x88, 0x4f, 0x9e, - 0x11, 0xc8, 0xa3, 0x65, 0x27, 0x72, 0xca, 0x1c, 0x84, 0x25, 0x0e, 0x5a, 0x83, 0xd1, 0x3a, 0xdb, - 0x90, 0xdb, 0x6b, 0x7e, 0x83, 0xb0, 0xc9, 0x2c, 0x2d, 0x3d, 0x4d, 0xd1, 0x97, 0xe3, 0xe2, 0xc3, - 0x83, 0xf9, 0x59, 0xde, 0x37, 0x41, 0x42, 0x83, 0x61, 0xbd, 0x3e, 0xb2, 0xd5, 0xfe, 0x1a, 0x60, - 0x94, 0x20, 0x63, 0x6f, 0x5d, 0xd2, 0xb6, 0xca, 0x20, 0xdb, 0x2a, 0x63, 0xd9, 0xdb, 0x04, 0x5d, - 0x81, 0x81, 0x5d, 0xd7, 0x6b, 0xcc, 0x0e, 0x31, 0x5a, 0xe7, 0xe8, 0x9c, 0x5f, 0x77, 0xbd, 0xc6, - 0xe1, 0xc1, 0xfc, 0xb4, 0xd1, 0x1d, 0x5a, 0x88, 0x19, 0xaa, 0xfd, 0xa7, 0x16, 0xcc, 0x33, 0xd8, - 0xaa, 0xdb, 0x24, 0x55, 0x12, 0x84, 0x6e, 0x18, 0x11, 0x2f, 0x32, 0x06, 0xf4, 0x39, 0x80, 0x90, - 0xd4, 0x03, 0x12, 0x69, 0x43, 0xaa, 0x16, 0x46, 0x4d, 0x41, 0xb0, 0x86, 0x45, 0x0f, 0x84, 0x70, - 0xc7, 0x09, 0xd8, 0xfa, 0x12, 0x03, 0xab, 0x0e, 0x84, 0x9a, 0x04, 0xe0, 0x18, 0xc7, 0x38, 0x10, - 0x8a, 0xbd, 0x0e, 0x04, 0xf4, 0x11, 0x98, 0x8c, 0x1b, 0x0b, 0xdb, 0x4e, 0x5d, 0x0e, 0x20, 0xdb, - 0x32, 0x35, 0x13, 0x84, 0x93, 0xb8, 0xf6, 0xdf, 0xb2, 0xc4, 0xe2, 0xa1, 0x5f, 0xfd, 0x0e, 0xff, - 0x56, 0xfb, 0x17, 0x2d, 0x18, 0x5e, 0x72, 0xbd, 0x86, 0xeb, 0x6d, 0xa3, 0x4f, 0xc3, 0x08, 0xbd, - 0x9b, 0x1a, 0x4e, 0xe4, 0x88, 0x73, 0xef, 0x03, 0xda, 0xde, 0x52, 0x57, 0xc5, 0x42, 0x7b, 0x77, - 0x9b, 0x16, 0x84, 0x0b, 0x14, 0x9b, 0xee, 0xb6, 0x9b, 0x9b, 0x9f, 0x21, 0xf5, 0x68, 0x8d, 0x44, - 0x4e, 0xfc, 0x39, 0x71, 0x19, 0x56, 0x54, 0xd1, 0x75, 0x18, 0x8a, 0x9c, 0x60, 0x9b, 0x44, 0xe2, - 0x00, 0xcc, 0x3c, 0xa8, 0x78, 0x4d, 0x4c, 0x77, 0x24, 0xf1, 0xea, 0x24, 0xbe, 0x16, 0x36, 0x58, - 0x55, 0x2c, 0x48, 0xd8, 0x3f, 0x32, 0x0c, 0x67, 0x97, 0x6b, 0x95, 0x9c, 0x75, 0x75, 0x11, 0x86, - 0x1a, 0x81, 0xbb, 0x47, 0x02, 0x31, 0xce, 0x8a, 0x4a, 0x99, 0x95, 0x62, 0x01, 0x45, 0x2f, 0xc1, - 0x18, 0xbf, 0x90, 0xae, 0x39, 0x5e, 0xa3, 0x29, 0x87, 0xf8, 0x94, 0xc0, 0x1e, 0xbb, 0xad, 0xc1, - 0xb0, 0x81, 0x79, 0xc4, 0x45, 0x75, 0x31, 0xb1, 0x19, 0xf3, 0x2e, 0xbb, 0xcf, 0x5b, 0x30, 0xc5, - 0x9b, 0x59, 0x8c, 0xa2, 0xc0, 0xdd, 0xec, 0x44, 0x24, 0x9c, 0x1d, 0x64, 0x27, 0xdd, 0x72, 0xd6, - 0x68, 0xe5, 0x8e, 0xc0, 0xc2, 0xed, 0x04, 0x15, 0x7e, 0x08, 0xce, 0x8a, 0x76, 0xa7, 0x92, 0x60, - 0x9c, 0x6a, 0x16, 0x7d, 0xb7, 0x05, 0x73, 0x75, 0xdf, 0x8b, 0x02, 0xbf, 0xd9, 0x24, 0x41, 0xb5, - 0xb3, 0xd9, 0x74, 0xc3, 0x1d, 0xbe, 0x4e, 0x31, 0xd9, 0x62, 0x27, 0x41, 0xce, 0x1c, 0x2a, 0x24, - 0x31, 0x87, 0xe7, 0xef, 0x1f, 0xcc, 0xcf, 0x2d, 0xe7, 0x92, 0xc2, 0x5d, 0x9a, 0x41, 0xbb, 0x80, - 0xe8, 0x55, 0x5a, 0x8b, 0x9c, 0x6d, 0x12, 0x37, 0x3e, 0xdc, 0x7f, 0xe3, 0x67, 0xee, 0x1f, 0xcc, - 0xa3, 0xf5, 0x14, 0x09, 0x9c, 0x41, 0x16, 0xbd, 0x09, 0xa7, 0x68, 0x69, 0xea, 0x5b, 0x47, 0xfa, - 0x6f, 0x6e, 0xf6, 0xfe, 0xc1, 0xfc, 0xa9, 0xf5, 0x0c, 0x22, 0x38, 0x93, 0x34, 0xfa, 0x2e, 0x0b, - 0xce, 0xc6, 0x9f, 0xbf, 0x72, 0xaf, 0xed, 0x78, 0x8d, 0xb8, 0xe1, 0x52, 0xff, 0x0d, 0xd3, 0x33, - 0xf9, 0xec, 0x72, 0x1e, 0x25, 0x9c, 0xdf, 0xc8, 0xdc, 0x32, 0x9c, 0xce, 0x5c, 0x2d, 0x68, 0x0a, - 0x8a, 0xbb, 0x84, 0x73, 0x41, 0x25, 0x4c, 0x7f, 0xa2, 0x53, 0x30, 0xb8, 0xe7, 0x34, 0x3b, 0x62, - 0xa3, 0x60, 0xfe, 0xe7, 0xe5, 0xc2, 0x4b, 0x96, 0xfd, 0x2f, 0x8b, 0x30, 0xb9, 0x5c, 0xab, 0x3c, - 0xd0, 0x2e, 0xd4, 0xaf, 0xa1, 0x42, 0xd7, 0x6b, 0x28, 0xbe, 0xd4, 0x8a, 0xb9, 0x97, 0xda, 0xff, - 0x9f, 0xb1, 0x85, 0x06, 0xd8, 0x16, 0xfa, 0xb6, 0x9c, 0x2d, 0x74, 0xcc, 0x1b, 0x67, 0x2f, 0x67, - 0x15, 0x0d, 0xb2, 0xc9, 0xcc, 0xe4, 0x58, 0x6e, 0xf8, 0x75, 0xa7, 0x99, 0x3c, 0xfa, 0x8e, 0xb8, - 0x94, 0x8e, 0x67, 0x1e, 0xeb, 0x30, 0xb6, 0xec, 0xb4, 0x9d, 0x4d, 0xb7, 0xe9, 0x46, 0x2e, 0x09, - 0xd1, 0x93, 0x50, 0x74, 0x1a, 0x0d, 0xc6, 0x6d, 0x95, 0x96, 0x4e, 0xdf, 0x3f, 0x98, 0x2f, 0x2e, - 0x36, 0xe8, 0xb5, 0x0f, 0x0a, 0x6b, 0x1f, 0x53, 0x0c, 0xf4, 0x7e, 0x18, 0x68, 0x04, 0x7e, 0x7b, - 0xb6, 0xc0, 0x30, 0xe9, 0xae, 0x1b, 0x28, 0x07, 0x7e, 0x3b, 0x81, 0xca, 0x70, 0xec, 0x5f, 0x2d, - 0xc0, 0x63, 0xcb, 0xa4, 0xbd, 0xb3, 0x5a, 0xcb, 0x39, 0xbf, 0x2f, 0xc1, 0x48, 0xcb, 0xf7, 0xdc, - 0xc8, 0x0f, 0x42, 0xd1, 0x34, 0x5b, 0x11, 0x6b, 0xa2, 0x0c, 0x2b, 0x28, 0xba, 0x00, 0x03, 0xed, - 0x98, 0xa9, 0x1c, 0x93, 0x0c, 0x29, 0x63, 0x27, 0x19, 0x84, 0x62, 0x74, 0x42, 0x12, 0x88, 0x15, - 0xa3, 0x30, 0x6e, 0x85, 0x24, 0xc0, 0x0c, 0x12, 0xdf, 0xcc, 0xf4, 0xce, 0x16, 0x27, 0x74, 0xe2, - 0x66, 0xa6, 0x10, 0xac, 0x61, 0xa1, 0x2a, 0x94, 0xc2, 0xc4, 0xcc, 0xf6, 0xb5, 0x4d, 0xc7, 0xd9, - 0xd5, 0xad, 0x66, 0x32, 0x26, 0x62, 0xdc, 0x28, 0x43, 0x3d, 0xaf, 0xee, 0xaf, 0x16, 0x00, 0xf1, - 0x21, 0xfc, 0x26, 0x1b, 0xb8, 0x5b, 0xe9, 0x81, 0xeb, 0x7f, 0x4b, 0x1c, 0xd7, 0xe8, 0xfd, 0x4f, - 0x0b, 0x1e, 0x5b, 0x76, 0xbd, 0x06, 0x09, 0x72, 0x16, 0xe0, 0xc3, 0x79, 0xcb, 0x1e, 0x8d, 0x69, - 0x30, 0x96, 0xd8, 0xc0, 0x31, 0x2c, 0x31, 0xfb, 0x8f, 0x2d, 0x40, 0xfc, 0xb3, 0xdf, 0x71, 0x1f, - 0x7b, 0x2b, 0xfd, 0xb1, 0xc7, 0xb0, 0x2c, 0xec, 0x1b, 0x30, 0xb1, 0xdc, 0x74, 0x89, 0x17, 0x55, - 0xaa, 0xcb, 0xbe, 0xb7, 0xe5, 0x6e, 0xa3, 0x97, 0x61, 0x22, 0x72, 0x5b, 0xc4, 0xef, 0x44, 0x35, - 0x52, 0xf7, 0x3d, 0xf6, 0x92, 0xb4, 0x2e, 0x0d, 0x2e, 0xa1, 0xfb, 0x07, 0xf3, 0x13, 0x1b, 0x06, - 0x04, 0x27, 0x30, 0xed, 0xdf, 0xa5, 0xe3, 0xe7, 0xb7, 0xda, 0xbe, 0x47, 0xbc, 0x68, 0xd9, 0xf7, - 0x1a, 0x5c, 0xe2, 0xf0, 0x32, 0x0c, 0x44, 0x74, 0x3c, 0xf8, 0xd8, 0x5d, 0x94, 0x1b, 0x85, 0x8e, - 0xc2, 0xe1, 0xc1, 0xfc, 0x99, 0x74, 0x0d, 0x36, 0x4e, 0xac, 0x0e, 0xfa, 0x36, 0x18, 0x0a, 0x23, - 0x27, 0xea, 0x84, 0x62, 0x34, 0x1f, 0x97, 0xa3, 0x59, 0x63, 0xa5, 0x87, 0x07, 0xf3, 0x93, 0xaa, - 0x1a, 0x2f, 0xc2, 0xa2, 0x02, 0x7a, 0x0a, 0x86, 0x5b, 0x24, 0x0c, 0x9d, 0x6d, 0x79, 0x1b, 0x4e, - 0x8a, 0xba, 0xc3, 0x6b, 0xbc, 0x18, 0x4b, 0x38, 0x7a, 0x02, 0x06, 0x49, 0x10, 0xf8, 0x81, 0xd8, - 0xa3, 0xe3, 0x02, 0x71, 0x70, 0x85, 0x16, 0x62, 0x0e, 0xb3, 0x7f, 0xc3, 0x82, 0x49, 0xd5, 0x57, - 0xde, 0xd6, 0x09, 0xbc, 0x0a, 0x3e, 0x01, 0x50, 0x97, 0x1f, 0x18, 0xb2, 0xdb, 0x63, 0xf4, 0xb9, - 0x8b, 0x99, 0x17, 0x75, 0x6a, 0x18, 0x63, 0xca, 0xaa, 0x28, 0xc4, 0x1a, 0x35, 0xfb, 0x1f, 0x5b, - 0x30, 0x93, 0xf8, 0xa2, 0x1b, 0x6e, 0x18, 0xa1, 0x37, 0x52, 0x5f, 0xb5, 0xd0, 0xdf, 0x57, 0xd1, - 0xda, 0xec, 0x9b, 0xd4, 0x52, 0x96, 0x25, 0xda, 0x17, 0x5d, 0x83, 0x41, 0x37, 0x22, 0x2d, 0xf9, - 0x31, 0x4f, 0x74, 0xfd, 0x18, 0xde, 0xab, 0x78, 0x46, 0x2a, 0xb4, 0x26, 0xe6, 0x04, 0xec, 0x5f, - 0x2d, 0x42, 0x89, 0x2f, 0xdb, 0x35, 0xa7, 0x7d, 0x02, 0x73, 0xf1, 0x34, 0x94, 0xdc, 0x56, 0xab, - 0x13, 0x39, 0x9b, 0xe2, 0x38, 0x1f, 0xe1, 0x5b, 0xab, 0x22, 0x0b, 0x71, 0x0c, 0x47, 0x15, 0x18, - 0x60, 0x5d, 0xe1, 0x5f, 0xf9, 0x64, 0xf6, 0x57, 0x8a, 0xbe, 0x2f, 0x94, 0x9d, 0xc8, 0xe1, 0x9c, - 0x94, 0xba, 0x47, 0x68, 0x11, 0x66, 0x24, 0x90, 0x03, 0xb0, 0xe9, 0x7a, 0x4e, 0xb0, 0x4f, 0xcb, - 0x66, 0x8b, 0x8c, 0xe0, 0xb3, 0xdd, 0x09, 0x2e, 0x29, 0x7c, 0x4e, 0x56, 0x7d, 0x58, 0x0c, 0xc0, - 0x1a, 0xd1, 0xb9, 0x0f, 0x41, 0x49, 0x21, 0x1f, 0x85, 0x21, 0x9a, 0xfb, 0x08, 0x4c, 0x26, 0xda, - 0xea, 0x55, 0x7d, 0x4c, 0xe7, 0xa7, 0x7e, 0x89, 0x1d, 0x19, 0xa2, 0xd7, 0x2b, 0xde, 0x9e, 0x38, - 0x72, 0xdf, 0x82, 0x53, 0xcd, 0x8c, 0x93, 0x4c, 0xcc, 0x6b, 0xff, 0x27, 0xdf, 0x63, 0xe2, 0xb3, - 0x4f, 0x65, 0x41, 0x71, 0x66, 0x1b, 0x94, 0x47, 0xf0, 0xdb, 0x74, 0x83, 0x38, 0x4d, 0x9d, 0xdd, - 0xbe, 0x29, 0xca, 0xb0, 0x82, 0xd2, 0xf3, 0xee, 0x94, 0xea, 0xfc, 0x75, 0xb2, 0x5f, 0x23, 0x4d, - 0x52, 0x8f, 0xfc, 0xe0, 0x1b, 0xda, 0xfd, 0x73, 0x7c, 0xf4, 0xf9, 0x71, 0x39, 0x2a, 0x08, 0x14, - 0xaf, 0x93, 0x7d, 0x3e, 0x15, 0xfa, 0xd7, 0x15, 0xbb, 0x7e, 0xdd, 0xcf, 0x58, 0x30, 0xae, 0xbe, - 0xee, 0x04, 0xce, 0x85, 0x25, 0xf3, 0x5c, 0x38, 0xd7, 0x75, 0x81, 0xe7, 0x9c, 0x08, 0x5f, 0x2d, - 0xc0, 0x59, 0x85, 0x43, 0xdf, 0x06, 0xfc, 0x8f, 0x58, 0x55, 0x97, 0xa1, 0xe4, 0x29, 0xa9, 0x95, - 0x65, 0x8a, 0x8b, 0x62, 0x99, 0x55, 0x8c, 0x43, 0x59, 0x3c, 0x2f, 0x16, 0x2d, 0x8d, 0xe9, 0xe2, - 0x5c, 0x21, 0xba, 0x5d, 0x82, 0x62, 0xc7, 0x6d, 0x88, 0x0b, 0xe6, 0x03, 0x72, 0xb4, 0x6f, 0x55, - 0xca, 0x87, 0x07, 0xf3, 0x8f, 0xe7, 0xa9, 0x12, 0xe8, 0xcd, 0x16, 0x2e, 0xdc, 0xaa, 0x94, 0x31, - 0xad, 0x8c, 0x16, 0x61, 0x52, 0x6a, 0x4b, 0x6e, 0x53, 0x76, 0xcb, 0xf7, 0xc4, 0x3d, 0xa4, 0x64, - 0xb2, 0xd8, 0x04, 0xe3, 0x24, 0x3e, 0x2a, 0xc3, 0xd4, 0x6e, 0x67, 0x93, 0x34, 0x49, 0xc4, 0x3f, - 0xf8, 0x3a, 0xe1, 0x12, 0xcb, 0x52, 0xfc, 0x32, 0xbb, 0x9e, 0x80, 0xe3, 0x54, 0x0d, 0xfb, 0xcf, - 0xd9, 0x7d, 0x20, 0x46, 0xaf, 0x1a, 0xf8, 0x74, 0x61, 0x51, 0xea, 0xdf, 0xc8, 0xe5, 0xdc, 0xcf, - 0xaa, 0xb8, 0x4e, 0xf6, 0x37, 0x7c, 0xca, 0x99, 0x67, 0xaf, 0x0a, 0x63, 0xcd, 0x0f, 0x74, 0x5d, - 0xf3, 0x3f, 0x57, 0x80, 0xd3, 0x6a, 0x04, 0x0c, 0x26, 0xf0, 0x9b, 0x7d, 0x0c, 0xae, 0xc0, 0x68, - 0x83, 0x6c, 0x39, 0x9d, 0x66, 0xa4, 0xc4, 0xe7, 0x83, 0x5c, 0x85, 0x52, 0x8e, 0x8b, 0xb1, 0x8e, - 0x73, 0x84, 0x61, 0xfb, 0x5f, 0xa3, 0xec, 0x22, 0x8e, 0x1c, 0xba, 0xc6, 0xd5, 0xae, 0xb1, 0x72, - 0x77, 0xcd, 0x13, 0x30, 0xe8, 0xb6, 0x28, 0x63, 0x56, 0x30, 0xf9, 0xad, 0x0a, 0x2d, 0xc4, 0x1c, - 0x86, 0xde, 0x07, 0xc3, 0x75, 0xbf, 0xd5, 0x72, 0xbc, 0x06, 0xbb, 0xf2, 0x4a, 0x4b, 0xa3, 0x94, - 0x77, 0x5b, 0xe6, 0x45, 0x58, 0xc2, 0xd0, 0x63, 0x30, 0xe0, 0x04, 0xdb, 0x5c, 0x86, 0x51, 0x5a, - 0x1a, 0xa1, 0x2d, 0x2d, 0x06, 0xdb, 0x21, 0x66, 0xa5, 0xf4, 0x09, 0x76, 0xd7, 0x0f, 0x76, 0x5d, - 0x6f, 0xbb, 0xec, 0x06, 0x62, 0x4b, 0xa8, 0xbb, 0xf0, 0x8e, 0x82, 0x60, 0x0d, 0x0b, 0xad, 0xc2, - 0x60, 0xdb, 0x0f, 0xa2, 0x70, 0x76, 0x88, 0x0d, 0xf7, 0xe3, 0x39, 0x07, 0x11, 0xff, 0xda, 0xaa, - 0x1f, 0x44, 0xf1, 0x07, 0xd0, 0x7f, 0x21, 0xe6, 0xd5, 0xd1, 0x0d, 0x18, 0x26, 0xde, 0xde, 0x6a, - 0xe0, 0xb7, 0x66, 0x67, 0xf2, 0x29, 0xad, 0x70, 0x14, 0xbe, 0xcc, 0x62, 0x1e, 0x55, 0x14, 0x63, - 0x49, 0x02, 0x7d, 0x1b, 0x14, 0x89, 0xb7, 0x37, 0x3b, 0xcc, 0x28, 0xcd, 0xe5, 0x50, 0xba, 0xed, - 0x04, 0xf1, 0x99, 0xbf, 0xe2, 0xed, 0x61, 0x5a, 0x07, 0x7d, 0x1c, 0x4a, 0xf2, 0xc0, 0x08, 0x85, - 0xb0, 0x2e, 0x73, 0xc1, 0xca, 0x63, 0x06, 0x93, 0x37, 0x3b, 0x6e, 0x40, 0x5a, 0xc4, 0x8b, 0xc2, - 0xf8, 0x84, 0x94, 0xd0, 0x10, 0xc7, 0xd4, 0xd0, 0xc7, 0xa5, 0x84, 0x78, 0xcd, 0xef, 0x78, 0x51, - 0x38, 0x5b, 0x62, 0xdd, 0xcb, 0xd4, 0xdd, 0xdd, 0x8e, 0xf1, 0x92, 0x22, 0x64, 0x5e, 0x19, 0x1b, - 0xa4, 0xd0, 0x27, 0x61, 0x9c, 0xff, 0xe7, 0x1a, 0xb0, 0x70, 0xf6, 0x34, 0xa3, 0x7d, 0x21, 0x9f, - 0x36, 0x47, 0x5c, 0x3a, 0x2d, 0x88, 0x8f, 0xeb, 0xa5, 0x21, 0x36, 0xa9, 0x21, 0x0c, 0xe3, 0x4d, - 0x77, 0x8f, 0x78, 0x24, 0x0c, 0xab, 0x81, 0xbf, 0x49, 0x66, 0x81, 0x0d, 0xcc, 0xd9, 0x6c, 0x8d, - 0x99, 0xbf, 0x49, 0x96, 0xa6, 0x29, 0xcd, 0x1b, 0x7a, 0x1d, 0x6c, 0x92, 0x40, 0xb7, 0x60, 0x82, - 0xbe, 0xd8, 0xdc, 0x98, 0xe8, 0x68, 0x2f, 0xa2, 0xec, 0x5d, 0x85, 0x8d, 0x4a, 0x38, 0x41, 0x04, - 0xdd, 0x84, 0xb1, 0x30, 0x72, 0x82, 0xa8, 0xd3, 0xe6, 0x44, 0xcf, 0xf4, 0x22, 0xca, 0x14, 0xae, - 0x35, 0xad, 0x0a, 0x36, 0x08, 0xa0, 0xd7, 0xa0, 0xd4, 0x74, 0xb7, 0x48, 0x7d, 0xbf, 0xde, 0x24, - 0xb3, 0x63, 0x8c, 0x5a, 0xe6, 0xa1, 0x72, 0x43, 0x22, 0x71, 0x3e, 0x57, 0xfd, 0xc5, 0x71, 0x75, - 0x74, 0x1b, 0xce, 0x44, 0x24, 0x68, 0xb9, 0x9e, 0x43, 0x0f, 0x03, 0xf1, 0xb4, 0x62, 0x8a, 0xcc, - 0x71, 0xb6, 0xdb, 0xce, 0x8b, 0xd9, 0x38, 0xb3, 0x91, 0x89, 0x85, 0x73, 0x6a, 0xa3, 0x7b, 0x30, - 0x9b, 0x01, 0xf1, 0x9b, 0x6e, 0x7d, 0x7f, 0xf6, 0x14, 0xa3, 0xfc, 0x61, 0x41, 0x79, 0x76, 0x23, - 0x07, 0xef, 0xb0, 0x0b, 0x0c, 0xe7, 0x52, 0x47, 0x37, 0x61, 0x92, 0x9d, 0x40, 0xd5, 0x4e, 0xb3, - 0x29, 0x1a, 0x9c, 0x60, 0x0d, 0xbe, 0x4f, 0xde, 0xc7, 0x15, 0x13, 0x7c, 0x78, 0x30, 0x0f, 0xf1, - 0x3f, 0x9c, 0xac, 0x8d, 0x36, 0x99, 0xce, 0xac, 0x13, 0xb8, 0xd1, 0x3e, 0x3d, 0x37, 0xc8, 0xbd, - 0x68, 0x76, 0xb2, 0xab, 0xbc, 0x42, 0x47, 0x55, 0x8a, 0x35, 0xbd, 0x10, 0x27, 0x09, 0xd2, 0x23, - 0x35, 0x8c, 0x1a, 0xae, 0x37, 0x3b, 0xc5, 0xdf, 0x25, 0xf2, 0x44, 0xaa, 0xd1, 0x42, 0xcc, 0x61, - 0x4c, 0x5f, 0x46, 0x7f, 0xdc, 0xa4, 0x37, 0xd7, 0x34, 0x43, 0x8c, 0xf5, 0x65, 0x12, 0x80, 0x63, - 0x1c, 0xca, 0x4c, 0x46, 0xd1, 0xfe, 0x2c, 0x62, 0xa8, 0xea, 0x60, 0xd9, 0xd8, 0xf8, 0x38, 0xa6, - 0xe5, 0xf6, 0x26, 0x4c, 0xa8, 0x83, 0x90, 0x8d, 0x09, 0x9a, 0x87, 0x41, 0xc6, 0x3e, 0x09, 0xe9, - 0x5a, 0x89, 0x76, 0x81, 0xb1, 0x56, 0x98, 0x97, 0xb3, 0x2e, 0xb8, 0x6f, 0x91, 0xa5, 0xfd, 0x88, - 0xf0, 0x37, 0x7d, 0x51, 0xeb, 0x82, 0x04, 0xe0, 0x18, 0xc7, 0xfe, 0xbf, 0x9c, 0x0d, 0x8d, 0x4f, - 0xdb, 0x3e, 0xee, 0x97, 0x67, 0x60, 0x64, 0xc7, 0x0f, 0x23, 0x8a, 0xcd, 0xda, 0x18, 0x8c, 0x19, - 0xcf, 0x6b, 0xa2, 0x1c, 0x2b, 0x0c, 0xf4, 0x0a, 0x8c, 0xd7, 0xf5, 0x06, 0xc4, 0xe5, 0xa8, 0x8e, - 0x11, 0xa3, 0x75, 0x6c, 0xe2, 0xa2, 0x97, 0x60, 0x84, 0xd9, 0x80, 0xd4, 0xfd, 0xa6, 0xe0, 0xda, - 0xe4, 0x0d, 0x3f, 0x52, 0x15, 0xe5, 0x87, 0xda, 0x6f, 0xac, 0xb0, 0xd1, 0x45, 0x18, 0xa2, 0x5d, - 0xa8, 0x54, 0xc5, 0xb5, 0xa4, 0x04, 0x45, 0xd7, 0x58, 0x29, 0x16, 0x50, 0xfb, 0x2f, 0x15, 0xb4, - 0x51, 0xa6, 0xef, 0x61, 0x82, 0xaa, 0x30, 0x7c, 0xd7, 0x71, 0x23, 0xd7, 0xdb, 0x16, 0xfc, 0xc7, - 0x53, 0x5d, 0xef, 0x28, 0x56, 0xe9, 0x0e, 0xaf, 0xc0, 0x6f, 0x51, 0xf1, 0x07, 0x4b, 0x32, 0x94, - 0x62, 0xd0, 0xf1, 0x3c, 0x4a, 0xb1, 0xd0, 0x2f, 0x45, 0xcc, 0x2b, 0x70, 0x8a, 0xe2, 0x0f, 0x96, - 0x64, 0xd0, 0x1b, 0x00, 0x72, 0x87, 0x91, 0x86, 0xb0, 0xbd, 0x78, 0xa6, 0x37, 0xd1, 0x0d, 0x55, - 0x67, 0x69, 0x82, 0xde, 0xd1, 0xf1, 0x7f, 0xac, 0xd1, 0xb3, 0x23, 0xc6, 0xa7, 0xa5, 0x3b, 0x83, - 0xbe, 0x83, 0x2e, 0x71, 0x27, 0x88, 0x48, 0x63, 0x31, 0x12, 0x83, 0xf3, 0xfe, 0xfe, 0x1e, 0x29, - 0x1b, 0x6e, 0x8b, 0xe8, 0xdb, 0x41, 0x10, 0xc1, 0x31, 0x3d, 0xfb, 0x17, 0x8a, 0x30, 0x9b, 0xd7, - 0x5d, 0xba, 0xe8, 0xc8, 0x3d, 0x37, 0x5a, 0xa6, 0xec, 0x95, 0x65, 0x2e, 0xba, 0x15, 0x51, 0x8e, - 0x15, 0x06, 0x9d, 0xfd, 0xd0, 0xdd, 0x96, 0x6f, 0xcc, 0xc1, 0x78, 0xf6, 0x6b, 0xac, 0x14, 0x0b, - 0x28, 0xc5, 0x0b, 0x88, 0x13, 0x0a, 0xe3, 0x1e, 0x6d, 0x95, 0x60, 0x56, 0x8a, 0x05, 0x54, 0x97, - 0x76, 0x0d, 0xf4, 0x90, 0x76, 0x19, 0x43, 0x34, 0x78, 0xbc, 0x43, 0x84, 0x3e, 0x05, 0xb0, 0xe5, - 0x7a, 0x6e, 0xb8, 0xc3, 0xa8, 0x0f, 0x1d, 0x99, 0xba, 0x62, 0xce, 0x56, 0x15, 0x15, 0xac, 0x51, - 0x44, 0x2f, 0xc2, 0xa8, 0xda, 0x80, 0x95, 0x32, 0xd3, 0x74, 0x6a, 0x96, 0x23, 0xf1, 0x69, 0x54, - 0xc6, 0x3a, 0x9e, 0xfd, 0x99, 0xe4, 0x7a, 0x11, 0x3b, 0x40, 0x1b, 0x5f, 0xab, 0xdf, 0xf1, 0x2d, - 0x74, 0x1f, 0x5f, 0xfb, 0xeb, 0x45, 0x98, 0x34, 0x1a, 0xeb, 0x84, 0x7d, 0x9c, 0x59, 0x57, 0xe9, - 0x01, 0xee, 0x44, 0x44, 0xec, 0x3f, 0xbb, 0xf7, 0x56, 0xd1, 0x0f, 0x79, 0xba, 0x03, 0x78, 0x7d, - 0xf4, 0x29, 0x28, 0x35, 0x9d, 0x90, 0x49, 0xce, 0x88, 0xd8, 0x77, 0xfd, 0x10, 0x8b, 0x1f, 0x26, - 0x4e, 0x18, 0x69, 0xb7, 0x26, 0xa7, 0x1d, 0x93, 0xa4, 0x37, 0x0d, 0xe5, 0x4f, 0xa4, 0xf5, 0x98, - 0xea, 0x04, 0x65, 0x62, 0xf6, 0x31, 0x87, 0xa1, 0x97, 0x60, 0x2c, 0x20, 0x6c, 0x55, 0x2c, 0x53, - 0x6e, 0x8e, 0x2d, 0xb3, 0xc1, 0x98, 0xed, 0xc3, 0x1a, 0x0c, 0x1b, 0x98, 0xf1, 0xdb, 0x60, 0xa8, - 0xcb, 0xdb, 0xe0, 0x29, 0x18, 0x66, 0x3f, 0xd4, 0x0a, 0x50, 0xb3, 0x51, 0xe1, 0xc5, 0x58, 0xc2, - 0x93, 0x0b, 0x66, 0xa4, 0xbf, 0x05, 0x43, 0x5f, 0x1f, 0x62, 0x51, 0x33, 0x2d, 0xf3, 0x08, 0x3f, - 0xe5, 0xc4, 0x92, 0xc7, 0x12, 0x66, 0xbf, 0x1f, 0x26, 0xca, 0x0e, 0x69, 0xf9, 0xde, 0x8a, 0xd7, - 0x68, 0xfb, 0xae, 0x17, 0xa1, 0x59, 0x18, 0x60, 0x97, 0x08, 0x3f, 0x02, 0x06, 0x68, 0x43, 0x98, - 0x95, 0xd8, 0xdb, 0x70, 0xba, 0xec, 0xdf, 0xf5, 0xee, 0x3a, 0x41, 0x63, 0xb1, 0x5a, 0xd1, 0xde, - 0xd7, 0xeb, 0xf2, 0x7d, 0xc7, 0x8d, 0xb6, 0x32, 0x8f, 0x5e, 0xad, 0x26, 0x67, 0x6b, 0x57, 0xdd, - 0x26, 0xc9, 0x91, 0x82, 0xfc, 0xd5, 0x82, 0xd1, 0x52, 0x8c, 0xaf, 0xb4, 0x5a, 0x56, 0xae, 0x56, - 0xeb, 0x75, 0x18, 0xd9, 0x72, 0x49, 0xb3, 0x81, 0xc9, 0x96, 0x58, 0x89, 0x4f, 0xe6, 0xdb, 0xa1, - 0xac, 0x52, 0x4c, 0x29, 0xf5, 0xe2, 0xaf, 0xc3, 0x55, 0x51, 0x19, 0x2b, 0x32, 0x68, 0x17, 0xa6, - 0xe4, 0x83, 0x41, 0x42, 0xc5, 0xba, 0x7c, 0xaa, 0xdb, 0x2b, 0xc4, 0x24, 0x7e, 0xea, 0xfe, 0xc1, - 0xfc, 0x14, 0x4e, 0x90, 0xc1, 0x29, 0xc2, 0xf4, 0x39, 0xd8, 0xa2, 0x27, 0xf0, 0x00, 0x1b, 0x7e, - 0xf6, 0x1c, 0x64, 0x2f, 0x5b, 0x56, 0x6a, 0xff, 0x98, 0x05, 0x8f, 0xa4, 0x46, 0x46, 0xbc, 0xf0, - 0x8f, 0x79, 0x16, 0x92, 0x2f, 0xee, 0x42, 0xef, 0x17, 0xb7, 0xfd, 0xb7, 0x2d, 0x38, 0xb5, 0xd2, - 0x6a, 0x47, 0xfb, 0x65, 0xd7, 0x54, 0x41, 0x7d, 0x08, 0x86, 0x5a, 0xa4, 0xe1, 0x76, 0x5a, 0x62, - 0xe6, 0xe6, 0xe5, 0x29, 0xb5, 0xc6, 0x4a, 0x0f, 0x0f, 0xe6, 0xc7, 0x6b, 0x91, 0x1f, 0x38, 0xdb, - 0x84, 0x17, 0x60, 0x81, 0xce, 0xce, 0x7a, 0xf7, 0x2d, 0x72, 0xc3, 0x6d, 0xb9, 0xd2, 0xae, 0xa8, - 0xab, 0xcc, 0x6e, 0x41, 0x0e, 0xe8, 0xc2, 0xeb, 0x1d, 0xc7, 0x8b, 0xdc, 0x68, 0x5f, 0x68, 0x8f, - 0x24, 0x11, 0x1c, 0xd3, 0xb3, 0xbf, 0x66, 0xc1, 0xa4, 0x5c, 0xf7, 0x8b, 0x8d, 0x46, 0x40, 0xc2, - 0x10, 0xcd, 0x41, 0xc1, 0x6d, 0x8b, 0x5e, 0x82, 0xe8, 0x65, 0xa1, 0x52, 0xc5, 0x05, 0xb7, 0x2d, - 0xd9, 0x32, 0x76, 0x10, 0x16, 0x4d, 0x45, 0xda, 0x35, 0x51, 0x8e, 0x15, 0x06, 0xba, 0x04, 0x23, - 0x9e, 0xdf, 0xe0, 0xb6, 0x5d, 0xfc, 0x4a, 0x63, 0x0b, 0x6c, 0x5d, 0x94, 0x61, 0x05, 0x45, 0x55, - 0x28, 0x71, 0xb3, 0xa7, 0x78, 0xd1, 0xf6, 0x65, 0x3c, 0xc5, 0xbe, 0x6c, 0x43, 0xd6, 0xc4, 0x31, - 0x11, 0xfb, 0x57, 0x2c, 0x18, 0x93, 0x5f, 0xd6, 0x27, 0xcf, 0x49, 0xb7, 0x56, 0xcc, 0x6f, 0xc6, - 0x5b, 0x8b, 0xf2, 0x8c, 0x0c, 0x62, 0xb0, 0x8a, 0xc5, 0x23, 0xb1, 0x8a, 0x57, 0x60, 0xd4, 0x69, - 0xb7, 0xab, 0x26, 0x9f, 0xc9, 0x96, 0xd2, 0x62, 0x5c, 0x8c, 0x75, 0x1c, 0xfb, 0x4b, 0x05, 0x98, - 0x90, 0x5f, 0x50, 0xeb, 0x6c, 0x86, 0x24, 0x42, 0x1b, 0x50, 0x72, 0xf8, 0x2c, 0x11, 0xb9, 0xc8, - 0x9f, 0xc8, 0x96, 0x23, 0x18, 0x53, 0x1a, 0x5f, 0xf8, 0x8b, 0xb2, 0x36, 0x8e, 0x09, 0xa1, 0x26, - 0x4c, 0x7b, 0x7e, 0xc4, 0x0e, 0x7f, 0x05, 0xef, 0xa6, 0xda, 0x49, 0x52, 0x3f, 0x2b, 0xa8, 0x4f, - 0xaf, 0x27, 0xa9, 0xe0, 0x34, 0x61, 0xb4, 0x22, 0x65, 0x33, 0xc5, 0x7c, 0x61, 0x80, 0x3e, 0x71, - 0xd9, 0xa2, 0x19, 0xfb, 0x97, 0x2d, 0x28, 0x49, 0xb4, 0x93, 0xd0, 0xe2, 0xad, 0xc1, 0x70, 0xc8, - 0x26, 0x41, 0x0e, 0x8d, 0xdd, 0xad, 0xe3, 0x7c, 0xbe, 0xe2, 0x3b, 0x8d, 0xff, 0x0f, 0xb1, 0xa4, - 0xc1, 0x44, 0xf3, 0xaa, 0xfb, 0xef, 0x10, 0xd1, 0xbc, 0xea, 0x4f, 0xce, 0xa5, 0xf4, 0x87, 0xac, - 0xcf, 0x9a, 0xac, 0x8b, 0xb2, 0x5e, 0xed, 0x80, 0x6c, 0xb9, 0xf7, 0x92, 0xac, 0x57, 0x95, 0x95, - 0x62, 0x01, 0x45, 0x6f, 0xc0, 0x58, 0x5d, 0xca, 0x64, 0xe3, 0x1d, 0x7e, 0xb1, 0xab, 0x7e, 0x40, - 0xa9, 0x92, 0xb8, 0x2c, 0x64, 0x59, 0xab, 0x8f, 0x0d, 0x6a, 0xa6, 0x19, 0x41, 0xb1, 0x97, 0x19, - 0x41, 0x4c, 0x37, 0x5f, 0xa9, 0xfe, 0xe3, 0x16, 0x0c, 0x71, 0x59, 0x5c, 0x7f, 0xa2, 0x50, 0x4d, - 0xb3, 0x16, 0x8f, 0xdd, 0x6d, 0x5a, 0x28, 0x34, 0x65, 0x68, 0x0d, 0x4a, 0xec, 0x07, 0x93, 0x25, - 0x16, 0xf3, 0xad, 0xee, 0x79, 0xab, 0x7a, 0x07, 0x6f, 0xcb, 0x6a, 0x38, 0xa6, 0x60, 0xff, 0x68, - 0x91, 0x9e, 0x6e, 0x31, 0xaa, 0x71, 0xe9, 0x5b, 0x0f, 0xef, 0xd2, 0x2f, 0x3c, 0xac, 0x4b, 0x7f, - 0x1b, 0x26, 0xeb, 0x9a, 0x1e, 0x2e, 0x9e, 0xc9, 0x4b, 0x5d, 0x17, 0x89, 0xa6, 0xb2, 0xe3, 0x52, - 0x96, 0x65, 0x93, 0x08, 0x4e, 0x52, 0x45, 0xdf, 0x01, 0x63, 0x7c, 0x9e, 0x45, 0x2b, 0xdc, 0x12, - 0xe3, 0x7d, 0xf9, 0xeb, 0x45, 0x6f, 0x82, 0x4b, 0xe5, 0xb4, 0xea, 0xd8, 0x20, 0x66, 0xff, 0x89, - 0x05, 0x68, 0xa5, 0xbd, 0x43, 0x5a, 0x24, 0x70, 0x9a, 0xb1, 0x38, 0xfd, 0x07, 0x2d, 0x98, 0x25, - 0xa9, 0xe2, 0x65, 0xbf, 0xd5, 0x12, 0x8f, 0x96, 0x9c, 0x77, 0xf5, 0x4a, 0x4e, 0x1d, 0xe5, 0x96, - 0x30, 0x9b, 0x87, 0x81, 0x73, 0xdb, 0x43, 0x6b, 0x30, 0xc3, 0x6f, 0x49, 0x05, 0xd0, 0x6c, 0xaf, - 0x1f, 0x15, 0x84, 0x67, 0x36, 0xd2, 0x28, 0x38, 0xab, 0x9e, 0xfd, 0x3d, 0x63, 0x90, 0xdb, 0x8b, - 0x77, 0xf5, 0x08, 0xef, 0xea, 0x11, 0xde, 0xd5, 0x23, 0xbc, 0xab, 0x47, 0x78, 0x57, 0x8f, 0xf0, - 0x2d, 0xaf, 0x47, 0xf8, 0xcb, 0x16, 0x9c, 0x56, 0xd7, 0x80, 0xf1, 0xf0, 0xfd, 0x2c, 0xcc, 0xf0, - 0xed, 0xb6, 0xdc, 0x74, 0xdc, 0xd6, 0x06, 0x69, 0xb5, 0x9b, 0x4e, 0x24, 0xb5, 0xee, 0x57, 0x32, - 0x57, 0x6e, 0xc2, 0x62, 0xd5, 0xa8, 0xb8, 0xf4, 0x08, 0xbd, 0x9e, 0x32, 0x00, 0x38, 0xab, 0x19, - 0xfb, 0x17, 0x46, 0x60, 0x70, 0x65, 0x8f, 0x78, 0xd1, 0x09, 0x3c, 0x11, 0xea, 0x30, 0xe1, 0x7a, - 0x7b, 0x7e, 0x73, 0x8f, 0x34, 0x38, 0xfc, 0x28, 0x2f, 0xd9, 0x33, 0x82, 0xf4, 0x44, 0xc5, 0x20, - 0x81, 0x13, 0x24, 0x1f, 0x86, 0x34, 0xf9, 0x2a, 0x0c, 0xf1, 0x43, 0x5c, 0x88, 0x92, 0x33, 0xcf, - 0x6c, 0x36, 0x88, 0xe2, 0x6a, 0x8a, 0x25, 0xdd, 0xfc, 0x92, 0x10, 0xd5, 0xd1, 0x67, 0x60, 0x62, - 0xcb, 0x0d, 0xc2, 0x68, 0xc3, 0x6d, 0x91, 0x30, 0x72, 0x5a, 0xed, 0x07, 0x90, 0x1e, 0xab, 0x71, - 0x58, 0x35, 0x28, 0xe1, 0x04, 0x65, 0xb4, 0x0d, 0xe3, 0x4d, 0x47, 0x6f, 0x6a, 0xf8, 0xc8, 0x4d, - 0xa9, 0xdb, 0xe1, 0x86, 0x4e, 0x08, 0x9b, 0x74, 0xe9, 0x76, 0xaa, 0x33, 0x01, 0xe8, 0x08, 0x13, - 0x0b, 0xa8, 0xed, 0xc4, 0x25, 0x9f, 0x1c, 0x46, 0x19, 0x1d, 0x66, 0x20, 0x5b, 0x32, 0x19, 0x1d, - 0xcd, 0x0c, 0xf6, 0xd3, 0x50, 0x22, 0x74, 0x08, 0x29, 0x61, 0x71, 0xc1, 0x5c, 0xee, 0xaf, 0xaf, - 0x6b, 0x6e, 0x3d, 0xf0, 0x4d, 0xb9, 0xfd, 0x8a, 0xa4, 0x84, 0x63, 0xa2, 0x68, 0x19, 0x86, 0x42, - 0x12, 0xb8, 0x24, 0x14, 0x57, 0x4d, 0x97, 0x69, 0x64, 0x68, 0xdc, 0xb7, 0x84, 0xff, 0xc6, 0xa2, - 0x2a, 0x5d, 0x5e, 0x0e, 0x13, 0x69, 0xb2, 0xcb, 0x40, 0x5b, 0x5e, 0x8b, 0xac, 0x14, 0x0b, 0x28, - 0x7a, 0x0d, 0x86, 0x03, 0xd2, 0x64, 0x8a, 0xa1, 0xf1, 0xfe, 0x17, 0x39, 0xd7, 0x33, 0xf1, 0x7a, - 0x58, 0x12, 0x40, 0xd7, 0x01, 0x05, 0x84, 0x32, 0x4a, 0xae, 0xb7, 0xad, 0xcc, 0x46, 0xc5, 0x41, - 0xab, 0x18, 0x52, 0x1c, 0x63, 0x48, 0x37, 0x1f, 0x9c, 0x51, 0x0d, 0x5d, 0x85, 0x69, 0x55, 0x5a, - 0xf1, 0xc2, 0xc8, 0xa1, 0x07, 0xdc, 0x24, 0xa3, 0xa5, 0xe4, 0x14, 0x38, 0x89, 0x80, 0xd3, 0x75, - 0xec, 0x2f, 0x5b, 0xc0, 0xc7, 0xf9, 0x04, 0x5e, 0xe7, 0xaf, 0x9a, 0xaf, 0xf3, 0xb3, 0xb9, 0x33, - 0x97, 0xf3, 0x32, 0xff, 0xb2, 0x05, 0xa3, 0xda, 0xcc, 0xc6, 0x6b, 0xd6, 0xea, 0xb2, 0x66, 0x3b, - 0x30, 0x45, 0x57, 0xfa, 0xcd, 0xcd, 0x90, 0x04, 0x7b, 0xa4, 0xc1, 0x16, 0x66, 0xe1, 0xc1, 0x16, - 0xa6, 0x32, 0x51, 0xbb, 0x91, 0x20, 0x88, 0x53, 0x4d, 0xd8, 0x9f, 0x96, 0x5d, 0x55, 0x16, 0x7d, - 0x75, 0x35, 0xe7, 0x09, 0x8b, 0x3e, 0x35, 0xab, 0x38, 0xc6, 0xa1, 0x5b, 0x6d, 0xc7, 0x0f, 0xa3, - 0xa4, 0x45, 0xdf, 0x35, 0x3f, 0x8c, 0x30, 0x83, 0xd8, 0xcf, 0x03, 0xac, 0xdc, 0x23, 0x75, 0xbe, - 0x62, 0xf5, 0xc7, 0x83, 0x95, 0xff, 0x78, 0xb0, 0x7f, 0xcb, 0x82, 0x89, 0xd5, 0x65, 0xe3, 0xe6, - 0x5a, 0x00, 0xe0, 0x2f, 0x9e, 0x3b, 0x77, 0xd6, 0xa5, 0x3a, 0x9c, 0x6b, 0x34, 0x55, 0x29, 0xd6, - 0x30, 0xd0, 0x59, 0x28, 0x36, 0x3b, 0x9e, 0x10, 0x1f, 0x0e, 0xd3, 0xeb, 0xf1, 0x46, 0xc7, 0xc3, - 0xb4, 0x4c, 0x73, 0x29, 0x28, 0xf6, 0xed, 0x52, 0xd0, 0xd3, 0xb5, 0x1f, 0xcd, 0xc3, 0xe0, 0xdd, - 0xbb, 0x6e, 0x83, 0x3b, 0x50, 0x0a, 0x55, 0xfd, 0x9d, 0x3b, 0x95, 0x72, 0x88, 0x79, 0xb9, 0xfd, - 0x85, 0x22, 0xcc, 0xad, 0x36, 0xc9, 0xbd, 0xb7, 0xe9, 0x44, 0xda, 0xaf, 0x43, 0xc4, 0xd1, 0x04, - 0x31, 0x47, 0x75, 0x7a, 0xe9, 0x3d, 0x1e, 0x5b, 0x30, 0xcc, 0x0d, 0xda, 0xa4, 0x4b, 0xe9, 0x2b, - 0x59, 0xad, 0xe7, 0x0f, 0xc8, 0x02, 0x37, 0x8c, 0x13, 0x1e, 0x71, 0xea, 0xc2, 0x14, 0xa5, 0x58, - 0x12, 0x9f, 0x7b, 0x19, 0xc6, 0x74, 0xcc, 0x23, 0xb9, 0x9f, 0xfd, 0x85, 0x22, 0x4c, 0xd1, 0x1e, - 0x3c, 0xd4, 0x89, 0xb8, 0x95, 0x9e, 0x88, 0xe3, 0x76, 0x41, 0xea, 0x3d, 0x1b, 0x6f, 0x24, 0x67, - 0xe3, 0x4a, 0xde, 0x6c, 0x9c, 0xf4, 0x1c, 0x7c, 0xb7, 0x05, 0x33, 0xab, 0x4d, 0xbf, 0xbe, 0x9b, - 0x70, 0x13, 0x7a, 0x11, 0x46, 0xe9, 0x71, 0x1c, 0x1a, 0x1e, 0xec, 0x46, 0x4c, 0x03, 0x01, 0xc2, - 0x3a, 0x9e, 0x56, 0xed, 0xd6, 0xad, 0x4a, 0x39, 0x2b, 0x14, 0x82, 0x00, 0x61, 0x1d, 0xcf, 0xfe, - 0x75, 0x0b, 0xce, 0x5d, 0x5d, 0x5e, 0x89, 0x97, 0x62, 0x2a, 0x1a, 0xc3, 0x45, 0x18, 0x6a, 0x37, - 0xb4, 0xae, 0xc4, 0xe2, 0xd5, 0x32, 0xeb, 0x85, 0x80, 0xbe, 0x53, 0x22, 0x8d, 0xfc, 0xb4, 0x05, - 0x33, 0x57, 0xdd, 0x88, 0xde, 0xae, 0xc9, 0xb8, 0x00, 0xf4, 0x7a, 0x0d, 0xdd, 0xc8, 0x0f, 0xf6, - 0x93, 0x71, 0x01, 0xb0, 0x82, 0x60, 0x0d, 0x8b, 0xb7, 0xbc, 0xe7, 0x32, 0x53, 0xea, 0x82, 0xa9, - 0x68, 0xc2, 0xa2, 0x1c, 0x2b, 0x0c, 0xfa, 0x61, 0x0d, 0x37, 0x60, 0x32, 0xba, 0x7d, 0x71, 0xc2, - 0xaa, 0x0f, 0x2b, 0x4b, 0x00, 0x8e, 0x71, 0xec, 0x3f, 0xb2, 0x60, 0xfe, 0x6a, 0xb3, 0x13, 0x46, - 0x24, 0xd8, 0x0a, 0x73, 0x4e, 0xc7, 0xe7, 0xa1, 0x44, 0xa4, 0x44, 0x5c, 0xf4, 0x5a, 0x71, 0x8c, - 0x4a, 0x54, 0xce, 0xc3, 0x13, 0x28, 0xbc, 0x3e, 0x9c, 0x0e, 0x8f, 0xe6, 0x35, 0xb6, 0x0a, 0x88, - 0xe8, 0x6d, 0xe9, 0xf1, 0x1a, 0x98, 0xe3, 0xf7, 0x4a, 0x0a, 0x8a, 0x33, 0x6a, 0xd8, 0x3f, 0x66, - 0xc1, 0x69, 0xf5, 0xc1, 0xef, 0xb8, 0xcf, 0xb4, 0x7f, 0xb6, 0x00, 0xe3, 0xd7, 0x36, 0x36, 0xaa, - 0x57, 0x49, 0x24, 0xae, 0xed, 0xde, 0x7a, 0x6e, 0xac, 0xa9, 0xeb, 0xba, 0x3d, 0xe6, 0x3a, 0x91, - 0xdb, 0x5c, 0xe0, 0x61, 0x7f, 0x16, 0x2a, 0x5e, 0x74, 0x33, 0xa8, 0x45, 0x81, 0xeb, 0x6d, 0x67, - 0x2a, 0xf8, 0x24, 0x73, 0x51, 0xcc, 0x63, 0x2e, 0xd0, 0xf3, 0x30, 0xc4, 0xe2, 0x0e, 0xc9, 0x49, - 0x78, 0x54, 0xbd, 0x85, 0x58, 0xe9, 0xe1, 0xc1, 0x7c, 0xe9, 0x16, 0xae, 0xf0, 0x3f, 0x58, 0xa0, - 0xa2, 0x5b, 0x30, 0xba, 0x13, 0x45, 0xed, 0x6b, 0xc4, 0x69, 0x90, 0x40, 0x1e, 0x87, 0xe7, 0xb3, - 0x8e, 0x43, 0x3a, 0x08, 0x1c, 0x2d, 0x3e, 0x41, 0xe2, 0xb2, 0x10, 0xeb, 0x74, 0xec, 0x1a, 0x40, - 0x0c, 0x3b, 0x26, 0x4d, 0x85, 0xbd, 0x01, 0x25, 0xfa, 0xb9, 0x8b, 0x4d, 0xd7, 0xe9, 0xae, 0x0b, - 0x7e, 0x1a, 0x4a, 0x52, 0xd3, 0x1b, 0x0a, 0xa7, 0x68, 0x76, 0x75, 0x48, 0x45, 0x70, 0x88, 0x63, - 0xb8, 0xbd, 0x05, 0xa7, 0x98, 0xdd, 0x9e, 0x13, 0xed, 0x18, 0xab, 0xaf, 0xf7, 0x34, 0x3f, 0x23, - 0x9e, 0x56, 0xbc, 0xcf, 0xb3, 0x9a, 0xdf, 0xe1, 0x98, 0xa4, 0x18, 0x3f, 0xb3, 0xec, 0xaf, 0x0f, - 0xc0, 0xa3, 0x95, 0x5a, 0x7e, 0xdc, 0x8c, 0x97, 0x60, 0x8c, 0x73, 0x6c, 0x74, 0xd2, 0x9d, 0xa6, - 0x68, 0x57, 0x09, 0x21, 0x37, 0x34, 0x18, 0x36, 0x30, 0xd1, 0x39, 0x28, 0xba, 0x6f, 0x7a, 0x49, - 0xaf, 0x9c, 0xca, 0xeb, 0xeb, 0x98, 0x96, 0x53, 0x30, 0x65, 0xfe, 0xf8, 0xa9, 0xaa, 0xc0, 0x8a, - 0x01, 0x7c, 0x15, 0x26, 0xdc, 0xb0, 0x1e, 0xba, 0x15, 0x8f, 0xee, 0x40, 0x6d, 0x0f, 0xab, 0x67, - 0x3f, 0xed, 0xb4, 0x82, 0xe2, 0x04, 0xb6, 0x76, 0xc4, 0x0f, 0xf6, 0xcd, 0x40, 0xf6, 0xf4, 0x12, - 0xa6, 0xbc, 0x71, 0x9b, 0x7d, 0x5d, 0xc8, 0xa4, 0xc9, 0x82, 0x37, 0xe6, 0x1f, 0x1c, 0x62, 0x09, - 0xa3, 0x6f, 0xaa, 0xfa, 0x8e, 0xd3, 0x5e, 0xec, 0x44, 0x3b, 0x65, 0x37, 0xac, 0xfb, 0x7b, 0x24, - 0xd8, 0x67, 0xcf, 0xe1, 0x91, 0xf8, 0x4d, 0xa5, 0x00, 0xcb, 0xd7, 0x16, 0xab, 0x14, 0x13, 0xa7, - 0xeb, 0xa0, 0x45, 0x98, 0x94, 0x85, 0x35, 0x12, 0xb2, 0xc3, 0x7d, 0x94, 0x91, 0x51, 0x7e, 0x32, - 0xa2, 0x58, 0x11, 0x49, 0xe2, 0x9b, 0x3c, 0x26, 0x1c, 0x07, 0x8f, 0xf9, 0x21, 0x18, 0x77, 0x3d, - 0x37, 0x72, 0x9d, 0xc8, 0xe7, 0xaa, 0x10, 0xfe, 0xf2, 0x65, 0x32, 0xde, 0x8a, 0x0e, 0xc0, 0x26, - 0x9e, 0xfd, 0x9f, 0x07, 0x60, 0x9a, 0x4d, 0xdb, 0xbb, 0x2b, 0xec, 0x5b, 0x69, 0x85, 0xdd, 0x4a, - 0xaf, 0xb0, 0xe3, 0x60, 0x9e, 0x1f, 0x78, 0x99, 0x7d, 0x06, 0x4a, 0xca, 0x35, 0x48, 0xfa, 0x06, - 0x5a, 0x39, 0xbe, 0x81, 0xbd, 0xef, 0x65, 0x69, 0x5d, 0x55, 0xcc, 0xb4, 0xae, 0xfa, 0x8a, 0x05, - 0xb1, 0x6c, 0x1f, 0xbd, 0x0e, 0xa5, 0xb6, 0xcf, 0x8c, 0x06, 0x03, 0x69, 0x89, 0xfb, 0xde, 0xae, - 0xca, 0x01, 0x1e, 0x3a, 0x28, 0xe0, 0xa3, 0x50, 0x95, 0x55, 0x71, 0x4c, 0x05, 0x5d, 0x87, 0xe1, - 0x76, 0x40, 0x6a, 0x11, 0x8b, 0xa3, 0xd1, 0x3f, 0x41, 0xbe, 0x6a, 0x78, 0x45, 0x2c, 0x29, 0xd8, - 0xff, 0xd5, 0x82, 0xa9, 0x24, 0x2a, 0xfa, 0x30, 0x0c, 0x90, 0x7b, 0xa4, 0x2e, 0xfa, 0x9b, 0x79, - 0xc9, 0xc6, 0xd2, 0x01, 0x3e, 0x00, 0xf4, 0x3f, 0x66, 0xb5, 0xd0, 0x35, 0x18, 0xa6, 0x37, 0xec, - 0x55, 0x15, 0xc3, 0xe9, 0xf1, 0xbc, 0x5b, 0x5a, 0xb1, 0x2a, 0xbc, 0x73, 0xa2, 0x08, 0xcb, 0xea, - 0xcc, 0xa4, 0xa9, 0xde, 0xae, 0xd1, 0x57, 0x46, 0xd4, 0xed, 0x31, 0xbc, 0xb1, 0x5c, 0xe5, 0x48, - 0x82, 0x1a, 0x37, 0x69, 0x92, 0x85, 0x38, 0x26, 0x62, 0xff, 0x9c, 0x05, 0xc0, 0x2d, 0xb8, 0x1c, - 0x6f, 0x9b, 0x9c, 0x80, 0x40, 0xbb, 0x0c, 0x03, 0x61, 0x9b, 0xd4, 0xbb, 0xd9, 0xb3, 0xc6, 0xfd, - 0xa9, 0xb5, 0x49, 0x3d, 0x5e, 0x71, 0xf4, 0x1f, 0x66, 0xb5, 0xed, 0xef, 0x05, 0x98, 0x88, 0xd1, - 0x2a, 0x11, 0x69, 0xa1, 0x67, 0x8d, 0x78, 0x02, 0x67, 0x13, 0xf1, 0x04, 0x4a, 0x0c, 0x5b, 0x93, - 0x9d, 0x7e, 0x06, 0x8a, 0x2d, 0xe7, 0x9e, 0x10, 0x8e, 0x3d, 0xdd, 0xbd, 0x1b, 0x94, 0xfe, 0xc2, - 0x9a, 0x73, 0x8f, 0xbf, 0x1f, 0x9f, 0x96, 0x3b, 0x64, 0xcd, 0xb9, 0x77, 0xc8, 0xad, 0x56, 0xd9, - 0x29, 0x7d, 0xc3, 0x0d, 0xa3, 0xcf, 0xfd, 0xa7, 0xf8, 0x3f, 0xdb, 0x77, 0xb4, 0x11, 0xd6, 0x96, - 0xeb, 0x09, 0xe3, 0xa4, 0xbe, 0xda, 0x72, 0xbd, 0x64, 0x5b, 0xae, 0xd7, 0x47, 0x5b, 0xae, 0x87, - 0xde, 0x82, 0x61, 0x61, 0x3b, 0x28, 0xe2, 0xf7, 0x5c, 0xee, 0xa3, 0x3d, 0x61, 0x7a, 0xc8, 0xdb, - 0xbc, 0x2c, 0xdf, 0xc7, 0xa2, 0xb4, 0x67, 0xbb, 0xb2, 0x41, 0xf4, 0x57, 0x2c, 0x98, 0x10, 0xbf, - 0x31, 0x79, 0xb3, 0x43, 0xc2, 0x48, 0xb0, 0xa5, 0x1f, 0xec, 0xbf, 0x0f, 0xa2, 0x22, 0xef, 0xca, - 0x07, 0xe5, 0x3d, 0x63, 0x02, 0x7b, 0xf6, 0x28, 0xd1, 0x0b, 0xf4, 0x77, 0x2d, 0x38, 0xd5, 0x72, - 0xee, 0xf1, 0x16, 0x79, 0x19, 0x76, 0x22, 0xd7, 0x17, 0x3a, 0xf8, 0x0f, 0xf7, 0x37, 0xfd, 0xa9, - 0xea, 0xbc, 0x93, 0x52, 0x51, 0x78, 0x2a, 0x0b, 0xa5, 0x67, 0x57, 0x33, 0xfb, 0x35, 0xb7, 0x05, - 0x23, 0x72, 0xbd, 0x65, 0x48, 0x21, 0xca, 0x3a, 0xcf, 0x7d, 0x64, 0xd3, 0x4d, 0xdd, 0x4f, 0x9f, - 0xb6, 0x23, 0xd6, 0xda, 0x43, 0x6d, 0xe7, 0x33, 0x30, 0xa6, 0xaf, 0xb1, 0x87, 0xda, 0xd6, 0x9b, - 0x30, 0x93, 0xb1, 0x96, 0x1e, 0x6a, 0x93, 0x77, 0xe1, 0x6c, 0xee, 0xfa, 0x78, 0x98, 0x0d, 0xdb, - 0x3f, 0x6b, 0xe9, 0xe7, 0xe0, 0x09, 0x68, 0x15, 0x96, 0x4d, 0xad, 0xc2, 0xf9, 0xee, 0x3b, 0x27, - 0x47, 0xb5, 0xf0, 0x86, 0xde, 0x69, 0x7a, 0xaa, 0xa3, 0xd7, 0x60, 0xa8, 0x49, 0x4b, 0xa4, 0x05, - 0xaa, 0xdd, 0x7b, 0x47, 0xc6, 0xcc, 0x24, 0x2b, 0x0f, 0xb1, 0xa0, 0x60, 0xff, 0xa2, 0x05, 0x03, - 0x27, 0x30, 0x12, 0xd8, 0x1c, 0x89, 0x67, 0x73, 0x49, 0x8b, 0xd0, 0xc2, 0x0b, 0xd8, 0xb9, 0xbb, - 0x72, 0x2f, 0x22, 0x5e, 0xc8, 0x6e, 0xe4, 0xcc, 0x81, 0xf9, 0x49, 0x0b, 0x66, 0x6e, 0xf8, 0x4e, - 0x63, 0xc9, 0x69, 0x3a, 0x5e, 0x9d, 0x04, 0x15, 0x6f, 0xfb, 0x48, 0xe6, 0xd3, 0x85, 0x9e, 0xe6, - 0xd3, 0xcb, 0xd2, 0xfa, 0x68, 0x20, 0x7f, 0xfe, 0x28, 0x27, 0x9d, 0x8c, 0xb0, 0x62, 0xd8, 0xc9, - 0xee, 0x00, 0xd2, 0x7b, 0x29, 0x9c, 0x59, 0x30, 0x0c, 0xbb, 0xbc, 0xbf, 0x62, 0x12, 0x9f, 0xcc, - 0xe6, 0x70, 0x53, 0x9f, 0xa7, 0xb9, 0x69, 0xf0, 0x02, 0x2c, 0x09, 0xd9, 0x2f, 0x41, 0xa6, 0x47, - 0x7c, 0x6f, 0xb9, 0x84, 0xfd, 0x71, 0x98, 0x66, 0x35, 0x8f, 0x28, 0x19, 0xb0, 0x13, 0x62, 0xcf, - 0x8c, 0x58, 0x79, 0xf6, 0xe7, 0x2d, 0x98, 0x5c, 0x4f, 0x84, 0x10, 0xbb, 0xc8, 0x14, 0xa5, 0x19, - 0xd2, 0xf6, 0x1a, 0x2b, 0xc5, 0x02, 0x7a, 0xec, 0x42, 0xae, 0x3f, 0xb7, 0x20, 0x0e, 0x52, 0x71, - 0x02, 0xec, 0xdb, 0xb2, 0xc1, 0xbe, 0x65, 0x32, 0xb2, 0xaa, 0x3b, 0x79, 0xdc, 0x1b, 0xba, 0xae, - 0xc2, 0x37, 0x75, 0xe1, 0x61, 0x63, 0x32, 0x7c, 0x29, 0x4e, 0x98, 0x31, 0x9e, 0x64, 0x40, 0x27, - 0xfb, 0xb7, 0x0b, 0x80, 0x14, 0x6e, 0xdf, 0xe1, 0xa5, 0xd2, 0x35, 0x8e, 0x27, 0xbc, 0xd4, 0x1e, - 0x20, 0xa6, 0xea, 0x0f, 0x1c, 0x2f, 0xe4, 0x64, 0x5d, 0x21, 0xd6, 0x3b, 0x9a, 0x1d, 0xc1, 0x9c, - 0x68, 0x12, 0xdd, 0x48, 0x51, 0xc3, 0x19, 0x2d, 0x68, 0x26, 0x1c, 0x83, 0xfd, 0x9a, 0x70, 0x0c, - 0xf5, 0x70, 0x58, 0xfb, 0x19, 0x0b, 0xc6, 0xd5, 0x30, 0xbd, 0x43, 0xcc, 0xc9, 0x55, 0x7f, 0x72, - 0x0e, 0xd0, 0xaa, 0xd6, 0x65, 0x76, 0xb1, 0x7c, 0x3b, 0x73, 0x3c, 0x74, 0x9a, 0xee, 0x5b, 0x44, - 0x05, 0xf7, 0x9b, 0x17, 0x8e, 0x84, 0xa2, 0xf4, 0xf0, 0x60, 0x7e, 0x5c, 0xfd, 0xe3, 0xc1, 0x84, - 0xe3, 0x2a, 0xf4, 0x48, 0x9e, 0x4c, 0x2c, 0x45, 0xf4, 0x22, 0x0c, 0xb6, 0x77, 0x9c, 0x90, 0x24, - 0xdc, 0x6e, 0x06, 0xab, 0xb4, 0xf0, 0xf0, 0x60, 0x7e, 0x42, 0x55, 0x60, 0x25, 0x98, 0x63, 0xf7, - 0x1f, 0xb4, 0x2b, 0xbd, 0x38, 0x7b, 0x06, 0xed, 0xfa, 0x13, 0x0b, 0x06, 0xd6, 0xfd, 0xc6, 0x49, - 0x1c, 0x01, 0xaf, 0x1a, 0x47, 0xc0, 0x63, 0x79, 0x71, 0xde, 0x73, 0x77, 0xff, 0x6a, 0x62, 0xf7, - 0x9f, 0xcf, 0xa5, 0xd0, 0x7d, 0xe3, 0xb7, 0x60, 0x94, 0x45, 0x8f, 0x17, 0x2e, 0x46, 0xcf, 0x1b, - 0x1b, 0x7e, 0x3e, 0xb1, 0xe1, 0x27, 0x35, 0x54, 0x6d, 0xa7, 0x3f, 0x05, 0xc3, 0xc2, 0x67, 0x25, - 0xe9, 0xbf, 0x29, 0x70, 0xb1, 0x84, 0xdb, 0x3f, 0x5e, 0x04, 0x23, 0x5a, 0x3d, 0xfa, 0x65, 0x0b, - 0x16, 0x02, 0x6e, 0xcb, 0xda, 0x28, 0x77, 0x02, 0xd7, 0xdb, 0xae, 0xd5, 0x77, 0x48, 0xa3, 0xd3, - 0x74, 0xbd, 0xed, 0xca, 0xb6, 0xe7, 0xab, 0xe2, 0x95, 0x7b, 0xa4, 0xde, 0x61, 0xfa, 0xb1, 0x1e, - 0xa1, 0xf1, 0x95, 0x4d, 0xf8, 0x73, 0xf7, 0x0f, 0xe6, 0x17, 0xf0, 0x91, 0x68, 0xe3, 0x23, 0xf6, - 0x05, 0xfd, 0xba, 0x05, 0x97, 0x79, 0x10, 0xf7, 0xfe, 0xfb, 0xdf, 0xe5, 0xb5, 0x5c, 0x95, 0xa4, - 0x62, 0x22, 0x1b, 0x24, 0x68, 0x2d, 0x7d, 0x48, 0x0c, 0xe8, 0xe5, 0xea, 0xd1, 0xda, 0xc2, 0x47, - 0xed, 0x9c, 0xfd, 0x4f, 0x8b, 0x30, 0x2e, 0x82, 0x3b, 0x89, 0x3b, 0xe0, 0x45, 0x63, 0x49, 0x3c, - 0x9e, 0x58, 0x12, 0xd3, 0x06, 0xf2, 0xf1, 0x1c, 0xff, 0x21, 0x4c, 0xd3, 0xc3, 0xf9, 0x1a, 0x71, - 0x82, 0x68, 0x93, 0x38, 0xdc, 0x32, 0xab, 0x78, 0xe4, 0xd3, 0x5f, 0xc9, 0x27, 0x6f, 0x24, 0x89, - 0xe1, 0x34, 0xfd, 0x6f, 0xa5, 0x3b, 0xc7, 0x83, 0xa9, 0x54, 0x7c, 0xae, 0x4f, 0x40, 0x49, 0x39, - 0x5c, 0x88, 0x43, 0xa7, 0x7b, 0x98, 0xbb, 0x24, 0x05, 0x2e, 0xfe, 0x8a, 0x9d, 0x7d, 0x62, 0x72, - 0xf6, 0xdf, 0x2f, 0x18, 0x0d, 0xf2, 0x49, 0x5c, 0x87, 0x11, 0x27, 0x0c, 0xdd, 0x6d, 0x8f, 0x34, - 0xba, 0x49, 0x28, 0x53, 0xcd, 0x30, 0xa7, 0x97, 0x45, 0x51, 0x13, 0x2b, 0x1a, 0xe8, 0x1a, 0xb7, - 0x7f, 0xdb, 0x23, 0xdd, 0xc4, 0x93, 0x29, 0x6a, 0x20, 0x2d, 0xe4, 0xf6, 0x08, 0x16, 0xf5, 0xd1, - 0x27, 0xb9, 0x81, 0xe2, 0x75, 0xcf, 0xbf, 0xeb, 0x5d, 0xf5, 0x7d, 0x19, 0x40, 0xa1, 0x3f, 0x82, - 0xd3, 0xd2, 0x2c, 0x51, 0x55, 0xc7, 0x26, 0xb5, 0xfe, 0x02, 0x5e, 0x7e, 0x16, 0x66, 0x28, 0x69, - 0xd3, 0xbf, 0x39, 0x44, 0x04, 0x26, 0x45, 0xe4, 0x30, 0x59, 0x26, 0xc6, 0x2e, 0xf3, 0x29, 0x67, - 0xd6, 0x8e, 0x05, 0xe9, 0xd7, 0x4d, 0x12, 0x38, 0x49, 0xd3, 0xfe, 0x29, 0x0b, 0x98, 0xaf, 0xe7, - 0x09, 0xf0, 0x23, 0x1f, 0x31, 0xf9, 0x91, 0xd9, 0xbc, 0x41, 0xce, 0x61, 0x45, 0x5e, 0xe0, 0x2b, - 0xab, 0x1a, 0xf8, 0xf7, 0xf6, 0x85, 0x55, 0x49, 0xef, 0xf7, 0x87, 0xfd, 0x7f, 0x2c, 0x7e, 0x88, - 0x29, 0x77, 0x08, 0xf4, 0x9d, 0x30, 0x52, 0x77, 0xda, 0x4e, 0x9d, 0xa7, 0x56, 0xc9, 0x95, 0xe8, - 0x19, 0x95, 0x16, 0x96, 0x45, 0x0d, 0x2e, 0xa1, 0x92, 0x11, 0xe8, 0x46, 0x64, 0x71, 0x4f, 0xa9, - 0x94, 0x6a, 0x72, 0x6e, 0x17, 0xc6, 0x0d, 0x62, 0x0f, 0x55, 0x9c, 0xf1, 0x9d, 0xfc, 0x8a, 0x55, - 0x11, 0x13, 0x5b, 0x30, 0xed, 0x69, 0xff, 0xe9, 0x85, 0x22, 0x1f, 0x97, 0xef, 0xed, 0x75, 0x89, - 0xb2, 0xdb, 0x47, 0x73, 0x23, 0x4d, 0x90, 0xc1, 0x69, 0xca, 0xf6, 0x4f, 0x58, 0xf0, 0x88, 0x8e, - 0xa8, 0x79, 0xaa, 0xf4, 0x52, 0x92, 0x94, 0x61, 0xc4, 0x6f, 0x93, 0xc0, 0x89, 0xfc, 0x40, 0xdc, - 0x1a, 0x97, 0xe4, 0xa0, 0xdf, 0x14, 0xe5, 0x87, 0x22, 0x30, 0xb9, 0xa4, 0x2e, 0xcb, 0xb1, 0xaa, - 0x49, 0x5f, 0x9f, 0x6c, 0x30, 0x42, 0xe1, 0x93, 0xc4, 0xce, 0x00, 0xa6, 0x49, 0x0f, 0xb1, 0x80, - 0xd8, 0x5f, 0xb7, 0xf8, 0xc2, 0xd2, 0xbb, 0x8e, 0xde, 0x84, 0xa9, 0x96, 0x13, 0xd5, 0x77, 0x56, - 0xee, 0xb5, 0x03, 0xae, 0x72, 0x92, 0xe3, 0xf4, 0x74, 0xaf, 0x71, 0xd2, 0x3e, 0x32, 0xb6, 0xb9, - 0x5c, 0x4b, 0x10, 0xc3, 0x29, 0xf2, 0x68, 0x13, 0x46, 0x59, 0x19, 0x73, 0xb7, 0x0b, 0xbb, 0xb1, - 0x06, 0x79, 0xad, 0x29, 0x63, 0x84, 0xb5, 0x98, 0x0e, 0xd6, 0x89, 0xda, 0x5f, 0x29, 0xf2, 0xdd, - 0xce, 0x58, 0xf9, 0xa7, 0x60, 0xb8, 0xed, 0x37, 0x96, 0x2b, 0x65, 0x2c, 0x66, 0x41, 0x5d, 0x23, - 0x55, 0x5e, 0x8c, 0x25, 0x1c, 0x5d, 0x82, 0x11, 0xf1, 0x53, 0xaa, 0x08, 0xd9, 0xd9, 0x2c, 0xf0, - 0x42, 0xac, 0xa0, 0xe8, 0x39, 0x80, 0x76, 0xe0, 0xef, 0xb9, 0x0d, 0x16, 0x06, 0xa2, 0x68, 0xda, - 0x11, 0x55, 0x15, 0x04, 0x6b, 0x58, 0xe8, 0x15, 0x18, 0xef, 0x78, 0x21, 0x67, 0x47, 0xb4, 0xa0, - 0xaf, 0xca, 0xc2, 0xe5, 0x96, 0x0e, 0xc4, 0x26, 0x2e, 0x5a, 0x84, 0xa1, 0xc8, 0x61, 0x76, 0x31, - 0x83, 0xf9, 0x76, 0xb9, 0x1b, 0x14, 0x43, 0xcf, 0xe2, 0x41, 0x2b, 0x60, 0x51, 0x11, 0x7d, 0x42, - 0x7a, 0xbe, 0xf2, 0x83, 0x5d, 0x18, 0xc4, 0xf7, 0x77, 0x09, 0x68, 0x7e, 0xaf, 0xc2, 0xd0, 0xde, - 0xa0, 0x85, 0x5e, 0x06, 0x20, 0xf7, 0x22, 0x12, 0x78, 0x4e, 0x53, 0x99, 0x9d, 0x29, 0xbe, 0xa0, - 0xec, 0xaf, 0xfb, 0xd1, 0xad, 0x90, 0xac, 0x28, 0x0c, 0xac, 0x61, 0xdb, 0xbf, 0x5e, 0x02, 0x88, - 0xf9, 0x76, 0xf4, 0x56, 0xea, 0xe0, 0x7a, 0xa6, 0x3b, 0xa7, 0x7f, 0x7c, 0xa7, 0x16, 0xfa, 0x3e, - 0x0b, 0x46, 0x9d, 0x66, 0xd3, 0xaf, 0x3b, 0x3c, 0x2c, 0x6f, 0xa1, 0xfb, 0xc1, 0x29, 0xda, 0x5f, - 0x8c, 0x6b, 0xf0, 0x2e, 0x3c, 0x2f, 0x57, 0xa8, 0x06, 0xe9, 0xd9, 0x0b, 0xbd, 0x61, 0xf4, 0x01, - 0xf9, 0x54, 0x2c, 0x1a, 0x43, 0xa9, 0x9e, 0x8a, 0x25, 0x76, 0x47, 0xe8, 0xaf, 0xc4, 0x5b, 0xc6, - 0x2b, 0x71, 0x20, 0xdf, 0xb5, 0xcf, 0x60, 0x5f, 0x7b, 0x3d, 0x10, 0x51, 0x55, 0x77, 0xf3, 0x1f, - 0xcc, 0xf7, 0xa3, 0xd3, 0xde, 0x49, 0x3d, 0x5c, 0xfc, 0x3f, 0x03, 0x93, 0x0d, 0x93, 0x09, 0x10, - 0x2b, 0xf1, 0xc9, 0x3c, 0xba, 0x09, 0x9e, 0x21, 0xbe, 0xf6, 0x13, 0x00, 0x9c, 0x24, 0x8c, 0xaa, - 0x3c, 0xea, 0x43, 0xc5, 0xdb, 0xf2, 0x85, 0x53, 0x86, 0x9d, 0x3b, 0x97, 0xfb, 0x61, 0x44, 0x5a, - 0x14, 0x33, 0xbe, 0xdd, 0xd7, 0x45, 0x5d, 0xac, 0xa8, 0xa0, 0xd7, 0x60, 0x88, 0x39, 0x52, 0x85, - 0xb3, 0x23, 0xf9, 0x12, 0x67, 0x33, 0x8c, 0x59, 0xbc, 0x21, 0xd9, 0xdf, 0x10, 0x0b, 0x0a, 0xe8, - 0x9a, 0x74, 0x53, 0x0c, 0x2b, 0xde, 0xad, 0x90, 0x30, 0x37, 0xc5, 0xd2, 0xd2, 0x7b, 0x63, 0x0f, - 0x44, 0x5e, 0x9e, 0x99, 0xeb, 0xcb, 0xa8, 0x49, 0xb9, 0x28, 0xf1, 0x5f, 0xa6, 0x10, 0x9b, 0x85, - 0xfc, 0xee, 0x99, 0x69, 0xc6, 0xe2, 0xe1, 0xbc, 0x6d, 0x92, 0xc0, 0x49, 0x9a, 0x94, 0x23, 0xe5, - 0xbb, 0x5e, 0xb8, 0x75, 0xf4, 0x3a, 0x3b, 0xf8, 0x43, 0x9c, 0xdd, 0x46, 0xbc, 0x04, 0x8b, 0xfa, - 0x27, 0xca, 0x1e, 0xcc, 0x79, 0x30, 0x95, 0xdc, 0xa2, 0x0f, 0x95, 0x1d, 0xf9, 0x83, 0x01, 0x98, - 0x30, 0x97, 0x14, 0xba, 0x0c, 0x25, 0x41, 0x44, 0x85, 0xfd, 0x57, 0xbb, 0x64, 0x4d, 0x02, 0x70, - 0x8c, 0xc3, 0xb2, 0x3d, 0xb0, 0xea, 0x9a, 0x1d, 0x6f, 0x9c, 0xed, 0x41, 0x41, 0xb0, 0x86, 0x45, - 0x1f, 0x56, 0x9b, 0xbe, 0x1f, 0xa9, 0x0b, 0x49, 0xad, 0xbb, 0x25, 0x56, 0x8a, 0x05, 0x94, 0x5e, - 0x44, 0xbb, 0x24, 0xf0, 0x48, 0xd3, 0x0c, 0x10, 0xac, 0x2e, 0xa2, 0xeb, 0x3a, 0x10, 0x9b, 0xb8, - 0xf4, 0x3a, 0xf5, 0x43, 0xb6, 0x90, 0xc5, 0xf3, 0x2d, 0xb6, 0x8b, 0xae, 0x71, 0x4f, 0x69, 0x09, - 0x47, 0x1f, 0x87, 0x47, 0x54, 0x10, 0x24, 0xcc, 0xb5, 0x19, 0xb2, 0xc5, 0x21, 0x43, 0xda, 0xf2, - 0xc8, 0x72, 0x36, 0x1a, 0xce, 0xab, 0x8f, 0x5e, 0x85, 0x09, 0xc1, 0xe2, 0x4b, 0x8a, 0xc3, 0xa6, - 0x85, 0xd1, 0x75, 0x03, 0x8a, 0x13, 0xd8, 0x32, 0xc4, 0x31, 0xe3, 0xb2, 0x25, 0x85, 0x91, 0x74, - 0x88, 0x63, 0x1d, 0x8e, 0x53, 0x35, 0xd0, 0x22, 0x4c, 0x72, 0x1e, 0xcc, 0xf5, 0xb6, 0xf9, 0x9c, - 0x08, 0xaf, 0x2b, 0xb5, 0xa5, 0x6e, 0x9a, 0x60, 0x9c, 0xc4, 0x47, 0x2f, 0xc1, 0x98, 0x13, 0xd4, - 0x77, 0xdc, 0x88, 0xd4, 0xa3, 0x4e, 0xc0, 0xdd, 0xb1, 0x34, 0x13, 0xad, 0x45, 0x0d, 0x86, 0x0d, - 0x4c, 0xfb, 0x2d, 0x98, 0xc9, 0x08, 0xa1, 0x40, 0x17, 0x8e, 0xd3, 0x76, 0xe5, 0x37, 0x25, 0x2c, - 0x9c, 0x17, 0xab, 0x15, 0xf9, 0x35, 0x1a, 0x16, 0x5d, 0x9d, 0x2c, 0xd4, 0x82, 0x96, 0x31, 0x50, - 0xad, 0xce, 0x55, 0x09, 0xc0, 0x31, 0x8e, 0xfd, 0x3f, 0x0a, 0x30, 0x99, 0xa1, 0x5b, 0x61, 0x59, - 0xeb, 0x12, 0x8f, 0x94, 0x38, 0x49, 0x9d, 0x19, 0x31, 0xbb, 0x70, 0x84, 0x88, 0xd9, 0xc5, 0x5e, - 0x11, 0xb3, 0x07, 0xde, 0x4e, 0xc4, 0x6c, 0x73, 0xc4, 0x06, 0xfb, 0x1a, 0xb1, 0x8c, 0x28, 0xdb, - 0x43, 0x47, 0x8c, 0xb2, 0x6d, 0x0c, 0xfa, 0x70, 0x1f, 0x83, 0xfe, 0xa3, 0x05, 0x98, 0x4a, 0x9a, - 0x92, 0x9e, 0x80, 0xdc, 0xf6, 0x35, 0x43, 0x6e, 0x7b, 0xa9, 0x1f, 0x2f, 0xd9, 0x5c, 0x19, 0x2e, - 0x4e, 0xc8, 0x70, 0xdf, 0xdf, 0x17, 0xb5, 0xee, 0xf2, 0xdc, 0xbf, 0x51, 0x80, 0xd3, 0x99, 0x6e, - 0xba, 0x27, 0x30, 0x36, 0x37, 0x8d, 0xb1, 0x79, 0xb6, 0x6f, 0x0f, 0xe2, 0xdc, 0x01, 0xba, 0x93, - 0x18, 0xa0, 0xcb, 0xfd, 0x93, 0xec, 0x3e, 0x4a, 0x5f, 0x2b, 0xc2, 0xf9, 0xcc, 0x7a, 0xb1, 0xd8, - 0x73, 0xd5, 0x10, 0x7b, 0x3e, 0x97, 0x10, 0x7b, 0xda, 0xdd, 0x6b, 0x1f, 0x8f, 0x1c, 0x54, 0x78, - 0xd2, 0xb2, 0x78, 0x00, 0x0f, 0x28, 0x03, 0x35, 0x3c, 0x69, 0x15, 0x21, 0x6c, 0xd2, 0xfd, 0x56, - 0x92, 0x7d, 0xfe, 0x1b, 0x0b, 0xce, 0x66, 0xce, 0xcd, 0x09, 0xc8, 0xba, 0xd6, 0x4d, 0x59, 0xd7, - 0x53, 0x7d, 0xaf, 0xd6, 0x1c, 0xe1, 0xd7, 0x57, 0x06, 0x73, 0xbe, 0x85, 0xbd, 0xe4, 0x6f, 0xc2, - 0xa8, 0x53, 0xaf, 0x93, 0x30, 0x5c, 0xf3, 0x1b, 0x2a, 0x28, 0xf0, 0xb3, 0xec, 0x9d, 0x15, 0x17, - 0x1f, 0x1e, 0xcc, 0xcf, 0x25, 0x49, 0xc4, 0x60, 0xac, 0x53, 0x40, 0x9f, 0x84, 0x91, 0x50, 0xdc, - 0x9b, 0x62, 0xee, 0x9f, 0xef, 0x73, 0x70, 0x9c, 0x4d, 0xd2, 0x34, 0xa3, 0x16, 0x29, 0x49, 0x85, - 0x22, 0x69, 0x46, 0x38, 0x29, 0x1c, 0x6b, 0x84, 0x93, 0xe7, 0x00, 0xf6, 0xd4, 0x63, 0x20, 0x29, - 0x7f, 0xd0, 0x9e, 0x09, 0x1a, 0x16, 0xfa, 0x28, 0x4c, 0x85, 0x3c, 0xac, 0xdf, 0x72, 0xd3, 0x09, - 0x99, 0x1f, 0x8d, 0x58, 0x85, 0x2c, 0x32, 0x52, 0x2d, 0x01, 0xc3, 0x29, 0x6c, 0xb4, 0x2a, 0x5b, - 0x65, 0x31, 0x08, 0xf9, 0xc2, 0xbc, 0x18, 0xb7, 0x28, 0x72, 0xe6, 0x9e, 0x4a, 0x0e, 0x3f, 0x1b, - 0x78, 0xad, 0x26, 0xfa, 0x24, 0x00, 0x5d, 0x3e, 0x42, 0x0e, 0x31, 0x9c, 0x7f, 0x78, 0xd2, 0x53, - 0xa5, 0x91, 0x69, 0xdc, 0xcc, 0x9c, 0x5f, 0xcb, 0x8a, 0x08, 0xd6, 0x08, 0xa2, 0x2d, 0x18, 0x8f, - 0xff, 0xc5, 0x29, 0x25, 0x8f, 0xd8, 0x02, 0x93, 0x7b, 0x97, 0x75, 0x3a, 0xd8, 0x24, 0x6b, 0xff, - 0xe8, 0x00, 0x3c, 0xda, 0xe5, 0x2c, 0x46, 0x8b, 0xa6, 0xbe, 0xf7, 0xe9, 0xe4, 0x23, 0x7e, 0x2e, - 0xb3, 0xb2, 0xf1, 0xaa, 0x4f, 0x2c, 0xf9, 0xc2, 0xdb, 0x5e, 0xf2, 0x3f, 0x64, 0x69, 0xe2, 0x15, - 0x6e, 0x59, 0xfa, 0x91, 0x23, 0xde, 0x31, 0xc7, 0x28, 0x6f, 0xd9, 0xca, 0x10, 0x5a, 0x3c, 0xd7, - 0x77, 0x77, 0xfa, 0x96, 0x62, 0x9c, 0xac, 0x34, 0xfa, 0xb7, 0x2c, 0x38, 0xd7, 0x35, 0x6e, 0xc8, - 0x37, 0x21, 0x63, 0x62, 0x7f, 0xce, 0x82, 0xc7, 0x33, 0x6b, 0x18, 0xe6, 0x4c, 0x97, 0xa1, 0x54, - 0xa7, 0x85, 0x9a, 0xa3, 0x68, 0xec, 0x41, 0x2f, 0x01, 0x38, 0xc6, 0x31, 0xac, 0x96, 0x0a, 0x3d, - 0xad, 0x96, 0x7e, 0xc5, 0x82, 0xd4, 0xe1, 0x72, 0x02, 0xb7, 0x5c, 0xc5, 0xbc, 0xe5, 0xde, 0xdb, - 0xcf, 0x68, 0xe6, 0x5c, 0x70, 0x7f, 0x3c, 0x09, 0x67, 0x72, 0xdc, 0xc1, 0xf6, 0x60, 0x7a, 0xbb, - 0x4e, 0x4c, 0x17, 0xdc, 0x6e, 0xa1, 0x69, 0xba, 0xfa, 0xeb, 0xb2, 0xec, 0xa1, 0xd3, 0x29, 0x14, - 0x9c, 0x6e, 0x02, 0x7d, 0xce, 0x82, 0x53, 0xce, 0xdd, 0x70, 0x85, 0x72, 0x2b, 0x6e, 0x7d, 0xa9, - 0xe9, 0xd7, 0x77, 0xe9, 0x55, 0x20, 0x37, 0xc2, 0x0b, 0x99, 0x12, 0xa4, 0x3b, 0xb5, 0x14, 0xbe, - 0xd1, 0x3c, 0x4b, 0xa7, 0x9a, 0x85, 0x85, 0x33, 0xdb, 0x42, 0x58, 0xc4, 0xd8, 0xa7, 0x6f, 0xa1, - 0x2e, 0x4e, 0xe2, 0x59, 0x7e, 0x7b, 0xfc, 0xfa, 0x95, 0x10, 0xac, 0xe8, 0xa0, 0x4f, 0x43, 0x69, - 0x5b, 0xba, 0x99, 0x66, 0x5c, 0xef, 0xf1, 0x40, 0x76, 0x77, 0xbe, 0xe5, 0x6a, 0x60, 0x85, 0x84, - 0x63, 0xa2, 0xe8, 0x55, 0x28, 0x7a, 0x5b, 0x61, 0xb7, 0x8c, 0xa4, 0x09, 0x7b, 0x3f, 0x1e, 0x8a, - 0x61, 0x7d, 0xb5, 0x86, 0x69, 0x45, 0x74, 0x0d, 0x8a, 0xc1, 0x66, 0x43, 0x88, 0x3f, 0x33, 0x37, - 0x29, 0x5e, 0x2a, 0xe7, 0xf4, 0x8a, 0x51, 0xc2, 0x4b, 0x65, 0x4c, 0x49, 0xa0, 0x2a, 0x0c, 0x32, - 0x1f, 0x2a, 0x71, 0x99, 0x66, 0x3e, 0x1b, 0xba, 0xf8, 0x22, 0xf2, 0x78, 0x0d, 0x0c, 0x01, 0x73, - 0x42, 0x68, 0x03, 0x86, 0xea, 0x2c, 0x7b, 0xa5, 0xb8, 0x3d, 0x3f, 0x90, 0x29, 0xe8, 0xec, 0x92, - 0xd6, 0x53, 0xc8, 0xfd, 0x18, 0x06, 0x16, 0xb4, 0x18, 0x55, 0xd2, 0xde, 0xd9, 0x0a, 0x45, 0xb6, - 0xe5, 0x6c, 0xaa, 0x5d, 0xb2, 0xd5, 0x0a, 0xaa, 0x0c, 0x03, 0x0b, 0x5a, 0xe8, 0x65, 0x28, 0x6c, - 0xd5, 0x85, 0x7f, 0x54, 0xa6, 0xc4, 0xd3, 0x8c, 0xa6, 0xb1, 0x34, 0x74, 0xff, 0x60, 0xbe, 0xb0, - 0xba, 0x8c, 0x0b, 0x5b, 0x75, 0xb4, 0x0e, 0xc3, 0x5b, 0xdc, 0xff, 0x5e, 0x08, 0x35, 0x9f, 0xcc, - 0x0e, 0x0d, 0x90, 0x72, 0xd1, 0xe7, 0xbe, 0x36, 0x02, 0x80, 0x25, 0x11, 0x16, 0xb2, 0x5e, 0xc5, - 0x11, 0x10, 0x61, 0xcc, 0x16, 0x8e, 0x16, 0xfb, 0x81, 0x33, 0x37, 0x71, 0x34, 0x02, 0xac, 0x51, - 0xa4, 0xab, 0xda, 0x91, 0x29, 0xef, 0x45, 0xbc, 0x9b, 0xcc, 0x55, 0xad, 0xf2, 0xe2, 0x77, 0x5b, - 0xd5, 0x0a, 0x09, 0xc7, 0x44, 0xd1, 0x2e, 0x8c, 0xef, 0x85, 0xed, 0x1d, 0x22, 0xb7, 0x34, 0x0b, - 0x7f, 0x93, 0x73, 0x2f, 0xdf, 0x16, 0x88, 0x6e, 0x10, 0x75, 0x9c, 0x66, 0xea, 0x14, 0x62, 0x3c, - 0xd4, 0x6d, 0x9d, 0x18, 0x36, 0x69, 0xd3, 0xe1, 0x7f, 0xb3, 0xe3, 0x6f, 0xee, 0x47, 0x44, 0x44, - 0x1f, 0xcb, 0x1c, 0xfe, 0xd7, 0x39, 0x4a, 0x7a, 0xf8, 0x05, 0x00, 0x4b, 0x22, 0xe8, 0xb6, 0x18, - 0x1e, 0x76, 0x7a, 0x4e, 0xe5, 0x87, 0x08, 0x5d, 0x94, 0x48, 0x39, 0x83, 0xc2, 0x4e, 0xcb, 0x98, - 0x14, 0x3b, 0x25, 0xdb, 0x3b, 0x7e, 0xe4, 0x7b, 0x89, 0x13, 0x7a, 0x3a, 0xff, 0x94, 0xac, 0x66, - 0xe0, 0xa7, 0x4f, 0xc9, 0x2c, 0x2c, 0x9c, 0xd9, 0x16, 0x6a, 0xc0, 0x44, 0xdb, 0x0f, 0xa2, 0xbb, - 0x7e, 0x20, 0xd7, 0x17, 0xea, 0x22, 0x94, 0x31, 0x30, 0x45, 0x8b, 0x2c, 0xb0, 0x9f, 0x09, 0xc1, - 0x09, 0x9a, 0xe8, 0x63, 0x30, 0x1c, 0xd6, 0x9d, 0x26, 0xa9, 0xdc, 0x9c, 0x9d, 0xc9, 0xbf, 0x7e, - 0x6a, 0x1c, 0x25, 0x67, 0x75, 0xf1, 0xf8, 0xf6, 0x1c, 0x05, 0x4b, 0x72, 0x68, 0x15, 0x06, 0x59, - 0x4a, 0x32, 0x16, 0x2a, 0x2f, 0x27, 0xd2, 0x69, 0xca, 0xfa, 0x9a, 0x9f, 0x4d, 0xac, 0x18, 0xf3, - 0xea, 0x74, 0x0f, 0x88, 0xb7, 0x89, 0x1f, 0xce, 0x9e, 0xce, 0xdf, 0x03, 0xe2, 0x49, 0x73, 0xb3, - 0xd6, 0x6d, 0x0f, 0x28, 0x24, 0x1c, 0x13, 0xa5, 0x27, 0x33, 0x3d, 0x4d, 0xcf, 0x74, 0x31, 0x1b, - 0xca, 0x3d, 0x4b, 0xd9, 0xc9, 0x4c, 0x4f, 0x52, 0x4a, 0xc2, 0xfe, 0xbd, 0xe1, 0x34, 0xcf, 0xc2, - 0x5e, 0xb3, 0xdf, 0x63, 0xa5, 0x14, 0x9d, 0x1f, 0xec, 0x57, 0xb8, 0x76, 0x8c, 0x2c, 0xf8, 0xe7, - 0x2c, 0x38, 0xd3, 0xce, 0xfc, 0x10, 0xc1, 0x00, 0xf4, 0x27, 0xa3, 0xe3, 0x9f, 0xae, 0xc2, 0x2a, - 0x66, 0xc3, 0x71, 0x4e, 0x4b, 0xc9, 0x67, 0x4e, 0xf1, 0x6d, 0x3f, 0x73, 0xd6, 0x60, 0x84, 0x31, - 0x99, 0x3d, 0xb2, 0x39, 0x27, 0xdf, 0x7c, 0x8c, 0x95, 0x58, 0x16, 0x15, 0xb1, 0x22, 0x81, 0x7e, - 0xd8, 0x82, 0x73, 0xc9, 0xae, 0x63, 0xc2, 0xc0, 0x22, 0x16, 0x23, 0x7f, 0x48, 0xaf, 0x8a, 0xef, - 0x4f, 0xf1, 0xff, 0x06, 0xf2, 0x61, 0x2f, 0x04, 0xdc, 0xbd, 0x31, 0x54, 0xce, 0x78, 0xc9, 0x0f, - 0x99, 0xda, 0x8b, 0x3e, 0x5e, 0xf3, 0x2f, 0xc0, 0x58, 0xcb, 0xef, 0x78, 0x91, 0xb0, 0x32, 0x12, - 0x16, 0x0f, 0x4c, 0xd3, 0xbf, 0xa6, 0x95, 0x63, 0x03, 0x2b, 0x21, 0x03, 0x18, 0x79, 0x60, 0x19, - 0xc0, 0x1b, 0x30, 0xe6, 0x69, 0x66, 0xb1, 0x82, 0x1f, 0xb8, 0x98, 0x1f, 0x47, 0x55, 0x37, 0xa2, - 0xe5, 0xbd, 0xd4, 0x4b, 0xb0, 0x41, 0xed, 0x64, 0x1f, 0x7c, 0x5f, 0xb6, 0x32, 0x98, 0x7a, 0x2e, - 0x02, 0xf8, 0xb0, 0x29, 0x02, 0xb8, 0x98, 0x14, 0x01, 0xa4, 0x24, 0xd7, 0xc6, 0xeb, 0xbf, 0xff, - 0x34, 0x31, 0xfd, 0xc6, 0x62, 0xb4, 0x9b, 0x70, 0xa1, 0xd7, 0xb5, 0xc4, 0xcc, 0xcd, 0x1a, 0x4a, - 0x4f, 0x19, 0x9b, 0x9b, 0x35, 0x2a, 0x65, 0xcc, 0x20, 0xfd, 0x46, 0xf9, 0xb1, 0xff, 0x9b, 0x05, - 0xc5, 0xaa, 0xdf, 0x38, 0x81, 0x07, 0xef, 0x47, 0x8c, 0x07, 0xef, 0xa3, 0xd9, 0x17, 0x62, 0x23, - 0x57, 0xee, 0xbe, 0x92, 0x90, 0xbb, 0x9f, 0xcb, 0x23, 0xd0, 0x5d, 0xca, 0xfe, 0x93, 0x45, 0x18, - 0xad, 0xfa, 0x0d, 0x65, 0xeb, 0xfd, 0xcf, 0x1f, 0xc4, 0xd6, 0x3b, 0x37, 0xd9, 0x81, 0x46, 0x99, - 0x59, 0xa9, 0x49, 0x37, 0xd7, 0x6f, 0x32, 0x93, 0xef, 0x3b, 0xc4, 0xdd, 0xde, 0x89, 0x48, 0x23, - 0xf9, 0x39, 0x27, 0x67, 0xf2, 0xfd, 0x7b, 0x05, 0x98, 0x4c, 0xb4, 0x8e, 0x9a, 0x30, 0xde, 0xd4, - 0xa5, 0xba, 0x62, 0x9d, 0x3e, 0x90, 0x40, 0x58, 0x98, 0xcc, 0x6a, 0x45, 0xd8, 0x24, 0x8e, 0x16, - 0x00, 0x94, 0x9a, 0x53, 0x8a, 0xf5, 0x18, 0xd7, 0xaf, 0xf4, 0xa0, 0x21, 0xd6, 0x30, 0xd0, 0x8b, - 0x30, 0x1a, 0xf9, 0x6d, 0xbf, 0xe9, 0x6f, 0xef, 0x5f, 0x27, 0x32, 0xae, 0x94, 0x32, 0x84, 0xdb, - 0x88, 0x41, 0x58, 0xc7, 0x43, 0xf7, 0x60, 0x5a, 0x11, 0xa9, 0x1d, 0x83, 0xa4, 0x9b, 0x49, 0x15, - 0xd6, 0x93, 0x14, 0x71, 0xba, 0x11, 0xfb, 0xa7, 0x8b, 0x7c, 0x88, 0xbd, 0xc8, 0x7d, 0x77, 0x37, - 0xbc, 0xb3, 0x77, 0xc3, 0xd7, 0x2c, 0x98, 0xa2, 0xad, 0x33, 0x2b, 0x1f, 0x79, 0xcd, 0xab, 0xc8, - 0xcd, 0x56, 0x97, 0xc8, 0xcd, 0x17, 0xe9, 0xa9, 0xd9, 0xf0, 0x3b, 0x91, 0x90, 0xdd, 0x69, 0xc7, - 0x22, 0x2d, 0xc5, 0x02, 0x2a, 0xf0, 0x48, 0x10, 0x08, 0xcf, 0x44, 0x1d, 0x8f, 0x04, 0x01, 0x16, - 0x50, 0x19, 0xd8, 0x79, 0x20, 0x3b, 0xb0, 0x33, 0x8f, 0xcf, 0x29, 0xec, 0x41, 0x04, 0xc3, 0xa5, - 0xc5, 0xe7, 0x94, 0x86, 0x22, 0x31, 0x8e, 0xfd, 0xb3, 0x45, 0x18, 0xab, 0xfa, 0x8d, 0x58, 0xc5, - 0xf9, 0x82, 0xa1, 0xe2, 0xbc, 0x90, 0x50, 0x71, 0x4e, 0xe9, 0xb8, 0xef, 0x2a, 0x34, 0xbf, 0x51, - 0x0a, 0xcd, 0x7f, 0x62, 0xb1, 0x59, 0x2b, 0xaf, 0xd7, 0xb8, 0xd1, 0x18, 0xba, 0x02, 0xa3, 0xec, - 0x80, 0x61, 0xae, 0xb0, 0x52, 0xef, 0xc7, 0x12, 0x16, 0xad, 0xc7, 0xc5, 0x58, 0xc7, 0x41, 0x97, - 0x60, 0x24, 0x24, 0x4e, 0x50, 0xdf, 0x51, 0xa7, 0xab, 0x50, 0xd2, 0xf1, 0x32, 0xac, 0xa0, 0xe8, - 0xf5, 0x38, 0x34, 0x64, 0x31, 0xdf, 0xb5, 0x4e, 0xef, 0x0f, 0xdf, 0x22, 0xf9, 0xf1, 0x20, 0xed, - 0x3b, 0x80, 0xd2, 0xf8, 0x7d, 0xc4, 0x44, 0x9b, 0x37, 0x63, 0xa2, 0x95, 0x52, 0xf1, 0xd0, 0xfe, - 0xcc, 0x82, 0x89, 0xaa, 0xdf, 0xa0, 0x5b, 0xf7, 0x5b, 0x69, 0x9f, 0xea, 0x71, 0x71, 0x87, 0xba, - 0xc4, 0xc5, 0x7d, 0x02, 0x06, 0xab, 0x7e, 0xa3, 0x52, 0xed, 0xe6, 0xd7, 0x6e, 0xff, 0x4d, 0x0b, - 0x86, 0xab, 0x7e, 0xe3, 0x04, 0xd4, 0x02, 0x1f, 0x36, 0xd5, 0x02, 0x8f, 0xe4, 0xac, 0x9b, 0x1c, - 0x4d, 0xc0, 0x5f, 0x1f, 0x80, 0x71, 0xda, 0x4f, 0x7f, 0x5b, 0x4e, 0xa5, 0x31, 0x6c, 0x56, 0x1f, - 0xc3, 0x46, 0xb9, 0x70, 0xbf, 0xd9, 0xf4, 0xef, 0x26, 0xa7, 0x75, 0x95, 0x95, 0x62, 0x01, 0x45, - 0xcf, 0xc0, 0x48, 0x3b, 0x20, 0x7b, 0xae, 0x2f, 0xd8, 0x5b, 0x4d, 0xc9, 0x52, 0x15, 0xe5, 0x58, - 0x61, 0xd0, 0x67, 0x61, 0xe8, 0x7a, 0xf4, 0x2a, 0xaf, 0xfb, 0x5e, 0x83, 0x4b, 0xce, 0x8b, 0x22, - 0x79, 0x83, 0x56, 0x8e, 0x0d, 0x2c, 0x74, 0x07, 0x4a, 0xec, 0x3f, 0x3b, 0x76, 0x8e, 0x9e, 0x06, - 0x54, 0xa4, 0x85, 0x13, 0x04, 0x70, 0x4c, 0x0b, 0x3d, 0x07, 0x10, 0xc9, 0x00, 0xe8, 0xa1, 0x88, - 0xf2, 0xa5, 0x9e, 0x02, 0x2a, 0x34, 0x7a, 0x88, 0x35, 0x2c, 0xf4, 0x34, 0x94, 0x22, 0xc7, 0x6d, - 0xde, 0x70, 0x3d, 0x12, 0x32, 0x89, 0x78, 0x51, 0x66, 0x67, 0x13, 0x85, 0x38, 0x86, 0x53, 0x56, - 0x8c, 0x45, 0x80, 0xe0, 0x49, 0x84, 0x47, 0x18, 0x36, 0x63, 0xc5, 0x6e, 0xa8, 0x52, 0xac, 0x61, - 0xa0, 0x1d, 0x78, 0xcc, 0xf5, 0x58, 0xa2, 0x03, 0x52, 0xdb, 0x75, 0xdb, 0x1b, 0x37, 0x6a, 0xb7, - 0x49, 0xe0, 0x6e, 0xed, 0x2f, 0x39, 0xf5, 0x5d, 0xe2, 0xc9, 0x04, 0x8f, 0xef, 0x15, 0x5d, 0x7c, - 0xac, 0xd2, 0x05, 0x17, 0x77, 0xa5, 0x64, 0x3f, 0xcf, 0xd6, 0xfb, 0xcd, 0x1a, 0x7a, 0xbf, 0x71, - 0x74, 0x9c, 0xd1, 0x8f, 0x8e, 0xc3, 0x83, 0xf9, 0xa1, 0x9b, 0x35, 0x2d, 0x80, 0xc1, 0x4b, 0x70, - 0xba, 0xea, 0x37, 0xaa, 0x7e, 0x10, 0xad, 0xfa, 0xc1, 0x5d, 0x27, 0x68, 0xc8, 0xe5, 0x35, 0x2f, - 0x43, 0x38, 0xd0, 0xf3, 0x73, 0x90, 0x9f, 0x2e, 0x46, 0x78, 0x86, 0xe7, 0x19, 0xc7, 0x76, 0x44, - 0xc7, 0xa3, 0x3a, 0xe3, 0x1d, 0x54, 0xaa, 0x90, 0xab, 0x4e, 0x44, 0xd0, 0x4d, 0x96, 0x02, 0x39, - 0xbe, 0x46, 0x45, 0xf5, 0xa7, 0xb4, 0x14, 0xc8, 0x31, 0x30, 0xf3, 0xde, 0x35, 0xeb, 0xdb, 0xff, - 0x7d, 0x90, 0x9d, 0xa8, 0x89, 0x74, 0x13, 0xe8, 0x53, 0x30, 0x11, 0x92, 0x1b, 0xae, 0xd7, 0xb9, - 0x27, 0x45, 0x18, 0x5d, 0x5c, 0xc7, 0x6a, 0x2b, 0x3a, 0x26, 0x17, 0x84, 0x9a, 0x65, 0x38, 0x41, - 0x0d, 0xb5, 0x60, 0xe2, 0xae, 0xeb, 0x35, 0xfc, 0xbb, 0xa1, 0xa4, 0x3f, 0x92, 0x2f, 0x0f, 0xbd, - 0xc3, 0x31, 0x13, 0x7d, 0x34, 0x9a, 0xbb, 0x63, 0x10, 0xc3, 0x09, 0xe2, 0x74, 0xd5, 0x06, 0x1d, - 0x6f, 0x31, 0xbc, 0x15, 0x92, 0x40, 0x24, 0xb3, 0x66, 0xab, 0x16, 0xcb, 0x42, 0x1c, 0xc3, 0xe9, - 0xaa, 0x65, 0x7f, 0xae, 0x06, 0x7e, 0x87, 0xe7, 0x36, 0x10, 0xab, 0x16, 0xab, 0x52, 0xac, 0x61, - 0xd0, 0x5d, 0xcd, 0xfe, 0xad, 0xfb, 0x1e, 0xf6, 0xfd, 0x48, 0x9e, 0x03, 0x2c, 0x7d, 0xaa, 0x56, - 0x8e, 0x0d, 0x2c, 0xb4, 0x0a, 0x28, 0xec, 0xb4, 0xdb, 0x4d, 0x66, 0x93, 0xe2, 0x34, 0x19, 0x29, - 0xae, 0xa7, 0x2f, 0xf2, 0x90, 0xaf, 0xb5, 0x14, 0x14, 0x67, 0xd4, 0xa0, 0x07, 0xfc, 0x96, 0xe8, - 0xea, 0x20, 0xeb, 0x2a, 0xd7, 0x9d, 0xd4, 0x78, 0x3f, 0x25, 0x0c, 0xad, 0xc0, 0x70, 0xb8, 0x1f, - 0xd6, 0x23, 0x11, 0xa1, 0x2f, 0x27, 0xa3, 0x50, 0x8d, 0xa1, 0x68, 0x09, 0xed, 0x78, 0x15, 0x2c, - 0xeb, 0xa2, 0x3a, 0xcc, 0x08, 0x8a, 0xcb, 0x3b, 0x8e, 0xa7, 0xf2, 0xb3, 0x70, 0xd3, 0xdc, 0x2b, - 0xf7, 0x0f, 0xe6, 0x67, 0x44, 0xcb, 0x3a, 0xf8, 0xf0, 0x60, 0xfe, 0x4c, 0xd5, 0x6f, 0x64, 0x40, - 0x70, 0x16, 0x35, 0xbe, 0xf8, 0xea, 0x75, 0xbf, 0xd5, 0xae, 0x06, 0xfe, 0x96, 0xdb, 0x24, 0xdd, - 0xf4, 0x4f, 0x35, 0x03, 0x53, 0x2c, 0x3e, 0xa3, 0x0c, 0x27, 0xa8, 0xd9, 0xdf, 0xc9, 0x98, 0x20, - 0x96, 0xbf, 0x39, 0xea, 0x04, 0x04, 0xb5, 0x60, 0xbc, 0xcd, 0xb6, 0x89, 0xc8, 0x38, 0x20, 0xd6, - 0xfa, 0x0b, 0x7d, 0xca, 0x51, 0xee, 0xd2, 0xbb, 0xc3, 0xb4, 0x6d, 0xa9, 0xea, 0xe4, 0xb0, 0x49, - 0xdd, 0xfe, 0x8d, 0x47, 0xd8, 0x35, 0x5a, 0xe3, 0xc2, 0x91, 0x61, 0xe1, 0x09, 0x20, 0xde, 0x63, - 0x73, 0xf9, 0x52, 0xba, 0x78, 0x5a, 0x84, 0x37, 0x01, 0x96, 0x75, 0xd1, 0x27, 0x61, 0x82, 0x3e, - 0x6f, 0xd4, 0x55, 0x16, 0xce, 0x9e, 0xca, 0x8f, 0xd8, 0xa0, 0xb0, 0xf4, 0x6c, 0x24, 0x7a, 0x65, - 0x9c, 0x20, 0x86, 0x5e, 0x67, 0xb6, 0x24, 0x92, 0x74, 0xa1, 0x1f, 0xd2, 0xba, 0xd9, 0x88, 0x24, - 0xab, 0x11, 0x41, 0x1d, 0x98, 0x49, 0xe7, 0x2e, 0x0b, 0x67, 0xed, 0x7c, 0x3e, 0x31, 0x9d, 0x7e, - 0x2c, 0x4e, 0x1b, 0x91, 0x86, 0x85, 0x38, 0x8b, 0x3e, 0xba, 0x01, 0xe3, 0x22, 0x89, 0xb1, 0x58, - 0xb9, 0x45, 0x43, 0x78, 0x38, 0x8e, 0x75, 0xe0, 0x61, 0xb2, 0x00, 0x9b, 0x95, 0xd1, 0x36, 0x9c, - 0xd3, 0x92, 0x0a, 0x5d, 0x0d, 0x1c, 0x66, 0x01, 0xe0, 0xb2, 0xe3, 0x54, 0xbb, 0xe0, 0x1f, 0xbf, - 0x7f, 0x30, 0x7f, 0x6e, 0xa3, 0x1b, 0x22, 0xee, 0x4e, 0x07, 0xdd, 0x84, 0xd3, 0xdc, 0xdf, 0xb8, - 0x4c, 0x9c, 0x46, 0xd3, 0xf5, 0x14, 0x07, 0xc1, 0xb7, 0xfc, 0xd9, 0xfb, 0x07, 0xf3, 0xa7, 0x17, - 0xb3, 0x10, 0x70, 0x76, 0x3d, 0xf4, 0x61, 0x28, 0x35, 0xbc, 0x50, 0x8c, 0xc1, 0x90, 0x91, 0xb7, - 0xa9, 0x54, 0x5e, 0xaf, 0xa9, 0xef, 0x8f, 0xff, 0xe0, 0xb8, 0x02, 0xda, 0xe6, 0x02, 0x66, 0x25, - 0xf6, 0x18, 0x4e, 0xc5, 0x5b, 0x4a, 0x4a, 0x06, 0x0d, 0x8f, 0x43, 0xae, 0x59, 0x51, 0x86, 0xf8, - 0x86, 0x33, 0xa2, 0x41, 0x18, 0xbd, 0x06, 0x88, 0x3e, 0x3b, 0xdc, 0x3a, 0x59, 0xac, 0xb3, 0x74, - 0x16, 0x4c, 0x1e, 0x3f, 0x62, 0xfa, 0xc0, 0xd5, 0x52, 0x18, 0x38, 0xa3, 0x16, 0xba, 0x46, 0x4f, - 0x15, 0xbd, 0x54, 0x9c, 0x5a, 0x2a, 0xcb, 0x5e, 0x99, 0xb4, 0x03, 0x52, 0x77, 0x22, 0xd2, 0x30, - 0x29, 0xe2, 0x44, 0x3d, 0xd4, 0x80, 0xc7, 0x9c, 0x4e, 0xe4, 0x33, 0xd9, 0xbd, 0x89, 0xba, 0xe1, - 0xef, 0x12, 0x8f, 0xa9, 0xcd, 0x46, 0x96, 0x2e, 0x50, 0x16, 0x65, 0xb1, 0x0b, 0x1e, 0xee, 0x4a, - 0x85, 0xb2, 0x96, 0x2a, 0xad, 0x2e, 0x98, 0x51, 0xa4, 0x32, 0x52, 0xeb, 0xbe, 0x08, 0xa3, 0x3b, - 0x7e, 0x18, 0xad, 0x93, 0xe8, 0xae, 0x1f, 0xec, 0x8a, 0x68, 0xa8, 0x71, 0x6c, 0xe9, 0x18, 0x84, - 0x75, 0x3c, 0xfa, 0x76, 0x64, 0x46, 0x1d, 0x95, 0x32, 0xd3, 0xa7, 0x8f, 0xc4, 0x67, 0xcc, 0x35, - 0x5e, 0x8c, 0x25, 0x5c, 0xa2, 0x56, 0xaa, 0xcb, 0x4c, 0x37, 0x9e, 0x40, 0xad, 0x54, 0x97, 0xb1, - 0x84, 0xd3, 0xe5, 0x1a, 0xee, 0x38, 0x01, 0xa9, 0x06, 0x7e, 0x9d, 0x84, 0x5a, 0x44, 0xf3, 0x47, - 0x79, 0xac, 0x57, 0xba, 0x5c, 0x6b, 0x59, 0x08, 0x38, 0xbb, 0x1e, 0x22, 0xe9, 0x84, 0x5a, 0x13, - 0xf9, 0x4a, 0x8d, 0x34, 0x3f, 0xd3, 0x67, 0x4e, 0x2d, 0x0f, 0xa6, 0x54, 0x2a, 0x2f, 0x1e, 0xdd, - 0x35, 0x9c, 0x9d, 0x64, 0x6b, 0xbb, 0xff, 0xd0, 0xb0, 0x4a, 0x4d, 0x54, 0x49, 0x50, 0xc2, 0x29, - 0xda, 0x46, 0xa0, 0xb0, 0xa9, 0x9e, 0x81, 0xc2, 0x2e, 0x43, 0x29, 0xec, 0x6c, 0x36, 0xfc, 0x96, - 0xe3, 0x7a, 0x4c, 0x37, 0xae, 0x3d, 0x62, 0x6a, 0x12, 0x80, 0x63, 0x1c, 0xb4, 0x0a, 0x23, 0x8e, - 0xd4, 0x01, 0xa1, 0xfc, 0xd0, 0x30, 0x4a, 0xf3, 0xc3, 0xa3, 0x25, 0x48, 0xad, 0x8f, 0xaa, 0x8b, - 0x5e, 0x81, 0x71, 0xe1, 0x2f, 0x2b, 0xb2, 0x48, 0xce, 0x98, 0x4e, 0x4d, 0x35, 0x1d, 0x88, 0x4d, - 0x5c, 0x74, 0x0b, 0x46, 0x23, 0xbf, 0xc9, 0x3c, 0x73, 0x28, 0x9b, 0x77, 0x26, 0x3f, 0xc8, 0xd9, - 0x86, 0x42, 0xd3, 0xc5, 0xaf, 0xaa, 0x2a, 0xd6, 0xe9, 0xa0, 0x0d, 0xbe, 0xde, 0x59, 0xfc, 0x72, - 0x12, 0xce, 0x3e, 0x92, 0x7f, 0x27, 0xa9, 0x30, 0xe7, 0xe6, 0x76, 0x10, 0x35, 0xb1, 0x4e, 0x06, - 0x5d, 0x85, 0xe9, 0x76, 0xe0, 0xfa, 0x6c, 0x4d, 0x28, 0xf5, 0xdf, 0xac, 0x99, 0x56, 0xa8, 0x9a, - 0x44, 0xc0, 0xe9, 0x3a, 0xcc, 0xdd, 0x59, 0x14, 0xce, 0x9e, 0xe5, 0x89, 0xa6, 0xf9, 0x9b, 0x90, - 0x97, 0x61, 0x05, 0x45, 0x6b, 0xec, 0x24, 0xe6, 0xe2, 0x8c, 0xd9, 0xb9, 0xfc, 0x68, 0x34, 0xba, - 0xd8, 0x83, 0x33, 0xaf, 0xea, 0x2f, 0x8e, 0x29, 0xa0, 0x86, 0x96, 0x91, 0x90, 0xbe, 0x18, 0xc2, - 0xd9, 0xc7, 0xba, 0x58, 0xd6, 0x25, 0x9e, 0x17, 0x31, 0x43, 0x60, 0x14, 0x87, 0x38, 0x41, 0x13, - 0x7d, 0x14, 0xa6, 0x44, 0x0c, 0xbd, 0x78, 0x98, 0xce, 0xc5, 0xf6, 0xce, 0x38, 0x01, 0xc3, 0x29, - 0x6c, 0x9e, 0xf1, 0xc0, 0xd9, 0x6c, 0x12, 0x71, 0xf4, 0xdd, 0x70, 0xbd, 0xdd, 0x70, 0xf6, 0x3c, - 0x3b, 0x1f, 0x44, 0xc6, 0x83, 0x24, 0x14, 0x67, 0xd4, 0x40, 0x1b, 0x30, 0xd5, 0x0e, 0x08, 0x69, - 0x31, 0x46, 0x5f, 0xdc, 0x67, 0xf3, 0xdc, 0xdb, 0x9f, 0xf6, 0xa4, 0x9a, 0x80, 0x1d, 0x66, 0x94, - 0xe1, 0x14, 0x05, 0x74, 0x17, 0x46, 0xfc, 0x3d, 0x12, 0xec, 0x10, 0xa7, 0x31, 0x7b, 0xa1, 0x8b, - 0xfd, 0xbd, 0xb8, 0xdc, 0x6e, 0x0a, 0xdc, 0x84, 0xc9, 0x80, 0x2c, 0xee, 0x6d, 0x32, 0x20, 0x1b, - 0x43, 0x3f, 0x62, 0xc1, 0x59, 0xa9, 0x65, 0xa8, 0xb5, 0xe9, 0xa8, 0x2f, 0xfb, 0x5e, 0x18, 0x05, - 0xdc, 0x3f, 0xfd, 0xf1, 0x7c, 0x9f, 0xed, 0x8d, 0x9c, 0x4a, 0x4a, 0xa2, 0x7a, 0x36, 0x0f, 0x23, - 0xc4, 0xf9, 0x2d, 0xa2, 0x65, 0x98, 0x0e, 0x49, 0x24, 0x0f, 0xa3, 0xc5, 0x70, 0xf5, 0xf5, 0xf2, - 0xfa, 0xec, 0x13, 0xdc, 0xb9, 0x9e, 0x6e, 0x86, 0x5a, 0x12, 0x88, 0xd3, 0xf8, 0xe8, 0x0a, 0x14, - 0xfc, 0x70, 0xf6, 0xbd, 0x5d, 0x92, 0x58, 0xd2, 0xa7, 0x38, 0x37, 0x1d, 0xbb, 0x59, 0xc3, 0x05, - 0x3f, 0x9c, 0xfb, 0x76, 0x98, 0x4e, 0x71, 0x0c, 0x47, 0x49, 0xfe, 0x32, 0xb7, 0x0b, 0xe3, 0xc6, - 0xac, 0x3c, 0x54, 0x2d, 0xf5, 0xbf, 0x1a, 0x86, 0x92, 0xd2, 0x60, 0xa2, 0xcb, 0xa6, 0x62, 0xfa, - 0x6c, 0x52, 0x31, 0x3d, 0x52, 0xf5, 0x1b, 0x86, 0x2e, 0x7a, 0x23, 0x23, 0x0a, 0x59, 0xde, 0x19, - 0xd0, 0xbf, 0x7b, 0xb9, 0x26, 0x16, 0x2e, 0xf6, 0xad, 0xe1, 0x1e, 0xe8, 0x2a, 0x69, 0xbe, 0x0a, - 0xd3, 0x9e, 0xcf, 0xd8, 0x54, 0xd2, 0x90, 0x3c, 0x08, 0x63, 0x35, 0x4a, 0x7a, 0x58, 0x8f, 0x04, - 0x02, 0x4e, 0xd7, 0xa1, 0x0d, 0x72, 0x5e, 0x21, 0x29, 0xda, 0xe6, 0xac, 0x04, 0x16, 0x50, 0xf4, - 0x04, 0x0c, 0xb6, 0xfd, 0x46, 0xa5, 0x2a, 0x58, 0x54, 0x2d, 0xf6, 0x65, 0xa3, 0x52, 0xc5, 0x1c, - 0x86, 0x16, 0x61, 0x88, 0xfd, 0x08, 0x67, 0xc7, 0xf2, 0xe3, 0x37, 0xb0, 0x1a, 0x5a, 0x6a, 0x1d, - 0x56, 0x01, 0x8b, 0x8a, 0x4c, 0xc4, 0x46, 0xf9, 0x7a, 0x26, 0x62, 0x1b, 0x7e, 0x40, 0x11, 0x9b, - 0x24, 0x80, 0x63, 0x5a, 0xe8, 0x1e, 0x9c, 0x36, 0xde, 0x52, 0x7c, 0x89, 0x90, 0x50, 0xf8, 0x90, - 0x3f, 0xd1, 0xf5, 0x11, 0x25, 0x34, 0xe2, 0xe7, 0x44, 0xa7, 0x4f, 0x57, 0xb2, 0x28, 0xe1, 0xec, - 0x06, 0x50, 0x13, 0xa6, 0xeb, 0xa9, 0x56, 0x47, 0xfa, 0x6f, 0x55, 0x4d, 0x68, 0xba, 0xc5, 0x34, - 0x61, 0xf4, 0x0a, 0x8c, 0xbc, 0xe9, 0x87, 0xec, 0x78, 0x17, 0x6c, 0xb5, 0x74, 0x40, 0x1e, 0x79, - 0xfd, 0x66, 0x8d, 0x95, 0x1f, 0x1e, 0xcc, 0x8f, 0x56, 0xfd, 0x86, 0xfc, 0x8b, 0x55, 0x05, 0xf4, - 0xfd, 0x16, 0xcc, 0xa5, 0x1f, 0x6b, 0xaa, 0xd3, 0xe3, 0xfd, 0x77, 0xda, 0x16, 0x8d, 0xce, 0xad, - 0xe4, 0x92, 0xc3, 0x5d, 0x9a, 0xb2, 0x7f, 0xc9, 0x62, 0x82, 0x3a, 0xa1, 0x69, 0x22, 0x61, 0xa7, - 0x79, 0x12, 0x19, 0x45, 0x57, 0x0c, 0x25, 0xd8, 0x03, 0x5b, 0x48, 0xfc, 0x33, 0x8b, 0x59, 0x48, - 0x9c, 0xa0, 0x2b, 0xc4, 0xeb, 0x30, 0x12, 0xc9, 0x4c, 0xaf, 0x5d, 0x92, 0xa0, 0x6a, 0x9d, 0x62, - 0x56, 0x22, 0x8a, 0xc9, 0x55, 0x49, 0x5d, 0x15, 0x19, 0xfb, 0x1f, 0xf2, 0x19, 0x90, 0x90, 0x13, - 0xd0, 0x35, 0x94, 0x4d, 0x5d, 0xc3, 0x7c, 0x8f, 0x2f, 0xc8, 0xd1, 0x39, 0xfc, 0x03, 0xb3, 0xdf, - 0x4c, 0xb8, 0xf3, 0x4e, 0x37, 0xcd, 0xb1, 0x3f, 0x6f, 0x01, 0xc4, 0xa1, 0x85, 0x99, 0x48, 0xda, - 0x0f, 0x64, 0x3a, 0xc9, 0xac, 0xc4, 0x49, 0x2f, 0x51, 0xb6, 0xd6, 0x8f, 0xfc, 0xba, 0xdf, 0x14, - 0x9a, 0xb4, 0xc7, 0x62, 0x75, 0x07, 0x2f, 0x3f, 0xd4, 0x7e, 0x63, 0x85, 0x8d, 0xe6, 0x65, 0x20, - 0xb3, 0x62, 0xac, 0x80, 0x33, 0x82, 0x98, 0x7d, 0xd1, 0x82, 0x53, 0x59, 0x76, 0xb5, 0xf4, 0x91, - 0xc4, 0xc5, 0x5c, 0xca, 0x6c, 0x4a, 0xcd, 0xe6, 0x6d, 0x51, 0x8e, 0x15, 0x46, 0xdf, 0x49, 0xd2, - 0x8e, 0x16, 0xd3, 0xf7, 0x26, 0x8c, 0x57, 0x03, 0xa2, 0x5d, 0xae, 0xaf, 0x72, 0xe7, 0x78, 0xde, - 0x9f, 0x67, 0x8e, 0xec, 0x18, 0x6f, 0x7f, 0xa5, 0x00, 0xa7, 0xb8, 0xf5, 0xc1, 0xe2, 0x9e, 0xef, - 0x36, 0xaa, 0x7e, 0x43, 0x24, 0xb8, 0xfb, 0x04, 0x8c, 0xb5, 0x35, 0xd9, 0x64, 0xb7, 0xf8, 0x94, - 0xba, 0x0c, 0x33, 0x96, 0xa6, 0xe8, 0xa5, 0xd8, 0xa0, 0x85, 0x1a, 0x30, 0x46, 0xf6, 0xdc, 0xba, - 0x52, 0x61, 0x17, 0x8e, 0x7c, 0xd1, 0xa9, 0x56, 0x56, 0x34, 0x3a, 0xd8, 0xa0, 0xfa, 0x10, 0x52, - 0x17, 0xdb, 0x5f, 0xb2, 0xe0, 0x91, 0x9c, 0x68, 0x96, 0xb4, 0xb9, 0xbb, 0xcc, 0xce, 0x43, 0x2c, - 0x5b, 0xd5, 0x1c, 0xb7, 0xfe, 0xc0, 0x02, 0x8a, 0x3e, 0x06, 0xc0, 0xad, 0x37, 0xe8, 0x2b, 0xbd, - 0x57, 0xd8, 0x3f, 0x23, 0x62, 0x99, 0x16, 0x7c, 0x4a, 0xd6, 0xc7, 0x1a, 0x2d, 0xfb, 0x8b, 0x03, - 0x30, 0xc8, 0xd3, 0xac, 0x57, 0x61, 0x78, 0x87, 0xe7, 0x27, 0xe9, 0x3a, 0x6f, 0x14, 0x57, 0xa6, - 0x3c, 0x89, 0xe7, 0x4d, 0x2b, 0xc5, 0x92, 0x0c, 0x5a, 0x83, 0x19, 0x9e, 0x26, 0xa6, 0x59, 0x26, - 0x4d, 0x67, 0x5f, 0x8a, 0xfd, 0x78, 0xf2, 0x51, 0x25, 0xfe, 0xac, 0xa4, 0x51, 0x70, 0x56, 0x3d, - 0xf4, 0x2a, 0x4c, 0xd0, 0x67, 0x98, 0xdf, 0x89, 0x24, 0x25, 0x9e, 0x20, 0x46, 0xbd, 0xfb, 0x36, - 0x0c, 0x28, 0x4e, 0x60, 0xa3, 0x57, 0x60, 0xbc, 0x9d, 0x12, 0x70, 0x0e, 0xc6, 0x92, 0x00, 0x53, - 0xa8, 0x69, 0xe2, 0x32, 0xd3, 0xda, 0x0e, 0x33, 0x24, 0xde, 0xd8, 0x09, 0x48, 0xb8, 0xe3, 0x37, - 0x1b, 0x8c, 0xfd, 0x1b, 0xd4, 0x4c, 0x6b, 0x13, 0x70, 0x9c, 0xaa, 0x41, 0xa9, 0x6c, 0x39, 0x6e, - 0xb3, 0x13, 0x90, 0x98, 0xca, 0x90, 0x49, 0x65, 0x35, 0x01, 0xc7, 0xa9, 0x1a, 0xbd, 0x25, 0xb7, - 0xc3, 0xc7, 0x23, 0xb9, 0xb5, 0xff, 0x8b, 0x05, 0xc6, 0xd4, 0x7e, 0x0b, 0x27, 0xae, 0xf9, 0x92, - 0x05, 0xa7, 0xab, 0x81, 0x4f, 0xaf, 0x29, 0x19, 0x00, 0x49, 0xd9, 0xa0, 0x0f, 0x4b, 0x5f, 0xed, - 0x2e, 0xa1, 0x02, 0x85, 0x95, 0x2e, 0xa7, 0x60, 0x98, 0x81, 0xd4, 0x84, 0x97, 0xb6, 0xa4, 0x82, - 0xae, 0xc0, 0xa8, 0xc8, 0x27, 0xc2, 0x4c, 0xa5, 0xf9, 0x76, 0x60, 0x66, 0x2b, 0xe5, 0xb8, 0x18, - 0xeb, 0x38, 0xf6, 0x0f, 0x14, 0x60, 0x26, 0xc3, 0xd7, 0x85, 0x5f, 0x04, 0xdb, 0x6e, 0x18, 0xa9, - 0xa4, 0x95, 0xda, 0x45, 0xc0, 0xcb, 0xb1, 0xc2, 0xa0, 0xa7, 0x0d, 0xbf, 0x6a, 0x92, 0xd7, 0x8b, - 0xb0, 0x25, 0x17, 0xd0, 0x23, 0xa6, 0x7f, 0xbc, 0x00, 0x03, 0x9d, 0x90, 0xc8, 0x20, 0x9f, 0xea, - 0xe2, 0x65, 0x8a, 0x49, 0x06, 0xa1, 0x0f, 0xa1, 0x6d, 0xa5, 0xe3, 0xd3, 0x1e, 0x42, 0x5c, 0xcb, - 0xc7, 0x61, 0xb4, 0x73, 0x11, 0xf1, 0x1c, 0x2f, 0x12, 0xcf, 0xa5, 0x38, 0x5a, 0x1d, 0x2b, 0xc5, - 0x02, 0x6a, 0x7f, 0xa1, 0x08, 0x67, 0x73, 0xbd, 0xdf, 0x68, 0xd7, 0x5b, 0xbe, 0xe7, 0x46, 0xbe, - 0xb2, 0x07, 0xe2, 0x11, 0xea, 0x48, 0x7b, 0x67, 0x4d, 0x94, 0x63, 0x85, 0x81, 0x2e, 0xc2, 0x20, - 0x13, 0x6b, 0xa6, 0xd2, 0x77, 0x2e, 0x95, 0x79, 0xc8, 0x22, 0x0e, 0xee, 0x3b, 0x35, 0xf2, 0x13, - 0x94, 0x07, 0xf1, 0x9b, 0xc9, 0x2b, 0x81, 0x76, 0xd7, 0xf7, 0x9b, 0x98, 0x01, 0xd1, 0xfb, 0xc4, - 0x78, 0x25, 0x0c, 0x60, 0xb0, 0xd3, 0xf0, 0x43, 0x6d, 0xd0, 0x9e, 0x82, 0xe1, 0x5d, 0xb2, 0x1f, - 0xb8, 0xde, 0x76, 0xd2, 0x30, 0xea, 0x3a, 0x2f, 0xc6, 0x12, 0x6e, 0xe6, 0x9b, 0x1b, 0x3e, 0xee, - 0x9c, 0xc6, 0x23, 0x3d, 0x19, 0x8c, 0x1f, 0x2a, 0xc2, 0x24, 0x5e, 0x2a, 0xbf, 0x3b, 0x11, 0xb7, - 0xd2, 0x13, 0x71, 0xdc, 0x39, 0x8d, 0x7b, 0xcf, 0xc6, 0xcf, 0x5b, 0x30, 0xc9, 0xb2, 0x9a, 0x88, - 0xd8, 0x66, 0xae, 0xef, 0x9d, 0x00, 0x33, 0xff, 0x04, 0x0c, 0x06, 0xb4, 0xd1, 0x64, 0xde, 0x4e, - 0xd6, 0x13, 0xcc, 0x61, 0xe8, 0x31, 0x18, 0x60, 0x5d, 0xa0, 0x93, 0x37, 0xc6, 0xaf, 0x87, 0xb2, - 0x13, 0x39, 0x98, 0x95, 0xb2, 0x80, 0x3d, 0x98, 0xb4, 0x9b, 0x2e, 0xef, 0x74, 0xac, 0x74, 0x7e, - 0x67, 0xf8, 0xc5, 0x67, 0x76, 0xed, 0xed, 0x05, 0xec, 0xc9, 0x26, 0xd9, 0xfd, 0xa1, 0xfc, 0x47, - 0x05, 0x38, 0x9f, 0x59, 0xaf, 0xef, 0x80, 0x3d, 0xdd, 0x6b, 0x3f, 0xcc, 0xbc, 0x15, 0xc5, 0x13, - 0x34, 0x3b, 0x1d, 0xe8, 0x97, 0x7f, 0x1f, 0xec, 0x23, 0x8e, 0x4e, 0xe6, 0x90, 0xbd, 0x43, 0xe2, - 0xe8, 0x64, 0xf6, 0x2d, 0xe7, 0xa1, 0xff, 0xe7, 0x85, 0x9c, 0x6f, 0x61, 0x4f, 0xfe, 0x4b, 0xf4, - 0x9c, 0x61, 0xc0, 0x50, 0x3e, 0xa3, 0xf9, 0x19, 0xc3, 0xcb, 0xb0, 0x82, 0xa2, 0x45, 0x98, 0x6c, - 0xb9, 0x1e, 0x3d, 0x7c, 0xf6, 0x4d, 0x66, 0x5a, 0x85, 0x39, 0x5b, 0x33, 0xc1, 0x38, 0x89, 0x8f, - 0x5c, 0x2d, 0xc6, 0x4e, 0x21, 0x3f, 0x13, 0x7e, 0x6e, 0x6f, 0x17, 0x4c, 0x85, 0xbc, 0x1a, 0xc5, - 0x8c, 0x78, 0x3b, 0x6b, 0x9a, 0xa4, 0xa7, 0xd8, 0xbf, 0xa4, 0x67, 0x2c, 0x5b, 0xca, 0x33, 0xf7, - 0x0a, 0x8c, 0x3f, 0xb0, 0x68, 0xdf, 0xfe, 0x5a, 0x11, 0x1e, 0xed, 0xb2, 0xed, 0xf9, 0x59, 0x6f, - 0xcc, 0x81, 0x76, 0xd6, 0xa7, 0xe6, 0xa1, 0x0a, 0xa7, 0xb6, 0x3a, 0xcd, 0xe6, 0x3e, 0xf3, 0xc6, - 0x20, 0x0d, 0x89, 0x21, 0x78, 0x4a, 0x29, 0xde, 0x38, 0xb5, 0x9a, 0x81, 0x83, 0x33, 0x6b, 0xd2, - 0x47, 0x12, 0xbd, 0x49, 0xf6, 0x15, 0xa9, 0xc4, 0x23, 0x09, 0xeb, 0x40, 0x6c, 0xe2, 0xa2, 0xab, - 0x30, 0xed, 0xec, 0x39, 0x2e, 0x0f, 0x54, 0x2c, 0x09, 0xf0, 0x57, 0x92, 0x92, 0xc8, 0x2e, 0x26, - 0x11, 0x70, 0xba, 0x0e, 0x7a, 0x0d, 0x90, 0xbf, 0xc9, 0x6c, 0xb6, 0x1b, 0x57, 0x89, 0x27, 0xf4, - 0xa6, 0x6c, 0xee, 0x8a, 0xf1, 0x91, 0x70, 0x33, 0x85, 0x81, 0x33, 0x6a, 0x25, 0x62, 0xc9, 0x0c, - 0xe5, 0xc7, 0x92, 0xe9, 0x7e, 0x2e, 0xf6, 0x4c, 0x99, 0xf2, 0x1f, 0x2d, 0x7a, 0x7d, 0x71, 0x26, - 0xdf, 0x0c, 0xbd, 0xf8, 0x0a, 0xb3, 0x7b, 0xe4, 0xd2, 0x5a, 0x2d, 0x02, 0xca, 0x69, 0xcd, 0xee, - 0x31, 0x06, 0x62, 0x13, 0x97, 0x2f, 0x88, 0x30, 0x76, 0xbc, 0x35, 0x58, 0x7c, 0x11, 0x1f, 0x4a, - 0x61, 0xa0, 0x8f, 0xc3, 0x70, 0xc3, 0xdd, 0x73, 0x43, 0x21, 0xab, 0x3a, 0xb2, 0x62, 0x28, 0x3e, - 0x07, 0xcb, 0x9c, 0x0c, 0x96, 0xf4, 0xec, 0x1f, 0x2a, 0xc0, 0xb8, 0x6c, 0xf1, 0xf5, 0x8e, 0x1f, - 0x39, 0x27, 0x70, 0x2d, 0x5f, 0x35, 0xae, 0xe5, 0xf7, 0x75, 0x0b, 0x92, 0xc5, 0xba, 0x94, 0x7b, - 0x1d, 0xdf, 0x4c, 0x5c, 0xc7, 0x4f, 0xf6, 0x26, 0xd5, 0xfd, 0x1a, 0xfe, 0x47, 0x16, 0x4c, 0x1b, - 0xf8, 0x27, 0x70, 0x1b, 0xac, 0x9a, 0xb7, 0xc1, 0xe3, 0x3d, 0xbf, 0x21, 0xe7, 0x16, 0xf8, 0xde, - 0x62, 0xa2, 0xef, 0xec, 0xf4, 0x7f, 0x13, 0x06, 0x76, 0x9c, 0xa0, 0xd1, 0x2d, 0x29, 0x40, 0xaa, - 0xd2, 0xc2, 0x35, 0x27, 0x10, 0x8a, 0xe3, 0x67, 0x54, 0x22, 0x7a, 0x27, 0xe8, 0xad, 0x34, 0x66, - 0x4d, 0xa1, 0x97, 0x60, 0x28, 0xac, 0xfb, 0x6d, 0xe5, 0x8b, 0x71, 0x81, 0x27, 0xa9, 0xa7, 0x25, - 0x87, 0x07, 0xf3, 0xc8, 0x6c, 0x8e, 0x16, 0x63, 0x81, 0x8f, 0x3e, 0x01, 0xe3, 0xec, 0x97, 0xb2, - 0xe2, 0x2a, 0xe6, 0x0b, 0x14, 0x6a, 0x3a, 0x22, 0x37, 0x71, 0x34, 0x8a, 0xb0, 0x49, 0x6a, 0x6e, - 0x1b, 0x4a, 0xea, 0xb3, 0x1e, 0xaa, 0xe6, 0xf5, 0xdf, 0x15, 0x61, 0x26, 0x63, 0xcd, 0xa1, 0xd0, - 0x98, 0x89, 0x2b, 0x7d, 0x2e, 0xd5, 0xb7, 0x39, 0x17, 0x21, 0x7b, 0x0d, 0x35, 0xc4, 0xda, 0xea, - 0xbb, 0xd1, 0x5b, 0x21, 0x49, 0x36, 0x4a, 0x8b, 0x7a, 0x37, 0x4a, 0x1b, 0x3b, 0xb1, 0xa1, 0xa6, - 0x0d, 0xa9, 0x9e, 0x3e, 0xd4, 0x39, 0xfd, 0xd3, 0x22, 0x9c, 0xca, 0x8a, 0xdb, 0x87, 0x3e, 0x9b, - 0x48, 0x49, 0xf9, 0x42, 0xbf, 0x11, 0xff, 0x78, 0x9e, 0x4a, 0x2e, 0x61, 0x5f, 0x5a, 0x30, 0x93, - 0x54, 0xf6, 0x1c, 0x66, 0xd1, 0x26, 0x0b, 0x2a, 0x11, 0xf0, 0x54, 0xa2, 0xf2, 0xf8, 0xf8, 0x60, - 0xdf, 0x1d, 0x10, 0x39, 0x48, 0xc3, 0x84, 0x85, 0x88, 0x2c, 0xee, 0x6d, 0x21, 0x22, 0x5b, 0x9e, - 0x73, 0x61, 0x54, 0xfb, 0x9a, 0x87, 0x3a, 0xe3, 0xbb, 0xf4, 0xb6, 0xd2, 0xfa, 0xfd, 0x50, 0x67, - 0xfd, 0x4b, 0x16, 0x24, 0x9c, 0x06, 0x94, 0x58, 0xcc, 0xca, 0x15, 0x8b, 0x5d, 0x80, 0x81, 0xc0, - 0x6f, 0x92, 0x64, 0xee, 0x46, 0xec, 0x37, 0x09, 0x66, 0x10, 0x8a, 0x11, 0xc5, 0xc2, 0x8e, 0x31, - 0xfd, 0x21, 0x27, 0x9e, 0x68, 0x4f, 0xc0, 0x60, 0x93, 0xec, 0x91, 0x66, 0x32, 0xc5, 0xce, 0x0d, - 0x5a, 0x88, 0x39, 0xcc, 0xfe, 0xf9, 0x01, 0x38, 0xd7, 0x35, 0x2c, 0x0b, 0x7d, 0x0e, 0x6d, 0x3b, - 0x11, 0xb9, 0xeb, 0xec, 0x27, 0x73, 0x61, 0x5c, 0xe5, 0xc5, 0x58, 0xc2, 0x99, 0x2f, 0x18, 0x0f, - 0x69, 0x9d, 0x10, 0x22, 0x8a, 0x48, 0xd6, 0x02, 0x6a, 0x0a, 0xa5, 0x8a, 0xc7, 0x21, 0x94, 0x7a, - 0x0e, 0x20, 0x0c, 0x9b, 0xdc, 0xb4, 0xaa, 0x21, 0x9c, 0xcc, 0xe2, 0xd0, 0xe7, 0xb5, 0x1b, 0x02, - 0x82, 0x35, 0x2c, 0x54, 0x86, 0xa9, 0x76, 0xe0, 0x47, 0x5c, 0x26, 0x5b, 0xe6, 0xd6, 0x87, 0x83, - 0x66, 0x44, 0x8c, 0x6a, 0x02, 0x8e, 0x53, 0x35, 0xd0, 0x8b, 0x30, 0x2a, 0xa2, 0x64, 0x54, 0x7d, - 0xbf, 0x29, 0xc4, 0x40, 0xca, 0x20, 0xaf, 0x16, 0x83, 0xb0, 0x8e, 0xa7, 0x55, 0x63, 0x82, 0xde, - 0xe1, 0xcc, 0x6a, 0x5c, 0xd8, 0xab, 0xe1, 0x25, 0x62, 0x78, 0x8e, 0xf4, 0x15, 0xc3, 0x33, 0x16, - 0x8c, 0x95, 0xfa, 0xd6, 0x1c, 0x42, 0x4f, 0x51, 0xd2, 0xcf, 0x0c, 0xc0, 0x8c, 0x58, 0x38, 0x0f, - 0x7b, 0xb9, 0xdc, 0x4a, 0x2f, 0x97, 0xe3, 0x10, 0x9d, 0xbd, 0xbb, 0x66, 0x4e, 0x7a, 0xcd, 0xfc, - 0xb0, 0x05, 0x26, 0x7b, 0x85, 0xfe, 0xbf, 0xdc, 0x64, 0x42, 0x2f, 0xe6, 0xb2, 0x6b, 0x0d, 0x79, - 0x81, 0xbc, 0xcd, 0xb4, 0x42, 0xf6, 0x7f, 0xb0, 0xe0, 0xf1, 0x9e, 0x14, 0xd1, 0x0a, 0x94, 0x18, - 0x0f, 0xa8, 0xbd, 0xce, 0x9e, 0x54, 0xd6, 0xc9, 0x12, 0x90, 0xc3, 0x92, 0xc6, 0x35, 0xd1, 0x4a, - 0x2a, 0x6b, 0xd3, 0x53, 0x19, 0x59, 0x9b, 0x4e, 0x1b, 0xc3, 0xf3, 0x80, 0x69, 0x9b, 0x7e, 0x90, - 0xde, 0x38, 0x86, 0x67, 0x10, 0xfa, 0xa0, 0x21, 0xf6, 0xb3, 0x13, 0x62, 0x3f, 0x64, 0x62, 0x6b, - 0x77, 0xc8, 0x47, 0x61, 0x8a, 0x85, 0xcf, 0x62, 0xb6, 0xf2, 0xc2, 0x67, 0xa9, 0x10, 0xdb, 0xc3, - 0xde, 0x48, 0xc0, 0x70, 0x0a, 0xdb, 0xfe, 0xc3, 0x22, 0x0c, 0xf1, 0xed, 0x77, 0x02, 0x6f, 0xc2, - 0xa7, 0xa1, 0xe4, 0xb6, 0x5a, 0x1d, 0x9e, 0x88, 0x67, 0x90, 0x7b, 0x37, 0xd3, 0x79, 0xaa, 0xc8, - 0x42, 0x1c, 0xc3, 0xd1, 0xaa, 0x90, 0x38, 0x77, 0x89, 0xd0, 0xc9, 0x3b, 0xbe, 0x50, 0x76, 0x22, - 0x87, 0x33, 0x38, 0xea, 0x9e, 0x8d, 0x65, 0xd3, 0xe8, 0x53, 0x00, 0x61, 0x14, 0xb8, 0xde, 0x36, - 0x2d, 0x13, 0x01, 0x69, 0xdf, 0xdf, 0x85, 0x5a, 0x4d, 0x21, 0x73, 0x9a, 0xf1, 0x99, 0xa3, 0x00, - 0x58, 0xa3, 0x88, 0x16, 0x8c, 0x9b, 0x7e, 0x2e, 0x31, 0x77, 0xc0, 0xa9, 0xc6, 0x73, 0x36, 0xf7, - 0x21, 0x28, 0x29, 0xe2, 0xbd, 0xe4, 0x4f, 0x63, 0x3a, 0x5b, 0xf4, 0x11, 0x98, 0x4c, 0xf4, 0xed, - 0x48, 0xe2, 0xab, 0x5f, 0xb0, 0x60, 0x92, 0x77, 0x66, 0xc5, 0xdb, 0x13, 0xb7, 0xc1, 0x5b, 0x70, - 0xaa, 0x99, 0x71, 0x2a, 0x8b, 0xe9, 0xef, 0xff, 0x14, 0x57, 0xe2, 0xaa, 0x2c, 0x28, 0xce, 0x6c, - 0x03, 0x5d, 0xa2, 0x3b, 0x8e, 0x9e, 0xba, 0x4e, 0x53, 0x38, 0x3b, 0x8f, 0xf1, 0xdd, 0xc6, 0xcb, - 0xb0, 0x82, 0xda, 0xbf, 0x63, 0xc1, 0x34, 0xef, 0xf9, 0x75, 0xb2, 0xaf, 0xce, 0xa6, 0x6f, 0x64, - 0xdf, 0x45, 0x0a, 0xb8, 0x42, 0x4e, 0x0a, 0x38, 0xfd, 0xd3, 0x8a, 0x5d, 0x3f, 0xed, 0x2b, 0x16, - 0x88, 0x15, 0x72, 0x02, 0x42, 0x88, 0x6f, 0x37, 0x85, 0x10, 0x73, 0xf9, 0x9b, 0x20, 0x47, 0xfa, - 0xf0, 0x67, 0x16, 0x4c, 0x71, 0x84, 0x58, 0x5b, 0xfe, 0x0d, 0x9d, 0x87, 0x7e, 0x12, 0x45, 0x5f, - 0x27, 0xfb, 0x1b, 0x7e, 0xd5, 0x89, 0x76, 0xb2, 0x3f, 0xca, 0x98, 0xac, 0x81, 0xae, 0x93, 0xd5, - 0x90, 0x1b, 0xe8, 0x08, 0xd9, 0xe7, 0x8f, 0x9c, 0x21, 0xc5, 0xfe, 0xba, 0x05, 0x88, 0x37, 0x63, - 0x30, 0x6e, 0x94, 0x1d, 0x62, 0xa5, 0xda, 0x45, 0x17, 0x1f, 0x4d, 0x0a, 0x82, 0x35, 0xac, 0x63, - 0x19, 0x9e, 0x84, 0xc9, 0x43, 0xb1, 0xb7, 0xc9, 0xc3, 0x11, 0x46, 0xf4, 0x5f, 0x0f, 0x41, 0xd2, - 0x3b, 0x0a, 0xdd, 0x86, 0xb1, 0xba, 0xd3, 0x76, 0x36, 0xdd, 0xa6, 0x1b, 0xb9, 0x24, 0xec, 0x66, - 0xd1, 0xb4, 0xac, 0xe1, 0x09, 0x25, 0xb5, 0x56, 0x82, 0x0d, 0x3a, 0x68, 0x01, 0xa0, 0x1d, 0xb8, - 0x7b, 0x6e, 0x93, 0x6c, 0x33, 0x59, 0x09, 0x0b, 0xaf, 0xc0, 0xcd, 0xab, 0x64, 0x29, 0xd6, 0x30, - 0x32, 0x5c, 0xd1, 0x8b, 0x0f, 0xd9, 0x15, 0x1d, 0x4e, 0xcc, 0x15, 0x7d, 0xe0, 0x48, 0xae, 0xe8, - 0x23, 0x47, 0x76, 0x45, 0x1f, 0xec, 0xcb, 0x15, 0x1d, 0xc3, 0x19, 0xc9, 0x7b, 0xd2, 0xff, 0xab, - 0x6e, 0x93, 0x88, 0x07, 0x07, 0x8f, 0x09, 0x31, 0x77, 0xff, 0x60, 0xfe, 0x0c, 0xce, 0xc4, 0xc0, - 0x39, 0x35, 0xd1, 0xc7, 0x60, 0xd6, 0x69, 0x36, 0xfd, 0xbb, 0x6a, 0x52, 0x57, 0xc2, 0xba, 0xd3, - 0xe4, 0x4a, 0x88, 0x61, 0x46, 0xf5, 0xb1, 0xfb, 0x07, 0xf3, 0xb3, 0x8b, 0x39, 0x38, 0x38, 0xb7, - 0x36, 0xfa, 0x30, 0x94, 0xda, 0x81, 0x5f, 0x5f, 0xd3, 0x5c, 0x38, 0xcf, 0xd3, 0x01, 0xac, 0xca, - 0xc2, 0xc3, 0x83, 0xf9, 0x71, 0xf5, 0x87, 0x5d, 0xf8, 0x71, 0x85, 0x0c, 0xdf, 0xf2, 0xd1, 0x63, - 0xf5, 0x2d, 0xdf, 0x85, 0x99, 0x1a, 0x09, 0x5c, 0x96, 0xab, 0xbe, 0x11, 0x9f, 0x4f, 0x1b, 0x50, - 0x0a, 0x12, 0x27, 0x72, 0x5f, 0x51, 0x33, 0xb5, 0x54, 0x15, 0xf2, 0x04, 0x8e, 0x09, 0xd9, 0xff, - 0xdb, 0x82, 0x61, 0xe1, 0x0d, 0x75, 0x02, 0x5c, 0xe3, 0xa2, 0xa1, 0x49, 0x98, 0xcf, 0x1e, 0x30, - 0xd6, 0x99, 0x5c, 0x1d, 0x42, 0x25, 0xa1, 0x43, 0x78, 0xbc, 0x1b, 0x91, 0xee, 0xda, 0x83, 0xbf, - 0x56, 0xa4, 0xdc, 0xbb, 0xe1, 0x97, 0xfb, 0xf0, 0x87, 0x60, 0x1d, 0x86, 0x43, 0xe1, 0x17, 0x5a, - 0xc8, 0xf7, 0x4a, 0x48, 0x4e, 0x62, 0x6c, 0xc7, 0x26, 0x3c, 0x41, 0x25, 0x91, 0x4c, 0x87, 0xd3, - 0xe2, 0x43, 0x74, 0x38, 0xed, 0xe5, 0xb9, 0x3c, 0x70, 0x1c, 0x9e, 0xcb, 0xf6, 0x57, 0xd9, 0xcd, - 0xa9, 0x97, 0x9f, 0x00, 0x53, 0x75, 0xd5, 0xbc, 0x63, 0xed, 0x2e, 0x2b, 0x4b, 0x74, 0x2a, 0x87, - 0xb9, 0xfa, 0x39, 0x0b, 0xce, 0x65, 0x7c, 0x95, 0xc6, 0x69, 0x3d, 0x03, 0x23, 0x4e, 0xa7, 0xe1, - 0xaa, 0xbd, 0xac, 0xe9, 0x13, 0x17, 0x45, 0x39, 0x56, 0x18, 0x68, 0x19, 0xa6, 0xc9, 0xbd, 0xb6, - 0xcb, 0x55, 0xa9, 0xba, 0x01, 0x6f, 0x91, 0xbb, 0xd0, 0xad, 0x24, 0x81, 0x38, 0x8d, 0xaf, 0xa2, - 0xc5, 0x14, 0x73, 0xa3, 0xc5, 0xfc, 0x1d, 0x0b, 0x46, 0x95, 0x67, 0xe4, 0x43, 0x1f, 0xed, 0x8f, - 0x9a, 0xa3, 0xfd, 0x68, 0x97, 0xd1, 0xce, 0x19, 0xe6, 0xdf, 0x2a, 0xa8, 0xfe, 0x56, 0xfd, 0x20, - 0xea, 0x83, 0x83, 0x7b, 0x70, 0xe7, 0x83, 0x2b, 0x30, 0xea, 0xb4, 0xdb, 0x12, 0x20, 0x6d, 0xd0, - 0x58, 0x0c, 0xe4, 0xb8, 0x18, 0xeb, 0x38, 0xca, 0x17, 0xa2, 0x98, 0xeb, 0x0b, 0xd1, 0x00, 0x88, - 0x9c, 0x60, 0x9b, 0x44, 0xb4, 0x4c, 0x84, 0x83, 0xcb, 0x3f, 0x6f, 0x3a, 0x91, 0xdb, 0x5c, 0x70, - 0xbd, 0x28, 0x8c, 0x82, 0x85, 0x8a, 0x17, 0xdd, 0x0c, 0xf8, 0x13, 0x52, 0x8b, 0xb7, 0xa4, 0x68, - 0x61, 0x8d, 0xae, 0x8c, 0x02, 0xc0, 0xda, 0x18, 0x34, 0x8d, 0x19, 0xd6, 0x45, 0x39, 0x56, 0x18, - 0xf6, 0x87, 0xd8, 0xed, 0xc3, 0xc6, 0xf4, 0x68, 0xb1, 0x86, 0xfe, 0xde, 0x98, 0x9a, 0x0d, 0xa6, - 0xc9, 0x2c, 0xeb, 0x11, 0x8d, 0xba, 0x1f, 0xf6, 0xb4, 0x61, 0xdd, 0x33, 0x2f, 0x0e, 0x7b, 0x84, - 0xbe, 0x23, 0x65, 0xa0, 0xf2, 0x6c, 0x8f, 0x5b, 0xe3, 0x08, 0x26, 0x29, 0x2c, 0x21, 0x0a, 0x4b, - 0x17, 0x51, 0xa9, 0x8a, 0x7d, 0xa1, 0x25, 0x44, 0x11, 0x00, 0x1c, 0xe3, 0x50, 0x66, 0x4a, 0xfd, - 0x09, 0x67, 0x51, 0x1c, 0x18, 0x54, 0x61, 0x87, 0x58, 0xc3, 0x40, 0x97, 0x85, 0x40, 0x81, 0xeb, - 0x05, 0x1e, 0x4d, 0x08, 0x14, 0xe4, 0x70, 0x69, 0x52, 0xa0, 0x2b, 0x30, 0xaa, 0x72, 0x2f, 0x57, - 0x79, 0x4a, 0x5f, 0xb1, 0xcc, 0x56, 0xe2, 0x62, 0xac, 0xe3, 0xa0, 0x0d, 0x98, 0x0c, 0xb9, 0x9c, - 0x4d, 0x45, 0x6b, 0xe6, 0xf2, 0xca, 0xf7, 0x4b, 0x2b, 0xa0, 0x9a, 0x09, 0x3e, 0x64, 0x45, 0xfc, - 0x74, 0x92, 0x9e, 0xfa, 0x49, 0x12, 0xe8, 0x55, 0x98, 0x68, 0xfa, 0x4e, 0x63, 0xc9, 0x69, 0x3a, - 0x5e, 0x9d, 0x8d, 0xcf, 0x88, 0x99, 0xc2, 0xf3, 0x86, 0x01, 0xc5, 0x09, 0x6c, 0xca, 0xbc, 0xe9, - 0x25, 0x22, 0xc2, 0xb8, 0xe3, 0x6d, 0x93, 0x50, 0x64, 0xd2, 0x65, 0xcc, 0xdb, 0x8d, 0x1c, 0x1c, - 0x9c, 0x5b, 0x1b, 0xbd, 0x04, 0x63, 0xf2, 0xf3, 0xb5, 0xc0, 0x16, 0xb1, 0x5b, 0x89, 0x06, 0xc3, - 0x06, 0x26, 0xba, 0x0b, 0xa7, 0xe5, 0xff, 0x8d, 0xc0, 0xd9, 0xda, 0x72, 0xeb, 0xc2, 0xdb, 0x9b, - 0xfb, 0x9f, 0x2e, 0x4a, 0x27, 0xc9, 0x95, 0x2c, 0xa4, 0xc3, 0x83, 0xf9, 0x0b, 0x62, 0xd4, 0x32, - 0xe1, 0x6c, 0x12, 0xb3, 0xe9, 0xa3, 0x35, 0x98, 0xd9, 0x21, 0x4e, 0x33, 0xda, 0x59, 0xde, 0x21, - 0xf5, 0x5d, 0xb9, 0xe9, 0x58, 0xb8, 0x0c, 0xcd, 0x05, 0xe3, 0x5a, 0x1a, 0x05, 0x67, 0xd5, 0x43, - 0x6f, 0xc0, 0x6c, 0xbb, 0xb3, 0xd9, 0x74, 0xc3, 0x9d, 0x75, 0x3f, 0x62, 0xa6, 0x40, 0x2a, 0x95, - 0xb3, 0x88, 0xab, 0xa1, 0x02, 0x92, 0x54, 0x73, 0xf0, 0x70, 0x2e, 0x05, 0xf4, 0x16, 0x9c, 0x4e, - 0x2c, 0x06, 0x11, 0x59, 0x60, 0x22, 0x3f, 0x5f, 0x43, 0x2d, 0xab, 0x82, 0x08, 0xd2, 0x91, 0x05, - 0xc2, 0xd9, 0x4d, 0xa0, 0x97, 0x01, 0xdc, 0xf6, 0xaa, 0xd3, 0x72, 0x9b, 0xf4, 0xb9, 0x38, 0xc3, - 0xd6, 0x09, 0x7d, 0x3a, 0x40, 0xa5, 0x2a, 0x4b, 0xe9, 0xf9, 0x2c, 0xfe, 0xed, 0x63, 0x0d, 0x1b, - 0x55, 0x61, 0x42, 0xfc, 0xdb, 0x17, 0xd3, 0x3a, 0xad, 0x9c, 0xf8, 0x27, 0x64, 0x0d, 0x35, 0x97, - 0xc8, 0x2c, 0x61, 0xb3, 0x97, 0xa8, 0x8f, 0xb6, 0xe1, 0x9c, 0xc8, 0xfa, 0x4d, 0xf4, 0x75, 0x2a, - 0xe7, 0x21, 0x64, 0x89, 0x12, 0x46, 0xb8, 0x87, 0xc7, 0x62, 0x37, 0x44, 0xdc, 0x9d, 0x0e, 0xbd, - 0xdf, 0xf5, 0xe5, 0xce, 0x7d, 0x60, 0x4f, 0x73, 0xf3, 0x24, 0x7a, 0xbf, 0xdf, 0x48, 0x02, 0x71, - 0x1a, 0x1f, 0x85, 0x70, 0xda, 0xf5, 0xb2, 0x56, 0xf7, 0x19, 0x46, 0xe8, 0x23, 0xdc, 0xfd, 0xb7, - 0xfb, 0xca, 0xce, 0x84, 0xf3, 0x95, 0x9d, 0x49, 0xfb, 0xed, 0x59, 0xe1, 0xfd, 0xb6, 0x45, 0x6b, - 0x6b, 0x9c, 0x3a, 0xfa, 0x34, 0x8c, 0xe9, 0x1f, 0x26, 0xb8, 0x8e, 0x8b, 0xd9, 0x8c, 0xac, 0x76, - 0x3e, 0x70, 0x3e, 0x5f, 0x9d, 0x01, 0x3a, 0x0c, 0x1b, 0x14, 0x51, 0x3d, 0xc3, 0x51, 0xfe, 0x72, - 0x7f, 0x5c, 0x4d, 0xff, 0x46, 0x68, 0x04, 0xb2, 0x97, 0x3d, 0xba, 0x01, 0x23, 0xf5, 0xa6, 0x4b, - 0xbc, 0xa8, 0x52, 0xed, 0x16, 0x0d, 0x6f, 0x59, 0xe0, 0x88, 0x7d, 0x24, 0xf2, 0x1e, 0xf0, 0x32, - 0xac, 0x28, 0xd8, 0xbf, 0x5a, 0x80, 0xf9, 0x1e, 0x49, 0x34, 0x12, 0x2a, 0x29, 0xab, 0x2f, 0x95, - 0xd4, 0xa2, 0xcc, 0x57, 0xbe, 0x9e, 0x90, 0x76, 0x25, 0x72, 0x91, 0xc7, 0x32, 0xaf, 0x24, 0x7e, - 0xdf, 0x2e, 0x02, 0xba, 0x56, 0x6b, 0xa0, 0xa7, 0x93, 0x8b, 0xa1, 0xcd, 0x1e, 0xec, 0xff, 0x09, - 0x9c, 0xab, 0x99, 0xb4, 0xbf, 0x5a, 0x80, 0xd3, 0x6a, 0x08, 0xbf, 0x75, 0x07, 0xee, 0x56, 0x7a, - 0xe0, 0x8e, 0x41, 0xaf, 0x6b, 0xdf, 0x84, 0x21, 0x1e, 0xde, 0xaf, 0x0f, 0xd6, 0xfb, 0x09, 0x33, - 0x7c, 0xae, 0xe2, 0xf6, 0x8c, 0x10, 0xba, 0xdf, 0x6f, 0xc1, 0x64, 0xc2, 0x5b, 0x0c, 0x61, 0xcd, - 0xa5, 0xf8, 0x41, 0xd8, 0xe3, 0x2c, 0xc6, 0xfb, 0x02, 0x0c, 0xec, 0xf8, 0x61, 0x94, 0x34, 0xfa, - 0xb8, 0xe6, 0x87, 0x11, 0x66, 0x10, 0xfb, 0x77, 0x2d, 0x18, 0xdc, 0x70, 0x5c, 0x2f, 0x92, 0x0a, - 0x02, 0x2b, 0x47, 0x41, 0xd0, 0xcf, 0x77, 0xa1, 0x17, 0x61, 0x88, 0x6c, 0x6d, 0x91, 0x7a, 0x24, - 0x66, 0x55, 0xc6, 0x63, 0x18, 0x5a, 0x61, 0xa5, 0x94, 0x17, 0x64, 0x8d, 0xf1, 0xbf, 0x58, 0x20, - 0xa3, 0x3b, 0x50, 0x8a, 0xdc, 0x16, 0x59, 0x6c, 0x34, 0x84, 0xda, 0xfc, 0x01, 0x62, 0x4a, 0x6c, - 0x48, 0x02, 0x38, 0xa6, 0x65, 0x7f, 0xa1, 0x00, 0x10, 0xc7, 0x45, 0xea, 0xf5, 0x89, 0x4b, 0x29, - 0x85, 0xea, 0xc5, 0x0c, 0x85, 0x2a, 0x8a, 0x09, 0x66, 0x68, 0x53, 0xd5, 0x30, 0x15, 0xfb, 0x1a, - 0xa6, 0x81, 0xa3, 0x0c, 0xd3, 0x32, 0x4c, 0xc7, 0x71, 0x9d, 0xcc, 0xb0, 0x76, 0xec, 0xfa, 0xdc, - 0x48, 0x02, 0x71, 0x1a, 0xdf, 0x26, 0x70, 0x41, 0x85, 0xb7, 0x11, 0x37, 0x1a, 0xb3, 0xca, 0xd6, - 0x15, 0xd4, 0x3d, 0xc6, 0x29, 0xd6, 0x18, 0x17, 0x72, 0x35, 0xc6, 0x3f, 0x61, 0xc1, 0xa9, 0x64, - 0x3b, 0xcc, 0x09, 0xf9, 0xf3, 0x16, 0x9c, 0x66, 0x7a, 0x73, 0xd6, 0x6a, 0x5a, 0x4b, 0xff, 0x42, - 0xd7, 0x90, 0x3d, 0x39, 0x3d, 0x8e, 0x03, 0x7f, 0xac, 0x65, 0x91, 0xc6, 0xd9, 0x2d, 0xda, 0xff, - 0xbe, 0x00, 0xb3, 0x79, 0xb1, 0x7e, 0x98, 0xd3, 0x86, 0x73, 0xaf, 0xb6, 0x4b, 0xee, 0x0a, 0xd3, - 0xf8, 0xd8, 0x69, 0x83, 0x17, 0x63, 0x09, 0x4f, 0xe6, 0x45, 0x28, 0xf4, 0x99, 0x17, 0x61, 0x07, - 0xa6, 0xef, 0xee, 0x10, 0xef, 0x96, 0x17, 0x3a, 0x91, 0x1b, 0x6e, 0xb9, 0x4c, 0xc7, 0xcc, 0xd7, - 0xcd, 0xcb, 0xd2, 0x80, 0xfd, 0x4e, 0x12, 0xe1, 0xf0, 0x60, 0xfe, 0x9c, 0x51, 0x10, 0x77, 0x99, - 0x1f, 0x24, 0x38, 0x4d, 0x34, 0x9d, 0x56, 0x62, 0xe0, 0x21, 0xa6, 0x95, 0xb0, 0x3f, 0x6f, 0xc1, - 0xd9, 0xdc, 0x8c, 0xb6, 0xe8, 0x12, 0x8c, 0x38, 0x6d, 0x97, 0x8b, 0xe9, 0xc5, 0x31, 0xca, 0xc4, - 0x41, 0xd5, 0x0a, 0x17, 0xd2, 0x2b, 0xa8, 0xca, 0xe5, 0x5f, 0xc8, 0xcd, 0xe5, 0xdf, 0x33, 0x35, - 0xbf, 0xfd, 0x7d, 0x16, 0x08, 0x87, 0xd3, 0x3e, 0xce, 0xee, 0x4f, 0xc0, 0xd8, 0x5e, 0x3a, 0xf5, - 0xd4, 0x85, 0x7c, 0x0f, 0x5c, 0x91, 0x70, 0x4a, 0x31, 0x64, 0x46, 0x9a, 0x29, 0x83, 0x96, 0xdd, - 0x00, 0x01, 0x2d, 0x13, 0x26, 0x84, 0xee, 0xdd, 0x9b, 0xe7, 0x00, 0x1a, 0x0c, 0x97, 0xe5, 0xa3, - 0x2c, 0x98, 0x37, 0x73, 0x59, 0x41, 0xb0, 0x86, 0x65, 0xff, 0xdb, 0x02, 0x8c, 0xca, 0x54, 0x47, - 0x1d, 0xaf, 0x1f, 0x51, 0xd1, 0x91, 0x72, 0x9f, 0xa2, 0xcb, 0x50, 0x62, 0xb2, 0xcc, 0x6a, 0x2c, - 0x61, 0x53, 0x92, 0x84, 0x35, 0x09, 0xc0, 0x31, 0x0e, 0xdd, 0x45, 0x61, 0x67, 0x93, 0xa1, 0x27, - 0xdc, 0x23, 0x6b, 0xbc, 0x18, 0x4b, 0x38, 0xfa, 0x18, 0x4c, 0xf1, 0x7a, 0x81, 0xdf, 0x76, 0xb6, - 0xb9, 0xfe, 0x63, 0x50, 0x45, 0x8d, 0x98, 0x5a, 0x4b, 0xc0, 0x0e, 0x0f, 0xe6, 0x4f, 0x25, 0xcb, - 0x98, 0x62, 0x2f, 0x45, 0x85, 0x99, 0x39, 0xf1, 0x46, 0xe8, 0xee, 0x4f, 0x59, 0x47, 0xc5, 0x20, - 0xac, 0xe3, 0xd9, 0x9f, 0x06, 0x94, 0x4e, 0xfa, 0x84, 0x5e, 0xe3, 0xb6, 0xad, 0x6e, 0x40, 0x1a, - 0xdd, 0x14, 0x7d, 0x7a, 0x6c, 0x04, 0xe9, 0xd9, 0xc4, 0x6b, 0x61, 0x55, 0xdf, 0xfe, 0x8b, 0x45, - 0x98, 0x4a, 0xfa, 0x72, 0xa3, 0x6b, 0x30, 0xc4, 0x59, 0x0f, 0x41, 0xbe, 0x8b, 0x1d, 0x89, 0xe6, - 0x01, 0xce, 0x0e, 0x61, 0xc1, 0xbd, 0x88, 0xfa, 0xe8, 0x0d, 0x18, 0x6d, 0xf8, 0x77, 0xbd, 0xbb, - 0x4e, 0xd0, 0x58, 0xac, 0x56, 0xc4, 0x72, 0xce, 0x7c, 0xd8, 0x96, 0x63, 0x34, 0xdd, 0xab, 0x9c, - 0xe9, 0x4c, 0x63, 0x10, 0xd6, 0xc9, 0xa1, 0x0d, 0x16, 0x29, 0x7e, 0xcb, 0xdd, 0x5e, 0x73, 0xda, - 0xdd, 0x1c, 0x1d, 0x96, 0x25, 0x92, 0x46, 0x79, 0x5c, 0x84, 0x93, 0xe7, 0x00, 0x1c, 0x13, 0x42, - 0x9f, 0x85, 0x99, 0x30, 0x47, 0xdc, 0x9e, 0x97, 0x03, 0xb0, 0x9b, 0x04, 0x7a, 0xe9, 0x91, 0xfb, - 0x07, 0xf3, 0x33, 0x59, 0x82, 0xf9, 0xac, 0x66, 0xec, 0x2f, 0x9e, 0x02, 0x63, 0x13, 0x1b, 0x29, - 0x61, 0xad, 0x63, 0x4a, 0x09, 0x8b, 0x61, 0x84, 0xb4, 0xda, 0xd1, 0x7e, 0xd9, 0x0d, 0xba, 0x25, - 0x64, 0x5f, 0x11, 0x38, 0x69, 0x9a, 0x12, 0x82, 0x15, 0x9d, 0xec, 0xbc, 0xbd, 0xc5, 0x6f, 0x60, - 0xde, 0xde, 0x81, 0x13, 0xcc, 0xdb, 0xbb, 0x0e, 0xc3, 0xdb, 0x6e, 0x84, 0x49, 0xdb, 0x17, 0x4c, - 0x7f, 0xe6, 0x3a, 0xbc, 0xca, 0x51, 0xd2, 0x19, 0x22, 0x05, 0x00, 0x4b, 0x22, 0xe8, 0x35, 0xb5, - 0x03, 0x87, 0xf2, 0x1f, 0xe6, 0x69, 0x83, 0x87, 0xcc, 0x3d, 0x28, 0xb2, 0xf3, 0x0e, 0x3f, 0x68, - 0x76, 0xde, 0x55, 0x99, 0x53, 0x77, 0x24, 0xdf, 0x2b, 0x89, 0xa5, 0xcc, 0xed, 0x91, 0x49, 0xf7, - 0xb6, 0x9e, 0x87, 0xb8, 0x94, 0x7f, 0x12, 0xa8, 0x14, 0xc3, 0x7d, 0x66, 0x1f, 0xfe, 0x3e, 0x0b, - 0x4e, 0xb7, 0xb3, 0x52, 0x72, 0x0b, 0xdb, 0x80, 0x17, 0xfb, 0xce, 0xfa, 0x6d, 0x34, 0xc8, 0x64, - 0x6a, 0x99, 0x68, 0x38, 0xbb, 0x39, 0x3a, 0xd0, 0xc1, 0x66, 0x43, 0xe8, 0xa8, 0x9f, 0xc8, 0x49, - 0x63, 0xdc, 0x25, 0x79, 0xf1, 0x46, 0x46, 0xca, 0xdc, 0xf7, 0xe6, 0xa5, 0xcc, 0xed, 0x3b, 0x51, - 0xee, 0x6b, 0x2a, 0x81, 0xf1, 0x78, 0xfe, 0x52, 0xe2, 0xe9, 0x89, 0x7b, 0xa6, 0x2d, 0x7e, 0x4d, - 0xa5, 0x2d, 0xee, 0x12, 0xd1, 0x97, 0x27, 0x25, 0xee, 0x99, 0xac, 0x58, 0x4b, 0x38, 0x3c, 0x79, - 0x3c, 0x09, 0x87, 0x8d, 0xab, 0x86, 0xe7, 0xbc, 0x7d, 0xba, 0xc7, 0x55, 0x63, 0xd0, 0xed, 0x7e, - 0xd9, 0xf0, 0xe4, 0xca, 0xd3, 0x0f, 0x94, 0x5c, 0xf9, 0xb6, 0x9e, 0xac, 0x18, 0xf5, 0xc8, 0xc6, - 0x4b, 0x91, 0xfa, 0x4c, 0x51, 0x7c, 0x5b, 0xbf, 0x00, 0x67, 0xf2, 0xe9, 0xaa, 0x7b, 0x2e, 0x4d, - 0x37, 0xf3, 0x0a, 0x4c, 0xa5, 0x3e, 0x3e, 0x75, 0x32, 0xa9, 0x8f, 0x4f, 0x1f, 0x7b, 0xea, 0xe3, - 0x33, 0x27, 0x90, 0xfa, 0xf8, 0x91, 0x13, 0x4c, 0x7d, 0x7c, 0x9b, 0x19, 0xd4, 0xf0, 0xb0, 0x3d, - 0x22, 0x02, 0xf1, 0x53, 0x39, 0x71, 0xab, 0xd2, 0xb1, 0x7d, 0xf8, 0xc7, 0x29, 0x10, 0x8e, 0x49, - 0x65, 0xa4, 0x54, 0x9e, 0x7d, 0x08, 0x29, 0x95, 0xd7, 0xe3, 0x94, 0xca, 0x67, 0xf3, 0xa7, 0x3a, - 0xc3, 0x05, 0x23, 0x27, 0x91, 0xf2, 0x6d, 0x3d, 0x01, 0xf2, 0xa3, 0x5d, 0xb4, 0x26, 0x59, 0x82, - 0xc7, 0x2e, 0x69, 0x8f, 0x5f, 0xe5, 0x69, 0x8f, 0x1f, 0xcb, 0x3f, 0xc9, 0x93, 0xd7, 0x9d, 0x91, - 0xec, 0x98, 0xf6, 0x4b, 0x05, 0xae, 0x64, 0xb1, 0x96, 0x73, 0xfa, 0xa5, 0x22, 0x5f, 0xa6, 0xfb, - 0xa5, 0x40, 0x38, 0x26, 0x65, 0xff, 0x40, 0x01, 0xce, 0x77, 0xdf, 0x6f, 0xb1, 0x34, 0xb5, 0x1a, - 0x2b, 0x91, 0x13, 0xd2, 0x54, 0xfe, 0x66, 0x8b, 0xb1, 0xfa, 0x8e, 0xc3, 0x77, 0x15, 0xa6, 0x95, - 0xef, 0x46, 0xd3, 0xad, 0xef, 0xaf, 0xc7, 0x2f, 0x5f, 0xe5, 0xef, 0x5e, 0x4b, 0x22, 0xe0, 0x74, - 0x1d, 0xb4, 0x08, 0x93, 0x46, 0x61, 0xa5, 0x2c, 0xde, 0x66, 0x4a, 0x7c, 0x5b, 0x33, 0xc1, 0x38, - 0x89, 0x6f, 0x7f, 0xd9, 0x82, 0x47, 0x72, 0x72, 0x06, 0xf6, 0x1d, 0x66, 0x6e, 0x0b, 0x26, 0xdb, - 0x66, 0xd5, 0x1e, 0x91, 0x31, 0x8d, 0xcc, 0x84, 0xaa, 0xaf, 0x09, 0x00, 0x4e, 0x12, 0xb5, 0x7f, - 0xaa, 0x00, 0xe7, 0xba, 0x1a, 0x23, 0x22, 0x0c, 0x67, 0xb6, 0x5b, 0xa1, 0xb3, 0x1c, 0x90, 0x06, - 0xf1, 0x22, 0xd7, 0x69, 0xd6, 0xda, 0xa4, 0xae, 0xc9, 0xc3, 0x99, 0x55, 0xdf, 0xd5, 0xb5, 0xda, - 0x62, 0x1a, 0x03, 0xe7, 0xd4, 0x44, 0xab, 0x80, 0xd2, 0x10, 0x31, 0xc3, 0x2c, 0x6a, 0x77, 0x9a, - 0x1e, 0xce, 0xa8, 0x81, 0x3e, 0x04, 0xe3, 0xca, 0xc8, 0x51, 0x9b, 0x71, 0x76, 0xb0, 0x63, 0x1d, - 0x80, 0x4d, 0x3c, 0x74, 0x85, 0x87, 0x7d, 0x17, 0x09, 0x02, 0x84, 0xf0, 0x7c, 0x52, 0xc6, 0x74, - 0x17, 0xc5, 0x58, 0xc7, 0x59, 0xba, 0xf4, 0x6b, 0xbf, 0x7f, 0xfe, 0x3d, 0xbf, 0xf9, 0xfb, 0xe7, - 0xdf, 0xf3, 0x3b, 0xbf, 0x7f, 0xfe, 0x3d, 0xdf, 0x75, 0xff, 0xbc, 0xf5, 0x6b, 0xf7, 0xcf, 0x5b, - 0xbf, 0x79, 0xff, 0xbc, 0xf5, 0x3b, 0xf7, 0xcf, 0x5b, 0xbf, 0x77, 0xff, 0xbc, 0xf5, 0x85, 0x3f, - 0x38, 0xff, 0x9e, 0x4f, 0x14, 0xf6, 0xae, 0xfc, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x58, 0xf6, - 0xf7, 0x4d, 0xa8, 0x05, 0x01, 0x00, + // 14201 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0xbd, 0x69, 0x70, 0x24, 0xc9, + 0x79, 0x18, 0xca, 0xea, 0xc6, 0xd5, 0x1f, 0xee, 0x9c, 0x63, 0x31, 0xd8, 0x9d, 0xc1, 0x6c, 0x2d, + 0x39, 0x3b, 0xcb, 0xdd, 0xc5, 0x70, 0xf6, 0x20, 0x57, 0xbb, 0xe4, 0x8a, 0x00, 0x1a, 0x98, 0xc1, + 0xce, 0x00, 0xd3, 0x9b, 0x8d, 0x99, 0x21, 0xa9, 0x25, 0x83, 0x85, 0xee, 0x04, 0x50, 0x44, 0x77, + 0x55, 0x6f, 0x55, 0x35, 0x66, 0xb0, 0x8f, 0x8a, 0xa7, 0x47, 0x9d, 0xd4, 0xf1, 0x82, 0xf1, 0x42, + 0xcf, 0x76, 0x90, 0x0a, 0x85, 0x43, 0x96, 0x43, 0xa2, 0xe9, 0x4b, 0xa6, 0x2c, 0xc9, 0xa2, 0x6c, + 0xc9, 0xb7, 0xec, 0x1f, 0x92, 0xac, 0xb0, 0x45, 0x45, 0x28, 0x0c, 0x4b, 0x23, 0x47, 0xc8, 0x8c, + 0xb0, 0x25, 0xd9, 0xb2, 0x7f, 0x78, 0xac, 0xb0, 0x1c, 0x79, 0x56, 0x66, 0x5d, 0xdd, 0x98, 0xc5, + 0x80, 0x4b, 0xc6, 0xfe, 0xeb, 0xce, 0xef, 0xcb, 0x2f, 0xb3, 0xf2, 0xfc, 0xf2, 0x3b, 0xe1, 0x95, + 0xdd, 0x97, 0xc2, 0x79, 0xd7, 0xbf, 0xb4, 0xdb, 0xdd, 0x24, 0x81, 0x47, 0x22, 0x12, 0x5e, 0xda, + 0x23, 0x5e, 0xd3, 0x0f, 0x2e, 0x09, 0x80, 0xd3, 0x71, 0x2f, 0x35, 0xfc, 0x80, 0x5c, 0xda, 0xbb, + 0x7c, 0x69, 0x9b, 0x78, 0x24, 0x70, 0x22, 0xd2, 0x9c, 0xef, 0x04, 0x7e, 0xe4, 0x23, 0xc4, 0x71, + 0xe6, 0x9d, 0x8e, 0x3b, 0x4f, 0x71, 0xe6, 0xf7, 0x2e, 0xcf, 0x3e, 0xbb, 0xed, 0x46, 0x3b, 0xdd, + 0xcd, 0xf9, 0x86, 0xdf, 0xbe, 0xb4, 0xed, 0x6f, 0xfb, 0x97, 0x18, 0xea, 0x66, 0x77, 0x8b, 0xfd, + 0x63, 0x7f, 0xd8, 0x2f, 0x4e, 0x62, 0xf6, 0x85, 0xb8, 0x99, 0xb6, 0xd3, 0xd8, 0x71, 0x3d, 0x12, + 0xec, 0x5f, 0xea, 0xec, 0x6e, 0xb3, 0x76, 0x03, 0x12, 0xfa, 0xdd, 0xa0, 0x41, 0x92, 0x0d, 0x17, + 0xd6, 0x0a, 0x2f, 0xb5, 0x49, 0xe4, 0x64, 0x74, 0x77, 0xf6, 0x52, 0x5e, 0xad, 0xa0, 0xeb, 0x45, + 0x6e, 0x3b, 0xdd, 0xcc, 0x07, 0x7b, 0x55, 0x08, 0x1b, 0x3b, 0xa4, 0xed, 0xa4, 0xea, 0x3d, 0x9f, + 0x57, 0xaf, 0x1b, 0xb9, 0xad, 0x4b, 0xae, 0x17, 0x85, 0x51, 0x90, 0xac, 0x64, 0x7f, 0xdd, 0x82, + 0xf3, 0x0b, 0xb7, 0xeb, 0xcb, 0x2d, 0x27, 0x8c, 0xdc, 0xc6, 0x62, 0xcb, 0x6f, 0xec, 0xd6, 0x23, + 0x3f, 0x20, 0xb7, 0xfc, 0x56, 0xb7, 0x4d, 0xea, 0x6c, 0x20, 0xd0, 0x33, 0x30, 0xb2, 0xc7, 0xfe, + 0xaf, 0x56, 0x67, 0xac, 0xf3, 0xd6, 0xc5, 0xca, 0xe2, 0xd4, 0xaf, 0x1f, 0xcc, 0xbd, 0xe7, 0xde, + 0xc1, 0xdc, 0xc8, 0x2d, 0x51, 0x8e, 0x15, 0x06, 0xba, 0x00, 0x43, 0x5b, 0xe1, 0xc6, 0x7e, 0x87, + 0xcc, 0x94, 0x18, 0xee, 0x84, 0xc0, 0x1d, 0x5a, 0xa9, 0xd3, 0x52, 0x2c, 0xa0, 0xe8, 0x12, 0x54, + 0x3a, 0x4e, 0x10, 0xb9, 0x91, 0xeb, 0x7b, 0x33, 0xe5, 0xf3, 0xd6, 0xc5, 0xc1, 0xc5, 0x69, 0x81, + 0x5a, 0xa9, 0x49, 0x00, 0x8e, 0x71, 0x68, 0x37, 0x02, 0xe2, 0x34, 0x6f, 0x78, 0xad, 0xfd, 0x99, + 0x81, 0xf3, 0xd6, 0xc5, 0x91, 0xb8, 0x1b, 0x58, 0x94, 0x63, 0x85, 0x61, 0x7f, 0xb1, 0x04, 0x23, + 0x0b, 0x5b, 0x5b, 0xae, 0xe7, 0x46, 0xfb, 0xe8, 0x16, 0x8c, 0x79, 0x7e, 0x93, 0xc8, 0xff, 0xec, + 0x2b, 0x46, 0x9f, 0x3b, 0x3f, 0x9f, 0x5e, 0x4a, 0xf3, 0xeb, 0x1a, 0xde, 0xe2, 0xd4, 0xbd, 0x83, + 0xb9, 0x31, 0xbd, 0x04, 0x1b, 0x74, 0x10, 0x86, 0xd1, 0x8e, 0xdf, 0x54, 0x64, 0x4b, 0x8c, 0xec, + 0x5c, 0x16, 0xd9, 0x5a, 0x8c, 0xb6, 0x38, 0x79, 0xef, 0x60, 0x6e, 0x54, 0x2b, 0xc0, 0x3a, 0x11, + 0xb4, 0x09, 0x93, 0xf4, 0xaf, 0x17, 0xb9, 0x8a, 0x6e, 0x99, 0xd1, 0x7d, 0x22, 0x8f, 0xae, 0x86, + 0xba, 0x78, 0xe2, 0xde, 0xc1, 0xdc, 0x64, 0xa2, 0x10, 0x27, 0x09, 0xda, 0x6f, 0xc1, 0xc4, 0x42, + 0x14, 0x39, 0x8d, 0x1d, 0xd2, 0xe4, 0x33, 0x88, 0x5e, 0x80, 0x01, 0xcf, 0x69, 0x13, 0x31, 0xbf, + 0xe7, 0xc5, 0xc0, 0x0e, 0xac, 0x3b, 0x6d, 0x72, 0xff, 0x60, 0x6e, 0xea, 0xa6, 0xe7, 0xbe, 0xd9, + 0x15, 0xab, 0x82, 0x96, 0x61, 0x86, 0x8d, 0x9e, 0x03, 0x68, 0x92, 0x3d, 0xb7, 0x41, 0x6a, 0x4e, + 0xb4, 0x23, 0xe6, 0x1b, 0x89, 0xba, 0x50, 0x55, 0x10, 0xac, 0x61, 0xd9, 0x77, 0xa1, 0xb2, 0xb0, + 0xe7, 0xbb, 0xcd, 0x9a, 0xdf, 0x0c, 0xd1, 0x2e, 0x4c, 0x76, 0x02, 0xb2, 0x45, 0x02, 0x55, 0x34, + 0x63, 0x9d, 0x2f, 0x5f, 0x1c, 0x7d, 0xee, 0x62, 0xe6, 0xc7, 0x9a, 0xa8, 0xcb, 0x5e, 0x14, 0xec, + 0x2f, 0x3e, 0x22, 0xda, 0x9b, 0x4c, 0x40, 0x71, 0x92, 0xb2, 0xfd, 0xcf, 0x4a, 0x70, 0x6a, 0xe1, + 0xad, 0x6e, 0x40, 0xaa, 0x6e, 0xb8, 0x9b, 0x5c, 0xe1, 0x4d, 0x37, 0xdc, 0x5d, 0x8f, 0x47, 0x40, + 0x2d, 0xad, 0xaa, 0x28, 0xc7, 0x0a, 0x03, 0x3d, 0x0b, 0xc3, 0xf4, 0xf7, 0x4d, 0xbc, 0x2a, 0x3e, + 0xf9, 0x84, 0x40, 0x1e, 0xad, 0x3a, 0x91, 0x53, 0xe5, 0x20, 0x2c, 0x71, 0xd0, 0x1a, 0x8c, 0x36, + 0xd8, 0x86, 0xdc, 0x5e, 0xf3, 0x9b, 0x84, 0x4d, 0x66, 0x65, 0xf1, 0x69, 0x8a, 0xbe, 0x14, 0x17, + 0xdf, 0x3f, 0x98, 0x9b, 0xe1, 0x7d, 0x13, 0x24, 0x34, 0x18, 0xd6, 0xeb, 0x23, 0x5b, 0xed, 0xaf, + 0x01, 0x46, 0x09, 0x32, 0xf6, 0xd6, 0x45, 0x6d, 0xab, 0x0c, 0xb2, 0xad, 0x32, 0x96, 0xbd, 0x4d, + 0xd0, 0x65, 0x18, 0xd8, 0x75, 0xbd, 0xe6, 0xcc, 0x10, 0xa3, 0x75, 0x96, 0xce, 0xf9, 0x35, 0xd7, + 0x6b, 0xde, 0x3f, 0x98, 0x9b, 0x36, 0xba, 0x43, 0x0b, 0x31, 0x43, 0xb5, 0xff, 0xcc, 0x82, 0x39, + 0x06, 0x5b, 0x71, 0x5b, 0xa4, 0x46, 0x82, 0xd0, 0x0d, 0x23, 0xe2, 0x45, 0xc6, 0x80, 0x3e, 0x07, + 0x10, 0x92, 0x46, 0x40, 0x22, 0x6d, 0x48, 0xd5, 0xc2, 0xa8, 0x2b, 0x08, 0xd6, 0xb0, 0xe8, 0x81, + 0x10, 0xee, 0x38, 0x01, 0x5b, 0x5f, 0x62, 0x60, 0xd5, 0x81, 0x50, 0x97, 0x00, 0x1c, 0xe3, 0x18, + 0x07, 0x42, 0xb9, 0xd7, 0x81, 0x80, 0x3e, 0x02, 0x93, 0x71, 0x63, 0x61, 0xc7, 0x69, 0xc8, 0x01, + 0x64, 0x5b, 0xa6, 0x6e, 0x82, 0x70, 0x12, 0xd7, 0xfe, 0x1b, 0x96, 0x58, 0x3c, 0xf4, 0xab, 0xdf, + 0xe1, 0xdf, 0x6a, 0xff, 0x92, 0x05, 0xc3, 0x8b, 0xae, 0xd7, 0x74, 0xbd, 0x6d, 0xf4, 0x69, 0x18, + 0xa1, 0x77, 0x53, 0xd3, 0x89, 0x1c, 0x71, 0xee, 0x7d, 0x40, 0xdb, 0x5b, 0xea, 0xaa, 0x98, 0xef, + 0xec, 0x6e, 0xd3, 0x82, 0x70, 0x9e, 0x62, 0xd3, 0xdd, 0x76, 0x63, 0xf3, 0x33, 0xa4, 0x11, 0xad, + 0x91, 0xc8, 0x89, 0x3f, 0x27, 0x2e, 0xc3, 0x8a, 0x2a, 0xba, 0x06, 0x43, 0x91, 0x13, 0x6c, 0x93, + 0x48, 0x1c, 0x80, 0x99, 0x07, 0x15, 0xaf, 0x89, 0xe9, 0x8e, 0x24, 0x5e, 0x83, 0xc4, 0xd7, 0xc2, + 0x06, 0xab, 0x8a, 0x05, 0x09, 0xfb, 0xc7, 0x86, 0xe1, 0xcc, 0x52, 0x7d, 0x35, 0x67, 0x5d, 0x5d, + 0x80, 0xa1, 0x66, 0xe0, 0xee, 0x91, 0x40, 0x8c, 0xb3, 0xa2, 0x52, 0x65, 0xa5, 0x58, 0x40, 0xd1, + 0x4b, 0x30, 0xc6, 0x2f, 0xa4, 0xab, 0x8e, 0xd7, 0x6c, 0xc9, 0x21, 0x3e, 0x29, 0xb0, 0xc7, 0x6e, + 0x69, 0x30, 0x6c, 0x60, 0x1e, 0x72, 0x51, 0x5d, 0x48, 0x6c, 0xc6, 0xbc, 0xcb, 0xee, 0xf3, 0x16, + 0x4c, 0xf1, 0x66, 0x16, 0xa2, 0x28, 0x70, 0x37, 0xbb, 0x11, 0x09, 0x67, 0x06, 0xd9, 0x49, 0xb7, + 0x94, 0x35, 0x5a, 0xb9, 0x23, 0x30, 0x7f, 0x2b, 0x41, 0x85, 0x1f, 0x82, 0x33, 0xa2, 0xdd, 0xa9, + 0x24, 0x18, 0xa7, 0x9a, 0x45, 0xdf, 0x6b, 0xc1, 0x6c, 0xc3, 0xf7, 0xa2, 0xc0, 0x6f, 0xb5, 0x48, + 0x50, 0xeb, 0x6e, 0xb6, 0xdc, 0x70, 0x87, 0xaf, 0x53, 0x4c, 0xb6, 0xd8, 0x49, 0x90, 0x33, 0x87, + 0x0a, 0x49, 0xcc, 0xe1, 0xb9, 0x7b, 0x07, 0x73, 0xb3, 0x4b, 0xb9, 0xa4, 0x70, 0x41, 0x33, 0x68, + 0x17, 0x10, 0xbd, 0x4a, 0xeb, 0x91, 0xb3, 0x4d, 0xe2, 0xc6, 0x87, 0xfb, 0x6f, 0xfc, 0xf4, 0xbd, + 0x83, 0x39, 0xb4, 0x9e, 0x22, 0x81, 0x33, 0xc8, 0xa2, 0x37, 0xe1, 0x24, 0x2d, 0x4d, 0x7d, 0xeb, + 0x48, 0xff, 0xcd, 0xcd, 0xdc, 0x3b, 0x98, 0x3b, 0xb9, 0x9e, 0x41, 0x04, 0x67, 0x92, 0x46, 0xdf, + 0x63, 0xc1, 0x99, 0xf8, 0xf3, 0x97, 0xef, 0x76, 0x1c, 0xaf, 0x19, 0x37, 0x5c, 0xe9, 0xbf, 0x61, + 0x7a, 0x26, 0x9f, 0x59, 0xca, 0xa3, 0x84, 0xf3, 0x1b, 0x99, 0x5d, 0x82, 0x53, 0x99, 0xab, 0x05, + 0x4d, 0x41, 0x79, 0x97, 0x70, 0x2e, 0xa8, 0x82, 0xe9, 0x4f, 0x74, 0x12, 0x06, 0xf7, 0x9c, 0x56, + 0x57, 0x6c, 0x14, 0xcc, 0xff, 0xbc, 0x5c, 0x7a, 0xc9, 0xb2, 0xff, 0x79, 0x19, 0x26, 0x97, 0xea, + 0xab, 0x0f, 0xb4, 0x0b, 0xf5, 0x6b, 0xa8, 0x54, 0x78, 0x0d, 0xc5, 0x97, 0x5a, 0x39, 0xf7, 0x52, + 0xfb, 0xbf, 0x33, 0xb6, 0xd0, 0x00, 0xdb, 0x42, 0xdf, 0x91, 0xb3, 0x85, 0x8e, 0x78, 0xe3, 0xec, + 0xe5, 0xac, 0xa2, 0x41, 0x36, 0x99, 0x99, 0x1c, 0xcb, 0x75, 0xbf, 0xe1, 0xb4, 0x92, 0x47, 0xdf, + 0x21, 0x97, 0xd2, 0xd1, 0xcc, 0x63, 0x03, 0xc6, 0x96, 0x9c, 0x8e, 0xb3, 0xe9, 0xb6, 0xdc, 0xc8, + 0x25, 0x21, 0x7a, 0x12, 0xca, 0x4e, 0xb3, 0xc9, 0xb8, 0xad, 0xca, 0xe2, 0xa9, 0x7b, 0x07, 0x73, + 0xe5, 0x85, 0x26, 0xbd, 0xf6, 0x41, 0x61, 0xed, 0x63, 0x8a, 0x81, 0xde, 0x0f, 0x03, 0xcd, 0xc0, + 0xef, 0xcc, 0x94, 0x18, 0x26, 0xdd, 0x75, 0x03, 0xd5, 0xc0, 0xef, 0x24, 0x50, 0x19, 0x8e, 0xfd, + 0x6b, 0x25, 0x78, 0x6c, 0x89, 0x74, 0x76, 0x56, 0xea, 0x39, 0xe7, 0xf7, 0x45, 0x18, 0x69, 0xfb, + 0x9e, 0x1b, 0xf9, 0x41, 0x28, 0x9a, 0x66, 0x2b, 0x62, 0x4d, 0x94, 0x61, 0x05, 0x45, 0xe7, 0x61, + 0xa0, 0x13, 0x33, 0x95, 0x63, 0x92, 0x21, 0x65, 0xec, 0x24, 0x83, 0x50, 0x8c, 0x6e, 0x48, 0x02, + 0xb1, 0x62, 0x14, 0xc6, 0xcd, 0x90, 0x04, 0x98, 0x41, 0xe2, 0x9b, 0x99, 0xde, 0xd9, 0xe2, 0x84, + 0x4e, 0xdc, 0xcc, 0x14, 0x82, 0x35, 0x2c, 0x54, 0x83, 0x4a, 0x98, 0x98, 0xd9, 0xbe, 0xb6, 0xe9, + 0x38, 0xbb, 0xba, 0xd5, 0x4c, 0xc6, 0x44, 0x8c, 0x1b, 0x65, 0xa8, 0xe7, 0xd5, 0xfd, 0xb5, 0x12, + 0x20, 0x3e, 0x84, 0xdf, 0x62, 0x03, 0x77, 0x33, 0x3d, 0x70, 0xfd, 0x6f, 0x89, 0xa3, 0x1a, 0xbd, + 0xff, 0x6e, 0xc1, 0x63, 0x4b, 0xae, 0xd7, 0x24, 0x41, 0xce, 0x02, 0x7c, 0x38, 0x6f, 0xd9, 0xc3, + 0x31, 0x0d, 0xc6, 0x12, 0x1b, 0x38, 0x82, 0x25, 0x66, 0xff, 0x89, 0x05, 0x88, 0x7f, 0xf6, 0x3b, + 0xee, 0x63, 0x6f, 0xa6, 0x3f, 0xf6, 0x08, 0x96, 0x85, 0x7d, 0x1d, 0x26, 0x96, 0x5a, 0x2e, 0xf1, + 0xa2, 0xd5, 0xda, 0x92, 0xef, 0x6d, 0xb9, 0xdb, 0xe8, 0x65, 0x98, 0x88, 0xdc, 0x36, 0xf1, 0xbb, + 0x51, 0x9d, 0x34, 0x7c, 0x8f, 0xbd, 0x24, 0xad, 0x8b, 0x83, 0x8b, 0xe8, 0xde, 0xc1, 0xdc, 0xc4, + 0x86, 0x01, 0xc1, 0x09, 0x4c, 0xfb, 0xf7, 0xe8, 0xf8, 0xf9, 0xed, 0x8e, 0xef, 0x11, 0x2f, 0x5a, + 0xf2, 0xbd, 0x26, 0x97, 0x38, 0xbc, 0x0c, 0x03, 0x11, 0x1d, 0x0f, 0x3e, 0x76, 0x17, 0xe4, 0x46, + 0xa1, 0xa3, 0x70, 0xff, 0x60, 0xee, 0x74, 0xba, 0x06, 0x1b, 0x27, 0x56, 0x07, 0x7d, 0x07, 0x0c, + 0x85, 0x91, 0x13, 0x75, 0x43, 0x31, 0x9a, 0x8f, 0xcb, 0xd1, 0xac, 0xb3, 0xd2, 0xfb, 0x07, 0x73, + 0x93, 0xaa, 0x1a, 0x2f, 0xc2, 0xa2, 0x02, 0x7a, 0x0a, 0x86, 0xdb, 0x24, 0x0c, 0x9d, 0x6d, 0x79, + 0x1b, 0x4e, 0x8a, 0xba, 0xc3, 0x6b, 0xbc, 0x18, 0x4b, 0x38, 0x7a, 0x02, 0x06, 0x49, 0x10, 0xf8, + 0x81, 0xd8, 0xa3, 0xe3, 0x02, 0x71, 0x70, 0x99, 0x16, 0x62, 0x0e, 0xb3, 0x7f, 0xd3, 0x82, 0x49, + 0xd5, 0x57, 0xde, 0xd6, 0x31, 0xbc, 0x0a, 0x3e, 0x01, 0xd0, 0x90, 0x1f, 0x18, 0xb2, 0xdb, 0x63, + 0xf4, 0xb9, 0x0b, 0x99, 0x17, 0x75, 0x6a, 0x18, 0x63, 0xca, 0xaa, 0x28, 0xc4, 0x1a, 0x35, 0xfb, + 0x1f, 0x5a, 0x70, 0x22, 0xf1, 0x45, 0xd7, 0xdd, 0x30, 0x42, 0x6f, 0xa4, 0xbe, 0x6a, 0xbe, 0xbf, + 0xaf, 0xa2, 0xb5, 0xd9, 0x37, 0xa9, 0xa5, 0x2c, 0x4b, 0xb4, 0x2f, 0xba, 0x0a, 0x83, 0x6e, 0x44, + 0xda, 0xf2, 0x63, 0x9e, 0x28, 0xfc, 0x18, 0xde, 0xab, 0x78, 0x46, 0x56, 0x69, 0x4d, 0xcc, 0x09, + 0xd8, 0xbf, 0x56, 0x86, 0x0a, 0x5f, 0xb6, 0x6b, 0x4e, 0xe7, 0x18, 0xe6, 0xe2, 0x69, 0xa8, 0xb8, + 0xed, 0x76, 0x37, 0x72, 0x36, 0xc5, 0x71, 0x3e, 0xc2, 0xb7, 0xd6, 0xaa, 0x2c, 0xc4, 0x31, 0x1c, + 0xad, 0xc2, 0x00, 0xeb, 0x0a, 0xff, 0xca, 0x27, 0xb3, 0xbf, 0x52, 0xf4, 0x7d, 0xbe, 0xea, 0x44, + 0x0e, 0xe7, 0xa4, 0xd4, 0x3d, 0x42, 0x8b, 0x30, 0x23, 0x81, 0x1c, 0x80, 0x4d, 0xd7, 0x73, 0x82, + 0x7d, 0x5a, 0x36, 0x53, 0x66, 0x04, 0x9f, 0x2d, 0x26, 0xb8, 0xa8, 0xf0, 0x39, 0x59, 0xf5, 0x61, + 0x31, 0x00, 0x6b, 0x44, 0x67, 0x3f, 0x04, 0x15, 0x85, 0x7c, 0x18, 0x86, 0x68, 0xf6, 0x23, 0x30, + 0x99, 0x68, 0xab, 0x57, 0xf5, 0x31, 0x9d, 0x9f, 0xfa, 0x65, 0x76, 0x64, 0x88, 0x5e, 0x2f, 0x7b, + 0x7b, 0xe2, 0xc8, 0x7d, 0x0b, 0x4e, 0xb6, 0x32, 0x4e, 0x32, 0x31, 0xaf, 0xfd, 0x9f, 0x7c, 0x8f, + 0x89, 0xcf, 0x3e, 0x99, 0x05, 0xc5, 0x99, 0x6d, 0x50, 0x1e, 0xc1, 0xef, 0xd0, 0x0d, 0xe2, 0xb4, + 0x74, 0x76, 0xfb, 0x86, 0x28, 0xc3, 0x0a, 0x4a, 0xcf, 0xbb, 0x93, 0xaa, 0xf3, 0xd7, 0xc8, 0x7e, + 0x9d, 0xb4, 0x48, 0x23, 0xf2, 0x83, 0x6f, 0x6a, 0xf7, 0xcf, 0xf2, 0xd1, 0xe7, 0xc7, 0xe5, 0xa8, + 0x20, 0x50, 0xbe, 0x46, 0xf6, 0xf9, 0x54, 0xe8, 0x5f, 0x57, 0x2e, 0xfc, 0xba, 0x9f, 0xb3, 0x60, + 0x5c, 0x7d, 0xdd, 0x31, 0x9c, 0x0b, 0x8b, 0xe6, 0xb9, 0x70, 0xb6, 0x70, 0x81, 0xe7, 0x9c, 0x08, + 0x5f, 0x2b, 0xc1, 0x19, 0x85, 0x43, 0xdf, 0x06, 0xfc, 0x8f, 0x58, 0x55, 0x97, 0xa0, 0xe2, 0x29, + 0xa9, 0x95, 0x65, 0x8a, 0x8b, 0x62, 0x99, 0x55, 0x8c, 0x43, 0x59, 0x3c, 0x2f, 0x16, 0x2d, 0x8d, + 0xe9, 0xe2, 0x5c, 0x21, 0xba, 0x5d, 0x84, 0x72, 0xd7, 0x6d, 0x8a, 0x0b, 0xe6, 0x03, 0x72, 0xb4, + 0x6f, 0xae, 0x56, 0xef, 0x1f, 0xcc, 0x3d, 0x9e, 0xa7, 0x4a, 0xa0, 0x37, 0x5b, 0x38, 0x7f, 0x73, + 0xb5, 0x8a, 0x69, 0x65, 0xb4, 0x00, 0x93, 0x52, 0x5b, 0x72, 0x8b, 0xb2, 0x5b, 0xbe, 0x27, 0xee, + 0x21, 0x25, 0x93, 0xc5, 0x26, 0x18, 0x27, 0xf1, 0x51, 0x15, 0xa6, 0x76, 0xbb, 0x9b, 0xa4, 0x45, + 0x22, 0xfe, 0xc1, 0xd7, 0x08, 0x97, 0x58, 0x56, 0xe2, 0x97, 0xd9, 0xb5, 0x04, 0x1c, 0xa7, 0x6a, + 0xd8, 0x7f, 0xc1, 0xee, 0x03, 0x31, 0x7a, 0xb5, 0xc0, 0xa7, 0x0b, 0x8b, 0x52, 0xff, 0x66, 0x2e, + 0xe7, 0x7e, 0x56, 0xc5, 0x35, 0xb2, 0xbf, 0xe1, 0x53, 0xce, 0x3c, 0x7b, 0x55, 0x18, 0x6b, 0x7e, + 0xa0, 0x70, 0xcd, 0xff, 0x7c, 0x09, 0x4e, 0xa9, 0x11, 0x30, 0x98, 0xc0, 0x6f, 0xf5, 0x31, 0xb8, + 0x0c, 0xa3, 0x4d, 0xb2, 0xe5, 0x74, 0x5b, 0x91, 0x12, 0x9f, 0x0f, 0x72, 0x15, 0x4a, 0x35, 0x2e, + 0xc6, 0x3a, 0xce, 0x21, 0x86, 0xed, 0x7f, 0x8c, 0xb2, 0x8b, 0x38, 0x72, 0xe8, 0x1a, 0x57, 0xbb, + 0xc6, 0xca, 0xdd, 0x35, 0x4f, 0xc0, 0xa0, 0xdb, 0xa6, 0x8c, 0x59, 0xc9, 0xe4, 0xb7, 0x56, 0x69, + 0x21, 0xe6, 0x30, 0xf4, 0x3e, 0x18, 0x6e, 0xf8, 0xed, 0xb6, 0xe3, 0x35, 0xd9, 0x95, 0x57, 0x59, + 0x1c, 0xa5, 0xbc, 0xdb, 0x12, 0x2f, 0xc2, 0x12, 0x86, 0x1e, 0x83, 0x01, 0x27, 0xd8, 0xe6, 0x32, + 0x8c, 0xca, 0xe2, 0x08, 0x6d, 0x69, 0x21, 0xd8, 0x0e, 0x31, 0x2b, 0xa5, 0x4f, 0xb0, 0x3b, 0x7e, + 0xb0, 0xeb, 0x7a, 0xdb, 0x55, 0x37, 0x10, 0x5b, 0x42, 0xdd, 0x85, 0xb7, 0x15, 0x04, 0x6b, 0x58, + 0x68, 0x05, 0x06, 0x3b, 0x7e, 0x10, 0x85, 0x33, 0x43, 0x6c, 0xb8, 0x1f, 0xcf, 0x39, 0x88, 0xf8, + 0xd7, 0xd6, 0xfc, 0x20, 0x8a, 0x3f, 0x80, 0xfe, 0x0b, 0x31, 0xaf, 0x8e, 0xae, 0xc3, 0x30, 0xf1, + 0xf6, 0x56, 0x02, 0xbf, 0x3d, 0x73, 0x22, 0x9f, 0xd2, 0x32, 0x47, 0xe1, 0xcb, 0x2c, 0xe6, 0x51, + 0x45, 0x31, 0x96, 0x24, 0xd0, 0x77, 0x40, 0x99, 0x78, 0x7b, 0x33, 0xc3, 0x8c, 0xd2, 0x6c, 0x0e, + 0xa5, 0x5b, 0x4e, 0x10, 0x9f, 0xf9, 0xcb, 0xde, 0x1e, 0xa6, 0x75, 0xd0, 0xc7, 0xa1, 0x22, 0x0f, + 0x8c, 0x50, 0x08, 0xeb, 0x32, 0x17, 0xac, 0x3c, 0x66, 0x30, 0x79, 0xb3, 0xeb, 0x06, 0xa4, 0x4d, + 0xbc, 0x28, 0x8c, 0x4f, 0x48, 0x09, 0x0d, 0x71, 0x4c, 0x0d, 0x7d, 0x5c, 0x4a, 0x88, 0xd7, 0xfc, + 0xae, 0x17, 0x85, 0x33, 0x15, 0xd6, 0xbd, 0x4c, 0xdd, 0xdd, 0xad, 0x18, 0x2f, 0x29, 0x42, 0xe6, + 0x95, 0xb1, 0x41, 0x0a, 0x7d, 0x12, 0xc6, 0xf9, 0x7f, 0xae, 0x01, 0x0b, 0x67, 0x4e, 0x31, 0xda, + 0xe7, 0xf3, 0x69, 0x73, 0xc4, 0xc5, 0x53, 0x82, 0xf8, 0xb8, 0x5e, 0x1a, 0x62, 0x93, 0x1a, 0xc2, + 0x30, 0xde, 0x72, 0xf7, 0x88, 0x47, 0xc2, 0xb0, 0x16, 0xf8, 0x9b, 0x64, 0x06, 0xd8, 0xc0, 0x9c, + 0xc9, 0xd6, 0x98, 0xf9, 0x9b, 0x64, 0x71, 0x9a, 0xd2, 0xbc, 0xae, 0xd7, 0xc1, 0x26, 0x09, 0x74, + 0x13, 0x26, 0xe8, 0x8b, 0xcd, 0x8d, 0x89, 0x8e, 0xf6, 0x22, 0xca, 0xde, 0x55, 0xd8, 0xa8, 0x84, + 0x13, 0x44, 0xd0, 0x0d, 0x18, 0x0b, 0x23, 0x27, 0x88, 0xba, 0x1d, 0x4e, 0xf4, 0x74, 0x2f, 0xa2, + 0x4c, 0xe1, 0x5a, 0xd7, 0xaa, 0x60, 0x83, 0x00, 0x7a, 0x0d, 0x2a, 0x2d, 0x77, 0x8b, 0x34, 0xf6, + 0x1b, 0x2d, 0x32, 0x33, 0xc6, 0xa8, 0x65, 0x1e, 0x2a, 0xd7, 0x25, 0x12, 0xe7, 0x73, 0xd5, 0x5f, + 0x1c, 0x57, 0x47, 0xb7, 0xe0, 0x74, 0x44, 0x82, 0xb6, 0xeb, 0x39, 0xf4, 0x30, 0x10, 0x4f, 0x2b, + 0xa6, 0xc8, 0x1c, 0x67, 0xbb, 0xed, 0x9c, 0x98, 0x8d, 0xd3, 0x1b, 0x99, 0x58, 0x38, 0xa7, 0x36, + 0xba, 0x0b, 0x33, 0x19, 0x10, 0xbf, 0xe5, 0x36, 0xf6, 0x67, 0x4e, 0x32, 0xca, 0x1f, 0x16, 0x94, + 0x67, 0x36, 0x72, 0xf0, 0xee, 0x17, 0xc0, 0x70, 0x2e, 0x75, 0x74, 0x03, 0x26, 0xd9, 0x09, 0x54, + 0xeb, 0xb6, 0x5a, 0xa2, 0xc1, 0x09, 0xd6, 0xe0, 0xfb, 0xe4, 0x7d, 0xbc, 0x6a, 0x82, 0xef, 0x1f, + 0xcc, 0x41, 0xfc, 0x0f, 0x27, 0x6b, 0xa3, 0x4d, 0xa6, 0x33, 0xeb, 0x06, 0x6e, 0xb4, 0x4f, 0xcf, + 0x0d, 0x72, 0x37, 0x9a, 0x99, 0x2c, 0x94, 0x57, 0xe8, 0xa8, 0x4a, 0xb1, 0xa6, 0x17, 0xe2, 0x24, + 0x41, 0x7a, 0xa4, 0x86, 0x51, 0xd3, 0xf5, 0x66, 0xa6, 0xf8, 0xbb, 0x44, 0x9e, 0x48, 0x75, 0x5a, + 0x88, 0x39, 0x8c, 0xe9, 0xcb, 0xe8, 0x8f, 0x1b, 0xf4, 0xe6, 0x9a, 0x66, 0x88, 0xb1, 0xbe, 0x4c, + 0x02, 0x70, 0x8c, 0x43, 0x99, 0xc9, 0x28, 0xda, 0x9f, 0x41, 0x0c, 0x55, 0x1d, 0x2c, 0x1b, 0x1b, + 0x1f, 0xc7, 0xb4, 0xdc, 0xde, 0x84, 0x09, 0x75, 0x10, 0xb2, 0x31, 0x41, 0x73, 0x30, 0xc8, 0xd8, + 0x27, 0x21, 0x5d, 0xab, 0xd0, 0x2e, 0x30, 0xd6, 0x0a, 0xf3, 0x72, 0xd6, 0x05, 0xf7, 0x2d, 0xb2, + 0xb8, 0x1f, 0x11, 0xfe, 0xa6, 0x2f, 0x6b, 0x5d, 0x90, 0x00, 0x1c, 0xe3, 0xd8, 0xff, 0x9b, 0xb3, + 0xa1, 0xf1, 0x69, 0xdb, 0xc7, 0xfd, 0xf2, 0x0c, 0x8c, 0xec, 0xf8, 0x61, 0x44, 0xb1, 0x59, 0x1b, + 0x83, 0x31, 0xe3, 0x79, 0x55, 0x94, 0x63, 0x85, 0x81, 0x5e, 0x81, 0xf1, 0x86, 0xde, 0x80, 0xb8, + 0x1c, 0xd5, 0x31, 0x62, 0xb4, 0x8e, 0x4d, 0x5c, 0xf4, 0x12, 0x8c, 0x30, 0x1b, 0x90, 0x86, 0xdf, + 0x12, 0x5c, 0x9b, 0xbc, 0xe1, 0x47, 0x6a, 0xa2, 0xfc, 0xbe, 0xf6, 0x1b, 0x2b, 0x6c, 0x74, 0x01, + 0x86, 0x68, 0x17, 0x56, 0x6b, 0xe2, 0x5a, 0x52, 0x82, 0xa2, 0xab, 0xac, 0x14, 0x0b, 0xa8, 0xfd, + 0xff, 0x95, 0xb4, 0x51, 0xa6, 0xef, 0x61, 0x82, 0x6a, 0x30, 0x7c, 0xc7, 0x71, 0x23, 0xd7, 0xdb, + 0x16, 0xfc, 0xc7, 0x53, 0x85, 0x77, 0x14, 0xab, 0x74, 0x9b, 0x57, 0xe0, 0xb7, 0xa8, 0xf8, 0x83, + 0x25, 0x19, 0x4a, 0x31, 0xe8, 0x7a, 0x1e, 0xa5, 0x58, 0xea, 0x97, 0x22, 0xe6, 0x15, 0x38, 0x45, + 0xf1, 0x07, 0x4b, 0x32, 0xe8, 0x0d, 0x00, 0xb9, 0xc3, 0x48, 0x53, 0xd8, 0x5e, 0x3c, 0xd3, 0x9b, + 0xe8, 0x86, 0xaa, 0xb3, 0x38, 0x41, 0xef, 0xe8, 0xf8, 0x3f, 0xd6, 0xe8, 0xd9, 0x11, 0xe3, 0xd3, + 0xd2, 0x9d, 0x41, 0xdf, 0x45, 0x97, 0xb8, 0x13, 0x44, 0xa4, 0xb9, 0x10, 0x89, 0xc1, 0x79, 0x7f, + 0x7f, 0x8f, 0x94, 0x0d, 0xb7, 0x4d, 0xf4, 0xed, 0x20, 0x88, 0xe0, 0x98, 0x9e, 0xfd, 0x8b, 0x65, + 0x98, 0xc9, 0xeb, 0x2e, 0x5d, 0x74, 0xe4, 0xae, 0x1b, 0x2d, 0x51, 0xf6, 0xca, 0x32, 0x17, 0xdd, + 0xb2, 0x28, 0xc7, 0x0a, 0x83, 0xce, 0x7e, 0xe8, 0x6e, 0xcb, 0x37, 0xe6, 0x60, 0x3c, 0xfb, 0x75, + 0x56, 0x8a, 0x05, 0x94, 0xe2, 0x05, 0xc4, 0x09, 0x85, 0x71, 0x8f, 0xb6, 0x4a, 0x30, 0x2b, 0xc5, + 0x02, 0xaa, 0x4b, 0xbb, 0x06, 0x7a, 0x48, 0xbb, 0x8c, 0x21, 0x1a, 0x3c, 0xda, 0x21, 0x42, 0x9f, + 0x02, 0xd8, 0x72, 0x3d, 0x37, 0xdc, 0x61, 0xd4, 0x87, 0x0e, 0x4d, 0x5d, 0x31, 0x67, 0x2b, 0x8a, + 0x0a, 0xd6, 0x28, 0xa2, 0x17, 0x61, 0x54, 0x6d, 0xc0, 0xd5, 0x2a, 0xd3, 0x74, 0x6a, 0x96, 0x23, + 0xf1, 0x69, 0x54, 0xc5, 0x3a, 0x9e, 0xfd, 0x99, 0xe4, 0x7a, 0x11, 0x3b, 0x40, 0x1b, 0x5f, 0xab, + 0xdf, 0xf1, 0x2d, 0x15, 0x8f, 0xaf, 0xfd, 0x8d, 0x32, 0x4c, 0x1a, 0x8d, 0x75, 0xc3, 0x3e, 0xce, + 0xac, 0x2b, 0xf4, 0x00, 0x77, 0x22, 0x22, 0xf6, 0x9f, 0xdd, 0x7b, 0xab, 0xe8, 0x87, 0x3c, 0xdd, + 0x01, 0xbc, 0x3e, 0xfa, 0x14, 0x54, 0x5a, 0x4e, 0xc8, 0x24, 0x67, 0x44, 0xec, 0xbb, 0x7e, 0x88, + 0xc5, 0x0f, 0x13, 0x27, 0x8c, 0xb4, 0x5b, 0x93, 0xd3, 0x8e, 0x49, 0xd2, 0x9b, 0x86, 0xf2, 0x27, + 0xd2, 0x7a, 0x4c, 0x75, 0x82, 0x32, 0x31, 0xfb, 0x98, 0xc3, 0xd0, 0x4b, 0x30, 0x16, 0x10, 0xb6, + 0x2a, 0x96, 0x28, 0x37, 0xc7, 0x96, 0xd9, 0x60, 0xcc, 0xf6, 0x61, 0x0d, 0x86, 0x0d, 0xcc, 0xf8, + 0x6d, 0x30, 0x54, 0xf0, 0x36, 0x78, 0x0a, 0x86, 0xd9, 0x0f, 0xb5, 0x02, 0xd4, 0x6c, 0xac, 0xf2, + 0x62, 0x2c, 0xe1, 0xc9, 0x05, 0x33, 0xd2, 0xdf, 0x82, 0xa1, 0xaf, 0x0f, 0xb1, 0xa8, 0x99, 0x96, + 0x79, 0x84, 0x9f, 0x72, 0x62, 0xc9, 0x63, 0x09, 0xb3, 0xdf, 0x0f, 0x13, 0x55, 0x87, 0xb4, 0x7d, + 0x6f, 0xd9, 0x6b, 0x76, 0x7c, 0xd7, 0x8b, 0xd0, 0x0c, 0x0c, 0xb0, 0x4b, 0x84, 0x1f, 0x01, 0x03, + 0xb4, 0x21, 0xcc, 0x4a, 0xec, 0x6d, 0x38, 0x55, 0xf5, 0xef, 0x78, 0x77, 0x9c, 0xa0, 0xb9, 0x50, + 0x5b, 0xd5, 0xde, 0xd7, 0xeb, 0xf2, 0x7d, 0xc7, 0x8d, 0xb6, 0x32, 0x8f, 0x5e, 0xad, 0x26, 0x67, + 0x6b, 0x57, 0xdc, 0x16, 0xc9, 0x91, 0x82, 0xfc, 0xe5, 0x92, 0xd1, 0x52, 0x8c, 0xaf, 0xb4, 0x5a, + 0x56, 0xae, 0x56, 0xeb, 0x75, 0x18, 0xd9, 0x72, 0x49, 0xab, 0x89, 0xc9, 0x96, 0x58, 0x89, 0x4f, + 0xe6, 0xdb, 0xa1, 0xac, 0x50, 0x4c, 0x29, 0xf5, 0xe2, 0xaf, 0xc3, 0x15, 0x51, 0x19, 0x2b, 0x32, + 0x68, 0x17, 0xa6, 0xe4, 0x83, 0x41, 0x42, 0xc5, 0xba, 0x7c, 0xaa, 0xe8, 0x15, 0x62, 0x12, 0x3f, + 0x79, 0xef, 0x60, 0x6e, 0x0a, 0x27, 0xc8, 0xe0, 0x14, 0x61, 0xfa, 0x1c, 0x6c, 0xd3, 0x13, 0x78, + 0x80, 0x0d, 0x3f, 0x7b, 0x0e, 0xb2, 0x97, 0x2d, 0x2b, 0xb5, 0x7f, 0xc2, 0x82, 0x47, 0x52, 0x23, + 0x23, 0x5e, 0xf8, 0x47, 0x3c, 0x0b, 0xc9, 0x17, 0x77, 0xa9, 0xf7, 0x8b, 0xdb, 0xfe, 0x9b, 0x16, + 0x9c, 0x5c, 0x6e, 0x77, 0xa2, 0xfd, 0xaa, 0x6b, 0xaa, 0xa0, 0x3e, 0x04, 0x43, 0x6d, 0xd2, 0x74, + 0xbb, 0x6d, 0x31, 0x73, 0x73, 0xf2, 0x94, 0x5a, 0x63, 0xa5, 0xf7, 0x0f, 0xe6, 0xc6, 0xeb, 0x91, + 0x1f, 0x38, 0xdb, 0x84, 0x17, 0x60, 0x81, 0xce, 0xce, 0x7a, 0xf7, 0x2d, 0x72, 0xdd, 0x6d, 0xbb, + 0xd2, 0xae, 0xa8, 0x50, 0x66, 0x37, 0x2f, 0x07, 0x74, 0xfe, 0xf5, 0xae, 0xe3, 0x45, 0x6e, 0xb4, + 0x2f, 0xb4, 0x47, 0x92, 0x08, 0x8e, 0xe9, 0xd9, 0x5f, 0xb7, 0x60, 0x52, 0xae, 0xfb, 0x85, 0x66, + 0x33, 0x20, 0x61, 0x88, 0x66, 0xa1, 0xe4, 0x76, 0x44, 0x2f, 0x41, 0xf4, 0xb2, 0xb4, 0x5a, 0xc3, + 0x25, 0xb7, 0x23, 0xd9, 0x32, 0x76, 0x10, 0x96, 0x4d, 0x45, 0xda, 0x55, 0x51, 0x8e, 0x15, 0x06, + 0xba, 0x08, 0x23, 0x9e, 0xdf, 0xe4, 0xb6, 0x5d, 0xfc, 0x4a, 0x63, 0x0b, 0x6c, 0x5d, 0x94, 0x61, + 0x05, 0x45, 0x35, 0xa8, 0x70, 0xb3, 0xa7, 0x78, 0xd1, 0xf6, 0x65, 0x3c, 0xc5, 0xbe, 0x6c, 0x43, + 0xd6, 0xc4, 0x31, 0x11, 0xfb, 0x57, 0x2d, 0x18, 0x93, 0x5f, 0xd6, 0x27, 0xcf, 0x49, 0xb7, 0x56, + 0xcc, 0x6f, 0xc6, 0x5b, 0x8b, 0xf2, 0x8c, 0x0c, 0x62, 0xb0, 0x8a, 0xe5, 0x43, 0xb1, 0x8a, 0x97, + 0x61, 0xd4, 0xe9, 0x74, 0x6a, 0x26, 0x9f, 0xc9, 0x96, 0xd2, 0x42, 0x5c, 0x8c, 0x75, 0x1c, 0xfb, + 0x4b, 0x25, 0x98, 0x90, 0x5f, 0x50, 0xef, 0x6e, 0x86, 0x24, 0x42, 0x1b, 0x50, 0x71, 0xf8, 0x2c, + 0x11, 0xb9, 0xc8, 0x9f, 0xc8, 0x96, 0x23, 0x18, 0x53, 0x1a, 0x5f, 0xf8, 0x0b, 0xb2, 0x36, 0x8e, + 0x09, 0xa1, 0x16, 0x4c, 0x7b, 0x7e, 0xc4, 0x0e, 0x7f, 0x05, 0x2f, 0x52, 0xed, 0x24, 0xa9, 0x9f, + 0x11, 0xd4, 0xa7, 0xd7, 0x93, 0x54, 0x70, 0x9a, 0x30, 0x5a, 0x96, 0xb2, 0x99, 0x72, 0xbe, 0x30, + 0x40, 0x9f, 0xb8, 0x6c, 0xd1, 0x8c, 0xfd, 0x2b, 0x16, 0x54, 0x24, 0xda, 0x71, 0x68, 0xf1, 0xd6, + 0x60, 0x38, 0x64, 0x93, 0x20, 0x87, 0xc6, 0x2e, 0xea, 0x38, 0x9f, 0xaf, 0xf8, 0x4e, 0xe3, 0xff, + 0x43, 0x2c, 0x69, 0x30, 0xd1, 0xbc, 0xea, 0xfe, 0x3b, 0x44, 0x34, 0xaf, 0xfa, 0x93, 0x73, 0x29, + 0xfd, 0x11, 0xeb, 0xb3, 0x26, 0xeb, 0xa2, 0xac, 0x57, 0x27, 0x20, 0x5b, 0xee, 0xdd, 0x24, 0xeb, + 0x55, 0x63, 0xa5, 0x58, 0x40, 0xd1, 0x1b, 0x30, 0xd6, 0x90, 0x32, 0xd9, 0x78, 0x87, 0x5f, 0x28, + 0xd4, 0x0f, 0x28, 0x55, 0x12, 0x97, 0x85, 0x2c, 0x69, 0xf5, 0xb1, 0x41, 0xcd, 0x34, 0x23, 0x28, + 0xf7, 0x32, 0x23, 0x88, 0xe9, 0xe6, 0x2b, 0xd5, 0x7f, 0xd2, 0x82, 0x21, 0x2e, 0x8b, 0xeb, 0x4f, + 0x14, 0xaa, 0x69, 0xd6, 0xe2, 0xb1, 0xbb, 0x45, 0x0b, 0x85, 0xa6, 0x0c, 0xad, 0x41, 0x85, 0xfd, + 0x60, 0xb2, 0xc4, 0x72, 0xbe, 0xd5, 0x3d, 0x6f, 0x55, 0xef, 0xe0, 0x2d, 0x59, 0x0d, 0xc7, 0x14, + 0xec, 0x1f, 0x2f, 0xd3, 0xd3, 0x2d, 0x46, 0x35, 0x2e, 0x7d, 0xeb, 0xe1, 0x5d, 0xfa, 0xa5, 0x87, + 0x75, 0xe9, 0x6f, 0xc3, 0x64, 0x43, 0xd3, 0xc3, 0xc5, 0x33, 0x79, 0xb1, 0x70, 0x91, 0x68, 0x2a, + 0x3b, 0x2e, 0x65, 0x59, 0x32, 0x89, 0xe0, 0x24, 0x55, 0xf4, 0x5d, 0x30, 0xc6, 0xe7, 0x59, 0xb4, + 0xc2, 0x2d, 0x31, 0xde, 0x97, 0xbf, 0x5e, 0xf4, 0x26, 0xb8, 0x54, 0x4e, 0xab, 0x8e, 0x0d, 0x62, + 0xf6, 0x9f, 0x5a, 0x80, 0x96, 0x3b, 0x3b, 0xa4, 0x4d, 0x02, 0xa7, 0x15, 0x8b, 0xd3, 0x7f, 0xd8, + 0x82, 0x19, 0x92, 0x2a, 0x5e, 0xf2, 0xdb, 0x6d, 0xf1, 0x68, 0xc9, 0x79, 0x57, 0x2f, 0xe7, 0xd4, + 0x51, 0x6e, 0x09, 0x33, 0x79, 0x18, 0x38, 0xb7, 0x3d, 0xb4, 0x06, 0x27, 0xf8, 0x2d, 0xa9, 0x00, + 0x9a, 0xed, 0xf5, 0xa3, 0x82, 0xf0, 0x89, 0x8d, 0x34, 0x0a, 0xce, 0xaa, 0x67, 0x7f, 0xdf, 0x18, + 0xe4, 0xf6, 0xe2, 0x5d, 0x3d, 0xc2, 0xbb, 0x7a, 0x84, 0x77, 0xf5, 0x08, 0xef, 0xea, 0x11, 0xde, + 0xd5, 0x23, 0x7c, 0xdb, 0xeb, 0x11, 0xfe, 0x7f, 0x0b, 0x4e, 0xa9, 0x6b, 0xc0, 0x78, 0xf8, 0x7e, + 0x16, 0x4e, 0xf0, 0xed, 0xb6, 0xd4, 0x72, 0xdc, 0xf6, 0x06, 0x69, 0x77, 0x5a, 0x4e, 0x24, 0xb5, + 0xee, 0x97, 0x33, 0x57, 0x6e, 0xc2, 0x62, 0xd5, 0xa8, 0xb8, 0xf8, 0x08, 0xbd, 0x9e, 0x32, 0x00, + 0x38, 0xab, 0x19, 0xfb, 0x17, 0x47, 0x60, 0x70, 0x79, 0x8f, 0x78, 0xd1, 0x31, 0x3c, 0x11, 0x1a, + 0x30, 0xe1, 0x7a, 0x7b, 0x7e, 0x6b, 0x8f, 0x34, 0x39, 0xfc, 0x30, 0x2f, 0xd9, 0xd3, 0x82, 0xf4, + 0xc4, 0xaa, 0x41, 0x02, 0x27, 0x48, 0x3e, 0x0c, 0x69, 0xf2, 0x15, 0x18, 0xe2, 0x87, 0xb8, 0x10, + 0x25, 0x67, 0x9e, 0xd9, 0x6c, 0x10, 0xc5, 0xd5, 0x14, 0x4b, 0xba, 0xf9, 0x25, 0x21, 0xaa, 0xa3, + 0xcf, 0xc0, 0xc4, 0x96, 0x1b, 0x84, 0xd1, 0x86, 0xdb, 0x26, 0x61, 0xe4, 0xb4, 0x3b, 0x0f, 0x20, + 0x3d, 0x56, 0xe3, 0xb0, 0x62, 0x50, 0xc2, 0x09, 0xca, 0x68, 0x1b, 0xc6, 0x5b, 0x8e, 0xde, 0xd4, + 0xf0, 0xa1, 0x9b, 0x52, 0xb7, 0xc3, 0x75, 0x9d, 0x10, 0x36, 0xe9, 0xd2, 0xed, 0xd4, 0x60, 0x02, + 0xd0, 0x11, 0x26, 0x16, 0x50, 0xdb, 0x89, 0x4b, 0x3e, 0x39, 0x8c, 0x32, 0x3a, 0xcc, 0x40, 0xb6, + 0x62, 0x32, 0x3a, 0x9a, 0x19, 0xec, 0xa7, 0xa1, 0x42, 0xe8, 0x10, 0x52, 0xc2, 0xe2, 0x82, 0xb9, + 0xd4, 0x5f, 0x5f, 0xd7, 0xdc, 0x46, 0xe0, 0x9b, 0x72, 0xfb, 0x65, 0x49, 0x09, 0xc7, 0x44, 0xd1, + 0x12, 0x0c, 0x85, 0x24, 0x70, 0x49, 0x28, 0xae, 0x9a, 0x82, 0x69, 0x64, 0x68, 0xdc, 0xb7, 0x84, + 0xff, 0xc6, 0xa2, 0x2a, 0x5d, 0x5e, 0x0e, 0x13, 0x69, 0xb2, 0xcb, 0x40, 0x5b, 0x5e, 0x0b, 0xac, + 0x14, 0x0b, 0x28, 0x7a, 0x0d, 0x86, 0x03, 0xd2, 0x62, 0x8a, 0xa1, 0xf1, 0xfe, 0x17, 0x39, 0xd7, + 0x33, 0xf1, 0x7a, 0x58, 0x12, 0x40, 0xd7, 0x00, 0x05, 0x84, 0x32, 0x4a, 0xae, 0xb7, 0xad, 0xcc, + 0x46, 0xc5, 0x41, 0xab, 0x18, 0x52, 0x1c, 0x63, 0x48, 0x37, 0x1f, 0x9c, 0x51, 0x0d, 0x5d, 0x81, + 0x69, 0x55, 0xba, 0xea, 0x85, 0x91, 0x43, 0x0f, 0xb8, 0x49, 0x46, 0x4b, 0xc9, 0x29, 0x70, 0x12, + 0x01, 0xa7, 0xeb, 0xd8, 0x5f, 0xb6, 0x80, 0x8f, 0xf3, 0x31, 0xbc, 0xce, 0x5f, 0x35, 0x5f, 0xe7, + 0x67, 0x72, 0x67, 0x2e, 0xe7, 0x65, 0xfe, 0x65, 0x0b, 0x46, 0xb5, 0x99, 0x8d, 0xd7, 0xac, 0x55, + 0xb0, 0x66, 0xbb, 0x30, 0x45, 0x57, 0xfa, 0x8d, 0xcd, 0x90, 0x04, 0x7b, 0xa4, 0xc9, 0x16, 0x66, + 0xe9, 0xc1, 0x16, 0xa6, 0x32, 0x51, 0xbb, 0x9e, 0x20, 0x88, 0x53, 0x4d, 0xd8, 0x9f, 0x96, 0x5d, + 0x55, 0x16, 0x7d, 0x0d, 0x35, 0xe7, 0x09, 0x8b, 0x3e, 0x35, 0xab, 0x38, 0xc6, 0xa1, 0x5b, 0x6d, + 0xc7, 0x0f, 0xa3, 0xa4, 0x45, 0xdf, 0x55, 0x3f, 0x8c, 0x30, 0x83, 0xd8, 0xcf, 0x03, 0x2c, 0xdf, + 0x25, 0x0d, 0xbe, 0x62, 0xf5, 0xc7, 0x83, 0x95, 0xff, 0x78, 0xb0, 0x7f, 0xdb, 0x82, 0x89, 0x95, + 0x25, 0xe3, 0xe6, 0x9a, 0x07, 0xe0, 0x2f, 0x9e, 0xdb, 0xb7, 0xd7, 0xa5, 0x3a, 0x9c, 0x6b, 0x34, + 0x55, 0x29, 0xd6, 0x30, 0xd0, 0x19, 0x28, 0xb7, 0xba, 0x9e, 0x10, 0x1f, 0x0e, 0xd3, 0xeb, 0xf1, + 0x7a, 0xd7, 0xc3, 0xb4, 0x4c, 0x73, 0x29, 0x28, 0xf7, 0xed, 0x52, 0xd0, 0xd3, 0xb5, 0x1f, 0xcd, + 0xc1, 0xe0, 0x9d, 0x3b, 0x6e, 0x93, 0x3b, 0x50, 0x0a, 0x55, 0xfd, 0xed, 0xdb, 0xab, 0xd5, 0x10, + 0xf3, 0x72, 0xfb, 0x0b, 0x65, 0x98, 0x5d, 0x69, 0x91, 0xbb, 0x6f, 0xd3, 0x89, 0xb4, 0x5f, 0x87, + 0x88, 0xc3, 0x09, 0x62, 0x0e, 0xeb, 0xf4, 0xd2, 0x7b, 0x3c, 0xb6, 0x60, 0x98, 0x1b, 0xb4, 0x49, + 0x97, 0xd2, 0x57, 0xb2, 0x5a, 0xcf, 0x1f, 0x90, 0x79, 0x6e, 0x18, 0x27, 0x3c, 0xe2, 0xd4, 0x85, + 0x29, 0x4a, 0xb1, 0x24, 0x3e, 0xfb, 0x32, 0x8c, 0xe9, 0x98, 0x87, 0x72, 0x3f, 0xfb, 0x7f, 0xca, + 0x30, 0x45, 0x7b, 0xf0, 0x50, 0x27, 0xe2, 0x66, 0x7a, 0x22, 0x8e, 0xda, 0x05, 0xa9, 0xf7, 0x6c, + 0xbc, 0x91, 0x9c, 0x8d, 0xcb, 0x79, 0xb3, 0x71, 0xdc, 0x73, 0xf0, 0xbd, 0x16, 0x9c, 0x58, 0x69, + 0xf9, 0x8d, 0xdd, 0x84, 0x9b, 0xd0, 0x8b, 0x30, 0x4a, 0x8f, 0xe3, 0xd0, 0xf0, 0x60, 0x37, 0x62, + 0x1a, 0x08, 0x10, 0xd6, 0xf1, 0xb4, 0x6a, 0x37, 0x6f, 0xae, 0x56, 0xb3, 0x42, 0x21, 0x08, 0x10, + 0xd6, 0xf1, 0xec, 0xdf, 0xb0, 0xe0, 0xec, 0x95, 0xa5, 0xe5, 0x78, 0x29, 0xa6, 0xa2, 0x31, 0x5c, + 0x80, 0xa1, 0x4e, 0x53, 0xeb, 0x4a, 0x2c, 0x5e, 0xad, 0xb2, 0x5e, 0x08, 0xe8, 0x3b, 0x25, 0xd2, + 0xc8, 0xcf, 0x5a, 0x70, 0xe2, 0x8a, 0x1b, 0xd1, 0xdb, 0x35, 0x19, 0x17, 0x80, 0x5e, 0xaf, 0xa1, + 0x1b, 0xf9, 0xc1, 0x7e, 0x32, 0x2e, 0x00, 0x56, 0x10, 0xac, 0x61, 0xf1, 0x96, 0xf7, 0x5c, 0x66, + 0x4a, 0x5d, 0x32, 0x15, 0x4d, 0x58, 0x94, 0x63, 0x85, 0x41, 0x3f, 0xac, 0xe9, 0x06, 0x4c, 0x46, + 0xb7, 0x2f, 0x4e, 0x58, 0xf5, 0x61, 0x55, 0x09, 0xc0, 0x31, 0x8e, 0xfd, 0xc7, 0x16, 0xcc, 0x5d, + 0x69, 0x75, 0xc3, 0x88, 0x04, 0x5b, 0x61, 0xce, 0xe9, 0xf8, 0x3c, 0x54, 0x88, 0x94, 0x88, 0x8b, + 0x5e, 0x2b, 0x8e, 0x51, 0x89, 0xca, 0x79, 0x78, 0x02, 0x85, 0xd7, 0x87, 0xd3, 0xe1, 0xe1, 0xbc, + 0xc6, 0x56, 0x00, 0x11, 0xbd, 0x2d, 0x3d, 0x5e, 0x03, 0x73, 0xfc, 0x5e, 0x4e, 0x41, 0x71, 0x46, + 0x0d, 0xfb, 0x27, 0x2c, 0x38, 0xa5, 0x3e, 0xf8, 0x1d, 0xf7, 0x99, 0xf6, 0x57, 0x4b, 0x30, 0x7e, + 0x75, 0x63, 0xa3, 0x76, 0x85, 0x44, 0xe2, 0xda, 0xee, 0xad, 0xe7, 0xc6, 0x9a, 0xba, 0xae, 0xe8, + 0x31, 0xd7, 0x8d, 0xdc, 0xd6, 0x3c, 0x0f, 0xfb, 0x33, 0xbf, 0xea, 0x45, 0x37, 0x82, 0x7a, 0x14, + 0xb8, 0xde, 0x76, 0xa6, 0x82, 0x4f, 0x32, 0x17, 0xe5, 0x3c, 0xe6, 0x02, 0x3d, 0x0f, 0x43, 0x2c, + 0xee, 0x90, 0x9c, 0x84, 0x47, 0xd5, 0x5b, 0x88, 0x95, 0xde, 0x3f, 0x98, 0xab, 0xdc, 0xc4, 0xab, + 0xfc, 0x0f, 0x16, 0xa8, 0xe8, 0x26, 0x8c, 0xee, 0x44, 0x51, 0xe7, 0x2a, 0x71, 0x9a, 0x24, 0x90, + 0xc7, 0xe1, 0xb9, 0xac, 0xe3, 0x90, 0x0e, 0x02, 0x47, 0x8b, 0x4f, 0x90, 0xb8, 0x2c, 0xc4, 0x3a, + 0x1d, 0xbb, 0x0e, 0x10, 0xc3, 0x8e, 0x48, 0x53, 0x61, 0x6f, 0x40, 0x85, 0x7e, 0xee, 0x42, 0xcb, + 0x75, 0x8a, 0x75, 0xc1, 0x4f, 0x43, 0x45, 0x6a, 0x7a, 0x43, 0xe1, 0x14, 0xcd, 0xae, 0x0e, 0xa9, + 0x08, 0x0e, 0x71, 0x0c, 0xb7, 0xb7, 0xe0, 0x24, 0xb3, 0xdb, 0x73, 0xa2, 0x1d, 0x63, 0xf5, 0xf5, + 0x9e, 0xe6, 0x67, 0xc4, 0xd3, 0x8a, 0xf7, 0x79, 0x46, 0xf3, 0x3b, 0x1c, 0x93, 0x14, 0xe3, 0x67, + 0x96, 0xfd, 0x8d, 0x01, 0x78, 0x74, 0xb5, 0x9e, 0x1f, 0x37, 0xe3, 0x25, 0x18, 0xe3, 0x1c, 0x1b, + 0x9d, 0x74, 0xa7, 0x25, 0xda, 0x55, 0x42, 0xc8, 0x0d, 0x0d, 0x86, 0x0d, 0x4c, 0x74, 0x16, 0xca, + 0xee, 0x9b, 0x5e, 0xd2, 0x2b, 0x67, 0xf5, 0xf5, 0x75, 0x4c, 0xcb, 0x29, 0x98, 0x32, 0x7f, 0xfc, + 0x54, 0x55, 0x60, 0xc5, 0x00, 0xbe, 0x0a, 0x13, 0x6e, 0xd8, 0x08, 0xdd, 0x55, 0x8f, 0xee, 0x40, + 0x6d, 0x0f, 0xab, 0x67, 0x3f, 0xed, 0xb4, 0x82, 0xe2, 0x04, 0xb6, 0x76, 0xc4, 0x0f, 0xf6, 0xcd, + 0x40, 0xf6, 0xf4, 0x12, 0xa6, 0xbc, 0x71, 0x87, 0x7d, 0x5d, 0xc8, 0xa4, 0xc9, 0x82, 0x37, 0xe6, + 0x1f, 0x1c, 0x62, 0x09, 0xa3, 0x6f, 0xaa, 0xc6, 0x8e, 0xd3, 0x59, 0xe8, 0x46, 0x3b, 0x55, 0x37, + 0x6c, 0xf8, 0x7b, 0x24, 0xd8, 0x67, 0xcf, 0xe1, 0x91, 0xf8, 0x4d, 0xa5, 0x00, 0x4b, 0x57, 0x17, + 0x6a, 0x14, 0x13, 0xa7, 0xeb, 0xa0, 0x05, 0x98, 0x94, 0x85, 0x75, 0x12, 0xb2, 0xc3, 0x7d, 0x94, + 0x91, 0x51, 0x7e, 0x32, 0xa2, 0x58, 0x11, 0x49, 0xe2, 0x9b, 0x3c, 0x26, 0x1c, 0x05, 0x8f, 0xf9, + 0x21, 0x18, 0x77, 0x3d, 0x37, 0x72, 0x9d, 0xc8, 0xe7, 0xaa, 0x10, 0xfe, 0xf2, 0x65, 0x32, 0xde, + 0x55, 0x1d, 0x80, 0x4d, 0x3c, 0xfb, 0x3f, 0x0e, 0xc0, 0x34, 0x9b, 0xb6, 0x77, 0x57, 0xd8, 0xb7, + 0xd3, 0x0a, 0xbb, 0x99, 0x5e, 0x61, 0x47, 0xc1, 0x3c, 0x3f, 0xf0, 0x32, 0xfb, 0x0c, 0x54, 0x94, + 0x6b, 0x90, 0xf4, 0x0d, 0xb4, 0x72, 0x7c, 0x03, 0x7b, 0xdf, 0xcb, 0xd2, 0xba, 0xaa, 0x9c, 0x69, + 0x5d, 0xf5, 0x15, 0x0b, 0x62, 0xd9, 0x3e, 0x7a, 0x1d, 0x2a, 0x1d, 0x9f, 0x19, 0x0d, 0x06, 0xd2, + 0x12, 0xf7, 0xbd, 0x85, 0xca, 0x01, 0x1e, 0x3a, 0x28, 0xe0, 0xa3, 0x50, 0x93, 0x55, 0x71, 0x4c, + 0x05, 0x5d, 0x83, 0xe1, 0x4e, 0x40, 0xea, 0x11, 0x8b, 0xa3, 0xd1, 0x3f, 0x41, 0xbe, 0x6a, 0x78, + 0x45, 0x2c, 0x29, 0xd8, 0xff, 0xd9, 0x82, 0xa9, 0x24, 0x2a, 0xfa, 0x30, 0x0c, 0x90, 0xbb, 0xa4, + 0x21, 0xfa, 0x9b, 0x79, 0xc9, 0xc6, 0xd2, 0x01, 0x3e, 0x00, 0xf4, 0x3f, 0x66, 0xb5, 0xd0, 0x55, + 0x18, 0xa6, 0x37, 0xec, 0x15, 0x15, 0xc3, 0xe9, 0xf1, 0xbc, 0x5b, 0x5a, 0xb1, 0x2a, 0xbc, 0x73, + 0xa2, 0x08, 0xcb, 0xea, 0xcc, 0xa4, 0xa9, 0xd1, 0xa9, 0xd3, 0x57, 0x46, 0x54, 0xf4, 0x18, 0xde, + 0x58, 0xaa, 0x71, 0x24, 0x41, 0x8d, 0x9b, 0x34, 0xc9, 0x42, 0x1c, 0x13, 0xb1, 0x7f, 0xde, 0x02, + 0xe0, 0x16, 0x5c, 0x8e, 0xb7, 0x4d, 0x8e, 0x41, 0xa0, 0x5d, 0x85, 0x81, 0xb0, 0x43, 0x1a, 0x45, + 0xf6, 0xac, 0x71, 0x7f, 0xea, 0x1d, 0xd2, 0x88, 0x57, 0x1c, 0xfd, 0x87, 0x59, 0x6d, 0xfb, 0xfb, + 0x01, 0x26, 0x62, 0xb4, 0xd5, 0x88, 0xb4, 0xd1, 0xb3, 0x46, 0x3c, 0x81, 0x33, 0x89, 0x78, 0x02, + 0x15, 0x86, 0xad, 0xc9, 0x4e, 0x3f, 0x03, 0xe5, 0xb6, 0x73, 0x57, 0x08, 0xc7, 0x9e, 0x2e, 0xee, + 0x06, 0xa5, 0x3f, 0xbf, 0xe6, 0xdc, 0xe5, 0xef, 0xc7, 0xa7, 0xe5, 0x0e, 0x59, 0x73, 0xee, 0xde, + 0xe7, 0x56, 0xab, 0xec, 0x94, 0xbe, 0xee, 0x86, 0xd1, 0xe7, 0xfe, 0x43, 0xfc, 0x9f, 0xed, 0x3b, + 0xda, 0x08, 0x6b, 0xcb, 0xf5, 0x84, 0x71, 0x52, 0x5f, 0x6d, 0xb9, 0x5e, 0xb2, 0x2d, 0xd7, 0xeb, + 0xa3, 0x2d, 0xd7, 0x43, 0x6f, 0xc1, 0xb0, 0xb0, 0x1d, 0x14, 0xf1, 0x7b, 0x2e, 0xf5, 0xd1, 0x9e, + 0x30, 0x3d, 0xe4, 0x6d, 0x5e, 0x92, 0xef, 0x63, 0x51, 0xda, 0xb3, 0x5d, 0xd9, 0x20, 0xfa, 0x4b, + 0x16, 0x4c, 0x88, 0xdf, 0x98, 0xbc, 0xd9, 0x25, 0x61, 0x24, 0xd8, 0xd2, 0x0f, 0xf6, 0xdf, 0x07, + 0x51, 0x91, 0x77, 0xe5, 0x83, 0xf2, 0x9e, 0x31, 0x81, 0x3d, 0x7b, 0x94, 0xe8, 0x05, 0xfa, 0xdb, + 0x16, 0x9c, 0x6c, 0x3b, 0x77, 0x79, 0x8b, 0xbc, 0x0c, 0x3b, 0x91, 0xeb, 0x0b, 0x1d, 0xfc, 0x87, + 0xfb, 0x9b, 0xfe, 0x54, 0x75, 0xde, 0x49, 0xa9, 0x28, 0x3c, 0x99, 0x85, 0xd2, 0xb3, 0xab, 0x99, + 0xfd, 0x9a, 0xdd, 0x82, 0x11, 0xb9, 0xde, 0x32, 0xa4, 0x10, 0x55, 0x9d, 0xe7, 0x3e, 0xb4, 0xe9, + 0xa6, 0xee, 0xa7, 0x4f, 0xdb, 0x11, 0x6b, 0xed, 0xa1, 0xb6, 0xf3, 0x19, 0x18, 0xd3, 0xd7, 0xd8, + 0x43, 0x6d, 0xeb, 0x4d, 0x38, 0x91, 0xb1, 0x96, 0x1e, 0x6a, 0x93, 0x77, 0xe0, 0x4c, 0xee, 0xfa, + 0x78, 0x98, 0x0d, 0xdb, 0x5f, 0xb5, 0xf4, 0x73, 0xf0, 0x18, 0xb4, 0x0a, 0x4b, 0xa6, 0x56, 0xe1, + 0x5c, 0xf1, 0xce, 0xc9, 0x51, 0x2d, 0xbc, 0xa1, 0x77, 0x9a, 0x9e, 0xea, 0xe8, 0x35, 0x18, 0x6a, + 0xd1, 0x12, 0x69, 0x81, 0x6a, 0xf7, 0xde, 0x91, 0x31, 0x33, 0xc9, 0xca, 0x43, 0x2c, 0x28, 0xd8, + 0xbf, 0x64, 0xc1, 0xc0, 0x31, 0x8c, 0x04, 0x36, 0x47, 0xe2, 0xd9, 0x5c, 0xd2, 0x22, 0xb4, 0xf0, + 0x3c, 0x76, 0xee, 0x2c, 0xdf, 0x8d, 0x88, 0x17, 0xb2, 0x1b, 0x39, 0x73, 0x60, 0x7e, 0xda, 0x82, + 0x13, 0xd7, 0x7d, 0xa7, 0xb9, 0xe8, 0xb4, 0x1c, 0xaf, 0x41, 0x82, 0x55, 0x6f, 0xfb, 0x50, 0xe6, + 0xd3, 0xa5, 0x9e, 0xe6, 0xd3, 0x4b, 0xd2, 0xfa, 0x68, 0x20, 0x7f, 0xfe, 0x28, 0x27, 0x9d, 0x8c, + 0xb0, 0x62, 0xd8, 0xc9, 0xee, 0x00, 0xd2, 0x7b, 0x29, 0x9c, 0x59, 0x30, 0x0c, 0xbb, 0xbc, 0xbf, + 0x62, 0x12, 0x9f, 0xcc, 0xe6, 0x70, 0x53, 0x9f, 0xa7, 0xb9, 0x69, 0xf0, 0x02, 0x2c, 0x09, 0xd9, + 0x2f, 0x41, 0xa6, 0x47, 0x7c, 0x6f, 0xb9, 0x84, 0xfd, 0x71, 0x98, 0x66, 0x35, 0x0f, 0x29, 0x19, + 0xb0, 0x13, 0x62, 0xcf, 0x8c, 0x58, 0x79, 0xf6, 0xe7, 0x2d, 0x98, 0x5c, 0x4f, 0x84, 0x10, 0xbb, + 0xc0, 0x14, 0xa5, 0x19, 0xd2, 0xf6, 0x3a, 0x2b, 0xc5, 0x02, 0x7a, 0xe4, 0x42, 0xae, 0xbf, 0xb0, + 0x20, 0x0e, 0x52, 0x71, 0x0c, 0xec, 0xdb, 0x92, 0xc1, 0xbe, 0x65, 0x32, 0xb2, 0xaa, 0x3b, 0x79, + 0xdc, 0x1b, 0xba, 0xa6, 0xc2, 0x37, 0x15, 0xf0, 0xb0, 0x31, 0x19, 0xbe, 0x14, 0x27, 0xcc, 0x18, + 0x4f, 0x32, 0xa0, 0x93, 0xfd, 0x3b, 0x25, 0x40, 0x0a, 0xb7, 0xef, 0xf0, 0x52, 0xe9, 0x1a, 0x47, + 0x13, 0x5e, 0x6a, 0x0f, 0x10, 0x53, 0xf5, 0x07, 0x8e, 0x17, 0x72, 0xb2, 0xae, 0x10, 0xeb, 0x1d, + 0xce, 0x8e, 0x60, 0x56, 0x34, 0x89, 0xae, 0xa7, 0xa8, 0xe1, 0x8c, 0x16, 0x34, 0x13, 0x8e, 0xc1, + 0x7e, 0x4d, 0x38, 0x86, 0x7a, 0x38, 0xac, 0xfd, 0x9c, 0x05, 0xe3, 0x6a, 0x98, 0xde, 0x21, 0xe6, + 0xe4, 0xaa, 0x3f, 0x39, 0x07, 0x68, 0x4d, 0xeb, 0x32, 0xbb, 0x58, 0xbe, 0x93, 0x39, 0x1e, 0x3a, + 0x2d, 0xf7, 0x2d, 0xa2, 0x82, 0xfb, 0xcd, 0x09, 0x47, 0x42, 0x51, 0x7a, 0xff, 0x60, 0x6e, 0x5c, + 0xfd, 0xe3, 0xc1, 0x84, 0xe3, 0x2a, 0xf4, 0x48, 0x9e, 0x4c, 0x2c, 0x45, 0xf4, 0x22, 0x0c, 0x76, + 0x76, 0x9c, 0x90, 0x24, 0xdc, 0x6e, 0x06, 0x6b, 0xb4, 0xf0, 0xfe, 0xc1, 0xdc, 0x84, 0xaa, 0xc0, + 0x4a, 0x30, 0xc7, 0xee, 0x3f, 0x68, 0x57, 0x7a, 0x71, 0xf6, 0x0c, 0xda, 0xf5, 0xa7, 0x16, 0x0c, + 0xac, 0xfb, 0xcd, 0xe3, 0x38, 0x02, 0x5e, 0x35, 0x8e, 0x80, 0xc7, 0xf2, 0xe2, 0xbc, 0xe7, 0xee, + 0xfe, 0x95, 0xc4, 0xee, 0x3f, 0x97, 0x4b, 0xa1, 0x78, 0xe3, 0xb7, 0x61, 0x94, 0x45, 0x8f, 0x17, + 0x2e, 0x46, 0xcf, 0x1b, 0x1b, 0x7e, 0x2e, 0xb1, 0xe1, 0x27, 0x35, 0x54, 0x6d, 0xa7, 0x3f, 0x05, + 0xc3, 0xc2, 0x67, 0x25, 0xe9, 0xbf, 0x29, 0x70, 0xb1, 0x84, 0xdb, 0x3f, 0x59, 0x06, 0x23, 0x5a, + 0x3d, 0xfa, 0x15, 0x0b, 0xe6, 0x03, 0x6e, 0xcb, 0xda, 0xac, 0x76, 0x03, 0xd7, 0xdb, 0xae, 0x37, + 0x76, 0x48, 0xb3, 0xdb, 0x72, 0xbd, 0xed, 0xd5, 0x6d, 0xcf, 0x57, 0xc5, 0xcb, 0x77, 0x49, 0xa3, + 0xcb, 0xf4, 0x63, 0x3d, 0x42, 0xe3, 0x2b, 0x9b, 0xf0, 0xe7, 0xee, 0x1d, 0xcc, 0xcd, 0xe3, 0x43, + 0xd1, 0xc6, 0x87, 0xec, 0x0b, 0xfa, 0x0d, 0x0b, 0x2e, 0xf1, 0x20, 0xee, 0xfd, 0xf7, 0xbf, 0xe0, + 0xb5, 0x5c, 0x93, 0xa4, 0x62, 0x22, 0x1b, 0x24, 0x68, 0x2f, 0x7e, 0x48, 0x0c, 0xe8, 0xa5, 0xda, + 0xe1, 0xda, 0xc2, 0x87, 0xed, 0x9c, 0xfd, 0x8f, 0xcb, 0x30, 0x2e, 0x82, 0x3b, 0x89, 0x3b, 0xe0, + 0x45, 0x63, 0x49, 0x3c, 0x9e, 0x58, 0x12, 0xd3, 0x06, 0xf2, 0xd1, 0x1c, 0xff, 0x21, 0x4c, 0xd3, + 0xc3, 0xf9, 0x2a, 0x71, 0x82, 0x68, 0x93, 0x38, 0xdc, 0x32, 0xab, 0x7c, 0xe8, 0xd3, 0x5f, 0xc9, + 0x27, 0xaf, 0x27, 0x89, 0xe1, 0x34, 0xfd, 0x6f, 0xa7, 0x3b, 0xc7, 0x83, 0xa9, 0x54, 0x7c, 0xae, + 0x4f, 0x40, 0x45, 0x39, 0x5c, 0x88, 0x43, 0xa7, 0x38, 0xcc, 0x5d, 0x92, 0x02, 0x17, 0x7f, 0xc5, + 0xce, 0x3e, 0x31, 0x39, 0xfb, 0xef, 0x96, 0x8c, 0x06, 0xf9, 0x24, 0xae, 0xc3, 0x88, 0x13, 0x86, + 0xee, 0xb6, 0x47, 0x9a, 0x45, 0x12, 0xca, 0x54, 0x33, 0xcc, 0xe9, 0x65, 0x41, 0xd4, 0xc4, 0x8a, + 0x06, 0xba, 0xca, 0xed, 0xdf, 0xf6, 0x48, 0x91, 0x78, 0x32, 0x45, 0x0d, 0xa4, 0x85, 0xdc, 0x1e, + 0xc1, 0xa2, 0x3e, 0xfa, 0x24, 0x37, 0x50, 0xbc, 0xe6, 0xf9, 0x77, 0xbc, 0x2b, 0xbe, 0x2f, 0x03, + 0x28, 0xf4, 0x47, 0x70, 0x5a, 0x9a, 0x25, 0xaa, 0xea, 0xd8, 0xa4, 0xd6, 0x5f, 0xc0, 0xcb, 0xcf, + 0xc2, 0x09, 0x4a, 0xda, 0xf4, 0x6f, 0x0e, 0x11, 0x81, 0x49, 0x11, 0x39, 0x4c, 0x96, 0x89, 0xb1, + 0xcb, 0x7c, 0xca, 0x99, 0xb5, 0x63, 0x41, 0xfa, 0x35, 0x93, 0x04, 0x4e, 0xd2, 0xb4, 0x7f, 0xc6, + 0x02, 0xe6, 0xeb, 0x79, 0x0c, 0xfc, 0xc8, 0x47, 0x4c, 0x7e, 0x64, 0x26, 0x6f, 0x90, 0x73, 0x58, + 0x91, 0x17, 0xf8, 0xca, 0xaa, 0x05, 0xfe, 0xdd, 0x7d, 0x61, 0x55, 0xd2, 0xfb, 0xfd, 0x61, 0xff, + 0x2f, 0x8b, 0x1f, 0x62, 0xca, 0x1d, 0x02, 0x7d, 0x37, 0x8c, 0x34, 0x9c, 0x8e, 0xd3, 0xe0, 0xa9, + 0x55, 0x72, 0x25, 0x7a, 0x46, 0xa5, 0xf9, 0x25, 0x51, 0x83, 0x4b, 0xa8, 0x64, 0x04, 0xba, 0x11, + 0x59, 0xdc, 0x53, 0x2a, 0xa5, 0x9a, 0x9c, 0xdd, 0x85, 0x71, 0x83, 0xd8, 0x43, 0x15, 0x67, 0x7c, + 0x37, 0xbf, 0x62, 0x55, 0xc4, 0xc4, 0x36, 0x4c, 0x7b, 0xda, 0x7f, 0x7a, 0xa1, 0xc8, 0xc7, 0xe5, + 0x7b, 0x7b, 0x5d, 0xa2, 0xec, 0xf6, 0xd1, 0xdc, 0x48, 0x13, 0x64, 0x70, 0x9a, 0xb2, 0xfd, 0x53, + 0x16, 0x3c, 0xa2, 0x23, 0x6a, 0x9e, 0x2a, 0xbd, 0x94, 0x24, 0x55, 0x18, 0xf1, 0x3b, 0x24, 0x70, + 0x22, 0x3f, 0x10, 0xb7, 0xc6, 0x45, 0x39, 0xe8, 0x37, 0x44, 0xf9, 0x7d, 0x11, 0x98, 0x5c, 0x52, + 0x97, 0xe5, 0x58, 0xd5, 0xa4, 0xaf, 0x4f, 0x36, 0x18, 0xa1, 0xf0, 0x49, 0x62, 0x67, 0x00, 0xd3, + 0xa4, 0x87, 0x58, 0x40, 0xec, 0x6f, 0x58, 0x7c, 0x61, 0xe9, 0x5d, 0x47, 0x6f, 0xc2, 0x54, 0xdb, + 0x89, 0x1a, 0x3b, 0xcb, 0x77, 0x3b, 0x01, 0x57, 0x39, 0xc9, 0x71, 0x7a, 0xba, 0xd7, 0x38, 0x69, + 0x1f, 0x19, 0xdb, 0x5c, 0xae, 0x25, 0x88, 0xe1, 0x14, 0x79, 0xb4, 0x09, 0xa3, 0xac, 0x8c, 0xb9, + 0xdb, 0x85, 0x45, 0xac, 0x41, 0x5e, 0x6b, 0xca, 0x18, 0x61, 0x2d, 0xa6, 0x83, 0x75, 0xa2, 0xf6, + 0x57, 0xca, 0x7c, 0xb7, 0x33, 0x56, 0xfe, 0x29, 0x18, 0xee, 0xf8, 0xcd, 0xa5, 0xd5, 0x2a, 0x16, + 0xb3, 0xa0, 0xae, 0x91, 0x1a, 0x2f, 0xc6, 0x12, 0x8e, 0x2e, 0xc2, 0x88, 0xf8, 0x29, 0x55, 0x84, + 0xec, 0x6c, 0x16, 0x78, 0x21, 0x56, 0x50, 0xf4, 0x1c, 0x40, 0x27, 0xf0, 0xf7, 0xdc, 0x26, 0x0b, + 0x03, 0x51, 0x36, 0xed, 0x88, 0x6a, 0x0a, 0x82, 0x35, 0x2c, 0xf4, 0x0a, 0x8c, 0x77, 0xbd, 0x90, + 0xb3, 0x23, 0x5a, 0xd0, 0x57, 0x65, 0xe1, 0x72, 0x53, 0x07, 0x62, 0x13, 0x17, 0x2d, 0xc0, 0x50, + 0xe4, 0x30, 0xbb, 0x98, 0xc1, 0x7c, 0xbb, 0xdc, 0x0d, 0x8a, 0xa1, 0x67, 0xf1, 0xa0, 0x15, 0xb0, + 0xa8, 0x88, 0x3e, 0x21, 0x3d, 0x5f, 0xf9, 0xc1, 0x2e, 0x0c, 0xe2, 0xfb, 0xbb, 0x04, 0x34, 0xbf, + 0x57, 0x61, 0x68, 0x6f, 0xd0, 0x42, 0x2f, 0x03, 0x90, 0xbb, 0x11, 0x09, 0x3c, 0xa7, 0xa5, 0xcc, + 0xce, 0x14, 0x5f, 0x50, 0xf5, 0xd7, 0xfd, 0xe8, 0x66, 0x48, 0x96, 0x15, 0x06, 0xd6, 0xb0, 0xed, + 0xdf, 0xa8, 0x00, 0xc4, 0x7c, 0x3b, 0x7a, 0x2b, 0x75, 0x70, 0x3d, 0x53, 0xcc, 0xe9, 0x1f, 0xdd, + 0xa9, 0x85, 0x7e, 0xc0, 0x82, 0x51, 0xa7, 0xd5, 0xf2, 0x1b, 0x0e, 0x0f, 0xcb, 0x5b, 0x2a, 0x3e, + 0x38, 0x45, 0xfb, 0x0b, 0x71, 0x0d, 0xde, 0x85, 0xe7, 0xe5, 0x0a, 0xd5, 0x20, 0x3d, 0x7b, 0xa1, + 0x37, 0x8c, 0x3e, 0x20, 0x9f, 0x8a, 0x65, 0x63, 0x28, 0xd5, 0x53, 0xb1, 0xc2, 0xee, 0x08, 0xfd, + 0x95, 0x78, 0xd3, 0x78, 0x25, 0x0e, 0xe4, 0xbb, 0xf6, 0x19, 0xec, 0x6b, 0xaf, 0x07, 0x22, 0xaa, + 0xe9, 0x6e, 0xfe, 0x83, 0xf9, 0x7e, 0x74, 0xda, 0x3b, 0xa9, 0x87, 0x8b, 0xff, 0x67, 0x60, 0xb2, + 0x69, 0x32, 0x01, 0x62, 0x25, 0x3e, 0x99, 0x47, 0x37, 0xc1, 0x33, 0xc4, 0xd7, 0x7e, 0x02, 0x80, + 0x93, 0x84, 0x51, 0x8d, 0x47, 0x7d, 0x58, 0xf5, 0xb6, 0x7c, 0xe1, 0x94, 0x61, 0xe7, 0xce, 0xe5, + 0x7e, 0x18, 0x91, 0x36, 0xc5, 0x8c, 0x6f, 0xf7, 0x75, 0x51, 0x17, 0x2b, 0x2a, 0xe8, 0x35, 0x18, + 0x62, 0x8e, 0x54, 0xe1, 0xcc, 0x48, 0xbe, 0xc4, 0xd9, 0x0c, 0x63, 0x16, 0x6f, 0x48, 0xf6, 0x37, + 0xc4, 0x82, 0x02, 0xba, 0x2a, 0xdd, 0x14, 0xc3, 0x55, 0xef, 0x66, 0x48, 0x98, 0x9b, 0x62, 0x65, + 0xf1, 0xbd, 0xb1, 0x07, 0x22, 0x2f, 0xcf, 0xcc, 0xf5, 0x65, 0xd4, 0xa4, 0x5c, 0x94, 0xf8, 0x2f, + 0x53, 0x88, 0xcd, 0x40, 0x7e, 0xf7, 0xcc, 0x34, 0x63, 0xf1, 0x70, 0xde, 0x32, 0x49, 0xe0, 0x24, + 0x4d, 0xca, 0x91, 0xf2, 0x5d, 0x2f, 0xdc, 0x3a, 0x7a, 0x9d, 0x1d, 0xfc, 0x21, 0xce, 0x6e, 0x23, + 0x5e, 0x82, 0x45, 0xfd, 0x63, 0x65, 0x0f, 0x66, 0x3d, 0x98, 0x4a, 0x6e, 0xd1, 0x87, 0xca, 0x8e, + 0xfc, 0xe1, 0x00, 0x4c, 0x98, 0x4b, 0x0a, 0x5d, 0x82, 0x8a, 0x20, 0xa2, 0xc2, 0xfe, 0xab, 0x5d, + 0xb2, 0x26, 0x01, 0x38, 0xc6, 0x61, 0xd9, 0x1e, 0x58, 0x75, 0xcd, 0x8e, 0x37, 0xce, 0xf6, 0xa0, + 0x20, 0x58, 0xc3, 0xa2, 0x0f, 0xab, 0x4d, 0xdf, 0x8f, 0xd4, 0x85, 0xa4, 0xd6, 0xdd, 0x22, 0x2b, + 0xc5, 0x02, 0x4a, 0x2f, 0xa2, 0x5d, 0x12, 0x78, 0xa4, 0x65, 0x06, 0x08, 0x56, 0x17, 0xd1, 0x35, + 0x1d, 0x88, 0x4d, 0x5c, 0x7a, 0x9d, 0xfa, 0x21, 0x5b, 0xc8, 0xe2, 0xf9, 0x16, 0xdb, 0x45, 0xd7, + 0xb9, 0xa7, 0xb4, 0x84, 0xa3, 0x8f, 0xc3, 0x23, 0x2a, 0x08, 0x12, 0xe6, 0xda, 0x0c, 0xd9, 0xe2, + 0x90, 0x21, 0x6d, 0x79, 0x64, 0x29, 0x1b, 0x0d, 0xe7, 0xd5, 0x47, 0xaf, 0xc2, 0x84, 0x60, 0xf1, + 0x25, 0xc5, 0x61, 0xd3, 0xc2, 0xe8, 0x9a, 0x01, 0xc5, 0x09, 0x6c, 0x19, 0xe2, 0x98, 0x71, 0xd9, + 0x92, 0xc2, 0x48, 0x3a, 0xc4, 0xb1, 0x0e, 0xc7, 0xa9, 0x1a, 0x68, 0x01, 0x26, 0x39, 0x0f, 0xe6, + 0x7a, 0xdb, 0x7c, 0x4e, 0x84, 0xd7, 0x95, 0xda, 0x52, 0x37, 0x4c, 0x30, 0x4e, 0xe2, 0xa3, 0x97, + 0x60, 0xcc, 0x09, 0x1a, 0x3b, 0x6e, 0x44, 0x1a, 0x51, 0x37, 0xe0, 0xee, 0x58, 0x9a, 0x89, 0xd6, + 0x82, 0x06, 0xc3, 0x06, 0xa6, 0xfd, 0x16, 0x9c, 0xc8, 0x08, 0xa1, 0x40, 0x17, 0x8e, 0xd3, 0x71, + 0xe5, 0x37, 0x25, 0x2c, 0x9c, 0x17, 0x6a, 0xab, 0xf2, 0x6b, 0x34, 0x2c, 0xba, 0x3a, 0x59, 0xa8, + 0x05, 0x2d, 0x63, 0xa0, 0x5a, 0x9d, 0x2b, 0x12, 0x80, 0x63, 0x1c, 0xfb, 0xbf, 0x95, 0x60, 0x32, + 0x43, 0xb7, 0xc2, 0xb2, 0xd6, 0x25, 0x1e, 0x29, 0x71, 0x92, 0x3a, 0x33, 0x62, 0x76, 0xe9, 0x10, + 0x11, 0xb3, 0xcb, 0xbd, 0x22, 0x66, 0x0f, 0xbc, 0x9d, 0x88, 0xd9, 0xe6, 0x88, 0x0d, 0xf6, 0x35, + 0x62, 0x19, 0x51, 0xb6, 0x87, 0x0e, 0x19, 0x65, 0xdb, 0x18, 0xf4, 0xe1, 0x3e, 0x06, 0xfd, 0xc7, + 0x4b, 0x30, 0x95, 0x34, 0x25, 0x3d, 0x06, 0xb9, 0xed, 0x6b, 0x86, 0xdc, 0xf6, 0x62, 0x3f, 0x5e, + 0xb2, 0xb9, 0x32, 0x5c, 0x9c, 0x90, 0xe1, 0xbe, 0xbf, 0x2f, 0x6a, 0xc5, 0xf2, 0xdc, 0xbf, 0x56, + 0x82, 0x53, 0x99, 0x6e, 0xba, 0xc7, 0x30, 0x36, 0x37, 0x8c, 0xb1, 0x79, 0xb6, 0x6f, 0x0f, 0xe2, + 0xdc, 0x01, 0xba, 0x9d, 0x18, 0xa0, 0x4b, 0xfd, 0x93, 0x2c, 0x1e, 0xa5, 0xaf, 0x97, 0xe1, 0x5c, + 0x66, 0xbd, 0x58, 0xec, 0xb9, 0x62, 0x88, 0x3d, 0x9f, 0x4b, 0x88, 0x3d, 0xed, 0xe2, 0xda, 0x47, + 0x23, 0x07, 0x15, 0x9e, 0xb4, 0x2c, 0x1e, 0xc0, 0x03, 0xca, 0x40, 0x0d, 0x4f, 0x5a, 0x45, 0x08, + 0x9b, 0x74, 0xbf, 0x9d, 0x64, 0x9f, 0xff, 0xca, 0x82, 0x33, 0x99, 0x73, 0x73, 0x0c, 0xb2, 0xae, + 0x75, 0x53, 0xd6, 0xf5, 0x54, 0xdf, 0xab, 0x35, 0x47, 0xf8, 0xf5, 0x95, 0xc1, 0x9c, 0x6f, 0x61, + 0x2f, 0xf9, 0x1b, 0x30, 0xea, 0x34, 0x1a, 0x24, 0x0c, 0xd7, 0xfc, 0xa6, 0x0a, 0x0a, 0xfc, 0x2c, + 0x7b, 0x67, 0xc5, 0xc5, 0xf7, 0x0f, 0xe6, 0x66, 0x93, 0x24, 0x62, 0x30, 0xd6, 0x29, 0xa0, 0x4f, + 0xc2, 0x48, 0x28, 0xee, 0x4d, 0x31, 0xf7, 0xcf, 0xf7, 0x39, 0x38, 0xce, 0x26, 0x69, 0x99, 0x51, + 0x8b, 0x94, 0xa4, 0x42, 0x91, 0x34, 0x23, 0x9c, 0x94, 0x8e, 0x34, 0xc2, 0xc9, 0x73, 0x00, 0x7b, + 0xea, 0x31, 0x90, 0x94, 0x3f, 0x68, 0xcf, 0x04, 0x0d, 0x0b, 0x7d, 0x14, 0xa6, 0x42, 0x1e, 0xd6, + 0x6f, 0xa9, 0xe5, 0x84, 0xcc, 0x8f, 0x46, 0xac, 0x42, 0x16, 0x19, 0xa9, 0x9e, 0x80, 0xe1, 0x14, + 0x36, 0x5a, 0x91, 0xad, 0xb2, 0x18, 0x84, 0x7c, 0x61, 0x5e, 0x88, 0x5b, 0x14, 0x39, 0x73, 0x4f, + 0x26, 0x87, 0x9f, 0x0d, 0xbc, 0x56, 0x13, 0x7d, 0x12, 0x80, 0x2e, 0x1f, 0x21, 0x87, 0x18, 0xce, + 0x3f, 0x3c, 0xe9, 0xa9, 0xd2, 0xcc, 0x34, 0x6e, 0x66, 0xce, 0xaf, 0x55, 0x45, 0x04, 0x6b, 0x04, + 0xd1, 0x16, 0x8c, 0xc7, 0xff, 0xe2, 0x94, 0x92, 0x87, 0x6c, 0x81, 0xc9, 0xbd, 0xab, 0x3a, 0x1d, + 0x6c, 0x92, 0xb5, 0x7f, 0x62, 0x18, 0x1e, 0x2d, 0x38, 0x8b, 0xd1, 0x82, 0xa9, 0xef, 0x7d, 0x3a, + 0xf9, 0x88, 0x9f, 0xcd, 0xac, 0x6c, 0xbc, 0xea, 0x13, 0x4b, 0xbe, 0xf4, 0xb6, 0x97, 0xfc, 0x8f, + 0x58, 0x9a, 0x78, 0x85, 0x5b, 0x96, 0x7e, 0xe4, 0x90, 0x77, 0xcc, 0x11, 0xca, 0x5b, 0xb6, 0x32, + 0x84, 0x16, 0xcf, 0xf5, 0xdd, 0x9d, 0xfe, 0xa5, 0x18, 0x5f, 0xb5, 0x00, 0x09, 0xf1, 0x0a, 0x69, + 0xaa, 0x0d, 0x25, 0xe4, 0x19, 0x57, 0x0e, 0xfb, 0xfd, 0x0b, 0x29, 0x4a, 0x7c, 0x24, 0x5e, 0x96, + 0x97, 0x41, 0x1a, 0xa1, 0xe7, 0x98, 0x64, 0x74, 0x0f, 0x7d, 0x9c, 0x85, 0xbd, 0x75, 0xdf, 0x12, + 0x1c, 0x90, 0xd8, 0x70, 0x2f, 0x8a, 0x90, 0xb7, 0xaa, 0x9c, 0xb2, 0xba, 0x99, 0xdd, 0xd5, 0x91, + 0xb0, 0x41, 0xea, 0x78, 0xdf, 0xdf, 0x5d, 0x78, 0x24, 0x67, 0xc8, 0x1e, 0xea, 0x33, 0xfc, 0xb7, + 0x2d, 0x38, 0x5b, 0x18, 0xbf, 0xe5, 0x5b, 0x90, 0x41, 0xb4, 0x3f, 0x67, 0x41, 0xf6, 0x64, 0x1b, + 0x66, 0x65, 0x97, 0xa0, 0xd2, 0xa0, 0x85, 0x9a, 0xc3, 0x6e, 0x1c, 0xc9, 0x40, 0x02, 0x70, 0x8c, + 0x63, 0x58, 0x8f, 0x95, 0x7a, 0x5a, 0x8f, 0xfd, 0xaa, 0x05, 0xa9, 0x43, 0xfe, 0x18, 0xb8, 0x8d, + 0x55, 0x93, 0xdb, 0x78, 0x6f, 0x3f, 0xa3, 0x99, 0xc3, 0x68, 0xfc, 0xc9, 0x24, 0x9c, 0xce, 0x71, + 0xcb, 0xdb, 0x83, 0xe9, 0xed, 0x06, 0x31, 0x5d, 0xa1, 0x8b, 0x42, 0x04, 0x15, 0xfa, 0x4d, 0xb3, + 0x2c, 0xae, 0xd3, 0x29, 0x14, 0x9c, 0x6e, 0x02, 0x7d, 0xce, 0x82, 0x93, 0xce, 0x9d, 0x70, 0x99, + 0x72, 0x8d, 0x6e, 0x63, 0xb1, 0xe5, 0x37, 0x76, 0xe9, 0x95, 0x2c, 0x37, 0xc2, 0x0b, 0x99, 0x92, + 0xbc, 0xdb, 0xf5, 0x14, 0xbe, 0xd1, 0x3c, 0x4b, 0x6b, 0x9b, 0x85, 0x85, 0x33, 0xdb, 0x42, 0x58, + 0xe4, 0x3a, 0xa0, 0x6f, 0xd2, 0x02, 0x67, 0xfd, 0x2c, 0xff, 0x49, 0xce, 0x06, 0x49, 0x08, 0x56, + 0x74, 0xd0, 0xa7, 0xa1, 0xb2, 0x2d, 0xdd, 0x7d, 0x33, 0xd8, 0xac, 0x78, 0x20, 0x8b, 0x9d, 0xa0, + 0xb9, 0x3a, 0x5e, 0x21, 0xe1, 0x98, 0x28, 0x7a, 0x15, 0xca, 0xde, 0x56, 0x58, 0x94, 0x19, 0x36, + 0x61, 0x77, 0xc9, 0x43, 0x62, 0xac, 0xaf, 0xd4, 0x31, 0xad, 0x88, 0xae, 0x42, 0x39, 0xd8, 0x6c, + 0x0a, 0x31, 0x74, 0xe6, 0x26, 0xc5, 0x8b, 0xd5, 0x9c, 0x5e, 0x31, 0x4a, 0x78, 0xb1, 0x8a, 0x29, + 0x09, 0x54, 0x83, 0x41, 0xe6, 0xcb, 0x26, 0x98, 0x9a, 0xcc, 0xe7, 0x5b, 0x81, 0x4f, 0x28, 0x8f, + 0x9b, 0xc1, 0x10, 0x30, 0x27, 0x84, 0x36, 0x60, 0xa8, 0xc1, 0xb2, 0x88, 0x0a, 0x2e, 0xe6, 0x03, + 0x99, 0x02, 0xe7, 0x82, 0xf4, 0xaa, 0x42, 0xfe, 0xca, 0x30, 0xb0, 0xa0, 0xc5, 0xa8, 0x92, 0xce, + 0xce, 0x56, 0x28, 0xb2, 0x5e, 0x67, 0x53, 0x2d, 0xc8, 0x1a, 0x2c, 0xa8, 0x32, 0x0c, 0x2c, 0x68, + 0xa1, 0x97, 0xa1, 0xb4, 0xd5, 0x10, 0x7e, 0x6a, 0x99, 0x92, 0x67, 0x33, 0xaa, 0xc9, 0xe2, 0xd0, + 0xbd, 0x83, 0xb9, 0xd2, 0xca, 0x12, 0x2e, 0x6d, 0x35, 0xd0, 0x3a, 0x0c, 0x6f, 0xf1, 0x38, 0x08, + 0x42, 0xb8, 0xfc, 0x64, 0x76, 0x88, 0x86, 0x54, 0xa8, 0x04, 0xee, 0xf3, 0x24, 0x00, 0x58, 0x12, + 0x61, 0xa9, 0x03, 0x54, 0x3c, 0x07, 0x11, 0x4e, 0x6e, 0xfe, 0x70, 0x31, 0x38, 0x38, 0x93, 0x19, + 0x47, 0x85, 0xc0, 0x1a, 0x45, 0xba, 0xaa, 0x9d, 0xb7, 0xba, 0x01, 0x8b, 0xd9, 0x2d, 0xe2, 0x0e, + 0x65, 0xae, 0xea, 0x05, 0x89, 0x54, 0xb4, 0xaa, 0x15, 0x12, 0x8e, 0x89, 0xa2, 0x5d, 0x18, 0xdf, + 0x0b, 0x3b, 0x3b, 0x44, 0x6e, 0x69, 0x16, 0x86, 0x28, 0x87, 0x3f, 0xba, 0x25, 0x10, 0xdd, 0x20, + 0xea, 0x3a, 0xad, 0xd4, 0x29, 0xc4, 0x78, 0xd9, 0x5b, 0x3a, 0x31, 0x6c, 0xd2, 0xa6, 0xc3, 0xff, + 0x66, 0xd7, 0xdf, 0xdc, 0x8f, 0x88, 0x88, 0x02, 0x97, 0x39, 0xfc, 0xaf, 0x73, 0x94, 0xf4, 0xf0, + 0x0b, 0x00, 0x96, 0x44, 0xd0, 0x2d, 0x31, 0x3c, 0xec, 0xf4, 0x9c, 0xca, 0x0f, 0xd5, 0xba, 0x20, + 0x91, 0x72, 0x06, 0x85, 0x9d, 0x96, 0x31, 0x29, 0x76, 0x4a, 0x76, 0x76, 0xfc, 0xc8, 0xf7, 0x12, + 0x27, 0xf4, 0x74, 0xfe, 0x29, 0x59, 0xcb, 0xc0, 0x4f, 0x9f, 0x92, 0x59, 0x58, 0x38, 0xb3, 0x2d, + 0xd4, 0x84, 0x89, 0x8e, 0x1f, 0x44, 0x77, 0xfc, 0x40, 0xae, 0x2f, 0x54, 0x20, 0x1c, 0x33, 0x30, + 0x45, 0x8b, 0x2c, 0xc0, 0xa2, 0x09, 0xc1, 0x09, 0x9a, 0xe8, 0x63, 0x30, 0x1c, 0x36, 0x9c, 0x16, + 0x59, 0xbd, 0x31, 0x73, 0x22, 0xff, 0xfa, 0xa9, 0x73, 0x94, 0x9c, 0xd5, 0xc5, 0xf3, 0x0c, 0x70, + 0x14, 0x2c, 0xc9, 0xa1, 0x15, 0x18, 0x64, 0xa9, 0xe1, 0x58, 0xc8, 0xc2, 0x9c, 0x88, 0xb3, 0x29, + 0x2b, 0x78, 0x7e, 0x36, 0xb1, 0x62, 0xcc, 0xab, 0xd3, 0x3d, 0x20, 0xde, 0x88, 0x7e, 0x38, 0x73, + 0x2a, 0x7f, 0x0f, 0x88, 0xa7, 0xe5, 0x8d, 0x7a, 0xd1, 0x1e, 0x50, 0x48, 0x38, 0x26, 0x4a, 0x4f, + 0x66, 0x7a, 0x9a, 0x9e, 0x2e, 0x30, 0xdf, 0xca, 0x3d, 0x4b, 0xd9, 0xc9, 0x4c, 0x4f, 0x52, 0x4a, + 0xc2, 0xfe, 0xfd, 0xe1, 0x34, 0xcf, 0xc2, 0xa4, 0x0a, 0xdf, 0x67, 0xa5, 0x14, 0xce, 0x1f, 0xec, + 0x57, 0xc8, 0x79, 0x84, 0x4f, 0xa1, 0xcf, 0x59, 0x70, 0xba, 0x93, 0xf9, 0x21, 0x82, 0x01, 0xe8, + 0x4f, 0x56, 0xca, 0x3f, 0x5d, 0x85, 0xb7, 0xcc, 0x86, 0xe3, 0x9c, 0x96, 0x92, 0xcf, 0xcd, 0xf2, + 0xdb, 0x7e, 0x6e, 0xae, 0xc1, 0x48, 0x83, 0x3f, 0x45, 0x0a, 0xb3, 0x6a, 0x27, 0xdf, 0xde, 0x8c, + 0x95, 0x10, 0x6f, 0x98, 0x2d, 0xac, 0x48, 0xa0, 0x1f, 0xb5, 0xe0, 0x6c, 0xb2, 0xeb, 0x98, 0x30, + 0xb0, 0x88, 0x89, 0xc9, 0x05, 0x1a, 0x2b, 0xe2, 0xfb, 0x53, 0xfc, 0xbf, 0x81, 0x7c, 0xbf, 0x17, + 0x02, 0x2e, 0x6e, 0x0c, 0x55, 0x33, 0x24, 0x2a, 0x43, 0xa6, 0x16, 0xa9, 0x0f, 0xa9, 0xca, 0x0b, + 0x30, 0xd6, 0xf6, 0xbb, 0x5e, 0x24, 0xac, 0xbd, 0x84, 0xe5, 0x09, 0xb3, 0xb8, 0x58, 0xd3, 0xca, + 0xb1, 0x81, 0x95, 0x90, 0xc5, 0x8c, 0x3c, 0xb0, 0x2c, 0xe6, 0x0d, 0x18, 0xf3, 0x34, 0xf3, 0x64, + 0xc1, 0x0f, 0x5c, 0xc8, 0x8f, 0x67, 0xab, 0x1b, 0x33, 0xf3, 0x5e, 0xea, 0x25, 0xd8, 0xa0, 0x76, + 0xbc, 0x66, 0x60, 0x5f, 0xb6, 0x32, 0x98, 0x7a, 0x2e, 0x8a, 0xf9, 0xb0, 0x29, 0x8a, 0xb9, 0x90, + 0x14, 0xc5, 0xa4, 0x34, 0x08, 0x86, 0x14, 0xa6, 0xff, 0x74, 0x3d, 0xfd, 0xc6, 0xc4, 0xb4, 0x5b, + 0x70, 0xbe, 0xd7, 0xb5, 0xc4, 0xcc, 0xfe, 0x9a, 0x4a, 0x5f, 0x1c, 0x9b, 0xfd, 0x35, 0x57, 0xab, + 0x98, 0x41, 0xfa, 0x8d, 0xb6, 0x64, 0xff, 0x17, 0x0b, 0xca, 0x35, 0xbf, 0x79, 0x0c, 0x0f, 0xde, + 0x8f, 0x18, 0x0f, 0xde, 0x47, 0xb3, 0x2f, 0xc4, 0x66, 0xae, 0xfe, 0x63, 0x39, 0xa1, 0xff, 0x38, + 0x9b, 0x47, 0xa0, 0x58, 0xdb, 0xf1, 0xd3, 0x65, 0x18, 0xad, 0xf9, 0x4d, 0x65, 0x73, 0xff, 0x4f, + 0x1f, 0xc4, 0xe6, 0x3e, 0x37, 0xe9, 0x84, 0x46, 0x99, 0x59, 0x0b, 0x4a, 0x77, 0xe3, 0x6f, 0x31, + 0xd3, 0xfb, 0xdb, 0xc4, 0xdd, 0xde, 0x89, 0x48, 0x33, 0xf9, 0x39, 0xc7, 0x67, 0x7a, 0xff, 0xfb, + 0x25, 0x98, 0x4c, 0xb4, 0x8e, 0x5a, 0x30, 0xde, 0xd2, 0xa5, 0xeb, 0x62, 0x9d, 0x3e, 0x90, 0x60, + 0x5e, 0x98, 0x2e, 0x6b, 0x45, 0xd8, 0x24, 0x8e, 0xe6, 0x01, 0x94, 0xba, 0x59, 0x8a, 0x57, 0x19, + 0xd7, 0xaf, 0xf4, 0xd1, 0x21, 0xd6, 0x30, 0xd0, 0x8b, 0x30, 0x1a, 0xf9, 0x1d, 0xbf, 0xe5, 0x6f, + 0xef, 0x5f, 0x23, 0x32, 0xbe, 0x97, 0x32, 0x48, 0xdc, 0x88, 0x41, 0x58, 0xc7, 0x43, 0x77, 0x61, + 0x5a, 0x11, 0xa9, 0x1f, 0x81, 0xc6, 0x81, 0x49, 0x15, 0xd6, 0x93, 0x14, 0x71, 0xba, 0x11, 0xfb, + 0x67, 0xcb, 0x7c, 0x88, 0xbd, 0xc8, 0x7d, 0x77, 0x37, 0xbc, 0xb3, 0x77, 0xc3, 0xd7, 0x2d, 0x98, + 0xa2, 0xad, 0x33, 0x6b, 0x2b, 0x79, 0xcd, 0xab, 0x08, 0xda, 0x56, 0x41, 0x04, 0xed, 0x0b, 0xf4, + 0xd4, 0x6c, 0xfa, 0xdd, 0x48, 0xc8, 0xee, 0xb4, 0x63, 0x91, 0x96, 0x62, 0x01, 0x15, 0x78, 0x24, + 0x08, 0x84, 0x87, 0xa8, 0x8e, 0x47, 0x82, 0x00, 0x0b, 0xa8, 0x0c, 0xb0, 0x3d, 0x90, 0x1d, 0x60, + 0x9b, 0xc7, 0x49, 0x15, 0x76, 0x39, 0x82, 0xe1, 0xd2, 0xe2, 0xa4, 0x4a, 0x83, 0x9d, 0x18, 0xc7, + 0xfe, 0x6a, 0x19, 0xc6, 0x6a, 0x7e, 0x33, 0x56, 0x35, 0xbf, 0x60, 0xa8, 0x9a, 0xcf, 0x27, 0x54, + 0xcd, 0x53, 0x3a, 0xee, 0xbb, 0x8a, 0xe5, 0x6f, 0x96, 0x62, 0xf9, 0x1f, 0x59, 0x6c, 0xd6, 0xaa, + 0xeb, 0x75, 0x6e, 0xbc, 0x87, 0x2e, 0xc3, 0x28, 0x3b, 0x60, 0x98, 0x4b, 0xb2, 0xd4, 0xbf, 0xb2, + 0xc4, 0x51, 0xeb, 0x71, 0x31, 0xd6, 0x71, 0xd0, 0x45, 0x18, 0x09, 0x89, 0x13, 0x34, 0x76, 0xd4, + 0xe9, 0x2a, 0x94, 0xa5, 0xbc, 0x0c, 0x2b, 0x28, 0x7a, 0x3d, 0x0e, 0xd1, 0x59, 0xce, 0x77, 0x71, + 0xd4, 0xfb, 0xc3, 0xb7, 0x48, 0x7e, 0x5c, 0x4e, 0xfb, 0x36, 0xa0, 0x34, 0x7e, 0x1f, 0xb1, 0xe9, + 0xe6, 0xcc, 0xd8, 0x74, 0x95, 0x54, 0x5c, 0xba, 0x3f, 0xb7, 0x60, 0xa2, 0xe6, 0x37, 0xe9, 0xd6, + 0xfd, 0x76, 0xda, 0xa7, 0x7a, 0x7c, 0xe2, 0xa1, 0x82, 0xf8, 0xc4, 0x4f, 0xc0, 0x60, 0xcd, 0x6f, + 0xae, 0xd6, 0x8a, 0xe2, 0x0b, 0xd8, 0x7f, 0xdd, 0x82, 0xe1, 0x9a, 0xdf, 0x3c, 0x06, 0xb5, 0xc0, + 0x87, 0x4d, 0xb5, 0xc0, 0x23, 0x39, 0xeb, 0x26, 0x47, 0x13, 0xf0, 0x57, 0x07, 0x60, 0x9c, 0xf6, + 0xd3, 0xdf, 0x96, 0x53, 0x69, 0x0c, 0x9b, 0xd5, 0xc7, 0xb0, 0x51, 0x2e, 0xdc, 0x6f, 0xb5, 0xfc, + 0x3b, 0xc9, 0x69, 0x5d, 0x61, 0xa5, 0x58, 0x40, 0xd1, 0x33, 0x30, 0xd2, 0x09, 0xc8, 0x9e, 0xeb, + 0x0b, 0xf6, 0x56, 0x53, 0xb2, 0xd4, 0x44, 0x39, 0x56, 0x18, 0xf4, 0x59, 0x18, 0xba, 0x1e, 0xbd, + 0xca, 0x1b, 0xbe, 0xd7, 0xe4, 0x92, 0xf3, 0xb2, 0x48, 0xa2, 0xa1, 0x95, 0x63, 0x03, 0x0b, 0xdd, + 0x86, 0x0a, 0xfb, 0xcf, 0x8e, 0x9d, 0xc3, 0xa7, 0x63, 0x15, 0xe9, 0xf9, 0x04, 0x01, 0x1c, 0xd3, + 0x42, 0xcf, 0x01, 0x44, 0x32, 0x10, 0x7d, 0x28, 0xa2, 0xad, 0xa9, 0xa7, 0x80, 0x0a, 0x51, 0x1f, + 0x62, 0x0d, 0x0b, 0x3d, 0x0d, 0x95, 0xc8, 0x71, 0x5b, 0xd7, 0x5d, 0x8f, 0x84, 0x4c, 0x22, 0x5e, + 0x96, 0x59, 0xf2, 0x44, 0x21, 0x8e, 0xe1, 0x94, 0x15, 0x63, 0x91, 0x38, 0x78, 0x32, 0xe7, 0x11, + 0x86, 0xcd, 0x58, 0xb1, 0xeb, 0xaa, 0x14, 0x6b, 0x18, 0x68, 0x07, 0x1e, 0x73, 0x3d, 0x96, 0x70, + 0x82, 0xd4, 0x77, 0xdd, 0xce, 0xc6, 0xf5, 0xfa, 0x2d, 0x12, 0xb8, 0x5b, 0xfb, 0x8b, 0x4e, 0x63, + 0x97, 0x78, 0x32, 0xd1, 0xe6, 0x7b, 0x45, 0x17, 0x1f, 0x5b, 0x2d, 0xc0, 0xc5, 0x85, 0x94, 0xec, + 0xe7, 0xd9, 0x7a, 0xbf, 0x51, 0x47, 0xef, 0x37, 0x8e, 0x8e, 0xd3, 0xfa, 0xd1, 0x71, 0xff, 0x60, + 0x6e, 0xe8, 0x46, 0x5d, 0x0b, 0x24, 0xf1, 0x12, 0x9c, 0xaa, 0xf9, 0xcd, 0x9a, 0x1f, 0x44, 0x2b, + 0x7e, 0x70, 0xc7, 0x09, 0x9a, 0x72, 0x79, 0xcd, 0xc9, 0x50, 0x1a, 0xf4, 0xfc, 0x1c, 0xe4, 0xa7, + 0x8b, 0x11, 0x26, 0xe3, 0x79, 0xc6, 0xb1, 0x1d, 0xd2, 0x01, 0xac, 0xc1, 0x78, 0x07, 0x95, 0xb2, + 0xe5, 0x8a, 0x13, 0x11, 0x74, 0x83, 0xa5, 0xa2, 0x8e, 0xaf, 0x51, 0x51, 0xfd, 0x29, 0x2d, 0x15, + 0x75, 0x0c, 0xcc, 0xbc, 0x77, 0xcd, 0xfa, 0xf6, 0x7f, 0x1d, 0x64, 0x27, 0x6a, 0x22, 0xed, 0x07, + 0xfa, 0x14, 0x4c, 0x84, 0xe4, 0xba, 0xeb, 0x75, 0xef, 0x4a, 0x11, 0x46, 0x81, 0x0b, 0x5f, 0x7d, + 0x59, 0xc7, 0xe4, 0x82, 0x50, 0xb3, 0x0c, 0x27, 0xa8, 0xa1, 0x36, 0x4c, 0xdc, 0x71, 0xbd, 0xa6, + 0x7f, 0x27, 0x94, 0xf4, 0x47, 0xf2, 0xe5, 0xa1, 0xb7, 0x39, 0x66, 0xa2, 0x8f, 0x46, 0x73, 0xb7, + 0x0d, 0x62, 0x38, 0x41, 0x9c, 0xae, 0xda, 0xa0, 0xeb, 0x2d, 0x84, 0x37, 0x43, 0x12, 0x88, 0xa4, + 0xe2, 0x6c, 0xd5, 0x62, 0x59, 0x88, 0x63, 0x38, 0x5d, 0xb5, 0xec, 0xcf, 0x95, 0xc0, 0xef, 0xf2, + 0x1c, 0x13, 0x62, 0xd5, 0x62, 0x55, 0x8a, 0x35, 0x0c, 0xba, 0xab, 0xd9, 0xbf, 0x75, 0xdf, 0xc3, + 0xbe, 0x1f, 0xc9, 0x73, 0x80, 0xe9, 0xf4, 0xb5, 0x72, 0x6c, 0x60, 0xa1, 0x15, 0x40, 0x61, 0xb7, + 0xd3, 0x69, 0x31, 0xdb, 0x20, 0xa7, 0xc5, 0x48, 0x71, 0x7b, 0x89, 0x32, 0x0f, 0xbd, 0x5b, 0x4f, + 0x41, 0x71, 0x46, 0x0d, 0x7a, 0xc0, 0x6f, 0x89, 0xae, 0x0e, 0xb2, 0xae, 0x72, 0xdd, 0x49, 0x9d, + 0xf7, 0x53, 0xc2, 0xd0, 0x32, 0x0c, 0x87, 0xfb, 0x61, 0x23, 0x12, 0x91, 0x12, 0x73, 0x32, 0x3b, + 0xd5, 0x19, 0x8a, 0x96, 0x58, 0x90, 0x57, 0xc1, 0xb2, 0x2e, 0x6a, 0xc0, 0x09, 0x41, 0x71, 0x69, + 0xc7, 0xf1, 0x54, 0x9e, 0x1c, 0x6e, 0x22, 0x7d, 0xf9, 0xde, 0xc1, 0xdc, 0x09, 0xd1, 0xb2, 0x0e, + 0xbe, 0x7f, 0x30, 0x77, 0xba, 0xe6, 0x37, 0x33, 0x20, 0x38, 0x8b, 0x1a, 0x5f, 0x7c, 0x8d, 0x86, + 0xdf, 0xee, 0xd4, 0x02, 0x7f, 0xcb, 0x6d, 0x91, 0x22, 0xfd, 0x53, 0xdd, 0xc0, 0x14, 0x8b, 0xcf, + 0x28, 0xc3, 0x09, 0x6a, 0xf6, 0x77, 0x33, 0x26, 0x88, 0xe5, 0xd1, 0x8e, 0xba, 0x01, 0x41, 0x6d, + 0x18, 0xef, 0xb0, 0x6d, 0x22, 0x32, 0x3f, 0x88, 0xb5, 0xfe, 0x42, 0x9f, 0x72, 0x94, 0x3b, 0xf4, + 0xee, 0x30, 0x6d, 0x8c, 0x6a, 0x3a, 0x39, 0x6c, 0x52, 0xb7, 0x7f, 0xf3, 0x11, 0x76, 0x8d, 0xd6, + 0xb9, 0x70, 0x64, 0x58, 0x78, 0x64, 0x88, 0xf7, 0xd8, 0x6c, 0xbe, 0x94, 0x2e, 0x9e, 0x16, 0xe1, + 0xd5, 0x81, 0x65, 0x5d, 0xf4, 0x49, 0x98, 0xa0, 0xcf, 0x1b, 0x75, 0x95, 0x85, 0x33, 0x27, 0xf3, + 0x23, 0x67, 0x28, 0x2c, 0x3d, 0x2b, 0x8c, 0x5e, 0x19, 0x27, 0x88, 0xa1, 0xd7, 0x99, 0x4d, 0x8f, + 0x24, 0x5d, 0xea, 0x87, 0xb4, 0x6e, 0xbe, 0x23, 0xc9, 0x6a, 0x44, 0x50, 0x17, 0x4e, 0xa4, 0x73, + 0xc8, 0x85, 0x33, 0x76, 0x3e, 0x9f, 0x98, 0x4e, 0x03, 0x17, 0xa7, 0xef, 0x48, 0xc3, 0x42, 0x9c, + 0x45, 0x1f, 0x5d, 0x87, 0x71, 0x91, 0x4c, 0x5a, 0xac, 0xdc, 0xb2, 0x21, 0x3c, 0x1c, 0xc7, 0x3a, + 0xf0, 0x7e, 0xb2, 0x00, 0x9b, 0x95, 0xd1, 0x36, 0x9c, 0xd5, 0x92, 0x3b, 0x5d, 0x09, 0x1c, 0x66, + 0x01, 0xe0, 0xb2, 0xe3, 0x54, 0xbb, 0xe0, 0x1f, 0xbf, 0x77, 0x30, 0x77, 0x76, 0xa3, 0x08, 0x11, + 0x17, 0xd3, 0x41, 0x37, 0xe0, 0x14, 0xf7, 0xfb, 0xae, 0x12, 0xa7, 0xd9, 0x72, 0x3d, 0xc5, 0x41, + 0xf0, 0x2d, 0x7f, 0xe6, 0xde, 0xc1, 0xdc, 0xa9, 0x85, 0x2c, 0x04, 0x9c, 0x5d, 0x0f, 0x7d, 0x18, + 0x2a, 0x4d, 0x2f, 0x14, 0x63, 0x30, 0x64, 0xe4, 0xcf, 0xaa, 0x54, 0xd7, 0xeb, 0xea, 0xfb, 0xe3, + 0x3f, 0x38, 0xae, 0x80, 0xb6, 0xb9, 0x80, 0x59, 0x89, 0x3d, 0x86, 0x53, 0x71, 0xaf, 0x92, 0x92, + 0x41, 0xc3, 0xf3, 0x93, 0x6b, 0x56, 0x94, 0x43, 0x84, 0xe1, 0x14, 0x6a, 0x10, 0x46, 0xaf, 0x01, + 0xa2, 0xcf, 0x0e, 0xb7, 0x41, 0x16, 0x1a, 0x2c, 0xad, 0x08, 0x93, 0xc7, 0x8f, 0x98, 0xbe, 0x88, + 0xf5, 0x14, 0x06, 0xce, 0xa8, 0x85, 0xae, 0xd2, 0x53, 0x45, 0x2f, 0x15, 0xa7, 0x96, 0xca, 0x76, + 0x58, 0x25, 0x9d, 0x80, 0x30, 0x8b, 0x26, 0x93, 0x22, 0x4e, 0xd4, 0x43, 0x4d, 0x78, 0xcc, 0xe9, + 0x46, 0x3e, 0x93, 0xdd, 0x9b, 0xa8, 0x1b, 0xfe, 0x2e, 0xf1, 0x98, 0xda, 0x6c, 0x64, 0xf1, 0x3c, + 0x65, 0x51, 0x16, 0x0a, 0xf0, 0x70, 0x21, 0x15, 0xca, 0x5a, 0xaa, 0xf4, 0xc6, 0x60, 0x46, 0xf3, + 0xca, 0x48, 0x71, 0xfc, 0x22, 0x8c, 0xee, 0xf8, 0x61, 0xb4, 0x4e, 0xa2, 0x3b, 0x7e, 0xb0, 0x2b, + 0xa2, 0xd2, 0xc6, 0x31, 0xbe, 0x63, 0x10, 0xd6, 0xf1, 0xe8, 0xdb, 0x91, 0x19, 0x75, 0xac, 0x56, + 0x99, 0x3e, 0x7d, 0x24, 0x3e, 0x63, 0xae, 0xf2, 0x62, 0x2c, 0xe1, 0x12, 0x75, 0xb5, 0xb6, 0xc4, + 0x74, 0xe3, 0x09, 0xd4, 0xd5, 0xda, 0x12, 0x96, 0x70, 0xba, 0x5c, 0xc3, 0x1d, 0x27, 0x20, 0xb5, + 0xc0, 0x6f, 0x90, 0x50, 0x8b, 0x2c, 0xff, 0x28, 0x8f, 0xb9, 0x4b, 0x97, 0x6b, 0x3d, 0x0b, 0x01, + 0x67, 0xd7, 0x43, 0x24, 0x9d, 0xd8, 0x6c, 0x22, 0x5f, 0xa9, 0x91, 0xe6, 0x67, 0xfa, 0xcc, 0x6d, + 0xe6, 0xc1, 0x94, 0x4a, 0xa9, 0xc6, 0xa3, 0xec, 0x86, 0x33, 0x93, 0x6c, 0x6d, 0xf7, 0x1f, 0xa2, + 0x57, 0xa9, 0x89, 0x56, 0x13, 0x94, 0x70, 0x8a, 0xb6, 0x11, 0xb0, 0x6d, 0xaa, 0x67, 0xc0, 0xb6, + 0x4b, 0x50, 0x09, 0xbb, 0x9b, 0x4d, 0xbf, 0xed, 0xb8, 0x1e, 0xd3, 0x8d, 0x6b, 0x8f, 0x98, 0xba, + 0x04, 0xe0, 0x18, 0x07, 0xad, 0xc0, 0x88, 0x23, 0x75, 0x40, 0x28, 0x3f, 0x44, 0x8f, 0xd2, 0xfc, + 0xf0, 0xa8, 0x15, 0x52, 0xeb, 0xa3, 0xea, 0xa2, 0x57, 0x60, 0x5c, 0xf8, 0x2d, 0x8b, 0x6c, 0x9e, + 0x27, 0x4c, 0xe7, 0xb2, 0xba, 0x0e, 0xc4, 0x26, 0x2e, 0xba, 0x09, 0xa3, 0x91, 0xdf, 0x62, 0x1e, + 0x52, 0x94, 0xcd, 0x3b, 0x9d, 0x1f, 0x6c, 0x6e, 0x43, 0xa1, 0xe9, 0xe2, 0x57, 0x55, 0x15, 0xeb, + 0x74, 0xd0, 0x06, 0x5f, 0xef, 0x2c, 0x8e, 0x3c, 0x09, 0x67, 0x1e, 0xc9, 0xbf, 0x93, 0x54, 0xb8, + 0x79, 0x73, 0x3b, 0x88, 0x9a, 0x58, 0x27, 0x83, 0xae, 0xc0, 0x74, 0x27, 0x70, 0x7d, 0xb6, 0x26, + 0x94, 0xfa, 0x6f, 0xc6, 0x4c, 0xef, 0x54, 0x4b, 0x22, 0xe0, 0x74, 0x1d, 0xe6, 0x76, 0x2e, 0x0a, + 0x67, 0xce, 0xf0, 0x84, 0xdf, 0xfc, 0x4d, 0xc8, 0xcb, 0xb0, 0x82, 0xa2, 0x35, 0x76, 0x12, 0x73, + 0x71, 0xc6, 0xcc, 0x6c, 0x7e, 0x54, 0x20, 0x5d, 0xec, 0xc1, 0x99, 0x57, 0xf5, 0x17, 0xc7, 0x14, + 0x50, 0x53, 0xcb, 0x0c, 0x49, 0x5f, 0x0c, 0xe1, 0xcc, 0x63, 0x05, 0x96, 0x75, 0x89, 0xe7, 0x45, + 0xcc, 0x10, 0x18, 0xc5, 0x21, 0x4e, 0xd0, 0x44, 0x1f, 0x85, 0x29, 0x11, 0xcb, 0x30, 0x1e, 0xa6, + 0xb3, 0xb1, 0xdd, 0x39, 0x4e, 0xc0, 0x70, 0x0a, 0x9b, 0x67, 0x9e, 0x70, 0x36, 0x5b, 0x44, 0x1c, + 0x7d, 0xd7, 0x5d, 0x6f, 0x37, 0x9c, 0x39, 0xc7, 0xce, 0x07, 0x91, 0x79, 0x22, 0x09, 0xc5, 0x19, + 0x35, 0xd0, 0x06, 0x4c, 0x75, 0x02, 0x42, 0xda, 0x8c, 0xd1, 0x17, 0xf7, 0xd9, 0x1c, 0x8f, 0xba, + 0x40, 0x7b, 0x52, 0x4b, 0xc0, 0xee, 0x67, 0x94, 0xe1, 0x14, 0x05, 0x74, 0x07, 0x46, 0xfc, 0x3d, + 0x12, 0xec, 0x10, 0xa7, 0x39, 0x73, 0xbe, 0xc0, 0x0f, 0x42, 0x5c, 0x6e, 0x37, 0x04, 0x6e, 0xc2, + 0x64, 0x40, 0x16, 0xf7, 0x36, 0x19, 0x90, 0x8d, 0xa1, 0x1f, 0xb3, 0xe0, 0x8c, 0xd4, 0x32, 0xd4, + 0x3b, 0x74, 0xd4, 0x97, 0x7c, 0x2f, 0x8c, 0x02, 0x1e, 0x27, 0xe0, 0xf1, 0x7c, 0xdf, 0xf9, 0x8d, + 0x9c, 0x4a, 0x4a, 0xa2, 0x7a, 0x26, 0x0f, 0x23, 0xc4, 0xf9, 0x2d, 0xa2, 0x25, 0x98, 0x0e, 0x49, + 0x24, 0x0f, 0xa3, 0x85, 0x70, 0xe5, 0xf5, 0xea, 0xfa, 0xcc, 0x13, 0x3c, 0xc8, 0x01, 0xdd, 0x0c, + 0xf5, 0x24, 0x10, 0xa7, 0xf1, 0xd1, 0x65, 0x28, 0xf9, 0xe1, 0xcc, 0x7b, 0x0b, 0x92, 0x89, 0xd2, + 0xa7, 0x38, 0x37, 0x1d, 0xbb, 0x51, 0xc7, 0x25, 0x3f, 0x9c, 0xfd, 0x4e, 0x98, 0x4e, 0x71, 0x0c, + 0x87, 0x49, 0xc2, 0x33, 0xbb, 0x0b, 0xe3, 0xc6, 0xac, 0x3c, 0x54, 0x2d, 0xf5, 0xbf, 0x18, 0x86, + 0x8a, 0xd2, 0x60, 0xa2, 0x4b, 0xa6, 0x62, 0xfa, 0x4c, 0x52, 0x31, 0x3d, 0x52, 0xf3, 0x9b, 0x86, + 0x2e, 0x7a, 0x23, 0x23, 0x1a, 0x5c, 0xde, 0x19, 0xd0, 0xbf, 0x81, 0xbc, 0x26, 0x16, 0x2e, 0xf7, + 0xad, 0xe1, 0x1e, 0x28, 0x94, 0x34, 0x5f, 0x81, 0x69, 0xcf, 0x67, 0x6c, 0x2a, 0x69, 0x4a, 0x1e, + 0x84, 0xb1, 0x1a, 0x15, 0x3d, 0xbc, 0x4a, 0x02, 0x01, 0xa7, 0xeb, 0xd0, 0x06, 0x39, 0xaf, 0x90, + 0x14, 0x6d, 0x73, 0x56, 0x02, 0x0b, 0x28, 0x7a, 0x02, 0x06, 0x3b, 0x7e, 0x73, 0xb5, 0x26, 0x58, + 0x54, 0x2d, 0x06, 0x69, 0x73, 0xb5, 0x86, 0x39, 0x0c, 0x2d, 0xc0, 0x10, 0xfb, 0x11, 0xce, 0x8c, + 0xe5, 0xc7, 0xd1, 0x60, 0x35, 0xb4, 0x14, 0x47, 0xac, 0x02, 0x16, 0x15, 0x99, 0x88, 0x8d, 0xf2, + 0xf5, 0x4c, 0xc4, 0x36, 0xfc, 0x80, 0x22, 0x36, 0x49, 0x00, 0xc7, 0xb4, 0xd0, 0x5d, 0x38, 0x65, + 0xbc, 0xa5, 0xf8, 0x12, 0x21, 0xa1, 0xf0, 0xe5, 0x7f, 0xa2, 0xf0, 0x11, 0x25, 0x34, 0xe2, 0x67, + 0x45, 0xa7, 0x4f, 0xad, 0x66, 0x51, 0xc2, 0xd9, 0x0d, 0xa0, 0x16, 0x4c, 0x37, 0x52, 0xad, 0x8e, + 0xf4, 0xdf, 0xaa, 0x9a, 0xd0, 0x74, 0x8b, 0x69, 0xc2, 0xe8, 0x15, 0x18, 0x79, 0xd3, 0x0f, 0xd9, + 0xf1, 0x2e, 0xd8, 0x6a, 0xe9, 0x08, 0x3e, 0xf2, 0xfa, 0x8d, 0x3a, 0x2b, 0xbf, 0x7f, 0x30, 0x37, + 0x5a, 0xf3, 0x9b, 0xf2, 0x2f, 0x56, 0x15, 0xd0, 0x0f, 0x5a, 0x30, 0x9b, 0x7e, 0xac, 0xa9, 0x4e, + 0x8f, 0xf7, 0xdf, 0x69, 0x5b, 0x34, 0x3a, 0xbb, 0x9c, 0x4b, 0x0e, 0x17, 0x34, 0x65, 0xff, 0xb2, + 0xc5, 0x04, 0x75, 0x42, 0xd3, 0x44, 0xc2, 0x6e, 0xeb, 0x38, 0x32, 0xbb, 0x2e, 0x1b, 0x4a, 0xb0, + 0x07, 0xb6, 0x90, 0xf8, 0x27, 0x16, 0xb3, 0x90, 0x38, 0x46, 0x57, 0x88, 0xd7, 0x61, 0x24, 0x92, + 0x19, 0x77, 0x0b, 0x92, 0xd1, 0x6a, 0x9d, 0x62, 0x56, 0x22, 0x8a, 0xc9, 0x55, 0xc9, 0x75, 0x15, + 0x19, 0xfb, 0xef, 0xf3, 0x19, 0x90, 0x90, 0x63, 0xd0, 0x35, 0x54, 0x4d, 0x5d, 0xc3, 0x5c, 0x8f, + 0x2f, 0xc8, 0xd1, 0x39, 0xfc, 0x3d, 0xb3, 0xdf, 0x4c, 0xb8, 0xf3, 0x4e, 0x37, 0xcd, 0xb1, 0x3f, + 0x6f, 0x01, 0xc4, 0x21, 0x9e, 0x99, 0x48, 0xda, 0x0f, 0x64, 0x5a, 0xcf, 0xac, 0x04, 0x56, 0x2f, + 0x51, 0xb6, 0xd6, 0x8f, 0xfc, 0x86, 0xdf, 0x12, 0x9a, 0xb4, 0xc7, 0x62, 0x75, 0x07, 0x2f, 0xbf, + 0xaf, 0xfd, 0xc6, 0x0a, 0x1b, 0xcd, 0xc9, 0x80, 0x72, 0xe5, 0x58, 0x01, 0x67, 0x04, 0x93, 0xfb, + 0xa2, 0x05, 0x27, 0xb3, 0xec, 0x6a, 0xe9, 0x23, 0x89, 0x8b, 0xb9, 0x94, 0xd9, 0x94, 0x9a, 0xcd, + 0x5b, 0xa2, 0x1c, 0x2b, 0x8c, 0xbe, 0x93, 0xd5, 0x1d, 0x2e, 0xb6, 0xf2, 0x0d, 0x18, 0xaf, 0x05, + 0x44, 0xbb, 0x5c, 0x5f, 0xe5, 0x41, 0x0a, 0x78, 0x7f, 0x9e, 0x39, 0x74, 0x80, 0x02, 0xfb, 0x2b, + 0x25, 0x38, 0xc9, 0xad, 0x0f, 0x16, 0xf6, 0x7c, 0xb7, 0x59, 0xf3, 0x9b, 0xc2, 0x7b, 0xea, 0x13, + 0x30, 0xd6, 0xd1, 0x64, 0x93, 0x45, 0x71, 0x42, 0x75, 0x19, 0x66, 0x2c, 0x4d, 0xd1, 0x4b, 0xb1, + 0x41, 0x0b, 0x35, 0x61, 0x8c, 0xec, 0xb9, 0x0d, 0xa5, 0xc2, 0x2e, 0x1d, 0xfa, 0xa2, 0x53, 0xad, + 0x2c, 0x6b, 0x74, 0xb0, 0x41, 0xf5, 0x21, 0xa4, 0x90, 0xb6, 0xbf, 0x64, 0xc1, 0x23, 0x39, 0x51, + 0x45, 0x69, 0x73, 0x77, 0x98, 0x9d, 0x87, 0x58, 0xb6, 0xaa, 0x39, 0x6e, 0xfd, 0x81, 0x05, 0x14, + 0x7d, 0x0c, 0x80, 0x5b, 0x6f, 0xd0, 0x57, 0x7a, 0xaf, 0xf0, 0x8b, 0x46, 0xe4, 0x38, 0x2d, 0x08, + 0x98, 0xac, 0x8f, 0x35, 0x5a, 0xf6, 0x17, 0x07, 0x60, 0x90, 0xa7, 0xbb, 0xaf, 0xc1, 0xf0, 0x0e, + 0xcf, 0x13, 0x53, 0x38, 0x6f, 0x14, 0x57, 0xa6, 0x9e, 0x89, 0xe7, 0x4d, 0x2b, 0xc5, 0x92, 0x0c, + 0x5a, 0x83, 0x13, 0x3c, 0x5d, 0x4f, 0xab, 0x4a, 0x5a, 0xce, 0xbe, 0x14, 0xfb, 0xf1, 0x24, 0xb0, + 0x4a, 0xfc, 0xb9, 0x9a, 0x46, 0xc1, 0x59, 0xf5, 0xd0, 0xab, 0x30, 0x41, 0x9f, 0x61, 0x7e, 0x37, + 0x92, 0x94, 0x78, 0xa2, 0x1e, 0xf5, 0xee, 0xdb, 0x30, 0xa0, 0x38, 0x81, 0x8d, 0x5e, 0x81, 0xf1, + 0x4e, 0x4a, 0xc0, 0x39, 0x18, 0x4b, 0x02, 0x4c, 0xa1, 0xa6, 0x89, 0xcb, 0x4c, 0x6b, 0xbb, 0xcc, + 0x90, 0x78, 0x63, 0x27, 0x20, 0xe1, 0x8e, 0xdf, 0x6a, 0x32, 0xf6, 0x6f, 0x50, 0x33, 0xad, 0x4d, + 0xc0, 0x71, 0xaa, 0x06, 0xa5, 0xb2, 0xe5, 0xb8, 0xad, 0x6e, 0x40, 0x62, 0x2a, 0x43, 0x26, 0x95, + 0x95, 0x04, 0x1c, 0xa7, 0x6a, 0xf4, 0x96, 0xdc, 0x0e, 0x1f, 0x8d, 0xe4, 0xd6, 0xfe, 0x4f, 0x16, + 0x18, 0x53, 0xfb, 0x6d, 0x9c, 0x40, 0xe8, 0x4b, 0x16, 0x9c, 0xaa, 0x05, 0x3e, 0xbd, 0xa6, 0x64, + 0x20, 0x2a, 0x65, 0x83, 0x3e, 0x2c, 0xfd, 0x73, 0x0b, 0x42, 0x36, 0x0a, 0x2b, 0x5d, 0x4e, 0xc1, + 0x30, 0x03, 0xa9, 0x0b, 0x6f, 0x79, 0x49, 0x05, 0x5d, 0x86, 0x51, 0x91, 0xd7, 0x85, 0x99, 0x4a, + 0xf3, 0xed, 0xc0, 0xcc, 0x56, 0xaa, 0x71, 0x31, 0xd6, 0x71, 0xec, 0x1f, 0x2a, 0xc1, 0x89, 0x0c, + 0x5f, 0x17, 0x7e, 0x11, 0x6c, 0xbb, 0x61, 0xa4, 0x92, 0x87, 0x6a, 0x17, 0x01, 0x2f, 0xc7, 0x0a, + 0x83, 0x9e, 0x36, 0xfc, 0xaa, 0x49, 0x5e, 0x2f, 0xc2, 0x96, 0x5c, 0x40, 0x0f, 0x99, 0x86, 0xf3, + 0x3c, 0x0c, 0x74, 0x43, 0x22, 0x83, 0xad, 0xaa, 0x8b, 0x97, 0x29, 0x26, 0x19, 0x84, 0x3e, 0x84, + 0xb6, 0x95, 0x8e, 0x4f, 0x7b, 0x08, 0x71, 0x2d, 0x1f, 0x87, 0xd1, 0xce, 0x45, 0xc4, 0x73, 0xbc, + 0x48, 0x3c, 0x97, 0xe2, 0xa8, 0x81, 0xac, 0x14, 0x0b, 0xa8, 0xfd, 0x85, 0x32, 0x9c, 0xc9, 0xf5, + 0x7e, 0xa3, 0x5d, 0x6f, 0xfb, 0x9e, 0x1b, 0xf9, 0xca, 0x1e, 0x88, 0x47, 0x0a, 0x24, 0x9d, 0x9d, + 0x35, 0x51, 0x8e, 0x15, 0x06, 0xba, 0x00, 0x83, 0x4c, 0xac, 0x99, 0x4a, 0xa3, 0xba, 0x58, 0xe5, + 0xa1, 0xa3, 0x38, 0xb8, 0xef, 0x14, 0xd5, 0x4f, 0x50, 0x1e, 0xc4, 0x6f, 0x25, 0xaf, 0x04, 0xda, + 0x5d, 0xdf, 0x6f, 0x61, 0x06, 0x44, 0xef, 0x13, 0xe3, 0x95, 0x30, 0x80, 0xc1, 0x4e, 0xd3, 0x0f, + 0xb5, 0x41, 0x7b, 0x0a, 0x86, 0x77, 0xc9, 0x7e, 0xe0, 0x7a, 0xdb, 0x49, 0xc3, 0xa8, 0x6b, 0xbc, + 0x18, 0x4b, 0xb8, 0x99, 0xf7, 0x6f, 0xf8, 0xa8, 0x73, 0x4b, 0x8f, 0xf4, 0x64, 0x30, 0x7e, 0xa4, + 0x0c, 0x93, 0x78, 0xb1, 0xfa, 0xee, 0x44, 0xdc, 0x4c, 0x4f, 0xc4, 0x51, 0xe7, 0x96, 0xee, 0x3d, + 0x1b, 0xbf, 0x60, 0xc1, 0x24, 0xcb, 0x2e, 0x23, 0x7c, 0xdc, 0x5d, 0xdf, 0x3b, 0x06, 0x66, 0xfe, + 0x09, 0x18, 0x0c, 0x68, 0xa3, 0xc9, 0xfc, 0xa9, 0xac, 0x27, 0x98, 0xc3, 0xd0, 0x63, 0x30, 0xc0, + 0xba, 0x40, 0x27, 0x6f, 0x8c, 0x5f, 0x0f, 0x55, 0x27, 0x72, 0x30, 0x2b, 0x65, 0x81, 0x93, 0x30, + 0xe9, 0xb4, 0x5c, 0xde, 0xe9, 0x58, 0xe9, 0xfc, 0xce, 0xf0, 0x8b, 0xcf, 0xec, 0xda, 0xdb, 0x0b, + 0x9c, 0x94, 0x4d, 0xb2, 0xf8, 0xa1, 0xfc, 0xc7, 0x25, 0x38, 0x97, 0x59, 0xaf, 0xef, 0xc0, 0x49, + 0xc5, 0xb5, 0x1f, 0x66, 0xfe, 0x90, 0xf2, 0x31, 0x9a, 0x9d, 0x0e, 0xf4, 0xcb, 0xbf, 0x0f, 0xf6, + 0x11, 0xcf, 0x28, 0x73, 0xc8, 0xde, 0x21, 0xf1, 0x8c, 0x32, 0xfb, 0x96, 0xf3, 0xd0, 0xff, 0x8b, + 0x52, 0xce, 0xb7, 0xb0, 0x27, 0xff, 0x45, 0x7a, 0xce, 0x30, 0x60, 0x28, 0x9f, 0xd1, 0xfc, 0x8c, + 0xe1, 0x65, 0x58, 0x41, 0xd1, 0x02, 0x4c, 0xb6, 0x5d, 0x8f, 0x1e, 0x3e, 0xfb, 0x26, 0x33, 0xad, + 0xc2, 0xcd, 0xad, 0x99, 0x60, 0x9c, 0xc4, 0x47, 0xae, 0x16, 0xeb, 0x88, 0x7f, 0xdd, 0x2b, 0x87, + 0xda, 0x75, 0xf3, 0xa6, 0x42, 0x5e, 0x8d, 0x62, 0x46, 0xdc, 0xa3, 0x35, 0x4d, 0xd2, 0x53, 0xee, + 0x5f, 0xd2, 0x33, 0x96, 0x2d, 0xe5, 0x99, 0x7d, 0x05, 0xc6, 0x1f, 0x58, 0xb4, 0x6f, 0x7f, 0xbd, + 0x0c, 0x8f, 0x16, 0x6c, 0x7b, 0x7e, 0xd6, 0x1b, 0x73, 0xa0, 0x9d, 0xf5, 0xa9, 0x79, 0xa8, 0xc1, + 0xc9, 0xad, 0x6e, 0xab, 0xb5, 0xcf, 0xbc, 0x31, 0x48, 0x53, 0x62, 0x08, 0x9e, 0x52, 0x8a, 0x37, + 0x4e, 0xae, 0x64, 0xe0, 0xe0, 0xcc, 0x9a, 0xf4, 0x91, 0x44, 0x6f, 0x92, 0x7d, 0x45, 0x2a, 0xf1, + 0x48, 0xc2, 0x3a, 0x10, 0x9b, 0xb8, 0xe8, 0x0a, 0x4c, 0x3b, 0x7b, 0x8e, 0xcb, 0x03, 0x46, 0x4b, + 0x02, 0xfc, 0x95, 0xa4, 0x24, 0xb2, 0x0b, 0x49, 0x04, 0x9c, 0xae, 0x83, 0x5e, 0x03, 0xe4, 0x6f, + 0x32, 0x9b, 0xed, 0xe6, 0x15, 0xe2, 0x09, 0xbd, 0x29, 0x9b, 0xbb, 0x72, 0x7c, 0x24, 0xdc, 0x48, + 0x61, 0xe0, 0x8c, 0x5a, 0x89, 0x98, 0x3e, 0x43, 0xf9, 0x31, 0x7d, 0x8a, 0xcf, 0xc5, 0x9e, 0xa9, + 0x6b, 0xfe, 0xbd, 0x45, 0xaf, 0x2f, 0xce, 0xe4, 0x9b, 0x21, 0x30, 0x5f, 0x61, 0x76, 0x8f, 0x5c, + 0x5a, 0xab, 0x45, 0x40, 0x39, 0xa5, 0xd9, 0x3d, 0xc6, 0x40, 0x6c, 0xe2, 0xf2, 0x05, 0x11, 0xc6, + 0x8e, 0xb7, 0x06, 0x8b, 0x2f, 0xe2, 0x74, 0x29, 0x0c, 0xf4, 0x71, 0x18, 0x6e, 0xba, 0x7b, 0x6e, + 0x28, 0x64, 0x55, 0x87, 0x56, 0x0c, 0xc5, 0xe7, 0x60, 0x95, 0x93, 0xc1, 0x92, 0x9e, 0xfd, 0x23, + 0x25, 0x18, 0x97, 0x2d, 0xbe, 0xde, 0xf5, 0x23, 0xe7, 0x18, 0xae, 0xe5, 0x2b, 0xc6, 0xb5, 0xfc, + 0xbe, 0xa2, 0x60, 0x65, 0xac, 0x4b, 0xb9, 0xd7, 0xf1, 0x8d, 0xc4, 0x75, 0xfc, 0x64, 0x6f, 0x52, + 0xc5, 0xd7, 0xf0, 0x3f, 0xb0, 0x60, 0xda, 0xc0, 0x3f, 0x86, 0xdb, 0x60, 0xc5, 0xbc, 0x0d, 0x1e, + 0xef, 0xf9, 0x0d, 0x39, 0xb7, 0xc0, 0xf7, 0x97, 0x13, 0x7d, 0x67, 0xa7, 0xff, 0x9b, 0x30, 0xb0, + 0xe3, 0x04, 0xcd, 0xa2, 0xe4, 0x0c, 0xa9, 0x4a, 0xf3, 0x57, 0x9d, 0x40, 0x28, 0x8e, 0x9f, 0x91, + 0xa3, 0x4e, 0x8b, 0x7a, 0x2a, 0x8d, 0x59, 0x53, 0xe8, 0x25, 0x18, 0x0a, 0x1b, 0x7e, 0x47, 0xf9, + 0x62, 0x9c, 0x67, 0x03, 0xcd, 0x4a, 0xee, 0x1f, 0xcc, 0x21, 0xb3, 0x39, 0x5a, 0x8c, 0x05, 0x3e, + 0xfa, 0x04, 0x8c, 0xb3, 0x5f, 0xca, 0x8a, 0xab, 0x9c, 0x2f, 0x50, 0xa8, 0xeb, 0x88, 0xdc, 0xc4, + 0xd1, 0x28, 0xc2, 0x26, 0xa9, 0xd9, 0x6d, 0xa8, 0xa8, 0xcf, 0x7a, 0xa8, 0x9a, 0xd7, 0x7f, 0x53, + 0x86, 0x13, 0x19, 0x6b, 0x0e, 0x85, 0xc6, 0x4c, 0x5c, 0xee, 0x73, 0xa9, 0xbe, 0xcd, 0xb9, 0x08, + 0xd9, 0x6b, 0xa8, 0x29, 0xd6, 0x56, 0xdf, 0x8d, 0xde, 0x0c, 0x49, 0xb2, 0x51, 0x5a, 0xd4, 0xbb, + 0x51, 0xda, 0xd8, 0xb1, 0x0d, 0x35, 0x6d, 0x48, 0xf5, 0xf4, 0xa1, 0xce, 0xe9, 0x9f, 0x95, 0xe1, + 0x64, 0x56, 0xfc, 0x44, 0xf4, 0xd9, 0x44, 0x6a, 0xd0, 0x17, 0xfa, 0x8d, 0xbc, 0xc8, 0xf3, 0x85, + 0x8a, 0x90, 0x6e, 0xf3, 0x66, 0xb2, 0xd0, 0x9e, 0xc3, 0x2c, 0xda, 0x64, 0x41, 0x25, 0x02, 0x9e, + 0xd2, 0x55, 0x1e, 0x1f, 0x1f, 0xec, 0xbb, 0x03, 0x22, 0x17, 0x6c, 0x98, 0xb0, 0x10, 0x91, 0xc5, + 0xbd, 0x2d, 0x44, 0x64, 0xcb, 0xb3, 0x2e, 0x8c, 0x6a, 0x5f, 0xf3, 0x50, 0x67, 0x7c, 0x97, 0xde, + 0x56, 0x5a, 0xbf, 0x1f, 0xea, 0xac, 0x7f, 0xc9, 0x82, 0x84, 0xd3, 0x80, 0x12, 0x8b, 0x59, 0xb9, + 0x62, 0xb1, 0xf3, 0x30, 0x10, 0xf8, 0x2d, 0x92, 0xcc, 0xa1, 0x89, 0xfd, 0x16, 0xc1, 0x0c, 0x42, + 0x31, 0xa2, 0x58, 0xd8, 0x31, 0xa6, 0x3f, 0xe4, 0xc4, 0x13, 0xed, 0x09, 0x18, 0x6c, 0x91, 0x3d, + 0xd2, 0x4a, 0xa6, 0x3a, 0xba, 0x4e, 0x0b, 0x31, 0x87, 0xd9, 0xbf, 0x30, 0x00, 0x67, 0x0b, 0xc3, + 0xb2, 0xd0, 0xe7, 0xd0, 0xb6, 0x13, 0x91, 0x3b, 0xce, 0x7e, 0x32, 0x27, 0xc9, 0x15, 0x5e, 0x8c, + 0x25, 0x9c, 0xf9, 0x82, 0xf1, 0xd0, 0xe2, 0x09, 0x21, 0xa2, 0x88, 0x28, 0x2e, 0xa0, 0xa6, 0x50, + 0xaa, 0x7c, 0x14, 0x42, 0xa9, 0xe7, 0x00, 0xc2, 0xb0, 0xc5, 0x4d, 0xab, 0x9a, 0xc2, 0xc9, 0x2c, + 0x0e, 0x41, 0x5f, 0xbf, 0x2e, 0x20, 0x58, 0xc3, 0x42, 0x55, 0x98, 0xea, 0x04, 0x7e, 0xc4, 0x65, + 0xb2, 0x55, 0x6e, 0x7d, 0x38, 0x68, 0x46, 0xc4, 0xa8, 0x25, 0xe0, 0x38, 0x55, 0x03, 0xbd, 0x08, + 0xa3, 0x22, 0x4a, 0x46, 0xcd, 0xf7, 0x5b, 0x42, 0x0c, 0xa4, 0x0c, 0xf2, 0xea, 0x31, 0x08, 0xeb, + 0x78, 0x5a, 0x35, 0x26, 0xe8, 0x1d, 0xce, 0xac, 0xc6, 0x85, 0xbd, 0x1a, 0x5e, 0x22, 0x96, 0xea, + 0x48, 0x5f, 0xb1, 0x54, 0x63, 0xc1, 0x58, 0xa5, 0x6f, 0xcd, 0x21, 0xf4, 0x14, 0x25, 0xfd, 0xdc, + 0x00, 0x9c, 0x10, 0x0b, 0xe7, 0x61, 0x2f, 0x97, 0x9b, 0xe9, 0xe5, 0x72, 0x14, 0xa2, 0xb3, 0x77, + 0xd7, 0xcc, 0x71, 0xaf, 0x99, 0x1f, 0xb5, 0xc0, 0x64, 0xaf, 0xd0, 0xff, 0x95, 0x9b, 0xd4, 0xe9, + 0xc5, 0x5c, 0x76, 0x4d, 0xc5, 0xe5, 0x7c, 0x9b, 0xe9, 0x9d, 0xec, 0x7f, 0x67, 0xc1, 0xe3, 0x3d, + 0x29, 0xa2, 0x65, 0xa8, 0x30, 0x1e, 0x50, 0x7b, 0x9d, 0x3d, 0xa9, 0xac, 0x93, 0x25, 0x20, 0x87, + 0x25, 0x8d, 0x6b, 0xa2, 0xe5, 0x54, 0xf6, 0xac, 0xa7, 0x32, 0xb2, 0x67, 0x9d, 0x32, 0x86, 0xe7, + 0x01, 0xd3, 0x67, 0xfd, 0x30, 0xbd, 0x71, 0x0c, 0xcf, 0x20, 0xf4, 0x41, 0x43, 0xec, 0x67, 0x27, + 0xc4, 0x7e, 0xc8, 0xc4, 0xd6, 0xee, 0x90, 0x8f, 0xc2, 0x14, 0x0b, 0x9f, 0xc5, 0x6c, 0xe5, 0x85, + 0xcf, 0x52, 0x29, 0xb6, 0x87, 0xbd, 0x9e, 0x80, 0xe1, 0x14, 0xb6, 0xfd, 0x47, 0x65, 0x18, 0xe2, + 0xdb, 0xef, 0x18, 0xde, 0x84, 0x4f, 0x43, 0xc5, 0x6d, 0xb7, 0xbb, 0x3c, 0x21, 0xd2, 0x20, 0xf7, + 0x6e, 0xa6, 0xf3, 0xb4, 0x2a, 0x0b, 0x71, 0x0c, 0x47, 0x2b, 0x42, 0xe2, 0x5c, 0x10, 0xa1, 0x93, + 0x77, 0x7c, 0xbe, 0xea, 0x44, 0x0e, 0x67, 0x70, 0xd4, 0x3d, 0x1b, 0xcb, 0xa6, 0xd1, 0xa7, 0x00, + 0xc2, 0x28, 0x70, 0xbd, 0x6d, 0x5a, 0x26, 0x02, 0x03, 0xbf, 0xbf, 0x80, 0x5a, 0x5d, 0x21, 0x73, + 0x9a, 0xf1, 0x99, 0xa3, 0x00, 0x58, 0xa3, 0x88, 0xe6, 0x8d, 0x9b, 0x7e, 0x36, 0x31, 0x77, 0xc0, + 0xa9, 0xc6, 0x73, 0x36, 0xfb, 0x21, 0xa8, 0x28, 0xe2, 0xbd, 0xe4, 0x4f, 0x63, 0x3a, 0x5b, 0xf4, + 0x11, 0x98, 0x4c, 0xf4, 0xed, 0x50, 0xe2, 0xab, 0x5f, 0xb4, 0x60, 0x92, 0x77, 0x66, 0xd9, 0xdb, + 0x13, 0xb7, 0xc1, 0x5b, 0x70, 0xb2, 0x95, 0x71, 0x2a, 0x8b, 0xe9, 0xef, 0xff, 0x14, 0x57, 0xe2, + 0xaa, 0x2c, 0x28, 0xce, 0x6c, 0x03, 0x5d, 0xa4, 0x3b, 0x8e, 0x9e, 0xba, 0x4e, 0x4b, 0x38, 0x3b, + 0x8f, 0xf1, 0xdd, 0xc6, 0xcb, 0xb0, 0x82, 0xda, 0xbf, 0x6b, 0xc1, 0x34, 0xef, 0xf9, 0x35, 0xb2, + 0xaf, 0xce, 0xa6, 0x6f, 0x66, 0xdf, 0x45, 0x2a, 0xbe, 0x52, 0x4e, 0x2a, 0x3e, 0xfd, 0xd3, 0xca, + 0x85, 0x9f, 0xf6, 0x15, 0x0b, 0xc4, 0x0a, 0x39, 0x06, 0x21, 0xc4, 0x77, 0x9a, 0x42, 0x88, 0xd9, + 0xfc, 0x4d, 0x90, 0x23, 0x7d, 0xf8, 0x73, 0x0b, 0xa6, 0x38, 0x42, 0xac, 0x2d, 0xff, 0xa6, 0xce, + 0x43, 0x3f, 0x09, 0xbb, 0xaf, 0x91, 0xfd, 0x0d, 0xbf, 0xe6, 0x44, 0x3b, 0xd9, 0x1f, 0x65, 0x4c, + 0xd6, 0x40, 0xe1, 0x64, 0x35, 0xe5, 0x06, 0x32, 0x32, 0xd5, 0xf4, 0x88, 0x00, 0x71, 0xd8, 0x4c, + 0x35, 0xf6, 0x37, 0x2c, 0x40, 0xbc, 0x19, 0x83, 0x71, 0xa3, 0xec, 0x10, 0x2b, 0xd5, 0x2e, 0xba, + 0xf8, 0x68, 0x52, 0x10, 0xac, 0x61, 0x1d, 0xc9, 0xf0, 0x24, 0x4c, 0x1e, 0xca, 0xbd, 0x4d, 0x1e, + 0x0e, 0x31, 0xa2, 0xff, 0x72, 0x08, 0x92, 0xde, 0x51, 0xe8, 0x16, 0x8c, 0x35, 0x9c, 0x8e, 0xb3, + 0xe9, 0xb6, 0xdc, 0xc8, 0x25, 0x61, 0x91, 0x45, 0xd3, 0x92, 0x86, 0x27, 0x94, 0xd4, 0x5a, 0x09, + 0x36, 0xe8, 0xa0, 0x79, 0x80, 0x4e, 0xe0, 0xee, 0xb9, 0x2d, 0xb2, 0xcd, 0x64, 0x25, 0x2c, 0xbc, + 0x02, 0x37, 0xaf, 0x92, 0xa5, 0x58, 0xc3, 0xc8, 0x70, 0x45, 0x2f, 0x3f, 0x64, 0x57, 0x74, 0x38, + 0x36, 0x57, 0xf4, 0x81, 0x43, 0xb9, 0xa2, 0x8f, 0x1c, 0xda, 0x15, 0x7d, 0xb0, 0x2f, 0x57, 0x74, + 0x0c, 0xa7, 0x25, 0xef, 0x49, 0xff, 0xaf, 0xb8, 0x2d, 0x22, 0x1e, 0x1c, 0x3c, 0x26, 0xc4, 0xec, + 0xbd, 0x83, 0xb9, 0xd3, 0x38, 0x13, 0x03, 0xe7, 0xd4, 0x44, 0x1f, 0x83, 0x19, 0xa7, 0xd5, 0xf2, + 0xef, 0xa8, 0x49, 0x5d, 0x0e, 0x1b, 0x4e, 0x8b, 0x2b, 0x21, 0x86, 0x19, 0xd5, 0xc7, 0xee, 0x1d, + 0xcc, 0xcd, 0x2c, 0xe4, 0xe0, 0xe0, 0xdc, 0xda, 0xe8, 0xc3, 0x50, 0xe9, 0x04, 0x7e, 0x63, 0x4d, + 0x73, 0xe1, 0x3c, 0x47, 0x07, 0xb0, 0x26, 0x0b, 0xef, 0x1f, 0xcc, 0x8d, 0xab, 0x3f, 0xec, 0xc2, + 0x8f, 0x2b, 0x64, 0xf8, 0x96, 0x8f, 0x1e, 0xa9, 0x6f, 0xf9, 0x2e, 0x9c, 0xa8, 0x93, 0xc0, 0x75, + 0x5a, 0xee, 0x5b, 0x94, 0x5f, 0x96, 0xe7, 0xd3, 0x06, 0x54, 0x82, 0xc4, 0x89, 0xdc, 0x57, 0xd4, + 0x4c, 0x2d, 0x65, 0x88, 0x3c, 0x81, 0x63, 0x42, 0xf6, 0xff, 0xb4, 0x60, 0x58, 0x78, 0x43, 0x1d, + 0x03, 0xd7, 0xb8, 0x60, 0x68, 0x12, 0xe6, 0xb2, 0x07, 0x8c, 0x75, 0x26, 0x57, 0x87, 0xb0, 0x9a, + 0xd0, 0x21, 0x3c, 0x5e, 0x44, 0xa4, 0x58, 0x7b, 0xf0, 0x57, 0xca, 0x94, 0x7b, 0x37, 0xfc, 0x72, + 0x1f, 0xfe, 0x10, 0xac, 0xc3, 0x70, 0x28, 0xfc, 0x42, 0x4b, 0xf9, 0x5e, 0x09, 0xc9, 0x49, 0x8c, + 0xed, 0xd8, 0x84, 0x27, 0xa8, 0x24, 0x92, 0xe9, 0x70, 0x5a, 0x7e, 0x88, 0x0e, 0xa7, 0xbd, 0x3c, + 0x97, 0x07, 0x8e, 0xc2, 0x73, 0xd9, 0xfe, 0x1a, 0xbb, 0x39, 0xf5, 0xf2, 0x63, 0x60, 0xaa, 0xae, + 0x98, 0x77, 0xac, 0x5d, 0xb0, 0xb2, 0x44, 0xa7, 0x72, 0x98, 0xab, 0x9f, 0xb7, 0xe0, 0x6c, 0xc6, + 0x57, 0x69, 0x9c, 0xd6, 0x33, 0x30, 0xe2, 0x74, 0x9b, 0xae, 0xda, 0xcb, 0x9a, 0x3e, 0x71, 0x41, + 0x94, 0x63, 0x85, 0x81, 0x96, 0x60, 0x9a, 0xdc, 0xed, 0xb8, 0x5c, 0x95, 0xaa, 0x1b, 0xf0, 0x96, + 0xb9, 0x0b, 0xdd, 0x72, 0x12, 0x88, 0xd3, 0xf8, 0x2a, 0x5a, 0x4c, 0x39, 0x37, 0x5a, 0xcc, 0xdf, + 0xb2, 0x60, 0x54, 0x79, 0x46, 0x3e, 0xf4, 0xd1, 0xfe, 0xa8, 0x39, 0xda, 0x8f, 0x16, 0x8c, 0x76, + 0xce, 0x30, 0xff, 0x76, 0x49, 0xf5, 0xb7, 0xe6, 0x07, 0x51, 0x1f, 0x1c, 0xdc, 0x83, 0x3b, 0x1f, + 0x5c, 0x86, 0x51, 0xa7, 0xd3, 0x91, 0x00, 0x69, 0x83, 0xc6, 0x62, 0x20, 0xc7, 0xc5, 0x58, 0xc7, + 0x51, 0xbe, 0x10, 0xe5, 0x5c, 0x5f, 0x88, 0x26, 0x40, 0xe4, 0x04, 0xdb, 0x24, 0xa2, 0x65, 0x22, + 0x1c, 0x5c, 0xfe, 0x79, 0xd3, 0x8d, 0xdc, 0xd6, 0xbc, 0xeb, 0x45, 0x61, 0x14, 0xcc, 0xaf, 0x7a, + 0xd1, 0x8d, 0x80, 0x3f, 0x21, 0xb5, 0x78, 0x4b, 0x8a, 0x16, 0xd6, 0xe8, 0xca, 0x28, 0x00, 0xac, + 0x8d, 0x41, 0xd3, 0x98, 0x61, 0x5d, 0x94, 0x63, 0x85, 0x61, 0x7f, 0x88, 0xdd, 0x3e, 0x6c, 0x4c, + 0x0f, 0x17, 0x6b, 0xe8, 0xef, 0x8c, 0xa9, 0xd9, 0x60, 0x9a, 0xcc, 0xaa, 0x1e, 0xd1, 0xa8, 0xf8, + 0xb0, 0xa7, 0x0d, 0xeb, 0x9e, 0x79, 0x71, 0xd8, 0x23, 0xf4, 0x5d, 0x29, 0x03, 0x95, 0x67, 0x7b, + 0xdc, 0x1a, 0x87, 0x30, 0x49, 0x61, 0x09, 0x51, 0x58, 0xba, 0x88, 0xd5, 0x9a, 0xd8, 0x17, 0x5a, + 0x42, 0x14, 0x01, 0xc0, 0x31, 0x0e, 0x65, 0xa6, 0xd4, 0x9f, 0x70, 0x06, 0xc5, 0x81, 0x41, 0x15, + 0x76, 0x88, 0x35, 0x0c, 0x74, 0x49, 0x08, 0x14, 0xb8, 0x5e, 0xe0, 0xd1, 0x84, 0x40, 0x41, 0x0e, + 0x97, 0x26, 0x05, 0xba, 0x0c, 0xa3, 0x2a, 0x07, 0x76, 0x8d, 0xa7, 0x22, 0x12, 0xcb, 0x6c, 0x39, + 0x2e, 0xc6, 0x3a, 0x0e, 0xda, 0x80, 0xc9, 0x90, 0xcb, 0xd9, 0x54, 0xb4, 0x66, 0x2e, 0xaf, 0x7c, + 0xbf, 0xb4, 0x02, 0xaa, 0x9b, 0xe0, 0xfb, 0xac, 0x88, 0x9f, 0x4e, 0xd2, 0x53, 0x3f, 0x49, 0x02, + 0xbd, 0x0a, 0x13, 0x2d, 0xdf, 0x69, 0x2e, 0x3a, 0x2d, 0xc7, 0x6b, 0xb0, 0xf1, 0x19, 0x31, 0x53, + 0xa9, 0x5e, 0x37, 0xa0, 0x38, 0x81, 0x4d, 0x99, 0x37, 0xbd, 0x44, 0x44, 0x18, 0x77, 0xbc, 0x6d, + 0x12, 0x8a, 0x8c, 0xc6, 0x8c, 0x79, 0xbb, 0x9e, 0x83, 0x83, 0x73, 0x6b, 0xa3, 0x97, 0x60, 0x4c, + 0x7e, 0xbe, 0x16, 0xd8, 0x22, 0x76, 0x2b, 0xd1, 0x60, 0xd8, 0xc0, 0x44, 0x77, 0xe0, 0x94, 0xfc, + 0xbf, 0x11, 0x38, 0x5b, 0x5b, 0x6e, 0x43, 0x78, 0x7b, 0x73, 0xff, 0xd3, 0x05, 0xe9, 0x24, 0xb9, + 0x9c, 0x85, 0x74, 0xff, 0x60, 0xee, 0xbc, 0x18, 0xb5, 0x4c, 0x38, 0x9b, 0xc4, 0x6c, 0xfa, 0x68, + 0x0d, 0x4e, 0xec, 0x10, 0xa7, 0x15, 0xed, 0x2c, 0xed, 0x90, 0xc6, 0xae, 0xdc, 0x74, 0x2c, 0x5c, + 0x86, 0xe6, 0x82, 0x71, 0x35, 0x8d, 0x82, 0xb3, 0xea, 0xa1, 0x37, 0x60, 0xa6, 0xd3, 0xdd, 0x6c, + 0xb9, 0xe1, 0xce, 0xba, 0x1f, 0x31, 0x53, 0x20, 0x95, 0x52, 0x5b, 0xc4, 0xd5, 0x50, 0x01, 0x49, + 0x6a, 0x39, 0x78, 0x38, 0x97, 0x02, 0x7a, 0x0b, 0x4e, 0x25, 0x16, 0x83, 0x88, 0x2c, 0x30, 0x91, + 0x9f, 0xaf, 0xa1, 0x9e, 0x55, 0x41, 0x04, 0xe9, 0xc8, 0x02, 0xe1, 0xec, 0x26, 0xd0, 0xcb, 0x00, + 0x6e, 0x67, 0xc5, 0x69, 0xbb, 0x2d, 0xfa, 0x5c, 0x3c, 0xc1, 0xd6, 0x09, 0x7d, 0x3a, 0xc0, 0x6a, + 0x4d, 0x96, 0xd2, 0xf3, 0x59, 0xfc, 0xdb, 0xc7, 0x1a, 0x36, 0xaa, 0xc1, 0x84, 0xf8, 0xb7, 0x2f, + 0xa6, 0x75, 0x5a, 0x39, 0xf1, 0x4f, 0xc8, 0x1a, 0x6a, 0x2e, 0x91, 0x59, 0xc2, 0x66, 0x2f, 0x51, + 0x1f, 0x6d, 0xc3, 0x59, 0x99, 0x7f, 0x4b, 0x5f, 0xa7, 0x72, 0x1e, 0x42, 0x96, 0x28, 0x61, 0x84, + 0x7b, 0x78, 0x2c, 0x14, 0x21, 0xe2, 0x62, 0x3a, 0xf4, 0x7e, 0xd7, 0x97, 0x3b, 0xf7, 0x81, 0x3d, + 0xc5, 0xcd, 0x93, 0xe8, 0xfd, 0x7e, 0x3d, 0x09, 0xc4, 0x69, 0x7c, 0x14, 0xc2, 0x29, 0xd7, 0xcb, + 0x5a, 0xdd, 0xa7, 0x19, 0xa1, 0x8f, 0x70, 0xf7, 0xdf, 0xe2, 0x95, 0x9d, 0x09, 0xe7, 0x2b, 0x3b, + 0x93, 0xf6, 0xdb, 0xb3, 0xc2, 0xfb, 0x1d, 0x8b, 0xd6, 0xd6, 0x38, 0x75, 0xf4, 0x69, 0x18, 0xd3, + 0x3f, 0x4c, 0x70, 0x1d, 0x17, 0xb2, 0x19, 0x59, 0xed, 0x7c, 0xe0, 0x7c, 0xbe, 0x3a, 0x03, 0x74, + 0x18, 0x36, 0x28, 0xa2, 0x46, 0x86, 0xa3, 0xfc, 0xa5, 0xfe, 0xb8, 0x9a, 0xfe, 0x8d, 0xd0, 0x08, + 0x64, 0x2f, 0x7b, 0x74, 0x1d, 0x46, 0x1a, 0x2d, 0x97, 0x78, 0xd1, 0x6a, 0xad, 0x28, 0x1a, 0xde, + 0x92, 0xc0, 0x11, 0xfb, 0x48, 0xe4, 0x3d, 0xe0, 0x65, 0x58, 0x51, 0xb0, 0x7f, 0xad, 0x04, 0x73, + 0x3d, 0x92, 0x68, 0x24, 0x54, 0x52, 0x56, 0x5f, 0x2a, 0xa9, 0x05, 0x99, 0x37, 0x7e, 0x3d, 0x21, + 0xed, 0x4a, 0xe4, 0x84, 0x8f, 0x65, 0x5e, 0x49, 0xfc, 0xbe, 0x5d, 0x04, 0x74, 0xad, 0xd6, 0x40, + 0x4f, 0x27, 0x17, 0x43, 0x9b, 0x3d, 0xd8, 0xff, 0x13, 0x38, 0x57, 0x33, 0x69, 0x7f, 0xad, 0x04, + 0xa7, 0xd4, 0x10, 0x7e, 0xfb, 0x0e, 0xdc, 0xcd, 0xf4, 0xc0, 0x1d, 0x81, 0x5e, 0xd7, 0xbe, 0x01, + 0x43, 0x3c, 0xbc, 0x5f, 0x1f, 0xac, 0xf7, 0x13, 0x66, 0xf8, 0x5c, 0xc5, 0xed, 0x19, 0x21, 0x74, + 0x7f, 0xd0, 0x82, 0xc9, 0x84, 0xb7, 0x18, 0xc2, 0x9a, 0x4b, 0xf1, 0x83, 0xb0, 0xc7, 0x59, 0x8c, + 0xf7, 0x79, 0x18, 0xd8, 0xf1, 0xc3, 0x28, 0x69, 0xf4, 0x71, 0xd5, 0x0f, 0x23, 0xcc, 0x20, 0xf6, + 0xef, 0x59, 0x30, 0xb8, 0xe1, 0xb8, 0x5e, 0x24, 0x15, 0x04, 0x56, 0x8e, 0x82, 0xa0, 0x9f, 0xef, + 0x42, 0x2f, 0xc2, 0x10, 0xd9, 0xda, 0x22, 0x8d, 0x48, 0xcc, 0xaa, 0x8c, 0xc7, 0x30, 0xb4, 0xcc, + 0x4a, 0x29, 0x2f, 0xc8, 0x1a, 0xe3, 0x7f, 0xb1, 0x40, 0x46, 0xb7, 0xa1, 0x12, 0xb9, 0x6d, 0xb2, + 0xd0, 0x6c, 0x0a, 0xb5, 0xf9, 0x03, 0xc4, 0x94, 0xd8, 0x90, 0x04, 0x70, 0x4c, 0xcb, 0xfe, 0x42, + 0x09, 0x20, 0x8e, 0x8b, 0xd4, 0xeb, 0x13, 0x17, 0x53, 0x0a, 0xd5, 0x0b, 0x19, 0x0a, 0x55, 0x14, + 0x13, 0xcc, 0xd0, 0xa6, 0xaa, 0x61, 0x2a, 0xf7, 0x35, 0x4c, 0x03, 0x87, 0x19, 0xa6, 0x25, 0x98, + 0x8e, 0xe3, 0x3a, 0x99, 0x61, 0xed, 0xd8, 0xf5, 0xb9, 0x91, 0x04, 0xe2, 0x34, 0xbe, 0x4d, 0xe0, + 0xbc, 0x0a, 0x6f, 0x23, 0x6e, 0x34, 0x66, 0x95, 0xad, 0x2b, 0xa8, 0x7b, 0x8c, 0x53, 0xac, 0x31, + 0x2e, 0xe5, 0x6a, 0x8c, 0x7f, 0xca, 0x82, 0x93, 0xc9, 0x76, 0x98, 0x13, 0xf2, 0xe7, 0x2d, 0x38, + 0xc5, 0xf4, 0xe6, 0xac, 0xd5, 0xb4, 0x96, 0xfe, 0x85, 0xc2, 0x90, 0x3d, 0x39, 0x3d, 0x8e, 0x03, + 0x7f, 0xac, 0x65, 0x91, 0xc6, 0xd9, 0x2d, 0xda, 0xff, 0xb6, 0x04, 0x33, 0x79, 0xb1, 0x7e, 0x98, + 0xd3, 0x86, 0x73, 0xb7, 0xbe, 0x4b, 0xee, 0x08, 0xd3, 0xf8, 0xd8, 0x69, 0x83, 0x17, 0x63, 0x09, + 0x4f, 0xe6, 0x45, 0x28, 0xf5, 0x99, 0x17, 0x61, 0x07, 0xa6, 0xef, 0xec, 0x10, 0xef, 0xa6, 0x17, + 0x3a, 0x91, 0x1b, 0x6e, 0xb9, 0x4c, 0xc7, 0xcc, 0xd7, 0x8d, 0x4c, 0xa6, 0x3a, 0x7d, 0x3b, 0x89, + 0x70, 0xff, 0x60, 0xee, 0xac, 0x51, 0x10, 0x77, 0x99, 0x1f, 0x24, 0x38, 0x4d, 0x34, 0x9d, 0x56, + 0x62, 0xe0, 0x21, 0xa6, 0x95, 0xb0, 0x3f, 0x6f, 0xc1, 0x99, 0xdc, 0xcc, 0xc2, 0xe8, 0x22, 0x8c, + 0x38, 0x1d, 0x97, 0x8b, 0xe9, 0xc5, 0x31, 0xca, 0xc4, 0x41, 0xb5, 0x55, 0x2e, 0xa4, 0x57, 0x50, + 0x7a, 0x7a, 0xed, 0xba, 0x5e, 0x33, 0x79, 0x7a, 0x5d, 0x73, 0xbd, 0x26, 0x66, 0x10, 0x75, 0x1c, + 0x97, 0xf3, 0x8e, 0x63, 0xfb, 0x07, 0x2c, 0x10, 0x0e, 0xa7, 0x7d, 0x9c, 0xdd, 0x9f, 0x80, 0xb1, + 0xbd, 0x74, 0xea, 0xa9, 0xf3, 0xf9, 0x1e, 0xb8, 0x22, 0xe1, 0x94, 0x62, 0xc8, 0x8c, 0x34, 0x53, + 0x06, 0x2d, 0xbb, 0x09, 0x02, 0x5a, 0x25, 0x4c, 0x08, 0xdd, 0xbb, 0x37, 0xcf, 0x01, 0x34, 0x19, + 0x2e, 0xcb, 0x47, 0x59, 0x32, 0x6f, 0xe6, 0xaa, 0x82, 0x60, 0x0d, 0xcb, 0xfe, 0xd7, 0x25, 0x18, + 0x95, 0xa9, 0x8e, 0xba, 0x5e, 0x3f, 0xa2, 0xa2, 0x43, 0xe5, 0x3e, 0x45, 0x97, 0xa0, 0xc2, 0x64, + 0x99, 0xb5, 0x58, 0xc2, 0xa6, 0x24, 0x09, 0x6b, 0x12, 0x80, 0x63, 0x1c, 0xba, 0x8b, 0xc2, 0xee, + 0x26, 0x43, 0x4f, 0xb8, 0x47, 0xd6, 0x79, 0x31, 0x96, 0x70, 0xf4, 0x31, 0x98, 0xe2, 0xf5, 0x02, + 0xbf, 0xe3, 0x6c, 0x73, 0xfd, 0xc7, 0xa0, 0x8a, 0x1a, 0x31, 0xb5, 0x96, 0x80, 0xdd, 0x3f, 0x98, + 0x3b, 0x99, 0x2c, 0x63, 0x8a, 0xbd, 0x14, 0x15, 0x66, 0xe6, 0xc4, 0x1b, 0xa1, 0xbb, 0x3f, 0x65, + 0x1d, 0x15, 0x83, 0xb0, 0x8e, 0x67, 0x7f, 0x1a, 0x50, 0x3a, 0xe9, 0x13, 0x7a, 0x8d, 0xdb, 0xb6, + 0xba, 0x01, 0x69, 0x16, 0x29, 0xfa, 0xf4, 0xd8, 0x08, 0xd2, 0xb3, 0x89, 0xd7, 0xc2, 0xaa, 0xbe, + 0xfd, 0xff, 0x96, 0x61, 0x2a, 0xe9, 0xcb, 0x8d, 0xae, 0xc2, 0x10, 0x67, 0x3d, 0x04, 0xf9, 0x02, + 0x3b, 0x12, 0xcd, 0x03, 0x9c, 0x1d, 0xc2, 0x82, 0x7b, 0x11, 0xf5, 0xd1, 0x1b, 0x30, 0xda, 0xf4, + 0xef, 0x78, 0x77, 0x9c, 0xa0, 0xb9, 0x50, 0x5b, 0x15, 0xcb, 0x39, 0xf3, 0x61, 0x5b, 0x8d, 0xd1, + 0x74, 0xaf, 0x72, 0xa6, 0x33, 0x8d, 0x41, 0x58, 0x27, 0x87, 0x36, 0x58, 0xa4, 0xf8, 0x2d, 0x77, + 0x7b, 0xcd, 0xe9, 0x14, 0x39, 0x3a, 0x2c, 0x49, 0x24, 0x8d, 0xf2, 0xb8, 0x08, 0x27, 0xcf, 0x01, + 0x38, 0x26, 0x84, 0x3e, 0x0b, 0x27, 0xc2, 0x1c, 0x71, 0x7b, 0x5e, 0x0e, 0xc0, 0x22, 0x09, 0xf4, + 0xe2, 0x23, 0xf7, 0x0e, 0xe6, 0x4e, 0x64, 0x09, 0xe6, 0xb3, 0x9a, 0xb1, 0xbf, 0x78, 0x12, 0x8c, + 0x4d, 0x6c, 0xa4, 0x84, 0xb5, 0x8e, 0x28, 0x25, 0x2c, 0x86, 0x11, 0xd2, 0xee, 0x44, 0xfb, 0x55, + 0x37, 0x28, 0x4a, 0x8c, 0xbf, 0x2c, 0x70, 0xd2, 0x34, 0x25, 0x04, 0x2b, 0x3a, 0xd9, 0x79, 0x7b, + 0xcb, 0xdf, 0xc4, 0xbc, 0xbd, 0x03, 0xc7, 0x98, 0xb7, 0x77, 0x1d, 0x86, 0xb7, 0xdd, 0x08, 0x93, + 0x8e, 0x2f, 0x98, 0xfe, 0xcc, 0x75, 0x78, 0x85, 0xa3, 0xa4, 0x33, 0x44, 0x0a, 0x00, 0x96, 0x44, + 0xd0, 0x6b, 0x6a, 0x07, 0x0e, 0xe5, 0x3f, 0xcc, 0xd3, 0x06, 0x0f, 0x99, 0x7b, 0x50, 0x64, 0xe7, + 0x1d, 0x7e, 0xd0, 0xec, 0xbc, 0x2b, 0x32, 0xa7, 0xee, 0x48, 0xbe, 0x57, 0x12, 0x4b, 0x99, 0xdb, + 0x23, 0x93, 0xee, 0x2d, 0x3d, 0x0f, 0x71, 0x25, 0xff, 0x24, 0x50, 0x29, 0x86, 0xfb, 0xcc, 0x3e, + 0xfc, 0x03, 0x16, 0x9c, 0xea, 0x64, 0xa5, 0xe4, 0x16, 0xb6, 0x01, 0x2f, 0xf6, 0x9d, 0xf5, 0xdb, + 0x68, 0x90, 0xc9, 0xd4, 0xb2, 0xf3, 0xba, 0x67, 0x37, 0x47, 0x07, 0x3a, 0xd8, 0x6c, 0x0a, 0x1d, + 0xf5, 0x13, 0x39, 0x69, 0x8c, 0x0b, 0x92, 0x17, 0x6f, 0x64, 0xa4, 0xcc, 0x7d, 0x6f, 0x5e, 0xca, + 0xdc, 0xbe, 0x13, 0xe5, 0xbe, 0xa6, 0x12, 0x18, 0x8f, 0xe7, 0x2f, 0x25, 0x9e, 0x9e, 0xb8, 0x67, + 0xda, 0xe2, 0xd7, 0x54, 0xda, 0xe2, 0x82, 0x88, 0xbe, 0x3c, 0x29, 0x71, 0xcf, 0x64, 0xc5, 0x5a, + 0xc2, 0xe1, 0xc9, 0xa3, 0x49, 0x38, 0x6c, 0x5c, 0x35, 0x3c, 0xe7, 0xed, 0xd3, 0x3d, 0xae, 0x1a, + 0x83, 0x6e, 0xf1, 0x65, 0xc3, 0x93, 0x2b, 0x4f, 0x3f, 0x50, 0x72, 0xe5, 0x5b, 0x7a, 0xb2, 0x62, + 0xd4, 0x23, 0x1b, 0x2f, 0x45, 0xea, 0x33, 0x45, 0xf1, 0x2d, 0xfd, 0x02, 0x3c, 0x91, 0x4f, 0x57, + 0xdd, 0x73, 0x69, 0xba, 0x99, 0x57, 0x60, 0x2a, 0xf5, 0xf1, 0xc9, 0xe3, 0x49, 0x7d, 0x7c, 0xea, + 0xc8, 0x53, 0x1f, 0x9f, 0x3e, 0x86, 0xd4, 0xc7, 0x8f, 0x1c, 0x63, 0xea, 0xe3, 0x5b, 0xcc, 0xa0, + 0x86, 0x87, 0xed, 0x11, 0x11, 0x88, 0x9f, 0xca, 0x89, 0x5b, 0x95, 0x8e, 0xed, 0xc3, 0x3f, 0x4e, + 0x81, 0x70, 0x4c, 0x2a, 0x23, 0xa5, 0xf2, 0xcc, 0x43, 0x48, 0xa9, 0xbc, 0x1e, 0xa7, 0x54, 0x3e, + 0x93, 0x3f, 0xd5, 0x19, 0x2e, 0x18, 0x39, 0x89, 0x94, 0x6f, 0xe9, 0x09, 0x90, 0x1f, 0x2d, 0xd0, + 0x9a, 0x64, 0x09, 0x1e, 0x0b, 0xd2, 0x1e, 0xbf, 0xca, 0xd3, 0x1e, 0x3f, 0x96, 0x7f, 0x92, 0x27, + 0xaf, 0x3b, 0x23, 0xd9, 0x31, 0xed, 0x97, 0x0a, 0x5c, 0xc9, 0x62, 0x2d, 0xe7, 0xf4, 0x4b, 0x45, + 0xbe, 0x4c, 0xf7, 0x4b, 0x81, 0x70, 0x4c, 0xca, 0xfe, 0xa1, 0x12, 0x9c, 0x2b, 0xde, 0x6f, 0xb1, + 0x34, 0xb5, 0x16, 0x2b, 0x91, 0x13, 0xd2, 0x54, 0xfe, 0x66, 0x8b, 0xb1, 0xfa, 0x8e, 0xc3, 0x77, + 0x05, 0xa6, 0x95, 0xef, 0x46, 0xcb, 0x6d, 0xec, 0xaf, 0xc7, 0x2f, 0x5f, 0xe5, 0xef, 0x5e, 0x4f, + 0x22, 0xe0, 0x74, 0x1d, 0xb4, 0x00, 0x93, 0x46, 0xe1, 0x6a, 0x55, 0xbc, 0xcd, 0x94, 0xf8, 0xb6, + 0x6e, 0x82, 0x71, 0x12, 0xdf, 0xfe, 0xb2, 0x05, 0x8f, 0xe4, 0xe4, 0x0c, 0xec, 0x3b, 0xcc, 0xdc, + 0x16, 0x4c, 0x76, 0xcc, 0xaa, 0x3d, 0x22, 0x63, 0x1a, 0x99, 0x09, 0x55, 0x5f, 0x13, 0x00, 0x9c, + 0x24, 0x6a, 0xff, 0x4c, 0x09, 0xce, 0x16, 0x1a, 0x23, 0x22, 0x0c, 0xa7, 0xb7, 0xdb, 0xa1, 0xb3, + 0x14, 0x90, 0x26, 0xf1, 0x22, 0xd7, 0x69, 0xd5, 0x3b, 0xa4, 0xa1, 0xc9, 0xc3, 0x99, 0x55, 0xdf, + 0x95, 0xb5, 0xfa, 0x42, 0x1a, 0x03, 0xe7, 0xd4, 0x44, 0x2b, 0x80, 0xd2, 0x10, 0x31, 0xc3, 0x2c, + 0x6a, 0x77, 0x9a, 0x1e, 0xce, 0xa8, 0x81, 0x3e, 0x04, 0xe3, 0xca, 0xc8, 0x51, 0x9b, 0x71, 0x76, + 0xb0, 0x63, 0x1d, 0x80, 0x4d, 0x3c, 0x74, 0x99, 0x87, 0x7d, 0x17, 0x09, 0x02, 0x84, 0xf0, 0x7c, + 0x52, 0xc6, 0x74, 0x17, 0xc5, 0x58, 0xc7, 0x59, 0xbc, 0xf8, 0xeb, 0x7f, 0x70, 0xee, 0x3d, 0xbf, + 0xf5, 0x07, 0xe7, 0xde, 0xf3, 0xbb, 0x7f, 0x70, 0xee, 0x3d, 0xdf, 0x73, 0xef, 0x9c, 0xf5, 0xeb, + 0xf7, 0xce, 0x59, 0xbf, 0x75, 0xef, 0x9c, 0xf5, 0xbb, 0xf7, 0xce, 0x59, 0xbf, 0x7f, 0xef, 0x9c, + 0xf5, 0x85, 0x3f, 0x3c, 0xf7, 0x9e, 0x4f, 0x94, 0xf6, 0x2e, 0xff, 0x9f, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x82, 0x9e, 0xbd, 0x79, 0x30, 0x07, 0x01, 0x00, } func (m *AWSElasticBlockStoreVolumeSource) Marshal() (dAtA []byte, err error) { @@ -13312,6 +13318,42 @@ func (m *PersistentVolumeClaimStatus) MarshalToSizedBuffer(dAtA []byte) (int, er _ = i var l int _ = l + if m.ResizeStatus != nil { + i -= len(*m.ResizeStatus) + copy(dAtA[i:], *m.ResizeStatus) + i = encodeVarintGenerated(dAtA, i, uint64(len(*m.ResizeStatus))) + i-- + dAtA[i] = 0x32 + } + if len(m.AllocatedResources) > 0 { + keysForAllocatedResources := make([]string, 0, len(m.AllocatedResources)) + for k := range m.AllocatedResources { + keysForAllocatedResources = append(keysForAllocatedResources, string(k)) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForAllocatedResources) + for iNdEx := len(keysForAllocatedResources) - 1; iNdEx >= 0; iNdEx-- { + v := m.AllocatedResources[ResourceName(keysForAllocatedResources[iNdEx])] + baseI := i + { + size, err := (&v).MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + i -= len(keysForAllocatedResources[iNdEx]) + copy(dAtA[i:], keysForAllocatedResources[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(keysForAllocatedResources[iNdEx]))) + i-- + dAtA[i] = 0xa + i = encodeVarintGenerated(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x2a + } + } if len(m.Conditions) > 0 { for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- { { @@ -21954,6 +21996,19 @@ func (m *PersistentVolumeClaimStatus) Size() (n int) { n += 1 + l + sovGenerated(uint64(l)) } } + if len(m.AllocatedResources) > 0 { + for k, v := range m.AllocatedResources { + _ = k + _ = v + l = v.Size() + mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l)) + n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize)) + } + } + if m.ResizeStatus != nil { + l = len(*m.ResizeStatus) + n += 1 + l + sovGenerated(uint64(l)) + } return n } @@ -26010,11 +26065,23 @@ func (this *PersistentVolumeClaimStatus) String() string { mapStringForCapacity += fmt.Sprintf("%v: %v,", k, this.Capacity[ResourceName(k)]) } mapStringForCapacity += "}" + keysForAllocatedResources := make([]string, 0, len(this.AllocatedResources)) + for k := range this.AllocatedResources { + keysForAllocatedResources = append(keysForAllocatedResources, string(k)) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForAllocatedResources) + mapStringForAllocatedResources := "ResourceList{" + for _, k := range keysForAllocatedResources { + mapStringForAllocatedResources += fmt.Sprintf("%v: %v,", k, this.AllocatedResources[ResourceName(k)]) + } + mapStringForAllocatedResources += "}" s := strings.Join([]string{`&PersistentVolumeClaimStatus{`, `Phase:` + fmt.Sprintf("%v", this.Phase) + `,`, `AccessModes:` + fmt.Sprintf("%v", this.AccessModes) + `,`, `Capacity:` + mapStringForCapacity + `,`, `Conditions:` + repeatedStringForConditions + `,`, + `AllocatedResources:` + mapStringForAllocatedResources + `,`, + `ResizeStatus:` + valueToStringGenerated(this.ResizeStatus) + `,`, `}`, }, "") return s @@ -47962,6 +48029,168 @@ func (m *PersistentVolumeClaimStatus) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AllocatedResources", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AllocatedResources == nil { + m.AllocatedResources = make(ResourceList) + } + var mapkey ResourceName + mapvalue := &resource.Quantity{} + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthGenerated + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = ResourceName(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapmsglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthGenerated + } + postmsgIndex := iNdEx + mapmsglen + if postmsgIndex < 0 { + return ErrInvalidLengthGenerated + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = &resource.Quantity{} + if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.AllocatedResources[ResourceName(mapkey)] = *mapvalue + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ResizeStatus", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := PersistentVolumeClaimResizeStatus(dAtA[iNdEx:postIndex]) + m.ResizeStatus = &s + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) diff --git a/staging/src/k8s.io/api/core/v1/generated.proto b/staging/src/k8s.io/api/core/v1/generated.proto index 9245f52d1a31..dbfe979e1cd6 100644 --- a/staging/src/k8s.io/api/core/v1/generated.proto +++ b/staging/src/k8s.io/api/core/v1/generated.proto @@ -2665,6 +2665,9 @@ message PersistentVolumeClaimSpec { optional k8s.io.apimachinery.pkg.apis.meta.v1.LabelSelector selector = 4; // Resources represents the minimum resources the volume should have. + // If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements + // that are lower than previous value but must still be higher than capacity recorded in the + // status field of the claim. // More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources // +optional optional ResourceRequirements resources = 2; @@ -2735,6 +2738,26 @@ message PersistentVolumeClaimStatus { // +patchMergeKey=type // +patchStrategy=merge repeated PersistentVolumeClaimCondition conditions = 4; + + // The storage resource within AllocatedResources tracks the capacity allocated to a PVC. It may + // be larger than the actual capacity when a volume expansion operation is requested. + // For storage quota, the larger value from allocatedResources and PVC.spec.resources is used. + // If allocatedResources is not set, PVC.spec.resources alone is used for quota calculation. + // If a volume expansion capacity request is lowered, allocatedResources is only + // lowered if there are no expansion operations in progress and if the actual volume capacity + // is equal or lower than the requested capacity. + // This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature. + // +featureGate=RecoverVolumeExpansionFailure + // +optional + map allocatedResources = 5; + + // ResizeStatus stores status of resize operation. + // ResizeStatus is not set by default but when expansion is complete resizeStatus is set to empty + // string by resize controller or kubelet. + // This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature. + // +featureGate=RecoverVolumeExpansionFailure + // +optional + optional string resizeStatus = 6; } // PersistentVolumeClaimTemplate is used to produce diff --git a/staging/src/k8s.io/api/core/v1/types.go b/staging/src/k8s.io/api/core/v1/types.go index 9abc10f853a5..866884aad9f2 100644 --- a/staging/src/k8s.io/api/core/v1/types.go +++ b/staging/src/k8s.io/api/core/v1/types.go @@ -472,6 +472,9 @@ type PersistentVolumeClaimSpec struct { // +optional Selector *metav1.LabelSelector `json:"selector,omitempty" protobuf:"bytes,4,opt,name=selector"` // Resources represents the minimum resources the volume should have. + // If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements + // that are lower than previous value but must still be higher than capacity recorded in the + // status field of the claim. // More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources // +optional Resources ResourceRequirements `json:"resources,omitempty" protobuf:"bytes,2,opt,name=resources"` @@ -526,6 +529,26 @@ const ( PersistentVolumeClaimFileSystemResizePending PersistentVolumeClaimConditionType = "FileSystemResizePending" ) +// +enum +type PersistentVolumeClaimResizeStatus string + +const ( + // When expansion is complete, the empty string is set by resize controller or kubelet. + PersistentVolumeClaimNoExpansionInProgress PersistentVolumeClaimResizeStatus = "" + // State set when resize controller starts expanding the volume in control-plane + PersistentVolumeClaimControllerExpansionInProgress PersistentVolumeClaimResizeStatus = "ControllerExpansionInProgress" + // State set when expansion has failed in resize controller with a terminal error. + // Transient errors such as timeout should not set this status and should leave ResizeStatus + // unmodified, so as resize controller can resume the volume expansion. + PersistentVolumeClaimControllerExpansionFailed PersistentVolumeClaimResizeStatus = "ControllerExpansionFailed" + // State set when resize controller has finished expanding the volume but further expansion is needed on the node. + PersistentVolumeClaimNodeExpansionPending PersistentVolumeClaimResizeStatus = "NodeExpansionPending" + // State set when kubelet starts expanding the volume. + PersistentVolumeClaimNodeExpansionInProgress PersistentVolumeClaimResizeStatus = "NodeExpansionInProgress" + // State set when expansion has failed in kubelet with a terminal error. Transient errors don't set NodeExpansionFailed. + PersistentVolumeClaimNodeExpansionFailed PersistentVolumeClaimResizeStatus = "NodeExpansionFailed" +) + // PersistentVolumeClaimCondition contails details about state of pvc type PersistentVolumeClaimCondition struct { Type PersistentVolumeClaimConditionType `json:"type" protobuf:"bytes,1,opt,name=type,casttype=PersistentVolumeClaimConditionType"` @@ -564,6 +587,24 @@ type PersistentVolumeClaimStatus struct { // +patchMergeKey=type // +patchStrategy=merge Conditions []PersistentVolumeClaimCondition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,4,rep,name=conditions"` + // The storage resource within AllocatedResources tracks the capacity allocated to a PVC. It may + // be larger than the actual capacity when a volume expansion operation is requested. + // For storage quota, the larger value from allocatedResources and PVC.spec.resources is used. + // If allocatedResources is not set, PVC.spec.resources alone is used for quota calculation. + // If a volume expansion capacity request is lowered, allocatedResources is only + // lowered if there are no expansion operations in progress and if the actual volume capacity + // is equal or lower than the requested capacity. + // This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature. + // +featureGate=RecoverVolumeExpansionFailure + // +optional + AllocatedResources ResourceList `json:"allocatedResources,omitempty" protobuf:"bytes,5,rep,name=allocatedResources,casttype=ResourceList,castkey=ResourceName"` + // ResizeStatus stores status of resize operation. + // ResizeStatus is not set by default but when expansion is complete resizeStatus is set to empty + // string by resize controller or kubelet. + // This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature. + // +featureGate=RecoverVolumeExpansionFailure + // +optional + ResizeStatus *PersistentVolumeClaimResizeStatus `json:"resizeStatus,omitempty" protobuf:"bytes,6,opt,name=resizeStatus,casttype=PersistentVolumeClaimResizeStatus"` } type PersistentVolumeAccessMode string diff --git a/staging/src/k8s.io/api/core/v1/types_swagger_doc_generated.go b/staging/src/k8s.io/api/core/v1/types_swagger_doc_generated.go index 45379d99b7e8..3f83dbcabbcc 100644 --- a/staging/src/k8s.io/api/core/v1/types_swagger_doc_generated.go +++ b/staging/src/k8s.io/api/core/v1/types_swagger_doc_generated.go @@ -1297,7 +1297,7 @@ var map_PersistentVolumeClaimSpec = map[string]string{ "": "PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes", "accessModes": "AccessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1", "selector": "A label query over volumes to consider for binding.", - "resources": "Resources represents the minimum resources the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources", + "resources": "Resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources", "volumeName": "VolumeName is the binding reference to the PersistentVolume backing this claim.", "storageClassName": "Name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1", "volumeMode": "volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.", @@ -1310,11 +1310,13 @@ func (PersistentVolumeClaimSpec) SwaggerDoc() map[string]string { } var map_PersistentVolumeClaimStatus = map[string]string{ - "": "PersistentVolumeClaimStatus is the current status of a persistent volume claim.", - "phase": "Phase represents the current phase of PersistentVolumeClaim.", - "accessModes": "AccessModes contains the actual access modes the volume backing the PVC has. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1", - "capacity": "Represents the actual resources of the underlying volume.", - "conditions": "Current Condition of persistent volume claim. If underlying persistent volume is being resized then the Condition will be set to 'ResizeStarted'.", + "": "PersistentVolumeClaimStatus is the current status of a persistent volume claim.", + "phase": "Phase represents the current phase of PersistentVolumeClaim.", + "accessModes": "AccessModes contains the actual access modes the volume backing the PVC has. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1", + "capacity": "Represents the actual resources of the underlying volume.", + "conditions": "Current Condition of persistent volume claim. If underlying persistent volume is being resized then the Condition will be set to 'ResizeStarted'.", + "allocatedResources": "The storage resource within AllocatedResources tracks the capacity allocated to a PVC. It may be larger than the actual capacity when a volume expansion operation is requested. For storage quota, the larger value from allocatedResources and PVC.spec.resources is used. If allocatedResources is not set, PVC.spec.resources alone is used for quota calculation. If a volume expansion capacity request is lowered, allocatedResources is only lowered if there are no expansion operations in progress and if the actual volume capacity is equal or lower than the requested capacity. This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature.", + "resizeStatus": "ResizeStatus stores status of resize operation. ResizeStatus is not set by default but when expansion is complete resizeStatus is set to empty string by resize controller or kubelet. This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature.", } func (PersistentVolumeClaimStatus) SwaggerDoc() map[string]string { diff --git a/staging/src/k8s.io/api/core/v1/zz_generated.deepcopy.go b/staging/src/k8s.io/api/core/v1/zz_generated.deepcopy.go index 266787d9ceeb..d7cb35d8b445 100644 --- a/staging/src/k8s.io/api/core/v1/zz_generated.deepcopy.go +++ b/staging/src/k8s.io/api/core/v1/zz_generated.deepcopy.go @@ -2975,6 +2975,18 @@ func (in *PersistentVolumeClaimStatus) DeepCopyInto(out *PersistentVolumeClaimSt (*in)[i].DeepCopyInto(&(*out)[i]) } } + if in.AllocatedResources != nil { + in, out := &in.AllocatedResources, &out.AllocatedResources + *out = make(ResourceList, len(*in)) + for key, val := range *in { + (*out)[key] = val.DeepCopy() + } + } + if in.ResizeStatus != nil { + in, out := &in.ResizeStatus, &out.ResizeStatus + *out = new(PersistentVolumeClaimResizeStatus) + **out = **in + } return } diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.json b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.json index ce0362e4b215..9f90d0d5cf57 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.json +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.json @@ -1642,39 +1642,43 @@ "reason": "523", "message": "524" } - ] + ], + "allocatedResources": { + "鐳VDɝ": "844" + }, + "resizeStatus": "但Ǭľa执mÎDƃ" } } ], "serviceName": "525", - "podManagementPolicy": "婵=ǻ", + "podManagementPolicy": "ƌ妜;)t罎j´A", "updateStrategy": { - "type": "ɝÔȗ$`Ž#", + "type": "徙蔿Yċʤw俣Ǫ", "rollingUpdate": { - "partition": -1644040574 + "partition": 2000146968 } }, - "revisionHistoryLimit": -1205784111, - "minReadySeconds": 1505300966 + "revisionHistoryLimit": 560461224, + "minReadySeconds": 2059121580 }, "status": { - "observedGeneration": 7422250233075984176, - "replicas": -326265137, - "readyReplicas": 1683394621, - "currentReplicas": 1862659237, - "updatedReplicas": 798811297, + "observedGeneration": -632886252136267545, + "replicas": 750655684, + "readyReplicas": -1012893423, + "currentReplicas": -1295777734, + "updatedReplicas": -1394190312, "currentRevision": "526", "updateRevision": "527", - "collisionCount": -1290326833, + "collisionCount": 1077247354, "conditions": [ { - "type": "´Aƺå嫹^Ȇɀ*ǹ", - "status": "蟷尨BABȳ", - "lastTransitionTime": "2464-04-30T23:47:03Z", + "type": "堏ȑ湸睑L暱ʖ妾崗", + "status": "ij敪賻yʗHiv\u003c", + "lastTransitionTime": "2814-04-22T10:44:02Z", "reason": "528", "message": "529" } ], - "availableReplicas": -1012893423 + "availableReplicas": 747018016 } } \ No newline at end of file diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.pb b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.pb index 5ccd618b923e..938f6747e773 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.pb and b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.yaml index d8cc0762514e..9f6221d32ea1 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.yaml @@ -31,10 +31,10 @@ metadata: selfLink: "5" uid: "7" spec: - minReadySeconds: 1505300966 - podManagementPolicy: 婵=ǻ + minReadySeconds: 2059121580 + podManagementPolicy: ƌ妜;)t罎j´A replicas: 896585016 - revisionHistoryLimit: -1205784111 + revisionHistoryLimit: 560461224 selector: matchExpressions: - key: 50-u--25cu87--r7p-w1e67-8pj5t-kl-v0q6b68--nu5oii38fn-8.629b-jd-8c45-0-8--6n--w0--w---196g8d--iv1-5--5ht-a-29--0qso796/3___47._49pIB_o61ISU4--A_.XK_._M99 @@ -1060,8 +1060,8 @@ spec: volumePath: "103" updateStrategy: rollingUpdate: - partition: -1644040574 - type: ɝÔȗ$`Ž# + partition: 2000146968 + type: 徙蔿Yċʤw俣Ǫ volumeClaimTemplates: - metadata: annotations: @@ -1123,6 +1123,8 @@ spec: status: accessModes: - v}鮩澊聝楧 + allocatedResources: + 鐳VDɝ: "844" capacity: 问Ð7ɞŶJŖ)j{驟ʦcȃ: "657" conditions: @@ -1133,19 +1135,20 @@ spec: status: Q¢鬣_棈Ý泷 type: ņȎZȐ樾'Ż£劾ů phase: 忣àÂƺ琰Ȃ芋醳鮩!廊臚cɶċ + resizeStatus: 但Ǭľa执mÎDƃ status: - availableReplicas: -1012893423 - collisionCount: -1290326833 + availableReplicas: 747018016 + collisionCount: 1077247354 conditions: - - lastTransitionTime: "2464-04-30T23:47:03Z" + - lastTransitionTime: "2814-04-22T10:44:02Z" message: "529" reason: "528" - status: 蟷尨BABȳ - type: ´Aƺå嫹^Ȇɀ*ǹ - currentReplicas: 1862659237 + status: ij敪賻yʗHiv< + type: 堏ȑ湸睑L暱ʖ妾崗 + currentReplicas: -1295777734 currentRevision: "526" - observedGeneration: 7422250233075984176 - readyReplicas: 1683394621 - replicas: -326265137 + observedGeneration: -632886252136267545 + readyReplicas: -1012893423 + replicas: 750655684 updateRevision: "527" - updatedReplicas: 798811297 + updatedReplicas: -1394190312 diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.json b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.json index 471ecab54e41..fc5c2fd5b837 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.json +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.json @@ -1642,39 +1642,43 @@ "reason": "523", "message": "524" } - ] + ], + "allocatedResources": { + "鐳VDɝ": "844" + }, + "resizeStatus": "但Ǭľa执mÎDƃ" } } ], "serviceName": "525", - "podManagementPolicy": "婵=ǻ", + "podManagementPolicy": "ƌ妜;)t罎j´A", "updateStrategy": { - "type": "ɝÔȗ$`Ž#", + "type": "徙蔿Yċʤw俣Ǫ", "rollingUpdate": { - "partition": -1644040574 + "partition": 2000146968 } }, - "revisionHistoryLimit": -1205784111, - "minReadySeconds": 1505300966 + "revisionHistoryLimit": 560461224, + "minReadySeconds": 2059121580 }, "status": { - "observedGeneration": 2345785178116014414, - "replicas": 923301621, - "readyReplicas": 2036280873, - "currentReplicas": 2102009515, - "updatedReplicas": -1974512490, + "observedGeneration": -8200913189823252840, + "replicas": 1892314617, + "readyReplicas": -1893854851, + "currentReplicas": 658548230, + "updatedReplicas": -301228056, "currentRevision": "526", "updateRevision": "527", - "collisionCount": -1001798049, + "collisionCount": 446542989, "conditions": [ { - "type": "Ǒl徙蔿Yċʤw", - "status": "ǹ脡È6", - "lastTransitionTime": "2744-07-10T16:37:22Z", + "type": "Ǚ3洠º襊Ł靫挕欰ij敪賻yʗHiv", + "status": "V汦\u003e蒃U", + "lastTransitionTime": "2800-08-07T22:03:04Z", "reason": "528", "message": "529" } ], - "availableReplicas": -180607525 + "availableReplicas": -2059927818 } } \ No newline at end of file diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.pb b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.pb index 66f72dd0cb03..35f8f6d3de3d 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.pb and b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.yaml index 2a809230020b..184cd513c200 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.yaml @@ -31,10 +31,10 @@ metadata: selfLink: "5" uid: "7" spec: - minReadySeconds: 1505300966 - podManagementPolicy: 婵=ǻ + minReadySeconds: 2059121580 + podManagementPolicy: ƌ妜;)t罎j´A replicas: 896585016 - revisionHistoryLimit: -1205784111 + revisionHistoryLimit: 560461224 selector: matchExpressions: - key: 50-u--25cu87--r7p-w1e67-8pj5t-kl-v0q6b68--nu5oii38fn-8.629b-jd-8c45-0-8--6n--w0--w---196g8d--iv1-5--5ht-a-29--0qso796/3___47._49pIB_o61ISU4--A_.XK_._M99 @@ -1060,8 +1060,8 @@ spec: volumePath: "103" updateStrategy: rollingUpdate: - partition: -1644040574 - type: ɝÔȗ$`Ž# + partition: 2000146968 + type: 徙蔿Yċʤw俣Ǫ volumeClaimTemplates: - metadata: annotations: @@ -1123,6 +1123,8 @@ spec: status: accessModes: - v}鮩澊聝楧 + allocatedResources: + 鐳VDɝ: "844" capacity: 问Ð7ɞŶJŖ)j{驟ʦcȃ: "657" conditions: @@ -1133,19 +1135,20 @@ spec: status: Q¢鬣_棈Ý泷 type: ņȎZȐ樾'Ż£劾ů phase: 忣àÂƺ琰Ȃ芋醳鮩!廊臚cɶċ + resizeStatus: 但Ǭľa执mÎDƃ status: - availableReplicas: -180607525 - collisionCount: -1001798049 + availableReplicas: -2059927818 + collisionCount: 446542989 conditions: - - lastTransitionTime: "2744-07-10T16:37:22Z" + - lastTransitionTime: "2800-08-07T22:03:04Z" message: "529" reason: "528" - status: ǹ脡È6 - type: Ǒl徙蔿Yċʤw - currentReplicas: 2102009515 + status: V汦>蒃U + type: Ǚ3洠º襊Ł靫挕欰ij敪賻yʗHiv + currentReplicas: 658548230 currentRevision: "526" - observedGeneration: 2345785178116014414 - readyReplicas: 2036280873 - replicas: 923301621 + observedGeneration: -8200913189823252840 + readyReplicas: -1893854851 + replicas: 1892314617 updateRevision: "527" - updatedReplicas: -1974512490 + updatedReplicas: -301228056 diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.json b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.json index a2c33d1d2b11..b67d0af41e9c 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.json +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.json @@ -1642,39 +1642,43 @@ "reason": "523", "message": "524" } - ] + ], + "allocatedResources": { + "鐳VDɝ": "844" + }, + "resizeStatus": "但Ǭľa执mÎDƃ" } } ], "serviceName": "525", - "podManagementPolicy": "婵=ǻ", + "podManagementPolicy": "ƌ妜;)t罎j´A", "updateStrategy": { - "type": "ɝÔȗ$`Ž#", + "type": "徙蔿Yċʤw俣Ǫ", "rollingUpdate": { - "partition": -1644040574 + "partition": 2000146968 } }, - "revisionHistoryLimit": -1205784111, - "minReadySeconds": 1505300966 + "revisionHistoryLimit": 560461224, + "minReadySeconds": 2059121580 }, "status": { - "observedGeneration": 7422250233075984176, - "replicas": -326265137, - "readyReplicas": 1683394621, - "currentReplicas": 1862659237, - "updatedReplicas": 798811297, + "observedGeneration": -632886252136267545, + "replicas": 750655684, + "readyReplicas": -1012893423, + "currentReplicas": -1295777734, + "updatedReplicas": -1394190312, "currentRevision": "526", "updateRevision": "527", - "collisionCount": -1290326833, + "collisionCount": 1077247354, "conditions": [ { - "type": "´Aƺå嫹^Ȇɀ*ǹ", - "status": "蟷尨BABȳ", - "lastTransitionTime": "2464-04-30T23:47:03Z", + "type": "堏ȑ湸睑L暱ʖ妾崗", + "status": "ij敪賻yʗHiv\u003c", + "lastTransitionTime": "2814-04-22T10:44:02Z", "reason": "528", "message": "529" } ], - "availableReplicas": -1012893423 + "availableReplicas": 747018016 } } \ No newline at end of file diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.pb b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.pb index b3d3d9b87c9e..a28b2631a08f 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.pb and b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.yaml index e2742f2573fd..18e7144c481d 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.yaml @@ -31,10 +31,10 @@ metadata: selfLink: "5" uid: "7" spec: - minReadySeconds: 1505300966 - podManagementPolicy: 婵=ǻ + minReadySeconds: 2059121580 + podManagementPolicy: ƌ妜;)t罎j´A replicas: 896585016 - revisionHistoryLimit: -1205784111 + revisionHistoryLimit: 560461224 selector: matchExpressions: - key: 50-u--25cu87--r7p-w1e67-8pj5t-kl-v0q6b68--nu5oii38fn-8.629b-jd-8c45-0-8--6n--w0--w---196g8d--iv1-5--5ht-a-29--0qso796/3___47._49pIB_o61ISU4--A_.XK_._M99 @@ -1060,8 +1060,8 @@ spec: volumePath: "103" updateStrategy: rollingUpdate: - partition: -1644040574 - type: ɝÔȗ$`Ž# + partition: 2000146968 + type: 徙蔿Yċʤw俣Ǫ volumeClaimTemplates: - metadata: annotations: @@ -1123,6 +1123,8 @@ spec: status: accessModes: - v}鮩澊聝楧 + allocatedResources: + 鐳VDɝ: "844" capacity: 问Ð7ɞŶJŖ)j{驟ʦcȃ: "657" conditions: @@ -1133,19 +1135,20 @@ spec: status: Q¢鬣_棈Ý泷 type: ņȎZȐ樾'Ż£劾ů phase: 忣àÂƺ琰Ȃ芋醳鮩!廊臚cɶċ + resizeStatus: 但Ǭľa执mÎDƃ status: - availableReplicas: -1012893423 - collisionCount: -1290326833 + availableReplicas: 747018016 + collisionCount: 1077247354 conditions: - - lastTransitionTime: "2464-04-30T23:47:03Z" + - lastTransitionTime: "2814-04-22T10:44:02Z" message: "529" reason: "528" - status: 蟷尨BABȳ - type: ´Aƺå嫹^Ȇɀ*ǹ - currentReplicas: 1862659237 + status: ij敪賻yʗHiv< + type: 堏ȑ湸睑L暱ʖ妾崗 + currentReplicas: -1295777734 currentRevision: "526" - observedGeneration: 7422250233075984176 - readyReplicas: 1683394621 - replicas: -326265137 + observedGeneration: -632886252136267545 + readyReplicas: -1012893423 + replicas: 750655684 updateRevision: "527" - updatedReplicas: 798811297 + updatedReplicas: -1394190312 diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.PersistentVolumeClaim.json b/staging/src/k8s.io/api/testdata/HEAD/core.v1.PersistentVolumeClaim.json index 1251e93c5692..455bed592f0c 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/core.v1.PersistentVolumeClaim.json +++ b/staging/src/k8s.io/api/testdata/HEAD/core.v1.PersistentVolumeClaim.json @@ -95,6 +95,10 @@ "reason": "34", "message": "35" } - ] + ], + "allocatedResources": { + " u衲\u003c¿燥": "98" + }, + "resizeStatus": "{舁吉蓨O澘" } } \ No newline at end of file diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.PersistentVolumeClaim.pb b/staging/src/k8s.io/api/testdata/HEAD/core.v1.PersistentVolumeClaim.pb index de69094f13d4..b20b4dc4955c 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/core.v1.PersistentVolumeClaim.pb and b/staging/src/k8s.io/api/testdata/HEAD/core.v1.PersistentVolumeClaim.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.PersistentVolumeClaim.yaml b/staging/src/k8s.io/api/testdata/HEAD/core.v1.PersistentVolumeClaim.yaml index 9b1068bcdb37..58dcbaab6bf3 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/core.v1.PersistentVolumeClaim.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/core.v1.PersistentVolumeClaim.yaml @@ -58,6 +58,8 @@ spec: status: accessModes: - l殛瓷雼浢Ü礽 + allocatedResources: + ' u衲<¿燥': "98" capacity: '{囥': "721" conditions: @@ -68,3 +70,4 @@ status: status: Ka縳讋ɮ衺勽Ƙq type: n(鲼ƳÐƣKʘńw:5塋訩塶"= phase: gɸ=ǤÆ碛,1ZƜ/C龷Ȫ + resizeStatus: '{舁吉蓨O澘' diff --git a/staging/src/k8s.io/client-go/applyconfigurations/core/v1/persistentvolumeclaimstatus.go b/staging/src/k8s.io/client-go/applyconfigurations/core/v1/persistentvolumeclaimstatus.go index 711651e0bcb7..4c38d89f5739 100644 --- a/staging/src/k8s.io/client-go/applyconfigurations/core/v1/persistentvolumeclaimstatus.go +++ b/staging/src/k8s.io/client-go/applyconfigurations/core/v1/persistentvolumeclaimstatus.go @@ -25,10 +25,12 @@ import ( // PersistentVolumeClaimStatusApplyConfiguration represents an declarative configuration of the PersistentVolumeClaimStatus type for use // with apply. type PersistentVolumeClaimStatusApplyConfiguration struct { - Phase *v1.PersistentVolumeClaimPhase `json:"phase,omitempty"` - AccessModes []v1.PersistentVolumeAccessMode `json:"accessModes,omitempty"` - Capacity *v1.ResourceList `json:"capacity,omitempty"` - Conditions []PersistentVolumeClaimConditionApplyConfiguration `json:"conditions,omitempty"` + Phase *v1.PersistentVolumeClaimPhase `json:"phase,omitempty"` + AccessModes []v1.PersistentVolumeAccessMode `json:"accessModes,omitempty"` + Capacity *v1.ResourceList `json:"capacity,omitempty"` + Conditions []PersistentVolumeClaimConditionApplyConfiguration `json:"conditions,omitempty"` + AllocatedResources *v1.ResourceList `json:"allocatedResources,omitempty"` + ResizeStatus *v1.PersistentVolumeClaimResizeStatus `json:"resizeStatus,omitempty"` } // PersistentVolumeClaimStatusApplyConfiguration constructs an declarative configuration of the PersistentVolumeClaimStatus type for use with @@ -75,3 +77,19 @@ func (b *PersistentVolumeClaimStatusApplyConfiguration) WithConditions(values .. } return b } + +// WithAllocatedResources sets the AllocatedResources field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the AllocatedResources field is set to the value of the last call. +func (b *PersistentVolumeClaimStatusApplyConfiguration) WithAllocatedResources(value v1.ResourceList) *PersistentVolumeClaimStatusApplyConfiguration { + b.AllocatedResources = &value + return b +} + +// WithResizeStatus sets the ResizeStatus field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ResizeStatus field is set to the value of the last call. +func (b *PersistentVolumeClaimStatusApplyConfiguration) WithResizeStatus(value v1.PersistentVolumeClaimResizeStatus) *PersistentVolumeClaimStatusApplyConfiguration { + b.ResizeStatus = &value + return b +} diff --git a/staging/src/k8s.io/client-go/applyconfigurations/internal/internal.go b/staging/src/k8s.io/client-go/applyconfigurations/internal/internal.go index fcedfc1f36c4..36480ad4cad3 100644 --- a/staging/src/k8s.io/client-go/applyconfigurations/internal/internal.go +++ b/staging/src/k8s.io/client-go/applyconfigurations/internal/internal.go @@ -5291,6 +5291,11 @@ var schemaYAML = typed.YAMLObject(`types: elementType: scalar: string elementRelationship: atomic + - name: allocatedResources + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity - name: capacity type: map: @@ -5307,6 +5312,9 @@ var schemaYAML = typed.YAMLObject(`types: - name: phase type: scalar: string + - name: resizeStatus + type: + scalar: string - name: io.k8s.api.core.v1.PersistentVolumeClaimTemplate map: fields: