From eee5fa8b8d35a3b786af806fc57e9e7bf6553264 Mon Sep 17 00:00:00 2001 From: Giuseppe Scrivano Date: Thu, 14 Jul 2022 09:55:16 +0200 Subject: [PATCH 01/12] volume: use the effective uid Signed-off-by: Giuseppe Scrivano --- pkg/volume/volume_linux_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkg/volume/volume_linux_test.go b/pkg/volume/volume_linux_test.go index 38c3b5b3c7c8..a4078879ab4d 100644 --- a/pkg/volume/volume_linux_test.go +++ b/pkg/volume/volume_linux_test.go @@ -342,7 +342,7 @@ func verifyDirectoryPermission(path string, readonly bool) bool { func TestSetVolumeOwnershipOwner(t *testing.T) { fsGroup := int64(3000) - currentUid := os.Getuid() + currentUid := os.Geteuid() if currentUid != 0 { t.Skip("running as non-root") } From 9e9b23fd3ca6c0c58ee401b18a65422c0564bec0 Mon Sep 17 00:00:00 2001 From: Giuseppe Scrivano Date: Thu, 7 Jul 2022 21:43:51 +0200 Subject: [PATCH 02/12] pkg/apis, staging: add HostUsers to pod spec It is used to request that a pod runs in a unique user namespace. Signed-off-by: Giuseppe Scrivano Signed-off-by: Rodrigo Campos Co-authored-by: Rodrigo Campos --- pkg/apis/core/types.go | 13 +++++++++++++ pkg/apis/core/v1/conversion.go | 2 ++ pkg/apis/core/validation/validation.go | 3 +++ staging/src/k8s.io/api/core/v1/types.go | 13 +++++++++++++ .../applyconfigurations/core/v1/podspec.go | 9 +++++++++ .../policy/check_hostNamespaces.go | 2 +- test/e2e/framework/pod/wait_test.go | 1 + 7 files changed, 42 insertions(+), 1 deletion(-) diff --git a/pkg/apis/core/types.go b/pkg/apis/core/types.go index a140753fb61b..9de322165eaa 100644 --- a/pkg/apis/core/types.go +++ b/pkg/apis/core/types.go @@ -2976,6 +2976,7 @@ type PodSpec struct { // If 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 @@ -3078,6 +3079,18 @@ type PodSecurityContext struct { // +k8s:conversion-gen=false // +optional ShareProcessNamespace *bool + // 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 user namespace 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. + // Note that this field cannot be set when spec.os.name is windows. + // +k8s:conversion-gen=false + // +optional + HostUsers *bool // 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 diff --git a/pkg/apis/core/v1/conversion.go b/pkg/apis/core/v1/conversion.go index d89ea26354b8..7869f0389b90 100644 --- a/pkg/apis/core/v1/conversion.go +++ b/pkg/apis/core/v1/conversion.go @@ -303,6 +303,7 @@ func Convert_core_PodSpec_To_v1_PodSpec(in *core.PodSpec, out *v1.PodSpec, s con out.HostNetwork = in.SecurityContext.HostNetwork out.HostIPC = in.SecurityContext.HostIPC out.ShareProcessNamespace = in.SecurityContext.ShareProcessNamespace + out.HostUsers = in.SecurityContext.HostUsers } return nil @@ -358,6 +359,7 @@ func Convert_v1_PodSpec_To_core_PodSpec(in *v1.PodSpec, out *core.PodSpec, s con out.SecurityContext.HostPID = in.HostPID out.SecurityContext.HostIPC = in.HostIPC out.SecurityContext.ShareProcessNamespace = in.ShareProcessNamespace + out.SecurityContext.HostUsers = in.HostUsers return nil } diff --git a/pkg/apis/core/validation/validation.go b/pkg/apis/core/validation/validation.go index fd8a67b23134..f6a7e417fd9f 100644 --- a/pkg/apis/core/validation/validation.go +++ b/pkg/apis/core/validation/validation.go @@ -3637,6 +3637,9 @@ func validateWindows(spec *core.PodSpec, fldPath *field.Path) field.ErrorList { if securityContext.SELinuxOptions != nil { allErrs = append(allErrs, field.Forbidden(fldPath.Child("securityContext").Child("seLinuxOptions"), "cannot be set for a windows pod")) } + if securityContext.HostUsers != nil { + allErrs = append(allErrs, field.Forbidden(fldPath.Child("hostUsers"), "cannot be set for a windows pod")) + } if securityContext.HostPID { allErrs = append(allErrs, field.Forbidden(fldPath.Child("hostPID"), "cannot be set for a windows pod")) } diff --git a/staging/src/k8s.io/api/core/v1/types.go b/staging/src/k8s.io/api/core/v1/types.go index f643bd80954a..a98e35d706c4 100644 --- a/staging/src/k8s.io/api/core/v1/types.go +++ b/staging/src/k8s.io/api/core/v1/types.go @@ -3289,6 +3289,7 @@ type PodSpec struct { // If 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 @@ -3309,6 +3310,18 @@ type PodSpec struct { // - spec.containers[*].securityContext.runAsGroup // +optional OS *PodOS `json:"os,omitempty" protobuf:"bytes,36,opt,name=os"` + // 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. + // +k8s:conversion-gen=false + // +optional + HostUsers *bool `json:"hostUsers,omitempty" protobuf:"bytes,37,opt,name=hostUsers"` } // OSName is the set of OS'es that can be used in OS. 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 015859e9a388..d3d3e028445e 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 @@ -41,6 +41,7 @@ type PodSpecApplyConfiguration struct { HostNetwork *bool `json:"hostNetwork,omitempty"` HostPID *bool `json:"hostPID,omitempty"` HostIPC *bool `json:"hostIPC,omitempty"` + HostUsers *bool `json:"hostUsers,omitempty"` ShareProcessNamespace *bool `json:"shareProcessNamespace,omitempty"` SecurityContext *PodSecurityContextApplyConfiguration `json:"securityContext,omitempty"` ImagePullSecrets []LocalObjectReferenceApplyConfiguration `json:"imagePullSecrets,omitempty"` @@ -207,6 +208,14 @@ func (b *PodSpecApplyConfiguration) WithHostNetwork(value bool) *PodSpecApplyCon return b } +// WithHostUsers sets the HostUsers 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 HostUsers field is set to the value of the last call. +func (b *PodSpecApplyConfiguration) WithHostUsers(value *bool) *PodSpecApplyConfiguration { + b.HostUsers = value + return b +} + // WithHostPID sets the HostPID 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 HostPID field is set to the value of the last call. diff --git a/staging/src/k8s.io/pod-security-admission/policy/check_hostNamespaces.go b/staging/src/k8s.io/pod-security-admission/policy/check_hostNamespaces.go index a11e59f9c72b..9092b64e92a4 100644 --- a/staging/src/k8s.io/pod-security-admission/policy/check_hostNamespaces.go +++ b/staging/src/k8s.io/pod-security-admission/policy/check_hostNamespaces.go @@ -25,7 +25,7 @@ import ( ) /* -Sharing the host namespaces must be disallowed. +Sharing the host network, PID, and IPC namespaces must be disallowed. **Restricted Fields:** diff --git a/test/e2e/framework/pod/wait_test.go b/test/e2e/framework/pod/wait_test.go index 8c46f0fd8ac6..5939fba6ab52 100644 --- a/test/e2e/framework/pod/wait_test.go +++ b/test/e2e/framework/pod/wait_test.go @@ -183,6 +183,7 @@ INFO: Unexpected error: wait for pod pending-pod running: TopologySpreadConstraints: nil, SetHostnameAsFQDN: nil, OS: nil, + HostUsers: nil, }, Status: { Phase: "", From 482e76dc2cfe3d4a4603cc9341f34398f6a529bd Mon Sep 17 00:00:00 2001 From: Giuseppe Scrivano Date: Thu, 7 Jul 2022 11:08:32 +0200 Subject: [PATCH 03/12] features: add UserNamespacesSupport feature define a feature gate for the user namespaces support. The feature is not enabled by default. Signed-off-by: Giuseppe Scrivano --- pkg/features/kube_features.go | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/pkg/features/kube_features.go b/pkg/features/kube_features.go index b70a830bf52a..94daf4966159 100644 --- a/pkg/features/kube_features.go +++ b/pkg/features/kube_features.go @@ -813,6 +813,13 @@ const ( // Enable resource managers to make NUMA aligned decisions TopologyManager featuregate.Feature = "TopologyManager" + // owner: @rata, @giuseppe + // kep: http://kep.k8s.io/127 + // alpha: v1.25 + // + // Enables user namespace support for stateless pods. + UserNamespacesStatelessPodsSupport featuregate.Feature = "UserNamespacesStatelessPodsSupport" + // owner: @cofyc // alpha: v1.21 VolumeCapacityPriority featuregate.Feature = "VolumeCapacityPriority" @@ -1071,6 +1078,8 @@ var defaultKubernetesFeatureGates = map[featuregate.Feature]featuregate.FeatureS VolumeCapacityPriority: {Default: false, PreRelease: featuregate.Alpha}, + UserNamespacesStatelessPodsSupport: {Default: false, PreRelease: featuregate.Alpha}, + WinDSR: {Default: false, PreRelease: featuregate.Alpha}, WinOverlay: {Default: true, PreRelease: featuregate.Beta}, From cf8164bccfc1cc8fa82061cf29813d1570bb6948 Mon Sep 17 00:00:00 2001 From: Rodrigo Campos Date: Thu, 7 Jul 2022 16:49:39 +0200 Subject: [PATCH 04/12] apis: add validation for HostUsers This commit just adds a validation according to KEP-127. We check that only the supported volumes for phase 1 of the KEP are accepted. Signed-off-by: Rodrigo Campos --- pkg/api/pod/util.go | 18 +++ pkg/api/pod/util_test.go | 97 ++++++++++++ pkg/apis/core/validation/validation.go | 47 ++++++ pkg/apis/core/validation/validation_test.go | 167 ++++++++++++++++++++ 4 files changed, 329 insertions(+) diff --git a/pkg/api/pod/util.go b/pkg/api/pod/util.go index a0af5b15de9a..819bd63d1741 100644 --- a/pkg/api/pod/util.go +++ b/pkg/api/pod/util.go @@ -539,6 +539,15 @@ func dropDisabledFields( }) } + // If the feature is disabled and not in use, drop the hostUsers field. + if !utilfeature.DefaultFeatureGate.Enabled(features.UserNamespacesStatelessPodsSupport) && !hostUsersInUse(oldPodSpec) { + // Drop the field in podSpec only if SecurityContext is not nil. + // If it is nil, there is no need to set hostUsers=nil (it will be nil too). + if podSpec.SecurityContext != nil { + podSpec.SecurityContext.HostUsers = nil + } + } + dropDisabledProcMountField(podSpec, oldPodSpec) dropDisabledCSIVolumeSourceAlphaFields(podSpec, oldPodSpec) @@ -672,6 +681,15 @@ func nodeTaintsPolicyInUse(podSpec *api.PodSpec) bool { return false } +// hostUsersInUse returns true if the pod spec has spec.hostUsers field set. +func hostUsersInUse(podSpec *api.PodSpec) bool { + if podSpec != nil && podSpec.SecurityContext != nil && podSpec.SecurityContext.HostUsers != nil { + return true + } + + return false +} + // procMountInUse returns true if the pod spec is non-nil and has a SecurityContext's ProcMount field set to a non-default value func procMountInUse(podSpec *api.PodSpec) bool { if podSpec == nil { diff --git a/pkg/api/pod/util_test.go b/pkg/api/pod/util_test.go index c536cc006fff..4796010a9d20 100644 --- a/pkg/api/pod/util_test.go +++ b/pkg/api/pod/util_test.go @@ -1949,3 +1949,100 @@ func TestDropDisabledMatchLabelKeysField(t *testing.T) { }) } } + +func TestDropHostUsers(t *testing.T) { + falseVar := false + trueVar := true + + podWithoutHostUsers := func() *api.Pod { + return &api.Pod{ + Spec: api.PodSpec{ + SecurityContext: &api.PodSecurityContext{}}, + } + } + podWithHostUsersFalse := func() *api.Pod { + return &api.Pod{ + Spec: api.PodSpec{ + SecurityContext: &api.PodSecurityContext{ + HostUsers: &falseVar, + }, + }, + } + } + podWithHostUsersTrue := func() *api.Pod { + return &api.Pod{ + Spec: api.PodSpec{ + SecurityContext: &api.PodSecurityContext{ + HostUsers: &trueVar, + }, + }, + } + } + + podInfo := []struct { + description string + hasHostUsers bool + pod func() *api.Pod + }{ + { + description: "with hostUsers=true", + hasHostUsers: true, + pod: podWithHostUsersTrue, + }, + { + description: "with hostUsers=false", + hasHostUsers: true, + pod: podWithHostUsersFalse, + }, + { + description: "with hostUsers=nil", + pod: func() *api.Pod { return nil }, + }, + } + + for _, enabled := range []bool{true, false} { + for _, oldPodInfo := range podInfo { + for _, newPodInfo := range podInfo { + oldPodHasHostUsers, oldPod := oldPodInfo.hasHostUsers, oldPodInfo.pod() + newPodHasHostUsers, newPod := newPodInfo.hasHostUsers, 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.UserNamespacesStatelessPodsSupport, enabled)() + + DropDisabledPodFields(newPod, oldPod) + + // old pod should never be changed + if !reflect.DeepEqual(oldPod, oldPodInfo.pod()) { + t.Errorf("old pod changed: %v", cmp.Diff(oldPod, oldPodInfo.pod())) + } + + switch { + case enabled || oldPodHasHostUsers: + // new pod should not be changed if the feature is enabled, or if the old pod had hostUsers + if !reflect.DeepEqual(newPod, newPodInfo.pod()) { + t.Errorf("new pod changed: %v", cmp.Diff(newPod, newPodInfo.pod())) + } + case newPodHasHostUsers: + // new pod should be changed + if reflect.DeepEqual(newPod, newPodInfo.pod()) { + t.Errorf("new pod was not changed") + } + // new pod should not have hostUsers + if exp := podWithoutHostUsers(); !reflect.DeepEqual(newPod, exp) { + t.Errorf("new pod had hostUsers: %v", cmp.Diff(newPod, exp)) + } + default: + // new pod should not need to be changed + if !reflect.DeepEqual(newPod, newPodInfo.pod()) { + t.Errorf("new pod changed: %v", cmp.Diff(newPod, newPodInfo.pod())) + } + } + }) + } + } + } + +} diff --git a/pkg/apis/core/validation/validation.go b/pkg/apis/core/validation/validation.go index f6a7e417fd9f..a8ea7551061b 100644 --- a/pkg/apis/core/validation/validation.go +++ b/pkg/apis/core/validation/validation.go @@ -3075,6 +3075,52 @@ func validateContainerCommon(ctr *core.Container, volumes map[string]core.Volume allErrs = append(allErrs, validatePullPolicy(ctr.ImagePullPolicy, path.Child("imagePullPolicy"))...) allErrs = append(allErrs, ValidateResourceRequirements(&ctr.Resources, path.Child("resources"), opts)...) allErrs = append(allErrs, ValidateSecurityContext(ctr.SecurityContext, path.Child("securityContext"))...) + return allErrs +} + +func validateHostUsers(spec *core.PodSpec, fldPath *field.Path) field.ErrorList { + allErrs := field.ErrorList{} + + // Only make the following checks if hostUsers is false (otherwise, the container uses the + // same userns as the host, and so there isn't anything to check). + if spec.SecurityContext == nil || spec.SecurityContext.HostUsers == nil || *spec.SecurityContext.HostUsers == true { + return allErrs + } + + // For now only these volumes are supported: + // - configmap + // - secret + // - downwardAPI + // - emptyDir + // - projected + // So reject anything else. + for i, vol := range spec.Volumes { + switch { + case vol.EmptyDir != nil: + case vol.Secret != nil: + case vol.DownwardAPI != nil: + case vol.ConfigMap != nil: + case vol.Projected != nil: + default: + allErrs = append(allErrs, field.Forbidden(fldPath.Child("volumes").Index(i), "volume type not supported when `pod.Spec.HostUsers` is false")) + } + } + + // We decided to restrict the usage of userns with other host namespaces: + // https://github.com/kubernetes/kubernetes/pull/111090#discussion_r935994282 + // The tl;dr is: you can easily run into permission issues that seem unexpected, we don't + // know of any good use case and we can always enable them later. + + // Note we already validated above spec.SecurityContext is not nil. + if spec.SecurityContext.HostNetwork { + allErrs = append(allErrs, field.Forbidden(fldPath.Child("hostNetwork"), "when `pod.Spec.HostUsers` is false")) + } + if spec.SecurityContext.HostPID { + allErrs = append(allErrs, field.Forbidden(fldPath.Child("HostPID"), "when `pod.Spec.HostUsers` is false")) + } + if spec.SecurityContext.HostIPC { + allErrs = append(allErrs, field.Forbidden(fldPath.Child("HostIPC"), "when `pod.Spec.HostUsers` is false")) + } return allErrs } @@ -3545,6 +3591,7 @@ func ValidatePodSpec(spec *core.PodSpec, podMeta *metav1.ObjectMeta, fldPath *fi allErrs = append(allErrs, validateReadinessGates(spec.ReadinessGates, fldPath.Child("readinessGates"))...) allErrs = append(allErrs, validateTopologySpreadConstraints(spec.TopologySpreadConstraints, fldPath.Child("topologySpreadConstraints"))...) allErrs = append(allErrs, validateWindowsHostProcessPod(spec, fldPath, opts)...) + allErrs = append(allErrs, validateHostUsers(spec, fldPath)...) if len(spec.ServiceAccountName) > 0 { for _, msg := range ValidateServiceAccountName(spec.ServiceAccountName, false) { allErrs = append(allErrs, field.Invalid(fldPath.Child("serviceAccountName"), spec.ServiceAccountName, msg)) diff --git a/pkg/apis/core/validation/validation_test.go b/pkg/apis/core/validation/validation_test.go index ce7008bdbc86..0fd71f1264ef 100644 --- a/pkg/apis/core/validation/validation_test.go +++ b/pkg/apis/core/validation/validation_test.go @@ -18277,6 +18277,7 @@ func TestValidateOSFields(t *testing.T) { "SecurityContext.HostIPC", "SecurityContext.HostNetwork", "SecurityContext.HostPID", + "SecurityContext.HostUsers", "SecurityContext.RunAsGroup", "SecurityContext.RunAsUser", "SecurityContext.SELinuxOptions", @@ -20572,6 +20573,172 @@ func TestValidateNonSpecialIP(t *testing.T) { } } +func TestValidateHostUsers(t *testing.T) { + falseVar := false + trueVar := true + + cases := []struct { + name string + success bool + spec *core.PodSpec + }{ + { + name: "empty", + success: true, + spec: &core.PodSpec{}, + }, + { + name: "hostUsers unset", + success: true, + spec: &core.PodSpec{ + SecurityContext: &core.PodSecurityContext{}, + }, + }, + { + name: "hostUsers=false", + success: true, + spec: &core.PodSpec{ + SecurityContext: &core.PodSecurityContext{ + HostUsers: &falseVar, + }, + }, + }, + { + name: "hostUsers=true", + success: true, + spec: &core.PodSpec{ + SecurityContext: &core.PodSecurityContext{ + HostUsers: &trueVar, + }, + }, + }, + { + name: "hostUsers=false & volumes", + success: true, + spec: &core.PodSpec{ + SecurityContext: &core.PodSecurityContext{ + HostUsers: &falseVar, + }, + Volumes: []core.Volume{ + { + Name: "configmap", + VolumeSource: core.VolumeSource{ + ConfigMap: &core.ConfigMapVolumeSource{ + LocalObjectReference: core.LocalObjectReference{Name: "configmap"}, + }, + }, + }, + { + Name: "secret", + VolumeSource: core.VolumeSource{ + Secret: &core.SecretVolumeSource{ + SecretName: "secret", + }, + }, + }, + { + Name: "downward-api", + VolumeSource: core.VolumeSource{ + DownwardAPI: &core.DownwardAPIVolumeSource{}, + }, + }, + { + Name: "proj", + VolumeSource: core.VolumeSource{ + Projected: &core.ProjectedVolumeSource{}, + }, + }, + { + Name: "empty-dir", + VolumeSource: core.VolumeSource{ + EmptyDir: &core.EmptyDirVolumeSource{}, + }, + }, + }, + }, + }, + { + name: "hostUsers=false - unsupported volume", + success: false, + spec: &core.PodSpec{ + SecurityContext: &core.PodSecurityContext{ + HostUsers: &falseVar, + }, + Volumes: []core.Volume{ + { + Name: "host-path", + VolumeSource: core.VolumeSource{ + HostPath: &core.HostPathVolumeSource{}, + }, + }, + }, + }, + }, + { + // It should ignore unsupported volumes with hostUsers=true. + name: "hostUsers=true - unsupported volume", + success: true, + spec: &core.PodSpec{ + SecurityContext: &core.PodSecurityContext{ + HostUsers: &trueVar, + }, + Volumes: []core.Volume{ + { + Name: "host-path", + VolumeSource: core.VolumeSource{ + HostPath: &core.HostPathVolumeSource{}, + }, + }, + }, + }, + }, + { + name: "hostUsers=false & HostNetwork", + success: false, + spec: &core.PodSpec{ + SecurityContext: &core.PodSecurityContext{ + HostUsers: &falseVar, + HostNetwork: true, + }, + }, + }, + { + name: "hostUsers=false & HostPID", + success: false, + spec: &core.PodSpec{ + SecurityContext: &core.PodSecurityContext{ + HostUsers: &falseVar, + HostPID: true, + }, + }, + }, + { + name: "hostUsers=false & HostIPC", + success: false, + spec: &core.PodSpec{ + SecurityContext: &core.PodSecurityContext{ + HostUsers: &falseVar, + HostIPC: true, + }, + }, + }, + } + + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + fPath := field.NewPath("spec") + + allErrs := validateHostUsers(tc.spec, fPath) + if !tc.success && len(allErrs) == 0 { + t.Errorf("Unexpected success") + } + if tc.success && len(allErrs) != 0 { + t.Errorf("Unexpected error(s): %v", allErrs) + } + }) + } +} + func TestValidateWindowsHostProcessPod(t *testing.T) { const containerName = "container" falseVar := false From 63462285d51eea2cc528c11912250e9a15acab41 Mon Sep 17 00:00:00 2001 From: Giuseppe Scrivano Date: Thu, 7 Jul 2022 11:21:33 +0200 Subject: [PATCH 05/12] kubelet: add userns manager it is used to allocate and keep track of the unique users ranges assigned to each pod that runs in a user namespace. Signed-off-by: Giuseppe Scrivano Signed-off-by: Rodrigo Campos Co-authored-by: Rodrigo Campos --- pkg/kubelet/kubelet.go | 9 + pkg/kubelet/kubelet_pods.go | 6 + pkg/kubelet/userns_manager.go | 530 +++++++++++++++++++++++++++++ pkg/kubelet/userns_manager_test.go | 215 ++++++++++++ 4 files changed, 760 insertions(+) create mode 100644 pkg/kubelet/userns_manager.go create mode 100644 pkg/kubelet/userns_manager_test.go diff --git a/pkg/kubelet/kubelet.go b/pkg/kubelet/kubelet.go index bc784890ae28..e5c7c59be631 100644 --- a/pkg/kubelet/kubelet.go +++ b/pkg/kubelet/kubelet.go @@ -837,6 +837,10 @@ func NewMainKubelet(kubeCfg *kubeletconfiginternal.KubeletConfiguration, StateDirectory: rootDirectory, }) klet.shutdownManager = shutdownManager + klet.usernsManager, err = MakeUserNsManager(klet) + if err != nil { + return nil, err + } klet.admitHandlers.AddPodAdmitHandler(shutdownAdmitHandler) // Finally, put the most recent version of the config on the Kubelet, so @@ -1175,6 +1179,9 @@ type Kubelet struct { // Handles node shutdown events for the Node. shutdownManager nodeshutdown.Manager + + // Manage user namespaces + usernsManager *usernsManager } // ListPodStats is delegated to StatsProvider, which implements stats.Provider interface @@ -1889,6 +1896,8 @@ func (kl *Kubelet) syncTerminatedPod(ctx context.Context, pod *v1.Pod, podStatus klog.V(4).InfoS("Pod termination removed cgroups", "pod", klog.KObj(pod), "podUID", pod.UID) } + kl.usernsManager.Release(pod.UID) + // mark the final pod status kl.statusManager.TerminatePod(pod) klog.V(4).InfoS("Pod is terminated and will need no more status updates", "pod", klog.KObj(pod), "podUID", pod.UID) diff --git a/pkg/kubelet/kubelet_pods.go b/pkg/kubelet/kubelet_pods.go index 84d93e09405e..456a2f76e996 100644 --- a/pkg/kubelet/kubelet_pods.go +++ b/pkg/kubelet/kubelet_pods.go @@ -1154,6 +1154,12 @@ func (kl *Kubelet) HandlePodCleanups() error { return err } + // Remove orphaned pod user namespace allocations (if any). + klog.V(3).InfoS("Clean up orphaned pod user namespace allocations") + if err = kl.usernsManager.CleanupOrphanedPodUsernsAllocations(allPods, runningRuntimePods); err != nil { + klog.ErrorS(err, "Failed cleaning up orphaned pod user namespaces allocations") + } + // Remove orphaned volumes from pods that are known not to have any // containers. Note that we pass all pods (including terminated pods) to // the function, so that we don't remove volumes associated with terminated diff --git a/pkg/kubelet/userns_manager.go b/pkg/kubelet/userns_manager.go new file mode 100644 index 000000000000..4ad96cba8f5b --- /dev/null +++ b/pkg/kubelet/userns_manager.go @@ -0,0 +1,530 @@ +/* +Copyright 2022 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package kubelet + +import ( + "encoding/json" + "fmt" + "math" + "os" + "path/filepath" + "sync" + + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/types" + "k8s.io/apimachinery/pkg/util/sets" + utilfeature "k8s.io/apiserver/pkg/util/feature" + runtimeapi "k8s.io/cri-api/pkg/apis/runtime/v1" + "k8s.io/klog/v2" + "k8s.io/kubernetes/pkg/features" + kubecontainer "k8s.io/kubernetes/pkg/kubelet/container" + utilstore "k8s.io/kubernetes/pkg/kubelet/util/store" + utilfs "k8s.io/kubernetes/pkg/util/filesystem" +) + +// bitsDataElement is the number of bits in a bitArray.data element. +const bitsDataElement = 32 + +type bitArray struct { + data []uint32 + firstIndex int +} + +func makeBitArray(size uint32) *bitArray { + m := bitArray{ + data: make([]uint32, (size+bitsDataElement-1)/bitsDataElement), + firstIndex: 0, + } + return &m +} + +func (b *bitArray) set(index uint32) { + b.data[index/bitsDataElement] |= (uint32(1) << (index % bitsDataElement)) +} + +func (b *bitArray) isSet(index uint32) bool { + return (b.data[index/bitsDataElement]>>(index%bitsDataElement))&0x1 == 1 +} + +func (b *bitArray) findAvailable() (uint32, bool) { + for i := b.firstIndex; i < len(b.data); i++ { + // Check if all bits are used (all 1s). + if b.data[i] == math.MaxUint32 { + continue + } + for j := uint32(0); j < bitsDataElement; j++ { + if (b.data[i]>>j)&0x1 == 0 { + v := uint32(i)*bitsDataElement + j + b.set(v) + // Update firstIndex to the current + // data element since there are no other + // unset bits before the current index. + b.firstIndex = int(i) + return v, true + } + } + } + return 0, false +} + +func (b *bitArray) clear(index uint32) { + i := index / bitsDataElement + // update firstIndex if the index found is less than + // the current one. + if i < uint32(b.firstIndex) { + b.firstIndex = int(i) + } + // clear the bit by ANDing the data element with the + // complement of the bitmask to be cleared. + b.data[i] &= ^(1 << (index % bitsDataElement)) +} + +// length for the user namespace to create (65536). +const userNsLength = (1 << 16) + +// Limit the total number of pods using userns in this node to this value. +// This is an alpha limitation that will probably be lifted later. +const maxPods = 1024 + +// Create a new map when we removed enough pods to avoid memory leaks +// since Go maps never free memory. +const mapReInitializeThreshold = 1000 + +type userNsPodsManager interface { + getPodDir(podUID types.UID) string + listPodsFromDisk() ([]types.UID, error) +} + +type usernsManager struct { + used *bitArray + usedBy map[types.UID]uint32 // Map pod.UID to range used + removed int + numAllocated int + kl userNsPodsManager + // This protects all members except for kl.anager + lock sync.Mutex +} + +// UserNamespace holds the configuration for the user namespace. +type userNamespace struct { + // UIDs mappings for the user namespace. + UIDMappings []idMapping `json:"uidMappings"` + // GIDs mappings for the user namespace. + GIDMappings []idMapping `json:"gidMappings"` +} + +// Pod user namespace mapping +type idMapping struct { + // Required. + HostId uint32 `json:"hostId"` + // Required. + ContainerId uint32 `json:"containerId"` + // Required. + Length uint32 `json:"length"` +} + +// mappingsFile is the file where the user namespace mappings are persisted. +const mappingsFile = "userns" + +// writeMappingsToFile writes the specified user namespace configuration to the pod +// directory. +func (m *usernsManager) writeMappingsToFile(pod types.UID, userNs userNamespace) error { + dir := m.kl.getPodDir(pod) + + data, err := json.Marshal(userNs) + if err != nil { + return err + } + + fstore, err := utilstore.NewFileStore(dir, &utilfs.DefaultFs{}) + if err != nil { + return err + } + if err := fstore.Write(mappingsFile, data); err != nil { + return err + } + + // We need to fsync the parent dir so the file is guaranteed to be there. + // fstore guarantees an atomic write, we need durability too. + parentDir, err := os.Open(dir) + if err != nil { + return err + } + + if err = parentDir.Sync(); err != nil { + // Ignore return here, there is already an error reported. + parentDir.Close() + return err + } + + return parentDir.Close() +} + +// readMappingsFromFile reads the user namespace configuration from the pod directory. +func (m *usernsManager) readMappingsFromFile(pod types.UID) ([]byte, error) { + dir := m.kl.getPodDir(pod) + fstore, err := utilstore.NewFileStore(dir, &utilfs.DefaultFs{}) + if err != nil { + return nil, err + } + return fstore.Read(mappingsFile) +} + +func MakeUserNsManager(kl userNsPodsManager) (*usernsManager, error) { + m := usernsManager{ + // Create a bitArray for all the UID space (2^32). + // As a by product of that, no index param to bitArray can be out of bounds (index is uint32). + used: makeBitArray((math.MaxUint32 + 1) / userNsLength), + usedBy: make(map[types.UID]uint32), + kl: kl, + } + // First block is reserved for the host. + m.used.set(0) + + // Second block will be used for phase II. Don't assign that range for now. + m.used.set(1) + + // do not bother reading the list of pods if user namespaces are not enabled. + if !utilfeature.DefaultFeatureGate.Enabled(features.UserNamespacesStatelessPodsSupport) { + return &m, nil + } + + found, err := kl.listPodsFromDisk() + if err != nil { + if os.IsNotExist(err) { + return &m, nil + } + return nil, fmt.Errorf("user namespace manager can't read pods from disk: %w", err) + + } + for _, podUID := range found { + klog.V(5).InfoS("reading pod from disk for user namespace", "podUID", podUID) + if err := m.recordPodMappings(podUID); err != nil { + return nil, err + } + } + + return &m, nil +} + +// recordPodMappings registers the range used for the user namespace if the +// usernsConfFile exists in the pod directory. +func (m *usernsManager) recordPodMappings(pod types.UID) error { + content, err := m.readMappingsFromFile(pod) + if err != nil && err != utilstore.ErrKeyNotFound { + return err + } + + // If no content, it means the pod doesn't have userns. Nothing else to do + if len(content) == 0 { + return nil + } + + _, err = m.parseUserNsFileAndRecord(pod, content) + return err +} + +// isSet checks if the specified index is already set. +func (m *usernsManager) isSet(v uint32) bool { + index := v / userNsLength + return m.used.isSet(index) +} + +// allocateOne finds a free user namespace and allocate it to the specified pod. +// The first return value is the first ID in the user namespace, the second returns +// the length for the user namespace range. +func (m *usernsManager) allocateOne(pod types.UID) (firstID uint32, length uint32, err error) { + if m.numAllocated >= maxPods { + return 0, 0, fmt.Errorf("limit on count of pods with user namespaces exceeded (limit is %v, current pods with userns: %v)", maxPods, m.numAllocated) + } + m.numAllocated++ + defer func() { + if err != nil { + m.numAllocated-- + } + }() + + firstZero, found := m.used.findAvailable() + if !found { + return 0, 0, fmt.Errorf("could not find an empty slot to allocate a user namespace") + } + + klog.V(5).InfoS("new pod user namespace allocation", "podUID", pod) + + firstID = firstZero * userNsLength + m.usedBy[pod] = firstID + return firstID, userNsLength, nil +} + +// record stores the user namespace [from; from+length] to the specified pod. +func (m *usernsManager) record(pod types.UID, from, length uint32) (err error) { + if length != userNsLength { + return fmt.Errorf("wrong user namespace length %v", length) + } + if from%userNsLength != 0 { + return fmt.Errorf("wrong user namespace offset specified %v", from) + } + prevFrom, found := m.usedBy[pod] + if found && prevFrom != from { + return fmt.Errorf("different user namespace range already used by pod %q", pod) + } + index := from / userNsLength + // if the pod wasn't found then verify the range is free. + if !found && m.used.isSet(index) { + return fmt.Errorf("range picked for pod %q already taken", pod) + } + // The pod is already registered, nothing to do. + if found && prevFrom == from { + return nil + } + if m.numAllocated >= maxPods { + return fmt.Errorf("limit on count of pods with user namespaces exceeded (limit is %v, current pods with userns: %v)", maxPods, m.numAllocated) + } + m.numAllocated++ + defer func() { + if err != nil { + m.numAllocated-- + } + }() + + klog.V(5).InfoS("new pod user namespace allocation", "podUID", pod) + + // "from" is a ID (UID/GID), set the corresponding userns of size + // userNsLength in the bit-array. + m.used.set(index) + m.usedBy[pod] = from + return nil +} + +// Release releases the user namespace allocated to the specified pod. +func (m *usernsManager) Release(podUID types.UID) { + if !utilfeature.DefaultFeatureGate.Enabled(features.UserNamespacesStatelessPodsSupport) { + return + } + + m.lock.Lock() + defer m.lock.Unlock() + + m.releaseWithLock(podUID) +} + +func (m *usernsManager) releaseWithLock(pod types.UID) { + v, ok := m.usedBy[pod] + if !ok { + klog.V(5).InfoS("pod user namespace allocation not present", "podUID", pod) + return + } + delete(m.usedBy, pod) + + klog.V(5).InfoS("releasing pod user namespace allocation", "podUID", pod) + m.numAllocated-- + m.removed++ + + _ = os.Remove(filepath.Join(m.kl.getPodDir(pod), mappingsFile)) + + if m.removed%mapReInitializeThreshold == 0 { + n := make(map[types.UID]uint32) + for k, v := range m.usedBy { + n[k] = v + } + m.usedBy = n + m.removed = 0 + } + m.used.clear(v / userNsLength) +} + +func (m *usernsManager) parseUserNsFileAndRecord(pod types.UID, content []byte) (userNs userNamespace, err error) { + if err = json.Unmarshal([]byte(content), &userNs); err != nil { + err = fmt.Errorf("can't parse file: %w", err) + return + } + + if len(userNs.UIDMappings) != 1 { + err = fmt.Errorf("invalid user namespace configuration: no more than one mapping allowed.") + return + } + + if len(userNs.UIDMappings) != len(userNs.GIDMappings) { + err = fmt.Errorf("invalid user namespace configuration: GID and UID mappings should be identical.") + return + } + + if userNs.UIDMappings[0] != userNs.GIDMappings[0] { + err = fmt.Errorf("invalid user namespace configuration: GID and UID mapping should be identical") + return + } + + // We don't produce configs without root mapped and some runtimes assume it is mapped. + // Validate the file has something we produced and can digest. + if userNs.UIDMappings[0].ContainerId != 0 { + err = fmt.Errorf("invalid user namespace configuration: UID 0 must be mapped") + return + } + + if userNs.GIDMappings[0].ContainerId != 0 { + err = fmt.Errorf("invalid user namespace configuration: GID 0 must be mapped") + return + } + + hostId := userNs.UIDMappings[0].HostId + length := userNs.UIDMappings[0].Length + + err = m.record(pod, hostId, length) + return +} + +func (m *usernsManager) createUserNs(pod *v1.Pod) (userNs userNamespace, err error) { + firstID, length, err := m.allocateOne(pod.UID) + if err != nil { + return + } + + defer func() { + if err != nil { + m.releaseWithLock(pod.UID) + } + }() + + userNs = userNamespace{ + UIDMappings: []idMapping{ + { + ContainerId: 0, + HostId: firstID, + Length: length, + }, + }, + GIDMappings: []idMapping{ + { + ContainerId: 0, + HostId: firstID, + Length: length, + }, + }, + } + + return userNs, m.writeMappingsToFile(pod.UID, userNs) +} + +// GetOrCreateUserNamespaceMappings returns the configuration for the sandbox user namespace +func (m *usernsManager) GetOrCreateUserNamespaceMappings(pod *v1.Pod) (*runtimeapi.UserNamespace, error) { + if !utilfeature.DefaultFeatureGate.Enabled(features.UserNamespacesStatelessPodsSupport) { + return nil, nil + } + + m.lock.Lock() + defer m.lock.Unlock() + + if pod.Spec.HostUsers == nil || *pod.Spec.HostUsers == true { + return &runtimeapi.UserNamespace{ + Mode: runtimeapi.NamespaceMode_NODE, + }, nil + } + + content, err := m.readMappingsFromFile(pod.UID) + if err != nil && err != utilstore.ErrKeyNotFound { + return nil, err + } + + var userNs userNamespace + if string(content) != "" { + userNs, err = m.parseUserNsFileAndRecord(pod.UID, content) + if err != nil { + return nil, err + } + } else { + userNs, err = m.createUserNs(pod) + if err != nil { + return nil, err + } + } + + var uids []*runtimeapi.IDMapping + var gids []*runtimeapi.IDMapping + + for _, u := range userNs.UIDMappings { + uids = append(uids, &runtimeapi.IDMapping{ + HostId: u.HostId, + ContainerId: u.ContainerId, + Length: u.Length, + }) + } + for _, g := range userNs.GIDMappings { + gids = append(gids, &runtimeapi.IDMapping{ + HostId: g.HostId, + ContainerId: g.ContainerId, + Length: g.Length, + }) + } + + return &runtimeapi.UserNamespace{ + Mode: runtimeapi.NamespaceMode_POD, + Uids: uids, + Gids: gids, + }, nil +} + +// CleanupOrphanedPodUsernsAllocations reconciliates the state of user namespace +// allocations with the pods actually running. It frees any user namespace +// allocation for orphaned pods. +func (m *usernsManager) CleanupOrphanedPodUsernsAllocations(pods []*v1.Pod, runningPods []*kubecontainer.Pod) error { + if !utilfeature.DefaultFeatureGate.Enabled(features.UserNamespacesStatelessPodsSupport) { + return nil + } + + m.lock.Lock() + defer m.lock.Unlock() + + allPods := sets.NewString() + for _, pod := range pods { + allPods.Insert(string(pod.UID)) + } + for _, pod := range runningPods { + allPods.Insert(string(pod.ID)) + } + + allFound := sets.NewString() + found, err := m.kl.listPodsFromDisk() + if err != nil { + return err + } + + for _, podUID := range found { + allFound.Insert(string(podUID)) + } + + // Lets remove all the pods "found" that are not known. + for _, podUID := range found { + if allPods.Has(string(podUID)) { + continue + } + + klog.V(5).InfoS("Clean up orphaned pod user namespace possible allocation", "podUID", podUID) + m.releaseWithLock(podUID) + } + + // Lets remove any existing allocation for a pod that is not "found". + for podUID := range m.usedBy { + if allFound.Has(string(podUID)) { + continue + } + + klog.V(5).InfoS("Clean up orphaned pod user namespace possible allocation", "podUID", podUID) + m.releaseWithLock(podUID) + } + + return nil +} diff --git a/pkg/kubelet/userns_manager_test.go b/pkg/kubelet/userns_manager_test.go new file mode 100644 index 000000000000..a445a40cde35 --- /dev/null +++ b/pkg/kubelet/userns_manager_test.go @@ -0,0 +1,215 @@ +/* +Copyright 2022 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package kubelet + +import ( + "fmt" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "k8s.io/apimachinery/pkg/types" + utilfeature "k8s.io/apiserver/pkg/util/feature" + featuregatetesting "k8s.io/component-base/featuregate/testing" + pkgfeatures "k8s.io/kubernetes/pkg/features" +) + +type testUserNsPodsManager struct { +} + +func (m *testUserNsPodsManager) getPodDir(podUID types.UID) string { + return "/tmp/non-existant-dir.This-is-not-used-in-tests" +} + +func (m *testUserNsPodsManager) listPodsFromDisk() ([]types.UID, error) { + return nil, nil +} + +func TestUserNsManagerAllocate(t *testing.T) { + defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, pkgfeatures.UserNamespacesStatelessPodsSupport, true)() + + testUserNsPodsManager := &testUserNsPodsManager{} + m, err := MakeUserNsManager(testUserNsPodsManager) + require.NoError(t, err) + + assert.Equal(t, true, m.isSet(0), "m.isSet(0) should be true") + assert.Equal(t, true, m.isSet(1), "m.isSet(1) should be true") + + allocated, length, err := m.allocateOne("one") + assert.NoError(t, err) + assert.Equal(t, userNsLength, int(length), "m.isSet(%d).length=%v", allocated, length) + assert.Equal(t, true, m.isSet(allocated), "m.isSet(%d)", allocated) + assert.Equal(t, userNsLength*2, int(allocated)) + + allocated2, length2, err := m.allocateOne("two") + assert.NoError(t, err) + assert.NotEqual(t, allocated, allocated2, "allocated != allocated2") + assert.Equal(t, length, length2, "length == length2") + assert.Equal(t, uint32(userNsLength*3), allocated2) + + // verify that re-adding the same pod with the same settings won't fail + err = m.record("two", allocated2, length2) + assert.NoError(t, err) + // but it fails if anyting is different + err = m.record("two", allocated2+1, length2) + assert.Error(t, err) + + m.Release("one") + m.Release("two") + assert.Equal(t, false, m.isSet(allocated), "m.isSet(%d)", allocated) + assert.Equal(t, false, m.isSet(allocated2), "m.nsSet(%d)", allocated2) + + var allocs []uint32 + for i := 0; i < 1000; i++ { + allocated, length, err = m.allocateOne(types.UID(fmt.Sprintf("%d", i))) + assert.Equal(t, userNsLength, int(length), "length is not the expected. iter: %v", i) + assert.Equal(t, userNsLength*(i+2), int(allocated), "firstID is not the expected. iter: %v", i) + assert.NoError(t, err) + allocs = append(allocs, allocated) + } + for i, v := range allocs { + assert.Equal(t, true, m.isSet(v), "m.isSet(%d) should be true", v) + m.Release(types.UID(fmt.Sprintf("%d", i))) + assert.Equal(t, false, m.isSet(v), "m.isSet(%d) should be false", v) + + err = m.record(types.UID(fmt.Sprintf("%d", i)), v, userNsLength) + assert.NoError(t, err) + m.Release(types.UID(fmt.Sprintf("%d", i))) + assert.Equal(t, false, m.isSet(v), "m.isSet(%d) should be false", v) + } +} + +func TestUserNsManagerParseUserNsFile(t *testing.T) { + defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, pkgfeatures.UserNamespacesStatelessPodsSupport, true)() + + cases := []struct { + name string + file string + success bool + }{ + { + name: "basic", + file: `{ + "uidMappings":[ { "hostId":131072, "containerId":0, "length":65536 } ], + "gidMappings":[ { "hostId":131072, "containerId":0, "length":65536 } ] + }`, + success: true, + }, + { + name: "invalid length", + file: `{ + "uidMappings":[ { "hostId":131072, "containerId":0, "length":0 } ], + "gidMappings":[ { "hostId":131072, "containerId":0, "length":0 } ] + }`, + success: false, + }, + { + name: "wrong offset", + file: `{ + "uidMappings":[ {"hostId":131072, "containerId":0, "length":65536 } ], + "gidMappings":[ {"hostId":1, "containerId":0, "length":65536 } ] + }`, + success: false, + }, + { + name: "two GID mappings", + file: `{ + "uidMappings":[ { "hostId":131072, "containerId":0, "length":userNsLength } ], + "gidMappings":[ { "hostId":131072, "containerId":0, "length":userNsLength }, { "hostId":196608, "containerId":0, "length":65536 } ] + }`, + success: false, + }, + { + name: "two UID mappings", + file: `{ + "uidMappings":[ { "hostId":131072, "containerId":0, "length":65536 }, { "hostId":196608, "containerId":0, "length":65536 } ], + "gidMappings":[ { "hostId":131072, "containerId":0, "length":65536 } ] + }`, + success: false, + }, + { + name: "no root UID", + file: `{ + "uidMappings":[ { "hostId":131072, "containerId":1, "length":65536 } ], + "gidMappings":[ { "hostId":131072, "containerId":0, "length":65536 } ] + }`, + success: false, + }, + { + name: "no root GID", + file: `{ + "uidMappings":[ { "hostId":131072, "containerId":0, "length":65536 } ], + "gidMappings":[ { "hostId":131072, "containerId":1, "length":65536 } ] + }`, + success: false, + }, + } + + testUserNsPodsManager := &testUserNsPodsManager{} + m, err := MakeUserNsManager(testUserNsPodsManager) + assert.NoError(t, err) + + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + // We don't validate the result. It was parsed with the json parser, we trust that. + _, err = m.parseUserNsFileAndRecord(types.UID(tc.name), []byte(tc.file)) + if (tc.success && err == nil) || (!tc.success && err != nil) { + return + } + + t.Errorf("expected success: %v but got error: %v", tc.success, err) + }) + } +} + +func BenchmarkBitmaskFindAndSetFirstZero(t *testing.B) { + b := makeBitArray(userNsLength) + for i := 0; i < userNsLength; i++ { + _, found := b.findAvailable() + assert.True(t, found) + } +} + +func BenchmarkBitmaskSetAndClear(t *testing.B) { + b := makeBitArray(userNsLength) + for i := uint32(0); i < userNsLength; i++ { + b.set(i) + b.clear(i) + } +} + +func BenchmarkBitmaskFindAndSetFirstZeroAndClear(t *testing.B) { + b := makeBitArray(userNsLength) + for i := 0; i < userNsLength; i++ { + ret, found := b.findAvailable() + assert.True(t, found) + b.clear(ret) + } +} + +func BenchmarkBitmaskFindAndSetFirstZeroAndClear0Every2(t *testing.B) { + // it is an interesting edge case as it forces a full scan + // on each second allocation. + b := makeBitArray(userNsLength) + for i := 0; i < userNsLength; i++ { + _, found := b.findAvailable() + assert.True(t, found) + if i%2 == 0 { + b.clear(0) + } + } +} From 9b2fc639a047e91e7e8a81ffb95965c5afcaf759 Mon Sep 17 00:00:00 2001 From: Giuseppe Scrivano Date: Thu, 7 Jul 2022 12:12:58 +0200 Subject: [PATCH 06/12] kubelet: add GetUserNamespaceMappings to RuntimeHelper Signed-off-by: Giuseppe Scrivano --- pkg/kubelet/container/helpers.go | 3 +++ pkg/kubelet/container/testing/fake_runtime_helper.go | 4 ++++ pkg/kubelet/kubelet_pods.go | 5 +++++ 3 files changed, 12 insertions(+) diff --git a/pkg/kubelet/container/helpers.go b/pkg/kubelet/container/helpers.go index a9be02a32d60..d11f2d678863 100644 --- a/pkg/kubelet/container/helpers.go +++ b/pkg/kubelet/container/helpers.go @@ -56,6 +56,9 @@ type RuntimeHelper interface { // supplemental groups for the Pod. These extra supplemental groups come // from annotations on persistent volumes that the pod depends on. GetExtraSupplementalGroupsForPod(pod *v1.Pod) []int64 + + // GetOrCreateUserNamespaceMappings returns the configuration for the sandbox user namespace + GetOrCreateUserNamespaceMappings(pod *v1.Pod) (*runtimeapi.UserNamespace, error) } // ShouldContainerBeRestarted checks whether a container needs to be restarted. diff --git a/pkg/kubelet/container/testing/fake_runtime_helper.go b/pkg/kubelet/container/testing/fake_runtime_helper.go index a7d13d606cea..eb4a51676bb1 100644 --- a/pkg/kubelet/container/testing/fake_runtime_helper.go +++ b/pkg/kubelet/container/testing/fake_runtime_helper.go @@ -65,3 +65,7 @@ func (f *FakeRuntimeHelper) GetPodDir(podUID kubetypes.UID) string { func (f *FakeRuntimeHelper) GetExtraSupplementalGroupsForPod(pod *v1.Pod) []int64 { return nil } + +func (f *FakeRuntimeHelper) GetOrCreateUserNamespaceMappings(pod *v1.Pod) (*runtimeapi.UserNamespace, error) { + return nil, nil +} diff --git a/pkg/kubelet/kubelet_pods.go b/pkg/kubelet/kubelet_pods.go index 456a2f76e996..93d1cd9a8b5e 100644 --- a/pkg/kubelet/kubelet_pods.go +++ b/pkg/kubelet/kubelet_pods.go @@ -420,6 +420,11 @@ func truncatePodHostnameIfNeeded(podName, hostname string) (string, error) { return truncated, nil } +// GetOrCreateUserNamespaceMappings returns the configuration for the sandbox user namespace +func (kl *Kubelet) GetOrCreateUserNamespaceMappings(pod *v1.Pod) (*runtimeapi.UserNamespace, error) { + return kl.usernsManager.GetOrCreateUserNamespaceMappings(pod) +} + // GeneratePodHostNameAndDomain creates a hostname and domain name for a pod, // given that pod's spec and annotations or returns an error. func (kl *Kubelet) GeneratePodHostNameAndDomain(pod *v1.Pod) (string, string, error) { From d07c2688fe07d7a65bca66d26853c637743544d4 Mon Sep 17 00:00:00 2001 From: Rodrigo Campos Date: Thu, 7 Jul 2022 16:51:55 +0200 Subject: [PATCH 07/12] kubelet: add GetHostIDsForPod() In future commits we will need this to set the user/group of supported volumes of KEP 127 - Phase 1. Signed-off-by: Rodrigo Campos --- .../attachdetach/attach_detach_controller.go | 4 + .../volume/expand/expand_controller.go | 4 + .../volume/persistentvolume/volume_host.go | 4 + pkg/kubelet/kubelet_pods.go | 4 + pkg/kubelet/userns_manager.go | 65 +++++++++ pkg/kubelet/userns_manager_test.go | 131 ++++++++++++++++++ pkg/kubelet/volume_host.go | 10 ++ pkg/volume/plugins.go | 7 + pkg/volume/testing/volume_host.go | 4 + 9 files changed, 233 insertions(+) diff --git a/pkg/controller/volume/attachdetach/attach_detach_controller.go b/pkg/controller/volume/attachdetach/attach_detach_controller.go index 31d898f1f2de..1d628afbfc53 100644 --- a/pkg/controller/volume/attachdetach/attach_detach_controller.go +++ b/pkg/controller/volume/attachdetach/attach_detach_controller.go @@ -819,6 +819,10 @@ func (adc *attachDetachController) GetPodVolumeDir(podUID types.UID, pluginName, return "" } +func (adc *attachDetachController) GetHostIDsForPod(pod *v1.Pod, containerUID, containerGID *int64) (hostUID, hostGID *int64, err error) { + return nil, nil, nil +} + func (adc *attachDetachController) GetPodPluginDir(podUID types.UID, pluginName string) string { return "" } diff --git a/pkg/controller/volume/expand/expand_controller.go b/pkg/controller/volume/expand/expand_controller.go index 9196d2856610..345d67e3ea05 100644 --- a/pkg/controller/volume/expand/expand_controller.go +++ b/pkg/controller/volume/expand/expand_controller.go @@ -394,6 +394,10 @@ func (expc *expandController) GetPodsDir() string { return "" } +func (expc *expandController) GetHostIDsForPod(pod *v1.Pod, containerUID, containerGID *int64) (hostUID, hostGID *int64, err error) { + return nil, nil, nil +} + func (expc *expandController) GetPodVolumeDir(podUID types.UID, pluginName string, volumeName string) string { return "" } diff --git a/pkg/controller/volume/persistentvolume/volume_host.go b/pkg/controller/volume/persistentvolume/volume_host.go index c064823c9c28..b47f183a61d3 100644 --- a/pkg/controller/volume/persistentvolume/volume_host.go +++ b/pkg/controller/volume/persistentvolume/volume_host.go @@ -55,6 +55,10 @@ func (ctrl *PersistentVolumeController) GetPodVolumeDir(podUID types.UID, plugin return "" } +func (ctrl *PersistentVolumeController) GetHostIDsForPod(pod *v1.Pod, containerUID, containerGID *int64) (hostUID, hostGID *int64, err error) { + return nil, nil, nil +} + func (ctrl *PersistentVolumeController) GetPodPluginDir(podUID types.UID, pluginName string) string { return "" } diff --git a/pkg/kubelet/kubelet_pods.go b/pkg/kubelet/kubelet_pods.go index 93d1cd9a8b5e..ecbf81099bdb 100644 --- a/pkg/kubelet/kubelet_pods.go +++ b/pkg/kubelet/kubelet_pods.go @@ -425,6 +425,10 @@ func (kl *Kubelet) GetOrCreateUserNamespaceMappings(pod *v1.Pod) (*runtimeapi.Us return kl.usernsManager.GetOrCreateUserNamespaceMappings(pod) } +func (kl *Kubelet) getHostIDsForPod(pod *v1.Pod, containerUID, containerGID *int64) (hostUID, hostGID *int64, err error) { + return kl.usernsManager.getHostIDsForPod(pod, containerUID, containerGID) +} + // GeneratePodHostNameAndDomain creates a hostname and domain name for a pod, // given that pod's spec and annotations or returns an error. func (kl *Kubelet) GeneratePodHostNameAndDomain(pod *v1.Pod) (string, string, error) { diff --git a/pkg/kubelet/userns_manager.go b/pkg/kubelet/userns_manager.go index 4ad96cba8f5b..07fb65512245 100644 --- a/pkg/kubelet/userns_manager.go +++ b/pkg/kubelet/userns_manager.go @@ -528,3 +528,68 @@ func (m *usernsManager) CleanupOrphanedPodUsernsAllocations(pods []*v1.Pod, runn return nil } + +// getHostIDsForPod if the pod uses user namespaces, takes the uid and gid +// inside the container and returns the host UID and GID those are mapped to on +// the host. If containerUID/containerGID is nil, then it returns the host +// UID/GID for ID 0 inside the container. +// If the pod is not using user namespaces, as there is no mapping needed, the +// same containerUID and containerGID params are returned. +func (m *usernsManager) getHostIDsForPod(pod *v1.Pod, containerUID, containerGID *int64) (hostUID, hostGID *int64, err error) { + if !utilfeature.DefaultFeatureGate.Enabled(features.UserNamespacesStatelessPodsSupport) { + return containerUID, containerGID, nil + } + + if pod == nil || pod.Spec.HostUsers == nil || *pod.Spec.HostUsers == true { + return containerUID, containerGID, nil + } + + mapping, err := m.GetOrCreateUserNamespaceMappings(pod) + if err != nil { + err = fmt.Errorf("Error getting pod user namespace mapping: %w", err) + return + } + + uid, err := hostIDFromMapping(mapping.Uids, containerUID) + if err != nil { + err = fmt.Errorf("Error getting host UID: %w", err) + return + } + + gid, err := hostIDFromMapping(mapping.Gids, containerGID) + if err != nil { + err = fmt.Errorf("Error getting host GID: %w", err) + return + } + + return &uid, &gid, nil +} + +func hostIDFromMapping(mapping []*runtimeapi.IDMapping, containerId *int64) (int64, error) { + if len(mapping) == 0 { + return 0, fmt.Errorf("can't use empty user namespace mapping") + } + + // If none is requested, root inside the container is used + id := int64(0) + if containerId != nil { + id = *containerId + } + + for _, m := range mapping { + if m == nil { + continue + } + + firstId := int64(m.ContainerId) + lastId := firstId + int64(m.Length) - 1 + + // The id we are looking for is in the range + if id >= firstId && id <= lastId { + // Return the host id for this container id + return int64(m.HostId) + id - firstId, nil + } + } + + return 0, fmt.Errorf("ID: %v not present in pod user namespace", id) +} diff --git a/pkg/kubelet/userns_manager_test.go b/pkg/kubelet/userns_manager_test.go index a445a40cde35..c3752426551f 100644 --- a/pkg/kubelet/userns_manager_test.go +++ b/pkg/kubelet/userns_manager_test.go @@ -25,6 +25,7 @@ import ( "k8s.io/apimachinery/pkg/types" utilfeature "k8s.io/apiserver/pkg/util/feature" featuregatetesting "k8s.io/component-base/featuregate/testing" + runtimeapi "k8s.io/cri-api/pkg/apis/runtime/v1" pkgfeatures "k8s.io/kubernetes/pkg/features" ) @@ -176,6 +177,136 @@ func TestUserNsManagerParseUserNsFile(t *testing.T) { } } +func TestUserNsManagerHostIDFromMapping(t *testing.T) { + // mapping []*runtimeapi.IDMapping, containerId *int64 + + cases := []struct { + name string + success bool + containerId int64 // -1 means a nil ptr will be used. + expHostId int64 + m []*runtimeapi.IDMapping + }{ + { + name: "one basic mapping", + success: true, + containerId: -1, + expHostId: 0, + m: []*runtimeapi.IDMapping{ + { + HostId: 0, + ContainerId: 0, + Length: userNsLength, + }, + }, + }, + { + name: "one unprivileged mapping", + success: true, + containerId: -1, + expHostId: userNsLength * 2, + m: []*runtimeapi.IDMapping{ + { + HostId: userNsLength * 2, + ContainerId: 0, + Length: userNsLength, + }, + }, + }, + { + name: "one unprivileged mapping random id", + success: true, + containerId: 3, + expHostId: userNsLength*2 + 3, + m: []*runtimeapi.IDMapping{ + { + HostId: userNsLength * 2, + ContainerId: 0, + Length: userNsLength, + }, + }, + }, + { + name: "two unprivileged mapping", + success: true, + containerId: 0, + expHostId: userNsLength*2 + 0, + m: []*runtimeapi.IDMapping{ + { + HostId: userNsLength * 2, + ContainerId: 0, + Length: 1, + }, + { + HostId: userNsLength*2 + 10, + ContainerId: 1, + Length: 1, + }, + }, + }, + { + name: "two unprivileged mapping - random id", + success: true, + containerId: 1, + expHostId: userNsLength*2 + 10, + m: []*runtimeapi.IDMapping{ + { + HostId: userNsLength * 2, + ContainerId: 0, + Length: 1, + }, + { + HostId: userNsLength*2 + 10, + ContainerId: 1, + Length: 1, + }, + }, + }, + { + name: "two unprivileged mapping - not mapped user", + success: false, + containerId: 3, + m: []*runtimeapi.IDMapping{ + { + HostId: userNsLength * 2, + ContainerId: 0, + Length: 1, + }, + { + HostId: userNsLength*2 + 1, + ContainerId: 1, + Length: 1, + }, + }, + }, + { + name: "no mappings", + success: false, + }, + } + + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + var containerId *int64 + if tc.containerId != -1 { + containerId = &tc.containerId + } + + id, err := hostIDFromMapping(tc.m, containerId) + if (tc.success && err != nil) || (!tc.success && err == nil) { + t.Fatalf("%v: expected success: %v - got error: %v", tc.name, tc.success, err) + } + if !tc.success && err != nil { + return + } + + if id != tc.expHostId { + t.Errorf("expected: %v - got: %v", tc.expHostId, id) + } + }) + } +} + func BenchmarkBitmaskFindAndSetFirstZero(t *testing.B) { b := makeBitArray(userNsLength) for i := 0; i < userNsLength; i++ { diff --git a/pkg/kubelet/volume_host.go b/pkg/kubelet/volume_host.go index fe880506b2b8..9c771c086350 100644 --- a/pkg/kubelet/volume_host.go +++ b/pkg/kubelet/volume_host.go @@ -128,6 +128,16 @@ func (kvh *kubeletVolumeHost) GetPodsDir() string { return kvh.kubelet.getPodsDir() } +// GetHostIDsForPod if the pod uses user namespaces, takes the uid and gid +// inside the container and returns the host UID and GID those are mapped to on +// the host. If containerUID/containerGID is nil, then it returns the host +// UID/GID for ID 0 inside the container. +// If the pod is not using user namespaces, as there is no mapping needed, the +// same containerUID and containerGID params are returned. +func (kvh *kubeletVolumeHost) GetHostIDsForPod(pod *v1.Pod, containerUID, containerGID *int64) (hostUID, hostGID *int64, err error) { + return kvh.kubelet.getHostIDsForPod(pod, containerUID, containerGID) +} + func (kvh *kubeletVolumeHost) GetPodVolumeDir(podUID types.UID, pluginName string, volumeName string) string { dir := kvh.kubelet.getPodVolumeDir(podUID, pluginName, volumeName) if runtime.GOOS == "windows" { diff --git a/pkg/volume/plugins.go b/pkg/volume/plugins.go index 6b40a59dd35d..5fd44568a01e 100644 --- a/pkg/volume/plugins.go +++ b/pkg/volume/plugins.go @@ -340,6 +340,13 @@ type KubeletVolumeHost interface { WaitForCacheSync() error // Returns hostutil.HostUtils GetHostUtil() hostutil.HostUtils + // GetHostIDsForPod if the pod uses user namespaces, takes the uid and + // gid inside the container and returns the host UID and GID those are + // mapped to on the host. If containerUID/containerGID is nil, then it + // returns the host UID/GID for ID 0 inside the container. + // If the pod is not using user namespaces, as there is no mapping needed, the + // same containerUID and containerGID params are returned. + GetHostIDsForPod(pod *v1.Pod, containerUID, containerGID *int64) (hostUID, hostGID *int64, err error) } // AttachDetachVolumeHost is a AttachDetach Controller specific interface that plugins can use diff --git a/pkg/volume/testing/volume_host.go b/pkg/volume/testing/volume_host.go index e422acfdcf98..dd0e6c227c95 100644 --- a/pkg/volume/testing/volume_host.go +++ b/pkg/volume/testing/volume_host.go @@ -118,6 +118,10 @@ func (f *fakeVolumeHost) GetPodsDir() string { return filepath.Join(f.rootDir, "pods") } +func (f *fakeVolumeHost) GetHostIDsForPod(pod *v1.Pod, containerUID, containerGID *int64) (hostUID, hostGID *int64, err error) { + return containerUID, containerGID, nil +} + func (f *fakeVolumeHost) GetPodVolumeDir(podUID types.UID, pluginName, volumeName string) string { return filepath.Join(f.rootDir, "pods", string(podUID), "volumes", pluginName, volumeName) } From 695b30e91c40e1932470f40ab71496089cfd777c Mon Sep 17 00:00:00 2001 From: Rodrigo Campos Date: Wed, 3 Aug 2022 17:18:56 +0200 Subject: [PATCH 08/12] volume: use GetHostIDsForPod() This commit only changes the UID/GID if user namespaces is enabled. When it is enabled, it changes it so the hostUID and hostGID that are mapped to the currently used UID/GID. This is needed so volumes are created with the hostUID/hostGID and the user inside the container can read them. If user namespaces are disabled for this pod, this is a no-op: there is no user namespace mapping, so the hostUID/hostGID are the same as inside the container. Signed-off-by: Rodrigo Campos --- .../operationexecutor/operation_generator.go | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/pkg/volume/util/operationexecutor/operation_generator.go b/pkg/volume/util/operationexecutor/operation_generator.go index fe04932c4dd0..6237755bbdbd 100644 --- a/pkg/volume/util/operationexecutor/operation_generator.go +++ b/pkg/volume/util/operationexecutor/operation_generator.go @@ -669,10 +669,23 @@ func (og *operationGenerator) GenerateMountVolumeFunc( resizeOptions.DeviceStagePath = deviceMountPath } + kvh, ok := og.GetVolumePluginMgr().Host.(volume.KubeletVolumeHost) + if !ok { + eventErr, detailedErr := volumeToMount.GenerateError("MountVolume type assertion error", fmt.Errorf("volume host does not implement KubeletVolumeHost interface")) + return volumetypes.NewOperationContext(eventErr, detailedErr, migrated) + } + uid := util.FsUserFrom(volumeToMount.Pod) + hostUID, hostGID, err := kvh.GetHostIDsForPod(volumeToMount.Pod, uid, fsGroup) + if err != nil { + msg := fmt.Sprintf("MountVolume.GetHostIDsForPod failed to find host ID in user namespace (UID: %v GID: %v)", uid, fsGroup) + eventErr, detailedErr := volumeToMount.GenerateError(msg, err) + return volumetypes.NewOperationContext(eventErr, detailedErr, migrated) + } + // Execute mount mountErr := volumeMounter.SetUp(volume.MounterArgs{ - FsUser: util.FsUserFrom(volumeToMount.Pod), - FsGroup: fsGroup, + FsUser: hostUID, + FsGroup: hostGID, DesiredSize: volumeToMount.DesiredSizeLimit, FSGroupChangePolicy: fsGroupChangePolicy, }) From 67b38ffe6ea3350f3cefd72caacd3f7ee9b1af42 Mon Sep 17 00:00:00 2001 From: Giuseppe Scrivano Date: Fri, 8 Jul 2022 11:43:05 +0200 Subject: [PATCH 09/12] kubelet: propagate errors from namespacesForPod it is a preparatory change for the next commit. Signed-off-by: Giuseppe Scrivano --- .../kuberuntime_container_linux.go | 16 ++++++++++---- .../kuberuntime_container_linux_test.go | 22 +++++++++++++------ .../kuberuntime/kuberuntime_sandbox.go | 6 ++++- pkg/kubelet/kuberuntime/security_context.go | 10 ++++++--- pkg/kubelet/kuberuntime/util/util.go | 6 ++--- pkg/kubelet/kuberuntime/util/util_test.go | 4 +++- 6 files changed, 45 insertions(+), 19 deletions(-) diff --git a/pkg/kubelet/kuberuntime/kuberuntime_container_linux.go b/pkg/kubelet/kuberuntime/kuberuntime_container_linux.go index 25917803b1ce..1e9a2377b510 100644 --- a/pkg/kubelet/kuberuntime/kuberuntime_container_linux.go +++ b/pkg/kubelet/kuberuntime/kuberuntime_container_linux.go @@ -45,15 +45,23 @@ func (m *kubeGenericRuntimeManager) applyPlatformSpecificContainerConfig(config libcontainercgroups.IsCgroup2UnifiedMode() { enforceMemoryQoS = true } - config.Linux = m.generateLinuxContainerConfig(container, pod, uid, username, nsTarget, enforceMemoryQoS) + cl, err := m.generateLinuxContainerConfig(container, pod, uid, username, nsTarget, enforceMemoryQoS) + if err != nil { + return err + } + config.Linux = cl return nil } // generateLinuxContainerConfig generates linux container config for kubelet runtime v1. -func (m *kubeGenericRuntimeManager) generateLinuxContainerConfig(container *v1.Container, pod *v1.Pod, uid *int64, username string, nsTarget *kubecontainer.ContainerID, enforceMemoryQoS bool) *runtimeapi.LinuxContainerConfig { +func (m *kubeGenericRuntimeManager) generateLinuxContainerConfig(container *v1.Container, pod *v1.Pod, uid *int64, username string, nsTarget *kubecontainer.ContainerID, enforceMemoryQoS bool) (*runtimeapi.LinuxContainerConfig, error) { + sc, err := m.determineEffectiveSecurityContext(pod, container, uid, username) + if err != nil { + return nil, err + } lc := &runtimeapi.LinuxContainerConfig{ Resources: &runtimeapi.LinuxContainerResources{}, - SecurityContext: m.determineEffectiveSecurityContext(pod, container, uid, username), + SecurityContext: sc, } if nsTarget != nil && lc.SecurityContext.NamespaceOptions.Pid == runtimeapi.NamespaceMode_CONTAINER { @@ -124,7 +132,7 @@ func (m *kubeGenericRuntimeManager) generateLinuxContainerConfig(container *v1.C } } - return lc + return lc, nil } // calculateLinuxResources will create the linuxContainerResources type based on the provided CPU and memory resource requests, limits diff --git a/pkg/kubelet/kuberuntime/kuberuntime_container_linux_test.go b/pkg/kubelet/kuberuntime/kuberuntime_container_linux_test.go index 307a40d01887..1a50d96143fd 100644 --- a/pkg/kubelet/kuberuntime/kuberuntime_container_linux_test.go +++ b/pkg/kubelet/kuberuntime/kuberuntime_container_linux_test.go @@ -47,6 +47,8 @@ func makeExpectedConfig(m *kubeGenericRuntimeManager, pod *v1.Pod, containerInde restartCountUint32 := uint32(restartCount) envs := make([]*runtimeapi.KeyValue, len(opts.Envs)) + l, _ := m.generateLinuxContainerConfig(container, pod, new(int64), "", nil, enforceMemoryQoS) + expectedConfig := &runtimeapi.ContainerConfig{ Metadata: &runtimeapi.ContainerMetadata{ Name: container.Name, @@ -64,7 +66,7 @@ func makeExpectedConfig(m *kubeGenericRuntimeManager, pod *v1.Pod, containerInde Stdin: container.Stdin, StdinOnce: container.StdinOnce, Tty: container.TTY, - Linux: m.generateLinuxContainerConfig(container, pod, new(int64), "", nil, enforceMemoryQoS), + Linux: l, Envs: envs, } return expectedConfig @@ -215,7 +217,8 @@ func TestGenerateLinuxContainerConfigResources(t *testing.T) { }, } - linuxConfig := m.generateLinuxContainerConfig(&pod.Spec.Containers[0], pod, new(int64), "", nil, false) + linuxConfig, err := m.generateLinuxContainerConfig(&pod.Spec.Containers[0], pod, new(int64), "", nil, false) + assert.NoError(t, err) assert.Equal(t, test.expected.CpuPeriod, linuxConfig.GetResources().CpuPeriod, test.name) assert.Equal(t, test.expected.CpuQuota, linuxConfig.GetResources().CpuQuota, test.name) assert.Equal(t, test.expected.CpuShares, linuxConfig.GetResources().CpuShares, test.name) @@ -329,6 +332,8 @@ func TestGenerateContainerConfigWithMemoryQoSEnforced(t *testing.T) { memoryLow int64 memoryHigh int64 } + l1, _ := m.generateLinuxContainerConfig(&pod1.Spec.Containers[0], pod1, new(int64), "", nil, true) + l2, _ := m.generateLinuxContainerConfig(&pod2.Spec.Containers[0], pod2, new(int64), "", nil, true) tests := []struct { name string pod *v1.Pod @@ -338,7 +343,7 @@ func TestGenerateContainerConfigWithMemoryQoSEnforced(t *testing.T) { name: "Request128MBLimit256MB", pod: pod1, expected: &expectedResult{ - m.generateLinuxContainerConfig(&pod1.Spec.Containers[0], pod1, new(int64), "", nil, true), + l1, 128 * 1024 * 1024, int64(float64(256*1024*1024) * m.memoryThrottlingFactor), }, @@ -347,7 +352,7 @@ func TestGenerateContainerConfigWithMemoryQoSEnforced(t *testing.T) { name: "Request128MBWithoutLimit", pod: pod2, expected: &expectedResult{ - m.generateLinuxContainerConfig(&pod2.Spec.Containers[0], pod2, new(int64), "", nil, true), + l2, 128 * 1024 * 1024, int64(pod2MemoryHigh), }, @@ -355,7 +360,8 @@ func TestGenerateContainerConfigWithMemoryQoSEnforced(t *testing.T) { } for _, test := range tests { - linuxConfig := m.generateLinuxContainerConfig(&test.pod.Spec.Containers[0], test.pod, new(int64), "", nil, true) + linuxConfig, err := m.generateLinuxContainerConfig(&test.pod.Spec.Containers[0], test.pod, new(int64), "", nil, true) + assert.NoError(t, err) assert.Equal(t, test.expected.containerConfig, linuxConfig, test.name) assert.Equal(t, linuxConfig.GetResources().GetUnified()["memory.min"], strconv.FormatInt(test.expected.memoryLow, 10), test.name) assert.Equal(t, linuxConfig.GetResources().GetUnified()["memory.high"], strconv.FormatInt(test.expected.memoryHigh, 10), test.name) @@ -577,7 +583,8 @@ func TestGenerateLinuxContainerConfigNamespaces(t *testing.T) { }, } { t.Run(tc.name, func(t *testing.T) { - got := m.generateLinuxContainerConfig(&tc.pod.Spec.Containers[0], tc.pod, nil, "", tc.target, false) + got, err := m.generateLinuxContainerConfig(&tc.pod.Spec.Containers[0], tc.pod, nil, "", tc.target, false) + assert.NoError(t, err) if diff := cmp.Diff(tc.want, got.SecurityContext.NamespaceOptions); diff != "" { t.Errorf("%v: diff (-want +got):\n%v", t.Name(), diff) } @@ -668,7 +675,8 @@ func TestGenerateLinuxContainerConfigSwap(t *testing.T) { } { t.Run(tc.name, func(t *testing.T) { m.memorySwapBehavior = tc.swapSetting - actual := m.generateLinuxContainerConfig(&tc.pod.Spec.Containers[0], tc.pod, nil, "", nil, false) + actual, err := m.generateLinuxContainerConfig(&tc.pod.Spec.Containers[0], tc.pod, nil, "", nil, false) + assert.NoError(t, err) assert.Equal(t, tc.expected, actual.Resources.MemorySwapLimitInBytes, "memory swap config for %s", tc.name) }) } diff --git a/pkg/kubelet/kuberuntime/kuberuntime_sandbox.go b/pkg/kubelet/kuberuntime/kuberuntime_sandbox.go index 835dbbcd6fda..c37270d26d99 100644 --- a/pkg/kubelet/kuberuntime/kuberuntime_sandbox.go +++ b/pkg/kubelet/kuberuntime/kuberuntime_sandbox.go @@ -195,7 +195,11 @@ func (m *kubeGenericRuntimeManager) generatePodSandboxLinuxConfig(pod *v1.Pod) ( if sc.RunAsGroup != nil && runtime.GOOS != "windows" { lc.SecurityContext.RunAsGroup = &runtimeapi.Int64Value{Value: int64(*sc.RunAsGroup)} } - lc.SecurityContext.NamespaceOptions = runtimeutil.NamespacesForPod(pod) + namespaceOptions, err := runtimeutil.NamespacesForPod(pod, m.runtimeHelper) + if err != nil { + return nil, err + } + lc.SecurityContext.NamespaceOptions = namespaceOptions if sc.FSGroup != nil && runtime.GOOS != "windows" { lc.SecurityContext.SupplementalGroups = append(lc.SecurityContext.SupplementalGroups, int64(*sc.FSGroup)) diff --git a/pkg/kubelet/kuberuntime/security_context.go b/pkg/kubelet/kuberuntime/security_context.go index e315d66e73c6..5e6f05b4e187 100644 --- a/pkg/kubelet/kuberuntime/security_context.go +++ b/pkg/kubelet/kuberuntime/security_context.go @@ -25,7 +25,7 @@ import ( ) // determineEffectiveSecurityContext gets container's security context from v1.Pod and v1.Container. -func (m *kubeGenericRuntimeManager) determineEffectiveSecurityContext(pod *v1.Pod, container *v1.Container, uid *int64, username string) *runtimeapi.LinuxContainerSecurityContext { +func (m *kubeGenericRuntimeManager) determineEffectiveSecurityContext(pod *v1.Pod, container *v1.Container, uid *int64, username string) (*runtimeapi.LinuxContainerSecurityContext, error) { effectiveSc := securitycontext.DetermineEffectiveSecurityContext(pod, container) synthesized := convertToRuntimeSecurityContext(effectiveSc) if synthesized == nil { @@ -53,7 +53,11 @@ func (m *kubeGenericRuntimeManager) determineEffectiveSecurityContext(pod *v1.Po } // set namespace options and supplemental groups. - synthesized.NamespaceOptions = runtimeutil.NamespacesForPod(pod) + namespaceOptions, err := runtimeutil.NamespacesForPod(pod, m.runtimeHelper) + if err != nil { + return nil, err + } + synthesized.NamespaceOptions = namespaceOptions podSc := pod.Spec.SecurityContext if podSc != nil { if podSc.FSGroup != nil { @@ -75,7 +79,7 @@ func (m *kubeGenericRuntimeManager) determineEffectiveSecurityContext(pod *v1.Po synthesized.MaskedPaths = securitycontext.ConvertToRuntimeMaskedPaths(effectiveSc.ProcMount) synthesized.ReadonlyPaths = securitycontext.ConvertToRuntimeReadonlyPaths(effectiveSc.ProcMount) - return synthesized + return synthesized, nil } // convertToRuntimeSecurityContext converts v1.SecurityContext to runtimeapi.SecurityContext. diff --git a/pkg/kubelet/kuberuntime/util/util.go b/pkg/kubelet/kuberuntime/util/util.go index 6ad66256a9ac..5c84e7d82ced 100644 --- a/pkg/kubelet/kuberuntime/util/util.go +++ b/pkg/kubelet/kuberuntime/util/util.go @@ -97,12 +97,12 @@ func PidNamespaceForPod(pod *v1.Pod) runtimeapi.NamespaceMode { return runtimeapi.NamespaceMode_CONTAINER } -// NamespacesForPod returns the runtimeapi.NamespaceOption for a given pod. +// namespacesForPod returns the runtimeapi.NamespaceOption for a given pod. // An empty or nil pod can be used to get the namespace defaults for v1.Pod. -func NamespacesForPod(pod *v1.Pod) *runtimeapi.NamespaceOption { +func NamespacesForPod(pod *v1.Pod, runtimeHelper kubecontainer.RuntimeHelper) (*runtimeapi.NamespaceOption, error) { return &runtimeapi.NamespaceOption{ Ipc: IpcNamespaceForPod(pod), Network: NetworkNamespaceForPod(pod), Pid: PidNamespaceForPod(pod), - } + }, nil } diff --git a/pkg/kubelet/kuberuntime/util/util_test.go b/pkg/kubelet/kuberuntime/util/util_test.go index 7189742358f8..7a96e23fa2e3 100644 --- a/pkg/kubelet/kuberuntime/util/util_test.go +++ b/pkg/kubelet/kuberuntime/util/util_test.go @@ -24,6 +24,7 @@ import ( v1 "k8s.io/api/core/v1" runtimeapi "k8s.io/cri-api/pkg/apis/runtime/v1" kubecontainer "k8s.io/kubernetes/pkg/kubelet/container" + kubecontainertest "k8s.io/kubernetes/pkg/kubelet/container/testing" ) func TestPodSandboxChanged(t *testing.T) { @@ -222,7 +223,8 @@ func TestNamespacesForPod(t *testing.T) { }, } { t.Run(desc, func(t *testing.T) { - actual := NamespacesForPod(test.input) + actual, err := NamespacesForPod(test.input, &kubecontainertest.FakeRuntimeHelper{}) + require.NoError(t, err) require.Equal(t, test.expected, actual) }) } From 138e80819e12d67efa106a02b92c5f74ead95caa Mon Sep 17 00:00:00 2001 From: Rodrigo Campos Date: Tue, 2 Aug 2022 12:16:01 +0200 Subject: [PATCH 10/12] kubelet: set user namespace options Set the user namespace options to use for the pod. Signed-off-by: Rodrigo Campos --- pkg/kubelet/kuberuntime/util/util.go | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/pkg/kubelet/kuberuntime/util/util.go b/pkg/kubelet/kuberuntime/util/util.go index 5c84e7d82ced..af61e17567eb 100644 --- a/pkg/kubelet/kuberuntime/util/util.go +++ b/pkg/kubelet/kuberuntime/util/util.go @@ -100,9 +100,15 @@ func PidNamespaceForPod(pod *v1.Pod) runtimeapi.NamespaceMode { // namespacesForPod returns the runtimeapi.NamespaceOption for a given pod. // An empty or nil pod can be used to get the namespace defaults for v1.Pod. func NamespacesForPod(pod *v1.Pod, runtimeHelper kubecontainer.RuntimeHelper) (*runtimeapi.NamespaceOption, error) { + userNs, err := runtimeHelper.GetOrCreateUserNamespaceMappings(pod) + if err != nil { + return nil, err + } + return &runtimeapi.NamespaceOption{ - Ipc: IpcNamespaceForPod(pod), - Network: NetworkNamespaceForPod(pod), - Pid: PidNamespaceForPod(pod), + Ipc: IpcNamespaceForPod(pod), + Network: NetworkNamespaceForPod(pod), + Pid: PidNamespaceForPod(pod), + UsernsOptions: userNs, }, nil } From b1eaf6a2d978d460d5d8f274102851925afff53c Mon Sep 17 00:00:00 2001 From: Giuseppe Scrivano Date: Mon, 20 Jun 2022 18:16:41 +0200 Subject: [PATCH 11/12] tests: add e2e tests for userns Co-authored-by: Rodrigo Campos Signed-off-by: Giuseppe Scrivano Signed-off-by: Rodrigo Campos --- test/e2e/common/node/security_context.go | 256 +++++++++++++++++++++++ 1 file changed, 256 insertions(+) diff --git a/test/e2e/common/node/security_context.go b/test/e2e/common/node/security_context.go index 6cd11d30fa7e..acfe36fc287c 100644 --- a/test/e2e/common/node/security_context.go +++ b/test/e2e/common/node/security_context.go @@ -17,6 +17,7 @@ limitations under the License. package node import ( + "context" "fmt" "strings" "time" @@ -49,6 +50,261 @@ var _ = SIGDescribe("Security Context", func() { podClient = f.PodClient() }) + ginkgo.Context("When creating a pod with HostUsers", func() { + containerName := "userns-test" + makePod := func(hostUsers bool) *v1.Pod { + return &v1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: "userns-" + string(uuid.NewUUID()), + }, + Spec: v1.PodSpec{ + Containers: []v1.Container{ + { + Name: containerName, + Image: imageutils.GetE2EImage(imageutils.BusyBox), + Command: []string{"cat", "/proc/self/uid_map"}, + }, + }, + RestartPolicy: v1.RestartPolicyNever, + HostUsers: &hostUsers, + }, + } + } + + ginkgo.It("must create the user namespace if set to false [LinuxOnly] [Feature:UserNamespacesStatelessPodsSupport]", func() { + // with hostUsers=false the pod must use a new user namespace + podClient := f.PodClientNS(f.Namespace.Name) + + createdPod1 := podClient.Create(makePod(false)) + createdPod2 := podClient.Create(makePod(false)) + defer func() { + ginkgo.By("delete the pods") + podClient.DeleteSync(createdPod1.Name, metav1.DeleteOptions{}, framework.DefaultPodDeletionTimeout) + podClient.DeleteSync(createdPod2.Name, metav1.DeleteOptions{}, framework.DefaultPodDeletionTimeout) + }() + getLogs := func(pod *v1.Pod) (string, error) { + err := e2epod.WaitForPodSuccessInNamespaceTimeout(f.ClientSet, createdPod1.Name, f.Namespace.Name, f.Timeouts.PodStart) + if err != nil { + return "", err + } + podStatus, err := podClient.Get(context.TODO(), pod.Name, metav1.GetOptions{}) + if err != nil { + return "", err + } + return e2epod.GetPodLogs(f.ClientSet, f.Namespace.Name, podStatus.Name, containerName) + } + + logs1, err := getLogs(createdPod1) + framework.ExpectNoError(err) + logs2, err := getLogs(createdPod2) + framework.ExpectNoError(err) + + // 65536 is the size used for a user namespace. Verify that the value is present + // in the /proc/self/uid_map file. + if !strings.Contains(logs1, "65536") || !strings.Contains(logs2, "65536") { + framework.Failf("user namespace not created") + } + if logs1 == logs2 { + framework.Failf("two different pods are running with the same user namespace configuration") + } + }) + + ginkgo.It("must not create the user namespace if set to true [LinuxOnly] [Feature:UserNamespacesStatelessPodsSupport]", func() { + // with hostUsers=true the pod must use the host user namespace + pod := makePod(true) + // When running in the host's user namespace, the /proc/self/uid_map file content looks like: + // 0 0 4294967295 + // Verify the value 4294967295 is present in the output. + f.TestContainerOutput("read namespace", pod, 0, []string{ + "4294967295", + }) + }) + + ginkgo.It("should mount all volumes with proper permissions with hostUsers=false [LinuxOnly] [Feature:UserNamespacesStatelessPodsSupport]", func() { + // Create all volume types supported: configmap, secret, downwardAPI, projected. + + // Create configmap. + name := "userns-volumes-test-" + string(uuid.NewUUID()) + configMap := newConfigMap(f, name) + ginkgo.By(fmt.Sprintf("Creating configMap %v/%v", f.Namespace.Name, configMap.Name)) + var err error + if configMap, err = f.ClientSet.CoreV1().ConfigMaps(f.Namespace.Name).Create(context.TODO(), configMap, metav1.CreateOptions{}); err != nil { + framework.Failf("unable to create test configMap %s: %v", configMap.Name, err) + } + + // Create secret. + secret := secretForTest(f.Namespace.Name, name) + ginkgo.By(fmt.Sprintf("Creating secret with name %s", secret.Name)) + if secret, err = f.ClientSet.CoreV1().Secrets(f.Namespace.Name).Create(context.TODO(), secret, metav1.CreateOptions{}); err != nil { + framework.Failf("unable to create test secret %s: %v", secret.Name, err) + } + + // downwardAPI definition. + downwardVolSource := &v1.DownwardAPIVolumeSource{ + Items: []v1.DownwardAPIVolumeFile{ + { + Path: "name", + FieldRef: &v1.ObjectFieldSelector{ + APIVersion: "v1", + FieldPath: "metadata.name", + }, + }, + }, + } + + // Create a pod with all the volumes + falseVar := false + pod := &v1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: "pod-userns-volumes-" + string(uuid.NewUUID()), + }, + Spec: v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "userns-file-permissions", + Image: imageutils.GetE2EImage(imageutils.BusyBox), + // Print (numeric) GID of the files in /vol/. + // We limit to "type f" as kubelet uses symlinks to those files, but we + // don't care about the owner of the symlink itself, just the files. + Command: []string{"sh", "-c", "stat -c='%g' $(find /vol/ -type f)"}, + VolumeMounts: []v1.VolumeMount{ + { + Name: "cfg", + MountPath: "/vol/cfg/", + }, + { + Name: "secret", + MountPath: "/vol/secret/", + }, + { + Name: "downward", + MountPath: "/vol/downward/", + }, + { + Name: "projected", + MountPath: "/vol/projected/", + }, + }, + }, + }, + Volumes: []v1.Volume{ + { + Name: "cfg", + VolumeSource: v1.VolumeSource{ + ConfigMap: &v1.ConfigMapVolumeSource{ + LocalObjectReference: v1.LocalObjectReference{Name: configMap.Name}, + }, + }, + }, + { + Name: "secret", + VolumeSource: v1.VolumeSource{ + Secret: &v1.SecretVolumeSource{ + SecretName: secret.Name, + }, + }, + }, + { + Name: "downward", + VolumeSource: v1.VolumeSource{ + DownwardAPI: downwardVolSource, + }, + }, + { + Name: "projected", + VolumeSource: v1.VolumeSource{ + Projected: &v1.ProjectedVolumeSource{ + Sources: []v1.VolumeProjection{ + { + DownwardAPI: &v1.DownwardAPIProjection{ + Items: downwardVolSource.Items, + }, + }, + { + Secret: &v1.SecretProjection{ + LocalObjectReference: v1.LocalObjectReference{Name: secret.Name}, + }, + }, + }, + }, + }, + }, + }, + HostUsers: &falseVar, + RestartPolicy: v1.RestartPolicyNever, + }, + } + + // Expect one line for each file on all the volumes. + // Each line should be "=0" that means root inside the container is the owner of the file. + downwardAPIVolFiles := 1 + projectedFiles := len(secret.Data) + downwardAPIVolFiles + f.TestContainerOutput("check file permissions", pod, 0, []string{ + strings.Repeat("=0\n", len(secret.Data)+len(configMap.Data)+downwardAPIVolFiles+projectedFiles), + }) + }) + + ginkgo.It("should set FSGroup to user inside the container with hostUsers=false [LinuxOnly] [Feature:UserNamespacesStatelessPodsSupport]", func() { + // Create configmap. + name := "userns-volumes-test-" + string(uuid.NewUUID()) + configMap := newConfigMap(f, name) + ginkgo.By(fmt.Sprintf("Creating configMap %v/%v", f.Namespace.Name, configMap.Name)) + var err error + if configMap, err = f.ClientSet.CoreV1().ConfigMaps(f.Namespace.Name).Create(context.TODO(), configMap, metav1.CreateOptions{}); err != nil { + framework.Failf("unable to create test configMap %s: %v", configMap.Name, err) + } + + // Create a pod with hostUsers=false + falseVar := false + fsGroup := int64(200) + pod := &v1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: "pod-userns-fsgroup-" + string(uuid.NewUUID()), + }, + Spec: v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "userns-fsgroup", + Image: imageutils.GetE2EImage(imageutils.BusyBox), + // Print (numeric) GID of the files in /vol/. + // We limit to "type f" as kubelet uses symlinks to those files, but we + // don't care about the owner of the symlink itself, just the files. + Command: []string{"sh", "-c", "stat -c='%g' $(find /vol/ -type f)"}, + VolumeMounts: []v1.VolumeMount{ + { + Name: "cfg", + MountPath: "/vol/cfg/", + }, + }, + }, + }, + Volumes: []v1.Volume{ + { + Name: "cfg", + VolumeSource: v1.VolumeSource{ + ConfigMap: &v1.ConfigMapVolumeSource{ + LocalObjectReference: v1.LocalObjectReference{Name: configMap.Name}, + }, + }, + }, + }, + HostUsers: &falseVar, + RestartPolicy: v1.RestartPolicyNever, + SecurityContext: &v1.PodSecurityContext{ + FSGroup: &fsGroup, + }, + }, + } + + // Expect one line for each file on all the volumes. + // Each line should be "=200" (fsGroup) that means it was mapped to the + // right user inside the container. + f.TestContainerOutput("check FSGroup is mapped correctly", pod, 0, []string{ + strings.Repeat(fmt.Sprintf("=%v\n", fsGroup), len(configMap.Data)), + }) + }) + }) + ginkgo.Context("When creating a container with runAsUser", func() { makeUserPod := func(podName, image string, command []string, userid int64) *v1.Pod { return &v1.Pod{ From 8dc98c9b8ecded941b2664f64d24b3ee98c0f500 Mon Sep 17 00:00:00 2001 From: Rodrigo Campos Date: Wed, 27 Jul 2022 12:54:15 +0200 Subject: [PATCH 12/12] Update autogenerated files Signed-off-by: Rodrigo Campos --- api/openapi-spec/swagger.json | 6 +- api/openapi-spec/v3/api__v1_openapi.json | 6 +- .../v3/apis__apps__v1_openapi.json | 6 +- .../v3/apis__batch__v1_openapi.json | 6 +- pkg/apis/core/v1/zz_generated.conversion.go | 2 + pkg/apis/core/zz_generated.deepcopy.go | 5 + pkg/generated/openapi/zz_generated.openapi.go | 9 +- .../src/k8s.io/api/core/v1/generated.pb.go | 1828 +++++++++-------- .../src/k8s.io/api/core/v1/generated.proto | 14 + .../core/v1/types_swagger_doc_generated.go | 3 +- .../api/core/v1/zz_generated.deepcopy.go | 5 + .../api/testdata/HEAD/apps.v1.DaemonSet.json | 3 +- .../api/testdata/HEAD/apps.v1.DaemonSet.pb | Bin 9893 -> 9896 bytes .../api/testdata/HEAD/apps.v1.DaemonSet.yaml | 1 + .../api/testdata/HEAD/apps.v1.Deployment.json | 3 +- .../api/testdata/HEAD/apps.v1.Deployment.pb | Bin 9906 -> 9909 bytes .../api/testdata/HEAD/apps.v1.Deployment.yaml | 1 + .../api/testdata/HEAD/apps.v1.ReplicaSet.json | 3 +- .../api/testdata/HEAD/apps.v1.ReplicaSet.pb | Bin 9823 -> 9826 bytes .../api/testdata/HEAD/apps.v1.ReplicaSet.yaml | 1 + .../testdata/HEAD/apps.v1.StatefulSet.json | 3 +- .../api/testdata/HEAD/apps.v1.StatefulSet.pb | Bin 10805 -> 10808 bytes .../testdata/HEAD/apps.v1.StatefulSet.yaml | 1 + .../HEAD/apps.v1beta1.Deployment.json | 3 +- .../testdata/HEAD/apps.v1beta1.Deployment.pb | Bin 9915 -> 9918 bytes .../HEAD/apps.v1beta1.Deployment.yaml | 1 + .../HEAD/apps.v1beta1.StatefulSet.json | 3 +- .../testdata/HEAD/apps.v1beta1.StatefulSet.pb | Bin 10810 -> 10813 bytes .../HEAD/apps.v1beta1.StatefulSet.yaml | 1 + .../testdata/HEAD/apps.v1beta2.DaemonSet.json | 3 +- .../testdata/HEAD/apps.v1beta2.DaemonSet.pb | Bin 9898 -> 9901 bytes .../testdata/HEAD/apps.v1beta2.DaemonSet.yaml | 1 + .../HEAD/apps.v1beta2.Deployment.json | 3 +- .../testdata/HEAD/apps.v1beta2.Deployment.pb | Bin 9911 -> 9914 bytes .../HEAD/apps.v1beta2.Deployment.yaml | 1 + .../HEAD/apps.v1beta2.ReplicaSet.json | 3 +- .../testdata/HEAD/apps.v1beta2.ReplicaSet.pb | Bin 9828 -> 9831 bytes .../HEAD/apps.v1beta2.ReplicaSet.yaml | 1 + .../HEAD/apps.v1beta2.StatefulSet.json | 3 +- .../testdata/HEAD/apps.v1beta2.StatefulSet.pb | Bin 10810 -> 10813 bytes .../HEAD/apps.v1beta2.StatefulSet.yaml | 1 + .../api/testdata/HEAD/batch.v1.CronJob.json | 3 +- .../api/testdata/HEAD/batch.v1.CronJob.pb | Bin 10327 -> 10330 bytes .../api/testdata/HEAD/batch.v1.CronJob.yaml | 1 + .../api/testdata/HEAD/batch.v1.Job.json | 3 +- .../k8s.io/api/testdata/HEAD/batch.v1.Job.pb | Bin 9931 -> 9934 bytes .../api/testdata/HEAD/batch.v1.Job.yaml | 1 + .../testdata/HEAD/batch.v1beta1.CronJob.json | 3 +- .../testdata/HEAD/batch.v1beta1.CronJob.pb | Bin 10332 -> 10335 bytes .../testdata/HEAD/batch.v1beta1.CronJob.yaml | 1 + .../HEAD/batch.v1beta1.JobTemplate.json | 3 +- .../HEAD/batch.v1beta1.JobTemplate.pb | Bin 10144 -> 10147 bytes .../HEAD/batch.v1beta1.JobTemplate.yaml | 1 + .../k8s.io/api/testdata/HEAD/core.v1.Pod.json | 3 +- .../k8s.io/api/testdata/HEAD/core.v1.Pod.pb | Bin 10369 -> 10372 bytes .../k8s.io/api/testdata/HEAD/core.v1.Pod.yaml | 1 + .../testdata/HEAD/core.v1.PodTemplate.json | 3 +- .../api/testdata/HEAD/core.v1.PodTemplate.pb | Bin 9659 -> 9662 bytes .../testdata/HEAD/core.v1.PodTemplate.yaml | 1 + .../HEAD/core.v1.ReplicationController.json | 3 +- .../HEAD/core.v1.ReplicationController.pb | Bin 9781 -> 9784 bytes .../HEAD/core.v1.ReplicationController.yaml | 1 + .../HEAD/extensions.v1beta1.DaemonSet.json | 3 +- .../HEAD/extensions.v1beta1.DaemonSet.pb | Bin 9906 -> 9909 bytes .../HEAD/extensions.v1beta1.DaemonSet.yaml | 1 + .../HEAD/extensions.v1beta1.Deployment.json | 3 +- .../HEAD/extensions.v1beta1.Deployment.pb | Bin 9921 -> 9924 bytes .../HEAD/extensions.v1beta1.Deployment.yaml | 1 + .../HEAD/extensions.v1beta1.ReplicaSet.json | 3 +- .../HEAD/extensions.v1beta1.ReplicaSet.pb | Bin 9834 -> 9837 bytes .../HEAD/extensions.v1beta1.ReplicaSet.yaml | 1 + .../applyconfigurations/core/v1/podspec.go | 18 +- .../applyconfigurations/internal/internal.go | 3 + 73 files changed, 1061 insertions(+), 930 deletions(-) diff --git a/api/openapi-spec/swagger.json b/api/openapi-spec/swagger.json index 72edd44da418..9f0951465e1f 100644 --- a/api/openapi-spec/swagger.json +++ b/api/openapi-spec/swagger.json @@ -7824,6 +7824,10 @@ "description": "Use the host's pid namespace. Optional: Default to false.", "type": "boolean" }, + "hostUsers": { + "description": "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.", + "type": "boolean" + }, "hostname": { "description": "Specifies the hostname of the Pod If not specified, the pod's hostname will be set to a system-defined value.", "type": "string" @@ -7860,7 +7864,7 @@ }, "os": { "$ref": "#/definitions/io.k8s.api.core.v1.PodOS", - "description": "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.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" + "description": "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" }, "overhead": { "additionalProperties": { diff --git a/api/openapi-spec/v3/api__v1_openapi.json b/api/openapi-spec/v3/api__v1_openapi.json index ae075a05d2e8..da6a986a81b0 100644 --- a/api/openapi-spec/v3/api__v1_openapi.json +++ b/api/openapi-spec/v3/api__v1_openapi.json @@ -5032,6 +5032,10 @@ "description": "Use the host's pid namespace. Optional: Default to false.", "type": "boolean" }, + "hostUsers": { + "description": "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.", + "type": "boolean" + }, "hostname": { "description": "Specifies the hostname of the Pod If not specified, the pod's hostname will be set to a system-defined value.", "type": "string" @@ -5083,7 +5087,7 @@ "$ref": "#/components/schemas/io.k8s.api.core.v1.PodOS" } ], - "description": "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.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" + "description": "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" }, "overhead": { "additionalProperties": { diff --git a/api/openapi-spec/v3/apis__apps__v1_openapi.json b/api/openapi-spec/v3/apis__apps__v1_openapi.json index 6be2b86cc3d9..0edafc8e2cbe 100644 --- a/api/openapi-spec/v3/apis__apps__v1_openapi.json +++ b/api/openapi-spec/v3/apis__apps__v1_openapi.json @@ -3455,6 +3455,10 @@ "description": "Use the host's pid namespace. Optional: Default to false.", "type": "boolean" }, + "hostUsers": { + "description": "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.", + "type": "boolean" + }, "hostname": { "description": "Specifies the hostname of the Pod If not specified, the pod's hostname will be set to a system-defined value.", "type": "string" @@ -3506,7 +3510,7 @@ "$ref": "#/components/schemas/io.k8s.api.core.v1.PodOS" } ], - "description": "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.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" + "description": "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" }, "overhead": { "additionalProperties": { diff --git a/api/openapi-spec/v3/apis__batch__v1_openapi.json b/api/openapi-spec/v3/apis__batch__v1_openapi.json index dcfb9c4a727b..6a1b40ac1d0a 100644 --- a/api/openapi-spec/v3/apis__batch__v1_openapi.json +++ b/api/openapi-spec/v3/apis__batch__v1_openapi.json @@ -2534,6 +2534,10 @@ "description": "Use the host's pid namespace. Optional: Default to false.", "type": "boolean" }, + "hostUsers": { + "description": "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.", + "type": "boolean" + }, "hostname": { "description": "Specifies the hostname of the Pod If not specified, the pod's hostname will be set to a system-defined value.", "type": "string" @@ -2585,7 +2589,7 @@ "$ref": "#/components/schemas/io.k8s.api.core.v1.PodOS" } ], - "description": "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.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" + "description": "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" }, "overhead": { "additionalProperties": { diff --git a/pkg/apis/core/v1/zz_generated.conversion.go b/pkg/apis/core/v1/zz_generated.conversion.go index 686c22e5a3a5..696b435c235b 100644 --- a/pkg/apis/core/v1/zz_generated.conversion.go +++ b/pkg/apis/core/v1/zz_generated.conversion.go @@ -6093,6 +6093,7 @@ func autoConvert_core_PodSecurityContext_To_v1_PodSecurityContext(in *core.PodSe // INFO: in.HostPID opted out of conversion generation // INFO: in.HostIPC opted out of conversion generation // INFO: in.ShareProcessNamespace opted out of conversion generation + // INFO: in.HostUsers opted out of conversion generation out.SELinuxOptions = (*v1.SELinuxOptions)(unsafe.Pointer(in.SELinuxOptions)) out.WindowsOptions = (*v1.WindowsSecurityContextOptions)(unsafe.Pointer(in.WindowsOptions)) out.RunAsUser = (*int64)(unsafe.Pointer(in.RunAsUser)) @@ -6186,6 +6187,7 @@ func autoConvert_v1_PodSpec_To_core_PodSpec(in *v1.PodSpec, out *core.PodSpec, s out.TopologySpreadConstraints = *(*[]core.TopologySpreadConstraint)(unsafe.Pointer(&in.TopologySpreadConstraints)) out.SetHostnameAsFQDN = (*bool)(unsafe.Pointer(in.SetHostnameAsFQDN)) out.OS = (*core.PodOS)(unsafe.Pointer(in.OS)) + // INFO: in.HostUsers opted out of conversion generation return nil } diff --git a/pkg/apis/core/zz_generated.deepcopy.go b/pkg/apis/core/zz_generated.deepcopy.go index 2c8da9001fd8..0fd886259b2d 100644 --- a/pkg/apis/core/zz_generated.deepcopy.go +++ b/pkg/apis/core/zz_generated.deepcopy.go @@ -3736,6 +3736,11 @@ func (in *PodSecurityContext) DeepCopyInto(out *PodSecurityContext) { *out = new(bool) **out = **in } + if in.HostUsers != nil { + in, out := &in.HostUsers, &out.HostUsers + *out = new(bool) + **out = **in + } if in.SELinuxOptions != nil { in, out := &in.SELinuxOptions, &out.SELinuxOptions *out = new(SELinuxOptions) diff --git a/pkg/generated/openapi/zz_generated.openapi.go b/pkg/generated/openapi/zz_generated.openapi.go index 4097987d0f1b..5681e0ae75b5 100644 --- a/pkg/generated/openapi/zz_generated.openapi.go +++ b/pkg/generated/openapi/zz_generated.openapi.go @@ -22196,10 +22196,17 @@ func schema_k8sio_api_core_v1_PodSpec(ref common.ReferenceCallback) common.OpenA }, "os": { SchemaProps: spec.SchemaProps{ - Description: "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.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", + Description: "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", Ref: ref("k8s.io/api/core/v1.PodOS"), }, }, + "hostUsers": { + SchemaProps: spec.SchemaProps{ + Description: "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.", + Type: []string{"boolean"}, + Format: "", + }, + }, }, Required: []string{"containers"}, }, 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 a5172d707235..aa62ba138fd7 100644 --- a/staging/src/k8s.io/api/core/v1/generated.pb.go +++ b/staging/src/k8s.io/api/core/v1/generated.pb.go @@ -6175,905 +6175,906 @@ func init() { } var fileDescriptor_83c10c24ec417dc9 = []byte{ - // 14361 bytes of a gzipped FileDescriptorProto + // 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, 0xf2, - 0xbd, 0x49, 0xc9, 0x2e, 0x57, 0xca, 0x71, 0x62, 0x2b, 0x4a, 0x52, 0x71, 0xe4, 0xd8, 0x8e, 0xe5, - 0xc4, 0xce, 0xdb, 0xc9, 0x0f, 0xdb, 0x71, 0x55, 0x2c, 0x57, 0xb9, 0x82, 0xd8, 0xeb, 0x54, 0xb9, - 0x54, 0x95, 0xd8, 0x4e, 0x9c, 0x54, 0x25, 0x88, 0x13, 0xa7, 0xce, 0xb3, 0xcf, 0xe9, 0xc7, 0xcc, - 0x60, 0x89, 0x85, 0x28, 0x15, 0xff, 0xcd, 0x9c, 0xef, 0x3b, 0xdf, 0x39, 0x7d, 0x9e, 0xdf, 0xf9, - 0x9e, 0xf0, 0xea, 0xee, 0xcb, 0xe1, 0xbc, 0xeb, 0x5f, 0xde, 0xed, 0x6c, 0x92, 0xc0, 0x23, 0x11, - 0x09, 0x2f, 0xef, 0x11, 0xaf, 0xe1, 0x07, 0x97, 0x05, 0xc0, 0x69, 0xbb, 0x97, 0xeb, 0x7e, 0x40, - 0x2e, 0xef, 0x5d, 0xb9, 0xbc, 0x4d, 0x3c, 0x12, 0x38, 0x11, 0x69, 0xcc, 0xb7, 0x03, 0x3f, 0xf2, - 0x11, 0xe2, 0x38, 0xf3, 0x4e, 0xdb, 0x9d, 0xa7, 0x38, 0xf3, 0x7b, 0x57, 0xe6, 0x9e, 0xdb, 0x76, - 0xa3, 0x9d, 0xce, 0xe6, 0x7c, 0xdd, 0x6f, 0x5d, 0xde, 0xf6, 0xb7, 0xfd, 0xcb, 0x0c, 0x75, 0xb3, - 0xb3, 0xc5, 0xfe, 0xb1, 0x3f, 0xec, 0x17, 0x27, 0x31, 0xf7, 0x62, 0xdc, 0x4c, 0xcb, 0xa9, 0xef, - 0xb8, 0x1e, 0x09, 0xf6, 0x2f, 0xb7, 0x77, 0xb7, 0x59, 0xbb, 0x01, 0x09, 0xfd, 0x4e, 0x50, 0x27, - 0xc9, 0x86, 0xbb, 0xd6, 0x0a, 0x2f, 0xb7, 0x48, 0xe4, 0x64, 0x74, 0x77, 0xee, 0x72, 0x5e, 0xad, - 0xa0, 0xe3, 0x45, 0x6e, 0x2b, 0xdd, 0xcc, 0x87, 0x7a, 0x55, 0x08, 0xeb, 0x3b, 0xa4, 0xe5, 0xa4, - 0xea, 0xbd, 0x90, 0x57, 0xaf, 0x13, 0xb9, 0xcd, 0xcb, 0xae, 0x17, 0x85, 0x51, 0x90, 0xac, 0x64, - 0x7f, 0xdd, 0x82, 0x0b, 0x0b, 0x77, 0x6a, 0xcb, 0x4d, 0x27, 0x8c, 0xdc, 0xfa, 0x62, 0xd3, 0xaf, - 0xef, 0xd6, 0x22, 0x3f, 0x20, 0xb7, 0xfd, 0x66, 0xa7, 0x45, 0x6a, 0x6c, 0x20, 0xd0, 0xb3, 0x30, - 0xb2, 0xc7, 0xfe, 0xaf, 0x56, 0x66, 0xad, 0x0b, 0xd6, 0xa5, 0xd2, 0xe2, 0xd4, 0xaf, 0x1f, 0x94, - 0xdf, 0x77, 0xff, 0xa0, 0x3c, 0x72, 0x5b, 0x94, 0x63, 0x85, 0x81, 0x2e, 0xc2, 0xd0, 0x56, 0xb8, - 0xb1, 0xdf, 0x26, 0xb3, 0x05, 0x86, 0x3b, 0x21, 0x70, 0x87, 0x56, 0x6a, 0xb4, 0x14, 0x0b, 0x28, - 0xba, 0x0c, 0xa5, 0xb6, 0x13, 0x44, 0x6e, 0xe4, 0xfa, 0xde, 0x6c, 0xf1, 0x82, 0x75, 0x69, 0x70, - 0x71, 0x5a, 0xa0, 0x96, 0xaa, 0x12, 0x80, 0x63, 0x1c, 0xda, 0x8d, 0x80, 0x38, 0x8d, 0x9b, 0x5e, - 0x73, 0x7f, 0x76, 0xe0, 0x82, 0x75, 0x69, 0x24, 0xee, 0x06, 0x16, 0xe5, 0x58, 0x61, 0xd8, 0x5f, - 0x2a, 0xc0, 0xc8, 0xc2, 0xd6, 0x96, 0xeb, 0xb9, 0xd1, 0x3e, 0xba, 0x0d, 0x63, 0x9e, 0xdf, 0x20, - 0xf2, 0x3f, 0xfb, 0x8a, 0xd1, 0xe7, 0x2f, 0xcc, 0xa7, 0x97, 0xd2, 0xfc, 0xba, 0x86, 0xb7, 0x38, - 0x75, 0xff, 0xa0, 0x3c, 0xa6, 0x97, 0x60, 0x83, 0x0e, 0xc2, 0x30, 0xda, 0xf6, 0x1b, 0x8a, 0x6c, - 0x81, 0x91, 0x2d, 0x67, 0x91, 0xad, 0xc6, 0x68, 0x8b, 0x93, 0xf7, 0x0f, 0xca, 0xa3, 0x5a, 0x01, - 0xd6, 0x89, 0xa0, 0x4d, 0x98, 0xa4, 0x7f, 0xbd, 0xc8, 0x55, 0x74, 0x8b, 0x8c, 0xee, 0x13, 0x79, - 0x74, 0x35, 0xd4, 0xc5, 0x99, 0xfb, 0x07, 0xe5, 0xc9, 0x44, 0x21, 0x4e, 0x12, 0xb4, 0xdf, 0x86, - 0x89, 0x85, 0x28, 0x72, 0xea, 0x3b, 0xa4, 0xc1, 0x67, 0x10, 0xbd, 0x08, 0x03, 0x9e, 0xd3, 0x22, - 0x62, 0x7e, 0x2f, 0x88, 0x81, 0x1d, 0x58, 0x77, 0x5a, 0xe4, 0xf0, 0xa0, 0x3c, 0x75, 0xcb, 0x73, - 0xdf, 0xea, 0x88, 0x55, 0x41, 0xcb, 0x30, 0xc3, 0x46, 0xcf, 0x03, 0x34, 0xc8, 0x9e, 0x5b, 0x27, - 0x55, 0x27, 0xda, 0x11, 0xf3, 0x8d, 0x44, 0x5d, 0xa8, 0x28, 0x08, 0xd6, 0xb0, 0xec, 0x7b, 0x50, - 0x5a, 0xd8, 0xf3, 0xdd, 0x46, 0xd5, 0x6f, 0x84, 0x68, 0x17, 0x26, 0xdb, 0x01, 0xd9, 0x22, 0x81, - 0x2a, 0x9a, 0xb5, 0x2e, 0x14, 0x2f, 0x8d, 0x3e, 0x7f, 0x29, 0xf3, 0x63, 0x4d, 0xd4, 0x65, 0x2f, - 0x0a, 0xf6, 0x17, 0x1f, 0x11, 0xed, 0x4d, 0x26, 0xa0, 0x38, 0x49, 0xd9, 0xfe, 0xa7, 0x05, 0x38, - 0xbd, 0xf0, 0x76, 0x27, 0x20, 0x15, 0x37, 0xdc, 0x4d, 0xae, 0xf0, 0x86, 0x1b, 0xee, 0xae, 0xc7, - 0x23, 0xa0, 0x96, 0x56, 0x45, 0x94, 0x63, 0x85, 0x81, 0x9e, 0x83, 0x61, 0xfa, 0xfb, 0x16, 0x5e, - 0x15, 0x9f, 0x3c, 0x23, 0x90, 0x47, 0x2b, 0x4e, 0xe4, 0x54, 0x38, 0x08, 0x4b, 0x1c, 0xb4, 0x06, - 0xa3, 0x75, 0xb6, 0x21, 0xb7, 0xd7, 0xfc, 0x06, 0x61, 0x93, 0x59, 0x5a, 0x7c, 0x86, 0xa2, 0x2f, - 0xc5, 0xc5, 0x87, 0x07, 0xe5, 0x59, 0xde, 0x37, 0x41, 0x42, 0x83, 0x61, 0xbd, 0x3e, 0xb2, 0xd5, - 0xfe, 0x1a, 0x60, 0x94, 0x20, 0x63, 0x6f, 0x5d, 0xd2, 0xb6, 0xca, 0x20, 0xdb, 0x2a, 0x63, 0xd9, - 0xdb, 0x04, 0x5d, 0x81, 0x81, 0x5d, 0xd7, 0x6b, 0xcc, 0x0e, 0x31, 0x5a, 0xe7, 0xe8, 0x9c, 0x5f, - 0x77, 0xbd, 0xc6, 0xe1, 0x41, 0x79, 0xda, 0xe8, 0x0e, 0x2d, 0xc4, 0x0c, 0xd5, 0xfe, 0x33, 0x0b, - 0xca, 0x0c, 0xb6, 0xe2, 0x36, 0x49, 0x95, 0x04, 0xa1, 0x1b, 0x46, 0xc4, 0x8b, 0x8c, 0x01, 0x7d, - 0x1e, 0x20, 0x24, 0xf5, 0x80, 0x44, 0xda, 0x90, 0xaa, 0x85, 0x51, 0x53, 0x10, 0xac, 0x61, 0xd1, - 0x03, 0x21, 0xdc, 0x71, 0x02, 0xb6, 0xbe, 0xc4, 0xc0, 0xaa, 0x03, 0xa1, 0x26, 0x01, 0x38, 0xc6, - 0x31, 0x0e, 0x84, 0x62, 0xaf, 0x03, 0x01, 0x7d, 0x14, 0x26, 0xe3, 0xc6, 0xc2, 0xb6, 0x53, 0x97, - 0x03, 0xc8, 0xb6, 0x4c, 0xcd, 0x04, 0xe1, 0x24, 0xae, 0xfd, 0x37, 0x2c, 0xb1, 0x78, 0xe8, 0x57, - 0xbf, 0xcb, 0xbf, 0xd5, 0xfe, 0x25, 0x0b, 0x86, 0x17, 0x5d, 0xaf, 0xe1, 0x7a, 0xdb, 0xe8, 0x33, - 0x30, 0x42, 0xef, 0xa6, 0x86, 0x13, 0x39, 0xe2, 0xdc, 0xfb, 0xa0, 0xb6, 0xb7, 0xd4, 0x55, 0x31, - 0xdf, 0xde, 0xdd, 0xa6, 0x05, 0xe1, 0x3c, 0xc5, 0xa6, 0xbb, 0xed, 0xe6, 0xe6, 0x67, 0x49, 0x3d, - 0x5a, 0x23, 0x91, 0x13, 0x7f, 0x4e, 0x5c, 0x86, 0x15, 0x55, 0x74, 0x1d, 0x86, 0x22, 0x27, 0xd8, - 0x26, 0x91, 0x38, 0x00, 0x33, 0x0f, 0x2a, 0x5e, 0x13, 0xd3, 0x1d, 0x49, 0xbc, 0x3a, 0x89, 0xaf, - 0x85, 0x0d, 0x56, 0x15, 0x0b, 0x12, 0xf6, 0xff, 0x1c, 0x86, 0xb3, 0x4b, 0xb5, 0xd5, 0x9c, 0x75, - 0x75, 0x11, 0x86, 0x1a, 0x81, 0xbb, 0x47, 0x02, 0x31, 0xce, 0x8a, 0x4a, 0x85, 0x95, 0x62, 0x01, - 0x45, 0x2f, 0xc3, 0x18, 0xbf, 0x90, 0xae, 0x39, 0x5e, 0xa3, 0x29, 0x87, 0xf8, 0x94, 0xc0, 0x1e, - 0xbb, 0xad, 0xc1, 0xb0, 0x81, 0x79, 0xc4, 0x45, 0x75, 0x31, 0xb1, 0x19, 0xf3, 0x2e, 0xbb, 0x2f, - 0x58, 0x30, 0xc5, 0x9b, 0x59, 0x88, 0xa2, 0xc0, 0xdd, 0xec, 0x44, 0x24, 0x9c, 0x1d, 0x64, 0x27, - 0xdd, 0x52, 0xd6, 0x68, 0xe5, 0x8e, 0xc0, 0xfc, 0xed, 0x04, 0x15, 0x7e, 0x08, 0xce, 0x8a, 0x76, - 0xa7, 0x92, 0x60, 0x9c, 0x6a, 0x16, 0x7d, 0xaf, 0x05, 0x73, 0x75, 0xdf, 0x8b, 0x02, 0xbf, 0xd9, - 0x24, 0x41, 0xb5, 0xb3, 0xd9, 0x74, 0xc3, 0x1d, 0xbe, 0x4e, 0x31, 0xd9, 0x62, 0x27, 0x41, 0xce, - 0x1c, 0x2a, 0x24, 0x31, 0x87, 0xe7, 0xef, 0x1f, 0x94, 0xe7, 0x96, 0x72, 0x49, 0xe1, 0x2e, 0xcd, - 0xa0, 0x5d, 0x40, 0xf4, 0x2a, 0xad, 0x45, 0xce, 0x36, 0x89, 0x1b, 0x1f, 0xee, 0xbf, 0xf1, 0x33, - 0xf7, 0x0f, 0xca, 0x68, 0x3d, 0x45, 0x02, 0x67, 0x90, 0x45, 0x6f, 0xc1, 0x29, 0x5a, 0x9a, 0xfa, - 0xd6, 0x91, 0xfe, 0x9b, 0x9b, 0xbd, 0x7f, 0x50, 0x3e, 0xb5, 0x9e, 0x41, 0x04, 0x67, 0x92, 0x46, - 0xdf, 0x63, 0xc1, 0xd9, 0xf8, 0xf3, 0x97, 0xef, 0xb5, 0x1d, 0xaf, 0x11, 0x37, 0x5c, 0xea, 0xbf, - 0x61, 0x7a, 0x26, 0x9f, 0x5d, 0xca, 0xa3, 0x84, 0xf3, 0x1b, 0x41, 0x1e, 0xcc, 0xd0, 0xae, 0x25, - 0xdb, 0x86, 0xfe, 0xdb, 0x7e, 0xe4, 0xfe, 0x41, 0x79, 0x66, 0x3d, 0x4d, 0x03, 0x67, 0x11, 0x9e, - 0x5b, 0x82, 0xd3, 0x99, 0xab, 0x13, 0x4d, 0x41, 0x71, 0x97, 0x70, 0xae, 0xab, 0x84, 0xe9, 0x4f, - 0x74, 0x0a, 0x06, 0xf7, 0x9c, 0x66, 0x47, 0x6c, 0x4c, 0xcc, 0xff, 0xbc, 0x52, 0x78, 0xd9, 0xb2, - 0xff, 0x59, 0x11, 0x26, 0x97, 0x6a, 0xab, 0x0f, 0xb4, 0xeb, 0xf5, 0x6b, 0xaf, 0xd0, 0xf5, 0xda, - 0x8b, 0x2f, 0xd1, 0x62, 0xee, 0x25, 0xfa, 0x7f, 0x66, 0x6c, 0xd9, 0x01, 0xb6, 0x65, 0xbf, 0x23, - 0x67, 0xcb, 0x1e, 0xf3, 0x46, 0xdd, 0xcb, 0x59, 0xb5, 0x83, 0x6c, 0x02, 0x33, 0x39, 0xa4, 0x1b, - 0x7e, 0xdd, 0x69, 0x26, 0x8f, 0xda, 0x23, 0x2e, 0xdd, 0xe3, 0x99, 0xc7, 0x3a, 0x8c, 0x2d, 0x39, - 0x6d, 0x67, 0xd3, 0x6d, 0xba, 0x91, 0x4b, 0x42, 0xf4, 0x14, 0x14, 0x9d, 0x46, 0x83, 0x71, 0x77, - 0xa5, 0xc5, 0xd3, 0xf7, 0x0f, 0xca, 0xc5, 0x85, 0x06, 0x65, 0x33, 0x40, 0x61, 0xed, 0x63, 0x8a, - 0x81, 0x3e, 0x00, 0x03, 0x8d, 0xc0, 0x6f, 0xcf, 0x16, 0x18, 0x26, 0xdd, 0xe5, 0x03, 0x95, 0xc0, - 0x6f, 0x27, 0x50, 0x19, 0x8e, 0xfd, 0x6b, 0x05, 0x78, 0x6c, 0x89, 0xb4, 0x77, 0x56, 0x6a, 0x39, - 0xf7, 0xc5, 0x25, 0x18, 0x69, 0xf9, 0x9e, 0x1b, 0xf9, 0x41, 0x28, 0x9a, 0x66, 0x2b, 0x62, 0x4d, - 0x94, 0x61, 0x05, 0x45, 0x17, 0x60, 0xa0, 0x1d, 0x33, 0xb1, 0x63, 0x92, 0x01, 0x66, 0xec, 0x2b, - 0x83, 0x50, 0x8c, 0x4e, 0x48, 0x02, 0xb1, 0x62, 0x14, 0xc6, 0xad, 0x90, 0x04, 0x98, 0x41, 0x62, - 0x4e, 0x80, 0xf2, 0x08, 0xe2, 0x46, 0x48, 0x70, 0x02, 0x14, 0x82, 0x35, 0x2c, 0x54, 0x85, 0x52, - 0x98, 0x98, 0xd9, 0xbe, 0xb6, 0xe6, 0x38, 0x63, 0x15, 0xd4, 0x4c, 0xc6, 0x44, 0x8c, 0x1b, 0x6c, - 0xa8, 0x27, 0xab, 0xf0, 0xb5, 0x02, 0x20, 0x3e, 0x84, 0xdf, 0x62, 0x03, 0x77, 0x2b, 0x3d, 0x70, - 0xfd, 0x6f, 0x89, 0xe3, 0x1a, 0xbd, 0xff, 0x62, 0xc1, 0x63, 0x4b, 0xae, 0xd7, 0x20, 0x41, 0xce, - 0x02, 0x7c, 0x38, 0x6f, 0xe7, 0xa3, 0x31, 0x29, 0xc6, 0x12, 0x1b, 0x38, 0x86, 0x25, 0x66, 0xff, - 0x89, 0x05, 0x88, 0x7f, 0xf6, 0xbb, 0xee, 0x63, 0x6f, 0xa5, 0x3f, 0xf6, 0x18, 0x96, 0x85, 0x7d, - 0x03, 0x26, 0x96, 0x9a, 0x2e, 0xf1, 0xa2, 0xd5, 0xea, 0x92, 0xef, 0x6d, 0xb9, 0xdb, 0xe8, 0x15, - 0x98, 0x88, 0xdc, 0x16, 0xf1, 0x3b, 0x51, 0x8d, 0xd4, 0x7d, 0x8f, 0xbd, 0x5c, 0xad, 0x4b, 0x83, - 0x8b, 0xe8, 0xfe, 0x41, 0x79, 0x62, 0xc3, 0x80, 0xe0, 0x04, 0xa6, 0xfd, 0x7b, 0x74, 0xfc, 0xfc, - 0x56, 0xdb, 0xf7, 0x88, 0x17, 0x2d, 0xf9, 0x5e, 0x83, 0x4b, 0x38, 0x5e, 0x81, 0x81, 0x88, 0x8e, - 0x07, 0x1f, 0xbb, 0x8b, 0x72, 0xa3, 0xd0, 0x51, 0x38, 0x3c, 0x28, 0x9f, 0x49, 0xd7, 0x60, 0xe3, - 0xc4, 0xea, 0xa0, 0xef, 0x80, 0xa1, 0x30, 0x72, 0xa2, 0x4e, 0x28, 0x46, 0xf3, 0x71, 0x39, 0x9a, - 0x35, 0x56, 0x7a, 0x78, 0x50, 0x9e, 0x54, 0xd5, 0x78, 0x11, 0x16, 0x15, 0xd0, 0xd3, 0x30, 0xdc, - 0x22, 0x61, 0xe8, 0x6c, 0xcb, 0xdb, 0x70, 0x52, 0xd4, 0x1d, 0x5e, 0xe3, 0xc5, 0x58, 0xc2, 0xd1, - 0x13, 0x30, 0x48, 0x82, 0xc0, 0x0f, 0xc4, 0x1e, 0x1d, 0x17, 0x88, 0x83, 0xcb, 0xb4, 0x10, 0x73, - 0x98, 0xfd, 0x9b, 0x16, 0x4c, 0xaa, 0xbe, 0xf2, 0xb6, 0x4e, 0xe0, 0x15, 0xf2, 0x49, 0x80, 0xba, - 0xfc, 0xc0, 0x90, 0xdd, 0x1e, 0xa3, 0xcf, 0x5f, 0xcc, 0xbc, 0xa8, 0x53, 0xc3, 0x18, 0x53, 0x56, - 0x45, 0x21, 0xd6, 0xa8, 0xd9, 0xff, 0xc0, 0x82, 0x99, 0xc4, 0x17, 0xdd, 0x70, 0xc3, 0x08, 0xbd, - 0x99, 0xfa, 0xaa, 0xf9, 0xfe, 0xbe, 0x8a, 0xd6, 0x66, 0xdf, 0xa4, 0x96, 0xb2, 0x2c, 0xd1, 0xbe, - 0xe8, 0x1a, 0x0c, 0xba, 0x11, 0x69, 0xc9, 0x8f, 0x79, 0xa2, 0xeb, 0xc7, 0xf0, 0x5e, 0xc5, 0x33, - 0xb2, 0x4a, 0x6b, 0x62, 0x4e, 0xc0, 0xfe, 0xb5, 0x22, 0x94, 0xf8, 0xb2, 0x5d, 0x73, 0xda, 0x27, - 0x30, 0x17, 0xcf, 0x40, 0xc9, 0x6d, 0xb5, 0x3a, 0x91, 0xb3, 0x29, 0x8e, 0xf3, 0x11, 0xbe, 0xb5, - 0x56, 0x65, 0x21, 0x8e, 0xe1, 0x68, 0x15, 0x06, 0x58, 0x57, 0xf8, 0x57, 0x3e, 0x95, 0xfd, 0x95, - 0xa2, 0xef, 0xf3, 0x15, 0x27, 0x72, 0x38, 0x27, 0xa5, 0xee, 0x11, 0x5a, 0x84, 0x19, 0x09, 0xe4, - 0x00, 0x6c, 0xba, 0x9e, 0x13, 0xec, 0xd3, 0xb2, 0xd9, 0x22, 0x23, 0xf8, 0x5c, 0x77, 0x82, 0x8b, - 0x0a, 0x9f, 0x93, 0x55, 0x1f, 0x16, 0x03, 0xb0, 0x46, 0x74, 0xee, 0xc3, 0x50, 0x52, 0xc8, 0x47, - 0x61, 0x88, 0xe6, 0x3e, 0x0a, 0x93, 0x89, 0xb6, 0x7a, 0x55, 0x1f, 0xd3, 0xf9, 0xa9, 0x5f, 0x66, - 0x47, 0x86, 0xe8, 0xf5, 0xb2, 0xb7, 0x27, 0x8e, 0xdc, 0xb7, 0xe1, 0x54, 0x33, 0xe3, 0x24, 0x13, - 0xf3, 0xda, 0xff, 0xc9, 0xf7, 0x98, 0xf8, 0xec, 0x53, 0x59, 0x50, 0x9c, 0xd9, 0x06, 0xe5, 0x11, - 0xfc, 0x36, 0xdd, 0x20, 0x4e, 0x53, 0x67, 0xb7, 0x6f, 0x8a, 0x32, 0xac, 0xa0, 0xf4, 0xbc, 0x3b, - 0xa5, 0x3a, 0x7f, 0x9d, 0xec, 0xd7, 0x48, 0x93, 0xd4, 0x23, 0x3f, 0xf8, 0xa6, 0x76, 0xff, 0x1c, - 0x1f, 0x7d, 0x7e, 0x5c, 0x8e, 0x0a, 0x02, 0xc5, 0xeb, 0x64, 0x9f, 0x4f, 0x85, 0xfe, 0x75, 0xc5, - 0xae, 0x5f, 0xf7, 0x73, 0x16, 0x8c, 0xab, 0xaf, 0x3b, 0x81, 0x73, 0x61, 0xd1, 0x3c, 0x17, 0xce, - 0x75, 0x5d, 0xe0, 0x39, 0x27, 0xc2, 0xd7, 0x0a, 0x70, 0x56, 0xe1, 0xd0, 0xb7, 0x01, 0xff, 0x23, - 0x56, 0xd5, 0x65, 0x28, 0x79, 0x4a, 0x4a, 0x66, 0x99, 0xe2, 0xa9, 0x58, 0x46, 0x16, 0xe3, 0x50, - 0x16, 0xcf, 0x8b, 0x45, 0x59, 0x63, 0xba, 0xf8, 0x58, 0x88, 0x8a, 0x17, 0xa1, 0xd8, 0x71, 0x1b, - 0xe2, 0x82, 0xf9, 0xa0, 0x1c, 0xed, 0x5b, 0xab, 0x95, 0xc3, 0x83, 0xf2, 0xe3, 0x79, 0xaa, 0x0b, - 0x7a, 0xb3, 0x85, 0xf3, 0xb7, 0x56, 0x2b, 0x98, 0x56, 0x46, 0x0b, 0x30, 0x29, 0xb5, 0x33, 0xb7, - 0x29, 0xbb, 0xe5, 0x7b, 0xe2, 0x1e, 0x52, 0x32, 0x60, 0x6c, 0x82, 0x71, 0x12, 0x1f, 0x55, 0x60, - 0x6a, 0xb7, 0xb3, 0x49, 0x9a, 0x24, 0xe2, 0x1f, 0x7c, 0x9d, 0x70, 0x09, 0x69, 0x29, 0x7e, 0x99, - 0x5d, 0x4f, 0xc0, 0x71, 0xaa, 0x86, 0xfd, 0x17, 0xec, 0x3e, 0x10, 0xa3, 0x57, 0x0d, 0x7c, 0xba, - 0xb0, 0x28, 0xf5, 0x6f, 0xe6, 0x72, 0xee, 0x67, 0x55, 0x5c, 0x27, 0xfb, 0x1b, 0x3e, 0xe5, 0xcc, - 0xb3, 0x57, 0x85, 0xb1, 0xe6, 0x07, 0xba, 0xae, 0xf9, 0x9f, 0x2f, 0xc0, 0x69, 0x35, 0x02, 0x06, - 0x13, 0xf8, 0xad, 0x3e, 0x06, 0x57, 0x60, 0xb4, 0x41, 0xb6, 0x9c, 0x4e, 0x33, 0x52, 0xe2, 0xfa, - 0x41, 0xae, 0xb2, 0xa9, 0xc4, 0xc5, 0x58, 0xc7, 0x39, 0xc2, 0xb0, 0xfd, 0xd7, 0x51, 0x76, 0x11, - 0x47, 0x0e, 0x5d, 0xe3, 0x6a, 0xd7, 0x58, 0xb9, 0xbb, 0xe6, 0x09, 0x18, 0x74, 0x5b, 0x94, 0x31, - 0x2b, 0x98, 0xfc, 0xd6, 0x2a, 0x2d, 0xc4, 0x1c, 0x86, 0xde, 0x0f, 0xc3, 0x75, 0xbf, 0xd5, 0x72, - 0xbc, 0x06, 0xbb, 0xf2, 0x4a, 0x8b, 0xa3, 0x94, 0x77, 0x5b, 0xe2, 0x45, 0x58, 0xc2, 0xd0, 0x63, - 0x30, 0xe0, 0x04, 0xdb, 0x5c, 0x86, 0x51, 0x5a, 0x1c, 0xa1, 0x2d, 0x2d, 0x04, 0xdb, 0x21, 0x66, - 0xa5, 0xf4, 0x09, 0x76, 0xd7, 0x0f, 0x76, 0x5d, 0x6f, 0xbb, 0xe2, 0x06, 0x62, 0x4b, 0xa8, 0xbb, - 0xf0, 0x8e, 0x82, 0x60, 0x0d, 0x0b, 0xad, 0xc0, 0x60, 0xdb, 0x0f, 0xa2, 0x70, 0x76, 0x88, 0x0d, - 0xf7, 0xe3, 0x39, 0x07, 0x11, 0xff, 0xda, 0xaa, 0x1f, 0x44, 0xf1, 0x07, 0xd0, 0x7f, 0x21, 0xe6, - 0xd5, 0xd1, 0x0d, 0x18, 0x26, 0xde, 0xde, 0x4a, 0xe0, 0xb7, 0x66, 0x67, 0xf2, 0x29, 0x2d, 0x73, - 0x14, 0xbe, 0xcc, 0x62, 0x1e, 0x55, 0x14, 0x63, 0x49, 0x02, 0x7d, 0x07, 0x14, 0x89, 0xb7, 0x37, - 0x3b, 0xcc, 0x28, 0xcd, 0xe5, 0x50, 0xba, 0xed, 0x04, 0xf1, 0x99, 0xbf, 0xec, 0xed, 0x61, 0x5a, - 0x07, 0x7d, 0x02, 0x4a, 0xf2, 0xc0, 0x08, 0x85, 0x70, 0x30, 0x73, 0xc1, 0xca, 0x63, 0x06, 0x93, - 0xb7, 0x3a, 0x6e, 0x40, 0x5a, 0xc4, 0x8b, 0xc2, 0xf8, 0x84, 0x94, 0xd0, 0x10, 0xc7, 0xd4, 0xd0, - 0x27, 0xa4, 0x44, 0x7a, 0xcd, 0xef, 0x78, 0x51, 0x38, 0x5b, 0x62, 0xdd, 0xcb, 0xd4, 0x15, 0xde, - 0x8e, 0xf1, 0x92, 0x22, 0x6b, 0x5e, 0x19, 0x1b, 0xa4, 0xd0, 0xa7, 0x60, 0x9c, 0xff, 0xe7, 0x1a, - 0xb7, 0x70, 0xf6, 0x34, 0xa3, 0x7d, 0x21, 0x9f, 0x36, 0x47, 0x5c, 0x3c, 0x2d, 0x88, 0x8f, 0xeb, - 0xa5, 0x21, 0x36, 0xa9, 0x21, 0x0c, 0xe3, 0x4d, 0x77, 0x8f, 0x78, 0x24, 0x0c, 0xab, 0x81, 0xbf, - 0x49, 0x84, 0x00, 0xf1, 0x6c, 0xb6, 0x86, 0xce, 0xdf, 0x24, 0x8b, 0xd3, 0x94, 0xe6, 0x0d, 0xbd, - 0x0e, 0x36, 0x49, 0xa0, 0x5b, 0x30, 0x41, 0x5f, 0x6c, 0x6e, 0x4c, 0x74, 0xb4, 0x17, 0x51, 0xf6, - 0xae, 0xc2, 0x46, 0x25, 0x9c, 0x20, 0x82, 0x6e, 0xc2, 0x58, 0x18, 0x39, 0x41, 0xd4, 0x69, 0x73, - 0xa2, 0x67, 0x7a, 0x11, 0x65, 0x0a, 0xde, 0x9a, 0x56, 0x05, 0x1b, 0x04, 0xd0, 0xeb, 0x50, 0x6a, - 0xba, 0x5b, 0xa4, 0xbe, 0x5f, 0x6f, 0x92, 0xd9, 0x31, 0x46, 0x2d, 0xf3, 0x50, 0xb9, 0x21, 0x91, - 0x38, 0x9f, 0xab, 0xfe, 0xe2, 0xb8, 0x3a, 0xba, 0x0d, 0x67, 0x22, 0x12, 0xb4, 0x5c, 0xcf, 0xa1, - 0x87, 0x81, 0x78, 0x5a, 0x31, 0xc5, 0xe9, 0x38, 0xdb, 0x6d, 0xe7, 0xc5, 0x6c, 0x9c, 0xd9, 0xc8, - 0xc4, 0xc2, 0x39, 0xb5, 0xd1, 0x3d, 0x98, 0xcd, 0x80, 0xf8, 0x4d, 0xb7, 0xbe, 0x3f, 0x7b, 0x8a, - 0x51, 0xfe, 0x88, 0xa0, 0x3c, 0xbb, 0x91, 0x83, 0x77, 0xd8, 0x05, 0x86, 0x73, 0xa9, 0xa3, 0x9b, - 0x30, 0xc9, 0x4e, 0xa0, 0x6a, 0xa7, 0xd9, 0x14, 0x0d, 0x4e, 0xb0, 0x06, 0xdf, 0x2f, 0xef, 0xe3, - 0x55, 0x13, 0x7c, 0x78, 0x50, 0x86, 0xf8, 0x1f, 0x4e, 0xd6, 0x46, 0x9b, 0x4c, 0x47, 0xd7, 0x09, - 0xdc, 0x68, 0x9f, 0x9e, 0x1b, 0xe4, 0x5e, 0x34, 0x3b, 0xd9, 0x55, 0x5e, 0xa1, 0xa3, 0x2a, 0x45, - 0x9e, 0x5e, 0x88, 0x93, 0x04, 0xe9, 0x91, 0x1a, 0x46, 0x0d, 0xd7, 0x9b, 0x9d, 0xe2, 0xef, 0x12, - 0x79, 0x22, 0xd5, 0x68, 0x21, 0xe6, 0x30, 0xa6, 0x9f, 0xa3, 0x3f, 0x6e, 0xd2, 0x9b, 0x6b, 0x9a, - 0x21, 0xc6, 0xfa, 0x39, 0x09, 0xc0, 0x31, 0x0e, 0x65, 0x26, 0xa3, 0x68, 0x7f, 0x16, 0x31, 0x54, - 0x75, 0xb0, 0x6c, 0x6c, 0x7c, 0x02, 0xd3, 0x72, 0x7b, 0x13, 0x26, 0xd4, 0x41, 0xc8, 0xc6, 0x04, - 0x95, 0x61, 0x90, 0xb1, 0x4f, 0x42, 0xba, 0x56, 0xa2, 0x5d, 0x60, 0xac, 0x15, 0xe6, 0xe5, 0xac, - 0x0b, 0xee, 0xdb, 0x64, 0x71, 0x3f, 0x22, 0xfc, 0x4d, 0x5f, 0xd4, 0xba, 0x20, 0x01, 0x38, 0xc6, - 0xb1, 0xff, 0x17, 0x67, 0x43, 0xe3, 0xd3, 0xb6, 0x8f, 0xfb, 0xe5, 0x59, 0x18, 0xd9, 0xf1, 0xc3, - 0x88, 0x62, 0xb3, 0x36, 0x06, 0x63, 0xc6, 0xf3, 0x9a, 0x28, 0xc7, 0x0a, 0x03, 0xbd, 0x0a, 0xe3, - 0x75, 0xbd, 0x01, 0x71, 0x39, 0xaa, 0x63, 0xc4, 0x68, 0x1d, 0x9b, 0xb8, 0xe8, 0x65, 0x18, 0x61, - 0x36, 0x27, 0x75, 0xbf, 0x29, 0xb8, 0x36, 0x79, 0xc3, 0x8f, 0x54, 0x45, 0xf9, 0xa1, 0xf6, 0x1b, - 0x2b, 0x6c, 0x74, 0x11, 0x86, 0x68, 0x17, 0x56, 0xab, 0xe2, 0x5a, 0x52, 0x82, 0xa2, 0x6b, 0xac, - 0x14, 0x0b, 0xa8, 0xfd, 0xff, 0x16, 0xb4, 0x51, 0xa6, 0xef, 0x61, 0x82, 0xaa, 0x30, 0x7c, 0xd7, - 0x71, 0x23, 0xd7, 0xdb, 0x16, 0xfc, 0xc7, 0xd3, 0x5d, 0xef, 0x28, 0x56, 0xe9, 0x0e, 0xaf, 0xc0, - 0x6f, 0x51, 0xf1, 0x07, 0x4b, 0x32, 0x94, 0x62, 0xd0, 0xf1, 0x3c, 0x4a, 0xb1, 0xd0, 0x2f, 0x45, - 0xcc, 0x2b, 0x70, 0x8a, 0xe2, 0x0f, 0x96, 0x64, 0xd0, 0x9b, 0x00, 0x72, 0x87, 0x91, 0x86, 0xb0, - 0xf5, 0x78, 0xb6, 0x37, 0xd1, 0x0d, 0x55, 0x67, 0x71, 0x82, 0xde, 0xd1, 0xf1, 0x7f, 0xac, 0xd1, - 0xb3, 0x23, 0xc6, 0xa7, 0xa5, 0x3b, 0x83, 0xbe, 0x8b, 0x2e, 0x71, 0x27, 0x88, 0x48, 0x63, 0x21, - 0x12, 0x83, 0xf3, 0x81, 0xfe, 0x1e, 0x29, 0x1b, 0x6e, 0x8b, 0xe8, 0xdb, 0x41, 0x10, 0xc1, 0x31, - 0x3d, 0xfb, 0x17, 0x8b, 0x30, 0x9b, 0xd7, 0x5d, 0xba, 0xe8, 0xc8, 0x3d, 0x37, 0x5a, 0xa2, 0xec, - 0x95, 0x65, 0x2e, 0xba, 0x65, 0x51, 0x8e, 0x15, 0x06, 0x9d, 0xfd, 0xd0, 0xdd, 0x96, 0x6f, 0xcc, - 0xc1, 0x78, 0xf6, 0x6b, 0xac, 0x14, 0x0b, 0x28, 0xc5, 0x0b, 0x88, 0x13, 0x0a, 0x63, 0x22, 0x6d, - 0x95, 0x60, 0x56, 0x8a, 0x05, 0x54, 0x97, 0x76, 0x0d, 0xf4, 0x90, 0x76, 0x19, 0x43, 0x34, 0x78, - 0xbc, 0x43, 0x84, 0x3e, 0x0d, 0xb0, 0xe5, 0x7a, 0x6e, 0xb8, 0xc3, 0xa8, 0x0f, 0x1d, 0x99, 0xba, - 0x62, 0xce, 0x56, 0x14, 0x15, 0xac, 0x51, 0x44, 0x2f, 0xc1, 0xa8, 0xda, 0x80, 0xab, 0x15, 0xa6, - 0x59, 0xd5, 0x2c, 0x55, 0xe2, 0xd3, 0xa8, 0x82, 0x75, 0x3c, 0xfb, 0xb3, 0xc9, 0xf5, 0x22, 0x76, - 0x80, 0x36, 0xbe, 0x56, 0xbf, 0xe3, 0x5b, 0xe8, 0x3e, 0xbe, 0xf6, 0x37, 0x8a, 0x30, 0x69, 0x34, - 0xd6, 0x09, 0xfb, 0x38, 0xb3, 0xae, 0xd2, 0x03, 0xdc, 0x89, 0x88, 0xd8, 0x7f, 0x76, 0xef, 0xad, - 0xa2, 0x1f, 0xf2, 0x74, 0x07, 0xf0, 0xfa, 0xe8, 0xd3, 0x50, 0x6a, 0x3a, 0x21, 0x93, 0x9c, 0x11, - 0xb1, 0xef, 0xfa, 0x21, 0x16, 0x3f, 0x4c, 0x9c, 0x30, 0xd2, 0x6e, 0x4d, 0x4e, 0x3b, 0x26, 0x49, - 0x6f, 0x1a, 0xca, 0x9f, 0x48, 0x6b, 0x35, 0xd5, 0x09, 0xca, 0xc4, 0xec, 0x63, 0x0e, 0x43, 0x2f, - 0xc3, 0x58, 0x40, 0xd8, 0xaa, 0x58, 0xa2, 0xdc, 0x1c, 0x5b, 0x66, 0x83, 0x31, 0xdb, 0x87, 0x35, - 0x18, 0x36, 0x30, 0xe3, 0xb7, 0xc1, 0x50, 0x97, 0xb7, 0xc1, 0xd3, 0x30, 0xcc, 0x7e, 0xa8, 0x15, - 0xa0, 0x66, 0x63, 0x95, 0x17, 0x63, 0x09, 0x4f, 0x2e, 0x98, 0x91, 0xfe, 0x16, 0x0c, 0x7d, 0x7d, - 0x88, 0x45, 0xcd, 0xb4, 0xda, 0x23, 0xfc, 0x94, 0x13, 0x4b, 0x1e, 0x4b, 0x98, 0xfd, 0x01, 0x98, - 0xa8, 0x38, 0xa4, 0xe5, 0x7b, 0xcb, 0x5e, 0xa3, 0xed, 0xbb, 0x5e, 0x84, 0x66, 0x61, 0x80, 0x5d, - 0x22, 0xfc, 0x08, 0x18, 0xa0, 0x0d, 0x61, 0x56, 0x62, 0x6f, 0xc3, 0xe9, 0x8a, 0x7f, 0xd7, 0xbb, - 0xeb, 0x04, 0x8d, 0x85, 0xea, 0xaa, 0xf6, 0xbe, 0x5e, 0x97, 0xef, 0x3b, 0x6e, 0x24, 0x96, 0x79, - 0xf4, 0x6a, 0x35, 0x39, 0x5b, 0xbb, 0xe2, 0x36, 0x49, 0x8e, 0x14, 0xe4, 0x2f, 0x15, 0x8c, 0x96, - 0x62, 0x7c, 0xa5, 0xd5, 0xb2, 0x72, 0xb5, 0x5a, 0x6f, 0xc0, 0xc8, 0x96, 0x4b, 0x9a, 0x0d, 0x4c, - 0xb6, 0xc4, 0x4a, 0x7c, 0x2a, 0xdf, 0xee, 0x65, 0x85, 0x62, 0x4a, 0xa9, 0x17, 0x7f, 0x1d, 0xae, - 0x88, 0xca, 0x58, 0x91, 0x41, 0xbb, 0x30, 0x25, 0x1f, 0x0c, 0x12, 0x2a, 0xd6, 0xe5, 0xd3, 0xdd, - 0x5e, 0x21, 0x26, 0xf1, 0x53, 0xf7, 0x0f, 0xca, 0x53, 0x38, 0x41, 0x06, 0xa7, 0x08, 0xd3, 0xe7, - 0x60, 0x8b, 0x9e, 0xc0, 0x03, 0x6c, 0xf8, 0xd9, 0x73, 0x90, 0xbd, 0x6c, 0x59, 0xa9, 0xfd, 0x13, - 0x16, 0x3c, 0x92, 0x1a, 0x19, 0xf1, 0xc2, 0x3f, 0xe6, 0x59, 0x48, 0xbe, 0xb8, 0x0b, 0xbd, 0x5f, - 0xdc, 0xf6, 0xdf, 0xb4, 0xe0, 0xd4, 0x72, 0xab, 0x1d, 0xed, 0x57, 0x5c, 0x53, 0x05, 0xf5, 0x61, - 0x18, 0x6a, 0x91, 0x86, 0xdb, 0x69, 0x89, 0x99, 0x2b, 0xcb, 0x53, 0x6a, 0x8d, 0x95, 0x1e, 0x1e, - 0x94, 0xc7, 0x6b, 0x91, 0x1f, 0x38, 0xdb, 0x84, 0x17, 0x60, 0x81, 0xce, 0xce, 0x7a, 0xf7, 0x6d, - 0x72, 0xc3, 0x6d, 0xb9, 0xd2, 0x8e, 0xa9, 0xab, 0xcc, 0x6e, 0x5e, 0x0e, 0xe8, 0xfc, 0x1b, 0x1d, - 0xc7, 0x8b, 0xdc, 0x68, 0x5f, 0x68, 0x8f, 0x24, 0x11, 0x1c, 0xd3, 0xb3, 0xbf, 0x6e, 0xc1, 0xa4, - 0x5c, 0xf7, 0x0b, 0x8d, 0x46, 0x40, 0xc2, 0x10, 0xcd, 0x41, 0xc1, 0x6d, 0x8b, 0x5e, 0x82, 0xe8, - 0x65, 0x61, 0xb5, 0x8a, 0x0b, 0x6e, 0x5b, 0xb2, 0x65, 0xec, 0x20, 0x2c, 0x9a, 0x8a, 0xb4, 0x6b, - 0xa2, 0x1c, 0x2b, 0x0c, 0x74, 0x09, 0x46, 0x3c, 0xbf, 0xc1, 0x6d, 0xc9, 0xf8, 0x95, 0xc6, 0x16, - 0xd8, 0xba, 0x28, 0xc3, 0x0a, 0x8a, 0xaa, 0x50, 0xe2, 0x66, 0x56, 0xf1, 0xa2, 0xed, 0xcb, 0x58, - 0x8b, 0x7d, 0xd9, 0x86, 0xac, 0x89, 0x63, 0x22, 0xf6, 0xaf, 0x5a, 0x30, 0x26, 0xbf, 0xac, 0x4f, - 0x9e, 0x93, 0x6e, 0xad, 0x98, 0xdf, 0x8c, 0xb7, 0x16, 0xe5, 0x19, 0x19, 0xc4, 0x60, 0x15, 0x8b, - 0x47, 0x62, 0x15, 0xaf, 0xc0, 0xa8, 0xd3, 0x6e, 0x57, 0x4d, 0x3e, 0x93, 0x2d, 0xa5, 0x85, 0xb8, - 0x18, 0xeb, 0x38, 0xf6, 0x8f, 0x17, 0x60, 0x42, 0x7e, 0x41, 0xad, 0xb3, 0x19, 0x92, 0x08, 0x6d, - 0x40, 0xc9, 0xe1, 0xb3, 0x44, 0xe4, 0x22, 0x7f, 0x22, 0x5b, 0x8e, 0x60, 0x4c, 0x69, 0x7c, 0xe1, - 0x2f, 0xc8, 0xda, 0x38, 0x26, 0x84, 0x9a, 0x30, 0xed, 0xf9, 0x11, 0x3b, 0xfc, 0x15, 0xbc, 0x9b, - 0x6a, 0x27, 0x49, 0xfd, 0xac, 0xa0, 0x3e, 0xbd, 0x9e, 0xa4, 0x82, 0xd3, 0x84, 0xd1, 0xb2, 0x94, - 0xcd, 0x14, 0xf3, 0x85, 0x01, 0xfa, 0xc4, 0x65, 0x8b, 0x66, 0xec, 0x5f, 0xb1, 0xa0, 0x24, 0xd1, - 0x4e, 0x42, 0x8b, 0xb7, 0x06, 0xc3, 0x21, 0x9b, 0x04, 0x39, 0x34, 0x76, 0xb7, 0x8e, 0xf3, 0xf9, - 0x8a, 0xef, 0x34, 0xfe, 0x3f, 0xc4, 0x92, 0x06, 0x13, 0xcd, 0xab, 0xee, 0xbf, 0x4b, 0x44, 0xf3, - 0xaa, 0x3f, 0x39, 0x97, 0xd2, 0x1f, 0xb1, 0x3e, 0x6b, 0xb2, 0x2e, 0xca, 0x7a, 0xb5, 0x03, 0xb2, - 0xe5, 0xde, 0x4b, 0xb2, 0x5e, 0x55, 0x56, 0x8a, 0x05, 0x14, 0xbd, 0x09, 0x63, 0x75, 0x29, 0x93, - 0x8d, 0x77, 0xf8, 0xc5, 0xae, 0xfa, 0x01, 0xa5, 0x4a, 0xe2, 0xb2, 0x90, 0x25, 0xad, 0x3e, 0x36, - 0xa8, 0x99, 0x66, 0x04, 0xc5, 0x5e, 0x66, 0x04, 0x31, 0xdd, 0x7c, 0xa5, 0xfa, 0x4f, 0x5a, 0x30, - 0xc4, 0x65, 0x71, 0xfd, 0x89, 0x42, 0x35, 0xcd, 0x5a, 0x3c, 0x76, 0xb7, 0x69, 0xa1, 0xd0, 0x94, - 0xa1, 0x35, 0x28, 0xb1, 0x1f, 0x4c, 0x96, 0x58, 0xcc, 0xb7, 0xf2, 0xe7, 0xad, 0xea, 0x1d, 0xbc, - 0x2d, 0xab, 0xe1, 0x98, 0x82, 0xfd, 0x63, 0x45, 0x7a, 0xba, 0xc5, 0xa8, 0xc6, 0xa5, 0x6f, 0x3d, - 0xbc, 0x4b, 0xbf, 0xf0, 0xb0, 0x2e, 0xfd, 0x6d, 0x98, 0xac, 0x6b, 0x7a, 0xb8, 0x78, 0x26, 0x2f, - 0x75, 0x5d, 0x24, 0x9a, 0xca, 0x8e, 0x4b, 0x59, 0x96, 0x4c, 0x22, 0x38, 0x49, 0x15, 0x7d, 0x17, - 0x8c, 0xf1, 0x79, 0x16, 0xad, 0x70, 0x4b, 0x8c, 0xf7, 0xe7, 0xaf, 0x17, 0xbd, 0x09, 0x2e, 0x95, - 0xd3, 0xaa, 0x63, 0x83, 0x98, 0xfd, 0xa7, 0x16, 0xa0, 0xe5, 0xf6, 0x0e, 0x69, 0x91, 0xc0, 0x69, - 0xc6, 0xe2, 0xf4, 0x1f, 0xb6, 0x60, 0x96, 0xa4, 0x8a, 0x97, 0xfc, 0x56, 0x4b, 0x3c, 0x5a, 0x72, - 0xde, 0xd5, 0xcb, 0x39, 0x75, 0x94, 0x1b, 0xc4, 0x6c, 0x1e, 0x06, 0xce, 0x6d, 0x0f, 0xad, 0xc1, - 0x0c, 0xbf, 0x25, 0x15, 0x40, 0xb3, 0xf5, 0x7e, 0x54, 0x10, 0x9e, 0xd9, 0x48, 0xa3, 0xe0, 0xac, - 0x7a, 0xf6, 0xf7, 0x8d, 0x41, 0x6e, 0x2f, 0xde, 0xd3, 0x23, 0xbc, 0xa7, 0x47, 0x78, 0x4f, 0x8f, - 0xf0, 0x9e, 0x1e, 0xe1, 0x3d, 0x3d, 0xc2, 0xb7, 0xbd, 0x1e, 0xe1, 0xff, 0xb3, 0xe0, 0xb4, 0xba, - 0x06, 0x8c, 0x87, 0xef, 0xe7, 0x60, 0x86, 0x6f, 0xb7, 0xa5, 0xa6, 0xe3, 0xb6, 0x36, 0x48, 0xab, - 0xdd, 0x74, 0x22, 0xa9, 0x75, 0xbf, 0x92, 0xb9, 0x72, 0x13, 0x16, 0xab, 0x46, 0x45, 0x6e, 0xfa, - 0x9f, 0x01, 0xc0, 0x59, 0xcd, 0xd8, 0xbf, 0x38, 0x02, 0x83, 0xcb, 0x7b, 0xc4, 0x8b, 0x4e, 0xe0, - 0x89, 0x50, 0x87, 0x09, 0xd7, 0xdb, 0xf3, 0x9b, 0x7b, 0xa4, 0xc1, 0xe1, 0x47, 0x79, 0xc9, 0x9e, - 0x11, 0xa4, 0x27, 0x56, 0x0d, 0x12, 0x38, 0x41, 0xf2, 0x61, 0x48, 0x93, 0xaf, 0xc2, 0x10, 0x3f, - 0xc4, 0x85, 0x28, 0x39, 0xf3, 0xcc, 0x66, 0x83, 0x28, 0xae, 0xa6, 0x58, 0xd2, 0xcd, 0x2f, 0x09, - 0x51, 0x1d, 0x7d, 0x16, 0x26, 0xb6, 0xdc, 0x20, 0x8c, 0x36, 0xdc, 0x16, 0x09, 0x23, 0xa7, 0xd5, - 0x7e, 0x00, 0xe9, 0xb1, 0x1a, 0x87, 0x15, 0x83, 0x12, 0x4e, 0x50, 0x46, 0xdb, 0x30, 0xde, 0x74, - 0xf4, 0xa6, 0x86, 0x8f, 0xdc, 0x94, 0xba, 0x1d, 0x6e, 0xe8, 0x84, 0xb0, 0x49, 0x97, 0x6e, 0xa7, - 0x3a, 0x13, 0x80, 0x8e, 0x30, 0xb1, 0x80, 0xda, 0x4e, 0x5c, 0xf2, 0xc9, 0x61, 0x94, 0xd1, 0x61, - 0x06, 0xb2, 0x25, 0x93, 0xd1, 0xd1, 0xcc, 0x60, 0x3f, 0x03, 0x25, 0x42, 0x87, 0x90, 0x12, 0x16, - 0x17, 0xcc, 0xe5, 0xfe, 0xfa, 0xba, 0xe6, 0xd6, 0x03, 0xdf, 0x94, 0xdb, 0x2f, 0x4b, 0x4a, 0x38, - 0x26, 0x8a, 0x96, 0x60, 0x28, 0x24, 0x81, 0x4b, 0x42, 0x71, 0xd5, 0x74, 0x99, 0x46, 0x86, 0xc6, - 0x7d, 0x4b, 0xf8, 0x6f, 0x2c, 0xaa, 0xd2, 0xe5, 0xe5, 0x30, 0x91, 0x26, 0xbb, 0x0c, 0xb4, 0xe5, - 0xb5, 0xc0, 0x4a, 0xb1, 0x80, 0xa2, 0xd7, 0x61, 0x38, 0x20, 0x4d, 0xa6, 0x18, 0x1a, 0xef, 0x7f, - 0x91, 0x73, 0x3d, 0x13, 0xaf, 0x87, 0x25, 0x01, 0x74, 0x1d, 0x50, 0x40, 0x28, 0xa3, 0xe4, 0x7a, - 0xdb, 0xca, 0x6c, 0x54, 0x1c, 0xb4, 0x8a, 0x21, 0xc5, 0x31, 0x86, 0x74, 0x2b, 0xc2, 0x19, 0xd5, - 0xd0, 0x55, 0x98, 0x56, 0xa5, 0xab, 0x5e, 0x18, 0x39, 0xf4, 0x80, 0x9b, 0x64, 0xb4, 0x94, 0x9c, - 0x02, 0x27, 0x11, 0x70, 0xba, 0x8e, 0xfd, 0x65, 0x0b, 0xf8, 0x38, 0x9f, 0xc0, 0xeb, 0xfc, 0x35, - 0xf3, 0x75, 0x7e, 0x36, 0x77, 0xe6, 0x72, 0x5e, 0xe6, 0x5f, 0xb6, 0x60, 0x54, 0x9b, 0xd9, 0x78, - 0xcd, 0x5a, 0x5d, 0xd6, 0x6c, 0x07, 0xa6, 0xe8, 0x4a, 0xbf, 0xb9, 0x19, 0x92, 0x60, 0x8f, 0x34, - 0xd8, 0xc2, 0x2c, 0x3c, 0xd8, 0xc2, 0x54, 0x26, 0x6a, 0x37, 0x12, 0x04, 0x71, 0xaa, 0x09, 0xfb, - 0x33, 0xb2, 0xab, 0xca, 0xa2, 0xaf, 0xae, 0xe6, 0x3c, 0x61, 0xd1, 0xa7, 0x66, 0x15, 0xc7, 0x38, - 0x74, 0xab, 0xed, 0xf8, 0x61, 0x94, 0xb4, 0xe8, 0xbb, 0xe6, 0x87, 0x11, 0x66, 0x10, 0xfb, 0x05, - 0x80, 0xe5, 0x7b, 0xa4, 0xce, 0x57, 0xac, 0xfe, 0x78, 0xb0, 0xf2, 0x1f, 0x0f, 0xf6, 0x6f, 0x5b, - 0x30, 0xb1, 0xb2, 0x64, 0xdc, 0x5c, 0xf3, 0x00, 0xfc, 0xc5, 0x73, 0xe7, 0xce, 0xba, 0x54, 0x87, - 0x73, 0x8d, 0xa6, 0x2a, 0xc5, 0x1a, 0x06, 0x3a, 0x0b, 0xc5, 0x66, 0xc7, 0x13, 0xe2, 0xc3, 0x61, - 0x7a, 0x3d, 0xde, 0xe8, 0x78, 0x98, 0x96, 0x69, 0x2e, 0x05, 0xc5, 0xbe, 0x5d, 0x0a, 0x7a, 0x86, - 0x12, 0x40, 0x65, 0x18, 0xbc, 0x7b, 0xd7, 0x6d, 0x70, 0x87, 0x4d, 0xa1, 0xaa, 0xbf, 0x73, 0x67, - 0xb5, 0x12, 0x62, 0x5e, 0x6e, 0x7f, 0xb1, 0x08, 0x73, 0x2b, 0x4d, 0x72, 0xef, 0x1d, 0x3a, 0xad, - 0xf6, 0xeb, 0x10, 0x71, 0x34, 0x41, 0xcc, 0x51, 0x9d, 0x5e, 0x7a, 0x8f, 0xc7, 0x16, 0x0c, 0x73, - 0x83, 0x36, 0xe9, 0xc2, 0xfa, 0x6a, 0x56, 0xeb, 0xf9, 0x03, 0x32, 0xcf, 0x0d, 0xe3, 0x84, 0x47, - 0x9c, 0xba, 0x30, 0x45, 0x29, 0x96, 0xc4, 0xe7, 0x5e, 0x81, 0x31, 0x1d, 0xf3, 0x48, 0xee, 0x67, - 0xff, 0x57, 0x11, 0xa6, 0x68, 0x0f, 0x1e, 0xea, 0x44, 0xdc, 0x4a, 0x4f, 0xc4, 0x71, 0xbb, 0x20, - 0xf5, 0x9e, 0x8d, 0x37, 0x93, 0xb3, 0x71, 0x25, 0x6f, 0x36, 0x4e, 0x7a, 0x0e, 0xbe, 0xd7, 0x82, - 0x99, 0x95, 0xa6, 0x5f, 0xdf, 0x4d, 0xb8, 0x09, 0xbd, 0x04, 0xa3, 0xf4, 0x38, 0x0e, 0x0d, 0x8f, - 0x79, 0x23, 0x86, 0x82, 0x00, 0x61, 0x1d, 0x4f, 0xab, 0x76, 0xeb, 0xd6, 0x6a, 0x25, 0x2b, 0xf4, - 0x82, 0x00, 0x61, 0x1d, 0xcf, 0xfe, 0x0d, 0x0b, 0xce, 0x5d, 0x5d, 0x5a, 0x8e, 0x97, 0x62, 0x2a, - 0xfa, 0xc3, 0x45, 0x18, 0x6a, 0x37, 0xb4, 0xae, 0xc4, 0xe2, 0xd5, 0x0a, 0xeb, 0x85, 0x80, 0xbe, - 0x5b, 0x22, 0x9b, 0xdc, 0x02, 0xb8, 0x8a, 0xab, 0x4b, 0xe2, 0xdc, 0x95, 0xda, 0x14, 0x2b, 0x57, - 0x9b, 0xf2, 0x7e, 0x18, 0xa6, 0xf7, 0x82, 0x5b, 0x97, 0xfd, 0xe6, 0x0a, 0x5a, 0x5e, 0x84, 0x25, - 0xcc, 0xfe, 0x59, 0x0b, 0x66, 0xae, 0xba, 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, 0x6a, 0xb8, 0x01, 0x13, - 0xfd, 0xed, 0x8b, 0x83, 0x5b, 0x8d, 0x57, 0x45, 0x02, 0x70, 0x8c, 0x63, 0xff, 0xb1, 0x05, 0xe5, - 0xab, 0xcd, 0x4e, 0x18, 0x91, 0x60, 0x2b, 0xcc, 0x39, 0x74, 0x5f, 0x80, 0x12, 0x91, 0x82, 0x76, - 0xd1, 0x6b, 0xc5, 0x88, 0x2a, 0x09, 0x3c, 0x8f, 0xb2, 0xa0, 0xf0, 0xfa, 0xf0, 0x65, 0x3c, 0x9a, - 0x33, 0xda, 0x0a, 0x20, 0xa2, 0xb7, 0xa5, 0x87, 0x9d, 0x60, 0xfe, 0xeb, 0xcb, 0x29, 0x28, 0xce, - 0xa8, 0x61, 0xff, 0x84, 0x05, 0xa7, 0xd5, 0x07, 0xbf, 0xeb, 0x3e, 0xd3, 0xfe, 0x6a, 0x01, 0xc6, - 0xaf, 0x6d, 0x6c, 0x54, 0xaf, 0x92, 0x48, 0x5b, 0x95, 0xdd, 0xd5, 0xe7, 0x58, 0xd3, 0x02, 0x76, - 0x7b, 0x23, 0x76, 0x22, 0xb7, 0x39, 0xcf, 0xa3, 0x17, 0xcd, 0xaf, 0x7a, 0xd1, 0xcd, 0xa0, 0x16, - 0x05, 0xae, 0xb7, 0x9d, 0xb9, 0xd2, 0x25, 0xcf, 0x52, 0xcc, 0xe3, 0x59, 0xd0, 0x0b, 0x30, 0xc4, - 0xc2, 0x27, 0xc9, 0x49, 0x78, 0x54, 0x3d, 0xb1, 0x58, 0xe9, 0xe1, 0x41, 0xb9, 0x74, 0x0b, 0xaf, - 0xf2, 0x3f, 0x58, 0xa0, 0xa2, 0x5b, 0x30, 0xba, 0x13, 0x45, 0xed, 0x6b, 0xc4, 0x69, 0x90, 0x40, - 0x9e, 0xb2, 0xe7, 0xb3, 0x4e, 0x59, 0x3a, 0x08, 0x1c, 0x2d, 0x3e, 0x98, 0xe2, 0xb2, 0x10, 0xeb, - 0x74, 0xec, 0x1a, 0x40, 0x0c, 0x3b, 0x26, 0x05, 0x88, 0xbd, 0x01, 0x25, 0xfa, 0xb9, 0x0b, 0x4d, - 0xd7, 0xe9, 0xae, 0x62, 0x7e, 0x06, 0x4a, 0x52, 0x81, 0x1c, 0x0a, 0x5f, 0x6b, 0x76, 0x23, 0x49, - 0xfd, 0x72, 0x88, 0x63, 0xb8, 0xbd, 0x05, 0xa7, 0x98, 0x39, 0xa0, 0x13, 0xed, 0x18, 0xab, 0xaf, - 0xf7, 0x34, 0x3f, 0x2b, 0x5e, 0x6c, 0xbc, 0xcf, 0xb3, 0x9a, 0x3b, 0xe3, 0x98, 0xa4, 0x18, 0xbf, - 0xde, 0xec, 0x6f, 0x0c, 0xc0, 0xa3, 0xab, 0xb5, 0xfc, 0xf0, 0x1f, 0x2f, 0xc3, 0x18, 0x67, 0x04, - 0xe9, 0xa4, 0x3b, 0x4d, 0xd1, 0xae, 0x92, 0x6d, 0x6e, 0x68, 0x30, 0x6c, 0x60, 0xa2, 0x73, 0x50, - 0x74, 0xdf, 0xf2, 0x92, 0xce, 0x3e, 0xab, 0x6f, 0xac, 0x63, 0x5a, 0x4e, 0xc1, 0x94, 0xa7, 0xe4, - 0x87, 0xb5, 0x02, 0x2b, 0xbe, 0xf2, 0x35, 0x98, 0x70, 0xc3, 0x7a, 0xe8, 0xae, 0x7a, 0x74, 0x07, - 0x6a, 0x7b, 0x58, 0x49, 0x13, 0x68, 0xa7, 0x15, 0x14, 0x27, 0xb0, 0xb5, 0x9b, 0x63, 0xb0, 0x6f, - 0xbe, 0xb4, 0xa7, 0xf3, 0x31, 0x3d, 0xd8, 0xdb, 0xec, 0xeb, 0x42, 0x26, 0xa4, 0x16, 0x07, 0x3b, - 0xff, 0xe0, 0x10, 0x4b, 0x18, 0x7d, 0xaa, 0xd5, 0x77, 0x9c, 0xf6, 0x42, 0x27, 0xda, 0xa9, 0xb8, - 0x61, 0xdd, 0xdf, 0x23, 0xc1, 0x3e, 0x7b, 0x65, 0x8f, 0xc4, 0x4f, 0x35, 0x05, 0x58, 0xba, 0xb6, - 0x50, 0xa5, 0x98, 0x38, 0x5d, 0x07, 0x2d, 0xc0, 0xa4, 0x2c, 0xac, 0x91, 0x90, 0x1d, 0xee, 0xa3, - 0x8c, 0x8c, 0x72, 0xbf, 0x11, 0xc5, 0x8a, 0x48, 0x12, 0xdf, 0x64, 0x5d, 0xe1, 0x38, 0x58, 0xd7, - 0x0f, 0xc3, 0xb8, 0xeb, 0xb9, 0x91, 0xeb, 0x44, 0x3e, 0xd7, 0xb0, 0xf0, 0x07, 0x35, 0x13, 0x1d, - 0xaf, 0xea, 0x00, 0x6c, 0xe2, 0xd9, 0xff, 0x7e, 0x00, 0xa6, 0xd9, 0xb4, 0xbd, 0xb7, 0xc2, 0xbe, - 0x9d, 0x56, 0xd8, 0xad, 0xf4, 0x0a, 0x3b, 0x0e, 0x9e, 0xfc, 0x81, 0x97, 0xd9, 0x67, 0xa1, 0xa4, - 0x3c, 0x8e, 0xa4, 0xcb, 0xa1, 0x95, 0xe3, 0x72, 0xd8, 0xfb, 0x5e, 0x96, 0x46, 0x5b, 0xc5, 0x4c, - 0xa3, 0xad, 0xaf, 0x58, 0x10, 0xab, 0x0c, 0xd0, 0x1b, 0x50, 0x6a, 0xfb, 0xcc, 0x16, 0x31, 0x90, - 0x06, 0xbe, 0x4f, 0x76, 0xd5, 0x39, 0xf0, 0x08, 0x48, 0x01, 0x1f, 0x85, 0xaa, 0xac, 0x8a, 0x63, - 0x2a, 0xe8, 0x3a, 0x0c, 0xb7, 0x03, 0x52, 0x8b, 0x58, 0x78, 0x8e, 0xfe, 0x09, 0xf2, 0x55, 0xc3, - 0x2b, 0x62, 0x49, 0xc1, 0xfe, 0x0f, 0x16, 0x4c, 0x25, 0x51, 0xd1, 0x47, 0x60, 0x80, 0xdc, 0x23, - 0x75, 0xd1, 0xdf, 0xcc, 0x4b, 0x36, 0x16, 0x3a, 0xf0, 0x01, 0xa0, 0xff, 0x31, 0xab, 0x85, 0xae, - 0xc1, 0x30, 0xbd, 0x61, 0xaf, 0xaa, 0x50, 0x54, 0x8f, 0xe7, 0xdd, 0xd2, 0x8a, 0x55, 0xe1, 0x9d, - 0x13, 0x45, 0x58, 0x56, 0x67, 0x96, 0x52, 0xf5, 0x76, 0x8d, 0x3e, 0x5e, 0xa2, 0x6e, 0x6f, 0xec, - 0x8d, 0xa5, 0x2a, 0x47, 0x12, 0xd4, 0xb8, 0xa5, 0x94, 0x2c, 0xc4, 0x31, 0x11, 0xfb, 0xe7, 0x2d, - 0x00, 0x6e, 0x18, 0xe6, 0x78, 0xdb, 0xe4, 0x04, 0xe4, 0xe4, 0x15, 0x18, 0x08, 0xdb, 0xa4, 0xde, - 0xcd, 0x4c, 0x36, 0xee, 0x4f, 0xad, 0x4d, 0xea, 0xf1, 0x8a, 0xa3, 0xff, 0x30, 0xab, 0x6d, 0x7f, - 0x3f, 0xc0, 0x44, 0x8c, 0xb6, 0x1a, 0x91, 0x16, 0x7a, 0xce, 0x08, 0x53, 0x70, 0x36, 0x11, 0xa6, - 0xa0, 0xc4, 0xb0, 0x35, 0x91, 0xec, 0x67, 0xa1, 0xd8, 0x72, 0xee, 0x09, 0x99, 0xdb, 0x33, 0xdd, - 0xbb, 0x41, 0xe9, 0xcf, 0xaf, 0x39, 0xf7, 0xf8, 0xb3, 0xf4, 0x19, 0xb9, 0x43, 0xd6, 0x9c, 0x7b, - 0x87, 0xdc, 0x18, 0x96, 0x9d, 0xd2, 0x37, 0xdc, 0x30, 0xfa, 0xfc, 0xbf, 0x8b, 0xff, 0xb3, 0x7d, - 0x47, 0x1b, 0x61, 0x6d, 0xb9, 0x9e, 0xb0, 0x79, 0xea, 0xab, 0x2d, 0xd7, 0x4b, 0xb6, 0xe5, 0x7a, - 0x7d, 0xb4, 0xe5, 0x7a, 0xe8, 0x6d, 0x18, 0x16, 0x26, 0x89, 0x22, 0x2c, 0xd0, 0xe5, 0x3e, 0xda, - 0x13, 0x16, 0x8d, 0xbc, 0xcd, 0xcb, 0xf2, 0xd9, 0x2d, 0x4a, 0x7b, 0xb6, 0x2b, 0x1b, 0x44, 0xff, - 0xbf, 0x05, 0x13, 0xe2, 0x37, 0x26, 0x6f, 0x75, 0x48, 0x18, 0x09, 0xb6, 0xf4, 0x43, 0xfd, 0xf7, - 0x41, 0x54, 0xe4, 0x5d, 0xf9, 0x90, 0xbc, 0x67, 0x4c, 0x60, 0xcf, 0x1e, 0x25, 0x7a, 0x81, 0xfe, - 0xb6, 0x05, 0xa7, 0x5a, 0xce, 0x3d, 0xde, 0x22, 0x2f, 0xc3, 0x4e, 0xe4, 0xfa, 0x42, 0xb5, 0xff, - 0x91, 0xfe, 0xa6, 0x3f, 0x55, 0x9d, 0x77, 0x52, 0xea, 0x1f, 0x4f, 0x65, 0xa1, 0xf4, 0xec, 0x6a, - 0x66, 0xbf, 0xe6, 0xb6, 0x60, 0x44, 0xae, 0xb7, 0x0c, 0xe1, 0x46, 0x45, 0xe7, 0xb9, 0x8f, 0x6c, - 0x11, 0xaa, 0xbb, 0xff, 0xd3, 0x76, 0xc4, 0x5a, 0x7b, 0xa8, 0xed, 0x7c, 0x16, 0xc6, 0xf4, 0x35, - 0xf6, 0x50, 0xdb, 0x7a, 0x0b, 0x66, 0x32, 0xd6, 0xd2, 0x43, 0x6d, 0xf2, 0x2e, 0x9c, 0xcd, 0x5d, - 0x1f, 0x0f, 0xb3, 0x61, 0xfb, 0xab, 0x96, 0x7e, 0x0e, 0x9e, 0x80, 0xb2, 0x62, 0xc9, 0x54, 0x56, - 0x9c, 0xef, 0xbe, 0x73, 0x72, 0x34, 0x16, 0x6f, 0xea, 0x9d, 0xa6, 0xa7, 0x3a, 0x7a, 0x1d, 0x86, - 0x9a, 0xb4, 0x44, 0x1a, 0xb6, 0xda, 0xbd, 0x77, 0x64, 0xcc, 0x4c, 0xb2, 0xf2, 0x10, 0x0b, 0x0a, - 0xf6, 0x2f, 0x59, 0x30, 0x70, 0x02, 0x23, 0x81, 0xcd, 0x91, 0x78, 0x2e, 0x97, 0xb4, 0x88, 0x90, - 0x3c, 0x8f, 0x9d, 0xbb, 0xcb, 0xf7, 0x22, 0xe2, 0x85, 0xec, 0x46, 0xce, 0x1c, 0x98, 0x9f, 0xb6, - 0x60, 0xe6, 0x86, 0xef, 0x34, 0x16, 0x9d, 0xa6, 0xe3, 0xd5, 0x49, 0xb0, 0xea, 0x6d, 0x1f, 0xc9, - 0x2a, 0xbb, 0xd0, 0xd3, 0x2a, 0x7b, 0x49, 0x1a, 0x35, 0x0d, 0xe4, 0xcf, 0x1f, 0xe5, 0xa4, 0x93, - 0x81, 0x5b, 0x0c, 0xf3, 0xdb, 0x1d, 0x40, 0x7a, 0x2f, 0x85, 0x8f, 0x0c, 0x86, 0x61, 0x97, 0xf7, - 0x57, 0x4c, 0xe2, 0x53, 0xd9, 0x1c, 0x6e, 0xea, 0xf3, 0x34, 0xef, 0x0f, 0x5e, 0x80, 0x25, 0x21, - 0xfb, 0x65, 0xc8, 0x74, 0xb4, 0xef, 0x2d, 0x97, 0xb0, 0x3f, 0x01, 0xd3, 0xac, 0xe6, 0x11, 0x25, - 0x03, 0x76, 0x42, 0x9a, 0x9a, 0x11, 0x82, 0xcf, 0xfe, 0x82, 0x05, 0x93, 0xeb, 0x89, 0xc8, 0x64, - 0x17, 0x99, 0xfe, 0x35, 0x43, 0x88, 0x5f, 0x63, 0xa5, 0x58, 0x40, 0x8f, 0x5d, 0xc8, 0xf5, 0x17, - 0x16, 0xc4, 0xb1, 0x2f, 0x4e, 0x80, 0x7d, 0x5b, 0x32, 0xd8, 0xb7, 0x4c, 0x46, 0x56, 0x75, 0x27, - 0x8f, 0x7b, 0x43, 0xd7, 0x55, 0x54, 0xa8, 0x2e, 0x3c, 0x6c, 0x4c, 0x86, 0x2f, 0xc5, 0x09, 0x33, - 0x74, 0x94, 0x8c, 0x13, 0x65, 0xff, 0x4e, 0x01, 0x90, 0xc2, 0xed, 0x3b, 0x6a, 0x55, 0xba, 0xc6, - 0xf1, 0x44, 0xad, 0xda, 0x03, 0xc4, 0x2c, 0x08, 0x02, 0xc7, 0x0b, 0x39, 0x59, 0x57, 0x88, 0xf5, - 0x8e, 0x66, 0x9e, 0x30, 0x27, 0x9a, 0x44, 0x37, 0x52, 0xd4, 0x70, 0x46, 0x0b, 0x9a, 0x65, 0xc8, - 0x60, 0xbf, 0x96, 0x21, 0x43, 0x3d, 0xfc, 0xe0, 0x7e, 0xce, 0x82, 0x71, 0x35, 0x4c, 0xef, 0x12, - 0x2b, 0x75, 0xd5, 0x9f, 0x9c, 0x03, 0xb4, 0xaa, 0x75, 0x99, 0x5d, 0x2c, 0xdf, 0xc9, 0xfc, 0x19, - 0x9d, 0xa6, 0xfb, 0x36, 0x51, 0x31, 0x03, 0xcb, 0xc2, 0x3f, 0x51, 0x94, 0x1e, 0x1e, 0x94, 0xc7, - 0xd5, 0x3f, 0x1e, 0x13, 0x39, 0xae, 0x42, 0x8f, 0xe4, 0xc9, 0xc4, 0x52, 0x44, 0x2f, 0xc1, 0x60, - 0x7b, 0xc7, 0x09, 0x49, 0xc2, 0x9b, 0x67, 0xb0, 0x4a, 0x0b, 0x0f, 0x0f, 0xca, 0x13, 0xaa, 0x02, - 0x2b, 0xc1, 0x1c, 0xbb, 0xff, 0x58, 0x60, 0xe9, 0xc5, 0xd9, 0x33, 0x16, 0xd8, 0x9f, 0x5a, 0x30, - 0xb0, 0xee, 0x37, 0x4e, 0xe2, 0x08, 0x78, 0xcd, 0x38, 0x02, 0x1e, 0xcb, 0x0b, 0x57, 0x9f, 0xbb, - 0xfb, 0x57, 0x12, 0xbb, 0xff, 0x7c, 0x2e, 0x85, 0xee, 0x1b, 0xbf, 0x05, 0xa3, 0x2c, 0x08, 0xbe, - 0xf0, 0x5c, 0x7a, 0xc1, 0xd8, 0xf0, 0xe5, 0xc4, 0x86, 0x9f, 0xd4, 0x50, 0xb5, 0x9d, 0xfe, 0x34, - 0x0c, 0x0b, 0x57, 0x98, 0xa4, 0x5b, 0xa8, 0xc0, 0xc5, 0x12, 0x6e, 0xff, 0x64, 0x11, 0x8c, 0xa0, - 0xfb, 0xe8, 0x57, 0x2c, 0x98, 0x0f, 0xb8, 0x89, 0x6c, 0xa3, 0xd2, 0x09, 0x5c, 0x6f, 0xbb, 0x56, - 0xdf, 0x21, 0x8d, 0x4e, 0xd3, 0xf5, 0xb6, 0x57, 0xb7, 0x3d, 0x5f, 0x15, 0x2f, 0xdf, 0x23, 0xf5, - 0x0e, 0x53, 0xbb, 0xf5, 0x88, 0xf0, 0xaf, 0x4c, 0xcd, 0x9f, 0xbf, 0x7f, 0x50, 0x9e, 0xc7, 0x47, - 0xa2, 0x8d, 0x8f, 0xd8, 0x17, 0xf4, 0x1b, 0x16, 0x5c, 0xe6, 0xb1, 0xe8, 0xfb, 0xef, 0x7f, 0x97, - 0xd7, 0x72, 0x55, 0x92, 0x8a, 0x89, 0x6c, 0x90, 0xa0, 0xb5, 0xf8, 0x61, 0x31, 0xa0, 0x97, 0xab, - 0x47, 0x6b, 0x0b, 0x1f, 0xb5, 0x73, 0xf6, 0x3f, 0x2a, 0xc2, 0xb8, 0x88, 0x19, 0x25, 0xee, 0x80, - 0x97, 0x8c, 0x25, 0xf1, 0x78, 0x62, 0x49, 0x4c, 0x1b, 0xc8, 0xc7, 0x73, 0xfc, 0x87, 0x30, 0x4d, - 0x0f, 0xe7, 0x6b, 0xc4, 0x09, 0xa2, 0x4d, 0xe2, 0x70, 0x83, 0xaf, 0xe2, 0x91, 0x4f, 0x7f, 0x25, - 0x9f, 0xbc, 0x91, 0x24, 0x86, 0xd3, 0xf4, 0xbf, 0x9d, 0xee, 0x1c, 0x0f, 0xa6, 0x52, 0x61, 0xbf, - 0x3e, 0x09, 0x25, 0xe5, 0xc7, 0x21, 0x0e, 0x9d, 0xee, 0xd1, 0xf3, 0x92, 0x14, 0xb8, 0xf8, 0x2b, - 0xf6, 0x21, 0x8a, 0xc9, 0xd9, 0x7f, 0xa7, 0x60, 0x34, 0xc8, 0x27, 0x71, 0x1d, 0x46, 0x9c, 0x30, - 0x74, 0xb7, 0x3d, 0xd2, 0xe8, 0x26, 0xa1, 0x4c, 0x35, 0xc3, 0x7c, 0x69, 0x16, 0x44, 0x4d, 0xac, - 0x68, 0xa0, 0x6b, 0xdc, 0xac, 0x6e, 0x8f, 0x74, 0x13, 0x4f, 0xa6, 0xa8, 0x81, 0x34, 0xbc, 0xdb, - 0x23, 0x58, 0xd4, 0x47, 0x9f, 0xe2, 0x76, 0x8f, 0xd7, 0x3d, 0xff, 0xae, 0x77, 0xd5, 0xf7, 0x65, - 0x5c, 0x86, 0xfe, 0x08, 0x4e, 0x4b, 0x6b, 0x47, 0x55, 0x1d, 0x9b, 0xd4, 0xfa, 0x8b, 0xa3, 0xf9, - 0x39, 0x60, 0xb1, 0xb7, 0x4d, 0xb7, 0xe9, 0x10, 0x11, 0x98, 0x14, 0x01, 0xc9, 0x64, 0x99, 0x18, - 0xbb, 0xcc, 0xa7, 0x9c, 0x59, 0x3b, 0x16, 0xa4, 0x5f, 0x37, 0x49, 0xe0, 0x24, 0x4d, 0xfb, 0x67, - 0x2c, 0x60, 0x2e, 0xa4, 0x27, 0xc0, 0x8f, 0x7c, 0xd4, 0xe4, 0x47, 0x66, 0xf3, 0x06, 0x39, 0x87, - 0x15, 0x79, 0x91, 0xaf, 0xac, 0x6a, 0xe0, 0xdf, 0xdb, 0x17, 0xc6, 0x2a, 0xbd, 0xdf, 0x1f, 0xf6, - 0xff, 0xb0, 0xf8, 0x21, 0xa6, 0xbc, 0x2c, 0xd0, 0x77, 0xc3, 0x48, 0xdd, 0x69, 0x3b, 0x75, 0x9e, - 0x21, 0x26, 0x57, 0xa2, 0x67, 0x54, 0x9a, 0x5f, 0x12, 0x35, 0xb8, 0x84, 0x4a, 0x06, 0xb6, 0x1b, - 0x91, 0xc5, 0x3d, 0xa5, 0x52, 0xaa, 0xc9, 0xb9, 0x5d, 0x18, 0x37, 0x88, 0x3d, 0x54, 0x71, 0xc6, - 0x77, 0xf3, 0x2b, 0x56, 0x05, 0x62, 0x6c, 0xc1, 0xb4, 0xa7, 0xfd, 0xa7, 0x17, 0x8a, 0x7c, 0x5c, - 0x3e, 0xd9, 0xeb, 0x12, 0x65, 0xb7, 0x8f, 0xe6, 0x9d, 0x9a, 0x20, 0x83, 0xd3, 0x94, 0xed, 0x9f, - 0xb2, 0xe0, 0x11, 0x1d, 0x51, 0x73, 0x80, 0xe9, 0xa5, 0x24, 0xa9, 0xc0, 0x88, 0xdf, 0x26, 0x81, - 0x13, 0xf9, 0x81, 0xb8, 0x35, 0x2e, 0xc9, 0x41, 0xbf, 0x29, 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, 0x61, 0xf1, 0x85, 0xa5, 0x77, 0x1d, 0xbd, 0x05, 0x53, 0x2d, - 0x27, 0xaa, 0xef, 0x2c, 0xdf, 0x6b, 0x07, 0x5c, 0xe5, 0x24, 0xc7, 0xe9, 0x99, 0x5e, 0xe3, 0xa4, - 0x7d, 0x64, 0x6c, 0xca, 0xb9, 0x96, 0x20, 0x86, 0x53, 0xe4, 0xd1, 0x26, 0x8c, 0xb2, 0x32, 0xe6, - 0xc5, 0x17, 0x76, 0x63, 0x0d, 0xf2, 0x5a, 0x53, 0xc6, 0x08, 0x6b, 0x31, 0x1d, 0xac, 0x13, 0xb5, - 0xbf, 0x52, 0xe4, 0xbb, 0x9d, 0xb1, 0xf2, 0x4f, 0xc3, 0x70, 0xdb, 0x6f, 0x2c, 0xad, 0x56, 0xb0, - 0x98, 0x05, 0x75, 0x8d, 0x54, 0x79, 0x31, 0x96, 0x70, 0x74, 0x09, 0x46, 0xc4, 0x4f, 0xa9, 0x22, - 0x64, 0x67, 0xb3, 0xc0, 0x0b, 0xb1, 0x82, 0xa2, 0xe7, 0x01, 0xda, 0x81, 0xbf, 0xe7, 0x36, 0x58, - 0x74, 0x89, 0xa2, 0x69, 0x47, 0x54, 0x55, 0x10, 0xac, 0x61, 0xa1, 0x57, 0x61, 0xbc, 0xe3, 0x85, - 0x9c, 0x1d, 0xd1, 0x62, 0xc9, 0x2a, 0x0b, 0x97, 0x5b, 0x3a, 0x10, 0x9b, 0xb8, 0x68, 0x01, 0x86, - 0x22, 0x87, 0xd9, 0xc5, 0x0c, 0xe6, 0x9b, 0xfb, 0x6e, 0x50, 0x0c, 0x3d, 0x19, 0x09, 0xad, 0x80, - 0x45, 0x45, 0xf4, 0x49, 0xe9, 0x50, 0xcb, 0x0f, 0x76, 0x61, 0x67, 0xdf, 0xdf, 0x25, 0xa0, 0xb9, - 0xd3, 0x0a, 0xfb, 0x7d, 0x83, 0x16, 0x7a, 0x05, 0x80, 0xdc, 0x8b, 0x48, 0xe0, 0x39, 0x4d, 0x65, - 0xcd, 0xa6, 0xf8, 0x82, 0x8a, 0xbf, 0xee, 0x47, 0xb7, 0x42, 0xb2, 0xac, 0x30, 0xb0, 0x86, 0x6d, - 0xff, 0x46, 0x09, 0x20, 0xe6, 0xdb, 0xd1, 0xdb, 0xa9, 0x83, 0xeb, 0xd9, 0xee, 0x9c, 0xfe, 0xf1, - 0x9d, 0x5a, 0xe8, 0x07, 0x2c, 0x18, 0x75, 0x9a, 0x4d, 0xbf, 0xee, 0xf0, 0x68, 0xbf, 0x85, 0xee, - 0x07, 0xa7, 0x68, 0x7f, 0x21, 0xae, 0xc1, 0xbb, 0xf0, 0x82, 0x5c, 0xa1, 0x1a, 0xa4, 0x67, 0x2f, - 0xf4, 0x86, 0xd1, 0x07, 0xe5, 0x53, 0xb1, 0x68, 0x0c, 0xa5, 0x7a, 0x2a, 0x96, 0xd8, 0x1d, 0xa1, - 0xbf, 0x12, 0x6f, 0x19, 0xaf, 0xc4, 0x81, 0x7c, 0x8f, 0x41, 0x83, 0x7d, 0xed, 0xf5, 0x40, 0x44, - 0x55, 0x3d, 0x7a, 0xc0, 0x60, 0xbe, 0x7b, 0x9e, 0xf6, 0x4e, 0xea, 0x11, 0x39, 0xe0, 0xb3, 0x30, - 0xd9, 0x30, 0x99, 0x00, 0xb1, 0x12, 0x9f, 0xca, 0xa3, 0x9b, 0xe0, 0x19, 0xe2, 0x6b, 0x3f, 0x01, - 0xc0, 0x49, 0xc2, 0xa8, 0xca, 0x83, 0x49, 0xac, 0x7a, 0x5b, 0xbe, 0xf0, 0xf5, 0xb0, 0x73, 0xe7, - 0x72, 0x3f, 0x8c, 0x48, 0x8b, 0x62, 0xc6, 0xb7, 0xfb, 0xba, 0xa8, 0x8b, 0x15, 0x15, 0xf4, 0x3a, - 0x0c, 0x31, 0xff, 0xac, 0x70, 0x76, 0x24, 0x5f, 0xe2, 0x6c, 0x46, 0x47, 0x8b, 0x37, 0x24, 0xfb, - 0x1b, 0x62, 0x41, 0x01, 0x5d, 0x93, 0xde, 0x8f, 0xe1, 0xaa, 0x77, 0x2b, 0x24, 0xcc, 0xfb, 0xb1, - 0xb4, 0xf8, 0x64, 0xec, 0xd8, 0xc8, 0xcb, 0x33, 0x53, 0x96, 0x19, 0x35, 0x29, 0x17, 0x25, 0xfe, - 0xcb, 0x4c, 0x68, 0xb3, 0x90, 0xdf, 0x3d, 0x33, 0x5b, 0x5a, 0x3c, 0x9c, 0xb7, 0x4d, 0x12, 0x38, - 0x49, 0x93, 0x72, 0xa4, 0x7c, 0xd7, 0x0b, 0x6f, 0x91, 0x5e, 0x67, 0x07, 0x7f, 0x88, 0xb3, 0xdb, - 0x88, 0x97, 0x60, 0x51, 0xff, 0x44, 0xd9, 0x83, 0x39, 0x0f, 0xa6, 0x92, 0x5b, 0xf4, 0xa1, 0xb2, - 0x23, 0x7f, 0x38, 0x00, 0x13, 0xe6, 0x92, 0x42, 0x97, 0xa1, 0x24, 0x88, 0xa8, 0x6c, 0x02, 0x6a, - 0x97, 0xac, 0x49, 0x00, 0x8e, 0x71, 0x58, 0x12, 0x09, 0x56, 0x5d, 0x33, 0x0f, 0x8e, 0x93, 0x48, - 0x28, 0x08, 0xd6, 0xb0, 0xe8, 0xc3, 0x6a, 0xd3, 0xf7, 0x23, 0x75, 0x21, 0xa9, 0x75, 0xb7, 0xc8, - 0x4a, 0xb1, 0x80, 0xd2, 0x8b, 0x68, 0x97, 0x04, 0x1e, 0x69, 0x9a, 0x71, 0x87, 0xd5, 0x45, 0x74, - 0x5d, 0x07, 0x62, 0x13, 0x97, 0x5e, 0xa7, 0x7e, 0xc8, 0x16, 0xb2, 0x78, 0xbe, 0xc5, 0xe6, 0xd6, - 0x35, 0xee, 0x80, 0x2d, 0xe1, 0xe8, 0x13, 0xf0, 0x88, 0x8a, 0xad, 0x84, 0xb9, 0x36, 0x43, 0xb6, - 0x38, 0x64, 0x48, 0x5b, 0x1e, 0x59, 0xca, 0x46, 0xc3, 0x79, 0xf5, 0xd1, 0x6b, 0x30, 0x21, 0x58, - 0x7c, 0x49, 0x71, 0xd8, 0xb4, 0x30, 0xba, 0x6e, 0x40, 0x71, 0x02, 0x5b, 0x46, 0x4e, 0x66, 0x5c, - 0xb6, 0xa4, 0x30, 0x92, 0x8e, 0x9c, 0xac, 0xc3, 0x71, 0xaa, 0x06, 0x5a, 0x80, 0x49, 0xce, 0x83, - 0xb9, 0xde, 0x36, 0x9f, 0x13, 0xe1, 0xcc, 0xa5, 0xb6, 0xd4, 0x4d, 0x13, 0x8c, 0x93, 0xf8, 0xe8, - 0x65, 0x18, 0x73, 0x82, 0xfa, 0x8e, 0x1b, 0x91, 0x7a, 0xd4, 0x09, 0xb8, 0x97, 0x97, 0x66, 0xa2, - 0xb5, 0xa0, 0xc1, 0xb0, 0x81, 0x69, 0xbf, 0x0d, 0x33, 0x19, 0x91, 0x19, 0xe8, 0xc2, 0x71, 0xda, - 0xae, 0xfc, 0xa6, 0x84, 0x85, 0xf3, 0x42, 0x75, 0x55, 0x7e, 0x8d, 0x86, 0x45, 0x57, 0x27, 0x8b, - 0xe0, 0xa0, 0x25, 0x3e, 0x54, 0xab, 0x73, 0x45, 0x02, 0x70, 0x8c, 0x63, 0xff, 0xe7, 0x02, 0x4c, - 0x66, 0xe8, 0x56, 0x58, 0xf2, 0xbd, 0xc4, 0x23, 0x25, 0xce, 0xb5, 0x67, 0x06, 0xe2, 0x2e, 0x1c, - 0x21, 0x10, 0x77, 0xb1, 0x57, 0x20, 0xee, 0x81, 0x77, 0x12, 0x88, 0xdb, 0x1c, 0xb1, 0xc1, 0xbe, - 0x46, 0x2c, 0x23, 0x78, 0xf7, 0xd0, 0x11, 0x83, 0x77, 0x1b, 0x83, 0x3e, 0xdc, 0xc7, 0xa0, 0xff, - 0x58, 0x01, 0xa6, 0x92, 0xa6, 0xa4, 0x27, 0x20, 0xb7, 0x7d, 0xdd, 0x90, 0xdb, 0x5e, 0xea, 0xc7, - 0xf9, 0x36, 0x57, 0x86, 0x8b, 0x13, 0x32, 0xdc, 0x0f, 0xf4, 0x45, 0xad, 0xbb, 0x3c, 0xf7, 0xaf, - 0x16, 0xe0, 0x74, 0xa6, 0xf7, 0xef, 0x09, 0x8c, 0xcd, 0x4d, 0x63, 0x6c, 0x9e, 0xeb, 0xdb, 0x31, - 0x39, 0x77, 0x80, 0xee, 0x24, 0x06, 0xe8, 0x72, 0xff, 0x24, 0xbb, 0x8f, 0xd2, 0xd7, 0x8b, 0x70, - 0x3e, 0xb3, 0x5e, 0x2c, 0xf6, 0x5c, 0x31, 0xc4, 0x9e, 0xcf, 0x27, 0xc4, 0x9e, 0x76, 0xf7, 0xda, - 0xc7, 0x23, 0x07, 0x15, 0x0e, 0xba, 0x2c, 0xcc, 0xc0, 0x03, 0xca, 0x40, 0x0d, 0x07, 0x5d, 0x45, - 0x08, 0x9b, 0x74, 0xbf, 0x9d, 0x64, 0x9f, 0xff, 0xd2, 0x82, 0xb3, 0x99, 0x73, 0x73, 0x02, 0xb2, - 0xae, 0x75, 0x53, 0xd6, 0xf5, 0x74, 0xdf, 0xab, 0x35, 0x47, 0xf8, 0xf5, 0x95, 0xc1, 0x9c, 0x6f, - 0x61, 0x2f, 0xf9, 0x9b, 0x30, 0xea, 0xd4, 0xeb, 0x24, 0x0c, 0xd7, 0xfc, 0x86, 0x8a, 0x35, 0xfc, - 0x1c, 0x7b, 0x67, 0xc5, 0xc5, 0x87, 0x07, 0xe5, 0xb9, 0x24, 0x89, 0x18, 0x8c, 0x75, 0x0a, 0xe8, - 0x53, 0x30, 0x12, 0x8a, 0x7b, 0x53, 0xcc, 0xfd, 0x0b, 0x7d, 0x0e, 0x8e, 0xb3, 0x49, 0x9a, 0x66, - 0x30, 0x24, 0x25, 0xa9, 0x50, 0x24, 0xcd, 0xc0, 0x29, 0x85, 0x63, 0x0d, 0x9c, 0xf2, 0x3c, 0xc0, - 0x9e, 0x7a, 0x0c, 0x24, 0xe5, 0x0f, 0xda, 0x33, 0x41, 0xc3, 0x42, 0x1f, 0x83, 0xa9, 0x90, 0x47, - 0x0b, 0x5c, 0x6a, 0x3a, 0x21, 0xf3, 0xa3, 0x11, 0xab, 0x90, 0x05, 0x5c, 0xaa, 0x25, 0x60, 0x38, - 0x85, 0x8d, 0x56, 0x64, 0xab, 0x2c, 0xb4, 0x21, 0x5f, 0x98, 0x17, 0xe3, 0x16, 0x45, 0xea, 0xdf, - 0x53, 0xc9, 0xe1, 0x67, 0x03, 0xaf, 0xd5, 0x44, 0x9f, 0x02, 0xa0, 0xcb, 0x47, 0xc8, 0x21, 0x86, - 0xf3, 0x0f, 0x4f, 0x7a, 0xaa, 0x34, 0x32, 0x8d, 0x9b, 0x99, 0x4f, 0x6d, 0x45, 0x11, 0xc1, 0x1a, - 0x41, 0xb4, 0x05, 0xe3, 0xf1, 0xbf, 0x38, 0x33, 0xe6, 0x11, 0x5b, 0x60, 0x72, 0xef, 0x8a, 0x4e, - 0x07, 0x9b, 0x64, 0xed, 0x9f, 0x18, 0x86, 0x47, 0xbb, 0x9c, 0xc5, 0x68, 0xc1, 0xd4, 0xf7, 0x3e, - 0x93, 0x7c, 0xc4, 0xcf, 0x65, 0x56, 0x36, 0x5e, 0xf5, 0x89, 0x25, 0x5f, 0x78, 0xc7, 0x4b, 0xfe, - 0x47, 0x2c, 0x4d, 0xbc, 0xc2, 0x2d, 0x4b, 0x3f, 0x7a, 0xc4, 0x3b, 0xe6, 0x18, 0xe5, 0x2d, 0x5b, - 0x19, 0x42, 0x8b, 0xe7, 0xfb, 0xee, 0x4e, 0xff, 0x52, 0x8c, 0xaf, 0x5a, 0x80, 0x84, 0x78, 0x85, - 0x34, 0xd4, 0x86, 0x12, 0xf2, 0x8c, 0xab, 0x47, 0xfd, 0xfe, 0x85, 0x14, 0x25, 0x3e, 0x12, 0xaf, - 0xc8, 0xcb, 0x20, 0x8d, 0xd0, 0x73, 0x4c, 0x32, 0xba, 0x87, 0x3e, 0xc1, 0xa2, 0xe9, 0xba, 0x6f, - 0x0b, 0x0e, 0x48, 0x6c, 0xb8, 0x97, 0x44, 0x24, 0x5d, 0x55, 0x4e, 0x59, 0xdd, 0xcc, 0xee, 0xea, - 0x48, 0xd8, 0x20, 0x75, 0xb2, 0xef, 0xef, 0x0e, 0x3c, 0x92, 0x33, 0x64, 0x0f, 0xf5, 0x19, 0xfe, - 0xdb, 0x16, 0x9c, 0xeb, 0x1a, 0x16, 0xe6, 0x5b, 0x90, 0x41, 0xb4, 0x3f, 0x6f, 0x41, 0xf6, 0x64, - 0x1b, 0x66, 0x65, 0x97, 0xa1, 0x54, 0xa7, 0x85, 0x9a, 0x1f, 0x70, 0x1c, 0x20, 0x41, 0x02, 0x70, - 0x8c, 0x63, 0x58, 0x8f, 0x15, 0x7a, 0x5a, 0x8f, 0xfd, 0xaa, 0x05, 0xa9, 0x43, 0xfe, 0x04, 0xb8, - 0x8d, 0x55, 0x93, 0xdb, 0x78, 0xb2, 0x9f, 0xd1, 0xcc, 0x61, 0x34, 0xfe, 0x64, 0x12, 0xce, 0xe4, - 0xb8, 0xe5, 0xed, 0xc1, 0xf4, 0x76, 0x9d, 0x98, 0x1e, 0xd6, 0xdd, 0x22, 0x0f, 0x75, 0x75, 0xc7, - 0x66, 0xc9, 0x61, 0xa7, 0x53, 0x28, 0x38, 0xdd, 0x04, 0xfa, 0xbc, 0x05, 0xa7, 0x9c, 0xbb, 0xe1, - 0x32, 0xe5, 0x1a, 0xdd, 0xfa, 0x62, 0xd3, 0xaf, 0xef, 0xd2, 0x2b, 0x59, 0x6e, 0x84, 0x17, 0x33, - 0x25, 0x79, 0x77, 0x6a, 0x29, 0x7c, 0xa3, 0x79, 0x96, 0x2d, 0x37, 0x0b, 0x0b, 0x67, 0xb6, 0x85, - 0xb0, 0x48, 0xa1, 0x40, 0xdf, 0xa4, 0x5d, 0x62, 0x00, 0x64, 0xf9, 0x4f, 0x72, 0x36, 0x48, 0x42, - 0xb0, 0xa2, 0x83, 0x3e, 0x03, 0xa5, 0x6d, 0xe9, 0xee, 0x9b, 0xc1, 0x66, 0xc5, 0x03, 0xd9, 0xdd, - 0x09, 0x9a, 0xab, 0xe3, 0x15, 0x12, 0x8e, 0x89, 0xa2, 0xd7, 0xa0, 0xe8, 0x6d, 0x85, 0xdd, 0x12, - 0xce, 0x26, 0xec, 0x2e, 0x79, 0xa4, 0x8d, 0xf5, 0x95, 0x1a, 0xa6, 0x15, 0xd1, 0x35, 0x28, 0x06, - 0x9b, 0x0d, 0x21, 0x86, 0xce, 0xdc, 0xa4, 0x78, 0xb1, 0x92, 0xd3, 0x2b, 0x46, 0x09, 0x2f, 0x56, - 0x30, 0x25, 0x81, 0xaa, 0x30, 0xc8, 0x7c, 0xd9, 0x04, 0x53, 0x93, 0xf9, 0x7c, 0xeb, 0xe2, 0x13, - 0xca, 0xc3, 0x71, 0x30, 0x04, 0xcc, 0x09, 0xa1, 0x0d, 0x18, 0xaa, 0xb3, 0xe4, 0xa4, 0x82, 0x8b, - 0xf9, 0x60, 0xa6, 0xc0, 0xb9, 0x4b, 0xd6, 0x56, 0x21, 0x7f, 0x65, 0x18, 0x58, 0xd0, 0x62, 0x54, - 0x49, 0x7b, 0x67, 0x2b, 0x14, 0xc9, 0xbb, 0xb3, 0xa9, 0x76, 0x49, 0x46, 0x2c, 0xa8, 0x32, 0x0c, - 0x2c, 0x68, 0xa1, 0x57, 0xa0, 0xb0, 0x55, 0x17, 0x7e, 0x6a, 0x99, 0x92, 0x67, 0x33, 0x58, 0xca, - 0xe2, 0xd0, 0xfd, 0x83, 0x72, 0x61, 0x65, 0x09, 0x17, 0xb6, 0xea, 0x68, 0x1d, 0x86, 0xb7, 0x78, - 0x78, 0x05, 0x21, 0x5c, 0x7e, 0x2a, 0x3b, 0xf2, 0x43, 0x2a, 0x02, 0x03, 0xf7, 0x79, 0x12, 0x00, - 0x2c, 0x89, 0xb0, 0x8c, 0x04, 0x2a, 0x4c, 0x84, 0x88, 0x52, 0x37, 0x7f, 0xb4, 0xd0, 0x1e, 0x9c, - 0xc9, 0x8c, 0x83, 0x4d, 0x60, 0x8d, 0x22, 0x5d, 0xd5, 0xce, 0xdb, 0x9d, 0x80, 0x85, 0x02, 0x17, - 0xe1, 0x8c, 0x32, 0x57, 0xf5, 0x82, 0x44, 0xea, 0xb6, 0xaa, 0x15, 0x12, 0x8e, 0x89, 0xa2, 0x5d, - 0x18, 0xdf, 0x0b, 0xdb, 0x3b, 0x44, 0x6e, 0x69, 0x16, 0xdd, 0x28, 0x87, 0x3f, 0xba, 0x2d, 0x10, - 0xdd, 0x20, 0xea, 0x38, 0xcd, 0xd4, 0x29, 0xc4, 0x78, 0xd9, 0xdb, 0x3a, 0x31, 0x6c, 0xd2, 0xa6, - 0xc3, 0xff, 0x56, 0xc7, 0xdf, 0xdc, 0x8f, 0x88, 0x08, 0x2e, 0x97, 0x39, 0xfc, 0x6f, 0x70, 0x94, - 0xf4, 0xf0, 0x0b, 0x00, 0x96, 0x44, 0xd0, 0x6d, 0x31, 0x3c, 0xec, 0xf4, 0x9c, 0xca, 0x8f, 0x00, - 0xbb, 0x20, 0x91, 0x72, 0x06, 0x85, 0x9d, 0x96, 0x31, 0x29, 0x76, 0x4a, 0xb6, 0x77, 0xfc, 0xc8, - 0xf7, 0x12, 0x27, 0xf4, 0x74, 0xfe, 0x29, 0x59, 0xcd, 0xc0, 0x4f, 0x9f, 0x92, 0x59, 0x58, 0x38, - 0xb3, 0x2d, 0xd4, 0x80, 0x89, 0xb6, 0x1f, 0x44, 0x77, 0xfd, 0x40, 0xae, 0x2f, 0xd4, 0x45, 0x38, - 0x66, 0x60, 0x8a, 0x16, 0x59, 0xdc, 0x46, 0x13, 0x82, 0x13, 0x34, 0xd1, 0xc7, 0x61, 0x38, 0xac, - 0x3b, 0x4d, 0xb2, 0x7a, 0x73, 0x76, 0x26, 0xff, 0xfa, 0xa9, 0x71, 0x94, 0x9c, 0xd5, 0xc5, 0xa3, - 0x63, 0x70, 0x14, 0x2c, 0xc9, 0xa1, 0x15, 0x18, 0x64, 0x19, 0xe7, 0x58, 0x24, 0xc4, 0x9c, 0x40, - 0xb6, 0x29, 0x2b, 0x78, 0x7e, 0x36, 0xb1, 0x62, 0xcc, 0xab, 0xd3, 0x3d, 0x20, 0xde, 0x88, 0x7e, - 0x38, 0x7b, 0x3a, 0x7f, 0x0f, 0x88, 0xa7, 0xe5, 0xcd, 0x5a, 0xb7, 0x3d, 0xa0, 0x90, 0x70, 0x4c, - 0x94, 0x9e, 0xcc, 0xf4, 0x34, 0x3d, 0xd3, 0xc5, 0x7c, 0x2b, 0xf7, 0x2c, 0x65, 0x27, 0x33, 0x3d, - 0x49, 0x29, 0x09, 0xfb, 0xf7, 0x87, 0xd3, 0x3c, 0x0b, 0x93, 0x2a, 0x7c, 0x9f, 0x95, 0x52, 0x38, - 0x7f, 0xa8, 0x5f, 0x21, 0xe7, 0x31, 0x3e, 0x85, 0x3e, 0x6f, 0xc1, 0x99, 0x76, 0xe6, 0x87, 0x08, - 0x06, 0xa0, 0x3f, 0x59, 0x29, 0xff, 0x74, 0x15, 0x35, 0x33, 0x1b, 0x8e, 0x73, 0x5a, 0x4a, 0x3e, - 0x37, 0x8b, 0xef, 0xf8, 0xb9, 0xb9, 0x06, 0x23, 0x75, 0xfe, 0x14, 0xe9, 0x9a, 0xac, 0x3b, 0xf9, - 0xf6, 0x66, 0xac, 0x84, 0x78, 0xc3, 0x6c, 0x61, 0x45, 0x02, 0xfd, 0xa8, 0x05, 0xe7, 0x92, 0x5d, - 0xc7, 0x84, 0x81, 0x45, 0xa8, 0x4d, 0x2e, 0xd0, 0x58, 0x11, 0xdf, 0x9f, 0xe2, 0xff, 0x0d, 0xe4, - 0xc3, 0x5e, 0x08, 0xb8, 0x7b, 0x63, 0xa8, 0x92, 0x21, 0x51, 0x19, 0x32, 0xb5, 0x48, 0x7d, 0x48, - 0x55, 0x5e, 0x84, 0xb1, 0x96, 0xdf, 0xf1, 0x22, 0x61, 0xed, 0x25, 0x2c, 0x4f, 0x98, 0xc5, 0xc5, - 0x9a, 0x56, 0x8e, 0x0d, 0xac, 0x84, 0x2c, 0x66, 0xe4, 0x81, 0x65, 0x31, 0x6f, 0xc2, 0x98, 0xa7, - 0x99, 0x27, 0x0b, 0x7e, 0xe0, 0x62, 0x7e, 0x98, 0x5c, 0xdd, 0x98, 0x99, 0xf7, 0x52, 0x2f, 0xc1, - 0x06, 0xb5, 0x93, 0x35, 0x03, 0xfb, 0xb2, 0x95, 0xc1, 0xd4, 0x73, 0x51, 0xcc, 0x47, 0x4c, 0x51, - 0xcc, 0xc5, 0xa4, 0x28, 0x26, 0xa5, 0x41, 0x30, 0xa4, 0x30, 0xfd, 0x67, 0x01, 0xea, 0x37, 0xd4, - 0xa6, 0xdd, 0x84, 0x0b, 0xbd, 0xae, 0x25, 0x66, 0xf6, 0xd7, 0x50, 0xfa, 0xe2, 0xd8, 0xec, 0xaf, - 0xb1, 0x5a, 0xc1, 0x0c, 0xd2, 0x6f, 0x10, 0x27, 0xfb, 0x3f, 0x5a, 0x50, 0xac, 0xfa, 0x8d, 0x13, - 0x78, 0xf0, 0x7e, 0xd4, 0x78, 0xf0, 0x3e, 0x9a, 0x7d, 0x21, 0x36, 0x72, 0xf5, 0x1f, 0xcb, 0x09, - 0xfd, 0xc7, 0xb9, 0x3c, 0x02, 0xdd, 0xb5, 0x1d, 0x3f, 0x5d, 0x84, 0xd1, 0xaa, 0xdf, 0x50, 0x36, - 0xf7, 0xff, 0xe4, 0x41, 0x6c, 0xee, 0x73, 0x73, 0x59, 0x68, 0x94, 0x99, 0xb5, 0xa0, 0x74, 0x37, - 0xfe, 0x16, 0x33, 0xbd, 0xbf, 0x43, 0xdc, 0xed, 0x9d, 0x88, 0x34, 0x92, 0x9f, 0x73, 0x72, 0xa6, - 0xf7, 0xbf, 0x5f, 0x80, 0xc9, 0x44, 0xeb, 0xa8, 0x09, 0xe3, 0x4d, 0x5d, 0xba, 0x2e, 0xd6, 0xe9, - 0x03, 0x09, 0xe6, 0x85, 0xe9, 0xb2, 0x56, 0x84, 0x4d, 0xe2, 0x68, 0x1e, 0x40, 0xa9, 0x9b, 0xa5, - 0x78, 0x95, 0x71, 0xfd, 0x4a, 0x1f, 0x1d, 0x62, 0x0d, 0x03, 0xbd, 0x04, 0xa3, 0x91, 0xdf, 0xf6, - 0x9b, 0xfe, 0xf6, 0xfe, 0x75, 0x22, 0xe3, 0x7b, 0x29, 0x83, 0xc4, 0x8d, 0x18, 0x84, 0x75, 0x3c, - 0x74, 0x0f, 0xa6, 0x15, 0x91, 0xda, 0x31, 0x68, 0x1c, 0x98, 0x54, 0x61, 0x3d, 0x49, 0x11, 0xa7, - 0x1b, 0xb1, 0x7f, 0xb6, 0xc8, 0x87, 0xd8, 0x8b, 0xdc, 0xf7, 0x76, 0xc3, 0xbb, 0x7b, 0x37, 0x7c, - 0xdd, 0x82, 0x29, 0xda, 0x3a, 0xb3, 0xb6, 0x92, 0xd7, 0xbc, 0x0a, 0xcc, 0x6d, 0x75, 0x09, 0xcc, - 0x7d, 0x91, 0x9e, 0x9a, 0x0d, 0xbf, 0x13, 0x09, 0xd9, 0x9d, 0x76, 0x2c, 0xd2, 0x52, 0x2c, 0xa0, - 0x02, 0x8f, 0x04, 0x81, 0xf0, 0x10, 0xd5, 0xf1, 0x48, 0x10, 0x60, 0x01, 0x95, 0x71, 0xbb, 0x07, - 0xb2, 0xe3, 0x76, 0xf3, 0xf0, 0xab, 0xc2, 0x2e, 0x47, 0x30, 0x5c, 0x5a, 0xf8, 0x55, 0x69, 0xb0, - 0x13, 0xe3, 0xd8, 0x5f, 0x2d, 0xc2, 0x58, 0xd5, 0x6f, 0xc4, 0xaa, 0xe6, 0x17, 0x0d, 0x55, 0xf3, - 0x85, 0x84, 0xaa, 0x79, 0x4a, 0xc7, 0x7d, 0x4f, 0xb1, 0xfc, 0xcd, 0x52, 0x2c, 0xff, 0x43, 0x8b, - 0xcd, 0x5a, 0x65, 0xbd, 0xc6, 0x8d, 0xf7, 0xd0, 0x15, 0x18, 0x65, 0x07, 0x0c, 0x73, 0x49, 0x96, - 0xfa, 0x57, 0x96, 0x8f, 0x6a, 0x3d, 0x2e, 0xc6, 0x3a, 0x0e, 0xba, 0x04, 0x23, 0x21, 0x71, 0x82, - 0xfa, 0x8e, 0x3a, 0x5d, 0x85, 0xb2, 0x94, 0x97, 0x61, 0x05, 0x45, 0x6f, 0xc4, 0x91, 0x3f, 0x8b, - 0xf9, 0x2e, 0x8e, 0x7a, 0x7f, 0xf8, 0x16, 0xc9, 0x0f, 0xf7, 0x69, 0xdf, 0x01, 0x94, 0xc6, 0xef, - 0x23, 0x36, 0x5d, 0xd9, 0x8c, 0x4d, 0x57, 0x4a, 0xc5, 0xa5, 0xfb, 0x73, 0x0b, 0x26, 0xaa, 0x7e, - 0x83, 0x6e, 0xdd, 0x6f, 0xa7, 0x7d, 0xaa, 0x87, 0x3d, 0x1e, 0xea, 0x12, 0xf6, 0xf8, 0x09, 0x18, - 0xac, 0xfa, 0x8d, 0xd5, 0x6a, 0xb7, 0xf8, 0x02, 0xf6, 0x5f, 0xb3, 0x60, 0xb8, 0xea, 0x37, 0x4e, - 0x40, 0x2d, 0xf0, 0x11, 0x53, 0x2d, 0xf0, 0x48, 0xce, 0xba, 0xc9, 0xd1, 0x04, 0xfc, 0x95, 0x01, - 0x18, 0xa7, 0xfd, 0xf4, 0xb7, 0xe5, 0x54, 0x1a, 0xc3, 0x66, 0xf5, 0x31, 0x6c, 0x94, 0x0b, 0xf7, - 0x9b, 0x4d, 0xff, 0x6e, 0x72, 0x5a, 0x57, 0x58, 0x29, 0x16, 0x50, 0xf4, 0x2c, 0x8c, 0xb4, 0x03, - 0xb2, 0xe7, 0xfa, 0x82, 0xbd, 0xd5, 0x94, 0x2c, 0x55, 0x51, 0x8e, 0x15, 0x06, 0x7d, 0x16, 0x86, - 0xae, 0x47, 0xaf, 0xf2, 0xba, 0xef, 0x35, 0xb8, 0xe4, 0xbc, 0x28, 0x72, 0x73, 0x68, 0xe5, 0xd8, - 0xc0, 0x42, 0x77, 0xa0, 0xc4, 0xfe, 0xb3, 0x63, 0xe7, 0xe8, 0x59, 0x5e, 0x45, 0xd6, 0x3f, 0x41, - 0x00, 0xc7, 0xb4, 0xd0, 0xf3, 0x00, 0x91, 0x8c, 0x6f, 0x1f, 0x8a, 0x68, 0x6b, 0xea, 0x29, 0xa0, - 0x22, 0xdf, 0x87, 0x58, 0xc3, 0x42, 0xcf, 0x40, 0x29, 0x72, 0xdc, 0xe6, 0x0d, 0xd7, 0x23, 0x21, - 0x93, 0x88, 0x17, 0x65, 0xf2, 0x3d, 0x51, 0x88, 0x63, 0x38, 0x65, 0xc5, 0x58, 0x24, 0x0e, 0x9e, - 0x23, 0x7a, 0x84, 0x61, 0x33, 0x56, 0xec, 0x86, 0x2a, 0xc5, 0x1a, 0x06, 0xda, 0x81, 0xc7, 0x5c, - 0x8f, 0xe5, 0xb1, 0x20, 0xb5, 0x5d, 0xb7, 0xbd, 0x71, 0xa3, 0x76, 0x9b, 0x04, 0xee, 0xd6, 0xfe, - 0xa2, 0x53, 0xdf, 0x25, 0x9e, 0xcc, 0xdf, 0xf9, 0xa4, 0xe8, 0xe2, 0x63, 0xab, 0x5d, 0x70, 0x71, - 0x57, 0x4a, 0xf6, 0x0b, 0x6c, 0xbd, 0xdf, 0xac, 0xa1, 0x0f, 0x18, 0x47, 0xc7, 0x19, 0xfd, 0xe8, - 0x38, 0x3c, 0x28, 0x0f, 0xdd, 0xac, 0x69, 0x81, 0x24, 0x5e, 0x86, 0xd3, 0x55, 0xbf, 0x51, 0xf5, - 0x83, 0x68, 0xc5, 0x0f, 0xee, 0x3a, 0x41, 0x43, 0x2e, 0xaf, 0xb2, 0x0c, 0xa5, 0x41, 0xcf, 0xcf, - 0x41, 0x7e, 0xba, 0x18, 0x61, 0x32, 0x5e, 0x60, 0x1c, 0xdb, 0x11, 0x1d, 0xc0, 0xea, 0x8c, 0x77, - 0x50, 0x99, 0x60, 0xae, 0x3a, 0x11, 0x41, 0x37, 0x59, 0x86, 0xeb, 0xf8, 0x1a, 0x15, 0xd5, 0x9f, - 0xd6, 0x32, 0x5c, 0xc7, 0xc0, 0xcc, 0x7b, 0xd7, 0xac, 0x6f, 0xff, 0xa7, 0x41, 0x76, 0xa2, 0x26, - 0xb2, 0x89, 0xa0, 0x4f, 0xc3, 0x44, 0x48, 0x6e, 0xb8, 0x5e, 0xe7, 0x9e, 0x14, 0x61, 0x74, 0x71, - 0xe1, 0xab, 0x2d, 0xeb, 0x98, 0x5c, 0x10, 0x6a, 0x96, 0xe1, 0x04, 0x35, 0xd4, 0x82, 0x89, 0xbb, - 0xae, 0xd7, 0xf0, 0xef, 0x86, 0x92, 0xfe, 0x48, 0xbe, 0x3c, 0xf4, 0x0e, 0xc7, 0x4c, 0xf4, 0xd1, - 0x68, 0xee, 0x8e, 0x41, 0x0c, 0x27, 0x88, 0xd3, 0x55, 0x1b, 0x74, 0xbc, 0x85, 0xf0, 0x56, 0x48, - 0x02, 0x91, 0xab, 0x9c, 0xad, 0x5a, 0x2c, 0x0b, 0x71, 0x0c, 0xa7, 0xab, 0x96, 0xfd, 0xb9, 0x1a, - 0xf8, 0x1d, 0x9e, 0xba, 0x42, 0xac, 0x5a, 0xac, 0x4a, 0xb1, 0x86, 0x41, 0x77, 0x35, 0xfb, 0xb7, - 0xee, 0x7b, 0xd8, 0xf7, 0x23, 0x79, 0x0e, 0x30, 0x9d, 0xbe, 0x56, 0x8e, 0x0d, 0x2c, 0xb4, 0x02, - 0x28, 0xec, 0xb4, 0xdb, 0x4d, 0x66, 0x1b, 0xe4, 0x34, 0x19, 0x29, 0x6e, 0x2f, 0x51, 0xe4, 0xa1, - 0x77, 0x6b, 0x29, 0x28, 0xce, 0xa8, 0x41, 0x0f, 0xf8, 0x2d, 0xd1, 0xd5, 0x41, 0xd6, 0x55, 0xae, - 0x3b, 0xa9, 0xf1, 0x7e, 0x4a, 0x18, 0x5a, 0x86, 0xe1, 0x70, 0x3f, 0xac, 0x47, 0x22, 0x52, 0x62, - 0x4e, 0xc2, 0xa8, 0x1a, 0x43, 0xd1, 0xf2, 0x15, 0xf2, 0x2a, 0x58, 0xd6, 0x45, 0x75, 0x98, 0x11, - 0x14, 0x97, 0x76, 0x1c, 0x4f, 0xa5, 0xdf, 0xe1, 0x26, 0xd2, 0x57, 0xee, 0x1f, 0x94, 0x67, 0x44, - 0xcb, 0x3a, 0xf8, 0xf0, 0xa0, 0x7c, 0xa6, 0xea, 0x37, 0x32, 0x20, 0x38, 0x8b, 0x1a, 0x5f, 0x7c, - 0xf5, 0xba, 0xdf, 0x6a, 0x57, 0x03, 0x7f, 0xcb, 0x6d, 0x92, 0x6e, 0xfa, 0xa7, 0x9a, 0x81, 0x29, - 0x16, 0x9f, 0x51, 0x86, 0x13, 0xd4, 0xec, 0xef, 0x66, 0x4c, 0x10, 0x4b, 0xcf, 0x1d, 0x75, 0x02, - 0x82, 0x5a, 0x30, 0xde, 0x66, 0xdb, 0x44, 0x24, 0x94, 0x10, 0x6b, 0xfd, 0xc5, 0x3e, 0xe5, 0x28, - 0x77, 0xe9, 0xdd, 0x61, 0xda, 0x18, 0x55, 0x75, 0x72, 0xd8, 0xa4, 0x6e, 0xff, 0xe6, 0x23, 0xec, - 0x1a, 0xad, 0x71, 0xe1, 0xc8, 0xb0, 0xf0, 0xc8, 0x10, 0xef, 0xb1, 0xb9, 0x7c, 0x29, 0x5d, 0x3c, - 0x2d, 0xc2, 0xab, 0x03, 0xcb, 0xba, 0xe8, 0x53, 0x30, 0x41, 0x9f, 0x37, 0xea, 0x2a, 0x0b, 0x67, - 0x4f, 0xe5, 0x47, 0xce, 0x50, 0x58, 0x7a, 0xb2, 0x19, 0xbd, 0x32, 0x4e, 0x10, 0x43, 0x6f, 0x30, - 0x9b, 0x1e, 0x49, 0xba, 0xd0, 0x0f, 0x69, 0xdd, 0x7c, 0x47, 0x92, 0xd5, 0x88, 0xa0, 0x0e, 0xcc, - 0xa4, 0x53, 0xd3, 0x85, 0xb3, 0x76, 0x3e, 0x9f, 0x98, 0xce, 0x2e, 0x17, 0x67, 0x05, 0x49, 0xc3, - 0x42, 0x9c, 0x45, 0x1f, 0xdd, 0x80, 0x71, 0x91, 0xa3, 0x5a, 0xac, 0xdc, 0xa2, 0x21, 0x3c, 0x1c, - 0xc7, 0x3a, 0xf0, 0x30, 0x59, 0x80, 0xcd, 0xca, 0x68, 0x1b, 0xce, 0x69, 0x39, 0xa3, 0xae, 0x06, - 0x0e, 0xb3, 0x00, 0x70, 0xd9, 0x71, 0xaa, 0x5d, 0xf0, 0x8f, 0xdf, 0x3f, 0x28, 0x9f, 0xdb, 0xe8, - 0x86, 0x88, 0xbb, 0xd3, 0x41, 0x37, 0xe1, 0x34, 0xf7, 0xfb, 0xae, 0x10, 0xa7, 0xd1, 0x74, 0x3d, - 0xc5, 0x41, 0xf0, 0x2d, 0x7f, 0xf6, 0xfe, 0x41, 0xf9, 0xf4, 0x42, 0x16, 0x02, 0xce, 0xae, 0x87, - 0x3e, 0x02, 0xa5, 0x86, 0x17, 0x8a, 0x31, 0x18, 0x32, 0xd2, 0x72, 0x95, 0x2a, 0xeb, 0x35, 0xf5, - 0xfd, 0xf1, 0x1f, 0x1c, 0x57, 0x40, 0xdb, 0x5c, 0xc0, 0xac, 0xc4, 0x1e, 0xc3, 0xa9, 0xb8, 0x57, - 0x49, 0xc9, 0xa0, 0xe1, 0xf9, 0xc9, 0x35, 0x2b, 0xca, 0x21, 0xc2, 0x70, 0x0a, 0x35, 0x08, 0xa3, - 0xd7, 0x01, 0x89, 0xf0, 0xef, 0x0b, 0x75, 0x96, 0xad, 0x84, 0xc9, 0xe3, 0x47, 0x4c, 0x5f, 0xc4, - 0x5a, 0x0a, 0x03, 0x67, 0xd4, 0x42, 0xd7, 0xe8, 0xa9, 0xa2, 0x97, 0x8a, 0x53, 0x4b, 0x25, 0x51, - 0xac, 0x90, 0x76, 0x40, 0x98, 0x45, 0x93, 0x49, 0x11, 0x27, 0xea, 0xa1, 0x06, 0x3c, 0xe6, 0x74, - 0x22, 0x9f, 0xc9, 0xee, 0x4d, 0xd4, 0x0d, 0x7f, 0x97, 0x78, 0x4c, 0x6d, 0x36, 0xb2, 0x78, 0x81, - 0xb2, 0x28, 0x0b, 0x5d, 0xf0, 0x70, 0x57, 0x2a, 0x94, 0xb5, 0x54, 0x59, 0x93, 0xc1, 0x8c, 0xe6, - 0x95, 0x91, 0x39, 0xf9, 0x25, 0x18, 0xdd, 0xf1, 0xc3, 0x68, 0x9d, 0x44, 0x77, 0xfd, 0x60, 0x57, - 0x44, 0xa5, 0x8d, 0x63, 0x7c, 0xc7, 0x20, 0xac, 0xe3, 0xd1, 0xb7, 0x23, 0x33, 0xea, 0x58, 0xad, - 0x30, 0x7d, 0xfa, 0x48, 0x7c, 0xc6, 0x5c, 0xe3, 0xc5, 0x58, 0xc2, 0x25, 0xea, 0x6a, 0x75, 0x89, - 0xe9, 0xc6, 0x13, 0xa8, 0xab, 0xd5, 0x25, 0x2c, 0xe1, 0x74, 0xb9, 0x86, 0x3b, 0x4e, 0x40, 0xaa, - 0x81, 0x5f, 0x27, 0xa1, 0x16, 0x59, 0xfe, 0x51, 0x1e, 0x73, 0x97, 0x2e, 0xd7, 0x5a, 0x16, 0x02, - 0xce, 0xae, 0x87, 0x48, 0x3a, 0x5f, 0xda, 0x44, 0xbe, 0x52, 0x23, 0xcd, 0xcf, 0xf4, 0x99, 0x32, - 0xcd, 0x83, 0x29, 0x95, 0xa9, 0x8d, 0x47, 0xd9, 0x0d, 0x67, 0x27, 0xd9, 0xda, 0xee, 0x3f, 0x44, - 0xaf, 0x52, 0x13, 0xad, 0x26, 0x28, 0xe1, 0x14, 0x6d, 0x23, 0x60, 0xdb, 0x54, 0xcf, 0x80, 0x6d, - 0x97, 0xa1, 0x14, 0x76, 0x36, 0x1b, 0x7e, 0xcb, 0x71, 0x3d, 0xa6, 0x1b, 0xd7, 0x1e, 0x31, 0x35, - 0x09, 0xc0, 0x31, 0x0e, 0x5a, 0x81, 0x11, 0x47, 0xea, 0x80, 0x50, 0x7e, 0x88, 0x1e, 0xa5, 0xf9, - 0xe1, 0x51, 0x2b, 0xa4, 0xd6, 0x47, 0xd5, 0x45, 0xaf, 0xc2, 0xb8, 0xf0, 0x5b, 0x16, 0x49, 0x42, - 0x67, 0x4c, 0xe7, 0xb2, 0x9a, 0x0e, 0xc4, 0x26, 0x2e, 0xba, 0x05, 0xa3, 0x91, 0xdf, 0x64, 0x1e, - 0x52, 0x94, 0xcd, 0x3b, 0x93, 0x1f, 0x6c, 0x6e, 0x43, 0xa1, 0xe9, 0xe2, 0x57, 0x55, 0x15, 0xeb, - 0x74, 0xd0, 0x06, 0x5f, 0xef, 0x2c, 0x8e, 0x3c, 0x09, 0x67, 0x1f, 0xc9, 0xbf, 0x93, 0x54, 0xb8, - 0x79, 0x73, 0x3b, 0x88, 0x9a, 0x58, 0x27, 0x83, 0xae, 0xc2, 0x74, 0x3b, 0x70, 0x7d, 0xb6, 0x26, - 0x94, 0xfa, 0x6f, 0xd6, 0xcc, 0x1a, 0x55, 0x4d, 0x22, 0xe0, 0x74, 0x1d, 0xe6, 0x76, 0x2e, 0x0a, - 0x67, 0xcf, 0xf2, 0xcc, 0x17, 0xfc, 0x4d, 0xc8, 0xcb, 0xb0, 0x82, 0xa2, 0x35, 0x76, 0x12, 0x73, - 0x71, 0xc6, 0xec, 0x5c, 0x7e, 0x54, 0x20, 0x5d, 0xec, 0xc1, 0x99, 0x57, 0xf5, 0x17, 0xc7, 0x14, - 0x50, 0x43, 0x4b, 0x38, 0x49, 0x5f, 0x0c, 0xe1, 0xec, 0x63, 0x5d, 0x2c, 0xeb, 0x12, 0xcf, 0x8b, - 0x98, 0x21, 0x30, 0x8a, 0x43, 0x9c, 0xa0, 0x89, 0x3e, 0x06, 0x53, 0x22, 0x96, 0x61, 0x3c, 0x4c, - 0xe7, 0x62, 0xbb, 0x73, 0x9c, 0x80, 0xe1, 0x14, 0x36, 0xcf, 0x3c, 0xe1, 0x6c, 0x36, 0x89, 0x38, - 0xfa, 0x6e, 0xb8, 0xde, 0x6e, 0x38, 0x7b, 0x9e, 0x9d, 0x0f, 0x22, 0xf3, 0x44, 0x12, 0x8a, 0x33, - 0x6a, 0xa0, 0x0d, 0x98, 0x6a, 0x07, 0x84, 0xb4, 0x18, 0xa3, 0x2f, 0xee, 0xb3, 0x32, 0x8f, 0xba, - 0x40, 0x7b, 0x52, 0x4d, 0xc0, 0x0e, 0x33, 0xca, 0x70, 0x8a, 0x02, 0xba, 0x0b, 0x23, 0xfe, 0x1e, - 0x09, 0x76, 0x88, 0xd3, 0x98, 0xbd, 0xd0, 0xc5, 0x0f, 0x42, 0x5c, 0x6e, 0x37, 0x05, 0x6e, 0xc2, - 0x64, 0x40, 0x16, 0xf7, 0x36, 0x19, 0x90, 0x8d, 0xa1, 0xff, 0xdb, 0x82, 0xb3, 0x52, 0xcb, 0x50, - 0x6b, 0xd3, 0x51, 0x5f, 0xf2, 0xbd, 0x30, 0x0a, 0x78, 0x9c, 0x80, 0xc7, 0xf3, 0x7d, 0xe7, 0x37, - 0x72, 0x2a, 0x29, 0x89, 0xea, 0xd9, 0x3c, 0x8c, 0x10, 0xe7, 0xb7, 0x88, 0x96, 0x60, 0x3a, 0x24, - 0x91, 0x3c, 0x8c, 0x16, 0xc2, 0x95, 0x37, 0x2a, 0xeb, 0xb3, 0x4f, 0xf0, 0x20, 0x07, 0x74, 0x33, - 0xd4, 0x92, 0x40, 0x9c, 0xc6, 0x47, 0x57, 0xa0, 0xe0, 0x87, 0xb3, 0x4f, 0x76, 0xc9, 0x51, 0x4a, - 0x9f, 0xe2, 0xdc, 0x74, 0xec, 0x66, 0x0d, 0x17, 0xfc, 0x70, 0xee, 0x3b, 0x61, 0x3a, 0xc5, 0x31, - 0x1c, 0x25, 0xb7, 0xcf, 0xdc, 0x2e, 0x8c, 0x1b, 0xb3, 0xf2, 0x50, 0xb5, 0xd4, 0xff, 0x7c, 0x18, - 0x4a, 0x4a, 0x83, 0x89, 0x2e, 0x9b, 0x8a, 0xe9, 0xb3, 0x49, 0xc5, 0xf4, 0x48, 0xd5, 0x6f, 0x18, - 0xba, 0xe8, 0x8d, 0x8c, 0x68, 0x70, 0x79, 0x67, 0x40, 0xff, 0x06, 0xf2, 0x9a, 0x58, 0xb8, 0xd8, - 0xb7, 0x86, 0x7b, 0xa0, 0xab, 0xa4, 0xf9, 0x2a, 0x4c, 0x7b, 0x3e, 0x63, 0x53, 0x49, 0x43, 0xf2, - 0x20, 0x8c, 0xd5, 0x28, 0xe9, 0xe1, 0x55, 0x12, 0x08, 0x38, 0x5d, 0x87, 0x36, 0xc8, 0x79, 0x85, - 0xa4, 0x68, 0x9b, 0xb3, 0x12, 0x58, 0x40, 0xd1, 0x13, 0x30, 0xd8, 0xf6, 0x1b, 0xab, 0x55, 0xc1, - 0xa2, 0x6a, 0x31, 0x48, 0x1b, 0xab, 0x55, 0xcc, 0x61, 0x68, 0x01, 0x86, 0xd8, 0x8f, 0x70, 0x76, - 0x2c, 0x3f, 0x8e, 0x06, 0xab, 0xa1, 0x65, 0x4e, 0x62, 0x15, 0xb0, 0xa8, 0xc8, 0x44, 0x6c, 0x94, - 0xaf, 0x67, 0x22, 0xb6, 0xe1, 0x07, 0x14, 0xb1, 0x49, 0x02, 0x38, 0xa6, 0x85, 0xee, 0xc1, 0x69, - 0xe3, 0x2d, 0xc5, 0x97, 0x08, 0x09, 0x85, 0x2f, 0xff, 0x13, 0x5d, 0x1f, 0x51, 0x42, 0x23, 0x7e, - 0x4e, 0x74, 0xfa, 0xf4, 0x6a, 0x16, 0x25, 0x9c, 0xdd, 0x00, 0x6a, 0xc2, 0x74, 0x3d, 0xd5, 0xea, - 0x48, 0xff, 0xad, 0xaa, 0x09, 0x4d, 0xb7, 0x98, 0x26, 0x8c, 0x5e, 0x85, 0x91, 0xb7, 0xfc, 0x90, - 0x1d, 0xef, 0x82, 0xad, 0x96, 0x8e, 0xe0, 0x23, 0x6f, 0xdc, 0xac, 0xb1, 0xf2, 0xc3, 0x83, 0xf2, - 0x68, 0xd5, 0x6f, 0xc8, 0xbf, 0x58, 0x55, 0x40, 0x3f, 0x68, 0xc1, 0x5c, 0xfa, 0xb1, 0xa6, 0x3a, - 0x3d, 0xde, 0x7f, 0xa7, 0x6d, 0xd1, 0xe8, 0xdc, 0x72, 0x2e, 0x39, 0xdc, 0xa5, 0x29, 0xfb, 0x97, - 0x2d, 0x26, 0xa8, 0x13, 0x9a, 0x26, 0x12, 0x76, 0x9a, 0x27, 0x91, 0x30, 0x76, 0xd9, 0x50, 0x82, - 0x3d, 0xb0, 0x85, 0xc4, 0x3f, 0xb6, 0x98, 0x85, 0xc4, 0x09, 0xba, 0x42, 0xbc, 0x01, 0x23, 0x91, - 0x4c, 0xe4, 0xdb, 0x25, 0xc7, 0xad, 0xd6, 0x29, 0x66, 0x25, 0xa2, 0x98, 0x5c, 0x95, 0xb3, 0x57, - 0x91, 0xb1, 0xff, 0x1e, 0x9f, 0x01, 0x09, 0x39, 0x01, 0x5d, 0x43, 0xc5, 0xd4, 0x35, 0x94, 0x7b, - 0x7c, 0x41, 0x8e, 0xce, 0xe1, 0xef, 0x9a, 0xfd, 0x66, 0xc2, 0x9d, 0x77, 0xbb, 0x69, 0x8e, 0xfd, - 0x05, 0x0b, 0x20, 0x0e, 0xf1, 0xdc, 0x47, 0xaa, 0xb6, 0x97, 0x29, 0x5b, 0xeb, 0x47, 0x7e, 0xdd, - 0x6f, 0x0a, 0x4d, 0xda, 0x63, 0xb1, 0xba, 0x83, 0x97, 0x1f, 0x6a, 0xbf, 0xb1, 0xc2, 0x46, 0x65, - 0x19, 0x50, 0xae, 0x18, 0x2b, 0xe0, 0x8c, 0x60, 0x72, 0x5f, 0xb2, 0xe0, 0x54, 0x96, 0x5d, 0x2d, - 0x7d, 0x24, 0x71, 0x31, 0x97, 0x32, 0x9b, 0x52, 0xb3, 0x79, 0x5b, 0x94, 0x63, 0x85, 0xd1, 0x77, - 0x0e, 0xbc, 0xa3, 0xc5, 0x56, 0xbe, 0x09, 0xe3, 0xd5, 0x80, 0x68, 0x97, 0xeb, 0x6b, 0x3c, 0x48, - 0x01, 0xef, 0xcf, 0xb3, 0x47, 0x0e, 0x50, 0x60, 0x7f, 0xa5, 0x00, 0xa7, 0xb8, 0xf5, 0xc1, 0xc2, - 0x9e, 0xef, 0x36, 0xaa, 0x7e, 0x43, 0x78, 0x4f, 0x7d, 0x12, 0xc6, 0xda, 0x9a, 0x6c, 0xb2, 0x5b, - 0x9c, 0x50, 0x5d, 0x86, 0x19, 0x4b, 0x53, 0xf4, 0x52, 0x6c, 0xd0, 0x42, 0x0d, 0x18, 0x23, 0x7b, - 0x6e, 0x5d, 0xa9, 0xb0, 0x0b, 0x47, 0xbe, 0xe8, 0x54, 0x2b, 0xcb, 0x1a, 0x1d, 0x6c, 0x50, 0x7d, - 0x08, 0x99, 0xa9, 0xed, 0x1f, 0xb7, 0xe0, 0x91, 0x9c, 0xa8, 0xa2, 0xb4, 0xb9, 0xbb, 0xcc, 0xce, - 0x43, 0x2c, 0x5b, 0xd5, 0x1c, 0xb7, 0xfe, 0xc0, 0x02, 0x8a, 0x3e, 0x0e, 0xc0, 0xad, 0x37, 0xe8, - 0x2b, 0xbd, 0x57, 0xf8, 0x45, 0x23, 0x72, 0x9c, 0x16, 0x04, 0x4c, 0xd6, 0xc7, 0x1a, 0x2d, 0xfb, - 0x4b, 0x03, 0x30, 0xc8, 0xb3, 0xe8, 0x57, 0x61, 0x78, 0x87, 0xe7, 0x89, 0xe9, 0x3a, 0x6f, 0x14, - 0x57, 0xa6, 0x9e, 0x89, 0xe7, 0x4d, 0x2b, 0xc5, 0x92, 0x0c, 0x5a, 0x83, 0x19, 0x9e, 0xae, 0xa7, - 0x59, 0x21, 0x4d, 0x67, 0x5f, 0x8a, 0xfd, 0x78, 0x6e, 0x59, 0x25, 0xfe, 0x5c, 0x4d, 0xa3, 0xe0, - 0xac, 0x7a, 0xe8, 0x35, 0x98, 0xa0, 0xcf, 0x30, 0xbf, 0x13, 0x49, 0x4a, 0x3c, 0x51, 0x8f, 0x7a, - 0xf7, 0x6d, 0x18, 0x50, 0x9c, 0xc0, 0x46, 0xaf, 0xc2, 0x78, 0x3b, 0x25, 0xe0, 0x1c, 0x8c, 0x25, - 0x01, 0xa6, 0x50, 0xd3, 0xc4, 0x65, 0xa6, 0xb5, 0x1d, 0x66, 0x48, 0xbc, 0xb1, 0x13, 0x90, 0x70, - 0xc7, 0x6f, 0x36, 0x18, 0xfb, 0x37, 0xa8, 0x99, 0xd6, 0x26, 0xe0, 0x38, 0x55, 0x83, 0x52, 0xd9, - 0x72, 0xdc, 0x66, 0x27, 0x20, 0x31, 0x95, 0x21, 0x93, 0xca, 0x4a, 0x02, 0x8e, 0x53, 0x35, 0x7a, - 0x4b, 0x6e, 0x87, 0x8f, 0x47, 0x72, 0x6b, 0xff, 0xf5, 0x02, 0x18, 0x53, 0xfb, 0xed, 0x9b, 0x40, - 0x88, 0x7e, 0xd9, 0x76, 0xd0, 0xae, 0x0b, 0xcb, 0x98, 0xcc, 0x2f, 0x8b, 0xf3, 0x82, 0xf2, 0x2f, - 0xa3, 0xff, 0x31, 0xab, 0x45, 0xf7, 0xf8, 0xe9, 0x6a, 0xe0, 0xd3, 0x4b, 0x4e, 0x86, 0xb1, 0x52, - 0x16, 0xec, 0xc3, 0xd2, 0xbb, 0xb7, 0x4b, 0xc0, 0x47, 0x61, 0xe3, 0xcb, 0x29, 0x18, 0x46, 0x24, - 0x35, 0xe1, 0x6b, 0x2f, 0xa9, 0xa0, 0x2b, 0x30, 0x2a, 0xb2, 0xc2, 0x30, 0x43, 0x6b, 0xbe, 0x99, - 0x98, 0xd1, 0x4b, 0x25, 0x2e, 0xc6, 0x3a, 0x8e, 0xfd, 0x43, 0x05, 0x98, 0xc9, 0xf0, 0x94, 0xe1, - 0xd7, 0xc8, 0xb6, 0x1b, 0x46, 0x2a, 0xf5, 0xa8, 0x76, 0x8d, 0xf0, 0x72, 0xac, 0x30, 0xe8, 0x59, - 0xc5, 0x2f, 0xaa, 0xe4, 0xe5, 0x24, 0x2c, 0xd1, 0x05, 0xf4, 0x88, 0x49, 0x3c, 0x2f, 0xc0, 0x40, - 0x27, 0x24, 0x32, 0x54, 0xab, 0xba, 0xb6, 0x99, 0x5a, 0x93, 0x41, 0xe8, 0x33, 0x6a, 0x5b, 0x69, - 0x08, 0xb5, 0x67, 0x14, 0xd7, 0x11, 0x72, 0x18, 0xed, 0x5c, 0x44, 0x3c, 0xc7, 0x8b, 0xc4, 0x63, - 0x2b, 0x8e, 0x39, 0xc8, 0x4a, 0xb1, 0x80, 0xda, 0x5f, 0x2c, 0xc2, 0xd9, 0x5c, 0xdf, 0x39, 0xda, - 0xf5, 0x96, 0xef, 0xb9, 0x91, 0xaf, 0xac, 0x89, 0x78, 0x9c, 0x41, 0xd2, 0xde, 0x59, 0x13, 0xe5, - 0x58, 0x61, 0xa0, 0x8b, 0x30, 0xc8, 0x84, 0xa2, 0xa9, 0x24, 0xac, 0x8b, 0x15, 0x1e, 0x78, 0x8a, - 0x83, 0xfb, 0xce, 0x9b, 0xfd, 0x04, 0xe5, 0x60, 0xfc, 0x66, 0xf2, 0x42, 0xa1, 0xdd, 0xf5, 0xfd, - 0x26, 0x66, 0x40, 0xf4, 0x7e, 0x31, 0x5e, 0x09, 0xf3, 0x19, 0xec, 0x34, 0xfc, 0x50, 0x1b, 0xb4, - 0xa7, 0x61, 0x78, 0x97, 0xec, 0x07, 0xae, 0xb7, 0x9d, 0x34, 0xab, 0xba, 0xce, 0x8b, 0xb1, 0x84, - 0x9b, 0x59, 0x03, 0x87, 0x8f, 0x3b, 0xe1, 0xf5, 0x48, 0x4f, 0xf6, 0xe4, 0x47, 0x8a, 0x30, 0x89, - 0x17, 0x2b, 0xef, 0x4d, 0xc4, 0xad, 0xf4, 0x44, 0x1c, 0x77, 0xc2, 0xeb, 0xde, 0xb3, 0xf1, 0x0b, - 0x16, 0x4c, 0xb2, 0xdc, 0x34, 0xc2, 0x43, 0xde, 0xf5, 0xbd, 0x13, 0x78, 0x0a, 0x3c, 0x01, 0x83, - 0x01, 0x6d, 0x34, 0x99, 0x7d, 0x95, 0xf5, 0x04, 0x73, 0x18, 0x7a, 0x0c, 0x06, 0x58, 0x17, 0xe8, - 0xe4, 0x8d, 0xf1, 0x23, 0xb8, 0xe2, 0x44, 0x0e, 0x66, 0xa5, 0x2c, 0xec, 0x12, 0x26, 0xed, 0xa6, - 0xcb, 0x3b, 0x1d, 0xab, 0xac, 0xdf, 0x1d, 0x5e, 0xf5, 0x99, 0x5d, 0x7b, 0x67, 0x61, 0x97, 0xb2, - 0x49, 0x76, 0x7f, 0x66, 0xff, 0x71, 0x01, 0xce, 0x67, 0xd6, 0xeb, 0x3b, 0xec, 0x52, 0xf7, 0xda, - 0x0f, 0x33, 0xfb, 0x48, 0xf1, 0x04, 0x8d, 0x56, 0x07, 0xfa, 0xe5, 0xfe, 0x07, 0xfb, 0x88, 0x86, - 0x94, 0x39, 0x64, 0xef, 0x92, 0x68, 0x48, 0x99, 0x7d, 0xcb, 0x11, 0x13, 0xfc, 0x45, 0x21, 0xe7, - 0x5b, 0x98, 0xc0, 0xe0, 0x12, 0x3d, 0x67, 0x18, 0x30, 0x94, 0x8f, 0x70, 0x7e, 0xc6, 0xf0, 0x32, - 0xac, 0xa0, 0x68, 0x01, 0x26, 0x5b, 0xae, 0x47, 0x0f, 0x9f, 0x7d, 0x93, 0x15, 0x57, 0xc1, 0xea, - 0xd6, 0x4c, 0x30, 0x4e, 0xe2, 0x23, 0x57, 0x8b, 0x94, 0xc4, 0xbf, 0xee, 0xd5, 0x23, 0xed, 0xba, - 0x79, 0x53, 0x9d, 0xaf, 0x46, 0x31, 0x23, 0x6a, 0xd2, 0x9a, 0x26, 0x27, 0x2a, 0xf6, 0x2f, 0x27, - 0x1a, 0xcb, 0x96, 0x11, 0xcd, 0xbd, 0x0a, 0xe3, 0x0f, 0xac, 0x18, 0xb0, 0xbf, 0x5e, 0x84, 0x47, - 0xbb, 0x6c, 0x7b, 0x7e, 0xd6, 0x1b, 0x73, 0xa0, 0x9d, 0xf5, 0xa9, 0x79, 0xa8, 0xc2, 0xa9, 0xad, - 0x4e, 0xb3, 0xb9, 0xcf, 0x7c, 0x39, 0x48, 0x43, 0x62, 0x08, 0x9e, 0x52, 0x0a, 0x47, 0x4e, 0xad, - 0x64, 0xe0, 0xe0, 0xcc, 0x9a, 0xf4, 0x89, 0x45, 0x6f, 0x92, 0x7d, 0x45, 0x2a, 0xf1, 0xc4, 0xc2, - 0x3a, 0x10, 0x9b, 0xb8, 0xe8, 0x2a, 0x4c, 0x3b, 0x7b, 0x8e, 0xcb, 0xc3, 0x4d, 0x4b, 0x02, 0xfc, - 0x8d, 0xa5, 0xe4, 0xb9, 0x0b, 0x49, 0x04, 0x9c, 0xae, 0x83, 0x5e, 0x07, 0xe4, 0x6f, 0x32, 0x8b, - 0xef, 0xc6, 0x55, 0xe2, 0x09, 0xad, 0x2b, 0x9b, 0xbb, 0x62, 0x7c, 0x24, 0xdc, 0x4c, 0x61, 0xe0, - 0x8c, 0x5a, 0x89, 0x88, 0x40, 0x43, 0xf9, 0x11, 0x81, 0xba, 0x9f, 0x8b, 0x3d, 0x13, 0xdf, 0xfc, - 0x5b, 0x8b, 0x5e, 0x5f, 0x9c, 0xc9, 0x37, 0x03, 0x68, 0xbe, 0xca, 0xac, 0x26, 0xb9, 0xac, 0x57, - 0x8b, 0x9f, 0x72, 0x5a, 0xb3, 0x9a, 0x8c, 0x81, 0xd8, 0xc4, 0xe5, 0x0b, 0x22, 0x8c, 0xdd, 0x76, - 0x0d, 0x16, 0x5f, 0x44, 0xf9, 0x52, 0x18, 0xe8, 0x13, 0x30, 0xdc, 0x70, 0xf7, 0xdc, 0x50, 0x48, - 0xba, 0x8e, 0xac, 0x56, 0x8a, 0xcf, 0xc1, 0x0a, 0x27, 0x83, 0x25, 0x3d, 0xfb, 0x47, 0x0a, 0x30, - 0x2e, 0x5b, 0x7c, 0xa3, 0xe3, 0x47, 0xce, 0x09, 0x5c, 0xcb, 0x57, 0x8d, 0x6b, 0xf9, 0xfd, 0xdd, - 0x42, 0x9d, 0xb1, 0x2e, 0xe5, 0x5e, 0xc7, 0x37, 0x13, 0xd7, 0xf1, 0x53, 0xbd, 0x49, 0x75, 0xbf, - 0x86, 0xff, 0xbe, 0x05, 0xd3, 0x06, 0xfe, 0x09, 0xdc, 0x06, 0x2b, 0xe6, 0x6d, 0xf0, 0x78, 0xcf, - 0x6f, 0xc8, 0xb9, 0x05, 0xbe, 0xbf, 0x98, 0xe8, 0x3b, 0x3b, 0xfd, 0xdf, 0x82, 0x81, 0x1d, 0x27, - 0x68, 0x74, 0x4b, 0xed, 0x90, 0xaa, 0x34, 0x7f, 0xcd, 0x09, 0x84, 0xda, 0xf9, 0x59, 0x39, 0xea, - 0xb4, 0xa8, 0xa7, 0xca, 0x99, 0x35, 0x85, 0x5e, 0x86, 0xa1, 0xb0, 0xee, 0xb7, 0x95, 0x27, 0xc7, - 0x05, 0x36, 0xd0, 0xac, 0xe4, 0xf0, 0xa0, 0x8c, 0xcc, 0xe6, 0x68, 0x31, 0x16, 0xf8, 0xe8, 0x93, - 0x30, 0xce, 0x7e, 0x29, 0x1b, 0xb0, 0x62, 0xbe, 0x38, 0xa2, 0xa6, 0x23, 0x72, 0x03, 0x49, 0xa3, - 0x08, 0x9b, 0xa4, 0xe6, 0xb6, 0xa1, 0xa4, 0x3e, 0xeb, 0xa1, 0xea, 0x6d, 0xff, 0x75, 0x11, 0x66, - 0x32, 0xd6, 0x1c, 0x0a, 0x8d, 0x99, 0xb8, 0xd2, 0xe7, 0x52, 0x7d, 0x87, 0x73, 0x11, 0xb2, 0xd7, - 0x50, 0x43, 0xac, 0xad, 0xbe, 0x1b, 0xbd, 0x15, 0x92, 0x64, 0xa3, 0xb4, 0xa8, 0x77, 0xa3, 0xb4, - 0xb1, 0x13, 0x1b, 0x6a, 0xda, 0x90, 0xea, 0xe9, 0x43, 0x9d, 0xd3, 0x3f, 0x2b, 0xc2, 0xa9, 0xac, - 0xe8, 0x8b, 0xe8, 0x73, 0x89, 0xc4, 0xa2, 0x2f, 0xf6, 0x1b, 0xb7, 0x91, 0x67, 0x1b, 0x15, 0x01, - 0xe1, 0xe6, 0xcd, 0x54, 0xa3, 0x3d, 0x87, 0x59, 0xb4, 0xc9, 0x42, 0x52, 0x04, 0x3c, 0x21, 0xac, - 0x3c, 0x3e, 0x3e, 0xd4, 0x77, 0x07, 0x44, 0x26, 0xd9, 0x30, 0x61, 0x5f, 0x22, 0x8b, 0x7b, 0xdb, - 0x97, 0xc8, 0x96, 0xe7, 0x5c, 0x18, 0xd5, 0xbe, 0xe6, 0xa1, 0xce, 0xf8, 0x2e, 0xbd, 0xad, 0xb4, - 0x7e, 0x3f, 0xd4, 0x59, 0xff, 0x71, 0x0b, 0x12, 0x2e, 0x07, 0x4a, 0x2c, 0x66, 0xe5, 0x8a, 0xc5, - 0x2e, 0xc0, 0x40, 0xe0, 0x37, 0x49, 0x32, 0x03, 0x27, 0xf6, 0x9b, 0x04, 0x33, 0x08, 0xc5, 0x88, - 0x62, 0x61, 0xc7, 0x98, 0xfe, 0x90, 0x13, 0x4f, 0xb4, 0x27, 0x60, 0xb0, 0x49, 0xf6, 0x48, 0x33, - 0x99, 0x28, 0xe9, 0x06, 0x2d, 0xc4, 0x1c, 0x66, 0xff, 0xc2, 0x00, 0x9c, 0xeb, 0x1a, 0xd4, 0x85, - 0x3e, 0x87, 0xb6, 0x9d, 0x88, 0xdc, 0x75, 0xf6, 0x93, 0x19, 0x4d, 0xae, 0xf2, 0x62, 0x2c, 0xe1, - 0xcc, 0x93, 0x8c, 0x07, 0x26, 0x4f, 0x08, 0x11, 0x45, 0x3c, 0x72, 0x01, 0x35, 0x85, 0x52, 0xc5, - 0xe3, 0x10, 0x4a, 0x3d, 0x0f, 0x10, 0x86, 0x4d, 0x6e, 0x98, 0xd5, 0x10, 0x2e, 0x6a, 0x71, 0x00, - 0xfb, 0xda, 0x0d, 0x01, 0xc1, 0x1a, 0x16, 0xaa, 0xc0, 0x54, 0x3b, 0xf0, 0x23, 0x2e, 0x93, 0xad, - 0x70, 0xdb, 0xc5, 0x41, 0x33, 0x9e, 0x46, 0x35, 0x01, 0xc7, 0xa9, 0x1a, 0xe8, 0x25, 0x18, 0x15, - 0x31, 0x36, 0xaa, 0xbe, 0xdf, 0x14, 0x62, 0x20, 0x65, 0xce, 0x57, 0x8b, 0x41, 0x58, 0xc7, 0xd3, - 0xaa, 0x31, 0x41, 0xef, 0x70, 0x66, 0x35, 0x2e, 0xec, 0xd5, 0xf0, 0x12, 0x91, 0x58, 0x47, 0xfa, - 0x8a, 0xc4, 0x1a, 0x0b, 0xc6, 0x4a, 0x7d, 0xeb, 0x1d, 0xa1, 0xa7, 0x28, 0xe9, 0xe7, 0x06, 0x60, - 0x46, 0x2c, 0x9c, 0x87, 0xbd, 0x5c, 0x6e, 0xa5, 0x97, 0xcb, 0x71, 0x88, 0xce, 0xde, 0x5b, 0x33, - 0x27, 0xbd, 0x66, 0x7e, 0xd4, 0x02, 0x93, 0xbd, 0x42, 0xff, 0x47, 0x6e, 0x4a, 0xa8, 0x97, 0x72, - 0xd9, 0x35, 0x15, 0xd5, 0xf3, 0x1d, 0x26, 0x87, 0xb2, 0xff, 0x8d, 0x05, 0x8f, 0xf7, 0xa4, 0x88, - 0x96, 0xa1, 0xc4, 0x78, 0x40, 0xed, 0x75, 0xf6, 0x94, 0xb2, 0x6d, 0x96, 0x80, 0x1c, 0x96, 0x34, - 0xae, 0x89, 0x96, 0x53, 0xb9, 0xb7, 0x9e, 0xce, 0xc8, 0xbd, 0x75, 0xda, 0x18, 0x9e, 0x07, 0x4c, - 0xbe, 0xf5, 0xc3, 0xf4, 0xc6, 0x31, 0xfc, 0x8a, 0xd0, 0x87, 0x0c, 0xb1, 0x9f, 0x9d, 0x10, 0xfb, - 0x21, 0x13, 0x5b, 0xbb, 0x43, 0x3e, 0x06, 0x53, 0x2c, 0xf8, 0x16, 0xb3, 0xb4, 0x17, 0x1e, 0x4f, - 0x85, 0xd8, 0x9a, 0xf6, 0x46, 0x02, 0x86, 0x53, 0xd8, 0xf6, 0x1f, 0x15, 0x61, 0x88, 0x6f, 0xbf, - 0x13, 0x78, 0x13, 0x3e, 0x03, 0x25, 0xb7, 0xd5, 0xea, 0xf0, 0x74, 0x4a, 0x83, 0xdc, 0x37, 0x9a, - 0xce, 0xd3, 0xaa, 0x2c, 0xc4, 0x31, 0x1c, 0xad, 0x08, 0x89, 0x73, 0x97, 0xf8, 0x9e, 0xbc, 0xe3, - 0xf3, 0x15, 0x27, 0x72, 0x38, 0x83, 0xa3, 0xee, 0xd9, 0x58, 0x36, 0x8d, 0x3e, 0x0d, 0x10, 0x46, - 0x81, 0xeb, 0x6d, 0xd3, 0x32, 0x11, 0x56, 0xf8, 0x03, 0x5d, 0xa8, 0xd5, 0x14, 0x32, 0xa7, 0x19, - 0x9f, 0x39, 0x0a, 0x80, 0x35, 0x8a, 0x68, 0xde, 0xb8, 0xe9, 0xe7, 0x12, 0x73, 0x07, 0x9c, 0x6a, - 0x3c, 0x67, 0x73, 0x1f, 0x86, 0x92, 0x22, 0xde, 0x4b, 0xfe, 0x34, 0xa6, 0xb3, 0x45, 0x1f, 0x85, - 0xc9, 0x44, 0xdf, 0x8e, 0x24, 0xbe, 0xfa, 0x45, 0x0b, 0x26, 0x79, 0x67, 0x96, 0xbd, 0x3d, 0x71, - 0x1b, 0xbc, 0x0d, 0xa7, 0x9a, 0x19, 0xa7, 0xb2, 0x98, 0xfe, 0xfe, 0x4f, 0x71, 0x25, 0xae, 0xca, - 0x82, 0xe2, 0xcc, 0x36, 0xd0, 0x25, 0xba, 0xe3, 0xe8, 0xa9, 0xeb, 0x34, 0x85, 0xab, 0xf4, 0x18, - 0xdf, 0x6d, 0xbc, 0x0c, 0x2b, 0xa8, 0xfd, 0xbb, 0x16, 0x4c, 0xf3, 0x9e, 0x5f, 0x27, 0xfb, 0xea, - 0x6c, 0xfa, 0x66, 0xf6, 0x5d, 0x24, 0xf2, 0x2b, 0xe4, 0x24, 0xf2, 0xd3, 0x3f, 0xad, 0xd8, 0xf5, - 0xd3, 0xbe, 0x62, 0x81, 0x58, 0x21, 0x27, 0x20, 0x84, 0xf8, 0x4e, 0x53, 0x08, 0x31, 0x97, 0xbf, - 0x09, 0x72, 0xa4, 0x0f, 0x7f, 0x6e, 0xc1, 0x14, 0x47, 0x88, 0xb5, 0xe5, 0xdf, 0xd4, 0x79, 0xe8, - 0x27, 0xdd, 0xf7, 0x75, 0xb2, 0xbf, 0xe1, 0x57, 0x9d, 0x68, 0x27, 0xfb, 0xa3, 0x8c, 0xc9, 0x1a, - 0xe8, 0x3a, 0x59, 0x0d, 0xb9, 0x81, 0x8c, 0x3c, 0x37, 0x3d, 0xe2, 0x47, 0x1c, 0x35, 0xcf, 0x8d, - 0xfd, 0x0d, 0x0b, 0x10, 0x6f, 0xc6, 0x60, 0xdc, 0x28, 0x3b, 0xc4, 0x4a, 0xb5, 0x8b, 0x2e, 0x3e, - 0x9a, 0x14, 0x04, 0x6b, 0x58, 0xc7, 0x32, 0x3c, 0x09, 0x93, 0x87, 0x62, 0x6f, 0x93, 0x87, 0x23, - 0x8c, 0xe8, 0xbf, 0x18, 0x82, 0xa4, 0x6f, 0x15, 0xba, 0x0d, 0x63, 0x75, 0xa7, 0xed, 0x6c, 0xba, - 0x4d, 0x37, 0x72, 0x49, 0xd8, 0xcd, 0x1e, 0x6a, 0x49, 0xc3, 0x13, 0x4a, 0x6a, 0xad, 0x04, 0x1b, - 0x74, 0xd0, 0x3c, 0x40, 0x3b, 0x70, 0xf7, 0xdc, 0x26, 0xd9, 0x66, 0xb2, 0x12, 0x16, 0x9c, 0x81, - 0x1b, 0x67, 0xc9, 0x52, 0xac, 0x61, 0x64, 0x38, 0xb2, 0x17, 0x1f, 0xb2, 0x23, 0x3b, 0x9c, 0x98, - 0x23, 0xfb, 0xc0, 0x91, 0x1c, 0xd9, 0x47, 0x8e, 0xec, 0xc8, 0x3e, 0xd8, 0x97, 0x23, 0x3b, 0x86, - 0x33, 0x92, 0xf7, 0xa4, 0xff, 0x57, 0xdc, 0x26, 0x11, 0x0f, 0x0e, 0x1e, 0x51, 0x62, 0xee, 0xfe, - 0x41, 0xf9, 0x0c, 0xce, 0xc4, 0xc0, 0x39, 0x35, 0xd1, 0xc7, 0x61, 0xd6, 0x69, 0x36, 0xfd, 0xbb, - 0x6a, 0x52, 0x97, 0xc3, 0xba, 0xd3, 0xe4, 0x4a, 0x88, 0x61, 0x46, 0xf5, 0xb1, 0xfb, 0x07, 0xe5, - 0xd9, 0x85, 0x1c, 0x1c, 0x9c, 0x5b, 0x1b, 0x7d, 0x04, 0x4a, 0xed, 0xc0, 0xaf, 0xaf, 0x69, 0x0e, - 0xa0, 0xe7, 0xe9, 0x00, 0x56, 0x65, 0xe1, 0xe1, 0x41, 0x79, 0x5c, 0xfd, 0x61, 0x17, 0x7e, 0x5c, - 0x21, 0xc3, 0x33, 0x7d, 0xf4, 0x58, 0x3d, 0xd3, 0x77, 0x61, 0xa6, 0x46, 0x02, 0xd7, 0x69, 0xba, - 0x6f, 0x53, 0x7e, 0x59, 0x9e, 0x4f, 0x1b, 0x50, 0x0a, 0x12, 0x27, 0x72, 0x5f, 0x31, 0x37, 0xb5, - 0x84, 0x23, 0xf2, 0x04, 0x8e, 0x09, 0xd9, 0xff, 0xdd, 0x82, 0x61, 0xe1, 0x4b, 0x75, 0x02, 0x5c, - 0xe3, 0x82, 0xa1, 0x49, 0x28, 0x67, 0x0f, 0x18, 0xeb, 0x4c, 0xae, 0x0e, 0x61, 0x35, 0xa1, 0x43, - 0x78, 0xbc, 0x1b, 0x91, 0xee, 0xda, 0x83, 0xbf, 0x5c, 0xa4, 0xdc, 0xbb, 0xe1, 0xd5, 0xfb, 0xf0, - 0x87, 0x60, 0x1d, 0x86, 0x43, 0xe1, 0x55, 0x5a, 0xc8, 0xf7, 0x69, 0x48, 0x4e, 0x62, 0x6c, 0xc7, - 0x26, 0xfc, 0x48, 0x25, 0x91, 0x4c, 0x77, 0xd5, 0xe2, 0x43, 0x74, 0x57, 0xed, 0xe5, 0xf7, 0x3c, - 0x70, 0x1c, 0x7e, 0xcf, 0xf6, 0xd7, 0xd8, 0xcd, 0xa9, 0x97, 0x9f, 0x00, 0x53, 0x75, 0xd5, 0xbc, - 0x63, 0xed, 0x2e, 0x2b, 0x4b, 0x74, 0x2a, 0x87, 0xb9, 0xfa, 0x79, 0x0b, 0xce, 0x65, 0x7c, 0x95, - 0xc6, 0x69, 0x3d, 0x0b, 0x23, 0x4e, 0xa7, 0xe1, 0xaa, 0xbd, 0xac, 0xe9, 0x13, 0x17, 0x44, 0x39, - 0x56, 0x18, 0x68, 0x09, 0xa6, 0xc9, 0xbd, 0xb6, 0xcb, 0x55, 0xa9, 0xba, 0xf9, 0x6f, 0x91, 0x3b, - 0xe0, 0x2d, 0x27, 0x81, 0x38, 0x8d, 0xaf, 0x62, 0xcd, 0x14, 0x73, 0x63, 0xcd, 0xfc, 0x2d, 0x0b, - 0x46, 0x95, 0x5f, 0xe5, 0x43, 0x1f, 0xed, 0x8f, 0x99, 0xa3, 0xfd, 0x68, 0x97, 0xd1, 0xce, 0x19, - 0xe6, 0xdf, 0x2e, 0xa8, 0xfe, 0x56, 0xfd, 0x20, 0xea, 0x83, 0x83, 0x7b, 0x70, 0xd7, 0x85, 0x2b, - 0x30, 0xea, 0xb4, 0xdb, 0x12, 0x20, 0x6d, 0xd0, 0x58, 0x04, 0xe5, 0xb8, 0x18, 0xeb, 0x38, 0xca, - 0x93, 0xa2, 0x98, 0xeb, 0x49, 0xd1, 0x00, 0x88, 0x9c, 0x60, 0x9b, 0x44, 0xb4, 0x4c, 0x98, 0xcc, - 0xe6, 0x9f, 0x37, 0x9d, 0xc8, 0x6d, 0xce, 0xbb, 0x5e, 0x14, 0x46, 0xc1, 0xfc, 0xaa, 0x17, 0xdd, - 0x0c, 0xf8, 0x13, 0x52, 0x8b, 0xd6, 0xa4, 0x68, 0x61, 0x8d, 0xae, 0x8c, 0x21, 0xc0, 0xda, 0x18, - 0x34, 0x8d, 0x19, 0xd6, 0x45, 0x39, 0x56, 0x18, 0xf6, 0x87, 0xd9, 0xed, 0xc3, 0xc6, 0xf4, 0x68, - 0x91, 0x8a, 0xbe, 0x32, 0xa6, 0x66, 0x83, 0x69, 0x32, 0x2b, 0x7a, 0x3c, 0xa4, 0xee, 0x87, 0x3d, - 0x6d, 0x58, 0xf7, 0xeb, 0x8b, 0x83, 0x26, 0xa1, 0xef, 0x4a, 0x19, 0xa8, 0x3c, 0xd7, 0xe3, 0xd6, - 0x38, 0x82, 0x49, 0x0a, 0x4b, 0xa7, 0xc2, 0x92, 0x4d, 0xac, 0x56, 0xc5, 0xbe, 0xd0, 0xd2, 0xa9, - 0x08, 0x00, 0x8e, 0x71, 0x28, 0x33, 0xa5, 0xfe, 0x84, 0xb3, 0x28, 0x0e, 0x2b, 0xaa, 0xb0, 0x43, - 0xac, 0x61, 0xa0, 0xcb, 0x42, 0xa0, 0xc0, 0xf5, 0x02, 0x8f, 0x26, 0x04, 0x0a, 0x72, 0xb8, 0x34, - 0x29, 0xd0, 0x15, 0x18, 0x55, 0x19, 0xb4, 0xab, 0x3c, 0x91, 0x91, 0x58, 0x66, 0xcb, 0x71, 0x31, - 0xd6, 0x71, 0xd0, 0x06, 0x4c, 0x86, 0x5c, 0xce, 0xa6, 0x62, 0x3d, 0x73, 0x79, 0xe5, 0x07, 0xa4, - 0x15, 0x50, 0xcd, 0x04, 0x1f, 0xb2, 0x22, 0x7e, 0x3a, 0x49, 0x3f, 0xff, 0x24, 0x09, 0xf4, 0x1a, - 0x4c, 0x34, 0x7d, 0xa7, 0xb1, 0xe8, 0x34, 0x1d, 0xaf, 0xce, 0xc6, 0x67, 0xc4, 0x4c, 0xc4, 0x7a, - 0xc3, 0x80, 0xe2, 0x04, 0x36, 0x65, 0xde, 0xf4, 0x12, 0x11, 0x9f, 0xdc, 0xf1, 0xb6, 0x49, 0x28, - 0xf2, 0x21, 0x33, 0xe6, 0xed, 0x46, 0x0e, 0x0e, 0xce, 0xad, 0x8d, 0x5e, 0x86, 0x31, 0xf9, 0xf9, - 0x5a, 0x58, 0x8c, 0xd8, 0x29, 0x45, 0x83, 0x61, 0x03, 0x13, 0xdd, 0x85, 0xd3, 0xf2, 0xff, 0x46, - 0xe0, 0x6c, 0x6d, 0xb9, 0x75, 0xe1, 0x2b, 0xce, 0xbd, 0x57, 0x17, 0xa4, 0x8b, 0xe5, 0x72, 0x16, - 0xd2, 0xe1, 0x41, 0xf9, 0x82, 0x18, 0xb5, 0x4c, 0x38, 0x9b, 0xc4, 0x6c, 0xfa, 0x68, 0x0d, 0x66, - 0x76, 0x88, 0xd3, 0x8c, 0x76, 0x96, 0x76, 0x48, 0x7d, 0x57, 0x6e, 0x3a, 0x16, 0x6c, 0x43, 0x73, - 0xe0, 0xb8, 0x96, 0x46, 0xc1, 0x59, 0xf5, 0xd0, 0x9b, 0x30, 0xdb, 0xee, 0x6c, 0x36, 0xdd, 0x70, - 0x67, 0xdd, 0x8f, 0x98, 0x29, 0x90, 0x4a, 0xc8, 0x2d, 0xa2, 0x72, 0xa8, 0x70, 0x26, 0xd5, 0x1c, - 0x3c, 0x9c, 0x4b, 0x01, 0xbd, 0x0d, 0xa7, 0x13, 0x8b, 0x41, 0xc4, 0x25, 0x98, 0xc8, 0xcf, 0xf6, - 0x50, 0xcb, 0xaa, 0x20, 0x42, 0x7c, 0x64, 0x81, 0x70, 0x76, 0x13, 0xe8, 0x15, 0x00, 0xb7, 0xbd, - 0xe2, 0xb4, 0xdc, 0x26, 0x7d, 0x2e, 0xce, 0xb0, 0x75, 0x42, 0x9f, 0x0e, 0xb0, 0x5a, 0x95, 0xa5, - 0xf4, 0x7c, 0x16, 0xff, 0xf6, 0xb1, 0x86, 0x8d, 0x6e, 0xc0, 0x84, 0xf8, 0xb7, 0x2f, 0xa6, 0x95, - 0x87, 0xc7, 0x78, 0x92, 0xc5, 0x36, 0xaa, 0xea, 0x90, 0xc3, 0x54, 0x09, 0x4e, 0xd4, 0x45, 0xdb, - 0x70, 0x4e, 0x66, 0xee, 0xd2, 0xd7, 0xa8, 0x9c, 0x83, 0x90, 0xa5, 0x58, 0x18, 0xe1, 0xbe, 0x21, - 0x0b, 0xdd, 0x10, 0x71, 0x77, 0x3a, 0xf4, 0x6e, 0xd7, 0x97, 0x3a, 0xf7, 0x9e, 0x3d, 0xcd, 0x4d, - 0x93, 0xe8, 0xdd, 0x7e, 0x23, 0x09, 0xc4, 0x69, 0x7c, 0x14, 0xc2, 0x69, 0xd7, 0xcb, 0x5a, 0xd9, - 0x67, 0x18, 0xa1, 0x8f, 0x72, 0xc7, 0xe1, 0xee, 0xab, 0x3a, 0x13, 0xce, 0x57, 0x75, 0x26, 0xed, - 0x77, 0x66, 0x81, 0xf7, 0x3b, 0x16, 0xad, 0xad, 0x71, 0xe9, 0xe8, 0x33, 0x30, 0xa6, 0x7f, 0x98, - 0xe0, 0x38, 0x2e, 0x66, 0x33, 0xb1, 0xda, 0xd9, 0xc0, 0x79, 0x7c, 0xb5, 0xff, 0x75, 0x18, 0x36, - 0x28, 0xa2, 0x7a, 0x86, 0x8b, 0xfd, 0xe5, 0xfe, 0x38, 0x9a, 0xfe, 0x0d, 0xd0, 0x08, 0x64, 0x2f, - 0x79, 0x74, 0x03, 0x46, 0xea, 0x4d, 0x97, 0x78, 0xd1, 0x6a, 0xb5, 0x5b, 0x1c, 0xbd, 0x25, 0x81, - 0x23, 0xf6, 0x90, 0xc8, 0x98, 0xc0, 0xcb, 0xb0, 0xa2, 0x60, 0xff, 0x5a, 0x01, 0xca, 0x3d, 0xd2, - 0x6f, 0x24, 0xd4, 0x51, 0x56, 0x5f, 0xea, 0xa8, 0x05, 0x99, 0x71, 0x7e, 0x3d, 0x21, 0xe9, 0x4a, - 0x64, 0x93, 0x8f, 0xe5, 0x5d, 0x49, 0xfc, 0xbe, 0xdd, 0x03, 0x74, 0x8d, 0xd6, 0x40, 0x4f, 0x07, - 0x17, 0x43, 0x93, 0x3d, 0xd8, 0xff, 0xf3, 0x37, 0x57, 0x2b, 0x69, 0x7f, 0xad, 0x00, 0xa7, 0xd5, - 0x10, 0x7e, 0xfb, 0x0e, 0xdc, 0xad, 0xf4, 0xc0, 0x1d, 0x83, 0x4e, 0xd7, 0xbe, 0x09, 0x43, 0x3c, - 0x30, 0x60, 0x1f, 0x6c, 0xf7, 0x13, 0x66, 0xe0, 0x5d, 0xc5, 0xe9, 0x19, 0xc1, 0x77, 0x7f, 0xd0, - 0x82, 0xc9, 0x84, 0x9f, 0x19, 0xc2, 0x9a, 0x33, 0xf2, 0x83, 0xb0, 0xc6, 0x59, 0x4c, 0xf7, 0x05, - 0x18, 0xd8, 0xf1, 0xc3, 0x28, 0x69, 0xf0, 0x71, 0xcd, 0x0f, 0x23, 0xcc, 0x20, 0xf6, 0xef, 0x59, - 0x30, 0xb8, 0xe1, 0xb8, 0x5e, 0x24, 0x95, 0x03, 0x56, 0x8e, 0x72, 0xa0, 0x9f, 0xef, 0x42, 0x2f, - 0xc1, 0x10, 0xd9, 0xda, 0x22, 0xf5, 0x48, 0xcc, 0xaa, 0x8c, 0xe4, 0x30, 0xb4, 0xcc, 0x4a, 0x29, - 0x1f, 0xc8, 0x1a, 0xe3, 0x7f, 0xb1, 0x40, 0x46, 0x77, 0xa0, 0x14, 0xb9, 0x2d, 0xb2, 0xd0, 0x68, - 0x08, 0x95, 0xf9, 0x03, 0x44, 0xa3, 0xd8, 0x90, 0x04, 0x70, 0x4c, 0xcb, 0xfe, 0x62, 0x01, 0x20, - 0x8e, 0xa8, 0xd4, 0xeb, 0x13, 0x17, 0x53, 0xca, 0xd4, 0x8b, 0x19, 0xca, 0x54, 0x14, 0x13, 0xcc, - 0xd0, 0xa4, 0xaa, 0x61, 0x2a, 0xf6, 0x35, 0x4c, 0x03, 0x47, 0x19, 0xa6, 0x25, 0x98, 0x8e, 0x23, - 0x42, 0x99, 0x01, 0xf1, 0xd8, 0xf5, 0xb9, 0x91, 0x04, 0xe2, 0x34, 0xbe, 0x4d, 0xe0, 0x82, 0x0a, - 0x8c, 0x23, 0x6e, 0x34, 0x66, 0x91, 0xad, 0x2b, 0xa7, 0x7b, 0x8c, 0x53, 0xac, 0x2d, 0x2e, 0xe4, - 0x6a, 0x8b, 0x7f, 0xca, 0x82, 0x53, 0xc9, 0x76, 0x98, 0xfb, 0xf2, 0x17, 0x2c, 0x38, 0xcd, 0x74, - 0xe6, 0xac, 0xd5, 0xb4, 0x86, 0xfe, 0xc5, 0xae, 0xc1, 0x7e, 0x72, 0x7a, 0x1c, 0x87, 0x0c, 0x59, - 0xcb, 0x22, 0x8d, 0xb3, 0x5b, 0xb4, 0xff, 0xdb, 0x00, 0xcc, 0xe6, 0x45, 0x09, 0x62, 0x0e, 0x1b, - 0xce, 0xbd, 0xda, 0x2e, 0xb9, 0x2b, 0xcc, 0xe2, 0x63, 0x87, 0x0d, 0x5e, 0x8c, 0x25, 0x3c, 0x99, - 0x51, 0xa1, 0xd0, 0x67, 0x46, 0x85, 0x1d, 0x98, 0xbe, 0xbb, 0x43, 0xbc, 0x5b, 0x5e, 0xe8, 0x44, - 0x6e, 0xb8, 0xe5, 0x32, 0xfd, 0x32, 0x5f, 0x37, 0x32, 0x0d, 0xeb, 0xf4, 0x9d, 0x24, 0xc2, 0xe1, - 0x41, 0xf9, 0x9c, 0x51, 0x10, 0x77, 0x99, 0x1f, 0x24, 0x38, 0x4d, 0x34, 0x9d, 0x90, 0x62, 0xe0, - 0x21, 0x27, 0xa4, 0x68, 0xb9, 0xc2, 0x2a, 0x45, 0x5a, 0xe3, 0xb3, 0x97, 0xe3, 0x9a, 0x2a, 0xc5, - 0x1a, 0x06, 0xfa, 0x14, 0x20, 0x3d, 0xe1, 0x8e, 0x11, 0xa4, 0xf1, 0xb9, 0xfb, 0x07, 0x65, 0xb4, - 0x9e, 0x82, 0x1e, 0x1e, 0x94, 0x67, 0x68, 0xe9, 0xaa, 0x47, 0x5f, 0xa0, 0x71, 0x64, 0xab, 0x0c, - 0x42, 0xe8, 0x0e, 0x4c, 0xd1, 0x52, 0xb6, 0xa3, 0x64, 0x04, 0x48, 0xfe, 0x6a, 0x7c, 0xe6, 0xfe, - 0x41, 0x79, 0x6a, 0x3d, 0x01, 0xcb, 0x23, 0x9d, 0x22, 0x82, 0x5e, 0x81, 0x89, 0x78, 0x5d, 0x5d, - 0x27, 0xfb, 0x3c, 0xdc, 0x4c, 0x89, 0x0b, 0xbe, 0xd7, 0x0c, 0x08, 0x4e, 0x60, 0xda, 0x5f, 0xb0, - 0xe0, 0x6c, 0x6e, 0xde, 0x66, 0x74, 0x09, 0x46, 0x9c, 0xb6, 0xcb, 0xd5, 0x18, 0xe2, 0xaa, 0x61, - 0xe2, 0xb2, 0xea, 0x2a, 0x57, 0x62, 0x28, 0x28, 0x3d, 0xe1, 0x77, 0x5d, 0xaf, 0x91, 0x3c, 0xe1, - 0xaf, 0xbb, 0x5e, 0x03, 0x33, 0x88, 0xba, 0xb2, 0x8a, 0x79, 0x57, 0x96, 0xfd, 0x03, 0x16, 0x08, - 0x87, 0xdc, 0x3e, 0xee, 0xb7, 0x4f, 0xc2, 0xd8, 0x5e, 0x3a, 0xb1, 0xd7, 0x85, 0x7c, 0x0f, 0x65, - 0x91, 0xce, 0x4b, 0x31, 0xad, 0x46, 0x12, 0x2f, 0x83, 0x96, 0xdd, 0x00, 0x01, 0xad, 0x10, 0x26, - 0xa4, 0xef, 0xdd, 0x9b, 0xe7, 0x01, 0x1a, 0x0c, 0x97, 0x65, 0xfb, 0x2c, 0x98, 0xdc, 0x4b, 0x45, - 0x41, 0xb0, 0x86, 0x65, 0xff, 0xab, 0x02, 0x8c, 0xca, 0x44, 0x52, 0x1d, 0xaf, 0x1f, 0x51, 0xda, - 0x91, 0x32, 0xcb, 0xa2, 0xcb, 0x50, 0x62, 0xb2, 0xde, 0x6a, 0x2c, 0x81, 0x54, 0x92, 0x96, 0x35, - 0x09, 0xc0, 0x31, 0x0e, 0x3d, 0x69, 0xc2, 0xce, 0x26, 0x43, 0x4f, 0xb8, 0x8f, 0xd6, 0x78, 0x31, - 0x96, 0x70, 0xf4, 0x71, 0x98, 0xe2, 0xf5, 0x02, 0xbf, 0xed, 0x6c, 0x73, 0xfd, 0xd0, 0xa0, 0x8a, - 0xc9, 0x31, 0xb5, 0x96, 0x80, 0x1d, 0x1e, 0x94, 0x4f, 0x25, 0xcb, 0x98, 0xe2, 0x33, 0x45, 0x85, - 0x99, 0x81, 0xf1, 0x46, 0xe8, 0x09, 0x99, 0xb2, 0x1e, 0x8b, 0x41, 0x58, 0xc7, 0xb3, 0x3f, 0x03, - 0x28, 0x9d, 0x52, 0x0b, 0xbd, 0xce, 0x6d, 0x7f, 0xdd, 0x80, 0x34, 0xba, 0x29, 0x42, 0xf5, 0xc8, - 0x13, 0xd2, 0xf3, 0x8b, 0xd7, 0xc2, 0xaa, 0xbe, 0xfd, 0xff, 0x14, 0x61, 0x2a, 0xe9, 0xeb, 0x8e, - 0xae, 0xc1, 0x10, 0x67, 0xcf, 0x04, 0xf9, 0x2e, 0x76, 0x36, 0x9a, 0x87, 0x3c, 0xbb, 0xa8, 0x04, - 0x87, 0x27, 0xea, 0xa3, 0x37, 0x61, 0xb4, 0xe1, 0xdf, 0xf5, 0xee, 0x3a, 0x41, 0x63, 0xa1, 0xba, - 0x2a, 0x96, 0x73, 0xe6, 0xc3, 0xbf, 0x12, 0xa3, 0xe9, 0x5e, 0xf7, 0x4c, 0xa7, 0x1c, 0x83, 0xb0, - 0x4e, 0x0e, 0x6d, 0xb0, 0x38, 0xfc, 0x5b, 0xee, 0xf6, 0x9a, 0xd3, 0xee, 0xe6, 0x08, 0xb2, 0x24, - 0x91, 0x34, 0xca, 0xe3, 0x22, 0x58, 0x3f, 0x07, 0xe0, 0x98, 0x10, 0xfa, 0x1c, 0xcc, 0x84, 0x39, - 0xea, 0x88, 0xbc, 0x0c, 0x8b, 0xdd, 0x24, 0xf4, 0x8b, 0x8f, 0xdc, 0x3f, 0x28, 0xcf, 0x64, 0x29, - 0x2e, 0xb2, 0x9a, 0xb1, 0xbf, 0x74, 0x0a, 0x8c, 0x4d, 0x6c, 0x24, 0xdc, 0xb5, 0x8e, 0x29, 0xe1, - 0x2e, 0x86, 0x11, 0xd2, 0x6a, 0x47, 0xfb, 0x15, 0x37, 0x10, 0x73, 0x92, 0x49, 0x73, 0x59, 0xe0, - 0xa4, 0x69, 0x4a, 0x08, 0x56, 0x74, 0xb2, 0xb3, 0x22, 0x17, 0xbf, 0x89, 0x59, 0x91, 0x07, 0x4e, - 0x30, 0x2b, 0xf2, 0x3a, 0x0c, 0x6f, 0xbb, 0x11, 0x26, 0x6d, 0x5f, 0x3c, 0x8c, 0x32, 0xd7, 0xe1, - 0x55, 0x8e, 0x92, 0xce, 0xbf, 0x29, 0x00, 0x58, 0x12, 0x41, 0xaf, 0xab, 0x1d, 0x38, 0x94, 0x2f, - 0xbc, 0x48, 0x1b, 0x84, 0x64, 0xee, 0x41, 0x91, 0xfb, 0x78, 0xf8, 0x41, 0x73, 0x1f, 0xaf, 0xc8, - 0x8c, 0xc5, 0x23, 0xf9, 0x5e, 0x5b, 0x2c, 0x21, 0x71, 0x8f, 0x3c, 0xc5, 0xb7, 0xf5, 0x2c, 0xcf, - 0xa5, 0xfc, 0x93, 0x40, 0x25, 0x70, 0xee, 0x33, 0xb7, 0xf3, 0x0f, 0x58, 0x70, 0xba, 0x9d, 0x95, - 0xf0, 0x5c, 0xd8, 0x4e, 0xbc, 0xd4, 0x77, 0x4e, 0x75, 0xa3, 0x41, 0x26, 0x73, 0xcc, 0xce, 0x9a, - 0x9f, 0xdd, 0x1c, 0x1d, 0xe8, 0x60, 0xb3, 0x21, 0x74, 0xf8, 0x4f, 0xe4, 0x24, 0x89, 0xee, 0x92, - 0x1a, 0x7a, 0x23, 0x23, 0x21, 0xf1, 0x93, 0x79, 0x09, 0x89, 0xfb, 0x4e, 0x43, 0xfc, 0xba, 0x4a, - 0x0f, 0x3d, 0x9e, 0xbf, 0x94, 0x78, 0xf2, 0xe7, 0x9e, 0x49, 0xa1, 0x5f, 0x57, 0x49, 0xa1, 0xbb, - 0xc4, 0x4b, 0xe6, 0x29, 0x9f, 0x7b, 0xa6, 0x82, 0xd6, 0xd2, 0x39, 0x4f, 0x1e, 0x4f, 0x3a, 0x67, - 0xe3, 0xaa, 0xe1, 0x19, 0x85, 0x9f, 0xe9, 0x71, 0xd5, 0x18, 0x74, 0xbb, 0x5f, 0x36, 0x3c, 0x75, - 0xf5, 0xf4, 0x03, 0xa5, 0xae, 0xbe, 0xad, 0xa7, 0x82, 0x46, 0x3d, 0x72, 0x1d, 0x53, 0xa4, 0x3e, - 0x13, 0x40, 0xdf, 0xd6, 0x2f, 0xc0, 0x99, 0x7c, 0xba, 0xea, 0x9e, 0x4b, 0xd3, 0xcd, 0xbc, 0x02, - 0x53, 0x89, 0xa5, 0x4f, 0x9d, 0x4c, 0x62, 0xe9, 0xd3, 0xc7, 0x9e, 0x58, 0xfa, 0xcc, 0x09, 0x24, - 0x96, 0x7e, 0xe4, 0x04, 0x13, 0x4b, 0xdf, 0x66, 0x06, 0x47, 0x3c, 0xac, 0x91, 0x88, 0xef, 0xfc, - 0x74, 0x4e, 0x54, 0xb0, 0x74, 0xec, 0x23, 0xfe, 0x71, 0x0a, 0x84, 0x63, 0x52, 0x19, 0x09, 0xab, - 0x67, 0x1f, 0x42, 0xc2, 0xea, 0xf5, 0x38, 0x61, 0xf5, 0xd9, 0xfc, 0xa9, 0xce, 0x70, 0x51, 0xc9, - 0x49, 0x53, 0x7d, 0x5b, 0x4f, 0x2f, 0xfd, 0x68, 0x17, 0xad, 0x52, 0x96, 0x70, 0xb6, 0x4b, 0x52, - 0xe9, 0xd7, 0x78, 0x52, 0xe9, 0xc7, 0xf2, 0x4f, 0xf2, 0xe4, 0x75, 0x67, 0xa4, 0x92, 0xa6, 0xfd, - 0x52, 0x61, 0x41, 0x59, 0x24, 0xeb, 0x9c, 0x7e, 0xa9, 0xb8, 0xa2, 0xe9, 0x7e, 0x29, 0x10, 0x8e, - 0x49, 0xd9, 0x3f, 0x54, 0x80, 0xf3, 0xdd, 0xf7, 0x5b, 0x2c, 0x71, 0xae, 0xc6, 0x4a, 0xf6, 0x84, - 0xc4, 0x99, 0xbf, 0xd9, 0x62, 0xac, 0xbe, 0xa3, 0x1c, 0x5e, 0x85, 0x69, 0xe5, 0xdb, 0x42, 0xdf, - 0xe8, 0xeb, 0xf1, 0xcb, 0x57, 0xc5, 0x03, 0xa8, 0x25, 0x11, 0x70, 0xba, 0x0e, 0x5a, 0x80, 0x49, - 0xa3, 0x70, 0xb5, 0x22, 0xde, 0x66, 0x4a, 0xc4, 0x5d, 0x33, 0xc1, 0x38, 0x89, 0x6f, 0x7f, 0xd9, - 0x82, 0x47, 0x72, 0x32, 0x32, 0xf6, 0x1d, 0xc4, 0x6f, 0x0b, 0x26, 0xdb, 0x66, 0xd5, 0x1e, 0x71, - 0x47, 0x8d, 0xbc, 0x8f, 0xaa, 0xaf, 0x09, 0x00, 0x4e, 0x12, 0xb5, 0x7f, 0xa6, 0x00, 0xe7, 0xba, - 0x1a, 0x6b, 0x22, 0x0c, 0x67, 0xb6, 0x5b, 0xa1, 0xb3, 0x14, 0x90, 0x06, 0xf1, 0x22, 0xd7, 0x69, - 0xd6, 0xda, 0xa4, 0xae, 0xe9, 0x0c, 0x98, 0xd5, 0xe3, 0xd5, 0xb5, 0xda, 0x42, 0x1a, 0x03, 0xe7, - 0xd4, 0x44, 0x2b, 0x80, 0xd2, 0x10, 0x31, 0xc3, 0x2c, 0x26, 0x7a, 0x9a, 0x1e, 0xce, 0xa8, 0x81, - 0x3e, 0x0c, 0xe3, 0xca, 0x08, 0x54, 0x9b, 0x71, 0x76, 0xb0, 0x63, 0x1d, 0x80, 0x4d, 0x3c, 0x74, - 0x85, 0x07, 0xd5, 0x17, 0xe9, 0x17, 0x84, 0x82, 0x61, 0x52, 0x46, 0xcc, 0x17, 0xc5, 0x58, 0xc7, - 0x59, 0x7c, 0xf9, 0xd7, 0xff, 0xe0, 0xfc, 0xfb, 0x7e, 0xeb, 0x0f, 0xce, 0xbf, 0xef, 0x77, 0xff, - 0xe0, 0xfc, 0xfb, 0xbe, 0xe7, 0xfe, 0x79, 0xeb, 0xd7, 0xef, 0x9f, 0xb7, 0x7e, 0xeb, 0xfe, 0x79, - 0xeb, 0x77, 0xef, 0x9f, 0xb7, 0x7e, 0xff, 0xfe, 0x79, 0xeb, 0x8b, 0x7f, 0x78, 0xfe, 0x7d, 0x9f, - 0x44, 0x71, 0x58, 0xcc, 0xcb, 0x74, 0x76, 0x2e, 0xef, 0x5d, 0xf9, 0xdf, 0x01, 0x00, 0x00, 0xff, - 0xff, 0xd9, 0x48, 0x50, 0xbd, 0x65, 0x09, 0x01, 0x00, + 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, } func (m *AWSElasticBlockStoreVolumeSource) Marshal() (dAtA []byte, err error) { @@ -15058,6 +15059,18 @@ func (m *PodSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.HostUsers != nil { + i-- + if *m.HostUsers { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xa8 + } if m.OS != nil { { size, err := m.OS.MarshalToSizedBuffer(dAtA[:i]) @@ -22857,6 +22870,9 @@ func (m *PodSpec) Size() (n int) { l = m.OS.Size() n += 2 + l + sovGenerated(uint64(l)) } + if m.HostUsers != nil { + n += 3 + } return n } @@ -26744,6 +26760,7 @@ func (this *PodSpec) String() string { `EphemeralContainers:` + repeatedStringForEphemeralContainers + `,`, `SetHostnameAsFQDN:` + valueToStringGenerated(this.SetHostnameAsFQDN) + `,`, `OS:` + strings.Replace(this.OS.String(), "PodOS", "PodOS", 1) + `,`, + `HostUsers:` + valueToStringGenerated(this.HostUsers) + `,`, `}`, }, "") return s @@ -54436,6 +54453,27 @@ func (m *PodSpec) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 37: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field HostUsers", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.HostUsers = &b 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 0b7cec2d5c17..43938bfb9895 100644 --- a/staging/src/k8s.io/api/core/v1/generated.proto +++ b/staging/src/k8s.io/api/core/v1/generated.proto @@ -3712,6 +3712,7 @@ message PodSpec { // If 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 @@ -3732,6 +3733,19 @@ message PodSpec { // - spec.containers[*].securityContext.runAsGroup // +optional optional PodOS os = 36; + + // 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. + // +k8s:conversion-gen=false + // +optional + optional bool hostUsers = 37; } // 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_swagger_doc_generated.go b/staging/src/k8s.io/api/core/v1/types_swagger_doc_generated.go index 699dd2cc3c83..630af4b331be 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 @@ -1670,7 +1670,8 @@ var map_PodSpec = map[string]string{ "overhead": "Overhead represents the resource overhead associated with running a pod for a given RuntimeClass. This field will be autopopulated at admission time by the RuntimeClass admission controller. If the RuntimeClass admission controller is enabled, overhead must not be set in Pod create requests. The RuntimeClass admission controller will reject Pod create requests which have the overhead already set. If RuntimeClass is configured and selected in the PodSpec, Overhead will be set to the value defined in the corresponding RuntimeClass, otherwise it will remain unset and treated as zero. More info: https://git.k8s.io/enhancements/keps/sig-node/688-pod-overhead/README.md", "topologySpreadConstraints": "TopologySpreadConstraints describes how a group of pods ought to spread across topology domains. Scheduler will schedule pods in a way which abides by the constraints. All topologySpreadConstraints are ANDed.", "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.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", + "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.", } 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 2574b3fad1ed..e5a644ead948 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 @@ -3954,6 +3954,11 @@ func (in *PodSpec) DeepCopyInto(out *PodSpec) { *out = new(PodOS) **out = **in } + if in.HostUsers != nil { + in, out := &in.HostUsers, &out.HostUsers + *out = new(bool) + **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 3f0b17693d0f..440a290800ca 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 @@ -1625,7 +1625,8 @@ "setHostnameAsFQDN": true, "os": { "name": "nameValue" - } + }, + "hostUsers": true } }, "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 c295730874d5bac2c5ade8b77575806276848a56..7f782b11a65195fb2d12478930948f60d9f1aacb 100644 GIT binary patch delta 41 xcmZ4LyTW&ZG-LZlnN&umbDonO#r>Ifd2EzTVPw3r*^>E^67vcs#>w1jvj8po4V(Y~ delta 37 tcmZ4CyVQ4rG-Jy~nN&um)1H$Z#r>JKdu)_VVPw3x*^>E^(qulhSpfP64CMd- 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 aebd268c9353..8d724ce14e68 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 @@ -592,6 +592,7 @@ spec: hostIPC: true hostNetwork: true hostPID: true + hostUsers: true hostname: hostnameValue imagePullSecrets: - name: nameValue 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 c6d08c291c70..aa1a1cdab787 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 @@ -1626,7 +1626,8 @@ "setHostnameAsFQDN": true, "os": { "name": "nameValue" - } + }, + "hostUsers": true } }, "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 fea88fd2dc1cc91d1914e63f35ee2977697c8b96..7ec2e672536de3cb6c43906fb2c351edd6e381e4 100644 GIT binary patch delta 45 zcmV+|0Mh@mO|?ys908ND9c2Lp)JX^d5|iHxO#>RbNUN4lMW`N DVABqy delta 41 zcmV+^0M`GtO|ngp908EA9c2Lp(Mbpa5|iHxO#>RYNURbNUN4vkxXF E1aMIfP5=M^ delta 50 zcmdlHvNdFaEaRk&a;c20n*ul(g(g4X_GOmZ?y*rmg^}^%W?SY0R`Ae2mun4FBVP#y0hB>WdQ-yvq1yWA_J%b0h1FZ EsDsE4nE(I) delta 42 zcmV+_0M-A#O}kByAp(?5v)ln>0R`1b2mun4FBVP#x3k*;WdQ-vvq1yWB9j&-s7Nmk A;s5{u 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 a599f4693101..cf6ce10867a0 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 @@ -602,6 +602,7 @@ spec: hostIPC: true hostNetwork: true hostPID: true + hostUsers: true hostname: hostnameValue imagePullSecrets: - name: nameValue 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 56141cc353ad..b2e723c3f02e 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 @@ -1626,7 +1626,8 @@ "setHostnameAsFQDN": true, "os": { "name": "nameValue" - } + }, + "hostUsers": true } }, "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 a9dc176720af24de178942186d06fd077d2fcc12..fe6716c7376fe6d8b980f36ab944283b6c5c10be 100644 GIT binary patch delta 55 zcmdlLvNvRc64TU>&37477+JRla4-r@HW2e;+_m`*V=5!#mCa7fmz3C6Ffl4EVFRn# JT&=#J2>>D`68ZoD delta 52 zcmdlRvMXeQ64RuR&37477+E(3a4-r@HW2e;+`jn^V=5!##m!F4mz0>5mau^pY_3z^ G&jbMNY7#>L 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 3390912b1f57..e13510a7d5bb 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 @@ -598,6 +598,7 @@ spec: hostIPC: true hostNetwork: true hostPID: true + hostUsers: true hostname: hostnameValue imagePullSecrets: - name: nameValue 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 404330b4e35d..a3bd480c5a52 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 @@ -1625,7 +1625,8 @@ "setHostnameAsFQDN": true, "os": { "name": "nameValue" - } + }, + "hostUsers": true } }, "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 4aa53c5ad1b859ee1391b181c2fe320697b1f75d..0dd7a5064d51eb4d2c8c8ab485e0f17b612b53d6 100644 GIT binary patch delta 43 zcmV+`0M!4gO|4CkAOVN5A!Pvr&PfWB@fJ=3x=6Dx3S0s)f{CYn@4 B4v_!= delta 39 vcmZ4MyUKTh0%OZY#Z*S-)1F+DKZ^M=ZTHx$&y~W+cyY5G^ChLp!fLYs9FPs# 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 f0eae0673ab0..9202c0d541d6 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 @@ -592,6 +592,7 @@ spec: hostIPC: true hostNetwork: true hostPID: true + hostUsers: true hostname: hostnameValue imagePullSecrets: - name: nameValue 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 45c8c6f06894..3e705d2bd5db 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 @@ -1626,7 +1626,8 @@ "setHostnameAsFQDN": true, "os": { "name": "nameValue" - } + }, + "hostUsers": true } }, "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 496af02aa3fcf92b70a931947e605c00523a6157..5fe69ef8e65d9dea43e224745b1615d4c0509240 100644 GIT binary patch delta 46 zcmV+}0MY-qO}b5xAp(<4v)ln>0R_}a2mun4FBVP#y0hB>WdQ-yvq1yWA_J%b0h1FZ Eq=7^ag#Z8m delta 42 zcmV+_0M-AxO}9;uAp($1v)ln>0R_=X2mun4FBVP#x3k*;WdQ-vvq1yWB9j&-q($ov A&Hw-a 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 3ae1e33ae9f1..18054366cc21 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 @@ -600,6 +600,7 @@ spec: hostIPC: true hostNetwork: true hostPID: true + hostUsers: true hostname: hostnameValue imagePullSecrets: - name: nameValue 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 555d29510374..0f6ecc2f2a5d 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 @@ -1627,7 +1627,8 @@ "setHostnameAsFQDN": true, "os": { "name": "nameValue" - } + }, + "hostUsers": true } } }, 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 7d9cbdbb11f37c570e7bf183a2366adbdc7250ee..031ea06428c966ffcc6f177d03218f26e5b75fee 100644 GIT binary patch delta 46 zcmV+}0MY;COy^9HAp*cmv)ln>0R@jq2mun4FBVP#y0hB>WdQ-yvq1yWA_J%b0h1FZ EQI5qAaR2}S delta 42 ycmaFv^TcO@BGX=<&37167+HHfIT(c|>x=m@Zr^;HF_n?=;$}zYOG=Z))B*uga1Ocv 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 92e6277bc08b..1285dac52361 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 @@ -592,6 +592,7 @@ spec: hostIPC: true hostNetwork: true hostPID: true + hostUsers: true hostname: hostnameValue imagePullSecrets: - name: nameValue 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 9ac29c31e2ab..552f7fd1ab6f 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 @@ -1626,7 +1626,8 @@ "setHostnameAsFQDN": true, "os": { "name": "nameValue" - } + }, + "hostUsers": true } }, "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 d6787f20e340cbb89bd2fbee19ba371bc036692b..fe44f78b626ec68f635a991408f8e612519551a2 100644 GIT binary patch delta 55 zcmdlLvNvRc64TU>&37477+JRla4-r@HW2e;+_m`*V=5!#mCa7fmz3C6Ffl4EVFRn# JT&=#J2>>D`68ZoD delta 52 zcmdlRvMXeQ64RuR&37477+E(3a4-r@HW2e;+`jn^V=5!##m!F4mz0>5mau^pY_3z^ G&jbMNY7#>L 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 7ff24cfcf340..33129967f809 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 @@ -598,6 +598,7 @@ spec: hostIPC: true hostNetwork: true hostPID: true + hostUsers: true hostname: hostnameValue imagePullSecrets: - name: nameValue 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 1cf8885d5069..1187b5b6fa99 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 @@ -1679,7 +1679,8 @@ "setHostnameAsFQDN": true, "os": { "name": "nameValue" - } + }, + "hostUsers": true } }, "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 92b3be14ffbab4233a0884e7a99f87e02353a06d..d527e1c72b3914c8c01442c7a9ac4f6747096fcc 100644 GIT binary patch delta 66 zcmcZ}a4TSf6w|JN%^Mg~7#XilZe-MDoU(a6V=5!ZI!_Kp0VWCN$p^*#STz`pc6mS) UUDM~97*{GPp$hdB@6mtaAE)Ov0%I2Famz0=SFfmSE Ht-cWe5~LGC delta 49 zcmcZ~a3^4bJmdC_3aN~YmnOF{>M~9A*{GPp$hdm46mtaAb`LP;;^vzymy{;2Q{M;x D$`KNU 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 e64883c2219f..b4c7fa936749 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 @@ -633,6 +633,7 @@ spec: hostIPC: true hostNetwork: true hostPID: true + hostUsers: true hostname: hostnameValue imagePullSecrets: - name: nameValue 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 40183101d54b..91c75f9ad142 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 @@ -1673,7 +1673,8 @@ "setHostnameAsFQDN": true, "os": { "name": "nameValue" - } + }, + "hostUsers": true } }, "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 22d220e26443a05faef16d19045cb774eb54ac24..050e2fbb843acd2e1e57830b099de7a5acfa5091 100644 GIT binary patch delta 51 zcmZ4Bzu13*GSe@=%?r3w7@4N{fN92clRq#;Fzxby@UCoL&vHqLc?A>Wh$a%qy4}H+!mBumAx4)eG|g delta 38 tcmZn(Yz!34wkT%c;^bl~GZbPD$WIY^y-_fgk@4c@a>h$an|)L)SOCy~3qk+@ 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 16229eb1a373..96b92ed1129e 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 @@ -548,6 +548,7 @@ spec: hostIPC: true hostNetwork: true hostPID: true + hostUsers: true hostname: hostnameValue imagePullSecrets: - name: nameValue 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 fd77fc1cb8f4..c2c9618f84c4 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 @@ -1610,7 +1610,8 @@ "setHostnameAsFQDN": true, "os": { "name": "nameValue" - } + }, + "hostUsers": true } } } \ 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 53968607d06806c18726301c9dc207f7cce9c4de..e2fb1454e67ae79e6fabc945d667ca9dbc994461 100644 GIT binary patch delta 36 scmdn(z0Z4s1k(cV%?*qxjEuWB*E6OvGG5vIlj& AC;$Ke delta 38 wcmV+>0NMYzOtnmqA_9#}v#kMS0Rh~Ti2))3x3jDPWdQ-vvl0W+B9rGOQ5^{maR2}S 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 e7f880f3e3c2..7e445f90bba1 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 @@ -586,6 +586,7 @@ spec: hostIPC: true hostNetwork: true hostPID: true + hostUsers: true hostname: hostnameValue imagePullSecrets: - name: nameValue 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 6ad80e5b2e8c..81467a1084f5 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 @@ -1625,7 +1625,8 @@ "setHostnameAsFQDN": true, "os": { "name": "nameValue" - } + }, + "hostUsers": true } }, "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 134b17040bdc74e5e9d790ecd19077fbbdcb27e2..5c9290df7292f386fd518906ab5fcefcf2fc0f96 100644 GIT binary patch delta 43 zcmV+`0M!4oO|?ysCIX2~v)=(^0RqrTlfV^E0lKr^0c8OJ)U!kb(jo(>0s)g2CY*K* B59t5^ delta 39 xcmV+?0NDSvO|ngpCIW^{v)=(^0RqiQlfV^E0k^Z>0c8OJ(X&JY(jt=?CY(7T4>AA% 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 bffe05eb96bd..6d428f16e92f 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 @@ -592,6 +592,7 @@ spec: hostIPC: true hostNetwork: true hostPID: true + hostUsers: true hostname: hostnameValue imagePullSecrets: - name: nameValue 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 c817516bde00..4d91f98f92d6 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 @@ -1626,7 +1626,8 @@ "setHostnameAsFQDN": true, "os": { "name": "nameValue" - } + }, + "hostUsers": true } }, "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 d9c2c3e0008acdfdf00ad146ae6cd75c60b259db..6ee00a1c040261551b58586fbf3fd7f4368ce73b 100644 GIT binary patch delta 40 vcmX@;d&GBwI^*<>8mWwoHzxNn1~Km1{E!jIxw6@v`H~Xz3MR(Ml4>geKvfQ( delta 36 rcmX@&d(d}+I^&d$8mWwoS10!|1~G2m{E!jIxwzS#`I6FP8MPGv2-*$k 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 e9bca491e4fe..ecf17efe773e 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 @@ -602,6 +602,7 @@ spec: hostIPC: true hostNetwork: true hostPID: true + hostUsers: true hostname: hostnameValue imagePullSecrets: - name: nameValue 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 5ff2f516fcb3..293d30354221 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 @@ -1627,7 +1627,8 @@ "setHostnameAsFQDN": true, "os": { "name": "nameValue" - } + }, + "hostUsers": true } } }, 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 50d7695a1fcb0959e0d6666a46549c31b216f381..3a53bd23ddc78242569b0b72788739243116304d 100644 GIT binary patch delta 40 vcmaFm^VVmAI^%(j8mWwo{ge9`gBW*he#i*qT-of-d`XFU1ry_BNwq)#NyZL% delta 36 rcmaFs^U7y}I^*7r8mWwoJ(K$wgBZ7Oe#i*qT-@x=d`W4tj9MT75sMAM 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 a7e826239e2a..be99c823cb2f 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 @@ -592,6 +592,7 @@ spec: hostIPC: true hostNetwork: true hostPID: true + hostUsers: true hostname: hostnameValue imagePullSecrets: - name: nameValue 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 d3d3e028445e..f638b5d91239 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 @@ -41,7 +41,6 @@ type PodSpecApplyConfiguration struct { HostNetwork *bool `json:"hostNetwork,omitempty"` HostPID *bool `json:"hostPID,omitempty"` HostIPC *bool `json:"hostIPC,omitempty"` - HostUsers *bool `json:"hostUsers,omitempty"` ShareProcessNamespace *bool `json:"shareProcessNamespace,omitempty"` SecurityContext *PodSecurityContextApplyConfiguration `json:"securityContext,omitempty"` ImagePullSecrets []LocalObjectReferenceApplyConfiguration `json:"imagePullSecrets,omitempty"` @@ -62,6 +61,7 @@ type PodSpecApplyConfiguration struct { TopologySpreadConstraints []TopologySpreadConstraintApplyConfiguration `json:"topologySpreadConstraints,omitempty"` SetHostnameAsFQDN *bool `json:"setHostnameAsFQDN,omitempty"` OS *PodOSApplyConfiguration `json:"os,omitempty"` + HostUsers *bool `json:"hostUsers,omitempty"` } // PodSpecApplyConfiguration constructs an declarative configuration of the PodSpec type for use with @@ -208,14 +208,6 @@ func (b *PodSpecApplyConfiguration) WithHostNetwork(value bool) *PodSpecApplyCon return b } -// WithHostUsers sets the HostUsers 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 HostUsers field is set to the value of the last call. -func (b *PodSpecApplyConfiguration) WithHostUsers(value *bool) *PodSpecApplyConfiguration { - b.HostUsers = value - return b -} - // WithHostPID sets the HostPID 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 HostPID field is set to the value of the last call. @@ -416,3 +408,11 @@ func (b *PodSpecApplyConfiguration) WithOS(value *PodOSApplyConfiguration) *PodS b.OS = value return b } + +// WithHostUsers sets the HostUsers 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 HostUsers field is set to the value of the last call. +func (b *PodSpecApplyConfiguration) WithHostUsers(value bool) *PodSpecApplyConfiguration { + b.HostUsers = &value + return b +} diff --git a/staging/src/k8s.io/client-go/applyconfigurations/internal/internal.go b/staging/src/k8s.io/client-go/applyconfigurations/internal/internal.go index fd65afb173a8..000803828661 100644 --- a/staging/src/k8s.io/client-go/applyconfigurations/internal/internal.go +++ b/staging/src/k8s.io/client-go/applyconfigurations/internal/internal.go @@ -5762,6 +5762,9 @@ var schemaYAML = typed.YAMLObject(`types: - name: hostPID type: scalar: boolean + - name: hostUsers + type: + scalar: boolean - name: hostname type: scalar: string