diff --git a/api/openapi-spec/swagger.json b/api/openapi-spec/swagger.json index 67c37dd0f9..5e07baad3e 100644 --- a/api/openapi-spec/swagger.json +++ b/api/openapi-spec/swagger.json @@ -9328,6 +9328,10 @@ "description": "NodeSelector is a selector which must be true for the pod to fit on a node. Selector which must match a node's labels for the pod to be scheduled on that node. More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/", "type": "object" }, + "preemptionPolicy": { + "description": "PreemptionPolicy is the Policy for preempting pods with lower priority. One of Never, PreemptLowerPriority. Defaults to PreemptLowerPriority if unset. This field is alpha-level and is only honored by servers that enable the NonPreemptingPriority feature.", + "type": "string" + }, "priority": { "description": "The priority value. Various system components use this field to find the priority of the pod. When Priority Admission Controller is enabled, it prevents users from setting this field. The admission controller populates this field from PriorityClassName. The higher the value, the higher the priority.", "format": "int32", @@ -15159,6 +15163,10 @@ "$ref": "#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta", "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata" }, + "preemptionPolicy": { + "description": "PreemptionPolicy is the Policy for preempting pods with lower priority. One of Never, PreemptLowerPriority. Defaults to PreemptLowerPriority if unset. This field is alpha-level and is only honored by servers that enable the NonPreemptingPriority feature.", + "type": "string" + }, "value": { "description": "The value of this priority class. This is the actual priority that pods receive when they have the name of this class in their pod spec.", "format": "int32", @@ -15235,6 +15243,10 @@ "$ref": "#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta", "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata" }, + "preemptionPolicy": { + "description": "PreemptionPolicy is the Policy for preempting pods with lower priority. One of Never, PreemptLowerPriority. Defaults to PreemptLowerPriority if unset. This field is alpha-level and is only honored by servers that enable the NonPreemptingPriority feature.", + "type": "string" + }, "value": { "description": "The value of this priority class. This is the actual priority that pods receive when they have the name of this class in their pod spec.", "format": "int32", @@ -15311,6 +15323,10 @@ "$ref": "#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta", "description": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata" }, + "preemptionPolicy": { + "description": "PreemptionPolicy is the Policy for preempting pods with lower priority. One of Never, PreemptLowerPriority. Defaults to PreemptLowerPriority if unset. This field is alpha-level and is only honored by servers that enable the NonPreemptingPriority feature.", + "type": "string" + }, "value": { "description": "The value of this priority class. This is the actual priority that pods receive when they have the name of this class in their pod spec.", "format": "int32", diff --git a/hack/.golint_failures b/hack/.golint_failures index e3ce8377b9..ba70b1647e 100644 --- a/hack/.golint_failures +++ b/hack/.golint_failures @@ -45,6 +45,9 @@ pkg/apis/rbac/v1 pkg/apis/rbac/v1alpha1 pkg/apis/rbac/v1beta1 pkg/apis/rbac/validation +pkg/apis/scheduling/v1 +pkg/apis/scheduling/v1alpha1 +pkg/apis/scheduling/v1beta1 pkg/apis/storage pkg/apis/storage/v1 pkg/apis/storage/v1beta1 diff --git a/pkg/api/pod/util.go b/pkg/api/pod/util.go index e2a7cb566e..d6f4fdbcf8 100644 --- a/pkg/api/pod/util.go +++ b/pkg/api/pod/util.go @@ -379,6 +379,12 @@ func dropDisabledFields( dropDisabledCSIVolumeSourceAlphaFields(podSpec, oldPodSpec) + if !utilfeature.DefaultFeatureGate.Enabled(features.NonPreemptingPriority) && + !podPriorityInUse(oldPodSpec) { + // Set to nil pod's PreemptionPolicy fields if the feature is disabled and the old pod + // does not specify any values for these fields. + podSpec.PreemptionPolicy = nil + } } // dropDisabledRunAsGroupField removes disabled fields from PodSpec related diff --git a/pkg/api/testing/BUILD b/pkg/api/testing/BUILD index 7f3b5aecdf..7d133a326f 100644 --- a/pkg/api/testing/BUILD +++ b/pkg/api/testing/BUILD @@ -30,6 +30,7 @@ go_library( "//pkg/apis/networking/fuzzer:go_default_library", "//pkg/apis/policy/fuzzer:go_default_library", "//pkg/apis/rbac/fuzzer:go_default_library", + "//pkg/apis/scheduling/fuzzer:go_default_library", "//pkg/apis/storage/fuzzer:go_default_library", "//staging/src/k8s.io/api/apps/v1:go_default_library", "//staging/src/k8s.io/api/core/v1:go_default_library", diff --git a/pkg/api/testing/defaulting_test.go b/pkg/api/testing/defaulting_test.go index 32995e4bab..b745b9f000 100644 --- a/pkg/api/testing/defaulting_test.go +++ b/pkg/api/testing/defaulting_test.go @@ -22,11 +22,11 @@ import ( "sort" "testing" - fuzz "github.com/google/gofuzz" + "github.com/google/gofuzz" apiv1 "k8s.io/api/core/v1" extensionsv1beta1 "k8s.io/api/extensions/v1beta1" - roundtrip "k8s.io/apimachinery/pkg/api/apitesting/roundtrip" + "k8s.io/apimachinery/pkg/api/apitesting/roundtrip" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" diff --git a/pkg/api/testing/fuzzer.go b/pkg/api/testing/fuzzer.go index 8bf1fd42a8..38a566ffbd 100644 --- a/pkg/api/testing/fuzzer.go +++ b/pkg/api/testing/fuzzer.go @@ -41,6 +41,7 @@ import ( networkingfuzzer "k8s.io/kubernetes/pkg/apis/networking/fuzzer" policyfuzzer "k8s.io/kubernetes/pkg/apis/policy/fuzzer" rbacfuzzer "k8s.io/kubernetes/pkg/apis/rbac/fuzzer" + schedulingfuzzer "k8s.io/kubernetes/pkg/apis/scheduling/fuzzer" storagefuzzer "k8s.io/kubernetes/pkg/apis/storage/fuzzer" ) @@ -105,4 +106,5 @@ var FuzzerFuncs = fuzzer.MergeFuzzerFuncs( storagefuzzer.Funcs, networkingfuzzer.Funcs, metafuzzer.Funcs, + schedulingfuzzer.Funcs, ) diff --git a/pkg/api/testing/serialization_test.go b/pkg/api/testing/serialization_test.go index c22f2b929f..6d7bfc8999 100644 --- a/pkg/api/testing/serialization_test.go +++ b/pkg/api/testing/serialization_test.go @@ -217,6 +217,7 @@ func TestRoundTripTypes(t *testing.T) { func TestEncodePtr(t *testing.T) { grace := int64(30) enableServiceLinks := v1.DefaultEnableServiceLinks + preemptNever := api.PreemptNever pod := &api.Pod{ ObjectMeta: metav1.ObjectMeta{ Labels: map[string]string{"name": "foo"}, @@ -230,6 +231,7 @@ func TestEncodePtr(t *testing.T) { SecurityContext: &api.PodSecurityContext{}, SchedulerName: api.DefaultSchedulerName, EnableServiceLinks: &enableServiceLinks, + PreemptionPolicy: &preemptNever, }, } obj := runtime.Object(pod) diff --git a/pkg/apis/core/types.go b/pkg/apis/core/types.go index fb0755e019..1f0ab9dea2 100644 --- a/pkg/apis/core/types.go +++ b/pkg/apis/core/types.go @@ -1941,6 +1941,16 @@ const ( PullIfNotPresent PullPolicy = "IfNotPresent" ) +// PreemptionPolicy describes a policy for if/when to preempt a pod. +type PreemptionPolicy string + +const ( + // PreemptLowerPriority means that pod can preempt other pods with lower priority. + PreemptLowerPriority PreemptionPolicy = "PreemptLowerPriority" + // PreemptNever means that pod never preempts other pods with lower priority. + PreemptNever PreemptionPolicy = "Never" +) + // TerminationMessagePolicy describes how termination messages are retrieved from a container. type TerminationMessagePolicy string @@ -2662,6 +2672,12 @@ type PodSpec struct { // The higher the value, the higher the priority. // +optional Priority *int32 + // PreemptionPolicy is the Policy for preempting pods with lower priority. + // One of Never, PreemptLowerPriority. + // Defaults to PreemptLowerPriority if unset. + // This field is alpha-level and is only honored by servers that enable the NonPreemptingPriority feature. + // +optional + PreemptionPolicy *PreemptionPolicy // Specifies the DNS parameters of a pod. // Parameters specified here will be merged to the generated DNS // configuration based on DNSPolicy. diff --git a/pkg/apis/core/v1/zz_generated.conversion.go b/pkg/apis/core/v1/zz_generated.conversion.go index 303da0cbd7..883066ec3a 100644 --- a/pkg/apis/core/v1/zz_generated.conversion.go +++ b/pkg/apis/core/v1/zz_generated.conversion.go @@ -5598,6 +5598,7 @@ func autoConvert_v1_PodSpec_To_core_PodSpec(in *v1.PodSpec, out *core.PodSpec, s out.ReadinessGates = *(*[]core.PodReadinessGate)(unsafe.Pointer(&in.ReadinessGates)) out.RuntimeClassName = (*string)(unsafe.Pointer(in.RuntimeClassName)) out.EnableServiceLinks = (*bool)(unsafe.Pointer(in.EnableServiceLinks)) + out.PreemptionPolicy = (*core.PreemptionPolicy)(unsafe.Pointer(in.PreemptionPolicy)) return nil } @@ -5641,6 +5642,7 @@ func autoConvert_core_PodSpec_To_v1_PodSpec(in *core.PodSpec, out *v1.PodSpec, s out.HostAliases = *(*[]v1.HostAlias)(unsafe.Pointer(&in.HostAliases)) out.PriorityClassName = in.PriorityClassName out.Priority = (*int32)(unsafe.Pointer(in.Priority)) + out.PreemptionPolicy = (*v1.PreemptionPolicy)(unsafe.Pointer(in.PreemptionPolicy)) out.DNSConfig = (*v1.PodDNSConfig)(unsafe.Pointer(in.DNSConfig)) out.ReadinessGates = *(*[]v1.PodReadinessGate)(unsafe.Pointer(&in.ReadinessGates)) out.RuntimeClassName = (*string)(unsafe.Pointer(in.RuntimeClassName)) diff --git a/pkg/apis/core/validation/validation.go b/pkg/apis/core/validation/validation.go index 7eca587e12..ead5c29c9c 100644 --- a/pkg/apis/core/validation/validation.go +++ b/pkg/apis/core/validation/validation.go @@ -2653,6 +2653,19 @@ func validateRestartPolicy(restartPolicy *core.RestartPolicy, fldPath *field.Pat return allErrors } +func ValidatePreemptionPolicy(preemptionPolicy *core.PreemptionPolicy, fldPath *field.Path) field.ErrorList { + allErrors := field.ErrorList{} + switch *preemptionPolicy { + case core.PreemptLowerPriority, core.PreemptNever: + case "": + allErrors = append(allErrors, field.Required(fldPath, "")) + default: + validValues := []string{string(core.PreemptLowerPriority), string(core.PreemptNever)} + allErrors = append(allErrors, field.NotSupported(fldPath, preemptionPolicy, validValues)) + } + return allErrors +} + func validateDNSPolicy(dnsPolicy *core.DNSPolicy, fldPath *field.Path) field.ErrorList { allErrors := field.ErrorList{} switch *dnsPolicy { @@ -3033,6 +3046,10 @@ func ValidatePodSpec(spec *core.PodSpec, fldPath *field.Path) field.ErrorList { allErrs = append(allErrs, ValidateRuntimeClassName(*spec.RuntimeClassName, fldPath.Child("runtimeClassName"))...) } + if spec.PreemptionPolicy != nil { + allErrs = append(allErrs, ValidatePreemptionPolicy(spec.PreemptionPolicy, fldPath.Child("preemptionPolicy"))...) + } + return allErrs } diff --git a/pkg/apis/core/zz_generated.deepcopy.go b/pkg/apis/core/zz_generated.deepcopy.go index f7a28a0b70..ae3343d0ab 100644 --- a/pkg/apis/core/zz_generated.deepcopy.go +++ b/pkg/apis/core/zz_generated.deepcopy.go @@ -3610,6 +3610,11 @@ func (in *PodSpec) DeepCopyInto(out *PodSpec) { *out = new(int32) **out = **in } + if in.PreemptionPolicy != nil { + in, out := &in.PreemptionPolicy, &out.PreemptionPolicy + *out = new(PreemptionPolicy) + **out = **in + } if in.DNSConfig != nil { in, out := &in.DNSConfig, &out.DNSConfig *out = new(PodDNSConfig) diff --git a/pkg/apis/scheduling/BUILD b/pkg/apis/scheduling/BUILD index 10cb5065e5..f32c1c166e 100644 --- a/pkg/apis/scheduling/BUILD +++ b/pkg/apis/scheduling/BUILD @@ -17,6 +17,7 @@ go_library( ], importpath = "k8s.io/kubernetes/pkg/apis/scheduling", deps = [ + "//pkg/apis/core:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/runtime/schema:go_default_library", @@ -36,6 +37,7 @@ filegroup( ":package-srcs", "//pkg/apis/scheduling/fuzzer:all-srcs", "//pkg/apis/scheduling/install:all-srcs", + "//pkg/apis/scheduling/util:all-srcs", "//pkg/apis/scheduling/v1:all-srcs", "//pkg/apis/scheduling/v1alpha1:all-srcs", "//pkg/apis/scheduling/v1beta1:all-srcs", diff --git a/pkg/apis/scheduling/fuzzer/BUILD b/pkg/apis/scheduling/fuzzer/BUILD index 814773a696..fb91296150 100644 --- a/pkg/apis/scheduling/fuzzer/BUILD +++ b/pkg/apis/scheduling/fuzzer/BUILD @@ -9,7 +9,14 @@ go_library( name = "go_default_library", srcs = ["fuzzer.go"], importpath = "k8s.io/kubernetes/pkg/apis/scheduling/fuzzer", - deps = ["//staging/src/k8s.io/apimachinery/pkg/runtime/serializer:go_default_library"], + deps = [ + "//pkg/apis/core:go_default_library", + "//pkg/apis/scheduling:go_default_library", + "//pkg/features:go_default_library", + "//staging/src/k8s.io/apimachinery/pkg/runtime/serializer:go_default_library", + "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library", + "//vendor/github.com/google/gofuzz:go_default_library", + ], ) filegroup( diff --git a/pkg/apis/scheduling/fuzzer/fuzzer.go b/pkg/apis/scheduling/fuzzer/fuzzer.go index ee9286de2c..5e5d146e44 100644 --- a/pkg/apis/scheduling/fuzzer/fuzzer.go +++ b/pkg/apis/scheduling/fuzzer/fuzzer.go @@ -17,10 +17,23 @@ limitations under the License. package fuzzer import ( + "github.com/google/gofuzz" runtimeserializer "k8s.io/apimachinery/pkg/runtime/serializer" + utilfeature "k8s.io/apiserver/pkg/util/feature" + "k8s.io/kubernetes/pkg/apis/core" + "k8s.io/kubernetes/pkg/apis/scheduling" + "k8s.io/kubernetes/pkg/features" ) // Funcs returns the fuzzer functions for the scheduling api group. var Funcs = func(codecs runtimeserializer.CodecFactory) []interface{} { - return []interface{}{} + return []interface{}{ + func(s *scheduling.PriorityClass, c fuzz.Continue) { + c.FuzzNoCustom(s) + if utilfeature.DefaultFeatureGate.Enabled(features.NonPreemptingPriority) && s.PreemptionPolicy == nil { + preemptLowerPriority := core.PreemptLowerPriority + s.PreemptionPolicy = &preemptLowerPriority + } + }, + } } diff --git a/pkg/apis/scheduling/types.go b/pkg/apis/scheduling/types.go index 3a6437731c..627e6a5191 100644 --- a/pkg/apis/scheduling/types.go +++ b/pkg/apis/scheduling/types.go @@ -16,7 +16,10 @@ limitations under the License. package scheduling -import metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +import ( + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/kubernetes/pkg/apis/core" +) const ( // DefaultPriorityWhenNoDefaultClassExists is used to set priority of pods @@ -64,6 +67,11 @@ type PriorityClass struct { // when this priority class should be used. // +optional Description string + + // PreemptionPolicy it the Policy for preempting pods with lower priority. + // This field is alpha-level and is only honored by servers that enable the NonPreemptingPriority feature. + // +optional + PreemptionPolicy *core.PreemptionPolicy } // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object diff --git a/pkg/apis/scheduling/util/BUILD b/pkg/apis/scheduling/util/BUILD new file mode 100644 index 0000000000..646da39158 --- /dev/null +++ b/pkg/apis/scheduling/util/BUILD @@ -0,0 +1,45 @@ +package(default_visibility = ["//visibility:public"]) + +load( + "@io_bazel_rules_go//go:def.bzl", + "go_library", + "go_test", +) + +go_library( + name = "go_default_library", + srcs = ["util.go"], + importpath = "k8s.io/kubernetes/pkg/apis/scheduling/util", + deps = [ + "//pkg/apis/scheduling:go_default_library", + "//pkg/features:go_default_library", + "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library", + ], +) + +filegroup( + name = "package-srcs", + srcs = glob(["**"]), + tags = ["automanaged"], + visibility = ["//visibility:private"], +) + +filegroup( + name = "all-srcs", + srcs = [":package-srcs"], + tags = ["automanaged"], +) + +go_test( + name = "go_default_test", + srcs = ["util_test.go"], + embed = [":go_default_library"], + deps = [ + "//pkg/apis/core:go_default_library", + "//pkg/apis/scheduling:go_default_library", + "//pkg/features:go_default_library", + "//staging/src/k8s.io/apimachinery/pkg/util/diff:go_default_library", + "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library", + "//staging/src/k8s.io/component-base/featuregate/testing:go_default_library", + ], +) diff --git a/pkg/apis/scheduling/util/util.go b/pkg/apis/scheduling/util/util.go new file mode 100644 index 0000000000..82fd50b03d --- /dev/null +++ b/pkg/apis/scheduling/util/util.go @@ -0,0 +1,40 @@ +/* +Copyright 2019 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package util + +import ( + utilfeature "k8s.io/apiserver/pkg/util/feature" + "k8s.io/kubernetes/pkg/apis/scheduling" + "k8s.io/kubernetes/pkg/features" +) + +// DropDisabledFields removes disabled fields from the PriorityClass object. +func DropDisabledFields(class, oldClass *scheduling.PriorityClass) { + if !utilfeature.DefaultFeatureGate.Enabled(features.NonPreemptingPriority) && !preemptingPriorityInUse(oldClass) { + class.PreemptionPolicy = nil + } +} + +func preemptingPriorityInUse(oldClass *scheduling.PriorityClass) bool { + if oldClass == nil { + return false + } + if oldClass.PreemptionPolicy != nil { + return true + } + return false +} diff --git a/pkg/apis/scheduling/util/util_test.go b/pkg/apis/scheduling/util/util_test.go new file mode 100644 index 0000000000..6c6bbabdbd --- /dev/null +++ b/pkg/apis/scheduling/util/util_test.go @@ -0,0 +1,109 @@ +/* +Copyright 2019 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package util + +import ( + "fmt" + "reflect" + "testing" + + "k8s.io/apimachinery/pkg/util/diff" + utilfeature "k8s.io/apiserver/pkg/util/feature" + featuregatetesting "k8s.io/component-base/featuregate/testing" + "k8s.io/kubernetes/pkg/apis/core" + "k8s.io/kubernetes/pkg/apis/scheduling" + "k8s.io/kubernetes/pkg/features" +) + +func TestDropNonPreemptingPriority(t *testing.T) { + pcWithoutNonPreemptingPriority := func() *scheduling.PriorityClass { + return &scheduling.PriorityClass{} + } + pcWithNonPreemptingPriority := func() *scheduling.PriorityClass { + preemptionPolicy := core.PreemptNever + return &scheduling.PriorityClass{ + PreemptionPolicy: &preemptionPolicy, + } + } + + pcInfo := []struct { + description string + hasNonPreemptingPriority bool + pc func() *scheduling.PriorityClass + }{ + { + description: "PriorityClass Without NonPreemptingPriority", + hasNonPreemptingPriority: false, + pc: pcWithoutNonPreemptingPriority, + }, + { + description: "PriorityClass With NonPreemptingPriority", + hasNonPreemptingPriority: true, + pc: pcWithNonPreemptingPriority, + }, + { + description: "is nil", + hasNonPreemptingPriority: false, + pc: func() *scheduling.PriorityClass { return nil }, + }, + } + + for _, enabled := range []bool{true, false} { + for _, oldPriorityClassInfo := range pcInfo { + for _, newPriorityClassInfo := range pcInfo { + oldPriorityClassHasNonPreemptingPriority, oldPriorityClass := oldPriorityClassInfo.hasNonPreemptingPriority, oldPriorityClassInfo.pc() + newPriorityClassHasNonPreemptingPriority, newPriorityClass := newPriorityClassInfo.hasNonPreemptingPriority, newPriorityClassInfo.pc() + if newPriorityClass == nil { + continue + } + + t.Run(fmt.Sprintf("feature enabled=%v, old PriorityClass %v, new PriorityClass %v", enabled, oldPriorityClassInfo.description, newPriorityClassInfo.description), func(t *testing.T) { + defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.NonPreemptingPriority, enabled)() + + DropDisabledFields(newPriorityClass, oldPriorityClass) + + // old PriorityClass should never be changed + if !reflect.DeepEqual(oldPriorityClass, oldPriorityClassInfo.pc()) { + t.Errorf("old PriorityClass changed: %v", diff.ObjectReflectDiff(oldPriorityClass, oldPriorityClassInfo.pc())) + } + + switch { + case enabled || oldPriorityClassHasNonPreemptingPriority: + // new PriorityClass should not be changed if the feature is enabled, or if the old PriorityClass had NonPreemptingPriority + if !reflect.DeepEqual(newPriorityClass, newPriorityClassInfo.pc()) { + t.Errorf("new PriorityClass changed: %v", diff.ObjectReflectDiff(newPriorityClass, newPriorityClassInfo.pc())) + } + case newPriorityClassHasNonPreemptingPriority: + // new PriorityClass should be changed + if reflect.DeepEqual(newPriorityClass, newPriorityClassInfo.pc()) { + t.Errorf("new PriorityClass was not changed") + } + // new PriorityClass should not have NonPreemptingPriority + if !reflect.DeepEqual(newPriorityClass, pcWithoutNonPreemptingPriority()) { + t.Errorf("new PriorityClass had PriorityClassNonPreemptingPriority: %v", diff.ObjectReflectDiff(newPriorityClass, pcWithoutNonPreemptingPriority())) + } + default: + // new PriorityClass should not need to be changed + if !reflect.DeepEqual(newPriorityClass, newPriorityClassInfo.pc()) { + t.Errorf("new PriorityClass changed: %v", diff.ObjectReflectDiff(newPriorityClass, newPriorityClassInfo.pc())) + } + } + }) + } + } + } +} diff --git a/pkg/apis/scheduling/v1/BUILD b/pkg/apis/scheduling/v1/BUILD index 1d04160703..9a88744d07 100644 --- a/pkg/apis/scheduling/v1/BUILD +++ b/pkg/apis/scheduling/v1/BUILD @@ -1,8 +1,9 @@ -load("@io_bazel_rules_go//go:def.bzl", "go_library") +load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test") go_library( name = "go_default_library", srcs = [ + "defaults.go", "doc.go", "register.go", "zz_generated.conversion.go", @@ -11,11 +12,15 @@ go_library( importpath = "k8s.io/kubernetes/pkg/apis/scheduling/v1", visibility = ["//visibility:public"], deps = [ + "//pkg/apis/core:go_default_library", "//pkg/apis/scheduling:go_default_library", + "//pkg/features:go_default_library", + "//staging/src/k8s.io/api/core/v1:go_default_library", "//staging/src/k8s.io/api/scheduling/v1:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/conversion:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/runtime/schema:go_default_library", + "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library", ], ) @@ -32,3 +37,19 @@ filegroup( tags = ["automanaged"], visibility = ["//visibility:public"], ) + +go_test( + name = "go_default_test", + srcs = ["defaults_test.go"], + embed = [":go_default_library"], + deps = [ + "//pkg/api/legacyscheme:go_default_library", + "//pkg/api/testapi:go_default_library", + "//pkg/features:go_default_library", + "//staging/src/k8s.io/api/core/v1:go_default_library", + "//staging/src/k8s.io/api/scheduling/v1:go_default_library", + "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library", + "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library", + "//staging/src/k8s.io/component-base/featuregate/testing:go_default_library", + ], +) diff --git a/pkg/apis/scheduling/v1/defaults.go b/pkg/apis/scheduling/v1/defaults.go new file mode 100644 index 0000000000..5da20cd3cd --- /dev/null +++ b/pkg/apis/scheduling/v1/defaults.go @@ -0,0 +1,38 @@ +/* +Copyright 2019 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1 + +import ( + apiv1 "k8s.io/api/core/v1" + "k8s.io/api/scheduling/v1" + "k8s.io/apimachinery/pkg/runtime" + utilfeature "k8s.io/apiserver/pkg/util/feature" + "k8s.io/kubernetes/pkg/features" +) + +func addDefaultingFuncs(scheme *runtime.Scheme) error { + return RegisterDefaults(scheme) +} + +// SetDefaults_PriorityClass sets additional defaults compared to its counterpart +// in extensions. +func SetDefaults_PriorityClass(obj *v1.PriorityClass) { + if utilfeature.DefaultFeatureGate.Enabled(features.NonPreemptingPriority) && obj.PreemptionPolicy == nil { + preemptLowerPriority := apiv1.PreemptLowerPriority + obj.PreemptionPolicy = &preemptLowerPriority + } +} diff --git a/pkg/apis/scheduling/v1/defaults_test.go b/pkg/apis/scheduling/v1/defaults_test.go new file mode 100644 index 0000000000..129d069be5 --- /dev/null +++ b/pkg/apis/scheduling/v1/defaults_test.go @@ -0,0 +1,66 @@ +/* +Copyright 2019 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1_test + +import ( + "reflect" + "testing" + + "k8s.io/api/scheduling/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/kubernetes/pkg/api/legacyscheme" + + apiv1 "k8s.io/api/core/v1" + utilfeature "k8s.io/apiserver/pkg/util/feature" + featuregatetesting "k8s.io/component-base/featuregate/testing" + // enforce that all types are installed + _ "k8s.io/kubernetes/pkg/api/testapi" + "k8s.io/kubernetes/pkg/features" +) + +func roundTrip(t *testing.T, obj runtime.Object) runtime.Object { + codec := legacyscheme.Codecs.LegacyCodec(v1.SchemeGroupVersion) + data, err := runtime.Encode(codec, obj) + if err != nil { + t.Errorf("%v\n %#v", err, obj) + return nil + } + obj2, err := runtime.Decode(codec, data) + if err != nil { + t.Errorf("%v\nData: %s\nSource: %#v", err, string(data), obj) + return nil + } + obj3 := reflect.New(reflect.TypeOf(obj).Elem()).Interface().(runtime.Object) + err = legacyscheme.Scheme.Convert(obj2, obj3, nil) + if err != nil { + t.Errorf("%v\nSource: %#v", err, obj2) + return nil + } + return obj3 +} + +func TestSetDefaultPreemptionPolicy(t *testing.T) { + priorityClass := &v1.PriorityClass{} + + // set NonPreemptingPriority true + defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.NonPreemptingPriority, true)() + + output := roundTrip(t, runtime.Object(priorityClass)).(*v1.PriorityClass) + if output.PreemptionPolicy == nil || *output.PreemptionPolicy != apiv1.PreemptLowerPriority { + t.Errorf("Expected PriorityClass.PreemptionPolicy value: %+v\ngot: %+v\n", apiv1.PreemptLowerPriority, output.PreemptionPolicy) + } +} diff --git a/pkg/apis/scheduling/v1/register.go b/pkg/apis/scheduling/v1/register.go index 8a16540758..e4dfca8c6f 100644 --- a/pkg/apis/scheduling/v1/register.go +++ b/pkg/apis/scheduling/v1/register.go @@ -42,5 +42,5 @@ func init() { // We only register manually written functions here. The registration of the // generated functions takes place in the generated files. The separation // makes the code compile even when the generated files are missing. - localSchemeBuilder.Register(RegisterDefaults) + localSchemeBuilder.Register(addDefaultingFuncs) } diff --git a/pkg/apis/scheduling/v1/zz_generated.conversion.go b/pkg/apis/scheduling/v1/zz_generated.conversion.go index a7d90b7ffe..495c3a3458 100644 --- a/pkg/apis/scheduling/v1/zz_generated.conversion.go +++ b/pkg/apis/scheduling/v1/zz_generated.conversion.go @@ -23,9 +23,11 @@ package v1 import ( unsafe "unsafe" + corev1 "k8s.io/api/core/v1" v1 "k8s.io/api/scheduling/v1" conversion "k8s.io/apimachinery/pkg/conversion" runtime "k8s.io/apimachinery/pkg/runtime" + core "k8s.io/kubernetes/pkg/apis/core" scheduling "k8s.io/kubernetes/pkg/apis/scheduling" ) @@ -64,6 +66,7 @@ func autoConvert_v1_PriorityClass_To_scheduling_PriorityClass(in *v1.PriorityCla out.Value = in.Value out.GlobalDefault = in.GlobalDefault out.Description = in.Description + out.PreemptionPolicy = (*core.PreemptionPolicy)(unsafe.Pointer(in.PreemptionPolicy)) return nil } @@ -77,6 +80,7 @@ func autoConvert_scheduling_PriorityClass_To_v1_PriorityClass(in *scheduling.Pri out.Value = in.Value out.GlobalDefault = in.GlobalDefault out.Description = in.Description + out.PreemptionPolicy = (*corev1.PreemptionPolicy)(unsafe.Pointer(in.PreemptionPolicy)) return nil } diff --git a/pkg/apis/scheduling/v1/zz_generated.defaults.go b/pkg/apis/scheduling/v1/zz_generated.defaults.go index cce2e603a6..4e502b516b 100644 --- a/pkg/apis/scheduling/v1/zz_generated.defaults.go +++ b/pkg/apis/scheduling/v1/zz_generated.defaults.go @@ -21,6 +21,7 @@ limitations under the License. package v1 import ( + v1 "k8s.io/api/scheduling/v1" runtime "k8s.io/apimachinery/pkg/runtime" ) @@ -28,5 +29,18 @@ import ( // Public to allow building arbitrary schemes. // All generated defaulters are covering - they call all nested defaulters. func RegisterDefaults(scheme *runtime.Scheme) error { + scheme.AddTypeDefaultingFunc(&v1.PriorityClass{}, func(obj interface{}) { SetObjectDefaults_PriorityClass(obj.(*v1.PriorityClass)) }) + scheme.AddTypeDefaultingFunc(&v1.PriorityClassList{}, func(obj interface{}) { SetObjectDefaults_PriorityClassList(obj.(*v1.PriorityClassList)) }) return nil } + +func SetObjectDefaults_PriorityClass(in *v1.PriorityClass) { + SetDefaults_PriorityClass(in) +} + +func SetObjectDefaults_PriorityClassList(in *v1.PriorityClassList) { + for i := range in.Items { + a := &in.Items[i] + SetObjectDefaults_PriorityClass(a) + } +} diff --git a/pkg/apis/scheduling/v1alpha1/BUILD b/pkg/apis/scheduling/v1alpha1/BUILD index e30497cde3..fb59ce663d 100644 --- a/pkg/apis/scheduling/v1alpha1/BUILD +++ b/pkg/apis/scheduling/v1alpha1/BUILD @@ -1,13 +1,11 @@ package(default_visibility = ["//visibility:public"]) -load( - "@io_bazel_rules_go//go:def.bzl", - "go_library", -) +load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test") go_library( name = "go_default_library", srcs = [ + "defaults.go", "doc.go", "register.go", "zz_generated.conversion.go", @@ -15,11 +13,15 @@ go_library( ], importpath = "k8s.io/kubernetes/pkg/apis/scheduling/v1alpha1", deps = [ + "//pkg/apis/core:go_default_library", "//pkg/apis/scheduling:go_default_library", + "//pkg/features:go_default_library", + "//staging/src/k8s.io/api/core/v1:go_default_library", "//staging/src/k8s.io/api/scheduling/v1alpha1:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/conversion:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/runtime/schema:go_default_library", + "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library", ], ) @@ -35,3 +37,19 @@ filegroup( srcs = [":package-srcs"], tags = ["automanaged"], ) + +go_test( + name = "go_default_test", + srcs = ["defaults_test.go"], + embed = [":go_default_library"], + deps = [ + "//pkg/api/legacyscheme:go_default_library", + "//pkg/api/testapi:go_default_library", + "//pkg/features:go_default_library", + "//staging/src/k8s.io/api/core/v1:go_default_library", + "//staging/src/k8s.io/api/scheduling/v1alpha1:go_default_library", + "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library", + "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library", + "//staging/src/k8s.io/component-base/featuregate/testing:go_default_library", + ], +) diff --git a/pkg/apis/scheduling/v1alpha1/defaults.go b/pkg/apis/scheduling/v1alpha1/defaults.go new file mode 100644 index 0000000000..41327f5fdc --- /dev/null +++ b/pkg/apis/scheduling/v1alpha1/defaults.go @@ -0,0 +1,38 @@ +/* +Copyright 2019 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1alpha1 + +import ( + apiv1 "k8s.io/api/core/v1" + "k8s.io/api/scheduling/v1alpha1" + "k8s.io/apimachinery/pkg/runtime" + utilfeature "k8s.io/apiserver/pkg/util/feature" + "k8s.io/kubernetes/pkg/features" +) + +func addDefaultingFuncs(scheme *runtime.Scheme) error { + return RegisterDefaults(scheme) +} + +// SetDefaults_PriorityClass sets additional defaults compared to its counterpart +// in extensions. +func SetDefaults_PriorityClass(obj *v1alpha1.PriorityClass) { + if utilfeature.DefaultFeatureGate.Enabled(features.NonPreemptingPriority) && obj.PreemptionPolicy == nil { + preemptLowerPriority := apiv1.PreemptLowerPriority + obj.PreemptionPolicy = &preemptLowerPriority + } +} diff --git a/pkg/apis/scheduling/v1alpha1/defaults_test.go b/pkg/apis/scheduling/v1alpha1/defaults_test.go new file mode 100644 index 0000000000..574b464542 --- /dev/null +++ b/pkg/apis/scheduling/v1alpha1/defaults_test.go @@ -0,0 +1,66 @@ +/* +Copyright 2019 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1alpha1_test + +import ( + "reflect" + "testing" + + "k8s.io/api/scheduling/v1alpha1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/kubernetes/pkg/api/legacyscheme" + + apiv1 "k8s.io/api/core/v1" + utilfeature "k8s.io/apiserver/pkg/util/feature" + featuregatetesting "k8s.io/component-base/featuregate/testing" + // enforce that all types are installed + _ "k8s.io/kubernetes/pkg/api/testapi" + "k8s.io/kubernetes/pkg/features" +) + +func roundTrip(t *testing.T, obj runtime.Object) runtime.Object { + codec := legacyscheme.Codecs.LegacyCodec(v1alpha1.SchemeGroupVersion) + data, err := runtime.Encode(codec, obj) + if err != nil { + t.Errorf("%v\n %#v", err, obj) + return nil + } + obj2, err := runtime.Decode(codec, data) + if err != nil { + t.Errorf("%v\nData: %s\nSource: %#v", err, string(data), obj) + return nil + } + obj3 := reflect.New(reflect.TypeOf(obj).Elem()).Interface().(runtime.Object) + err = legacyscheme.Scheme.Convert(obj2, obj3, nil) + if err != nil { + t.Errorf("%v\nSource: %#v", err, obj2) + return nil + } + return obj3 +} + +func TestSetDefaultPreempting(t *testing.T) { + priorityClass := &v1alpha1.PriorityClass{} + + // set NonPreemptingPriority true + defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.NonPreemptingPriority, true)() + + output := roundTrip(t, runtime.Object(priorityClass)).(*v1alpha1.PriorityClass) + if output.PreemptionPolicy == nil || *output.PreemptionPolicy != apiv1.PreemptLowerPriority { + t.Errorf("Expected PriorityClass.Preempting value: %+v\ngot: %+v\n", apiv1.PreemptLowerPriority, output.PreemptionPolicy) + } +} diff --git a/pkg/apis/scheduling/v1alpha1/zz_generated.conversion.go b/pkg/apis/scheduling/v1alpha1/zz_generated.conversion.go index cfa6617d5b..dfcb61abcb 100644 --- a/pkg/apis/scheduling/v1alpha1/zz_generated.conversion.go +++ b/pkg/apis/scheduling/v1alpha1/zz_generated.conversion.go @@ -23,9 +23,11 @@ package v1alpha1 import ( unsafe "unsafe" + v1 "k8s.io/api/core/v1" v1alpha1 "k8s.io/api/scheduling/v1alpha1" conversion "k8s.io/apimachinery/pkg/conversion" runtime "k8s.io/apimachinery/pkg/runtime" + core "k8s.io/kubernetes/pkg/apis/core" scheduling "k8s.io/kubernetes/pkg/apis/scheduling" ) @@ -64,6 +66,7 @@ func autoConvert_v1alpha1_PriorityClass_To_scheduling_PriorityClass(in *v1alpha1 out.Value = in.Value out.GlobalDefault = in.GlobalDefault out.Description = in.Description + out.PreemptionPolicy = (*core.PreemptionPolicy)(unsafe.Pointer(in.PreemptionPolicy)) return nil } @@ -77,6 +80,7 @@ func autoConvert_scheduling_PriorityClass_To_v1alpha1_PriorityClass(in *scheduli out.Value = in.Value out.GlobalDefault = in.GlobalDefault out.Description = in.Description + out.PreemptionPolicy = (*v1.PreemptionPolicy)(unsafe.Pointer(in.PreemptionPolicy)) return nil } diff --git a/pkg/apis/scheduling/v1alpha1/zz_generated.defaults.go b/pkg/apis/scheduling/v1alpha1/zz_generated.defaults.go index dd621a3acd..84c4876661 100644 --- a/pkg/apis/scheduling/v1alpha1/zz_generated.defaults.go +++ b/pkg/apis/scheduling/v1alpha1/zz_generated.defaults.go @@ -21,6 +21,7 @@ limitations under the License. package v1alpha1 import ( + v1alpha1 "k8s.io/api/scheduling/v1alpha1" runtime "k8s.io/apimachinery/pkg/runtime" ) @@ -28,5 +29,18 @@ import ( // Public to allow building arbitrary schemes. // All generated defaulters are covering - they call all nested defaulters. func RegisterDefaults(scheme *runtime.Scheme) error { + scheme.AddTypeDefaultingFunc(&v1alpha1.PriorityClass{}, func(obj interface{}) { SetObjectDefaults_PriorityClass(obj.(*v1alpha1.PriorityClass)) }) + scheme.AddTypeDefaultingFunc(&v1alpha1.PriorityClassList{}, func(obj interface{}) { SetObjectDefaults_PriorityClassList(obj.(*v1alpha1.PriorityClassList)) }) return nil } + +func SetObjectDefaults_PriorityClass(in *v1alpha1.PriorityClass) { + SetDefaults_PriorityClass(in) +} + +func SetObjectDefaults_PriorityClassList(in *v1alpha1.PriorityClassList) { + for i := range in.Items { + a := &in.Items[i] + SetObjectDefaults_PriorityClass(a) + } +} diff --git a/pkg/apis/scheduling/v1beta1/BUILD b/pkg/apis/scheduling/v1beta1/BUILD index ab1cfa74ff..ac56ec19ad 100644 --- a/pkg/apis/scheduling/v1beta1/BUILD +++ b/pkg/apis/scheduling/v1beta1/BUILD @@ -1,13 +1,11 @@ package(default_visibility = ["//visibility:public"]) -load( - "@io_bazel_rules_go//go:def.bzl", - "go_library", -) +load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test") go_library( name = "go_default_library", srcs = [ + "defaults.go", "doc.go", "register.go", "zz_generated.conversion.go", @@ -15,11 +13,15 @@ go_library( ], importpath = "k8s.io/kubernetes/pkg/apis/scheduling/v1beta1", deps = [ + "//pkg/apis/core:go_default_library", "//pkg/apis/scheduling:go_default_library", + "//pkg/features:go_default_library", + "//staging/src/k8s.io/api/core/v1:go_default_library", "//staging/src/k8s.io/api/scheduling/v1beta1:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/conversion:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/runtime/schema:go_default_library", + "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library", ], ) @@ -35,3 +37,19 @@ filegroup( srcs = [":package-srcs"], tags = ["automanaged"], ) + +go_test( + name = "go_default_test", + srcs = ["defaults_test.go"], + embed = [":go_default_library"], + deps = [ + "//pkg/api/legacyscheme:go_default_library", + "//pkg/api/testapi:go_default_library", + "//pkg/features:go_default_library", + "//staging/src/k8s.io/api/core/v1:go_default_library", + "//staging/src/k8s.io/api/scheduling/v1beta1:go_default_library", + "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library", + "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library", + "//staging/src/k8s.io/component-base/featuregate/testing:go_default_library", + ], +) diff --git a/pkg/apis/scheduling/v1beta1/defaults.go b/pkg/apis/scheduling/v1beta1/defaults.go new file mode 100644 index 0000000000..c35594e4c1 --- /dev/null +++ b/pkg/apis/scheduling/v1beta1/defaults.go @@ -0,0 +1,38 @@ +/* +Copyright 2019 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1beta1 + +import ( + apiv1 "k8s.io/api/core/v1" + "k8s.io/api/scheduling/v1beta1" + "k8s.io/apimachinery/pkg/runtime" + utilfeature "k8s.io/apiserver/pkg/util/feature" + "k8s.io/kubernetes/pkg/features" +) + +func addDefaultingFuncs(scheme *runtime.Scheme) error { + return RegisterDefaults(scheme) +} + +// SetDefaults_PriorityClass sets additional defaults compared to its counterpart +// in extensions. +func SetDefaults_PriorityClass(obj *v1beta1.PriorityClass) { + if utilfeature.DefaultFeatureGate.Enabled(features.NonPreemptingPriority) && obj.PreemptionPolicy == nil { + preemptLowerPriority := apiv1.PreemptLowerPriority + obj.PreemptionPolicy = &preemptLowerPriority + } +} diff --git a/pkg/apis/scheduling/v1beta1/defaults_test.go b/pkg/apis/scheduling/v1beta1/defaults_test.go new file mode 100644 index 0000000000..f758a717eb --- /dev/null +++ b/pkg/apis/scheduling/v1beta1/defaults_test.go @@ -0,0 +1,66 @@ +/* +Copyright 2019 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1beta1_test + +import ( + "reflect" + "testing" + + "k8s.io/api/scheduling/v1beta1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/kubernetes/pkg/api/legacyscheme" + + apiv1 "k8s.io/api/core/v1" + utilfeature "k8s.io/apiserver/pkg/util/feature" + featuregatetesting "k8s.io/component-base/featuregate/testing" + // enforce that all types are installed + _ "k8s.io/kubernetes/pkg/api/testapi" + "k8s.io/kubernetes/pkg/features" +) + +func roundTrip(t *testing.T, obj runtime.Object) runtime.Object { + codec := legacyscheme.Codecs.LegacyCodec(v1beta1.SchemeGroupVersion) + data, err := runtime.Encode(codec, obj) + if err != nil { + t.Errorf("%v\n %#v", err, obj) + return nil + } + obj2, err := runtime.Decode(codec, data) + if err != nil { + t.Errorf("%v\nData: %s\nSource: %#v", err, string(data), obj) + return nil + } + obj3 := reflect.New(reflect.TypeOf(obj).Elem()).Interface().(runtime.Object) + err = legacyscheme.Scheme.Convert(obj2, obj3, nil) + if err != nil { + t.Errorf("%v\nSource: %#v", err, obj2) + return nil + } + return obj3 +} + +func TestSetDefaultPreempting(t *testing.T) { + priorityClass := &v1beta1.PriorityClass{} + + // set NonPreemptingPriority true + defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.NonPreemptingPriority, true)() + + output := roundTrip(t, runtime.Object(priorityClass)).(*v1beta1.PriorityClass) + if output.PreemptionPolicy == nil || *output.PreemptionPolicy != apiv1.PreemptLowerPriority { + t.Errorf("Expected PriorityClass.Preempting value: %+v\ngot: %+v\n", apiv1.PreemptLowerPriority, output.PreemptionPolicy) + } +} diff --git a/pkg/apis/scheduling/v1beta1/zz_generated.conversion.go b/pkg/apis/scheduling/v1beta1/zz_generated.conversion.go index b2e3f28663..d06661e826 100644 --- a/pkg/apis/scheduling/v1beta1/zz_generated.conversion.go +++ b/pkg/apis/scheduling/v1beta1/zz_generated.conversion.go @@ -23,9 +23,11 @@ package v1beta1 import ( unsafe "unsafe" + v1 "k8s.io/api/core/v1" v1beta1 "k8s.io/api/scheduling/v1beta1" conversion "k8s.io/apimachinery/pkg/conversion" runtime "k8s.io/apimachinery/pkg/runtime" + core "k8s.io/kubernetes/pkg/apis/core" scheduling "k8s.io/kubernetes/pkg/apis/scheduling" ) @@ -64,6 +66,7 @@ func autoConvert_v1beta1_PriorityClass_To_scheduling_PriorityClass(in *v1beta1.P out.Value = in.Value out.GlobalDefault = in.GlobalDefault out.Description = in.Description + out.PreemptionPolicy = (*core.PreemptionPolicy)(unsafe.Pointer(in.PreemptionPolicy)) return nil } @@ -77,6 +80,7 @@ func autoConvert_scheduling_PriorityClass_To_v1beta1_PriorityClass(in *schedulin out.Value = in.Value out.GlobalDefault = in.GlobalDefault out.Description = in.Description + out.PreemptionPolicy = (*v1.PreemptionPolicy)(unsafe.Pointer(in.PreemptionPolicy)) return nil } diff --git a/pkg/apis/scheduling/v1beta1/zz_generated.defaults.go b/pkg/apis/scheduling/v1beta1/zz_generated.defaults.go index 73e63fc114..a134b3b598 100644 --- a/pkg/apis/scheduling/v1beta1/zz_generated.defaults.go +++ b/pkg/apis/scheduling/v1beta1/zz_generated.defaults.go @@ -21,6 +21,7 @@ limitations under the License. package v1beta1 import ( + v1beta1 "k8s.io/api/scheduling/v1beta1" runtime "k8s.io/apimachinery/pkg/runtime" ) @@ -28,5 +29,18 @@ import ( // Public to allow building arbitrary schemes. // All generated defaulters are covering - they call all nested defaulters. func RegisterDefaults(scheme *runtime.Scheme) error { + scheme.AddTypeDefaultingFunc(&v1beta1.PriorityClass{}, func(obj interface{}) { SetObjectDefaults_PriorityClass(obj.(*v1beta1.PriorityClass)) }) + scheme.AddTypeDefaultingFunc(&v1beta1.PriorityClassList{}, func(obj interface{}) { SetObjectDefaults_PriorityClassList(obj.(*v1beta1.PriorityClassList)) }) return nil } + +func SetObjectDefaults_PriorityClass(in *v1beta1.PriorityClass) { + SetDefaults_PriorityClass(in) +} + +func SetObjectDefaults_PriorityClassList(in *v1beta1.PriorityClassList) { + for i := range in.Items { + a := &in.Items[i] + SetObjectDefaults_PriorityClass(a) + } +} diff --git a/pkg/apis/scheduling/validation/validation.go b/pkg/apis/scheduling/validation/validation.go index 5b2fcaeb99..80aee8233b 100644 --- a/pkg/apis/scheduling/validation/validation.go +++ b/pkg/apis/scheduling/validation/validation.go @@ -41,6 +41,9 @@ func ValidatePriorityClass(pc *scheduling.PriorityClass) field.ErrorList { // Non-system critical priority classes are not allowed to have a value larger than HighestUserDefinablePriority. allErrs = append(allErrs, field.Forbidden(field.NewPath("value"), fmt.Sprintf("maximum allowed value of a user defined priority is %v", scheduling.HighestUserDefinablePriority))) } + if pc.PreemptionPolicy != nil { + allErrs = append(allErrs, apivalidation.ValidatePreemptionPolicy(pc.PreemptionPolicy, field.NewPath("preemptionPolicy"))...) + } return allErrs } @@ -52,5 +55,7 @@ func ValidatePriorityClassUpdate(pc, oldPc *scheduling.PriorityClass) field.Erro if pc.Value != oldPc.Value { allErrs = append(allErrs, field.Forbidden(field.NewPath("Value"), "may not be changed in an update.")) } + // PreemptionPolicy is immutable and is checked by the ObjectMeta validator. + allErrs = append(allErrs, apivalidation.ValidateImmutableField(pc.PreemptionPolicy, oldPc.PreemptionPolicy, field.NewPath("preemptionPolicy"))...) return allErrs } diff --git a/pkg/apis/scheduling/zz_generated.deepcopy.go b/pkg/apis/scheduling/zz_generated.deepcopy.go index 6105680cae..43ff21471c 100644 --- a/pkg/apis/scheduling/zz_generated.deepcopy.go +++ b/pkg/apis/scheduling/zz_generated.deepcopy.go @@ -22,6 +22,7 @@ package scheduling import ( runtime "k8s.io/apimachinery/pkg/runtime" + core "k8s.io/kubernetes/pkg/apis/core" ) // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. @@ -29,6 +30,11 @@ func (in *PriorityClass) DeepCopyInto(out *PriorityClass) { *out = *in out.TypeMeta = in.TypeMeta in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + if in.PreemptionPolicy != nil { + in, out := &in.PreemptionPolicy, &out.PreemptionPolicy + *out = new(core.PreemptionPolicy) + **out = **in + } return } diff --git a/pkg/controller/.import-restrictions b/pkg/controller/.import-restrictions index ad130f6dad..a47e51a2b1 100644 --- a/pkg/controller/.import-restrictions +++ b/pkg/controller/.import-restrictions @@ -83,7 +83,8 @@ "k8s.io/api/admission/v1beta1", "k8s.io/api/networking/v1", "k8s.io/component-base/config", - "k8s.io/component-base/config/v1alpha1" + "k8s.io/component-base/config/v1alpha1", + "k8s.io/api/scheduling/v1" ] }, { diff --git a/pkg/features/kube_features.go b/pkg/features/kube_features.go index c70e965c15..20fc26e2cb 100644 --- a/pkg/features/kube_features.go +++ b/pkg/features/kube_features.go @@ -459,6 +459,12 @@ const ( // Allow use of filesystems for ephemeral storage monitoring. // Only applies if LocalStorageCapacityIsolation is set. LocalStorageCapacityIsolationFSQuotaMonitoring featuregate.Feature = "LocalStorageCapacityIsolationFSQuotaMonitoring" + + // owner: @denkensk + // alpha: v1.15 + // + // Enables NonPreempting option for priorityClass and pod. + NonPreemptingPriority featuregate.Feature = "NonPreemptingPriority" ) func init() { @@ -536,6 +542,7 @@ var defaultKubernetesFeatureGates = map[featuregate.Feature]featuregate.FeatureS KubeletPodResources: {Default: false, PreRelease: featuregate.Alpha}, WindowsGMSA: {Default: false, PreRelease: featuregate.Alpha}, LocalStorageCapacityIsolationFSQuotaMonitoring: {Default: false, PreRelease: featuregate.Alpha}, + NonPreemptingPriority: {Default: false, PreRelease: featuregate.Alpha}, // inherited features from generic apiserver, relisted here to get a conflict if it is changed // unintentionally on either side: diff --git a/pkg/kubectl/cmd/create/create_priorityclass.go b/pkg/kubectl/cmd/create/create_priorityclass.go index 7555593763..7ea86b3352 100644 --- a/pkg/kubectl/cmd/create/create_priorityclass.go +++ b/pkg/kubectl/cmd/create/create_priorityclass.go @@ -19,6 +19,7 @@ package create import ( "github.com/spf13/cobra" + apiv1 "k8s.io/api/core/v1" "k8s.io/cli-runtime/pkg/genericclioptions" cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util" "k8s.io/kubernetes/pkg/kubectl/generate" @@ -36,7 +37,10 @@ var ( kubectl create priorityclass high-priority --value=1000 --description="high priority" # Create a priorityclass named default-priority that considered as the global default priority - kubectl create priorityclass default-priority --value=1000 --global-default=true --description="default priority"`)) + kubectl create priorityclass default-priority --value=1000 --global-default=true --description="default priority" + + # Create a priorityclass named high-priority that can not preempt pods with lower priority + kubectl create priorityclass high-priority --value=1000 --description="high priority" --preemption-policy="Never"`)) ) // PriorityClassOpts holds the options for 'create priorityclass' sub command @@ -67,11 +71,12 @@ func NewCmdCreatePriorityClass(f cmdutil.Factory, ioStreams genericclioptions.IO cmdutil.AddApplyAnnotationFlags(cmd) cmdutil.AddValidateFlags(cmd) - cmdutil.AddGeneratorFlags(cmd, generateversioned.PriorityClassV1Alpha1GeneratorName) + cmdutil.AddGeneratorFlags(cmd, generateversioned.PriorityClassV1GeneratorName) cmd.Flags().Int32("value", 0, i18n.T("the value of this priority class.")) cmd.Flags().Bool("global-default", false, i18n.T("global-default specifies whether this PriorityClass should be considered as the default priority.")) cmd.Flags().String("description", "", i18n.T("description is an arbitrary string that usually provides guidelines on when this priority class should be used.")) + cmd.Flags().String("preemption-policy", "", i18n.T("preemption-policy is the policy for preempting pods with lower priority.")) return cmd } @@ -84,12 +89,13 @@ func (o *PriorityClassOpts) Complete(f cmdutil.Factory, cmd *cobra.Command, args var generator generate.StructuredGenerator switch generatorName := cmdutil.GetFlagString(cmd, "generator"); generatorName { - case generateversioned.PriorityClassV1Alpha1GeneratorName: + case generateversioned.PriorityClassV1GeneratorName: generator = &generateversioned.PriorityClassV1Generator{ - Name: name, - Value: cmdutil.GetFlagInt32(cmd, "value"), - GlobalDefault: cmdutil.GetFlagBool(cmd, "global-default"), - Description: cmdutil.GetFlagString(cmd, "description"), + Name: name, + Value: cmdutil.GetFlagInt32(cmd, "value"), + GlobalDefault: cmdutil.GetFlagBool(cmd, "global-default"), + Description: cmdutil.GetFlagString(cmd, "description"), + PreemptionPolicy: apiv1.PreemptionPolicy(cmdutil.GetFlagString(cmd, "preemption-policy")), } default: return errUnsupportedGenerator(cmd, generatorName) diff --git a/pkg/kubectl/cmd/create/create_priorityclass_test.go b/pkg/kubectl/cmd/create/create_priorityclass_test.go index e437ab71d7..3fdf719756 100644 --- a/pkg/kubectl/cmd/create/create_priorityclass_test.go +++ b/pkg/kubectl/cmd/create/create_priorityclass_test.go @@ -58,6 +58,7 @@ func TestCreatePriorityClass(t *testing.T) { cmd.Flags().Set("description", "my priority") cmd.Flags().Set("dry-run", "true") cmd.Flags().Set("output", outputFormat) + cmd.Flags().Set("preemption-policy", "Never") printFlags := genericclioptions.NewPrintFlags("created").WithTypeSetter(scheme.Scheme) printFlags.OutputFormat = &outputFormat diff --git a/pkg/kubectl/generate/versioned/generator.go b/pkg/kubectl/generate/versioned/generator.go index 01d0e21d5a..f0a6d6aba1 100644 --- a/pkg/kubectl/generate/versioned/generator.go +++ b/pkg/kubectl/generate/versioned/generator.go @@ -69,6 +69,8 @@ const ( PodDisruptionBudgetV1GeneratorName = "poddisruptionbudget/v1beta1" PodDisruptionBudgetV2GeneratorName = "poddisruptionbudget/v1beta1/v2" PriorityClassV1Alpha1GeneratorName = "priorityclass/v1alpha1" + PriorityClassV1Beta1GeneratorName = "priorityclass/v1beta1" + PriorityClassV1GeneratorName = "priorityclass/v1" ) // DefaultGenerators returns the set of default generators for use in Factory instances diff --git a/pkg/kubectl/generate/versioned/priorityclass.go b/pkg/kubectl/generate/versioned/priorityclass.go index 6e6684185a..a141d21966 100644 --- a/pkg/kubectl/generate/versioned/priorityclass.go +++ b/pkg/kubectl/generate/versioned/priorityclass.go @@ -19,6 +19,7 @@ package versioned import ( "fmt" + apiv1 "k8s.io/api/core/v1" scheduling "k8s.io/api/scheduling/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" @@ -27,10 +28,11 @@ import ( // PriorityClassV1Generator supports stable generation of a priorityClass. type PriorityClassV1Generator struct { - Name string - Value int32 - GlobalDefault bool - Description string + Name string + Value int32 + GlobalDefault bool + Description string + PreemptionPolicy apiv1.PreemptionPolicy } // Ensure it supports the generator pattern that uses parameters specified during construction. @@ -42,6 +44,7 @@ func (PriorityClassV1Generator) ParamNames() []generate.GeneratorParam { {Name: "value", Required: true}, {Name: "global-default", Required: false}, {Name: "description", Required: false}, + {Name: "preemption-policy", Required: false}, } } @@ -69,7 +72,10 @@ func (s PriorityClassV1Generator) Generate(params map[string]interface{}) (runti if !found { return nil, fmt.Errorf("expected string, found %v", description) } - delegate := &PriorityClassV1Generator{Name: name, Value: value, GlobalDefault: globalDefault, Description: description} + + preemptionPolicy := apiv1.PreemptionPolicy(params["preemption-policy"].(string)) + + delegate := &PriorityClassV1Generator{Name: name, Value: value, GlobalDefault: globalDefault, Description: description, PreemptionPolicy: preemptionPolicy} return delegate.StructuredGenerate() } @@ -79,8 +85,9 @@ func (s *PriorityClassV1Generator) StructuredGenerate() (runtime.Object, error) ObjectMeta: metav1.ObjectMeta{ Name: s.Name, }, - Value: s.Value, - GlobalDefault: s.GlobalDefault, - Description: s.Description, + Value: s.Value, + GlobalDefault: s.GlobalDefault, + Description: s.Description, + PreemptionPolicy: &s.PreemptionPolicy, }, nil } diff --git a/pkg/kubectl/generate/versioned/priorityclass_test.go b/pkg/kubectl/generate/versioned/priorityclass_test.go index f947e75f93..968a53ad9a 100644 --- a/pkg/kubectl/generate/versioned/priorityclass_test.go +++ b/pkg/kubectl/generate/versioned/priorityclass_test.go @@ -17,6 +17,7 @@ limitations under the License. package versioned import ( + apiv1 "k8s.io/api/core/v1" scheduling "k8s.io/api/scheduling/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -25,6 +26,10 @@ import ( ) func TestPriorityClassV1Generator(t *testing.T) { + var ( + preemptLowerPriority = apiv1.PreemptLowerPriority + preemptNever = apiv1.PreemptNever + ) tests := []struct { name string params map[string]interface{} @@ -34,45 +39,70 @@ func TestPriorityClassV1Generator(t *testing.T) { { name: "test valid case", params: map[string]interface{}{ - "name": "foo", - "value": int32(1000), - "global-default": false, - "description": "high priority class", + "name": "foo", + "value": int32(1000), + "global-default": false, + "description": "high priority class", + "preemption-policy": "PreemptLowerPriority", }, expected: &scheduling.PriorityClass{ ObjectMeta: metav1.ObjectMeta{ Name: "foo", }, - Value: int32(1000), - GlobalDefault: false, - Description: "high priority class", + Value: int32(1000), + GlobalDefault: false, + Description: "high priority class", + PreemptionPolicy: &preemptLowerPriority, + }, + expectErr: false, + }, + { + name: "test valid case that field non-preempting is set", + params: map[string]interface{}{ + "name": "foo", + "value": int32(1000), + "global-default": false, + "description": "high priority class", + "preemption-policy": "Never", + }, + expected: &scheduling.PriorityClass{ + ObjectMeta: metav1.ObjectMeta{ + Name: "foo", + }, + Value: int32(1000), + GlobalDefault: false, + Description: "high priority class", + PreemptionPolicy: &preemptNever, }, expectErr: false, }, { name: "test valid case that as default priority", params: map[string]interface{}{ - "name": "foo", - "value": int32(1000), - "global-default": true, - "description": "high priority class", + "name": "foo", + "value": int32(1000), + "global-default": true, + "description": "high priority class", + "preemption-policy": "PreemptLowerPriority", }, expected: &scheduling.PriorityClass{ ObjectMeta: metav1.ObjectMeta{ Name: "foo", }, - Value: int32(1000), - GlobalDefault: true, - Description: "high priority class", + Value: int32(1000), + GlobalDefault: true, + Description: "high priority class", + PreemptionPolicy: &preemptLowerPriority, }, expectErr: false, }, { name: "test missing required param", params: map[string]interface{}{ - "name": "foo", - "global-default": true, - "description": "high priority class", + "name": "foo", + "global-default": true, + "description": "high priority class", + "preemption-policy": "PreemptLowerPriority", }, expectErr: true, }, diff --git a/pkg/registry/scheduling/priorityclass/BUILD b/pkg/registry/scheduling/priorityclass/BUILD index 1140ceeab6..0616258142 100644 --- a/pkg/registry/scheduling/priorityclass/BUILD +++ b/pkg/registry/scheduling/priorityclass/BUILD @@ -27,6 +27,7 @@ go_library( deps = [ "//pkg/api/legacyscheme:go_default_library", "//pkg/apis/scheduling:go_default_library", + "//pkg/apis/scheduling/util:go_default_library", "//pkg/apis/scheduling/validation:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/util/validation/field:go_default_library", diff --git a/pkg/registry/scheduling/priorityclass/strategy.go b/pkg/registry/scheduling/priorityclass/strategy.go index 3a763d6bf2..0a3a9cf67d 100644 --- a/pkg/registry/scheduling/priorityclass/strategy.go +++ b/pkg/registry/scheduling/priorityclass/strategy.go @@ -24,6 +24,7 @@ import ( "k8s.io/apiserver/pkg/storage/names" "k8s.io/kubernetes/pkg/api/legacyscheme" "k8s.io/kubernetes/pkg/apis/scheduling" + schedulingutil "k8s.io/kubernetes/pkg/apis/scheduling/util" "k8s.io/kubernetes/pkg/apis/scheduling/validation" ) @@ -45,12 +46,15 @@ func (priorityClassStrategy) NamespaceScoped() bool { func (priorityClassStrategy) PrepareForCreate(ctx context.Context, obj runtime.Object) { pc := obj.(*scheduling.PriorityClass) pc.Generation = 1 + schedulingutil.DropDisabledFields(pc, nil) } // PrepareForUpdate clears fields that are not allowed to be set by end users on update. func (priorityClassStrategy) PrepareForUpdate(ctx context.Context, obj, old runtime.Object) { - _ = obj.(*scheduling.PriorityClass) - _ = old.(*scheduling.PriorityClass) + newClass := obj.(*scheduling.PriorityClass) + oldClass := old.(*scheduling.PriorityClass) + + schedulingutil.DropDisabledFields(newClass, oldClass) } // Validate validates a new PriorityClass. diff --git a/pkg/scheduler/core/extender_test.go b/pkg/scheduler/core/extender_test.go index 444f5a426e..205e5b8ef3 100644 --- a/pkg/scheduler/core/extender_test.go +++ b/pkg/scheduler/core/extender_test.go @@ -549,7 +549,8 @@ func TestGenericSchedulerWithExtenders(t *testing.T) { schedulertesting.FakePDBLister{}, false, false, - schedulerapi.DefaultPercentageOfNodesToScore) + schedulerapi.DefaultPercentageOfNodesToScore, + false) podIgnored := &v1.Pod{} result, err := scheduler.Schedule(podIgnored, schedulertesting.FakeNodeLister(makeNodeList(test.nodes))) if test.expectsErr { diff --git a/pkg/scheduler/core/generic_scheduler.go b/pkg/scheduler/core/generic_scheduler.go index 8eb2a6b82a..ad7b779bf7 100644 --- a/pkg/scheduler/core/generic_scheduler.go +++ b/pkg/scheduler/core/generic_scheduler.go @@ -169,6 +169,7 @@ type genericScheduler struct { disablePreemption bool lastIndex int percentageOfNodesToScore int32 + enableNonPreempting bool } // snapshot snapshots scheduler cache and node infos for all fit and priority @@ -314,7 +315,7 @@ func (g *genericScheduler) Preempt(pod *v1.Pod, nodeLister algorithm.NodeLister, if !ok || fitError == nil { return nil, nil, nil, nil } - if !podEligibleToPreemptOthers(pod, g.nodeInfoSnapshot.NodeInfoMap) { + if !podEligibleToPreemptOthers(pod, g.nodeInfoSnapshot.NodeInfoMap, g.enableNonPreempting) { klog.V(5).Infof("Pod %v/%v is not eligible for more preemption.", pod.Namespace, pod.Name) return nil, nil, nil, nil } @@ -1162,7 +1163,11 @@ func nodesWherePreemptionMightHelp(nodes []*v1.Node, failedPredicatesMap FailedP // considered for preemption. // We look at the node that is nominated for this pod and as long as there are // terminating pods on the node, we don't consider this for preempting more pods. -func podEligibleToPreemptOthers(pod *v1.Pod, nodeNameToInfo map[string]*schedulernodeinfo.NodeInfo) bool { +func podEligibleToPreemptOthers(pod *v1.Pod, nodeNameToInfo map[string]*schedulernodeinfo.NodeInfo, enableNonPreempting bool) bool { + if enableNonPreempting && pod.Spec.PreemptionPolicy != nil && *pod.Spec.PreemptionPolicy == v1.PreemptNever { + klog.V(5).Infof("Pod %v/%v is not eligible for preemption because it has a preemptionPolicy of %v", pod.Namespace, pod.Name, v1.PreemptNever) + return false + } nomNodeName := pod.Status.NominatedNodeName if len(nomNodeName) > 0 { if nodeInfo, found := nodeNameToInfo[nomNodeName]; found { @@ -1220,6 +1225,7 @@ func NewGenericScheduler( alwaysCheckAllPredicates bool, disablePreemption bool, percentageOfNodesToScore int32, + enableNonPreempting bool, ) ScheduleAlgorithm { return &genericScheduler{ cache: cache, @@ -1237,5 +1243,6 @@ func NewGenericScheduler( alwaysCheckAllPredicates: alwaysCheckAllPredicates, disablePreemption: disablePreemption, percentageOfNodesToScore: percentageOfNodesToScore, + enableNonPreempting: enableNonPreempting, } } diff --git a/pkg/scheduler/core/generic_scheduler_test.go b/pkg/scheduler/core/generic_scheduler_test.go index 9ca5a9c954..fd9bc27446 100644 --- a/pkg/scheduler/core/generic_scheduler_test.go +++ b/pkg/scheduler/core/generic_scheduler_test.go @@ -464,7 +464,8 @@ func TestGenericScheduler(t *testing.T) { schedulertesting.FakePDBLister{}, test.alwaysCheckAllPredicates, false, - schedulerapi.DefaultPercentageOfNodesToScore) + schedulerapi.DefaultPercentageOfNodesToScore, + false) result, err := scheduler.Schedule(test.pod, schedulertesting.FakeNodeLister(makeNodeList(test.nodes))) if !reflect.DeepEqual(err, test.wErr) { @@ -494,7 +495,7 @@ func makeScheduler(predicates map[string]algorithmpredicates.FitPredicate, nodes priorities.EmptyPriorityMetadataProducer, emptyFramework, nil, nil, nil, nil, false, false, - schedulerapi.DefaultPercentageOfNodesToScore) + schedulerapi.DefaultPercentageOfNodesToScore, false) cache.UpdateNodeInfoSnapshot(s.(*genericScheduler).nodeInfoSnapshot) return s.(*genericScheduler) @@ -1332,6 +1333,10 @@ func TestPreempt(t *testing.T) { for i := 1; i < 4; i++ { nodeNames = append(nodeNames, fmt.Sprintf("machine%d", i)) } + var ( + preemptLowerPriority = v1.PreemptLowerPriority + preemptNever = v1.PreemptNever + ) tests := []struct { name string pod *v1.Pod @@ -1343,8 +1348,9 @@ func TestPreempt(t *testing.T) { { name: "basic preemption logic", pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "pod1", UID: types.UID("pod1")}, Spec: v1.PodSpec{ - Containers: veryLargeContainers, - Priority: &highPriority}, + Containers: veryLargeContainers, + Priority: &highPriority, + PreemptionPolicy: &preemptLowerPriority}, }, pods: []*v1.Pod{ {ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine1"}, Status: v1.PodStatus{Phase: v1.PodRunning}}, @@ -1358,8 +1364,9 @@ func TestPreempt(t *testing.T) { { name: "One node doesn't need any preemption", pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "pod1", UID: types.UID("pod1")}, Spec: v1.PodSpec{ - Containers: veryLargeContainers, - Priority: &highPriority}, + Containers: veryLargeContainers, + Priority: &highPriority, + PreemptionPolicy: &preemptLowerPriority}, }, pods: []*v1.Pod{ {ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine1"}, Status: v1.PodStatus{Phase: v1.PodRunning}}, @@ -1373,8 +1380,9 @@ func TestPreempt(t *testing.T) { { name: "Scheduler extenders allow only machine1, otherwise machine3 would have been chosen", pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "pod1", UID: types.UID("pod1")}, Spec: v1.PodSpec{ - Containers: veryLargeContainers, - Priority: &highPriority}, + Containers: veryLargeContainers, + Priority: &highPriority, + PreemptionPolicy: &preemptLowerPriority}, }, pods: []*v1.Pod{ {ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &midPriority, NodeName: "machine1"}, Status: v1.PodStatus{Phase: v1.PodRunning}}, @@ -1396,8 +1404,9 @@ func TestPreempt(t *testing.T) { { name: "Scheduler extenders do not allow any preemption", pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "pod1", UID: types.UID("pod1")}, Spec: v1.PodSpec{ - Containers: veryLargeContainers, - Priority: &highPriority}, + Containers: veryLargeContainers, + Priority: &highPriority, + PreemptionPolicy: &preemptLowerPriority}, }, pods: []*v1.Pod{ {ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &midPriority, NodeName: "machine1"}, Status: v1.PodStatus{Phase: v1.PodRunning}}, @@ -1416,8 +1425,9 @@ func TestPreempt(t *testing.T) { { name: "One scheduler extender allows only machine1, the other returns error but ignorable. Only machine1 would be chosen", pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "pod1", UID: types.UID("pod1")}, Spec: v1.PodSpec{ - Containers: veryLargeContainers, - Priority: &highPriority}, + Containers: veryLargeContainers, + Priority: &highPriority, + PreemptionPolicy: &preemptLowerPriority}, }, pods: []*v1.Pod{ {ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &midPriority, NodeName: "machine1"}, Status: v1.PodStatus{Phase: v1.PodRunning}}, @@ -1440,8 +1450,9 @@ func TestPreempt(t *testing.T) { { name: "One scheduler extender allows only machine1, but it is not interested in given pod, otherwise machine1 would have been chosen", pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "pod1", UID: types.UID("pod1")}, Spec: v1.PodSpec{ - Containers: veryLargeContainers, - Priority: &highPriority}, + Containers: veryLargeContainers, + Priority: &highPriority, + PreemptionPolicy: &preemptLowerPriority}, }, pods: []*v1.Pod{ {ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &midPriority, NodeName: "machine1"}, Status: v1.PodStatus{Phase: v1.PodRunning}}, @@ -1461,6 +1472,38 @@ func TestPreempt(t *testing.T) { expectedNode: "machine3", expectedPods: []string{}, }, + { + name: "no preempting in pod", + pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "pod1", UID: types.UID("pod1")}, Spec: v1.PodSpec{ + Containers: veryLargeContainers, + Priority: &highPriority, + PreemptionPolicy: &preemptNever}, + }, + pods: []*v1.Pod{ + {ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine1"}, Status: v1.PodStatus{Phase: v1.PodRunning}}, + {ObjectMeta: metav1.ObjectMeta{Name: "m1.2", UID: types.UID("m1.2")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine1"}, Status: v1.PodStatus{Phase: v1.PodRunning}}, + {ObjectMeta: metav1.ObjectMeta{Name: "m2.1", UID: types.UID("m2.1")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &highPriority, NodeName: "machine2"}, Status: v1.PodStatus{Phase: v1.PodRunning}}, + {ObjectMeta: metav1.ObjectMeta{Name: "m3.1", UID: types.UID("m3.1")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine3"}, Status: v1.PodStatus{Phase: v1.PodRunning}}, + }, + expectedNode: "", + expectedPods: nil, + }, + { + name: "PreemptionPolicy is nil", + pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "pod1", UID: types.UID("pod1")}, Spec: v1.PodSpec{ + Containers: veryLargeContainers, + Priority: &highPriority, + PreemptionPolicy: nil}, + }, + pods: []*v1.Pod{ + {ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine1"}, Status: v1.PodStatus{Phase: v1.PodRunning}}, + {ObjectMeta: metav1.ObjectMeta{Name: "m1.2", UID: types.UID("m1.2")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine1"}, Status: v1.PodStatus{Phase: v1.PodRunning}}, + {ObjectMeta: metav1.ObjectMeta{Name: "m2.1", UID: types.UID("m2.1")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &highPriority, NodeName: "machine2"}, Status: v1.PodStatus{Phase: v1.PodRunning}}, + {ObjectMeta: metav1.ObjectMeta{Name: "m3.1", UID: types.UID("m3.1")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine3"}, Status: v1.PodStatus{Phase: v1.PodRunning}}, + }, + expectedNode: "machine1", + expectedPods: []string{"m1.1", "m1.2"}, + }, } for _, test := range tests { @@ -1501,7 +1544,8 @@ func TestPreempt(t *testing.T) { schedulertesting.FakePDBLister{}, false, false, - schedulerapi.DefaultPercentageOfNodesToScore) + schedulerapi.DefaultPercentageOfNodesToScore, + true) scheduler.(*genericScheduler).snapshot() // Call Preempt and check the expected results. node, victims, _, err := scheduler.Preempt(test.pod, schedulertesting.FakeNodeLister(makeNodeList(nodeNames)), error(&FitError{Pod: test.pod, FailedPredicates: failedPredMap})) diff --git a/pkg/scheduler/factory/BUILD b/pkg/scheduler/factory/BUILD index 15a03325cc..924d8c0e18 100644 --- a/pkg/scheduler/factory/BUILD +++ b/pkg/scheduler/factory/BUILD @@ -10,6 +10,7 @@ go_library( visibility = ["//visibility:public"], deps = [ "//pkg/api/v1/pod:go_default_library", + "//pkg/features:go_default_library", "//pkg/scheduler/algorithm:go_default_library", "//pkg/scheduler/algorithm/predicates:go_default_library", "//pkg/scheduler/algorithm/priorities:go_default_library", @@ -32,6 +33,7 @@ go_library( "//staging/src/k8s.io/apimachinery/pkg/util/runtime:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/util/sets:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/util/wait:go_default_library", + "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library", "//staging/src/k8s.io/client-go/informers/apps/v1:go_default_library", "//staging/src/k8s.io/client-go/informers/core/v1:go_default_library", "//staging/src/k8s.io/client-go/informers/policy/v1beta1:go_default_library", diff --git a/pkg/scheduler/factory/factory.go b/pkg/scheduler/factory/factory.go index e0496df8db..579c4dccb4 100644 --- a/pkg/scheduler/factory/factory.go +++ b/pkg/scheduler/factory/factory.go @@ -32,6 +32,7 @@ import ( "k8s.io/apimachinery/pkg/util/runtime" "k8s.io/apimachinery/pkg/util/sets" "k8s.io/apimachinery/pkg/util/wait" + utilfeature "k8s.io/apiserver/pkg/util/feature" appsinformers "k8s.io/client-go/informers/apps/v1" coreinformers "k8s.io/client-go/informers/core/v1" policyinformers "k8s.io/client-go/informers/policy/v1beta1" @@ -45,6 +46,7 @@ import ( "k8s.io/client-go/tools/record" "k8s.io/klog" podutil "k8s.io/kubernetes/pkg/api/v1/pod" + "k8s.io/kubernetes/pkg/features" "k8s.io/kubernetes/pkg/scheduler/algorithm" "k8s.io/kubernetes/pkg/scheduler/algorithm/predicates" "k8s.io/kubernetes/pkg/scheduler/algorithm/priorities" @@ -217,6 +219,8 @@ type configFactory struct { bindTimeoutSeconds int64 // queue for pods that need scheduling podQueue internalqueue.SchedulingQueue + + enableNonPreempting bool } // ConfigFactoryArgs is a set arguments passed to NewConfigFactory. @@ -283,6 +287,7 @@ func NewConfigFactory(args *ConfigFactoryArgs) Configurator { disablePreemption: args.DisablePreemption, percentageOfNodesToScore: args.PercentageOfNodesToScore, bindTimeoutSeconds: args.BindTimeoutSeconds, + enableNonPreempting: utilfeature.DefaultFeatureGate.Enabled(features.NonPreemptingPriority), } // Setup volume binder c.volumeBinder = volumebinder.NewVolumeBinder(args.Client, args.NodeInformer, args.PvcInformer, args.PvInformer, args.StorageClassInformer, time.Duration(args.BindTimeoutSeconds)*time.Second) @@ -466,6 +471,7 @@ func (c *configFactory) CreateFromKeys(predicateKeys, priorityKeys sets.String, c.alwaysCheckAllPredicates, c.disablePreemption, c.percentageOfNodesToScore, + c.enableNonPreempting, ) return &Config{ diff --git a/pkg/scheduler/scheduler_test.go b/pkg/scheduler/scheduler_test.go index cfb81e7bc2..d96f8740d8 100644 --- a/pkg/scheduler/scheduler_test.go +++ b/pkg/scheduler/scheduler_test.go @@ -661,6 +661,7 @@ func setupTestScheduler(queuedPodStore *clientcache.FIFO, scache internalcache.C false, false, schedulerapi.DefaultPercentageOfNodesToScore, + false, ) bindingChan := make(chan *v1.Binding, 1) errChan := make(chan error, 1) @@ -714,6 +715,7 @@ func setupTestSchedulerLongBindingWithRetry(queuedPodStore *clientcache.FIFO, sc false, false, schedulerapi.DefaultPercentageOfNodesToScore, + false, ) bindingChan := make(chan *v1.Binding, 2) diff --git a/plugin/pkg/admission/priority/BUILD b/plugin/pkg/admission/priority/BUILD index d799b30629..2b34a81b71 100644 --- a/plugin/pkg/admission/priority/BUILD +++ b/plugin/pkg/admission/priority/BUILD @@ -37,6 +37,7 @@ go_library( "//pkg/apis/scheduling:go_default_library", "//pkg/features:go_default_library", "//pkg/kubelet/types:go_default_library", + "//staging/src/k8s.io/api/core/v1:go_default_library", "//staging/src/k8s.io/api/scheduling/v1:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/api/errors:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library", diff --git a/plugin/pkg/admission/priority/admission.go b/plugin/pkg/admission/priority/admission.go index a39be3e7fb..4c82d65acf 100644 --- a/plugin/pkg/admission/priority/admission.go +++ b/plugin/pkg/admission/priority/admission.go @@ -20,6 +20,7 @@ import ( "fmt" "io" + apiv1 "k8s.io/api/core/v1" schedulingv1 "k8s.io/api/scheduling/v1" "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -30,6 +31,7 @@ import ( "k8s.io/client-go/informers" "k8s.io/client-go/kubernetes" schedulingv1listers "k8s.io/client-go/listers/scheduling/v1" + "k8s.io/kubernetes/pkg/apis/core" api "k8s.io/kubernetes/pkg/apis/core" "k8s.io/kubernetes/pkg/apis/scheduling" "k8s.io/kubernetes/pkg/features" @@ -179,6 +181,7 @@ func (p *priorityPlugin) admitPod(a admission.Attributes) error { if operation == admission.Create { var priority int32 + var preemptionPolicy *apiv1.PreemptionPolicy // TODO: @ravig - This is for backwards compatibility to ensure that critical pods with annotations just work fine. // Remove when no longer needed. if len(pod.Spec.PriorityClassName) == 0 && @@ -189,7 +192,7 @@ func (p *priorityPlugin) admitPod(a admission.Attributes) error { if len(pod.Spec.PriorityClassName) == 0 { var err error var pcName string - pcName, priority, err = p.getDefaultPriority() + pcName, priority, preemptionPolicy, err = p.getDefaultPriority() if err != nil { return fmt.Errorf("failed to get default priority class: %v", err) } @@ -211,12 +214,24 @@ func (p *priorityPlugin) admitPod(a admission.Attributes) error { } priority = pc.Value + preemptionPolicy = pc.PreemptionPolicy } // if the pod contained a priority that differs from the one computed from the priority class, error if pod.Spec.Priority != nil && *pod.Spec.Priority != priority { return admission.NewForbidden(a, fmt.Errorf("the integer value of priority (%d) must not be provided in pod spec; priority admission controller computed %d from the given PriorityClass name", *pod.Spec.Priority, priority)) } pod.Spec.Priority = &priority + + if utilfeature.DefaultFeatureGate.Enabled(features.NonPreemptingPriority) { + var corePolicy core.PreemptionPolicy + if preemptionPolicy != nil { + corePolicy = core.PreemptionPolicy(*preemptionPolicy) + if pod.Spec.PreemptionPolicy != nil && *pod.Spec.PreemptionPolicy != corePolicy { + return admission.NewForbidden(a, fmt.Errorf("the string value of PreemptionPolicy (%s) must not be provided in pod spec; priority admission controller computed %s from the given PriorityClass name", *pod.Spec.PreemptionPolicy, corePolicy)) + } + pod.Spec.PreemptionPolicy = &corePolicy + } + } } return nil } @@ -262,14 +277,14 @@ func (p *priorityPlugin) getDefaultPriorityClass() (*schedulingv1.PriorityClass, return defaultPC, nil } -func (p *priorityPlugin) getDefaultPriority() (string, int32, error) { +func (p *priorityPlugin) getDefaultPriority() (string, int32, *apiv1.PreemptionPolicy, error) { dpc, err := p.getDefaultPriorityClass() if err != nil { - return "", 0, err + return "", 0, nil, err } if dpc != nil { - return dpc.Name, dpc.Value, nil + return dpc.Name, dpc.Value, dpc.PreemptionPolicy, nil } - - return "", int32(scheduling.DefaultPriorityWhenNoDefaultClassExists), nil + preemptLowerPriority := apiv1.PreemptLowerPriority + return "", int32(scheduling.DefaultPriorityWhenNoDefaultClassExists), &preemptLowerPriority, nil } diff --git a/plugin/pkg/admission/priority/admission_test.go b/plugin/pkg/admission/priority/admission_test.go index e54e84f0d8..1181956ef0 100644 --- a/plugin/pkg/admission/priority/admission_test.go +++ b/plugin/pkg/admission/priority/admission_test.go @@ -50,6 +50,11 @@ func addPriorityClasses(ctrl *priorityPlugin, priorityClasses []*scheduling.Prio return nil } +var ( + preemptNever = api.PreemptNever + preemptLowerPriority = api.PreemptLowerPriority +) + var defaultClass1 = &scheduling.PriorityClass{ TypeMeta: metav1.TypeMeta{ Kind: "PriorityClass", @@ -94,6 +99,32 @@ var systemClusterCritical = &scheduling.PriorityClass{ GlobalDefault: true, } +var neverPreemptionPolicyClass = &scheduling.PriorityClass{ + TypeMeta: metav1.TypeMeta{ + Kind: "PriorityClass", + }, + ObjectMeta: metav1.ObjectMeta{ + Name: "nopreemptionpolicy", + }, + Value: 2000, + Description: "Just a test priority class", + GlobalDefault: true, + PreemptionPolicy: &preemptNever, +} + +var preemptionPolicyClass = &scheduling.PriorityClass{ + TypeMeta: metav1.TypeMeta{ + Kind: "PriorityClass", + }, + ObjectMeta: metav1.ObjectMeta{ + Name: "nopreemptionpolicy", + }, + Value: 2000, + Description: "Just a test priority class", + GlobalDefault: true, + PreemptionPolicy: &preemptLowerPriority, +} + func TestPriorityClassAdmission(t *testing.T) { var systemClass = &scheduling.PriorityClass{ TypeMeta: metav1.TypeMeta{ @@ -246,7 +277,7 @@ func TestDefaultPriority(t *testing.T) { if err := addPriorityClasses(ctrl, test.classesBefore); err != nil { t.Errorf("Test %q: unable to add object to informer: %v", test.name, err) } - pcName, defaultPriority, err := ctrl.getDefaultPriority() + pcName, defaultPriority, _, err := ctrl.getDefaultPriority() if err != nil { t.Errorf("Test %q: unexpected error while getting default priority: %v", test.name, err) } @@ -264,7 +295,7 @@ func TestDefaultPriority(t *testing.T) { if err := addPriorityClasses(ctrl, test.classesAfter); err != nil { t.Errorf("Test %q: unable to add object to informer: %v", test.name, err) } - pcName, defaultPriority, err = ctrl.getDefaultPriority() + pcName, defaultPriority, _, err = ctrl.getDefaultPriority() if err != nil { t.Errorf("Test %q: unexpected error while getting default priority: %v", test.name, err) } @@ -468,19 +499,73 @@ func TestPodAdmission(t *testing.T) { Priority: &systemClusterCritical.Value, }, }, + // pod[12]: Pod without a preemption policy that matches the resolved preemption policy + { + ObjectMeta: metav1.ObjectMeta{ + Name: "pod-never-preemption-policy-matching-resolved-preemption-policy", + Namespace: metav1.NamespaceSystem, + }, + Spec: api.PodSpec{ + Containers: []api.Container{ + { + Name: containerName, + }, + }, + PriorityClassName: neverPreemptionPolicyClass.Name, + Priority: &neverPreemptionPolicyClass.Value, + PreemptionPolicy: nil, + }, + }, + // pod[13]: Pod with a preemption policy that matches the resolved preemption policy + { + ObjectMeta: metav1.ObjectMeta{ + Name: "pod-preemption-policy-matching-resolved-preemption-policy", + Namespace: metav1.NamespaceSystem, + }, + Spec: api.PodSpec{ + Containers: []api.Container{ + { + Name: containerName, + }, + }, + PriorityClassName: preemptionPolicyClass.Name, + Priority: &preemptionPolicyClass.Value, + PreemptionPolicy: &preemptLowerPriority, + }, + }, + // pod[14]: Pod with a preemption policy that does't match the resolved preemption policy + { + ObjectMeta: metav1.ObjectMeta{ + Name: "pod-preemption-policy-not-matching-resolved-preemption-policy", + Namespace: metav1.NamespaceSystem, + }, + Spec: api.PodSpec{ + Containers: []api.Container{ + { + Name: containerName, + }, + }, + PriorityClassName: preemptionPolicyClass.Name, + Priority: &preemptionPolicyClass.Value, + PreemptionPolicy: &preemptNever, + }, + }, } // Enable PodPriority feature gate. defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.PodPriority, true)() // Enable ExperimentalCriticalPodAnnotation feature gate. defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.ExperimentalCriticalPodAnnotation, true)() + // Enable NonPreemptingPriority feature gate. + defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.NonPreemptingPriority, true)() tests := []struct { name string existingClasses []*scheduling.PriorityClass // Admission controller changes pod spec. So, we take an api.Pod instead of // *api.Pod to avoid interfering with other tests. - pod api.Pod - expectedPriority int32 - expectError bool + pod api.Pod + expectedPriority int32 + expectError bool + expectPreemptionPolicy *api.PreemptionPolicy }{ { "Pod with priority class", @@ -488,6 +573,7 @@ func TestPodAdmission(t *testing.T) { *pods[0], 1000, false, + nil, }, { @@ -496,6 +582,7 @@ func TestPodAdmission(t *testing.T) { *pods[1], 1000, false, + nil, }, { "pod without priority class and no existing priority class", @@ -503,6 +590,7 @@ func TestPodAdmission(t *testing.T) { *pods[1], scheduling.DefaultPriorityWhenNoDefaultClassExists, false, + nil, }, { "pod without priority class and no default class", @@ -510,6 +598,7 @@ func TestPodAdmission(t *testing.T) { *pods[1], scheduling.DefaultPriorityWhenNoDefaultClassExists, false, + nil, }, { "pod with a system priority class", @@ -517,6 +606,7 @@ func TestPodAdmission(t *testing.T) { *pods[4], scheduling.SystemCriticalPriority, false, + nil, }, { "Pod with non-existing priority class", @@ -524,6 +614,7 @@ func TestPodAdmission(t *testing.T) { *pods[2], 0, true, + nil, }, { "pod with integer priority", @@ -531,6 +622,7 @@ func TestPodAdmission(t *testing.T) { *pods[3], 0, true, + nil, }, { "mirror pod with system priority class", @@ -538,6 +630,7 @@ func TestPodAdmission(t *testing.T) { *pods[5], scheduling.SystemCriticalPriority, false, + nil, }, { "mirror pod with integer priority", @@ -545,6 +638,7 @@ func TestPodAdmission(t *testing.T) { *pods[6], 0, true, + nil, }, { "pod with critical pod annotation", @@ -552,6 +646,7 @@ func TestPodAdmission(t *testing.T) { *pods[7], scheduling.SystemCriticalPriority, false, + nil, }, { "pod with system critical priority in non-system namespace", @@ -559,6 +654,7 @@ func TestPodAdmission(t *testing.T) { *pods[8], scheduling.SystemCriticalPriority, true, + nil, }, { "pod with priority that matches computed priority", @@ -566,6 +662,7 @@ func TestPodAdmission(t *testing.T) { *pods[9], 0, false, + nil, }, { "pod with priority that matches default priority", @@ -573,6 +670,7 @@ func TestPodAdmission(t *testing.T) { *pods[10], defaultClass2.Value, false, + nil, }, { "pod with priority that matches resolved priority", @@ -580,6 +678,31 @@ func TestPodAdmission(t *testing.T) { *pods[11], systemClusterCritical.Value, false, + nil, + }, + { + "pod with nil preemtpion policy", + []*scheduling.PriorityClass{preemptionPolicyClass}, + *pods[12], + preemptionPolicyClass.Value, + false, + nil, + }, + { + "pod with preemtpion policy that matches resolved preemtpion policy", + []*scheduling.PriorityClass{preemptionPolicyClass}, + *pods[13], + preemptionPolicyClass.Value, + false, + &preemptLowerPriority, + }, + { + "pod with preemtpion policy that does't matches resolved preemtpion policy", + []*scheduling.PriorityClass{preemptionPolicyClass}, + *pods[14], + preemptionPolicyClass.Value, + true, + &preemptLowerPriority, }, } @@ -613,6 +736,8 @@ func TestPodAdmission(t *testing.T) { t.Errorf("Test %q: unexpected error received: %v", test.name, err) } else if *test.pod.Spec.Priority != test.expectedPriority { t.Errorf("Test %q: expected priority is %d, but got %d.", test.name, test.expectedPriority, *test.pod.Spec.Priority) + } else if test.pod.Spec.PreemptionPolicy != nil && test.expectPreemptionPolicy != nil && *test.pod.Spec.PreemptionPolicy != *test.expectPreemptionPolicy { + t.Errorf("Test %q: expected preemption policy is %s, but got %s.", test.name, *test.expectPreemptionPolicy, *test.pod.Spec.PreemptionPolicy) } } if err == nil && test.expectError { 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 d579b2fbea..79ecb2610c 100644 --- a/staging/src/k8s.io/api/core/v1/generated.pb.go +++ b/staging/src/k8s.io/api/core/v1/generated.pb.go @@ -7847,6 +7847,14 @@ func (m *PodSpec) MarshalTo(dAtA []byte) (int, error) { } i++ } + if m.PreemptionPolicy != nil { + dAtA[i] = 0xfa + i++ + dAtA[i] = 0x1 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(len(*m.PreemptionPolicy))) + i += copy(dAtA[i:], *m.PreemptionPolicy) + } return i, nil } @@ -13573,6 +13581,10 @@ func (m *PodSpec) Size() (n int) { if m.EnableServiceLinks != nil { n += 3 } + if m.PreemptionPolicy != nil { + l = len(*m.PreemptionPolicy) + n += 2 + l + sovGenerated(uint64(l)) + } return n } @@ -16649,6 +16661,7 @@ func (this *PodSpec) String() string { `ReadinessGates:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ReadinessGates), "PodReadinessGate", "PodReadinessGate", 1), `&`, ``, 1) + `,`, `RuntimeClassName:` + valueToStringGenerated(this.RuntimeClassName) + `,`, `EnableServiceLinks:` + valueToStringGenerated(this.EnableServiceLinks) + `,`, + `PreemptionPolicy:` + valueToStringGenerated(this.PreemptionPolicy) + `,`, `}`, }, "") return s @@ -40406,6 +40419,36 @@ func (m *PodSpec) Unmarshal(dAtA []byte) error { } b := bool(v != 0) m.EnableServiceLinks = &b + case 31: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PreemptionPolicy", 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 > l { + return io.ErrUnexpectedEOF + } + s := PreemptionPolicy(dAtA[iNdEx:postIndex]) + m.PreemptionPolicy = &s + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) @@ -52495,821 +52538,823 @@ func init() { } var fileDescriptorGenerated = []byte{ - // 13056 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x6d, 0x70, 0x64, 0x57, - 0x56, 0xd8, 0xbe, 0x6e, 0x7d, 0xf5, 0xd1, 0xf7, 0x9d, 0x0f, 0x6b, 0xe4, 0x99, 0xe9, 0xf1, 0xf3, - 0xee, 0x78, 0xbc, 0xb6, 0x35, 0xeb, 0xb1, 0xbd, 0x36, 0x6b, 0xaf, 0x41, 0x52, 0x4b, 0x33, 0xf2, - 0x8c, 0x34, 0xed, 0xdb, 0x9a, 0x99, 0x5d, 0xe3, 0x5d, 0xfc, 0xd4, 0xef, 0xaa, 0xf5, 0xac, 0xd6, - 0x7b, 0xed, 0xf7, 0x5e, 0x6b, 0x46, 0x0e, 0x54, 0xc8, 0x12, 0x08, 0x5b, 0x90, 0xd4, 0x56, 0xb2, - 0x95, 0x0f, 0xa0, 0x48, 0x15, 0x21, 0x05, 0x04, 0x92, 0x0a, 0x81, 0x00, 0x61, 0x49, 0x42, 0x20, - 0xa9, 0x22, 0xf9, 0xb1, 0x21, 0xa9, 0x4a, 0x2d, 0x55, 0x54, 0x14, 0x10, 0xa9, 0x50, 0xfc, 0x08, - 0xa4, 0x42, 0xfe, 0xa0, 0x50, 0x21, 0x75, 0x3f, 0xdf, 0xbd, 0xaf, 0xdf, 0xeb, 0x6e, 0x8d, 0x35, - 0xb2, 0xa1, 0xf6, 0x5f, 0xf7, 0x3d, 0xe7, 0x9e, 0x7b, 0xdf, 0xfd, 0x3c, 0xe7, 0xdc, 0xf3, 0x01, - 0xaf, 0x6e, 0xbf, 0x12, 0xcd, 0x79, 0xc1, 0xd5, 0xed, 0xf6, 0x06, 0x09, 0x7d, 0x12, 0x93, 0xe8, - 0xea, 0x2e, 0xf1, 0xdd, 0x20, 0xbc, 0x2a, 0x00, 0x4e, 0xcb, 0xbb, 0x5a, 0x0f, 0x42, 0x72, 0x75, - 0xf7, 0xf9, 0xab, 0x0d, 0xe2, 0x93, 0xd0, 0x89, 0x89, 0x3b, 0xd7, 0x0a, 0x83, 0x38, 0x40, 0x88, - 0xe3, 0xcc, 0x39, 0x2d, 0x6f, 0x8e, 0xe2, 0xcc, 0xed, 0x3e, 0x3f, 0xfb, 0x5c, 0xc3, 0x8b, 0xb7, - 0xda, 0x1b, 0x73, 0xf5, 0x60, 0xe7, 0x6a, 0x23, 0x68, 0x04, 0x57, 0x19, 0xea, 0x46, 0x7b, 0x93, - 0xfd, 0x63, 0x7f, 0xd8, 0x2f, 0x4e, 0x62, 0xf6, 0xc5, 0xa4, 0x99, 0x1d, 0xa7, 0xbe, 0xe5, 0xf9, - 0x24, 0xdc, 0xbb, 0xda, 0xda, 0x6e, 0xb0, 0x76, 0x43, 0x12, 0x05, 0xed, 0xb0, 0x4e, 0xd2, 0x0d, - 0x77, 0xad, 0x15, 0x5d, 0xdd, 0x21, 0xb1, 0x93, 0xd1, 0xdd, 0xd9, 0xab, 0x79, 0xb5, 0xc2, 0xb6, - 0x1f, 0x7b, 0x3b, 0x9d, 0xcd, 0x7c, 0xba, 0x57, 0x85, 0xa8, 0xbe, 0x45, 0x76, 0x9c, 0x8e, 0x7a, - 0x2f, 0xe4, 0xd5, 0x6b, 0xc7, 0x5e, 0xf3, 0xaa, 0xe7, 0xc7, 0x51, 0x1c, 0xa6, 0x2b, 0xd9, 0xdf, - 0xb0, 0xe0, 0xd2, 0xfc, 0xbd, 0xda, 0x52, 0xd3, 0x89, 0x62, 0xaf, 0xbe, 0xd0, 0x0c, 0xea, 0xdb, - 0xb5, 0x38, 0x08, 0xc9, 0xdd, 0xa0, 0xd9, 0xde, 0x21, 0x35, 0x36, 0x10, 0xe8, 0x59, 0x18, 0xd9, - 0x65, 0xff, 0x57, 0x2a, 0x33, 0xd6, 0x25, 0xeb, 0x4a, 0x69, 0x61, 0xea, 0x37, 0xf6, 0xcb, 0x1f, - 0x3b, 0xd8, 0x2f, 0x8f, 0xdc, 0x15, 0xe5, 0x58, 0x61, 0xa0, 0xcb, 0x30, 0xb4, 0x19, 0xad, 0xef, - 0xb5, 0xc8, 0x4c, 0x81, 0xe1, 0x4e, 0x08, 0xdc, 0xa1, 0xe5, 0x1a, 0x2d, 0xc5, 0x02, 0x8a, 0xae, - 0x42, 0xa9, 0xe5, 0x84, 0xb1, 0x17, 0x7b, 0x81, 0x3f, 0x53, 0xbc, 0x64, 0x5d, 0x19, 0x5c, 0x98, - 0x16, 0xa8, 0xa5, 0xaa, 0x04, 0xe0, 0x04, 0x87, 0x76, 0x23, 0x24, 0x8e, 0x7b, 0xdb, 0x6f, 0xee, - 0xcd, 0x0c, 0x5c, 0xb2, 0xae, 0x8c, 0x24, 0xdd, 0xc0, 0xa2, 0x1c, 0x2b, 0x0c, 0xfb, 0x87, 0x0a, - 0x30, 0x32, 0xbf, 0xb9, 0xe9, 0xf9, 0x5e, 0xbc, 0x87, 0xee, 0xc2, 0x98, 0x1f, 0xb8, 0x44, 0xfe, - 0x67, 0x5f, 0x31, 0x7a, 0xed, 0xd2, 0x5c, 0xe7, 0x52, 0x9a, 0x5b, 0xd3, 0xf0, 0x16, 0xa6, 0x0e, - 0xf6, 0xcb, 0x63, 0x7a, 0x09, 0x36, 0xe8, 0x20, 0x0c, 0xa3, 0xad, 0xc0, 0x55, 0x64, 0x0b, 0x8c, - 0x6c, 0x39, 0x8b, 0x6c, 0x35, 0x41, 0x5b, 0x98, 0x3c, 0xd8, 0x2f, 0x8f, 0x6a, 0x05, 0x58, 0x27, - 0x82, 0x36, 0x60, 0x92, 0xfe, 0xf5, 0x63, 0x4f, 0xd1, 0x2d, 0x32, 0xba, 0x4f, 0xe6, 0xd1, 0xd5, - 0x50, 0x17, 0x4e, 0x1d, 0xec, 0x97, 0x27, 0x53, 0x85, 0x38, 0x4d, 0xd0, 0x7e, 0x1f, 0x26, 0xe6, - 0xe3, 0xd8, 0xa9, 0x6f, 0x11, 0x97, 0xcf, 0x20, 0x7a, 0x11, 0x06, 0x7c, 0x67, 0x87, 0x88, 0xf9, - 0xbd, 0x24, 0x06, 0x76, 0x60, 0xcd, 0xd9, 0x21, 0x87, 0xfb, 0xe5, 0xa9, 0x3b, 0xbe, 0xf7, 0x5e, - 0x5b, 0xac, 0x0a, 0x5a, 0x86, 0x19, 0x36, 0xba, 0x06, 0xe0, 0x92, 0x5d, 0xaf, 0x4e, 0xaa, 0x4e, - 0xbc, 0x25, 0xe6, 0x1b, 0x89, 0xba, 0x50, 0x51, 0x10, 0xac, 0x61, 0xd9, 0x0f, 0xa0, 0x34, 0xbf, - 0x1b, 0x78, 0x6e, 0x35, 0x70, 0x23, 0xb4, 0x0d, 0x93, 0xad, 0x90, 0x6c, 0x92, 0x50, 0x15, 0xcd, - 0x58, 0x97, 0x8a, 0x57, 0x46, 0xaf, 0x5d, 0xc9, 0xfc, 0x58, 0x13, 0x75, 0xc9, 0x8f, 0xc3, 0xbd, - 0x85, 0xc7, 0x44, 0x7b, 0x93, 0x29, 0x28, 0x4e, 0x53, 0xb6, 0xff, 0x6d, 0x01, 0xce, 0xcc, 0xbf, - 0xdf, 0x0e, 0x49, 0xc5, 0x8b, 0xb6, 0xd3, 0x2b, 0xdc, 0xf5, 0xa2, 0xed, 0xb5, 0x64, 0x04, 0xd4, - 0xd2, 0xaa, 0x88, 0x72, 0xac, 0x30, 0xd0, 0x73, 0x30, 0x4c, 0x7f, 0xdf, 0xc1, 0x2b, 0xe2, 0x93, - 0x4f, 0x09, 0xe4, 0xd1, 0x8a, 0x13, 0x3b, 0x15, 0x0e, 0xc2, 0x12, 0x07, 0xad, 0xc2, 0x68, 0x9d, - 0x6d, 0xc8, 0xc6, 0x6a, 0xe0, 0x12, 0x36, 0x99, 0xa5, 0x85, 0x67, 0x28, 0xfa, 0x62, 0x52, 0x7c, - 0xb8, 0x5f, 0x9e, 0xe1, 0x7d, 0x13, 0x24, 0x34, 0x18, 0xd6, 0xeb, 0x23, 0x5b, 0xed, 0xaf, 0x01, - 0x46, 0x09, 0x32, 0xf6, 0xd6, 0x15, 0x6d, 0xab, 0x0c, 0xb2, 0xad, 0x32, 0x96, 0xbd, 0x4d, 0xd0, - 0xf3, 0x30, 0xb0, 0xed, 0xf9, 0xee, 0xcc, 0x10, 0xa3, 0x75, 0x81, 0xce, 0xf9, 0x4d, 0xcf, 0x77, - 0x0f, 0xf7, 0xcb, 0xd3, 0x46, 0x77, 0x68, 0x21, 0x66, 0xa8, 0xf6, 0x1f, 0x5b, 0x50, 0x66, 0xb0, - 0x65, 0xaf, 0x49, 0xaa, 0x24, 0x8c, 0xbc, 0x28, 0x26, 0x7e, 0x6c, 0x0c, 0xe8, 0x35, 0x80, 0x88, - 0xd4, 0x43, 0x12, 0x6b, 0x43, 0xaa, 0x16, 0x46, 0x4d, 0x41, 0xb0, 0x86, 0x45, 0x0f, 0x84, 0x68, - 0xcb, 0x09, 0xd9, 0xfa, 0x12, 0x03, 0xab, 0x0e, 0x84, 0x9a, 0x04, 0xe0, 0x04, 0xc7, 0x38, 0x10, - 0x8a, 0xbd, 0x0e, 0x04, 0xf4, 0x59, 0x98, 0x4c, 0x1a, 0x8b, 0x5a, 0x4e, 0x5d, 0x0e, 0x20, 0xdb, - 0x32, 0x35, 0x13, 0x84, 0xd3, 0xb8, 0xf6, 0x3f, 0xb2, 0xc4, 0xe2, 0xa1, 0x5f, 0xfd, 0x11, 0xff, - 0x56, 0xfb, 0x97, 0x2c, 0x18, 0x5e, 0xf0, 0x7c, 0xd7, 0xf3, 0x1b, 0xe8, 0x1d, 0x18, 0xa1, 0x77, - 0x93, 0xeb, 0xc4, 0x8e, 0x38, 0xf7, 0x3e, 0xa5, 0xed, 0x2d, 0x75, 0x55, 0xcc, 0xb5, 0xb6, 0x1b, - 0xb4, 0x20, 0x9a, 0xa3, 0xd8, 0x74, 0xb7, 0xdd, 0xde, 0x78, 0x97, 0xd4, 0xe3, 0x55, 0x12, 0x3b, - 0xc9, 0xe7, 0x24, 0x65, 0x58, 0x51, 0x45, 0x37, 0x61, 0x28, 0x76, 0xc2, 0x06, 0x89, 0xc5, 0x01, - 0x98, 0x79, 0x50, 0xf1, 0x9a, 0x98, 0xee, 0x48, 0xe2, 0xd7, 0x49, 0x72, 0x2d, 0xac, 0xb3, 0xaa, - 0x58, 0x90, 0xb0, 0xff, 0xfa, 0x30, 0x9c, 0x5b, 0xac, 0xad, 0xe4, 0xac, 0xab, 0xcb, 0x30, 0xe4, - 0x86, 0xde, 0x2e, 0x09, 0xc5, 0x38, 0x2b, 0x2a, 0x15, 0x56, 0x8a, 0x05, 0x14, 0xbd, 0x02, 0x63, - 0xfc, 0x42, 0xba, 0xe1, 0xf8, 0x6e, 0x53, 0x0e, 0xf1, 0x69, 0x81, 0x3d, 0x76, 0x57, 0x83, 0x61, - 0x03, 0xf3, 0x88, 0x8b, 0xea, 0x72, 0x6a, 0x33, 0xe6, 0x5d, 0x76, 0x5f, 0xb6, 0x60, 0x8a, 0x37, - 0x33, 0x1f, 0xc7, 0xa1, 0xb7, 0xd1, 0x8e, 0x49, 0x34, 0x33, 0xc8, 0x4e, 0xba, 0xc5, 0xac, 0xd1, - 0xca, 0x1d, 0x81, 0xb9, 0xbb, 0x29, 0x2a, 0xfc, 0x10, 0x9c, 0x11, 0xed, 0x4e, 0xa5, 0xc1, 0xb8, - 0xa3, 0x59, 0xf4, 0x3d, 0x16, 0xcc, 0xd6, 0x03, 0x3f, 0x0e, 0x83, 0x66, 0x93, 0x84, 0xd5, 0xf6, - 0x46, 0xd3, 0x8b, 0xb6, 0xf8, 0x3a, 0xc5, 0x64, 0x93, 0x9d, 0x04, 0x39, 0x73, 0xa8, 0x90, 0xc4, - 0x1c, 0x5e, 0x3c, 0xd8, 0x2f, 0xcf, 0x2e, 0xe6, 0x92, 0xc2, 0x5d, 0x9a, 0x41, 0xdb, 0x80, 0xe8, - 0x55, 0x5a, 0x8b, 0x9d, 0x06, 0x49, 0x1a, 0x1f, 0xee, 0xbf, 0xf1, 0xb3, 0x07, 0xfb, 0x65, 0xb4, - 0xd6, 0x41, 0x02, 0x67, 0x90, 0x45, 0xef, 0xc1, 0x69, 0x5a, 0xda, 0xf1, 0xad, 0x23, 0xfd, 0x37, - 0x37, 0x73, 0xb0, 0x5f, 0x3e, 0xbd, 0x96, 0x41, 0x04, 0x67, 0x92, 0x46, 0xdf, 0x6d, 0xc1, 0xb9, - 0xe4, 0xf3, 0x97, 0x1e, 0xb4, 0x1c, 0xdf, 0x4d, 0x1a, 0x2e, 0xf5, 0xdf, 0x30, 0x3d, 0x93, 0xcf, - 0x2d, 0xe6, 0x51, 0xc2, 0xf9, 0x8d, 0xcc, 0x2e, 0xc2, 0x99, 0xcc, 0xd5, 0x82, 0xa6, 0xa0, 0xb8, - 0x4d, 0x38, 0x17, 0x54, 0xc2, 0xf4, 0x27, 0x3a, 0x0d, 0x83, 0xbb, 0x4e, 0xb3, 0x2d, 0x36, 0x0a, - 0xe6, 0x7f, 0x3e, 0x53, 0x78, 0xc5, 0xb2, 0xff, 0x5d, 0x11, 0x26, 0x17, 0x6b, 0x2b, 0x0f, 0xb5, - 0x0b, 0xf5, 0x6b, 0xa8, 0xd0, 0xf5, 0x1a, 0x4a, 0x2e, 0xb5, 0x62, 0xee, 0xa5, 0xf6, 0x97, 0x33, - 0xb6, 0xd0, 0x00, 0xdb, 0x42, 0xdf, 0x92, 0xb3, 0x85, 0x8e, 0x79, 0xe3, 0xec, 0xe6, 0xac, 0xa2, - 0x41, 0x36, 0x99, 0x99, 0x1c, 0xcb, 0xad, 0xa0, 0xee, 0x34, 0xd3, 0x47, 0xdf, 0x11, 0x97, 0xd2, - 0xf1, 0xcc, 0x63, 0x1d, 0xc6, 0x16, 0x9d, 0x96, 0xb3, 0xe1, 0x35, 0xbd, 0xd8, 0x23, 0x11, 0x7a, - 0x0a, 0x8a, 0x8e, 0xeb, 0x32, 0x6e, 0xab, 0xb4, 0x70, 0xe6, 0x60, 0xbf, 0x5c, 0x9c, 0x77, 0xe9, - 0xb5, 0x0f, 0x0a, 0x6b, 0x0f, 0x53, 0x0c, 0xf4, 0x49, 0x18, 0x70, 0xc3, 0xa0, 0x35, 0x53, 0x60, - 0x98, 0x74, 0xd7, 0x0d, 0x54, 0xc2, 0xa0, 0x95, 0x42, 0x65, 0x38, 0xf6, 0xaf, 0x16, 0xe0, 0xfc, - 0x22, 0x69, 0x6d, 0x2d, 0xd7, 0x72, 0xce, 0xef, 0x2b, 0x30, 0xb2, 0x13, 0xf8, 0x5e, 0x1c, 0x84, - 0x91, 0x68, 0x9a, 0xad, 0x88, 0x55, 0x51, 0x86, 0x15, 0x14, 0x5d, 0x82, 0x81, 0x56, 0xc2, 0x54, - 0x8e, 0x49, 0x86, 0x94, 0xb1, 0x93, 0x0c, 0x42, 0x31, 0xda, 0x11, 0x09, 0xc5, 0x8a, 0x51, 0x18, - 0x77, 0x22, 0x12, 0x62, 0x06, 0x49, 0x6e, 0x66, 0x7a, 0x67, 0x8b, 0x13, 0x3a, 0x75, 0x33, 0x53, - 0x08, 0xd6, 0xb0, 0x50, 0x15, 0x4a, 0x51, 0x6a, 0x66, 0xfb, 0xda, 0xa6, 0xe3, 0xec, 0xea, 0x56, - 0x33, 0x99, 0x10, 0x31, 0x6e, 0x94, 0xa1, 0x9e, 0x57, 0xf7, 0xd7, 0x0a, 0x80, 0xf8, 0x10, 0xfe, - 0x39, 0x1b, 0xb8, 0x3b, 0x9d, 0x03, 0xd7, 0xff, 0x96, 0x38, 0xae, 0xd1, 0xfb, 0x3f, 0x16, 0x9c, - 0x5f, 0xf4, 0x7c, 0x97, 0x84, 0x39, 0x0b, 0xf0, 0xd1, 0xc8, 0xb2, 0x47, 0x63, 0x1a, 0x8c, 0x25, - 0x36, 0x70, 0x0c, 0x4b, 0xcc, 0xfe, 0x23, 0x0b, 0x10, 0xff, 0xec, 0x8f, 0xdc, 0xc7, 0xde, 0xe9, - 0xfc, 0xd8, 0x63, 0x58, 0x16, 0xf6, 0x2d, 0x98, 0x58, 0x6c, 0x7a, 0xc4, 0x8f, 0x57, 0xaa, 0x8b, - 0x81, 0xbf, 0xe9, 0x35, 0xd0, 0x67, 0x60, 0x22, 0xf6, 0x76, 0x48, 0xd0, 0x8e, 0x6b, 0xa4, 0x1e, - 0xf8, 0x4c, 0x92, 0xb4, 0xae, 0x0c, 0x2e, 0xa0, 0x83, 0xfd, 0xf2, 0xc4, 0xba, 0x01, 0xc1, 0x29, - 0x4c, 0xfb, 0xb7, 0xe9, 0xf8, 0x05, 0x3b, 0xad, 0xc0, 0x27, 0x7e, 0xbc, 0x18, 0xf8, 0x2e, 0xd7, - 0x38, 0x7c, 0x06, 0x06, 0x62, 0x3a, 0x1e, 0x7c, 0xec, 0x2e, 0xcb, 0x8d, 0x42, 0x47, 0xe1, 0x70, - 0xbf, 0x7c, 0xb6, 0xb3, 0x06, 0x1b, 0x27, 0x56, 0x07, 0x7d, 0x0b, 0x0c, 0x45, 0xb1, 0x13, 0xb7, - 0x23, 0x31, 0x9a, 0x4f, 0xc8, 0xd1, 0xac, 0xb1, 0xd2, 0xc3, 0xfd, 0xf2, 0xa4, 0xaa, 0xc6, 0x8b, - 0xb0, 0xa8, 0x80, 0x9e, 0x86, 0xe1, 0x1d, 0x12, 0x45, 0x4e, 0x43, 0xde, 0x86, 0x93, 0xa2, 0xee, - 0xf0, 0x2a, 0x2f, 0xc6, 0x12, 0x8e, 0x9e, 0x84, 0x41, 0x12, 0x86, 0x41, 0x28, 0xf6, 0xe8, 0xb8, - 0x40, 0x1c, 0x5c, 0xa2, 0x85, 0x98, 0xc3, 0xec, 0xff, 0x68, 0xc1, 0xa4, 0xea, 0x2b, 0x6f, 0xeb, - 0x04, 0xa4, 0x82, 0xb7, 0x00, 0xea, 0xf2, 0x03, 0x23, 0x76, 0x7b, 0x8c, 0x5e, 0xbb, 0x9c, 0x79, - 0x51, 0x77, 0x0c, 0x63, 0x42, 0x59, 0x15, 0x45, 0x58, 0xa3, 0x66, 0xff, 0x4b, 0x0b, 0x4e, 0xa5, - 0xbe, 0xe8, 0x96, 0x17, 0xc5, 0xe8, 0xed, 0x8e, 0xaf, 0x9a, 0xeb, 0xef, 0xab, 0x68, 0x6d, 0xf6, - 0x4d, 0x6a, 0x29, 0xcb, 0x12, 0xed, 0x8b, 0x6e, 0xc0, 0xa0, 0x17, 0x93, 0x1d, 0xf9, 0x31, 0x4f, - 0x76, 0xfd, 0x18, 0xde, 0xab, 0x64, 0x46, 0x56, 0x68, 0x4d, 0xcc, 0x09, 0xd8, 0x7f, 0xab, 0x08, - 0x25, 0xbe, 0x6c, 0x57, 0x9d, 0xd6, 0x09, 0xcc, 0xc5, 0x0a, 0x0c, 0x30, 0xea, 0xbc, 0xe3, 0x4f, - 0x65, 0x77, 0x5c, 0x74, 0x67, 0x8e, 0x8a, 0xfc, 0x9c, 0x39, 0x52, 0x57, 0x03, 0x2d, 0xc2, 0x8c, - 0x04, 0x72, 0x00, 0x36, 0x3c, 0xdf, 0x09, 0xf7, 0x68, 0xd9, 0x4c, 0x91, 0x11, 0x7c, 0xae, 0x3b, - 0xc1, 0x05, 0x85, 0xcf, 0xc9, 0xaa, 0xbe, 0x26, 0x00, 0xac, 0x11, 0x9d, 0x7d, 0x19, 0x4a, 0x0a, - 0xf9, 0x28, 0x3c, 0xce, 0xec, 0x67, 0x61, 0x32, 0xd5, 0x56, 0xaf, 0xea, 0x63, 0x3a, 0x8b, 0xf4, - 0xcb, 0xec, 0x14, 0x10, 0xbd, 0x5e, 0xf2, 0x77, 0xc5, 0x29, 0xfa, 0x3e, 0x9c, 0x6e, 0x66, 0x1c, - 0x4e, 0x62, 0xaa, 0xfa, 0x3f, 0xcc, 0xce, 0x8b, 0xcf, 0x3e, 0x9d, 0x05, 0xc5, 0x99, 0x6d, 0xd0, - 0x6b, 0x3f, 0x68, 0xd1, 0x35, 0xef, 0x34, 0x75, 0x0e, 0xfa, 0xb6, 0x28, 0xc3, 0x0a, 0x4a, 0x8f, - 0xb0, 0xd3, 0xaa, 0xf3, 0x37, 0xc9, 0x5e, 0x8d, 0x34, 0x49, 0x3d, 0x0e, 0xc2, 0x0f, 0xb5, 0xfb, - 0x17, 0xf8, 0xe8, 0xf3, 0x13, 0x70, 0x54, 0x10, 0x28, 0xde, 0x24, 0x7b, 0x7c, 0x2a, 0xf4, 0xaf, - 0x2b, 0x76, 0xfd, 0xba, 0x9f, 0xb5, 0x60, 0x5c, 0x7d, 0xdd, 0x09, 0x6c, 0xf5, 0x05, 0x73, 0xab, - 0x5f, 0xe8, 0xba, 0xc0, 0x73, 0x36, 0xf9, 0xd7, 0x0a, 0x70, 0x4e, 0xe1, 0x50, 0x76, 0x9f, 0xff, - 0x11, 0xab, 0xea, 0x2a, 0x94, 0x7c, 0xa5, 0x88, 0xb2, 0x4c, 0x0d, 0x50, 0xa2, 0x86, 0x4a, 0x70, - 0x28, 0xd7, 0xe6, 0x27, 0xda, 0xa2, 0x31, 0x5d, 0x43, 0x2b, 0xb4, 0xb1, 0x0b, 0x50, 0x6c, 0x7b, - 0xae, 0xb8, 0x33, 0x3e, 0x25, 0x47, 0xfb, 0xce, 0x4a, 0xe5, 0x70, 0xbf, 0xfc, 0x44, 0xde, 0xeb, - 0x00, 0xbd, 0xac, 0xa2, 0xb9, 0x3b, 0x2b, 0x15, 0x4c, 0x2b, 0xa3, 0x79, 0x98, 0x94, 0x0f, 0x20, - 0x77, 0x29, 0x07, 0x15, 0xf8, 0xe2, 0x6a, 0x51, 0x6a, 0x56, 0x6c, 0x82, 0x71, 0x1a, 0x1f, 0x55, - 0x60, 0x6a, 0xbb, 0xbd, 0x41, 0x9a, 0x24, 0xe6, 0x1f, 0x7c, 0x93, 0x70, 0x25, 0x64, 0x29, 0x11, - 0xb6, 0x6e, 0xa6, 0xe0, 0xb8, 0xa3, 0x86, 0xfd, 0x67, 0xec, 0x88, 0x17, 0xa3, 0x57, 0x0d, 0x03, - 0xba, 0xb0, 0x28, 0xf5, 0x0f, 0x73, 0x39, 0xf7, 0xb3, 0x2a, 0x6e, 0x92, 0xbd, 0xf5, 0x80, 0x32, - 0xdb, 0xd9, 0xab, 0xc2, 0x58, 0xf3, 0x03, 0x5d, 0xd7, 0xfc, 0xcf, 0x17, 0xe0, 0x8c, 0x1a, 0x01, - 0x83, 0xaf, 0xfb, 0xf3, 0x3e, 0x06, 0xcf, 0xc3, 0xa8, 0x4b, 0x36, 0x9d, 0x76, 0x33, 0x56, 0x1a, - 0xf1, 0x41, 0xfe, 0x2a, 0x52, 0x49, 0x8a, 0xb1, 0x8e, 0x73, 0x84, 0x61, 0xfb, 0xf1, 0x51, 0x76, - 0xb7, 0xc6, 0x0e, 0x5d, 0xe3, 0x6a, 0xd7, 0x58, 0xb9, 0xbb, 0xe6, 0x49, 0x18, 0xf4, 0x76, 0x28, - 0xaf, 0x55, 0x30, 0x59, 0xa8, 0x15, 0x5a, 0x88, 0x39, 0x0c, 0x7d, 0x02, 0x86, 0xeb, 0xc1, 0xce, - 0x8e, 0xe3, 0xbb, 0xec, 0xca, 0x2b, 0x2d, 0x8c, 0x52, 0x76, 0x6c, 0x91, 0x17, 0x61, 0x09, 0x43, - 0xe7, 0x61, 0xc0, 0x09, 0x1b, 0x5c, 0x2d, 0x51, 0x5a, 0x18, 0xa1, 0x2d, 0xcd, 0x87, 0x8d, 0x08, - 0xb3, 0x52, 0x2a, 0x55, 0xdd, 0x0f, 0xc2, 0x6d, 0xcf, 0x6f, 0x54, 0xbc, 0x50, 0x6c, 0x09, 0x75, - 0x17, 0xde, 0x53, 0x10, 0xac, 0x61, 0xa1, 0x65, 0x18, 0x6c, 0x05, 0x61, 0x1c, 0xcd, 0x0c, 0xb1, - 0xe1, 0x7e, 0x22, 0xe7, 0x20, 0xe2, 0x5f, 0x5b, 0x0d, 0xc2, 0x38, 0xf9, 0x00, 0xfa, 0x2f, 0xc2, - 0xbc, 0x3a, 0xfa, 0x16, 0x28, 0x12, 0x7f, 0x77, 0x66, 0x98, 0x51, 0x99, 0xcd, 0xa2, 0xb2, 0xe4, - 0xef, 0xde, 0x75, 0xc2, 0xe4, 0x94, 0x5e, 0xf2, 0x77, 0x31, 0xad, 0x83, 0x3e, 0x0f, 0x25, 0xb9, - 0xc5, 0x23, 0xa1, 0x31, 0xcb, 0x5c, 0x62, 0xf2, 0x60, 0xc0, 0xe4, 0xbd, 0xb6, 0x17, 0x92, 0x1d, - 0xe2, 0xc7, 0x51, 0x72, 0xa6, 0x49, 0x68, 0x84, 0x13, 0x6a, 0xe8, 0xf3, 0x52, 0x4d, 0xbb, 0x1a, - 0xb4, 0xfd, 0x38, 0x9a, 0x29, 0xb1, 0xee, 0x65, 0x3e, 0xa0, 0xdd, 0x4d, 0xf0, 0xd2, 0x7a, 0x5c, - 0x5e, 0x19, 0x1b, 0xa4, 0x10, 0x86, 0xf1, 0xa6, 0xb7, 0x4b, 0x7c, 0x12, 0x45, 0xd5, 0x30, 0xd8, - 0x20, 0x33, 0xc0, 0x7a, 0x7e, 0x2e, 0xfb, 0x5d, 0x29, 0xd8, 0x20, 0x0b, 0xd3, 0x07, 0xfb, 0xe5, - 0xf1, 0x5b, 0x7a, 0x1d, 0x6c, 0x92, 0x40, 0x77, 0x60, 0x82, 0xca, 0x35, 0x5e, 0x42, 0x74, 0xb4, - 0x17, 0x51, 0x26, 0x7d, 0x60, 0xa3, 0x12, 0x4e, 0x11, 0x41, 0x6f, 0x40, 0xa9, 0xe9, 0x6d, 0x92, - 0xfa, 0x5e, 0xbd, 0x49, 0x66, 0xc6, 0x18, 0xc5, 0xcc, 0x6d, 0x75, 0x4b, 0x22, 0x71, 0xb9, 0x48, - 0xfd, 0xc5, 0x49, 0x75, 0x74, 0x17, 0xce, 0xc6, 0x24, 0xdc, 0xf1, 0x7c, 0x87, 0x6e, 0x07, 0x21, - 0x2f, 0xb0, 0xd7, 0xb9, 0x71, 0xb6, 0xde, 0x2e, 0x8a, 0xa1, 0x3b, 0xbb, 0x9e, 0x89, 0x85, 0x73, - 0x6a, 0xa3, 0xdb, 0x30, 0xc9, 0x76, 0x42, 0xb5, 0xdd, 0x6c, 0x56, 0x83, 0xa6, 0x57, 0xdf, 0x9b, - 0x99, 0x60, 0x04, 0x3f, 0x21, 0xef, 0x85, 0x15, 0x13, 0x7c, 0xb8, 0x5f, 0x86, 0xe4, 0x1f, 0x4e, - 0xd7, 0x46, 0x1b, 0xec, 0x39, 0xa6, 0x1d, 0x7a, 0xf1, 0x1e, 0x5d, 0xbf, 0xe4, 0x41, 0x3c, 0x33, - 0xd9, 0x55, 0x14, 0xd6, 0x51, 0xd5, 0x9b, 0x8d, 0x5e, 0x88, 0xd3, 0x04, 0xe9, 0xd6, 0x8e, 0x62, - 0xd7, 0xf3, 0x67, 0xa6, 0xd8, 0x89, 0xa1, 0x76, 0x46, 0x8d, 0x16, 0x62, 0x0e, 0x63, 0x4f, 0x31, - 0xf4, 0xc7, 0x6d, 0x7a, 0x82, 0x4e, 0x33, 0xc4, 0xe4, 0x29, 0x46, 0x02, 0x70, 0x82, 0x43, 0x99, - 0x9a, 0x38, 0xde, 0x9b, 0x41, 0x0c, 0x55, 0x6d, 0x97, 0xf5, 0xf5, 0xcf, 0x63, 0x5a, 0x8e, 0x6e, - 0xc1, 0x30, 0xf1, 0x77, 0x97, 0xc3, 0x60, 0x67, 0xe6, 0x54, 0xfe, 0x9e, 0x5d, 0xe2, 0x28, 0xfc, - 0x40, 0x4f, 0x04, 0x3c, 0x51, 0x8c, 0x25, 0x09, 0xf4, 0x00, 0x66, 0x32, 0x66, 0x84, 0x4f, 0xc0, - 0x69, 0x36, 0x01, 0xaf, 0x89, 0xba, 0x33, 0xeb, 0x39, 0x78, 0x87, 0x5d, 0x60, 0x38, 0x97, 0x3a, - 0xfa, 0x02, 0x8c, 0xf3, 0x0d, 0xc5, 0xdf, 0x71, 0xa3, 0x99, 0x33, 0xec, 0x6b, 0x2e, 0xe5, 0x6f, - 0x4e, 0x8e, 0xb8, 0x70, 0x46, 0x74, 0x68, 0x5c, 0x2f, 0x8d, 0xb0, 0x49, 0xcd, 0xde, 0x80, 0x09, - 0x75, 0x6e, 0xb1, 0xa5, 0x83, 0xca, 0x30, 0xc8, 0xb8, 0x1d, 0xa1, 0xdf, 0x2a, 0xd1, 0x99, 0x62, - 0x9c, 0x10, 0xe6, 0xe5, 0x6c, 0xa6, 0xbc, 0xf7, 0xc9, 0xc2, 0x5e, 0x4c, 0xb8, 0x54, 0x5d, 0xd4, - 0x66, 0x4a, 0x02, 0x70, 0x82, 0x63, 0xff, 0x3f, 0xce, 0x35, 0x26, 0x87, 0x63, 0x1f, 0xd7, 0xc1, - 0xb3, 0x30, 0xb2, 0x15, 0x44, 0x31, 0xc5, 0x66, 0x6d, 0x0c, 0x26, 0x7c, 0xe2, 0x0d, 0x51, 0x8e, - 0x15, 0x06, 0x7a, 0x15, 0xc6, 0xeb, 0x7a, 0x03, 0xe2, 0x2e, 0x53, 0x43, 0x60, 0xb4, 0x8e, 0x4d, - 0x5c, 0xf4, 0x0a, 0x8c, 0x30, 0x2b, 0x8c, 0x7a, 0xd0, 0x14, 0x4c, 0x96, 0xbc, 0x90, 0x47, 0xaa, - 0xa2, 0xfc, 0x50, 0xfb, 0x8d, 0x15, 0x36, 0xba, 0x0c, 0x43, 0xb4, 0x0b, 0x2b, 0x55, 0x71, 0x8b, - 0x28, 0x55, 0xcd, 0x0d, 0x56, 0x8a, 0x05, 0xd4, 0xfe, 0x9b, 0x05, 0x6d, 0x94, 0xa9, 0x44, 0x4a, - 0x50, 0x15, 0x86, 0xef, 0x3b, 0x5e, 0xec, 0xf9, 0x0d, 0xc1, 0x2e, 0x3c, 0xdd, 0xf5, 0x4a, 0x61, - 0x95, 0xee, 0xf1, 0x0a, 0xfc, 0xd2, 0x13, 0x7f, 0xb0, 0x24, 0x43, 0x29, 0x86, 0x6d, 0xdf, 0xa7, - 0x14, 0x0b, 0xfd, 0x52, 0xc4, 0xbc, 0x02, 0xa7, 0x28, 0xfe, 0x60, 0x49, 0x06, 0xbd, 0x0d, 0x20, - 0x97, 0x25, 0x71, 0x85, 0xf5, 0xc3, 0xb3, 0xbd, 0x89, 0xae, 0xab, 0x3a, 0x0b, 0x13, 0xf4, 0x4a, - 0x4d, 0xfe, 0x63, 0x8d, 0x9e, 0x1d, 0x33, 0xb6, 0xaa, 0xb3, 0x33, 0xe8, 0xdb, 0xe9, 0x49, 0xe0, - 0x84, 0x31, 0x71, 0xe7, 0x63, 0x31, 0x38, 0x9f, 0xec, 0x4f, 0xa6, 0x58, 0xf7, 0x76, 0x88, 0x7e, - 0x6a, 0x08, 0x22, 0x38, 0xa1, 0x67, 0xff, 0x62, 0x11, 0x66, 0xf2, 0xba, 0x4b, 0x17, 0x1d, 0x79, - 0xe0, 0xc5, 0x8b, 0x94, 0x1b, 0xb2, 0xcc, 0x45, 0xb7, 0x24, 0xca, 0xb1, 0xc2, 0xa0, 0xb3, 0x1f, - 0x79, 0x0d, 0x29, 0x12, 0x0e, 0x26, 0xb3, 0x5f, 0x63, 0xa5, 0x58, 0x40, 0x29, 0x5e, 0x48, 0x9c, - 0x48, 0x98, 0xd7, 0x68, 0xab, 0x04, 0xb3, 0x52, 0x2c, 0xa0, 0xba, 0xbe, 0x69, 0xa0, 0x87, 0xbe, - 0xc9, 0x18, 0xa2, 0xc1, 0xe3, 0x1d, 0x22, 0xf4, 0x45, 0x80, 0x4d, 0xcf, 0xf7, 0xa2, 0x2d, 0x46, - 0x7d, 0xe8, 0xc8, 0xd4, 0x15, 0x2f, 0xb5, 0xac, 0xa8, 0x60, 0x8d, 0x22, 0x7a, 0x09, 0x46, 0xd5, - 0x06, 0x5c, 0xa9, 0xb0, 0xb7, 0x46, 0xcd, 0x76, 0x23, 0x39, 0x8d, 0x2a, 0x58, 0xc7, 0xb3, 0xdf, - 0x4d, 0xaf, 0x17, 0xb1, 0x03, 0xb4, 0xf1, 0xb5, 0xfa, 0x1d, 0xdf, 0x42, 0xf7, 0xf1, 0xb5, 0x7f, - 0xad, 0x08, 0x93, 0x46, 0x63, 0xed, 0xa8, 0x8f, 0x33, 0xeb, 0x3a, 0xbd, 0xe7, 0x9c, 0x98, 0x88, - 0xfd, 0x67, 0xf7, 0xde, 0x2a, 0xfa, 0x5d, 0x48, 0x77, 0x00, 0xaf, 0x8f, 0xbe, 0x08, 0xa5, 0xa6, - 0x13, 0x31, 0xdd, 0x15, 0x11, 0xfb, 0xae, 0x1f, 0x62, 0x89, 0x1c, 0xe1, 0x44, 0xb1, 0x76, 0xd5, - 0x70, 0xda, 0x09, 0x49, 0x7a, 0x21, 0x53, 0xde, 0x47, 0xda, 0x6f, 0xa9, 0x4e, 0x50, 0x06, 0x69, - 0x0f, 0x73, 0x18, 0x7a, 0x05, 0xc6, 0x42, 0xc2, 0x56, 0xc5, 0x22, 0x65, 0xe5, 0xd8, 0x32, 0x1b, - 0x4c, 0x78, 0x3e, 0xac, 0xc1, 0xb0, 0x81, 0x99, 0xb0, 0xf2, 0x43, 0x5d, 0x58, 0xf9, 0xa7, 0x61, - 0x98, 0xfd, 0x50, 0x2b, 0x40, 0xcd, 0xc6, 0x0a, 0x2f, 0xc6, 0x12, 0x9e, 0x5e, 0x30, 0x23, 0x7d, - 0x2e, 0x98, 0x4f, 0xc2, 0x44, 0xc5, 0x21, 0x3b, 0x81, 0xbf, 0xe4, 0xbb, 0xad, 0xc0, 0xf3, 0x63, - 0x34, 0x03, 0x03, 0xec, 0x76, 0xe0, 0x7b, 0x7b, 0x80, 0x52, 0xc0, 0x03, 0x94, 0x31, 0xb7, 0x1b, - 0x70, 0xa6, 0x12, 0xdc, 0xf7, 0xef, 0x3b, 0xa1, 0x3b, 0x5f, 0x5d, 0xd1, 0xe4, 0xdc, 0x35, 0x29, - 0x67, 0x71, 0x7b, 0xa8, 0xcc, 0x33, 0x55, 0xab, 0xc9, 0xef, 0xda, 0x65, 0xaf, 0x49, 0x72, 0xb4, - 0x11, 0x7f, 0xa7, 0x60, 0xb4, 0x94, 0xe0, 0xab, 0x07, 0x23, 0x2b, 0xf7, 0xc1, 0xe8, 0x4d, 0x18, - 0xd9, 0xf4, 0x48, 0xd3, 0xc5, 0x64, 0x53, 0x2c, 0xb1, 0xa7, 0xf2, 0x4d, 0x3c, 0x96, 0x29, 0xa6, - 0xd4, 0x3e, 0x71, 0x29, 0x6d, 0x59, 0x54, 0xc6, 0x8a, 0x0c, 0xda, 0x86, 0x29, 0x29, 0x06, 0x48, - 0xa8, 0x58, 0x70, 0x4f, 0x77, 0x93, 0x2d, 0x4c, 0xe2, 0xa7, 0x0f, 0xf6, 0xcb, 0x53, 0x38, 0x45, - 0x06, 0x77, 0x10, 0xa6, 0x62, 0xd9, 0x0e, 0x3d, 0x5a, 0x07, 0xd8, 0xf0, 0x33, 0xb1, 0x8c, 0x49, - 0x98, 0xac, 0xd4, 0xfe, 0x11, 0x0b, 0x1e, 0xeb, 0x18, 0x19, 0x21, 0x69, 0x1f, 0xf3, 0x2c, 0xa4, - 0x25, 0xdf, 0x42, 0x6f, 0xc9, 0xd7, 0xfe, 0x19, 0x0b, 0x4e, 0x2f, 0xed, 0xb4, 0xe2, 0xbd, 0x8a, - 0x67, 0xbe, 0xee, 0xbc, 0x0c, 0x43, 0x3b, 0xc4, 0xf5, 0xda, 0x3b, 0x62, 0xe6, 0xca, 0xf2, 0xf8, - 0x59, 0x65, 0xa5, 0x87, 0xfb, 0xe5, 0xf1, 0x5a, 0x1c, 0x84, 0x4e, 0x83, 0xf0, 0x02, 0x2c, 0xd0, - 0xd9, 0x21, 0xee, 0xbd, 0x4f, 0x6e, 0x79, 0x3b, 0x9e, 0x34, 0xd9, 0xe9, 0xaa, 0x3b, 0x9b, 0x93, - 0x03, 0x3a, 0xf7, 0x66, 0xdb, 0xf1, 0x63, 0x2f, 0xde, 0x13, 0x0f, 0x33, 0x92, 0x08, 0x4e, 0xe8, - 0xd9, 0xdf, 0xb0, 0x60, 0x52, 0xae, 0xfb, 0x79, 0xd7, 0x0d, 0x49, 0x14, 0xa1, 0x59, 0x28, 0x78, - 0x2d, 0xd1, 0x4b, 0x10, 0xbd, 0x2c, 0xac, 0x54, 0x71, 0xc1, 0x6b, 0xa1, 0x2a, 0x94, 0xb8, 0xe5, - 0x4f, 0xb2, 0xb8, 0xfa, 0xb2, 0x1f, 0x62, 0x3d, 0x58, 0x97, 0x35, 0x71, 0x42, 0x44, 0x72, 0x70, - 0xec, 0xcc, 0x2c, 0x9a, 0xaf, 0x5e, 0x37, 0x44, 0x39, 0x56, 0x18, 0xe8, 0x0a, 0x8c, 0xf8, 0x81, - 0xcb, 0x0d, 0xb1, 0xf8, 0xed, 0xc7, 0x96, 0xec, 0x9a, 0x28, 0xc3, 0x0a, 0x6a, 0xff, 0xa0, 0x05, - 0x63, 0xf2, 0xcb, 0xfa, 0x64, 0x26, 0xe9, 0xd6, 0x4a, 0x18, 0xc9, 0x64, 0x6b, 0x51, 0x66, 0x90, - 0x41, 0x0c, 0x1e, 0xb0, 0x78, 0x14, 0x1e, 0xd0, 0xfe, 0xe1, 0x02, 0x4c, 0xc8, 0xee, 0xd4, 0xda, - 0x1b, 0x11, 0x89, 0xd1, 0x3a, 0x94, 0x1c, 0x3e, 0xe4, 0x44, 0xae, 0xd8, 0x27, 0xb3, 0x85, 0x0f, - 0x63, 0x7e, 0x92, 0x6b, 0x79, 0x5e, 0xd6, 0xc6, 0x09, 0x21, 0xd4, 0x84, 0x69, 0x3f, 0x88, 0xd9, - 0x11, 0xad, 0xe0, 0xdd, 0x9e, 0x40, 0xd2, 0xd4, 0xcf, 0x09, 0xea, 0xd3, 0x6b, 0x69, 0x2a, 0xb8, - 0x93, 0x30, 0x5a, 0x92, 0x0a, 0x8f, 0x62, 0xbe, 0xb8, 0xa1, 0xcf, 0x42, 0xb6, 0xbe, 0xc3, 0xfe, - 0x15, 0x0b, 0x4a, 0x12, 0xed, 0x24, 0x5e, 0xbb, 0x56, 0x61, 0x38, 0x62, 0x93, 0x20, 0x87, 0xc6, - 0xee, 0xd6, 0x71, 0x3e, 0x5f, 0xc9, 0xcd, 0xc3, 0xff, 0x47, 0x58, 0xd2, 0x60, 0xfa, 0x6e, 0xd5, - 0xfd, 0x8f, 0x88, 0xbe, 0x5b, 0xf5, 0x27, 0xe7, 0x86, 0xf9, 0x7d, 0xd6, 0x67, 0x4d, 0xac, 0xa5, - 0x0c, 0x52, 0x2b, 0x24, 0x9b, 0xde, 0x83, 0x34, 0x83, 0x54, 0x65, 0xa5, 0x58, 0x40, 0xd1, 0xdb, - 0x30, 0x56, 0x97, 0x8a, 0xce, 0xe4, 0x18, 0xb8, 0xdc, 0x55, 0xe9, 0xae, 0xde, 0x67, 0xb8, 0x91, - 0xf6, 0xa2, 0x56, 0x1f, 0x1b, 0xd4, 0xcc, 0xe7, 0xf6, 0x62, 0xaf, 0xe7, 0xf6, 0x84, 0x6e, 0xfe, - 0xe3, 0xf3, 0x8f, 0x5a, 0x30, 0xc4, 0xd5, 0x65, 0xfd, 0xe9, 0x17, 0xb5, 0xe7, 0xaa, 0x64, 0xec, - 0xee, 0xd2, 0x42, 0xf1, 0xfc, 0x84, 0x56, 0xa1, 0xc4, 0x7e, 0x30, 0xb5, 0x41, 0x31, 0xdf, 0x3a, - 0x9d, 0xb7, 0xaa, 0x77, 0xf0, 0xae, 0xac, 0x86, 0x13, 0x0a, 0xf6, 0x57, 0x8b, 0xf4, 0xa8, 0x4a, - 0x50, 0x8d, 0x1b, 0xdc, 0x7a, 0x74, 0x37, 0x78, 0xe1, 0x51, 0xdd, 0xe0, 0x0d, 0x98, 0xac, 0x6b, - 0x8f, 0x5b, 0xc9, 0x4c, 0x5e, 0xe9, 0xba, 0x48, 0xb4, 0x77, 0x30, 0xae, 0x32, 0x5a, 0x34, 0x89, - 0xe0, 0x34, 0x55, 0xf4, 0xed, 0x30, 0xc6, 0xe7, 0x59, 0xb4, 0xc2, 0x2d, 0x16, 0x3e, 0x91, 0xbf, - 0x5e, 0xf4, 0x26, 0xd8, 0x4a, 0xac, 0x69, 0xd5, 0xb1, 0x41, 0xcc, 0xfe, 0xc5, 0x11, 0x18, 0x5c, - 0xda, 0x25, 0x7e, 0x7c, 0x02, 0x07, 0x52, 0x1d, 0x26, 0x3c, 0x7f, 0x37, 0x68, 0xee, 0x12, 0x97, - 0xc3, 0x8f, 0x72, 0xb9, 0x9e, 0x15, 0xa4, 0x27, 0x56, 0x0c, 0x12, 0x38, 0x45, 0xf2, 0x51, 0x48, - 0x98, 0xd7, 0x61, 0x88, 0xcf, 0xbd, 0x10, 0x2f, 0x33, 0x95, 0xc1, 0x6c, 0x10, 0xc5, 0x2e, 0x48, - 0xa4, 0x5f, 0xae, 0x7d, 0x16, 0xd5, 0xd1, 0xbb, 0x30, 0xb1, 0xe9, 0x85, 0x51, 0x4c, 0x45, 0xc3, - 0x28, 0x76, 0x76, 0x5a, 0x0f, 0x21, 0x51, 0xaa, 0x71, 0x58, 0x36, 0x28, 0xe1, 0x14, 0x65, 0xd4, - 0x80, 0x71, 0x2a, 0xe4, 0x24, 0x4d, 0x0d, 0x1f, 0xb9, 0x29, 0xa5, 0x32, 0xba, 0xa5, 0x13, 0xc2, - 0x26, 0x5d, 0x7a, 0x98, 0xd4, 0x99, 0x50, 0x34, 0xc2, 0x38, 0x0a, 0x75, 0x98, 0x70, 0x69, 0x88, - 0xc3, 0xe8, 0x99, 0xc4, 0xcc, 0x56, 0x4a, 0xe6, 0x99, 0xa4, 0x19, 0xa7, 0xbc, 0x03, 0x25, 0x42, - 0x87, 0x90, 0x12, 0x16, 0x8a, 0xf1, 0xab, 0xfd, 0xf5, 0x75, 0xd5, 0xab, 0x87, 0x81, 0x29, 0xcb, - 0x2f, 0x49, 0x4a, 0x38, 0x21, 0x8a, 0x16, 0x61, 0x28, 0x22, 0xa1, 0x47, 0x22, 0xa1, 0x22, 0xef, - 0x32, 0x8d, 0x0c, 0x8d, 0x5b, 0x7c, 0xf2, 0xdf, 0x58, 0x54, 0xa5, 0xcb, 0xcb, 0x61, 0xd2, 0x10, - 0xd3, 0x8a, 0x6b, 0xcb, 0x6b, 0x9e, 0x95, 0x62, 0x01, 0x45, 0x6f, 0xc0, 0x70, 0x48, 0x9a, 0x4c, - 0x59, 0x34, 0xde, 0xff, 0x22, 0xe7, 0xba, 0x27, 0x5e, 0x0f, 0x4b, 0x02, 0xe8, 0x26, 0xa0, 0x90, - 0x50, 0x1e, 0xc2, 0xf3, 0x1b, 0xca, 0x98, 0x43, 0xe8, 0xba, 0x1f, 0x17, 0xed, 0x9f, 0xc2, 0x09, - 0x86, 0x34, 0xbe, 0xc5, 0x19, 0xd5, 0xd0, 0x75, 0x98, 0x56, 0xa5, 0x2b, 0x7e, 0x14, 0x3b, 0x7e, - 0x9d, 0x30, 0x35, 0x77, 0x29, 0xe1, 0x8a, 0x70, 0x1a, 0x01, 0x77, 0xd6, 0xb1, 0x7f, 0x8a, 0xb2, - 0x33, 0x74, 0xb4, 0x4e, 0x80, 0x17, 0x78, 0xdd, 0xe4, 0x05, 0xce, 0xe5, 0xce, 0x5c, 0x0e, 0x1f, - 0x70, 0x60, 0xc1, 0xa8, 0x36, 0xb3, 0xc9, 0x9a, 0xb5, 0xba, 0xac, 0xd9, 0x36, 0x4c, 0xd1, 0x95, - 0x7e, 0x7b, 0x23, 0x22, 0xe1, 0x2e, 0x71, 0xd9, 0xc2, 0x2c, 0x3c, 0xdc, 0xc2, 0x54, 0xaf, 0xcc, - 0xb7, 0x52, 0x04, 0x71, 0x47, 0x13, 0xe8, 0x65, 0xa9, 0x39, 0x29, 0x1a, 0x46, 0x5a, 0x5c, 0x2b, - 0x72, 0xb8, 0x5f, 0x9e, 0xd2, 0x3e, 0x44, 0xd7, 0x94, 0xd8, 0xef, 0xc8, 0x6f, 0x54, 0xaf, 0xf9, - 0x75, 0xb5, 0x58, 0x52, 0xaf, 0xf9, 0x6a, 0x39, 0xe0, 0x04, 0x87, 0xee, 0x51, 0x2a, 0x82, 0xa4, - 0x5f, 0xf3, 0xa9, 0x80, 0x82, 0x19, 0xc4, 0x7e, 0x01, 0x60, 0xe9, 0x01, 0xa9, 0xf3, 0xa5, 0xae, - 0x3f, 0x40, 0x5a, 0xf9, 0x0f, 0x90, 0xf6, 0x7f, 0xb6, 0x60, 0x62, 0x79, 0xd1, 0x10, 0x13, 0xe7, - 0x00, 0xb8, 0x6c, 0x74, 0xef, 0xde, 0x9a, 0xd4, 0xad, 0x73, 0xf5, 0xa8, 0x2a, 0xc5, 0x1a, 0x06, - 0x3a, 0x07, 0xc5, 0x66, 0xdb, 0x17, 0x22, 0xcb, 0xf0, 0xc1, 0x7e, 0xb9, 0x78, 0xab, 0xed, 0x63, - 0x5a, 0xa6, 0x59, 0x08, 0x16, 0xfb, 0xb6, 0x10, 0xec, 0xe9, 0xa9, 0x87, 0xca, 0x30, 0x78, 0xff, - 0xbe, 0xe7, 0x72, 0x7f, 0x08, 0xa1, 0xf7, 0xbf, 0x77, 0x6f, 0xa5, 0x12, 0x61, 0x5e, 0x6e, 0x7f, - 0xa5, 0x08, 0xb3, 0xcb, 0x4d, 0xf2, 0xe0, 0x03, 0xfa, 0x84, 0xf4, 0x6b, 0xdf, 0x78, 0x34, 0x7e, - 0xf1, 0xa8, 0x36, 0xac, 0xbd, 0xc7, 0x63, 0x13, 0x86, 0xf9, 0x63, 0xb6, 0xf4, 0x10, 0x79, 0x35, - 0xab, 0xf5, 0xfc, 0x01, 0x99, 0xe3, 0x8f, 0xe2, 0xc2, 0xc0, 0x5d, 0xdd, 0xb4, 0xa2, 0x14, 0x4b, - 0xe2, 0xb3, 0x9f, 0x81, 0x31, 0x1d, 0xf3, 0x48, 0xd6, 0xe4, 0x7f, 0xa5, 0x08, 0x53, 0xb4, 0x07, - 0x8f, 0x74, 0x22, 0xee, 0x74, 0x4e, 0xc4, 0x71, 0x5b, 0x14, 0xf7, 0x9e, 0x8d, 0xb7, 0xd3, 0xb3, - 0xf1, 0x7c, 0xde, 0x6c, 0x9c, 0xf4, 0x1c, 0x7c, 0x8f, 0x05, 0xa7, 0x96, 0x9b, 0x41, 0x7d, 0x3b, - 0x65, 0xf5, 0xfb, 0x12, 0x8c, 0xd2, 0x73, 0x3c, 0x32, 0x1c, 0xd2, 0x0c, 0x17, 0x45, 0x01, 0xc2, - 0x3a, 0x9e, 0x56, 0xed, 0xce, 0x9d, 0x95, 0x4a, 0x96, 0x67, 0xa3, 0x00, 0x61, 0x1d, 0xcf, 0xfe, - 0xba, 0x05, 0x17, 0xae, 0x2f, 0x2e, 0x25, 0x4b, 0xb1, 0xc3, 0xb9, 0x92, 0x4a, 0x81, 0xae, 0xd6, - 0x95, 0x44, 0x0a, 0xac, 0xb0, 0x5e, 0x08, 0xe8, 0x47, 0xc5, 0x71, 0xf8, 0x27, 0x2d, 0x38, 0x75, - 0xdd, 0x8b, 0xe9, 0xb5, 0x9c, 0x76, 0xf3, 0xa3, 0xf7, 0x72, 0xe4, 0xc5, 0x41, 0xb8, 0x97, 0x76, - 0xf3, 0xc3, 0x0a, 0x82, 0x35, 0x2c, 0xde, 0xf2, 0xae, 0xc7, 0xcc, 0xa8, 0x0a, 0xa6, 0x2a, 0x0a, - 0x8b, 0x72, 0xac, 0x30, 0xe8, 0x87, 0xb9, 0x5e, 0xc8, 0x44, 0x89, 0x3d, 0x71, 0xc2, 0xaa, 0x0f, - 0xab, 0x48, 0x00, 0x4e, 0x70, 0xec, 0x3f, 0xb4, 0xa0, 0x7c, 0xbd, 0xd9, 0x8e, 0x62, 0x12, 0x6e, - 0x46, 0x39, 0xa7, 0xe3, 0x0b, 0x50, 0x22, 0x52, 0x70, 0x17, 0xbd, 0x56, 0xac, 0xa6, 0x92, 0xe8, - 0xb9, 0xb7, 0xa1, 0xc2, 0xeb, 0xc3, 0x87, 0xe0, 0x68, 0x46, 0xe0, 0xcb, 0x80, 0x88, 0xde, 0x96, - 0xee, 0x7e, 0xc9, 0xfc, 0xb8, 0x96, 0x3a, 0xa0, 0x38, 0xa3, 0x86, 0xfd, 0x23, 0x16, 0x9c, 0x51, - 0x1f, 0xfc, 0x91, 0xfb, 0x4c, 0xfb, 0xe7, 0x0a, 0x30, 0x7e, 0x63, 0x7d, 0xbd, 0x7a, 0x9d, 0xc4, - 0xe2, 0xda, 0xee, 0xad, 0x5b, 0xc7, 0x9a, 0x8a, 0xb0, 0x9b, 0x14, 0xd8, 0x8e, 0xbd, 0xe6, 0x1c, - 0xf7, 0xe2, 0x9f, 0x5b, 0xf1, 0xe3, 0xdb, 0x61, 0x2d, 0x0e, 0x3d, 0xbf, 0x91, 0xa9, 0x54, 0x94, - 0xcc, 0x45, 0x31, 0x8f, 0xb9, 0x40, 0x2f, 0xc0, 0x10, 0x0b, 0x23, 0x20, 0x27, 0xe1, 0x71, 0x25, - 0x44, 0xb1, 0xd2, 0xc3, 0xfd, 0x72, 0xe9, 0x0e, 0x5e, 0xe1, 0x7f, 0xb0, 0x40, 0x45, 0x77, 0x60, - 0x74, 0x2b, 0x8e, 0x5b, 0x37, 0x88, 0xe3, 0x92, 0x50, 0x1e, 0x87, 0x17, 0xb3, 0x8e, 0x43, 0x3a, - 0x08, 0x1c, 0x2d, 0x39, 0x41, 0x92, 0xb2, 0x08, 0xeb, 0x74, 0xec, 0x1a, 0x40, 0x02, 0x3b, 0x26, - 0x85, 0x8a, 0xfd, 0x7b, 0x16, 0x0c, 0x73, 0x8f, 0xce, 0x10, 0xbd, 0x06, 0x03, 0xe4, 0x01, 0xa9, - 0x0b, 0x56, 0x39, 0xb3, 0xc3, 0x09, 0xa7, 0xc5, 0x9f, 0x07, 0xe8, 0x7f, 0xcc, 0x6a, 0xa1, 0x1b, - 0x30, 0x4c, 0x7b, 0x7b, 0x5d, 0xb9, 0xb7, 0x3e, 0x91, 0xf7, 0xc5, 0x6a, 0xda, 0x39, 0x73, 0x26, - 0x8a, 0xb0, 0xac, 0xce, 0x54, 0xdd, 0xf5, 0x56, 0x8d, 0x9e, 0xd8, 0x71, 0x37, 0xc6, 0x62, 0x7d, - 0xb1, 0xca, 0x91, 0x04, 0x35, 0xae, 0xea, 0x96, 0x85, 0x38, 0x21, 0x62, 0xaf, 0x43, 0x89, 0x4e, - 0xea, 0x7c, 0xd3, 0x73, 0xba, 0x6b, 0xd9, 0x9f, 0x81, 0x92, 0xd4, 0x78, 0x47, 0xc2, 0x93, 0x8b, - 0x51, 0x95, 0x0a, 0xf1, 0x08, 0x27, 0x70, 0x7b, 0x13, 0x4e, 0x33, 0x53, 0x07, 0x27, 0xde, 0x32, - 0xf6, 0x58, 0xef, 0xc5, 0xfc, 0xac, 0x90, 0x3c, 0xf9, 0xcc, 0xcc, 0x68, 0xce, 0x12, 0x63, 0x92, - 0x62, 0x22, 0x85, 0xda, 0x7f, 0x30, 0x00, 0x8f, 0xaf, 0xd4, 0xf2, 0x9d, 0x7d, 0x5f, 0x81, 0x31, - 0xce, 0x97, 0xd2, 0xa5, 0xed, 0x34, 0x45, 0xbb, 0xea, 0x21, 0x70, 0x5d, 0x83, 0x61, 0x03, 0x13, - 0x5d, 0x80, 0xa2, 0xf7, 0x9e, 0x9f, 0xb6, 0x3b, 0x5e, 0x79, 0x73, 0x0d, 0xd3, 0x72, 0x0a, 0xa6, - 0x2c, 0x2e, 0xbf, 0x3b, 0x14, 0x58, 0xb1, 0xb9, 0xaf, 0xc3, 0x84, 0x17, 0xd5, 0x23, 0x6f, 0xc5, - 0xa7, 0xe7, 0x8c, 0x76, 0x52, 0x29, 0xad, 0x08, 0xed, 0xb4, 0x82, 0xe2, 0x14, 0xb6, 0x76, 0x91, - 0x0d, 0xf6, 0xcd, 0x26, 0xf7, 0x74, 0x6d, 0xa2, 0x12, 0x40, 0x8b, 0x7d, 0x5d, 0xc4, 0xac, 0xf8, - 0x84, 0x04, 0xc0, 0x3f, 0x38, 0xc2, 0x12, 0x46, 0x45, 0xce, 0xfa, 0x96, 0xd3, 0x9a, 0x6f, 0xc7, - 0x5b, 0x15, 0x2f, 0xaa, 0x07, 0xbb, 0x24, 0xdc, 0x63, 0xda, 0x82, 0x91, 0x44, 0xe4, 0x54, 0x80, - 0xc5, 0x1b, 0xf3, 0x55, 0x8a, 0x89, 0x3b, 0xeb, 0x98, 0x6c, 0x30, 0x1c, 0x07, 0x1b, 0x3c, 0x0f, - 0x93, 0xb2, 0x99, 0x1a, 0x89, 0xd8, 0xa5, 0x38, 0xca, 0x3a, 0xa6, 0x6c, 0x8b, 0x45, 0xb1, 0xea, - 0x56, 0x1a, 0x1f, 0xbd, 0x0c, 0xe3, 0x9e, 0xef, 0xc5, 0x9e, 0x13, 0x07, 0x21, 0x63, 0x29, 0xb8, - 0x62, 0x80, 0x99, 0xee, 0xad, 0xe8, 0x00, 0x6c, 0xe2, 0xd9, 0xff, 0x7d, 0x00, 0xa6, 0xd9, 0xb4, - 0x7d, 0x73, 0x85, 0x7d, 0x64, 0x56, 0xd8, 0x9d, 0xce, 0x15, 0x76, 0x1c, 0xfc, 0xfd, 0x87, 0xb9, - 0xcc, 0xde, 0x85, 0x92, 0x32, 0x7e, 0x96, 0xde, 0x0f, 0x56, 0x8e, 0xf7, 0x43, 0x6f, 0xee, 0x43, - 0xbe, 0x5b, 0x17, 0x33, 0xdf, 0xad, 0xff, 0x9e, 0x05, 0x89, 0x0d, 0x28, 0xba, 0x01, 0xa5, 0x56, - 0xc0, 0xec, 0x2c, 0x42, 0x69, 0xbc, 0xf4, 0x78, 0xe6, 0x45, 0xc5, 0x2f, 0x45, 0x3e, 0x7e, 0x55, - 0x59, 0x03, 0x27, 0x95, 0xd1, 0x02, 0x0c, 0xb7, 0x42, 0x52, 0x8b, 0x99, 0xcf, 0x6f, 0x4f, 0x3a, - 0x7c, 0x8d, 0x70, 0x7c, 0x2c, 0x2b, 0xda, 0x3f, 0x6f, 0x01, 0xf0, 0xa7, 0x61, 0xc7, 0x6f, 0x90, - 0x13, 0x50, 0x77, 0x57, 0x60, 0x20, 0x6a, 0x91, 0x7a, 0x37, 0x0b, 0x98, 0xa4, 0x3f, 0xb5, 0x16, - 0xa9, 0x27, 0x03, 0x4e, 0xff, 0x61, 0x56, 0xdb, 0xfe, 0x5e, 0x80, 0x89, 0x04, 0x6d, 0x25, 0x26, - 0x3b, 0xe8, 0x39, 0xc3, 0x07, 0xf0, 0x5c, 0xca, 0x07, 0xb0, 0xc4, 0xb0, 0x35, 0xcd, 0xea, 0xbb, - 0x50, 0xdc, 0x71, 0x1e, 0x08, 0xd5, 0xd9, 0x33, 0xdd, 0xbb, 0x41, 0xe9, 0xcf, 0xad, 0x3a, 0x0f, - 0xb8, 0x90, 0xf8, 0x8c, 0x5c, 0x20, 0xab, 0xce, 0x83, 0x43, 0x6e, 0xe7, 0xc2, 0x0e, 0xa9, 0x5b, - 0x5e, 0x14, 0x7f, 0xe9, 0xbf, 0x25, 0xff, 0xd9, 0xb2, 0xa3, 0x8d, 0xb0, 0xb6, 0x3c, 0x5f, 0x3c, - 0x94, 0xf6, 0xd5, 0x96, 0xe7, 0xa7, 0xdb, 0xf2, 0xfc, 0x3e, 0xda, 0xf2, 0x7c, 0xf4, 0x3e, 0x0c, - 0x0b, 0xa3, 0x04, 0xe1, 0x73, 0x7f, 0xb5, 0x8f, 0xf6, 0x84, 0x4d, 0x03, 0x6f, 0xf3, 0xaa, 0x14, - 0x82, 0x45, 0x69, 0xcf, 0x76, 0x65, 0x83, 0xe8, 0x6f, 0x5b, 0x30, 0x21, 0x7e, 0x63, 0xf2, 0x5e, - 0x9b, 0x44, 0xb1, 0xe0, 0x3d, 0x3f, 0xdd, 0x7f, 0x1f, 0x44, 0x45, 0xde, 0x95, 0x4f, 0xcb, 0x63, - 0xd6, 0x04, 0xf6, 0xec, 0x51, 0xaa, 0x17, 0xe8, 0x9f, 0x58, 0x70, 0x7a, 0xc7, 0x79, 0xc0, 0x5b, - 0xe4, 0x65, 0xd8, 0x89, 0xbd, 0x40, 0x18, 0xeb, 0xbf, 0xd6, 0xdf, 0xf4, 0x77, 0x54, 0xe7, 0x9d, - 0x94, 0x76, 0xbd, 0xa7, 0xb3, 0x50, 0x7a, 0x76, 0x35, 0xb3, 0x5f, 0xb3, 0x9b, 0x30, 0x22, 0xd7, - 0x5b, 0x86, 0xaa, 0xa1, 0xa2, 0x33, 0xd6, 0x47, 0xb6, 0x09, 0xd1, 0x1d, 0xf1, 0x68, 0x3b, 0x62, - 0xad, 0x3d, 0xd2, 0x76, 0xde, 0x85, 0x31, 0x7d, 0x8d, 0x3d, 0xd2, 0xb6, 0xde, 0x83, 0x53, 0x19, - 0x6b, 0xe9, 0x91, 0x36, 0x79, 0x1f, 0xce, 0xe5, 0xae, 0x8f, 0x47, 0xd9, 0xb0, 0xfd, 0x73, 0x96, - 0x7e, 0x0e, 0x9e, 0xc0, 0x9b, 0xc3, 0xa2, 0xf9, 0xe6, 0x70, 0xb1, 0xfb, 0xce, 0xc9, 0x79, 0x78, - 0x78, 0x5b, 0xef, 0x34, 0x3d, 0xd5, 0xd1, 0x1b, 0x30, 0xd4, 0xa4, 0x25, 0xd2, 0x1a, 0xc6, 0xee, - 0xbd, 0x23, 0x13, 0x5e, 0x8a, 0x95, 0x47, 0x58, 0x50, 0xb0, 0x7f, 0xc9, 0x82, 0x81, 0x13, 0x18, - 0x09, 0x6c, 0x8e, 0xc4, 0x73, 0xb9, 0xa4, 0x45, 0x38, 0xc0, 0x39, 0xec, 0xdc, 0x5f, 0x7a, 0x10, - 0x13, 0x3f, 0x62, 0xa2, 0x62, 0xe6, 0xc0, 0x7c, 0x07, 0x9c, 0xba, 0x15, 0x38, 0xee, 0x82, 0xd3, - 0x74, 0xfc, 0x3a, 0x09, 0x57, 0xfc, 0x46, 0x4f, 0xb3, 0x2c, 0xdd, 0x88, 0xaa, 0xd0, 0xcb, 0x88, - 0xca, 0xde, 0x02, 0xa4, 0x37, 0x20, 0x0c, 0x57, 0x31, 0x0c, 0x7b, 0xbc, 0x29, 0x31, 0xfc, 0x4f, - 0x65, 0x73, 0x77, 0x1d, 0x3d, 0xd3, 0x4c, 0x32, 0x79, 0x01, 0x96, 0x84, 0xec, 0x57, 0x20, 0xd3, - 0x59, 0xad, 0xb7, 0xda, 0xc0, 0xfe, 0x3c, 0x4c, 0xb3, 0x9a, 0x47, 0x14, 0x69, 0xed, 0x94, 0x56, - 0x32, 0x23, 0x32, 0x8d, 0xfd, 0x65, 0x0b, 0x26, 0xd7, 0x52, 0x01, 0x3b, 0x2e, 0xb3, 0x07, 0xd0, - 0x0c, 0x65, 0x78, 0x8d, 0x95, 0x62, 0x01, 0x3d, 0x76, 0x1d, 0xd4, 0x9f, 0x59, 0x90, 0xf8, 0x8f, - 0x9e, 0x00, 0xe3, 0xb5, 0x68, 0x30, 0x5e, 0x99, 0xba, 0x11, 0xd5, 0x9d, 0x3c, 0xbe, 0x0b, 0xdd, - 0x54, 0xc1, 0x12, 0xba, 0xa8, 0x45, 0x12, 0x32, 0xdc, 0xb5, 0x7e, 0xc2, 0x8c, 0xa8, 0x20, 0xc3, - 0x27, 0x30, 0xdb, 0x29, 0x85, 0xfb, 0x11, 0xb1, 0x9d, 0x52, 0xfd, 0xc9, 0xd9, 0xa1, 0x55, 0xad, - 0xcb, 0xec, 0xe4, 0xfa, 0x56, 0x66, 0x0b, 0xef, 0x34, 0xbd, 0xf7, 0x89, 0x8a, 0xf8, 0x52, 0x16, - 0xb6, 0xed, 0xa2, 0xf4, 0x70, 0xbf, 0x3c, 0xae, 0xfe, 0xf1, 0x08, 0x73, 0x49, 0x15, 0xfb, 0x06, - 0x4c, 0xa6, 0x06, 0x0c, 0xbd, 0x04, 0x83, 0xad, 0x2d, 0x27, 0x22, 0x29, 0x7b, 0xd1, 0xc1, 0x2a, - 0x2d, 0x3c, 0xdc, 0x2f, 0x4f, 0xa8, 0x0a, 0xac, 0x04, 0x73, 0x6c, 0xfb, 0x7f, 0x59, 0x30, 0xb0, - 0x16, 0xb8, 0x27, 0xb1, 0x98, 0x5e, 0x37, 0x16, 0xd3, 0xf9, 0xbc, 0xf8, 0x9c, 0xb9, 0xeb, 0x68, - 0x39, 0xb5, 0x8e, 0x2e, 0xe6, 0x52, 0xe8, 0xbe, 0x84, 0x76, 0x60, 0x94, 0x45, 0xfd, 0x14, 0xf6, - 0xab, 0x2f, 0x18, 0x32, 0x40, 0x39, 0x25, 0x03, 0x4c, 0x6a, 0xa8, 0x9a, 0x24, 0xf0, 0x34, 0x0c, - 0x0b, 0x1b, 0xca, 0xb4, 0xd5, 0xbf, 0xc0, 0xc5, 0x12, 0x6e, 0xff, 0x68, 0x11, 0x8c, 0x28, 0xa3, - 0xe8, 0x57, 0x2c, 0x98, 0x0b, 0xb9, 0x1b, 0xa5, 0x5b, 0x69, 0x87, 0x9e, 0xdf, 0xa8, 0xd5, 0xb7, - 0x88, 0xdb, 0x6e, 0x7a, 0x7e, 0x63, 0xa5, 0xe1, 0x07, 0xaa, 0x78, 0xe9, 0x01, 0xa9, 0xb7, 0xd9, - 0x43, 0x48, 0x8f, 0x90, 0xa6, 0xca, 0x46, 0xe9, 0xda, 0xc1, 0x7e, 0x79, 0x0e, 0x1f, 0x89, 0x36, - 0x3e, 0x62, 0x5f, 0xd0, 0xd7, 0x2d, 0xb8, 0xca, 0x83, 0x6f, 0xf6, 0xdf, 0xff, 0x2e, 0x12, 0x53, - 0x55, 0x92, 0x4a, 0x88, 0xac, 0x93, 0x70, 0x67, 0xe1, 0x65, 0x31, 0xa0, 0x57, 0xab, 0x47, 0x6b, - 0x0b, 0x1f, 0xb5, 0x73, 0xf6, 0xbf, 0x29, 0xc2, 0xb8, 0xf0, 0xe0, 0x17, 0xa1, 0x61, 0x5e, 0x32, - 0x96, 0xc4, 0x13, 0xa9, 0x25, 0x31, 0x6d, 0x20, 0x1f, 0x4f, 0x54, 0x98, 0x08, 0xa6, 0x9b, 0x4e, - 0x14, 0xdf, 0x20, 0x4e, 0x18, 0x6f, 0x10, 0x87, 0xdb, 0xee, 0x14, 0x8f, 0x6c, 0x67, 0xa4, 0x54, - 0x34, 0xb7, 0xd2, 0xc4, 0x70, 0x27, 0x7d, 0xb4, 0x0b, 0x88, 0x19, 0x20, 0x85, 0x8e, 0x1f, 0xf1, - 0x6f, 0xf1, 0xc4, 0x9b, 0xc1, 0xd1, 0x5a, 0x9d, 0x15, 0xad, 0xa2, 0x5b, 0x1d, 0xd4, 0x70, 0x46, - 0x0b, 0x9a, 0x61, 0xd9, 0x60, 0xbf, 0x86, 0x65, 0x43, 0x3d, 0x5c, 0x6b, 0x7c, 0x98, 0xea, 0x08, - 0xc2, 0xf0, 0x16, 0x94, 0x94, 0x01, 0xa0, 0x38, 0x74, 0xba, 0xc7, 0x32, 0x49, 0x53, 0xe0, 0x6a, - 0x94, 0xc4, 0xf8, 0x34, 0x21, 0x67, 0xff, 0xd3, 0x82, 0xd1, 0x20, 0x9f, 0xc4, 0x35, 0x18, 0x71, - 0xa2, 0xc8, 0x6b, 0xf8, 0xc4, 0x15, 0x3b, 0xf6, 0xe3, 0x79, 0x3b, 0xd6, 0x68, 0x86, 0x19, 0x61, - 0xce, 0x8b, 0x9a, 0x58, 0xd1, 0x40, 0x37, 0xb8, 0x85, 0xd4, 0xae, 0xe4, 0xf9, 0xfb, 0xa3, 0x06, - 0xd2, 0x86, 0x6a, 0x97, 0x60, 0x51, 0x1f, 0x7d, 0x81, 0x9b, 0xb0, 0xdd, 0xf4, 0x83, 0xfb, 0xfe, - 0xf5, 0x20, 0x90, 0x6e, 0x77, 0xfd, 0x11, 0x9c, 0x96, 0x86, 0x6b, 0xaa, 0x3a, 0x36, 0xa9, 0xf5, - 0x17, 0xa8, 0xe8, 0x3b, 0xe1, 0x14, 0x25, 0x6d, 0x3a, 0xcf, 0x44, 0x88, 0xc0, 0xa4, 0x08, 0x0f, - 0x21, 0xcb, 0xc4, 0xd8, 0x65, 0xb2, 0xf3, 0x66, 0xed, 0x44, 0xe9, 0x77, 0xd3, 0x24, 0x81, 0xd3, - 0x34, 0xed, 0x9f, 0xb0, 0x80, 0x99, 0xfd, 0x9f, 0x00, 0xcb, 0xf0, 0x59, 0x93, 0x65, 0x98, 0xc9, - 0x1b, 0xe4, 0x1c, 0x6e, 0xe1, 0x45, 0xbe, 0xb2, 0xaa, 0x61, 0xf0, 0x60, 0x4f, 0x98, 0x0f, 0xf4, - 0xe6, 0x64, 0xed, 0xff, 0x6b, 0xf1, 0x43, 0x4c, 0x79, 0xe2, 0xa3, 0xef, 0x82, 0x91, 0xba, 0xd3, - 0x72, 0xea, 0x3c, 0x24, 0x76, 0xae, 0x56, 0xc7, 0xa8, 0x34, 0xb7, 0x28, 0x6a, 0x70, 0x2d, 0x85, - 0x0c, 0x33, 0x32, 0x22, 0x8b, 0x7b, 0x6a, 0x26, 0x54, 0x93, 0xb3, 0xdb, 0x30, 0x6e, 0x10, 0x7b, - 0xa4, 0x22, 0xed, 0x77, 0xf1, 0x2b, 0x56, 0x85, 0xc5, 0xd9, 0x81, 0x69, 0x5f, 0xfb, 0x4f, 0x2f, - 0x14, 0x29, 0xa6, 0x7c, 0xbc, 0xd7, 0x25, 0xca, 0x6e, 0x1f, 0xcd, 0xad, 0x21, 0x45, 0x06, 0x77, - 0x52, 0xb6, 0x7f, 0xcc, 0x82, 0xc7, 0x74, 0x44, 0x2d, 0x48, 0x42, 0x2f, 0x3d, 0x71, 0x05, 0x46, - 0x82, 0x16, 0x09, 0x9d, 0x38, 0x08, 0xc5, 0xad, 0x71, 0x45, 0x0e, 0xfa, 0x6d, 0x51, 0x7e, 0x28, - 0x02, 0x4a, 0x4a, 0xea, 0xb2, 0x1c, 0xab, 0x9a, 0x54, 0x8e, 0x61, 0x83, 0x11, 0x89, 0x00, 0x16, - 0xec, 0x0c, 0x60, 0x4f, 0xa6, 0x11, 0x16, 0x10, 0xfb, 0x0f, 0x2c, 0xbe, 0xb0, 0xf4, 0xae, 0xa3, - 0xf7, 0x60, 0x6a, 0xc7, 0x89, 0xeb, 0x5b, 0x4b, 0x0f, 0x5a, 0x21, 0x57, 0x8f, 0xcb, 0x71, 0x7a, - 0xa6, 0xd7, 0x38, 0x69, 0x1f, 0x99, 0x58, 0xe5, 0xad, 0xa6, 0x88, 0xe1, 0x0e, 0xf2, 0x68, 0x03, - 0x46, 0x59, 0x19, 0x33, 0xff, 0x8e, 0xba, 0xb1, 0x06, 0x79, 0xad, 0xa9, 0x57, 0xe7, 0xd5, 0x84, - 0x0e, 0xd6, 0x89, 0xda, 0x5f, 0x2a, 0xf2, 0xdd, 0xce, 0xb8, 0xed, 0xa7, 0x61, 0xb8, 0x15, 0xb8, - 0x8b, 0x2b, 0x15, 0x2c, 0x66, 0x41, 0x5d, 0x23, 0x55, 0x5e, 0x8c, 0x25, 0x1c, 0xbd, 0x0a, 0x40, - 0x1e, 0xc4, 0x24, 0xf4, 0x9d, 0xa6, 0xb2, 0x92, 0x51, 0x76, 0xa1, 0x95, 0x60, 0x2d, 0x88, 0xef, - 0x44, 0xe4, 0x3b, 0x96, 0x14, 0x0a, 0xd6, 0xd0, 0xd1, 0x35, 0x80, 0x56, 0x18, 0xec, 0x7a, 0x2e, - 0xf3, 0x27, 0x2c, 0x9a, 0x36, 0x24, 0x55, 0x05, 0xc1, 0x1a, 0x16, 0x7a, 0x15, 0xc6, 0xdb, 0x7e, - 0xc4, 0x39, 0x14, 0x67, 0x43, 0x84, 0x63, 0x1c, 0x49, 0xac, 0x1b, 0xee, 0xe8, 0x40, 0x6c, 0xe2, - 0xa2, 0x79, 0x18, 0x8a, 0x1d, 0x66, 0x13, 0x31, 0x98, 0x6f, 0xcc, 0xb9, 0x4e, 0x31, 0xf4, 0x80, - 0xcc, 0xb4, 0x02, 0x16, 0x15, 0xd1, 0x5b, 0xd2, 0x39, 0x83, 0x9f, 0xf5, 0xc2, 0x8a, 0xba, 0xbf, - 0x7b, 0x41, 0x73, 0xcd, 0x10, 0xd6, 0xd9, 0x06, 0x2d, 0xfb, 0xeb, 0x25, 0x80, 0x84, 0x1d, 0x47, - 0xef, 0x77, 0x9c, 0x47, 0xcf, 0x76, 0x67, 0xe0, 0x8f, 0xef, 0x30, 0x42, 0xdf, 0x67, 0xc1, 0xa8, - 0xd3, 0x6c, 0x06, 0x75, 0x27, 0x66, 0xa3, 0x5c, 0xe8, 0x7e, 0x1e, 0x8a, 0xf6, 0xe7, 0x93, 0x1a, - 0xbc, 0x0b, 0x2f, 0xc8, 0x85, 0xa7, 0x41, 0x7a, 0xf6, 0x42, 0x6f, 0x18, 0x7d, 0x4a, 0x4a, 0x69, - 0x7c, 0x79, 0xcc, 0xa6, 0xa5, 0xb4, 0x12, 0x3b, 0xfa, 0x35, 0x01, 0x0d, 0xdd, 0x31, 0x22, 0xed, - 0x0d, 0xe4, 0x07, 0x9d, 0x30, 0xb8, 0xd2, 0x5e, 0x41, 0xf6, 0x50, 0x55, 0xf7, 0x26, 0x1b, 0xcc, - 0x8f, 0xcc, 0xa2, 0x89, 0x3f, 0x3d, 0x3c, 0xc9, 0xde, 0x85, 0x49, 0xd7, 0xbc, 0xdb, 0xc5, 0x6a, - 0x7a, 0x2a, 0x8f, 0x6e, 0x8a, 0x15, 0x48, 0x6e, 0xf3, 0x14, 0x00, 0xa7, 0x09, 0xa3, 0x2a, 0xf7, - 0xeb, 0x5b, 0xf1, 0x37, 0x03, 0x61, 0x8d, 0x6f, 0xe7, 0xce, 0xe5, 0x5e, 0x14, 0x93, 0x1d, 0x8a, - 0x99, 0x5c, 0xda, 0x6b, 0xa2, 0x2e, 0x56, 0x54, 0xd0, 0x1b, 0x30, 0xc4, 0x1c, 0x83, 0xa3, 0x99, - 0x91, 0x7c, 0x65, 0xa2, 0x19, 0xd3, 0x22, 0xd9, 0x54, 0xec, 0x6f, 0x84, 0x05, 0x05, 0x74, 0x43, - 0x06, 0xbe, 0x89, 0x56, 0xfc, 0x3b, 0x11, 0x61, 0x81, 0x6f, 0x4a, 0x0b, 0x1f, 0x4f, 0x62, 0xda, - 0xf0, 0xf2, 0xcc, 0xd4, 0x0b, 0x46, 0x4d, 0xca, 0x1c, 0x89, 0xff, 0x32, 0xa3, 0xc3, 0x0c, 0xe4, - 0x77, 0xcf, 0xcc, 0xfa, 0x90, 0x0c, 0xe7, 0x5d, 0x93, 0x04, 0x4e, 0xd3, 0xa4, 0x8c, 0x26, 0xdf, - 0xb9, 0xc2, 0x9e, 0xbf, 0xd7, 0xfe, 0xe7, 0xf2, 0x35, 0xbb, 0x64, 0x78, 0x09, 0x16, 0xf5, 0x4f, - 0xf4, 0xd6, 0x9f, 0xf5, 0x61, 0x2a, 0xbd, 0x45, 0x1f, 0x29, 0x97, 0xf1, 0x7b, 0x03, 0x30, 0x61, - 0x2e, 0x29, 0x74, 0x15, 0x4a, 0x82, 0x88, 0x8a, 0xc2, 0xaa, 0x76, 0xc9, 0xaa, 0x04, 0xe0, 0x04, - 0x87, 0x05, 0xdf, 0x65, 0xd5, 0x35, 0x3b, 0xcc, 0x24, 0xf8, 0xae, 0x82, 0x60, 0x0d, 0x8b, 0xca, - 0x4b, 0x1b, 0x41, 0x10, 0xab, 0x4b, 0x45, 0xad, 0xbb, 0x05, 0x56, 0x8a, 0x05, 0x94, 0x5e, 0x26, - 0xdb, 0x24, 0xf4, 0x49, 0xd3, 0x0c, 0xee, 0xa6, 0x2e, 0x93, 0x9b, 0x3a, 0x10, 0x9b, 0xb8, 0xf4, - 0x96, 0x0c, 0x22, 0xb6, 0x90, 0x85, 0x54, 0x96, 0xd8, 0xb5, 0xd6, 0xb8, 0x8b, 0xbd, 0x84, 0xa3, - 0xcf, 0xc3, 0x63, 0xca, 0x23, 0x1e, 0x73, 0x45, 0xb5, 0x6c, 0x71, 0xc8, 0x50, 0xa2, 0x3c, 0xb6, - 0x98, 0x8d, 0x86, 0xf3, 0xea, 0xa3, 0xd7, 0x61, 0x42, 0x70, 0xee, 0x92, 0xe2, 0xb0, 0x69, 0x3b, - 0x71, 0xd3, 0x80, 0xe2, 0x14, 0xb6, 0x0c, 0x4f, 0xc7, 0x98, 0x67, 0x49, 0x61, 0xa4, 0x33, 0x3c, - 0x9d, 0x0e, 0xc7, 0x1d, 0x35, 0xd0, 0x3c, 0x4c, 0x72, 0xd6, 0xca, 0xf3, 0x1b, 0x7c, 0x4e, 0x84, - 0xbb, 0x8d, 0xda, 0x52, 0xb7, 0x4d, 0x30, 0x4e, 0xe3, 0xa3, 0x57, 0x60, 0xcc, 0x09, 0xeb, 0x5b, - 0x5e, 0x4c, 0xea, 0x71, 0x3b, 0xe4, 0x7e, 0x38, 0x9a, 0xf1, 0xc9, 0xbc, 0x06, 0xc3, 0x06, 0xa6, - 0xfd, 0x3e, 0x9c, 0xca, 0xf0, 0xd4, 0xa3, 0x0b, 0xc7, 0x69, 0x79, 0xf2, 0x9b, 0x52, 0x16, 0xaa, - 0xf3, 0xd5, 0x15, 0xf9, 0x35, 0x1a, 0x16, 0x5d, 0x9d, 0xcc, 0xa3, 0x4f, 0x4b, 0xe0, 0xa2, 0x56, - 0xe7, 0xb2, 0x04, 0xe0, 0x04, 0xc7, 0xfe, 0xdf, 0x05, 0x98, 0xcc, 0x50, 0xbe, 0xb3, 0x24, 0x22, - 0x29, 0xd9, 0x23, 0xc9, 0x19, 0x62, 0x46, 0x3b, 0x2c, 0x1c, 0x21, 0xda, 0x61, 0xb1, 0x57, 0xb4, - 0xc3, 0x81, 0x0f, 0x12, 0xed, 0xd0, 0x1c, 0xb1, 0xc1, 0xbe, 0x46, 0x2c, 0x23, 0x42, 0xe2, 0xd0, - 0x11, 0x23, 0x24, 0x1a, 0x83, 0x3e, 0xdc, 0xc7, 0xa0, 0x7f, 0xb5, 0x00, 0x53, 0x69, 0x23, 0xb9, - 0x13, 0x50, 0xc7, 0xbe, 0x61, 0xa8, 0x63, 0xb3, 0x53, 0xf2, 0xa4, 0x4d, 0xf7, 0xf2, 0x54, 0xb3, - 0x38, 0xa5, 0x9a, 0xfd, 0x64, 0x5f, 0xd4, 0xba, 0xab, 0x69, 0xff, 0x41, 0x01, 0xce, 0xa4, 0xab, - 0x2c, 0x36, 0x1d, 0x6f, 0xe7, 0x04, 0xc6, 0xe6, 0xb6, 0x31, 0x36, 0xcf, 0xf5, 0xf3, 0x35, 0xac, - 0x6b, 0xb9, 0x03, 0x74, 0x2f, 0x35, 0x40, 0x57, 0xfb, 0x27, 0xd9, 0x7d, 0x94, 0xbe, 0x51, 0x84, - 0x8b, 0x99, 0xf5, 0x12, 0x6d, 0xe6, 0xb2, 0xa1, 0xcd, 0xbc, 0x96, 0xd2, 0x66, 0xda, 0xdd, 0x6b, - 0x1f, 0x8f, 0x7a, 0x53, 0xb8, 0x50, 0xb2, 0x88, 0x78, 0x0f, 0xa9, 0xda, 0x34, 0x5c, 0x28, 0x15, - 0x21, 0x6c, 0xd2, 0xfd, 0x8b, 0xa4, 0xd2, 0xfc, 0xf7, 0x16, 0x9c, 0xcb, 0x9c, 0x9b, 0x13, 0x50, - 0x61, 0xad, 0x99, 0x2a, 0xac, 0xa7, 0xfb, 0x5e, 0xad, 0x39, 0x3a, 0xad, 0x5f, 0x1f, 0xc8, 0xf9, - 0x16, 0x26, 0xa0, 0xdf, 0x86, 0x51, 0xa7, 0x5e, 0x27, 0x51, 0xb4, 0x1a, 0xb8, 0x2a, 0x42, 0xdc, - 0x73, 0x4c, 0xce, 0x4a, 0x8a, 0x0f, 0xf7, 0xcb, 0xb3, 0x69, 0x12, 0x09, 0x18, 0xeb, 0x14, 0xcc, - 0xa0, 0x96, 0x85, 0x63, 0x0d, 0x6a, 0x79, 0x0d, 0x60, 0x57, 0x71, 0xeb, 0x69, 0x21, 0x5f, 0xe3, - 0xe3, 0x35, 0x2c, 0xf4, 0x05, 0x18, 0x89, 0xc4, 0x35, 0x2e, 0x96, 0xe2, 0x0b, 0x7d, 0xce, 0x95, - 0xb3, 0x41, 0x9a, 0xa6, 0xaf, 0xbe, 0xd2, 0x87, 0x28, 0x92, 0xe8, 0xdb, 0x60, 0x2a, 0xe2, 0xa1, - 0x60, 0x16, 0x9b, 0x4e, 0xc4, 0xfc, 0x20, 0xc4, 0x2a, 0x64, 0x0e, 0xf8, 0xb5, 0x14, 0x0c, 0x77, - 0x60, 0xa3, 0x65, 0xf9, 0x51, 0x2c, 0x6e, 0x0d, 0x5f, 0x98, 0x97, 0x93, 0x0f, 0x12, 0x29, 0xcc, - 0x4e, 0xa7, 0x87, 0x9f, 0x0d, 0xbc, 0x56, 0x13, 0x7d, 0x01, 0x80, 0x2e, 0x1f, 0xa1, 0x4b, 0x18, - 0xce, 0x3f, 0x3c, 0xe9, 0xa9, 0xe2, 0x66, 0x5a, 0x7e, 0x32, 0xe7, 0xc5, 0x8a, 0x22, 0x82, 0x35, - 0x82, 0xf6, 0x57, 0x07, 0xe0, 0xf1, 0x2e, 0x67, 0x24, 0x9a, 0x37, 0x9f, 0x40, 0x9f, 0x49, 0x0b, - 0xd7, 0xb3, 0x99, 0x95, 0x0d, 0x69, 0x3b, 0xb5, 0x14, 0x0b, 0x1f, 0x78, 0x29, 0xfe, 0x80, 0xa5, - 0xa9, 0x3d, 0xb8, 0x31, 0xdf, 0x67, 0x8f, 0x78, 0xf6, 0x1f, 0xa3, 0x1e, 0x64, 0x33, 0x43, 0x99, - 0x70, 0xad, 0xef, 0xee, 0xf4, 0xad, 0x5d, 0x38, 0x59, 0xe5, 0xef, 0x97, 0x2c, 0x78, 0x22, 0xb3, - 0xbf, 0x86, 0xc9, 0xc6, 0x55, 0x28, 0xd5, 0x69, 0xa1, 0xe6, 0xab, 0x96, 0x38, 0xf1, 0x4a, 0x00, - 0x4e, 0x70, 0x0c, 0xcb, 0x8c, 0x42, 0x4f, 0xcb, 0x8c, 0x7f, 0x6d, 0x41, 0xc7, 0xfe, 0x38, 0x81, - 0x83, 0x7a, 0xc5, 0x3c, 0xa8, 0x3f, 0xde, 0xcf, 0x5c, 0xe6, 0x9c, 0xd1, 0x7f, 0x34, 0x09, 0x67, - 0x73, 0x7c, 0x35, 0x76, 0x61, 0xba, 0x51, 0x27, 0xa6, 0x17, 0xa0, 0xf8, 0x98, 0x4c, 0x87, 0xc9, - 0xae, 0x2e, 0x83, 0x2c, 0x1f, 0xd1, 0x74, 0x07, 0x0a, 0xee, 0x6c, 0x02, 0x7d, 0xc9, 0x82, 0xd3, - 0xce, 0xfd, 0xa8, 0x23, 0x81, 0xa9, 0x58, 0x33, 0x2f, 0x66, 0x2a, 0x41, 0x7a, 0x24, 0x3c, 0xe5, - 0x09, 0x9a, 0xb2, 0xb0, 0x70, 0x66, 0x5b, 0x08, 0x8b, 0x98, 0xa1, 0x94, 0x9d, 0xef, 0xe2, 0xa7, - 0x9a, 0xe5, 0x54, 0xc3, 0x8f, 0x6c, 0x09, 0xc1, 0x8a, 0x0e, 0x7a, 0x07, 0x4a, 0x0d, 0xe9, 0xe9, - 0x96, 0x71, 0x25, 0x24, 0x03, 0xd9, 0xdd, 0xff, 0x8f, 0x3f, 0x50, 0x2a, 0x24, 0x9c, 0x10, 0x45, - 0xaf, 0x43, 0xd1, 0xdf, 0x8c, 0xba, 0xe5, 0x38, 0x4a, 0xd9, 0x34, 0x71, 0x6f, 0xf0, 0xb5, 0xe5, - 0x1a, 0xa6, 0x15, 0xd1, 0x0d, 0x28, 0x86, 0x1b, 0xae, 0xd0, 0xe0, 0x65, 0x9e, 0xe1, 0x78, 0xa1, - 0x92, 0xd3, 0x2b, 0x46, 0x09, 0x2f, 0x54, 0x30, 0x25, 0x81, 0xaa, 0x30, 0xc8, 0x1c, 0x1c, 0xc4, - 0x7d, 0x90, 0xc9, 0xf9, 0x76, 0x71, 0x14, 0xe2, 0x2e, 0xe3, 0x0c, 0x01, 0x73, 0x42, 0x68, 0x1d, - 0x86, 0xea, 0x2c, 0x1f, 0x8e, 0x08, 0x58, 0xfd, 0xa9, 0x4c, 0x5d, 0x5d, 0x97, 0x44, 0x41, 0x42, - 0x75, 0xc5, 0x30, 0xb0, 0xa0, 0xc5, 0xa8, 0x92, 0xd6, 0xd6, 0x66, 0x24, 0xf2, 0xb7, 0x65, 0x53, - 0xed, 0x92, 0xff, 0x4a, 0x50, 0x65, 0x18, 0x58, 0xd0, 0x42, 0x9f, 0x81, 0xc2, 0x66, 0x5d, 0xf8, - 0x3f, 0x64, 0x2a, 0xed, 0x4c, 0x87, 0xfe, 0x85, 0xa1, 0x83, 0xfd, 0x72, 0x61, 0x79, 0x11, 0x17, - 0x36, 0xeb, 0x68, 0x0d, 0x86, 0x37, 0xb9, 0x0b, 0xb0, 0xd0, 0xcb, 0x3d, 0x95, 0xed, 0x9d, 0xdc, - 0xe1, 0x25, 0xcc, 0xed, 0xf6, 0x05, 0x00, 0x4b, 0x22, 0x2c, 0x04, 0xa7, 0x72, 0x65, 0x16, 0xb1, - 0xa8, 0xe7, 0x8e, 0xe6, 0x7e, 0xce, 0xef, 0xe7, 0xc4, 0x21, 0x1a, 0x6b, 0x14, 0xe9, 0xaa, 0x76, - 0x64, 0x12, 0x4d, 0x11, 0xab, 0x23, 0x73, 0x55, 0xf7, 0xc8, 0x2f, 0xca, 0x57, 0xb5, 0x42, 0xc2, - 0x09, 0x51, 0xb4, 0x0d, 0xe3, 0xbb, 0x51, 0x6b, 0x8b, 0xc8, 0x2d, 0xcd, 0x42, 0x77, 0xe4, 0x5c, - 0x61, 0x77, 0x05, 0xa2, 0x17, 0xc6, 0x6d, 0xa7, 0xd9, 0x71, 0x0a, 0xb1, 0x57, 0xed, 0xbb, 0x3a, - 0x31, 0x6c, 0xd2, 0xa6, 0xc3, 0xff, 0x5e, 0x3b, 0xd8, 0xd8, 0x8b, 0x89, 0x08, 0x5e, 0x9d, 0x39, - 0xfc, 0x6f, 0x72, 0x94, 0xce, 0xe1, 0x17, 0x00, 0x2c, 0x89, 0xa0, 0xbb, 0x62, 0x78, 0xd8, 0xe9, - 0x39, 0x95, 0x1f, 0x4c, 0x29, 0x33, 0x8b, 0xad, 0x36, 0x28, 0xec, 0xb4, 0x4c, 0x48, 0xb1, 0x53, - 0xb2, 0xb5, 0x15, 0xc4, 0x81, 0x9f, 0x3a, 0xa1, 0xa7, 0xf3, 0x4f, 0xc9, 0x6a, 0x06, 0x7e, 0xe7, - 0x29, 0x99, 0x85, 0x85, 0x33, 0xdb, 0x42, 0x2e, 0x4c, 0xb4, 0x82, 0x30, 0xbe, 0x1f, 0x84, 0x72, - 0x7d, 0xa1, 0x2e, 0x7a, 0x05, 0x03, 0x53, 0xb4, 0xc8, 0x82, 0xa9, 0x9b, 0x10, 0x9c, 0xa2, 0x89, - 0x3e, 0x07, 0xc3, 0x51, 0xdd, 0x69, 0x92, 0x95, 0xdb, 0x33, 0xa7, 0xf2, 0xaf, 0x9f, 0x1a, 0x47, - 0xc9, 0x59, 0x5d, 0x6c, 0x72, 0x04, 0x0a, 0x96, 0xe4, 0xd0, 0x32, 0x0c, 0xb2, 0x8c, 0x08, 0x2c, - 0xee, 0x76, 0x4e, 0x4c, 0xa8, 0x0e, 0x0b, 0x53, 0x7e, 0x36, 0xb1, 0x62, 0xcc, 0xab, 0xd3, 0x3d, - 0x20, 0xd8, 0xeb, 0x20, 0x9a, 0x39, 0x93, 0xbf, 0x07, 0x04, 0x57, 0x7e, 0xbb, 0xd6, 0x6d, 0x0f, - 0x28, 0x24, 0x9c, 0x10, 0xa5, 0x27, 0x33, 0x3d, 0x4d, 0xcf, 0x76, 0x31, 0x68, 0xc9, 0x3d, 0x4b, - 0xd9, 0xc9, 0x4c, 0x4f, 0x52, 0x4a, 0xc2, 0xfe, 0x9d, 0xe1, 0x4e, 0x9e, 0x85, 0x09, 0x64, 0x7f, - 0xd5, 0xea, 0x78, 0xab, 0xfb, 0x74, 0xbf, 0xfa, 0xa1, 0x63, 0xe4, 0x56, 0xbf, 0x64, 0xc1, 0xd9, - 0x56, 0xe6, 0x87, 0x08, 0x06, 0xa0, 0x3f, 0x35, 0x13, 0xff, 0x74, 0x15, 0x1b, 0x3f, 0x1b, 0x8e, - 0x73, 0x5a, 0x4a, 0x4b, 0x04, 0xc5, 0x0f, 0x2c, 0x11, 0xac, 0xc2, 0x08, 0x63, 0x32, 0x7b, 0xe4, - 0x87, 0x4b, 0x0b, 0x46, 0x8c, 0x95, 0x58, 0x14, 0x15, 0xb1, 0x22, 0x81, 0x7e, 0xd0, 0x82, 0x0b, - 0xe9, 0xae, 0x63, 0xc2, 0xc0, 0x22, 0x92, 0x3c, 0x97, 0x05, 0x97, 0xc5, 0xf7, 0x5f, 0xa8, 0x76, - 0x43, 0x3e, 0xec, 0x85, 0x80, 0xbb, 0x37, 0x86, 0x2a, 0x19, 0xc2, 0xe8, 0x90, 0xa9, 0x80, 0xef, - 0x43, 0x20, 0x7d, 0x11, 0xc6, 0x76, 0x82, 0xb6, 0x1f, 0x0b, 0xfb, 0x17, 0xe1, 0xb1, 0xc8, 0x1e, - 0x9c, 0x57, 0xb5, 0x72, 0x6c, 0x60, 0xa5, 0xc4, 0xd8, 0x91, 0x87, 0x16, 0x63, 0xdf, 0x4e, 0x25, - 0x94, 0x2f, 0xe5, 0x47, 0x2c, 0x14, 0x12, 0xff, 0x11, 0xd2, 0xca, 0x9f, 0xac, 0x6c, 0xf4, 0x53, - 0x56, 0x06, 0x53, 0xcf, 0xa5, 0xe5, 0xd7, 0x4c, 0x69, 0xf9, 0x72, 0x5a, 0x5a, 0xee, 0x50, 0xbe, - 0x1a, 0x82, 0x72, 0xff, 0x61, 0xaf, 0xfb, 0x8d, 0x23, 0x67, 0x37, 0xe1, 0x52, 0xaf, 0x6b, 0x89, - 0x19, 0x42, 0xb9, 0xea, 0xa9, 0x2d, 0x31, 0x84, 0x72, 0x57, 0x2a, 0x98, 0x41, 0xfa, 0x0d, 0x34, - 0x62, 0xff, 0x4f, 0x0b, 0x8a, 0xd5, 0xc0, 0x3d, 0x01, 0x65, 0xf2, 0x67, 0x0d, 0x65, 0xf2, 0xe3, - 0x39, 0x89, 0xfe, 0x73, 0x55, 0xc7, 0x4b, 0x29, 0xd5, 0xf1, 0x85, 0x3c, 0x02, 0xdd, 0x15, 0xc5, - 0x3f, 0x5e, 0x84, 0xd1, 0x6a, 0xe0, 0x2a, 0x2b, 0xe4, 0x5f, 0x7f, 0x18, 0x2b, 0xe4, 0xdc, 0xb0, - 0xb0, 0x1a, 0x65, 0x66, 0x3f, 0x25, 0x9d, 0xf0, 0xfe, 0x9c, 0x19, 0x23, 0xdf, 0x23, 0x5e, 0x63, - 0x2b, 0x26, 0x6e, 0xfa, 0x73, 0x4e, 0xce, 0x18, 0xf9, 0x7f, 0x58, 0x30, 0x99, 0x6a, 0x1d, 0x35, - 0x61, 0xbc, 0xa9, 0x6b, 0x02, 0xc5, 0x3a, 0x7d, 0x28, 0x25, 0xa2, 0x30, 0xe6, 0xd4, 0x8a, 0xb0, - 0x49, 0x1c, 0xcd, 0x01, 0xa8, 0x97, 0x3a, 0xa9, 0x01, 0x63, 0x5c, 0xbf, 0x7a, 0xca, 0x8b, 0xb0, - 0x86, 0x81, 0x5e, 0x82, 0xd1, 0x38, 0x68, 0x05, 0xcd, 0xa0, 0xb1, 0x77, 0x93, 0xc8, 0xd0, 0x36, - 0xca, 0x44, 0x6b, 0x3d, 0x01, 0x61, 0x1d, 0xcf, 0xfe, 0xc9, 0x22, 0xff, 0x50, 0x3f, 0xf6, 0xbe, - 0xb9, 0x26, 0x3f, 0xda, 0x6b, 0xf2, 0x1b, 0x16, 0x4c, 0xd1, 0xd6, 0x99, 0xb9, 0x88, 0xbc, 0x6c, - 0x55, 0xfa, 0x1d, 0xab, 0x4b, 0xfa, 0x9d, 0xcb, 0xf4, 0xec, 0x72, 0x83, 0x76, 0x2c, 0x34, 0x68, - 0xda, 0xe1, 0x44, 0x4b, 0xb1, 0x80, 0x0a, 0x3c, 0x12, 0x86, 0xc2, 0x07, 0x4a, 0xc7, 0x23, 0x61, - 0x88, 0x05, 0x54, 0x66, 0xe7, 0x19, 0xc8, 0xc9, 0xce, 0xc3, 0x02, 0xf5, 0x09, 0xc3, 0x02, 0xc1, - 0xf6, 0x68, 0x81, 0xfa, 0xa4, 0xc5, 0x41, 0x82, 0x63, 0xff, 0x5c, 0x11, 0xc6, 0xaa, 0x81, 0x9b, - 0xbc, 0x95, 0xbd, 0x68, 0xbc, 0x95, 0x5d, 0x4a, 0xbd, 0x95, 0x4d, 0xe9, 0xb8, 0xdf, 0x7c, 0x19, - 0xfb, 0xb0, 0x5e, 0xc6, 0xfe, 0x95, 0xc5, 0x66, 0xad, 0xb2, 0x56, 0x13, 0xd9, 0x81, 0x9f, 0x87, - 0x51, 0x76, 0x20, 0x31, 0xa7, 0x3b, 0xf9, 0x80, 0xc4, 0x02, 0xef, 0xaf, 0x25, 0xc5, 0x58, 0xc7, - 0x41, 0x57, 0x60, 0x24, 0x22, 0x4e, 0x58, 0xdf, 0x52, 0x67, 0x9c, 0x78, 0x5e, 0xe1, 0x65, 0x58, - 0x41, 0xd1, 0x9b, 0x49, 0x8c, 0xb8, 0x62, 0x7e, 0x9e, 0x5b, 0xbd, 0x3f, 0x7c, 0x8b, 0xe4, 0x07, - 0x86, 0xb3, 0xef, 0x01, 0xea, 0xc4, 0xef, 0x23, 0x38, 0x52, 0xd9, 0x0c, 0x8e, 0x54, 0xea, 0x08, - 0x8c, 0xf4, 0xa7, 0x16, 0x4c, 0x54, 0x03, 0x97, 0x6e, 0xdd, 0xbf, 0x48, 0xfb, 0x54, 0x0f, 0x90, - 0x39, 0xd4, 0x25, 0x40, 0xe6, 0x3f, 0xb4, 0x60, 0xb8, 0x1a, 0xb8, 0x27, 0xa0, 0x77, 0x7f, 0xcd, - 0xd4, 0xbb, 0x3f, 0x96, 0xb3, 0x24, 0x72, 0x54, 0xed, 0xbf, 0x50, 0x84, 0x71, 0xda, 0xcf, 0xa0, - 0x21, 0x67, 0xc9, 0x18, 0x11, 0xab, 0x8f, 0x11, 0xa1, 0x6c, 0x6e, 0xd0, 0x6c, 0x06, 0xf7, 0xd3, - 0x33, 0xb6, 0xcc, 0x4a, 0xb1, 0x80, 0xa2, 0x67, 0x61, 0xa4, 0x15, 0x92, 0x5d, 0x2f, 0x10, 0xfc, - 0xa3, 0xf6, 0x8a, 0x51, 0x15, 0xe5, 0x58, 0x61, 0x50, 0xb9, 0x2b, 0xf2, 0xfc, 0x3a, 0x91, 0x49, - 0xb6, 0x07, 0x58, 0x1e, 0x2e, 0x1e, 0xf9, 0x5a, 0x2b, 0xc7, 0x06, 0x16, 0xba, 0x07, 0x25, 0xf6, - 0x9f, 0x9d, 0x28, 0x47, 0xcf, 0x1b, 0x24, 0xd2, 0x4d, 0x08, 0x02, 0x38, 0xa1, 0x85, 0xae, 0x01, - 0xc4, 0x32, 0x3a, 0x72, 0x24, 0x62, 0xdc, 0x28, 0x5e, 0x5b, 0xc5, 0x4d, 0x8e, 0xb0, 0x86, 0x85, - 0x9e, 0x81, 0x52, 0xec, 0x78, 0xcd, 0x5b, 0x9e, 0x4f, 0x22, 0xa6, 0x72, 0x2e, 0xca, 0x6c, 0x12, - 0xa2, 0x10, 0x27, 0x70, 0xca, 0xeb, 0x30, 0x07, 0x70, 0x9e, 0x75, 0x6c, 0x84, 0x61, 0x33, 0x5e, - 0xe7, 0x96, 0x2a, 0xc5, 0x1a, 0x86, 0xfd, 0x0a, 0x9c, 0xa9, 0x06, 0x6e, 0x35, 0x08, 0xe3, 0xe5, - 0x20, 0xbc, 0xef, 0x84, 0xae, 0x9c, 0xbf, 0xb2, 0x4c, 0x6c, 0x40, 0xcf, 0x9e, 0x41, 0xbe, 0x33, - 0x8d, 0x94, 0x05, 0x2f, 0x30, 0x6e, 0xe7, 0x88, 0x4e, 0x1d, 0x75, 0x76, 0xef, 0xaa, 0x04, 0x83, - 0xd7, 0x9d, 0x98, 0xa0, 0xdb, 0x2c, 0x29, 0x59, 0x72, 0x05, 0x89, 0xea, 0x4f, 0x6b, 0x49, 0xc9, - 0x12, 0x60, 0xe6, 0x9d, 0x65, 0xd6, 0xb7, 0x7f, 0x66, 0x80, 0x9d, 0x46, 0xa9, 0x7c, 0x7b, 0xe8, - 0x8b, 0x30, 0x11, 0x91, 0x5b, 0x9e, 0xdf, 0x7e, 0x20, 0x85, 0xf0, 0x2e, 0x6e, 0x39, 0xb5, 0x25, - 0x1d, 0x93, 0xab, 0xf2, 0xcc, 0x32, 0x9c, 0xa2, 0x46, 0xe7, 0x29, 0x6c, 0xfb, 0xf3, 0xd1, 0x9d, - 0x88, 0x84, 0x22, 0xdf, 0x1b, 0x9b, 0x27, 0x2c, 0x0b, 0x71, 0x02, 0xa7, 0xeb, 0x92, 0xfd, 0x59, - 0x0b, 0x7c, 0x1c, 0x04, 0xb1, 0x5c, 0xc9, 0x2c, 0x63, 0x90, 0x56, 0x8e, 0x0d, 0x2c, 0xb4, 0x0c, - 0x28, 0x6a, 0xb7, 0x5a, 0x4d, 0xf6, 0xb0, 0xef, 0x34, 0xaf, 0x87, 0x41, 0xbb, 0xc5, 0x5f, 0x3d, - 0x8b, 0x3c, 0x30, 0x61, 0xad, 0x03, 0x8a, 0x33, 0x6a, 0xd0, 0xd3, 0x67, 0x33, 0x62, 0xbf, 0xd9, - 0xea, 0x2e, 0x0a, 0xf5, 0x7a, 0x8d, 0x15, 0x61, 0x09, 0xa3, 0x8b, 0x89, 0x35, 0xcf, 0x31, 0x87, - 0x92, 0xc5, 0x84, 0x55, 0x29, 0xd6, 0x30, 0xd0, 0x12, 0x0c, 0x47, 0x7b, 0x51, 0x3d, 0x16, 0x11, - 0x99, 0x72, 0x32, 0x77, 0xd6, 0x18, 0x8a, 0x96, 0x4d, 0x82, 0x57, 0xc1, 0xb2, 0x2e, 0xda, 0x81, - 0x89, 0xfb, 0x9e, 0xef, 0x06, 0xf7, 0x23, 0x39, 0x51, 0x23, 0xf9, 0xaa, 0xd1, 0x7b, 0x1c, 0x33, - 0x35, 0xd9, 0xc6, 0xbc, 0xdd, 0x33, 0x88, 0xe1, 0x14, 0x71, 0xfb, 0xbb, 0xd8, 0xdd, 0xcb, 0x92, - 0x91, 0xc5, 0xed, 0x90, 0xa0, 0x1d, 0x18, 0x6f, 0xb1, 0x15, 0x26, 0x42, 0x65, 0x8b, 0x65, 0xf2, - 0x62, 0x9f, 0x42, 0xf4, 0x7d, 0x7a, 0xae, 0x29, 0x25, 0x17, 0x93, 0x4e, 0xaa, 0x3a, 0x39, 0x6c, - 0x52, 0xb7, 0xbf, 0x8a, 0xd8, 0x11, 0x5f, 0xe3, 0x92, 0xf1, 0xb0, 0xb0, 0x64, 0x16, 0x62, 0xc0, - 0x6c, 0xbe, 0x8a, 0x26, 0x19, 0x40, 0x61, 0x0d, 0x8d, 0x65, 0x5d, 0xf4, 0x26, 0x7b, 0x14, 0xe7, - 0xe7, 0x6a, 0xaf, 0x9c, 0xd0, 0x1c, 0xcb, 0x78, 0xff, 0x16, 0x15, 0xb1, 0x46, 0x04, 0xdd, 0x82, - 0x71, 0x91, 0xbb, 0x4a, 0xe8, 0xe0, 0x8a, 0x86, 0x8e, 0x65, 0x1c, 0xeb, 0xc0, 0xc3, 0x74, 0x01, - 0x36, 0x2b, 0xa3, 0x06, 0x5c, 0xd0, 0x12, 0x39, 0x5e, 0x0f, 0x1d, 0xf6, 0x50, 0xea, 0xb1, 0x3d, - 0xab, 0x1d, 0xd3, 0x4f, 0x1c, 0xec, 0x97, 0x2f, 0xac, 0x77, 0x43, 0xc4, 0xdd, 0xe9, 0xa0, 0xdb, - 0x70, 0x86, 0x3b, 0x0c, 0x56, 0x88, 0xe3, 0x36, 0x3d, 0x5f, 0xdd, 0x03, 0x7c, 0xd9, 0x9f, 0x3b, - 0xd8, 0x2f, 0x9f, 0x99, 0xcf, 0x42, 0xc0, 0xd9, 0xf5, 0xd0, 0x6b, 0x50, 0x72, 0xfd, 0x48, 0x8c, - 0xc1, 0x90, 0x91, 0xa3, 0xb4, 0x54, 0x59, 0xab, 0xa9, 0xef, 0x4f, 0xfe, 0xe0, 0xa4, 0x02, 0x6a, - 0x70, 0x3d, 0x9c, 0x12, 0x7b, 0x87, 0xf3, 0xf3, 0xd1, 0x8b, 0x25, 0x61, 0xb8, 0x0c, 0x71, 0x05, - 0xb4, 0x32, 0xb9, 0x35, 0xbc, 0x89, 0x0c, 0xc2, 0xe8, 0x0d, 0x40, 0x94, 0x2f, 0xf4, 0xea, 0x64, - 0xbe, 0xce, 0x22, 0x96, 0x33, 0xb5, 0xe5, 0x88, 0xe1, 0xa2, 0x81, 0x6a, 0x1d, 0x18, 0x38, 0xa3, - 0x16, 0xba, 0x41, 0xcf, 0x4d, 0xbd, 0x54, 0x98, 0x0e, 0x4b, 0x59, 0x62, 0xa6, 0x42, 0x5a, 0x21, - 0xa9, 0x3b, 0x31, 0x71, 0x4d, 0x8a, 0x38, 0x55, 0x8f, 0x5e, 0xdd, 0x2a, 0x79, 0x11, 0x98, 0x51, - 0x3a, 0x3a, 0x13, 0x18, 0x51, 0x31, 0x7c, 0x2b, 0x88, 0xe2, 0x35, 0x12, 0xdf, 0x0f, 0xc2, 0x6d, - 0x11, 0x14, 0x2d, 0x89, 0xcf, 0x99, 0x80, 0xb0, 0x8e, 0x47, 0xd9, 0x6e, 0xf6, 0x2a, 0xbd, 0x52, - 0x61, 0x0f, 0x82, 0x23, 0xc9, 0x3e, 0xb9, 0xc1, 0x8b, 0xb1, 0x84, 0x4b, 0xd4, 0x95, 0xea, 0x22, - 0x7b, 0xdc, 0x4b, 0xa1, 0xae, 0x54, 0x17, 0xb1, 0x84, 0x23, 0xd2, 0x99, 0xff, 0x75, 0x22, 0x5f, - 0x89, 0xda, 0x79, 0xfb, 0xf4, 0x99, 0x02, 0xd6, 0x87, 0x29, 0x95, 0x79, 0x96, 0x47, 0x8b, 0x8b, - 0x66, 0x26, 0xd9, 0x22, 0xe9, 0x3f, 0xd4, 0x9c, 0x52, 0x4b, 0xaf, 0xa4, 0x28, 0xe1, 0x0e, 0xda, - 0x46, 0xdc, 0x94, 0xa9, 0x9e, 0xc9, 0xa7, 0xae, 0x42, 0x29, 0x6a, 0x6f, 0xb8, 0xc1, 0x8e, 0xe3, - 0xf9, 0xec, 0x2d, 0x4e, 0xe3, 0xe9, 0x6a, 0x12, 0x80, 0x13, 0x1c, 0xb4, 0x0c, 0x23, 0x8e, 0xd4, - 0x39, 0xa3, 0xfc, 0x20, 0x09, 0x4a, 0xd3, 0xcc, 0xfd, 0x86, 0xa5, 0x96, 0x59, 0xd5, 0x45, 0xaf, - 0xc2, 0xb8, 0x70, 0x13, 0xe3, 0xa1, 0x23, 0xd8, 0x5b, 0x99, 0xe6, 0x07, 0x50, 0xd3, 0x81, 0xd8, - 0xc4, 0x45, 0x5f, 0x80, 0x09, 0x4a, 0x25, 0x39, 0xd8, 0x66, 0x4e, 0xf7, 0x73, 0x22, 0x6a, 0x49, - 0x45, 0xf4, 0xca, 0x38, 0x45, 0x0c, 0xb9, 0x70, 0xde, 0x69, 0xc7, 0x01, 0xd3, 0xdb, 0x9b, 0xeb, - 0x7f, 0x3d, 0xd8, 0x26, 0x3e, 0x7b, 0x32, 0x1b, 0x59, 0xb8, 0x74, 0xb0, 0x5f, 0x3e, 0x3f, 0xdf, - 0x05, 0x0f, 0x77, 0xa5, 0x82, 0xee, 0xc0, 0x68, 0x1c, 0x34, 0x99, 0x45, 0x3e, 0xbd, 0x10, 0xcf, - 0xe6, 0xc7, 0x1d, 0x5a, 0x57, 0x68, 0xba, 0xce, 0x4a, 0x55, 0xc5, 0x3a, 0x1d, 0xb4, 0xce, 0xf7, - 0x18, 0x8b, 0xc8, 0x4a, 0xa2, 0x99, 0xc7, 0xf2, 0x07, 0x46, 0x05, 0x6e, 0x35, 0xb7, 0xa0, 0xa8, - 0x89, 0x75, 0x32, 0xe8, 0x3a, 0x4c, 0xb7, 0x42, 0x2f, 0x60, 0x0b, 0x5b, 0xbd, 0x99, 0xcc, 0x98, - 0x79, 0x24, 0xaa, 0x69, 0x04, 0xdc, 0x59, 0x87, 0xca, 0xb4, 0xb2, 0x70, 0xe6, 0x1c, 0x4f, 0x4a, - 0xc6, 0xf9, 0x7c, 0x5e, 0x86, 0x15, 0x14, 0xad, 0xb2, 0x73, 0x99, 0x4b, 0x9f, 0x33, 0xb3, 0xf9, - 0xc1, 0x25, 0x74, 0x29, 0x95, 0xb3, 0x67, 0xea, 0x2f, 0x4e, 0x28, 0xd0, 0x7b, 0x23, 0xda, 0x72, - 0x42, 0x52, 0x0d, 0x83, 0x3a, 0x89, 0xb4, 0x20, 0xd0, 0x8f, 0xf3, 0xc0, 0x91, 0xf4, 0xde, 0xa8, - 0x65, 0x21, 0xe0, 0xec, 0x7a, 0xc8, 0xd5, 0x72, 0x71, 0x53, 0xae, 0x37, 0x9a, 0x39, 0xdf, 0xc5, - 0xbe, 0x29, 0xc5, 0x22, 0x27, 0x6b, 0xd1, 0x28, 0x8e, 0x70, 0x8a, 0x26, 0xfa, 0x36, 0x98, 0x12, - 0x71, 0x96, 0x92, 0x71, 0xbf, 0x90, 0x18, 0x4e, 0xe2, 0x14, 0x0c, 0x77, 0x60, 0xf3, 0xd0, 0xd7, - 0xce, 0x46, 0x93, 0x88, 0x45, 0x78, 0xcb, 0xf3, 0xb7, 0xa3, 0x99, 0x8b, 0xec, 0xab, 0x45, 0xe8, - 0xeb, 0x34, 0x14, 0x67, 0xd4, 0x98, 0xfd, 0x56, 0x98, 0xee, 0xb8, 0xb9, 0x8e, 0x14, 0x2e, 0xfe, - 0x4f, 0x06, 0xa1, 0xa4, 0xde, 0x00, 0xd0, 0x55, 0xf3, 0x69, 0xe7, 0x5c, 0xfa, 0x69, 0x67, 0x84, - 0x8a, 0x22, 0xfa, 0x6b, 0xce, 0xba, 0x61, 0x17, 0x58, 0xc8, 0x4f, 0xce, 0xa6, 0x0b, 0x13, 0x3d, - 0x7d, 0x0c, 0x35, 0x95, 0x4e, 0xb1, 0xef, 0x37, 0xa2, 0x81, 0xae, 0x5a, 0xa2, 0x3e, 0x73, 0x23, - 0xa3, 0x27, 0xa9, 0x3c, 0xe6, 0xae, 0x54, 0xd3, 0xc9, 0x42, 0xab, 0xb4, 0x10, 0x73, 0x18, 0x93, - 0x5b, 0x29, 0x9b, 0xc5, 0xe4, 0xd6, 0xe1, 0x87, 0x94, 0x5b, 0x25, 0x01, 0x9c, 0xd0, 0x42, 0x4d, - 0x98, 0xae, 0x9b, 0x79, 0x5e, 0x95, 0x5f, 0xe1, 0x93, 0x3d, 0x33, 0xae, 0xb6, 0xb5, 0xa4, 0x7a, - 0x8b, 0x69, 0x2a, 0xb8, 0x93, 0x30, 0x7a, 0x15, 0x46, 0xde, 0x0b, 0x22, 0xb6, 0x28, 0x05, 0xaf, - 0x21, 0xfd, 0xaf, 0x46, 0xde, 0xbc, 0x5d, 0x63, 0xe5, 0x87, 0xfb, 0xe5, 0xd1, 0x6a, 0xe0, 0xca, - 0xbf, 0x58, 0x55, 0x40, 0x0f, 0xe0, 0x8c, 0x71, 0x42, 0xab, 0xee, 0x42, 0xff, 0xdd, 0xbd, 0x20, - 0x9a, 0x3b, 0xb3, 0x92, 0x45, 0x09, 0x67, 0x37, 0x40, 0x8f, 0x3d, 0x3f, 0x10, 0x39, 0x92, 0x25, - 0x3f, 0xc3, 0xd8, 0x96, 0x92, 0xee, 0x7d, 0x9f, 0x42, 0xc0, 0x9d, 0x75, 0xec, 0x5f, 0xe6, 0x4f, - 0x26, 0x42, 0xb1, 0x4a, 0xa2, 0x76, 0xf3, 0x24, 0x52, 0x70, 0x2d, 0x19, 0x3a, 0xdf, 0x87, 0x7e, - 0x96, 0xfb, 0x35, 0x8b, 0x3d, 0xcb, 0xad, 0x93, 0x9d, 0x56, 0x93, 0x8a, 0xf7, 0x8f, 0xbe, 0xe3, - 0x6f, 0xc2, 0x48, 0x2c, 0x5a, 0xeb, 0x96, 0x35, 0x4c, 0xeb, 0x14, 0x7b, 0x9a, 0x54, 0x9c, 0x8e, - 0x2c, 0xc5, 0x8a, 0x8c, 0xfd, 0xcf, 0xf9, 0x0c, 0x48, 0xc8, 0x09, 0xe8, 0xdf, 0x2a, 0xa6, 0xfe, - 0xad, 0xdc, 0xe3, 0x0b, 0x72, 0xf4, 0x70, 0xff, 0xcc, 0xec, 0x37, 0x13, 0x2a, 0x3f, 0xea, 0xef, - 0xc1, 0xf6, 0x0f, 0x59, 0x70, 0x3a, 0xcb, 0x80, 0x8a, 0x72, 0xa7, 0x5c, 0xa4, 0x55, 0xef, 0xe3, - 0x6a, 0x04, 0xef, 0x8a, 0x72, 0xac, 0x30, 0xfa, 0x4e, 0xc8, 0x71, 0xb4, 0x00, 0x75, 0xb7, 0x61, - 0xbc, 0x1a, 0x12, 0xed, 0x0e, 0x78, 0x9d, 0x3b, 0xf2, 0xf1, 0xfe, 0x3c, 0x7b, 0x64, 0x27, 0x3e, - 0xfb, 0xa7, 0x0b, 0x70, 0x9a, 0x3f, 0x70, 0xcd, 0xef, 0x06, 0x9e, 0x5b, 0x0d, 0x5c, 0x91, 0x4c, - 0xe5, 0x2d, 0x18, 0x6b, 0x69, 0x7a, 0x88, 0x6e, 0x21, 0xb2, 0x74, 0x7d, 0x45, 0x22, 0x0f, 0xea, - 0xa5, 0xd8, 0xa0, 0x85, 0x5c, 0x18, 0x23, 0xbb, 0x5e, 0x5d, 0xbd, 0x92, 0x14, 0x8e, 0x7c, 0x37, - 0xa8, 0x56, 0x96, 0x34, 0x3a, 0xd8, 0xa0, 0xfa, 0x08, 0xf2, 0xeb, 0xd9, 0x3f, 0x6c, 0xc1, 0x63, - 0x39, 0x01, 0xb5, 0x68, 0x73, 0xf7, 0xd9, 0x53, 0xa2, 0x48, 0xd5, 0xa5, 0x9a, 0xe3, 0x0f, 0x8c, - 0x58, 0x40, 0xd1, 0xe7, 0x00, 0xf8, 0x03, 0x21, 0x15, 0x8f, 0x7a, 0x45, 0x1e, 0x32, 0x82, 0xa6, - 0x68, 0xc1, 0x2e, 0x64, 0x7d, 0xac, 0xd1, 0xb2, 0x7f, 0xa2, 0x08, 0x83, 0xec, 0x41, 0x0a, 0x2d, - 0xc3, 0xf0, 0x16, 0x0f, 0x31, 0xdd, 0x4f, 0x34, 0xeb, 0x44, 0xce, 0xe4, 0x05, 0x58, 0x56, 0x46, - 0xab, 0x70, 0x8a, 0x87, 0xe8, 0x6e, 0x56, 0x48, 0xd3, 0xd9, 0x93, 0xea, 0x0a, 0x9e, 0xde, 0x4a, - 0x05, 0xee, 0x58, 0xe9, 0x44, 0xc1, 0x59, 0xf5, 0xd0, 0xeb, 0x30, 0x41, 0xf9, 0xbb, 0xa0, 0x1d, - 0x4b, 0x4a, 0x3c, 0x38, 0xb7, 0x62, 0x28, 0xd7, 0x0d, 0x28, 0x4e, 0x61, 0x53, 0xc1, 0xab, 0xd5, - 0xa1, 0x98, 0x19, 0x4c, 0x04, 0x2f, 0x53, 0x19, 0x63, 0xe2, 0x32, 0xcb, 0xa9, 0x36, 0xb3, 0x13, - 0x5b, 0xdf, 0x0a, 0x49, 0xb4, 0x15, 0x34, 0x5d, 0x91, 0x1d, 0x3d, 0xb1, 0x9c, 0x4a, 0xc1, 0x71, - 0x47, 0x0d, 0x4a, 0x65, 0xd3, 0xf1, 0x9a, 0xed, 0x90, 0x24, 0x54, 0x86, 0x4c, 0x2a, 0xcb, 0x29, - 0x38, 0xee, 0xa8, 0x41, 0xd7, 0xd1, 0x19, 0x91, 0xae, 0x5c, 0x86, 0x13, 0x50, 0xe6, 0x70, 0xc3, - 0xd2, 0xb1, 0xaa, 0x4b, 0x3c, 0x1d, 0x61, 0x30, 0xa4, 0x12, 0x9e, 0x6b, 0xea, 0x4b, 0xe1, 0x52, - 0x25, 0xa9, 0x3c, 0x4c, 0xd2, 0xec, 0xef, 0x2f, 0xc0, 0xa9, 0x0c, 0xb3, 0x5b, 0x7e, 0x54, 0x35, - 0xbc, 0x28, 0x56, 0x29, 0x7c, 0xb4, 0xa3, 0x8a, 0x97, 0x63, 0x85, 0x41, 0xf7, 0x03, 0x3f, 0x0c, - 0xd3, 0x07, 0xa0, 0x30, 0x6b, 0x13, 0xd0, 0x23, 0x26, 0xc3, 0xb9, 0x04, 0x03, 0xed, 0x88, 0xc8, - 0x48, 0x58, 0xea, 0xfc, 0x66, 0x0a, 0x6d, 0x06, 0xa1, 0xac, 0x69, 0x43, 0xe9, 0x92, 0x35, 0xd6, - 0x94, 0x2b, 0x88, 0x39, 0x8c, 0x76, 0x2e, 0x26, 0xbe, 0xe3, 0xc7, 0x82, 0x81, 0x4d, 0xe2, 0xb7, - 0xb0, 0x52, 0x2c, 0xa0, 0xf6, 0x57, 0x8a, 0x70, 0x2e, 0xd7, 0x10, 0x9f, 0x76, 0x7d, 0x27, 0xf0, - 0xbd, 0x38, 0x50, 0x8f, 0xa2, 0x3c, 0x66, 0x0b, 0x69, 0x6d, 0xad, 0x8a, 0x72, 0xac, 0x30, 0xd0, - 0x65, 0x99, 0x60, 0x3f, 0x9d, 0xcc, 0x68, 0xa1, 0x62, 0xe4, 0xd8, 0xef, 0x37, 0x51, 0xdc, 0x93, - 0x30, 0xd0, 0x0a, 0x82, 0x66, 0xfa, 0xd0, 0xa2, 0xdd, 0x0d, 0x82, 0x26, 0x66, 0x40, 0xf4, 0x09, - 0x31, 0x5e, 0xa9, 0x57, 0x40, 0xec, 0xb8, 0x41, 0xa4, 0x0d, 0xda, 0xd3, 0x30, 0xbc, 0x4d, 0xf6, - 0x42, 0xcf, 0x6f, 0xa4, 0x5f, 0x87, 0x6f, 0xf2, 0x62, 0x2c, 0xe1, 0x66, 0x6a, 0x8b, 0xe1, 0xe3, - 0xce, 0xf0, 0x36, 0xd2, 0xf3, 0x0a, 0xfc, 0x81, 0x22, 0x4c, 0xe2, 0x85, 0xca, 0x37, 0x27, 0xe2, - 0x4e, 0xe7, 0x44, 0x1c, 0x77, 0x86, 0xb7, 0xde, 0xb3, 0xf1, 0x0b, 0x16, 0x4c, 0xb2, 0xf0, 0xcf, - 0x22, 0x52, 0x88, 0x17, 0xf8, 0x27, 0xc0, 0xe2, 0x3d, 0x09, 0x83, 0x21, 0x6d, 0x34, 0x9d, 0xc5, - 0x88, 0xf5, 0x04, 0x73, 0x18, 0x3a, 0x0f, 0x03, 0xac, 0x0b, 0x74, 0xf2, 0xc6, 0x78, 0x02, 0x88, - 0x8a, 0x13, 0x3b, 0x98, 0x95, 0x32, 0xf7, 0x77, 0x4c, 0x5a, 0x4d, 0x8f, 0x77, 0x3a, 0x79, 0x02, - 0xf9, 0x68, 0xb8, 0xbf, 0x67, 0x76, 0xed, 0x83, 0xb9, 0xbf, 0x67, 0x93, 0xec, 0x2e, 0x3e, 0xfd, - 0x61, 0x01, 0x2e, 0x66, 0xd6, 0xeb, 0xdb, 0xfd, 0xbd, 0x7b, 0xed, 0xe3, 0x31, 0xf2, 0xc9, 0xb6, - 0xbd, 0x29, 0x9e, 0xa0, 0xed, 0xcd, 0x40, 0xbf, 0x1c, 0xe6, 0x60, 0x1f, 0x5e, 0xe9, 0x99, 0x43, - 0xf6, 0x11, 0xf1, 0x4a, 0xcf, 0xec, 0x5b, 0x8e, 0xf8, 0xf7, 0x67, 0x85, 0x9c, 0x6f, 0x61, 0x82, - 0xe0, 0x15, 0x7a, 0xce, 0x30, 0x60, 0x24, 0x38, 0xe6, 0x31, 0x7e, 0xc6, 0xf0, 0x32, 0xac, 0xa0, - 0xc8, 0xd3, 0xfc, 0xbb, 0x0b, 0xf9, 0x49, 0x3d, 0x73, 0x9b, 0x9a, 0x33, 0x5f, 0xac, 0xd4, 0x10, - 0x64, 0xf8, 0x7a, 0xaf, 0x6a, 0xc2, 0x7b, 0xb1, 0x7f, 0xe1, 0x7d, 0x2c, 0x5b, 0x70, 0x47, 0xf3, - 0x30, 0xb9, 0xe3, 0xf9, 0xf4, 0xd8, 0xdc, 0x33, 0x59, 0x56, 0x15, 0xee, 0x64, 0xd5, 0x04, 0xe3, - 0x34, 0xfe, 0xec, 0xab, 0x30, 0xfe, 0xf0, 0x6a, 0xcb, 0x6f, 0x14, 0xe1, 0xf1, 0x2e, 0xdb, 0x9e, - 0x9f, 0xf5, 0xc6, 0x1c, 0x68, 0x67, 0x7d, 0xc7, 0x3c, 0x54, 0xe1, 0xf4, 0x66, 0xbb, 0xd9, 0xdc, - 0x63, 0xe6, 0xad, 0xc4, 0x95, 0x18, 0x82, 0xa7, 0x3c, 0x2f, 0x53, 0x6e, 0x2c, 0x67, 0xe0, 0xe0, - 0xcc, 0x9a, 0xe8, 0x0d, 0x40, 0x81, 0xc8, 0x28, 0x7c, 0x9d, 0xf8, 0xe2, 0x1d, 0x80, 0x0d, 0x7c, - 0x31, 0xd9, 0x8c, 0xb7, 0x3b, 0x30, 0x70, 0x46, 0x2d, 0x2a, 0x1c, 0xd0, 0x5b, 0x69, 0x4f, 0x75, - 0x2b, 0x25, 0x1c, 0x60, 0x1d, 0x88, 0x4d, 0x5c, 0x74, 0x1d, 0xa6, 0x9d, 0x5d, 0xc7, 0xe3, 0x61, - 0x00, 0x25, 0x01, 0x2e, 0x1d, 0x28, 0x65, 0xd9, 0x7c, 0x1a, 0x01, 0x77, 0xd6, 0x49, 0x79, 0x80, - 0x0f, 0xe5, 0x7b, 0x80, 0x77, 0x3f, 0x17, 0x7b, 0xe9, 0x7e, 0xed, 0xff, 0x6a, 0xd1, 0xeb, 0x4b, - 0x4b, 0xf4, 0xaf, 0x1e, 0x5b, 0x5f, 0x65, 0x06, 0x2c, 0x5c, 0x19, 0xa8, 0x39, 0x63, 0x9f, 0xd1, - 0x0c, 0x58, 0x12, 0x20, 0x36, 0x71, 0xf9, 0x82, 0x88, 0x12, 0x1f, 0x20, 0x83, 0xc5, 0x17, 0xc1, - 0x1c, 0x14, 0x06, 0xfa, 0x3c, 0x0c, 0xbb, 0xde, 0xae, 0x17, 0x05, 0xa1, 0xd8, 0x2c, 0x47, 0xf4, - 0xa4, 0x48, 0xce, 0xc1, 0x0a, 0x27, 0x83, 0x25, 0x3d, 0xfb, 0x07, 0x0a, 0x30, 0x2e, 0x5b, 0x7c, - 0xb3, 0x1d, 0xc4, 0xce, 0x09, 0x5c, 0xcb, 0xd7, 0x8d, 0x6b, 0xf9, 0x13, 0xdd, 0x22, 0x5a, 0xb0, - 0x2e, 0xe5, 0x5e, 0xc7, 0xb7, 0x53, 0xd7, 0xf1, 0x53, 0xbd, 0x49, 0x75, 0xbf, 0x86, 0xff, 0x85, - 0x05, 0xd3, 0x06, 0xfe, 0x09, 0xdc, 0x06, 0xcb, 0xe6, 0x6d, 0xf0, 0x44, 0xcf, 0x6f, 0xc8, 0xb9, - 0x05, 0xbe, 0xb7, 0x98, 0xea, 0x3b, 0x3b, 0xfd, 0xdf, 0x83, 0x81, 0x2d, 0x27, 0x74, 0xbb, 0x45, - 0xce, 0xed, 0xa8, 0x34, 0x77, 0xc3, 0x09, 0x5d, 0x7e, 0x86, 0x3f, 0xab, 0xd2, 0x72, 0x3a, 0xa1, - 0xdb, 0xd3, 0xe5, 0x8d, 0x35, 0x85, 0x5e, 0x81, 0xa1, 0xa8, 0x1e, 0xb4, 0x94, 0x41, 0xea, 0x25, - 0x9e, 0xb2, 0x93, 0x96, 0x1c, 0xee, 0x97, 0x91, 0xd9, 0x1c, 0x2d, 0xc6, 0x02, 0x1f, 0xbd, 0x05, - 0xe3, 0xec, 0x97, 0xb2, 0x94, 0x28, 0xe6, 0xe7, 0x6b, 0xa8, 0xe9, 0x88, 0xdc, 0xe0, 0xc6, 0x28, - 0xc2, 0x26, 0xa9, 0xd9, 0x06, 0x94, 0xd4, 0x67, 0x3d, 0x52, 0x57, 0xa5, 0xff, 0x54, 0x84, 0x53, - 0x19, 0x6b, 0x0e, 0x45, 0xc6, 0x4c, 0x3c, 0xdf, 0xe7, 0x52, 0xfd, 0x80, 0x73, 0x11, 0x31, 0x69, - 0xc8, 0x15, 0x6b, 0xab, 0xef, 0x46, 0xef, 0x44, 0x24, 0xdd, 0x28, 0x2d, 0xea, 0xdd, 0x28, 0x6d, - 0xec, 0xc4, 0x86, 0x9a, 0x36, 0xa4, 0x7a, 0xfa, 0x48, 0xe7, 0xf4, 0x8f, 0x8b, 0x70, 0x3a, 0x2b, - 0xc8, 0x0e, 0xfa, 0xce, 0x54, 0xee, 0x9e, 0x17, 0xfb, 0x0d, 0xcf, 0xc3, 0x13, 0xfa, 0x88, 0xd4, - 0xdb, 0x73, 0x66, 0x36, 0x9f, 0x9e, 0xc3, 0x2c, 0xda, 0x64, 0xfe, 0xad, 0x21, 0xcf, 0xb9, 0x24, - 0x8f, 0x8f, 0x4f, 0xf7, 0xdd, 0x01, 0x91, 0xac, 0x29, 0x4a, 0xf9, 0xb7, 0xca, 0xe2, 0xde, 0xfe, - 0xad, 0xb2, 0xe5, 0x59, 0x0f, 0x46, 0xb5, 0xaf, 0x79, 0xa4, 0x33, 0xbe, 0x4d, 0x6f, 0x2b, 0xad, - 0xdf, 0x8f, 0x74, 0xd6, 0x7f, 0xd8, 0x82, 0x94, 0xf5, 0xa7, 0x52, 0x8b, 0x59, 0xb9, 0x6a, 0xb1, - 0x4b, 0x30, 0x10, 0x06, 0x4d, 0x92, 0x4e, 0x95, 0x83, 0x83, 0x26, 0xc1, 0x0c, 0x42, 0x31, 0xe2, - 0x44, 0xd9, 0x31, 0xa6, 0x0b, 0x72, 0x42, 0x44, 0x7b, 0x12, 0x06, 0x9b, 0x64, 0x97, 0x34, 0xd3, - 0x71, 0xe8, 0x6f, 0xd1, 0x42, 0xcc, 0x61, 0xf6, 0x2f, 0x0c, 0xc0, 0x85, 0xae, 0x1e, 0xe2, 0x54, - 0x1c, 0x6a, 0x38, 0x31, 0xb9, 0xef, 0xec, 0xa5, 0x03, 0x46, 0x5f, 0xe7, 0xc5, 0x58, 0xc2, 0x99, - 0x41, 0x3c, 0x0f, 0x10, 0x99, 0x52, 0x22, 0x8a, 0xb8, 0x90, 0x02, 0x6a, 0x2a, 0xa5, 0x8a, 0xc7, - 0xa1, 0x94, 0xba, 0x06, 0x10, 0x45, 0x4d, 0x6e, 0x5f, 0xe0, 0x0a, 0x4b, 0xfb, 0x24, 0x90, 0x68, - 0xed, 0x96, 0x80, 0x60, 0x0d, 0x0b, 0x55, 0x60, 0xaa, 0x15, 0x06, 0x31, 0xd7, 0xc9, 0x56, 0xb8, - 0x61, 0xd2, 0xa0, 0xe9, 0x9c, 0x5b, 0x4d, 0xc1, 0x71, 0x47, 0x0d, 0xf4, 0x12, 0x8c, 0x0a, 0x87, - 0xdd, 0x6a, 0x10, 0x34, 0x85, 0x1a, 0x48, 0x99, 0xb9, 0xd4, 0x12, 0x10, 0xd6, 0xf1, 0xb4, 0x6a, - 0x4c, 0xd1, 0x3b, 0x9c, 0x59, 0x8d, 0x2b, 0x7b, 0x35, 0xbc, 0x54, 0xc0, 0xad, 0x91, 0xbe, 0x02, - 0x6e, 0x25, 0x8a, 0xb1, 0x52, 0xdf, 0x6f, 0x5b, 0xd0, 0x53, 0x95, 0xf4, 0xb3, 0x03, 0x70, 0x4a, - 0x2c, 0x9c, 0x47, 0xbd, 0x5c, 0xee, 0x74, 0x2e, 0x97, 0xe3, 0x50, 0x9d, 0x7d, 0x73, 0xcd, 0x9c, - 0xf4, 0x9a, 0xf9, 0x41, 0x0b, 0x4c, 0xf6, 0x0a, 0xfd, 0xa5, 0xdc, 0x88, 0xfb, 0x2f, 0xe5, 0xb2, - 0x6b, 0xae, 0xbc, 0x40, 0x3e, 0x60, 0xec, 0x7d, 0xfb, 0xbf, 0x58, 0xf0, 0x44, 0x4f, 0x8a, 0x68, - 0x09, 0x4a, 0x8c, 0x07, 0xd4, 0xa4, 0xb3, 0xa7, 0x94, 0xe1, 0xa2, 0x04, 0xe4, 0xb0, 0xa4, 0x49, - 0x4d, 0xb4, 0xd4, 0x91, 0xda, 0xe0, 0xe9, 0x8c, 0xd4, 0x06, 0x67, 0x8c, 0xe1, 0x79, 0xc8, 0xdc, - 0x06, 0xbf, 0x5c, 0x84, 0x21, 0xbe, 0xe2, 0x4f, 0x40, 0x0c, 0x5b, 0x16, 0x7a, 0xdb, 0x2e, 0x21, - 0xb7, 0x78, 0x5f, 0xe6, 0x2a, 0x4e, 0xec, 0x70, 0x36, 0x41, 0xdd, 0x56, 0x89, 0x86, 0x17, 0xcd, - 0x19, 0xf7, 0xd9, 0x6c, 0x4a, 0x31, 0x09, 0x9c, 0x86, 0x76, 0xbb, 0x7d, 0x11, 0x20, 0x8a, 0x43, - 0xcf, 0x6f, 0x50, 0x1a, 0x22, 0x78, 0xdb, 0x27, 0xbb, 0xb4, 0x5e, 0x53, 0xc8, 0xbc, 0x0f, 0xc9, - 0x4e, 0x57, 0x00, 0xac, 0x51, 0x9c, 0x7d, 0x19, 0x4a, 0x0a, 0xb9, 0x97, 0x16, 0x67, 0x4c, 0x67, - 0x2e, 0x3e, 0x0b, 0x93, 0xa9, 0xb6, 0x8e, 0xa4, 0x04, 0xfa, 0x45, 0x0b, 0x26, 0x79, 0x97, 0x97, - 0xfc, 0x5d, 0x71, 0xa6, 0xbe, 0x0f, 0xa7, 0x9b, 0x19, 0x67, 0x9b, 0x98, 0xd1, 0xfe, 0xcf, 0x42, - 0xa5, 0xf4, 0xc9, 0x82, 0xe2, 0xcc, 0x36, 0xd0, 0x15, 0xba, 0x6e, 0xe9, 0xd9, 0xe5, 0x34, 0x85, - 0x73, 0xd5, 0x18, 0x5f, 0xb3, 0xbc, 0x0c, 0x2b, 0xa8, 0xfd, 0x5b, 0x16, 0x4c, 0xf3, 0x9e, 0xdf, - 0x24, 0x7b, 0x6a, 0x87, 0x7f, 0x98, 0x7d, 0x17, 0xd9, 0x46, 0x0a, 0x39, 0xd9, 0x46, 0xf4, 0x4f, - 0x2b, 0x76, 0xfd, 0xb4, 0x9f, 0xb6, 0x40, 0xac, 0xc0, 0x13, 0x10, 0xe5, 0xbf, 0xd5, 0x14, 0xe5, - 0x67, 0xf3, 0x17, 0x75, 0x8e, 0x0c, 0xff, 0xa7, 0x16, 0x4c, 0x71, 0x84, 0xe4, 0xcd, 0xf9, 0x43, - 0x9d, 0x87, 0x7e, 0xd2, 0x06, 0xaa, 0x5c, 0xe2, 0xd9, 0x1f, 0x65, 0x4c, 0xd6, 0x40, 0xd7, 0xc9, - 0x72, 0xe5, 0x06, 0x3a, 0x42, 0xca, 0xcc, 0x23, 0x47, 0xed, 0xb6, 0xff, 0xc0, 0x02, 0xc4, 0x9b, - 0x31, 0xd8, 0x1f, 0xca, 0x54, 0xb0, 0x52, 0xed, 0xba, 0x48, 0x8e, 0x1a, 0x05, 0xc1, 0x1a, 0xd6, - 0xb1, 0x0c, 0x4f, 0xca, 0x70, 0xa0, 0xd8, 0xdb, 0x70, 0xe0, 0x08, 0x23, 0xfa, 0xfb, 0x83, 0x90, - 0x76, 0x3f, 0x40, 0x77, 0x61, 0xac, 0xee, 0xb4, 0x9c, 0x0d, 0xaf, 0xe9, 0xc5, 0x1e, 0x89, 0xba, - 0x59, 0x1c, 0x2d, 0x6a, 0x78, 0xe2, 0xa9, 0x57, 0x2b, 0xc1, 0x06, 0x1d, 0x34, 0x07, 0xd0, 0x0a, - 0xbd, 0x5d, 0xaf, 0x49, 0x1a, 0x4c, 0xe3, 0xc0, 0xdc, 0x39, 0xb9, 0x19, 0x8d, 0x2c, 0xc5, 0x1a, - 0x46, 0x86, 0x67, 0x5e, 0xf1, 0xd1, 0x79, 0xe6, 0x0d, 0x1c, 0xd1, 0x33, 0x6f, 0xb0, 0x2f, 0xcf, - 0x3c, 0x0c, 0x67, 0x25, 0x8b, 0x44, 0xff, 0x2f, 0x7b, 0x4d, 0x22, 0xf8, 0x62, 0xee, 0xe4, 0x39, - 0x7b, 0xb0, 0x5f, 0x3e, 0x8b, 0x33, 0x31, 0x70, 0x4e, 0x4d, 0xf4, 0x39, 0x98, 0x71, 0x9a, 0xcd, - 0xe0, 0xbe, 0x1a, 0xb5, 0xa5, 0xa8, 0xee, 0x34, 0xb9, 0xc6, 0x7e, 0x98, 0x51, 0x3d, 0x7f, 0xb0, - 0x5f, 0x9e, 0x99, 0xcf, 0xc1, 0xc1, 0xb9, 0xb5, 0x53, 0x8e, 0x7d, 0x23, 0x3d, 0x1d, 0xfb, 0x5e, - 0x83, 0x52, 0x2b, 0x0c, 0xea, 0xab, 0x9a, 0xf7, 0xcf, 0x45, 0x96, 0x90, 0x5f, 0x16, 0x1e, 0xee, - 0x97, 0xc7, 0xd5, 0x1f, 0x76, 0xc3, 0x27, 0x15, 0x32, 0xfc, 0xf9, 0xe0, 0x51, 0xfa, 0xf3, 0x6d, - 0xc3, 0xa9, 0x1a, 0x09, 0x3d, 0x96, 0x59, 0xd4, 0x4d, 0xce, 0x8f, 0x75, 0x28, 0x85, 0xa9, 0x13, - 0xb3, 0xaf, 0x30, 0x55, 0x5a, 0xf4, 0x64, 0x79, 0x42, 0x26, 0x84, 0xec, 0x3f, 0xb1, 0x60, 0x58, - 0x18, 0xbe, 0x9f, 0x00, 0xa3, 0x36, 0x6f, 0xe8, 0xcb, 0xcb, 0xd9, 0xb7, 0x0a, 0xeb, 0x4c, 0xae, - 0xa6, 0x7c, 0x25, 0xa5, 0x29, 0x7f, 0xa2, 0x1b, 0x91, 0xee, 0x3a, 0xf2, 0xbf, 0x5b, 0x84, 0x09, - 0xd3, 0x57, 0xe5, 0x04, 0x86, 0x60, 0x0d, 0x86, 0x23, 0xe1, 0x18, 0x55, 0xc8, 0x37, 0xe8, 0x4e, - 0x4f, 0x62, 0x62, 0xad, 0x25, 0x5c, 0xa1, 0x24, 0x91, 0x4c, 0x8f, 0xab, 0xe2, 0x23, 0xf4, 0xb8, - 0xea, 0xe5, 0x2e, 0x34, 0x70, 0x1c, 0xee, 0x42, 0xf6, 0xd7, 0xd8, 0xcd, 0xa6, 0x97, 0x9f, 0x00, - 0xd3, 0x73, 0xdd, 0xbc, 0x03, 0xed, 0x2e, 0x2b, 0x4b, 0x74, 0x2a, 0x87, 0xf9, 0xf9, 0x79, 0x0b, - 0x2e, 0x64, 0x7c, 0x95, 0xc6, 0x09, 0x3d, 0x0b, 0x23, 0x4e, 0xdb, 0xf5, 0xd4, 0x5e, 0xd6, 0x5e, - 0xcd, 0xe6, 0x45, 0x39, 0x56, 0x18, 0x68, 0x11, 0xa6, 0xc9, 0x83, 0x96, 0xc7, 0x9f, 0x2d, 0x75, - 0x93, 0xca, 0x22, 0x0f, 0xdd, 0xbb, 0x94, 0x06, 0xe2, 0x4e, 0x7c, 0xe5, 0xdc, 0x5e, 0xcc, 0x75, - 0x6e, 0xff, 0xc7, 0x16, 0x8c, 0x2a, 0x27, 0x98, 0x47, 0x3e, 0xda, 0xdf, 0x66, 0x8e, 0xf6, 0xe3, - 0x5d, 0x46, 0x3b, 0x67, 0x98, 0xff, 0x7e, 0x41, 0xf5, 0xb7, 0x1a, 0x84, 0x71, 0x1f, 0x1c, 0xd6, - 0x2b, 0x30, 0xd2, 0x0a, 0x83, 0x38, 0xa8, 0x07, 0x4d, 0xc1, 0x60, 0x9d, 0x4f, 0x62, 0x2f, 0xf0, - 0xf2, 0x43, 0xed, 0x37, 0x56, 0xd8, 0x6c, 0xf4, 0x82, 0x30, 0x16, 0x4c, 0x4d, 0x32, 0x7a, 0x41, - 0x18, 0x63, 0x06, 0x41, 0x2e, 0x40, 0xec, 0x84, 0x0d, 0x12, 0xd3, 0x32, 0x11, 0xc6, 0x25, 0xff, - 0xf0, 0x68, 0xc7, 0x5e, 0x73, 0xce, 0xf3, 0xe3, 0x28, 0x0e, 0xe7, 0x56, 0xfc, 0xf8, 0x76, 0xc8, - 0xe5, 0x35, 0x2d, 0x98, 0x82, 0xa2, 0x85, 0x35, 0xba, 0xd2, 0x05, 0x95, 0xb5, 0x31, 0x68, 0xbe, - 0xbf, 0xaf, 0x89, 0x72, 0xac, 0x30, 0xec, 0x97, 0xd9, 0x55, 0xc2, 0x06, 0xe8, 0x68, 0x71, 0x0e, - 0xbe, 0x3e, 0xa2, 0x86, 0x96, 0x3d, 0xbe, 0x55, 0xf4, 0x68, 0x0a, 0xdd, 0x4f, 0x6e, 0xda, 0xb0, - 0xee, 0xde, 0x93, 0x84, 0x5c, 0x40, 0xdf, 0xde, 0x61, 0x96, 0xf1, 0x5c, 0x8f, 0x2b, 0xe0, 0x08, - 0x86, 0x18, 0x2c, 0x9c, 0x38, 0x0b, 0xb6, 0xbc, 0x52, 0x15, 0x8b, 0x5c, 0x0b, 0x27, 0x2e, 0x00, - 0x38, 0xc1, 0x41, 0x57, 0x85, 0xb4, 0x3f, 0x60, 0x24, 0x15, 0x94, 0xd2, 0xbe, 0xfc, 0x7c, 0x4d, - 0xdc, 0x7f, 0x1e, 0x46, 0x55, 0x72, 0xc1, 0x2a, 0xcf, 0xd1, 0x26, 0x82, 0xda, 0x2c, 0x25, 0xc5, - 0x58, 0xc7, 0x41, 0xeb, 0x30, 0x19, 0x71, 0x55, 0x8f, 0x8a, 0x5d, 0xc8, 0x55, 0x66, 0x9f, 0x94, - 0xe6, 0x1c, 0x35, 0x13, 0x7c, 0xc8, 0x8a, 0xf8, 0xd1, 0x21, 0xfd, 0x48, 0xd3, 0x24, 0xd0, 0xeb, - 0x30, 0xd1, 0xd4, 0xd3, 0xf8, 0x57, 0x85, 0x46, 0x4d, 0x59, 0x45, 0x1b, 0x49, 0xfe, 0xab, 0x38, - 0x85, 0x4d, 0x19, 0x33, 0xbd, 0x44, 0xc4, 0xdb, 0x74, 0xfc, 0x06, 0x89, 0x44, 0x6a, 0x34, 0xc6, - 0x98, 0xdd, 0xca, 0xc1, 0xc1, 0xb9, 0xb5, 0xd1, 0x2b, 0x30, 0x26, 0x3f, 0x5f, 0xf3, 0x92, 0x4e, - 0x6c, 0xef, 0x35, 0x18, 0x36, 0x30, 0xd1, 0x7d, 0x38, 0x23, 0xff, 0xaf, 0x87, 0xce, 0xe6, 0xa6, - 0x57, 0x17, 0x4e, 0xea, 0xdc, 0x01, 0x69, 0x5e, 0x7a, 0x34, 0x2d, 0x65, 0x21, 0x1d, 0xee, 0x97, - 0x2f, 0x89, 0x51, 0xcb, 0x84, 0xb3, 0x49, 0xcc, 0xa6, 0x8f, 0x56, 0xe1, 0xd4, 0x16, 0x71, 0x9a, - 0xf1, 0xd6, 0xe2, 0x16, 0xa9, 0x6f, 0xcb, 0x4d, 0xc4, 0x7c, 0xaf, 0x35, 0x8b, 0xf5, 0x1b, 0x9d, - 0x28, 0x38, 0xab, 0x1e, 0x7a, 0x1b, 0x66, 0x5a, 0xed, 0x8d, 0xa6, 0x17, 0x6d, 0xad, 0x05, 0x31, - 0xb3, 0x20, 0x51, 0xb9, 0xf9, 0x84, 0x93, 0xb6, 0xf2, 0x3b, 0xaf, 0xe6, 0xe0, 0xe1, 0x5c, 0x0a, - 0xe8, 0x7d, 0x38, 0x93, 0x5a, 0x0c, 0xc2, 0x65, 0x74, 0x22, 0x3f, 0x7a, 0x71, 0x2d, 0xab, 0x82, - 0x70, 0x01, 0xcd, 0x02, 0xe1, 0xec, 0x26, 0x3e, 0x98, 0x5d, 0xd1, 0x7b, 0xb4, 0xb2, 0xc6, 0x94, - 0xa1, 0x77, 0x60, 0x4c, 0x5f, 0x45, 0xe2, 0x82, 0xb9, 0x9c, 0xcd, 0xb3, 0x68, 0xab, 0x8d, 0xb3, - 0x74, 0x6a, 0x45, 0xe9, 0x30, 0x6c, 0x50, 0xb4, 0x09, 0x64, 0x7f, 0x1f, 0xba, 0x05, 0x23, 0xf5, - 0xa6, 0x47, 0xfc, 0x78, 0xa5, 0xda, 0x2d, 0x84, 0xca, 0xa2, 0xc0, 0x11, 0x03, 0x26, 0xc2, 0xbd, - 0xf2, 0x32, 0xac, 0x28, 0xd8, 0xbf, 0x5a, 0x80, 0x72, 0x8f, 0xd8, 0xc1, 0x29, 0xf5, 0xb7, 0xd5, - 0x97, 0xfa, 0x7b, 0x5e, 0x66, 0x1a, 0x5c, 0x4b, 0xe9, 0x04, 0x52, 0x59, 0x04, 0x13, 0xcd, 0x40, - 0x1a, 0xbf, 0x6f, 0x73, 0x64, 0x5d, 0x83, 0x3e, 0xd0, 0xd3, 0xa0, 0xde, 0x78, 0x39, 0x1b, 0xec, - 0x5f, 0x10, 0xc9, 0x7d, 0x05, 0xb1, 0xbf, 0x56, 0x80, 0x33, 0x6a, 0x08, 0xff, 0xe2, 0x0e, 0xdc, - 0x9d, 0xce, 0x81, 0x3b, 0x86, 0x37, 0x24, 0xfb, 0x36, 0x0c, 0xf1, 0x10, 0x34, 0x7d, 0x30, 0x40, - 0x4f, 0x9a, 0xf1, 0xca, 0xd4, 0x35, 0x6d, 0xc4, 0x2c, 0xfb, 0x6b, 0x16, 0x4c, 0xae, 0x2f, 0x56, - 0x6b, 0x41, 0x7d, 0x9b, 0xc4, 0xf3, 0x9c, 0x61, 0xc5, 0x82, 0xff, 0xb1, 0x1e, 0x92, 0xaf, 0xc9, - 0xe2, 0x98, 0x2e, 0xc1, 0xc0, 0x56, 0x10, 0xc5, 0xe9, 0x07, 0xe6, 0x1b, 0x41, 0x14, 0x63, 0x06, - 0xb1, 0x7f, 0xdb, 0x82, 0x41, 0x96, 0x1f, 0xb7, 0x57, 0xd2, 0xe6, 0x7e, 0xbe, 0x0b, 0xbd, 0x04, - 0x43, 0x64, 0x73, 0x93, 0xd4, 0x63, 0x31, 0xab, 0xd2, 0x4b, 0x76, 0x68, 0x89, 0x95, 0xd2, 0x4b, - 0x9f, 0x35, 0xc6, 0xff, 0x62, 0x81, 0x8c, 0xee, 0x41, 0x29, 0xf6, 0x76, 0xc8, 0xbc, 0xeb, 0x8a, - 0x27, 0xba, 0x87, 0x70, 0x4a, 0x5e, 0x97, 0x04, 0x70, 0x42, 0xcb, 0xfe, 0x4a, 0x01, 0x20, 0x89, - 0x6c, 0xd0, 0xeb, 0x13, 0x17, 0x3a, 0x1e, 0x6f, 0x2e, 0x67, 0x3c, 0xde, 0xa0, 0x84, 0x60, 0xc6, - 0xcb, 0x8d, 0x1a, 0xa6, 0x62, 0x5f, 0xc3, 0x34, 0x70, 0x94, 0x61, 0x5a, 0x84, 0xe9, 0x24, 0x32, - 0x83, 0x19, 0xa6, 0x86, 0x09, 0x29, 0xeb, 0x69, 0x20, 0xee, 0xc4, 0xb7, 0x09, 0x5c, 0x92, 0xf1, - 0x49, 0xe5, 0x5d, 0xc3, 0x2c, 0x40, 0x8f, 0x90, 0xbf, 0x3b, 0x79, 0x9d, 0x2a, 0xe4, 0xbe, 0x4e, - 0xfd, 0x98, 0x05, 0xa7, 0xd3, 0xed, 0x30, 0x97, 0xbc, 0x2f, 0x5b, 0x70, 0x86, 0xbd, 0xd1, 0xb1, - 0x56, 0x3b, 0x5f, 0x04, 0x5f, 0xcc, 0x8e, 0x58, 0xd1, 0xbd, 0xc7, 0x89, 0x3b, 0xf6, 0x6a, 0x16, - 0x69, 0x9c, 0xdd, 0xa2, 0xfd, 0x65, 0x0b, 0xce, 0xe5, 0xa6, 0x65, 0x42, 0x57, 0x60, 0xc4, 0x69, - 0x79, 0x5c, 0x01, 0x26, 0xf6, 0x3b, 0x93, 0x1e, 0xab, 0x2b, 0x5c, 0xfd, 0xa5, 0xa0, 0x2a, 0x5d, - 0x64, 0x21, 0x37, 0x5d, 0x64, 0xcf, 0xec, 0x8f, 0xf6, 0xf7, 0x59, 0x20, 0xbc, 0xb0, 0xfa, 0x38, - 0x64, 0xde, 0x92, 0xd9, 0x76, 0x8d, 0xd0, 0xf0, 0x97, 0xf2, 0xdd, 0xd2, 0x44, 0x40, 0x78, 0x75, - 0xa9, 0x1b, 0x61, 0xe0, 0x0d, 0x5a, 0xb6, 0x0b, 0x02, 0x5a, 0x21, 0x4c, 0x67, 0xd5, 0xbb, 0x37, - 0xd7, 0x00, 0x5c, 0x86, 0xab, 0xe5, 0xdc, 0x54, 0x57, 0x48, 0x45, 0x41, 0xb0, 0x86, 0x65, 0xff, - 0x87, 0x02, 0x8c, 0xca, 0x50, 0xe4, 0x6d, 0xbf, 0x1f, 0xc9, 0xf2, 0x48, 0xb9, 0x89, 0x58, 0x92, - 0x5a, 0x4a, 0xb8, 0x9a, 0x08, 0xe4, 0x49, 0x92, 0x5a, 0x09, 0xc0, 0x09, 0x0e, 0x7a, 0x1a, 0x86, - 0xa3, 0xf6, 0x06, 0x43, 0x4f, 0xf9, 0x0c, 0xd5, 0x78, 0x31, 0x96, 0x70, 0xf4, 0x39, 0x98, 0xe2, - 0xf5, 0xc2, 0xa0, 0xe5, 0x34, 0xb8, 0xb6, 0x75, 0x50, 0x39, 0xfb, 0x4e, 0xad, 0xa6, 0x60, 0x87, - 0xfb, 0xe5, 0xd3, 0xe9, 0x32, 0xa6, 0xa7, 0xef, 0xa0, 0xc2, 0xde, 0xfe, 0x79, 0x23, 0x74, 0x99, - 0x76, 0x98, 0x0c, 0x24, 0x20, 0xac, 0xe3, 0xd9, 0xef, 0x00, 0xea, 0x0c, 0xca, 0x8e, 0xde, 0xe0, - 0x06, 0x5f, 0x5e, 0x48, 0xdc, 0x6e, 0x7a, 0x7b, 0xdd, 0xa5, 0x55, 0x9a, 0xfb, 0xf3, 0x5a, 0x58, - 0xd5, 0xb7, 0xff, 0x46, 0x11, 0xa6, 0xd2, 0x0e, 0x8e, 0xe8, 0x06, 0x0c, 0xf1, 0x3b, 0x52, 0x90, - 0xef, 0xf2, 0x2c, 0xac, 0xb9, 0x45, 0xb2, 0xd3, 0x42, 0x5c, 0xb3, 0xa2, 0x3e, 0x7a, 0x1b, 0x46, - 0xdd, 0xe0, 0xbe, 0x7f, 0xdf, 0x09, 0xdd, 0xf9, 0xea, 0x8a, 0x58, 0xce, 0x99, 0xac, 0x76, 0x25, - 0x41, 0xd3, 0x5d, 0x2d, 0xd9, 0x13, 0x48, 0x02, 0xc2, 0x3a, 0x39, 0xb4, 0xce, 0x02, 0x4d, 0x6e, - 0x7a, 0x8d, 0x55, 0xa7, 0xd5, 0xcd, 0xfa, 0x77, 0x51, 0x22, 0x69, 0x94, 0xc7, 0x45, 0x34, 0x4a, - 0x0e, 0xc0, 0x09, 0x21, 0xf4, 0x9d, 0x70, 0x2a, 0xca, 0xd1, 0xce, 0xe5, 0xe5, 0xe8, 0xe8, 0xa6, - 0xb0, 0x5a, 0x78, 0x8c, 0x0a, 0x41, 0x59, 0x7a, 0xbc, 0xac, 0x66, 0xec, 0x5f, 0x3b, 0x05, 0xc6, - 0x26, 0x36, 0x52, 0x36, 0x59, 0xc7, 0x94, 0xb2, 0x09, 0xc3, 0x08, 0xd9, 0x69, 0xc5, 0x7b, 0x15, - 0x2f, 0xec, 0x96, 0x52, 0x70, 0x49, 0xe0, 0x74, 0xd2, 0x94, 0x10, 0xac, 0xe8, 0x64, 0xe7, 0xd5, - 0x2a, 0x7e, 0x88, 0x79, 0xb5, 0x06, 0x4e, 0x30, 0xaf, 0xd6, 0x1a, 0x0c, 0x37, 0xbc, 0x18, 0x93, - 0x56, 0x20, 0xb8, 0xd3, 0xcc, 0x75, 0x78, 0x9d, 0xa3, 0x74, 0x66, 0x70, 0x11, 0x00, 0x2c, 0x89, - 0xa0, 0x37, 0xd4, 0x0e, 0x1c, 0xca, 0x17, 0xee, 0x3a, 0xdf, 0x2f, 0x33, 0xf7, 0xa0, 0xc8, 0x9e, - 0x35, 0xfc, 0xb0, 0xd9, 0xb3, 0x96, 0x65, 0xce, 0xab, 0x91, 0x7c, 0x53, 0x7d, 0x96, 0xd2, 0xaa, - 0x47, 0xa6, 0xab, 0xbb, 0x7a, 0x9e, 0xb0, 0x52, 0xfe, 0x49, 0xa0, 0x52, 0x80, 0xf5, 0x99, 0x1d, - 0xec, 0xfb, 0x2c, 0x38, 0xd3, 0xca, 0x4a, 0x99, 0x27, 0xde, 0x9a, 0x5e, 0xea, 0x3b, 0x27, 0xa0, - 0xd1, 0x20, 0x93, 0xf2, 0x33, 0xd1, 0x70, 0x76, 0x73, 0x74, 0xa0, 0xc3, 0x0d, 0x57, 0xa4, 0xb7, - 0x7a, 0x32, 0x27, 0xcd, 0x58, 0x97, 0xe4, 0x62, 0xeb, 0x19, 0x29, 0xad, 0x3e, 0x9e, 0x97, 0xd2, - 0xaa, 0xef, 0x44, 0x56, 0x6f, 0xa8, 0x04, 0x63, 0xe3, 0xf9, 0x4b, 0x89, 0xa7, 0x0f, 0xeb, 0x99, - 0x56, 0xec, 0x0d, 0x95, 0x56, 0xac, 0x4b, 0x04, 0x3c, 0x9e, 0x34, 0xac, 0x67, 0x32, 0x31, 0x2d, - 0x21, 0xd8, 0xe4, 0xf1, 0x24, 0x04, 0x33, 0xae, 0x1a, 0x9e, 0x93, 0xea, 0x99, 0x1e, 0x57, 0x8d, - 0x41, 0xb7, 0xfb, 0x65, 0xc3, 0x93, 0x9f, 0x4d, 0x3f, 0x54, 0xf2, 0xb3, 0xbb, 0x7a, 0x32, 0x31, - 0xd4, 0x23, 0x5b, 0x16, 0x45, 0xea, 0x33, 0x85, 0xd8, 0x5d, 0xfd, 0x02, 0x3c, 0x95, 0x4f, 0x57, - 0xdd, 0x73, 0x9d, 0x74, 0x33, 0xaf, 0xc0, 0x8e, 0xd4, 0x64, 0xa7, 0x4f, 0x26, 0x35, 0xd9, 0x99, - 0x63, 0x4f, 0x4d, 0x76, 0xf6, 0x04, 0x52, 0x93, 0x3d, 0xf6, 0xa1, 0xa6, 0x26, 0x9b, 0x79, 0x04, - 0xa9, 0xc9, 0xd6, 0x92, 0xd4, 0x64, 0xe7, 0xf2, 0xa7, 0x24, 0xc3, 0x7e, 0x38, 0x27, 0x21, 0xd9, - 0x5d, 0x66, 0x44, 0xc0, 0x23, 0x70, 0x88, 0x10, 0x7d, 0xd9, 0x69, 0x98, 0xb3, 0xc2, 0x74, 0xf0, - 0x29, 0x51, 0x20, 0x9c, 0x90, 0xa2, 0x74, 0x93, 0x04, 0x65, 0x8f, 0x77, 0xd1, 0xe3, 0x66, 0x69, - 0xc8, 0xba, 0xa4, 0x25, 0x7b, 0x9d, 0xa7, 0x25, 0x3b, 0x9f, 0x7f, 0x92, 0xa7, 0xaf, 0x3b, 0x33, - 0x19, 0xd9, 0xf7, 0x17, 0xe0, 0x62, 0xf7, 0x7d, 0x91, 0xa8, 0xe7, 0xaa, 0xc9, 0x73, 0x52, 0x4a, - 0x3d, 0xc7, 0x65, 0xab, 0x04, 0xab, 0xef, 0x30, 0x47, 0xd7, 0x61, 0x5a, 0x19, 0x1e, 0x37, 0xbd, - 0xfa, 0x9e, 0x96, 0xde, 0x59, 0x39, 0x58, 0xd6, 0xd2, 0x08, 0xb8, 0xb3, 0x0e, 0x9a, 0x87, 0x49, - 0xa3, 0x70, 0xa5, 0x22, 0x64, 0x28, 0xa5, 0x0f, 0xac, 0x99, 0x60, 0x9c, 0xc6, 0xb7, 0x7f, 0xca, - 0x82, 0xc7, 0x72, 0xb2, 0x7e, 0xf4, 0x1d, 0xc5, 0x67, 0x13, 0x26, 0x5b, 0x66, 0xd5, 0x1e, 0xc1, - 0xbe, 0x8c, 0xdc, 0x22, 0xaa, 0xaf, 0x29, 0x00, 0x4e, 0x13, 0xb5, 0xbf, 0x66, 0xc1, 0x85, 0xae, - 0x46, 0x28, 0x08, 0xc3, 0xd9, 0xc6, 0x4e, 0xe4, 0x2c, 0x86, 0xc4, 0x25, 0x7e, 0xec, 0x39, 0xcd, - 0x5a, 0x8b, 0xd4, 0x35, 0x05, 0x2b, 0xb3, 0xf5, 0xb9, 0xbe, 0x5a, 0x9b, 0xef, 0xc4, 0xc0, 0x39, - 0x35, 0xd1, 0x32, 0xa0, 0x4e, 0x88, 0x98, 0x61, 0x16, 0x77, 0xb1, 0x93, 0x1e, 0xce, 0xa8, 0xb1, - 0x70, 0xe5, 0x37, 0x7e, 0xf7, 0xe2, 0xc7, 0x7e, 0xf3, 0x77, 0x2f, 0x7e, 0xec, 0xb7, 0x7e, 0xf7, - 0xe2, 0xc7, 0xbe, 0xfb, 0xe0, 0xa2, 0xf5, 0x1b, 0x07, 0x17, 0xad, 0xdf, 0x3c, 0xb8, 0x68, 0xfd, - 0xd6, 0xc1, 0x45, 0xeb, 0x77, 0x0e, 0x2e, 0x5a, 0x5f, 0xf9, 0xbd, 0x8b, 0x1f, 0x7b, 0xab, 0xb0, - 0xfb, 0xfc, 0xff, 0x0f, 0x00, 0x00, 0xff, 0xff, 0x43, 0x82, 0xdf, 0x38, 0xd6, 0xec, 0x00, 0x00, + // 13088 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0xbd, 0x7d, 0x70, 0x64, 0x57, + 0x56, 0x18, 0xbe, 0xaf, 0x5b, 0x1f, 0xdd, 0x47, 0xdf, 0x77, 0x3e, 0xac, 0x91, 0x67, 0xa6, 0xc7, + 0xcf, 0xbb, 0xe3, 0xf1, 0xda, 0xd6, 0xac, 0xc7, 0xf6, 0xda, 0xac, 0xbd, 0x06, 0x49, 0x2d, 0xcd, + 0xc8, 0x33, 0xd2, 0xb4, 0x6f, 0x6b, 0x66, 0x76, 0x8d, 0x77, 0xf1, 0x53, 0xbf, 0x2b, 0xe9, 0x59, + 0xad, 0xf7, 0xda, 0xef, 0xbd, 0xd6, 0x8c, 0xfc, 0x83, 0xfa, 0x91, 0x25, 0x10, 0xb6, 0x20, 0xa9, + 0xad, 0x84, 0xca, 0x07, 0x50, 0xa4, 0x8a, 0x90, 0x02, 0x02, 0x49, 0x85, 0x40, 0x80, 0xb0, 0x24, + 0x21, 0x90, 0x54, 0x91, 0xfc, 0xb1, 0x21, 0xa9, 0x4a, 0x2d, 0x55, 0x54, 0x14, 0x10, 0xa9, 0x50, + 0xa4, 0x2a, 0x90, 0x0a, 0xf9, 0x07, 0x85, 0x0a, 0xa9, 0xfb, 0xf9, 0xee, 0x7d, 0xfd, 0x5e, 0x77, + 0x6b, 0xac, 0x91, 0xcd, 0xd6, 0xfe, 0xd7, 0x7d, 0xcf, 0xb9, 0xe7, 0xde, 0x77, 0x3f, 0xcf, 0x39, + 0xf7, 0x7c, 0xc0, 0xab, 0xdb, 0xaf, 0x44, 0xb3, 0x5e, 0x70, 0x75, 0xbb, 0xbd, 0x4e, 0x42, 0x9f, + 0xc4, 0x24, 0xba, 0xba, 0x4b, 0x7c, 0x37, 0x08, 0xaf, 0x0a, 0x80, 0xd3, 0xf2, 0xae, 0x36, 0x82, + 0x90, 0x5c, 0xdd, 0x7d, 0xfe, 0xea, 0x26, 0xf1, 0x49, 0xe8, 0xc4, 0xc4, 0x9d, 0x6d, 0x85, 0x41, + 0x1c, 0x20, 0xc4, 0x71, 0x66, 0x9d, 0x96, 0x37, 0x4b, 0x71, 0x66, 0x77, 0x9f, 0x9f, 0x79, 0x6e, + 0xd3, 0x8b, 0xb7, 0xda, 0xeb, 0xb3, 0x8d, 0x60, 0xe7, 0xea, 0x66, 0xb0, 0x19, 0x5c, 0x65, 0xa8, + 0xeb, 0xed, 0x0d, 0xf6, 0x8f, 0xfd, 0x61, 0xbf, 0x38, 0x89, 0x99, 0x17, 0x93, 0x66, 0x76, 0x9c, + 0xc6, 0x96, 0xe7, 0x93, 0x70, 0xef, 0x6a, 0x6b, 0x7b, 0x93, 0xb5, 0x1b, 0x92, 0x28, 0x68, 0x87, + 0x0d, 0x92, 0x6e, 0xb8, 0x6b, 0xad, 0xe8, 0xea, 0x0e, 0x89, 0x9d, 0x8c, 0xee, 0xce, 0x5c, 0xcd, + 0xab, 0x15, 0xb6, 0xfd, 0xd8, 0xdb, 0xe9, 0x6c, 0xe6, 0xd3, 0xbd, 0x2a, 0x44, 0x8d, 0x2d, 0xb2, + 0xe3, 0x74, 0xd4, 0x7b, 0x21, 0xaf, 0x5e, 0x3b, 0xf6, 0x9a, 0x57, 0x3d, 0x3f, 0x8e, 0xe2, 0x30, + 0x5d, 0xc9, 0xfe, 0xba, 0x05, 0x97, 0xe6, 0xee, 0xd5, 0x17, 0x9b, 0x4e, 0x14, 0x7b, 0x8d, 0xf9, + 0x66, 0xd0, 0xd8, 0xae, 0xc7, 0x41, 0x48, 0xee, 0x06, 0xcd, 0xf6, 0x0e, 0xa9, 0xb3, 0x81, 0x40, + 0xcf, 0x42, 0x69, 0x97, 0xfd, 0x5f, 0xae, 0x4e, 0x5b, 0x97, 0xac, 0x2b, 0xe5, 0xf9, 0xc9, 0xdf, + 0xdc, 0xaf, 0x7c, 0xec, 0x60, 0xbf, 0x52, 0xba, 0x2b, 0xca, 0xb1, 0xc2, 0x40, 0x97, 0x61, 0x68, + 0x23, 0x5a, 0xdb, 0x6b, 0x91, 0xe9, 0x02, 0xc3, 0x1d, 0x17, 0xb8, 0x43, 0x4b, 0x75, 0x5a, 0x8a, + 0x05, 0x14, 0x5d, 0x85, 0x72, 0xcb, 0x09, 0x63, 0x2f, 0xf6, 0x02, 0x7f, 0xba, 0x78, 0xc9, 0xba, + 0x32, 0x38, 0x3f, 0x25, 0x50, 0xcb, 0x35, 0x09, 0xc0, 0x09, 0x0e, 0xed, 0x46, 0x48, 0x1c, 0xf7, + 0xb6, 0xdf, 0xdc, 0x9b, 0x1e, 0xb8, 0x64, 0x5d, 0x29, 0x25, 0xdd, 0xc0, 0xa2, 0x1c, 0x2b, 0x0c, + 0xfb, 0x87, 0x0b, 0x50, 0x9a, 0xdb, 0xd8, 0xf0, 0x7c, 0x2f, 0xde, 0x43, 0x77, 0x61, 0xd4, 0x0f, + 0x5c, 0x22, 0xff, 0xb3, 0xaf, 0x18, 0xb9, 0x76, 0x69, 0xb6, 0x73, 0x29, 0xcd, 0xae, 0x6a, 0x78, + 0xf3, 0x93, 0x07, 0xfb, 0x95, 0x51, 0xbd, 0x04, 0x1b, 0x74, 0x10, 0x86, 0x91, 0x56, 0xe0, 0x2a, + 0xb2, 0x05, 0x46, 0xb6, 0x92, 0x45, 0xb6, 0x96, 0xa0, 0xcd, 0x4f, 0x1c, 0xec, 0x57, 0x46, 0xb4, + 0x02, 0xac, 0x13, 0x41, 0xeb, 0x30, 0x41, 0xff, 0xfa, 0xb1, 0xa7, 0xe8, 0x16, 0x19, 0xdd, 0x27, + 0xf3, 0xe8, 0x6a, 0xa8, 0xf3, 0xa7, 0x0e, 0xf6, 0x2b, 0x13, 0xa9, 0x42, 0x9c, 0x26, 0x68, 0xbf, + 0x0f, 0xe3, 0x73, 0x71, 0xec, 0x34, 0xb6, 0x88, 0xcb, 0x67, 0x10, 0xbd, 0x08, 0x03, 0xbe, 0xb3, + 0x43, 0xc4, 0xfc, 0x5e, 0x12, 0x03, 0x3b, 0xb0, 0xea, 0xec, 0x90, 0xc3, 0xfd, 0xca, 0xe4, 0x1d, + 0xdf, 0x7b, 0xaf, 0x2d, 0x56, 0x05, 0x2d, 0xc3, 0x0c, 0x1b, 0x5d, 0x03, 0x70, 0xc9, 0xae, 0xd7, + 0x20, 0x35, 0x27, 0xde, 0x12, 0xf3, 0x8d, 0x44, 0x5d, 0xa8, 0x2a, 0x08, 0xd6, 0xb0, 0xec, 0x07, + 0x50, 0x9e, 0xdb, 0x0d, 0x3c, 0xb7, 0x16, 0xb8, 0x11, 0xda, 0x86, 0x89, 0x56, 0x48, 0x36, 0x48, + 0xa8, 0x8a, 0xa6, 0xad, 0x4b, 0xc5, 0x2b, 0x23, 0xd7, 0xae, 0x64, 0x7e, 0xac, 0x89, 0xba, 0xe8, + 0xc7, 0xe1, 0xde, 0xfc, 0x63, 0xa2, 0xbd, 0x89, 0x14, 0x14, 0xa7, 0x29, 0xdb, 0xff, 0xba, 0x00, + 0x67, 0xe6, 0xde, 0x6f, 0x87, 0xa4, 0xea, 0x45, 0xdb, 0xe9, 0x15, 0xee, 0x7a, 0xd1, 0xf6, 0x6a, + 0x32, 0x02, 0x6a, 0x69, 0x55, 0x45, 0x39, 0x56, 0x18, 0xe8, 0x39, 0x18, 0xa6, 0xbf, 0xef, 0xe0, + 0x65, 0xf1, 0xc9, 0xa7, 0x04, 0xf2, 0x48, 0xd5, 0x89, 0x9d, 0x2a, 0x07, 0x61, 0x89, 0x83, 0x56, + 0x60, 0xa4, 0xc1, 0x36, 0xe4, 0xe6, 0x4a, 0xe0, 0x12, 0x36, 0x99, 0xe5, 0xf9, 0x67, 0x28, 0xfa, + 0x42, 0x52, 0x7c, 0xb8, 0x5f, 0x99, 0xe6, 0x7d, 0x13, 0x24, 0x34, 0x18, 0xd6, 0xeb, 0x23, 0x5b, + 0xed, 0xaf, 0x01, 0x46, 0x09, 0x32, 0xf6, 0xd6, 0x15, 0x6d, 0xab, 0x0c, 0xb2, 0xad, 0x32, 0x9a, + 0xbd, 0x4d, 0xd0, 0xf3, 0x30, 0xb0, 0xed, 0xf9, 0xee, 0xf4, 0x10, 0xa3, 0x75, 0x81, 0xce, 0xf9, + 0x4d, 0xcf, 0x77, 0x0f, 0xf7, 0x2b, 0x53, 0x46, 0x77, 0x68, 0x21, 0x66, 0xa8, 0xf6, 0x9f, 0x58, + 0x50, 0x61, 0xb0, 0x25, 0xaf, 0x49, 0x6a, 0x24, 0x8c, 0xbc, 0x28, 0x26, 0x7e, 0x6c, 0x0c, 0xe8, + 0x35, 0x80, 0x88, 0x34, 0x42, 0x12, 0x6b, 0x43, 0xaa, 0x16, 0x46, 0x5d, 0x41, 0xb0, 0x86, 0x45, + 0x0f, 0x84, 0x68, 0xcb, 0x09, 0xd9, 0xfa, 0x12, 0x03, 0xab, 0x0e, 0x84, 0xba, 0x04, 0xe0, 0x04, + 0xc7, 0x38, 0x10, 0x8a, 0xbd, 0x0e, 0x04, 0xf4, 0x59, 0x98, 0x48, 0x1a, 0x8b, 0x5a, 0x4e, 0x43, + 0x0e, 0x20, 0xdb, 0x32, 0x75, 0x13, 0x84, 0xd3, 0xb8, 0xf6, 0x3f, 0xb0, 0xc4, 0xe2, 0xa1, 0x5f, + 0xfd, 0x11, 0xff, 0x56, 0xfb, 0x97, 0x2d, 0x18, 0x9e, 0xf7, 0x7c, 0xd7, 0xf3, 0x37, 0xd1, 0x3b, + 0x50, 0xa2, 0x77, 0x93, 0xeb, 0xc4, 0x8e, 0x38, 0xf7, 0x3e, 0xa5, 0xed, 0x2d, 0x75, 0x55, 0xcc, + 0xb6, 0xb6, 0x37, 0x69, 0x41, 0x34, 0x4b, 0xb1, 0xe9, 0x6e, 0xbb, 0xbd, 0xfe, 0x2e, 0x69, 0xc4, + 0x2b, 0x24, 0x76, 0x92, 0xcf, 0x49, 0xca, 0xb0, 0xa2, 0x8a, 0x6e, 0xc2, 0x50, 0xec, 0x84, 0x9b, + 0x24, 0x16, 0x07, 0x60, 0xe6, 0x41, 0xc5, 0x6b, 0x62, 0xba, 0x23, 0x89, 0xdf, 0x20, 0xc9, 0xb5, + 0xb0, 0xc6, 0xaa, 0x62, 0x41, 0xc2, 0xfe, 0xab, 0xc3, 0x70, 0x6e, 0xa1, 0xbe, 0x9c, 0xb3, 0xae, + 0x2e, 0xc3, 0x90, 0x1b, 0x7a, 0xbb, 0x24, 0x14, 0xe3, 0xac, 0xa8, 0x54, 0x59, 0x29, 0x16, 0x50, + 0xf4, 0x0a, 0x8c, 0xf2, 0x0b, 0xe9, 0x86, 0xe3, 0xbb, 0x4d, 0x39, 0xc4, 0xa7, 0x05, 0xf6, 0xe8, + 0x5d, 0x0d, 0x86, 0x0d, 0xcc, 0x23, 0x2e, 0xaa, 0xcb, 0xa9, 0xcd, 0x98, 0x77, 0xd9, 0x7d, 0xd9, + 0x82, 0x49, 0xde, 0xcc, 0x5c, 0x1c, 0x87, 0xde, 0x7a, 0x3b, 0x26, 0xd1, 0xf4, 0x20, 0x3b, 0xe9, + 0x16, 0xb2, 0x46, 0x2b, 0x77, 0x04, 0x66, 0xef, 0xa6, 0xa8, 0xf0, 0x43, 0x70, 0x5a, 0xb4, 0x3b, + 0x99, 0x06, 0xe3, 0x8e, 0x66, 0xd1, 0xf7, 0x58, 0x30, 0xd3, 0x08, 0xfc, 0x38, 0x0c, 0x9a, 0x4d, + 0x12, 0xd6, 0xda, 0xeb, 0x4d, 0x2f, 0xda, 0xe2, 0xeb, 0x14, 0x93, 0x0d, 0x76, 0x12, 0xe4, 0xcc, + 0xa1, 0x42, 0x12, 0x73, 0x78, 0xf1, 0x60, 0xbf, 0x32, 0xb3, 0x90, 0x4b, 0x0a, 0x77, 0x69, 0x06, + 0x6d, 0x03, 0xa2, 0x57, 0x69, 0x3d, 0x76, 0x36, 0x49, 0xd2, 0xf8, 0x70, 0xff, 0x8d, 0x9f, 0x3d, + 0xd8, 0xaf, 0xa0, 0xd5, 0x0e, 0x12, 0x38, 0x83, 0x2c, 0x7a, 0x0f, 0x4e, 0xd3, 0xd2, 0x8e, 0x6f, + 0x2d, 0xf5, 0xdf, 0xdc, 0xf4, 0xc1, 0x7e, 0xe5, 0xf4, 0x6a, 0x06, 0x11, 0x9c, 0x49, 0x1a, 0x7d, + 0xb7, 0x05, 0xe7, 0x92, 0xcf, 0x5f, 0x7c, 0xd0, 0x72, 0x7c, 0x37, 0x69, 0xb8, 0xdc, 0x7f, 0xc3, + 0xf4, 0x4c, 0x3e, 0xb7, 0x90, 0x47, 0x09, 0xe7, 0x37, 0x32, 0xb3, 0x00, 0x67, 0x32, 0x57, 0x0b, + 0x9a, 0x84, 0xe2, 0x36, 0xe1, 0x5c, 0x50, 0x19, 0xd3, 0x9f, 0xe8, 0x34, 0x0c, 0xee, 0x3a, 0xcd, + 0xb6, 0xd8, 0x28, 0x98, 0xff, 0xf9, 0x4c, 0xe1, 0x15, 0xcb, 0xfe, 0x37, 0x45, 0x98, 0x58, 0xa8, + 0x2f, 0x3f, 0xd4, 0x2e, 0xd4, 0xaf, 0xa1, 0x42, 0xd7, 0x6b, 0x28, 0xb9, 0xd4, 0x8a, 0xb9, 0x97, + 0xda, 0xff, 0x9f, 0xb1, 0x85, 0x06, 0xd8, 0x16, 0xfa, 0x96, 0x9c, 0x2d, 0x74, 0xcc, 0x1b, 0x67, + 0x37, 0x67, 0x15, 0x0d, 0xb2, 0xc9, 0xcc, 0xe4, 0x58, 0x6e, 0x05, 0x0d, 0xa7, 0x99, 0x3e, 0xfa, + 0x8e, 0xb8, 0x94, 0x8e, 0x67, 0x1e, 0x1b, 0x30, 0xba, 0xe0, 0xb4, 0x9c, 0x75, 0xaf, 0xe9, 0xc5, + 0x1e, 0x89, 0xd0, 0x53, 0x50, 0x74, 0x5c, 0x97, 0x71, 0x5b, 0xe5, 0xf9, 0x33, 0x07, 0xfb, 0x95, + 0xe2, 0x9c, 0x4b, 0xaf, 0x7d, 0x50, 0x58, 0x7b, 0x98, 0x62, 0xa0, 0x4f, 0xc2, 0x80, 0x1b, 0x06, + 0xad, 0xe9, 0x02, 0xc3, 0xa4, 0xbb, 0x6e, 0xa0, 0x1a, 0x06, 0xad, 0x14, 0x2a, 0xc3, 0xb1, 0x7f, + 0xad, 0x00, 0xe7, 0x17, 0x48, 0x6b, 0x6b, 0xa9, 0x9e, 0x73, 0x7e, 0x5f, 0x81, 0xd2, 0x4e, 0xe0, + 0x7b, 0x71, 0x10, 0x46, 0xa2, 0x69, 0xb6, 0x22, 0x56, 0x44, 0x19, 0x56, 0x50, 0x74, 0x09, 0x06, + 0x5a, 0x09, 0x53, 0x39, 0x2a, 0x19, 0x52, 0xc6, 0x4e, 0x32, 0x08, 0xc5, 0x68, 0x47, 0x24, 0x14, + 0x2b, 0x46, 0x61, 0xdc, 0x89, 0x48, 0x88, 0x19, 0x24, 0xb9, 0x99, 0xe9, 0x9d, 0x2d, 0x4e, 0xe8, + 0xd4, 0xcd, 0x4c, 0x21, 0x58, 0xc3, 0x42, 0x35, 0x28, 0x47, 0xa9, 0x99, 0xed, 0x6b, 0x9b, 0x8e, + 0xb1, 0xab, 0x5b, 0xcd, 0x64, 0x42, 0xc4, 0xb8, 0x51, 0x86, 0x7a, 0x5e, 0xdd, 0x5f, 0x2d, 0x00, + 0xe2, 0x43, 0xf8, 0x17, 0x6c, 0xe0, 0xee, 0x74, 0x0e, 0x5c, 0xff, 0x5b, 0xe2, 0xb8, 0x46, 0xef, + 0x7f, 0x5b, 0x70, 0x7e, 0xc1, 0xf3, 0x5d, 0x12, 0xe6, 0x2c, 0xc0, 0x47, 0x23, 0xcb, 0x1e, 0x8d, + 0x69, 0x30, 0x96, 0xd8, 0xc0, 0x31, 0x2c, 0x31, 0xfb, 0x8f, 0x2d, 0x40, 0xfc, 0xb3, 0x3f, 0x72, + 0x1f, 0x7b, 0xa7, 0xf3, 0x63, 0x8f, 0x61, 0x59, 0xd8, 0xb7, 0x60, 0x7c, 0xa1, 0xe9, 0x11, 0x3f, + 0x5e, 0xae, 0x2d, 0x04, 0xfe, 0x86, 0xb7, 0x89, 0x3e, 0x03, 0xe3, 0xb1, 0xb7, 0x43, 0x82, 0x76, + 0x5c, 0x27, 0x8d, 0xc0, 0x67, 0x92, 0xa4, 0x75, 0x65, 0x70, 0x1e, 0x1d, 0xec, 0x57, 0xc6, 0xd7, + 0x0c, 0x08, 0x4e, 0x61, 0xda, 0xbf, 0x43, 0xc7, 0x2f, 0xd8, 0x69, 0x05, 0x3e, 0xf1, 0xe3, 0x85, + 0xc0, 0x77, 0xb9, 0xc6, 0xe1, 0x33, 0x30, 0x10, 0xd3, 0xf1, 0xe0, 0x63, 0x77, 0x59, 0x6e, 0x14, + 0x3a, 0x0a, 0x87, 0xfb, 0x95, 0xb3, 0x9d, 0x35, 0xd8, 0x38, 0xb1, 0x3a, 0xe8, 0x5b, 0x60, 0x28, + 0x8a, 0x9d, 0xb8, 0x1d, 0x89, 0xd1, 0x7c, 0x42, 0x8e, 0x66, 0x9d, 0x95, 0x1e, 0xee, 0x57, 0x26, + 0x54, 0x35, 0x5e, 0x84, 0x45, 0x05, 0xf4, 0x34, 0x0c, 0xef, 0x90, 0x28, 0x72, 0x36, 0xe5, 0x6d, + 0x38, 0x21, 0xea, 0x0e, 0xaf, 0xf0, 0x62, 0x2c, 0xe1, 0xe8, 0x49, 0x18, 0x24, 0x61, 0x18, 0x84, + 0x62, 0x8f, 0x8e, 0x09, 0xc4, 0xc1, 0x45, 0x5a, 0x88, 0x39, 0xcc, 0xfe, 0xf7, 0x16, 0x4c, 0xa8, + 0xbe, 0xf2, 0xb6, 0x4e, 0x40, 0x2a, 0x78, 0x0b, 0xa0, 0x21, 0x3f, 0x30, 0x62, 0xb7, 0xc7, 0xc8, + 0xb5, 0xcb, 0x99, 0x17, 0x75, 0xc7, 0x30, 0x26, 0x94, 0x55, 0x51, 0x84, 0x35, 0x6a, 0xf6, 0x3f, + 0xb7, 0xe0, 0x54, 0xea, 0x8b, 0x6e, 0x79, 0x51, 0x8c, 0xde, 0xee, 0xf8, 0xaa, 0xd9, 0xfe, 0xbe, + 0x8a, 0xd6, 0x66, 0xdf, 0xa4, 0x96, 0xb2, 0x2c, 0xd1, 0xbe, 0xe8, 0x06, 0x0c, 0x7a, 0x31, 0xd9, + 0x91, 0x1f, 0xf3, 0x64, 0xd7, 0x8f, 0xe1, 0xbd, 0x4a, 0x66, 0x64, 0x99, 0xd6, 0xc4, 0x9c, 0x80, + 0xfd, 0x37, 0x8a, 0x50, 0xe6, 0xcb, 0x76, 0xc5, 0x69, 0x9d, 0xc0, 0x5c, 0x2c, 0xc3, 0x00, 0xa3, + 0xce, 0x3b, 0xfe, 0x54, 0x76, 0xc7, 0x45, 0x77, 0x66, 0xa9, 0xc8, 0xcf, 0x99, 0x23, 0x75, 0x35, + 0xd0, 0x22, 0xcc, 0x48, 0x20, 0x07, 0x60, 0xdd, 0xf3, 0x9d, 0x70, 0x8f, 0x96, 0x4d, 0x17, 0x19, + 0xc1, 0xe7, 0xba, 0x13, 0x9c, 0x57, 0xf8, 0x9c, 0xac, 0xea, 0x6b, 0x02, 0xc0, 0x1a, 0xd1, 0x99, + 0x97, 0xa1, 0xac, 0x90, 0x8f, 0xc2, 0xe3, 0xcc, 0x7c, 0x16, 0x26, 0x52, 0x6d, 0xf5, 0xaa, 0x3e, + 0xaa, 0xb3, 0x48, 0xbf, 0xc2, 0x4e, 0x01, 0xd1, 0xeb, 0x45, 0x7f, 0x57, 0x9c, 0xa2, 0xef, 0xc3, + 0xe9, 0x66, 0xc6, 0xe1, 0x24, 0xa6, 0xaa, 0xff, 0xc3, 0xec, 0xbc, 0xf8, 0xec, 0xd3, 0x59, 0x50, + 0x9c, 0xd9, 0x06, 0xbd, 0xf6, 0x83, 0x16, 0x5d, 0xf3, 0x4e, 0x53, 0xe7, 0xa0, 0x6f, 0x8b, 0x32, + 0xac, 0xa0, 0xf4, 0x08, 0x3b, 0xad, 0x3a, 0x7f, 0x93, 0xec, 0xd5, 0x49, 0x93, 0x34, 0xe2, 0x20, + 0xfc, 0x50, 0xbb, 0x7f, 0x81, 0x8f, 0x3e, 0x3f, 0x01, 0x47, 0x04, 0x81, 0xe2, 0x4d, 0xb2, 0xc7, + 0xa7, 0x42, 0xff, 0xba, 0x62, 0xd7, 0xaf, 0xfb, 0x39, 0x0b, 0xc6, 0xd4, 0xd7, 0x9d, 0xc0, 0x56, + 0x9f, 0x37, 0xb7, 0xfa, 0x85, 0xae, 0x0b, 0x3c, 0x67, 0x93, 0x7f, 0xb5, 0x00, 0xe7, 0x14, 0x0e, + 0x65, 0xf7, 0xf9, 0x1f, 0xb1, 0xaa, 0xae, 0x42, 0xd9, 0x57, 0x8a, 0x28, 0xcb, 0xd4, 0x00, 0x25, + 0x6a, 0xa8, 0x04, 0x87, 0x72, 0x6d, 0x7e, 0xa2, 0x2d, 0x1a, 0xd5, 0x35, 0xb4, 0x42, 0x1b, 0x3b, + 0x0f, 0xc5, 0xb6, 0xe7, 0x8a, 0x3b, 0xe3, 0x53, 0x72, 0xb4, 0xef, 0x2c, 0x57, 0x0f, 0xf7, 0x2b, + 0x4f, 0xe4, 0xbd, 0x0e, 0xd0, 0xcb, 0x2a, 0x9a, 0xbd, 0xb3, 0x5c, 0xc5, 0xb4, 0x32, 0x9a, 0x83, + 0x09, 0xf9, 0x00, 0x72, 0x97, 0x72, 0x50, 0x81, 0x2f, 0xae, 0x16, 0xa5, 0x66, 0xc5, 0x26, 0x18, + 0xa7, 0xf1, 0x51, 0x15, 0x26, 0xb7, 0xdb, 0xeb, 0xa4, 0x49, 0x62, 0xfe, 0xc1, 0x37, 0x09, 0x57, + 0x42, 0x96, 0x13, 0x61, 0xeb, 0x66, 0x0a, 0x8e, 0x3b, 0x6a, 0xd8, 0x7f, 0xce, 0x8e, 0x78, 0x31, + 0x7a, 0xb5, 0x30, 0xa0, 0x0b, 0x8b, 0x52, 0xff, 0x30, 0x97, 0x73, 0x3f, 0xab, 0xe2, 0x26, 0xd9, + 0x5b, 0x0b, 0x28, 0xb3, 0x9d, 0xbd, 0x2a, 0x8c, 0x35, 0x3f, 0xd0, 0x75, 0xcd, 0xff, 0x42, 0x01, + 0xce, 0xa8, 0x11, 0x30, 0xf8, 0xba, 0xbf, 0xe8, 0x63, 0xf0, 0x3c, 0x8c, 0xb8, 0x64, 0xc3, 0x69, + 0x37, 0x63, 0xa5, 0x11, 0x1f, 0xe4, 0xaf, 0x22, 0xd5, 0xa4, 0x18, 0xeb, 0x38, 0x47, 0x18, 0xb6, + 0x9f, 0x18, 0x61, 0x77, 0x6b, 0xec, 0xd0, 0x35, 0xae, 0x76, 0x8d, 0x95, 0xbb, 0x6b, 0x9e, 0x84, + 0x41, 0x6f, 0x87, 0xf2, 0x5a, 0x05, 0x93, 0x85, 0x5a, 0xa6, 0x85, 0x98, 0xc3, 0xd0, 0x27, 0x60, + 0xb8, 0x11, 0xec, 0xec, 0x38, 0xbe, 0xcb, 0xae, 0xbc, 0xf2, 0xfc, 0x08, 0x65, 0xc7, 0x16, 0x78, + 0x11, 0x96, 0x30, 0x74, 0x1e, 0x06, 0x9c, 0x70, 0x93, 0xab, 0x25, 0xca, 0xf3, 0x25, 0xda, 0xd2, + 0x5c, 0xb8, 0x19, 0x61, 0x56, 0x4a, 0xa5, 0xaa, 0xfb, 0x41, 0xb8, 0xed, 0xf9, 0x9b, 0x55, 0x2f, + 0x14, 0x5b, 0x42, 0xdd, 0x85, 0xf7, 0x14, 0x04, 0x6b, 0x58, 0x68, 0x09, 0x06, 0x5b, 0x41, 0x18, + 0x47, 0xd3, 0x43, 0x6c, 0xb8, 0x9f, 0xc8, 0x39, 0x88, 0xf8, 0xd7, 0xd6, 0x82, 0x30, 0x4e, 0x3e, + 0x80, 0xfe, 0x8b, 0x30, 0xaf, 0x8e, 0xbe, 0x05, 0x8a, 0xc4, 0xdf, 0x9d, 0x1e, 0x66, 0x54, 0x66, + 0xb2, 0xa8, 0x2c, 0xfa, 0xbb, 0x77, 0x9d, 0x30, 0x39, 0xa5, 0x17, 0xfd, 0x5d, 0x4c, 0xeb, 0xa0, + 0xcf, 0x43, 0x59, 0x6e, 0xf1, 0x48, 0x68, 0xcc, 0x32, 0x97, 0x98, 0x3c, 0x18, 0x30, 0x79, 0xaf, + 0xed, 0x85, 0x64, 0x87, 0xf8, 0x71, 0x94, 0x9c, 0x69, 0x12, 0x1a, 0xe1, 0x84, 0x1a, 0xfa, 0xbc, + 0x54, 0xd3, 0xae, 0x04, 0x6d, 0x3f, 0x8e, 0xa6, 0xcb, 0xac, 0x7b, 0x99, 0x0f, 0x68, 0x77, 0x13, + 0xbc, 0xb4, 0x1e, 0x97, 0x57, 0xc6, 0x06, 0x29, 0x84, 0x61, 0xac, 0xe9, 0xed, 0x12, 0x9f, 0x44, + 0x51, 0x2d, 0x0c, 0xd6, 0xc9, 0x34, 0xb0, 0x9e, 0x9f, 0xcb, 0x7e, 0x57, 0x0a, 0xd6, 0xc9, 0xfc, + 0xd4, 0xc1, 0x7e, 0x65, 0xec, 0x96, 0x5e, 0x07, 0x9b, 0x24, 0xd0, 0x1d, 0x18, 0xa7, 0x72, 0x8d, + 0x97, 0x10, 0x1d, 0xe9, 0x45, 0x94, 0x49, 0x1f, 0xd8, 0xa8, 0x84, 0x53, 0x44, 0xd0, 0x1b, 0x50, + 0x6e, 0x7a, 0x1b, 0xa4, 0xb1, 0xd7, 0x68, 0x92, 0xe9, 0x51, 0x46, 0x31, 0x73, 0x5b, 0xdd, 0x92, + 0x48, 0x5c, 0x2e, 0x52, 0x7f, 0x71, 0x52, 0x1d, 0xdd, 0x85, 0xb3, 0x31, 0x09, 0x77, 0x3c, 0xdf, + 0xa1, 0xdb, 0x41, 0xc8, 0x0b, 0xec, 0x75, 0x6e, 0x8c, 0xad, 0xb7, 0x8b, 0x62, 0xe8, 0xce, 0xae, + 0x65, 0x62, 0xe1, 0x9c, 0xda, 0xe8, 0x36, 0x4c, 0xb0, 0x9d, 0x50, 0x6b, 0x37, 0x9b, 0xb5, 0xa0, + 0xe9, 0x35, 0xf6, 0xa6, 0xc7, 0x19, 0xc1, 0x4f, 0xc8, 0x7b, 0x61, 0xd9, 0x04, 0x1f, 0xee, 0x57, + 0x20, 0xf9, 0x87, 0xd3, 0xb5, 0xd1, 0x3a, 0x7b, 0x8e, 0x69, 0x87, 0x5e, 0xbc, 0x47, 0xd7, 0x2f, + 0x79, 0x10, 0x4f, 0x4f, 0x74, 0x15, 0x85, 0x75, 0x54, 0xf5, 0x66, 0xa3, 0x17, 0xe2, 0x34, 0x41, + 0xba, 0xb5, 0xa3, 0xd8, 0xf5, 0xfc, 0xe9, 0x49, 0x76, 0x62, 0xa8, 0x9d, 0x51, 0xa7, 0x85, 0x98, + 0xc3, 0xd8, 0x53, 0x0c, 0xfd, 0x71, 0x9b, 0x9e, 0xa0, 0x53, 0x0c, 0x31, 0x79, 0x8a, 0x91, 0x00, + 0x9c, 0xe0, 0x50, 0xa6, 0x26, 0x8e, 0xf7, 0xa6, 0x11, 0x43, 0x55, 0xdb, 0x65, 0x6d, 0xed, 0xf3, + 0x98, 0x96, 0xa3, 0x5b, 0x30, 0x4c, 0xfc, 0xdd, 0xa5, 0x30, 0xd8, 0x99, 0x3e, 0x95, 0xbf, 0x67, + 0x17, 0x39, 0x0a, 0x3f, 0xd0, 0x13, 0x01, 0x4f, 0x14, 0x63, 0x49, 0x02, 0x3d, 0x80, 0xe9, 0x8c, + 0x19, 0xe1, 0x13, 0x70, 0x9a, 0x4d, 0xc0, 0x6b, 0xa2, 0xee, 0xf4, 0x5a, 0x0e, 0xde, 0x61, 0x17, + 0x18, 0xce, 0xa5, 0x8e, 0xbe, 0x00, 0x63, 0x7c, 0x43, 0xf1, 0x77, 0xdc, 0x68, 0xfa, 0x0c, 0xfb, + 0x9a, 0x4b, 0xf9, 0x9b, 0x93, 0x23, 0xce, 0x9f, 0x11, 0x1d, 0x1a, 0xd3, 0x4b, 0x23, 0x6c, 0x52, + 0xb3, 0xd7, 0x61, 0x5c, 0x9d, 0x5b, 0x6c, 0xe9, 0xa0, 0x0a, 0x0c, 0x32, 0x6e, 0x47, 0xe8, 0xb7, + 0xca, 0x74, 0xa6, 0x18, 0x27, 0x84, 0x79, 0x39, 0x9b, 0x29, 0xef, 0x7d, 0x32, 0xbf, 0x17, 0x13, + 0x2e, 0x55, 0x17, 0xb5, 0x99, 0x92, 0x00, 0x9c, 0xe0, 0xd8, 0xff, 0x97, 0x73, 0x8d, 0xc9, 0xe1, + 0xd8, 0xc7, 0x75, 0xf0, 0x2c, 0x94, 0xb6, 0x82, 0x28, 0xa6, 0xd8, 0xac, 0x8d, 0xc1, 0x84, 0x4f, + 0xbc, 0x21, 0xca, 0xb1, 0xc2, 0x40, 0xaf, 0xc2, 0x58, 0x43, 0x6f, 0x40, 0xdc, 0x65, 0x6a, 0x08, + 0x8c, 0xd6, 0xb1, 0x89, 0x8b, 0x5e, 0x81, 0x12, 0xb3, 0xc2, 0x68, 0x04, 0x4d, 0xc1, 0x64, 0xc9, + 0x0b, 0xb9, 0x54, 0x13, 0xe5, 0x87, 0xda, 0x6f, 0xac, 0xb0, 0xd1, 0x65, 0x18, 0xa2, 0x5d, 0x58, + 0xae, 0x89, 0x5b, 0x44, 0xa9, 0x6a, 0x6e, 0xb0, 0x52, 0x2c, 0xa0, 0xf6, 0x5f, 0x2f, 0x68, 0xa3, + 0x4c, 0x25, 0x52, 0x82, 0x6a, 0x30, 0x7c, 0xdf, 0xf1, 0x62, 0xcf, 0xdf, 0x14, 0xec, 0xc2, 0xd3, + 0x5d, 0xaf, 0x14, 0x56, 0xe9, 0x1e, 0xaf, 0xc0, 0x2f, 0x3d, 0xf1, 0x07, 0x4b, 0x32, 0x94, 0x62, + 0xd8, 0xf6, 0x7d, 0x4a, 0xb1, 0xd0, 0x2f, 0x45, 0xcc, 0x2b, 0x70, 0x8a, 0xe2, 0x0f, 0x96, 0x64, + 0xd0, 0xdb, 0x00, 0x72, 0x59, 0x12, 0x57, 0x58, 0x3f, 0x3c, 0xdb, 0x9b, 0xe8, 0x9a, 0xaa, 0x33, + 0x3f, 0x4e, 0xaf, 0xd4, 0xe4, 0x3f, 0xd6, 0xe8, 0xd9, 0x31, 0x63, 0xab, 0x3a, 0x3b, 0x83, 0xbe, + 0x9d, 0x9e, 0x04, 0x4e, 0x18, 0x13, 0x77, 0x2e, 0x16, 0x83, 0xf3, 0xc9, 0xfe, 0x64, 0x8a, 0x35, + 0x6f, 0x87, 0xe8, 0xa7, 0x86, 0x20, 0x82, 0x13, 0x7a, 0xf6, 0x2f, 0x15, 0x61, 0x3a, 0xaf, 0xbb, + 0x74, 0xd1, 0x91, 0x07, 0x5e, 0xbc, 0x40, 0xb9, 0x21, 0xcb, 0x5c, 0x74, 0x8b, 0xa2, 0x1c, 0x2b, + 0x0c, 0x3a, 0xfb, 0x91, 0xb7, 0x29, 0x45, 0xc2, 0xc1, 0x64, 0xf6, 0xeb, 0xac, 0x14, 0x0b, 0x28, + 0xc5, 0x0b, 0x89, 0x13, 0x09, 0xf3, 0x1a, 0x6d, 0x95, 0x60, 0x56, 0x8a, 0x05, 0x54, 0xd7, 0x37, + 0x0d, 0xf4, 0xd0, 0x37, 0x19, 0x43, 0x34, 0x78, 0xbc, 0x43, 0x84, 0xbe, 0x08, 0xb0, 0xe1, 0xf9, + 0x5e, 0xb4, 0xc5, 0xa8, 0x0f, 0x1d, 0x99, 0xba, 0xe2, 0xa5, 0x96, 0x14, 0x15, 0xac, 0x51, 0x44, + 0x2f, 0xc1, 0x88, 0xda, 0x80, 0xcb, 0x55, 0xf6, 0xd6, 0xa8, 0xd9, 0x6e, 0x24, 0xa7, 0x51, 0x15, + 0xeb, 0x78, 0xf6, 0xbb, 0xe9, 0xf5, 0x22, 0x76, 0x80, 0x36, 0xbe, 0x56, 0xbf, 0xe3, 0x5b, 0xe8, + 0x3e, 0xbe, 0xf6, 0xaf, 0x17, 0x61, 0xc2, 0x68, 0xac, 0x1d, 0xf5, 0x71, 0x66, 0x5d, 0xa7, 0xf7, + 0x9c, 0x13, 0x13, 0xb1, 0xff, 0xec, 0xde, 0x5b, 0x45, 0xbf, 0x0b, 0xe9, 0x0e, 0xe0, 0xf5, 0xd1, + 0x17, 0xa1, 0xdc, 0x74, 0x22, 0xa6, 0xbb, 0x22, 0x62, 0xdf, 0xf5, 0x43, 0x2c, 0x91, 0x23, 0x9c, + 0x28, 0xd6, 0xae, 0x1a, 0x4e, 0x3b, 0x21, 0x49, 0x2f, 0x64, 0xca, 0xfb, 0x48, 0xfb, 0x2d, 0xd5, + 0x09, 0xca, 0x20, 0xed, 0x61, 0x0e, 0x43, 0xaf, 0xc0, 0x68, 0x48, 0xd8, 0xaa, 0x58, 0xa0, 0xac, + 0x1c, 0x5b, 0x66, 0x83, 0x09, 0xcf, 0x87, 0x35, 0x18, 0x36, 0x30, 0x13, 0x56, 0x7e, 0xa8, 0x0b, + 0x2b, 0xff, 0x34, 0x0c, 0xb3, 0x1f, 0x6a, 0x05, 0xa8, 0xd9, 0x58, 0xe6, 0xc5, 0x58, 0xc2, 0xd3, + 0x0b, 0xa6, 0xd4, 0xe7, 0x82, 0xf9, 0x24, 0x8c, 0x57, 0x1d, 0xb2, 0x13, 0xf8, 0x8b, 0xbe, 0xdb, + 0x0a, 0x3c, 0x3f, 0x46, 0xd3, 0x30, 0xc0, 0x6e, 0x07, 0xbe, 0xb7, 0x07, 0x28, 0x05, 0x3c, 0x40, + 0x19, 0x73, 0x7b, 0x13, 0xce, 0x54, 0x83, 0xfb, 0xfe, 0x7d, 0x27, 0x74, 0xe7, 0x6a, 0xcb, 0x9a, + 0x9c, 0xbb, 0x2a, 0xe5, 0x2c, 0x6e, 0x0f, 0x95, 0x79, 0xa6, 0x6a, 0x35, 0xf9, 0x5d, 0xbb, 0xe4, + 0x35, 0x49, 0x8e, 0x36, 0xe2, 0x6f, 0x15, 0x8c, 0x96, 0x12, 0x7c, 0xf5, 0x60, 0x64, 0xe5, 0x3e, + 0x18, 0xbd, 0x09, 0xa5, 0x0d, 0x8f, 0x34, 0x5d, 0x4c, 0x36, 0xc4, 0x12, 0x7b, 0x2a, 0xdf, 0xc4, + 0x63, 0x89, 0x62, 0x4a, 0xed, 0x13, 0x97, 0xd2, 0x96, 0x44, 0x65, 0xac, 0xc8, 0xa0, 0x6d, 0x98, + 0x94, 0x62, 0x80, 0x84, 0x8a, 0x05, 0xf7, 0x74, 0x37, 0xd9, 0xc2, 0x24, 0x7e, 0xfa, 0x60, 0xbf, + 0x32, 0x89, 0x53, 0x64, 0x70, 0x07, 0x61, 0x2a, 0x96, 0xed, 0xd0, 0xa3, 0x75, 0x80, 0x0d, 0x3f, + 0x13, 0xcb, 0x98, 0x84, 0xc9, 0x4a, 0xed, 0x1f, 0xb5, 0xe0, 0xb1, 0x8e, 0x91, 0x11, 0x92, 0xf6, + 0x31, 0xcf, 0x42, 0x5a, 0xf2, 0x2d, 0xf4, 0x96, 0x7c, 0xed, 0x9f, 0xb5, 0xe0, 0xf4, 0xe2, 0x4e, + 0x2b, 0xde, 0xab, 0x7a, 0xe6, 0xeb, 0xce, 0xcb, 0x30, 0xb4, 0x43, 0x5c, 0xaf, 0xbd, 0x23, 0x66, + 0xae, 0x22, 0x8f, 0x9f, 0x15, 0x56, 0x7a, 0xb8, 0x5f, 0x19, 0xab, 0xc7, 0x41, 0xe8, 0x6c, 0x12, + 0x5e, 0x80, 0x05, 0x3a, 0x3b, 0xc4, 0xbd, 0xf7, 0xc9, 0x2d, 0x6f, 0xc7, 0x93, 0x26, 0x3b, 0x5d, + 0x75, 0x67, 0xb3, 0x72, 0x40, 0x67, 0xdf, 0x6c, 0x3b, 0x7e, 0xec, 0xc5, 0x7b, 0xe2, 0x61, 0x46, + 0x12, 0xc1, 0x09, 0x3d, 0xfb, 0xeb, 0x16, 0x4c, 0xc8, 0x75, 0x3f, 0xe7, 0xba, 0x21, 0x89, 0x22, + 0x34, 0x03, 0x05, 0xaf, 0x25, 0x7a, 0x09, 0xa2, 0x97, 0x85, 0xe5, 0x1a, 0x2e, 0x78, 0x2d, 0x54, + 0x83, 0x32, 0xb7, 0xfc, 0x49, 0x16, 0x57, 0x5f, 0xf6, 0x43, 0xac, 0x07, 0x6b, 0xb2, 0x26, 0x4e, + 0x88, 0x48, 0x0e, 0x8e, 0x9d, 0x99, 0x45, 0xf3, 0xd5, 0xeb, 0x86, 0x28, 0xc7, 0x0a, 0x03, 0x5d, + 0x81, 0x92, 0x1f, 0xb8, 0xdc, 0x10, 0x8b, 0xdf, 0x7e, 0x6c, 0xc9, 0xae, 0x8a, 0x32, 0xac, 0xa0, + 0xf6, 0x0f, 0x5a, 0x30, 0x2a, 0xbf, 0xac, 0x4f, 0x66, 0x92, 0x6e, 0xad, 0x84, 0x91, 0x4c, 0xb6, + 0x16, 0x65, 0x06, 0x19, 0xc4, 0xe0, 0x01, 0x8b, 0x47, 0xe1, 0x01, 0xed, 0x1f, 0x29, 0xc0, 0xb8, + 0xec, 0x4e, 0xbd, 0xbd, 0x1e, 0x91, 0x18, 0xad, 0x41, 0xd9, 0xe1, 0x43, 0x4e, 0xe4, 0x8a, 0x7d, + 0x32, 0x5b, 0xf8, 0x30, 0xe6, 0x27, 0xb9, 0x96, 0xe7, 0x64, 0x6d, 0x9c, 0x10, 0x42, 0x4d, 0x98, + 0xf2, 0x83, 0x98, 0x1d, 0xd1, 0x0a, 0xde, 0xed, 0x09, 0x24, 0x4d, 0xfd, 0x9c, 0xa0, 0x3e, 0xb5, + 0x9a, 0xa6, 0x82, 0x3b, 0x09, 0xa3, 0x45, 0xa9, 0xf0, 0x28, 0xe6, 0x8b, 0x1b, 0xfa, 0x2c, 0x64, + 0xeb, 0x3b, 0xec, 0x5f, 0xb5, 0xa0, 0x2c, 0xd1, 0x4e, 0xe2, 0xb5, 0x6b, 0x05, 0x86, 0x23, 0x36, + 0x09, 0x72, 0x68, 0xec, 0x6e, 0x1d, 0xe7, 0xf3, 0x95, 0xdc, 0x3c, 0xfc, 0x7f, 0x84, 0x25, 0x0d, + 0xa6, 0xef, 0x56, 0xdd, 0xff, 0x88, 0xe8, 0xbb, 0x55, 0x7f, 0x72, 0x6e, 0x98, 0x3f, 0x60, 0x7d, + 0xd6, 0xc4, 0x5a, 0xca, 0x20, 0xb5, 0x42, 0xb2, 0xe1, 0x3d, 0x48, 0x33, 0x48, 0x35, 0x56, 0x8a, + 0x05, 0x14, 0xbd, 0x0d, 0xa3, 0x0d, 0xa9, 0xe8, 0x4c, 0x8e, 0x81, 0xcb, 0x5d, 0x95, 0xee, 0xea, + 0x7d, 0x86, 0x1b, 0x69, 0x2f, 0x68, 0xf5, 0xb1, 0x41, 0xcd, 0x7c, 0x6e, 0x2f, 0xf6, 0x7a, 0x6e, + 0x4f, 0xe8, 0xe6, 0x3f, 0x3e, 0xff, 0x98, 0x05, 0x43, 0x5c, 0x5d, 0xd6, 0x9f, 0x7e, 0x51, 0x7b, + 0xae, 0x4a, 0xc6, 0xee, 0x2e, 0x2d, 0x14, 0xcf, 0x4f, 0x68, 0x05, 0xca, 0xec, 0x07, 0x53, 0x1b, + 0x14, 0xf3, 0xad, 0xd3, 0x79, 0xab, 0x7a, 0x07, 0xef, 0xca, 0x6a, 0x38, 0xa1, 0x60, 0xff, 0x50, + 0x91, 0x1e, 0x55, 0x09, 0xaa, 0x71, 0x83, 0x5b, 0x8f, 0xee, 0x06, 0x2f, 0x3c, 0xaa, 0x1b, 0x7c, + 0x13, 0x26, 0x1a, 0xda, 0xe3, 0x56, 0x32, 0x93, 0x57, 0xba, 0x2e, 0x12, 0xed, 0x1d, 0x8c, 0xab, + 0x8c, 0x16, 0x4c, 0x22, 0x38, 0x4d, 0x15, 0x7d, 0x3b, 0x8c, 0xf2, 0x79, 0x16, 0xad, 0x70, 0x8b, + 0x85, 0x4f, 0xe4, 0xaf, 0x17, 0xbd, 0x09, 0xb6, 0x12, 0xeb, 0x5a, 0x75, 0x6c, 0x10, 0xb3, 0x7f, + 0xa9, 0x04, 0x83, 0x8b, 0xbb, 0xc4, 0x8f, 0x4f, 0xe0, 0x40, 0x6a, 0xc0, 0xb8, 0xe7, 0xef, 0x06, + 0xcd, 0x5d, 0xe2, 0x72, 0xf8, 0x51, 0x2e, 0xd7, 0xb3, 0x82, 0xf4, 0xf8, 0xb2, 0x41, 0x02, 0xa7, + 0x48, 0x3e, 0x0a, 0x09, 0xf3, 0x3a, 0x0c, 0xf1, 0xb9, 0x17, 0xe2, 0x65, 0xa6, 0x32, 0x98, 0x0d, + 0xa2, 0xd8, 0x05, 0x89, 0xf4, 0xcb, 0xb5, 0xcf, 0xa2, 0x3a, 0x7a, 0x17, 0xc6, 0x37, 0xbc, 0x30, + 0x8a, 0xa9, 0x68, 0x18, 0xc5, 0xce, 0x4e, 0xeb, 0x21, 0x24, 0x4a, 0x35, 0x0e, 0x4b, 0x06, 0x25, + 0x9c, 0xa2, 0x8c, 0x36, 0x61, 0x8c, 0x0a, 0x39, 0x49, 0x53, 0xc3, 0x47, 0x6e, 0x4a, 0xa9, 0x8c, + 0x6e, 0xe9, 0x84, 0xb0, 0x49, 0x97, 0x1e, 0x26, 0x0d, 0x26, 0x14, 0x95, 0x18, 0x47, 0xa1, 0x0e, + 0x13, 0x2e, 0x0d, 0x71, 0x18, 0x3d, 0x93, 0x98, 0xd9, 0x4a, 0xd9, 0x3c, 0x93, 0x34, 0xe3, 0x94, + 0x77, 0xa0, 0x4c, 0xe8, 0x10, 0x52, 0xc2, 0x42, 0x31, 0x7e, 0xb5, 0xbf, 0xbe, 0xae, 0x78, 0x8d, + 0x30, 0x30, 0x65, 0xf9, 0x45, 0x49, 0x09, 0x27, 0x44, 0xd1, 0x02, 0x0c, 0x45, 0x24, 0xf4, 0x48, + 0x24, 0x54, 0xe4, 0x5d, 0xa6, 0x91, 0xa1, 0x71, 0x8b, 0x4f, 0xfe, 0x1b, 0x8b, 0xaa, 0x74, 0x79, + 0x39, 0x4c, 0x1a, 0x62, 0x5a, 0x71, 0x6d, 0x79, 0xcd, 0xb1, 0x52, 0x2c, 0xa0, 0xe8, 0x0d, 0x18, + 0x0e, 0x49, 0x93, 0x29, 0x8b, 0xc6, 0xfa, 0x5f, 0xe4, 0x5c, 0xf7, 0xc4, 0xeb, 0x61, 0x49, 0x00, + 0xdd, 0x04, 0x14, 0x12, 0xca, 0x43, 0x78, 0xfe, 0xa6, 0x32, 0xe6, 0x10, 0xba, 0xee, 0xc7, 0x45, + 0xfb, 0xa7, 0x70, 0x82, 0x21, 0x8d, 0x6f, 0x71, 0x46, 0x35, 0x74, 0x1d, 0xa6, 0x54, 0xe9, 0xb2, + 0x1f, 0xc5, 0x8e, 0xdf, 0x20, 0x4c, 0xcd, 0x5d, 0x4e, 0xb8, 0x22, 0x9c, 0x46, 0xc0, 0x9d, 0x75, + 0xec, 0x9f, 0xa6, 0xec, 0x0c, 0x1d, 0xad, 0x13, 0xe0, 0x05, 0x5e, 0x37, 0x79, 0x81, 0x73, 0xb9, + 0x33, 0x97, 0xc3, 0x07, 0x1c, 0x58, 0x30, 0xa2, 0xcd, 0x6c, 0xb2, 0x66, 0xad, 0x2e, 0x6b, 0xb6, + 0x0d, 0x93, 0x74, 0xa5, 0xdf, 0x5e, 0x8f, 0x48, 0xb8, 0x4b, 0x5c, 0xb6, 0x30, 0x0b, 0x0f, 0xb7, + 0x30, 0xd5, 0x2b, 0xf3, 0xad, 0x14, 0x41, 0xdc, 0xd1, 0x04, 0x7a, 0x59, 0x6a, 0x4e, 0x8a, 0x86, + 0x91, 0x16, 0xd7, 0x8a, 0x1c, 0xee, 0x57, 0x26, 0xb5, 0x0f, 0xd1, 0x35, 0x25, 0xf6, 0x3b, 0xf2, + 0x1b, 0xd5, 0x6b, 0x7e, 0x43, 0x2d, 0x96, 0xd4, 0x6b, 0xbe, 0x5a, 0x0e, 0x38, 0xc1, 0xa1, 0x7b, + 0x94, 0x8a, 0x20, 0xe9, 0xd7, 0x7c, 0x2a, 0xa0, 0x60, 0x06, 0xb1, 0x5f, 0x00, 0x58, 0x7c, 0x40, + 0x1a, 0x7c, 0xa9, 0xeb, 0x0f, 0x90, 0x56, 0xfe, 0x03, 0xa4, 0xfd, 0x1f, 0x2d, 0x18, 0x5f, 0x5a, + 0x30, 0xc4, 0xc4, 0x59, 0x00, 0x2e, 0x1b, 0xdd, 0xbb, 0xb7, 0x2a, 0x75, 0xeb, 0x5c, 0x3d, 0xaa, + 0x4a, 0xb1, 0x86, 0x81, 0xce, 0x41, 0xb1, 0xd9, 0xf6, 0x85, 0xc8, 0x32, 0x7c, 0xb0, 0x5f, 0x29, + 0xde, 0x6a, 0xfb, 0x98, 0x96, 0x69, 0x16, 0x82, 0xc5, 0xbe, 0x2d, 0x04, 0x7b, 0x7a, 0xea, 0xa1, + 0x0a, 0x0c, 0xde, 0xbf, 0xef, 0xb9, 0xdc, 0x1f, 0x42, 0xe8, 0xfd, 0xef, 0xdd, 0x5b, 0xae, 0x46, + 0x98, 0x97, 0xdb, 0x5f, 0x29, 0xc2, 0xcc, 0x52, 0x93, 0x3c, 0xf8, 0x80, 0x3e, 0x21, 0xfd, 0xda, + 0x37, 0x1e, 0x8d, 0x5f, 0x3c, 0xaa, 0x0d, 0x6b, 0xef, 0xf1, 0xd8, 0x80, 0x61, 0xfe, 0x98, 0x2d, + 0x3d, 0x44, 0x5e, 0xcd, 0x6a, 0x3d, 0x7f, 0x40, 0x66, 0xf9, 0xa3, 0xb8, 0x30, 0x70, 0x57, 0x37, + 0xad, 0x28, 0xc5, 0x92, 0xf8, 0xcc, 0x67, 0x60, 0x54, 0xc7, 0x3c, 0x92, 0x35, 0xf9, 0x5f, 0x2a, + 0xc2, 0x24, 0xed, 0xc1, 0x23, 0x9d, 0x88, 0x3b, 0x9d, 0x13, 0x71, 0xdc, 0x16, 0xc5, 0xbd, 0x67, + 0xe3, 0xed, 0xf4, 0x6c, 0x3c, 0x9f, 0x37, 0x1b, 0x27, 0x3d, 0x07, 0xdf, 0x63, 0xc1, 0xa9, 0xa5, + 0x66, 0xd0, 0xd8, 0x4e, 0x59, 0xfd, 0xbe, 0x04, 0x23, 0xf4, 0x1c, 0x8f, 0x0c, 0x87, 0x34, 0xc3, + 0x45, 0x51, 0x80, 0xb0, 0x8e, 0xa7, 0x55, 0xbb, 0x73, 0x67, 0xb9, 0x9a, 0xe5, 0xd9, 0x28, 0x40, + 0x58, 0xc7, 0xb3, 0xbf, 0x66, 0xc1, 0x85, 0xeb, 0x0b, 0x8b, 0xc9, 0x52, 0xec, 0x70, 0xae, 0xa4, + 0x52, 0xa0, 0xab, 0x75, 0x25, 0x91, 0x02, 0xab, 0xac, 0x17, 0x02, 0xfa, 0x51, 0x71, 0x1c, 0xfe, + 0x29, 0x0b, 0x4e, 0x5d, 0xf7, 0x62, 0x7a, 0x2d, 0xa7, 0xdd, 0xfc, 0xe8, 0xbd, 0x1c, 0x79, 0x71, + 0x10, 0xee, 0xa5, 0xdd, 0xfc, 0xb0, 0x82, 0x60, 0x0d, 0x8b, 0xb7, 0xbc, 0xeb, 0x31, 0x33, 0xaa, + 0x82, 0xa9, 0x8a, 0xc2, 0xa2, 0x1c, 0x2b, 0x0c, 0xfa, 0x61, 0xae, 0x17, 0x32, 0x51, 0x62, 0x4f, + 0x9c, 0xb0, 0xea, 0xc3, 0xaa, 0x12, 0x80, 0x13, 0x1c, 0xfb, 0x8f, 0x2c, 0xa8, 0x5c, 0x6f, 0xb6, + 0xa3, 0x98, 0x84, 0x1b, 0x51, 0xce, 0xe9, 0xf8, 0x02, 0x94, 0x89, 0x14, 0xdc, 0x45, 0xaf, 0x15, + 0xab, 0xa9, 0x24, 0x7a, 0xee, 0x6d, 0xa8, 0xf0, 0xfa, 0xf0, 0x21, 0x38, 0x9a, 0x11, 0xf8, 0x12, + 0x20, 0xa2, 0xb7, 0xa5, 0xbb, 0x5f, 0x32, 0x3f, 0xae, 0xc5, 0x0e, 0x28, 0xce, 0xa8, 0x61, 0xff, + 0xa8, 0x05, 0x67, 0xd4, 0x07, 0x7f, 0xe4, 0x3e, 0xd3, 0xfe, 0xf9, 0x02, 0x8c, 0xdd, 0x58, 0x5b, + 0xab, 0x5d, 0x27, 0xb1, 0xb8, 0xb6, 0x7b, 0xeb, 0xd6, 0xb1, 0xa6, 0x22, 0xec, 0x26, 0x05, 0xb6, + 0x63, 0xaf, 0x39, 0xcb, 0xbd, 0xf8, 0x67, 0x97, 0xfd, 0xf8, 0x76, 0x58, 0x8f, 0x43, 0xcf, 0xdf, + 0xcc, 0x54, 0x2a, 0x4a, 0xe6, 0xa2, 0x98, 0xc7, 0x5c, 0xa0, 0x17, 0x60, 0x88, 0x85, 0x11, 0x90, + 0x93, 0xf0, 0xb8, 0x12, 0xa2, 0x58, 0xe9, 0xe1, 0x7e, 0xa5, 0x7c, 0x07, 0x2f, 0xf3, 0x3f, 0x58, + 0xa0, 0xa2, 0x3b, 0x30, 0xb2, 0x15, 0xc7, 0xad, 0x1b, 0xc4, 0x71, 0x49, 0x28, 0x8f, 0xc3, 0x8b, + 0x59, 0xc7, 0x21, 0x1d, 0x04, 0x8e, 0x96, 0x9c, 0x20, 0x49, 0x59, 0x84, 0x75, 0x3a, 0x76, 0x1d, + 0x20, 0x81, 0x1d, 0x93, 0x42, 0xc5, 0xfe, 0x7d, 0x0b, 0x86, 0xb9, 0x47, 0x67, 0x88, 0x5e, 0x83, + 0x01, 0xf2, 0x80, 0x34, 0x04, 0xab, 0x9c, 0xd9, 0xe1, 0x84, 0xd3, 0xe2, 0xcf, 0x03, 0xf4, 0x3f, + 0x66, 0xb5, 0xd0, 0x0d, 0x18, 0xa6, 0xbd, 0xbd, 0xae, 0xdc, 0x5b, 0x9f, 0xc8, 0xfb, 0x62, 0x35, + 0xed, 0x9c, 0x39, 0x13, 0x45, 0x58, 0x56, 0x67, 0xaa, 0xee, 0x46, 0xab, 0x4e, 0x4f, 0xec, 0xb8, + 0x1b, 0x63, 0xb1, 0xb6, 0x50, 0xe3, 0x48, 0x82, 0x1a, 0x57, 0x75, 0xcb, 0x42, 0x9c, 0x10, 0xb1, + 0xd7, 0xa0, 0x4c, 0x27, 0x75, 0xae, 0xe9, 0x39, 0xdd, 0xb5, 0xec, 0xcf, 0x40, 0x59, 0x6a, 0xbc, + 0x23, 0xe1, 0xc9, 0xc5, 0xa8, 0x4a, 0x85, 0x78, 0x84, 0x13, 0xb8, 0xbd, 0x01, 0xa7, 0x99, 0xa9, + 0x83, 0x13, 0x6f, 0x19, 0x7b, 0xac, 0xf7, 0x62, 0x7e, 0x56, 0x48, 0x9e, 0x7c, 0x66, 0xa6, 0x35, + 0x67, 0x89, 0x51, 0x49, 0x31, 0x91, 0x42, 0xed, 0x3f, 0x1c, 0x80, 0xc7, 0x97, 0xeb, 0xf9, 0xce, + 0xbe, 0xaf, 0xc0, 0x28, 0xe7, 0x4b, 0xe9, 0xd2, 0x76, 0x9a, 0xa2, 0x5d, 0xf5, 0x10, 0xb8, 0xa6, + 0xc1, 0xb0, 0x81, 0x89, 0x2e, 0x40, 0xd1, 0x7b, 0xcf, 0x4f, 0xdb, 0x1d, 0x2f, 0xbf, 0xb9, 0x8a, + 0x69, 0x39, 0x05, 0x53, 0x16, 0x97, 0xdf, 0x1d, 0x0a, 0xac, 0xd8, 0xdc, 0xd7, 0x61, 0xdc, 0x8b, + 0x1a, 0x91, 0xb7, 0xec, 0xd3, 0x73, 0x46, 0x3b, 0xa9, 0x94, 0x56, 0x84, 0x76, 0x5a, 0x41, 0x71, + 0x0a, 0x5b, 0xbb, 0xc8, 0x06, 0xfb, 0x66, 0x93, 0x7b, 0xba, 0x36, 0x51, 0x09, 0xa0, 0xc5, 0xbe, + 0x2e, 0x62, 0x56, 0x7c, 0x42, 0x02, 0xe0, 0x1f, 0x1c, 0x61, 0x09, 0xa3, 0x22, 0x67, 0x63, 0xcb, + 0x69, 0xcd, 0xb5, 0xe3, 0xad, 0xaa, 0x17, 0x35, 0x82, 0x5d, 0x12, 0xee, 0x31, 0x6d, 0x41, 0x29, + 0x11, 0x39, 0x15, 0x60, 0xe1, 0xc6, 0x5c, 0x8d, 0x62, 0xe2, 0xce, 0x3a, 0x26, 0x1b, 0x0c, 0xc7, + 0xc1, 0x06, 0xcf, 0xc1, 0x84, 0x6c, 0xa6, 0x4e, 0x22, 0x76, 0x29, 0x8e, 0xb0, 0x8e, 0x29, 0xdb, + 0x62, 0x51, 0xac, 0xba, 0x95, 0xc6, 0x47, 0x2f, 0xc3, 0x98, 0xe7, 0x7b, 0xb1, 0xe7, 0xc4, 0x41, + 0xc8, 0x58, 0x0a, 0xae, 0x18, 0x60, 0xa6, 0x7b, 0xcb, 0x3a, 0x00, 0x9b, 0x78, 0xf6, 0x7f, 0x1d, + 0x80, 0x29, 0x36, 0x6d, 0xdf, 0x5c, 0x61, 0x1f, 0x99, 0x15, 0x76, 0xa7, 0x73, 0x85, 0x1d, 0x07, + 0x7f, 0xff, 0x61, 0x2e, 0xb3, 0x77, 0xa1, 0xac, 0x8c, 0x9f, 0xa5, 0xf7, 0x83, 0x95, 0xe3, 0xfd, + 0xd0, 0x9b, 0xfb, 0x90, 0xef, 0xd6, 0xc5, 0xcc, 0x77, 0xeb, 0xbf, 0x63, 0x41, 0x62, 0x03, 0x8a, + 0x6e, 0x40, 0xb9, 0x15, 0x30, 0x3b, 0x8b, 0x50, 0x1a, 0x2f, 0x3d, 0x9e, 0x79, 0x51, 0xf1, 0x4b, + 0x91, 0x8f, 0x5f, 0x4d, 0xd6, 0xc0, 0x49, 0x65, 0x34, 0x0f, 0xc3, 0xad, 0x90, 0xd4, 0x63, 0xe6, + 0xf3, 0xdb, 0x93, 0x0e, 0x5f, 0x23, 0x1c, 0x1f, 0xcb, 0x8a, 0xf6, 0x2f, 0x58, 0x00, 0xfc, 0x69, + 0xd8, 0xf1, 0x37, 0xc9, 0x09, 0xa8, 0xbb, 0xab, 0x30, 0x10, 0xb5, 0x48, 0xa3, 0x9b, 0x05, 0x4c, + 0xd2, 0x9f, 0x7a, 0x8b, 0x34, 0x92, 0x01, 0xa7, 0xff, 0x30, 0xab, 0x6d, 0x7f, 0x2f, 0xc0, 0x78, + 0x82, 0xb6, 0x1c, 0x93, 0x1d, 0xf4, 0x9c, 0xe1, 0x03, 0x78, 0x2e, 0xe5, 0x03, 0x58, 0x66, 0xd8, + 0x9a, 0x66, 0xf5, 0x5d, 0x28, 0xee, 0x38, 0x0f, 0x84, 0xea, 0xec, 0x99, 0xee, 0xdd, 0xa0, 0xf4, + 0x67, 0x57, 0x9c, 0x07, 0x5c, 0x48, 0x7c, 0x46, 0x2e, 0x90, 0x15, 0xe7, 0xc1, 0x21, 0xb7, 0x73, + 0x61, 0x87, 0xd4, 0x2d, 0x2f, 0x8a, 0xbf, 0xf4, 0x5f, 0x92, 0xff, 0x6c, 0xd9, 0xd1, 0x46, 0x58, + 0x5b, 0x9e, 0x2f, 0x1e, 0x4a, 0xfb, 0x6a, 0xcb, 0xf3, 0xd3, 0x6d, 0x79, 0x7e, 0x1f, 0x6d, 0x79, + 0x3e, 0x7a, 0x1f, 0x86, 0x85, 0x51, 0x82, 0xf0, 0xb9, 0xbf, 0xda, 0x47, 0x7b, 0xc2, 0xa6, 0x81, + 0xb7, 0x79, 0x55, 0x0a, 0xc1, 0xa2, 0xb4, 0x67, 0xbb, 0xb2, 0x41, 0xf4, 0x37, 0x2d, 0x18, 0x17, + 0xbf, 0x31, 0x79, 0xaf, 0x4d, 0xa2, 0x58, 0xf0, 0x9e, 0x9f, 0xee, 0xbf, 0x0f, 0xa2, 0x22, 0xef, + 0xca, 0xa7, 0xe5, 0x31, 0x6b, 0x02, 0x7b, 0xf6, 0x28, 0xd5, 0x0b, 0xf4, 0x8f, 0x2c, 0x38, 0xbd, + 0xe3, 0x3c, 0xe0, 0x2d, 0xf2, 0x32, 0xec, 0xc4, 0x5e, 0x20, 0x8c, 0xf5, 0x5f, 0xeb, 0x6f, 0xfa, + 0x3b, 0xaa, 0xf3, 0x4e, 0x4a, 0xbb, 0xde, 0xd3, 0x59, 0x28, 0x3d, 0xbb, 0x9a, 0xd9, 0xaf, 0x99, + 0x0d, 0x28, 0xc9, 0xf5, 0x96, 0xa1, 0x6a, 0xa8, 0xea, 0x8c, 0xf5, 0x91, 0x6d, 0x42, 0x74, 0x47, + 0x3c, 0xda, 0x8e, 0x58, 0x6b, 0x8f, 0xb4, 0x9d, 0x77, 0x61, 0x54, 0x5f, 0x63, 0x8f, 0xb4, 0xad, + 0xf7, 0xe0, 0x54, 0xc6, 0x5a, 0x7a, 0xa4, 0x4d, 0xde, 0x87, 0x73, 0xb9, 0xeb, 0xe3, 0x51, 0x36, + 0x6c, 0xff, 0xbc, 0xa5, 0x9f, 0x83, 0x27, 0xf0, 0xe6, 0xb0, 0x60, 0xbe, 0x39, 0x5c, 0xec, 0xbe, + 0x73, 0x72, 0x1e, 0x1e, 0xde, 0xd6, 0x3b, 0x4d, 0x4f, 0x75, 0xf4, 0x06, 0x0c, 0x35, 0x69, 0x89, + 0xb4, 0x86, 0xb1, 0x7b, 0xef, 0xc8, 0x84, 0x97, 0x62, 0xe5, 0x11, 0x16, 0x14, 0xec, 0x5f, 0xb6, + 0x60, 0xe0, 0x04, 0x46, 0x02, 0x9b, 0x23, 0xf1, 0x5c, 0x2e, 0x69, 0x11, 0x0e, 0x70, 0x16, 0x3b, + 0xf7, 0x17, 0x1f, 0xc4, 0xc4, 0x8f, 0x98, 0xa8, 0x98, 0x39, 0x30, 0xdf, 0x01, 0xa7, 0x6e, 0x05, + 0x8e, 0x3b, 0xef, 0x34, 0x1d, 0xbf, 0x41, 0xc2, 0x65, 0x7f, 0xb3, 0xa7, 0x59, 0x96, 0x6e, 0x44, + 0x55, 0xe8, 0x65, 0x44, 0x65, 0x6f, 0x01, 0xd2, 0x1b, 0x10, 0x86, 0xab, 0x18, 0x86, 0x3d, 0xde, + 0x94, 0x18, 0xfe, 0xa7, 0xb2, 0xb9, 0xbb, 0x8e, 0x9e, 0x69, 0x26, 0x99, 0xbc, 0x00, 0x4b, 0x42, + 0xf6, 0x2b, 0x90, 0xe9, 0xac, 0xd6, 0x5b, 0x6d, 0x60, 0x7f, 0x1e, 0xa6, 0x58, 0xcd, 0x23, 0x8a, + 0xb4, 0x76, 0x4a, 0x2b, 0x99, 0x11, 0x99, 0xc6, 0xfe, 0xb2, 0x05, 0x13, 0xab, 0xa9, 0x80, 0x1d, + 0x97, 0xd9, 0x03, 0x68, 0x86, 0x32, 0xbc, 0xce, 0x4a, 0xb1, 0x80, 0x1e, 0xbb, 0x0e, 0xea, 0xcf, + 0x2d, 0x48, 0xfc, 0x47, 0x4f, 0x80, 0xf1, 0x5a, 0x30, 0x18, 0xaf, 0x4c, 0xdd, 0x88, 0xea, 0x4e, + 0x1e, 0xdf, 0x85, 0x6e, 0xaa, 0x60, 0x09, 0x5d, 0xd4, 0x22, 0x09, 0x19, 0xee, 0x5a, 0x3f, 0x6e, + 0x46, 0x54, 0x90, 0xe1, 0x13, 0x98, 0xed, 0x94, 0xc2, 0xfd, 0x88, 0xd8, 0x4e, 0xa9, 0xfe, 0xe4, + 0xec, 0xd0, 0x9a, 0xd6, 0x65, 0x76, 0x72, 0x7d, 0x2b, 0xb3, 0x85, 0x77, 0x9a, 0xde, 0xfb, 0x44, + 0x45, 0x7c, 0xa9, 0x08, 0xdb, 0x76, 0x51, 0x7a, 0xb8, 0x5f, 0x19, 0x53, 0xff, 0x78, 0x84, 0xb9, + 0xa4, 0x8a, 0x7d, 0x03, 0x26, 0x52, 0x03, 0x86, 0x5e, 0x82, 0xc1, 0xd6, 0x96, 0x13, 0x91, 0x94, + 0xbd, 0xe8, 0x60, 0x8d, 0x16, 0x1e, 0xee, 0x57, 0xc6, 0x55, 0x05, 0x56, 0x82, 0x39, 0xb6, 0xfd, + 0x3f, 0x2d, 0x18, 0x58, 0x0d, 0xdc, 0x93, 0x58, 0x4c, 0xaf, 0x1b, 0x8b, 0xe9, 0x7c, 0x5e, 0x7c, + 0xce, 0xdc, 0x75, 0xb4, 0x94, 0x5a, 0x47, 0x17, 0x73, 0x29, 0x74, 0x5f, 0x42, 0x3b, 0x30, 0xc2, + 0xa2, 0x7e, 0x0a, 0xfb, 0xd5, 0x17, 0x0c, 0x19, 0xa0, 0x92, 0x92, 0x01, 0x26, 0x34, 0x54, 0x4d, + 0x12, 0x78, 0x1a, 0x86, 0x85, 0x0d, 0x65, 0xda, 0xea, 0x5f, 0xe0, 0x62, 0x09, 0xb7, 0x7f, 0xac, + 0x08, 0x46, 0x94, 0x51, 0xf4, 0xab, 0x16, 0xcc, 0x86, 0xdc, 0x8d, 0xd2, 0xad, 0xb6, 0x43, 0xcf, + 0xdf, 0xac, 0x37, 0xb6, 0x88, 0xdb, 0x6e, 0x7a, 0xfe, 0xe6, 0xf2, 0xa6, 0x1f, 0xa8, 0xe2, 0xc5, + 0x07, 0xa4, 0xd1, 0x66, 0x0f, 0x21, 0x3d, 0x42, 0x9a, 0x2a, 0x1b, 0xa5, 0x6b, 0x07, 0xfb, 0x95, + 0x59, 0x7c, 0x24, 0xda, 0xf8, 0x88, 0x7d, 0x41, 0x5f, 0xb3, 0xe0, 0x2a, 0x0f, 0xbe, 0xd9, 0x7f, + 0xff, 0xbb, 0x48, 0x4c, 0x35, 0x49, 0x2a, 0x21, 0xb2, 0x46, 0xc2, 0x9d, 0xf9, 0x97, 0xc5, 0x80, + 0x5e, 0xad, 0x1d, 0xad, 0x2d, 0x7c, 0xd4, 0xce, 0xd9, 0xff, 0xaa, 0x08, 0x63, 0xc2, 0x83, 0x5f, + 0x84, 0x86, 0x79, 0xc9, 0x58, 0x12, 0x4f, 0xa4, 0x96, 0xc4, 0x94, 0x81, 0x7c, 0x3c, 0x51, 0x61, + 0x22, 0x98, 0x6a, 0x3a, 0x51, 0x7c, 0x83, 0x38, 0x61, 0xbc, 0x4e, 0x1c, 0x6e, 0xbb, 0x53, 0x3c, + 0xb2, 0x9d, 0x91, 0x52, 0xd1, 0xdc, 0x4a, 0x13, 0xc3, 0x9d, 0xf4, 0xd1, 0x2e, 0x20, 0x66, 0x80, + 0x14, 0x3a, 0x7e, 0xc4, 0xbf, 0xc5, 0x13, 0x6f, 0x06, 0x47, 0x6b, 0x75, 0x46, 0xb4, 0x8a, 0x6e, + 0x75, 0x50, 0xc3, 0x19, 0x2d, 0x68, 0x86, 0x65, 0x83, 0xfd, 0x1a, 0x96, 0x0d, 0xf5, 0x70, 0xad, + 0xf1, 0x61, 0xb2, 0x23, 0x08, 0xc3, 0x5b, 0x50, 0x56, 0x06, 0x80, 0xe2, 0xd0, 0xe9, 0x1e, 0xcb, + 0x24, 0x4d, 0x81, 0xab, 0x51, 0x12, 0xe3, 0xd3, 0x84, 0x9c, 0xfd, 0x8f, 0x0b, 0x46, 0x83, 0x7c, + 0x12, 0x57, 0xa1, 0xe4, 0x44, 0x91, 0xb7, 0xe9, 0x13, 0x57, 0xec, 0xd8, 0x8f, 0xe7, 0xed, 0x58, + 0xa3, 0x19, 0x66, 0x84, 0x39, 0x27, 0x6a, 0x62, 0x45, 0x03, 0xdd, 0xe0, 0x16, 0x52, 0xbb, 0x92, + 0xe7, 0xef, 0x8f, 0x1a, 0x48, 0x1b, 0xaa, 0x5d, 0x82, 0x45, 0x7d, 0xf4, 0x05, 0x6e, 0xc2, 0x76, + 0xd3, 0x0f, 0xee, 0xfb, 0xd7, 0x83, 0x40, 0xba, 0xdd, 0xf5, 0x47, 0x70, 0x4a, 0x1a, 0xae, 0xa9, + 0xea, 0xd8, 0xa4, 0xd6, 0x5f, 0xa0, 0xa2, 0xef, 0x84, 0x53, 0x94, 0xb4, 0xe9, 0x3c, 0x13, 0x21, + 0x02, 0x13, 0x22, 0x3c, 0x84, 0x2c, 0x13, 0x63, 0x97, 0xc9, 0xce, 0x9b, 0xb5, 0x13, 0xa5, 0xdf, + 0x4d, 0x93, 0x04, 0x4e, 0xd3, 0xb4, 0x7f, 0xd2, 0x02, 0x66, 0xf6, 0x7f, 0x02, 0x2c, 0xc3, 0x67, + 0x4d, 0x96, 0x61, 0x3a, 0x6f, 0x90, 0x73, 0xb8, 0x85, 0x17, 0xf9, 0xca, 0xaa, 0x85, 0xc1, 0x83, + 0x3d, 0x61, 0x3e, 0xd0, 0x9b, 0x93, 0xb5, 0xff, 0x8f, 0xc5, 0x0f, 0x31, 0xe5, 0x89, 0x8f, 0xbe, + 0x0b, 0x4a, 0x0d, 0xa7, 0xe5, 0x34, 0x78, 0x48, 0xec, 0x5c, 0xad, 0x8e, 0x51, 0x69, 0x76, 0x41, + 0xd4, 0xe0, 0x5a, 0x0a, 0x19, 0x66, 0xa4, 0x24, 0x8b, 0x7b, 0x6a, 0x26, 0x54, 0x93, 0x33, 0xdb, + 0x30, 0x66, 0x10, 0x7b, 0xa4, 0x22, 0xed, 0x77, 0xf1, 0x2b, 0x56, 0x85, 0xc5, 0xd9, 0x81, 0x29, + 0x5f, 0xfb, 0x4f, 0x2f, 0x14, 0x29, 0xa6, 0x7c, 0xbc, 0xd7, 0x25, 0xca, 0x6e, 0x1f, 0xcd, 0xad, + 0x21, 0x45, 0x06, 0x77, 0x52, 0xb6, 0x7f, 0xdc, 0x82, 0xc7, 0x74, 0x44, 0x2d, 0x48, 0x42, 0x2f, + 0x3d, 0x71, 0x15, 0x4a, 0x41, 0x8b, 0x84, 0x4e, 0x1c, 0x84, 0xe2, 0xd6, 0xb8, 0x22, 0x07, 0xfd, + 0xb6, 0x28, 0x3f, 0x14, 0x01, 0x25, 0x25, 0x75, 0x59, 0x8e, 0x55, 0x4d, 0x2a, 0xc7, 0xb0, 0xc1, + 0x88, 0x44, 0x00, 0x0b, 0x76, 0x06, 0xb0, 0x27, 0xd3, 0x08, 0x0b, 0x88, 0xfd, 0x87, 0x16, 0x5f, + 0x58, 0x7a, 0xd7, 0xd1, 0x7b, 0x30, 0xb9, 0xe3, 0xc4, 0x8d, 0xad, 0xc5, 0x07, 0xad, 0x90, 0xab, + 0xc7, 0xe5, 0x38, 0x3d, 0xd3, 0x6b, 0x9c, 0xb4, 0x8f, 0x4c, 0xac, 0xf2, 0x56, 0x52, 0xc4, 0x70, + 0x07, 0x79, 0xb4, 0x0e, 0x23, 0xac, 0x8c, 0x99, 0x7f, 0x47, 0xdd, 0x58, 0x83, 0xbc, 0xd6, 0xd4, + 0xab, 0xf3, 0x4a, 0x42, 0x07, 0xeb, 0x44, 0xed, 0x2f, 0x15, 0xf9, 0x6e, 0x67, 0xdc, 0xf6, 0xd3, + 0x30, 0xdc, 0x0a, 0xdc, 0x85, 0xe5, 0x2a, 0x16, 0xb3, 0xa0, 0xae, 0x91, 0x1a, 0x2f, 0xc6, 0x12, + 0x8e, 0x5e, 0x05, 0x20, 0x0f, 0x62, 0x12, 0xfa, 0x4e, 0x53, 0x59, 0xc9, 0x28, 0xbb, 0xd0, 0x6a, + 0xb0, 0x1a, 0xc4, 0x77, 0x22, 0xf2, 0x1d, 0x8b, 0x0a, 0x05, 0x6b, 0xe8, 0xe8, 0x1a, 0x40, 0x2b, + 0x0c, 0x76, 0x3d, 0x97, 0xf9, 0x13, 0x16, 0x4d, 0x1b, 0x92, 0x9a, 0x82, 0x60, 0x0d, 0x0b, 0xbd, + 0x0a, 0x63, 0x6d, 0x3f, 0xe2, 0x1c, 0x8a, 0xb3, 0x2e, 0xc2, 0x31, 0x96, 0x12, 0xeb, 0x86, 0x3b, + 0x3a, 0x10, 0x9b, 0xb8, 0x68, 0x0e, 0x86, 0x62, 0x87, 0xd9, 0x44, 0x0c, 0xe6, 0x1b, 0x73, 0xae, + 0x51, 0x0c, 0x3d, 0x20, 0x33, 0xad, 0x80, 0x45, 0x45, 0xf4, 0x96, 0x74, 0xce, 0xe0, 0x67, 0xbd, + 0xb0, 0xa2, 0xee, 0xef, 0x5e, 0xd0, 0x5c, 0x33, 0x84, 0x75, 0xb6, 0x41, 0xcb, 0xfe, 0x5a, 0x19, + 0x20, 0x61, 0xc7, 0xd1, 0xfb, 0x1d, 0xe7, 0xd1, 0xb3, 0xdd, 0x19, 0xf8, 0xe3, 0x3b, 0x8c, 0xd0, + 0xf7, 0x59, 0x30, 0xe2, 0x34, 0x9b, 0x41, 0xc3, 0x89, 0xd9, 0x28, 0x17, 0xba, 0x9f, 0x87, 0xa2, + 0xfd, 0xb9, 0xa4, 0x06, 0xef, 0xc2, 0x0b, 0x72, 0xe1, 0x69, 0x90, 0x9e, 0xbd, 0xd0, 0x1b, 0x46, + 0x9f, 0x92, 0x52, 0x1a, 0x5f, 0x1e, 0x33, 0x69, 0x29, 0xad, 0xcc, 0x8e, 0x7e, 0x4d, 0x40, 0x43, + 0x77, 0x8c, 0x48, 0x7b, 0x03, 0xf9, 0x41, 0x27, 0x0c, 0xae, 0xb4, 0x57, 0x90, 0x3d, 0x54, 0xd3, + 0xbd, 0xc9, 0x06, 0xf3, 0x23, 0xb3, 0x68, 0xe2, 0x4f, 0x0f, 0x4f, 0xb2, 0x77, 0x61, 0xc2, 0x35, + 0xef, 0x76, 0xb1, 0x9a, 0x9e, 0xca, 0xa3, 0x9b, 0x62, 0x05, 0x92, 0xdb, 0x3c, 0x05, 0xc0, 0x69, + 0xc2, 0xa8, 0xc6, 0xfd, 0xfa, 0x96, 0xfd, 0x8d, 0x40, 0x58, 0xe3, 0xdb, 0xb9, 0x73, 0xb9, 0x17, + 0xc5, 0x64, 0x87, 0x62, 0x26, 0x97, 0xf6, 0xaa, 0xa8, 0x8b, 0x15, 0x15, 0xf4, 0x06, 0x0c, 0x31, + 0xc7, 0xe0, 0x68, 0xba, 0x94, 0xaf, 0x4c, 0x34, 0x63, 0x5a, 0x24, 0x9b, 0x8a, 0xfd, 0x8d, 0xb0, + 0xa0, 0x80, 0x6e, 0xc8, 0xc0, 0x37, 0xd1, 0xb2, 0x7f, 0x27, 0x22, 0x2c, 0xf0, 0x4d, 0x79, 0xfe, + 0xe3, 0x49, 0x4c, 0x1b, 0x5e, 0x9e, 0x99, 0x7a, 0xc1, 0xa8, 0x49, 0x99, 0x23, 0xf1, 0x5f, 0x66, + 0x74, 0x98, 0x86, 0xfc, 0xee, 0x99, 0x59, 0x1f, 0x92, 0xe1, 0xbc, 0x6b, 0x92, 0xc0, 0x69, 0x9a, + 0x94, 0xd1, 0xe4, 0x3b, 0x57, 0xd8, 0xf3, 0xf7, 0xda, 0xff, 0x5c, 0xbe, 0x66, 0x97, 0x0c, 0x2f, + 0xc1, 0xa2, 0xfe, 0x89, 0xde, 0xfa, 0x33, 0x3e, 0x4c, 0xa6, 0xb7, 0xe8, 0x23, 0xe5, 0x32, 0x7e, + 0x7f, 0x00, 0xc6, 0xcd, 0x25, 0x85, 0xae, 0x42, 0x59, 0x10, 0x51, 0x51, 0x58, 0xd5, 0x2e, 0x59, + 0x91, 0x00, 0x9c, 0xe0, 0xb0, 0xe0, 0xbb, 0xac, 0xba, 0x66, 0x87, 0x99, 0x04, 0xdf, 0x55, 0x10, + 0xac, 0x61, 0x51, 0x79, 0x69, 0x3d, 0x08, 0x62, 0x75, 0xa9, 0xa8, 0x75, 0x37, 0xcf, 0x4a, 0xb1, + 0x80, 0xd2, 0xcb, 0x64, 0x9b, 0x84, 0x3e, 0x69, 0x9a, 0xc1, 0xdd, 0xd4, 0x65, 0x72, 0x53, 0x07, + 0x62, 0x13, 0x97, 0xde, 0x92, 0x41, 0xc4, 0x16, 0xb2, 0x90, 0xca, 0x12, 0xbb, 0xd6, 0x3a, 0x77, + 0xb1, 0x97, 0x70, 0xf4, 0x79, 0x78, 0x4c, 0x79, 0xc4, 0x63, 0xae, 0xa8, 0x96, 0x2d, 0x0e, 0x19, + 0x4a, 0x94, 0xc7, 0x16, 0xb2, 0xd1, 0x70, 0x5e, 0x7d, 0xf4, 0x3a, 0x8c, 0x0b, 0xce, 0x5d, 0x52, + 0x1c, 0x36, 0x6d, 0x27, 0x6e, 0x1a, 0x50, 0x9c, 0xc2, 0x96, 0xe1, 0xe9, 0x18, 0xf3, 0x2c, 0x29, + 0x94, 0x3a, 0xc3, 0xd3, 0xe9, 0x70, 0xdc, 0x51, 0x03, 0xcd, 0xc1, 0x04, 0x67, 0xad, 0x3c, 0x7f, + 0x93, 0xcf, 0x89, 0x70, 0xb7, 0x51, 0x5b, 0xea, 0xb6, 0x09, 0xc6, 0x69, 0x7c, 0xf4, 0x0a, 0x8c, + 0x3a, 0x61, 0x63, 0xcb, 0x8b, 0x49, 0x23, 0x6e, 0x87, 0xdc, 0x0f, 0x47, 0x33, 0x3e, 0x99, 0xd3, + 0x60, 0xd8, 0xc0, 0xb4, 0xdf, 0x87, 0x53, 0x19, 0x9e, 0x7a, 0x74, 0xe1, 0x38, 0x2d, 0x4f, 0x7e, + 0x53, 0xca, 0x42, 0x75, 0xae, 0xb6, 0x2c, 0xbf, 0x46, 0xc3, 0xa2, 0xab, 0x93, 0x79, 0xf4, 0x69, + 0x09, 0x5c, 0xd4, 0xea, 0x5c, 0x92, 0x00, 0x9c, 0xe0, 0xd8, 0xff, 0xab, 0x00, 0x13, 0x19, 0xca, + 0x77, 0x96, 0x44, 0x24, 0x25, 0x7b, 0x24, 0x39, 0x43, 0xcc, 0x68, 0x87, 0x85, 0x23, 0x44, 0x3b, + 0x2c, 0xf6, 0x8a, 0x76, 0x38, 0xf0, 0x41, 0xa2, 0x1d, 0x9a, 0x23, 0x36, 0xd8, 0xd7, 0x88, 0x65, + 0x44, 0x48, 0x1c, 0x3a, 0x62, 0x84, 0x44, 0x63, 0xd0, 0x87, 0xfb, 0x18, 0xf4, 0x1f, 0x2a, 0xc0, + 0x64, 0xda, 0x48, 0xee, 0x04, 0xd4, 0xb1, 0x6f, 0x18, 0xea, 0xd8, 0xec, 0x94, 0x3c, 0x69, 0xd3, + 0xbd, 0x3c, 0xd5, 0x2c, 0x4e, 0xa9, 0x66, 0x3f, 0xd9, 0x17, 0xb5, 0xee, 0x6a, 0xda, 0xbf, 0x57, + 0x80, 0x33, 0xe9, 0x2a, 0x0b, 0x4d, 0xc7, 0xdb, 0x39, 0x81, 0xb1, 0xb9, 0x6d, 0x8c, 0xcd, 0x73, + 0xfd, 0x7c, 0x0d, 0xeb, 0x5a, 0xee, 0x00, 0xdd, 0x4b, 0x0d, 0xd0, 0xd5, 0xfe, 0x49, 0x76, 0x1f, + 0xa5, 0xaf, 0x17, 0xe1, 0x62, 0x66, 0xbd, 0x44, 0x9b, 0xb9, 0x64, 0x68, 0x33, 0xaf, 0xa5, 0xb4, + 0x99, 0x76, 0xf7, 0xda, 0xc7, 0xa3, 0xde, 0x14, 0x2e, 0x94, 0x2c, 0x22, 0xde, 0x43, 0xaa, 0x36, + 0x0d, 0x17, 0x4a, 0x45, 0x08, 0x9b, 0x74, 0xbf, 0x91, 0x54, 0x9a, 0xff, 0xd6, 0x82, 0x73, 0x99, + 0x73, 0x73, 0x02, 0x2a, 0xac, 0x55, 0x53, 0x85, 0xf5, 0x74, 0xdf, 0xab, 0x35, 0x47, 0xa7, 0xf5, + 0x1b, 0x03, 0x39, 0xdf, 0xc2, 0x04, 0xf4, 0xdb, 0x30, 0xe2, 0x34, 0x1a, 0x24, 0x8a, 0x56, 0x02, + 0x57, 0x45, 0x88, 0x7b, 0x8e, 0xc9, 0x59, 0x49, 0xf1, 0xe1, 0x7e, 0x65, 0x26, 0x4d, 0x22, 0x01, + 0x63, 0x9d, 0x82, 0x19, 0xd4, 0xb2, 0x70, 0xac, 0x41, 0x2d, 0xaf, 0x01, 0xec, 0x2a, 0x6e, 0x3d, + 0x2d, 0xe4, 0x6b, 0x7c, 0xbc, 0x86, 0x85, 0xbe, 0x00, 0xa5, 0x48, 0x5c, 0xe3, 0x62, 0x29, 0xbe, + 0xd0, 0xe7, 0x5c, 0x39, 0xeb, 0xa4, 0x69, 0xfa, 0xea, 0x2b, 0x7d, 0x88, 0x22, 0x89, 0xbe, 0x0d, + 0x26, 0x23, 0x1e, 0x0a, 0x66, 0xa1, 0xe9, 0x44, 0xcc, 0x0f, 0x42, 0xac, 0x42, 0xe6, 0x80, 0x5f, + 0x4f, 0xc1, 0x70, 0x07, 0x36, 0x5a, 0x92, 0x1f, 0xc5, 0xe2, 0xd6, 0xf0, 0x85, 0x79, 0x39, 0xf9, + 0x20, 0x91, 0xc2, 0xec, 0x74, 0x7a, 0xf8, 0xd9, 0xc0, 0x6b, 0x35, 0xd1, 0x17, 0x00, 0xe8, 0xf2, + 0x11, 0xba, 0x84, 0xe1, 0xfc, 0xc3, 0x93, 0x9e, 0x2a, 0x6e, 0xa6, 0xe5, 0x27, 0x73, 0x5e, 0xac, + 0x2a, 0x22, 0x58, 0x23, 0x68, 0xff, 0xd0, 0x00, 0x3c, 0xde, 0xe5, 0x8c, 0x44, 0x73, 0xe6, 0x13, + 0xe8, 0x33, 0x69, 0xe1, 0x7a, 0x26, 0xb3, 0xb2, 0x21, 0x6d, 0xa7, 0x96, 0x62, 0xe1, 0x03, 0x2f, + 0xc5, 0x1f, 0xb0, 0x34, 0xb5, 0x07, 0x37, 0xe6, 0xfb, 0xec, 0x11, 0xcf, 0xfe, 0x63, 0xd4, 0x83, + 0x6c, 0x64, 0x28, 0x13, 0xae, 0xf5, 0xdd, 0x9d, 0xbe, 0xb5, 0x0b, 0x27, 0xab, 0xfc, 0xfd, 0x92, + 0x05, 0x4f, 0x64, 0xf6, 0xd7, 0x30, 0xd9, 0xb8, 0x0a, 0xe5, 0x06, 0x2d, 0xd4, 0x7c, 0xd5, 0x12, + 0x27, 0x5e, 0x09, 0xc0, 0x09, 0x8e, 0x61, 0x99, 0x51, 0xe8, 0x69, 0x99, 0xf1, 0x2f, 0x2d, 0xe8, + 0xd8, 0x1f, 0x27, 0x70, 0x50, 0x2f, 0x9b, 0x07, 0xf5, 0xc7, 0xfb, 0x99, 0xcb, 0x9c, 0x33, 0xfa, + 0x8f, 0x27, 0xe0, 0x6c, 0x8e, 0xaf, 0xc6, 0x2e, 0x4c, 0x6d, 0x36, 0x88, 0xe9, 0x05, 0x28, 0x3e, + 0x26, 0xd3, 0x61, 0xb2, 0xab, 0xcb, 0x20, 0xcb, 0x47, 0x34, 0xd5, 0x81, 0x82, 0x3b, 0x9b, 0x40, + 0x5f, 0xb2, 0xe0, 0xb4, 0x73, 0x3f, 0xea, 0x48, 0x60, 0x2a, 0xd6, 0xcc, 0x8b, 0x99, 0x4a, 0x90, + 0x1e, 0x09, 0x4f, 0x79, 0x82, 0xa6, 0x2c, 0x2c, 0x9c, 0xd9, 0x16, 0xc2, 0x22, 0x66, 0x28, 0x65, + 0xe7, 0xbb, 0xf8, 0xa9, 0x66, 0x39, 0xd5, 0xf0, 0x23, 0x5b, 0x42, 0xb0, 0xa2, 0x83, 0xde, 0x81, + 0xf2, 0xa6, 0xf4, 0x74, 0xcb, 0xb8, 0x12, 0x92, 0x81, 0xec, 0xee, 0xff, 0xc7, 0x1f, 0x28, 0x15, + 0x12, 0x4e, 0x88, 0xa2, 0xd7, 0xa1, 0xe8, 0x6f, 0x44, 0xdd, 0x72, 0x1c, 0xa5, 0x6c, 0x9a, 0xb8, + 0x37, 0xf8, 0xea, 0x52, 0x1d, 0xd3, 0x8a, 0xe8, 0x06, 0x14, 0xc3, 0x75, 0x57, 0x68, 0xf0, 0x32, + 0xcf, 0x70, 0x3c, 0x5f, 0xcd, 0xe9, 0x15, 0xa3, 0x84, 0xe7, 0xab, 0x98, 0x92, 0x40, 0x35, 0x18, + 0x64, 0x0e, 0x0e, 0xe2, 0x3e, 0xc8, 0xe4, 0x7c, 0xbb, 0x38, 0x0a, 0x71, 0x97, 0x71, 0x86, 0x80, + 0x39, 0x21, 0xb4, 0x06, 0x43, 0x0d, 0x96, 0x0f, 0x47, 0x04, 0xac, 0xfe, 0x54, 0xa6, 0xae, 0xae, + 0x4b, 0xa2, 0x20, 0xa1, 0xba, 0x62, 0x18, 0x58, 0xd0, 0x62, 0x54, 0x49, 0x6b, 0x6b, 0x23, 0x12, + 0xf9, 0xdb, 0xb2, 0xa9, 0x76, 0xc9, 0x7f, 0x25, 0xa8, 0x32, 0x0c, 0x2c, 0x68, 0xa1, 0xcf, 0x40, + 0x61, 0xa3, 0x21, 0xfc, 0x1f, 0x32, 0x95, 0x76, 0xa6, 0x43, 0xff, 0xfc, 0xd0, 0xc1, 0x7e, 0xa5, + 0xb0, 0xb4, 0x80, 0x0b, 0x1b, 0x0d, 0xb4, 0x0a, 0xc3, 0x1b, 0xdc, 0x05, 0x58, 0xe8, 0xe5, 0x9e, + 0xca, 0xf6, 0x4e, 0xee, 0xf0, 0x12, 0xe6, 0x76, 0xfb, 0x02, 0x80, 0x25, 0x11, 0x16, 0x82, 0x53, + 0xb9, 0x32, 0x8b, 0x58, 0xd4, 0xb3, 0x47, 0x73, 0x3f, 0xe7, 0xf7, 0x73, 0xe2, 0x10, 0x8d, 0x35, + 0x8a, 0x74, 0x55, 0x3b, 0x32, 0x89, 0xa6, 0x88, 0xd5, 0x91, 0xb9, 0xaa, 0x7b, 0xe4, 0x17, 0xe5, + 0xab, 0x5a, 0x21, 0xe1, 0x84, 0x28, 0xda, 0x86, 0xb1, 0xdd, 0xa8, 0xb5, 0x45, 0xe4, 0x96, 0x66, + 0xa1, 0x3b, 0x72, 0xae, 0xb0, 0xbb, 0x02, 0xd1, 0x0b, 0xe3, 0xb6, 0xd3, 0xec, 0x38, 0x85, 0xd8, + 0xab, 0xf6, 0x5d, 0x9d, 0x18, 0x36, 0x69, 0xd3, 0xe1, 0x7f, 0xaf, 0x1d, 0xac, 0xef, 0xc5, 0x44, + 0x04, 0xaf, 0xce, 0x1c, 0xfe, 0x37, 0x39, 0x4a, 0xe7, 0xf0, 0x0b, 0x00, 0x96, 0x44, 0xd0, 0x5d, + 0x31, 0x3c, 0xec, 0xf4, 0x9c, 0xcc, 0x0f, 0xa6, 0x94, 0x99, 0xc5, 0x56, 0x1b, 0x14, 0x76, 0x5a, + 0x26, 0xa4, 0xd8, 0x29, 0xd9, 0xda, 0x0a, 0xe2, 0xc0, 0x4f, 0x9d, 0xd0, 0x53, 0xf9, 0xa7, 0x64, + 0x2d, 0x03, 0xbf, 0xf3, 0x94, 0xcc, 0xc2, 0xc2, 0x99, 0x6d, 0x21, 0x17, 0xc6, 0x5b, 0x41, 0x18, + 0xdf, 0x0f, 0x42, 0xb9, 0xbe, 0x50, 0x17, 0xbd, 0x82, 0x81, 0x29, 0x5a, 0x64, 0xc1, 0xd4, 0x4d, + 0x08, 0x4e, 0xd1, 0x44, 0x9f, 0x83, 0xe1, 0xa8, 0xe1, 0x34, 0xc9, 0xf2, 0xed, 0xe9, 0x53, 0xf9, + 0xd7, 0x4f, 0x9d, 0xa3, 0xe4, 0xac, 0x2e, 0x36, 0x39, 0x02, 0x05, 0x4b, 0x72, 0x68, 0x09, 0x06, + 0x59, 0x46, 0x04, 0x16, 0x77, 0x3b, 0x27, 0x26, 0x54, 0x87, 0x85, 0x29, 0x3f, 0x9b, 0x58, 0x31, + 0xe6, 0xd5, 0xe9, 0x1e, 0x10, 0xec, 0x75, 0x10, 0x4d, 0x9f, 0xc9, 0xdf, 0x03, 0x82, 0x2b, 0xbf, + 0x5d, 0xef, 0xb6, 0x07, 0x14, 0x12, 0x4e, 0x88, 0xd2, 0x93, 0x99, 0x9e, 0xa6, 0x67, 0xbb, 0x18, + 0xb4, 0xe4, 0x9e, 0xa5, 0xec, 0x64, 0xa6, 0x27, 0x29, 0x25, 0x61, 0xff, 0xee, 0x70, 0x27, 0xcf, + 0xc2, 0x04, 0xb2, 0xbf, 0x6c, 0x75, 0xbc, 0xd5, 0x7d, 0xba, 0x5f, 0xfd, 0xd0, 0x31, 0x72, 0xab, + 0x5f, 0xb2, 0xe0, 0x6c, 0x2b, 0xf3, 0x43, 0x04, 0x03, 0xd0, 0x9f, 0x9a, 0x89, 0x7f, 0xba, 0x8a, + 0x8d, 0x9f, 0x0d, 0xc7, 0x39, 0x2d, 0xa5, 0x25, 0x82, 0xe2, 0x07, 0x96, 0x08, 0x56, 0xa0, 0xc4, + 0x98, 0xcc, 0x1e, 0xf9, 0xe1, 0xd2, 0x82, 0x11, 0x63, 0x25, 0x16, 0x44, 0x45, 0xac, 0x48, 0xa0, + 0x1f, 0xb4, 0xe0, 0x42, 0xba, 0xeb, 0x98, 0x30, 0xb0, 0x88, 0x24, 0xcf, 0x65, 0xc1, 0x25, 0xf1, + 0xfd, 0x17, 0x6a, 0xdd, 0x90, 0x0f, 0x7b, 0x21, 0xe0, 0xee, 0x8d, 0xa1, 0x6a, 0x86, 0x30, 0x3a, + 0x64, 0x2a, 0xe0, 0xfb, 0x10, 0x48, 0x5f, 0x84, 0xd1, 0x9d, 0xa0, 0xed, 0xc7, 0xc2, 0xfe, 0x45, + 0x78, 0x2c, 0xb2, 0x07, 0xe7, 0x15, 0xad, 0x1c, 0x1b, 0x58, 0x29, 0x31, 0xb6, 0xf4, 0xd0, 0x62, + 0xec, 0xdb, 0xa9, 0x84, 0xf2, 0xe5, 0xfc, 0x88, 0x85, 0x42, 0xe2, 0x3f, 0x42, 0x5a, 0xf9, 0x93, + 0x95, 0x8d, 0x7e, 0xda, 0xca, 0x60, 0xea, 0xb9, 0xb4, 0xfc, 0x9a, 0x29, 0x2d, 0x5f, 0x4e, 0x4b, + 0xcb, 0x1d, 0xca, 0x57, 0x43, 0x50, 0xee, 0x3f, 0xec, 0x75, 0xbf, 0x71, 0xe4, 0xec, 0x26, 0x5c, + 0xea, 0x75, 0x2d, 0x31, 0x43, 0x28, 0x57, 0x3d, 0xb5, 0x25, 0x86, 0x50, 0xee, 0x72, 0x15, 0x33, + 0x48, 0xbf, 0x81, 0x46, 0xec, 0xff, 0x61, 0x41, 0xb1, 0x16, 0xb8, 0x27, 0xa0, 0x4c, 0xfe, 0xac, + 0xa1, 0x4c, 0x7e, 0x3c, 0x27, 0xd1, 0x7f, 0xae, 0xea, 0x78, 0x31, 0xa5, 0x3a, 0xbe, 0x90, 0x47, + 0xa0, 0xbb, 0xa2, 0xf8, 0x27, 0x8a, 0x30, 0x52, 0x0b, 0x5c, 0x65, 0x85, 0xfc, 0x1b, 0x0f, 0x63, + 0x85, 0x9c, 0x1b, 0x16, 0x56, 0xa3, 0xcc, 0xec, 0xa7, 0xa4, 0x13, 0xde, 0x5f, 0x30, 0x63, 0xe4, + 0x7b, 0xc4, 0xdb, 0xdc, 0x8a, 0x89, 0x9b, 0xfe, 0x9c, 0x93, 0x33, 0x46, 0xfe, 0x6f, 0x16, 0x4c, + 0xa4, 0x5a, 0x47, 0x4d, 0x18, 0x6b, 0xea, 0x9a, 0x40, 0xb1, 0x4e, 0x1f, 0x4a, 0x89, 0x28, 0x8c, + 0x39, 0xb5, 0x22, 0x6c, 0x12, 0x47, 0xb3, 0x00, 0xea, 0xa5, 0x4e, 0x6a, 0xc0, 0x18, 0xd7, 0xaf, + 0x9e, 0xf2, 0x22, 0xac, 0x61, 0xa0, 0x97, 0x60, 0x24, 0x0e, 0x5a, 0x41, 0x33, 0xd8, 0xdc, 0xbb, + 0x49, 0x64, 0x68, 0x1b, 0x65, 0xa2, 0xb5, 0x96, 0x80, 0xb0, 0x8e, 0x67, 0xff, 0x54, 0x91, 0x7f, + 0xa8, 0x1f, 0x7b, 0xdf, 0x5c, 0x93, 0x1f, 0xed, 0x35, 0xf9, 0x75, 0x0b, 0x26, 0x69, 0xeb, 0xcc, + 0x5c, 0x44, 0x5e, 0xb6, 0x2a, 0xfd, 0x8e, 0xd5, 0x25, 0xfd, 0xce, 0x65, 0x7a, 0x76, 0xb9, 0x41, + 0x3b, 0x16, 0x1a, 0x34, 0xed, 0x70, 0xa2, 0xa5, 0x58, 0x40, 0x05, 0x1e, 0x09, 0x43, 0xe1, 0x03, + 0xa5, 0xe3, 0x91, 0x30, 0xc4, 0x02, 0x2a, 0xb3, 0xf3, 0x0c, 0xe4, 0x64, 0xe7, 0x61, 0x81, 0xfa, + 0x84, 0x61, 0x81, 0x60, 0x7b, 0xb4, 0x40, 0x7d, 0xd2, 0xe2, 0x20, 0xc1, 0xb1, 0x7f, 0xbe, 0x08, + 0xa3, 0xb5, 0xc0, 0x4d, 0xde, 0xca, 0x5e, 0x34, 0xde, 0xca, 0x2e, 0xa5, 0xde, 0xca, 0x26, 0x75, + 0xdc, 0x6f, 0xbe, 0x8c, 0x7d, 0x58, 0x2f, 0x63, 0xff, 0xc2, 0x62, 0xb3, 0x56, 0x5d, 0xad, 0x8b, + 0xec, 0xc0, 0xcf, 0xc3, 0x08, 0x3b, 0x90, 0x98, 0xd3, 0x9d, 0x7c, 0x40, 0x62, 0x81, 0xf7, 0x57, + 0x93, 0x62, 0xac, 0xe3, 0xa0, 0x2b, 0x50, 0x8a, 0x88, 0x13, 0x36, 0xb6, 0xd4, 0x19, 0x27, 0x9e, + 0x57, 0x78, 0x19, 0x56, 0x50, 0xf4, 0x66, 0x12, 0x23, 0xae, 0x98, 0x9f, 0xe7, 0x56, 0xef, 0x0f, + 0xdf, 0x22, 0xf9, 0x81, 0xe1, 0xec, 0x7b, 0x80, 0x3a, 0xf1, 0xfb, 0x08, 0x8e, 0x54, 0x31, 0x83, + 0x23, 0x95, 0x3b, 0x02, 0x23, 0xfd, 0x99, 0x05, 0xe3, 0xb5, 0xc0, 0xa5, 0x5b, 0xf7, 0x1b, 0x69, + 0x9f, 0xea, 0x01, 0x32, 0x87, 0xba, 0x04, 0xc8, 0xfc, 0xfb, 0x16, 0x0c, 0xd7, 0x02, 0xf7, 0x04, + 0xf4, 0xee, 0xaf, 0x99, 0x7a, 0xf7, 0xc7, 0x72, 0x96, 0x44, 0x8e, 0xaa, 0xfd, 0x17, 0x8b, 0x30, + 0x46, 0xfb, 0x19, 0x6c, 0xca, 0x59, 0x32, 0x46, 0xc4, 0xea, 0x63, 0x44, 0x28, 0x9b, 0x1b, 0x34, + 0x9b, 0xc1, 0xfd, 0xf4, 0x8c, 0x2d, 0xb1, 0x52, 0x2c, 0xa0, 0xe8, 0x59, 0x28, 0xb5, 0x42, 0xb2, + 0xeb, 0x05, 0x82, 0x7f, 0xd4, 0x5e, 0x31, 0x6a, 0xa2, 0x1c, 0x2b, 0x0c, 0x2a, 0x77, 0x45, 0x9e, + 0xdf, 0x20, 0x32, 0xc9, 0xf6, 0x00, 0xcb, 0xc3, 0xc5, 0x23, 0x5f, 0x6b, 0xe5, 0xd8, 0xc0, 0x42, + 0xf7, 0xa0, 0xcc, 0xfe, 0xb3, 0x13, 0xe5, 0xe8, 0x79, 0x83, 0x44, 0xba, 0x09, 0x41, 0x00, 0x27, + 0xb4, 0xd0, 0x35, 0x80, 0x58, 0x46, 0x47, 0x8e, 0x44, 0x8c, 0x1b, 0xc5, 0x6b, 0xab, 0xb8, 0xc9, + 0x11, 0xd6, 0xb0, 0xd0, 0x33, 0x50, 0x8e, 0x1d, 0xaf, 0x79, 0xcb, 0xf3, 0x49, 0xc4, 0x54, 0xce, + 0x45, 0x99, 0x4d, 0x42, 0x14, 0xe2, 0x04, 0x4e, 0x79, 0x1d, 0xe6, 0x00, 0xce, 0xb3, 0x8e, 0x95, + 0x18, 0x36, 0xe3, 0x75, 0x6e, 0xa9, 0x52, 0xac, 0x61, 0xd8, 0xaf, 0xc0, 0x99, 0x5a, 0xe0, 0xd6, + 0x82, 0x30, 0x5e, 0x0a, 0xc2, 0xfb, 0x4e, 0xe8, 0xca, 0xf9, 0xab, 0xc8, 0xc4, 0x06, 0xf4, 0xec, + 0x19, 0xe4, 0x3b, 0xd3, 0x48, 0x59, 0xf0, 0x02, 0xe3, 0x76, 0x8e, 0xe8, 0xd4, 0xd1, 0x60, 0xf7, + 0xae, 0x4a, 0x30, 0x78, 0xdd, 0x89, 0x09, 0xba, 0xcd, 0x92, 0x92, 0x25, 0x57, 0x90, 0xa8, 0xfe, + 0xb4, 0x96, 0x94, 0x2c, 0x01, 0x66, 0xde, 0x59, 0x66, 0x7d, 0xfb, 0x67, 0x07, 0xd8, 0x69, 0x94, + 0xca, 0xb7, 0x87, 0xbe, 0x08, 0xe3, 0x11, 0xb9, 0xe5, 0xf9, 0xed, 0x07, 0x52, 0x08, 0xef, 0xe2, + 0x96, 0x53, 0x5f, 0xd4, 0x31, 0xb9, 0x2a, 0xcf, 0x2c, 0xc3, 0x29, 0x6a, 0x74, 0x9e, 0xc2, 0xb6, + 0x3f, 0x17, 0xdd, 0x89, 0x48, 0x28, 0xf2, 0xbd, 0xb1, 0x79, 0xc2, 0xb2, 0x10, 0x27, 0x70, 0xba, + 0x2e, 0xd9, 0x9f, 0xd5, 0xc0, 0xc7, 0x41, 0x10, 0xcb, 0x95, 0xcc, 0x32, 0x06, 0x69, 0xe5, 0xd8, + 0xc0, 0x42, 0x4b, 0x80, 0xa2, 0x76, 0xab, 0xd5, 0x64, 0x0f, 0xfb, 0x4e, 0xf3, 0x7a, 0x18, 0xb4, + 0x5b, 0xfc, 0xd5, 0xb3, 0xc8, 0x03, 0x13, 0xd6, 0x3b, 0xa0, 0x38, 0xa3, 0x06, 0x3d, 0x7d, 0x36, + 0x22, 0xf6, 0x9b, 0xad, 0xee, 0xa2, 0x50, 0xaf, 0xd7, 0x59, 0x11, 0x96, 0x30, 0xba, 0x98, 0x58, + 0xf3, 0x1c, 0x73, 0x28, 0x59, 0x4c, 0x58, 0x95, 0x62, 0x0d, 0x03, 0x2d, 0xc2, 0x70, 0xb4, 0x17, + 0x35, 0x62, 0x11, 0x91, 0x29, 0x27, 0x73, 0x67, 0x9d, 0xa1, 0x68, 0xd9, 0x24, 0x78, 0x15, 0x2c, + 0xeb, 0xa2, 0x1d, 0x18, 0xbf, 0xef, 0xf9, 0x6e, 0x70, 0x3f, 0x92, 0x13, 0x55, 0xca, 0x57, 0x8d, + 0xde, 0xe3, 0x98, 0xa9, 0xc9, 0x36, 0xe6, 0xed, 0x9e, 0x41, 0x0c, 0xa7, 0x88, 0xdb, 0xdf, 0xc5, + 0xee, 0x5e, 0x96, 0x8c, 0x2c, 0x6e, 0x87, 0x04, 0xed, 0xc0, 0x58, 0x8b, 0xad, 0x30, 0x11, 0x2a, + 0x5b, 0x2c, 0x93, 0x17, 0xfb, 0x14, 0xa2, 0xef, 0xd3, 0x73, 0x4d, 0x29, 0xb9, 0x98, 0x74, 0x52, + 0xd3, 0xc9, 0x61, 0x93, 0xba, 0xfd, 0xdf, 0x11, 0x3b, 0xe2, 0xeb, 0x5c, 0x32, 0x1e, 0x16, 0x96, + 0xcc, 0x42, 0x0c, 0x98, 0xc9, 0x57, 0xd1, 0x24, 0x03, 0x28, 0xac, 0xa1, 0xb1, 0xac, 0x8b, 0xde, + 0x64, 0x8f, 0xe2, 0xfc, 0x5c, 0xed, 0x95, 0x13, 0x9a, 0x63, 0x19, 0xef, 0xdf, 0xa2, 0x22, 0xd6, + 0x88, 0xa0, 0x5b, 0x30, 0x26, 0x72, 0x57, 0x09, 0x1d, 0x5c, 0xd1, 0xd0, 0xb1, 0x8c, 0x61, 0x1d, + 0x78, 0x98, 0x2e, 0xc0, 0x66, 0x65, 0xb4, 0x09, 0x17, 0xb4, 0x44, 0x8e, 0xd7, 0x43, 0x87, 0x3d, + 0x94, 0x7a, 0x6c, 0xcf, 0x6a, 0xc7, 0xf4, 0x13, 0x07, 0xfb, 0x95, 0x0b, 0x6b, 0xdd, 0x10, 0x71, + 0x77, 0x3a, 0xe8, 0x36, 0x9c, 0xe1, 0x0e, 0x83, 0x55, 0xe2, 0xb8, 0x4d, 0xcf, 0x57, 0xf7, 0x00, + 0x5f, 0xf6, 0xe7, 0x0e, 0xf6, 0x2b, 0x67, 0xe6, 0xb2, 0x10, 0x70, 0x76, 0x3d, 0xf4, 0x1a, 0x94, + 0x5d, 0x3f, 0x12, 0x63, 0x30, 0x64, 0xe4, 0x28, 0x2d, 0x57, 0x57, 0xeb, 0xea, 0xfb, 0x93, 0x3f, + 0x38, 0xa9, 0x80, 0x36, 0xb9, 0x1e, 0x4e, 0x89, 0xbd, 0xc3, 0xf9, 0xf9, 0xe8, 0xc5, 0x92, 0x30, + 0x5c, 0x86, 0xb8, 0x02, 0x5a, 0x99, 0xdc, 0x1a, 0xde, 0x44, 0x06, 0x61, 0xf4, 0x06, 0x20, 0xca, + 0x17, 0x7a, 0x0d, 0x32, 0xd7, 0x60, 0x11, 0xcb, 0x99, 0xda, 0xb2, 0x64, 0xb8, 0x68, 0xa0, 0x7a, + 0x07, 0x06, 0xce, 0xa8, 0x85, 0x6e, 0xd0, 0x73, 0x53, 0x2f, 0x15, 0xa6, 0xc3, 0x52, 0x96, 0x98, + 0xae, 0x92, 0x56, 0x48, 0x1a, 0x4e, 0x4c, 0x5c, 0x93, 0x22, 0x4e, 0xd5, 0xa3, 0x57, 0xb7, 0x4a, + 0x5e, 0x04, 0x66, 0x94, 0x8e, 0xce, 0x04, 0x46, 0x54, 0x0c, 0xdf, 0x0a, 0xa2, 0x78, 0x95, 0xc4, + 0xf7, 0x83, 0x70, 0x5b, 0x04, 0x45, 0x4b, 0xe2, 0x73, 0x26, 0x20, 0xac, 0xe3, 0x51, 0xb6, 0x9b, + 0xbd, 0x4a, 0x2f, 0x57, 0xd9, 0x83, 0x60, 0x29, 0xd9, 0x27, 0x37, 0x78, 0x31, 0x96, 0x70, 0x89, + 0xba, 0x5c, 0x5b, 0x60, 0x8f, 0x7b, 0x29, 0xd4, 0xe5, 0xda, 0x02, 0x96, 0x70, 0x44, 0x3a, 0xf3, + 0xbf, 0x8e, 0xe7, 0x2b, 0x51, 0x3b, 0x6f, 0x9f, 0x3e, 0x53, 0xc0, 0xfa, 0x30, 0xa9, 0x32, 0xcf, + 0xf2, 0x68, 0x71, 0xd1, 0xf4, 0x04, 0x5b, 0x24, 0xfd, 0x87, 0x9a, 0x53, 0x6a, 0xe9, 0xe5, 0x14, + 0x25, 0xdc, 0x41, 0xdb, 0x88, 0x9b, 0x32, 0xd9, 0x33, 0xf9, 0xd4, 0x55, 0x28, 0x47, 0xed, 0x75, + 0x37, 0xd8, 0x71, 0x3c, 0x9f, 0xbd, 0xc5, 0x69, 0x3c, 0x5d, 0x5d, 0x02, 0x70, 0x82, 0x83, 0x96, + 0xa0, 0xe4, 0x48, 0x9d, 0x33, 0xca, 0x0f, 0x92, 0xa0, 0x34, 0xcd, 0xdc, 0x6f, 0x58, 0x6a, 0x99, + 0x55, 0x5d, 0xf4, 0x2a, 0x8c, 0x09, 0x37, 0x31, 0x1e, 0x3a, 0x82, 0xbd, 0x95, 0x69, 0x7e, 0x00, + 0x75, 0x1d, 0x88, 0x4d, 0x5c, 0xf4, 0x05, 0x18, 0xa7, 0x54, 0x92, 0x83, 0x6d, 0xfa, 0x74, 0x3f, + 0x27, 0xa2, 0x96, 0x54, 0x44, 0xaf, 0x8c, 0x53, 0xc4, 0x90, 0x0b, 0xe7, 0x9d, 0x76, 0x1c, 0x30, + 0xbd, 0xbd, 0xb9, 0xfe, 0xd7, 0x82, 0x6d, 0xe2, 0xb3, 0x27, 0xb3, 0xd2, 0xfc, 0xa5, 0x83, 0xfd, + 0xca, 0xf9, 0xb9, 0x2e, 0x78, 0xb8, 0x2b, 0x15, 0x74, 0x07, 0x46, 0xe2, 0xa0, 0xc9, 0x2c, 0xf2, + 0xe9, 0x85, 0x78, 0x36, 0x3f, 0xee, 0xd0, 0x9a, 0x42, 0xd3, 0x75, 0x56, 0xaa, 0x2a, 0xd6, 0xe9, + 0xa0, 0x35, 0xbe, 0xc7, 0x58, 0x44, 0x56, 0x12, 0x4d, 0x3f, 0x96, 0x3f, 0x30, 0x2a, 0x70, 0xab, + 0xb9, 0x05, 0x45, 0x4d, 0xac, 0x93, 0x41, 0xd7, 0x61, 0xaa, 0x15, 0x7a, 0x01, 0x5b, 0xd8, 0xea, + 0xcd, 0x64, 0xda, 0xcc, 0x23, 0x51, 0x4b, 0x23, 0xe0, 0xce, 0x3a, 0x54, 0xa6, 0x95, 0x85, 0xd3, + 0xe7, 0x78, 0x52, 0x32, 0xce, 0xe7, 0xf3, 0x32, 0xac, 0xa0, 0x68, 0x85, 0x9d, 0xcb, 0x5c, 0xfa, + 0x9c, 0x9e, 0xc9, 0x0f, 0x2e, 0xa1, 0x4b, 0xa9, 0x9c, 0x3d, 0x53, 0x7f, 0x71, 0x42, 0x81, 0xde, + 0x1b, 0xd1, 0x96, 0x13, 0x92, 0x5a, 0x18, 0x34, 0x48, 0xa4, 0x05, 0x81, 0x7e, 0x9c, 0x07, 0x8e, + 0xa4, 0xf7, 0x46, 0x3d, 0x0b, 0x01, 0x67, 0xd7, 0x43, 0xae, 0x96, 0x8b, 0x9b, 0x72, 0xbd, 0xd1, + 0xf4, 0xf9, 0x2e, 0xf6, 0x4d, 0x29, 0x16, 0x39, 0x59, 0x8b, 0x46, 0x71, 0x84, 0x53, 0x34, 0xd1, + 0xb7, 0xc1, 0xa4, 0x88, 0xb3, 0x94, 0x8c, 0xfb, 0x85, 0xc4, 0x70, 0x12, 0xa7, 0x60, 0xb8, 0x03, + 0x9b, 0x87, 0xbe, 0x76, 0xd6, 0x9b, 0x44, 0x2c, 0xc2, 0x5b, 0x9e, 0xbf, 0x1d, 0x4d, 0x5f, 0x64, + 0x5f, 0x2d, 0x42, 0x5f, 0xa7, 0xa1, 0x38, 0xa3, 0x06, 0x5a, 0x83, 0xc9, 0x56, 0x48, 0xc8, 0x0e, + 0xe3, 0xb1, 0xc4, 0x75, 0x59, 0xe1, 0xde, 0xc0, 0xb4, 0x27, 0xb5, 0x14, 0xec, 0x30, 0xa3, 0x0c, + 0x77, 0x50, 0x98, 0xf9, 0x56, 0x98, 0xea, 0xb8, 0x0f, 0x8f, 0x14, 0x84, 0xfe, 0x4f, 0x07, 0xa1, + 0xac, 0x5e, 0x16, 0xd0, 0x55, 0xf3, 0xc1, 0xe8, 0x5c, 0xfa, 0xc1, 0xa8, 0x44, 0x05, 0x1c, 0xfd, + 0x8d, 0x68, 0xcd, 0xb0, 0x36, 0x2c, 0xe4, 0xa7, 0x7c, 0xd3, 0x45, 0x94, 0x9e, 0x9e, 0x8b, 0x9a, + 0xa2, 0xa8, 0xd8, 0xf7, 0xcb, 0xd3, 0x40, 0x57, 0xdd, 0x53, 0x9f, 0x19, 0x97, 0xd1, 0x93, 0x54, + 0xca, 0x73, 0x97, 0x6b, 0xe9, 0x14, 0xa4, 0x35, 0x5a, 0x88, 0x39, 0x8c, 0x49, 0xc3, 0x94, 0x79, + 0x63, 0xd2, 0xf0, 0xf0, 0x43, 0x4a, 0xc3, 0x92, 0x00, 0x4e, 0x68, 0xa1, 0x26, 0x4c, 0x35, 0xcc, + 0xec, 0xb1, 0xca, 0x5b, 0xf1, 0xc9, 0x9e, 0x79, 0x5c, 0xdb, 0x5a, 0xaa, 0xbe, 0x85, 0x34, 0x15, + 0xdc, 0x49, 0x18, 0xbd, 0x0a, 0xa5, 0xf7, 0x82, 0x88, 0x2d, 0x75, 0xc1, 0xc1, 0x48, 0xaf, 0xae, + 0xd2, 0x9b, 0xb7, 0xeb, 0xac, 0xfc, 0x70, 0xbf, 0x32, 0x52, 0x0b, 0x5c, 0xf9, 0x17, 0xab, 0x0a, + 0xe8, 0x01, 0x9c, 0x31, 0xce, 0x7d, 0xd5, 0x5d, 0xe8, 0xbf, 0xbb, 0x17, 0x44, 0x73, 0x67, 0x96, + 0xb3, 0x28, 0xe1, 0xec, 0x06, 0xe8, 0x61, 0xea, 0x07, 0x22, 0xf3, 0xb2, 0xe4, 0x92, 0x18, 0x33, + 0x54, 0xd6, 0x7d, 0xfa, 0x53, 0x08, 0xb8, 0xb3, 0x8e, 0xfd, 0x2b, 0xfc, 0x21, 0x46, 0xa8, 0x6b, + 0x49, 0xd4, 0x6e, 0x9e, 0x44, 0x62, 0xaf, 0x45, 0x43, 0x93, 0xfc, 0xd0, 0x8f, 0x7d, 0xbf, 0x6e, + 0xb1, 0xc7, 0xbe, 0x35, 0xb2, 0xd3, 0x6a, 0x3a, 0xf1, 0x49, 0x78, 0x13, 0xbd, 0x09, 0xa5, 0x58, + 0xb4, 0xd6, 0x2d, 0x17, 0x99, 0xd6, 0x29, 0xf6, 0xe0, 0xa9, 0xf8, 0x27, 0x59, 0x8a, 0x15, 0x19, + 0xfb, 0x9f, 0xf2, 0x19, 0x90, 0x90, 0x13, 0xd0, 0xea, 0x55, 0x4d, 0xad, 0x5e, 0xa5, 0xc7, 0x17, + 0xe4, 0x68, 0xf7, 0xfe, 0x89, 0xd9, 0x6f, 0x26, 0xaa, 0x7e, 0xd4, 0x5f, 0x99, 0xed, 0x1f, 0xb6, + 0xe0, 0x74, 0x96, 0x59, 0x16, 0xe5, 0x79, 0xb9, 0xa0, 0xac, 0x5e, 0xdd, 0xd5, 0x08, 0xde, 0x15, + 0xe5, 0x58, 0x61, 0xf4, 0x9d, 0xe6, 0xe3, 0x68, 0x61, 0xef, 0x6e, 0xc3, 0x58, 0x2d, 0x24, 0xda, + 0x1d, 0xf0, 0x3a, 0x77, 0x0f, 0xe4, 0xfd, 0x79, 0xf6, 0xc8, 0xae, 0x81, 0xf6, 0xcf, 0x14, 0xe0, + 0x34, 0x7f, 0x36, 0x9b, 0xdb, 0x0d, 0x3c, 0xb7, 0x16, 0xb8, 0x22, 0x45, 0xcb, 0x5b, 0x30, 0xda, + 0xd2, 0xb4, 0x1b, 0xdd, 0x02, 0x6f, 0xe9, 0x5a, 0x90, 0x44, 0xca, 0xd4, 0x4b, 0xb1, 0x41, 0x0b, + 0xb9, 0x30, 0x4a, 0x76, 0xbd, 0x86, 0x7a, 0x7b, 0x29, 0x1c, 0xf9, 0x6e, 0x50, 0xad, 0x2c, 0x6a, + 0x74, 0xb0, 0x41, 0xf5, 0x11, 0x64, 0xed, 0xb3, 0x7f, 0xc4, 0x82, 0xc7, 0x72, 0xc2, 0x74, 0xd1, + 0xe6, 0xee, 0xb3, 0x07, 0x4a, 0x91, 0x00, 0x4c, 0x35, 0xc7, 0x9f, 0x2d, 0xb1, 0x80, 0xa2, 0xcf, + 0x01, 0xf0, 0x67, 0x47, 0x2a, 0x74, 0xf5, 0x8a, 0x67, 0x64, 0x84, 0x62, 0xd1, 0x42, 0x68, 0xc8, + 0xfa, 0x58, 0xa3, 0x65, 0xff, 0x64, 0x11, 0x06, 0xd9, 0x33, 0x17, 0x5a, 0x82, 0xe1, 0x2d, 0x1e, + 0xb8, 0xba, 0x9f, 0x18, 0xd9, 0x89, 0xf4, 0xca, 0x0b, 0xb0, 0xac, 0x8c, 0x56, 0xe0, 0x14, 0x0f, + 0xfc, 0xdd, 0xac, 0x92, 0xa6, 0xb3, 0x27, 0x95, 0x20, 0x3c, 0x69, 0x96, 0x0a, 0x07, 0xb2, 0xdc, + 0x89, 0x82, 0xb3, 0xea, 0xa1, 0xd7, 0x61, 0x9c, 0x72, 0x8d, 0x41, 0x3b, 0x96, 0x94, 0x78, 0xc8, + 0x6f, 0xc5, 0xa6, 0xae, 0x19, 0x50, 0x9c, 0xc2, 0xa6, 0xe2, 0x5c, 0xab, 0x43, 0xdd, 0x33, 0x98, + 0x88, 0x73, 0xa6, 0x8a, 0xc7, 0xc4, 0x65, 0xf6, 0x58, 0x6d, 0x66, 0x7d, 0xb6, 0xb6, 0x15, 0x92, + 0x68, 0x2b, 0x68, 0xba, 0x22, 0xe7, 0x7a, 0x62, 0x8f, 0x95, 0x82, 0xe3, 0x8e, 0x1a, 0x94, 0xca, + 0x86, 0xe3, 0x35, 0xdb, 0x21, 0x49, 0xa8, 0x0c, 0x99, 0x54, 0x96, 0x52, 0x70, 0xdc, 0x51, 0x83, + 0xae, 0xa3, 0x33, 0x22, 0x09, 0xba, 0x0c, 0x52, 0xa0, 0x8c, 0xec, 0x86, 0xa5, 0xbb, 0x56, 0x97, + 0x28, 0x3d, 0xc2, 0x0c, 0x49, 0xa5, 0x51, 0xd7, 0x94, 0xa2, 0xc2, 0x51, 0x4b, 0x52, 0x79, 0x98, + 0x54, 0xdc, 0xdf, 0x5f, 0x80, 0x53, 0x19, 0xc6, 0xbc, 0xfc, 0xa8, 0xda, 0xf4, 0xa2, 0x58, 0x25, + 0x06, 0xd2, 0x8e, 0x2a, 0x5e, 0x8e, 0x15, 0x06, 0xdd, 0x0f, 0xfc, 0x30, 0x4c, 0x1f, 0x80, 0xc2, + 0x58, 0x4e, 0x40, 0x8f, 0x98, 0x62, 0xe7, 0x12, 0x0c, 0xb4, 0x23, 0x22, 0xe3, 0x6b, 0xa9, 0xf3, + 0x9b, 0xa9, 0xc9, 0x19, 0x84, 0xb2, 0xa6, 0x9b, 0x4a, 0x43, 0xad, 0xb1, 0xa6, 0x5c, 0xed, 0xcc, + 0x61, 0xb4, 0x73, 0x31, 0xf1, 0x1d, 0x3f, 0x16, 0x0c, 0x6c, 0x12, 0x15, 0x86, 0x95, 0x62, 0x01, + 0xb5, 0xbf, 0x52, 0x84, 0x73, 0xb9, 0xe6, 0xfd, 0xb4, 0xeb, 0x3b, 0x81, 0xef, 0xc5, 0x81, 0x7a, + 0x6a, 0xe5, 0x91, 0x60, 0x48, 0x6b, 0x6b, 0x45, 0x94, 0x63, 0x85, 0x81, 0x2e, 0xcb, 0xb4, 0xfd, + 0xe9, 0x14, 0x49, 0xf3, 0x55, 0x23, 0x73, 0x7f, 0xbf, 0xe9, 0xe7, 0x9e, 0x84, 0x81, 0x56, 0x10, + 0x34, 0xd3, 0x87, 0x16, 0xed, 0x6e, 0x10, 0x34, 0x31, 0x03, 0xa2, 0x4f, 0x88, 0xf1, 0x4a, 0xbd, + 0x2d, 0x62, 0xc7, 0x0d, 0x22, 0x6d, 0xd0, 0x9e, 0x86, 0xe1, 0x6d, 0xb2, 0x17, 0x7a, 0xfe, 0x66, + 0xfa, 0xcd, 0xf9, 0x26, 0x2f, 0xc6, 0x12, 0x6e, 0x26, 0xcc, 0x18, 0x3e, 0xee, 0xbc, 0x71, 0xa5, + 0x9e, 0x57, 0xe0, 0x0f, 0x14, 0x61, 0x02, 0xcf, 0x57, 0xbf, 0x39, 0x11, 0x77, 0x3a, 0x27, 0xe2, + 0xb8, 0xf3, 0xc6, 0xf5, 0x9e, 0x8d, 0x5f, 0xb4, 0x60, 0x82, 0x05, 0x95, 0x16, 0xf1, 0x47, 0xbc, + 0xc0, 0x3f, 0x01, 0x16, 0xef, 0x49, 0x18, 0x0c, 0x69, 0xa3, 0xe9, 0xdc, 0x48, 0xac, 0x27, 0x98, + 0xc3, 0xd0, 0x79, 0x18, 0x60, 0x5d, 0xa0, 0x93, 0x37, 0xca, 0xd3, 0x4a, 0x54, 0x9d, 0xd8, 0xc1, + 0xac, 0x94, 0x39, 0xd5, 0x63, 0xd2, 0x6a, 0x7a, 0xbc, 0xd3, 0xc9, 0xc3, 0xca, 0x47, 0xc3, 0xa9, + 0x3e, 0xb3, 0x6b, 0x1f, 0xcc, 0xa9, 0x3e, 0x9b, 0x64, 0x77, 0xf1, 0xe9, 0x8f, 0x0a, 0x70, 0x31, + 0xb3, 0x5e, 0xdf, 0x4e, 0xf5, 0xdd, 0x6b, 0x1f, 0x8f, 0xe9, 0x50, 0xb6, 0x45, 0x4f, 0xf1, 0x04, + 0x2d, 0x7a, 0x06, 0xfa, 0xe5, 0x30, 0x07, 0xfb, 0xf0, 0x75, 0xcf, 0x1c, 0xb2, 0x8f, 0x88, 0xaf, + 0x7b, 0x66, 0xdf, 0x72, 0xc4, 0xbf, 0x3f, 0x2f, 0xe4, 0x7c, 0x0b, 0x13, 0x04, 0xaf, 0xd0, 0x73, + 0x86, 0x01, 0x23, 0xc1, 0x31, 0x8f, 0xf2, 0x33, 0x86, 0x97, 0x61, 0x05, 0x45, 0x9e, 0xe6, 0x35, + 0x5e, 0xc8, 0x4f, 0x15, 0x9a, 0xdb, 0xd4, 0xac, 0xf9, 0x0e, 0xa6, 0x86, 0x20, 0xc3, 0x83, 0x7c, + 0x45, 0x13, 0xde, 0x8b, 0xfd, 0x0b, 0xef, 0xa3, 0xd9, 0x82, 0x3b, 0x9a, 0x83, 0x89, 0x1d, 0xcf, + 0xa7, 0xc7, 0xe6, 0x9e, 0xc9, 0xb2, 0xaa, 0x20, 0x2a, 0x2b, 0x26, 0x18, 0xa7, 0xf1, 0x67, 0x5e, + 0x85, 0xb1, 0x87, 0x57, 0x5b, 0x7e, 0xbd, 0x08, 0x8f, 0x77, 0xd9, 0xf6, 0xfc, 0xac, 0x37, 0xe6, + 0x40, 0x3b, 0xeb, 0x3b, 0xe6, 0xa1, 0x06, 0xa7, 0x37, 0xda, 0xcd, 0xe6, 0x1e, 0x33, 0x9a, 0x25, + 0xae, 0xc4, 0x10, 0x3c, 0xe5, 0x79, 0x99, 0xc8, 0x63, 0x29, 0x03, 0x07, 0x67, 0xd6, 0x44, 0x6f, + 0x00, 0x0a, 0x44, 0x9e, 0xe2, 0xeb, 0xc4, 0x17, 0xaf, 0x0b, 0x6c, 0xe0, 0x8b, 0xc9, 0x66, 0xbc, + 0xdd, 0x81, 0x81, 0x33, 0x6a, 0x51, 0xe1, 0x80, 0xde, 0x4a, 0x7b, 0xaa, 0x5b, 0x29, 0xe1, 0x00, + 0xeb, 0x40, 0x6c, 0xe2, 0xa2, 0xeb, 0x30, 0xe5, 0xec, 0x3a, 0x1e, 0x0f, 0x2e, 0x28, 0x09, 0x70, + 0xe9, 0x40, 0x29, 0xcb, 0xe6, 0xd2, 0x08, 0xb8, 0xb3, 0x4e, 0xca, 0xaf, 0x7c, 0x28, 0xdf, 0xaf, + 0xbc, 0xfb, 0xb9, 0xd8, 0x4b, 0xf7, 0x6b, 0xff, 0x67, 0x8b, 0x5e, 0x5f, 0x9c, 0xc9, 0x37, 0xc3, + 0x23, 0xbd, 0xca, 0xcc, 0x62, 0xb8, 0x32, 0x50, 0x73, 0xf1, 0x3e, 0xa3, 0x99, 0xc5, 0x24, 0x40, + 0x6c, 0xe2, 0xf2, 0x05, 0x11, 0x25, 0x9e, 0x45, 0x06, 0x8b, 0x2f, 0x42, 0x44, 0x28, 0x0c, 0xf4, + 0x79, 0x18, 0x76, 0xbd, 0x5d, 0x2f, 0x0a, 0x42, 0xb1, 0x59, 0x8e, 0xe8, 0x9f, 0x91, 0x9c, 0x83, + 0x55, 0x4e, 0x06, 0x4b, 0x7a, 0xf6, 0x0f, 0x14, 0x60, 0x4c, 0xb6, 0xf8, 0x66, 0x3b, 0x88, 0x9d, + 0x13, 0xb8, 0x96, 0xaf, 0x1b, 0xd7, 0xf2, 0x27, 0xba, 0xc5, 0xc9, 0x60, 0x5d, 0xca, 0xbd, 0x8e, + 0x6f, 0xa7, 0xae, 0xe3, 0xa7, 0x7a, 0x93, 0xea, 0x7e, 0x0d, 0xff, 0x33, 0x0b, 0xa6, 0x0c, 0xfc, + 0x13, 0xb8, 0x0d, 0x96, 0xcc, 0xdb, 0xe0, 0x89, 0x9e, 0xdf, 0x90, 0x73, 0x0b, 0x7c, 0x6f, 0x31, + 0xd5, 0x77, 0x76, 0xfa, 0xbf, 0x07, 0x03, 0x5b, 0x4e, 0xe8, 0x76, 0x8b, 0xc7, 0xdb, 0x51, 0x69, + 0xf6, 0x86, 0x13, 0xba, 0xfc, 0x0c, 0x7f, 0x56, 0x25, 0xfb, 0x74, 0x42, 0xb7, 0xa7, 0x23, 0x1d, + 0x6b, 0x0a, 0xbd, 0x02, 0x43, 0x51, 0x23, 0x68, 0x29, 0x33, 0xd7, 0x4b, 0x3c, 0x11, 0x28, 0x2d, + 0x39, 0xdc, 0xaf, 0x20, 0xb3, 0x39, 0x5a, 0x8c, 0x05, 0x3e, 0x7a, 0x0b, 0xc6, 0xd8, 0x2f, 0x65, + 0x7f, 0x51, 0xcc, 0xcf, 0x02, 0x51, 0xd7, 0x11, 0xb9, 0x19, 0x8f, 0x51, 0x84, 0x4d, 0x52, 0x33, + 0x9b, 0x50, 0x56, 0x9f, 0xf5, 0x48, 0x1d, 0xa0, 0xfe, 0x43, 0x11, 0x4e, 0x65, 0xac, 0x39, 0x14, + 0x19, 0x33, 0xf1, 0x7c, 0x9f, 0x4b, 0xf5, 0x03, 0xce, 0x45, 0xc4, 0xa4, 0x21, 0x57, 0xac, 0xad, + 0xbe, 0x1b, 0xbd, 0x13, 0x91, 0x74, 0xa3, 0xb4, 0xa8, 0x77, 0xa3, 0xb4, 0xb1, 0x13, 0x1b, 0x6a, + 0xda, 0x90, 0xea, 0xe9, 0x23, 0x9d, 0xd3, 0x3f, 0x29, 0xc2, 0xe9, 0xac, 0xd0, 0x3d, 0xe8, 0x3b, + 0x53, 0x19, 0x81, 0x5e, 0xec, 0x37, 0xe8, 0x0f, 0x4f, 0x13, 0x24, 0x12, 0x7a, 0xcf, 0x9a, 0x39, + 0x82, 0x7a, 0x0e, 0xb3, 0x68, 0x93, 0x79, 0xcd, 0x86, 0x3c, 0x93, 0x93, 0x3c, 0x3e, 0x3e, 0xdd, + 0x77, 0x07, 0x44, 0x0a, 0xa8, 0x28, 0xe5, 0x35, 0x2b, 0x8b, 0x7b, 0x7b, 0xcd, 0xca, 0x96, 0x67, + 0x3c, 0x18, 0xd1, 0xbe, 0xe6, 0x91, 0xce, 0xf8, 0x36, 0xbd, 0xad, 0xb4, 0x7e, 0x3f, 0xd2, 0x59, + 0xff, 0x11, 0x0b, 0x52, 0x36, 0xa5, 0x4a, 0x2d, 0x66, 0xe5, 0xaa, 0xc5, 0x2e, 0xc1, 0x40, 0x18, + 0x34, 0x49, 0x3a, 0x01, 0x0f, 0x0e, 0x9a, 0x04, 0x33, 0x08, 0xc5, 0x88, 0x13, 0x65, 0xc7, 0xa8, + 0x2e, 0xc8, 0x09, 0x11, 0xed, 0x49, 0x18, 0x6c, 0x92, 0x5d, 0xd2, 0x4c, 0x47, 0xb7, 0xbf, 0x45, + 0x0b, 0x31, 0x87, 0xd9, 0xbf, 0x38, 0x00, 0x17, 0xba, 0xfa, 0x9d, 0x53, 0x71, 0x68, 0xd3, 0x89, + 0xc9, 0x7d, 0x67, 0x2f, 0x1d, 0x86, 0xfa, 0x3a, 0x2f, 0xc6, 0x12, 0xce, 0xcc, 0xec, 0x79, 0xd8, + 0xc9, 0x94, 0x12, 0x51, 0x44, 0x9b, 0x14, 0x50, 0x53, 0x29, 0x55, 0x3c, 0x0e, 0xa5, 0xd4, 0x35, + 0x80, 0x28, 0x6a, 0x72, 0xab, 0x05, 0x57, 0xd8, 0xef, 0x27, 0xe1, 0x49, 0xeb, 0xb7, 0x04, 0x04, + 0x6b, 0x58, 0xa8, 0x0a, 0x93, 0xad, 0x30, 0x88, 0xb9, 0x4e, 0xb6, 0xca, 0xcd, 0x9d, 0x06, 0x4d, + 0x97, 0xdf, 0x5a, 0x0a, 0x8e, 0x3b, 0x6a, 0xa0, 0x97, 0x60, 0x44, 0xb8, 0x01, 0xd7, 0x82, 0xa0, + 0x29, 0xd4, 0x40, 0xca, 0x78, 0xa6, 0x9e, 0x80, 0xb0, 0x8e, 0xa7, 0x55, 0x63, 0x8a, 0xde, 0xe1, + 0xcc, 0x6a, 0x5c, 0xd9, 0xab, 0xe1, 0xa5, 0xc2, 0x78, 0x95, 0xfa, 0x0a, 0xe3, 0x95, 0x28, 0xc6, + 0xca, 0x7d, 0xbf, 0x6d, 0x41, 0x4f, 0x55, 0xd2, 0xcf, 0x0d, 0xc0, 0x29, 0xb1, 0x70, 0x1e, 0xf5, + 0x72, 0xb9, 0xd3, 0xb9, 0x5c, 0x8e, 0x43, 0x75, 0xf6, 0xcd, 0x35, 0x73, 0xd2, 0x6b, 0xe6, 0x07, + 0x2d, 0x30, 0xd9, 0x2b, 0xf4, 0xff, 0xe5, 0xc6, 0xf1, 0x7f, 0x29, 0x97, 0x5d, 0x73, 0xe5, 0x05, + 0xf2, 0x01, 0x23, 0xfa, 0xdb, 0xff, 0xc9, 0x82, 0x27, 0x7a, 0x52, 0x44, 0x8b, 0x50, 0x66, 0x3c, + 0xa0, 0x26, 0x9d, 0x3d, 0xa5, 0xcc, 0x21, 0x25, 0x20, 0x87, 0x25, 0x4d, 0x6a, 0xa2, 0xc5, 0x8e, + 0x84, 0x09, 0x4f, 0x67, 0x24, 0x4c, 0x38, 0x63, 0x0c, 0xcf, 0x43, 0x66, 0x4c, 0xf8, 0x95, 0x22, + 0x0c, 0xf1, 0x15, 0x7f, 0x02, 0x62, 0xd8, 0x92, 0xd0, 0xdb, 0x76, 0x09, 0xe4, 0xc5, 0xfb, 0x32, + 0x5b, 0x75, 0x62, 0x87, 0xb3, 0x09, 0xea, 0xb6, 0x4a, 0x34, 0xbc, 0x68, 0xd6, 0xb8, 0xcf, 0x66, + 0x52, 0x8a, 0x49, 0xe0, 0x34, 0xb4, 0xdb, 0xed, 0x8b, 0x00, 0x51, 0x1c, 0x7a, 0xfe, 0x26, 0xa5, + 0x21, 0x42, 0xc2, 0x7d, 0xb2, 0x4b, 0xeb, 0x75, 0x85, 0xcc, 0xfb, 0x90, 0xec, 0x74, 0x05, 0xc0, + 0x1a, 0xc5, 0x99, 0x97, 0xa1, 0xac, 0x90, 0x7b, 0x69, 0x71, 0x46, 0x75, 0xe6, 0xe2, 0xb3, 0x30, + 0x91, 0x6a, 0xeb, 0x48, 0x4a, 0xa0, 0x5f, 0xb2, 0x60, 0x82, 0x77, 0x79, 0xd1, 0xdf, 0x15, 0x67, + 0xea, 0xfb, 0x70, 0xba, 0x99, 0x71, 0xb6, 0x89, 0x19, 0xed, 0xff, 0x2c, 0x54, 0x4a, 0x9f, 0x2c, + 0x28, 0xce, 0x6c, 0x03, 0x5d, 0xa1, 0xeb, 0x96, 0x9e, 0x5d, 0x4e, 0x53, 0xb8, 0x6c, 0x8d, 0xf2, + 0x35, 0xcb, 0xcb, 0xb0, 0x82, 0xda, 0xbf, 0x6d, 0xc1, 0x14, 0xef, 0xf9, 0x4d, 0xb2, 0xa7, 0x76, + 0xf8, 0x87, 0xd9, 0x77, 0x91, 0xc3, 0xa4, 0x90, 0x93, 0xc3, 0x44, 0xff, 0xb4, 0x62, 0xd7, 0x4f, + 0xfb, 0x19, 0x0b, 0xc4, 0x0a, 0x3c, 0x01, 0x51, 0xfe, 0x5b, 0x4d, 0x51, 0x7e, 0x26, 0x7f, 0x51, + 0xe7, 0xc8, 0xf0, 0x7f, 0x66, 0xc1, 0x24, 0x47, 0x48, 0xde, 0x9c, 0x3f, 0xd4, 0x79, 0xe8, 0x27, + 0x19, 0xa1, 0xca, 0x50, 0x9e, 0xfd, 0x51, 0xc6, 0x64, 0x0d, 0x74, 0x9d, 0x2c, 0x57, 0x6e, 0xa0, + 0x23, 0x24, 0xe2, 0x3c, 0x72, 0x2c, 0x70, 0xfb, 0x0f, 0x2d, 0x40, 0xbc, 0x19, 0x83, 0xfd, 0xa1, + 0x4c, 0x05, 0x2b, 0xd5, 0xae, 0x8b, 0xe4, 0xa8, 0x51, 0x10, 0xac, 0x61, 0x1d, 0xcb, 0xf0, 0xa4, + 0x0c, 0x07, 0x8a, 0xbd, 0x0d, 0x07, 0x8e, 0x30, 0xa2, 0x7f, 0x30, 0x08, 0x69, 0xa7, 0x06, 0x74, + 0x17, 0x46, 0x1b, 0x4e, 0xcb, 0x59, 0xf7, 0x9a, 0x5e, 0xec, 0x91, 0xa8, 0x9b, 0xc5, 0xd1, 0x82, + 0x86, 0x27, 0x9e, 0x7a, 0xb5, 0x12, 0x6c, 0xd0, 0x41, 0xb3, 0x00, 0xad, 0xd0, 0xdb, 0xf5, 0x9a, + 0x64, 0x93, 0x69, 0x1c, 0x98, 0x93, 0x28, 0x37, 0xa3, 0x91, 0xa5, 0x58, 0xc3, 0xc8, 0xf0, 0xf7, + 0x2b, 0x3e, 0x3a, 0x7f, 0xbf, 0x81, 0x23, 0xfa, 0xfb, 0x0d, 0xf6, 0xe5, 0xef, 0x87, 0xe1, 0xac, + 0x64, 0x91, 0xe8, 0xff, 0x25, 0xaf, 0x49, 0x04, 0x5f, 0xcc, 0x5d, 0x47, 0x67, 0x0e, 0xf6, 0x2b, + 0x67, 0x71, 0x26, 0x06, 0xce, 0xa9, 0x89, 0x3e, 0x07, 0xd3, 0x4e, 0xb3, 0x19, 0xdc, 0x57, 0xa3, + 0xb6, 0x18, 0x35, 0x9c, 0x26, 0xd7, 0xd8, 0x0f, 0x33, 0xaa, 0xe7, 0x0f, 0xf6, 0x2b, 0xd3, 0x73, + 0x39, 0x38, 0x38, 0xb7, 0x76, 0xca, 0x5d, 0xb0, 0xd4, 0xd3, 0x5d, 0xf0, 0x35, 0x28, 0xb7, 0xc2, + 0xa0, 0xb1, 0xa2, 0xf9, 0x14, 0x5d, 0x64, 0x69, 0xfe, 0x65, 0xe1, 0xe1, 0x7e, 0x65, 0x4c, 0xfd, + 0x61, 0x37, 0x7c, 0x52, 0x21, 0xc3, 0x4b, 0x10, 0x1e, 0xa5, 0x97, 0xe0, 0x36, 0x9c, 0xaa, 0x93, + 0xd0, 0x63, 0xf9, 0x4a, 0xdd, 0xe4, 0xfc, 0x58, 0x83, 0x72, 0x98, 0x3a, 0x31, 0xfb, 0x0a, 0x7e, + 0xa5, 0xc5, 0x64, 0x96, 0x27, 0x64, 0x42, 0xc8, 0xfe, 0x53, 0x0b, 0x86, 0x85, 0x39, 0xfd, 0x09, + 0x30, 0x6a, 0x73, 0x86, 0xbe, 0xbc, 0x92, 0x7d, 0xab, 0xb0, 0xce, 0xe4, 0x6a, 0xca, 0x97, 0x53, + 0x9a, 0xf2, 0x27, 0xba, 0x11, 0xe9, 0xae, 0x23, 0xff, 0xdb, 0x45, 0x18, 0x37, 0x3d, 0x60, 0x4e, + 0x60, 0x08, 0x56, 0x61, 0x38, 0x12, 0xee, 0x56, 0x85, 0x7c, 0x83, 0xee, 0xf4, 0x24, 0x26, 0xd6, + 0x5a, 0xc2, 0xc1, 0x4a, 0x12, 0xc9, 0xf4, 0xe3, 0x2a, 0x3e, 0x42, 0x3f, 0xae, 0x5e, 0x4e, 0x48, + 0x03, 0xc7, 0xe1, 0x84, 0x64, 0x7f, 0x95, 0xdd, 0x6c, 0x7a, 0xf9, 0x09, 0x30, 0x3d, 0xd7, 0xcd, + 0x3b, 0xd0, 0xee, 0xb2, 0xb2, 0x44, 0xa7, 0x72, 0x98, 0x9f, 0x5f, 0xb0, 0xe0, 0x42, 0xc6, 0x57, + 0x69, 0x9c, 0xd0, 0xb3, 0x50, 0x72, 0xda, 0xae, 0xa7, 0xf6, 0xb2, 0xf6, 0x6a, 0x36, 0x27, 0xca, + 0xb1, 0xc2, 0x40, 0x0b, 0x30, 0x45, 0x1e, 0xb4, 0x3c, 0xfe, 0x6c, 0xa9, 0x9b, 0x54, 0x16, 0x79, + 0x40, 0xe0, 0xc5, 0x34, 0x10, 0x77, 0xe2, 0x2b, 0x97, 0xf9, 0x62, 0xae, 0xcb, 0xfc, 0x3f, 0xb4, + 0x60, 0x44, 0xb9, 0xd6, 0x3c, 0xf2, 0xd1, 0xfe, 0x36, 0x73, 0xb4, 0x1f, 0xef, 0x32, 0xda, 0x39, + 0xc3, 0xfc, 0x77, 0x0b, 0xaa, 0xbf, 0xb5, 0x20, 0x8c, 0xfb, 0xe0, 0xb0, 0x5e, 0x81, 0x52, 0x2b, + 0x0c, 0xe2, 0xa0, 0x11, 0x34, 0x05, 0x83, 0x75, 0x3e, 0x89, 0xe8, 0xc0, 0xcb, 0x0f, 0xb5, 0xdf, + 0x58, 0x61, 0xb3, 0xd1, 0x0b, 0xc2, 0x58, 0x30, 0x35, 0xc9, 0xe8, 0x05, 0x61, 0x8c, 0x19, 0x04, + 0xb9, 0x00, 0xb1, 0x13, 0x6e, 0x92, 0x98, 0x96, 0x89, 0xe0, 0x30, 0xf9, 0x87, 0x47, 0x3b, 0xf6, + 0x9a, 0xb3, 0x9e, 0x1f, 0x47, 0x71, 0x38, 0xbb, 0xec, 0xc7, 0xb7, 0x43, 0x2e, 0xaf, 0x69, 0x21, + 0x1a, 0x14, 0x2d, 0xac, 0xd1, 0x95, 0x8e, 0xad, 0xac, 0x8d, 0x41, 0xf3, 0xfd, 0x7d, 0x55, 0x94, + 0x63, 0x85, 0x61, 0xbf, 0xcc, 0xae, 0x12, 0x36, 0x40, 0x47, 0x8b, 0x9e, 0xf0, 0xb5, 0x92, 0x1a, + 0x5a, 0xf6, 0xf8, 0x56, 0xd5, 0x63, 0x34, 0x74, 0x3f, 0xb9, 0x69, 0xc3, 0xba, 0x7b, 0x4f, 0x12, + 0xc8, 0x01, 0x7d, 0x7b, 0x87, 0x59, 0xc6, 0x73, 0x3d, 0xae, 0x80, 0x23, 0x18, 0x62, 0xb0, 0x20, + 0xe5, 0x2c, 0x84, 0xf3, 0x72, 0x4d, 0x2c, 0x72, 0x2d, 0x48, 0xb9, 0x00, 0xe0, 0x04, 0x07, 0x5d, + 0x15, 0xd2, 0xfe, 0x80, 0x91, 0xaa, 0x50, 0x4a, 0xfb, 0xf2, 0xf3, 0x35, 0x71, 0xff, 0x79, 0x18, + 0x51, 0x29, 0x0b, 0x6b, 0x3c, 0xf3, 0x9b, 0x08, 0x95, 0xb3, 0x98, 0x14, 0x63, 0x1d, 0x07, 0xad, + 0xc1, 0x44, 0xc4, 0x55, 0x3d, 0x2a, 0x22, 0x22, 0x57, 0x99, 0x7d, 0x52, 0x9a, 0x73, 0xd4, 0x4d, + 0xf0, 0x21, 0x2b, 0xe2, 0x47, 0x87, 0xf4, 0x4e, 0x4d, 0x93, 0x40, 0xaf, 0xc3, 0x78, 0x33, 0x70, + 0xdc, 0x79, 0xa7, 0xe9, 0xf8, 0x0d, 0xf6, 0xbd, 0x25, 0x33, 0xd3, 0xd3, 0x2d, 0x03, 0x8a, 0x53, + 0xd8, 0x94, 0x31, 0xd3, 0x4b, 0x44, 0x14, 0x4f, 0xc7, 0xdf, 0x24, 0x91, 0x48, 0xb8, 0xc6, 0x18, + 0xb3, 0x5b, 0x39, 0x38, 0x38, 0xb7, 0x36, 0x7a, 0x05, 0x46, 0xe5, 0xe7, 0x6b, 0xbe, 0xd7, 0x89, + 0xed, 0xbd, 0x06, 0xc3, 0x06, 0x26, 0xba, 0x0f, 0x67, 0xe4, 0xff, 0xb5, 0xd0, 0xd9, 0xd8, 0xf0, + 0x1a, 0xc2, 0x97, 0x8f, 0x3b, 0x20, 0xcd, 0x49, 0x8f, 0xa6, 0xc5, 0x2c, 0xa4, 0xc3, 0xfd, 0xca, + 0x25, 0x31, 0x6a, 0x99, 0x70, 0x36, 0x89, 0xd9, 0xf4, 0xd1, 0x0a, 0x9c, 0xda, 0x22, 0x4e, 0x33, + 0xde, 0x5a, 0xd8, 0x22, 0x8d, 0x6d, 0xb9, 0x89, 0x98, 0x47, 0xb7, 0x66, 0xb1, 0x7e, 0xa3, 0x13, + 0x05, 0x67, 0xd5, 0x43, 0x6f, 0xc3, 0x74, 0xab, 0xbd, 0xde, 0xf4, 0xa2, 0xad, 0xd5, 0x20, 0x66, + 0x16, 0x24, 0x2a, 0xe3, 0x9f, 0x70, 0xfd, 0x56, 0xde, 0xec, 0xb5, 0x1c, 0x3c, 0x9c, 0x4b, 0x01, + 0xbd, 0x0f, 0x67, 0x52, 0x8b, 0x41, 0x38, 0xa2, 0x8e, 0xe7, 0xc7, 0x44, 0xae, 0x67, 0x55, 0x10, + 0x8e, 0xa5, 0x59, 0x20, 0x9c, 0xdd, 0xc4, 0x07, 0xb3, 0x2b, 0x7a, 0x8f, 0x56, 0xd6, 0x98, 0x32, + 0xf4, 0x0e, 0x8c, 0xea, 0xab, 0x48, 0x5c, 0x30, 0x97, 0xb3, 0x79, 0x16, 0x6d, 0xb5, 0x71, 0x96, + 0x4e, 0xad, 0x28, 0x1d, 0x86, 0x0d, 0x8a, 0x36, 0x81, 0xec, 0xef, 0x43, 0xb7, 0xa0, 0xd4, 0x68, + 0x7a, 0xc4, 0x8f, 0x97, 0x6b, 0xdd, 0x02, 0xb3, 0x2c, 0x08, 0x1c, 0x31, 0x60, 0x22, 0x88, 0x2c, + 0x2f, 0xc3, 0x8a, 0x82, 0xfd, 0x6b, 0x05, 0xa8, 0xf4, 0x88, 0x48, 0x9c, 0x52, 0x7f, 0x5b, 0x7d, + 0xa9, 0xbf, 0xe7, 0x64, 0xfe, 0xc2, 0xd5, 0x94, 0x4e, 0x20, 0x95, 0x9b, 0x30, 0xd1, 0x0c, 0xa4, + 0xf1, 0xfb, 0x36, 0x47, 0xd6, 0x35, 0xe8, 0x03, 0x3d, 0x0d, 0xea, 0x8d, 0x97, 0xb3, 0xc1, 0xfe, + 0x05, 0x91, 0xdc, 0x57, 0x10, 0xfb, 0xab, 0x05, 0x38, 0xa3, 0x86, 0xf0, 0x1b, 0x77, 0xe0, 0xee, + 0x74, 0x0e, 0xdc, 0x31, 0xbc, 0x21, 0xd9, 0xb7, 0x61, 0x88, 0x07, 0xb6, 0xe9, 0x83, 0x01, 0x7a, + 0xd2, 0x8c, 0x82, 0xa6, 0xae, 0x69, 0x23, 0x12, 0xda, 0x5f, 0xb1, 0x60, 0x62, 0x6d, 0xa1, 0x56, + 0x0f, 0x1a, 0xdb, 0x24, 0x9e, 0xe3, 0x0c, 0x2b, 0x16, 0xfc, 0x8f, 0xf5, 0x90, 0x7c, 0x4d, 0x16, + 0xc7, 0x74, 0x09, 0x06, 0xb6, 0x82, 0x28, 0x4e, 0x3f, 0x30, 0xdf, 0x08, 0xa2, 0x18, 0x33, 0x88, + 0xfd, 0x3b, 0x16, 0x0c, 0xb2, 0xac, 0xbb, 0xbd, 0x52, 0x41, 0xf7, 0xf3, 0x5d, 0xe8, 0x25, 0x18, + 0x22, 0x1b, 0x1b, 0xa4, 0x11, 0x8b, 0x59, 0x95, 0x5e, 0xb2, 0x43, 0x8b, 0xac, 0x94, 0x5e, 0xfa, + 0xac, 0x31, 0xfe, 0x17, 0x0b, 0x64, 0x74, 0x0f, 0xca, 0xb1, 0xb7, 0x43, 0xe6, 0x5c, 0x57, 0x3c, + 0xd1, 0x3d, 0x84, 0x53, 0xf2, 0x9a, 0x24, 0x80, 0x13, 0x5a, 0xf6, 0x57, 0x0a, 0x00, 0x49, 0xbc, + 0x84, 0x5e, 0x9f, 0x38, 0xdf, 0xf1, 0x78, 0x73, 0x39, 0xe3, 0xf1, 0x06, 0x25, 0x04, 0x33, 0x5e, + 0x6e, 0xd4, 0x30, 0x15, 0xfb, 0x1a, 0xa6, 0x81, 0xa3, 0x0c, 0xd3, 0x02, 0x4c, 0x25, 0xf1, 0x1e, + 0xcc, 0xe0, 0x37, 0x4c, 0x48, 0x59, 0x4b, 0x03, 0x71, 0x27, 0xbe, 0x4d, 0xe0, 0x92, 0x8c, 0x7a, + 0x2a, 0xef, 0x1a, 0x66, 0x01, 0x7a, 0x84, 0xac, 0xe0, 0xc9, 0xeb, 0x54, 0x21, 0xf7, 0x75, 0xea, + 0xc7, 0x2d, 0x38, 0x9d, 0x6e, 0x87, 0xb9, 0xe4, 0x7d, 0xd9, 0x82, 0x33, 0xec, 0x8d, 0x8e, 0xb5, + 0xda, 0xf9, 0x22, 0xf8, 0x62, 0x76, 0x1c, 0x8c, 0xee, 0x3d, 0x4e, 0xdc, 0xb1, 0x57, 0xb2, 0x48, + 0xe3, 0xec, 0x16, 0xed, 0x2f, 0x5b, 0x70, 0x2e, 0x37, 0xd9, 0x13, 0xba, 0x02, 0x25, 0xa7, 0xe5, + 0x71, 0x05, 0x98, 0xd8, 0xef, 0x4c, 0x7a, 0xac, 0x2d, 0x73, 0xf5, 0x97, 0x82, 0xaa, 0x24, 0x94, + 0x85, 0xdc, 0x24, 0x94, 0x3d, 0x73, 0x4a, 0xda, 0xdf, 0x67, 0x81, 0xf0, 0xc2, 0xea, 0xe3, 0x90, + 0x79, 0x4b, 0xe6, 0xf0, 0x35, 0x02, 0xce, 0x5f, 0xca, 0x77, 0x4b, 0x13, 0x61, 0xe6, 0xd5, 0xa5, + 0x6e, 0x04, 0x97, 0x37, 0x68, 0xd9, 0x2e, 0x08, 0x68, 0x95, 0x30, 0x9d, 0x55, 0xef, 0xde, 0x5c, + 0x03, 0x70, 0x19, 0xae, 0x96, 0xc9, 0x53, 0x5d, 0x21, 0x55, 0x05, 0xc1, 0x1a, 0x96, 0xfd, 0xef, + 0x0a, 0x30, 0x22, 0x03, 0x9c, 0xb7, 0xfd, 0x7e, 0x24, 0xcb, 0x23, 0x65, 0x3c, 0x62, 0xa9, 0x6f, + 0x29, 0xe1, 0x5a, 0x22, 0x90, 0x27, 0xa9, 0x6f, 0x25, 0x00, 0x27, 0x38, 0xe8, 0x69, 0x18, 0x8e, + 0xda, 0xeb, 0x0c, 0x3d, 0xe5, 0x33, 0x54, 0xe7, 0xc5, 0x58, 0xc2, 0xd1, 0xe7, 0x60, 0x92, 0xd7, + 0x0b, 0x83, 0x96, 0xb3, 0xc9, 0xb5, 0xad, 0x83, 0xca, 0xd9, 0x77, 0x72, 0x25, 0x05, 0x3b, 0xdc, + 0xaf, 0x9c, 0x4e, 0x97, 0x31, 0x3d, 0x7d, 0x07, 0x15, 0xf6, 0xf6, 0xcf, 0x1b, 0xa1, 0xcb, 0xb4, + 0xc3, 0x64, 0x20, 0x01, 0x61, 0x1d, 0xcf, 0x7e, 0x07, 0x50, 0x67, 0xa8, 0x77, 0xf4, 0x06, 0x37, + 0xf8, 0xf2, 0x42, 0xe2, 0x76, 0xd3, 0xdb, 0xeb, 0x2e, 0xad, 0xd2, 0xdc, 0x9f, 0xd7, 0xc2, 0xaa, + 0xbe, 0xfd, 0xd7, 0x8a, 0x30, 0x99, 0x76, 0x70, 0x44, 0x37, 0x60, 0x88, 0xdf, 0x91, 0x82, 0x7c, + 0x97, 0x67, 0x61, 0xcd, 0x2d, 0x92, 0x9d, 0x16, 0xe2, 0x9a, 0x15, 0xf5, 0xd1, 0xdb, 0x30, 0xe2, + 0x06, 0xf7, 0xfd, 0xfb, 0x4e, 0xe8, 0xce, 0xd5, 0x96, 0xc5, 0x72, 0xce, 0x64, 0xb5, 0xab, 0x09, + 0x9a, 0xee, 0x6a, 0xc9, 0x9e, 0x40, 0x12, 0x10, 0xd6, 0xc9, 0xa1, 0x35, 0x16, 0xbe, 0x72, 0xc3, + 0xdb, 0x5c, 0x71, 0x5a, 0xdd, 0xac, 0x7f, 0x17, 0x24, 0x92, 0x46, 0x79, 0x4c, 0xc4, 0xb8, 0xe4, + 0x00, 0x9c, 0x10, 0x42, 0xdf, 0x09, 0xa7, 0xa2, 0x1c, 0xed, 0x5c, 0x5e, 0xe6, 0x8f, 0x6e, 0x0a, + 0xab, 0xf9, 0xc7, 0xa8, 0x10, 0x94, 0xa5, 0xc7, 0xcb, 0x6a, 0xc6, 0xfe, 0xf5, 0x53, 0x60, 0x6c, + 0x62, 0x23, 0x11, 0x94, 0x75, 0x4c, 0x89, 0xa0, 0x30, 0x94, 0xc8, 0x4e, 0x2b, 0xde, 0xab, 0x7a, + 0x61, 0xb7, 0x44, 0x85, 0x8b, 0x02, 0xa7, 0x93, 0xa6, 0x84, 0x60, 0x45, 0x27, 0x3b, 0x5b, 0x57, + 0xf1, 0x43, 0xcc, 0xd6, 0x35, 0x70, 0x82, 0xd9, 0xba, 0x56, 0x61, 0x78, 0xd3, 0x8b, 0x31, 0x69, + 0x05, 0x82, 0x3b, 0xcd, 0x5c, 0x87, 0xd7, 0x39, 0x4a, 0x67, 0x5e, 0x18, 0x01, 0xc0, 0x92, 0x08, + 0x7a, 0x43, 0xed, 0xc0, 0xa1, 0x7c, 0xe1, 0xae, 0xf3, 0xfd, 0x32, 0x73, 0x0f, 0x8a, 0x9c, 0x5c, + 0xc3, 0x0f, 0x9b, 0x93, 0x6b, 0x49, 0x66, 0xd2, 0x2a, 0xe5, 0x9b, 0xea, 0xb3, 0x44, 0x59, 0x3d, + 0xf2, 0x67, 0xdd, 0xd5, 0xb3, 0x8f, 0x95, 0xf3, 0x4f, 0x02, 0x95, 0x58, 0xac, 0xcf, 0x9c, 0x63, + 0xdf, 0x67, 0xc1, 0x99, 0x56, 0x56, 0x22, 0x3e, 0xf1, 0xd6, 0xf4, 0x52, 0xdf, 0x99, 0x06, 0x8d, + 0x06, 0x99, 0x94, 0x9f, 0x89, 0x86, 0xb3, 0x9b, 0xa3, 0x03, 0x1d, 0xae, 0xbb, 0x22, 0x69, 0xd6, + 0x93, 0x39, 0xc9, 0xcb, 0xba, 0xa4, 0x2c, 0x5b, 0xcb, 0x48, 0x94, 0xf5, 0xf1, 0xbc, 0x44, 0x59, + 0x7d, 0xa7, 0xc7, 0x7a, 0x43, 0xa5, 0x2d, 0x1b, 0xcb, 0x5f, 0x4a, 0x3c, 0x29, 0x59, 0xcf, 0x64, + 0x65, 0x6f, 0xa8, 0x64, 0x65, 0x5d, 0xe2, 0xea, 0xf1, 0x54, 0x64, 0x3d, 0x53, 0x94, 0x69, 0x69, + 0xc6, 0x26, 0x8e, 0x27, 0xcd, 0x98, 0x71, 0xd5, 0xf0, 0x4c, 0x57, 0xcf, 0xf4, 0xb8, 0x6a, 0x0c, + 0xba, 0xdd, 0x2f, 0x1b, 0x9e, 0x52, 0x6d, 0xea, 0xa1, 0x52, 0xaa, 0xdd, 0xd5, 0x53, 0x94, 0xa1, + 0x1e, 0x39, 0xb8, 0x28, 0x52, 0x9f, 0x89, 0xc9, 0xee, 0xea, 0x17, 0xe0, 0xa9, 0x7c, 0xba, 0xea, + 0x9e, 0xeb, 0xa4, 0x9b, 0x79, 0x05, 0x76, 0x24, 0x3c, 0x3b, 0x7d, 0x32, 0x09, 0xcf, 0xce, 0x1c, + 0x7b, 0xc2, 0xb3, 0xb3, 0x27, 0x90, 0xf0, 0xec, 0xb1, 0x0f, 0x35, 0xe1, 0xd9, 0xf4, 0x23, 0x48, + 0x78, 0xb6, 0x9a, 0x24, 0x3c, 0x3b, 0x97, 0x3f, 0x25, 0x19, 0xf6, 0xc3, 0x39, 0x69, 0xce, 0xee, + 0x32, 0x23, 0x02, 0x1e, 0x81, 0x43, 0x04, 0xfe, 0xcb, 0x4e, 0xee, 0x9c, 0x15, 0xa6, 0x83, 0x4f, + 0x89, 0x02, 0xe1, 0x84, 0x14, 0xa5, 0x9b, 0xa4, 0x3d, 0x7b, 0xbc, 0x8b, 0x1e, 0x37, 0x4b, 0x43, + 0xd6, 0x25, 0xd9, 0xd9, 0xeb, 0x3c, 0xd9, 0xd9, 0xf9, 0xfc, 0x93, 0x3c, 0x7d, 0xdd, 0x99, 0x29, + 0xce, 0xbe, 0xbf, 0x00, 0x17, 0xbb, 0xef, 0x8b, 0x44, 0x3d, 0x57, 0x4b, 0x9e, 0x93, 0x52, 0xea, + 0x39, 0x2e, 0x5b, 0x25, 0x58, 0x7d, 0x87, 0x39, 0xba, 0x0e, 0x53, 0xca, 0xf0, 0xb8, 0xe9, 0x35, + 0xf6, 0xb4, 0xa4, 0xd1, 0xca, 0xc1, 0xb2, 0x9e, 0x46, 0xc0, 0x9d, 0x75, 0xd0, 0x1c, 0x4c, 0x18, + 0x85, 0xcb, 0x55, 0x21, 0x43, 0x29, 0x7d, 0x60, 0xdd, 0x04, 0xe3, 0x34, 0xbe, 0xfd, 0xd3, 0x16, + 0x3c, 0x96, 0x93, 0x4b, 0xa4, 0xef, 0x28, 0x3e, 0x1b, 0x30, 0xd1, 0x32, 0xab, 0xf6, 0x08, 0xf6, + 0x65, 0x64, 0x2c, 0x51, 0x7d, 0x4d, 0x01, 0x70, 0x9a, 0xa8, 0xfd, 0x55, 0x0b, 0x2e, 0x74, 0x35, + 0x42, 0x41, 0x18, 0xce, 0x6e, 0xee, 0x44, 0xce, 0x42, 0x48, 0x5c, 0xe2, 0xc7, 0x9e, 0xd3, 0xac, + 0xb7, 0x48, 0x43, 0x53, 0xb0, 0x32, 0x5b, 0x9f, 0xeb, 0x2b, 0xf5, 0xb9, 0x4e, 0x0c, 0x9c, 0x53, + 0x13, 0x2d, 0x01, 0xea, 0x84, 0x88, 0x19, 0x66, 0xd1, 0x1c, 0x3b, 0xe9, 0xe1, 0x8c, 0x1a, 0xf3, + 0x57, 0x7e, 0xf3, 0xf7, 0x2e, 0x7e, 0xec, 0xb7, 0x7e, 0xef, 0xe2, 0xc7, 0x7e, 0xfb, 0xf7, 0x2e, + 0x7e, 0xec, 0xbb, 0x0f, 0x2e, 0x5a, 0xbf, 0x79, 0x70, 0xd1, 0xfa, 0xad, 0x83, 0x8b, 0xd6, 0x6f, + 0x1f, 0x5c, 0xb4, 0x7e, 0xf7, 0xe0, 0xa2, 0xf5, 0x95, 0xdf, 0xbf, 0xf8, 0xb1, 0xb7, 0x0a, 0xbb, + 0xcf, 0xff, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe3, 0xc5, 0xa7, 0xa5, 0x2c, 0xed, 0x00, 0x00, } diff --git a/staging/src/k8s.io/api/core/v1/generated.proto b/staging/src/k8s.io/api/core/v1/generated.proto index 9f0dfa0257..bb88fb27cf 100644 --- a/staging/src/k8s.io/api/core/v1/generated.proto +++ b/staging/src/k8s.io/api/core/v1/generated.proto @@ -3208,6 +3208,13 @@ message PodSpec { // Optional: Defaults to true. // +optional optional bool enableServiceLinks = 30; + + // PreemptionPolicy is the Policy for preempting pods with lower priority. + // One of Never, PreemptLowerPriority. + // Defaults to PreemptLowerPriority if unset. + // This field is alpha-level and is only honored by servers that enable the NonPreemptingPriority feature. + // +optional + optional string preemptionPolicy = 31; } // PodStatus represents information about the status of a pod. Status may trail the actual diff --git a/staging/src/k8s.io/api/core/v1/types.go b/staging/src/k8s.io/api/core/v1/types.go index 2a0320d1a8..d014d0baf3 100644 --- a/staging/src/k8s.io/api/core/v1/types.go +++ b/staging/src/k8s.io/api/core/v1/types.go @@ -2046,6 +2046,16 @@ const ( PullIfNotPresent PullPolicy = "IfNotPresent" ) +// PreemptionPolicy describes a policy for if/when to preempt a pod. +type PreemptionPolicy string + +const ( + // PreemptLowerPriority means that pod can preempt other pods with lower priority. + PreemptLowerPriority PreemptionPolicy = "PreemptLowerPriority" + // PreemptNever means that pod never preempts other pods with lower priority. + PreemptNever PreemptionPolicy = "Never" +) + // TerminationMessagePolicy describes how termination messages are retrieved from a container. type TerminationMessagePolicy string @@ -2966,7 +2976,6 @@ type PodSpec struct { // configuration based on DNSPolicy. // +optional DNSConfig *PodDNSConfig `json:"dnsConfig,omitempty" protobuf:"bytes,26,opt,name=dnsConfig"` - // If specified, all readiness gates will be evaluated for pod readiness. // A pod is ready when all its containers are ready AND // all conditions specified in the readiness gates have status equal to "True" @@ -2986,6 +2995,12 @@ type PodSpec struct { // Optional: Defaults to true. // +optional EnableServiceLinks *bool `json:"enableServiceLinks,omitempty" protobuf:"varint,30,opt,name=enableServiceLinks"` + // PreemptionPolicy is the Policy for preempting pods with lower priority. + // One of Never, PreemptLowerPriority. + // Defaults to PreemptLowerPriority if unset. + // This field is alpha-level and is only honored by servers that enable the NonPreemptingPriority feature. + // +optional + PreemptionPolicy *PreemptionPolicy `json:"preemptionPolicy,omitempty" protobuf:"bytes,31,opt,name=preemptionPolicy"` } const ( 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 85691d91f7..c0489ca170 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 @@ -1556,6 +1556,7 @@ var map_PodSpec = map[string]string{ "readinessGates": "If specified, all readiness gates will be evaluated for pod readiness. A pod is ready when all its containers are ready AND all conditions specified in the readiness gates have status equal to \"True\" More info: https://git.k8s.io/enhancements/keps/sig-network/0007-pod-ready%2B%2B.md", "runtimeClassName": "RuntimeClassName refers to a RuntimeClass object in the node.k8s.io group, which should be used to run this pod. If no RuntimeClass resource matches the named class, the pod will not be run. If unset or empty, the \"legacy\" RuntimeClass will be used, which is an implicit class with an empty definition that uses the default runtime handler. More info: https://git.k8s.io/enhancements/keps/sig-node/runtime-class.md This is a beta feature as of Kubernetes v1.14.", "enableServiceLinks": "EnableServiceLinks indicates whether information about services should be injected into pod's environment variables, matching the syntax of Docker links. Optional: Defaults to true.", + "preemptionPolicy": "PreemptionPolicy is the Policy for preempting pods with lower priority. One of Never, PreemptLowerPriority. Defaults to PreemptLowerPriority if unset. This field is alpha-level and is only honored by servers that enable the NonPreemptingPriority feature.", } func (PodSpec) 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 db6d5a7130..114e1974cd 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 @@ -3628,6 +3628,11 @@ func (in *PodSpec) DeepCopyInto(out *PodSpec) { *out = new(bool) **out = **in } + if in.PreemptionPolicy != nil { + in, out := &in.PreemptionPolicy, &out.PreemptionPolicy + *out = new(PreemptionPolicy) + **out = **in + } return } diff --git a/staging/src/k8s.io/api/scheduling/v1/BUILD b/staging/src/k8s.io/api/scheduling/v1/BUILD index b29e257133..9343d81e6e 100644 --- a/staging/src/k8s.io/api/scheduling/v1/BUILD +++ b/staging/src/k8s.io/api/scheduling/v1/BUILD @@ -14,6 +14,7 @@ go_library( importpath = "k8s.io/api/scheduling/v1", visibility = ["//visibility:public"], deps = [ + "//staging/src/k8s.io/api/core/v1:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/runtime/schema:go_default_library", diff --git a/staging/src/k8s.io/api/scheduling/v1/generated.pb.go b/staging/src/k8s.io/api/scheduling/v1/generated.pb.go index 5adf978ef8..bed5f2f393 100644 --- a/staging/src/k8s.io/api/scheduling/v1/generated.pb.go +++ b/staging/src/k8s.io/api/scheduling/v1/generated.pb.go @@ -33,6 +33,8 @@ import proto "github.com/gogo/protobuf/proto" import fmt "fmt" import math "math" +import k8s_io_api_core_v1 "k8s.io/api/core/v1" + import strings "strings" import reflect "reflect" @@ -99,6 +101,12 @@ func (m *PriorityClass) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintGenerated(dAtA, i, uint64(len(m.Description))) i += copy(dAtA[i:], m.Description) + if m.PreemptionPolicy != nil { + dAtA[i] = 0x2a + i++ + i = encodeVarintGenerated(dAtA, i, uint64(len(*m.PreemptionPolicy))) + i += copy(dAtA[i:], *m.PreemptionPolicy) + } return i, nil } @@ -158,6 +166,10 @@ func (m *PriorityClass) Size() (n int) { n += 2 l = len(m.Description) n += 1 + l + sovGenerated(uint64(l)) + if m.PreemptionPolicy != nil { + l = len(*m.PreemptionPolicy) + n += 1 + l + sovGenerated(uint64(l)) + } return n } @@ -197,6 +209,7 @@ func (this *PriorityClass) String() string { `Value:` + fmt.Sprintf("%v", this.Value) + `,`, `GlobalDefault:` + fmt.Sprintf("%v", this.GlobalDefault) + `,`, `Description:` + fmt.Sprintf("%v", this.Description) + `,`, + `PreemptionPolicy:` + valueToStringGenerated(this.PreemptionPolicy) + `,`, `}`, }, "") return s @@ -347,6 +360,36 @@ func (m *PriorityClass) Unmarshal(dAtA []byte) error { } m.Description = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PreemptionPolicy", 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 > l { + return io.ErrUnexpectedEOF + } + s := k8s_io_api_core_v1.PreemptionPolicy(dAtA[iNdEx:postIndex]) + m.PreemptionPolicy = &s + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) @@ -589,33 +632,36 @@ func init() { } var fileDescriptorGenerated = []byte{ - // 442 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0x3f, 0x8b, 0xd4, 0x40, - 0x18, 0xc6, 0x33, 0x7b, 0x2e, 0xac, 0xb3, 0x2c, 0x68, 0x44, 0x08, 0x5b, 0xcc, 0x85, 0xb3, 0x30, - 0x8d, 0x33, 0xee, 0xa1, 0x22, 0x58, 0x19, 0x0f, 0x44, 0x38, 0x51, 0x52, 0x58, 0x88, 0x85, 0x93, - 0xe4, 0xbd, 0xec, 0xb8, 0x49, 0x26, 0xcc, 0x4c, 0x02, 0xd7, 0x59, 0x5b, 0xf9, 0x8d, 0x6c, 0xb7, - 0xbc, 0xf2, 0xaa, 0xc3, 0x8d, 0x5f, 0x44, 0xf2, 0xc7, 0xcb, 0xae, 0xe7, 0xe1, 0x75, 0x99, 0xe7, - 0x7d, 0x7e, 0xcf, 0x3b, 0x79, 0x18, 0xfc, 0x72, 0xf5, 0x5c, 0x53, 0x21, 0xd9, 0xaa, 0x0c, 0x41, - 0xe5, 0x60, 0x40, 0xb3, 0x0a, 0xf2, 0x58, 0x2a, 0xd6, 0x0f, 0x78, 0x21, 0x98, 0x8e, 0x96, 0x10, - 0x97, 0xa9, 0xc8, 0x13, 0x56, 0x2d, 0x58, 0x02, 0x39, 0x28, 0x6e, 0x20, 0xa6, 0x85, 0x92, 0x46, - 0xda, 0x4e, 0xe7, 0xa4, 0xbc, 0x10, 0x74, 0x70, 0xd2, 0x6a, 0x31, 0x7f, 0x94, 0x08, 0xb3, 0x2c, - 0x43, 0x1a, 0xc9, 0x8c, 0x25, 0x32, 0x91, 0xac, 0x05, 0xc2, 0xf2, 0xa4, 0x3d, 0xb5, 0x87, 0xf6, - 0xab, 0x0b, 0x9a, 0x3f, 0x19, 0x56, 0x66, 0x3c, 0x5a, 0x8a, 0x1c, 0xd4, 0x29, 0x2b, 0x56, 0x49, - 0x23, 0x68, 0x96, 0x81, 0xe1, 0xff, 0x58, 0x3f, 0x67, 0xd7, 0x51, 0xaa, 0xcc, 0x8d, 0xc8, 0xe0, - 0x0a, 0xf0, 0xec, 0x7f, 0x40, 0xf3, 0x13, 0x19, 0xff, 0x9b, 0x3b, 0xf8, 0x36, 0xc2, 0xb3, 0xf7, - 0x4a, 0x48, 0x25, 0xcc, 0xe9, 0xab, 0x94, 0x6b, 0x6d, 0x7f, 0xc6, 0x93, 0xe6, 0x56, 0x31, 0x37, - 0xdc, 0x41, 0x2e, 0xf2, 0xa6, 0x87, 0x8f, 0xe9, 0x50, 0xc6, 0x65, 0x38, 0x2d, 0x56, 0x49, 0x23, - 0x68, 0xda, 0xb8, 0x69, 0xb5, 0xa0, 0xef, 0xc2, 0x2f, 0x10, 0x99, 0xb7, 0x60, 0xb8, 0x6f, 0xaf, - 0x2f, 0xf6, 0xad, 0xfa, 0x62, 0x1f, 0x0f, 0x5a, 0x70, 0x99, 0x6a, 0x3f, 0xc0, 0xe3, 0x8a, 0xa7, - 0x25, 0x38, 0x23, 0x17, 0x79, 0x63, 0x7f, 0xd6, 0x9b, 0xc7, 0x1f, 0x1a, 0x31, 0xe8, 0x66, 0xf6, - 0x0b, 0x3c, 0x4b, 0x52, 0x19, 0xf2, 0xf4, 0x08, 0x4e, 0x78, 0x99, 0x1a, 0x67, 0xcf, 0x45, 0xde, - 0xc4, 0xbf, 0xdf, 0x9b, 0x67, 0xaf, 0xb7, 0x87, 0xc1, 0xae, 0xd7, 0x7e, 0x8a, 0xa7, 0x31, 0xe8, - 0x48, 0x89, 0xc2, 0x08, 0x99, 0x3b, 0xb7, 0x5c, 0xe4, 0xdd, 0xf6, 0xef, 0xf5, 0xe8, 0xf4, 0x68, - 0x18, 0x05, 0xdb, 0xbe, 0x83, 0x1f, 0x08, 0xdf, 0xdd, 0x29, 0xe3, 0x58, 0x68, 0x63, 0x7f, 0xba, - 0x52, 0x08, 0xbd, 0x59, 0x21, 0x0d, 0xdd, 0xd6, 0x71, 0xa7, 0xdf, 0x3c, 0xf9, 0xa3, 0x6c, 0x95, - 0x71, 0x8c, 0xc7, 0xc2, 0x40, 0xa6, 0x9d, 0x91, 0xbb, 0xe7, 0x4d, 0x0f, 0x1f, 0xd2, 0xeb, 0x1e, - 0x1e, 0xdd, 0xb9, 0xd9, 0xd0, 0xda, 0x9b, 0x86, 0x0e, 0xba, 0x10, 0xdf, 0x5b, 0x6f, 0x88, 0x75, - 0xb6, 0x21, 0xd6, 0xf9, 0x86, 0x58, 0x5f, 0x6b, 0x82, 0xd6, 0x35, 0x41, 0x67, 0x35, 0x41, 0xe7, - 0x35, 0x41, 0x3f, 0x6b, 0x82, 0xbe, 0xff, 0x22, 0xd6, 0xc7, 0x51, 0xb5, 0xf8, 0x1d, 0x00, 0x00, - 0xff, 0xff, 0x32, 0xe8, 0x23, 0x88, 0x24, 0x03, 0x00, 0x00, + // 488 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0x3f, 0x8f, 0xd3, 0x30, + 0x18, 0xc6, 0xeb, 0x1e, 0x95, 0x0e, 0x57, 0x95, 0x4a, 0x10, 0x52, 0xd4, 0x21, 0xad, 0x7a, 0x03, + 0x59, 0xb0, 0xe9, 0x09, 0x10, 0xd2, 0x4d, 0x84, 0x93, 0x10, 0xd2, 0x21, 0xaa, 0x0c, 0x0c, 0x88, + 0x01, 0x27, 0x79, 0x2f, 0x35, 0x4d, 0xe2, 0xc8, 0x76, 0x22, 0x75, 0xe3, 0x23, 0xf0, 0x8d, 0x58, + 0x3b, 0xde, 0x78, 0x53, 0x45, 0xc3, 0x47, 0x60, 0x63, 0x42, 0x49, 0xc3, 0xa5, 0x7f, 0xee, 0x04, + 0x5b, 0xfc, 0x3e, 0xcf, 0xef, 0xb1, 0xfd, 0x24, 0xc1, 0xaf, 0xe6, 0x2f, 0x15, 0xe1, 0x82, 0xce, + 0x33, 0x0f, 0x64, 0x02, 0x1a, 0x14, 0xcd, 0x21, 0x09, 0x84, 0xa4, 0xb5, 0xc0, 0x52, 0x4e, 0x95, + 0x3f, 0x83, 0x20, 0x8b, 0x78, 0x12, 0xd2, 0x7c, 0x42, 0x43, 0x48, 0x40, 0x32, 0x0d, 0x01, 0x49, + 0xa5, 0xd0, 0xc2, 0x30, 0x37, 0x4e, 0xc2, 0x52, 0x4e, 0x1a, 0x27, 0xc9, 0x27, 0x83, 0x27, 0x21, + 0xd7, 0xb3, 0xcc, 0x23, 0xbe, 0x88, 0x69, 0x28, 0x42, 0x41, 0x2b, 0xc0, 0xcb, 0x2e, 0xab, 0x55, + 0xb5, 0xa8, 0x9e, 0x36, 0x41, 0x83, 0xf1, 0xd6, 0x96, 0xbe, 0x90, 0x70, 0xcb, 0x66, 0x83, 0x67, + 0x8d, 0x27, 0x66, 0xfe, 0x8c, 0x27, 0x20, 0x17, 0x34, 0x9d, 0x87, 0xe5, 0x40, 0xd1, 0x18, 0x34, + 0xbb, 0x8d, 0xa2, 0x77, 0x51, 0x32, 0x4b, 0x34, 0x8f, 0xe1, 0x00, 0x78, 0xf1, 0x2f, 0xa0, 0xbc, + 0x68, 0xcc, 0xf6, 0xb9, 0xf1, 0xaf, 0x36, 0xee, 0x4d, 0x25, 0x17, 0x92, 0xeb, 0xc5, 0xeb, 0x88, + 0x29, 0x65, 0x7c, 0xc6, 0xc7, 0xe5, 0xa9, 0x02, 0xa6, 0x99, 0x89, 0x46, 0xc8, 0xee, 0x9e, 0x3e, + 0x25, 0x4d, 0x61, 0x37, 0xe1, 0x24, 0x9d, 0x87, 0xe5, 0x40, 0x91, 0xd2, 0x4d, 0xf2, 0x09, 0x79, + 0xef, 0x7d, 0x01, 0x5f, 0xbf, 0x03, 0xcd, 0x1c, 0x63, 0xb9, 0x1a, 0xb6, 0x8a, 0xd5, 0x10, 0x37, + 0x33, 0xf7, 0x26, 0xd5, 0x38, 0xc1, 0x9d, 0x9c, 0x45, 0x19, 0x98, 0xed, 0x11, 0xb2, 0x3b, 0x4e, + 0xaf, 0x36, 0x77, 0x3e, 0x94, 0x43, 0x77, 0xa3, 0x19, 0x67, 0xb8, 0x17, 0x46, 0xc2, 0x63, 0xd1, + 0x39, 0x5c, 0xb2, 0x2c, 0xd2, 0xe6, 0xd1, 0x08, 0xd9, 0xc7, 0xce, 0xa3, 0xda, 0xdc, 0x7b, 0xb3, + 0x2d, 0xba, 0xbb, 0x5e, 0xe3, 0x39, 0xee, 0x06, 0xa0, 0x7c, 0xc9, 0x53, 0xcd, 0x45, 0x62, 0xde, + 0x1b, 0x21, 0xfb, 0xbe, 0xf3, 0xb0, 0x46, 0xbb, 0xe7, 0x8d, 0xe4, 0x6e, 0xfb, 0x8c, 0x10, 0xf7, + 0x53, 0x09, 0x10, 0x57, 0xab, 0xa9, 0x88, 0xb8, 0xbf, 0x30, 0x3b, 0x15, 0x7b, 0x56, 0xac, 0x86, + 0xfd, 0xe9, 0x9e, 0xf6, 0x7b, 0x35, 0x3c, 0x39, 0xfc, 0x02, 0xc8, 0xbe, 0xcd, 0x3d, 0x08, 0x1d, + 0x7f, 0x47, 0xf8, 0xc1, 0x4e, 0xeb, 0x17, 0x5c, 0x69, 0xe3, 0xd3, 0x41, 0xf3, 0xe4, 0xff, 0x9a, + 0x2f, 0xe9, 0xaa, 0xf7, 0x7e, 0x7d, 0xc5, 0xe3, 0xbf, 0x93, 0xad, 0xd6, 0x2f, 0x70, 0x87, 0x6b, + 0x88, 0x95, 0xd9, 0x1e, 0x1d, 0xd9, 0xdd, 0xd3, 0xc7, 0xe4, 0xae, 0xbf, 0x80, 0xec, 0x9c, 0xac, + 0x79, 0x3d, 0x6f, 0x4b, 0xda, 0xdd, 0x84, 0x38, 0xf6, 0x72, 0x6d, 0xb5, 0xae, 0xd6, 0x56, 0xeb, + 0x7a, 0x6d, 0xb5, 0xbe, 0x16, 0x16, 0x5a, 0x16, 0x16, 0xba, 0x2a, 0x2c, 0x74, 0x5d, 0x58, 0xe8, + 0x47, 0x61, 0xa1, 0x6f, 0x3f, 0xad, 0xd6, 0xc7, 0x76, 0x3e, 0xf9, 0x13, 0x00, 0x00, 0xff, 0xff, + 0x53, 0xd9, 0x28, 0x30, 0xb1, 0x03, 0x00, 0x00, } diff --git a/staging/src/k8s.io/api/scheduling/v1/generated.proto b/staging/src/k8s.io/api/scheduling/v1/generated.proto index 791ba8dc79..ada9eaf85b 100644 --- a/staging/src/k8s.io/api/scheduling/v1/generated.proto +++ b/staging/src/k8s.io/api/scheduling/v1/generated.proto @@ -21,6 +21,7 @@ syntax = 'proto2'; package k8s.io.api.scheduling.v1; +import "k8s.io/api/core/v1/generated.proto"; import "k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto"; import "k8s.io/apimachinery/pkg/runtime/generated.proto"; import "k8s.io/apimachinery/pkg/runtime/schema/generated.proto"; @@ -52,6 +53,13 @@ message PriorityClass { // when this priority class should be used. // +optional optional string description = 4; + + // PreemptionPolicy is the Policy for preempting pods with lower priority. + // One of Never, PreemptLowerPriority. + // Defaults to PreemptLowerPriority if unset. + // This field is alpha-level and is only honored by servers that enable the NonPreemptingPriority feature. + // +optional + optional string preemptionPolicy = 5; } // PriorityClassList is a collection of priority classes. diff --git a/staging/src/k8s.io/api/scheduling/v1/types.go b/staging/src/k8s.io/api/scheduling/v1/types.go index d33e0085aa..e91842ec4d 100644 --- a/staging/src/k8s.io/api/scheduling/v1/types.go +++ b/staging/src/k8s.io/api/scheduling/v1/types.go @@ -17,6 +17,7 @@ limitations under the License. package v1 import ( + apiv1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) @@ -49,6 +50,13 @@ type PriorityClass struct { // when this priority class should be used. // +optional Description string `json:"description,omitempty" protobuf:"bytes,4,opt,name=description"` + + // PreemptionPolicy is the Policy for preempting pods with lower priority. + // One of Never, PreemptLowerPriority. + // Defaults to PreemptLowerPriority if unset. + // This field is alpha-level and is only honored by servers that enable the NonPreemptingPriority feature. + // +optional + PreemptionPolicy *apiv1.PreemptionPolicy `json:"preemptionPolicy,omitempty" protobuf:"bytes,5,opt,name=preemptionPolicy"` } // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object diff --git a/staging/src/k8s.io/api/scheduling/v1/types_swagger_doc_generated.go b/staging/src/k8s.io/api/scheduling/v1/types_swagger_doc_generated.go index 6f3999a915..853f255d52 100644 --- a/staging/src/k8s.io/api/scheduling/v1/types_swagger_doc_generated.go +++ b/staging/src/k8s.io/api/scheduling/v1/types_swagger_doc_generated.go @@ -28,11 +28,12 @@ package v1 // AUTO-GENERATED FUNCTIONS START HERE. DO NOT EDIT. var map_PriorityClass = map[string]string{ - "": "PriorityClass defines mapping from a priority class name to the priority integer value. The value can be any valid integer.", - "metadata": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata", - "value": "The value of this priority class. This is the actual priority that pods receive when they have the name of this class in their pod spec.", - "globalDefault": "globalDefault specifies whether this PriorityClass should be considered as the default priority for pods that do not have any priority class. Only one PriorityClass can be marked as `globalDefault`. However, if more than one PriorityClasses exists with their `globalDefault` field set to true, the smallest value of such global default PriorityClasses will be used as the default priority.", - "description": "description is an arbitrary string that usually provides guidelines on when this priority class should be used.", + "": "PriorityClass defines mapping from a priority class name to the priority integer value. The value can be any valid integer.", + "metadata": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata", + "value": "The value of this priority class. This is the actual priority that pods receive when they have the name of this class in their pod spec.", + "globalDefault": "globalDefault specifies whether this PriorityClass should be considered as the default priority for pods that do not have any priority class. Only one PriorityClass can be marked as `globalDefault`. However, if more than one PriorityClasses exists with their `globalDefault` field set to true, the smallest value of such global default PriorityClasses will be used as the default priority.", + "description": "description is an arbitrary string that usually provides guidelines on when this priority class should be used.", + "preemptionPolicy": "PreemptionPolicy is the Policy for preempting pods with lower priority. One of Never, PreemptLowerPriority. Defaults to PreemptLowerPriority if unset. This field is alpha-level and is only honored by servers that enable the NonPreemptingPriority feature.", } func (PriorityClass) SwaggerDoc() map[string]string { diff --git a/staging/src/k8s.io/api/scheduling/v1/zz_generated.deepcopy.go b/staging/src/k8s.io/api/scheduling/v1/zz_generated.deepcopy.go index 106fc6e917..63bfe64042 100644 --- a/staging/src/k8s.io/api/scheduling/v1/zz_generated.deepcopy.go +++ b/staging/src/k8s.io/api/scheduling/v1/zz_generated.deepcopy.go @@ -21,6 +21,7 @@ limitations under the License. package v1 import ( + corev1 "k8s.io/api/core/v1" runtime "k8s.io/apimachinery/pkg/runtime" ) @@ -29,6 +30,11 @@ func (in *PriorityClass) DeepCopyInto(out *PriorityClass) { *out = *in out.TypeMeta = in.TypeMeta in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + if in.PreemptionPolicy != nil { + in, out := &in.PreemptionPolicy, &out.PreemptionPolicy + *out = new(corev1.PreemptionPolicy) + **out = **in + } return } diff --git a/staging/src/k8s.io/api/scheduling/v1alpha1/BUILD b/staging/src/k8s.io/api/scheduling/v1alpha1/BUILD index bcea964b4c..4a7c618f52 100644 --- a/staging/src/k8s.io/api/scheduling/v1alpha1/BUILD +++ b/staging/src/k8s.io/api/scheduling/v1alpha1/BUILD @@ -18,6 +18,7 @@ go_library( importmap = "k8s.io/kubernetes/vendor/k8s.io/api/scheduling/v1alpha1", importpath = "k8s.io/api/scheduling/v1alpha1", deps = [ + "//staging/src/k8s.io/api/core/v1:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/runtime/schema:go_default_library", diff --git a/staging/src/k8s.io/api/scheduling/v1alpha1/generated.pb.go b/staging/src/k8s.io/api/scheduling/v1alpha1/generated.pb.go index 0a0d481a28..3fedb7d602 100644 --- a/staging/src/k8s.io/api/scheduling/v1alpha1/generated.pb.go +++ b/staging/src/k8s.io/api/scheduling/v1alpha1/generated.pb.go @@ -33,6 +33,8 @@ import proto "github.com/gogo/protobuf/proto" import fmt "fmt" import math "math" +import k8s_io_api_core_v1 "k8s.io/api/core/v1" + import strings "strings" import reflect "reflect" @@ -99,6 +101,12 @@ func (m *PriorityClass) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintGenerated(dAtA, i, uint64(len(m.Description))) i += copy(dAtA[i:], m.Description) + if m.PreemptionPolicy != nil { + dAtA[i] = 0x2a + i++ + i = encodeVarintGenerated(dAtA, i, uint64(len(*m.PreemptionPolicy))) + i += copy(dAtA[i:], *m.PreemptionPolicy) + } return i, nil } @@ -158,6 +166,10 @@ func (m *PriorityClass) Size() (n int) { n += 2 l = len(m.Description) n += 1 + l + sovGenerated(uint64(l)) + if m.PreemptionPolicy != nil { + l = len(*m.PreemptionPolicy) + n += 1 + l + sovGenerated(uint64(l)) + } return n } @@ -197,6 +209,7 @@ func (this *PriorityClass) String() string { `Value:` + fmt.Sprintf("%v", this.Value) + `,`, `GlobalDefault:` + fmt.Sprintf("%v", this.GlobalDefault) + `,`, `Description:` + fmt.Sprintf("%v", this.Description) + `,`, + `PreemptionPolicy:` + valueToStringGenerated(this.PreemptionPolicy) + `,`, `}`, }, "") return s @@ -347,6 +360,36 @@ func (m *PriorityClass) Unmarshal(dAtA []byte) error { } m.Description = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PreemptionPolicy", 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 > l { + return io.ErrUnexpectedEOF + } + s := k8s_io_api_core_v1.PreemptionPolicy(dAtA[iNdEx:postIndex]) + m.PreemptionPolicy = &s + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) @@ -589,33 +632,36 @@ func init() { } var fileDescriptorGenerated = []byte{ - // 447 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0x4f, 0x8b, 0xd3, 0x40, - 0x18, 0xc6, 0x33, 0x5d, 0x0b, 0x75, 0x4a, 0x41, 0x23, 0x42, 0xe8, 0x61, 0x36, 0xac, 0x97, 0x5c, - 0x76, 0xc6, 0x2e, 0x2a, 0x82, 0xb7, 0xb8, 0xb0, 0x08, 0x8a, 0x92, 0x83, 0x07, 0xf1, 0xe0, 0x24, - 0x79, 0x37, 0x1d, 0x9b, 0x64, 0xc2, 0xcc, 0x24, 0xb0, 0x37, 0xcf, 0x9e, 0xfc, 0x52, 0x42, 0x8f, - 0x7b, 0xdc, 0xd3, 0x62, 0xe3, 0x17, 0x91, 0xa4, 0x69, 0xd3, 0x5a, 0xfc, 0x73, 0xcb, 0x3c, 0xef, - 0xef, 0x79, 0xe6, 0xcd, 0xc3, 0xe0, 0x8b, 0xc5, 0x73, 0x4d, 0x85, 0x64, 0x8b, 0x32, 0x04, 0x95, - 0x83, 0x01, 0xcd, 0x2a, 0xc8, 0x63, 0xa9, 0x58, 0x37, 0xe0, 0x85, 0x60, 0x3a, 0x9a, 0x43, 0x5c, - 0xa6, 0x22, 0x4f, 0x58, 0x35, 0xe3, 0x69, 0x31, 0xe7, 0x33, 0x96, 0x40, 0x0e, 0x8a, 0x1b, 0x88, - 0x69, 0xa1, 0xa4, 0x91, 0x36, 0x59, 0xf3, 0x94, 0x17, 0x82, 0xf6, 0x3c, 0xdd, 0xf0, 0xd3, 0xd3, - 0x44, 0x98, 0x79, 0x19, 0xd2, 0x48, 0x66, 0x2c, 0x91, 0x89, 0x64, 0xad, 0x2d, 0x2c, 0x2f, 0xdb, - 0x53, 0x7b, 0x68, 0xbf, 0xd6, 0x71, 0xd3, 0x27, 0xfd, 0xf5, 0x19, 0x8f, 0xe6, 0x22, 0x07, 0x75, - 0xc5, 0x8a, 0x45, 0xd2, 0x08, 0x9a, 0x65, 0x60, 0x38, 0xab, 0x0e, 0x96, 0x98, 0xb2, 0x3f, 0xb9, - 0x54, 0x99, 0x1b, 0x91, 0xc1, 0x81, 0xe1, 0xd9, 0xbf, 0x0c, 0xcd, 0xaf, 0x64, 0xfc, 0x77, 0xdf, - 0xc9, 0xd7, 0x01, 0x9e, 0xbc, 0x53, 0x42, 0x2a, 0x61, 0xae, 0x5e, 0xa6, 0x5c, 0x6b, 0xfb, 0x13, - 0x1e, 0x35, 0x5b, 0xc5, 0xdc, 0x70, 0x07, 0xb9, 0xc8, 0x1b, 0x9f, 0x3d, 0xa6, 0x7d, 0x25, 0xdb, - 0x70, 0x5a, 0x2c, 0x92, 0x46, 0xd0, 0xb4, 0xa1, 0x69, 0x35, 0xa3, 0x6f, 0xc3, 0xcf, 0x10, 0x99, - 0x37, 0x60, 0xb8, 0x6f, 0x2f, 0x6f, 0x8f, 0xad, 0xfa, 0xf6, 0x18, 0xf7, 0x5a, 0xb0, 0x4d, 0xb5, - 0x1f, 0xe1, 0x61, 0xc5, 0xd3, 0x12, 0x9c, 0x81, 0x8b, 0xbc, 0xa1, 0x3f, 0xe9, 0xe0, 0xe1, 0xfb, - 0x46, 0x0c, 0xd6, 0x33, 0xfb, 0x05, 0x9e, 0x24, 0xa9, 0x0c, 0x79, 0x7a, 0x0e, 0x97, 0xbc, 0x4c, - 0x8d, 0x73, 0xe4, 0x22, 0x6f, 0xe4, 0x3f, 0xec, 0xe0, 0xc9, 0xc5, 0xee, 0x30, 0xd8, 0x67, 0xed, - 0xa7, 0x78, 0x1c, 0x83, 0x8e, 0x94, 0x28, 0x8c, 0x90, 0xb9, 0x73, 0xc7, 0x45, 0xde, 0x5d, 0xff, - 0x41, 0x67, 0x1d, 0x9f, 0xf7, 0xa3, 0x60, 0x97, 0x3b, 0xf9, 0x8e, 0xf0, 0xfd, 0xbd, 0x32, 0x5e, - 0x0b, 0x6d, 0xec, 0x8f, 0x07, 0x85, 0xd0, 0xff, 0x2b, 0xa4, 0x71, 0xb7, 0x75, 0xdc, 0xeb, 0x6e, - 0x1e, 0x6d, 0x94, 0x9d, 0x32, 0x02, 0x3c, 0x14, 0x06, 0x32, 0xed, 0x0c, 0xdc, 0x23, 0x6f, 0x7c, - 0x76, 0x4a, 0xff, 0xfe, 0xfc, 0xe8, 0xde, 0x7e, 0x7d, 0x77, 0xaf, 0x9a, 0x8c, 0x60, 0x1d, 0xe5, - 0xd3, 0xe5, 0x8a, 0x58, 0xd7, 0x2b, 0x62, 0xdd, 0xac, 0x88, 0xf5, 0xa5, 0x26, 0x68, 0x59, 0x13, - 0x74, 0x5d, 0x13, 0x74, 0x53, 0x13, 0xf4, 0xa3, 0x26, 0xe8, 0xdb, 0x4f, 0x62, 0x7d, 0x18, 0x6d, - 0x32, 0x7f, 0x05, 0x00, 0x00, 0xff, 0xff, 0xab, 0x20, 0x12, 0x63, 0x3c, 0x03, 0x00, 0x00, + // 494 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0x4f, 0x8b, 0xd3, 0x40, + 0x18, 0xc6, 0x3b, 0x5d, 0x0b, 0x75, 0x4a, 0xa1, 0x46, 0x84, 0xd0, 0xc3, 0xb4, 0x74, 0x2f, 0xbd, + 0xec, 0x8c, 0x5d, 0x54, 0x84, 0xbd, 0xd5, 0x85, 0x45, 0x50, 0x2c, 0x39, 0x78, 0x10, 0x0f, 0x4e, + 0xd3, 0x77, 0xd3, 0xb1, 0x49, 0x26, 0xcc, 0x4c, 0x02, 0xbd, 0xf9, 0x11, 0xfc, 0x52, 0x42, 0x8f, + 0x7b, 0xdc, 0x53, 0xb1, 0xf1, 0x23, 0x78, 0xf3, 0x24, 0x49, 0xd3, 0x4d, 0xdb, 0xf8, 0x67, 0x6f, + 0x99, 0xf7, 0xf9, 0x3d, 0xcf, 0xcc, 0x3c, 0x49, 0xf0, 0xd5, 0xe2, 0xa5, 0xa6, 0x42, 0xb2, 0x45, + 0x3c, 0x05, 0x15, 0x82, 0x01, 0xcd, 0x12, 0x08, 0x67, 0x52, 0xb1, 0x42, 0xe0, 0x91, 0x60, 0xda, + 0x9d, 0xc3, 0x2c, 0xf6, 0x45, 0xe8, 0xb1, 0x64, 0xc4, 0xfd, 0x68, 0xce, 0x47, 0xcc, 0x83, 0x10, + 0x14, 0x37, 0x30, 0xa3, 0x91, 0x92, 0x46, 0x5a, 0x64, 0xcb, 0x53, 0x1e, 0x09, 0x5a, 0xf2, 0x74, + 0xc7, 0x77, 0xcf, 0x3c, 0x61, 0xe6, 0xf1, 0x94, 0xba, 0x32, 0x60, 0x9e, 0xf4, 0x24, 0xcb, 0x6d, + 0xd3, 0xf8, 0x3a, 0x5f, 0xe5, 0x8b, 0xfc, 0x69, 0x1b, 0xd7, 0x1d, 0xec, 0x6d, 0xef, 0x4a, 0x05, + 0x2c, 0xa9, 0x6c, 0xd9, 0x7d, 0x56, 0x32, 0x01, 0x77, 0xe7, 0x22, 0x04, 0xb5, 0x64, 0xd1, 0xc2, + 0xcb, 0x06, 0x9a, 0x05, 0x60, 0xf8, 0x9f, 0x5c, 0xec, 0x6f, 0x2e, 0x15, 0x87, 0x46, 0x04, 0x50, + 0x31, 0xbc, 0xf8, 0x9f, 0x21, 0xbb, 0x6e, 0xc0, 0x8f, 0x7d, 0x83, 0x9f, 0x75, 0xdc, 0x9e, 0x28, + 0x21, 0x95, 0x30, 0xcb, 0x57, 0x3e, 0xd7, 0xda, 0xfa, 0x84, 0x9b, 0xd9, 0xa9, 0x66, 0xdc, 0x70, + 0x1b, 0xf5, 0xd1, 0xb0, 0x75, 0xfe, 0x94, 0x96, 0xb5, 0xdd, 0x85, 0xd3, 0x68, 0xe1, 0x65, 0x03, + 0x4d, 0x33, 0x9a, 0x26, 0x23, 0xfa, 0x6e, 0xfa, 0x19, 0x5c, 0xf3, 0x16, 0x0c, 0x1f, 0x5b, 0xab, + 0x75, 0xaf, 0x96, 0xae, 0x7b, 0xb8, 0x9c, 0x39, 0x77, 0xa9, 0xd6, 0x29, 0x6e, 0x24, 0xdc, 0x8f, + 0xc1, 0xae, 0xf7, 0xd1, 0xb0, 0x31, 0x6e, 0x17, 0x70, 0xe3, 0x7d, 0x36, 0x74, 0xb6, 0x9a, 0x75, + 0x81, 0xdb, 0x9e, 0x2f, 0xa7, 0xdc, 0xbf, 0x84, 0x6b, 0x1e, 0xfb, 0xc6, 0x3e, 0xe9, 0xa3, 0x61, + 0x73, 0xfc, 0xa4, 0x80, 0xdb, 0x57, 0xfb, 0xa2, 0x73, 0xc8, 0x5a, 0xcf, 0x71, 0x6b, 0x06, 0xda, + 0x55, 0x22, 0x32, 0x42, 0x86, 0xf6, 0x83, 0x3e, 0x1a, 0x3e, 0x1c, 0x3f, 0x2e, 0xac, 0xad, 0xcb, + 0x52, 0x72, 0xf6, 0x39, 0xcb, 0xc3, 0x9d, 0x48, 0x01, 0x04, 0xf9, 0x6a, 0x22, 0x7d, 0xe1, 0x2e, + 0xed, 0x46, 0xee, 0xbd, 0x48, 0xd7, 0xbd, 0xce, 0xe4, 0x48, 0xfb, 0xb5, 0xee, 0x9d, 0x56, 0xbf, + 0x00, 0x7a, 0x8c, 0x39, 0x95, 0xd0, 0xc1, 0x37, 0x84, 0x1f, 0x1d, 0xb4, 0xfe, 0x46, 0x68, 0x63, + 0x7d, 0xac, 0x34, 0x4f, 0xef, 0xd7, 0x7c, 0xe6, 0xce, 0x7b, 0xef, 0x14, 0x57, 0x6c, 0xee, 0x26, + 0x7b, 0xad, 0x3b, 0xb8, 0x21, 0x0c, 0x04, 0xda, 0xae, 0xf7, 0x4f, 0x86, 0xad, 0xf3, 0x33, 0xfa, + 0xef, 0x7f, 0x81, 0x1e, 0x9c, 0xaf, 0x7c, 0x49, 0xaf, 0xb3, 0x0c, 0x67, 0x1b, 0x35, 0xa6, 0xab, + 0x0d, 0xa9, 0xdd, 0x6c, 0x48, 0xed, 0x76, 0x43, 0x6a, 0x5f, 0x52, 0x82, 0x56, 0x29, 0x41, 0x37, + 0x29, 0x41, 0xb7, 0x29, 0x41, 0xdf, 0x53, 0x82, 0xbe, 0xfe, 0x20, 0xb5, 0x0f, 0xcd, 0x5d, 0xe6, + 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0x55, 0x5c, 0x1a, 0x39, 0xc9, 0x03, 0x00, 0x00, } diff --git a/staging/src/k8s.io/api/scheduling/v1alpha1/generated.proto b/staging/src/k8s.io/api/scheduling/v1alpha1/generated.proto index bfd85f5598..584a2918a2 100644 --- a/staging/src/k8s.io/api/scheduling/v1alpha1/generated.proto +++ b/staging/src/k8s.io/api/scheduling/v1alpha1/generated.proto @@ -21,6 +21,7 @@ syntax = 'proto2'; package k8s.io.api.scheduling.v1alpha1; +import "k8s.io/api/core/v1/generated.proto"; import "k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto"; import "k8s.io/apimachinery/pkg/runtime/generated.proto"; import "k8s.io/apimachinery/pkg/runtime/schema/generated.proto"; @@ -53,6 +54,13 @@ message PriorityClass { // when this priority class should be used. // +optional optional string description = 4; + + // PreemptionPolicy is the Policy for preempting pods with lower priority. + // One of Never, PreemptLowerPriority. + // Defaults to PreemptLowerPriority if unset. + // This field is alpha-level and is only honored by servers that enable the NonPreemptingPriority feature. + // +optional + optional string preemptionPolicy = 5; } // PriorityClassList is a collection of priority classes. diff --git a/staging/src/k8s.io/api/scheduling/v1alpha1/types.go b/staging/src/k8s.io/api/scheduling/v1alpha1/types.go index 6103ea4e7e..c1a09bce8e 100644 --- a/staging/src/k8s.io/api/scheduling/v1alpha1/types.go +++ b/staging/src/k8s.io/api/scheduling/v1alpha1/types.go @@ -17,6 +17,7 @@ limitations under the License. package v1alpha1 import ( + apiv1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) @@ -50,6 +51,13 @@ type PriorityClass struct { // when this priority class should be used. // +optional Description string `json:"description,omitempty" protobuf:"bytes,4,opt,name=description"` + + // PreemptionPolicy is the Policy for preempting pods with lower priority. + // One of Never, PreemptLowerPriority. + // Defaults to PreemptLowerPriority if unset. + // This field is alpha-level and is only honored by servers that enable the NonPreemptingPriority feature. + // +optional + PreemptionPolicy *apiv1.PreemptionPolicy `json:"preemptionPolicy,omitempty" protobuf:"bytes,5,opt,name=preemptionPolicy"` } // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object diff --git a/staging/src/k8s.io/api/scheduling/v1alpha1/types_swagger_doc_generated.go b/staging/src/k8s.io/api/scheduling/v1alpha1/types_swagger_doc_generated.go index 89565012f9..f9880922a1 100644 --- a/staging/src/k8s.io/api/scheduling/v1alpha1/types_swagger_doc_generated.go +++ b/staging/src/k8s.io/api/scheduling/v1alpha1/types_swagger_doc_generated.go @@ -28,11 +28,12 @@ package v1alpha1 // AUTO-GENERATED FUNCTIONS START HERE. DO NOT EDIT. var map_PriorityClass = map[string]string{ - "": "DEPRECATED - This group version of PriorityClass is deprecated by scheduling.k8s.io/v1/PriorityClass. PriorityClass defines mapping from a priority class name to the priority integer value. The value can be any valid integer.", - "metadata": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata", - "value": "The value of this priority class. This is the actual priority that pods receive when they have the name of this class in their pod spec.", - "globalDefault": "globalDefault specifies whether this PriorityClass should be considered as the default priority for pods that do not have any priority class. Only one PriorityClass can be marked as `globalDefault`. However, if more than one PriorityClasses exists with their `globalDefault` field set to true, the smallest value of such global default PriorityClasses will be used as the default priority.", - "description": "description is an arbitrary string that usually provides guidelines on when this priority class should be used.", + "": "DEPRECATED - This group version of PriorityClass is deprecated by scheduling.k8s.io/v1/PriorityClass. PriorityClass defines mapping from a priority class name to the priority integer value. The value can be any valid integer.", + "metadata": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata", + "value": "The value of this priority class. This is the actual priority that pods receive when they have the name of this class in their pod spec.", + "globalDefault": "globalDefault specifies whether this PriorityClass should be considered as the default priority for pods that do not have any priority class. Only one PriorityClass can be marked as `globalDefault`. However, if more than one PriorityClasses exists with their `globalDefault` field set to true, the smallest value of such global default PriorityClasses will be used as the default priority.", + "description": "description is an arbitrary string that usually provides guidelines on when this priority class should be used.", + "preemptionPolicy": "PreemptionPolicy is the Policy for preempting pods with lower priority. One of Never, PreemptLowerPriority. Defaults to PreemptLowerPriority if unset. This field is alpha-level and is only honored by servers that enable the NonPreemptingPriority feature.", } func (PriorityClass) SwaggerDoc() map[string]string { diff --git a/staging/src/k8s.io/api/scheduling/v1alpha1/zz_generated.deepcopy.go b/staging/src/k8s.io/api/scheduling/v1alpha1/zz_generated.deepcopy.go index 1d4e664c78..0392823975 100644 --- a/staging/src/k8s.io/api/scheduling/v1alpha1/zz_generated.deepcopy.go +++ b/staging/src/k8s.io/api/scheduling/v1alpha1/zz_generated.deepcopy.go @@ -21,6 +21,7 @@ limitations under the License. package v1alpha1 import ( + v1 "k8s.io/api/core/v1" runtime "k8s.io/apimachinery/pkg/runtime" ) @@ -29,6 +30,11 @@ func (in *PriorityClass) DeepCopyInto(out *PriorityClass) { *out = *in out.TypeMeta = in.TypeMeta in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + if in.PreemptionPolicy != nil { + in, out := &in.PreemptionPolicy, &out.PreemptionPolicy + *out = new(v1.PreemptionPolicy) + **out = **in + } return } diff --git a/staging/src/k8s.io/api/scheduling/v1beta1/BUILD b/staging/src/k8s.io/api/scheduling/v1beta1/BUILD index 148494529e..d1bb4e8aef 100644 --- a/staging/src/k8s.io/api/scheduling/v1beta1/BUILD +++ b/staging/src/k8s.io/api/scheduling/v1beta1/BUILD @@ -18,6 +18,7 @@ go_library( importmap = "k8s.io/kubernetes/vendor/k8s.io/api/scheduling/v1beta1", importpath = "k8s.io/api/scheduling/v1beta1", deps = [ + "//staging/src/k8s.io/api/core/v1:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/runtime/schema:go_default_library", diff --git a/staging/src/k8s.io/api/scheduling/v1beta1/generated.pb.go b/staging/src/k8s.io/api/scheduling/v1beta1/generated.pb.go index ddb285446b..58bbf835d7 100644 --- a/staging/src/k8s.io/api/scheduling/v1beta1/generated.pb.go +++ b/staging/src/k8s.io/api/scheduling/v1beta1/generated.pb.go @@ -33,6 +33,8 @@ import proto "github.com/gogo/protobuf/proto" import fmt "fmt" import math "math" +import k8s_io_api_core_v1 "k8s.io/api/core/v1" + import strings "strings" import reflect "reflect" @@ -99,6 +101,12 @@ func (m *PriorityClass) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintGenerated(dAtA, i, uint64(len(m.Description))) i += copy(dAtA[i:], m.Description) + if m.PreemptionPolicy != nil { + dAtA[i] = 0x2a + i++ + i = encodeVarintGenerated(dAtA, i, uint64(len(*m.PreemptionPolicy))) + i += copy(dAtA[i:], *m.PreemptionPolicy) + } return i, nil } @@ -158,6 +166,10 @@ func (m *PriorityClass) Size() (n int) { n += 2 l = len(m.Description) n += 1 + l + sovGenerated(uint64(l)) + if m.PreemptionPolicy != nil { + l = len(*m.PreemptionPolicy) + n += 1 + l + sovGenerated(uint64(l)) + } return n } @@ -197,6 +209,7 @@ func (this *PriorityClass) String() string { `Value:` + fmt.Sprintf("%v", this.Value) + `,`, `GlobalDefault:` + fmt.Sprintf("%v", this.GlobalDefault) + `,`, `Description:` + fmt.Sprintf("%v", this.Description) + `,`, + `PreemptionPolicy:` + valueToStringGenerated(this.PreemptionPolicy) + `,`, `}`, }, "") return s @@ -347,6 +360,36 @@ func (m *PriorityClass) Unmarshal(dAtA []byte) error { } m.Description = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PreemptionPolicy", 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 > l { + return io.ErrUnexpectedEOF + } + s := k8s_io_api_core_v1.PreemptionPolicy(dAtA[iNdEx:postIndex]) + m.PreemptionPolicy = &s + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) @@ -589,33 +632,36 @@ func init() { } var fileDescriptorGenerated = []byte{ - // 448 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xc1, 0x8b, 0xd3, 0x40, - 0x18, 0xc5, 0x33, 0x5d, 0x8b, 0x75, 0x4a, 0x41, 0x23, 0x42, 0x28, 0x38, 0x1b, 0xd6, 0x4b, 0x0e, - 0xee, 0x8c, 0x5d, 0x54, 0x04, 0x6f, 0x71, 0x51, 0x04, 0x45, 0xcd, 0xc1, 0x83, 0x78, 0x70, 0x92, - 0x7c, 0x9b, 0x8e, 0x4d, 0x32, 0x61, 0x66, 0x12, 0xd8, 0x9b, 0x67, 0x4f, 0xfe, 0x51, 0x1e, 0x7a, - 0xdc, 0xe3, 0x9e, 0x16, 0x1b, 0xff, 0x11, 0x49, 0x1a, 0x37, 0xad, 0x45, 0xdd, 0x5b, 0xe6, 0x7d, - 0xbf, 0xf7, 0xe6, 0xcb, 0x63, 0xf0, 0xf3, 0xc5, 0x13, 0x4d, 0x85, 0x64, 0x8b, 0x32, 0x04, 0x95, - 0x83, 0x01, 0xcd, 0x2a, 0xc8, 0x63, 0xa9, 0x58, 0x37, 0xe0, 0x85, 0x60, 0x3a, 0x9a, 0x43, 0x5c, - 0xa6, 0x22, 0x4f, 0x58, 0x35, 0x0b, 0xc1, 0xf0, 0x19, 0x4b, 0x20, 0x07, 0xc5, 0x0d, 0xc4, 0xb4, - 0x50, 0xd2, 0x48, 0xfb, 0xee, 0x1a, 0xa7, 0xbc, 0x10, 0xb4, 0xc7, 0x69, 0x87, 0x4f, 0x0f, 0x13, - 0x61, 0xe6, 0x65, 0x48, 0x23, 0x99, 0xb1, 0x44, 0x26, 0x92, 0xb5, 0xae, 0xb0, 0x3c, 0x69, 0x4f, - 0xed, 0xa1, 0xfd, 0x5a, 0xa7, 0x4d, 0x1f, 0xf6, 0x97, 0x67, 0x3c, 0x9a, 0x8b, 0x1c, 0xd4, 0x29, - 0x2b, 0x16, 0x49, 0x23, 0x68, 0x96, 0x81, 0xe1, 0xac, 0xda, 0xd9, 0x61, 0xca, 0xfe, 0xe6, 0x52, - 0x65, 0x6e, 0x44, 0x06, 0x3b, 0x86, 0xc7, 0xff, 0x33, 0x34, 0x7f, 0x92, 0xf1, 0x3f, 0x7d, 0x07, - 0x5f, 0x07, 0x78, 0xf2, 0x56, 0x09, 0xa9, 0x84, 0x39, 0x7d, 0x96, 0x72, 0xad, 0xed, 0x4f, 0x78, - 0xd4, 0x6c, 0x15, 0x73, 0xc3, 0x1d, 0xe4, 0x22, 0x6f, 0x7c, 0xf4, 0x80, 0xf6, 0x8d, 0x5c, 0x86, - 0xd3, 0x62, 0x91, 0x34, 0x82, 0xa6, 0x0d, 0x4d, 0xab, 0x19, 0x7d, 0x13, 0x7e, 0x86, 0xc8, 0xbc, - 0x06, 0xc3, 0x7d, 0x7b, 0x79, 0xb1, 0x6f, 0xd5, 0x17, 0xfb, 0xb8, 0xd7, 0x82, 0xcb, 0x54, 0xfb, - 0x1e, 0x1e, 0x56, 0x3c, 0x2d, 0xc1, 0x19, 0xb8, 0xc8, 0x1b, 0xfa, 0x93, 0x0e, 0x1e, 0xbe, 0x6f, - 0xc4, 0x60, 0x3d, 0xb3, 0x9f, 0xe2, 0x49, 0x92, 0xca, 0x90, 0xa7, 0xc7, 0x70, 0xc2, 0xcb, 0xd4, - 0x38, 0x7b, 0x2e, 0xf2, 0x46, 0xfe, 0x9d, 0x0e, 0x9e, 0xbc, 0xd8, 0x1c, 0x06, 0xdb, 0xac, 0xfd, - 0x08, 0x8f, 0x63, 0xd0, 0x91, 0x12, 0x85, 0x11, 0x32, 0x77, 0xae, 0xb9, 0xc8, 0xbb, 0xe1, 0xdf, - 0xee, 0xac, 0xe3, 0xe3, 0x7e, 0x14, 0x6c, 0x72, 0x07, 0xdf, 0x11, 0xbe, 0xb5, 0x55, 0xc6, 0x2b, - 0xa1, 0x8d, 0xfd, 0x71, 0xa7, 0x10, 0x7a, 0xb5, 0x42, 0x1a, 0x77, 0x5b, 0xc7, 0xcd, 0xee, 0xe6, - 0xd1, 0x6f, 0x65, 0xa3, 0x8c, 0x77, 0x78, 0x28, 0x0c, 0x64, 0xda, 0x19, 0xb8, 0x7b, 0xde, 0xf8, - 0xe8, 0x3e, 0xfd, 0xe7, 0xeb, 0xa3, 0x5b, 0xeb, 0xf5, 0xd5, 0xbd, 0x6c, 0x22, 0x82, 0x75, 0x92, - 0x7f, 0xb8, 0x5c, 0x11, 0xeb, 0x6c, 0x45, 0xac, 0xf3, 0x15, 0xb1, 0xbe, 0xd4, 0x04, 0x2d, 0x6b, - 0x82, 0xce, 0x6a, 0x82, 0xce, 0x6b, 0x82, 0x7e, 0xd4, 0x04, 0x7d, 0xfb, 0x49, 0xac, 0x0f, 0xd7, - 0xbb, 0xc8, 0x5f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x41, 0x74, 0x8a, 0x60, 0x38, 0x03, 0x00, 0x00, + // 494 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0x3f, 0x8f, 0xd3, 0x30, + 0x18, 0xc6, 0xeb, 0x1e, 0x15, 0xc5, 0x55, 0xa5, 0x12, 0x84, 0x14, 0x55, 0x22, 0xad, 0x7a, 0x4b, + 0x07, 0xce, 0xa6, 0x27, 0x40, 0x48, 0xb7, 0x95, 0x13, 0x08, 0x09, 0x44, 0xc9, 0xc0, 0x80, 0x18, + 0x70, 0x92, 0xf7, 0x52, 0xd3, 0x24, 0x8e, 0x6c, 0x27, 0x52, 0x37, 0x3e, 0x02, 0x1f, 0x8a, 0xa1, + 0xe3, 0x8d, 0x37, 0x55, 0x34, 0x7c, 0x04, 0x36, 0x26, 0x94, 0x34, 0x5c, 0xda, 0x86, 0x7f, 0x5b, + 0xfc, 0x3e, 0xbf, 0xe7, 0xb1, 0xfd, 0x24, 0xc1, 0xcf, 0x16, 0x4f, 0x14, 0xe1, 0x82, 0x2e, 0x12, + 0x07, 0x64, 0x04, 0x1a, 0x14, 0x4d, 0x21, 0xf2, 0x84, 0xa4, 0xa5, 0xc0, 0x62, 0x4e, 0x95, 0x3b, + 0x07, 0x2f, 0x09, 0x78, 0xe4, 0xd3, 0x74, 0xe2, 0x80, 0x66, 0x13, 0xea, 0x43, 0x04, 0x92, 0x69, + 0xf0, 0x48, 0x2c, 0x85, 0x16, 0xc6, 0xbd, 0x2d, 0x4e, 0x58, 0xcc, 0x49, 0x85, 0x93, 0x12, 0xef, + 0x9f, 0xf8, 0x5c, 0xcf, 0x13, 0x87, 0xb8, 0x22, 0xa4, 0xbe, 0xf0, 0x05, 0x2d, 0x5c, 0x4e, 0x72, + 0x51, 0xac, 0x8a, 0x45, 0xf1, 0xb4, 0x4d, 0xeb, 0x8f, 0x76, 0x36, 0x77, 0x85, 0x04, 0x9a, 0xd6, + 0x76, 0xec, 0x3f, 0xac, 0x98, 0x90, 0xb9, 0x73, 0x1e, 0x81, 0x5c, 0xd2, 0x78, 0xe1, 0xe7, 0x03, + 0x45, 0x43, 0xd0, 0xec, 0x77, 0x2e, 0xfa, 0x27, 0x97, 0x4c, 0x22, 0xcd, 0x43, 0xa8, 0x19, 0x1e, + 0xff, 0xcb, 0x90, 0xdf, 0x36, 0x64, 0x87, 0xbe, 0xd1, 0xf7, 0x26, 0xee, 0xce, 0x24, 0x17, 0x92, + 0xeb, 0xe5, 0xd3, 0x80, 0x29, 0x65, 0x7c, 0xc0, 0xed, 0xfc, 0x54, 0x1e, 0xd3, 0xcc, 0x44, 0x43, + 0x34, 0xee, 0x9c, 0x3e, 0x20, 0x55, 0x6b, 0xd7, 0xe1, 0x24, 0x5e, 0xf8, 0xf9, 0x40, 0x91, 0x9c, + 0x26, 0xe9, 0x84, 0xbc, 0x76, 0x3e, 0x82, 0xab, 0x5f, 0x81, 0x66, 0x53, 0x63, 0xb5, 0x1e, 0x34, + 0xb2, 0xf5, 0x00, 0x57, 0x33, 0xfb, 0x3a, 0xd5, 0x38, 0xc6, 0xad, 0x94, 0x05, 0x09, 0x98, 0xcd, + 0x21, 0x1a, 0xb7, 0xa6, 0xdd, 0x12, 0x6e, 0xbd, 0xcd, 0x87, 0xf6, 0x56, 0x33, 0xce, 0x70, 0xd7, + 0x0f, 0x84, 0xc3, 0x82, 0x73, 0xb8, 0x60, 0x49, 0xa0, 0xcd, 0xa3, 0x21, 0x1a, 0xb7, 0xa7, 0x77, + 0x4b, 0xb8, 0xfb, 0x7c, 0x57, 0xb4, 0xf7, 0x59, 0xe3, 0x11, 0xee, 0x78, 0xa0, 0x5c, 0xc9, 0x63, + 0xcd, 0x45, 0x64, 0xde, 0x18, 0xa2, 0xf1, 0xad, 0xe9, 0x9d, 0xd2, 0xda, 0x39, 0xaf, 0x24, 0x7b, + 0x97, 0x33, 0x7c, 0xdc, 0x8b, 0x25, 0x40, 0x58, 0xac, 0x66, 0x22, 0xe0, 0xee, 0xd2, 0x6c, 0x15, + 0xde, 0xb3, 0x6c, 0x3d, 0xe8, 0xcd, 0x0e, 0xb4, 0x1f, 0xeb, 0xc1, 0x71, 0xfd, 0x0b, 0x20, 0x87, + 0x98, 0x5d, 0x0b, 0x1d, 0x7d, 0x41, 0xf8, 0xf6, 0x5e, 0xeb, 0x2f, 0xb9, 0xd2, 0xc6, 0xfb, 0x5a, + 0xf3, 0xe4, 0xff, 0x9a, 0xcf, 0xdd, 0x45, 0xef, 0xbd, 0xf2, 0x8a, 0xed, 0x5f, 0x93, 0x9d, 0xd6, + 0xdf, 0xe0, 0x16, 0xd7, 0x10, 0x2a, 0xb3, 0x39, 0x3c, 0x1a, 0x77, 0x4e, 0xef, 0x93, 0xbf, 0xfe, + 0x0a, 0x64, 0xef, 0x78, 0xd5, 0x3b, 0x7a, 0x91, 0x47, 0xd8, 0xdb, 0xa4, 0xe9, 0xc9, 0x6a, 0x63, + 0x35, 0x2e, 0x37, 0x56, 0xe3, 0x6a, 0x63, 0x35, 0x3e, 0x65, 0x16, 0x5a, 0x65, 0x16, 0xba, 0xcc, + 0x2c, 0x74, 0x95, 0x59, 0xe8, 0x6b, 0x66, 0xa1, 0xcf, 0xdf, 0xac, 0xc6, 0xbb, 0x9b, 0x65, 0xe4, + 0xcf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x1a, 0xc2, 0xc0, 0x1f, 0xc5, 0x03, 0x00, 0x00, } diff --git a/staging/src/k8s.io/api/scheduling/v1beta1/generated.proto b/staging/src/k8s.io/api/scheduling/v1beta1/generated.proto index 3f15dc1d5c..2582891bb3 100644 --- a/staging/src/k8s.io/api/scheduling/v1beta1/generated.proto +++ b/staging/src/k8s.io/api/scheduling/v1beta1/generated.proto @@ -21,6 +21,7 @@ syntax = 'proto2'; package k8s.io.api.scheduling.v1beta1; +import "k8s.io/api/core/v1/generated.proto"; import "k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto"; import "k8s.io/apimachinery/pkg/runtime/generated.proto"; import "k8s.io/apimachinery/pkg/runtime/schema/generated.proto"; @@ -53,6 +54,13 @@ message PriorityClass { // when this priority class should be used. // +optional optional string description = 4; + + // PreemptionPolicy is the Policy for preempting pods with lower priority. + // One of Never, PreemptLowerPriority. + // Defaults to PreemptLowerPriority if unset. + // This field is alpha-level and is only honored by servers that enable the NonPreemptingPriority feature. + // +optional + optional string preemptionPolicy = 5; } // PriorityClassList is a collection of priority classes. diff --git a/staging/src/k8s.io/api/scheduling/v1beta1/types.go b/staging/src/k8s.io/api/scheduling/v1beta1/types.go index 2f6b3c9683..f806ecd4c2 100644 --- a/staging/src/k8s.io/api/scheduling/v1beta1/types.go +++ b/staging/src/k8s.io/api/scheduling/v1beta1/types.go @@ -17,6 +17,7 @@ limitations under the License. package v1beta1 import ( + apiv1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) @@ -50,6 +51,13 @@ type PriorityClass struct { // when this priority class should be used. // +optional Description string `json:"description,omitempty" protobuf:"bytes,4,opt,name=description"` + + // PreemptionPolicy is the Policy for preempting pods with lower priority. + // One of Never, PreemptLowerPriority. + // Defaults to PreemptLowerPriority if unset. + // This field is alpha-level and is only honored by servers that enable the NonPreemptingPriority feature. + // +optional + PreemptionPolicy *apiv1.PreemptionPolicy `json:"preemptionPolicy,omitempty" protobuf:"bytes,5,opt,name=preemptionPolicy"` } // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object diff --git a/staging/src/k8s.io/api/scheduling/v1beta1/types_swagger_doc_generated.go b/staging/src/k8s.io/api/scheduling/v1beta1/types_swagger_doc_generated.go index e99ed8fc48..ffded9df0f 100644 --- a/staging/src/k8s.io/api/scheduling/v1beta1/types_swagger_doc_generated.go +++ b/staging/src/k8s.io/api/scheduling/v1beta1/types_swagger_doc_generated.go @@ -28,11 +28,12 @@ package v1beta1 // AUTO-GENERATED FUNCTIONS START HERE. DO NOT EDIT. var map_PriorityClass = map[string]string{ - "": "DEPRECATED - This group version of PriorityClass is deprecated by scheduling.k8s.io/v1/PriorityClass. PriorityClass defines mapping from a priority class name to the priority integer value. The value can be any valid integer.", - "metadata": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata", - "value": "The value of this priority class. This is the actual priority that pods receive when they have the name of this class in their pod spec.", - "globalDefault": "globalDefault specifies whether this PriorityClass should be considered as the default priority for pods that do not have any priority class. Only one PriorityClass can be marked as `globalDefault`. However, if more than one PriorityClasses exists with their `globalDefault` field set to true, the smallest value of such global default PriorityClasses will be used as the default priority.", - "description": "description is an arbitrary string that usually provides guidelines on when this priority class should be used.", + "": "DEPRECATED - This group version of PriorityClass is deprecated by scheduling.k8s.io/v1/PriorityClass. PriorityClass defines mapping from a priority class name to the priority integer value. The value can be any valid integer.", + "metadata": "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata", + "value": "The value of this priority class. This is the actual priority that pods receive when they have the name of this class in their pod spec.", + "globalDefault": "globalDefault specifies whether this PriorityClass should be considered as the default priority for pods that do not have any priority class. Only one PriorityClass can be marked as `globalDefault`. However, if more than one PriorityClasses exists with their `globalDefault` field set to true, the smallest value of such global default PriorityClasses will be used as the default priority.", + "description": "description is an arbitrary string that usually provides guidelines on when this priority class should be used.", + "preemptionPolicy": "PreemptionPolicy is the Policy for preempting pods with lower priority. One of Never, PreemptLowerPriority. Defaults to PreemptLowerPriority if unset. This field is alpha-level and is only honored by servers that enable the NonPreemptingPriority feature.", } func (PriorityClass) SwaggerDoc() map[string]string { diff --git a/staging/src/k8s.io/api/scheduling/v1beta1/zz_generated.deepcopy.go b/staging/src/k8s.io/api/scheduling/v1beta1/zz_generated.deepcopy.go index 7c049b1e58..6e2008578e 100644 --- a/staging/src/k8s.io/api/scheduling/v1beta1/zz_generated.deepcopy.go +++ b/staging/src/k8s.io/api/scheduling/v1beta1/zz_generated.deepcopy.go @@ -21,6 +21,7 @@ limitations under the License. package v1beta1 import ( + v1 "k8s.io/api/core/v1" runtime "k8s.io/apimachinery/pkg/runtime" ) @@ -29,6 +30,11 @@ func (in *PriorityClass) DeepCopyInto(out *PriorityClass) { *out = *in out.TypeMeta = in.TypeMeta in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + if in.PreemptionPolicy != nil { + in, out := &in.PreemptionPolicy, &out.PreemptionPolicy + *out = new(v1.PreemptionPolicy) + **out = **in + } return }