From d5d3c26337af418555fe6f62f86b9aaf38dc59d3 Mon Sep 17 00:00:00 2001 From: Kensei Nakada Date: Sun, 26 Feb 2023 04:25:59 +0000 Subject: [PATCH] feature(scheduler): implement matchLabelKeys in PodAffinity and PodAntiAffinity --- api/openapi-spec/swagger.json | 18 +- api/openapi-spec/v3/api__v1_openapi.json | 20 +- .../v3/apis__apps__v1_openapi.json | 20 +- .../v3/apis__batch__v1_openapi.json | 20 +- pkg/api/pod/util.go | 85 +- pkg/api/pod/util_test.go | 857 ++++++- pkg/apis/core/types.go | 19 + pkg/apis/core/v1/zz_generated.conversion.go | 4 + pkg/apis/core/validation/validation.go | 83 +- pkg/apis/core/validation/validation_test.go | 717 +++++- pkg/apis/core/zz_generated.deepcopy.go | 10 + pkg/features/kube_features.go | 9 + pkg/generated/openapi/zz_generated.openapi.go | 42 +- pkg/registry/core/pod/strategy.go | 51 + pkg/registry/core/pod/strategy_test.go | 359 +++ .../src/k8s.io/api/core/v1/generated.pb.go | 1990 +++++++++-------- .../src/k8s.io/api/core/v1/generated.proto | 27 + staging/src/k8s.io/api/core/v1/types.go | 25 + .../core/v1/types_swagger_doc_generated.go | 4 +- .../api/core/v1/zz_generated.deepcopy.go | 10 + .../api/testdata/HEAD/apps.v1.DaemonSet.json | 32 +- .../api/testdata/HEAD/apps.v1.DaemonSet.pb | Bin 10256 -> 10436 bytes .../api/testdata/HEAD/apps.v1.DaemonSet.yaml | 16 + .../api/testdata/HEAD/apps.v1.Deployment.json | 32 +- .../api/testdata/HEAD/apps.v1.Deployment.pb | Bin 10269 -> 10449 bytes .../api/testdata/HEAD/apps.v1.Deployment.yaml | 16 + .../api/testdata/HEAD/apps.v1.ReplicaSet.json | 32 +- .../api/testdata/HEAD/apps.v1.ReplicaSet.pb | Bin 10186 -> 10366 bytes .../api/testdata/HEAD/apps.v1.ReplicaSet.yaml | 16 + .../testdata/HEAD/apps.v1.StatefulSet.json | 32 +- .../api/testdata/HEAD/apps.v1.StatefulSet.pb | Bin 11233 -> 11413 bytes .../testdata/HEAD/apps.v1.StatefulSet.yaml | 16 + .../HEAD/apps.v1beta1.Deployment.json | 32 +- .../testdata/HEAD/apps.v1beta1.Deployment.pb | Bin 10278 -> 10458 bytes .../HEAD/apps.v1beta1.Deployment.yaml | 16 + .../HEAD/apps.v1beta1.StatefulSet.json | 32 +- .../testdata/HEAD/apps.v1beta1.StatefulSet.pb | Bin 11238 -> 11418 bytes .../HEAD/apps.v1beta1.StatefulSet.yaml | 16 + .../testdata/HEAD/apps.v1beta2.DaemonSet.json | 32 +- .../testdata/HEAD/apps.v1beta2.DaemonSet.pb | Bin 10261 -> 10441 bytes .../testdata/HEAD/apps.v1beta2.DaemonSet.yaml | 16 + .../HEAD/apps.v1beta2.Deployment.json | 32 +- .../testdata/HEAD/apps.v1beta2.Deployment.pb | Bin 10274 -> 10454 bytes .../HEAD/apps.v1beta2.Deployment.yaml | 16 + .../HEAD/apps.v1beta2.ReplicaSet.json | 32 +- .../testdata/HEAD/apps.v1beta2.ReplicaSet.pb | Bin 10191 -> 10371 bytes .../HEAD/apps.v1beta2.ReplicaSet.yaml | 16 + .../HEAD/apps.v1beta2.StatefulSet.json | 32 +- .../testdata/HEAD/apps.v1beta2.StatefulSet.pb | Bin 11238 -> 11418 bytes .../HEAD/apps.v1beta2.StatefulSet.yaml | 16 + .../api/testdata/HEAD/batch.v1.CronJob.json | 32 +- .../api/testdata/HEAD/batch.v1.CronJob.pb | Bin 10803 -> 10983 bytes .../api/testdata/HEAD/batch.v1.CronJob.yaml | 16 + .../api/testdata/HEAD/batch.v1.Job.json | 32 +- .../k8s.io/api/testdata/HEAD/batch.v1.Job.pb | Bin 10429 -> 10609 bytes .../api/testdata/HEAD/batch.v1.Job.yaml | 16 + .../testdata/HEAD/batch.v1beta1.CronJob.json | 32 +- .../testdata/HEAD/batch.v1beta1.CronJob.pb | Bin 10808 -> 10988 bytes .../testdata/HEAD/batch.v1beta1.CronJob.yaml | 16 + .../k8s.io/api/testdata/HEAD/core.v1.Pod.json | 32 +- .../k8s.io/api/testdata/HEAD/core.v1.Pod.pb | Bin 11043 -> 11223 bytes .../k8s.io/api/testdata/HEAD/core.v1.Pod.yaml | 16 + .../testdata/HEAD/core.v1.PodTemplate.json | 32 +- .../api/testdata/HEAD/core.v1.PodTemplate.pb | Bin 10022 -> 10202 bytes .../testdata/HEAD/core.v1.PodTemplate.yaml | 16 + .../HEAD/core.v1.ReplicationController.json | 32 +- .../HEAD/core.v1.ReplicationController.pb | Bin 10144 -> 10324 bytes .../HEAD/core.v1.ReplicationController.yaml | 16 + .../HEAD/extensions.v1beta1.DaemonSet.json | 32 +- .../HEAD/extensions.v1beta1.DaemonSet.pb | Bin 10269 -> 10449 bytes .../HEAD/extensions.v1beta1.DaemonSet.yaml | 16 + .../HEAD/extensions.v1beta1.Deployment.json | 32 +- .../HEAD/extensions.v1beta1.Deployment.pb | Bin 10284 -> 10464 bytes .../HEAD/extensions.v1beta1.Deployment.yaml | 16 + .../HEAD/extensions.v1beta1.ReplicaSet.json | 32 +- .../HEAD/extensions.v1beta1.ReplicaSet.pb | Bin 10197 -> 10377 bytes .../HEAD/extensions.v1beta1.ReplicaSet.yaml | 16 + .../core/v1/podaffinityterm.go | 22 + .../applyconfigurations/internal/internal.go | 12 + .../scheduler/filters/filters_test.go | 345 ++- .../scheduler/scoring/priorities_test.go | 373 ++- 81 files changed, 4922 insertions(+), 1112 deletions(-) diff --git a/api/openapi-spec/swagger.json b/api/openapi-spec/swagger.json index ee18a296166..28710ce6c21 100644 --- a/api/openapi-spec/swagger.json +++ b/api/openapi-spec/swagger.json @@ -8354,7 +8354,23 @@ "properties": { "labelSelector": { "$ref": "#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector", - "description": "A label query over a set of resources, in this case pods." + "description": "A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm matches with no Pods." + }, + "matchLabelKeys": { + "description": "MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `LabelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both MatchLabelKeys and LabelSelector. Also, MatchLabelKeys cannot be set when LabelSelector isn't set. This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.", + "items": { + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "mismatchLabelKeys": { + "description": "MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `LabelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both MismatchLabelKeys and LabelSelector. Also, MismatchLabelKeys cannot be set when LabelSelector isn't set. This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.", + "items": { + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" }, "namespaceSelector": { "$ref": "#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector", diff --git a/api/openapi-spec/v3/api__v1_openapi.json b/api/openapi-spec/v3/api__v1_openapi.json index 647c8df9868..51176ef188f 100644 --- a/api/openapi-spec/v3/api__v1_openapi.json +++ b/api/openapi-spec/v3/api__v1_openapi.json @@ -4757,7 +4757,25 @@ "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" } ], - "description": "A label query over a set of resources, in this case pods." + "description": "A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm matches with no Pods." + }, + "matchLabelKeys": { + "description": "MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `LabelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both MatchLabelKeys and LabelSelector. Also, MatchLabelKeys cannot be set when LabelSelector isn't set. This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "mismatchLabelKeys": { + "description": "MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `LabelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both MismatchLabelKeys and LabelSelector. Also, MismatchLabelKeys cannot be set when LabelSelector isn't set. This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" }, "namespaceSelector": { "allOf": [ diff --git a/api/openapi-spec/v3/apis__apps__v1_openapi.json b/api/openapi-spec/v3/apis__apps__v1_openapi.json index f72d2ee2fcc..332cdf06352 100644 --- a/api/openapi-spec/v3/apis__apps__v1_openapi.json +++ b/api/openapi-spec/v3/apis__apps__v1_openapi.json @@ -3258,7 +3258,25 @@ "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" } ], - "description": "A label query over a set of resources, in this case pods." + "description": "A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm matches with no Pods." + }, + "matchLabelKeys": { + "description": "MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `LabelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both MatchLabelKeys and LabelSelector. Also, MatchLabelKeys cannot be set when LabelSelector isn't set. This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "mismatchLabelKeys": { + "description": "MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `LabelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both MismatchLabelKeys and LabelSelector. Also, MismatchLabelKeys cannot be set when LabelSelector isn't set. This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" }, "namespaceSelector": { "allOf": [ diff --git a/api/openapi-spec/v3/apis__batch__v1_openapi.json b/api/openapi-spec/v3/apis__batch__v1_openapi.json index 5fa450ccdaf..98e92af3379 100644 --- a/api/openapi-spec/v3/apis__batch__v1_openapi.json +++ b/api/openapi-spec/v3/apis__batch__v1_openapi.json @@ -2449,7 +2449,25 @@ "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" } ], - "description": "A label query over a set of resources, in this case pods." + "description": "A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm matches with no Pods." + }, + "matchLabelKeys": { + "description": "MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `LabelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both MatchLabelKeys and LabelSelector. Also, MatchLabelKeys cannot be set when LabelSelector isn't set. This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, + "mismatchLabelKeys": { + "description": "MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `LabelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both MismatchLabelKeys and LabelSelector. Also, MismatchLabelKeys cannot be set when LabelSelector isn't set. This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.", + "items": { + "default": "", + "type": "string" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" }, "namespaceSelector": { "allOf": [ diff --git a/pkg/api/pod/util.go b/pkg/api/pod/util.go index 64bcef12c74..e9ca7c271d5 100644 --- a/pkg/api/pod/util.go +++ b/pkg/api/pod/util.go @@ -534,7 +534,8 @@ func dropDisabledFields( dropDisabledTopologySpreadConstraintsFields(podSpec, oldPodSpec) dropDisabledNodeInclusionPolicyFields(podSpec, oldPodSpec) - dropDisabledMatchLabelKeysField(podSpec, oldPodSpec) + dropDisabledMatchLabelKeysFieldInTopologySpread(podSpec, oldPodSpec) + dropDisabledMatchLabelKeysFieldInPodAffinity(podSpec, oldPodSpec) dropDisabledDynamicResourceAllocationFields(podSpec, oldPodSpec) if !utilfeature.DefaultFeatureGate.Enabled(features.InPlacePodVerticalScaling) && !inPlacePodVerticalScalingInUse(oldPodSpec) { @@ -752,19 +753,89 @@ func dropDisabledNodeInclusionPolicyFields(podSpec, oldPodSpec *api.PodSpec) { } } -// dropDisabledMatchLabelKeysField removes disabled fields from PodSpec related -// to MatchLabelKeys only if it is not already used by the old spec. -func dropDisabledMatchLabelKeysField(podSpec, oldPodSpec *api.PodSpec) { - if !utilfeature.DefaultFeatureGate.Enabled(features.MatchLabelKeysInPodTopologySpread) && !matchLabelKeysInUse(oldPodSpec) { +// dropDisabledMatchLabelKeysFieldInPodAffinity removes disabled fields from PodSpec related +// to MatchLabelKeys in required/preferred PodAffinity/PodAntiAffinity only if it is not already used by the old spec. +func dropDisabledMatchLabelKeysFieldInPodAffinity(podSpec, oldPodSpec *api.PodSpec) { + if podSpec == nil || podSpec.Affinity == nil || utilfeature.DefaultFeatureGate.Enabled(features.MatchLabelKeysInPodAffinity) || matchLabelKeysFieldInPodAffinityInUse(oldPodSpec) { + return + } + + if affinity := podSpec.Affinity.PodAffinity; affinity != nil { + dropMatchLabelKeysFieldInPodAffnityTerm(affinity.RequiredDuringSchedulingIgnoredDuringExecution) + dropMatchLabelKeysFieldInWeightedPodAffnityTerm(affinity.PreferredDuringSchedulingIgnoredDuringExecution) + } + if antiaffinity := podSpec.Affinity.PodAntiAffinity; antiaffinity != nil { + dropMatchLabelKeysFieldInPodAffnityTerm(antiaffinity.RequiredDuringSchedulingIgnoredDuringExecution) + dropMatchLabelKeysFieldInWeightedPodAffnityTerm(antiaffinity.PreferredDuringSchedulingIgnoredDuringExecution) + } +} + +// dropDisabledMatchLabelKeysFieldInTopologySpread removes disabled fields from PodSpec related +// to MatchLabelKeys in TopologySpread only if it is not already used by the old spec. +func dropDisabledMatchLabelKeysFieldInTopologySpread(podSpec, oldPodSpec *api.PodSpec) { + if !utilfeature.DefaultFeatureGate.Enabled(features.MatchLabelKeysInPodTopologySpread) && !matchLabelKeysInTopologySpreadInUse(oldPodSpec) { for i := range podSpec.TopologySpreadConstraints { podSpec.TopologySpreadConstraints[i].MatchLabelKeys = nil } } } -// matchLabelKeysInUse returns true if the pod spec is non-nil +// dropMatchLabelKeysFieldInWeightedPodAffnityTerm removes MatchLabelKeys and MismatchLabelKeys fields from WeightedPodAffinityTerm +func dropMatchLabelKeysFieldInWeightedPodAffnityTerm(terms []api.WeightedPodAffinityTerm) { + for i := range terms { + terms[i].PodAffinityTerm.MatchLabelKeys = nil + terms[i].PodAffinityTerm.MismatchLabelKeys = nil + } +} + +// dropMatchLabelKeysFieldInPodAffnityTerm removes MatchLabelKeys and MismatchLabelKeys fields from PodAffinityTerm +func dropMatchLabelKeysFieldInPodAffnityTerm(terms []api.PodAffinityTerm) { + for i := range terms { + terms[i].MatchLabelKeys = nil + terms[i].MismatchLabelKeys = nil + } +} + +// matchLabelKeysFieldInPodAffinityInUse returns true if given affinityTerms have MatchLabelKeys field set. +func matchLabelKeysFieldInPodAffinityInUse(podSpec *api.PodSpec) bool { + if podSpec == nil || podSpec.Affinity == nil { + return false + } + + if affinity := podSpec.Affinity.PodAffinity; affinity != nil { + for _, c := range affinity.RequiredDuringSchedulingIgnoredDuringExecution { + if len(c.MatchLabelKeys) > 0 || len(c.MismatchLabelKeys) > 0 { + return true + } + } + + for _, c := range affinity.PreferredDuringSchedulingIgnoredDuringExecution { + if len(c.PodAffinityTerm.MatchLabelKeys) > 0 || len(c.PodAffinityTerm.MismatchLabelKeys) > 0 { + return true + } + } + } + + if antiAffinity := podSpec.Affinity.PodAntiAffinity; antiAffinity != nil { + for _, c := range antiAffinity.RequiredDuringSchedulingIgnoredDuringExecution { + if len(c.MatchLabelKeys) > 0 || len(c.MismatchLabelKeys) > 0 { + return true + } + } + + for _, c := range antiAffinity.PreferredDuringSchedulingIgnoredDuringExecution { + if len(c.PodAffinityTerm.MatchLabelKeys) > 0 || len(c.PodAffinityTerm.MismatchLabelKeys) > 0 { + return true + } + } + } + + return false +} + +// matchLabelKeysInTopologySpreadInUse returns true if the pod spec is non-nil // and has MatchLabelKeys field set in TopologySpreadConstraints. -func matchLabelKeysInUse(podSpec *api.PodSpec) bool { +func matchLabelKeysInTopologySpreadInUse(podSpec *api.PodSpec) bool { if podSpec == nil { return false } diff --git a/pkg/api/pod/util_test.go b/pkg/api/pod/util_test.go index 9e63215caf2..ec33d2009b5 100644 --- a/pkg/api/pod/util_test.go +++ b/pkg/api/pod/util_test.go @@ -1515,7 +1515,862 @@ func TestDropNodeInclusionPolicyFields(t *testing.T) { } } -func TestDropDisabledMatchLabelKeysField(t *testing.T) { +func Test_dropDisabledMatchLabelKeysFieldInPodAffinity(t *testing.T) { + tests := []struct { + name string + enabled bool + podSpec *api.PodSpec + oldPodSpec *api.PodSpec + wantPodSpec *api.PodSpec + }{ + { + name: "[PodAffinity/required] feature disabled, both pods don't use MatchLabelKeys/MismatchLabelKeys fields", + enabled: false, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{}, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{}, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{}, + }, + }, + }, + }, + { + name: "[PodAffinity/required] feature disabled, only old pod uses MatchLabelKeys/MismatchLabelKeys field", + enabled: false, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + {MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{}, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{}, + }, + }, + }, + }, + { + name: "[PodAffinity/required] feature disabled, only current pod uses MatchLabelKeys/MismatchLabelKeys field", + enabled: false, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{}, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + {MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{{}}, + }, + }, + }, + }, + { + name: "[PodAffinity/required] feature disabled, both pods use MatchLabelKeys/MismatchLabelKeys fields", + enabled: false, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + {MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + {MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + {MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + { + name: "[PodAffinity/required] feature enabled, only old pod uses MatchLabelKeys/MismatchLabelKeys field", + enabled: true, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + {MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{}, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{}, + }, + }, + }, + }, + { + name: "[PodAffinity/required] feature enabled, only current pod uses MatchLabelKeys/MismatchLabelKeys field", + enabled: true, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{}, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + {MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + {MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + { + name: "[PodAffinity/required] feature enabled, both pods use MatchLabelKeys/MismatchLabelKeys fields", + enabled: false, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + {MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + {MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + {MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + { + name: "[PodAffinity/preferred] feature disabled, both pods don't use MatchLabelKeys/MismatchLabelKeys fields", + enabled: false, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{}, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{}, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{}, + }, + }, + }, + }, + { + name: "[PodAffinity/preferred] feature disabled, only old pod uses MatchLabelKeys/MismatchLabelKeys field", + enabled: false, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{ + { + PodAffinityTerm: api.PodAffinityTerm{MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{}, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{}, + }, + }, + }, + }, + { + name: "[PodAffinity/preferred] feature disabled, only current pod uses MatchLabelKeys/MismatchLabelKeys field", + enabled: false, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{}, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{ + { + PodAffinityTerm: api.PodAffinityTerm{MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{{}}, + }, + }, + }, + }, + { + name: "[PodAffinity/preferred] feature disabled, both pods use MatchLabelKeys/MismatchLabelKeys fields", + enabled: false, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{ + { + PodAffinityTerm: api.PodAffinityTerm{MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{ + { + PodAffinityTerm: api.PodAffinityTerm{MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{ + { + PodAffinityTerm: api.PodAffinityTerm{MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + }, + { + name: "[PodAffinity/preferred] feature enabled, only old pod uses MatchLabelKeys/MismatchLabelKeys field", + enabled: true, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{ + { + PodAffinityTerm: api.PodAffinityTerm{MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{}, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{}, + }, + }, + }, + }, + { + name: "[PodAffinity/preferred] feature enabled, only current pod uses MatchLabelKeys/MismatchLabelKeys field", + enabled: true, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{}, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{ + { + PodAffinityTerm: api.PodAffinityTerm{MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{ + { + PodAffinityTerm: api.PodAffinityTerm{MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + }, + { + name: "[PodAffinity/preferred] feature enabled, both pods use MatchLabelKeys/MismatchLabelKeys fields", + enabled: false, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{ + { + PodAffinityTerm: api.PodAffinityTerm{MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{ + { + PodAffinityTerm: api.PodAffinityTerm{MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{ + { + PodAffinityTerm: api.PodAffinityTerm{MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + }, + { + name: "[PodAntiAffinity/required] feature disabled, both pods don't use MatchLabelKeys/MismatchLabelKeys fields", + enabled: false, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{}, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{}, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{}, + }, + }, + }, + }, + { + name: "[PodAntiAffinity/required] feature disabled, only old pod uses MatchLabelKeys/MismatchLabelKeys field", + enabled: false, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + {MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{}, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{}, + }, + }, + }, + }, + { + name: "[PodAntiAffinity/required] feature disabled, only current pod uses MatchLabelKeys/MismatchLabelKeys field", + enabled: false, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{}, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + {MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{{}}, + }, + }, + }, + }, + { + name: "[PodAntiAffinity/required] feature disabled, both pods use MatchLabelKeys/MismatchLabelKeys fields", + enabled: false, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + {MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + {MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + {MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + { + name: "[PodAntiAffinity/required] feature enabled, only old pod uses MatchLabelKeys/MismatchLabelKeys field", + enabled: true, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + {MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{}, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{}, + }, + }, + }, + }, + { + name: "[PodAntiAffinity/required] feature enabled, only current pod uses MatchLabelKeys/MismatchLabelKeys field", + enabled: true, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{}, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + {MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + {MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + { + name: "[PodAntiAffinity/required] feature enabled, both pods use MatchLabelKeys/MismatchLabelKeys fields", + enabled: false, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + {MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + {MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + {MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + + { + name: "[PodAntiAffinity/preferred] feature disabled, both pods don't use MatchLabelKeys/MismatchLabelKeys fields", + enabled: false, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{}, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{}, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{}, + }, + }, + }, + }, + { + name: "[PodAntiAffinity/preferred] feature disabled, only old pod uses MatchLabelKeys/MismatchLabelKeys field", + enabled: false, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{ + { + PodAffinityTerm: api.PodAffinityTerm{MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{}, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{}, + }, + }, + }, + }, + { + name: "[PodAntiAffinity/preferred] feature disabled, only current pod uses MatchLabelKeys/MismatchLabelKeys field", + enabled: false, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{}, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{ + { + PodAffinityTerm: api.PodAffinityTerm{MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{{}}, + }, + }, + }, + }, + { + name: "[PodAntiAffinity/preferred] feature disabled, both pods use MatchLabelKeys/MismatchLabelKeys fields", + enabled: false, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{ + { + PodAffinityTerm: api.PodAffinityTerm{MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{ + { + PodAffinityTerm: api.PodAffinityTerm{MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{ + { + PodAffinityTerm: api.PodAffinityTerm{MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + }, + { + name: "[PodAntiAffinity/preferred] feature enabled, only old pod uses MatchLabelKeys/MismatchLabelKeys field", + enabled: true, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{ + { + PodAffinityTerm: api.PodAffinityTerm{MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{}, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{}, + }, + }, + }, + }, + { + name: "[PodAntiAffinity/preferred] feature enabled, only current pod uses MatchLabelKeys/MismatchLabelKeys field", + enabled: true, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{}, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{ + { + PodAffinityTerm: api.PodAffinityTerm{MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{ + { + PodAffinityTerm: api.PodAffinityTerm{MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + }, + { + name: "[PodAntiAffinity/preferred] feature enabled, both pods use MatchLabelKeys/MismatchLabelKeys fields", + enabled: false, + oldPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{ + { + PodAffinityTerm: api.PodAffinityTerm{MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + podSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{ + { + PodAffinityTerm: api.PodAffinityTerm{MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + Affinity: &api.Affinity{ + PodAntiAffinity: &api.PodAntiAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{ + { + PodAffinityTerm: api.PodAffinityTerm{MatchLabelKeys: []string{"foo"}, MismatchLabelKeys: []string{"foo"}}, + }, + }, + }, + }, + }, + }, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.MatchLabelKeysInPodAffinity, test.enabled)() + + dropDisabledFields(test.podSpec, nil, test.oldPodSpec, nil) + if diff := cmp.Diff(test.wantPodSpec, test.podSpec); diff != "" { + t.Errorf("unexpected pod spec (-want, +got):\n%s", diff) + } + }) + } +} + +func Test_dropDisabledMatchLabelKeysFieldInTopologySpread(t *testing.T) { tests := []struct { name string enabled bool diff --git a/pkg/apis/core/types.go b/pkg/apis/core/types.go index b57618d9992..2a8abe5016b 100644 --- a/pkg/apis/core/types.go +++ b/pkg/apis/core/types.go @@ -2902,6 +2902,7 @@ type WeightedPodAffinityTerm struct { // a pod of the set of pods is running. type PodAffinityTerm struct { // A label query over a set of resources, in this case pods. + // If it's null, this PodAffinityTerm matches with no Pods. // +optional LabelSelector *metav1.LabelSelector // namespaces specifies a static list of namespace names that the term applies to. @@ -2923,6 +2924,24 @@ type PodAffinityTerm struct { // An empty selector ({}) matches all namespaces. // +optional NamespaceSelector *metav1.LabelSelector + // MatchLabelKeys is a set of pod label keys to select which pods will + // be taken into consideration. The keys are used to lookup values from the + // incoming pod labels, those key-value labels are merged with `LabelSelector` as `key in (value)` + // to select the group of existing pods which pods will be taken into consideration + // for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming + // pod labels will be ignored. The default value is empty. + // +listType=atomic + // +optional + MatchLabelKeys []string + // MismatchLabelKeys is a set of pod label keys to select which pods will + // be taken into consideration. The keys are used to lookup values from the + // incoming pod labels, those key-value labels are merged with `LabelSelector` as `key notin (value)` + // to select the group of existing pods which pods will be taken into consideration + // for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming + // pod labels will be ignored. The default value is empty. + // +listType=atomic + // +optional + MismatchLabelKeys []string } // NodeAffinity is a group of node affinity scheduling rules. diff --git a/pkg/apis/core/v1/zz_generated.conversion.go b/pkg/apis/core/v1/zz_generated.conversion.go index 63254aac6e4..f5eeabb4e67 100644 --- a/pkg/apis/core/v1/zz_generated.conversion.go +++ b/pkg/apis/core/v1/zz_generated.conversion.go @@ -5689,6 +5689,8 @@ func autoConvert_v1_PodAffinityTerm_To_core_PodAffinityTerm(in *v1.PodAffinityTe out.Namespaces = *(*[]string)(unsafe.Pointer(&in.Namespaces)) out.TopologyKey = in.TopologyKey out.NamespaceSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.NamespaceSelector)) + out.MatchLabelKeys = *(*[]string)(unsafe.Pointer(&in.MatchLabelKeys)) + out.MismatchLabelKeys = *(*[]string)(unsafe.Pointer(&in.MismatchLabelKeys)) return nil } @@ -5702,6 +5704,8 @@ func autoConvert_core_PodAffinityTerm_To_v1_PodAffinityTerm(in *core.PodAffinity out.Namespaces = *(*[]string)(unsafe.Pointer(&in.Namespaces)) out.TopologyKey = in.TopologyKey out.NamespaceSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.NamespaceSelector)) + out.MatchLabelKeys = *(*[]string)(unsafe.Pointer(&in.MatchLabelKeys)) + out.MismatchLabelKeys = *(*[]string)(unsafe.Pointer(&in.MismatchLabelKeys)) return nil } diff --git a/pkg/apis/core/validation/validation.go b/pkg/apis/core/validation/validation.go index 94978ee4452..e7c0a1b295d 100644 --- a/pkg/apis/core/validation/validation.go +++ b/pkg/apis/core/validation/validation.go @@ -4385,6 +4385,7 @@ func validatePodAffinityTerm(podAffinityTerm core.PodAffinityTerm, allowInvalidL allErrs = append(allErrs, field.Invalid(fldPath.Child("namespace"), name, msg)) } } + allErrs = append(allErrs, validateMatchLabelKeysAndMismatchLabelKeys(fldPath, podAffinityTerm.MatchLabelKeys, podAffinityTerm.MismatchLabelKeys, podAffinityTerm.LabelSelector)...) if len(podAffinityTerm.TopologyKey) == 0 { allErrs = append(allErrs, field.Required(fldPath.Child("topologyKey"), "can not be empty")) } @@ -4945,6 +4946,11 @@ func ValidatePodUpdate(newPod, oldPod *core.Pod, opts PodValidationOptions) fiel mungedPodSpec.Affinity.NodeAffinity = oldNodeAffinity // +k8s:verify-mutation:reason=clone } } + + // Note: Unlike NodeAffinity and NodeSelector, we cannot make PodAffinity/PodAntiAffinity mutable due to the presence of the matchLabelKeys/mismatchLabelKeys feature. + // Those features automatically generate the matchExpressions in labelSelector for PodAffinity/PodAntiAffinity when the Pod is created. + // When we make them mutable, we need to make sure things like how to handle/validate matchLabelKeys, + // and what if the fieldManager/A sets matchexpressions and fieldManager/B sets matchLabelKeys later. (could it lead the understandable conflict, etc) } if !apiequality.Semantic.DeepEqual(mungedPodSpec, oldPod.Spec) { @@ -7210,7 +7216,7 @@ func validateTopologySpreadConstraints(constraints []core.TopologySpreadConstrai if err := validateNodeInclusionPolicy(subFldPath.Child("nodeTaintsPolicy"), constraint.NodeTaintsPolicy); err != nil { allErrs = append(allErrs, err) } - allErrs = append(allErrs, validateMatchLabelKeys(subFldPath.Child("matchLabelKeys"), constraint.MatchLabelKeys, constraint.LabelSelector)...) + allErrs = append(allErrs, validateMatchLabelKeysInTopologySpread(subFldPath.Child("matchLabelKeys"), constraint.MatchLabelKeys, constraint.LabelSelector)...) if !opts.AllowInvalidTopologySpreadConstraintLabelSelector { allErrs = append(allErrs, unversionedvalidation.ValidateLabelSelector(constraint.LabelSelector, unversionedvalidation.LabelSelectorValidationOptions{AllowInvalidLabelValueInSelector: false}, subFldPath.Child("labelSelector"))...) } @@ -7287,8 +7293,60 @@ func validateNodeInclusionPolicy(fldPath *field.Path, policy *core.NodeInclusion return nil } -// validateMatchLabelKeys tests that the elements are a valid label name and are not already included in labelSelector. -func validateMatchLabelKeys(fldPath *field.Path, matchLabelKeys []string, labelSelector *metav1.LabelSelector) field.ErrorList { +// validateMatchLabelKeysAndMismatchLabelKeys checks if both matchLabelKeys and mismatchLabelKeys are valid. +// - validate that all matchLabelKeys and mismatchLabelKeys are valid label names. +// - validate that the user doens't specify the same key in both matchLabelKeys and labelSelector. +// - validate that any matchLabelKeys are not duplicated with mismatchLabelKeys. +func validateMatchLabelKeysAndMismatchLabelKeys(fldPath *field.Path, matchLabelKeys, mismatchLabelKeys []string, labelSelector *metav1.LabelSelector) field.ErrorList { + var allErrs field.ErrorList + // 1. validate that all matchLabelKeys and mismatchLabelKeys are valid label names. + allErrs = append(allErrs, validateLabelKeys(fldPath.Child("matchLabelKeys"), matchLabelKeys, labelSelector)...) + allErrs = append(allErrs, validateLabelKeys(fldPath.Child("mismatchLabelKeys"), mismatchLabelKeys, labelSelector)...) + + // 2. validate that the user doens't specify the same key in both matchLabelKeys and labelSelector. + // It doesn't make sense to have the labelselector with the key specified in matchLabelKeys + // because the matchLabelKeys will be `In` labelSelector which matches with only one value in the key + // and we cannot make any further filtering with that key. + // On the other hand, we may want to have labelSelector with the key specified in mismatchLabelKeys. + // because the mismatchLabelKeys will be `NotIn` labelSelector + // and we may want to filter Pods further with other labelSelector with that key. + + // labelKeysMap is keyed by label key and valued by the index of label key in labelKeys. + if labelSelector != nil { + labelKeysMap := map[string]int{} + for i, key := range matchLabelKeys { + labelKeysMap[key] = i + } + labelSelectorKeys := sets.New[string]() + for key := range labelSelector.MatchLabels { + labelSelectorKeys.Insert(key) + } + for _, matchExpression := range labelSelector.MatchExpressions { + key := matchExpression.Key + if i, ok := labelKeysMap[key]; ok && labelSelectorKeys.Has(key) { + // Before validateLabelKeysWithSelector is called, the labelSelector has already got the selector created from matchLabelKeys. + // Here, we found the duplicate key in labelSelector and the key is specified in labelKeys. + // Meaning that the same key is specified in both labelSelector and matchLabelKeys/mismatchLabelKeys. + allErrs = append(allErrs, field.Invalid(fldPath.Index(i), key, "exists in both matchLabelKeys and labelSelector")) + } + + labelSelectorKeys.Insert(key) + } + } + + // 3. validate that any matchLabelKeys are not duplicated with mismatchLabelKeys. + mismatchLabelKeysSet := sets.New(mismatchLabelKeys...) + for i, k := range matchLabelKeys { + if mismatchLabelKeysSet.Has(k) { + allErrs = append(allErrs, field.Invalid(fldPath.Child("matchLabelKeys").Index(i), k, "exists in both matchLabelKeys and mismatchLabelKeys")) + } + } + + return allErrs +} + +// validateMatchLabelKeysInTopologySpread tests that the elements are a valid label name and are not already included in labelSelector. +func validateMatchLabelKeysInTopologySpread(fldPath *field.Path, matchLabelKeys []string, labelSelector *metav1.LabelSelector) field.ErrorList { if len(matchLabelKeys) == 0 { return nil } @@ -7317,6 +7375,25 @@ func validateMatchLabelKeys(fldPath *field.Path, matchLabelKeys []string, labelS return allErrs } +// validateLabelKeys tests that the label keys are a valid label name. +// It's intended to be used for matchLabelKeys or mismatchLabelKeys. +func validateLabelKeys(fldPath *field.Path, labelKeys []string, labelSelector *metav1.LabelSelector) field.ErrorList { + if len(labelKeys) == 0 { + return nil + } + + if labelSelector == nil { + return field.ErrorList{field.Forbidden(fldPath, "must not be specified when labelSelector is not set")} + } + + var allErrs field.ErrorList + for i, key := range labelKeys { + allErrs = append(allErrs, unversionedvalidation.ValidateLabelName(key, fldPath.Index(i))...) + } + + return allErrs +} + // ValidateServiceClusterIPsRelatedFields validates .spec.ClusterIPs,, // .spec.IPFamilies, .spec.ipFamilyPolicy. This is exported because it is used // during IP init and allocation. diff --git a/pkg/apis/core/validation/validation_test.go b/pkg/apis/core/validation/validation_test.go index 36a8d17c6a3..eb2ca269e53 100644 --- a/pkg/apis/core/validation/validation_test.go +++ b/pkg/apis/core/validation/validation_test.go @@ -10198,7 +10198,206 @@ func TestValidatePod(t *testing.T) { DNSPolicy: core.DNSClusterFirst, }, }, + "MatchLabelKeys/MismatchLabelKeys in required PodAffinity": { + ObjectMeta: metav1.ObjectMeta{Name: "123", Namespace: "ns"}, + Spec: core.PodSpec{ + Containers: []core.Container{{Name: "ctr", Image: "image", ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: "File"}}, + RestartPolicy: core.RestartPolicyAlways, + DNSPolicy: core.DNSClusterFirst, + Affinity: &core.Affinity{ + PodAffinity: &core.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []core.PodAffinityTerm{ + { + LabelSelector: &metav1.LabelSelector{ + MatchExpressions: []metav1.LabelSelectorRequirement{ + { + Key: "key", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value1", "value2"}, + }, + { + Key: "key2", + Operator: metav1.LabelSelectorOpIn, + Values: []string{"value1"}, + }, + { + Key: "key3", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value1"}, + }, + }, + }, + TopologyKey: "k8s.io/zone", + MatchLabelKeys: []string{"key2"}, + MismatchLabelKeys: []string{"key3"}, + }, + }, + }, + }, + }, + }, + "MatchLabelKeys/MismatchLabelKeys in preferred PodAffinity": { + ObjectMeta: metav1.ObjectMeta{Name: "123", Namespace: "ns"}, + Spec: core.PodSpec{ + Containers: []core.Container{{Name: "ctr", Image: "image", ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: "File"}}, + RestartPolicy: core.RestartPolicyAlways, + DNSPolicy: core.DNSClusterFirst, + Affinity: &core.Affinity{ + PodAffinity: &core.PodAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []core.WeightedPodAffinityTerm{ + { + Weight: 10, + PodAffinityTerm: core.PodAffinityTerm{ + LabelSelector: &metav1.LabelSelector{ + MatchExpressions: []metav1.LabelSelectorRequirement{ + { + Key: "key", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value1", "value2"}, + }, + { + Key: "key2", + Operator: metav1.LabelSelectorOpIn, + Values: []string{"value1"}, + }, + { + Key: "key3", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value1"}, + }, + }, + }, + TopologyKey: "k8s.io/zone", + MatchLabelKeys: []string{"key2"}, + MismatchLabelKeys: []string{"key3"}, + }, + }, + }, + }, + }, + }, + }, + "MatchLabelKeys/MismatchLabelKeys in required PodAntiAffinity": { + ObjectMeta: metav1.ObjectMeta{Name: "123", Namespace: "ns"}, + Spec: core.PodSpec{ + Containers: []core.Container{{Name: "ctr", Image: "image", ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: "File"}}, + RestartPolicy: core.RestartPolicyAlways, + DNSPolicy: core.DNSClusterFirst, + Affinity: &core.Affinity{ + PodAntiAffinity: &core.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []core.PodAffinityTerm{ + { + LabelSelector: &metav1.LabelSelector{ + MatchExpressions: []metav1.LabelSelectorRequirement{ + { + Key: "key", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value1", "value2"}, + }, + { + Key: "key2", + Operator: metav1.LabelSelectorOpIn, + Values: []string{"value1"}, + }, + { + Key: "key3", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value1"}, + }, + }, + }, + TopologyKey: "k8s.io/zone", + MatchLabelKeys: []string{"key2"}, + MismatchLabelKeys: []string{"key3"}, + }, + }, + }, + }, + }, + }, + "MatchLabelKeys/MismatchLabelKeys in preferred PodAntiAffinity": { + ObjectMeta: metav1.ObjectMeta{Name: "123", Namespace: "ns"}, + Spec: core.PodSpec{ + Containers: []core.Container{{Name: "ctr", Image: "image", ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: "File"}}, + RestartPolicy: core.RestartPolicyAlways, + DNSPolicy: core.DNSClusterFirst, + Affinity: &core.Affinity{ + PodAntiAffinity: &core.PodAntiAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []core.WeightedPodAffinityTerm{ + { + Weight: 10, + PodAffinityTerm: core.PodAffinityTerm{ + LabelSelector: &metav1.LabelSelector{ + MatchExpressions: []metav1.LabelSelectorRequirement{ + { + Key: "key", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value1", "value2"}, + }, + { + Key: "key2", + Operator: metav1.LabelSelectorOpIn, + Values: []string{"value1"}, + }, + { + Key: "key3", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value1"}, + }, + }, + }, + TopologyKey: "k8s.io/zone", + MatchLabelKeys: []string{"key2"}, + MismatchLabelKeys: []string{"key3"}, + }, + }, + }, + }, + }, + }, + }, + "LabelSelector can have the same key as MismatchLabelKeys": { + // Note: On the contrary, in case of matchLabelKeys, keys in matchLabelKeys are not allowed to be specified in labelSelector by users. + ObjectMeta: metav1.ObjectMeta{Name: "123", Namespace: "ns"}, + Spec: core.PodSpec{ + Containers: []core.Container{{Name: "ctr", Image: "image", ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: "File"}}, + RestartPolicy: core.RestartPolicyAlways, + DNSPolicy: core.DNSClusterFirst, + Affinity: &core.Affinity{ + PodAffinity: &core.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []core.PodAffinityTerm{ + { + LabelSelector: &metav1.LabelSelector{ + MatchExpressions: []metav1.LabelSelectorRequirement{ + { + Key: "key", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value1", "value2"}, + }, + { + // This is the same key as in MismatchLabelKeys + // but it's allowed. + Key: "key2", + Operator: metav1.LabelSelectorOpIn, + Values: []string{"value1"}, + }, + { + Key: "key2", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value1"}, + }, + }, + }, + TopologyKey: "k8s.io/zone", + MismatchLabelKeys: []string{"key2"}, + }, + }, + }, + }, + }, + }, } + for k, v := range successCases { t.Run(k, func(t *testing.T) { if errs := ValidatePodCreate(&v, PodValidationOptions{}); len(errs) != 0 { @@ -10657,6 +10856,510 @@ func TestValidatePod(t *testing.T) { }), }, }, + "invalid soft pod affinity, key in MatchLabelKeys isn't correctly defined": { + expectedError: "prefix part must be non-empty", + spec: core.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: "123", + Namespace: "ns", + }, + Spec: validPodSpec(&core.Affinity{ + PodAffinity: &core.PodAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []core.WeightedPodAffinityTerm{ + { + Weight: 10, + PodAffinityTerm: core.PodAffinityTerm{ + LabelSelector: &metav1.LabelSelector{ + MatchExpressions: []metav1.LabelSelectorRequirement{ + { + Key: "key", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value1", "value2"}, + }, + }, + }, + TopologyKey: "k8s.io/zone", + MatchLabelKeys: []string{"/simple"}, + }, + }, + }, + }, + }), + }, + }, + "invalid hard pod affinity, key in MatchLabelKeys isn't correctly defined": { + expectedError: "prefix part must be non-empty", + spec: core.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: "123", + Namespace: "ns", + }, + Spec: validPodSpec(&core.Affinity{ + PodAffinity: &core.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []core.PodAffinityTerm{ + { + LabelSelector: &metav1.LabelSelector{ + MatchExpressions: []metav1.LabelSelectorRequirement{ + { + Key: "key", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value1", "value2"}, + }, + }, + }, + TopologyKey: "k8s.io/zone", + MatchLabelKeys: []string{"/simple"}, + }, + }, + }, + }), + }, + }, + "invalid soft pod anti-affinity, key in MatchLabelKeys isn't correctly defined": { + expectedError: "prefix part must be non-empty", + spec: core.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: "123", + Namespace: "ns", + }, + Spec: validPodSpec(&core.Affinity{ + PodAntiAffinity: &core.PodAntiAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []core.WeightedPodAffinityTerm{ + { + Weight: 10, + PodAffinityTerm: core.PodAffinityTerm{ + LabelSelector: &metav1.LabelSelector{ + MatchExpressions: []metav1.LabelSelectorRequirement{ + { + Key: "key", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value1", "value2"}, + }, + }, + }, + TopologyKey: "k8s.io/zone", + MatchLabelKeys: []string{"/simple"}, + }, + }, + }, + }, + }), + }, + }, + "invalid hard pod anti-affinity, key in MatchLabelKeys isn't correctly defined": { + expectedError: "prefix part must be non-empty", + spec: core.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: "123", + Namespace: "ns", + }, + Spec: validPodSpec(&core.Affinity{ + PodAntiAffinity: &core.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []core.PodAffinityTerm{ + { + LabelSelector: &metav1.LabelSelector{ + MatchExpressions: []metav1.LabelSelectorRequirement{ + { + Key: "key", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value1", "value2"}, + }, + }, + }, + TopologyKey: "k8s.io/zone", + MatchLabelKeys: []string{"/simple"}, + }, + }, + }, + }), + }, + }, + "invalid soft pod affinity, key in MismatchLabelKeys isn't correctly defined": { + expectedError: "prefix part must be non-empty", + spec: core.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: "123", + Namespace: "ns", + }, + Spec: validPodSpec(&core.Affinity{ + PodAffinity: &core.PodAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []core.WeightedPodAffinityTerm{ + { + Weight: 10, + PodAffinityTerm: core.PodAffinityTerm{ + LabelSelector: &metav1.LabelSelector{ + MatchExpressions: []metav1.LabelSelectorRequirement{ + { + Key: "key", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value1", "value2"}, + }, + }, + }, + TopologyKey: "k8s.io/zone", + MismatchLabelKeys: []string{"/simple"}, + }, + }, + }, + }, + }), + }, + }, + "invalid hard pod affinity, key in MismatchLabelKeys isn't correctly defined": { + expectedError: "prefix part must be non-empty", + spec: core.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: "123", + Namespace: "ns", + }, + Spec: validPodSpec(&core.Affinity{ + PodAffinity: &core.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []core.PodAffinityTerm{ + { + LabelSelector: &metav1.LabelSelector{ + MatchExpressions: []metav1.LabelSelectorRequirement{ + { + Key: "key", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value1", "value2"}, + }, + }, + }, + TopologyKey: "k8s.io/zone", + MismatchLabelKeys: []string{"/simple"}, + }, + }, + }, + }), + }, + }, + "invalid soft pod anti-affinity, key in MismatchLabelKeys isn't correctly defined": { + expectedError: "prefix part must be non-empty", + spec: core.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: "123", + Namespace: "ns", + }, + Spec: validPodSpec(&core.Affinity{ + PodAntiAffinity: &core.PodAntiAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []core.WeightedPodAffinityTerm{ + { + Weight: 10, + PodAffinityTerm: core.PodAffinityTerm{ + LabelSelector: &metav1.LabelSelector{ + MatchExpressions: []metav1.LabelSelectorRequirement{ + { + Key: "key", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value1", "value2"}, + }, + }, + }, + TopologyKey: "k8s.io/zone", + MismatchLabelKeys: []string{"/simple"}, + }, + }, + }, + }, + }), + }, + }, + "invalid hard pod anti-affinity, key in MismatchLabelKeys isn't correctly defined": { + expectedError: "prefix part must be non-empty", + spec: core.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: "123", + Namespace: "ns", + }, + Spec: validPodSpec(&core.Affinity{ + PodAntiAffinity: &core.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []core.PodAffinityTerm{ + { + LabelSelector: &metav1.LabelSelector{ + MatchExpressions: []metav1.LabelSelectorRequirement{ + { + Key: "key", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value1", "value2"}, + }, + }, + }, + TopologyKey: "k8s.io/zone", + MismatchLabelKeys: []string{"/simple"}, + }, + }, + }, + }), + }, + }, + "invalid soft pod affinity, key exists in both matchLabelKeys and labelSelector": { + expectedError: "exists in both matchLabelKeys and labelSelector", + spec: core.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: "123", + Namespace: "ns", + Labels: map[string]string{"key": "value1"}, + }, + Spec: validPodSpec(&core.Affinity{ + PodAffinity: &core.PodAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []core.WeightedPodAffinityTerm{ + { + Weight: 10, + PodAffinityTerm: core.PodAffinityTerm{ + LabelSelector: &metav1.LabelSelector{ + MatchExpressions: []metav1.LabelSelectorRequirement{ + // This one should be created from MatchLabelKeys. + { + Key: "key", + Operator: metav1.LabelSelectorOpIn, + Values: []string{"value1"}, + }, + { + Key: "key", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value2"}, + }, + }, + }, + TopologyKey: "k8s.io/zone", + MatchLabelKeys: []string{"key"}, + }, + }, + }, + }, + }), + }, + }, + "invalid hard pod affinity, key exists in both matchLabelKeys and labelSelector": { + expectedError: "exists in both matchLabelKeys and labelSelector", + spec: core.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: "123", + Namespace: "ns", + Labels: map[string]string{"key": "value1"}, + }, + Spec: validPodSpec(&core.Affinity{ + PodAffinity: &core.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []core.PodAffinityTerm{ + { + LabelSelector: &metav1.LabelSelector{ + MatchExpressions: []metav1.LabelSelectorRequirement{ + // This one should be created from MatchLabelKeys. + { + Key: "key", + Operator: metav1.LabelSelectorOpIn, + Values: []string{"value1"}, + }, + { + Key: "key", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value2"}, + }, + }, + }, + TopologyKey: "k8s.io/zone", + MatchLabelKeys: []string{"key"}, + }, + }, + }, + }), + }, + }, + "invalid soft pod anti-affinity, key exists in both matchLabelKeys and labelSelector": { + expectedError: "exists in both matchLabelKeys and labelSelector", + spec: core.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: "123", + Namespace: "ns", + Labels: map[string]string{"key": "value1"}, + }, + Spec: validPodSpec(&core.Affinity{ + PodAntiAffinity: &core.PodAntiAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []core.WeightedPodAffinityTerm{ + { + Weight: 10, + PodAffinityTerm: core.PodAffinityTerm{ + LabelSelector: &metav1.LabelSelector{ + MatchExpressions: []metav1.LabelSelectorRequirement{ + // This one should be created from MatchLabelKeys. + { + Key: "key", + Operator: metav1.LabelSelectorOpIn, + Values: []string{"value1"}, + }, + { + Key: "key", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value2"}, + }, + }, + }, + TopologyKey: "k8s.io/zone", + MatchLabelKeys: []string{"key"}, + }, + }, + }, + }, + }), + }, + }, + "invalid hard pod anti-affinity, key exists in both matchLabelKeys and labelSelector": { + expectedError: "exists in both matchLabelKeys and labelSelector", + spec: core.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: "123", + Namespace: "ns", + Labels: map[string]string{"key": "value1"}, + }, + Spec: validPodSpec(&core.Affinity{ + PodAntiAffinity: &core.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []core.PodAffinityTerm{ + { + LabelSelector: &metav1.LabelSelector{ + MatchExpressions: []metav1.LabelSelectorRequirement{ + // This one should be created from MatchLabelKeys. + { + Key: "key", + Operator: metav1.LabelSelectorOpIn, + Values: []string{"value1"}, + }, + { + Key: "key", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value2"}, + }, + }, + }, + TopologyKey: "k8s.io/zone", + MatchLabelKeys: []string{"key"}, + }, + }, + }, + }), + }, + }, + "invalid soft pod affinity, key exists in both MatchLabelKeys and MismatchLabelKeys": { + expectedError: "exists in both matchLabelKeys and mismatchLabelKeys", + spec: core.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: "123", + Namespace: "ns", + }, + Spec: validPodSpec(&core.Affinity{ + PodAffinity: &core.PodAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []core.WeightedPodAffinityTerm{ + { + Weight: 10, + PodAffinityTerm: core.PodAffinityTerm{ + LabelSelector: &metav1.LabelSelector{ + MatchExpressions: []metav1.LabelSelectorRequirement{ + { + Key: "key", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value1", "value2"}, + }, + }, + }, + TopologyKey: "k8s.io/zone", + MatchLabelKeys: []string{"samekey"}, + MismatchLabelKeys: []string{"samekey"}, + }, + }, + }, + }, + }), + }, + }, + "invalid hard pod affinity, key exists in both MatchLabelKeys and MismatchLabelKeys": { + expectedError: "exists in both matchLabelKeys and mismatchLabelKeys", + spec: core.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: "123", + Namespace: "ns", + }, + Spec: validPodSpec(&core.Affinity{ + PodAffinity: &core.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []core.PodAffinityTerm{ + { + LabelSelector: &metav1.LabelSelector{ + MatchExpressions: []metav1.LabelSelectorRequirement{ + { + Key: "key", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value1", "value2"}, + }, + }, + }, + TopologyKey: "k8s.io/zone", + MatchLabelKeys: []string{"samekey"}, + MismatchLabelKeys: []string{"samekey"}, + }, + }, + }, + }), + }, + }, + "invalid soft pod anti-affinity, key exists in both MatchLabelKeys and MismatchLabelKeys": { + expectedError: "exists in both matchLabelKeys and mismatchLabelKeys", + spec: core.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: "123", + Namespace: "ns", + }, + Spec: validPodSpec(&core.Affinity{ + PodAntiAffinity: &core.PodAntiAffinity{ + PreferredDuringSchedulingIgnoredDuringExecution: []core.WeightedPodAffinityTerm{ + { + Weight: 10, + PodAffinityTerm: core.PodAffinityTerm{ + LabelSelector: &metav1.LabelSelector{ + MatchExpressions: []metav1.LabelSelectorRequirement{ + { + Key: "key", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value1", "value2"}, + }, + }, + }, + TopologyKey: "k8s.io/zone", + MatchLabelKeys: []string{"samekey"}, + MismatchLabelKeys: []string{"samekey"}, + }, + }, + }, + }, + }), + }, + }, + "invalid hard pod anti-affinity, key exists in both MatchLabelKeys and MismatchLabelKeys": { + expectedError: "exists in both matchLabelKeys and mismatchLabelKeys", + spec: core.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: "123", + Namespace: "ns", + }, + Spec: validPodSpec(&core.Affinity{ + PodAntiAffinity: &core.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []core.PodAffinityTerm{ + { + LabelSelector: &metav1.LabelSelector{ + MatchExpressions: []metav1.LabelSelectorRequirement{ + { + Key: "key", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value1", "value2"}, + }, + }, + }, + TopologyKey: "k8s.io/zone", + MatchLabelKeys: []string{"samekey"}, + MismatchLabelKeys: []string{"samekey"}, + }, + }, + }, + }), + }, + }, "invalid toleration key": { expectedError: "spec.tolerations[0].key", spec: core.Pod{ @@ -11143,7 +11846,7 @@ func TestValidatePod(t *testing.T) { } for k, v := range errorCases { t.Run(k, func(t *testing.T) { - if errs := ValidatePodCreate(&v.spec, PodValidationOptions{AllowInvalidPodDeletionCost: false}); len(errs) == 0 { + if errs := ValidatePodCreate(&v.spec, PodValidationOptions{}); len(errs) == 0 { t.Errorf("expected failure") } else if v.expectedError == "" { t.Errorf("missing expectedError, got %q", errs.ToAggregate().Error()) @@ -21756,11 +22459,13 @@ func TestValidateTopologySpreadConstraints(t *testing.T) { WhenUnsatisfiable: core.DoNotSchedule, MatchLabelKeys: []string{"foo"}, LabelSelector: &metav1.LabelSelector{ - MatchExpressions: []metav1.LabelSelectorRequirement{{ - Key: "foo", - Operator: metav1.LabelSelectorOpNotIn, - Values: []string{"value1", "value2"}, - }}, + MatchExpressions: []metav1.LabelSelectorRequirement{ + { + Key: "foo", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"value1", "value2"}, + }, + }, }, }}, wantFieldErrors: field.ErrorList{field.Invalid(fieldPathMatchLabelKeys.Index(0), "foo", "exists in both matchLabelKeys and labelSelector")}, diff --git a/pkg/apis/core/zz_generated.deepcopy.go b/pkg/apis/core/zz_generated.deepcopy.go index 28111083744..01b597f46e2 100644 --- a/pkg/apis/core/zz_generated.deepcopy.go +++ b/pkg/apis/core/zz_generated.deepcopy.go @@ -3484,6 +3484,16 @@ func (in *PodAffinityTerm) DeepCopyInto(out *PodAffinityTerm) { *out = new(v1.LabelSelector) (*in).DeepCopyInto(*out) } + if in.MatchLabelKeys != nil { + in, out := &in.MatchLabelKeys, &out.MatchLabelKeys + *out = make([]string, len(*in)) + copy(*out, *in) + } + if in.MismatchLabelKeys != nil { + in, out := &in.MismatchLabelKeys, &out.MismatchLabelKeys + *out = make([]string, len(*in)) + copy(*out, *in) + } return } diff --git a/pkg/features/kube_features.go b/pkg/features/kube_features.go index cc45bde045b..10769906f29 100644 --- a/pkg/features/kube_features.go +++ b/pkg/features/kube_features.go @@ -488,6 +488,13 @@ const ( // Enables scaling down replicas via logarithmic comparison of creation/ready timestamps LogarithmicScaleDown featuregate.Feature = "LogarithmicScaleDown" + // owner: @sanposhiho + // kep: https://kep.k8s.io/3633 + // alpha: v1.29 + // + // Enables the MatchLabelKeys and MismatchLabelKeys in PodAffinity and PodAntiAffinity. + MatchLabelKeysInPodAffinity featuregate.Feature = "MatchLabelKeysInPodAffinity" + // owner: @denkensk // kep: https://kep.k8s.io/3243 // alpha: v1.25 @@ -1009,6 +1016,8 @@ var defaultKubernetesFeatureGates = map[featuregate.Feature]featuregate.FeatureS LogarithmicScaleDown: {Default: true, PreRelease: featuregate.Beta}, + MatchLabelKeysInPodAffinity: {Default: false, PreRelease: featuregate.Alpha}, + MatchLabelKeysInPodTopologySpread: {Default: true, PreRelease: featuregate.Beta}, MaxUnavailableStatefulSet: {Default: false, PreRelease: featuregate.Alpha}, diff --git a/pkg/generated/openapi/zz_generated.openapi.go b/pkg/generated/openapi/zz_generated.openapi.go index b8e37305b6e..2ac4d1b79b6 100644 --- a/pkg/generated/openapi/zz_generated.openapi.go +++ b/pkg/generated/openapi/zz_generated.openapi.go @@ -24089,7 +24089,7 @@ func schema_k8sio_api_core_v1_PodAffinityTerm(ref common.ReferenceCallback) comm Properties: map[string]spec.Schema{ "labelSelector": { SchemaProps: spec.SchemaProps{ - Description: "A label query over a set of resources, in this case pods.", + Description: "A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm matches with no Pods.", Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.LabelSelector"), }, }, @@ -24122,6 +24122,46 @@ func schema_k8sio_api_core_v1_PodAffinityTerm(ref common.ReferenceCallback) comm Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.LabelSelector"), }, }, + "matchLabelKeys": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-list-type": "atomic", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `LabelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both MatchLabelKeys and LabelSelector. Also, MatchLabelKeys cannot be set when LabelSelector isn't set. This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + "mismatchLabelKeys": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-list-type": "atomic", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `LabelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both MismatchLabelKeys and LabelSelector. Also, MismatchLabelKeys cannot be set when LabelSelector isn't set. This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, }, Required: []string{"topologyKey"}, }, diff --git a/pkg/registry/core/pod/strategy.go b/pkg/registry/core/pod/strategy.go index f638eb64e2e..c31ee7b0180 100644 --- a/pkg/registry/core/pod/strategy.go +++ b/pkg/registry/core/pod/strategy.go @@ -90,6 +90,7 @@ func (podStrategy) PrepareForCreate(ctx context.Context, obj runtime.Object) { podutil.DropDisabledPodFields(pod, nil) applyWaitingForSchedulingGatesCondition(pod) + mutatePodAffinity(pod) } // PrepareForUpdate clears fields that are not allowed to be set by end users on update. @@ -669,6 +670,56 @@ func validateContainer(container string, pod *api.Pod) (string, error) { return container, nil } +// applyLabelKeysToLabelSelector obtains the label value from the given label set by the key in labelKeys, +// and merge to LabelSelector with the given operator: +func applyLabelKeysToLabelSelector(labelSelector *metav1.LabelSelector, labelKeys []string, operator metav1.LabelSelectorOperator, podLabels map[string]string) { + for _, key := range labelKeys { + if value, ok := podLabels[key]; ok { + labelSelector.MatchExpressions = append(labelSelector.MatchExpressions, metav1.LabelSelectorRequirement{ + Key: key, + Operator: operator, + Values: []string{value}, + }) + } + } +} + +// applyMatchLabelKeysAndMismatchLabelKeys obtains the labels from the pod labels by the key in matchLabelKeys or mismatchLabelKeys, +// and merge to LabelSelector of PodAffinityTerm depending on field: +// - If matchLabelKeys, key in (value) is merged with LabelSelector. +// - If mismatchLabelKeys, key notin (value) is merged with LabelSelector. +func applyMatchLabelKeysAndMismatchLabelKeys(term *api.PodAffinityTerm, label map[string]string) { + if (len(term.MatchLabelKeys) == 0 && len(term.MismatchLabelKeys) == 0) || term.LabelSelector == nil { + // If LabelSelector is nil, we don't need to apply label keys to it because nil-LabelSelector is match none. + return + } + + applyLabelKeysToLabelSelector(term.LabelSelector, term.MatchLabelKeys, metav1.LabelSelectorOpIn, label) + applyLabelKeysToLabelSelector(term.LabelSelector, term.MismatchLabelKeys, metav1.LabelSelectorOpNotIn, label) +} + +func mutatePodAffinity(pod *api.Pod) { + if !utilfeature.DefaultFeatureGate.Enabled(features.MatchLabelKeysInPodAffinity) || pod.Spec.Affinity == nil { + return + } + if affinity := pod.Spec.Affinity.PodAffinity; affinity != nil { + for i := range affinity.PreferredDuringSchedulingIgnoredDuringExecution { + applyMatchLabelKeysAndMismatchLabelKeys(&affinity.PreferredDuringSchedulingIgnoredDuringExecution[i].PodAffinityTerm, pod.Labels) + } + for i := range affinity.RequiredDuringSchedulingIgnoredDuringExecution { + applyMatchLabelKeysAndMismatchLabelKeys(&affinity.RequiredDuringSchedulingIgnoredDuringExecution[i], pod.Labels) + } + } + if affinity := pod.Spec.Affinity.PodAntiAffinity; affinity != nil { + for i := range affinity.PreferredDuringSchedulingIgnoredDuringExecution { + applyMatchLabelKeysAndMismatchLabelKeys(&affinity.PreferredDuringSchedulingIgnoredDuringExecution[i].PodAffinityTerm, pod.Labels) + } + for i := range affinity.RequiredDuringSchedulingIgnoredDuringExecution { + applyMatchLabelKeysAndMismatchLabelKeys(&affinity.RequiredDuringSchedulingIgnoredDuringExecution[i], pod.Labels) + } + } +} + // applyWaitingForSchedulingGatesCondition adds a {type:PodScheduled, reason:WaitingForGates} condition // to a new-created Pod if necessary. func applyWaitingForSchedulingGatesCondition(pod *api.Pod) { diff --git a/pkg/registry/core/pod/strategy_test.go b/pkg/registry/core/pod/strategy_test.go index 76f589a1642..6317af86da6 100644 --- a/pkg/registry/core/pod/strategy_test.go +++ b/pkg/registry/core/pod/strategy_test.go @@ -1672,3 +1672,362 @@ func TestNodeInclusionPolicyEnablementInUpdating(t *testing.T) { t.Error("NodeInclusionPolicy updated with unexpected result") } } + +func Test_mutatePodAffinity(t *testing.T) { + tests := []struct { + name string + pod *api.Pod + wantPod *api.Pod + featureGateEnabled bool + }{ + { + name: "matchLabelKeys are merged into labelSelector with In and mismatchLabelKeys are merged with NotIn", + featureGateEnabled: true, + pod: &api.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + "country": "Japan", + "city": "Kyoto", + }, + }, + Spec: api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + { + LabelSelector: &metav1.LabelSelector{ + MatchLabels: map[string]string{ + "region": "Asia", + }, + }, + MatchLabelKeys: []string{"country"}, + MismatchLabelKeys: []string{"city"}, + }, + }, + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{ + { + PodAffinityTerm: api.PodAffinityTerm{ + LabelSelector: &metav1.LabelSelector{ + MatchLabels: map[string]string{ + "region": "Asia", + }, + }, + MatchLabelKeys: []string{"country"}, + MismatchLabelKeys: []string{"city"}, + }, + }, + }, + }, + PodAntiAffinity: &api.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + { + LabelSelector: &metav1.LabelSelector{ + MatchLabels: map[string]string{ + "region": "Asia", + }, + }, + MatchLabelKeys: []string{"country"}, + MismatchLabelKeys: []string{"city"}, + }, + }, + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{ + { + PodAffinityTerm: api.PodAffinityTerm{ + LabelSelector: &metav1.LabelSelector{ + MatchLabels: map[string]string{ + "region": "Asia", + }, + }, + MatchLabelKeys: []string{"country"}, + MismatchLabelKeys: []string{"city"}, + }, + }, + }, + }, + }, + }, + }, + wantPod: &api.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + "country": "Japan", + "city": "Kyoto", + }, + }, + Spec: api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + { + LabelSelector: &metav1.LabelSelector{ + MatchLabels: map[string]string{ + "region": "Asia", + }, + MatchExpressions: []metav1.LabelSelectorRequirement{ + { + Key: "country", + Operator: metav1.LabelSelectorOpIn, + Values: []string{"Japan"}, + }, + { + Key: "city", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"Kyoto"}, + }, + }, + }, + MatchLabelKeys: []string{"country"}, + MismatchLabelKeys: []string{"city"}, + }, + }, + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{ + { + PodAffinityTerm: api.PodAffinityTerm{ + LabelSelector: &metav1.LabelSelector{ + MatchLabels: map[string]string{ + "region": "Asia", + }, + MatchExpressions: []metav1.LabelSelectorRequirement{ + { + Key: "country", + Operator: metav1.LabelSelectorOpIn, + Values: []string{"Japan"}, + }, + { + Key: "city", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"Kyoto"}, + }, + }, + }, + MatchLabelKeys: []string{"country"}, + MismatchLabelKeys: []string{"city"}, + }, + }, + }, + }, + PodAntiAffinity: &api.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + { + LabelSelector: &metav1.LabelSelector{ + MatchLabels: map[string]string{ + "region": "Asia", + }, + MatchExpressions: []metav1.LabelSelectorRequirement{ + { + Key: "country", + Operator: metav1.LabelSelectorOpIn, + Values: []string{"Japan"}, + }, + { + Key: "city", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"Kyoto"}, + }, + }, + }, + MatchLabelKeys: []string{"country"}, + MismatchLabelKeys: []string{"city"}, + }, + }, + PreferredDuringSchedulingIgnoredDuringExecution: []api.WeightedPodAffinityTerm{ + { + PodAffinityTerm: api.PodAffinityTerm{ + LabelSelector: &metav1.LabelSelector{ + MatchLabels: map[string]string{ + "region": "Asia", + }, + MatchExpressions: []metav1.LabelSelectorRequirement{ + { + Key: "country", + Operator: metav1.LabelSelectorOpIn, + Values: []string{"Japan"}, + }, + { + Key: "city", + Operator: metav1.LabelSelectorOpNotIn, + Values: []string{"Kyoto"}, + }, + }, + }, + MatchLabelKeys: []string{"country"}, + MismatchLabelKeys: []string{"city"}, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "keys, which are not found in Pod labels, are ignored", + featureGateEnabled: true, + pod: &api.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + "country": "Japan", + "city": "Kyoto", + }, + }, + Spec: api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + { + LabelSelector: &metav1.LabelSelector{ + MatchLabels: map[string]string{ + "region": "Asia", + }, + }, + MatchLabelKeys: []string{"city", "not-found"}, + }, + }, + }, + }, + }, + }, + wantPod: &api.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + "country": "Japan", + "city": "Kyoto", + }, + }, + Spec: api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + { + LabelSelector: &metav1.LabelSelector{ + MatchLabels: map[string]string{ + "region": "Asia", + }, + MatchExpressions: []metav1.LabelSelectorRequirement{ + // "city" should be added correctly even if matchLabelKey has "not-found" key. + { + Key: "city", + Operator: metav1.LabelSelectorOpIn, + Values: []string{"Kyoto"}, + }, + }, + }, + MatchLabelKeys: []string{"city", "not-found"}, + }, + }, + }, + }, + }, + }, + }, + { + name: "matchLabelKeys is ignored if the labelSelector is nil", + featureGateEnabled: true, + pod: &api.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + "country": "Japan", + "city": "Kyoto", + }, + }, + Spec: api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + { + MatchLabelKeys: []string{"country"}, + MismatchLabelKeys: []string{"city"}, + }, + }, + }, + }, + }, + }, + wantPod: &api.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + "country": "Japan", + "city": "Kyoto", + }, + }, + Spec: api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + { + MatchLabelKeys: []string{"country"}, + MismatchLabelKeys: []string{"city"}, + }, + }, + }, + }, + }, + }, + }, + { + name: "the feature gate is disabled and matchLabelKeys is ignored", + pod: &api.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + "country": "Japan", + "city": "Kyoto", + }, + }, + Spec: api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + { + LabelSelector: &metav1.LabelSelector{ + MatchLabels: map[string]string{ + "region": "Asia", + }, + }, + MatchLabelKeys: []string{"country"}, + MismatchLabelKeys: []string{"city"}, + }, + }, + }, + }, + }, + }, + wantPod: &api.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + "country": "Japan", + "city": "Kyoto", + }, + }, + Spec: api.PodSpec{ + Affinity: &api.Affinity{ + PodAffinity: &api.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{ + { + LabelSelector: &metav1.LabelSelector{ + MatchLabels: map[string]string{ + "region": "Asia", + }, + }, + MatchLabelKeys: []string{"country"}, + MismatchLabelKeys: []string{"city"}, + }, + }, + }, + }, + }, + }, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.MatchLabelKeysInPodAffinity, tc.featureGateEnabled)() + + pod := tc.pod + mutatePodAffinity(pod) + if diff := cmp.Diff(tc.wantPod.Spec.Affinity, pod.Spec.Affinity); diff != "" { + t.Errorf("unexpected affinity (-want, +got): %s\n", diff) + } + }) + } +} 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 382e8d1823e..7cded1c22d7 100644 --- a/staging/src/k8s.io/api/core/v1/generated.pb.go +++ b/staging/src/k8s.io/api/core/v1/generated.pb.go @@ -6469,955 +6469,959 @@ func init() { } var fileDescriptor_83c10c24ec417dc9 = []byte{ - // 15166 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0xbd, 0x69, 0x70, 0x5c, 0xd9, - 0x75, 0x18, 0xac, 0xd7, 0x8d, 0xad, 0x0f, 0xf6, 0x0b, 0x92, 0x03, 0x62, 0x48, 0x36, 0xe7, 0xcd, - 0x0c, 0x87, 0xb3, 0x81, 0xe2, 0x2c, 0xd2, 0x68, 0x66, 0x34, 0x16, 0x56, 0x12, 0x43, 0x00, 0xec, - 0xb9, 0x0d, 0x92, 0xd2, 0x68, 0xa4, 0x4f, 0x0f, 0xdd, 0x17, 0xc0, 0x13, 0x1a, 0xef, 0xf5, 0xbc, - 0xf7, 0x1a, 0x24, 0xf8, 0x49, 0x65, 0x5b, 0xfe, 0x2c, 0x5b, 0xb2, 0xbf, 0xaf, 0x54, 0x5f, 0xf9, - 0x5b, 0x4a, 0x76, 0xb9, 0xbe, 0xb2, 0xfd, 0xc5, 0x76, 0x64, 0x3b, 0x51, 0xe4, 0xd8, 0x8e, 0xe5, - 0x2d, 0x5b, 0xc5, 0x4e, 0xa5, 0x1c, 0xc7, 0x55, 0xb1, 0x5c, 0xe5, 0x0a, 0x6c, 0xd1, 0xa9, 0x72, - 0xfc, 0x23, 0xb6, 0xb3, 0xfc, 0x48, 0x10, 0x27, 0x4e, 0xdd, 0xf5, 0xdd, 0xfb, 0x96, 0xee, 0x06, - 0x07, 0x84, 0x46, 0xaa, 0xf9, 0xd7, 0x7d, 0xce, 0xb9, 0xe7, 0xde, 0x77, 0xd7, 0x73, 0xcf, 0x39, - 0xf7, 0x1c, 0x78, 0x65, 0xfb, 0xa5, 0x70, 0xda, 0xf5, 0x2f, 0x6d, 0xb7, 0xd6, 0x49, 0xe0, 0x91, - 0x88, 0x84, 0x97, 0x76, 0x89, 0x57, 0xf7, 0x83, 0x4b, 0x02, 0xe1, 0x34, 0xdd, 0x4b, 0x35, 0x3f, - 0x20, 0x97, 0x76, 0x2f, 0x5f, 0xda, 0x24, 0x1e, 0x09, 0x9c, 0x88, 0xd4, 0xa7, 0x9b, 0x81, 0x1f, - 0xf9, 0x08, 0x71, 0x9a, 0x69, 0xa7, 0xe9, 0x4e, 0x53, 0x9a, 0xe9, 0xdd, 0xcb, 0x53, 0xcf, 0x6e, - 0xba, 0xd1, 0x56, 0x6b, 0x7d, 0xba, 0xe6, 0xef, 0x5c, 0xda, 0xf4, 0x37, 0xfd, 0x4b, 0x8c, 0x74, - 0xbd, 0xb5, 0xc1, 0xfe, 0xb1, 0x3f, 0xec, 0x17, 0x67, 0x31, 0xf5, 0x42, 0x5c, 0xcd, 0x8e, 0x53, - 0xdb, 0x72, 0x3d, 0x12, 0xec, 0x5d, 0x6a, 0x6e, 0x6f, 0xb2, 0x7a, 0x03, 0x12, 0xfa, 0xad, 0xa0, - 0x46, 0x92, 0x15, 0xb7, 0x2d, 0x15, 0x5e, 0xda, 0x21, 0x91, 0x93, 0xd1, 0xdc, 0xa9, 0x4b, 0x79, - 0xa5, 0x82, 0x96, 0x17, 0xb9, 0x3b, 0xe9, 0x6a, 0x3e, 0xd0, 0xa9, 0x40, 0x58, 0xdb, 0x22, 0x3b, - 0x4e, 0xaa, 0xdc, 0xf3, 0x79, 0xe5, 0x5a, 0x91, 0xdb, 0xb8, 0xe4, 0x7a, 0x51, 0x18, 0x05, 0xc9, - 0x42, 0xf6, 0x37, 0x2c, 0x38, 0x3f, 0x73, 0xab, 0xba, 0xd0, 0x70, 0xc2, 0xc8, 0xad, 0xcd, 0x36, - 0xfc, 0xda, 0x76, 0x35, 0xf2, 0x03, 0x72, 0xd3, 0x6f, 0xb4, 0x76, 0x48, 0x95, 0x75, 0x04, 0x7a, - 0x06, 0x06, 0x76, 0xd9, 0xff, 0xa5, 0xf9, 0x49, 0xeb, 0xbc, 0x75, 0xb1, 0x34, 0x3b, 0xf6, 0xdb, - 0xfb, 0xe5, 0xf7, 0xdd, 0xdb, 0x2f, 0x0f, 0xdc, 0x14, 0x70, 0xac, 0x28, 0xd0, 0x05, 0xe8, 0xdb, - 0x08, 0xd7, 0xf6, 0x9a, 0x64, 0xb2, 0xc0, 0x68, 0x47, 0x04, 0x6d, 0xdf, 0x62, 0x95, 0x42, 0xb1, - 0xc0, 0xa2, 0x4b, 0x50, 0x6a, 0x3a, 0x41, 0xe4, 0x46, 0xae, 0xef, 0x4d, 0x16, 0xcf, 0x5b, 0x17, - 0x7b, 0x67, 0xc7, 0x05, 0x69, 0xa9, 0x22, 0x11, 0x38, 0xa6, 0xa1, 0xcd, 0x08, 0x88, 0x53, 0xbf, - 0xee, 0x35, 0xf6, 0x26, 0x7b, 0xce, 0x5b, 0x17, 0x07, 0xe2, 0x66, 0x60, 0x01, 0xc7, 0x8a, 0xc2, - 0xfe, 0x72, 0x01, 0x06, 0x66, 0x36, 0x36, 0x5c, 0xcf, 0x8d, 0xf6, 0xd0, 0x4d, 0x18, 0xf2, 0xfc, - 0x3a, 0x91, 0xff, 0xd9, 0x57, 0x0c, 0x3e, 0x77, 0x7e, 0x3a, 0x3d, 0x95, 0xa6, 0x57, 0x35, 0xba, - 0xd9, 0xb1, 0x7b, 0xfb, 0xe5, 0x21, 0x1d, 0x82, 0x0d, 0x3e, 0x08, 0xc3, 0x60, 0xd3, 0xaf, 0x2b, - 0xb6, 0x05, 0xc6, 0xb6, 0x9c, 0xc5, 0xb6, 0x12, 0x93, 0xcd, 0x8e, 0xde, 0xdb, 0x2f, 0x0f, 0x6a, - 0x00, 0xac, 0x33, 0x41, 0xeb, 0x30, 0x4a, 0xff, 0x7a, 0x91, 0xab, 0xf8, 0x16, 0x19, 0xdf, 0x47, - 0xf3, 0xf8, 0x6a, 0xa4, 0xb3, 0x13, 0xf7, 0xf6, 0xcb, 0xa3, 0x09, 0x20, 0x4e, 0x32, 0xb4, 0xef, - 0xc2, 0xc8, 0x4c, 0x14, 0x39, 0xb5, 0x2d, 0x52, 0xe7, 0x23, 0x88, 0x5e, 0x80, 0x1e, 0xcf, 0xd9, - 0x21, 0x62, 0x7c, 0xcf, 0x8b, 0x8e, 0xed, 0x59, 0x75, 0x76, 0xc8, 0xc1, 0x7e, 0x79, 0xec, 0x86, - 0xe7, 0xbe, 0xdd, 0x12, 0xb3, 0x82, 0xc2, 0x30, 0xa3, 0x46, 0xcf, 0x01, 0xd4, 0xc9, 0xae, 0x5b, - 0x23, 0x15, 0x27, 0xda, 0x12, 0xe3, 0x8d, 0x44, 0x59, 0x98, 0x57, 0x18, 0xac, 0x51, 0xd9, 0x77, - 0xa0, 0x34, 0xb3, 0xeb, 0xbb, 0xf5, 0x8a, 0x5f, 0x0f, 0xd1, 0x36, 0x8c, 0x36, 0x03, 0xb2, 0x41, - 0x02, 0x05, 0x9a, 0xb4, 0xce, 0x17, 0x2f, 0x0e, 0x3e, 0x77, 0x31, 0xf3, 0x63, 0x4d, 0xd2, 0x05, - 0x2f, 0x0a, 0xf6, 0x66, 0x1f, 0x12, 0xf5, 0x8d, 0x26, 0xb0, 0x38, 0xc9, 0xd9, 0xfe, 0x27, 0x05, - 0x38, 0x39, 0x73, 0xb7, 0x15, 0x90, 0x79, 0x37, 0xdc, 0x4e, 0xce, 0xf0, 0xba, 0x1b, 0x6e, 0xaf, - 0xc6, 0x3d, 0xa0, 0xa6, 0xd6, 0xbc, 0x80, 0x63, 0x45, 0x81, 0x9e, 0x85, 0x7e, 0xfa, 0xfb, 0x06, - 0x5e, 0x12, 0x9f, 0x3c, 0x21, 0x88, 0x07, 0xe7, 0x9d, 0xc8, 0x99, 0xe7, 0x28, 0x2c, 0x69, 0xd0, - 0x0a, 0x0c, 0xd6, 0xd8, 0x82, 0xdc, 0x5c, 0xf1, 0xeb, 0x84, 0x0d, 0x66, 0x69, 0xf6, 0x69, 0x4a, - 0x3e, 0x17, 0x83, 0x0f, 0xf6, 0xcb, 0x93, 0xbc, 0x6d, 0x82, 0x85, 0x86, 0xc3, 0x7a, 0x79, 0x64, - 0xab, 0xf5, 0xd5, 0xc3, 0x38, 0x41, 0xc6, 0xda, 0xba, 0xa8, 0x2d, 0x95, 0x5e, 0xb6, 0x54, 0x86, - 0xb2, 0x97, 0x09, 0xba, 0x0c, 0x3d, 0xdb, 0xae, 0x57, 0x9f, 0xec, 0x63, 0xbc, 0xce, 0xd2, 0x31, - 0xbf, 0xe6, 0x7a, 0xf5, 0x83, 0xfd, 0xf2, 0xb8, 0xd1, 0x1c, 0x0a, 0xc4, 0x8c, 0xd4, 0xfe, 0x4f, - 0x16, 0x94, 0x19, 0x6e, 0xd1, 0x6d, 0x90, 0x0a, 0x09, 0x42, 0x37, 0x8c, 0x88, 0x17, 0x19, 0x1d, - 0xfa, 0x1c, 0x40, 0x48, 0x6a, 0x01, 0x89, 0xb4, 0x2e, 0x55, 0x13, 0xa3, 0xaa, 0x30, 0x58, 0xa3, - 0xa2, 0x1b, 0x42, 0xb8, 0xe5, 0x04, 0x6c, 0x7e, 0x89, 0x8e, 0x55, 0x1b, 0x42, 0x55, 0x22, 0x70, - 0x4c, 0x63, 0x6c, 0x08, 0xc5, 0x4e, 0x1b, 0x02, 0xfa, 0x30, 0x8c, 0xc6, 0x95, 0x85, 0x4d, 0xa7, - 0x26, 0x3b, 0x90, 0x2d, 0x99, 0xaa, 0x89, 0xc2, 0x49, 0x5a, 0xfb, 0x6f, 0x5b, 0x62, 0xf2, 0xd0, - 0xaf, 0x7e, 0x97, 0x7f, 0xab, 0xfd, 0x2b, 0x16, 0xf4, 0xcf, 0xba, 0x5e, 0xdd, 0xf5, 0x36, 0xd1, - 0xa7, 0x60, 0x80, 0x9e, 0x4d, 0x75, 0x27, 0x72, 0xc4, 0xbe, 0xf7, 0x7e, 0x6d, 0x6d, 0xa9, 0xa3, - 0x62, 0xba, 0xb9, 0xbd, 0x49, 0x01, 0xe1, 0x34, 0xa5, 0xa6, 0xab, 0xed, 0xfa, 0xfa, 0xa7, 0x49, - 0x2d, 0x5a, 0x21, 0x91, 0x13, 0x7f, 0x4e, 0x0c, 0xc3, 0x8a, 0x2b, 0xba, 0x06, 0x7d, 0x91, 0x13, - 0x6c, 0x92, 0x48, 0x6c, 0x80, 0x99, 0x1b, 0x15, 0x2f, 0x89, 0xe9, 0x8a, 0x24, 0x5e, 0x8d, 0xc4, - 0xc7, 0xc2, 0x1a, 0x2b, 0x8a, 0x05, 0x0b, 0xfb, 0xbf, 0xf7, 0xc3, 0xe9, 0xb9, 0xea, 0x52, 0xce, - 0xbc, 0xba, 0x00, 0x7d, 0xf5, 0xc0, 0xdd, 0x25, 0x81, 0xe8, 0x67, 0xc5, 0x65, 0x9e, 0x41, 0xb1, - 0xc0, 0xa2, 0x97, 0x60, 0x88, 0x1f, 0x48, 0x57, 0x1d, 0xaf, 0xde, 0x90, 0x5d, 0x7c, 0x42, 0x50, - 0x0f, 0xdd, 0xd4, 0x70, 0xd8, 0xa0, 0x3c, 0xe4, 0xa4, 0xba, 0x90, 0x58, 0x8c, 0x79, 0x87, 0xdd, - 0x17, 0x2c, 0x18, 0xe3, 0xd5, 0xcc, 0x44, 0x51, 0xe0, 0xae, 0xb7, 0x22, 0x12, 0x4e, 0xf6, 0xb2, - 0x9d, 0x6e, 0x2e, 0xab, 0xb7, 0x72, 0x7b, 0x60, 0xfa, 0x66, 0x82, 0x0b, 0xdf, 0x04, 0x27, 0x45, - 0xbd, 0x63, 0x49, 0x34, 0x4e, 0x55, 0x8b, 0xbe, 0xcf, 0x82, 0xa9, 0x9a, 0xef, 0x45, 0x81, 0xdf, - 0x68, 0x90, 0xa0, 0xd2, 0x5a, 0x6f, 0xb8, 0xe1, 0x16, 0x9f, 0xa7, 0x98, 0x6c, 0xb0, 0x9d, 0x20, - 0x67, 0x0c, 0x15, 0x91, 0x18, 0xc3, 0x73, 0xf7, 0xf6, 0xcb, 0x53, 0x73, 0xb9, 0xac, 0x70, 0x9b, - 0x6a, 0xd0, 0x36, 0x20, 0x7a, 0x94, 0x56, 0x23, 0x67, 0x93, 0xc4, 0x95, 0xf7, 0x77, 0x5f, 0xf9, - 0xa9, 0x7b, 0xfb, 0x65, 0xb4, 0x9a, 0x62, 0x81, 0x33, 0xd8, 0xa2, 0xb7, 0xe1, 0x04, 0x85, 0xa6, - 0xbe, 0x75, 0xa0, 0xfb, 0xea, 0x26, 0xef, 0xed, 0x97, 0x4f, 0xac, 0x66, 0x30, 0xc1, 0x99, 0xac, - 0xd1, 0xf7, 0x58, 0x70, 0x3a, 0xfe, 0xfc, 0x85, 0x3b, 0x4d, 0xc7, 0xab, 0xc7, 0x15, 0x97, 0xba, - 0xaf, 0x98, 0xee, 0xc9, 0xa7, 0xe7, 0xf2, 0x38, 0xe1, 0xfc, 0x4a, 0x90, 0x07, 0x13, 0xb4, 0x69, - 0xc9, 0xba, 0xa1, 0xfb, 0xba, 0x1f, 0xba, 0xb7, 0x5f, 0x9e, 0x58, 0x4d, 0xf3, 0xc0, 0x59, 0x8c, - 0xa7, 0xe6, 0xe0, 0x64, 0xe6, 0xec, 0x44, 0x63, 0x50, 0xdc, 0x26, 0x5c, 0xea, 0x2a, 0x61, 0xfa, - 0x13, 0x9d, 0x80, 0xde, 0x5d, 0xa7, 0xd1, 0x12, 0x0b, 0x13, 0xf3, 0x3f, 0x2f, 0x17, 0x5e, 0xb2, - 0xec, 0x7f, 0x5a, 0x84, 0xd1, 0xb9, 0xea, 0xd2, 0x7d, 0xad, 0x7a, 0xfd, 0xd8, 0x2b, 0xb4, 0x3d, - 0xf6, 0xe2, 0x43, 0xb4, 0x98, 0x7b, 0x88, 0x7e, 0x77, 0xc6, 0x92, 0xed, 0x61, 0x4b, 0xf6, 0x43, - 0x39, 0x4b, 0xf6, 0x88, 0x17, 0xea, 0x6e, 0xce, 0xac, 0xed, 0x65, 0x03, 0x98, 0x29, 0x21, 0x2d, - 0xfb, 0x35, 0xa7, 0x91, 0xdc, 0x6a, 0x0f, 0x39, 0x75, 0x8f, 0x66, 0x1c, 0x6b, 0x30, 0x34, 0xe7, - 0x34, 0x9d, 0x75, 0xb7, 0xe1, 0x46, 0x2e, 0x09, 0xd1, 0x13, 0x50, 0x74, 0xea, 0x75, 0x26, 0xdd, - 0x95, 0x66, 0x4f, 0xde, 0xdb, 0x2f, 0x17, 0x67, 0xea, 0x54, 0xcc, 0x00, 0x45, 0xb5, 0x87, 0x29, - 0x05, 0x7a, 0x0a, 0x7a, 0xea, 0x81, 0xdf, 0x9c, 0x2c, 0x30, 0x4a, 0xba, 0xca, 0x7b, 0xe6, 0x03, - 0xbf, 0x99, 0x20, 0x65, 0x34, 0xf6, 0x6f, 0x15, 0xe0, 0xcc, 0x1c, 0x69, 0x6e, 0x2d, 0x56, 0x73, - 0xce, 0x8b, 0x8b, 0x30, 0xb0, 0xe3, 0x7b, 0x6e, 0xe4, 0x07, 0xa1, 0xa8, 0x9a, 0xcd, 0x88, 0x15, - 0x01, 0xc3, 0x0a, 0x8b, 0xce, 0x43, 0x4f, 0x33, 0x16, 0x62, 0x87, 0xa4, 0x00, 0xcc, 0xc4, 0x57, - 0x86, 0xa1, 0x14, 0xad, 0x90, 0x04, 0x62, 0xc6, 0x28, 0x8a, 0x1b, 0x21, 0x09, 0x30, 0xc3, 0xc4, - 0x92, 0x00, 0x95, 0x11, 0xc4, 0x89, 0x90, 0x90, 0x04, 0x28, 0x06, 0x6b, 0x54, 0xa8, 0x02, 0xa5, - 0x30, 0x31, 0xb2, 0x5d, 0x2d, 0xcd, 0x61, 0x26, 0x2a, 0xa8, 0x91, 0x8c, 0x99, 0x18, 0x27, 0x58, - 0x5f, 0x47, 0x51, 0xe1, 0xeb, 0x05, 0x40, 0xbc, 0x0b, 0xbf, 0xcd, 0x3a, 0xee, 0x46, 0xba, 0xe3, - 0xba, 0x5f, 0x12, 0x47, 0xd5, 0x7b, 0xff, 0xd9, 0x82, 0x33, 0x73, 0xae, 0x57, 0x27, 0x41, 0xce, - 0x04, 0x7c, 0x30, 0x77, 0xe7, 0xc3, 0x09, 0x29, 0xc6, 0x14, 0xeb, 0x39, 0x82, 0x29, 0x66, 0xff, - 0xa5, 0x05, 0x88, 0x7f, 0xf6, 0xbb, 0xee, 0x63, 0x6f, 0xa4, 0x3f, 0xf6, 0x08, 0xa6, 0x85, 0xfd, - 0x77, 0x2c, 0x18, 0x9c, 0x6b, 0x38, 0xee, 0x8e, 0xf8, 0xd4, 0x39, 0x18, 0x97, 0x8a, 0x22, 0x06, - 0xd6, 0x64, 0x7f, 0xba, 0xb9, 0x8d, 0xe3, 0x24, 0x12, 0xa7, 0xe9, 0xd1, 0xc7, 0xe1, 0xb4, 0x01, - 0x5c, 0x23, 0x3b, 0xcd, 0x86, 0x13, 0xe9, 0xb7, 0x02, 0x76, 0xfa, 0xe3, 0x3c, 0x22, 0x9c, 0x5f, - 0xde, 0x5e, 0x86, 0x91, 0xb9, 0x86, 0x4b, 0xbc, 0x68, 0xa9, 0x32, 0xe7, 0x7b, 0x1b, 0xee, 0x26, - 0x7a, 0x19, 0x46, 0x22, 0x77, 0x87, 0xf8, 0xad, 0xa8, 0x4a, 0x6a, 0xbe, 0xc7, 0xee, 0xda, 0xd6, - 0xc5, 0xde, 0x59, 0x74, 0x6f, 0xbf, 0x3c, 0xb2, 0x66, 0x60, 0x70, 0x82, 0xd2, 0xfe, 0x23, 0x3a, - 0xe2, 0xfe, 0x4e, 0xd3, 0xf7, 0x88, 0x17, 0xcd, 0xf9, 0x5e, 0x9d, 0xeb, 0x64, 0x5e, 0x86, 0x9e, - 0x88, 0x8e, 0x20, 0xff, 0xf2, 0x0b, 0x72, 0x69, 0xd3, 0x71, 0x3b, 0xd8, 0x2f, 0x9f, 0x4a, 0x97, - 0x60, 0x23, 0xcb, 0xca, 0xa0, 0x0f, 0x41, 0x5f, 0x18, 0x39, 0x51, 0x2b, 0x14, 0x9f, 0xfa, 0x88, - 0x1c, 0xff, 0x2a, 0x83, 0x1e, 0xec, 0x97, 0x47, 0x55, 0x31, 0x0e, 0xc2, 0xa2, 0x00, 0x7a, 0x12, - 0xfa, 0x77, 0x48, 0x18, 0x3a, 0x9b, 0xf2, 0xfc, 0x1e, 0x15, 0x65, 0xfb, 0x57, 0x38, 0x18, 0x4b, - 0x3c, 0x7a, 0x14, 0x7a, 0x49, 0x10, 0xf8, 0x81, 0xd8, 0x55, 0x86, 0x05, 0x61, 0xef, 0x02, 0x05, - 0x62, 0x8e, 0xb3, 0xff, 0xa5, 0x05, 0xa3, 0xaa, 0xad, 0xbc, 0xae, 0x63, 0xb8, 0x37, 0xbd, 0x09, - 0x50, 0x93, 0x1f, 0x18, 0xb2, 0xf3, 0x6e, 0xf0, 0xb9, 0x0b, 0x99, 0xa2, 0x45, 0xaa, 0x1b, 0x63, - 0xce, 0x0a, 0x14, 0x62, 0x8d, 0x9b, 0xfd, 0xeb, 0x16, 0x4c, 0x24, 0xbe, 0x68, 0xd9, 0x0d, 0x23, - 0xf4, 0x56, 0xea, 0xab, 0xa6, 0xbb, 0xfb, 0x2a, 0x5a, 0x9a, 0x7d, 0x93, 0x5a, 0x7c, 0x12, 0xa2, - 0x7d, 0xd1, 0x55, 0xe8, 0x75, 0x23, 0xb2, 0x23, 0x3f, 0xe6, 0xd1, 0xb6, 0x1f, 0xc3, 0x5b, 0x15, - 0x8f, 0xc8, 0x12, 0x2d, 0x89, 0x39, 0x03, 0xfb, 0xb7, 0x8a, 0x50, 0xe2, 0xd3, 0x76, 0xc5, 0x69, - 0x1e, 0xc3, 0x58, 0x3c, 0x0d, 0x25, 0x77, 0x67, 0xa7, 0x15, 0x39, 0xeb, 0xe2, 0x00, 0x1a, 0xe0, - 0x9b, 0xc1, 0x92, 0x04, 0xe2, 0x18, 0x8f, 0x96, 0xa0, 0x87, 0x35, 0x85, 0x7f, 0xe5, 0x13, 0xd9, - 0x5f, 0x29, 0xda, 0x3e, 0x3d, 0xef, 0x44, 0x0e, 0x97, 0xfd, 0xd4, 0xc9, 0x47, 0x41, 0x98, 0xb1, - 0x40, 0x0e, 0xc0, 0xba, 0xeb, 0x39, 0xc1, 0x1e, 0x85, 0x4d, 0x16, 0x19, 0xc3, 0x67, 0xdb, 0x33, - 0x9c, 0x55, 0xf4, 0x9c, 0xad, 0xfa, 0xb0, 0x18, 0x81, 0x35, 0xa6, 0x53, 0x1f, 0x84, 0x92, 0x22, - 0x3e, 0x8c, 0x08, 0x37, 0xf5, 0x61, 0x18, 0x4d, 0xd4, 0xd5, 0xa9, 0xf8, 0x90, 0x2e, 0x01, 0xfe, - 0x2a, 0xdb, 0x32, 0x44, 0xab, 0x17, 0xbc, 0x5d, 0xb1, 0x73, 0xde, 0x85, 0x13, 0x8d, 0x8c, 0xbd, - 0x57, 0x8c, 0x6b, 0xf7, 0x7b, 0xf5, 0x19, 0xf1, 0xd9, 0x27, 0xb2, 0xb0, 0x38, 0xb3, 0x0e, 0x2a, - 0xd5, 0xf8, 0x4d, 0xba, 0x40, 0x9c, 0x86, 0x7e, 0x41, 0xb8, 0x2e, 0x60, 0x58, 0x61, 0xe9, 0x7e, - 0x77, 0x42, 0x35, 0xfe, 0x1a, 0xd9, 0xab, 0x92, 0x06, 0xa9, 0x45, 0x7e, 0xf0, 0x2d, 0x6d, 0xfe, - 0x59, 0xde, 0xfb, 0x7c, 0xbb, 0x1c, 0x14, 0x0c, 0x8a, 0xd7, 0xc8, 0x1e, 0x1f, 0x0a, 0xfd, 0xeb, - 0x8a, 0x6d, 0xbf, 0xee, 0xab, 0x16, 0x0c, 0xab, 0xaf, 0x3b, 0x86, 0x7d, 0x61, 0xd6, 0xdc, 0x17, - 0xce, 0xb6, 0x9d, 0xe0, 0x39, 0x3b, 0xc2, 0xd7, 0x0b, 0x70, 0x5a, 0xd1, 0xd0, 0xdb, 0x0c, 0xff, - 0x23, 0x66, 0xd5, 0x25, 0x28, 0x79, 0x4a, 0xaf, 0x67, 0x99, 0x0a, 0xb5, 0x58, 0xab, 0x17, 0xd3, - 0x50, 0xa1, 0xd4, 0x8b, 0x8f, 0xd9, 0x21, 0x5d, 0xe1, 0x2d, 0x94, 0xdb, 0xb3, 0x50, 0x6c, 0xb9, - 0x75, 0x71, 0xc0, 0xbc, 0x5f, 0xf6, 0xf6, 0x8d, 0xa5, 0xf9, 0x83, 0xfd, 0xf2, 0x23, 0x79, 0xc6, - 0x16, 0x7a, 0xb2, 0x85, 0xd3, 0x37, 0x96, 0xe6, 0x31, 0x2d, 0x8c, 0x66, 0x60, 0x54, 0x9e, 0xd0, - 0x37, 0xa9, 0x80, 0xe8, 0x7b, 0xe2, 0x1c, 0x52, 0x5a, 0x6b, 0x6c, 0xa2, 0x71, 0x92, 0x1e, 0xcd, - 0xc3, 0xd8, 0x76, 0x6b, 0x9d, 0x34, 0x48, 0xc4, 0x3f, 0xf8, 0x1a, 0xe1, 0x3a, 0xdd, 0x52, 0x7c, - 0x97, 0xbc, 0x96, 0xc0, 0xe3, 0x54, 0x09, 0xfb, 0x6f, 0xd8, 0x79, 0x20, 0x7a, 0xaf, 0x12, 0xf8, - 0x74, 0x62, 0x51, 0xee, 0xdf, 0xca, 0xe9, 0xdc, 0xcd, 0xac, 0xb8, 0x46, 0xf6, 0xd6, 0x7c, 0x7a, - 0x97, 0xc8, 0x9e, 0x15, 0xc6, 0x9c, 0xef, 0x69, 0x3b, 0xe7, 0x7f, 0xb1, 0x00, 0x27, 0x55, 0x0f, - 0x18, 0x62, 0xeb, 0xb7, 0x7b, 0x1f, 0x5c, 0x86, 0xc1, 0x3a, 0xd9, 0x70, 0x5a, 0x8d, 0x48, 0x19, - 0x18, 0x7a, 0xb9, 0x91, 0x69, 0x3e, 0x06, 0x63, 0x9d, 0xe6, 0x10, 0xdd, 0xf6, 0xf3, 0xc3, 0xec, - 0x20, 0x8e, 0x1c, 0x3a, 0xc7, 0xd5, 0xaa, 0xb1, 0x72, 0x57, 0xcd, 0xa3, 0xd0, 0xeb, 0xee, 0x50, - 0xc1, 0xac, 0x60, 0xca, 0x5b, 0x4b, 0x14, 0x88, 0x39, 0x0e, 0x3d, 0x0e, 0xfd, 0x35, 0x7f, 0x67, - 0xc7, 0xf1, 0xea, 0xec, 0xc8, 0x2b, 0xcd, 0x0e, 0x52, 0xd9, 0x6d, 0x8e, 0x83, 0xb0, 0xc4, 0xa1, - 0x33, 0xd0, 0xe3, 0x04, 0x9b, 0x5c, 0xeb, 0x52, 0x9a, 0x1d, 0xa0, 0x35, 0xcd, 0x04, 0x9b, 0x21, - 0x66, 0x50, 0x7a, 0x69, 0xbc, 0xed, 0x07, 0xdb, 0xae, 0xb7, 0x39, 0xef, 0x06, 0x62, 0x49, 0xa8, - 0xb3, 0xf0, 0x96, 0xc2, 0x60, 0x8d, 0x0a, 0x2d, 0x42, 0x6f, 0xd3, 0x0f, 0xa2, 0x70, 0xb2, 0x8f, - 0x75, 0xf7, 0x23, 0x39, 0x1b, 0x11, 0xff, 0xda, 0x8a, 0x1f, 0x44, 0xf1, 0x07, 0xd0, 0x7f, 0x21, - 0xe6, 0xc5, 0xd1, 0x32, 0xf4, 0x13, 0x6f, 0x77, 0x31, 0xf0, 0x77, 0x26, 0x27, 0xf2, 0x39, 0x2d, - 0x70, 0x12, 0x3e, 0xcd, 0x62, 0x19, 0x55, 0x80, 0xb1, 0x64, 0x81, 0x3e, 0x04, 0x45, 0xe2, 0xed, - 0x4e, 0xf6, 0x33, 0x4e, 0x53, 0x39, 0x9c, 0x6e, 0x3a, 0x41, 0xbc, 0xe7, 0x2f, 0x78, 0xbb, 0x98, - 0x96, 0x41, 0x1f, 0x83, 0x92, 0xdc, 0x30, 0x42, 0xa1, 0xce, 0xcc, 0x9c, 0xb0, 0x72, 0x9b, 0xc1, - 0xe4, 0xed, 0x96, 0x1b, 0x90, 0x1d, 0xe2, 0x45, 0x61, 0xbc, 0x43, 0x4a, 0x6c, 0x88, 0x63, 0x6e, - 0xa8, 0x06, 0x43, 0x01, 0x09, 0xdd, 0xbb, 0xa4, 0xe2, 0x37, 0xdc, 0xda, 0xde, 0xe4, 0x43, 0xac, - 0x79, 0x4f, 0xb6, 0xed, 0x32, 0xac, 0x15, 0x88, 0xd5, 0xed, 0x3a, 0x14, 0x1b, 0x4c, 0xd1, 0x1b, - 0x30, 0x1c, 0x90, 0x30, 0x72, 0x82, 0x48, 0xd4, 0x32, 0xa9, 0xcc, 0x63, 0xc3, 0x58, 0x47, 0xf0, - 0xeb, 0x44, 0x5c, 0x4d, 0x8c, 0xc1, 0x26, 0x07, 0xf4, 0x31, 0xa9, 0xfb, 0x5f, 0xf1, 0x5b, 0x5e, - 0x14, 0x4e, 0x96, 0x58, 0xbb, 0x33, 0xad, 0xb2, 0x37, 0x63, 0xba, 0xa4, 0x71, 0x80, 0x17, 0xc6, - 0x06, 0x2b, 0xf4, 0x09, 0x18, 0xe6, 0xff, 0xb9, 0x6d, 0x33, 0x9c, 0x3c, 0xc9, 0x78, 0x9f, 0xcf, - 0xe7, 0xcd, 0x09, 0x67, 0x4f, 0x0a, 0xe6, 0xc3, 0x3a, 0x34, 0xc4, 0x26, 0x37, 0x84, 0x61, 0xb8, - 0xe1, 0xee, 0x12, 0x8f, 0x84, 0x61, 0x25, 0xf0, 0xd7, 0x89, 0x50, 0xd5, 0x9e, 0xce, 0xb6, 0x85, - 0xfa, 0xeb, 0x64, 0x76, 0x9c, 0xf2, 0x5c, 0xd6, 0xcb, 0x60, 0x93, 0x05, 0xba, 0x01, 0x23, 0xf4, - 0x6e, 0xec, 0xc6, 0x4c, 0x07, 0x3b, 0x31, 0x65, 0xf7, 0x41, 0x6c, 0x14, 0xc2, 0x09, 0x26, 0xe8, - 0x3a, 0x0c, 0xb1, 0x3e, 0x6f, 0x35, 0x39, 0xd3, 0x53, 0x9d, 0x98, 0x32, 0x53, 0x7a, 0x55, 0x2b, - 0x82, 0x0d, 0x06, 0xe8, 0x75, 0x28, 0x35, 0xdc, 0x0d, 0x52, 0xdb, 0xab, 0x35, 0xc8, 0xe4, 0x10, - 0xe3, 0x96, 0xb9, 0x19, 0x2e, 0x4b, 0x22, 0x2e, 0x9f, 0xab, 0xbf, 0x38, 0x2e, 0x8e, 0x6e, 0xc2, - 0xa9, 0x88, 0x04, 0x3b, 0xae, 0xe7, 0xd0, 0x4d, 0x4c, 0x5c, 0x09, 0x99, 0x89, 0x7a, 0x98, 0xcd, - 0xae, 0x73, 0x62, 0x34, 0x4e, 0xad, 0x65, 0x52, 0xe1, 0x9c, 0xd2, 0xe8, 0x0e, 0x4c, 0x66, 0x60, - 0xf8, 0xbc, 0x3d, 0xc1, 0x38, 0xbf, 0x2a, 0x38, 0x4f, 0xae, 0xe5, 0xd0, 0x1d, 0xb4, 0xc1, 0xe1, - 0x5c, 0xee, 0xe8, 0x3a, 0x8c, 0xb2, 0x9d, 0xb3, 0xd2, 0x6a, 0x34, 0x44, 0x85, 0x23, 0xac, 0xc2, - 0xc7, 0xa5, 0x1c, 0xb1, 0x64, 0xa2, 0x0f, 0xf6, 0xcb, 0x10, 0xff, 0xc3, 0xc9, 0xd2, 0x68, 0x9d, - 0x59, 0x43, 0x5b, 0x81, 0x1b, 0xed, 0xd1, 0x55, 0x45, 0xee, 0x44, 0x93, 0xa3, 0x6d, 0x35, 0x43, - 0x3a, 0xa9, 0x32, 0x99, 0xea, 0x40, 0x9c, 0x64, 0x48, 0x8f, 0x82, 0x30, 0xaa, 0xbb, 0xde, 0xe4, - 0x18, 0xbf, 0x4f, 0xc9, 0x9d, 0xb4, 0x4a, 0x81, 0x98, 0xe3, 0x98, 0x25, 0x94, 0xfe, 0xb8, 0x4e, - 0x4f, 0xdc, 0x71, 0x46, 0x18, 0x5b, 0x42, 0x25, 0x02, 0xc7, 0x34, 0x54, 0x08, 0x8e, 0xa2, 0xbd, - 0x49, 0xc4, 0x48, 0xd5, 0x86, 0xb8, 0xb6, 0xf6, 0x31, 0x4c, 0xe1, 0xf6, 0x3a, 0x8c, 0xa8, 0x6d, - 0x82, 0xf5, 0x09, 0x2a, 0x43, 0x2f, 0x13, 0xfb, 0x84, 0x1e, 0xb3, 0x44, 0x9b, 0xc0, 0x44, 0x42, - 0xcc, 0xe1, 0xac, 0x09, 0xee, 0x5d, 0x32, 0xbb, 0x17, 0x11, 0xae, 0x8b, 0x28, 0x6a, 0x4d, 0x90, - 0x08, 0x1c, 0xd3, 0xd8, 0xff, 0x83, 0x8b, 0xcf, 0xf1, 0x29, 0xd1, 0xc5, 0xb9, 0xf8, 0x0c, 0x0c, - 0x6c, 0xf9, 0x61, 0x44, 0xa9, 0x59, 0x1d, 0xbd, 0xb1, 0xc0, 0x7c, 0x55, 0xc0, 0xb1, 0xa2, 0x40, - 0xaf, 0xc0, 0x70, 0x4d, 0xaf, 0x40, 0x1c, 0xea, 0x6a, 0x1b, 0x31, 0x6a, 0xc7, 0x26, 0x2d, 0x7a, - 0x09, 0x06, 0x98, 0x77, 0x4f, 0xcd, 0x6f, 0x08, 0x69, 0x53, 0x4a, 0x26, 0x03, 0x15, 0x01, 0x3f, - 0xd0, 0x7e, 0x63, 0x45, 0x8d, 0x2e, 0x40, 0x1f, 0x6d, 0xc2, 0x52, 0x45, 0x1c, 0xa7, 0x4a, 0x25, - 0x77, 0x95, 0x41, 0xb1, 0xc0, 0xda, 0xbf, 0x6e, 0x31, 0x59, 0x2a, 0xbd, 0xe7, 0xa3, 0xab, 0xec, - 0xd0, 0x60, 0x27, 0x88, 0xa6, 0x12, 0x7b, 0x4c, 0x3b, 0x09, 0x14, 0xee, 0x20, 0xf1, 0x1f, 0x1b, - 0x25, 0xd1, 0x9b, 0xc9, 0x93, 0x81, 0x0b, 0x14, 0x2f, 0xc8, 0x2e, 0x48, 0x9e, 0x0e, 0x0f, 0xc7, - 0x47, 0x1c, 0x6d, 0x4f, 0xbb, 0x23, 0xc2, 0xfe, 0x3f, 0x0b, 0xda, 0x2c, 0xa9, 0x46, 0x4e, 0x44, - 0x50, 0x05, 0xfa, 0x6f, 0x3b, 0x6e, 0xe4, 0x7a, 0x9b, 0x42, 0xee, 0x6b, 0x7f, 0xd0, 0xb1, 0x42, - 0xb7, 0x78, 0x01, 0x2e, 0xbd, 0x88, 0x3f, 0x58, 0xb2, 0xa1, 0x1c, 0x83, 0x96, 0xe7, 0x51, 0x8e, - 0x85, 0x6e, 0x39, 0x62, 0x5e, 0x80, 0x73, 0x14, 0x7f, 0xb0, 0x64, 0x83, 0xde, 0x02, 0x90, 0x3b, - 0x04, 0xa9, 0x0b, 0xaf, 0xa0, 0x67, 0x3a, 0x33, 0x5d, 0x53, 0x65, 0x66, 0x47, 0xa8, 0x6c, 0x14, - 0xff, 0xc7, 0x1a, 0x3f, 0x3b, 0xd2, 0xc6, 0x54, 0x6f, 0x0c, 0xfa, 0x38, 0x5d, 0xa2, 0x4e, 0x10, - 0x91, 0xfa, 0x4c, 0x24, 0x3a, 0xe7, 0xa9, 0xee, 0x2e, 0x87, 0x6b, 0xee, 0x0e, 0xd1, 0x97, 0xb3, - 0x60, 0x82, 0x63, 0x7e, 0xf6, 0x2f, 0x17, 0x61, 0x32, 0xaf, 0xb9, 0x74, 0xd1, 0x90, 0x3b, 0x6e, - 0x34, 0x47, 0xc5, 0x5a, 0xcb, 0x5c, 0x34, 0x0b, 0x02, 0x8e, 0x15, 0x05, 0x9d, 0xbd, 0xa1, 0xbb, - 0x29, 0xef, 0xf6, 0xbd, 0xf1, 0xec, 0xad, 0x32, 0x28, 0x16, 0x58, 0x4a, 0x17, 0x10, 0x27, 0x14, - 0x6e, 0x67, 0xda, 0x2c, 0xc7, 0x0c, 0x8a, 0x05, 0x56, 0xd7, 0x32, 0xf6, 0x74, 0xd0, 0x32, 0x1a, - 0x5d, 0xd4, 0x7b, 0xb4, 0x5d, 0x84, 0x3e, 0x09, 0xb0, 0xe1, 0x7a, 0x6e, 0xb8, 0xc5, 0xb8, 0xf7, - 0x1d, 0x9a, 0xbb, 0x12, 0x8a, 0x17, 0x15, 0x17, 0xac, 0x71, 0x44, 0x2f, 0xc2, 0xa0, 0xda, 0x40, - 0x96, 0xe6, 0x99, 0x0d, 0x5e, 0xf3, 0x69, 0x8a, 0x77, 0xd3, 0x79, 0xac, 0xd3, 0xd9, 0x9f, 0x4e, - 0xce, 0x17, 0xb1, 0x02, 0xb4, 0xfe, 0xb5, 0xba, 0xed, 0xdf, 0x42, 0xfb, 0xfe, 0xb5, 0xbf, 0xd9, - 0x07, 0xa3, 0x46, 0x65, 0xad, 0xb0, 0x8b, 0x3d, 0xf7, 0x0a, 0x3d, 0x80, 0x9c, 0x88, 0x88, 0xf5, - 0x67, 0x77, 0x5e, 0x2a, 0xfa, 0x21, 0x45, 0x57, 0x00, 0x2f, 0x8f, 0x3e, 0x09, 0xa5, 0x86, 0x13, - 0x32, 0x8d, 0x25, 0x11, 0xeb, 0xae, 0x1b, 0x66, 0xf1, 0x85, 0xd0, 0x09, 0x23, 0xed, 0xd4, 0xe7, - 0xbc, 0x63, 0x96, 0xf4, 0xa4, 0xa4, 0xf2, 0x95, 0xf4, 0x6b, 0x54, 0x8d, 0xa0, 0x42, 0xd8, 0x1e, - 0xe6, 0x38, 0xf4, 0x12, 0xdb, 0x5a, 0xe9, 0xac, 0x98, 0xa3, 0xd2, 0x28, 0x9b, 0x66, 0xbd, 0x86, - 0x90, 0xad, 0x70, 0xd8, 0xa0, 0x8c, 0xef, 0x64, 0x7d, 0x6d, 0xee, 0x64, 0x4f, 0x42, 0x3f, 0xfb, - 0xa1, 0x66, 0x80, 0x1a, 0x8d, 0x25, 0x0e, 0xc6, 0x12, 0x9f, 0x9c, 0x30, 0x03, 0xdd, 0x4d, 0x18, - 0x7a, 0xeb, 0x13, 0x93, 0x9a, 0xf9, 0x3f, 0x0c, 0xf0, 0x5d, 0x4e, 0x4c, 0x79, 0x2c, 0x71, 0xe8, - 0xa7, 0x2d, 0x40, 0x4e, 0x83, 0xde, 0x96, 0x29, 0x58, 0x5d, 0x6e, 0x80, 0x89, 0xda, 0xaf, 0x74, - 0xec, 0xf6, 0x56, 0x38, 0x3d, 0x93, 0x2a, 0xcd, 0x35, 0xa5, 0x2f, 0x8b, 0x26, 0xa2, 0x34, 0x81, - 0x7e, 0x18, 0x2d, 0xbb, 0x61, 0xf4, 0xb9, 0x3f, 0x4e, 0x1c, 0x4e, 0x19, 0x4d, 0x42, 0x37, 0xf4, - 0xcb, 0xd7, 0xe0, 0x21, 0x2f, 0x5f, 0xc3, 0x79, 0x17, 0xaf, 0xa9, 0x16, 0x3c, 0x94, 0xf3, 0x05, - 0x19, 0xfa, 0xd7, 0x79, 0x5d, 0xff, 0xda, 0x41, 0x6b, 0x37, 0x2d, 0xeb, 0x98, 0x7e, 0xa3, 0xe5, - 0x78, 0x91, 0x1b, 0xed, 0xe9, 0xfa, 0xda, 0xa7, 0x60, 0x64, 0xde, 0x21, 0x3b, 0xbe, 0xb7, 0xe0, - 0xd5, 0x9b, 0xbe, 0xeb, 0x45, 0x68, 0x12, 0x7a, 0x98, 0xf0, 0xc1, 0xb7, 0xde, 0x1e, 0xda, 0x7b, - 0x98, 0x41, 0xec, 0x4d, 0x38, 0x39, 0xef, 0xdf, 0xf6, 0x6e, 0x3b, 0x41, 0x7d, 0xa6, 0xb2, 0xa4, - 0xe9, 0x93, 0x56, 0xa5, 0x3e, 0xc3, 0xca, 0xbf, 0x2d, 0x6a, 0x25, 0xf9, 0x75, 0x68, 0xd1, 0x6d, - 0x90, 0x1c, 0xad, 0xdf, 0xff, 0x53, 0x30, 0x6a, 0x8a, 0xe9, 0x95, 0xdd, 0xd9, 0xca, 0xb5, 0x3b, - 0xbf, 0x01, 0x03, 0x1b, 0x2e, 0x69, 0xd4, 0x31, 0xd9, 0x10, 0xbd, 0xf3, 0x44, 0xbe, 0x67, 0xda, - 0x22, 0xa5, 0x94, 0x5a, 0x5e, 0xae, 0x0d, 0x59, 0x14, 0x85, 0xb1, 0x62, 0x83, 0xb6, 0x61, 0x4c, - 0xf6, 0xa1, 0xc4, 0x8a, 0xfd, 0xe0, 0xc9, 0x76, 0x03, 0x6f, 0x32, 0x3f, 0x71, 0x6f, 0xbf, 0x3c, - 0x86, 0x13, 0x6c, 0x70, 0x8a, 0x31, 0x3a, 0x03, 0x3d, 0x3b, 0xf4, 0xe4, 0xeb, 0x61, 0xdd, 0xcf, - 0xd4, 0x1f, 0x4c, 0x93, 0xc3, 0xa0, 0xf6, 0x8f, 0x59, 0xf0, 0x50, 0xaa, 0x67, 0x84, 0x46, 0xeb, - 0x88, 0x47, 0x21, 0xa9, 0x61, 0x2a, 0x74, 0xd6, 0x30, 0xd9, 0x3f, 0x67, 0xc1, 0x89, 0x85, 0x9d, - 0x66, 0xb4, 0x37, 0xef, 0x9a, 0x46, 0xe2, 0x0f, 0x42, 0xdf, 0x0e, 0xa9, 0xbb, 0xad, 0x1d, 0x31, - 0x72, 0x65, 0x79, 0x3a, 0xac, 0x30, 0xe8, 0xc1, 0x7e, 0x79, 0xb8, 0x1a, 0xf9, 0x81, 0xb3, 0x49, - 0x38, 0x00, 0x0b, 0x72, 0x76, 0xc6, 0xba, 0x77, 0xc9, 0xb2, 0xbb, 0xe3, 0x46, 0xf7, 0x37, 0xdb, - 0x85, 0x7d, 0x57, 0x32, 0xc1, 0x31, 0x3f, 0xfb, 0x1b, 0x16, 0x8c, 0xca, 0x79, 0x3f, 0x53, 0xaf, - 0x07, 0x24, 0x0c, 0xd1, 0x14, 0x14, 0xdc, 0xa6, 0x68, 0x25, 0x88, 0x56, 0x16, 0x96, 0x2a, 0xb8, - 0xe0, 0x36, 0xa5, 0x38, 0xcf, 0x0e, 0xa0, 0xa2, 0x69, 0xea, 0xbe, 0x2a, 0xe0, 0x58, 0x51, 0xa0, - 0x8b, 0x30, 0xe0, 0xf9, 0x75, 0x2e, 0x11, 0x73, 0x51, 0x82, 0x4d, 0xb0, 0x55, 0x01, 0xc3, 0x0a, - 0x8b, 0x2a, 0x50, 0xe2, 0x8e, 0x90, 0xf1, 0xa4, 0xed, 0xca, 0x9d, 0x92, 0x7d, 0xd9, 0x9a, 0x2c, - 0x89, 0x63, 0x26, 0xf6, 0x6f, 0x5a, 0x30, 0x24, 0xbf, 0xac, 0xcb, 0xbb, 0x0a, 0x5d, 0x5a, 0xf1, - 0x3d, 0x25, 0x5e, 0x5a, 0xf4, 0xae, 0xc1, 0x30, 0xc6, 0x15, 0xa3, 0x78, 0xa8, 0x2b, 0xc6, 0x65, - 0x18, 0x74, 0x9a, 0xcd, 0x8a, 0x79, 0x3f, 0x61, 0x53, 0x69, 0x26, 0x06, 0x63, 0x9d, 0xc6, 0xfe, - 0xd1, 0x02, 0x8c, 0xc8, 0x2f, 0xa8, 0xb6, 0xd6, 0x43, 0x12, 0xa1, 0x35, 0x28, 0x39, 0x7c, 0x94, - 0x88, 0x9c, 0xe4, 0x8f, 0x66, 0xeb, 0xcd, 0x8c, 0x21, 0x8d, 0x05, 0xad, 0x19, 0x59, 0x1a, 0xc7, - 0x8c, 0x50, 0x03, 0xc6, 0x3d, 0x3f, 0x62, 0x87, 0xae, 0xc2, 0xb7, 0x33, 0x65, 0x26, 0xb9, 0x9f, - 0x16, 0xdc, 0xc7, 0x57, 0x93, 0x5c, 0x70, 0x9a, 0x31, 0x5a, 0x90, 0xba, 0xc8, 0x62, 0xbe, 0x12, - 0x49, 0x1f, 0xb8, 0x6c, 0x55, 0xa4, 0xfd, 0x6b, 0x16, 0x94, 0x24, 0xd9, 0x71, 0x58, 0xad, 0x57, - 0xa0, 0x3f, 0x64, 0x83, 0x20, 0xbb, 0xc6, 0x6e, 0xd7, 0x70, 0x3e, 0x5e, 0xb1, 0x2c, 0xc1, 0xff, - 0x87, 0x58, 0xf2, 0x60, 0xa6, 0x28, 0xd5, 0xfc, 0x77, 0x89, 0x29, 0x4a, 0xb5, 0x27, 0xe7, 0x50, - 0xfa, 0x33, 0xd6, 0x66, 0x4d, 0xb7, 0x4b, 0x45, 0xde, 0x66, 0x40, 0x36, 0xdc, 0x3b, 0x49, 0x91, - 0xb7, 0xc2, 0xa0, 0x58, 0x60, 0xd1, 0x5b, 0x30, 0x54, 0x93, 0x36, 0x88, 0x78, 0x85, 0x5f, 0x68, - 0x6b, 0x0f, 0x53, 0xa6, 0x53, 0xae, 0x43, 0x9b, 0xd3, 0xca, 0x63, 0x83, 0x9b, 0xe9, 0xe8, 0x53, - 0xec, 0xe4, 0xe8, 0x13, 0xf3, 0xcd, 0x77, 0x7b, 0xf9, 0x71, 0x0b, 0xfa, 0xb8, 0xee, 0xb9, 0x3b, - 0xd5, 0xbf, 0x66, 0x49, 0x8e, 0xfb, 0xee, 0x26, 0x05, 0x0a, 0x49, 0x03, 0xad, 0x40, 0x89, 0xfd, - 0x60, 0xba, 0xf3, 0x62, 0xfe, 0x3b, 0x1c, 0x5e, 0xab, 0xde, 0xc0, 0x9b, 0xb2, 0x18, 0x8e, 0x39, - 0xd8, 0x3f, 0x52, 0xa4, 0xbb, 0x5b, 0x4c, 0x6a, 0x1c, 0xfa, 0xd6, 0x83, 0x3b, 0xf4, 0x0b, 0x0f, - 0xea, 0xd0, 0xdf, 0x84, 0xd1, 0x9a, 0x66, 0x77, 0x8e, 0x47, 0xf2, 0x62, 0xdb, 0x49, 0xa2, 0x99, - 0xa8, 0xb9, 0x76, 0x6e, 0xce, 0x64, 0x82, 0x93, 0x5c, 0xd1, 0xc7, 0x61, 0x88, 0x8f, 0xb3, 0xa8, - 0x85, 0xfb, 0x4a, 0x3d, 0x9e, 0x3f, 0x5f, 0xf4, 0x2a, 0xb8, 0x36, 0x57, 0x2b, 0x8e, 0x0d, 0x66, - 0xf6, 0x5f, 0x59, 0x80, 0x16, 0x9a, 0x5b, 0x64, 0x87, 0x04, 0x4e, 0x23, 0x36, 0x1f, 0x7d, 0xd1, - 0x82, 0x49, 0x92, 0x02, 0xcf, 0xf9, 0x3b, 0x3b, 0xe2, 0xb2, 0x98, 0xa3, 0xcf, 0x58, 0xc8, 0x29, - 0xa3, 0x1e, 0x2a, 0x4d, 0xe6, 0x51, 0xe0, 0xdc, 0xfa, 0xd0, 0x0a, 0x4c, 0xf0, 0x53, 0x52, 0x21, - 0x34, 0xbf, 0xab, 0x87, 0x05, 0xe3, 0x89, 0xb5, 0x34, 0x09, 0xce, 0x2a, 0x67, 0xff, 0xda, 0x30, - 0xe4, 0xb6, 0xe2, 0x3d, 0xbb, 0xd9, 0x7b, 0x76, 0xb3, 0xf7, 0xec, 0x66, 0xef, 0xd9, 0xcd, 0xde, - 0xb3, 0x9b, 0xbd, 0x67, 0x37, 0x7b, 0x97, 0xda, 0xcd, 0xfe, 0x2f, 0x0b, 0x4e, 0xaa, 0xe3, 0xcb, - 0xb8, 0xb0, 0x7f, 0x06, 0x26, 0xf8, 0x72, 0x33, 0x7c, 0x8c, 0xc5, 0x71, 0x7d, 0x39, 0x73, 0xe6, - 0x26, 0x7c, 0xe1, 0x8d, 0x82, 0xfc, 0x51, 0x51, 0x06, 0x02, 0x67, 0x55, 0x63, 0xff, 0xf2, 0x00, - 0xf4, 0x2e, 0xec, 0x12, 0x2f, 0x3a, 0x86, 0xab, 0x4d, 0x0d, 0x46, 0x5c, 0x6f, 0xd7, 0x6f, 0xec, - 0x92, 0x3a, 0xc7, 0x1f, 0xe6, 0x06, 0x7e, 0x4a, 0xb0, 0x1e, 0x59, 0x32, 0x58, 0xe0, 0x04, 0xcb, - 0x07, 0x61, 0x7d, 0xb8, 0x02, 0x7d, 0xfc, 0xf0, 0x11, 0xa6, 0x87, 0xcc, 0x3d, 0x9b, 0x75, 0xa2, - 0x38, 0x52, 0x63, 0xcb, 0x08, 0x3f, 0xdc, 0x44, 0x71, 0xf4, 0x69, 0x18, 0xd9, 0x70, 0x83, 0x30, - 0x5a, 0x73, 0x77, 0xe8, 0xd1, 0xb0, 0xd3, 0xbc, 0x0f, 0x6b, 0x83, 0xea, 0x87, 0x45, 0x83, 0x13, - 0x4e, 0x70, 0x46, 0x9b, 0x30, 0xdc, 0x70, 0xf4, 0xaa, 0xfa, 0x0f, 0x5d, 0x95, 0x3a, 0x1d, 0x96, - 0x75, 0x46, 0xd8, 0xe4, 0x4b, 0x97, 0x53, 0x8d, 0x29, 0xcc, 0x07, 0x98, 0x3a, 0x43, 0x2d, 0x27, - 0xae, 0x29, 0xe7, 0x38, 0x2a, 0xa0, 0x31, 0x47, 0xf6, 0x92, 0x29, 0xa0, 0x69, 0xee, 0xea, 0x9f, - 0x82, 0x12, 0xa1, 0x5d, 0x48, 0x19, 0x8b, 0x03, 0xe6, 0x52, 0x77, 0x6d, 0x5d, 0x71, 0x6b, 0x81, - 0x6f, 0xda, 0x79, 0x16, 0x24, 0x27, 0x1c, 0x33, 0x45, 0x73, 0xd0, 0x17, 0x92, 0xc0, 0x55, 0xba, - 0xe4, 0x36, 0xc3, 0xc8, 0xc8, 0xf8, 0xab, 0x35, 0xfe, 0x1b, 0x8b, 0xa2, 0x74, 0x7a, 0x39, 0x4c, - 0x15, 0xcb, 0x0e, 0x03, 0x6d, 0x7a, 0xcd, 0x30, 0x28, 0x16, 0x58, 0xf4, 0x3a, 0xf4, 0x07, 0xa4, - 0xc1, 0x0c, 0x89, 0xc3, 0xdd, 0x4f, 0x72, 0x6e, 0x97, 0xe4, 0xe5, 0xb0, 0x64, 0x80, 0xae, 0x01, - 0x0a, 0x08, 0x15, 0xf0, 0x5c, 0x6f, 0x53, 0xb9, 0x77, 0x8b, 0x8d, 0x56, 0x09, 0xd2, 0x38, 0xa6, - 0x90, 0x0f, 0x16, 0x71, 0x46, 0x31, 0x74, 0x05, 0xc6, 0x15, 0x74, 0xc9, 0x0b, 0x23, 0x87, 0x6e, - 0x70, 0xa3, 0x8c, 0x97, 0xd2, 0xaf, 0xe0, 0x24, 0x01, 0x4e, 0x97, 0xb1, 0x7f, 0xd6, 0x02, 0xde, - 0xcf, 0xc7, 0xa0, 0x55, 0x78, 0xcd, 0xd4, 0x2a, 0x9c, 0xce, 0x1d, 0xb9, 0x1c, 0x8d, 0xc2, 0xcf, - 0x5a, 0x30, 0xa8, 0x8d, 0x6c, 0x3c, 0x67, 0xad, 0x36, 0x73, 0xb6, 0x05, 0x63, 0x74, 0xa6, 0x5f, - 0x5f, 0x0f, 0x49, 0xb0, 0x4b, 0xea, 0x6c, 0x62, 0x16, 0xee, 0x6f, 0x62, 0x2a, 0x57, 0xd2, 0xe5, - 0x04, 0x43, 0x9c, 0xaa, 0xc2, 0xfe, 0x94, 0x6c, 0xaa, 0xf2, 0xbc, 0xad, 0xa9, 0x31, 0x4f, 0x78, - 0xde, 0xaa, 0x51, 0xc5, 0x31, 0x0d, 0x5d, 0x6a, 0x5b, 0x7e, 0x18, 0x25, 0x3d, 0x6f, 0xaf, 0xfa, - 0x61, 0x84, 0x19, 0xc6, 0x7e, 0x1e, 0x60, 0xe1, 0x0e, 0xa9, 0xf1, 0x19, 0xab, 0x5f, 0x7a, 0xac, - 0xfc, 0x4b, 0x8f, 0xfd, 0xfb, 0x16, 0x8c, 0x2c, 0xce, 0x19, 0x27, 0xd7, 0x34, 0x00, 0xbf, 0xa9, - 0xdd, 0xba, 0xb5, 0x2a, 0xdd, 0x3f, 0xb8, 0x05, 0x5c, 0x41, 0xb1, 0x46, 0x81, 0x4e, 0x43, 0xb1, - 0xd1, 0xf2, 0x84, 0xda, 0xb3, 0x9f, 0x1e, 0x8f, 0xcb, 0x2d, 0x0f, 0x53, 0x98, 0xf6, 0x58, 0xa9, - 0xd8, 0xf5, 0x63, 0xa5, 0x8e, 0x41, 0x4a, 0x50, 0x19, 0x7a, 0x6f, 0xdf, 0x76, 0xeb, 0xfc, 0x29, - 0xb8, 0x70, 0x4d, 0xb9, 0x75, 0x6b, 0x69, 0x3e, 0xc4, 0x1c, 0x6e, 0x7f, 0xa9, 0x08, 0x53, 0x8b, - 0x0d, 0x72, 0xe7, 0x1d, 0x3e, 0x87, 0xef, 0xf6, 0xa9, 0xd5, 0xe1, 0x14, 0x48, 0x87, 0x7d, 0x4e, - 0xd7, 0xb9, 0x3f, 0x36, 0xa0, 0x9f, 0x3b, 0x9e, 0xca, 0xc7, 0xf1, 0x99, 0xe6, 0xbe, 0xfc, 0x0e, - 0x99, 0xe6, 0x0e, 0xac, 0xc2, 0xdc, 0xa7, 0x0e, 0x4c, 0x01, 0xc5, 0x92, 0xf9, 0xd4, 0xcb, 0x30, - 0xa4, 0x53, 0x1e, 0xea, 0x61, 0xeb, 0xf7, 0x16, 0x61, 0x8c, 0xb6, 0xe0, 0x81, 0x0e, 0xc4, 0x8d, - 0xf4, 0x40, 0x1c, 0xf5, 0xe3, 0xc6, 0xce, 0xa3, 0xf1, 0x56, 0x72, 0x34, 0x2e, 0xe7, 0x8d, 0xc6, - 0x71, 0x8f, 0xc1, 0xf7, 0x59, 0x30, 0xb1, 0xd8, 0xf0, 0x6b, 0xdb, 0x89, 0x07, 0x88, 0x2f, 0xc2, - 0x20, 0xdd, 0x8e, 0x43, 0x23, 0x16, 0x87, 0x11, 0x9d, 0x45, 0xa0, 0xb0, 0x4e, 0xa7, 0x15, 0xbb, - 0x71, 0x63, 0x69, 0x3e, 0x2b, 0xa8, 0x8b, 0x40, 0x61, 0x9d, 0xce, 0xfe, 0x5d, 0x0b, 0xce, 0x5e, - 0x99, 0x5b, 0x88, 0xa7, 0x62, 0x2a, 0xae, 0xcc, 0x05, 0xe8, 0x6b, 0xd6, 0xb5, 0xa6, 0xc4, 0x6a, - 0xe1, 0x79, 0xd6, 0x0a, 0x81, 0x7d, 0xb7, 0xc4, 0x4c, 0xba, 0x01, 0x70, 0x05, 0x57, 0xe6, 0xc4, - 0xbe, 0x2b, 0xad, 0x40, 0x56, 0xae, 0x15, 0xe8, 0x71, 0xe8, 0xa7, 0xe7, 0x82, 0x5b, 0x93, 0xed, - 0xe6, 0x06, 0x7d, 0x0e, 0xc2, 0x12, 0x67, 0xff, 0x8c, 0x05, 0x13, 0x57, 0xdc, 0x88, 0x1e, 0xda, - 0xc9, 0xc0, 0x29, 0xf4, 0xd4, 0x0e, 0xdd, 0xc8, 0x0f, 0xf6, 0x92, 0x81, 0x53, 0xb0, 0xc2, 0x60, - 0x8d, 0x8a, 0x7f, 0xd0, 0xae, 0xcb, 0x5e, 0x52, 0x14, 0x4c, 0xbb, 0x1b, 0x16, 0x70, 0xac, 0x28, - 0x68, 0x7f, 0xd5, 0xdd, 0x80, 0xa9, 0x2c, 0xf7, 0xc4, 0xc6, 0xad, 0xfa, 0x6b, 0x5e, 0x22, 0x70, - 0x4c, 0x63, 0xff, 0x85, 0x05, 0xe5, 0x2b, 0x8d, 0x56, 0x18, 0x91, 0x60, 0x23, 0xcc, 0xd9, 0x74, - 0x9f, 0x87, 0x12, 0x91, 0x06, 0x02, 0xf9, 0xe4, 0x53, 0x0a, 0xa2, 0xca, 0x72, 0xc0, 0xe3, 0xb7, - 0x28, 0xba, 0x2e, 0x5e, 0x49, 0x1f, 0xee, 0x99, 0xeb, 0x22, 0x20, 0xa2, 0xd7, 0xa5, 0x07, 0xb4, - 0x61, 0x91, 0x31, 0x16, 0x52, 0x58, 0x9c, 0x51, 0xc2, 0xfe, 0x31, 0x0b, 0x4e, 0xaa, 0x0f, 0x7e, - 0xd7, 0x7d, 0xa6, 0xfd, 0xb5, 0x02, 0x0c, 0x5f, 0x5d, 0x5b, 0xab, 0x5c, 0x21, 0x91, 0x36, 0x2b, - 0xdb, 0x9b, 0xfd, 0xb1, 0x66, 0xbd, 0x6c, 0x77, 0x47, 0x6c, 0x45, 0x6e, 0x63, 0x9a, 0xc7, 0x45, - 0x9b, 0x5e, 0xf2, 0xa2, 0xeb, 0x41, 0x35, 0x0a, 0x5c, 0x6f, 0x33, 0x73, 0xa6, 0x4b, 0x99, 0xa5, - 0x98, 0x27, 0xb3, 0xa0, 0xe7, 0xa1, 0x8f, 0x05, 0x66, 0x93, 0x83, 0xf0, 0xb0, 0xba, 0x62, 0x31, - 0xe8, 0xc1, 0x7e, 0xb9, 0x74, 0x03, 0x2f, 0xf1, 0x3f, 0x58, 0x90, 0xa2, 0x1b, 0x30, 0xb8, 0x15, - 0x45, 0xcd, 0xab, 0xc4, 0xa9, 0x93, 0x40, 0xee, 0xb2, 0xe7, 0xb2, 0x76, 0x59, 0xda, 0x09, 0x9c, - 0x2c, 0xde, 0x98, 0x62, 0x58, 0x88, 0x75, 0x3e, 0x76, 0x15, 0x20, 0xc6, 0x1d, 0x91, 0xe1, 0xc6, - 0x5e, 0x83, 0x12, 0xfd, 0xdc, 0x99, 0x86, 0xeb, 0xb4, 0x37, 0x8d, 0x3f, 0x0d, 0x25, 0x69, 0xf8, - 0x0e, 0x45, 0x14, 0x07, 0x76, 0x22, 0x49, 0xbb, 0x78, 0x88, 0x63, 0xbc, 0xfd, 0x18, 0x08, 0xdf, - 0xd2, 0x76, 0x2c, 0xed, 0x0d, 0x38, 0xc1, 0x9c, 0x64, 0x9d, 0x68, 0xcb, 0x98, 0xa3, 0x9d, 0x27, - 0xc3, 0x33, 0xe2, 0x5e, 0xc7, 0xbf, 0x6c, 0x52, 0x7b, 0x9c, 0x3c, 0x24, 0x39, 0xc6, 0x77, 0x3c, - 0xfb, 0xcf, 0x7b, 0xe0, 0xe1, 0xa5, 0x6a, 0x7e, 0xf8, 0xa1, 0x97, 0x60, 0x88, 0x8b, 0x8b, 0x74, - 0x6a, 0x38, 0x0d, 0x51, 0xaf, 0xd2, 0x80, 0xae, 0x69, 0x38, 0x6c, 0x50, 0xa2, 0xb3, 0x50, 0x74, - 0xdf, 0xf6, 0x92, 0x4f, 0xf7, 0x96, 0xde, 0x58, 0xc5, 0x14, 0x4e, 0xd1, 0x54, 0xf2, 0xe4, 0x5b, - 0xba, 0x42, 0x2b, 0xe9, 0xf3, 0x35, 0x18, 0x71, 0xc3, 0x5a, 0xe8, 0x2e, 0x79, 0x74, 0x9d, 0x6a, - 0x2b, 0x5d, 0xe9, 0x1c, 0x68, 0xa3, 0x15, 0x16, 0x27, 0xa8, 0xb5, 0xf3, 0xa5, 0xb7, 0x6b, 0xe9, - 0xb5, 0x63, 0xf0, 0x03, 0xba, 0xfd, 0x37, 0xd9, 0xd7, 0x85, 0x4c, 0x05, 0x2f, 0xb6, 0x7f, 0xfe, - 0xc1, 0x21, 0x96, 0x38, 0x7a, 0xa1, 0xab, 0x6d, 0x39, 0xcd, 0x99, 0x56, 0xb4, 0x35, 0xef, 0x86, - 0x35, 0x7f, 0x97, 0x04, 0x7b, 0xec, 0x2e, 0x3e, 0x10, 0x5f, 0xe8, 0x14, 0x62, 0xee, 0xea, 0x4c, - 0x85, 0x52, 0xe2, 0x74, 0x19, 0x34, 0x03, 0xa3, 0x12, 0x58, 0x25, 0x21, 0x3b, 0x02, 0x06, 0x19, - 0x1b, 0xf5, 0x98, 0x4e, 0x80, 0x15, 0x93, 0x24, 0xbd, 0x29, 0xe0, 0xc2, 0x51, 0x08, 0xb8, 0x1f, - 0x84, 0x61, 0xd7, 0x73, 0x23, 0xd7, 0x89, 0x7c, 0x6e, 0x3f, 0xe2, 0xd7, 0x6e, 0xa6, 0x60, 0x5e, - 0xd2, 0x11, 0xd8, 0xa4, 0xb3, 0xff, 0x6d, 0x0f, 0x8c, 0xb3, 0x61, 0x7b, 0x6f, 0x86, 0x7d, 0x27, - 0xcd, 0xb0, 0x1b, 0xe9, 0x19, 0x76, 0x14, 0x92, 0xfb, 0x7d, 0x4f, 0xb3, 0x4f, 0x43, 0x49, 0xbd, - 0x1f, 0x94, 0x0f, 0x88, 0xad, 0x9c, 0x07, 0xc4, 0x9d, 0x4f, 0x6f, 0xe9, 0x92, 0x56, 0xcc, 0x74, - 0x49, 0xfb, 0x8a, 0x05, 0xb1, 0x61, 0x01, 0xbd, 0x01, 0xa5, 0xa6, 0xcf, 0x3c, 0x5c, 0x03, 0xe9, - 0x36, 0xfe, 0x58, 0x5b, 0xcb, 0x04, 0x8f, 0xc0, 0x16, 0xf0, 0x5e, 0xa8, 0xc8, 0xa2, 0x38, 0xe6, - 0x82, 0xae, 0x41, 0x7f, 0x33, 0x20, 0xd5, 0x88, 0x85, 0x07, 0xea, 0x9e, 0x21, 0x9f, 0x35, 0xbc, - 0x20, 0x96, 0x1c, 0xec, 0x5f, 0x28, 0xc0, 0x58, 0x92, 0x14, 0xbd, 0x0a, 0x3d, 0xe4, 0x0e, 0xa9, - 0x89, 0xf6, 0x66, 0x1e, 0xc5, 0xb1, 0x6a, 0x82, 0x77, 0x00, 0xfd, 0x8f, 0x59, 0x29, 0x74, 0x15, - 0xfa, 0xe9, 0x39, 0x7c, 0x45, 0x85, 0xc2, 0x7b, 0x24, 0xef, 0x2c, 0x57, 0x02, 0x0d, 0x6f, 0x9c, - 0x00, 0x61, 0x59, 0x9c, 0xf9, 0x81, 0xd5, 0x9a, 0x55, 0x7a, 0xc5, 0x89, 0xda, 0xdd, 0xc4, 0xd7, - 0xe6, 0x2a, 0x9c, 0x48, 0x70, 0xe3, 0x7e, 0x60, 0x12, 0x88, 0x63, 0x26, 0xe8, 0x23, 0xd0, 0x1b, - 0x36, 0x08, 0x69, 0x0a, 0x43, 0x7f, 0xa6, 0x72, 0xb1, 0x4a, 0x09, 0x04, 0x27, 0xa6, 0x8c, 0x60, - 0x00, 0xcc, 0x0b, 0xda, 0xbf, 0x68, 0x01, 0x70, 0xc7, 0x39, 0xc7, 0xdb, 0x24, 0xc7, 0xa0, 0x8f, - 0x9f, 0x87, 0x9e, 0xb0, 0x49, 0x6a, 0xed, 0xdc, 0xb7, 0xe3, 0xf6, 0x54, 0x9b, 0xa4, 0x16, 0xcf, - 0x59, 0xfa, 0x0f, 0xb3, 0xd2, 0xf6, 0xf7, 0x03, 0x8c, 0xc4, 0x64, 0x4b, 0x11, 0xd9, 0x41, 0xcf, - 0x1a, 0x61, 0x4b, 0x4e, 0x27, 0xc2, 0x96, 0x94, 0x18, 0xb5, 0xa6, 0xfa, 0xfd, 0x34, 0x14, 0x77, - 0x9c, 0x3b, 0x42, 0xb7, 0xf7, 0x74, 0xfb, 0x66, 0x50, 0xfe, 0xd3, 0x2b, 0xce, 0x1d, 0x7e, 0xfd, - 0x7d, 0x5a, 0xae, 0xb1, 0x15, 0xe7, 0x4e, 0x47, 0x17, 0x63, 0x5a, 0x09, 0xab, 0xcb, 0xf5, 0x84, - 0x4f, 0x58, 0x57, 0x75, 0xb9, 0x5e, 0xb2, 0x2e, 0xd7, 0xeb, 0xa2, 0x2e, 0xd7, 0x43, 0x77, 0xa1, - 0x5f, 0xb8, 0x6c, 0x8a, 0xc0, 0x66, 0x97, 0xba, 0xa8, 0x4f, 0x78, 0x7c, 0xf2, 0x3a, 0x2f, 0xc9, - 0xeb, 0xbd, 0x80, 0x76, 0xac, 0x57, 0x56, 0x88, 0xfe, 0x6f, 0x0b, 0x46, 0xc4, 0x6f, 0x4c, 0xde, - 0x6e, 0x91, 0x30, 0x12, 0xe2, 0xef, 0x07, 0xba, 0x6f, 0x83, 0x28, 0xc8, 0x9b, 0xf2, 0x01, 0x79, - 0x52, 0x99, 0xc8, 0x8e, 0x2d, 0x4a, 0xb4, 0x02, 0xfd, 0x82, 0x05, 0x27, 0x76, 0x9c, 0x3b, 0xbc, - 0x46, 0x0e, 0xc3, 0x4e, 0xe4, 0xfa, 0xc2, 0xf5, 0xe1, 0xd5, 0xee, 0x86, 0x3f, 0x55, 0x9c, 0x37, - 0x52, 0xda, 0x39, 0x4f, 0x64, 0x91, 0x74, 0x6c, 0x6a, 0x66, 0xbb, 0xa6, 0x36, 0x60, 0x40, 0xce, - 0xb7, 0x07, 0xe9, 0x1f, 0xce, 0xea, 0x11, 0x73, 0xed, 0x81, 0xd6, 0xf3, 0x69, 0x18, 0xd2, 0xe7, - 0xd8, 0x03, 0xad, 0xeb, 0x6d, 0x98, 0xc8, 0x98, 0x4b, 0x0f, 0xb4, 0xca, 0xdb, 0x70, 0x3a, 0x77, - 0x7e, 0x3c, 0x50, 0xff, 0xfe, 0xaf, 0x59, 0xfa, 0x3e, 0x78, 0x0c, 0x46, 0x91, 0x39, 0xd3, 0x28, - 0x72, 0xae, 0xfd, 0xca, 0xc9, 0xb1, 0x8c, 0xbc, 0xa5, 0x37, 0x9a, 0xee, 0xea, 0xe8, 0x75, 0xe8, - 0x6b, 0x50, 0x88, 0x74, 0xfc, 0xb5, 0x3b, 0xaf, 0xc8, 0x58, 0x1c, 0x65, 0xf0, 0x10, 0x0b, 0x0e, - 0xf6, 0xaf, 0x58, 0xd0, 0x73, 0x0c, 0x3d, 0x81, 0xcd, 0x9e, 0x78, 0x36, 0x97, 0xb5, 0x88, 0xf1, - 0x3e, 0x8d, 0x9d, 0xdb, 0x0b, 0x77, 0x22, 0xe2, 0x85, 0xec, 0x4c, 0xcf, 0xec, 0x98, 0x7d, 0x0b, - 0x26, 0x96, 0x7d, 0xa7, 0x3e, 0xeb, 0x34, 0x1c, 0xaf, 0x46, 0x82, 0x25, 0x6f, 0xf3, 0x50, 0x5e, - 0xeb, 0x85, 0x8e, 0x5e, 0xeb, 0x2f, 0x41, 0x9f, 0xdb, 0xd4, 0x62, 0x56, 0x9f, 0xa7, 0x1d, 0xb8, - 0x54, 0x11, 0xe1, 0xaa, 0x91, 0x51, 0x39, 0x83, 0x62, 0x41, 0x4f, 0x47, 0x9e, 0xbb, 0x8b, 0xf5, - 0xe4, 0x8f, 0x3c, 0x95, 0xe2, 0x93, 0x21, 0xa0, 0x0c, 0xc7, 0xe6, 0x2d, 0x30, 0xaa, 0x10, 0xaf, - 0xbe, 0x30, 0xf4, 0xbb, 0xfc, 0x4b, 0xc5, 0xf0, 0x3f, 0x91, 0x2d, 0x5d, 0xa7, 0x3a, 0x46, 0x7b, - 0xcf, 0xc4, 0x01, 0x58, 0x32, 0xb2, 0x5f, 0x82, 0xcc, 0x90, 0x1d, 0x9d, 0x35, 0x27, 0xf6, 0xc7, - 0x60, 0x9c, 0x95, 0x3c, 0xa4, 0x56, 0xc2, 0x4e, 0xe8, 0x7b, 0x33, 0xc2, 0x8f, 0xda, 0x5f, 0xb0, - 0x60, 0x74, 0x35, 0x11, 0x95, 0xf1, 0x02, 0xb3, 0x10, 0x67, 0x98, 0x19, 0xaa, 0x0c, 0x8a, 0x05, - 0xf6, 0xc8, 0xd5, 0x70, 0x7f, 0x63, 0x41, 0x1c, 0x45, 0xe7, 0x18, 0x04, 0xbf, 0x39, 0x43, 0xf0, - 0xcb, 0x14, 0xa2, 0x55, 0x73, 0xf2, 0xe4, 0x3e, 0x74, 0x4d, 0xc5, 0x97, 0x6b, 0x23, 0x3f, 0xc7, - 0x6c, 0xf8, 0x54, 0x1c, 0x31, 0x83, 0xd0, 0xc9, 0x88, 0x73, 0xf6, 0x1f, 0x14, 0x00, 0x29, 0xda, - 0xae, 0xe3, 0xdf, 0xa5, 0x4b, 0x1c, 0x4d, 0xfc, 0xbb, 0x5d, 0x40, 0xcc, 0xc7, 0x21, 0x70, 0xbc, - 0x90, 0xb3, 0x75, 0x85, 0xe2, 0xf1, 0x70, 0x0e, 0x14, 0x53, 0xf2, 0x41, 0xdc, 0x72, 0x8a, 0x1b, - 0xce, 0xa8, 0x41, 0xf3, 0x5d, 0xe9, 0xed, 0xd6, 0x77, 0xa5, 0xaf, 0xc3, 0xcb, 0xce, 0xaf, 0x5a, - 0x30, 0xac, 0xba, 0xe9, 0x5d, 0xe2, 0xff, 0xaf, 0xda, 0x93, 0xb3, 0xf5, 0x56, 0xb4, 0x26, 0xb3, - 0x23, 0xe9, 0xbb, 0xd8, 0x0b, 0x5d, 0xa7, 0xe1, 0xde, 0x25, 0x2a, 0x5e, 0x6a, 0x59, 0xbc, 0xb8, - 0x15, 0xd0, 0x83, 0xfd, 0xf2, 0xb0, 0xfa, 0xc7, 0xe3, 0xc1, 0xc7, 0x45, 0xec, 0x9f, 0xa2, 0x8b, - 0xdd, 0x9c, 0x8a, 0xe8, 0x45, 0xe8, 0x6d, 0x6e, 0x39, 0x21, 0x49, 0xbc, 0x93, 0xea, 0xad, 0x50, - 0xe0, 0xc1, 0x7e, 0x79, 0x44, 0x15, 0x60, 0x10, 0xcc, 0xa9, 0xbb, 0x8f, 0x2a, 0x98, 0x9e, 0x9c, - 0x1d, 0xa3, 0x0a, 0xfe, 0x95, 0x05, 0x3d, 0xab, 0x74, 0x83, 0x7f, 0xf0, 0x5b, 0xc0, 0x6b, 0xc6, - 0x16, 0x70, 0x26, 0x2f, 0x55, 0x47, 0xee, 0xea, 0x5f, 0x4c, 0xac, 0xfe, 0x73, 0xb9, 0x1c, 0xda, - 0x2f, 0xfc, 0x1d, 0x18, 0x64, 0x09, 0x40, 0xc4, 0x9b, 0xb0, 0xe7, 0x8d, 0x05, 0x5f, 0x4e, 0x2c, - 0xf8, 0x51, 0x8d, 0x54, 0x5b, 0xe9, 0x4f, 0x42, 0xbf, 0x78, 0x64, 0x94, 0x7c, 0xe8, 0x2c, 0x68, - 0xb1, 0xc4, 0xdb, 0x3f, 0x5e, 0x04, 0x23, 0xe1, 0x08, 0xfa, 0x35, 0x0b, 0xa6, 0x03, 0xee, 0x7c, - 0x5c, 0x9f, 0x6f, 0x05, 0xae, 0xb7, 0x59, 0xad, 0x6d, 0x91, 0x7a, 0xab, 0xe1, 0x7a, 0x9b, 0x4b, - 0x9b, 0x9e, 0xaf, 0xc0, 0x0b, 0x77, 0x48, 0xad, 0xc5, 0x0c, 0x83, 0x1d, 0xb2, 0x9b, 0x28, 0x27, - 0xfe, 0xe7, 0xee, 0xed, 0x97, 0xa7, 0xf1, 0xa1, 0x78, 0xe3, 0x43, 0xb6, 0x05, 0xfd, 0xae, 0x05, - 0x97, 0x78, 0x1e, 0x8e, 0xee, 0xdb, 0xdf, 0xe6, 0x9e, 0x5d, 0x91, 0xac, 0x62, 0x26, 0x6b, 0x24, - 0xd8, 0x99, 0xfd, 0xa0, 0xe8, 0xd0, 0x4b, 0x95, 0xc3, 0xd5, 0x85, 0x0f, 0xdb, 0x38, 0xfb, 0x1f, - 0x16, 0x61, 0x58, 0x44, 0x9f, 0x13, 0x67, 0xc0, 0x8b, 0xc6, 0x94, 0x78, 0x24, 0x31, 0x25, 0xc6, - 0x0d, 0xe2, 0xa3, 0xd9, 0xfe, 0x43, 0x18, 0xa7, 0x9b, 0xf3, 0x55, 0xe2, 0x04, 0xd1, 0x3a, 0x71, - 0xb8, 0x4b, 0x5a, 0xf1, 0xd0, 0xbb, 0xbf, 0xd2, 0x8d, 0x2e, 0x27, 0x99, 0xe1, 0x34, 0xff, 0xef, - 0xa4, 0x33, 0xc7, 0x83, 0xb1, 0x54, 0x00, 0xc1, 0x37, 0xa1, 0xa4, 0x5e, 0xc8, 0x88, 0x4d, 0xa7, - 0x7d, 0x1c, 0xce, 0x24, 0x07, 0xae, 0x7a, 0x8b, 0x5f, 0x67, 0xc5, 0xec, 0xec, 0xbf, 0x5b, 0x30, - 0x2a, 0xe4, 0x83, 0xb8, 0x0a, 0x03, 0x4e, 0x18, 0xba, 0x9b, 0x1e, 0xa9, 0xb7, 0xd3, 0x8e, 0xa6, - 0xaa, 0x61, 0xaf, 0x94, 0x66, 0x44, 0x49, 0xac, 0x78, 0xa0, 0xab, 0xdc, 0xf1, 0x6f, 0x97, 0xb4, - 0x53, 0x8d, 0xa6, 0xb8, 0x81, 0x74, 0x0d, 0xdc, 0x25, 0x58, 0x94, 0x47, 0x9f, 0xe0, 0x9e, 0x99, - 0xd7, 0x3c, 0xff, 0xb6, 0x77, 0xc5, 0xf7, 0x65, 0xa4, 0x91, 0xee, 0x18, 0x8e, 0x4b, 0x7f, 0x4c, - 0x55, 0x1c, 0x9b, 0xdc, 0xba, 0x8b, 0xc8, 0xfb, 0x19, 0x60, 0x79, 0x07, 0xcc, 0x07, 0xe9, 0x21, - 0x22, 0x30, 0x2a, 0x42, 0x1b, 0x4a, 0x98, 0xe8, 0xbb, 0xcc, 0x4b, 0xa0, 0x59, 0x3a, 0x56, 0xe2, - 0x5f, 0x33, 0x59, 0xe0, 0x24, 0x4f, 0xfb, 0xa7, 0x2d, 0x60, 0x8f, 0x73, 0x8f, 0x41, 0x1e, 0xf9, - 0xb0, 0x29, 0x8f, 0x4c, 0xe6, 0x75, 0x72, 0x8e, 0x28, 0xf2, 0x02, 0x9f, 0x59, 0x95, 0xc0, 0xbf, - 0xb3, 0x27, 0xdc, 0x69, 0x3a, 0xdf, 0x3f, 0xec, 0xff, 0x66, 0xf1, 0x4d, 0x2c, 0x0e, 0x65, 0xf0, - 0x59, 0x18, 0xa8, 0x39, 0x4d, 0xa7, 0xc6, 0xb3, 0x63, 0xe5, 0xea, 0x02, 0x8d, 0x42, 0xd3, 0x73, - 0xa2, 0x04, 0xd7, 0x6d, 0xc9, 0x10, 0x99, 0x03, 0x12, 0xdc, 0x51, 0x9f, 0xa5, 0xaa, 0x9c, 0xda, - 0x86, 0x61, 0x83, 0xd9, 0x03, 0x55, 0x84, 0x7c, 0x96, 0x1f, 0xb1, 0x2a, 0xa4, 0xeb, 0x0e, 0x8c, - 0x7b, 0xda, 0x7f, 0x7a, 0xa0, 0xc8, 0xcb, 0xe5, 0x63, 0x9d, 0x0e, 0x51, 0x76, 0xfa, 0x68, 0xef, - 0x7e, 0x13, 0x6c, 0x70, 0x9a, 0xb3, 0xfd, 0x13, 0x16, 0x3c, 0xa4, 0x13, 0x6a, 0x4f, 0x8b, 0x3a, - 0x19, 0x68, 0xe6, 0x61, 0xc0, 0x6f, 0x92, 0xc0, 0x89, 0xfc, 0x40, 0x9c, 0x1a, 0x17, 0x65, 0xa7, - 0x5f, 0x17, 0xf0, 0x03, 0x91, 0xeb, 0x41, 0x72, 0x97, 0x70, 0xac, 0x4a, 0xd2, 0xdb, 0x27, 0xeb, + // 15230 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0xbd, 0x69, 0x90, 0x1c, 0xc9, + 0x75, 0x18, 0xcc, 0xea, 0x9e, 0xab, 0xdf, 0xdc, 0x39, 0x00, 0x76, 0x30, 0x0b, 0xa0, 0xb1, 0xb5, + 0xbb, 0x58, 0xec, 0x35, 0x20, 0xf6, 0x20, 0x97, 0xbb, 0xcb, 0x15, 0xe7, 0x04, 0x7a, 0x81, 0x19, + 0xf4, 0x66, 0x0f, 0x00, 0x72, 0xb9, 0xe4, 0xc7, 0x42, 0x77, 0xce, 0x4c, 0x71, 0x7a, 0xaa, 0x7a, + 0xab, 0xaa, 0x07, 0x18, 0x7c, 0x64, 0x48, 0xa2, 0x3e, 0x51, 0x22, 0xa5, 0xef, 0x0b, 0xc6, 0x17, + 0xfa, 0x8e, 0xa0, 0x14, 0x8a, 0x2f, 0x24, 0x7d, 0x96, 0x64, 0x4a, 0xb2, 0x69, 0xca, 0x92, 0x2c, + 0xea, 0xf2, 0x15, 0x96, 0x1c, 0x0e, 0x59, 0x56, 0x84, 0x45, 0x45, 0x28, 0x3c, 0x12, 0x21, 0x47, + 0xc8, 0xfa, 0x61, 0x49, 0x3e, 0x7e, 0xd8, 0x63, 0xd9, 0x72, 0xe4, 0x59, 0x99, 0x75, 0x74, 0xf7, + 0x60, 0x07, 0xc3, 0x25, 0x63, 0xff, 0x75, 0xbf, 0xf7, 0xf2, 0x65, 0x56, 0x9e, 0x2f, 0xdf, 0x7b, + 0xf9, 0x1e, 0xbc, 0xb2, 0xf5, 0x52, 0x38, 0xeb, 0xfa, 0x17, 0xb6, 0xda, 0xb7, 0x48, 0xe0, 0x91, + 0x88, 0x84, 0x17, 0x76, 0x88, 0xd7, 0xf0, 0x83, 0x0b, 0x02, 0xe1, 0xb4, 0xdc, 0x0b, 0x75, 0x3f, + 0x20, 0x17, 0x76, 0x2e, 0x5e, 0xd8, 0x20, 0x1e, 0x09, 0x9c, 0x88, 0x34, 0x66, 0x5b, 0x81, 0x1f, + 0xf9, 0x08, 0x71, 0x9a, 0x59, 0xa7, 0xe5, 0xce, 0x52, 0x9a, 0xd9, 0x9d, 0x8b, 0x33, 0xcf, 0x6e, + 0xb8, 0xd1, 0x66, 0xfb, 0xd6, 0x6c, 0xdd, 0xdf, 0xbe, 0xb0, 0xe1, 0x6f, 0xf8, 0x17, 0x18, 0xe9, + 0xad, 0xf6, 0x3a, 0xfb, 0xc7, 0xfe, 0xb0, 0x5f, 0x9c, 0xc5, 0xcc, 0x0b, 0x71, 0x35, 0xdb, 0x4e, + 0x7d, 0xd3, 0xf5, 0x48, 0xb0, 0x7b, 0xa1, 0xb5, 0xb5, 0xc1, 0xea, 0x0d, 0x48, 0xe8, 0xb7, 0x83, + 0x3a, 0x49, 0x56, 0xdc, 0xb1, 0x54, 0x78, 0x61, 0x9b, 0x44, 0x4e, 0x46, 0x73, 0x67, 0x2e, 0xe4, + 0x95, 0x0a, 0xda, 0x5e, 0xe4, 0x6e, 0xa7, 0xab, 0xf9, 0x40, 0xb7, 0x02, 0x61, 0x7d, 0x93, 0x6c, + 0x3b, 0xa9, 0x72, 0xcf, 0xe7, 0x95, 0x6b, 0x47, 0x6e, 0xf3, 0x82, 0xeb, 0x45, 0x61, 0x14, 0x24, + 0x0b, 0xd9, 0xdf, 0xb0, 0xe0, 0xec, 0xdc, 0xcd, 0xda, 0x52, 0xd3, 0x09, 0x23, 0xb7, 0x3e, 0xdf, + 0xf4, 0xeb, 0x5b, 0xb5, 0xc8, 0x0f, 0xc8, 0x0d, 0xbf, 0xd9, 0xde, 0x26, 0x35, 0xd6, 0x11, 0xe8, + 0x19, 0x18, 0xda, 0x61, 0xff, 0x2b, 0x8b, 0xd3, 0xd6, 0x59, 0xeb, 0x7c, 0x69, 0x7e, 0xe2, 0xb7, + 0xf7, 0xca, 0xef, 0xbb, 0xb7, 0x57, 0x1e, 0xba, 0x21, 0xe0, 0x58, 0x51, 0xa0, 0x73, 0x30, 0xb0, + 0x1e, 0xae, 0xed, 0xb6, 0xc8, 0x74, 0x81, 0xd1, 0x8e, 0x09, 0xda, 0x81, 0xe5, 0x1a, 0x85, 0x62, + 0x81, 0x45, 0x17, 0xa0, 0xd4, 0x72, 0x82, 0xc8, 0x8d, 0x5c, 0xdf, 0x9b, 0x2e, 0x9e, 0xb5, 0xce, + 0xf7, 0xcf, 0x4f, 0x0a, 0xd2, 0x52, 0x55, 0x22, 0x70, 0x4c, 0x43, 0x9b, 0x11, 0x10, 0xa7, 0x71, + 0xcd, 0x6b, 0xee, 0x4e, 0xf7, 0x9d, 0xb5, 0xce, 0x0f, 0xc5, 0xcd, 0xc0, 0x02, 0x8e, 0x15, 0x85, + 0xfd, 0xe5, 0x02, 0x0c, 0xcd, 0xad, 0xaf, 0xbb, 0x9e, 0x1b, 0xed, 0xa2, 0x1b, 0x30, 0xe2, 0xf9, + 0x0d, 0x22, 0xff, 0xb3, 0xaf, 0x18, 0x7e, 0xee, 0xec, 0x6c, 0x7a, 0x2a, 0xcd, 0xae, 0x6a, 0x74, + 0xf3, 0x13, 0xf7, 0xf6, 0xca, 0x23, 0x3a, 0x04, 0x1b, 0x7c, 0x10, 0x86, 0xe1, 0x96, 0xdf, 0x50, + 0x6c, 0x0b, 0x8c, 0x6d, 0x39, 0x8b, 0x6d, 0x35, 0x26, 0x9b, 0x1f, 0xbf, 0xb7, 0x57, 0x1e, 0xd6, + 0x00, 0x58, 0x67, 0x82, 0x6e, 0xc1, 0x38, 0xfd, 0xeb, 0x45, 0xae, 0xe2, 0x5b, 0x64, 0x7c, 0x1f, + 0xcd, 0xe3, 0xab, 0x91, 0xce, 0x4f, 0xdd, 0xdb, 0x2b, 0x8f, 0x27, 0x80, 0x38, 0xc9, 0xd0, 0xbe, + 0x0b, 0x63, 0x73, 0x51, 0xe4, 0xd4, 0x37, 0x49, 0x83, 0x8f, 0x20, 0x7a, 0x01, 0xfa, 0x3c, 0x67, + 0x9b, 0x88, 0xf1, 0x3d, 0x2b, 0x3a, 0xb6, 0x6f, 0xd5, 0xd9, 0x26, 0xfb, 0x7b, 0xe5, 0x89, 0xeb, + 0x9e, 0xfb, 0x76, 0x5b, 0xcc, 0x0a, 0x0a, 0xc3, 0x8c, 0x1a, 0x3d, 0x07, 0xd0, 0x20, 0x3b, 0x6e, + 0x9d, 0x54, 0x9d, 0x68, 0x53, 0x8c, 0x37, 0x12, 0x65, 0x61, 0x51, 0x61, 0xb0, 0x46, 0x65, 0xdf, + 0x81, 0xd2, 0xdc, 0x8e, 0xef, 0x36, 0xaa, 0x7e, 0x23, 0x44, 0x5b, 0x30, 0xde, 0x0a, 0xc8, 0x3a, + 0x09, 0x14, 0x68, 0xda, 0x3a, 0x5b, 0x3c, 0x3f, 0xfc, 0xdc, 0xf9, 0xcc, 0x8f, 0x35, 0x49, 0x97, + 0xbc, 0x28, 0xd8, 0x9d, 0x7f, 0x48, 0xd4, 0x37, 0x9e, 0xc0, 0xe2, 0x24, 0x67, 0xfb, 0x9f, 0x14, + 0xe0, 0xf8, 0xdc, 0xdd, 0x76, 0x40, 0x16, 0xdd, 0x70, 0x2b, 0x39, 0xc3, 0x1b, 0x6e, 0xb8, 0xb5, + 0x1a, 0xf7, 0x80, 0x9a, 0x5a, 0x8b, 0x02, 0x8e, 0x15, 0x05, 0x7a, 0x16, 0x06, 0xe9, 0xef, 0xeb, + 0xb8, 0x22, 0x3e, 0x79, 0x4a, 0x10, 0x0f, 0x2f, 0x3a, 0x91, 0xb3, 0xc8, 0x51, 0x58, 0xd2, 0xa0, + 0x15, 0x18, 0xae, 0xb3, 0x05, 0xb9, 0xb1, 0xe2, 0x37, 0x08, 0x1b, 0xcc, 0xd2, 0xfc, 0xd3, 0x94, + 0x7c, 0x21, 0x06, 0xef, 0xef, 0x95, 0xa7, 0x79, 0xdb, 0x04, 0x0b, 0x0d, 0x87, 0xf5, 0xf2, 0xc8, + 0x56, 0xeb, 0xab, 0x8f, 0x71, 0x82, 0x8c, 0xb5, 0x75, 0x5e, 0x5b, 0x2a, 0xfd, 0x6c, 0xa9, 0x8c, + 0x64, 0x2f, 0x13, 0x74, 0x11, 0xfa, 0xb6, 0x5c, 0xaf, 0x31, 0x3d, 0xc0, 0x78, 0x9d, 0xa6, 0x63, + 0x7e, 0xc5, 0xf5, 0x1a, 0xfb, 0x7b, 0xe5, 0x49, 0xa3, 0x39, 0x14, 0x88, 0x19, 0xa9, 0xfd, 0x9f, + 0x2c, 0x28, 0x33, 0xdc, 0xb2, 0xdb, 0x24, 0x55, 0x12, 0x84, 0x6e, 0x18, 0x11, 0x2f, 0x32, 0x3a, + 0xf4, 0x39, 0x80, 0x90, 0xd4, 0x03, 0x12, 0x69, 0x5d, 0xaa, 0x26, 0x46, 0x4d, 0x61, 0xb0, 0x46, + 0x45, 0x37, 0x84, 0x70, 0xd3, 0x09, 0xd8, 0xfc, 0x12, 0x1d, 0xab, 0x36, 0x84, 0x9a, 0x44, 0xe0, + 0x98, 0xc6, 0xd8, 0x10, 0x8a, 0xdd, 0x36, 0x04, 0xf4, 0x61, 0x18, 0x8f, 0x2b, 0x0b, 0x5b, 0x4e, + 0x5d, 0x76, 0x20, 0x5b, 0x32, 0x35, 0x13, 0x85, 0x93, 0xb4, 0xf6, 0xdf, 0xb6, 0xc4, 0xe4, 0xa1, + 0x5f, 0xfd, 0x2e, 0xff, 0x56, 0xfb, 0x57, 0x2c, 0x18, 0x9c, 0x77, 0xbd, 0x86, 0xeb, 0x6d, 0xa0, + 0x4f, 0xc1, 0x10, 0x3d, 0x9b, 0x1a, 0x4e, 0xe4, 0x88, 0x7d, 0xef, 0xfd, 0xda, 0xda, 0x52, 0x47, + 0xc5, 0x6c, 0x6b, 0x6b, 0x83, 0x02, 0xc2, 0x59, 0x4a, 0x4d, 0x57, 0xdb, 0xb5, 0x5b, 0x9f, 0x26, + 0xf5, 0x68, 0x85, 0x44, 0x4e, 0xfc, 0x39, 0x31, 0x0c, 0x2b, 0xae, 0xe8, 0x0a, 0x0c, 0x44, 0x4e, + 0xb0, 0x41, 0x22, 0xb1, 0x01, 0x66, 0x6e, 0x54, 0xbc, 0x24, 0xa6, 0x2b, 0x92, 0x78, 0x75, 0x12, + 0x1f, 0x0b, 0x6b, 0xac, 0x28, 0x16, 0x2c, 0xec, 0xff, 0x3e, 0x08, 0x27, 0x17, 0x6a, 0x95, 0x9c, + 0x79, 0x75, 0x0e, 0x06, 0x1a, 0x81, 0xbb, 0x43, 0x02, 0xd1, 0xcf, 0x8a, 0xcb, 0x22, 0x83, 0x62, + 0x81, 0x45, 0x2f, 0xc1, 0x08, 0x3f, 0x90, 0x2e, 0x3b, 0x5e, 0xa3, 0x29, 0xbb, 0xf8, 0x98, 0xa0, + 0x1e, 0xb9, 0xa1, 0xe1, 0xb0, 0x41, 0x79, 0xc0, 0x49, 0x75, 0x2e, 0xb1, 0x18, 0xf3, 0x0e, 0xbb, + 0x2f, 0x58, 0x30, 0xc1, 0xab, 0x99, 0x8b, 0xa2, 0xc0, 0xbd, 0xd5, 0x8e, 0x48, 0x38, 0xdd, 0xcf, + 0x76, 0xba, 0x85, 0xac, 0xde, 0xca, 0xed, 0x81, 0xd9, 0x1b, 0x09, 0x2e, 0x7c, 0x13, 0x9c, 0x16, + 0xf5, 0x4e, 0x24, 0xd1, 0x38, 0x55, 0x2d, 0xfa, 0x3e, 0x0b, 0x66, 0xea, 0xbe, 0x17, 0x05, 0x7e, + 0xb3, 0x49, 0x82, 0x6a, 0xfb, 0x56, 0xd3, 0x0d, 0x37, 0xf9, 0x3c, 0xc5, 0x64, 0x9d, 0xed, 0x04, + 0x39, 0x63, 0xa8, 0x88, 0xc4, 0x18, 0x9e, 0xb9, 0xb7, 0x57, 0x9e, 0x59, 0xc8, 0x65, 0x85, 0x3b, + 0x54, 0x83, 0xb6, 0x00, 0xd1, 0xa3, 0xb4, 0x16, 0x39, 0x1b, 0x24, 0xae, 0x7c, 0xb0, 0xf7, 0xca, + 0x4f, 0xdc, 0xdb, 0x2b, 0xa3, 0xd5, 0x14, 0x0b, 0x9c, 0xc1, 0x16, 0xbd, 0x0d, 0xc7, 0x28, 0x34, + 0xf5, 0xad, 0x43, 0xbd, 0x57, 0x37, 0x7d, 0x6f, 0xaf, 0x7c, 0x6c, 0x35, 0x83, 0x09, 0xce, 0x64, + 0x8d, 0xbe, 0xc7, 0x82, 0x93, 0xf1, 0xe7, 0x2f, 0xdd, 0x69, 0x39, 0x5e, 0x23, 0xae, 0xb8, 0xd4, + 0x7b, 0xc5, 0x74, 0x4f, 0x3e, 0xb9, 0x90, 0xc7, 0x09, 0xe7, 0x57, 0x82, 0x3c, 0x98, 0xa2, 0x4d, + 0x4b, 0xd6, 0x0d, 0xbd, 0xd7, 0xfd, 0xd0, 0xbd, 0xbd, 0xf2, 0xd4, 0x6a, 0x9a, 0x07, 0xce, 0x62, + 0x3c, 0xb3, 0x00, 0xc7, 0x33, 0x67, 0x27, 0x9a, 0x80, 0xe2, 0x16, 0xe1, 0x52, 0x57, 0x09, 0xd3, + 0x9f, 0xe8, 0x18, 0xf4, 0xef, 0x38, 0xcd, 0xb6, 0x58, 0x98, 0x98, 0xff, 0x79, 0xb9, 0xf0, 0x92, + 0x65, 0xff, 0xd3, 0x22, 0x8c, 0x2f, 0xd4, 0x2a, 0xf7, 0xb5, 0xea, 0xf5, 0x63, 0xaf, 0xd0, 0xf1, + 0xd8, 0x8b, 0x0f, 0xd1, 0x62, 0xee, 0x21, 0xfa, 0xdd, 0x19, 0x4b, 0xb6, 0x8f, 0x2d, 0xd9, 0x0f, + 0xe5, 0x2c, 0xd9, 0x43, 0x5e, 0xa8, 0x3b, 0x39, 0xb3, 0xb6, 0x9f, 0x0d, 0x60, 0xa6, 0x84, 0x74, + 0xd5, 0xaf, 0x3b, 0xcd, 0xe4, 0x56, 0x7b, 0xc0, 0xa9, 0x7b, 0x38, 0xe3, 0x58, 0x87, 0x91, 0x05, + 0xa7, 0xe5, 0xdc, 0x72, 0x9b, 0x6e, 0xe4, 0x92, 0x10, 0x3d, 0x01, 0x45, 0xa7, 0xd1, 0x60, 0xd2, + 0x5d, 0x69, 0xfe, 0xf8, 0xbd, 0xbd, 0x72, 0x71, 0xae, 0x41, 0xc5, 0x0c, 0x50, 0x54, 0xbb, 0x98, + 0x52, 0xa0, 0xa7, 0xa0, 0xaf, 0x11, 0xf8, 0xad, 0xe9, 0x02, 0xa3, 0xa4, 0xab, 0xbc, 0x6f, 0x31, + 0xf0, 0x5b, 0x09, 0x52, 0x46, 0x63, 0xff, 0x56, 0x01, 0x4e, 0x2d, 0x90, 0xd6, 0xe6, 0x72, 0x2d, + 0xe7, 0xbc, 0x38, 0x0f, 0x43, 0xdb, 0xbe, 0xe7, 0x46, 0x7e, 0x10, 0x8a, 0xaa, 0xd9, 0x8c, 0x58, + 0x11, 0x30, 0xac, 0xb0, 0xe8, 0x2c, 0xf4, 0xb5, 0x62, 0x21, 0x76, 0x44, 0x0a, 0xc0, 0x4c, 0x7c, + 0x65, 0x18, 0x4a, 0xd1, 0x0e, 0x49, 0x20, 0x66, 0x8c, 0xa2, 0xb8, 0x1e, 0x92, 0x00, 0x33, 0x4c, + 0x2c, 0x09, 0x50, 0x19, 0x41, 0x9c, 0x08, 0x09, 0x49, 0x80, 0x62, 0xb0, 0x46, 0x85, 0xaa, 0x50, + 0x0a, 0x13, 0x23, 0xdb, 0xd3, 0xd2, 0x1c, 0x65, 0xa2, 0x82, 0x1a, 0xc9, 0x98, 0x89, 0x71, 0x82, + 0x0d, 0x74, 0x15, 0x15, 0xbe, 0x5e, 0x00, 0xc4, 0xbb, 0xf0, 0xdb, 0xac, 0xe3, 0xae, 0xa7, 0x3b, + 0xae, 0xf7, 0x25, 0x71, 0x58, 0xbd, 0xf7, 0x9f, 0x2d, 0x38, 0xb5, 0xe0, 0x7a, 0x0d, 0x12, 0xe4, + 0x4c, 0xc0, 0x07, 0x73, 0x77, 0x3e, 0x98, 0x90, 0x62, 0x4c, 0xb1, 0xbe, 0x43, 0x98, 0x62, 0xf6, + 0x5f, 0x5a, 0x80, 0xf8, 0x67, 0xbf, 0xeb, 0x3e, 0xf6, 0x7a, 0xfa, 0x63, 0x0f, 0x61, 0x5a, 0xd8, + 0x7f, 0xc7, 0x82, 0xe1, 0x85, 0xa6, 0xe3, 0x6e, 0x8b, 0x4f, 0x5d, 0x80, 0x49, 0xa9, 0x28, 0x62, + 0x60, 0x4d, 0xf6, 0xa7, 0x9b, 0xdb, 0x24, 0x4e, 0x22, 0x71, 0x9a, 0x1e, 0x7d, 0x1c, 0x4e, 0x1a, + 0xc0, 0x35, 0xb2, 0xdd, 0x6a, 0x3a, 0x91, 0x7e, 0x2b, 0x60, 0xa7, 0x3f, 0xce, 0x23, 0xc2, 0xf9, + 0xe5, 0xed, 0xab, 0x30, 0xb6, 0xd0, 0x74, 0x89, 0x17, 0x55, 0xaa, 0x0b, 0xbe, 0xb7, 0xee, 0x6e, + 0xa0, 0x97, 0x61, 0x2c, 0x72, 0xb7, 0x89, 0xdf, 0x8e, 0x6a, 0xa4, 0xee, 0x7b, 0xec, 0xae, 0x6d, + 0x9d, 0xef, 0x9f, 0x47, 0xf7, 0xf6, 0xca, 0x63, 0x6b, 0x06, 0x06, 0x27, 0x28, 0xed, 0x3f, 0xa2, + 0x23, 0xee, 0x6f, 0xb7, 0x7c, 0x8f, 0x78, 0xd1, 0x82, 0xef, 0x35, 0xb8, 0x4e, 0xe6, 0x65, 0xe8, + 0x8b, 0xe8, 0x08, 0xf2, 0x2f, 0x3f, 0x27, 0x97, 0x36, 0x1d, 0xb7, 0xfd, 0xbd, 0xf2, 0x89, 0x74, + 0x09, 0x36, 0xb2, 0xac, 0x0c, 0xfa, 0x10, 0x0c, 0x84, 0x91, 0x13, 0xb5, 0x43, 0xf1, 0xa9, 0x8f, + 0xc8, 0xf1, 0xaf, 0x31, 0xe8, 0xfe, 0x5e, 0x79, 0x5c, 0x15, 0xe3, 0x20, 0x2c, 0x0a, 0xa0, 0x27, + 0x61, 0x70, 0x9b, 0x84, 0xa1, 0xb3, 0x21, 0xcf, 0xef, 0x71, 0x51, 0x76, 0x70, 0x85, 0x83, 0xb1, + 0xc4, 0xa3, 0x47, 0xa1, 0x9f, 0x04, 0x81, 0x1f, 0x88, 0x5d, 0x65, 0x54, 0x10, 0xf6, 0x2f, 0x51, + 0x20, 0xe6, 0x38, 0xfb, 0x5f, 0x5a, 0x30, 0xae, 0xda, 0xca, 0xeb, 0x3a, 0x82, 0x7b, 0xd3, 0x9b, + 0x00, 0x75, 0xf9, 0x81, 0x21, 0x3b, 0xef, 0x86, 0x9f, 0x3b, 0x97, 0x29, 0x5a, 0xa4, 0xba, 0x31, + 0xe6, 0xac, 0x40, 0x21, 0xd6, 0xb8, 0xd9, 0xbf, 0x6e, 0xc1, 0x54, 0xe2, 0x8b, 0xae, 0xba, 0x61, + 0x84, 0xde, 0x4a, 0x7d, 0xd5, 0x6c, 0x6f, 0x5f, 0x45, 0x4b, 0xb3, 0x6f, 0x52, 0x8b, 0x4f, 0x42, + 0xb4, 0x2f, 0xba, 0x0c, 0xfd, 0x6e, 0x44, 0xb6, 0xe5, 0xc7, 0x3c, 0xda, 0xf1, 0x63, 0x78, 0xab, + 0xe2, 0x11, 0xa9, 0xd0, 0x92, 0x98, 0x33, 0xb0, 0x7f, 0xab, 0x08, 0x25, 0x3e, 0x6d, 0x57, 0x9c, + 0xd6, 0x11, 0x8c, 0xc5, 0xd3, 0x50, 0x72, 0xb7, 0xb7, 0xdb, 0x91, 0x73, 0x4b, 0x1c, 0x40, 0x43, + 0x7c, 0x33, 0xa8, 0x48, 0x20, 0x8e, 0xf1, 0xa8, 0x02, 0x7d, 0xac, 0x29, 0xfc, 0x2b, 0x9f, 0xc8, + 0xfe, 0x4a, 0xd1, 0xf6, 0xd9, 0x45, 0x27, 0x72, 0xb8, 0xec, 0xa7, 0x4e, 0x3e, 0x0a, 0xc2, 0x8c, + 0x05, 0x72, 0x00, 0x6e, 0xb9, 0x9e, 0x13, 0xec, 0x52, 0xd8, 0x74, 0x91, 0x31, 0x7c, 0xb6, 0x33, + 0xc3, 0x79, 0x45, 0xcf, 0xd9, 0xaa, 0x0f, 0x8b, 0x11, 0x58, 0x63, 0x3a, 0xf3, 0x41, 0x28, 0x29, + 0xe2, 0x83, 0x88, 0x70, 0x33, 0x1f, 0x86, 0xf1, 0x44, 0x5d, 0xdd, 0x8a, 0x8f, 0xe8, 0x12, 0xe0, + 0xaf, 0xb2, 0x2d, 0x43, 0xb4, 0x7a, 0xc9, 0xdb, 0x11, 0x3b, 0xe7, 0x5d, 0x38, 0xd6, 0xcc, 0xd8, + 0x7b, 0xc5, 0xb8, 0xf6, 0xbe, 0x57, 0x9f, 0x12, 0x9f, 0x7d, 0x2c, 0x0b, 0x8b, 0x33, 0xeb, 0xa0, + 0x52, 0x8d, 0xdf, 0xa2, 0x0b, 0xc4, 0x69, 0xea, 0x17, 0x84, 0x6b, 0x02, 0x86, 0x15, 0x96, 0xee, + 0x77, 0xc7, 0x54, 0xe3, 0xaf, 0x90, 0xdd, 0x1a, 0x69, 0x92, 0x7a, 0xe4, 0x07, 0xdf, 0xd2, 0xe6, + 0x9f, 0xe6, 0xbd, 0xcf, 0xb7, 0xcb, 0x61, 0xc1, 0xa0, 0x78, 0x85, 0xec, 0xf2, 0xa1, 0xd0, 0xbf, + 0xae, 0xd8, 0xf1, 0xeb, 0xbe, 0x6a, 0xc1, 0xa8, 0xfa, 0xba, 0x23, 0xd8, 0x17, 0xe6, 0xcd, 0x7d, + 0xe1, 0x74, 0xc7, 0x09, 0x9e, 0xb3, 0x23, 0x7c, 0xbd, 0x00, 0x27, 0x15, 0x0d, 0xbd, 0xcd, 0xf0, + 0x3f, 0x62, 0x56, 0x5d, 0x80, 0x92, 0xa7, 0xf4, 0x7a, 0x96, 0xa9, 0x50, 0x8b, 0xb5, 0x7a, 0x31, + 0x0d, 0x15, 0x4a, 0xbd, 0xf8, 0x98, 0x1d, 0xd1, 0x15, 0xde, 0x42, 0xb9, 0x3d, 0x0f, 0xc5, 0xb6, + 0xdb, 0x10, 0x07, 0xcc, 0xfb, 0x65, 0x6f, 0x5f, 0xaf, 0x2c, 0xee, 0xef, 0x95, 0x1f, 0xc9, 0x33, + 0xb6, 0xd0, 0x93, 0x2d, 0x9c, 0xbd, 0x5e, 0x59, 0xc4, 0xb4, 0x30, 0x9a, 0x83, 0x71, 0x79, 0x42, + 0xdf, 0xa0, 0x02, 0xa2, 0xef, 0x89, 0x73, 0x48, 0x69, 0xad, 0xb1, 0x89, 0xc6, 0x49, 0x7a, 0xb4, + 0x08, 0x13, 0x5b, 0xed, 0x5b, 0xa4, 0x49, 0x22, 0xfe, 0xc1, 0x57, 0x08, 0xd7, 0xe9, 0x96, 0xe2, + 0xbb, 0xe4, 0x95, 0x04, 0x1e, 0xa7, 0x4a, 0xd8, 0x7f, 0xc3, 0xce, 0x03, 0xd1, 0x7b, 0xd5, 0xc0, + 0xa7, 0x13, 0x8b, 0x72, 0xff, 0x56, 0x4e, 0xe7, 0x5e, 0x66, 0xc5, 0x15, 0xb2, 0xbb, 0xe6, 0xd3, + 0xbb, 0x44, 0xf6, 0xac, 0x30, 0xe6, 0x7c, 0x5f, 0xc7, 0x39, 0xff, 0x8b, 0x05, 0x38, 0xae, 0x7a, + 0xc0, 0x10, 0x5b, 0xbf, 0xdd, 0xfb, 0xe0, 0x22, 0x0c, 0x37, 0xc8, 0xba, 0xd3, 0x6e, 0x46, 0xca, + 0xc0, 0xd0, 0xcf, 0x8d, 0x4c, 0x8b, 0x31, 0x18, 0xeb, 0x34, 0x07, 0xe8, 0xb6, 0x9f, 0x1f, 0x65, + 0x07, 0x71, 0xe4, 0xd0, 0x39, 0xae, 0x56, 0x8d, 0x95, 0xbb, 0x6a, 0x1e, 0x85, 0x7e, 0x77, 0x9b, + 0x0a, 0x66, 0x05, 0x53, 0xde, 0xaa, 0x50, 0x20, 0xe6, 0x38, 0xf4, 0x38, 0x0c, 0xd6, 0xfd, 0xed, + 0x6d, 0xc7, 0x6b, 0xb0, 0x23, 0xaf, 0x34, 0x3f, 0x4c, 0x65, 0xb7, 0x05, 0x0e, 0xc2, 0x12, 0x87, + 0x4e, 0x41, 0x9f, 0x13, 0x6c, 0x70, 0xad, 0x4b, 0x69, 0x7e, 0x88, 0xd6, 0x34, 0x17, 0x6c, 0x84, + 0x98, 0x41, 0xe9, 0xa5, 0xf1, 0xb6, 0x1f, 0x6c, 0xb9, 0xde, 0xc6, 0xa2, 0x1b, 0x88, 0x25, 0xa1, + 0xce, 0xc2, 0x9b, 0x0a, 0x83, 0x35, 0x2a, 0xb4, 0x0c, 0xfd, 0x2d, 0x3f, 0x88, 0xc2, 0xe9, 0x01, + 0xd6, 0xdd, 0x8f, 0xe4, 0x6c, 0x44, 0xfc, 0x6b, 0xab, 0x7e, 0x10, 0xc5, 0x1f, 0x40, 0xff, 0x85, + 0x98, 0x17, 0x47, 0x57, 0x61, 0x90, 0x78, 0x3b, 0xcb, 0x81, 0xbf, 0x3d, 0x3d, 0x95, 0xcf, 0x69, + 0x89, 0x93, 0xf0, 0x69, 0x16, 0xcb, 0xa8, 0x02, 0x8c, 0x25, 0x0b, 0xf4, 0x21, 0x28, 0x12, 0x6f, + 0x67, 0x7a, 0x90, 0x71, 0x9a, 0xc9, 0xe1, 0x74, 0xc3, 0x09, 0xe2, 0x3d, 0x7f, 0xc9, 0xdb, 0xc1, + 0xb4, 0x0c, 0xfa, 0x18, 0x94, 0xe4, 0x86, 0x11, 0x0a, 0x75, 0x66, 0xe6, 0x84, 0x95, 0xdb, 0x0c, + 0x26, 0x6f, 0xb7, 0xdd, 0x80, 0x6c, 0x13, 0x2f, 0x0a, 0xe3, 0x1d, 0x52, 0x62, 0x43, 0x1c, 0x73, + 0x43, 0x75, 0x18, 0x09, 0x48, 0xe8, 0xde, 0x25, 0x55, 0xbf, 0xe9, 0xd6, 0x77, 0xa7, 0x1f, 0x62, + 0xcd, 0x7b, 0xb2, 0x63, 0x97, 0x61, 0xad, 0x40, 0xac, 0x6e, 0xd7, 0xa1, 0xd8, 0x60, 0x8a, 0xde, + 0x80, 0xd1, 0x80, 0x84, 0x91, 0x13, 0x44, 0xa2, 0x96, 0x69, 0x65, 0x1e, 0x1b, 0xc5, 0x3a, 0x82, + 0x5f, 0x27, 0xe2, 0x6a, 0x62, 0x0c, 0x36, 0x39, 0xa0, 0x8f, 0x49, 0xdd, 0xff, 0x8a, 0xdf, 0xf6, + 0xa2, 0x70, 0xba, 0xc4, 0xda, 0x9d, 0x69, 0x95, 0xbd, 0x11, 0xd3, 0x25, 0x8d, 0x03, 0xbc, 0x30, + 0x36, 0x58, 0xa1, 0x4f, 0xc0, 0x28, 0xff, 0xcf, 0x6d, 0x9b, 0xe1, 0xf4, 0x71, 0xc6, 0xfb, 0x6c, + 0x3e, 0x6f, 0x4e, 0x38, 0x7f, 0x5c, 0x30, 0x1f, 0xd5, 0xa1, 0x21, 0x36, 0xb9, 0x21, 0x0c, 0xa3, + 0x4d, 0x77, 0x87, 0x78, 0x24, 0x0c, 0xab, 0x81, 0x7f, 0x8b, 0x08, 0x55, 0xed, 0xc9, 0x6c, 0x5b, + 0xa8, 0x7f, 0x8b, 0xcc, 0x4f, 0x52, 0x9e, 0x57, 0xf5, 0x32, 0xd8, 0x64, 0x81, 0xae, 0xc3, 0x18, + 0xbd, 0x1b, 0xbb, 0x31, 0xd3, 0xe1, 0x6e, 0x4c, 0xd9, 0x7d, 0x10, 0x1b, 0x85, 0x70, 0x82, 0x09, + 0xba, 0x06, 0x23, 0xac, 0xcf, 0xdb, 0x2d, 0xce, 0xf4, 0x44, 0x37, 0xa6, 0xcc, 0x94, 0x5e, 0xd3, + 0x8a, 0x60, 0x83, 0x01, 0x7a, 0x1d, 0x4a, 0x4d, 0x77, 0x9d, 0xd4, 0x77, 0xeb, 0x4d, 0x32, 0x3d, + 0xc2, 0xb8, 0x65, 0x6e, 0x86, 0x57, 0x25, 0x11, 0x97, 0xcf, 0xd5, 0x5f, 0x1c, 0x17, 0x47, 0x37, + 0xe0, 0x44, 0x44, 0x82, 0x6d, 0xd7, 0x73, 0xe8, 0x26, 0x26, 0xae, 0x84, 0xcc, 0x44, 0x3d, 0xca, + 0x66, 0xd7, 0x19, 0x31, 0x1a, 0x27, 0xd6, 0x32, 0xa9, 0x70, 0x4e, 0x69, 0x74, 0x07, 0xa6, 0x33, + 0x30, 0x7c, 0xde, 0x1e, 0x63, 0x9c, 0x5f, 0x15, 0x9c, 0xa7, 0xd7, 0x72, 0xe8, 0xf6, 0x3b, 0xe0, + 0x70, 0x2e, 0x77, 0x74, 0x0d, 0xc6, 0xd9, 0xce, 0x59, 0x6d, 0x37, 0x9b, 0xa2, 0xc2, 0x31, 0x56, + 0xe1, 0xe3, 0x52, 0x8e, 0xa8, 0x98, 0xe8, 0xfd, 0xbd, 0x32, 0xc4, 0xff, 0x70, 0xb2, 0x34, 0xba, + 0xc5, 0xac, 0xa1, 0xed, 0xc0, 0x8d, 0x76, 0xe9, 0xaa, 0x22, 0x77, 0xa2, 0xe9, 0xf1, 0x8e, 0x9a, + 0x21, 0x9d, 0x54, 0x99, 0x4c, 0x75, 0x20, 0x4e, 0x32, 0xa4, 0x47, 0x41, 0x18, 0x35, 0x5c, 0x6f, + 0x7a, 0x82, 0xdf, 0xa7, 0xe4, 0x4e, 0x5a, 0xa3, 0x40, 0xcc, 0x71, 0xcc, 0x12, 0x4a, 0x7f, 0x5c, + 0xa3, 0x27, 0xee, 0x24, 0x23, 0x8c, 0x2d, 0xa1, 0x12, 0x81, 0x63, 0x1a, 0x2a, 0x04, 0x47, 0xd1, + 0xee, 0x34, 0x62, 0xa4, 0x6a, 0x43, 0x5c, 0x5b, 0xfb, 0x18, 0xa6, 0x70, 0xfb, 0x16, 0x8c, 0xa9, + 0x6d, 0x82, 0xf5, 0x09, 0x2a, 0x43, 0x3f, 0x13, 0xfb, 0x84, 0x1e, 0xb3, 0x44, 0x9b, 0xc0, 0x44, + 0x42, 0xcc, 0xe1, 0xac, 0x09, 0xee, 0x5d, 0x32, 0xbf, 0x1b, 0x11, 0xae, 0x8b, 0x28, 0x6a, 0x4d, + 0x90, 0x08, 0x1c, 0xd3, 0xd8, 0xff, 0x83, 0x8b, 0xcf, 0xf1, 0x29, 0xd1, 0xc3, 0xb9, 0xf8, 0x0c, + 0x0c, 0x6d, 0xfa, 0x61, 0x44, 0xa9, 0x59, 0x1d, 0xfd, 0xb1, 0xc0, 0x7c, 0x59, 0xc0, 0xb1, 0xa2, + 0x40, 0xaf, 0xc0, 0x68, 0x5d, 0xaf, 0x40, 0x1c, 0xea, 0x6a, 0x1b, 0x31, 0x6a, 0xc7, 0x26, 0x2d, + 0x7a, 0x09, 0x86, 0x98, 0x77, 0x4f, 0xdd, 0x6f, 0x0a, 0x69, 0x53, 0x4a, 0x26, 0x43, 0x55, 0x01, + 0xdf, 0xd7, 0x7e, 0x63, 0x45, 0x8d, 0xce, 0xc1, 0x00, 0x6d, 0x42, 0xa5, 0x2a, 0x8e, 0x53, 0xa5, + 0x92, 0xbb, 0xcc, 0xa0, 0x58, 0x60, 0xed, 0x5f, 0xb7, 0x98, 0x2c, 0x95, 0xde, 0xf3, 0xd1, 0x65, + 0x76, 0x68, 0xb0, 0x13, 0x44, 0x53, 0x89, 0x3d, 0xa6, 0x9d, 0x04, 0x0a, 0xb7, 0x9f, 0xf8, 0x8f, + 0x8d, 0x92, 0xe8, 0xcd, 0xe4, 0xc9, 0xc0, 0x05, 0x8a, 0x17, 0x64, 0x17, 0x24, 0x4f, 0x87, 0x87, + 0xe3, 0x23, 0x8e, 0xb6, 0xa7, 0xd3, 0x11, 0x61, 0xff, 0x9f, 0x05, 0x6d, 0x96, 0xd4, 0x22, 0x27, + 0x22, 0xa8, 0x0a, 0x83, 0xb7, 0x1d, 0x37, 0x72, 0xbd, 0x0d, 0x21, 0xf7, 0x75, 0x3e, 0xe8, 0x58, + 0xa1, 0x9b, 0xbc, 0x00, 0x97, 0x5e, 0xc4, 0x1f, 0x2c, 0xd9, 0x50, 0x8e, 0x41, 0xdb, 0xf3, 0x28, + 0xc7, 0x42, 0xaf, 0x1c, 0x31, 0x2f, 0xc0, 0x39, 0x8a, 0x3f, 0x58, 0xb2, 0x41, 0x6f, 0x01, 0xc8, + 0x1d, 0x82, 0x34, 0x84, 0x57, 0xd0, 0x33, 0xdd, 0x99, 0xae, 0xa9, 0x32, 0xf3, 0x63, 0x54, 0x36, + 0x8a, 0xff, 0x63, 0x8d, 0x9f, 0x1d, 0x69, 0x63, 0xaa, 0x37, 0x06, 0x7d, 0x9c, 0x2e, 0x51, 0x27, + 0x88, 0x48, 0x63, 0x2e, 0x12, 0x9d, 0xf3, 0x54, 0x6f, 0x97, 0xc3, 0x35, 0x77, 0x9b, 0xe8, 0xcb, + 0x59, 0x30, 0xc1, 0x31, 0x3f, 0xfb, 0x97, 0x8b, 0x30, 0x9d, 0xd7, 0x5c, 0xba, 0x68, 0xc8, 0x1d, + 0x37, 0x5a, 0xa0, 0x62, 0xad, 0x65, 0x2e, 0x9a, 0x25, 0x01, 0xc7, 0x8a, 0x82, 0xce, 0xde, 0xd0, + 0xdd, 0x90, 0x77, 0xfb, 0xfe, 0x78, 0xf6, 0xd6, 0x18, 0x14, 0x0b, 0x2c, 0xa5, 0x0b, 0x88, 0x13, + 0x0a, 0xb7, 0x33, 0x6d, 0x96, 0x63, 0x06, 0xc5, 0x02, 0xab, 0x6b, 0x19, 0xfb, 0xba, 0x68, 0x19, + 0x8d, 0x2e, 0xea, 0x3f, 0xdc, 0x2e, 0x42, 0x9f, 0x04, 0x58, 0x77, 0x3d, 0x37, 0xdc, 0x64, 0xdc, + 0x07, 0x0e, 0xcc, 0x5d, 0x09, 0xc5, 0xcb, 0x8a, 0x0b, 0xd6, 0x38, 0xa2, 0x17, 0x61, 0x58, 0x6d, + 0x20, 0x95, 0x45, 0x66, 0x83, 0xd7, 0x7c, 0x9a, 0xe2, 0xdd, 0x74, 0x11, 0xeb, 0x74, 0xf6, 0xa7, + 0x93, 0xf3, 0x45, 0xac, 0x00, 0xad, 0x7f, 0xad, 0x5e, 0xfb, 0xb7, 0xd0, 0xb9, 0x7f, 0xed, 0x6f, + 0x0e, 0xc0, 0xb8, 0x51, 0x59, 0x3b, 0xec, 0x61, 0xcf, 0xbd, 0x44, 0x0f, 0x20, 0x27, 0x22, 0x62, + 0xfd, 0xd9, 0xdd, 0x97, 0x8a, 0x7e, 0x48, 0xd1, 0x15, 0xc0, 0xcb, 0xa3, 0x4f, 0x42, 0xa9, 0xe9, + 0x84, 0x4c, 0x63, 0x49, 0xc4, 0xba, 0xeb, 0x85, 0x59, 0x7c, 0x21, 0x74, 0xc2, 0x48, 0x3b, 0xf5, + 0x39, 0xef, 0x98, 0x25, 0x3d, 0x29, 0xa9, 0x7c, 0x25, 0xfd, 0x1a, 0x55, 0x23, 0xa8, 0x10, 0xb6, + 0x8b, 0x39, 0x0e, 0xbd, 0xc4, 0xb6, 0x56, 0x3a, 0x2b, 0x16, 0xa8, 0x34, 0xca, 0xa6, 0x59, 0xbf, + 0x21, 0x64, 0x2b, 0x1c, 0x36, 0x28, 0xe3, 0x3b, 0xd9, 0x40, 0x87, 0x3b, 0xd9, 0x93, 0x30, 0xc8, + 0x7e, 0xa8, 0x19, 0xa0, 0x46, 0xa3, 0xc2, 0xc1, 0x58, 0xe2, 0x93, 0x13, 0x66, 0xa8, 0xb7, 0x09, + 0x43, 0x6f, 0x7d, 0x62, 0x52, 0x33, 0xff, 0x87, 0x21, 0xbe, 0xcb, 0x89, 0x29, 0x8f, 0x25, 0x0e, + 0xfd, 0xb4, 0x05, 0xc8, 0x69, 0xd2, 0xdb, 0x32, 0x05, 0xab, 0xcb, 0x0d, 0x30, 0x51, 0xfb, 0x95, + 0xae, 0xdd, 0xde, 0x0e, 0x67, 0xe7, 0x52, 0xa5, 0xb9, 0xa6, 0xf4, 0x65, 0xd1, 0x44, 0x94, 0x26, + 0xd0, 0x0f, 0xa3, 0xab, 0x6e, 0x18, 0x7d, 0xee, 0x8f, 0x13, 0x87, 0x53, 0x46, 0x93, 0xd0, 0x75, + 0xfd, 0xf2, 0x35, 0x7c, 0xc0, 0xcb, 0xd7, 0x68, 0xde, 0xc5, 0x6b, 0xa6, 0x0d, 0x0f, 0xe5, 0x7c, + 0x41, 0x86, 0xfe, 0x75, 0x51, 0xd7, 0xbf, 0x76, 0xd1, 0xda, 0xcd, 0xca, 0x3a, 0x66, 0xdf, 0x68, + 0x3b, 0x5e, 0xe4, 0x46, 0xbb, 0xba, 0xbe, 0xf6, 0x29, 0x18, 0x5b, 0x74, 0xc8, 0xb6, 0xef, 0x2d, + 0x79, 0x8d, 0x96, 0xef, 0x7a, 0x11, 0x9a, 0x86, 0x3e, 0x26, 0x7c, 0xf0, 0xad, 0xb7, 0x8f, 0xf6, + 0x1e, 0x66, 0x10, 0x7b, 0x03, 0x8e, 0x2f, 0xfa, 0xb7, 0xbd, 0xdb, 0x4e, 0xd0, 0x98, 0xab, 0x56, + 0x34, 0x7d, 0xd2, 0xaa, 0xd4, 0x67, 0x58, 0xf9, 0xb7, 0x45, 0xad, 0x24, 0xbf, 0x0e, 0x2d, 0xbb, + 0x4d, 0x92, 0xa3, 0xf5, 0xfb, 0x7f, 0x0a, 0x46, 0x4d, 0x31, 0xbd, 0xb2, 0x3b, 0x5b, 0xb9, 0x76, + 0xe7, 0x37, 0x60, 0x68, 0xdd, 0x25, 0xcd, 0x06, 0x26, 0xeb, 0xa2, 0x77, 0x9e, 0xc8, 0xf7, 0x4c, + 0x5b, 0xa6, 0x94, 0x52, 0xcb, 0xcb, 0xb5, 0x21, 0xcb, 0xa2, 0x30, 0x56, 0x6c, 0xd0, 0x16, 0x4c, + 0xc8, 0x3e, 0x94, 0x58, 0xb1, 0x1f, 0x3c, 0xd9, 0x69, 0xe0, 0x4d, 0xe6, 0xc7, 0xee, 0xed, 0x95, + 0x27, 0x70, 0x82, 0x0d, 0x4e, 0x31, 0x46, 0xa7, 0xa0, 0x6f, 0x9b, 0x9e, 0x7c, 0x7d, 0xac, 0xfb, + 0x99, 0xfa, 0x83, 0x69, 0x72, 0x18, 0xd4, 0xfe, 0x31, 0x0b, 0x1e, 0x4a, 0xf5, 0x8c, 0xd0, 0x68, + 0x1d, 0xf2, 0x28, 0x24, 0x35, 0x4c, 0x85, 0xee, 0x1a, 0x26, 0xfb, 0xe7, 0x2c, 0x38, 0xb6, 0xb4, + 0xdd, 0x8a, 0x76, 0x17, 0x5d, 0xd3, 0x48, 0xfc, 0x41, 0x18, 0xd8, 0x26, 0x0d, 0xb7, 0xbd, 0x2d, + 0x46, 0xae, 0x2c, 0x4f, 0x87, 0x15, 0x06, 0xdd, 0xdf, 0x2b, 0x8f, 0xd6, 0x22, 0x3f, 0x70, 0x36, + 0x08, 0x07, 0x60, 0x41, 0xce, 0xce, 0x58, 0xf7, 0x2e, 0xb9, 0xea, 0x6e, 0xbb, 0xd1, 0xfd, 0xcd, + 0x76, 0x61, 0xdf, 0x95, 0x4c, 0x70, 0xcc, 0xcf, 0xfe, 0x86, 0x05, 0xe3, 0x72, 0xde, 0xcf, 0x35, + 0x1a, 0x01, 0x09, 0x43, 0x34, 0x03, 0x05, 0xb7, 0x25, 0x5a, 0x09, 0xa2, 0x95, 0x85, 0x4a, 0x15, + 0x17, 0xdc, 0x96, 0x14, 0xe7, 0xd9, 0x01, 0x54, 0x34, 0x4d, 0xdd, 0x97, 0x05, 0x1c, 0x2b, 0x0a, + 0x74, 0x1e, 0x86, 0x3c, 0xbf, 0xc1, 0x25, 0x62, 0x2e, 0x4a, 0xb0, 0x09, 0xb6, 0x2a, 0x60, 0x58, + 0x61, 0x51, 0x15, 0x4a, 0xdc, 0x11, 0x32, 0x9e, 0xb4, 0x3d, 0xb9, 0x53, 0xb2, 0x2f, 0x5b, 0x93, + 0x25, 0x71, 0xcc, 0xc4, 0xfe, 0x4d, 0x0b, 0x46, 0xe4, 0x97, 0xf5, 0x78, 0x57, 0xa1, 0x4b, 0x2b, + 0xbe, 0xa7, 0xc4, 0x4b, 0x8b, 0xde, 0x35, 0x18, 0xc6, 0xb8, 0x62, 0x14, 0x0f, 0x74, 0xc5, 0xb8, + 0x08, 0xc3, 0x4e, 0xab, 0x55, 0x35, 0xef, 0x27, 0x6c, 0x2a, 0xcd, 0xc5, 0x60, 0xac, 0xd3, 0xd8, + 0x3f, 0x5a, 0x80, 0x31, 0xf9, 0x05, 0xb5, 0xf6, 0xad, 0x90, 0x44, 0x68, 0x0d, 0x4a, 0x0e, 0x1f, + 0x25, 0x22, 0x27, 0xf9, 0xa3, 0xd9, 0x7a, 0x33, 0x63, 0x48, 0x63, 0x41, 0x6b, 0x4e, 0x96, 0xc6, + 0x31, 0x23, 0xd4, 0x84, 0x49, 0xcf, 0x8f, 0xd8, 0xa1, 0xab, 0xf0, 0x9d, 0x4c, 0x99, 0x49, 0xee, + 0x27, 0x05, 0xf7, 0xc9, 0xd5, 0x24, 0x17, 0x9c, 0x66, 0x8c, 0x96, 0xa4, 0x2e, 0xb2, 0x98, 0xaf, + 0x44, 0xd2, 0x07, 0x2e, 0x5b, 0x15, 0x69, 0xff, 0x9a, 0x05, 0x25, 0x49, 0x76, 0x14, 0x56, 0xeb, + 0x15, 0x18, 0x0c, 0xd9, 0x20, 0xc8, 0xae, 0xb1, 0x3b, 0x35, 0x9c, 0x8f, 0x57, 0x2c, 0x4b, 0xf0, + 0xff, 0x21, 0x96, 0x3c, 0x98, 0x29, 0x4a, 0x35, 0xff, 0x5d, 0x62, 0x8a, 0x52, 0xed, 0xc9, 0x39, + 0x94, 0xfe, 0x8c, 0xb5, 0x59, 0xd3, 0xed, 0x52, 0x91, 0xb7, 0x15, 0x90, 0x75, 0xf7, 0x4e, 0x52, + 0xe4, 0xad, 0x32, 0x28, 0x16, 0x58, 0xf4, 0x16, 0x8c, 0xd4, 0xa5, 0x0d, 0x22, 0x5e, 0xe1, 0xe7, + 0x3a, 0xda, 0xc3, 0x94, 0xe9, 0x94, 0xeb, 0xd0, 0x16, 0xb4, 0xf2, 0xd8, 0xe0, 0x66, 0x3a, 0xfa, + 0x14, 0xbb, 0x39, 0xfa, 0xc4, 0x7c, 0xf3, 0xdd, 0x5e, 0x7e, 0xdc, 0x82, 0x01, 0xae, 0x7b, 0xee, + 0x4d, 0xf5, 0xaf, 0x59, 0x92, 0xe3, 0xbe, 0xbb, 0x41, 0x81, 0x42, 0xd2, 0x40, 0x2b, 0x50, 0x62, + 0x3f, 0x98, 0xee, 0xbc, 0x98, 0xff, 0x0e, 0x87, 0xd7, 0xaa, 0x37, 0xf0, 0x86, 0x2c, 0x86, 0x63, + 0x0e, 0xf6, 0x8f, 0x14, 0xe9, 0xee, 0x16, 0x93, 0x1a, 0x87, 0xbe, 0xf5, 0xe0, 0x0e, 0xfd, 0xc2, + 0x83, 0x3a, 0xf4, 0x37, 0x60, 0xbc, 0xae, 0xd9, 0x9d, 0xe3, 0x91, 0x3c, 0xdf, 0x71, 0x92, 0x68, + 0x26, 0x6a, 0xae, 0x9d, 0x5b, 0x30, 0x99, 0xe0, 0x24, 0x57, 0xf4, 0x71, 0x18, 0xe1, 0xe3, 0x2c, + 0x6a, 0xe1, 0xbe, 0x52, 0x8f, 0xe7, 0xcf, 0x17, 0xbd, 0x0a, 0xae, 0xcd, 0xd5, 0x8a, 0x63, 0x83, + 0x99, 0xfd, 0x57, 0x16, 0xa0, 0xa5, 0xd6, 0x26, 0xd9, 0x26, 0x81, 0xd3, 0x8c, 0xcd, 0x47, 0x5f, + 0xb4, 0x60, 0x9a, 0xa4, 0xc0, 0x0b, 0xfe, 0xf6, 0xb6, 0xb8, 0x2c, 0xe6, 0xe8, 0x33, 0x96, 0x72, + 0xca, 0xa8, 0x87, 0x4a, 0xd3, 0x79, 0x14, 0x38, 0xb7, 0x3e, 0xb4, 0x02, 0x53, 0xfc, 0x94, 0x54, + 0x08, 0xcd, 0xef, 0xea, 0x61, 0xc1, 0x78, 0x6a, 0x2d, 0x4d, 0x82, 0xb3, 0xca, 0xd9, 0xbf, 0x36, + 0x0a, 0xb9, 0xad, 0x78, 0xcf, 0x6e, 0xf6, 0x9e, 0xdd, 0xec, 0x3d, 0xbb, 0xd9, 0x7b, 0x76, 0xb3, + 0xf7, 0xec, 0x66, 0xef, 0xd9, 0xcd, 0xde, 0xa5, 0x76, 0xb3, 0xff, 0xcb, 0x82, 0xe3, 0xea, 0xf8, + 0x32, 0x2e, 0xec, 0x9f, 0x81, 0x29, 0xbe, 0xdc, 0x0c, 0x1f, 0x63, 0x71, 0x5c, 0x5f, 0xcc, 0x9c, + 0xb9, 0x09, 0x5f, 0x78, 0xa3, 0x20, 0x7f, 0x54, 0x94, 0x81, 0xc0, 0x59, 0xd5, 0xd8, 0xbf, 0x3c, + 0x04, 0xfd, 0x4b, 0x3b, 0xc4, 0x8b, 0x8e, 0xe0, 0x6a, 0x53, 0x87, 0x31, 0xd7, 0xdb, 0xf1, 0x9b, + 0x3b, 0xa4, 0xc1, 0xf1, 0x07, 0xb9, 0x81, 0x9f, 0x10, 0xac, 0xc7, 0x2a, 0x06, 0x0b, 0x9c, 0x60, + 0xf9, 0x20, 0xac, 0x0f, 0x97, 0x60, 0x80, 0x1f, 0x3e, 0xc2, 0xf4, 0x90, 0xb9, 0x67, 0xb3, 0x4e, + 0x14, 0x47, 0x6a, 0x6c, 0x19, 0xe1, 0x87, 0x9b, 0x28, 0x8e, 0x3e, 0x0d, 0x63, 0xeb, 0x6e, 0x10, + 0x46, 0x6b, 0xee, 0x36, 0x3d, 0x1a, 0xb6, 0x5b, 0xf7, 0x61, 0x6d, 0x50, 0xfd, 0xb0, 0x6c, 0x70, + 0xc2, 0x09, 0xce, 0x68, 0x03, 0x46, 0x9b, 0x8e, 0x5e, 0xd5, 0xe0, 0x81, 0xab, 0x52, 0xa7, 0xc3, + 0x55, 0x9d, 0x11, 0x36, 0xf9, 0xd2, 0xe5, 0x54, 0x67, 0x0a, 0xf3, 0x21, 0xa6, 0xce, 0x50, 0xcb, + 0x89, 0x6b, 0xca, 0x39, 0x8e, 0x0a, 0x68, 0xcc, 0x91, 0xbd, 0x64, 0x0a, 0x68, 0x9a, 0xbb, 0xfa, + 0xa7, 0xa0, 0x44, 0x68, 0x17, 0x52, 0xc6, 0xe2, 0x80, 0xb9, 0xd0, 0x5b, 0x5b, 0x57, 0xdc, 0x7a, + 0xe0, 0x9b, 0x76, 0x9e, 0x25, 0xc9, 0x09, 0xc7, 0x4c, 0xd1, 0x02, 0x0c, 0x84, 0x24, 0x70, 0x95, + 0x2e, 0xb9, 0xc3, 0x30, 0x32, 0x32, 0xfe, 0x6a, 0x8d, 0xff, 0xc6, 0xa2, 0x28, 0x9d, 0x5e, 0x0e, + 0x53, 0xc5, 0xb2, 0xc3, 0x40, 0x9b, 0x5e, 0x73, 0x0c, 0x8a, 0x05, 0x16, 0xbd, 0x0e, 0x83, 0x01, + 0x69, 0x32, 0x43, 0xe2, 0x68, 0xef, 0x93, 0x9c, 0xdb, 0x25, 0x79, 0x39, 0x2c, 0x19, 0xa0, 0x2b, + 0x80, 0x02, 0x42, 0x05, 0x3c, 0xd7, 0xdb, 0x50, 0xee, 0xdd, 0x62, 0xa3, 0x55, 0x82, 0x34, 0x8e, + 0x29, 0xe4, 0x83, 0x45, 0x9c, 0x51, 0x0c, 0x5d, 0x82, 0x49, 0x05, 0xad, 0x78, 0x61, 0xe4, 0xd0, + 0x0d, 0x6e, 0x9c, 0xf1, 0x52, 0xfa, 0x15, 0x9c, 0x24, 0xc0, 0xe9, 0x32, 0xf6, 0xcf, 0x5a, 0xc0, + 0xfb, 0xf9, 0x08, 0xb4, 0x0a, 0xaf, 0x99, 0x5a, 0x85, 0x93, 0xb9, 0x23, 0x97, 0xa3, 0x51, 0xf8, + 0x59, 0x0b, 0x86, 0xb5, 0x91, 0x8d, 0xe7, 0xac, 0xd5, 0x61, 0xce, 0xb6, 0x61, 0x82, 0xce, 0xf4, + 0x6b, 0xb7, 0x42, 0x12, 0xec, 0x90, 0x06, 0x9b, 0x98, 0x85, 0xfb, 0x9b, 0x98, 0xca, 0x95, 0xf4, + 0x6a, 0x82, 0x21, 0x4e, 0x55, 0x61, 0x7f, 0x4a, 0x36, 0x55, 0x79, 0xde, 0xd6, 0xd5, 0x98, 0x27, + 0x3c, 0x6f, 0xd5, 0xa8, 0xe2, 0x98, 0x86, 0x2e, 0xb5, 0x4d, 0x3f, 0x8c, 0x92, 0x9e, 0xb7, 0x97, + 0xfd, 0x30, 0xc2, 0x0c, 0x63, 0x3f, 0x0f, 0xb0, 0x74, 0x87, 0xd4, 0xf9, 0x8c, 0xd5, 0x2f, 0x3d, + 0x56, 0xfe, 0xa5, 0xc7, 0xfe, 0x7d, 0x0b, 0xc6, 0x96, 0x17, 0x8c, 0x93, 0x6b, 0x16, 0x80, 0xdf, + 0xd4, 0x6e, 0xde, 0x5c, 0x95, 0xee, 0x1f, 0xdc, 0x02, 0xae, 0xa0, 0x58, 0xa3, 0x40, 0x27, 0xa1, + 0xd8, 0x6c, 0x7b, 0x42, 0xed, 0x39, 0x48, 0x8f, 0xc7, 0xab, 0x6d, 0x0f, 0x53, 0x98, 0xf6, 0x58, + 0xa9, 0xd8, 0xf3, 0x63, 0xa5, 0xae, 0x41, 0x4a, 0x50, 0x19, 0xfa, 0x6f, 0xdf, 0x76, 0x1b, 0xfc, + 0x29, 0xb8, 0x70, 0x4d, 0xb9, 0x79, 0xb3, 0xb2, 0x18, 0x62, 0x0e, 0xb7, 0xbf, 0x54, 0x84, 0x99, + 0xe5, 0x26, 0xb9, 0xf3, 0x0e, 0x9f, 0xc3, 0xf7, 0xfa, 0xd4, 0xea, 0x60, 0x0a, 0xa4, 0x83, 0x3e, + 0xa7, 0xeb, 0xde, 0x1f, 0xeb, 0x30, 0xc8, 0x1d, 0x4f, 0xe5, 0xe3, 0xf8, 0x4c, 0x73, 0x5f, 0x7e, + 0x87, 0xcc, 0x72, 0x07, 0x56, 0x61, 0xee, 0x53, 0x07, 0xa6, 0x80, 0x62, 0xc9, 0x7c, 0xe6, 0x65, + 0x18, 0xd1, 0x29, 0x0f, 0xf4, 0xb0, 0xf5, 0x7b, 0x8b, 0x30, 0x41, 0x5b, 0xf0, 0x40, 0x07, 0xe2, + 0x7a, 0x7a, 0x20, 0x0e, 0xfb, 0x71, 0x63, 0xf7, 0xd1, 0x78, 0x2b, 0x39, 0x1a, 0x17, 0xf3, 0x46, + 0xe3, 0xa8, 0xc7, 0xe0, 0xfb, 0x2c, 0x98, 0x5a, 0x6e, 0xfa, 0xf5, 0xad, 0xc4, 0x03, 0xc4, 0x17, + 0x61, 0x98, 0x6e, 0xc7, 0xa1, 0x11, 0x8b, 0xc3, 0x88, 0xce, 0x22, 0x50, 0x58, 0xa7, 0xd3, 0x8a, + 0x5d, 0xbf, 0x5e, 0x59, 0xcc, 0x0a, 0xea, 0x22, 0x50, 0x58, 0xa7, 0xb3, 0x7f, 0xd7, 0x82, 0xd3, + 0x97, 0x16, 0x96, 0xe2, 0xa9, 0x98, 0x8a, 0x2b, 0x73, 0x0e, 0x06, 0x5a, 0x0d, 0xad, 0x29, 0xb1, + 0x5a, 0x78, 0x91, 0xb5, 0x42, 0x60, 0xdf, 0x2d, 0x31, 0x93, 0xae, 0x03, 0x5c, 0xc2, 0xd5, 0x05, + 0xb1, 0xef, 0x4a, 0x2b, 0x90, 0x95, 0x6b, 0x05, 0x7a, 0x1c, 0x06, 0xe9, 0xb9, 0xe0, 0xd6, 0x65, + 0xbb, 0xb9, 0x41, 0x9f, 0x83, 0xb0, 0xc4, 0xd9, 0x3f, 0x63, 0xc1, 0xd4, 0x25, 0x37, 0xa2, 0x87, + 0x76, 0x32, 0x70, 0x0a, 0x3d, 0xb5, 0x43, 0x37, 0xf2, 0x83, 0xdd, 0x64, 0xe0, 0x14, 0xac, 0x30, + 0x58, 0xa3, 0xe2, 0x1f, 0xb4, 0xe3, 0xb2, 0x97, 0x14, 0x05, 0xd3, 0xee, 0x86, 0x05, 0x1c, 0x2b, + 0x0a, 0xda, 0x5f, 0x0d, 0x37, 0x60, 0x2a, 0xcb, 0x5d, 0xb1, 0x71, 0xab, 0xfe, 0x5a, 0x94, 0x08, + 0x1c, 0xd3, 0xd8, 0x7f, 0x61, 0x41, 0xf9, 0x52, 0xb3, 0x1d, 0x46, 0x24, 0x58, 0x0f, 0x73, 0x36, + 0xdd, 0xe7, 0xa1, 0x44, 0xa4, 0x81, 0x40, 0x3e, 0xf9, 0x94, 0x82, 0xa8, 0xb2, 0x1c, 0xf0, 0xf8, + 0x2d, 0x8a, 0xae, 0x87, 0x57, 0xd2, 0x07, 0x7b, 0xe6, 0xba, 0x0c, 0x88, 0xe8, 0x75, 0xe9, 0x01, + 0x6d, 0x58, 0x64, 0x8c, 0xa5, 0x14, 0x16, 0x67, 0x94, 0xb0, 0x7f, 0xcc, 0x82, 0xe3, 0xea, 0x83, + 0xdf, 0x75, 0x9f, 0x69, 0x7f, 0xad, 0x00, 0xa3, 0x97, 0xd7, 0xd6, 0xaa, 0x97, 0x48, 0xa4, 0xcd, + 0xca, 0xce, 0x66, 0x7f, 0xac, 0x59, 0x2f, 0x3b, 0xdd, 0x11, 0xdb, 0x91, 0xdb, 0x9c, 0xe5, 0x71, + 0xd1, 0x66, 0x2b, 0x5e, 0x74, 0x2d, 0xa8, 0x45, 0x81, 0xeb, 0x6d, 0x64, 0xce, 0x74, 0x29, 0xb3, + 0x14, 0xf3, 0x64, 0x16, 0xf4, 0x3c, 0x0c, 0xb0, 0xc0, 0x6c, 0x72, 0x10, 0x1e, 0x56, 0x57, 0x2c, + 0x06, 0xdd, 0xdf, 0x2b, 0x97, 0xae, 0xe3, 0x0a, 0xff, 0x83, 0x05, 0x29, 0xba, 0x0e, 0xc3, 0x9b, + 0x51, 0xd4, 0xba, 0x4c, 0x9c, 0x06, 0x09, 0xe4, 0x2e, 0x7b, 0x26, 0x6b, 0x97, 0xa5, 0x9d, 0xc0, + 0xc9, 0xe2, 0x8d, 0x29, 0x86, 0x85, 0x58, 0xe7, 0x63, 0xd7, 0x00, 0x62, 0xdc, 0x21, 0x19, 0x6e, + 0xec, 0x35, 0x28, 0xd1, 0xcf, 0x9d, 0x6b, 0xba, 0x4e, 0x67, 0xd3, 0xf8, 0xd3, 0x50, 0x92, 0x86, + 0xef, 0x50, 0x44, 0x71, 0x60, 0x27, 0x92, 0xb4, 0x8b, 0x87, 0x38, 0xc6, 0xdb, 0x8f, 0x81, 0xf0, + 0x2d, 0xed, 0xc4, 0xd2, 0x5e, 0x87, 0x63, 0xcc, 0x49, 0xd6, 0x89, 0x36, 0x8d, 0x39, 0xda, 0x7d, + 0x32, 0x3c, 0x23, 0xee, 0x75, 0xfc, 0xcb, 0xa6, 0xb5, 0xc7, 0xc9, 0x23, 0x92, 0x63, 0x7c, 0xc7, + 0xb3, 0xff, 0xbc, 0x0f, 0x1e, 0xae, 0xd4, 0xf2, 0xc3, 0x0f, 0xbd, 0x04, 0x23, 0x5c, 0x5c, 0xa4, + 0x53, 0xc3, 0x69, 0x8a, 0x7a, 0x95, 0x06, 0x74, 0x4d, 0xc3, 0x61, 0x83, 0x12, 0x9d, 0x86, 0xa2, + 0xfb, 0xb6, 0x97, 0x7c, 0xba, 0x57, 0x79, 0x63, 0x15, 0x53, 0x38, 0x45, 0x53, 0xc9, 0x93, 0x6f, + 0xe9, 0x0a, 0xad, 0xa4, 0xcf, 0xd7, 0x60, 0xcc, 0x0d, 0xeb, 0xa1, 0x5b, 0xf1, 0xe8, 0x3a, 0xd5, + 0x56, 0xba, 0xd2, 0x39, 0xd0, 0x46, 0x2b, 0x2c, 0x4e, 0x50, 0x6b, 0xe7, 0x4b, 0x7f, 0xcf, 0xd2, + 0x6b, 0xd7, 0xe0, 0x07, 0x74, 0xfb, 0x6f, 0xb1, 0xaf, 0x0b, 0x99, 0x0a, 0x5e, 0x6c, 0xff, 0xfc, + 0x83, 0x43, 0x2c, 0x71, 0xf4, 0x42, 0x57, 0xdf, 0x74, 0x5a, 0x73, 0xed, 0x68, 0x73, 0xd1, 0x0d, + 0xeb, 0xfe, 0x0e, 0x09, 0x76, 0xd9, 0x5d, 0x7c, 0x28, 0xbe, 0xd0, 0x29, 0xc4, 0xc2, 0xe5, 0xb9, + 0x2a, 0xa5, 0xc4, 0xe9, 0x32, 0x68, 0x0e, 0xc6, 0x25, 0xb0, 0x46, 0x42, 0x76, 0x04, 0x0c, 0x33, + 0x36, 0xea, 0x31, 0x9d, 0x00, 0x2b, 0x26, 0x49, 0x7a, 0x53, 0xc0, 0x85, 0xc3, 0x10, 0x70, 0x3f, + 0x08, 0xa3, 0xae, 0xe7, 0x46, 0xae, 0x13, 0xf9, 0xdc, 0x7e, 0xc4, 0xaf, 0xdd, 0x4c, 0xc1, 0x5c, + 0xd1, 0x11, 0xd8, 0xa4, 0xb3, 0xff, 0x6d, 0x1f, 0x4c, 0xb2, 0x61, 0x7b, 0x6f, 0x86, 0x7d, 0x27, + 0xcd, 0xb0, 0xeb, 0xe9, 0x19, 0x76, 0x18, 0x92, 0xfb, 0x7d, 0x4f, 0xb3, 0x4f, 0x43, 0x49, 0xbd, + 0x1f, 0x94, 0x0f, 0x88, 0xad, 0x9c, 0x07, 0xc4, 0xdd, 0x4f, 0x6f, 0xe9, 0x92, 0x56, 0xcc, 0x74, + 0x49, 0xfb, 0x8a, 0x05, 0xb1, 0x61, 0x01, 0xbd, 0x01, 0xa5, 0x96, 0xcf, 0x3c, 0x5c, 0x03, 0xe9, + 0x36, 0xfe, 0x58, 0x47, 0xcb, 0x04, 0x8f, 0xc0, 0x16, 0xf0, 0x5e, 0xa8, 0xca, 0xa2, 0x38, 0xe6, + 0x82, 0xae, 0xc0, 0x60, 0x2b, 0x20, 0xb5, 0x88, 0x85, 0x07, 0xea, 0x9d, 0x21, 0x9f, 0x35, 0xbc, + 0x20, 0x96, 0x1c, 0xec, 0x5f, 0x28, 0xc0, 0x44, 0x92, 0x14, 0xbd, 0x0a, 0x7d, 0xe4, 0x0e, 0xa9, + 0x8b, 0xf6, 0x66, 0x1e, 0xc5, 0xb1, 0x6a, 0x82, 0x77, 0x00, 0xfd, 0x8f, 0x59, 0x29, 0x74, 0x19, + 0x06, 0xe9, 0x39, 0x7c, 0x49, 0x85, 0xc2, 0x7b, 0x24, 0xef, 0x2c, 0x57, 0x02, 0x0d, 0x6f, 0x9c, + 0x00, 0x61, 0x59, 0x9c, 0xf9, 0x81, 0xd5, 0x5b, 0x35, 0x7a, 0xc5, 0x89, 0x3a, 0xdd, 0xc4, 0xd7, + 0x16, 0xaa, 0x9c, 0x48, 0x70, 0xe3, 0x7e, 0x60, 0x12, 0x88, 0x63, 0x26, 0xe8, 0x23, 0xd0, 0x1f, + 0x36, 0x09, 0x69, 0x09, 0x43, 0x7f, 0xa6, 0x72, 0xb1, 0x46, 0x09, 0x04, 0x27, 0xa6, 0x8c, 0x60, + 0x00, 0xcc, 0x0b, 0xda, 0xbf, 0x68, 0x01, 0x70, 0xc7, 0x39, 0xc7, 0xdb, 0x20, 0x47, 0xa0, 0x8f, + 0x5f, 0x84, 0xbe, 0xb0, 0x45, 0xea, 0x9d, 0xdc, 0xb7, 0xe3, 0xf6, 0xd4, 0x5a, 0xa4, 0x1e, 0xcf, + 0x59, 0xfa, 0x0f, 0xb3, 0xd2, 0xf6, 0xf7, 0x03, 0x8c, 0xc5, 0x64, 0x95, 0x88, 0x6c, 0xa3, 0x67, + 0x8d, 0xb0, 0x25, 0x27, 0x13, 0x61, 0x4b, 0x4a, 0x8c, 0x5a, 0x53, 0xfd, 0x7e, 0x1a, 0x8a, 0xdb, + 0xce, 0x1d, 0xa1, 0xdb, 0x7b, 0xba, 0x73, 0x33, 0x28, 0xff, 0xd9, 0x15, 0xe7, 0x0e, 0xbf, 0xfe, + 0x3e, 0x2d, 0xd7, 0xd8, 0x8a, 0x73, 0xa7, 0xab, 0x8b, 0x31, 0xad, 0x84, 0xd5, 0xe5, 0x7a, 0xc2, + 0x27, 0xac, 0xa7, 0xba, 0x5c, 0x2f, 0x59, 0x97, 0xeb, 0xf5, 0x50, 0x97, 0xeb, 0xa1, 0xbb, 0x30, + 0x28, 0x5c, 0x36, 0x45, 0x60, 0xb3, 0x0b, 0x3d, 0xd4, 0x27, 0x3c, 0x3e, 0x79, 0x9d, 0x17, 0xe4, + 0xf5, 0x5e, 0x40, 0xbb, 0xd6, 0x2b, 0x2b, 0x44, 0xff, 0xb7, 0x05, 0x63, 0xe2, 0x37, 0x26, 0x6f, + 0xb7, 0x49, 0x18, 0x09, 0xf1, 0xf7, 0x03, 0xbd, 0xb7, 0x41, 0x14, 0xe4, 0x4d, 0xf9, 0x80, 0x3c, + 0xa9, 0x4c, 0x64, 0xd7, 0x16, 0x25, 0x5a, 0x81, 0x7e, 0xc1, 0x82, 0x63, 0xdb, 0xce, 0x1d, 0x5e, + 0x23, 0x87, 0x61, 0x27, 0x72, 0x7d, 0xe1, 0xfa, 0xf0, 0x6a, 0x6f, 0xc3, 0x9f, 0x2a, 0xce, 0x1b, + 0x29, 0xed, 0x9c, 0xc7, 0xb2, 0x48, 0xba, 0x36, 0x35, 0xb3, 0x5d, 0x33, 0xeb, 0x30, 0x24, 0xe7, + 0xdb, 0x83, 0xf4, 0x0f, 0x67, 0xf5, 0x88, 0xb9, 0xf6, 0x40, 0xeb, 0xf9, 0x34, 0x8c, 0xe8, 0x73, + 0xec, 0x81, 0xd6, 0xf5, 0x36, 0x4c, 0x65, 0xcc, 0xa5, 0x07, 0x5a, 0xe5, 0x6d, 0x38, 0x99, 0x3b, + 0x3f, 0x1e, 0xa8, 0x7f, 0xff, 0xd7, 0x2c, 0x7d, 0x1f, 0x3c, 0x02, 0xa3, 0xc8, 0x82, 0x69, 0x14, + 0x39, 0xd3, 0x79, 0xe5, 0xe4, 0x58, 0x46, 0xde, 0xd2, 0x1b, 0x4d, 0x77, 0x75, 0xf4, 0x3a, 0x0c, + 0x34, 0x29, 0x44, 0x3a, 0xfe, 0xda, 0xdd, 0x57, 0x64, 0x2c, 0x8e, 0x32, 0x78, 0x88, 0x05, 0x07, + 0xfb, 0x57, 0x2c, 0xe8, 0x3b, 0x82, 0x9e, 0xc0, 0x66, 0x4f, 0x3c, 0x9b, 0xcb, 0x5a, 0xc4, 0x78, + 0x9f, 0xc5, 0xce, 0xed, 0xa5, 0x3b, 0x11, 0xf1, 0x42, 0x76, 0xa6, 0x67, 0x76, 0xcc, 0x9e, 0x05, + 0x53, 0x57, 0x7d, 0xa7, 0x31, 0xef, 0x34, 0x1d, 0xaf, 0x4e, 0x82, 0x8a, 0xb7, 0x71, 0x20, 0xaf, + 0xf5, 0x42, 0x57, 0xaf, 0xf5, 0x97, 0x60, 0xc0, 0x6d, 0x69, 0x31, 0xab, 0xcf, 0xd2, 0x0e, 0xac, + 0x54, 0x45, 0xb8, 0x6a, 0x64, 0x54, 0xce, 0xa0, 0x58, 0xd0, 0xd3, 0x91, 0xe7, 0xee, 0x62, 0x7d, + 0xf9, 0x23, 0x4f, 0xa5, 0xf8, 0x64, 0x08, 0x28, 0xc3, 0xb1, 0x79, 0x13, 0x8c, 0x2a, 0xc4, 0xab, + 0x2f, 0x0c, 0x83, 0x2e, 0xff, 0x52, 0x31, 0xfc, 0x4f, 0x64, 0x4b, 0xd7, 0xa9, 0x8e, 0xd1, 0xde, + 0x33, 0x71, 0x00, 0x96, 0x8c, 0xec, 0x97, 0x20, 0x33, 0x64, 0x47, 0x77, 0xcd, 0x89, 0xfd, 0x31, + 0x98, 0x64, 0x25, 0x0f, 0xa8, 0x95, 0xb0, 0x13, 0xfa, 0xde, 0x8c, 0xf0, 0xa3, 0xf6, 0x17, 0x2c, + 0x18, 0x5f, 0x4d, 0x44, 0x65, 0x3c, 0xc7, 0x2c, 0xc4, 0x19, 0x66, 0x86, 0x1a, 0x83, 0x62, 0x81, + 0x3d, 0x74, 0x35, 0xdc, 0xdf, 0x58, 0x10, 0x47, 0xd1, 0x39, 0x02, 0xc1, 0x6f, 0xc1, 0x10, 0xfc, + 0x32, 0x85, 0x68, 0xd5, 0x9c, 0x3c, 0xb9, 0x0f, 0x5d, 0x51, 0xf1, 0xe5, 0x3a, 0xc8, 0xcf, 0x31, + 0x1b, 0x3e, 0x15, 0xc7, 0xcc, 0x20, 0x74, 0x32, 0xe2, 0x9c, 0xfd, 0x07, 0x05, 0x40, 0x8a, 0xb6, + 0xe7, 0xf8, 0x77, 0xe9, 0x12, 0x87, 0x13, 0xff, 0x6e, 0x07, 0x10, 0xf3, 0x71, 0x08, 0x1c, 0x2f, + 0xe4, 0x6c, 0x5d, 0xa1, 0x78, 0x3c, 0x98, 0x03, 0xc5, 0x8c, 0x7c, 0x10, 0x77, 0x35, 0xc5, 0x0d, + 0x67, 0xd4, 0xa0, 0xf9, 0xae, 0xf4, 0xf7, 0xea, 0xbb, 0x32, 0xd0, 0xe5, 0x65, 0xe7, 0x57, 0x2d, + 0x18, 0x55, 0xdd, 0xf4, 0x2e, 0xf1, 0xff, 0x57, 0xed, 0xc9, 0xd9, 0x7a, 0xab, 0x5a, 0x93, 0xd9, + 0x91, 0xf4, 0x5d, 0xec, 0x85, 0xae, 0xd3, 0x74, 0xef, 0x12, 0x15, 0x2f, 0xb5, 0x2c, 0x5e, 0xdc, + 0x0a, 0xe8, 0xfe, 0x5e, 0x79, 0x54, 0xfd, 0xe3, 0xf1, 0xe0, 0xe3, 0x22, 0xf6, 0x4f, 0xd1, 0xc5, + 0x6e, 0x4e, 0x45, 0xf4, 0x22, 0xf4, 0xb7, 0x36, 0x9d, 0x90, 0x24, 0xde, 0x49, 0xf5, 0x57, 0x29, + 0x70, 0x7f, 0xaf, 0x3c, 0xa6, 0x0a, 0x30, 0x08, 0xe6, 0xd4, 0xbd, 0x47, 0x15, 0x4c, 0x4f, 0xce, + 0xae, 0x51, 0x05, 0xff, 0xca, 0x82, 0xbe, 0x55, 0xba, 0xc1, 0x3f, 0xf8, 0x2d, 0xe0, 0x35, 0x63, + 0x0b, 0x38, 0x95, 0x97, 0xaa, 0x23, 0x77, 0xf5, 0x2f, 0x27, 0x56, 0xff, 0x99, 0x5c, 0x0e, 0x9d, + 0x17, 0xfe, 0x36, 0x0c, 0xb3, 0x04, 0x20, 0xe2, 0x4d, 0xd8, 0xf3, 0xc6, 0x82, 0x2f, 0x27, 0x16, + 0xfc, 0xb8, 0x46, 0xaa, 0xad, 0xf4, 0x27, 0x61, 0x50, 0x3c, 0x32, 0x4a, 0x3e, 0x74, 0x16, 0xb4, + 0x58, 0xe2, 0xed, 0x1f, 0x2f, 0x82, 0x91, 0x70, 0x04, 0xfd, 0x9a, 0x05, 0xb3, 0x01, 0x77, 0x3e, + 0x6e, 0x2c, 0xb6, 0x03, 0xd7, 0xdb, 0xa8, 0xd5, 0x37, 0x49, 0xa3, 0xdd, 0x74, 0xbd, 0x8d, 0xca, + 0x86, 0xe7, 0x2b, 0xf0, 0xd2, 0x1d, 0x52, 0x6f, 0x33, 0xc3, 0x60, 0x97, 0xec, 0x26, 0xca, 0x89, + 0xff, 0xb9, 0x7b, 0x7b, 0xe5, 0x59, 0x7c, 0x20, 0xde, 0xf8, 0x80, 0x6d, 0x41, 0xbf, 0x6b, 0xc1, + 0x05, 0x9e, 0x87, 0xa3, 0xf7, 0xf6, 0x77, 0xb8, 0x67, 0x57, 0x25, 0xab, 0x98, 0xc9, 0x1a, 0x09, + 0xb6, 0xe7, 0x3f, 0x28, 0x3a, 0xf4, 0x42, 0xf5, 0x60, 0x75, 0xe1, 0x83, 0x36, 0xce, 0xfe, 0x87, + 0x45, 0x18, 0x15, 0xd1, 0xe7, 0xc4, 0x19, 0xf0, 0xa2, 0x31, 0x25, 0x1e, 0x49, 0x4c, 0x89, 0x49, + 0x83, 0xf8, 0x70, 0xb6, 0xff, 0x10, 0x26, 0xe9, 0xe6, 0x7c, 0x99, 0x38, 0x41, 0x74, 0x8b, 0x38, + 0xdc, 0x25, 0xad, 0x78, 0xe0, 0xdd, 0x5f, 0xe9, 0x46, 0xaf, 0x26, 0x99, 0xe1, 0x34, 0xff, 0xef, + 0xa4, 0x33, 0xc7, 0x83, 0x89, 0x54, 0x00, 0xc1, 0x37, 0xa1, 0xa4, 0x5e, 0xc8, 0x88, 0x4d, 0xa7, + 0x73, 0x1c, 0xce, 0x24, 0x07, 0xae, 0x7a, 0x8b, 0x5f, 0x67, 0xc5, 0xec, 0xec, 0xbf, 0x5b, 0x30, + 0x2a, 0xe4, 0x83, 0xb8, 0x0a, 0x43, 0x4e, 0x18, 0xba, 0x1b, 0x1e, 0x69, 0x74, 0xd2, 0x8e, 0xa6, + 0xaa, 0x61, 0xaf, 0x94, 0xe6, 0x44, 0x49, 0xac, 0x78, 0xa0, 0xcb, 0xdc, 0xf1, 0x6f, 0x87, 0x74, + 0x52, 0x8d, 0xa6, 0xb8, 0x81, 0x74, 0x0d, 0xdc, 0x21, 0x58, 0x94, 0x47, 0x9f, 0xe0, 0x9e, 0x99, + 0x57, 0x3c, 0xff, 0xb6, 0x77, 0xc9, 0xf7, 0x65, 0xa4, 0x91, 0xde, 0x18, 0x4e, 0x4a, 0x7f, 0x4c, + 0x55, 0x1c, 0x9b, 0xdc, 0x7a, 0x8b, 0xc8, 0xfb, 0x19, 0x60, 0x79, 0x07, 0xcc, 0x07, 0xe9, 0x21, + 0x22, 0x30, 0x2e, 0x42, 0x1b, 0x4a, 0x98, 0xe8, 0xbb, 0xcc, 0x4b, 0xa0, 0x59, 0x3a, 0x56, 0xe2, + 0x5f, 0x31, 0x59, 0xe0, 0x24, 0x4f, 0xfb, 0xa7, 0x2d, 0x60, 0x8f, 0x73, 0x8f, 0x40, 0x1e, 0xf9, + 0xb0, 0x29, 0x8f, 0x4c, 0xe7, 0x75, 0x72, 0x8e, 0x28, 0xf2, 0x02, 0x9f, 0x59, 0xd5, 0xc0, 0xbf, + 0xb3, 0x2b, 0xdc, 0x69, 0xba, 0xdf, 0x3f, 0xec, 0xff, 0x66, 0xf1, 0x4d, 0x2c, 0x0e, 0x65, 0xf0, + 0x59, 0x18, 0xaa, 0x3b, 0x2d, 0xa7, 0xce, 0xb3, 0x63, 0xe5, 0xea, 0x02, 0x8d, 0x42, 0xb3, 0x0b, + 0xa2, 0x04, 0xd7, 0x6d, 0xc9, 0x10, 0x99, 0x43, 0x12, 0xdc, 0x55, 0x9f, 0xa5, 0xaa, 0x9c, 0xd9, + 0x82, 0x51, 0x83, 0xd9, 0x03, 0x55, 0x84, 0x7c, 0x96, 0x1f, 0xb1, 0x2a, 0xa4, 0xeb, 0x36, 0x4c, + 0x7a, 0xda, 0x7f, 0x7a, 0xa0, 0xc8, 0xcb, 0xe5, 0x63, 0xdd, 0x0e, 0x51, 0x76, 0xfa, 0x68, 0xef, + 0x7e, 0x13, 0x6c, 0x70, 0x9a, 0xb3, 0xfd, 0x13, 0x16, 0x3c, 0xa4, 0x13, 0x6a, 0x4f, 0x8b, 0xba, + 0x19, 0x68, 0x16, 0x61, 0xc8, 0x6f, 0x91, 0xc0, 0x89, 0xfc, 0x40, 0x9c, 0x1a, 0xe7, 0x65, 0xa7, + 0x5f, 0x13, 0xf0, 0x7d, 0x91, 0xeb, 0x41, 0x72, 0x97, 0x70, 0xac, 0x4a, 0xd2, 0xdb, 0x27, 0xeb, 0x8c, 0x50, 0x3c, 0x22, 0x63, 0x7b, 0x00, 0xb3, 0xf5, 0x87, 0x58, 0x60, 0xec, 0x3f, 0xb7, 0xf8, - 0xc4, 0xd2, 0x9b, 0x8e, 0xde, 0x86, 0xb1, 0x1d, 0x27, 0xaa, 0x6d, 0x2d, 0xdc, 0x69, 0x06, 0xdc, - 0xdc, 0x25, 0xfb, 0xe9, 0xe9, 0x4e, 0xfd, 0xa4, 0x7d, 0x64, 0xec, 0x6c, 0xba, 0x92, 0x60, 0x86, - 0x53, 0xec, 0xd1, 0x3a, 0x0c, 0x32, 0x18, 0x7b, 0x1f, 0x19, 0xb6, 0x13, 0x0d, 0xf2, 0x6a, 0x53, - 0xee, 0x12, 0x2b, 0x31, 0x1f, 0xac, 0x33, 0xb5, 0xbf, 0x52, 0xe4, 0xab, 0x9d, 0x89, 0xf2, 0x4f, - 0x42, 0x7f, 0xd3, 0xaf, 0xcf, 0x2d, 0xcd, 0x63, 0x31, 0x0a, 0xea, 0x18, 0xa9, 0x70, 0x30, 0x96, - 0x78, 0x74, 0x11, 0x06, 0xc4, 0x4f, 0x69, 0x9e, 0x64, 0x7b, 0xb3, 0xa0, 0x0b, 0xb1, 0xc2, 0xa2, - 0xe7, 0x00, 0x9a, 0x81, 0xbf, 0xeb, 0xd6, 0x59, 0xbc, 0x94, 0xa2, 0xe9, 0xe9, 0x54, 0x51, 0x18, - 0xac, 0x51, 0xa1, 0x57, 0x60, 0xb8, 0xe5, 0x85, 0x5c, 0x1c, 0xd1, 0xa2, 0x52, 0x2b, 0x1f, 0x9c, - 0x1b, 0x3a, 0x12, 0x9b, 0xb4, 0x68, 0x06, 0xfa, 0x22, 0x87, 0x79, 0xee, 0xf4, 0xe6, 0x3b, 0x24, + 0xc4, 0xd2, 0x9b, 0x8e, 0xde, 0x86, 0x89, 0x6d, 0x27, 0xaa, 0x6f, 0x2e, 0xdd, 0x69, 0x05, 0xdc, + 0xdc, 0x25, 0xfb, 0xe9, 0xe9, 0x6e, 0xfd, 0xa4, 0x7d, 0x64, 0xec, 0x6c, 0xba, 0x92, 0x60, 0x86, + 0x53, 0xec, 0xd1, 0x2d, 0x18, 0x66, 0x30, 0xf6, 0x3e, 0x32, 0xec, 0x24, 0x1a, 0xe4, 0xd5, 0xa6, + 0xdc, 0x25, 0x56, 0x62, 0x3e, 0x58, 0x67, 0x6a, 0x7f, 0xa5, 0xc8, 0x57, 0x3b, 0x13, 0xe5, 0x9f, + 0x84, 0xc1, 0x96, 0xdf, 0x58, 0xa8, 0x2c, 0x62, 0x31, 0x0a, 0xea, 0x18, 0xa9, 0x72, 0x30, 0x96, + 0x78, 0x74, 0x1e, 0x86, 0xc4, 0x4f, 0x69, 0x9e, 0x64, 0x7b, 0xb3, 0xa0, 0x0b, 0xb1, 0xc2, 0xa2, + 0xe7, 0x00, 0x5a, 0x81, 0xbf, 0xe3, 0x36, 0x58, 0xbc, 0x94, 0xa2, 0xe9, 0xe9, 0x54, 0x55, 0x18, + 0xac, 0x51, 0xa1, 0x57, 0x60, 0xb4, 0xed, 0x85, 0x5c, 0x1c, 0xd1, 0xa2, 0x52, 0x2b, 0x1f, 0x9c, + 0xeb, 0x3a, 0x12, 0x9b, 0xb4, 0x68, 0x0e, 0x06, 0x22, 0x87, 0x79, 0xee, 0xf4, 0xe7, 0x3b, 0x24, 0xaf, 0x51, 0x0a, 0x3d, 0x11, 0x13, 0x2d, 0x80, 0x45, 0x41, 0xf4, 0xa6, 0x7c, 0xaa, 0xcc, 0x37, - 0x76, 0xf1, 0x12, 0xa0, 0xbb, 0x43, 0x40, 0x7b, 0xa8, 0x2c, 0x5e, 0x18, 0x18, 0xbc, 0xd0, 0xcb, - 0x00, 0xe4, 0x4e, 0x44, 0x02, 0xcf, 0x69, 0x28, 0x7f, 0x3b, 0x25, 0x17, 0xcc, 0xfb, 0xab, 0x7e, - 0x74, 0x23, 0x24, 0x0b, 0x8a, 0x02, 0x6b, 0xd4, 0xf6, 0xef, 0x96, 0x00, 0x62, 0xb9, 0x1d, 0xdd, - 0x4d, 0x6d, 0x5c, 0xcf, 0xb4, 0x97, 0xf4, 0x8f, 0x6e, 0xd7, 0x42, 0x9f, 0xb7, 0x60, 0x50, 0x84, - 0x85, 0x61, 0x23, 0x54, 0x68, 0xbf, 0x71, 0x9a, 0xd1, 0x69, 0x68, 0x09, 0xde, 0x84, 0xe7, 0xe5, - 0x0c, 0xd5, 0x30, 0x1d, 0x5b, 0xa1, 0x57, 0x8c, 0xde, 0x2f, 0xaf, 0x8a, 0x45, 0xa3, 0x2b, 0xd5, - 0x55, 0xb1, 0xc4, 0xce, 0x08, 0xfd, 0x96, 0x78, 0xc3, 0xb8, 0x25, 0xf6, 0xe4, 0xbf, 0xc5, 0x34, - 0xc4, 0xd7, 0x4e, 0x17, 0x44, 0x54, 0xd1, 0xe3, 0x32, 0xf4, 0xe6, 0x3f, 0x20, 0xd4, 0xee, 0x49, - 0x1d, 0x62, 0x32, 0x7c, 0x1a, 0x46, 0xeb, 0xa6, 0x10, 0x20, 0x66, 0xe2, 0x13, 0x79, 0x7c, 0x13, - 0x32, 0x43, 0x7c, 0xec, 0x27, 0x10, 0x38, 0xc9, 0x18, 0x55, 0x78, 0x98, 0x8e, 0x25, 0x6f, 0xc3, - 0x17, 0xaf, 0x51, 0xec, 0xdc, 0xb1, 0xdc, 0x0b, 0x23, 0xb2, 0x43, 0x29, 0xe3, 0xd3, 0x7d, 0x55, - 0x94, 0xc5, 0x8a, 0x0b, 0x7a, 0x1d, 0xfa, 0xd8, 0x0b, 0xb2, 0x70, 0x72, 0x20, 0x5f, 0x57, 0x6d, - 0xc6, 0x2b, 0x8c, 0x17, 0x24, 0xfb, 0x1b, 0x62, 0xc1, 0x01, 0x5d, 0x95, 0xef, 0x33, 0xc3, 0x25, - 0xef, 0x46, 0x48, 0xd8, 0xfb, 0xcc, 0xd2, 0xec, 0x63, 0xf1, 0xd3, 0x4b, 0x0e, 0xcf, 0x4c, 0xd7, - 0x68, 0x94, 0xa4, 0x52, 0x94, 0xf8, 0x2f, 0xb3, 0x40, 0x8a, 0xe8, 0x4a, 0x99, 0xcd, 0x33, 0x33, - 0x45, 0xc6, 0xdd, 0x79, 0xd3, 0x64, 0x81, 0x93, 0x3c, 0xa9, 0x44, 0xca, 0x57, 0xbd, 0x78, 0xcf, - 0xd2, 0x69, 0xef, 0xe0, 0x17, 0x71, 0x76, 0x1a, 0x71, 0x08, 0x16, 0xe5, 0x8f, 0x55, 0x3c, 0x98, - 0xf2, 0x60, 0x2c, 0xb9, 0x44, 0x1f, 0xa8, 0x38, 0xf2, 0xa7, 0x3d, 0x30, 0x62, 0x4e, 0x29, 0x74, - 0x09, 0x4a, 0x82, 0x89, 0xca, 0xa4, 0xa2, 0x56, 0xc9, 0x8a, 0x44, 0xe0, 0x98, 0x86, 0x25, 0xd0, - 0x61, 0xc5, 0x35, 0x07, 0xe6, 0x38, 0x81, 0x8e, 0xc2, 0x60, 0x8d, 0x8a, 0x5e, 0xac, 0xd6, 0x7d, - 0x3f, 0x52, 0x07, 0x92, 0x9a, 0x77, 0xb3, 0x0c, 0x8a, 0x05, 0x96, 0x1e, 0x44, 0xdb, 0x24, 0xf0, - 0x48, 0xc3, 0x8c, 0x60, 0xae, 0x0e, 0xa2, 0x6b, 0x3a, 0x12, 0x9b, 0xb4, 0xf4, 0x38, 0xf5, 0x43, - 0x36, 0x91, 0xc5, 0xf5, 0x2d, 0x76, 0x08, 0xaf, 0xf2, 0xa7, 0xed, 0x12, 0x8f, 0x3e, 0x06, 0x0f, - 0xa9, 0x68, 0x61, 0x98, 0xdb, 0x41, 0x64, 0x8d, 0x7d, 0x86, 0xb6, 0xe5, 0xa1, 0xb9, 0x6c, 0x32, - 0x9c, 0x57, 0x1e, 0xbd, 0x06, 0x23, 0x42, 0xc4, 0x97, 0x1c, 0xfb, 0x4d, 0xef, 0xa6, 0x6b, 0x06, - 0x16, 0x27, 0xa8, 0x65, 0x0c, 0x76, 0x26, 0x65, 0x4b, 0x0e, 0x03, 0xe9, 0x18, 0xec, 0x3a, 0x1e, - 0xa7, 0x4a, 0xa0, 0x19, 0x18, 0xe5, 0x32, 0x98, 0xeb, 0x6d, 0xf2, 0x31, 0x11, 0xcf, 0xcd, 0xd4, - 0x92, 0xba, 0x6e, 0xa2, 0x71, 0x92, 0x1e, 0xbd, 0x04, 0x43, 0x4e, 0x50, 0xdb, 0x72, 0x23, 0x52, - 0x8b, 0x5a, 0x01, 0x7f, 0x87, 0xa6, 0xb9, 0x87, 0xcd, 0x68, 0x38, 0x6c, 0x50, 0xda, 0x77, 0x61, - 0x22, 0x23, 0xe6, 0x05, 0x9d, 0x38, 0x4e, 0xd3, 0x95, 0xdf, 0x94, 0xf0, 0xc1, 0x9e, 0xa9, 0x2c, - 0xc9, 0xaf, 0xd1, 0xa8, 0xe8, 0xec, 0x64, 0xb1, 0x31, 0xb4, 0xa4, 0xaf, 0x6a, 0x76, 0x2e, 0x4a, - 0x04, 0x8e, 0x69, 0xec, 0xff, 0x58, 0x80, 0xd1, 0x0c, 0xdb, 0x0a, 0x4b, 0x3c, 0x9a, 0xb8, 0xa4, - 0xc4, 0x79, 0x46, 0xcd, 0x90, 0xfe, 0x85, 0x43, 0x84, 0xf4, 0x2f, 0x76, 0x0a, 0xe9, 0xdf, 0xf3, - 0x4e, 0x42, 0xfa, 0x9b, 0x3d, 0xd6, 0xdb, 0x55, 0x8f, 0x65, 0xa4, 0x01, 0xe8, 0x3b, 0x64, 0x1a, - 0x00, 0xa3, 0xd3, 0xfb, 0xbb, 0xe8, 0xf4, 0x1f, 0x29, 0xc0, 0x58, 0xd2, 0x8d, 0xf5, 0x18, 0xf4, - 0xb6, 0xaf, 0x1b, 0x7a, 0xdb, 0x8b, 0xdd, 0x3c, 0x0f, 0xce, 0xd5, 0xe1, 0xe2, 0x84, 0x0e, 0xf7, - 0xa9, 0xae, 0xb8, 0xb5, 0xd7, 0xe7, 0xfe, 0x64, 0x01, 0x4e, 0x66, 0xbe, 0x4f, 0x3e, 0x86, 0xbe, - 0xb9, 0x6e, 0xf4, 0xcd, 0xb3, 0x5d, 0x3f, 0x9d, 0xce, 0xed, 0xa0, 0x5b, 0x89, 0x0e, 0xba, 0xd4, - 0x3d, 0xcb, 0xf6, 0xbd, 0xf4, 0x8d, 0x22, 0x9c, 0xcb, 0x2c, 0x17, 0xab, 0x3d, 0x17, 0x0d, 0xb5, - 0xe7, 0x73, 0x09, 0xb5, 0xa7, 0xdd, 0xbe, 0xf4, 0xd1, 0xe8, 0x41, 0xc5, 0x13, 0x62, 0x16, 0x08, - 0xe1, 0x3e, 0x75, 0xa0, 0xc6, 0x13, 0x62, 0xc5, 0x08, 0x9b, 0x7c, 0xbf, 0x93, 0x74, 0x9f, 0xbf, - 0x63, 0xc1, 0xe9, 0xcc, 0xb1, 0x39, 0x06, 0x5d, 0xd7, 0xaa, 0xa9, 0xeb, 0x7a, 0xb2, 0xeb, 0xd9, - 0x9a, 0xa3, 0xfc, 0xfa, 0xb9, 0xde, 0x9c, 0x6f, 0x61, 0x37, 0xf9, 0xeb, 0x30, 0xe8, 0xd4, 0x6a, - 0x24, 0x0c, 0x57, 0xfc, 0xba, 0x8a, 0xfe, 0xfd, 0x2c, 0xbb, 0x67, 0xc5, 0xe0, 0x83, 0xfd, 0xf2, - 0x54, 0x92, 0x45, 0x8c, 0xc6, 0x3a, 0x07, 0xf4, 0x09, 0x18, 0x08, 0xc5, 0xb9, 0x29, 0xc6, 0xfe, - 0xf9, 0x2e, 0x3b, 0xc7, 0x59, 0x27, 0x0d, 0x33, 0xcc, 0x94, 0xd2, 0x54, 0x28, 0x96, 0xe8, 0x7f, - 0xd1, 0x43, 0xd2, 0xa4, 0xa5, 0xca, 0x44, 0x80, 0x94, 0xfb, 0x08, 0x4c, 0xf3, 0x1c, 0xc0, 0xae, - 0xba, 0x12, 0x24, 0xb5, 0x10, 0xda, 0x65, 0x41, 0xa3, 0x42, 0x1f, 0x81, 0xb1, 0x90, 0x47, 0x63, - 0x9c, 0x6b, 0x38, 0x21, 0x7b, 0xef, 0x23, 0xe6, 0x22, 0x0b, 0x68, 0x55, 0x4d, 0xe0, 0x70, 0x8a, - 0x1a, 0x2d, 0xca, 0x5a, 0x99, 0x27, 0x09, 0x9f, 0x9e, 0x17, 0xe2, 0x1a, 0x85, 0x37, 0xc9, 0x89, - 0xe4, 0x20, 0xb0, 0xee, 0xd7, 0x4a, 0xa2, 0x4f, 0x00, 0xd0, 0x49, 0x24, 0xb4, 0x11, 0xfd, 0xf9, - 0x5b, 0x28, 0xdd, 0x5b, 0xea, 0x99, 0xee, 0xd5, 0xec, 0xed, 0xef, 0xbc, 0x62, 0x82, 0x35, 0x86, - 0xc8, 0x81, 0xe1, 0xf8, 0x5f, 0x9c, 0x1b, 0xf8, 0x62, 0x6e, 0x0d, 0x49, 0xe6, 0x4c, 0xf1, 0x3d, - 0xaf, 0xb3, 0xc0, 0x26, 0x47, 0xfb, 0xdf, 0x0d, 0xc0, 0xc3, 0x6d, 0x36, 0x63, 0x34, 0x63, 0x1a, - 0x7c, 0x9f, 0x4e, 0xde, 0xe2, 0xa7, 0x32, 0x0b, 0x1b, 0xd7, 0xfa, 0xc4, 0x9c, 0x2f, 0xbc, 0xe3, - 0x39, 0xff, 0x43, 0x96, 0xa6, 0x5f, 0xe1, 0x4e, 0xa9, 0x1f, 0x3e, 0xe4, 0x21, 0x73, 0x84, 0x0a, - 0x97, 0x8d, 0x0c, 0xad, 0xc5, 0x73, 0x5d, 0x37, 0xa7, 0x7b, 0x35, 0xc6, 0xd7, 0xb2, 0x43, 0x10, - 0x73, 0x85, 0xc6, 0x95, 0xc3, 0x7e, 0xff, 0x71, 0x85, 0x23, 0xfe, 0x03, 0x0b, 0x4e, 0xa7, 0xc0, - 0xbc, 0x0d, 0x24, 0x14, 0x51, 0xb2, 0x56, 0xdf, 0x71, 0xe3, 0x25, 0x43, 0xfe, 0x0d, 0x57, 0xc5, - 0x37, 0x9c, 0xce, 0xa5, 0x4b, 0x36, 0xfd, 0x8b, 0x7f, 0x5c, 0x9e, 0x60, 0x15, 0x98, 0x84, 0x38, - 0xbf, 0xe9, 0xc7, 0x7b, 0xfd, 0xff, 0xd6, 0x44, 0x5f, 0x9e, 0x5a, 0x86, 0x73, 0xed, 0xbb, 0xfa, - 0x50, 0x0f, 0xa4, 0x7f, 0xdf, 0x82, 0xb3, 0x6d, 0xa3, 0xf0, 0x7c, 0x1b, 0x4a, 0xbb, 0xf6, 0xe7, - 0x2c, 0x78, 0x24, 0xb3, 0x84, 0xe1, 0x23, 0x77, 0x09, 0x4a, 0xb5, 0x44, 0x46, 0xd6, 0x38, 0x1e, - 0x85, 0xca, 0xc6, 0x1a, 0xd3, 0x18, 0xae, 0x70, 0x85, 0x8e, 0xae, 0x70, 0xbf, 0x69, 0x41, 0xea, - 0xac, 0x3a, 0x06, 0xd1, 0x69, 0xc9, 0x14, 0x9d, 0x1e, 0xeb, 0xa6, 0x37, 0x73, 0xa4, 0xa6, 0xbf, - 0x1c, 0x85, 0x53, 0x39, 0xef, 0x1b, 0x77, 0x61, 0x7c, 0xb3, 0x46, 0xcc, 0x07, 0xed, 0xed, 0x02, - 0x3d, 0xb5, 0x7d, 0xfd, 0xce, 0x13, 0xe1, 0xa6, 0x48, 0x70, 0xba, 0x0a, 0xf4, 0x39, 0x0b, 0x4e, - 0x38, 0xb7, 0xc3, 0x05, 0x2a, 0x02, 0xbb, 0xb5, 0xd9, 0x86, 0x5f, 0xdb, 0xa6, 0x92, 0x85, 0x5c, - 0x56, 0x2f, 0x64, 0xaa, 0x25, 0x6f, 0x55, 0x53, 0xf4, 0x46, 0xf5, 0x2c, 0xed, 0x79, 0x16, 0x15, - 0xce, 0xac, 0x0b, 0x61, 0x91, 0xa1, 0x85, 0x5e, 0xb0, 0xdb, 0x84, 0x5c, 0xc8, 0x7a, 0x88, 0xca, - 0x65, 0x3a, 0x89, 0xc1, 0x8a, 0x0f, 0xfa, 0x14, 0x94, 0x36, 0xe5, 0xeb, 0xea, 0x0c, 0x99, 0x31, - 0xee, 0xc8, 0xf6, 0x6f, 0xce, 0xb9, 0x6f, 0x81, 0x22, 0xc2, 0x31, 0x53, 0xf4, 0x1a, 0x14, 0xbd, - 0x8d, 0xb0, 0x5d, 0xe6, 0xf0, 0x84, 0x13, 0x29, 0x0f, 0x6c, 0xb2, 0xba, 0x58, 0xc5, 0xb4, 0x20, - 0xba, 0x0a, 0xc5, 0x60, 0xbd, 0x2e, 0x74, 0xea, 0x99, 0x8b, 0x14, 0xcf, 0xce, 0xe7, 0xb4, 0x8a, - 0x71, 0xc2, 0xb3, 0xf3, 0x98, 0xb2, 0x40, 0x15, 0xe8, 0x65, 0x8f, 0x02, 0x85, 0x6c, 0x96, 0x79, - 0x17, 0x6d, 0xf3, 0xb8, 0x96, 0x3f, 0x38, 0x62, 0x04, 0x98, 0x33, 0x42, 0x6b, 0xd0, 0x57, 0x63, - 0x59, 0xa6, 0x85, 0x30, 0xf6, 0xfe, 0x4c, 0xed, 0x79, 0x9b, 0xf4, 0xdb, 0x42, 0x99, 0xcc, 0x28, - 0xb0, 0xe0, 0xc5, 0xb8, 0x92, 0xe6, 0xd6, 0x46, 0xc8, 0xb4, 0x6f, 0x79, 0x5c, 0xdb, 0x64, 0x95, - 0x17, 0x5c, 0x19, 0x05, 0x16, 0xbc, 0xd0, 0xcb, 0x50, 0xd8, 0xa8, 0x89, 0x07, 0x7f, 0x99, 0x6a, - 0x74, 0x33, 0x36, 0xcd, 0x6c, 0xdf, 0xbd, 0xfd, 0x72, 0x61, 0x71, 0x0e, 0x17, 0x36, 0x6a, 0x68, - 0x15, 0xfa, 0x37, 0x78, 0x34, 0x0b, 0xa1, 0x29, 0x7f, 0x22, 0x3b, 0xd0, 0x46, 0x2a, 0xe0, 0x05, - 0x7f, 0x3c, 0x26, 0x10, 0x58, 0x32, 0x61, 0x09, 0x43, 0x54, 0x54, 0x0e, 0x11, 0x14, 0x70, 0xfa, - 0x70, 0x91, 0x54, 0xb8, 0xac, 0x1c, 0xc7, 0xf6, 0xc0, 0x1a, 0x47, 0x3a, 0xab, 0x9d, 0xbb, 0xad, - 0x80, 0x45, 0x8c, 0x17, 0xd1, 0xa3, 0x32, 0x67, 0xf5, 0x8c, 0x24, 0x6a, 0x37, 0xab, 0x15, 0x11, - 0x8e, 0x99, 0xa2, 0x6d, 0x18, 0xde, 0x0d, 0x9b, 0x5b, 0x44, 0x2e, 0x69, 0x16, 0x4c, 0x2a, 0x47, - 0xd6, 0xbb, 0x29, 0x08, 0xdd, 0x20, 0x6a, 0x39, 0x8d, 0xd4, 0x2e, 0xc4, 0xe4, 0xf2, 0x9b, 0x3a, - 0x33, 0x6c, 0xf2, 0xa6, 0xdd, 0xff, 0x76, 0xcb, 0x5f, 0xdf, 0x8b, 0x88, 0x88, 0xe5, 0x97, 0xd9, - 0xfd, 0x6f, 0x70, 0x92, 0x74, 0xf7, 0x0b, 0x04, 0x96, 0x4c, 0xd0, 0x4d, 0xd1, 0x3d, 0x6c, 0xf7, - 0x1c, 0xcb, 0x0f, 0x14, 0x3c, 0x23, 0x89, 0x72, 0x3a, 0x85, 0xed, 0x96, 0x31, 0x2b, 0xb6, 0x4b, - 0x36, 0xb7, 0xfc, 0xc8, 0xf7, 0x12, 0x3b, 0xf4, 0x78, 0xfe, 0x2e, 0x59, 0xc9, 0xa0, 0x4f, 0xef, - 0x92, 0x59, 0x54, 0x38, 0xb3, 0x2e, 0x54, 0x87, 0x91, 0xa6, 0x1f, 0x44, 0xb7, 0xfd, 0x40, 0xce, - 0x2f, 0xd4, 0x46, 0xd3, 0x67, 0x50, 0x8a, 0x1a, 0x59, 0x98, 0x4c, 0x13, 0x83, 0x13, 0x3c, 0xd1, - 0x47, 0xa1, 0x3f, 0xac, 0x39, 0x0d, 0xb2, 0x74, 0x7d, 0x72, 0x22, 0xff, 0xf8, 0xa9, 0x72, 0x92, - 0x9c, 0xd9, 0xc5, 0x83, 0x91, 0x70, 0x12, 0x2c, 0xd9, 0xa1, 0x45, 0xe8, 0x65, 0x89, 0x38, 0x59, + 0x76, 0xf1, 0x12, 0xa0, 0xb7, 0x43, 0x40, 0x7b, 0xa8, 0x2c, 0x5e, 0x18, 0x18, 0xbc, 0xd0, 0xcb, + 0x00, 0xe4, 0x4e, 0x44, 0x02, 0xcf, 0x69, 0x2a, 0x7f, 0x3b, 0x25, 0x17, 0x2c, 0xfa, 0xab, 0x7e, + 0x74, 0x3d, 0x24, 0x4b, 0x8a, 0x02, 0x6b, 0xd4, 0xf6, 0xef, 0x96, 0x00, 0x62, 0xb9, 0x1d, 0xdd, + 0x4d, 0x6d, 0x5c, 0xcf, 0x74, 0x96, 0xf4, 0x0f, 0x6f, 0xd7, 0x42, 0x9f, 0xb7, 0x60, 0x58, 0x84, + 0x85, 0x61, 0x23, 0x54, 0xe8, 0xbc, 0x71, 0x9a, 0xd1, 0x69, 0x68, 0x09, 0xde, 0x84, 0xe7, 0xe5, + 0x0c, 0xd5, 0x30, 0x5d, 0x5b, 0xa1, 0x57, 0x8c, 0xde, 0x2f, 0xaf, 0x8a, 0x45, 0xa3, 0x2b, 0xd5, + 0x55, 0xb1, 0xc4, 0xce, 0x08, 0xfd, 0x96, 0x78, 0xdd, 0xb8, 0x25, 0xf6, 0xe5, 0xbf, 0xc5, 0x34, + 0xc4, 0xd7, 0x6e, 0x17, 0x44, 0x54, 0xd5, 0xe3, 0x32, 0xf4, 0xe7, 0x3f, 0x20, 0xd4, 0xee, 0x49, + 0x5d, 0x62, 0x32, 0x7c, 0x1a, 0xc6, 0x1b, 0xa6, 0x10, 0x20, 0x66, 0xe2, 0x13, 0x79, 0x7c, 0x13, + 0x32, 0x43, 0x7c, 0xec, 0x27, 0x10, 0x38, 0xc9, 0x18, 0x55, 0x79, 0x98, 0x8e, 0x8a, 0xb7, 0xee, + 0x8b, 0xd7, 0x28, 0x76, 0xee, 0x58, 0xee, 0x86, 0x11, 0xd9, 0xa6, 0x94, 0xf1, 0xe9, 0xbe, 0x2a, + 0xca, 0x62, 0xc5, 0x05, 0xbd, 0x0e, 0x03, 0xec, 0x05, 0x59, 0x38, 0x3d, 0x94, 0xaf, 0xab, 0x36, + 0xe3, 0x15, 0xc6, 0x0b, 0x92, 0xfd, 0x0d, 0xb1, 0xe0, 0x80, 0x2e, 0xcb, 0xf7, 0x99, 0x61, 0xc5, + 0xbb, 0x1e, 0x12, 0xf6, 0x3e, 0xb3, 0x34, 0xff, 0x58, 0xfc, 0xf4, 0x92, 0xc3, 0x33, 0xd3, 0x35, + 0x1a, 0x25, 0xa9, 0x14, 0x25, 0xfe, 0xcb, 0x2c, 0x90, 0x22, 0xba, 0x52, 0x66, 0xf3, 0xcc, 0x4c, + 0x91, 0x71, 0x77, 0xde, 0x30, 0x59, 0xe0, 0x24, 0x4f, 0x2a, 0x91, 0xf2, 0x55, 0x2f, 0xde, 0xb3, + 0x74, 0xdb, 0x3b, 0xf8, 0x45, 0x9c, 0x9d, 0x46, 0x1c, 0x82, 0x45, 0xf9, 0x23, 0x15, 0x0f, 0x66, + 0x3c, 0x98, 0x48, 0x2e, 0xd1, 0x07, 0x2a, 0x8e, 0xfc, 0x69, 0x1f, 0x8c, 0x99, 0x53, 0x0a, 0x5d, + 0x80, 0x92, 0x60, 0xa2, 0x32, 0xa9, 0xa8, 0x55, 0xb2, 0x22, 0x11, 0x38, 0xa6, 0x61, 0x09, 0x74, + 0x58, 0x71, 0xcd, 0x81, 0x39, 0x4e, 0xa0, 0xa3, 0x30, 0x58, 0xa3, 0xa2, 0x17, 0xab, 0x5b, 0xbe, + 0x1f, 0xa9, 0x03, 0x49, 0xcd, 0xbb, 0x79, 0x06, 0xc5, 0x02, 0x4b, 0x0f, 0xa2, 0x2d, 0x12, 0x78, + 0xa4, 0x69, 0x46, 0x30, 0x57, 0x07, 0xd1, 0x15, 0x1d, 0x89, 0x4d, 0x5a, 0x7a, 0x9c, 0xfa, 0x21, + 0x9b, 0xc8, 0xe2, 0xfa, 0x16, 0x3b, 0x84, 0xd7, 0xf8, 0xd3, 0x76, 0x89, 0x47, 0x1f, 0x83, 0x87, + 0x54, 0xb4, 0x30, 0xcc, 0xed, 0x20, 0xb2, 0xc6, 0x01, 0x43, 0xdb, 0xf2, 0xd0, 0x42, 0x36, 0x19, + 0xce, 0x2b, 0x8f, 0x5e, 0x83, 0x31, 0x21, 0xe2, 0x4b, 0x8e, 0x83, 0xa6, 0x77, 0xd3, 0x15, 0x03, + 0x8b, 0x13, 0xd4, 0x32, 0x06, 0x3b, 0x93, 0xb2, 0x25, 0x87, 0xa1, 0x74, 0x0c, 0x76, 0x1d, 0x8f, + 0x53, 0x25, 0xd0, 0x1c, 0x8c, 0x73, 0x19, 0xcc, 0xf5, 0x36, 0xf8, 0x98, 0x88, 0xe7, 0x66, 0x6a, + 0x49, 0x5d, 0x33, 0xd1, 0x38, 0x49, 0x8f, 0x5e, 0x82, 0x11, 0x27, 0xa8, 0x6f, 0xba, 0x11, 0xa9, + 0x47, 0xed, 0x80, 0xbf, 0x43, 0xd3, 0xdc, 0xc3, 0xe6, 0x34, 0x1c, 0x36, 0x28, 0xed, 0xbb, 0x30, + 0x95, 0x11, 0xf3, 0x82, 0x4e, 0x1c, 0xa7, 0xe5, 0xca, 0x6f, 0x4a, 0xf8, 0x60, 0xcf, 0x55, 0x2b, + 0xf2, 0x6b, 0x34, 0x2a, 0x3a, 0x3b, 0x59, 0x6c, 0x0c, 0x2d, 0xe9, 0xab, 0x9a, 0x9d, 0xcb, 0x12, + 0x81, 0x63, 0x1a, 0xfb, 0x3f, 0x16, 0x60, 0x3c, 0xc3, 0xb6, 0xc2, 0x12, 0x8f, 0x26, 0x2e, 0x29, + 0x71, 0x9e, 0x51, 0x33, 0xa4, 0x7f, 0xe1, 0x00, 0x21, 0xfd, 0x8b, 0xdd, 0x42, 0xfa, 0xf7, 0xbd, + 0x93, 0x90, 0xfe, 0x66, 0x8f, 0xf5, 0xf7, 0xd4, 0x63, 0x19, 0x69, 0x00, 0x06, 0x0e, 0x98, 0x06, + 0xc0, 0xe8, 0xf4, 0xc1, 0x1e, 0x3a, 0xfd, 0x47, 0x0a, 0x30, 0x91, 0x74, 0x63, 0x3d, 0x02, 0xbd, + 0xed, 0xeb, 0x86, 0xde, 0xf6, 0x7c, 0x2f, 0xcf, 0x83, 0x73, 0x75, 0xb8, 0x38, 0xa1, 0xc3, 0x7d, + 0xaa, 0x27, 0x6e, 0x9d, 0xf5, 0xb9, 0x3f, 0x59, 0x80, 0xe3, 0x99, 0xef, 0x93, 0x8f, 0xa0, 0x6f, + 0xae, 0x19, 0x7d, 0xf3, 0x6c, 0xcf, 0x4f, 0xa7, 0x73, 0x3b, 0xe8, 0x66, 0xa2, 0x83, 0x2e, 0xf4, + 0xce, 0xb2, 0x73, 0x2f, 0x7d, 0xa3, 0x08, 0x67, 0x32, 0xcb, 0xc5, 0x6a, 0xcf, 0x65, 0x43, 0xed, + 0xf9, 0x5c, 0x42, 0xed, 0x69, 0x77, 0x2e, 0x7d, 0x38, 0x7a, 0x50, 0xf1, 0x84, 0x98, 0x05, 0x42, + 0xb8, 0x4f, 0x1d, 0xa8, 0xf1, 0x84, 0x58, 0x31, 0xc2, 0x26, 0xdf, 0xef, 0x24, 0xdd, 0xe7, 0xef, + 0x58, 0x70, 0x32, 0x73, 0x6c, 0x8e, 0x40, 0xd7, 0xb5, 0x6a, 0xea, 0xba, 0x9e, 0xec, 0x79, 0xb6, + 0xe6, 0x28, 0xbf, 0x7e, 0xae, 0x3f, 0xe7, 0x5b, 0xd8, 0x4d, 0xfe, 0x1a, 0x0c, 0x3b, 0xf5, 0x3a, + 0x09, 0xc3, 0x15, 0xbf, 0xa1, 0xa2, 0x7f, 0x3f, 0xcb, 0xee, 0x59, 0x31, 0x78, 0x7f, 0xaf, 0x3c, + 0x93, 0x64, 0x11, 0xa3, 0xb1, 0xce, 0x01, 0x7d, 0x02, 0x86, 0x42, 0x71, 0x6e, 0x8a, 0xb1, 0x7f, + 0xbe, 0xc7, 0xce, 0x71, 0x6e, 0x91, 0xa6, 0x19, 0x66, 0x4a, 0x69, 0x2a, 0x14, 0x4b, 0xf4, 0xbf, + 0xe8, 0x21, 0x69, 0xd2, 0x52, 0x65, 0x22, 0x40, 0xca, 0x7d, 0x04, 0xa6, 0x79, 0x0e, 0x60, 0x47, + 0x5d, 0x09, 0x92, 0x5a, 0x08, 0xed, 0xb2, 0xa0, 0x51, 0xa1, 0x8f, 0xc0, 0x44, 0xc8, 0xa3, 0x31, + 0x2e, 0x34, 0x9d, 0x90, 0xbd, 0xf7, 0x11, 0x73, 0x91, 0x05, 0xb4, 0xaa, 0x25, 0x70, 0x38, 0x45, + 0x8d, 0x96, 0x65, 0xad, 0xcc, 0x93, 0x84, 0x4f, 0xcf, 0x73, 0x71, 0x8d, 0xc2, 0x9b, 0xe4, 0x58, + 0x72, 0x10, 0x58, 0xf7, 0x6b, 0x25, 0xd1, 0x27, 0x00, 0xe8, 0x24, 0x12, 0xda, 0x88, 0xc1, 0xfc, + 0x2d, 0x94, 0xee, 0x2d, 0x8d, 0x4c, 0xf7, 0x6a, 0xf6, 0xf6, 0x77, 0x51, 0x31, 0xc1, 0x1a, 0x43, + 0xe4, 0xc0, 0x68, 0xfc, 0x2f, 0xce, 0x0d, 0x7c, 0x3e, 0xb7, 0x86, 0x24, 0x73, 0xa6, 0xf8, 0x5e, + 0xd4, 0x59, 0x60, 0x93, 0xa3, 0xfd, 0xef, 0x86, 0xe0, 0xe1, 0x0e, 0x9b, 0x31, 0x9a, 0x33, 0x0d, + 0xbe, 0x4f, 0x27, 0x6f, 0xf1, 0x33, 0x99, 0x85, 0x8d, 0x6b, 0x7d, 0x62, 0xce, 0x17, 0xde, 0xf1, + 0x9c, 0xff, 0x21, 0x4b, 0xd3, 0xaf, 0x70, 0xa7, 0xd4, 0x0f, 0x1f, 0xf0, 0x90, 0x39, 0x44, 0x85, + 0xcb, 0x7a, 0x86, 0xd6, 0xe2, 0xb9, 0x9e, 0x9b, 0xd3, 0xbb, 0x1a, 0xe3, 0x6b, 0xd9, 0x21, 0x88, + 0xb9, 0x42, 0xe3, 0xd2, 0x41, 0xbf, 0xff, 0xa8, 0xc2, 0x11, 0xff, 0x81, 0x05, 0x27, 0x53, 0x60, + 0xde, 0x06, 0x12, 0x8a, 0x28, 0x59, 0xab, 0xef, 0xb8, 0xf1, 0x92, 0x21, 0xff, 0x86, 0xcb, 0xe2, + 0x1b, 0x4e, 0xe6, 0xd2, 0x25, 0x9b, 0xfe, 0xc5, 0x3f, 0x2e, 0x4f, 0xb1, 0x0a, 0x4c, 0x42, 0x9c, + 0xdf, 0xf4, 0xa3, 0xbd, 0xfe, 0x7f, 0x6b, 0xa2, 0x2f, 0xcf, 0x5c, 0x85, 0x33, 0x9d, 0xbb, 0xfa, + 0x40, 0x0f, 0xa4, 0x7f, 0xdf, 0x82, 0xd3, 0x1d, 0xa3, 0xf0, 0x7c, 0x1b, 0x4a, 0xbb, 0xf6, 0xe7, + 0x2c, 0x78, 0x24, 0xb3, 0x84, 0xe1, 0x23, 0x77, 0x01, 0x4a, 0xf5, 0x44, 0x46, 0xd6, 0x38, 0x1e, + 0x85, 0xca, 0xc6, 0x1a, 0xd3, 0x18, 0xae, 0x70, 0x85, 0xae, 0xae, 0x70, 0xbf, 0x69, 0x41, 0xea, + 0xac, 0x3a, 0x02, 0xd1, 0xa9, 0x62, 0x8a, 0x4e, 0x8f, 0xf5, 0xd2, 0x9b, 0x39, 0x52, 0xd3, 0x5f, + 0x8e, 0xc3, 0x89, 0x9c, 0xf7, 0x8d, 0x3b, 0x30, 0xb9, 0x51, 0x27, 0xe6, 0x83, 0xf6, 0x4e, 0x81, + 0x9e, 0x3a, 0xbe, 0x7e, 0xe7, 0x89, 0x70, 0x53, 0x24, 0x38, 0x5d, 0x05, 0xfa, 0x9c, 0x05, 0xc7, + 0x9c, 0xdb, 0xe1, 0x12, 0x15, 0x81, 0xdd, 0xfa, 0x7c, 0xd3, 0xaf, 0x6f, 0x51, 0xc9, 0x42, 0x2e, + 0xab, 0x17, 0x32, 0xd5, 0x92, 0x37, 0x6b, 0x29, 0x7a, 0xa3, 0x7a, 0x96, 0xf6, 0x3c, 0x8b, 0x0a, + 0x67, 0xd6, 0x85, 0xb0, 0xc8, 0xd0, 0x42, 0x2f, 0xd8, 0x1d, 0x42, 0x2e, 0x64, 0x3d, 0x44, 0xe5, + 0x32, 0x9d, 0xc4, 0x60, 0xc5, 0x07, 0x7d, 0x0a, 0x4a, 0x1b, 0xf2, 0x75, 0x75, 0x86, 0xcc, 0x18, + 0x77, 0x64, 0xe7, 0x37, 0xe7, 0xdc, 0xb7, 0x40, 0x11, 0xe1, 0x98, 0x29, 0x7a, 0x0d, 0x8a, 0xde, + 0x7a, 0xd8, 0x29, 0x73, 0x78, 0xc2, 0x89, 0x94, 0x07, 0x36, 0x59, 0x5d, 0xae, 0x61, 0x5a, 0x10, + 0x5d, 0x86, 0x62, 0x70, 0xab, 0x21, 0x74, 0xea, 0x99, 0x8b, 0x14, 0xcf, 0x2f, 0xe6, 0xb4, 0x8a, + 0x71, 0xc2, 0xf3, 0x8b, 0x98, 0xb2, 0x40, 0x55, 0xe8, 0x67, 0x8f, 0x02, 0x85, 0x6c, 0x96, 0x79, + 0x17, 0xed, 0xf0, 0xb8, 0x96, 0x3f, 0x38, 0x62, 0x04, 0x98, 0x33, 0x42, 0x6b, 0x30, 0x50, 0x67, + 0x59, 0xa6, 0x85, 0x30, 0xf6, 0xfe, 0x4c, 0xed, 0x79, 0x87, 0xf4, 0xdb, 0x42, 0x99, 0xcc, 0x28, + 0xb0, 0xe0, 0xc5, 0xb8, 0x92, 0xd6, 0xe6, 0x7a, 0xc8, 0xb4, 0x6f, 0x79, 0x5c, 0x3b, 0x64, 0x95, + 0x17, 0x5c, 0x19, 0x05, 0x16, 0xbc, 0xd0, 0xcb, 0x50, 0x58, 0xaf, 0x8b, 0x07, 0x7f, 0x99, 0x6a, + 0x74, 0x33, 0x36, 0xcd, 0xfc, 0xc0, 0xbd, 0xbd, 0x72, 0x61, 0x79, 0x01, 0x17, 0xd6, 0xeb, 0x68, + 0x15, 0x06, 0xd7, 0x79, 0x34, 0x0b, 0xa1, 0x29, 0x7f, 0x22, 0x3b, 0xd0, 0x46, 0x2a, 0xe0, 0x05, + 0x7f, 0x3c, 0x26, 0x10, 0x58, 0x32, 0x61, 0x09, 0x43, 0x54, 0x54, 0x0e, 0x11, 0x14, 0x70, 0xf6, + 0x60, 0x91, 0x54, 0xb8, 0xac, 0x1c, 0xc7, 0xf6, 0xc0, 0x1a, 0x47, 0x3a, 0xab, 0x9d, 0xbb, 0xed, + 0x80, 0x45, 0x8c, 0x17, 0xd1, 0xa3, 0x32, 0x67, 0xf5, 0x9c, 0x24, 0xea, 0x34, 0xab, 0x15, 0x11, + 0x8e, 0x99, 0xa2, 0x2d, 0x18, 0xdd, 0x09, 0x5b, 0x9b, 0x44, 0x2e, 0x69, 0x16, 0x4c, 0x2a, 0x47, + 0xd6, 0xbb, 0x21, 0x08, 0xdd, 0x20, 0x6a, 0x3b, 0xcd, 0xd4, 0x2e, 0xc4, 0xe4, 0xf2, 0x1b, 0x3a, + 0x33, 0x6c, 0xf2, 0xa6, 0xdd, 0xff, 0x76, 0xdb, 0xbf, 0xb5, 0x1b, 0x11, 0x11, 0xcb, 0x2f, 0xb3, + 0xfb, 0xdf, 0xe0, 0x24, 0xe9, 0xee, 0x17, 0x08, 0x2c, 0x99, 0xa0, 0x1b, 0xa2, 0x7b, 0xd8, 0xee, + 0x39, 0x91, 0x1f, 0x28, 0x78, 0x4e, 0x12, 0xe5, 0x74, 0x0a, 0xdb, 0x2d, 0x63, 0x56, 0x6c, 0x97, + 0x6c, 0x6d, 0xfa, 0x91, 0xef, 0x25, 0x76, 0xe8, 0xc9, 0xfc, 0x5d, 0xb2, 0x9a, 0x41, 0x9f, 0xde, + 0x25, 0xb3, 0xa8, 0x70, 0x66, 0x5d, 0xa8, 0x01, 0x63, 0x2d, 0x3f, 0x88, 0x6e, 0xfb, 0x81, 0x9c, + 0x5f, 0xa8, 0x83, 0xa6, 0xcf, 0xa0, 0x14, 0x35, 0xb2, 0x30, 0x99, 0x26, 0x06, 0x27, 0x78, 0xa2, + 0x8f, 0xc2, 0x60, 0x58, 0x77, 0x9a, 0xa4, 0x72, 0x6d, 0x7a, 0x2a, 0xff, 0xf8, 0xa9, 0x71, 0x92, + 0x9c, 0xd9, 0xc5, 0x83, 0x91, 0x70, 0x12, 0x2c, 0xd9, 0xa1, 0x65, 0xe8, 0x67, 0x89, 0x38, 0x59, 0xe0, 0xc9, 0x9c, 0x78, 0xc7, 0x29, 0x97, 0x7e, 0xbe, 0x37, 0x31, 0x30, 0xe6, 0xc5, 0xe9, 0x1a, - 0x10, 0x57, 0x5d, 0x3f, 0x9c, 0x3c, 0x99, 0xbf, 0x06, 0xc4, 0x0d, 0xf9, 0x7a, 0xb5, 0xdd, 0x1a, - 0x50, 0x44, 0x38, 0x66, 0x4a, 0x77, 0x66, 0xba, 0x9b, 0x9e, 0x6a, 0xe3, 0x8b, 0x96, 0xbb, 0x97, - 0xb2, 0x9d, 0x99, 0xee, 0xa4, 0x94, 0x85, 0xfd, 0x27, 0xfd, 0x69, 0x99, 0x85, 0xa9, 0x48, 0xfe, - 0x37, 0x2b, 0x65, 0x3d, 0xff, 0x40, 0xb7, 0x1a, 0xdb, 0x23, 0xbc, 0xd6, 0x7d, 0xce, 0x82, 0x53, - 0xcd, 0xcc, 0x0f, 0x11, 0x02, 0x40, 0x77, 0x8a, 0x5f, 0xfe, 0xe9, 0x2a, 0x48, 0x69, 0x36, 0x1e, - 0xe7, 0xd4, 0x94, 0xbc, 0x3a, 0x17, 0xdf, 0xf1, 0xd5, 0x79, 0x05, 0x06, 0x6a, 0xfc, 0x9e, 0x23, - 0x83, 0x6b, 0x77, 0x15, 0x62, 0x8f, 0x89, 0x12, 0xe2, 0x82, 0xb4, 0x81, 0x15, 0x0b, 0xf4, 0xc3, - 0x16, 0x9c, 0x4d, 0x36, 0x1d, 0x13, 0x86, 0x16, 0x91, 0x4d, 0xb9, 0x5e, 0x66, 0x51, 0x7c, 0x7f, - 0x4a, 0xfe, 0x37, 0x88, 0x0f, 0x3a, 0x11, 0xe0, 0xf6, 0x95, 0xa1, 0xf9, 0x0c, 0xc5, 0x50, 0x9f, - 0x69, 0x12, 0xeb, 0x42, 0x39, 0xf4, 0x02, 0x0c, 0xed, 0xf8, 0x2d, 0x2f, 0x12, 0xae, 0x6b, 0xc2, - 0x8d, 0x86, 0xb9, 0x8f, 0xac, 0x68, 0x70, 0x6c, 0x50, 0x25, 0x54, 0x4a, 0x03, 0xf7, 0xad, 0x52, - 0x7a, 0x0b, 0x86, 0x3c, 0xcd, 0xd7, 0x5a, 0xc8, 0x03, 0x17, 0xf2, 0x95, 0x6e, 0xba, 0x67, 0x36, - 0x6f, 0xa5, 0x0e, 0xc1, 0x06, 0xb7, 0xe3, 0xf5, 0x69, 0xfb, 0xf9, 0x42, 0x86, 0x50, 0xcf, 0xd5, - 0x4a, 0xaf, 0x9a, 0x6a, 0xa5, 0x0b, 0x49, 0xb5, 0x52, 0xca, 0x1c, 0x62, 0x68, 0x94, 0xba, 0x4f, - 0xd2, 0xd5, 0x75, 0x64, 0xd3, 0xef, 0xb5, 0xe0, 0x21, 0xa6, 0x5f, 0xa7, 0x15, 0xbc, 0x63, 0x9d, - 0xfa, 0xc3, 0xf7, 0xf6, 0xcb, 0x0f, 0x2d, 0x67, 0xb3, 0xc3, 0x79, 0xf5, 0xd8, 0x0d, 0x38, 0xdf, - 0xe9, 0x68, 0x64, 0x7e, 0x94, 0x75, 0x65, 0x80, 0x8f, 0xfd, 0x28, 0xeb, 0x4b, 0xf3, 0x98, 0x61, - 0xba, 0x8d, 0xdb, 0x65, 0xff, 0x7b, 0x0b, 0x8a, 0x15, 0xbf, 0x7e, 0x0c, 0x97, 0xee, 0x0f, 0x1b, - 0x97, 0xee, 0x87, 0xb3, 0x0f, 0xe5, 0x7a, 0xae, 0x41, 0x69, 0x21, 0x61, 0x50, 0x3a, 0x9b, 0xc7, - 0xa0, 0xbd, 0xf9, 0xe8, 0xa7, 0x8a, 0x30, 0x58, 0xf1, 0xeb, 0xea, 0x11, 0xc3, 0x3f, 0xbe, 0x9f, + 0x10, 0x57, 0x5d, 0x3f, 0x9c, 0x3e, 0x9e, 0xbf, 0x06, 0xc4, 0x0d, 0xf9, 0x5a, 0xad, 0xd3, 0x1a, + 0x50, 0x44, 0x38, 0x66, 0x4a, 0x77, 0x66, 0xba, 0x9b, 0x9e, 0xe8, 0xe0, 0x8b, 0x96, 0xbb, 0x97, + 0xb2, 0x9d, 0x99, 0xee, 0xa4, 0x94, 0x85, 0xfd, 0x27, 0x83, 0x69, 0x99, 0x85, 0xa9, 0x48, 0xfe, + 0x37, 0x2b, 0x65, 0x3d, 0xff, 0x40, 0xaf, 0x1a, 0xdb, 0x43, 0xbc, 0xd6, 0x7d, 0xce, 0x82, 0x13, + 0xad, 0xcc, 0x0f, 0x11, 0x02, 0x40, 0x6f, 0x8a, 0x5f, 0xfe, 0xe9, 0x2a, 0x48, 0x69, 0x36, 0x1e, + 0xe7, 0xd4, 0x94, 0xbc, 0x3a, 0x17, 0xdf, 0xf1, 0xd5, 0x79, 0x05, 0x86, 0xea, 0xfc, 0x9e, 0x23, + 0x83, 0x6b, 0xf7, 0x14, 0x62, 0x8f, 0x89, 0x12, 0xe2, 0x82, 0xb4, 0x8e, 0x15, 0x0b, 0xf4, 0xc3, + 0x16, 0x9c, 0x4e, 0x36, 0x1d, 0x13, 0x86, 0x16, 0x91, 0x4d, 0xb9, 0x5e, 0x66, 0x59, 0x7c, 0x7f, + 0x4a, 0xfe, 0x37, 0x88, 0xf7, 0xbb, 0x11, 0xe0, 0xce, 0x95, 0xa1, 0xc5, 0x0c, 0xc5, 0xd0, 0x80, + 0x69, 0x12, 0xeb, 0x41, 0x39, 0xf4, 0x02, 0x8c, 0x6c, 0xfb, 0x6d, 0x2f, 0x12, 0xae, 0x6b, 0xc2, + 0x8d, 0x86, 0xb9, 0x8f, 0xac, 0x68, 0x70, 0x6c, 0x50, 0x25, 0x54, 0x4a, 0x43, 0xf7, 0xad, 0x52, + 0x7a, 0x0b, 0x46, 0x3c, 0xcd, 0xd7, 0x5a, 0xc8, 0x03, 0xe7, 0xf2, 0x95, 0x6e, 0xba, 0x67, 0x36, + 0x6f, 0xa5, 0x0e, 0xc1, 0x06, 0xb7, 0xa3, 0xf5, 0x69, 0xfb, 0xf9, 0x42, 0x86, 0x50, 0xcf, 0xd5, + 0x4a, 0xaf, 0x9a, 0x6a, 0xa5, 0x73, 0x49, 0xb5, 0x52, 0xca, 0x1c, 0x62, 0x68, 0x94, 0x7a, 0x4f, + 0xd2, 0xd5, 0x73, 0x64, 0xd3, 0xef, 0xb5, 0xe0, 0x21, 0xa6, 0x5f, 0xa7, 0x15, 0xbc, 0x63, 0x9d, + 0xfa, 0xc3, 0xf7, 0xf6, 0xca, 0x0f, 0x5d, 0xcd, 0x66, 0x87, 0xf3, 0xea, 0xb1, 0x9b, 0x70, 0xb6, + 0xdb, 0xd1, 0xc8, 0xfc, 0x28, 0x1b, 0xca, 0x00, 0x1f, 0xfb, 0x51, 0x36, 0x2a, 0x8b, 0x98, 0x61, + 0x7a, 0x8d, 0xdb, 0x65, 0xff, 0x7b, 0x0b, 0x8a, 0x55, 0xbf, 0x71, 0x04, 0x97, 0xee, 0x0f, 0x1b, + 0x97, 0xee, 0x87, 0xb3, 0x0f, 0xe5, 0x46, 0xae, 0x41, 0x69, 0x29, 0x61, 0x50, 0x3a, 0x9d, 0xc7, + 0xa0, 0xb3, 0xf9, 0xe8, 0xa7, 0x8a, 0x30, 0x5c, 0xf5, 0x1b, 0xea, 0x11, 0xc3, 0x3f, 0xbe, 0x9f, 0x47, 0x0c, 0xb9, 0x69, 0x57, 0x34, 0xce, 0xcc, 0xfd, 0x52, 0xbe, 0xfc, 0xfe, 0x36, 0x7b, 0xcb, - 0x70, 0x8b, 0xb8, 0x9b, 0x5b, 0x11, 0xa9, 0x27, 0x3f, 0xe7, 0xf8, 0xde, 0x32, 0xfc, 0x49, 0x01, - 0x46, 0x13, 0xb5, 0xa3, 0x06, 0x0c, 0x37, 0x74, 0x73, 0x85, 0x98, 0xa7, 0xf7, 0x65, 0xe9, 0x10, - 0xbe, 0xe0, 0x1a, 0x08, 0x9b, 0xcc, 0xd1, 0x34, 0x80, 0xb2, 0xdf, 0x4b, 0x75, 0x35, 0xbb, 0x79, - 0x28, 0x03, 0x7f, 0x88, 0x35, 0x0a, 0xf4, 0x22, 0x0c, 0x46, 0x7e, 0xd3, 0x6f, 0xf8, 0x9b, 0x7b, - 0xd7, 0x88, 0x0c, 0xe9, 0xa6, 0x3c, 0x3c, 0xd7, 0x62, 0x14, 0xd6, 0xe9, 0xd0, 0x1d, 0x18, 0x57, - 0x4c, 0xaa, 0x47, 0x60, 0xc2, 0x61, 0x9a, 0x8d, 0xd5, 0x24, 0x47, 0x9c, 0xae, 0xc4, 0xfe, 0x99, - 0x22, 0xef, 0x62, 0x2f, 0x72, 0xdf, 0x5b, 0x0d, 0xef, 0xee, 0xd5, 0xf0, 0x0d, 0x0b, 0xc6, 0x68, - 0xed, 0xcc, 0x7d, 0x4d, 0x8a, 0x1a, 0x2a, 0x16, 0xbb, 0xd5, 0x26, 0x16, 0xfb, 0x05, 0xba, 0x6b, - 0xd6, 0xfd, 0x56, 0x24, 0xf4, 0x87, 0xda, 0xb6, 0x48, 0xa1, 0x58, 0x60, 0x05, 0x1d, 0x09, 0x02, - 0xf1, 0xe4, 0x56, 0xa7, 0x23, 0x41, 0x80, 0x05, 0x56, 0x86, 0x6a, 0xef, 0xc9, 0x0e, 0xd5, 0xce, - 0x23, 0xee, 0x0a, 0x47, 0x27, 0x21, 0xf4, 0x69, 0x11, 0x77, 0xa5, 0x07, 0x54, 0x4c, 0x63, 0x7f, - 0xad, 0x08, 0x43, 0x15, 0xbf, 0x1e, 0xdb, 0xee, 0x5f, 0x30, 0x6c, 0xf7, 0xe7, 0x13, 0xb6, 0xfb, - 0x31, 0x9d, 0xf6, 0x3d, 0x4b, 0xfd, 0xb7, 0xca, 0x52, 0xff, 0x1b, 0x16, 0x1b, 0xb5, 0xf9, 0xd5, - 0x2a, 0xf7, 0x86, 0x44, 0x97, 0x61, 0x90, 0x6d, 0x30, 0xec, 0x8d, 0xb7, 0x34, 0x68, 0xb3, 0xd4, - 0x69, 0xab, 0x31, 0x18, 0xeb, 0x34, 0xe8, 0x22, 0x0c, 0x84, 0xc4, 0x09, 0x6a, 0x5b, 0x6a, 0x77, - 0x15, 0xd6, 0x67, 0x0e, 0xc3, 0x0a, 0x8b, 0xde, 0x88, 0x83, 0xbd, 0x16, 0xf3, 0xdf, 0x8c, 0xea, - 0xed, 0xe1, 0x4b, 0x24, 0x3f, 0xc2, 0xab, 0x7d, 0x0b, 0x50, 0x9a, 0xbe, 0x8b, 0x70, 0x84, 0x65, - 0x33, 0x1c, 0x61, 0x29, 0x15, 0x8a, 0xf0, 0xaf, 0x2d, 0x18, 0xa9, 0xf8, 0x75, 0xba, 0x74, 0xbf, - 0x93, 0xd6, 0xa9, 0x1e, 0xe9, 0xba, 0xaf, 0x4d, 0xa4, 0xeb, 0x47, 0xa1, 0xb7, 0xe2, 0xd7, 0x3b, - 0x84, 0x4c, 0xfc, 0xff, 0x2d, 0xe8, 0xaf, 0xf8, 0xf5, 0x63, 0x30, 0x4d, 0xbc, 0x6a, 0x9a, 0x26, - 0x1e, 0xca, 0x99, 0x37, 0x39, 0xd6, 0x88, 0xff, 0xaf, 0x07, 0x86, 0x69, 0x3b, 0xfd, 0x4d, 0x39, - 0x94, 0x46, 0xb7, 0x59, 0x5d, 0x74, 0x1b, 0x95, 0xc2, 0xfd, 0x46, 0xc3, 0xbf, 0x9d, 0x1c, 0xd6, - 0x45, 0x06, 0xc5, 0x02, 0x8b, 0x9e, 0x81, 0x81, 0x66, 0x40, 0x76, 0x5d, 0x5f, 0x88, 0xb7, 0x9a, - 0xa1, 0xa7, 0x22, 0xe0, 0x58, 0x51, 0xd0, 0xab, 0x69, 0xe8, 0x7a, 0xf4, 0x28, 0xaf, 0xf9, 0x5e, - 0x9d, 0x6b, 0xef, 0x8b, 0x22, 0x1d, 0x8b, 0x06, 0xc7, 0x06, 0x15, 0xba, 0x05, 0x25, 0xf6, 0x9f, - 0x6d, 0x3b, 0x87, 0x4f, 0x04, 0x2d, 0x12, 0x54, 0x0a, 0x06, 0x38, 0xe6, 0x85, 0x9e, 0x03, 0x88, - 0x64, 0x4a, 0x83, 0x50, 0x84, 0xce, 0x53, 0x57, 0x01, 0x95, 0xec, 0x20, 0xc4, 0x1a, 0x15, 0x7a, - 0x1a, 0x4a, 0x91, 0xe3, 0x36, 0x96, 0x5d, 0x8f, 0xd9, 0x7f, 0x69, 0xfb, 0x45, 0x9e, 0x48, 0x01, - 0xc4, 0x31, 0x9e, 0x8a, 0x62, 0x2c, 0x28, 0x0a, 0x4f, 0x83, 0x3f, 0xc0, 0xa8, 0x99, 0x28, 0xb6, - 0xac, 0xa0, 0x58, 0xa3, 0x40, 0x5b, 0x70, 0xc6, 0xf5, 0x58, 0xea, 0x12, 0x52, 0xdd, 0x76, 0x9b, - 0x6b, 0xcb, 0xd5, 0x9b, 0x24, 0x70, 0x37, 0xf6, 0x66, 0x9d, 0xda, 0x36, 0xf1, 0x64, 0x8a, 0x5f, - 0x99, 0xf9, 0xfd, 0xcc, 0x52, 0x1b, 0x5a, 0xdc, 0x96, 0x93, 0xfd, 0x3c, 0x9b, 0xef, 0xd7, 0xab, - 0xe8, 0x29, 0x63, 0xeb, 0x38, 0xa5, 0x6f, 0x1d, 0x07, 0xfb, 0xe5, 0xbe, 0xeb, 0x55, 0x2d, 0x32, - 0xc7, 0x4b, 0x70, 0xb2, 0xe2, 0xd7, 0x2b, 0x7e, 0x10, 0x2d, 0xfa, 0xc1, 0x6d, 0x27, 0xa8, 0xcb, - 0xe9, 0x55, 0x96, 0xb1, 0x49, 0xe8, 0xfe, 0xd9, 0xcb, 0x77, 0x17, 0x23, 0xee, 0xc8, 0xf3, 0x4c, - 0x62, 0x3b, 0xe4, 0x8b, 0xba, 0x1a, 0x93, 0x1d, 0x54, 0xf2, 0x9f, 0x2b, 0x4e, 0x44, 0xd0, 0x75, - 0x96, 0xc4, 0x3f, 0x3e, 0x46, 0x45, 0xf1, 0x27, 0xb5, 0x24, 0xfe, 0x31, 0x32, 0xf3, 0xdc, 0x35, - 0xcb, 0xdb, 0x9f, 0x15, 0x95, 0x70, 0x3d, 0x00, 0xf7, 0x5a, 0xec, 0x26, 0x0b, 0xb6, 0xcc, 0x0e, - 0x52, 0xc8, 0x8f, 0xfc, 0xc6, 0x2d, 0xaf, 0x6d, 0xb3, 0x83, 0xd8, 0xdf, 0x0d, 0xa7, 0x92, 0xd5, - 0x77, 0x9d, 0x8a, 0x7b, 0x0e, 0xc6, 0x03, 0xbd, 0xa0, 0x96, 0x6a, 0xed, 0x24, 0xcf, 0xe8, 0x90, - 0x40, 0xe2, 0x34, 0xbd, 0xfd, 0x22, 0x8c, 0xd3, 0xbb, 0xa7, 0x12, 0xe4, 0x58, 0x2f, 0x77, 0x0e, - 0xd2, 0xf2, 0x1f, 0x7a, 0xd9, 0x41, 0x94, 0xc8, 0xbb, 0x83, 0x3e, 0x09, 0x23, 0x21, 0x59, 0x76, - 0xbd, 0xd6, 0x1d, 0xa9, 0x7d, 0x6a, 0xf3, 0x94, 0xb4, 0xba, 0xa0, 0x53, 0x72, 0x1d, 0xb6, 0x09, - 0xc3, 0x09, 0x6e, 0x68, 0x07, 0x46, 0x6e, 0xbb, 0x5e, 0xdd, 0xbf, 0x1d, 0x4a, 0xfe, 0x03, 0xf9, - 0xaa, 0xec, 0x5b, 0x9c, 0x32, 0xd1, 0x46, 0xa3, 0xba, 0x5b, 0x06, 0x33, 0x9c, 0x60, 0x4e, 0x17, - 0x7b, 0xd0, 0xf2, 0x66, 0xc2, 0x1b, 0x21, 0xe1, 0x8f, 0x03, 0xc5, 0x62, 0xc7, 0x12, 0x88, 0x63, - 0x3c, 0x5d, 0xec, 0xec, 0xcf, 0x95, 0xc0, 0x6f, 0xf1, 0x24, 0x2f, 0x62, 0xb1, 0x63, 0x05, 0xc5, - 0x1a, 0x05, 0xdd, 0x0c, 0xd9, 0xbf, 0x55, 0xdf, 0xc3, 0xbe, 0x1f, 0xc9, 0xed, 0x93, 0x25, 0x29, - 0xd3, 0xe0, 0xd8, 0xa0, 0x42, 0x8b, 0x80, 0xc2, 0x56, 0xb3, 0xd9, 0x60, 0xde, 0x69, 0x4e, 0x83, - 0xb1, 0xe2, 0x6e, 0x3b, 0x45, 0x1e, 0xa4, 0xba, 0x9a, 0xc2, 0xe2, 0x8c, 0x12, 0xf4, 0x5c, 0xdc, - 0x10, 0x4d, 0xed, 0x65, 0x4d, 0xe5, 0x66, 0xaf, 0x2a, 0x6f, 0xa7, 0xc4, 0xa1, 0x05, 0xe8, 0x0f, - 0xf7, 0xc2, 0x5a, 0xd4, 0x08, 0xdb, 0xa5, 0x84, 0xab, 0x32, 0x12, 0x2d, 0x23, 0x29, 0x2f, 0x82, - 0x65, 0x59, 0x54, 0x83, 0x09, 0xc1, 0x71, 0x6e, 0xcb, 0xf1, 0x54, 0xa2, 0x2a, 0xee, 0xaa, 0x7f, - 0xf9, 0xde, 0x7e, 0x79, 0x42, 0xd4, 0xac, 0xa3, 0x0f, 0xf6, 0xcb, 0x74, 0x71, 0x64, 0x60, 0x70, - 0x16, 0x37, 0x3e, 0xf9, 0x6a, 0x35, 0x7f, 0xa7, 0x59, 0x09, 0xfc, 0x0d, 0xb7, 0x41, 0xda, 0x99, - 0x0e, 0xab, 0x06, 0xa5, 0x98, 0x7c, 0x06, 0x0c, 0x27, 0xb8, 0xd9, 0x9f, 0x65, 0xb2, 0x63, 0xd5, - 0xdd, 0xf4, 0x9c, 0xa8, 0x15, 0x10, 0xb4, 0x03, 0xc3, 0x4d, 0xb6, 0xbb, 0x88, 0xd4, 0x2b, 0x62, - 0xae, 0xbf, 0xd0, 0xa5, 0xfa, 0xe9, 0x36, 0x4b, 0x1e, 0x67, 0xb8, 0xba, 0x55, 0x74, 0x76, 0xd8, - 0xe4, 0x6e, 0xff, 0x8b, 0xd3, 0x4c, 0xfa, 0xa8, 0x72, 0x9d, 0x52, 0xbf, 0x78, 0x19, 0x24, 0xae, - 0xb1, 0x53, 0xf9, 0x0a, 0xd6, 0x78, 0x58, 0xc4, 0xeb, 0x22, 0x2c, 0xcb, 0xa2, 0x4f, 0xc0, 0x08, - 0xbd, 0x15, 0x2a, 0x09, 0x20, 0x9c, 0x3c, 0x91, 0x1f, 0xc1, 0x45, 0x51, 0xe9, 0x69, 0x99, 0xf4, - 0xc2, 0x38, 0xc1, 0x0c, 0xbd, 0xc1, 0x5c, 0xcb, 0x24, 0xeb, 0x42, 0x37, 0xac, 0x75, 0x2f, 0x32, - 0xc9, 0x56, 0x63, 0x82, 0x5a, 0x30, 0x91, 0x4e, 0x3e, 0x19, 0x4e, 0xda, 0xf9, 0xe2, 0x75, 0x3a, - 0x7f, 0x64, 0x9c, 0x3f, 0x27, 0x8d, 0x0b, 0x71, 0x16, 0x7f, 0xb4, 0x9c, 0x4c, 0x0d, 0x58, 0x34, - 0xf4, 0xbe, 0xa9, 0xf4, 0x80, 0xc3, 0x6d, 0xb3, 0x02, 0x6e, 0xc2, 0x59, 0x2d, 0xbb, 0xda, 0x95, - 0xc0, 0x61, 0xce, 0x1b, 0x2e, 0xdb, 0x4e, 0x35, 0xb9, 0xe8, 0x91, 0x7b, 0xfb, 0xe5, 0xb3, 0x6b, - 0xed, 0x08, 0x71, 0x7b, 0x3e, 0xe8, 0x3a, 0x9c, 0xe4, 0xf1, 0x07, 0xe6, 0x89, 0x53, 0x6f, 0xb8, - 0x9e, 0x12, 0xbc, 0xf8, 0x92, 0x3f, 0x7d, 0x6f, 0xbf, 0x7c, 0x72, 0x26, 0x8b, 0x00, 0x67, 0x97, - 0x43, 0xaf, 0x42, 0xa9, 0xee, 0x85, 0xa2, 0x0f, 0xfa, 0x8c, 0x04, 0x76, 0xa5, 0xf9, 0xd5, 0xaa, - 0xfa, 0xfe, 0xf8, 0x0f, 0x8e, 0x0b, 0xa0, 0x4d, 0x6e, 0x1b, 0x50, 0xda, 0xa2, 0xfe, 0x54, 0xe4, - 0xb6, 0xa4, 0x42, 0xd5, 0x78, 0x81, 0xcc, 0x8d, 0x62, 0xea, 0x61, 0x8e, 0xf1, 0x38, 0xd9, 0x60, - 0x8c, 0x5e, 0x07, 0x24, 0x12, 0x25, 0xcc, 0xd4, 0x58, 0x5e, 0x1f, 0x76, 0x34, 0x0e, 0x98, 0x6f, - 0x62, 0xab, 0x29, 0x0a, 0x9c, 0x51, 0x0a, 0x5d, 0xa5, 0xbb, 0x8a, 0x0e, 0x15, 0xbb, 0x96, 0x4a, - 0x93, 0x3a, 0x4f, 0x9a, 0x01, 0x61, 0x3e, 0x66, 0x26, 0x47, 0x9c, 0x28, 0x87, 0xea, 0x70, 0xc6, - 0x69, 0x45, 0x3e, 0x33, 0xbb, 0x98, 0xa4, 0x6b, 0xfe, 0x36, 0xf1, 0x98, 0xc5, 0x73, 0x80, 0x45, - 0x84, 0x3b, 0x33, 0xd3, 0x86, 0x0e, 0xb7, 0xe5, 0x42, 0x25, 0x72, 0x95, 0x17, 0x1d, 0xcc, 0x78, - 0x74, 0x19, 0xb9, 0xd1, 0x5f, 0x84, 0xc1, 0x2d, 0x3f, 0x8c, 0x56, 0x49, 0x74, 0xdb, 0x0f, 0xb6, - 0x45, 0x64, 0xe6, 0x38, 0x1a, 0x7e, 0x8c, 0xc2, 0x3a, 0x1d, 0xbd, 0x72, 0x33, 0x7f, 0x9c, 0xa5, - 0x79, 0xe6, 0x0a, 0x31, 0x10, 0xef, 0x31, 0x57, 0x39, 0x18, 0x4b, 0xbc, 0x24, 0x5d, 0xaa, 0xcc, - 0x31, 0xb7, 0x86, 0x04, 0xe9, 0x52, 0x65, 0x0e, 0x4b, 0x3c, 0x9d, 0xae, 0xe1, 0x96, 0x13, 0x90, - 0x4a, 0xe0, 0xd7, 0x48, 0xa8, 0xe5, 0x60, 0x78, 0x98, 0xc7, 0x9d, 0xa6, 0xd3, 0xb5, 0x9a, 0x45, - 0x80, 0xb3, 0xcb, 0x21, 0x92, 0xce, 0x2c, 0x38, 0x92, 0x6f, 0x8f, 0x4a, 0xcb, 0x33, 0x5d, 0x26, - 0x17, 0xf4, 0x60, 0x4c, 0xe5, 0x34, 0xe4, 0x91, 0xa6, 0xc3, 0xc9, 0x51, 0x36, 0xb7, 0xbb, 0x0f, - 0x53, 0xad, 0x2c, 0x7c, 0x4b, 0x09, 0x4e, 0x38, 0xc5, 0xdb, 0x08, 0x39, 0x38, 0xd6, 0x31, 0xe4, - 0xe0, 0x25, 0x28, 0x85, 0xad, 0xf5, 0xba, 0xbf, 0xe3, 0xb8, 0x1e, 0x73, 0x6b, 0xd0, 0xee, 0x7e, - 0x55, 0x89, 0xc0, 0x31, 0x0d, 0x5a, 0x84, 0x01, 0x47, 0x9a, 0xef, 0x50, 0x7e, 0xa8, 0x28, 0x65, - 0xb4, 0xe3, 0xd1, 0x53, 0xa4, 0xc1, 0x4e, 0x95, 0x45, 0xaf, 0xc0, 0xb0, 0x78, 0x3f, 0x2f, 0xd2, - 0x00, 0x4f, 0x98, 0x8f, 0x1c, 0xab, 0x3a, 0x12, 0x9b, 0xb4, 0xe8, 0x06, 0x0c, 0x46, 0x7e, 0x83, - 0xbd, 0xd4, 0xa3, 0x62, 0xde, 0xa9, 0xfc, 0xa0, 0x87, 0x6b, 0x8a, 0x4c, 0xd7, 0x5a, 0xab, 0xa2, - 0x58, 0xe7, 0x83, 0xd6, 0xf8, 0x7c, 0x67, 0x19, 0x17, 0x48, 0x28, 0xf2, 0xc8, 0x9e, 0xcd, 0xf3, - 0x49, 0x63, 0x64, 0xe6, 0x72, 0x10, 0x25, 0xb1, 0xce, 0x06, 0x5d, 0x81, 0xf1, 0x66, 0xe0, 0xfa, - 0x6c, 0x4e, 0x28, 0xcb, 0xed, 0xa4, 0x99, 0x5f, 0xad, 0x92, 0x24, 0xc0, 0xe9, 0x32, 0x2c, 0xfc, - 0x81, 0x00, 0x4e, 0x9e, 0xe6, 0x39, 0x62, 0xf8, 0x55, 0x9a, 0xc3, 0xb0, 0xc2, 0xa2, 0x15, 0xb6, - 0x13, 0x73, 0x2d, 0xd0, 0xe4, 0x54, 0x7e, 0x74, 0x2a, 0x5d, 0x5b, 0xc4, 0x85, 0x57, 0xf5, 0x17, - 0xc7, 0x1c, 0x50, 0x5d, 0x4b, 0xcd, 0x4a, 0xaf, 0x00, 0xe1, 0xe4, 0x99, 0x36, 0x4e, 0x91, 0x89, - 0x5b, 0x59, 0x2c, 0x10, 0x18, 0xe0, 0x10, 0x27, 0x78, 0xa2, 0x8f, 0xc0, 0x98, 0x88, 0xc6, 0x19, - 0x77, 0xd3, 0xd9, 0xf8, 0xe5, 0x03, 0x4e, 0xe0, 0x70, 0x8a, 0x9a, 0xe7, 0x68, 0x71, 0xd6, 0x1b, - 0x44, 0x6c, 0x7d, 0xcb, 0xae, 0xb7, 0x1d, 0x4e, 0x9e, 0x63, 0xfb, 0x83, 0xc8, 0xd1, 0x92, 0xc4, - 0xe2, 0x8c, 0x12, 0x68, 0x0d, 0xc6, 0x9a, 0x01, 0x21, 0x3b, 0x4c, 0xd0, 0x17, 0xe7, 0x59, 0x99, - 0x47, 0xff, 0xa0, 0x2d, 0xa9, 0x24, 0x70, 0x07, 0x19, 0x30, 0x9c, 0xe2, 0x80, 0x6e, 0xc3, 0x80, - 0xbf, 0x4b, 0x82, 0x2d, 0xe2, 0xd4, 0x27, 0xcf, 0xb7, 0x79, 0x8f, 0x23, 0x0e, 0xb7, 0xeb, 0x82, - 0x36, 0xe1, 0xed, 0x21, 0xc1, 0x9d, 0xbd, 0x3d, 0x64, 0x65, 0xe8, 0x7f, 0xb7, 0xe0, 0xb4, 0x34, - 0xce, 0x54, 0x9b, 0xb4, 0xd7, 0xe7, 0x7c, 0x2f, 0x8c, 0x02, 0x1e, 0xaf, 0xe2, 0x91, 0xfc, 0x18, - 0x0e, 0x6b, 0x39, 0x85, 0x94, 0x22, 0xfa, 0x74, 0x1e, 0x45, 0x88, 0xf3, 0x6b, 0xa4, 0x57, 0xd3, - 0x90, 0x44, 0x72, 0x33, 0x9a, 0x09, 0x17, 0xdf, 0x98, 0x5f, 0x9d, 0x7c, 0x94, 0x07, 0xdb, 0xa0, - 0x8b, 0xa1, 0x9a, 0x44, 0xe2, 0x34, 0x3d, 0xba, 0x0c, 0x05, 0x3f, 0x9c, 0x7c, 0xac, 0x4d, 0x36, - 0x5f, 0xbf, 0x7e, 0xbd, 0xca, 0xbd, 0xfe, 0xae, 0x57, 0x71, 0xc1, 0x0f, 0x65, 0x9e, 0x14, 0x7a, - 0x1f, 0x0b, 0x27, 0x1f, 0xe7, 0x6a, 0x4b, 0x99, 0x27, 0x85, 0x01, 0x71, 0x8c, 0x47, 0x5b, 0x30, - 0x1a, 0x1a, 0xf7, 0xde, 0x70, 0xf2, 0x02, 0xeb, 0xa9, 0xc7, 0xf3, 0x06, 0xcd, 0xa0, 0xd6, 0x12, - 0x18, 0x98, 0x5c, 0x70, 0x92, 0x2d, 0x5f, 0x5d, 0xda, 0xcd, 0x3b, 0x9c, 0x7c, 0xa2, 0xc3, 0xea, - 0xd2, 0x88, 0xf5, 0xd5, 0xa5, 0xf3, 0xc0, 0x09, 0x9e, 0x53, 0xdf, 0x05, 0xe3, 0x29, 0x71, 0xe9, - 0x30, 0x1e, 0xee, 0x53, 0xdb, 0x30, 0x6c, 0x4c, 0xc9, 0x07, 0xea, 0x5d, 0xf1, 0x3b, 0x25, 0x28, - 0x29, 0xab, 0x37, 0xba, 0x64, 0x3a, 0x54, 0x9c, 0x4e, 0x3a, 0x54, 0x0c, 0x54, 0xfc, 0xba, 0xe1, - 0x43, 0xb1, 0x96, 0x11, 0x92, 0x31, 0x6f, 0x03, 0xec, 0xfe, 0x91, 0x8a, 0x66, 0x4a, 0x28, 0x76, - 0xed, 0x99, 0xd1, 0xd3, 0xd6, 0x3a, 0x71, 0x05, 0xc6, 0x3d, 0x9f, 0xc9, 0xe8, 0xa4, 0x2e, 0x05, - 0x30, 0x26, 0x67, 0x95, 0xf4, 0x18, 0x47, 0x09, 0x02, 0x9c, 0x2e, 0x43, 0x2b, 0xe4, 0x82, 0x52, - 0xd2, 0x1c, 0xc2, 0xe5, 0x28, 0x2c, 0xb0, 0xf4, 0x6e, 0xc8, 0x7f, 0x85, 0x93, 0x63, 0xf9, 0x77, - 0x43, 0x5e, 0x28, 0x29, 0x8c, 0x85, 0x52, 0x18, 0x63, 0xda, 0xff, 0xa6, 0x5f, 0x5f, 0xaa, 0x08, - 0x31, 0x5f, 0x8b, 0x27, 0x5c, 0x5f, 0xaa, 0x60, 0x8e, 0x43, 0x33, 0xd0, 0xc7, 0x7e, 0x84, 0x93, - 0x43, 0xf9, 0x31, 0x71, 0x58, 0x09, 0x2d, 0x4f, 0x1b, 0x2b, 0x80, 0x45, 0x41, 0xa6, 0xdd, 0xa5, - 0x77, 0x23, 0xa6, 0xdd, 0xed, 0xbf, 0x4f, 0xed, 0xae, 0x64, 0x80, 0x63, 0x5e, 0xe8, 0x0e, 0x9c, - 0x34, 0xee, 0xa3, 0xea, 0xd5, 0x0e, 0xe4, 0x1b, 0x7e, 0x13, 0xc4, 0xb3, 0x67, 0x45, 0xa3, 0x4f, - 0x2e, 0x65, 0x71, 0xc2, 0xd9, 0x15, 0xa0, 0x06, 0x8c, 0xd7, 0x52, 0xb5, 0x0e, 0x74, 0x5f, 0xab, - 0x9a, 0x17, 0xe9, 0x1a, 0xd3, 0x8c, 0xd1, 0x2b, 0x30, 0xf0, 0xb6, 0x1f, 0xb2, 0x23, 0x52, 0x5c, - 0x4d, 0x64, 0x50, 0x87, 0x81, 0x37, 0xae, 0x57, 0x19, 0xfc, 0x60, 0xbf, 0x3c, 0x58, 0xf1, 0xeb, - 0xf2, 0x2f, 0x56, 0x05, 0xd0, 0x0f, 0x58, 0x30, 0x95, 0xbe, 0xf0, 0xaa, 0x46, 0x0f, 0x77, 0xdf, - 0x68, 0x5b, 0x54, 0x3a, 0xb5, 0x90, 0xcb, 0x0e, 0xb7, 0xa9, 0x0a, 0x7d, 0x88, 0xae, 0xa7, 0xd0, - 0xbd, 0x4b, 0x44, 0x92, 0xdb, 0x47, 0xe2, 0xf5, 0x44, 0xa1, 0x07, 0xfb, 0xe5, 0x51, 0xbe, 0x33, - 0xba, 0x77, 0xe5, 0xf3, 0x26, 0x51, 0x00, 0x7d, 0x37, 0x9c, 0x0c, 0xd2, 0x1a, 0x54, 0x22, 0x85, - 0xf0, 0xa7, 0xba, 0xd9, 0x65, 0x93, 0x03, 0x8e, 0xb3, 0x18, 0xe2, 0xec, 0x7a, 0xec, 0x5f, 0xb5, - 0x98, 0x7e, 0x5b, 0x34, 0x8b, 0x84, 0xad, 0xc6, 0x71, 0xa4, 0xd6, 0x5e, 0x30, 0x6c, 0xc7, 0xf7, - 0xed, 0x58, 0xf4, 0x8f, 0x2c, 0xe6, 0x58, 0x74, 0x8c, 0xaf, 0x98, 0xde, 0x80, 0x81, 0x48, 0xa6, - 0x3c, 0x6f, 0x93, 0x0d, 0x5c, 0x6b, 0x14, 0x73, 0xae, 0x52, 0x97, 0x1c, 0x95, 0xdd, 0x5c, 0xb1, - 0xb1, 0xff, 0x3e, 0x1f, 0x01, 0x89, 0x39, 0x06, 0x13, 0xdd, 0xbc, 0x69, 0xa2, 0x2b, 0x77, 0xf8, - 0x82, 0x1c, 0x53, 0xdd, 0xdf, 0x33, 0xdb, 0xcd, 0x94, 0x7b, 0xef, 0x76, 0x8f, 0x36, 0xfb, 0x0b, - 0x16, 0x40, 0x1c, 0x6a, 0xbe, 0x8b, 0xa4, 0x96, 0x2f, 0xd1, 0x6b, 0x8d, 0x1f, 0xf9, 0x35, 0xbf, - 0x21, 0x0c, 0x14, 0x67, 0x62, 0x2b, 0x21, 0x87, 0x1f, 0x68, 0xbf, 0xb1, 0xa2, 0x46, 0x65, 0x19, - 0xd8, 0xb2, 0x18, 0xdb, 0xad, 0x8d, 0xa0, 0x96, 0x5f, 0xb6, 0xe0, 0x44, 0x96, 0x4b, 0x3c, 0xbd, - 0x24, 0x73, 0x35, 0xa7, 0xf2, 0x36, 0x54, 0xa3, 0x79, 0x53, 0xc0, 0xb1, 0xa2, 0xe8, 0x3a, 0x5b, - 0xe8, 0xe1, 0x62, 0xbc, 0x5f, 0x87, 0xe1, 0x4a, 0x40, 0x34, 0xf9, 0xe2, 0x35, 0x1e, 0x2c, 0x85, - 0xb7, 0xe7, 0x99, 0x43, 0x07, 0x4a, 0xb1, 0xbf, 0x52, 0x80, 0x13, 0xdc, 0x69, 0x67, 0x66, 0xd7, - 0x77, 0xeb, 0x15, 0xbf, 0x2e, 0x1e, 0x32, 0xbe, 0x09, 0x43, 0x4d, 0x4d, 0x37, 0xdd, 0x2e, 0x5e, - 0xb1, 0xae, 0xc3, 0x8e, 0xb5, 0x69, 0x3a, 0x14, 0x1b, 0xbc, 0x50, 0x1d, 0x86, 0xc8, 0xae, 0x5b, - 0x53, 0x9e, 0x1f, 0x85, 0x43, 0x1f, 0xd2, 0xaa, 0x96, 0x05, 0x8d, 0x0f, 0x36, 0xb8, 0x3e, 0x80, - 0x1c, 0xfe, 0xf6, 0x8f, 0x5a, 0xf0, 0x50, 0x4e, 0x74, 0x63, 0x5a, 0xdd, 0x6d, 0xe6, 0x1e, 0x25, - 0xa6, 0xad, 0xaa, 0x8e, 0x3b, 0x4d, 0x61, 0x81, 0x45, 0x1f, 0x05, 0xe0, 0x4e, 0x4f, 0xc4, 0xab, - 0x75, 0x0c, 0x03, 0x6b, 0x44, 0xb0, 0xd4, 0x82, 0x11, 0xca, 0xf2, 0x58, 0xe3, 0x65, 0x7f, 0xb9, - 0x07, 0x7a, 0x99, 0x93, 0x0d, 0xaa, 0x40, 0xff, 0x16, 0xcf, 0x95, 0xd5, 0x76, 0xdc, 0x28, 0xad, - 0x4c, 0xbf, 0x15, 0x8f, 0x9b, 0x06, 0xc5, 0x92, 0x0d, 0x5a, 0x81, 0x09, 0x9e, 0xb2, 0xac, 0x31, - 0x4f, 0x1a, 0xce, 0x9e, 0x54, 0xfb, 0xf2, 0x2c, 0xdc, 0x4a, 0xfd, 0xbd, 0x94, 0x26, 0xc1, 0x59, - 0xe5, 0xd0, 0x6b, 0x30, 0x42, 0xaf, 0xe1, 0x7e, 0x2b, 0x92, 0x9c, 0x78, 0xb2, 0x32, 0x75, 0x33, - 0x59, 0x33, 0xb0, 0x38, 0x41, 0x8d, 0x5e, 0x81, 0xe1, 0x66, 0x4a, 0xc1, 0xdd, 0x1b, 0x6b, 0x82, - 0x4c, 0xa5, 0xb6, 0x49, 0xcb, 0xbc, 0xe2, 0x5b, 0xec, 0x0d, 0xc0, 0xda, 0x56, 0x40, 0xc2, 0x2d, - 0xbf, 0x51, 0x67, 0x12, 0x70, 0xaf, 0xe6, 0x15, 0x9f, 0xc0, 0xe3, 0x54, 0x09, 0xca, 0x65, 0xc3, - 0x71, 0x1b, 0xad, 0x80, 0xc4, 0x5c, 0xfa, 0x4c, 0x2e, 0x8b, 0x09, 0x3c, 0x4e, 0x95, 0xe8, 0xac, - 0xb9, 0xef, 0x3f, 0x1a, 0xcd, 0xbd, 0xfd, 0xb7, 0x0a, 0x60, 0x0c, 0xed, 0x77, 0x70, 0x12, 0xb5, - 0x57, 0xa1, 0x67, 0x33, 0x68, 0xd6, 0x84, 0x43, 0x59, 0xe6, 0x97, 0xc5, 0x19, 0x94, 0xf9, 0x97, - 0xd1, 0xff, 0x98, 0x95, 0xa2, 0x6b, 0xfc, 0x64, 0x25, 0xf0, 0xe9, 0x21, 0x27, 0xc3, 0xe9, 0xa9, - 0xc7, 0x27, 0xfd, 0x32, 0xc8, 0x40, 0x9b, 0xc0, 0xb3, 0xc2, 0x3d, 0x9f, 0x73, 0x30, 0x7c, 0xaf, - 0xaa, 0x22, 0xda, 0x87, 0xe4, 0x82, 0x2e, 0xc3, 0xa0, 0xc8, 0x6b, 0xc5, 0xde, 0x48, 0xf0, 0xc5, - 0xc4, 0x7c, 0xc5, 0xe6, 0x63, 0x30, 0xd6, 0x69, 0xec, 0x1f, 0x2c, 0xc0, 0x44, 0xc6, 0x23, 0x37, - 0x7e, 0x8c, 0x6c, 0xba, 0x61, 0xa4, 0x92, 0x34, 0x6b, 0xc7, 0x08, 0x87, 0x63, 0x45, 0x41, 0xf7, - 0x2a, 0x7e, 0x50, 0x25, 0x0f, 0x27, 0xf1, 0x88, 0x44, 0x60, 0x0f, 0x99, 0xee, 0xf8, 0x3c, 0xf4, - 0xb4, 0x42, 0x22, 0x43, 0x46, 0xab, 0x63, 0x9b, 0x99, 0xb5, 0x19, 0x86, 0x5e, 0x01, 0x37, 0x95, - 0x85, 0x58, 0xbb, 0x02, 0x72, 0x1b, 0x31, 0xc7, 0xd1, 0xc6, 0x45, 0xc4, 0x73, 0xbc, 0x48, 0x5c, - 0x14, 0xe3, 0xd8, 0xa7, 0x0c, 0x8a, 0x05, 0xd6, 0xfe, 0x52, 0x11, 0x4e, 0xe7, 0x3e, 0x7b, 0xa5, - 0x4d, 0xdf, 0xf1, 0x3d, 0x37, 0xf2, 0x95, 0x13, 0x1e, 0x8f, 0x77, 0x4a, 0x9a, 0x5b, 0x2b, 0x02, - 0x8e, 0x15, 0x05, 0xba, 0x00, 0xbd, 0x4c, 0x29, 0x9e, 0x4a, 0x57, 0x3d, 0x3b, 0xcf, 0x03, 0xe0, - 0x71, 0xb4, 0x76, 0xaa, 0x17, 0xdb, 0x9e, 0xea, 0x8f, 0x52, 0x09, 0xc6, 0x6f, 0x24, 0x0f, 0x14, - 0xda, 0x5c, 0xdf, 0x6f, 0x60, 0x86, 0x44, 0x8f, 0x8b, 0xfe, 0x4a, 0x78, 0x9d, 0x61, 0xa7, 0xee, - 0x87, 0x5a, 0xa7, 0x3d, 0x09, 0xfd, 0xdb, 0x64, 0x2f, 0x70, 0xbd, 0xcd, 0xa4, 0x37, 0xe2, 0x35, - 0x0e, 0xc6, 0x12, 0x6f, 0x66, 0x4e, 0xed, 0x3f, 0x8a, 0xcc, 0xa9, 0xfa, 0x0c, 0x18, 0xe8, 0x28, - 0x9e, 0xfc, 0x50, 0x11, 0x46, 0xf1, 0xec, 0xfc, 0x7b, 0x03, 0x71, 0x23, 0x3d, 0x10, 0x47, 0x91, - 0x60, 0xf4, 0x70, 0xa3, 0xf1, 0x4b, 0x16, 0x8c, 0xb2, 0xec, 0x5a, 0x22, 0x66, 0x85, 0xeb, 0x7b, - 0xc7, 0x70, 0x15, 0x78, 0x14, 0x7a, 0x03, 0x5a, 0x69, 0x32, 0x4f, 0x35, 0x6b, 0x09, 0xe6, 0x38, - 0x74, 0x06, 0x7a, 0x58, 0x13, 0xe8, 0xe0, 0x0d, 0xf1, 0x2d, 0x78, 0xde, 0x89, 0x1c, 0xcc, 0xa0, - 0x2c, 0xfc, 0x1b, 0x26, 0xcd, 0x86, 0xcb, 0x1b, 0x1d, 0xbb, 0x2c, 0xbc, 0x3b, 0x02, 0x62, 0x64, - 0x36, 0xed, 0x9d, 0x85, 0x7f, 0xcb, 0x66, 0xd9, 0xfe, 0x9a, 0xfd, 0x17, 0x05, 0x38, 0x97, 0x59, - 0xae, 0xeb, 0xf0, 0x6f, 0xed, 0x4b, 0x3f, 0xc8, 0x2c, 0x48, 0xc5, 0x63, 0xf4, 0xf5, 0xee, 0xe9, - 0x56, 0xfa, 0xef, 0xed, 0x22, 0x2a, 0x5b, 0x66, 0x97, 0xbd, 0x4b, 0xa2, 0xb2, 0x65, 0xb6, 0x2d, - 0x47, 0x4d, 0xf0, 0x37, 0x85, 0x9c, 0x6f, 0x61, 0x0a, 0x83, 0x8b, 0x74, 0x9f, 0x61, 0xc8, 0x50, - 0x5e, 0xc2, 0xf9, 0x1e, 0xc3, 0x61, 0x58, 0x61, 0xd1, 0x0c, 0x8c, 0xee, 0xb8, 0x1e, 0xdd, 0x7c, - 0xf6, 0x4c, 0x51, 0x5c, 0xd9, 0x32, 0x56, 0x4c, 0x34, 0x4e, 0xd2, 0x23, 0x57, 0x8b, 0xd8, 0xc6, - 0xbf, 0xee, 0x95, 0x43, 0xad, 0xba, 0x69, 0xd3, 0x9d, 0x43, 0xf5, 0x62, 0x46, 0xf4, 0xb6, 0x15, - 0x4d, 0x4f, 0x54, 0xec, 0x5e, 0x4f, 0x34, 0x94, 0xad, 0x23, 0x9a, 0x7a, 0x05, 0x86, 0xef, 0xdb, - 0x36, 0x62, 0x7f, 0xa3, 0x08, 0x0f, 0xb7, 0x59, 0xf6, 0x7c, 0xaf, 0x37, 0xc6, 0x40, 0xdb, 0xeb, - 0x53, 0xe3, 0x50, 0x81, 0x13, 0x1b, 0xad, 0x46, 0x63, 0x8f, 0x3d, 0x81, 0x22, 0x75, 0x49, 0x21, - 0x64, 0x4a, 0xa9, 0x1c, 0x39, 0xb1, 0x98, 0x41, 0x83, 0x33, 0x4b, 0xd2, 0x2b, 0x16, 0x3d, 0x49, - 0xf6, 0x14, 0xab, 0xc4, 0x15, 0x0b, 0xeb, 0x48, 0x6c, 0xd2, 0xa2, 0x2b, 0x30, 0xee, 0xec, 0x3a, - 0x2e, 0x0f, 0x7b, 0x2f, 0x19, 0xf0, 0x3b, 0x96, 0xd2, 0x45, 0xcf, 0x24, 0x09, 0x70, 0xba, 0x0c, - 0x7a, 0x1d, 0x90, 0xbf, 0xce, 0x1e, 0x4a, 0xd4, 0xaf, 0x10, 0x4f, 0x58, 0xdd, 0xd9, 0xd8, 0x15, - 0xe3, 0x2d, 0xe1, 0x7a, 0x8a, 0x02, 0x67, 0x94, 0x4a, 0x04, 0x26, 0xeb, 0xcb, 0x0f, 0x4c, 0xd6, - 0x7e, 0x5f, 0xec, 0x98, 0x80, 0xeb, 0x32, 0x0c, 0x1f, 0xd2, 0xfd, 0xd7, 0xfe, 0x37, 0x16, 0x28, - 0x05, 0xb1, 0x19, 0xfb, 0xf7, 0x15, 0xe6, 0x9f, 0xcc, 0x55, 0xdb, 0x5a, 0xb4, 0xa4, 0x93, 0x9a, - 0x7f, 0x72, 0x8c, 0xc4, 0x26, 0x2d, 0x9f, 0x43, 0x9a, 0x5f, 0xb1, 0x71, 0x2b, 0x10, 0xa1, 0x09, - 0x15, 0x05, 0xfa, 0x18, 0xf4, 0xd7, 0xdd, 0x5d, 0x37, 0x14, 0xca, 0xb1, 0x43, 0x1b, 0xe3, 0xe2, - 0xad, 0x73, 0x9e, 0xb3, 0xc1, 0x92, 0x9f, 0xfd, 0x43, 0x85, 0xb8, 0x4f, 0xde, 0x68, 0xf9, 0x91, - 0x73, 0x0c, 0x27, 0xf9, 0x15, 0xe3, 0x24, 0x7f, 0x3c, 0x7b, 0xa0, 0xb5, 0x26, 0xe5, 0x9e, 0xe0, - 0xd7, 0x13, 0x27, 0xf8, 0x13, 0x9d, 0x59, 0xb5, 0x3f, 0xb9, 0xff, 0x81, 0x05, 0xe3, 0x06, 0xfd, - 0x31, 0x1c, 0x20, 0x8b, 0xe6, 0x01, 0xf2, 0x48, 0xc7, 0x6f, 0xc8, 0x39, 0x38, 0xbe, 0xbf, 0x98, - 0x68, 0x3b, 0x3b, 0x30, 0xde, 0x86, 0x9e, 0x2d, 0x27, 0xa8, 0xb7, 0xcb, 0x4a, 0x93, 0x2a, 0x34, - 0x7d, 0xd5, 0x09, 0x84, 0xa7, 0xc2, 0x33, 0xb2, 0xd7, 0x29, 0xa8, 0xa3, 0x97, 0x02, 0xab, 0x0a, - 0xbd, 0x04, 0x7d, 0x61, 0xcd, 0x6f, 0xaa, 0x37, 0x53, 0x2c, 0xf1, 0x69, 0x95, 0x41, 0x0e, 0xf6, - 0xcb, 0xc8, 0xac, 0x8e, 0x82, 0xb1, 0xa0, 0x47, 0x6f, 0xc2, 0x30, 0xfb, 0xa5, 0xdc, 0x06, 0x8b, - 0xf9, 0x1a, 0x8c, 0xaa, 0x4e, 0xc8, 0x7d, 0x6a, 0x0d, 0x10, 0x36, 0x59, 0x4d, 0x6d, 0x42, 0x49, - 0x7d, 0xd6, 0x03, 0xb5, 0x76, 0xff, 0xab, 0x22, 0x4c, 0x64, 0xcc, 0x39, 0x14, 0x1a, 0x23, 0x71, - 0xb9, 0xcb, 0xa9, 0xfa, 0x0e, 0xc7, 0x22, 0x64, 0x17, 0xa8, 0xba, 0x98, 0x5b, 0x5d, 0x57, 0x7a, - 0x23, 0x24, 0xc9, 0x4a, 0x29, 0xa8, 0x73, 0xa5, 0xb4, 0xb2, 0x63, 0xeb, 0x6a, 0x5a, 0x91, 0x6a, - 0xe9, 0x03, 0x1d, 0xd3, 0xdf, 0xe8, 0x81, 0x13, 0x59, 0x21, 0x63, 0xd1, 0x67, 0x12, 0xd9, 0x94, - 0x5f, 0x68, 0xd7, 0xc3, 0x7a, 0x49, 0x9e, 0x62, 0x59, 0x84, 0x81, 0x9c, 0x36, 0xf3, 0x2b, 0x77, - 0xec, 0x66, 0x51, 0x27, 0x0b, 0x40, 0x13, 0xf0, 0x2c, 0xd8, 0x72, 0xfb, 0xf8, 0x40, 0xd7, 0x0d, - 0x10, 0xe9, 0xb3, 0xc3, 0x84, 0x4b, 0x92, 0x04, 0x77, 0x76, 0x49, 0x92, 0x35, 0xa3, 0x25, 0xe8, - 0xab, 0x71, 0x5f, 0x97, 0x62, 0xe7, 0x2d, 0x8c, 0x3b, 0xba, 0xa8, 0x0d, 0x58, 0x38, 0xb8, 0x08, - 0x06, 0x53, 0x2e, 0x0c, 0x6a, 0x1d, 0xf3, 0x40, 0x27, 0xcf, 0x36, 0x3d, 0xf8, 0xb4, 0x2e, 0x78, - 0xa0, 0x13, 0xe8, 0x47, 0x2d, 0x48, 0x3c, 0x78, 0x51, 0x4a, 0x39, 0x2b, 0x57, 0x29, 0x77, 0x1e, - 0x7a, 0x02, 0xbf, 0x41, 0x92, 0x79, 0x88, 0xb1, 0xdf, 0x20, 0x98, 0x61, 0x28, 0x45, 0x14, 0xab, - 0x5a, 0x86, 0xf4, 0x6b, 0xa4, 0xb8, 0x20, 0x3e, 0x0a, 0xbd, 0x0d, 0xb2, 0x4b, 0x1a, 0xc9, 0x74, - 0x71, 0xcb, 0x14, 0x88, 0x39, 0xce, 0xfe, 0xa5, 0x1e, 0x38, 0xdb, 0x36, 0x1a, 0x14, 0xbd, 0x8c, - 0x6d, 0x3a, 0x11, 0xb9, 0xed, 0xec, 0x25, 0xf3, 0x3a, 0x5d, 0xe1, 0x60, 0x2c, 0xf1, 0xec, 0xf9, - 0x27, 0x4f, 0xcf, 0x90, 0x50, 0x61, 0x8a, 0xac, 0x0c, 0x02, 0x6b, 0xaa, 0xc4, 0x8a, 0x47, 0xa1, - 0x12, 0x7b, 0x0e, 0x20, 0x0c, 0x1b, 0xdc, 0x2d, 0xb0, 0x2e, 0xde, 0x95, 0xc6, 0x69, 0x3c, 0xaa, - 0xcb, 0x02, 0x83, 0x35, 0x2a, 0x34, 0x0f, 0x63, 0xcd, 0xc0, 0x8f, 0xb8, 0x46, 0x78, 0x9e, 0x7b, - 0xce, 0xf6, 0x9a, 0x81, 0x78, 0x2a, 0x09, 0x3c, 0x4e, 0x95, 0x40, 0x2f, 0xc2, 0xa0, 0x08, 0xce, - 0x53, 0xf1, 0xfd, 0x86, 0x50, 0x42, 0x29, 0x67, 0xd2, 0x6a, 0x8c, 0xc2, 0x3a, 0x9d, 0x56, 0x8c, - 0xa9, 0x99, 0xfb, 0x33, 0x8b, 0x71, 0x55, 0xb3, 0x46, 0x97, 0x88, 0x44, 0x3d, 0xd0, 0x55, 0x24, - 0xea, 0x58, 0x2d, 0x57, 0xea, 0xda, 0xea, 0x09, 0x1d, 0x15, 0x59, 0x5f, 0xed, 0x81, 0x09, 0x31, - 0x71, 0x1e, 0xf4, 0x74, 0xb9, 0x91, 0x9e, 0x2e, 0x47, 0xa1, 0xb8, 0x7b, 0x6f, 0xce, 0x1c, 0xf7, - 0x9c, 0xf9, 0x61, 0x0b, 0x4c, 0x49, 0x0d, 0xfd, 0xaf, 0xb9, 0x89, 0xf1, 0x5e, 0xcc, 0x95, 0xfc, - 0xe2, 0x28, 0xbf, 0xef, 0x2c, 0x45, 0x9e, 0xfd, 0xaf, 0x2d, 0x78, 0xa4, 0x23, 0x47, 0xb4, 0x00, - 0x25, 0x26, 0x4e, 0x6a, 0x17, 0xbd, 0x27, 0x94, 0x67, 0xbd, 0x44, 0xe4, 0x48, 0xb7, 0x71, 0x49, - 0xb4, 0x90, 0xca, 0x40, 0xf8, 0x64, 0x46, 0x06, 0xc2, 0x93, 0x46, 0xf7, 0xdc, 0x67, 0x0a, 0xc2, - 0x2f, 0xd2, 0x13, 0xc7, 0x78, 0xd5, 0x86, 0x3e, 0x60, 0x28, 0x1d, 0xed, 0x84, 0xd2, 0x11, 0x99, - 0xd4, 0xda, 0x19, 0xf2, 0x11, 0x18, 0x63, 0x51, 0xfb, 0xd8, 0x3b, 0x0f, 0xf1, 0xde, 0xae, 0x10, - 0xfb, 0x72, 0x2f, 0x27, 0x70, 0x38, 0x45, 0x6d, 0xff, 0x59, 0x11, 0xfa, 0xf8, 0xf2, 0x3b, 0x86, - 0xeb, 0xe5, 0xd3, 0x50, 0x72, 0x77, 0x76, 0x5a, 0x3c, 0xa9, 0x5c, 0x6f, 0xec, 0x19, 0xbc, 0x24, - 0x81, 0x38, 0xc6, 0xa3, 0x45, 0xa1, 0xef, 0x6e, 0x13, 0x18, 0x98, 0x37, 0x7c, 0x7a, 0xde, 0x89, - 0x1c, 0x2e, 0x2b, 0xa9, 0x73, 0x36, 0xd6, 0x8c, 0xa3, 0x4f, 0x02, 0x84, 0x51, 0xe0, 0x7a, 0x9b, - 0x14, 0x26, 0x62, 0xab, 0x3f, 0xd5, 0x86, 0x5b, 0x55, 0x11, 0x73, 0x9e, 0xf1, 0x9e, 0xa3, 0x10, - 0x58, 0xe3, 0x88, 0xa6, 0x8d, 0x93, 0x7e, 0x2a, 0x31, 0x76, 0xc0, 0xb9, 0xc6, 0x63, 0x36, 0xf5, - 0x41, 0x28, 0x29, 0xe6, 0x9d, 0xb4, 0x5f, 0x43, 0xba, 0x58, 0xf4, 0x61, 0x18, 0x4d, 0xb4, 0xed, - 0x50, 0xca, 0xb3, 0x5f, 0xb6, 0x60, 0x94, 0x37, 0x66, 0xc1, 0xdb, 0x15, 0xa7, 0xc1, 0x5d, 0x38, - 0xd1, 0xc8, 0xd8, 0x95, 0xc5, 0xf0, 0x77, 0xbf, 0x8b, 0x2b, 0x65, 0x59, 0x16, 0x16, 0x67, 0xd6, - 0x81, 0x2e, 0xd2, 0x15, 0x47, 0x77, 0x5d, 0xa7, 0x21, 0xe2, 0x1b, 0x0c, 0xf1, 0xd5, 0xc6, 0x61, - 0x58, 0x61, 0xed, 0x3f, 0xb4, 0x60, 0x9c, 0xb7, 0xfc, 0x1a, 0xd9, 0x53, 0x7b, 0xd3, 0xb7, 0xb2, - 0xed, 0x22, 0x9d, 0x69, 0x21, 0x27, 0x9d, 0xa9, 0xfe, 0x69, 0xc5, 0xb6, 0x9f, 0xf6, 0x15, 0x0b, - 0xc4, 0x0c, 0x39, 0x06, 0x7d, 0xc6, 0x77, 0x99, 0xfa, 0x8c, 0xa9, 0xfc, 0x45, 0x90, 0xa3, 0xc8, - 0xf8, 0x6b, 0x0b, 0xc6, 0x38, 0x41, 0x6c, 0xab, 0xff, 0x96, 0x8e, 0xc3, 0xac, 0xf9, 0x45, 0x99, - 0xce, 0x97, 0xd7, 0xc8, 0xde, 0x9a, 0x5f, 0x71, 0xa2, 0xad, 0xec, 0x8f, 0x32, 0x06, 0xab, 0xa7, - 0xed, 0x60, 0xd5, 0xe5, 0x02, 0x32, 0xb2, 0x7d, 0x75, 0x08, 0x10, 0x70, 0xd8, 0x6c, 0x5f, 0xf6, - 0x9f, 0x5b, 0x80, 0x78, 0x35, 0x86, 0xe0, 0x46, 0xc5, 0x21, 0x06, 0xd5, 0x0e, 0xba, 0x78, 0x6b, - 0x52, 0x18, 0xac, 0x51, 0x1d, 0x49, 0xf7, 0x24, 0x1c, 0x2e, 0x8a, 0x9d, 0x1d, 0x2e, 0x0e, 0xd1, - 0xa3, 0xff, 0xac, 0x0f, 0x92, 0x2f, 0xfb, 0xd0, 0x4d, 0x18, 0xaa, 0x39, 0x4d, 0x67, 0xdd, 0x6d, - 0xb8, 0x91, 0x4b, 0xc2, 0x76, 0xde, 0x58, 0x73, 0x1a, 0x9d, 0x30, 0x91, 0x6b, 0x10, 0x6c, 0xf0, - 0x41, 0xd3, 0x00, 0xcd, 0xc0, 0xdd, 0x75, 0x1b, 0x64, 0x93, 0xa9, 0x5d, 0x58, 0x44, 0x15, 0xee, - 0x1a, 0x26, 0xa1, 0x58, 0xa3, 0xc8, 0x08, 0xa3, 0x50, 0x7c, 0xc0, 0x61, 0x14, 0xe0, 0xd8, 0xc2, - 0x28, 0xf4, 0x1c, 0x2a, 0x8c, 0xc2, 0xc0, 0xa1, 0xc3, 0x28, 0xf4, 0x76, 0x15, 0x46, 0x01, 0xc3, - 0x29, 0x29, 0x7b, 0xd2, 0xff, 0x8b, 0x6e, 0x83, 0x88, 0x0b, 0x07, 0x0f, 0x03, 0x33, 0x75, 0x6f, - 0xbf, 0x7c, 0x0a, 0x67, 0x52, 0xe0, 0x9c, 0x92, 0xe8, 0xa3, 0x30, 0xe9, 0x34, 0x1a, 0xfe, 0x6d, - 0x35, 0xa8, 0x0b, 0x61, 0xcd, 0x69, 0x70, 0x13, 0x48, 0x3f, 0xe3, 0x7a, 0xe6, 0xde, 0x7e, 0x79, - 0x72, 0x26, 0x87, 0x06, 0xe7, 0x96, 0x46, 0xaf, 0x42, 0xa9, 0x19, 0xf8, 0xb5, 0x15, 0xed, 0xf9, - 0xf1, 0x39, 0xda, 0x81, 0x15, 0x09, 0x3c, 0xd8, 0x2f, 0x0f, 0xab, 0x3f, 0xec, 0xc0, 0x8f, 0x0b, - 0x64, 0xc4, 0x45, 0x18, 0x3c, 0xd2, 0xb8, 0x08, 0xdb, 0x30, 0x51, 0x25, 0x81, 0xeb, 0x34, 0xdc, - 0xbb, 0x54, 0x5e, 0x96, 0xfb, 0xd3, 0x1a, 0x94, 0x82, 0xc4, 0x8e, 0xdc, 0x55, 0xb0, 0x5e, 0x2d, - 0xe1, 0x92, 0xdc, 0x81, 0x63, 0x46, 0xf6, 0x7f, 0xb5, 0xa0, 0x5f, 0xbc, 0xe4, 0x3b, 0x06, 0xa9, - 0x71, 0xc6, 0x30, 0x4a, 0x94, 0xb3, 0x3b, 0x8c, 0x35, 0x26, 0xd7, 0x1c, 0xb1, 0x94, 0x30, 0x47, - 0x3c, 0xd2, 0x8e, 0x49, 0x7b, 0x43, 0xc4, 0xff, 0x5b, 0xa4, 0xd2, 0xbb, 0xf1, 0xa6, 0xfc, 0xc1, - 0x77, 0xc1, 0x2a, 0xf4, 0x87, 0xe2, 0x4d, 0x73, 0x21, 0xff, 0x35, 0x48, 0x72, 0x10, 0x63, 0x2f, - 0x3a, 0xf1, 0x8a, 0x59, 0x32, 0xc9, 0x7c, 0x2c, 0x5d, 0x7c, 0x80, 0x8f, 0xa5, 0x3b, 0xbd, 0xba, - 0xef, 0x39, 0x8a, 0x57, 0xf7, 0xf6, 0xd7, 0xd9, 0xc9, 0xa9, 0xc3, 0x8f, 0x41, 0xa8, 0xba, 0x62, - 0x9e, 0xb1, 0x76, 0x9b, 0x99, 0x25, 0x1a, 0x95, 0x23, 0x5c, 0xfd, 0xa2, 0x05, 0x67, 0x33, 0xbe, - 0x4a, 0x93, 0xb4, 0x9e, 0x81, 0x01, 0xa7, 0x55, 0x77, 0xd5, 0x5a, 0xd6, 0x4c, 0x93, 0x33, 0x02, - 0x8e, 0x15, 0x05, 0x9a, 0x83, 0x71, 0x72, 0xa7, 0xe9, 0x72, 0x43, 0xae, 0xee, 0x7c, 0x5c, 0xe4, - 0xcf, 0x3f, 0x17, 0x92, 0x48, 0x9c, 0xa6, 0x57, 0x01, 0xa2, 0x8a, 0xb9, 0x01, 0xa2, 0x7e, 0xde, - 0x82, 0x41, 0xf5, 0xaa, 0xf7, 0x81, 0xf7, 0xf6, 0x47, 0xcc, 0xde, 0x7e, 0xb8, 0x4d, 0x6f, 0xe7, - 0x74, 0xf3, 0xef, 0x17, 0x54, 0x7b, 0x2b, 0x7e, 0x10, 0x75, 0x21, 0xc1, 0xdd, 0xff, 0xc3, 0x89, - 0xcb, 0x30, 0xe8, 0x34, 0x9b, 0x12, 0x21, 0x3d, 0xe0, 0x58, 0xe8, 0xf5, 0x18, 0x8c, 0x75, 0x1a, - 0xf5, 0x8e, 0xa3, 0x98, 0xfb, 0x8e, 0xa3, 0x0e, 0x10, 0x39, 0xc1, 0x26, 0x89, 0x28, 0x4c, 0x38, - 0xec, 0xe6, 0xef, 0x37, 0xad, 0xc8, 0x6d, 0x4c, 0xbb, 0x5e, 0x14, 0x46, 0xc1, 0xf4, 0x92, 0x17, - 0x5d, 0x0f, 0xf8, 0x15, 0x52, 0x0b, 0xb1, 0xa6, 0x78, 0x61, 0x8d, 0xaf, 0x8c, 0x60, 0xc1, 0xea, - 0xe8, 0x35, 0x5d, 0x29, 0x56, 0x05, 0x1c, 0x2b, 0x0a, 0xfb, 0x83, 0xec, 0xf4, 0x61, 0x7d, 0x7a, - 0xb8, 0xf0, 0x62, 0x3f, 0x39, 0xa4, 0x46, 0x83, 0x19, 0x45, 0xe7, 0xf5, 0x20, 0x66, 0xed, 0x37, - 0x7b, 0x5a, 0xb1, 0xfe, 0x22, 0x32, 0x8e, 0x74, 0x86, 0x3e, 0x9e, 0x72, 0x8f, 0x79, 0xb6, 0xc3, - 0xa9, 0x71, 0x08, 0x87, 0x18, 0x96, 0x87, 0x89, 0x65, 0xa9, 0x59, 0xaa, 0x88, 0x75, 0xa1, 0xe5, - 0x61, 0x12, 0x08, 0x1c, 0xd3, 0x50, 0x61, 0x4a, 0xfd, 0x09, 0x27, 0x51, 0x1c, 0x0b, 0x58, 0x51, - 0x87, 0x58, 0xa3, 0x40, 0x97, 0x84, 0x42, 0x81, 0xdb, 0x05, 0x1e, 0x4e, 0x28, 0x14, 0x64, 0x77, - 0x69, 0x5a, 0xa0, 0xcb, 0x30, 0x48, 0xee, 0x44, 0x24, 0xf0, 0x9c, 0x06, 0xad, 0xa1, 0x37, 0x8e, - 0x9f, 0xb9, 0x10, 0x83, 0xb1, 0x4e, 0x83, 0xd6, 0x60, 0x34, 0xe4, 0x7a, 0x36, 0x15, 0x24, 0x9e, - 0xeb, 0x2b, 0x9f, 0x52, 0xef, 0xa9, 0x4d, 0xf4, 0x01, 0x03, 0xf1, 0xdd, 0x49, 0x46, 0x99, 0x48, - 0xb2, 0x40, 0xaf, 0xc1, 0x48, 0xc3, 0x77, 0xea, 0xb3, 0x4e, 0xc3, 0xf1, 0x6a, 0xac, 0x7f, 0x06, - 0xcc, 0x74, 0xd4, 0xcb, 0x06, 0x16, 0x27, 0xa8, 0xa9, 0xf0, 0xa6, 0x43, 0x44, 0x98, 0x36, 0xc7, - 0xdb, 0x24, 0xa1, 0xc8, 0x0a, 0xcf, 0x84, 0xb7, 0xe5, 0x1c, 0x1a, 0x9c, 0x5b, 0x1a, 0xbd, 0x04, - 0x43, 0xf2, 0xf3, 0xb5, 0xa0, 0x2c, 0xf1, 0x93, 0x18, 0x0d, 0x87, 0x0d, 0x4a, 0x14, 0xc2, 0x49, - 0xf9, 0x7f, 0x2d, 0x70, 0x36, 0x36, 0xdc, 0x9a, 0x88, 0x54, 0xc0, 0x9f, 0x0f, 0x7f, 0x58, 0xbe, - 0x55, 0x5c, 0xc8, 0x22, 0x3a, 0xd8, 0x2f, 0x9f, 0x11, 0xbd, 0x96, 0x89, 0xc7, 0xd9, 0xbc, 0xd1, - 0x0a, 0x4c, 0x6c, 0x11, 0xa7, 0x11, 0x6d, 0xcd, 0x6d, 0x91, 0xda, 0xb6, 0x5c, 0x70, 0x2c, 0xcc, - 0x8b, 0xf6, 0x74, 0xe4, 0x6a, 0x9a, 0x04, 0x67, 0x95, 0x43, 0x6f, 0xc1, 0x64, 0xb3, 0xb5, 0xde, - 0x70, 0xc3, 0xad, 0x55, 0x3f, 0x62, 0x4e, 0x48, 0x33, 0xf5, 0x7a, 0x40, 0x42, 0xfe, 0xba, 0x94, - 0x1d, 0xbd, 0x32, 0x90, 0x4e, 0x25, 0x87, 0x0e, 0xe7, 0x72, 0x40, 0x77, 0xe1, 0x64, 0x62, 0x22, - 0x88, 0x88, 0x18, 0x23, 0xf9, 0x29, 0x62, 0xaa, 0x59, 0x05, 0x44, 0x70, 0x99, 0x2c, 0x14, 0xce, - 0xae, 0x02, 0xbd, 0x0c, 0xe0, 0x36, 0x17, 0x9d, 0x1d, 0xb7, 0x41, 0xaf, 0x8a, 0x13, 0x6c, 0x8e, - 0xd0, 0x6b, 0x03, 0x2c, 0x55, 0x24, 0x94, 0xee, 0xcd, 0xe2, 0xdf, 0x1e, 0xd6, 0xa8, 0xd1, 0x32, - 0x8c, 0x88, 0x7f, 0x7b, 0x62, 0x48, 0x79, 0x60, 0x96, 0xc7, 0x58, 0x54, 0xad, 0x8a, 0x8e, 0x39, - 0x48, 0x41, 0x70, 0xa2, 0x2c, 0xda, 0x84, 0xb3, 0x32, 0xd1, 0x9f, 0x3e, 0x3f, 0xe5, 0x18, 0x84, - 0x2c, 0x2f, 0xcb, 0x00, 0x7f, 0x95, 0x32, 0xd3, 0x8e, 0x10, 0xb7, 0xe7, 0x43, 0xcf, 0x75, 0x7d, - 0x9a, 0xf3, 0x37, 0xc7, 0x27, 0xe3, 0x88, 0x83, 0xcb, 0x49, 0x24, 0x4e, 0xd3, 0x23, 0x1f, 0x4e, - 0xba, 0x5e, 0xd6, 0xac, 0x3e, 0xc5, 0x18, 0x7d, 0x88, 0x3f, 0xb7, 0x6e, 0x3f, 0xa3, 0x33, 0xf1, - 0x38, 0x9b, 0xef, 0x3b, 0xf3, 0xfb, 0xfb, 0x03, 0x8b, 0x96, 0xd6, 0xa4, 0x73, 0xf4, 0x29, 0x18, - 0xd2, 0x3f, 0x4a, 0x48, 0x1a, 0x17, 0xb2, 0x85, 0x57, 0x6d, 0x4f, 0xe0, 0xb2, 0xbd, 0x5a, 0xf7, - 0x3a, 0x0e, 0x1b, 0x1c, 0x51, 0x2d, 0x23, 0xb6, 0xc1, 0xa5, 0xee, 0x24, 0x99, 0xee, 0xdd, 0xde, - 0x08, 0x64, 0x4f, 0x77, 0xb4, 0x0c, 0x03, 0xb5, 0x86, 0x4b, 0xbc, 0x68, 0xa9, 0xd2, 0x2e, 0x7a, - 0xe3, 0x9c, 0xa0, 0x11, 0xeb, 0x47, 0xa4, 0x58, 0xe1, 0x30, 0xac, 0x38, 0xd8, 0x2f, 0xc1, 0x60, - 0xb5, 0x41, 0x48, 0x93, 0x3f, 0xdf, 0x41, 0x4f, 0xb2, 0xdb, 0x04, 0x93, 0x07, 0x2d, 0x26, 0x0f, - 0xea, 0x17, 0x05, 0x26, 0x09, 0x4a, 0xbc, 0xfd, 0x5b, 0x05, 0x28, 0x77, 0xc8, 0xf4, 0x93, 0x30, - 0x60, 0x59, 0x5d, 0x19, 0xb0, 0x66, 0x60, 0x34, 0xfe, 0xa7, 0xeb, 0xc6, 0x94, 0x0f, 0xec, 0x4d, - 0x13, 0x8d, 0x93, 0xf4, 0x5d, 0x3f, 0x67, 0xd0, 0x6d, 0x60, 0x3d, 0x1d, 0x1f, 0xe4, 0x18, 0xb6, - 0xef, 0xde, 0xee, 0x2f, 0xcc, 0xb9, 0x76, 0x4c, 0xfb, 0xeb, 0x05, 0x38, 0xa9, 0xba, 0xf0, 0x3b, - 0xb7, 0xe3, 0x6e, 0xa4, 0x3b, 0xee, 0x08, 0xac, 0xc0, 0xf6, 0x75, 0xe8, 0xe3, 0x81, 0x2c, 0xbb, - 0x10, 0xd4, 0x1f, 0x35, 0xe3, 0x6b, 0x2b, 0xd9, 0xd0, 0x88, 0xb1, 0xfd, 0x03, 0x16, 0x8c, 0x26, - 0xde, 0xc5, 0x21, 0xac, 0x3d, 0x9e, 0xbe, 0x1f, 0x61, 0x3a, 0x4b, 0x4c, 0x3f, 0x0f, 0x3d, 0x5b, - 0x7e, 0x18, 0x25, 0x5d, 0x44, 0xae, 0xfa, 0x61, 0x84, 0x19, 0xc6, 0xfe, 0x23, 0x0b, 0x7a, 0xd7, - 0x1c, 0xd7, 0x8b, 0xa4, 0x39, 0xc1, 0xca, 0x31, 0x27, 0x74, 0xf3, 0x5d, 0xe8, 0x45, 0xe8, 0x23, - 0x1b, 0x1b, 0xa4, 0x16, 0x89, 0x51, 0x95, 0x41, 0x14, 0xfa, 0x16, 0x18, 0x94, 0x4a, 0x8e, 0xac, - 0x32, 0xfe, 0x17, 0x0b, 0x62, 0x74, 0x0b, 0x4a, 0x91, 0xbb, 0x43, 0x66, 0xea, 0x75, 0x61, 0x64, - 0xbf, 0x8f, 0xc8, 0x1f, 0x6b, 0x92, 0x01, 0x8e, 0x79, 0xd9, 0x5f, 0x2a, 0x00, 0xc4, 0x11, 0xc0, - 0x3a, 0x7d, 0xe2, 0x6c, 0xca, 0xfc, 0x7a, 0x21, 0xc3, 0xfc, 0x8a, 0x62, 0x86, 0x19, 0xb6, 0x57, - 0xd5, 0x4d, 0xc5, 0xae, 0xba, 0xa9, 0xe7, 0x30, 0xdd, 0x34, 0x07, 0xe3, 0x71, 0x04, 0x33, 0x33, - 0x80, 0x23, 0x3b, 0x74, 0xd7, 0x92, 0x48, 0x9c, 0xa6, 0xb7, 0x09, 0x9c, 0x57, 0x81, 0x9c, 0xc4, - 0x59, 0xc8, 0x3c, 0xc8, 0x75, 0x73, 0x76, 0x87, 0x7e, 0x8a, 0xed, 0xcb, 0x85, 0x5c, 0xfb, 0xf2, - 0x4f, 0x58, 0x70, 0x22, 0x59, 0x0f, 0x7b, 0x6e, 0xfd, 0x05, 0x0b, 0x4e, 0x32, 0x2b, 0x3b, 0xab, - 0x35, 0x6d, 0xd3, 0x7f, 0xa1, 0x6d, 0x70, 0xaa, 0x9c, 0x16, 0xc7, 0xd1, 0x3a, 0x56, 0xb2, 0x58, - 0xe3, 0xec, 0x1a, 0xed, 0xff, 0xd2, 0x03, 0x93, 0x79, 0x51, 0xad, 0xd8, 0x03, 0x13, 0xe7, 0x4e, - 0x75, 0x9b, 0xdc, 0x16, 0x6e, 0xfc, 0xf1, 0x03, 0x13, 0x0e, 0xc6, 0x12, 0x9f, 0x4c, 0x9c, 0x52, - 0xe8, 0x32, 0x71, 0xca, 0x16, 0x8c, 0xdf, 0xde, 0x22, 0xde, 0x0d, 0x2f, 0x74, 0x22, 0x37, 0xdc, - 0x70, 0x99, 0x45, 0x9a, 0xcf, 0x1b, 0x99, 0xbd, 0x7a, 0xfc, 0x56, 0x92, 0xe0, 0x60, 0xbf, 0x7c, - 0xd6, 0x00, 0xc4, 0x4d, 0xe6, 0x1b, 0x09, 0x4e, 0x33, 0x4d, 0xe7, 0x9d, 0xe9, 0x79, 0xc0, 0x79, - 0x67, 0x76, 0x5c, 0xe1, 0xc7, 0x22, 0x5f, 0x0f, 0xb0, 0xbb, 0xe6, 0x8a, 0x82, 0x62, 0x8d, 0x02, - 0x7d, 0x02, 0x90, 0x9e, 0xdb, 0xcb, 0x08, 0x2a, 0xfa, 0xec, 0xbd, 0xfd, 0x32, 0x5a, 0x4d, 0x61, - 0x0f, 0xf6, 0xcb, 0x13, 0x14, 0xba, 0xe4, 0xd1, 0x3b, 0x6b, 0x1c, 0x89, 0x2d, 0x83, 0x11, 0xba, - 0x05, 0x63, 0x14, 0xca, 0x56, 0x94, 0x8c, 0x58, 0xca, 0xef, 0x99, 0x4f, 0xdf, 0xdb, 0x2f, 0x8f, - 0xad, 0x26, 0x70, 0x79, 0xac, 0x53, 0x4c, 0xd0, 0xcb, 0x30, 0x12, 0xcf, 0xab, 0x6b, 0x64, 0x8f, - 0x87, 0xf6, 0x29, 0x71, 0x55, 0xf9, 0x8a, 0x81, 0xc1, 0x09, 0x4a, 0xfb, 0x0b, 0x16, 0x9c, 0xce, - 0xcd, 0xa5, 0x8f, 0x2e, 0xc2, 0x80, 0xd3, 0x74, 0xb9, 0xe1, 0x43, 0x1c, 0x35, 0x4c, 0xc1, 0x56, - 0x59, 0xe2, 0x66, 0x0f, 0x85, 0xa5, 0x3b, 0xfc, 0xb6, 0xeb, 0xd5, 0x93, 0x3b, 0xfc, 0x35, 0xd7, - 0xab, 0x63, 0x86, 0x51, 0x47, 0x56, 0x31, 0xf7, 0x11, 0xc3, 0x57, 0xe9, 0x5a, 0xcd, 0xc8, 0xba, - 0x7f, 0xbc, 0xcd, 0x40, 0x4f, 0xeb, 0x46, 0x4a, 0xe1, 0x8f, 0x98, 0x6b, 0xa0, 0xfc, 0xbc, 0x05, - 0xe2, 0xd1, 0x73, 0x17, 0x67, 0xf2, 0x9b, 0x30, 0xb4, 0x9b, 0xce, 0x7b, 0x78, 0x3e, 0xff, 0x15, - 0xb8, 0x88, 0xd5, 0xae, 0x44, 0x74, 0x23, 0xc7, 0xa1, 0xc1, 0xcb, 0xae, 0x83, 0xc0, 0xce, 0x13, - 0x66, 0x8a, 0xe8, 0xdc, 0x9a, 0xe7, 0x00, 0xea, 0x8c, 0x96, 0x25, 0x43, 0x2e, 0x98, 0x12, 0xd7, - 0xbc, 0xc2, 0x60, 0x8d, 0xca, 0xfe, 0xe7, 0x05, 0x18, 0x94, 0x79, 0xf6, 0x5a, 0x5e, 0x37, 0x0a, - 0xc3, 0x43, 0x25, 0xde, 0x46, 0x97, 0xa0, 0xc4, 0x34, 0xda, 0x95, 0x58, 0xcf, 0xaa, 0xf4, 0x49, - 0x2b, 0x12, 0x81, 0x63, 0x1a, 0x26, 0xbe, 0xb7, 0xd6, 0x19, 0x79, 0xe2, 0x89, 0x6e, 0x95, 0x83, - 0xb1, 0xc4, 0xa3, 0x8f, 0xc2, 0x18, 0x2f, 0x17, 0xf8, 0x4d, 0x67, 0x93, 0x5b, 0xc1, 0x7a, 0x55, - 0xdc, 0x93, 0xb1, 0x95, 0x04, 0xee, 0x60, 0xbf, 0x7c, 0x22, 0x09, 0x63, 0xe6, 0xdd, 0x14, 0x17, - 0xe6, 0xec, 0xc6, 0x2b, 0xa1, 0xbb, 0x7a, 0xca, 0x47, 0x2e, 0x46, 0x61, 0x9d, 0xce, 0xfe, 0x14, - 0xa0, 0x74, 0xc6, 0x41, 0xf4, 0x3a, 0x77, 0x96, 0x76, 0x03, 0x52, 0x6f, 0x67, 0xee, 0xd5, 0xa3, - 0x7b, 0xc8, 0xd7, 0x75, 0xbc, 0x14, 0x56, 0xe5, 0xed, 0xff, 0xa3, 0x08, 0x63, 0xc9, 0x78, 0x02, - 0xe8, 0x2a, 0xf4, 0x71, 0x91, 0x52, 0xb0, 0x6f, 0xe3, 0x4d, 0xa4, 0x45, 0x21, 0x60, 0x87, 0xab, - 0x90, 0x4a, 0x45, 0x79, 0xf4, 0x16, 0x0c, 0xd6, 0xfd, 0xdb, 0xde, 0x6d, 0x27, 0xa8, 0xcf, 0x54, - 0x96, 0xc4, 0x74, 0xce, 0x54, 0x71, 0xcc, 0xc7, 0x64, 0x7a, 0x64, 0x03, 0x66, 0x39, 0x8f, 0x51, - 0x58, 0x67, 0x87, 0xd6, 0x58, 0x8a, 0x90, 0x0d, 0x77, 0x73, 0xc5, 0x69, 0xb6, 0x7b, 0x39, 0x33, - 0x27, 0x89, 0x34, 0xce, 0xc3, 0x22, 0x8f, 0x08, 0x47, 0xe0, 0x98, 0x11, 0xfa, 0x0c, 0x4c, 0x84, - 0x39, 0x46, 0x97, 0xbc, 0x04, 0xb4, 0xed, 0xec, 0x10, 0xb3, 0x0f, 0xdd, 0xdb, 0x2f, 0x4f, 0x64, - 0x99, 0x67, 0xb2, 0xaa, 0xb1, 0x3f, 0xdf, 0x03, 0x53, 0x32, 0xd1, 0x66, 0x86, 0x9f, 0xfe, 0xe7, - 0xac, 0x84, 0xa3, 0xfe, 0xcb, 0xf9, 0x7b, 0xc3, 0x03, 0x73, 0xd7, 0xff, 0x62, 0xda, 0x5d, 0xff, - 0xd5, 0x43, 0x36, 0xe3, 0xc8, 0x9c, 0xf6, 0xbf, 0x63, 0x3d, 0xed, 0xbf, 0x7c, 0x02, 0x8c, 0xdd, - 0xdc, 0x48, 0x4c, 0x6f, 0x1d, 0x51, 0x62, 0x7a, 0x0c, 0x03, 0x64, 0xa7, 0x19, 0xed, 0xcd, 0xbb, - 0x81, 0x68, 0x71, 0x26, 0xcf, 0x05, 0x41, 0x93, 0xe6, 0x29, 0x31, 0x58, 0xf1, 0x41, 0xbb, 0x90, - 0x4e, 0xed, 0x2f, 0x56, 0x67, 0xe6, 0xea, 0xb9, 0x32, 0xb7, 0xd0, 0x26, 0x31, 0x35, 0xbb, 0x2f, - 0xa4, 0x48, 0x70, 0xba, 0x0a, 0x96, 0x17, 0x3b, 0x2b, 0xa3, 0xbf, 0x58, 0xb9, 0x99, 0xe2, 0xfa, - 0xcc, 0xad, 0x6a, 0x8a, 0x3e, 0x9d, 0x17, 0x3b, 0x8b, 0x0a, 0x67, 0xd6, 0x85, 0x56, 0xa1, 0x7f, - 0xd3, 0x8d, 0x30, 0x69, 0xfa, 0xe2, 0x56, 0x9f, 0xb9, 0x21, 0x5d, 0xe1, 0x24, 0xe9, 0x3c, 0xd5, - 0x02, 0x81, 0x25, 0x13, 0xf4, 0xba, 0xda, 0x8a, 0xfb, 0xf2, 0x75, 0x76, 0x69, 0xff, 0xa7, 0xcc, - 0xcd, 0xf8, 0x35, 0x28, 0x7a, 0x1b, 0x61, 0xbb, 0xa8, 0x1d, 0xab, 0x8b, 0xd5, 0x74, 0xfe, 0xe8, - 0xd5, 0xc5, 0x2a, 0xa6, 0x05, 0xd9, 0x03, 0x3f, 0x96, 0xd9, 0x7f, 0x20, 0xff, 0xbd, 0x23, 0x4b, - 0xdc, 0xdf, 0x21, 0x9f, 0xff, 0x4d, 0x28, 0x6d, 0x72, 0xfb, 0x8d, 0x4a, 0xbe, 0x9f, 0x79, 0x24, - 0x5c, 0x91, 0x44, 0xe9, 0x4c, 0xd9, 0x0a, 0x85, 0x63, 0x56, 0xe8, 0xf3, 0x16, 0x9c, 0x4c, 0x66, - 0x2b, 0x66, 0xcf, 0x72, 0x84, 0xab, 0xd0, 0x8b, 0xdd, 0xa4, 0x8f, 0x66, 0x05, 0x8c, 0x0a, 0x99, - 0x9a, 0x3d, 0x93, 0x0c, 0x67, 0x57, 0x47, 0x3b, 0x3a, 0x58, 0xaf, 0x0b, 0x97, 0x95, 0xcc, 0x8e, - 0x4e, 0x84, 0x30, 0xe1, 0x1d, 0x8d, 0x67, 0xe7, 0x31, 0x2d, 0x88, 0xd6, 0x32, 0x12, 0xf7, 0x3f, - 0x96, 0x97, 0xb8, 0xbf, 0xeb, 0x74, 0xfd, 0xaf, 0x43, 0x5f, 0xcd, 0xf5, 0xea, 0x24, 0x10, 0xb9, - 0xfa, 0x33, 0xa7, 0xd2, 0x1c, 0xa3, 0x48, 0x4f, 0x25, 0x0e, 0xc7, 0x82, 0x03, 0xe3, 0x45, 0x9a, - 0x5b, 0x1b, 0x61, 0xbb, 0xe0, 0xf4, 0x73, 0xa4, 0xb9, 0x95, 0x98, 0x50, 0x9c, 0x17, 0x83, 0x63, - 0xc1, 0x81, 0x2e, 0x99, 0x0d, 0xba, 0x80, 0x48, 0xd0, 0x2e, 0xef, 0xfe, 0x22, 0x27, 0x49, 0x2f, - 0x19, 0x81, 0xc0, 0x92, 0x09, 0xfa, 0xa4, 0x29, 0x73, 0xf0, 0xcc, 0xfb, 0x4f, 0x77, 0x90, 0x39, - 0x0c, 0xbe, 0xed, 0xa5, 0x8e, 0x97, 0xa1, 0xb0, 0x51, 0x13, 0xc9, 0xf6, 0x33, 0xd5, 0xcc, 0x8b, - 0x73, 0x06, 0x37, 0x16, 0xec, 0x79, 0x71, 0x0e, 0x17, 0x36, 0x6a, 0x74, 0xea, 0xb3, 0x44, 0xfe, - 0x8b, 0x6e, 0x43, 0x66, 0xcc, 0xcf, 0x9c, 0xfa, 0x33, 0x92, 0x28, 0x3d, 0xf5, 0x15, 0x0a, 0xc7, - 0xac, 0x28, 0xdf, 0x58, 0x12, 0x9a, 0xc8, 0xe7, 0xab, 0x04, 0x9e, 0x34, 0xdf, 0x4c, 0x59, 0x68, - 0x1b, 0x86, 0x77, 0xc3, 0xe6, 0x16, 0x91, 0xbb, 0xa2, 0x48, 0x97, 0x9f, 0xf9, 0xa6, 0xfd, 0xa6, - 0x20, 0x74, 0x83, 0xa8, 0xe5, 0x34, 0x52, 0x1b, 0x39, 0xbb, 0x8d, 0xdf, 0xd4, 0x99, 0x61, 0x93, - 0x37, 0x9d, 0x08, 0x6f, 0xf3, 0xc0, 0x53, 0x22, 0x93, 0x7e, 0xe6, 0x44, 0xc8, 0x88, 0x4d, 0xc5, - 0x27, 0x82, 0x40, 0x60, 0xc9, 0x44, 0x75, 0x36, 0x3b, 0x80, 0x4e, 0x75, 0xe8, 0xec, 0x54, 0x7b, - 0xe3, 0xce, 0x66, 0x07, 0x4e, 0xcc, 0x8a, 0x1d, 0x34, 0xcd, 0x8c, 0xac, 0xd1, 0x93, 0x0f, 0xe5, - 0x1f, 0x34, 0x9d, 0xb2, 0x4c, 0xf3, 0x83, 0x26, 0x8b, 0x0a, 0x67, 0xd6, 0x45, 0x3f, 0xae, 0x29, - 0x63, 0x88, 0x89, 0x60, 0xfa, 0x4f, 0xe6, 0x84, 0xe0, 0x4b, 0x07, 0x1a, 0xe3, 0x1f, 0xa7, 0x50, - 0x38, 0x66, 0x85, 0xea, 0x30, 0xd2, 0x34, 0x62, 0x53, 0xb2, 0xa4, 0x00, 0x39, 0x72, 0x41, 0x56, - 0x14, 0x4b, 0xae, 0x54, 0x30, 0x31, 0x38, 0xc1, 0x93, 0x79, 0x68, 0xf1, 0xe7, 0x56, 0x2c, 0x67, - 0x40, 0xce, 0x50, 0x67, 0xbc, 0xc8, 0xe2, 0x43, 0x2d, 0x10, 0x58, 0x32, 0xa1, 0xbd, 0x21, 0x1e, - 0x09, 0xf9, 0x21, 0x4b, 0xbd, 0x91, 0x67, 0x48, 0xcd, 0xb2, 0x2c, 0xc8, 0x80, 0xcc, 0x02, 0x85, - 0x63, 0x56, 0x74, 0x27, 0xa7, 0x07, 0xde, 0x99, 0xfc, 0x9d, 0x3c, 0x79, 0xdc, 0xb1, 0x9d, 0x9c, - 0x1e, 0x76, 0x45, 0x71, 0xd4, 0xa9, 0xf8, 0xc1, 0x2c, 0x6d, 0x40, 0x4e, 0xbb, 0x54, 0x00, 0xe2, - 0x74, 0xbb, 0x14, 0x0a, 0xc7, 0xac, 0xec, 0x1f, 0x2c, 0xc0, 0xb9, 0xf6, 0xeb, 0x2d, 0x36, 0x97, - 0x54, 0x62, 0x9f, 0x92, 0x84, 0xb9, 0x84, 0x5f, 0xde, 0x63, 0xaa, 0xae, 0x43, 0x8a, 0x5e, 0x81, - 0x71, 0xf5, 0x94, 0xab, 0xe1, 0xd6, 0xf6, 0x56, 0x63, 0x7d, 0x89, 0x0a, 0xbe, 0x51, 0x4d, 0x12, - 0xe0, 0x74, 0x19, 0x34, 0x03, 0xa3, 0x06, 0x70, 0x69, 0x5e, 0x5c, 0xd2, 0xe3, 0x40, 0xf5, 0x26, - 0x1a, 0x27, 0xe9, 0xed, 0x9f, 0xb5, 0xe0, 0xa1, 0x9c, 0xac, 0xc1, 0x5d, 0x47, 0xcc, 0xdc, 0x80, - 0xd1, 0xa6, 0x59, 0xb4, 0x43, 0x90, 0x5f, 0x23, 0x37, 0xb1, 0x6a, 0x6b, 0x02, 0x81, 0x93, 0x4c, - 0xed, 0x9f, 0x2e, 0xc0, 0xd9, 0xb6, 0xbe, 0xc9, 0x08, 0xc3, 0xa9, 0xcd, 0x9d, 0xd0, 0x99, 0x0b, - 0x48, 0x9d, 0x78, 0x91, 0xeb, 0x34, 0xaa, 0x4d, 0x52, 0xd3, 0x0c, 0x5e, 0xcc, 0xc9, 0xf7, 0xca, - 0x4a, 0x75, 0x26, 0x4d, 0x81, 0x73, 0x4a, 0xa2, 0x45, 0x40, 0x69, 0x8c, 0x18, 0x61, 0x96, 0x80, - 0x22, 0xcd, 0x0f, 0x67, 0x94, 0x40, 0x1f, 0x84, 0x61, 0xe5, 0xf3, 0xac, 0x8d, 0x38, 0xdb, 0xd8, - 0xb1, 0x8e, 0xc0, 0x26, 0x1d, 0xba, 0xcc, 0x33, 0x98, 0x88, 0x5c, 0x37, 0xc2, 0x3a, 0x36, 0x2a, - 0xd3, 0x93, 0x08, 0x30, 0xd6, 0x69, 0x66, 0x5f, 0xfa, 0xed, 0x6f, 0x9e, 0x7b, 0xdf, 0xef, 0x7d, - 0xf3, 0xdc, 0xfb, 0xfe, 0xf0, 0x9b, 0xe7, 0xde, 0xf7, 0x3d, 0xf7, 0xce, 0x59, 0xbf, 0x7d, 0xef, - 0x9c, 0xf5, 0x7b, 0xf7, 0xce, 0x59, 0x7f, 0x78, 0xef, 0x9c, 0xf5, 0x27, 0xf7, 0xce, 0x59, 0x5f, - 0xfa, 0xd3, 0x73, 0xef, 0x7b, 0x13, 0xc5, 0x31, 0x68, 0x2f, 0xd1, 0xd1, 0xb9, 0xb4, 0x7b, 0xf9, - 0x7f, 0x06, 0x00, 0x00, 0xff, 0xff, 0xb7, 0xcc, 0x26, 0x0e, 0x56, 0x16, 0x01, 0x00, + 0x70, 0x93, 0xb8, 0x1b, 0x9b, 0x11, 0x69, 0x24, 0x3f, 0xe7, 0xe8, 0xde, 0x32, 0x7c, 0xb3, 0x08, + 0xe3, 0x89, 0xda, 0x51, 0x13, 0x46, 0x9b, 0xba, 0xb9, 0x42, 0xcc, 0xd3, 0xfb, 0xb2, 0x74, 0x08, + 0x5f, 0x70, 0x0d, 0x84, 0x4d, 0xe6, 0x68, 0x16, 0x40, 0xd9, 0xef, 0xa5, 0xba, 0x9a, 0xdd, 0x3c, + 0x94, 0x81, 0x3f, 0xc4, 0x1a, 0x05, 0x7a, 0x11, 0x86, 0x23, 0xbf, 0xe5, 0x37, 0xfd, 0x8d, 0xdd, + 0x2b, 0x44, 0x86, 0x74, 0x53, 0x1e, 0x9e, 0x6b, 0x31, 0x0a, 0xeb, 0x74, 0xe8, 0x0e, 0x4c, 0x2a, + 0x26, 0xb5, 0x43, 0x30, 0xe1, 0x30, 0xcd, 0xc6, 0x6a, 0x92, 0x23, 0x4e, 0x57, 0x82, 0x5e, 0x86, + 0x31, 0xe6, 0x6a, 0xca, 0xca, 0x5f, 0x21, 0xbb, 0x32, 0xd4, 0x27, 0x13, 0x82, 0x57, 0x0c, 0x0c, + 0x4e, 0x50, 0xa2, 0x05, 0x98, 0xdc, 0x76, 0xc3, 0x44, 0xf1, 0x01, 0x56, 0x9c, 0x35, 0x60, 0x25, + 0x89, 0xc4, 0x69, 0x7a, 0xfb, 0x67, 0xc4, 0x18, 0x7b, 0x91, 0xfb, 0xde, 0x72, 0x7c, 0x77, 0x2f, + 0xc7, 0x6f, 0x58, 0x30, 0x41, 0x6b, 0x67, 0xfe, 0x73, 0x52, 0xd6, 0x51, 0xc1, 0xe0, 0xad, 0x0e, + 0xc1, 0xe0, 0xcf, 0xd1, 0x6d, 0xbb, 0xe1, 0xb7, 0x23, 0xa1, 0xc0, 0xd4, 0xf6, 0x65, 0x0a, 0xc5, + 0x02, 0x2b, 0xe8, 0x48, 0x10, 0x88, 0x37, 0xbf, 0x3a, 0x1d, 0x09, 0x02, 0x2c, 0xb0, 0x32, 0x56, + 0x7c, 0x5f, 0x76, 0xac, 0x78, 0x1e, 0xf2, 0x57, 0x78, 0x5a, 0x09, 0xa9, 0x53, 0x0b, 0xf9, 0x2b, + 0x5d, 0xb0, 0x62, 0x1a, 0xfb, 0x6b, 0x45, 0x18, 0xa9, 0xfa, 0x8d, 0xd8, 0x79, 0xe0, 0x05, 0xc3, + 0x79, 0xe0, 0x6c, 0xc2, 0x79, 0x60, 0x42, 0xa7, 0x7d, 0xcf, 0x55, 0xe0, 0x5b, 0xe5, 0x2a, 0xf0, + 0x1b, 0x16, 0x1b, 0xb5, 0xc5, 0xd5, 0x1a, 0x77, 0xc7, 0x44, 0x17, 0x61, 0x98, 0xed, 0x70, 0xec, + 0x91, 0xb9, 0xb4, 0xa8, 0xb3, 0xdc, 0x6d, 0xab, 0x31, 0x18, 0xeb, 0x34, 0xe8, 0x3c, 0x0c, 0x85, + 0xc4, 0x09, 0xea, 0x9b, 0x6a, 0x7b, 0x17, 0xe6, 0x6f, 0x0e, 0xc3, 0x0a, 0x8b, 0xde, 0x88, 0xa3, + 0xcd, 0x16, 0xf3, 0x1f, 0xad, 0xea, 0xed, 0xe1, 0x4b, 0x24, 0x3f, 0xc4, 0xac, 0x7d, 0x13, 0x50, + 0x9a, 0xbe, 0x87, 0x78, 0x88, 0x65, 0x33, 0x1e, 0x62, 0x29, 0x15, 0x0b, 0xf1, 0xaf, 0x2d, 0x18, + 0xab, 0xfa, 0x0d, 0xba, 0x74, 0xbf, 0x93, 0xd6, 0xa9, 0x1e, 0x6a, 0x7b, 0xa0, 0x43, 0xa8, 0xed, + 0x47, 0xa1, 0xbf, 0xea, 0x37, 0xba, 0xc4, 0x6c, 0xfc, 0xff, 0x2d, 0x18, 0xac, 0xfa, 0x8d, 0x23, + 0xb0, 0x8d, 0xbc, 0x6a, 0xda, 0x46, 0x1e, 0xca, 0x99, 0x37, 0x39, 0xe6, 0x90, 0xff, 0xaf, 0x0f, + 0x46, 0x69, 0x3b, 0xfd, 0x0d, 0x39, 0x94, 0x46, 0xb7, 0x59, 0x3d, 0x74, 0x1b, 0xbd, 0x06, 0xf8, + 0xcd, 0xa6, 0x7f, 0x3b, 0x39, 0xac, 0xcb, 0x0c, 0x8a, 0x05, 0x16, 0x3d, 0x03, 0x43, 0xad, 0x80, + 0xec, 0xb8, 0xbe, 0x90, 0xaf, 0x35, 0x4b, 0x53, 0x55, 0xc0, 0xb1, 0xa2, 0xa0, 0x77, 0xe3, 0xd0, + 0xf5, 0xa8, 0x2c, 0x51, 0xf7, 0xbd, 0x06, 0x37, 0x1f, 0x14, 0x45, 0x3e, 0x18, 0x0d, 0x8e, 0x0d, + 0x2a, 0x74, 0x13, 0x4a, 0xec, 0x3f, 0xdb, 0x76, 0x0e, 0x9e, 0x89, 0x5a, 0x64, 0xc8, 0x14, 0x0c, + 0x70, 0xcc, 0x0b, 0x3d, 0x07, 0x10, 0xc9, 0x9c, 0x0a, 0xa1, 0x88, 0xdd, 0xa7, 0xee, 0x22, 0x2a, + 0xdb, 0x42, 0x88, 0x35, 0x2a, 0xf4, 0x34, 0x94, 0x22, 0xc7, 0x6d, 0x5e, 0x75, 0x3d, 0x66, 0x80, + 0xa6, 0xed, 0x17, 0x89, 0x2a, 0x05, 0x10, 0xc7, 0x78, 0x2a, 0x0b, 0xb2, 0xa8, 0x2c, 0x3c, 0x0f, + 0xff, 0x10, 0xa3, 0x66, 0xb2, 0xe0, 0x55, 0x05, 0xc5, 0x1a, 0x05, 0xda, 0x84, 0x53, 0xae, 0xc7, + 0x72, 0xa7, 0x90, 0xda, 0x96, 0xdb, 0x5a, 0xbb, 0x5a, 0xbb, 0x41, 0x02, 0x77, 0x7d, 0x77, 0xde, + 0xa9, 0x6f, 0x11, 0x4f, 0xe6, 0x18, 0x96, 0xa9, 0xe7, 0x4f, 0x55, 0x3a, 0xd0, 0xe2, 0x8e, 0x9c, + 0xec, 0xe7, 0xd9, 0x7c, 0xbf, 0x56, 0x43, 0x4f, 0x19, 0x5b, 0xc7, 0x09, 0x7d, 0xeb, 0xd8, 0xdf, + 0x2b, 0x0f, 0x5c, 0xab, 0x69, 0xa1, 0x41, 0x5e, 0x82, 0xe3, 0x55, 0xbf, 0x51, 0xf5, 0x83, 0x68, + 0xd9, 0x0f, 0x6e, 0x3b, 0x41, 0x43, 0x4e, 0xaf, 0xb2, 0x0c, 0x8e, 0x42, 0xf7, 0xcf, 0x7e, 0xbe, + 0xbb, 0x18, 0x81, 0x4f, 0x9e, 0x67, 0x12, 0xdb, 0x01, 0x9f, 0xf4, 0xd5, 0x99, 0xec, 0xa0, 0xb2, + 0x0f, 0x5d, 0x72, 0x22, 0x82, 0xae, 0xc1, 0x68, 0x5d, 0x3f, 0x46, 0x45, 0xf1, 0x27, 0xe5, 0x41, + 0x66, 0x9c, 0xb1, 0x99, 0xe7, 0xae, 0x59, 0xde, 0xfe, 0xac, 0xa8, 0x84, 0x2b, 0x22, 0xb8, 0xdb, + 0x64, 0x2f, 0x69, 0xb8, 0x65, 0x7a, 0x92, 0x42, 0x7e, 0xe8, 0x39, 0x6e, 0xfa, 0xed, 0x98, 0x9e, + 0xc4, 0xfe, 0x6e, 0x38, 0x91, 0xac, 0xbe, 0xe7, 0x5c, 0xe0, 0x0b, 0x30, 0x19, 0xe8, 0x05, 0xb5, + 0x5c, 0x6f, 0xc7, 0x79, 0x4a, 0x89, 0x04, 0x12, 0xa7, 0xe9, 0xed, 0x17, 0x61, 0x92, 0x5e, 0x7e, + 0x95, 0x20, 0xc7, 0x7a, 0xb9, 0x7b, 0x94, 0x98, 0xff, 0xd0, 0xcf, 0x0e, 0xa2, 0x44, 0xe2, 0x1f, + 0xf4, 0x49, 0x18, 0x0b, 0xc9, 0x55, 0xd7, 0x6b, 0xdf, 0x91, 0xea, 0xaf, 0x0e, 0x6f, 0x59, 0x6b, + 0x4b, 0x3a, 0x25, 0xbf, 0x3f, 0x98, 0x30, 0x9c, 0xe0, 0x86, 0xb6, 0x61, 0xec, 0xb6, 0xeb, 0x35, + 0xfc, 0xdb, 0xa1, 0xe4, 0x3f, 0x94, 0xaf, 0x4b, 0xbf, 0xc9, 0x29, 0x13, 0x6d, 0x34, 0xaa, 0xbb, + 0x69, 0x30, 0xc3, 0x09, 0xe6, 0x74, 0xb1, 0x07, 0x6d, 0x6f, 0x2e, 0xbc, 0x1e, 0x12, 0xfe, 0x3a, + 0x51, 0x2c, 0x76, 0x2c, 0x81, 0x38, 0xc6, 0xd3, 0xc5, 0xce, 0xfe, 0x5c, 0x0a, 0xfc, 0x36, 0xcf, + 0x32, 0x23, 0x16, 0x3b, 0x56, 0x50, 0xac, 0x51, 0xd0, 0xcd, 0x90, 0xfd, 0x5b, 0xf5, 0x3d, 0xec, + 0xfb, 0x91, 0xdc, 0x3e, 0x59, 0x96, 0x34, 0x0d, 0x8e, 0x0d, 0x2a, 0xb4, 0x0c, 0x28, 0x6c, 0xb7, + 0x5a, 0x4d, 0xe6, 0x1e, 0xe7, 0x34, 0x19, 0x2b, 0xee, 0x37, 0x54, 0xe4, 0x51, 0xb2, 0x6b, 0x29, + 0x2c, 0xce, 0x28, 0x41, 0xcf, 0xc5, 0x75, 0xd1, 0xd4, 0x7e, 0xd6, 0x54, 0x6e, 0x77, 0xab, 0xf1, + 0x76, 0x4a, 0x1c, 0x5a, 0x82, 0xc1, 0x70, 0x37, 0xac, 0x47, 0xcd, 0xb0, 0x53, 0x4e, 0xba, 0x1a, + 0x23, 0xd1, 0x52, 0xa2, 0xf2, 0x22, 0x58, 0x96, 0x45, 0x75, 0x98, 0x12, 0x1c, 0x17, 0x36, 0x1d, + 0x4f, 0x65, 0xca, 0xe2, 0x6f, 0x05, 0x2e, 0xde, 0xdb, 0x2b, 0x4f, 0x89, 0x9a, 0x75, 0xf4, 0xfe, + 0x5e, 0x99, 0x2e, 0x8e, 0x0c, 0x0c, 0xce, 0xe2, 0xc6, 0x27, 0x5f, 0xbd, 0xee, 0x6f, 0xb7, 0xaa, + 0x81, 0xbf, 0xee, 0x36, 0x49, 0x27, 0xdb, 0x65, 0xcd, 0xa0, 0x14, 0x93, 0xcf, 0x80, 0xe1, 0x04, + 0x37, 0xfb, 0xb3, 0x4c, 0x76, 0xac, 0xb9, 0x1b, 0x9e, 0x13, 0xb5, 0x03, 0x82, 0xb6, 0x61, 0xb4, + 0xc5, 0x76, 0x17, 0x91, 0xfb, 0x45, 0xcc, 0xf5, 0x17, 0x7a, 0xd4, 0x7f, 0xdd, 0x66, 0xd9, 0xeb, + 0x0c, 0x5f, 0xbb, 0xaa, 0xce, 0x0e, 0x9b, 0xdc, 0xed, 0x7f, 0x71, 0x92, 0x49, 0x1f, 0x35, 0xae, + 0xd4, 0x1a, 0x14, 0x4f, 0x93, 0xc4, 0x35, 0x76, 0x26, 0x5f, 0xc3, 0x1b, 0x0f, 0x8b, 0x78, 0xde, + 0x84, 0x65, 0x59, 0xf4, 0x09, 0x18, 0xa3, 0xb7, 0x42, 0x25, 0x01, 0x84, 0xd3, 0xc7, 0xf2, 0x43, + 0xc8, 0x28, 0x2a, 0x3d, 0x2f, 0x94, 0x5e, 0x18, 0x27, 0x98, 0xa1, 0x37, 0x98, 0x6f, 0x9b, 0x64, + 0x5d, 0xe8, 0x85, 0xb5, 0xee, 0xc6, 0x26, 0xd9, 0x6a, 0x4c, 0x50, 0x1b, 0xa6, 0xd2, 0xd9, 0x2f, + 0xc3, 0x69, 0x3b, 0x5f, 0xbc, 0x4e, 0x27, 0xb0, 0x8c, 0x13, 0xf8, 0xa4, 0x71, 0x21, 0xce, 0xe2, + 0x8f, 0xae, 0x26, 0x73, 0x13, 0x16, 0x0d, 0xc5, 0x73, 0x2a, 0x3f, 0xe1, 0x68, 0xc7, 0xb4, 0x84, + 0x1b, 0x70, 0x5a, 0x4b, 0xef, 0x76, 0x29, 0x70, 0x98, 0xf7, 0x88, 0xcb, 0xb6, 0x53, 0x4d, 0x2e, + 0x7a, 0xe4, 0xde, 0x5e, 0xf9, 0xf4, 0x5a, 0x27, 0x42, 0xdc, 0x99, 0x0f, 0xba, 0x06, 0xc7, 0x79, + 0x00, 0x84, 0x45, 0xe2, 0x34, 0x9a, 0xae, 0xa7, 0x04, 0x2f, 0xbe, 0xe4, 0x4f, 0xde, 0xdb, 0x2b, + 0x1f, 0x9f, 0xcb, 0x22, 0xc0, 0xd9, 0xe5, 0xd0, 0xab, 0x50, 0x6a, 0x78, 0xa1, 0xe8, 0x83, 0x01, + 0x23, 0x83, 0x5e, 0x69, 0x71, 0xb5, 0xa6, 0xbe, 0x3f, 0xfe, 0x83, 0xe3, 0x02, 0x68, 0x83, 0x1b, + 0x27, 0x94, 0xba, 0x6a, 0x30, 0x15, 0x3a, 0x2e, 0xa9, 0xd1, 0x35, 0x9e, 0x40, 0x73, 0xab, 0x9c, + 0x7a, 0x19, 0x64, 0xbc, 0x8e, 0x36, 0x18, 0xa3, 0xd7, 0x01, 0x89, 0x4c, 0x0d, 0x73, 0x75, 0x96, + 0x58, 0x88, 0x1d, 0x8d, 0x43, 0xe6, 0xa3, 0xdc, 0x5a, 0x8a, 0x02, 0x67, 0x94, 0x42, 0x97, 0xe9, + 0xae, 0xa2, 0x43, 0xc5, 0xae, 0xa5, 0xf2, 0xb4, 0x2e, 0x92, 0x56, 0x40, 0x98, 0x93, 0x9b, 0xc9, + 0x11, 0x27, 0xca, 0xa1, 0x06, 0x9c, 0x72, 0xda, 0x91, 0xcf, 0xec, 0x3e, 0x26, 0xe9, 0x9a, 0xbf, + 0x45, 0x3c, 0x66, 0x72, 0x1d, 0x62, 0x21, 0xe9, 0x4e, 0xcd, 0x75, 0xa0, 0xc3, 0x1d, 0xb9, 0x50, + 0x89, 0x5c, 0x25, 0x66, 0x07, 0x33, 0x20, 0x5e, 0x46, 0x72, 0xf6, 0x17, 0x61, 0x78, 0xd3, 0x0f, + 0xa3, 0x55, 0x12, 0xdd, 0xf6, 0x83, 0x2d, 0x11, 0x1a, 0x3a, 0x0e, 0xc7, 0x1f, 0xa3, 0xb0, 0x4e, + 0x47, 0xaf, 0xdc, 0xcc, 0x21, 0xa8, 0xb2, 0xc8, 0x7c, 0x31, 0x86, 0xe2, 0x3d, 0xe6, 0x32, 0x07, + 0x63, 0x89, 0x97, 0xa4, 0x95, 0xea, 0x02, 0xf3, 0xab, 0x48, 0x90, 0x56, 0xaa, 0x0b, 0x58, 0xe2, + 0xe9, 0x74, 0x0d, 0x37, 0x9d, 0x80, 0x54, 0x03, 0xbf, 0x4e, 0x42, 0x2d, 0x09, 0xc4, 0xc3, 0x3c, + 0xf0, 0x35, 0x9d, 0xae, 0xb5, 0x2c, 0x02, 0x9c, 0x5d, 0x0e, 0x91, 0x74, 0x6a, 0xc3, 0xb1, 0x7c, + 0x83, 0x58, 0x5a, 0x9e, 0xe9, 0x31, 0xbb, 0xa1, 0x07, 0x13, 0x2a, 0xa9, 0x22, 0x0f, 0x75, 0x1d, + 0x4e, 0x8f, 0xb3, 0xb9, 0xdd, 0x7b, 0x9c, 0x6c, 0x65, 0x62, 0xac, 0x24, 0x38, 0xe1, 0x14, 0x6f, + 0x23, 0xe6, 0xe1, 0x44, 0xd7, 0x98, 0x87, 0x17, 0xa0, 0x14, 0xb6, 0x6f, 0x35, 0xfc, 0x6d, 0xc7, + 0xf5, 0x98, 0x5f, 0x85, 0x76, 0xf7, 0xab, 0x49, 0x04, 0x8e, 0x69, 0xd0, 0x32, 0x0c, 0x39, 0xd2, + 0x7e, 0x88, 0xf2, 0x63, 0x55, 0x29, 0xab, 0x21, 0x0f, 0xdf, 0x22, 0x2d, 0x86, 0xaa, 0x2c, 0x7a, + 0x05, 0x46, 0xc5, 0x03, 0x7e, 0x91, 0x87, 0x78, 0xca, 0x7c, 0x65, 0x59, 0xd3, 0x91, 0xd8, 0xa4, + 0x45, 0xd7, 0x61, 0x38, 0xf2, 0x9b, 0xec, 0xa9, 0x20, 0x15, 0xf3, 0x4e, 0xe4, 0x47, 0x5d, 0x5c, + 0x53, 0x64, 0xba, 0xda, 0x5c, 0x15, 0xc5, 0x3a, 0x1f, 0xb4, 0xc6, 0xe7, 0x3b, 0x4b, 0xf9, 0x40, + 0x42, 0x91, 0xc8, 0xf6, 0x74, 0x9e, 0x53, 0x1c, 0x23, 0x33, 0x97, 0x83, 0x28, 0x89, 0x75, 0x36, + 0xe8, 0x12, 0x4c, 0xb6, 0x02, 0xd7, 0x67, 0x73, 0x42, 0x99, 0x8e, 0xa7, 0xcd, 0x04, 0x6f, 0xd5, + 0x24, 0x01, 0x4e, 0x97, 0x61, 0xf1, 0x17, 0x04, 0x70, 0xfa, 0x24, 0x4f, 0x52, 0xc3, 0xaf, 0xd2, + 0x1c, 0x86, 0x15, 0x16, 0xad, 0xb0, 0x9d, 0x98, 0x6b, 0x81, 0xa6, 0x67, 0xf2, 0xc3, 0x63, 0xe9, + 0xda, 0x22, 0x2e, 0xbc, 0xaa, 0xbf, 0x38, 0xe6, 0x80, 0x1a, 0x5a, 0x6e, 0x58, 0x7a, 0x05, 0x08, + 0xa7, 0x4f, 0x75, 0xf0, 0xca, 0x4c, 0xdc, 0xca, 0x62, 0x81, 0xc0, 0x00, 0x87, 0x38, 0xc1, 0x13, + 0x7d, 0x04, 0x26, 0x44, 0x38, 0xd0, 0xb8, 0x9b, 0x4e, 0xc7, 0x4f, 0x2f, 0x70, 0x02, 0x87, 0x53, + 0xd4, 0x3c, 0x49, 0x8c, 0x73, 0xab, 0x49, 0xc4, 0xd6, 0x77, 0xd5, 0xf5, 0xb6, 0xc2, 0xe9, 0x33, + 0x6c, 0x7f, 0x10, 0x49, 0x62, 0x92, 0x58, 0x9c, 0x51, 0x02, 0xad, 0xc1, 0x44, 0x2b, 0x20, 0x64, + 0x9b, 0x09, 0xfa, 0xe2, 0x3c, 0x2b, 0xf3, 0xf0, 0x23, 0xb4, 0x25, 0xd5, 0x04, 0x6e, 0x3f, 0x03, + 0x86, 0x53, 0x1c, 0xd0, 0x6d, 0x18, 0xf2, 0x77, 0x48, 0xb0, 0x49, 0x9c, 0xc6, 0xf4, 0xd9, 0x0e, + 0x0f, 0x82, 0xc4, 0xe1, 0x76, 0x4d, 0xd0, 0x26, 0xdc, 0x4d, 0x24, 0xb8, 0xbb, 0xbb, 0x89, 0xac, + 0x0c, 0xfd, 0xef, 0x16, 0x9c, 0x94, 0xd6, 0xa1, 0x5a, 0x8b, 0xf6, 0xfa, 0x82, 0xef, 0x85, 0x51, + 0xc0, 0x03, 0x66, 0x3c, 0x92, 0x1f, 0x44, 0x62, 0x2d, 0xa7, 0x90, 0x52, 0x44, 0x9f, 0xcc, 0xa3, + 0x08, 0x71, 0x7e, 0x8d, 0xf4, 0x6a, 0x1a, 0x92, 0x48, 0x6e, 0x46, 0x73, 0xe1, 0xf2, 0x1b, 0x8b, + 0xab, 0xd3, 0x8f, 0xf2, 0x68, 0x1f, 0x74, 0x31, 0xd4, 0x92, 0x48, 0x9c, 0xa6, 0x47, 0x17, 0xa1, + 0xe0, 0x87, 0xd3, 0x8f, 0x75, 0x48, 0x27, 0xec, 0x37, 0xae, 0xd5, 0xb8, 0xdb, 0xe1, 0xb5, 0x1a, + 0x2e, 0xf8, 0xa1, 0x4c, 0xd4, 0x42, 0xef, 0x63, 0xe1, 0xf4, 0xe3, 0x5c, 0x6d, 0x29, 0x13, 0xb5, + 0x30, 0x20, 0x8e, 0xf1, 0x68, 0x13, 0xc6, 0x43, 0xe3, 0xde, 0x1b, 0x4e, 0x9f, 0x63, 0x3d, 0xf5, + 0x78, 0xde, 0xa0, 0x19, 0xd4, 0x5a, 0x06, 0x05, 0x93, 0x0b, 0x4e, 0xb2, 0xe5, 0xab, 0x4b, 0xbb, + 0x79, 0x87, 0xd3, 0x4f, 0x74, 0x59, 0x5d, 0x1a, 0xb1, 0xbe, 0xba, 0x74, 0x1e, 0x38, 0xc1, 0x73, + 0xe6, 0xbb, 0x60, 0x32, 0x25, 0x2e, 0x1d, 0xc4, 0xc5, 0x7e, 0x66, 0x0b, 0x46, 0x8d, 0x29, 0xf9, + 0x40, 0xdd, 0x3b, 0x7e, 0xa7, 0x04, 0x25, 0x65, 0x76, 0x47, 0x17, 0x4c, 0x8f, 0x8e, 0x93, 0x49, + 0x8f, 0x8e, 0xa1, 0xaa, 0xdf, 0x30, 0x9c, 0x38, 0xd6, 0x32, 0x62, 0x42, 0xe6, 0x6d, 0x80, 0xbd, + 0xbf, 0x92, 0xd1, 0x4c, 0x09, 0xc5, 0x9e, 0x5d, 0x43, 0xfa, 0x3a, 0x5a, 0x27, 0x2e, 0xc1, 0xa4, + 0xe7, 0x33, 0x19, 0x9d, 0x34, 0xa4, 0x00, 0xc6, 0xe4, 0xac, 0x92, 0x1e, 0x64, 0x29, 0x41, 0x80, + 0xd3, 0x65, 0x68, 0x85, 0x5c, 0x50, 0x4a, 0x9a, 0x43, 0xb8, 0x1c, 0x85, 0x05, 0x96, 0xde, 0x0d, + 0xf9, 0xaf, 0x70, 0x7a, 0x22, 0xff, 0x6e, 0xc8, 0x0b, 0x25, 0x85, 0xb1, 0x50, 0x0a, 0x63, 0x4c, + 0xfb, 0xdf, 0xf2, 0x1b, 0x95, 0xaa, 0x10, 0xf3, 0xb5, 0x80, 0xc6, 0x8d, 0x4a, 0x15, 0x73, 0x1c, + 0x9a, 0x83, 0x01, 0xf6, 0x23, 0x9c, 0x1e, 0xc9, 0x0f, 0xca, 0xc3, 0x4a, 0x68, 0x89, 0xe2, 0x58, + 0x01, 0x2c, 0x0a, 0x32, 0xed, 0x2e, 0xbd, 0x1b, 0x31, 0xed, 0xee, 0xe0, 0x7d, 0x6a, 0x77, 0x25, + 0x03, 0x1c, 0xf3, 0x42, 0x77, 0xe0, 0xb8, 0x71, 0x1f, 0x55, 0xcf, 0x86, 0x20, 0xdf, 0xf0, 0x9b, + 0x20, 0x9e, 0x3f, 0x2d, 0x1a, 0x7d, 0xbc, 0x92, 0xc5, 0x09, 0x67, 0x57, 0x80, 0x9a, 0x30, 0x59, + 0x4f, 0xd5, 0x3a, 0xd4, 0x7b, 0xad, 0x6a, 0x5e, 0xa4, 0x6b, 0x4c, 0x33, 0x46, 0xaf, 0xc0, 0xd0, + 0xdb, 0x7e, 0xc8, 0x8e, 0x48, 0x71, 0x35, 0x91, 0x51, 0x25, 0x86, 0xde, 0xb8, 0x56, 0x63, 0xf0, + 0xfd, 0xbd, 0xf2, 0x70, 0xd5, 0x6f, 0xc8, 0xbf, 0x58, 0x15, 0x40, 0x3f, 0x60, 0xc1, 0x4c, 0xfa, + 0xc2, 0xab, 0x1a, 0x3d, 0xda, 0x7b, 0xa3, 0x6d, 0x51, 0xe9, 0xcc, 0x52, 0x2e, 0x3b, 0xdc, 0xa1, + 0x2a, 0xf4, 0x21, 0xba, 0x9e, 0x42, 0xf7, 0x2e, 0x11, 0x59, 0x76, 0x1f, 0x89, 0xd7, 0x13, 0x85, + 0xee, 0xef, 0x95, 0xc7, 0xf9, 0xce, 0xe8, 0xde, 0x95, 0xef, 0xab, 0x44, 0x01, 0xf4, 0xdd, 0x70, + 0x3c, 0x48, 0x6b, 0x50, 0x89, 0x14, 0xc2, 0x9f, 0xea, 0x65, 0x97, 0x4d, 0x0e, 0x38, 0xce, 0x62, + 0x88, 0xb3, 0xeb, 0xb1, 0x7f, 0xd5, 0x62, 0xfa, 0x6d, 0xd1, 0x2c, 0x12, 0xb6, 0x9b, 0x47, 0x91, + 0xdb, 0x7b, 0xc9, 0xb0, 0x1d, 0xdf, 0xb7, 0x67, 0xd3, 0x3f, 0xb2, 0x98, 0x67, 0xd3, 0x11, 0x3e, + 0xa3, 0x7a, 0x03, 0x86, 0x22, 0x99, 0x73, 0xbd, 0x43, 0x3a, 0x72, 0xad, 0x51, 0xcc, 0xbb, 0x4b, + 0x5d, 0x72, 0x54, 0x7a, 0x75, 0xc5, 0xc6, 0xfe, 0xfb, 0x7c, 0x04, 0x24, 0xe6, 0x08, 0x4c, 0x74, + 0x8b, 0xa6, 0x89, 0xae, 0xdc, 0xe5, 0x0b, 0x72, 0x4c, 0x75, 0x7f, 0xcf, 0x6c, 0x37, 0x53, 0xee, + 0xbd, 0xdb, 0x5d, 0xea, 0xec, 0x2f, 0x58, 0x00, 0x71, 0xac, 0xfb, 0x1e, 0xb2, 0x6a, 0xbe, 0x44, + 0xaf, 0x35, 0x7e, 0xe4, 0xd7, 0xfd, 0xa6, 0x30, 0x50, 0x9c, 0x8a, 0xad, 0x84, 0x1c, 0xbe, 0xaf, + 0xfd, 0xc6, 0x8a, 0x1a, 0x95, 0x65, 0x64, 0xcd, 0x62, 0x6c, 0xb7, 0x36, 0xa2, 0x6a, 0x7e, 0xd9, + 0x82, 0x63, 0x59, 0x3e, 0xf9, 0xf4, 0x92, 0xcc, 0xd5, 0x9c, 0xca, 0xdd, 0x51, 0x8d, 0xe6, 0x0d, + 0x01, 0xc7, 0x8a, 0xa2, 0xe7, 0x74, 0xa5, 0x07, 0x0b, 0x32, 0x7f, 0x0d, 0x46, 0xab, 0x01, 0xd1, + 0xe4, 0x8b, 0xd7, 0x78, 0xb4, 0x16, 0xde, 0x9e, 0x67, 0x0e, 0x1c, 0xa9, 0xc5, 0xfe, 0x4a, 0x01, + 0x8e, 0x71, 0xa7, 0x9d, 0xb9, 0x1d, 0xdf, 0x6d, 0x54, 0xfd, 0x86, 0x78, 0x49, 0xf9, 0x26, 0x8c, + 0xb4, 0x34, 0xdd, 0x74, 0xa7, 0x80, 0xc9, 0xba, 0x0e, 0x3b, 0xd6, 0xa6, 0xe9, 0x50, 0x6c, 0xf0, + 0x42, 0x0d, 0x18, 0x21, 0x3b, 0x6e, 0x5d, 0x79, 0x7e, 0x14, 0x0e, 0x7c, 0x48, 0xab, 0x5a, 0x96, + 0x34, 0x3e, 0xd8, 0xe0, 0xda, 0xb3, 0xab, 0xad, 0x26, 0xa2, 0xf5, 0x75, 0xf1, 0xf6, 0xf8, 0x51, + 0x0b, 0x1e, 0xca, 0x09, 0xaf, 0x4c, 0xab, 0xbb, 0xcd, 0xdc, 0xa3, 0xc4, 0xb4, 0x55, 0xd5, 0x71, + 0xa7, 0x29, 0x2c, 0xb0, 0xe8, 0xa3, 0x00, 0xdc, 0xe9, 0x89, 0x78, 0xf5, 0xae, 0x71, 0x68, 0x8d, + 0x10, 0x9a, 0x5a, 0x34, 0x44, 0x59, 0x1e, 0x6b, 0xbc, 0xec, 0x2f, 0xf7, 0x41, 0x3f, 0x73, 0xb2, + 0x41, 0x55, 0x18, 0xdc, 0xe4, 0xc9, 0xba, 0x3a, 0x8e, 0x1b, 0xa5, 0x95, 0xf9, 0xbf, 0xe2, 0x71, + 0xd3, 0xa0, 0x58, 0xb2, 0x41, 0x2b, 0x30, 0xc5, 0x73, 0xa6, 0x35, 0x17, 0x49, 0xd3, 0xd9, 0x95, + 0x6a, 0x5f, 0x9e, 0x06, 0x5c, 0xa9, 0xbf, 0x2b, 0x69, 0x12, 0x9c, 0x55, 0x0e, 0xbd, 0x06, 0x63, + 0xf4, 0x1a, 0xee, 0xb7, 0x23, 0xc9, 0x89, 0x67, 0x4b, 0x53, 0x37, 0x93, 0x35, 0x03, 0x8b, 0x13, + 0xd4, 0xe8, 0x15, 0x18, 0x6d, 0xa5, 0x14, 0xdc, 0xfd, 0xb1, 0x26, 0xc8, 0x54, 0x6a, 0x9b, 0xb4, + 0xcc, 0x2d, 0xbf, 0xcd, 0x1e, 0x21, 0xac, 0x6d, 0x06, 0x24, 0xdc, 0xf4, 0x9b, 0x0d, 0x26, 0x01, + 0xf7, 0x6b, 0x6e, 0xf9, 0x09, 0x3c, 0x4e, 0x95, 0xa0, 0x5c, 0xd6, 0x1d, 0xb7, 0xd9, 0x0e, 0x48, + 0xcc, 0x65, 0xc0, 0xe4, 0xb2, 0x9c, 0xc0, 0xe3, 0x54, 0x89, 0xee, 0x9a, 0xfb, 0xc1, 0xc3, 0xd1, + 0xdc, 0xdb, 0x7f, 0xab, 0x00, 0xc6, 0xd0, 0x7e, 0x07, 0x67, 0x71, 0x7b, 0x15, 0xfa, 0x36, 0x82, + 0x56, 0x5d, 0x38, 0x94, 0x65, 0x7e, 0x59, 0x9c, 0xc2, 0x99, 0x7f, 0x19, 0xfd, 0x8f, 0x59, 0x29, + 0xba, 0xc6, 0x8f, 0x57, 0x03, 0x9f, 0x1e, 0x72, 0x32, 0x9e, 0x9f, 0x7a, 0xfd, 0x32, 0x28, 0xa3, + 0x1c, 0x74, 0x88, 0x7c, 0x2b, 0xde, 0x07, 0x70, 0x0e, 0x86, 0xef, 0x55, 0x4d, 0x84, 0x1b, 0x91, + 0x5c, 0xd0, 0x45, 0x18, 0x16, 0x89, 0xb5, 0xd8, 0x23, 0x0d, 0xbe, 0x98, 0x98, 0xaf, 0xd8, 0x62, + 0x0c, 0xc6, 0x3a, 0x8d, 0xfd, 0x83, 0x05, 0x98, 0xca, 0x78, 0x65, 0xc7, 0x8f, 0x91, 0x0d, 0x37, + 0x8c, 0x54, 0x96, 0x68, 0xed, 0x18, 0xe1, 0x70, 0xac, 0x28, 0xe8, 0x5e, 0xc5, 0x0f, 0xaa, 0xe4, + 0xe1, 0x24, 0x5e, 0xb1, 0x08, 0xec, 0x01, 0xf3, 0x2d, 0x9f, 0x85, 0xbe, 0x76, 0x48, 0x64, 0xcc, + 0x6a, 0x75, 0x6c, 0x33, 0xb3, 0x36, 0xc3, 0xd0, 0x2b, 0xe0, 0x86, 0xb2, 0x10, 0x6b, 0x57, 0x40, + 0x6e, 0x23, 0xe6, 0x38, 0xda, 0xb8, 0x88, 0x78, 0x8e, 0x17, 0x89, 0x8b, 0x62, 0x1c, 0x7c, 0x95, + 0x41, 0xb1, 0xc0, 0xda, 0x5f, 0x2a, 0xc2, 0xc9, 0xdc, 0x77, 0xb7, 0xb4, 0xe9, 0xdb, 0xbe, 0xe7, + 0x46, 0xbe, 0x72, 0xc2, 0xe3, 0x01, 0x57, 0x49, 0x6b, 0x73, 0x45, 0xc0, 0xb1, 0xa2, 0x40, 0xe7, + 0xa0, 0x9f, 0x29, 0xc5, 0x53, 0xf9, 0xb2, 0xe7, 0x17, 0x79, 0x04, 0x3e, 0x8e, 0xd6, 0x4e, 0xf5, + 0x62, 0xc7, 0x53, 0xfd, 0x51, 0x2a, 0xc1, 0xf8, 0xcd, 0xe4, 0x81, 0x42, 0x9b, 0xeb, 0xfb, 0x4d, + 0xcc, 0x90, 0xe8, 0x71, 0xd1, 0x5f, 0x09, 0xaf, 0x33, 0xec, 0x34, 0xfc, 0x50, 0xeb, 0xb4, 0x27, + 0x61, 0x70, 0x8b, 0xec, 0x06, 0xae, 0xb7, 0x91, 0xf4, 0x46, 0xbc, 0xc2, 0xc1, 0x58, 0xe2, 0xcd, + 0xd4, 0xad, 0x83, 0x87, 0x91, 0xba, 0x55, 0x9f, 0x01, 0x43, 0x5d, 0xc5, 0x93, 0x1f, 0x2a, 0xc2, + 0x38, 0x9e, 0x5f, 0x7c, 0x6f, 0x20, 0xae, 0xa7, 0x07, 0xe2, 0x30, 0x32, 0x9c, 0x1e, 0x6c, 0x34, + 0x7e, 0xc9, 0x82, 0x71, 0x96, 0xde, 0x4b, 0x04, 0xcd, 0x70, 0x7d, 0xef, 0x08, 0xae, 0x02, 0x8f, + 0x42, 0x7f, 0x40, 0x2b, 0x4d, 0x26, 0xca, 0x66, 0x2d, 0xc1, 0x1c, 0x87, 0x4e, 0x41, 0x1f, 0x6b, + 0x02, 0x1d, 0xbc, 0x11, 0xbe, 0x05, 0x2f, 0x3a, 0x91, 0x83, 0x19, 0x94, 0xc5, 0x9f, 0xc3, 0xa4, + 0xd5, 0x74, 0x79, 0xa3, 0x63, 0x97, 0x85, 0x77, 0x47, 0x44, 0x8e, 0xcc, 0xa6, 0xbd, 0xb3, 0xf8, + 0x73, 0xd9, 0x2c, 0x3b, 0x5f, 0xb3, 0xff, 0xa2, 0x00, 0x67, 0x32, 0xcb, 0xf5, 0x1c, 0x7f, 0xae, + 0x73, 0xe9, 0x07, 0x99, 0x86, 0xa9, 0x78, 0x84, 0xbe, 0xde, 0x7d, 0xbd, 0x4a, 0xff, 0xfd, 0x3d, + 0x84, 0x85, 0xcb, 0xec, 0xb2, 0x77, 0x49, 0x58, 0xb8, 0xcc, 0xb6, 0xe5, 0xa8, 0x09, 0xfe, 0xa6, + 0x90, 0xf3, 0x2d, 0x4c, 0x61, 0x70, 0x9e, 0xee, 0x33, 0x0c, 0x19, 0xca, 0x4b, 0x38, 0xdf, 0x63, + 0x38, 0x0c, 0x2b, 0x2c, 0x9a, 0x83, 0xf1, 0x6d, 0xd7, 0xa3, 0x9b, 0xcf, 0xae, 0x29, 0x8a, 0x2b, + 0x5b, 0xc6, 0x8a, 0x89, 0xc6, 0x49, 0x7a, 0xe4, 0x6a, 0x21, 0xe3, 0xf8, 0xd7, 0xbd, 0x72, 0xa0, + 0x55, 0x37, 0x6b, 0xba, 0x73, 0xa8, 0x5e, 0xcc, 0x08, 0x1f, 0xb7, 0xa2, 0xe9, 0x89, 0x8a, 0xbd, + 0xeb, 0x89, 0x46, 0xb2, 0x75, 0x44, 0x33, 0xaf, 0xc0, 0xe8, 0x7d, 0xdb, 0x46, 0xec, 0x6f, 0x14, + 0xe1, 0xe1, 0x0e, 0xcb, 0x9e, 0xef, 0xf5, 0xc6, 0x18, 0x68, 0x7b, 0x7d, 0x6a, 0x1c, 0xaa, 0x70, + 0x6c, 0xbd, 0xdd, 0x6c, 0xee, 0xb2, 0x47, 0x4d, 0xa4, 0x21, 0x29, 0x84, 0x4c, 0x29, 0x95, 0x23, + 0xc7, 0x96, 0x33, 0x68, 0x70, 0x66, 0x49, 0x7a, 0xc5, 0xa2, 0x27, 0xc9, 0xae, 0x62, 0x95, 0xb8, + 0x62, 0x61, 0x1d, 0x89, 0x4d, 0x5a, 0x74, 0x09, 0x26, 0x9d, 0x1d, 0xc7, 0xe5, 0x71, 0xf7, 0x25, + 0x03, 0x7e, 0xc7, 0x52, 0xba, 0xe8, 0xb9, 0x24, 0x01, 0x4e, 0x97, 0x41, 0xaf, 0x03, 0xf2, 0x6f, + 0xb1, 0x87, 0x12, 0x8d, 0x4b, 0xc4, 0x13, 0x56, 0x77, 0x36, 0x76, 0xc5, 0x78, 0x4b, 0xb8, 0x96, + 0xa2, 0xc0, 0x19, 0xa5, 0x12, 0x91, 0xd1, 0x06, 0xf2, 0x23, 0xa3, 0x75, 0xde, 0x17, 0xbb, 0x66, + 0x00, 0xbb, 0x08, 0xa3, 0x07, 0x74, 0xff, 0xb5, 0xff, 0x8d, 0x05, 0x4a, 0x41, 0x6c, 0x06, 0x1f, + 0x7e, 0x85, 0xf9, 0x27, 0x73, 0xd5, 0xb6, 0x16, 0xae, 0xe9, 0xb8, 0xe6, 0x9f, 0x1c, 0x23, 0xb1, + 0x49, 0xcb, 0xe7, 0x90, 0xe6, 0x57, 0x6c, 0xdc, 0x0a, 0x44, 0x6c, 0x44, 0x45, 0x81, 0x3e, 0x06, + 0x83, 0x0d, 0x77, 0xc7, 0x0d, 0x85, 0x72, 0xec, 0xc0, 0xc6, 0xb8, 0x78, 0xeb, 0x5c, 0xe4, 0x6c, + 0xb0, 0xe4, 0x67, 0xff, 0x50, 0x21, 0xee, 0x93, 0x37, 0xda, 0x7e, 0xe4, 0x1c, 0xc1, 0x49, 0x7e, + 0xc9, 0x38, 0xc9, 0x1f, 0xcf, 0x1e, 0x68, 0xad, 0x49, 0xb9, 0x27, 0xf8, 0xb5, 0xc4, 0x09, 0xfe, + 0x44, 0x77, 0x56, 0x9d, 0x4f, 0xee, 0x7f, 0x60, 0xc1, 0xa4, 0x41, 0x7f, 0x04, 0x07, 0xc8, 0xb2, + 0x79, 0x80, 0x3c, 0xd2, 0xf5, 0x1b, 0x72, 0x0e, 0x8e, 0xef, 0x2f, 0x26, 0xda, 0xce, 0x0e, 0x8c, + 0xb7, 0xa1, 0x6f, 0xd3, 0x09, 0x1a, 0x9d, 0xd2, 0xe2, 0xa4, 0x0a, 0xcd, 0x5e, 0x76, 0x02, 0xe1, + 0xa9, 0xf0, 0x8c, 0xec, 0x75, 0x0a, 0xea, 0xea, 0xa5, 0xc0, 0xaa, 0x42, 0x2f, 0xc1, 0x40, 0x58, + 0xf7, 0x5b, 0xea, 0xcd, 0x14, 0xcb, 0xbc, 0x5a, 0x63, 0x90, 0xfd, 0xbd, 0x32, 0x32, 0xab, 0xa3, + 0x60, 0x2c, 0xe8, 0xd1, 0x9b, 0x30, 0xca, 0x7e, 0x29, 0xb7, 0xc1, 0x62, 0xbe, 0x06, 0xa3, 0xa6, + 0x13, 0x72, 0x9f, 0x5a, 0x03, 0x84, 0x4d, 0x56, 0x33, 0x1b, 0x50, 0x52, 0x9f, 0xf5, 0x40, 0xad, + 0xdd, 0xff, 0xaa, 0x08, 0x53, 0x19, 0x73, 0x0e, 0x85, 0xc6, 0x48, 0x5c, 0xec, 0x71, 0xaa, 0xbe, + 0xc3, 0xb1, 0x08, 0xd9, 0x05, 0xaa, 0x21, 0xe6, 0x56, 0xcf, 0x95, 0x5e, 0x0f, 0x49, 0xb2, 0x52, + 0x0a, 0xea, 0x5e, 0x29, 0xad, 0xec, 0xc8, 0xba, 0x9a, 0x56, 0xa4, 0x5a, 0xfa, 0x40, 0xc7, 0xf4, + 0x37, 0xfa, 0xe0, 0x58, 0x56, 0xcc, 0x5a, 0xf4, 0x99, 0x44, 0x3a, 0xe7, 0x17, 0x3a, 0xf5, 0xb0, + 0x5e, 0x92, 0xe7, 0x78, 0x16, 0x71, 0x28, 0x67, 0xcd, 0x04, 0xcf, 0x5d, 0xbb, 0x59, 0xd4, 0xc9, + 0x22, 0xe0, 0x04, 0x3c, 0x0d, 0xb7, 0xdc, 0x3e, 0x3e, 0xd0, 0x73, 0x03, 0x44, 0xfe, 0xee, 0x30, + 0xe1, 0x92, 0x24, 0xc1, 0xdd, 0x5d, 0x92, 0x64, 0xcd, 0xa8, 0x02, 0x03, 0x75, 0xee, 0xeb, 0x52, + 0xec, 0xbe, 0x85, 0x71, 0x47, 0x17, 0xb5, 0x01, 0x0b, 0x07, 0x17, 0xc1, 0x60, 0xc6, 0x85, 0x61, + 0xad, 0x63, 0x1e, 0xe8, 0xe4, 0xd9, 0xa2, 0x07, 0x9f, 0xd6, 0x05, 0x0f, 0x74, 0x02, 0xfd, 0xa8, + 0x05, 0x89, 0x07, 0x2f, 0x4a, 0x29, 0x67, 0xe5, 0x2a, 0xe5, 0xce, 0x42, 0x5f, 0xe0, 0x37, 0x49, + 0x32, 0x11, 0x32, 0xf6, 0x9b, 0x04, 0x33, 0x0c, 0xa5, 0x88, 0x62, 0x55, 0xcb, 0x88, 0x7e, 0x8d, + 0x14, 0x17, 0xc4, 0x47, 0xa1, 0xbf, 0x49, 0x76, 0x48, 0x33, 0x99, 0xaf, 0xee, 0x2a, 0x05, 0x62, + 0x8e, 0xb3, 0x7f, 0xa9, 0x0f, 0x4e, 0x77, 0x0c, 0x47, 0x45, 0x2f, 0x63, 0x1b, 0x4e, 0x44, 0x6e, + 0x3b, 0xbb, 0xc9, 0xc4, 0x52, 0x97, 0x38, 0x18, 0x4b, 0x3c, 0x7b, 0xfe, 0xc9, 0xf3, 0x43, 0x24, + 0x54, 0x98, 0x22, 0x2d, 0x84, 0xc0, 0x9a, 0x2a, 0xb1, 0xe2, 0x61, 0xa8, 0xc4, 0x9e, 0x03, 0x08, + 0xc3, 0x26, 0x77, 0x0b, 0x6c, 0x88, 0x77, 0xa5, 0x71, 0x1e, 0x91, 0xda, 0x55, 0x81, 0xc1, 0x1a, + 0x15, 0x5a, 0x84, 0x89, 0x56, 0xe0, 0x47, 0x5c, 0x23, 0xbc, 0xc8, 0x3d, 0x67, 0xfb, 0xcd, 0x48, + 0x40, 0xd5, 0x04, 0x1e, 0xa7, 0x4a, 0xa0, 0x17, 0x61, 0x58, 0x44, 0x07, 0xaa, 0xfa, 0x7e, 0x53, + 0x28, 0xa1, 0x94, 0x33, 0x69, 0x2d, 0x46, 0x61, 0x9d, 0x4e, 0x2b, 0xc6, 0xd4, 0xcc, 0x83, 0x99, + 0xc5, 0xb8, 0xaa, 0x59, 0xa3, 0x4b, 0x84, 0xc2, 0x1e, 0xea, 0x29, 0x14, 0x76, 0xac, 0x96, 0x2b, + 0xf5, 0x6c, 0xf5, 0x84, 0xae, 0x8a, 0xac, 0xaf, 0xf6, 0xc1, 0x94, 0x98, 0x38, 0x0f, 0x7a, 0xba, + 0x5c, 0x4f, 0x4f, 0x97, 0xc3, 0x50, 0xdc, 0xbd, 0x37, 0x67, 0x8e, 0x7a, 0xce, 0xfc, 0xb0, 0x05, + 0xa6, 0xa4, 0x86, 0xfe, 0xd7, 0xdc, 0xcc, 0x7c, 0x2f, 0xe6, 0x4a, 0x7e, 0x71, 0x98, 0xe1, 0x77, + 0x96, 0xa3, 0xcf, 0xfe, 0xd7, 0x16, 0x3c, 0xd2, 0x95, 0x23, 0x5a, 0x82, 0x12, 0x13, 0x27, 0xb5, + 0x8b, 0xde, 0x13, 0xca, 0xb3, 0x5e, 0x22, 0x72, 0xa4, 0xdb, 0xb8, 0x24, 0x5a, 0x4a, 0xa5, 0x40, + 0x7c, 0x32, 0x23, 0x05, 0xe2, 0x71, 0xa3, 0x7b, 0xee, 0x33, 0x07, 0xe2, 0x17, 0xe9, 0x89, 0x63, + 0xbc, 0x6a, 0x43, 0x1f, 0x30, 0x94, 0x8e, 0x76, 0x42, 0xe9, 0x88, 0x4c, 0x6a, 0xed, 0x0c, 0xf9, + 0x08, 0x4c, 0xb0, 0xb0, 0x81, 0xec, 0x9d, 0x87, 0x78, 0x6f, 0x57, 0x88, 0x7d, 0xb9, 0xaf, 0x26, + 0x70, 0x38, 0x45, 0x6d, 0xff, 0x59, 0x11, 0x06, 0xf8, 0xf2, 0x3b, 0x82, 0xeb, 0xe5, 0xd3, 0x50, + 0x72, 0xb7, 0xb7, 0xdb, 0x3c, 0xab, 0x5d, 0x7f, 0xec, 0x19, 0x5c, 0x91, 0x40, 0x1c, 0xe3, 0xd1, + 0xb2, 0xd0, 0x77, 0x77, 0x88, 0x4c, 0xcc, 0x1b, 0x3e, 0xbb, 0xe8, 0x44, 0x0e, 0x97, 0x95, 0xd4, + 0x39, 0x1b, 0x6b, 0xc6, 0xd1, 0x27, 0x01, 0xc2, 0x28, 0x70, 0xbd, 0x0d, 0x0a, 0x13, 0xc1, 0xdd, + 0x9f, 0xea, 0xc0, 0xad, 0xa6, 0x88, 0x39, 0xcf, 0x78, 0xcf, 0x51, 0x08, 0xac, 0x71, 0x44, 0xb3, + 0xc6, 0x49, 0x3f, 0x93, 0x18, 0x3b, 0xe0, 0x5c, 0xe3, 0x31, 0x9b, 0xf9, 0x20, 0x94, 0x14, 0xf3, + 0x6e, 0xda, 0xaf, 0x11, 0x5d, 0x2c, 0xfa, 0x30, 0x8c, 0x27, 0xda, 0x76, 0x20, 0xe5, 0xd9, 0x2f, + 0x5b, 0x30, 0xce, 0x1b, 0xb3, 0xe4, 0xed, 0x88, 0xd3, 0xe0, 0x2e, 0x1c, 0x6b, 0x66, 0xec, 0xca, + 0x62, 0xf8, 0x7b, 0xdf, 0xc5, 0x95, 0xb2, 0x2c, 0x0b, 0x8b, 0x33, 0xeb, 0x40, 0xe7, 0xe9, 0x8a, + 0xa3, 0xbb, 0xae, 0xd3, 0x14, 0xf1, 0x0d, 0x46, 0xf8, 0x6a, 0xe3, 0x30, 0xac, 0xb0, 0xf6, 0x1f, + 0x5a, 0x30, 0xc9, 0x5b, 0x7e, 0x85, 0xec, 0xaa, 0xbd, 0xe9, 0x5b, 0xd9, 0x76, 0x91, 0x4f, 0xb5, + 0x90, 0x93, 0x4f, 0x55, 0xff, 0xb4, 0x62, 0xc7, 0x4f, 0xfb, 0x8a, 0x05, 0x62, 0x86, 0x1c, 0x81, + 0x3e, 0xe3, 0xbb, 0x4c, 0x7d, 0xc6, 0x4c, 0xfe, 0x22, 0xc8, 0x51, 0x64, 0xfc, 0xb5, 0x05, 0x13, + 0x9c, 0x20, 0xb6, 0xd5, 0x7f, 0x4b, 0xc7, 0x61, 0xde, 0xfc, 0xa2, 0x4c, 0xe7, 0xcb, 0x2b, 0x64, + 0x77, 0xcd, 0xaf, 0x3a, 0xd1, 0x66, 0xf6, 0x47, 0x19, 0x83, 0xd5, 0xd7, 0x71, 0xb0, 0x1a, 0x72, + 0x01, 0x19, 0xe9, 0xc6, 0xba, 0x04, 0x08, 0x38, 0x68, 0xba, 0x31, 0xfb, 0xcf, 0x2d, 0x40, 0xbc, + 0x1a, 0x43, 0x70, 0xa3, 0xe2, 0x10, 0x83, 0x6a, 0x07, 0x5d, 0xbc, 0x35, 0x29, 0x0c, 0xd6, 0xa8, + 0x0e, 0xa5, 0x7b, 0x12, 0x0e, 0x17, 0xc5, 0xee, 0x0e, 0x17, 0x07, 0xe8, 0xd1, 0x7f, 0x36, 0x00, + 0xc9, 0x97, 0x7d, 0xe8, 0x06, 0x8c, 0xd4, 0x9d, 0x96, 0x73, 0xcb, 0x6d, 0xba, 0x91, 0x4b, 0xc2, + 0x4e, 0xde, 0x58, 0x0b, 0x1a, 0x9d, 0x30, 0x91, 0x6b, 0x10, 0x6c, 0xf0, 0x41, 0xb3, 0x00, 0xad, + 0xc0, 0xdd, 0x71, 0x9b, 0x64, 0x83, 0xa9, 0x5d, 0x58, 0x44, 0x15, 0xee, 0x1a, 0x26, 0xa1, 0x58, + 0xa3, 0xc8, 0x08, 0xa3, 0x50, 0x7c, 0xc0, 0x61, 0x14, 0xe0, 0xc8, 0xc2, 0x28, 0xf4, 0x1d, 0x28, + 0x8c, 0xc2, 0xd0, 0x81, 0xc3, 0x28, 0xf4, 0xf7, 0x14, 0x46, 0x01, 0xc3, 0x09, 0x29, 0x7b, 0xd2, + 0xff, 0xcb, 0x6e, 0x93, 0x88, 0x0b, 0x07, 0x0f, 0x03, 0x33, 0x73, 0x6f, 0xaf, 0x7c, 0x02, 0x67, + 0x52, 0xe0, 0x9c, 0x92, 0xe8, 0xa3, 0x30, 0xed, 0x34, 0x9b, 0xfe, 0x6d, 0x35, 0xa8, 0x4b, 0x61, + 0xdd, 0x69, 0x72, 0x13, 0xc8, 0x20, 0xe3, 0x7a, 0xea, 0xde, 0x5e, 0x79, 0x7a, 0x2e, 0x87, 0x06, + 0xe7, 0x96, 0x46, 0xaf, 0x42, 0xa9, 0x15, 0xf8, 0xf5, 0x15, 0xed, 0xf9, 0xf1, 0x19, 0xda, 0x81, + 0x55, 0x09, 0xdc, 0xdf, 0x2b, 0x8f, 0xaa, 0x3f, 0xec, 0xc0, 0x8f, 0x0b, 0x64, 0xc4, 0x45, 0x18, + 0x3e, 0xd4, 0xb8, 0x08, 0x5b, 0x30, 0x55, 0x23, 0x81, 0xeb, 0x34, 0xdd, 0xbb, 0x54, 0x5e, 0x96, + 0xfb, 0xd3, 0x1a, 0x94, 0x82, 0xc4, 0x8e, 0xdc, 0x53, 0xb4, 0x60, 0x2d, 0xe3, 0x93, 0xdc, 0x81, + 0x63, 0x46, 0xf6, 0x7f, 0xb5, 0x60, 0x50, 0xbc, 0xe4, 0x3b, 0x02, 0xa9, 0x71, 0xce, 0x30, 0x4a, + 0x94, 0xb3, 0x3b, 0x8c, 0x35, 0x26, 0xd7, 0x1c, 0x51, 0x49, 0x98, 0x23, 0x1e, 0xe9, 0xc4, 0xa4, + 0xb3, 0x21, 0xe2, 0xff, 0x2d, 0x52, 0xe9, 0xdd, 0x78, 0x53, 0xfe, 0xe0, 0xbb, 0x60, 0x15, 0x06, + 0x43, 0xf1, 0xa6, 0xb9, 0x90, 0xff, 0x1a, 0x24, 0x39, 0x88, 0xb1, 0x17, 0x9d, 0x78, 0xc5, 0x2c, + 0x99, 0x64, 0x3e, 0x96, 0x2e, 0x3e, 0xc0, 0xc7, 0xd2, 0xdd, 0x5e, 0xdd, 0xf7, 0x1d, 0xc6, 0xab, + 0x7b, 0xfb, 0xeb, 0xec, 0xe4, 0xd4, 0xe1, 0x47, 0x20, 0x54, 0x5d, 0x32, 0xcf, 0x58, 0xbb, 0xc3, + 0xcc, 0x12, 0x8d, 0xca, 0x11, 0xae, 0x7e, 0xd1, 0x82, 0xd3, 0x19, 0x5f, 0xa5, 0x49, 0x5a, 0xcf, + 0xc0, 0x90, 0xd3, 0x6e, 0xb8, 0x6a, 0x2d, 0x6b, 0xa6, 0xc9, 0x39, 0x01, 0xc7, 0x8a, 0x02, 0x2d, + 0xc0, 0x24, 0xb9, 0xd3, 0x72, 0xb9, 0x21, 0x57, 0x77, 0x3e, 0x2e, 0xf2, 0xe7, 0x9f, 0x4b, 0x49, + 0x24, 0x4e, 0xd3, 0xab, 0x00, 0x51, 0xc5, 0xdc, 0x00, 0x51, 0x3f, 0x6f, 0xc1, 0xb0, 0x7a, 0xd5, + 0xfb, 0xc0, 0x7b, 0xfb, 0x23, 0x66, 0x6f, 0x3f, 0xdc, 0xa1, 0xb7, 0x73, 0xba, 0xf9, 0xf7, 0x0b, + 0xaa, 0xbd, 0x55, 0x3f, 0x88, 0x7a, 0x90, 0xe0, 0xee, 0xff, 0xe1, 0xc4, 0x45, 0x18, 0x76, 0x5a, + 0x2d, 0x89, 0x90, 0x1e, 0x70, 0x2c, 0xf6, 0x7b, 0x0c, 0xc6, 0x3a, 0x8d, 0x7a, 0xc7, 0x51, 0xcc, + 0x7d, 0xc7, 0xd1, 0x00, 0x88, 0x9c, 0x60, 0x83, 0x44, 0x14, 0x26, 0x1c, 0x76, 0xf3, 0xf7, 0x9b, + 0x76, 0xe4, 0x36, 0x67, 0x5d, 0x2f, 0x0a, 0xa3, 0x60, 0xb6, 0xe2, 0x45, 0xd7, 0x02, 0x7e, 0x85, + 0xd4, 0x42, 0xac, 0x29, 0x5e, 0x58, 0xe3, 0x2b, 0x23, 0x58, 0xb0, 0x3a, 0xfa, 0x4d, 0x57, 0x8a, + 0x55, 0x01, 0xc7, 0x8a, 0xc2, 0xfe, 0x20, 0x3b, 0x7d, 0x58, 0x9f, 0x1e, 0x2c, 0xbc, 0xd8, 0x4f, + 0x8e, 0xa8, 0xd1, 0x60, 0x46, 0xd1, 0x45, 0x3d, 0x88, 0x59, 0xe7, 0xcd, 0x9e, 0x56, 0xac, 0xbf, + 0x88, 0x8c, 0x23, 0x9d, 0xa1, 0x8f, 0xa7, 0xdc, 0x63, 0x9e, 0xed, 0x72, 0x6a, 0x1c, 0xc0, 0x21, + 0x86, 0x25, 0x82, 0x62, 0x69, 0x72, 0x2a, 0x55, 0xb1, 0x2e, 0xb4, 0x44, 0x50, 0x02, 0x81, 0x63, + 0x1a, 0x2a, 0x4c, 0xa9, 0x3f, 0xe1, 0x34, 0x8a, 0x83, 0x11, 0x2b, 0xea, 0x10, 0x6b, 0x14, 0xe8, + 0x82, 0x50, 0x28, 0x70, 0xbb, 0xc0, 0xc3, 0x09, 0x85, 0x82, 0xec, 0x2e, 0x4d, 0x0b, 0x74, 0x11, + 0x86, 0xc9, 0x9d, 0x88, 0x04, 0x9e, 0xd3, 0xa4, 0x35, 0xf4, 0xc7, 0xf1, 0x33, 0x97, 0x62, 0x30, + 0xd6, 0x69, 0xd0, 0x1a, 0x8c, 0x87, 0x5c, 0xcf, 0xa6, 0xa2, 0xd4, 0x73, 0x7d, 0xe5, 0x53, 0xea, + 0x3d, 0xb5, 0x89, 0xde, 0x67, 0x20, 0xbe, 0x3b, 0xc9, 0x28, 0x13, 0x49, 0x16, 0xe8, 0x35, 0x18, + 0x6b, 0xfa, 0x4e, 0x63, 0xde, 0x69, 0x3a, 0x5e, 0x9d, 0xf5, 0xcf, 0x90, 0x99, 0x0f, 0xfb, 0xaa, + 0x81, 0xc5, 0x09, 0x6a, 0x2a, 0xbc, 0xe9, 0x10, 0x11, 0xa6, 0xcd, 0xf1, 0x36, 0x48, 0x28, 0xd2, + 0xd2, 0x33, 0xe1, 0xed, 0x6a, 0x0e, 0x0d, 0xce, 0x2d, 0x8d, 0x5e, 0x82, 0x11, 0xf9, 0xf9, 0x5a, + 0x50, 0x96, 0xf8, 0x49, 0x8c, 0x86, 0xc3, 0x06, 0x25, 0x0a, 0xe1, 0xb8, 0xfc, 0xbf, 0x16, 0x38, + 0xeb, 0xeb, 0x6e, 0x5d, 0x44, 0x2a, 0xe0, 0xcf, 0x87, 0x3f, 0x2c, 0xdf, 0x2a, 0x2e, 0x65, 0x11, + 0xed, 0xef, 0x95, 0x4f, 0x89, 0x5e, 0xcb, 0xc4, 0xe3, 0x6c, 0xde, 0x68, 0x05, 0xa6, 0x36, 0x89, + 0xd3, 0x8c, 0x36, 0x17, 0x36, 0x49, 0x7d, 0x4b, 0x2e, 0x38, 0x16, 0xe6, 0x45, 0x7b, 0x3a, 0x72, + 0x39, 0x4d, 0x82, 0xb3, 0xca, 0xa1, 0xb7, 0x60, 0xba, 0xd5, 0xbe, 0xd5, 0x74, 0xc3, 0xcd, 0x55, + 0x3f, 0x62, 0x4e, 0x48, 0x73, 0x8d, 0x46, 0x40, 0x42, 0xfe, 0xba, 0x94, 0x1d, 0xbd, 0x32, 0x90, + 0x4e, 0x35, 0x87, 0x0e, 0xe7, 0x72, 0x40, 0x77, 0xe1, 0x78, 0x62, 0x22, 0x88, 0x88, 0x18, 0x63, + 0xf9, 0x39, 0x6a, 0x6a, 0x59, 0x05, 0x44, 0x70, 0x99, 0x2c, 0x14, 0xce, 0xae, 0x02, 0xbd, 0x0c, + 0xe0, 0xb6, 0x96, 0x9d, 0x6d, 0xb7, 0x49, 0xaf, 0x8a, 0x53, 0x6c, 0x8e, 0xd0, 0x6b, 0x03, 0x54, + 0xaa, 0x12, 0x4a, 0xf7, 0x66, 0xf1, 0x6f, 0x17, 0x6b, 0xd4, 0xe8, 0x2a, 0x8c, 0x89, 0x7f, 0xbb, + 0x62, 0x48, 0x79, 0x60, 0x96, 0xc7, 0x58, 0x54, 0xad, 0xaa, 0x8e, 0xd9, 0x4f, 0x41, 0x70, 0xa2, + 0x2c, 0xda, 0x80, 0xd3, 0x32, 0xd3, 0xa0, 0x3e, 0x3f, 0xe5, 0x18, 0x84, 0x2c, 0x31, 0xcc, 0x10, + 0x7f, 0x95, 0x32, 0xd7, 0x89, 0x10, 0x77, 0xe6, 0x43, 0xcf, 0x75, 0x7d, 0x9a, 0xf3, 0x37, 0xc7, + 0xc7, 0xe3, 0x88, 0x83, 0x57, 0x93, 0x48, 0x9c, 0xa6, 0x47, 0x3e, 0x1c, 0x77, 0xbd, 0xac, 0x59, + 0x7d, 0x82, 0x31, 0xfa, 0x10, 0x7f, 0x6e, 0xdd, 0x79, 0x46, 0x67, 0xe2, 0x71, 0x36, 0xdf, 0x77, + 0xe6, 0xf7, 0xf7, 0x07, 0x16, 0x2d, 0xad, 0x49, 0xe7, 0xe8, 0x53, 0x30, 0xa2, 0x7f, 0x94, 0x90, + 0x34, 0xce, 0x65, 0x0b, 0xaf, 0xda, 0x9e, 0xc0, 0x65, 0x7b, 0xb5, 0xee, 0x75, 0x1c, 0x36, 0x38, + 0xa2, 0x7a, 0x46, 0x6c, 0x83, 0x0b, 0xbd, 0x49, 0x32, 0xbd, 0xbb, 0xbd, 0x11, 0xc8, 0x9e, 0xee, + 0xe8, 0x2a, 0x0c, 0xd5, 0x9b, 0x2e, 0xf1, 0xa2, 0x4a, 0xb5, 0x53, 0xf4, 0xc6, 0x05, 0x41, 0x23, + 0xd6, 0x8f, 0xc8, 0xf1, 0xc2, 0x61, 0x58, 0x71, 0xb0, 0x5f, 0x82, 0xe1, 0x5a, 0x93, 0x90, 0x16, + 0x7f, 0xbe, 0x83, 0x9e, 0x64, 0xb7, 0x09, 0x26, 0x0f, 0x5a, 0x4c, 0x1e, 0xd4, 0x2f, 0x0a, 0x4c, + 0x12, 0x94, 0x78, 0xfb, 0xb7, 0x0a, 0x50, 0xee, 0x92, 0x6a, 0x28, 0x61, 0xc0, 0xb2, 0x7a, 0x32, + 0x60, 0xcd, 0xc1, 0x78, 0xfc, 0x4f, 0xd7, 0x8d, 0x29, 0x1f, 0xd8, 0x1b, 0x26, 0x1a, 0x27, 0xe9, + 0x7b, 0x7e, 0xce, 0xa0, 0xdb, 0xc0, 0xfa, 0xba, 0x3e, 0xc8, 0x31, 0x6c, 0xdf, 0xfd, 0xbd, 0x5f, + 0x98, 0x73, 0xed, 0x98, 0xf6, 0xd7, 0x0b, 0x70, 0x5c, 0x75, 0xe1, 0x77, 0x6e, 0xc7, 0x5d, 0x4f, + 0x77, 0xdc, 0x21, 0x58, 0x81, 0xed, 0x6b, 0x30, 0xc0, 0x03, 0x59, 0xf6, 0x20, 0xa8, 0x3f, 0x6a, + 0xc6, 0xd7, 0x56, 0xb2, 0xa1, 0x11, 0x63, 0xfb, 0x07, 0x2c, 0x18, 0x4f, 0xbc, 0x8b, 0x43, 0x58, + 0x7b, 0x3c, 0x7d, 0x3f, 0xc2, 0x74, 0x96, 0x98, 0x7e, 0x16, 0xfa, 0x36, 0xfd, 0x30, 0x4a, 0xba, + 0x88, 0x5c, 0xf6, 0xc3, 0x08, 0x33, 0x8c, 0xfd, 0x47, 0x16, 0xf4, 0xaf, 0x39, 0xae, 0x17, 0x49, + 0x73, 0x82, 0x95, 0x63, 0x4e, 0xe8, 0xe5, 0xbb, 0xd0, 0x8b, 0x30, 0x40, 0xd6, 0xd7, 0x49, 0x3d, + 0x12, 0xa3, 0x2a, 0x83, 0x28, 0x0c, 0x2c, 0x31, 0x28, 0x95, 0x1c, 0x59, 0x65, 0xfc, 0x2f, 0x16, + 0xc4, 0xe8, 0x26, 0x94, 0x22, 0x77, 0x9b, 0xcc, 0x35, 0x1a, 0xc2, 0xc8, 0x7e, 0x1f, 0x91, 0x3f, + 0xd6, 0x24, 0x03, 0x1c, 0xf3, 0xb2, 0xbf, 0x54, 0x00, 0x88, 0x23, 0x80, 0x75, 0xfb, 0xc4, 0xf9, + 0x94, 0xf9, 0xf5, 0x5c, 0x86, 0xf9, 0x15, 0xc5, 0x0c, 0x33, 0x6c, 0xaf, 0xaa, 0x9b, 0x8a, 0x3d, + 0x75, 0x53, 0xdf, 0x41, 0xba, 0x69, 0x01, 0x26, 0xe3, 0x08, 0x66, 0x66, 0x00, 0x47, 0x76, 0xe8, + 0xae, 0x25, 0x91, 0x38, 0x4d, 0x6f, 0x13, 0x38, 0xab, 0x02, 0x39, 0x89, 0xb3, 0x90, 0x79, 0x90, + 0xeb, 0xe6, 0xec, 0x2e, 0xfd, 0x14, 0xdb, 0x97, 0x0b, 0xb9, 0xf6, 0xe5, 0x9f, 0xb0, 0xe0, 0x58, + 0xb2, 0x1e, 0xf6, 0xdc, 0xfa, 0x0b, 0x16, 0x1c, 0x8f, 0xd3, 0x78, 0xa4, 0x6d, 0xfa, 0x2f, 0x74, + 0x0c, 0x4e, 0x95, 0xd3, 0xe2, 0x38, 0x5a, 0xc7, 0x4a, 0x16, 0x6b, 0x9c, 0x5d, 0xa3, 0xfd, 0x5f, + 0xfa, 0x60, 0x3a, 0x2f, 0xaa, 0x15, 0x7b, 0x60, 0xe2, 0xdc, 0xa9, 0x6d, 0x91, 0xdb, 0xc2, 0x8d, + 0x3f, 0x7e, 0x60, 0xc2, 0xc1, 0x58, 0xe2, 0x93, 0x99, 0x5b, 0x0a, 0x3d, 0x66, 0x6e, 0xd9, 0x84, + 0xc9, 0xdb, 0x9b, 0xc4, 0xbb, 0xee, 0x85, 0x4e, 0xe4, 0x86, 0xeb, 0x2e, 0xb3, 0x48, 0xf3, 0x79, + 0x23, 0xd3, 0x67, 0x4f, 0xde, 0x4c, 0x12, 0xec, 0xef, 0x95, 0x4f, 0x1b, 0x80, 0xb8, 0xc9, 0x7c, + 0x23, 0xc1, 0x69, 0xa6, 0xe9, 0xc4, 0x37, 0x7d, 0x0f, 0x38, 0xf1, 0xcd, 0xb6, 0x2b, 0xfc, 0x58, + 0xe4, 0xeb, 0x01, 0x76, 0xd7, 0x5c, 0x51, 0x50, 0xac, 0x51, 0xa0, 0x4f, 0x00, 0xd2, 0x93, 0x8b, + 0x19, 0x41, 0x45, 0x9f, 0xbd, 0xb7, 0x57, 0x46, 0xab, 0x29, 0xec, 0xfe, 0x5e, 0x79, 0x8a, 0x42, + 0x2b, 0x1e, 0xbd, 0xb3, 0xc6, 0x91, 0xd8, 0x32, 0x18, 0xa1, 0x9b, 0x30, 0x41, 0xa1, 0x6c, 0x45, + 0xc9, 0x88, 0xa5, 0xfc, 0x9e, 0xf9, 0xf4, 0xbd, 0xbd, 0xf2, 0xc4, 0x6a, 0x02, 0x97, 0xc7, 0x3a, + 0xc5, 0x24, 0x23, 0xff, 0xcd, 0x50, 0xaf, 0xf9, 0x6f, 0xec, 0x2f, 0x58, 0x70, 0x32, 0x37, 0x99, + 0x3f, 0x3a, 0x0f, 0x43, 0x4e, 0xcb, 0xe5, 0x86, 0x0f, 0x71, 0xd4, 0x30, 0x05, 0x5b, 0xb5, 0xc2, + 0xcd, 0x1e, 0x0a, 0x4b, 0x77, 0xf8, 0x2d, 0xd7, 0x6b, 0x24, 0x77, 0xf8, 0x2b, 0xae, 0xd7, 0xc0, + 0x0c, 0xa3, 0x8e, 0xac, 0x62, 0xee, 0x23, 0x86, 0xaf, 0xd2, 0xb5, 0x9a, 0x91, 0xf6, 0xff, 0x68, + 0x9b, 0x81, 0x9e, 0xd6, 0x8d, 0x94, 0xc2, 0x1f, 0x31, 0xd7, 0x40, 0xf9, 0x79, 0x0b, 0xc4, 0xa3, + 0xe7, 0x1e, 0xce, 0xe4, 0x37, 0x61, 0x64, 0x27, 0x9d, 0x78, 0xf1, 0x6c, 0xfe, 0x2b, 0x70, 0x11, + 0xab, 0x5d, 0x89, 0xe8, 0x46, 0x92, 0x45, 0x83, 0x97, 0xdd, 0x00, 0x81, 0x5d, 0x24, 0xcc, 0x14, + 0xd1, 0xbd, 0x35, 0xcf, 0x01, 0x34, 0x18, 0x2d, 0xcb, 0xc6, 0x5c, 0x30, 0x25, 0xae, 0x45, 0x85, + 0xc1, 0x1a, 0x95, 0xfd, 0xcf, 0x0b, 0x30, 0x2c, 0x13, 0xfd, 0xb5, 0xbd, 0x5e, 0x14, 0x86, 0x07, + 0xca, 0xfc, 0x8d, 0x2e, 0x40, 0x89, 0x69, 0xb4, 0xab, 0xb1, 0x9e, 0x55, 0xe9, 0x93, 0x56, 0x24, + 0x02, 0xc7, 0x34, 0x4c, 0x7c, 0x6f, 0xdf, 0x62, 0xe4, 0x89, 0x27, 0xba, 0x35, 0x0e, 0xc6, 0x12, + 0x8f, 0x3e, 0x0a, 0x13, 0xbc, 0x5c, 0xe0, 0xb7, 0x9c, 0x0d, 0x6e, 0x05, 0xeb, 0x57, 0x71, 0x4f, + 0x26, 0x56, 0x12, 0xb8, 0xfd, 0xbd, 0xf2, 0xb1, 0x24, 0x8c, 0x99, 0x77, 0x53, 0x5c, 0x98, 0xb3, + 0x1b, 0xaf, 0x84, 0xee, 0xea, 0x29, 0x1f, 0xb9, 0x18, 0x85, 0x75, 0x3a, 0xfb, 0x53, 0x80, 0xd2, + 0x29, 0x0f, 0xd1, 0xeb, 0xdc, 0x59, 0xda, 0x0d, 0x48, 0xa3, 0x93, 0xb9, 0x57, 0x8f, 0xee, 0x21, + 0x5f, 0xd7, 0xf1, 0x52, 0x58, 0x95, 0xb7, 0xff, 0x8f, 0x22, 0x4c, 0x24, 0xe3, 0x09, 0xa0, 0xcb, + 0x30, 0xc0, 0x45, 0x4a, 0xc1, 0xbe, 0x83, 0x37, 0x91, 0x16, 0x85, 0x80, 0x1d, 0xae, 0x42, 0x2a, + 0x15, 0xe5, 0xd1, 0x5b, 0x30, 0xdc, 0xf0, 0x6f, 0x7b, 0xb7, 0x9d, 0xa0, 0x31, 0x57, 0xad, 0x88, + 0xe9, 0x9c, 0xa9, 0xe2, 0x58, 0x8c, 0xc9, 0xf4, 0xc8, 0x06, 0xcc, 0x72, 0x1e, 0xa3, 0xb0, 0xce, + 0x0e, 0xad, 0xb1, 0x14, 0x21, 0xeb, 0xee, 0xc6, 0x8a, 0xd3, 0xea, 0xf4, 0x72, 0x66, 0x41, 0x12, + 0x69, 0x9c, 0x47, 0x45, 0x1e, 0x11, 0x8e, 0xc0, 0x31, 0x23, 0xf4, 0x19, 0x98, 0x0a, 0x73, 0x8c, + 0x2e, 0x79, 0x19, 0x70, 0x3b, 0xd9, 0x21, 0xe6, 0x1f, 0xba, 0xb7, 0x57, 0x9e, 0xca, 0x32, 0xcf, + 0x64, 0x55, 0x63, 0x7f, 0xbe, 0x0f, 0x66, 0x64, 0xa6, 0xcf, 0x0c, 0x3f, 0xfd, 0xcf, 0x59, 0x09, + 0x47, 0xfd, 0x97, 0xf3, 0xf7, 0x86, 0x07, 0xe6, 0xae, 0xff, 0xc5, 0xb4, 0xbb, 0xfe, 0xab, 0x07, + 0x6c, 0xc6, 0xa1, 0x39, 0xed, 0x7f, 0xc7, 0x7a, 0xda, 0x7f, 0xf9, 0x18, 0x18, 0xbb, 0xb9, 0x91, + 0x19, 0xdf, 0x3a, 0xa4, 0xcc, 0xf8, 0x18, 0x86, 0xc8, 0x76, 0x2b, 0xda, 0x5d, 0x74, 0x03, 0xd1, + 0xe2, 0x4c, 0x9e, 0x4b, 0x82, 0x26, 0xcd, 0x53, 0x62, 0xb0, 0xe2, 0x83, 0x76, 0x60, 0x72, 0xa3, + 0x4e, 0x12, 0xc9, 0xb1, 0x8b, 0xf9, 0xab, 0xe7, 0xd2, 0xc2, 0x52, 0x87, 0xcc, 0xd8, 0xec, 0xbe, + 0x90, 0x22, 0xc1, 0xe9, 0x2a, 0x58, 0x62, 0x6e, 0xe7, 0x76, 0xb8, 0xd4, 0x74, 0xc2, 0xc8, 0xad, + 0xcf, 0x37, 0xfd, 0xfa, 0x56, 0x2d, 0xf2, 0x03, 0x99, 0xf6, 0x2b, 0x53, 0x5c, 0x9f, 0xbb, 0x59, + 0x4b, 0xd1, 0xa7, 0x13, 0x73, 0x67, 0x51, 0xe1, 0xcc, 0xba, 0xd0, 0x2a, 0x0c, 0x6e, 0xb8, 0x11, + 0x26, 0x2d, 0x5f, 0xdc, 0xea, 0x33, 0x37, 0xa4, 0x4b, 0x9c, 0x24, 0x9d, 0x28, 0x5b, 0x20, 0xb0, + 0x64, 0x82, 0x5e, 0x57, 0x5b, 0xf1, 0x40, 0xbe, 0xce, 0x2e, 0xed, 0xff, 0x94, 0xb9, 0x19, 0xbf, + 0x06, 0x45, 0x6f, 0x3d, 0xec, 0x14, 0xb5, 0x63, 0x75, 0xb9, 0x96, 0x4e, 0x60, 0xbd, 0xba, 0x5c, + 0xc3, 0xb4, 0x20, 0x7b, 0xe0, 0x17, 0xd6, 0x43, 0x57, 0x24, 0x30, 0xc9, 0x7c, 0xef, 0x58, 0xa9, + 0x2d, 0xd4, 0x2a, 0xe9, 0xa4, 0xdd, 0x0c, 0x8c, 0x79, 0x71, 0x74, 0x03, 0x4a, 0x1b, 0xdc, 0x7e, + 0xa3, 0xb2, 0xff, 0x67, 0x1e, 0x09, 0x97, 0x24, 0x51, 0x3a, 0x55, 0xb7, 0x42, 0xe1, 0x98, 0x15, + 0xfa, 0xbc, 0x05, 0xc7, 0x93, 0xe9, 0x92, 0xd9, 0xb3, 0x1c, 0xe1, 0x2a, 0xf4, 0x62, 0x2f, 0xf9, + 0xab, 0x59, 0x01, 0xa3, 0x42, 0xa6, 0x66, 0xcf, 0x24, 0xc3, 0xd9, 0xd5, 0xd1, 0x8e, 0x0e, 0x6e, + 0x35, 0x84, 0xcb, 0x4a, 0x66, 0x47, 0x27, 0x42, 0x98, 0xf0, 0x8e, 0xc6, 0xf3, 0x8b, 0x98, 0x16, + 0x44, 0x6b, 0xa0, 0xe5, 0xf9, 0x67, 0x66, 0x8c, 0x9c, 0x33, 0x78, 0x59, 0x51, 0xc9, 0x9c, 0x3d, + 0x54, 0x32, 0x8b, 0xa1, 0x58, 0xe3, 0x43, 0xa7, 0x52, 0xdd, 0xf5, 0x1a, 0x24, 0x60, 0x46, 0x8c, + 0x9c, 0xa9, 0xb4, 0xc0, 0x28, 0xd2, 0x53, 0x89, 0xc3, 0xb1, 0xe0, 0xc0, 0x78, 0x91, 0xd6, 0xe6, + 0x7a, 0xd8, 0x29, 0x38, 0xfd, 0x02, 0x69, 0x6d, 0x26, 0x26, 0x14, 0xe7, 0xc5, 0xe0, 0x58, 0x70, + 0xa0, 0x4b, 0x66, 0x9d, 0x2e, 0x20, 0x12, 0x74, 0x4a, 0xfc, 0xbf, 0xcc, 0x49, 0xd2, 0x4b, 0x46, + 0x20, 0xb0, 0x64, 0x82, 0x3e, 0x69, 0xca, 0x1c, 0x3c, 0xf5, 0xff, 0xd3, 0x5d, 0x64, 0x0e, 0x83, + 0x6f, 0x67, 0xa9, 0xe3, 0x65, 0x28, 0xac, 0xd7, 0x45, 0xb6, 0xff, 0x4c, 0x35, 0xf3, 0xf2, 0x82, + 0xc1, 0x8d, 0x05, 0x7b, 0x5e, 0x5e, 0xc0, 0x85, 0xf5, 0x3a, 0x9d, 0xfa, 0xce, 0xdd, 0x76, 0x40, + 0x96, 0xdd, 0xa6, 0x4c, 0xd9, 0x9f, 0x39, 0xf5, 0xe7, 0x24, 0x51, 0x7a, 0xea, 0x2b, 0x14, 0x8e, + 0x59, 0x51, 0xbe, 0xb1, 0x24, 0x34, 0x95, 0xcf, 0x57, 0x09, 0x3c, 0x69, 0xbe, 0x99, 0xb2, 0xd0, + 0x16, 0x8c, 0xee, 0x84, 0xad, 0x4d, 0x22, 0x77, 0x45, 0x91, 0xaf, 0x3f, 0xf3, 0x4d, 0xfb, 0x0d, + 0x41, 0xe8, 0x06, 0x51, 0xdb, 0x69, 0xa6, 0x36, 0x72, 0x76, 0x1b, 0xbf, 0xa1, 0x33, 0xc3, 0x26, + 0x6f, 0x3a, 0x11, 0xde, 0xe6, 0x81, 0xa7, 0x44, 0x2a, 0xff, 0xcc, 0x89, 0x90, 0x11, 0x9b, 0x8a, + 0x4f, 0x04, 0x81, 0xc0, 0x92, 0x89, 0xea, 0x6c, 0x76, 0x00, 0x9d, 0xe8, 0xd2, 0xd9, 0xa9, 0xf6, + 0xc6, 0x9d, 0xcd, 0x0e, 0x9c, 0x98, 0x15, 0x3b, 0x68, 0x5a, 0x19, 0x69, 0xab, 0xa7, 0x1f, 0xca, + 0x3f, 0x68, 0xba, 0xa5, 0xb9, 0xe6, 0x07, 0x4d, 0x16, 0x15, 0xce, 0xac, 0x8b, 0x7e, 0x5c, 0x4b, + 0xc6, 0x10, 0x13, 0xc1, 0xf4, 0x9f, 0xcc, 0x09, 0xc1, 0x97, 0x0e, 0x34, 0xc6, 0x3f, 0x4e, 0xa1, + 0x70, 0xcc, 0x0a, 0x35, 0x60, 0xac, 0x65, 0xc4, 0xa6, 0x64, 0x49, 0x01, 0x72, 0xe4, 0x82, 0xac, + 0x28, 0x96, 0x5c, 0xa9, 0x60, 0x62, 0x70, 0x82, 0x27, 0xf3, 0xd0, 0xe2, 0xcf, 0xad, 0x58, 0xce, + 0x80, 0x9c, 0xa1, 0xce, 0x78, 0x91, 0xc5, 0x87, 0x5a, 0x20, 0xb0, 0x64, 0x42, 0x7b, 0x43, 0x3c, + 0x12, 0xf2, 0x43, 0x96, 0x7a, 0x23, 0xcf, 0x90, 0x9a, 0x65, 0x59, 0x90, 0x01, 0x99, 0x05, 0x0a, + 0xc7, 0xac, 0xe8, 0x4e, 0x4e, 0x0f, 0xbc, 0x53, 0xf9, 0x3b, 0x79, 0xf2, 0xb8, 0x63, 0x3b, 0x39, + 0x3d, 0xec, 0x8a, 0xe2, 0xa8, 0x53, 0xf1, 0x83, 0x59, 0xda, 0x80, 0x9c, 0x76, 0xa9, 0x00, 0xc4, + 0xe9, 0x76, 0x29, 0x14, 0x8e, 0x59, 0xd9, 0x3f, 0x58, 0x80, 0x33, 0x9d, 0xd7, 0x5b, 0x6c, 0x2e, + 0xa9, 0xc6, 0x3e, 0x25, 0x09, 0x73, 0x09, 0xbf, 0xbc, 0xc7, 0x54, 0x3d, 0x87, 0x14, 0xbd, 0x04, + 0x93, 0xea, 0x29, 0x57, 0xd3, 0xad, 0xef, 0xae, 0xc6, 0xfa, 0x12, 0x15, 0x7c, 0xa3, 0x96, 0x24, + 0xc0, 0xe9, 0x32, 0x68, 0x0e, 0xc6, 0x0d, 0x60, 0x65, 0x51, 0x5c, 0xd2, 0xe3, 0x40, 0xf5, 0x26, + 0x1a, 0x27, 0xe9, 0xed, 0x9f, 0xb5, 0xe0, 0xa1, 0x9c, 0xac, 0xc1, 0x3d, 0x47, 0xcc, 0x5c, 0x87, + 0xf1, 0x96, 0x59, 0xb4, 0x4b, 0x90, 0x5f, 0x23, 0x37, 0xb1, 0x6a, 0x6b, 0x02, 0x81, 0x93, 0x4c, + 0xed, 0x9f, 0x2e, 0xc0, 0xe9, 0x8e, 0xbe, 0xc9, 0x08, 0xc3, 0x89, 0x8d, 0xed, 0xd0, 0x59, 0x08, + 0x48, 0x83, 0x78, 0x91, 0xeb, 0x34, 0x6b, 0x2d, 0x52, 0xd7, 0x0c, 0x5e, 0xcc, 0xc9, 0xf7, 0xd2, + 0x4a, 0x6d, 0x2e, 0x4d, 0x81, 0x73, 0x4a, 0xa2, 0x65, 0x40, 0x69, 0x8c, 0x18, 0x61, 0x96, 0x80, + 0x22, 0xcd, 0x0f, 0x67, 0x94, 0x40, 0x1f, 0x84, 0x51, 0xe5, 0xf3, 0xac, 0x8d, 0x38, 0xdb, 0xd8, + 0xb1, 0x8e, 0xc0, 0x26, 0x1d, 0xba, 0xc8, 0x33, 0x98, 0x88, 0x5c, 0x37, 0xc2, 0x3a, 0x36, 0x2e, + 0xd3, 0x93, 0x08, 0x30, 0xd6, 0x69, 0xe6, 0x5f, 0xfa, 0xed, 0x6f, 0x9e, 0x79, 0xdf, 0xef, 0x7d, + 0xf3, 0xcc, 0xfb, 0xfe, 0xf0, 0x9b, 0x67, 0xde, 0xf7, 0x3d, 0xf7, 0xce, 0x58, 0xbf, 0x7d, 0xef, + 0x8c, 0xf5, 0x7b, 0xf7, 0xce, 0x58, 0x7f, 0x78, 0xef, 0x8c, 0xf5, 0x27, 0xf7, 0xce, 0x58, 0x5f, + 0xfa, 0xd3, 0x33, 0xef, 0x7b, 0x13, 0xc5, 0x31, 0x68, 0x2f, 0xd0, 0xd1, 0xb9, 0xb0, 0x73, 0xf1, + 0x7f, 0x06, 0x00, 0x00, 0xff, 0xff, 0x1c, 0x95, 0x37, 0xa6, 0xd7, 0x16, 0x01, 0x00, } func (m *AWSElasticBlockStoreVolumeSource) Marshal() (dAtA []byte, err error) { @@ -14822,6 +14826,24 @@ func (m *PodAffinityTerm) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if len(m.MismatchLabelKeys) > 0 { + for iNdEx := len(m.MismatchLabelKeys) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.MismatchLabelKeys[iNdEx]) + copy(dAtA[i:], m.MismatchLabelKeys[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.MismatchLabelKeys[iNdEx]))) + i-- + dAtA[i] = 0x32 + } + } + if len(m.MatchLabelKeys) > 0 { + for iNdEx := len(m.MatchLabelKeys) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.MatchLabelKeys[iNdEx]) + copy(dAtA[i:], m.MatchLabelKeys[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.MatchLabelKeys[iNdEx]))) + i-- + dAtA[i] = 0x2a + } + } if m.NamespaceSelector != nil { { size, err := m.NamespaceSelector.MarshalToSizedBuffer(dAtA[:i]) @@ -23474,6 +23496,18 @@ func (m *PodAffinityTerm) Size() (n int) { l = m.NamespaceSelector.Size() n += 1 + l + sovGenerated(uint64(l)) } + if len(m.MatchLabelKeys) > 0 { + for _, s := range m.MatchLabelKeys { + l = len(s) + n += 1 + l + sovGenerated(uint64(l)) + } + } + if len(m.MismatchLabelKeys) > 0 { + for _, s := range m.MismatchLabelKeys { + l = len(s) + n += 1 + l + sovGenerated(uint64(l)) + } + } return n } @@ -27684,6 +27718,8 @@ func (this *PodAffinityTerm) String() string { `Namespaces:` + fmt.Sprintf("%v", this.Namespaces) + `,`, `TopologyKey:` + fmt.Sprintf("%v", this.TopologyKey) + `,`, `NamespaceSelector:` + strings.Replace(fmt.Sprintf("%v", this.NamespaceSelector), "LabelSelector", "v1.LabelSelector", 1) + `,`, + `MatchLabelKeys:` + fmt.Sprintf("%v", this.MatchLabelKeys) + `,`, + `MismatchLabelKeys:` + fmt.Sprintf("%v", this.MismatchLabelKeys) + `,`, `}`, }, "") return s @@ -53043,6 +53079,70 @@ func (m *PodAffinityTerm) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MatchLabelKeys", 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.MatchLabelKeys = append(m.MatchLabelKeys, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MismatchLabelKeys", 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.MismatchLabelKeys = append(m.MismatchLabelKeys, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) diff --git a/staging/src/k8s.io/api/core/v1/generated.proto b/staging/src/k8s.io/api/core/v1/generated.proto index 4c3f02b2b54..7dbe5ab42e4 100644 --- a/staging/src/k8s.io/api/core/v1/generated.proto +++ b/staging/src/k8s.io/api/core/v1/generated.proto @@ -3267,6 +3267,7 @@ message PodAffinity { // a pod of the set of pods is running message PodAffinityTerm { // A label query over a set of resources, in this case pods. + // If it's null, this PodAffinityTerm matches with no Pods. // +optional optional k8s.io.apimachinery.pkg.apis.meta.v1.LabelSelector labelSelector = 1; @@ -3291,6 +3292,32 @@ message PodAffinityTerm { // An empty selector ({}) matches all namespaces. // +optional optional k8s.io.apimachinery.pkg.apis.meta.v1.LabelSelector namespaceSelector = 4; + + // MatchLabelKeys is a set of pod label keys to select which pods will + // be taken into consideration. The keys are used to lookup values from the + // incoming pod labels, those key-value labels are merged with `LabelSelector` as `key in (value)` + // to select the group of existing pods which pods will be taken into consideration + // for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming + // pod labels will be ignored. The default value is empty. + // The same key is forbidden to exist in both MatchLabelKeys and LabelSelector. + // Also, MatchLabelKeys cannot be set when LabelSelector isn't set. + // This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate. + // +listType=atomic + // +optional + repeated string matchLabelKeys = 5; + + // MismatchLabelKeys is a set of pod label keys to select which pods will + // be taken into consideration. The keys are used to lookup values from the + // incoming pod labels, those key-value labels are merged with `LabelSelector` as `key notin (value)` + // to select the group of existing pods which pods will be taken into consideration + // for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming + // pod labels will be ignored. The default value is empty. + // The same key is forbidden to exist in both MismatchLabelKeys and LabelSelector. + // Also, MismatchLabelKeys cannot be set when LabelSelector isn't set. + // This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate. + // +listType=atomic + // +optional + repeated string mismatchLabelKeys = 6; } // Pod anti affinity is a group of inter pod anti affinity scheduling rules. diff --git a/staging/src/k8s.io/api/core/v1/types.go b/staging/src/k8s.io/api/core/v1/types.go index cc8cef943f3..9ba456c1f50 100644 --- a/staging/src/k8s.io/api/core/v1/types.go +++ b/staging/src/k8s.io/api/core/v1/types.go @@ -3170,6 +3170,7 @@ type WeightedPodAffinityTerm struct { // a pod of the set of pods is running type PodAffinityTerm struct { // A label query over a set of resources, in this case pods. + // If it's null, this PodAffinityTerm matches with no Pods. // +optional LabelSelector *metav1.LabelSelector `json:"labelSelector,omitempty" protobuf:"bytes,1,opt,name=labelSelector"` // namespaces specifies a static list of namespace names that the term applies to. @@ -3191,6 +3192,30 @@ type PodAffinityTerm struct { // An empty selector ({}) matches all namespaces. // +optional NamespaceSelector *metav1.LabelSelector `json:"namespaceSelector,omitempty" protobuf:"bytes,4,opt,name=namespaceSelector"` + // MatchLabelKeys is a set of pod label keys to select which pods will + // be taken into consideration. The keys are used to lookup values from the + // incoming pod labels, those key-value labels are merged with `LabelSelector` as `key in (value)` + // to select the group of existing pods which pods will be taken into consideration + // for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming + // pod labels will be ignored. The default value is empty. + // The same key is forbidden to exist in both MatchLabelKeys and LabelSelector. + // Also, MatchLabelKeys cannot be set when LabelSelector isn't set. + // This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate. + // +listType=atomic + // +optional + MatchLabelKeys []string `json:"matchLabelKeys,omitempty" protobuf:"bytes,5,opt,name=matchLabelKeys"` + // MismatchLabelKeys is a set of pod label keys to select which pods will + // be taken into consideration. The keys are used to lookup values from the + // incoming pod labels, those key-value labels are merged with `LabelSelector` as `key notin (value)` + // to select the group of existing pods which pods will be taken into consideration + // for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming + // pod labels will be ignored. The default value is empty. + // The same key is forbidden to exist in both MismatchLabelKeys and LabelSelector. + // Also, MismatchLabelKeys cannot be set when LabelSelector isn't set. + // This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate. + // +listType=atomic + // +optional + MismatchLabelKeys []string `json:"mismatchLabelKeys,omitempty" protobuf:"bytes,6,opt,name=mismatchLabelKeys"` } // Node affinity is a group of node affinity scheduling rules. 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 0684857311d..ada7fb9f3f6 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 @@ -1491,10 +1491,12 @@ func (PodAffinity) SwaggerDoc() map[string]string { var map_PodAffinityTerm = map[string]string{ "": "Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running", - "labelSelector": "A label query over a set of resources, in this case pods.", + "labelSelector": "A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm matches with no Pods.", "namespaces": "namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means \"this pod's namespace\".", "topologyKey": "This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.", "namespaceSelector": "A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means \"this pod's namespace\". An empty selector ({}) matches all namespaces.", + "matchLabelKeys": "MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `LabelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both MatchLabelKeys and LabelSelector. Also, MatchLabelKeys cannot be set when LabelSelector isn't set. This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.", + "mismatchLabelKeys": "MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `LabelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both MismatchLabelKeys and LabelSelector. Also, MismatchLabelKeys cannot be set when LabelSelector isn't set. This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.", } func (PodAffinityTerm) SwaggerDoc() map[string]string { diff --git a/staging/src/k8s.io/api/core/v1/zz_generated.deepcopy.go b/staging/src/k8s.io/api/core/v1/zz_generated.deepcopy.go index 3770c3ba2d7..528fbb3b125 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 @@ -3482,6 +3482,16 @@ func (in *PodAffinityTerm) DeepCopyInto(out *PodAffinityTerm) { *out = new(metav1.LabelSelector) (*in).DeepCopyInto(*out) } + if in.MatchLabelKeys != nil { + in, out := &in.MatchLabelKeys, &out.MatchLabelKeys + *out = make([]string, len(*in)) + copy(*out, *in) + } + if in.MismatchLabelKeys != nil { + in, out := &in.MismatchLabelKeys, &out.MismatchLabelKeys + *out = make([]string, len(*in)) + copy(*out, *in) + } return } 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 a01a031d7fb..b8a149ba650 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 @@ -1484,7 +1484,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } ], "preferredDuringSchedulingIgnoredDuringExecution": [ @@ -1522,7 +1528,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } } ] @@ -1561,7 +1573,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } ], "preferredDuringSchedulingIgnoredDuringExecution": [ @@ -1599,7 +1617,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } } ] 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 f5a19eab5171f8913894ef0a91e16714ab4287ff..e0508dbda05e67fb0713c38fb57bc3def2a0f091 100644 GIT binary patch delta 265 zcmbOba3pYoG}Ge1jj}0>Os{+=KM?b0y5__EH|?li@4B7Mh-?Hutp=2G)hrypE{BDZBCHb Gzz+aD{A7Co delta 116 zcmX>SI3ZwyG}C+kjj}0>%-ejpCNGfiWfofG4dOHH@z`v|oGQq4lzs9-k#%gH%v}2! d!73)#NEC7k9bx2P6habVmm;KMvy|j2egK3CBk%wK 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 d1ecdd5f191..7b2b628c658 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 @@ -116,6 +116,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -137,6 +141,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -159,6 +167,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -180,6 +192,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue 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 bf7f7542c43..41d75f1ffd6 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 @@ -1485,7 +1485,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } ], "preferredDuringSchedulingIgnoredDuringExecution": [ @@ -1523,7 +1529,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } } ] @@ -1562,7 +1574,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } ], "preferredDuringSchedulingIgnoredDuringExecution": [ @@ -1600,7 +1618,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } } ] 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 946c1ad3f83cb1a6516a3343f8994ecd1139f97c..0e7deff85ed9a353e9730b16e60f42b8546d7e48 100644 GIT binary patch delta 301 zcmbOma4~R#4Ac6+jdCfBtRH+i7=u{~zydc(*CROvf8N376HOE@>NBss$;F)202JGHVnEHS4v)krKivlxrG&__m~ XElAo;NYXAvRlC)Rw0m>1#4dgSfCOpi delta 103 zcmcZ@I5%K|4AXD_jdCfBtb2So7=u{~zydc(*CROvf8N376HOE@>NBss$;F)202JGHVnEHS4v)krKivlxrG&__m~ XElAo;NYXAvRlC)Rw0m>1L^?kJ%dTnE delta 103 zcmewtaLRvz4ATn#jdCfBtlzyk7=)0MM zbG>2Y0x6mNSG>?nOE@>NBss$;F)202JGHVnEHS4v)krKivlxrG&__m~@krWDNYXAv PRlC)Rw0m=g#6Eriy{Boz delta 96 zcmcZ=xGZ3TBGZ5W&37167+DYaa4-r@4ixicmRjTu7Gm1tvDt|^Rgmc@`{b1(>sUIO cx%N+X6hFW&bc7M87R+Xq!X~;|Npc5204(AkXaE2J 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 2f7eeb16e8b..4c537c4aebd 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 @@ -126,6 +126,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -147,6 +151,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -169,6 +177,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -190,6 +202,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue 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 edec6ba45df..b67c5a6f33b 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 @@ -1485,7 +1485,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } ], "preferredDuringSchedulingIgnoredDuringExecution": [ @@ -1523,7 +1529,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } } ] @@ -1562,7 +1574,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } ], "preferredDuringSchedulingIgnoredDuringExecution": [ @@ -1600,7 +1618,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } } ] 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 f1cc24abf5b35e9681b8b0db0332eb75fd09580a..08fc1f1b5320e7027e3b5909316c27f37e1db23e 100644 GIT binary patch delta 271 zcmaDBJ}Yv964R%M&37477+EKUaxe-_-YD+NEOpHXEX4G|bF(vZsvy%(j>)S;*0DTh z=6W-Ez4!qWE#ch6lH?4Z#H7?5@6^iTu*96wR3ow6%wjC!LLV7{27@&kk)%osM9 delta 96 zcmbOg`7C^b64So$&37477+LQHb1(``J}>IaEValREX1_OW3w}Jsvy%*_Q|V6*0FRl cbM2oTAa;OV=m;ZFEtt(Jg-vv`vShh1093vo;Q#;t 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 33445ed4994..6d4bc4d12ae 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 @@ -124,6 +124,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -145,6 +149,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -167,6 +175,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -188,6 +200,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue 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 c834489a62d..5c6df44c492 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 @@ -1484,7 +1484,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } ], "preferredDuringSchedulingIgnoredDuringExecution": [ @@ -1522,7 +1528,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } } ] @@ -1561,7 +1573,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } ], "preferredDuringSchedulingIgnoredDuringExecution": [ @@ -1599,7 +1617,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } } ] 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 11cc98fcf73b598a16e5b11e50c0be05357f69eb..33411f8b80f7532ae290c2d8657500026f588925 100644 GIT binary patch delta 223 zcmbOla58X$0@LEa&H7v^j7+b5Co72gGhOq6a6fo%wr5TiZI5l8`0@Hi{&H7v^jLh47xF$d3_GK1YJ+T*d=o;g*J>nJ)0MM zbG>2Y0x6mNSG>?nOE@>NBss$;F)202JGHVnEHS4v)krKivlxrG&__m~@krWDNYXAv PRlC)Rw0m=g#4dgStB+}~ delta 96 zcmcZ>xF}$PBGYgG&37167+LrDa4-r@4ixicmRjTu7Gm1tvDt|^Rgmc@`{b1(>sUIO cx%N+X6hFW&bc7M87R+Xq!X~;|NpcH604F*hQ~&?~ 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 4e57e8fd5f1..7aded373e51 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 @@ -124,6 +124,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -145,6 +149,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -167,6 +175,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -188,6 +200,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue 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 12c4ecb76b0..9fb52a28996 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 @@ -1486,7 +1486,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } ], "preferredDuringSchedulingIgnoredDuringExecution": [ @@ -1524,7 +1530,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } } ] @@ -1563,7 +1575,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } ], "preferredDuringSchedulingIgnoredDuringExecution": [ @@ -1601,7 +1619,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } } ] 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 7c9dd2c5b133509c6bd12d5efd618060ef55416d..ddc5cff24da36c5e9fc03778aa32eef7f700a1df 100644 GIT binary patch delta 295 zcmX@_-yAqWk?Bsr<~xijjI67DIT(c|D@yn>OI`B;3o(80-0Z}hD#-McWAaLob!?BB zx!y2xfs{=CD_&@(C7hdBlAPg_n3S61omyEOmY7qTY9yAMS&T(o=p!T0cqHv6Bx#qT Ps@>{D+PyhLBAp)qWTB?GiXUJXI>HE43ud!QVH4e~B$>z$01X`;!2kdN 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 835b25b73d9..aa675ba48d5 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 @@ -116,6 +116,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -137,6 +141,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -159,6 +167,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -180,6 +192,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue 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 b41dfa6e4e9..173842cd32b 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 @@ -1485,7 +1485,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } ], "preferredDuringSchedulingIgnoredDuringExecution": [ @@ -1523,7 +1529,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } } ] @@ -1562,7 +1574,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } ], "preferredDuringSchedulingIgnoredDuringExecution": [ @@ -1600,7 +1618,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } } ] 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 8ed1deb7220e48b543ef8822e05c097499371c70..3f091401ece5a79289c477ff75698bdb3a3c2048 100644 GIT binary patch delta 271 zcmaDBJ}Yv964R%M&37477+EKUaxe-_-YD+NEOpHXEX4G|bF(vZsvy%(j>)S;*0DTh z=6W-Ez4!qWE#ch6lH?4Z#H7?5@6^iTu*96wR3ow6%wjC!LLV7{27@&kk)%osM9 delta 96 zcmbOg`7C^b64So$&37477+LQHb1(``J}>IaEValREX1_OW3w}Jsvy%*_Q|V6*0FRl cbM2oTAa;OV=m;ZFEtt(Jg-vv`vShh1093vo;Q#;t 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 8eea8917e63..605da4f3085 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 @@ -124,6 +124,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -145,6 +149,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -167,6 +175,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -188,6 +200,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue 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 0e201ac2484..61062c83590 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 @@ -1560,7 +1560,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } ], "preferredDuringSchedulingIgnoredDuringExecution": [ @@ -1598,7 +1604,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } } ] @@ -1637,7 +1649,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } ], "preferredDuringSchedulingIgnoredDuringExecution": [ @@ -1675,7 +1693,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } } ] 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 9dc5caad023e6328f9c1836248fb1c4519f94b41..0051f3a43bb1145e8c082e802ee5a15fdb23a978 100644 GIT binary patch delta 291 zcmdlS@;r2c6w~q0%^Mg~7?~agPHtkkAnwPi!Dw{N2cqnQ z=jN*{se(*DIVRhPtz&u2%=KonqvQb-E#ch6lH?4Z#H7?5@6^iTu*96wR3ow6%wjC! cLLV797=^$ZjY!fcMX`PAMB2Ccx1@yt0Otv5E&u=k delta 140 zcmaDJx;bQm6w~C8%^Mg~7@5`uOm1S-VS4Ki=5nH?br+!zVE*HOD)(vN$X;r!>__EH|?li@4B7Mh-?H WB<&_7X_um^-ReZzy*XJTN&o<@1!=MX delta 101 zcmewuv^Q{q7}LVQ&AMDEj7;smlj|76nHG6NxO+S{+cKvLavWvnTE)l}#5GAYX!0MC hFqTecuKkk@Bo43(9bx2P6auqZrLc)^mX!<<003y^9{vCT 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 0559bfeefad..122d6464ec7 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 @@ -135,6 +135,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -156,6 +160,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -178,6 +186,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -199,6 +211,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue 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 46a5bc06863..4e17905804d 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 @@ -1560,7 +1560,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } ], "preferredDuringSchedulingIgnoredDuringExecution": [ @@ -1598,7 +1604,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } } ] @@ -1637,7 +1649,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } ], "preferredDuringSchedulingIgnoredDuringExecution": [ @@ -1675,7 +1693,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } } ] 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 fd2f86f92f89b0340a8693b0c9f1e390458f6bea..010f565133a7597600da83c3a4d1a08aa9d066f3 100644 GIT binary patch delta 278 zcmdlH@+NeGJk#;ejfyFZOpgL5w=?Q6Eer(ncKc11W)5e%<^$$^@Z5ZhB~_5=C&y$* zv2`qunYrFfu9rAqq9vT0SdyIKlbDp6C$;`EX a@_SHvIT(e&Y*s03qMIYc>qP(*C>=on 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 9714840f063..988d02398a6 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 @@ -72,6 +72,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -93,6 +97,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -115,6 +123,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -136,6 +148,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue 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 787651f55e1..3d08304c9a0 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 @@ -1469,7 +1469,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } ], "preferredDuringSchedulingIgnoredDuringExecution": [ @@ -1507,7 +1513,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } } ] @@ -1546,7 +1558,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } ], "preferredDuringSchedulingIgnoredDuringExecution": [ @@ -1584,7 +1602,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } } ] 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 13f5f21e5224294b67872cb684dfff01da4d3750..29a3dffd9b1a5ec58b71bb6166f9228ac9209304 100644 GIT binary patch delta 260 zcmZ4Hcguf*1k)b>%?*qxj7-;jAoK^%&Ci%p1(|+wO!gI7$MTq&>&@i delta 85 zcmccRzszrf1XG9K<_5+TMy5sH5PFZt=4VW)f=ox*C;N)5W9ek(+CTZf$N_etBa9r3 QLSQzl6gJV#$0S7f0VX*f&j0`b 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 a633652776c..3159f2d707b 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 @@ -105,6 +105,10 @@ template: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -126,6 +130,10 @@ template: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -148,6 +156,10 @@ template: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -169,6 +181,10 @@ template: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue 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 fb761b98683..fb729da601d 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 @@ -1475,7 +1475,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } ], "preferredDuringSchedulingIgnoredDuringExecution": [ @@ -1513,7 +1519,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } } ] @@ -1552,7 +1564,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } ], "preferredDuringSchedulingIgnoredDuringExecution": [ @@ -1590,7 +1608,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } } ] 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 3da22016211410d555d7c58607ad551d0b9a6e7f..d445b707e32a52c0d7ac5d76ecc692b48bbf82c4 100644 GIT binary patch delta 267 zcmZ4Bec@1=2h3;s;JMkAIaQG9C&%P9BI{TlGjqL} zyixpsiI#9~Vo7p_PhwJPj(2KhaadwbX{wP}Ze}qSaiNcl9E?I>jYcGCl%m)^bt3KC JoGr159{{d_WtRW| delta 118 zcmcZ@I5%K|8q-Jr&G#8o7@2qYa814_>dP#&$Qvxcw8vw!D|4zK(^2-xYed$ubux49 fX9O#myjHZ3Q|JgI2cr;@2)h&^6`NHh*YE=Xihn0$ 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 67113b877ae..ff380e1c35d 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 @@ -116,6 +116,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -137,6 +141,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -159,6 +167,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue @@ -180,6 +192,10 @@ spec: - valuesValue matchLabels: matchLabelsKey: matchLabelsValue + matchLabelKeys: + - matchLabelKeysValue + mismatchLabelKeys: + - mismatchLabelKeysValue namespaceSelector: matchExpressions: - key: keyValue 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 a68bb43d8c5..bbbdc7262b0 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 @@ -1485,7 +1485,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } ], "preferredDuringSchedulingIgnoredDuringExecution": [ @@ -1523,7 +1529,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } } ] @@ -1562,7 +1574,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } ], "preferredDuringSchedulingIgnoredDuringExecution": [ @@ -1600,7 +1618,13 @@ ] } ] - } + }, + "matchLabelKeys": [ + "matchLabelKeysValue" + ], + "mismatchLabelKeys": [ + "mismatchLabelKeysValue" + ] } } ] 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 098ab68b669fba4b77eb32f0a35979a52a912cbb..edb8b3f84a026b2a2378fe726999687172a3c519 100644 GIT binary patch delta 265 zcmZ1z@E~x4I@9LBjhZQpOkaE__cI1EUGo9+K6q~SU``ce`pGeQy~sM2$IM)BCMSv> zFwqjuO)N>y@JUQc&GAmHEDlS|DNQvJ%grptA};iik%LhPtkH-hjZzfbr%t4OoAV_0 G@dE&6&SJ>` delta 90 zcmaD5xF%qNI@5pujhZQpOb2`>_cI1EE%FBQ_IPaeU``ceI?6tIy~sM2PG+wClM_V` XunQew5lM_V` zm}m*-CYB^;_#`H!=6I)87KbI~l%^Vq