diff --git a/api/openapi-spec/swagger.json b/api/openapi-spec/swagger.json index c219ecc41c8..4c2939fff7a 100644 --- a/api/openapi-spec/swagger.json +++ b/api/openapi-spec/swagger.json @@ -7248,6 +7248,19 @@ ], "type": "object" }, + "io.k8s.api.core.v1.PodSchedulingGate": { + "description": "PodSchedulingGate is associated to a Pod to guard its scheduling.", + "properties": { + "name": { + "description": "Name of the scheduling gate. Each scheduling gate must have a unique name field.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, "io.k8s.api.core.v1.PodSecurityContext": { "description": "PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext.", "properties": { @@ -7452,6 +7465,19 @@ "description": "If specified, the pod will be dispatched by specified scheduler. If not specified, the pod will be dispatched by default scheduler.", "type": "string" }, + "schedulingGates": { + "description": "SchedulingGates is an opaque list of values that if specified will block scheduling the pod. More info: https://git.k8s.io/enhancements/keps/sig-scheduling/3521-pod-scheduling-readiness.\n\nThis is an alpha-level feature enabled by PodSchedulingReadiness feature gate.", + "items": { + "$ref": "#/definitions/io.k8s.api.core.v1.PodSchedulingGate" + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + }, "securityContext": { "$ref": "#/definitions/io.k8s.api.core.v1.PodSecurityContext", "description": "SecurityContext holds pod-level security attributes and common container settings. Optional: Defaults to empty. See type description for default values of each field." diff --git a/api/openapi-spec/v3/api__v1_openapi.json b/api/openapi-spec/v3/api__v1_openapi.json index 854e3d77d95..47ae39b51d7 100644 --- a/api/openapi-spec/v3/api__v1_openapi.json +++ b/api/openapi-spec/v3/api__v1_openapi.json @@ -4869,6 +4869,20 @@ ], "type": "object" }, + "io.k8s.api.core.v1.PodSchedulingGate": { + "description": "PodSchedulingGate is associated to a Pod to guard its scheduling.", + "properties": { + "name": { + "default": "", + "description": "Name of the scheduling gate. Each scheduling gate must have a unique name field.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, "io.k8s.api.core.v1.PodSecurityContext": { "description": "PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext.", "properties": { @@ -5139,6 +5153,24 @@ "description": "If specified, the pod will be dispatched by specified scheduler. If not specified, the pod will be dispatched by default scheduler.", "type": "string" }, + "schedulingGates": { + "description": "SchedulingGates is an opaque list of values that if specified will block scheduling the pod. More info: https://git.k8s.io/enhancements/keps/sig-scheduling/3521-pod-scheduling-readiness.\n\nThis is an alpha-level feature enabled by PodSchedulingReadiness feature gate.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodSchedulingGate" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + }, "securityContext": { "allOf": [ { diff --git a/api/openapi-spec/v3/apis__apps__v1_openapi.json b/api/openapi-spec/v3/apis__apps__v1_openapi.json index c840a588451..cfd962f32d0 100644 --- a/api/openapi-spec/v3/apis__apps__v1_openapi.json +++ b/api/openapi-spec/v3/apis__apps__v1_openapi.json @@ -3291,6 +3291,20 @@ ], "type": "object" }, + "io.k8s.api.core.v1.PodSchedulingGate": { + "description": "PodSchedulingGate is associated to a Pod to guard its scheduling.", + "properties": { + "name": { + "default": "", + "description": "Name of the scheduling gate. Each scheduling gate must have a unique name field.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, "io.k8s.api.core.v1.PodSecurityContext": { "description": "PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext.", "properties": { @@ -3561,6 +3575,24 @@ "description": "If specified, the pod will be dispatched by specified scheduler. If not specified, the pod will be dispatched by default scheduler.", "type": "string" }, + "schedulingGates": { + "description": "SchedulingGates is an opaque list of values that if specified will block scheduling the pod. More info: https://git.k8s.io/enhancements/keps/sig-scheduling/3521-pod-scheduling-readiness.\n\nThis is an alpha-level feature enabled by PodSchedulingReadiness feature gate.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodSchedulingGate" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + }, "securityContext": { "allOf": [ { diff --git a/api/openapi-spec/v3/apis__batch__v1_openapi.json b/api/openapi-spec/v3/apis__batch__v1_openapi.json index 37c0c2cd5a9..adb4b76fc45 100644 --- a/api/openapi-spec/v3/apis__batch__v1_openapi.json +++ b/api/openapi-spec/v3/apis__batch__v1_openapi.json @@ -2485,6 +2485,20 @@ ], "type": "object" }, + "io.k8s.api.core.v1.PodSchedulingGate": { + "description": "PodSchedulingGate is associated to a Pod to guard its scheduling.", + "properties": { + "name": { + "default": "", + "description": "Name of the scheduling gate. Each scheduling gate must have a unique name field.", + "type": "string" + } + }, + "required": [ + "name" + ], + "type": "object" + }, "io.k8s.api.core.v1.PodSecurityContext": { "description": "PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext.", "properties": { @@ -2755,6 +2769,24 @@ "description": "If specified, the pod will be dispatched by specified scheduler. If not specified, the pod will be dispatched by default scheduler.", "type": "string" }, + "schedulingGates": { + "description": "SchedulingGates is an opaque list of values that if specified will block scheduling the pod. More info: https://git.k8s.io/enhancements/keps/sig-scheduling/3521-pod-scheduling-readiness.\n\nThis is an alpha-level feature enabled by PodSchedulingReadiness feature gate.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.PodSchedulingGate" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge" + }, "securityContext": { "allOf": [ { diff --git a/pkg/api/pod/util.go b/pkg/api/pod/util.go index 8f1a63bb719..1bdbd4523eb 100644 --- a/pkg/api/pod/util.go +++ b/pkg/api/pod/util.go @@ -537,6 +537,11 @@ func dropDisabledFields( } } + // If the feature is disabled and not in use, drop the schedulingGates field. + if !utilfeature.DefaultFeatureGate.Enabled(features.PodSchedulingReadiness) && !schedulingGatesInUse(oldPodSpec) { + podSpec.SchedulingGates = nil + } + dropDisabledProcMountField(podSpec, oldPodSpec) dropDisabledTopologySpreadConstraintsFields(podSpec, oldPodSpec) @@ -719,6 +724,14 @@ func probeGracePeriodInUse(podSpec *api.PodSpec) bool { return inUse } +// schedulingGatesInUse returns true if the pod spec is non-nil and it has SchedulingGates field set. +func schedulingGatesInUse(podSpec *api.PodSpec) bool { + if podSpec == nil { + return false + } + return len(podSpec.SchedulingGates) != 0 +} + // SeccompAnnotationForField takes a pod seccomp profile field and returns the // converted annotation value func SeccompAnnotationForField(field *api.SeccompProfile) string { diff --git a/pkg/api/pod/util_test.go b/pkg/api/pod/util_test.go index 15ee5d5705d..1dfef8aa245 100644 --- a/pkg/api/pod/util_test.go +++ b/pkg/api/pod/util_test.go @@ -1935,3 +1935,85 @@ func TestDropHostUsers(t *testing.T) { } } + +func TestDropSchedulingGates(t *testing.T) { + podWithSchedulingGates := func() *api.Pod { + return &api.Pod{ + Spec: api.PodSpec{ + SchedulingGates: []api.PodSchedulingGate{ + {Name: "foo"}, + {Name: "bar"}, + }, + }, + } + } + podWithoutSchedulingGates := func() *api.Pod { return &api.Pod{} } + + podInfo := []struct { + description string + hasSchedulingGatesField bool + pod func() *api.Pod + }{ + { + description: "has SchedulingGates field", + hasSchedulingGatesField: true, + pod: podWithSchedulingGates, + }, + { + description: "does not have SchedulingGates field", + hasSchedulingGatesField: false, + pod: podWithoutSchedulingGates, + }, + { + description: "is nil", + hasSchedulingGatesField: false, + pod: func() *api.Pod { return nil }, + }, + } + + for _, enabled := range []bool{true, false} { + for _, oldPodInfo := range podInfo { + for _, newPodInfo := range podInfo { + oldPodHasSchedulingGates, oldPod := oldPodInfo.hasSchedulingGatesField, oldPodInfo.pod() + newPodHasSchedulingGates, newPod := newPodInfo.hasSchedulingGatesField, newPodInfo.pod() + if newPod == nil { + continue + } + + t.Run(fmt.Sprintf("feature enabled=%v, old pod %v, new pod %v", enabled, oldPodInfo.description, newPodInfo.description), func(t *testing.T) { + defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.PodSchedulingReadiness, enabled)() + var oldPodSpec *api.PodSpec + if oldPod != nil { + oldPodSpec = &oldPod.Spec + } + dropDisabledFields(&newPod.Spec, nil, oldPodSpec, nil) + // Old Pod should never be changed. + if diff := cmp.Diff(oldPod, oldPodInfo.pod()); diff != "" { + t.Errorf("old pod changed: %v", diff) + } + switch { + case enabled || oldPodHasSchedulingGates: + // New Pod should not be changed if the feature is enabled, or if the old Pod had schedulingGates. + if diff := cmp.Diff(newPod, newPodInfo.pod()); diff != "" { + t.Errorf("new pod changed: %v", diff) + } + case newPodHasSchedulingGates: + // New Pod should be changed. + if reflect.DeepEqual(newPod, newPodInfo.pod()) { + t.Errorf("new pod was not changed") + } + // New Pod should not have SchedulingGates field. + if diff := cmp.Diff(newPod, podWithoutSchedulingGates()); diff != "" { + t.Errorf("new pod has SchedulingGates field: %v", diff) + } + default: + // New pod should not need to be changed. + if diff := cmp.Diff(newPod, newPodInfo.pod()); diff != "" { + t.Errorf("new pod changed: %v", diff) + } + } + }) + } + } + } +} diff --git a/pkg/apis/core/types.go b/pkg/apis/core/types.go index 0598bcc7237..5bbd397fbaa 100644 --- a/pkg/apis/core/types.go +++ b/pkg/apis/core/types.go @@ -291,7 +291,7 @@ type PersistentVolume struct { // +optional metav1.ObjectMeta - //Spec defines a persistent volume owned by the cluster + // Spec defines a persistent volume owned by the cluster // +optional Spec PersistentVolumeSpec @@ -1977,10 +1977,10 @@ type EnvFromSource struct { // +optional Prefix string // The ConfigMap to select from. - //+optional + // +optional ConfigMapRef *ConfigMapEnvSource // The Secret to select from. - //+optional + // +optional SecretRef *SecretEnvSource } @@ -2428,6 +2428,9 @@ const ( // PodReasonUnschedulable reason in PodScheduled PodCondition means that the scheduler // can't schedule the pod right now, for example due to insufficient resources in the cluster. PodReasonUnschedulable = "Unschedulable" + // PodReasonSchedulingGated reason in PodScheduled PodCondition means that the scheduler + // skips scheduling the pod because one or more scheduling gates are still present. + PodReasonSchedulingGated = "SchedulingGated" // ContainersReady indicates whether all containers in the pod are ready. ContainersReady PodConditionType = "ContainersReady" // AlphaNoCompatGuaranteeDisruptionTarget indicates the pod is about to be deleted due to a @@ -2502,7 +2505,7 @@ const ( // over a set of nodes; that is, it represents the OR of the selectors represented // by the node selector terms. type NodeSelector struct { - //Required. A list of node selector terms. The terms are ORed. + // Required. A list of node selector terms. The terms are ORed. NodeSelectorTerms []NodeSelectorTerm } @@ -2997,6 +3000,12 @@ type PodSpec struct { // - spec.containers[*].securityContext.runAsGroup // +optional OS *PodOS + // SchedulingGates is an opaque list of values that if specified will block scheduling the pod. + // More info: https://git.k8s.io/enhancements/keps/sig-scheduling/3521-pod-scheduling-readiness. + // + // This is an alpha-level feature enabled by PodSchedulingReadiness feature gate. + // +optional + SchedulingGates []PodSchedulingGate } // OSName is the set of OS'es that can be used in OS. @@ -3017,6 +3026,13 @@ type PodOS struct { Name OSName } +// PodSchedulingGate is associated to a Pod to guard its scheduling. +type PodSchedulingGate struct { + // Name of the scheduling gate. + // Each scheduling gate must have a unique name field. + Name string +} + // HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the // pod's hosts file. type HostAlias struct { @@ -3494,7 +3510,7 @@ type ReplicationControllerSpec struct { // insufficient replicas are detected. This reference is ignored if a Template is set. // Must be set before converting to a versioned API object // +optional - //TemplateRef *ObjectReference + // TemplateRef *ObjectReference // Template is the object that describes the pod that will be created if // insufficient replicas are detected. Internally, this takes precedence over a @@ -4829,7 +4845,7 @@ type ObjectReference struct { // LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace. type LocalObjectReference struct { - //TODO: Add other useful fields. apiVersion, kind, uid? + // TODO: Add other useful fields. apiVersion, kind, uid? Name string } diff --git a/pkg/apis/core/v1/zz_generated.conversion.go b/pkg/apis/core/v1/zz_generated.conversion.go index 696b435c235..e93e625d110 100644 --- a/pkg/apis/core/v1/zz_generated.conversion.go +++ b/pkg/apis/core/v1/zz_generated.conversion.go @@ -1352,6 +1352,16 @@ func RegisterConversions(s *runtime.Scheme) error { }); err != nil { return err } + if err := s.AddGeneratedConversionFunc((*v1.PodSchedulingGate)(nil), (*core.PodSchedulingGate)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1_PodSchedulingGate_To_core_PodSchedulingGate(a.(*v1.PodSchedulingGate), b.(*core.PodSchedulingGate), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*core.PodSchedulingGate)(nil), (*v1.PodSchedulingGate)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_core_PodSchedulingGate_To_v1_PodSchedulingGate(a.(*core.PodSchedulingGate), b.(*v1.PodSchedulingGate), scope) + }); err != nil { + return err + } if err := s.AddGeneratedConversionFunc((*v1.PodSecurityContext)(nil), (*core.PodSecurityContext)(nil), func(a, b interface{}, scope conversion.Scope) error { return Convert_v1_PodSecurityContext_To_core_PodSecurityContext(a.(*v1.PodSecurityContext), b.(*core.PodSecurityContext), scope) }); err != nil { @@ -6069,6 +6079,26 @@ func Convert_core_PodReadinessGate_To_v1_PodReadinessGate(in *core.PodReadinessG return autoConvert_core_PodReadinessGate_To_v1_PodReadinessGate(in, out, s) } +func autoConvert_v1_PodSchedulingGate_To_core_PodSchedulingGate(in *v1.PodSchedulingGate, out *core.PodSchedulingGate, s conversion.Scope) error { + out.Name = in.Name + return nil +} + +// Convert_v1_PodSchedulingGate_To_core_PodSchedulingGate is an autogenerated conversion function. +func Convert_v1_PodSchedulingGate_To_core_PodSchedulingGate(in *v1.PodSchedulingGate, out *core.PodSchedulingGate, s conversion.Scope) error { + return autoConvert_v1_PodSchedulingGate_To_core_PodSchedulingGate(in, out, s) +} + +func autoConvert_core_PodSchedulingGate_To_v1_PodSchedulingGate(in *core.PodSchedulingGate, out *v1.PodSchedulingGate, s conversion.Scope) error { + out.Name = in.Name + return nil +} + +// Convert_core_PodSchedulingGate_To_v1_PodSchedulingGate is an autogenerated conversion function. +func Convert_core_PodSchedulingGate_To_v1_PodSchedulingGate(in *core.PodSchedulingGate, out *v1.PodSchedulingGate, s conversion.Scope) error { + return autoConvert_core_PodSchedulingGate_To_v1_PodSchedulingGate(in, out, s) +} + func autoConvert_v1_PodSecurityContext_To_core_PodSecurityContext(in *v1.PodSecurityContext, out *core.PodSecurityContext, s conversion.Scope) error { out.SELinuxOptions = (*core.SELinuxOptions)(unsafe.Pointer(in.SELinuxOptions)) out.WindowsOptions = (*core.WindowsSecurityContextOptions)(unsafe.Pointer(in.WindowsOptions)) @@ -6188,6 +6218,7 @@ func autoConvert_v1_PodSpec_To_core_PodSpec(in *v1.PodSpec, out *core.PodSpec, s out.SetHostnameAsFQDN = (*bool)(unsafe.Pointer(in.SetHostnameAsFQDN)) out.OS = (*core.PodOS)(unsafe.Pointer(in.OS)) // INFO: in.HostUsers opted out of conversion generation + out.SchedulingGates = *(*[]core.PodSchedulingGate)(unsafe.Pointer(&in.SchedulingGates)) return nil } @@ -6241,6 +6272,7 @@ func autoConvert_core_PodSpec_To_v1_PodSpec(in *core.PodSpec, out *v1.PodSpec, s out.EnableServiceLinks = (*bool)(unsafe.Pointer(in.EnableServiceLinks)) out.TopologySpreadConstraints = *(*[]v1.TopologySpreadConstraint)(unsafe.Pointer(&in.TopologySpreadConstraints)) out.OS = (*v1.PodOS)(unsafe.Pointer(in.OS)) + out.SchedulingGates = *(*[]v1.PodSchedulingGate)(unsafe.Pointer(&in.SchedulingGates)) return nil } diff --git a/pkg/apis/core/validation/validation.go b/pkg/apis/core/validation/validation.go index 7b46b7b9498..d658925937c 100644 --- a/pkg/apis/core/validation/validation.go +++ b/pkg/apis/core/validation/validation.go @@ -1013,7 +1013,7 @@ func validateGlusterfsPersistentVolumeSource(glusterfs *core.GlusterfsPersistent func validateFlockerVolumeSource(flocker *core.FlockerVolumeSource, fldPath *field.Path) field.ErrorList { allErrs := field.ErrorList{} if len(flocker.DatasetName) == 0 && len(flocker.DatasetUUID) == 0 { - //TODO: consider adding a RequiredOneOf() error for this and similar cases + // TODO: consider adding a RequiredOneOf() error for this and similar cases allErrs = append(allErrs, field.Required(fldPath, "one of datasetName and datasetUUID is required")) } if len(flocker.DatasetName) != 0 && len(flocker.DatasetUUID) != 0 { @@ -3272,6 +3272,22 @@ func validateReadinessGates(readinessGates []core.PodReadinessGate, fldPath *fie return allErrs } +func validateSchedulingGates(schedulingGates []core.PodSchedulingGate, fldPath *field.Path) field.ErrorList { + allErrs := field.ErrorList{} + // There should be no duplicates in the list of scheduling gates. + seen := sets.String{} + for i, schedulingGate := range schedulingGates { + if schedulingGate.Name == "" { + allErrs = append(allErrs, field.Required(fldPath.Index(i), "must not be empty")) + } + if seen.Has(schedulingGate.Name) { + allErrs = append(allErrs, field.Duplicate(fldPath.Index(i), schedulingGate.Name)) + } + seen.Insert(schedulingGate.Name) + } + return allErrs +} + func validatePodDNSConfig(dnsConfig *core.PodDNSConfig, dnsPolicy *core.DNSPolicy, fldPath *field.Path, opts PodValidationOptions) field.ErrorList { allErrs := field.ErrorList{} @@ -3420,6 +3436,28 @@ func validateOnlyAddedTolerations(newTolerations []core.Toleration, oldToleratio return allErrs } +func validateOnlyDeletedSchedulingGates(newGates, oldGates []core.PodSchedulingGate, fldPath *field.Path) field.ErrorList { + allErrs := field.ErrorList{} + if len(newGates) == 0 { + return allErrs + } + + additionalGates := make(map[string]int) + for i, newGate := range newGates { + additionalGates[newGate.Name] = i + } + + for _, oldGate := range oldGates { + delete(additionalGates, oldGate.Name) + } + + for gate, i := range additionalGates { + allErrs = append(allErrs, field.Forbidden(fldPath.Index(i).Child("name"), fmt.Sprintf("only deletion is allowed, but found new scheduling gate '%s'", gate))) + } + + return allErrs +} + func ValidateHostAliases(hostAliases []core.HostAlias, fldPath *field.Path) field.ErrorList { allErrs := field.ErrorList{} for _, hostAlias := range hostAliases { @@ -3577,7 +3615,7 @@ func validatePodIPs(pod *core.Pod) field.ErrorList { } // There should be no duplicates in list of Pod.PodIPs - seen := sets.String{} //:= make(map[string]int) + seen := sets.String{} // := make(map[string]int) for i, podIP := range pod.Status.PodIPs { if seen.Has(podIP.IP) { allErrs = append(allErrs, field.Duplicate(podIPsField.Index(i), podIP)) @@ -3611,6 +3649,7 @@ func ValidatePodSpec(spec *core.PodSpec, podMeta *metav1.ObjectMeta, fldPath *fi allErrs = append(allErrs, validateAffinity(spec.Affinity, fldPath.Child("affinity"))...) allErrs = append(allErrs, validatePodDNSConfig(spec.DNSConfig, &spec.DNSPolicy, fldPath.Child("dnsConfig"), opts)...) allErrs = append(allErrs, validateReadinessGates(spec.ReadinessGates, fldPath.Child("readinessGates"))...) + allErrs = append(allErrs, validateSchedulingGates(spec.SchedulingGates, fldPath.Child("schedulingGates"))...) allErrs = append(allErrs, validateTopologySpreadConstraints(spec.TopologySpreadConstraints, fldPath.Child("topologySpreadConstraints"))...) allErrs = append(allErrs, validateWindowsHostProcessPod(spec, fldPath)...) allErrs = append(allErrs, validateHostUsers(spec, fldPath)...) @@ -4016,7 +4055,7 @@ func validatePodAntiAffinity(podAntiAffinity *core.PodAntiAffinity, fldPath *fie // if podAntiAffinity.RequiredDuringSchedulingRequiredDuringExecution != nil { // allErrs = append(allErrs, validatePodAffinityTerms(podAntiAffinity.RequiredDuringSchedulingRequiredDuringExecution, false, // fldPath.Child("requiredDuringSchedulingRequiredDuringExecution"))...) - //} + // } if podAntiAffinity.RequiredDuringSchedulingIgnoredDuringExecution != nil { allErrs = append(allErrs, validatePodAffinityTerms(podAntiAffinity.RequiredDuringSchedulingIgnoredDuringExecution, fldPath.Child("requiredDuringSchedulingIgnoredDuringExecution"))...) @@ -4051,7 +4090,7 @@ func validatePodAffinity(podAffinity *core.PodAffinity, fldPath *field.Path) fie // if podAffinity.RequiredDuringSchedulingRequiredDuringExecution != nil { // allErrs = append(allErrs, validatePodAffinityTerms(podAffinity.RequiredDuringSchedulingRequiredDuringExecution, false, // fldPath.Child("requiredDuringSchedulingRequiredDuringExecution"))...) - //} + // } if podAffinity.RequiredDuringSchedulingIgnoredDuringExecution != nil { allErrs = append(allErrs, validatePodAffinityTerms(podAffinity.RequiredDuringSchedulingIgnoredDuringExecution, fldPath.Child("requiredDuringSchedulingIgnoredDuringExecution"))...) @@ -4258,7 +4297,7 @@ func ValidatePodSecurityContext(securityContext *core.PodSecurityContext, spec * func ValidateContainerUpdates(newContainers, oldContainers []core.Container, fldPath *field.Path) (allErrs field.ErrorList, stop bool) { allErrs = field.ErrorList{} if len(newContainers) != len(oldContainers) { - //TODO: Pinpoint the specific container that causes the invalid error after we have strategic merge diff + // TODO: Pinpoint the specific container that causes the invalid error after we have strategic merge diff allErrs = append(allErrs, field.Forbidden(fldPath, "pod updates may not add or remove containers")) return allErrs, true } @@ -4285,6 +4324,11 @@ func ValidatePodCreate(pod *core.Pod, opts PodValidationOptions) field.ErrorList if len(pod.Spec.EphemeralContainers) > 0 { allErrs = append(allErrs, field.Forbidden(fldPath.Child("ephemeralContainers"), "cannot be set on create")) } + // A Pod cannot be assigned a Node if there are remaining scheduling gates. + if utilfeature.DefaultFeatureGate.Enabled(features.PodSchedulingReadiness) && + pod.Spec.NodeName != "" && len(pod.Spec.SchedulingGates) != 0 { + allErrs = append(allErrs, field.Forbidden(fldPath.Child("nodeName"), "cannot be set until all schedulingGates have been cleared")) + } allErrs = append(allErrs, validateSeccompAnnotationsAndFields(pod.ObjectMeta, &pod.Spec, fldPath)...) return allErrs @@ -4370,6 +4414,7 @@ func ValidatePodUpdate(newPod, oldPod *core.Pod, opts PodValidationOptions) fiel // 2. spec.initContainers[*].image // 3. spec.activeDeadlineSeconds // 4. spec.terminationGracePeriodSeconds + // 5. spec.schedulingGates containerErrs, stop := ValidateContainerUpdates(newPod.Spec.Containers, oldPod.Spec.Containers, specPath.Child("containers")) allErrs = append(allErrs, containerErrs...) @@ -4405,6 +4450,9 @@ func ValidatePodUpdate(newPod, oldPod *core.Pod, opts PodValidationOptions) fiel // Allow only additions to tolerations updates. allErrs = append(allErrs, validateOnlyAddedTolerations(newPod.Spec.Tolerations, oldPod.Spec.Tolerations, specPath.Child("tolerations"))...) + // Allow only deletions to schedulingGates updates. + allErrs = append(allErrs, validateOnlyDeletedSchedulingGates(newPod.Spec.SchedulingGates, oldPod.Spec.SchedulingGates, specPath.Child("schedulingGates"))...) + // the last thing to check is pod spec equality. If the pod specs are equal, then we can simply return the errors we have // so far and save the cost of a deep copy. if apiequality.Semantic.DeepEqual(newPod.Spec, oldPod.Spec) { @@ -4433,6 +4481,8 @@ func ValidatePodUpdate(newPod, oldPod *core.Pod, opts PodValidationOptions) fiel activeDeadlineSeconds := *oldPod.Spec.ActiveDeadlineSeconds mungedPodSpec.ActiveDeadlineSeconds = &activeDeadlineSeconds } + // munge spec.schedulingGates + mungedPodSpec.SchedulingGates = oldPod.Spec.SchedulingGates // +k8s:verify-mutation:reason=clone // tolerations are checked before the deep copy, so munge those too mungedPodSpec.Tolerations = oldPod.Spec.Tolerations // +k8s:verify-mutation:reason=clone @@ -4444,7 +4494,7 @@ func ValidatePodUpdate(newPod, oldPod *core.Pod, opts PodValidationOptions) fiel if !apiequality.Semantic.DeepEqual(mungedPodSpec, oldPod.Spec) { // This diff isn't perfect, but it's a helluva lot better an "I'm not going to tell you what the difference is". - //TODO: Pinpoint the specific field that causes the invalid error after we have strategic merge diff + // TODO: Pinpoint the specific field that causes the invalid error after we have strategic merge diff specDiff := cmp.Diff(oldPod.Spec, mungedPodSpec) allErrs = append(allErrs, field.Forbidden(specPath, fmt.Sprintf("pod updates may not change fields other than `spec.containers[*].image`, `spec.initContainers[*].image`, `spec.activeDeadlineSeconds`, `spec.tolerations` (only additions to existing tolerations) or `spec.terminationGracePeriodSeconds` (allow it to be set to 1 if it was previously negative)\n%v", specDiff))) } @@ -6119,7 +6169,7 @@ func validateEndpointSubsets(subsets []core.EndpointSubset, fldPath *field.Path) // EndpointSubsets must include endpoint address. For headless service, we allow its endpoints not to have ports. if len(ss.Addresses) == 0 && len(ss.NotReadyAddresses) == 0 { - //TODO: consider adding a RequiredOneOf() error for this and similar cases + // TODO: consider adding a RequiredOneOf() error for this and similar cases allErrs = append(allErrs, field.Required(idxPath, "must specify `addresses` or `notReadyAddresses`")) } for addr := range ss.Addresses { @@ -6208,7 +6258,7 @@ func validateEndpointPort(port *core.EndpointPort, requireName bool, fldPath *fi // ValidateSecurityContext ensures the security context contains valid settings func ValidateSecurityContext(sc *core.SecurityContext, fldPath *field.Path) field.ErrorList { allErrs := field.ErrorList{} - //this should only be true for testing since SecurityContext is defaulted by the core + // this should only be true for testing since SecurityContext is defaulted by the core if sc == nil { return allErrs } @@ -6724,7 +6774,7 @@ func ValidateServiceClusterIPsRelatedFields(service *core.Service) field.ErrorLi } // IPFamilyPolicy stand alone validation - //note: nil is ok, defaulted in alloc check registry/core/service/* + // note: nil is ok, defaulted in alloc check registry/core/service/* if service.Spec.IPFamilyPolicy != nil { // must have a supported value if !supportedServiceIPFamilyPolicy.Has(string(*(service.Spec.IPFamilyPolicy))) { diff --git a/pkg/apis/core/validation/validation_test.go b/pkg/apis/core/validation/validation_test.go index c935e6f7384..15629884d56 100644 --- a/pkg/apis/core/validation/validation_test.go +++ b/pkg/apis/core/validation/validation_test.go @@ -703,7 +703,7 @@ func TestValidatePersistentVolumeSourceUpdate(t *testing.T) { Namespace: "default", } - //longSecretRef refers to the secretRefs which are validated with IsDNS1123Subdomain + // longSecretRef refers to the secretRefs which are validated with IsDNS1123Subdomain longSecretName := "key-name.example.com" longSecretRef := &core.SecretReference{ Name: longSecretName, @@ -10794,6 +10794,91 @@ func TestValidatePod(t *testing.T) { } } +func TestValidatePodCreateWithSchedulingGates(t *testing.T) { + applyEssentials := func(pod *core.Pod) { + pod.Spec.Containers = []core.Container{ + {Name: "con", Image: "pause", ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: "File"}, + } + pod.Spec.RestartPolicy = core.RestartPolicyAlways + pod.Spec.DNSPolicy = core.DNSClusterFirst + } + fldPath := field.NewPath("spec") + + tests := []struct { + name string + pod *core.Pod + featureEnabled bool + wantFieldErrors field.ErrorList + }{ + { + name: "create a Pod with nodeName and schedulingGates, feature disabled", + pod: &core.Pod{ + ObjectMeta: metav1.ObjectMeta{Name: "pod", Namespace: "ns"}, + Spec: core.PodSpec{ + NodeName: "node", + SchedulingGates: []core.PodSchedulingGate{ + {Name: "foo"}, + }, + }, + }, + featureEnabled: false, + wantFieldErrors: nil, + }, + { + name: "create a Pod with nodeName and schedulingGates, feature enabled", + pod: &core.Pod{ + ObjectMeta: metav1.ObjectMeta{Name: "pod", Namespace: "ns"}, + Spec: core.PodSpec{ + NodeName: "node", + SchedulingGates: []core.PodSchedulingGate{ + {Name: "foo"}, + }, + }, + }, + featureEnabled: true, + wantFieldErrors: []*field.Error{field.Forbidden(fldPath.Child("nodeName"), "cannot be set until all schedulingGates have been cleared")}, + }, + { + name: "create a Pod with schedulingGates, feature disabled", + pod: &core.Pod{ + ObjectMeta: metav1.ObjectMeta{Name: "pod", Namespace: "ns"}, + Spec: core.PodSpec{ + SchedulingGates: []core.PodSchedulingGate{ + {Name: "foo"}, + }, + }, + }, + featureEnabled: false, + wantFieldErrors: nil, + }, + { + name: "create a Pod with schedulingGates, feature enabled", + pod: &core.Pod{ + ObjectMeta: metav1.ObjectMeta{Name: "pod", Namespace: "ns"}, + Spec: core.PodSpec{ + SchedulingGates: []core.PodSchedulingGate{ + {Name: "foo"}, + }, + }, + }, + featureEnabled: true, + wantFieldErrors: nil, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.PodSchedulingReadiness, tt.featureEnabled)() + + applyEssentials(tt.pod) + errs := ValidatePodCreate(tt.pod, PodValidationOptions{}) + if diff := cmp.Diff(tt.wantFieldErrors, errs); diff != "" { + t.Errorf("unexpected field errors (-want, +got):\n%s", diff) + } + }) + } +} + func TestValidatePodUpdate(t *testing.T) { var ( activeDeadlineSecondsZero = int64(0) @@ -11698,6 +11783,54 @@ func TestValidatePodUpdate(t *testing.T) { err: "Forbidden: pod updates may not change fields other than ", test: "update pod spec OS to a valid value, featuregate disabled", }, + { + new: core.Pod{ + Spec: core.PodSpec{ + SchedulingGates: []core.PodSchedulingGate{{Name: "foo"}}, + }, + }, + old: core.Pod{}, + err: "Forbidden: only deletion is allowed, but found new scheduling gate 'foo'", + test: "update pod spec schedulingGates: add new scheduling gate", + }, + { + new: core.Pod{ + Spec: core.PodSpec{ + SchedulingGates: []core.PodSchedulingGate{{Name: "bar"}}, + }, + }, + old: core.Pod{ + Spec: core.PodSpec{ + SchedulingGates: []core.PodSchedulingGate{{Name: "foo"}}, + }, + }, + err: "Forbidden: only deletion is allowed, but found new scheduling gate 'bar'", + test: "update pod spec schedulingGates: mutating an existing scheduling gate", + }, + { + new: core.Pod{ + Spec: core.PodSpec{ + SchedulingGates: []core.PodSchedulingGate{{Name: "baz"}}, + }, + }, + old: core.Pod{ + Spec: core.PodSpec{ + SchedulingGates: []core.PodSchedulingGate{{Name: "foo"}, {Name: "bar"}}, + }, + }, + err: "Forbidden: only deletion is allowed, but found new scheduling gate 'baz'", + test: "update pod spec schedulingGates: mutating an existing scheduling gate along with deletion", + }, + { + new: core.Pod{}, + old: core.Pod{ + Spec: core.PodSpec{ + SchedulingGates: []core.PodSchedulingGate{{Name: "foo"}}, + }, + }, + err: "", + test: "update pod spec schedulingGates: legal deletion", + }, } for _, test := range tests { test.new.ObjectMeta.ResourceVersion = "1" @@ -18481,6 +18614,7 @@ func TestValidateOSFields(t *testing.T) { "RestartPolicy", "RuntimeClassName", "SchedulerName", + "SchedulingGates[*].Name", "SecurityContext.RunAsNonRoot", "ServiceAccountName", "SetHostnameAsFQDN", @@ -18517,6 +18651,71 @@ func TestValidateOSFields(t *testing.T) { } } +func TestValidateSchedulingGates(t *testing.T) { + fieldPath := field.NewPath("field") + + tests := []struct { + name string + schedulingGates []core.PodSchedulingGate + wantFieldErrors field.ErrorList + }{ + { + name: "nil gates", + schedulingGates: nil, + wantFieldErrors: field.ErrorList{}, + }, + { + name: "empty string in gates", + schedulingGates: []core.PodSchedulingGate{ + {Name: "foo"}, + {Name: ""}, + }, + wantFieldErrors: []*field.Error{field.Required(fieldPath.Index(1), "must not be empty")}, + }, + { + name: "legal gates", + schedulingGates: []core.PodSchedulingGate{ + {Name: "foo"}, + {Name: "bar"}, + }, + wantFieldErrors: field.ErrorList{}, + }, + { + name: "duplicated gates (single duplication)", + schedulingGates: []core.PodSchedulingGate{ + {Name: "foo"}, + {Name: "bar"}, + {Name: "bar"}, + }, + wantFieldErrors: []*field.Error{field.Duplicate(fieldPath.Index(2), "bar")}, + }, + { + name: "duplicated gates (multiple duplications)", + schedulingGates: []core.PodSchedulingGate{ + {Name: "foo"}, + {Name: "bar"}, + {Name: "foo"}, + {Name: "baz"}, + {Name: "foo"}, + {Name: "bar"}, + }, + wantFieldErrors: field.ErrorList{ + field.Duplicate(fieldPath.Index(2), "foo"), + field.Duplicate(fieldPath.Index(4), "foo"), + field.Duplicate(fieldPath.Index(5), "bar"), + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + errs := validateSchedulingGates(tt.schedulingGates, fieldPath) + if diff := cmp.Diff(tt.wantFieldErrors, errs); diff != "" { + t.Errorf("unexpected field errors (-want, +got):\n%s", diff) + } + }) + } +} + // collectResourcePaths traverses the object, computing all the struct paths. func collectResourcePaths(t *testing.T, skipRecurseList sets.String, tp reflect.Type, path *field.Path) sets.String { if pathStr := path.String(); len(pathStr) > 0 && skipRecurseList.Has(pathStr) { @@ -18661,7 +18860,7 @@ func TestValidateSecurityContext(t *testing.T) { } } - //setup data + // setup data allSettings := fullValidSC() noCaps := fullValidSC() noCaps.Capabilities = nil diff --git a/pkg/apis/core/zz_generated.deepcopy.go b/pkg/apis/core/zz_generated.deepcopy.go index 0fd886259b2..8411862b008 100644 --- a/pkg/apis/core/zz_generated.deepcopy.go +++ b/pkg/apis/core/zz_generated.deepcopy.go @@ -3728,6 +3728,22 @@ func (in *PodReadinessGate) DeepCopy() *PodReadinessGate { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PodSchedulingGate) DeepCopyInto(out *PodSchedulingGate) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodSchedulingGate. +func (in *PodSchedulingGate) DeepCopy() *PodSchedulingGate { + if in == nil { + return nil + } + out := new(PodSchedulingGate) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *PodSecurityContext) DeepCopyInto(out *PodSecurityContext) { *out = *in @@ -3961,6 +3977,11 @@ func (in *PodSpec) DeepCopyInto(out *PodSpec) { *out = new(PodOS) **out = **in } + if in.SchedulingGates != nil { + in, out := &in.SchedulingGates, &out.SchedulingGates + *out = make([]PodSchedulingGate, len(*in)) + copy(*out, *in) + } return } diff --git a/pkg/features/kube_features.go b/pkg/features/kube_features.go index 6150cffa7cb..18da94ce825 100644 --- a/pkg/features/kube_features.go +++ b/pkg/features/kube_features.go @@ -643,6 +643,13 @@ const ( // sandbox creation and network configuration completes successfully PodHasNetworkCondition featuregate.Feature = "PodHasNetworkCondition" + // owner: @Huang-Wei + // kep: https://kep.k8s.io/3521 + // alpha: v1.26 + // + // Enable users to specify when a Pod is ready for scheduling. + PodSchedulingReadiness featuregate.Feature = "PodSchedulingReadiness" + // owner: @liggitt, @tallclair, sig-auth // alpha: v1.22 // beta: v1.23 @@ -996,6 +1003,8 @@ var defaultKubernetesFeatureGates = map[featuregate.Feature]featuregate.FeatureS PodHasNetworkCondition: {Default: false, PreRelease: featuregate.Alpha}, + PodSchedulingReadiness: {Default: false, PreRelease: featuregate.Alpha}, + PodSecurity: {Default: true, PreRelease: featuregate.GA, LockToDefault: true}, ProbeTerminationGracePeriod: {Default: true, PreRelease: featuregate.Beta}, // Default to true in beta 1.25 diff --git a/pkg/generated/openapi/zz_generated.openapi.go b/pkg/generated/openapi/zz_generated.openapi.go index 993eef17ce5..0737653b391 100644 --- a/pkg/generated/openapi/zz_generated.openapi.go +++ b/pkg/generated/openapi/zz_generated.openapi.go @@ -448,6 +448,7 @@ func GetOpenAPIDefinitions(ref common.ReferenceCallback) map[string]common.OpenA "k8s.io/api/core/v1.PodPortForwardOptions": schema_k8sio_api_core_v1_PodPortForwardOptions(ref), "k8s.io/api/core/v1.PodProxyOptions": schema_k8sio_api_core_v1_PodProxyOptions(ref), "k8s.io/api/core/v1.PodReadinessGate": schema_k8sio_api_core_v1_PodReadinessGate(ref), + "k8s.io/api/core/v1.PodSchedulingGate": schema_k8sio_api_core_v1_PodSchedulingGate(ref), "k8s.io/api/core/v1.PodSecurityContext": schema_k8sio_api_core_v1_PodSecurityContext(ref), "k8s.io/api/core/v1.PodSignature": schema_k8sio_api_core_v1_PodSignature(ref), "k8s.io/api/core/v1.PodSpec": schema_k8sio_api_core_v1_PodSpec(ref), @@ -22346,6 +22347,28 @@ func schema_k8sio_api_core_v1_PodReadinessGate(ref common.ReferenceCallback) com } } +func schema_k8sio_api_core_v1_PodSchedulingGate(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "PodSchedulingGate is associated to a Pod to guard its scheduling.", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Description: "Name of the scheduling gate. Each scheduling gate must have a unique name field.", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"name"}, + }, + }, + } +} + func schema_k8sio_api_core_v1_PodSecurityContext(ref common.ReferenceCallback) common.OpenAPIDefinition { return common.OpenAPIDefinition{ Schema: spec.Schema{ @@ -22858,12 +22881,36 @@ func schema_k8sio_api_core_v1_PodSpec(ref common.ReferenceCallback) common.OpenA Format: "", }, }, + "schedulingGates": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-list-map-keys": []interface{}{ + "name", + }, + "x-kubernetes-list-type": "map", + "x-kubernetes-patch-merge-key": "name", + "x-kubernetes-patch-strategy": "merge", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "SchedulingGates is an opaque list of values that if specified will block scheduling the pod. More info: https://git.k8s.io/enhancements/keps/sig-scheduling/3521-pod-scheduling-readiness.\n\nThis is an alpha-level feature enabled by PodSchedulingReadiness feature gate.", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("k8s.io/api/core/v1.PodSchedulingGate"), + }, + }, + }, + }, + }, }, Required: []string{"containers"}, }, }, Dependencies: []string{ - "k8s.io/api/core/v1.Affinity", "k8s.io/api/core/v1.Container", "k8s.io/api/core/v1.EphemeralContainer", "k8s.io/api/core/v1.HostAlias", "k8s.io/api/core/v1.LocalObjectReference", "k8s.io/api/core/v1.PodDNSConfig", "k8s.io/api/core/v1.PodOS", "k8s.io/api/core/v1.PodReadinessGate", "k8s.io/api/core/v1.PodSecurityContext", "k8s.io/api/core/v1.Toleration", "k8s.io/api/core/v1.TopologySpreadConstraint", "k8s.io/api/core/v1.Volume", "k8s.io/apimachinery/pkg/api/resource.Quantity"}, + "k8s.io/api/core/v1.Affinity", "k8s.io/api/core/v1.Container", "k8s.io/api/core/v1.EphemeralContainer", "k8s.io/api/core/v1.HostAlias", "k8s.io/api/core/v1.LocalObjectReference", "k8s.io/api/core/v1.PodDNSConfig", "k8s.io/api/core/v1.PodOS", "k8s.io/api/core/v1.PodReadinessGate", "k8s.io/api/core/v1.PodSchedulingGate", "k8s.io/api/core/v1.PodSecurityContext", "k8s.io/api/core/v1.Toleration", "k8s.io/api/core/v1.TopologySpreadConstraint", "k8s.io/api/core/v1.Volume", "k8s.io/apimachinery/pkg/api/resource.Quantity"}, } } diff --git a/pkg/printers/internalversion/printers.go b/pkg/printers/internalversion/printers.go index 2f917745eb9..4238e9e9050 100644 --- a/pkg/printers/internalversion/printers.go +++ b/pkg/printers/internalversion/printers.go @@ -767,6 +767,13 @@ func printPod(pod *api.Pod, options printers.GenerateOptions) ([]metav1.TableRow reason = pod.Status.Reason } + // If the Pod carries {type:PodScheduled, reason:WaitingForGates}, set reason to 'SchedulingGated'. + for _, condition := range pod.Status.Conditions { + if condition.Type == api.PodScheduled && condition.Reason == api.PodReasonSchedulingGated { + reason = api.PodReasonSchedulingGated + } + } + row := metav1.TableRow{ Object: runtime.RawExtension{Object: pod}, } diff --git a/pkg/printers/internalversion/printers_test.go b/pkg/printers/internalversion/printers_test.go index b9ee04bcc4c..2a9c9ef9c6c 100644 --- a/pkg/printers/internalversion/printers_test.go +++ b/pkg/printers/internalversion/printers_test.go @@ -1502,6 +1502,24 @@ func TestPrintPod(t *testing.T) { }, []metav1.TableRow{{Cells: []interface{}{"test14", "2/2", "Running", "9 (5d ago)", ""}}}, }, + { + // Test PodScheduled condition with reason WaitingForGates + api.Pod{ + ObjectMeta: metav1.ObjectMeta{Name: "test15"}, + Spec: api.PodSpec{Containers: make([]api.Container, 2)}, + Status: api.PodStatus{ + Phase: "podPhase", + Conditions: []api.PodCondition{ + { + Type: api.PodScheduled, + Status: api.ConditionFalse, + Reason: api.PodReasonSchedulingGated, + }, + }, + }, + }, + []metav1.TableRow{{Cells: []interface{}{"test15", "0/2", api.PodReasonSchedulingGated, "0", ""}}}, + }, } for i, test := range tests { diff --git a/pkg/registry/core/pod/storage/storage.go b/pkg/registry/core/pod/storage/storage.go index db21b59da4d..3960918de62 100644 --- a/pkg/registry/core/pod/storage/storage.go +++ b/pkg/registry/core/pod/storage/storage.go @@ -33,10 +33,12 @@ import ( "k8s.io/apiserver/pkg/storage" storeerr "k8s.io/apiserver/pkg/storage/errors" "k8s.io/apiserver/pkg/util/dryrun" + utilfeature "k8s.io/apiserver/pkg/util/feature" policyclient "k8s.io/client-go/kubernetes/typed/policy/v1" podutil "k8s.io/kubernetes/pkg/api/pod" api "k8s.io/kubernetes/pkg/apis/core" "k8s.io/kubernetes/pkg/apis/core/validation" + "k8s.io/kubernetes/pkg/features" "k8s.io/kubernetes/pkg/kubelet/client" "k8s.io/kubernetes/pkg/printers" printersinternal "k8s.io/kubernetes/pkg/printers/internalversion" @@ -221,6 +223,10 @@ func (r *BindingREST) setPodHostAndAnnotations(ctx context.Context, podUID types if pod.Spec.NodeName != "" { return nil, fmt.Errorf("pod %v is already assigned to node %q", pod.Name, pod.Spec.NodeName) } + // Reject binding to a scheduling un-ready Pod. + if utilfeature.DefaultFeatureGate.Enabled(features.PodSchedulingReadiness) && len(pod.Spec.SchedulingGates) != 0 { + return nil, fmt.Errorf("pod %v has non-empty .spec.schedulingGates", pod.Name) + } pod.Spec.NodeName = machine if pod.Annotations == nil { pod.Annotations = make(map[string]string) diff --git a/pkg/registry/core/pod/storage/storage_test.go b/pkg/registry/core/pod/storage/storage_test.go index 4f671e2c48b..1e15ca8a834 100644 --- a/pkg/registry/core/pod/storage/storage_test.go +++ b/pkg/registry/core/pod/storage/storage_test.go @@ -18,6 +18,7 @@ package storage import ( "context" + goerrors "errors" "fmt" "net/url" "strings" @@ -41,7 +42,10 @@ import ( apiserverstorage "k8s.io/apiserver/pkg/storage" storeerr "k8s.io/apiserver/pkg/storage/errors" etcd3testing "k8s.io/apiserver/pkg/storage/etcd3/testing" + utilfeature "k8s.io/apiserver/pkg/util/feature" + featuregatetesting "k8s.io/component-base/featuregate/testing" api "k8s.io/kubernetes/pkg/apis/core" + "k8s.io/kubernetes/pkg/features" "k8s.io/kubernetes/pkg/registry/registrytest" "k8s.io/kubernetes/pkg/securitycontext" ) @@ -745,6 +749,77 @@ func TestEtcdCreateWithConflict(t *testing.T) { } } +func TestEtcdCreateWithSchedulingGates(t *testing.T) { + tests := []struct { + name string + featureEnabled bool + schedulingGates []api.PodSchedulingGate + wantErr error + }{ + { + name: "pod with non-nil schedulingGates, feature disabled", + featureEnabled: false, + schedulingGates: []api.PodSchedulingGate{ + {Name: "foo"}, + {Name: "bar"}, + }, + wantErr: nil, + }, + { + name: "pod with non-nil schedulingGates, feature enabled", + featureEnabled: true, + schedulingGates: []api.PodSchedulingGate{ + {Name: "foo"}, + {Name: "bar"}, + }, + wantErr: goerrors.New(`Operation cannot be fulfilled on pods/binding "foo": pod foo has non-empty .spec.schedulingGates`), + }, + { + name: "pod with nil schedulingGates, feature disabled", + featureEnabled: false, + schedulingGates: nil, + wantErr: nil, + }, + { + name: "pod with nil schedulingGates, feature enabled", + featureEnabled: true, + schedulingGates: nil, + wantErr: nil, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.PodSchedulingReadiness, tt.featureEnabled)() + storage, bindingStorage, _, server := newStorage(t) + defer server.Terminate(t) + defer storage.Store.DestroyFunc() + ctx := genericapirequest.NewDefaultContext() + + pod := validNewPod() + pod.Spec.SchedulingGates = tt.schedulingGates + if _, err := storage.Create(ctx, pod, rest.ValidateAllObjectFunc, &metav1.CreateOptions{}); err != nil { + t.Fatalf("Unexpected error: %v", err) + } + _, err := bindingStorage.Create(ctx, "foo", &api.Binding{ + ObjectMeta: metav1.ObjectMeta{Namespace: metav1.NamespaceDefault, Name: "foo"}, + Target: api.ObjectReference{Name: "machine"}, + }, rest.ValidateAllObjectFunc, &metav1.CreateOptions{}) + if tt.wantErr == nil { + if err != nil { + t.Errorf("Want nil err, but got %v", err) + } + } else { + if err == nil { + t.Errorf("Want %v, but got nil err", tt.wantErr) + } else if tt.wantErr.Error() != err.Error() { + t.Errorf("Want %v, but got %v", tt.wantErr, err) + } + } + }) + } +} + func validNewBinding() *api.Binding { return &api.Binding{ ObjectMeta: metav1.ObjectMeta{Name: "foo"}, diff --git a/pkg/registry/core/pod/strategy.go b/pkg/registry/core/pod/strategy.go index 5a50105cadc..4021b4eb4fb 100644 --- a/pkg/registry/core/pod/strategy.go +++ b/pkg/registry/core/pod/strategy.go @@ -38,12 +38,14 @@ import ( "k8s.io/apiserver/pkg/registry/generic" "k8s.io/apiserver/pkg/storage" "k8s.io/apiserver/pkg/storage/names" + utilfeature "k8s.io/apiserver/pkg/util/feature" "k8s.io/client-go/tools/cache" "k8s.io/kubernetes/pkg/api/legacyscheme" podutil "k8s.io/kubernetes/pkg/api/pod" api "k8s.io/kubernetes/pkg/apis/core" "k8s.io/kubernetes/pkg/apis/core/helper/qos" "k8s.io/kubernetes/pkg/apis/core/validation" + "k8s.io/kubernetes/pkg/features" "k8s.io/kubernetes/pkg/kubelet/client" proxyutil "k8s.io/kubernetes/pkg/proxy/util" "sigs.k8s.io/structured-merge-diff/v4/fieldpath" @@ -87,6 +89,7 @@ func (podStrategy) PrepareForCreate(ctx context.Context, obj runtime.Object) { podutil.DropDisabledPodFields(pod, nil) applySeccompVersionSkew(pod) + applyWaitingForSchedulingGatesCondition(pod) } // PrepareForUpdate clears fields that are not allowed to be set by end users on update. @@ -642,6 +645,29 @@ func validateContainer(container string, pod *api.Pod) (string, error) { return container, nil } +// applyWaitingForSchedulingGatesCondition adds a {type:PodScheduled, reason:WaitingForGates} condition +// to a new-created Pod if necessary. +func applyWaitingForSchedulingGatesCondition(pod *api.Pod) { + if !utilfeature.DefaultFeatureGate.Enabled(features.PodSchedulingReadiness) || + len(pod.Spec.SchedulingGates) == 0 { + return + } + + // If found a condition with type PodScheduled, return. + for _, condition := range pod.Status.Conditions { + if condition.Type == api.PodScheduled { + return + } + } + + pod.Status.Conditions = append(pod.Status.Conditions, api.PodCondition{ + Type: api.PodScheduled, + Status: api.ConditionFalse, + Reason: api.PodReasonSchedulingGated, + Message: "Scheduling is blocked due to non-empty scheduling gates", + }) +} + // applySeccompVersionSkew implements the version skew behavior described in: // https://github.com/kubernetes/enhancements/tree/master/keps/sig-node/135-seccomp#version-skew-strategy // Note that we dropped copying the field to annotation synchronization in diff --git a/pkg/registry/core/pod/strategy_test.go b/pkg/registry/core/pod/strategy_test.go index a6e4a530eb7..e8896c77216 100644 --- a/pkg/registry/core/pod/strategy_test.go +++ b/pkg/registry/core/pod/strategy_test.go @@ -35,9 +35,12 @@ import ( "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/types" genericapirequest "k8s.io/apiserver/pkg/endpoints/request" + utilfeature "k8s.io/apiserver/pkg/util/feature" "k8s.io/client-go/tools/cache" + featuregatetesting "k8s.io/component-base/featuregate/testing" apitesting "k8s.io/kubernetes/pkg/api/testing" api "k8s.io/kubernetes/pkg/apis/core" + "k8s.io/kubernetes/pkg/features" "k8s.io/kubernetes/pkg/kubelet/client" utilpointer "k8s.io/utils/pointer" @@ -261,6 +264,72 @@ func TestGetPodQOS(t *testing.T) { } } +func TestWaitingForGatesCondition(t *testing.T) { + tests := []struct { + name string + pod *api.Pod + featureEnabled bool + want api.PodCondition + }{ + { + name: "pod without .spec.schedulingGates, feature disabled", + pod: &api.Pod{}, + featureEnabled: false, + want: api.PodCondition{}, + }, + { + name: "pod without .spec.schedulingGates, feature enabled", + pod: &api.Pod{}, + featureEnabled: true, + want: api.PodCondition{}, + }, + { + name: "pod with .spec.schedulingGates, feature disabled", + pod: &api.Pod{ + Spec: api.PodSpec{ + SchedulingGates: []api.PodSchedulingGate{{Name: "foo"}}, + }, + }, + featureEnabled: false, + want: api.PodCondition{}, + }, + { + name: "pod with .spec.schedulingGates, feature enabled", + pod: &api.Pod{ + Spec: api.PodSpec{ + SchedulingGates: []api.PodSchedulingGate{{Name: "foo"}}, + }, + }, + featureEnabled: true, + want: api.PodCondition{ + Type: api.PodScheduled, + Status: api.ConditionFalse, + Reason: api.PodReasonSchedulingGated, + Message: "Scheduling is blocked due to non-empty scheduling gates", + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.PodSchedulingReadiness, tt.featureEnabled)() + + Strategy.PrepareForCreate(genericapirequest.NewContext(), tt.pod) + var got api.PodCondition + for _, condition := range tt.pod.Status.Conditions { + if condition.Type == api.PodScheduled { + got = condition + break + } + } + + if diff := cmp.Diff(tt.want, got); diff != "" { + t.Errorf("unexpected field errors (-want, +got):\n%s", diff) + } + }) + } +} + func TestCheckGracefulDelete(t *testing.T) { defaultGracePeriod := int64(30) tcs := []struct { 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 aa62ba138fd..88fe74cf973 100644 --- a/staging/src/k8s.io/api/core/v1/generated.pb.go +++ b/staging/src/k8s.io/api/core/v1/generated.pb.go @@ -3829,10 +3829,38 @@ func (m *PodReadinessGate) XXX_DiscardUnknown() { var xxx_messageInfo_PodReadinessGate proto.InternalMessageInfo +func (m *PodSchedulingGate) Reset() { *m = PodSchedulingGate{} } +func (*PodSchedulingGate) ProtoMessage() {} +func (*PodSchedulingGate) Descriptor() ([]byte, []int) { + return fileDescriptor_83c10c24ec417dc9, []int{135} +} +func (m *PodSchedulingGate) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PodSchedulingGate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *PodSchedulingGate) XXX_Merge(src proto.Message) { + xxx_messageInfo_PodSchedulingGate.Merge(m, src) +} +func (m *PodSchedulingGate) XXX_Size() int { + return m.Size() +} +func (m *PodSchedulingGate) XXX_DiscardUnknown() { + xxx_messageInfo_PodSchedulingGate.DiscardUnknown(m) +} + +var xxx_messageInfo_PodSchedulingGate proto.InternalMessageInfo + func (m *PodSecurityContext) Reset() { *m = PodSecurityContext{} } func (*PodSecurityContext) ProtoMessage() {} func (*PodSecurityContext) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{135} + return fileDescriptor_83c10c24ec417dc9, []int{136} } func (m *PodSecurityContext) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3860,7 +3888,7 @@ var xxx_messageInfo_PodSecurityContext proto.InternalMessageInfo func (m *PodSignature) Reset() { *m = PodSignature{} } func (*PodSignature) ProtoMessage() {} func (*PodSignature) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{136} + return fileDescriptor_83c10c24ec417dc9, []int{137} } func (m *PodSignature) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3888,7 +3916,7 @@ var xxx_messageInfo_PodSignature proto.InternalMessageInfo func (m *PodSpec) Reset() { *m = PodSpec{} } func (*PodSpec) ProtoMessage() {} func (*PodSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{137} + return fileDescriptor_83c10c24ec417dc9, []int{138} } func (m *PodSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3916,7 +3944,7 @@ var xxx_messageInfo_PodSpec proto.InternalMessageInfo func (m *PodStatus) Reset() { *m = PodStatus{} } func (*PodStatus) ProtoMessage() {} func (*PodStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{138} + return fileDescriptor_83c10c24ec417dc9, []int{139} } func (m *PodStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3944,7 +3972,7 @@ var xxx_messageInfo_PodStatus proto.InternalMessageInfo func (m *PodStatusResult) Reset() { *m = PodStatusResult{} } func (*PodStatusResult) ProtoMessage() {} func (*PodStatusResult) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{139} + return fileDescriptor_83c10c24ec417dc9, []int{140} } func (m *PodStatusResult) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3972,7 +4000,7 @@ var xxx_messageInfo_PodStatusResult proto.InternalMessageInfo func (m *PodTemplate) Reset() { *m = PodTemplate{} } func (*PodTemplate) ProtoMessage() {} func (*PodTemplate) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{140} + return fileDescriptor_83c10c24ec417dc9, []int{141} } func (m *PodTemplate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4000,7 +4028,7 @@ var xxx_messageInfo_PodTemplate proto.InternalMessageInfo func (m *PodTemplateList) Reset() { *m = PodTemplateList{} } func (*PodTemplateList) ProtoMessage() {} func (*PodTemplateList) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{141} + return fileDescriptor_83c10c24ec417dc9, []int{142} } func (m *PodTemplateList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4028,7 +4056,7 @@ var xxx_messageInfo_PodTemplateList proto.InternalMessageInfo func (m *PodTemplateSpec) Reset() { *m = PodTemplateSpec{} } func (*PodTemplateSpec) ProtoMessage() {} func (*PodTemplateSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{142} + return fileDescriptor_83c10c24ec417dc9, []int{143} } func (m *PodTemplateSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4056,7 +4084,7 @@ var xxx_messageInfo_PodTemplateSpec proto.InternalMessageInfo func (m *PortStatus) Reset() { *m = PortStatus{} } func (*PortStatus) ProtoMessage() {} func (*PortStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{143} + return fileDescriptor_83c10c24ec417dc9, []int{144} } func (m *PortStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4084,7 +4112,7 @@ var xxx_messageInfo_PortStatus proto.InternalMessageInfo func (m *PortworxVolumeSource) Reset() { *m = PortworxVolumeSource{} } func (*PortworxVolumeSource) ProtoMessage() {} func (*PortworxVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{144} + return fileDescriptor_83c10c24ec417dc9, []int{145} } func (m *PortworxVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4112,7 +4140,7 @@ var xxx_messageInfo_PortworxVolumeSource proto.InternalMessageInfo func (m *Preconditions) Reset() { *m = Preconditions{} } func (*Preconditions) ProtoMessage() {} func (*Preconditions) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{145} + return fileDescriptor_83c10c24ec417dc9, []int{146} } func (m *Preconditions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4140,7 +4168,7 @@ var xxx_messageInfo_Preconditions proto.InternalMessageInfo func (m *PreferAvoidPodsEntry) Reset() { *m = PreferAvoidPodsEntry{} } func (*PreferAvoidPodsEntry) ProtoMessage() {} func (*PreferAvoidPodsEntry) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{146} + return fileDescriptor_83c10c24ec417dc9, []int{147} } func (m *PreferAvoidPodsEntry) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4168,7 +4196,7 @@ var xxx_messageInfo_PreferAvoidPodsEntry proto.InternalMessageInfo func (m *PreferredSchedulingTerm) Reset() { *m = PreferredSchedulingTerm{} } func (*PreferredSchedulingTerm) ProtoMessage() {} func (*PreferredSchedulingTerm) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{147} + return fileDescriptor_83c10c24ec417dc9, []int{148} } func (m *PreferredSchedulingTerm) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4196,7 +4224,7 @@ var xxx_messageInfo_PreferredSchedulingTerm proto.InternalMessageInfo func (m *Probe) Reset() { *m = Probe{} } func (*Probe) ProtoMessage() {} func (*Probe) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{148} + return fileDescriptor_83c10c24ec417dc9, []int{149} } func (m *Probe) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4224,7 +4252,7 @@ var xxx_messageInfo_Probe proto.InternalMessageInfo func (m *ProbeHandler) Reset() { *m = ProbeHandler{} } func (*ProbeHandler) ProtoMessage() {} func (*ProbeHandler) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{149} + return fileDescriptor_83c10c24ec417dc9, []int{150} } func (m *ProbeHandler) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4252,7 +4280,7 @@ var xxx_messageInfo_ProbeHandler proto.InternalMessageInfo func (m *ProjectedVolumeSource) Reset() { *m = ProjectedVolumeSource{} } func (*ProjectedVolumeSource) ProtoMessage() {} func (*ProjectedVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{150} + return fileDescriptor_83c10c24ec417dc9, []int{151} } func (m *ProjectedVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4280,7 +4308,7 @@ var xxx_messageInfo_ProjectedVolumeSource proto.InternalMessageInfo func (m *QuobyteVolumeSource) Reset() { *m = QuobyteVolumeSource{} } func (*QuobyteVolumeSource) ProtoMessage() {} func (*QuobyteVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{151} + return fileDescriptor_83c10c24ec417dc9, []int{152} } func (m *QuobyteVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4308,7 +4336,7 @@ var xxx_messageInfo_QuobyteVolumeSource proto.InternalMessageInfo func (m *RBDPersistentVolumeSource) Reset() { *m = RBDPersistentVolumeSource{} } func (*RBDPersistentVolumeSource) ProtoMessage() {} func (*RBDPersistentVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{152} + return fileDescriptor_83c10c24ec417dc9, []int{153} } func (m *RBDPersistentVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4336,7 +4364,7 @@ var xxx_messageInfo_RBDPersistentVolumeSource proto.InternalMessageInfo func (m *RBDVolumeSource) Reset() { *m = RBDVolumeSource{} } func (*RBDVolumeSource) ProtoMessage() {} func (*RBDVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{153} + return fileDescriptor_83c10c24ec417dc9, []int{154} } func (m *RBDVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4364,7 +4392,7 @@ var xxx_messageInfo_RBDVolumeSource proto.InternalMessageInfo func (m *RangeAllocation) Reset() { *m = RangeAllocation{} } func (*RangeAllocation) ProtoMessage() {} func (*RangeAllocation) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{154} + return fileDescriptor_83c10c24ec417dc9, []int{155} } func (m *RangeAllocation) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4392,7 +4420,7 @@ var xxx_messageInfo_RangeAllocation proto.InternalMessageInfo func (m *ReplicationController) Reset() { *m = ReplicationController{} } func (*ReplicationController) ProtoMessage() {} func (*ReplicationController) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{155} + return fileDescriptor_83c10c24ec417dc9, []int{156} } func (m *ReplicationController) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4420,7 +4448,7 @@ var xxx_messageInfo_ReplicationController proto.InternalMessageInfo func (m *ReplicationControllerCondition) Reset() { *m = ReplicationControllerCondition{} } func (*ReplicationControllerCondition) ProtoMessage() {} func (*ReplicationControllerCondition) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{156} + return fileDescriptor_83c10c24ec417dc9, []int{157} } func (m *ReplicationControllerCondition) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4448,7 +4476,7 @@ var xxx_messageInfo_ReplicationControllerCondition proto.InternalMessageInfo func (m *ReplicationControllerList) Reset() { *m = ReplicationControllerList{} } func (*ReplicationControllerList) ProtoMessage() {} func (*ReplicationControllerList) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{157} + return fileDescriptor_83c10c24ec417dc9, []int{158} } func (m *ReplicationControllerList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4476,7 +4504,7 @@ var xxx_messageInfo_ReplicationControllerList proto.InternalMessageInfo func (m *ReplicationControllerSpec) Reset() { *m = ReplicationControllerSpec{} } func (*ReplicationControllerSpec) ProtoMessage() {} func (*ReplicationControllerSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{158} + return fileDescriptor_83c10c24ec417dc9, []int{159} } func (m *ReplicationControllerSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4504,7 +4532,7 @@ var xxx_messageInfo_ReplicationControllerSpec proto.InternalMessageInfo func (m *ReplicationControllerStatus) Reset() { *m = ReplicationControllerStatus{} } func (*ReplicationControllerStatus) ProtoMessage() {} func (*ReplicationControllerStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{159} + return fileDescriptor_83c10c24ec417dc9, []int{160} } func (m *ReplicationControllerStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4532,7 +4560,7 @@ var xxx_messageInfo_ReplicationControllerStatus proto.InternalMessageInfo func (m *ResourceFieldSelector) Reset() { *m = ResourceFieldSelector{} } func (*ResourceFieldSelector) ProtoMessage() {} func (*ResourceFieldSelector) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{160} + return fileDescriptor_83c10c24ec417dc9, []int{161} } func (m *ResourceFieldSelector) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4560,7 +4588,7 @@ var xxx_messageInfo_ResourceFieldSelector proto.InternalMessageInfo func (m *ResourceQuota) Reset() { *m = ResourceQuota{} } func (*ResourceQuota) ProtoMessage() {} func (*ResourceQuota) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{161} + return fileDescriptor_83c10c24ec417dc9, []int{162} } func (m *ResourceQuota) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4588,7 +4616,7 @@ var xxx_messageInfo_ResourceQuota proto.InternalMessageInfo func (m *ResourceQuotaList) Reset() { *m = ResourceQuotaList{} } func (*ResourceQuotaList) ProtoMessage() {} func (*ResourceQuotaList) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{162} + return fileDescriptor_83c10c24ec417dc9, []int{163} } func (m *ResourceQuotaList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4616,7 +4644,7 @@ var xxx_messageInfo_ResourceQuotaList proto.InternalMessageInfo func (m *ResourceQuotaSpec) Reset() { *m = ResourceQuotaSpec{} } func (*ResourceQuotaSpec) ProtoMessage() {} func (*ResourceQuotaSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{163} + return fileDescriptor_83c10c24ec417dc9, []int{164} } func (m *ResourceQuotaSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4644,7 +4672,7 @@ var xxx_messageInfo_ResourceQuotaSpec proto.InternalMessageInfo func (m *ResourceQuotaStatus) Reset() { *m = ResourceQuotaStatus{} } func (*ResourceQuotaStatus) ProtoMessage() {} func (*ResourceQuotaStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{164} + return fileDescriptor_83c10c24ec417dc9, []int{165} } func (m *ResourceQuotaStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4672,7 +4700,7 @@ var xxx_messageInfo_ResourceQuotaStatus proto.InternalMessageInfo func (m *ResourceRequirements) Reset() { *m = ResourceRequirements{} } func (*ResourceRequirements) ProtoMessage() {} func (*ResourceRequirements) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{165} + return fileDescriptor_83c10c24ec417dc9, []int{166} } func (m *ResourceRequirements) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4700,7 +4728,7 @@ var xxx_messageInfo_ResourceRequirements proto.InternalMessageInfo func (m *SELinuxOptions) Reset() { *m = SELinuxOptions{} } func (*SELinuxOptions) ProtoMessage() {} func (*SELinuxOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{166} + return fileDescriptor_83c10c24ec417dc9, []int{167} } func (m *SELinuxOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4728,7 +4756,7 @@ var xxx_messageInfo_SELinuxOptions proto.InternalMessageInfo func (m *ScaleIOPersistentVolumeSource) Reset() { *m = ScaleIOPersistentVolumeSource{} } func (*ScaleIOPersistentVolumeSource) ProtoMessage() {} func (*ScaleIOPersistentVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{167} + return fileDescriptor_83c10c24ec417dc9, []int{168} } func (m *ScaleIOPersistentVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4756,7 +4784,7 @@ var xxx_messageInfo_ScaleIOPersistentVolumeSource proto.InternalMessageInfo func (m *ScaleIOVolumeSource) Reset() { *m = ScaleIOVolumeSource{} } func (*ScaleIOVolumeSource) ProtoMessage() {} func (*ScaleIOVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{168} + return fileDescriptor_83c10c24ec417dc9, []int{169} } func (m *ScaleIOVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4784,7 +4812,7 @@ var xxx_messageInfo_ScaleIOVolumeSource proto.InternalMessageInfo func (m *ScopeSelector) Reset() { *m = ScopeSelector{} } func (*ScopeSelector) ProtoMessage() {} func (*ScopeSelector) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{169} + return fileDescriptor_83c10c24ec417dc9, []int{170} } func (m *ScopeSelector) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4812,7 +4840,7 @@ var xxx_messageInfo_ScopeSelector proto.InternalMessageInfo func (m *ScopedResourceSelectorRequirement) Reset() { *m = ScopedResourceSelectorRequirement{} } func (*ScopedResourceSelectorRequirement) ProtoMessage() {} func (*ScopedResourceSelectorRequirement) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{170} + return fileDescriptor_83c10c24ec417dc9, []int{171} } func (m *ScopedResourceSelectorRequirement) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4840,7 +4868,7 @@ var xxx_messageInfo_ScopedResourceSelectorRequirement proto.InternalMessageInfo func (m *SeccompProfile) Reset() { *m = SeccompProfile{} } func (*SeccompProfile) ProtoMessage() {} func (*SeccompProfile) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{171} + return fileDescriptor_83c10c24ec417dc9, []int{172} } func (m *SeccompProfile) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4868,7 +4896,7 @@ var xxx_messageInfo_SeccompProfile proto.InternalMessageInfo func (m *Secret) Reset() { *m = Secret{} } func (*Secret) ProtoMessage() {} func (*Secret) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{172} + return fileDescriptor_83c10c24ec417dc9, []int{173} } func (m *Secret) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4896,7 +4924,7 @@ var xxx_messageInfo_Secret proto.InternalMessageInfo func (m *SecretEnvSource) Reset() { *m = SecretEnvSource{} } func (*SecretEnvSource) ProtoMessage() {} func (*SecretEnvSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{173} + return fileDescriptor_83c10c24ec417dc9, []int{174} } func (m *SecretEnvSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4924,7 +4952,7 @@ var xxx_messageInfo_SecretEnvSource proto.InternalMessageInfo func (m *SecretKeySelector) Reset() { *m = SecretKeySelector{} } func (*SecretKeySelector) ProtoMessage() {} func (*SecretKeySelector) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{174} + return fileDescriptor_83c10c24ec417dc9, []int{175} } func (m *SecretKeySelector) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4952,7 +4980,7 @@ var xxx_messageInfo_SecretKeySelector proto.InternalMessageInfo func (m *SecretList) Reset() { *m = SecretList{} } func (*SecretList) ProtoMessage() {} func (*SecretList) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{175} + return fileDescriptor_83c10c24ec417dc9, []int{176} } func (m *SecretList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4980,7 +5008,7 @@ var xxx_messageInfo_SecretList proto.InternalMessageInfo func (m *SecretProjection) Reset() { *m = SecretProjection{} } func (*SecretProjection) ProtoMessage() {} func (*SecretProjection) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{176} + return fileDescriptor_83c10c24ec417dc9, []int{177} } func (m *SecretProjection) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5008,7 +5036,7 @@ var xxx_messageInfo_SecretProjection proto.InternalMessageInfo func (m *SecretReference) Reset() { *m = SecretReference{} } func (*SecretReference) ProtoMessage() {} func (*SecretReference) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{177} + return fileDescriptor_83c10c24ec417dc9, []int{178} } func (m *SecretReference) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5036,7 +5064,7 @@ var xxx_messageInfo_SecretReference proto.InternalMessageInfo func (m *SecretVolumeSource) Reset() { *m = SecretVolumeSource{} } func (*SecretVolumeSource) ProtoMessage() {} func (*SecretVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{178} + return fileDescriptor_83c10c24ec417dc9, []int{179} } func (m *SecretVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5064,7 +5092,7 @@ var xxx_messageInfo_SecretVolumeSource proto.InternalMessageInfo func (m *SecurityContext) Reset() { *m = SecurityContext{} } func (*SecurityContext) ProtoMessage() {} func (*SecurityContext) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{179} + return fileDescriptor_83c10c24ec417dc9, []int{180} } func (m *SecurityContext) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5092,7 +5120,7 @@ var xxx_messageInfo_SecurityContext proto.InternalMessageInfo func (m *SerializedReference) Reset() { *m = SerializedReference{} } func (*SerializedReference) ProtoMessage() {} func (*SerializedReference) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{180} + return fileDescriptor_83c10c24ec417dc9, []int{181} } func (m *SerializedReference) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5120,7 +5148,7 @@ var xxx_messageInfo_SerializedReference proto.InternalMessageInfo func (m *Service) Reset() { *m = Service{} } func (*Service) ProtoMessage() {} func (*Service) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{181} + return fileDescriptor_83c10c24ec417dc9, []int{182} } func (m *Service) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5148,7 +5176,7 @@ var xxx_messageInfo_Service proto.InternalMessageInfo func (m *ServiceAccount) Reset() { *m = ServiceAccount{} } func (*ServiceAccount) ProtoMessage() {} func (*ServiceAccount) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{182} + return fileDescriptor_83c10c24ec417dc9, []int{183} } func (m *ServiceAccount) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5176,7 +5204,7 @@ var xxx_messageInfo_ServiceAccount proto.InternalMessageInfo func (m *ServiceAccountList) Reset() { *m = ServiceAccountList{} } func (*ServiceAccountList) ProtoMessage() {} func (*ServiceAccountList) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{183} + return fileDescriptor_83c10c24ec417dc9, []int{184} } func (m *ServiceAccountList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5204,7 +5232,7 @@ var xxx_messageInfo_ServiceAccountList proto.InternalMessageInfo func (m *ServiceAccountTokenProjection) Reset() { *m = ServiceAccountTokenProjection{} } func (*ServiceAccountTokenProjection) ProtoMessage() {} func (*ServiceAccountTokenProjection) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{184} + return fileDescriptor_83c10c24ec417dc9, []int{185} } func (m *ServiceAccountTokenProjection) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5232,7 +5260,7 @@ var xxx_messageInfo_ServiceAccountTokenProjection proto.InternalMessageInfo func (m *ServiceList) Reset() { *m = ServiceList{} } func (*ServiceList) ProtoMessage() {} func (*ServiceList) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{185} + return fileDescriptor_83c10c24ec417dc9, []int{186} } func (m *ServiceList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5260,7 +5288,7 @@ var xxx_messageInfo_ServiceList proto.InternalMessageInfo func (m *ServicePort) Reset() { *m = ServicePort{} } func (*ServicePort) ProtoMessage() {} func (*ServicePort) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{186} + return fileDescriptor_83c10c24ec417dc9, []int{187} } func (m *ServicePort) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5288,7 +5316,7 @@ var xxx_messageInfo_ServicePort proto.InternalMessageInfo func (m *ServiceProxyOptions) Reset() { *m = ServiceProxyOptions{} } func (*ServiceProxyOptions) ProtoMessage() {} func (*ServiceProxyOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{187} + return fileDescriptor_83c10c24ec417dc9, []int{188} } func (m *ServiceProxyOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5316,7 +5344,7 @@ var xxx_messageInfo_ServiceProxyOptions proto.InternalMessageInfo func (m *ServiceSpec) Reset() { *m = ServiceSpec{} } func (*ServiceSpec) ProtoMessage() {} func (*ServiceSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{188} + return fileDescriptor_83c10c24ec417dc9, []int{189} } func (m *ServiceSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5344,7 +5372,7 @@ var xxx_messageInfo_ServiceSpec proto.InternalMessageInfo func (m *ServiceStatus) Reset() { *m = ServiceStatus{} } func (*ServiceStatus) ProtoMessage() {} func (*ServiceStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{189} + return fileDescriptor_83c10c24ec417dc9, []int{190} } func (m *ServiceStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5372,7 +5400,7 @@ var xxx_messageInfo_ServiceStatus proto.InternalMessageInfo func (m *SessionAffinityConfig) Reset() { *m = SessionAffinityConfig{} } func (*SessionAffinityConfig) ProtoMessage() {} func (*SessionAffinityConfig) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{190} + return fileDescriptor_83c10c24ec417dc9, []int{191} } func (m *SessionAffinityConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5400,7 +5428,7 @@ var xxx_messageInfo_SessionAffinityConfig proto.InternalMessageInfo func (m *StorageOSPersistentVolumeSource) Reset() { *m = StorageOSPersistentVolumeSource{} } func (*StorageOSPersistentVolumeSource) ProtoMessage() {} func (*StorageOSPersistentVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{191} + return fileDescriptor_83c10c24ec417dc9, []int{192} } func (m *StorageOSPersistentVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5428,7 +5456,7 @@ var xxx_messageInfo_StorageOSPersistentVolumeSource proto.InternalMessageInfo func (m *StorageOSVolumeSource) Reset() { *m = StorageOSVolumeSource{} } func (*StorageOSVolumeSource) ProtoMessage() {} func (*StorageOSVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{192} + return fileDescriptor_83c10c24ec417dc9, []int{193} } func (m *StorageOSVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5456,7 +5484,7 @@ var xxx_messageInfo_StorageOSVolumeSource proto.InternalMessageInfo func (m *Sysctl) Reset() { *m = Sysctl{} } func (*Sysctl) ProtoMessage() {} func (*Sysctl) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{193} + return fileDescriptor_83c10c24ec417dc9, []int{194} } func (m *Sysctl) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5484,7 +5512,7 @@ var xxx_messageInfo_Sysctl proto.InternalMessageInfo func (m *TCPSocketAction) Reset() { *m = TCPSocketAction{} } func (*TCPSocketAction) ProtoMessage() {} func (*TCPSocketAction) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{194} + return fileDescriptor_83c10c24ec417dc9, []int{195} } func (m *TCPSocketAction) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5512,7 +5540,7 @@ var xxx_messageInfo_TCPSocketAction proto.InternalMessageInfo func (m *Taint) Reset() { *m = Taint{} } func (*Taint) ProtoMessage() {} func (*Taint) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{195} + return fileDescriptor_83c10c24ec417dc9, []int{196} } func (m *Taint) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5540,7 +5568,7 @@ var xxx_messageInfo_Taint proto.InternalMessageInfo func (m *Toleration) Reset() { *m = Toleration{} } func (*Toleration) ProtoMessage() {} func (*Toleration) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{196} + return fileDescriptor_83c10c24ec417dc9, []int{197} } func (m *Toleration) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5568,7 +5596,7 @@ var xxx_messageInfo_Toleration proto.InternalMessageInfo func (m *TopologySelectorLabelRequirement) Reset() { *m = TopologySelectorLabelRequirement{} } func (*TopologySelectorLabelRequirement) ProtoMessage() {} func (*TopologySelectorLabelRequirement) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{197} + return fileDescriptor_83c10c24ec417dc9, []int{198} } func (m *TopologySelectorLabelRequirement) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5596,7 +5624,7 @@ var xxx_messageInfo_TopologySelectorLabelRequirement proto.InternalMessageInfo func (m *TopologySelectorTerm) Reset() { *m = TopologySelectorTerm{} } func (*TopologySelectorTerm) ProtoMessage() {} func (*TopologySelectorTerm) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{198} + return fileDescriptor_83c10c24ec417dc9, []int{199} } func (m *TopologySelectorTerm) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5624,7 +5652,7 @@ var xxx_messageInfo_TopologySelectorTerm proto.InternalMessageInfo func (m *TopologySpreadConstraint) Reset() { *m = TopologySpreadConstraint{} } func (*TopologySpreadConstraint) ProtoMessage() {} func (*TopologySpreadConstraint) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{199} + return fileDescriptor_83c10c24ec417dc9, []int{200} } func (m *TopologySpreadConstraint) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5652,7 +5680,7 @@ var xxx_messageInfo_TopologySpreadConstraint proto.InternalMessageInfo func (m *TypedLocalObjectReference) Reset() { *m = TypedLocalObjectReference{} } func (*TypedLocalObjectReference) ProtoMessage() {} func (*TypedLocalObjectReference) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{200} + return fileDescriptor_83c10c24ec417dc9, []int{201} } func (m *TypedLocalObjectReference) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5680,7 +5708,7 @@ var xxx_messageInfo_TypedLocalObjectReference proto.InternalMessageInfo func (m *Volume) Reset() { *m = Volume{} } func (*Volume) ProtoMessage() {} func (*Volume) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{201} + return fileDescriptor_83c10c24ec417dc9, []int{202} } func (m *Volume) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5708,7 +5736,7 @@ var xxx_messageInfo_Volume proto.InternalMessageInfo func (m *VolumeDevice) Reset() { *m = VolumeDevice{} } func (*VolumeDevice) ProtoMessage() {} func (*VolumeDevice) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{202} + return fileDescriptor_83c10c24ec417dc9, []int{203} } func (m *VolumeDevice) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5736,7 +5764,7 @@ var xxx_messageInfo_VolumeDevice proto.InternalMessageInfo func (m *VolumeMount) Reset() { *m = VolumeMount{} } func (*VolumeMount) ProtoMessage() {} func (*VolumeMount) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{203} + return fileDescriptor_83c10c24ec417dc9, []int{204} } func (m *VolumeMount) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5764,7 +5792,7 @@ var xxx_messageInfo_VolumeMount proto.InternalMessageInfo func (m *VolumeNodeAffinity) Reset() { *m = VolumeNodeAffinity{} } func (*VolumeNodeAffinity) ProtoMessage() {} func (*VolumeNodeAffinity) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{204} + return fileDescriptor_83c10c24ec417dc9, []int{205} } func (m *VolumeNodeAffinity) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5792,7 +5820,7 @@ var xxx_messageInfo_VolumeNodeAffinity proto.InternalMessageInfo func (m *VolumeProjection) Reset() { *m = VolumeProjection{} } func (*VolumeProjection) ProtoMessage() {} func (*VolumeProjection) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{205} + return fileDescriptor_83c10c24ec417dc9, []int{206} } func (m *VolumeProjection) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5820,7 +5848,7 @@ var xxx_messageInfo_VolumeProjection proto.InternalMessageInfo func (m *VolumeSource) Reset() { *m = VolumeSource{} } func (*VolumeSource) ProtoMessage() {} func (*VolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{206} + return fileDescriptor_83c10c24ec417dc9, []int{207} } func (m *VolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5848,7 +5876,7 @@ var xxx_messageInfo_VolumeSource proto.InternalMessageInfo func (m *VsphereVirtualDiskVolumeSource) Reset() { *m = VsphereVirtualDiskVolumeSource{} } func (*VsphereVirtualDiskVolumeSource) ProtoMessage() {} func (*VsphereVirtualDiskVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{207} + return fileDescriptor_83c10c24ec417dc9, []int{208} } func (m *VsphereVirtualDiskVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5876,7 +5904,7 @@ var xxx_messageInfo_VsphereVirtualDiskVolumeSource proto.InternalMessageInfo func (m *WeightedPodAffinityTerm) Reset() { *m = WeightedPodAffinityTerm{} } func (*WeightedPodAffinityTerm) ProtoMessage() {} func (*WeightedPodAffinityTerm) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{208} + return fileDescriptor_83c10c24ec417dc9, []int{209} } func (m *WeightedPodAffinityTerm) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5904,7 +5932,7 @@ var xxx_messageInfo_WeightedPodAffinityTerm proto.InternalMessageInfo func (m *WindowsSecurityContextOptions) Reset() { *m = WindowsSecurityContextOptions{} } func (*WindowsSecurityContextOptions) ProtoMessage() {} func (*WindowsSecurityContextOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_83c10c24ec417dc9, []int{209} + return fileDescriptor_83c10c24ec417dc9, []int{210} } func (m *WindowsSecurityContextOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6082,6 +6110,7 @@ func init() { proto.RegisterType((*PodPortForwardOptions)(nil), "k8s.io.api.core.v1.PodPortForwardOptions") proto.RegisterType((*PodProxyOptions)(nil), "k8s.io.api.core.v1.PodProxyOptions") proto.RegisterType((*PodReadinessGate)(nil), "k8s.io.api.core.v1.PodReadinessGate") + proto.RegisterType((*PodSchedulingGate)(nil), "k8s.io.api.core.v1.PodSchedulingGate") proto.RegisterType((*PodSecurityContext)(nil), "k8s.io.api.core.v1.PodSecurityContext") proto.RegisterType((*PodSignature)(nil), "k8s.io.api.core.v1.PodSignature") proto.RegisterType((*PodSpec)(nil), "k8s.io.api.core.v1.PodSpec") @@ -6175,906 +6204,908 @@ func init() { } var fileDescriptor_83c10c24ec417dc9 = []byte{ - // 14376 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0xbd, 0x6b, 0x70, 0x24, 0xd7, - 0x79, 0x18, 0xaa, 0x9e, 0xc1, 0x6b, 0x3e, 0xbc, 0x0f, 0x76, 0x97, 0x58, 0x90, 0xbb, 0xb3, 0x6c, - 0x52, 0xcb, 0xa5, 0x48, 0x62, 0xb5, 0x7c, 0x48, 0x34, 0x29, 0xd1, 0x02, 0x30, 0xc0, 0x2e, 0xb8, - 0x0b, 0xec, 0xf0, 0x0c, 0x76, 0x57, 0x92, 0x29, 0x95, 0x1a, 0x33, 0x07, 0x40, 0x0b, 0x33, 0xdd, - 0xc3, 0xee, 0x1e, 0xec, 0x82, 0x57, 0xae, 0xeb, 0x2b, 0x3f, 0x65, 0xfb, 0xde, 0x52, 0xdd, 0x72, - 0x1e, 0x25, 0xbb, 0x5c, 0x29, 0xc7, 0x89, 0xad, 0x28, 0x49, 0xc5, 0x91, 0x63, 0x3b, 0x96, 0x13, - 0x3b, 0x6f, 0x27, 0x3f, 0x1c, 0xc7, 0x55, 0xb1, 0x5c, 0xe5, 0x0a, 0x62, 0xaf, 0x53, 0xe5, 0x52, - 0x55, 0x62, 0x3b, 0x71, 0x52, 0x95, 0x20, 0x4e, 0x9c, 0x3a, 0xcf, 0x3e, 0xa7, 0x1f, 0x33, 0x83, - 0x25, 0x16, 0xa2, 0x54, 0xfc, 0x37, 0x73, 0xbe, 0xef, 0x7c, 0xe7, 0xf4, 0x79, 0x7e, 0xe7, 0x7b, - 0xc2, 0xab, 0xbb, 0x2f, 0x87, 0xf3, 0xae, 0x7f, 0x79, 0xb7, 0xb3, 0x49, 0x02, 0x8f, 0x44, 0x24, - 0xbc, 0xbc, 0x47, 0xbc, 0x86, 0x1f, 0x5c, 0x16, 0x00, 0xa7, 0xed, 0x5e, 0xae, 0xfb, 0x01, 0xb9, - 0xbc, 0x77, 0xe5, 0xf2, 0x36, 0xf1, 0x48, 0xe0, 0x44, 0xa4, 0x31, 0xdf, 0x0e, 0xfc, 0xc8, 0x47, - 0x88, 0xe3, 0xcc, 0x3b, 0x6d, 0x77, 0x9e, 0xe2, 0xcc, 0xef, 0x5d, 0x99, 0x7b, 0x6e, 0xdb, 0x8d, - 0x76, 0x3a, 0x9b, 0xf3, 0x75, 0xbf, 0x75, 0x79, 0xdb, 0xdf, 0xf6, 0x2f, 0x33, 0xd4, 0xcd, 0xce, - 0x16, 0xfb, 0xc7, 0xfe, 0xb0, 0x5f, 0x9c, 0xc4, 0xdc, 0x8b, 0x71, 0x33, 0x2d, 0xa7, 0xbe, 0xe3, - 0x7a, 0x24, 0xd8, 0xbf, 0xdc, 0xde, 0xdd, 0x66, 0xed, 0x06, 0x24, 0xf4, 0x3b, 0x41, 0x9d, 0x24, - 0x1b, 0xee, 0x5a, 0x2b, 0xbc, 0xdc, 0x22, 0x91, 0x93, 0xd1, 0xdd, 0xb9, 0xcb, 0x79, 0xb5, 0x82, - 0x8e, 0x17, 0xb9, 0xad, 0x74, 0x33, 0x1f, 0xea, 0x55, 0x21, 0xac, 0xef, 0x90, 0x96, 0x93, 0xaa, - 0xf7, 0x42, 0x5e, 0xbd, 0x4e, 0xe4, 0x36, 0x2f, 0xbb, 0x5e, 0x14, 0x46, 0x41, 0xb2, 0x92, 0xfd, - 0x75, 0x0b, 0x2e, 0x2c, 0xdc, 0xa9, 0x2d, 0x37, 0x9d, 0x30, 0x72, 0xeb, 0x8b, 0x4d, 0xbf, 0xbe, - 0x5b, 0x8b, 0xfc, 0x80, 0xdc, 0xf6, 0x9b, 0x9d, 0x16, 0xa9, 0xb1, 0x81, 0x40, 0xcf, 0xc2, 0xc8, - 0x1e, 0xfb, 0xbf, 0x5a, 0x99, 0xb5, 0x2e, 0x58, 0x97, 0x4a, 0x8b, 0x53, 0xbf, 0x7e, 0x50, 0x7e, - 0xdf, 0xfd, 0x83, 0xf2, 0xc8, 0x6d, 0x51, 0x8e, 0x15, 0x06, 0xba, 0x08, 0x43, 0x5b, 0xe1, 0xc6, - 0x7e, 0x9b, 0xcc, 0x16, 0x18, 0xee, 0x84, 0xc0, 0x1d, 0x5a, 0xa9, 0xd1, 0x52, 0x2c, 0xa0, 0xe8, - 0x32, 0x94, 0xda, 0x4e, 0x10, 0xb9, 0x91, 0xeb, 0x7b, 0xb3, 0xc5, 0x0b, 0xd6, 0xa5, 0xc1, 0xc5, - 0x69, 0x81, 0x5a, 0xaa, 0x4a, 0x00, 0x8e, 0x71, 0x68, 0x37, 0x02, 0xe2, 0x34, 0x6e, 0x7a, 0xcd, - 0xfd, 0xd9, 0x81, 0x0b, 0xd6, 0xa5, 0x91, 0xb8, 0x1b, 0x58, 0x94, 0x63, 0x85, 0x61, 0x7f, 0xa9, - 0x00, 0x23, 0x0b, 0x5b, 0x5b, 0xae, 0xe7, 0x46, 0xfb, 0xe8, 0x36, 0x8c, 0x79, 0x7e, 0x83, 0xc8, - 0xff, 0xec, 0x2b, 0x46, 0x9f, 0xbf, 0x30, 0x9f, 0x5e, 0x4a, 0xf3, 0xeb, 0x1a, 0xde, 0xe2, 0xd4, - 0xfd, 0x83, 0xf2, 0x98, 0x5e, 0x82, 0x0d, 0x3a, 0x08, 0xc3, 0x68, 0xdb, 0x6f, 0x28, 0xb2, 0x05, - 0x46, 0xb6, 0x9c, 0x45, 0xb6, 0x1a, 0xa3, 0x2d, 0x4e, 0xde, 0x3f, 0x28, 0x8f, 0x6a, 0x05, 0x58, - 0x27, 0x82, 0x36, 0x61, 0x92, 0xfe, 0xf5, 0x22, 0x57, 0xd1, 0x2d, 0x32, 0xba, 0x4f, 0xe4, 0xd1, - 0xd5, 0x50, 0x17, 0x67, 0xee, 0x1f, 0x94, 0x27, 0x13, 0x85, 0x38, 0x49, 0xd0, 0x7e, 0x1b, 0x26, - 0x16, 0xa2, 0xc8, 0xa9, 0xef, 0x90, 0x06, 0x9f, 0x41, 0xf4, 0x22, 0x0c, 0x78, 0x4e, 0x8b, 0x88, - 0xf9, 0xbd, 0x20, 0x06, 0x76, 0x60, 0xdd, 0x69, 0x91, 0xc3, 0x83, 0xf2, 0xd4, 0x2d, 0xcf, 0x7d, - 0xab, 0x23, 0x56, 0x05, 0x2d, 0xc3, 0x0c, 0x1b, 0x3d, 0x0f, 0xd0, 0x20, 0x7b, 0x6e, 0x9d, 0x54, - 0x9d, 0x68, 0x47, 0xcc, 0x37, 0x12, 0x75, 0xa1, 0xa2, 0x20, 0x58, 0xc3, 0xb2, 0xef, 0x41, 0x69, - 0x61, 0xcf, 0x77, 0x1b, 0x55, 0xbf, 0x11, 0xa2, 0x5d, 0x98, 0x6c, 0x07, 0x64, 0x8b, 0x04, 0xaa, - 0x68, 0xd6, 0xba, 0x50, 0xbc, 0x34, 0xfa, 0xfc, 0xa5, 0xcc, 0x8f, 0x35, 0x51, 0x97, 0xbd, 0x28, - 0xd8, 0x5f, 0x7c, 0x44, 0xb4, 0x37, 0x99, 0x80, 0xe2, 0x24, 0x65, 0xfb, 0x9f, 0x16, 0xe0, 0xf4, - 0xc2, 0xdb, 0x9d, 0x80, 0x54, 0xdc, 0x70, 0x37, 0xb9, 0xc2, 0x1b, 0x6e, 0xb8, 0xbb, 0x1e, 0x8f, - 0x80, 0x5a, 0x5a, 0x15, 0x51, 0x8e, 0x15, 0x06, 0x7a, 0x0e, 0x86, 0xe9, 0xef, 0x5b, 0x78, 0x55, - 0x7c, 0xf2, 0x8c, 0x40, 0x1e, 0xad, 0x38, 0x91, 0x53, 0xe1, 0x20, 0x2c, 0x71, 0xd0, 0x1a, 0x8c, - 0xd6, 0xd9, 0x86, 0xdc, 0x5e, 0xf3, 0x1b, 0x84, 0x4d, 0x66, 0x69, 0xf1, 0x19, 0x8a, 0xbe, 0x14, - 0x17, 0x1f, 0x1e, 0x94, 0x67, 0x79, 0xdf, 0x04, 0x09, 0x0d, 0x86, 0xf5, 0xfa, 0xc8, 0x56, 0xfb, - 0x6b, 0x80, 0x51, 0x82, 0x8c, 0xbd, 0x75, 0x49, 0xdb, 0x2a, 0x83, 0x6c, 0xab, 0x8c, 0x65, 0x6f, - 0x13, 0x74, 0x05, 0x06, 0x76, 0x5d, 0xaf, 0x31, 0x3b, 0xc4, 0x68, 0x9d, 0xa3, 0x73, 0x7e, 0xdd, - 0xf5, 0x1a, 0x87, 0x07, 0xe5, 0x69, 0xa3, 0x3b, 0xb4, 0x10, 0x33, 0x54, 0xfb, 0x4f, 0x2d, 0x28, - 0x33, 0xd8, 0x8a, 0xdb, 0x24, 0x55, 0x12, 0x84, 0x6e, 0x18, 0x11, 0x2f, 0x32, 0x06, 0xf4, 0x79, - 0x80, 0x90, 0xd4, 0x03, 0x12, 0x69, 0x43, 0xaa, 0x16, 0x46, 0x4d, 0x41, 0xb0, 0x86, 0x45, 0x0f, - 0x84, 0x70, 0xc7, 0x09, 0xd8, 0xfa, 0x12, 0x03, 0xab, 0x0e, 0x84, 0x9a, 0x04, 0xe0, 0x18, 0xc7, - 0x38, 0x10, 0x8a, 0xbd, 0x0e, 0x04, 0xf4, 0x51, 0x98, 0x8c, 0x1b, 0x0b, 0xdb, 0x4e, 0x5d, 0x0e, - 0x20, 0xdb, 0x32, 0x35, 0x13, 0x84, 0x93, 0xb8, 0xf6, 0xdf, 0xb0, 0xc4, 0xe2, 0xa1, 0x5f, 0xfd, - 0x2e, 0xff, 0x56, 0xfb, 0x97, 0x2c, 0x18, 0x5e, 0x74, 0xbd, 0x86, 0xeb, 0x6d, 0xa3, 0xcf, 0xc0, - 0x08, 0xbd, 0x9b, 0x1a, 0x4e, 0xe4, 0x88, 0x73, 0xef, 0x83, 0xda, 0xde, 0x52, 0x57, 0xc5, 0x7c, - 0x7b, 0x77, 0x9b, 0x16, 0x84, 0xf3, 0x14, 0x9b, 0xee, 0xb6, 0x9b, 0x9b, 0x9f, 0x25, 0xf5, 0x68, - 0x8d, 0x44, 0x4e, 0xfc, 0x39, 0x71, 0x19, 0x56, 0x54, 0xd1, 0x75, 0x18, 0x8a, 0x9c, 0x60, 0x9b, - 0x44, 0xe2, 0x00, 0xcc, 0x3c, 0xa8, 0x78, 0x4d, 0x4c, 0x77, 0x24, 0xf1, 0xea, 0x24, 0xbe, 0x16, - 0x36, 0x58, 0x55, 0x2c, 0x48, 0xd8, 0xff, 0x6b, 0x18, 0xce, 0x2e, 0xd5, 0x56, 0x73, 0xd6, 0xd5, - 0x45, 0x18, 0x6a, 0x04, 0xee, 0x1e, 0x09, 0xc4, 0x38, 0x2b, 0x2a, 0x15, 0x56, 0x8a, 0x05, 0x14, - 0xbd, 0x0c, 0x63, 0xfc, 0x42, 0xba, 0xe6, 0x78, 0x8d, 0xa6, 0x1c, 0xe2, 0x53, 0x02, 0x7b, 0xec, - 0xb6, 0x06, 0xc3, 0x06, 0xe6, 0x11, 0x17, 0xd5, 0xc5, 0xc4, 0x66, 0xcc, 0xbb, 0xec, 0xbe, 0x60, - 0xc1, 0x14, 0x6f, 0x66, 0x21, 0x8a, 0x02, 0x77, 0xb3, 0x13, 0x91, 0x70, 0x76, 0x90, 0x9d, 0x74, - 0x4b, 0x59, 0xa3, 0x95, 0x3b, 0x02, 0xf3, 0xb7, 0x13, 0x54, 0xf8, 0x21, 0x38, 0x2b, 0xda, 0x9d, - 0x4a, 0x82, 0x71, 0xaa, 0x59, 0xf4, 0xbd, 0x16, 0xcc, 0xd5, 0x7d, 0x2f, 0x0a, 0xfc, 0x66, 0x93, - 0x04, 0xd5, 0xce, 0x66, 0xd3, 0x0d, 0x77, 0xf8, 0x3a, 0xc5, 0x64, 0x8b, 0x9d, 0x04, 0x39, 0x73, - 0xa8, 0x90, 0xc4, 0x1c, 0x9e, 0xbf, 0x7f, 0x50, 0x9e, 0x5b, 0xca, 0x25, 0x85, 0xbb, 0x34, 0x83, - 0x76, 0x01, 0xd1, 0xab, 0xb4, 0x16, 0x39, 0xdb, 0x24, 0x6e, 0x7c, 0xb8, 0xff, 0xc6, 0xcf, 0xdc, - 0x3f, 0x28, 0xa3, 0xf5, 0x14, 0x09, 0x9c, 0x41, 0x16, 0xbd, 0x05, 0xa7, 0x68, 0x69, 0xea, 0x5b, - 0x47, 0xfa, 0x6f, 0x6e, 0xf6, 0xfe, 0x41, 0xf9, 0xd4, 0x7a, 0x06, 0x11, 0x9c, 0x49, 0x1a, 0x7d, - 0x8f, 0x05, 0x67, 0xe3, 0xcf, 0x5f, 0xbe, 0xd7, 0x76, 0xbc, 0x46, 0xdc, 0x70, 0xa9, 0xff, 0x86, - 0xe9, 0x99, 0x7c, 0x76, 0x29, 0x8f, 0x12, 0xce, 0x6f, 0x04, 0x79, 0x30, 0x43, 0xbb, 0x96, 0x6c, - 0x1b, 0xfa, 0x6f, 0xfb, 0x91, 0xfb, 0x07, 0xe5, 0x99, 0xf5, 0x34, 0x0d, 0x9c, 0x45, 0x78, 0x6e, - 0x09, 0x4e, 0x67, 0xae, 0x4e, 0x34, 0x05, 0xc5, 0x5d, 0xc2, 0xb9, 0xae, 0x12, 0xa6, 0x3f, 0xd1, - 0x29, 0x18, 0xdc, 0x73, 0x9a, 0x1d, 0xb1, 0x31, 0x31, 0xff, 0xf3, 0x4a, 0xe1, 0x65, 0xcb, 0xfe, - 0x67, 0x45, 0x98, 0x5c, 0xaa, 0xad, 0x3e, 0xd0, 0xae, 0xd7, 0xaf, 0xbd, 0x42, 0xd7, 0x6b, 0x2f, - 0xbe, 0x44, 0x8b, 0xb9, 0x97, 0xe8, 0xff, 0x9d, 0xb1, 0x65, 0x07, 0xd8, 0x96, 0xfd, 0x8e, 0x9c, - 0x2d, 0x7b, 0xcc, 0x1b, 0x75, 0x2f, 0x67, 0xd5, 0x0e, 0xb2, 0x09, 0xcc, 0xe4, 0x90, 0x6e, 0xf8, - 0x75, 0xa7, 0x99, 0x3c, 0x6a, 0x8f, 0xb8, 0x74, 0x8f, 0x67, 0x1e, 0xeb, 0x30, 0xb6, 0xe4, 0xb4, - 0x9d, 0x4d, 0xb7, 0xe9, 0x46, 0x2e, 0x09, 0xd1, 0x53, 0x50, 0x74, 0x1a, 0x0d, 0xc6, 0xdd, 0x95, - 0x16, 0x4f, 0xdf, 0x3f, 0x28, 0x17, 0x17, 0x1a, 0x94, 0xcd, 0x00, 0x85, 0xb5, 0x8f, 0x29, 0x06, - 0xfa, 0x00, 0x0c, 0x34, 0x02, 0xbf, 0x3d, 0x5b, 0x60, 0x98, 0x74, 0x97, 0x0f, 0x54, 0x02, 0xbf, - 0x9d, 0x40, 0x65, 0x38, 0xf6, 0xaf, 0x15, 0xe0, 0xb1, 0x25, 0xd2, 0xde, 0x59, 0xa9, 0xe5, 0xdc, - 0x17, 0x97, 0x60, 0xa4, 0xe5, 0x7b, 0x6e, 0xe4, 0x07, 0xa1, 0x68, 0x9a, 0xad, 0x88, 0x35, 0x51, - 0x86, 0x15, 0x14, 0x5d, 0x80, 0x81, 0x76, 0xcc, 0xc4, 0x8e, 0x49, 0x06, 0x98, 0xb1, 0xaf, 0x0c, - 0x42, 0x31, 0x3a, 0x21, 0x09, 0xc4, 0x8a, 0x51, 0x18, 0xb7, 0x42, 0x12, 0x60, 0x06, 0x89, 0x39, - 0x01, 0xca, 0x23, 0x88, 0x1b, 0x21, 0xc1, 0x09, 0x50, 0x08, 0xd6, 0xb0, 0x50, 0x15, 0x4a, 0x61, - 0x62, 0x66, 0xfb, 0xda, 0x9a, 0xe3, 0x8c, 0x55, 0x50, 0x33, 0x19, 0x13, 0x31, 0x6e, 0xb0, 0xa1, - 0x9e, 0xac, 0xc2, 0xd7, 0x0a, 0x80, 0xf8, 0x10, 0x7e, 0x8b, 0x0d, 0xdc, 0xad, 0xf4, 0xc0, 0xf5, - 0xbf, 0x25, 0x8e, 0x6b, 0xf4, 0xfe, 0xab, 0x05, 0x8f, 0x2d, 0xb9, 0x5e, 0x83, 0x04, 0x39, 0x0b, - 0xf0, 0xe1, 0xbc, 0x9d, 0x8f, 0xc6, 0xa4, 0x18, 0x4b, 0x6c, 0xe0, 0x18, 0x96, 0x98, 0xfd, 0xc7, - 0x16, 0x20, 0xfe, 0xd9, 0xef, 0xba, 0x8f, 0xbd, 0x95, 0xfe, 0xd8, 0x63, 0x58, 0x16, 0xf6, 0x0d, - 0x98, 0x58, 0x6a, 0xba, 0xc4, 0x8b, 0x56, 0xab, 0x4b, 0xbe, 0xb7, 0xe5, 0x6e, 0xa3, 0x57, 0x60, - 0x22, 0x72, 0x5b, 0xc4, 0xef, 0x44, 0x35, 0x52, 0xf7, 0x3d, 0xf6, 0x72, 0xb5, 0x2e, 0x0d, 0x2e, - 0xa2, 0xfb, 0x07, 0xe5, 0x89, 0x0d, 0x03, 0x82, 0x13, 0x98, 0xf6, 0xef, 0xd2, 0xf1, 0xf3, 0x5b, - 0x6d, 0xdf, 0x23, 0x5e, 0xb4, 0xe4, 0x7b, 0x0d, 0x2e, 0xe1, 0x78, 0x05, 0x06, 0x22, 0x3a, 0x1e, - 0x7c, 0xec, 0x2e, 0xca, 0x8d, 0x42, 0x47, 0xe1, 0xf0, 0xa0, 0x7c, 0x26, 0x5d, 0x83, 0x8d, 0x13, - 0xab, 0x83, 0xbe, 0x03, 0x86, 0xc2, 0xc8, 0x89, 0x3a, 0xa1, 0x18, 0xcd, 0xc7, 0xe5, 0x68, 0xd6, - 0x58, 0xe9, 0xe1, 0x41, 0x79, 0x52, 0x55, 0xe3, 0x45, 0x58, 0x54, 0x40, 0x4f, 0xc3, 0x70, 0x8b, - 0x84, 0xa1, 0xb3, 0x2d, 0x6f, 0xc3, 0x49, 0x51, 0x77, 0x78, 0x8d, 0x17, 0x63, 0x09, 0x47, 0x4f, - 0xc0, 0x20, 0x09, 0x02, 0x3f, 0x10, 0x7b, 0x74, 0x5c, 0x20, 0x0e, 0x2e, 0xd3, 0x42, 0xcc, 0x61, - 0xf6, 0xbf, 0xb6, 0x60, 0x52, 0xf5, 0x95, 0xb7, 0x75, 0x02, 0xaf, 0x90, 0x4f, 0x02, 0xd4, 0xe5, - 0x07, 0x86, 0xec, 0xf6, 0x18, 0x7d, 0xfe, 0x62, 0xe6, 0x45, 0x9d, 0x1a, 0xc6, 0x98, 0xb2, 0x2a, - 0x0a, 0xb1, 0x46, 0xcd, 0xfe, 0x07, 0x16, 0xcc, 0x24, 0xbe, 0xe8, 0x86, 0x1b, 0x46, 0xe8, 0xcd, - 0xd4, 0x57, 0xcd, 0xf7, 0xf7, 0x55, 0xb4, 0x36, 0xfb, 0x26, 0xb5, 0x94, 0x65, 0x89, 0xf6, 0x45, - 0xd7, 0x60, 0xd0, 0x8d, 0x48, 0x4b, 0x7e, 0xcc, 0x13, 0x5d, 0x3f, 0x86, 0xf7, 0x2a, 0x9e, 0x91, - 0x55, 0x5a, 0x13, 0x73, 0x02, 0xf6, 0xaf, 0x15, 0xa1, 0xc4, 0x97, 0xed, 0x9a, 0xd3, 0x3e, 0x81, - 0xb9, 0x78, 0x06, 0x4a, 0x6e, 0xab, 0xd5, 0x89, 0x9c, 0x4d, 0x71, 0x9c, 0x8f, 0xf0, 0xad, 0xb5, - 0x2a, 0x0b, 0x71, 0x0c, 0x47, 0xab, 0x30, 0xc0, 0xba, 0xc2, 0xbf, 0xf2, 0xa9, 0xec, 0xaf, 0x14, - 0x7d, 0x9f, 0xaf, 0x38, 0x91, 0xc3, 0x39, 0x29, 0x75, 0x8f, 0xd0, 0x22, 0xcc, 0x48, 0x20, 0x07, - 0x60, 0xd3, 0xf5, 0x9c, 0x60, 0x9f, 0x96, 0xcd, 0x16, 0x19, 0xc1, 0xe7, 0xba, 0x13, 0x5c, 0x54, - 0xf8, 0x9c, 0xac, 0xfa, 0xb0, 0x18, 0x80, 0x35, 0xa2, 0x73, 0x1f, 0x86, 0x92, 0x42, 0x3e, 0x0a, - 0x43, 0x34, 0xf7, 0x51, 0x98, 0x4c, 0xb4, 0xd5, 0xab, 0xfa, 0x98, 0xce, 0x4f, 0xfd, 0x32, 0x3b, - 0x32, 0x44, 0xaf, 0x97, 0xbd, 0x3d, 0x71, 0xe4, 0xbe, 0x0d, 0xa7, 0x9a, 0x19, 0x27, 0x99, 0x98, - 0xd7, 0xfe, 0x4f, 0xbe, 0xc7, 0xc4, 0x67, 0x9f, 0xca, 0x82, 0xe2, 0xcc, 0x36, 0x28, 0x8f, 0xe0, - 0xb7, 0xe9, 0x06, 0x71, 0x9a, 0x3a, 0xbb, 0x7d, 0x53, 0x94, 0x61, 0x05, 0xa5, 0xe7, 0xdd, 0x29, - 0xd5, 0xf9, 0xeb, 0x64, 0xbf, 0x46, 0x9a, 0xa4, 0x1e, 0xf9, 0xc1, 0x37, 0xb5, 0xfb, 0xe7, 0xf8, - 0xe8, 0xf3, 0xe3, 0x72, 0x54, 0x10, 0x28, 0x5e, 0x27, 0xfb, 0x7c, 0x2a, 0xf4, 0xaf, 0x2b, 0x76, - 0xfd, 0xba, 0x9f, 0xb3, 0x60, 0x5c, 0x7d, 0xdd, 0x09, 0x9c, 0x0b, 0x8b, 0xe6, 0xb9, 0x70, 0xae, - 0xeb, 0x02, 0xcf, 0x39, 0x11, 0xbe, 0x56, 0x80, 0xb3, 0x0a, 0x87, 0xbe, 0x0d, 0xf8, 0x1f, 0xb1, - 0xaa, 0x2e, 0x43, 0xc9, 0x53, 0x52, 0x32, 0xcb, 0x14, 0x4f, 0xc5, 0x32, 0xb2, 0x18, 0x87, 0xb2, - 0x78, 0x5e, 0x2c, 0xca, 0x1a, 0xd3, 0xc5, 0xc7, 0x42, 0x54, 0xbc, 0x08, 0xc5, 0x8e, 0xdb, 0x10, - 0x17, 0xcc, 0x07, 0xe5, 0x68, 0xdf, 0x5a, 0xad, 0x1c, 0x1e, 0x94, 0x1f, 0xcf, 0x53, 0x5d, 0xd0, - 0x9b, 0x2d, 0x9c, 0xbf, 0xb5, 0x5a, 0xc1, 0xb4, 0x32, 0x5a, 0x80, 0x49, 0xa9, 0x9d, 0xb9, 0x4d, - 0xd9, 0x2d, 0xdf, 0x13, 0xf7, 0x90, 0x92, 0x01, 0x63, 0x13, 0x8c, 0x93, 0xf8, 0xa8, 0x02, 0x53, - 0xbb, 0x9d, 0x4d, 0xd2, 0x24, 0x11, 0xff, 0xe0, 0xeb, 0x84, 0x4b, 0x48, 0x4b, 0xf1, 0xcb, 0xec, - 0x7a, 0x02, 0x8e, 0x53, 0x35, 0xec, 0x3f, 0x67, 0xf7, 0x81, 0x18, 0xbd, 0x6a, 0xe0, 0xd3, 0x85, - 0x45, 0xa9, 0x7f, 0x33, 0x97, 0x73, 0x3f, 0xab, 0xe2, 0x3a, 0xd9, 0xdf, 0xf0, 0x29, 0x67, 0x9e, - 0xbd, 0x2a, 0x8c, 0x35, 0x3f, 0xd0, 0x75, 0xcd, 0xff, 0x7c, 0x01, 0x4e, 0xab, 0x11, 0x30, 0x98, - 0xc0, 0x6f, 0xf5, 0x31, 0xb8, 0x02, 0xa3, 0x0d, 0xb2, 0xe5, 0x74, 0x9a, 0x91, 0x12, 0xd7, 0x0f, - 0x72, 0x95, 0x4d, 0x25, 0x2e, 0xc6, 0x3a, 0xce, 0x11, 0x86, 0xed, 0xbf, 0x8d, 0xb2, 0x8b, 0x38, - 0x72, 0xe8, 0x1a, 0x57, 0xbb, 0xc6, 0xca, 0xdd, 0x35, 0x4f, 0xc0, 0xa0, 0xdb, 0xa2, 0x8c, 0x59, - 0xc1, 0xe4, 0xb7, 0x56, 0x69, 0x21, 0xe6, 0x30, 0xf4, 0x7e, 0x18, 0xae, 0xfb, 0xad, 0x96, 0xe3, - 0x35, 0xd8, 0x95, 0x57, 0x5a, 0x1c, 0xa5, 0xbc, 0xdb, 0x12, 0x2f, 0xc2, 0x12, 0x86, 0x1e, 0x83, - 0x01, 0x27, 0xd8, 0xe6, 0x32, 0x8c, 0xd2, 0xe2, 0x08, 0x6d, 0x69, 0x21, 0xd8, 0x0e, 0x31, 0x2b, - 0xa5, 0x4f, 0xb0, 0xbb, 0x7e, 0xb0, 0xeb, 0x7a, 0xdb, 0x15, 0x37, 0x10, 0x5b, 0x42, 0xdd, 0x85, - 0x77, 0x14, 0x04, 0x6b, 0x58, 0x68, 0x05, 0x06, 0xdb, 0x7e, 0x10, 0x85, 0xb3, 0x43, 0x6c, 0xb8, - 0x1f, 0xcf, 0x39, 0x88, 0xf8, 0xd7, 0x56, 0xfd, 0x20, 0x8a, 0x3f, 0x80, 0xfe, 0x0b, 0x31, 0xaf, - 0x8e, 0x6e, 0xc0, 0x30, 0xf1, 0xf6, 0x56, 0x02, 0xbf, 0x35, 0x3b, 0x93, 0x4f, 0x69, 0x99, 0xa3, - 0xf0, 0x65, 0x16, 0xf3, 0xa8, 0xa2, 0x18, 0x4b, 0x12, 0xe8, 0x3b, 0xa0, 0x48, 0xbc, 0xbd, 0xd9, - 0x61, 0x46, 0x69, 0x2e, 0x87, 0xd2, 0x6d, 0x27, 0x88, 0xcf, 0xfc, 0x65, 0x6f, 0x0f, 0xd3, 0x3a, - 0xe8, 0x13, 0x50, 0x92, 0x07, 0x46, 0x28, 0x84, 0x83, 0x99, 0x0b, 0x56, 0x1e, 0x33, 0x98, 0xbc, - 0xd5, 0x71, 0x03, 0xd2, 0x22, 0x5e, 0x14, 0xc6, 0x27, 0xa4, 0x84, 0x86, 0x38, 0xa6, 0x86, 0x3e, - 0x21, 0x25, 0xd2, 0x6b, 0x7e, 0xc7, 0x8b, 0xc2, 0xd9, 0x12, 0xeb, 0x5e, 0xa6, 0xae, 0xf0, 0x76, - 0x8c, 0x97, 0x14, 0x59, 0xf3, 0xca, 0xd8, 0x20, 0x85, 0x3e, 0x05, 0xe3, 0xfc, 0x3f, 0xd7, 0xb8, - 0x85, 0xb3, 0xa7, 0x19, 0xed, 0x0b, 0xf9, 0xb4, 0x39, 0xe2, 0xe2, 0x69, 0x41, 0x7c, 0x5c, 0x2f, - 0x0d, 0xb1, 0x49, 0x0d, 0x61, 0x18, 0x6f, 0xba, 0x7b, 0xc4, 0x23, 0x61, 0x58, 0x0d, 0xfc, 0x4d, - 0x22, 0x04, 0x88, 0x67, 0xb3, 0x35, 0x74, 0xfe, 0x26, 0x59, 0x9c, 0xa6, 0x34, 0x6f, 0xe8, 0x75, - 0xb0, 0x49, 0x02, 0xdd, 0x82, 0x09, 0xfa, 0x62, 0x73, 0x63, 0xa2, 0xa3, 0xbd, 0x88, 0xb2, 0x77, - 0x15, 0x36, 0x2a, 0xe1, 0x04, 0x11, 0x74, 0x13, 0xc6, 0xc2, 0xc8, 0x09, 0xa2, 0x4e, 0x9b, 0x13, - 0x3d, 0xd3, 0x8b, 0x28, 0x53, 0xf0, 0xd6, 0xb4, 0x2a, 0xd8, 0x20, 0x80, 0x5e, 0x87, 0x52, 0xd3, - 0xdd, 0x22, 0xf5, 0xfd, 0x7a, 0x93, 0xcc, 0x8e, 0x31, 0x6a, 0x99, 0x87, 0xca, 0x0d, 0x89, 0xc4, - 0xf9, 0x5c, 0xf5, 0x17, 0xc7, 0xd5, 0xd1, 0x6d, 0x38, 0x13, 0x91, 0xa0, 0xe5, 0x7a, 0x0e, 0x3d, - 0x0c, 0xc4, 0xd3, 0x8a, 0x29, 0x4e, 0xc7, 0xd9, 0x6e, 0x3b, 0x2f, 0x66, 0xe3, 0xcc, 0x46, 0x26, - 0x16, 0xce, 0xa9, 0x8d, 0xee, 0xc1, 0x6c, 0x06, 0xc4, 0x6f, 0xba, 0xf5, 0xfd, 0xd9, 0x53, 0x8c, - 0xf2, 0x47, 0x04, 0xe5, 0xd9, 0x8d, 0x1c, 0xbc, 0xc3, 0x2e, 0x30, 0x9c, 0x4b, 0x1d, 0xdd, 0x84, - 0x49, 0x76, 0x02, 0x55, 0x3b, 0xcd, 0xa6, 0x68, 0x70, 0x82, 0x35, 0xf8, 0x7e, 0x79, 0x1f, 0xaf, - 0x9a, 0xe0, 0xc3, 0x83, 0x32, 0xc4, 0xff, 0x70, 0xb2, 0x36, 0xda, 0x64, 0x3a, 0xba, 0x4e, 0xe0, - 0x46, 0xfb, 0xf4, 0xdc, 0x20, 0xf7, 0xa2, 0xd9, 0xc9, 0xae, 0xf2, 0x0a, 0x1d, 0x55, 0x29, 0xf2, - 0xf4, 0x42, 0x9c, 0x24, 0x48, 0x8f, 0xd4, 0x30, 0x6a, 0xb8, 0xde, 0xec, 0x14, 0x7f, 0x97, 0xc8, - 0x13, 0xa9, 0x46, 0x0b, 0x31, 0x87, 0x31, 0xfd, 0x1c, 0xfd, 0x71, 0x93, 0xde, 0x5c, 0xd3, 0x0c, - 0x31, 0xd6, 0xcf, 0x49, 0x00, 0x8e, 0x71, 0x28, 0x33, 0x19, 0x45, 0xfb, 0xb3, 0x88, 0xa1, 0xaa, - 0x83, 0x65, 0x63, 0xe3, 0x13, 0x98, 0x96, 0xdb, 0x9b, 0x30, 0xa1, 0x0e, 0x42, 0x36, 0x26, 0xa8, - 0x0c, 0x83, 0x8c, 0x7d, 0x12, 0xd2, 0xb5, 0x12, 0xed, 0x02, 0x63, 0xad, 0x30, 0x2f, 0x67, 0x5d, - 0x70, 0xdf, 0x26, 0x8b, 0xfb, 0x11, 0xe1, 0x6f, 0xfa, 0xa2, 0xd6, 0x05, 0x09, 0xc0, 0x31, 0x8e, - 0xfd, 0xbf, 0x39, 0x1b, 0x1a, 0x9f, 0xb6, 0x7d, 0xdc, 0x2f, 0xcf, 0xc2, 0xc8, 0x8e, 0x1f, 0x46, - 0x14, 0x9b, 0xb5, 0x31, 0x18, 0x33, 0x9e, 0xd7, 0x44, 0x39, 0x56, 0x18, 0xe8, 0x55, 0x18, 0xaf, - 0xeb, 0x0d, 0x88, 0xcb, 0x51, 0x1d, 0x23, 0x46, 0xeb, 0xd8, 0xc4, 0x45, 0x2f, 0xc3, 0x08, 0xb3, - 0x39, 0xa9, 0xfb, 0x4d, 0xc1, 0xb5, 0xc9, 0x1b, 0x7e, 0xa4, 0x2a, 0xca, 0x0f, 0xb5, 0xdf, 0x58, - 0x61, 0xa3, 0x8b, 0x30, 0x44, 0xbb, 0xb0, 0x5a, 0x15, 0xd7, 0x92, 0x12, 0x14, 0x5d, 0x63, 0xa5, - 0x58, 0x40, 0xed, 0xff, 0xbf, 0xa0, 0x8d, 0x32, 0x7d, 0x0f, 0x13, 0x54, 0x85, 0xe1, 0xbb, 0x8e, - 0x1b, 0xb9, 0xde, 0xb6, 0xe0, 0x3f, 0x9e, 0xee, 0x7a, 0x47, 0xb1, 0x4a, 0x77, 0x78, 0x05, 0x7e, - 0x8b, 0x8a, 0x3f, 0x58, 0x92, 0xa1, 0x14, 0x83, 0x8e, 0xe7, 0x51, 0x8a, 0x85, 0x7e, 0x29, 0x62, - 0x5e, 0x81, 0x53, 0x14, 0x7f, 0xb0, 0x24, 0x83, 0xde, 0x04, 0x90, 0x3b, 0x8c, 0x34, 0x84, 0xad, - 0xc7, 0xb3, 0xbd, 0x89, 0x6e, 0xa8, 0x3a, 0x8b, 0x13, 0xf4, 0x8e, 0x8e, 0xff, 0x63, 0x8d, 0x9e, - 0x1d, 0x31, 0x3e, 0x2d, 0xdd, 0x19, 0xf4, 0x5d, 0x74, 0x89, 0x3b, 0x41, 0x44, 0x1a, 0x0b, 0x91, - 0x18, 0x9c, 0x0f, 0xf4, 0xf7, 0x48, 0xd9, 0x70, 0x5b, 0x44, 0xdf, 0x0e, 0x82, 0x08, 0x8e, 0xe9, - 0xd9, 0xbf, 0x58, 0x84, 0xd9, 0xbc, 0xee, 0xd2, 0x45, 0x47, 0xee, 0xb9, 0xd1, 0x12, 0x65, 0xaf, - 0x2c, 0x73, 0xd1, 0x2d, 0x8b, 0x72, 0xac, 0x30, 0xe8, 0xec, 0x87, 0xee, 0xb6, 0x7c, 0x63, 0x0e, - 0xc6, 0xb3, 0x5f, 0x63, 0xa5, 0x58, 0x40, 0x29, 0x5e, 0x40, 0x9c, 0x50, 0x18, 0x13, 0x69, 0xab, - 0x04, 0xb3, 0x52, 0x2c, 0xa0, 0xba, 0xb4, 0x6b, 0xa0, 0x87, 0xb4, 0xcb, 0x18, 0xa2, 0xc1, 0xe3, - 0x1d, 0x22, 0xf4, 0x69, 0x80, 0x2d, 0xd7, 0x73, 0xc3, 0x1d, 0x46, 0x7d, 0xe8, 0xc8, 0xd4, 0x15, - 0x73, 0xb6, 0xa2, 0xa8, 0x60, 0x8d, 0x22, 0x7a, 0x09, 0x46, 0xd5, 0x06, 0x5c, 0xad, 0x30, 0xcd, - 0xaa, 0x66, 0xa9, 0x12, 0x9f, 0x46, 0x15, 0xac, 0xe3, 0xd9, 0x9f, 0x4d, 0xae, 0x17, 0xb1, 0x03, - 0xb4, 0xf1, 0xb5, 0xfa, 0x1d, 0xdf, 0x42, 0xf7, 0xf1, 0xb5, 0xbf, 0x51, 0x84, 0x49, 0xa3, 0xb1, - 0x4e, 0xd8, 0xc7, 0x99, 0x75, 0x95, 0x1e, 0xe0, 0x4e, 0x44, 0xc4, 0xfe, 0xb3, 0x7b, 0x6f, 0x15, - 0xfd, 0x90, 0xa7, 0x3b, 0x80, 0xd7, 0x47, 0x9f, 0x86, 0x52, 0xd3, 0x09, 0x99, 0xe4, 0x8c, 0x88, - 0x7d, 0xd7, 0x0f, 0xb1, 0xf8, 0x61, 0xe2, 0x84, 0x91, 0x76, 0x6b, 0x72, 0xda, 0x31, 0x49, 0x7a, - 0xd3, 0x50, 0xfe, 0x44, 0x5a, 0xab, 0xa9, 0x4e, 0x50, 0x26, 0x66, 0x1f, 0x73, 0x18, 0x7a, 0x19, - 0xc6, 0x02, 0xc2, 0x56, 0xc5, 0x12, 0xe5, 0xe6, 0xd8, 0x32, 0x1b, 0x8c, 0xd9, 0x3e, 0xac, 0xc1, - 0xb0, 0x81, 0x19, 0xbf, 0x0d, 0x86, 0xba, 0xbc, 0x0d, 0x9e, 0x86, 0x61, 0xf6, 0x43, 0xad, 0x00, - 0x35, 0x1b, 0xab, 0xbc, 0x18, 0x4b, 0x78, 0x72, 0xc1, 0x8c, 0xf4, 0xb7, 0x60, 0xe8, 0xeb, 0x43, - 0x2c, 0x6a, 0xa6, 0xd5, 0x1e, 0xe1, 0xa7, 0x9c, 0x58, 0xf2, 0x58, 0xc2, 0xec, 0x0f, 0xc0, 0x44, - 0xc5, 0x21, 0x2d, 0xdf, 0x5b, 0xf6, 0x1a, 0x6d, 0xdf, 0xf5, 0x22, 0x34, 0x0b, 0x03, 0xec, 0x12, - 0xe1, 0x47, 0xc0, 0x00, 0x6d, 0x08, 0xb3, 0x12, 0x7b, 0x1b, 0x4e, 0x57, 0xfc, 0xbb, 0xde, 0x5d, - 0x27, 0x68, 0x2c, 0x54, 0x57, 0xb5, 0xf7, 0xf5, 0xba, 0x7c, 0xdf, 0x71, 0x23, 0xb1, 0xcc, 0xa3, - 0x57, 0xab, 0xc9, 0xd9, 0xda, 0x15, 0xb7, 0x49, 0x72, 0xa4, 0x20, 0x7f, 0xa9, 0x60, 0xb4, 0x14, - 0xe3, 0x2b, 0xad, 0x96, 0x95, 0xab, 0xd5, 0x7a, 0x03, 0x46, 0xb6, 0x5c, 0xd2, 0x6c, 0x60, 0xb2, - 0x25, 0x56, 0xe2, 0x53, 0xf9, 0x76, 0x2f, 0x2b, 0x14, 0x53, 0x4a, 0xbd, 0xf8, 0xeb, 0x70, 0x45, - 0x54, 0xc6, 0x8a, 0x0c, 0xda, 0x85, 0x29, 0xf9, 0x60, 0x90, 0x50, 0xb1, 0x2e, 0x9f, 0xee, 0xf6, - 0x0a, 0x31, 0x89, 0x9f, 0xba, 0x7f, 0x50, 0x9e, 0xc2, 0x09, 0x32, 0x38, 0x45, 0x98, 0x3e, 0x07, - 0x5b, 0xf4, 0x04, 0x1e, 0x60, 0xc3, 0xcf, 0x9e, 0x83, 0xec, 0x65, 0xcb, 0x4a, 0xed, 0x9f, 0xb0, - 0xe0, 0x91, 0xd4, 0xc8, 0x88, 0x17, 0xfe, 0x31, 0xcf, 0x42, 0xf2, 0xc5, 0x5d, 0xe8, 0xfd, 0xe2, - 0xb6, 0xff, 0xa6, 0x05, 0xa7, 0x96, 0x5b, 0xed, 0x68, 0xbf, 0xe2, 0x9a, 0x2a, 0xa8, 0x0f, 0xc3, - 0x50, 0x8b, 0x34, 0xdc, 0x4e, 0x4b, 0xcc, 0x5c, 0x59, 0x9e, 0x52, 0x6b, 0xac, 0xf4, 0xf0, 0xa0, - 0x3c, 0x5e, 0x8b, 0xfc, 0xc0, 0xd9, 0x26, 0xbc, 0x00, 0x0b, 0x74, 0x76, 0xd6, 0xbb, 0x6f, 0x93, - 0x1b, 0x6e, 0xcb, 0x95, 0x76, 0x4c, 0x5d, 0x65, 0x76, 0xf3, 0x72, 0x40, 0xe7, 0xdf, 0xe8, 0x38, - 0x5e, 0xe4, 0x46, 0xfb, 0x42, 0x7b, 0x24, 0x89, 0xe0, 0x98, 0x9e, 0xfd, 0x75, 0x0b, 0x26, 0xe5, - 0xba, 0x5f, 0x68, 0x34, 0x02, 0x12, 0x86, 0x68, 0x0e, 0x0a, 0x6e, 0x5b, 0xf4, 0x12, 0x44, 0x2f, - 0x0b, 0xab, 0x55, 0x5c, 0x70, 0xdb, 0x92, 0x2d, 0x63, 0x07, 0x61, 0xd1, 0x54, 0xa4, 0x5d, 0x13, - 0xe5, 0x58, 0x61, 0xa0, 0x4b, 0x30, 0xe2, 0xf9, 0x0d, 0x6e, 0x4b, 0xc6, 0xaf, 0x34, 0xb6, 0xc0, - 0xd6, 0x45, 0x19, 0x56, 0x50, 0x54, 0x85, 0x12, 0x37, 0xb3, 0x8a, 0x17, 0x6d, 0x5f, 0xc6, 0x5a, - 0xec, 0xcb, 0x36, 0x64, 0x4d, 0x1c, 0x13, 0xb1, 0x7f, 0xd5, 0x82, 0x31, 0xf9, 0x65, 0x7d, 0xf2, - 0x9c, 0x74, 0x6b, 0xc5, 0xfc, 0x66, 0xbc, 0xb5, 0x28, 0xcf, 0xc8, 0x20, 0x06, 0xab, 0x58, 0x3c, - 0x12, 0xab, 0x78, 0x05, 0x46, 0x9d, 0x76, 0xbb, 0x6a, 0xf2, 0x99, 0x6c, 0x29, 0x2d, 0xc4, 0xc5, - 0x58, 0xc7, 0xb1, 0x7f, 0xbc, 0x00, 0x13, 0xf2, 0x0b, 0x6a, 0x9d, 0xcd, 0x90, 0x44, 0x68, 0x03, - 0x4a, 0x0e, 0x9f, 0x25, 0x22, 0x17, 0xf9, 0x13, 0xd9, 0x72, 0x04, 0x63, 0x4a, 0xe3, 0x0b, 0x7f, - 0x41, 0xd6, 0xc6, 0x31, 0x21, 0xd4, 0x84, 0x69, 0xcf, 0x8f, 0xd8, 0xe1, 0xaf, 0xe0, 0xdd, 0x54, - 0x3b, 0x49, 0xea, 0x67, 0x05, 0xf5, 0xe9, 0xf5, 0x24, 0x15, 0x9c, 0x26, 0x8c, 0x96, 0xa5, 0x6c, - 0xa6, 0x98, 0x2f, 0x0c, 0xd0, 0x27, 0x2e, 0x5b, 0x34, 0x63, 0xff, 0x8a, 0x05, 0x25, 0x89, 0x76, - 0x12, 0x5a, 0xbc, 0x35, 0x18, 0x0e, 0xd9, 0x24, 0xc8, 0xa1, 0xb1, 0xbb, 0x75, 0x9c, 0xcf, 0x57, - 0x7c, 0xa7, 0xf1, 0xff, 0x21, 0x96, 0x34, 0x98, 0x68, 0x5e, 0x75, 0xff, 0x5d, 0x22, 0x9a, 0x57, - 0xfd, 0xc9, 0xb9, 0x94, 0xfe, 0x90, 0xf5, 0x59, 0x93, 0x75, 0x51, 0xd6, 0xab, 0x1d, 0x90, 0x2d, - 0xf7, 0x5e, 0x92, 0xf5, 0xaa, 0xb2, 0x52, 0x2c, 0xa0, 0xe8, 0x4d, 0x18, 0xab, 0x4b, 0x99, 0x6c, - 0xbc, 0xc3, 0x2f, 0x76, 0xd5, 0x0f, 0x28, 0x55, 0x12, 0x97, 0x85, 0x2c, 0x69, 0xf5, 0xb1, 0x41, - 0xcd, 0x34, 0x23, 0x28, 0xf6, 0x32, 0x23, 0x88, 0xe9, 0xe6, 0x2b, 0xd5, 0x7f, 0xd2, 0x82, 0x21, - 0x2e, 0x8b, 0xeb, 0x4f, 0x14, 0xaa, 0x69, 0xd6, 0xe2, 0xb1, 0xbb, 0x4d, 0x0b, 0x85, 0xa6, 0x0c, - 0xad, 0x41, 0x89, 0xfd, 0x60, 0xb2, 0xc4, 0x62, 0xbe, 0x95, 0x3f, 0x6f, 0x55, 0xef, 0xe0, 0x6d, - 0x59, 0x0d, 0xc7, 0x14, 0xec, 0x1f, 0x2b, 0xd2, 0xd3, 0x2d, 0x46, 0x35, 0x2e, 0x7d, 0xeb, 0xe1, - 0x5d, 0xfa, 0x85, 0x87, 0x75, 0xe9, 0x6f, 0xc3, 0x64, 0x5d, 0xd3, 0xc3, 0xc5, 0x33, 0x79, 0xa9, - 0xeb, 0x22, 0xd1, 0x54, 0x76, 0x5c, 0xca, 0xb2, 0x64, 0x12, 0xc1, 0x49, 0xaa, 0xe8, 0xbb, 0x60, - 0x8c, 0xcf, 0xb3, 0x68, 0x85, 0x5b, 0x62, 0xbc, 0x3f, 0x7f, 0xbd, 0xe8, 0x4d, 0x70, 0xa9, 0x9c, - 0x56, 0x1d, 0x1b, 0xc4, 0xec, 0x3f, 0xb1, 0x00, 0x2d, 0xb7, 0x77, 0x48, 0x8b, 0x04, 0x4e, 0x33, - 0x16, 0xa7, 0xff, 0xb0, 0x05, 0xb3, 0x24, 0x55, 0xbc, 0xe4, 0xb7, 0x5a, 0xe2, 0xd1, 0x92, 0xf3, - 0xae, 0x5e, 0xce, 0xa9, 0xa3, 0xdc, 0x20, 0x66, 0xf3, 0x30, 0x70, 0x6e, 0x7b, 0x68, 0x0d, 0x66, - 0xf8, 0x2d, 0xa9, 0x00, 0x9a, 0xad, 0xf7, 0xa3, 0x82, 0xf0, 0xcc, 0x46, 0x1a, 0x05, 0x67, 0xd5, - 0xb3, 0xbf, 0x6f, 0x0c, 0x72, 0x7b, 0xf1, 0x9e, 0x1e, 0xe1, 0x3d, 0x3d, 0xc2, 0x7b, 0x7a, 0x84, - 0xf7, 0xf4, 0x08, 0xef, 0xe9, 0x11, 0xbe, 0xed, 0xf5, 0x08, 0x7f, 0xc1, 0x82, 0xd3, 0xea, 0x1a, - 0x30, 0x1e, 0xbe, 0x9f, 0x83, 0x19, 0xbe, 0xdd, 0x96, 0x9a, 0x8e, 0xdb, 0xda, 0x20, 0xad, 0x76, - 0xd3, 0x89, 0xa4, 0xd6, 0xfd, 0x4a, 0xe6, 0xca, 0x4d, 0x58, 0xac, 0x1a, 0x15, 0xb9, 0xe9, 0x7f, - 0x06, 0x00, 0x67, 0x35, 0x63, 0xff, 0xe2, 0x08, 0x0c, 0x2e, 0xef, 0x11, 0x2f, 0x3a, 0x81, 0x27, - 0x42, 0x1d, 0x26, 0x5c, 0x6f, 0xcf, 0x6f, 0xee, 0x91, 0x06, 0x87, 0x1f, 0xe5, 0x25, 0x7b, 0x46, - 0x90, 0x9e, 0x58, 0x35, 0x48, 0xe0, 0x04, 0xc9, 0x87, 0x21, 0x4d, 0xbe, 0x0a, 0x43, 0xfc, 0x10, - 0x17, 0xa2, 0xe4, 0xcc, 0x33, 0x9b, 0x0d, 0xa2, 0xb8, 0x9a, 0x62, 0x49, 0x37, 0xbf, 0x24, 0x44, - 0x75, 0xf4, 0x59, 0x98, 0xd8, 0x72, 0x83, 0x30, 0xda, 0x70, 0x5b, 0x24, 0x8c, 0x9c, 0x56, 0xfb, - 0x01, 0xa4, 0xc7, 0x6a, 0x1c, 0x56, 0x0c, 0x4a, 0x38, 0x41, 0x19, 0x6d, 0xc3, 0x78, 0xd3, 0xd1, - 0x9b, 0x1a, 0x3e, 0x72, 0x53, 0xea, 0x76, 0xb8, 0xa1, 0x13, 0xc2, 0x26, 0x5d, 0xba, 0x9d, 0xea, - 0x4c, 0x00, 0x3a, 0xc2, 0xc4, 0x02, 0x6a, 0x3b, 0x71, 0xc9, 0x27, 0x87, 0x51, 0x46, 0x87, 0x19, - 0xc8, 0x96, 0x4c, 0x46, 0x47, 0x33, 0x83, 0xfd, 0x0c, 0x94, 0x08, 0x1d, 0x42, 0x4a, 0x58, 0x5c, - 0x30, 0x97, 0xfb, 0xeb, 0xeb, 0x9a, 0x5b, 0x0f, 0x7c, 0x53, 0x6e, 0xbf, 0x2c, 0x29, 0xe1, 0x98, - 0x28, 0x5a, 0x82, 0xa1, 0x90, 0x04, 0x2e, 0x09, 0xc5, 0x55, 0xd3, 0x65, 0x1a, 0x19, 0x1a, 0xf7, - 0x2d, 0xe1, 0xbf, 0xb1, 0xa8, 0x4a, 0x97, 0x97, 0xc3, 0x44, 0x9a, 0xec, 0x32, 0xd0, 0x96, 0xd7, - 0x02, 0x2b, 0xc5, 0x02, 0x8a, 0x5e, 0x87, 0xe1, 0x80, 0x34, 0x99, 0x62, 0x68, 0xbc, 0xff, 0x45, - 0xce, 0xf5, 0x4c, 0xbc, 0x1e, 0x96, 0x04, 0xd0, 0x75, 0x40, 0x01, 0xa1, 0x8c, 0x92, 0xeb, 0x6d, - 0x2b, 0xb3, 0x51, 0x71, 0xd0, 0x2a, 0x86, 0x14, 0xc7, 0x18, 0xd2, 0xad, 0x08, 0x67, 0x54, 0x43, - 0x57, 0x61, 0x5a, 0x95, 0xae, 0x7a, 0x61, 0xe4, 0xd0, 0x03, 0x6e, 0x92, 0xd1, 0x52, 0x72, 0x0a, - 0x9c, 0x44, 0xc0, 0xe9, 0x3a, 0xf6, 0x97, 0x2d, 0xe0, 0xe3, 0x7c, 0x02, 0xaf, 0xf3, 0xd7, 0xcc, - 0xd7, 0xf9, 0xd9, 0xdc, 0x99, 0xcb, 0x79, 0x99, 0x7f, 0xd9, 0x82, 0x51, 0x6d, 0x66, 0xe3, 0x35, - 0x6b, 0x75, 0x59, 0xb3, 0x1d, 0x98, 0xa2, 0x2b, 0xfd, 0xe6, 0x66, 0x48, 0x82, 0x3d, 0xd2, 0x60, - 0x0b, 0xb3, 0xf0, 0x60, 0x0b, 0x53, 0x99, 0xa8, 0xdd, 0x48, 0x10, 0xc4, 0xa9, 0x26, 0xec, 0xcf, - 0xc8, 0xae, 0x2a, 0x8b, 0xbe, 0xba, 0x9a, 0xf3, 0x84, 0x45, 0x9f, 0x9a, 0x55, 0x1c, 0xe3, 0xd0, - 0xad, 0xb6, 0xe3, 0x87, 0x51, 0xd2, 0xa2, 0xef, 0x9a, 0x1f, 0x46, 0x98, 0x41, 0xec, 0x17, 0x00, - 0x96, 0xef, 0x91, 0x3a, 0x5f, 0xb1, 0xfa, 0xe3, 0xc1, 0xca, 0x7f, 0x3c, 0xd8, 0xbf, 0x65, 0xc1, - 0xc4, 0xca, 0x92, 0x71, 0x73, 0xcd, 0x03, 0xf0, 0x17, 0xcf, 0x9d, 0x3b, 0xeb, 0x52, 0x1d, 0xce, - 0x35, 0x9a, 0xaa, 0x14, 0x6b, 0x18, 0xe8, 0x2c, 0x14, 0x9b, 0x1d, 0x4f, 0x88, 0x0f, 0x87, 0xe9, - 0xf5, 0x78, 0xa3, 0xe3, 0x61, 0x5a, 0xa6, 0xb9, 0x14, 0x14, 0xfb, 0x76, 0x29, 0xe8, 0x19, 0x4a, - 0x00, 0x95, 0x61, 0xf0, 0xee, 0x5d, 0xb7, 0xc1, 0x1d, 0x36, 0x85, 0xaa, 0xfe, 0xce, 0x9d, 0xd5, - 0x4a, 0x88, 0x79, 0xb9, 0xfd, 0xc5, 0x22, 0xcc, 0xad, 0x34, 0xc9, 0xbd, 0x77, 0xe8, 0xb4, 0xda, - 0xaf, 0x43, 0xc4, 0xd1, 0x04, 0x31, 0x47, 0x75, 0x7a, 0xe9, 0x3d, 0x1e, 0x5b, 0x30, 0xcc, 0x0d, - 0xda, 0xa4, 0x0b, 0xeb, 0xab, 0x59, 0xad, 0xe7, 0x0f, 0xc8, 0x3c, 0x37, 0x8c, 0x13, 0x1e, 0x71, - 0xea, 0xc2, 0x14, 0xa5, 0x58, 0x12, 0x9f, 0x7b, 0x05, 0xc6, 0x74, 0xcc, 0x23, 0xb9, 0x9f, 0xfd, - 0x3f, 0x45, 0x98, 0xa2, 0x3d, 0x78, 0xa8, 0x13, 0x71, 0x2b, 0x3d, 0x11, 0xc7, 0xed, 0x82, 0xd4, - 0x7b, 0x36, 0xde, 0x4c, 0xce, 0xc6, 0x95, 0xbc, 0xd9, 0x38, 0xe9, 0x39, 0xf8, 0x5e, 0x0b, 0x66, - 0x56, 0x9a, 0x7e, 0x7d, 0x37, 0xe1, 0x26, 0xf4, 0x12, 0x8c, 0xd2, 0xe3, 0x38, 0x34, 0x3c, 0xe6, - 0x8d, 0x18, 0x0a, 0x02, 0x84, 0x75, 0x3c, 0xad, 0xda, 0xad, 0x5b, 0xab, 0x95, 0xac, 0xd0, 0x0b, - 0x02, 0x84, 0x75, 0x3c, 0xfb, 0x37, 0x2c, 0x38, 0x77, 0x75, 0x69, 0x39, 0x5e, 0x8a, 0xa9, 0xe8, - 0x0f, 0x17, 0x61, 0xa8, 0xdd, 0xd0, 0xba, 0x12, 0x8b, 0x57, 0x2b, 0xac, 0x17, 0x02, 0xfa, 0x6e, - 0x89, 0x6c, 0x72, 0x0b, 0xe0, 0x2a, 0xae, 0x2e, 0x89, 0x73, 0x57, 0x6a, 0x53, 0xac, 0x5c, 0x6d, - 0xca, 0xfb, 0x61, 0x98, 0xde, 0x0b, 0x6e, 0x5d, 0xf6, 0x9b, 0x2b, 0x68, 0x79, 0x11, 0x96, 0x30, - 0xfb, 0x67, 0x2d, 0x98, 0xb9, 0xea, 0x46, 0xf4, 0xd2, 0x4e, 0x86, 0x37, 0xa0, 0xb7, 0x76, 0xe8, - 0x46, 0x7e, 0xb0, 0x9f, 0x0c, 0x6f, 0x80, 0x15, 0x04, 0x6b, 0x58, 0xfc, 0x83, 0xf6, 0x5c, 0x66, - 0xa1, 0x5d, 0x30, 0xf5, 0x57, 0x58, 0x94, 0x63, 0x85, 0x41, 0xc7, 0xab, 0xe1, 0x06, 0x4c, 0xf4, - 0xb7, 0x2f, 0x0e, 0x6e, 0x35, 0x5e, 0x15, 0x09, 0xc0, 0x31, 0x8e, 0xfd, 0x47, 0x16, 0x94, 0xaf, - 0x36, 0x3b, 0x61, 0x44, 0x82, 0xad, 0x30, 0xe7, 0xd0, 0x7d, 0x01, 0x4a, 0x44, 0x0a, 0xda, 0x45, - 0xaf, 0x15, 0x23, 0xaa, 0x24, 0xf0, 0x3c, 0xca, 0x82, 0xc2, 0xeb, 0xc3, 0x97, 0xf1, 0x68, 0xce, - 0x68, 0x2b, 0x80, 0x88, 0xde, 0x96, 0x1e, 0x76, 0x82, 0xf9, 0xaf, 0x2f, 0xa7, 0xa0, 0x38, 0xa3, - 0x86, 0xfd, 0x13, 0x16, 0x9c, 0x56, 0x1f, 0xfc, 0xae, 0xfb, 0x4c, 0xfb, 0xab, 0x05, 0x18, 0xbf, - 0xb6, 0xb1, 0x51, 0xbd, 0x4a, 0x22, 0x6d, 0x55, 0x76, 0x57, 0x9f, 0x63, 0x4d, 0x0b, 0xd8, 0xed, - 0x8d, 0xd8, 0x89, 0xdc, 0xe6, 0x3c, 0x8f, 0x5e, 0x34, 0xbf, 0xea, 0x45, 0x37, 0x83, 0x5a, 0x14, - 0xb8, 0xde, 0x76, 0xe6, 0x4a, 0x97, 0x3c, 0x4b, 0x31, 0x8f, 0x67, 0x41, 0x2f, 0xc0, 0x10, 0x0b, - 0x9f, 0x24, 0x27, 0xe1, 0x51, 0xf5, 0xc4, 0x62, 0xa5, 0x87, 0x07, 0xe5, 0xd2, 0x2d, 0xbc, 0xca, - 0xff, 0x60, 0x81, 0x8a, 0x6e, 0xc1, 0xe8, 0x4e, 0x14, 0xb5, 0xaf, 0x11, 0xa7, 0x41, 0x02, 0x79, - 0xca, 0x9e, 0xcf, 0x3a, 0x65, 0xe9, 0x20, 0x70, 0xb4, 0xf8, 0x60, 0x8a, 0xcb, 0x42, 0xac, 0xd3, - 0xb1, 0x6b, 0x00, 0x31, 0xec, 0x98, 0x14, 0x20, 0xf6, 0x06, 0x94, 0xe8, 0xe7, 0x2e, 0x34, 0x5d, - 0xa7, 0xbb, 0x8a, 0xf9, 0x19, 0x28, 0x49, 0x05, 0x72, 0x28, 0x7c, 0xad, 0xd9, 0x8d, 0x24, 0xf5, - 0xcb, 0x21, 0x8e, 0xe1, 0xf6, 0x16, 0x9c, 0x62, 0xe6, 0x80, 0x4e, 0xb4, 0x63, 0xac, 0xbe, 0xde, - 0xd3, 0xfc, 0xac, 0x78, 0xb1, 0xf1, 0x3e, 0xcf, 0x6a, 0xee, 0x8c, 0x63, 0x92, 0x62, 0xfc, 0x7a, - 0xb3, 0xbf, 0x31, 0x00, 0x8f, 0xae, 0xd6, 0xf2, 0xc3, 0x7f, 0xbc, 0x0c, 0x63, 0x9c, 0x11, 0xa4, - 0x93, 0xee, 0x34, 0x45, 0xbb, 0x4a, 0xb6, 0xb9, 0xa1, 0xc1, 0xb0, 0x81, 0x89, 0xce, 0x41, 0xd1, - 0x7d, 0xcb, 0x4b, 0x3a, 0xfb, 0xac, 0xbe, 0xb1, 0x8e, 0x69, 0x39, 0x05, 0x53, 0x9e, 0x92, 0x1f, - 0xd6, 0x0a, 0xac, 0xf8, 0xca, 0xd7, 0x60, 0xc2, 0x0d, 0xeb, 0xa1, 0xbb, 0xea, 0xd1, 0x1d, 0xa8, - 0xed, 0x61, 0x25, 0x4d, 0xa0, 0x9d, 0x56, 0x50, 0x9c, 0xc0, 0xd6, 0x6e, 0x8e, 0xc1, 0xbe, 0xf9, - 0xd2, 0x9e, 0xce, 0xc7, 0xf4, 0x60, 0x6f, 0xb3, 0xaf, 0x0b, 0x99, 0x90, 0x5a, 0x1c, 0xec, 0xfc, - 0x83, 0x43, 0x2c, 0x61, 0xf4, 0xa9, 0x56, 0xdf, 0x71, 0xda, 0x0b, 0x9d, 0x68, 0xa7, 0xe2, 0x86, - 0x75, 0x7f, 0x8f, 0x04, 0xfb, 0xec, 0x95, 0x3d, 0x12, 0x3f, 0xd5, 0x14, 0x60, 0xe9, 0xda, 0x42, - 0x95, 0x62, 0xe2, 0x74, 0x1d, 0xb4, 0x00, 0x93, 0xb2, 0xb0, 0x46, 0x42, 0x76, 0xb8, 0x8f, 0x32, - 0x32, 0xca, 0xfd, 0x46, 0x14, 0x2b, 0x22, 0x49, 0x7c, 0x93, 0x75, 0x85, 0xe3, 0x60, 0x5d, 0x3f, - 0x0c, 0xe3, 0xae, 0xe7, 0x46, 0xae, 0x13, 0xf9, 0x5c, 0xc3, 0xc2, 0x1f, 0xd4, 0x4c, 0x74, 0xbc, - 0xaa, 0x03, 0xb0, 0x89, 0x67, 0xff, 0x87, 0x01, 0x98, 0x66, 0xd3, 0xf6, 0xde, 0x0a, 0xfb, 0x76, - 0x5a, 0x61, 0xb7, 0xd2, 0x2b, 0xec, 0x38, 0x78, 0xf2, 0x07, 0x5e, 0x66, 0x9f, 0x85, 0x92, 0xf2, - 0x38, 0x92, 0x2e, 0x87, 0x56, 0x8e, 0xcb, 0x61, 0xef, 0x7b, 0x59, 0x1a, 0x6d, 0x15, 0x33, 0x8d, - 0xb6, 0xbe, 0x62, 0x41, 0xac, 0x32, 0x40, 0x6f, 0x40, 0xa9, 0xed, 0x33, 0x5b, 0xc4, 0x40, 0x1a, - 0xf8, 0x3e, 0xd9, 0x55, 0xe7, 0xc0, 0x23, 0x20, 0x05, 0x7c, 0x14, 0xaa, 0xb2, 0x2a, 0x8e, 0xa9, - 0xa0, 0xeb, 0x30, 0xdc, 0x0e, 0x48, 0x2d, 0x62, 0xe1, 0x39, 0xfa, 0x27, 0xc8, 0x57, 0x0d, 0xaf, - 0x88, 0x25, 0x05, 0xfb, 0x3f, 0x5a, 0x30, 0x95, 0x44, 0x45, 0x1f, 0x81, 0x01, 0x72, 0x8f, 0xd4, - 0x45, 0x7f, 0x33, 0x2f, 0xd9, 0x58, 0xe8, 0xc0, 0x07, 0x80, 0xfe, 0xc7, 0xac, 0x16, 0xba, 0x06, - 0xc3, 0xf4, 0x86, 0xbd, 0xaa, 0x42, 0x51, 0x3d, 0x9e, 0x77, 0x4b, 0x2b, 0x56, 0x85, 0x77, 0x4e, - 0x14, 0x61, 0x59, 0x9d, 0x59, 0x4a, 0xd5, 0xdb, 0x35, 0xfa, 0x78, 0x89, 0xba, 0xbd, 0xb1, 0x37, - 0x96, 0xaa, 0x1c, 0x49, 0x50, 0xe3, 0x96, 0x52, 0xb2, 0x10, 0xc7, 0x44, 0xec, 0x9f, 0xb7, 0x00, - 0xb8, 0x61, 0x98, 0xe3, 0x6d, 0x93, 0x13, 0x90, 0x93, 0x57, 0x60, 0x20, 0x6c, 0x93, 0x7a, 0x37, - 0x33, 0xd9, 0xb8, 0x3f, 0xb5, 0x36, 0xa9, 0xc7, 0x2b, 0x8e, 0xfe, 0xc3, 0xac, 0xb6, 0xfd, 0xfd, - 0x00, 0x13, 0x31, 0xda, 0x6a, 0x44, 0x5a, 0xe8, 0x39, 0x23, 0x4c, 0xc1, 0xd9, 0x44, 0x98, 0x82, - 0x12, 0xc3, 0xd6, 0x44, 0xb2, 0x9f, 0x85, 0x62, 0xcb, 0xb9, 0x27, 0x64, 0x6e, 0xcf, 0x74, 0xef, - 0x06, 0xa5, 0x3f, 0xbf, 0xe6, 0xdc, 0xe3, 0xcf, 0xd2, 0x67, 0xe4, 0x0e, 0x59, 0x73, 0xee, 0x1d, - 0x72, 0x63, 0x58, 0x76, 0x4a, 0xdf, 0x70, 0xc3, 0xe8, 0xf3, 0xff, 0x3e, 0xfe, 0xcf, 0xf6, 0x1d, - 0x6d, 0x84, 0xb5, 0xe5, 0x7a, 0xc2, 0xe6, 0xa9, 0xaf, 0xb6, 0x5c, 0x2f, 0xd9, 0x96, 0xeb, 0xf5, - 0xd1, 0x96, 0xeb, 0xa1, 0xb7, 0x61, 0x58, 0x98, 0x24, 0x8a, 0xb0, 0x40, 0x97, 0xfb, 0x68, 0x4f, - 0x58, 0x34, 0xf2, 0x36, 0x2f, 0xcb, 0x67, 0xb7, 0x28, 0xed, 0xd9, 0xae, 0x6c, 0x10, 0xfd, 0x45, - 0x0b, 0x26, 0xc4, 0x6f, 0x4c, 0xde, 0xea, 0x90, 0x30, 0x12, 0x6c, 0xe9, 0x87, 0xfa, 0xef, 0x83, - 0xa8, 0xc8, 0xbb, 0xf2, 0x21, 0x79, 0xcf, 0x98, 0xc0, 0x9e, 0x3d, 0x4a, 0xf4, 0x02, 0xfd, 0x6d, - 0x0b, 0x4e, 0xb5, 0x9c, 0x7b, 0xbc, 0x45, 0x5e, 0x86, 0x9d, 0xc8, 0xf5, 0x85, 0x6a, 0xff, 0x23, - 0xfd, 0x4d, 0x7f, 0xaa, 0x3a, 0xef, 0xa4, 0xd4, 0x3f, 0x9e, 0xca, 0x42, 0xe9, 0xd9, 0xd5, 0xcc, - 0x7e, 0xcd, 0x6d, 0xc1, 0x88, 0x5c, 0x6f, 0x19, 0xc2, 0x8d, 0x8a, 0xce, 0x73, 0x1f, 0xd9, 0x22, - 0x54, 0x77, 0xff, 0xa7, 0xed, 0x88, 0xb5, 0xf6, 0x50, 0xdb, 0xf9, 0x2c, 0x8c, 0xe9, 0x6b, 0xec, - 0xa1, 0xb6, 0xf5, 0x16, 0xcc, 0x64, 0xac, 0xa5, 0x87, 0xda, 0xe4, 0x5d, 0x38, 0x9b, 0xbb, 0x3e, - 0x1e, 0x66, 0xc3, 0xf6, 0x57, 0x2d, 0xfd, 0x1c, 0x3c, 0x01, 0x65, 0xc5, 0x92, 0xa9, 0xac, 0x38, - 0xdf, 0x7d, 0xe7, 0xe4, 0x68, 0x2c, 0xde, 0xd4, 0x3b, 0x4d, 0x4f, 0x75, 0xf4, 0x3a, 0x0c, 0x35, - 0x69, 0x89, 0x34, 0x6c, 0xb5, 0x7b, 0xef, 0xc8, 0x98, 0x99, 0x64, 0xe5, 0x21, 0x16, 0x14, 0xec, - 0x5f, 0xb2, 0x60, 0xe0, 0x04, 0x46, 0x02, 0x9b, 0x23, 0xf1, 0x5c, 0x2e, 0x69, 0x11, 0x21, 0x79, - 0x1e, 0x3b, 0x77, 0x97, 0xef, 0x45, 0xc4, 0x0b, 0xd9, 0x8d, 0x9c, 0x39, 0x30, 0x3f, 0x6d, 0xc1, - 0xcc, 0x0d, 0xdf, 0x69, 0x2c, 0x3a, 0x4d, 0xc7, 0xab, 0x93, 0x60, 0xd5, 0xdb, 0x3e, 0x92, 0x55, - 0x76, 0xa1, 0xa7, 0x55, 0xf6, 0x92, 0x34, 0x6a, 0x1a, 0xc8, 0x9f, 0x3f, 0xca, 0x49, 0x27, 0x03, - 0xb7, 0x18, 0xe6, 0xb7, 0x3b, 0x80, 0xf4, 0x5e, 0x0a, 0x1f, 0x19, 0x0c, 0xc3, 0x2e, 0xef, 0xaf, - 0x98, 0xc4, 0xa7, 0xb2, 0x39, 0xdc, 0xd4, 0xe7, 0x69, 0xde, 0x1f, 0xbc, 0x00, 0x4b, 0x42, 0xf6, - 0xcb, 0x90, 0xe9, 0x68, 0xdf, 0x5b, 0x2e, 0x61, 0x7f, 0x02, 0xa6, 0x59, 0xcd, 0x23, 0x4a, 0x06, - 0xec, 0x84, 0x34, 0x35, 0x23, 0x04, 0x9f, 0xfd, 0x05, 0x0b, 0x26, 0xd7, 0x13, 0x91, 0xc9, 0x2e, - 0x32, 0xfd, 0x6b, 0x86, 0x10, 0xbf, 0xc6, 0x4a, 0xb1, 0x80, 0x1e, 0xbb, 0x90, 0xeb, 0xcf, 0x2d, - 0x88, 0x63, 0x5f, 0x9c, 0x00, 0xfb, 0xb6, 0x64, 0xb0, 0x6f, 0x99, 0x8c, 0xac, 0xea, 0x4e, 0x1e, - 0xf7, 0x86, 0xae, 0xab, 0xa8, 0x50, 0x5d, 0x78, 0xd8, 0x98, 0x0c, 0x5f, 0x8a, 0x13, 0x66, 0xe8, - 0x28, 0x19, 0x27, 0xca, 0xfe, 0xed, 0x02, 0x20, 0x85, 0xdb, 0x77, 0xd4, 0xaa, 0x74, 0x8d, 0xe3, - 0x89, 0x5a, 0xb5, 0x07, 0x88, 0x59, 0x10, 0x04, 0x8e, 0x17, 0x72, 0xb2, 0xae, 0x10, 0xeb, 0x1d, - 0xcd, 0x3c, 0x61, 0x4e, 0x34, 0x89, 0x6e, 0xa4, 0xa8, 0xe1, 0x8c, 0x16, 0x34, 0xcb, 0x90, 0xc1, - 0x7e, 0x2d, 0x43, 0x86, 0x7a, 0xf8, 0xc1, 0xfd, 0x9c, 0x05, 0xe3, 0x6a, 0x98, 0xde, 0x25, 0x56, - 0xea, 0xaa, 0x3f, 0x39, 0x07, 0x68, 0x55, 0xeb, 0x32, 0xbb, 0x58, 0xbe, 0x93, 0xf9, 0x33, 0x3a, - 0x4d, 0xf7, 0x6d, 0xa2, 0x62, 0x06, 0x96, 0x85, 0x7f, 0xa2, 0x28, 0x3d, 0x3c, 0x28, 0x8f, 0xab, - 0x7f, 0x3c, 0x26, 0x72, 0x5c, 0x85, 0x1e, 0xc9, 0x93, 0x89, 0xa5, 0x88, 0x5e, 0x82, 0xc1, 0xf6, - 0x8e, 0x13, 0x92, 0x84, 0x37, 0xcf, 0x60, 0x95, 0x16, 0x1e, 0x1e, 0x94, 0x27, 0x54, 0x05, 0x56, - 0x82, 0x39, 0x76, 0xff, 0xb1, 0xc0, 0xd2, 0x8b, 0xb3, 0x67, 0x2c, 0xb0, 0x3f, 0xb1, 0x60, 0x60, - 0xdd, 0x6f, 0x9c, 0xc4, 0x11, 0xf0, 0x9a, 0x71, 0x04, 0x3c, 0x96, 0x17, 0xae, 0x3e, 0x77, 0xf7, - 0xaf, 0x24, 0x76, 0xff, 0xf9, 0x5c, 0x0a, 0xdd, 0x37, 0x7e, 0x0b, 0x46, 0x59, 0x10, 0x7c, 0xe1, - 0xb9, 0xf4, 0x82, 0xb1, 0xe1, 0xcb, 0x89, 0x0d, 0x3f, 0xa9, 0xa1, 0x6a, 0x3b, 0xfd, 0x69, 0x18, - 0x16, 0xae, 0x30, 0x49, 0xb7, 0x50, 0x81, 0x8b, 0x25, 0xdc, 0xfe, 0xc9, 0x22, 0x18, 0x41, 0xf7, - 0xd1, 0xaf, 0x58, 0x30, 0x1f, 0x70, 0x13, 0xd9, 0x46, 0xa5, 0x13, 0xb8, 0xde, 0x76, 0xad, 0xbe, - 0x43, 0x1a, 0x9d, 0xa6, 0xeb, 0x6d, 0xaf, 0x6e, 0x7b, 0xbe, 0x2a, 0x5e, 0xbe, 0x47, 0xea, 0x1d, - 0xa6, 0x76, 0xeb, 0x11, 0xe1, 0x5f, 0x99, 0x9a, 0x3f, 0x7f, 0xff, 0xa0, 0x3c, 0x8f, 0x8f, 0x44, - 0x1b, 0x1f, 0xb1, 0x2f, 0xe8, 0x37, 0x2c, 0xb8, 0xcc, 0x63, 0xd1, 0xf7, 0xdf, 0xff, 0x2e, 0xaf, - 0xe5, 0xaa, 0x24, 0x15, 0x13, 0xd9, 0x20, 0x41, 0x6b, 0xf1, 0xc3, 0x62, 0x40, 0x2f, 0x57, 0x8f, - 0xd6, 0x16, 0x3e, 0x6a, 0xe7, 0xec, 0x7f, 0x54, 0x84, 0x71, 0x11, 0x33, 0x4a, 0xdc, 0x01, 0x2f, - 0x19, 0x4b, 0xe2, 0xf1, 0xc4, 0x92, 0x98, 0x36, 0x90, 0x8f, 0xe7, 0xf8, 0x0f, 0x61, 0x9a, 0x1e, - 0xce, 0xd7, 0x88, 0x13, 0x44, 0x9b, 0xc4, 0xe1, 0x06, 0x5f, 0xc5, 0x23, 0x9f, 0xfe, 0x4a, 0x3e, - 0x79, 0x23, 0x49, 0x0c, 0xa7, 0xe9, 0x7f, 0x3b, 0xdd, 0x39, 0x1e, 0x4c, 0xa5, 0xc2, 0x7e, 0x7d, - 0x12, 0x4a, 0xca, 0x8f, 0x43, 0x1c, 0x3a, 0xdd, 0xa3, 0xe7, 0x25, 0x29, 0x70, 0xf1, 0x57, 0xec, - 0x43, 0x14, 0x93, 0xb3, 0xff, 0x4e, 0xc1, 0x68, 0x90, 0x4f, 0xe2, 0x3a, 0x8c, 0x38, 0x61, 0xe8, - 0x6e, 0x7b, 0xa4, 0xd1, 0x4d, 0x42, 0x99, 0x6a, 0x86, 0xf9, 0xd2, 0x2c, 0x88, 0x9a, 0x58, 0xd1, - 0x40, 0xd7, 0xb8, 0x59, 0xdd, 0x1e, 0xe9, 0x26, 0x9e, 0x4c, 0x51, 0x03, 0x69, 0x78, 0xb7, 0x47, - 0xb0, 0xa8, 0x8f, 0x3e, 0xc5, 0xed, 0x1e, 0xaf, 0x7b, 0xfe, 0x5d, 0xef, 0xaa, 0xef, 0xcb, 0xb8, - 0x0c, 0xfd, 0x11, 0x9c, 0x96, 0xd6, 0x8e, 0xaa, 0x3a, 0x36, 0xa9, 0xf5, 0x17, 0x47, 0xf3, 0x73, - 0xc0, 0x62, 0x6f, 0x9b, 0x6e, 0xd3, 0x21, 0x22, 0x30, 0x29, 0x02, 0x92, 0xc9, 0x32, 0x31, 0x76, - 0x99, 0x4f, 0x39, 0xb3, 0x76, 0x2c, 0x48, 0xbf, 0x6e, 0x92, 0xc0, 0x49, 0x9a, 0xf6, 0xcf, 0x58, - 0xc0, 0x5c, 0x48, 0x4f, 0x80, 0x1f, 0xf9, 0xa8, 0xc9, 0x8f, 0xcc, 0xe6, 0x0d, 0x72, 0x0e, 0x2b, - 0xf2, 0x22, 0x5f, 0x59, 0xd5, 0xc0, 0xbf, 0xb7, 0x2f, 0x8c, 0x55, 0x7a, 0xbf, 0x3f, 0xec, 0xff, - 0x69, 0xf1, 0x43, 0x4c, 0x79, 0x59, 0xa0, 0xef, 0x86, 0x91, 0xba, 0xd3, 0x76, 0xea, 0x3c, 0x43, - 0x4c, 0xae, 0x44, 0xcf, 0xa8, 0x34, 0xbf, 0x24, 0x6a, 0x70, 0x09, 0x95, 0x0c, 0x6c, 0x37, 0x22, - 0x8b, 0x7b, 0x4a, 0xa5, 0x54, 0x93, 0x73, 0xbb, 0x30, 0x6e, 0x10, 0x7b, 0xa8, 0xe2, 0x8c, 0xef, - 0xe6, 0x57, 0xac, 0x0a, 0xc4, 0xd8, 0x82, 0x69, 0x4f, 0xfb, 0x4f, 0x2f, 0x14, 0xf9, 0xb8, 0x7c, - 0xb2, 0xd7, 0x25, 0xca, 0x6e, 0x1f, 0xcd, 0x3b, 0x35, 0x41, 0x06, 0xa7, 0x29, 0xdb, 0x3f, 0x65, - 0xc1, 0x23, 0x3a, 0xa2, 0xe6, 0x00, 0xd3, 0x4b, 0x49, 0x52, 0x81, 0x11, 0xbf, 0x4d, 0x02, 0x27, - 0xf2, 0x03, 0x71, 0x6b, 0x5c, 0x92, 0x83, 0x7e, 0x53, 0x94, 0x1f, 0x8a, 0x78, 0xe7, 0x92, 0xba, - 0x2c, 0xc7, 0xaa, 0x26, 0x7d, 0x7d, 0xb2, 0xc1, 0x08, 0x85, 0xab, 0x13, 0x3b, 0x03, 0x98, 0x26, - 0x3d, 0xc4, 0x02, 0x62, 0x7f, 0xc3, 0xe2, 0x0b, 0x4b, 0xef, 0x3a, 0x7a, 0x0b, 0xa6, 0x5a, 0x4e, - 0x54, 0xdf, 0x59, 0xbe, 0xd7, 0x0e, 0xb8, 0xca, 0x49, 0x8e, 0xd3, 0x33, 0xbd, 0xc6, 0x49, 0xfb, - 0xc8, 0xd8, 0x94, 0x73, 0x2d, 0x41, 0x0c, 0xa7, 0xc8, 0xa3, 0x4d, 0x18, 0x65, 0x65, 0xcc, 0x8b, - 0x2f, 0xec, 0xc6, 0x1a, 0xe4, 0xb5, 0xa6, 0x8c, 0x11, 0xd6, 0x62, 0x3a, 0x58, 0x27, 0x6a, 0x7f, - 0xa5, 0xc8, 0x77, 0x3b, 0x63, 0xe5, 0x9f, 0x86, 0xe1, 0xb6, 0xdf, 0x58, 0x5a, 0xad, 0x60, 0x31, - 0x0b, 0xea, 0x1a, 0xa9, 0xf2, 0x62, 0x2c, 0xe1, 0xe8, 0x12, 0x8c, 0x88, 0x9f, 0x52, 0x45, 0xc8, - 0xce, 0x66, 0x81, 0x17, 0x62, 0x05, 0x45, 0xcf, 0x03, 0xb4, 0x03, 0x7f, 0xcf, 0x6d, 0xb0, 0xe8, - 0x12, 0x45, 0xd3, 0x8e, 0xa8, 0xaa, 0x20, 0x58, 0xc3, 0x42, 0xaf, 0xc2, 0x78, 0xc7, 0x0b, 0x39, - 0x3b, 0xa2, 0xc5, 0x92, 0x55, 0x16, 0x2e, 0xb7, 0x74, 0x20, 0x36, 0x71, 0xd1, 0x02, 0x0c, 0x45, - 0x0e, 0xb3, 0x8b, 0x19, 0xcc, 0x37, 0xf7, 0xdd, 0xa0, 0x18, 0x7a, 0x32, 0x12, 0x5a, 0x01, 0x8b, - 0x8a, 0xe8, 0x93, 0xd2, 0xa1, 0x96, 0x1f, 0xec, 0xc2, 0xce, 0xbe, 0xbf, 0x4b, 0x40, 0x73, 0xa7, - 0x15, 0xf6, 0xfb, 0x06, 0x2d, 0xf4, 0x0a, 0x00, 0xb9, 0x17, 0x91, 0xc0, 0x73, 0x9a, 0xca, 0x9a, - 0x4d, 0xf1, 0x05, 0x15, 0x7f, 0xdd, 0x8f, 0x6e, 0x85, 0x64, 0x59, 0x61, 0x60, 0x0d, 0xdb, 0xfe, - 0x8d, 0x12, 0x40, 0xcc, 0xb7, 0xa3, 0xb7, 0x53, 0x07, 0xd7, 0xb3, 0xdd, 0x39, 0xfd, 0xe3, 0x3b, - 0xb5, 0xd0, 0x0f, 0x58, 0x30, 0xea, 0x34, 0x9b, 0x7e, 0xdd, 0xe1, 0xd1, 0x7e, 0x0b, 0xdd, 0x0f, - 0x4e, 0xd1, 0xfe, 0x42, 0x5c, 0x83, 0x77, 0xe1, 0x05, 0xb9, 0x42, 0x35, 0x48, 0xcf, 0x5e, 0xe8, - 0x0d, 0xa3, 0x0f, 0xca, 0xa7, 0x62, 0xd1, 0x18, 0x4a, 0xf5, 0x54, 0x2c, 0xb1, 0x3b, 0x42, 0x7f, - 0x25, 0xde, 0x32, 0x5e, 0x89, 0x03, 0xf9, 0x1e, 0x83, 0x06, 0xfb, 0xda, 0xeb, 0x81, 0x88, 0xaa, - 0x7a, 0xf4, 0x80, 0xc1, 0x7c, 0xf7, 0x3c, 0xed, 0x9d, 0xd4, 0x23, 0x72, 0xc0, 0x67, 0x61, 0xb2, - 0x61, 0x32, 0x01, 0x62, 0x25, 0x3e, 0x95, 0x47, 0x37, 0xc1, 0x33, 0xc4, 0xd7, 0x7e, 0x02, 0x80, - 0x93, 0x84, 0x51, 0x95, 0x07, 0x93, 0x58, 0xf5, 0xb6, 0x7c, 0xe1, 0xeb, 0x61, 0xe7, 0xce, 0xe5, - 0x7e, 0x18, 0x91, 0x16, 0xc5, 0x8c, 0x6f, 0xf7, 0x75, 0x51, 0x17, 0x2b, 0x2a, 0xe8, 0x75, 0x18, - 0x62, 0xfe, 0x59, 0xe1, 0xec, 0x48, 0xbe, 0xc4, 0xd9, 0x8c, 0x8e, 0x16, 0x6f, 0x48, 0xf6, 0x37, - 0xc4, 0x82, 0x02, 0xba, 0x26, 0xbd, 0x1f, 0xc3, 0x55, 0xef, 0x56, 0x48, 0x98, 0xf7, 0x63, 0x69, - 0xf1, 0xc9, 0xd8, 0xb1, 0x91, 0x97, 0x67, 0xa6, 0x2c, 0x33, 0x6a, 0x52, 0x2e, 0x4a, 0xfc, 0x97, - 0x99, 0xd0, 0x66, 0x21, 0xbf, 0x7b, 0x66, 0xb6, 0xb4, 0x78, 0x38, 0x6f, 0x9b, 0x24, 0x70, 0x92, - 0x26, 0xe5, 0x48, 0xf9, 0xae, 0x17, 0xde, 0x22, 0xbd, 0xce, 0x0e, 0xfe, 0x10, 0x67, 0xb7, 0x11, - 0x2f, 0xc1, 0xa2, 0xfe, 0x89, 0xb2, 0x07, 0x73, 0x1e, 0x4c, 0x25, 0xb7, 0xe8, 0x43, 0x65, 0x47, - 0xfe, 0x60, 0x00, 0x26, 0xcc, 0x25, 0x85, 0x2e, 0x43, 0x49, 0x10, 0x51, 0xd9, 0x04, 0xd4, 0x2e, - 0x59, 0x93, 0x00, 0x1c, 0xe3, 0xb0, 0x24, 0x12, 0xac, 0xba, 0x66, 0x1e, 0x1c, 0x27, 0x91, 0x50, - 0x10, 0xac, 0x61, 0xd1, 0x87, 0xd5, 0xa6, 0xef, 0x47, 0xea, 0x42, 0x52, 0xeb, 0x6e, 0x91, 0x95, - 0x62, 0x01, 0xa5, 0x17, 0xd1, 0x2e, 0x09, 0x3c, 0xd2, 0x34, 0xe3, 0x0e, 0xab, 0x8b, 0xe8, 0xba, - 0x0e, 0xc4, 0x26, 0x2e, 0xbd, 0x4e, 0xfd, 0x90, 0x2d, 0x64, 0xf1, 0x7c, 0x8b, 0xcd, 0xad, 0x6b, - 0xdc, 0x01, 0x5b, 0xc2, 0xd1, 0x27, 0xe0, 0x11, 0x15, 0x5b, 0x09, 0x73, 0x6d, 0x86, 0x6c, 0x71, - 0xc8, 0x90, 0xb6, 0x3c, 0xb2, 0x94, 0x8d, 0x86, 0xf3, 0xea, 0xa3, 0xd7, 0x60, 0x42, 0xb0, 0xf8, - 0x92, 0xe2, 0xb0, 0x69, 0x61, 0x74, 0xdd, 0x80, 0xe2, 0x04, 0xb6, 0x8c, 0x9c, 0xcc, 0xb8, 0x6c, - 0x49, 0x61, 0x24, 0x1d, 0x39, 0x59, 0x87, 0xe3, 0x54, 0x0d, 0xb4, 0x00, 0x93, 0x9c, 0x07, 0x73, - 0xbd, 0x6d, 0x3e, 0x27, 0xc2, 0x99, 0x4b, 0x6d, 0xa9, 0x9b, 0x26, 0x18, 0x27, 0xf1, 0xd1, 0xcb, - 0x30, 0xe6, 0x04, 0xf5, 0x1d, 0x37, 0x22, 0xf5, 0xa8, 0x13, 0x70, 0x2f, 0x2f, 0xcd, 0x44, 0x6b, - 0x41, 0x83, 0x61, 0x03, 0xd3, 0x7e, 0x1b, 0x66, 0x32, 0x22, 0x33, 0xd0, 0x85, 0xe3, 0xb4, 0x5d, - 0xf9, 0x4d, 0x09, 0x0b, 0xe7, 0x85, 0xea, 0xaa, 0xfc, 0x1a, 0x0d, 0x8b, 0xae, 0x4e, 0x16, 0xc1, - 0x41, 0x4b, 0x7c, 0xa8, 0x56, 0xe7, 0x8a, 0x04, 0xe0, 0x18, 0xc7, 0xfe, 0x2f, 0x05, 0x98, 0xcc, - 0xd0, 0xad, 0xb0, 0xe4, 0x7b, 0x89, 0x47, 0x4a, 0x9c, 0x6b, 0xcf, 0x0c, 0xc4, 0x5d, 0x38, 0x42, - 0x20, 0xee, 0x62, 0xaf, 0x40, 0xdc, 0x03, 0xef, 0x24, 0x10, 0xb7, 0x39, 0x62, 0x83, 0x7d, 0x8d, - 0x58, 0x46, 0xf0, 0xee, 0xa1, 0x23, 0x06, 0xef, 0x36, 0x06, 0x7d, 0xb8, 0x8f, 0x41, 0xff, 0xb1, - 0x02, 0x4c, 0x25, 0x4d, 0x49, 0x4f, 0x40, 0x6e, 0xfb, 0xba, 0x21, 0xb7, 0xbd, 0xd4, 0x8f, 0xf3, - 0x6d, 0xae, 0x0c, 0x17, 0x27, 0x64, 0xb8, 0x1f, 0xe8, 0x8b, 0x5a, 0x77, 0x79, 0xee, 0x5f, 0x2d, - 0xc0, 0xe9, 0x4c, 0xef, 0xdf, 0x13, 0x18, 0x9b, 0x9b, 0xc6, 0xd8, 0x3c, 0xd7, 0xb7, 0x63, 0x72, - 0xee, 0x00, 0xdd, 0x49, 0x0c, 0xd0, 0xe5, 0xfe, 0x49, 0x76, 0x1f, 0xa5, 0xaf, 0x17, 0xe1, 0x7c, - 0x66, 0xbd, 0x58, 0xec, 0xb9, 0x62, 0x88, 0x3d, 0x9f, 0x4f, 0x88, 0x3d, 0xed, 0xee, 0xb5, 0x8f, - 0x47, 0x0e, 0x2a, 0x1c, 0x74, 0x59, 0x98, 0x81, 0x07, 0x94, 0x81, 0x1a, 0x0e, 0xba, 0x8a, 0x10, - 0x36, 0xe9, 0x7e, 0x3b, 0xc9, 0x3e, 0xff, 0xa5, 0x05, 0x67, 0x33, 0xe7, 0xe6, 0x04, 0x64, 0x5d, - 0xeb, 0xa6, 0xac, 0xeb, 0xe9, 0xbe, 0x57, 0x6b, 0x8e, 0xf0, 0xeb, 0x2b, 0x83, 0x39, 0xdf, 0xc2, - 0x5e, 0xf2, 0x37, 0x61, 0xd4, 0xa9, 0xd7, 0x49, 0x18, 0xae, 0xf9, 0x0d, 0x15, 0x6b, 0xf8, 0x39, - 0xf6, 0xce, 0x8a, 0x8b, 0x0f, 0x0f, 0xca, 0x73, 0x49, 0x12, 0x31, 0x18, 0xeb, 0x14, 0xd0, 0xa7, - 0x60, 0x24, 0x14, 0xf7, 0xa6, 0x98, 0xfb, 0x17, 0xfa, 0x1c, 0x1c, 0x67, 0x93, 0x34, 0xcd, 0x60, - 0x48, 0x4a, 0x52, 0xa1, 0x48, 0x9a, 0x81, 0x53, 0x0a, 0xc7, 0x1a, 0x38, 0xe5, 0x79, 0x80, 0x3d, - 0xf5, 0x18, 0x48, 0xca, 0x1f, 0xb4, 0x67, 0x82, 0x86, 0x85, 0x3e, 0x06, 0x53, 0x21, 0x8f, 0x16, - 0xb8, 0xd4, 0x74, 0x42, 0xe6, 0x47, 0x23, 0x56, 0x21, 0x0b, 0xb8, 0x54, 0x4b, 0xc0, 0x70, 0x0a, - 0x1b, 0xad, 0xc8, 0x56, 0x59, 0x68, 0x43, 0xbe, 0x30, 0x2f, 0xc6, 0x2d, 0x8a, 0xd4, 0xbf, 0xa7, - 0x92, 0xc3, 0xcf, 0x06, 0x5e, 0xab, 0x89, 0x3e, 0x05, 0x40, 0x97, 0x8f, 0x90, 0x43, 0x0c, 0xe7, - 0x1f, 0x9e, 0xf4, 0x54, 0x69, 0x64, 0x1a, 0x37, 0x33, 0x9f, 0xda, 0x8a, 0x22, 0x82, 0x35, 0x82, - 0x68, 0x0b, 0xc6, 0xe3, 0x7f, 0x71, 0x66, 0xcc, 0x23, 0xb6, 0xc0, 0xe4, 0xde, 0x15, 0x9d, 0x0e, - 0x36, 0xc9, 0xda, 0x3f, 0x31, 0x0c, 0x8f, 0x76, 0x39, 0x8b, 0xd1, 0x82, 0xa9, 0xef, 0x7d, 0x26, - 0xf9, 0x88, 0x9f, 0xcb, 0xac, 0x6c, 0xbc, 0xea, 0x13, 0x4b, 0xbe, 0xf0, 0x8e, 0x97, 0xfc, 0x8f, - 0x58, 0x9a, 0x78, 0x85, 0x5b, 0x96, 0x7e, 0xf4, 0x88, 0x77, 0xcc, 0x31, 0xca, 0x5b, 0xb6, 0x32, - 0x84, 0x16, 0xcf, 0xf7, 0xdd, 0x9d, 0xfe, 0xa5, 0x18, 0x5f, 0xb5, 0x00, 0x09, 0xf1, 0x0a, 0x69, - 0xa8, 0x0d, 0x25, 0xe4, 0x19, 0x57, 0x8f, 0xfa, 0xfd, 0x0b, 0x29, 0x4a, 0x7c, 0x24, 0x5e, 0x91, - 0x97, 0x41, 0x1a, 0xa1, 0xe7, 0x98, 0x64, 0x74, 0x0f, 0x7d, 0x82, 0x45, 0xd3, 0x75, 0xdf, 0x16, - 0x1c, 0x90, 0xd8, 0x70, 0x2f, 0x89, 0x48, 0xba, 0xaa, 0x9c, 0xb2, 0xba, 0x99, 0xdd, 0xd5, 0x91, - 0xb0, 0x41, 0xea, 0x64, 0xdf, 0xdf, 0x1d, 0x78, 0x24, 0x67, 0xc8, 0x1e, 0xea, 0x33, 0xfc, 0xb7, - 0x2c, 0x38, 0xd7, 0x35, 0x2c, 0xcc, 0xb7, 0x20, 0x83, 0x68, 0x7f, 0xde, 0x82, 0xec, 0xc9, 0x36, - 0xcc, 0xca, 0x2e, 0x43, 0xa9, 0x4e, 0x0b, 0x35, 0x3f, 0xe0, 0x38, 0x40, 0x82, 0x04, 0xe0, 0x18, - 0xc7, 0xb0, 0x1e, 0x2b, 0xf4, 0xb4, 0x1e, 0xfb, 0x55, 0x0b, 0x52, 0x87, 0xfc, 0x09, 0x70, 0x1b, - 0xab, 0x26, 0xb7, 0xf1, 0x64, 0x3f, 0xa3, 0x99, 0xc3, 0x68, 0xfc, 0xf1, 0x24, 0x9c, 0xc9, 0x71, - 0xcb, 0xdb, 0x83, 0xe9, 0xed, 0x3a, 0x31, 0x3d, 0xac, 0xbb, 0x45, 0x1e, 0xea, 0xea, 0x8e, 0xcd, - 0x92, 0xc3, 0x4e, 0xa7, 0x50, 0x70, 0xba, 0x09, 0xf4, 0x79, 0x0b, 0x4e, 0x39, 0x77, 0xc3, 0x65, - 0xca, 0x35, 0xba, 0xf5, 0xc5, 0xa6, 0x5f, 0xdf, 0xa5, 0x57, 0xb2, 0xdc, 0x08, 0x2f, 0x66, 0x4a, - 0xf2, 0xee, 0xd4, 0x52, 0xf8, 0x46, 0xf3, 0x2c, 0x5b, 0x6e, 0x16, 0x16, 0xce, 0x6c, 0x0b, 0x61, - 0x91, 0x42, 0x81, 0xbe, 0x49, 0xbb, 0xc4, 0x00, 0xc8, 0xf2, 0x9f, 0xe4, 0x6c, 0x90, 0x84, 0x60, - 0x45, 0x07, 0x7d, 0x06, 0x4a, 0xdb, 0xd2, 0xdd, 0x37, 0x83, 0xcd, 0x8a, 0x07, 0xb2, 0xbb, 0x13, - 0x34, 0x57, 0xc7, 0x2b, 0x24, 0x1c, 0x13, 0x45, 0xaf, 0x41, 0xd1, 0xdb, 0x0a, 0xbb, 0x25, 0x9c, - 0x4d, 0xd8, 0x5d, 0xf2, 0x48, 0x1b, 0xeb, 0x2b, 0x35, 0x4c, 0x2b, 0xa2, 0x6b, 0x50, 0x0c, 0x36, - 0x1b, 0x42, 0x0c, 0x9d, 0xb9, 0x49, 0xf1, 0x62, 0x25, 0xa7, 0x57, 0x8c, 0x12, 0x5e, 0xac, 0x60, - 0x4a, 0x02, 0x55, 0x61, 0x90, 0xf9, 0xb2, 0x09, 0xa6, 0x26, 0xf3, 0xf9, 0xd6, 0xc5, 0x27, 0x94, - 0x87, 0xe3, 0x60, 0x08, 0x98, 0x13, 0x42, 0x1b, 0x30, 0x54, 0x67, 0xc9, 0x49, 0x05, 0x17, 0xf3, - 0xc1, 0x4c, 0x81, 0x73, 0x97, 0xac, 0xad, 0x42, 0xfe, 0xca, 0x30, 0xb0, 0xa0, 0xc5, 0xa8, 0x92, - 0xf6, 0xce, 0x56, 0x28, 0x92, 0x77, 0x67, 0x53, 0xed, 0x92, 0x8c, 0x58, 0x50, 0x65, 0x18, 0x58, - 0xd0, 0x42, 0xaf, 0x40, 0x61, 0xab, 0x2e, 0xfc, 0xd4, 0x32, 0x25, 0xcf, 0x66, 0xb0, 0x94, 0xc5, - 0xa1, 0xfb, 0x07, 0xe5, 0xc2, 0xca, 0x12, 0x2e, 0x6c, 0xd5, 0xd1, 0x3a, 0x0c, 0x6f, 0xf1, 0xf0, - 0x0a, 0x42, 0xb8, 0xfc, 0x54, 0x76, 0xe4, 0x87, 0x54, 0x04, 0x06, 0xee, 0xf3, 0x24, 0x00, 0x58, - 0x12, 0x61, 0x19, 0x09, 0x54, 0x98, 0x08, 0x11, 0xa5, 0x6e, 0xfe, 0x68, 0xa1, 0x3d, 0x38, 0x93, - 0x19, 0x07, 0x9b, 0xc0, 0x1a, 0x45, 0xba, 0xaa, 0x9d, 0xb7, 0x3b, 0x01, 0x0b, 0x05, 0x2e, 0xc2, - 0x19, 0x65, 0xae, 0xea, 0x05, 0x89, 0xd4, 0x6d, 0x55, 0x2b, 0x24, 0x1c, 0x13, 0x45, 0xbb, 0x30, - 0xbe, 0x17, 0xb6, 0x77, 0x88, 0xdc, 0xd2, 0x2c, 0xba, 0x51, 0x0e, 0x7f, 0x74, 0x5b, 0x20, 0xba, - 0x41, 0xd4, 0x71, 0x9a, 0xa9, 0x53, 0x88, 0xf1, 0xb2, 0xb7, 0x75, 0x62, 0xd8, 0xa4, 0x4d, 0x87, - 0xff, 0xad, 0x8e, 0xbf, 0xb9, 0x1f, 0x11, 0x11, 0x5c, 0x2e, 0x73, 0xf8, 0xdf, 0xe0, 0x28, 0xe9, - 0xe1, 0x17, 0x00, 0x2c, 0x89, 0xa0, 0xdb, 0x62, 0x78, 0xd8, 0xe9, 0x39, 0x95, 0x1f, 0x01, 0x76, - 0x41, 0x22, 0xe5, 0x0c, 0x0a, 0x3b, 0x2d, 0x63, 0x52, 0xec, 0x94, 0x6c, 0xef, 0xf8, 0x91, 0xef, - 0x25, 0x4e, 0xe8, 0xe9, 0xfc, 0x53, 0xb2, 0x9a, 0x81, 0x9f, 0x3e, 0x25, 0xb3, 0xb0, 0x70, 0x66, - 0x5b, 0xa8, 0x01, 0x13, 0x6d, 0x3f, 0x88, 0xee, 0xfa, 0x81, 0x5c, 0x5f, 0xa8, 0x8b, 0x70, 0xcc, - 0xc0, 0x14, 0x2d, 0xb2, 0xb8, 0x8d, 0x26, 0x04, 0x27, 0x68, 0xa2, 0x8f, 0xc3, 0x70, 0x58, 0x77, - 0x9a, 0x64, 0xf5, 0xe6, 0xec, 0x4c, 0xfe, 0xf5, 0x53, 0xe3, 0x28, 0x39, 0xab, 0x8b, 0x47, 0xc7, - 0xe0, 0x28, 0x58, 0x92, 0x43, 0x2b, 0x30, 0xc8, 0x32, 0xce, 0xb1, 0x48, 0x88, 0x39, 0x81, 0x6c, - 0x53, 0x56, 0xf0, 0xfc, 0x6c, 0x62, 0xc5, 0x98, 0x57, 0xa7, 0x7b, 0x40, 0xbc, 0x11, 0xfd, 0x70, - 0xf6, 0x74, 0xfe, 0x1e, 0x10, 0x4f, 0xcb, 0x9b, 0xb5, 0x6e, 0x7b, 0x40, 0x21, 0xe1, 0x98, 0x28, - 0x3d, 0x99, 0xe9, 0x69, 0x7a, 0xa6, 0x8b, 0xf9, 0x56, 0xee, 0x59, 0xca, 0x4e, 0x66, 0x7a, 0x92, - 0x52, 0x12, 0xf6, 0xef, 0x0d, 0xa7, 0x79, 0x16, 0x26, 0x55, 0xf8, 0x3e, 0x2b, 0xa5, 0x70, 0xfe, - 0x50, 0xbf, 0x42, 0xce, 0x63, 0x7c, 0x0a, 0x7d, 0xde, 0x82, 0x33, 0xed, 0xcc, 0x0f, 0x11, 0x0c, - 0x40, 0x7f, 0xb2, 0x52, 0xfe, 0xe9, 0x2a, 0x6a, 0x66, 0x36, 0x1c, 0xe7, 0xb4, 0x94, 0x7c, 0x6e, - 0x16, 0xdf, 0xf1, 0x73, 0x73, 0x0d, 0x46, 0xea, 0xfc, 0x29, 0xd2, 0x35, 0x59, 0x77, 0xf2, 0xed, - 0xcd, 0x58, 0x09, 0xf1, 0x86, 0xd9, 0xc2, 0x8a, 0x04, 0xfa, 0x51, 0x0b, 0xce, 0x25, 0xbb, 0x8e, - 0x09, 0x03, 0x8b, 0x50, 0x9b, 0x5c, 0xa0, 0xb1, 0x22, 0xbe, 0x3f, 0xc5, 0xff, 0x1b, 0xc8, 0x87, - 0xbd, 0x10, 0x70, 0xf7, 0xc6, 0x50, 0x25, 0x43, 0xa2, 0x32, 0x64, 0x6a, 0x91, 0xfa, 0x90, 0xaa, - 0xbc, 0x08, 0x63, 0x2d, 0xbf, 0xe3, 0x45, 0xc2, 0xda, 0x4b, 0x58, 0x9e, 0x30, 0x8b, 0x8b, 0x35, - 0xad, 0x1c, 0x1b, 0x58, 0x09, 0x59, 0xcc, 0xc8, 0x03, 0xcb, 0x62, 0xde, 0x84, 0x31, 0x4f, 0x33, - 0x4f, 0x16, 0xfc, 0xc0, 0xc5, 0xfc, 0x30, 0xb9, 0xba, 0x31, 0x33, 0xef, 0xa5, 0x5e, 0x82, 0x0d, - 0x6a, 0x27, 0x6b, 0x06, 0xf6, 0x65, 0x2b, 0x83, 0xa9, 0xe7, 0xa2, 0x98, 0x8f, 0x98, 0xa2, 0x98, - 0x8b, 0x49, 0x51, 0x4c, 0x4a, 0x83, 0x60, 0x48, 0x61, 0xfa, 0xcf, 0x02, 0xd4, 0x6f, 0xa8, 0x4d, - 0xbb, 0x09, 0x17, 0x7a, 0x5d, 0x4b, 0xcc, 0xec, 0xaf, 0xa1, 0xf4, 0xc5, 0xb1, 0xd9, 0x5f, 0x63, - 0xb5, 0x82, 0x19, 0xa4, 0xdf, 0x20, 0x4e, 0xf6, 0x7f, 0xb2, 0xa0, 0x58, 0xf5, 0x1b, 0x27, 0xf0, - 0xe0, 0xfd, 0xa8, 0xf1, 0xe0, 0x7d, 0x34, 0xfb, 0x42, 0x6c, 0xe4, 0xea, 0x3f, 0x96, 0x13, 0xfa, - 0x8f, 0x73, 0x79, 0x04, 0xba, 0x6b, 0x3b, 0x7e, 0xba, 0x08, 0xa3, 0x55, 0xbf, 0xa1, 0x6c, 0xee, - 0xff, 0xc9, 0x83, 0xd8, 0xdc, 0xe7, 0xe6, 0xb2, 0xd0, 0x28, 0x33, 0x6b, 0x41, 0xe9, 0x6e, 0xfc, - 0x2d, 0x66, 0x7a, 0x7f, 0x87, 0xb8, 0xdb, 0x3b, 0x11, 0x69, 0x24, 0x3f, 0xe7, 0xe4, 0x4c, 0xef, - 0x7f, 0xaf, 0x00, 0x93, 0x89, 0xd6, 0x51, 0x13, 0xc6, 0x9b, 0xba, 0x74, 0x5d, 0xac, 0xd3, 0x07, - 0x12, 0xcc, 0x0b, 0xd3, 0x65, 0xad, 0x08, 0x9b, 0xc4, 0xd1, 0x3c, 0x80, 0x52, 0x37, 0x4b, 0xf1, - 0x2a, 0xe3, 0xfa, 0x95, 0x3e, 0x3a, 0xc4, 0x1a, 0x06, 0x7a, 0x09, 0x46, 0x23, 0xbf, 0xed, 0x37, - 0xfd, 0xed, 0xfd, 0xeb, 0x44, 0xc6, 0xf7, 0x52, 0x06, 0x89, 0x1b, 0x31, 0x08, 0xeb, 0x78, 0xe8, - 0x1e, 0x4c, 0x2b, 0x22, 0xb5, 0x63, 0xd0, 0x38, 0x30, 0xa9, 0xc2, 0x7a, 0x92, 0x22, 0x4e, 0x37, - 0x62, 0xff, 0x6c, 0x91, 0x0f, 0xb1, 0x17, 0xb9, 0xef, 0xed, 0x86, 0x77, 0xf7, 0x6e, 0xf8, 0xba, - 0x05, 0x53, 0xb4, 0x75, 0x66, 0x6d, 0x25, 0xaf, 0x79, 0x15, 0x98, 0xdb, 0xea, 0x12, 0x98, 0xfb, - 0x22, 0x3d, 0x35, 0x1b, 0x7e, 0x27, 0x12, 0xb2, 0x3b, 0xed, 0x58, 0xa4, 0xa5, 0x58, 0x40, 0x05, - 0x1e, 0x09, 0x02, 0xe1, 0x21, 0xaa, 0xe3, 0x91, 0x20, 0xc0, 0x02, 0x2a, 0xe3, 0x76, 0x0f, 0x64, - 0xc7, 0xed, 0xe6, 0xe1, 0x57, 0x85, 0x5d, 0x8e, 0x60, 0xb8, 0xb4, 0xf0, 0xab, 0xd2, 0x60, 0x27, - 0xc6, 0xb1, 0xbf, 0x5a, 0x84, 0xb1, 0xaa, 0xdf, 0x88, 0x55, 0xcd, 0x2f, 0x1a, 0xaa, 0xe6, 0x0b, - 0x09, 0x55, 0xf3, 0x94, 0x8e, 0xfb, 0x9e, 0x62, 0xf9, 0x9b, 0xa5, 0x58, 0xfe, 0x87, 0x16, 0x9b, - 0xb5, 0xca, 0x7a, 0x8d, 0x1b, 0xef, 0xa1, 0x2b, 0x30, 0xca, 0x0e, 0x18, 0xe6, 0x92, 0x2c, 0xf5, - 0xaf, 0x2c, 0x1f, 0xd5, 0x7a, 0x5c, 0x8c, 0x75, 0x1c, 0x74, 0x09, 0x46, 0x42, 0xe2, 0x04, 0xf5, - 0x1d, 0x75, 0xba, 0x0a, 0x65, 0x29, 0x2f, 0xc3, 0x0a, 0x8a, 0xde, 0x88, 0x23, 0x7f, 0x16, 0xf3, - 0x5d, 0x1c, 0xf5, 0xfe, 0xf0, 0x2d, 0x92, 0x1f, 0xee, 0xd3, 0xbe, 0x03, 0x28, 0x8d, 0xdf, 0x47, - 0x6c, 0xba, 0xb2, 0x19, 0x9b, 0xae, 0x94, 0x8a, 0x4b, 0xf7, 0x67, 0x16, 0x4c, 0x54, 0xfd, 0x06, - 0xdd, 0xba, 0xdf, 0x4e, 0xfb, 0x54, 0x0f, 0x7b, 0x3c, 0xd4, 0x25, 0xec, 0xf1, 0x13, 0x30, 0x58, - 0xf5, 0x1b, 0xab, 0xd5, 0x6e, 0xf1, 0x05, 0xec, 0xbf, 0x66, 0xc1, 0x70, 0xd5, 0x6f, 0x9c, 0x80, - 0x5a, 0xe0, 0x23, 0xa6, 0x5a, 0xe0, 0x91, 0x9c, 0x75, 0x93, 0xa3, 0x09, 0xf8, 0x2b, 0x03, 0x30, - 0x4e, 0xfb, 0xe9, 0x6f, 0xcb, 0xa9, 0x34, 0x86, 0xcd, 0xea, 0x63, 0xd8, 0x28, 0x17, 0xee, 0x37, - 0x9b, 0xfe, 0xdd, 0xe4, 0xb4, 0xae, 0xb0, 0x52, 0x2c, 0xa0, 0xe8, 0x59, 0x18, 0x69, 0x07, 0x64, - 0xcf, 0xf5, 0x05, 0x7b, 0xab, 0x29, 0x59, 0xaa, 0xa2, 0x1c, 0x2b, 0x0c, 0xfa, 0x2c, 0x0c, 0x5d, - 0x8f, 0x5e, 0xe5, 0x75, 0xdf, 0x6b, 0x70, 0xc9, 0x79, 0x51, 0xe4, 0xe6, 0xd0, 0xca, 0xb1, 0x81, - 0x85, 0xee, 0x40, 0x89, 0xfd, 0x67, 0xc7, 0xce, 0xd1, 0xb3, 0xbc, 0x8a, 0xac, 0x7f, 0x82, 0x00, - 0x8e, 0x69, 0xa1, 0xe7, 0x01, 0x22, 0x19, 0xdf, 0x3e, 0x14, 0xd1, 0xd6, 0xd4, 0x53, 0x40, 0x45, - 0xbe, 0x0f, 0xb1, 0x86, 0x85, 0x9e, 0x81, 0x52, 0xe4, 0xb8, 0xcd, 0x1b, 0xae, 0x47, 0x42, 0x26, - 0x11, 0x2f, 0xca, 0xe4, 0x7b, 0xa2, 0x10, 0xc7, 0x70, 0xca, 0x8a, 0xb1, 0x48, 0x1c, 0x3c, 0x47, - 0xf4, 0x08, 0xc3, 0x66, 0xac, 0xd8, 0x0d, 0x55, 0x8a, 0x35, 0x0c, 0xb4, 0x03, 0x8f, 0xb9, 0x1e, - 0xcb, 0x63, 0x41, 0x6a, 0xbb, 0x6e, 0x7b, 0xe3, 0x46, 0xed, 0x36, 0x09, 0xdc, 0xad, 0xfd, 0x45, - 0xa7, 0xbe, 0x4b, 0x3c, 0x99, 0xbf, 0xf3, 0x49, 0xd1, 0xc5, 0xc7, 0x56, 0xbb, 0xe0, 0xe2, 0xae, - 0x94, 0xec, 0x17, 0xd8, 0x7a, 0xbf, 0x59, 0x43, 0x1f, 0x30, 0x8e, 0x8e, 0x33, 0xfa, 0xd1, 0x71, - 0x78, 0x50, 0x1e, 0xba, 0x59, 0xd3, 0x02, 0x49, 0xbc, 0x0c, 0xa7, 0xab, 0x7e, 0xa3, 0xea, 0x07, - 0xd1, 0x8a, 0x1f, 0xdc, 0x75, 0x82, 0x86, 0x5c, 0x5e, 0x65, 0x19, 0x4a, 0x83, 0x9e, 0x9f, 0x83, - 0xfc, 0x74, 0x31, 0xc2, 0x64, 0xbc, 0xc0, 0x38, 0xb6, 0x23, 0x3a, 0x80, 0xd5, 0x19, 0xef, 0xa0, - 0x32, 0xc1, 0x5c, 0x75, 0x22, 0x82, 0x6e, 0xb2, 0x0c, 0xd7, 0xf1, 0x35, 0x2a, 0xaa, 0x3f, 0xad, - 0x65, 0xb8, 0x8e, 0x81, 0x99, 0xf7, 0xae, 0x59, 0xdf, 0xfe, 0xcf, 0x83, 0xec, 0x44, 0x4d, 0x64, - 0x13, 0x41, 0x9f, 0x86, 0x89, 0x90, 0xdc, 0x70, 0xbd, 0xce, 0x3d, 0x29, 0xc2, 0xe8, 0xe2, 0xc2, - 0x57, 0x5b, 0xd6, 0x31, 0xb9, 0x20, 0xd4, 0x2c, 0xc3, 0x09, 0x6a, 0xa8, 0x05, 0x13, 0x77, 0x5d, - 0xaf, 0xe1, 0xdf, 0x0d, 0x25, 0xfd, 0x91, 0x7c, 0x79, 0xe8, 0x1d, 0x8e, 0x99, 0xe8, 0xa3, 0xd1, - 0xdc, 0x1d, 0x83, 0x18, 0x4e, 0x10, 0xa7, 0xab, 0x36, 0xe8, 0x78, 0x0b, 0xe1, 0xad, 0x90, 0x04, - 0x22, 0x57, 0x39, 0x5b, 0xb5, 0x58, 0x16, 0xe2, 0x18, 0x4e, 0x57, 0x2d, 0xfb, 0x73, 0x35, 0xf0, - 0x3b, 0x3c, 0x75, 0x85, 0x58, 0xb5, 0x58, 0x95, 0x62, 0x0d, 0x83, 0xee, 0x6a, 0xf6, 0x6f, 0xdd, - 0xf7, 0xb0, 0xef, 0x47, 0xf2, 0x1c, 0x60, 0x3a, 0x7d, 0xad, 0x1c, 0x1b, 0x58, 0x68, 0x05, 0x50, - 0xd8, 0x69, 0xb7, 0x9b, 0xcc, 0x36, 0xc8, 0x69, 0x32, 0x52, 0xdc, 0x5e, 0xa2, 0xc8, 0x43, 0xef, - 0xd6, 0x52, 0x50, 0x9c, 0x51, 0x83, 0x1e, 0xf0, 0x5b, 0xa2, 0xab, 0x83, 0xac, 0xab, 0x5c, 0x77, - 0x52, 0xe3, 0xfd, 0x94, 0x30, 0xb4, 0x0c, 0xc3, 0xe1, 0x7e, 0x58, 0x8f, 0x44, 0xa4, 0xc4, 0x9c, - 0x84, 0x51, 0x35, 0x86, 0xa2, 0xe5, 0x2b, 0xe4, 0x55, 0xb0, 0xac, 0x8b, 0xea, 0x30, 0x23, 0x28, - 0x2e, 0xed, 0x38, 0x9e, 0x4a, 0xbf, 0xc3, 0x4d, 0xa4, 0xaf, 0xdc, 0x3f, 0x28, 0xcf, 0x88, 0x96, - 0x75, 0xf0, 0xe1, 0x41, 0xf9, 0x4c, 0xd5, 0x6f, 0x64, 0x40, 0x70, 0x16, 0x35, 0xbe, 0xf8, 0xea, - 0x75, 0xbf, 0xd5, 0xae, 0x06, 0xfe, 0x96, 0xdb, 0x24, 0xdd, 0xf4, 0x4f, 0x35, 0x03, 0x53, 0x2c, - 0x3e, 0xa3, 0x0c, 0x27, 0xa8, 0xd9, 0xdf, 0xcd, 0x98, 0x20, 0x96, 0x9e, 0x3b, 0xea, 0x04, 0x04, - 0xb5, 0x60, 0xbc, 0xcd, 0xb6, 0x89, 0x48, 0x28, 0x21, 0xd6, 0xfa, 0x8b, 0x7d, 0xca, 0x51, 0xee, - 0xd2, 0xbb, 0xc3, 0xb4, 0x31, 0xaa, 0xea, 0xe4, 0xb0, 0x49, 0xdd, 0xfe, 0xb3, 0x47, 0xd8, 0x35, - 0x5a, 0xe3, 0xc2, 0x91, 0x61, 0xe1, 0x91, 0x21, 0xde, 0x63, 0x73, 0xf9, 0x52, 0xba, 0x78, 0x5a, - 0x84, 0x57, 0x07, 0x96, 0x75, 0xd1, 0xa7, 0x60, 0x82, 0x3e, 0x6f, 0xd4, 0x55, 0x16, 0xce, 0x9e, - 0xca, 0x8f, 0x9c, 0xa1, 0xb0, 0xf4, 0x64, 0x33, 0x7a, 0x65, 0x9c, 0x20, 0x86, 0xde, 0x60, 0x36, - 0x3d, 0x92, 0x74, 0xa1, 0x1f, 0xd2, 0xba, 0xf9, 0x8e, 0x24, 0xab, 0x11, 0x41, 0x1d, 0x98, 0x49, - 0xa7, 0xa6, 0x0b, 0x67, 0xed, 0x7c, 0x3e, 0x31, 0x9d, 0x5d, 0x2e, 0xce, 0x0a, 0x92, 0x86, 0x85, - 0x38, 0x8b, 0x3e, 0xba, 0x01, 0xe3, 0x22, 0x47, 0xb5, 0x58, 0xb9, 0x45, 0x43, 0x78, 0x38, 0x8e, - 0x75, 0xe0, 0x61, 0xb2, 0x00, 0x9b, 0x95, 0xd1, 0x36, 0x9c, 0xd3, 0x72, 0x46, 0x5d, 0x0d, 0x1c, - 0x66, 0x01, 0xe0, 0xb2, 0xe3, 0x54, 0xbb, 0xe0, 0x1f, 0xbf, 0x7f, 0x50, 0x3e, 0xb7, 0xd1, 0x0d, - 0x11, 0x77, 0xa7, 0x83, 0x6e, 0xc2, 0x69, 0xee, 0xf7, 0x5d, 0x21, 0x4e, 0xa3, 0xe9, 0x7a, 0x8a, - 0x83, 0xe0, 0x5b, 0xfe, 0xec, 0xfd, 0x83, 0xf2, 0xe9, 0x85, 0x2c, 0x04, 0x9c, 0x5d, 0x0f, 0x7d, - 0x04, 0x4a, 0x0d, 0x2f, 0x14, 0x63, 0x30, 0x64, 0xa4, 0xe5, 0x2a, 0x55, 0xd6, 0x6b, 0xea, 0xfb, - 0xe3, 0x3f, 0x38, 0xae, 0x80, 0xb6, 0xb9, 0x80, 0x59, 0x89, 0x3d, 0x86, 0x53, 0x71, 0xaf, 0x92, - 0x92, 0x41, 0xc3, 0xf3, 0x93, 0x6b, 0x56, 0x94, 0x43, 0x84, 0xe1, 0x14, 0x6a, 0x10, 0x46, 0xaf, - 0x03, 0x12, 0xe1, 0xdf, 0x17, 0xea, 0x2c, 0x5b, 0x09, 0x93, 0xc7, 0x8f, 0x98, 0xbe, 0x88, 0xb5, - 0x14, 0x06, 0xce, 0xa8, 0x85, 0xae, 0xd1, 0x53, 0x45, 0x2f, 0x15, 0xa7, 0x96, 0x4a, 0xa2, 0x58, - 0x21, 0xed, 0x80, 0x30, 0x8b, 0x26, 0x93, 0x22, 0x4e, 0xd4, 0x43, 0x0d, 0x78, 0xcc, 0xe9, 0x44, - 0x3e, 0x93, 0xdd, 0x9b, 0xa8, 0x1b, 0xfe, 0x2e, 0xf1, 0x98, 0xda, 0x6c, 0x64, 0xf1, 0x02, 0x65, - 0x51, 0x16, 0xba, 0xe0, 0xe1, 0xae, 0x54, 0x28, 0x6b, 0xa9, 0xb2, 0x26, 0x83, 0x19, 0xcd, 0x2b, - 0x23, 0x73, 0xf2, 0x4b, 0x30, 0xba, 0xe3, 0x87, 0xd1, 0x3a, 0x89, 0xee, 0xfa, 0xc1, 0xae, 0x88, - 0x4a, 0x1b, 0xc7, 0xf8, 0x8e, 0x41, 0x58, 0xc7, 0xa3, 0x6f, 0x47, 0x66, 0xd4, 0xb1, 0x5a, 0x61, - 0xfa, 0xf4, 0x91, 0xf8, 0x8c, 0xb9, 0xc6, 0x8b, 0xb1, 0x84, 0x4b, 0xd4, 0xd5, 0xea, 0x12, 0xd3, - 0x8d, 0x27, 0x50, 0x57, 0xab, 0x4b, 0x58, 0xc2, 0xe9, 0x72, 0x0d, 0x77, 0x9c, 0x80, 0x54, 0x03, - 0xbf, 0x4e, 0x42, 0x2d, 0xb2, 0xfc, 0xa3, 0x3c, 0xe6, 0x2e, 0x5d, 0xae, 0xb5, 0x2c, 0x04, 0x9c, - 0x5d, 0x0f, 0x91, 0x74, 0xbe, 0xb4, 0x89, 0x7c, 0xa5, 0x46, 0x9a, 0x9f, 0xe9, 0x33, 0x65, 0x9a, - 0x07, 0x53, 0x2a, 0x53, 0x1b, 0x8f, 0xb2, 0x1b, 0xce, 0x4e, 0xb2, 0xb5, 0xdd, 0x7f, 0x88, 0x5e, - 0xa5, 0x26, 0x5a, 0x4d, 0x50, 0xc2, 0x29, 0xda, 0x46, 0xc0, 0xb6, 0xa9, 0x9e, 0x01, 0xdb, 0x2e, - 0x43, 0x29, 0xec, 0x6c, 0x36, 0xfc, 0x96, 0xe3, 0x7a, 0x4c, 0x37, 0xae, 0x3d, 0x62, 0x6a, 0x12, - 0x80, 0x63, 0x1c, 0xb4, 0x02, 0x23, 0x8e, 0xd4, 0x01, 0xa1, 0xfc, 0x10, 0x3d, 0x4a, 0xf3, 0xc3, - 0xa3, 0x56, 0x48, 0xad, 0x8f, 0xaa, 0x8b, 0x5e, 0x85, 0x71, 0xe1, 0xb7, 0x2c, 0x92, 0x84, 0xce, - 0x98, 0xce, 0x65, 0x35, 0x1d, 0x88, 0x4d, 0x5c, 0x74, 0x0b, 0x46, 0x23, 0xbf, 0xc9, 0x3c, 0xa4, - 0x28, 0x9b, 0x77, 0x26, 0x3f, 0xd8, 0xdc, 0x86, 0x42, 0xd3, 0xc5, 0xaf, 0xaa, 0x2a, 0xd6, 0xe9, - 0xa0, 0x0d, 0xbe, 0xde, 0x59, 0x1c, 0x79, 0x12, 0xce, 0x3e, 0x92, 0x7f, 0x27, 0xa9, 0x70, 0xf3, - 0xe6, 0x76, 0x10, 0x35, 0xb1, 0x4e, 0x06, 0x5d, 0x85, 0xe9, 0x76, 0xe0, 0xfa, 0x6c, 0x4d, 0x28, - 0xf5, 0xdf, 0xac, 0x99, 0x35, 0xaa, 0x9a, 0x44, 0xc0, 0xe9, 0x3a, 0xcc, 0xed, 0x5c, 0x14, 0xce, - 0x9e, 0xe5, 0x99, 0x2f, 0xf8, 0x9b, 0x90, 0x97, 0x61, 0x05, 0x45, 0x6b, 0xec, 0x24, 0xe6, 0xe2, - 0x8c, 0xd9, 0xb9, 0xfc, 0xa8, 0x40, 0xba, 0xd8, 0x83, 0x33, 0xaf, 0xea, 0x2f, 0x8e, 0x29, 0xa0, - 0x86, 0x96, 0x70, 0x92, 0xbe, 0x18, 0xc2, 0xd9, 0xc7, 0xba, 0x58, 0xd6, 0x25, 0x9e, 0x17, 0x31, - 0x43, 0x60, 0x14, 0x87, 0x38, 0x41, 0x13, 0x7d, 0x0c, 0xa6, 0x44, 0x2c, 0xc3, 0x78, 0x98, 0xce, - 0xc5, 0x76, 0xe7, 0x38, 0x01, 0xc3, 0x29, 0x6c, 0x9e, 0x79, 0xc2, 0xd9, 0x6c, 0x12, 0x71, 0xf4, - 0xdd, 0x70, 0xbd, 0xdd, 0x70, 0xf6, 0x3c, 0x3b, 0x1f, 0x44, 0xe6, 0x89, 0x24, 0x14, 0x67, 0xd4, - 0x40, 0x1b, 0x30, 0xd5, 0x0e, 0x08, 0x69, 0x31, 0x46, 0x5f, 0xdc, 0x67, 0x65, 0x1e, 0x75, 0x81, - 0xf6, 0xa4, 0x9a, 0x80, 0x1d, 0x66, 0x94, 0xe1, 0x14, 0x05, 0x74, 0x17, 0x46, 0xfc, 0x3d, 0x12, - 0xec, 0x10, 0xa7, 0x31, 0x7b, 0xa1, 0x8b, 0x1f, 0x84, 0xb8, 0xdc, 0x6e, 0x0a, 0xdc, 0x84, 0xc9, - 0x80, 0x2c, 0xee, 0x6d, 0x32, 0x20, 0x1b, 0x43, 0xff, 0xaf, 0x05, 0x67, 0xa5, 0x96, 0xa1, 0xd6, - 0xa6, 0xa3, 0xbe, 0xe4, 0x7b, 0x61, 0x14, 0xf0, 0x38, 0x01, 0x8f, 0xe7, 0xfb, 0xce, 0x6f, 0xe4, - 0x54, 0x52, 0x12, 0xd5, 0xb3, 0x79, 0x18, 0x21, 0xce, 0x6f, 0x11, 0x2d, 0xc1, 0x74, 0x48, 0x22, - 0x79, 0x18, 0x2d, 0x84, 0x2b, 0x6f, 0x54, 0xd6, 0x67, 0x9f, 0xe0, 0x41, 0x0e, 0xe8, 0x66, 0xa8, - 0x25, 0x81, 0x38, 0x8d, 0x8f, 0xae, 0x40, 0xc1, 0x0f, 0x67, 0x9f, 0xec, 0x92, 0xa3, 0x94, 0x3e, - 0xc5, 0xb9, 0xe9, 0xd8, 0xcd, 0x1a, 0x2e, 0xf8, 0xa1, 0xcc, 0xfe, 0x40, 0xdf, 0x63, 0xe1, 0xec, - 0xfb, 0xb9, 0xfc, 0x4d, 0x66, 0x7f, 0x60, 0x85, 0x38, 0x86, 0xcf, 0x7d, 0x27, 0x4c, 0xa7, 0xd8, - 0x8b, 0xa3, 0x24, 0x02, 0x9a, 0xdb, 0x85, 0x71, 0x63, 0x0a, 0x1f, 0xaa, 0x4a, 0xfb, 0x9f, 0x0f, - 0x43, 0x49, 0xa9, 0x3b, 0xd1, 0x65, 0x53, 0x8b, 0x7d, 0x36, 0xa9, 0xc5, 0x1e, 0xa9, 0xfa, 0x0d, - 0x43, 0x71, 0xbd, 0x91, 0x11, 0x3a, 0x2e, 0xef, 0xc0, 0xe8, 0xdf, 0x9a, 0x5e, 0x93, 0x21, 0x17, - 0xfb, 0x56, 0x87, 0x0f, 0x74, 0x15, 0x4b, 0x5f, 0x85, 0x69, 0xcf, 0x67, 0x3c, 0x2d, 0x69, 0x48, - 0x86, 0x85, 0xf1, 0x25, 0x25, 0x3d, 0x16, 0x4b, 0x02, 0x01, 0xa7, 0xeb, 0xd0, 0x06, 0x39, 0x63, - 0x91, 0x94, 0x83, 0x73, 0xbe, 0x03, 0x0b, 0x28, 0x7a, 0x02, 0x06, 0xdb, 0x7e, 0x63, 0xb5, 0x2a, - 0xf8, 0x59, 0x2d, 0x60, 0x69, 0x63, 0xb5, 0x8a, 0x39, 0x0c, 0x2d, 0xc0, 0x10, 0xfb, 0x11, 0xce, - 0x8e, 0xe5, 0x07, 0xdd, 0x60, 0x35, 0xb4, 0x34, 0x4b, 0xac, 0x02, 0x16, 0x15, 0x99, 0x3c, 0x8e, - 0x3e, 0x02, 0x98, 0x3c, 0x6e, 0xf8, 0x01, 0xe5, 0x71, 0x92, 0x00, 0x8e, 0x69, 0xa1, 0x7b, 0x70, - 0xda, 0x78, 0x78, 0xf1, 0x25, 0x42, 0x42, 0xe1, 0xf8, 0xff, 0x44, 0xd7, 0x17, 0x97, 0x50, 0x9f, - 0x9f, 0x13, 0x9d, 0x3e, 0xbd, 0x9a, 0x45, 0x09, 0x67, 0x37, 0x80, 0x9a, 0x30, 0x5d, 0x4f, 0xb5, - 0x3a, 0xd2, 0x7f, 0xab, 0x6a, 0x42, 0xd3, 0x2d, 0xa6, 0x09, 0xa3, 0x57, 0x61, 0xe4, 0x2d, 0x3f, - 0x64, 0x77, 0x81, 0xe0, 0xc1, 0xa5, 0xd7, 0xf8, 0xc8, 0x1b, 0x37, 0x6b, 0xac, 0xfc, 0xf0, 0xa0, - 0x3c, 0x5a, 0xf5, 0x1b, 0xf2, 0x2f, 0x56, 0x15, 0xd0, 0x0f, 0x5a, 0x30, 0x97, 0x7e, 0xd9, 0xa9, - 0x4e, 0x8f, 0xf7, 0xdf, 0x69, 0x5b, 0x34, 0x3a, 0xb7, 0x9c, 0x4b, 0x0e, 0x77, 0x69, 0xca, 0xfe, - 0x65, 0x8b, 0x49, 0xf5, 0x84, 0x5a, 0x8a, 0x84, 0x9d, 0xe6, 0x49, 0x64, 0x97, 0x5d, 0x36, 0x34, - 0x66, 0x0f, 0x6c, 0x4e, 0xf1, 0x8f, 0x2d, 0x66, 0x4e, 0x71, 0x82, 0x7e, 0x13, 0x6f, 0xc0, 0x48, - 0x24, 0xb3, 0xfe, 0x76, 0x49, 0x88, 0xab, 0x75, 0x8a, 0x99, 0x94, 0x28, 0x8e, 0x58, 0x25, 0xf8, - 0x55, 0x64, 0xec, 0xbf, 0xc7, 0x67, 0x40, 0x42, 0x4e, 0x40, 0x31, 0x51, 0x31, 0x15, 0x13, 0xe5, - 0x1e, 0x5f, 0x90, 0xa3, 0xa0, 0xf8, 0xbb, 0x66, 0xbf, 0x99, 0x24, 0xe8, 0xdd, 0x6e, 0xc7, 0x63, - 0x7f, 0xc1, 0x02, 0x88, 0xe3, 0x41, 0xf7, 0x91, 0xd7, 0xed, 0x65, 0xca, 0x03, 0xfb, 0x91, 0x5f, - 0xf7, 0x9b, 0x42, 0xed, 0xf6, 0x58, 0xac, 0x1b, 0xe1, 0xe5, 0x87, 0xda, 0x6f, 0xac, 0xb0, 0x51, - 0x59, 0x46, 0x9f, 0x2b, 0xc6, 0xda, 0x3a, 0x23, 0xf2, 0xdc, 0x97, 0x2c, 0x38, 0x95, 0x65, 0x84, - 0x4b, 0x5f, 0x54, 0x5c, 0x26, 0xa6, 0x6c, 0xac, 0xd4, 0x6c, 0xde, 0x16, 0xe5, 0x58, 0x61, 0xf4, - 0x9d, 0x30, 0xef, 0x68, 0x81, 0x98, 0x6f, 0xc2, 0x78, 0x35, 0x20, 0xda, 0xe5, 0xfa, 0x1a, 0x8f, - 0x68, 0xc0, 0xfb, 0xf3, 0xec, 0x91, 0xa3, 0x19, 0xd8, 0x5f, 0x29, 0xc0, 0x29, 0x6e, 0xaa, 0xb0, - 0xb0, 0xe7, 0xbb, 0x8d, 0xaa, 0xdf, 0x10, 0xae, 0x56, 0x9f, 0x84, 0xb1, 0xb6, 0x26, 0xc8, 0xec, - 0x16, 0x54, 0x54, 0x17, 0x78, 0xc6, 0xa2, 0x17, 0xbd, 0x14, 0x1b, 0xb4, 0x50, 0x03, 0xc6, 0xc8, - 0x9e, 0x5b, 0x57, 0xfa, 0xee, 0xc2, 0x91, 0x2f, 0x3a, 0xd5, 0xca, 0xb2, 0x46, 0x07, 0x1b, 0x54, - 0x1f, 0x42, 0x1a, 0x6b, 0xfb, 0xc7, 0x2d, 0x78, 0x24, 0x27, 0x04, 0x29, 0x6d, 0xee, 0x2e, 0x33, - 0x0a, 0x11, 0xcb, 0x56, 0x35, 0xc7, 0x4d, 0x45, 0xb0, 0x80, 0xa2, 0x8f, 0x03, 0x70, 0x53, 0x0f, - 0xfa, 0xa4, 0xef, 0x15, 0xab, 0xd1, 0x08, 0x33, 0xa7, 0x45, 0x0c, 0x93, 0xf5, 0xb1, 0x46, 0xcb, - 0xfe, 0xd2, 0x00, 0x0c, 0xf2, 0x94, 0xfb, 0x55, 0x18, 0xde, 0xe1, 0x49, 0x65, 0xba, 0xce, 0x1b, - 0xc5, 0x95, 0x79, 0x6a, 0xe2, 0x79, 0xd3, 0x4a, 0xb1, 0x24, 0x83, 0xd6, 0x60, 0x86, 0xe7, 0xf6, - 0x69, 0x56, 0x48, 0xd3, 0xd9, 0x97, 0x32, 0x42, 0x9e, 0x88, 0x56, 0xc9, 0x4a, 0x57, 0xd3, 0x28, - 0x38, 0xab, 0x1e, 0x7a, 0x0d, 0x26, 0xe8, 0x9b, 0xcd, 0xef, 0x44, 0x92, 0x12, 0xcf, 0xea, 0xa3, - 0x1e, 0x89, 0x1b, 0x06, 0x14, 0x27, 0xb0, 0xd1, 0xab, 0x30, 0xde, 0x4e, 0x49, 0x43, 0x07, 0x63, - 0xb1, 0x81, 0x29, 0x01, 0x35, 0x71, 0x99, 0x1d, 0x6e, 0x87, 0x59, 0x1d, 0x6f, 0xec, 0x04, 0x24, - 0xdc, 0xf1, 0x9b, 0x0d, 0xc6, 0xfe, 0x0d, 0x6a, 0x76, 0xb8, 0x09, 0x38, 0x4e, 0xd5, 0xa0, 0x54, - 0xb6, 0x1c, 0xb7, 0xd9, 0x09, 0x48, 0x4c, 0x65, 0xc8, 0xa4, 0xb2, 0x92, 0x80, 0xe3, 0x54, 0x8d, - 0xde, 0x62, 0xde, 0xe1, 0xe3, 0x11, 0xf3, 0xda, 0x7f, 0xbd, 0x00, 0xc6, 0xd4, 0x7e, 0xfb, 0x66, - 0x1b, 0xa2, 0x5f, 0xb6, 0x1d, 0xb4, 0xeb, 0xc2, 0x8c, 0x26, 0xf3, 0xcb, 0xe2, 0x24, 0xa2, 0xfc, - 0xcb, 0xe8, 0x7f, 0xcc, 0x6a, 0xd1, 0x3d, 0x7e, 0xba, 0x1a, 0xf8, 0xf4, 0x92, 0x93, 0x31, 0xaf, - 0x94, 0xb9, 0xfb, 0xb0, 0x74, 0x05, 0xee, 0x12, 0x1d, 0x52, 0x18, 0x04, 0x73, 0x0a, 0x86, 0xc5, - 0x49, 0x4d, 0x38, 0xe6, 0x4b, 0x2a, 0xe8, 0x0a, 0x8c, 0x8a, 0x14, 0x32, 0xcc, 0x2a, 0x9b, 0x6f, - 0x26, 0x66, 0x21, 0x53, 0x89, 0x8b, 0xb1, 0x8e, 0x63, 0xff, 0x50, 0x01, 0x66, 0x32, 0xdc, 0x6a, - 0xf8, 0x35, 0xb2, 0xed, 0x86, 0x91, 0xca, 0x53, 0xaa, 0x5d, 0x23, 0xbc, 0x1c, 0x2b, 0x0c, 0x7a, - 0x56, 0xf1, 0x8b, 0x2a, 0x79, 0x39, 0x09, 0xb3, 0x75, 0x01, 0x3d, 0x62, 0xc6, 0xcf, 0x0b, 0x30, - 0xd0, 0x09, 0x89, 0x8c, 0xeb, 0xaa, 0xae, 0x6d, 0xa6, 0x03, 0x65, 0x10, 0xfa, 0x8c, 0xda, 0x56, - 0xea, 0x44, 0xed, 0x19, 0xc5, 0x15, 0x8a, 0x1c, 0x46, 0x3b, 0x17, 0x11, 0xcf, 0xf1, 0x22, 0xf1, - 0xd8, 0x8a, 0x03, 0x14, 0xb2, 0x52, 0x2c, 0xa0, 0xf6, 0x17, 0x8b, 0x70, 0x36, 0xd7, 0xd1, 0x8e, - 0x76, 0xbd, 0xe5, 0x7b, 0x6e, 0xe4, 0x2b, 0xd3, 0x23, 0x1e, 0x94, 0x90, 0xb4, 0x77, 0xd6, 0x44, - 0x39, 0x56, 0x18, 0xe8, 0x22, 0x0c, 0x32, 0x09, 0x6a, 0x2a, 0x63, 0xeb, 0x62, 0x85, 0x47, 0xa9, - 0xe2, 0xe0, 0xbe, 0x93, 0x6c, 0x3f, 0x41, 0x39, 0x18, 0xbf, 0x99, 0xbc, 0x50, 0x68, 0x77, 0x7d, - 0xbf, 0x89, 0x19, 0x10, 0xbd, 0x5f, 0x8c, 0x57, 0xc2, 0xd6, 0x06, 0x3b, 0x0d, 0x3f, 0xd4, 0x06, - 0xed, 0x69, 0x18, 0xde, 0x25, 0xfb, 0x81, 0xeb, 0x6d, 0x27, 0x6d, 0xb0, 0xae, 0xf3, 0x62, 0x2c, - 0xe1, 0x66, 0x8a, 0xc1, 0xe1, 0xe3, 0xce, 0x8e, 0x3d, 0xd2, 0x93, 0x3d, 0xf9, 0x91, 0x22, 0x4c, - 0xe2, 0xc5, 0xca, 0x7b, 0x13, 0x71, 0x2b, 0x3d, 0x11, 0xc7, 0x9d, 0x1d, 0xbb, 0xf7, 0x6c, 0xfc, - 0x82, 0x05, 0x93, 0x2c, 0x91, 0x8d, 0x70, 0xa7, 0x77, 0x7d, 0xef, 0x04, 0x9e, 0x02, 0x4f, 0xc0, - 0x60, 0x40, 0x1b, 0x4d, 0xa6, 0x6a, 0x65, 0x3d, 0xc1, 0x1c, 0x86, 0x1e, 0x83, 0x01, 0xd6, 0x05, - 0x3a, 0x79, 0x63, 0xfc, 0x08, 0xae, 0x38, 0x91, 0x83, 0x59, 0x29, 0x8b, 0xd1, 0x84, 0x49, 0xbb, - 0xe9, 0xf2, 0x4e, 0xc7, 0xfa, 0xed, 0x77, 0x87, 0x0b, 0x7e, 0x66, 0xd7, 0xde, 0x59, 0x8c, 0xa6, - 0x6c, 0x92, 0xdd, 0x9f, 0xd9, 0x7f, 0x54, 0x80, 0xf3, 0x99, 0xf5, 0xfa, 0x8e, 0xd1, 0xd4, 0xbd, - 0xf6, 0xc3, 0x4c, 0x55, 0x52, 0x3c, 0x41, 0x0b, 0xd7, 0x81, 0x7e, 0xb9, 0xff, 0xc1, 0x3e, 0x42, - 0x27, 0x65, 0x0e, 0xd9, 0xbb, 0x24, 0x74, 0x52, 0x66, 0xdf, 0x72, 0xc4, 0x04, 0x7f, 0x5e, 0xc8, - 0xf9, 0x16, 0x26, 0x30, 0xb8, 0x44, 0xcf, 0x19, 0x06, 0x0c, 0xe5, 0x23, 0x9c, 0x9f, 0x31, 0xbc, - 0x0c, 0x2b, 0x28, 0x5a, 0x80, 0xc9, 0x96, 0xeb, 0xd1, 0xc3, 0x67, 0xdf, 0x64, 0xc5, 0x55, 0x64, - 0xbb, 0x35, 0x13, 0x8c, 0x93, 0xf8, 0xc8, 0xd5, 0xc2, 0x2a, 0xf1, 0xaf, 0x7b, 0xf5, 0x48, 0xbb, - 0x6e, 0xde, 0xd4, 0xfd, 0xab, 0x51, 0xcc, 0x08, 0xb1, 0xb4, 0xa6, 0xc9, 0x89, 0x8a, 0xfd, 0xcb, - 0x89, 0xc6, 0xb2, 0x65, 0x44, 0x73, 0xaf, 0xc2, 0xf8, 0x03, 0x2b, 0x06, 0xec, 0xaf, 0x17, 0xe1, - 0xd1, 0x2e, 0xdb, 0x9e, 0x9f, 0xf5, 0xc6, 0x1c, 0x68, 0x67, 0x7d, 0x6a, 0x1e, 0xaa, 0x70, 0x6a, - 0xab, 0xd3, 0x6c, 0xee, 0x33, 0xc7, 0x0f, 0xd2, 0x90, 0x18, 0x82, 0xa7, 0x94, 0xc2, 0x91, 0x53, - 0x2b, 0x19, 0x38, 0x38, 0xb3, 0x26, 0x7d, 0x62, 0xd1, 0x9b, 0x64, 0x5f, 0x91, 0x4a, 0x3c, 0xb1, - 0xb0, 0x0e, 0xc4, 0x26, 0x2e, 0xba, 0x0a, 0xd3, 0xce, 0x9e, 0xe3, 0xf2, 0xd8, 0xd4, 0x92, 0x00, - 0x7f, 0x63, 0x29, 0x79, 0xee, 0x42, 0x12, 0x01, 0xa7, 0xeb, 0xa0, 0xd7, 0x01, 0xf9, 0x9b, 0xcc, - 0x3c, 0xbc, 0x71, 0x95, 0x78, 0x42, 0x45, 0xcb, 0xe6, 0xae, 0x18, 0x1f, 0x09, 0x37, 0x53, 0x18, - 0x38, 0xa3, 0x56, 0x22, 0x7c, 0xd0, 0x50, 0x7e, 0xf8, 0xa0, 0xee, 0xe7, 0x62, 0xcf, 0x2c, 0x39, - 0xff, 0xce, 0xa2, 0xd7, 0x17, 0x67, 0xf2, 0xcd, 0x68, 0x9b, 0xaf, 0x32, 0x13, 0x4b, 0x2e, 0xeb, - 0xd5, 0x82, 0xad, 0x9c, 0xd6, 0x4c, 0x2c, 0x63, 0x20, 0x36, 0x71, 0xf9, 0x82, 0x08, 0x63, 0x1f, - 0x5f, 0x83, 0xc5, 0x17, 0x21, 0xc1, 0x14, 0x06, 0xfa, 0x04, 0x0c, 0x37, 0xdc, 0x3d, 0x37, 0x14, - 0x92, 0xae, 0x23, 0xab, 0x95, 0xe2, 0x73, 0xb0, 0xc2, 0xc9, 0x60, 0x49, 0xcf, 0xfe, 0x91, 0x02, - 0x8c, 0xcb, 0x16, 0xdf, 0xe8, 0xf8, 0x91, 0x73, 0x02, 0xd7, 0xf2, 0x55, 0xe3, 0x5a, 0x7e, 0x7f, - 0xb7, 0xb8, 0x68, 0xac, 0x4b, 0xb9, 0xd7, 0xf1, 0xcd, 0xc4, 0x75, 0xfc, 0x54, 0x6f, 0x52, 0xdd, - 0xaf, 0xe1, 0xbf, 0x6f, 0xc1, 0xb4, 0x81, 0x7f, 0x02, 0xb7, 0xc1, 0x8a, 0x79, 0x1b, 0x3c, 0xde, - 0xf3, 0x1b, 0x72, 0x6e, 0x81, 0xef, 0x2f, 0x26, 0xfa, 0xce, 0x4e, 0xff, 0xb7, 0x60, 0x60, 0xc7, - 0x09, 0x1a, 0xdd, 0xf2, 0x40, 0xa4, 0x2a, 0xcd, 0x5f, 0x73, 0x02, 0xa1, 0xa3, 0x7e, 0x56, 0x8e, - 0x3a, 0x2d, 0xea, 0xa9, 0x9f, 0x66, 0x4d, 0xa1, 0x97, 0x61, 0x28, 0xac, 0xfb, 0x6d, 0xe5, 0xf6, - 0x71, 0x81, 0x0d, 0x34, 0x2b, 0x39, 0x3c, 0x28, 0x23, 0xb3, 0x39, 0x5a, 0x8c, 0x05, 0x3e, 0xfa, - 0x24, 0x8c, 0xb3, 0x5f, 0xca, 0x60, 0xac, 0x98, 0x2f, 0x8e, 0xa8, 0xe9, 0x88, 0xdc, 0x9a, 0xd2, - 0x28, 0xc2, 0x26, 0xa9, 0xb9, 0x6d, 0x28, 0xa9, 0xcf, 0x7a, 0xa8, 0x7a, 0xdb, 0x7f, 0x53, 0x84, - 0x99, 0x8c, 0x35, 0x87, 0x42, 0x63, 0x26, 0xae, 0xf4, 0xb9, 0x54, 0xdf, 0xe1, 0x5c, 0x84, 0xec, - 0x35, 0xd4, 0x10, 0x6b, 0xab, 0xef, 0x46, 0x6f, 0x85, 0x24, 0xd9, 0x28, 0x2d, 0xea, 0xdd, 0x28, - 0x6d, 0xec, 0xc4, 0x86, 0x9a, 0x36, 0xa4, 0x7a, 0xfa, 0x50, 0xe7, 0xf4, 0x4f, 0x8b, 0x70, 0x2a, - 0x2b, 0x54, 0x23, 0xfa, 0x5c, 0x22, 0x0b, 0xe9, 0x8b, 0xfd, 0x06, 0x79, 0xe4, 0xa9, 0x49, 0x45, - 0xf4, 0xb8, 0x79, 0x33, 0x2f, 0x69, 0xcf, 0x61, 0x16, 0x6d, 0xb2, 0xf8, 0x15, 0x01, 0xcf, 0x1e, - 0x2b, 0x8f, 0x8f, 0x0f, 0xf5, 0xdd, 0x01, 0x91, 0x76, 0x36, 0x4c, 0x18, 0xa3, 0xc8, 0xe2, 0xde, - 0xc6, 0x28, 0xb2, 0xe5, 0x39, 0x17, 0x46, 0xb5, 0xaf, 0x79, 0xa8, 0x33, 0xbe, 0x4b, 0x6f, 0x2b, - 0xad, 0xdf, 0x0f, 0x75, 0xd6, 0x7f, 0xdc, 0x82, 0x84, 0x7f, 0x82, 0x12, 0x8b, 0x59, 0xb9, 0x62, - 0xb1, 0x0b, 0x30, 0x10, 0xf8, 0x4d, 0x92, 0x4c, 0xd7, 0x89, 0xfd, 0x26, 0xc1, 0x0c, 0x42, 0x31, - 0xa2, 0x58, 0xd8, 0x31, 0xa6, 0x3f, 0xe4, 0xc4, 0x13, 0xed, 0x09, 0x18, 0x6c, 0x92, 0x3d, 0xd2, - 0x4c, 0x66, 0x55, 0xba, 0x41, 0x0b, 0x31, 0x87, 0xd9, 0xbf, 0x30, 0x00, 0xe7, 0xba, 0x46, 0x80, - 0xa1, 0xcf, 0xa1, 0x6d, 0x27, 0x22, 0x77, 0x9d, 0xfd, 0x64, 0xfa, 0x93, 0xab, 0xbc, 0x18, 0x4b, - 0x38, 0x73, 0x3b, 0xe3, 0x51, 0xcc, 0x13, 0x42, 0x44, 0x11, 0xbc, 0x5c, 0x40, 0x4d, 0xa1, 0x54, - 0xf1, 0x38, 0x84, 0x52, 0xcf, 0x03, 0x84, 0x61, 0x93, 0x5b, 0x71, 0x35, 0x84, 0x3f, 0x5b, 0x1c, - 0xed, 0xbe, 0x76, 0x43, 0x40, 0xb0, 0x86, 0x85, 0x2a, 0x30, 0xd5, 0x0e, 0xfc, 0x88, 0xcb, 0x64, - 0x2b, 0xdc, 0xd0, 0x71, 0xd0, 0x0c, 0xbe, 0x51, 0x4d, 0xc0, 0x71, 0xaa, 0x06, 0x7a, 0x09, 0x46, - 0x45, 0x40, 0x8e, 0xaa, 0xef, 0x37, 0x85, 0x18, 0x48, 0xd9, 0xfe, 0xd5, 0x62, 0x10, 0xd6, 0xf1, - 0xb4, 0x6a, 0x4c, 0xd0, 0x3b, 0x9c, 0x59, 0x8d, 0x0b, 0x7b, 0x35, 0xbc, 0x44, 0xd8, 0xd6, 0x91, - 0xbe, 0xc2, 0xb6, 0xc6, 0x82, 0xb1, 0x52, 0xdf, 0x7a, 0x47, 0xe8, 0x29, 0x4a, 0xfa, 0xb9, 0x01, - 0x98, 0x11, 0x0b, 0xe7, 0x61, 0x2f, 0x97, 0x5b, 0xe9, 0xe5, 0x72, 0x1c, 0xa2, 0xb3, 0xf7, 0xd6, - 0xcc, 0x49, 0xaf, 0x99, 0x1f, 0xb5, 0xc0, 0x64, 0xaf, 0xd0, 0xff, 0x95, 0x9b, 0x3f, 0xea, 0xa5, - 0x5c, 0x76, 0x4d, 0x85, 0x00, 0x7d, 0x87, 0x99, 0xa4, 0xec, 0x7f, 0x6b, 0xc1, 0xe3, 0x3d, 0x29, - 0xa2, 0x65, 0x28, 0x31, 0x1e, 0x50, 0x7b, 0x9d, 0x3d, 0xa5, 0x0c, 0xa1, 0x25, 0x20, 0x87, 0x25, - 0x8d, 0x6b, 0xa2, 0xe5, 0x54, 0xa2, 0xae, 0xa7, 0x33, 0x12, 0x75, 0x9d, 0x36, 0x86, 0xe7, 0x01, - 0x33, 0x75, 0xfd, 0x30, 0xbd, 0x71, 0x0c, 0x27, 0x24, 0xf4, 0x21, 0x43, 0xec, 0x67, 0x27, 0xc4, - 0x7e, 0xc8, 0xc4, 0xd6, 0xee, 0x90, 0x8f, 0xc1, 0x14, 0x8b, 0xd4, 0xc5, 0xcc, 0xf2, 0x85, 0x7b, - 0x54, 0x21, 0x36, 0xbd, 0xbd, 0x91, 0x80, 0xe1, 0x14, 0xb6, 0xfd, 0x87, 0x45, 0x18, 0xe2, 0xdb, - 0xef, 0x04, 0xde, 0x84, 0xcf, 0x40, 0xc9, 0x6d, 0xb5, 0x3a, 0x3c, 0xf7, 0xd2, 0x60, 0x6c, 0xc8, - 0xb9, 0x2a, 0x0b, 0x71, 0x0c, 0x47, 0x2b, 0x42, 0xe2, 0xdc, 0x25, 0x18, 0x28, 0xef, 0xf8, 0x7c, - 0xc5, 0x89, 0x1c, 0xce, 0xe0, 0xa8, 0x7b, 0x36, 0x96, 0x4d, 0xa3, 0x4f, 0x03, 0x84, 0x51, 0xe0, - 0x7a, 0xdb, 0xb4, 0x4c, 0xc4, 0x20, 0xfe, 0x40, 0x17, 0x6a, 0x35, 0x85, 0xcc, 0x69, 0xc6, 0x67, - 0x8e, 0x02, 0x60, 0x8d, 0x22, 0x9a, 0x37, 0x6e, 0xfa, 0xb9, 0xc4, 0xdc, 0x01, 0xa7, 0x1a, 0xcf, - 0xd9, 0xdc, 0x87, 0xa1, 0xa4, 0x88, 0xf7, 0x92, 0x3f, 0x8d, 0xe9, 0x6c, 0xd1, 0x47, 0x61, 0x32, - 0xd1, 0xb7, 0x23, 0x89, 0xaf, 0x7e, 0xd1, 0x82, 0x49, 0xde, 0x99, 0x65, 0x6f, 0x4f, 0xdc, 0x06, - 0x6f, 0xc3, 0xa9, 0x66, 0xc6, 0xa9, 0x2c, 0xa6, 0xbf, 0xff, 0x53, 0x5c, 0x89, 0xab, 0xb2, 0xa0, - 0x38, 0xb3, 0x0d, 0x74, 0x89, 0xee, 0x38, 0x7a, 0xea, 0x3a, 0x4d, 0xe1, 0x57, 0x3d, 0xc6, 0x77, - 0x1b, 0x2f, 0xc3, 0x0a, 0x6a, 0xff, 0x8e, 0x05, 0xd3, 0xbc, 0xe7, 0xd7, 0xc9, 0xbe, 0x3a, 0x9b, - 0xbe, 0x99, 0x7d, 0x17, 0x59, 0xff, 0x0a, 0x39, 0x59, 0xff, 0xf4, 0x4f, 0x2b, 0x76, 0xfd, 0xb4, - 0xaf, 0x58, 0x20, 0x56, 0xc8, 0x09, 0x08, 0x21, 0xbe, 0xd3, 0x14, 0x42, 0xcc, 0xe5, 0x6f, 0x82, - 0x1c, 0xe9, 0xc3, 0x9f, 0x59, 0x30, 0xc5, 0x11, 0x62, 0x6d, 0xf9, 0x37, 0x75, 0x1e, 0xfa, 0xc9, - 0x0d, 0x7e, 0x9d, 0xec, 0x6f, 0xf8, 0x55, 0x27, 0xda, 0xc9, 0xfe, 0x28, 0x63, 0xb2, 0x06, 0xba, - 0x4e, 0x56, 0x43, 0x6e, 0x20, 0x23, 0x29, 0x4e, 0x8f, 0x60, 0x13, 0x47, 0x4d, 0x8a, 0x63, 0x7f, - 0xc3, 0x02, 0xc4, 0x9b, 0x31, 0x18, 0x37, 0xca, 0x0e, 0xb1, 0x52, 0xed, 0xa2, 0x8b, 0x8f, 0x26, - 0x05, 0xc1, 0x1a, 0xd6, 0xb1, 0x0c, 0x4f, 0xc2, 0xe4, 0xa1, 0xd8, 0xdb, 0xe4, 0xe1, 0x08, 0x23, - 0xfa, 0x2f, 0x86, 0x20, 0xe9, 0x88, 0x85, 0x6e, 0xc3, 0x58, 0xdd, 0x69, 0x3b, 0x9b, 0x6e, 0xd3, - 0x8d, 0x5c, 0x12, 0x76, 0xb3, 0x87, 0x5a, 0xd2, 0xf0, 0x84, 0x92, 0x5a, 0x2b, 0xc1, 0x06, 0x1d, - 0x34, 0x0f, 0xd0, 0x0e, 0xdc, 0x3d, 0xb7, 0x49, 0xb6, 0x99, 0xac, 0x84, 0x45, 0x72, 0xe0, 0xc6, - 0x59, 0xb2, 0x14, 0x6b, 0x18, 0x19, 0x5e, 0xef, 0xc5, 0x87, 0xec, 0xf5, 0x0e, 0x27, 0xe6, 0xf5, - 0x3e, 0x70, 0x24, 0xaf, 0xf7, 0x91, 0x23, 0x7b, 0xbd, 0x0f, 0xf6, 0xe5, 0xf5, 0x8e, 0xe1, 0x8c, - 0xe4, 0x3d, 0xe9, 0xff, 0x15, 0xb7, 0x49, 0xc4, 0x83, 0x83, 0x87, 0x9f, 0x98, 0xbb, 0x7f, 0x50, - 0x3e, 0x83, 0x33, 0x31, 0x70, 0x4e, 0x4d, 0xf4, 0x71, 0x98, 0x75, 0x9a, 0x4d, 0xff, 0xae, 0x9a, - 0xd4, 0xe5, 0xb0, 0xee, 0x34, 0xb9, 0x12, 0x62, 0x98, 0x51, 0x7d, 0xec, 0xfe, 0x41, 0x79, 0x76, - 0x21, 0x07, 0x07, 0xe7, 0xd6, 0x46, 0x1f, 0x81, 0x52, 0x3b, 0xf0, 0xeb, 0x6b, 0x9a, 0xb7, 0xe8, - 0x79, 0x3a, 0x80, 0x55, 0x59, 0x78, 0x78, 0x50, 0x1e, 0x57, 0x7f, 0xd8, 0x85, 0x1f, 0x57, 0xc8, - 0x70, 0x63, 0x1f, 0x3d, 0x56, 0x37, 0xf6, 0x5d, 0x98, 0xa9, 0x91, 0xc0, 0x75, 0x9a, 0xee, 0xdb, - 0x94, 0x5f, 0x96, 0xe7, 0xd3, 0x06, 0x94, 0x82, 0xc4, 0x89, 0xdc, 0x57, 0x80, 0x4e, 0x2d, 0x3b, - 0x89, 0x3c, 0x81, 0x63, 0x42, 0xf6, 0xff, 0xb0, 0x60, 0x58, 0x38, 0x5e, 0x9d, 0x00, 0xd7, 0xb8, - 0x60, 0x68, 0x12, 0xca, 0xd9, 0x03, 0xc6, 0x3a, 0x93, 0xab, 0x43, 0x58, 0x4d, 0xe8, 0x10, 0x1e, - 0xef, 0x46, 0xa4, 0xbb, 0xf6, 0xe0, 0x2f, 0x17, 0x29, 0xf7, 0x6e, 0xb8, 0x00, 0x3f, 0xfc, 0x21, - 0x58, 0x87, 0xe1, 0x50, 0xb8, 0xa0, 0x16, 0xf2, 0x7d, 0x1a, 0x92, 0x93, 0x18, 0xdb, 0xb1, 0x09, - 0xa7, 0x53, 0x49, 0x24, 0xd3, 0xb7, 0xb5, 0xf8, 0x10, 0x7d, 0x5b, 0x7b, 0x39, 0x49, 0x0f, 0x1c, - 0x87, 0x93, 0xb4, 0xfd, 0x35, 0x76, 0x73, 0xea, 0xe5, 0x27, 0xc0, 0x54, 0x5d, 0x35, 0xef, 0x58, - 0xbb, 0xcb, 0xca, 0x12, 0x9d, 0xca, 0x61, 0xae, 0x7e, 0xde, 0x82, 0x73, 0x19, 0x5f, 0xa5, 0x71, - 0x5a, 0xcf, 0xc2, 0x88, 0xd3, 0x69, 0xb8, 0x6a, 0x2f, 0x6b, 0xfa, 0xc4, 0x05, 0x51, 0x8e, 0x15, - 0x06, 0x5a, 0x82, 0x69, 0x72, 0xaf, 0xed, 0x72, 0x55, 0xaa, 0x6e, 0xfe, 0x5b, 0xe4, 0xde, 0x7a, - 0xcb, 0x49, 0x20, 0x4e, 0xe3, 0xab, 0xc0, 0x34, 0xc5, 0xdc, 0xc0, 0x34, 0x7f, 0xcb, 0x82, 0x51, - 0xe5, 0x84, 0xf9, 0xd0, 0x47, 0xfb, 0x63, 0xe6, 0x68, 0x3f, 0xda, 0x65, 0xb4, 0x73, 0x86, 0xf9, - 0xb7, 0x0a, 0xaa, 0xbf, 0x55, 0x3f, 0x88, 0xfa, 0xe0, 0xe0, 0x1e, 0xdc, 0x75, 0xe1, 0x0a, 0x8c, - 0x3a, 0xed, 0xb6, 0x04, 0x48, 0x1b, 0x34, 0x16, 0x6e, 0x39, 0x2e, 0xc6, 0x3a, 0x8e, 0xf2, 0xa4, - 0x28, 0xe6, 0x7a, 0x52, 0x34, 0x00, 0x22, 0x27, 0xd8, 0x26, 0x11, 0x2d, 0x13, 0x26, 0xb3, 0xf9, - 0xe7, 0x4d, 0x27, 0x72, 0x9b, 0xf3, 0xae, 0x17, 0x85, 0x51, 0x30, 0xbf, 0xea, 0x45, 0x37, 0x03, - 0xfe, 0x84, 0xd4, 0x42, 0x3b, 0x29, 0x5a, 0x58, 0xa3, 0x2b, 0x03, 0x0e, 0xb0, 0x36, 0x06, 0x4d, - 0x63, 0x86, 0x75, 0x51, 0x8e, 0x15, 0x86, 0xfd, 0x61, 0x76, 0xfb, 0xb0, 0x31, 0x3d, 0x5a, 0x58, - 0xa3, 0xaf, 0x8c, 0xa9, 0xd9, 0x60, 0x9a, 0xcc, 0x8a, 0x1e, 0x3c, 0xa9, 0xfb, 0x61, 0x4f, 0x1b, - 0xd6, 0xfd, 0xfa, 0xe2, 0x08, 0x4b, 0xe8, 0xbb, 0x52, 0x06, 0x2a, 0xcf, 0xf5, 0xb8, 0x35, 0x8e, - 0x60, 0x92, 0xc2, 0x72, 0xaf, 0xb0, 0xcc, 0x14, 0xab, 0x55, 0xb1, 0x2f, 0xb4, 0xdc, 0x2b, 0x02, - 0x80, 0x63, 0x1c, 0xca, 0x4c, 0xa9, 0x3f, 0xe1, 0x2c, 0x8a, 0x63, 0x90, 0x2a, 0xec, 0x10, 0x6b, - 0x18, 0xe8, 0xb2, 0x10, 0x28, 0x70, 0xbd, 0xc0, 0xa3, 0x09, 0x81, 0x82, 0x1c, 0x2e, 0x4d, 0x0a, - 0x74, 0x05, 0x46, 0x55, 0xba, 0xed, 0x2a, 0xcf, 0x7a, 0x24, 0x96, 0xd9, 0x72, 0x5c, 0x8c, 0x75, - 0x1c, 0xb4, 0x01, 0x93, 0x21, 0x97, 0xb3, 0xa9, 0xc0, 0xd0, 0x5c, 0x5e, 0xf9, 0x01, 0x69, 0x05, - 0x54, 0x33, 0xc1, 0x87, 0xac, 0x88, 0x9f, 0x4e, 0x32, 0x28, 0x40, 0x92, 0x04, 0x7a, 0x0d, 0x26, - 0x9a, 0xbe, 0xd3, 0x58, 0x74, 0x9a, 0x8e, 0x57, 0x67, 0xe3, 0x33, 0x62, 0x66, 0x6d, 0xbd, 0x61, - 0x40, 0x71, 0x02, 0x9b, 0x32, 0x6f, 0x7a, 0x89, 0x08, 0x66, 0xee, 0x78, 0xdb, 0x24, 0x14, 0xc9, - 0x93, 0x19, 0xf3, 0x76, 0x23, 0x07, 0x07, 0xe7, 0xd6, 0x46, 0x2f, 0xc3, 0x98, 0xfc, 0x7c, 0x2d, - 0x86, 0x46, 0xec, 0x94, 0xa2, 0xc1, 0xb0, 0x81, 0x89, 0xee, 0xc2, 0x69, 0xf9, 0x7f, 0x23, 0x70, - 0xb6, 0xb6, 0xdc, 0xba, 0x70, 0x2c, 0xe7, 0xde, 0xab, 0x0b, 0xd2, 0xc5, 0x72, 0x39, 0x0b, 0xe9, - 0xf0, 0xa0, 0x7c, 0x41, 0x8c, 0x5a, 0x26, 0x9c, 0x4d, 0x62, 0x36, 0x7d, 0xb4, 0x06, 0x33, 0x3b, - 0xc4, 0x69, 0x46, 0x3b, 0x4b, 0x3b, 0xa4, 0xbe, 0x2b, 0x37, 0x1d, 0x8b, 0xcc, 0xa1, 0x39, 0x70, - 0x5c, 0x4b, 0xa3, 0xe0, 0xac, 0x7a, 0xe8, 0x4d, 0x98, 0x6d, 0x77, 0x36, 0x9b, 0x6e, 0xb8, 0xb3, - 0xee, 0x47, 0xcc, 0x14, 0x48, 0x65, 0xef, 0x16, 0x21, 0x3c, 0x54, 0xec, 0x93, 0x6a, 0x0e, 0x1e, - 0xce, 0xa5, 0x80, 0xde, 0x86, 0xd3, 0x89, 0xc5, 0x20, 0x82, 0x18, 0x4c, 0xe4, 0xa7, 0x86, 0xa8, - 0x65, 0x55, 0x10, 0xf1, 0x40, 0xb2, 0x40, 0x38, 0xbb, 0x09, 0xf4, 0x0a, 0x80, 0xdb, 0x5e, 0x71, - 0x5a, 0x6e, 0x93, 0x3e, 0x17, 0x67, 0xd8, 0x3a, 0xa1, 0x4f, 0x07, 0x58, 0xad, 0xca, 0x52, 0x7a, - 0x3e, 0x8b, 0x7f, 0xfb, 0x58, 0xc3, 0x46, 0x37, 0x60, 0x42, 0xfc, 0xdb, 0x17, 0xd3, 0xca, 0x63, - 0x69, 0x3c, 0xc9, 0x02, 0x21, 0x55, 0x75, 0xc8, 0x61, 0xaa, 0x04, 0x27, 0xea, 0xa2, 0x6d, 0x38, - 0x27, 0xd3, 0x7c, 0xe9, 0x6b, 0x54, 0xce, 0x41, 0xc8, 0xf2, 0x31, 0x8c, 0x70, 0xdf, 0x90, 0x85, - 0x6e, 0x88, 0xb8, 0x3b, 0x1d, 0x7a, 0xb7, 0xeb, 0x4b, 0x9d, 0x7b, 0xcf, 0x9e, 0xe6, 0xa6, 0x49, - 0xf4, 0x6e, 0xbf, 0x91, 0x04, 0xe2, 0x34, 0x3e, 0x0a, 0xe1, 0xb4, 0xeb, 0x65, 0xad, 0xec, 0x33, - 0x8c, 0xd0, 0x47, 0xb9, 0xe3, 0x70, 0xf7, 0x55, 0x9d, 0x09, 0xe7, 0xab, 0x3a, 0x93, 0xf6, 0x3b, - 0xb3, 0xc0, 0xfb, 0x6d, 0x8b, 0xd6, 0xd6, 0xb8, 0x74, 0xf4, 0x19, 0x18, 0xd3, 0x3f, 0x4c, 0x70, - 0x1c, 0x17, 0xb3, 0x99, 0x58, 0xed, 0x6c, 0xe0, 0x3c, 0xbe, 0xda, 0xff, 0x3a, 0x0c, 0x1b, 0x14, - 0x51, 0x3d, 0xc3, 0xc5, 0xfe, 0x72, 0x7f, 0x1c, 0x4d, 0xff, 0x06, 0x68, 0x04, 0xb2, 0x97, 0x3c, - 0xba, 0x01, 0x23, 0xf5, 0xa6, 0x4b, 0xbc, 0x68, 0xb5, 0xda, 0x2d, 0xe8, 0xde, 0x92, 0xc0, 0x11, - 0x7b, 0x48, 0xa4, 0x57, 0xe0, 0x65, 0x58, 0x51, 0xb0, 0x7f, 0xad, 0x00, 0xe5, 0x1e, 0xb9, 0x3a, - 0x12, 0xea, 0x28, 0xab, 0x2f, 0x75, 0xd4, 0x82, 0x4c, 0x4f, 0xbf, 0x9e, 0x90, 0x74, 0x25, 0x52, - 0xcf, 0xc7, 0xf2, 0xae, 0x24, 0x7e, 0xdf, 0xee, 0x01, 0xba, 0x46, 0x6b, 0xa0, 0xa7, 0x83, 0x8b, - 0xa1, 0xc9, 0x1e, 0xec, 0xff, 0xf9, 0x9b, 0xab, 0x95, 0xb4, 0xbf, 0x56, 0x80, 0xd3, 0x6a, 0x08, - 0xbf, 0x7d, 0x07, 0xee, 0x56, 0x7a, 0xe0, 0x8e, 0x41, 0xa7, 0x6b, 0xdf, 0x84, 0x21, 0x1e, 0x45, - 0xb0, 0x0f, 0xb6, 0xfb, 0x09, 0x33, 0x4a, 0xaf, 0xe2, 0xf4, 0x8c, 0x48, 0xbd, 0x3f, 0x68, 0xc1, - 0x64, 0xc2, 0xcf, 0x0c, 0x61, 0xcd, 0x19, 0xf9, 0x41, 0x58, 0xe3, 0x2c, 0xa6, 0xfb, 0x02, 0x0c, - 0xec, 0xf8, 0x61, 0x94, 0x34, 0xf8, 0xb8, 0xe6, 0x87, 0x11, 0x66, 0x10, 0xfb, 0x77, 0x2d, 0x18, - 0xdc, 0x70, 0x5c, 0x2f, 0x92, 0xca, 0x01, 0x2b, 0x47, 0x39, 0xd0, 0xcf, 0x77, 0xa1, 0x97, 0x60, - 0x88, 0x6c, 0x6d, 0x91, 0x7a, 0x24, 0x66, 0x55, 0x46, 0x72, 0x18, 0x5a, 0x66, 0xa5, 0x94, 0x0f, - 0x64, 0x8d, 0xf1, 0xbf, 0x58, 0x20, 0xa3, 0x3b, 0x50, 0x8a, 0xdc, 0x16, 0x59, 0x68, 0x34, 0x84, - 0xca, 0xfc, 0x01, 0xa2, 0x51, 0x6c, 0x48, 0x02, 0x38, 0xa6, 0x65, 0x7f, 0xb1, 0x00, 0x10, 0x87, - 0x5f, 0xea, 0xf5, 0x89, 0x8b, 0x29, 0x65, 0xea, 0xc5, 0x0c, 0x65, 0x2a, 0x8a, 0x09, 0x66, 0x68, - 0x52, 0xd5, 0x30, 0x15, 0xfb, 0x1a, 0xa6, 0x81, 0xa3, 0x0c, 0xd3, 0x12, 0x4c, 0xc7, 0xe1, 0xa3, - 0xcc, 0xe8, 0x79, 0xec, 0xfa, 0xdc, 0x48, 0x02, 0x71, 0x1a, 0xdf, 0x26, 0x70, 0x41, 0x45, 0xd1, - 0x11, 0x37, 0x1a, 0xb3, 0xc8, 0xd6, 0x95, 0xd3, 0x3d, 0xc6, 0x29, 0xd6, 0x16, 0x17, 0x72, 0xb5, - 0xc5, 0x3f, 0x65, 0xc1, 0xa9, 0x64, 0x3b, 0xcc, 0x7d, 0xf9, 0x0b, 0x16, 0x9c, 0x66, 0x3a, 0x73, - 0xd6, 0x6a, 0x5a, 0x43, 0xff, 0x62, 0xd7, 0xc8, 0x40, 0x39, 0x3d, 0x8e, 0x43, 0x86, 0xac, 0x65, - 0x91, 0xc6, 0xd9, 0x2d, 0xda, 0xff, 0x7d, 0x00, 0x66, 0xf3, 0x42, 0x0a, 0x31, 0x87, 0x0d, 0xe7, - 0x5e, 0x6d, 0x97, 0xdc, 0x15, 0x66, 0xf1, 0xb1, 0xc3, 0x06, 0x2f, 0xc6, 0x12, 0x9e, 0x4c, 0xbf, - 0x50, 0xe8, 0x33, 0xfd, 0xc2, 0x0e, 0x4c, 0xdf, 0xdd, 0x21, 0xde, 0x2d, 0x2f, 0x74, 0x22, 0x37, - 0xdc, 0x72, 0x99, 0x7e, 0x99, 0xaf, 0x1b, 0x99, 0xb3, 0x75, 0xfa, 0x4e, 0x12, 0xe1, 0xf0, 0xa0, - 0x7c, 0xce, 0x28, 0x88, 0xbb, 0xcc, 0x0f, 0x12, 0x9c, 0x26, 0x9a, 0xce, 0x5e, 0x31, 0xf0, 0x90, - 0xb3, 0x57, 0xb4, 0x5c, 0x61, 0x95, 0x22, 0xad, 0xf1, 0xd9, 0xcb, 0x71, 0x4d, 0x95, 0x62, 0x0d, - 0x03, 0x7d, 0x0a, 0x90, 0x9e, 0x9d, 0xc7, 0x88, 0xe8, 0xf8, 0xdc, 0xfd, 0x83, 0x32, 0x5a, 0x4f, - 0x41, 0x0f, 0x0f, 0xca, 0x33, 0xb4, 0x74, 0xd5, 0xa3, 0x2f, 0xd0, 0x38, 0x0c, 0x56, 0x06, 0x21, - 0x74, 0x07, 0xa6, 0x68, 0x29, 0xdb, 0x51, 0x32, 0x5c, 0x24, 0x7f, 0x35, 0x3e, 0x73, 0xff, 0xa0, - 0x3c, 0xb5, 0x9e, 0x80, 0xe5, 0x91, 0x4e, 0x11, 0x41, 0xaf, 0xc0, 0x44, 0xbc, 0xae, 0xae, 0x93, - 0x7d, 0x1e, 0x6e, 0xa6, 0xc4, 0x05, 0xdf, 0x6b, 0x06, 0x04, 0x27, 0x30, 0xed, 0x2f, 0x58, 0x70, - 0x36, 0x37, 0xc9, 0x33, 0xba, 0x04, 0x23, 0x4e, 0xdb, 0xe5, 0x6a, 0x0c, 0x71, 0xd5, 0x30, 0x71, - 0x59, 0x75, 0x95, 0x2b, 0x31, 0x14, 0x94, 0x9e, 0xf0, 0xbb, 0xae, 0xd7, 0x48, 0x9e, 0xf0, 0xd7, - 0x5d, 0xaf, 0x81, 0x19, 0x44, 0x5d, 0x59, 0xc5, 0xbc, 0x2b, 0xcb, 0xfe, 0x01, 0x0b, 0x84, 0x43, - 0x6e, 0x1f, 0xf7, 0xdb, 0x27, 0x61, 0x6c, 0x2f, 0x9d, 0x05, 0xec, 0x42, 0xbe, 0x87, 0xb2, 0xc8, - 0xfd, 0xa5, 0x98, 0x56, 0x23, 0xe3, 0x97, 0x41, 0xcb, 0x6e, 0x80, 0x80, 0x56, 0x08, 0x13, 0xd2, - 0xf7, 0xee, 0xcd, 0xf3, 0x00, 0x0d, 0x86, 0xcb, 0x52, 0x83, 0x16, 0x4c, 0xee, 0xa5, 0xa2, 0x20, - 0x58, 0xc3, 0xb2, 0xff, 0x55, 0x01, 0x46, 0x65, 0xd6, 0xa9, 0x8e, 0xd7, 0x8f, 0x28, 0xed, 0x48, - 0x69, 0x68, 0xd1, 0x65, 0x28, 0x31, 0x59, 0x6f, 0x35, 0x96, 0x40, 0x2a, 0x49, 0xcb, 0x9a, 0x04, - 0xe0, 0x18, 0x87, 0x9e, 0x34, 0x61, 0x67, 0x93, 0xa1, 0x27, 0xdc, 0x47, 0x6b, 0xbc, 0x18, 0x4b, - 0x38, 0xfa, 0x38, 0x4c, 0xf1, 0x7a, 0x81, 0xdf, 0x76, 0xb6, 0xb9, 0x7e, 0x68, 0x50, 0xc5, 0xe4, - 0x98, 0x5a, 0x4b, 0xc0, 0x0e, 0x0f, 0xca, 0xa7, 0x92, 0x65, 0x4c, 0xf1, 0x99, 0xa2, 0xc2, 0xcc, - 0xc0, 0x78, 0x23, 0xf4, 0x84, 0x4c, 0x59, 0x8f, 0xc5, 0x20, 0xac, 0xe3, 0xd9, 0x9f, 0x01, 0x94, - 0xce, 0xbf, 0x85, 0x5e, 0xe7, 0xb6, 0xbf, 0x6e, 0x40, 0x1a, 0xdd, 0x14, 0xa1, 0x7a, 0xe4, 0x09, - 0xe9, 0xf9, 0xc5, 0x6b, 0x61, 0x55, 0xdf, 0xfe, 0xff, 0x8a, 0x30, 0x95, 0xf4, 0x75, 0x47, 0xd7, - 0x60, 0x88, 0xb3, 0x67, 0x82, 0x7c, 0x17, 0x3b, 0x1b, 0xcd, 0x43, 0x9e, 0x5d, 0x54, 0x82, 0xc3, - 0x13, 0xf5, 0xd1, 0x9b, 0x30, 0xda, 0xf0, 0xef, 0x7a, 0x77, 0x9d, 0xa0, 0xb1, 0x50, 0x5d, 0x15, - 0xcb, 0x39, 0xf3, 0xe1, 0x5f, 0x89, 0xd1, 0x74, 0xaf, 0x7b, 0xa6, 0x53, 0x8e, 0x41, 0x58, 0x27, - 0x87, 0x36, 0x58, 0xd0, 0xfe, 0x2d, 0x77, 0x7b, 0xcd, 0x69, 0x77, 0x73, 0x04, 0x59, 0x92, 0x48, - 0x1a, 0xe5, 0x71, 0x11, 0xd9, 0x9f, 0x03, 0x70, 0x4c, 0x08, 0x7d, 0x0e, 0x66, 0xc2, 0x1c, 0x75, - 0x44, 0x5e, 0x3a, 0xc6, 0x6e, 0x12, 0xfa, 0xc5, 0x47, 0xee, 0x1f, 0x94, 0x67, 0xb2, 0x14, 0x17, - 0x59, 0xcd, 0xd8, 0x5f, 0x3a, 0x05, 0xc6, 0x26, 0x36, 0xb2, 0xf3, 0x5a, 0xc7, 0x94, 0x9d, 0x17, - 0xc3, 0x08, 0x69, 0xb5, 0xa3, 0xfd, 0x8a, 0x1b, 0x88, 0x39, 0xc9, 0xa4, 0xb9, 0x2c, 0x70, 0xd2, - 0x34, 0x25, 0x04, 0x2b, 0x3a, 0xd9, 0x29, 0x94, 0x8b, 0xdf, 0xc4, 0x14, 0xca, 0x03, 0x27, 0x98, - 0x42, 0x79, 0x1d, 0x86, 0xb7, 0xdd, 0x08, 0x93, 0xb6, 0x2f, 0x1e, 0x46, 0x99, 0xeb, 0xf0, 0x2a, - 0x47, 0x49, 0x27, 0xeb, 0x14, 0x00, 0x2c, 0x89, 0xa0, 0xd7, 0xd5, 0x0e, 0x1c, 0xca, 0x17, 0x5e, - 0xa4, 0x0d, 0x42, 0x32, 0xf7, 0xa0, 0x48, 0x94, 0x3c, 0xfc, 0xa0, 0x89, 0x92, 0x57, 0x64, 0x7a, - 0xe3, 0x91, 0x7c, 0xaf, 0x2d, 0x96, 0xbd, 0xb8, 0x47, 0x52, 0xe3, 0xdb, 0x7a, 0x4a, 0xe8, 0x52, - 0xfe, 0x49, 0xa0, 0xb2, 0x3d, 0xf7, 0x99, 0x08, 0xfa, 0x07, 0x2c, 0x38, 0xdd, 0xce, 0xca, 0x8e, - 0x2e, 0x6c, 0x27, 0x5e, 0xea, 0x3b, 0x01, 0xbb, 0xd1, 0x20, 0x93, 0x39, 0x66, 0xa7, 0xd8, 0xcf, - 0x6e, 0x8e, 0x0e, 0x74, 0xb0, 0xd9, 0x10, 0x3a, 0xfc, 0x27, 0x72, 0x32, 0x4a, 0x77, 0xc9, 0x23, - 0xbd, 0x91, 0x91, 0xbd, 0xf8, 0xc9, 0xbc, 0xec, 0xc5, 0x7d, 0xe7, 0x2c, 0x7e, 0x5d, 0xe5, 0x92, - 0x1e, 0xcf, 0x5f, 0x4a, 0x3c, 0x53, 0x74, 0xcf, 0x0c, 0xd2, 0xaf, 0xab, 0x0c, 0xd2, 0x5d, 0x82, - 0x2b, 0xf3, 0xfc, 0xd0, 0x3d, 0xf3, 0x46, 0x6b, 0xb9, 0x9f, 0x27, 0x8f, 0x27, 0xf7, 0xb3, 0x71, - 0xd5, 0xf0, 0xf4, 0xc3, 0xcf, 0xf4, 0xb8, 0x6a, 0x0c, 0xba, 0xdd, 0x2f, 0x1b, 0x9e, 0xe7, 0x7a, - 0xfa, 0x81, 0xf2, 0x5c, 0xdf, 0xd6, 0xf3, 0x46, 0xa3, 0x1e, 0x89, 0x91, 0x29, 0x52, 0x9f, 0xd9, - 0xa2, 0x6f, 0xeb, 0x17, 0xe0, 0x4c, 0x3e, 0x5d, 0x75, 0xcf, 0xa5, 0xe9, 0x66, 0x5e, 0x81, 0xa9, - 0x2c, 0xd4, 0xa7, 0x4e, 0x26, 0x0b, 0xf5, 0xe9, 0x63, 0xcf, 0x42, 0x7d, 0xe6, 0x04, 0xb2, 0x50, - 0x3f, 0x72, 0x82, 0x59, 0xa8, 0x6f, 0x33, 0x83, 0x23, 0x1e, 0xd6, 0x48, 0x04, 0x83, 0x7e, 0x3a, - 0x27, 0x2a, 0x58, 0x3a, 0xf6, 0x11, 0xff, 0x38, 0x05, 0xc2, 0x31, 0xa9, 0x8c, 0xec, 0xd6, 0xb3, - 0x0f, 0x21, 0xbb, 0xf5, 0x7a, 0x9c, 0xdd, 0xfa, 0x6c, 0xfe, 0x54, 0x67, 0xb8, 0xa8, 0xe4, 0xe4, - 0xb4, 0xbe, 0xad, 0xe7, 0xa2, 0x7e, 0xb4, 0x8b, 0x56, 0x29, 0x4b, 0x38, 0xdb, 0x25, 0x03, 0xf5, - 0x6b, 0x3c, 0x03, 0xf5, 0x63, 0xf9, 0x27, 0x79, 0xf2, 0xba, 0x33, 0xf2, 0x4e, 0xd3, 0x7e, 0xa9, - 0xb0, 0xa0, 0x2c, 0xec, 0x75, 0x4e, 0xbf, 0x54, 0x5c, 0xd1, 0x74, 0xbf, 0x14, 0x08, 0xc7, 0xa4, - 0xec, 0x1f, 0x2a, 0xc0, 0xf9, 0xee, 0xfb, 0x2d, 0x96, 0x38, 0x57, 0x63, 0x25, 0x7b, 0x42, 0xe2, - 0xcc, 0xdf, 0x6c, 0x31, 0x56, 0xdf, 0x51, 0x0e, 0xaf, 0xc2, 0xb4, 0xf2, 0x6d, 0xa1, 0x6f, 0xf4, - 0xf5, 0xf8, 0xe5, 0xab, 0xe2, 0x01, 0xd4, 0x92, 0x08, 0x38, 0x5d, 0x07, 0x2d, 0xc0, 0xa4, 0x51, - 0xb8, 0x5a, 0x11, 0x6f, 0x33, 0x25, 0xe2, 0xae, 0x99, 0x60, 0x9c, 0xc4, 0xb7, 0xbf, 0x6c, 0xc1, - 0x23, 0x39, 0xe9, 0x1b, 0xfb, 0x0e, 0xe2, 0xb7, 0x05, 0x93, 0x6d, 0xb3, 0x6a, 0x8f, 0xb8, 0xa3, - 0x46, 0x92, 0x48, 0xd5, 0xd7, 0x04, 0x00, 0x27, 0x89, 0xda, 0x3f, 0x53, 0x80, 0x73, 0x5d, 0x8d, - 0x35, 0x11, 0x86, 0x33, 0xdb, 0xad, 0xd0, 0x59, 0x0a, 0x48, 0x83, 0x78, 0x91, 0xeb, 0x34, 0x6b, - 0x6d, 0x52, 0xd7, 0x74, 0x06, 0xcc, 0xea, 0xf1, 0xea, 0x5a, 0x6d, 0x21, 0x8d, 0x81, 0x73, 0x6a, - 0xa2, 0x15, 0x40, 0x69, 0x88, 0x98, 0x61, 0x16, 0x40, 0x3d, 0x4d, 0x0f, 0x67, 0xd4, 0x40, 0x1f, - 0x86, 0x71, 0x65, 0x04, 0xaa, 0xcd, 0x38, 0x3b, 0xd8, 0xb1, 0x0e, 0xc0, 0x26, 0x1e, 0xba, 0xc2, - 0x23, 0xf0, 0x8b, 0x5c, 0x0d, 0x42, 0xc1, 0x30, 0x29, 0xc3, 0xeb, 0x8b, 0x62, 0xac, 0xe3, 0x2c, - 0xbe, 0xfc, 0xeb, 0xbf, 0x7f, 0xfe, 0x7d, 0xbf, 0xf9, 0xfb, 0xe7, 0xdf, 0xf7, 0x3b, 0xbf, 0x7f, - 0xfe, 0x7d, 0xdf, 0x73, 0xff, 0xbc, 0xf5, 0xeb, 0xf7, 0xcf, 0x5b, 0xbf, 0x79, 0xff, 0xbc, 0xf5, - 0x3b, 0xf7, 0xcf, 0x5b, 0xbf, 0x77, 0xff, 0xbc, 0xf5, 0xc5, 0x3f, 0x38, 0xff, 0xbe, 0x4f, 0xa2, - 0x38, 0x2c, 0xe6, 0x65, 0x3a, 0x3b, 0x97, 0xf7, 0xae, 0xfc, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, - 0x04, 0xa7, 0x88, 0x7f, 0x92, 0x09, 0x01, 0x00, + // 14408 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x6b, 0x70, 0x5c, 0xd7, + 0x79, 0x98, 0xef, 0x2e, 0x5e, 0xfb, 0xe1, 0x7d, 0x40, 0x52, 0x20, 0x24, 0x12, 0xd4, 0x95, 0x44, + 0x51, 0x96, 0x04, 0x98, 0x7a, 0xd8, 0x8a, 0x64, 0x2b, 0x06, 0xb0, 0x00, 0x09, 0x91, 0x00, 0x57, + 0x67, 0x41, 0xd2, 0x76, 0x64, 0x8f, 0x2f, 0x76, 0x0f, 0x80, 0x6b, 0xec, 0xde, 0xbb, 0xba, 0xf7, + 0x2e, 0x48, 0xb0, 0xce, 0x34, 0x75, 0x9e, 0x4e, 0xd2, 0x8e, 0xa7, 0x93, 0x3e, 0xc6, 0xc9, 0x64, + 0x3a, 0x69, 0xda, 0xc4, 0x75, 0xdb, 0x69, 0xea, 0x34, 0x49, 0xe3, 0xb4, 0x49, 0xdf, 0x69, 0x7f, + 0xa4, 0x69, 0x66, 0x1a, 0x67, 0x26, 0x53, 0x34, 0x61, 0x3a, 0xcd, 0x78, 0xa6, 0x4d, 0xd2, 0xa6, + 0x9d, 0x69, 0xd1, 0xb4, 0xe9, 0x9c, 0xe7, 0x3d, 0xe7, 0x3e, 0x76, 0x17, 0x14, 0x08, 0xcb, 0x1e, + 0xfd, 0xdb, 0x3d, 0xdf, 0x77, 0xbe, 0x73, 0xee, 0x79, 0x7e, 0xe7, 0x7b, 0xc2, 0x6b, 0xbb, 0xaf, + 0x84, 0x73, 0xae, 0x3f, 0xbf, 0xdb, 0xde, 0x24, 0x81, 0x47, 0x22, 0x12, 0xce, 0xef, 0x11, 0xaf, + 0xee, 0x07, 0xf3, 0x02, 0xe0, 0xb4, 0xdc, 0xf9, 0x9a, 0x1f, 0x90, 0xf9, 0xbd, 0xcb, 0xf3, 0xdb, + 0xc4, 0x23, 0x81, 0x13, 0x91, 0xfa, 0x5c, 0x2b, 0xf0, 0x23, 0x1f, 0x21, 0x8e, 0x33, 0xe7, 0xb4, + 0xdc, 0x39, 0x8a, 0x33, 0xb7, 0x77, 0x79, 0xe6, 0xf9, 0x6d, 0x37, 0xda, 0x69, 0x6f, 0xce, 0xd5, + 0xfc, 0xe6, 0xfc, 0xb6, 0xbf, 0xed, 0xcf, 0x33, 0xd4, 0xcd, 0xf6, 0x16, 0xfb, 0xc7, 0xfe, 0xb0, + 0x5f, 0x9c, 0xc4, 0xcc, 0x4b, 0x71, 0x33, 0x4d, 0xa7, 0xb6, 0xe3, 0x7a, 0x24, 0xd8, 0x9f, 0x6f, + 0xed, 0x6e, 0xb3, 0x76, 0x03, 0x12, 0xfa, 0xed, 0xa0, 0x46, 0x92, 0x0d, 0x77, 0xac, 0x15, 0xce, + 0x37, 0x49, 0xe4, 0x64, 0x74, 0x77, 0x66, 0x3e, 0xaf, 0x56, 0xd0, 0xf6, 0x22, 0xb7, 0x99, 0x6e, + 0xe6, 0x83, 0xdd, 0x2a, 0x84, 0xb5, 0x1d, 0xd2, 0x74, 0x52, 0xf5, 0x5e, 0xcc, 0xab, 0xd7, 0x8e, + 0xdc, 0xc6, 0xbc, 0xeb, 0x45, 0x61, 0x14, 0x24, 0x2b, 0xd9, 0x5f, 0xb3, 0xe0, 0xc2, 0xc2, 0xed, + 0xea, 0x72, 0xc3, 0x09, 0x23, 0xb7, 0xb6, 0xd8, 0xf0, 0x6b, 0xbb, 0xd5, 0xc8, 0x0f, 0xc8, 0x2d, + 0xbf, 0xd1, 0x6e, 0x92, 0x2a, 0x1b, 0x08, 0xf4, 0x1c, 0x0c, 0xed, 0xb1, 0xff, 0xab, 0xe5, 0x69, + 0xeb, 0x82, 0x75, 0xa9, 0xb4, 0x38, 0xf1, 0xab, 0x07, 0xb3, 0xef, 0xbb, 0x7f, 0x30, 0x3b, 0x74, + 0x4b, 0x94, 0x63, 0x85, 0x81, 0x2e, 0xc2, 0xc0, 0x56, 0xb8, 0xb1, 0xdf, 0x22, 0xd3, 0x05, 0x86, + 0x3b, 0x26, 0x70, 0x07, 0x56, 0xaa, 0xb4, 0x14, 0x0b, 0x28, 0x9a, 0x87, 0x52, 0xcb, 0x09, 0x22, + 0x37, 0x72, 0x7d, 0x6f, 0xba, 0x78, 0xc1, 0xba, 0xd4, 0xbf, 0x38, 0x29, 0x50, 0x4b, 0x15, 0x09, + 0xc0, 0x31, 0x0e, 0xed, 0x46, 0x40, 0x9c, 0xfa, 0x0d, 0xaf, 0xb1, 0x3f, 0xdd, 0x77, 0xc1, 0xba, + 0x34, 0x14, 0x77, 0x03, 0x8b, 0x72, 0xac, 0x30, 0xec, 0x2f, 0x16, 0x60, 0x68, 0x61, 0x6b, 0xcb, + 0xf5, 0xdc, 0x68, 0x1f, 0xdd, 0x82, 0x11, 0xcf, 0xaf, 0x13, 0xf9, 0x9f, 0x7d, 0xc5, 0xf0, 0x0b, + 0x17, 0xe6, 0xd2, 0x4b, 0x69, 0x6e, 0x5d, 0xc3, 0x5b, 0x9c, 0xb8, 0x7f, 0x30, 0x3b, 0xa2, 0x97, + 0x60, 0x83, 0x0e, 0xc2, 0x30, 0xdc, 0xf2, 0xeb, 0x8a, 0x6c, 0x81, 0x91, 0x9d, 0xcd, 0x22, 0x5b, + 0x89, 0xd1, 0x16, 0xc7, 0xef, 0x1f, 0xcc, 0x0e, 0x6b, 0x05, 0x58, 0x27, 0x82, 0x36, 0x61, 0x9c, + 0xfe, 0xf5, 0x22, 0x57, 0xd1, 0x2d, 0x32, 0xba, 0x4f, 0xe4, 0xd1, 0xd5, 0x50, 0x17, 0xa7, 0xee, + 0x1f, 0xcc, 0x8e, 0x27, 0x0a, 0x71, 0x92, 0xa0, 0x7d, 0x0f, 0xc6, 0x16, 0xa2, 0xc8, 0xa9, 0xed, + 0x90, 0x3a, 0x9f, 0x41, 0xf4, 0x12, 0xf4, 0x79, 0x4e, 0x93, 0x88, 0xf9, 0xbd, 0x20, 0x06, 0xb6, + 0x6f, 0xdd, 0x69, 0x92, 0xc3, 0x83, 0xd9, 0x89, 0x9b, 0x9e, 0xfb, 0x76, 0x5b, 0xac, 0x0a, 0x5a, + 0x86, 0x19, 0x36, 0x7a, 0x01, 0xa0, 0x4e, 0xf6, 0xdc, 0x1a, 0xa9, 0x38, 0xd1, 0x8e, 0x98, 0x6f, + 0x24, 0xea, 0x42, 0x59, 0x41, 0xb0, 0x86, 0x65, 0xdf, 0x85, 0xd2, 0xc2, 0x9e, 0xef, 0xd6, 0x2b, + 0x7e, 0x3d, 0x44, 0xbb, 0x30, 0xde, 0x0a, 0xc8, 0x16, 0x09, 0x54, 0xd1, 0xb4, 0x75, 0xa1, 0x78, + 0x69, 0xf8, 0x85, 0x4b, 0x99, 0x1f, 0x6b, 0xa2, 0x2e, 0x7b, 0x51, 0xb0, 0xbf, 0xf8, 0x88, 0x68, + 0x6f, 0x3c, 0x01, 0xc5, 0x49, 0xca, 0xf6, 0x3f, 0x2f, 0xc0, 0xe9, 0x85, 0x7b, 0xed, 0x80, 0x94, + 0xdd, 0x70, 0x37, 0xb9, 0xc2, 0xeb, 0x6e, 0xb8, 0xbb, 0x1e, 0x8f, 0x80, 0x5a, 0x5a, 0x65, 0x51, + 0x8e, 0x15, 0x06, 0x7a, 0x1e, 0x06, 0xe9, 0xef, 0x9b, 0x78, 0x55, 0x7c, 0xf2, 0x94, 0x40, 0x1e, + 0x2e, 0x3b, 0x91, 0x53, 0xe6, 0x20, 0x2c, 0x71, 0xd0, 0x1a, 0x0c, 0xd7, 0xd8, 0x86, 0xdc, 0x5e, + 0xf3, 0xeb, 0x84, 0x4d, 0x66, 0x69, 0xf1, 0x59, 0x8a, 0xbe, 0x14, 0x17, 0x1f, 0x1e, 0xcc, 0x4e, + 0xf3, 0xbe, 0x09, 0x12, 0x1a, 0x0c, 0xeb, 0xf5, 0x91, 0xad, 0xf6, 0x57, 0x1f, 0xa3, 0x04, 0x19, + 0x7b, 0xeb, 0x92, 0xb6, 0x55, 0xfa, 0xd9, 0x56, 0x19, 0xc9, 0xde, 0x26, 0xe8, 0x32, 0xf4, 0xed, + 0xba, 0x5e, 0x7d, 0x7a, 0x80, 0xd1, 0x3a, 0x47, 0xe7, 0xfc, 0x9a, 0xeb, 0xd5, 0x0f, 0x0f, 0x66, + 0x27, 0x8d, 0xee, 0xd0, 0x42, 0xcc, 0x50, 0xed, 0x3f, 0xb6, 0x60, 0x96, 0xc1, 0x56, 0xdc, 0x06, + 0xa9, 0x90, 0x20, 0x74, 0xc3, 0x88, 0x78, 0x91, 0x31, 0xa0, 0x2f, 0x00, 0x84, 0xa4, 0x16, 0x90, + 0x48, 0x1b, 0x52, 0xb5, 0x30, 0xaa, 0x0a, 0x82, 0x35, 0x2c, 0x7a, 0x20, 0x84, 0x3b, 0x4e, 0xc0, + 0xd6, 0x97, 0x18, 0x58, 0x75, 0x20, 0x54, 0x25, 0x00, 0xc7, 0x38, 0xc6, 0x81, 0x50, 0xec, 0x76, + 0x20, 0xa0, 0x8f, 0xc0, 0x78, 0xdc, 0x58, 0xd8, 0x72, 0x6a, 0x72, 0x00, 0xd9, 0x96, 0xa9, 0x9a, + 0x20, 0x9c, 0xc4, 0xb5, 0xff, 0x96, 0x25, 0x16, 0x0f, 0xfd, 0xea, 0x77, 0xf9, 0xb7, 0xda, 0xbf, + 0x60, 0xc1, 0xe0, 0xa2, 0xeb, 0xd5, 0x5d, 0x6f, 0x1b, 0x7d, 0x1a, 0x86, 0xe8, 0xdd, 0x54, 0x77, + 0x22, 0x47, 0x9c, 0x7b, 0x1f, 0xd0, 0xf6, 0x96, 0xba, 0x2a, 0xe6, 0x5a, 0xbb, 0xdb, 0xb4, 0x20, + 0x9c, 0xa3, 0xd8, 0x74, 0xb7, 0xdd, 0xd8, 0xfc, 0x0c, 0xa9, 0x45, 0x6b, 0x24, 0x72, 0xe2, 0xcf, + 0x89, 0xcb, 0xb0, 0xa2, 0x8a, 0xae, 0xc1, 0x40, 0xe4, 0x04, 0xdb, 0x24, 0x12, 0x07, 0x60, 0xe6, + 0x41, 0xc5, 0x6b, 0x62, 0xba, 0x23, 0x89, 0x57, 0x23, 0xf1, 0xb5, 0xb0, 0xc1, 0xaa, 0x62, 0x41, + 0xc2, 0xfe, 0xbf, 0x83, 0x70, 0x76, 0xa9, 0xba, 0x9a, 0xb3, 0xae, 0x2e, 0xc2, 0x40, 0x3d, 0x70, + 0xf7, 0x48, 0x20, 0xc6, 0x59, 0x51, 0x29, 0xb3, 0x52, 0x2c, 0xa0, 0xe8, 0x15, 0x18, 0xe1, 0x17, + 0xd2, 0x55, 0xc7, 0xab, 0x37, 0xe4, 0x10, 0x9f, 0x12, 0xd8, 0x23, 0xb7, 0x34, 0x18, 0x36, 0x30, + 0x8f, 0xb8, 0xa8, 0x2e, 0x26, 0x36, 0x63, 0xde, 0x65, 0xf7, 0x79, 0x0b, 0x26, 0x78, 0x33, 0x0b, + 0x51, 0x14, 0xb8, 0x9b, 0xed, 0x88, 0x84, 0xd3, 0xfd, 0xec, 0xa4, 0x5b, 0xca, 0x1a, 0xad, 0xdc, + 0x11, 0x98, 0xbb, 0x95, 0xa0, 0xc2, 0x0f, 0xc1, 0x69, 0xd1, 0xee, 0x44, 0x12, 0x8c, 0x53, 0xcd, + 0xa2, 0xef, 0xb6, 0x60, 0xa6, 0xe6, 0x7b, 0x51, 0xe0, 0x37, 0x1a, 0x24, 0xa8, 0xb4, 0x37, 0x1b, + 0x6e, 0xb8, 0xc3, 0xd7, 0x29, 0x26, 0x5b, 0xec, 0x24, 0xc8, 0x99, 0x43, 0x85, 0x24, 0xe6, 0xf0, + 0xfc, 0xfd, 0x83, 0xd9, 0x99, 0xa5, 0x5c, 0x52, 0xb8, 0x43, 0x33, 0x68, 0x17, 0x10, 0xbd, 0x4a, + 0xab, 0x91, 0xb3, 0x4d, 0xe2, 0xc6, 0x07, 0x7b, 0x6f, 0xfc, 0xcc, 0xfd, 0x83, 0x59, 0xb4, 0x9e, + 0x22, 0x81, 0x33, 0xc8, 0xa2, 0xb7, 0xe1, 0x14, 0x2d, 0x4d, 0x7d, 0xeb, 0x50, 0xef, 0xcd, 0x4d, + 0xdf, 0x3f, 0x98, 0x3d, 0xb5, 0x9e, 0x41, 0x04, 0x67, 0x92, 0x46, 0xdf, 0x65, 0xc1, 0xd9, 0xf8, + 0xf3, 0x97, 0xef, 0xb6, 0x1c, 0xaf, 0x1e, 0x37, 0x5c, 0xea, 0xbd, 0x61, 0x7a, 0x26, 0x9f, 0x5d, + 0xca, 0xa3, 0x84, 0xf3, 0x1b, 0x41, 0x1e, 0x4c, 0xd1, 0xae, 0x25, 0xdb, 0x86, 0xde, 0xdb, 0x7e, + 0xe4, 0xfe, 0xc1, 0xec, 0xd4, 0x7a, 0x9a, 0x06, 0xce, 0x22, 0x3c, 0xb3, 0x04, 0xa7, 0x33, 0x57, + 0x27, 0x9a, 0x80, 0xe2, 0x2e, 0xe1, 0x5c, 0x57, 0x09, 0xd3, 0x9f, 0xe8, 0x14, 0xf4, 0xef, 0x39, + 0x8d, 0xb6, 0xd8, 0x98, 0x98, 0xff, 0x79, 0xb5, 0xf0, 0x8a, 0x65, 0xff, 0x8b, 0x22, 0x8c, 0x2f, + 0x55, 0x57, 0x1f, 0x68, 0xd7, 0xeb, 0xd7, 0x5e, 0xa1, 0xe3, 0xb5, 0x17, 0x5f, 0xa2, 0xc5, 0xdc, + 0x4b, 0xf4, 0xcf, 0x66, 0x6c, 0xd9, 0x3e, 0xb6, 0x65, 0xbf, 0x2d, 0x67, 0xcb, 0x1e, 0xf3, 0x46, + 0xdd, 0xcb, 0x59, 0xb5, 0xfd, 0x6c, 0x02, 0x33, 0x39, 0xa4, 0xeb, 0x7e, 0xcd, 0x69, 0x24, 0x8f, + 0xda, 0x23, 0x2e, 0xdd, 0xe3, 0x99, 0xc7, 0x1a, 0x8c, 0x2c, 0x39, 0x2d, 0x67, 0xd3, 0x6d, 0xb8, + 0x91, 0x4b, 0x42, 0xf4, 0x34, 0x14, 0x9d, 0x7a, 0x9d, 0x71, 0x77, 0xa5, 0xc5, 0xd3, 0xf7, 0x0f, + 0x66, 0x8b, 0x0b, 0x75, 0xca, 0x66, 0x80, 0xc2, 0xda, 0xc7, 0x14, 0x03, 0xbd, 0x1f, 0xfa, 0xea, + 0x81, 0xdf, 0x9a, 0x2e, 0x30, 0x4c, 0xba, 0xcb, 0xfb, 0xca, 0x81, 0xdf, 0x4a, 0xa0, 0x32, 0x1c, + 0xfb, 0x57, 0x0a, 0xf0, 0xd8, 0x12, 0x69, 0xed, 0xac, 0x54, 0x73, 0xee, 0x8b, 0x4b, 0x30, 0xd4, + 0xf4, 0x3d, 0x37, 0xf2, 0x83, 0x50, 0x34, 0xcd, 0x56, 0xc4, 0x9a, 0x28, 0xc3, 0x0a, 0x8a, 0x2e, + 0x40, 0x5f, 0x2b, 0x66, 0x62, 0x47, 0x24, 0x03, 0xcc, 0xd8, 0x57, 0x06, 0xa1, 0x18, 0xed, 0x90, + 0x04, 0x62, 0xc5, 0x28, 0x8c, 0x9b, 0x21, 0x09, 0x30, 0x83, 0xc4, 0x9c, 0x00, 0xe5, 0x11, 0xc4, + 0x8d, 0x90, 0xe0, 0x04, 0x28, 0x04, 0x6b, 0x58, 0xa8, 0x02, 0xa5, 0x30, 0x31, 0xb3, 0x3d, 0x6d, + 0xcd, 0x51, 0xc6, 0x2a, 0xa8, 0x99, 0x8c, 0x89, 0x18, 0x37, 0xd8, 0x40, 0x57, 0x56, 0xe1, 0xab, + 0x05, 0x40, 0x7c, 0x08, 0xbf, 0xc9, 0x06, 0xee, 0x66, 0x7a, 0xe0, 0x7a, 0xdf, 0x12, 0xc7, 0x35, + 0x7a, 0xff, 0xc3, 0x82, 0xc7, 0x96, 0x5c, 0xaf, 0x4e, 0x82, 0x9c, 0x05, 0xf8, 0x70, 0xde, 0xce, + 0x47, 0x63, 0x52, 0x8c, 0x25, 0xd6, 0x77, 0x0c, 0x4b, 0xcc, 0xfe, 0x43, 0x0b, 0x10, 0xff, 0xec, + 0x77, 0xdd, 0xc7, 0xde, 0x4c, 0x7f, 0xec, 0x31, 0x2c, 0x0b, 0xfb, 0x3a, 0x8c, 0x2d, 0x35, 0x5c, + 0xe2, 0x45, 0xab, 0x95, 0x25, 0xdf, 0xdb, 0x72, 0xb7, 0xd1, 0xab, 0x30, 0x16, 0xb9, 0x4d, 0xe2, + 0xb7, 0xa3, 0x2a, 0xa9, 0xf9, 0x1e, 0x7b, 0xb9, 0x5a, 0x97, 0xfa, 0x17, 0xd1, 0xfd, 0x83, 0xd9, + 0xb1, 0x0d, 0x03, 0x82, 0x13, 0x98, 0xf6, 0x6f, 0xd3, 0xf1, 0xf3, 0x9b, 0x2d, 0xdf, 0x23, 0x5e, + 0xb4, 0xe4, 0x7b, 0x75, 0x2e, 0xe1, 0x78, 0x15, 0xfa, 0x22, 0x3a, 0x1e, 0x7c, 0xec, 0x2e, 0xca, + 0x8d, 0x42, 0x47, 0xe1, 0xf0, 0x60, 0xf6, 0x4c, 0xba, 0x06, 0x1b, 0x27, 0x56, 0x07, 0x7d, 0x1b, + 0x0c, 0x84, 0x91, 0x13, 0xb5, 0x43, 0x31, 0x9a, 0x8f, 0xcb, 0xd1, 0xac, 0xb2, 0xd2, 0xc3, 0x83, + 0xd9, 0x71, 0x55, 0x8d, 0x17, 0x61, 0x51, 0x01, 0x3d, 0x03, 0x83, 0x4d, 0x12, 0x86, 0xce, 0xb6, + 0xbc, 0x0d, 0xc7, 0x45, 0xdd, 0xc1, 0x35, 0x5e, 0x8c, 0x25, 0x1c, 0x3d, 0x01, 0xfd, 0x24, 0x08, + 0xfc, 0x40, 0xec, 0xd1, 0x51, 0x81, 0xd8, 0xbf, 0x4c, 0x0b, 0x31, 0x87, 0xd9, 0xff, 0xd6, 0x82, + 0x71, 0xd5, 0x57, 0xde, 0xd6, 0x09, 0xbc, 0x42, 0x3e, 0x01, 0x50, 0x93, 0x1f, 0x18, 0xb2, 0xdb, + 0x63, 0xf8, 0x85, 0x8b, 0x99, 0x17, 0x75, 0x6a, 0x18, 0x63, 0xca, 0xaa, 0x28, 0xc4, 0x1a, 0x35, + 0xfb, 0x1f, 0x59, 0x30, 0x95, 0xf8, 0xa2, 0xeb, 0x6e, 0x18, 0xa1, 0xb7, 0x52, 0x5f, 0x35, 0xd7, + 0xdb, 0x57, 0xd1, 0xda, 0xec, 0x9b, 0xd4, 0x52, 0x96, 0x25, 0xda, 0x17, 0x5d, 0x85, 0x7e, 0x37, + 0x22, 0x4d, 0xf9, 0x31, 0x4f, 0x74, 0xfc, 0x18, 0xde, 0xab, 0x78, 0x46, 0x56, 0x69, 0x4d, 0xcc, + 0x09, 0xd8, 0xbf, 0x52, 0x84, 0x12, 0x5f, 0xb6, 0x6b, 0x4e, 0xeb, 0x04, 0xe6, 0xe2, 0x59, 0x28, + 0xb9, 0xcd, 0x66, 0x3b, 0x72, 0x36, 0xc5, 0x71, 0x3e, 0xc4, 0xb7, 0xd6, 0xaa, 0x2c, 0xc4, 0x31, + 0x1c, 0xad, 0x42, 0x1f, 0xeb, 0x0a, 0xff, 0xca, 0xa7, 0xb3, 0xbf, 0x52, 0xf4, 0x7d, 0xae, 0xec, + 0x44, 0x0e, 0xe7, 0xa4, 0xd4, 0x3d, 0x42, 0x8b, 0x30, 0x23, 0x81, 0x1c, 0x80, 0x4d, 0xd7, 0x73, + 0x82, 0x7d, 0x5a, 0x36, 0x5d, 0x64, 0x04, 0x9f, 0xef, 0x4c, 0x70, 0x51, 0xe1, 0x73, 0xb2, 0xea, + 0xc3, 0x62, 0x00, 0xd6, 0x88, 0xce, 0x7c, 0x08, 0x4a, 0x0a, 0xf9, 0x28, 0x0c, 0xd1, 0xcc, 0x47, + 0x60, 0x3c, 0xd1, 0x56, 0xb7, 0xea, 0x23, 0x3a, 0x3f, 0xf5, 0x8b, 0xec, 0xc8, 0x10, 0xbd, 0x5e, + 0xf6, 0xf6, 0xc4, 0x91, 0x7b, 0x0f, 0x4e, 0x35, 0x32, 0x4e, 0x32, 0x31, 0xaf, 0xbd, 0x9f, 0x7c, + 0x8f, 0x89, 0xcf, 0x3e, 0x95, 0x05, 0xc5, 0x99, 0x6d, 0x50, 0x1e, 0xc1, 0x6f, 0xd1, 0x0d, 0xe2, + 0x34, 0x74, 0x76, 0xfb, 0x86, 0x28, 0xc3, 0x0a, 0x4a, 0xcf, 0xbb, 0x53, 0xaa, 0xf3, 0xd7, 0xc8, + 0x7e, 0x95, 0x34, 0x48, 0x2d, 0xf2, 0x83, 0x6f, 0x68, 0xf7, 0xcf, 0xf1, 0xd1, 0xe7, 0xc7, 0xe5, + 0xb0, 0x20, 0x50, 0xbc, 0x46, 0xf6, 0xf9, 0x54, 0xe8, 0x5f, 0x57, 0xec, 0xf8, 0x75, 0x3f, 0x63, + 0xc1, 0xa8, 0xfa, 0xba, 0x13, 0x38, 0x17, 0x16, 0xcd, 0x73, 0xe1, 0x5c, 0xc7, 0x05, 0x9e, 0x73, + 0x22, 0x7c, 0xb5, 0x00, 0x67, 0x15, 0x0e, 0x7d, 0x1b, 0xf0, 0x3f, 0x62, 0x55, 0xcd, 0x43, 0xc9, + 0x53, 0x52, 0x32, 0xcb, 0x14, 0x4f, 0xc5, 0x32, 0xb2, 0x18, 0x87, 0xb2, 0x78, 0x5e, 0x2c, 0xca, + 0x1a, 0xd1, 0xc5, 0xc7, 0x42, 0x54, 0xbc, 0x08, 0xc5, 0xb6, 0x5b, 0x17, 0x17, 0xcc, 0x07, 0xe4, + 0x68, 0xdf, 0x5c, 0x2d, 0x1f, 0x1e, 0xcc, 0x3e, 0x9e, 0xa7, 0xba, 0xa0, 0x37, 0x5b, 0x38, 0x77, + 0x73, 0xb5, 0x8c, 0x69, 0x65, 0xb4, 0x00, 0xe3, 0x52, 0x3b, 0x73, 0x8b, 0xb2, 0x5b, 0xbe, 0x27, + 0xee, 0x21, 0x25, 0x03, 0xc6, 0x26, 0x18, 0x27, 0xf1, 0x51, 0x19, 0x26, 0x76, 0xdb, 0x9b, 0xa4, + 0x41, 0x22, 0xfe, 0xc1, 0xd7, 0x08, 0x97, 0x90, 0x96, 0xe2, 0x97, 0xd9, 0xb5, 0x04, 0x1c, 0xa7, + 0x6a, 0xd8, 0x7f, 0xca, 0xee, 0x03, 0x31, 0x7a, 0x95, 0xc0, 0xa7, 0x0b, 0x8b, 0x52, 0xff, 0x46, + 0x2e, 0xe7, 0x5e, 0x56, 0xc5, 0x35, 0xb2, 0xbf, 0xe1, 0x53, 0xce, 0x3c, 0x7b, 0x55, 0x18, 0x6b, + 0xbe, 0xaf, 0xe3, 0x9a, 0xff, 0xd9, 0x02, 0x9c, 0x56, 0x23, 0x60, 0x30, 0x81, 0xdf, 0xec, 0x63, + 0x70, 0x19, 0x86, 0xeb, 0x64, 0xcb, 0x69, 0x37, 0x22, 0x25, 0xae, 0xef, 0xe7, 0x2a, 0x9b, 0x72, + 0x5c, 0x8c, 0x75, 0x9c, 0x23, 0x0c, 0xdb, 0xff, 0x1c, 0x66, 0x17, 0x71, 0xe4, 0xd0, 0x35, 0xae, + 0x76, 0x8d, 0x95, 0xbb, 0x6b, 0x9e, 0x80, 0x7e, 0xb7, 0x49, 0x19, 0xb3, 0x82, 0xc9, 0x6f, 0xad, + 0xd2, 0x42, 0xcc, 0x61, 0xe8, 0x29, 0x18, 0xac, 0xf9, 0xcd, 0xa6, 0xe3, 0xd5, 0xd9, 0x95, 0x57, + 0x5a, 0x1c, 0xa6, 0xbc, 0xdb, 0x12, 0x2f, 0xc2, 0x12, 0x86, 0x1e, 0x83, 0x3e, 0x27, 0xd8, 0xe6, + 0x32, 0x8c, 0xd2, 0xe2, 0x10, 0x6d, 0x69, 0x21, 0xd8, 0x0e, 0x31, 0x2b, 0xa5, 0x4f, 0xb0, 0x3b, + 0x7e, 0xb0, 0xeb, 0x7a, 0xdb, 0x65, 0x37, 0x10, 0x5b, 0x42, 0xdd, 0x85, 0xb7, 0x15, 0x04, 0x6b, + 0x58, 0x68, 0x05, 0xfa, 0x5b, 0x7e, 0x10, 0x85, 0xd3, 0x03, 0x6c, 0xb8, 0x1f, 0xcf, 0x39, 0x88, + 0xf8, 0xd7, 0x56, 0xfc, 0x20, 0x8a, 0x3f, 0x80, 0xfe, 0x0b, 0x31, 0xaf, 0x8e, 0xae, 0xc3, 0x20, + 0xf1, 0xf6, 0x56, 0x02, 0xbf, 0x39, 0x3d, 0x95, 0x4f, 0x69, 0x99, 0xa3, 0xf0, 0x65, 0x16, 0xf3, + 0xa8, 0xa2, 0x18, 0x4b, 0x12, 0xe8, 0xdb, 0xa0, 0x48, 0xbc, 0xbd, 0xe9, 0x41, 0x46, 0x69, 0x26, + 0x87, 0xd2, 0x2d, 0x27, 0x88, 0xcf, 0xfc, 0x65, 0x6f, 0x0f, 0xd3, 0x3a, 0xe8, 0xe3, 0x50, 0x92, + 0x07, 0x46, 0x28, 0x84, 0x83, 0x99, 0x0b, 0x56, 0x1e, 0x33, 0x98, 0xbc, 0xdd, 0x76, 0x03, 0xd2, + 0x24, 0x5e, 0x14, 0xc6, 0x27, 0xa4, 0x84, 0x86, 0x38, 0xa6, 0x86, 0x3e, 0x2e, 0x25, 0xd2, 0x6b, + 0x7e, 0xdb, 0x8b, 0xc2, 0xe9, 0x12, 0xeb, 0x5e, 0xa6, 0xae, 0xf0, 0x56, 0x8c, 0x97, 0x14, 0x59, + 0xf3, 0xca, 0xd8, 0x20, 0x85, 0x3e, 0x09, 0xa3, 0xfc, 0x3f, 0xd7, 0xb8, 0x85, 0xd3, 0xa7, 0x19, + 0xed, 0x0b, 0xf9, 0xb4, 0x39, 0xe2, 0xe2, 0x69, 0x41, 0x7c, 0x54, 0x2f, 0x0d, 0xb1, 0x49, 0x0d, + 0x61, 0x18, 0x6d, 0xb8, 0x7b, 0xc4, 0x23, 0x61, 0x58, 0x09, 0xfc, 0x4d, 0x22, 0x04, 0x88, 0x67, + 0xb3, 0x35, 0x74, 0xfe, 0x26, 0x59, 0x9c, 0xa4, 0x34, 0xaf, 0xeb, 0x75, 0xb0, 0x49, 0x02, 0xdd, + 0x84, 0x31, 0xfa, 0x62, 0x73, 0x63, 0xa2, 0xc3, 0xdd, 0x88, 0xb2, 0x77, 0x15, 0x36, 0x2a, 0xe1, + 0x04, 0x11, 0x74, 0x03, 0x46, 0xc2, 0xc8, 0x09, 0xa2, 0x76, 0x8b, 0x13, 0x3d, 0xd3, 0x8d, 0x28, + 0x53, 0xf0, 0x56, 0xb5, 0x2a, 0xd8, 0x20, 0x80, 0xde, 0x80, 0x52, 0xc3, 0xdd, 0x22, 0xb5, 0xfd, + 0x5a, 0x83, 0x4c, 0x8f, 0x30, 0x6a, 0x99, 0x87, 0xca, 0x75, 0x89, 0xc4, 0xf9, 0x5c, 0xf5, 0x17, + 0xc7, 0xd5, 0xd1, 0x2d, 0x38, 0x13, 0x91, 0xa0, 0xe9, 0x7a, 0x0e, 0x3d, 0x0c, 0xc4, 0xd3, 0x8a, + 0x29, 0x4e, 0x47, 0xd9, 0x6e, 0x3b, 0x2f, 0x66, 0xe3, 0xcc, 0x46, 0x26, 0x16, 0xce, 0xa9, 0x8d, + 0xee, 0xc2, 0x74, 0x06, 0xc4, 0x6f, 0xb8, 0xb5, 0xfd, 0xe9, 0x53, 0x8c, 0xf2, 0x87, 0x05, 0xe5, + 0xe9, 0x8d, 0x1c, 0xbc, 0xc3, 0x0e, 0x30, 0x9c, 0x4b, 0x1d, 0xdd, 0x80, 0x71, 0x76, 0x02, 0x55, + 0xda, 0x8d, 0x86, 0x68, 0x70, 0x8c, 0x35, 0xf8, 0x94, 0xbc, 0x8f, 0x57, 0x4d, 0xf0, 0xe1, 0xc1, + 0x2c, 0xc4, 0xff, 0x70, 0xb2, 0x36, 0xda, 0x64, 0x3a, 0xba, 0x76, 0xe0, 0x46, 0xfb, 0xf4, 0xdc, + 0x20, 0x77, 0xa3, 0xe9, 0xf1, 0x8e, 0xf2, 0x0a, 0x1d, 0x55, 0x29, 0xf2, 0xf4, 0x42, 0x9c, 0x24, + 0x48, 0x8f, 0xd4, 0x30, 0xaa, 0xbb, 0xde, 0xf4, 0x04, 0x7f, 0x97, 0xc8, 0x13, 0xa9, 0x4a, 0x0b, + 0x31, 0x87, 0x31, 0xfd, 0x1c, 0xfd, 0x71, 0x83, 0xde, 0x5c, 0x93, 0x0c, 0x31, 0xd6, 0xcf, 0x49, + 0x00, 0x8e, 0x71, 0x28, 0x33, 0x19, 0x45, 0xfb, 0xd3, 0x88, 0xa1, 0xaa, 0x83, 0x65, 0x63, 0xe3, + 0xe3, 0x98, 0x96, 0xdb, 0x9b, 0x30, 0xa6, 0x0e, 0x42, 0x36, 0x26, 0x68, 0x16, 0xfa, 0x19, 0xfb, + 0x24, 0xa4, 0x6b, 0x25, 0xda, 0x05, 0xc6, 0x5a, 0x61, 0x5e, 0xce, 0xba, 0xe0, 0xde, 0x23, 0x8b, + 0xfb, 0x11, 0xe1, 0x6f, 0xfa, 0xa2, 0xd6, 0x05, 0x09, 0xc0, 0x31, 0x8e, 0xfd, 0xff, 0x38, 0x1b, + 0x1a, 0x9f, 0xb6, 0x3d, 0xdc, 0x2f, 0xcf, 0xc1, 0xd0, 0x8e, 0x1f, 0x46, 0x14, 0x9b, 0xb5, 0xd1, + 0x1f, 0x33, 0x9e, 0x57, 0x45, 0x39, 0x56, 0x18, 0xe8, 0x35, 0x18, 0xad, 0xe9, 0x0d, 0x88, 0xcb, + 0x51, 0x1d, 0x23, 0x46, 0xeb, 0xd8, 0xc4, 0x45, 0xaf, 0xc0, 0x10, 0xb3, 0x39, 0xa9, 0xf9, 0x0d, + 0xc1, 0xb5, 0xc9, 0x1b, 0x7e, 0xa8, 0x22, 0xca, 0x0f, 0xb5, 0xdf, 0x58, 0x61, 0xa3, 0x8b, 0x30, + 0x40, 0xbb, 0xb0, 0x5a, 0x11, 0xd7, 0x92, 0x12, 0x14, 0x5d, 0x65, 0xa5, 0x58, 0x40, 0xed, 0xbf, + 0x58, 0xd0, 0x46, 0x99, 0xbe, 0x87, 0x09, 0xaa, 0xc0, 0xe0, 0x1d, 0xc7, 0x8d, 0x5c, 0x6f, 0x5b, + 0xf0, 0x1f, 0xcf, 0x74, 0xbc, 0xa3, 0x58, 0xa5, 0xdb, 0xbc, 0x02, 0xbf, 0x45, 0xc5, 0x1f, 0x2c, + 0xc9, 0x50, 0x8a, 0x41, 0xdb, 0xf3, 0x28, 0xc5, 0x42, 0xaf, 0x14, 0x31, 0xaf, 0xc0, 0x29, 0x8a, + 0x3f, 0x58, 0x92, 0x41, 0x6f, 0x01, 0xc8, 0x1d, 0x46, 0xea, 0xc2, 0xd6, 0xe3, 0xb9, 0xee, 0x44, + 0x37, 0x54, 0x9d, 0xc5, 0x31, 0x7a, 0x47, 0xc7, 0xff, 0xb1, 0x46, 0xcf, 0x8e, 0x18, 0x9f, 0x96, + 0xee, 0x0c, 0xfa, 0x0e, 0xba, 0xc4, 0x9d, 0x20, 0x22, 0xf5, 0x85, 0x48, 0x0c, 0xce, 0xfb, 0x7b, + 0x7b, 0xa4, 0x6c, 0xb8, 0x4d, 0xa2, 0x6f, 0x07, 0x41, 0x04, 0xc7, 0xf4, 0xec, 0x9f, 0x2f, 0xc2, + 0x74, 0x5e, 0x77, 0xe9, 0xa2, 0x23, 0x77, 0xdd, 0x68, 0x89, 0xb2, 0x57, 0x96, 0xb9, 0xe8, 0x96, + 0x45, 0x39, 0x56, 0x18, 0x74, 0xf6, 0x43, 0x77, 0x5b, 0xbe, 0x31, 0xfb, 0xe3, 0xd9, 0xaf, 0xb2, + 0x52, 0x2c, 0xa0, 0x14, 0x2f, 0x20, 0x4e, 0x28, 0x8c, 0x89, 0xb4, 0x55, 0x82, 0x59, 0x29, 0x16, + 0x50, 0x5d, 0xda, 0xd5, 0xd7, 0x45, 0xda, 0x65, 0x0c, 0x51, 0xff, 0xf1, 0x0e, 0x11, 0xfa, 0x14, + 0xc0, 0x96, 0xeb, 0xb9, 0xe1, 0x0e, 0xa3, 0x3e, 0x70, 0x64, 0xea, 0x8a, 0x39, 0x5b, 0x51, 0x54, + 0xb0, 0x46, 0x11, 0xbd, 0x0c, 0xc3, 0x6a, 0x03, 0xae, 0x96, 0x99, 0x66, 0x55, 0xb3, 0x54, 0x89, + 0x4f, 0xa3, 0x32, 0xd6, 0xf1, 0xec, 0xcf, 0x24, 0xd7, 0x8b, 0xd8, 0x01, 0xda, 0xf8, 0x5a, 0xbd, + 0x8e, 0x6f, 0xa1, 0xf3, 0xf8, 0xda, 0x5f, 0x2f, 0xc2, 0xb8, 0xd1, 0x58, 0x3b, 0xec, 0xe1, 0xcc, + 0xba, 0x42, 0x0f, 0x70, 0x27, 0x22, 0x62, 0xff, 0xd9, 0xdd, 0xb7, 0x8a, 0x7e, 0xc8, 0xd3, 0x1d, + 0xc0, 0xeb, 0xa3, 0x4f, 0x41, 0xa9, 0xe1, 0x84, 0x4c, 0x72, 0x46, 0xc4, 0xbe, 0xeb, 0x85, 0x58, + 0xfc, 0x30, 0x71, 0xc2, 0x48, 0xbb, 0x35, 0x39, 0xed, 0x98, 0x24, 0xbd, 0x69, 0x28, 0x7f, 0x22, + 0xad, 0xd5, 0x54, 0x27, 0x28, 0x13, 0xb3, 0x8f, 0x39, 0x0c, 0xbd, 0x02, 0x23, 0x01, 0x61, 0xab, + 0x62, 0x89, 0x72, 0x73, 0x6c, 0x99, 0xf5, 0xc7, 0x6c, 0x1f, 0xd6, 0x60, 0xd8, 0xc0, 0x8c, 0xdf, + 0x06, 0x03, 0x1d, 0xde, 0x06, 0xcf, 0xc0, 0x20, 0xfb, 0xa1, 0x56, 0x80, 0x9a, 0x8d, 0x55, 0x5e, + 0x8c, 0x25, 0x3c, 0xb9, 0x60, 0x86, 0x7a, 0x5b, 0x30, 0xf4, 0xf5, 0x21, 0x16, 0x35, 0xd3, 0x6a, + 0x0f, 0xf1, 0x53, 0x4e, 0x2c, 0x79, 0x2c, 0x61, 0xf6, 0xfb, 0x61, 0xac, 0xec, 0x90, 0xa6, 0xef, + 0x2d, 0x7b, 0xf5, 0x96, 0xef, 0x7a, 0x11, 0x9a, 0x86, 0x3e, 0x76, 0x89, 0xf0, 0x23, 0xa0, 0x8f, + 0x36, 0x84, 0x59, 0x89, 0xbd, 0x0d, 0xa7, 0xcb, 0xfe, 0x1d, 0xef, 0x8e, 0x13, 0xd4, 0x17, 0x2a, + 0xab, 0xda, 0xfb, 0x7a, 0x5d, 0xbe, 0xef, 0xb8, 0x91, 0x58, 0xe6, 0xd1, 0xab, 0xd5, 0xe4, 0x6c, + 0xed, 0x8a, 0xdb, 0x20, 0x39, 0x52, 0x90, 0xbf, 0x52, 0x30, 0x5a, 0x8a, 0xf1, 0x95, 0x56, 0xcb, + 0xca, 0xd5, 0x6a, 0xbd, 0x09, 0x43, 0x5b, 0x2e, 0x69, 0xd4, 0x31, 0xd9, 0x12, 0x2b, 0xf1, 0xe9, + 0x7c, 0xbb, 0x97, 0x15, 0x8a, 0x29, 0xa5, 0x5e, 0xfc, 0x75, 0xb8, 0x22, 0x2a, 0x63, 0x45, 0x06, + 0xed, 0xc2, 0x84, 0x7c, 0x30, 0x48, 0xa8, 0x58, 0x97, 0xcf, 0x74, 0x7a, 0x85, 0x98, 0xc4, 0x4f, + 0xdd, 0x3f, 0x98, 0x9d, 0xc0, 0x09, 0x32, 0x38, 0x45, 0x98, 0x3e, 0x07, 0x9b, 0xf4, 0x04, 0xee, + 0x63, 0xc3, 0xcf, 0x9e, 0x83, 0xec, 0x65, 0xcb, 0x4a, 0xed, 0x1f, 0xb3, 0xe0, 0x91, 0xd4, 0xc8, + 0x88, 0x17, 0xfe, 0x31, 0xcf, 0x42, 0xf2, 0xc5, 0x5d, 0xe8, 0xfe, 0xe2, 0xb6, 0xff, 0xb6, 0x05, + 0xa7, 0x96, 0x9b, 0xad, 0x68, 0xbf, 0xec, 0x9a, 0x2a, 0xa8, 0x0f, 0xc1, 0x40, 0x93, 0xd4, 0xdd, + 0x76, 0x53, 0xcc, 0xdc, 0xac, 0x3c, 0xa5, 0xd6, 0x58, 0xe9, 0xe1, 0xc1, 0xec, 0x68, 0x35, 0xf2, + 0x03, 0x67, 0x9b, 0xf0, 0x02, 0x2c, 0xd0, 0xd9, 0x59, 0xef, 0xde, 0x23, 0xd7, 0xdd, 0xa6, 0x2b, + 0xed, 0x98, 0x3a, 0xca, 0xec, 0xe6, 0xe4, 0x80, 0xce, 0xbd, 0xd9, 0x76, 0xbc, 0xc8, 0x8d, 0xf6, + 0x85, 0xf6, 0x48, 0x12, 0xc1, 0x31, 0x3d, 0xfb, 0x6b, 0x16, 0x8c, 0xcb, 0x75, 0xbf, 0x50, 0xaf, + 0x07, 0x24, 0x0c, 0xd1, 0x0c, 0x14, 0xdc, 0x96, 0xe8, 0x25, 0x88, 0x5e, 0x16, 0x56, 0x2b, 0xb8, + 0xe0, 0xb6, 0x24, 0x5b, 0xc6, 0x0e, 0xc2, 0xa2, 0xa9, 0x48, 0xbb, 0x2a, 0xca, 0xb1, 0xc2, 0x40, + 0x97, 0x60, 0xc8, 0xf3, 0xeb, 0xdc, 0x96, 0x8c, 0x5f, 0x69, 0x6c, 0x81, 0xad, 0x8b, 0x32, 0xac, + 0xa0, 0xa8, 0x02, 0x25, 0x6e, 0x66, 0x15, 0x2f, 0xda, 0x9e, 0x8c, 0xb5, 0xd8, 0x97, 0x6d, 0xc8, + 0x9a, 0x38, 0x26, 0x62, 0xff, 0xb2, 0x05, 0x23, 0xf2, 0xcb, 0x7a, 0xe4, 0x39, 0xe9, 0xd6, 0x8a, + 0xf9, 0xcd, 0x78, 0x6b, 0x51, 0x9e, 0x91, 0x41, 0x0c, 0x56, 0xb1, 0x78, 0x24, 0x56, 0xf1, 0x32, + 0x0c, 0x3b, 0xad, 0x56, 0xc5, 0xe4, 0x33, 0xd9, 0x52, 0x5a, 0x88, 0x8b, 0xb1, 0x8e, 0x63, 0xff, + 0x68, 0x01, 0xc6, 0xe4, 0x17, 0x54, 0xdb, 0x9b, 0x21, 0x89, 0xd0, 0x06, 0x94, 0x1c, 0x3e, 0x4b, + 0x44, 0x2e, 0xf2, 0x27, 0xb2, 0xe5, 0x08, 0xc6, 0x94, 0xc6, 0x17, 0xfe, 0x82, 0xac, 0x8d, 0x63, + 0x42, 0xa8, 0x01, 0x93, 0x9e, 0x1f, 0xb1, 0xc3, 0x5f, 0xc1, 0x3b, 0xa9, 0x76, 0x92, 0xd4, 0xcf, + 0x0a, 0xea, 0x93, 0xeb, 0x49, 0x2a, 0x38, 0x4d, 0x18, 0x2d, 0x4b, 0xd9, 0x4c, 0x31, 0x5f, 0x18, + 0xa0, 0x4f, 0x5c, 0xb6, 0x68, 0xc6, 0xfe, 0x25, 0x0b, 0x4a, 0x12, 0xed, 0x24, 0xb4, 0x78, 0x6b, + 0x30, 0x18, 0xb2, 0x49, 0x90, 0x43, 0x63, 0x77, 0xea, 0x38, 0x9f, 0xaf, 0xf8, 0x4e, 0xe3, 0xff, + 0x43, 0x2c, 0x69, 0x30, 0xd1, 0xbc, 0xea, 0xfe, 0xbb, 0x44, 0x34, 0xaf, 0xfa, 0x93, 0x73, 0x29, + 0xfd, 0x3e, 0xeb, 0xb3, 0x26, 0xeb, 0xa2, 0xac, 0x57, 0x2b, 0x20, 0x5b, 0xee, 0xdd, 0x24, 0xeb, + 0x55, 0x61, 0xa5, 0x58, 0x40, 0xd1, 0x5b, 0x30, 0x52, 0x93, 0x32, 0xd9, 0x78, 0x87, 0x5f, 0xec, + 0xa8, 0x1f, 0x50, 0xaa, 0x24, 0x2e, 0x0b, 0x59, 0xd2, 0xea, 0x63, 0x83, 0x9a, 0x69, 0x46, 0x50, + 0xec, 0x66, 0x46, 0x10, 0xd3, 0xcd, 0x57, 0xaa, 0xff, 0xb8, 0x05, 0x03, 0x5c, 0x16, 0xd7, 0x9b, + 0x28, 0x54, 0xd3, 0xac, 0xc5, 0x63, 0x77, 0x8b, 0x16, 0x0a, 0x4d, 0x19, 0x5a, 0x83, 0x12, 0xfb, + 0xc1, 0x64, 0x89, 0xc5, 0x7c, 0x2b, 0x7f, 0xde, 0xaa, 0xde, 0xc1, 0x5b, 0xb2, 0x1a, 0x8e, 0x29, + 0xd8, 0x3f, 0x52, 0xa4, 0xa7, 0x5b, 0x8c, 0x6a, 0x5c, 0xfa, 0xd6, 0xc3, 0xbb, 0xf4, 0x0b, 0x0f, + 0xeb, 0xd2, 0xdf, 0x86, 0xf1, 0x9a, 0xa6, 0x87, 0x8b, 0x67, 0xf2, 0x52, 0xc7, 0x45, 0xa2, 0xa9, + 0xec, 0xb8, 0x94, 0x65, 0xc9, 0x24, 0x82, 0x93, 0x54, 0xd1, 0x77, 0xc0, 0x08, 0x9f, 0x67, 0xd1, + 0x0a, 0xb7, 0xc4, 0x78, 0x2a, 0x7f, 0xbd, 0xe8, 0x4d, 0x70, 0xa9, 0x9c, 0x56, 0x1d, 0x1b, 0xc4, + 0xec, 0x3f, 0xb2, 0x00, 0x2d, 0xb7, 0x76, 0x48, 0x93, 0x04, 0x4e, 0x23, 0x16, 0xa7, 0xff, 0xa0, + 0x05, 0xd3, 0x24, 0x55, 0xbc, 0xe4, 0x37, 0x9b, 0xe2, 0xd1, 0x92, 0xf3, 0xae, 0x5e, 0xce, 0xa9, + 0xa3, 0xdc, 0x20, 0xa6, 0xf3, 0x30, 0x70, 0x6e, 0x7b, 0x68, 0x0d, 0xa6, 0xf8, 0x2d, 0xa9, 0x00, + 0x9a, 0xad, 0xf7, 0xa3, 0x82, 0xf0, 0xd4, 0x46, 0x1a, 0x05, 0x67, 0xd5, 0xb3, 0xbf, 0x67, 0x04, + 0x72, 0x7b, 0xf1, 0x9e, 0x1e, 0xe1, 0x3d, 0x3d, 0xc2, 0x7b, 0x7a, 0x84, 0xf7, 0xf4, 0x08, 0xef, + 0xe9, 0x11, 0xbe, 0xe5, 0xf5, 0x08, 0x7f, 0xc9, 0x82, 0xd3, 0xea, 0x1a, 0x30, 0x1e, 0xbe, 0x9f, + 0x85, 0x29, 0xbe, 0xdd, 0x96, 0x1a, 0x8e, 0xdb, 0xdc, 0x20, 0xcd, 0x56, 0xc3, 0x89, 0xa4, 0xd6, + 0xfd, 0x72, 0xe6, 0xca, 0x4d, 0x58, 0xac, 0x1a, 0x15, 0xb9, 0xe9, 0x7f, 0x06, 0x00, 0x67, 0x35, + 0x63, 0xff, 0xfc, 0x10, 0xf4, 0x2f, 0xef, 0x11, 0x2f, 0x3a, 0x81, 0x27, 0x42, 0x0d, 0xc6, 0x5c, + 0x6f, 0xcf, 0x6f, 0xec, 0x91, 0x3a, 0x87, 0x1f, 0xe5, 0x25, 0x7b, 0x46, 0x90, 0x1e, 0x5b, 0x35, + 0x48, 0xe0, 0x04, 0xc9, 0x87, 0x21, 0x4d, 0xbe, 0x02, 0x03, 0xfc, 0x10, 0x17, 0xa2, 0xe4, 0xcc, + 0x33, 0x9b, 0x0d, 0xa2, 0xb8, 0x9a, 0x62, 0x49, 0x37, 0xbf, 0x24, 0x44, 0x75, 0xf4, 0x19, 0x18, + 0xdb, 0x72, 0x83, 0x30, 0xda, 0x70, 0x9b, 0x24, 0x8c, 0x9c, 0x66, 0xeb, 0x01, 0xa4, 0xc7, 0x6a, + 0x1c, 0x56, 0x0c, 0x4a, 0x38, 0x41, 0x19, 0x6d, 0xc3, 0x68, 0xc3, 0xd1, 0x9b, 0x1a, 0x3c, 0x72, + 0x53, 0xea, 0x76, 0xb8, 0xae, 0x13, 0xc2, 0x26, 0x5d, 0xba, 0x9d, 0x6a, 0x4c, 0x00, 0x3a, 0xc4, + 0xc4, 0x02, 0x6a, 0x3b, 0x71, 0xc9, 0x27, 0x87, 0x51, 0x46, 0x87, 0x19, 0xc8, 0x96, 0x4c, 0x46, + 0x47, 0x33, 0x83, 0xfd, 0x34, 0x94, 0x08, 0x1d, 0x42, 0x4a, 0x58, 0x5c, 0x30, 0xf3, 0xbd, 0xf5, + 0x75, 0xcd, 0xad, 0x05, 0xbe, 0x29, 0xb7, 0x5f, 0x96, 0x94, 0x70, 0x4c, 0x14, 0x2d, 0xc1, 0x40, + 0x48, 0x02, 0x97, 0x84, 0xe2, 0xaa, 0xe9, 0x30, 0x8d, 0x0c, 0x8d, 0xfb, 0x96, 0xf0, 0xdf, 0x58, + 0x54, 0xa5, 0xcb, 0xcb, 0x61, 0x22, 0x4d, 0x76, 0x19, 0x68, 0xcb, 0x6b, 0x81, 0x95, 0x62, 0x01, + 0x45, 0x6f, 0xc0, 0x60, 0x40, 0x1a, 0x4c, 0x31, 0x34, 0xda, 0xfb, 0x22, 0xe7, 0x7a, 0x26, 0x5e, + 0x0f, 0x4b, 0x02, 0xe8, 0x1a, 0xa0, 0x80, 0x50, 0x46, 0xc9, 0xf5, 0xb6, 0x95, 0xd9, 0xa8, 0x38, + 0x68, 0x15, 0x43, 0x8a, 0x63, 0x0c, 0xe9, 0x56, 0x84, 0x33, 0xaa, 0xa1, 0x2b, 0x30, 0xa9, 0x4a, + 0x57, 0xbd, 0x30, 0x72, 0xe8, 0x01, 0x37, 0xce, 0x68, 0x29, 0x39, 0x05, 0x4e, 0x22, 0xe0, 0x74, + 0x1d, 0xfb, 0x4b, 0x16, 0xf0, 0x71, 0x3e, 0x81, 0xd7, 0xf9, 0xeb, 0xe6, 0xeb, 0xfc, 0x6c, 0xee, + 0xcc, 0xe5, 0xbc, 0xcc, 0xbf, 0x64, 0xc1, 0xb0, 0x36, 0xb3, 0xf1, 0x9a, 0xb5, 0x3a, 0xac, 0xd9, + 0x36, 0x4c, 0xd0, 0x95, 0x7e, 0x63, 0x33, 0x24, 0xc1, 0x1e, 0xa9, 0xb3, 0x85, 0x59, 0x78, 0xb0, + 0x85, 0xa9, 0x4c, 0xd4, 0xae, 0x27, 0x08, 0xe2, 0x54, 0x13, 0xf6, 0xa7, 0x65, 0x57, 0x95, 0x45, + 0x5f, 0x4d, 0xcd, 0x79, 0xc2, 0xa2, 0x4f, 0xcd, 0x2a, 0x8e, 0x71, 0xe8, 0x56, 0xdb, 0xf1, 0xc3, + 0x28, 0x69, 0xd1, 0x77, 0xd5, 0x0f, 0x23, 0xcc, 0x20, 0xf6, 0x8b, 0x00, 0xcb, 0x77, 0x49, 0x8d, + 0xaf, 0x58, 0xfd, 0xf1, 0x60, 0xe5, 0x3f, 0x1e, 0xec, 0xdf, 0xb0, 0x60, 0x6c, 0x65, 0xc9, 0xb8, + 0xb9, 0xe6, 0x00, 0xf8, 0x8b, 0xe7, 0xf6, 0xed, 0x75, 0xa9, 0x0e, 0xe7, 0x1a, 0x4d, 0x55, 0x8a, + 0x35, 0x0c, 0x74, 0x16, 0x8a, 0x8d, 0xb6, 0x27, 0xc4, 0x87, 0x83, 0xf4, 0x7a, 0xbc, 0xde, 0xf6, + 0x30, 0x2d, 0xd3, 0x5c, 0x0a, 0x8a, 0x3d, 0xbb, 0x14, 0x74, 0x0d, 0x25, 0x80, 0x66, 0xa1, 0xff, + 0xce, 0x1d, 0xb7, 0xce, 0x1d, 0x36, 0x85, 0xaa, 0xfe, 0xf6, 0xed, 0xd5, 0x72, 0x88, 0x79, 0xb9, + 0xfd, 0x85, 0x22, 0xcc, 0xac, 0x34, 0xc8, 0xdd, 0x77, 0xe8, 0xb4, 0xda, 0xab, 0x43, 0xc4, 0xd1, + 0x04, 0x31, 0x47, 0x75, 0x7a, 0xe9, 0x3e, 0x1e, 0x5b, 0x30, 0xc8, 0x0d, 0xda, 0xa4, 0x0b, 0xeb, + 0x6b, 0x59, 0xad, 0xe7, 0x0f, 0xc8, 0x1c, 0x37, 0x8c, 0x13, 0x1e, 0x71, 0xea, 0xc2, 0x14, 0xa5, + 0x58, 0x12, 0x9f, 0x79, 0x15, 0x46, 0x74, 0xcc, 0x23, 0xb9, 0x9f, 0xfd, 0xb9, 0x22, 0x4c, 0xd0, + 0x1e, 0x3c, 0xd4, 0x89, 0xb8, 0x99, 0x9e, 0x88, 0xe3, 0x76, 0x41, 0xea, 0x3e, 0x1b, 0x6f, 0x25, + 0x67, 0xe3, 0x72, 0xde, 0x6c, 0x9c, 0xf4, 0x1c, 0x7c, 0xb7, 0x05, 0x53, 0x2b, 0x0d, 0xbf, 0xb6, + 0x9b, 0x70, 0x13, 0x7a, 0x19, 0x86, 0xe9, 0x71, 0x1c, 0x1a, 0x1e, 0xf3, 0x46, 0x0c, 0x05, 0x01, + 0xc2, 0x3a, 0x9e, 0x56, 0xed, 0xe6, 0xcd, 0xd5, 0x72, 0x56, 0xe8, 0x05, 0x01, 0xc2, 0x3a, 0x9e, + 0xfd, 0x6b, 0x16, 0x9c, 0xbb, 0xb2, 0xb4, 0x1c, 0x2f, 0xc5, 0x54, 0xf4, 0x87, 0x8b, 0x30, 0xd0, + 0xaa, 0x6b, 0x5d, 0x89, 0xc5, 0xab, 0x65, 0xd6, 0x0b, 0x01, 0x7d, 0xb7, 0x44, 0x36, 0xb9, 0x09, + 0x70, 0x05, 0x57, 0x96, 0xc4, 0xb9, 0x2b, 0xb5, 0x29, 0x56, 0xae, 0x36, 0xe5, 0x29, 0x18, 0xa4, + 0xf7, 0x82, 0x5b, 0x93, 0xfd, 0xe6, 0x0a, 0x5a, 0x5e, 0x84, 0x25, 0xcc, 0xfe, 0x69, 0x0b, 0xa6, + 0xae, 0xb8, 0x11, 0xbd, 0xb4, 0x93, 0xe1, 0x0d, 0xe8, 0xad, 0x1d, 0xba, 0x91, 0x1f, 0xec, 0x27, + 0xc3, 0x1b, 0x60, 0x05, 0xc1, 0x1a, 0x16, 0xff, 0xa0, 0x3d, 0x97, 0x59, 0x68, 0x17, 0x4c, 0xfd, + 0x15, 0x16, 0xe5, 0x58, 0x61, 0xd0, 0xf1, 0xaa, 0xbb, 0x01, 0x13, 0xfd, 0xed, 0x8b, 0x83, 0x5b, + 0x8d, 0x57, 0x59, 0x02, 0x70, 0x8c, 0x63, 0xff, 0x81, 0x05, 0xb3, 0x57, 0x1a, 0xed, 0x30, 0x22, + 0xc1, 0x56, 0x98, 0x73, 0xe8, 0xbe, 0x08, 0x25, 0x22, 0x05, 0xed, 0xa2, 0xd7, 0x8a, 0x11, 0x55, + 0x12, 0x78, 0x1e, 0x65, 0x41, 0xe1, 0xf5, 0xe0, 0xcb, 0x78, 0x34, 0x67, 0xb4, 0x15, 0x40, 0x44, + 0x6f, 0x4b, 0x0f, 0x3b, 0xc1, 0xfc, 0xd7, 0x97, 0x53, 0x50, 0x9c, 0x51, 0xc3, 0xfe, 0x31, 0x0b, + 0x4e, 0xab, 0x0f, 0x7e, 0xd7, 0x7d, 0xa6, 0xfd, 0x95, 0x02, 0x8c, 0x5e, 0xdd, 0xd8, 0xa8, 0x5c, + 0x21, 0x91, 0xb6, 0x2a, 0x3b, 0xab, 0xcf, 0xb1, 0xa6, 0x05, 0xec, 0xf4, 0x46, 0x6c, 0x47, 0x6e, + 0x63, 0x8e, 0x47, 0x2f, 0x9a, 0x5b, 0xf5, 0xa2, 0x1b, 0x41, 0x35, 0x0a, 0x5c, 0x6f, 0x3b, 0x73, + 0xa5, 0x4b, 0x9e, 0xa5, 0x98, 0xc7, 0xb3, 0xa0, 0x17, 0x61, 0x80, 0x85, 0x4f, 0x92, 0x93, 0xf0, + 0xa8, 0x7a, 0x62, 0xb1, 0xd2, 0xc3, 0x83, 0xd9, 0xd2, 0x4d, 0xbc, 0xca, 0xff, 0x60, 0x81, 0x8a, + 0x6e, 0xc2, 0xf0, 0x4e, 0x14, 0xb5, 0xae, 0x12, 0xa7, 0x4e, 0x02, 0x79, 0xca, 0x9e, 0xcf, 0x3a, + 0x65, 0xe9, 0x20, 0x70, 0xb4, 0xf8, 0x60, 0x8a, 0xcb, 0x42, 0xac, 0xd3, 0xb1, 0xab, 0x00, 0x31, + 0xec, 0x98, 0x14, 0x20, 0xf6, 0x06, 0x94, 0xe8, 0xe7, 0x2e, 0x34, 0x5c, 0xa7, 0xb3, 0x8a, 0xf9, + 0x59, 0x28, 0x49, 0x05, 0x72, 0x28, 0x7c, 0xad, 0xd9, 0x8d, 0x24, 0xf5, 0xcb, 0x21, 0x8e, 0xe1, + 0xf6, 0x16, 0x9c, 0x62, 0xe6, 0x80, 0x4e, 0xb4, 0x63, 0xac, 0xbe, 0xee, 0xd3, 0xfc, 0x9c, 0x78, + 0xb1, 0xf1, 0x3e, 0x4f, 0x6b, 0xee, 0x8c, 0x23, 0x92, 0x62, 0xfc, 0x7a, 0xb3, 0xbf, 0xde, 0x07, + 0x8f, 0xae, 0x56, 0xf3, 0xc3, 0x7f, 0xbc, 0x02, 0x23, 0x9c, 0x11, 0xa4, 0x93, 0xee, 0x34, 0x44, + 0xbb, 0x4a, 0xb6, 0xb9, 0xa1, 0xc1, 0xb0, 0x81, 0x89, 0xce, 0x41, 0xd1, 0x7d, 0xdb, 0x4b, 0x3a, + 0xfb, 0xac, 0xbe, 0xb9, 0x8e, 0x69, 0x39, 0x05, 0x53, 0x9e, 0x92, 0x1f, 0xd6, 0x0a, 0xac, 0xf8, + 0xca, 0xd7, 0x61, 0xcc, 0x0d, 0x6b, 0xa1, 0xbb, 0xea, 0xd1, 0x1d, 0xa8, 0xed, 0x61, 0x25, 0x4d, + 0xa0, 0x9d, 0x56, 0x50, 0x9c, 0xc0, 0xd6, 0x6e, 0x8e, 0xfe, 0x9e, 0xf9, 0xd2, 0xae, 0xce, 0xc7, + 0xf4, 0x60, 0x6f, 0xb1, 0xaf, 0x0b, 0x99, 0x90, 0x5a, 0x1c, 0xec, 0xfc, 0x83, 0x43, 0x2c, 0x61, + 0xf4, 0xa9, 0x56, 0xdb, 0x71, 0x5a, 0x0b, 0xed, 0x68, 0xa7, 0xec, 0x86, 0x35, 0x7f, 0x8f, 0x04, + 0xfb, 0xec, 0x95, 0x3d, 0x14, 0x3f, 0xd5, 0x14, 0x60, 0xe9, 0xea, 0x42, 0x85, 0x62, 0xe2, 0x74, + 0x1d, 0xb4, 0x00, 0xe3, 0xb2, 0xb0, 0x4a, 0x42, 0x76, 0xb8, 0x0f, 0x33, 0x32, 0xca, 0xfd, 0x46, + 0x14, 0x2b, 0x22, 0x49, 0x7c, 0x93, 0x75, 0x85, 0xe3, 0x60, 0x5d, 0x3f, 0x04, 0xa3, 0xae, 0xe7, + 0x46, 0xae, 0x13, 0xf9, 0x5c, 0xc3, 0xc2, 0x1f, 0xd4, 0x4c, 0x74, 0xbc, 0xaa, 0x03, 0xb0, 0x89, + 0x67, 0xff, 0xa7, 0x3e, 0x98, 0x64, 0xd3, 0xf6, 0xde, 0x0a, 0xfb, 0x56, 0x5a, 0x61, 0x37, 0xd3, + 0x2b, 0xec, 0x38, 0x78, 0xf2, 0x07, 0x5e, 0x66, 0x9f, 0x81, 0x92, 0xf2, 0x38, 0x92, 0x2e, 0x87, + 0x56, 0x8e, 0xcb, 0x61, 0xf7, 0x7b, 0x59, 0x1a, 0x6d, 0x15, 0x33, 0x8d, 0xb6, 0xbe, 0x6c, 0x41, + 0xac, 0x32, 0x40, 0x6f, 0x42, 0xa9, 0xe5, 0x33, 0x5b, 0xc4, 0x40, 0x1a, 0xf8, 0x3e, 0xd9, 0x51, + 0xe7, 0xc0, 0x23, 0x20, 0x05, 0x7c, 0x14, 0x2a, 0xb2, 0x2a, 0x8e, 0xa9, 0xa0, 0x6b, 0x30, 0xd8, + 0x0a, 0x48, 0x35, 0x62, 0xe1, 0x39, 0x7a, 0x27, 0xc8, 0x57, 0x0d, 0xaf, 0x88, 0x25, 0x05, 0xfb, + 0xbf, 0x58, 0x30, 0x91, 0x44, 0x45, 0x1f, 0x86, 0x3e, 0x72, 0x97, 0xd4, 0x44, 0x7f, 0x33, 0x2f, + 0xd9, 0x58, 0xe8, 0xc0, 0x07, 0x80, 0xfe, 0xc7, 0xac, 0x16, 0xba, 0x0a, 0x83, 0xf4, 0x86, 0xbd, + 0xa2, 0x42, 0x51, 0x3d, 0x9e, 0x77, 0x4b, 0x2b, 0x56, 0x85, 0x77, 0x4e, 0x14, 0x61, 0x59, 0x9d, + 0x59, 0x4a, 0xd5, 0x5a, 0x55, 0xfa, 0x78, 0x89, 0x3a, 0xbd, 0xb1, 0x37, 0x96, 0x2a, 0x1c, 0x49, + 0x50, 0xe3, 0x96, 0x52, 0xb2, 0x10, 0xc7, 0x44, 0xec, 0x9f, 0xb5, 0x00, 0xb8, 0x61, 0x98, 0xe3, + 0x6d, 0x93, 0x13, 0x90, 0x93, 0x97, 0xa1, 0x2f, 0x6c, 0x91, 0x5a, 0x27, 0x33, 0xd9, 0xb8, 0x3f, + 0xd5, 0x16, 0xa9, 0xc5, 0x2b, 0x8e, 0xfe, 0xc3, 0xac, 0xb6, 0xfd, 0xbd, 0x00, 0x63, 0x31, 0xda, + 0x6a, 0x44, 0x9a, 0xe8, 0x79, 0x23, 0x4c, 0xc1, 0xd9, 0x44, 0x98, 0x82, 0x12, 0xc3, 0xd6, 0x44, + 0xb2, 0x9f, 0x81, 0x62, 0xd3, 0xb9, 0x2b, 0x64, 0x6e, 0xcf, 0x76, 0xee, 0x06, 0xa5, 0x3f, 0xb7, + 0xe6, 0xdc, 0xe5, 0xcf, 0xd2, 0x67, 0xe5, 0x0e, 0x59, 0x73, 0xee, 0x1e, 0x72, 0x63, 0x58, 0x76, + 0x4a, 0x5f, 0x77, 0xc3, 0xe8, 0x73, 0xff, 0x31, 0xfe, 0xcf, 0xf6, 0x1d, 0x6d, 0x84, 0xb5, 0xe5, + 0x7a, 0xc2, 0xe6, 0xa9, 0xa7, 0xb6, 0x5c, 0x2f, 0xd9, 0x96, 0xeb, 0xf5, 0xd0, 0x96, 0xeb, 0xa1, + 0x7b, 0x30, 0x28, 0x4c, 0x12, 0x45, 0x58, 0xa0, 0xf9, 0x1e, 0xda, 0x13, 0x16, 0x8d, 0xbc, 0xcd, + 0x79, 0xf9, 0xec, 0x16, 0xa5, 0x5d, 0xdb, 0x95, 0x0d, 0xa2, 0xbf, 0x6c, 0xc1, 0x98, 0xf8, 0x8d, + 0xc9, 0xdb, 0x6d, 0x12, 0x46, 0x82, 0x2d, 0xfd, 0x60, 0xef, 0x7d, 0x10, 0x15, 0x79, 0x57, 0x3e, + 0x28, 0xef, 0x19, 0x13, 0xd8, 0xb5, 0x47, 0x89, 0x5e, 0xa0, 0xbf, 0x6b, 0xc1, 0xa9, 0xa6, 0x73, + 0x97, 0xb7, 0xc8, 0xcb, 0xb0, 0x13, 0xb9, 0xbe, 0x50, 0xed, 0x7f, 0xb8, 0xb7, 0xe9, 0x4f, 0x55, + 0xe7, 0x9d, 0x94, 0xfa, 0xc7, 0x53, 0x59, 0x28, 0x5d, 0xbb, 0x9a, 0xd9, 0xaf, 0x99, 0x2d, 0x18, + 0x92, 0xeb, 0x2d, 0x43, 0xb8, 0x51, 0xd6, 0x79, 0xee, 0x23, 0x5b, 0x84, 0xea, 0xee, 0xff, 0xb4, + 0x1d, 0xb1, 0xd6, 0x1e, 0x6a, 0x3b, 0x9f, 0x81, 0x11, 0x7d, 0x8d, 0x3d, 0xd4, 0xb6, 0xde, 0x86, + 0xa9, 0x8c, 0xb5, 0xf4, 0x50, 0x9b, 0xbc, 0x03, 0x67, 0x73, 0xd7, 0xc7, 0xc3, 0x6c, 0xd8, 0xfe, + 0x8a, 0xa5, 0x9f, 0x83, 0x27, 0xa0, 0xac, 0x58, 0x32, 0x95, 0x15, 0xe7, 0x3b, 0xef, 0x9c, 0x1c, + 0x8d, 0xc5, 0x5b, 0x7a, 0xa7, 0xe9, 0xa9, 0x8e, 0xde, 0x80, 0x81, 0x06, 0x2d, 0x91, 0x86, 0xad, + 0x76, 0xf7, 0x1d, 0x19, 0x33, 0x93, 0xac, 0x3c, 0xc4, 0x82, 0x82, 0xfd, 0x0b, 0x16, 0xf4, 0x9d, + 0xc0, 0x48, 0x60, 0x73, 0x24, 0x9e, 0xcf, 0x25, 0x2d, 0x22, 0x24, 0xcf, 0x61, 0xe7, 0xce, 0xf2, + 0xdd, 0x88, 0x78, 0x21, 0xbb, 0x91, 0x33, 0x07, 0xe6, 0x27, 0x2d, 0x98, 0xba, 0xee, 0x3b, 0xf5, + 0x45, 0xa7, 0xe1, 0x78, 0x35, 0x12, 0xac, 0x7a, 0xdb, 0x47, 0xb2, 0xca, 0x2e, 0x74, 0xb5, 0xca, + 0x5e, 0x92, 0x46, 0x4d, 0x7d, 0xf9, 0xf3, 0x47, 0x39, 0xe9, 0x64, 0xe0, 0x16, 0xc3, 0xfc, 0x76, + 0x07, 0x90, 0xde, 0x4b, 0xe1, 0x23, 0x83, 0x61, 0xd0, 0xe5, 0xfd, 0x15, 0x93, 0xf8, 0x74, 0x36, + 0x87, 0x9b, 0xfa, 0x3c, 0xcd, 0xfb, 0x83, 0x17, 0x60, 0x49, 0xc8, 0x7e, 0x05, 0x32, 0x1d, 0xed, + 0xbb, 0xcb, 0x25, 0xec, 0x8f, 0xc3, 0x24, 0xab, 0x79, 0x44, 0xc9, 0x80, 0x9d, 0x90, 0xa6, 0x66, + 0x84, 0xe0, 0xb3, 0x3f, 0x6f, 0xc1, 0xf8, 0x7a, 0x22, 0x32, 0xd9, 0x45, 0xa6, 0x7f, 0xcd, 0x10, + 0xe2, 0x57, 0x59, 0x29, 0x16, 0xd0, 0x63, 0x17, 0x72, 0xfd, 0xa9, 0x05, 0x71, 0xec, 0x8b, 0x13, + 0x60, 0xdf, 0x96, 0x0c, 0xf6, 0x2d, 0x93, 0x91, 0x55, 0xdd, 0xc9, 0xe3, 0xde, 0xd0, 0x35, 0x15, + 0x15, 0xaa, 0x03, 0x0f, 0x1b, 0x93, 0xe1, 0x4b, 0x71, 0xcc, 0x0c, 0x1d, 0x25, 0xe3, 0x44, 0xd9, + 0xbf, 0x59, 0x00, 0xa4, 0x70, 0x7b, 0x8e, 0x5a, 0x95, 0xae, 0x71, 0x3c, 0x51, 0xab, 0xf6, 0x00, + 0x31, 0x0b, 0x82, 0xc0, 0xf1, 0x42, 0x4e, 0xd6, 0x15, 0x62, 0xbd, 0xa3, 0x99, 0x27, 0xcc, 0x88, + 0x26, 0xd1, 0xf5, 0x14, 0x35, 0x9c, 0xd1, 0x82, 0x66, 0x19, 0xd2, 0xdf, 0xab, 0x65, 0xc8, 0x40, + 0x17, 0x3f, 0xb8, 0x9f, 0xb1, 0x60, 0x54, 0x0d, 0xd3, 0xbb, 0xc4, 0x4a, 0x5d, 0xf5, 0x27, 0xe7, + 0x00, 0xad, 0x68, 0x5d, 0x66, 0x17, 0xcb, 0xb7, 0x33, 0x7f, 0x46, 0xa7, 0xe1, 0xde, 0x23, 0x2a, + 0x66, 0xe0, 0xac, 0xf0, 0x4f, 0x14, 0xa5, 0x87, 0x07, 0xb3, 0xa3, 0xea, 0x1f, 0x8f, 0x89, 0x1c, + 0x57, 0xa1, 0x47, 0xf2, 0x78, 0x62, 0x29, 0xa2, 0x97, 0xa1, 0xbf, 0xb5, 0xe3, 0x84, 0x24, 0xe1, + 0xcd, 0xd3, 0x5f, 0xa1, 0x85, 0x87, 0x07, 0xb3, 0x63, 0xaa, 0x02, 0x2b, 0xc1, 0x1c, 0xbb, 0xf7, + 0x58, 0x60, 0xe9, 0xc5, 0xd9, 0x35, 0x16, 0xd8, 0x1f, 0x59, 0xd0, 0xb7, 0xee, 0xd7, 0x4f, 0xe2, + 0x08, 0x78, 0xdd, 0x38, 0x02, 0x1e, 0xcb, 0x0b, 0x57, 0x9f, 0xbb, 0xfb, 0x57, 0x12, 0xbb, 0xff, + 0x7c, 0x2e, 0x85, 0xce, 0x1b, 0xbf, 0x09, 0xc3, 0x2c, 0x08, 0xbe, 0xf0, 0x5c, 0x7a, 0xd1, 0xd8, + 0xf0, 0xb3, 0x89, 0x0d, 0x3f, 0xae, 0xa1, 0x6a, 0x3b, 0xfd, 0x19, 0x18, 0x14, 0xae, 0x30, 0x49, + 0xb7, 0x50, 0x81, 0x8b, 0x25, 0xdc, 0xfe, 0xf1, 0x22, 0x18, 0x41, 0xf7, 0xd1, 0x2f, 0x59, 0x30, + 0x17, 0x70, 0x13, 0xd9, 0x7a, 0xb9, 0x1d, 0xb8, 0xde, 0x76, 0xb5, 0xb6, 0x43, 0xea, 0xed, 0x86, + 0xeb, 0x6d, 0xaf, 0x6e, 0x7b, 0xbe, 0x2a, 0x5e, 0xbe, 0x4b, 0x6a, 0x6d, 0xa6, 0x76, 0xeb, 0x12, + 0xe1, 0x5f, 0x99, 0x9a, 0xbf, 0x70, 0xff, 0x60, 0x76, 0x0e, 0x1f, 0x89, 0x36, 0x3e, 0x62, 0x5f, + 0xd0, 0xaf, 0x59, 0x30, 0xcf, 0x63, 0xd1, 0xf7, 0xde, 0xff, 0x0e, 0xaf, 0xe5, 0x8a, 0x24, 0x15, + 0x13, 0xd9, 0x20, 0x41, 0x73, 0xf1, 0x43, 0x62, 0x40, 0xe7, 0x2b, 0x47, 0x6b, 0x0b, 0x1f, 0xb5, + 0x73, 0xf6, 0x3f, 0x29, 0xc2, 0xa8, 0x88, 0x19, 0x25, 0xee, 0x80, 0x97, 0x8d, 0x25, 0xf1, 0x78, + 0x62, 0x49, 0x4c, 0x1a, 0xc8, 0xc7, 0x73, 0xfc, 0x87, 0x30, 0x49, 0x0f, 0xe7, 0xab, 0xc4, 0x09, + 0xa2, 0x4d, 0xe2, 0x70, 0x83, 0xaf, 0xe2, 0x91, 0x4f, 0x7f, 0x25, 0x9f, 0xbc, 0x9e, 0x24, 0x86, + 0xd3, 0xf4, 0xbf, 0x95, 0xee, 0x1c, 0x0f, 0x26, 0x52, 0x61, 0xbf, 0x3e, 0x01, 0x25, 0xe5, 0xc7, + 0x21, 0x0e, 0x9d, 0xce, 0xd1, 0xf3, 0x92, 0x14, 0xb8, 0xf8, 0x2b, 0xf6, 0x21, 0x8a, 0xc9, 0xd9, + 0x7f, 0xaf, 0x60, 0x34, 0xc8, 0x27, 0x71, 0x1d, 0x86, 0x9c, 0x30, 0x74, 0xb7, 0x3d, 0x52, 0xef, + 0x24, 0xa1, 0x4c, 0x35, 0xc3, 0x7c, 0x69, 0x16, 0x44, 0x4d, 0xac, 0x68, 0xa0, 0xab, 0xdc, 0xac, + 0x6e, 0x8f, 0x74, 0x12, 0x4f, 0xa6, 0xa8, 0x81, 0x34, 0xbc, 0xdb, 0x23, 0x58, 0xd4, 0x47, 0x9f, + 0xe4, 0x76, 0x8f, 0xd7, 0x3c, 0xff, 0x8e, 0x77, 0xc5, 0xf7, 0x65, 0x5c, 0x86, 0xde, 0x08, 0x4e, + 0x4a, 0x6b, 0x47, 0x55, 0x1d, 0x9b, 0xd4, 0x7a, 0x8b, 0xa3, 0xf9, 0x59, 0x60, 0xb1, 0xb7, 0x4d, + 0xb7, 0xe9, 0x10, 0x11, 0x18, 0x17, 0x01, 0xc9, 0x64, 0x99, 0x18, 0xbb, 0xcc, 0xa7, 0x9c, 0x59, + 0x3b, 0x16, 0xa4, 0x5f, 0x33, 0x49, 0xe0, 0x24, 0x4d, 0xfb, 0xa7, 0x2c, 0x60, 0x2e, 0xa4, 0x27, + 0xc0, 0x8f, 0x7c, 0xc4, 0xe4, 0x47, 0xa6, 0xf3, 0x06, 0x39, 0x87, 0x15, 0x79, 0x89, 0xaf, 0xac, + 0x4a, 0xe0, 0xdf, 0xdd, 0x17, 0xc6, 0x2a, 0xdd, 0xdf, 0x1f, 0xf6, 0xff, 0xb1, 0xf8, 0x21, 0xa6, + 0xbc, 0x2c, 0xd0, 0x77, 0xc2, 0x50, 0xcd, 0x69, 0x39, 0x35, 0x9e, 0x21, 0x26, 0x57, 0xa2, 0x67, + 0x54, 0x9a, 0x5b, 0x12, 0x35, 0xb8, 0x84, 0x4a, 0x06, 0xb6, 0x1b, 0x92, 0xc5, 0x5d, 0xa5, 0x52, + 0xaa, 0xc9, 0x99, 0x5d, 0x18, 0x35, 0x88, 0x3d, 0x54, 0x71, 0xc6, 0x77, 0xf2, 0x2b, 0x56, 0x05, + 0x62, 0x6c, 0xc2, 0xa4, 0xa7, 0xfd, 0xa7, 0x17, 0x8a, 0x7c, 0x5c, 0x3e, 0xd9, 0xed, 0x12, 0x65, + 0xb7, 0x8f, 0xe6, 0x9d, 0x9a, 0x20, 0x83, 0xd3, 0x94, 0xed, 0x9f, 0xb0, 0xe0, 0x11, 0x1d, 0x51, + 0x73, 0x80, 0xe9, 0xa6, 0x24, 0x29, 0xc3, 0x90, 0xdf, 0x22, 0x81, 0x13, 0xf9, 0x81, 0xb8, 0x35, + 0x2e, 0xc9, 0x41, 0xbf, 0x21, 0xca, 0x0f, 0x45, 0xbc, 0x73, 0x49, 0x5d, 0x96, 0x63, 0x55, 0x93, + 0xbe, 0x3e, 0xd9, 0x60, 0x84, 0xc2, 0xd5, 0x89, 0x9d, 0x01, 0x4c, 0x93, 0x1e, 0x62, 0x01, 0xb1, + 0xbf, 0x6e, 0xf1, 0x85, 0xa5, 0x77, 0x1d, 0xbd, 0x0d, 0x13, 0x4d, 0x27, 0xaa, 0xed, 0x2c, 0xdf, + 0x6d, 0x05, 0x5c, 0xe5, 0x24, 0xc7, 0xe9, 0xd9, 0x6e, 0xe3, 0xa4, 0x7d, 0x64, 0x6c, 0xca, 0xb9, + 0x96, 0x20, 0x86, 0x53, 0xe4, 0xd1, 0x26, 0x0c, 0xb3, 0x32, 0xe6, 0xc5, 0x17, 0x76, 0x62, 0x0d, + 0xf2, 0x5a, 0x53, 0xc6, 0x08, 0x6b, 0x31, 0x1d, 0xac, 0x13, 0xb5, 0xbf, 0x5c, 0xe4, 0xbb, 0x9d, + 0xb1, 0xf2, 0xcf, 0xc0, 0x60, 0xcb, 0xaf, 0x2f, 0xad, 0x96, 0xb1, 0x98, 0x05, 0x75, 0x8d, 0x54, + 0x78, 0x31, 0x96, 0x70, 0x74, 0x09, 0x86, 0xc4, 0x4f, 0xa9, 0x22, 0x64, 0x67, 0xb3, 0xc0, 0x0b, + 0xb1, 0x82, 0xa2, 0x17, 0x00, 0x5a, 0x81, 0xbf, 0xe7, 0xd6, 0x59, 0x74, 0x89, 0xa2, 0x69, 0x47, + 0x54, 0x51, 0x10, 0xac, 0x61, 0xa1, 0xd7, 0x60, 0xb4, 0xed, 0x85, 0x9c, 0x1d, 0xd1, 0x62, 0xc9, + 0x2a, 0x0b, 0x97, 0x9b, 0x3a, 0x10, 0x9b, 0xb8, 0x68, 0x01, 0x06, 0x22, 0x87, 0xd9, 0xc5, 0xf4, + 0xe7, 0x9b, 0xfb, 0x6e, 0x50, 0x0c, 0x3d, 0x19, 0x09, 0xad, 0x80, 0x45, 0x45, 0xf4, 0x09, 0xe9, + 0x50, 0xcb, 0x0f, 0x76, 0x61, 0x67, 0xdf, 0xdb, 0x25, 0xa0, 0xb9, 0xd3, 0x0a, 0xfb, 0x7d, 0x83, + 0x16, 0x7a, 0x15, 0x80, 0xdc, 0x8d, 0x48, 0xe0, 0x39, 0x0d, 0x65, 0xcd, 0xa6, 0xf8, 0x82, 0xb2, + 0xbf, 0xee, 0x47, 0x37, 0x43, 0xb2, 0xac, 0x30, 0xb0, 0x86, 0x6d, 0xff, 0x5a, 0x09, 0x20, 0xe6, + 0xdb, 0xd1, 0xbd, 0xd4, 0xc1, 0xf5, 0x5c, 0x67, 0x4e, 0xff, 0xf8, 0x4e, 0x2d, 0xf4, 0x7d, 0x16, + 0x0c, 0x3b, 0x8d, 0x86, 0x5f, 0x73, 0x78, 0xb4, 0xdf, 0x42, 0xe7, 0x83, 0x53, 0xb4, 0xbf, 0x10, + 0xd7, 0xe0, 0x5d, 0x78, 0x51, 0xae, 0x50, 0x0d, 0xd2, 0xb5, 0x17, 0x7a, 0xc3, 0xe8, 0x03, 0xf2, + 0xa9, 0x58, 0x34, 0x86, 0x52, 0x3d, 0x15, 0x4b, 0xec, 0x8e, 0xd0, 0x5f, 0x89, 0x37, 0x8d, 0x57, + 0x62, 0x5f, 0xbe, 0xc7, 0xa0, 0xc1, 0xbe, 0x76, 0x7b, 0x20, 0xa2, 0x8a, 0x1e, 0x3d, 0xa0, 0x3f, + 0xdf, 0x3d, 0x4f, 0x7b, 0x27, 0x75, 0x89, 0x1c, 0xf0, 0x19, 0x18, 0xaf, 0x9b, 0x4c, 0x80, 0x58, + 0x89, 0x4f, 0xe7, 0xd1, 0x4d, 0xf0, 0x0c, 0xf1, 0xb5, 0x9f, 0x00, 0xe0, 0x24, 0x61, 0x54, 0xe1, + 0xc1, 0x24, 0x56, 0xbd, 0x2d, 0x5f, 0xf8, 0x7a, 0xd8, 0xb9, 0x73, 0xb9, 0x1f, 0x46, 0xa4, 0x49, + 0x31, 0xe3, 0xdb, 0x7d, 0x5d, 0xd4, 0xc5, 0x8a, 0x0a, 0x7a, 0x03, 0x06, 0x98, 0x7f, 0x56, 0x38, + 0x3d, 0x94, 0x2f, 0x71, 0x36, 0xa3, 0xa3, 0xc5, 0x1b, 0x92, 0xfd, 0x0d, 0xb1, 0xa0, 0x80, 0xae, + 0x4a, 0xef, 0xc7, 0x70, 0xd5, 0xbb, 0x19, 0x12, 0xe6, 0xfd, 0x58, 0x5a, 0x7c, 0x32, 0x76, 0x6c, + 0xe4, 0xe5, 0x99, 0x29, 0xcb, 0x8c, 0x9a, 0x94, 0x8b, 0x12, 0xff, 0x65, 0x26, 0xb4, 0x69, 0xc8, + 0xef, 0x9e, 0x99, 0x2d, 0x2d, 0x1e, 0xce, 0x5b, 0x26, 0x09, 0x9c, 0xa4, 0x49, 0x39, 0x52, 0xbe, + 0xeb, 0x85, 0xb7, 0x48, 0xb7, 0xb3, 0x83, 0x3f, 0xc4, 0xd9, 0x6d, 0xc4, 0x4b, 0xb0, 0xa8, 0x7f, + 0xa2, 0xec, 0xc1, 0x8c, 0x07, 0x13, 0xc9, 0x2d, 0xfa, 0x50, 0xd9, 0x91, 0xdf, 0xeb, 0x83, 0x31, + 0x73, 0x49, 0xa1, 0x79, 0x28, 0x09, 0x22, 0x2a, 0x9b, 0x80, 0xda, 0x25, 0x6b, 0x12, 0x80, 0x63, + 0x1c, 0x96, 0x44, 0x82, 0x55, 0xd7, 0xcc, 0x83, 0xe3, 0x24, 0x12, 0x0a, 0x82, 0x35, 0x2c, 0xfa, + 0xb0, 0xda, 0xf4, 0xfd, 0x48, 0x5d, 0x48, 0x6a, 0xdd, 0x2d, 0xb2, 0x52, 0x2c, 0xa0, 0xf4, 0x22, + 0xda, 0x25, 0x81, 0x47, 0x1a, 0x66, 0xdc, 0x61, 0x75, 0x11, 0x5d, 0xd3, 0x81, 0xd8, 0xc4, 0xa5, + 0xd7, 0xa9, 0x1f, 0xb2, 0x85, 0x2c, 0x9e, 0x6f, 0xb1, 0xb9, 0x75, 0x95, 0x3b, 0x60, 0x4b, 0x38, + 0xfa, 0x38, 0x3c, 0xa2, 0x62, 0x2b, 0x61, 0xae, 0xcd, 0x90, 0x2d, 0x0e, 0x18, 0xd2, 0x96, 0x47, + 0x96, 0xb2, 0xd1, 0x70, 0x5e, 0x7d, 0xf4, 0x3a, 0x8c, 0x09, 0x16, 0x5f, 0x52, 0x1c, 0x34, 0x2d, + 0x8c, 0xae, 0x19, 0x50, 0x9c, 0xc0, 0x96, 0x91, 0x93, 0x19, 0x97, 0x2d, 0x29, 0x0c, 0xa5, 0x23, + 0x27, 0xeb, 0x70, 0x9c, 0xaa, 0x81, 0x16, 0x60, 0x9c, 0xf3, 0x60, 0xae, 0xb7, 0xcd, 0xe7, 0x44, + 0x38, 0x73, 0xa9, 0x2d, 0x75, 0xc3, 0x04, 0xe3, 0x24, 0x3e, 0x7a, 0x05, 0x46, 0x9c, 0xa0, 0xb6, + 0xe3, 0x46, 0xa4, 0x16, 0xb5, 0x03, 0xee, 0xe5, 0xa5, 0x99, 0x68, 0x2d, 0x68, 0x30, 0x6c, 0x60, + 0xda, 0xf7, 0x60, 0x2a, 0x23, 0x32, 0x03, 0x5d, 0x38, 0x4e, 0xcb, 0x95, 0xdf, 0x94, 0xb0, 0x70, + 0x5e, 0xa8, 0xac, 0xca, 0xaf, 0xd1, 0xb0, 0xe8, 0xea, 0x64, 0x11, 0x1c, 0xb4, 0xc4, 0x87, 0x6a, + 0x75, 0xae, 0x48, 0x00, 0x8e, 0x71, 0xec, 0xff, 0x5e, 0x80, 0xf1, 0x0c, 0xdd, 0x0a, 0x4b, 0xbe, + 0x97, 0x78, 0xa4, 0xc4, 0xb9, 0xf6, 0xcc, 0x40, 0xdc, 0x85, 0x23, 0x04, 0xe2, 0x2e, 0x76, 0x0b, + 0xc4, 0xdd, 0xf7, 0x4e, 0x02, 0x71, 0x9b, 0x23, 0xd6, 0xdf, 0xd3, 0x88, 0x65, 0x04, 0xef, 0x1e, + 0x38, 0x62, 0xf0, 0x6e, 0x63, 0xd0, 0x07, 0x7b, 0x18, 0xf4, 0x1f, 0x29, 0xc0, 0x44, 0xd2, 0x94, + 0xf4, 0x04, 0xe4, 0xb6, 0x6f, 0x18, 0x72, 0xdb, 0x4b, 0xbd, 0x38, 0xdf, 0xe6, 0xca, 0x70, 0x71, + 0x42, 0x86, 0xfb, 0xfe, 0x9e, 0xa8, 0x75, 0x96, 0xe7, 0xfe, 0xf5, 0x02, 0x9c, 0xce, 0xf4, 0xfe, + 0x3d, 0x81, 0xb1, 0xb9, 0x61, 0x8c, 0xcd, 0xf3, 0x3d, 0x3b, 0x26, 0xe7, 0x0e, 0xd0, 0xed, 0xc4, + 0x00, 0xcd, 0xf7, 0x4e, 0xb2, 0xf3, 0x28, 0x7d, 0xad, 0x08, 0xe7, 0x33, 0xeb, 0xc5, 0x62, 0xcf, + 0x15, 0x43, 0xec, 0xf9, 0x42, 0x42, 0xec, 0x69, 0x77, 0xae, 0x7d, 0x3c, 0x72, 0x50, 0xe1, 0xa0, + 0xcb, 0xc2, 0x0c, 0x3c, 0xa0, 0x0c, 0xd4, 0x70, 0xd0, 0x55, 0x84, 0xb0, 0x49, 0xf7, 0x5b, 0x49, + 0xf6, 0xf9, 0xaf, 0x2d, 0x38, 0x9b, 0x39, 0x37, 0x27, 0x20, 0xeb, 0x5a, 0x37, 0x65, 0x5d, 0xcf, + 0xf4, 0xbc, 0x5a, 0x73, 0x84, 0x5f, 0x5f, 0xee, 0xcf, 0xf9, 0x16, 0xf6, 0x92, 0xbf, 0x01, 0xc3, + 0x4e, 0xad, 0x46, 0xc2, 0x70, 0xcd, 0xaf, 0xab, 0x58, 0xc3, 0xcf, 0xb3, 0x77, 0x56, 0x5c, 0x7c, + 0x78, 0x30, 0x3b, 0x93, 0x24, 0x11, 0x83, 0xb1, 0x4e, 0x01, 0x7d, 0x12, 0x86, 0x42, 0x71, 0x6f, + 0x8a, 0xb9, 0x7f, 0xb1, 0xc7, 0xc1, 0x71, 0x36, 0x49, 0xc3, 0x0c, 0x86, 0xa4, 0x24, 0x15, 0x8a, + 0xa4, 0x19, 0x38, 0xa5, 0x70, 0xac, 0x81, 0x53, 0x5e, 0x00, 0xd8, 0x53, 0x8f, 0x81, 0xa4, 0xfc, + 0x41, 0x7b, 0x26, 0x68, 0x58, 0xe8, 0xa3, 0x30, 0x11, 0xf2, 0x68, 0x81, 0x4b, 0x0d, 0x27, 0x64, + 0x7e, 0x34, 0x62, 0x15, 0xb2, 0x80, 0x4b, 0xd5, 0x04, 0x0c, 0xa7, 0xb0, 0xd1, 0x8a, 0x6c, 0x95, + 0x85, 0x36, 0xe4, 0x0b, 0xf3, 0x62, 0xdc, 0xa2, 0x48, 0xfd, 0x7b, 0x2a, 0x39, 0xfc, 0x6c, 0xe0, + 0xb5, 0x9a, 0xe8, 0x93, 0x00, 0x74, 0xf9, 0x08, 0x39, 0xc4, 0x60, 0xfe, 0xe1, 0x49, 0x4f, 0x95, + 0x7a, 0xa6, 0x71, 0x33, 0xf3, 0xa9, 0x2d, 0x2b, 0x22, 0x58, 0x23, 0x88, 0xb6, 0x60, 0x34, 0xfe, + 0x17, 0x67, 0xc6, 0x3c, 0x62, 0x0b, 0x4c, 0xee, 0x5d, 0xd6, 0xe9, 0x60, 0x93, 0xac, 0xfd, 0x63, + 0x83, 0xf0, 0x68, 0x87, 0xb3, 0x18, 0x2d, 0x98, 0xfa, 0xde, 0x67, 0x93, 0x8f, 0xf8, 0x99, 0xcc, + 0xca, 0xc6, 0xab, 0x3e, 0xb1, 0xe4, 0x0b, 0xef, 0x78, 0xc9, 0xff, 0x90, 0xa5, 0x89, 0x57, 0xb8, + 0x65, 0xe9, 0x47, 0x8e, 0x78, 0xc7, 0x1c, 0xa3, 0xbc, 0x65, 0x2b, 0x43, 0x68, 0xf1, 0x42, 0xcf, + 0xdd, 0xe9, 0x5d, 0x8a, 0xf1, 0x15, 0x0b, 0x90, 0x10, 0xaf, 0x90, 0xba, 0xda, 0x50, 0x42, 0x9e, + 0x71, 0xe5, 0xa8, 0xdf, 0xbf, 0x90, 0xa2, 0xc4, 0x47, 0xe2, 0x55, 0x79, 0x19, 0xa4, 0x11, 0xba, + 0x8e, 0x49, 0x46, 0xf7, 0xd0, 0xc7, 0x59, 0x34, 0x5d, 0xf7, 0x9e, 0xe0, 0x80, 0xc4, 0x86, 0x7b, + 0x59, 0x44, 0xd2, 0x55, 0xe5, 0x94, 0xd5, 0xcd, 0xec, 0xae, 0x8e, 0x84, 0x0d, 0x52, 0x27, 0xfb, + 0xfe, 0x6e, 0xc3, 0x23, 0x39, 0x43, 0xf6, 0x50, 0x9f, 0xe1, 0xbf, 0x61, 0xc1, 0xb9, 0x8e, 0x61, + 0x61, 0xbe, 0x09, 0x19, 0x44, 0xfb, 0x73, 0x16, 0x64, 0x4f, 0xb6, 0x61, 0x56, 0x36, 0x0f, 0xa5, + 0x1a, 0x2d, 0xd4, 0xfc, 0x80, 0xe3, 0x00, 0x09, 0x12, 0x80, 0x63, 0x1c, 0xc3, 0x7a, 0xac, 0xd0, + 0xd5, 0x7a, 0xec, 0x97, 0x2d, 0x48, 0x1d, 0xf2, 0x27, 0xc0, 0x6d, 0xac, 0x9a, 0xdc, 0xc6, 0x93, + 0xbd, 0x8c, 0x66, 0x0e, 0xa3, 0xf1, 0x87, 0xe3, 0x70, 0x26, 0xc7, 0x2d, 0x6f, 0x0f, 0x26, 0xb7, + 0x6b, 0xc4, 0xf4, 0xb0, 0xee, 0x14, 0x79, 0xa8, 0xa3, 0x3b, 0x36, 0x4b, 0x0e, 0x3b, 0x99, 0x42, + 0xc1, 0xe9, 0x26, 0xd0, 0xe7, 0x2c, 0x38, 0xe5, 0xdc, 0x09, 0x97, 0x29, 0xd7, 0xe8, 0xd6, 0x16, + 0x1b, 0x7e, 0x6d, 0x97, 0x5e, 0xc9, 0x72, 0x23, 0xbc, 0x94, 0x29, 0xc9, 0xbb, 0x5d, 0x4d, 0xe1, + 0x1b, 0xcd, 0xb3, 0x6c, 0xb9, 0x59, 0x58, 0x38, 0xb3, 0x2d, 0x84, 0x45, 0x0a, 0x05, 0xfa, 0x26, + 0xed, 0x10, 0x03, 0x20, 0xcb, 0x7f, 0x92, 0xb3, 0x41, 0x12, 0x82, 0x15, 0x1d, 0xf4, 0x69, 0x28, + 0x6d, 0x4b, 0x77, 0xdf, 0x0c, 0x36, 0x2b, 0x1e, 0xc8, 0xce, 0x4e, 0xd0, 0x5c, 0x1d, 0xaf, 0x90, + 0x70, 0x4c, 0x14, 0xbd, 0x0e, 0x45, 0x6f, 0x2b, 0xec, 0x94, 0x70, 0x36, 0x61, 0x77, 0xc9, 0x23, + 0x6d, 0xac, 0xaf, 0x54, 0x31, 0xad, 0x88, 0xae, 0x42, 0x31, 0xd8, 0xac, 0x0b, 0x31, 0x74, 0xe6, + 0x26, 0xc5, 0x8b, 0xe5, 0x9c, 0x5e, 0x31, 0x4a, 0x78, 0xb1, 0x8c, 0x29, 0x09, 0x54, 0x81, 0x7e, + 0xe6, 0xcb, 0x26, 0x98, 0x9a, 0xcc, 0xe7, 0x5b, 0x07, 0x9f, 0x50, 0x1e, 0x8e, 0x83, 0x21, 0x60, + 0x4e, 0x08, 0x6d, 0xc0, 0x40, 0x8d, 0x25, 0x27, 0x15, 0x5c, 0xcc, 0x07, 0x32, 0x05, 0xce, 0x1d, + 0xb2, 0xb6, 0x0a, 0xf9, 0x2b, 0xc3, 0xc0, 0x82, 0x16, 0xa3, 0x4a, 0x5a, 0x3b, 0x5b, 0xa1, 0x48, + 0xde, 0x9d, 0x4d, 0xb5, 0x43, 0x32, 0x62, 0x41, 0x95, 0x61, 0x60, 0x41, 0x0b, 0xbd, 0x0a, 0x85, + 0xad, 0x9a, 0xf0, 0x53, 0xcb, 0x94, 0x3c, 0x9b, 0xc1, 0x52, 0x16, 0x07, 0xee, 0x1f, 0xcc, 0x16, + 0x56, 0x96, 0x70, 0x61, 0xab, 0x86, 0xd6, 0x61, 0x70, 0x8b, 0x87, 0x57, 0x10, 0xc2, 0xe5, 0xa7, + 0xb3, 0x23, 0x3f, 0xa4, 0x22, 0x30, 0x70, 0x9f, 0x27, 0x01, 0xc0, 0x92, 0x08, 0xcb, 0x48, 0xa0, + 0xc2, 0x44, 0x88, 0x28, 0x75, 0x73, 0x47, 0x0b, 0xed, 0xc1, 0x99, 0xcc, 0x38, 0xd8, 0x04, 0xd6, + 0x28, 0xd2, 0x55, 0xed, 0xdc, 0x6b, 0x07, 0x2c, 0x14, 0xb8, 0x08, 0x67, 0x94, 0xb9, 0xaa, 0x17, + 0x24, 0x52, 0xa7, 0x55, 0xad, 0x90, 0x70, 0x4c, 0x14, 0xed, 0xc2, 0xe8, 0x5e, 0xd8, 0xda, 0x21, + 0x72, 0x4b, 0xb3, 0xe8, 0x46, 0x39, 0xfc, 0xd1, 0x2d, 0x81, 0xe8, 0x06, 0x51, 0xdb, 0x69, 0xa4, + 0x4e, 0x21, 0xc6, 0xcb, 0xde, 0xd2, 0x89, 0x61, 0x93, 0x36, 0x1d, 0xfe, 0xb7, 0xdb, 0xfe, 0xe6, + 0x7e, 0x44, 0x44, 0x70, 0xb9, 0xcc, 0xe1, 0x7f, 0x93, 0xa3, 0xa4, 0x87, 0x5f, 0x00, 0xb0, 0x24, + 0x82, 0x6e, 0x89, 0xe1, 0x61, 0xa7, 0xe7, 0x44, 0x7e, 0x04, 0xd8, 0x05, 0x89, 0x94, 0x33, 0x28, + 0xec, 0xb4, 0x8c, 0x49, 0xb1, 0x53, 0xb2, 0xb5, 0xe3, 0x47, 0xbe, 0x97, 0x38, 0xa1, 0x27, 0xf3, + 0x4f, 0xc9, 0x4a, 0x06, 0x7e, 0xfa, 0x94, 0xcc, 0xc2, 0xc2, 0x99, 0x6d, 0xa1, 0x3a, 0x8c, 0xb5, + 0xfc, 0x20, 0xba, 0xe3, 0x07, 0x72, 0x7d, 0xa1, 0x0e, 0xc2, 0x31, 0x03, 0x53, 0xb4, 0xc8, 0xe2, + 0x36, 0x9a, 0x10, 0x9c, 0xa0, 0x89, 0x3e, 0x06, 0x83, 0x61, 0xcd, 0x69, 0x90, 0xd5, 0x1b, 0xd3, + 0x53, 0xf9, 0xd7, 0x4f, 0x95, 0xa3, 0xe4, 0xac, 0x2e, 0x1e, 0x1d, 0x83, 0xa3, 0x60, 0x49, 0x0e, + 0xad, 0x40, 0x3f, 0xcb, 0x38, 0xc7, 0x22, 0x21, 0xe6, 0x04, 0xb2, 0x4d, 0x59, 0xc1, 0xf3, 0xb3, + 0x89, 0x15, 0x63, 0x5e, 0x9d, 0xee, 0x01, 0xf1, 0x46, 0xf4, 0xc3, 0xe9, 0xd3, 0xf9, 0x7b, 0x40, + 0x3c, 0x2d, 0x6f, 0x54, 0x3b, 0xed, 0x01, 0x85, 0x84, 0x63, 0xa2, 0xf4, 0x64, 0xa6, 0xa7, 0xe9, + 0x99, 0x0e, 0xe6, 0x5b, 0xb9, 0x67, 0x29, 0x3b, 0x99, 0xe9, 0x49, 0x4a, 0x49, 0xd8, 0xbf, 0x33, + 0x98, 0xe6, 0x59, 0x98, 0x54, 0xe1, 0x7b, 0xac, 0x94, 0xc2, 0xf9, 0x83, 0xbd, 0x0a, 0x39, 0x8f, + 0xf1, 0x29, 0xf4, 0x39, 0x0b, 0xce, 0xb4, 0x32, 0x3f, 0x44, 0x30, 0x00, 0xbd, 0xc9, 0x4a, 0xf9, + 0xa7, 0xab, 0xa8, 0x99, 0xd9, 0x70, 0x9c, 0xd3, 0x52, 0xf2, 0xb9, 0x59, 0x7c, 0xc7, 0xcf, 0xcd, + 0x35, 0x18, 0xaa, 0xf1, 0xa7, 0x48, 0xc7, 0x64, 0xdd, 0xc9, 0xb7, 0x37, 0x63, 0x25, 0xc4, 0x1b, + 0x66, 0x0b, 0x2b, 0x12, 0xe8, 0x87, 0x2d, 0x38, 0x97, 0xec, 0x3a, 0x26, 0x0c, 0x2c, 0x42, 0x6d, + 0x72, 0x81, 0xc6, 0x8a, 0xf8, 0xfe, 0x14, 0xff, 0x6f, 0x20, 0x1f, 0x76, 0x43, 0xc0, 0x9d, 0x1b, + 0x43, 0xe5, 0x0c, 0x89, 0xca, 0x80, 0xa9, 0x45, 0xea, 0x41, 0xaa, 0xf2, 0x12, 0x8c, 0x34, 0xfd, + 0xb6, 0x17, 0x09, 0x6b, 0x2f, 0x61, 0x79, 0xc2, 0x2c, 0x2e, 0xd6, 0xb4, 0x72, 0x6c, 0x60, 0x25, + 0x64, 0x31, 0x43, 0x0f, 0x2c, 0x8b, 0x79, 0x0b, 0x46, 0x3c, 0xcd, 0x3c, 0x59, 0xf0, 0x03, 0x17, + 0xf3, 0xc3, 0xe4, 0xea, 0xc6, 0xcc, 0xbc, 0x97, 0x7a, 0x09, 0x36, 0xa8, 0x9d, 0xac, 0x19, 0xd8, + 0x97, 0xac, 0x0c, 0xa6, 0x9e, 0x8b, 0x62, 0x3e, 0x6c, 0x8a, 0x62, 0x2e, 0x26, 0x45, 0x31, 0x29, + 0x0d, 0x82, 0x21, 0x85, 0xe9, 0x3d, 0x0b, 0x50, 0xaf, 0xa1, 0x36, 0xed, 0x06, 0x5c, 0xe8, 0x76, + 0x2d, 0x31, 0xb3, 0xbf, 0xba, 0xd2, 0x17, 0xc7, 0x66, 0x7f, 0xf5, 0xd5, 0x32, 0x66, 0x90, 0x5e, + 0x83, 0x38, 0xd9, 0xff, 0xd5, 0x82, 0x62, 0xc5, 0xaf, 0x9f, 0xc0, 0x83, 0xf7, 0x23, 0xc6, 0x83, + 0xf7, 0xd1, 0xec, 0x0b, 0xb1, 0x9e, 0xab, 0xff, 0x58, 0x4e, 0xe8, 0x3f, 0xce, 0xe5, 0x11, 0xe8, + 0xac, 0xed, 0xf8, 0xc9, 0x22, 0x0c, 0x57, 0xfc, 0xba, 0xb2, 0xb9, 0xff, 0x67, 0x0f, 0x62, 0x73, + 0x9f, 0x9b, 0xcb, 0x42, 0xa3, 0xcc, 0xac, 0x05, 0xa5, 0xbb, 0xf1, 0x37, 0x99, 0xe9, 0xfd, 0x6d, + 0xe2, 0x6e, 0xef, 0x44, 0xa4, 0x9e, 0xfc, 0x9c, 0x93, 0x33, 0xbd, 0xff, 0x9d, 0x02, 0x8c, 0x27, + 0x5a, 0x47, 0x0d, 0x18, 0x6d, 0xe8, 0xd2, 0x75, 0xb1, 0x4e, 0x1f, 0x48, 0x30, 0x2f, 0x4c, 0x97, + 0xb5, 0x22, 0x6c, 0x12, 0x47, 0x73, 0x00, 0x4a, 0xdd, 0x2c, 0xc5, 0xab, 0x8c, 0xeb, 0x57, 0xfa, + 0xe8, 0x10, 0x6b, 0x18, 0xe8, 0x65, 0x18, 0x8e, 0xfc, 0x96, 0xdf, 0xf0, 0xb7, 0xf7, 0xaf, 0x11, + 0x19, 0xdf, 0x4b, 0x19, 0x24, 0x6e, 0xc4, 0x20, 0xac, 0xe3, 0xa1, 0xbb, 0x30, 0xa9, 0x88, 0x54, + 0x8f, 0x41, 0xe3, 0xc0, 0xa4, 0x0a, 0xeb, 0x49, 0x8a, 0x38, 0xdd, 0x88, 0xfd, 0xd3, 0x45, 0x3e, + 0xc4, 0x5e, 0xe4, 0xbe, 0xb7, 0x1b, 0xde, 0xdd, 0xbb, 0xe1, 0x6b, 0x16, 0x4c, 0xd0, 0xd6, 0x99, + 0xb5, 0x95, 0xbc, 0xe6, 0x55, 0x60, 0x6e, 0xab, 0x43, 0x60, 0xee, 0x8b, 0xf4, 0xd4, 0xac, 0xfb, + 0xed, 0x48, 0xc8, 0xee, 0xb4, 0x63, 0x91, 0x96, 0x62, 0x01, 0x15, 0x78, 0x24, 0x08, 0x84, 0x87, + 0xa8, 0x8e, 0x47, 0x82, 0x00, 0x0b, 0xa8, 0x8c, 0xdb, 0xdd, 0x97, 0x1d, 0xb7, 0x9b, 0x87, 0x5f, + 0x15, 0x76, 0x39, 0x82, 0xe1, 0xd2, 0xc2, 0xaf, 0x4a, 0x83, 0x9d, 0x18, 0xc7, 0xfe, 0x4a, 0x11, + 0x46, 0x2a, 0x7e, 0x3d, 0x56, 0x35, 0xbf, 0x64, 0xa8, 0x9a, 0x2f, 0x24, 0x54, 0xcd, 0x13, 0x3a, + 0xee, 0x7b, 0x8a, 0xe5, 0x6f, 0x94, 0x62, 0xf9, 0x1f, 0x5b, 0x6c, 0xd6, 0xca, 0xeb, 0x55, 0x6e, + 0xbc, 0x87, 0x2e, 0xc3, 0x30, 0x3b, 0x60, 0x98, 0x4b, 0xb2, 0xd4, 0xbf, 0xb2, 0x7c, 0x54, 0xeb, + 0x71, 0x31, 0xd6, 0x71, 0xd0, 0x25, 0x18, 0x0a, 0x89, 0x13, 0xd4, 0x76, 0xd4, 0xe9, 0x2a, 0x94, + 0xa5, 0xbc, 0x0c, 0x2b, 0x28, 0x7a, 0x33, 0x8e, 0xfc, 0x59, 0xcc, 0x77, 0x71, 0xd4, 0xfb, 0xc3, + 0xb7, 0x48, 0x7e, 0xb8, 0x4f, 0xfb, 0x36, 0xa0, 0x34, 0x7e, 0x0f, 0xb1, 0xe9, 0x66, 0xcd, 0xd8, + 0x74, 0xa5, 0x54, 0x5c, 0xba, 0x3f, 0xb1, 0x60, 0xac, 0xe2, 0xd7, 0xe9, 0xd6, 0xfd, 0x56, 0xda, + 0xa7, 0x7a, 0xd8, 0xe3, 0x81, 0x0e, 0x61, 0x8f, 0x9f, 0x80, 0xfe, 0x8a, 0x5f, 0x5f, 0xad, 0x74, + 0x8a, 0x2f, 0x60, 0xff, 0x0d, 0x0b, 0x06, 0x2b, 0x7e, 0xfd, 0x04, 0xd4, 0x02, 0x1f, 0x36, 0xd5, + 0x02, 0x8f, 0xe4, 0xac, 0x9b, 0x1c, 0x4d, 0xc0, 0x5f, 0xeb, 0x83, 0x51, 0xda, 0x4f, 0x7f, 0x5b, + 0x4e, 0xa5, 0x31, 0x6c, 0x56, 0x0f, 0xc3, 0x46, 0xb9, 0x70, 0xbf, 0xd1, 0xf0, 0xef, 0x24, 0xa7, + 0x75, 0x85, 0x95, 0x62, 0x01, 0x45, 0xcf, 0xc1, 0x50, 0x2b, 0x20, 0x7b, 0xae, 0x2f, 0xd8, 0x5b, + 0x4d, 0xc9, 0x52, 0x11, 0xe5, 0x58, 0x61, 0xd0, 0x67, 0x61, 0xe8, 0x7a, 0xf4, 0x2a, 0xaf, 0xf9, + 0x5e, 0x9d, 0x4b, 0xce, 0x8b, 0x22, 0x37, 0x87, 0x56, 0x8e, 0x0d, 0x2c, 0x74, 0x1b, 0x4a, 0xec, + 0x3f, 0x3b, 0x76, 0x8e, 0x9e, 0xe5, 0x55, 0x64, 0xfd, 0x13, 0x04, 0x70, 0x4c, 0x0b, 0xbd, 0x00, + 0x10, 0xc9, 0xf8, 0xf6, 0xa1, 0x88, 0xb6, 0xa6, 0x9e, 0x02, 0x2a, 0xf2, 0x7d, 0x88, 0x35, 0x2c, + 0xf4, 0x2c, 0x94, 0x22, 0xc7, 0x6d, 0x5c, 0x77, 0x3d, 0x12, 0x32, 0x89, 0x78, 0x51, 0x26, 0xdf, + 0x13, 0x85, 0x38, 0x86, 0x53, 0x56, 0x8c, 0x45, 0xe2, 0xe0, 0x39, 0xa2, 0x87, 0x18, 0x36, 0x63, + 0xc5, 0xae, 0xab, 0x52, 0xac, 0x61, 0xa0, 0x1d, 0x78, 0xcc, 0xf5, 0x58, 0x1e, 0x0b, 0x52, 0xdd, + 0x75, 0x5b, 0x1b, 0xd7, 0xab, 0xb7, 0x48, 0xe0, 0x6e, 0xed, 0x2f, 0x3a, 0xb5, 0x5d, 0xe2, 0xc9, + 0xfc, 0x9d, 0x4f, 0x8a, 0x2e, 0x3e, 0xb6, 0xda, 0x01, 0x17, 0x77, 0xa4, 0x64, 0xbf, 0xc8, 0xd6, + 0xfb, 0x8d, 0x2a, 0x7a, 0xbf, 0x71, 0x74, 0x9c, 0xd1, 0x8f, 0x8e, 0xc3, 0x83, 0xd9, 0x81, 0x1b, + 0x55, 0x2d, 0x90, 0xc4, 0x2b, 0x70, 0xba, 0xe2, 0xd7, 0x2b, 0x7e, 0x10, 0xad, 0xf8, 0xc1, 0x1d, + 0x27, 0xa8, 0xcb, 0xe5, 0x35, 0x2b, 0x43, 0x69, 0xd0, 0xf3, 0xb3, 0x9f, 0x9f, 0x2e, 0x46, 0x98, + 0x8c, 0x17, 0x19, 0xc7, 0x76, 0x44, 0x07, 0xb0, 0x1a, 0xe3, 0x1d, 0x54, 0x26, 0x98, 0x2b, 0x4e, + 0x44, 0xd0, 0x0d, 0x96, 0xe1, 0x3a, 0xbe, 0x46, 0x45, 0xf5, 0x67, 0xb4, 0x0c, 0xd7, 0x31, 0x30, + 0xf3, 0xde, 0x35, 0xeb, 0xdb, 0x2f, 0xc3, 0x24, 0x7d, 0x7b, 0x29, 0x46, 0x86, 0xb5, 0xd2, 0x3d, + 0xa6, 0xc6, 0x7f, 0xeb, 0x67, 0x07, 0x71, 0x22, 0x09, 0x09, 0xfa, 0x14, 0x8c, 0x85, 0xe4, 0xba, + 0xeb, 0xb5, 0xef, 0x4a, 0xc9, 0x47, 0x07, 0xcf, 0xbf, 0xea, 0xb2, 0x8e, 0xc9, 0xe5, 0xa7, 0x66, + 0x19, 0x4e, 0x50, 0x43, 0x4d, 0x18, 0xbb, 0xe3, 0x7a, 0x75, 0xff, 0x4e, 0x28, 0xe9, 0x0f, 0xe5, + 0x8b, 0x51, 0x6f, 0x73, 0xcc, 0x44, 0x1f, 0x8d, 0xe6, 0x6e, 0x1b, 0xc4, 0x70, 0x82, 0x38, 0x5d, + 0xec, 0x41, 0xdb, 0x5b, 0x08, 0x6f, 0x86, 0x24, 0x10, 0x29, 0xce, 0xd9, 0x62, 0xc7, 0xb2, 0x10, + 0xc7, 0x70, 0xba, 0xd8, 0xd9, 0x9f, 0x2b, 0x81, 0xdf, 0xe6, 0x19, 0x2f, 0xc4, 0x62, 0xc7, 0xaa, + 0x14, 0x6b, 0x18, 0xf4, 0x30, 0x60, 0xff, 0xd6, 0x7d, 0x0f, 0xfb, 0x7e, 0x24, 0x8f, 0x0f, 0x66, + 0x0a, 0xa0, 0x95, 0x63, 0x03, 0x0b, 0xad, 0x00, 0x0a, 0xdb, 0xad, 0x56, 0x83, 0x99, 0x14, 0x39, + 0x0d, 0x46, 0x8a, 0x9b, 0x59, 0x14, 0x79, 0xc4, 0xde, 0x6a, 0x0a, 0x8a, 0x33, 0x6a, 0xd0, 0x7b, + 0x61, 0x4b, 0x74, 0xb5, 0x9f, 0x75, 0x95, 0xab, 0x5c, 0xaa, 0xbc, 0x9f, 0x12, 0x86, 0x96, 0x61, + 0x30, 0xdc, 0x0f, 0x6b, 0x91, 0x08, 0xb0, 0x98, 0x93, 0x67, 0xaa, 0xca, 0x50, 0xb4, 0x34, 0x87, + 0xbc, 0x0a, 0x96, 0x75, 0x51, 0x0d, 0xa6, 0x04, 0xc5, 0xa5, 0x1d, 0xc7, 0x53, 0x59, 0x7b, 0xb8, + 0x65, 0xf5, 0xe5, 0xfb, 0x07, 0xb3, 0x53, 0xa2, 0x65, 0x1d, 0x7c, 0x78, 0x30, 0x7b, 0xa6, 0xe2, + 0xd7, 0x33, 0x20, 0x38, 0x8b, 0x1a, 0x5f, 0x7c, 0xb5, 0x9a, 0xdf, 0x6c, 0x55, 0x02, 0x7f, 0xcb, + 0x6d, 0x90, 0x4e, 0x6a, 0xab, 0xaa, 0x81, 0x29, 0x16, 0x9f, 0x51, 0x86, 0x13, 0xd4, 0xec, 0xef, + 0x64, 0xbc, 0x13, 0xcb, 0xea, 0x1d, 0xb5, 0x03, 0x82, 0x9a, 0x30, 0xda, 0x62, 0xbb, 0x4b, 0xe4, + 0xa1, 0x10, 0x6b, 0xfd, 0xa5, 0x1e, 0xc5, 0x2f, 0x77, 0xe8, 0x95, 0x63, 0x9a, 0x26, 0x55, 0x74, + 0x72, 0xd8, 0xa4, 0x6e, 0xff, 0xe7, 0x69, 0x76, 0xfb, 0x56, 0xb9, 0x4c, 0x65, 0x50, 0x38, 0x72, + 0x88, 0x67, 0xdc, 0x4c, 0xbe, 0x70, 0x2f, 0x9e, 0x16, 0xe1, 0x0c, 0x82, 0x65, 0x5d, 0xf4, 0x49, + 0x18, 0xa3, 0xaf, 0x22, 0x75, 0x03, 0x86, 0xd3, 0xa7, 0xf2, 0x03, 0x6e, 0x28, 0x2c, 0x3d, 0x47, + 0x8d, 0x5e, 0x19, 0x27, 0x88, 0xa1, 0x37, 0x99, 0x29, 0x90, 0x24, 0x5d, 0xe8, 0x85, 0xb4, 0x6e, + 0xf5, 0x23, 0xc9, 0x6a, 0x44, 0x50, 0x1b, 0xa6, 0xd2, 0x19, 0xed, 0xc2, 0x69, 0x3b, 0x9f, 0xbd, + 0x4c, 0x27, 0xa5, 0x8b, 0x93, 0x89, 0xa4, 0x61, 0x21, 0xce, 0xa2, 0x8f, 0xae, 0xc3, 0xa8, 0x48, + 0x6d, 0x2d, 0x56, 0x6e, 0xd1, 0x90, 0x39, 0x8e, 0x62, 0x1d, 0x78, 0x98, 0x2c, 0xc0, 0x66, 0x65, + 0xb4, 0x0d, 0xe7, 0xb4, 0x54, 0x53, 0x57, 0x02, 0x87, 0x19, 0x0e, 0xb8, 0xec, 0x38, 0xd5, 0xf8, + 0x82, 0xc7, 0xef, 0x1f, 0xcc, 0x9e, 0xdb, 0xe8, 0x84, 0x88, 0x3b, 0xd3, 0x41, 0x37, 0xe0, 0x34, + 0x77, 0x17, 0x2f, 0x13, 0xa7, 0xde, 0x70, 0x3d, 0xc5, 0x78, 0xf0, 0x2d, 0x7f, 0xf6, 0xfe, 0xc1, + 0xec, 0xe9, 0x85, 0x2c, 0x04, 0x9c, 0x5d, 0x0f, 0x7d, 0x18, 0x4a, 0x75, 0x2f, 0x14, 0x63, 0x30, + 0x60, 0x64, 0xf3, 0x2a, 0x95, 0xd7, 0xab, 0xea, 0xfb, 0xe3, 0x3f, 0x38, 0xae, 0x80, 0xb6, 0xb9, + 0x5c, 0x5a, 0x49, 0x4b, 0x06, 0x53, 0xe1, 0xb2, 0x92, 0x02, 0x45, 0xc3, 0x61, 0x94, 0x2b, 0x64, + 0x94, 0x1f, 0x85, 0xe1, 0x4b, 0x6a, 0x10, 0x46, 0x6f, 0x00, 0x12, 0x51, 0xe3, 0x17, 0x6a, 0x2c, + 0xc9, 0x09, 0x13, 0xe3, 0x0f, 0x99, 0x2e, 0x8c, 0xd5, 0x14, 0x06, 0xce, 0xa8, 0x85, 0xae, 0xd2, + 0x53, 0x45, 0x2f, 0x15, 0xa7, 0x96, 0xca, 0xbd, 0x58, 0x26, 0xad, 0x80, 0x30, 0x43, 0x28, 0x93, + 0x22, 0x4e, 0xd4, 0x43, 0x75, 0x78, 0xcc, 0x69, 0x47, 0x3e, 0x13, 0xf9, 0x9b, 0xa8, 0x1b, 0xfe, + 0x2e, 0xf1, 0x98, 0xb6, 0x6d, 0x68, 0xf1, 0x02, 0xe5, 0x6c, 0x16, 0x3a, 0xe0, 0xe1, 0x8e, 0x54, + 0x28, 0x47, 0xaa, 0x92, 0x2d, 0x83, 0x19, 0x04, 0x2c, 0x23, 0xe1, 0xf2, 0xcb, 0x30, 0xbc, 0xe3, + 0x87, 0xd1, 0x3a, 0x89, 0xee, 0xf8, 0xc1, 0xae, 0x08, 0x66, 0x1b, 0x87, 0x06, 0x8f, 0x41, 0x58, + 0xc7, 0xa3, 0x4f, 0x4e, 0x66, 0x0b, 0xb2, 0x5a, 0x66, 0x6a, 0xf8, 0xa1, 0xf8, 0x8c, 0xb9, 0xca, + 0x8b, 0xb1, 0x84, 0x4b, 0xd4, 0xd5, 0xca, 0x12, 0x53, 0xa9, 0x27, 0x50, 0x57, 0x2b, 0x4b, 0x58, + 0xc2, 0xe9, 0x72, 0x0d, 0x77, 0x9c, 0x80, 0x54, 0x02, 0xbf, 0x46, 0x42, 0x2d, 0x20, 0xfd, 0xa3, + 0x3c, 0x54, 0x2f, 0x5d, 0xae, 0xd5, 0x2c, 0x04, 0x9c, 0x5d, 0x0f, 0x91, 0x74, 0x9a, 0xb5, 0xb1, + 0x7c, 0x5d, 0x48, 0x9a, 0x9f, 0xe9, 0x31, 0xd3, 0x9a, 0x07, 0x13, 0x2a, 0xc1, 0x1b, 0x0f, 0xce, + 0x1b, 0x4e, 0x8f, 0xb3, 0xb5, 0xdd, 0x7b, 0x64, 0x5f, 0xa5, 0x5d, 0x5a, 0x4d, 0x50, 0xc2, 0x29, + 0xda, 0x46, 0x9c, 0xb7, 0x89, 0xae, 0x71, 0xde, 0xe6, 0xa1, 0x14, 0xb6, 0x37, 0xeb, 0x7e, 0xd3, + 0x71, 0x3d, 0xa6, 0x52, 0xd7, 0xde, 0x3e, 0x55, 0x09, 0xc0, 0x31, 0x0e, 0x5a, 0x81, 0x21, 0x47, + 0xaa, 0x8e, 0x50, 0x7e, 0x64, 0x1f, 0xa5, 0x30, 0xe2, 0xc1, 0x2e, 0xa4, 0xb2, 0x48, 0xd5, 0x45, + 0xaf, 0xc1, 0xa8, 0x70, 0x77, 0x16, 0xb9, 0x45, 0xa7, 0x4c, 0x9f, 0xb4, 0xaa, 0x0e, 0xc4, 0x26, + 0x2e, 0xba, 0x09, 0xc3, 0x91, 0xdf, 0x60, 0x8e, 0x55, 0x94, 0xcd, 0x3b, 0x93, 0x1f, 0xa3, 0x6e, + 0x43, 0xa1, 0xe9, 0x52, 0x5b, 0x55, 0x15, 0xeb, 0x74, 0xd0, 0x06, 0x5f, 0xef, 0x2c, 0xfc, 0x3c, + 0x09, 0xa7, 0x1f, 0xc9, 0xbf, 0x93, 0x54, 0x94, 0x7a, 0x73, 0x3b, 0x88, 0x9a, 0x58, 0x27, 0x83, + 0xae, 0xc0, 0x64, 0x2b, 0x70, 0x7d, 0xb6, 0x26, 0x94, 0xd6, 0x70, 0xda, 0x4c, 0x36, 0x55, 0x49, + 0x22, 0xe0, 0x74, 0x1d, 0xe6, 0xad, 0x2e, 0x0a, 0xa7, 0xcf, 0xf2, 0x84, 0x19, 0xfc, 0x29, 0xc9, + 0xcb, 0xb0, 0x82, 0xa2, 0x35, 0x76, 0x12, 0x73, 0x29, 0xc8, 0xf4, 0x4c, 0x7e, 0x30, 0x21, 0x5d, + 0x5a, 0xc2, 0x99, 0x57, 0xf5, 0x17, 0xc7, 0x14, 0x50, 0x5d, 0xcb, 0x53, 0x49, 0x9f, 0x00, 0xe1, + 0xf4, 0x63, 0x1d, 0x0c, 0xf2, 0x12, 0xaf, 0x92, 0x98, 0x21, 0x30, 0x8a, 0x43, 0x9c, 0xa0, 0x89, + 0x3e, 0x0a, 0x13, 0x22, 0x04, 0x62, 0x3c, 0x4c, 0xe7, 0x62, 0x73, 0x75, 0x9c, 0x80, 0xe1, 0x14, + 0x36, 0x4f, 0x58, 0xe1, 0x6c, 0x36, 0x88, 0x38, 0xfa, 0xae, 0xbb, 0xde, 0x6e, 0x38, 0x7d, 0x9e, + 0x9d, 0x0f, 0x22, 0x61, 0x45, 0x12, 0x8a, 0x33, 0x6a, 0xa0, 0x0d, 0x98, 0x68, 0x05, 0x84, 0x34, + 0x19, 0xa3, 0x2f, 0xee, 0xb3, 0x59, 0x1e, 0xac, 0x81, 0xf6, 0xa4, 0x92, 0x80, 0x1d, 0x66, 0x94, + 0xe1, 0x14, 0x05, 0x74, 0x07, 0x86, 0xfc, 0x3d, 0x12, 0xec, 0x10, 0xa7, 0x3e, 0x7d, 0xa1, 0x83, + 0xfb, 0x84, 0xb8, 0xdc, 0x6e, 0x08, 0xdc, 0x84, 0xa5, 0x81, 0x2c, 0xee, 0x6e, 0x69, 0x20, 0x1b, + 0x43, 0x7f, 0xde, 0x82, 0xb3, 0x52, 0x39, 0x51, 0x6d, 0xd1, 0x51, 0x5f, 0xf2, 0xbd, 0x30, 0x0a, + 0x78, 0x78, 0x81, 0xc7, 0xf3, 0x5d, 0xee, 0x37, 0x72, 0x2a, 0x29, 0x41, 0xec, 0xd9, 0x3c, 0x8c, + 0x10, 0xe7, 0xb7, 0x88, 0x96, 0x60, 0x32, 0x24, 0x91, 0x3c, 0x8c, 0x16, 0xc2, 0x95, 0x37, 0xcb, + 0xeb, 0xd3, 0x4f, 0xf0, 0xd8, 0x08, 0x74, 0x33, 0x54, 0x93, 0x40, 0x9c, 0xc6, 0x47, 0x97, 0xa1, + 0xe0, 0x87, 0xd3, 0x4f, 0x76, 0x48, 0x6d, 0x4a, 0x5f, 0xf0, 0xdc, 0xe2, 0xec, 0x46, 0x15, 0x17, + 0xfc, 0x50, 0x26, 0x8d, 0xa0, 0xef, 0xb1, 0x70, 0xfa, 0x29, 0x2e, 0xb6, 0x93, 0x49, 0x23, 0x58, + 0x21, 0x8e, 0xe1, 0x68, 0x07, 0xc6, 0x43, 0xe3, 0xdd, 0x1b, 0x4e, 0x5f, 0x64, 0x23, 0xf5, 0x54, + 0xde, 0xa4, 0x19, 0xd8, 0x5a, 0xcc, 0x77, 0x93, 0x0a, 0x4e, 0x92, 0x9d, 0xf9, 0x76, 0x98, 0x4c, + 0x31, 0x32, 0x47, 0xc9, 0x54, 0x34, 0xb3, 0x0b, 0xa3, 0xc6, 0x62, 0x79, 0xa8, 0x3a, 0xf7, 0x7f, + 0x39, 0x08, 0x25, 0xa5, 0x8f, 0x45, 0xf3, 0xa6, 0x9a, 0xfd, 0x6c, 0x52, 0xcd, 0x3e, 0x54, 0xf1, + 0xeb, 0x86, 0x66, 0x7d, 0x23, 0x23, 0xb6, 0x5d, 0xde, 0xd1, 0xd4, 0xbb, 0xb9, 0xbf, 0x26, 0xe4, + 0x2e, 0xf6, 0xac, 0xaf, 0xef, 0xeb, 0x28, 0x37, 0xbf, 0x02, 0x93, 0x9e, 0xcf, 0xb8, 0x67, 0x52, + 0x97, 0xac, 0x11, 0xe3, 0x80, 0x4a, 0x7a, 0xb0, 0x98, 0x04, 0x02, 0x4e, 0xd7, 0xa1, 0x0d, 0x72, + 0x16, 0x26, 0x29, 0xa8, 0xe7, 0x1c, 0x0e, 0x16, 0x50, 0xf4, 0x04, 0xf4, 0xb7, 0xfc, 0xfa, 0x6a, + 0x45, 0x70, 0xce, 0x5a, 0x44, 0xd5, 0xfa, 0x6a, 0x05, 0x73, 0x18, 0x5a, 0x80, 0x01, 0xf6, 0x23, + 0x9c, 0x1e, 0xc9, 0x8f, 0x0a, 0xc2, 0x6a, 0x68, 0x79, 0xa0, 0x58, 0x05, 0x2c, 0x2a, 0x32, 0x81, + 0x21, 0x7d, 0x6e, 0x30, 0x81, 0xe1, 0xe0, 0x03, 0x0a, 0x0c, 0x25, 0x01, 0x1c, 0xd3, 0x42, 0x77, + 0xe1, 0xb4, 0xf1, 0xc4, 0xe3, 0x4b, 0x84, 0x84, 0x22, 0x32, 0xc1, 0x13, 0x1d, 0xdf, 0x76, 0x42, + 0xbf, 0x7f, 0x4e, 0x74, 0xfa, 0xf4, 0x6a, 0x16, 0x25, 0x9c, 0xdd, 0x00, 0x6a, 0xc0, 0x64, 0x2d, + 0xd5, 0xea, 0x50, 0xef, 0xad, 0xaa, 0x09, 0x4d, 0xb7, 0x98, 0x26, 0x8c, 0x5e, 0x83, 0xa1, 0xb7, + 0xfd, 0x90, 0xdd, 0x3a, 0x82, 0xdb, 0x97, 0x6e, 0xed, 0x43, 0x6f, 0xde, 0xa8, 0xb2, 0xf2, 0xc3, + 0x83, 0xd9, 0xe1, 0x8a, 0x5f, 0x97, 0x7f, 0xb1, 0xaa, 0x80, 0xbe, 0xdf, 0x82, 0x99, 0xf4, 0x1b, + 0x52, 0x75, 0x7a, 0xb4, 0xf7, 0x4e, 0xdb, 0xa2, 0xd1, 0x99, 0xe5, 0x5c, 0x72, 0xb8, 0x43, 0x53, + 0xf6, 0x2f, 0x5a, 0x4c, 0xec, 0x28, 0xf4, 0x66, 0x24, 0x6c, 0x37, 0x4e, 0x22, 0xfd, 0xed, 0xb2, + 0xa1, 0xd2, 0x7b, 0x60, 0x7b, 0x8f, 0x7f, 0x6a, 0x31, 0x7b, 0x8f, 0x13, 0x74, 0xec, 0x78, 0x13, + 0x86, 0x22, 0x99, 0x96, 0xb8, 0x43, 0xc6, 0x5e, 0xad, 0x53, 0xcc, 0xe6, 0x45, 0xf1, 0xde, 0x2a, + 0x03, 0xb1, 0x22, 0x63, 0xff, 0x03, 0x3e, 0x03, 0x12, 0x72, 0x02, 0x9a, 0x93, 0xb2, 0xa9, 0x39, + 0x99, 0xed, 0xf2, 0x05, 0x39, 0x1a, 0x94, 0xbf, 0x6f, 0xf6, 0x9b, 0xc9, 0x9c, 0xde, 0xed, 0x86, + 0x46, 0xf6, 0xe7, 0x2d, 0x80, 0x38, 0x60, 0x75, 0x0f, 0x89, 0xe7, 0x5e, 0xa1, 0xdc, 0xb6, 0x1f, + 0xf9, 0x35, 0xbf, 0x21, 0xf4, 0x82, 0x8f, 0xc5, 0xca, 0x1b, 0x5e, 0x7e, 0xa8, 0xfd, 0xc6, 0x0a, + 0x1b, 0xcd, 0xca, 0xf0, 0x78, 0xc5, 0x58, 0x9d, 0x68, 0x84, 0xc6, 0xfb, 0xa2, 0x05, 0xa7, 0xb2, + 0xac, 0x84, 0xe9, 0xdb, 0x8d, 0x4b, 0xdf, 0x94, 0x11, 0x98, 0x9a, 0xcd, 0x5b, 0xa2, 0x1c, 0x2b, + 0x8c, 0x9e, 0x33, 0xfa, 0x1d, 0x2d, 0x52, 0xf4, 0x0d, 0x18, 0xad, 0x04, 0x44, 0xbb, 0x5c, 0x5f, + 0xe7, 0x21, 0x17, 0x78, 0x7f, 0x9e, 0x3b, 0x72, 0xb8, 0x05, 0xfb, 0xcb, 0x05, 0x38, 0xc5, 0x6d, + 0x29, 0x16, 0xf6, 0x7c, 0xb7, 0x5e, 0xf1, 0xeb, 0xc2, 0x17, 0xec, 0x13, 0x30, 0xd2, 0xd2, 0x44, + 0xa6, 0x9d, 0xa2, 0x9e, 0xea, 0xa2, 0xd5, 0x58, 0xc8, 0xa3, 0x97, 0x62, 0x83, 0x16, 0xaa, 0xc3, + 0x08, 0xd9, 0x73, 0x6b, 0x4a, 0x21, 0x5f, 0x38, 0xf2, 0x45, 0xa7, 0x5a, 0x59, 0xd6, 0xe8, 0x60, + 0x83, 0xea, 0x43, 0xc8, 0xb3, 0x6d, 0xff, 0xa8, 0x05, 0x8f, 0xe4, 0xc4, 0x48, 0xa5, 0xcd, 0xdd, + 0x61, 0x56, 0x2b, 0x62, 0xd9, 0xaa, 0xe6, 0xb8, 0x2d, 0x0b, 0x16, 0x50, 0xf4, 0x31, 0x00, 0x6e, + 0x8b, 0x42, 0xbc, 0x5a, 0xd7, 0x60, 0x92, 0x46, 0x1c, 0x3c, 0x2d, 0xa4, 0x99, 0xac, 0x8f, 0x35, + 0x5a, 0xf6, 0x17, 0xfb, 0xa0, 0x9f, 0xd9, 0x3e, 0xa0, 0x0a, 0x0c, 0xee, 0xf0, 0xac, 0x37, 0x1d, + 0xe7, 0x8d, 0xe2, 0xca, 0x44, 0x3a, 0xf1, 0xbc, 0x69, 0xa5, 0x58, 0x92, 0x41, 0x6b, 0x30, 0xc5, + 0x93, 0x0f, 0x35, 0xca, 0xa4, 0xe1, 0xec, 0x4b, 0x69, 0x24, 0xcf, 0x94, 0xab, 0xa4, 0xb2, 0xab, + 0x69, 0x14, 0x9c, 0x55, 0x0f, 0xbd, 0x0e, 0x63, 0xf4, 0x75, 0xe8, 0xb7, 0x23, 0x49, 0x89, 0xa7, + 0x1d, 0x52, 0xcf, 0xd1, 0x0d, 0x03, 0x8a, 0x13, 0xd8, 0xe8, 0x35, 0x18, 0x6d, 0xa5, 0xe4, 0xae, + 0xfd, 0xb1, 0x80, 0xc2, 0x94, 0xb5, 0x9a, 0xb8, 0xcc, 0x50, 0xb8, 0xcd, 0xcc, 0xa2, 0x37, 0x76, + 0x02, 0x12, 0xee, 0xf8, 0x8d, 0x3a, 0x63, 0xff, 0xfa, 0x35, 0x43, 0xe1, 0x04, 0x1c, 0xa7, 0x6a, + 0x50, 0x2a, 0x5b, 0x8e, 0xdb, 0x68, 0x07, 0x24, 0xa6, 0x32, 0x60, 0x52, 0x59, 0x49, 0xc0, 0x71, + 0xaa, 0x46, 0x77, 0x81, 0xf2, 0xe0, 0xf1, 0x08, 0x94, 0xed, 0xbf, 0x59, 0x00, 0x63, 0x6a, 0xbf, + 0x75, 0xd3, 0x21, 0xd1, 0x2f, 0xdb, 0x0e, 0x5a, 0x35, 0x61, 0xe7, 0x93, 0xf9, 0x65, 0x71, 0x96, + 0x53, 0xfe, 0x65, 0xf4, 0x3f, 0x66, 0xb5, 0xe8, 0x1e, 0x3f, 0x5d, 0x09, 0x7c, 0x7a, 0xc9, 0xc9, + 0xa0, 0x5c, 0xca, 0x1e, 0x7f, 0x50, 0xfa, 0x2a, 0x77, 0x08, 0x5f, 0x29, 0x2c, 0x96, 0x39, 0x05, + 0xc3, 0x24, 0xa6, 0x2a, 0x22, 0x07, 0x48, 0x2a, 0xe8, 0x32, 0x0c, 0x8b, 0x1c, 0x37, 0xcc, 0x6c, + 0x9c, 0x6f, 0x26, 0x66, 0xc2, 0x53, 0x8e, 0x8b, 0xb1, 0x8e, 0x63, 0xff, 0x40, 0x01, 0xa6, 0x32, + 0xfc, 0x7e, 0xf8, 0x35, 0xb2, 0xed, 0x86, 0x91, 0x4a, 0xa4, 0xaa, 0x5d, 0x23, 0xbc, 0x1c, 0x2b, + 0x0c, 0x7a, 0x56, 0xf1, 0x8b, 0x2a, 0x79, 0x39, 0x09, 0xbb, 0x7a, 0x01, 0x3d, 0x62, 0x4a, 0xd2, + 0x0b, 0xd0, 0xd7, 0x0e, 0x89, 0x0c, 0x3c, 0xab, 0xae, 0x6d, 0xa6, 0x6d, 0x65, 0x10, 0xfa, 0x8c, + 0xda, 0x56, 0x8a, 0x4b, 0xed, 0x19, 0xc5, 0x55, 0x97, 0x1c, 0x46, 0x3b, 0x17, 0x11, 0xcf, 0xf1, + 0x22, 0xf1, 0xd8, 0x8a, 0x23, 0x28, 0xb2, 0x52, 0x2c, 0xa0, 0xf6, 0x17, 0x8a, 0x70, 0x36, 0xd7, + 0x13, 0x90, 0x76, 0xbd, 0xe9, 0x7b, 0x6e, 0xe4, 0x2b, 0xdb, 0x28, 0x1e, 0x35, 0x91, 0xb4, 0x76, + 0xd6, 0x44, 0x39, 0x56, 0x18, 0xe8, 0x22, 0xf4, 0x33, 0x59, 0x6d, 0x2a, 0xa5, 0xec, 0x62, 0x99, + 0x87, 0xd1, 0xe2, 0xe0, 0x9e, 0xb3, 0x80, 0x3f, 0x41, 0x39, 0x18, 0xbf, 0x91, 0xbc, 0x50, 0x68, + 0x77, 0x7d, 0xbf, 0x81, 0x19, 0x10, 0x3d, 0x25, 0xc6, 0x2b, 0x61, 0x0c, 0x84, 0x9d, 0xba, 0x1f, + 0x6a, 0x83, 0xf6, 0x0c, 0x0c, 0xee, 0x92, 0xfd, 0xc0, 0xf5, 0xb6, 0x93, 0x46, 0x62, 0xd7, 0x78, + 0x31, 0x96, 0x70, 0x33, 0x07, 0xe2, 0xe0, 0x71, 0xa7, 0xef, 0x1e, 0xea, 0xca, 0x9e, 0xfc, 0x50, + 0x11, 0xc6, 0xf1, 0x62, 0xf9, 0xbd, 0x89, 0xb8, 0x99, 0x9e, 0x88, 0xe3, 0x4e, 0xdf, 0xdd, 0x7d, + 0x36, 0x7e, 0xce, 0x82, 0x71, 0x96, 0x69, 0x47, 0xf8, 0xfb, 0xbb, 0xbe, 0x77, 0x02, 0x4f, 0x81, + 0x27, 0xa0, 0x3f, 0xa0, 0x8d, 0x26, 0x73, 0xc9, 0xb2, 0x9e, 0x60, 0x0e, 0x43, 0x8f, 0x41, 0x1f, + 0xeb, 0x02, 0x9d, 0xbc, 0x11, 0x7e, 0x04, 0x97, 0x9d, 0xc8, 0xc1, 0xac, 0x94, 0x05, 0x91, 0xc2, + 0xa4, 0xd5, 0x70, 0x79, 0xa7, 0x63, 0x4d, 0xfa, 0xbb, 0x23, 0x46, 0x40, 0x66, 0xd7, 0xde, 0x59, + 0x10, 0xa9, 0x6c, 0x92, 0x9d, 0x9f, 0xd9, 0x7f, 0x50, 0x80, 0xf3, 0x99, 0xf5, 0x7a, 0x0e, 0x22, + 0xd5, 0xb9, 0xf6, 0xc3, 0xcc, 0xa5, 0x52, 0x3c, 0x41, 0x13, 0xdc, 0xbe, 0x5e, 0xb9, 0xff, 0xfe, + 0x1e, 0x62, 0x3b, 0x65, 0x0e, 0xd9, 0xbb, 0x24, 0xb6, 0x53, 0x66, 0xdf, 0x72, 0xc4, 0x04, 0x7f, + 0x5a, 0xc8, 0xf9, 0x16, 0x26, 0x30, 0xb8, 0x44, 0xcf, 0x19, 0x06, 0x0c, 0xe5, 0x23, 0x9c, 0x9f, + 0x31, 0xbc, 0x0c, 0x2b, 0x28, 0x5a, 0x80, 0xf1, 0xa6, 0xeb, 0xd1, 0xc3, 0x67, 0xdf, 0x64, 0xc5, + 0x95, 0x88, 0x7d, 0xcd, 0x04, 0xe3, 0x24, 0x3e, 0x72, 0xb5, 0xb8, 0x4f, 0xfc, 0xeb, 0x5e, 0x3b, + 0xd2, 0xae, 0x9b, 0x33, 0xad, 0x0c, 0xd4, 0x28, 0x66, 0xc4, 0x80, 0x5a, 0xd3, 0xe4, 0x44, 0xc5, + 0xde, 0xe5, 0x44, 0x23, 0xd9, 0x32, 0xa2, 0x99, 0xd7, 0x60, 0xf4, 0x81, 0x15, 0x03, 0xf6, 0xd7, + 0x8a, 0xf0, 0x68, 0x87, 0x6d, 0xcf, 0xcf, 0x7a, 0x63, 0x0e, 0xb4, 0xb3, 0x3e, 0x35, 0x0f, 0x15, + 0x38, 0xb5, 0xd5, 0x6e, 0x34, 0xf6, 0x99, 0x67, 0x0a, 0xa9, 0x4b, 0x0c, 0xc1, 0x53, 0x4a, 0xe1, + 0xc8, 0xa9, 0x95, 0x0c, 0x1c, 0x9c, 0x59, 0x93, 0x3e, 0xb1, 0xe8, 0x4d, 0xb2, 0xaf, 0x48, 0x25, + 0x9e, 0x58, 0x58, 0x07, 0x62, 0x13, 0x17, 0x5d, 0x81, 0x49, 0x67, 0xcf, 0x71, 0x79, 0xf0, 0x6c, + 0x49, 0x80, 0xbf, 0xb1, 0x94, 0x3c, 0x77, 0x21, 0x89, 0x80, 0xd3, 0x75, 0xd0, 0x1b, 0x80, 0xfc, + 0x4d, 0x66, 0xbf, 0x5e, 0xbf, 0x42, 0x3c, 0xa1, 0x0c, 0x66, 0x73, 0x57, 0x8c, 0x8f, 0x84, 0x1b, + 0x29, 0x0c, 0x9c, 0x51, 0x2b, 0x11, 0xdf, 0x68, 0x20, 0x3f, 0xbe, 0x51, 0xe7, 0x73, 0xb1, 0x6b, + 0x1a, 0x9f, 0xff, 0x60, 0xd1, 0xeb, 0x8b, 0x33, 0xf9, 0x66, 0x38, 0xd0, 0xd7, 0x98, 0x0d, 0x28, + 0x97, 0xf5, 0x6a, 0xd1, 0x60, 0x4e, 0x6b, 0x36, 0xa0, 0x31, 0x10, 0x9b, 0xb8, 0x7c, 0x41, 0x84, + 0xb1, 0x13, 0xb2, 0xc1, 0xe2, 0x8b, 0x98, 0x65, 0x0a, 0x03, 0x7d, 0x1c, 0x06, 0xeb, 0xee, 0x9e, + 0x1b, 0x0a, 0x49, 0xd7, 0x91, 0xd5, 0x4a, 0xf1, 0x39, 0x58, 0xe6, 0x64, 0xb0, 0xa4, 0x67, 0xff, + 0x50, 0x01, 0x46, 0x65, 0x8b, 0x6f, 0xb6, 0xfd, 0xc8, 0x39, 0x81, 0x6b, 0xf9, 0x8a, 0x71, 0x2d, + 0x3f, 0xd5, 0x29, 0x70, 0x1b, 0xeb, 0x52, 0xee, 0x75, 0x7c, 0x23, 0x71, 0x1d, 0x3f, 0xdd, 0x9d, + 0x54, 0xe7, 0x6b, 0xf8, 0x1f, 0x5a, 0x30, 0x69, 0xe0, 0x9f, 0xc0, 0x6d, 0xb0, 0x62, 0xde, 0x06, + 0x8f, 0x77, 0xfd, 0x86, 0x9c, 0x5b, 0xe0, 0x7b, 0x8b, 0x89, 0xbe, 0xb3, 0xd3, 0xff, 0x6d, 0xe8, + 0xdb, 0x71, 0x82, 0x7a, 0xa7, 0x44, 0x15, 0xa9, 0x4a, 0x73, 0x57, 0x9d, 0x40, 0x68, 0xc3, 0x9f, + 0x93, 0xa3, 0x4e, 0x8b, 0xba, 0x6a, 0xc2, 0x59, 0x53, 0xe8, 0x15, 0x18, 0x08, 0x6b, 0x7e, 0x4b, + 0xf9, 0xa5, 0x5c, 0x60, 0x03, 0xcd, 0x4a, 0x0e, 0x0f, 0x66, 0x91, 0xd9, 0x1c, 0x2d, 0xc6, 0x02, + 0x1f, 0x7d, 0x02, 0x46, 0xd9, 0x2f, 0x65, 0x9a, 0x56, 0xcc, 0x17, 0x47, 0x54, 0x75, 0x44, 0x6e, + 0xb7, 0x69, 0x14, 0x61, 0x93, 0xd4, 0xcc, 0x36, 0x94, 0xd4, 0x67, 0x3d, 0x54, 0xbd, 0xed, 0xbf, + 0x2b, 0xc2, 0x54, 0xc6, 0x9a, 0x43, 0xa1, 0x31, 0x13, 0x97, 0x7b, 0x5c, 0xaa, 0xef, 0x70, 0x2e, + 0x42, 0xf6, 0x1a, 0xaa, 0x8b, 0xb5, 0xd5, 0x73, 0xa3, 0x37, 0x43, 0x92, 0x6c, 0x94, 0x16, 0x75, + 0x6f, 0x94, 0x36, 0x76, 0x62, 0x43, 0x4d, 0x1b, 0x52, 0x3d, 0x7d, 0xa8, 0x73, 0xfa, 0xc7, 0x45, + 0x38, 0x95, 0x15, 0x4b, 0x12, 0x7d, 0x36, 0x91, 0x26, 0xf5, 0xa5, 0x5e, 0xa3, 0x50, 0xf2, 0xdc, + 0xa9, 0x22, 0xbc, 0xdd, 0x9c, 0x99, 0x38, 0xb5, 0xeb, 0x30, 0x8b, 0x36, 0x59, 0x80, 0x8d, 0x80, + 0xa7, 0xb7, 0x95, 0xc7, 0xc7, 0x07, 0x7b, 0xee, 0x80, 0xc8, 0x8b, 0x1b, 0x26, 0xcc, 0x5e, 0x64, + 0x71, 0x77, 0xb3, 0x17, 0xd9, 0xf2, 0x8c, 0x0b, 0xc3, 0xda, 0xd7, 0x3c, 0xd4, 0x19, 0xdf, 0xa5, + 0xb7, 0x95, 0xd6, 0xef, 0x87, 0x3a, 0xeb, 0x3f, 0x6a, 0x41, 0xc2, 0x13, 0x42, 0x89, 0xc5, 0xac, + 0x5c, 0xb1, 0xd8, 0x05, 0xe8, 0x0b, 0xfc, 0x06, 0x49, 0xe6, 0x13, 0xc5, 0x7e, 0x83, 0x60, 0x06, + 0xa1, 0x18, 0x51, 0x2c, 0xec, 0x18, 0xd1, 0x1f, 0x72, 0xe2, 0x89, 0xf6, 0x04, 0xf4, 0x37, 0xc8, + 0x1e, 0x69, 0x24, 0xd3, 0x3e, 0x5d, 0xa7, 0x85, 0x98, 0xc3, 0xec, 0x9f, 0xeb, 0x83, 0x73, 0x1d, + 0x43, 0xd4, 0xd0, 0xe7, 0xd0, 0xb6, 0x13, 0x91, 0x3b, 0xce, 0x7e, 0x32, 0x3f, 0xcb, 0x15, 0x5e, + 0x8c, 0x25, 0x9c, 0xf9, 0xc5, 0xf1, 0x30, 0xeb, 0x09, 0x21, 0xa2, 0x88, 0xae, 0x2e, 0xa0, 0xa6, + 0x50, 0xaa, 0x78, 0x1c, 0x42, 0xa9, 0x17, 0x00, 0xc2, 0xb0, 0xc1, 0xed, 0xc5, 0xea, 0xc2, 0xe1, + 0x2e, 0x0e, 0xc7, 0x5f, 0xbd, 0x2e, 0x20, 0x58, 0xc3, 0x42, 0x65, 0x98, 0x68, 0x05, 0x7e, 0xc4, + 0x65, 0xb2, 0x65, 0x6e, 0x52, 0xd9, 0x6f, 0x46, 0x07, 0xa9, 0x24, 0xe0, 0x38, 0x55, 0x03, 0xbd, + 0x0c, 0xc3, 0x22, 0x62, 0x48, 0xc5, 0xf7, 0x1b, 0x42, 0x0c, 0xa4, 0xac, 0x0c, 0xab, 0x31, 0x08, + 0xeb, 0x78, 0x5a, 0x35, 0x26, 0xe8, 0x1d, 0xcc, 0xac, 0xc6, 0x85, 0xbd, 0x1a, 0x5e, 0x22, 0xae, + 0xec, 0x50, 0x4f, 0x71, 0x65, 0x63, 0xc1, 0x58, 0xa9, 0x67, 0xbd, 0x23, 0x74, 0x15, 0x25, 0xfd, + 0x4c, 0x1f, 0x4c, 0x89, 0x85, 0xf3, 0xb0, 0x97, 0xcb, 0xcd, 0xf4, 0x72, 0x39, 0x0e, 0xd1, 0xd9, + 0x7b, 0x6b, 0xe6, 0xa4, 0xd7, 0xcc, 0x0f, 0x5b, 0x60, 0xb2, 0x57, 0xe8, 0xcf, 0xe4, 0x26, 0xb8, + 0x7a, 0x39, 0x97, 0x5d, 0x53, 0x31, 0x4a, 0xdf, 0x61, 0xaa, 0x2b, 0xfb, 0xdf, 0x5b, 0xf0, 0x78, + 0x57, 0x8a, 0x68, 0x19, 0x4a, 0x8c, 0x07, 0xd4, 0x5e, 0x67, 0x4f, 0x2b, 0x93, 0x6b, 0x09, 0xc8, + 0x61, 0x49, 0xe3, 0x9a, 0x68, 0x39, 0x95, 0x49, 0xec, 0x99, 0x8c, 0x4c, 0x62, 0xa7, 0x8d, 0xe1, + 0x79, 0xc0, 0x54, 0x62, 0x3f, 0x48, 0x6f, 0x1c, 0xc3, 0xdd, 0x09, 0x7d, 0xd0, 0x10, 0xfb, 0xd9, + 0x09, 0xb1, 0x1f, 0x32, 0xb1, 0xb5, 0x3b, 0xe4, 0xa3, 0x30, 0xc1, 0x42, 0x89, 0x31, 0x07, 0x00, + 0xe1, 0x88, 0x55, 0x88, 0x8d, 0x7c, 0xaf, 0x27, 0x60, 0x38, 0x85, 0x6d, 0xff, 0x7e, 0x11, 0x06, + 0xf8, 0xf6, 0x3b, 0x81, 0x37, 0xe1, 0xb3, 0x50, 0x72, 0x9b, 0xcd, 0x36, 0x4f, 0x0e, 0xd5, 0x1f, + 0x9b, 0x8c, 0xae, 0xca, 0x42, 0x1c, 0xc3, 0xd1, 0x8a, 0x90, 0x38, 0x77, 0x88, 0x56, 0xca, 0x3b, + 0x3e, 0x57, 0x76, 0x22, 0x87, 0x33, 0x38, 0xea, 0x9e, 0x8d, 0x65, 0xd3, 0xe8, 0x53, 0x00, 0x61, + 0x14, 0xb8, 0xde, 0x36, 0x2d, 0x13, 0x41, 0x92, 0xdf, 0xdf, 0x81, 0x5a, 0x55, 0x21, 0x73, 0x9a, + 0xf1, 0x99, 0xa3, 0x00, 0x58, 0xa3, 0x88, 0xe6, 0x8c, 0x9b, 0x7e, 0x26, 0x31, 0x77, 0xc0, 0xa9, + 0xc6, 0x73, 0x36, 0xf3, 0x21, 0x28, 0x29, 0xe2, 0xdd, 0xe4, 0x4f, 0x23, 0x3a, 0x5b, 0xf4, 0x11, + 0x18, 0x4f, 0xf4, 0xed, 0x48, 0xe2, 0xab, 0x9f, 0xb7, 0x60, 0x9c, 0x77, 0x66, 0xd9, 0xdb, 0x13, + 0xb7, 0xc1, 0x3d, 0x38, 0xd5, 0xc8, 0x38, 0x95, 0xc5, 0xf4, 0xf7, 0x7e, 0x8a, 0x2b, 0x71, 0x55, + 0x16, 0x14, 0x67, 0xb6, 0x81, 0x2e, 0xd1, 0x1d, 0x47, 0x4f, 0x5d, 0xa7, 0x21, 0x1c, 0xbf, 0x47, + 0xf8, 0x6e, 0xe3, 0x65, 0x58, 0x41, 0xed, 0xdf, 0xb2, 0x60, 0x92, 0xf7, 0xfc, 0x1a, 0xd9, 0x57, + 0x67, 0xd3, 0x37, 0xb2, 0xef, 0x22, 0x2d, 0x61, 0x21, 0x27, 0x2d, 0xa1, 0xfe, 0x69, 0xc5, 0x8e, + 0x9f, 0xf6, 0x65, 0x0b, 0xc4, 0x0a, 0x39, 0x01, 0x21, 0xc4, 0xb7, 0x9b, 0x42, 0x88, 0x99, 0xfc, + 0x4d, 0x90, 0x23, 0x7d, 0xf8, 0x13, 0x0b, 0x26, 0x38, 0x42, 0xac, 0x2d, 0xff, 0x86, 0xce, 0x43, + 0x2f, 0xc9, 0xcb, 0xaf, 0x91, 0xfd, 0x0d, 0xbf, 0xe2, 0x44, 0x3b, 0xd9, 0x1f, 0x65, 0x4c, 0x56, + 0x5f, 0xc7, 0xc9, 0xaa, 0xcb, 0x0d, 0x64, 0x64, 0xed, 0xe9, 0x12, 0x0d, 0xe3, 0xa8, 0x59, 0x7b, + 0xec, 0xaf, 0x5b, 0x80, 0x78, 0x33, 0x06, 0xe3, 0x46, 0xd9, 0x21, 0x56, 0xaa, 0x5d, 0x74, 0xf1, + 0xd1, 0xa4, 0x20, 0x58, 0xc3, 0x3a, 0x96, 0xe1, 0x49, 0x98, 0x3c, 0x14, 0xbb, 0x9b, 0x3c, 0x1c, + 0x61, 0x44, 0xff, 0xd5, 0x00, 0x24, 0x5d, 0xbe, 0xd0, 0x2d, 0x18, 0xa9, 0x39, 0x2d, 0x67, 0xd3, + 0x6d, 0xb8, 0x91, 0x4b, 0xc2, 0x4e, 0xf6, 0x50, 0x4b, 0x1a, 0x9e, 0x50, 0x52, 0x6b, 0x25, 0xd8, + 0xa0, 0x83, 0xe6, 0x00, 0x5a, 0x81, 0xbb, 0xe7, 0x36, 0xc8, 0x36, 0x93, 0x95, 0xb0, 0x50, 0x13, + 0xdc, 0x38, 0x4b, 0x96, 0x62, 0x0d, 0x23, 0xc3, 0xbf, 0xbe, 0xf8, 0x90, 0xfd, 0xeb, 0xe1, 0xc4, + 0xfc, 0xeb, 0xfb, 0x8e, 0xe4, 0x5f, 0x3f, 0x74, 0x64, 0xff, 0xfa, 0xfe, 0x9e, 0xfc, 0xeb, 0x31, + 0x9c, 0x91, 0xbc, 0x27, 0xfd, 0xbf, 0xe2, 0x36, 0x88, 0x78, 0x70, 0xf0, 0xf8, 0x18, 0x33, 0xf7, + 0x0f, 0x66, 0xcf, 0xe0, 0x4c, 0x0c, 0x9c, 0x53, 0x13, 0x7d, 0x0c, 0xa6, 0x9d, 0x46, 0xc3, 0xbf, + 0xa3, 0x26, 0x75, 0x39, 0xac, 0x39, 0x0d, 0xae, 0x84, 0x18, 0x64, 0x54, 0x1f, 0xbb, 0x7f, 0x30, + 0x3b, 0xbd, 0x90, 0x83, 0x83, 0x73, 0x6b, 0xa3, 0x0f, 0x43, 0xa9, 0x15, 0xf8, 0xb5, 0x35, 0xcd, + 0x2f, 0xf5, 0x3c, 0x1d, 0xc0, 0x8a, 0x2c, 0x3c, 0x3c, 0x98, 0x1d, 0x55, 0x7f, 0xd8, 0x85, 0x1f, + 0x57, 0xc8, 0x70, 0x98, 0x1f, 0x3e, 0x56, 0x87, 0xf9, 0x5d, 0x98, 0xaa, 0x92, 0xc0, 0x75, 0x1a, + 0xee, 0x3d, 0xca, 0x2f, 0xcb, 0xf3, 0x69, 0x03, 0x4a, 0x41, 0xe2, 0x44, 0xee, 0x29, 0x82, 0xa8, + 0x96, 0x3e, 0x45, 0x9e, 0xc0, 0x31, 0x21, 0xfb, 0x7f, 0x5b, 0x30, 0x28, 0x5c, 0xbc, 0x4e, 0x80, + 0x6b, 0x5c, 0x30, 0x34, 0x09, 0xb3, 0xd9, 0x03, 0xc6, 0x3a, 0x93, 0xab, 0x43, 0x58, 0x4d, 0xe8, + 0x10, 0x1e, 0xef, 0x44, 0xa4, 0xb3, 0xf6, 0xe0, 0xaf, 0x16, 0x29, 0xf7, 0x6e, 0x38, 0x1b, 0x3f, + 0xfc, 0x21, 0x58, 0x87, 0xc1, 0x50, 0x38, 0xbb, 0x16, 0xf2, 0x7d, 0x1a, 0x92, 0x93, 0x18, 0xdb, + 0xb1, 0x09, 0xf7, 0x56, 0x49, 0x24, 0xd3, 0x8b, 0xb6, 0xf8, 0x10, 0xbd, 0x68, 0xbb, 0xb9, 0x63, + 0xf7, 0x1d, 0x87, 0x3b, 0xb6, 0xfd, 0x55, 0x76, 0x73, 0xea, 0xe5, 0x27, 0xc0, 0x54, 0x5d, 0x31, + 0xef, 0x58, 0xbb, 0xc3, 0xca, 0x12, 0x9d, 0xca, 0x61, 0xae, 0x7e, 0xd6, 0x82, 0x73, 0x19, 0x5f, + 0xa5, 0x71, 0x5a, 0xcf, 0xc1, 0x90, 0xd3, 0xae, 0xbb, 0x6a, 0x2f, 0x6b, 0xfa, 0xc4, 0x05, 0x51, + 0x8e, 0x15, 0x06, 0x5a, 0x82, 0x49, 0x72, 0xb7, 0xe5, 0x72, 0x55, 0xaa, 0x6e, 0xfe, 0x5b, 0xe4, + 0x7e, 0x81, 0xcb, 0x49, 0x20, 0x4e, 0xe3, 0xab, 0xc8, 0x39, 0xc5, 0xdc, 0xc8, 0x39, 0x7f, 0xc7, + 0x82, 0x61, 0xe5, 0xee, 0xf9, 0xd0, 0x47, 0xfb, 0xa3, 0xe6, 0x68, 0x3f, 0xda, 0x61, 0xb4, 0x73, + 0x86, 0xf9, 0x37, 0x0a, 0xaa, 0xbf, 0x15, 0x3f, 0x88, 0x7a, 0xe0, 0xe0, 0x1e, 0xdc, 0x75, 0xe1, + 0x32, 0x0c, 0x3b, 0xad, 0x96, 0x04, 0x48, 0x1b, 0x34, 0x16, 0x0f, 0x3a, 0x2e, 0xc6, 0x3a, 0x8e, + 0xf2, 0xa4, 0x28, 0xe6, 0x7a, 0x52, 0xd4, 0x01, 0x22, 0x27, 0xd8, 0x26, 0x11, 0x2d, 0x13, 0x26, + 0xb3, 0xf9, 0xe7, 0x4d, 0x3b, 0x72, 0x1b, 0x73, 0xae, 0x17, 0x85, 0x51, 0x30, 0xb7, 0xea, 0x45, + 0x37, 0x02, 0xfe, 0x84, 0xd4, 0x62, 0x4f, 0x29, 0x5a, 0x58, 0xa3, 0x2b, 0x43, 0x1b, 0xb0, 0x36, + 0xfa, 0x4d, 0x63, 0x86, 0x75, 0x51, 0x8e, 0x15, 0x86, 0xfd, 0x21, 0x76, 0xfb, 0xb0, 0x31, 0x3d, + 0x5a, 0xdc, 0xa5, 0x2f, 0x8f, 0xa8, 0xd9, 0x60, 0x9a, 0xcc, 0xb2, 0x1e, 0xdd, 0xa9, 0xf3, 0x61, + 0x4f, 0x1b, 0xd6, 0xfd, 0xfa, 0xe2, 0x10, 0x50, 0xe8, 0x3b, 0x52, 0x06, 0x2a, 0xcf, 0x77, 0xb9, + 0x35, 0x8e, 0x60, 0x92, 0xc2, 0x92, 0xc3, 0xb0, 0xd4, 0x19, 0xab, 0x15, 0xb1, 0x2f, 0xb4, 0xe4, + 0x30, 0x02, 0x80, 0x63, 0x1c, 0xca, 0x4c, 0xa9, 0x3f, 0xe1, 0x34, 0x8a, 0x83, 0xa4, 0x2a, 0xec, + 0x10, 0x6b, 0x18, 0x68, 0x5e, 0x08, 0x14, 0xb8, 0x5e, 0xe0, 0xd1, 0x84, 0x40, 0x41, 0x0e, 0x97, + 0x26, 0x05, 0xba, 0x0c, 0xc3, 0x2a, 0x1f, 0x78, 0x85, 0xa7, 0x65, 0x12, 0xcb, 0x6c, 0x39, 0x2e, + 0xc6, 0x3a, 0x0e, 0xda, 0x80, 0xf1, 0x90, 0xcb, 0xd9, 0x54, 0xe4, 0x6a, 0x2e, 0xaf, 0x7c, 0xbf, + 0x72, 0xb4, 0x35, 0xc1, 0x87, 0xac, 0x88, 0x9f, 0x4e, 0x32, 0xfc, 0x40, 0x92, 0x04, 0x7a, 0x1d, + 0xc6, 0x1a, 0xbe, 0x53, 0x5f, 0x74, 0x1a, 0x8e, 0x57, 0x63, 0xe3, 0x33, 0x64, 0xa6, 0x95, 0xbd, + 0x6e, 0x40, 0x71, 0x02, 0x9b, 0x32, 0x6f, 0x7a, 0x89, 0x88, 0xb6, 0xee, 0x78, 0xdb, 0x24, 0x14, + 0xd9, 0x9d, 0x19, 0xf3, 0x76, 0x3d, 0x07, 0x07, 0xe7, 0xd6, 0x46, 0xaf, 0xc0, 0x88, 0xfc, 0x7c, + 0x2d, 0x5a, 0x47, 0xec, 0x94, 0xa2, 0xc1, 0xb0, 0x81, 0x89, 0xee, 0xc0, 0x69, 0xf9, 0x7f, 0x23, + 0x70, 0xb6, 0xb6, 0xdc, 0x9a, 0x70, 0x61, 0xe7, 0xde, 0xab, 0x0b, 0xd2, 0xc5, 0x72, 0x39, 0x0b, + 0xe9, 0xf0, 0x60, 0xf6, 0x82, 0x18, 0xb5, 0x4c, 0x38, 0x9b, 0xc4, 0x6c, 0xfa, 0x68, 0x0d, 0xa6, + 0x76, 0x88, 0xd3, 0x88, 0x76, 0x96, 0x76, 0x48, 0x6d, 0x57, 0x6e, 0x3a, 0x16, 0x03, 0x44, 0x73, + 0xe0, 0xb8, 0x9a, 0x46, 0xc1, 0x59, 0xf5, 0xd0, 0x5b, 0x30, 0xdd, 0x6a, 0x6f, 0x36, 0xdc, 0x70, + 0x67, 0xdd, 0x8f, 0x98, 0x29, 0x90, 0x4a, 0x2f, 0x2e, 0x82, 0x85, 0xa8, 0x28, 0x2b, 0x95, 0x1c, + 0x3c, 0x9c, 0x4b, 0x01, 0xdd, 0x83, 0xd3, 0x89, 0xc5, 0x20, 0xc2, 0x25, 0x8c, 0xe5, 0xe7, 0xae, + 0xa8, 0x66, 0x55, 0x10, 0x91, 0x47, 0xb2, 0x40, 0x38, 0xbb, 0x09, 0xf4, 0x2a, 0x80, 0xdb, 0x5a, + 0x71, 0x9a, 0x6e, 0x83, 0x3e, 0x17, 0xa7, 0xd8, 0x3a, 0xa1, 0x4f, 0x07, 0x58, 0xad, 0xc8, 0x52, + 0x7a, 0x3e, 0x8b, 0x7f, 0xfb, 0x58, 0xc3, 0x46, 0xd7, 0x61, 0x4c, 0xfc, 0xdb, 0x17, 0xd3, 0xca, + 0xa3, 0x76, 0x3c, 0xc9, 0x42, 0x2e, 0x55, 0x74, 0xc8, 0x61, 0xaa, 0x04, 0x27, 0xea, 0xa2, 0x6d, + 0x38, 0x27, 0xf3, 0x90, 0xe9, 0x6b, 0x54, 0xce, 0x41, 0xc8, 0x12, 0x46, 0x0c, 0x71, 0xdf, 0x90, + 0x85, 0x4e, 0x88, 0xb8, 0x33, 0x1d, 0x7a, 0xb7, 0xeb, 0x4b, 0x9d, 0x7b, 0xcf, 0x9e, 0xe6, 0xa6, + 0x49, 0xf4, 0x6e, 0xbf, 0x9e, 0x04, 0xe2, 0x34, 0x3e, 0x0a, 0xe1, 0xb4, 0xeb, 0x65, 0xad, 0xec, + 0x33, 0x8c, 0xd0, 0x47, 0xb8, 0xe3, 0x70, 0xe7, 0x55, 0x9d, 0x09, 0xe7, 0xab, 0x3a, 0x93, 0xf6, + 0x3b, 0xb3, 0xc0, 0xfb, 0x4d, 0x8b, 0xd6, 0xd6, 0xb8, 0x74, 0xf4, 0x69, 0x18, 0xd1, 0x3f, 0x4c, + 0x70, 0x1c, 0x17, 0xb3, 0x99, 0x58, 0xed, 0x6c, 0xe0, 0x3c, 0xbe, 0xda, 0xff, 0x3a, 0x0c, 0x1b, + 0x14, 0x51, 0x2d, 0xc3, 0xc5, 0x7e, 0xbe, 0x37, 0x8e, 0xa6, 0x77, 0x03, 0x34, 0x02, 0xd9, 0x4b, + 0x1e, 0x5d, 0x87, 0xa1, 0x5a, 0xc3, 0x25, 0x5e, 0xb4, 0x5a, 0xe9, 0x14, 0xde, 0x6f, 0x49, 0xe0, + 0x88, 0x3d, 0x24, 0xf2, 0x3f, 0xf0, 0x32, 0xac, 0x28, 0xd8, 0xbf, 0x52, 0x80, 0xd9, 0x2e, 0xc9, + 0x44, 0x12, 0xea, 0x28, 0xab, 0x27, 0x75, 0xd4, 0x82, 0xcc, 0x9f, 0xbf, 0x9e, 0x90, 0x74, 0x25, + 0x72, 0xe3, 0xc7, 0xf2, 0xae, 0x24, 0x7e, 0xcf, 0xee, 0x01, 0xba, 0x46, 0xab, 0xaf, 0xab, 0x83, + 0x8b, 0xa1, 0xc9, 0xee, 0xef, 0xfd, 0xf9, 0x9b, 0xab, 0x95, 0xb4, 0xbf, 0x5a, 0x80, 0xd3, 0x6a, + 0x08, 0xbf, 0x75, 0x07, 0xee, 0x66, 0x7a, 0xe0, 0x8e, 0x41, 0xa7, 0x6b, 0xdf, 0x80, 0x01, 0x1e, + 0xaf, 0xb0, 0x07, 0xb6, 0xfb, 0x09, 0x33, 0x8c, 0xb0, 0xe2, 0xf4, 0x8c, 0x50, 0xc2, 0xdf, 0x6f, + 0xc1, 0x78, 0xc2, 0xcf, 0x0c, 0x61, 0xcd, 0x19, 0xf9, 0x41, 0x58, 0xe3, 0x2c, 0xa6, 0xfb, 0x02, + 0xf4, 0xed, 0xf8, 0x61, 0x94, 0x34, 0xf8, 0xb8, 0xea, 0x87, 0x11, 0x66, 0x10, 0xfb, 0xb7, 0x2d, + 0xe8, 0xdf, 0x70, 0x5c, 0x2f, 0x92, 0xca, 0x01, 0x2b, 0x47, 0x39, 0xd0, 0xcb, 0x77, 0xa1, 0x97, + 0x61, 0x80, 0x6c, 0x6d, 0x91, 0x5a, 0x24, 0x66, 0x55, 0x46, 0x72, 0x18, 0x58, 0x66, 0xa5, 0x94, + 0x0f, 0x64, 0x8d, 0xf1, 0xbf, 0x58, 0x20, 0xa3, 0xdb, 0x50, 0x8a, 0xdc, 0x26, 0x59, 0xa8, 0xd7, + 0x85, 0xca, 0xfc, 0x01, 0xa2, 0x51, 0x6c, 0x48, 0x02, 0x38, 0xa6, 0x65, 0x7f, 0xa1, 0x00, 0x10, + 0x07, 0x7a, 0xea, 0xf6, 0x89, 0x8b, 0x29, 0x65, 0xea, 0xc5, 0x0c, 0x65, 0x2a, 0x8a, 0x09, 0x66, + 0x68, 0x52, 0xd5, 0x30, 0x15, 0x7b, 0x1a, 0xa6, 0xbe, 0xa3, 0x0c, 0xd3, 0x12, 0x4c, 0xc6, 0x81, + 0xaa, 0xcc, 0x38, 0x7d, 0xec, 0xfa, 0xdc, 0x48, 0x02, 0x71, 0x1a, 0xdf, 0x26, 0x70, 0x41, 0xc5, + 0xeb, 0x11, 0x37, 0x1a, 0xb3, 0xc8, 0xd6, 0x95, 0xd3, 0x5d, 0xc6, 0x29, 0xd6, 0x16, 0x17, 0x72, + 0xb5, 0xc5, 0x3f, 0x61, 0xc1, 0xa9, 0x64, 0x3b, 0xcc, 0x7d, 0xf9, 0xf3, 0x16, 0x9c, 0x66, 0x3a, + 0x73, 0xd6, 0x6a, 0x5a, 0x43, 0xff, 0x52, 0xc7, 0x18, 0x44, 0x39, 0x3d, 0x8e, 0x43, 0x86, 0xac, + 0x65, 0x91, 0xc6, 0xd9, 0x2d, 0xda, 0xff, 0xab, 0x0f, 0xa6, 0xf3, 0x82, 0x17, 0x31, 0x87, 0x0d, + 0xe7, 0x6e, 0x75, 0x97, 0xdc, 0x11, 0x66, 0xf1, 0xb1, 0xc3, 0x06, 0x2f, 0xc6, 0x12, 0x9e, 0xcc, + 0x0f, 0x51, 0xe8, 0x31, 0x3f, 0xc4, 0x0e, 0x4c, 0xde, 0xd9, 0x21, 0xde, 0x4d, 0x2f, 0x74, 0x22, + 0x37, 0xdc, 0x72, 0x99, 0x7e, 0x99, 0xaf, 0x1b, 0x99, 0x54, 0x76, 0xf2, 0x76, 0x12, 0xe1, 0xf0, + 0x60, 0xf6, 0x9c, 0x51, 0x10, 0x77, 0x99, 0x1f, 0x24, 0x38, 0x4d, 0x34, 0x9d, 0x5e, 0xa3, 0xef, + 0x21, 0xa7, 0xd7, 0x68, 0xba, 0xc2, 0x2a, 0x45, 0x5a, 0xe3, 0xb3, 0x97, 0xe3, 0x9a, 0x2a, 0xc5, + 0x1a, 0x06, 0xfa, 0x24, 0x20, 0x3d, 0x7d, 0x90, 0x11, 0x3b, 0xf2, 0xf9, 0xfb, 0x07, 0xb3, 0x68, + 0x3d, 0x05, 0x3d, 0x3c, 0x98, 0x9d, 0xa2, 0xa5, 0xab, 0x1e, 0x7d, 0x81, 0xc6, 0x01, 0xb7, 0x32, + 0x08, 0xa1, 0xdb, 0x30, 0x41, 0x4b, 0xd9, 0x8e, 0x92, 0x81, 0x29, 0xf9, 0xab, 0xf1, 0xd9, 0xfb, + 0x07, 0xb3, 0x13, 0xeb, 0x09, 0x58, 0x1e, 0xe9, 0x14, 0x11, 0xf4, 0x2a, 0x8c, 0xc5, 0xeb, 0xea, + 0x1a, 0xd9, 0xe7, 0xe1, 0x66, 0x4a, 0x5c, 0xf0, 0xbd, 0x66, 0x40, 0x70, 0x02, 0xd3, 0xfe, 0xbc, + 0x05, 0x67, 0x73, 0xb3, 0x50, 0xa3, 0x4b, 0x30, 0xe4, 0xb4, 0x5c, 0xae, 0xc6, 0x10, 0x57, 0x0d, + 0x13, 0x97, 0x55, 0x56, 0xb9, 0x12, 0x43, 0x41, 0xe9, 0x09, 0xbf, 0xeb, 0x7a, 0xf5, 0xe4, 0x09, + 0x7f, 0xcd, 0xf5, 0xea, 0x98, 0x41, 0xd4, 0x95, 0x55, 0xcc, 0x8d, 0xd4, 0xfc, 0x7d, 0x16, 0x08, + 0x87, 0xdc, 0x1e, 0xee, 0xb7, 0x4f, 0xc0, 0xc8, 0x5e, 0x3a, 0x4d, 0xd9, 0x85, 0x7c, 0x0f, 0x65, + 0x91, 0x9c, 0x4c, 0x31, 0xad, 0x46, 0x4a, 0x32, 0x83, 0x96, 0x5d, 0x07, 0x01, 0x2d, 0x13, 0x26, + 0xa4, 0xef, 0xde, 0x9b, 0x17, 0x00, 0xea, 0x0c, 0x97, 0xe5, 0x2e, 0x2d, 0x98, 0xdc, 0x4b, 0x59, + 0x41, 0xb0, 0x86, 0x65, 0xff, 0x9b, 0x02, 0x0c, 0xcb, 0xb4, 0x58, 0x6d, 0xaf, 0x17, 0x51, 0xda, + 0x91, 0xf2, 0xe4, 0xa2, 0x79, 0x28, 0x31, 0x59, 0x6f, 0x25, 0x96, 0x40, 0x2a, 0x49, 0xcb, 0x9a, + 0x04, 0xe0, 0x18, 0x87, 0x9e, 0x34, 0x61, 0x7b, 0x93, 0xa1, 0x27, 0xdc, 0x47, 0xab, 0xbc, 0x18, + 0x4b, 0x38, 0xfa, 0x18, 0x4c, 0xf0, 0x7a, 0x81, 0xdf, 0x72, 0xb6, 0xb9, 0x7e, 0xa8, 0x5f, 0xc5, + 0xe4, 0x98, 0x58, 0x4b, 0xc0, 0x0e, 0x0f, 0x66, 0x4f, 0x25, 0xcb, 0x98, 0xe2, 0x33, 0x45, 0x85, + 0x99, 0x81, 0xf1, 0x46, 0xe8, 0x09, 0x99, 0xb2, 0x1e, 0x8b, 0x41, 0x58, 0xc7, 0xb3, 0x3f, 0x0d, + 0x28, 0x9d, 0x20, 0x0c, 0xbd, 0xc1, 0x6d, 0x7f, 0xdd, 0x80, 0xd4, 0x3b, 0x29, 0x42, 0xf5, 0xc8, + 0x13, 0xd2, 0xf3, 0x8b, 0xd7, 0xc2, 0xaa, 0xbe, 0xfd, 0x17, 0x8a, 0x30, 0x91, 0xf4, 0x75, 0x47, + 0x57, 0x61, 0x80, 0xb3, 0x67, 0x82, 0x7c, 0x07, 0x3b, 0x1b, 0xcd, 0x43, 0x9e, 0x5d, 0x54, 0x82, + 0xc3, 0x13, 0xf5, 0xd1, 0x5b, 0x30, 0x5c, 0xf7, 0xef, 0x78, 0x77, 0x9c, 0xa0, 0xbe, 0x50, 0x59, + 0x15, 0xcb, 0x39, 0xf3, 0xe1, 0x5f, 0x8e, 0xd1, 0x74, 0xaf, 0x7b, 0xa6, 0x53, 0x8e, 0x41, 0x58, + 0x27, 0x87, 0x36, 0x58, 0x56, 0x81, 0x2d, 0x77, 0x7b, 0xcd, 0x69, 0x75, 0x72, 0x04, 0x59, 0x92, + 0x48, 0x1a, 0xe5, 0x51, 0x91, 0x7a, 0x80, 0x03, 0x70, 0x4c, 0x08, 0x7d, 0x16, 0xa6, 0xc2, 0x1c, + 0x75, 0x44, 0x5e, 0xbe, 0xc8, 0x4e, 0x12, 0xfa, 0xc5, 0x47, 0xee, 0x1f, 0xcc, 0x4e, 0x65, 0x29, + 0x2e, 0xb2, 0x9a, 0xb1, 0xbf, 0x78, 0x0a, 0x8c, 0x4d, 0x6c, 0xa4, 0x0f, 0xb6, 0x8e, 0x29, 0x7d, + 0x30, 0x86, 0x21, 0xd2, 0x6c, 0x45, 0xfb, 0x65, 0x37, 0x10, 0x73, 0x92, 0x49, 0x73, 0x59, 0xe0, + 0xa4, 0x69, 0x4a, 0x08, 0x56, 0x74, 0xb2, 0x73, 0x3c, 0x17, 0xbf, 0x81, 0x39, 0x9e, 0xfb, 0x4e, + 0x30, 0xc7, 0xf3, 0x3a, 0x0c, 0x6e, 0xbb, 0x11, 0x26, 0x2d, 0x5f, 0x3c, 0x8c, 0x32, 0xd7, 0xe1, + 0x15, 0x8e, 0x92, 0xce, 0x26, 0x2a, 0x00, 0x58, 0x12, 0x41, 0x6f, 0xa8, 0x1d, 0x38, 0x90, 0x2f, + 0xbc, 0x48, 0x1b, 0x84, 0x64, 0xee, 0x41, 0x91, 0xc9, 0x79, 0xf0, 0x41, 0x33, 0x39, 0xaf, 0xc8, + 0xfc, 0xcb, 0x43, 0xf9, 0x5e, 0x5b, 0x2c, 0xbd, 0x72, 0x97, 0xac, 0xcb, 0xb7, 0xf4, 0x9c, 0xd5, + 0xa5, 0xfc, 0x93, 0x40, 0xa5, 0xa3, 0xee, 0x31, 0x53, 0xf5, 0xf7, 0x59, 0x70, 0xba, 0x95, 0x95, + 0xbe, 0x5d, 0xd8, 0x4e, 0xbc, 0xdc, 0x73, 0x86, 0x78, 0xa3, 0x41, 0x26, 0x73, 0xcc, 0x44, 0xc3, + 0xd9, 0xcd, 0xd1, 0x81, 0x0e, 0x36, 0xeb, 0x42, 0x87, 0xff, 0x44, 0x4e, 0xca, 0xeb, 0x0e, 0x89, + 0xae, 0x37, 0x32, 0xd2, 0x2b, 0x3f, 0x99, 0x97, 0x5e, 0xb9, 0xe7, 0xa4, 0xca, 0x6f, 0xa8, 0x64, + 0xd7, 0xa3, 0xf9, 0x4b, 0x89, 0xa7, 0xb2, 0xee, 0x9a, 0xe2, 0xfa, 0x0d, 0x95, 0xe2, 0xba, 0x43, + 0x18, 0x67, 0x9e, 0xc0, 0xba, 0x6b, 0x62, 0x6b, 0x2d, 0x39, 0xf5, 0xf8, 0xf1, 0x24, 0xa7, 0x36, + 0xae, 0x1a, 0x9e, 0x1f, 0xf9, 0xd9, 0x2e, 0x57, 0x8d, 0x41, 0xb7, 0xf3, 0x65, 0xc3, 0x13, 0x71, + 0x4f, 0x3e, 0x50, 0x22, 0xee, 0x5b, 0x7a, 0x62, 0x6b, 0xd4, 0x25, 0x73, 0x33, 0x45, 0xea, 0x31, + 0x9d, 0xf5, 0x2d, 0xfd, 0x02, 0x9c, 0xca, 0xa7, 0xab, 0xee, 0xb9, 0x34, 0xdd, 0xcc, 0x2b, 0x30, + 0x95, 0x26, 0xfb, 0xd4, 0xc9, 0xa4, 0xc9, 0x3e, 0x7d, 0xec, 0x69, 0xb2, 0xcf, 0x9c, 0x40, 0x9a, + 0xec, 0x47, 0x4e, 0x30, 0x4d, 0xf6, 0x2d, 0x66, 0x70, 0xc4, 0xc3, 0x1a, 0x89, 0xb0, 0xd3, 0xcf, + 0xe4, 0x44, 0x05, 0x4b, 0xc7, 0x3e, 0xe2, 0x1f, 0xa7, 0x40, 0x38, 0x26, 0x95, 0x91, 0x7e, 0x7b, + 0xfa, 0x21, 0xa4, 0xdf, 0x5e, 0x8f, 0xd3, 0x6f, 0x9f, 0xcd, 0x9f, 0xea, 0x0c, 0x17, 0x95, 0x9c, + 0xa4, 0xdb, 0xb7, 0xf4, 0x64, 0xd9, 0x8f, 0x76, 0xd0, 0x2a, 0x65, 0x09, 0x67, 0x3b, 0xa4, 0xc8, + 0x7e, 0x9d, 0xa7, 0xc8, 0x7e, 0x2c, 0xff, 0x24, 0x4f, 0x5e, 0x77, 0x46, 0x62, 0x6c, 0xda, 0x2f, + 0x15, 0x16, 0x94, 0x05, 0xd8, 0xce, 0xe9, 0x97, 0x8a, 0x2b, 0x9a, 0xee, 0x97, 0x02, 0xe1, 0x98, + 0x94, 0xfd, 0x03, 0x05, 0x38, 0xdf, 0x79, 0xbf, 0xc5, 0x12, 0xe7, 0x4a, 0xac, 0x64, 0x4f, 0x48, + 0x9c, 0xf9, 0x9b, 0x2d, 0xc6, 0xea, 0x39, 0xca, 0xe1, 0x15, 0x98, 0x54, 0xbe, 0x2d, 0xf4, 0x8d, + 0xbe, 0x1e, 0xbf, 0x7c, 0x55, 0x3c, 0x80, 0x6a, 0x12, 0x01, 0xa7, 0xeb, 0xa0, 0x05, 0x18, 0x37, + 0x0a, 0x57, 0xcb, 0xe2, 0x6d, 0x16, 0x87, 0x74, 0x36, 0xc1, 0x38, 0x89, 0x6f, 0x7f, 0xc9, 0x82, + 0x47, 0x72, 0xf2, 0x4b, 0xf6, 0x1c, 0xc4, 0x6f, 0x0b, 0xc6, 0x5b, 0x66, 0xd5, 0x2e, 0x71, 0x47, + 0x8d, 0x2c, 0x96, 0xaa, 0xaf, 0x09, 0x00, 0x4e, 0x12, 0xb5, 0x7f, 0xaa, 0x00, 0xe7, 0x3a, 0x1a, + 0x6b, 0x22, 0x0c, 0x67, 0xb6, 0x9b, 0xa1, 0xb3, 0x14, 0x90, 0x3a, 0xf1, 0x22, 0xd7, 0x69, 0x54, + 0x5b, 0xa4, 0xa6, 0xe9, 0x0c, 0x98, 0xd5, 0xe3, 0x95, 0xb5, 0xea, 0x42, 0x1a, 0x03, 0xe7, 0xd4, + 0x44, 0x2b, 0x80, 0xd2, 0x10, 0x31, 0xc3, 0x2c, 0x54, 0x7b, 0x9a, 0x1e, 0xce, 0xa8, 0x81, 0x3e, + 0x04, 0xa3, 0xca, 0x08, 0x54, 0x9b, 0x71, 0x76, 0xb0, 0x63, 0x1d, 0x80, 0x4d, 0x3c, 0x74, 0x99, + 0xc7, 0xfa, 0x17, 0x59, 0x21, 0x84, 0x82, 0x61, 0x5c, 0x06, 0xf2, 0x17, 0xc5, 0x58, 0xc7, 0x59, + 0x7c, 0xe5, 0x57, 0x7f, 0xf7, 0xfc, 0xfb, 0x7e, 0xfd, 0x77, 0xcf, 0xbf, 0xef, 0xb7, 0x7e, 0xf7, + 0xfc, 0xfb, 0xbe, 0xeb, 0xfe, 0x79, 0xeb, 0x57, 0xef, 0x9f, 0xb7, 0x7e, 0xfd, 0xfe, 0x79, 0xeb, + 0xb7, 0xee, 0x9f, 0xb7, 0x7e, 0xe7, 0xfe, 0x79, 0xeb, 0x0b, 0xbf, 0x77, 0xfe, 0x7d, 0x9f, 0x40, + 0x71, 0x58, 0xcc, 0x79, 0x3a, 0x3b, 0xf3, 0x7b, 0x97, 0xff, 0x7f, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x27, 0x62, 0xd1, 0x9e, 0x33, 0x0a, 0x01, 0x00, } func (m *AWSElasticBlockStoreVolumeSource) Marshal() (dAtA []byte, err error) { @@ -14892,6 +14923,34 @@ func (m *PodReadinessGate) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *PodSchedulingGate) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PodSchedulingGate) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PodSchedulingGate) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + func (m *PodSecurityContext) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -15059,6 +15118,22 @@ func (m *PodSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if len(m.SchedulingGates) > 0 { + for iNdEx := len(m.SchedulingGates) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.SchedulingGates[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xb2 + } + } if m.HostUsers != nil { i-- if *m.HostUsers { @@ -22666,6 +22741,17 @@ func (m *PodReadinessGate) Size() (n int) { return n } +func (m *PodSchedulingGate) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + func (m *PodSecurityContext) Size() (n int) { if m == nil { return 0 @@ -22873,6 +22959,12 @@ func (m *PodSpec) Size() (n int) { if m.HostUsers != nil { n += 3 } + if len(m.SchedulingGates) > 0 { + for _, e := range m.SchedulingGates { + l = e.Size() + n += 2 + l + sovGenerated(uint64(l)) + } + } return n } @@ -26620,6 +26712,16 @@ func (this *PodReadinessGate) String() string { }, "") return s } +func (this *PodSchedulingGate) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&PodSchedulingGate{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `}`, + }, "") + return s +} func (this *PodSecurityContext) String() string { if this == nil { return "nil" @@ -26703,6 +26805,11 @@ func (this *PodSpec) String() string { repeatedStringForEphemeralContainers += strings.Replace(strings.Replace(f.String(), "EphemeralContainer", "EphemeralContainer", 1), `&`, ``, 1) + "," } repeatedStringForEphemeralContainers += "}" + repeatedStringForSchedulingGates := "[]PodSchedulingGate{" + for _, f := range this.SchedulingGates { + repeatedStringForSchedulingGates += strings.Replace(strings.Replace(f.String(), "PodSchedulingGate", "PodSchedulingGate", 1), `&`, ``, 1) + "," + } + repeatedStringForSchedulingGates += "}" keysForNodeSelector := make([]string, 0, len(this.NodeSelector)) for k := range this.NodeSelector { keysForNodeSelector = append(keysForNodeSelector, k) @@ -26761,6 +26868,7 @@ func (this *PodSpec) String() string { `SetHostnameAsFQDN:` + valueToStringGenerated(this.SetHostnameAsFQDN) + `,`, `OS:` + strings.Replace(this.OS.String(), "PodOS", "PodOS", 1) + `,`, `HostUsers:` + valueToStringGenerated(this.HostUsers) + `,`, + `SchedulingGates:` + repeatedStringForSchedulingGates + `,`, `}`, }, "") return s @@ -52692,6 +52800,88 @@ func (m *PodReadinessGate) Unmarshal(dAtA []byte) error { } return nil } +func (m *PodSchedulingGate) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PodSchedulingGate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PodSchedulingGate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *PodSecurityContext) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -54474,6 +54664,40 @@ func (m *PodSpec) Unmarshal(dAtA []byte) error { } b := bool(v != 0) m.HostUsers = &b + case 38: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SchedulingGates", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SchedulingGates = append(m.SchedulingGates, PodSchedulingGate{}) + if err := m.SchedulingGates[len(m.SchedulingGates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) diff --git a/staging/src/k8s.io/api/core/v1/generated.proto b/staging/src/k8s.io/api/core/v1/generated.proto index c073776195b..09edf9c9a79 100644 --- a/staging/src/k8s.io/api/core/v1/generated.proto +++ b/staging/src/k8s.io/api/core/v1/generated.proto @@ -3353,6 +3353,13 @@ message PodReadinessGate { optional string conditionType = 1; } +// PodSchedulingGate is associated to a Pod to guard its scheduling. +message PodSchedulingGate { + // Name of the scheduling gate. + // Each scheduling gate must have a unique name field. + optional string name = 1; +} + // PodSecurityContext holds pod-level security attributes and common container settings. // Some fields are also present in container.securityContext. Field values of // container.securityContext take precedence over field values of PodSecurityContext. @@ -3747,6 +3754,17 @@ message PodSpec { // +k8s:conversion-gen=false // +optional optional bool hostUsers = 37; + + // SchedulingGates is an opaque list of values that if specified will block scheduling the pod. + // More info: https://git.k8s.io/enhancements/keps/sig-scheduling/3521-pod-scheduling-readiness. + // + // This is an alpha-level feature enabled by PodSchedulingReadiness feature gate. + // +optional + // +patchMergeKey=name + // +patchStrategy=merge + // +listType=map + // +listMapKey=name + repeated PodSchedulingGate schedulingGates = 38; } // 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 22156917971..11cde28150b 100644 --- a/staging/src/k8s.io/api/core/v1/types.go +++ b/staging/src/k8s.io/api/core/v1/types.go @@ -1663,7 +1663,7 @@ type ServiceAccountTokenProjection struct { // must identify itself with an identifier specified in the audience of the // token, and otherwise should reject the token. The audience defaults to the // identifier of the apiserver. - //+optional + // +optional Audience string `json:"audience,omitempty" protobuf:"bytes,1,rep,name=audience"` // expirationSeconds is the requested duration of validity of the service // account token. As the token approaches expiration, the kubelet volume @@ -1671,7 +1671,7 @@ type ServiceAccountTokenProjection struct { // start trying to rotate the token if the token is older than 80 percent of // its time to live or if the token is older than 24 hours.Defaults to 1 hour // and must be at least 10 minutes. - //+optional + // +optional ExpirationSeconds *int64 `json:"expirationSeconds,omitempty" protobuf:"varint,2,opt,name=expirationSeconds"` // path is the path relative to the mount point of the file to project the // token into. @@ -2666,6 +2666,10 @@ const ( // can't schedule the pod right now, for example due to insufficient resources in the cluster. PodReasonUnschedulable = "Unschedulable" + // PodReasonSchedulingGated reason in PodScheduled PodCondition means that the scheduler + // skips scheduling the pod because one or more scheduling gates are still present. + PodReasonSchedulingGated = "SchedulingGated" + // PodReasonSchedulerError reason in PodScheduled PodCondition means that some internal error happens // during scheduling, for example due to nodeAffinity parsing errors. PodReasonSchedulerError = "SchedulerError" @@ -2743,7 +2747,7 @@ const ( // by the node selector terms. // +structType=atomic type NodeSelector struct { - //Required. A list of node selector terms. The terms are ORed. + // Required. A list of node selector terms. The terms are ORed. NodeSelectorTerms []NodeSelectorTerm `json:"nodeSelectorTerms" protobuf:"bytes,1,rep,name=nodeSelectorTerms"` } @@ -3327,6 +3331,16 @@ type PodSpec struct { // +k8s:conversion-gen=false // +optional HostUsers *bool `json:"hostUsers,omitempty" protobuf:"bytes,37,opt,name=hostUsers"` + // SchedulingGates is an opaque list of values that if specified will block scheduling the pod. + // More info: https://git.k8s.io/enhancements/keps/sig-scheduling/3521-pod-scheduling-readiness. + // + // This is an alpha-level feature enabled by PodSchedulingReadiness feature gate. + // +optional + // +patchMergeKey=name + // +patchStrategy=merge + // +listType=map + // +listMapKey=name + SchedulingGates []PodSchedulingGate `json:"schedulingGates,omitempty" patchStrategy:"merge" patchMergeKey:"name" protobuf:"bytes,38,opt,name=schedulingGates"` } // OSName is the set of OS'es that can be used in OS. @@ -3347,6 +3361,13 @@ type PodOS struct { Name OSName `json:"name" protobuf:"bytes,1,opt,name=name"` } +// PodSchedulingGate is associated to a Pod to guard its scheduling. +type PodSchedulingGate struct { + // Name of the scheduling gate. + // Each scheduling gate must have a unique name field. + Name string `json:"name" protobuf:"bytes,1,opt,name=name"` +} + // +enum type UnsatisfiableConstraintAction string @@ -4526,7 +4547,7 @@ type ServiceSpec struct { SessionAffinityConfig *SessionAffinityConfig `json:"sessionAffinityConfig,omitempty" protobuf:"bytes,14,opt,name=sessionAffinityConfig"` // TopologyKeys is tombstoned to show why 16 is reserved protobuf tag. - //TopologyKeys []string `json:"topologyKeys,omitempty" protobuf:"bytes,16,opt,name=topologyKeys"` + // TopologyKeys []string `json:"topologyKeys,omitempty" protobuf:"bytes,16,opt,name=topologyKeys"` // IPFamily is tombstoned to show why 15 is a reserved protobuf tag. // IPFamily *IPFamily `json:"ipFamily,omitempty" protobuf:"bytes,15,opt,name=ipFamily,Configcasttype=IPFamily"` 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 4a2394a5246..9469433cdcb 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 @@ -1606,6 +1606,15 @@ func (PodReadinessGate) SwaggerDoc() map[string]string { return map_PodReadinessGate } +var map_PodSchedulingGate = map[string]string{ + "": "PodSchedulingGate is associated to a Pod to guard its scheduling.", + "name": "Name of the scheduling gate. Each scheduling gate must have a unique name field.", +} + +func (PodSchedulingGate) SwaggerDoc() map[string]string { + return map_PodSchedulingGate +} + var map_PodSecurityContext = map[string]string{ "": "PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext.", "seLinuxOptions": "The SELinux context to be applied to all containers. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.", @@ -1672,6 +1681,7 @@ var map_PodSpec = map[string]string{ "setHostnameAsFQDN": "If true the pod's hostname will be configured as the pod's FQDN, rather than the leaf name (the default). In Linux containers, this means setting the FQDN in the hostname field of the kernel (the nodename field of struct utsname). In Windows containers, this means setting the registry value of hostname for the registry key HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters to FQDN. If a pod does not have FQDN, this has no effect. Default to false.", "os": "Specifies the OS of the containers in the pod. Some pod and container fields are restricted if this is set.\n\nIf the OS field is set to linux, the following fields must be unset: -securityContext.windowsOptions\n\nIf the OS field is set to windows, following fields must be unset: - spec.hostPID - spec.hostIPC - spec.hostUsers - spec.securityContext.seLinuxOptions - spec.securityContext.seccompProfile - spec.securityContext.fsGroup - spec.securityContext.fsGroupChangePolicy - spec.securityContext.sysctls - spec.shareProcessNamespace - spec.securityContext.runAsUser - spec.securityContext.runAsGroup - spec.securityContext.supplementalGroups - spec.containers[*].securityContext.seLinuxOptions - spec.containers[*].securityContext.seccompProfile - spec.containers[*].securityContext.capabilities - spec.containers[*].securityContext.readOnlyRootFilesystem - spec.containers[*].securityContext.privileged - spec.containers[*].securityContext.allowPrivilegeEscalation - spec.containers[*].securityContext.procMount - spec.containers[*].securityContext.runAsUser - spec.containers[*].securityContext.runAsGroup", "hostUsers": "Use the host's user namespace. Optional: Default to true. If set to true or not present, the pod will be run in the host user namespace, useful for when the pod needs a feature only available to the host user namespace, such as loading a kernel module with CAP_SYS_MODULE. When set to false, a new userns is created for the pod. Setting false is useful for mitigating container breakout vulnerabilities even allowing users to run their containers as root without actually having root privileges on the host. This field is alpha-level and is only honored by servers that enable the UserNamespacesSupport feature.", + "schedulingGates": "SchedulingGates is an opaque list of values that if specified will block scheduling the pod. More info: https://git.k8s.io/enhancements/keps/sig-scheduling/3521-pod-scheduling-readiness.\n\nThis is an alpha-level feature enabled by PodSchedulingReadiness feature gate.", } 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 e5a644ead94..9c6759d040b 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 @@ -3726,6 +3726,22 @@ func (in *PodReadinessGate) DeepCopy() *PodReadinessGate { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PodSchedulingGate) DeepCopyInto(out *PodSchedulingGate) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodSchedulingGate. +func (in *PodSchedulingGate) DeepCopy() *PodSchedulingGate { + if in == nil { + return nil + } + out := new(PodSchedulingGate) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *PodSecurityContext) DeepCopyInto(out *PodSecurityContext) { *out = *in @@ -3959,6 +3975,11 @@ func (in *PodSpec) DeepCopyInto(out *PodSpec) { *out = new(bool) **out = **in } + if in.SchedulingGates != nil { + in, out := &in.SchedulingGates, &out.SchedulingGates + *out = make([]PodSchedulingGate, len(*in)) + copy(*out, *in) + } return } diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.json b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.json index 440a290800c..d2c30d50118 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.json +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.json @@ -1626,7 +1626,12 @@ "os": { "name": "nameValue" }, - "hostUsers": true + "hostUsers": true, + "schedulingGates": [ + { + "name": "nameValue" + } + ] } }, "updateStrategy": { diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.pb b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.pb index 7f782b11a65..0031ce8bd09 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.pb and b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.yaml index 8d724ce14e6..88841e5f823 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.yaml @@ -802,6 +802,8 @@ spec: restartPolicy: restartPolicyValue runtimeClassName: runtimeClassNameValue schedulerName: schedulerNameValue + schedulingGates: + - name: nameValue securityContext: fsGroup: 5 fsGroupChangePolicy: fsGroupChangePolicyValue diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.Deployment.json b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.Deployment.json index aa1a1cdab78..a32f6acf114 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.Deployment.json +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.Deployment.json @@ -1627,7 +1627,12 @@ "os": { "name": "nameValue" }, - "hostUsers": true + "hostUsers": true, + "schedulingGates": [ + { + "name": "nameValue" + } + ] } }, "strategy": { diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.Deployment.pb b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.Deployment.pb index 7ec2e672536..bdd62fc53d5 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.Deployment.pb and b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.Deployment.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.Deployment.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.Deployment.yaml index 397983f3046..b0a3d1a20e8 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.Deployment.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.Deployment.yaml @@ -810,6 +810,8 @@ spec: restartPolicy: restartPolicyValue runtimeClassName: runtimeClassNameValue schedulerName: schedulerNameValue + schedulingGates: + - name: nameValue securityContext: fsGroup: 5 fsGroupChangePolicy: fsGroupChangePolicyValue diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.json b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.json index 5d1844d0a29..192d248ad80 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.json +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.json @@ -1628,7 +1628,12 @@ "os": { "name": "nameValue" }, - "hostUsers": true + "hostUsers": true, + "schedulingGates": [ + { + "name": "nameValue" + } + ] } } }, diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.pb b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.pb index 42d81efc550..851de10a56b 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.pb and b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.yaml index 04363598893..2ee51097e8a 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.yaml @@ -802,6 +802,8 @@ spec: restartPolicy: restartPolicyValue runtimeClassName: runtimeClassNameValue schedulerName: schedulerNameValue + schedulingGates: + - name: nameValue securityContext: fsGroup: 5 fsGroupChangePolicy: fsGroupChangePolicyValue diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.json b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.json index 630ae21a88f..c7397a234a8 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.json +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.json @@ -1627,7 +1627,12 @@ "os": { "name": "nameValue" }, - "hostUsers": true + "hostUsers": true, + "schedulingGates": [ + { + "name": "nameValue" + } + ] } }, "volumeClaimTemplates": [ diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.pb b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.pb index a3a89c37be8..9bf609b38e2 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.pb and b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.yaml index e9ffff7c708..39fe9ab7eb1 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.yaml @@ -808,6 +808,8 @@ spec: restartPolicy: restartPolicyValue runtimeClassName: runtimeClassNameValue schedulerName: schedulerNameValue + schedulingGates: + - name: nameValue securityContext: fsGroup: 5 fsGroupChangePolicy: fsGroupChangePolicyValue diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.Deployment.json b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.Deployment.json index 1a3bca726f3..a651d268f7f 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.Deployment.json +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.Deployment.json @@ -1627,7 +1627,12 @@ "os": { "name": "nameValue" }, - "hostUsers": true + "hostUsers": true, + "schedulingGates": [ + { + "name": "nameValue" + } + ] } }, "strategy": { diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.Deployment.pb b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.Deployment.pb index d95c913c352..06eacb84b6d 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.Deployment.pb and b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.Deployment.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.Deployment.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.Deployment.yaml index cf6ce10867a..4fd200b9bc0 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.Deployment.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.Deployment.yaml @@ -812,6 +812,8 @@ spec: restartPolicy: restartPolicyValue runtimeClassName: runtimeClassNameValue schedulerName: schedulerNameValue + schedulingGates: + - name: nameValue securityContext: fsGroup: 5 fsGroupChangePolicy: fsGroupChangePolicyValue diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.json b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.json index b2e723c3f02..a84e28cd9ec 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.json +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.json @@ -1627,7 +1627,12 @@ "os": { "name": "nameValue" }, - "hostUsers": true + "hostUsers": true, + "schedulingGates": [ + { + "name": "nameValue" + } + ] } }, "volumeClaimTemplates": [ diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.pb b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.pb index fe6716c7376..99a2898ed05 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.pb and b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.yaml index e13510a7d5b..37b479b9dff 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta1.StatefulSet.yaml @@ -808,6 +808,8 @@ spec: restartPolicy: restartPolicyValue runtimeClassName: runtimeClassNameValue schedulerName: schedulerNameValue + schedulingGates: + - name: nameValue securityContext: fsGroup: 5 fsGroupChangePolicy: fsGroupChangePolicyValue diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.json b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.json index a3bd480c5a5..b0a8ab9fc57 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.json +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.json @@ -1626,7 +1626,12 @@ "os": { "name": "nameValue" }, - "hostUsers": true + "hostUsers": true, + "schedulingGates": [ + { + "name": "nameValue" + } + ] } }, "updateStrategy": { diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.pb b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.pb index 0dd7a5064d5..ae5da05a928 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.pb and b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.yaml index 9202c0d541d..ec5b8db2465 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.yaml @@ -802,6 +802,8 @@ spec: restartPolicy: restartPolicyValue runtimeClassName: runtimeClassNameValue schedulerName: schedulerNameValue + schedulingGates: + - name: nameValue securityContext: fsGroup: 5 fsGroupChangePolicy: fsGroupChangePolicyValue diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.json b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.json index 3e705d2bd5d..c53c398186c 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.json +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.json @@ -1627,7 +1627,12 @@ "os": { "name": "nameValue" }, - "hostUsers": true + "hostUsers": true, + "schedulingGates": [ + { + "name": "nameValue" + } + ] } }, "strategy": { diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.pb b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.pb index 5fe69ef8e65..36dd3fa1e17 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.pb and b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.yaml index 18054366cc2..3c448d2fe6b 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.yaml @@ -810,6 +810,8 @@ spec: restartPolicy: restartPolicyValue runtimeClassName: runtimeClassNameValue schedulerName: schedulerNameValue + schedulingGates: + - name: nameValue securityContext: fsGroup: 5 fsGroupChangePolicy: fsGroupChangePolicyValue diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.ReplicaSet.json b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.ReplicaSet.json index 0f6ecc2f2a5..b3286c0cbe0 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.ReplicaSet.json +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.ReplicaSet.json @@ -1628,7 +1628,12 @@ "os": { "name": "nameValue" }, - "hostUsers": true + "hostUsers": true, + "schedulingGates": [ + { + "name": "nameValue" + } + ] } } }, diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.ReplicaSet.pb b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.ReplicaSet.pb index 031ea06428c..6d274496fb8 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.ReplicaSet.pb and b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.ReplicaSet.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.ReplicaSet.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.ReplicaSet.yaml index 1285dac5236..8d017573fbc 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.ReplicaSet.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.ReplicaSet.yaml @@ -802,6 +802,8 @@ spec: restartPolicy: restartPolicyValue runtimeClassName: runtimeClassNameValue schedulerName: schedulerNameValue + schedulingGates: + - name: nameValue securityContext: fsGroup: 5 fsGroupChangePolicy: fsGroupChangePolicyValue diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.json b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.json index 552f7fd1ab6..ee9f9a50ad8 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.json +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.json @@ -1627,7 +1627,12 @@ "os": { "name": "nameValue" }, - "hostUsers": true + "hostUsers": true, + "schedulingGates": [ + { + "name": "nameValue" + } + ] } }, "volumeClaimTemplates": [ diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.pb b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.pb index fe44f78b626..10444635571 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.pb and b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.yaml index 33129967f80..c9afd6747ab 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.StatefulSet.yaml @@ -808,6 +808,8 @@ spec: restartPolicy: restartPolicyValue runtimeClassName: runtimeClassNameValue schedulerName: schedulerNameValue + schedulingGates: + - name: nameValue securityContext: fsGroup: 5 fsGroupChangePolicy: fsGroupChangePolicyValue diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1.CronJob.json b/staging/src/k8s.io/api/testdata/HEAD/batch.v1.CronJob.json index d4c617aecb7..4272a886010 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/batch.v1.CronJob.json +++ b/staging/src/k8s.io/api/testdata/HEAD/batch.v1.CronJob.json @@ -1700,7 +1700,12 @@ "os": { "name": "nameValue" }, - "hostUsers": true + "hostUsers": true, + "schedulingGates": [ + { + "name": "nameValue" + } + ] } }, "ttlSecondsAfterFinished": 8, diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1.CronJob.pb b/staging/src/k8s.io/api/testdata/HEAD/batch.v1.CronJob.pb index 5504c82e6ad..9f94363a9f7 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/batch.v1.CronJob.pb and b/staging/src/k8s.io/api/testdata/HEAD/batch.v1.CronJob.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1.CronJob.yaml b/staging/src/k8s.io/api/testdata/HEAD/batch.v1.CronJob.yaml index 5f6569b502f..c60f0e8a1a8 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/batch.v1.CronJob.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/batch.v1.CronJob.yaml @@ -854,6 +854,8 @@ spec: restartPolicy: restartPolicyValue runtimeClassName: runtimeClassNameValue schedulerName: schedulerNameValue + schedulingGates: + - name: nameValue securityContext: fsGroup: 5 fsGroupChangePolicy: fsGroupChangePolicyValue diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.json b/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.json index 9ab1a8c374d..10ed69cf8c8 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.json +++ b/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.json @@ -1651,7 +1651,12 @@ "os": { "name": "nameValue" }, - "hostUsers": true + "hostUsers": true, + "schedulingGates": [ + { + "name": "nameValue" + } + ] } }, "ttlSecondsAfterFinished": 8, diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.pb b/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.pb index a83ca371d23..812fb630a82 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.pb and b/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.yaml b/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.yaml index 34bf69eb318..2c54eda338a 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.yaml @@ -818,6 +818,8 @@ spec: restartPolicy: restartPolicyValue runtimeClassName: runtimeClassNameValue schedulerName: schedulerNameValue + schedulingGates: + - name: nameValue securityContext: fsGroup: 5 fsGroupChangePolicy: fsGroupChangePolicyValue diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.json b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.json index 6faf258a8e3..43ca3d6052f 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.json +++ b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.json @@ -1700,7 +1700,12 @@ "os": { "name": "nameValue" }, - "hostUsers": true + "hostUsers": true, + "schedulingGates": [ + { + "name": "nameValue" + } + ] } }, "ttlSecondsAfterFinished": 8, diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.pb b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.pb index 5ced1e5421c..9943f47c579 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.pb and b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.yaml b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.yaml index 42fb068d633..0e638391c78 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.yaml @@ -854,6 +854,8 @@ spec: restartPolicy: restartPolicyValue runtimeClassName: runtimeClassNameValue schedulerName: schedulerNameValue + schedulingGates: + - name: nameValue securityContext: fsGroup: 5 fsGroupChangePolicy: fsGroupChangePolicyValue diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.json b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.json index 804679ceeb6..d16516333c9 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.json +++ b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.json @@ -1694,7 +1694,12 @@ "os": { "name": "nameValue" }, - "hostUsers": true + "hostUsers": true, + "schedulingGates": [ + { + "name": "nameValue" + } + ] } }, "ttlSecondsAfterFinished": 8, diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.pb b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.pb index 8ad50386474..5c48e2e2e5d 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.pb and b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.yaml b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.yaml index 07a53c69f35..81e4caf2fb9 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.yaml @@ -851,6 +851,8 @@ template: restartPolicy: restartPolicyValue runtimeClassName: runtimeClassNameValue schedulerName: schedulerNameValue + schedulingGates: + - name: nameValue securityContext: fsGroup: 5 fsGroupChangePolicy: fsGroupChangePolicyValue diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.json b/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.json index 702391f0593..3085dc6c7df 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.json +++ b/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.json @@ -1568,7 +1568,12 @@ "os": { "name": "nameValue" }, - "hostUsers": true + "hostUsers": true, + "schedulingGates": [ + { + "name": "nameValue" + } + ] }, "status": { "phase": "phaseValue", diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.pb b/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.pb index 7402a5fa786..ee56d74ed94 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.pb and b/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.yaml b/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.yaml index 96b92ed1129..4eb4c150db7 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.yaml @@ -758,6 +758,8 @@ spec: restartPolicy: restartPolicyValue runtimeClassName: runtimeClassNameValue schedulerName: schedulerNameValue + schedulingGates: + - name: nameValue securityContext: fsGroup: 5 fsGroupChangePolicy: fsGroupChangePolicyValue diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.json b/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.json index c2c9618f84c..c01fc878411 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.json +++ b/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.json @@ -1611,7 +1611,12 @@ "os": { "name": "nameValue" }, - "hostUsers": true + "hostUsers": true, + "schedulingGates": [ + { + "name": "nameValue" + } + ] } } } \ No newline at end of file diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.pb b/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.pb index e2fb1454e67..7340ab2b6f1 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.pb and b/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.yaml b/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.yaml index 1906bbf2911..3deb4feebb9 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.yaml @@ -791,6 +791,8 @@ template: restartPolicy: restartPolicyValue runtimeClassName: runtimeClassNameValue schedulerName: schedulerNameValue + schedulingGates: + - name: nameValue securityContext: fsGroup: 5 fsGroupChangePolicy: fsGroupChangePolicyValue diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.ReplicationController.json b/staging/src/k8s.io/api/testdata/HEAD/core.v1.ReplicationController.json index adfcd8b6ec3..ad081b11b9a 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/core.v1.ReplicationController.json +++ b/staging/src/k8s.io/api/testdata/HEAD/core.v1.ReplicationController.json @@ -1617,7 +1617,12 @@ "os": { "name": "nameValue" }, - "hostUsers": true + "hostUsers": true, + "schedulingGates": [ + { + "name": "nameValue" + } + ] } } }, diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.ReplicationController.pb b/staging/src/k8s.io/api/testdata/HEAD/core.v1.ReplicationController.pb index 522c53c34e1..930bc3937c3 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/core.v1.ReplicationController.pb and b/staging/src/k8s.io/api/testdata/HEAD/core.v1.ReplicationController.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.ReplicationController.yaml b/staging/src/k8s.io/api/testdata/HEAD/core.v1.ReplicationController.yaml index 7e445f90bba..c0b46d39287 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/core.v1.ReplicationController.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/core.v1.ReplicationController.yaml @@ -796,6 +796,8 @@ spec: restartPolicy: restartPolicyValue runtimeClassName: runtimeClassNameValue schedulerName: schedulerNameValue + schedulingGates: + - name: nameValue securityContext: fsGroup: 5 fsGroupChangePolicy: fsGroupChangePolicyValue diff --git a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.json b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.json index 81467a1084f..248226989b9 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.json +++ b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.json @@ -1626,7 +1626,12 @@ "os": { "name": "nameValue" }, - "hostUsers": true + "hostUsers": true, + "schedulingGates": [ + { + "name": "nameValue" + } + ] } }, "updateStrategy": { diff --git a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.pb b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.pb index 5c9290df729..d7aac25d57f 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.pb and b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.yaml b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.yaml index 6d428f16e92..86ec73ff845 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.yaml @@ -802,6 +802,8 @@ spec: restartPolicy: restartPolicyValue runtimeClassName: runtimeClassNameValue schedulerName: schedulerNameValue + schedulingGates: + - name: nameValue securityContext: fsGroup: 5 fsGroupChangePolicy: fsGroupChangePolicyValue diff --git a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.json b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.json index 4d91f98f92d..9457abac502 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.json +++ b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.json @@ -1627,7 +1627,12 @@ "os": { "name": "nameValue" }, - "hostUsers": true + "hostUsers": true, + "schedulingGates": [ + { + "name": "nameValue" + } + ] } }, "strategy": { diff --git a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.pb b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.pb index 6ee00a1c040..259dbb242c7 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.pb and b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.yaml b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.yaml index ecf17efe773..2dbf7d1fa4d 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.yaml @@ -812,6 +812,8 @@ spec: restartPolicy: restartPolicyValue runtimeClassName: runtimeClassNameValue schedulerName: schedulerNameValue + schedulingGates: + - name: nameValue securityContext: fsGroup: 5 fsGroupChangePolicy: fsGroupChangePolicyValue diff --git a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.json b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.json index 293d3035422..b7def761682 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.json +++ b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.json @@ -1628,7 +1628,12 @@ "os": { "name": "nameValue" }, - "hostUsers": true + "hostUsers": true, + "schedulingGates": [ + { + "name": "nameValue" + } + ] } } }, diff --git a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.pb b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.pb index 3a53bd23ddc..1f6d2971f62 100644 Binary files a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.pb and b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.pb differ diff --git a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.yaml b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.yaml index be99c823cb2..0363a415347 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.yaml @@ -802,6 +802,8 @@ spec: restartPolicy: restartPolicyValue runtimeClassName: runtimeClassNameValue schedulerName: schedulerNameValue + schedulingGates: + - name: nameValue securityContext: fsGroup: 5 fsGroupChangePolicy: fsGroupChangePolicyValue diff --git a/staging/src/k8s.io/client-go/applyconfigurations/core/v1/podschedulinggate.go b/staging/src/k8s.io/client-go/applyconfigurations/core/v1/podschedulinggate.go new file mode 100644 index 00000000000..f7649c2e921 --- /dev/null +++ b/staging/src/k8s.io/client-go/applyconfigurations/core/v1/podschedulinggate.go @@ -0,0 +1,39 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1 + +// PodSchedulingGateApplyConfiguration represents an declarative configuration of the PodSchedulingGate type for use +// with apply. +type PodSchedulingGateApplyConfiguration struct { + Name *string `json:"name,omitempty"` +} + +// PodSchedulingGateApplyConfiguration constructs an declarative configuration of the PodSchedulingGate type for use with +// apply. +func PodSchedulingGate() *PodSchedulingGateApplyConfiguration { + return &PodSchedulingGateApplyConfiguration{} +} + +// WithName sets the Name field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Name field is set to the value of the last call. +func (b *PodSchedulingGateApplyConfiguration) WithName(value string) *PodSchedulingGateApplyConfiguration { + b.Name = &value + return b +} diff --git a/staging/src/k8s.io/client-go/applyconfigurations/core/v1/podspec.go b/staging/src/k8s.io/client-go/applyconfigurations/core/v1/podspec.go index f638b5d9123..984c6160128 100644 --- a/staging/src/k8s.io/client-go/applyconfigurations/core/v1/podspec.go +++ b/staging/src/k8s.io/client-go/applyconfigurations/core/v1/podspec.go @@ -62,6 +62,7 @@ type PodSpecApplyConfiguration struct { SetHostnameAsFQDN *bool `json:"setHostnameAsFQDN,omitempty"` OS *PodOSApplyConfiguration `json:"os,omitempty"` HostUsers *bool `json:"hostUsers,omitempty"` + SchedulingGates []PodSchedulingGateApplyConfiguration `json:"schedulingGates,omitempty"` } // PodSpecApplyConfiguration constructs an declarative configuration of the PodSpec type for use with @@ -416,3 +417,16 @@ func (b *PodSpecApplyConfiguration) WithHostUsers(value bool) *PodSpecApplyConfi b.HostUsers = &value return b } + +// WithSchedulingGates adds the given value to the SchedulingGates field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the SchedulingGates field. +func (b *PodSpecApplyConfiguration) WithSchedulingGates(values ...*PodSchedulingGateApplyConfiguration) *PodSpecApplyConfiguration { + for i := range values { + if values[i] == nil { + panic("nil value passed to WithSchedulingGates") + } + b.SchedulingGates = append(b.SchedulingGates, *values[i]) + } + return b +} diff --git a/staging/src/k8s.io/client-go/applyconfigurations/internal/internal.go b/staging/src/k8s.io/client-go/applyconfigurations/internal/internal.go index de1fdfec1c9..8a71eb63690 100644 --- a/staging/src/k8s.io/client-go/applyconfigurations/internal/internal.go +++ b/staging/src/k8s.io/client-go/applyconfigurations/internal/internal.go @@ -5725,6 +5725,13 @@ var schemaYAML = typed.YAMLObject(`types: type: scalar: string default: "" +- name: io.k8s.api.core.v1.PodSchedulingGate + map: + fields: + - name: name + type: + scalar: string + default: "" - name: io.k8s.api.core.v1.PodSecurityContext map: fields: @@ -5881,6 +5888,14 @@ var schemaYAML = typed.YAMLObject(`types: - name: schedulerName type: scalar: string + - name: schedulingGates + type: + list: + elementType: + namedType: io.k8s.api.core.v1.PodSchedulingGate + elementRelationship: associative + keys: + - name - name: securityContext type: namedType: io.k8s.api.core.v1.PodSecurityContext diff --git a/staging/src/k8s.io/client-go/applyconfigurations/utils.go b/staging/src/k8s.io/client-go/applyconfigurations/utils.go index 1ef550b5cb3..dfc58c14798 100644 --- a/staging/src/k8s.io/client-go/applyconfigurations/utils.go +++ b/staging/src/k8s.io/client-go/applyconfigurations/utils.go @@ -735,6 +735,8 @@ func ForKind(kind schema.GroupVersionKind) interface{} { return &applyconfigurationscorev1.PodOSApplyConfiguration{} case corev1.SchemeGroupVersion.WithKind("PodReadinessGate"): return &applyconfigurationscorev1.PodReadinessGateApplyConfiguration{} + case corev1.SchemeGroupVersion.WithKind("PodSchedulingGate"): + return &applyconfigurationscorev1.PodSchedulingGateApplyConfiguration{} case corev1.SchemeGroupVersion.WithKind("PodSecurityContext"): return &applyconfigurationscorev1.PodSecurityContextApplyConfiguration{} case corev1.SchemeGroupVersion.WithKind("PodSpec"): diff --git a/test/e2e/framework/pod/wait_test.go b/test/e2e/framework/pod/wait_test.go index 5939fba6ab5..3cae475458d 100644 --- a/test/e2e/framework/pod/wait_test.go +++ b/test/e2e/framework/pod/wait_test.go @@ -184,6 +184,7 @@ INFO: Unexpected error: wait for pod pending-pod running: SetHostnameAsFQDN: nil, OS: nil, HostUsers: nil, + SchedulingGates: nil, }, Status: { Phase: "",