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/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/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/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/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/features/kube_features.go b/pkg/features/kube_features.go index b2755dfca73..adfad5c6412 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/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/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/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.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/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 0031ce8bd09..3be2f777dd8 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.pb and b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.pb differ 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 bdd62fc53d5..59bdf8abf2f 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.Deployment.pb and b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.Deployment.pb differ 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 851de10a56b..8b244cdd8f2 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.pb and b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.pb differ 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 b26d490e746..98328c384bb 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.pb and b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.yaml index acd94c8d214..7d5e459b6e1 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.yaml @@ -973,6 +973,7 @@ spec: apiGroup: apiGroupValue kind: kindValue name: nameValue + namespace: namespaceValue resources: limits: limitsKey: "0" @@ -1184,6 +1185,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.v1beta1.Deployment.json b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.Deployment.json index a651d268f7f..c7c846ee8b8 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.Deployment.json +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.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/apps.v1beta1.Deployment.pb b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.Deployment.pb index 06eacb84b6d..56120ac8cf6 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.Deployment.pb and b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.Deployment.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.Deployment.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.Deployment.yaml index 4fd200b9bc0..a3a28763017 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.Deployment.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.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/apps.v1beta1.StatefulSet.json b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.json index c12c903aa34..ed6bc5ea22c 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.json +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.json @@ -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.v1beta1.StatefulSet.pb b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.pb index 710c5530b3a..a21cff7a91c 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.pb and b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.yaml index 20087374182..e7accde44a8 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.yaml @@ -973,6 +973,7 @@ spec: apiGroup: apiGroupValue kind: kindValue name: nameValue + namespace: namespaceValue resources: limits: limitsKey: "0" @@ -1184,6 +1185,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.DaemonSet.json b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.json index b0a8ab9fc57..e688d3dc2f4 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.json +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.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.v1beta2.DaemonSet.pb b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.pb index ae5da05a928..85a4a42dde5 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.pb and b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.pb differ 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 36dd3fa1e17..126c3415208 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.pb and b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.yaml index 3c448d2fe6b..25961b6f6fc 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.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.v1beta2.ReplicaSet.json b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.ReplicaSet.json index b3286c0cbe0..27c85a19150 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.ReplicaSet.json +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.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.v1beta2.ReplicaSet.pb b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.ReplicaSet.pb index 6d274496fb8..779c5aff486 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.ReplicaSet.pb and b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.ReplicaSet.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.ReplicaSet.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.ReplicaSet.yaml index 8d017573fbc..cb7a2832753 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.ReplicaSet.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.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.v1beta2.StatefulSet.json b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.json index 24deb7ba35f..8cad36c601a 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.json +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.json @@ -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.v1beta2.StatefulSet.pb b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.pb index b11288d69a5..6835199453e 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.pb and b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.yaml index f514ca0291f..417a6e08333 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.yaml @@ -973,6 +973,7 @@ spec: apiGroup: apiGroupValue kind: kindValue name: nameValue + namespace: namespaceValue resources: limits: limitsKey: "0" @@ -1184,6 +1185,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.CronJob.json b/staging/src/k8s.io/api/testdata/HEAD/batch.v1.CronJob.json index 4272a886010..f8924f0deb4 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/batch.v1.CronJob.json +++ b/staging/src/k8s.io/api/testdata/HEAD/batch.v1.CronJob.json @@ -539,7 +539,8 @@ "dataSourceRef": { "apiGroup": "apiGroupValue", "kind": "kindValue", - "name": "nameValue" + "name": "nameValue", + "namespace": "namespaceValue" } } } diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1.CronJob.pb b/staging/src/k8s.io/api/testdata/HEAD/batch.v1.CronJob.pb index 9f94363a9f7..ffe76eb932d 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/batch.v1.CronJob.pb and b/staging/src/k8s.io/api/testdata/HEAD/batch.v1.CronJob.pb differ 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 812fb630a82..622f1302dfa 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.pb and b/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.yaml b/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.yaml index 2c54eda338a..7985d12e991 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.yaml @@ -981,6 +981,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.CronJob.json b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.json index 43ca3d6052f..8f038e7a26b 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.json +++ b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.json @@ -539,7 +539,8 @@ "dataSourceRef": { "apiGroup": "apiGroupValue", "kind": "kindValue", - "name": "nameValue" + "name": "nameValue", + "namespace": "namespaceValue" } } } diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.pb b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.pb index 9943f47c579..98ada33e7e4 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.pb and b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.pb differ 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 5c48e2e2e5d..c12c0b1988d 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.pb and b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.pb differ 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 4bc1dfec2e9..fb08edfee5b 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/core.v1.PersistentVolumeClaim.pb and b/staging/src/k8s.io/api/testdata/HEAD/core.v1.PersistentVolumeClaim.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.PersistentVolumeClaim.yaml b/staging/src/k8s.io/api/testdata/HEAD/core.v1.PersistentVolumeClaim.yaml index 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 ee56d74ed94..6453885b2c5 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.pb and b/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.pb differ 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 7340ab2b6f1..1d9d2c5c97d 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.pb and b/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.pb differ 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 930bc3937c3..b9b57d85367 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/core.v1.ReplicationController.pb and b/staging/src/k8s.io/api/testdata/HEAD/core.v1.ReplicationController.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.ReplicationController.yaml b/staging/src/k8s.io/api/testdata/HEAD/core.v1.ReplicationController.yaml index c0b46d39287..d5c3711da15 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/core.v1.ReplicationController.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/core.v1.ReplicationController.yaml @@ -959,6 +959,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.DaemonSet.json b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.json index 248226989b9..2ae4e1a61a9 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.json +++ b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.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/extensions.v1beta1.DaemonSet.pb b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.pb index d7aac25d57f..25a7c5d2629 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.pb and b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.pb differ 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 259dbb242c7..329354d1c17 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.pb and b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.pb differ 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 1f6d2971f62..fc81a5b9320 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.pb and b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.pb differ 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"): 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(), }