From 87c1ca88d45ac7ec2b37d46187f40ff70d36aee1 Mon Sep 17 00:00:00 2001 From: Takafumi Takahashi Date: Tue, 1 Nov 2022 03:54:34 +0000 Subject: [PATCH 1/2] Add API and validation for CrossNamespaceVolumeDataSource --- pkg/api/persistentvolumeclaim/util.go | 47 +++- pkg/api/persistentvolumeclaim/util_test.go | 202 +++++++++++++----- pkg/apis/core/types.go | 43 +++- pkg/apis/core/validation/validation.go | 44 +++- pkg/apis/core/validation/validation_test.go | 112 +++++++++- pkg/features/kube_features.go | 9 + .../storage/storage_test.go | 11 +- .../core/persistentvolumeclaim/strategy.go | 4 +- .../persistentvolumeclaim/strategy_test.go | 184 +++++++++++++--- staging/src/k8s.io/api/core/v1/types.go | 43 +++- test/e2e/storage/testsuites/multivolume.go | 8 +- test/e2e/storage/testsuites/provisioning.go | 26 +-- 12 files changed, 596 insertions(+), 137 deletions(-) diff --git a/pkg/api/persistentvolumeclaim/util.go b/pkg/api/persistentvolumeclaim/util.go index 2f24c645b66..4334afcca59 100644 --- a/pkg/api/persistentvolumeclaim/util.go +++ b/pkg/api/persistentvolumeclaim/util.go @@ -32,11 +32,22 @@ const ( // DropDisabledFields removes disabled fields from the pvc spec. // This should be called from PrepareForCreate/PrepareForUpdate for all resources containing a pvc spec. -func DropDisabledFields(pvcSpec *core.PersistentVolumeClaimSpec) { +func DropDisabledFields(pvcSpec, oldPVCSpec *core.PersistentVolumeClaimSpec) { // Drop the contents of the dataSourceRef field if the AnyVolumeDataSource // feature gate is disabled. if !utilfeature.DefaultFeatureGate.Enabled(features.AnyVolumeDataSource) { - pvcSpec.DataSourceRef = nil + if !dataSourceRefInUse(oldPVCSpec) { + pvcSpec.DataSourceRef = nil + } + } + + // Drop the contents of the dataSourceRef field if the CrossNamespaceVolumeDataSource + // feature gate is disabled and dataSourceRef.Namespace is specified. + if !utilfeature.DefaultFeatureGate.Enabled(features.CrossNamespaceVolumeDataSource) && + pvcSpec.DataSourceRef != nil && pvcSpec.DataSourceRef.Namespace != nil && len(*pvcSpec.DataSourceRef.Namespace) != 0 { + if !dataSourceRefInUse(oldPVCSpec) { + pvcSpec.DataSourceRef = nil + } } } @@ -116,6 +127,16 @@ func dataSourceIsPvcOrSnapshot(dataSource *core.TypedLocalObjectReference) bool return false } +func dataSourceRefInUse(oldPVCSpec *core.PersistentVolumeClaimSpec) bool { + if oldPVCSpec == nil { + return false + } + if oldPVCSpec.DataSourceRef != nil { + return true + } + return false +} + // NormalizeDataSources ensures that DataSource and DataSourceRef have the same contents // as long as both are not explicitly set. // This should be used by creates/gets of PVCs, but not updates @@ -126,10 +147,26 @@ func NormalizeDataSources(pvcSpec *core.PersistentVolumeClaimSpec) { } if pvcSpec.DataSource != nil && pvcSpec.DataSourceRef == nil { // Using the old way of setting a data source - pvcSpec.DataSourceRef = pvcSpec.DataSource.DeepCopy() + pvcSpec.DataSourceRef = &core.TypedObjectReference{ + Kind: pvcSpec.DataSource.Kind, + Name: pvcSpec.DataSource.Name, + } + if pvcSpec.DataSource.APIGroup != nil { + apiGroup := *pvcSpec.DataSource.APIGroup + pvcSpec.DataSourceRef.APIGroup = &apiGroup + } } else if pvcSpec.DataSourceRef != nil && pvcSpec.DataSource == nil { - // Using the new way of setting a data source - pvcSpec.DataSource = pvcSpec.DataSourceRef.DeepCopy() + if pvcSpec.DataSourceRef.Namespace == nil || len(*pvcSpec.DataSourceRef.Namespace) == 0 { + // Using the new way of setting a data source + pvcSpec.DataSource = &core.TypedLocalObjectReference{ + Kind: pvcSpec.DataSourceRef.Kind, + Name: pvcSpec.DataSourceRef.Name, + } + if pvcSpec.DataSourceRef.APIGroup != nil { + apiGroup := *pvcSpec.DataSourceRef.APIGroup + pvcSpec.DataSource.APIGroup = &apiGroup + } + } } } diff --git a/pkg/api/persistentvolumeclaim/util_test.go b/pkg/api/persistentvolumeclaim/util_test.go index a0e4f5fec63..945ff2f0446 100644 --- a/pkg/api/persistentvolumeclaim/util_test.go +++ b/pkg/api/persistentvolumeclaim/util_test.go @@ -154,23 +154,47 @@ func TestPVCDataSourceSpecFilter(t *testing.T) { } } -// TestAnyDataSourceFilter checks to ensure the AnyVolumeDataSource feature gate works -func TestAnyDataSourceFilter(t *testing.T) { - makeDataSource := func(apiGroup, kind, name string) *core.TypedLocalObjectReference { - return &core.TypedLocalObjectReference{ - APIGroup: &apiGroup, - Kind: kind, - Name: name, - } - } +var ( + coreGroup = "" + snapGroup = "snapshot.storage.k8s.io" + genericGroup = "generic.storage.k8s.io" + pvcKind = "PersistentVolumeClaim" + snapKind = "VolumeSnapshot" + genericKind = "Generic" + podKind = "Pod" +) - volumeDataSource := makeDataSource("", "PersistentVolumeClaim", "my-vol") +func makeDataSource(apiGroup, kind, name string) *core.TypedLocalObjectReference { + return &core.TypedLocalObjectReference{ + APIGroup: &apiGroup, + Kind: kind, + Name: name, + } +} + +func makeDataSourceRef(apiGroup, kind, name string, namespace *string) *core.TypedObjectReference { + return &core.TypedObjectReference{ + APIGroup: &apiGroup, + Kind: kind, + Name: name, + Namespace: namespace, + } +} + +// TestDataSourceFilter checks to ensure the AnyVolumeDataSource feature gate and CrossNamespaceVolumeDataSource works +func TestDataSourceFilter(t *testing.T) { + ns := "ns1" + volumeDataSource := makeDataSource(coreGroup, pvcKind, "my-vol") + volumeDataSourceRef := makeDataSourceRef(coreGroup, pvcKind, "my-vol", nil) + xnsVolumeDataSourceRef := makeDataSourceRef(coreGroup, pvcKind, "my-vol", &ns) var tests = map[string]struct { spec core.PersistentVolumeClaimSpec + oldSpec core.PersistentVolumeClaimSpec anyEnabled bool + xnsEnabled bool want *core.TypedLocalObjectReference - wantRef *core.TypedLocalObjectReference + wantRef *core.TypedObjectReference }{ "any disabled with empty ds": { spec: core.PersistentVolumeClaimSpec{}, @@ -180,10 +204,10 @@ func TestAnyDataSourceFilter(t *testing.T) { want: volumeDataSource, }, "any disabled with volume ds ref": { - spec: core.PersistentVolumeClaimSpec{DataSourceRef: volumeDataSource}, + spec: core.PersistentVolumeClaimSpec{DataSourceRef: volumeDataSourceRef}, }, "any disabled with both data sources": { - spec: core.PersistentVolumeClaimSpec{DataSource: volumeDataSource, DataSourceRef: volumeDataSource}, + spec: core.PersistentVolumeClaimSpec{DataSource: volumeDataSource, DataSourceRef: volumeDataSourceRef}, want: volumeDataSource, }, "any enabled with empty ds": { @@ -196,25 +220,63 @@ func TestAnyDataSourceFilter(t *testing.T) { want: volumeDataSource, }, "any enabled with volume ds ref": { - spec: core.PersistentVolumeClaimSpec{DataSourceRef: volumeDataSource}, + spec: core.PersistentVolumeClaimSpec{DataSourceRef: volumeDataSourceRef}, anyEnabled: true, - wantRef: volumeDataSource, + wantRef: volumeDataSourceRef, }, "any enabled with both data sources": { - spec: core.PersistentVolumeClaimSpec{DataSource: volumeDataSource, DataSourceRef: volumeDataSource}, + spec: core.PersistentVolumeClaimSpec{DataSource: volumeDataSource, DataSourceRef: volumeDataSourceRef}, anyEnabled: true, want: volumeDataSource, - wantRef: volumeDataSource, + wantRef: volumeDataSourceRef, + }, + "both any and xns enabled with xns volume ds": { + spec: core.PersistentVolumeClaimSpec{DataSourceRef: xnsVolumeDataSourceRef}, + anyEnabled: true, + xnsEnabled: true, + wantRef: xnsVolumeDataSourceRef, + }, + "both any and xns enabled with xns volume ds when xns volume exists in oldSpec": { + spec: core.PersistentVolumeClaimSpec{DataSourceRef: xnsVolumeDataSourceRef}, + oldSpec: core.PersistentVolumeClaimSpec{DataSourceRef: xnsVolumeDataSourceRef}, + anyEnabled: true, + xnsEnabled: true, + wantRef: xnsVolumeDataSourceRef, + }, + "only xns enabled with xns volume ds": { + spec: core.PersistentVolumeClaimSpec{DataSourceRef: xnsVolumeDataSourceRef}, + xnsEnabled: true, + }, + "only any enabled with xns volume ds": { + spec: core.PersistentVolumeClaimSpec{DataSourceRef: xnsVolumeDataSourceRef}, + anyEnabled: true, + }, + "only any enabled with xns volume ds when xns volume exists in oldSpec": { + spec: core.PersistentVolumeClaimSpec{DataSourceRef: xnsVolumeDataSourceRef}, + oldSpec: core.PersistentVolumeClaimSpec{DataSourceRef: xnsVolumeDataSourceRef}, + anyEnabled: true, + wantRef: xnsVolumeDataSourceRef, // existing field isn't dropped. + }, + "only any enabled with xns volume ds when volume exists in oldSpec": { + spec: core.PersistentVolumeClaimSpec{DataSourceRef: xnsVolumeDataSourceRef}, + oldSpec: core.PersistentVolumeClaimSpec{DataSourceRef: volumeDataSourceRef}, + anyEnabled: true, + wantRef: xnsVolumeDataSourceRef, // existing field isn't dropped. }, } for testName, test := range tests { t.Run(testName, func(t *testing.T) { defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.AnyVolumeDataSource, test.anyEnabled)() - DropDisabledFields(&test.spec) - if test.spec.DataSource != test.want || test.spec.DataSourceRef != test.wantRef { - t.Errorf("expected condition was not met, test: %s, anyEnabled: %v, spec: %v, expected: %v %v", - testName, test.anyEnabled, test.spec, test.want, test.wantRef) + defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CrossNamespaceVolumeDataSource, test.xnsEnabled)() + DropDisabledFields(&test.spec, &test.oldSpec) + if test.spec.DataSource != test.want { + t.Errorf("expected condition was not met, test: %s, anyEnabled: %v, xnsEnabled: %v, spec: %+v, expected DataSource: %+v", + testName, test.anyEnabled, test.xnsEnabled, test.spec, test.want) + } + if test.spec.DataSourceRef != test.wantRef { + t.Errorf("expected condition was not met, test: %s, anyEnabled: %v, xnsEnabled: %v, spec: %+v, expected DataSourceRef: %+v", + testName, test.anyEnabled, test.xnsEnabled, test.spec, test.wantRef) } }) } @@ -223,69 +285,99 @@ func TestAnyDataSourceFilter(t *testing.T) { // TestDataSourceRef checks to ensure the DataSourceRef field handles backwards // compatibility with the DataSource field func TestDataSourceRef(t *testing.T) { - makeDataSource := func(apiGroup, kind, name string) *core.TypedLocalObjectReference { - return &core.TypedLocalObjectReference{ - APIGroup: &apiGroup, - Kind: kind, - Name: name, - } - } - - volumeDataSource := makeDataSource("", "PersistentVolumeClaim", "my-vol") - snapshotDataSource := makeDataSource("snapshot.storage.k8s.io", "VolumeSnapshot", "my-snap") - genericDataSource := makeDataSource("generic.storage.k8s.io", "Generic", "my-foo") - coreDataSource := makeDataSource("", "Pod", "my-pod") + ns := "ns1" + volumeDataSource := makeDataSource(coreGroup, pvcKind, "my-vol") + volumeDataSourceRef := makeDataSourceRef(coreGroup, pvcKind, "my-vol", nil) + xnsVolumeDataSourceRef := makeDataSourceRef(coreGroup, pvcKind, "my-vol", &ns) + snapshotDataSource := makeDataSource(snapGroup, snapKind, "my-snap") + snapshotDataSourceRef := makeDataSourceRef(snapGroup, snapKind, "my-snap", nil) + xnsSnapshotDataSourceRef := makeDataSourceRef(snapGroup, snapKind, "my-snap", &ns) + genericDataSource := makeDataSource(genericGroup, genericKind, "my-foo") + genericDataSourceRef := makeDataSourceRef(genericGroup, genericKind, "my-foo", nil) + xnsGenericDataSourceRef := makeDataSourceRef(genericGroup, genericKind, "my-foo", &ns) + coreDataSource := makeDataSource(coreGroup, podKind, "my-pod") + coreDataSourceRef := makeDataSourceRef(coreGroup, podKind, "my-pod", nil) + xnsCoreDataSourceRef := makeDataSourceRef(coreGroup, podKind, "my-pod", &ns) var tests = map[string]struct { - spec core.PersistentVolumeClaimSpec - want *core.TypedLocalObjectReference + spec core.PersistentVolumeClaimSpec + want *core.TypedLocalObjectReference + wantRef *core.TypedObjectReference }{ "empty ds": { spec: core.PersistentVolumeClaimSpec{}, }, "volume ds": { - spec: core.PersistentVolumeClaimSpec{DataSource: volumeDataSource}, - want: volumeDataSource, + spec: core.PersistentVolumeClaimSpec{DataSource: volumeDataSource}, + want: volumeDataSource, + wantRef: volumeDataSourceRef, }, "snapshot ds": { - spec: core.PersistentVolumeClaimSpec{DataSource: snapshotDataSource}, - want: snapshotDataSource, + spec: core.PersistentVolumeClaimSpec{DataSource: snapshotDataSource}, + want: snapshotDataSource, + wantRef: snapshotDataSourceRef, }, "generic ds": { - spec: core.PersistentVolumeClaimSpec{DataSource: genericDataSource}, - want: genericDataSource, + spec: core.PersistentVolumeClaimSpec{DataSource: genericDataSource}, + want: genericDataSource, + wantRef: genericDataSourceRef, }, "core ds": { - spec: core.PersistentVolumeClaimSpec{DataSource: coreDataSource}, - want: coreDataSource, + spec: core.PersistentVolumeClaimSpec{DataSource: coreDataSource}, + want: coreDataSource, + wantRef: coreDataSourceRef, }, "volume ds ref": { - spec: core.PersistentVolumeClaimSpec{DataSourceRef: volumeDataSource}, - want: volumeDataSource, + spec: core.PersistentVolumeClaimSpec{DataSourceRef: volumeDataSourceRef}, + want: volumeDataSource, + wantRef: volumeDataSourceRef, }, "snapshot ds ref": { - spec: core.PersistentVolumeClaimSpec{DataSourceRef: snapshotDataSource}, - want: snapshotDataSource, + spec: core.PersistentVolumeClaimSpec{DataSourceRef: snapshotDataSourceRef}, + want: snapshotDataSource, + wantRef: snapshotDataSourceRef, }, "generic ds ref": { - spec: core.PersistentVolumeClaimSpec{DataSourceRef: genericDataSource}, - want: genericDataSource, + spec: core.PersistentVolumeClaimSpec{DataSourceRef: genericDataSourceRef}, + want: genericDataSource, + wantRef: genericDataSourceRef, }, "core ds ref": { - spec: core.PersistentVolumeClaimSpec{DataSourceRef: coreDataSource}, - want: coreDataSource, + spec: core.PersistentVolumeClaimSpec{DataSourceRef: coreDataSourceRef}, + want: coreDataSource, + wantRef: coreDataSourceRef, + }, + "xns volume ds ref": { + spec: core.PersistentVolumeClaimSpec{DataSourceRef: xnsVolumeDataSourceRef}, + wantRef: xnsVolumeDataSourceRef, + }, + "xns snapshot ds ref": { + spec: core.PersistentVolumeClaimSpec{DataSourceRef: xnsSnapshotDataSourceRef}, + wantRef: xnsSnapshotDataSourceRef, + }, + "xns generic ds ref": { + spec: core.PersistentVolumeClaimSpec{DataSourceRef: xnsGenericDataSourceRef}, + wantRef: xnsGenericDataSourceRef, + }, + "xns core ds ref": { + spec: core.PersistentVolumeClaimSpec{DataSourceRef: xnsCoreDataSourceRef}, + wantRef: xnsCoreDataSourceRef, }, } defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.AnyVolumeDataSource, true)() + defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CrossNamespaceVolumeDataSource, true)() for testName, test := range tests { t.Run(testName, func(t *testing.T) { NormalizeDataSources(&test.spec) - if !reflect.DeepEqual(test.spec.DataSource, test.want) || - !reflect.DeepEqual(test.spec.DataSourceRef, test.want) { - t.Errorf("expected condition was not met, test: %s, spec: %v, expected: %v", - testName, test.spec, test.want) + if !reflect.DeepEqual(test.spec.DataSource, test.want) { + t.Errorf("expected condition was not met, test: %s, spec.datasource: %+v, want: %+v", + testName, test.spec.DataSource, test.want) + } + if !reflect.DeepEqual(test.spec.DataSourceRef, test.wantRef) { + t.Errorf("expected condition was not met, test: %s, spec.datasourceRef: %+v, wantRef: %+v", + testName, test.spec.DataSourceRef, test.wantRef) } }) } diff --git a/pkg/apis/core/types.go b/pkg/apis/core/types.go index 1746640f1db..0622050a17d 100644 --- a/pkg/apis/core/types.go +++ b/pkg/apis/core/types.go @@ -452,29 +452,54 @@ type PersistentVolumeClaimSpec struct { // * An existing PVC (PersistentVolumeClaim) // If the provisioner or an external controller can support the specified data source, // it will create a new volume based on the contents of the specified data source. - // If the AnyVolumeDataSource feature gate is enabled, this field will always have - // the same contents as the DataSourceRef field. + // When the AnyVolumeDataSource feature gate is enabled, dataSource contents will be copied to dataSourceRef, + // and dataSourceRef contents will be copied to dataSource when dataSourceRef.namespace is not specified. + // If the namespace is specified, then dataSourceRef will not be copied to dataSource. // +optional DataSource *TypedLocalObjectReference // Specifies the object from which to populate the volume with data, if a non-empty - // volume is desired. This may be any local object from a non-empty API group (non + // volume is desired. This may be any object from a non-empty API group (non // core object) or a PersistentVolumeClaim object. // When this field is specified, volume binding will only succeed if the type of // the specified object matches some installed volume populator or dynamic // provisioner. - // This field will replace the functionality of the DataSource field and as such + // This field will replace the functionality of the dataSource field and as such // if both fields are non-empty, they must have the same value. For backwards - // compatibility, both fields (DataSource and DataSourceRef) will be set to the same + // compatibility, when namespace isn't specified in dataSourceRef, + // both fields (dataSource and dataSourceRef) will be set to the same // value automatically if one of them is empty and the other is non-empty. - // There are two important differences between DataSource and DataSourceRef: - // * While DataSource only allows two specific types of objects, DataSourceRef + // When namespace is specified in dataSourceRef, + // dataSource isn't set to the same value and must be empty. + // There are three important differences between dataSource and dataSourceRef: + // * While dataSource only allows two specific types of objects, dataSourceRef // allows any non-core object, as well as PersistentVolumeClaim objects. - // * While DataSource ignores disallowed values (dropping them), DataSourceRef + // * While dataSource ignores disallowed values (dropping them), dataSourceRef // preserves all values, and generates an error if a disallowed value is // specified. + // * While dataSource only allows local objects, dataSourceRef allows objects + // in any namespaces. // (Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled. + // (Alpha) Using the namespace field of dataSourceRef requires the CrossNamespaceVolumeDataSource feature gate to be enabled. // +optional - DataSourceRef *TypedLocalObjectReference + DataSourceRef *TypedObjectReference +} + +type TypedObjectReference struct { + // APIGroup is the group for the resource being referenced. + // If APIGroup is not specified, the specified Kind must be in the core API group. + // For any other third-party types, APIGroup is required. + // +optional + APIGroup *string + // Kind is the type of resource being referenced + Kind string + // Name is the name of resource being referenced + Name string + // Namespace is the namespace of resource being referenced + // Note that when a namespace is specified, a gateway.networking.k8s.io/ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details. + // (Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled. + // +featureGate=CrossNamespaceVolumeDataSource + // +optional + Namespace *string } // PersistentVolumeClaimConditionType defines the condition of PV claim. diff --git a/pkg/apis/core/validation/validation.go b/pkg/apis/core/validation/validation.go index 91635d83dca..8c5611cec59 100644 --- a/pkg/apis/core/validation/validation.go +++ b/pkg/apis/core/validation/validation.go @@ -2104,7 +2104,34 @@ func validateDataSource(dataSource *core.TypedLocalObjectReference, fldPath *fie apiGroup = *dataSource.APIGroup } if len(apiGroup) == 0 && dataSource.Kind != "PersistentVolumeClaim" { - allErrs = append(allErrs, field.Invalid(fldPath, dataSource.Kind, "")) + allErrs = append(allErrs, field.Invalid(fldPath, dataSource.Kind, "must be 'PersistentVolumeClaim' when referencing the default apiGroup")) + } + + return allErrs +} + +// validateDataSourceRef validates a DataSourceRef in a PersistentVolumeClaimSpec +func validateDataSourceRef(dataSourceRef *core.TypedObjectReference, fldPath *field.Path) field.ErrorList { + allErrs := field.ErrorList{} + + if len(dataSourceRef.Name) == 0 { + allErrs = append(allErrs, field.Required(fldPath.Child("name"), "")) + } + if len(dataSourceRef.Kind) == 0 { + allErrs = append(allErrs, field.Required(fldPath.Child("kind"), "")) + } + apiGroup := "" + if dataSourceRef.APIGroup != nil { + apiGroup = *dataSourceRef.APIGroup + } + if len(apiGroup) == 0 && dataSourceRef.Kind != "PersistentVolumeClaim" { + allErrs = append(allErrs, field.Invalid(fldPath, dataSourceRef.Kind, "must be 'PersistentVolumeClaim' when referencing the default apiGroup")) + } + + if dataSourceRef.Namespace != nil && len(*dataSourceRef.Namespace) > 0 { + for _, msg := range ValidateNameFunc(ValidateNamespaceName)(*dataSourceRef.Namespace, false) { + allErrs = append(allErrs, field.Invalid(fldPath.Child("namespace"), *dataSourceRef.Namespace, msg)) + } } return allErrs @@ -2166,10 +2193,15 @@ func ValidatePersistentVolumeClaimSpec(spec *core.PersistentVolumeClaimSpec, fld allErrs = append(allErrs, validateDataSource(spec.DataSource, fldPath.Child("dataSource"))...) } if spec.DataSourceRef != nil { - allErrs = append(allErrs, validateDataSource(spec.DataSourceRef, fldPath.Child("dataSourceRef"))...) + allErrs = append(allErrs, validateDataSourceRef(spec.DataSourceRef, fldPath.Child("dataSourceRef"))...) } - if spec.DataSource != nil && spec.DataSourceRef != nil { - if !apiequality.Semantic.DeepEqual(spec.DataSource, spec.DataSourceRef) { + if spec.DataSourceRef != nil && spec.DataSourceRef.Namespace != nil && len(*spec.DataSourceRef.Namespace) > 0 { + if spec.DataSource != nil { + allErrs = append(allErrs, field.Invalid(fldPath, fldPath.Child("dataSource"), + "may not be specified when dataSourceRef.namespace is specified")) + } + } else if spec.DataSource != nil && spec.DataSourceRef != nil { + if !isDataSourceEqualDataSourceRef(spec.DataSource, spec.DataSourceRef) { allErrs = append(allErrs, field.Invalid(fldPath, fldPath.Child("dataSource"), "must match dataSourceRef")) } @@ -2178,6 +2210,10 @@ func ValidatePersistentVolumeClaimSpec(spec *core.PersistentVolumeClaimSpec, fld return allErrs } +func isDataSourceEqualDataSourceRef(dataSource *core.TypedLocalObjectReference, dataSourceRef *core.TypedObjectReference) bool { + return reflect.DeepEqual(dataSource.APIGroup, dataSourceRef.APIGroup) && dataSource.Kind == dataSourceRef.Kind && dataSource.Name == dataSourceRef.Name +} + // ValidatePersistentVolumeClaimUpdate validates an update to a PersistentVolumeClaim func ValidatePersistentVolumeClaimUpdate(newPvc, oldPvc *core.PersistentVolumeClaim, opts PersistentVolumeClaimSpecValidationOptions) field.ErrorList { allErrs := ValidateObjectMetaUpdate(&newPvc.ObjectMeta, &oldPvc.ObjectMeta, field.NewPath("metadata")) diff --git a/pkg/apis/core/validation/validation_test.go b/pkg/apis/core/validation/validation_test.go index 15629884d56..9947b30045b 100644 --- a/pkg/apis/core/validation/validation_test.go +++ b/pkg/apis/core/validation/validation_test.go @@ -1672,7 +1672,7 @@ func testValidatePVC(t *testing.T, ephemeral bool) { Kind: "PersistentVolumeClaim", Name: "pvc1", }, - DataSourceRef: &core.TypedLocalObjectReference{ + DataSourceRef: &core.TypedObjectReference{ Kind: "PersistentVolumeClaim", Name: "pvc2", }, @@ -19816,7 +19816,11 @@ func testAnyDataSource(t *testing.T, ds, dsRef bool) { for _, tc := range testCases { if dsRef { - tc.claimSpec.DataSourceRef = tc.claimSpec.DataSource.DeepCopy() + tc.claimSpec.DataSourceRef = &core.TypedObjectReference{ + APIGroup: tc.claimSpec.DataSource.APIGroup, + Kind: tc.claimSpec.DataSource.Kind, + Name: tc.claimSpec.DataSource.Name, + } } if !ds { tc.claimSpec.DataSource = nil @@ -19840,6 +19844,110 @@ func TestAnyDataSource(t *testing.T) { testAnyDataSource(t, true, false) } +func pvcSpecWithCrossNamespaceSource(apiGroup *string, kind string, namespace *string, name string, isDataSourceSet bool) *core.PersistentVolumeClaimSpec { + scName := "csi-plugin" + spec := core.PersistentVolumeClaimSpec{ + AccessModes: []core.PersistentVolumeAccessMode{ + core.ReadOnlyMany, + }, + Resources: core.ResourceRequirements{ + Requests: core.ResourceList{ + core.ResourceName(core.ResourceStorage): resource.MustParse("10G"), + }, + }, + StorageClassName: &scName, + DataSourceRef: &core.TypedObjectReference{ + APIGroup: apiGroup, + Kind: kind, + Namespace: namespace, + Name: name, + }, + } + + if isDataSourceSet { + spec.DataSource = &core.TypedLocalObjectReference{ + APIGroup: apiGroup, + Kind: kind, + Name: name, + } + } + return &spec +} + +func TestCrossNamespaceSource(t *testing.T) { + snapAPIGroup := "snapshot.storage.k8s.io" + coreAPIGroup := "" + unsupportedAPIGroup := "unsupported.example.com" + snapKind := "VolumeSnapshot" + pvcKind := "PersistentVolumeClaim" + goodNS := "ns1" + badNS := "a*b" + emptyNS := "" + goodName := "snapshot1" + + testCases := []struct { + testName string + expectedFail bool + claimSpec *core.PersistentVolumeClaimSpec + }{ + { + testName: "Feature gate enabled and valid xns DataSourceRef specified", + expectedFail: false, + claimSpec: pvcSpecWithCrossNamespaceSource(&snapAPIGroup, snapKind, &goodNS, goodName, false), + }, + { + testName: "Feature gate enabled and xns DataSourceRef with PVC source specified", + expectedFail: false, + claimSpec: pvcSpecWithCrossNamespaceSource(&coreAPIGroup, pvcKind, &goodNS, goodName, false), + }, + { + testName: "Feature gate enabled and xns DataSourceRef with unsupported source specified", + expectedFail: false, + claimSpec: pvcSpecWithCrossNamespaceSource(&unsupportedAPIGroup, "UnsupportedKind", &goodNS, goodName, false), + }, + { + testName: "Feature gate enabled and xns DataSourceRef with nil apiGroup", + expectedFail: true, + claimSpec: pvcSpecWithCrossNamespaceSource(nil, "UnsupportedKind", &goodNS, goodName, false), + }, + { + testName: "Feature gate enabled and xns DataSourceRef with invalid namspace specified", + expectedFail: true, + claimSpec: pvcSpecWithCrossNamespaceSource(&snapAPIGroup, snapKind, &badNS, goodName, false), + }, + { + testName: "Feature gate enabled and xns DataSourceRef with nil namspace specified", + expectedFail: false, + claimSpec: pvcSpecWithCrossNamespaceSource(&snapAPIGroup, snapKind, nil, goodName, false), + }, + { + testName: "Feature gate enabled and xns DataSourceRef with empty namspace specified", + expectedFail: false, + claimSpec: pvcSpecWithCrossNamespaceSource(&snapAPIGroup, snapKind, &emptyNS, goodName, false), + }, + { + testName: "Feature gate enabled and both xns DataSourceRef and DataSource specified", + expectedFail: true, + claimSpec: pvcSpecWithCrossNamespaceSource(&snapAPIGroup, snapKind, &goodNS, goodName, true), + }, + } + + for _, tc := range testCases { + defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.AnyVolumeDataSource, true)() + defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CrossNamespaceVolumeDataSource, true)() + opts := PersistentVolumeClaimSpecValidationOptions{} + if tc.expectedFail { + if errs := ValidatePersistentVolumeClaimSpec(tc.claimSpec, field.NewPath("spec"), opts); len(errs) == 0 { + t.Errorf("%s: expected failure: %v", tc.testName, errs) + } + } else { + if errs := ValidatePersistentVolumeClaimSpec(tc.claimSpec, field.NewPath("spec"), opts); len(errs) != 0 { + t.Errorf("%s: expected success: %v", tc.testName, errs) + } + } + } +} + func TestValidateTopologySpreadConstraints(t *testing.T) { fieldPath := field.NewPath("field") subFldPath0 := fieldPath.Index(0) diff --git a/pkg/features/kube_features.go b/pkg/features/kube_features.go index e4abde3d789..a84d7368e7b 100644 --- a/pkg/features/kube_features.go +++ b/pkg/features/kube_features.go @@ -36,6 +36,13 @@ const ( // of code conflicts because changes are more likely to be scattered // across the file. + // owner: @ttakahashi21 @mkimuram + // kep: https://kep.k8s.io/3294 + // alpha: v1.26 + // + // Enable usage of Provision of PVCs from snapshots in other namespaces + CrossNamespaceVolumeDataSource featuregate.Feature = "CrossNamespaceVolumeDataSource" + // owner: @bswartz // alpha: v1.18 // beta: v1.24 @@ -893,6 +900,8 @@ func init() { // Entries are separated from each other with blank lines to avoid sweeping gofmt changes // when adding or removing one entry. var defaultKubernetesFeatureGates = map[featuregate.Feature]featuregate.FeatureSpec{ + CrossNamespaceVolumeDataSource: {Default: false, PreRelease: featuregate.Alpha}, + AnyVolumeDataSource: {Default: true, PreRelease: featuregate.Beta}, // on by default in 1.24 APISelfSubjectReview: {Default: false, PreRelease: featuregate.Alpha}, diff --git a/pkg/registry/core/persistentvolumeclaim/storage/storage_test.go b/pkg/registry/core/persistentvolumeclaim/storage/storage_test.go index 5cbdc2a65ca..54c0ca625f5 100644 --- a/pkg/registry/core/persistentvolumeclaim/storage/storage_test.go +++ b/pkg/registry/core/persistentvolumeclaim/storage/storage_test.go @@ -216,11 +216,14 @@ func TestDefaultOnReadPvc(t *testing.T) { storage, _, server := newStorage(t) defer server.Terminate(t) defer storage.Store.DestroyFunc() - dataSource := api.TypedLocalObjectReference{ Kind: "PersistentVolumeClaim", Name: "my-pvc", } + dataSourceRef := api.TypedObjectReference{ + Kind: "PersistentVolumeClaim", + Name: "my-pvc", + } var tests = map[string]struct { anyEnabled bool @@ -278,15 +281,15 @@ func TestDefaultOnReadPvc(t *testing.T) { pvc.Spec.DataSource = dataSource.DeepCopy() } if test.dataSourceRef { - pvc.Spec.DataSourceRef = dataSource.DeepCopy() + pvc.Spec.DataSourceRef = dataSourceRef.DeepCopy() } var expectDataSource *api.TypedLocalObjectReference if test.want { expectDataSource = &dataSource } - var expectDataSourceRef *api.TypedLocalObjectReference + var expectDataSourceRef *api.TypedObjectReference if test.wantRef { - expectDataSourceRef = &dataSource + expectDataSourceRef = &dataSourceRef } // Method under test diff --git a/pkg/registry/core/persistentvolumeclaim/strategy.go b/pkg/registry/core/persistentvolumeclaim/strategy.go index 14bf61e2b33..2352c8edc4e 100644 --- a/pkg/registry/core/persistentvolumeclaim/strategy.go +++ b/pkg/registry/core/persistentvolumeclaim/strategy.go @@ -65,7 +65,7 @@ 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) + pvcutil.DropDisabledFields(&pvc.Spec, nil) // For data sources, we need to do 2 things to implement KEP 1495 @@ -103,7 +103,7 @@ func (persistentvolumeclaimStrategy) PrepareForUpdate(ctx context.Context, obj, oldPvc := old.(*api.PersistentVolumeClaim) newPvc.Status = oldPvc.Status - pvcutil.DropDisabledFields(&newPvc.Spec) + pvcutil.DropDisabledFields(&newPvc.Spec, &oldPvc.Spec) // We need to use similar logic to PrepareForCreate here both to preserve backwards // compatibility with the old behavior (ignoring of garbage dataSources at both create diff --git a/pkg/registry/core/persistentvolumeclaim/strategy_test.go b/pkg/registry/core/persistentvolumeclaim/strategy_test.go index 1f6a332a9b9..a868b8bb922 100644 --- a/pkg/registry/core/persistentvolumeclaim/strategy_test.go +++ b/pkg/registry/core/persistentvolumeclaim/strategy_test.go @@ -107,28 +107,58 @@ func TestDropConditions(t *testing.T) { } +var ( + coreGroup = "" + snapGroup = "snapshot.storage.k8s.io" + genericGroup = "generic.storage.k8s.io" + pvcKind = "PersistentVolumeClaim" + snapKind = "VolumeSnapshot" + genericKind = "Generic" + podKind = "Pod" +) + +func makeDataSource(apiGroup, kind, name string) *api.TypedLocalObjectReference { + return &api.TypedLocalObjectReference{ + APIGroup: &apiGroup, + Kind: kind, + Name: name, + } + +} + +func makeDataSourceRef(apiGroup, kind, name string, namespace *string) *api.TypedObjectReference { + return &api.TypedObjectReference{ + APIGroup: &apiGroup, + Kind: kind, + Name: name, + Namespace: namespace, + } +} + func TestPrepareForCreate(t *testing.T) { ctx := genericapirequest.NewDefaultContext() - makeDataSource := func(apiGroup, kind, name string) *api.TypedLocalObjectReference { - return &api.TypedLocalObjectReference{ - APIGroup: &apiGroup, - Kind: kind, - Name: name, - } - } - - volumeDataSource := makeDataSource("", "PersistentVolumeClaim", "my-vol") - snapshotDataSource := makeDataSource("snapshot.storage.k8s.io", "VolumeSnapshot", "my-snap") - genericDataSource := makeDataSource("generic.storage.k8s.io", "Generic", "my-foo") - coreDataSource := makeDataSource("", "Pod", "my-pod") + ns := "ns1" + volumeDataSource := makeDataSource(coreGroup, pvcKind, "my-vol") + volumeDataSourceRef := makeDataSourceRef(coreGroup, pvcKind, "my-vol", nil) + xnsVolumeDataSourceRef := makeDataSourceRef(coreGroup, pvcKind, "my-vol", &ns) + snapshotDataSource := makeDataSource(snapGroup, snapKind, "my-snap") + snapshotDataSourceRef := makeDataSourceRef(snapGroup, snapKind, "my-snap", nil) + xnsSnapshotDataSourceRef := makeDataSourceRef(snapGroup, snapKind, "my-snap", &ns) + genericDataSource := makeDataSource(genericGroup, genericKind, "my-foo") + genericDataSourceRef := makeDataSourceRef(genericGroup, genericKind, "my-foo", nil) + xnsGenericDataSourceRef := makeDataSourceRef(genericGroup, genericKind, "my-foo", &ns) + coreDataSource := makeDataSource(coreGroup, podKind, "my-pod") + coreDataSourceRef := makeDataSourceRef(coreGroup, podKind, "my-pod", nil) + xnsCoreDataSourceRef := makeDataSourceRef(coreGroup, podKind, "my-pod", &ns) var tests = map[string]struct { anyEnabled bool + xnsEnabled bool dataSource *api.TypedLocalObjectReference - dataSourceRef *api.TypedLocalObjectReference + dataSourceRef *api.TypedObjectReference want *api.TypedLocalObjectReference - wantRef *api.TypedLocalObjectReference + wantRef *api.TypedObjectReference }{ "any disabled with empty ds": { want: nil, @@ -150,16 +180,16 @@ func TestPrepareForCreate(t *testing.T) { want: nil, }, "any disabled with volume ds ref": { - dataSourceRef: volumeDataSource, + dataSourceRef: volumeDataSourceRef, }, "any disabled with snapshot ds ref": { - dataSourceRef: snapshotDataSource, + dataSourceRef: snapshotDataSourceRef, }, "any disabled with generic ds ref": { - dataSourceRef: genericDataSource, + dataSourceRef: genericDataSourceRef, }, "any disabled with invalid ds ref": { - dataSourceRef: coreDataSource, + dataSourceRef: coreDataSourceRef, }, "any enabled with empty ds": { anyEnabled: true, @@ -169,13 +199,13 @@ func TestPrepareForCreate(t *testing.T) { dataSource: volumeDataSource, anyEnabled: true, want: volumeDataSource, - wantRef: volumeDataSource, + wantRef: volumeDataSourceRef, }, "any enabled with snapshot ds": { dataSource: snapshotDataSource, anyEnabled: true, want: snapshotDataSource, - wantRef: snapshotDataSource, + wantRef: snapshotDataSourceRef, }, "any enabled with generic ds": { dataSource: genericDataSource, @@ -186,41 +216,135 @@ func TestPrepareForCreate(t *testing.T) { anyEnabled: true, }, "any enabled with volume ds ref": { - dataSourceRef: volumeDataSource, + dataSourceRef: volumeDataSourceRef, anyEnabled: true, want: volumeDataSource, - wantRef: volumeDataSource, + wantRef: volumeDataSourceRef, }, "any enabled with snapshot ds ref": { - dataSourceRef: snapshotDataSource, + dataSourceRef: snapshotDataSourceRef, anyEnabled: true, want: snapshotDataSource, - wantRef: snapshotDataSource, + wantRef: snapshotDataSourceRef, }, "any enabled with generic ds ref": { - dataSourceRef: genericDataSource, + dataSourceRef: genericDataSourceRef, anyEnabled: true, want: genericDataSource, - wantRef: genericDataSource, + wantRef: genericDataSourceRef, }, "any enabled with invalid ds ref": { - dataSourceRef: coreDataSource, + dataSourceRef: coreDataSourceRef, anyEnabled: true, want: coreDataSource, - wantRef: coreDataSource, + wantRef: coreDataSourceRef, }, "any enabled with mismatched data sources": { dataSource: volumeDataSource, - dataSourceRef: snapshotDataSource, + dataSourceRef: snapshotDataSourceRef, anyEnabled: true, want: volumeDataSource, - wantRef: snapshotDataSource, + wantRef: snapshotDataSourceRef, + }, + "both any and xns enabled with empty ds": { + anyEnabled: true, + xnsEnabled: true, + want: nil, + }, + "both any and xns enabled with volume ds": { + dataSource: volumeDataSource, + anyEnabled: true, + xnsEnabled: true, + want: volumeDataSource, + wantRef: volumeDataSourceRef, + }, + "both any and xns enabled with snapshot ds": { + dataSource: snapshotDataSource, + anyEnabled: true, + xnsEnabled: true, + want: snapshotDataSource, + wantRef: snapshotDataSourceRef, + }, + "both any and xns enabled with generic ds": { + dataSource: genericDataSource, + anyEnabled: true, + xnsEnabled: true, + }, + "both any and xns enabled with invalid ds": { + dataSource: coreDataSource, + anyEnabled: true, + xnsEnabled: true, + }, + "both any and xns enabled with volume ds ref": { + dataSourceRef: volumeDataSourceRef, + anyEnabled: true, + xnsEnabled: true, + want: volumeDataSource, + wantRef: volumeDataSourceRef, + }, + "both any and xns enabled with snapshot ds ref": { + dataSourceRef: snapshotDataSourceRef, + anyEnabled: true, + xnsEnabled: true, + want: snapshotDataSource, + wantRef: snapshotDataSourceRef, + }, + "both any and xns enabled with generic ds ref": { + dataSourceRef: genericDataSourceRef, + anyEnabled: true, + xnsEnabled: true, + want: genericDataSource, + wantRef: genericDataSourceRef, + }, + "both any and xns enabled with invalid ds ref": { + dataSourceRef: coreDataSourceRef, + anyEnabled: true, + xnsEnabled: true, + want: coreDataSource, + wantRef: coreDataSourceRef, + }, + "both any and xns enabled with mismatched data sources": { + dataSource: volumeDataSource, + dataSourceRef: snapshotDataSourceRef, + anyEnabled: true, + xnsEnabled: true, + want: volumeDataSource, + wantRef: snapshotDataSourceRef, + }, + "both any and xns enabled with volume xns ds ref": { + dataSourceRef: xnsVolumeDataSourceRef, + anyEnabled: true, + xnsEnabled: true, + wantRef: xnsVolumeDataSourceRef, + }, + "both any and xns enabled with snapshot xns ds ref": { + dataSourceRef: xnsSnapshotDataSourceRef, + anyEnabled: true, + xnsEnabled: true, + wantRef: xnsSnapshotDataSourceRef, + }, + "both any and xns enabled with generic xns ds ref": { + dataSourceRef: xnsGenericDataSourceRef, + anyEnabled: true, + xnsEnabled: true, + wantRef: xnsGenericDataSourceRef, + }, + "both any and xns enabled with invalid xns ds ref": { + dataSourceRef: xnsCoreDataSourceRef, + anyEnabled: true, + xnsEnabled: true, + wantRef: xnsCoreDataSourceRef, + }, + "only xns enabled with snapshot xns ds ref": { + dataSourceRef: xnsSnapshotDataSourceRef, + xnsEnabled: true, }, } for testName, test := range tests { t.Run(testName, func(t *testing.T) { defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.AnyVolumeDataSource, test.anyEnabled)() + defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CrossNamespaceVolumeDataSource, test.xnsEnabled)() pvc := api.PersistentVolumeClaim{ Spec: api.PersistentVolumeClaimSpec{ DataSource: test.dataSource, diff --git a/staging/src/k8s.io/api/core/v1/types.go b/staging/src/k8s.io/api/core/v1/types.go index bae7e8940b1..0b8ecc6b270 100644 --- a/staging/src/k8s.io/api/core/v1/types.go +++ b/staging/src/k8s.io/api/core/v1/types.go @@ -497,29 +497,54 @@ type PersistentVolumeClaimSpec struct { // * An existing PVC (PersistentVolumeClaim) // If the provisioner or an external controller can support the specified data source, // it will create a new volume based on the contents of the specified data source. - // If the AnyVolumeDataSource feature gate is enabled, this field will always have - // the same contents as the DataSourceRef field. + // When the AnyVolumeDataSource feature gate is enabled, dataSource contents will be copied to dataSourceRef, + // and dataSourceRef contents will be copied to dataSource when dataSourceRef.namespace is not specified. + // If the namespace is specified, then dataSourceRef will not be copied to dataSource. // +optional DataSource *TypedLocalObjectReference `json:"dataSource,omitempty" protobuf:"bytes,7,opt,name=dataSource"` // dataSourceRef specifies the object from which to populate the volume with data, if a non-empty - // volume is desired. This may be any local object from a non-empty API group (non + // volume is desired. This may be any object from a non-empty API group (non // core object) or a PersistentVolumeClaim object. // When this field is specified, volume binding will only succeed if the type of // the specified object matches some installed volume populator or dynamic // provisioner. - // This field will replace the functionality of the DataSource field and as such + // This field will replace the functionality of the dataSource field and as such // if both fields are non-empty, they must have the same value. For backwards - // compatibility, both fields (DataSource and DataSourceRef) will be set to the same + // compatibility, when namespace isn't specified in dataSourceRef, + // both fields (dataSource and dataSourceRef) will be set to the same // value automatically if one of them is empty and the other is non-empty. - // There are two important differences between DataSource and DataSourceRef: - // * While DataSource only allows two specific types of objects, DataSourceRef + // When namespace is specified in dataSourceRef, + // dataSource isn't set to the same value and must be empty. + // There are three important differences between dataSource and dataSourceRef: + // * While dataSource only allows two specific types of objects, dataSourceRef // allows any non-core object, as well as PersistentVolumeClaim objects. - // * While DataSource ignores disallowed values (dropping them), DataSourceRef + // * While dataSource ignores disallowed values (dropping them), dataSourceRef // preserves all values, and generates an error if a disallowed value is // specified. + // * While dataSource only allows local objects, dataSourceRef allows objects + // in any namespaces. // (Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled. + // (Alpha) Using the namespace field of dataSourceRef requires the CrossNamespaceVolumeDataSource feature gate to be enabled. // +optional - DataSourceRef *TypedLocalObjectReference `json:"dataSourceRef,omitempty" protobuf:"bytes,8,opt,name=dataSourceRef"` + DataSourceRef *TypedObjectReference `json:"dataSourceRef,omitempty" protobuf:"bytes,8,opt,name=dataSourceRef"` +} + +type TypedObjectReference struct { + // APIGroup is the group for the resource being referenced. + // If APIGroup is not specified, the specified Kind must be in the core API group. + // For any other third-party types, APIGroup is required. + // +optional + APIGroup *string `json:"apiGroup" protobuf:"bytes,1,opt,name=apiGroup"` + // Kind is the type of resource being referenced + Kind string `json:"kind" protobuf:"bytes,2,opt,name=kind"` + // Name is the name of resource being referenced + Name string `json:"name" protobuf:"bytes,3,opt,name=name"` + // Namespace is the namespace of resource being referenced + // Note that when a namespace is specified, a gateway.networking.k8s.io/ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details. + // (Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled. + // +featureGate=CrossNamespaceVolumeDataSource + // +optional + Namespace *string `json:"namespace,omitempty" protobuf:"bytes,4,opt,name=namespace"` } // PersistentVolumeClaimConditionType is a valid value of PersistentVolumeClaimCondition.Type diff --git a/test/e2e/storage/testsuites/multivolume.go b/test/e2e/storage/testsuites/multivolume.go index 002fa166ef5..3a96a391558 100644 --- a/test/e2e/storage/testsuites/multivolume.go +++ b/test/e2e/storage/testsuites/multivolume.go @@ -342,7 +342,7 @@ func (t *multiVolumeTestSuite) DefineTests(driver storageframework.TestDriver, p } testConfig := storageframework.ConvertTestConfig(l.config) dc := l.config.Framework.DynamicClient - dataSource := prepareSnapshotDataSourceForProvisioning(ctx, f, testConfig, l.config, pattern, l.cs, dc, resource.Pvc, resource.Sc, sDriver, pattern.VolMode, expectedContent) + dataSourceRef := prepareSnapshotDataSourceForProvisioning(ctx, f, testConfig, l.config, pattern, l.cs, dc, resource.Pvc, resource.Sc, sDriver, pattern.VolMode, expectedContent) // Create 2nd PVC for testing pvc2 := &v1.PersistentVolumeClaim{ @@ -353,7 +353,7 @@ func (t *multiVolumeTestSuite) DefineTests(driver storageframework.TestDriver, p } resource.Pvc.Spec.DeepCopyInto(&pvc2.Spec) pvc2.Spec.VolumeName = "" - pvc2.Spec.DataSource = dataSource + pvc2.Spec.DataSourceRef = dataSourceRef pvc2, err := l.cs.CoreV1().PersistentVolumeClaims(pvc2.Namespace).Create(context.TODO(), pvc2, metav1.CreateOptions{}) framework.ExpectNoError(err) @@ -386,7 +386,7 @@ func (t *multiVolumeTestSuite) DefineTests(driver storageframework.TestDriver, p l.resources = append(l.resources, resource) pvcs := []*v1.PersistentVolumeClaim{resource.Pvc} testConfig := storageframework.ConvertTestConfig(l.config) - dataSource := preparePVCDataSourceForProvisioning(ctx, f, testConfig, l.cs, resource.Pvc, resource.Sc, pattern.VolMode, expectedContent) + dataSourceRef := preparePVCDataSourceForProvisioning(ctx, f, testConfig, l.cs, resource.Pvc, resource.Sc, pattern.VolMode, expectedContent) // Create 2nd PVC for testing pvc2 := &v1.PersistentVolumeClaim{ @@ -397,7 +397,7 @@ func (t *multiVolumeTestSuite) DefineTests(driver storageframework.TestDriver, p } resource.Pvc.Spec.DeepCopyInto(&pvc2.Spec) pvc2.Spec.VolumeName = "" - pvc2.Spec.DataSource = dataSource + pvc2.Spec.DataSourceRef = dataSourceRef pvc2, err := l.cs.CoreV1().PersistentVolumeClaims(pvc2.Namespace).Create(context.TODO(), pvc2, metav1.CreateOptions{}) framework.ExpectNoError(err) diff --git a/test/e2e/storage/testsuites/provisioning.go b/test/e2e/storage/testsuites/provisioning.go index 70e4086b8f6..5a18638d25f 100644 --- a/test/e2e/storage/testsuites/provisioning.go +++ b/test/e2e/storage/testsuites/provisioning.go @@ -214,9 +214,9 @@ func (p *provisioningTestSuite) DefineTests(driver storageframework.TestDriver, dc := l.config.Framework.DynamicClient testConfig := storageframework.ConvertTestConfig(l.config) expectedContent := fmt.Sprintf("Hello from namespace %s", f.Namespace.Name) - dataSource := prepareSnapshotDataSourceForProvisioning(ctx, f, testConfig, l.config, pattern, l.cs, dc, l.pvc, l.sc, sDriver, pattern.VolMode, expectedContent) + dataSourceRef := prepareSnapshotDataSourceForProvisioning(ctx, f, testConfig, l.config, pattern, l.cs, dc, l.pvc, l.sc, sDriver, pattern.VolMode, expectedContent) - l.pvc.Spec.DataSource = dataSource + l.pvc.Spec.DataSourceRef = dataSourceRef l.testCase.PvCheck = func(claim *v1.PersistentVolumeClaim) { ginkgo.By("checking whether the created volume has the pre-populated data") tests := []e2evolume.Test{ @@ -386,7 +386,7 @@ func (p *provisioningTestSuite) DefineTests(driver storageframework.TestDriver, }() apiGroup := "hello.example.com" - l.pvc.Spec.DataSourceRef = &v1.TypedLocalObjectReference{ + l.pvc.Spec.DataSourceRef = &v1.TypedObjectReference{ APIGroup: &apiGroup, Kind: "Hello", Name: helloCRName, @@ -427,8 +427,8 @@ func (p *provisioningTestSuite) DefineTests(driver storageframework.TestDriver, } testConfig := storageframework.ConvertTestConfig(l.config) expectedContent := fmt.Sprintf("Hello from namespace %s", f.Namespace.Name) - dataSource := preparePVCDataSourceForProvisioning(ctx, f, testConfig, l.cs, l.sourcePVC, l.sc, pattern.VolMode, expectedContent) - l.pvc.Spec.DataSource = dataSource + dataSourceRef := preparePVCDataSourceForProvisioning(ctx, f, testConfig, l.cs, l.sourcePVC, l.sc, pattern.VolMode, expectedContent) + l.pvc.Spec.DataSourceRef = dataSourceRef l.testCase.NodeSelection = testConfig.ClientNodeSelection l.testCase.PvCheck = func(claim *v1.PersistentVolumeClaim) { ginkgo.By("checking whether the created volume has the pre-populated data") @@ -443,7 +443,7 @@ func (p *provisioningTestSuite) DefineTests(driver storageframework.TestDriver, e2evolume.TestVolumeClientSlow(f, testConfig, nil, "", tests) } // Cloning fails if the source disk is still in the process of detaching, so we wait for the VolumeAttachment to be removed before cloning. - volumeAttachment := e2evolume.GetVolumeAttachmentName(f.ClientSet, testConfig, l.testCase.Provisioner, dataSource.Name, l.sourcePVC.Namespace) + volumeAttachment := e2evolume.GetVolumeAttachmentName(f.ClientSet, testConfig, l.testCase.Provisioner, dataSourceRef.Name, l.sourcePVC.Namespace) e2evolume.WaitForVolumeAttachmentTerminated(volumeAttachment, f.ClientSet, f.Timeouts.DataSourceProvision) l.testCase.TestDynamicProvisioning(ctx) }) @@ -468,8 +468,8 @@ func (p *provisioningTestSuite) DefineTests(driver storageframework.TestDriver, } testConfig := storageframework.ConvertTestConfig(l.config) expectedContent := fmt.Sprintf("Hello from namespace %s", f.Namespace.Name) - dataSource := preparePVCDataSourceForProvisioning(ctx, f, testConfig, l.cs, l.sourcePVC, l.sc, pattern.VolMode, expectedContent) - l.pvc.Spec.DataSource = dataSource + dataSourceRef := preparePVCDataSourceForProvisioning(ctx, f, testConfig, l.cs, l.sourcePVC, l.sc, pattern.VolMode, expectedContent) + l.pvc.Spec.DataSourceRef = dataSourceRef var wg sync.WaitGroup for i := 0; i < 5; i++ { @@ -497,7 +497,7 @@ func (p *provisioningTestSuite) DefineTests(driver storageframework.TestDriver, e2evolume.TestVolumeClientSlow(f, myTestConfig, nil, "", tests) } // Cloning fails if the source disk is still in the process of detaching, so we wait for the VolumeAttachment to be removed before cloning. - volumeAttachment := e2evolume.GetVolumeAttachmentName(f.ClientSet, testConfig, l.testCase.Provisioner, dataSource.Name, l.sourcePVC.Namespace) + volumeAttachment := e2evolume.GetVolumeAttachmentName(f.ClientSet, testConfig, l.testCase.Provisioner, dataSourceRef.Name, l.sourcePVC.Namespace) e2evolume.WaitForVolumeAttachmentTerminated(volumeAttachment, f.ClientSet, f.Timeouts.DataSourceProvision) t.TestDynamicProvisioning(ctx) }(i) @@ -1049,7 +1049,7 @@ func prepareSnapshotDataSourceForProvisioning( sDriver storageframework.SnapshottableTestDriver, mode v1.PersistentVolumeMode, injectContent string, -) *v1.TypedLocalObjectReference { +) *v1.TypedObjectReference { SetupStorageClass(ctx, client, class) if initClaim.ResourceVersion != "" { @@ -1078,7 +1078,7 @@ func prepareSnapshotDataSourceForProvisioning( parameters := map[string]string{} snapshotResource := storageframework.CreateSnapshotResource(sDriver, perTestConfig, pattern, initClaim.GetName(), initClaim.GetNamespace(), f.Timeouts, parameters) group := "snapshot.storage.k8s.io" - dataSourceRef := &v1.TypedLocalObjectReference{ + dataSourceRef := &v1.TypedObjectReference{ APIGroup: &group, Kind: "VolumeSnapshot", Name: snapshotResource.Vs.GetName(), @@ -1108,7 +1108,7 @@ func preparePVCDataSourceForProvisioning( class *storagev1.StorageClass, mode v1.PersistentVolumeMode, injectContent string, -) *v1.TypedLocalObjectReference { +) *v1.TypedObjectReference { SetupStorageClass(ctx, client, class) if source.ResourceVersion != "" { @@ -1130,7 +1130,7 @@ func preparePVCDataSourceForProvisioning( } e2evolume.InjectContent(f, config, nil, "", tests) - dataSourceRef := &v1.TypedLocalObjectReference{ + dataSourceRef := &v1.TypedObjectReference{ Kind: "PersistentVolumeClaim", Name: source.GetName(), } From cb12a2bc5118fe34e2eb396dc1a3b8e7cc1de9f4 Mon Sep 17 00:00:00 2001 From: Takafumi Takahashi Date: Wed, 9 Nov 2022 21:21:52 +0000 Subject: [PATCH 2/2] Generate code --- api/openapi-spec/swagger.json | 31 +- api/openapi-spec/v3/api__v1_openapi.json | 33 +- .../v3/apis__apps__v1_openapi.json | 33 +- .../v3/apis__batch__v1_openapi.json | 33 +- pkg/apis/core/v1/zz_generated.conversion.go | 40 +- pkg/apis/core/zz_generated.deepcopy.go | 28 +- pkg/generated/openapi/zz_generated.openapi.go | 52 +- .../src/k8s.io/api/core/v1/generated.pb.go | 2118 ++++++++++------- .../src/k8s.io/api/core/v1/generated.proto | 46 +- .../core/v1/types_swagger_doc_generated.go | 15 +- .../api/core/v1/zz_generated.deepcopy.go | 28 +- .../api/testdata/HEAD/apps.v1.DaemonSet.json | 3 +- .../api/testdata/HEAD/apps.v1.DaemonSet.pb | Bin 9910 -> 9926 bytes .../api/testdata/HEAD/apps.v1.DaemonSet.yaml | 1 + .../api/testdata/HEAD/apps.v1.Deployment.json | 3 +- .../api/testdata/HEAD/apps.v1.Deployment.pb | Bin 9923 -> 9939 bytes .../api/testdata/HEAD/apps.v1.Deployment.yaml | 1 + .../api/testdata/HEAD/apps.v1.ReplicaSet.json | 3 +- .../api/testdata/HEAD/apps.v1.ReplicaSet.pb | Bin 9840 -> 9856 bytes .../api/testdata/HEAD/apps.v1.ReplicaSet.yaml | 1 + .../testdata/HEAD/apps.v1.StatefulSet.json | 6 +- .../api/testdata/HEAD/apps.v1.StatefulSet.pb | Bin 10826 -> 10858 bytes .../testdata/HEAD/apps.v1.StatefulSet.yaml | 2 + .../HEAD/apps.v1beta1.Deployment.json | 3 +- .../testdata/HEAD/apps.v1beta1.Deployment.pb | Bin 9932 -> 9948 bytes .../HEAD/apps.v1beta1.Deployment.yaml | 1 + .../HEAD/apps.v1beta1.StatefulSet.json | 6 +- .../testdata/HEAD/apps.v1beta1.StatefulSet.pb | Bin 10831 -> 10863 bytes .../HEAD/apps.v1beta1.StatefulSet.yaml | 2 + .../testdata/HEAD/apps.v1beta2.DaemonSet.json | 3 +- .../testdata/HEAD/apps.v1beta2.DaemonSet.pb | Bin 9915 -> 9931 bytes .../testdata/HEAD/apps.v1beta2.DaemonSet.yaml | 1 + .../HEAD/apps.v1beta2.Deployment.json | 3 +- .../testdata/HEAD/apps.v1beta2.Deployment.pb | Bin 9928 -> 9944 bytes .../HEAD/apps.v1beta2.Deployment.yaml | 1 + .../HEAD/apps.v1beta2.ReplicaSet.json | 3 +- .../testdata/HEAD/apps.v1beta2.ReplicaSet.pb | Bin 9845 -> 9861 bytes .../HEAD/apps.v1beta2.ReplicaSet.yaml | 1 + .../HEAD/apps.v1beta2.StatefulSet.json | 6 +- .../testdata/HEAD/apps.v1beta2.StatefulSet.pb | Bin 10831 -> 10863 bytes .../HEAD/apps.v1beta2.StatefulSet.yaml | 2 + .../api/testdata/HEAD/batch.v1.CronJob.json | 3 +- .../api/testdata/HEAD/batch.v1.CronJob.pb | Bin 10426 -> 10442 bytes .../api/testdata/HEAD/batch.v1.CronJob.yaml | 1 + .../api/testdata/HEAD/batch.v1.Job.json | 3 +- .../k8s.io/api/testdata/HEAD/batch.v1.Job.pb | Bin 10030 -> 10046 bytes .../api/testdata/HEAD/batch.v1.Job.yaml | 1 + .../testdata/HEAD/batch.v1beta1.CronJob.json | 3 +- .../testdata/HEAD/batch.v1beta1.CronJob.pb | Bin 10431 -> 10447 bytes .../testdata/HEAD/batch.v1beta1.CronJob.yaml | 1 + .../HEAD/batch.v1beta1.JobTemplate.json | 3 +- .../HEAD/batch.v1beta1.JobTemplate.pb | Bin 10243 -> 10259 bytes .../HEAD/batch.v1beta1.JobTemplate.yaml | 1 + .../HEAD/core.v1.PersistentVolumeClaim.json | 3 +- .../HEAD/core.v1.PersistentVolumeClaim.pb | Bin 844 -> 860 bytes .../HEAD/core.v1.PersistentVolumeClaim.yaml | 1 + .../k8s.io/api/testdata/HEAD/core.v1.Pod.json | 3 +- .../k8s.io/api/testdata/HEAD/core.v1.Pod.pb | Bin 10386 -> 10402 bytes .../k8s.io/api/testdata/HEAD/core.v1.Pod.yaml | 1 + .../testdata/HEAD/core.v1.PodTemplate.json | 3 +- .../api/testdata/HEAD/core.v1.PodTemplate.pb | Bin 9676 -> 9692 bytes .../testdata/HEAD/core.v1.PodTemplate.yaml | 1 + .../HEAD/core.v1.ReplicationController.json | 3 +- .../HEAD/core.v1.ReplicationController.pb | Bin 9798 -> 9814 bytes .../HEAD/core.v1.ReplicationController.yaml | 1 + .../HEAD/extensions.v1beta1.DaemonSet.json | 3 +- .../HEAD/extensions.v1beta1.DaemonSet.pb | Bin 9923 -> 9939 bytes .../HEAD/extensions.v1beta1.DaemonSet.yaml | 1 + .../HEAD/extensions.v1beta1.Deployment.json | 3 +- .../HEAD/extensions.v1beta1.Deployment.pb | Bin 9938 -> 9954 bytes .../HEAD/extensions.v1beta1.Deployment.yaml | 1 + .../HEAD/extensions.v1beta1.ReplicaSet.json | 3 +- .../HEAD/extensions.v1beta1.ReplicaSet.pb | Bin 9851 -> 9867 bytes .../HEAD/extensions.v1beta1.ReplicaSet.yaml | 1 + .../core/v1/persistentvolumeclaimspec.go | 4 +- .../core/v1/typedobjectreference.go | 66 + .../applyconfigurations/internal/internal.go | 19 +- .../client-go/applyconfigurations/utils.go | 2 + 78 files changed, 1673 insertions(+), 971 deletions(-) create mode 100644 staging/src/k8s.io/client-go/applyconfigurations/core/v1/typedobjectreference.go diff --git a/api/openapi-spec/swagger.json b/api/openapi-spec/swagger.json index 5ad38e106c8..4bc0c6bcaba 100644 --- a/api/openapi-spec/swagger.json +++ b/api/openapi-spec/swagger.json @@ -7014,11 +7014,11 @@ }, "dataSource": { "$ref": "#/definitions/io.k8s.api.core.v1.TypedLocalObjectReference", - "description": "dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. If the AnyVolumeDataSource feature gate is enabled, this field will always have the same contents as the DataSourceRef field." + "description": "dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. When the AnyVolumeDataSource feature gate is enabled, dataSource contents will be copied to dataSourceRef, and dataSourceRef contents will be copied to dataSource when dataSourceRef.namespace is not specified. If the namespace is specified, then dataSourceRef will not be copied to dataSource." }, "dataSourceRef": { - "$ref": "#/definitions/io.k8s.api.core.v1.TypedLocalObjectReference", - "description": "dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While DataSource ignores disallowed values (dropping them), DataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled." + "$ref": "#/definitions/io.k8s.api.core.v1.TypedObjectReference", + "description": "dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the dataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, when namespace isn't specified in dataSourceRef, both fields (dataSource and dataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. When namespace is specified in dataSourceRef, dataSource isn't set to the same value and must be empty. There are three important differences between dataSource and dataSourceRef: * While dataSource only allows two specific types of objects, dataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While dataSource ignores disallowed values (dropping them), dataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n* While dataSource only allows local objects, dataSourceRef allows objects\n in any namespaces.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled. (Alpha) Using the namespace field of dataSourceRef requires the CrossNamespaceVolumeDataSource feature gate to be enabled." }, "resources": { "$ref": "#/definitions/io.k8s.api.core.v1.ResourceRequirements", @@ -9619,6 +9619,31 @@ "type": "object", "x-kubernetes-map-type": "atomic" }, + "io.k8s.api.core.v1.TypedObjectReference": { + "properties": { + "apiGroup": { + "description": "APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.", + "type": "string" + }, + "kind": { + "description": "Kind is the type of resource being referenced", + "type": "string" + }, + "name": { + "description": "Name is the name of resource being referenced", + "type": "string" + }, + "namespace": { + "description": "Namespace is the namespace of resource being referenced Note that when a namespace is specified, a gateway.networking.k8s.io/ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details. (Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled.", + "type": "string" + } + }, + "required": [ + "kind", + "name" + ], + "type": "object" + }, "io.k8s.api.core.v1.Volume": { "description": "Volume represents a named volume in a pod that may be accessed by any container in the pod.", "properties": { diff --git a/api/openapi-spec/v3/api__v1_openapi.json b/api/openapi-spec/v3/api__v1_openapi.json index a547b5e618f..8c73deeb599 100644 --- a/api/openapi-spec/v3/api__v1_openapi.json +++ b/api/openapi-spec/v3/api__v1_openapi.json @@ -4080,15 +4080,15 @@ "$ref": "#/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference" } ], - "description": "dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. If the AnyVolumeDataSource feature gate is enabled, this field will always have the same contents as the DataSourceRef field." + "description": "dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. When the AnyVolumeDataSource feature gate is enabled, dataSource contents will be copied to dataSourceRef, and dataSourceRef contents will be copied to dataSource when dataSourceRef.namespace is not specified. If the namespace is specified, then dataSourceRef will not be copied to dataSource." }, "dataSourceRef": { "allOf": [ { - "$ref": "#/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference" + "$ref": "#/components/schemas/io.k8s.api.core.v1.TypedObjectReference" } ], - "description": "dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While DataSource ignores disallowed values (dropping them), DataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled." + "description": "dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the dataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, when namespace isn't specified in dataSourceRef, both fields (dataSource and dataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. When namespace is specified in dataSourceRef, dataSource isn't set to the same value and must be empty. There are three important differences between dataSource and dataSourceRef: * While dataSource only allows two specific types of objects, dataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While dataSource ignores disallowed values (dropping them), dataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n* While dataSource only allows local objects, dataSourceRef allows objects\n in any namespaces.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled. (Alpha) Using the namespace field of dataSourceRef requires the CrossNamespaceVolumeDataSource feature gate to be enabled." }, "resources": { "allOf": [ @@ -7359,6 +7359,33 @@ "type": "object", "x-kubernetes-map-type": "atomic" }, + "io.k8s.api.core.v1.TypedObjectReference": { + "properties": { + "apiGroup": { + "description": "APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.", + "type": "string" + }, + "kind": { + "default": "", + "description": "Kind is the type of resource being referenced", + "type": "string" + }, + "name": { + "default": "", + "description": "Name is the name of resource being referenced", + "type": "string" + }, + "namespace": { + "description": "Namespace is the namespace of resource being referenced Note that when a namespace is specified, a gateway.networking.k8s.io/ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details. (Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled.", + "type": "string" + } + }, + "required": [ + "kind", + "name" + ], + "type": "object" + }, "io.k8s.api.core.v1.Volume": { "description": "Volume represents a named volume in a pod that may be accessed by any container in the pod.", "properties": { diff --git a/api/openapi-spec/v3/apis__apps__v1_openapi.json b/api/openapi-spec/v3/apis__apps__v1_openapi.json index b25dd31737c..8fc4e23c2d4 100644 --- a/api/openapi-spec/v3/apis__apps__v1_openapi.json +++ b/api/openapi-spec/v3/apis__apps__v1_openapi.json @@ -2973,15 +2973,15 @@ "$ref": "#/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference" } ], - "description": "dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. If the AnyVolumeDataSource feature gate is enabled, this field will always have the same contents as the DataSourceRef field." + "description": "dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. When the AnyVolumeDataSource feature gate is enabled, dataSource contents will be copied to dataSourceRef, and dataSourceRef contents will be copied to dataSource when dataSourceRef.namespace is not specified. If the namespace is specified, then dataSourceRef will not be copied to dataSource." }, "dataSourceRef": { "allOf": [ { - "$ref": "#/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference" + "$ref": "#/components/schemas/io.k8s.api.core.v1.TypedObjectReference" } ], - "description": "dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While DataSource ignores disallowed values (dropping them), DataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled." + "description": "dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the dataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, when namespace isn't specified in dataSourceRef, both fields (dataSource and dataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. When namespace is specified in dataSourceRef, dataSource isn't set to the same value and must be empty. There are three important differences between dataSource and dataSourceRef: * While dataSource only allows two specific types of objects, dataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While dataSource ignores disallowed values (dropping them), dataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n* While dataSource only allows local objects, dataSourceRef allows objects\n in any namespaces.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled. (Alpha) Using the namespace field of dataSourceRef requires the CrossNamespaceVolumeDataSource feature gate to be enabled." }, "resources": { "allOf": [ @@ -4475,6 +4475,33 @@ "type": "object", "x-kubernetes-map-type": "atomic" }, + "io.k8s.api.core.v1.TypedObjectReference": { + "properties": { + "apiGroup": { + "description": "APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.", + "type": "string" + }, + "kind": { + "default": "", + "description": "Kind is the type of resource being referenced", + "type": "string" + }, + "name": { + "default": "", + "description": "Name is the name of resource being referenced", + "type": "string" + }, + "namespace": { + "description": "Namespace is the namespace of resource being referenced Note that when a namespace is specified, a gateway.networking.k8s.io/ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details. (Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled.", + "type": "string" + } + }, + "required": [ + "kind", + "name" + ], + "type": "object" + }, "io.k8s.api.core.v1.Volume": { "description": "Volume represents a named volume in a pod that may be accessed by any container in the pod.", "properties": { diff --git a/api/openapi-spec/v3/apis__batch__v1_openapi.json b/api/openapi-spec/v3/apis__batch__v1_openapi.json index 8f56d8734bc..6ead130646c 100644 --- a/api/openapi-spec/v3/apis__batch__v1_openapi.json +++ b/api/openapi-spec/v3/apis__batch__v1_openapi.json @@ -2207,15 +2207,15 @@ "$ref": "#/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference" } ], - "description": "dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. If the AnyVolumeDataSource feature gate is enabled, this field will always have the same contents as the DataSourceRef field." + "description": "dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. When the AnyVolumeDataSource feature gate is enabled, dataSource contents will be copied to dataSourceRef, and dataSourceRef contents will be copied to dataSource when dataSourceRef.namespace is not specified. If the namespace is specified, then dataSourceRef will not be copied to dataSource." }, "dataSourceRef": { "allOf": [ { - "$ref": "#/components/schemas/io.k8s.api.core.v1.TypedLocalObjectReference" + "$ref": "#/components/schemas/io.k8s.api.core.v1.TypedObjectReference" } ], - "description": "dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While DataSource ignores disallowed values (dropping them), DataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled." + "description": "dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the dataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, when namespace isn't specified in dataSourceRef, both fields (dataSource and dataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. When namespace is specified in dataSourceRef, dataSource isn't set to the same value and must be empty. There are three important differences between dataSource and dataSourceRef: * While dataSource only allows two specific types of objects, dataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While dataSource ignores disallowed values (dropping them), dataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n* While dataSource only allows local objects, dataSourceRef allows objects\n in any namespaces.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled. (Alpha) Using the namespace field of dataSourceRef requires the CrossNamespaceVolumeDataSource feature gate to be enabled." }, "resources": { "allOf": [ @@ -3649,6 +3649,33 @@ "type": "object", "x-kubernetes-map-type": "atomic" }, + "io.k8s.api.core.v1.TypedObjectReference": { + "properties": { + "apiGroup": { + "description": "APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.", + "type": "string" + }, + "kind": { + "default": "", + "description": "Kind is the type of resource being referenced", + "type": "string" + }, + "name": { + "default": "", + "description": "Name is the name of resource being referenced", + "type": "string" + }, + "namespace": { + "description": "Namespace is the namespace of resource being referenced Note that when a namespace is specified, a gateway.networking.k8s.io/ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details. (Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled.", + "type": "string" + } + }, + "required": [ + "kind", + "name" + ], + "type": "object" + }, "io.k8s.api.core.v1.Volume": { "description": "Volume represents a named volume in a pod that may be accessed by any container in the pod.", "properties": { diff --git a/pkg/apis/core/v1/zz_generated.conversion.go b/pkg/apis/core/v1/zz_generated.conversion.go index e93e625d110..153441540b1 100644 --- a/pkg/apis/core/v1/zz_generated.conversion.go +++ b/pkg/apis/core/v1/zz_generated.conversion.go @@ -1977,6 +1977,16 @@ func RegisterConversions(s *runtime.Scheme) error { }); err != nil { return err } + if err := s.AddGeneratedConversionFunc((*v1.TypedObjectReference)(nil), (*core.TypedObjectReference)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1_TypedObjectReference_To_core_TypedObjectReference(a.(*v1.TypedObjectReference), b.(*core.TypedObjectReference), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*core.TypedObjectReference)(nil), (*v1.TypedObjectReference)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_core_TypedObjectReference_To_v1_TypedObjectReference(a.(*core.TypedObjectReference), b.(*v1.TypedObjectReference), scope) + }); err != nil { + return err + } if err := s.AddGeneratedConversionFunc((*v1.VolumeDevice)(nil), (*core.VolumeDevice)(nil), func(a, b interface{}, scope conversion.Scope) error { return Convert_v1_VolumeDevice_To_core_VolumeDevice(a.(*v1.VolumeDevice), b.(*core.VolumeDevice), scope) }); err != nil { @@ -5182,7 +5192,7 @@ func autoConvert_v1_PersistentVolumeClaimSpec_To_core_PersistentVolumeClaimSpec( out.StorageClassName = (*string)(unsafe.Pointer(in.StorageClassName)) out.VolumeMode = (*core.PersistentVolumeMode)(unsafe.Pointer(in.VolumeMode)) out.DataSource = (*core.TypedLocalObjectReference)(unsafe.Pointer(in.DataSource)) - out.DataSourceRef = (*core.TypedLocalObjectReference)(unsafe.Pointer(in.DataSourceRef)) + out.DataSourceRef = (*core.TypedObjectReference)(unsafe.Pointer(in.DataSourceRef)) return nil } @@ -5201,7 +5211,7 @@ func autoConvert_core_PersistentVolumeClaimSpec_To_v1_PersistentVolumeClaimSpec( out.StorageClassName = (*string)(unsafe.Pointer(in.StorageClassName)) out.VolumeMode = (*v1.PersistentVolumeMode)(unsafe.Pointer(in.VolumeMode)) out.DataSource = (*v1.TypedLocalObjectReference)(unsafe.Pointer(in.DataSource)) - out.DataSourceRef = (*v1.TypedLocalObjectReference)(unsafe.Pointer(in.DataSourceRef)) + out.DataSourceRef = (*v1.TypedObjectReference)(unsafe.Pointer(in.DataSourceRef)) return nil } @@ -8083,6 +8093,32 @@ func Convert_core_TypedLocalObjectReference_To_v1_TypedLocalObjectReference(in * return autoConvert_core_TypedLocalObjectReference_To_v1_TypedLocalObjectReference(in, out, s) } +func autoConvert_v1_TypedObjectReference_To_core_TypedObjectReference(in *v1.TypedObjectReference, out *core.TypedObjectReference, s conversion.Scope) error { + out.APIGroup = (*string)(unsafe.Pointer(in.APIGroup)) + out.Kind = in.Kind + out.Name = in.Name + out.Namespace = (*string)(unsafe.Pointer(in.Namespace)) + return nil +} + +// Convert_v1_TypedObjectReference_To_core_TypedObjectReference is an autogenerated conversion function. +func Convert_v1_TypedObjectReference_To_core_TypedObjectReference(in *v1.TypedObjectReference, out *core.TypedObjectReference, s conversion.Scope) error { + return autoConvert_v1_TypedObjectReference_To_core_TypedObjectReference(in, out, s) +} + +func autoConvert_core_TypedObjectReference_To_v1_TypedObjectReference(in *core.TypedObjectReference, out *v1.TypedObjectReference, s conversion.Scope) error { + out.APIGroup = (*string)(unsafe.Pointer(in.APIGroup)) + out.Kind = in.Kind + out.Name = in.Name + out.Namespace = (*string)(unsafe.Pointer(in.Namespace)) + return nil +} + +// Convert_core_TypedObjectReference_To_v1_TypedObjectReference is an autogenerated conversion function. +func Convert_core_TypedObjectReference_To_v1_TypedObjectReference(in *core.TypedObjectReference, out *v1.TypedObjectReference, s conversion.Scope) error { + return autoConvert_core_TypedObjectReference_To_v1_TypedObjectReference(in, out, s) +} + func autoConvert_v1_Volume_To_core_Volume(in *v1.Volume, out *core.Volume, s conversion.Scope) error { out.Name = in.Name if err := Convert_v1_VolumeSource_To_core_VolumeSource(&in.VolumeSource, &out.VolumeSource, s); err != nil { diff --git a/pkg/apis/core/zz_generated.deepcopy.go b/pkg/apis/core/zz_generated.deepcopy.go index 8411862b008..a7a4521d130 100644 --- a/pkg/apis/core/zz_generated.deepcopy.go +++ b/pkg/apis/core/zz_generated.deepcopy.go @@ -2965,7 +2965,7 @@ func (in *PersistentVolumeClaimSpec) DeepCopyInto(out *PersistentVolumeClaimSpec } if in.DataSourceRef != nil { in, out := &in.DataSourceRef, &out.DataSourceRef - *out = new(TypedLocalObjectReference) + *out = new(TypedObjectReference) (*in).DeepCopyInto(*out) } return @@ -5714,6 +5714,32 @@ func (in *TypedLocalObjectReference) DeepCopy() *TypedLocalObjectReference { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *TypedObjectReference) DeepCopyInto(out *TypedObjectReference) { + *out = *in + if in.APIGroup != nil { + in, out := &in.APIGroup, &out.APIGroup + *out = new(string) + **out = **in + } + if in.Namespace != nil { + in, out := &in.Namespace, &out.Namespace + *out = new(string) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TypedObjectReference. +func (in *TypedObjectReference) DeepCopy() *TypedObjectReference { + if in == nil { + return nil + } + out := new(TypedObjectReference) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *Volume) DeepCopyInto(out *Volume) { *out = *in diff --git a/pkg/generated/openapi/zz_generated.openapi.go b/pkg/generated/openapi/zz_generated.openapi.go index 1f094830307..6f910ce6a1c 100644 --- a/pkg/generated/openapi/zz_generated.openapi.go +++ b/pkg/generated/openapi/zz_generated.openapi.go @@ -526,6 +526,7 @@ func GetOpenAPIDefinitions(ref common.ReferenceCallback) map[string]common.OpenA "k8s.io/api/core/v1.TopologySelectorTerm": schema_k8sio_api_core_v1_TopologySelectorTerm(ref), "k8s.io/api/core/v1.TopologySpreadConstraint": schema_k8sio_api_core_v1_TopologySpreadConstraint(ref), "k8s.io/api/core/v1.TypedLocalObjectReference": schema_k8sio_api_core_v1_TypedLocalObjectReference(ref), + "k8s.io/api/core/v1.TypedObjectReference": schema_k8sio_api_core_v1_TypedObjectReference(ref), "k8s.io/api/core/v1.Volume": schema_k8sio_api_core_v1_Volume(ref), "k8s.io/api/core/v1.VolumeDevice": schema_k8sio_api_core_v1_VolumeDevice(ref), "k8s.io/api/core/v1.VolumeMount": schema_k8sio_api_core_v1_VolumeMount(ref), @@ -21490,21 +21491,21 @@ func schema_k8sio_api_core_v1_PersistentVolumeClaimSpec(ref common.ReferenceCall }, "dataSource": { SchemaProps: spec.SchemaProps{ - Description: "dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. If the AnyVolumeDataSource feature gate is enabled, this field will always have the same contents as the DataSourceRef field.", + Description: "dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. When the AnyVolumeDataSource feature gate is enabled, dataSource contents will be copied to dataSourceRef, and dataSourceRef contents will be copied to dataSource when dataSourceRef.namespace is not specified. If the namespace is specified, then dataSourceRef will not be copied to dataSource.", Ref: ref("k8s.io/api/core/v1.TypedLocalObjectReference"), }, }, "dataSourceRef": { SchemaProps: spec.SchemaProps{ - Description: "dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While DataSource ignores disallowed values (dropping them), DataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled.", - Ref: ref("k8s.io/api/core/v1.TypedLocalObjectReference"), + Description: "dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the dataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, when namespace isn't specified in dataSourceRef, both fields (dataSource and dataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. When namespace is specified in dataSourceRef, dataSource isn't set to the same value and must be empty. There are three important differences between dataSource and dataSourceRef: * While dataSource only allows two specific types of objects, dataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While dataSource ignores disallowed values (dropping them), dataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n* While dataSource only allows local objects, dataSourceRef allows objects\n in any namespaces.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled. (Alpha) Using the namespace field of dataSourceRef requires the CrossNamespaceVolumeDataSource feature gate to be enabled.", + Ref: ref("k8s.io/api/core/v1.TypedObjectReference"), }, }, }, }, }, Dependencies: []string{ - "k8s.io/api/core/v1.ResourceRequirements", "k8s.io/api/core/v1.TypedLocalObjectReference", "k8s.io/apimachinery/pkg/apis/meta/v1.LabelSelector"}, + "k8s.io/api/core/v1.ResourceRequirements", "k8s.io/api/core/v1.TypedLocalObjectReference", "k8s.io/api/core/v1.TypedObjectReference", "k8s.io/apimachinery/pkg/apis/meta/v1.LabelSelector"}, } } @@ -26813,6 +26814,49 @@ func schema_k8sio_api_core_v1_TypedLocalObjectReference(ref common.ReferenceCall } } +func schema_k8sio_api_core_v1_TypedObjectReference(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "apiGroup": { + SchemaProps: spec.SchemaProps{ + Description: "APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.", + Type: []string{"string"}, + Format: "", + }, + }, + "kind": { + SchemaProps: spec.SchemaProps{ + Description: "Kind is the type of resource being referenced", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "name": { + SchemaProps: spec.SchemaProps{ + Description: "Name is the name of resource being referenced", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "namespace": { + SchemaProps: spec.SchemaProps{ + Description: "Namespace is the namespace of resource being referenced Note that when a namespace is specified, a gateway.networking.k8s.io/ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details. (Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled.", + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"kind", "name"}, + }, + }, + } +} + func schema_k8sio_api_core_v1_Volume(ref common.ReferenceCallback) common.OpenAPIDefinition { return common.OpenAPIDefinition{ Schema: spec.Schema{ 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 88fe74cf973..4c0456cb616 100644 --- a/staging/src/k8s.io/api/core/v1/generated.pb.go +++ b/staging/src/k8s.io/api/core/v1/generated.pb.go @@ -5705,10 +5705,38 @@ func (m *TypedLocalObjectReference) XXX_DiscardUnknown() { var xxx_messageInfo_TypedLocalObjectReference proto.InternalMessageInfo +func (m *TypedObjectReference) Reset() { *m = TypedObjectReference{} } +func (*TypedObjectReference) ProtoMessage() {} +func (*TypedObjectReference) Descriptor() ([]byte, []int) { + return fileDescriptor_83c10c24ec417dc9, []int{202} +} +func (m *TypedObjectReference) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TypedObjectReference) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *TypedObjectReference) XXX_Merge(src proto.Message) { + xxx_messageInfo_TypedObjectReference.Merge(m, src) +} +func (m *TypedObjectReference) XXX_Size() int { + return m.Size() +} +func (m *TypedObjectReference) XXX_DiscardUnknown() { + xxx_messageInfo_TypedObjectReference.DiscardUnknown(m) +} + +var xxx_messageInfo_TypedObjectReference proto.InternalMessageInfo + func (m *Volume) Reset() { *m = Volume{} } func (*Volume) ProtoMessage() {} func (*Volume) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{202} + return fileDescriptor_83c10c24ec417dc9, []int{203} } func (m *Volume) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5736,7 +5764,7 @@ var xxx_messageInfo_Volume proto.InternalMessageInfo func (m *VolumeDevice) Reset() { *m = VolumeDevice{} } func (*VolumeDevice) ProtoMessage() {} func (*VolumeDevice) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{203} + return fileDescriptor_83c10c24ec417dc9, []int{204} } func (m *VolumeDevice) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5764,7 +5792,7 @@ var xxx_messageInfo_VolumeDevice proto.InternalMessageInfo func (m *VolumeMount) Reset() { *m = VolumeMount{} } func (*VolumeMount) ProtoMessage() {} func (*VolumeMount) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{204} + return fileDescriptor_83c10c24ec417dc9, []int{205} } func (m *VolumeMount) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5792,7 +5820,7 @@ var xxx_messageInfo_VolumeMount proto.InternalMessageInfo func (m *VolumeNodeAffinity) Reset() { *m = VolumeNodeAffinity{} } func (*VolumeNodeAffinity) ProtoMessage() {} func (*VolumeNodeAffinity) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{205} + return fileDescriptor_83c10c24ec417dc9, []int{206} } func (m *VolumeNodeAffinity) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5820,7 +5848,7 @@ var xxx_messageInfo_VolumeNodeAffinity proto.InternalMessageInfo func (m *VolumeProjection) Reset() { *m = VolumeProjection{} } func (*VolumeProjection) ProtoMessage() {} func (*VolumeProjection) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{206} + return fileDescriptor_83c10c24ec417dc9, []int{207} } func (m *VolumeProjection) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5848,7 +5876,7 @@ var xxx_messageInfo_VolumeProjection proto.InternalMessageInfo func (m *VolumeSource) Reset() { *m = VolumeSource{} } func (*VolumeSource) ProtoMessage() {} func (*VolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{207} + return fileDescriptor_83c10c24ec417dc9, []int{208} } func (m *VolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5876,7 +5904,7 @@ var xxx_messageInfo_VolumeSource proto.InternalMessageInfo func (m *VsphereVirtualDiskVolumeSource) Reset() { *m = VsphereVirtualDiskVolumeSource{} } func (*VsphereVirtualDiskVolumeSource) ProtoMessage() {} func (*VsphereVirtualDiskVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{208} + return fileDescriptor_83c10c24ec417dc9, []int{209} } func (m *VsphereVirtualDiskVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5904,7 +5932,7 @@ var xxx_messageInfo_VsphereVirtualDiskVolumeSource proto.InternalMessageInfo func (m *WeightedPodAffinityTerm) Reset() { *m = WeightedPodAffinityTerm{} } func (*WeightedPodAffinityTerm) ProtoMessage() {} func (*WeightedPodAffinityTerm) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{209} + return fileDescriptor_83c10c24ec417dc9, []int{210} } func (m *WeightedPodAffinityTerm) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5932,7 +5960,7 @@ var xxx_messageInfo_WeightedPodAffinityTerm proto.InternalMessageInfo func (m *WindowsSecurityContextOptions) Reset() { *m = WindowsSecurityContextOptions{} } func (*WindowsSecurityContextOptions) ProtoMessage() {} func (*WindowsSecurityContextOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{210} + return fileDescriptor_83c10c24ec417dc9, []int{211} } func (m *WindowsSecurityContextOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6188,6 +6216,7 @@ func init() { proto.RegisterType((*TopologySelectorTerm)(nil), "k8s.io.api.core.v1.TopologySelectorTerm") proto.RegisterType((*TopologySpreadConstraint)(nil), "k8s.io.api.core.v1.TopologySpreadConstraint") proto.RegisterType((*TypedLocalObjectReference)(nil), "k8s.io.api.core.v1.TypedLocalObjectReference") + proto.RegisterType((*TypedObjectReference)(nil), "k8s.io.api.core.v1.TypedObjectReference") proto.RegisterType((*Volume)(nil), "k8s.io.api.core.v1.Volume") proto.RegisterType((*VolumeDevice)(nil), "k8s.io.api.core.v1.VolumeDevice") proto.RegisterType((*VolumeMount)(nil), "k8s.io.api.core.v1.VolumeMount") @@ -6204,908 +6233,910 @@ func init() { } var fileDescriptor_83c10c24ec417dc9 = []byte{ - // 14408 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x6b, 0x70, 0x5c, 0xd7, - 0x79, 0x98, 0xef, 0x2e, 0x5e, 0xfb, 0xe1, 0x7d, 0x40, 0x52, 0x20, 0x24, 0x12, 0xd4, 0x95, 0x44, - 0x51, 0x96, 0x04, 0x98, 0x7a, 0xd8, 0x8a, 0x64, 0x2b, 0x06, 0xb0, 0x00, 0x09, 0x91, 0x00, 0x57, - 0x67, 0x41, 0xd2, 0x76, 0x64, 0x8f, 0x2f, 0x76, 0x0f, 0x80, 0x6b, 0xec, 0xde, 0xbb, 0xba, 0xf7, - 0x2e, 0x48, 0xb0, 0xce, 0x34, 0x75, 0x9e, 0x4e, 0xd2, 0x8e, 0xa7, 0x93, 0x3e, 0xc6, 0xc9, 0x64, - 0x3a, 0x69, 0xda, 0xc4, 0x75, 0xdb, 0x69, 0xea, 0x34, 0x49, 0xe3, 0xb4, 0x49, 0xdf, 0x69, 0x7f, - 0xa4, 0x69, 0x66, 0x1a, 0x67, 0x26, 0x53, 0x34, 0x61, 0x3a, 0xcd, 0x78, 0xa6, 0x4d, 0xd2, 0xa6, - 0x9d, 0x69, 0xd1, 0xb4, 0xe9, 0x9c, 0xe7, 0x3d, 0xe7, 0x3e, 0x76, 0x17, 0x14, 0x08, 0xcb, 0x1e, - 0xfd, 0xdb, 0x3d, 0xdf, 0x77, 0xbe, 0x73, 0xee, 0x79, 0x7e, 0xe7, 0x7b, 0xc2, 0x6b, 0xbb, 0xaf, - 0x84, 0x73, 0xae, 0x3f, 0xbf, 0xdb, 0xde, 0x24, 0x81, 0x47, 0x22, 0x12, 0xce, 0xef, 0x11, 0xaf, - 0xee, 0x07, 0xf3, 0x02, 0xe0, 0xb4, 0xdc, 0xf9, 0x9a, 0x1f, 0x90, 0xf9, 0xbd, 0xcb, 0xf3, 0xdb, - 0xc4, 0x23, 0x81, 0x13, 0x91, 0xfa, 0x5c, 0x2b, 0xf0, 0x23, 0x1f, 0x21, 0x8e, 0x33, 0xe7, 0xb4, - 0xdc, 0x39, 0x8a, 0x33, 0xb7, 0x77, 0x79, 0xe6, 0xf9, 0x6d, 0x37, 0xda, 0x69, 0x6f, 0xce, 0xd5, - 0xfc, 0xe6, 0xfc, 0xb6, 0xbf, 0xed, 0xcf, 0x33, 0xd4, 0xcd, 0xf6, 0x16, 0xfb, 0xc7, 0xfe, 0xb0, - 0x5f, 0x9c, 0xc4, 0xcc, 0x4b, 0x71, 0x33, 0x4d, 0xa7, 0xb6, 0xe3, 0x7a, 0x24, 0xd8, 0x9f, 0x6f, - 0xed, 0x6e, 0xb3, 0x76, 0x03, 0x12, 0xfa, 0xed, 0xa0, 0x46, 0x92, 0x0d, 0x77, 0xac, 0x15, 0xce, - 0x37, 0x49, 0xe4, 0x64, 0x74, 0x77, 0x66, 0x3e, 0xaf, 0x56, 0xd0, 0xf6, 0x22, 0xb7, 0x99, 0x6e, - 0xe6, 0x83, 0xdd, 0x2a, 0x84, 0xb5, 0x1d, 0xd2, 0x74, 0x52, 0xf5, 0x5e, 0xcc, 0xab, 0xd7, 0x8e, - 0xdc, 0xc6, 0xbc, 0xeb, 0x45, 0x61, 0x14, 0x24, 0x2b, 0xd9, 0x5f, 0xb3, 0xe0, 0xc2, 0xc2, 0xed, - 0xea, 0x72, 0xc3, 0x09, 0x23, 0xb7, 0xb6, 0xd8, 0xf0, 0x6b, 0xbb, 0xd5, 0xc8, 0x0f, 0xc8, 0x2d, - 0xbf, 0xd1, 0x6e, 0x92, 0x2a, 0x1b, 0x08, 0xf4, 0x1c, 0x0c, 0xed, 0xb1, 0xff, 0xab, 0xe5, 0x69, - 0xeb, 0x82, 0x75, 0xa9, 0xb4, 0x38, 0xf1, 0xab, 0x07, 0xb3, 0xef, 0xbb, 0x7f, 0x30, 0x3b, 0x74, - 0x4b, 0x94, 0x63, 0x85, 0x81, 0x2e, 0xc2, 0xc0, 0x56, 0xb8, 0xb1, 0xdf, 0x22, 0xd3, 0x05, 0x86, - 0x3b, 0x26, 0x70, 0x07, 0x56, 0xaa, 0xb4, 0x14, 0x0b, 0x28, 0x9a, 0x87, 0x52, 0xcb, 0x09, 0x22, - 0x37, 0x72, 0x7d, 0x6f, 0xba, 0x78, 0xc1, 0xba, 0xd4, 0xbf, 0x38, 0x29, 0x50, 0x4b, 0x15, 0x09, - 0xc0, 0x31, 0x0e, 0xed, 0x46, 0x40, 0x9c, 0xfa, 0x0d, 0xaf, 0xb1, 0x3f, 0xdd, 0x77, 0xc1, 0xba, - 0x34, 0x14, 0x77, 0x03, 0x8b, 0x72, 0xac, 0x30, 0xec, 0x2f, 0x16, 0x60, 0x68, 0x61, 0x6b, 0xcb, - 0xf5, 0xdc, 0x68, 0x1f, 0xdd, 0x82, 0x11, 0xcf, 0xaf, 0x13, 0xf9, 0x9f, 0x7d, 0xc5, 0xf0, 0x0b, - 0x17, 0xe6, 0xd2, 0x4b, 0x69, 0x6e, 0x5d, 0xc3, 0x5b, 0x9c, 0xb8, 0x7f, 0x30, 0x3b, 0xa2, 0x97, - 0x60, 0x83, 0x0e, 0xc2, 0x30, 0xdc, 0xf2, 0xeb, 0x8a, 0x6c, 0x81, 0x91, 0x9d, 0xcd, 0x22, 0x5b, - 0x89, 0xd1, 0x16, 0xc7, 0xef, 0x1f, 0xcc, 0x0e, 0x6b, 0x05, 0x58, 0x27, 0x82, 0x36, 0x61, 0x9c, - 0xfe, 0xf5, 0x22, 0x57, 0xd1, 0x2d, 0x32, 0xba, 0x4f, 0xe4, 0xd1, 0xd5, 0x50, 0x17, 0xa7, 0xee, - 0x1f, 0xcc, 0x8e, 0x27, 0x0a, 0x71, 0x92, 0xa0, 0x7d, 0x0f, 0xc6, 0x16, 0xa2, 0xc8, 0xa9, 0xed, - 0x90, 0x3a, 0x9f, 0x41, 0xf4, 0x12, 0xf4, 0x79, 0x4e, 0x93, 0x88, 0xf9, 0xbd, 0x20, 0x06, 0xb6, - 0x6f, 0xdd, 0x69, 0x92, 0xc3, 0x83, 0xd9, 0x89, 0x9b, 0x9e, 0xfb, 0x76, 0x5b, 0xac, 0x0a, 0x5a, - 0x86, 0x19, 0x36, 0x7a, 0x01, 0xa0, 0x4e, 0xf6, 0xdc, 0x1a, 0xa9, 0x38, 0xd1, 0x8e, 0x98, 0x6f, - 0x24, 0xea, 0x42, 0x59, 0x41, 0xb0, 0x86, 0x65, 0xdf, 0x85, 0xd2, 0xc2, 0x9e, 0xef, 0xd6, 0x2b, - 0x7e, 0x3d, 0x44, 0xbb, 0x30, 0xde, 0x0a, 0xc8, 0x16, 0x09, 0x54, 0xd1, 0xb4, 0x75, 0xa1, 0x78, - 0x69, 0xf8, 0x85, 0x4b, 0x99, 0x1f, 0x6b, 0xa2, 0x2e, 0x7b, 0x51, 0xb0, 0xbf, 0xf8, 0x88, 0x68, - 0x6f, 0x3c, 0x01, 0xc5, 0x49, 0xca, 0xf6, 0x3f, 0x2f, 0xc0, 0xe9, 0x85, 0x7b, 0xed, 0x80, 0x94, - 0xdd, 0x70, 0x37, 0xb9, 0xc2, 0xeb, 0x6e, 0xb8, 0xbb, 0x1e, 0x8f, 0x80, 0x5a, 0x5a, 0x65, 0x51, - 0x8e, 0x15, 0x06, 0x7a, 0x1e, 0x06, 0xe9, 0xef, 0x9b, 0x78, 0x55, 0x7c, 0xf2, 0x94, 0x40, 0x1e, - 0x2e, 0x3b, 0x91, 0x53, 0xe6, 0x20, 0x2c, 0x71, 0xd0, 0x1a, 0x0c, 0xd7, 0xd8, 0x86, 0xdc, 0x5e, - 0xf3, 0xeb, 0x84, 0x4d, 0x66, 0x69, 0xf1, 0x59, 0x8a, 0xbe, 0x14, 0x17, 0x1f, 0x1e, 0xcc, 0x4e, - 0xf3, 0xbe, 0x09, 0x12, 0x1a, 0x0c, 0xeb, 0xf5, 0x91, 0xad, 0xf6, 0x57, 0x1f, 0xa3, 0x04, 0x19, - 0x7b, 0xeb, 0x92, 0xb6, 0x55, 0xfa, 0xd9, 0x56, 0x19, 0xc9, 0xde, 0x26, 0xe8, 0x32, 0xf4, 0xed, - 0xba, 0x5e, 0x7d, 0x7a, 0x80, 0xd1, 0x3a, 0x47, 0xe7, 0xfc, 0x9a, 0xeb, 0xd5, 0x0f, 0x0f, 0x66, - 0x27, 0x8d, 0xee, 0xd0, 0x42, 0xcc, 0x50, 0xed, 0x3f, 0xb6, 0x60, 0x96, 0xc1, 0x56, 0xdc, 0x06, - 0xa9, 0x90, 0x20, 0x74, 0xc3, 0x88, 0x78, 0x91, 0x31, 0xa0, 0x2f, 0x00, 0x84, 0xa4, 0x16, 0x90, - 0x48, 0x1b, 0x52, 0xb5, 0x30, 0xaa, 0x0a, 0x82, 0x35, 0x2c, 0x7a, 0x20, 0x84, 0x3b, 0x4e, 0xc0, - 0xd6, 0x97, 0x18, 0x58, 0x75, 0x20, 0x54, 0x25, 0x00, 0xc7, 0x38, 0xc6, 0x81, 0x50, 0xec, 0x76, - 0x20, 0xa0, 0x8f, 0xc0, 0x78, 0xdc, 0x58, 0xd8, 0x72, 0x6a, 0x72, 0x00, 0xd9, 0x96, 0xa9, 0x9a, - 0x20, 0x9c, 0xc4, 0xb5, 0xff, 0x96, 0x25, 0x16, 0x0f, 0xfd, 0xea, 0x77, 0xf9, 0xb7, 0xda, 0xbf, - 0x60, 0xc1, 0xe0, 0xa2, 0xeb, 0xd5, 0x5d, 0x6f, 0x1b, 0x7d, 0x1a, 0x86, 0xe8, 0xdd, 0x54, 0x77, - 0x22, 0x47, 0x9c, 0x7b, 0x1f, 0xd0, 0xf6, 0x96, 0xba, 0x2a, 0xe6, 0x5a, 0xbb, 0xdb, 0xb4, 0x20, - 0x9c, 0xa3, 0xd8, 0x74, 0xb7, 0xdd, 0xd8, 0xfc, 0x0c, 0xa9, 0x45, 0x6b, 0x24, 0x72, 0xe2, 0xcf, - 0x89, 0xcb, 0xb0, 0xa2, 0x8a, 0xae, 0xc1, 0x40, 0xe4, 0x04, 0xdb, 0x24, 0x12, 0x07, 0x60, 0xe6, - 0x41, 0xc5, 0x6b, 0x62, 0xba, 0x23, 0x89, 0x57, 0x23, 0xf1, 0xb5, 0xb0, 0xc1, 0xaa, 0x62, 0x41, - 0xc2, 0xfe, 0xbf, 0x83, 0x70, 0x76, 0xa9, 0xba, 0x9a, 0xb3, 0xae, 0x2e, 0xc2, 0x40, 0x3d, 0x70, - 0xf7, 0x48, 0x20, 0xc6, 0x59, 0x51, 0x29, 0xb3, 0x52, 0x2c, 0xa0, 0xe8, 0x15, 0x18, 0xe1, 0x17, - 0xd2, 0x55, 0xc7, 0xab, 0x37, 0xe4, 0x10, 0x9f, 0x12, 0xd8, 0x23, 0xb7, 0x34, 0x18, 0x36, 0x30, - 0x8f, 0xb8, 0xa8, 0x2e, 0x26, 0x36, 0x63, 0xde, 0x65, 0xf7, 0x79, 0x0b, 0x26, 0x78, 0x33, 0x0b, - 0x51, 0x14, 0xb8, 0x9b, 0xed, 0x88, 0x84, 0xd3, 0xfd, 0xec, 0xa4, 0x5b, 0xca, 0x1a, 0xad, 0xdc, - 0x11, 0x98, 0xbb, 0x95, 0xa0, 0xc2, 0x0f, 0xc1, 0x69, 0xd1, 0xee, 0x44, 0x12, 0x8c, 0x53, 0xcd, - 0xa2, 0xef, 0xb6, 0x60, 0xa6, 0xe6, 0x7b, 0x51, 0xe0, 0x37, 0x1a, 0x24, 0xa8, 0xb4, 0x37, 0x1b, - 0x6e, 0xb8, 0xc3, 0xd7, 0x29, 0x26, 0x5b, 0xec, 0x24, 0xc8, 0x99, 0x43, 0x85, 0x24, 0xe6, 0xf0, - 0xfc, 0xfd, 0x83, 0xd9, 0x99, 0xa5, 0x5c, 0x52, 0xb8, 0x43, 0x33, 0x68, 0x17, 0x10, 0xbd, 0x4a, - 0xab, 0x91, 0xb3, 0x4d, 0xe2, 0xc6, 0x07, 0x7b, 0x6f, 0xfc, 0xcc, 0xfd, 0x83, 0x59, 0xb4, 0x9e, - 0x22, 0x81, 0x33, 0xc8, 0xa2, 0xb7, 0xe1, 0x14, 0x2d, 0x4d, 0x7d, 0xeb, 0x50, 0xef, 0xcd, 0x4d, - 0xdf, 0x3f, 0x98, 0x3d, 0xb5, 0x9e, 0x41, 0x04, 0x67, 0x92, 0x46, 0xdf, 0x65, 0xc1, 0xd9, 0xf8, - 0xf3, 0x97, 0xef, 0xb6, 0x1c, 0xaf, 0x1e, 0x37, 0x5c, 0xea, 0xbd, 0x61, 0x7a, 0x26, 0x9f, 0x5d, - 0xca, 0xa3, 0x84, 0xf3, 0x1b, 0x41, 0x1e, 0x4c, 0xd1, 0xae, 0x25, 0xdb, 0x86, 0xde, 0xdb, 0x7e, - 0xe4, 0xfe, 0xc1, 0xec, 0xd4, 0x7a, 0x9a, 0x06, 0xce, 0x22, 0x3c, 0xb3, 0x04, 0xa7, 0x33, 0x57, - 0x27, 0x9a, 0x80, 0xe2, 0x2e, 0xe1, 0x5c, 0x57, 0x09, 0xd3, 0x9f, 0xe8, 0x14, 0xf4, 0xef, 0x39, - 0x8d, 0xb6, 0xd8, 0x98, 0x98, 0xff, 0x79, 0xb5, 0xf0, 0x8a, 0x65, 0xff, 0x8b, 0x22, 0x8c, 0x2f, - 0x55, 0x57, 0x1f, 0x68, 0xd7, 0xeb, 0xd7, 0x5e, 0xa1, 0xe3, 0xb5, 0x17, 0x5f, 0xa2, 0xc5, 0xdc, - 0x4b, 0xf4, 0xcf, 0x66, 0x6c, 0xd9, 0x3e, 0xb6, 0x65, 0xbf, 0x2d, 0x67, 0xcb, 0x1e, 0xf3, 0x46, - 0xdd, 0xcb, 0x59, 0xb5, 0xfd, 0x6c, 0x02, 0x33, 0x39, 0xa4, 0xeb, 0x7e, 0xcd, 0x69, 0x24, 0x8f, - 0xda, 0x23, 0x2e, 0xdd, 0xe3, 0x99, 0xc7, 0x1a, 0x8c, 0x2c, 0x39, 0x2d, 0x67, 0xd3, 0x6d, 0xb8, - 0x91, 0x4b, 0x42, 0xf4, 0x34, 0x14, 0x9d, 0x7a, 0x9d, 0x71, 0x77, 0xa5, 0xc5, 0xd3, 0xf7, 0x0f, - 0x66, 0x8b, 0x0b, 0x75, 0xca, 0x66, 0x80, 0xc2, 0xda, 0xc7, 0x14, 0x03, 0xbd, 0x1f, 0xfa, 0xea, - 0x81, 0xdf, 0x9a, 0x2e, 0x30, 0x4c, 0xba, 0xcb, 0xfb, 0xca, 0x81, 0xdf, 0x4a, 0xa0, 0x32, 0x1c, - 0xfb, 0x57, 0x0a, 0xf0, 0xd8, 0x12, 0x69, 0xed, 0xac, 0x54, 0x73, 0xee, 0x8b, 0x4b, 0x30, 0xd4, - 0xf4, 0x3d, 0x37, 0xf2, 0x83, 0x50, 0x34, 0xcd, 0x56, 0xc4, 0x9a, 0x28, 0xc3, 0x0a, 0x8a, 0x2e, - 0x40, 0x5f, 0x2b, 0x66, 0x62, 0x47, 0x24, 0x03, 0xcc, 0xd8, 0x57, 0x06, 0xa1, 0x18, 0xed, 0x90, - 0x04, 0x62, 0xc5, 0x28, 0x8c, 0x9b, 0x21, 0x09, 0x30, 0x83, 0xc4, 0x9c, 0x00, 0xe5, 0x11, 0xc4, - 0x8d, 0x90, 0xe0, 0x04, 0x28, 0x04, 0x6b, 0x58, 0xa8, 0x02, 0xa5, 0x30, 0x31, 0xb3, 0x3d, 0x6d, - 0xcd, 0x51, 0xc6, 0x2a, 0xa8, 0x99, 0x8c, 0x89, 0x18, 0x37, 0xd8, 0x40, 0x57, 0x56, 0xe1, 0xab, - 0x05, 0x40, 0x7c, 0x08, 0xbf, 0xc9, 0x06, 0xee, 0x66, 0x7a, 0xe0, 0x7a, 0xdf, 0x12, 0xc7, 0x35, - 0x7a, 0xff, 0xc3, 0x82, 0xc7, 0x96, 0x5c, 0xaf, 0x4e, 0x82, 0x9c, 0x05, 0xf8, 0x70, 0xde, 0xce, - 0x47, 0x63, 0x52, 0x8c, 0x25, 0xd6, 0x77, 0x0c, 0x4b, 0xcc, 0xfe, 0x43, 0x0b, 0x10, 0xff, 0xec, - 0x77, 0xdd, 0xc7, 0xde, 0x4c, 0x7f, 0xec, 0x31, 0x2c, 0x0b, 0xfb, 0x3a, 0x8c, 0x2d, 0x35, 0x5c, - 0xe2, 0x45, 0xab, 0x95, 0x25, 0xdf, 0xdb, 0x72, 0xb7, 0xd1, 0xab, 0x30, 0x16, 0xb9, 0x4d, 0xe2, - 0xb7, 0xa3, 0x2a, 0xa9, 0xf9, 0x1e, 0x7b, 0xb9, 0x5a, 0x97, 0xfa, 0x17, 0xd1, 0xfd, 0x83, 0xd9, - 0xb1, 0x0d, 0x03, 0x82, 0x13, 0x98, 0xf6, 0x6f, 0xd3, 0xf1, 0xf3, 0x9b, 0x2d, 0xdf, 0x23, 0x5e, - 0xb4, 0xe4, 0x7b, 0x75, 0x2e, 0xe1, 0x78, 0x15, 0xfa, 0x22, 0x3a, 0x1e, 0x7c, 0xec, 0x2e, 0xca, - 0x8d, 0x42, 0x47, 0xe1, 0xf0, 0x60, 0xf6, 0x4c, 0xba, 0x06, 0x1b, 0x27, 0x56, 0x07, 0x7d, 0x1b, - 0x0c, 0x84, 0x91, 0x13, 0xb5, 0x43, 0x31, 0x9a, 0x8f, 0xcb, 0xd1, 0xac, 0xb2, 0xd2, 0xc3, 0x83, - 0xd9, 0x71, 0x55, 0x8d, 0x17, 0x61, 0x51, 0x01, 0x3d, 0x03, 0x83, 0x4d, 0x12, 0x86, 0xce, 0xb6, - 0xbc, 0x0d, 0xc7, 0x45, 0xdd, 0xc1, 0x35, 0x5e, 0x8c, 0x25, 0x1c, 0x3d, 0x01, 0xfd, 0x24, 0x08, - 0xfc, 0x40, 0xec, 0xd1, 0x51, 0x81, 0xd8, 0xbf, 0x4c, 0x0b, 0x31, 0x87, 0xd9, 0xff, 0xd6, 0x82, - 0x71, 0xd5, 0x57, 0xde, 0xd6, 0x09, 0xbc, 0x42, 0x3e, 0x01, 0x50, 0x93, 0x1f, 0x18, 0xb2, 0xdb, - 0x63, 0xf8, 0x85, 0x8b, 0x99, 0x17, 0x75, 0x6a, 0x18, 0x63, 0xca, 0xaa, 0x28, 0xc4, 0x1a, 0x35, - 0xfb, 0x1f, 0x59, 0x30, 0x95, 0xf8, 0xa2, 0xeb, 0x6e, 0x18, 0xa1, 0xb7, 0x52, 0x5f, 0x35, 0xd7, - 0xdb, 0x57, 0xd1, 0xda, 0xec, 0x9b, 0xd4, 0x52, 0x96, 0x25, 0xda, 0x17, 0x5d, 0x85, 0x7e, 0x37, - 0x22, 0x4d, 0xf9, 0x31, 0x4f, 0x74, 0xfc, 0x18, 0xde, 0xab, 0x78, 0x46, 0x56, 0x69, 0x4d, 0xcc, - 0x09, 0xd8, 0xbf, 0x52, 0x84, 0x12, 0x5f, 0xb6, 0x6b, 0x4e, 0xeb, 0x04, 0xe6, 0xe2, 0x59, 0x28, - 0xb9, 0xcd, 0x66, 0x3b, 0x72, 0x36, 0xc5, 0x71, 0x3e, 0xc4, 0xb7, 0xd6, 0xaa, 0x2c, 0xc4, 0x31, - 0x1c, 0xad, 0x42, 0x1f, 0xeb, 0x0a, 0xff, 0xca, 0xa7, 0xb3, 0xbf, 0x52, 0xf4, 0x7d, 0xae, 0xec, - 0x44, 0x0e, 0xe7, 0xa4, 0xd4, 0x3d, 0x42, 0x8b, 0x30, 0x23, 0x81, 0x1c, 0x80, 0x4d, 0xd7, 0x73, - 0x82, 0x7d, 0x5a, 0x36, 0x5d, 0x64, 0x04, 0x9f, 0xef, 0x4c, 0x70, 0x51, 0xe1, 0x73, 0xb2, 0xea, - 0xc3, 0x62, 0x00, 0xd6, 0x88, 0xce, 0x7c, 0x08, 0x4a, 0x0a, 0xf9, 0x28, 0x0c, 0xd1, 0xcc, 0x47, - 0x60, 0x3c, 0xd1, 0x56, 0xb7, 0xea, 0x23, 0x3a, 0x3f, 0xf5, 0x8b, 0xec, 0xc8, 0x10, 0xbd, 0x5e, - 0xf6, 0xf6, 0xc4, 0x91, 0x7b, 0x0f, 0x4e, 0x35, 0x32, 0x4e, 0x32, 0x31, 0xaf, 0xbd, 0x9f, 0x7c, - 0x8f, 0x89, 0xcf, 0x3e, 0x95, 0x05, 0xc5, 0x99, 0x6d, 0x50, 0x1e, 0xc1, 0x6f, 0xd1, 0x0d, 0xe2, - 0x34, 0x74, 0x76, 0xfb, 0x86, 0x28, 0xc3, 0x0a, 0x4a, 0xcf, 0xbb, 0x53, 0xaa, 0xf3, 0xd7, 0xc8, - 0x7e, 0x95, 0x34, 0x48, 0x2d, 0xf2, 0x83, 0x6f, 0x68, 0xf7, 0xcf, 0xf1, 0xd1, 0xe7, 0xc7, 0xe5, - 0xb0, 0x20, 0x50, 0xbc, 0x46, 0xf6, 0xf9, 0x54, 0xe8, 0x5f, 0x57, 0xec, 0xf8, 0x75, 0x3f, 0x63, - 0xc1, 0xa8, 0xfa, 0xba, 0x13, 0x38, 0x17, 0x16, 0xcd, 0x73, 0xe1, 0x5c, 0xc7, 0x05, 0x9e, 0x73, - 0x22, 0x7c, 0xb5, 0x00, 0x67, 0x15, 0x0e, 0x7d, 0x1b, 0xf0, 0x3f, 0x62, 0x55, 0xcd, 0x43, 0xc9, - 0x53, 0x52, 0x32, 0xcb, 0x14, 0x4f, 0xc5, 0x32, 0xb2, 0x18, 0x87, 0xb2, 0x78, 0x5e, 0x2c, 0xca, - 0x1a, 0xd1, 0xc5, 0xc7, 0x42, 0x54, 0xbc, 0x08, 0xc5, 0xb6, 0x5b, 0x17, 0x17, 0xcc, 0x07, 0xe4, - 0x68, 0xdf, 0x5c, 0x2d, 0x1f, 0x1e, 0xcc, 0x3e, 0x9e, 0xa7, 0xba, 0xa0, 0x37, 0x5b, 0x38, 0x77, - 0x73, 0xb5, 0x8c, 0x69, 0x65, 0xb4, 0x00, 0xe3, 0x52, 0x3b, 0x73, 0x8b, 0xb2, 0x5b, 0xbe, 0x27, - 0xee, 0x21, 0x25, 0x03, 0xc6, 0x26, 0x18, 0x27, 0xf1, 0x51, 0x19, 0x26, 0x76, 0xdb, 0x9b, 0xa4, - 0x41, 0x22, 0xfe, 0xc1, 0xd7, 0x08, 0x97, 0x90, 0x96, 0xe2, 0x97, 0xd9, 0xb5, 0x04, 0x1c, 0xa7, - 0x6a, 0xd8, 0x7f, 0xca, 0xee, 0x03, 0x31, 0x7a, 0x95, 0xc0, 0xa7, 0x0b, 0x8b, 0x52, 0xff, 0x46, - 0x2e, 0xe7, 0x5e, 0x56, 0xc5, 0x35, 0xb2, 0xbf, 0xe1, 0x53, 0xce, 0x3c, 0x7b, 0x55, 0x18, 0x6b, - 0xbe, 0xaf, 0xe3, 0x9a, 0xff, 0xd9, 0x02, 0x9c, 0x56, 0x23, 0x60, 0x30, 0x81, 0xdf, 0xec, 0x63, - 0x70, 0x19, 0x86, 0xeb, 0x64, 0xcb, 0x69, 0x37, 0x22, 0x25, 0xae, 0xef, 0xe7, 0x2a, 0x9b, 0x72, - 0x5c, 0x8c, 0x75, 0x9c, 0x23, 0x0c, 0xdb, 0xff, 0x1c, 0x66, 0x17, 0x71, 0xe4, 0xd0, 0x35, 0xae, - 0x76, 0x8d, 0x95, 0xbb, 0x6b, 0x9e, 0x80, 0x7e, 0xb7, 0x49, 0x19, 0xb3, 0x82, 0xc9, 0x6f, 0xad, - 0xd2, 0x42, 0xcc, 0x61, 0xe8, 0x29, 0x18, 0xac, 0xf9, 0xcd, 0xa6, 0xe3, 0xd5, 0xd9, 0x95, 0x57, - 0x5a, 0x1c, 0xa6, 0xbc, 0xdb, 0x12, 0x2f, 0xc2, 0x12, 0x86, 0x1e, 0x83, 0x3e, 0x27, 0xd8, 0xe6, - 0x32, 0x8c, 0xd2, 0xe2, 0x10, 0x6d, 0x69, 0x21, 0xd8, 0x0e, 0x31, 0x2b, 0xa5, 0x4f, 0xb0, 0x3b, - 0x7e, 0xb0, 0xeb, 0x7a, 0xdb, 0x65, 0x37, 0x10, 0x5b, 0x42, 0xdd, 0x85, 0xb7, 0x15, 0x04, 0x6b, - 0x58, 0x68, 0x05, 0xfa, 0x5b, 0x7e, 0x10, 0x85, 0xd3, 0x03, 0x6c, 0xb8, 0x1f, 0xcf, 0x39, 0x88, - 0xf8, 0xd7, 0x56, 0xfc, 0x20, 0x8a, 0x3f, 0x80, 0xfe, 0x0b, 0x31, 0xaf, 0x8e, 0xae, 0xc3, 0x20, - 0xf1, 0xf6, 0x56, 0x02, 0xbf, 0x39, 0x3d, 0x95, 0x4f, 0x69, 0x99, 0xa3, 0xf0, 0x65, 0x16, 0xf3, - 0xa8, 0xa2, 0x18, 0x4b, 0x12, 0xe8, 0xdb, 0xa0, 0x48, 0xbc, 0xbd, 0xe9, 0x41, 0x46, 0x69, 0x26, - 0x87, 0xd2, 0x2d, 0x27, 0x88, 0xcf, 0xfc, 0x65, 0x6f, 0x0f, 0xd3, 0x3a, 0xe8, 0xe3, 0x50, 0x92, - 0x07, 0x46, 0x28, 0x84, 0x83, 0x99, 0x0b, 0x56, 0x1e, 0x33, 0x98, 0xbc, 0xdd, 0x76, 0x03, 0xd2, - 0x24, 0x5e, 0x14, 0xc6, 0x27, 0xa4, 0x84, 0x86, 0x38, 0xa6, 0x86, 0x3e, 0x2e, 0x25, 0xd2, 0x6b, - 0x7e, 0xdb, 0x8b, 0xc2, 0xe9, 0x12, 0xeb, 0x5e, 0xa6, 0xae, 0xf0, 0x56, 0x8c, 0x97, 0x14, 0x59, - 0xf3, 0xca, 0xd8, 0x20, 0x85, 0x3e, 0x09, 0xa3, 0xfc, 0x3f, 0xd7, 0xb8, 0x85, 0xd3, 0xa7, 0x19, - 0xed, 0x0b, 0xf9, 0xb4, 0x39, 0xe2, 0xe2, 0x69, 0x41, 0x7c, 0x54, 0x2f, 0x0d, 0xb1, 0x49, 0x0d, - 0x61, 0x18, 0x6d, 0xb8, 0x7b, 0xc4, 0x23, 0x61, 0x58, 0x09, 0xfc, 0x4d, 0x22, 0x04, 0x88, 0x67, - 0xb3, 0x35, 0x74, 0xfe, 0x26, 0x59, 0x9c, 0xa4, 0x34, 0xaf, 0xeb, 0x75, 0xb0, 0x49, 0x02, 0xdd, - 0x84, 0x31, 0xfa, 0x62, 0x73, 0x63, 0xa2, 0xc3, 0xdd, 0x88, 0xb2, 0x77, 0x15, 0x36, 0x2a, 0xe1, - 0x04, 0x11, 0x74, 0x03, 0x46, 0xc2, 0xc8, 0x09, 0xa2, 0x76, 0x8b, 0x13, 0x3d, 0xd3, 0x8d, 0x28, - 0x53, 0xf0, 0x56, 0xb5, 0x2a, 0xd8, 0x20, 0x80, 0xde, 0x80, 0x52, 0xc3, 0xdd, 0x22, 0xb5, 0xfd, - 0x5a, 0x83, 0x4c, 0x8f, 0x30, 0x6a, 0x99, 0x87, 0xca, 0x75, 0x89, 0xc4, 0xf9, 0x5c, 0xf5, 0x17, - 0xc7, 0xd5, 0xd1, 0x2d, 0x38, 0x13, 0x91, 0xa0, 0xe9, 0x7a, 0x0e, 0x3d, 0x0c, 0xc4, 0xd3, 0x8a, - 0x29, 0x4e, 0x47, 0xd9, 0x6e, 0x3b, 0x2f, 0x66, 0xe3, 0xcc, 0x46, 0x26, 0x16, 0xce, 0xa9, 0x8d, - 0xee, 0xc2, 0x74, 0x06, 0xc4, 0x6f, 0xb8, 0xb5, 0xfd, 0xe9, 0x53, 0x8c, 0xf2, 0x87, 0x05, 0xe5, - 0xe9, 0x8d, 0x1c, 0xbc, 0xc3, 0x0e, 0x30, 0x9c, 0x4b, 0x1d, 0xdd, 0x80, 0x71, 0x76, 0x02, 0x55, - 0xda, 0x8d, 0x86, 0x68, 0x70, 0x8c, 0x35, 0xf8, 0x94, 0xbc, 0x8f, 0x57, 0x4d, 0xf0, 0xe1, 0xc1, - 0x2c, 0xc4, 0xff, 0x70, 0xb2, 0x36, 0xda, 0x64, 0x3a, 0xba, 0x76, 0xe0, 0x46, 0xfb, 0xf4, 0xdc, - 0x20, 0x77, 0xa3, 0xe9, 0xf1, 0x8e, 0xf2, 0x0a, 0x1d, 0x55, 0x29, 0xf2, 0xf4, 0x42, 0x9c, 0x24, - 0x48, 0x8f, 0xd4, 0x30, 0xaa, 0xbb, 0xde, 0xf4, 0x04, 0x7f, 0x97, 0xc8, 0x13, 0xa9, 0x4a, 0x0b, - 0x31, 0x87, 0x31, 0xfd, 0x1c, 0xfd, 0x71, 0x83, 0xde, 0x5c, 0x93, 0x0c, 0x31, 0xd6, 0xcf, 0x49, - 0x00, 0x8e, 0x71, 0x28, 0x33, 0x19, 0x45, 0xfb, 0xd3, 0x88, 0xa1, 0xaa, 0x83, 0x65, 0x63, 0xe3, - 0xe3, 0x98, 0x96, 0xdb, 0x9b, 0x30, 0xa6, 0x0e, 0x42, 0x36, 0x26, 0x68, 0x16, 0xfa, 0x19, 0xfb, - 0x24, 0xa4, 0x6b, 0x25, 0xda, 0x05, 0xc6, 0x5a, 0x61, 0x5e, 0xce, 0xba, 0xe0, 0xde, 0x23, 0x8b, - 0xfb, 0x11, 0xe1, 0x6f, 0xfa, 0xa2, 0xd6, 0x05, 0x09, 0xc0, 0x31, 0x8e, 0xfd, 0xff, 0x38, 0x1b, - 0x1a, 0x9f, 0xb6, 0x3d, 0xdc, 0x2f, 0xcf, 0xc1, 0xd0, 0x8e, 0x1f, 0x46, 0x14, 0x9b, 0xb5, 0xd1, - 0x1f, 0x33, 0x9e, 0x57, 0x45, 0x39, 0x56, 0x18, 0xe8, 0x35, 0x18, 0xad, 0xe9, 0x0d, 0x88, 0xcb, - 0x51, 0x1d, 0x23, 0x46, 0xeb, 0xd8, 0xc4, 0x45, 0xaf, 0xc0, 0x10, 0xb3, 0x39, 0xa9, 0xf9, 0x0d, - 0xc1, 0xb5, 0xc9, 0x1b, 0x7e, 0xa8, 0x22, 0xca, 0x0f, 0xb5, 0xdf, 0x58, 0x61, 0xa3, 0x8b, 0x30, - 0x40, 0xbb, 0xb0, 0x5a, 0x11, 0xd7, 0x92, 0x12, 0x14, 0x5d, 0x65, 0xa5, 0x58, 0x40, 0xed, 0xbf, - 0x58, 0xd0, 0x46, 0x99, 0xbe, 0x87, 0x09, 0xaa, 0xc0, 0xe0, 0x1d, 0xc7, 0x8d, 0x5c, 0x6f, 0x5b, - 0xf0, 0x1f, 0xcf, 0x74, 0xbc, 0xa3, 0x58, 0xa5, 0xdb, 0xbc, 0x02, 0xbf, 0x45, 0xc5, 0x1f, 0x2c, - 0xc9, 0x50, 0x8a, 0x41, 0xdb, 0xf3, 0x28, 0xc5, 0x42, 0xaf, 0x14, 0x31, 0xaf, 0xc0, 0x29, 0x8a, - 0x3f, 0x58, 0x92, 0x41, 0x6f, 0x01, 0xc8, 0x1d, 0x46, 0xea, 0xc2, 0xd6, 0xe3, 0xb9, 0xee, 0x44, - 0x37, 0x54, 0x9d, 0xc5, 0x31, 0x7a, 0x47, 0xc7, 0xff, 0xb1, 0x46, 0xcf, 0x8e, 0x18, 0x9f, 0x96, - 0xee, 0x0c, 0xfa, 0x0e, 0xba, 0xc4, 0x9d, 0x20, 0x22, 0xf5, 0x85, 0x48, 0x0c, 0xce, 0xfb, 0x7b, - 0x7b, 0xa4, 0x6c, 0xb8, 0x4d, 0xa2, 0x6f, 0x07, 0x41, 0x04, 0xc7, 0xf4, 0xec, 0x9f, 0x2f, 0xc2, - 0x74, 0x5e, 0x77, 0xe9, 0xa2, 0x23, 0x77, 0xdd, 0x68, 0x89, 0xb2, 0x57, 0x96, 0xb9, 0xe8, 0x96, - 0x45, 0x39, 0x56, 0x18, 0x74, 0xf6, 0x43, 0x77, 0x5b, 0xbe, 0x31, 0xfb, 0xe3, 0xd9, 0xaf, 0xb2, - 0x52, 0x2c, 0xa0, 0x14, 0x2f, 0x20, 0x4e, 0x28, 0x8c, 0x89, 0xb4, 0x55, 0x82, 0x59, 0x29, 0x16, - 0x50, 0x5d, 0xda, 0xd5, 0xd7, 0x45, 0xda, 0x65, 0x0c, 0x51, 0xff, 0xf1, 0x0e, 0x11, 0xfa, 0x14, - 0xc0, 0x96, 0xeb, 0xb9, 0xe1, 0x0e, 0xa3, 0x3e, 0x70, 0x64, 0xea, 0x8a, 0x39, 0x5b, 0x51, 0x54, - 0xb0, 0x46, 0x11, 0xbd, 0x0c, 0xc3, 0x6a, 0x03, 0xae, 0x96, 0x99, 0x66, 0x55, 0xb3, 0x54, 0x89, - 0x4f, 0xa3, 0x32, 0xd6, 0xf1, 0xec, 0xcf, 0x24, 0xd7, 0x8b, 0xd8, 0x01, 0xda, 0xf8, 0x5a, 0xbd, - 0x8e, 0x6f, 0xa1, 0xf3, 0xf8, 0xda, 0x5f, 0x2f, 0xc2, 0xb8, 0xd1, 0x58, 0x3b, 0xec, 0xe1, 0xcc, - 0xba, 0x42, 0x0f, 0x70, 0x27, 0x22, 0x62, 0xff, 0xd9, 0xdd, 0xb7, 0x8a, 0x7e, 0xc8, 0xd3, 0x1d, - 0xc0, 0xeb, 0xa3, 0x4f, 0x41, 0xa9, 0xe1, 0x84, 0x4c, 0x72, 0x46, 0xc4, 0xbe, 0xeb, 0x85, 0x58, - 0xfc, 0x30, 0x71, 0xc2, 0x48, 0xbb, 0x35, 0x39, 0xed, 0x98, 0x24, 0xbd, 0x69, 0x28, 0x7f, 0x22, - 0xad, 0xd5, 0x54, 0x27, 0x28, 0x13, 0xb3, 0x8f, 0x39, 0x0c, 0xbd, 0x02, 0x23, 0x01, 0x61, 0xab, - 0x62, 0x89, 0x72, 0x73, 0x6c, 0x99, 0xf5, 0xc7, 0x6c, 0x1f, 0xd6, 0x60, 0xd8, 0xc0, 0x8c, 0xdf, - 0x06, 0x03, 0x1d, 0xde, 0x06, 0xcf, 0xc0, 0x20, 0xfb, 0xa1, 0x56, 0x80, 0x9a, 0x8d, 0x55, 0x5e, - 0x8c, 0x25, 0x3c, 0xb9, 0x60, 0x86, 0x7a, 0x5b, 0x30, 0xf4, 0xf5, 0x21, 0x16, 0x35, 0xd3, 0x6a, - 0x0f, 0xf1, 0x53, 0x4e, 0x2c, 0x79, 0x2c, 0x61, 0xf6, 0xfb, 0x61, 0xac, 0xec, 0x90, 0xa6, 0xef, - 0x2d, 0x7b, 0xf5, 0x96, 0xef, 0x7a, 0x11, 0x9a, 0x86, 0x3e, 0x76, 0x89, 0xf0, 0x23, 0xa0, 0x8f, - 0x36, 0x84, 0x59, 0x89, 0xbd, 0x0d, 0xa7, 0xcb, 0xfe, 0x1d, 0xef, 0x8e, 0x13, 0xd4, 0x17, 0x2a, - 0xab, 0xda, 0xfb, 0x7a, 0x5d, 0xbe, 0xef, 0xb8, 0x91, 0x58, 0xe6, 0xd1, 0xab, 0xd5, 0xe4, 0x6c, - 0xed, 0x8a, 0xdb, 0x20, 0x39, 0x52, 0x90, 0xbf, 0x52, 0x30, 0x5a, 0x8a, 0xf1, 0x95, 0x56, 0xcb, - 0xca, 0xd5, 0x6a, 0xbd, 0x09, 0x43, 0x5b, 0x2e, 0x69, 0xd4, 0x31, 0xd9, 0x12, 0x2b, 0xf1, 0xe9, - 0x7c, 0xbb, 0x97, 0x15, 0x8a, 0x29, 0xa5, 0x5e, 0xfc, 0x75, 0xb8, 0x22, 0x2a, 0x63, 0x45, 0x06, - 0xed, 0xc2, 0x84, 0x7c, 0x30, 0x48, 0xa8, 0x58, 0x97, 0xcf, 0x74, 0x7a, 0x85, 0x98, 0xc4, 0x4f, - 0xdd, 0x3f, 0x98, 0x9d, 0xc0, 0x09, 0x32, 0x38, 0x45, 0x98, 0x3e, 0x07, 0x9b, 0xf4, 0x04, 0xee, - 0x63, 0xc3, 0xcf, 0x9e, 0x83, 0xec, 0x65, 0xcb, 0x4a, 0xed, 0x1f, 0xb3, 0xe0, 0x91, 0xd4, 0xc8, - 0x88, 0x17, 0xfe, 0x31, 0xcf, 0x42, 0xf2, 0xc5, 0x5d, 0xe8, 0xfe, 0xe2, 0xb6, 0xff, 0xb6, 0x05, - 0xa7, 0x96, 0x9b, 0xad, 0x68, 0xbf, 0xec, 0x9a, 0x2a, 0xa8, 0x0f, 0xc1, 0x40, 0x93, 0xd4, 0xdd, - 0x76, 0x53, 0xcc, 0xdc, 0xac, 0x3c, 0xa5, 0xd6, 0x58, 0xe9, 0xe1, 0xc1, 0xec, 0x68, 0x35, 0xf2, - 0x03, 0x67, 0x9b, 0xf0, 0x02, 0x2c, 0xd0, 0xd9, 0x59, 0xef, 0xde, 0x23, 0xd7, 0xdd, 0xa6, 0x2b, - 0xed, 0x98, 0x3a, 0xca, 0xec, 0xe6, 0xe4, 0x80, 0xce, 0xbd, 0xd9, 0x76, 0xbc, 0xc8, 0x8d, 0xf6, - 0x85, 0xf6, 0x48, 0x12, 0xc1, 0x31, 0x3d, 0xfb, 0x6b, 0x16, 0x8c, 0xcb, 0x75, 0xbf, 0x50, 0xaf, - 0x07, 0x24, 0x0c, 0xd1, 0x0c, 0x14, 0xdc, 0x96, 0xe8, 0x25, 0x88, 0x5e, 0x16, 0x56, 0x2b, 0xb8, - 0xe0, 0xb6, 0x24, 0x5b, 0xc6, 0x0e, 0xc2, 0xa2, 0xa9, 0x48, 0xbb, 0x2a, 0xca, 0xb1, 0xc2, 0x40, - 0x97, 0x60, 0xc8, 0xf3, 0xeb, 0xdc, 0x96, 0x8c, 0x5f, 0x69, 0x6c, 0x81, 0xad, 0x8b, 0x32, 0xac, - 0xa0, 0xa8, 0x02, 0x25, 0x6e, 0x66, 0x15, 0x2f, 0xda, 0x9e, 0x8c, 0xb5, 0xd8, 0x97, 0x6d, 0xc8, - 0x9a, 0x38, 0x26, 0x62, 0xff, 0xb2, 0x05, 0x23, 0xf2, 0xcb, 0x7a, 0xe4, 0x39, 0xe9, 0xd6, 0x8a, - 0xf9, 0xcd, 0x78, 0x6b, 0x51, 0x9e, 0x91, 0x41, 0x0c, 0x56, 0xb1, 0x78, 0x24, 0x56, 0xf1, 0x32, - 0x0c, 0x3b, 0xad, 0x56, 0xc5, 0xe4, 0x33, 0xd9, 0x52, 0x5a, 0x88, 0x8b, 0xb1, 0x8e, 0x63, 0xff, - 0x68, 0x01, 0xc6, 0xe4, 0x17, 0x54, 0xdb, 0x9b, 0x21, 0x89, 0xd0, 0x06, 0x94, 0x1c, 0x3e, 0x4b, - 0x44, 0x2e, 0xf2, 0x27, 0xb2, 0xe5, 0x08, 0xc6, 0x94, 0xc6, 0x17, 0xfe, 0x82, 0xac, 0x8d, 0x63, - 0x42, 0xa8, 0x01, 0x93, 0x9e, 0x1f, 0xb1, 0xc3, 0x5f, 0xc1, 0x3b, 0xa9, 0x76, 0x92, 0xd4, 0xcf, - 0x0a, 0xea, 0x93, 0xeb, 0x49, 0x2a, 0x38, 0x4d, 0x18, 0x2d, 0x4b, 0xd9, 0x4c, 0x31, 0x5f, 0x18, - 0xa0, 0x4f, 0x5c, 0xb6, 0x68, 0xc6, 0xfe, 0x25, 0x0b, 0x4a, 0x12, 0xed, 0x24, 0xb4, 0x78, 0x6b, - 0x30, 0x18, 0xb2, 0x49, 0x90, 0x43, 0x63, 0x77, 0xea, 0x38, 0x9f, 0xaf, 0xf8, 0x4e, 0xe3, 0xff, - 0x43, 0x2c, 0x69, 0x30, 0xd1, 0xbc, 0xea, 0xfe, 0xbb, 0x44, 0x34, 0xaf, 0xfa, 0x93, 0x73, 0x29, - 0xfd, 0x3e, 0xeb, 0xb3, 0x26, 0xeb, 0xa2, 0xac, 0x57, 0x2b, 0x20, 0x5b, 0xee, 0xdd, 0x24, 0xeb, - 0x55, 0x61, 0xa5, 0x58, 0x40, 0xd1, 0x5b, 0x30, 0x52, 0x93, 0x32, 0xd9, 0x78, 0x87, 0x5f, 0xec, - 0xa8, 0x1f, 0x50, 0xaa, 0x24, 0x2e, 0x0b, 0x59, 0xd2, 0xea, 0x63, 0x83, 0x9a, 0x69, 0x46, 0x50, - 0xec, 0x66, 0x46, 0x10, 0xd3, 0xcd, 0x57, 0xaa, 0xff, 0xb8, 0x05, 0x03, 0x5c, 0x16, 0xd7, 0x9b, - 0x28, 0x54, 0xd3, 0xac, 0xc5, 0x63, 0x77, 0x8b, 0x16, 0x0a, 0x4d, 0x19, 0x5a, 0x83, 0x12, 0xfb, - 0xc1, 0x64, 0x89, 0xc5, 0x7c, 0x2b, 0x7f, 0xde, 0xaa, 0xde, 0xc1, 0x5b, 0xb2, 0x1a, 0x8e, 0x29, - 0xd8, 0x3f, 0x52, 0xa4, 0xa7, 0x5b, 0x8c, 0x6a, 0x5c, 0xfa, 0xd6, 0xc3, 0xbb, 0xf4, 0x0b, 0x0f, - 0xeb, 0xd2, 0xdf, 0x86, 0xf1, 0x9a, 0xa6, 0x87, 0x8b, 0x67, 0xf2, 0x52, 0xc7, 0x45, 0xa2, 0xa9, - 0xec, 0xb8, 0x94, 0x65, 0xc9, 0x24, 0x82, 0x93, 0x54, 0xd1, 0x77, 0xc0, 0x08, 0x9f, 0x67, 0xd1, - 0x0a, 0xb7, 0xc4, 0x78, 0x2a, 0x7f, 0xbd, 0xe8, 0x4d, 0x70, 0xa9, 0x9c, 0x56, 0x1d, 0x1b, 0xc4, - 0xec, 0x3f, 0xb2, 0x00, 0x2d, 0xb7, 0x76, 0x48, 0x93, 0x04, 0x4e, 0x23, 0x16, 0xa7, 0xff, 0xa0, - 0x05, 0xd3, 0x24, 0x55, 0xbc, 0xe4, 0x37, 0x9b, 0xe2, 0xd1, 0x92, 0xf3, 0xae, 0x5e, 0xce, 0xa9, - 0xa3, 0xdc, 0x20, 0xa6, 0xf3, 0x30, 0x70, 0x6e, 0x7b, 0x68, 0x0d, 0xa6, 0xf8, 0x2d, 0xa9, 0x00, - 0x9a, 0xad, 0xf7, 0xa3, 0x82, 0xf0, 0xd4, 0x46, 0x1a, 0x05, 0x67, 0xd5, 0xb3, 0xbf, 0x67, 0x04, - 0x72, 0x7b, 0xf1, 0x9e, 0x1e, 0xe1, 0x3d, 0x3d, 0xc2, 0x7b, 0x7a, 0x84, 0xf7, 0xf4, 0x08, 0xef, - 0xe9, 0x11, 0xbe, 0xe5, 0xf5, 0x08, 0x7f, 0xc9, 0x82, 0xd3, 0xea, 0x1a, 0x30, 0x1e, 0xbe, 0x9f, - 0x85, 0x29, 0xbe, 0xdd, 0x96, 0x1a, 0x8e, 0xdb, 0xdc, 0x20, 0xcd, 0x56, 0xc3, 0x89, 0xa4, 0xd6, - 0xfd, 0x72, 0xe6, 0xca, 0x4d, 0x58, 0xac, 0x1a, 0x15, 0xb9, 0xe9, 0x7f, 0x06, 0x00, 0x67, 0x35, - 0x63, 0xff, 0xfc, 0x10, 0xf4, 0x2f, 0xef, 0x11, 0x2f, 0x3a, 0x81, 0x27, 0x42, 0x0d, 0xc6, 0x5c, - 0x6f, 0xcf, 0x6f, 0xec, 0x91, 0x3a, 0x87, 0x1f, 0xe5, 0x25, 0x7b, 0x46, 0x90, 0x1e, 0x5b, 0x35, - 0x48, 0xe0, 0x04, 0xc9, 0x87, 0x21, 0x4d, 0xbe, 0x02, 0x03, 0xfc, 0x10, 0x17, 0xa2, 0xe4, 0xcc, - 0x33, 0x9b, 0x0d, 0xa2, 0xb8, 0x9a, 0x62, 0x49, 0x37, 0xbf, 0x24, 0x44, 0x75, 0xf4, 0x19, 0x18, - 0xdb, 0x72, 0x83, 0x30, 0xda, 0x70, 0x9b, 0x24, 0x8c, 0x9c, 0x66, 0xeb, 0x01, 0xa4, 0xc7, 0x6a, - 0x1c, 0x56, 0x0c, 0x4a, 0x38, 0x41, 0x19, 0x6d, 0xc3, 0x68, 0xc3, 0xd1, 0x9b, 0x1a, 0x3c, 0x72, - 0x53, 0xea, 0x76, 0xb8, 0xae, 0x13, 0xc2, 0x26, 0x5d, 0xba, 0x9d, 0x6a, 0x4c, 0x00, 0x3a, 0xc4, - 0xc4, 0x02, 0x6a, 0x3b, 0x71, 0xc9, 0x27, 0x87, 0x51, 0x46, 0x87, 0x19, 0xc8, 0x96, 0x4c, 0x46, - 0x47, 0x33, 0x83, 0xfd, 0x34, 0x94, 0x08, 0x1d, 0x42, 0x4a, 0x58, 0x5c, 0x30, 0xf3, 0xbd, 0xf5, - 0x75, 0xcd, 0xad, 0x05, 0xbe, 0x29, 0xb7, 0x5f, 0x96, 0x94, 0x70, 0x4c, 0x14, 0x2d, 0xc1, 0x40, - 0x48, 0x02, 0x97, 0x84, 0xe2, 0xaa, 0xe9, 0x30, 0x8d, 0x0c, 0x8d, 0xfb, 0x96, 0xf0, 0xdf, 0x58, - 0x54, 0xa5, 0xcb, 0xcb, 0x61, 0x22, 0x4d, 0x76, 0x19, 0x68, 0xcb, 0x6b, 0x81, 0x95, 0x62, 0x01, - 0x45, 0x6f, 0xc0, 0x60, 0x40, 0x1a, 0x4c, 0x31, 0x34, 0xda, 0xfb, 0x22, 0xe7, 0x7a, 0x26, 0x5e, - 0x0f, 0x4b, 0x02, 0xe8, 0x1a, 0xa0, 0x80, 0x50, 0x46, 0xc9, 0xf5, 0xb6, 0x95, 0xd9, 0xa8, 0x38, - 0x68, 0x15, 0x43, 0x8a, 0x63, 0x0c, 0xe9, 0x56, 0x84, 0x33, 0xaa, 0xa1, 0x2b, 0x30, 0xa9, 0x4a, - 0x57, 0xbd, 0x30, 0x72, 0xe8, 0x01, 0x37, 0xce, 0x68, 0x29, 0x39, 0x05, 0x4e, 0x22, 0xe0, 0x74, - 0x1d, 0xfb, 0x4b, 0x16, 0xf0, 0x71, 0x3e, 0x81, 0xd7, 0xf9, 0xeb, 0xe6, 0xeb, 0xfc, 0x6c, 0xee, - 0xcc, 0xe5, 0xbc, 0xcc, 0xbf, 0x64, 0xc1, 0xb0, 0x36, 0xb3, 0xf1, 0x9a, 0xb5, 0x3a, 0xac, 0xd9, - 0x36, 0x4c, 0xd0, 0x95, 0x7e, 0x63, 0x33, 0x24, 0xc1, 0x1e, 0xa9, 0xb3, 0x85, 0x59, 0x78, 0xb0, - 0x85, 0xa9, 0x4c, 0xd4, 0xae, 0x27, 0x08, 0xe2, 0x54, 0x13, 0xf6, 0xa7, 0x65, 0x57, 0x95, 0x45, - 0x5f, 0x4d, 0xcd, 0x79, 0xc2, 0xa2, 0x4f, 0xcd, 0x2a, 0x8e, 0x71, 0xe8, 0x56, 0xdb, 0xf1, 0xc3, - 0x28, 0x69, 0xd1, 0x77, 0xd5, 0x0f, 0x23, 0xcc, 0x20, 0xf6, 0x8b, 0x00, 0xcb, 0x77, 0x49, 0x8d, - 0xaf, 0x58, 0xfd, 0xf1, 0x60, 0xe5, 0x3f, 0x1e, 0xec, 0xdf, 0xb0, 0x60, 0x6c, 0x65, 0xc9, 0xb8, - 0xb9, 0xe6, 0x00, 0xf8, 0x8b, 0xe7, 0xf6, 0xed, 0x75, 0xa9, 0x0e, 0xe7, 0x1a, 0x4d, 0x55, 0x8a, - 0x35, 0x0c, 0x74, 0x16, 0x8a, 0x8d, 0xb6, 0x27, 0xc4, 0x87, 0x83, 0xf4, 0x7a, 0xbc, 0xde, 0xf6, - 0x30, 0x2d, 0xd3, 0x5c, 0x0a, 0x8a, 0x3d, 0xbb, 0x14, 0x74, 0x0d, 0x25, 0x80, 0x66, 0xa1, 0xff, - 0xce, 0x1d, 0xb7, 0xce, 0x1d, 0x36, 0x85, 0xaa, 0xfe, 0xf6, 0xed, 0xd5, 0x72, 0x88, 0x79, 0xb9, - 0xfd, 0x85, 0x22, 0xcc, 0xac, 0x34, 0xc8, 0xdd, 0x77, 0xe8, 0xb4, 0xda, 0xab, 0x43, 0xc4, 0xd1, - 0x04, 0x31, 0x47, 0x75, 0x7a, 0xe9, 0x3e, 0x1e, 0x5b, 0x30, 0xc8, 0x0d, 0xda, 0xa4, 0x0b, 0xeb, - 0x6b, 0x59, 0xad, 0xe7, 0x0f, 0xc8, 0x1c, 0x37, 0x8c, 0x13, 0x1e, 0x71, 0xea, 0xc2, 0x14, 0xa5, - 0x58, 0x12, 0x9f, 0x79, 0x15, 0x46, 0x74, 0xcc, 0x23, 0xb9, 0x9f, 0xfd, 0xb9, 0x22, 0x4c, 0xd0, - 0x1e, 0x3c, 0xd4, 0x89, 0xb8, 0x99, 0x9e, 0x88, 0xe3, 0x76, 0x41, 0xea, 0x3e, 0x1b, 0x6f, 0x25, - 0x67, 0xe3, 0x72, 0xde, 0x6c, 0x9c, 0xf4, 0x1c, 0x7c, 0xb7, 0x05, 0x53, 0x2b, 0x0d, 0xbf, 0xb6, - 0x9b, 0x70, 0x13, 0x7a, 0x19, 0x86, 0xe9, 0x71, 0x1c, 0x1a, 0x1e, 0xf3, 0x46, 0x0c, 0x05, 0x01, - 0xc2, 0x3a, 0x9e, 0x56, 0xed, 0xe6, 0xcd, 0xd5, 0x72, 0x56, 0xe8, 0x05, 0x01, 0xc2, 0x3a, 0x9e, - 0xfd, 0x6b, 0x16, 0x9c, 0xbb, 0xb2, 0xb4, 0x1c, 0x2f, 0xc5, 0x54, 0xf4, 0x87, 0x8b, 0x30, 0xd0, - 0xaa, 0x6b, 0x5d, 0x89, 0xc5, 0xab, 0x65, 0xd6, 0x0b, 0x01, 0x7d, 0xb7, 0x44, 0x36, 0xb9, 0x09, - 0x70, 0x05, 0x57, 0x96, 0xc4, 0xb9, 0x2b, 0xb5, 0x29, 0x56, 0xae, 0x36, 0xe5, 0x29, 0x18, 0xa4, - 0xf7, 0x82, 0x5b, 0x93, 0xfd, 0xe6, 0x0a, 0x5a, 0x5e, 0x84, 0x25, 0xcc, 0xfe, 0x69, 0x0b, 0xa6, - 0xae, 0xb8, 0x11, 0xbd, 0xb4, 0x93, 0xe1, 0x0d, 0xe8, 0xad, 0x1d, 0xba, 0x91, 0x1f, 0xec, 0x27, - 0xc3, 0x1b, 0x60, 0x05, 0xc1, 0x1a, 0x16, 0xff, 0xa0, 0x3d, 0x97, 0x59, 0x68, 0x17, 0x4c, 0xfd, - 0x15, 0x16, 0xe5, 0x58, 0x61, 0xd0, 0xf1, 0xaa, 0xbb, 0x01, 0x13, 0xfd, 0xed, 0x8b, 0x83, 0x5b, - 0x8d, 0x57, 0x59, 0x02, 0x70, 0x8c, 0x63, 0xff, 0x81, 0x05, 0xb3, 0x57, 0x1a, 0xed, 0x30, 0x22, - 0xc1, 0x56, 0x98, 0x73, 0xe8, 0xbe, 0x08, 0x25, 0x22, 0x05, 0xed, 0xa2, 0xd7, 0x8a, 0x11, 0x55, - 0x12, 0x78, 0x1e, 0x65, 0x41, 0xe1, 0xf5, 0xe0, 0xcb, 0x78, 0x34, 0x67, 0xb4, 0x15, 0x40, 0x44, - 0x6f, 0x4b, 0x0f, 0x3b, 0xc1, 0xfc, 0xd7, 0x97, 0x53, 0x50, 0x9c, 0x51, 0xc3, 0xfe, 0x31, 0x0b, - 0x4e, 0xab, 0x0f, 0x7e, 0xd7, 0x7d, 0xa6, 0xfd, 0x95, 0x02, 0x8c, 0x5e, 0xdd, 0xd8, 0xa8, 0x5c, - 0x21, 0x91, 0xb6, 0x2a, 0x3b, 0xab, 0xcf, 0xb1, 0xa6, 0x05, 0xec, 0xf4, 0x46, 0x6c, 0x47, 0x6e, - 0x63, 0x8e, 0x47, 0x2f, 0x9a, 0x5b, 0xf5, 0xa2, 0x1b, 0x41, 0x35, 0x0a, 0x5c, 0x6f, 0x3b, 0x73, - 0xa5, 0x4b, 0x9e, 0xa5, 0x98, 0xc7, 0xb3, 0xa0, 0x17, 0x61, 0x80, 0x85, 0x4f, 0x92, 0x93, 0xf0, - 0xa8, 0x7a, 0x62, 0xb1, 0xd2, 0xc3, 0x83, 0xd9, 0xd2, 0x4d, 0xbc, 0xca, 0xff, 0x60, 0x81, 0x8a, - 0x6e, 0xc2, 0xf0, 0x4e, 0x14, 0xb5, 0xae, 0x12, 0xa7, 0x4e, 0x02, 0x79, 0xca, 0x9e, 0xcf, 0x3a, - 0x65, 0xe9, 0x20, 0x70, 0xb4, 0xf8, 0x60, 0x8a, 0xcb, 0x42, 0xac, 0xd3, 0xb1, 0xab, 0x00, 0x31, - 0xec, 0x98, 0x14, 0x20, 0xf6, 0x06, 0x94, 0xe8, 0xe7, 0x2e, 0x34, 0x5c, 0xa7, 0xb3, 0x8a, 0xf9, - 0x59, 0x28, 0x49, 0x05, 0x72, 0x28, 0x7c, 0xad, 0xd9, 0x8d, 0x24, 0xf5, 0xcb, 0x21, 0x8e, 0xe1, - 0xf6, 0x16, 0x9c, 0x62, 0xe6, 0x80, 0x4e, 0xb4, 0x63, 0xac, 0xbe, 0xee, 0xd3, 0xfc, 0x9c, 0x78, - 0xb1, 0xf1, 0x3e, 0x4f, 0x6b, 0xee, 0x8c, 0x23, 0x92, 0x62, 0xfc, 0x7a, 0xb3, 0xbf, 0xde, 0x07, - 0x8f, 0xae, 0x56, 0xf3, 0xc3, 0x7f, 0xbc, 0x02, 0x23, 0x9c, 0x11, 0xa4, 0x93, 0xee, 0x34, 0x44, - 0xbb, 0x4a, 0xb6, 0xb9, 0xa1, 0xc1, 0xb0, 0x81, 0x89, 0xce, 0x41, 0xd1, 0x7d, 0xdb, 0x4b, 0x3a, - 0xfb, 0xac, 0xbe, 0xb9, 0x8e, 0x69, 0x39, 0x05, 0x53, 0x9e, 0x92, 0x1f, 0xd6, 0x0a, 0xac, 0xf8, - 0xca, 0xd7, 0x61, 0xcc, 0x0d, 0x6b, 0xa1, 0xbb, 0xea, 0xd1, 0x1d, 0xa8, 0xed, 0x61, 0x25, 0x4d, - 0xa0, 0x9d, 0x56, 0x50, 0x9c, 0xc0, 0xd6, 0x6e, 0x8e, 0xfe, 0x9e, 0xf9, 0xd2, 0xae, 0xce, 0xc7, - 0xf4, 0x60, 0x6f, 0xb1, 0xaf, 0x0b, 0x99, 0x90, 0x5a, 0x1c, 0xec, 0xfc, 0x83, 0x43, 0x2c, 0x61, - 0xf4, 0xa9, 0x56, 0xdb, 0x71, 0x5a, 0x0b, 0xed, 0x68, 0xa7, 0xec, 0x86, 0x35, 0x7f, 0x8f, 0x04, - 0xfb, 0xec, 0x95, 0x3d, 0x14, 0x3f, 0xd5, 0x14, 0x60, 0xe9, 0xea, 0x42, 0x85, 0x62, 0xe2, 0x74, - 0x1d, 0xb4, 0x00, 0xe3, 0xb2, 0xb0, 0x4a, 0x42, 0x76, 0xb8, 0x0f, 0x33, 0x32, 0xca, 0xfd, 0x46, - 0x14, 0x2b, 0x22, 0x49, 0x7c, 0x93, 0x75, 0x85, 0xe3, 0x60, 0x5d, 0x3f, 0x04, 0xa3, 0xae, 0xe7, - 0x46, 0xae, 0x13, 0xf9, 0x5c, 0xc3, 0xc2, 0x1f, 0xd4, 0x4c, 0x74, 0xbc, 0xaa, 0x03, 0xb0, 0x89, - 0x67, 0xff, 0xa7, 0x3e, 0x98, 0x64, 0xd3, 0xf6, 0xde, 0x0a, 0xfb, 0x56, 0x5a, 0x61, 0x37, 0xd3, - 0x2b, 0xec, 0x38, 0x78, 0xf2, 0x07, 0x5e, 0x66, 0x9f, 0x81, 0x92, 0xf2, 0x38, 0x92, 0x2e, 0x87, - 0x56, 0x8e, 0xcb, 0x61, 0xf7, 0x7b, 0x59, 0x1a, 0x6d, 0x15, 0x33, 0x8d, 0xb6, 0xbe, 0x6c, 0x41, - 0xac, 0x32, 0x40, 0x6f, 0x42, 0xa9, 0xe5, 0x33, 0x5b, 0xc4, 0x40, 0x1a, 0xf8, 0x3e, 0xd9, 0x51, - 0xe7, 0xc0, 0x23, 0x20, 0x05, 0x7c, 0x14, 0x2a, 0xb2, 0x2a, 0x8e, 0xa9, 0xa0, 0x6b, 0x30, 0xd8, - 0x0a, 0x48, 0x35, 0x62, 0xe1, 0x39, 0x7a, 0x27, 0xc8, 0x57, 0x0d, 0xaf, 0x88, 0x25, 0x05, 0xfb, - 0xbf, 0x58, 0x30, 0x91, 0x44, 0x45, 0x1f, 0x86, 0x3e, 0x72, 0x97, 0xd4, 0x44, 0x7f, 0x33, 0x2f, - 0xd9, 0x58, 0xe8, 0xc0, 0x07, 0x80, 0xfe, 0xc7, 0xac, 0x16, 0xba, 0x0a, 0x83, 0xf4, 0x86, 0xbd, - 0xa2, 0x42, 0x51, 0x3d, 0x9e, 0x77, 0x4b, 0x2b, 0x56, 0x85, 0x77, 0x4e, 0x14, 0x61, 0x59, 0x9d, - 0x59, 0x4a, 0xd5, 0x5a, 0x55, 0xfa, 0x78, 0x89, 0x3a, 0xbd, 0xb1, 0x37, 0x96, 0x2a, 0x1c, 0x49, - 0x50, 0xe3, 0x96, 0x52, 0xb2, 0x10, 0xc7, 0x44, 0xec, 0x9f, 0xb5, 0x00, 0xb8, 0x61, 0x98, 0xe3, - 0x6d, 0x93, 0x13, 0x90, 0x93, 0x97, 0xa1, 0x2f, 0x6c, 0x91, 0x5a, 0x27, 0x33, 0xd9, 0xb8, 0x3f, - 0xd5, 0x16, 0xa9, 0xc5, 0x2b, 0x8e, 0xfe, 0xc3, 0xac, 0xb6, 0xfd, 0xbd, 0x00, 0x63, 0x31, 0xda, - 0x6a, 0x44, 0x9a, 0xe8, 0x79, 0x23, 0x4c, 0xc1, 0xd9, 0x44, 0x98, 0x82, 0x12, 0xc3, 0xd6, 0x44, - 0xb2, 0x9f, 0x81, 0x62, 0xd3, 0xb9, 0x2b, 0x64, 0x6e, 0xcf, 0x76, 0xee, 0x06, 0xa5, 0x3f, 0xb7, - 0xe6, 0xdc, 0xe5, 0xcf, 0xd2, 0x67, 0xe5, 0x0e, 0x59, 0x73, 0xee, 0x1e, 0x72, 0x63, 0x58, 0x76, - 0x4a, 0x5f, 0x77, 0xc3, 0xe8, 0x73, 0xff, 0x31, 0xfe, 0xcf, 0xf6, 0x1d, 0x6d, 0x84, 0xb5, 0xe5, - 0x7a, 0xc2, 0xe6, 0xa9, 0xa7, 0xb6, 0x5c, 0x2f, 0xd9, 0x96, 0xeb, 0xf5, 0xd0, 0x96, 0xeb, 0xa1, - 0x7b, 0x30, 0x28, 0x4c, 0x12, 0x45, 0x58, 0xa0, 0xf9, 0x1e, 0xda, 0x13, 0x16, 0x8d, 0xbc, 0xcd, - 0x79, 0xf9, 0xec, 0x16, 0xa5, 0x5d, 0xdb, 0x95, 0x0d, 0xa2, 0xbf, 0x6c, 0xc1, 0x98, 0xf8, 0x8d, - 0xc9, 0xdb, 0x6d, 0x12, 0x46, 0x82, 0x2d, 0xfd, 0x60, 0xef, 0x7d, 0x10, 0x15, 0x79, 0x57, 0x3e, - 0x28, 0xef, 0x19, 0x13, 0xd8, 0xb5, 0x47, 0x89, 0x5e, 0xa0, 0xbf, 0x6b, 0xc1, 0xa9, 0xa6, 0x73, - 0x97, 0xb7, 0xc8, 0xcb, 0xb0, 0x13, 0xb9, 0xbe, 0x50, 0xed, 0x7f, 0xb8, 0xb7, 0xe9, 0x4f, 0x55, - 0xe7, 0x9d, 0x94, 0xfa, 0xc7, 0x53, 0x59, 0x28, 0x5d, 0xbb, 0x9a, 0xd9, 0xaf, 0x99, 0x2d, 0x18, - 0x92, 0xeb, 0x2d, 0x43, 0xb8, 0x51, 0xd6, 0x79, 0xee, 0x23, 0x5b, 0x84, 0xea, 0xee, 0xff, 0xb4, - 0x1d, 0xb1, 0xd6, 0x1e, 0x6a, 0x3b, 0x9f, 0x81, 0x11, 0x7d, 0x8d, 0x3d, 0xd4, 0xb6, 0xde, 0x86, - 0xa9, 0x8c, 0xb5, 0xf4, 0x50, 0x9b, 0xbc, 0x03, 0x67, 0x73, 0xd7, 0xc7, 0xc3, 0x6c, 0xd8, 0xfe, - 0x8a, 0xa5, 0x9f, 0x83, 0x27, 0xa0, 0xac, 0x58, 0x32, 0x95, 0x15, 0xe7, 0x3b, 0xef, 0x9c, 0x1c, - 0x8d, 0xc5, 0x5b, 0x7a, 0xa7, 0xe9, 0xa9, 0x8e, 0xde, 0x80, 0x81, 0x06, 0x2d, 0x91, 0x86, 0xad, - 0x76, 0xf7, 0x1d, 0x19, 0x33, 0x93, 0xac, 0x3c, 0xc4, 0x82, 0x82, 0xfd, 0x0b, 0x16, 0xf4, 0x9d, - 0xc0, 0x48, 0x60, 0x73, 0x24, 0x9e, 0xcf, 0x25, 0x2d, 0x22, 0x24, 0xcf, 0x61, 0xe7, 0xce, 0xf2, - 0xdd, 0x88, 0x78, 0x21, 0xbb, 0x91, 0x33, 0x07, 0xe6, 0x27, 0x2d, 0x98, 0xba, 0xee, 0x3b, 0xf5, - 0x45, 0xa7, 0xe1, 0x78, 0x35, 0x12, 0xac, 0x7a, 0xdb, 0x47, 0xb2, 0xca, 0x2e, 0x74, 0xb5, 0xca, - 0x5e, 0x92, 0x46, 0x4d, 0x7d, 0xf9, 0xf3, 0x47, 0x39, 0xe9, 0x64, 0xe0, 0x16, 0xc3, 0xfc, 0x76, - 0x07, 0x90, 0xde, 0x4b, 0xe1, 0x23, 0x83, 0x61, 0xd0, 0xe5, 0xfd, 0x15, 0x93, 0xf8, 0x74, 0x36, - 0x87, 0x9b, 0xfa, 0x3c, 0xcd, 0xfb, 0x83, 0x17, 0x60, 0x49, 0xc8, 0x7e, 0x05, 0x32, 0x1d, 0xed, - 0xbb, 0xcb, 0x25, 0xec, 0x8f, 0xc3, 0x24, 0xab, 0x79, 0x44, 0xc9, 0x80, 0x9d, 0x90, 0xa6, 0x66, - 0x84, 0xe0, 0xb3, 0x3f, 0x6f, 0xc1, 0xf8, 0x7a, 0x22, 0x32, 0xd9, 0x45, 0xa6, 0x7f, 0xcd, 0x10, - 0xe2, 0x57, 0x59, 0x29, 0x16, 0xd0, 0x63, 0x17, 0x72, 0xfd, 0xa9, 0x05, 0x71, 0xec, 0x8b, 0x13, - 0x60, 0xdf, 0x96, 0x0c, 0xf6, 0x2d, 0x93, 0x91, 0x55, 0xdd, 0xc9, 0xe3, 0xde, 0xd0, 0x35, 0x15, - 0x15, 0xaa, 0x03, 0x0f, 0x1b, 0x93, 0xe1, 0x4b, 0x71, 0xcc, 0x0c, 0x1d, 0x25, 0xe3, 0x44, 0xd9, - 0xbf, 0x59, 0x00, 0xa4, 0x70, 0x7b, 0x8e, 0x5a, 0x95, 0xae, 0x71, 0x3c, 0x51, 0xab, 0xf6, 0x00, - 0x31, 0x0b, 0x82, 0xc0, 0xf1, 0x42, 0x4e, 0xd6, 0x15, 0x62, 0xbd, 0xa3, 0x99, 0x27, 0xcc, 0x88, - 0x26, 0xd1, 0xf5, 0x14, 0x35, 0x9c, 0xd1, 0x82, 0x66, 0x19, 0xd2, 0xdf, 0xab, 0x65, 0xc8, 0x40, - 0x17, 0x3f, 0xb8, 0x9f, 0xb1, 0x60, 0x54, 0x0d, 0xd3, 0xbb, 0xc4, 0x4a, 0x5d, 0xf5, 0x27, 0xe7, - 0x00, 0xad, 0x68, 0x5d, 0x66, 0x17, 0xcb, 0xb7, 0x33, 0x7f, 0x46, 0xa7, 0xe1, 0xde, 0x23, 0x2a, - 0x66, 0xe0, 0xac, 0xf0, 0x4f, 0x14, 0xa5, 0x87, 0x07, 0xb3, 0xa3, 0xea, 0x1f, 0x8f, 0x89, 0x1c, - 0x57, 0xa1, 0x47, 0xf2, 0x78, 0x62, 0x29, 0xa2, 0x97, 0xa1, 0xbf, 0xb5, 0xe3, 0x84, 0x24, 0xe1, - 0xcd, 0xd3, 0x5f, 0xa1, 0x85, 0x87, 0x07, 0xb3, 0x63, 0xaa, 0x02, 0x2b, 0xc1, 0x1c, 0xbb, 0xf7, - 0x58, 0x60, 0xe9, 0xc5, 0xd9, 0x35, 0x16, 0xd8, 0x1f, 0x59, 0xd0, 0xb7, 0xee, 0xd7, 0x4f, 0xe2, - 0x08, 0x78, 0xdd, 0x38, 0x02, 0x1e, 0xcb, 0x0b, 0x57, 0x9f, 0xbb, 0xfb, 0x57, 0x12, 0xbb, 0xff, - 0x7c, 0x2e, 0x85, 0xce, 0x1b, 0xbf, 0x09, 0xc3, 0x2c, 0x08, 0xbe, 0xf0, 0x5c, 0x7a, 0xd1, 0xd8, - 0xf0, 0xb3, 0x89, 0x0d, 0x3f, 0xae, 0xa1, 0x6a, 0x3b, 0xfd, 0x19, 0x18, 0x14, 0xae, 0x30, 0x49, - 0xb7, 0x50, 0x81, 0x8b, 0x25, 0xdc, 0xfe, 0xf1, 0x22, 0x18, 0x41, 0xf7, 0xd1, 0x2f, 0x59, 0x30, - 0x17, 0x70, 0x13, 0xd9, 0x7a, 0xb9, 0x1d, 0xb8, 0xde, 0x76, 0xb5, 0xb6, 0x43, 0xea, 0xed, 0x86, - 0xeb, 0x6d, 0xaf, 0x6e, 0x7b, 0xbe, 0x2a, 0x5e, 0xbe, 0x4b, 0x6a, 0x6d, 0xa6, 0x76, 0xeb, 0x12, - 0xe1, 0x5f, 0x99, 0x9a, 0xbf, 0x70, 0xff, 0x60, 0x76, 0x0e, 0x1f, 0x89, 0x36, 0x3e, 0x62, 0x5f, - 0xd0, 0xaf, 0x59, 0x30, 0xcf, 0x63, 0xd1, 0xf7, 0xde, 0xff, 0x0e, 0xaf, 0xe5, 0x8a, 0x24, 0x15, - 0x13, 0xd9, 0x20, 0x41, 0x73, 0xf1, 0x43, 0x62, 0x40, 0xe7, 0x2b, 0x47, 0x6b, 0x0b, 0x1f, 0xb5, - 0x73, 0xf6, 0x3f, 0x29, 0xc2, 0xa8, 0x88, 0x19, 0x25, 0xee, 0x80, 0x97, 0x8d, 0x25, 0xf1, 0x78, - 0x62, 0x49, 0x4c, 0x1a, 0xc8, 0xc7, 0x73, 0xfc, 0x87, 0x30, 0x49, 0x0f, 0xe7, 0xab, 0xc4, 0x09, - 0xa2, 0x4d, 0xe2, 0x70, 0x83, 0xaf, 0xe2, 0x91, 0x4f, 0x7f, 0x25, 0x9f, 0xbc, 0x9e, 0x24, 0x86, - 0xd3, 0xf4, 0xbf, 0x95, 0xee, 0x1c, 0x0f, 0x26, 0x52, 0x61, 0xbf, 0x3e, 0x01, 0x25, 0xe5, 0xc7, - 0x21, 0x0e, 0x9d, 0xce, 0xd1, 0xf3, 0x92, 0x14, 0xb8, 0xf8, 0x2b, 0xf6, 0x21, 0x8a, 0xc9, 0xd9, - 0x7f, 0xaf, 0x60, 0x34, 0xc8, 0x27, 0x71, 0x1d, 0x86, 0x9c, 0x30, 0x74, 0xb7, 0x3d, 0x52, 0xef, - 0x24, 0xa1, 0x4c, 0x35, 0xc3, 0x7c, 0x69, 0x16, 0x44, 0x4d, 0xac, 0x68, 0xa0, 0xab, 0xdc, 0xac, - 0x6e, 0x8f, 0x74, 0x12, 0x4f, 0xa6, 0xa8, 0x81, 0x34, 0xbc, 0xdb, 0x23, 0x58, 0xd4, 0x47, 0x9f, - 0xe4, 0x76, 0x8f, 0xd7, 0x3c, 0xff, 0x8e, 0x77, 0xc5, 0xf7, 0x65, 0x5c, 0x86, 0xde, 0x08, 0x4e, - 0x4a, 0x6b, 0x47, 0x55, 0x1d, 0x9b, 0xd4, 0x7a, 0x8b, 0xa3, 0xf9, 0x59, 0x60, 0xb1, 0xb7, 0x4d, - 0xb7, 0xe9, 0x10, 0x11, 0x18, 0x17, 0x01, 0xc9, 0x64, 0x99, 0x18, 0xbb, 0xcc, 0xa7, 0x9c, 0x59, - 0x3b, 0x16, 0xa4, 0x5f, 0x33, 0x49, 0xe0, 0x24, 0x4d, 0xfb, 0xa7, 0x2c, 0x60, 0x2e, 0xa4, 0x27, - 0xc0, 0x8f, 0x7c, 0xc4, 0xe4, 0x47, 0xa6, 0xf3, 0x06, 0x39, 0x87, 0x15, 0x79, 0x89, 0xaf, 0xac, - 0x4a, 0xe0, 0xdf, 0xdd, 0x17, 0xc6, 0x2a, 0xdd, 0xdf, 0x1f, 0xf6, 0xff, 0xb1, 0xf8, 0x21, 0xa6, - 0xbc, 0x2c, 0xd0, 0x77, 0xc2, 0x50, 0xcd, 0x69, 0x39, 0x35, 0x9e, 0x21, 0x26, 0x57, 0xa2, 0x67, - 0x54, 0x9a, 0x5b, 0x12, 0x35, 0xb8, 0x84, 0x4a, 0x06, 0xb6, 0x1b, 0x92, 0xc5, 0x5d, 0xa5, 0x52, - 0xaa, 0xc9, 0x99, 0x5d, 0x18, 0x35, 0x88, 0x3d, 0x54, 0x71, 0xc6, 0x77, 0xf2, 0x2b, 0x56, 0x05, - 0x62, 0x6c, 0xc2, 0xa4, 0xa7, 0xfd, 0xa7, 0x17, 0x8a, 0x7c, 0x5c, 0x3e, 0xd9, 0xed, 0x12, 0x65, - 0xb7, 0x8f, 0xe6, 0x9d, 0x9a, 0x20, 0x83, 0xd3, 0x94, 0xed, 0x9f, 0xb0, 0xe0, 0x11, 0x1d, 0x51, - 0x73, 0x80, 0xe9, 0xa6, 0x24, 0x29, 0xc3, 0x90, 0xdf, 0x22, 0x81, 0x13, 0xf9, 0x81, 0xb8, 0x35, - 0x2e, 0xc9, 0x41, 0xbf, 0x21, 0xca, 0x0f, 0x45, 0xbc, 0x73, 0x49, 0x5d, 0x96, 0x63, 0x55, 0x93, - 0xbe, 0x3e, 0xd9, 0x60, 0x84, 0xc2, 0xd5, 0x89, 0x9d, 0x01, 0x4c, 0x93, 0x1e, 0x62, 0x01, 0xb1, - 0xbf, 0x6e, 0xf1, 0x85, 0xa5, 0x77, 0x1d, 0xbd, 0x0d, 0x13, 0x4d, 0x27, 0xaa, 0xed, 0x2c, 0xdf, - 0x6d, 0x05, 0x5c, 0xe5, 0x24, 0xc7, 0xe9, 0xd9, 0x6e, 0xe3, 0xa4, 0x7d, 0x64, 0x6c, 0xca, 0xb9, - 0x96, 0x20, 0x86, 0x53, 0xe4, 0xd1, 0x26, 0x0c, 0xb3, 0x32, 0xe6, 0xc5, 0x17, 0x76, 0x62, 0x0d, - 0xf2, 0x5a, 0x53, 0xc6, 0x08, 0x6b, 0x31, 0x1d, 0xac, 0x13, 0xb5, 0xbf, 0x5c, 0xe4, 0xbb, 0x9d, - 0xb1, 0xf2, 0xcf, 0xc0, 0x60, 0xcb, 0xaf, 0x2f, 0xad, 0x96, 0xb1, 0x98, 0x05, 0x75, 0x8d, 0x54, - 0x78, 0x31, 0x96, 0x70, 0x74, 0x09, 0x86, 0xc4, 0x4f, 0xa9, 0x22, 0x64, 0x67, 0xb3, 0xc0, 0x0b, - 0xb1, 0x82, 0xa2, 0x17, 0x00, 0x5a, 0x81, 0xbf, 0xe7, 0xd6, 0x59, 0x74, 0x89, 0xa2, 0x69, 0x47, - 0x54, 0x51, 0x10, 0xac, 0x61, 0xa1, 0xd7, 0x60, 0xb4, 0xed, 0x85, 0x9c, 0x1d, 0xd1, 0x62, 0xc9, - 0x2a, 0x0b, 0x97, 0x9b, 0x3a, 0x10, 0x9b, 0xb8, 0x68, 0x01, 0x06, 0x22, 0x87, 0xd9, 0xc5, 0xf4, - 0xe7, 0x9b, 0xfb, 0x6e, 0x50, 0x0c, 0x3d, 0x19, 0x09, 0xad, 0x80, 0x45, 0x45, 0xf4, 0x09, 0xe9, - 0x50, 0xcb, 0x0f, 0x76, 0x61, 0x67, 0xdf, 0xdb, 0x25, 0xa0, 0xb9, 0xd3, 0x0a, 0xfb, 0x7d, 0x83, - 0x16, 0x7a, 0x15, 0x80, 0xdc, 0x8d, 0x48, 0xe0, 0x39, 0x0d, 0x65, 0xcd, 0xa6, 0xf8, 0x82, 0xb2, - 0xbf, 0xee, 0x47, 0x37, 0x43, 0xb2, 0xac, 0x30, 0xb0, 0x86, 0x6d, 0xff, 0x5a, 0x09, 0x20, 0xe6, - 0xdb, 0xd1, 0xbd, 0xd4, 0xc1, 0xf5, 0x5c, 0x67, 0x4e, 0xff, 0xf8, 0x4e, 0x2d, 0xf4, 0x7d, 0x16, - 0x0c, 0x3b, 0x8d, 0x86, 0x5f, 0x73, 0x78, 0xb4, 0xdf, 0x42, 0xe7, 0x83, 0x53, 0xb4, 0xbf, 0x10, - 0xd7, 0xe0, 0x5d, 0x78, 0x51, 0xae, 0x50, 0x0d, 0xd2, 0xb5, 0x17, 0x7a, 0xc3, 0xe8, 0x03, 0xf2, - 0xa9, 0x58, 0x34, 0x86, 0x52, 0x3d, 0x15, 0x4b, 0xec, 0x8e, 0xd0, 0x5f, 0x89, 0x37, 0x8d, 0x57, - 0x62, 0x5f, 0xbe, 0xc7, 0xa0, 0xc1, 0xbe, 0x76, 0x7b, 0x20, 0xa2, 0x8a, 0x1e, 0x3d, 0xa0, 0x3f, - 0xdf, 0x3d, 0x4f, 0x7b, 0x27, 0x75, 0x89, 0x1c, 0xf0, 0x19, 0x18, 0xaf, 0x9b, 0x4c, 0x80, 0x58, - 0x89, 0x4f, 0xe7, 0xd1, 0x4d, 0xf0, 0x0c, 0xf1, 0xb5, 0x9f, 0x00, 0xe0, 0x24, 0x61, 0x54, 0xe1, - 0xc1, 0x24, 0x56, 0xbd, 0x2d, 0x5f, 0xf8, 0x7a, 0xd8, 0xb9, 0x73, 0xb9, 0x1f, 0x46, 0xa4, 0x49, - 0x31, 0xe3, 0xdb, 0x7d, 0x5d, 0xd4, 0xc5, 0x8a, 0x0a, 0x7a, 0x03, 0x06, 0x98, 0x7f, 0x56, 0x38, - 0x3d, 0x94, 0x2f, 0x71, 0x36, 0xa3, 0xa3, 0xc5, 0x1b, 0x92, 0xfd, 0x0d, 0xb1, 0xa0, 0x80, 0xae, - 0x4a, 0xef, 0xc7, 0x70, 0xd5, 0xbb, 0x19, 0x12, 0xe6, 0xfd, 0x58, 0x5a, 0x7c, 0x32, 0x76, 0x6c, - 0xe4, 0xe5, 0x99, 0x29, 0xcb, 0x8c, 0x9a, 0x94, 0x8b, 0x12, 0xff, 0x65, 0x26, 0xb4, 0x69, 0xc8, - 0xef, 0x9e, 0x99, 0x2d, 0x2d, 0x1e, 0xce, 0x5b, 0x26, 0x09, 0x9c, 0xa4, 0x49, 0x39, 0x52, 0xbe, - 0xeb, 0x85, 0xb7, 0x48, 0xb7, 0xb3, 0x83, 0x3f, 0xc4, 0xd9, 0x6d, 0xc4, 0x4b, 0xb0, 0xa8, 0x7f, - 0xa2, 0xec, 0xc1, 0x8c, 0x07, 0x13, 0xc9, 0x2d, 0xfa, 0x50, 0xd9, 0x91, 0xdf, 0xeb, 0x83, 0x31, - 0x73, 0x49, 0xa1, 0x79, 0x28, 0x09, 0x22, 0x2a, 0x9b, 0x80, 0xda, 0x25, 0x6b, 0x12, 0x80, 0x63, - 0x1c, 0x96, 0x44, 0x82, 0x55, 0xd7, 0xcc, 0x83, 0xe3, 0x24, 0x12, 0x0a, 0x82, 0x35, 0x2c, 0xfa, - 0xb0, 0xda, 0xf4, 0xfd, 0x48, 0x5d, 0x48, 0x6a, 0xdd, 0x2d, 0xb2, 0x52, 0x2c, 0xa0, 0xf4, 0x22, - 0xda, 0x25, 0x81, 0x47, 0x1a, 0x66, 0xdc, 0x61, 0x75, 0x11, 0x5d, 0xd3, 0x81, 0xd8, 0xc4, 0xa5, - 0xd7, 0xa9, 0x1f, 0xb2, 0x85, 0x2c, 0x9e, 0x6f, 0xb1, 0xb9, 0x75, 0x95, 0x3b, 0x60, 0x4b, 0x38, - 0xfa, 0x38, 0x3c, 0xa2, 0x62, 0x2b, 0x61, 0xae, 0xcd, 0x90, 0x2d, 0x0e, 0x18, 0xd2, 0x96, 0x47, - 0x96, 0xb2, 0xd1, 0x70, 0x5e, 0x7d, 0xf4, 0x3a, 0x8c, 0x09, 0x16, 0x5f, 0x52, 0x1c, 0x34, 0x2d, - 0x8c, 0xae, 0x19, 0x50, 0x9c, 0xc0, 0x96, 0x91, 0x93, 0x19, 0x97, 0x2d, 0x29, 0x0c, 0xa5, 0x23, - 0x27, 0xeb, 0x70, 0x9c, 0xaa, 0x81, 0x16, 0x60, 0x9c, 0xf3, 0x60, 0xae, 0xb7, 0xcd, 0xe7, 0x44, - 0x38, 0x73, 0xa9, 0x2d, 0x75, 0xc3, 0x04, 0xe3, 0x24, 0x3e, 0x7a, 0x05, 0x46, 0x9c, 0xa0, 0xb6, - 0xe3, 0x46, 0xa4, 0x16, 0xb5, 0x03, 0xee, 0xe5, 0xa5, 0x99, 0x68, 0x2d, 0x68, 0x30, 0x6c, 0x60, - 0xda, 0xf7, 0x60, 0x2a, 0x23, 0x32, 0x03, 0x5d, 0x38, 0x4e, 0xcb, 0x95, 0xdf, 0x94, 0xb0, 0x70, - 0x5e, 0xa8, 0xac, 0xca, 0xaf, 0xd1, 0xb0, 0xe8, 0xea, 0x64, 0x11, 0x1c, 0xb4, 0xc4, 0x87, 0x6a, - 0x75, 0xae, 0x48, 0x00, 0x8e, 0x71, 0xec, 0xff, 0x5e, 0x80, 0xf1, 0x0c, 0xdd, 0x0a, 0x4b, 0xbe, - 0x97, 0x78, 0xa4, 0xc4, 0xb9, 0xf6, 0xcc, 0x40, 0xdc, 0x85, 0x23, 0x04, 0xe2, 0x2e, 0x76, 0x0b, - 0xc4, 0xdd, 0xf7, 0x4e, 0x02, 0x71, 0x9b, 0x23, 0xd6, 0xdf, 0xd3, 0x88, 0x65, 0x04, 0xef, 0x1e, - 0x38, 0x62, 0xf0, 0x6e, 0x63, 0xd0, 0x07, 0x7b, 0x18, 0xf4, 0x1f, 0x29, 0xc0, 0x44, 0xd2, 0x94, - 0xf4, 0x04, 0xe4, 0xb6, 0x6f, 0x18, 0x72, 0xdb, 0x4b, 0xbd, 0x38, 0xdf, 0xe6, 0xca, 0x70, 0x71, - 0x42, 0x86, 0xfb, 0xfe, 0x9e, 0xa8, 0x75, 0x96, 0xe7, 0xfe, 0xf5, 0x02, 0x9c, 0xce, 0xf4, 0xfe, - 0x3d, 0x81, 0xb1, 0xb9, 0x61, 0x8c, 0xcd, 0xf3, 0x3d, 0x3b, 0x26, 0xe7, 0x0e, 0xd0, 0xed, 0xc4, - 0x00, 0xcd, 0xf7, 0x4e, 0xb2, 0xf3, 0x28, 0x7d, 0xad, 0x08, 0xe7, 0x33, 0xeb, 0xc5, 0x62, 0xcf, - 0x15, 0x43, 0xec, 0xf9, 0x42, 0x42, 0xec, 0x69, 0x77, 0xae, 0x7d, 0x3c, 0x72, 0x50, 0xe1, 0xa0, - 0xcb, 0xc2, 0x0c, 0x3c, 0xa0, 0x0c, 0xd4, 0x70, 0xd0, 0x55, 0x84, 0xb0, 0x49, 0xf7, 0x5b, 0x49, - 0xf6, 0xf9, 0xaf, 0x2d, 0x38, 0x9b, 0x39, 0x37, 0x27, 0x20, 0xeb, 0x5a, 0x37, 0x65, 0x5d, 0xcf, - 0xf4, 0xbc, 0x5a, 0x73, 0x84, 0x5f, 0x5f, 0xee, 0xcf, 0xf9, 0x16, 0xf6, 0x92, 0xbf, 0x01, 0xc3, - 0x4e, 0xad, 0x46, 0xc2, 0x70, 0xcd, 0xaf, 0xab, 0x58, 0xc3, 0xcf, 0xb3, 0x77, 0x56, 0x5c, 0x7c, - 0x78, 0x30, 0x3b, 0x93, 0x24, 0x11, 0x83, 0xb1, 0x4e, 0x01, 0x7d, 0x12, 0x86, 0x42, 0x71, 0x6f, - 0x8a, 0xb9, 0x7f, 0xb1, 0xc7, 0xc1, 0x71, 0x36, 0x49, 0xc3, 0x0c, 0x86, 0xa4, 0x24, 0x15, 0x8a, - 0xa4, 0x19, 0x38, 0xa5, 0x70, 0xac, 0x81, 0x53, 0x5e, 0x00, 0xd8, 0x53, 0x8f, 0x81, 0xa4, 0xfc, - 0x41, 0x7b, 0x26, 0x68, 0x58, 0xe8, 0xa3, 0x30, 0x11, 0xf2, 0x68, 0x81, 0x4b, 0x0d, 0x27, 0x64, - 0x7e, 0x34, 0x62, 0x15, 0xb2, 0x80, 0x4b, 0xd5, 0x04, 0x0c, 0xa7, 0xb0, 0xd1, 0x8a, 0x6c, 0x95, - 0x85, 0x36, 0xe4, 0x0b, 0xf3, 0x62, 0xdc, 0xa2, 0x48, 0xfd, 0x7b, 0x2a, 0x39, 0xfc, 0x6c, 0xe0, - 0xb5, 0x9a, 0xe8, 0x93, 0x00, 0x74, 0xf9, 0x08, 0x39, 0xc4, 0x60, 0xfe, 0xe1, 0x49, 0x4f, 0x95, - 0x7a, 0xa6, 0x71, 0x33, 0xf3, 0xa9, 0x2d, 0x2b, 0x22, 0x58, 0x23, 0x88, 0xb6, 0x60, 0x34, 0xfe, - 0x17, 0x67, 0xc6, 0x3c, 0x62, 0x0b, 0x4c, 0xee, 0x5d, 0xd6, 0xe9, 0x60, 0x93, 0xac, 0xfd, 0x63, - 0x83, 0xf0, 0x68, 0x87, 0xb3, 0x18, 0x2d, 0x98, 0xfa, 0xde, 0x67, 0x93, 0x8f, 0xf8, 0x99, 0xcc, - 0xca, 0xc6, 0xab, 0x3e, 0xb1, 0xe4, 0x0b, 0xef, 0x78, 0xc9, 0xff, 0x90, 0xa5, 0x89, 0x57, 0xb8, - 0x65, 0xe9, 0x47, 0x8e, 0x78, 0xc7, 0x1c, 0xa3, 0xbc, 0x65, 0x2b, 0x43, 0x68, 0xf1, 0x42, 0xcf, - 0xdd, 0xe9, 0x5d, 0x8a, 0xf1, 0x15, 0x0b, 0x90, 0x10, 0xaf, 0x90, 0xba, 0xda, 0x50, 0x42, 0x9e, - 0x71, 0xe5, 0xa8, 0xdf, 0xbf, 0x90, 0xa2, 0xc4, 0x47, 0xe2, 0x55, 0x79, 0x19, 0xa4, 0x11, 0xba, - 0x8e, 0x49, 0x46, 0xf7, 0xd0, 0xc7, 0x59, 0x34, 0x5d, 0xf7, 0x9e, 0xe0, 0x80, 0xc4, 0x86, 0x7b, - 0x59, 0x44, 0xd2, 0x55, 0xe5, 0x94, 0xd5, 0xcd, 0xec, 0xae, 0x8e, 0x84, 0x0d, 0x52, 0x27, 0xfb, - 0xfe, 0x6e, 0xc3, 0x23, 0x39, 0x43, 0xf6, 0x50, 0x9f, 0xe1, 0xbf, 0x61, 0xc1, 0xb9, 0x8e, 0x61, - 0x61, 0xbe, 0x09, 0x19, 0x44, 0xfb, 0x73, 0x16, 0x64, 0x4f, 0xb6, 0x61, 0x56, 0x36, 0x0f, 0xa5, - 0x1a, 0x2d, 0xd4, 0xfc, 0x80, 0xe3, 0x00, 0x09, 0x12, 0x80, 0x63, 0x1c, 0xc3, 0x7a, 0xac, 0xd0, - 0xd5, 0x7a, 0xec, 0x97, 0x2d, 0x48, 0x1d, 0xf2, 0x27, 0xc0, 0x6d, 0xac, 0x9a, 0xdc, 0xc6, 0x93, - 0xbd, 0x8c, 0x66, 0x0e, 0xa3, 0xf1, 0x87, 0xe3, 0x70, 0x26, 0xc7, 0x2d, 0x6f, 0x0f, 0x26, 0xb7, - 0x6b, 0xc4, 0xf4, 0xb0, 0xee, 0x14, 0x79, 0xa8, 0xa3, 0x3b, 0x36, 0x4b, 0x0e, 0x3b, 0x99, 0x42, - 0xc1, 0xe9, 0x26, 0xd0, 0xe7, 0x2c, 0x38, 0xe5, 0xdc, 0x09, 0x97, 0x29, 0xd7, 0xe8, 0xd6, 0x16, - 0x1b, 0x7e, 0x6d, 0x97, 0x5e, 0xc9, 0x72, 0x23, 0xbc, 0x94, 0x29, 0xc9, 0xbb, 0x5d, 0x4d, 0xe1, - 0x1b, 0xcd, 0xb3, 0x6c, 0xb9, 0x59, 0x58, 0x38, 0xb3, 0x2d, 0x84, 0x45, 0x0a, 0x05, 0xfa, 0x26, - 0xed, 0x10, 0x03, 0x20, 0xcb, 0x7f, 0x92, 0xb3, 0x41, 0x12, 0x82, 0x15, 0x1d, 0xf4, 0x69, 0x28, - 0x6d, 0x4b, 0x77, 0xdf, 0x0c, 0x36, 0x2b, 0x1e, 0xc8, 0xce, 0x4e, 0xd0, 0x5c, 0x1d, 0xaf, 0x90, - 0x70, 0x4c, 0x14, 0xbd, 0x0e, 0x45, 0x6f, 0x2b, 0xec, 0x94, 0x70, 0x36, 0x61, 0x77, 0xc9, 0x23, - 0x6d, 0xac, 0xaf, 0x54, 0x31, 0xad, 0x88, 0xae, 0x42, 0x31, 0xd8, 0xac, 0x0b, 0x31, 0x74, 0xe6, - 0x26, 0xc5, 0x8b, 0xe5, 0x9c, 0x5e, 0x31, 0x4a, 0x78, 0xb1, 0x8c, 0x29, 0x09, 0x54, 0x81, 0x7e, - 0xe6, 0xcb, 0x26, 0x98, 0x9a, 0xcc, 0xe7, 0x5b, 0x07, 0x9f, 0x50, 0x1e, 0x8e, 0x83, 0x21, 0x60, - 0x4e, 0x08, 0x6d, 0xc0, 0x40, 0x8d, 0x25, 0x27, 0x15, 0x5c, 0xcc, 0x07, 0x32, 0x05, 0xce, 0x1d, - 0xb2, 0xb6, 0x0a, 0xf9, 0x2b, 0xc3, 0xc0, 0x82, 0x16, 0xa3, 0x4a, 0x5a, 0x3b, 0x5b, 0xa1, 0x48, - 0xde, 0x9d, 0x4d, 0xb5, 0x43, 0x32, 0x62, 0x41, 0x95, 0x61, 0x60, 0x41, 0x0b, 0xbd, 0x0a, 0x85, - 0xad, 0x9a, 0xf0, 0x53, 0xcb, 0x94, 0x3c, 0x9b, 0xc1, 0x52, 0x16, 0x07, 0xee, 0x1f, 0xcc, 0x16, - 0x56, 0x96, 0x70, 0x61, 0xab, 0x86, 0xd6, 0x61, 0x70, 0x8b, 0x87, 0x57, 0x10, 0xc2, 0xe5, 0xa7, - 0xb3, 0x23, 0x3f, 0xa4, 0x22, 0x30, 0x70, 0x9f, 0x27, 0x01, 0xc0, 0x92, 0x08, 0xcb, 0x48, 0xa0, - 0xc2, 0x44, 0x88, 0x28, 0x75, 0x73, 0x47, 0x0b, 0xed, 0xc1, 0x99, 0xcc, 0x38, 0xd8, 0x04, 0xd6, - 0x28, 0xd2, 0x55, 0xed, 0xdc, 0x6b, 0x07, 0x2c, 0x14, 0xb8, 0x08, 0x67, 0x94, 0xb9, 0xaa, 0x17, - 0x24, 0x52, 0xa7, 0x55, 0xad, 0x90, 0x70, 0x4c, 0x14, 0xed, 0xc2, 0xe8, 0x5e, 0xd8, 0xda, 0x21, - 0x72, 0x4b, 0xb3, 0xe8, 0x46, 0x39, 0xfc, 0xd1, 0x2d, 0x81, 0xe8, 0x06, 0x51, 0xdb, 0x69, 0xa4, - 0x4e, 0x21, 0xc6, 0xcb, 0xde, 0xd2, 0x89, 0x61, 0x93, 0x36, 0x1d, 0xfe, 0xb7, 0xdb, 0xfe, 0xe6, - 0x7e, 0x44, 0x44, 0x70, 0xb9, 0xcc, 0xe1, 0x7f, 0x93, 0xa3, 0xa4, 0x87, 0x5f, 0x00, 0xb0, 0x24, - 0x82, 0x6e, 0x89, 0xe1, 0x61, 0xa7, 0xe7, 0x44, 0x7e, 0x04, 0xd8, 0x05, 0x89, 0x94, 0x33, 0x28, - 0xec, 0xb4, 0x8c, 0x49, 0xb1, 0x53, 0xb2, 0xb5, 0xe3, 0x47, 0xbe, 0x97, 0x38, 0xa1, 0x27, 0xf3, - 0x4f, 0xc9, 0x4a, 0x06, 0x7e, 0xfa, 0x94, 0xcc, 0xc2, 0xc2, 0x99, 0x6d, 0xa1, 0x3a, 0x8c, 0xb5, - 0xfc, 0x20, 0xba, 0xe3, 0x07, 0x72, 0x7d, 0xa1, 0x0e, 0xc2, 0x31, 0x03, 0x53, 0xb4, 0xc8, 0xe2, - 0x36, 0x9a, 0x10, 0x9c, 0xa0, 0x89, 0x3e, 0x06, 0x83, 0x61, 0xcd, 0x69, 0x90, 0xd5, 0x1b, 0xd3, - 0x53, 0xf9, 0xd7, 0x4f, 0x95, 0xa3, 0xe4, 0xac, 0x2e, 0x1e, 0x1d, 0x83, 0xa3, 0x60, 0x49, 0x0e, - 0xad, 0x40, 0x3f, 0xcb, 0x38, 0xc7, 0x22, 0x21, 0xe6, 0x04, 0xb2, 0x4d, 0x59, 0xc1, 0xf3, 0xb3, - 0x89, 0x15, 0x63, 0x5e, 0x9d, 0xee, 0x01, 0xf1, 0x46, 0xf4, 0xc3, 0xe9, 0xd3, 0xf9, 0x7b, 0x40, - 0x3c, 0x2d, 0x6f, 0x54, 0x3b, 0xed, 0x01, 0x85, 0x84, 0x63, 0xa2, 0xf4, 0x64, 0xa6, 0xa7, 0xe9, - 0x99, 0x0e, 0xe6, 0x5b, 0xb9, 0x67, 0x29, 0x3b, 0x99, 0xe9, 0x49, 0x4a, 0x49, 0xd8, 0xbf, 0x33, - 0x98, 0xe6, 0x59, 0x98, 0x54, 0xe1, 0x7b, 0xac, 0x94, 0xc2, 0xf9, 0x83, 0xbd, 0x0a, 0x39, 0x8f, - 0xf1, 0x29, 0xf4, 0x39, 0x0b, 0xce, 0xb4, 0x32, 0x3f, 0x44, 0x30, 0x00, 0xbd, 0xc9, 0x4a, 0xf9, - 0xa7, 0xab, 0xa8, 0x99, 0xd9, 0x70, 0x9c, 0xd3, 0x52, 0xf2, 0xb9, 0x59, 0x7c, 0xc7, 0xcf, 0xcd, - 0x35, 0x18, 0xaa, 0xf1, 0xa7, 0x48, 0xc7, 0x64, 0xdd, 0xc9, 0xb7, 0x37, 0x63, 0x25, 0xc4, 0x1b, - 0x66, 0x0b, 0x2b, 0x12, 0xe8, 0x87, 0x2d, 0x38, 0x97, 0xec, 0x3a, 0x26, 0x0c, 0x2c, 0x42, 0x6d, - 0x72, 0x81, 0xc6, 0x8a, 0xf8, 0xfe, 0x14, 0xff, 0x6f, 0x20, 0x1f, 0x76, 0x43, 0xc0, 0x9d, 0x1b, - 0x43, 0xe5, 0x0c, 0x89, 0xca, 0x80, 0xa9, 0x45, 0xea, 0x41, 0xaa, 0xf2, 0x12, 0x8c, 0x34, 0xfd, - 0xb6, 0x17, 0x09, 0x6b, 0x2f, 0x61, 0x79, 0xc2, 0x2c, 0x2e, 0xd6, 0xb4, 0x72, 0x6c, 0x60, 0x25, - 0x64, 0x31, 0x43, 0x0f, 0x2c, 0x8b, 0x79, 0x0b, 0x46, 0x3c, 0xcd, 0x3c, 0x59, 0xf0, 0x03, 0x17, - 0xf3, 0xc3, 0xe4, 0xea, 0xc6, 0xcc, 0xbc, 0x97, 0x7a, 0x09, 0x36, 0xa8, 0x9d, 0xac, 0x19, 0xd8, - 0x97, 0xac, 0x0c, 0xa6, 0x9e, 0x8b, 0x62, 0x3e, 0x6c, 0x8a, 0x62, 0x2e, 0x26, 0x45, 0x31, 0x29, - 0x0d, 0x82, 0x21, 0x85, 0xe9, 0x3d, 0x0b, 0x50, 0xaf, 0xa1, 0x36, 0xed, 0x06, 0x5c, 0xe8, 0x76, - 0x2d, 0x31, 0xb3, 0xbf, 0xba, 0xd2, 0x17, 0xc7, 0x66, 0x7f, 0xf5, 0xd5, 0x32, 0x66, 0x90, 0x5e, - 0x83, 0x38, 0xd9, 0xff, 0xd5, 0x82, 0x62, 0xc5, 0xaf, 0x9f, 0xc0, 0x83, 0xf7, 0x23, 0xc6, 0x83, - 0xf7, 0xd1, 0xec, 0x0b, 0xb1, 0x9e, 0xab, 0xff, 0x58, 0x4e, 0xe8, 0x3f, 0xce, 0xe5, 0x11, 0xe8, - 0xac, 0xed, 0xf8, 0xc9, 0x22, 0x0c, 0x57, 0xfc, 0xba, 0xb2, 0xb9, 0xff, 0x67, 0x0f, 0x62, 0x73, - 0x9f, 0x9b, 0xcb, 0x42, 0xa3, 0xcc, 0xac, 0x05, 0xa5, 0xbb, 0xf1, 0x37, 0x99, 0xe9, 0xfd, 0x6d, - 0xe2, 0x6e, 0xef, 0x44, 0xa4, 0x9e, 0xfc, 0x9c, 0x93, 0x33, 0xbd, 0xff, 0x9d, 0x02, 0x8c, 0x27, - 0x5a, 0x47, 0x0d, 0x18, 0x6d, 0xe8, 0xd2, 0x75, 0xb1, 0x4e, 0x1f, 0x48, 0x30, 0x2f, 0x4c, 0x97, - 0xb5, 0x22, 0x6c, 0x12, 0x47, 0x73, 0x00, 0x4a, 0xdd, 0x2c, 0xc5, 0xab, 0x8c, 0xeb, 0x57, 0xfa, - 0xe8, 0x10, 0x6b, 0x18, 0xe8, 0x65, 0x18, 0x8e, 0xfc, 0x96, 0xdf, 0xf0, 0xb7, 0xf7, 0xaf, 0x11, - 0x19, 0xdf, 0x4b, 0x19, 0x24, 0x6e, 0xc4, 0x20, 0xac, 0xe3, 0xa1, 0xbb, 0x30, 0xa9, 0x88, 0x54, - 0x8f, 0x41, 0xe3, 0xc0, 0xa4, 0x0a, 0xeb, 0x49, 0x8a, 0x38, 0xdd, 0x88, 0xfd, 0xd3, 0x45, 0x3e, - 0xc4, 0x5e, 0xe4, 0xbe, 0xb7, 0x1b, 0xde, 0xdd, 0xbb, 0xe1, 0x6b, 0x16, 0x4c, 0xd0, 0xd6, 0x99, - 0xb5, 0x95, 0xbc, 0xe6, 0x55, 0x60, 0x6e, 0xab, 0x43, 0x60, 0xee, 0x8b, 0xf4, 0xd4, 0xac, 0xfb, - 0xed, 0x48, 0xc8, 0xee, 0xb4, 0x63, 0x91, 0x96, 0x62, 0x01, 0x15, 0x78, 0x24, 0x08, 0x84, 0x87, - 0xa8, 0x8e, 0x47, 0x82, 0x00, 0x0b, 0xa8, 0x8c, 0xdb, 0xdd, 0x97, 0x1d, 0xb7, 0x9b, 0x87, 0x5f, - 0x15, 0x76, 0x39, 0x82, 0xe1, 0xd2, 0xc2, 0xaf, 0x4a, 0x83, 0x9d, 0x18, 0xc7, 0xfe, 0x4a, 0x11, - 0x46, 0x2a, 0x7e, 0x3d, 0x56, 0x35, 0xbf, 0x64, 0xa8, 0x9a, 0x2f, 0x24, 0x54, 0xcd, 0x13, 0x3a, - 0xee, 0x7b, 0x8a, 0xe5, 0x6f, 0x94, 0x62, 0xf9, 0x1f, 0x5b, 0x6c, 0xd6, 0xca, 0xeb, 0x55, 0x6e, - 0xbc, 0x87, 0x2e, 0xc3, 0x30, 0x3b, 0x60, 0x98, 0x4b, 0xb2, 0xd4, 0xbf, 0xb2, 0x7c, 0x54, 0xeb, - 0x71, 0x31, 0xd6, 0x71, 0xd0, 0x25, 0x18, 0x0a, 0x89, 0x13, 0xd4, 0x76, 0xd4, 0xe9, 0x2a, 0x94, - 0xa5, 0xbc, 0x0c, 0x2b, 0x28, 0x7a, 0x33, 0x8e, 0xfc, 0x59, 0xcc, 0x77, 0x71, 0xd4, 0xfb, 0xc3, - 0xb7, 0x48, 0x7e, 0xb8, 0x4f, 0xfb, 0x36, 0xa0, 0x34, 0x7e, 0x0f, 0xb1, 0xe9, 0x66, 0xcd, 0xd8, - 0x74, 0xa5, 0x54, 0x5c, 0xba, 0x3f, 0xb1, 0x60, 0xac, 0xe2, 0xd7, 0xe9, 0xd6, 0xfd, 0x56, 0xda, - 0xa7, 0x7a, 0xd8, 0xe3, 0x81, 0x0e, 0x61, 0x8f, 0x9f, 0x80, 0xfe, 0x8a, 0x5f, 0x5f, 0xad, 0x74, - 0x8a, 0x2f, 0x60, 0xff, 0x0d, 0x0b, 0x06, 0x2b, 0x7e, 0xfd, 0x04, 0xd4, 0x02, 0x1f, 0x36, 0xd5, - 0x02, 0x8f, 0xe4, 0xac, 0x9b, 0x1c, 0x4d, 0xc0, 0x5f, 0xeb, 0x83, 0x51, 0xda, 0x4f, 0x7f, 0x5b, - 0x4e, 0xa5, 0x31, 0x6c, 0x56, 0x0f, 0xc3, 0x46, 0xb9, 0x70, 0xbf, 0xd1, 0xf0, 0xef, 0x24, 0xa7, - 0x75, 0x85, 0x95, 0x62, 0x01, 0x45, 0xcf, 0xc1, 0x50, 0x2b, 0x20, 0x7b, 0xae, 0x2f, 0xd8, 0x5b, - 0x4d, 0xc9, 0x52, 0x11, 0xe5, 0x58, 0x61, 0xd0, 0x67, 0x61, 0xe8, 0x7a, 0xf4, 0x2a, 0xaf, 0xf9, - 0x5e, 0x9d, 0x4b, 0xce, 0x8b, 0x22, 0x37, 0x87, 0x56, 0x8e, 0x0d, 0x2c, 0x74, 0x1b, 0x4a, 0xec, - 0x3f, 0x3b, 0x76, 0x8e, 0x9e, 0xe5, 0x55, 0x64, 0xfd, 0x13, 0x04, 0x70, 0x4c, 0x0b, 0xbd, 0x00, - 0x10, 0xc9, 0xf8, 0xf6, 0xa1, 0x88, 0xb6, 0xa6, 0x9e, 0x02, 0x2a, 0xf2, 0x7d, 0x88, 0x35, 0x2c, - 0xf4, 0x2c, 0x94, 0x22, 0xc7, 0x6d, 0x5c, 0x77, 0x3d, 0x12, 0x32, 0x89, 0x78, 0x51, 0x26, 0xdf, - 0x13, 0x85, 0x38, 0x86, 0x53, 0x56, 0x8c, 0x45, 0xe2, 0xe0, 0x39, 0xa2, 0x87, 0x18, 0x36, 0x63, - 0xc5, 0xae, 0xab, 0x52, 0xac, 0x61, 0xa0, 0x1d, 0x78, 0xcc, 0xf5, 0x58, 0x1e, 0x0b, 0x52, 0xdd, - 0x75, 0x5b, 0x1b, 0xd7, 0xab, 0xb7, 0x48, 0xe0, 0x6e, 0xed, 0x2f, 0x3a, 0xb5, 0x5d, 0xe2, 0xc9, - 0xfc, 0x9d, 0x4f, 0x8a, 0x2e, 0x3e, 0xb6, 0xda, 0x01, 0x17, 0x77, 0xa4, 0x64, 0xbf, 0xc8, 0xd6, - 0xfb, 0x8d, 0x2a, 0x7a, 0xbf, 0x71, 0x74, 0x9c, 0xd1, 0x8f, 0x8e, 0xc3, 0x83, 0xd9, 0x81, 0x1b, - 0x55, 0x2d, 0x90, 0xc4, 0x2b, 0x70, 0xba, 0xe2, 0xd7, 0x2b, 0x7e, 0x10, 0xad, 0xf8, 0xc1, 0x1d, - 0x27, 0xa8, 0xcb, 0xe5, 0x35, 0x2b, 0x43, 0x69, 0xd0, 0xf3, 0xb3, 0x9f, 0x9f, 0x2e, 0x46, 0x98, - 0x8c, 0x17, 0x19, 0xc7, 0x76, 0x44, 0x07, 0xb0, 0x1a, 0xe3, 0x1d, 0x54, 0x26, 0x98, 0x2b, 0x4e, - 0x44, 0xd0, 0x0d, 0x96, 0xe1, 0x3a, 0xbe, 0x46, 0x45, 0xf5, 0x67, 0xb4, 0x0c, 0xd7, 0x31, 0x30, - 0xf3, 0xde, 0x35, 0xeb, 0xdb, 0x2f, 0xc3, 0x24, 0x7d, 0x7b, 0x29, 0x46, 0x86, 0xb5, 0xd2, 0x3d, - 0xa6, 0xc6, 0x7f, 0xeb, 0x67, 0x07, 0x71, 0x22, 0x09, 0x09, 0xfa, 0x14, 0x8c, 0x85, 0xe4, 0xba, - 0xeb, 0xb5, 0xef, 0x4a, 0xc9, 0x47, 0x07, 0xcf, 0xbf, 0xea, 0xb2, 0x8e, 0xc9, 0xe5, 0xa7, 0x66, - 0x19, 0x4e, 0x50, 0x43, 0x4d, 0x18, 0xbb, 0xe3, 0x7a, 0x75, 0xff, 0x4e, 0x28, 0xe9, 0x0f, 0xe5, - 0x8b, 0x51, 0x6f, 0x73, 0xcc, 0x44, 0x1f, 0x8d, 0xe6, 0x6e, 0x1b, 0xc4, 0x70, 0x82, 0x38, 0x5d, - 0xec, 0x41, 0xdb, 0x5b, 0x08, 0x6f, 0x86, 0x24, 0x10, 0x29, 0xce, 0xd9, 0x62, 0xc7, 0xb2, 0x10, - 0xc7, 0x70, 0xba, 0xd8, 0xd9, 0x9f, 0x2b, 0x81, 0xdf, 0xe6, 0x19, 0x2f, 0xc4, 0x62, 0xc7, 0xaa, - 0x14, 0x6b, 0x18, 0xf4, 0x30, 0x60, 0xff, 0xd6, 0x7d, 0x0f, 0xfb, 0x7e, 0x24, 0x8f, 0x0f, 0x66, - 0x0a, 0xa0, 0x95, 0x63, 0x03, 0x0b, 0xad, 0x00, 0x0a, 0xdb, 0xad, 0x56, 0x83, 0x99, 0x14, 0x39, - 0x0d, 0x46, 0x8a, 0x9b, 0x59, 0x14, 0x79, 0xc4, 0xde, 0x6a, 0x0a, 0x8a, 0x33, 0x6a, 0xd0, 0x7b, - 0x61, 0x4b, 0x74, 0xb5, 0x9f, 0x75, 0x95, 0xab, 0x5c, 0xaa, 0xbc, 0x9f, 0x12, 0x86, 0x96, 0x61, - 0x30, 0xdc, 0x0f, 0x6b, 0x91, 0x08, 0xb0, 0x98, 0x93, 0x67, 0xaa, 0xca, 0x50, 0xb4, 0x34, 0x87, - 0xbc, 0x0a, 0x96, 0x75, 0x51, 0x0d, 0xa6, 0x04, 0xc5, 0xa5, 0x1d, 0xc7, 0x53, 0x59, 0x7b, 0xb8, - 0x65, 0xf5, 0xe5, 0xfb, 0x07, 0xb3, 0x53, 0xa2, 0x65, 0x1d, 0x7c, 0x78, 0x30, 0x7b, 0xa6, 0xe2, - 0xd7, 0x33, 0x20, 0x38, 0x8b, 0x1a, 0x5f, 0x7c, 0xb5, 0x9a, 0xdf, 0x6c, 0x55, 0x02, 0x7f, 0xcb, - 0x6d, 0x90, 0x4e, 0x6a, 0xab, 0xaa, 0x81, 0x29, 0x16, 0x9f, 0x51, 0x86, 0x13, 0xd4, 0xec, 0xef, - 0x64, 0xbc, 0x13, 0xcb, 0xea, 0x1d, 0xb5, 0x03, 0x82, 0x9a, 0x30, 0xda, 0x62, 0xbb, 0x4b, 0xe4, - 0xa1, 0x10, 0x6b, 0xfd, 0xa5, 0x1e, 0xc5, 0x2f, 0x77, 0xe8, 0x95, 0x63, 0x9a, 0x26, 0x55, 0x74, - 0x72, 0xd8, 0xa4, 0x6e, 0xff, 0xe7, 0x69, 0x76, 0xfb, 0x56, 0xb9, 0x4c, 0x65, 0x50, 0x38, 0x72, - 0x88, 0x67, 0xdc, 0x4c, 0xbe, 0x70, 0x2f, 0x9e, 0x16, 0xe1, 0x0c, 0x82, 0x65, 0x5d, 0xf4, 0x49, - 0x18, 0xa3, 0xaf, 0x22, 0x75, 0x03, 0x86, 0xd3, 0xa7, 0xf2, 0x03, 0x6e, 0x28, 0x2c, 0x3d, 0x47, - 0x8d, 0x5e, 0x19, 0x27, 0x88, 0xa1, 0x37, 0x99, 0x29, 0x90, 0x24, 0x5d, 0xe8, 0x85, 0xb4, 0x6e, - 0xf5, 0x23, 0xc9, 0x6a, 0x44, 0x50, 0x1b, 0xa6, 0xd2, 0x19, 0xed, 0xc2, 0x69, 0x3b, 0x9f, 0xbd, - 0x4c, 0x27, 0xa5, 0x8b, 0x93, 0x89, 0xa4, 0x61, 0x21, 0xce, 0xa2, 0x8f, 0xae, 0xc3, 0xa8, 0x48, - 0x6d, 0x2d, 0x56, 0x6e, 0xd1, 0x90, 0x39, 0x8e, 0x62, 0x1d, 0x78, 0x98, 0x2c, 0xc0, 0x66, 0x65, - 0xb4, 0x0d, 0xe7, 0xb4, 0x54, 0x53, 0x57, 0x02, 0x87, 0x19, 0x0e, 0xb8, 0xec, 0x38, 0xd5, 0xf8, - 0x82, 0xc7, 0xef, 0x1f, 0xcc, 0x9e, 0xdb, 0xe8, 0x84, 0x88, 0x3b, 0xd3, 0x41, 0x37, 0xe0, 0x34, - 0x77, 0x17, 0x2f, 0x13, 0xa7, 0xde, 0x70, 0x3d, 0xc5, 0x78, 0xf0, 0x2d, 0x7f, 0xf6, 0xfe, 0xc1, - 0xec, 0xe9, 0x85, 0x2c, 0x04, 0x9c, 0x5d, 0x0f, 0x7d, 0x18, 0x4a, 0x75, 0x2f, 0x14, 0x63, 0x30, - 0x60, 0x64, 0xf3, 0x2a, 0x95, 0xd7, 0xab, 0xea, 0xfb, 0xe3, 0x3f, 0x38, 0xae, 0x80, 0xb6, 0xb9, - 0x5c, 0x5a, 0x49, 0x4b, 0x06, 0x53, 0xe1, 0xb2, 0x92, 0x02, 0x45, 0xc3, 0x61, 0x94, 0x2b, 0x64, - 0x94, 0x1f, 0x85, 0xe1, 0x4b, 0x6a, 0x10, 0x46, 0x6f, 0x00, 0x12, 0x51, 0xe3, 0x17, 0x6a, 0x2c, - 0xc9, 0x09, 0x13, 0xe3, 0x0f, 0x99, 0x2e, 0x8c, 0xd5, 0x14, 0x06, 0xce, 0xa8, 0x85, 0xae, 0xd2, - 0x53, 0x45, 0x2f, 0x15, 0xa7, 0x96, 0xca, 0xbd, 0x58, 0x26, 0xad, 0x80, 0x30, 0x43, 0x28, 0x93, - 0x22, 0x4e, 0xd4, 0x43, 0x75, 0x78, 0xcc, 0x69, 0x47, 0x3e, 0x13, 0xf9, 0x9b, 0xa8, 0x1b, 0xfe, - 0x2e, 0xf1, 0x98, 0xb6, 0x6d, 0x68, 0xf1, 0x02, 0xe5, 0x6c, 0x16, 0x3a, 0xe0, 0xe1, 0x8e, 0x54, - 0x28, 0x47, 0xaa, 0x92, 0x2d, 0x83, 0x19, 0x04, 0x2c, 0x23, 0xe1, 0xf2, 0xcb, 0x30, 0xbc, 0xe3, - 0x87, 0xd1, 0x3a, 0x89, 0xee, 0xf8, 0xc1, 0xae, 0x08, 0x66, 0x1b, 0x87, 0x06, 0x8f, 0x41, 0x58, - 0xc7, 0xa3, 0x4f, 0x4e, 0x66, 0x0b, 0xb2, 0x5a, 0x66, 0x6a, 0xf8, 0xa1, 0xf8, 0x8c, 0xb9, 0xca, - 0x8b, 0xb1, 0x84, 0x4b, 0xd4, 0xd5, 0xca, 0x12, 0x53, 0xa9, 0x27, 0x50, 0x57, 0x2b, 0x4b, 0x58, - 0xc2, 0xe9, 0x72, 0x0d, 0x77, 0x9c, 0x80, 0x54, 0x02, 0xbf, 0x46, 0x42, 0x2d, 0x20, 0xfd, 0xa3, - 0x3c, 0x54, 0x2f, 0x5d, 0xae, 0xd5, 0x2c, 0x04, 0x9c, 0x5d, 0x0f, 0x91, 0x74, 0x9a, 0xb5, 0xb1, - 0x7c, 0x5d, 0x48, 0x9a, 0x9f, 0xe9, 0x31, 0xd3, 0x9a, 0x07, 0x13, 0x2a, 0xc1, 0x1b, 0x0f, 0xce, - 0x1b, 0x4e, 0x8f, 0xb3, 0xb5, 0xdd, 0x7b, 0x64, 0x5f, 0xa5, 0x5d, 0x5a, 0x4d, 0x50, 0xc2, 0x29, - 0xda, 0x46, 0x9c, 0xb7, 0x89, 0xae, 0x71, 0xde, 0xe6, 0xa1, 0x14, 0xb6, 0x37, 0xeb, 0x7e, 0xd3, - 0x71, 0x3d, 0xa6, 0x52, 0xd7, 0xde, 0x3e, 0x55, 0x09, 0xc0, 0x31, 0x0e, 0x5a, 0x81, 0x21, 0x47, - 0xaa, 0x8e, 0x50, 0x7e, 0x64, 0x1f, 0xa5, 0x30, 0xe2, 0xc1, 0x2e, 0xa4, 0xb2, 0x48, 0xd5, 0x45, - 0xaf, 0xc1, 0xa8, 0x70, 0x77, 0x16, 0xb9, 0x45, 0xa7, 0x4c, 0x9f, 0xb4, 0xaa, 0x0e, 0xc4, 0x26, - 0x2e, 0xba, 0x09, 0xc3, 0x91, 0xdf, 0x60, 0x8e, 0x55, 0x94, 0xcd, 0x3b, 0x93, 0x1f, 0xa3, 0x6e, - 0x43, 0xa1, 0xe9, 0x52, 0x5b, 0x55, 0x15, 0xeb, 0x74, 0xd0, 0x06, 0x5f, 0xef, 0x2c, 0xfc, 0x3c, - 0x09, 0xa7, 0x1f, 0xc9, 0xbf, 0x93, 0x54, 0x94, 0x7a, 0x73, 0x3b, 0x88, 0x9a, 0x58, 0x27, 0x83, - 0xae, 0xc0, 0x64, 0x2b, 0x70, 0x7d, 0xb6, 0x26, 0x94, 0xd6, 0x70, 0xda, 0x4c, 0x36, 0x55, 0x49, - 0x22, 0xe0, 0x74, 0x1d, 0xe6, 0xad, 0x2e, 0x0a, 0xa7, 0xcf, 0xf2, 0x84, 0x19, 0xfc, 0x29, 0xc9, - 0xcb, 0xb0, 0x82, 0xa2, 0x35, 0x76, 0x12, 0x73, 0x29, 0xc8, 0xf4, 0x4c, 0x7e, 0x30, 0x21, 0x5d, - 0x5a, 0xc2, 0x99, 0x57, 0xf5, 0x17, 0xc7, 0x14, 0x50, 0x5d, 0xcb, 0x53, 0x49, 0x9f, 0x00, 0xe1, - 0xf4, 0x63, 0x1d, 0x0c, 0xf2, 0x12, 0xaf, 0x92, 0x98, 0x21, 0x30, 0x8a, 0x43, 0x9c, 0xa0, 0x89, - 0x3e, 0x0a, 0x13, 0x22, 0x04, 0x62, 0x3c, 0x4c, 0xe7, 0x62, 0x73, 0x75, 0x9c, 0x80, 0xe1, 0x14, - 0x36, 0x4f, 0x58, 0xe1, 0x6c, 0x36, 0x88, 0x38, 0xfa, 0xae, 0xbb, 0xde, 0x6e, 0x38, 0x7d, 0x9e, - 0x9d, 0x0f, 0x22, 0x61, 0x45, 0x12, 0x8a, 0x33, 0x6a, 0xa0, 0x0d, 0x98, 0x68, 0x05, 0x84, 0x34, - 0x19, 0xa3, 0x2f, 0xee, 0xb3, 0x59, 0x1e, 0xac, 0x81, 0xf6, 0xa4, 0x92, 0x80, 0x1d, 0x66, 0x94, - 0xe1, 0x14, 0x05, 0x74, 0x07, 0x86, 0xfc, 0x3d, 0x12, 0xec, 0x10, 0xa7, 0x3e, 0x7d, 0xa1, 0x83, - 0xfb, 0x84, 0xb8, 0xdc, 0x6e, 0x08, 0xdc, 0x84, 0xa5, 0x81, 0x2c, 0xee, 0x6e, 0x69, 0x20, 0x1b, - 0x43, 0x7f, 0xde, 0x82, 0xb3, 0x52, 0x39, 0x51, 0x6d, 0xd1, 0x51, 0x5f, 0xf2, 0xbd, 0x30, 0x0a, - 0x78, 0x78, 0x81, 0xc7, 0xf3, 0x5d, 0xee, 0x37, 0x72, 0x2a, 0x29, 0x41, 0xec, 0xd9, 0x3c, 0x8c, - 0x10, 0xe7, 0xb7, 0x88, 0x96, 0x60, 0x32, 0x24, 0x91, 0x3c, 0x8c, 0x16, 0xc2, 0x95, 0x37, 0xcb, - 0xeb, 0xd3, 0x4f, 0xf0, 0xd8, 0x08, 0x74, 0x33, 0x54, 0x93, 0x40, 0x9c, 0xc6, 0x47, 0x97, 0xa1, - 0xe0, 0x87, 0xd3, 0x4f, 0x76, 0x48, 0x6d, 0x4a, 0x5f, 0xf0, 0xdc, 0xe2, 0xec, 0x46, 0x15, 0x17, - 0xfc, 0x50, 0x26, 0x8d, 0xa0, 0xef, 0xb1, 0x70, 0xfa, 0x29, 0x2e, 0xb6, 0x93, 0x49, 0x23, 0x58, - 0x21, 0x8e, 0xe1, 0x68, 0x07, 0xc6, 0x43, 0xe3, 0xdd, 0x1b, 0x4e, 0x5f, 0x64, 0x23, 0xf5, 0x54, - 0xde, 0xa4, 0x19, 0xd8, 0x5a, 0xcc, 0x77, 0x93, 0x0a, 0x4e, 0x92, 0x9d, 0xf9, 0x76, 0x98, 0x4c, - 0x31, 0x32, 0x47, 0xc9, 0x54, 0x34, 0xb3, 0x0b, 0xa3, 0xc6, 0x62, 0x79, 0xa8, 0x3a, 0xf7, 0x7f, - 0x39, 0x08, 0x25, 0xa5, 0x8f, 0x45, 0xf3, 0xa6, 0x9a, 0xfd, 0x6c, 0x52, 0xcd, 0x3e, 0x54, 0xf1, - 0xeb, 0x86, 0x66, 0x7d, 0x23, 0x23, 0xb6, 0x5d, 0xde, 0xd1, 0xd4, 0xbb, 0xb9, 0xbf, 0x26, 0xe4, - 0x2e, 0xf6, 0xac, 0xaf, 0xef, 0xeb, 0x28, 0x37, 0xbf, 0x02, 0x93, 0x9e, 0xcf, 0xb8, 0x67, 0x52, - 0x97, 0xac, 0x11, 0xe3, 0x80, 0x4a, 0x7a, 0xb0, 0x98, 0x04, 0x02, 0x4e, 0xd7, 0xa1, 0x0d, 0x72, - 0x16, 0x26, 0x29, 0xa8, 0xe7, 0x1c, 0x0e, 0x16, 0x50, 0xf4, 0x04, 0xf4, 0xb7, 0xfc, 0xfa, 0x6a, - 0x45, 0x70, 0xce, 0x5a, 0x44, 0xd5, 0xfa, 0x6a, 0x05, 0x73, 0x18, 0x5a, 0x80, 0x01, 0xf6, 0x23, - 0x9c, 0x1e, 0xc9, 0x8f, 0x0a, 0xc2, 0x6a, 0x68, 0x79, 0xa0, 0x58, 0x05, 0x2c, 0x2a, 0x32, 0x81, - 0x21, 0x7d, 0x6e, 0x30, 0x81, 0xe1, 0xe0, 0x03, 0x0a, 0x0c, 0x25, 0x01, 0x1c, 0xd3, 0x42, 0x77, - 0xe1, 0xb4, 0xf1, 0xc4, 0xe3, 0x4b, 0x84, 0x84, 0x22, 0x32, 0xc1, 0x13, 0x1d, 0xdf, 0x76, 0x42, - 0xbf, 0x7f, 0x4e, 0x74, 0xfa, 0xf4, 0x6a, 0x16, 0x25, 0x9c, 0xdd, 0x00, 0x6a, 0xc0, 0x64, 0x2d, - 0xd5, 0xea, 0x50, 0xef, 0xad, 0xaa, 0x09, 0x4d, 0xb7, 0x98, 0x26, 0x8c, 0x5e, 0x83, 0xa1, 0xb7, - 0xfd, 0x90, 0xdd, 0x3a, 0x82, 0xdb, 0x97, 0x6e, 0xed, 0x43, 0x6f, 0xde, 0xa8, 0xb2, 0xf2, 0xc3, - 0x83, 0xd9, 0xe1, 0x8a, 0x5f, 0x97, 0x7f, 0xb1, 0xaa, 0x80, 0xbe, 0xdf, 0x82, 0x99, 0xf4, 0x1b, - 0x52, 0x75, 0x7a, 0xb4, 0xf7, 0x4e, 0xdb, 0xa2, 0xd1, 0x99, 0xe5, 0x5c, 0x72, 0xb8, 0x43, 0x53, - 0xf6, 0x2f, 0x5a, 0x4c, 0xec, 0x28, 0xf4, 0x66, 0x24, 0x6c, 0x37, 0x4e, 0x22, 0xfd, 0xed, 0xb2, - 0xa1, 0xd2, 0x7b, 0x60, 0x7b, 0x8f, 0x7f, 0x6a, 0x31, 0x7b, 0x8f, 0x13, 0x74, 0xec, 0x78, 0x13, - 0x86, 0x22, 0x99, 0x96, 0xb8, 0x43, 0xc6, 0x5e, 0xad, 0x53, 0xcc, 0xe6, 0x45, 0xf1, 0xde, 0x2a, - 0x03, 0xb1, 0x22, 0x63, 0xff, 0x03, 0x3e, 0x03, 0x12, 0x72, 0x02, 0x9a, 0x93, 0xb2, 0xa9, 0x39, - 0x99, 0xed, 0xf2, 0x05, 0x39, 0x1a, 0x94, 0xbf, 0x6f, 0xf6, 0x9b, 0xc9, 0x9c, 0xde, 0xed, 0x86, - 0x46, 0xf6, 0xe7, 0x2d, 0x80, 0x38, 0x60, 0x75, 0x0f, 0x89, 0xe7, 0x5e, 0xa1, 0xdc, 0xb6, 0x1f, - 0xf9, 0x35, 0xbf, 0x21, 0xf4, 0x82, 0x8f, 0xc5, 0xca, 0x1b, 0x5e, 0x7e, 0xa8, 0xfd, 0xc6, 0x0a, - 0x1b, 0xcd, 0xca, 0xf0, 0x78, 0xc5, 0x58, 0x9d, 0x68, 0x84, 0xc6, 0xfb, 0xa2, 0x05, 0xa7, 0xb2, - 0xac, 0x84, 0xe9, 0xdb, 0x8d, 0x4b, 0xdf, 0x94, 0x11, 0x98, 0x9a, 0xcd, 0x5b, 0xa2, 0x1c, 0x2b, - 0x8c, 0x9e, 0x33, 0xfa, 0x1d, 0x2d, 0x52, 0xf4, 0x0d, 0x18, 0xad, 0x04, 0x44, 0xbb, 0x5c, 0x5f, - 0xe7, 0x21, 0x17, 0x78, 0x7f, 0x9e, 0x3b, 0x72, 0xb8, 0x05, 0xfb, 0xcb, 0x05, 0x38, 0xc5, 0x6d, - 0x29, 0x16, 0xf6, 0x7c, 0xb7, 0x5e, 0xf1, 0xeb, 0xc2, 0x17, 0xec, 0x13, 0x30, 0xd2, 0xd2, 0x44, - 0xa6, 0x9d, 0xa2, 0x9e, 0xea, 0xa2, 0xd5, 0x58, 0xc8, 0xa3, 0x97, 0x62, 0x83, 0x16, 0xaa, 0xc3, - 0x08, 0xd9, 0x73, 0x6b, 0x4a, 0x21, 0x5f, 0x38, 0xf2, 0x45, 0xa7, 0x5a, 0x59, 0xd6, 0xe8, 0x60, - 0x83, 0xea, 0x43, 0xc8, 0xb3, 0x6d, 0xff, 0xa8, 0x05, 0x8f, 0xe4, 0xc4, 0x48, 0xa5, 0xcd, 0xdd, - 0x61, 0x56, 0x2b, 0x62, 0xd9, 0xaa, 0xe6, 0xb8, 0x2d, 0x0b, 0x16, 0x50, 0xf4, 0x31, 0x00, 0x6e, - 0x8b, 0x42, 0xbc, 0x5a, 0xd7, 0x60, 0x92, 0x46, 0x1c, 0x3c, 0x2d, 0xa4, 0x99, 0xac, 0x8f, 0x35, - 0x5a, 0xf6, 0x17, 0xfb, 0xa0, 0x9f, 0xd9, 0x3e, 0xa0, 0x0a, 0x0c, 0xee, 0xf0, 0xac, 0x37, 0x1d, - 0xe7, 0x8d, 0xe2, 0xca, 0x44, 0x3a, 0xf1, 0xbc, 0x69, 0xa5, 0x58, 0x92, 0x41, 0x6b, 0x30, 0xc5, - 0x93, 0x0f, 0x35, 0xca, 0xa4, 0xe1, 0xec, 0x4b, 0x69, 0x24, 0xcf, 0x94, 0xab, 0xa4, 0xb2, 0xab, - 0x69, 0x14, 0x9c, 0x55, 0x0f, 0xbd, 0x0e, 0x63, 0xf4, 0x75, 0xe8, 0xb7, 0x23, 0x49, 0x89, 0xa7, - 0x1d, 0x52, 0xcf, 0xd1, 0x0d, 0x03, 0x8a, 0x13, 0xd8, 0xe8, 0x35, 0x18, 0x6d, 0xa5, 0xe4, 0xae, - 0xfd, 0xb1, 0x80, 0xc2, 0x94, 0xb5, 0x9a, 0xb8, 0xcc, 0x50, 0xb8, 0xcd, 0xcc, 0xa2, 0x37, 0x76, - 0x02, 0x12, 0xee, 0xf8, 0x8d, 0x3a, 0x63, 0xff, 0xfa, 0x35, 0x43, 0xe1, 0x04, 0x1c, 0xa7, 0x6a, - 0x50, 0x2a, 0x5b, 0x8e, 0xdb, 0x68, 0x07, 0x24, 0xa6, 0x32, 0x60, 0x52, 0x59, 0x49, 0xc0, 0x71, - 0xaa, 0x46, 0x77, 0x81, 0xf2, 0xe0, 0xf1, 0x08, 0x94, 0xed, 0xbf, 0x59, 0x00, 0x63, 0x6a, 0xbf, - 0x75, 0xd3, 0x21, 0xd1, 0x2f, 0xdb, 0x0e, 0x5a, 0x35, 0x61, 0xe7, 0x93, 0xf9, 0x65, 0x71, 0x96, - 0x53, 0xfe, 0x65, 0xf4, 0x3f, 0x66, 0xb5, 0xe8, 0x1e, 0x3f, 0x5d, 0x09, 0x7c, 0x7a, 0xc9, 0xc9, - 0xa0, 0x5c, 0xca, 0x1e, 0x7f, 0x50, 0xfa, 0x2a, 0x77, 0x08, 0x5f, 0x29, 0x2c, 0x96, 0x39, 0x05, - 0xc3, 0x24, 0xa6, 0x2a, 0x22, 0x07, 0x48, 0x2a, 0xe8, 0x32, 0x0c, 0x8b, 0x1c, 0x37, 0xcc, 0x6c, - 0x9c, 0x6f, 0x26, 0x66, 0xc2, 0x53, 0x8e, 0x8b, 0xb1, 0x8e, 0x63, 0xff, 0x40, 0x01, 0xa6, 0x32, - 0xfc, 0x7e, 0xf8, 0x35, 0xb2, 0xed, 0x86, 0x91, 0x4a, 0xa4, 0xaa, 0x5d, 0x23, 0xbc, 0x1c, 0x2b, - 0x0c, 0x7a, 0x56, 0xf1, 0x8b, 0x2a, 0x79, 0x39, 0x09, 0xbb, 0x7a, 0x01, 0x3d, 0x62, 0x4a, 0xd2, - 0x0b, 0xd0, 0xd7, 0x0e, 0x89, 0x0c, 0x3c, 0xab, 0xae, 0x6d, 0xa6, 0x6d, 0x65, 0x10, 0xfa, 0x8c, - 0xda, 0x56, 0x8a, 0x4b, 0xed, 0x19, 0xc5, 0x55, 0x97, 0x1c, 0x46, 0x3b, 0x17, 0x11, 0xcf, 0xf1, - 0x22, 0xf1, 0xd8, 0x8a, 0x23, 0x28, 0xb2, 0x52, 0x2c, 0xa0, 0xf6, 0x17, 0x8a, 0x70, 0x36, 0xd7, - 0x13, 0x90, 0x76, 0xbd, 0xe9, 0x7b, 0x6e, 0xe4, 0x2b, 0xdb, 0x28, 0x1e, 0x35, 0x91, 0xb4, 0x76, - 0xd6, 0x44, 0x39, 0x56, 0x18, 0xe8, 0x22, 0xf4, 0x33, 0x59, 0x6d, 0x2a, 0xa5, 0xec, 0x62, 0x99, - 0x87, 0xd1, 0xe2, 0xe0, 0x9e, 0xb3, 0x80, 0x3f, 0x41, 0x39, 0x18, 0xbf, 0x91, 0xbc, 0x50, 0x68, - 0x77, 0x7d, 0xbf, 0x81, 0x19, 0x10, 0x3d, 0x25, 0xc6, 0x2b, 0x61, 0x0c, 0x84, 0x9d, 0xba, 0x1f, - 0x6a, 0x83, 0xf6, 0x0c, 0x0c, 0xee, 0x92, 0xfd, 0xc0, 0xf5, 0xb6, 0x93, 0x46, 0x62, 0xd7, 0x78, - 0x31, 0x96, 0x70, 0x33, 0x07, 0xe2, 0xe0, 0x71, 0xa7, 0xef, 0x1e, 0xea, 0xca, 0x9e, 0xfc, 0x50, - 0x11, 0xc6, 0xf1, 0x62, 0xf9, 0xbd, 0x89, 0xb8, 0x99, 0x9e, 0x88, 0xe3, 0x4e, 0xdf, 0xdd, 0x7d, - 0x36, 0x7e, 0xce, 0x82, 0x71, 0x96, 0x69, 0x47, 0xf8, 0xfb, 0xbb, 0xbe, 0x77, 0x02, 0x4f, 0x81, - 0x27, 0xa0, 0x3f, 0xa0, 0x8d, 0x26, 0x73, 0xc9, 0xb2, 0x9e, 0x60, 0x0e, 0x43, 0x8f, 0x41, 0x1f, - 0xeb, 0x02, 0x9d, 0xbc, 0x11, 0x7e, 0x04, 0x97, 0x9d, 0xc8, 0xc1, 0xac, 0x94, 0x05, 0x91, 0xc2, - 0xa4, 0xd5, 0x70, 0x79, 0xa7, 0x63, 0x4d, 0xfa, 0xbb, 0x23, 0x46, 0x40, 0x66, 0xd7, 0xde, 0x59, - 0x10, 0xa9, 0x6c, 0x92, 0x9d, 0x9f, 0xd9, 0x7f, 0x50, 0x80, 0xf3, 0x99, 0xf5, 0x7a, 0x0e, 0x22, - 0xd5, 0xb9, 0xf6, 0xc3, 0xcc, 0xa5, 0x52, 0x3c, 0x41, 0x13, 0xdc, 0xbe, 0x5e, 0xb9, 0xff, 0xfe, - 0x1e, 0x62, 0x3b, 0x65, 0x0e, 0xd9, 0xbb, 0x24, 0xb6, 0x53, 0x66, 0xdf, 0x72, 0xc4, 0x04, 0x7f, - 0x5a, 0xc8, 0xf9, 0x16, 0x26, 0x30, 0xb8, 0x44, 0xcf, 0x19, 0x06, 0x0c, 0xe5, 0x23, 0x9c, 0x9f, - 0x31, 0xbc, 0x0c, 0x2b, 0x28, 0x5a, 0x80, 0xf1, 0xa6, 0xeb, 0xd1, 0xc3, 0x67, 0xdf, 0x64, 0xc5, - 0x95, 0x88, 0x7d, 0xcd, 0x04, 0xe3, 0x24, 0x3e, 0x72, 0xb5, 0xb8, 0x4f, 0xfc, 0xeb, 0x5e, 0x3b, - 0xd2, 0xae, 0x9b, 0x33, 0xad, 0x0c, 0xd4, 0x28, 0x66, 0xc4, 0x80, 0x5a, 0xd3, 0xe4, 0x44, 0xc5, - 0xde, 0xe5, 0x44, 0x23, 0xd9, 0x32, 0xa2, 0x99, 0xd7, 0x60, 0xf4, 0x81, 0x15, 0x03, 0xf6, 0xd7, - 0x8a, 0xf0, 0x68, 0x87, 0x6d, 0xcf, 0xcf, 0x7a, 0x63, 0x0e, 0xb4, 0xb3, 0x3e, 0x35, 0x0f, 0x15, - 0x38, 0xb5, 0xd5, 0x6e, 0x34, 0xf6, 0x99, 0x67, 0x0a, 0xa9, 0x4b, 0x0c, 0xc1, 0x53, 0x4a, 0xe1, - 0xc8, 0xa9, 0x95, 0x0c, 0x1c, 0x9c, 0x59, 0x93, 0x3e, 0xb1, 0xe8, 0x4d, 0xb2, 0xaf, 0x48, 0x25, - 0x9e, 0x58, 0x58, 0x07, 0x62, 0x13, 0x17, 0x5d, 0x81, 0x49, 0x67, 0xcf, 0x71, 0x79, 0xf0, 0x6c, - 0x49, 0x80, 0xbf, 0xb1, 0x94, 0x3c, 0x77, 0x21, 0x89, 0x80, 0xd3, 0x75, 0xd0, 0x1b, 0x80, 0xfc, - 0x4d, 0x66, 0xbf, 0x5e, 0xbf, 0x42, 0x3c, 0xa1, 0x0c, 0x66, 0x73, 0x57, 0x8c, 0x8f, 0x84, 0x1b, - 0x29, 0x0c, 0x9c, 0x51, 0x2b, 0x11, 0xdf, 0x68, 0x20, 0x3f, 0xbe, 0x51, 0xe7, 0x73, 0xb1, 0x6b, - 0x1a, 0x9f, 0xff, 0x60, 0xd1, 0xeb, 0x8b, 0x33, 0xf9, 0x66, 0x38, 0xd0, 0xd7, 0x98, 0x0d, 0x28, - 0x97, 0xf5, 0x6a, 0xd1, 0x60, 0x4e, 0x6b, 0x36, 0xa0, 0x31, 0x10, 0x9b, 0xb8, 0x7c, 0x41, 0x84, - 0xb1, 0x13, 0xb2, 0xc1, 0xe2, 0x8b, 0x98, 0x65, 0x0a, 0x03, 0x7d, 0x1c, 0x06, 0xeb, 0xee, 0x9e, - 0x1b, 0x0a, 0x49, 0xd7, 0x91, 0xd5, 0x4a, 0xf1, 0x39, 0x58, 0xe6, 0x64, 0xb0, 0xa4, 0x67, 0xff, - 0x50, 0x01, 0x46, 0x65, 0x8b, 0x6f, 0xb6, 0xfd, 0xc8, 0x39, 0x81, 0x6b, 0xf9, 0x8a, 0x71, 0x2d, - 0x3f, 0xd5, 0x29, 0x70, 0x1b, 0xeb, 0x52, 0xee, 0x75, 0x7c, 0x23, 0x71, 0x1d, 0x3f, 0xdd, 0x9d, - 0x54, 0xe7, 0x6b, 0xf8, 0x1f, 0x5a, 0x30, 0x69, 0xe0, 0x9f, 0xc0, 0x6d, 0xb0, 0x62, 0xde, 0x06, - 0x8f, 0x77, 0xfd, 0x86, 0x9c, 0x5b, 0xe0, 0x7b, 0x8b, 0x89, 0xbe, 0xb3, 0xd3, 0xff, 0x6d, 0xe8, - 0xdb, 0x71, 0x82, 0x7a, 0xa7, 0x44, 0x15, 0xa9, 0x4a, 0x73, 0x57, 0x9d, 0x40, 0x68, 0xc3, 0x9f, - 0x93, 0xa3, 0x4e, 0x8b, 0xba, 0x6a, 0xc2, 0x59, 0x53, 0xe8, 0x15, 0x18, 0x08, 0x6b, 0x7e, 0x4b, - 0xf9, 0xa5, 0x5c, 0x60, 0x03, 0xcd, 0x4a, 0x0e, 0x0f, 0x66, 0x91, 0xd9, 0x1c, 0x2d, 0xc6, 0x02, - 0x1f, 0x7d, 0x02, 0x46, 0xd9, 0x2f, 0x65, 0x9a, 0x56, 0xcc, 0x17, 0x47, 0x54, 0x75, 0x44, 0x6e, - 0xb7, 0x69, 0x14, 0x61, 0x93, 0xd4, 0xcc, 0x36, 0x94, 0xd4, 0x67, 0x3d, 0x54, 0xbd, 0xed, 0xbf, - 0x2b, 0xc2, 0x54, 0xc6, 0x9a, 0x43, 0xa1, 0x31, 0x13, 0x97, 0x7b, 0x5c, 0xaa, 0xef, 0x70, 0x2e, - 0x42, 0xf6, 0x1a, 0xaa, 0x8b, 0xb5, 0xd5, 0x73, 0xa3, 0x37, 0x43, 0x92, 0x6c, 0x94, 0x16, 0x75, - 0x6f, 0x94, 0x36, 0x76, 0x62, 0x43, 0x4d, 0x1b, 0x52, 0x3d, 0x7d, 0xa8, 0x73, 0xfa, 0xc7, 0x45, - 0x38, 0x95, 0x15, 0x4b, 0x12, 0x7d, 0x36, 0x91, 0x26, 0xf5, 0xa5, 0x5e, 0xa3, 0x50, 0xf2, 0xdc, - 0xa9, 0x22, 0xbc, 0xdd, 0x9c, 0x99, 0x38, 0xb5, 0xeb, 0x30, 0x8b, 0x36, 0x59, 0x80, 0x8d, 0x80, - 0xa7, 0xb7, 0x95, 0xc7, 0xc7, 0x07, 0x7b, 0xee, 0x80, 0xc8, 0x8b, 0x1b, 0x26, 0xcc, 0x5e, 0x64, - 0x71, 0x77, 0xb3, 0x17, 0xd9, 0xf2, 0x8c, 0x0b, 0xc3, 0xda, 0xd7, 0x3c, 0xd4, 0x19, 0xdf, 0xa5, - 0xb7, 0x95, 0xd6, 0xef, 0x87, 0x3a, 0xeb, 0x3f, 0x6a, 0x41, 0xc2, 0x13, 0x42, 0x89, 0xc5, 0xac, - 0x5c, 0xb1, 0xd8, 0x05, 0xe8, 0x0b, 0xfc, 0x06, 0x49, 0xe6, 0x13, 0xc5, 0x7e, 0x83, 0x60, 0x06, - 0xa1, 0x18, 0x51, 0x2c, 0xec, 0x18, 0xd1, 0x1f, 0x72, 0xe2, 0x89, 0xf6, 0x04, 0xf4, 0x37, 0xc8, - 0x1e, 0x69, 0x24, 0xd3, 0x3e, 0x5d, 0xa7, 0x85, 0x98, 0xc3, 0xec, 0x9f, 0xeb, 0x83, 0x73, 0x1d, - 0x43, 0xd4, 0xd0, 0xe7, 0xd0, 0xb6, 0x13, 0x91, 0x3b, 0xce, 0x7e, 0x32, 0x3f, 0xcb, 0x15, 0x5e, - 0x8c, 0x25, 0x9c, 0xf9, 0xc5, 0xf1, 0x30, 0xeb, 0x09, 0x21, 0xa2, 0x88, 0xae, 0x2e, 0xa0, 0xa6, - 0x50, 0xaa, 0x78, 0x1c, 0x42, 0xa9, 0x17, 0x00, 0xc2, 0xb0, 0xc1, 0xed, 0xc5, 0xea, 0xc2, 0xe1, - 0x2e, 0x0e, 0xc7, 0x5f, 0xbd, 0x2e, 0x20, 0x58, 0xc3, 0x42, 0x65, 0x98, 0x68, 0x05, 0x7e, 0xc4, - 0x65, 0xb2, 0x65, 0x6e, 0x52, 0xd9, 0x6f, 0x46, 0x07, 0xa9, 0x24, 0xe0, 0x38, 0x55, 0x03, 0xbd, - 0x0c, 0xc3, 0x22, 0x62, 0x48, 0xc5, 0xf7, 0x1b, 0x42, 0x0c, 0xa4, 0xac, 0x0c, 0xab, 0x31, 0x08, - 0xeb, 0x78, 0x5a, 0x35, 0x26, 0xe8, 0x1d, 0xcc, 0xac, 0xc6, 0x85, 0xbd, 0x1a, 0x5e, 0x22, 0xae, - 0xec, 0x50, 0x4f, 0x71, 0x65, 0x63, 0xc1, 0x58, 0xa9, 0x67, 0xbd, 0x23, 0x74, 0x15, 0x25, 0xfd, - 0x4c, 0x1f, 0x4c, 0x89, 0x85, 0xf3, 0xb0, 0x97, 0xcb, 0xcd, 0xf4, 0x72, 0x39, 0x0e, 0xd1, 0xd9, - 0x7b, 0x6b, 0xe6, 0xa4, 0xd7, 0xcc, 0x0f, 0x5b, 0x60, 0xb2, 0x57, 0xe8, 0xcf, 0xe4, 0x26, 0xb8, - 0x7a, 0x39, 0x97, 0x5d, 0x53, 0x31, 0x4a, 0xdf, 0x61, 0xaa, 0x2b, 0xfb, 0xdf, 0x5b, 0xf0, 0x78, - 0x57, 0x8a, 0x68, 0x19, 0x4a, 0x8c, 0x07, 0xd4, 0x5e, 0x67, 0x4f, 0x2b, 0x93, 0x6b, 0x09, 0xc8, - 0x61, 0x49, 0xe3, 0x9a, 0x68, 0x39, 0x95, 0x49, 0xec, 0x99, 0x8c, 0x4c, 0x62, 0xa7, 0x8d, 0xe1, - 0x79, 0xc0, 0x54, 0x62, 0x3f, 0x48, 0x6f, 0x1c, 0xc3, 0xdd, 0x09, 0x7d, 0xd0, 0x10, 0xfb, 0xd9, - 0x09, 0xb1, 0x1f, 0x32, 0xb1, 0xb5, 0x3b, 0xe4, 0xa3, 0x30, 0xc1, 0x42, 0x89, 0x31, 0x07, 0x00, - 0xe1, 0x88, 0x55, 0x88, 0x8d, 0x7c, 0xaf, 0x27, 0x60, 0x38, 0x85, 0x6d, 0xff, 0x7e, 0x11, 0x06, - 0xf8, 0xf6, 0x3b, 0x81, 0x37, 0xe1, 0xb3, 0x50, 0x72, 0x9b, 0xcd, 0x36, 0x4f, 0x0e, 0xd5, 0x1f, - 0x9b, 0x8c, 0xae, 0xca, 0x42, 0x1c, 0xc3, 0xd1, 0x8a, 0x90, 0x38, 0x77, 0x88, 0x56, 0xca, 0x3b, - 0x3e, 0x57, 0x76, 0x22, 0x87, 0x33, 0x38, 0xea, 0x9e, 0x8d, 0x65, 0xd3, 0xe8, 0x53, 0x00, 0x61, - 0x14, 0xb8, 0xde, 0x36, 0x2d, 0x13, 0x41, 0x92, 0xdf, 0xdf, 0x81, 0x5a, 0x55, 0x21, 0x73, 0x9a, - 0xf1, 0x99, 0xa3, 0x00, 0x58, 0xa3, 0x88, 0xe6, 0x8c, 0x9b, 0x7e, 0x26, 0x31, 0x77, 0xc0, 0xa9, - 0xc6, 0x73, 0x36, 0xf3, 0x21, 0x28, 0x29, 0xe2, 0xdd, 0xe4, 0x4f, 0x23, 0x3a, 0x5b, 0xf4, 0x11, - 0x18, 0x4f, 0xf4, 0xed, 0x48, 0xe2, 0xab, 0x9f, 0xb7, 0x60, 0x9c, 0x77, 0x66, 0xd9, 0xdb, 0x13, - 0xb7, 0xc1, 0x3d, 0x38, 0xd5, 0xc8, 0x38, 0x95, 0xc5, 0xf4, 0xf7, 0x7e, 0x8a, 0x2b, 0x71, 0x55, - 0x16, 0x14, 0x67, 0xb6, 0x81, 0x2e, 0xd1, 0x1d, 0x47, 0x4f, 0x5d, 0xa7, 0x21, 0x1c, 0xbf, 0x47, - 0xf8, 0x6e, 0xe3, 0x65, 0x58, 0x41, 0xed, 0xdf, 0xb2, 0x60, 0x92, 0xf7, 0xfc, 0x1a, 0xd9, 0x57, - 0x67, 0xd3, 0x37, 0xb2, 0xef, 0x22, 0x2d, 0x61, 0x21, 0x27, 0x2d, 0xa1, 0xfe, 0x69, 0xc5, 0x8e, - 0x9f, 0xf6, 0x65, 0x0b, 0xc4, 0x0a, 0x39, 0x01, 0x21, 0xc4, 0xb7, 0x9b, 0x42, 0x88, 0x99, 0xfc, - 0x4d, 0x90, 0x23, 0x7d, 0xf8, 0x13, 0x0b, 0x26, 0x38, 0x42, 0xac, 0x2d, 0xff, 0x86, 0xce, 0x43, - 0x2f, 0xc9, 0xcb, 0xaf, 0x91, 0xfd, 0x0d, 0xbf, 0xe2, 0x44, 0x3b, 0xd9, 0x1f, 0x65, 0x4c, 0x56, - 0x5f, 0xc7, 0xc9, 0xaa, 0xcb, 0x0d, 0x64, 0x64, 0xed, 0xe9, 0x12, 0x0d, 0xe3, 0xa8, 0x59, 0x7b, - 0xec, 0xaf, 0x5b, 0x80, 0x78, 0x33, 0x06, 0xe3, 0x46, 0xd9, 0x21, 0x56, 0xaa, 0x5d, 0x74, 0xf1, - 0xd1, 0xa4, 0x20, 0x58, 0xc3, 0x3a, 0x96, 0xe1, 0x49, 0x98, 0x3c, 0x14, 0xbb, 0x9b, 0x3c, 0x1c, - 0x61, 0x44, 0xff, 0xd5, 0x00, 0x24, 0x5d, 0xbe, 0xd0, 0x2d, 0x18, 0xa9, 0x39, 0x2d, 0x67, 0xd3, - 0x6d, 0xb8, 0x91, 0x4b, 0xc2, 0x4e, 0xf6, 0x50, 0x4b, 0x1a, 0x9e, 0x50, 0x52, 0x6b, 0x25, 0xd8, - 0xa0, 0x83, 0xe6, 0x00, 0x5a, 0x81, 0xbb, 0xe7, 0x36, 0xc8, 0x36, 0x93, 0x95, 0xb0, 0x50, 0x13, - 0xdc, 0x38, 0x4b, 0x96, 0x62, 0x0d, 0x23, 0xc3, 0xbf, 0xbe, 0xf8, 0x90, 0xfd, 0xeb, 0xe1, 0xc4, - 0xfc, 0xeb, 0xfb, 0x8e, 0xe4, 0x5f, 0x3f, 0x74, 0x64, 0xff, 0xfa, 0xfe, 0x9e, 0xfc, 0xeb, 0x31, - 0x9c, 0x91, 0xbc, 0x27, 0xfd, 0xbf, 0xe2, 0x36, 0x88, 0x78, 0x70, 0xf0, 0xf8, 0x18, 0x33, 0xf7, - 0x0f, 0x66, 0xcf, 0xe0, 0x4c, 0x0c, 0x9c, 0x53, 0x13, 0x7d, 0x0c, 0xa6, 0x9d, 0x46, 0xc3, 0xbf, - 0xa3, 0x26, 0x75, 0x39, 0xac, 0x39, 0x0d, 0xae, 0x84, 0x18, 0x64, 0x54, 0x1f, 0xbb, 0x7f, 0x30, - 0x3b, 0xbd, 0x90, 0x83, 0x83, 0x73, 0x6b, 0xa3, 0x0f, 0x43, 0xa9, 0x15, 0xf8, 0xb5, 0x35, 0xcd, - 0x2f, 0xf5, 0x3c, 0x1d, 0xc0, 0x8a, 0x2c, 0x3c, 0x3c, 0x98, 0x1d, 0x55, 0x7f, 0xd8, 0x85, 0x1f, - 0x57, 0xc8, 0x70, 0x98, 0x1f, 0x3e, 0x56, 0x87, 0xf9, 0x5d, 0x98, 0xaa, 0x92, 0xc0, 0x75, 0x1a, - 0xee, 0x3d, 0xca, 0x2f, 0xcb, 0xf3, 0x69, 0x03, 0x4a, 0x41, 0xe2, 0x44, 0xee, 0x29, 0x82, 0xa8, - 0x96, 0x3e, 0x45, 0x9e, 0xc0, 0x31, 0x21, 0xfb, 0x7f, 0x5b, 0x30, 0x28, 0x5c, 0xbc, 0x4e, 0x80, - 0x6b, 0x5c, 0x30, 0x34, 0x09, 0xb3, 0xd9, 0x03, 0xc6, 0x3a, 0x93, 0xab, 0x43, 0x58, 0x4d, 0xe8, - 0x10, 0x1e, 0xef, 0x44, 0xa4, 0xb3, 0xf6, 0xe0, 0xaf, 0x16, 0x29, 0xf7, 0x6e, 0x38, 0x1b, 0x3f, - 0xfc, 0x21, 0x58, 0x87, 0xc1, 0x50, 0x38, 0xbb, 0x16, 0xf2, 0x7d, 0x1a, 0x92, 0x93, 0x18, 0xdb, - 0xb1, 0x09, 0xf7, 0x56, 0x49, 0x24, 0xd3, 0x8b, 0xb6, 0xf8, 0x10, 0xbd, 0x68, 0xbb, 0xb9, 0x63, - 0xf7, 0x1d, 0x87, 0x3b, 0xb6, 0xfd, 0x55, 0x76, 0x73, 0xea, 0xe5, 0x27, 0xc0, 0x54, 0x5d, 0x31, - 0xef, 0x58, 0xbb, 0xc3, 0xca, 0x12, 0x9d, 0xca, 0x61, 0xae, 0x7e, 0xd6, 0x82, 0x73, 0x19, 0x5f, - 0xa5, 0x71, 0x5a, 0xcf, 0xc1, 0x90, 0xd3, 0xae, 0xbb, 0x6a, 0x2f, 0x6b, 0xfa, 0xc4, 0x05, 0x51, - 0x8e, 0x15, 0x06, 0x5a, 0x82, 0x49, 0x72, 0xb7, 0xe5, 0x72, 0x55, 0xaa, 0x6e, 0xfe, 0x5b, 0xe4, - 0x7e, 0x81, 0xcb, 0x49, 0x20, 0x4e, 0xe3, 0xab, 0xc8, 0x39, 0xc5, 0xdc, 0xc8, 0x39, 0x7f, 0xc7, - 0x82, 0x61, 0xe5, 0xee, 0xf9, 0xd0, 0x47, 0xfb, 0xa3, 0xe6, 0x68, 0x3f, 0xda, 0x61, 0xb4, 0x73, - 0x86, 0xf9, 0x37, 0x0a, 0xaa, 0xbf, 0x15, 0x3f, 0x88, 0x7a, 0xe0, 0xe0, 0x1e, 0xdc, 0x75, 0xe1, - 0x32, 0x0c, 0x3b, 0xad, 0x96, 0x04, 0x48, 0x1b, 0x34, 0x16, 0x0f, 0x3a, 0x2e, 0xc6, 0x3a, 0x8e, - 0xf2, 0xa4, 0x28, 0xe6, 0x7a, 0x52, 0xd4, 0x01, 0x22, 0x27, 0xd8, 0x26, 0x11, 0x2d, 0x13, 0x26, - 0xb3, 0xf9, 0xe7, 0x4d, 0x3b, 0x72, 0x1b, 0x73, 0xae, 0x17, 0x85, 0x51, 0x30, 0xb7, 0xea, 0x45, - 0x37, 0x02, 0xfe, 0x84, 0xd4, 0x62, 0x4f, 0x29, 0x5a, 0x58, 0xa3, 0x2b, 0x43, 0x1b, 0xb0, 0x36, - 0xfa, 0x4d, 0x63, 0x86, 0x75, 0x51, 0x8e, 0x15, 0x86, 0xfd, 0x21, 0x76, 0xfb, 0xb0, 0x31, 0x3d, - 0x5a, 0xdc, 0xa5, 0x2f, 0x8f, 0xa8, 0xd9, 0x60, 0x9a, 0xcc, 0xb2, 0x1e, 0xdd, 0xa9, 0xf3, 0x61, - 0x4f, 0x1b, 0xd6, 0xfd, 0xfa, 0xe2, 0x10, 0x50, 0xe8, 0x3b, 0x52, 0x06, 0x2a, 0xcf, 0x77, 0xb9, - 0x35, 0x8e, 0x60, 0x92, 0xc2, 0x92, 0xc3, 0xb0, 0xd4, 0x19, 0xab, 0x15, 0xb1, 0x2f, 0xb4, 0xe4, - 0x30, 0x02, 0x80, 0x63, 0x1c, 0xca, 0x4c, 0xa9, 0x3f, 0xe1, 0x34, 0x8a, 0x83, 0xa4, 0x2a, 0xec, - 0x10, 0x6b, 0x18, 0x68, 0x5e, 0x08, 0x14, 0xb8, 0x5e, 0xe0, 0xd1, 0x84, 0x40, 0x41, 0x0e, 0x97, - 0x26, 0x05, 0xba, 0x0c, 0xc3, 0x2a, 0x1f, 0x78, 0x85, 0xa7, 0x65, 0x12, 0xcb, 0x6c, 0x39, 0x2e, - 0xc6, 0x3a, 0x0e, 0xda, 0x80, 0xf1, 0x90, 0xcb, 0xd9, 0x54, 0xe4, 0x6a, 0x2e, 0xaf, 0x7c, 0xbf, - 0x72, 0xb4, 0x35, 0xc1, 0x87, 0xac, 0x88, 0x9f, 0x4e, 0x32, 0xfc, 0x40, 0x92, 0x04, 0x7a, 0x1d, - 0xc6, 0x1a, 0xbe, 0x53, 0x5f, 0x74, 0x1a, 0x8e, 0x57, 0x63, 0xe3, 0x33, 0x64, 0xa6, 0x95, 0xbd, - 0x6e, 0x40, 0x71, 0x02, 0x9b, 0x32, 0x6f, 0x7a, 0x89, 0x88, 0xb6, 0xee, 0x78, 0xdb, 0x24, 0x14, - 0xd9, 0x9d, 0x19, 0xf3, 0x76, 0x3d, 0x07, 0x07, 0xe7, 0xd6, 0x46, 0xaf, 0xc0, 0x88, 0xfc, 0x7c, - 0x2d, 0x5a, 0x47, 0xec, 0x94, 0xa2, 0xc1, 0xb0, 0x81, 0x89, 0xee, 0xc0, 0x69, 0xf9, 0x7f, 0x23, - 0x70, 0xb6, 0xb6, 0xdc, 0x9a, 0x70, 0x61, 0xe7, 0xde, 0xab, 0x0b, 0xd2, 0xc5, 0x72, 0x39, 0x0b, - 0xe9, 0xf0, 0x60, 0xf6, 0x82, 0x18, 0xb5, 0x4c, 0x38, 0x9b, 0xc4, 0x6c, 0xfa, 0x68, 0x0d, 0xa6, - 0x76, 0x88, 0xd3, 0x88, 0x76, 0x96, 0x76, 0x48, 0x6d, 0x57, 0x6e, 0x3a, 0x16, 0x03, 0x44, 0x73, - 0xe0, 0xb8, 0x9a, 0x46, 0xc1, 0x59, 0xf5, 0xd0, 0x5b, 0x30, 0xdd, 0x6a, 0x6f, 0x36, 0xdc, 0x70, - 0x67, 0xdd, 0x8f, 0x98, 0x29, 0x90, 0x4a, 0x2f, 0x2e, 0x82, 0x85, 0xa8, 0x28, 0x2b, 0x95, 0x1c, - 0x3c, 0x9c, 0x4b, 0x01, 0xdd, 0x83, 0xd3, 0x89, 0xc5, 0x20, 0xc2, 0x25, 0x8c, 0xe5, 0xe7, 0xae, - 0xa8, 0x66, 0x55, 0x10, 0x91, 0x47, 0xb2, 0x40, 0x38, 0xbb, 0x09, 0xf4, 0x2a, 0x80, 0xdb, 0x5a, - 0x71, 0x9a, 0x6e, 0x83, 0x3e, 0x17, 0xa7, 0xd8, 0x3a, 0xa1, 0x4f, 0x07, 0x58, 0xad, 0xc8, 0x52, - 0x7a, 0x3e, 0x8b, 0x7f, 0xfb, 0x58, 0xc3, 0x46, 0xd7, 0x61, 0x4c, 0xfc, 0xdb, 0x17, 0xd3, 0xca, - 0xa3, 0x76, 0x3c, 0xc9, 0x42, 0x2e, 0x55, 0x74, 0xc8, 0x61, 0xaa, 0x04, 0x27, 0xea, 0xa2, 0x6d, - 0x38, 0x27, 0xf3, 0x90, 0xe9, 0x6b, 0x54, 0xce, 0x41, 0xc8, 0x12, 0x46, 0x0c, 0x71, 0xdf, 0x90, - 0x85, 0x4e, 0x88, 0xb8, 0x33, 0x1d, 0x7a, 0xb7, 0xeb, 0x4b, 0x9d, 0x7b, 0xcf, 0x9e, 0xe6, 0xa6, - 0x49, 0xf4, 0x6e, 0xbf, 0x9e, 0x04, 0xe2, 0x34, 0x3e, 0x0a, 0xe1, 0xb4, 0xeb, 0x65, 0xad, 0xec, - 0x33, 0x8c, 0xd0, 0x47, 0xb8, 0xe3, 0x70, 0xe7, 0x55, 0x9d, 0x09, 0xe7, 0xab, 0x3a, 0x93, 0xf6, - 0x3b, 0xb3, 0xc0, 0xfb, 0x4d, 0x8b, 0xd6, 0xd6, 0xb8, 0x74, 0xf4, 0x69, 0x18, 0xd1, 0x3f, 0x4c, - 0x70, 0x1c, 0x17, 0xb3, 0x99, 0x58, 0xed, 0x6c, 0xe0, 0x3c, 0xbe, 0xda, 0xff, 0x3a, 0x0c, 0x1b, - 0x14, 0x51, 0x2d, 0xc3, 0xc5, 0x7e, 0xbe, 0x37, 0x8e, 0xa6, 0x77, 0x03, 0x34, 0x02, 0xd9, 0x4b, - 0x1e, 0x5d, 0x87, 0xa1, 0x5a, 0xc3, 0x25, 0x5e, 0xb4, 0x5a, 0xe9, 0x14, 0xde, 0x6f, 0x49, 0xe0, - 0x88, 0x3d, 0x24, 0xf2, 0x3f, 0xf0, 0x32, 0xac, 0x28, 0xd8, 0xbf, 0x52, 0x80, 0xd9, 0x2e, 0xc9, - 0x44, 0x12, 0xea, 0x28, 0xab, 0x27, 0x75, 0xd4, 0x82, 0xcc, 0x9f, 0xbf, 0x9e, 0x90, 0x74, 0x25, - 0x72, 0xe3, 0xc7, 0xf2, 0xae, 0x24, 0x7e, 0xcf, 0xee, 0x01, 0xba, 0x46, 0xab, 0xaf, 0xab, 0x83, - 0x8b, 0xa1, 0xc9, 0xee, 0xef, 0xfd, 0xf9, 0x9b, 0xab, 0x95, 0xb4, 0xbf, 0x5a, 0x80, 0xd3, 0x6a, - 0x08, 0xbf, 0x75, 0x07, 0xee, 0x66, 0x7a, 0xe0, 0x8e, 0x41, 0xa7, 0x6b, 0xdf, 0x80, 0x01, 0x1e, - 0xaf, 0xb0, 0x07, 0xb6, 0xfb, 0x09, 0x33, 0x8c, 0xb0, 0xe2, 0xf4, 0x8c, 0x50, 0xc2, 0xdf, 0x6f, - 0xc1, 0x78, 0xc2, 0xcf, 0x0c, 0x61, 0xcd, 0x19, 0xf9, 0x41, 0x58, 0xe3, 0x2c, 0xa6, 0xfb, 0x02, - 0xf4, 0xed, 0xf8, 0x61, 0x94, 0x34, 0xf8, 0xb8, 0xea, 0x87, 0x11, 0x66, 0x10, 0xfb, 0xb7, 0x2d, - 0xe8, 0xdf, 0x70, 0x5c, 0x2f, 0x92, 0xca, 0x01, 0x2b, 0x47, 0x39, 0xd0, 0xcb, 0x77, 0xa1, 0x97, - 0x61, 0x80, 0x6c, 0x6d, 0x91, 0x5a, 0x24, 0x66, 0x55, 0x46, 0x72, 0x18, 0x58, 0x66, 0xa5, 0x94, - 0x0f, 0x64, 0x8d, 0xf1, 0xbf, 0x58, 0x20, 0xa3, 0xdb, 0x50, 0x8a, 0xdc, 0x26, 0x59, 0xa8, 0xd7, - 0x85, 0xca, 0xfc, 0x01, 0xa2, 0x51, 0x6c, 0x48, 0x02, 0x38, 0xa6, 0x65, 0x7f, 0xa1, 0x00, 0x10, - 0x07, 0x7a, 0xea, 0xf6, 0x89, 0x8b, 0x29, 0x65, 0xea, 0xc5, 0x0c, 0x65, 0x2a, 0x8a, 0x09, 0x66, - 0x68, 0x52, 0xd5, 0x30, 0x15, 0x7b, 0x1a, 0xa6, 0xbe, 0xa3, 0x0c, 0xd3, 0x12, 0x4c, 0xc6, 0x81, - 0xaa, 0xcc, 0x38, 0x7d, 0xec, 0xfa, 0xdc, 0x48, 0x02, 0x71, 0x1a, 0xdf, 0x26, 0x70, 0x41, 0xc5, - 0xeb, 0x11, 0x37, 0x1a, 0xb3, 0xc8, 0xd6, 0x95, 0xd3, 0x5d, 0xc6, 0x29, 0xd6, 0x16, 0x17, 0x72, - 0xb5, 0xc5, 0x3f, 0x61, 0xc1, 0xa9, 0x64, 0x3b, 0xcc, 0x7d, 0xf9, 0xf3, 0x16, 0x9c, 0x66, 0x3a, - 0x73, 0xd6, 0x6a, 0x5a, 0x43, 0xff, 0x52, 0xc7, 0x18, 0x44, 0x39, 0x3d, 0x8e, 0x43, 0x86, 0xac, - 0x65, 0x91, 0xc6, 0xd9, 0x2d, 0xda, 0xff, 0xab, 0x0f, 0xa6, 0xf3, 0x82, 0x17, 0x31, 0x87, 0x0d, - 0xe7, 0x6e, 0x75, 0x97, 0xdc, 0x11, 0x66, 0xf1, 0xb1, 0xc3, 0x06, 0x2f, 0xc6, 0x12, 0x9e, 0xcc, - 0x0f, 0x51, 0xe8, 0x31, 0x3f, 0xc4, 0x0e, 0x4c, 0xde, 0xd9, 0x21, 0xde, 0x4d, 0x2f, 0x74, 0x22, - 0x37, 0xdc, 0x72, 0x99, 0x7e, 0x99, 0xaf, 0x1b, 0x99, 0x54, 0x76, 0xf2, 0x76, 0x12, 0xe1, 0xf0, - 0x60, 0xf6, 0x9c, 0x51, 0x10, 0x77, 0x99, 0x1f, 0x24, 0x38, 0x4d, 0x34, 0x9d, 0x5e, 0xa3, 0xef, - 0x21, 0xa7, 0xd7, 0x68, 0xba, 0xc2, 0x2a, 0x45, 0x5a, 0xe3, 0xb3, 0x97, 0xe3, 0x9a, 0x2a, 0xc5, - 0x1a, 0x06, 0xfa, 0x24, 0x20, 0x3d, 0x7d, 0x90, 0x11, 0x3b, 0xf2, 0xf9, 0xfb, 0x07, 0xb3, 0x68, - 0x3d, 0x05, 0x3d, 0x3c, 0x98, 0x9d, 0xa2, 0xa5, 0xab, 0x1e, 0x7d, 0x81, 0xc6, 0x01, 0xb7, 0x32, - 0x08, 0xa1, 0xdb, 0x30, 0x41, 0x4b, 0xd9, 0x8e, 0x92, 0x81, 0x29, 0xf9, 0xab, 0xf1, 0xd9, 0xfb, - 0x07, 0xb3, 0x13, 0xeb, 0x09, 0x58, 0x1e, 0xe9, 0x14, 0x11, 0xf4, 0x2a, 0x8c, 0xc5, 0xeb, 0xea, - 0x1a, 0xd9, 0xe7, 0xe1, 0x66, 0x4a, 0x5c, 0xf0, 0xbd, 0x66, 0x40, 0x70, 0x02, 0xd3, 0xfe, 0xbc, - 0x05, 0x67, 0x73, 0xb3, 0x50, 0xa3, 0x4b, 0x30, 0xe4, 0xb4, 0x5c, 0xae, 0xc6, 0x10, 0x57, 0x0d, - 0x13, 0x97, 0x55, 0x56, 0xb9, 0x12, 0x43, 0x41, 0xe9, 0x09, 0xbf, 0xeb, 0x7a, 0xf5, 0xe4, 0x09, - 0x7f, 0xcd, 0xf5, 0xea, 0x98, 0x41, 0xd4, 0x95, 0x55, 0xcc, 0x8d, 0xd4, 0xfc, 0x7d, 0x16, 0x08, - 0x87, 0xdc, 0x1e, 0xee, 0xb7, 0x4f, 0xc0, 0xc8, 0x5e, 0x3a, 0x4d, 0xd9, 0x85, 0x7c, 0x0f, 0x65, - 0x91, 0x9c, 0x4c, 0x31, 0xad, 0x46, 0x4a, 0x32, 0x83, 0x96, 0x5d, 0x07, 0x01, 0x2d, 0x13, 0x26, - 0xa4, 0xef, 0xde, 0x9b, 0x17, 0x00, 0xea, 0x0c, 0x97, 0xe5, 0x2e, 0x2d, 0x98, 0xdc, 0x4b, 0x59, - 0x41, 0xb0, 0x86, 0x65, 0xff, 0x9b, 0x02, 0x0c, 0xcb, 0xb4, 0x58, 0x6d, 0xaf, 0x17, 0x51, 0xda, - 0x91, 0xf2, 0xe4, 0xa2, 0x79, 0x28, 0x31, 0x59, 0x6f, 0x25, 0x96, 0x40, 0x2a, 0x49, 0xcb, 0x9a, - 0x04, 0xe0, 0x18, 0x87, 0x9e, 0x34, 0x61, 0x7b, 0x93, 0xa1, 0x27, 0xdc, 0x47, 0xab, 0xbc, 0x18, - 0x4b, 0x38, 0xfa, 0x18, 0x4c, 0xf0, 0x7a, 0x81, 0xdf, 0x72, 0xb6, 0xb9, 0x7e, 0xa8, 0x5f, 0xc5, - 0xe4, 0x98, 0x58, 0x4b, 0xc0, 0x0e, 0x0f, 0x66, 0x4f, 0x25, 0xcb, 0x98, 0xe2, 0x33, 0x45, 0x85, - 0x99, 0x81, 0xf1, 0x46, 0xe8, 0x09, 0x99, 0xb2, 0x1e, 0x8b, 0x41, 0x58, 0xc7, 0xb3, 0x3f, 0x0d, - 0x28, 0x9d, 0x20, 0x0c, 0xbd, 0xc1, 0x6d, 0x7f, 0xdd, 0x80, 0xd4, 0x3b, 0x29, 0x42, 0xf5, 0xc8, - 0x13, 0xd2, 0xf3, 0x8b, 0xd7, 0xc2, 0xaa, 0xbe, 0xfd, 0x17, 0x8a, 0x30, 0x91, 0xf4, 0x75, 0x47, - 0x57, 0x61, 0x80, 0xb3, 0x67, 0x82, 0x7c, 0x07, 0x3b, 0x1b, 0xcd, 0x43, 0x9e, 0x5d, 0x54, 0x82, - 0xc3, 0x13, 0xf5, 0xd1, 0x5b, 0x30, 0x5c, 0xf7, 0xef, 0x78, 0x77, 0x9c, 0xa0, 0xbe, 0x50, 0x59, - 0x15, 0xcb, 0x39, 0xf3, 0xe1, 0x5f, 0x8e, 0xd1, 0x74, 0xaf, 0x7b, 0xa6, 0x53, 0x8e, 0x41, 0x58, - 0x27, 0x87, 0x36, 0x58, 0x56, 0x81, 0x2d, 0x77, 0x7b, 0xcd, 0x69, 0x75, 0x72, 0x04, 0x59, 0x92, - 0x48, 0x1a, 0xe5, 0x51, 0x91, 0x7a, 0x80, 0x03, 0x70, 0x4c, 0x08, 0x7d, 0x16, 0xa6, 0xc2, 0x1c, - 0x75, 0x44, 0x5e, 0xbe, 0xc8, 0x4e, 0x12, 0xfa, 0xc5, 0x47, 0xee, 0x1f, 0xcc, 0x4e, 0x65, 0x29, - 0x2e, 0xb2, 0x9a, 0xb1, 0xbf, 0x78, 0x0a, 0x8c, 0x4d, 0x6c, 0xa4, 0x0f, 0xb6, 0x8e, 0x29, 0x7d, - 0x30, 0x86, 0x21, 0xd2, 0x6c, 0x45, 0xfb, 0x65, 0x37, 0x10, 0x73, 0x92, 0x49, 0x73, 0x59, 0xe0, - 0xa4, 0x69, 0x4a, 0x08, 0x56, 0x74, 0xb2, 0x73, 0x3c, 0x17, 0xbf, 0x81, 0x39, 0x9e, 0xfb, 0x4e, - 0x30, 0xc7, 0xf3, 0x3a, 0x0c, 0x6e, 0xbb, 0x11, 0x26, 0x2d, 0x5f, 0x3c, 0x8c, 0x32, 0xd7, 0xe1, - 0x15, 0x8e, 0x92, 0xce, 0x26, 0x2a, 0x00, 0x58, 0x12, 0x41, 0x6f, 0xa8, 0x1d, 0x38, 0x90, 0x2f, - 0xbc, 0x48, 0x1b, 0x84, 0x64, 0xee, 0x41, 0x91, 0xc9, 0x79, 0xf0, 0x41, 0x33, 0x39, 0xaf, 0xc8, - 0xfc, 0xcb, 0x43, 0xf9, 0x5e, 0x5b, 0x2c, 0xbd, 0x72, 0x97, 0xac, 0xcb, 0xb7, 0xf4, 0x9c, 0xd5, - 0xa5, 0xfc, 0x93, 0x40, 0xa5, 0xa3, 0xee, 0x31, 0x53, 0xf5, 0xf7, 0x59, 0x70, 0xba, 0x95, 0x95, - 0xbe, 0x5d, 0xd8, 0x4e, 0xbc, 0xdc, 0x73, 0x86, 0x78, 0xa3, 0x41, 0x26, 0x73, 0xcc, 0x44, 0xc3, - 0xd9, 0xcd, 0xd1, 0x81, 0x0e, 0x36, 0xeb, 0x42, 0x87, 0xff, 0x44, 0x4e, 0xca, 0xeb, 0x0e, 0x89, - 0xae, 0x37, 0x32, 0xd2, 0x2b, 0x3f, 0x99, 0x97, 0x5e, 0xb9, 0xe7, 0xa4, 0xca, 0x6f, 0xa8, 0x64, - 0xd7, 0xa3, 0xf9, 0x4b, 0x89, 0xa7, 0xb2, 0xee, 0x9a, 0xe2, 0xfa, 0x0d, 0x95, 0xe2, 0xba, 0x43, - 0x18, 0x67, 0x9e, 0xc0, 0xba, 0x6b, 0x62, 0x6b, 0x2d, 0x39, 0xf5, 0xf8, 0xf1, 0x24, 0xa7, 0x36, - 0xae, 0x1a, 0x9e, 0x1f, 0xf9, 0xd9, 0x2e, 0x57, 0x8d, 0x41, 0xb7, 0xf3, 0x65, 0xc3, 0x13, 0x71, - 0x4f, 0x3e, 0x50, 0x22, 0xee, 0x5b, 0x7a, 0x62, 0x6b, 0xd4, 0x25, 0x73, 0x33, 0x45, 0xea, 0x31, - 0x9d, 0xf5, 0x2d, 0xfd, 0x02, 0x9c, 0xca, 0xa7, 0xab, 0xee, 0xb9, 0x34, 0xdd, 0xcc, 0x2b, 0x30, - 0x95, 0x26, 0xfb, 0xd4, 0xc9, 0xa4, 0xc9, 0x3e, 0x7d, 0xec, 0x69, 0xb2, 0xcf, 0x9c, 0x40, 0x9a, - 0xec, 0x47, 0x4e, 0x30, 0x4d, 0xf6, 0x2d, 0x66, 0x70, 0xc4, 0xc3, 0x1a, 0x89, 0xb0, 0xd3, 0xcf, - 0xe4, 0x44, 0x05, 0x4b, 0xc7, 0x3e, 0xe2, 0x1f, 0xa7, 0x40, 0x38, 0x26, 0x95, 0x91, 0x7e, 0x7b, - 0xfa, 0x21, 0xa4, 0xdf, 0x5e, 0x8f, 0xd3, 0x6f, 0x9f, 0xcd, 0x9f, 0xea, 0x0c, 0x17, 0x95, 0x9c, - 0xa4, 0xdb, 0xb7, 0xf4, 0x64, 0xd9, 0x8f, 0x76, 0xd0, 0x2a, 0x65, 0x09, 0x67, 0x3b, 0xa4, 0xc8, - 0x7e, 0x9d, 0xa7, 0xc8, 0x7e, 0x2c, 0xff, 0x24, 0x4f, 0x5e, 0x77, 0x46, 0x62, 0x6c, 0xda, 0x2f, - 0x15, 0x16, 0x94, 0x05, 0xd8, 0xce, 0xe9, 0x97, 0x8a, 0x2b, 0x9a, 0xee, 0x97, 0x02, 0xe1, 0x98, - 0x94, 0xfd, 0x03, 0x05, 0x38, 0xdf, 0x79, 0xbf, 0xc5, 0x12, 0xe7, 0x4a, 0xac, 0x64, 0x4f, 0x48, - 0x9c, 0xf9, 0x9b, 0x2d, 0xc6, 0xea, 0x39, 0xca, 0xe1, 0x15, 0x98, 0x54, 0xbe, 0x2d, 0xf4, 0x8d, - 0xbe, 0x1e, 0xbf, 0x7c, 0x55, 0x3c, 0x80, 0x6a, 0x12, 0x01, 0xa7, 0xeb, 0xa0, 0x05, 0x18, 0x37, - 0x0a, 0x57, 0xcb, 0xe2, 0x6d, 0x16, 0x87, 0x74, 0x36, 0xc1, 0x38, 0x89, 0x6f, 0x7f, 0xc9, 0x82, - 0x47, 0x72, 0xf2, 0x4b, 0xf6, 0x1c, 0xc4, 0x6f, 0x0b, 0xc6, 0x5b, 0x66, 0xd5, 0x2e, 0x71, 0x47, - 0x8d, 0x2c, 0x96, 0xaa, 0xaf, 0x09, 0x00, 0x4e, 0x12, 0xb5, 0x7f, 0xaa, 0x00, 0xe7, 0x3a, 0x1a, - 0x6b, 0x22, 0x0c, 0x67, 0xb6, 0x9b, 0xa1, 0xb3, 0x14, 0x90, 0x3a, 0xf1, 0x22, 0xd7, 0x69, 0x54, - 0x5b, 0xa4, 0xa6, 0xe9, 0x0c, 0x98, 0xd5, 0xe3, 0x95, 0xb5, 0xea, 0x42, 0x1a, 0x03, 0xe7, 0xd4, - 0x44, 0x2b, 0x80, 0xd2, 0x10, 0x31, 0xc3, 0x2c, 0x54, 0x7b, 0x9a, 0x1e, 0xce, 0xa8, 0x81, 0x3e, - 0x04, 0xa3, 0xca, 0x08, 0x54, 0x9b, 0x71, 0x76, 0xb0, 0x63, 0x1d, 0x80, 0x4d, 0x3c, 0x74, 0x99, - 0xc7, 0xfa, 0x17, 0x59, 0x21, 0x84, 0x82, 0x61, 0x5c, 0x06, 0xf2, 0x17, 0xc5, 0x58, 0xc7, 0x59, - 0x7c, 0xe5, 0x57, 0x7f, 0xf7, 0xfc, 0xfb, 0x7e, 0xfd, 0x77, 0xcf, 0xbf, 0xef, 0xb7, 0x7e, 0xf7, - 0xfc, 0xfb, 0xbe, 0xeb, 0xfe, 0x79, 0xeb, 0x57, 0xef, 0x9f, 0xb7, 0x7e, 0xfd, 0xfe, 0x79, 0xeb, - 0xb7, 0xee, 0x9f, 0xb7, 0x7e, 0xe7, 0xfe, 0x79, 0xeb, 0x0b, 0xbf, 0x77, 0xfe, 0x7d, 0x9f, 0x40, - 0x71, 0x58, 0xcc, 0x79, 0x3a, 0x3b, 0xf3, 0x7b, 0x97, 0xff, 0x7f, 0x00, 0x00, 0x00, 0xff, 0xff, - 0x27, 0x62, 0xd1, 0x9e, 0x33, 0x0a, 0x01, 0x00, + // 14435 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0xbd, 0x6b, 0x70, 0x24, 0xd7, + 0x79, 0x18, 0xaa, 0x9e, 0xc1, 0x6b, 0x3e, 0xbc, 0x0f, 0x76, 0x97, 0x58, 0x90, 0xbb, 0x58, 0x36, + 0xc9, 0xe5, 0x52, 0x24, 0x01, 0x2d, 0x1f, 0x12, 0x4d, 0x4a, 0xb4, 0x00, 0x0c, 0xb0, 0x0b, 0xee, + 0x02, 0x3b, 0x3c, 0x83, 0xdd, 0x95, 0x64, 0x4a, 0xa5, 0xc6, 0xcc, 0x01, 0xd0, 0xc2, 0x4c, 0xf7, + 0xb0, 0xbb, 0x07, 0xbb, 0xd8, 0x2b, 0xd7, 0xf5, 0x95, 0x9f, 0xb2, 0x7d, 0x6f, 0xa9, 0x6e, 0x39, + 0x8f, 0x92, 0x5d, 0xae, 0x94, 0xe3, 0xd8, 0x56, 0x94, 0xa4, 0xa2, 0xc8, 0xb1, 0x1d, 0xcb, 0x89, + 0x9d, 0xb7, 0x93, 0x1f, 0x8e, 0xe3, 0xaa, 0x58, 0xae, 0x72, 0x05, 0xb1, 0xd7, 0xa9, 0xb8, 0x54, + 0x95, 0xd8, 0x4e, 0x9c, 0x54, 0x25, 0x88, 0x13, 0xa7, 0xce, 0xb3, 0xcf, 0xe9, 0xc7, 0xcc, 0x60, + 0x89, 0x85, 0x28, 0x15, 0xff, 0xcd, 0x9c, 0xef, 0x3b, 0xdf, 0x39, 0x7d, 0x9e, 0xdf, 0xf9, 0x9e, + 0xf0, 0xda, 0xee, 0x2b, 0xe1, 0x9c, 0xeb, 0xcf, 0xef, 0xb6, 0x37, 0x49, 0xe0, 0x91, 0x88, 0x84, + 0xf3, 0x7b, 0xc4, 0xab, 0xfb, 0xc1, 0xbc, 0x00, 0x38, 0x2d, 0x77, 0xbe, 0xe6, 0x07, 0x64, 0x7e, + 0xef, 0xf2, 0xfc, 0x36, 0xf1, 0x48, 0xe0, 0x44, 0xa4, 0x3e, 0xd7, 0x0a, 0xfc, 0xc8, 0x47, 0x88, + 0xe3, 0xcc, 0x39, 0x2d, 0x77, 0x8e, 0xe2, 0xcc, 0xed, 0x5d, 0x9e, 0x79, 0x7e, 0xdb, 0x8d, 0x76, + 0xda, 0x9b, 0x73, 0x35, 0xbf, 0x39, 0xbf, 0xed, 0x6f, 0xfb, 0xf3, 0x0c, 0x75, 0xb3, 0xbd, 0xc5, + 0xfe, 0xb1, 0x3f, 0xec, 0x17, 0x27, 0x31, 0xf3, 0x52, 0xdc, 0x4c, 0xd3, 0xa9, 0xed, 0xb8, 0x1e, + 0x09, 0xf6, 0xe7, 0x5b, 0xbb, 0xdb, 0xac, 0xdd, 0x80, 0x84, 0x7e, 0x3b, 0xa8, 0x91, 0x64, 0xc3, + 0x1d, 0x6b, 0x85, 0xf3, 0x4d, 0x12, 0x39, 0x19, 0xdd, 0x9d, 0x99, 0xcf, 0xab, 0x15, 0xb4, 0xbd, + 0xc8, 0x6d, 0xa6, 0x9b, 0xf9, 0x60, 0xb7, 0x0a, 0x61, 0x6d, 0x87, 0x34, 0x9d, 0x54, 0xbd, 0x17, + 0xf3, 0xea, 0xb5, 0x23, 0xb7, 0x31, 0xef, 0x7a, 0x51, 0x18, 0x05, 0xc9, 0x4a, 0xf6, 0xd7, 0x2d, + 0xb8, 0xb0, 0x70, 0xbb, 0xba, 0xdc, 0x70, 0xc2, 0xc8, 0xad, 0x2d, 0x36, 0xfc, 0xda, 0x6e, 0x35, + 0xf2, 0x03, 0x72, 0xcb, 0x6f, 0xb4, 0x9b, 0xa4, 0xca, 0x06, 0x02, 0x3d, 0x07, 0x43, 0x7b, 0xec, + 0xff, 0x6a, 0x79, 0xda, 0xba, 0x60, 0x5d, 0x2a, 0x2d, 0x4e, 0xfc, 0xfa, 0xc1, 0xec, 0xfb, 0xee, + 0x1f, 0xcc, 0x0e, 0xdd, 0x12, 0xe5, 0x58, 0x61, 0xa0, 0x8b, 0x30, 0xb0, 0x15, 0x6e, 0xec, 0xb7, + 0xc8, 0x74, 0x81, 0xe1, 0x8e, 0x09, 0xdc, 0x81, 0x95, 0x2a, 0x2d, 0xc5, 0x02, 0x8a, 0xe6, 0xa1, + 0xd4, 0x72, 0x82, 0xc8, 0x8d, 0x5c, 0xdf, 0x9b, 0x2e, 0x5e, 0xb0, 0x2e, 0xf5, 0x2f, 0x4e, 0x0a, + 0xd4, 0x52, 0x45, 0x02, 0x70, 0x8c, 0x43, 0xbb, 0x11, 0x10, 0xa7, 0x7e, 0xc3, 0x6b, 0xec, 0x4f, + 0xf7, 0x5d, 0xb0, 0x2e, 0x0d, 0xc5, 0xdd, 0xc0, 0xa2, 0x1c, 0x2b, 0x0c, 0xfb, 0x8b, 0x05, 0x18, + 0x5a, 0xd8, 0xda, 0x72, 0x3d, 0x37, 0xda, 0x47, 0xb7, 0x60, 0xc4, 0xf3, 0xeb, 0x44, 0xfe, 0x67, + 0x5f, 0x31, 0xfc, 0xc2, 0x85, 0xb9, 0xf4, 0x52, 0x9a, 0x5b, 0xd7, 0xf0, 0x16, 0x27, 0xee, 0x1f, + 0xcc, 0x8e, 0xe8, 0x25, 0xd8, 0xa0, 0x83, 0x30, 0x0c, 0xb7, 0xfc, 0xba, 0x22, 0x5b, 0x60, 0x64, + 0x67, 0xb3, 0xc8, 0x56, 0x62, 0xb4, 0xc5, 0xf1, 0xfb, 0x07, 0xb3, 0xc3, 0x5a, 0x01, 0xd6, 0x89, + 0xa0, 0x4d, 0x18, 0xa7, 0x7f, 0xbd, 0xc8, 0x55, 0x74, 0x8b, 0x8c, 0xee, 0x13, 0x79, 0x74, 0x35, + 0xd4, 0xc5, 0xa9, 0xfb, 0x07, 0xb3, 0xe3, 0x89, 0x42, 0x9c, 0x24, 0x68, 0xdf, 0x83, 0xb1, 0x85, + 0x28, 0x72, 0x6a, 0x3b, 0xa4, 0xce, 0x67, 0x10, 0xbd, 0x04, 0x7d, 0x9e, 0xd3, 0x24, 0x62, 0x7e, + 0x2f, 0x88, 0x81, 0xed, 0x5b, 0x77, 0x9a, 0xe4, 0xf0, 0x60, 0x76, 0xe2, 0xa6, 0xe7, 0xbe, 0xdd, + 0x16, 0xab, 0x82, 0x96, 0x61, 0x86, 0x8d, 0x5e, 0x00, 0xa8, 0x93, 0x3d, 0xb7, 0x46, 0x2a, 0x4e, + 0xb4, 0x23, 0xe6, 0x1b, 0x89, 0xba, 0x50, 0x56, 0x10, 0xac, 0x61, 0xd9, 0x77, 0xa1, 0xb4, 0xb0, + 0xe7, 0xbb, 0xf5, 0x8a, 0x5f, 0x0f, 0xd1, 0x2e, 0x8c, 0xb7, 0x02, 0xb2, 0x45, 0x02, 0x55, 0x34, + 0x6d, 0x5d, 0x28, 0x5e, 0x1a, 0x7e, 0xe1, 0x52, 0xe6, 0xc7, 0x9a, 0xa8, 0xcb, 0x5e, 0x14, 0xec, + 0x2f, 0x3e, 0x22, 0xda, 0x1b, 0x4f, 0x40, 0x71, 0x92, 0xb2, 0xfd, 0x4f, 0x0a, 0x70, 0x7a, 0xe1, + 0x5e, 0x3b, 0x20, 0x65, 0x37, 0xdc, 0x4d, 0xae, 0xf0, 0xba, 0x1b, 0xee, 0xae, 0xc7, 0x23, 0xa0, + 0x96, 0x56, 0x59, 0x94, 0x63, 0x85, 0x81, 0x9e, 0x87, 0x41, 0xfa, 0xfb, 0x26, 0x5e, 0x15, 0x9f, + 0x3c, 0x25, 0x90, 0x87, 0xcb, 0x4e, 0xe4, 0x94, 0x39, 0x08, 0x4b, 0x1c, 0xb4, 0x06, 0xc3, 0x35, + 0xb6, 0x21, 0xb7, 0xd7, 0xfc, 0x3a, 0x61, 0x93, 0x59, 0x5a, 0x7c, 0x96, 0xa2, 0x2f, 0xc5, 0xc5, + 0x87, 0x07, 0xb3, 0xd3, 0xbc, 0x6f, 0x82, 0x84, 0x06, 0xc3, 0x7a, 0x7d, 0x64, 0xab, 0xfd, 0xd5, + 0xc7, 0x28, 0x41, 0xc6, 0xde, 0xba, 0xa4, 0x6d, 0x95, 0x7e, 0xb6, 0x55, 0x46, 0xb2, 0xb7, 0x09, + 0xba, 0x0c, 0x7d, 0xbb, 0xae, 0x57, 0x9f, 0x1e, 0x60, 0xb4, 0xce, 0xd1, 0x39, 0xbf, 0xe6, 0x7a, + 0xf5, 0xc3, 0x83, 0xd9, 0x49, 0xa3, 0x3b, 0xb4, 0x10, 0x33, 0x54, 0xfb, 0x4f, 0x2d, 0x98, 0x65, + 0xb0, 0x15, 0xb7, 0x41, 0x2a, 0x24, 0x08, 0xdd, 0x30, 0x22, 0x5e, 0x64, 0x0c, 0xe8, 0x0b, 0x00, + 0x21, 0xa9, 0x05, 0x24, 0xd2, 0x86, 0x54, 0x2d, 0x8c, 0xaa, 0x82, 0x60, 0x0d, 0x8b, 0x1e, 0x08, + 0xe1, 0x8e, 0x13, 0xb0, 0xf5, 0x25, 0x06, 0x56, 0x1d, 0x08, 0x55, 0x09, 0xc0, 0x31, 0x8e, 0x71, + 0x20, 0x14, 0xbb, 0x1d, 0x08, 0xe8, 0x23, 0x30, 0x1e, 0x37, 0x16, 0xb6, 0x9c, 0x9a, 0x1c, 0x40, + 0xb6, 0x65, 0xaa, 0x26, 0x08, 0x27, 0x71, 0xed, 0xbf, 0x6e, 0x89, 0xc5, 0x43, 0xbf, 0xfa, 0x5d, + 0xfe, 0xad, 0xf6, 0x2f, 0x59, 0x30, 0xb8, 0xe8, 0x7a, 0x75, 0xd7, 0xdb, 0x46, 0x9f, 0x86, 0x21, + 0x7a, 0x37, 0xd5, 0x9d, 0xc8, 0x11, 0xe7, 0xde, 0x07, 0xb4, 0xbd, 0xa5, 0xae, 0x8a, 0xb9, 0xd6, + 0xee, 0x36, 0x2d, 0x08, 0xe7, 0x28, 0x36, 0xdd, 0x6d, 0x37, 0x36, 0x3f, 0x43, 0x6a, 0xd1, 0x1a, + 0x89, 0x9c, 0xf8, 0x73, 0xe2, 0x32, 0xac, 0xa8, 0xa2, 0x6b, 0x30, 0x10, 0x39, 0xc1, 0x36, 0x89, + 0xc4, 0x01, 0x98, 0x79, 0x50, 0xf1, 0x9a, 0x98, 0xee, 0x48, 0xe2, 0xd5, 0x48, 0x7c, 0x2d, 0x6c, + 0xb0, 0xaa, 0x58, 0x90, 0xb0, 0xff, 0xd7, 0x20, 0x9c, 0x5d, 0xaa, 0xae, 0xe6, 0xac, 0xab, 0x8b, + 0x30, 0x50, 0x0f, 0xdc, 0x3d, 0x12, 0x88, 0x71, 0x56, 0x54, 0xca, 0xac, 0x14, 0x0b, 0x28, 0x7a, + 0x05, 0x46, 0xf8, 0x85, 0x74, 0xd5, 0xf1, 0xea, 0x0d, 0x39, 0xc4, 0xa7, 0x04, 0xf6, 0xc8, 0x2d, + 0x0d, 0x86, 0x0d, 0xcc, 0x23, 0x2e, 0xaa, 0x8b, 0x89, 0xcd, 0x98, 0x77, 0xd9, 0x7d, 0xde, 0x82, + 0x09, 0xde, 0xcc, 0x42, 0x14, 0x05, 0xee, 0x66, 0x3b, 0x22, 0xe1, 0x74, 0x3f, 0x3b, 0xe9, 0x96, + 0xb2, 0x46, 0x2b, 0x77, 0x04, 0xe6, 0x6e, 0x25, 0xa8, 0xf0, 0x43, 0x70, 0x5a, 0xb4, 0x3b, 0x91, + 0x04, 0xe3, 0x54, 0xb3, 0xe8, 0x7b, 0x2d, 0x98, 0xa9, 0xf9, 0x5e, 0x14, 0xf8, 0x8d, 0x06, 0x09, + 0x2a, 0xed, 0xcd, 0x86, 0x1b, 0xee, 0xf0, 0x75, 0x8a, 0xc9, 0x16, 0x3b, 0x09, 0x72, 0xe6, 0x50, + 0x21, 0x89, 0x39, 0x3c, 0x7f, 0xff, 0x60, 0x76, 0x66, 0x29, 0x97, 0x14, 0xee, 0xd0, 0x0c, 0xda, + 0x05, 0x44, 0xaf, 0xd2, 0x6a, 0xe4, 0x6c, 0x93, 0xb8, 0xf1, 0xc1, 0xde, 0x1b, 0x3f, 0x73, 0xff, + 0x60, 0x16, 0xad, 0xa7, 0x48, 0xe0, 0x0c, 0xb2, 0xe8, 0x6d, 0x38, 0x45, 0x4b, 0x53, 0xdf, 0x3a, + 0xd4, 0x7b, 0x73, 0xd3, 0xf7, 0x0f, 0x66, 0x4f, 0xad, 0x67, 0x10, 0xc1, 0x99, 0xa4, 0xd1, 0xf7, + 0x58, 0x70, 0x36, 0xfe, 0xfc, 0xe5, 0xbb, 0x2d, 0xc7, 0xab, 0xc7, 0x0d, 0x97, 0x7a, 0x6f, 0x98, + 0x9e, 0xc9, 0x67, 0x97, 0xf2, 0x28, 0xe1, 0xfc, 0x46, 0x90, 0x07, 0x53, 0xb4, 0x6b, 0xc9, 0xb6, + 0xa1, 0xf7, 0xb6, 0x1f, 0xb9, 0x7f, 0x30, 0x3b, 0xb5, 0x9e, 0xa6, 0x81, 0xb3, 0x08, 0xcf, 0x2c, + 0xc1, 0xe9, 0xcc, 0xd5, 0x89, 0x26, 0xa0, 0xb8, 0x4b, 0x38, 0xd7, 0x55, 0xc2, 0xf4, 0x27, 0x3a, + 0x05, 0xfd, 0x7b, 0x4e, 0xa3, 0x2d, 0x36, 0x26, 0xe6, 0x7f, 0x5e, 0x2d, 0xbc, 0x62, 0xd9, 0xff, + 0xb4, 0x08, 0xe3, 0x4b, 0xd5, 0xd5, 0x07, 0xda, 0xf5, 0xfa, 0xb5, 0x57, 0xe8, 0x78, 0xed, 0xc5, + 0x97, 0x68, 0x31, 0xf7, 0x12, 0xfd, 0xbf, 0x33, 0xb6, 0x6c, 0x1f, 0xdb, 0xb2, 0xdf, 0x91, 0xb3, + 0x65, 0x8f, 0x79, 0xa3, 0xee, 0xe5, 0xac, 0xda, 0x7e, 0x36, 0x81, 0x99, 0x1c, 0xd2, 0x75, 0xbf, + 0xe6, 0x34, 0x92, 0x47, 0xed, 0x11, 0x97, 0xee, 0xf1, 0xcc, 0x63, 0x0d, 0x46, 0x96, 0x9c, 0x96, + 0xb3, 0xe9, 0x36, 0xdc, 0xc8, 0x25, 0x21, 0x7a, 0x1a, 0x8a, 0x4e, 0xbd, 0xce, 0xb8, 0xbb, 0xd2, + 0xe2, 0xe9, 0xfb, 0x07, 0xb3, 0xc5, 0x85, 0x3a, 0x65, 0x33, 0x40, 0x61, 0xed, 0x63, 0x8a, 0x81, + 0xde, 0x0f, 0x7d, 0xf5, 0xc0, 0x6f, 0x4d, 0x17, 0x18, 0x26, 0xdd, 0xe5, 0x7d, 0xe5, 0xc0, 0x6f, + 0x25, 0x50, 0x19, 0x8e, 0xfd, 0x6b, 0x05, 0x78, 0x6c, 0x89, 0xb4, 0x76, 0x56, 0xaa, 0x39, 0xf7, + 0xc5, 0x25, 0x18, 0x6a, 0xfa, 0x9e, 0x1b, 0xf9, 0x41, 0x28, 0x9a, 0x66, 0x2b, 0x62, 0x4d, 0x94, + 0x61, 0x05, 0x45, 0x17, 0xa0, 0xaf, 0x15, 0x33, 0xb1, 0x23, 0x92, 0x01, 0x66, 0xec, 0x2b, 0x83, + 0x50, 0x8c, 0x76, 0x48, 0x02, 0xb1, 0x62, 0x14, 0xc6, 0xcd, 0x90, 0x04, 0x98, 0x41, 0x62, 0x4e, + 0x80, 0xf2, 0x08, 0xe2, 0x46, 0x48, 0x70, 0x02, 0x14, 0x82, 0x35, 0x2c, 0x54, 0x81, 0x52, 0x98, + 0x98, 0xd9, 0x9e, 0xb6, 0xe6, 0x28, 0x63, 0x15, 0xd4, 0x4c, 0xc6, 0x44, 0x8c, 0x1b, 0x6c, 0xa0, + 0x2b, 0xab, 0xf0, 0xb5, 0x02, 0x20, 0x3e, 0x84, 0xdf, 0x62, 0x03, 0x77, 0x33, 0x3d, 0x70, 0xbd, + 0x6f, 0x89, 0xe3, 0x1a, 0xbd, 0xff, 0x6a, 0xc1, 0x63, 0x4b, 0xae, 0x57, 0x27, 0x41, 0xce, 0x02, + 0x7c, 0x38, 0x6f, 0xe7, 0xa3, 0x31, 0x29, 0xc6, 0x12, 0xeb, 0x3b, 0x86, 0x25, 0x66, 0xff, 0xb1, + 0x05, 0x88, 0x7f, 0xf6, 0xbb, 0xee, 0x63, 0x6f, 0xa6, 0x3f, 0xf6, 0x18, 0x96, 0x85, 0x7d, 0x1d, + 0xc6, 0x96, 0x1a, 0x2e, 0xf1, 0xa2, 0xd5, 0xca, 0x92, 0xef, 0x6d, 0xb9, 0xdb, 0xe8, 0x55, 0x18, + 0x8b, 0xdc, 0x26, 0xf1, 0xdb, 0x51, 0x95, 0xd4, 0x7c, 0x8f, 0xbd, 0x5c, 0xad, 0x4b, 0xfd, 0x8b, + 0xe8, 0xfe, 0xc1, 0xec, 0xd8, 0x86, 0x01, 0xc1, 0x09, 0x4c, 0xfb, 0x77, 0xe9, 0xf8, 0xf9, 0xcd, + 0x96, 0xef, 0x11, 0x2f, 0x5a, 0xf2, 0xbd, 0x3a, 0x97, 0x70, 0xbc, 0x0a, 0x7d, 0x11, 0x1d, 0x0f, + 0x3e, 0x76, 0x17, 0xe5, 0x46, 0xa1, 0xa3, 0x70, 0x78, 0x30, 0x7b, 0x26, 0x5d, 0x83, 0x8d, 0x13, + 0xab, 0x83, 0xbe, 0x03, 0x06, 0xc2, 0xc8, 0x89, 0xda, 0xa1, 0x18, 0xcd, 0xc7, 0xe5, 0x68, 0x56, + 0x59, 0xe9, 0xe1, 0xc1, 0xec, 0xb8, 0xaa, 0xc6, 0x8b, 0xb0, 0xa8, 0x80, 0x9e, 0x81, 0xc1, 0x26, + 0x09, 0x43, 0x67, 0x5b, 0xde, 0x86, 0xe3, 0xa2, 0xee, 0xe0, 0x1a, 0x2f, 0xc6, 0x12, 0x8e, 0x9e, + 0x80, 0x7e, 0x12, 0x04, 0x7e, 0x20, 0xf6, 0xe8, 0xa8, 0x40, 0xec, 0x5f, 0xa6, 0x85, 0x98, 0xc3, + 0xec, 0x7f, 0x65, 0xc1, 0xb8, 0xea, 0x2b, 0x6f, 0xeb, 0x04, 0x5e, 0x21, 0x9f, 0x00, 0xa8, 0xc9, + 0x0f, 0x0c, 0xd9, 0xed, 0x31, 0xfc, 0xc2, 0xc5, 0xcc, 0x8b, 0x3a, 0x35, 0x8c, 0x31, 0x65, 0x55, + 0x14, 0x62, 0x8d, 0x9a, 0xfd, 0xf7, 0x2d, 0x98, 0x4a, 0x7c, 0xd1, 0x75, 0x37, 0x8c, 0xd0, 0x5b, + 0xa9, 0xaf, 0x9a, 0xeb, 0xed, 0xab, 0x68, 0x6d, 0xf6, 0x4d, 0x6a, 0x29, 0xcb, 0x12, 0xed, 0x8b, + 0xae, 0x42, 0xbf, 0x1b, 0x91, 0xa6, 0xfc, 0x98, 0x27, 0x3a, 0x7e, 0x0c, 0xef, 0x55, 0x3c, 0x23, + 0xab, 0xb4, 0x26, 0xe6, 0x04, 0xec, 0x5f, 0x2b, 0x42, 0x89, 0x2f, 0xdb, 0x35, 0xa7, 0x75, 0x02, + 0x73, 0xf1, 0x2c, 0x94, 0xdc, 0x66, 0xb3, 0x1d, 0x39, 0x9b, 0xe2, 0x38, 0x1f, 0xe2, 0x5b, 0x6b, + 0x55, 0x16, 0xe2, 0x18, 0x8e, 0x56, 0xa1, 0x8f, 0x75, 0x85, 0x7f, 0xe5, 0xd3, 0xd9, 0x5f, 0x29, + 0xfa, 0x3e, 0x57, 0x76, 0x22, 0x87, 0x73, 0x52, 0xea, 0x1e, 0xa1, 0x45, 0x98, 0x91, 0x40, 0x0e, + 0xc0, 0xa6, 0xeb, 0x39, 0xc1, 0x3e, 0x2d, 0x9b, 0x2e, 0x32, 0x82, 0xcf, 0x77, 0x26, 0xb8, 0xa8, + 0xf0, 0x39, 0x59, 0xf5, 0x61, 0x31, 0x00, 0x6b, 0x44, 0x67, 0x3e, 0x04, 0x25, 0x85, 0x7c, 0x14, + 0x86, 0x68, 0xe6, 0x23, 0x30, 0x9e, 0x68, 0xab, 0x5b, 0xf5, 0x11, 0x9d, 0x9f, 0xfa, 0x65, 0x76, + 0x64, 0x88, 0x5e, 0x2f, 0x7b, 0x7b, 0xe2, 0xc8, 0xbd, 0x07, 0xa7, 0x1a, 0x19, 0x27, 0x99, 0x98, + 0xd7, 0xde, 0x4f, 0xbe, 0xc7, 0xc4, 0x67, 0x9f, 0xca, 0x82, 0xe2, 0xcc, 0x36, 0x28, 0x8f, 0xe0, + 0xb7, 0xe8, 0x06, 0x71, 0x1a, 0x3a, 0xbb, 0x7d, 0x43, 0x94, 0x61, 0x05, 0xa5, 0xe7, 0xdd, 0x29, + 0xd5, 0xf9, 0x6b, 0x64, 0xbf, 0x4a, 0x1a, 0xa4, 0x16, 0xf9, 0xc1, 0x37, 0xb5, 0xfb, 0xe7, 0xf8, + 0xe8, 0xf3, 0xe3, 0x72, 0x58, 0x10, 0x28, 0x5e, 0x23, 0xfb, 0x7c, 0x2a, 0xf4, 0xaf, 0x2b, 0x76, + 0xfc, 0xba, 0xaf, 0x58, 0x30, 0xaa, 0xbe, 0xee, 0x04, 0xce, 0x85, 0x45, 0xf3, 0x5c, 0x38, 0xd7, + 0x71, 0x81, 0xe7, 0x9c, 0x08, 0x5f, 0x2b, 0xc0, 0x59, 0x85, 0x43, 0xdf, 0x06, 0xfc, 0x8f, 0x58, + 0x55, 0xf3, 0x50, 0xf2, 0x94, 0x94, 0xcc, 0x32, 0xc5, 0x53, 0xb1, 0x8c, 0x2c, 0xc6, 0xa1, 0x2c, + 0x9e, 0x17, 0x8b, 0xb2, 0x46, 0x74, 0xf1, 0xb1, 0x10, 0x15, 0x2f, 0x42, 0xb1, 0xed, 0xd6, 0xc5, + 0x05, 0xf3, 0x01, 0x39, 0xda, 0x37, 0x57, 0xcb, 0x87, 0x07, 0xb3, 0x8f, 0xe7, 0xa9, 0x2e, 0xe8, + 0xcd, 0x16, 0xce, 0xdd, 0x5c, 0x2d, 0x63, 0x5a, 0x19, 0x2d, 0xc0, 0xb8, 0xd4, 0xce, 0xdc, 0xa2, + 0xec, 0x96, 0xef, 0x89, 0x7b, 0x48, 0xc9, 0x80, 0xb1, 0x09, 0xc6, 0x49, 0x7c, 0x54, 0x86, 0x89, + 0xdd, 0xf6, 0x26, 0x69, 0x90, 0x88, 0x7f, 0xf0, 0x35, 0xc2, 0x25, 0xa4, 0xa5, 0xf8, 0x65, 0x76, + 0x2d, 0x01, 0xc7, 0xa9, 0x1a, 0xf6, 0x9f, 0xb3, 0xfb, 0x40, 0x8c, 0x5e, 0x25, 0xf0, 0xe9, 0xc2, + 0xa2, 0xd4, 0xbf, 0x99, 0xcb, 0xb9, 0x97, 0x55, 0x71, 0x8d, 0xec, 0x6f, 0xf8, 0x94, 0x33, 0xcf, + 0x5e, 0x15, 0xc6, 0x9a, 0xef, 0xeb, 0xb8, 0xe6, 0x7f, 0xbe, 0x00, 0xa7, 0xd5, 0x08, 0x18, 0x4c, + 0xe0, 0xb7, 0xfa, 0x18, 0x5c, 0x86, 0xe1, 0x3a, 0xd9, 0x72, 0xda, 0x8d, 0x48, 0x89, 0xeb, 0xfb, + 0xb9, 0xca, 0xa6, 0x1c, 0x17, 0x63, 0x1d, 0xe7, 0x08, 0xc3, 0xf6, 0xdf, 0x86, 0xd9, 0x45, 0x1c, + 0x39, 0x74, 0x8d, 0xab, 0x5d, 0x63, 0xe5, 0xee, 0x9a, 0x27, 0xa0, 0xdf, 0x6d, 0x52, 0xc6, 0xac, + 0x60, 0xf2, 0x5b, 0xab, 0xb4, 0x10, 0x73, 0x18, 0x7a, 0x0a, 0x06, 0x6b, 0x7e, 0xb3, 0xe9, 0x78, + 0x75, 0x76, 0xe5, 0x95, 0x16, 0x87, 0x29, 0xef, 0xb6, 0xc4, 0x8b, 0xb0, 0x84, 0xa1, 0xc7, 0xa0, + 0xcf, 0x09, 0xb6, 0xb9, 0x0c, 0xa3, 0xb4, 0x38, 0x44, 0x5b, 0x5a, 0x08, 0xb6, 0x43, 0xcc, 0x4a, + 0xe9, 0x13, 0xec, 0x8e, 0x1f, 0xec, 0xba, 0xde, 0x76, 0xd9, 0x0d, 0xc4, 0x96, 0x50, 0x77, 0xe1, + 0x6d, 0x05, 0xc1, 0x1a, 0x16, 0x5a, 0x81, 0xfe, 0x96, 0x1f, 0x44, 0xe1, 0xf4, 0x00, 0x1b, 0xee, + 0xc7, 0x73, 0x0e, 0x22, 0xfe, 0xb5, 0x15, 0x3f, 0x88, 0xe2, 0x0f, 0xa0, 0xff, 0x42, 0xcc, 0xab, + 0xa3, 0xeb, 0x30, 0x48, 0xbc, 0xbd, 0x95, 0xc0, 0x6f, 0x4e, 0x4f, 0xe5, 0x53, 0x5a, 0xe6, 0x28, + 0x7c, 0x99, 0xc5, 0x3c, 0xaa, 0x28, 0xc6, 0x92, 0x04, 0xfa, 0x0e, 0x28, 0x12, 0x6f, 0x6f, 0x7a, + 0x90, 0x51, 0x9a, 0xc9, 0xa1, 0x74, 0xcb, 0x09, 0xe2, 0x33, 0x7f, 0xd9, 0xdb, 0xc3, 0xb4, 0x0e, + 0xfa, 0x38, 0x94, 0xe4, 0x81, 0x11, 0x0a, 0xe1, 0x60, 0xe6, 0x82, 0x95, 0xc7, 0x0c, 0x26, 0x6f, + 0xb7, 0xdd, 0x80, 0x34, 0x89, 0x17, 0x85, 0xf1, 0x09, 0x29, 0xa1, 0x21, 0x8e, 0xa9, 0xa1, 0x8f, + 0x4b, 0x89, 0xf4, 0x9a, 0xdf, 0xf6, 0xa2, 0x70, 0xba, 0xc4, 0xba, 0x97, 0xa9, 0x2b, 0xbc, 0x15, + 0xe3, 0x25, 0x45, 0xd6, 0xbc, 0x32, 0x36, 0x48, 0xa1, 0x4f, 0xc2, 0x28, 0xff, 0xcf, 0x35, 0x6e, + 0xe1, 0xf4, 0x69, 0x46, 0xfb, 0x42, 0x3e, 0x6d, 0x8e, 0xb8, 0x78, 0x5a, 0x10, 0x1f, 0xd5, 0x4b, + 0x43, 0x6c, 0x52, 0x43, 0x18, 0x46, 0x1b, 0xee, 0x1e, 0xf1, 0x48, 0x18, 0x56, 0x02, 0x7f, 0x93, + 0x08, 0x01, 0xe2, 0xd9, 0x6c, 0x0d, 0x9d, 0xbf, 0x49, 0x16, 0x27, 0x29, 0xcd, 0xeb, 0x7a, 0x1d, + 0x6c, 0x92, 0x40, 0x37, 0x61, 0x8c, 0xbe, 0xd8, 0xdc, 0x98, 0xe8, 0x70, 0x37, 0xa2, 0xec, 0x5d, + 0x85, 0x8d, 0x4a, 0x38, 0x41, 0x04, 0xdd, 0x80, 0x91, 0x30, 0x72, 0x82, 0xa8, 0xdd, 0xe2, 0x44, + 0xcf, 0x74, 0x23, 0xca, 0x14, 0xbc, 0x55, 0xad, 0x0a, 0x36, 0x08, 0xa0, 0x37, 0xa0, 0xd4, 0x70, + 0xb7, 0x48, 0x6d, 0xbf, 0xd6, 0x20, 0xd3, 0x23, 0x8c, 0x5a, 0xe6, 0xa1, 0x72, 0x5d, 0x22, 0x71, + 0x3e, 0x57, 0xfd, 0xc5, 0x71, 0x75, 0x74, 0x0b, 0xce, 0x44, 0x24, 0x68, 0xba, 0x9e, 0x43, 0x0f, + 0x03, 0xf1, 0xb4, 0x62, 0x8a, 0xd3, 0x51, 0xb6, 0xdb, 0xce, 0x8b, 0xd9, 0x38, 0xb3, 0x91, 0x89, + 0x85, 0x73, 0x6a, 0xa3, 0xbb, 0x30, 0x9d, 0x01, 0xf1, 0x1b, 0x6e, 0x6d, 0x7f, 0xfa, 0x14, 0xa3, + 0xfc, 0x61, 0x41, 0x79, 0x7a, 0x23, 0x07, 0xef, 0xb0, 0x03, 0x0c, 0xe7, 0x52, 0x47, 0x37, 0x60, + 0x9c, 0x9d, 0x40, 0x95, 0x76, 0xa3, 0x21, 0x1a, 0x1c, 0x63, 0x0d, 0x3e, 0x25, 0xef, 0xe3, 0x55, + 0x13, 0x7c, 0x78, 0x30, 0x0b, 0xf1, 0x3f, 0x9c, 0xac, 0x8d, 0x36, 0x99, 0x8e, 0xae, 0x1d, 0xb8, + 0xd1, 0x3e, 0x3d, 0x37, 0xc8, 0xdd, 0x68, 0x7a, 0xbc, 0xa3, 0xbc, 0x42, 0x47, 0x55, 0x8a, 0x3c, + 0xbd, 0x10, 0x27, 0x09, 0xd2, 0x23, 0x35, 0x8c, 0xea, 0xae, 0x37, 0x3d, 0xc1, 0xdf, 0x25, 0xf2, + 0x44, 0xaa, 0xd2, 0x42, 0xcc, 0x61, 0x4c, 0x3f, 0x47, 0x7f, 0xdc, 0xa0, 0x37, 0xd7, 0x24, 0x43, + 0x8c, 0xf5, 0x73, 0x12, 0x80, 0x63, 0x1c, 0xca, 0x4c, 0x46, 0xd1, 0xfe, 0x34, 0x62, 0xa8, 0xea, + 0x60, 0xd9, 0xd8, 0xf8, 0x38, 0xa6, 0xe5, 0xf6, 0x26, 0x8c, 0xa9, 0x83, 0x90, 0x8d, 0x09, 0x9a, + 0x85, 0x7e, 0xc6, 0x3e, 0x09, 0xe9, 0x5a, 0x89, 0x76, 0x81, 0xb1, 0x56, 0x98, 0x97, 0xb3, 0x2e, + 0xb8, 0xf7, 0xc8, 0xe2, 0x7e, 0x44, 0xf8, 0x9b, 0xbe, 0xa8, 0x75, 0x41, 0x02, 0x70, 0x8c, 0x63, + 0xff, 0x6f, 0xce, 0x86, 0xc6, 0xa7, 0x6d, 0x0f, 0xf7, 0xcb, 0x73, 0x30, 0xb4, 0xe3, 0x87, 0x11, + 0xc5, 0x66, 0x6d, 0xf4, 0xc7, 0x8c, 0xe7, 0x55, 0x51, 0x8e, 0x15, 0x06, 0x7a, 0x0d, 0x46, 0x6b, + 0x7a, 0x03, 0xe2, 0x72, 0x54, 0xc7, 0x88, 0xd1, 0x3a, 0x36, 0x71, 0xd1, 0x2b, 0x30, 0xc4, 0x6c, + 0x4e, 0x6a, 0x7e, 0x43, 0x70, 0x6d, 0xf2, 0x86, 0x1f, 0xaa, 0x88, 0xf2, 0x43, 0xed, 0x37, 0x56, + 0xd8, 0xe8, 0x22, 0x0c, 0xd0, 0x2e, 0xac, 0x56, 0xc4, 0xb5, 0xa4, 0x04, 0x45, 0x57, 0x59, 0x29, + 0x16, 0x50, 0xfb, 0xff, 0x2f, 0x68, 0xa3, 0x4c, 0xdf, 0xc3, 0x04, 0x55, 0x60, 0xf0, 0x8e, 0xe3, + 0x46, 0xae, 0xb7, 0x2d, 0xf8, 0x8f, 0x67, 0x3a, 0xde, 0x51, 0xac, 0xd2, 0x6d, 0x5e, 0x81, 0xdf, + 0xa2, 0xe2, 0x0f, 0x96, 0x64, 0x28, 0xc5, 0xa0, 0xed, 0x79, 0x94, 0x62, 0xa1, 0x57, 0x8a, 0x98, + 0x57, 0xe0, 0x14, 0xc5, 0x1f, 0x2c, 0xc9, 0xa0, 0xb7, 0x00, 0xe4, 0x0e, 0x23, 0x75, 0x61, 0xeb, + 0xf1, 0x5c, 0x77, 0xa2, 0x1b, 0xaa, 0xce, 0xe2, 0x18, 0xbd, 0xa3, 0xe3, 0xff, 0x58, 0xa3, 0x67, + 0x47, 0x8c, 0x4f, 0x4b, 0x77, 0x06, 0x7d, 0x17, 0x5d, 0xe2, 0x4e, 0x10, 0x91, 0xfa, 0x42, 0x24, + 0x06, 0xe7, 0xfd, 0xbd, 0x3d, 0x52, 0x36, 0xdc, 0x26, 0xd1, 0xb7, 0x83, 0x20, 0x82, 0x63, 0x7a, + 0xf6, 0x2f, 0x16, 0x61, 0x3a, 0xaf, 0xbb, 0x74, 0xd1, 0x91, 0xbb, 0x6e, 0xb4, 0x44, 0xd9, 0x2b, + 0xcb, 0x5c, 0x74, 0xcb, 0xa2, 0x1c, 0x2b, 0x0c, 0x3a, 0xfb, 0xa1, 0xbb, 0x2d, 0xdf, 0x98, 0xfd, + 0xf1, 0xec, 0x57, 0x59, 0x29, 0x16, 0x50, 0x8a, 0x17, 0x10, 0x27, 0x14, 0xc6, 0x44, 0xda, 0x2a, + 0xc1, 0xac, 0x14, 0x0b, 0xa8, 0x2e, 0xed, 0xea, 0xeb, 0x22, 0xed, 0x32, 0x86, 0xa8, 0xff, 0x78, + 0x87, 0x08, 0x7d, 0x0a, 0x60, 0xcb, 0xf5, 0xdc, 0x70, 0x87, 0x51, 0x1f, 0x38, 0x32, 0x75, 0xc5, + 0x9c, 0xad, 0x28, 0x2a, 0x58, 0xa3, 0x88, 0x5e, 0x86, 0x61, 0xb5, 0x01, 0x57, 0xcb, 0x4c, 0xb3, + 0xaa, 0x59, 0xaa, 0xc4, 0xa7, 0x51, 0x19, 0xeb, 0x78, 0xf6, 0x67, 0x92, 0xeb, 0x45, 0xec, 0x00, + 0x6d, 0x7c, 0xad, 0x5e, 0xc7, 0xb7, 0xd0, 0x79, 0x7c, 0xed, 0x6f, 0x14, 0x61, 0xdc, 0x68, 0xac, + 0x1d, 0xf6, 0x70, 0x66, 0x5d, 0xa1, 0x07, 0xb8, 0x13, 0x11, 0xb1, 0xff, 0xec, 0xee, 0x5b, 0x45, + 0x3f, 0xe4, 0xe9, 0x0e, 0xe0, 0xf5, 0xd1, 0xa7, 0xa0, 0xd4, 0x70, 0x42, 0x26, 0x39, 0x23, 0x62, + 0xdf, 0xf5, 0x42, 0x2c, 0x7e, 0x98, 0x38, 0x61, 0xa4, 0xdd, 0x9a, 0x9c, 0x76, 0x4c, 0x92, 0xde, + 0x34, 0x94, 0x3f, 0x91, 0xd6, 0x6a, 0xaa, 0x13, 0x94, 0x89, 0xd9, 0xc7, 0x1c, 0x86, 0x5e, 0x81, + 0x91, 0x80, 0xb0, 0x55, 0xb1, 0x44, 0xb9, 0x39, 0xb6, 0xcc, 0xfa, 0x63, 0xb6, 0x0f, 0x6b, 0x30, + 0x6c, 0x60, 0xc6, 0x6f, 0x83, 0x81, 0x0e, 0x6f, 0x83, 0x67, 0x60, 0x90, 0xfd, 0x50, 0x2b, 0x40, + 0xcd, 0xc6, 0x2a, 0x2f, 0xc6, 0x12, 0x9e, 0x5c, 0x30, 0x43, 0xbd, 0x2d, 0x18, 0xfa, 0xfa, 0x10, + 0x8b, 0x9a, 0x69, 0xb5, 0x87, 0xf8, 0x29, 0x27, 0x96, 0x3c, 0x96, 0x30, 0xfb, 0xfd, 0x30, 0x56, + 0x76, 0x48, 0xd3, 0xf7, 0x96, 0xbd, 0x7a, 0xcb, 0x77, 0xbd, 0x08, 0x4d, 0x43, 0x1f, 0xbb, 0x44, + 0xf8, 0x11, 0xd0, 0x47, 0x1b, 0xc2, 0xac, 0xc4, 0xde, 0x86, 0xd3, 0x65, 0xff, 0x8e, 0x77, 0xc7, + 0x09, 0xea, 0x0b, 0x95, 0x55, 0xed, 0x7d, 0xbd, 0x2e, 0xdf, 0x77, 0xdc, 0x48, 0x2c, 0xf3, 0xe8, + 0xd5, 0x6a, 0x72, 0xb6, 0x76, 0xc5, 0x6d, 0x90, 0x1c, 0x29, 0xc8, 0x5f, 0x2a, 0x18, 0x2d, 0xc5, + 0xf8, 0x4a, 0xab, 0x65, 0xe5, 0x6a, 0xb5, 0xde, 0x84, 0xa1, 0x2d, 0x97, 0x34, 0xea, 0x98, 0x6c, + 0x89, 0x95, 0xf8, 0x74, 0xbe, 0xdd, 0xcb, 0x0a, 0xc5, 0x94, 0x52, 0x2f, 0xfe, 0x3a, 0x5c, 0x11, + 0x95, 0xb1, 0x22, 0x83, 0x76, 0x61, 0x42, 0x3e, 0x18, 0x24, 0x54, 0xac, 0xcb, 0x67, 0x3a, 0xbd, + 0x42, 0x4c, 0xe2, 0xa7, 0xee, 0x1f, 0xcc, 0x4e, 0xe0, 0x04, 0x19, 0x9c, 0x22, 0x4c, 0x9f, 0x83, + 0x4d, 0x7a, 0x02, 0xf7, 0xb1, 0xe1, 0x67, 0xcf, 0x41, 0xf6, 0xb2, 0x65, 0xa5, 0xf6, 0x4f, 0x58, + 0xf0, 0x48, 0x6a, 0x64, 0xc4, 0x0b, 0xff, 0x98, 0x67, 0x21, 0xf9, 0xe2, 0x2e, 0x74, 0x7f, 0x71, + 0xdb, 0x7f, 0xc3, 0x82, 0x53, 0xcb, 0xcd, 0x56, 0xb4, 0x5f, 0x76, 0x4d, 0x15, 0xd4, 0x87, 0x60, + 0xa0, 0x49, 0xea, 0x6e, 0xbb, 0x29, 0x66, 0x6e, 0x56, 0x9e, 0x52, 0x6b, 0xac, 0xf4, 0xf0, 0x60, + 0x76, 0xb4, 0x1a, 0xf9, 0x81, 0xb3, 0x4d, 0x78, 0x01, 0x16, 0xe8, 0xec, 0xac, 0x77, 0xef, 0x91, + 0xeb, 0x6e, 0xd3, 0x95, 0x76, 0x4c, 0x1d, 0x65, 0x76, 0x73, 0x72, 0x40, 0xe7, 0xde, 0x6c, 0x3b, + 0x5e, 0xe4, 0x46, 0xfb, 0x42, 0x7b, 0x24, 0x89, 0xe0, 0x98, 0x9e, 0xfd, 0x75, 0x0b, 0xc6, 0xe5, + 0xba, 0x5f, 0xa8, 0xd7, 0x03, 0x12, 0x86, 0x68, 0x06, 0x0a, 0x6e, 0x4b, 0xf4, 0x12, 0x44, 0x2f, + 0x0b, 0xab, 0x15, 0x5c, 0x70, 0x5b, 0x92, 0x2d, 0x63, 0x07, 0x61, 0xd1, 0x54, 0xa4, 0x5d, 0x15, + 0xe5, 0x58, 0x61, 0xa0, 0x4b, 0x30, 0xe4, 0xf9, 0x75, 0x6e, 0x4b, 0xc6, 0xaf, 0x34, 0xb6, 0xc0, + 0xd6, 0x45, 0x19, 0x56, 0x50, 0x54, 0x81, 0x12, 0x37, 0xb3, 0x8a, 0x17, 0x6d, 0x4f, 0xc6, 0x5a, + 0xec, 0xcb, 0x36, 0x64, 0x4d, 0x1c, 0x13, 0xb1, 0x7f, 0xd5, 0x82, 0x11, 0xf9, 0x65, 0x3d, 0xf2, + 0x9c, 0x74, 0x6b, 0xc5, 0xfc, 0x66, 0xbc, 0xb5, 0x28, 0xcf, 0xc8, 0x20, 0x06, 0xab, 0x58, 0x3c, + 0x12, 0xab, 0x78, 0x19, 0x86, 0x9d, 0x56, 0xab, 0x62, 0xf2, 0x99, 0x6c, 0x29, 0x2d, 0xc4, 0xc5, + 0x58, 0xc7, 0xb1, 0x7f, 0xbc, 0x00, 0x63, 0xf2, 0x0b, 0xaa, 0xed, 0xcd, 0x90, 0x44, 0x68, 0x03, + 0x4a, 0x0e, 0x9f, 0x25, 0x22, 0x17, 0xf9, 0x13, 0xd9, 0x72, 0x04, 0x63, 0x4a, 0xe3, 0x0b, 0x7f, + 0x41, 0xd6, 0xc6, 0x31, 0x21, 0xd4, 0x80, 0x49, 0xcf, 0x8f, 0xd8, 0xe1, 0xaf, 0xe0, 0x9d, 0x54, + 0x3b, 0x49, 0xea, 0x67, 0x05, 0xf5, 0xc9, 0xf5, 0x24, 0x15, 0x9c, 0x26, 0x8c, 0x96, 0xa5, 0x6c, + 0xa6, 0x98, 0x2f, 0x0c, 0xd0, 0x27, 0x2e, 0x5b, 0x34, 0x63, 0xff, 0x8a, 0x05, 0x25, 0x89, 0x76, + 0x12, 0x5a, 0xbc, 0x35, 0x18, 0x0c, 0xd9, 0x24, 0xc8, 0xa1, 0xb1, 0x3b, 0x75, 0x9c, 0xcf, 0x57, + 0x7c, 0xa7, 0xf1, 0xff, 0x21, 0x96, 0x34, 0x98, 0x68, 0x5e, 0x75, 0xff, 0x5d, 0x22, 0x9a, 0x57, + 0xfd, 0xc9, 0xb9, 0x94, 0xfe, 0x90, 0xf5, 0x59, 0x93, 0x75, 0x51, 0xd6, 0xab, 0x15, 0x90, 0x2d, + 0xf7, 0x6e, 0x92, 0xf5, 0xaa, 0xb0, 0x52, 0x2c, 0xa0, 0xe8, 0x2d, 0x18, 0xa9, 0x49, 0x99, 0x6c, + 0xbc, 0xc3, 0x2f, 0x76, 0xd4, 0x0f, 0x28, 0x55, 0x12, 0x97, 0x85, 0x2c, 0x69, 0xf5, 0xb1, 0x41, + 0xcd, 0x34, 0x23, 0x28, 0x76, 0x33, 0x23, 0x88, 0xe9, 0xe6, 0x2b, 0xd5, 0x7f, 0xd2, 0x82, 0x01, + 0x2e, 0x8b, 0xeb, 0x4d, 0x14, 0xaa, 0x69, 0xd6, 0xe2, 0xb1, 0xbb, 0x45, 0x0b, 0x85, 0xa6, 0x0c, + 0xad, 0x41, 0x89, 0xfd, 0x60, 0xb2, 0xc4, 0x62, 0xbe, 0x95, 0x3f, 0x6f, 0x55, 0xef, 0xe0, 0x2d, + 0x59, 0x0d, 0xc7, 0x14, 0xec, 0x1f, 0x2b, 0xd2, 0xd3, 0x2d, 0x46, 0x35, 0x2e, 0x7d, 0xeb, 0xe1, + 0x5d, 0xfa, 0x85, 0x87, 0x75, 0xe9, 0x6f, 0xc3, 0x78, 0x4d, 0xd3, 0xc3, 0xc5, 0x33, 0x79, 0xa9, + 0xe3, 0x22, 0xd1, 0x54, 0x76, 0x5c, 0xca, 0xb2, 0x64, 0x12, 0xc1, 0x49, 0xaa, 0xe8, 0xbb, 0x60, + 0x84, 0xcf, 0xb3, 0x68, 0x85, 0x5b, 0x62, 0x3c, 0x95, 0xbf, 0x5e, 0xf4, 0x26, 0xb8, 0x54, 0x4e, + 0xab, 0x8e, 0x0d, 0x62, 0xf6, 0x9f, 0x58, 0x80, 0x96, 0x5b, 0x3b, 0xa4, 0x49, 0x02, 0xa7, 0x11, + 0x8b, 0xd3, 0x7f, 0xd8, 0x82, 0x69, 0x92, 0x2a, 0x5e, 0xf2, 0x9b, 0x4d, 0xf1, 0x68, 0xc9, 0x79, + 0x57, 0x2f, 0xe7, 0xd4, 0x51, 0x6e, 0x10, 0xd3, 0x79, 0x18, 0x38, 0xb7, 0x3d, 0xb4, 0x06, 0x53, + 0xfc, 0x96, 0x54, 0x00, 0xcd, 0xd6, 0xfb, 0x51, 0x41, 0x78, 0x6a, 0x23, 0x8d, 0x82, 0xb3, 0xea, + 0xd9, 0xdf, 0x37, 0x02, 0xb9, 0xbd, 0x78, 0x4f, 0x8f, 0xf0, 0x9e, 0x1e, 0xe1, 0x3d, 0x3d, 0xc2, + 0x7b, 0x7a, 0x84, 0xf7, 0xf4, 0x08, 0xdf, 0xf6, 0x7a, 0x84, 0xbf, 0x60, 0xc1, 0x69, 0x75, 0x0d, + 0x18, 0x0f, 0xdf, 0xcf, 0xc2, 0x14, 0xdf, 0x6e, 0x4b, 0x0d, 0xc7, 0x6d, 0x6e, 0x90, 0x66, 0xab, + 0xe1, 0x44, 0x52, 0xeb, 0x7e, 0x39, 0x73, 0xe5, 0x26, 0x2c, 0x56, 0x8d, 0x8a, 0xdc, 0xf4, 0x3f, + 0x03, 0x80, 0xb3, 0x9a, 0xb1, 0x7f, 0x71, 0x08, 0xfa, 0x97, 0xf7, 0x88, 0x17, 0x9d, 0xc0, 0x13, + 0xa1, 0x06, 0x63, 0xae, 0xb7, 0xe7, 0x37, 0xf6, 0x48, 0x9d, 0xc3, 0x8f, 0xf2, 0x92, 0x3d, 0x23, + 0x48, 0x8f, 0xad, 0x1a, 0x24, 0x70, 0x82, 0xe4, 0xc3, 0x90, 0x26, 0x5f, 0x81, 0x01, 0x7e, 0x88, + 0x0b, 0x51, 0x72, 0xe6, 0x99, 0xcd, 0x06, 0x51, 0x5c, 0x4d, 0xb1, 0xa4, 0x9b, 0x5f, 0x12, 0xa2, + 0x3a, 0xfa, 0x0c, 0x8c, 0x6d, 0xb9, 0x41, 0x18, 0x6d, 0xb8, 0x4d, 0x12, 0x46, 0x4e, 0xb3, 0xf5, + 0x00, 0xd2, 0x63, 0x35, 0x0e, 0x2b, 0x06, 0x25, 0x9c, 0xa0, 0x8c, 0xb6, 0x61, 0xb4, 0xe1, 0xe8, + 0x4d, 0x0d, 0x1e, 0xb9, 0x29, 0x75, 0x3b, 0x5c, 0xd7, 0x09, 0x61, 0x93, 0x2e, 0xdd, 0x4e, 0x35, + 0x26, 0x00, 0x1d, 0x62, 0x62, 0x01, 0xb5, 0x9d, 0xb8, 0xe4, 0x93, 0xc3, 0x28, 0xa3, 0xc3, 0x0c, + 0x64, 0x4b, 0x26, 0xa3, 0xa3, 0x99, 0xc1, 0x7e, 0x1a, 0x4a, 0x84, 0x0e, 0x21, 0x25, 0x2c, 0x2e, + 0x98, 0xf9, 0xde, 0xfa, 0xba, 0xe6, 0xd6, 0x02, 0xdf, 0x94, 0xdb, 0x2f, 0x4b, 0x4a, 0x38, 0x26, + 0x8a, 0x96, 0x60, 0x20, 0x24, 0x81, 0x4b, 0x42, 0x71, 0xd5, 0x74, 0x98, 0x46, 0x86, 0xc6, 0x7d, + 0x4b, 0xf8, 0x6f, 0x2c, 0xaa, 0xd2, 0xe5, 0xe5, 0x30, 0x91, 0x26, 0xbb, 0x0c, 0xb4, 0xe5, 0xb5, + 0xc0, 0x4a, 0xb1, 0x80, 0xa2, 0x37, 0x60, 0x30, 0x20, 0x0d, 0xa6, 0x18, 0x1a, 0xed, 0x7d, 0x91, + 0x73, 0x3d, 0x13, 0xaf, 0x87, 0x25, 0x01, 0x74, 0x0d, 0x50, 0x40, 0x28, 0xa3, 0xe4, 0x7a, 0xdb, + 0xca, 0x6c, 0x54, 0x1c, 0xb4, 0x8a, 0x21, 0xc5, 0x31, 0x86, 0x74, 0x2b, 0xc2, 0x19, 0xd5, 0xd0, + 0x15, 0x98, 0x54, 0xa5, 0xab, 0x5e, 0x18, 0x39, 0xf4, 0x80, 0x1b, 0x67, 0xb4, 0x94, 0x9c, 0x02, + 0x27, 0x11, 0x70, 0xba, 0x8e, 0xfd, 0x25, 0x0b, 0xf8, 0x38, 0x9f, 0xc0, 0xeb, 0xfc, 0x75, 0xf3, + 0x75, 0x7e, 0x36, 0x77, 0xe6, 0x72, 0x5e, 0xe6, 0x5f, 0xb2, 0x60, 0x58, 0x9b, 0xd9, 0x78, 0xcd, + 0x5a, 0x1d, 0xd6, 0x6c, 0x1b, 0x26, 0xe8, 0x4a, 0xbf, 0xb1, 0x19, 0x92, 0x60, 0x8f, 0xd4, 0xd9, + 0xc2, 0x2c, 0x3c, 0xd8, 0xc2, 0x54, 0x26, 0x6a, 0xd7, 0x13, 0x04, 0x71, 0xaa, 0x09, 0xfb, 0xd3, + 0xb2, 0xab, 0xca, 0xa2, 0xaf, 0xa6, 0xe6, 0x3c, 0x61, 0xd1, 0xa7, 0x66, 0x15, 0xc7, 0x38, 0x74, + 0xab, 0xed, 0xf8, 0x61, 0x94, 0xb4, 0xe8, 0xbb, 0xea, 0x87, 0x11, 0x66, 0x10, 0xfb, 0x45, 0x80, + 0xe5, 0xbb, 0xa4, 0xc6, 0x57, 0xac, 0xfe, 0x78, 0xb0, 0xf2, 0x1f, 0x0f, 0xf6, 0x6f, 0x59, 0x30, + 0xb6, 0xb2, 0x64, 0xdc, 0x5c, 0x73, 0x00, 0xfc, 0xc5, 0x73, 0xfb, 0xf6, 0xba, 0x54, 0x87, 0x73, + 0x8d, 0xa6, 0x2a, 0xc5, 0x1a, 0x06, 0x3a, 0x0b, 0xc5, 0x46, 0xdb, 0x13, 0xe2, 0xc3, 0x41, 0x7a, + 0x3d, 0x5e, 0x6f, 0x7b, 0x98, 0x96, 0x69, 0x2e, 0x05, 0xc5, 0x9e, 0x5d, 0x0a, 0xba, 0x86, 0x12, + 0x40, 0xb3, 0xd0, 0x7f, 0xe7, 0x8e, 0x5b, 0xe7, 0x0e, 0x9b, 0x42, 0x55, 0x7f, 0xfb, 0xf6, 0x6a, + 0x39, 0xc4, 0xbc, 0xdc, 0xfe, 0x42, 0x11, 0x66, 0x56, 0x1a, 0xe4, 0xee, 0x3b, 0x74, 0x5a, 0xed, + 0xd5, 0x21, 0xe2, 0x68, 0x82, 0x98, 0xa3, 0x3a, 0xbd, 0x74, 0x1f, 0x8f, 0x2d, 0x18, 0xe4, 0x06, + 0x6d, 0xd2, 0x85, 0xf5, 0xb5, 0xac, 0xd6, 0xf3, 0x07, 0x64, 0x8e, 0x1b, 0xc6, 0x09, 0x8f, 0x38, + 0x75, 0x61, 0x8a, 0x52, 0x2c, 0x89, 0xcf, 0xbc, 0x0a, 0x23, 0x3a, 0xe6, 0x91, 0xdc, 0xcf, 0xfe, + 0x9f, 0x22, 0x4c, 0xd0, 0x1e, 0x3c, 0xd4, 0x89, 0xb8, 0x99, 0x9e, 0x88, 0xe3, 0x76, 0x41, 0xea, + 0x3e, 0x1b, 0x6f, 0x25, 0x67, 0xe3, 0x72, 0xde, 0x6c, 0x9c, 0xf4, 0x1c, 0x7c, 0xaf, 0x05, 0x53, + 0x2b, 0x0d, 0xbf, 0xb6, 0x9b, 0x70, 0x13, 0x7a, 0x19, 0x86, 0xe9, 0x71, 0x1c, 0x1a, 0x1e, 0xf3, + 0x46, 0x0c, 0x05, 0x01, 0xc2, 0x3a, 0x9e, 0x56, 0xed, 0xe6, 0xcd, 0xd5, 0x72, 0x56, 0xe8, 0x05, + 0x01, 0xc2, 0x3a, 0x9e, 0xfd, 0x1b, 0x16, 0x9c, 0xbb, 0xb2, 0xb4, 0x1c, 0x2f, 0xc5, 0x54, 0xf4, + 0x87, 0x8b, 0x30, 0xd0, 0xaa, 0x6b, 0x5d, 0x89, 0xc5, 0xab, 0x65, 0xd6, 0x0b, 0x01, 0x7d, 0xb7, + 0x44, 0x36, 0xb9, 0x09, 0x70, 0x05, 0x57, 0x96, 0xc4, 0xb9, 0x2b, 0xb5, 0x29, 0x56, 0xae, 0x36, + 0xe5, 0x29, 0x18, 0xa4, 0xf7, 0x82, 0x5b, 0x93, 0xfd, 0xe6, 0x0a, 0x5a, 0x5e, 0x84, 0x25, 0xcc, + 0xfe, 0x39, 0x0b, 0xa6, 0xae, 0xb8, 0x11, 0xbd, 0xb4, 0x93, 0xe1, 0x0d, 0xe8, 0xad, 0x1d, 0xba, + 0x91, 0x1f, 0xec, 0x27, 0xc3, 0x1b, 0x60, 0x05, 0xc1, 0x1a, 0x16, 0xff, 0xa0, 0x3d, 0x97, 0x59, + 0x68, 0x17, 0x4c, 0xfd, 0x15, 0x16, 0xe5, 0x58, 0x61, 0xd0, 0xf1, 0xaa, 0xbb, 0x01, 0x13, 0xfd, + 0xed, 0x8b, 0x83, 0x5b, 0x8d, 0x57, 0x59, 0x02, 0x70, 0x8c, 0x63, 0xff, 0x91, 0x05, 0xb3, 0x57, + 0x1a, 0xed, 0x30, 0x22, 0xc1, 0x56, 0x98, 0x73, 0xe8, 0xbe, 0x08, 0x25, 0x22, 0x05, 0xed, 0xa2, + 0xd7, 0x8a, 0x11, 0x55, 0x12, 0x78, 0x1e, 0x65, 0x41, 0xe1, 0xf5, 0xe0, 0xcb, 0x78, 0x34, 0x67, + 0xb4, 0x15, 0x40, 0x44, 0x6f, 0x4b, 0x0f, 0x3b, 0xc1, 0xfc, 0xd7, 0x97, 0x53, 0x50, 0x9c, 0x51, + 0xc3, 0xfe, 0x09, 0x0b, 0x4e, 0xab, 0x0f, 0x7e, 0xd7, 0x7d, 0xa6, 0xfd, 0xd5, 0x02, 0x8c, 0x5e, + 0xdd, 0xd8, 0xa8, 0x5c, 0x21, 0x91, 0xb6, 0x2a, 0x3b, 0xab, 0xcf, 0xb1, 0xa6, 0x05, 0xec, 0xf4, + 0x46, 0x6c, 0x47, 0x6e, 0x63, 0x8e, 0x47, 0x2f, 0x9a, 0x5b, 0xf5, 0xa2, 0x1b, 0x41, 0x35, 0x0a, + 0x5c, 0x6f, 0x3b, 0x73, 0xa5, 0x4b, 0x9e, 0xa5, 0x98, 0xc7, 0xb3, 0xa0, 0x17, 0x61, 0x80, 0x85, + 0x4f, 0x92, 0x93, 0xf0, 0xa8, 0x7a, 0x62, 0xb1, 0xd2, 0xc3, 0x83, 0xd9, 0xd2, 0x4d, 0xbc, 0xca, + 0xff, 0x60, 0x81, 0x8a, 0x6e, 0xc2, 0xf0, 0x4e, 0x14, 0xb5, 0xae, 0x12, 0xa7, 0x4e, 0x02, 0x79, + 0xca, 0x9e, 0xcf, 0x3a, 0x65, 0xe9, 0x20, 0x70, 0xb4, 0xf8, 0x60, 0x8a, 0xcb, 0x42, 0xac, 0xd3, + 0xb1, 0xab, 0x00, 0x31, 0xec, 0x98, 0x14, 0x20, 0xf6, 0x06, 0x94, 0xe8, 0xe7, 0x2e, 0x34, 0x5c, + 0xa7, 0xb3, 0x8a, 0xf9, 0x59, 0x28, 0x49, 0x05, 0x72, 0x28, 0x7c, 0xad, 0xd9, 0x8d, 0x24, 0xf5, + 0xcb, 0x21, 0x8e, 0xe1, 0xf6, 0x16, 0x9c, 0x62, 0xe6, 0x80, 0x4e, 0xb4, 0x63, 0xac, 0xbe, 0xee, + 0xd3, 0xfc, 0x9c, 0x78, 0xb1, 0xf1, 0x3e, 0x4f, 0x6b, 0xee, 0x8c, 0x23, 0x92, 0x62, 0xfc, 0x7a, + 0xb3, 0xbf, 0xd1, 0x07, 0x8f, 0xae, 0x56, 0xf3, 0xc3, 0x7f, 0xbc, 0x02, 0x23, 0x9c, 0x11, 0xa4, + 0x93, 0xee, 0x34, 0x44, 0xbb, 0x4a, 0xb6, 0xb9, 0xa1, 0xc1, 0xb0, 0x81, 0x89, 0xce, 0x41, 0xd1, + 0x7d, 0xdb, 0x4b, 0x3a, 0xfb, 0xac, 0xbe, 0xb9, 0x8e, 0x69, 0x39, 0x05, 0x53, 0x9e, 0x92, 0x1f, + 0xd6, 0x0a, 0xac, 0xf8, 0xca, 0xd7, 0x61, 0xcc, 0x0d, 0x6b, 0xa1, 0xbb, 0xea, 0xd1, 0x1d, 0xa8, + 0xed, 0x61, 0x25, 0x4d, 0xa0, 0x9d, 0x56, 0x50, 0x9c, 0xc0, 0xd6, 0x6e, 0x8e, 0xfe, 0x9e, 0xf9, + 0xd2, 0xae, 0xce, 0xc7, 0xf4, 0x60, 0x6f, 0xb1, 0xaf, 0x0b, 0x99, 0x90, 0x5a, 0x1c, 0xec, 0xfc, + 0x83, 0x43, 0x2c, 0x61, 0xf4, 0xa9, 0x56, 0xdb, 0x71, 0x5a, 0x0b, 0xed, 0x68, 0xa7, 0xec, 0x86, + 0x35, 0x7f, 0x8f, 0x04, 0xfb, 0xec, 0x95, 0x3d, 0x14, 0x3f, 0xd5, 0x14, 0x60, 0xe9, 0xea, 0x42, + 0x85, 0x62, 0xe2, 0x74, 0x1d, 0xb4, 0x00, 0xe3, 0xb2, 0xb0, 0x4a, 0x42, 0x76, 0xb8, 0x0f, 0x33, + 0x32, 0xca, 0xfd, 0x46, 0x14, 0x2b, 0x22, 0x49, 0x7c, 0x93, 0x75, 0x85, 0xe3, 0x60, 0x5d, 0x3f, + 0x04, 0xa3, 0xae, 0xe7, 0x46, 0xae, 0x13, 0xf9, 0x5c, 0xc3, 0xc2, 0x1f, 0xd4, 0x4c, 0x74, 0xbc, + 0xaa, 0x03, 0xb0, 0x89, 0x67, 0xff, 0xfb, 0x3e, 0x98, 0x64, 0xd3, 0xf6, 0xde, 0x0a, 0xfb, 0x76, + 0x5a, 0x61, 0x37, 0xd3, 0x2b, 0xec, 0x38, 0x78, 0xf2, 0x07, 0x5e, 0x66, 0x9f, 0x81, 0x92, 0xf2, + 0x38, 0x92, 0x2e, 0x87, 0x56, 0x8e, 0xcb, 0x61, 0xf7, 0x7b, 0x59, 0x1a, 0x6d, 0x15, 0x33, 0x8d, + 0xb6, 0xbe, 0x6c, 0x41, 0xac, 0x32, 0x40, 0x6f, 0x42, 0xa9, 0xe5, 0x33, 0x5b, 0xc4, 0x40, 0x1a, + 0xf8, 0x3e, 0xd9, 0x51, 0xe7, 0xc0, 0x23, 0x20, 0x05, 0x7c, 0x14, 0x2a, 0xb2, 0x2a, 0x8e, 0xa9, + 0xa0, 0x6b, 0x30, 0xd8, 0x0a, 0x48, 0x35, 0x62, 0xe1, 0x39, 0x7a, 0x27, 0xc8, 0x57, 0x0d, 0xaf, + 0x88, 0x25, 0x05, 0xfb, 0x3f, 0x5a, 0x30, 0x91, 0x44, 0x45, 0x1f, 0x86, 0x3e, 0x72, 0x97, 0xd4, + 0x44, 0x7f, 0x33, 0x2f, 0xd9, 0x58, 0xe8, 0xc0, 0x07, 0x80, 0xfe, 0xc7, 0xac, 0x16, 0xba, 0x0a, + 0x83, 0xf4, 0x86, 0xbd, 0xa2, 0x42, 0x51, 0x3d, 0x9e, 0x77, 0x4b, 0x2b, 0x56, 0x85, 0x77, 0x4e, + 0x14, 0x61, 0x59, 0x9d, 0x59, 0x4a, 0xd5, 0x5a, 0x55, 0xfa, 0x78, 0x89, 0x3a, 0xbd, 0xb1, 0x37, + 0x96, 0x2a, 0x1c, 0x49, 0x50, 0xe3, 0x96, 0x52, 0xb2, 0x10, 0xc7, 0x44, 0xec, 0x9f, 0xb7, 0x00, + 0xb8, 0x61, 0x98, 0xe3, 0x6d, 0x93, 0x13, 0x90, 0x93, 0x97, 0xa1, 0x2f, 0x6c, 0x91, 0x5a, 0x27, + 0x33, 0xd9, 0xb8, 0x3f, 0xd5, 0x16, 0xa9, 0xc5, 0x2b, 0x8e, 0xfe, 0xc3, 0xac, 0xb6, 0xfd, 0xfd, + 0x00, 0x63, 0x31, 0xda, 0x6a, 0x44, 0x9a, 0xe8, 0x79, 0x23, 0x4c, 0xc1, 0xd9, 0x44, 0x98, 0x82, + 0x12, 0xc3, 0xd6, 0x44, 0xb2, 0x9f, 0x81, 0x62, 0xd3, 0xb9, 0x2b, 0x64, 0x6e, 0xcf, 0x76, 0xee, + 0x06, 0xa5, 0x3f, 0xb7, 0xe6, 0xdc, 0xe5, 0xcf, 0xd2, 0x67, 0xe5, 0x0e, 0x59, 0x73, 0xee, 0x1e, + 0x72, 0x63, 0x58, 0x76, 0x4a, 0x5f, 0x77, 0xc3, 0xe8, 0x73, 0xff, 0x2e, 0xfe, 0xcf, 0xf6, 0x1d, + 0x6d, 0x84, 0xb5, 0xe5, 0x7a, 0xc2, 0xe6, 0xa9, 0xa7, 0xb6, 0x5c, 0x2f, 0xd9, 0x96, 0xeb, 0xf5, + 0xd0, 0x96, 0xeb, 0xa1, 0x7b, 0x30, 0x28, 0x4c, 0x12, 0x45, 0x58, 0xa0, 0xf9, 0x1e, 0xda, 0x13, + 0x16, 0x8d, 0xbc, 0xcd, 0x79, 0xf9, 0xec, 0x16, 0xa5, 0x5d, 0xdb, 0x95, 0x0d, 0xa2, 0xbf, 0x68, + 0xc1, 0x98, 0xf8, 0x8d, 0xc9, 0xdb, 0x6d, 0x12, 0x46, 0x82, 0x2d, 0xfd, 0x60, 0xef, 0x7d, 0x10, + 0x15, 0x79, 0x57, 0x3e, 0x28, 0xef, 0x19, 0x13, 0xd8, 0xb5, 0x47, 0x89, 0x5e, 0xa0, 0xbf, 0x65, + 0xc1, 0xa9, 0xa6, 0x73, 0x97, 0xb7, 0xc8, 0xcb, 0xb0, 0x13, 0xb9, 0xbe, 0x50, 0xed, 0x7f, 0xb8, + 0xb7, 0xe9, 0x4f, 0x55, 0xe7, 0x9d, 0x94, 0xfa, 0xc7, 0x53, 0x59, 0x28, 0x5d, 0xbb, 0x9a, 0xd9, + 0xaf, 0x99, 0x2d, 0x18, 0x92, 0xeb, 0x2d, 0x43, 0xb8, 0x51, 0xd6, 0x79, 0xee, 0x23, 0x5b, 0x84, + 0xea, 0xee, 0xff, 0xb4, 0x1d, 0xb1, 0xd6, 0x1e, 0x6a, 0x3b, 0x9f, 0x81, 0x11, 0x7d, 0x8d, 0x3d, + 0xd4, 0xb6, 0xde, 0x86, 0xa9, 0x8c, 0xb5, 0xf4, 0x50, 0x9b, 0xbc, 0x03, 0x67, 0x73, 0xd7, 0xc7, + 0xc3, 0x6c, 0xd8, 0xfe, 0xaa, 0xa5, 0x9f, 0x83, 0x27, 0xa0, 0xac, 0x58, 0x32, 0x95, 0x15, 0xe7, + 0x3b, 0xef, 0x9c, 0x1c, 0x8d, 0xc5, 0x5b, 0x7a, 0xa7, 0xe9, 0xa9, 0x8e, 0xde, 0x80, 0x81, 0x06, + 0x2d, 0x91, 0x86, 0xad, 0x76, 0xf7, 0x1d, 0x19, 0x33, 0x93, 0xac, 0x3c, 0xc4, 0x82, 0x82, 0xfd, + 0x4b, 0x16, 0xf4, 0x9d, 0xc0, 0x48, 0x60, 0x73, 0x24, 0x9e, 0xcf, 0x25, 0x2d, 0x22, 0x24, 0xcf, + 0x61, 0xe7, 0xce, 0xf2, 0xdd, 0x88, 0x78, 0x21, 0xbb, 0x91, 0x33, 0x07, 0xe6, 0xa7, 0x2d, 0x98, + 0xba, 0xee, 0x3b, 0xf5, 0x45, 0xa7, 0xe1, 0x78, 0x35, 0x12, 0xac, 0x7a, 0xdb, 0x47, 0xb2, 0xca, + 0x2e, 0x74, 0xb5, 0xca, 0x5e, 0x92, 0x46, 0x4d, 0x7d, 0xf9, 0xf3, 0x47, 0x39, 0xe9, 0x64, 0xe0, + 0x16, 0xc3, 0xfc, 0x76, 0x07, 0x90, 0xde, 0x4b, 0xe1, 0x23, 0x83, 0x61, 0xd0, 0xe5, 0xfd, 0x15, + 0x93, 0xf8, 0x74, 0x36, 0x87, 0x9b, 0xfa, 0x3c, 0xcd, 0xfb, 0x83, 0x17, 0x60, 0x49, 0xc8, 0x7e, + 0x05, 0x32, 0x1d, 0xed, 0xbb, 0xcb, 0x25, 0xec, 0x8f, 0xc3, 0x24, 0xab, 0x79, 0x44, 0xc9, 0x80, + 0x9d, 0x90, 0xa6, 0x66, 0x84, 0xe0, 0xb3, 0x3f, 0x6f, 0xc1, 0xf8, 0x7a, 0x22, 0x32, 0xd9, 0x45, + 0xa6, 0x7f, 0xcd, 0x10, 0xe2, 0x57, 0x59, 0x29, 0x16, 0xd0, 0x63, 0x17, 0x72, 0xfd, 0xb9, 0x05, + 0x71, 0xec, 0x8b, 0x13, 0x60, 0xdf, 0x96, 0x0c, 0xf6, 0x2d, 0x93, 0x91, 0x55, 0xdd, 0xc9, 0xe3, + 0xde, 0xd0, 0x35, 0x15, 0x15, 0xaa, 0x03, 0x0f, 0x1b, 0x93, 0xe1, 0x4b, 0x71, 0xcc, 0x0c, 0x1d, + 0x25, 0xe3, 0x44, 0xd9, 0xbf, 0x5d, 0x00, 0xa4, 0x70, 0x7b, 0x8e, 0x5a, 0x95, 0xae, 0x71, 0x3c, + 0x51, 0xab, 0xf6, 0x00, 0x31, 0x0b, 0x82, 0xc0, 0xf1, 0x42, 0x4e, 0xd6, 0x15, 0x62, 0xbd, 0xa3, + 0x99, 0x27, 0xcc, 0x88, 0x26, 0xd1, 0xf5, 0x14, 0x35, 0x9c, 0xd1, 0x82, 0x66, 0x19, 0xd2, 0xdf, + 0xab, 0x65, 0xc8, 0x40, 0x17, 0x3f, 0xb8, 0xaf, 0x58, 0x30, 0xaa, 0x86, 0xe9, 0x5d, 0x62, 0xa5, + 0xae, 0xfa, 0x93, 0x73, 0x80, 0x56, 0xb4, 0x2e, 0xb3, 0x8b, 0xe5, 0x3b, 0x99, 0x3f, 0xa3, 0xd3, + 0x70, 0xef, 0x11, 0x15, 0x33, 0x70, 0x56, 0xf8, 0x27, 0x8a, 0xd2, 0xc3, 0x83, 0xd9, 0x51, 0xf5, + 0x8f, 0xc7, 0x44, 0x8e, 0xab, 0xd0, 0x23, 0x79, 0x3c, 0xb1, 0x14, 0xd1, 0xcb, 0xd0, 0xdf, 0xda, + 0x71, 0x42, 0x92, 0xf0, 0xe6, 0xe9, 0xaf, 0xd0, 0xc2, 0xc3, 0x83, 0xd9, 0x31, 0x55, 0x81, 0x95, + 0x60, 0x8e, 0xdd, 0x7b, 0x2c, 0xb0, 0xf4, 0xe2, 0xec, 0x1a, 0x0b, 0xec, 0x4f, 0x2c, 0xe8, 0x5b, + 0xf7, 0xeb, 0x27, 0x71, 0x04, 0xbc, 0x6e, 0x1c, 0x01, 0x8f, 0xe5, 0x85, 0xab, 0xcf, 0xdd, 0xfd, + 0x2b, 0x89, 0xdd, 0x7f, 0x3e, 0x97, 0x42, 0xe7, 0x8d, 0xdf, 0x84, 0x61, 0x16, 0x04, 0x5f, 0x78, + 0x2e, 0xbd, 0x68, 0x6c, 0xf8, 0xd9, 0xc4, 0x86, 0x1f, 0xd7, 0x50, 0xb5, 0x9d, 0xfe, 0x0c, 0x0c, + 0x0a, 0x57, 0x98, 0xa4, 0x5b, 0xa8, 0xc0, 0xc5, 0x12, 0x6e, 0xff, 0x64, 0x11, 0x8c, 0xa0, 0xfb, + 0xe8, 0x57, 0x2c, 0x98, 0x0b, 0xb8, 0x89, 0x6c, 0xbd, 0xdc, 0x0e, 0x5c, 0x6f, 0xbb, 0x5a, 0xdb, + 0x21, 0xf5, 0x76, 0xc3, 0xf5, 0xb6, 0x57, 0xb7, 0x3d, 0x5f, 0x15, 0x2f, 0xdf, 0x25, 0xb5, 0x36, + 0x53, 0xbb, 0x75, 0x89, 0xf0, 0xaf, 0x4c, 0xcd, 0x5f, 0xb8, 0x7f, 0x30, 0x3b, 0x87, 0x8f, 0x44, + 0x1b, 0x1f, 0xb1, 0x2f, 0xe8, 0x37, 0x2c, 0x98, 0xe7, 0xb1, 0xe8, 0x7b, 0xef, 0x7f, 0x87, 0xd7, + 0x72, 0x45, 0x92, 0x8a, 0x89, 0x6c, 0x90, 0xa0, 0xb9, 0xf8, 0x21, 0x31, 0xa0, 0xf3, 0x95, 0xa3, + 0xb5, 0x85, 0x8f, 0xda, 0x39, 0xfb, 0x1f, 0x16, 0x61, 0x54, 0xc4, 0x8c, 0x12, 0x77, 0xc0, 0xcb, + 0xc6, 0x92, 0x78, 0x3c, 0xb1, 0x24, 0x26, 0x0d, 0xe4, 0xe3, 0x39, 0xfe, 0x43, 0x98, 0xa4, 0x87, + 0xf3, 0x55, 0xe2, 0x04, 0xd1, 0x26, 0x71, 0xb8, 0xc1, 0x57, 0xf1, 0xc8, 0xa7, 0xbf, 0x92, 0x4f, + 0x5e, 0x4f, 0x12, 0xc3, 0x69, 0xfa, 0xdf, 0x4e, 0x77, 0x8e, 0x07, 0x13, 0xa9, 0xb0, 0x5f, 0x9f, + 0x80, 0x92, 0xf2, 0xe3, 0x10, 0x87, 0x4e, 0xe7, 0xe8, 0x79, 0x49, 0x0a, 0x5c, 0xfc, 0x15, 0xfb, + 0x10, 0xc5, 0xe4, 0xec, 0xbf, 0x5d, 0x30, 0x1a, 0xe4, 0x93, 0xb8, 0x0e, 0x43, 0x4e, 0x18, 0xba, + 0xdb, 0x1e, 0xa9, 0x77, 0x92, 0x50, 0xa6, 0x9a, 0x61, 0xbe, 0x34, 0x0b, 0xa2, 0x26, 0x56, 0x34, + 0xd0, 0x55, 0x6e, 0x56, 0xb7, 0x47, 0x3a, 0x89, 0x27, 0x53, 0xd4, 0x40, 0x1a, 0xde, 0xed, 0x11, + 0x2c, 0xea, 0xa3, 0x4f, 0x72, 0xbb, 0xc7, 0x6b, 0x9e, 0x7f, 0xc7, 0xbb, 0xe2, 0xfb, 0x32, 0x2e, + 0x43, 0x6f, 0x04, 0x27, 0xa5, 0xb5, 0xa3, 0xaa, 0x8e, 0x4d, 0x6a, 0xbd, 0xc5, 0xd1, 0xfc, 0x2c, + 0xb0, 0xd8, 0xdb, 0xa6, 0xdb, 0x74, 0x88, 0x08, 0x8c, 0x8b, 0x80, 0x64, 0xb2, 0x4c, 0x8c, 0x5d, + 0xe6, 0x53, 0xce, 0xac, 0x1d, 0x0b, 0xd2, 0xaf, 0x99, 0x24, 0x70, 0x92, 0xa6, 0xfd, 0xb3, 0x16, + 0x30, 0x17, 0xd2, 0x13, 0xe0, 0x47, 0x3e, 0x62, 0xf2, 0x23, 0xd3, 0x79, 0x83, 0x9c, 0xc3, 0x8a, + 0xbc, 0xc4, 0x57, 0x56, 0x25, 0xf0, 0xef, 0xee, 0x0b, 0x63, 0x95, 0xee, 0xef, 0x0f, 0xfb, 0x7f, + 0x5a, 0xfc, 0x10, 0x53, 0x5e, 0x16, 0xe8, 0xbb, 0x61, 0xa8, 0xe6, 0xb4, 0x9c, 0x1a, 0xcf, 0x10, + 0x93, 0x2b, 0xd1, 0x33, 0x2a, 0xcd, 0x2d, 0x89, 0x1a, 0x5c, 0x42, 0x25, 0x03, 0xdb, 0x0d, 0xc9, + 0xe2, 0xae, 0x52, 0x29, 0xd5, 0xe4, 0xcc, 0x2e, 0x8c, 0x1a, 0xc4, 0x1e, 0xaa, 0x38, 0xe3, 0xbb, + 0xf9, 0x15, 0xab, 0x02, 0x31, 0x36, 0x61, 0xd2, 0xd3, 0xfe, 0xd3, 0x0b, 0x45, 0x3e, 0x2e, 0x9f, + 0xec, 0x76, 0x89, 0xb2, 0xdb, 0x47, 0xf3, 0x4e, 0x4d, 0x90, 0xc1, 0x69, 0xca, 0xf6, 0x4f, 0x59, + 0xf0, 0x88, 0x8e, 0xa8, 0x39, 0xc0, 0x74, 0x53, 0x92, 0x94, 0x61, 0xc8, 0x6f, 0x91, 0xc0, 0x89, + 0xfc, 0x40, 0xdc, 0x1a, 0x97, 0xe4, 0xa0, 0xdf, 0x10, 0xe5, 0x87, 0x22, 0xde, 0xb9, 0xa4, 0x2e, + 0xcb, 0xb1, 0xaa, 0x49, 0x5f, 0x9f, 0x6c, 0x30, 0x42, 0xe1, 0xea, 0xc4, 0xce, 0x00, 0xa6, 0x49, + 0x0f, 0xb1, 0x80, 0xd8, 0xdf, 0xb0, 0xf8, 0xc2, 0xd2, 0xbb, 0x8e, 0xde, 0x86, 0x89, 0xa6, 0x13, + 0xd5, 0x76, 0x96, 0xef, 0xb6, 0x02, 0xae, 0x72, 0x92, 0xe3, 0xf4, 0x6c, 0xb7, 0x71, 0xd2, 0x3e, + 0x32, 0x36, 0xe5, 0x5c, 0x4b, 0x10, 0xc3, 0x29, 0xf2, 0x68, 0x13, 0x86, 0x59, 0x19, 0xf3, 0xe2, + 0x0b, 0x3b, 0xb1, 0x06, 0x79, 0xad, 0x29, 0x63, 0x84, 0xb5, 0x98, 0x0e, 0xd6, 0x89, 0xda, 0x5f, + 0x2e, 0xf2, 0xdd, 0xce, 0x58, 0xf9, 0x67, 0x60, 0xb0, 0xe5, 0xd7, 0x97, 0x56, 0xcb, 0x58, 0xcc, + 0x82, 0xba, 0x46, 0x2a, 0xbc, 0x18, 0x4b, 0x38, 0xba, 0x04, 0x43, 0xe2, 0xa7, 0x54, 0x11, 0xb2, + 0xb3, 0x59, 0xe0, 0x85, 0x58, 0x41, 0xd1, 0x0b, 0x00, 0xad, 0xc0, 0xdf, 0x73, 0xeb, 0x2c, 0xba, + 0x44, 0xd1, 0xb4, 0x23, 0xaa, 0x28, 0x08, 0xd6, 0xb0, 0xd0, 0x6b, 0x30, 0xda, 0xf6, 0x42, 0xce, + 0x8e, 0x68, 0xb1, 0x64, 0x95, 0x85, 0xcb, 0x4d, 0x1d, 0x88, 0x4d, 0x5c, 0xb4, 0x00, 0x03, 0x91, + 0xc3, 0xec, 0x62, 0xfa, 0xf3, 0xcd, 0x7d, 0x37, 0x28, 0x86, 0x9e, 0x8c, 0x84, 0x56, 0xc0, 0xa2, + 0x22, 0xfa, 0x84, 0x74, 0xa8, 0xe5, 0x07, 0xbb, 0xb0, 0xb3, 0xef, 0xed, 0x12, 0xd0, 0xdc, 0x69, + 0x85, 0xfd, 0xbe, 0x41, 0x0b, 0xbd, 0x0a, 0x40, 0xee, 0x46, 0x24, 0xf0, 0x9c, 0x86, 0xb2, 0x66, + 0x53, 0x7c, 0x41, 0xd9, 0x5f, 0xf7, 0xa3, 0x9b, 0x21, 0x59, 0x56, 0x18, 0x58, 0xc3, 0xb6, 0x7f, + 0xa3, 0x04, 0x10, 0xf3, 0xed, 0xe8, 0x5e, 0xea, 0xe0, 0x7a, 0xae, 0x33, 0xa7, 0x7f, 0x7c, 0xa7, + 0x16, 0xfa, 0x01, 0x0b, 0x86, 0x9d, 0x46, 0xc3, 0xaf, 0x39, 0x3c, 0xda, 0x6f, 0xa1, 0xf3, 0xc1, + 0x29, 0xda, 0x5f, 0x88, 0x6b, 0xf0, 0x2e, 0xbc, 0x28, 0x57, 0xa8, 0x06, 0xe9, 0xda, 0x0b, 0xbd, + 0x61, 0xf4, 0x01, 0xf9, 0x54, 0x2c, 0x1a, 0x43, 0xa9, 0x9e, 0x8a, 0x25, 0x76, 0x47, 0xe8, 0xaf, + 0xc4, 0x9b, 0xc6, 0x2b, 0xb1, 0x2f, 0xdf, 0x63, 0xd0, 0x60, 0x5f, 0xbb, 0x3d, 0x10, 0x51, 0x45, + 0x8f, 0x1e, 0xd0, 0x9f, 0xef, 0x9e, 0xa7, 0xbd, 0x93, 0xba, 0x44, 0x0e, 0xf8, 0x0c, 0x8c, 0xd7, + 0x4d, 0x26, 0x40, 0xac, 0xc4, 0xa7, 0xf3, 0xe8, 0x26, 0x78, 0x86, 0xf8, 0xda, 0x4f, 0x00, 0x70, + 0x92, 0x30, 0xaa, 0xf0, 0x60, 0x12, 0xab, 0xde, 0x96, 0x2f, 0x7c, 0x3d, 0xec, 0xdc, 0xb9, 0xdc, + 0x0f, 0x23, 0xd2, 0xa4, 0x98, 0xf1, 0xed, 0xbe, 0x2e, 0xea, 0x62, 0x45, 0x05, 0xbd, 0x01, 0x03, + 0xcc, 0x3f, 0x2b, 0x9c, 0x1e, 0xca, 0x97, 0x38, 0x9b, 0xd1, 0xd1, 0xe2, 0x0d, 0xc9, 0xfe, 0x86, + 0x58, 0x50, 0x40, 0x57, 0xa5, 0xf7, 0x63, 0xb8, 0xea, 0xdd, 0x0c, 0x09, 0xf3, 0x7e, 0x2c, 0x2d, + 0x3e, 0x19, 0x3b, 0x36, 0xf2, 0xf2, 0xcc, 0x94, 0x65, 0x46, 0x4d, 0xca, 0x45, 0x89, 0xff, 0x32, + 0x13, 0xda, 0x34, 0xe4, 0x77, 0xcf, 0xcc, 0x96, 0x16, 0x0f, 0xe7, 0x2d, 0x93, 0x04, 0x4e, 0xd2, + 0xa4, 0x1c, 0x29, 0xdf, 0xf5, 0xc2, 0x5b, 0xa4, 0xdb, 0xd9, 0xc1, 0x1f, 0xe2, 0xec, 0x36, 0xe2, + 0x25, 0x58, 0xd4, 0x3f, 0x51, 0xf6, 0x60, 0xc6, 0x83, 0x89, 0xe4, 0x16, 0x7d, 0xa8, 0xec, 0xc8, + 0x1f, 0xf4, 0xc1, 0x98, 0xb9, 0xa4, 0xd0, 0x3c, 0x94, 0x04, 0x11, 0x95, 0x4d, 0x40, 0xed, 0x92, + 0x35, 0x09, 0xc0, 0x31, 0x0e, 0x4b, 0x22, 0xc1, 0xaa, 0x6b, 0xe6, 0xc1, 0x71, 0x12, 0x09, 0x05, + 0xc1, 0x1a, 0x16, 0x7d, 0x58, 0x6d, 0xfa, 0x7e, 0xa4, 0x2e, 0x24, 0xb5, 0xee, 0x16, 0x59, 0x29, + 0x16, 0x50, 0x7a, 0x11, 0xed, 0x92, 0xc0, 0x23, 0x0d, 0x33, 0xee, 0xb0, 0xba, 0x88, 0xae, 0xe9, + 0x40, 0x6c, 0xe2, 0xd2, 0xeb, 0xd4, 0x0f, 0xd9, 0x42, 0x16, 0xcf, 0xb7, 0xd8, 0xdc, 0xba, 0xca, + 0x1d, 0xb0, 0x25, 0x1c, 0x7d, 0x1c, 0x1e, 0x51, 0xb1, 0x95, 0x30, 0xd7, 0x66, 0xc8, 0x16, 0x07, + 0x0c, 0x69, 0xcb, 0x23, 0x4b, 0xd9, 0x68, 0x38, 0xaf, 0x3e, 0x7a, 0x1d, 0xc6, 0x04, 0x8b, 0x2f, + 0x29, 0x0e, 0x9a, 0x16, 0x46, 0xd7, 0x0c, 0x28, 0x4e, 0x60, 0xcb, 0xc8, 0xc9, 0x8c, 0xcb, 0x96, + 0x14, 0x86, 0xd2, 0x91, 0x93, 0x75, 0x38, 0x4e, 0xd5, 0x40, 0x0b, 0x30, 0xce, 0x79, 0x30, 0xd7, + 0xdb, 0xe6, 0x73, 0x22, 0x9c, 0xb9, 0xd4, 0x96, 0xba, 0x61, 0x82, 0x71, 0x12, 0x1f, 0xbd, 0x02, + 0x23, 0x4e, 0x50, 0xdb, 0x71, 0x23, 0x52, 0x8b, 0xda, 0x01, 0xf7, 0xf2, 0xd2, 0x4c, 0xb4, 0x16, + 0x34, 0x18, 0x36, 0x30, 0xed, 0x7b, 0x30, 0x95, 0x11, 0x99, 0x81, 0x2e, 0x1c, 0xa7, 0xe5, 0xca, + 0x6f, 0x4a, 0x58, 0x38, 0x2f, 0x54, 0x56, 0xe5, 0xd7, 0x68, 0x58, 0x74, 0x75, 0xb2, 0x08, 0x0e, + 0x5a, 0xe2, 0x43, 0xb5, 0x3a, 0x57, 0x24, 0x00, 0xc7, 0x38, 0xf6, 0x7f, 0x29, 0xc0, 0x78, 0x86, + 0x6e, 0x85, 0x25, 0xdf, 0x4b, 0x3c, 0x52, 0xe2, 0x5c, 0x7b, 0x66, 0x20, 0xee, 0xc2, 0x11, 0x02, + 0x71, 0x17, 0xbb, 0x05, 0xe2, 0xee, 0x7b, 0x27, 0x81, 0xb8, 0xcd, 0x11, 0xeb, 0xef, 0x69, 0xc4, + 0x32, 0x82, 0x77, 0x0f, 0x1c, 0x31, 0x78, 0xb7, 0x31, 0xe8, 0x83, 0x3d, 0x0c, 0xfa, 0x8f, 0x15, + 0x60, 0x22, 0x69, 0x4a, 0x7a, 0x02, 0x72, 0xdb, 0x37, 0x0c, 0xb9, 0xed, 0xa5, 0x5e, 0x9c, 0x6f, + 0x73, 0x65, 0xb8, 0x38, 0x21, 0xc3, 0x7d, 0x7f, 0x4f, 0xd4, 0x3a, 0xcb, 0x73, 0xff, 0x6a, 0x01, + 0x4e, 0x67, 0x7a, 0xff, 0x9e, 0xc0, 0xd8, 0xdc, 0x30, 0xc6, 0xe6, 0xf9, 0x9e, 0x1d, 0x93, 0x73, + 0x07, 0xe8, 0x76, 0x62, 0x80, 0xe6, 0x7b, 0x27, 0xd9, 0x79, 0x94, 0xbe, 0x5e, 0x84, 0xf3, 0x99, + 0xf5, 0x62, 0xb1, 0xe7, 0x8a, 0x21, 0xf6, 0x7c, 0x21, 0x21, 0xf6, 0xb4, 0x3b, 0xd7, 0x3e, 0x1e, + 0x39, 0xa8, 0x70, 0xd0, 0x65, 0x61, 0x06, 0x1e, 0x50, 0x06, 0x6a, 0x38, 0xe8, 0x2a, 0x42, 0xd8, + 0xa4, 0xfb, 0xed, 0x24, 0xfb, 0xfc, 0x17, 0x16, 0x9c, 0xcd, 0x9c, 0x9b, 0x13, 0x90, 0x75, 0xad, + 0x9b, 0xb2, 0xae, 0x67, 0x7a, 0x5e, 0xad, 0x39, 0xc2, 0xaf, 0x9f, 0xe9, 0xcf, 0xf9, 0x16, 0xf6, + 0x92, 0xbf, 0x01, 0xc3, 0x4e, 0xad, 0x46, 0xc2, 0x70, 0xcd, 0xaf, 0xab, 0x58, 0xc3, 0xcf, 0xb3, + 0x77, 0x56, 0x5c, 0x7c, 0x78, 0x30, 0x3b, 0x93, 0x24, 0x11, 0x83, 0xb1, 0x4e, 0x01, 0x7d, 0x12, + 0x86, 0x42, 0x71, 0x6f, 0x8a, 0xb9, 0x7f, 0xb1, 0xc7, 0xc1, 0x71, 0x36, 0x49, 0xc3, 0x0c, 0x86, + 0xa4, 0x24, 0x15, 0x8a, 0xa4, 0x19, 0x38, 0xa5, 0x70, 0xac, 0x81, 0x53, 0x5e, 0x00, 0xd8, 0x53, + 0x8f, 0x81, 0xa4, 0xfc, 0x41, 0x7b, 0x26, 0x68, 0x58, 0xe8, 0xa3, 0x30, 0x11, 0xf2, 0x68, 0x81, + 0x4b, 0x0d, 0x27, 0x64, 0x7e, 0x34, 0x62, 0x15, 0xb2, 0x80, 0x4b, 0xd5, 0x04, 0x0c, 0xa7, 0xb0, + 0xd1, 0x8a, 0x6c, 0x95, 0x85, 0x36, 0xe4, 0x0b, 0xf3, 0x62, 0xdc, 0xa2, 0x48, 0xfd, 0x7b, 0x2a, + 0x39, 0xfc, 0x6c, 0xe0, 0xb5, 0x9a, 0xe8, 0x93, 0x00, 0x74, 0xf9, 0x08, 0x39, 0xc4, 0x60, 0xfe, + 0xe1, 0x49, 0x4f, 0x95, 0x7a, 0xa6, 0x71, 0x33, 0xf3, 0xa9, 0x2d, 0x2b, 0x22, 0x58, 0x23, 0x88, + 0x1c, 0x18, 0x8d, 0xff, 0xc5, 0x99, 0x31, 0x2f, 0xe5, 0xb6, 0x90, 0x24, 0xce, 0x44, 0xde, 0x65, + 0x9d, 0x04, 0x36, 0x29, 0xda, 0x3f, 0x31, 0x08, 0x8f, 0x76, 0x38, 0x86, 0xd1, 0x82, 0xa9, 0xea, + 0x7d, 0x36, 0xf9, 0x7e, 0x9f, 0xc9, 0xac, 0x6c, 0x3c, 0xe8, 0x13, 0xab, 0xbd, 0xf0, 0x8e, 0x57, + 0xfb, 0x8f, 0x58, 0x9a, 0x64, 0x85, 0x1b, 0x95, 0x7e, 0xe4, 0x88, 0xd7, 0xcb, 0x31, 0x8a, 0x5a, + 0xb6, 0x32, 0xe4, 0x15, 0x2f, 0xf4, 0xdc, 0x9d, 0xde, 0x05, 0x18, 0x5f, 0xb5, 0x00, 0x09, 0xc9, + 0x0a, 0xa9, 0xab, 0xbd, 0x24, 0x44, 0x19, 0x57, 0x8e, 0xfa, 0xfd, 0x0b, 0x29, 0x4a, 0x7c, 0x24, + 0x5e, 0x95, 0xf7, 0x40, 0x1a, 0xa1, 0xeb, 0x98, 0x64, 0x74, 0x0f, 0x7d, 0x9c, 0x05, 0xd2, 0x75, + 0xef, 0x09, 0xe6, 0x47, 0xec, 0xb5, 0x97, 0x45, 0x10, 0x5d, 0x55, 0x4e, 0xb9, 0xdc, 0xcc, 0xee, + 0xea, 0x48, 0xd8, 0x20, 0x75, 0xb2, 0x4f, 0xef, 0x36, 0x3c, 0x92, 0x33, 0x64, 0x0f, 0xf5, 0x05, + 0xfe, 0x5b, 0x16, 0x9c, 0xeb, 0x18, 0x11, 0xe6, 0x5b, 0x90, 0x37, 0xb4, 0x3f, 0x67, 0x41, 0xf6, + 0x64, 0x1b, 0x16, 0x65, 0xf3, 0x50, 0xaa, 0xd1, 0x42, 0xcd, 0x05, 0x38, 0x8e, 0x8d, 0x20, 0x01, + 0x38, 0xc6, 0x31, 0x0c, 0xc7, 0x0a, 0x5d, 0x0d, 0xc7, 0x7e, 0xd5, 0x82, 0xd4, 0xf9, 0x7e, 0x02, + 0x8c, 0xc6, 0xaa, 0xc9, 0x68, 0x3c, 0xd9, 0xcb, 0x68, 0xe6, 0xf0, 0x18, 0x7f, 0x3c, 0x0e, 0x67, + 0x72, 0x3c, 0xf2, 0xf6, 0x60, 0x72, 0xbb, 0x46, 0x4c, 0xe7, 0xea, 0x4e, 0x41, 0x87, 0x3a, 0x7a, + 0x62, 0xb3, 0xbc, 0xb0, 0x93, 0x29, 0x14, 0x9c, 0x6e, 0x02, 0x7d, 0xce, 0x82, 0x53, 0xce, 0x9d, + 0x70, 0x99, 0x32, 0x8c, 0x6e, 0x6d, 0xb1, 0xe1, 0xd7, 0x76, 0xe9, 0x6d, 0x2c, 0x37, 0xc2, 0x4b, + 0x99, 0x42, 0xbc, 0xdb, 0xd5, 0x14, 0xbe, 0xd1, 0x3c, 0x4b, 0x94, 0x9b, 0x85, 0x85, 0x33, 0xdb, + 0x42, 0x58, 0x64, 0x4f, 0xa0, 0xcf, 0xd1, 0x0e, 0xee, 0xff, 0x59, 0xae, 0x93, 0x9c, 0x03, 0x92, + 0x10, 0xac, 0xe8, 0xa0, 0x4f, 0x43, 0x69, 0x5b, 0x7a, 0xfa, 0x66, 0x70, 0x58, 0xf1, 0x40, 0x76, + 0xf6, 0x7f, 0xe6, 0x9a, 0x78, 0x85, 0x84, 0x63, 0xa2, 0xe8, 0x75, 0x28, 0x7a, 0x5b, 0x61, 0xa7, + 0x5c, 0xb3, 0x09, 0x93, 0x4b, 0x1e, 0x64, 0x63, 0x7d, 0xa5, 0x8a, 0x69, 0x45, 0x74, 0x15, 0x8a, + 0xc1, 0x66, 0x5d, 0x48, 0xa0, 0x33, 0x37, 0x29, 0x5e, 0x2c, 0xe7, 0xf4, 0x8a, 0x51, 0xc2, 0x8b, + 0x65, 0x4c, 0x49, 0xa0, 0x0a, 0xf4, 0x33, 0x37, 0x36, 0xc1, 0xcf, 0x64, 0xbe, 0xdc, 0x3a, 0xb8, + 0x83, 0xf2, 0x48, 0x1c, 0x0c, 0x01, 0x73, 0x42, 0x68, 0x03, 0x06, 0x6a, 0x2c, 0x2f, 0xa9, 0x60, + 0x60, 0x3e, 0x90, 0x29, 0x6b, 0xee, 0x90, 0xb0, 0x55, 0x88, 0x5e, 0x19, 0x06, 0x16, 0xb4, 0x18, + 0x55, 0xd2, 0xda, 0xd9, 0x0a, 0x45, 0xde, 0xee, 0x6c, 0xaa, 0x1d, 0xf2, 0x10, 0x0b, 0xaa, 0x0c, + 0x03, 0x0b, 0x5a, 0xe8, 0x55, 0x28, 0x6c, 0xd5, 0x84, 0x8b, 0x5a, 0xa6, 0xd0, 0xd9, 0x8c, 0x93, + 0xb2, 0x38, 0x70, 0xff, 0x60, 0xb6, 0xb0, 0xb2, 0x84, 0x0b, 0x5b, 0x35, 0xb4, 0x0e, 0x83, 0x5b, + 0x3c, 0xb2, 0x82, 0x90, 0x2b, 0x3f, 0x9d, 0x1d, 0xf4, 0x21, 0x15, 0x7c, 0x81, 0xbb, 0x3b, 0x09, + 0x00, 0x96, 0x44, 0x58, 0x32, 0x02, 0x15, 0x21, 0x42, 0x04, 0xa8, 0x9b, 0x3b, 0x5a, 0x54, 0x0f, + 0xce, 0x5f, 0xc6, 0x71, 0x26, 0xb0, 0x46, 0x91, 0xae, 0x6a, 0xe7, 0x5e, 0x3b, 0x60, 0x51, 0xc0, + 0x45, 0x24, 0xa3, 0xcc, 0x55, 0xbd, 0x20, 0x91, 0x3a, 0xad, 0x6a, 0x85, 0x84, 0x63, 0xa2, 0x68, + 0x17, 0x46, 0xf7, 0xc2, 0xd6, 0x0e, 0x91, 0x5b, 0x9a, 0x05, 0x36, 0xca, 0xe1, 0x8f, 0x6e, 0x09, + 0x44, 0x37, 0x88, 0xda, 0x4e, 0x23, 0x75, 0x0a, 0x31, 0x5e, 0xf6, 0x96, 0x4e, 0x0c, 0x9b, 0xb4, + 0xe9, 0xf0, 0xbf, 0xdd, 0xf6, 0x37, 0xf7, 0x23, 0x22, 0xe2, 0xca, 0x65, 0x0e, 0xff, 0x9b, 0x1c, + 0x25, 0x3d, 0xfc, 0x02, 0x80, 0x25, 0x11, 0x74, 0x4b, 0x0c, 0x0f, 0x3b, 0x3d, 0x27, 0xf2, 0x83, + 0xbf, 0x2e, 0x48, 0xa4, 0x9c, 0x41, 0x61, 0xa7, 0x65, 0x4c, 0x8a, 0x9d, 0x92, 0xad, 0x1d, 0x3f, + 0xf2, 0xbd, 0xc4, 0x09, 0x3d, 0x99, 0x7f, 0x4a, 0x56, 0x32, 0xf0, 0xd3, 0xa7, 0x64, 0x16, 0x16, + 0xce, 0x6c, 0x0b, 0xd5, 0x61, 0xac, 0xe5, 0x07, 0xd1, 0x1d, 0x3f, 0x90, 0xeb, 0x0b, 0x75, 0x90, + 0x8b, 0x19, 0x98, 0xa2, 0x45, 0x16, 0xb2, 0xd1, 0x84, 0xe0, 0x04, 0x4d, 0xf4, 0x31, 0x18, 0x0c, + 0x6b, 0x4e, 0x83, 0xac, 0xde, 0x98, 0x9e, 0xca, 0xbf, 0x7e, 0xaa, 0x1c, 0x25, 0x67, 0x75, 0xf1, + 0xc0, 0x18, 0x1c, 0x05, 0x4b, 0x72, 0x68, 0x05, 0xfa, 0x59, 0xb2, 0x39, 0x16, 0x04, 0x31, 0x27, + 0x86, 0x6d, 0xca, 0x00, 0x9e, 0x9f, 0x4d, 0xac, 0x18, 0xf3, 0xea, 0x74, 0x0f, 0x88, 0xe7, 0xa1, + 0x1f, 0x4e, 0x9f, 0xce, 0xdf, 0x03, 0xe2, 0x55, 0x79, 0xa3, 0xda, 0x69, 0x0f, 0x28, 0x24, 0x1c, + 0x13, 0xa5, 0x27, 0x33, 0x3d, 0x4d, 0xcf, 0x74, 0xb0, 0xdc, 0xca, 0x3d, 0x4b, 0xd9, 0xc9, 0x4c, + 0x4f, 0x52, 0x4a, 0xc2, 0xfe, 0xbd, 0xc1, 0x34, 0xcf, 0xc2, 0x04, 0x0a, 0xdf, 0x67, 0xa5, 0x74, + 0xcd, 0x1f, 0xec, 0x55, 0xbe, 0x79, 0x8c, 0x4f, 0xa1, 0xcf, 0x59, 0x70, 0xa6, 0x95, 0xf9, 0x21, + 0x82, 0x01, 0xe8, 0x4d, 0x4c, 0xca, 0x3f, 0x5d, 0x05, 0xcc, 0xcc, 0x86, 0xe3, 0x9c, 0x96, 0x92, + 0xcf, 0xcd, 0xe2, 0x3b, 0x7e, 0x6e, 0xae, 0xc1, 0x50, 0x8d, 0x3f, 0x45, 0x3a, 0xe6, 0xe9, 0x4e, + 0xbe, 0xbd, 0x19, 0x2b, 0x21, 0xde, 0x30, 0x5b, 0x58, 0x91, 0x40, 0x3f, 0x6a, 0xc1, 0xb9, 0x64, + 0xd7, 0x31, 0x61, 0x60, 0x11, 0x65, 0x93, 0xcb, 0x32, 0x56, 0xc4, 0xf7, 0xa7, 0xf8, 0x7f, 0x03, + 0xf9, 0xb0, 0x1b, 0x02, 0xee, 0xdc, 0x18, 0x2a, 0x67, 0x08, 0x53, 0x06, 0x4c, 0x05, 0x52, 0x0f, + 0x02, 0x95, 0x97, 0x60, 0xa4, 0xe9, 0xb7, 0xbd, 0x48, 0x18, 0x7a, 0x09, 0xa3, 0x13, 0x66, 0x6c, + 0xb1, 0xa6, 0x95, 0x63, 0x03, 0x2b, 0x21, 0x86, 0x19, 0x7a, 0x60, 0x31, 0xcc, 0x5b, 0x30, 0xe2, + 0x69, 0x96, 0xc9, 0x82, 0x1f, 0xb8, 0x98, 0x1f, 0x21, 0x57, 0xb7, 0x63, 0xe6, 0xbd, 0xd4, 0x4b, + 0xb0, 0x41, 0xed, 0x64, 0x2d, 0xc0, 0xbe, 0x64, 0x65, 0x30, 0xf5, 0x5c, 0x14, 0xf3, 0x61, 0x53, + 0x14, 0x73, 0x31, 0x29, 0x8a, 0x49, 0x29, 0x0f, 0x0c, 0x29, 0x4c, 0xef, 0x09, 0x80, 0x7a, 0x8d, + 0xb2, 0x69, 0x37, 0xe0, 0x42, 0xb7, 0x6b, 0x89, 0x59, 0xfc, 0xd5, 0x95, 0xaa, 0x38, 0xb6, 0xf8, + 0xab, 0xaf, 0x96, 0x31, 0x83, 0xf4, 0x1a, 0xbf, 0xc9, 0xfe, 0x4f, 0x16, 0x14, 0x2b, 0x7e, 0xfd, + 0x04, 0x1e, 0xbc, 0x1f, 0x31, 0x1e, 0xbc, 0x8f, 0x66, 0x5f, 0x88, 0xf5, 0x5c, 0xd5, 0xc7, 0x72, + 0x42, 0xf5, 0x71, 0x2e, 0x8f, 0x40, 0x67, 0x45, 0xc7, 0x4f, 0x17, 0x61, 0xb8, 0xe2, 0xd7, 0x95, + 0xb9, 0xfd, 0x3f, 0x7e, 0x10, 0x73, 0xfb, 0xdc, 0x34, 0x16, 0x1a, 0x65, 0x66, 0x28, 0x28, 0x3d, + 0x8d, 0xbf, 0xc5, 0xac, 0xee, 0x6f, 0x13, 0x77, 0x7b, 0x27, 0x22, 0xf5, 0xe4, 0xe7, 0x9c, 0x9c, + 0xd5, 0xfd, 0xef, 0x15, 0x60, 0x3c, 0xd1, 0x3a, 0x6a, 0xc0, 0x68, 0x43, 0x17, 0xac, 0x8b, 0x75, + 0xfa, 0x40, 0x32, 0x79, 0x61, 0xb5, 0xac, 0x15, 0x61, 0x93, 0x38, 0x9a, 0x03, 0x50, 0x9a, 0x66, + 0x29, 0x5e, 0x65, 0x5c, 0xbf, 0x52, 0x45, 0x87, 0x58, 0xc3, 0x40, 0x2f, 0xc3, 0x70, 0xe4, 0xb7, + 0xfc, 0x86, 0xbf, 0xbd, 0x7f, 0x8d, 0xc8, 0xd0, 0x5e, 0xca, 0x16, 0x71, 0x23, 0x06, 0x61, 0x1d, + 0x0f, 0xdd, 0x85, 0x49, 0x45, 0xa4, 0x7a, 0x0c, 0xca, 0x06, 0x26, 0x55, 0x58, 0x4f, 0x52, 0xc4, + 0xe9, 0x46, 0xec, 0x9f, 0x2b, 0xf2, 0x21, 0xf6, 0x22, 0xf7, 0xbd, 0xdd, 0xf0, 0xee, 0xde, 0x0d, + 0x5f, 0xb7, 0x60, 0x82, 0xb6, 0xce, 0x0c, 0xad, 0xe4, 0x35, 0xaf, 0x62, 0x72, 0x5b, 0x1d, 0x62, + 0x72, 0x5f, 0xa4, 0xa7, 0x66, 0xdd, 0x6f, 0x47, 0x42, 0x76, 0xa7, 0x1d, 0x8b, 0xb4, 0x14, 0x0b, + 0xa8, 0xc0, 0x23, 0x41, 0x20, 0x9c, 0x43, 0x75, 0x3c, 0x12, 0x04, 0x58, 0x40, 0x65, 0xc8, 0xee, + 0xbe, 0xec, 0x90, 0xdd, 0x3c, 0xf2, 0xaa, 0x30, 0xc9, 0x11, 0x0c, 0x97, 0x16, 0x79, 0x55, 0xda, + 0xea, 0xc4, 0x38, 0xf6, 0x57, 0x8b, 0x30, 0x52, 0xf1, 0xeb, 0xb1, 0x96, 0xf9, 0x25, 0x43, 0xcb, + 0x7c, 0x21, 0xa1, 0x65, 0x9e, 0xd0, 0x71, 0xdf, 0xd3, 0x29, 0x7f, 0xb3, 0x74, 0xca, 0xff, 0xc0, + 0x62, 0xb3, 0x56, 0x5e, 0xaf, 0x72, 0xbb, 0x3d, 0x74, 0x19, 0x86, 0xd9, 0x01, 0xc3, 0xbc, 0x91, + 0xa5, 0xea, 0x95, 0xa5, 0xa2, 0x5a, 0x8f, 0x8b, 0xb1, 0x8e, 0x83, 0x2e, 0xc1, 0x50, 0x48, 0x9c, + 0xa0, 0xb6, 0xa3, 0x4e, 0x57, 0xa1, 0x27, 0xe5, 0x65, 0x58, 0x41, 0xd1, 0x9b, 0x71, 0xd0, 0xcf, + 0x62, 0xbe, 0x77, 0xa3, 0xde, 0x1f, 0xbe, 0x45, 0xf2, 0x23, 0x7d, 0xda, 0xb7, 0x01, 0xa5, 0xf1, + 0x7b, 0x08, 0x4b, 0x37, 0x6b, 0x86, 0xa5, 0x2b, 0xa5, 0x42, 0xd2, 0xfd, 0x99, 0x05, 0x63, 0x15, + 0xbf, 0x4e, 0xb7, 0xee, 0xb7, 0xd3, 0x3e, 0xd5, 0x23, 0x1e, 0x0f, 0x74, 0x88, 0x78, 0xfc, 0x04, + 0xf4, 0x57, 0xfc, 0xfa, 0x6a, 0xa5, 0x53, 0x68, 0x01, 0xfb, 0xaf, 0x59, 0x30, 0x58, 0xf1, 0xeb, + 0x27, 0xa0, 0x16, 0xf8, 0xb0, 0xa9, 0x16, 0x78, 0x24, 0x67, 0xdd, 0xe4, 0x68, 0x02, 0xfe, 0x4a, + 0x1f, 0x8c, 0xd2, 0x7e, 0xfa, 0xdb, 0x72, 0x2a, 0x8d, 0x61, 0xb3, 0x7a, 0x18, 0x36, 0xca, 0x85, + 0xfb, 0x8d, 0x86, 0x7f, 0x27, 0x39, 0xad, 0x2b, 0xac, 0x14, 0x0b, 0x28, 0x7a, 0x0e, 0x86, 0x5a, + 0x01, 0xd9, 0x73, 0x7d, 0xc1, 0xde, 0x6a, 0x4a, 0x96, 0x8a, 0x28, 0xc7, 0x0a, 0x83, 0x3e, 0x0b, + 0x43, 0xd7, 0xa3, 0x57, 0x79, 0xcd, 0xf7, 0xea, 0x5c, 0x72, 0x5e, 0x14, 0x69, 0x39, 0xb4, 0x72, + 0x6c, 0x60, 0xa1, 0xdb, 0x50, 0x62, 0xff, 0xd9, 0xb1, 0x73, 0xf4, 0x04, 0xaf, 0x22, 0xe1, 0x9f, + 0x20, 0x80, 0x63, 0x5a, 0xe8, 0x05, 0x80, 0x48, 0x86, 0xb6, 0x0f, 0x45, 0xa0, 0x35, 0xf5, 0x14, + 0x50, 0x41, 0xef, 0x43, 0xac, 0x61, 0xa1, 0x67, 0xa1, 0x14, 0x39, 0x6e, 0xe3, 0xba, 0xeb, 0x91, + 0x90, 0x49, 0xc4, 0x8b, 0x32, 0xef, 0x9e, 0x28, 0xc4, 0x31, 0x9c, 0xb2, 0x62, 0x2c, 0x08, 0x07, + 0x4f, 0x0f, 0x3d, 0xc4, 0xb0, 0x19, 0x2b, 0x76, 0x5d, 0x95, 0x62, 0x0d, 0x03, 0xed, 0xc0, 0x63, + 0xae, 0xc7, 0x52, 0x58, 0x90, 0xea, 0xae, 0xdb, 0xda, 0xb8, 0x5e, 0xbd, 0x45, 0x02, 0x77, 0x6b, + 0x7f, 0xd1, 0xa9, 0xed, 0x12, 0x4f, 0xa6, 0xee, 0x7c, 0x52, 0x74, 0xf1, 0xb1, 0xd5, 0x0e, 0xb8, + 0xb8, 0x23, 0x25, 0xfb, 0x45, 0xb6, 0xde, 0x6f, 0x54, 0xd1, 0xfb, 0x8d, 0xa3, 0xe3, 0x8c, 0x7e, + 0x74, 0x1c, 0x1e, 0xcc, 0x0e, 0xdc, 0xa8, 0x6a, 0x31, 0x24, 0x5e, 0x81, 0xd3, 0x15, 0xbf, 0x5e, + 0xf1, 0x83, 0x68, 0xc5, 0x0f, 0xee, 0x38, 0x41, 0x5d, 0x2e, 0xaf, 0x59, 0x19, 0x45, 0x83, 0x9e, + 0x9f, 0xfd, 0xfc, 0x74, 0x31, 0x22, 0x64, 0xbc, 0xc8, 0x38, 0xb6, 0x23, 0xfa, 0x7e, 0xd5, 0x18, + 0xef, 0xa0, 0x92, 0xc0, 0x5c, 0x71, 0x22, 0x82, 0x6e, 0xb0, 0xe4, 0xd6, 0xf1, 0x35, 0x2a, 0xaa, + 0x3f, 0xa3, 0x25, 0xb7, 0x8e, 0x81, 0x99, 0xf7, 0xae, 0x59, 0xdf, 0x7e, 0x19, 0x26, 0xe9, 0xdb, + 0x4b, 0x31, 0x32, 0xac, 0x95, 0xee, 0xe1, 0x34, 0xfe, 0x73, 0x3f, 0x3b, 0x88, 0x13, 0xf9, 0x47, + 0xd0, 0xa7, 0x60, 0x2c, 0x24, 0xd7, 0x5d, 0xaf, 0x7d, 0x57, 0x4a, 0x3e, 0x3a, 0x38, 0xfd, 0x55, + 0x97, 0x75, 0x4c, 0x2e, 0x3f, 0x35, 0xcb, 0x70, 0x82, 0x1a, 0x6a, 0xc2, 0xd8, 0x1d, 0xd7, 0xab, + 0xfb, 0x77, 0x42, 0x49, 0x7f, 0x28, 0x5f, 0x8c, 0x7a, 0x9b, 0x63, 0x26, 0xfa, 0x68, 0x34, 0x77, + 0xdb, 0x20, 0x86, 0x13, 0xc4, 0xe9, 0x62, 0x0f, 0xda, 0xde, 0x42, 0x78, 0x33, 0x24, 0x81, 0xc8, + 0x6e, 0xce, 0x16, 0x3b, 0x96, 0x85, 0x38, 0x86, 0xd3, 0xc5, 0xce, 0xfe, 0x5c, 0x09, 0xfc, 0x36, + 0x4f, 0x76, 0x21, 0x16, 0x3b, 0x56, 0xa5, 0x58, 0xc3, 0xa0, 0x87, 0x01, 0xfb, 0xb7, 0xee, 0x7b, + 0xd8, 0xf7, 0x23, 0x79, 0x7c, 0x30, 0x53, 0x00, 0xad, 0x1c, 0x1b, 0x58, 0x68, 0x05, 0x50, 0xd8, + 0x6e, 0xb5, 0x1a, 0xcc, 0x9a, 0xc8, 0x69, 0x30, 0x52, 0xdc, 0xcc, 0xa2, 0xc8, 0x83, 0xf5, 0x56, + 0x53, 0x50, 0x9c, 0x51, 0x83, 0xde, 0x0b, 0x5b, 0xa2, 0xab, 0xfd, 0xac, 0xab, 0x5c, 0xe5, 0x52, + 0xe5, 0xfd, 0x94, 0x30, 0xb4, 0x0c, 0x83, 0xe1, 0x7e, 0x58, 0x8b, 0x44, 0x6c, 0xc5, 0x9c, 0x14, + 0x53, 0x55, 0x86, 0xa2, 0x65, 0x38, 0xe4, 0x55, 0xb0, 0xac, 0x8b, 0x6a, 0x30, 0x25, 0x28, 0x2e, + 0xed, 0x38, 0x9e, 0x4a, 0xd8, 0xc3, 0x8d, 0xaa, 0x2f, 0xdf, 0x3f, 0x98, 0x9d, 0x12, 0x2d, 0xeb, + 0xe0, 0xc3, 0x83, 0xd9, 0x33, 0x15, 0xbf, 0x9e, 0x01, 0xc1, 0x59, 0xd4, 0xf8, 0xe2, 0xab, 0xd5, + 0xfc, 0x66, 0xab, 0x12, 0xf8, 0x5b, 0x6e, 0x83, 0x74, 0x52, 0x5b, 0x55, 0x0d, 0x4c, 0xb1, 0xf8, + 0x8c, 0x32, 0x9c, 0xa0, 0x66, 0x7f, 0x37, 0xe3, 0x9d, 0x58, 0x42, 0xef, 0xa8, 0x1d, 0x10, 0xd4, + 0x84, 0xd1, 0x16, 0xdb, 0x5d, 0x22, 0x05, 0x85, 0x58, 0xeb, 0x2f, 0xf5, 0x28, 0x7e, 0xb9, 0x43, + 0xaf, 0x1c, 0xd3, 0x34, 0xa9, 0xa2, 0x93, 0xc3, 0x26, 0x75, 0xfb, 0x3f, 0x4c, 0xb3, 0xdb, 0xb7, + 0xca, 0x65, 0x2a, 0x83, 0xc2, 0x87, 0x43, 0x3c, 0xe3, 0x66, 0xf2, 0x85, 0x7b, 0xf1, 0xb4, 0x08, + 0x3f, 0x10, 0x2c, 0xeb, 0xa2, 0x4f, 0xc2, 0x18, 0x7d, 0x15, 0xa9, 0x1b, 0x30, 0x9c, 0x3e, 0x95, + 0x1f, 0x6b, 0x43, 0x61, 0xe9, 0xe9, 0x69, 0xf4, 0xca, 0x38, 0x41, 0x0c, 0xbd, 0xc9, 0x4c, 0x81, + 0x24, 0xe9, 0x42, 0x2f, 0xa4, 0x75, 0xab, 0x1f, 0x49, 0x56, 0x23, 0x82, 0xda, 0x30, 0x95, 0x4e, + 0x66, 0x17, 0x4e, 0xdb, 0xf9, 0xec, 0x65, 0x3a, 0x1f, 0x5d, 0x9c, 0x47, 0x24, 0x0d, 0x0b, 0x71, + 0x16, 0x7d, 0x74, 0x1d, 0x46, 0x45, 0x56, 0x6b, 0xb1, 0x72, 0x8b, 0x86, 0xcc, 0x71, 0x14, 0xeb, + 0xc0, 0xc3, 0x64, 0x01, 0x36, 0x2b, 0xa3, 0x6d, 0x38, 0xa7, 0x65, 0x99, 0xba, 0x12, 0x38, 0xcc, + 0x70, 0xc0, 0x65, 0xc7, 0xa9, 0xc6, 0x17, 0x3c, 0x7e, 0xff, 0x60, 0xf6, 0xdc, 0x46, 0x27, 0x44, + 0xdc, 0x99, 0x0e, 0xba, 0x01, 0xa7, 0xb9, 0xa7, 0x78, 0x99, 0x38, 0xf5, 0x86, 0xeb, 0x29, 0xc6, + 0x83, 0x6f, 0xf9, 0xb3, 0xf7, 0x0f, 0x66, 0x4f, 0x2f, 0x64, 0x21, 0xe0, 0xec, 0x7a, 0xe8, 0xc3, + 0x50, 0xaa, 0x7b, 0xa1, 0x18, 0x83, 0x01, 0x23, 0x91, 0x57, 0xa9, 0xbc, 0x5e, 0x55, 0xdf, 0x1f, + 0xff, 0xc1, 0x71, 0x05, 0xb4, 0xcd, 0xe5, 0xd2, 0x4a, 0x5a, 0x32, 0x98, 0x8a, 0x94, 0x95, 0x14, + 0x28, 0x1a, 0xbe, 0xa2, 0x5c, 0x21, 0xa3, 0x5c, 0x28, 0x0c, 0x37, 0x52, 0x83, 0x30, 0x7a, 0x03, + 0x90, 0x08, 0x18, 0xbf, 0x50, 0x63, 0xf9, 0x4d, 0x98, 0x18, 0x7f, 0xc8, 0xf4, 0x5e, 0xac, 0xa6, + 0x30, 0x70, 0x46, 0x2d, 0x74, 0x95, 0x9e, 0x2a, 0x7a, 0xa9, 0x38, 0xb5, 0x54, 0xda, 0xc5, 0x32, + 0x69, 0x05, 0x84, 0x19, 0x42, 0x99, 0x14, 0x71, 0xa2, 0x1e, 0xaa, 0xc3, 0x63, 0x4e, 0x3b, 0xf2, + 0x99, 0xc8, 0xdf, 0x44, 0xdd, 0xf0, 0x77, 0x89, 0xc7, 0xb4, 0x6d, 0x43, 0x8b, 0x17, 0x28, 0x67, + 0xb3, 0xd0, 0x01, 0x0f, 0x77, 0xa4, 0x42, 0x39, 0x52, 0x95, 0x67, 0x19, 0xcc, 0xf8, 0x5f, 0x19, + 0xb9, 0x96, 0x5f, 0x86, 0xe1, 0x1d, 0x3f, 0x8c, 0xd6, 0x49, 0x74, 0xc7, 0x0f, 0x76, 0x45, 0x1c, + 0xdb, 0x38, 0x2a, 0x78, 0x0c, 0xc2, 0x3a, 0x1e, 0x7d, 0x72, 0x32, 0x5b, 0x90, 0xd5, 0x32, 0x53, + 0xc3, 0x0f, 0xc5, 0x67, 0xcc, 0x55, 0x5e, 0x8c, 0x25, 0x5c, 0xa2, 0xae, 0x56, 0x96, 0x98, 0x4a, + 0x3d, 0x81, 0xba, 0x5a, 0x59, 0xc2, 0x12, 0x4e, 0x97, 0x6b, 0xb8, 0xe3, 0x04, 0xa4, 0x12, 0xf8, + 0x35, 0x12, 0x6a, 0xb1, 0xe8, 0x1f, 0xe5, 0x51, 0x7a, 0xe9, 0x72, 0xad, 0x66, 0x21, 0xe0, 0xec, + 0x7a, 0x88, 0xa4, 0x33, 0xac, 0x8d, 0xe5, 0xeb, 0x42, 0xd2, 0xfc, 0x4c, 0x8f, 0x49, 0xd6, 0x3c, + 0x98, 0x50, 0xb9, 0xdd, 0x78, 0x5c, 0xde, 0x70, 0x7a, 0x9c, 0xad, 0xed, 0xde, 0x83, 0xfa, 0x2a, + 0xed, 0xd2, 0x6a, 0x82, 0x12, 0x4e, 0xd1, 0x36, 0x42, 0xbc, 0x4d, 0x74, 0x0d, 0xf1, 0x36, 0x0f, + 0xa5, 0xb0, 0xbd, 0x59, 0xf7, 0x9b, 0x8e, 0xeb, 0x31, 0x95, 0xba, 0xf6, 0xf6, 0xa9, 0x4a, 0x00, + 0x8e, 0x71, 0xd0, 0x0a, 0x0c, 0x39, 0x52, 0x75, 0x84, 0xf2, 0x83, 0xfa, 0x28, 0x85, 0x11, 0x8f, + 0x73, 0x21, 0x95, 0x45, 0xaa, 0x2e, 0x7a, 0x0d, 0x46, 0x85, 0xa7, 0xb3, 0x48, 0x2b, 0x3a, 0x65, + 0xba, 0xa3, 0x55, 0x75, 0x20, 0x36, 0x71, 0xd1, 0x4d, 0x18, 0x8e, 0xfc, 0x06, 0xf3, 0xa9, 0xa2, + 0x6c, 0xde, 0x99, 0xfc, 0xf0, 0x74, 0x1b, 0x0a, 0x4d, 0x97, 0xda, 0xaa, 0xaa, 0x58, 0xa7, 0x83, + 0x36, 0xf8, 0x7a, 0x67, 0x91, 0xe7, 0x49, 0x38, 0xfd, 0x48, 0xfe, 0x9d, 0xa4, 0x02, 0xd4, 0x9b, + 0xdb, 0x41, 0xd4, 0xc4, 0x3a, 0x19, 0x74, 0x05, 0x26, 0x5b, 0x81, 0xeb, 0xb3, 0x35, 0xa1, 0xb4, + 0x86, 0xd3, 0x66, 0x9e, 0xa9, 0x4a, 0x12, 0x01, 0xa7, 0xeb, 0x30, 0x47, 0x75, 0x51, 0x38, 0x7d, + 0x96, 0xe7, 0xca, 0xe0, 0x4f, 0x49, 0x5e, 0x86, 0x15, 0x14, 0xad, 0xb1, 0x93, 0x98, 0x4b, 0x41, + 0xa6, 0x67, 0xf2, 0xe3, 0x08, 0xe9, 0xd2, 0x12, 0xce, 0xbc, 0xaa, 0xbf, 0x38, 0xa6, 0x80, 0xea, + 0x5a, 0x8a, 0x4a, 0xfa, 0x04, 0x08, 0xa7, 0x1f, 0xeb, 0x60, 0x90, 0x97, 0x78, 0x95, 0xc4, 0x0c, + 0x81, 0x51, 0x1c, 0xe2, 0x04, 0x4d, 0xf4, 0x51, 0x98, 0x10, 0xd1, 0x0f, 0xe3, 0x61, 0x3a, 0x17, + 0x5b, 0xaa, 0xe3, 0x04, 0x0c, 0xa7, 0xb0, 0x79, 0xae, 0x0a, 0x67, 0xb3, 0x41, 0xc4, 0xd1, 0x77, + 0xdd, 0xf5, 0x76, 0xc3, 0xe9, 0xf3, 0xec, 0x7c, 0x10, 0xb9, 0x2a, 0x92, 0x50, 0x9c, 0x51, 0x03, + 0x6d, 0xc0, 0x44, 0x2b, 0x20, 0xa4, 0xc9, 0x18, 0x7d, 0x71, 0x9f, 0xcd, 0xf2, 0x38, 0x0d, 0xb4, + 0x27, 0x95, 0x04, 0xec, 0x30, 0xa3, 0x0c, 0xa7, 0x28, 0xa0, 0x3b, 0x30, 0xe4, 0xef, 0x91, 0x60, + 0x87, 0x38, 0xf5, 0xe9, 0x0b, 0x1d, 0x3c, 0x27, 0xc4, 0xe5, 0x76, 0x43, 0xe0, 0x26, 0x2c, 0x0d, + 0x64, 0x71, 0x77, 0x4b, 0x03, 0xd9, 0x18, 0xfa, 0x7f, 0x2d, 0x38, 0x2b, 0x95, 0x13, 0xd5, 0x16, + 0x1d, 0xf5, 0x25, 0xdf, 0x0b, 0xa3, 0x80, 0x47, 0x16, 0x78, 0x3c, 0xdf, 0xdb, 0x7e, 0x23, 0xa7, + 0x92, 0x12, 0xc4, 0x9e, 0xcd, 0xc3, 0x08, 0x71, 0x7e, 0x8b, 0x68, 0x09, 0x26, 0x43, 0x12, 0xc9, + 0xc3, 0x68, 0x21, 0x5c, 0x79, 0xb3, 0xbc, 0x3e, 0xfd, 0x04, 0x0f, 0x8b, 0x40, 0x37, 0x43, 0x35, + 0x09, 0xc4, 0x69, 0x7c, 0x74, 0x19, 0x0a, 0x7e, 0x38, 0xfd, 0x64, 0x87, 0xac, 0xa6, 0xf4, 0x05, + 0xcf, 0x2d, 0xce, 0x6e, 0x54, 0x71, 0xc1, 0x0f, 0x65, 0xbe, 0x08, 0xfa, 0x1e, 0x0b, 0xa7, 0x9f, + 0xe2, 0x62, 0x3b, 0x99, 0x2f, 0x82, 0x15, 0xe2, 0x18, 0x8e, 0x76, 0x60, 0x3c, 0x34, 0xde, 0xbd, + 0xe1, 0xf4, 0x45, 0x36, 0x52, 0x4f, 0xe5, 0x4d, 0x9a, 0x81, 0xad, 0x85, 0x7b, 0x37, 0xa9, 0xe0, + 0x24, 0xd9, 0x99, 0xef, 0x84, 0xc9, 0x14, 0x23, 0x73, 0x94, 0x24, 0x45, 0x33, 0xbb, 0x30, 0x6a, + 0x2c, 0x96, 0x87, 0xaa, 0x73, 0xff, 0x67, 0x83, 0x50, 0x52, 0xfa, 0x58, 0x34, 0x6f, 0xaa, 0xd9, + 0xcf, 0x26, 0xd5, 0xec, 0x43, 0x15, 0xbf, 0x6e, 0x68, 0xd6, 0x37, 0x32, 0xc2, 0xda, 0xe5, 0x1d, + 0x4d, 0xbd, 0x9b, 0xfb, 0x6b, 0x42, 0xee, 0x62, 0xcf, 0xfa, 0xfa, 0xbe, 0x8e, 0x72, 0xf3, 0x2b, + 0x30, 0xe9, 0xf9, 0x8c, 0x7b, 0x26, 0x75, 0xc9, 0x1a, 0x31, 0x0e, 0xa8, 0xa4, 0xc7, 0x89, 0x49, + 0x20, 0xe0, 0x74, 0x1d, 0xda, 0x20, 0x67, 0x61, 0x92, 0x82, 0x7a, 0xce, 0xe1, 0x60, 0x01, 0x45, + 0x4f, 0x40, 0x7f, 0xcb, 0xaf, 0xaf, 0x56, 0x04, 0xe7, 0xac, 0x05, 0x53, 0xad, 0xaf, 0x56, 0x30, + 0x87, 0xa1, 0x05, 0x18, 0x60, 0x3f, 0xc2, 0xe9, 0x91, 0xfc, 0x80, 0x20, 0xac, 0x86, 0x96, 0x02, + 0x8a, 0x55, 0xc0, 0xa2, 0x22, 0x13, 0x18, 0xd2, 0xe7, 0x06, 0x13, 0x18, 0x0e, 0x3e, 0xa0, 0xc0, + 0x50, 0x12, 0xc0, 0x31, 0x2d, 0x74, 0x17, 0x4e, 0x1b, 0x4f, 0x3c, 0xbe, 0x44, 0x48, 0x28, 0x82, + 0x12, 0x3c, 0xd1, 0xf1, 0x6d, 0x27, 0xf4, 0xfb, 0xe7, 0x44, 0xa7, 0x4f, 0xaf, 0x66, 0x51, 0xc2, + 0xd9, 0x0d, 0xa0, 0x06, 0x4c, 0xd6, 0x52, 0xad, 0x0e, 0xf5, 0xde, 0xaa, 0x9a, 0xd0, 0x74, 0x8b, + 0x69, 0xc2, 0xe8, 0x35, 0x18, 0x7a, 0xdb, 0x0f, 0xd9, 0xad, 0x23, 0xb8, 0x7d, 0xe9, 0xd1, 0x3e, + 0xf4, 0xe6, 0x8d, 0x2a, 0x2b, 0x3f, 0x3c, 0x98, 0x1d, 0xae, 0xf8, 0x75, 0xf9, 0x17, 0xab, 0x0a, + 0xe8, 0x07, 0x2d, 0x98, 0x49, 0xbf, 0x21, 0x55, 0xa7, 0x47, 0x7b, 0xef, 0xb4, 0x2d, 0x1a, 0x9d, + 0x59, 0xce, 0x25, 0x87, 0x3b, 0x34, 0x65, 0xff, 0xb2, 0xc5, 0xc4, 0x8e, 0x42, 0x6f, 0x46, 0xc2, + 0x76, 0xe3, 0x24, 0x32, 0xdf, 0x2e, 0x1b, 0x2a, 0xbd, 0x07, 0xb6, 0xf7, 0xf8, 0x47, 0x16, 0xb3, + 0xf7, 0x38, 0x41, 0xc7, 0x8e, 0x37, 0x61, 0x28, 0x92, 0x19, 0x89, 0x3b, 0x24, 0xeb, 0xd5, 0x3a, + 0xc5, 0x6c, 0x5e, 0x14, 0xef, 0xad, 0x92, 0x0f, 0x2b, 0x32, 0xf6, 0xdf, 0xe5, 0x33, 0x20, 0x21, + 0x27, 0xa0, 0x39, 0x29, 0x9b, 0x9a, 0x93, 0xd9, 0x2e, 0x5f, 0x90, 0xa3, 0x41, 0xf9, 0x3b, 0x66, + 0xbf, 0x99, 0xcc, 0xe9, 0xdd, 0x6e, 0x68, 0x64, 0x7f, 0xde, 0x02, 0x88, 0x63, 0x55, 0xf7, 0x90, + 0x73, 0xee, 0x15, 0xca, 0x6d, 0xfb, 0x91, 0x5f, 0xf3, 0x1b, 0x42, 0x2f, 0xf8, 0x58, 0xac, 0xbc, + 0xe1, 0xe5, 0x87, 0xda, 0x6f, 0xac, 0xb0, 0xd1, 0xac, 0x8c, 0x8c, 0x57, 0x8c, 0xd5, 0x89, 0x46, + 0x54, 0xbc, 0x2f, 0x5a, 0x70, 0x2a, 0xcb, 0x4a, 0x98, 0xbe, 0xdd, 0xb8, 0xf4, 0x4d, 0x19, 0x81, + 0xa9, 0xd9, 0xbc, 0x25, 0xca, 0xb1, 0xc2, 0xe8, 0x39, 0x99, 0xdf, 0xd1, 0x82, 0x44, 0xdf, 0x80, + 0xd1, 0x4a, 0x40, 0xb4, 0xcb, 0xf5, 0x75, 0x1e, 0x6d, 0x81, 0xf7, 0xe7, 0xb9, 0x23, 0x47, 0x5a, + 0xb0, 0xbf, 0x5c, 0x80, 0x53, 0xdc, 0x96, 0x62, 0x61, 0xcf, 0x77, 0xeb, 0x15, 0xbf, 0x2e, 0x7c, + 0xc1, 0x3e, 0x01, 0x23, 0x2d, 0x4d, 0x64, 0xda, 0x29, 0xe0, 0xa9, 0x2e, 0x5a, 0x8d, 0x85, 0x3c, + 0x7a, 0x29, 0x36, 0x68, 0xa1, 0x3a, 0x8c, 0x90, 0x3d, 0xb7, 0xa6, 0x14, 0xf2, 0x85, 0x23, 0x5f, + 0x74, 0xaa, 0x95, 0x65, 0x8d, 0x0e, 0x36, 0xa8, 0x3e, 0x84, 0x14, 0xdb, 0xf6, 0x8f, 0x5b, 0xf0, + 0x48, 0x4e, 0x78, 0x54, 0xda, 0xdc, 0x1d, 0x66, 0xb5, 0x22, 0x96, 0xad, 0x6a, 0x8e, 0xdb, 0xb2, + 0x60, 0x01, 0x45, 0x1f, 0x03, 0xe0, 0xb6, 0x28, 0xc4, 0xab, 0x75, 0x8d, 0x23, 0x69, 0x84, 0xc0, + 0xd3, 0xa2, 0x99, 0xc9, 0xfa, 0x58, 0xa3, 0x65, 0x7f, 0xb1, 0x0f, 0xfa, 0x99, 0xed, 0x03, 0xaa, + 0xc0, 0xe0, 0x0e, 0x4f, 0x78, 0xd3, 0x71, 0xde, 0x28, 0xae, 0xcc, 0xa1, 0x13, 0xcf, 0x9b, 0x56, + 0x8a, 0x25, 0x19, 0xb4, 0x06, 0x53, 0x3c, 0xef, 0x50, 0xa3, 0x4c, 0x1a, 0xce, 0xbe, 0x94, 0x46, + 0xf2, 0x24, 0xb9, 0x4a, 0x2a, 0xbb, 0x9a, 0x46, 0xc1, 0x59, 0xf5, 0xd0, 0xeb, 0x30, 0x46, 0x5f, + 0x87, 0x7e, 0x3b, 0x92, 0x94, 0x78, 0xc6, 0x21, 0xf5, 0x1c, 0xdd, 0x30, 0xa0, 0x38, 0x81, 0x8d, + 0x5e, 0x83, 0xd1, 0x56, 0x4a, 0xee, 0xda, 0x1f, 0x0b, 0x28, 0x4c, 0x59, 0xab, 0x89, 0xcb, 0x0c, + 0x85, 0xdb, 0xcc, 0x2c, 0x7a, 0x63, 0x27, 0x20, 0xe1, 0x8e, 0xdf, 0xa8, 0x33, 0xf6, 0xaf, 0x5f, + 0x33, 0x14, 0x4e, 0xc0, 0x71, 0xaa, 0x06, 0xa5, 0xb2, 0xe5, 0xb8, 0x8d, 0x76, 0x40, 0x62, 0x2a, + 0x03, 0x26, 0x95, 0x95, 0x04, 0x1c, 0xa7, 0x6a, 0x74, 0x17, 0x28, 0x0f, 0x1e, 0x8f, 0x40, 0xd9, + 0xfe, 0x99, 0x02, 0x18, 0x53, 0xfb, 0xed, 0x9b, 0x09, 0x89, 0x7e, 0xd9, 0x76, 0xd0, 0xaa, 0x09, + 0x3b, 0x9f, 0xcc, 0x2f, 0x8b, 0x13, 0x9c, 0xf2, 0x2f, 0xa3, 0xff, 0x31, 0xab, 0x45, 0xf7, 0xf8, + 0xe9, 0x4a, 0xe0, 0xd3, 0x4b, 0x4e, 0xc6, 0xe3, 0x52, 0xf6, 0xf8, 0x83, 0xd2, 0x57, 0xb9, 0x43, + 0xe4, 0x4a, 0x61, 0xb1, 0xcc, 0x29, 0x18, 0x26, 0x31, 0x55, 0x11, 0x34, 0x40, 0x52, 0x41, 0x97, + 0x61, 0x58, 0xa4, 0xb7, 0x61, 0x66, 0xe3, 0x7c, 0x33, 0x31, 0x13, 0x9e, 0x72, 0x5c, 0x8c, 0x75, + 0x1c, 0xfb, 0x87, 0x0a, 0x30, 0x95, 0xe1, 0xf7, 0xc3, 0xaf, 0x91, 0x6d, 0x37, 0x8c, 0x54, 0x0e, + 0x55, 0xed, 0x1a, 0xe1, 0xe5, 0x58, 0x61, 0xd0, 0xb3, 0x8a, 0x5f, 0x54, 0xc9, 0xcb, 0x49, 0xd8, + 0xd5, 0x0b, 0xe8, 0x11, 0xb3, 0x91, 0x5e, 0x80, 0xbe, 0x76, 0x48, 0x64, 0xcc, 0x59, 0x75, 0x6d, + 0x33, 0x6d, 0x2b, 0x83, 0xd0, 0x67, 0xd4, 0xb6, 0x52, 0x5c, 0x6a, 0xcf, 0x28, 0xae, 0xba, 0xe4, + 0x30, 0xda, 0xb9, 0x88, 0x78, 0x8e, 0x17, 0x89, 0xc7, 0x56, 0x1c, 0x3c, 0x91, 0x95, 0x62, 0x01, + 0xb5, 0xbf, 0x50, 0x84, 0xb3, 0xb9, 0x9e, 0x80, 0xb4, 0xeb, 0x4d, 0xdf, 0x73, 0x23, 0x5f, 0xd9, + 0x46, 0xf1, 0x80, 0x89, 0xa4, 0xb5, 0xb3, 0x26, 0xca, 0xb1, 0xc2, 0x40, 0x17, 0xa1, 0x9f, 0xc9, + 0x6a, 0x53, 0xd9, 0x64, 0x17, 0xcb, 0x3c, 0x82, 0x16, 0x07, 0xf7, 0x9c, 0x00, 0xfc, 0x09, 0xca, + 0xc1, 0xf8, 0x8d, 0xe4, 0x85, 0x42, 0xbb, 0xeb, 0xfb, 0x0d, 0xcc, 0x80, 0xe8, 0x29, 0x31, 0x5e, + 0x09, 0x63, 0x20, 0xec, 0xd4, 0xfd, 0x50, 0x1b, 0xb4, 0x67, 0x60, 0x70, 0x97, 0xec, 0x07, 0xae, + 0xb7, 0x9d, 0x34, 0x12, 0xbb, 0xc6, 0x8b, 0xb1, 0x84, 0x9b, 0xe9, 0x0f, 0x07, 0x8f, 0x3b, 0x73, + 0xf7, 0x50, 0x57, 0xf6, 0xe4, 0x47, 0x8a, 0x30, 0x8e, 0x17, 0xcb, 0xef, 0x4d, 0xc4, 0xcd, 0xf4, + 0x44, 0x1c, 0x77, 0xe6, 0xee, 0xee, 0xb3, 0xf1, 0x0b, 0x16, 0x8c, 0xb3, 0x24, 0x3b, 0xc2, 0xdf, + 0xdf, 0xf5, 0xbd, 0x13, 0x78, 0x0a, 0x3c, 0x01, 0xfd, 0x01, 0x6d, 0x34, 0x99, 0x46, 0x96, 0xf5, + 0x04, 0x73, 0x18, 0x7a, 0x0c, 0xfa, 0x58, 0x17, 0xe8, 0xe4, 0x8d, 0xf0, 0x23, 0xb8, 0xec, 0x44, + 0x0e, 0x66, 0xa5, 0x2c, 0x7e, 0x14, 0x26, 0xad, 0x86, 0xcb, 0x3b, 0x1d, 0x6b, 0xd2, 0xdf, 0x1d, + 0x31, 0x02, 0x32, 0xbb, 0xf6, 0xce, 0xe2, 0x47, 0x65, 0x93, 0xec, 0xfc, 0xcc, 0xfe, 0xa3, 0x02, + 0x9c, 0xcf, 0xac, 0xd7, 0x73, 0xfc, 0xa8, 0xce, 0xb5, 0x1f, 0x66, 0x1a, 0x95, 0xe2, 0x09, 0x9a, + 0xe0, 0xf6, 0xf5, 0xca, 0xfd, 0xf7, 0xf7, 0x10, 0xd6, 0x29, 0x73, 0xc8, 0xde, 0x25, 0x61, 0x9d, + 0x32, 0xfb, 0x96, 0x23, 0x26, 0xf8, 0xf3, 0x42, 0xce, 0xb7, 0x30, 0x81, 0xc1, 0x25, 0x7a, 0xce, + 0x30, 0x60, 0x28, 0x1f, 0xe1, 0xfc, 0x8c, 0xe1, 0x65, 0x58, 0x41, 0xd1, 0x02, 0x8c, 0x37, 0x5d, + 0x8f, 0x1e, 0x3e, 0xfb, 0x26, 0x2b, 0xae, 0x44, 0xec, 0x6b, 0x26, 0x18, 0x27, 0xf1, 0x91, 0xab, + 0x85, 0x7c, 0xe2, 0x5f, 0xf7, 0xda, 0x91, 0x76, 0xdd, 0x9c, 0x69, 0x65, 0xa0, 0x46, 0x31, 0x23, + 0xfc, 0xd3, 0x9a, 0x26, 0x27, 0x2a, 0xf6, 0x2e, 0x27, 0x1a, 0xc9, 0x96, 0x11, 0xcd, 0xbc, 0x06, + 0xa3, 0x0f, 0xac, 0x18, 0xb0, 0xbf, 0x5e, 0x84, 0x47, 0x3b, 0x6c, 0x7b, 0x7e, 0xd6, 0x1b, 0x73, + 0xa0, 0x9d, 0xf5, 0xa9, 0x79, 0xa8, 0xc0, 0xa9, 0xad, 0x76, 0xa3, 0xb1, 0xcf, 0x3c, 0x53, 0x48, + 0x5d, 0x62, 0x08, 0x9e, 0x52, 0x0a, 0x47, 0x4e, 0xad, 0x64, 0xe0, 0xe0, 0xcc, 0x9a, 0xf4, 0x89, + 0x45, 0x6f, 0x92, 0x7d, 0x45, 0x2a, 0xf1, 0xc4, 0xc2, 0x3a, 0x10, 0x9b, 0xb8, 0xe8, 0x0a, 0x4c, + 0x3a, 0x7b, 0x8e, 0xcb, 0xe3, 0x66, 0x4b, 0x02, 0xfc, 0x8d, 0xa5, 0xe4, 0xb9, 0x0b, 0x49, 0x04, + 0x9c, 0xae, 0x83, 0xde, 0x00, 0xe4, 0x6f, 0x32, 0xfb, 0xf5, 0xfa, 0x15, 0xe2, 0x09, 0x65, 0x30, + 0x9b, 0xbb, 0x62, 0x7c, 0x24, 0xdc, 0x48, 0x61, 0xe0, 0x8c, 0x5a, 0x89, 0xf8, 0x46, 0x03, 0xf9, + 0xf1, 0x8d, 0x3a, 0x9f, 0x8b, 0x5d, 0x33, 0xf8, 0xfc, 0x5b, 0x8b, 0x5e, 0x5f, 0x9c, 0xc9, 0x37, + 0x23, 0x81, 0xbe, 0xc6, 0x6c, 0x40, 0xb9, 0xac, 0x57, 0x8b, 0x06, 0x73, 0x5a, 0xb3, 0x01, 0x8d, + 0x81, 0xd8, 0xc4, 0xe5, 0x0b, 0x22, 0x8c, 0x9d, 0x90, 0x0d, 0x16, 0x5f, 0x84, 0x2b, 0x53, 0x18, + 0xe8, 0xe3, 0x30, 0x58, 0x77, 0xf7, 0xdc, 0x50, 0x48, 0xba, 0x8e, 0xac, 0x56, 0x8a, 0xcf, 0xc1, + 0x32, 0x27, 0x83, 0x25, 0x3d, 0xfb, 0x47, 0x0a, 0x30, 0x2a, 0x5b, 0x7c, 0xb3, 0xed, 0x47, 0xce, + 0x09, 0x5c, 0xcb, 0x57, 0x8c, 0x6b, 0xf9, 0xa9, 0x4e, 0x31, 0xdb, 0x58, 0x97, 0x72, 0xaf, 0xe3, + 0x1b, 0x89, 0xeb, 0xf8, 0xe9, 0xee, 0xa4, 0x3a, 0x5f, 0xc3, 0x7f, 0xcf, 0x82, 0x49, 0x03, 0xff, + 0x04, 0x6e, 0x83, 0x15, 0xf3, 0x36, 0x78, 0xbc, 0xeb, 0x37, 0xe4, 0xdc, 0x02, 0xdf, 0x5f, 0x4c, + 0xf4, 0x9d, 0x9d, 0xfe, 0x6f, 0x43, 0xdf, 0x8e, 0x13, 0xd4, 0x3b, 0xe5, 0xa8, 0x48, 0x55, 0x9a, + 0xbb, 0xea, 0x04, 0x42, 0x1b, 0xfe, 0x9c, 0x1c, 0x75, 0x5a, 0xd4, 0x55, 0x13, 0xce, 0x9a, 0x42, + 0xaf, 0xc0, 0x40, 0x58, 0xf3, 0x5b, 0xca, 0x2f, 0xe5, 0x02, 0x1b, 0x68, 0x56, 0x72, 0x78, 0x30, + 0x8b, 0xcc, 0xe6, 0x68, 0x31, 0x16, 0xf8, 0xe8, 0x13, 0x30, 0xca, 0x7e, 0x29, 0xd3, 0xb4, 0x62, + 0xbe, 0x38, 0xa2, 0xaa, 0x23, 0x72, 0xbb, 0x4d, 0xa3, 0x08, 0x9b, 0xa4, 0x66, 0xb6, 0xa1, 0xa4, + 0x3e, 0xeb, 0xa1, 0xea, 0x6d, 0xff, 0x75, 0x11, 0xa6, 0x32, 0xd6, 0x1c, 0x0a, 0x8d, 0x99, 0xb8, + 0xdc, 0xe3, 0x52, 0x7d, 0x87, 0x73, 0x11, 0xb2, 0xd7, 0x50, 0x5d, 0xac, 0xad, 0x9e, 0x1b, 0xbd, + 0x19, 0x92, 0x64, 0xa3, 0xb4, 0xa8, 0x7b, 0xa3, 0xb4, 0xb1, 0x13, 0x1b, 0x6a, 0xda, 0x90, 0xea, + 0xe9, 0x43, 0x9d, 0xd3, 0x3f, 0x2d, 0xc2, 0xa9, 0xac, 0x30, 0x92, 0xe8, 0xb3, 0x89, 0x0c, 0xa9, + 0x2f, 0xf5, 0x1a, 0x80, 0x92, 0xa7, 0x4d, 0x15, 0xe1, 0xed, 0xe6, 0xcc, 0x9c, 0xa9, 0x5d, 0x87, + 0x59, 0xb4, 0xc9, 0x02, 0x6c, 0x04, 0x3c, 0xb3, 0xad, 0x3c, 0x3e, 0x3e, 0xd8, 0x73, 0x07, 0x44, + 0x4a, 0xdc, 0x30, 0x61, 0xf6, 0x22, 0x8b, 0xbb, 0x9b, 0xbd, 0xc8, 0x96, 0x67, 0x5c, 0x18, 0xd6, + 0xbe, 0xe6, 0xa1, 0xce, 0xf8, 0x2e, 0xbd, 0xad, 0xb4, 0x7e, 0x3f, 0xd4, 0x59, 0xff, 0x71, 0x0b, + 0x12, 0x9e, 0x10, 0x4a, 0x2c, 0x66, 0xe5, 0x8a, 0xc5, 0x2e, 0x40, 0x5f, 0xe0, 0x37, 0x48, 0x32, + 0x95, 0x28, 0xf6, 0x1b, 0x04, 0x33, 0x08, 0xc5, 0x88, 0x62, 0x61, 0xc7, 0x88, 0xfe, 0x90, 0x13, + 0x4f, 0xb4, 0x27, 0xa0, 0xbf, 0x41, 0xf6, 0x48, 0x23, 0x99, 0xf1, 0xe9, 0x3a, 0x2d, 0xc4, 0x1c, + 0x66, 0xff, 0x42, 0x1f, 0x9c, 0xeb, 0x18, 0xa2, 0x86, 0x3e, 0x87, 0xb6, 0x9d, 0x88, 0xdc, 0x71, + 0xf6, 0x93, 0xa9, 0x59, 0xae, 0xf0, 0x62, 0x2c, 0xe1, 0xcc, 0x2f, 0x8e, 0x47, 0x58, 0x4f, 0x08, + 0x11, 0x45, 0x60, 0x75, 0x01, 0x35, 0x85, 0x52, 0xc5, 0xe3, 0x10, 0x4a, 0xbd, 0x00, 0x10, 0x86, + 0x0d, 0x6e, 0x2f, 0x56, 0x17, 0x0e, 0x77, 0x71, 0x24, 0xfe, 0xea, 0x75, 0x01, 0xc1, 0x1a, 0x16, + 0x2a, 0xc3, 0x44, 0x2b, 0xf0, 0x23, 0x2e, 0x93, 0x2d, 0x73, 0x93, 0xca, 0x7e, 0x33, 0x3a, 0x48, + 0x25, 0x01, 0xc7, 0xa9, 0x1a, 0xe8, 0x65, 0x18, 0x16, 0x11, 0x43, 0x2a, 0xbe, 0xdf, 0x10, 0x62, + 0x20, 0x65, 0x65, 0x58, 0x8d, 0x41, 0x58, 0xc7, 0xd3, 0xaa, 0x31, 0x41, 0xef, 0x60, 0x66, 0x35, + 0x2e, 0xec, 0xd5, 0xf0, 0x12, 0x21, 0x65, 0x87, 0x7a, 0x0a, 0x29, 0x1b, 0x0b, 0xc6, 0x4a, 0x3d, + 0xeb, 0x1d, 0xa1, 0xab, 0x28, 0xe9, 0x2b, 0x7d, 0x30, 0x25, 0x16, 0xce, 0xc3, 0x5e, 0x2e, 0x37, + 0xd3, 0xcb, 0xe5, 0x38, 0x44, 0x67, 0xef, 0xad, 0x99, 0x93, 0x5e, 0x33, 0x3f, 0x6a, 0x81, 0xc9, + 0x5e, 0xa1, 0xff, 0x2b, 0x37, 0xb7, 0xd5, 0xcb, 0xb9, 0xec, 0x9a, 0x8a, 0x51, 0xfa, 0x0e, 0xb3, + 0x5c, 0xd9, 0xff, 0xc6, 0x82, 0xc7, 0xbb, 0x52, 0x44, 0xcb, 0x50, 0x62, 0x3c, 0xa0, 0xf6, 0x3a, + 0x7b, 0x5a, 0x99, 0x5c, 0x4b, 0x40, 0x0e, 0x4b, 0x1a, 0xd7, 0x44, 0xcb, 0xa9, 0x24, 0x62, 0xcf, + 0x64, 0x24, 0x11, 0x3b, 0x6d, 0x0c, 0xcf, 0x03, 0x66, 0x11, 0xfb, 0x61, 0x7a, 0xe3, 0x18, 0xee, + 0x4e, 0xe8, 0x83, 0x86, 0xd8, 0xcf, 0x4e, 0x88, 0xfd, 0x90, 0x89, 0xad, 0xdd, 0x21, 0x1f, 0x85, + 0x09, 0x16, 0x4a, 0x8c, 0x39, 0x00, 0x08, 0x47, 0xac, 0x42, 0x6c, 0xe4, 0x7b, 0x3d, 0x01, 0xc3, + 0x29, 0x6c, 0xfb, 0x0f, 0x8b, 0x30, 0xc0, 0xb7, 0xdf, 0x09, 0xbc, 0x09, 0x9f, 0x85, 0x92, 0xdb, + 0x6c, 0xb6, 0x79, 0x5e, 0xa8, 0xfe, 0xd8, 0x64, 0x74, 0x55, 0x16, 0xe2, 0x18, 0x8e, 0x56, 0x84, + 0xc4, 0xb9, 0x43, 0xb4, 0x52, 0xde, 0xf1, 0xb9, 0xb2, 0x13, 0x39, 0x9c, 0xc1, 0x51, 0xf7, 0x6c, + 0x2c, 0x9b, 0x46, 0x9f, 0x02, 0x08, 0xa3, 0xc0, 0xf5, 0xb6, 0x69, 0x99, 0x08, 0x92, 0xfc, 0xfe, + 0x0e, 0xd4, 0xaa, 0x0a, 0x99, 0xd3, 0x8c, 0xcf, 0x1c, 0x05, 0xc0, 0x1a, 0x45, 0x34, 0x67, 0xdc, + 0xf4, 0x33, 0x89, 0xb9, 0x03, 0x4e, 0x35, 0x9e, 0xb3, 0x99, 0x0f, 0x41, 0x49, 0x11, 0xef, 0x26, + 0x7f, 0x1a, 0xd1, 0xd9, 0xa2, 0x8f, 0xc0, 0x78, 0xa2, 0x6f, 0x47, 0x12, 0x5f, 0xfd, 0xa2, 0x05, + 0xe3, 0xbc, 0x33, 0xcb, 0xde, 0x9e, 0xb8, 0x0d, 0xee, 0xc1, 0xa9, 0x46, 0xc6, 0xa9, 0x2c, 0xa6, + 0xbf, 0xf7, 0x53, 0x5c, 0x89, 0xab, 0xb2, 0xa0, 0x38, 0xb3, 0x0d, 0x74, 0x89, 0xee, 0x38, 0x7a, + 0xea, 0x3a, 0x0d, 0xe1, 0xf8, 0x3d, 0xc2, 0x77, 0x1b, 0x2f, 0xc3, 0x0a, 0x6a, 0xff, 0x8e, 0x05, + 0x93, 0xbc, 0xe7, 0xd7, 0xc8, 0xbe, 0x3a, 0x9b, 0xbe, 0x99, 0x7d, 0x17, 0x19, 0x09, 0x0b, 0x39, + 0x19, 0x09, 0xf5, 0x4f, 0x2b, 0x76, 0xfc, 0xb4, 0x2f, 0x5b, 0x20, 0x56, 0xc8, 0x09, 0x08, 0x21, + 0xbe, 0xd3, 0x14, 0x42, 0xcc, 0xe4, 0x6f, 0x82, 0x1c, 0xe9, 0xc3, 0x9f, 0x59, 0x30, 0xc1, 0x11, + 0x62, 0x6d, 0xf9, 0x37, 0x75, 0x1e, 0x7a, 0xc9, 0x5b, 0x7e, 0x8d, 0xec, 0x6f, 0xf8, 0x15, 0x27, + 0xda, 0xc9, 0xfe, 0x28, 0x63, 0xb2, 0xfa, 0x3a, 0x4e, 0x56, 0x5d, 0x6e, 0x20, 0x23, 0x61, 0x4f, + 0x97, 0x68, 0x18, 0x47, 0x4d, 0xd8, 0x63, 0x7f, 0xc3, 0x02, 0xc4, 0x9b, 0x31, 0x18, 0x37, 0xca, + 0x0e, 0xb1, 0x52, 0xed, 0xa2, 0x8b, 0x8f, 0x26, 0x05, 0xc1, 0x1a, 0xd6, 0xb1, 0x0c, 0x4f, 0xc2, + 0xe4, 0xa1, 0xd8, 0xdd, 0xe4, 0xe1, 0x08, 0x23, 0xfa, 0xcf, 0x07, 0x20, 0xe9, 0xf2, 0x85, 0x6e, + 0xc1, 0x48, 0xcd, 0x69, 0x39, 0x9b, 0x6e, 0xc3, 0x8d, 0x5c, 0x12, 0x76, 0xb2, 0x87, 0x5a, 0xd2, + 0xf0, 0x84, 0x92, 0x5a, 0x2b, 0xc1, 0x06, 0x1d, 0x34, 0x07, 0xd0, 0x0a, 0xdc, 0x3d, 0xb7, 0x41, + 0xb6, 0x99, 0xac, 0x84, 0x85, 0x9a, 0xe0, 0xc6, 0x59, 0xb2, 0x14, 0x6b, 0x18, 0x19, 0xfe, 0xf5, + 0xc5, 0x87, 0xec, 0x5f, 0x0f, 0x27, 0xe6, 0x5f, 0xdf, 0x77, 0x24, 0xff, 0xfa, 0xa1, 0x23, 0xfb, + 0xd7, 0xf7, 0xf7, 0xe4, 0x5f, 0x8f, 0xe1, 0x8c, 0xe4, 0x3d, 0xe9, 0xff, 0x15, 0xb7, 0x41, 0xc4, + 0x83, 0x83, 0xc7, 0xc7, 0x98, 0xb9, 0x7f, 0x30, 0x7b, 0x06, 0x67, 0x62, 0xe0, 0x9c, 0x9a, 0xe8, + 0x63, 0x30, 0xed, 0x34, 0x1a, 0xfe, 0x1d, 0x35, 0xa9, 0xcb, 0x61, 0xcd, 0x69, 0x70, 0x25, 0xc4, + 0x20, 0xa3, 0xfa, 0xd8, 0xfd, 0x83, 0xd9, 0xe9, 0x85, 0x1c, 0x1c, 0x9c, 0x5b, 0x1b, 0x7d, 0x18, + 0x4a, 0xad, 0xc0, 0xaf, 0xad, 0x69, 0x7e, 0xa9, 0xe7, 0xe9, 0x00, 0x56, 0x64, 0xe1, 0xe1, 0xc1, + 0xec, 0xa8, 0xfa, 0xc3, 0x2e, 0xfc, 0xb8, 0x42, 0x86, 0xc3, 0xfc, 0xf0, 0xb1, 0x3a, 0xcc, 0xef, + 0xc2, 0x54, 0x95, 0x04, 0xae, 0xd3, 0x70, 0xef, 0x51, 0x7e, 0x59, 0x9e, 0x4f, 0x1b, 0x50, 0x0a, + 0x12, 0x27, 0x72, 0x4f, 0x11, 0x44, 0xb5, 0xcc, 0x29, 0xf2, 0x04, 0x8e, 0x09, 0xd9, 0xff, 0xc3, + 0x82, 0x41, 0xe1, 0xe2, 0x75, 0x02, 0x5c, 0xe3, 0x82, 0xa1, 0x49, 0x98, 0xcd, 0x1e, 0x30, 0xd6, + 0x99, 0x5c, 0x1d, 0xc2, 0x6a, 0x42, 0x87, 0xf0, 0x78, 0x27, 0x22, 0x9d, 0xb5, 0x07, 0x7f, 0xb9, + 0x48, 0xb9, 0x77, 0xc3, 0xd9, 0xf8, 0xe1, 0x0f, 0xc1, 0x3a, 0x0c, 0x86, 0xc2, 0xd9, 0xb5, 0x90, + 0xef, 0xd3, 0x90, 0x9c, 0xc4, 0xd8, 0x8e, 0x4d, 0xb8, 0xb7, 0x4a, 0x22, 0x99, 0x5e, 0xb4, 0xc5, + 0x87, 0xe8, 0x45, 0xdb, 0xcd, 0x1d, 0xbb, 0xef, 0x38, 0xdc, 0xb1, 0xed, 0xaf, 0xb1, 0x9b, 0x53, + 0x2f, 0x3f, 0x01, 0xa6, 0xea, 0x8a, 0x79, 0xc7, 0xda, 0x1d, 0x56, 0x96, 0xe8, 0x54, 0x0e, 0x73, + 0xf5, 0xf3, 0x16, 0x9c, 0xcb, 0xf8, 0x2a, 0x8d, 0xd3, 0x7a, 0x0e, 0x86, 0x9c, 0x76, 0xdd, 0x55, + 0x7b, 0x59, 0xd3, 0x27, 0x2e, 0x88, 0x72, 0xac, 0x30, 0xd0, 0x12, 0x4c, 0x92, 0xbb, 0x2d, 0x97, + 0xab, 0x52, 0x75, 0xf3, 0xdf, 0x22, 0xf7, 0x0b, 0x5c, 0x4e, 0x02, 0x71, 0x1a, 0x5f, 0x45, 0xce, + 0x29, 0xe6, 0x46, 0xce, 0xf9, 0x9b, 0x16, 0x0c, 0x2b, 0x77, 0xcf, 0x87, 0x3e, 0xda, 0x1f, 0x35, + 0x47, 0xfb, 0xd1, 0x0e, 0xa3, 0x9d, 0x33, 0xcc, 0xbf, 0x55, 0x50, 0xfd, 0xad, 0xf8, 0x41, 0xd4, + 0x03, 0x07, 0xf7, 0xe0, 0xae, 0x0b, 0x97, 0x61, 0xd8, 0x69, 0xb5, 0x24, 0x40, 0xda, 0xa0, 0xb1, + 0x78, 0xd0, 0x71, 0x31, 0xd6, 0x71, 0x94, 0x27, 0x45, 0x31, 0xd7, 0x93, 0xa2, 0x0e, 0x10, 0x39, + 0xc1, 0x36, 0x89, 0x68, 0x99, 0x30, 0x99, 0xcd, 0x3f, 0x6f, 0xda, 0x91, 0xdb, 0x98, 0x73, 0xbd, + 0x28, 0x8c, 0x82, 0xb9, 0x55, 0x2f, 0xba, 0x11, 0xf0, 0x27, 0xa4, 0x16, 0x7b, 0x4a, 0xd1, 0xc2, + 0x1a, 0x5d, 0x19, 0xda, 0x80, 0xb5, 0xd1, 0x6f, 0x1a, 0x33, 0xac, 0x8b, 0x72, 0xac, 0x30, 0xec, + 0x0f, 0xb1, 0xdb, 0x87, 0x8d, 0xe9, 0xd1, 0xe2, 0x2e, 0x7d, 0x79, 0x44, 0xcd, 0x06, 0xd3, 0x64, + 0x96, 0xf5, 0xe8, 0x4e, 0x9d, 0x0f, 0x7b, 0xda, 0xb0, 0xee, 0xd7, 0x17, 0x87, 0x80, 0x42, 0xdf, + 0x95, 0x32, 0x50, 0x79, 0xbe, 0xcb, 0xad, 0x71, 0x04, 0x93, 0x14, 0x96, 0x1c, 0x86, 0xa5, 0xce, + 0x58, 0xad, 0x88, 0x7d, 0xa1, 0x25, 0x87, 0x11, 0x00, 0x1c, 0xe3, 0x50, 0x66, 0x4a, 0xfd, 0x09, + 0xa7, 0x51, 0x1c, 0x24, 0x55, 0x61, 0x87, 0x58, 0xc3, 0x40, 0xf3, 0x42, 0xa0, 0xc0, 0xf5, 0x02, + 0x8f, 0x26, 0x04, 0x0a, 0x72, 0xb8, 0x34, 0x29, 0xd0, 0x65, 0x18, 0x56, 0xa9, 0xc0, 0x2b, 0x3c, + 0x2d, 0x93, 0x58, 0x66, 0xcb, 0x71, 0x31, 0xd6, 0x71, 0xd0, 0x06, 0x8c, 0x87, 0x5c, 0xce, 0xa6, + 0x22, 0x57, 0x73, 0x79, 0xe5, 0xfb, 0x95, 0xa3, 0xad, 0x09, 0x3e, 0x64, 0x45, 0xfc, 0x74, 0x92, + 0xe1, 0x07, 0x92, 0x24, 0xd0, 0xeb, 0x30, 0xd6, 0xf0, 0x9d, 0xfa, 0xa2, 0xd3, 0x70, 0xbc, 0x1a, + 0x1b, 0x9f, 0x21, 0x33, 0xa3, 0xec, 0x75, 0x03, 0x8a, 0x13, 0xd8, 0x94, 0x79, 0xd3, 0x4b, 0x44, + 0xb4, 0x75, 0xc7, 0xdb, 0x26, 0xa1, 0x48, 0xec, 0xcc, 0x98, 0xb7, 0xeb, 0x39, 0x38, 0x38, 0xb7, + 0x36, 0x7a, 0x05, 0x46, 0xe4, 0xe7, 0x6b, 0xd1, 0x3a, 0x62, 0xa7, 0x14, 0x0d, 0x86, 0x0d, 0x4c, + 0x74, 0x07, 0x4e, 0xcb, 0xff, 0x1b, 0x81, 0xb3, 0xb5, 0xe5, 0xd6, 0x84, 0x0b, 0x3b, 0xf7, 0x5e, + 0x5d, 0x90, 0x2e, 0x96, 0xcb, 0x59, 0x48, 0x87, 0x07, 0xb3, 0x17, 0xc4, 0xa8, 0x65, 0xc2, 0xd9, + 0x24, 0x66, 0xd3, 0x47, 0x6b, 0x30, 0xb5, 0x43, 0x9c, 0x46, 0xb4, 0xb3, 0xb4, 0x43, 0x6a, 0xbb, + 0x72, 0xd3, 0xb1, 0x18, 0x20, 0x9a, 0x03, 0xc7, 0xd5, 0x34, 0x0a, 0xce, 0xaa, 0x87, 0xde, 0x82, + 0xe9, 0x56, 0x7b, 0xb3, 0xe1, 0x86, 0x3b, 0xeb, 0x7e, 0xc4, 0x4c, 0x81, 0x54, 0x66, 0x71, 0x11, + 0x2c, 0x44, 0x45, 0x59, 0xa9, 0xe4, 0xe0, 0xe1, 0x5c, 0x0a, 0xe8, 0x1e, 0x9c, 0x4e, 0x2c, 0x06, + 0x11, 0x2e, 0x61, 0x2c, 0x3f, 0x77, 0x45, 0x35, 0xab, 0x82, 0x88, 0x3c, 0x92, 0x05, 0xc2, 0xd9, + 0x4d, 0xa0, 0x57, 0x01, 0xdc, 0xd6, 0x8a, 0xd3, 0x74, 0x1b, 0xf4, 0xb9, 0x38, 0xc5, 0xd6, 0x09, + 0x7d, 0x3a, 0xc0, 0x6a, 0x45, 0x96, 0xd2, 0xf3, 0x59, 0xfc, 0xdb, 0xc7, 0x1a, 0x36, 0xba, 0x0e, + 0x63, 0xe2, 0xdf, 0xbe, 0x98, 0x56, 0x1e, 0xb5, 0xe3, 0x49, 0x16, 0x72, 0xa9, 0xa2, 0x43, 0x0e, + 0x53, 0x25, 0x38, 0x51, 0x17, 0x6d, 0xc3, 0x39, 0x99, 0x87, 0x4c, 0x5f, 0xa3, 0x72, 0x0e, 0x42, + 0x96, 0x30, 0x62, 0x88, 0xfb, 0x86, 0x2c, 0x74, 0x42, 0xc4, 0x9d, 0xe9, 0xd0, 0xbb, 0x5d, 0x5f, + 0xea, 0xdc, 0x7b, 0xf6, 0x34, 0x37, 0x4d, 0xa2, 0x77, 0xfb, 0xf5, 0x24, 0x10, 0xa7, 0xf1, 0x51, + 0x08, 0xa7, 0x5d, 0x2f, 0x6b, 0x65, 0x9f, 0x61, 0x84, 0x3e, 0xc2, 0x1d, 0x87, 0x3b, 0xaf, 0xea, + 0x4c, 0x38, 0x5f, 0xd5, 0x99, 0xb4, 0xdf, 0x99, 0x05, 0xde, 0x6f, 0x5b, 0xb4, 0xb6, 0xc6, 0xa5, + 0xa3, 0x4f, 0xc3, 0x88, 0xfe, 0x61, 0x82, 0xe3, 0xb8, 0x98, 0xcd, 0xc4, 0x6a, 0x67, 0x03, 0xe7, + 0xf1, 0xd5, 0xfe, 0xd7, 0x61, 0xd8, 0xa0, 0x88, 0x6a, 0x19, 0x2e, 0xf6, 0xf3, 0xbd, 0x71, 0x34, + 0xbd, 0x1b, 0xa0, 0x11, 0xc8, 0x5e, 0xf2, 0xe8, 0x3a, 0x0c, 0xd5, 0x1a, 0x2e, 0xf1, 0xa2, 0xd5, + 0x4a, 0xa7, 0xf0, 0x7e, 0x4b, 0x02, 0x47, 0xec, 0x21, 0x91, 0xff, 0x81, 0x97, 0x61, 0x45, 0xc1, + 0xfe, 0xb5, 0x02, 0xcc, 0x76, 0x49, 0x26, 0x92, 0x50, 0x47, 0x59, 0x3d, 0xa9, 0xa3, 0x16, 0x64, + 0xea, 0xfc, 0xf5, 0x84, 0xa4, 0x2b, 0x91, 0x16, 0x3f, 0x96, 0x77, 0x25, 0xf1, 0x7b, 0x76, 0x0f, + 0xd0, 0x35, 0x5a, 0x7d, 0x5d, 0x1d, 0x5c, 0x0c, 0x4d, 0x76, 0x7f, 0xef, 0xcf, 0xdf, 0x5c, 0xad, + 0xa4, 0xfd, 0xb5, 0x02, 0x9c, 0x56, 0x43, 0xf8, 0xed, 0x3b, 0x70, 0x37, 0xd3, 0x03, 0x77, 0x0c, + 0x3a, 0x5d, 0xfb, 0x06, 0x0c, 0xf0, 0x78, 0x85, 0x3d, 0xb0, 0xdd, 0x4f, 0x98, 0x61, 0x84, 0x15, + 0xa7, 0x67, 0x84, 0x12, 0xfe, 0x41, 0x0b, 0xc6, 0x13, 0x7e, 0x66, 0x08, 0x6b, 0xce, 0xc8, 0x0f, + 0xc2, 0x1a, 0x67, 0x31, 0xdd, 0x17, 0xa0, 0x6f, 0xc7, 0x0f, 0xa3, 0xa4, 0xc1, 0xc7, 0x55, 0x3f, + 0x8c, 0x30, 0x83, 0xd8, 0xbf, 0x6b, 0x41, 0xff, 0x86, 0xe3, 0x7a, 0x91, 0x54, 0x0e, 0x58, 0x39, + 0xca, 0x81, 0x5e, 0xbe, 0x0b, 0xbd, 0x0c, 0x03, 0x64, 0x6b, 0x8b, 0xd4, 0x22, 0x31, 0xab, 0x32, + 0x92, 0xc3, 0xc0, 0x32, 0x2b, 0xa5, 0x7c, 0x20, 0x6b, 0x8c, 0xff, 0xc5, 0x02, 0x19, 0xdd, 0x86, + 0x52, 0xe4, 0x36, 0xc9, 0x42, 0xbd, 0x2e, 0x54, 0xe6, 0x0f, 0x10, 0x8d, 0x62, 0x43, 0x12, 0xc0, + 0x31, 0x2d, 0xfb, 0x0b, 0x05, 0x80, 0x38, 0xd0, 0x53, 0xb7, 0x4f, 0x5c, 0x4c, 0x29, 0x53, 0x2f, + 0x66, 0x28, 0x53, 0x51, 0x4c, 0x30, 0x43, 0x93, 0xaa, 0x86, 0xa9, 0xd8, 0xd3, 0x30, 0xf5, 0x1d, + 0x65, 0x98, 0x96, 0x60, 0x32, 0x0e, 0x54, 0x65, 0xc6, 0xe9, 0x63, 0xd7, 0xe7, 0x46, 0x12, 0x88, + 0xd3, 0xf8, 0x36, 0x81, 0x0b, 0x2a, 0x5e, 0x8f, 0xb8, 0xd1, 0x98, 0x45, 0xb6, 0xae, 0x9c, 0xee, + 0x32, 0x4e, 0xb1, 0xb6, 0xb8, 0x90, 0xab, 0x2d, 0xfe, 0x29, 0x0b, 0x4e, 0x25, 0xdb, 0x61, 0xee, + 0xcb, 0x9f, 0xb7, 0xe0, 0x34, 0xd3, 0x99, 0xb3, 0x56, 0xd3, 0x1a, 0xfa, 0x97, 0x3a, 0xc6, 0x20, + 0xca, 0xe9, 0x71, 0x1c, 0x32, 0x64, 0x2d, 0x8b, 0x34, 0xce, 0x6e, 0xd1, 0xfe, 0xef, 0x7d, 0x30, + 0x9d, 0x17, 0xbc, 0x88, 0x39, 0x6c, 0x38, 0x77, 0xab, 0xbb, 0xe4, 0x8e, 0x30, 0x8b, 0x8f, 0x1d, + 0x36, 0x78, 0x31, 0x96, 0xf0, 0x64, 0x7e, 0x88, 0x42, 0x8f, 0xf9, 0x21, 0x76, 0x60, 0xf2, 0xce, + 0x0e, 0xf1, 0x6e, 0x7a, 0xa1, 0x13, 0xb9, 0xe1, 0x96, 0xcb, 0xf4, 0xcb, 0x7c, 0xdd, 0xc8, 0xa4, + 0xb2, 0x93, 0xb7, 0x93, 0x08, 0x87, 0x07, 0xb3, 0xe7, 0x8c, 0x82, 0xb8, 0xcb, 0xfc, 0x20, 0xc1, + 0x69, 0xa2, 0xe9, 0xf4, 0x1a, 0x7d, 0x0f, 0x39, 0xbd, 0x46, 0xd3, 0x15, 0x56, 0x29, 0xd2, 0x1a, + 0x9f, 0xbd, 0x1c, 0xd7, 0x54, 0x29, 0xd6, 0x30, 0xd0, 0x27, 0x01, 0xe9, 0xe9, 0x83, 0x8c, 0xd8, + 0x91, 0xcf, 0xdf, 0x3f, 0x98, 0x45, 0xeb, 0x29, 0xe8, 0xe1, 0xc1, 0xec, 0x14, 0x2d, 0x5d, 0xf5, + 0xe8, 0x0b, 0x34, 0x0e, 0xb8, 0x95, 0x41, 0x08, 0xdd, 0x86, 0x09, 0x5a, 0xca, 0x76, 0x94, 0x0c, + 0x4c, 0xc9, 0x5f, 0x8d, 0xcf, 0xde, 0x3f, 0x98, 0x9d, 0x58, 0x4f, 0xc0, 0xf2, 0x48, 0xa7, 0x88, + 0xa0, 0x57, 0x61, 0x2c, 0x5e, 0x57, 0xd7, 0xc8, 0x3e, 0x0f, 0x37, 0x53, 0xe2, 0x82, 0xef, 0x35, + 0x03, 0x82, 0x13, 0x98, 0xf6, 0xe7, 0x2d, 0x38, 0x9b, 0x9b, 0xe2, 0x1a, 0x5d, 0x82, 0x21, 0xa7, + 0xe5, 0x72, 0x35, 0x86, 0xb8, 0x6a, 0x98, 0xb8, 0xac, 0xb2, 0xca, 0x95, 0x18, 0x0a, 0x4a, 0x4f, + 0xf8, 0x5d, 0xd7, 0xab, 0x27, 0x4f, 0xf8, 0x6b, 0xae, 0x57, 0xc7, 0x0c, 0xa2, 0xae, 0xac, 0x62, + 0x6e, 0xa4, 0xe6, 0xaf, 0xd0, 0xbd, 0x9a, 0x91, 0x0c, 0xfb, 0x64, 0xbb, 0x81, 0x9e, 0xd5, 0x55, + 0x8e, 0xc2, 0xba, 0x30, 0x57, 0xdd, 0xf8, 0x03, 0x16, 0x08, 0x27, 0xe2, 0x1e, 0xee, 0xe4, 0x4f, + 0xc0, 0xc8, 0x5e, 0x3a, 0xb5, 0xda, 0x85, 0x7c, 0xaf, 0x6a, 0x91, 0x50, 0x4d, 0x31, 0xda, 0x46, + 0x1a, 0x35, 0x83, 0x96, 0x5d, 0x07, 0x01, 0x2d, 0x13, 0xa6, 0x58, 0xe8, 0xde, 0x9b, 0x17, 0x00, + 0xea, 0x0c, 0x97, 0xe5, 0x5b, 0x2d, 0x98, 0x1c, 0x57, 0x59, 0x41, 0xb0, 0x86, 0x65, 0xff, 0xcb, + 0x02, 0x0c, 0xcb, 0x54, 0x5e, 0x6d, 0xaf, 0x17, 0xf1, 0xdf, 0x91, 0x72, 0xfb, 0xa2, 0x79, 0x28, + 0x31, 0xf9, 0x74, 0x25, 0x96, 0x9a, 0x2a, 0xe9, 0xd0, 0x9a, 0x04, 0xe0, 0x18, 0x87, 0x9e, 0x8e, + 0x61, 0x7b, 0x93, 0xa1, 0x27, 0x5c, 0x5e, 0xab, 0xbc, 0x18, 0x4b, 0x38, 0xfa, 0x18, 0x4c, 0xf0, + 0x7a, 0x81, 0xdf, 0x72, 0xb6, 0xb9, 0x4e, 0xab, 0x5f, 0xc5, 0x11, 0x99, 0x58, 0x4b, 0xc0, 0x0e, + 0x0f, 0x66, 0x4f, 0x25, 0xcb, 0x98, 0xb2, 0x36, 0x45, 0x85, 0x99, 0xae, 0xf1, 0x46, 0xe8, 0xa9, + 0x9e, 0xb2, 0x78, 0x8b, 0x41, 0x58, 0xc7, 0xb3, 0x3f, 0x0d, 0x28, 0x9d, 0xd4, 0x0c, 0xbd, 0xc1, + 0xed, 0x95, 0xdd, 0x80, 0xd4, 0x3b, 0x29, 0x6f, 0xf5, 0x68, 0x19, 0xd2, 0x5b, 0x8d, 0xd7, 0xc2, + 0xaa, 0xbe, 0xfd, 0xff, 0x15, 0x61, 0x22, 0xe9, 0x9f, 0x8f, 0xae, 0xc2, 0x00, 0x67, 0x29, 0x05, + 0xf9, 0x0e, 0xb6, 0x41, 0x9a, 0x57, 0x3f, 0xbb, 0x5c, 0x05, 0x57, 0x2a, 0xea, 0xa3, 0xb7, 0x60, + 0xb8, 0xee, 0xdf, 0xf1, 0xee, 0x38, 0x41, 0x7d, 0xa1, 0xb2, 0x2a, 0x96, 0x73, 0xa6, 0xb0, 0xa2, + 0x1c, 0xa3, 0xe9, 0x91, 0x02, 0x98, 0x1e, 0x3c, 0x06, 0x61, 0x9d, 0x1c, 0xda, 0x60, 0x99, 0x10, + 0xb6, 0xdc, 0xed, 0x35, 0xa7, 0xd5, 0xc9, 0x79, 0x65, 0x49, 0x22, 0x69, 0x94, 0x47, 0x45, 0xba, + 0x04, 0x0e, 0xc0, 0x31, 0x21, 0xf4, 0x59, 0x98, 0x0a, 0x73, 0x54, 0x28, 0x79, 0x39, 0x2e, 0x3b, + 0x69, 0x15, 0x16, 0x1f, 0xb9, 0x7f, 0x30, 0x3b, 0x95, 0xa5, 0x6c, 0xc9, 0x6a, 0xc6, 0xfe, 0xe2, + 0x29, 0x30, 0x36, 0xb1, 0x91, 0xf2, 0xd8, 0x3a, 0xa6, 0x94, 0xc7, 0x18, 0x86, 0x48, 0xb3, 0x15, + 0xed, 0x97, 0xdd, 0x40, 0xcc, 0x49, 0x26, 0xcd, 0x65, 0x81, 0x93, 0xa6, 0x29, 0x21, 0x58, 0xd1, + 0xc9, 0xce, 0x4b, 0x5d, 0xfc, 0x26, 0xe6, 0xa5, 0xee, 0x3b, 0xc1, 0xbc, 0xd4, 0xeb, 0x30, 0xb8, + 0xed, 0x46, 0x98, 0xb4, 0x7c, 0xf1, 0x98, 0xcb, 0x5c, 0x87, 0x57, 0x38, 0x4a, 0x3a, 0x03, 0xaa, + 0x00, 0x60, 0x49, 0x04, 0xbd, 0xa1, 0x76, 0xe0, 0x40, 0xbe, 0xc0, 0x25, 0x6d, 0xc4, 0x92, 0xb9, + 0x07, 0x45, 0xf6, 0xe9, 0xc1, 0x07, 0xcd, 0x3e, 0xbd, 0x22, 0x73, 0x46, 0x0f, 0xe5, 0x7b, 0x9a, + 0xb1, 0x94, 0xd0, 0x5d, 0x32, 0x45, 0xdf, 0xd2, 0xf3, 0x6c, 0x97, 0xf2, 0x4f, 0x02, 0x95, 0x42, + 0xbb, 0xc7, 0xec, 0xda, 0x3f, 0x60, 0xc1, 0xe9, 0x56, 0x56, 0xca, 0x79, 0x61, 0xef, 0xf1, 0x72, + 0xcf, 0x59, 0xed, 0x8d, 0x06, 0x99, 0x9c, 0x34, 0x13, 0x0d, 0x67, 0x37, 0x47, 0x07, 0x3a, 0xd8, + 0xac, 0x0b, 0xbb, 0x83, 0x27, 0x72, 0xd2, 0x74, 0x77, 0x48, 0xce, 0xbd, 0x91, 0x91, 0x12, 0xfa, + 0xc9, 0xbc, 0x94, 0xd0, 0x3d, 0x27, 0x82, 0x7e, 0x43, 0x25, 0xe8, 0x1e, 0xcd, 0x5f, 0x4a, 0x3c, + 0xfd, 0x76, 0xd7, 0xb4, 0xdc, 0x6f, 0xa8, 0xb4, 0xdc, 0x1d, 0x42, 0x4f, 0xf3, 0xa4, 0xdb, 0x5d, + 0x93, 0x71, 0x6b, 0x09, 0xb5, 0xc7, 0x8f, 0x27, 0xa1, 0xb6, 0x71, 0xd5, 0xf0, 0x9c, 0xce, 0xcf, + 0x76, 0xb9, 0x6a, 0x0c, 0xba, 0x9d, 0x2f, 0x1b, 0x9e, 0x3c, 0x7c, 0xf2, 0x81, 0x92, 0x87, 0xdf, + 0xd2, 0x93, 0x71, 0xa3, 0x2e, 0xd9, 0xa6, 0x29, 0x52, 0x8f, 0x29, 0xb8, 0x6f, 0xe9, 0x17, 0xe0, + 0x54, 0x3e, 0x5d, 0x75, 0xcf, 0xa5, 0xe9, 0x66, 0x5e, 0x81, 0xa9, 0xd4, 0xde, 0xa7, 0x4e, 0x26, + 0xb5, 0xf7, 0xe9, 0x63, 0x4f, 0xed, 0x7d, 0xe6, 0x04, 0x52, 0x7b, 0x3f, 0x72, 0x82, 0xa9, 0xbd, + 0x6f, 0x31, 0x23, 0x29, 0x1e, 0x8a, 0x49, 0x84, 0xca, 0x7e, 0x26, 0x27, 0x92, 0x59, 0x3a, 0x5e, + 0x13, 0xff, 0x38, 0x05, 0xc2, 0x31, 0xa9, 0x8c, 0x94, 0xe1, 0xd3, 0x0f, 0x21, 0x65, 0xf8, 0x7a, + 0x9c, 0x32, 0xfc, 0x6c, 0xfe, 0x54, 0x67, 0xb8, 0xd5, 0xe4, 0x24, 0x0a, 0xbf, 0xa5, 0x27, 0xf8, + 0x7e, 0xb4, 0x83, 0x26, 0x2c, 0x4b, 0xa0, 0xdc, 0x21, 0xad, 0xf7, 0xeb, 0x3c, 0xad, 0xf7, 0x63, + 0xf9, 0x27, 0x79, 0xf2, 0xba, 0x33, 0x92, 0x79, 0xd3, 0x7e, 0xa9, 0x50, 0xa6, 0x2c, 0x28, 0x78, + 0x4e, 0xbf, 0x54, 0x2c, 0xd4, 0x74, 0xbf, 0x14, 0x08, 0xc7, 0xa4, 0xec, 0x1f, 0x2a, 0xc0, 0xf9, + 0xce, 0xfb, 0x2d, 0x96, 0x92, 0x57, 0x62, 0xc3, 0x80, 0x84, 0x94, 0x9c, 0xbf, 0xd9, 0x62, 0xac, + 0x9e, 0x23, 0x33, 0x5e, 0x81, 0x49, 0xe5, 0x8f, 0xd3, 0x70, 0x6b, 0xfb, 0xeb, 0xf1, 0x33, 0x59, + 0xc5, 0x30, 0xa8, 0x26, 0x11, 0x70, 0xba, 0x0e, 0x5a, 0x80, 0x71, 0xa3, 0x70, 0xb5, 0x2c, 0xde, + 0x66, 0x71, 0x18, 0x6a, 0x13, 0x8c, 0x93, 0xf8, 0xf6, 0x97, 0x2c, 0x78, 0x24, 0x27, 0x27, 0x66, + 0xcf, 0x81, 0x07, 0xb7, 0x60, 0xbc, 0x65, 0x56, 0xed, 0x12, 0x2b, 0xd5, 0xc8, 0xbc, 0xa9, 0xfa, + 0x9a, 0x00, 0xe0, 0x24, 0x51, 0xfb, 0x67, 0x0b, 0x70, 0xae, 0xa3, 0x81, 0x29, 0xc2, 0x70, 0x66, + 0xbb, 0x19, 0x3a, 0x4b, 0x01, 0xa9, 0x13, 0x2f, 0x72, 0x9d, 0x46, 0xb5, 0x45, 0x6a, 0x9a, 0x9e, + 0x83, 0x59, 0x6a, 0x5e, 0x59, 0xab, 0x2e, 0xa4, 0x31, 0x70, 0x4e, 0x4d, 0xb4, 0x02, 0x28, 0x0d, + 0x11, 0x33, 0xcc, 0xc2, 0xcb, 0xa7, 0xe9, 0xe1, 0x8c, 0x1a, 0xe8, 0x43, 0x30, 0xaa, 0x0c, 0x57, + 0xb5, 0x19, 0x67, 0x07, 0x3b, 0xd6, 0x01, 0xd8, 0xc4, 0x43, 0x97, 0x79, 0x7e, 0x02, 0x91, 0xc9, + 0x42, 0x28, 0x45, 0xc6, 0x65, 0xf2, 0x01, 0x51, 0x8c, 0x75, 0x9c, 0xc5, 0x57, 0x7e, 0xfd, 0xf7, + 0xcf, 0xbf, 0xef, 0x37, 0x7f, 0xff, 0xfc, 0xfb, 0x7e, 0xe7, 0xf7, 0xcf, 0xbf, 0xef, 0x7b, 0xee, + 0x9f, 0xb7, 0x7e, 0xfd, 0xfe, 0x79, 0xeb, 0x37, 0xef, 0x9f, 0xb7, 0x7e, 0xe7, 0xfe, 0x79, 0xeb, + 0xf7, 0xee, 0x9f, 0xb7, 0xbe, 0xf0, 0x07, 0xe7, 0xdf, 0xf7, 0x09, 0x14, 0x87, 0xf2, 0x9c, 0xa7, + 0xb3, 0x33, 0xbf, 0x77, 0xf9, 0xff, 0x04, 0x00, 0x00, 0xff, 0xff, 0xd1, 0x15, 0x7f, 0x61, 0xe2, + 0x0a, 0x01, 0x00, } func (m *AWSElasticBlockStoreVolumeSource) Marshal() (dAtA []byte, err error) { @@ -19104,6 +19135,53 @@ func (m *TypedLocalObjectReference) MarshalToSizedBuffer(dAtA []byte) (int, erro return len(dAtA) - i, nil } +func (m *TypedObjectReference) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TypedObjectReference) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TypedObjectReference) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Namespace != nil { + i -= len(*m.Namespace) + copy(dAtA[i:], *m.Namespace) + i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Namespace))) + i-- + dAtA[i] = 0x22 + } + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x1a + i -= len(m.Kind) + copy(dAtA[i:], m.Kind) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind))) + i-- + dAtA[i] = 0x12 + if m.APIGroup != nil { + i -= len(*m.APIGroup) + copy(dAtA[i:], *m.APIGroup) + i = encodeVarintGenerated(dAtA, i, uint64(len(*m.APIGroup))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func (m *Volume) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -24280,6 +24358,27 @@ func (m *TypedLocalObjectReference) Size() (n int) { return n } +func (m *TypedObjectReference) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.APIGroup != nil { + l = len(*m.APIGroup) + n += 1 + l + sovGenerated(uint64(l)) + } + l = len(m.Kind) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + if m.Namespace != nil { + l = len(*m.Namespace) + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + func (m *Volume) Size() (n int) { if m == nil { return 0 @@ -26324,7 +26423,7 @@ func (this *PersistentVolumeClaimSpec) String() string { `StorageClassName:` + valueToStringGenerated(this.StorageClassName) + `,`, `VolumeMode:` + valueToStringGenerated(this.VolumeMode) + `,`, `DataSource:` + strings.Replace(this.DataSource.String(), "TypedLocalObjectReference", "TypedLocalObjectReference", 1) + `,`, - `DataSourceRef:` + strings.Replace(this.DataSourceRef.String(), "TypedLocalObjectReference", "TypedLocalObjectReference", 1) + `,`, + `DataSourceRef:` + strings.Replace(this.DataSourceRef.String(), "TypedObjectReference", "TypedObjectReference", 1) + `,`, `}`, }, "") return s @@ -27885,6 +27984,19 @@ func (this *TypedLocalObjectReference) String() string { }, "") return s } +func (this *TypedObjectReference) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TypedObjectReference{`, + `APIGroup:` + valueToStringGenerated(this.APIGroup) + `,`, + `Kind:` + fmt.Sprintf("%v", this.Kind) + `,`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Namespace:` + valueToStringGenerated(this.Namespace) + `,`, + `}`, + }, "") + return s +} func (this *Volume) String() string { if this == nil { return "nil" @@ -48189,7 +48301,7 @@ func (m *PersistentVolumeClaimSpec) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.DataSourceRef == nil { - m.DataSourceRef = &TypedLocalObjectReference{} + m.DataSourceRef = &TypedObjectReference{} } if err := m.DataSourceRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -66329,6 +66441,186 @@ func (m *TypedLocalObjectReference) Unmarshal(dAtA []byte) error { } return nil } +func (m *TypedObjectReference) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: TypedObjectReference: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TypedObjectReference: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field APIGroup", 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 := string(dAtA[iNdEx:postIndex]) + m.APIGroup = &s + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Kind", 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 + } + m.Kind = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", 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 + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Namespace", 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 := string(dAtA[iNdEx:postIndex]) + m.Namespace = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *Volume) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/staging/src/k8s.io/api/core/v1/generated.proto b/staging/src/k8s.io/api/core/v1/generated.proto index b33cdab3ea6..36ed2e2afaf 100644 --- a/staging/src/k8s.io/api/core/v1/generated.proto +++ b/staging/src/k8s.io/api/core/v1/generated.proto @@ -2711,30 +2711,37 @@ message PersistentVolumeClaimSpec { // * An existing PVC (PersistentVolumeClaim) // If the provisioner or an external controller can support the specified data source, // it will create a new volume based on the contents of the specified data source. - // If the AnyVolumeDataSource feature gate is enabled, this field will always have - // the same contents as the DataSourceRef field. + // When the AnyVolumeDataSource feature gate is enabled, dataSource contents will be copied to dataSourceRef, + // and dataSourceRef contents will be copied to dataSource when dataSourceRef.namespace is not specified. + // If the namespace is specified, then dataSourceRef will not be copied to dataSource. // +optional optional TypedLocalObjectReference dataSource = 7; // dataSourceRef specifies the object from which to populate the volume with data, if a non-empty - // volume is desired. This may be any local object from a non-empty API group (non + // volume is desired. This may be any object from a non-empty API group (non // core object) or a PersistentVolumeClaim object. // When this field is specified, volume binding will only succeed if the type of // the specified object matches some installed volume populator or dynamic // provisioner. - // This field will replace the functionality of the DataSource field and as such + // This field will replace the functionality of the dataSource field and as such // if both fields are non-empty, they must have the same value. For backwards - // compatibility, both fields (DataSource and DataSourceRef) will be set to the same + // compatibility, when namespace isn't specified in dataSourceRef, + // both fields (dataSource and dataSourceRef) will be set to the same // value automatically if one of them is empty and the other is non-empty. - // There are two important differences between DataSource and DataSourceRef: - // * While DataSource only allows two specific types of objects, DataSourceRef + // When namespace is specified in dataSourceRef, + // dataSource isn't set to the same value and must be empty. + // There are three important differences between dataSource and dataSourceRef: + // * While dataSource only allows two specific types of objects, dataSourceRef // allows any non-core object, as well as PersistentVolumeClaim objects. - // * While DataSource ignores disallowed values (dropping them), DataSourceRef + // * While dataSource ignores disallowed values (dropping them), dataSourceRef // preserves all values, and generates an error if a disallowed value is // specified. + // * While dataSource only allows local objects, dataSourceRef allows objects + // in any namespaces. // (Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled. + // (Alpha) Using the namespace field of dataSourceRef requires the CrossNamespaceVolumeDataSource feature gate to be enabled. // +optional - optional TypedLocalObjectReference dataSourceRef = 8; + optional TypedObjectReference dataSourceRef = 8; } // PersistentVolumeClaimStatus is the current status of a persistent volume claim. @@ -5563,6 +5570,27 @@ message TypedLocalObjectReference { optional string name = 3; } +message TypedObjectReference { + // APIGroup is the group for the resource being referenced. + // If APIGroup is not specified, the specified Kind must be in the core API group. + // For any other third-party types, APIGroup is required. + // +optional + optional string apiGroup = 1; + + // Kind is the type of resource being referenced + optional string kind = 2; + + // Name is the name of resource being referenced + optional string name = 3; + + // Namespace is the namespace of resource being referenced + // Note that when a namespace is specified, a gateway.networking.k8s.io/ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details. + // (Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled. + // +featureGate=CrossNamespaceVolumeDataSource + // +optional + optional string namespace = 4; +} + // Volume represents a named volume in a pod that may be accessed by any container in the pod. message Volume { // name of the volume. 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 1b3dc86e3e8..10db6717770 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 @@ -1311,8 +1311,8 @@ var map_PersistentVolumeClaimSpec = map[string]string{ "volumeName": "volumeName is the binding reference to the PersistentVolume backing this claim.", "storageClassName": "storageClassName is the 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.", - "dataSource": "dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. If the AnyVolumeDataSource feature gate is enabled, this field will always have the same contents as the DataSourceRef field.", - "dataSourceRef": "dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While DataSource ignores disallowed values (dropping them), DataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled.", + "dataSource": "dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. When the AnyVolumeDataSource feature gate is enabled, dataSource contents will be copied to dataSourceRef, and dataSourceRef contents will be copied to dataSource when dataSourceRef.namespace is not specified. If the namespace is specified, then dataSourceRef will not be copied to dataSource.", + "dataSourceRef": "dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the dataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, when namespace isn't specified in dataSourceRef, both fields (dataSource and dataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. When namespace is specified in dataSourceRef, dataSource isn't set to the same value and must be empty. There are three important differences between dataSource and dataSourceRef: * While dataSource only allows two specific types of objects, dataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While dataSource ignores disallowed values (dropping them), dataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n* While dataSource only allows local objects, dataSourceRef allows objects\n in any namespaces.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled. (Alpha) Using the namespace field of dataSourceRef requires the CrossNamespaceVolumeDataSource feature gate to be enabled.", } func (PersistentVolumeClaimSpec) SwaggerDoc() map[string]string { @@ -2437,6 +2437,17 @@ func (TypedLocalObjectReference) SwaggerDoc() map[string]string { return map_TypedLocalObjectReference } +var map_TypedObjectReference = map[string]string{ + "apiGroup": "APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.", + "kind": "Kind is the type of resource being referenced", + "name": "Name is the name of resource being referenced", + "namespace": "Namespace is the namespace of resource being referenced Note that when a namespace is specified, a gateway.networking.k8s.io/ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details. (Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled.", +} + +func (TypedObjectReference) SwaggerDoc() map[string]string { + return map_TypedObjectReference +} + var map_Volume = map[string]string{ "": "Volume represents a named volume in a pod that may be accessed by any container in the pod.", "name": "name of the volume. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names", 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 9c6759d040b..59efcdf216e 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 @@ -2963,7 +2963,7 @@ func (in *PersistentVolumeClaimSpec) DeepCopyInto(out *PersistentVolumeClaimSpec } if in.DataSourceRef != nil { in, out := &in.DataSourceRef, &out.DataSourceRef - *out = new(TypedLocalObjectReference) + *out = new(TypedObjectReference) (*in).DeepCopyInto(*out) } return @@ -5729,6 +5729,32 @@ func (in *TypedLocalObjectReference) DeepCopy() *TypedLocalObjectReference { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *TypedObjectReference) DeepCopyInto(out *TypedObjectReference) { + *out = *in + if in.APIGroup != nil { + in, out := &in.APIGroup, &out.APIGroup + *out = new(string) + **out = **in + } + if in.Namespace != nil { + in, out := &in.Namespace, &out.Namespace + *out = new(string) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TypedObjectReference. +func (in *TypedObjectReference) DeepCopy() *TypedObjectReference { + if in == nil { + return nil + } + out := new(TypedObjectReference) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *Volume) DeepCopyInto(out *Volume) { *out = *in diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.json b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.json index d2c30d50118..738a6262fe2 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.json +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.json @@ -465,7 +465,8 @@ "dataSourceRef": { "apiGroup": "apiGroupValue", "kind": "kindValue", - "name": "nameValue" + "name": "nameValue", + "namespace": "namespaceValue" } } } diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.pb b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.pb index 0031ce8bd0900fefc075a58b46661dba106dbc30..3be2f777dd84af352958295e170d8b5d82ef63cd 100644 GIT binary patch delta 88 zcmdnyd(3x&G~?2ZGO3JAZ#*YEiu*I&@YpDu!YK5~mFtrb7iV5#ZfaO!PHC#plg(bt px7k=bSh-qRK`I#MPwwY_#b`RYibs`8i4UZ(xF9ik^GqIDDF9;59n}B; delta 77 zcmX@+yUllkG~?8bGO3JAcRVKtiu*I2@YpDu!YK5}mFtlZ7iV5#ZfaO!PHC#pmCatv gx7k>KuyB240jXf@pWM&=icxiP6_4uX^*rKI05f+Q(EtDd diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.yaml index 88841e5f823..af8f209a00b 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.yaml @@ -965,6 +965,7 @@ spec: apiGroup: apiGroupValue kind: kindValue name: nameValue + namespace: namespaceValue resources: limits: limitsKey: "0" diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.Deployment.json b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.Deployment.json index a32f6acf114..dafac19bb22 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.Deployment.json +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.Deployment.json @@ -466,7 +466,8 @@ "dataSourceRef": { "apiGroup": "apiGroupValue", "kind": "kindValue", - "name": "nameValue" + "name": "nameValue", + "namespace": "namespaceValue" } } } diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.Deployment.pb b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.Deployment.pb index bdd62fc53d54009fd01e867ecc2edebcf5c86470..59bdf8abf2fbf8789f15ffb57f41ee1b6642aa67 100644 GIT binary patch delta 92 zcmX@?d)aq_4CBU)vZ;)$pFBAjg(lzU_GOm3;jvLJg;D5}E7vC>F3!Bf+|;ndoYGXG tC!2klZ?my>uyVDsf>bchpFD~C6{G3oS{_v{B|ebC;)2BF&2xCvr2xg`9^?Q3 delta 81 zcmccYd)Rk^4CBI$vZ;)$k32aTg(lzU_GOkj;jvLJg;D5{E7v0-F3!Bf+|;ndoYGXG lE1P|pZ?m!fVBz}80#d=)KY0@OD@N7HwLGeuH}NP+0RV?58_)m% diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.Deployment.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.Deployment.yaml index b0a3d1a20e8..c8151f68c4a 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.Deployment.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.Deployment.yaml @@ -973,6 +973,7 @@ spec: apiGroup: apiGroupValue kind: kindValue name: nameValue + namespace: namespaceValue resources: limits: limitsKey: "0" diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.json b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.json index 192d248ad80..1c8dce80b92 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.json +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.json @@ -467,7 +467,8 @@ "dataSourceRef": { "apiGroup": "apiGroupValue", "kind": "kindValue", - "name": "nameValue" + "name": "nameValue", + "namespace": "namespaceValue" } } } diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.pb b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.pb index 851de10a56b5268980c7b8d304e642981533c5cc..8b244cdd8f2fdb49e86779b3250519edb3e45956 100644 GIT binary patch delta 92 zcmez1)8IQnhVkA;*;Gc>wVoV|LX+=v`!Y-2@YpDq!YK5~mFtrb7iV5#ZfaO!PHC#p tlg+-&x7k=bSh-qRK`I#MPoBj6iqUj(EsrXf5+6umaY178<~cl9BmuLAA5j1R delta 81 zcmZqh{ope}hVk4+*;Gc>xt<)1LX+=v`!Y+N@YpDq!YK5}mFtlZ7iV5#ZfaO!PHC#p lmCe4)x7k>KuyB240jXf@pFD~C6{G6pS{~KSn|RJi0swY^96bO4 diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.yaml index 2ee51097e8a..7847af5aad7 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.yaml @@ -965,6 +965,7 @@ spec: apiGroup: apiGroupValue kind: kindValue name: nameValue + namespace: namespaceValue resources: limits: limitsKey: "0" 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 50d615bdb28..f2bcbc148f2 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 @@ -466,7 +466,8 @@ "dataSourceRef": { "apiGroup": "apiGroupValue", "kind": "kindValue", - "name": "nameValue" + "name": "nameValue", + "namespace": "namespaceValue" } } } @@ -1716,7 +1717,8 @@ "dataSourceRef": { "apiGroup": "apiGroupValue", "kind": "kindValue", - "name": "nameValue" + "name": "nameValue", + "namespace": "namespaceValue" } }, "status": { 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 b26d490e7467a24d44b53a191de0cd424df3d78e..98328c384bb2cb486f6757d6fb292be7dea1511d 100644 GIT binary patch delta 127 zcmX>V@+xG4EaUNwa;c20&jUCZg(g4X_GOm3;jvLZg;D5}E7vC>F3!Bf+|;ndoYGXG zC!774Z?my>uyVDsf>bchpWLDTiqUj(9gixP5+6umaY178=D9pAl1y9J@F|(3v4ar+ D{M9RU delta 105 zcmaDAaw=qkEaUQxa;c20#{)PRg(g4X_GOkj;jvLZg;D5{E7v0-F3!Bf+|;ndoYGXG uE1Uh8Z?m!fVBz}80#d=)KY51wD@N7Hbv&w@H}ljf@;+pO64UXJ&37477+IeOa4-r@HW2e;ys`NXV=AN2Cs(ddLR_4AiMgp^i8-aI zLQggaGv8)o?O^3ppjU9{tFoZHL delta 111 zcmaDKaz12&64UaK&37477+H@8a4-r@b`bMpJhAx>V=AN2BUi3RLR_4AiMgp^i8-aI zLRU5iGv8)o{lUWZl?AMav48Sh^;eSwX%YhFwUPmh5Hqw>EwDIRW2nykjmnM#N^HMcx0sj&x0QF delta 80 zcmX@@yW4ky0^`(;im8mucRaZ!Gm85$o$%PK&y~U`^vIR#kq{SWUSe))SYl3Ts?e3q i{>-=8Sbwl^ePsbFVeFqgh5Hqw>g0MJ)y-RY#H9dLuo~|G diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.yaml index ec5b8db2465..c86d3c7e23c 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.yaml @@ -965,6 +965,7 @@ spec: apiGroup: apiGroupValue kind: kindValue name: nameValue + namespace: namespaceValue resources: limits: limitsKey: "0" diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.json b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.json index c53c398186c..bdfdf88cb0c 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.json +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.json @@ -466,7 +466,8 @@ "dataSourceRef": { "apiGroup": "apiGroupValue", "kind": "kindValue", - "name": "nameValue" + "name": "nameValue", + "namespace": "namespaceValue" } } } diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.pb b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.pb index 36dd3fa1e17493a7d73b004109c69a57b2480d80..126c341520814158ba3f935a2c93e01748c061a6 100644 GIT binary patch delta 94 zcmX@%d&75vBGX3S&37167+F7gaxe-_))(_*ys`Nx=m@-q?JbF_ls1lPlLJAui6m#N5=d#GKMp vp(mSzm~XSOcCd1_vV!$6&YwJ;`xT?<f@;+pO64UXJ&37477+IeOa4-r@HW2e;ys`NXV=AN2Cs(ddLR_4AiMgp^i8-aI zLQggaGv8)o?O^3ppjU9{tFoZHL delta 111 zcmaDKaz12&64UaK&37477+H@8a4-r@b`bMpJhAx>V=AN2BUi3RLR_4AiMgp^i8-aI zLRU5iGv8)o{lUWZl?AMav48Sh^;eSVxGQji6w|E0%^Mg~7#X)tZe-MD`r-rTarAj{FbXh9Fi*ZH?#HUZXmr8@EH3oO ymFtlZ7iV5#ZfaO!PHC#pmCa9CZnLreVBz}80x_t6vKH^F$!~epHhb|kNC5!;z#~=w diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1.CronJob.yaml b/staging/src/k8s.io/api/testdata/HEAD/batch.v1.CronJob.yaml index c60f0e8a1a8..e463690b728 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/batch.v1.CronJob.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/batch.v1.CronJob.yaml @@ -1017,6 +1017,7 @@ spec: apiGroup: apiGroupValue kind: kindValue name: nameValue + namespace: namespaceValue resources: limits: limitsKey: "0" diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.json b/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.json index 10ed69cf8c8..814b4d0b20c 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.json +++ b/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.json @@ -490,7 +490,8 @@ "dataSourceRef": { "apiGroup": "apiGroupValue", "kind": "kindValue", - "name": "nameValue" + "name": "nameValue", + "namespace": "namespaceValue" } } } diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.pb b/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.pb index 812fb630a8248e4d8f6718ded701a1818c3e961c..622f1302dfabb0e3db94d0c9b696eb169b0d5355 100644 GIT binary patch delta 91 zcmZ4Ix6f~a7}FxZ&AMDEjEwUp*D^*h-S7bOgg&`)eG=m0%uCEo4NJ@^O%-~w*_Zh? n8*2wES1T(-!~DsUxL+}vPOjxqN2(XZd6QRWSloyiaCPmh6jiv^vRX$lMokYUSe)) ySYl3Ts?d|ouUKxgv39U>wX%Yh&!4Q%`-;(YvJ{^xml7XHVR1oX@@7lEHYotgqai^6 delta 89 zcmX>fxIb`$Jmaj53aN~YTPL?M>N0)t*{GPp$k;boiaCPmga?Qt^vIR#kq{SWUSe)) pSYl3Ts?e3quUKxgvHoD;`pN=U-alEN_Z6e+WGOz?&Hj81QUHrQ9*h70 diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.yaml b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.yaml index 0e638391c78..35ca72f8b0e 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.yaml @@ -1017,6 +1017,7 @@ spec: apiGroup: apiGroupValue kind: kindValue name: nameValue + namespace: namespaceValue resources: limits: limitsKey: "0" diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.json b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.json index d16516333c9..bc6fc0d6076 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.json +++ b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.json @@ -533,7 +533,8 @@ "dataSourceRef": { "apiGroup": "apiGroupValue", "kind": "kindValue", - "name": "nameValue" + "name": "nameValue", + "namespace": "namespaceValue" } } } diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.pb b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.pb index 5c48e2e2e5da5f008fd19cfc92ef283db074ef34..c12c0b1988daf705c57a51b1071710d93eeb027d 100644 GIT binary patch delta 99 zcmZn;m>e)cndz1P<^|j-j7%-QV488>hcN sY(Btpn~k-Dm8+E%qGA4IR^C^PrjtMLs&Xmufm9Y3Bqnd>=ldcF00^lg7XSbN delta 88 zcmbOn&>S#9ndz4Q<^|j-j7(pAz%*muhcd jY(Btpn~n7c3)fc`h=%^jth}!nRVRPoRo$%0_f8T3zHK0K diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.yaml b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.yaml index 81e4caf2fb9..3fc7398f5c1 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.yaml @@ -1014,6 +1014,7 @@ template: apiGroup: apiGroupValue kind: kindValue name: nameValue + namespace: namespaceValue resources: limits: limitsKey: "0" 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 886de6b3c29..2fcd9a1bc5f 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 @@ -80,7 +80,8 @@ "dataSourceRef": { "apiGroup": "apiGroupValue", "kind": "kindValue", - "name": "nameValue" + "name": "nameValue", + "namespace": "namespaceValue" } }, "status": { 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 4bc1dfec2e9d78e565bfd721d52f519e5af8a947..fb08edfee5b8f3d1a9509ccc2b5c862546f85a8f 100644 GIT binary patch delta 39 vcmX@Zc86_(662PQ%BhTu^Cx#QzG5_;?8~IerNoz)n44N$keEDqGSf}~4@(W5 delta 26 icmcb^c7|<&662DM%BhTu{gXQxUrqL5Qk%SzX)^$X5DC=) 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 2827b1444cc..f91c3e83f7e 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 @@ -43,6 +43,7 @@ spec: apiGroup: apiGroupValue kind: kindValue name: nameValue + namespace: namespaceValue resources: limits: limitsKey: "0" diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.json b/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.json index 3085dc6c7df..2cb051c418c 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.json +++ b/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.json @@ -407,7 +407,8 @@ "dataSourceRef": { "apiGroup": "apiGroupValue", "kind": "kindValue", - "name": "nameValue" + "name": "nameValue", + "namespace": "namespaceValue" } } } diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.pb b/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.pb index ee56d74ed9456a78700f04327243dea671264723..6453885b2c53814233f26975655e97dd34ce8706 100644 GIT binary patch delta 91 zcmbOfxF}F4+oG6(i<66~%ut9qAU{Q@CvbBHM+&3RCs(ddLR_4AiMgp^i8-aILQgh# rFy3Zk?O^3=oDvJvelQ&=I+ARwJ0j?dV delta 78 zcmZ1!I4Mvl+oG6(i<66~%ut9qAU{RuPr&93jub|rN3L9tgt$2K5_40-5_3vZg|2Mw gV7$%7`h$h*D+^c&WB=r{oUbNN;8NTCmTRjl0MINO3;+NC diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.yaml b/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.yaml index 4eb4c150db7..905e57cbf00 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.yaml @@ -921,6 +921,7 @@ spec: apiGroup: apiGroupValue kind: kindValue name: nameValue + namespace: namespaceValue resources: limits: limitsKey: "0" diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.json b/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.json index c01fc878411..e5dce99a8d2 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.json +++ b/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.json @@ -450,7 +450,8 @@ "dataSourceRef": { "apiGroup": "apiGroupValue", "kind": "kindValue", - "name": "nameValue" + "name": "nameValue", + "namespace": "namespaceValue" } } } diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.pb b/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.pb index 7340ab2b6f17150c5bc626d13a117eb26563af36..1d9d2c5c97debe2e6e9269a18dfc1bfb66057877 100644 GIT binary patch delta 84 zcmX@(eaCx(1k*n6%?*qxjEpxn*E6Ov3Vm|r`Xt1~nU|QG8kU$-nkw{U^Eam3Y^)uu jT&=7SmGdWCbH8FVo&29$l}m{aq_VgmF?q8qPrD=lBSIa= delta 71 zcmccPea3r&1k*b2%?*qxjEpBX*E6Ov3O#b=dL+cfnU|QG8kU$-nksZ<^Eam3Y^*<6 YxW2MLRQ6A{=6*H#AGg}(Xr4w%0LGpgod5s; diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.yaml b/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.yaml index 3deb4feebb9..7a87881ccf9 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.yaml @@ -954,6 +954,7 @@ template: apiGroup: apiGroupValue kind: kindValue name: nameValue + namespace: namespaceValue resources: limits: limitsKey: "0" diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.ReplicationController.json b/staging/src/k8s.io/api/testdata/HEAD/core.v1.ReplicationController.json index ad081b11b9a..345db29615d 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/core.v1.ReplicationController.json +++ b/staging/src/k8s.io/api/testdata/HEAD/core.v1.ReplicationController.json @@ -456,7 +456,8 @@ "dataSourceRef": { "apiGroup": "apiGroupValue", "kind": "kindValue", - "name": "nameValue" + "name": "nameValue", + "namespace": "namespaceValue" } } } diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.ReplicationController.pb b/staging/src/k8s.io/api/testdata/HEAD/core.v1.ReplicationController.pb index 930bc3937c3904d4a67f1e833536425c1d98c4ab..b9b57d85367eec0e6cc193999c2a537a7e8b5888 100644 GIT binary patch delta 102 zcmX@+bIoUh64N@L&1)G`7#aUg?qpPAys>!=V=AN2Cs(ddLR_4AiMgp^i8-aILQgg; xGv8)o?O^3njUb17rW>S=_HC$MUFc-o+y+1pvGM9jpKV diff --git a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.yaml b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.yaml index 86ec73ff845..c098bb447ae 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.yaml @@ -965,6 +965,7 @@ spec: apiGroup: apiGroupValue kind: kindValue name: nameValue + namespace: namespaceValue resources: limits: limitsKey: "0" diff --git a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.json b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.json index 9457abac502..fb690e084a7 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.json +++ b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.json @@ -466,7 +466,8 @@ "dataSourceRef": { "apiGroup": "apiGroupValue", "kind": "kindValue", - "name": "nameValue" + "name": "nameValue", + "namespace": "namespaceValue" } } } diff --git a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.pb b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.pb index 259dbb242c7fd4826a08eb6d7d58479cfe7d6dd6..329354d1c17ce5659d3229b985e89d9cecd0fa7e 100644 GIT binary patch delta 87 zcmccQ`^a~KI^))j8mWwo-zN7l1~J~){E#t~QRtH^*C!z^&b-9j)Ud>y(o~@*nS);t~o8ZeeX@R$**)WfIi0 gSOePz1^5IC^#rjgWB~z>lbs9dlVA)cv%L%@8ZS>9p8x;= diff --git a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.yaml b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.yaml index 2dbf7d1fa4d..9a075556187 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.yaml @@ -975,6 +975,7 @@ spec: apiGroup: apiGroupValue kind: kindValue name: nameValue + namespace: namespaceValue resources: limits: limitsKey: "0" diff --git a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.json b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.json index b7def761682..8a6ff2e3b17 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.json +++ b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.json @@ -467,7 +467,8 @@ "dataSourceRef": { "apiGroup": "apiGroupValue", "kind": "kindValue", - "name": "nameValue" + "name": "nameValue", + "namespace": "namespaceValue" } } } diff --git a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.pb b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.pb index 1f6d2971f627a9073bb11ac9c309a543dea1da78..fc81a5b932040b17f09b614352d66f1bbf1d6302 100644 GIT binary patch delta 87 zcmezE)9pJ!o$=mAjZ{X)wUhf8gBWjYe#n^0DD=sd>yr={XI^4%YFJ`UX{ykZ%@NGE r*;qSRxmsB_YNjwU&YwJ&`xT?<S);t~o8ZeeX@R$**)WfIi0 gSOePz1^5IC^#rjgWB~z>lbs9dlVA)cv%L(?85|KC_y7O^ diff --git a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.yaml b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.yaml index 0363a415347..ac712f2ac99 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.yaml @@ -965,6 +965,7 @@ spec: apiGroup: apiGroupValue kind: kindValue name: nameValue + namespace: namespaceValue resources: limits: limitsKey: "0" diff --git a/staging/src/k8s.io/client-go/applyconfigurations/core/v1/persistentvolumeclaimspec.go b/staging/src/k8s.io/client-go/applyconfigurations/core/v1/persistentvolumeclaimspec.go index e22d04b0d59..f324584aba2 100644 --- a/staging/src/k8s.io/client-go/applyconfigurations/core/v1/persistentvolumeclaimspec.go +++ b/staging/src/k8s.io/client-go/applyconfigurations/core/v1/persistentvolumeclaimspec.go @@ -33,7 +33,7 @@ type PersistentVolumeClaimSpecApplyConfiguration struct { StorageClassName *string `json:"storageClassName,omitempty"` VolumeMode *v1.PersistentVolumeMode `json:"volumeMode,omitempty"` DataSource *TypedLocalObjectReferenceApplyConfiguration `json:"dataSource,omitempty"` - DataSourceRef *TypedLocalObjectReferenceApplyConfiguration `json:"dataSourceRef,omitempty"` + DataSourceRef *TypedObjectReferenceApplyConfiguration `json:"dataSourceRef,omitempty"` } // PersistentVolumeClaimSpecApplyConfiguration constructs an declarative configuration of the PersistentVolumeClaimSpec type for use with @@ -103,7 +103,7 @@ func (b *PersistentVolumeClaimSpecApplyConfiguration) WithDataSource(value *Type // WithDataSourceRef sets the DataSourceRef 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 DataSourceRef field is set to the value of the last call. -func (b *PersistentVolumeClaimSpecApplyConfiguration) WithDataSourceRef(value *TypedLocalObjectReferenceApplyConfiguration) *PersistentVolumeClaimSpecApplyConfiguration { +func (b *PersistentVolumeClaimSpecApplyConfiguration) WithDataSourceRef(value *TypedObjectReferenceApplyConfiguration) *PersistentVolumeClaimSpecApplyConfiguration { b.DataSourceRef = value return b } diff --git a/staging/src/k8s.io/client-go/applyconfigurations/core/v1/typedobjectreference.go b/staging/src/k8s.io/client-go/applyconfigurations/core/v1/typedobjectreference.go new file mode 100644 index 00000000000..d9a01c9c3a0 --- /dev/null +++ b/staging/src/k8s.io/client-go/applyconfigurations/core/v1/typedobjectreference.go @@ -0,0 +1,66 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1 + +// TypedObjectReferenceApplyConfiguration represents an declarative configuration of the TypedObjectReference type for use +// with apply. +type TypedObjectReferenceApplyConfiguration struct { + APIGroup *string `json:"apiGroup,omitempty"` + Kind *string `json:"kind,omitempty"` + Name *string `json:"name,omitempty"` + Namespace *string `json:"namespace,omitempty"` +} + +// TypedObjectReferenceApplyConfiguration constructs an declarative configuration of the TypedObjectReference type for use with +// apply. +func TypedObjectReference() *TypedObjectReferenceApplyConfiguration { + return &TypedObjectReferenceApplyConfiguration{} +} + +// WithAPIGroup sets the APIGroup 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 APIGroup field is set to the value of the last call. +func (b *TypedObjectReferenceApplyConfiguration) WithAPIGroup(value string) *TypedObjectReferenceApplyConfiguration { + b.APIGroup = &value + return b +} + +// WithKind sets the Kind 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 Kind field is set to the value of the last call. +func (b *TypedObjectReferenceApplyConfiguration) WithKind(value string) *TypedObjectReferenceApplyConfiguration { + b.Kind = &value + return b +} + +// WithName sets the Name 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 Name field is set to the value of the last call. +func (b *TypedObjectReferenceApplyConfiguration) WithName(value string) *TypedObjectReferenceApplyConfiguration { + b.Name = &value + return b +} + +// WithNamespace sets the Namespace 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 Namespace field is set to the value of the last call. +func (b *TypedObjectReferenceApplyConfiguration) WithNamespace(value string) *TypedObjectReferenceApplyConfiguration { + b.Namespace = &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 55f219ae459..88ec4532763 100644 --- a/staging/src/k8s.io/client-go/applyconfigurations/internal/internal.go +++ b/staging/src/k8s.io/client-go/applyconfigurations/internal/internal.go @@ -5544,7 +5544,7 @@ var schemaYAML = typed.YAMLObject(`types: namedType: io.k8s.api.core.v1.TypedLocalObjectReference - name: dataSourceRef type: - namedType: io.k8s.api.core.v1.TypedLocalObjectReference + namedType: io.k8s.api.core.v1.TypedObjectReference - name: resources type: namedType: io.k8s.api.core.v1.ResourceRequirements @@ -7133,6 +7133,23 @@ var schemaYAML = typed.YAMLObject(`types: scalar: string default: "" elementRelationship: atomic +- name: io.k8s.api.core.v1.TypedObjectReference + map: + fields: + - name: apiGroup + type: + scalar: string + - name: kind + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" + - name: namespace + type: + scalar: string - name: io.k8s.api.core.v1.Volume map: fields: diff --git a/staging/src/k8s.io/client-go/applyconfigurations/utils.go b/staging/src/k8s.io/client-go/applyconfigurations/utils.go index 1acc51af314..a72887b33c6 100644 --- a/staging/src/k8s.io/client-go/applyconfigurations/utils.go +++ b/staging/src/k8s.io/client-go/applyconfigurations/utils.go @@ -867,6 +867,8 @@ func ForKind(kind schema.GroupVersionKind) interface{} { return &applyconfigurationscorev1.TopologySpreadConstraintApplyConfiguration{} case corev1.SchemeGroupVersion.WithKind("TypedLocalObjectReference"): return &applyconfigurationscorev1.TypedLocalObjectReferenceApplyConfiguration{} + case corev1.SchemeGroupVersion.WithKind("TypedObjectReference"): + return &applyconfigurationscorev1.TypedObjectReferenceApplyConfiguration{} case corev1.SchemeGroupVersion.WithKind("Volume"): return &applyconfigurationscorev1.VolumeApplyConfiguration{} case corev1.SchemeGroupVersion.WithKind("VolumeDevice"):