From 3b13e9445a3bf86c94781c898f224e6690399178 Mon Sep 17 00:00:00 2001 From: sanposhiho <44139130+sanposhiho@users.noreply.github.com> Date: Wed, 23 Feb 2022 21:11:59 +0900 Subject: [PATCH] Add MinDomains API to TopologySpreadConstraints field --- api/openapi-spec/swagger.json | 9 +- api/openapi-spec/v3/api__v1_openapi.json | 9 +- .../v3/apis__apps__v1_openapi.json | 9 +- .../v3/apis__batch__v1_openapi.json | 9 +- .../v3/apis__batch__v1beta1_openapi.json | 9 +- pkg/api/pod/util.go | 29 + pkg/api/pod/util_test.go | 168 ++ pkg/apis/core/types.go | 41 +- pkg/apis/core/v1/defaults.go | 9 +- pkg/apis/core/v1/zz_generated.conversion.go | 2 + pkg/apis/core/validation/validation.go | 17 + pkg/apis/core/validation/validation_test.go | 125 +- pkg/apis/core/zz_generated.deepcopy.go | 5 + pkg/features/kube_features.go | 8 + pkg/generated/openapi/zz_generated.openapi.go | 11 +- .../default_preemption_test.go | 6 +- .../framework/plugins/feature/feature.go | 13 +- .../plugins/podtopologyspread/common.go | 14 +- .../plugins/podtopologyspread/filtering.go | 2 +- .../podtopologyspread/filtering_test.go | 39 +- .../plugins/podtopologyspread/plugin.go | 27 +- .../plugins/podtopologyspread/scoring.go | 2 +- .../plugins/podtopologyspread/scoring_test.go | 20 +- pkg/scheduler/framework/plugins/registry.go | 13 +- pkg/scheduler/scheduler_test.go | 6 +- .../src/k8s.io/api/core/v1/generated.pb.go | 1814 +++++++++-------- .../src/k8s.io/api/core/v1/generated.proto | 42 +- staging/src/k8s.io/api/core/v1/types.go | 41 +- .../core/v1/types_swagger_doc_generated.go | 5 +- .../api/core/v1/zz_generated.deepcopy.go | 5 + .../api/testdata/HEAD/apps.v1.DaemonSet.json | 3 +- .../api/testdata/HEAD/apps.v1.DaemonSet.pb | Bin 9875 -> 9877 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 9888 -> 9890 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 9805 -> 9807 bytes .../api/testdata/HEAD/apps.v1.ReplicaSet.yaml | 1 + .../testdata/HEAD/apps.v1.StatefulSet.json | 3 +- .../api/testdata/HEAD/apps.v1.StatefulSet.pb | Bin 10778 -> 10780 bytes .../testdata/HEAD/apps.v1.StatefulSet.yaml | 1 + .../HEAD/apps.v1beta1.Deployment.json | 3 +- .../testdata/HEAD/apps.v1beta1.Deployment.pb | Bin 9897 -> 9899 bytes .../HEAD/apps.v1beta1.Deployment.yaml | 1 + .../HEAD/apps.v1beta1.StatefulSet.json | 3 +- .../testdata/HEAD/apps.v1beta1.StatefulSet.pb | Bin 10783 -> 10785 bytes .../HEAD/apps.v1beta1.StatefulSet.yaml | 1 + .../testdata/HEAD/apps.v1beta2.DaemonSet.json | 3 +- .../testdata/HEAD/apps.v1beta2.DaemonSet.pb | Bin 9880 -> 9882 bytes .../testdata/HEAD/apps.v1beta2.DaemonSet.yaml | 1 + .../HEAD/apps.v1beta2.Deployment.json | 3 +- .../testdata/HEAD/apps.v1beta2.Deployment.pb | Bin 9893 -> 9895 bytes .../HEAD/apps.v1beta2.Deployment.yaml | 1 + .../HEAD/apps.v1beta2.ReplicaSet.json | 3 +- .../testdata/HEAD/apps.v1beta2.ReplicaSet.pb | Bin 9810 -> 9812 bytes .../HEAD/apps.v1beta2.ReplicaSet.yaml | 1 + .../HEAD/apps.v1beta2.StatefulSet.json | 3 +- .../testdata/HEAD/apps.v1beta2.StatefulSet.pb | Bin 10783 -> 10785 bytes .../HEAD/apps.v1beta2.StatefulSet.yaml | 1 + .../api/testdata/HEAD/batch.v1.CronJob.json | 3 +- .../api/testdata/HEAD/batch.v1.CronJob.pb | Bin 10312 -> 10314 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 9913 -> 9915 bytes .../api/testdata/HEAD/batch.v1.Job.yaml | 1 + .../testdata/HEAD/batch.v1beta1.CronJob.json | 3 +- .../testdata/HEAD/batch.v1beta1.CronJob.pb | Bin 10317 -> 10319 bytes .../testdata/HEAD/batch.v1beta1.CronJob.yaml | 1 + .../HEAD/batch.v1beta1.JobTemplate.json | 3 +- .../HEAD/batch.v1beta1.JobTemplate.pb | Bin 10144 -> 10146 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 10333 -> 10335 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 9641 -> 9643 bytes .../testdata/HEAD/core.v1.PodTemplate.yaml | 1 + .../HEAD/core.v1.ReplicationController.json | 3 +- .../HEAD/core.v1.ReplicationController.pb | Bin 9763 -> 9765 bytes .../HEAD/core.v1.ReplicationController.yaml | 1 + .../HEAD/extensions.v1beta1.DaemonSet.json | 3 +- .../HEAD/extensions.v1beta1.DaemonSet.pb | Bin 9888 -> 9890 bytes .../HEAD/extensions.v1beta1.DaemonSet.yaml | 1 + .../HEAD/extensions.v1beta1.Deployment.json | 3 +- .../HEAD/extensions.v1beta1.Deployment.pb | Bin 9903 -> 9905 bytes .../HEAD/extensions.v1beta1.Deployment.yaml | 1 + .../HEAD/extensions.v1beta1.ReplicaSet.json | 3 +- .../HEAD/extensions.v1beta1.ReplicaSet.pb | Bin 9816 -> 9818 bytes .../HEAD/extensions.v1beta1.ReplicaSet.yaml | 1 + .../core/v1/topologyspreadconstraint.go | 9 + .../applyconfigurations/internal/internal.go | 3 + 92 files changed, 1576 insertions(+), 1025 deletions(-) diff --git a/api/openapi-spec/swagger.json b/api/openapi-spec/swagger.json index 1e714c034f4..337ff9b09d9 100644 --- a/api/openapi-spec/swagger.json +++ b/api/openapi-spec/swagger.json @@ -10524,12 +10524,17 @@ "description": "LabelSelector is used to find matching pods. Pods that match this label selector are counted to determine the number of pods in their corresponding topology domain." }, "maxSkew": { - "description": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 1/1/0: | zone1 | zone2 | zone3 | | P | P | | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 1/1/1; scheduling it onto zone1(zone2) would make the ActualSkew(2-0) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.", + "description": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. | zone1 | zone2 | zone3 | | P P | P P | P | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.", + "format": "int32", + "type": "integer" + }, + "minDomains": { + "description": "MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats \"global minimum\" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule.\n\nFor example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | | P P | P P | P P | The number of domains is less than 5(MinDomains), so \"global minimum\" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew.\n\nThis is an alpha field and requires enabling MinDomainsInPodTopologySpread feature gate.", "format": "int32", "type": "integer" }, "topologyKey": { - "description": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a \"bucket\", and try to put balanced number of pods into each bucket. It's a required field.", + "description": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a \"bucket\", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes match the node selector. e.g. If TopologyKey is \"kubernetes.io/hostname\", each Node is a domain of that topology. And, if TopologyKey is \"topology.kubernetes.io/zone\", each zone is a domain of that topology. It's a required field.", "type": "string" }, "whenUnsatisfiable": { diff --git a/api/openapi-spec/v3/api__v1_openapi.json b/api/openapi-spec/v3/api__v1_openapi.json index ea82feb380d..b8b9725e99a 100644 --- a/api/openapi-spec/v3/api__v1_openapi.json +++ b/api/openapi-spec/v3/api__v1_openapi.json @@ -6226,13 +6226,18 @@ }, "maxSkew": { "default": 0, - "description": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 1/1/0: | zone1 | zone2 | zone3 | | P | P | | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 1/1/1; scheduling it onto zone1(zone2) would make the ActualSkew(2-0) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.", + "description": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. | zone1 | zone2 | zone3 | | P P | P P | P | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.", + "format": "int32", + "type": "integer" + }, + "minDomains": { + "description": "MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats \"global minimum\" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule.\n\nFor example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | | P P | P P | P P | The number of domains is less than 5(MinDomains), so \"global minimum\" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew.\n\nThis is an alpha field and requires enabling MinDomainsInPodTopologySpread feature gate.", "format": "int32", "type": "integer" }, "topologyKey": { "default": "", - "description": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a \"bucket\", and try to put balanced number of pods into each bucket. It's a required field.", + "description": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a \"bucket\", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes match the node selector. e.g. If TopologyKey is \"kubernetes.io/hostname\", each Node is a domain of that topology. And, if TopologyKey is \"topology.kubernetes.io/zone\", each zone is a domain of that topology. It's a required field.", "type": "string" }, "whenUnsatisfiable": { diff --git a/api/openapi-spec/v3/apis__apps__v1_openapi.json b/api/openapi-spec/v3/apis__apps__v1_openapi.json index ac57c66fdd2..18b397d7570 100644 --- a/api/openapi-spec/v3/apis__apps__v1_openapi.json +++ b/api/openapi-spec/v3/apis__apps__v1_openapi.json @@ -3739,13 +3739,18 @@ }, "maxSkew": { "default": 0, - "description": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 1/1/0: | zone1 | zone2 | zone3 | | P | P | | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 1/1/1; scheduling it onto zone1(zone2) would make the ActualSkew(2-0) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.", + "description": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. | zone1 | zone2 | zone3 | | P P | P P | P | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.", + "format": "int32", + "type": "integer" + }, + "minDomains": { + "description": "MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats \"global minimum\" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule.\n\nFor example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | | P P | P P | P P | The number of domains is less than 5(MinDomains), so \"global minimum\" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew.\n\nThis is an alpha field and requires enabling MinDomainsInPodTopologySpread feature gate.", "format": "int32", "type": "integer" }, "topologyKey": { "default": "", - "description": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a \"bucket\", and try to put balanced number of pods into each bucket. It's a required field.", + "description": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a \"bucket\", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes match the node selector. e.g. If TopologyKey is \"kubernetes.io/hostname\", each Node is a domain of that topology. And, if TopologyKey is \"topology.kubernetes.io/zone\", each zone is a domain of that topology. It's a required field.", "type": "string" }, "whenUnsatisfiable": { diff --git a/api/openapi-spec/v3/apis__batch__v1_openapi.json b/api/openapi-spec/v3/apis__batch__v1_openapi.json index ee06995acde..1d30c68ce9e 100644 --- a/api/openapi-spec/v3/apis__batch__v1_openapi.json +++ b/api/openapi-spec/v3/apis__batch__v1_openapi.json @@ -2965,13 +2965,18 @@ }, "maxSkew": { "default": 0, - "description": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 1/1/0: | zone1 | zone2 | zone3 | | P | P | | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 1/1/1; scheduling it onto zone1(zone2) would make the ActualSkew(2-0) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.", + "description": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. | zone1 | zone2 | zone3 | | P P | P P | P | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.", + "format": "int32", + "type": "integer" + }, + "minDomains": { + "description": "MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats \"global minimum\" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule.\n\nFor example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | | P P | P P | P P | The number of domains is less than 5(MinDomains), so \"global minimum\" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew.\n\nThis is an alpha field and requires enabling MinDomainsInPodTopologySpread feature gate.", "format": "int32", "type": "integer" }, "topologyKey": { "default": "", - "description": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a \"bucket\", and try to put balanced number of pods into each bucket. It's a required field.", + "description": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a \"bucket\", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes match the node selector. e.g. If TopologyKey is \"kubernetes.io/hostname\", each Node is a domain of that topology. And, if TopologyKey is \"topology.kubernetes.io/zone\", each zone is a domain of that topology. It's a required field.", "type": "string" }, "whenUnsatisfiable": { diff --git a/api/openapi-spec/v3/apis__batch__v1beta1_openapi.json b/api/openapi-spec/v3/apis__batch__v1beta1_openapi.json index ca8765a2635..294ecb2a171 100644 --- a/api/openapi-spec/v3/apis__batch__v1beta1_openapi.json +++ b/api/openapi-spec/v3/apis__batch__v1beta1_openapi.json @@ -2767,13 +2767,18 @@ }, "maxSkew": { "default": 0, - "description": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 1/1/0: | zone1 | zone2 | zone3 | | P | P | | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 1/1/1; scheduling it onto zone1(zone2) would make the ActualSkew(2-0) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.", + "description": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. | zone1 | zone2 | zone3 | | P P | P P | P | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.", + "format": "int32", + "type": "integer" + }, + "minDomains": { + "description": "MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats \"global minimum\" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule.\n\nFor example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | | P P | P P | P P | The number of domains is less than 5(MinDomains), so \"global minimum\" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew.\n\nThis is an alpha field and requires enabling MinDomainsInPodTopologySpread feature gate.", "format": "int32", "type": "integer" }, "topologyKey": { "default": "", - "description": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a \"bucket\", and try to put balanced number of pods into each bucket. It's a required field.", + "description": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a \"bucket\", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes match the node selector. e.g. If TopologyKey is \"kubernetes.io/hostname\", each Node is a domain of that topology. And, if TopologyKey is \"topology.kubernetes.io/zone\", each zone is a domain of that topology. It's a required field.", "type": "string" }, "whenUnsatisfiable": { diff --git a/pkg/api/pod/util.go b/pkg/api/pod/util.go index ff7d8e231e4..85abdc1bc74 100644 --- a/pkg/api/pod/util.go +++ b/pkg/api/pod/util.go @@ -583,6 +583,35 @@ func dropDisabledFields( if !utilfeature.DefaultFeatureGate.Enabled(features.IdentifyPodOS) && !podOSInUse(oldPodSpec) { podSpec.OS = nil } + + dropDisabledTopologySpreadConstraintsFields(podSpec, oldPodSpec) +} + +// dropDisabledTopologySpreadConstraintsFields removes disabled fields from PodSpec related +// to TopologySpreadConstraints only if it is not already used by the old spec. +func dropDisabledTopologySpreadConstraintsFields(podSpec, oldPodSpec *api.PodSpec) { + if !utilfeature.DefaultFeatureGate.Enabled(features.MinDomainsInPodTopologySpread) && + !minDomainsInUse(oldPodSpec) && + podSpec != nil { + for i := range podSpec.TopologySpreadConstraints { + podSpec.TopologySpreadConstraints[i].MinDomains = nil + } + } +} + +// minDomainsInUse returns true if the pod spec is non-nil +// and has non-nil MinDomains field in TopologySpreadConstraints. +func minDomainsInUse(podSpec *api.PodSpec) bool { + if podSpec == nil { + return false + } + + for _, c := range podSpec.TopologySpreadConstraints { + if c.MinDomains != nil { + return true + } + } + return false } // podOSInUse returns true if the pod spec is non-nil and has OS field set diff --git a/pkg/api/pod/util_test.go b/pkg/api/pod/util_test.go index 7082a6426f2..e011da17325 100644 --- a/pkg/api/pod/util_test.go +++ b/pkg/api/pod/util_test.go @@ -33,6 +33,7 @@ import ( featuregatetesting "k8s.io/component-base/featuregate/testing" api "k8s.io/kubernetes/pkg/apis/core" "k8s.io/kubernetes/pkg/features" + "k8s.io/utils/pointer" ) func TestVisitContainers(t *testing.T) { @@ -1519,6 +1520,173 @@ func TestHaveSameExpandedDNSConfig(t *testing.T) { } } +func TestDropDisabledTopologySpreadConstraintsFields(t *testing.T) { + testCases := []struct { + name string + enabled bool + podSpec *api.PodSpec + oldPodSpec *api.PodSpec + wantPodSpec *api.PodSpec + }{ + { + name: "TopologySpreadConstraints is nil", + podSpec: &api.PodSpec{}, + oldPodSpec: &api.PodSpec{}, + wantPodSpec: &api.PodSpec{}, + }, + { + name: "TopologySpreadConstraints is empty", + podSpec: &api.PodSpec{TopologySpreadConstraints: []api.TopologySpreadConstraint{}}, + oldPodSpec: &api.PodSpec{TopologySpreadConstraints: []api.TopologySpreadConstraint{}}, + wantPodSpec: &api.PodSpec{TopologySpreadConstraints: []api.TopologySpreadConstraint{}}, + }, + { + name: "TopologySpreadConstraints is not empty, but all constraints don't have minDomains", + podSpec: &api.PodSpec{TopologySpreadConstraints: []api.TopologySpreadConstraint{ + { + MinDomains: nil, + }, + { + MinDomains: nil, + }, + }}, + oldPodSpec: &api.PodSpec{TopologySpreadConstraints: []api.TopologySpreadConstraint{ + { + MinDomains: nil, + }, + { + MinDomains: nil, + }, + }}, + wantPodSpec: &api.PodSpec{TopologySpreadConstraints: []api.TopologySpreadConstraint{ + { + MinDomains: nil, + }, + { + MinDomains: nil, + }, + }}, + }, + { + name: "one constraint in podSpec has non-empty minDomains, feature gate is disabled " + + "and all constraint in oldPodSpec doesn't have minDomains", + enabled: false, + podSpec: &api.PodSpec{ + TopologySpreadConstraints: []api.TopologySpreadConstraint{ + { + MinDomains: pointer.Int32(2), + }, + { + MinDomains: nil, + }, + }, + }, + oldPodSpec: &api.PodSpec{ + TopologySpreadConstraints: []api.TopologySpreadConstraint{ + { + MinDomains: nil, + }, + { + MinDomains: nil, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + TopologySpreadConstraints: []api.TopologySpreadConstraint{ + { + // cleared. + MinDomains: nil, + }, + { + MinDomains: nil, + }, + }, + }, + }, + { + name: "one constraint in podSpec has non-empty minDomains, feature gate is disabled " + + "and one constraint in oldPodSpec has minDomains", + enabled: false, + podSpec: &api.PodSpec{ + TopologySpreadConstraints: []api.TopologySpreadConstraint{ + { + MinDomains: pointer.Int32(2), + }, + { + MinDomains: nil, + }, + }, + }, + oldPodSpec: &api.PodSpec{ + TopologySpreadConstraints: []api.TopologySpreadConstraint{ + { + MinDomains: pointer.Int32(2), + }, + { + MinDomains: nil, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + TopologySpreadConstraints: []api.TopologySpreadConstraint{ + { + // not cleared. + MinDomains: pointer.Int32(2), + }, + { + MinDomains: nil, + }, + }, + }, + }, + { + name: "one constraint in podSpec has non-empty minDomains, feature gate is enabled" + + "and all constraint in oldPodSpec doesn't have minDomains", + enabled: true, + podSpec: &api.PodSpec{ + TopologySpreadConstraints: []api.TopologySpreadConstraint{ + { + MinDomains: pointer.Int32(2), + }, + { + MinDomains: nil, + }, + }, + }, + oldPodSpec: &api.PodSpec{ + TopologySpreadConstraints: []api.TopologySpreadConstraint{ + { + MinDomains: nil, + }, + { + MinDomains: nil, + }, + }, + }, + wantPodSpec: &api.PodSpec{ + TopologySpreadConstraints: []api.TopologySpreadConstraint{ + { + // not cleared. + MinDomains: pointer.Int32(2), + }, + { + MinDomains: nil, + }, + }, + }, + }, + } + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.MinDomainsInPodTopologySpread, tc.enabled)() + dropDisabledFields(tc.podSpec, nil, tc.oldPodSpec, nil) + if diff := cmp.Diff(tc.wantPodSpec, tc.podSpec); diff != "" { + t.Errorf("unexpected pod spec (-want, +got):\n%s", diff) + } + }) + } +} + func TestDropOSField(t *testing.T) { podWithOSField := func() *api.Pod { osField := api.PodOS{Name: "linux"} diff --git a/pkg/apis/core/types.go b/pkg/apis/core/types.go index 17751be7822..65b3d1d55cf 100644 --- a/pkg/apis/core/types.go +++ b/pkg/apis/core/types.go @@ -5605,15 +5605,18 @@ type TopologySpreadConstraint struct { // MaxSkew describes the degree to which pods may be unevenly distributed. // When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference // between the number of matching pods in the target topology and the global minimum. + // The global minimum is the minimum number of matching pods in an eligible domain + // or zero if the number of eligible domains is less than MinDomains. // For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same - // labelSelector spread as 1/1/0: + // labelSelector spread as 2/2/1: + // In this case, the global minimum is 1. // +-------+-------+-------+ // | zone1 | zone2 | zone3 | // +-------+-------+-------+ - // | P | P | | + // | P P | P P | P | // +-------+-------+-------+ - // - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 1/1/1; - // scheduling it onto zone1(zone2) would make the ActualSkew(2-0) on zone1(zone2) + // - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; + // scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) // violate MaxSkew(1). // - if MaxSkew is 2, incoming pod can be scheduled onto any zone. // When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence @@ -5624,6 +5627,10 @@ type TopologySpreadConstraint struct { // and identical values are considered to be in the same topology. // We consider each as a "bucket", and try to put balanced number // of pods into each bucket. + // We define a domain as a particular instance of a topology. + // Also, we define an eligible domain as a domain whose nodes match the node selector. + // e.g. If TopologyKey is "kubernetes.io/hostname", each Node is a domain of that topology. + // And, if TopologyKey is "topology.kubernetes.io/zone", each zone is a domain of that topology. // It's a required field. TopologyKey string // WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy @@ -5653,6 +5660,32 @@ type TopologySpreadConstraint struct { // in their corresponding topology domain. // +optional LabelSelector *metav1.LabelSelector + // MinDomains indicates a minimum number of eligible domains. + // When the number of eligible domains with matching topology keys is less than minDomains, + // Pod Topology Spread treats "global minimum" as 0, and then the calculation of Skew is performed. + // And when the number of eligible domains with matching topology keys equals or greater than minDomains, + // this value has no effect on scheduling. + // As a result, when the number of eligible domains is less than minDomains, + // scheduler won't schedule more than maxSkew Pods to those domains. + // If value is nil, the constraint behaves as if MinDomains is equal to 1. + // Valid values are integers greater than 0. + // When value is not nil, WhenUnsatisfiable must be DoNotSchedule. + // + // For example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same + // labelSelector spread as 2/2/2: + // +-------+-------+-------+ + // | zone1 | zone2 | zone3 | + // +-------+-------+-------+ + // | P P | P P | P P | + // +-------+-------+-------+ + // The number of domains is less than 5(MinDomains), so "global minimum" is treated as 0. + // In this situation, new pod with the same labelSelector cannot be scheduled, + // because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, + // it will violate MaxSkew. + // + // This is an alpha field and requires enabling MinDomainsInPodTopologySpread feature gate. + // +optional + MinDomains *int32 } // These are the built-in errors for PortStatus. diff --git a/pkg/apis/core/v1/defaults.go b/pkg/apis/core/v1/defaults.go index dcf5ea17dd1..0d16a8a1bda 100644 --- a/pkg/apis/core/v1/defaults.go +++ b/pkg/apis/core/v1/defaults.go @@ -22,11 +22,10 @@ import ( v1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/util/intstr" - "k8s.io/kubernetes/pkg/util/parsers" - utilpointer "k8s.io/utils/pointer" - utilfeature "k8s.io/apiserver/pkg/util/feature" "k8s.io/kubernetes/pkg/features" + "k8s.io/kubernetes/pkg/util/parsers" + "k8s.io/utils/pointer" ) func addDefaultingFuncs(scheme *runtime.Scheme) error { @@ -64,7 +63,7 @@ func SetDefaults_ReplicationController(obj *v1.ReplicationController) { } } func SetDefaults_Volume(obj *v1.Volume) { - if utilpointer.AllPtrFieldsNil(&obj.VolumeSource) { + if pointer.AllPtrFieldsNil(&obj.VolumeSource) { obj.VolumeSource = v1.VolumeSource{ EmptyDir: &v1.EmptyDirVolumeSource{}, } @@ -143,7 +142,7 @@ func SetDefaults_Service(obj *v1.Service) { if obj.Spec.Type == v1.ServiceTypeLoadBalancer { if obj.Spec.AllocateLoadBalancerNodePorts == nil { - obj.Spec.AllocateLoadBalancerNodePorts = utilpointer.BoolPtr(true) + obj.Spec.AllocateLoadBalancerNodePorts = pointer.BoolPtr(true) } } } diff --git a/pkg/apis/core/v1/zz_generated.conversion.go b/pkg/apis/core/v1/zz_generated.conversion.go index 8118b1ba302..3f613c62ee9 100644 --- a/pkg/apis/core/v1/zz_generated.conversion.go +++ b/pkg/apis/core/v1/zz_generated.conversion.go @@ -7994,6 +7994,7 @@ func autoConvert_v1_TopologySpreadConstraint_To_core_TopologySpreadConstraint(in out.TopologyKey = in.TopologyKey out.WhenUnsatisfiable = core.UnsatisfiableConstraintAction(in.WhenUnsatisfiable) out.LabelSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.LabelSelector)) + out.MinDomains = (*int32)(unsafe.Pointer(in.MinDomains)) return nil } @@ -8007,6 +8008,7 @@ func autoConvert_core_TopologySpreadConstraint_To_v1_TopologySpreadConstraint(in out.TopologyKey = in.TopologyKey out.WhenUnsatisfiable = v1.UnsatisfiableConstraintAction(in.WhenUnsatisfiable) out.LabelSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.LabelSelector)) + out.MinDomains = (*int32)(unsafe.Pointer(in.MinDomains)) return nil } diff --git a/pkg/apis/core/validation/validation.go b/pkg/apis/core/validation/validation.go index 38737542c40..6e2af9cf930 100644 --- a/pkg/apis/core/validation/validation.go +++ b/pkg/apis/core/validation/validation.go @@ -6528,6 +6528,7 @@ func validateTopologySpreadConstraints(constraints []core.TopologySpreadConstrai if err := ValidateSpreadConstraintNotRepeat(subFldPath.Child("{topologyKey, whenUnsatisfiable}"), constraint, constraints[i+1:]); err != nil { allErrs = append(allErrs, err) } + allErrs = append(allErrs, validateMinDomains(subFldPath.Child("minDomains"), constraint.MinDomains, constraint.WhenUnsatisfiable)...) } return allErrs @@ -6541,6 +6542,22 @@ func ValidateMaxSkew(fldPath *field.Path, maxSkew int32) *field.Error { return nil } +// validateMinDomains tests that the argument is a valid MinDomains. +func validateMinDomains(fldPath *field.Path, minDomains *int32, action core.UnsatisfiableConstraintAction) field.ErrorList { + if minDomains == nil { + return nil + } + var allErrs field.ErrorList + if *minDomains <= 0 { + allErrs = append(allErrs, field.Invalid(fldPath, minDomains, isNotPositiveErrorMsg)) + } + // When MinDomains is non-nil, whenUnsatisfiable must be DoNotSchedule. + if action != core.DoNotSchedule { + allErrs = append(allErrs, field.Invalid(fldPath, minDomains, fmt.Sprintf("can only use minDomains if whenUnsatisfiable=%s, not %s", string(core.DoNotSchedule), string(action)))) + } + return allErrs +} + // ValidateTopologyKey tests that the argument is a valid TopologyKey. func ValidateTopologyKey(fldPath *field.Path, topologyKey string) *field.Error { if len(topologyKey) == 0 { diff --git a/pkg/apis/core/validation/validation_test.go b/pkg/apis/core/validation/validation_test.go index 788888f8b44..5e609e7e6a1 100644 --- a/pkg/apis/core/validation/validation_test.go +++ b/pkg/apis/core/validation/validation_test.go @@ -43,6 +43,7 @@ import ( "k8s.io/kubernetes/pkg/apis/core" "k8s.io/kubernetes/pkg/capabilities" "k8s.io/kubernetes/pkg/features" + "k8s.io/utils/pointer" utilpointer "k8s.io/utils/pointer" ) @@ -18804,57 +18805,115 @@ func TestAnyDataSource(t *testing.T) { } func TestValidateTopologySpreadConstraints(t *testing.T) { + fieldPath := field.NewPath("field") + subFldPath0 := fieldPath.Index(0) + fieldPathMinDomains := subFldPath0.Child("minDomains") + fieldPathMaxSkew := subFldPath0.Child("maxSkew") + fieldPathTopologyKey := subFldPath0.Child("topologyKey") + fieldPathWhenUnsatisfiable := subFldPath0.Child("whenUnsatisfiable") + fieldPathTopologyKeyAndWhenUnsatisfiable := subFldPath0.Child("{topologyKey, whenUnsatisfiable}") testCases := []struct { - name string - constraints []core.TopologySpreadConstraint - errtype field.ErrorType - errfield string + name string + constraints []core.TopologySpreadConstraint + wantFieldErrors field.ErrorList }{ { name: "all required fields ok", constraints: []core.TopologySpreadConstraint{ - {MaxSkew: 1, TopologyKey: "k8s.io/zone", WhenUnsatisfiable: core.DoNotSchedule}, + { + MaxSkew: 1, + TopologyKey: "k8s.io/zone", + WhenUnsatisfiable: core.DoNotSchedule, + MinDomains: pointer.Int32(3), + }, }, + wantFieldErrors: field.ErrorList{}, }, { name: "missing MaxSkew", constraints: []core.TopologySpreadConstraint{ {TopologyKey: "k8s.io/zone", WhenUnsatisfiable: core.DoNotSchedule}, }, - errtype: field.ErrorTypeInvalid, - errfield: "maxSkew", + wantFieldErrors: []*field.Error{field.Invalid(fieldPathMaxSkew, int32(0), isNotPositiveErrorMsg)}, }, { - name: "invalid MaxSkew", + name: "negative MaxSkew", constraints: []core.TopologySpreadConstraint{ - {MaxSkew: 0, TopologyKey: "k8s.io/zone", WhenUnsatisfiable: core.DoNotSchedule}, + {MaxSkew: -1, TopologyKey: "k8s.io/zone", WhenUnsatisfiable: core.DoNotSchedule}, + }, + wantFieldErrors: []*field.Error{field.Invalid(fieldPathMaxSkew, int32(-1), isNotPositiveErrorMsg)}, + }, + { + name: "can use MinDomains with ScheduleAnyway, when MinDomains = nil", + constraints: []core.TopologySpreadConstraint{ + { + MaxSkew: 1, + TopologyKey: "k8s.io/zone", + WhenUnsatisfiable: core.ScheduleAnyway, + MinDomains: nil, + }, + }, + wantFieldErrors: field.ErrorList{}, + }, + { + name: "negative minDomains is invalid", + constraints: []core.TopologySpreadConstraint{ + { + MaxSkew: 1, + TopologyKey: "k8s.io/zone", + WhenUnsatisfiable: core.DoNotSchedule, + MinDomains: pointer.Int32(-1), + }, + }, + wantFieldErrors: []*field.Error{field.Invalid(fieldPathMinDomains, pointer.Int32(-1), isNotPositiveErrorMsg)}, + }, + { + name: "cannot use non-nil MinDomains with ScheduleAnyway", + constraints: []core.TopologySpreadConstraint{ + { + MaxSkew: 1, + TopologyKey: "k8s.io/zone", + WhenUnsatisfiable: core.ScheduleAnyway, + MinDomains: pointer.Int32(10), + }, + }, + wantFieldErrors: []*field.Error{field.Invalid(fieldPathMinDomains, pointer.Int32(10), fmt.Sprintf("can only use minDomains if whenUnsatisfiable=%s, not %s", string(core.DoNotSchedule), string(core.ScheduleAnyway)))}, + }, + { + name: "use negative MinDomains with ScheduleAnyway(invalid)", + constraints: []core.TopologySpreadConstraint{ + { + MaxSkew: 1, + TopologyKey: "k8s.io/zone", + WhenUnsatisfiable: core.ScheduleAnyway, + MinDomains: pointer.Int32(-1), + }, + }, + wantFieldErrors: []*field.Error{ + field.Invalid(fieldPathMinDomains, pointer.Int32(-1), isNotPositiveErrorMsg), + field.Invalid(fieldPathMinDomains, pointer.Int32(-1), fmt.Sprintf("can only use minDomains if whenUnsatisfiable=%s, not %s", string(core.DoNotSchedule), string(core.ScheduleAnyway))), }, - errtype: field.ErrorTypeInvalid, - errfield: "maxSkew", }, { name: "missing TopologyKey", constraints: []core.TopologySpreadConstraint{ {MaxSkew: 1, WhenUnsatisfiable: core.DoNotSchedule}, }, - errtype: field.ErrorTypeRequired, - errfield: "topologyKey", + wantFieldErrors: []*field.Error{field.Required(fieldPathTopologyKey, "can not be empty")}, }, { name: "missing scheduling mode", constraints: []core.TopologySpreadConstraint{ {MaxSkew: 1, TopologyKey: "k8s.io/zone"}, }, - errtype: field.ErrorTypeNotSupported, - errfield: "whenUnsatisfiable", + wantFieldErrors: []*field.Error{field.NotSupported(fieldPathWhenUnsatisfiable, core.UnsatisfiableConstraintAction(""), supportedScheduleActions.List())}, }, { name: "unsupported scheduling mode", constraints: []core.TopologySpreadConstraint{ {MaxSkew: 1, TopologyKey: "k8s.io/zone", WhenUnsatisfiable: core.UnsatisfiableConstraintAction("N/A")}, }, - errtype: field.ErrorTypeNotSupported, - errfield: "whenUnsatisfiable", + wantFieldErrors: []*field.Error{field.NotSupported(fieldPathWhenUnsatisfiable, core.UnsatisfiableConstraintAction("N/A"), supportedScheduleActions.List())}, }, { name: "multiple constraints ok with all required fields", @@ -18862,15 +18921,15 @@ func TestValidateTopologySpreadConstraints(t *testing.T) { {MaxSkew: 1, TopologyKey: "k8s.io/zone", WhenUnsatisfiable: core.DoNotSchedule}, {MaxSkew: 2, TopologyKey: "k8s.io/node", WhenUnsatisfiable: core.ScheduleAnyway}, }, + wantFieldErrors: field.ErrorList{}, }, { name: "multiple constraints missing TopologyKey on partial ones", constraints: []core.TopologySpreadConstraint{ - {MaxSkew: 1, TopologyKey: "k8s.io/zone", WhenUnsatisfiable: core.DoNotSchedule}, - {MaxSkew: 2, WhenUnsatisfiable: core.ScheduleAnyway}, + {MaxSkew: 1, WhenUnsatisfiable: core.ScheduleAnyway}, + {MaxSkew: 2, TopologyKey: "k8s.io/zone", WhenUnsatisfiable: core.DoNotSchedule}, }, - errtype: field.ErrorTypeRequired, - errfield: "topologyKey", + wantFieldErrors: []*field.Error{field.Required(fieldPathTopologyKey, "can not be empty")}, }, { name: "duplicate constraints", @@ -18878,25 +18937,19 @@ func TestValidateTopologySpreadConstraints(t *testing.T) { {MaxSkew: 1, TopologyKey: "k8s.io/zone", WhenUnsatisfiable: core.DoNotSchedule}, {MaxSkew: 2, TopologyKey: "k8s.io/zone", WhenUnsatisfiable: core.DoNotSchedule}, }, - errtype: field.ErrorTypeDuplicate, - errfield: "{topologyKey, whenUnsatisfiable}", + wantFieldErrors: []*field.Error{ + field.Duplicate(fieldPathTopologyKeyAndWhenUnsatisfiable, fmt.Sprintf("{%v, %v}", "k8s.io/zone", core.DoNotSchedule)), + }, }, } - for i, tc := range testCases { - errs := validateTopologySpreadConstraints(tc.constraints, field.NewPath("field")) - - if len(errs) > 0 && tc.errtype == "" { - t.Errorf("[%d: %q] unexpected error(s): %v", i, tc.name, errs) - } else if len(errs) == 0 && tc.errtype != "" { - t.Errorf("[%d: %q] expected error type %v", i, tc.name, tc.errtype) - } else if len(errs) >= 1 { - if errs[0].Type != tc.errtype { - t.Errorf("[%d: %q] expected error type %v, got %v", i, tc.name, tc.errtype, errs[0].Type) - } else if !strings.HasSuffix(errs[0].Field, "."+tc.errfield) { - t.Errorf("[%d: %q] expected error on field %q, got %q", i, tc.name, tc.errfield, errs[0].Field) + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + errs := validateTopologySpreadConstraints(tc.constraints, fieldPath) + if diff := cmp.Diff(tc.wantFieldErrors, errs); diff != "" { + t.Errorf("unexpected field errors (-want, +got):\n%s", diff) } - } + }) } } diff --git a/pkg/apis/core/zz_generated.deepcopy.go b/pkg/apis/core/zz_generated.deepcopy.go index 38f7d5cd8ca..6063cbd7398 100644 --- a/pkg/apis/core/zz_generated.deepcopy.go +++ b/pkg/apis/core/zz_generated.deepcopy.go @@ -5629,6 +5629,11 @@ func (in *TopologySpreadConstraint) DeepCopyInto(out *TopologySpreadConstraint) *out = new(v1.LabelSelector) (*in).DeepCopyInto(*out) } + if in.MinDomains != nil { + in, out := &in.MinDomains, &out.MinDomains + *out = new(int32) + **out = **in + } return } diff --git a/pkg/features/kube_features.go b/pkg/features/kube_features.go index cbb35119c22..fdb0cdb7fde 100644 --- a/pkg/features/kube_features.go +++ b/pkg/features/kube_features.go @@ -826,6 +826,13 @@ const ( // // Stop auto-generation of secret-based service account tokens. LegacyServiceAccountTokenNoAutoGeneration featuregate.Feature = "LegacyServiceAccountTokenNoAutoGeneration" + + // owner: @sanposhiho + // kep: http://kep.k8s.io/3022 + // alpha: v1.24 + // + // Enable MinDomains in Pod Topology Spread. + MinDomainsInPodTopologySpread featuregate.Feature = "MinDomainsInPodTopologySpread" ) func init() { @@ -947,6 +954,7 @@ var defaultKubernetesFeatureGates = map[featuregate.Feature]featuregate.FeatureS RecoverVolumeExpansionFailure: {Default: false, PreRelease: featuregate.Alpha}, GRPCContainerProbe: {Default: false, PreRelease: featuregate.Alpha}, LegacyServiceAccountTokenNoAutoGeneration: {Default: true, PreRelease: featuregate.Beta}, + MinDomainsInPodTopologySpread: {Default: false, PreRelease: featuregate.Alpha}, // inherited features from generic apiserver, relisted here to get a conflict if it is changed // unintentionally on either side: diff --git a/pkg/generated/openapi/zz_generated.openapi.go b/pkg/generated/openapi/zz_generated.openapi.go index fc6a2bdb727..a45aca1f753 100644 --- a/pkg/generated/openapi/zz_generated.openapi.go +++ b/pkg/generated/openapi/zz_generated.openapi.go @@ -25362,7 +25362,7 @@ func schema_k8sio_api_core_v1_TopologySpreadConstraint(ref common.ReferenceCallb Properties: map[string]spec.Schema{ "maxSkew": { SchemaProps: spec.SchemaProps{ - Description: "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 1/1/0: | zone1 | zone2 | zone3 | | P | P | | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 1/1/1; scheduling it onto zone1(zone2) would make the ActualSkew(2-0) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.", + Description: "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. | zone1 | zone2 | zone3 | | P P | P P | P | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.", Default: 0, Type: []string{"integer"}, Format: "int32", @@ -25370,7 +25370,7 @@ func schema_k8sio_api_core_v1_TopologySpreadConstraint(ref common.ReferenceCallb }, "topologyKey": { SchemaProps: spec.SchemaProps{ - Description: "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a \"bucket\", and try to put balanced number of pods into each bucket. It's a required field.", + Description: "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a \"bucket\", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes match the node selector. e.g. If TopologyKey is \"kubernetes.io/hostname\", each Node is a domain of that topology. And, if TopologyKey is \"topology.kubernetes.io/zone\", each zone is a domain of that topology. It's a required field.", Default: "", Type: []string{"string"}, Format: "", @@ -25390,6 +25390,13 @@ func schema_k8sio_api_core_v1_TopologySpreadConstraint(ref common.ReferenceCallb Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.LabelSelector"), }, }, + "minDomains": { + SchemaProps: spec.SchemaProps{ + Description: "MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats \"global minimum\" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule.\n\nFor example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | | P P | P P | P P | The number of domains is less than 5(MinDomains), so \"global minimum\" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew.\n\nThis is an alpha field and requires enabling MinDomainsInPodTopologySpread feature gate.", + Type: []string{"integer"}, + Format: "int32", + }, + }, }, Required: []string{"maxSkew", "topologyKey", "whenUnsatisfiable"}, }, diff --git a/pkg/scheduler/framework/plugins/defaultpreemption/default_preemption_test.go b/pkg/scheduler/framework/plugins/defaultpreemption/default_preemption_test.go index 691427d1dda..8fddcf4b846 100644 --- a/pkg/scheduler/framework/plugins/defaultpreemption/default_preemption_test.go +++ b/pkg/scheduler/framework/plugins/defaultpreemption/default_preemption_test.go @@ -30,7 +30,6 @@ import ( v1 "k8s.io/api/core/v1" policy "k8s.io/api/policy/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/util/sets" "k8s.io/client-go/informers" @@ -96,6 +95,7 @@ func getDefaultDefaultPreemptionArgs() *config.DefaultPreemptionArgs { } var nodeResourcesFitFunc = frameworkruntime.FactoryAdapter(feature.Features{}, noderesources.NewFit) +var podTopologySpreadFunc = frameworkruntime.FactoryAdapter(feature.Features{}, podtopologyspread.New) // TestPlugin returns Error status when trying to `AddPod` or `RemovePod` on the nodes which have the {k,v} label pair defined on the nodes. type TestPlugin struct { @@ -636,7 +636,7 @@ func TestDryRunPreemption(t *testing.T) { { name: "preemption to resolve pod topology spread filter failure", registerPlugins: []st.RegisterPluginFunc{ - st.RegisterPluginAsExtensions(podtopologyspread.Name, podtopologyspread.New, "PreFilter", "Filter"), + st.RegisterPluginAsExtensions(podtopologyspread.Name, podTopologySpreadFunc, "PreFilter", "Filter"), }, nodeNames: []string{"node-a/zone1", "node-b/zone1", "node-x/zone2"}, testPods: []*v1.Pod{ @@ -1495,7 +1495,7 @@ func TestPreempt(t *testing.T) { st.MakePod().Name("p-x2").UID("p-x2").Namespace(v1.NamespaceDefault).Node("node-x").Label("foo", "").Priority(highPriority).Obj(), }, nodeNames: []string{"node-a/zone1", "node-b/zone1", "node-x/zone2"}, - registerPlugin: st.RegisterPluginAsExtensions(podtopologyspread.Name, podtopologyspread.New, "PreFilter", "Filter"), + registerPlugin: st.RegisterPluginAsExtensions(podtopologyspread.Name, podTopologySpreadFunc, "PreFilter", "Filter"), want: framework.NewPostFilterResultWithNominatedNode("node-b"), expectedPods: []string{"p-b1"}, }, diff --git a/pkg/scheduler/framework/plugins/feature/feature.go b/pkg/scheduler/framework/plugins/feature/feature.go index 6c2b4fb0de2..38ba8a77906 100644 --- a/pkg/scheduler/framework/plugins/feature/feature.go +++ b/pkg/scheduler/framework/plugins/feature/feature.go @@ -20,10 +20,11 @@ package feature // This struct allows us to break the dependency of the plugins on // the internal k8s features pkg. type Features struct { - EnablePodAffinityNamespaceSelector bool - EnablePodDisruptionBudget bool - EnablePodOverhead bool - EnableReadWriteOncePod bool - EnableVolumeCapacityPriority bool - EnableCSIStorageCapacity bool + EnablePodAffinityNamespaceSelector bool + EnablePodDisruptionBudget bool + EnablePodOverhead bool + EnableReadWriteOncePod bool + EnableVolumeCapacityPriority bool + EnableCSIStorageCapacity bool + EnableMinDomainsInPodTopologySpread bool } diff --git a/pkg/scheduler/framework/plugins/podtopologyspread/common.go b/pkg/scheduler/framework/plugins/podtopologyspread/common.go index 2c66b50d1f1..a6cefc89dcc 100644 --- a/pkg/scheduler/framework/plugins/podtopologyspread/common.go +++ b/pkg/scheduler/framework/plugins/podtopologyspread/common.go @@ -36,13 +36,14 @@ type topologySpreadConstraint struct { MaxSkew int32 TopologyKey string Selector labels.Selector + MinDomains int32 } // buildDefaultConstraints builds the constraints for a pod using // .DefaultConstraints and the selectors from the services, replication // controllers, replica sets and stateful sets that match the pod. func (pl *PodTopologySpread) buildDefaultConstraints(p *v1.Pod, action v1.UnsatisfiableConstraintAction) ([]topologySpreadConstraint, error) { - constraints, err := filterTopologySpreadConstraints(pl.defaultConstraints, action) + constraints, err := filterTopologySpreadConstraints(pl.defaultConstraints, action, pl.enableMinDomainsInPodTopologySpread) if err != nil || len(constraints) == 0 { return nil, err } @@ -66,7 +67,7 @@ func nodeLabelsMatchSpreadConstraints(nodeLabels map[string]string, constraints return true } -func filterTopologySpreadConstraints(constraints []v1.TopologySpreadConstraint, action v1.UnsatisfiableConstraintAction) ([]topologySpreadConstraint, error) { +func filterTopologySpreadConstraints(constraints []v1.TopologySpreadConstraint, action v1.UnsatisfiableConstraintAction, enableMinDomainsInPodTopologySpread bool) ([]topologySpreadConstraint, error) { var result []topologySpreadConstraint for _, c := range constraints { if c.WhenUnsatisfiable == action { @@ -74,11 +75,16 @@ func filterTopologySpreadConstraints(constraints []v1.TopologySpreadConstraint, if err != nil { return nil, err } - result = append(result, topologySpreadConstraint{ + tsc := topologySpreadConstraint{ MaxSkew: c.MaxSkew, TopologyKey: c.TopologyKey, Selector: selector, - }) + MinDomains: 1, // if MinDomains is nil, we treat MinDomains as 1. + } + if enableMinDomainsInPodTopologySpread && c.MinDomains != nil { + tsc.MinDomains = *c.MinDomains + } + result = append(result, tsc) } } return result, nil diff --git a/pkg/scheduler/framework/plugins/podtopologyspread/filtering.go b/pkg/scheduler/framework/plugins/podtopologyspread/filtering.go index e4e60642147..703d67d311f 100644 --- a/pkg/scheduler/framework/plugins/podtopologyspread/filtering.go +++ b/pkg/scheduler/framework/plugins/podtopologyspread/filtering.go @@ -201,7 +201,7 @@ func (pl *PodTopologySpread) calPreFilterState(ctx context.Context, pod *v1.Pod) if len(pod.Spec.TopologySpreadConstraints) > 0 { // We have feature gating in APIServer to strip the spec // so don't need to re-check feature gate, just check length of Constraints. - constraints, err = filterTopologySpreadConstraints(pod.Spec.TopologySpreadConstraints, v1.DoNotSchedule) + constraints, err = filterTopologySpreadConstraints(pod.Spec.TopologySpreadConstraints, v1.DoNotSchedule, pl.enableMinDomainsInPodTopologySpread) if err != nil { return nil, fmt.Errorf("obtaining pod's hard topology spread constraints: %w", err) } diff --git a/pkg/scheduler/framework/plugins/podtopologyspread/filtering_test.go b/pkg/scheduler/framework/plugins/podtopologyspread/filtering_test.go index 515af4d983d..c6ebe983d80 100644 --- a/pkg/scheduler/framework/plugins/podtopologyspread/filtering_test.go +++ b/pkg/scheduler/framework/plugins/podtopologyspread/filtering_test.go @@ -29,7 +29,9 @@ import ( "k8s.io/apimachinery/pkg/runtime" "k8s.io/kubernetes/pkg/scheduler/apis/config" "k8s.io/kubernetes/pkg/scheduler/framework" + "k8s.io/kubernetes/pkg/scheduler/framework/plugins/feature" plugintesting "k8s.io/kubernetes/pkg/scheduler/framework/plugins/testing" + frameworkruntime "k8s.io/kubernetes/pkg/scheduler/framework/runtime" "k8s.io/kubernetes/pkg/scheduler/internal/cache" st "k8s.io/kubernetes/pkg/scheduler/testing" ) @@ -45,6 +47,8 @@ var cmpOpts = []cmp.Option{ }), } +var topologySpreadFunc = frameworkruntime.FactoryAdapter(feature.Features{}, New) + func (p *criticalPaths) sort() { if p[0].MatchNum == p[1].MatchNum && p[0].TopologyValue > p[1].TopologyValue { // Swap TopologyValue to make them sorted alphabetically. @@ -81,6 +85,7 @@ func TestPreFilterState(t *testing.T) { MaxSkew: 5, TopologyKey: "zone", Selector: mustConvertLabelSelectorAsSelector(t, st.MakeLabelSelector().Label("foo", "bar").Obj()), + MinDomains: 1, }, }, TpKeyToCriticalPaths: map[string]*criticalPaths{ @@ -116,6 +121,7 @@ func TestPreFilterState(t *testing.T) { MaxSkew: 1, TopologyKey: "zone", Selector: mustConvertLabelSelectorAsSelector(t, fooSelector), + MinDomains: 1, }, }, TpKeyToCriticalPaths: map[string]*criticalPaths{ @@ -153,6 +159,7 @@ func TestPreFilterState(t *testing.T) { MaxSkew: 1, TopologyKey: "zone", Selector: mustConvertLabelSelectorAsSelector(t, fooSelector), + MinDomains: 1, }, }, TpKeyToCriticalPaths: map[string]*criticalPaths{ @@ -189,6 +196,7 @@ func TestPreFilterState(t *testing.T) { MaxSkew: 1, TopologyKey: "zone", Selector: mustConvertLabelSelectorAsSelector(t, fooSelector), + MinDomains: 1, }, }, TpKeyToCriticalPaths: map[string]*criticalPaths{ @@ -227,11 +235,13 @@ func TestPreFilterState(t *testing.T) { MaxSkew: 1, TopologyKey: "zone", Selector: mustConvertLabelSelectorAsSelector(t, fooSelector), + MinDomains: 1, }, { MaxSkew: 1, TopologyKey: "node", Selector: mustConvertLabelSelectorAsSelector(t, fooSelector), + MinDomains: 1, }, }, TpKeyToCriticalPaths: map[string]*criticalPaths{ @@ -276,11 +286,13 @@ func TestPreFilterState(t *testing.T) { MaxSkew: 1, TopologyKey: "zone", Selector: mustConvertLabelSelectorAsSelector(t, fooSelector), + MinDomains: 1, }, { MaxSkew: 1, TopologyKey: "node", Selector: mustConvertLabelSelectorAsSelector(t, fooSelector), + MinDomains: 1, }, }, TpKeyToCriticalPaths: map[string]*criticalPaths{ @@ -317,11 +329,13 @@ func TestPreFilterState(t *testing.T) { MaxSkew: 1, TopologyKey: "zone", Selector: mustConvertLabelSelectorAsSelector(t, fooSelector), + MinDomains: 1, }, { MaxSkew: 1, TopologyKey: "node", Selector: mustConvertLabelSelectorAsSelector(t, barSelector), + MinDomains: 1, }, }, TpKeyToCriticalPaths: map[string]*criticalPaths{ @@ -363,11 +377,13 @@ func TestPreFilterState(t *testing.T) { MaxSkew: 1, TopologyKey: "zone", Selector: mustConvertLabelSelectorAsSelector(t, fooSelector), + MinDomains: 1, }, { MaxSkew: 1, TopologyKey: "node", Selector: mustConvertLabelSelectorAsSelector(t, barSelector), + MinDomains: 1, }, }, TpKeyToCriticalPaths: map[string]*criticalPaths{ @@ -411,11 +427,13 @@ func TestPreFilterState(t *testing.T) { MaxSkew: 1, TopologyKey: "zone", Selector: mustConvertLabelSelectorAsSelector(t, fooSelector), + MinDomains: 1, }, { MaxSkew: 1, TopologyKey: "node", Selector: mustConvertLabelSelectorAsSelector(t, fooSelector), + MinDomains: 1, }, }, TpKeyToCriticalPaths: map[string]*criticalPaths{ @@ -448,11 +466,13 @@ func TestPreFilterState(t *testing.T) { MaxSkew: 3, TopologyKey: "node", Selector: mustConvertLabelSelectorAsSelector(t, st.MakeLabelSelector().Label("foo", "bar").Obj()), + MinDomains: 1, }, { MaxSkew: 5, TopologyKey: "rack", Selector: mustConvertLabelSelectorAsSelector(t, st.MakeLabelSelector().Label("foo", "bar").Obj()), + MinDomains: 1, }, }, TpKeyToCriticalPaths: map[string]*criticalPaths{ @@ -490,6 +510,7 @@ func TestPreFilterState(t *testing.T) { MaxSkew: 1, TopologyKey: "zone", Selector: mustConvertLabelSelectorAsSelector(t, st.MakeLabelSelector().Label("baz", "tar").Obj()), + MinDomains: 1, }, }, TpKeyToCriticalPaths: map[string]*criticalPaths{ @@ -518,7 +539,7 @@ func TestPreFilterState(t *testing.T) { DefaultConstraints: tt.defaultConstraints, DefaultingType: config.ListDefaulting, } - p := plugintesting.SetupPluginWithInformers(ctx, t, New, args, cache.NewSnapshot(tt.existingPods, tt.nodes), tt.objs) + p := plugintesting.SetupPluginWithInformers(ctx, t, topologySpreadFunc, args, cache.NewSnapshot(tt.existingPods, tt.nodes), tt.objs) cs := framework.NewCycleState() if s := p.(*PodTopologySpread).PreFilter(ctx, cs, tt.pod); !s.IsSuccess() { t.Fatal(s.AsError()) @@ -539,6 +560,7 @@ func TestPreFilterStateAddPod(t *testing.T) { MaxSkew: 1, TopologyKey: "node", Selector: mustConvertLabelSelectorAsSelector(t, st.MakeLabelSelector().Exists("foo").Obj()), + MinDomains: 1, } zoneConstraint := nodeConstraint zoneConstraint.TopologyKey = "zone" @@ -763,6 +785,7 @@ func TestPreFilterStateAddPod(t *testing.T) { MaxSkew: 1, TopologyKey: "node", Selector: mustConvertLabelSelectorAsSelector(t, st.MakeLabelSelector().Exists("bar").Obj()), + MinDomains: 1, }, }, TpKeyToCriticalPaths: map[string]*criticalPaths{ @@ -803,6 +826,7 @@ func TestPreFilterStateAddPod(t *testing.T) { MaxSkew: 1, TopologyKey: "node", Selector: mustConvertLabelSelectorAsSelector(t, st.MakeLabelSelector().Exists("bar").Obj()), + MinDomains: 1, }, }, TpKeyToCriticalPaths: map[string]*criticalPaths{ @@ -823,7 +847,7 @@ func TestPreFilterStateAddPod(t *testing.T) { t.Run(tt.name, func(t *testing.T) { ctx := context.Background() snapshot := cache.NewSnapshot(tt.existingPods, tt.nodes) - pl := plugintesting.SetupPlugin(t, New, &config.PodTopologySpreadArgs{DefaultingType: config.ListDefaulting}, snapshot) + pl := plugintesting.SetupPlugin(t, topologySpreadFunc, &config.PodTopologySpreadArgs{DefaultingType: config.ListDefaulting}, snapshot) p := pl.(*PodTopologySpread) cs := framework.NewCycleState() if s := p.PreFilter(ctx, cs, tt.preemptor); !s.IsSuccess() { @@ -852,6 +876,7 @@ func TestPreFilterStateRemovePod(t *testing.T) { MaxSkew: 1, TopologyKey: "node", Selector: mustConvertLabelSelectorAsSelector(t, st.MakeLabelSelector().Exists("foo").Obj()), + MinDomains: 1, } zoneConstraint := nodeConstraint zoneConstraint.TopologyKey = "zone" @@ -1027,7 +1052,7 @@ func TestPreFilterStateRemovePod(t *testing.T) { t.Run(tt.name, func(t *testing.T) { ctx := context.Background() snapshot := cache.NewSnapshot(tt.existingPods, tt.nodes) - pl := plugintesting.SetupPlugin(t, New, &config.PodTopologySpreadArgs{DefaultingType: config.ListDefaulting}, snapshot) + pl := plugintesting.SetupPlugin(t, topologySpreadFunc, &config.PodTopologySpreadArgs{DefaultingType: config.ListDefaulting}, snapshot) p := pl.(*PodTopologySpread) cs := framework.NewCycleState() s := p.PreFilter(ctx, cs, tt.preemptor) @@ -1101,7 +1126,7 @@ func BenchmarkFilter(b *testing.B) { b.Run(tt.name, func(b *testing.B) { existingPods, allNodes, _ := st.MakeNodesAndPodsForEvenPodsSpread(tt.pod.Labels, tt.existingPodsNum, tt.allNodesNum, tt.filteredNodesNum) ctx := context.Background() - pl := plugintesting.SetupPlugin(b, New, &config.PodTopologySpreadArgs{DefaultingType: config.ListDefaulting}, cache.NewSnapshot(existingPods, allNodes)) + pl := plugintesting.SetupPlugin(b, topologySpreadFunc, &config.PodTopologySpreadArgs{DefaultingType: config.ListDefaulting}, cache.NewSnapshot(existingPods, allNodes)) p := pl.(*PodTopologySpread) b.ResetTimer() for i := 0; i < b.N; i++ { @@ -1429,7 +1454,7 @@ func TestSingleConstraint(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { snapshot := cache.NewSnapshot(tt.existingPods, tt.nodes) - pl := plugintesting.SetupPlugin(t, New, &config.PodTopologySpreadArgs{DefaultingType: config.ListDefaulting}, snapshot) + pl := plugintesting.SetupPlugin(t, topologySpreadFunc, &config.PodTopologySpreadArgs{DefaultingType: config.ListDefaulting}, snapshot) p := pl.(*PodTopologySpread) state := framework.NewCycleState() preFilterStatus := p.PreFilter(context.Background(), state, tt.pod) @@ -1656,7 +1681,7 @@ func TestMultipleConstraints(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { snapshot := cache.NewSnapshot(tt.existingPods, tt.nodes) - pl := plugintesting.SetupPlugin(t, New, &config.PodTopologySpreadArgs{DefaultingType: config.ListDefaulting}, snapshot) + pl := plugintesting.SetupPlugin(t, topologySpreadFunc, &config.PodTopologySpreadArgs{DefaultingType: config.ListDefaulting}, snapshot) p := pl.(*PodTopologySpread) state := framework.NewCycleState() preFilterStatus := p.PreFilter(context.Background(), state, tt.pod) @@ -1680,7 +1705,7 @@ func TestPreFilterDisabled(t *testing.T) { nodeInfo := framework.NewNodeInfo() node := v1.Node{} nodeInfo.SetNode(&node) - p := plugintesting.SetupPlugin(t, New, &config.PodTopologySpreadArgs{DefaultingType: config.ListDefaulting}, cache.NewEmptySnapshot()) + p := plugintesting.SetupPlugin(t, topologySpreadFunc, &config.PodTopologySpreadArgs{DefaultingType: config.ListDefaulting}, cache.NewEmptySnapshot()) cycleState := framework.NewCycleState() gotStatus := p.(*PodTopologySpread).Filter(context.Background(), cycleState, pod, nodeInfo) wantStatus := framework.AsStatus(fmt.Errorf(`reading "PreFilterPodTopologySpread" from cycleState: %w`, framework.ErrNotFound)) diff --git a/pkg/scheduler/framework/plugins/podtopologyspread/plugin.go b/pkg/scheduler/framework/plugins/podtopologyspread/plugin.go index 568c1cc77ea..2584bc89a2b 100644 --- a/pkg/scheduler/framework/plugins/podtopologyspread/plugin.go +++ b/pkg/scheduler/framework/plugins/podtopologyspread/plugin.go @@ -28,6 +28,7 @@ import ( "k8s.io/kubernetes/pkg/scheduler/apis/config/validation" "k8s.io/kubernetes/pkg/scheduler/framework" "k8s.io/kubernetes/pkg/scheduler/framework/parallelize" + "k8s.io/kubernetes/pkg/scheduler/framework/plugins/feature" "k8s.io/kubernetes/pkg/scheduler/framework/plugins/names" ) @@ -53,14 +54,15 @@ var systemDefaultConstraints = []v1.TopologySpreadConstraint{ // PodTopologySpread is a plugin that ensures pod's topologySpreadConstraints is satisfied. type PodTopologySpread struct { - systemDefaulted bool - parallelizer parallelize.Parallelizer - defaultConstraints []v1.TopologySpreadConstraint - sharedLister framework.SharedLister - services corelisters.ServiceLister - replicationCtrls corelisters.ReplicationControllerLister - replicaSets appslisters.ReplicaSetLister - statefulSets appslisters.StatefulSetLister + systemDefaulted bool + parallelizer parallelize.Parallelizer + defaultConstraints []v1.TopologySpreadConstraint + sharedLister framework.SharedLister + services corelisters.ServiceLister + replicationCtrls corelisters.ReplicationControllerLister + replicaSets appslisters.ReplicaSetLister + statefulSets appslisters.StatefulSetLister + enableMinDomainsInPodTopologySpread bool } var _ framework.PreFilterPlugin = &PodTopologySpread{} @@ -80,7 +82,7 @@ func (pl *PodTopologySpread) Name() string { } // New initializes a new plugin and returns it. -func New(plArgs runtime.Object, h framework.Handle) (framework.Plugin, error) { +func New(plArgs runtime.Object, h framework.Handle, fts feature.Features) (framework.Plugin, error) { if h.SnapshotSharedLister() == nil { return nil, fmt.Errorf("SnapshotSharedlister is nil") } @@ -92,9 +94,10 @@ func New(plArgs runtime.Object, h framework.Handle) (framework.Plugin, error) { return nil, err } pl := &PodTopologySpread{ - parallelizer: h.Parallelizer(), - sharedLister: h.SnapshotSharedLister(), - defaultConstraints: args.DefaultConstraints, + parallelizer: h.Parallelizer(), + sharedLister: h.SnapshotSharedLister(), + defaultConstraints: args.DefaultConstraints, + enableMinDomainsInPodTopologySpread: fts.EnableMinDomainsInPodTopologySpread, } if args.DefaultingType == config.SystemDefaulting { pl.defaultConstraints = systemDefaultConstraints diff --git a/pkg/scheduler/framework/plugins/podtopologyspread/scoring.go b/pkg/scheduler/framework/plugins/podtopologyspread/scoring.go index 34181560bba..7b71f786b1d 100644 --- a/pkg/scheduler/framework/plugins/podtopologyspread/scoring.go +++ b/pkg/scheduler/framework/plugins/podtopologyspread/scoring.go @@ -59,7 +59,7 @@ func (s *preScoreState) Clone() framework.StateData { func (pl *PodTopologySpread) initPreScoreState(s *preScoreState, pod *v1.Pod, filteredNodes []*v1.Node, requireAllTopologies bool) error { var err error if len(pod.Spec.TopologySpreadConstraints) > 0 { - s.Constraints, err = filterTopologySpreadConstraints(pod.Spec.TopologySpreadConstraints, v1.ScheduleAnyway) + s.Constraints, err = filterTopologySpreadConstraints(pod.Spec.TopologySpreadConstraints, v1.ScheduleAnyway, pl.enableMinDomainsInPodTopologySpread) if err != nil { return fmt.Errorf("obtaining pod's soft topology spread constraints: %w", err) } diff --git a/pkg/scheduler/framework/plugins/podtopologyspread/scoring_test.go b/pkg/scheduler/framework/plugins/podtopologyspread/scoring_test.go index f5c9c84430e..4d6d645b88f 100644 --- a/pkg/scheduler/framework/plugins/podtopologyspread/scoring_test.go +++ b/pkg/scheduler/framework/plugins/podtopologyspread/scoring_test.go @@ -30,6 +30,7 @@ import ( "k8s.io/client-go/kubernetes/fake" "k8s.io/kubernetes/pkg/scheduler/apis/config" "k8s.io/kubernetes/pkg/scheduler/framework" + "k8s.io/kubernetes/pkg/scheduler/framework/plugins/feature" plugintesting "k8s.io/kubernetes/pkg/scheduler/framework/plugins/testing" frameworkruntime "k8s.io/kubernetes/pkg/scheduler/framework/runtime" "k8s.io/kubernetes/pkg/scheduler/internal/cache" @@ -37,6 +38,8 @@ import ( "k8s.io/utils/pointer" ) +var podTopologySpreadFunc = frameworkruntime.FactoryAdapter(feature.Features{}, New) + func TestPreScoreStateEmptyNodes(t *testing.T) { tests := []struct { name string @@ -66,11 +69,13 @@ func TestPreScoreStateEmptyNodes(t *testing.T) { MaxSkew: 1, TopologyKey: "zone", Selector: mustConvertLabelSelectorAsSelector(t, st.MakeLabelSelector().Exists("foo").Obj()), + MinDomains: 1, }, { MaxSkew: 1, TopologyKey: v1.LabelHostname, Selector: mustConvertLabelSelectorAsSelector(t, st.MakeLabelSelector().Exists("foo").Obj()), + MinDomains: 1, }, }, IgnoredNodes: sets.NewString(), @@ -101,11 +106,13 @@ func TestPreScoreStateEmptyNodes(t *testing.T) { MaxSkew: 1, TopologyKey: "zone", Selector: mustConvertLabelSelectorAsSelector(t, st.MakeLabelSelector().Exists("foo").Obj()), + MinDomains: 1, }, { MaxSkew: 1, TopologyKey: v1.LabelHostname, Selector: mustConvertLabelSelectorAsSelector(t, st.MakeLabelSelector().Exists("bar").Obj()), + MinDomains: 1, }, }, IgnoredNodes: sets.NewString("node-x"), @@ -137,11 +144,13 @@ func TestPreScoreStateEmptyNodes(t *testing.T) { MaxSkew: 3, TopologyKey: v1.LabelHostname, Selector: mustConvertLabelSelectorAsSelector(t, st.MakeLabelSelector().Exists("foo").Obj()), + MinDomains: 1, }, { MaxSkew: 5, TopologyKey: v1.LabelTopologyZone, Selector: mustConvertLabelSelectorAsSelector(t, st.MakeLabelSelector().Exists("foo").Obj()), + MinDomains: 1, }, }, IgnoredNodes: sets.NewString(), @@ -175,11 +184,13 @@ func TestPreScoreStateEmptyNodes(t *testing.T) { MaxSkew: 1, TopologyKey: v1.LabelHostname, Selector: mustConvertLabelSelectorAsSelector(t, st.MakeLabelSelector().Exists("foo").Obj()), + MinDomains: 1, }, { MaxSkew: 2, TopologyKey: "planet", Selector: mustConvertLabelSelectorAsSelector(t, st.MakeLabelSelector().Exists("foo").Obj()), + MinDomains: 1, }, }, IgnoredNodes: sets.NewString(), @@ -232,6 +243,7 @@ func TestPreScoreStateEmptyNodes(t *testing.T) { MaxSkew: 2, TopologyKey: "planet", Selector: mustConvertLabelSelectorAsSelector(t, st.MakeLabelSelector().Label("baz", "sup").Obj()), + MinDomains: 1, }, }, IgnoredNodes: sets.NewString(), @@ -253,7 +265,7 @@ func TestPreScoreStateEmptyNodes(t *testing.T) { if err != nil { t.Fatalf("Failed creating framework runtime: %v", err) } - pl, err := New(&tt.config, f) + pl, err := New(&tt.config, f, feature.Features{}) if err != nil { t.Fatalf("Failed creating plugin: %v", err) } @@ -732,7 +744,7 @@ func TestPodTopologySpreadScore(t *testing.T) { allNodes := append([]*v1.Node{}, tt.nodes...) allNodes = append(allNodes, tt.failedNodes...) state := framework.NewCycleState() - pl := plugintesting.SetupPluginWithInformers(ctx, t, New, &config.PodTopologySpreadArgs{DefaultingType: config.SystemDefaulting}, cache.NewSnapshot(tt.existingPods, allNodes), tt.objs) + pl := plugintesting.SetupPluginWithInformers(ctx, t, podTopologySpreadFunc, &config.PodTopologySpreadArgs{DefaultingType: config.SystemDefaulting}, cache.NewSnapshot(tt.existingPods, allNodes), tt.objs) p := pl.(*PodTopologySpread) status := p.PreScore(context.Background(), state, tt.pod, tt.nodes) @@ -802,7 +814,7 @@ func BenchmarkTestPodTopologySpreadScore(b *testing.B) { b.Run(tt.name, func(b *testing.B) { existingPods, allNodes, filteredNodes := st.MakeNodesAndPodsForEvenPodsSpread(tt.pod.Labels, tt.existingPodsNum, tt.allNodesNum, tt.filteredNodesNum) state := framework.NewCycleState() - pl := plugintesting.SetupPlugin(b, New, &config.PodTopologySpreadArgs{DefaultingType: config.ListDefaulting}, cache.NewSnapshot(existingPods, allNodes)) + pl := plugintesting.SetupPlugin(b, podTopologySpreadFunc, &config.PodTopologySpreadArgs{DefaultingType: config.ListDefaulting}, cache.NewSnapshot(existingPods, allNodes)) p := pl.(*PodTopologySpread) status := p.PreScore(context.Background(), state, tt.pod, filteredNodes) @@ -879,7 +891,7 @@ func BenchmarkTestDefaultEvenPodsSpreadPriority(b *testing.B) { if err != nil { b.Fatalf("Failed creating framework runtime: %v", err) } - pl, err := New(&config.PodTopologySpreadArgs{DefaultingType: config.SystemDefaulting}, f) + pl, err := New(&config.PodTopologySpreadArgs{DefaultingType: config.SystemDefaulting}, f, feature.Features{}) if err != nil { b.Fatalf("Failed creating plugin: %v", err) } diff --git a/pkg/scheduler/framework/plugins/registry.go b/pkg/scheduler/framework/plugins/registry.go index 8a536c4713a..793b6c895b0 100644 --- a/pkg/scheduler/framework/plugins/registry.go +++ b/pkg/scheduler/framework/plugins/registry.go @@ -45,11 +45,12 @@ import ( // through the WithFrameworkOutOfTreeRegistry option. func NewInTreeRegistry() runtime.Registry { fts := plfeature.Features{ - EnablePodDisruptionBudget: feature.DefaultFeatureGate.Enabled(features.PodDisruptionBudget), - EnablePodOverhead: feature.DefaultFeatureGate.Enabled(features.PodOverhead), - EnableReadWriteOncePod: feature.DefaultFeatureGate.Enabled(features.ReadWriteOncePod), - EnableVolumeCapacityPriority: feature.DefaultFeatureGate.Enabled(features.VolumeCapacityPriority), - EnableCSIStorageCapacity: feature.DefaultFeatureGate.Enabled(features.CSIStorageCapacity), + EnablePodDisruptionBudget: feature.DefaultFeatureGate.Enabled(features.PodDisruptionBudget), + EnablePodOverhead: feature.DefaultFeatureGate.Enabled(features.PodOverhead), + EnableReadWriteOncePod: feature.DefaultFeatureGate.Enabled(features.ReadWriteOncePod), + EnableVolumeCapacityPriority: feature.DefaultFeatureGate.Enabled(features.VolumeCapacityPriority), + EnableCSIStorageCapacity: feature.DefaultFeatureGate.Enabled(features.CSIStorageCapacity), + EnableMinDomainsInPodTopologySpread: feature.DefaultFeatureGate.Enabled(features.MinDomainsInPodTopologySpread), } return runtime.Registry{ @@ -59,7 +60,7 @@ func NewInTreeRegistry() runtime.Registry { nodename.Name: nodename.New, nodeports.Name: nodeports.New, nodeaffinity.Name: nodeaffinity.New, - podtopologyspread.Name: podtopologyspread.New, + podtopologyspread.Name: runtime.FactoryAdapter(fts, podtopologyspread.New), nodeunschedulable.Name: nodeunschedulable.New, noderesources.Name: runtime.FactoryAdapter(fts, noderesources.NewFit), noderesources.BalancedAllocationName: runtime.FactoryAdapter(fts, noderesources.NewBalancedAllocation), diff --git a/pkg/scheduler/scheduler_test.go b/pkg/scheduler/scheduler_test.go index c5597c85e42..1efc4bef1c3 100644 --- a/pkg/scheduler/scheduler_test.go +++ b/pkg/scheduler/scheduler_test.go @@ -66,6 +66,8 @@ import ( schedutil "k8s.io/kubernetes/pkg/scheduler/util" ) +var podTopologySpreadFunc = frameworkruntime.FactoryAdapter(feature.Features{}, podtopologyspread.New) + func podWithID(id, desiredHost string) *v1.Pod { return &v1.Pod{ ObjectMeta: metav1.ObjectMeta{ @@ -2096,7 +2098,7 @@ func TestSchedulerSchedulePod(t *testing.T) { st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New), st.RegisterPluginAsExtensions( podtopologyspread.Name, - podtopologyspread.New, + podTopologySpreadFunc, "PreFilter", "Filter", ), @@ -2143,7 +2145,7 @@ func TestSchedulerSchedulePod(t *testing.T) { st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New), st.RegisterPluginAsExtensions( podtopologyspread.Name, - podtopologyspread.New, + podTopologySpreadFunc, "PreFilter", "Filter", ), 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 d4bdf242850..3f8aaf1006b 100644 --- a/staging/src/k8s.io/api/core/v1/generated.pb.go +++ b/staging/src/k8s.io/api/core/v1/generated.pb.go @@ -6175,898 +6175,899 @@ func init() { } var fileDescriptor_83c10c24ec417dc9 = []byte{ - // 14247 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0xbd, 0x79, 0x70, 0x24, 0xd7, - 0x79, 0x18, 0xae, 0x9e, 0xc1, 0x35, 0x1f, 0xee, 0xb7, 0x07, 0xb1, 0x20, 0x77, 0xb1, 0x6c, 0x4a, - 0xcb, 0xa5, 0x48, 0x02, 0x5a, 0x1e, 0x12, 0x4d, 0x4a, 0xb4, 0x00, 0x0c, 0xb0, 0x0b, 0xee, 0x02, - 0x3b, 0x7c, 0x83, 0xdd, 0x95, 0x64, 0x4a, 0xa5, 0xc6, 0xcc, 0x03, 0xd0, 0xc2, 0xa0, 0x7b, 0xd8, - 0xdd, 0x83, 0x5d, 0xf0, 0x27, 0xd7, 0xcf, 0x91, 0x4f, 0xf9, 0x48, 0xa9, 0x52, 0xce, 0x51, 0xb2, - 0xcb, 0x95, 0x72, 0x9c, 0xd8, 0x8a, 0x72, 0x39, 0x72, 0x6c, 0xc7, 0x72, 0x62, 0xe7, 0x76, 0xf2, - 0x87, 0xed, 0xb8, 0x12, 0xcb, 0x55, 0xae, 0x20, 0xf6, 0x3a, 0x55, 0x2e, 0x55, 0x25, 0xb6, 0x13, - 0x27, 0x7f, 0x04, 0x71, 0xc5, 0xa9, 0x77, 0xf6, 0x7b, 0x7d, 0xcd, 0x60, 0x89, 0x85, 0x28, 0x15, - 0xff, 0x9b, 0x79, 0xdf, 0xf7, 0xbe, 0xf7, 0xfa, 0x9d, 0xdf, 0xfb, 0x4e, 0x78, 0x65, 0xe7, 0xa5, - 0x70, 0xd6, 0xf5, 0xe7, 0x76, 0x3a, 0x1b, 0x24, 0xf0, 0x48, 0x44, 0xc2, 0xb9, 0x3d, 0xe2, 0x35, - 0xfd, 0x60, 0x4e, 0x00, 0x9c, 0xb6, 0x3b, 0xd7, 0xf0, 0x03, 0x32, 0xb7, 0x77, 0x65, 0x6e, 0x8b, - 0x78, 0x24, 0x70, 0x22, 0xd2, 0x9c, 0x6d, 0x07, 0x7e, 0xe4, 0x23, 0xc4, 0x71, 0x66, 0x9d, 0xb6, - 0x3b, 0x4b, 0x71, 0x66, 0xf7, 0xae, 0x4c, 0x3f, 0xbb, 0xe5, 0x46, 0xdb, 0x9d, 0x8d, 0xd9, 0x86, - 0xbf, 0x3b, 0xb7, 0xe5, 0x6f, 0xf9, 0x73, 0x0c, 0x75, 0xa3, 0xb3, 0xc9, 0xfe, 0xb1, 0x3f, 0xec, - 0x17, 0x27, 0x31, 0xfd, 0x42, 0xdc, 0xcc, 0xae, 0xd3, 0xd8, 0x76, 0x3d, 0x12, 0xec, 0xcf, 0xb5, - 0x77, 0xb6, 0x58, 0xbb, 0x01, 0x09, 0xfd, 0x4e, 0xd0, 0x20, 0xc9, 0x86, 0x0b, 0x6b, 0x85, 0x73, - 0xbb, 0x24, 0x72, 0x32, 0xba, 0x3b, 0x3d, 0x97, 0x57, 0x2b, 0xe8, 0x78, 0x91, 0xbb, 0x9b, 0x6e, - 0xe6, 0x83, 0xdd, 0x2a, 0x84, 0x8d, 0x6d, 0xb2, 0xeb, 0xa4, 0xea, 0x3d, 0x9f, 0x57, 0xaf, 0x13, - 0xb9, 0xad, 0x39, 0xd7, 0x8b, 0xc2, 0x28, 0x48, 0x56, 0xb2, 0xbf, 0x66, 0xc1, 0xc5, 0xf9, 0x3b, - 0xf5, 0xa5, 0x96, 0x13, 0x46, 0x6e, 0x63, 0xa1, 0xe5, 0x37, 0x76, 0xea, 0x91, 0x1f, 0x90, 0xdb, - 0x7e, 0xab, 0xb3, 0x4b, 0xea, 0x6c, 0x20, 0xd0, 0x33, 0x30, 0xb4, 0xc7, 0xfe, 0xaf, 0x54, 0xa7, - 0xac, 0x8b, 0xd6, 0xe5, 0xca, 0xc2, 0xc4, 0xaf, 0x1d, 0xcc, 0xbc, 0xe7, 0xfe, 0xc1, 0xcc, 0xd0, - 0x6d, 0x51, 0x8e, 0x15, 0x06, 0xba, 0x04, 0x03, 0x9b, 0xe1, 0xfa, 0x7e, 0x9b, 0x4c, 0x95, 0x18, - 0xee, 0x98, 0xc0, 0x1d, 0x58, 0xae, 0xd3, 0x52, 0x2c, 0xa0, 0x68, 0x0e, 0x2a, 0x6d, 0x27, 0x88, - 0xdc, 0xc8, 0xf5, 0xbd, 0xa9, 0xf2, 0x45, 0xeb, 0x72, 0xff, 0xc2, 0xa4, 0x40, 0xad, 0xd4, 0x24, - 0x00, 0xc7, 0x38, 0xb4, 0x1b, 0x01, 0x71, 0x9a, 0x37, 0xbd, 0xd6, 0xfe, 0x54, 0xdf, 0x45, 0xeb, - 0xf2, 0x50, 0xdc, 0x0d, 0x2c, 0xca, 0xb1, 0xc2, 0xb0, 0xbf, 0x58, 0x82, 0xa1, 0xf9, 0xcd, 0x4d, - 0xd7, 0x73, 0xa3, 0x7d, 0x74, 0x1b, 0x46, 0x3c, 0xbf, 0x49, 0xe4, 0x7f, 0xf6, 0x15, 0xc3, 0xcf, - 0x5d, 0x9c, 0x4d, 0x2f, 0xa5, 0xd9, 0x35, 0x0d, 0x6f, 0x61, 0xe2, 0xfe, 0xc1, 0xcc, 0x88, 0x5e, - 0x82, 0x0d, 0x3a, 0x08, 0xc3, 0x70, 0xdb, 0x6f, 0x2a, 0xb2, 0x25, 0x46, 0x76, 0x26, 0x8b, 0x6c, - 0x2d, 0x46, 0x5b, 0x18, 0xbf, 0x7f, 0x30, 0x33, 0xac, 0x15, 0x60, 0x9d, 0x08, 0xda, 0x80, 0x71, - 0xfa, 0xd7, 0x8b, 0x5c, 0x45, 0xb7, 0xcc, 0xe8, 0x3e, 0x91, 0x47, 0x57, 0x43, 0x5d, 0x38, 0x75, - 0xff, 0x60, 0x66, 0x3c, 0x51, 0x88, 0x93, 0x04, 0xed, 0xb7, 0x60, 0x6c, 0x3e, 0x8a, 0x9c, 0xc6, - 0x36, 0x69, 0xf2, 0x19, 0x44, 0x2f, 0x40, 0x9f, 0xe7, 0xec, 0x12, 0x31, 0xbf, 0x17, 0xc5, 0xc0, - 0xf6, 0xad, 0x39, 0xbb, 0xe4, 0xf0, 0x60, 0x66, 0xe2, 0x96, 0xe7, 0xbe, 0xd9, 0x11, 0xab, 0x82, - 0x96, 0x61, 0x86, 0x8d, 0x9e, 0x03, 0x68, 0x92, 0x3d, 0xb7, 0x41, 0x6a, 0x4e, 0xb4, 0x2d, 0xe6, - 0x1b, 0x89, 0xba, 0x50, 0x55, 0x10, 0xac, 0x61, 0xd9, 0xf7, 0xa0, 0x32, 0xbf, 0xe7, 0xbb, 0xcd, - 0x9a, 0xdf, 0x0c, 0xd1, 0x0e, 0x8c, 0xb7, 0x03, 0xb2, 0x49, 0x02, 0x55, 0x34, 0x65, 0x5d, 0x2c, - 0x5f, 0x1e, 0x7e, 0xee, 0x72, 0xe6, 0xc7, 0x9a, 0xa8, 0x4b, 0x5e, 0x14, 0xec, 0x2f, 0x3c, 0x22, - 0xda, 0x1b, 0x4f, 0x40, 0x71, 0x92, 0xb2, 0xfd, 0x2f, 0x4b, 0x70, 0x66, 0xfe, 0xad, 0x4e, 0x40, - 0xaa, 0x6e, 0xb8, 0x93, 0x5c, 0xe1, 0x4d, 0x37, 0xdc, 0x59, 0x8b, 0x47, 0x40, 0x2d, 0xad, 0xaa, - 0x28, 0xc7, 0x0a, 0x03, 0x3d, 0x0b, 0x83, 0xf4, 0xf7, 0x2d, 0xbc, 0x22, 0x3e, 0xf9, 0x94, 0x40, - 0x1e, 0xae, 0x3a, 0x91, 0x53, 0xe5, 0x20, 0x2c, 0x71, 0xd0, 0x2a, 0x0c, 0x37, 0xd8, 0x86, 0xdc, - 0x5a, 0xf5, 0x9b, 0x84, 0x4d, 0x66, 0x65, 0xe1, 0x69, 0x8a, 0xbe, 0x18, 0x17, 0x1f, 0x1e, 0xcc, - 0x4c, 0xf1, 0xbe, 0x09, 0x12, 0x1a, 0x0c, 0xeb, 0xf5, 0x91, 0xad, 0xf6, 0x57, 0x1f, 0xa3, 0x04, - 0x19, 0x7b, 0xeb, 0xb2, 0xb6, 0x55, 0xfa, 0xd9, 0x56, 0x19, 0xc9, 0xde, 0x26, 0xe8, 0x0a, 0xf4, - 0xed, 0xb8, 0x5e, 0x73, 0x6a, 0x80, 0xd1, 0x3a, 0x4f, 0xe7, 0xfc, 0xba, 0xeb, 0x35, 0x0f, 0x0f, - 0x66, 0x26, 0x8d, 0xee, 0xd0, 0x42, 0xcc, 0x50, 0xed, 0x3f, 0xb5, 0x60, 0x86, 0xc1, 0x96, 0xdd, - 0x16, 0xa9, 0x91, 0x20, 0x74, 0xc3, 0x88, 0x78, 0x91, 0x31, 0xa0, 0xcf, 0x01, 0x84, 0xa4, 0x11, - 0x90, 0x48, 0x1b, 0x52, 0xb5, 0x30, 0xea, 0x0a, 0x82, 0x35, 0x2c, 0x7a, 0x20, 0x84, 0xdb, 0x4e, - 0xc0, 0xd6, 0x97, 0x18, 0x58, 0x75, 0x20, 0xd4, 0x25, 0x00, 0xc7, 0x38, 0xc6, 0x81, 0x50, 0xee, - 0x76, 0x20, 0xa0, 0x8f, 0xc0, 0x78, 0xdc, 0x58, 0xd8, 0x76, 0x1a, 0x72, 0x00, 0xd9, 0x96, 0xa9, - 0x9b, 0x20, 0x9c, 0xc4, 0xb5, 0xff, 0xb6, 0x25, 0x16, 0x0f, 0xfd, 0xea, 0x77, 0xf8, 0xb7, 0xda, - 0xbf, 0x68, 0xc1, 0xe0, 0x82, 0xeb, 0x35, 0x5d, 0x6f, 0x0b, 0x7d, 0x1a, 0x86, 0xe8, 0xdd, 0xd4, - 0x74, 0x22, 0x47, 0x9c, 0x7b, 0x1f, 0xd0, 0xf6, 0x96, 0xba, 0x2a, 0x66, 0xdb, 0x3b, 0x5b, 0xb4, - 0x20, 0x9c, 0xa5, 0xd8, 0x74, 0xb7, 0xdd, 0xdc, 0xf8, 0x0c, 0x69, 0x44, 0xab, 0x24, 0x72, 0xe2, - 0xcf, 0x89, 0xcb, 0xb0, 0xa2, 0x8a, 0xae, 0xc3, 0x40, 0xe4, 0x04, 0x5b, 0x24, 0x12, 0x07, 0x60, - 0xe6, 0x41, 0xc5, 0x6b, 0x62, 0xba, 0x23, 0x89, 0xd7, 0x20, 0xf1, 0xb5, 0xb0, 0xce, 0xaa, 0x62, - 0x41, 0xc2, 0xfe, 0x91, 0x41, 0x38, 0xb7, 0x58, 0x5f, 0xc9, 0x59, 0x57, 0x97, 0x60, 0xa0, 0x19, - 0xb8, 0x7b, 0x24, 0x10, 0xe3, 0xac, 0xa8, 0x54, 0x59, 0x29, 0x16, 0x50, 0xf4, 0x12, 0x8c, 0xf0, - 0x0b, 0xe9, 0x9a, 0xe3, 0x35, 0x5b, 0x72, 0x88, 0x4f, 0x0b, 0xec, 0x91, 0xdb, 0x1a, 0x0c, 0x1b, - 0x98, 0x47, 0x5c, 0x54, 0x97, 0x12, 0x9b, 0x31, 0xef, 0xb2, 0xfb, 0xbc, 0x05, 0x13, 0xbc, 0x99, - 0xf9, 0x28, 0x0a, 0xdc, 0x8d, 0x4e, 0x44, 0xc2, 0xa9, 0x7e, 0x76, 0xd2, 0x2d, 0x66, 0x8d, 0x56, - 0xee, 0x08, 0xcc, 0xde, 0x4e, 0x50, 0xe1, 0x87, 0xe0, 0x94, 0x68, 0x77, 0x22, 0x09, 0xc6, 0xa9, - 0x66, 0xd1, 0x77, 0x5b, 0x30, 0xdd, 0xf0, 0xbd, 0x28, 0xf0, 0x5b, 0x2d, 0x12, 0xd4, 0x3a, 0x1b, - 0x2d, 0x37, 0xdc, 0xe6, 0xeb, 0x14, 0x93, 0x4d, 0x76, 0x12, 0xe4, 0xcc, 0xa1, 0x42, 0x12, 0x73, - 0x78, 0xe1, 0xfe, 0xc1, 0xcc, 0xf4, 0x62, 0x2e, 0x29, 0x5c, 0xd0, 0x0c, 0xda, 0x01, 0x44, 0xaf, - 0xd2, 0x7a, 0xe4, 0x6c, 0x91, 0xb8, 0xf1, 0xc1, 0xde, 0x1b, 0x3f, 0x7b, 0xff, 0x60, 0x06, 0xad, - 0xa5, 0x48, 0xe0, 0x0c, 0xb2, 0xe8, 0x4d, 0x38, 0x4d, 0x4b, 0x53, 0xdf, 0x3a, 0xd4, 0x7b, 0x73, - 0x53, 0xf7, 0x0f, 0x66, 0x4e, 0xaf, 0x65, 0x10, 0xc1, 0x99, 0xa4, 0xd1, 0x77, 0x59, 0x70, 0x2e, - 0xfe, 0xfc, 0xa5, 0x7b, 0x6d, 0xc7, 0x6b, 0xc6, 0x0d, 0x57, 0x7a, 0x6f, 0x98, 0x9e, 0xc9, 0xe7, - 0x16, 0xf3, 0x28, 0xe1, 0xfc, 0x46, 0xa6, 0x17, 0xe1, 0x4c, 0xe6, 0x6a, 0x41, 0x13, 0x50, 0xde, - 0x21, 0x9c, 0x0b, 0xaa, 0x60, 0xfa, 0x13, 0x9d, 0x86, 0xfe, 0x3d, 0xa7, 0xd5, 0x11, 0x1b, 0x05, - 0xf3, 0x3f, 0x2f, 0x97, 0x5e, 0xb2, 0xec, 0x7f, 0x55, 0x86, 0xf1, 0xc5, 0xfa, 0xca, 0x03, 0xed, - 0x42, 0xfd, 0x1a, 0x2a, 0x15, 0x5e, 0x43, 0xf1, 0xa5, 0x56, 0xce, 0xbd, 0xd4, 0xfe, 0xff, 0x8c, - 0x2d, 0xd4, 0xc7, 0xb6, 0xd0, 0xb7, 0xe5, 0x6c, 0xa1, 0x63, 0xde, 0x38, 0x7b, 0x39, 0xab, 0xa8, - 0x9f, 0x4d, 0x66, 0x26, 0xc7, 0x72, 0xc3, 0x6f, 0x38, 0xad, 0xe4, 0xd1, 0x77, 0xc4, 0xa5, 0x74, - 0x3c, 0xf3, 0xd8, 0x80, 0x91, 0x45, 0xa7, 0xed, 0x6c, 0xb8, 0x2d, 0x37, 0x72, 0x49, 0x88, 0x9e, - 0x84, 0xb2, 0xd3, 0x6c, 0x32, 0x6e, 0xab, 0xb2, 0x70, 0xe6, 0xfe, 0xc1, 0x4c, 0x79, 0xbe, 0x49, - 0xaf, 0x7d, 0x50, 0x58, 0xfb, 0x98, 0x62, 0xa0, 0xf7, 0x43, 0x5f, 0x33, 0xf0, 0xdb, 0x53, 0x25, - 0x86, 0x49, 0x77, 0x5d, 0x5f, 0x35, 0xf0, 0xdb, 0x09, 0x54, 0x86, 0x63, 0xff, 0x6a, 0x09, 0x1e, - 0x5b, 0x24, 0xed, 0xed, 0xe5, 0x7a, 0xce, 0xf9, 0x7d, 0x19, 0x86, 0x76, 0x7d, 0xcf, 0x8d, 0xfc, - 0x20, 0x14, 0x4d, 0xb3, 0x15, 0xb1, 0x2a, 0xca, 0xb0, 0x82, 0xa2, 0x8b, 0xd0, 0xd7, 0x8e, 0x99, - 0xca, 0x11, 0xc9, 0x90, 0x32, 0x76, 0x92, 0x41, 0x28, 0x46, 0x27, 0x24, 0x81, 0x58, 0x31, 0x0a, - 0xe3, 0x56, 0x48, 0x02, 0xcc, 0x20, 0xf1, 0xcd, 0x4c, 0xef, 0x6c, 0x71, 0x42, 0x27, 0x6e, 0x66, - 0x0a, 0xc1, 0x1a, 0x16, 0xaa, 0x41, 0x25, 0x4c, 0xcc, 0x6c, 0x4f, 0xdb, 0x74, 0x94, 0x5d, 0xdd, - 0x6a, 0x26, 0x63, 0x22, 0xc6, 0x8d, 0x32, 0xd0, 0xf5, 0xea, 0xfe, 0x6a, 0x09, 0x10, 0x1f, 0xc2, - 0x6f, 0xb2, 0x81, 0xbb, 0x95, 0x1e, 0xb8, 0xde, 0xb7, 0xc4, 0x71, 0x8d, 0xde, 0xff, 0xb4, 0xe0, - 0xb1, 0x45, 0xd7, 0x6b, 0x92, 0x20, 0x67, 0x01, 0x3e, 0x9c, 0xb7, 0xec, 0xd1, 0x98, 0x06, 0x63, - 0x89, 0xf5, 0x1d, 0xc3, 0x12, 0xb3, 0xff, 0xd8, 0x02, 0xc4, 0x3f, 0xfb, 0x1d, 0xf7, 0xb1, 0xb7, - 0xd2, 0x1f, 0x7b, 0x0c, 0xcb, 0xc2, 0xbe, 0x01, 0x63, 0x8b, 0x2d, 0x97, 0x78, 0xd1, 0x4a, 0x6d, - 0xd1, 0xf7, 0x36, 0xdd, 0x2d, 0xf4, 0x32, 0x8c, 0x45, 0xee, 0x2e, 0xf1, 0x3b, 0x51, 0x9d, 0x34, - 0x7c, 0x8f, 0xbd, 0x24, 0xad, 0xcb, 0xfd, 0x0b, 0xe8, 0xfe, 0xc1, 0xcc, 0xd8, 0xba, 0x01, 0xc1, - 0x09, 0x4c, 0xfb, 0x77, 0xe9, 0xf8, 0xf9, 0xbb, 0x6d, 0xdf, 0x23, 0x5e, 0xb4, 0xe8, 0x7b, 0x4d, - 0x2e, 0x71, 0x78, 0x19, 0xfa, 0x22, 0x3a, 0x1e, 0x7c, 0xec, 0x2e, 0xc9, 0x8d, 0x42, 0x47, 0xe1, - 0xf0, 0x60, 0xe6, 0x6c, 0xba, 0x06, 0x1b, 0x27, 0x56, 0x07, 0x7d, 0x1b, 0x0c, 0x84, 0x91, 0x13, - 0x75, 0x42, 0x31, 0x9a, 0x8f, 0xcb, 0xd1, 0xac, 0xb3, 0xd2, 0xc3, 0x83, 0x99, 0x71, 0x55, 0x8d, - 0x17, 0x61, 0x51, 0x01, 0x3d, 0x05, 0x83, 0xbb, 0x24, 0x0c, 0x9d, 0x2d, 0x79, 0x1b, 0x8e, 0x8b, - 0xba, 0x83, 0xab, 0xbc, 0x18, 0x4b, 0x38, 0x7a, 0x02, 0xfa, 0x49, 0x10, 0xf8, 0x81, 0xd8, 0xa3, - 0xa3, 0x02, 0xb1, 0x7f, 0x89, 0x16, 0x62, 0x0e, 0xb3, 0x7f, 0xc3, 0x82, 0x71, 0xd5, 0x57, 0xde, - 0xd6, 0x09, 0xbc, 0x0a, 0x3e, 0x01, 0xd0, 0x90, 0x1f, 0x18, 0xb2, 0xdb, 0x63, 0xf8, 0xb9, 0x4b, - 0x99, 0x17, 0x75, 0x6a, 0x18, 0x63, 0xca, 0xaa, 0x28, 0xc4, 0x1a, 0x35, 0xfb, 0x9f, 0x58, 0x70, - 0x2a, 0xf1, 0x45, 0x37, 0xdc, 0x30, 0x42, 0x6f, 0xa4, 0xbe, 0x6a, 0xb6, 0xb7, 0xaf, 0xa2, 0xb5, - 0xd9, 0x37, 0xa9, 0xa5, 0x2c, 0x4b, 0xb4, 0x2f, 0xba, 0x06, 0xfd, 0x6e, 0x44, 0x76, 0xe5, 0xc7, - 0x3c, 0x51, 0xf8, 0x31, 0xbc, 0x57, 0xf1, 0x8c, 0xac, 0xd0, 0x9a, 0x98, 0x13, 0xb0, 0x7f, 0xb5, - 0x0c, 0x15, 0xbe, 0x6c, 0x57, 0x9d, 0xf6, 0x09, 0xcc, 0xc5, 0xd3, 0x50, 0x71, 0x77, 0x77, 0x3b, - 0x91, 0xb3, 0x21, 0x8e, 0xf3, 0x21, 0xbe, 0xb5, 0x56, 0x64, 0x21, 0x8e, 0xe1, 0x68, 0x05, 0xfa, - 0x58, 0x57, 0xf8, 0x57, 0x3e, 0x99, 0xfd, 0x95, 0xa2, 0xef, 0xb3, 0x55, 0x27, 0x72, 0x38, 0x27, - 0xa5, 0xee, 0x11, 0x5a, 0x84, 0x19, 0x09, 0xe4, 0x00, 0x6c, 0xb8, 0x9e, 0x13, 0xec, 0xd3, 0xb2, - 0xa9, 0x32, 0x23, 0xf8, 0x6c, 0x31, 0xc1, 0x05, 0x85, 0xcf, 0xc9, 0xaa, 0x0f, 0x8b, 0x01, 0x58, - 0x23, 0x3a, 0xfd, 0x21, 0xa8, 0x28, 0xe4, 0xa3, 0x30, 0x44, 0xd3, 0x1f, 0x81, 0xf1, 0x44, 0x5b, - 0xdd, 0xaa, 0x8f, 0xe8, 0xfc, 0xd4, 0x2f, 0xb1, 0x23, 0x43, 0xf4, 0x7a, 0xc9, 0xdb, 0x13, 0x47, - 0xee, 0x5b, 0x70, 0xba, 0x95, 0x71, 0x92, 0x89, 0x79, 0xed, 0xfd, 0xe4, 0x7b, 0x4c, 0x7c, 0xf6, - 0xe9, 0x2c, 0x28, 0xce, 0x6c, 0x83, 0xf2, 0x08, 0x7e, 0x9b, 0x6e, 0x10, 0xa7, 0xa5, 0xb3, 0xdb, - 0x37, 0x45, 0x19, 0x56, 0x50, 0x7a, 0xde, 0x9d, 0x56, 0x9d, 0xbf, 0x4e, 0xf6, 0xeb, 0xa4, 0x45, - 0x1a, 0x91, 0x1f, 0x7c, 0x43, 0xbb, 0x7f, 0x9e, 0x8f, 0x3e, 0x3f, 0x2e, 0x87, 0x05, 0x81, 0xf2, - 0x75, 0xb2, 0xcf, 0xa7, 0x42, 0xff, 0xba, 0x72, 0xe1, 0xd7, 0xfd, 0xac, 0x05, 0xa3, 0xea, 0xeb, - 0x4e, 0xe0, 0x5c, 0x58, 0x30, 0xcf, 0x85, 0xf3, 0x85, 0x0b, 0x3c, 0xe7, 0x44, 0xf8, 0x6a, 0x09, - 0xce, 0x29, 0x1c, 0xfa, 0x36, 0xe0, 0x7f, 0xc4, 0xaa, 0x9a, 0x83, 0x8a, 0xa7, 0xa4, 0x56, 0x96, - 0x29, 0x2e, 0x8a, 0x65, 0x56, 0x31, 0x0e, 0x65, 0xf1, 0xbc, 0x58, 0xb4, 0x34, 0xa2, 0x8b, 0x73, - 0x85, 0xe8, 0x76, 0x01, 0xca, 0x1d, 0xb7, 0x29, 0x2e, 0x98, 0x0f, 0xc8, 0xd1, 0xbe, 0xb5, 0x52, - 0x3d, 0x3c, 0x98, 0x79, 0x3c, 0x4f, 0x95, 0x40, 0x6f, 0xb6, 0x70, 0xf6, 0xd6, 0x4a, 0x15, 0xd3, - 0xca, 0x68, 0x1e, 0xc6, 0xa5, 0xb6, 0xe4, 0x36, 0x65, 0xb7, 0x7c, 0x4f, 0xdc, 0x43, 0x4a, 0x26, - 0x8b, 0x4d, 0x30, 0x4e, 0xe2, 0xa3, 0x2a, 0x4c, 0xec, 0x74, 0x36, 0x48, 0x8b, 0x44, 0xfc, 0x83, - 0xaf, 0x13, 0x2e, 0xb1, 0xac, 0xc4, 0x2f, 0xb3, 0xeb, 0x09, 0x38, 0x4e, 0xd5, 0xb0, 0xff, 0x9c, - 0xdd, 0x07, 0x62, 0xf4, 0x6a, 0x81, 0x4f, 0x17, 0x16, 0xa5, 0xfe, 0x8d, 0x5c, 0xce, 0xbd, 0xac, - 0x8a, 0xeb, 0x64, 0x7f, 0xdd, 0xa7, 0x9c, 0x79, 0xf6, 0xaa, 0x30, 0xd6, 0x7c, 0x5f, 0xe1, 0x9a, - 0xff, 0xb9, 0x12, 0x9c, 0x51, 0x23, 0x60, 0x30, 0x81, 0xdf, 0xec, 0x63, 0x70, 0x05, 0x86, 0x9b, - 0x64, 0xd3, 0xe9, 0xb4, 0x22, 0x25, 0x3e, 0xef, 0xe7, 0x2a, 0x94, 0x6a, 0x5c, 0x8c, 0x75, 0x9c, - 0x23, 0x0c, 0xdb, 0xff, 0x1a, 0x66, 0x17, 0x71, 0xe4, 0xd0, 0x35, 0xae, 0x76, 0x8d, 0x95, 0xbb, - 0x6b, 0x9e, 0x80, 0x7e, 0x77, 0x97, 0x32, 0x66, 0x25, 0x93, 0xdf, 0x5a, 0xa1, 0x85, 0x98, 0xc3, - 0xd0, 0xfb, 0x60, 0xb0, 0xe1, 0xef, 0xee, 0x3a, 0x5e, 0x93, 0x5d, 0x79, 0x95, 0x85, 0x61, 0xca, - 0xbb, 0x2d, 0xf2, 0x22, 0x2c, 0x61, 0xe8, 0x31, 0xe8, 0x73, 0x82, 0x2d, 0x2e, 0xc3, 0xa8, 0x2c, - 0x0c, 0xd1, 0x96, 0xe6, 0x83, 0xad, 0x10, 0xb3, 0x52, 0xfa, 0x04, 0xbb, 0xeb, 0x07, 0x3b, 0xae, - 0xb7, 0x55, 0x75, 0x03, 0xb1, 0x25, 0xd4, 0x5d, 0x78, 0x47, 0x41, 0xb0, 0x86, 0x85, 0x96, 0xa1, - 0xbf, 0xed, 0x07, 0x51, 0x38, 0x35, 0xc0, 0x86, 0xfb, 0xf1, 0x9c, 0x83, 0x88, 0x7f, 0x6d, 0xcd, - 0x0f, 0xa2, 0xf8, 0x03, 0xe8, 0xbf, 0x10, 0xf3, 0xea, 0xe8, 0x06, 0x0c, 0x12, 0x6f, 0x6f, 0x39, - 0xf0, 0x77, 0xa7, 0x4e, 0xe5, 0x53, 0x5a, 0xe2, 0x28, 0x7c, 0x99, 0xc5, 0x3c, 0xaa, 0x28, 0xc6, - 0x92, 0x04, 0xfa, 0x36, 0x28, 0x13, 0x6f, 0x6f, 0x6a, 0x90, 0x51, 0x9a, 0xce, 0xa1, 0x74, 0xdb, - 0x09, 0xe2, 0x33, 0x7f, 0xc9, 0xdb, 0xc3, 0xb4, 0x0e, 0xfa, 0x38, 0x54, 0xe4, 0x81, 0x11, 0x0a, - 0x61, 0x5d, 0xe6, 0x82, 0x95, 0xc7, 0x0c, 0x26, 0x6f, 0x76, 0xdc, 0x80, 0xec, 0x12, 0x2f, 0x0a, - 0xe3, 0x13, 0x52, 0x42, 0x43, 0x1c, 0x53, 0x43, 0x1f, 0x97, 0x12, 0xe2, 0x55, 0xbf, 0xe3, 0x45, - 0xe1, 0x54, 0x85, 0x75, 0x2f, 0x53, 0x77, 0x77, 0x3b, 0xc6, 0x4b, 0x8a, 0x90, 0x79, 0x65, 0x6c, - 0x90, 0x42, 0x9f, 0x84, 0x51, 0xfe, 0x9f, 0x6b, 0xc0, 0xc2, 0xa9, 0x33, 0x8c, 0xf6, 0xc5, 0x7c, - 0xda, 0x1c, 0x71, 0xe1, 0x8c, 0x20, 0x3e, 0xaa, 0x97, 0x86, 0xd8, 0xa4, 0x86, 0x30, 0x8c, 0xb6, - 0xdc, 0x3d, 0xe2, 0x91, 0x30, 0xac, 0x05, 0xfe, 0x06, 0x99, 0x02, 0x36, 0x30, 0xe7, 0xb2, 0x35, - 0x66, 0xfe, 0x06, 0x59, 0x98, 0xa4, 0x34, 0x6f, 0xe8, 0x75, 0xb0, 0x49, 0x02, 0xdd, 0x82, 0x31, - 0xfa, 0x62, 0x73, 0x63, 0xa2, 0xc3, 0xdd, 0x88, 0xb2, 0x77, 0x15, 0x36, 0x2a, 0xe1, 0x04, 0x11, - 0x74, 0x13, 0x46, 0xc2, 0xc8, 0x09, 0xa2, 0x4e, 0x9b, 0x13, 0x3d, 0xdb, 0x8d, 0x28, 0x53, 0xb8, - 0xd6, 0xb5, 0x2a, 0xd8, 0x20, 0x80, 0x5e, 0x83, 0x4a, 0xcb, 0xdd, 0x24, 0x8d, 0xfd, 0x46, 0x8b, - 0x4c, 0x8d, 0x30, 0x6a, 0x99, 0x87, 0xca, 0x0d, 0x89, 0xc4, 0xf9, 0x5c, 0xf5, 0x17, 0xc7, 0xd5, - 0xd1, 0x6d, 0x38, 0x1b, 0x91, 0x60, 0xd7, 0xf5, 0x1c, 0x7a, 0x18, 0x88, 0xa7, 0x15, 0x53, 0x64, - 0x8e, 0xb2, 0xdd, 0x76, 0x41, 0xcc, 0xc6, 0xd9, 0xf5, 0x4c, 0x2c, 0x9c, 0x53, 0x1b, 0xdd, 0x83, - 0xa9, 0x0c, 0x88, 0xdf, 0x72, 0x1b, 0xfb, 0x53, 0xa7, 0x19, 0xe5, 0x0f, 0x0b, 0xca, 0x53, 0xeb, - 0x39, 0x78, 0x87, 0x05, 0x30, 0x9c, 0x4b, 0x1d, 0xdd, 0x84, 0x71, 0x76, 0x02, 0xd5, 0x3a, 0xad, - 0x96, 0x68, 0x70, 0x8c, 0x35, 0xf8, 0x3e, 0x79, 0x1f, 0xaf, 0x98, 0xe0, 0xc3, 0x83, 0x19, 0x88, - 0xff, 0xe1, 0x64, 0x6d, 0xb4, 0xc1, 0x74, 0x66, 0x9d, 0xc0, 0x8d, 0xf6, 0xe9, 0xb9, 0x41, 0xee, - 0x45, 0x53, 0xe3, 0x85, 0xf2, 0x0a, 0x1d, 0x55, 0x29, 0xd6, 0xf4, 0x42, 0x9c, 0x24, 0x48, 0x8f, - 0xd4, 0x30, 0x6a, 0xba, 0xde, 0xd4, 0x04, 0x7f, 0x97, 0xc8, 0x13, 0xa9, 0x4e, 0x0b, 0x31, 0x87, - 0x31, 0x7d, 0x19, 0xfd, 0x71, 0x93, 0xde, 0x5c, 0x93, 0x0c, 0x31, 0xd6, 0x97, 0x49, 0x00, 0x8e, - 0x71, 0x28, 0x33, 0x19, 0x45, 0xfb, 0x53, 0x88, 0xa1, 0xaa, 0x83, 0x65, 0x7d, 0xfd, 0xe3, 0x98, - 0x96, 0xdb, 0x1b, 0x30, 0xa6, 0x0e, 0x42, 0x36, 0x26, 0x68, 0x06, 0xfa, 0x19, 0xfb, 0x24, 0xa4, - 0x6b, 0x15, 0xda, 0x05, 0xc6, 0x5a, 0x61, 0x5e, 0xce, 0xba, 0xe0, 0xbe, 0x45, 0x16, 0xf6, 0x23, - 0xc2, 0xdf, 0xf4, 0x65, 0xad, 0x0b, 0x12, 0x80, 0x63, 0x1c, 0xfb, 0xff, 0x72, 0x36, 0x34, 0x3e, - 0x6d, 0x7b, 0xb8, 0x5f, 0x9e, 0x81, 0xa1, 0x6d, 0x3f, 0x8c, 0x28, 0x36, 0x6b, 0xa3, 0x3f, 0x66, - 0x3c, 0xaf, 0x89, 0x72, 0xac, 0x30, 0xd0, 0x2b, 0x30, 0xda, 0xd0, 0x1b, 0x10, 0x97, 0xa3, 0x3a, - 0x46, 0x8c, 0xd6, 0xb1, 0x89, 0x8b, 0x5e, 0x82, 0x21, 0x66, 0x03, 0xd2, 0xf0, 0x5b, 0x82, 0x6b, - 0x93, 0x37, 0xfc, 0x50, 0x4d, 0x94, 0x1f, 0x6a, 0xbf, 0xb1, 0xc2, 0x46, 0x97, 0x60, 0x80, 0x76, - 0x61, 0xa5, 0x26, 0xae, 0x25, 0x25, 0x28, 0xba, 0xc6, 0x4a, 0xb1, 0x80, 0xda, 0x7f, 0xa9, 0xa4, - 0x8d, 0x32, 0x7d, 0x0f, 0x13, 0x54, 0x83, 0xc1, 0xbb, 0x8e, 0x1b, 0xb9, 0xde, 0x96, 0xe0, 0x3f, - 0x9e, 0x2a, 0xbc, 0xa3, 0x58, 0xa5, 0x3b, 0xbc, 0x02, 0xbf, 0x45, 0xc5, 0x1f, 0x2c, 0xc9, 0x50, - 0x8a, 0x41, 0xc7, 0xf3, 0x28, 0xc5, 0x52, 0xaf, 0x14, 0x31, 0xaf, 0xc0, 0x29, 0x8a, 0x3f, 0x58, - 0x92, 0x41, 0x6f, 0x00, 0xc8, 0x1d, 0x46, 0x9a, 0xc2, 0xf6, 0xe2, 0x99, 0xee, 0x44, 0xd7, 0x55, - 0x9d, 0x85, 0x31, 0x7a, 0x47, 0xc7, 0xff, 0xb1, 0x46, 0xcf, 0x8e, 0x18, 0x9f, 0x96, 0xee, 0x0c, - 0xfa, 0x0e, 0xba, 0xc4, 0x9d, 0x20, 0x22, 0xcd, 0xf9, 0x48, 0x0c, 0xce, 0xfb, 0x7b, 0x7b, 0xa4, - 0xac, 0xbb, 0xbb, 0x44, 0xdf, 0x0e, 0x82, 0x08, 0x8e, 0xe9, 0xd9, 0xbf, 0x50, 0x86, 0xa9, 0xbc, - 0xee, 0xd2, 0x45, 0x47, 0xee, 0xb9, 0xd1, 0x22, 0x65, 0xaf, 0x2c, 0x73, 0xd1, 0x2d, 0x89, 0x72, - 0xac, 0x30, 0xe8, 0xec, 0x87, 0xee, 0x96, 0x7c, 0x63, 0xf6, 0xc7, 0xb3, 0x5f, 0x67, 0xa5, 0x58, - 0x40, 0x29, 0x5e, 0x40, 0x9c, 0x50, 0x18, 0xf7, 0x68, 0xab, 0x04, 0xb3, 0x52, 0x2c, 0xa0, 0xba, - 0xb4, 0xab, 0xaf, 0x8b, 0xb4, 0xcb, 0x18, 0xa2, 0xfe, 0xe3, 0x1d, 0x22, 0xf4, 0x29, 0x80, 0x4d, - 0xd7, 0x73, 0xc3, 0x6d, 0x46, 0x7d, 0xe0, 0xc8, 0xd4, 0x15, 0x73, 0xb6, 0xac, 0xa8, 0x60, 0x8d, - 0x22, 0x7a, 0x11, 0x86, 0xd5, 0x06, 0x5c, 0xa9, 0x32, 0x4d, 0xa7, 0x66, 0x39, 0x12, 0x9f, 0x46, - 0x55, 0xac, 0xe3, 0xd9, 0x9f, 0x49, 0xae, 0x17, 0xb1, 0x03, 0xb4, 0xf1, 0xb5, 0x7a, 0x1d, 0xdf, - 0x52, 0xf1, 0xf8, 0xda, 0x5f, 0x2f, 0xc3, 0xb8, 0xd1, 0x58, 0x27, 0xec, 0xe1, 0xcc, 0xba, 0x4a, - 0x0f, 0x70, 0x27, 0x22, 0x62, 0xff, 0xd9, 0xdd, 0xb7, 0x8a, 0x7e, 0xc8, 0xd3, 0x1d, 0xc0, 0xeb, - 0xa3, 0x4f, 0x41, 0xa5, 0xe5, 0x84, 0x4c, 0x72, 0x46, 0xc4, 0xbe, 0xeb, 0x85, 0x58, 0xfc, 0x30, - 0x71, 0xc2, 0x48, 0xbb, 0x35, 0x39, 0xed, 0x98, 0x24, 0xbd, 0x69, 0x28, 0x7f, 0x22, 0xad, 0xc7, - 0x54, 0x27, 0x28, 0x13, 0xb3, 0x8f, 0x39, 0x0c, 0xbd, 0x04, 0x23, 0x01, 0x61, 0xab, 0x62, 0x91, - 0x72, 0x73, 0x6c, 0x99, 0xf5, 0xc7, 0x6c, 0x1f, 0xd6, 0x60, 0xd8, 0xc0, 0x8c, 0xdf, 0x06, 0x03, - 0x05, 0x6f, 0x83, 0xa7, 0x60, 0x90, 0xfd, 0x50, 0x2b, 0x40, 0xcd, 0xc6, 0x0a, 0x2f, 0xc6, 0x12, - 0x9e, 0x5c, 0x30, 0x43, 0xbd, 0x2d, 0x18, 0xfa, 0xfa, 0x10, 0x8b, 0x9a, 0x69, 0x99, 0x87, 0xf8, - 0x29, 0x27, 0x96, 0x3c, 0x96, 0x30, 0xfb, 0xfd, 0x30, 0x56, 0x75, 0xc8, 0xae, 0xef, 0x2d, 0x79, - 0xcd, 0xb6, 0xef, 0x7a, 0x11, 0x9a, 0x82, 0x3e, 0x76, 0x89, 0xf0, 0x23, 0xa0, 0x8f, 0x36, 0x84, - 0x59, 0x89, 0xbd, 0x05, 0x67, 0xaa, 0xfe, 0x5d, 0xef, 0xae, 0x13, 0x34, 0xe7, 0x6b, 0x2b, 0xda, - 0xfb, 0x7a, 0x4d, 0xbe, 0xef, 0xb8, 0xd1, 0x56, 0xe6, 0xd1, 0xab, 0xd5, 0xe4, 0x6c, 0xed, 0xb2, - 0xdb, 0x22, 0x39, 0x52, 0x90, 0xbf, 0x5a, 0x32, 0x5a, 0x8a, 0xf1, 0x95, 0x56, 0xcb, 0xca, 0xd5, - 0x6a, 0xbd, 0x0e, 0x43, 0x9b, 0x2e, 0x69, 0x35, 0x31, 0xd9, 0x14, 0x2b, 0xf1, 0xc9, 0x7c, 0x3b, - 0x94, 0x65, 0x8a, 0x29, 0xa5, 0x5e, 0xfc, 0x75, 0xb8, 0x2c, 0x2a, 0x63, 0x45, 0x06, 0xed, 0xc0, - 0x84, 0x7c, 0x30, 0x48, 0xa8, 0x58, 0x97, 0x4f, 0x15, 0xbd, 0x42, 0x4c, 0xe2, 0xa7, 0xef, 0x1f, - 0xcc, 0x4c, 0xe0, 0x04, 0x19, 0x9c, 0x22, 0x4c, 0x9f, 0x83, 0xbb, 0xf4, 0x04, 0xee, 0x63, 0xc3, - 0xcf, 0x9e, 0x83, 0xec, 0x65, 0xcb, 0x4a, 0xed, 0x1f, 0xb7, 0xe0, 0x91, 0xd4, 0xc8, 0x88, 0x17, - 0xfe, 0x31, 0xcf, 0x42, 0xf2, 0xc5, 0x5d, 0xea, 0xfe, 0xe2, 0xb6, 0xff, 0x8e, 0x05, 0xa7, 0x97, - 0x76, 0xdb, 0xd1, 0x7e, 0xd5, 0x35, 0x55, 0x50, 0x1f, 0x82, 0x81, 0x5d, 0xd2, 0x74, 0x3b, 0xbb, - 0x62, 0xe6, 0x66, 0xe4, 0x29, 0xb5, 0xca, 0x4a, 0x0f, 0x0f, 0x66, 0x46, 0xeb, 0x91, 0x1f, 0x38, - 0x5b, 0x84, 0x17, 0x60, 0x81, 0xce, 0xce, 0x7a, 0xf7, 0x2d, 0x72, 0xc3, 0xdd, 0x75, 0xa5, 0x5d, - 0x51, 0xa1, 0xcc, 0x6e, 0x56, 0x0e, 0xe8, 0xec, 0xeb, 0x1d, 0xc7, 0x8b, 0xdc, 0x68, 0x5f, 0x68, - 0x8f, 0x24, 0x11, 0x1c, 0xd3, 0xb3, 0xbf, 0x66, 0xc1, 0xb8, 0x5c, 0xf7, 0xf3, 0xcd, 0x66, 0x40, - 0xc2, 0x10, 0x4d, 0x43, 0xc9, 0x6d, 0x8b, 0x5e, 0x82, 0xe8, 0x65, 0x69, 0xa5, 0x86, 0x4b, 0x6e, - 0x5b, 0xb2, 0x65, 0xec, 0x20, 0x2c, 0x9b, 0x8a, 0xb4, 0x6b, 0xa2, 0x1c, 0x2b, 0x0c, 0x74, 0x19, - 0x86, 0x3c, 0xbf, 0xc9, 0x6d, 0xbb, 0xf8, 0x95, 0xc6, 0x16, 0xd8, 0x9a, 0x28, 0xc3, 0x0a, 0x8a, - 0x6a, 0x50, 0xe1, 0x66, 0x4f, 0xf1, 0xa2, 0xed, 0xc9, 0x78, 0x8a, 0x7d, 0xd9, 0xba, 0xac, 0x89, - 0x63, 0x22, 0xf6, 0xaf, 0x58, 0x30, 0x22, 0xbf, 0xac, 0x47, 0x9e, 0x93, 0x6e, 0xad, 0x98, 0xdf, - 0x8c, 0xb7, 0x16, 0xe5, 0x19, 0x19, 0xc4, 0x60, 0x15, 0xcb, 0x47, 0x62, 0x15, 0xaf, 0xc0, 0xb0, - 0xd3, 0x6e, 0xd7, 0x4c, 0x3e, 0x93, 0x2d, 0xa5, 0xf9, 0xb8, 0x18, 0xeb, 0x38, 0xf6, 0x8f, 0x95, - 0x60, 0x4c, 0x7e, 0x41, 0xbd, 0xb3, 0x11, 0x92, 0x08, 0xad, 0x43, 0xc5, 0xe1, 0xb3, 0x44, 0xe4, - 0x22, 0x7f, 0x22, 0x5b, 0x8e, 0x60, 0x4c, 0x69, 0x7c, 0xe1, 0xcf, 0xcb, 0xda, 0x38, 0x26, 0x84, - 0x5a, 0x30, 0xe9, 0xf9, 0x11, 0x3b, 0xfc, 0x15, 0xbc, 0x48, 0xb5, 0x93, 0xa4, 0x7e, 0x4e, 0x50, - 0x9f, 0x5c, 0x4b, 0x52, 0xc1, 0x69, 0xc2, 0x68, 0x49, 0xca, 0x66, 0xca, 0xf9, 0xc2, 0x00, 0x7d, - 0xe2, 0xb2, 0x45, 0x33, 0xf6, 0x2f, 0x5b, 0x50, 0x91, 0x68, 0x27, 0xa1, 0xc5, 0x5b, 0x85, 0xc1, - 0x90, 0x4d, 0x82, 0x1c, 0x1a, 0xbb, 0xa8, 0xe3, 0x7c, 0xbe, 0xe2, 0x3b, 0x8d, 0xff, 0x0f, 0xb1, - 0xa4, 0xc1, 0x44, 0xf3, 0xaa, 0xfb, 0xef, 0x10, 0xd1, 0xbc, 0xea, 0x4f, 0xce, 0xa5, 0xf4, 0x87, - 0xac, 0xcf, 0x9a, 0xac, 0x8b, 0xb2, 0x5e, 0xed, 0x80, 0x6c, 0xba, 0xf7, 0x92, 0xac, 0x57, 0x8d, - 0x95, 0x62, 0x01, 0x45, 0x6f, 0xc0, 0x48, 0x43, 0xca, 0x64, 0xe3, 0x1d, 0x7e, 0xa9, 0x50, 0x3f, - 0xa0, 0x54, 0x49, 0x5c, 0x16, 0xb2, 0xa8, 0xd5, 0xc7, 0x06, 0x35, 0xd3, 0x8c, 0xa0, 0xdc, 0xcd, - 0x8c, 0x20, 0xa6, 0x9b, 0xaf, 0x54, 0xff, 0x09, 0x0b, 0x06, 0xb8, 0x2c, 0xae, 0x37, 0x51, 0xa8, - 0xa6, 0x59, 0x8b, 0xc7, 0xee, 0x36, 0x2d, 0x14, 0x9a, 0x32, 0xb4, 0x0a, 0x15, 0xf6, 0x83, 0xc9, - 0x12, 0xcb, 0xf9, 0x56, 0xf7, 0xbc, 0x55, 0xbd, 0x83, 0xb7, 0x65, 0x35, 0x1c, 0x53, 0xb0, 0x7f, - 0xb4, 0x4c, 0x4f, 0xb7, 0x18, 0xd5, 0xb8, 0xf4, 0xad, 0x87, 0x77, 0xe9, 0x97, 0x1e, 0xd6, 0xa5, - 0xbf, 0x05, 0xe3, 0x0d, 0x4d, 0x0f, 0x17, 0xcf, 0xe4, 0xe5, 0xc2, 0x45, 0xa2, 0xa9, 0xec, 0xb8, - 0x94, 0x65, 0xd1, 0x24, 0x82, 0x93, 0x54, 0xd1, 0x77, 0xc0, 0x08, 0x9f, 0x67, 0xd1, 0x0a, 0xb7, - 0xc4, 0x78, 0x5f, 0xfe, 0x7a, 0xd1, 0x9b, 0xe0, 0x52, 0x39, 0xad, 0x3a, 0x36, 0x88, 0xd9, 0x7f, - 0x62, 0x01, 0x5a, 0x6a, 0x6f, 0x93, 0x5d, 0x12, 0x38, 0xad, 0x58, 0x9c, 0xfe, 0x83, 0x16, 0x4c, - 0x91, 0x54, 0xf1, 0xa2, 0xbf, 0xbb, 0x2b, 0x1e, 0x2d, 0x39, 0xef, 0xea, 0xa5, 0x9c, 0x3a, 0xca, - 0x2d, 0x61, 0x2a, 0x0f, 0x03, 0xe7, 0xb6, 0x87, 0x56, 0xe1, 0x14, 0xbf, 0x25, 0x15, 0x40, 0xb3, - 0xbd, 0x7e, 0x54, 0x10, 0x3e, 0xb5, 0x9e, 0x46, 0xc1, 0x59, 0xf5, 0xec, 0xef, 0x19, 0x81, 0xdc, - 0x5e, 0xbc, 0xab, 0x47, 0x78, 0x57, 0x8f, 0xf0, 0xae, 0x1e, 0xe1, 0x5d, 0x3d, 0xc2, 0xbb, 0x7a, - 0x84, 0x6f, 0x79, 0x3d, 0xc2, 0x5f, 0xb6, 0xe0, 0x8c, 0xba, 0x06, 0x8c, 0x87, 0xef, 0x67, 0xe1, - 0x14, 0xdf, 0x6e, 0x8b, 0x2d, 0xc7, 0xdd, 0x5d, 0x27, 0xbb, 0xed, 0x96, 0x13, 0x49, 0xad, 0xfb, - 0x95, 0xcc, 0x95, 0x9b, 0xb0, 0x58, 0x35, 0x2a, 0x2e, 0x3c, 0x42, 0xaf, 0xa7, 0x0c, 0x00, 0xce, - 0x6a, 0xc6, 0xfe, 0x85, 0x21, 0xe8, 0x5f, 0xda, 0x23, 0x5e, 0x74, 0x02, 0x4f, 0x84, 0x06, 0x8c, - 0xb9, 0xde, 0x9e, 0xdf, 0xda, 0x23, 0x4d, 0x0e, 0x3f, 0xca, 0x4b, 0xf6, 0xac, 0x20, 0x3d, 0xb6, - 0x62, 0x90, 0xc0, 0x09, 0x92, 0x0f, 0x43, 0x9a, 0x7c, 0x15, 0x06, 0xf8, 0x21, 0x2e, 0x44, 0xc9, - 0x99, 0x67, 0x36, 0x1b, 0x44, 0x71, 0x35, 0xc5, 0x92, 0x6e, 0x7e, 0x49, 0x88, 0xea, 0xe8, 0x33, - 0x30, 0xb6, 0xe9, 0x06, 0x61, 0xb4, 0xee, 0xee, 0x92, 0x30, 0x72, 0x76, 0xdb, 0x0f, 0x20, 0x3d, - 0x56, 0xe3, 0xb0, 0x6c, 0x50, 0xc2, 0x09, 0xca, 0x68, 0x0b, 0x46, 0x5b, 0x8e, 0xde, 0xd4, 0xe0, - 0x91, 0x9b, 0x52, 0xb7, 0xc3, 0x0d, 0x9d, 0x10, 0x36, 0xe9, 0xd2, 0xed, 0xd4, 0x60, 0x02, 0xd0, - 0x21, 0x26, 0x16, 0x50, 0xdb, 0x89, 0x4b, 0x3e, 0x39, 0x8c, 0x32, 0x3a, 0xcc, 0x40, 0xb6, 0x62, - 0x32, 0x3a, 0x9a, 0x19, 0xec, 0xa7, 0xa1, 0x42, 0xe8, 0x10, 0x52, 0xc2, 0xe2, 0x82, 0x99, 0xeb, - 0xad, 0xaf, 0xab, 0x6e, 0x23, 0xf0, 0x4d, 0xb9, 0xfd, 0x92, 0xa4, 0x84, 0x63, 0xa2, 0x68, 0x11, - 0x06, 0x42, 0x12, 0xb8, 0x24, 0x14, 0x57, 0x4d, 0xc1, 0x34, 0x32, 0x34, 0xee, 0x5b, 0xc2, 0x7f, - 0x63, 0x51, 0x95, 0x2e, 0x2f, 0x87, 0x89, 0x34, 0xd9, 0x65, 0xa0, 0x2d, 0xaf, 0x79, 0x56, 0x8a, - 0x05, 0x14, 0xbd, 0x06, 0x83, 0x01, 0x69, 0x31, 0xc5, 0xd0, 0x68, 0xef, 0x8b, 0x9c, 0xeb, 0x99, - 0x78, 0x3d, 0x2c, 0x09, 0xa0, 0xeb, 0x80, 0x02, 0x42, 0x19, 0x25, 0xd7, 0xdb, 0x52, 0x66, 0xa3, - 0xe2, 0xa0, 0x55, 0x0c, 0x29, 0x8e, 0x31, 0xa4, 0x9b, 0x0f, 0xce, 0xa8, 0x86, 0xae, 0xc2, 0xa4, - 0x2a, 0x5d, 0xf1, 0xc2, 0xc8, 0xa1, 0x07, 0xdc, 0x38, 0xa3, 0xa5, 0xe4, 0x14, 0x38, 0x89, 0x80, - 0xd3, 0x75, 0xec, 0x2f, 0x59, 0xc0, 0xc7, 0xf9, 0x04, 0x5e, 0xe7, 0xaf, 0x9a, 0xaf, 0xf3, 0x73, - 0xb9, 0x33, 0x97, 0xf3, 0x32, 0xff, 0x92, 0x05, 0xc3, 0xda, 0xcc, 0xc6, 0x6b, 0xd6, 0x2a, 0x58, - 0xb3, 0x1d, 0x98, 0xa0, 0x2b, 0xfd, 0xe6, 0x46, 0x48, 0x82, 0x3d, 0xd2, 0x64, 0x0b, 0xb3, 0xf4, - 0x60, 0x0b, 0x53, 0x99, 0xa8, 0xdd, 0x48, 0x10, 0xc4, 0xa9, 0x26, 0xec, 0x4f, 0xcb, 0xae, 0x2a, - 0x8b, 0xbe, 0x86, 0x9a, 0xf3, 0x84, 0x45, 0x9f, 0x9a, 0x55, 0x1c, 0xe3, 0xd0, 0xad, 0xb6, 0xed, - 0x87, 0x51, 0xd2, 0xa2, 0xef, 0x9a, 0x1f, 0x46, 0x98, 0x41, 0xec, 0xe7, 0x01, 0x96, 0xee, 0x91, - 0x06, 0x5f, 0xb1, 0xfa, 0xe3, 0xc1, 0xca, 0x7f, 0x3c, 0xd8, 0xbf, 0x65, 0xc1, 0xd8, 0xf2, 0xa2, - 0x71, 0x73, 0xcd, 0x02, 0xf0, 0x17, 0xcf, 0x9d, 0x3b, 0x6b, 0x52, 0x1d, 0xce, 0x35, 0x9a, 0xaa, - 0x14, 0x6b, 0x18, 0xe8, 0x1c, 0x94, 0x5b, 0x1d, 0x4f, 0x88, 0x0f, 0x07, 0xe9, 0xf5, 0x78, 0xa3, - 0xe3, 0x61, 0x5a, 0xa6, 0xb9, 0x14, 0x94, 0x7b, 0x76, 0x29, 0xe8, 0xea, 0xda, 0x8f, 0x66, 0xa0, - 0xff, 0xee, 0x5d, 0xb7, 0xc9, 0x1d, 0x28, 0x85, 0xaa, 0xfe, 0xce, 0x9d, 0x95, 0x6a, 0x88, 0x79, - 0xb9, 0xfd, 0x85, 0x32, 0x4c, 0x2f, 0xb7, 0xc8, 0xbd, 0xb7, 0xe9, 0x44, 0xda, 0xab, 0x43, 0xc4, - 0xd1, 0x04, 0x31, 0x47, 0x75, 0x7a, 0xe9, 0x3e, 0x1e, 0x9b, 0x30, 0xc8, 0x0d, 0xda, 0xa4, 0x4b, - 0xe9, 0x2b, 0x59, 0xad, 0xe7, 0x0f, 0xc8, 0x2c, 0x37, 0x8c, 0x13, 0x1e, 0x71, 0xea, 0xc2, 0x14, - 0xa5, 0x58, 0x12, 0x9f, 0x7e, 0x19, 0x46, 0x74, 0xcc, 0x23, 0xb9, 0x9f, 0xfd, 0x85, 0x32, 0x4c, - 0xd0, 0x1e, 0x3c, 0xd4, 0x89, 0xb8, 0x95, 0x9e, 0x88, 0xe3, 0x76, 0x41, 0xea, 0x3e, 0x1b, 0x6f, - 0x24, 0x67, 0xe3, 0x4a, 0xde, 0x6c, 0x9c, 0xf4, 0x1c, 0x7c, 0xb7, 0x05, 0xa7, 0x96, 0x5b, 0x7e, - 0x63, 0x27, 0xe1, 0x26, 0xf4, 0x22, 0x0c, 0xd3, 0xe3, 0x38, 0x34, 0x3c, 0xd8, 0x8d, 0x98, 0x06, - 0x02, 0x84, 0x75, 0x3c, 0xad, 0xda, 0xad, 0x5b, 0x2b, 0xd5, 0xac, 0x50, 0x08, 0x02, 0x84, 0x75, - 0x3c, 0xfb, 0xd7, 0x2d, 0x38, 0x7f, 0x75, 0x71, 0x29, 0x5e, 0x8a, 0xa9, 0x68, 0x0c, 0x97, 0x60, - 0xa0, 0xdd, 0xd4, 0xba, 0x12, 0x8b, 0x57, 0xab, 0xac, 0x17, 0x02, 0xfa, 0x4e, 0x89, 0x34, 0x72, - 0x0b, 0xe0, 0x2a, 0xae, 0x2d, 0x8a, 0x73, 0x57, 0x6a, 0x53, 0xac, 0x5c, 0x6d, 0xca, 0xfb, 0x60, - 0x90, 0xde, 0x0b, 0x6e, 0x43, 0xf6, 0x9b, 0x2b, 0x68, 0x79, 0x11, 0x96, 0x30, 0xfb, 0x67, 0x2c, - 0x38, 0x75, 0xd5, 0x8d, 0xe8, 0xa5, 0x9d, 0x0c, 0x37, 0x40, 0x6f, 0xed, 0xd0, 0x8d, 0xfc, 0x60, - 0x3f, 0x19, 0x6e, 0x00, 0x2b, 0x08, 0xd6, 0xb0, 0xf8, 0x07, 0xed, 0xb9, 0xcc, 0x42, 0xbb, 0x64, - 0xea, 0xaf, 0xb0, 0x28, 0xc7, 0x0a, 0x83, 0x8e, 0x57, 0xd3, 0x0d, 0x98, 0xe8, 0x6f, 0x5f, 0x1c, - 0xdc, 0x6a, 0xbc, 0xaa, 0x12, 0x80, 0x63, 0x1c, 0xfb, 0x8f, 0x2c, 0x98, 0xb9, 0xda, 0xea, 0x84, - 0x11, 0x09, 0x36, 0xc3, 0x9c, 0x43, 0xf7, 0x79, 0xa8, 0x10, 0x29, 0x68, 0x17, 0xbd, 0x56, 0x8c, - 0xa8, 0x92, 0xc0, 0xf3, 0xa8, 0x07, 0x0a, 0xaf, 0x07, 0x5f, 0xc6, 0xa3, 0x39, 0xa3, 0x2d, 0x03, - 0x22, 0x7a, 0x5b, 0x7a, 0x18, 0x08, 0xe6, 0x4f, 0xbe, 0x94, 0x82, 0xe2, 0x8c, 0x1a, 0xf6, 0x8f, - 0x5b, 0x70, 0x46, 0x7d, 0xf0, 0x3b, 0xee, 0x33, 0xed, 0xaf, 0x94, 0x60, 0xf4, 0xda, 0xfa, 0x7a, - 0xed, 0x2a, 0x89, 0xb4, 0x55, 0x59, 0xac, 0x3e, 0xc7, 0x9a, 0x16, 0xb0, 0xe8, 0x8d, 0xd8, 0x89, - 0xdc, 0xd6, 0x2c, 0x8f, 0x26, 0x34, 0xbb, 0xe2, 0x45, 0x37, 0x83, 0x7a, 0x14, 0xb8, 0xde, 0x56, - 0xe6, 0x4a, 0x97, 0x3c, 0x4b, 0x39, 0x8f, 0x67, 0x41, 0xcf, 0xc3, 0x00, 0x0b, 0x67, 0x24, 0x27, - 0xe1, 0x51, 0xf5, 0xc4, 0x62, 0xa5, 0x87, 0x07, 0x33, 0x95, 0x5b, 0x78, 0x85, 0xff, 0xc1, 0x02, - 0x15, 0xdd, 0x82, 0xe1, 0xed, 0x28, 0x6a, 0x5f, 0x23, 0x4e, 0x93, 0x04, 0xf2, 0x94, 0xbd, 0x90, - 0x75, 0xca, 0xd2, 0x41, 0xe0, 0x68, 0xf1, 0xc1, 0x14, 0x97, 0x85, 0x58, 0xa7, 0x63, 0xd7, 0x01, - 0x62, 0xd8, 0x31, 0x29, 0x40, 0xec, 0x75, 0xa8, 0xd0, 0xcf, 0x9d, 0x6f, 0xb9, 0x4e, 0xb1, 0x8a, - 0xf9, 0x69, 0xa8, 0x48, 0x05, 0x72, 0x28, 0x7c, 0xad, 0xd9, 0x8d, 0x24, 0xf5, 0xcb, 0x21, 0x8e, - 0xe1, 0xf6, 0x26, 0x9c, 0x66, 0xe6, 0x80, 0x4e, 0xb4, 0x6d, 0xac, 0xbe, 0xee, 0xd3, 0xfc, 0x8c, - 0x78, 0xb1, 0xf1, 0x3e, 0x4f, 0x69, 0xee, 0x8c, 0x23, 0x92, 0x62, 0xfc, 0x7a, 0xb3, 0xbf, 0xde, - 0x07, 0x8f, 0xae, 0xd4, 0xf3, 0xc3, 0x71, 0xbc, 0x04, 0x23, 0x9c, 0x11, 0xa4, 0x93, 0xee, 0xb4, - 0x44, 0xbb, 0x4a, 0xb6, 0xb9, 0xae, 0xc1, 0xb0, 0x81, 0x89, 0xce, 0x43, 0xd9, 0x7d, 0xd3, 0x4b, - 0x3a, 0xfb, 0xac, 0xbc, 0xbe, 0x86, 0x69, 0x39, 0x05, 0x53, 0x9e, 0x92, 0x1f, 0xd6, 0x0a, 0xac, - 0xf8, 0xca, 0x57, 0x61, 0xcc, 0x0d, 0x1b, 0xa1, 0xbb, 0xe2, 0xd1, 0x1d, 0xa8, 0xed, 0x61, 0x25, - 0x4d, 0xa0, 0x9d, 0x56, 0x50, 0x9c, 0xc0, 0xd6, 0x6e, 0x8e, 0xfe, 0x9e, 0xf9, 0xd2, 0xae, 0xce, - 0xc7, 0xf4, 0x60, 0x6f, 0xb3, 0xaf, 0x0b, 0x99, 0x90, 0x5a, 0x1c, 0xec, 0xfc, 0x83, 0x43, 0x2c, - 0x61, 0xf4, 0xa9, 0xd6, 0xd8, 0x76, 0xda, 0xf3, 0x9d, 0x68, 0xbb, 0xea, 0x86, 0x0d, 0x7f, 0x8f, - 0x04, 0xfb, 0xec, 0x95, 0x3d, 0x14, 0x3f, 0xd5, 0x14, 0x60, 0xf1, 0xda, 0x7c, 0x8d, 0x62, 0xe2, - 0x74, 0x1d, 0x34, 0x0f, 0xe3, 0xb2, 0xb0, 0x4e, 0x42, 0x76, 0xb8, 0x0f, 0x33, 0x32, 0xca, 0xfd, - 0x46, 0x14, 0x2b, 0x22, 0x49, 0x7c, 0x93, 0x75, 0x85, 0xe3, 0x60, 0x5d, 0x3f, 0x04, 0xa3, 0xae, - 0xe7, 0x46, 0xae, 0x13, 0xf9, 0x5c, 0xc3, 0xc2, 0x1f, 0xd4, 0x4c, 0x74, 0xbc, 0xa2, 0x03, 0xb0, - 0x89, 0x67, 0xff, 0x97, 0x3e, 0x98, 0x64, 0xd3, 0xf6, 0xee, 0x0a, 0xfb, 0x56, 0x5a, 0x61, 0xb7, - 0xd2, 0x2b, 0xec, 0x38, 0x78, 0xf2, 0x07, 0x5e, 0x66, 0x9f, 0x81, 0x8a, 0xf2, 0x38, 0x92, 0x2e, - 0x87, 0x56, 0x8e, 0xcb, 0x61, 0xf7, 0x7b, 0x59, 0x1a, 0x6d, 0x95, 0x33, 0x8d, 0xb6, 0xbe, 0x6c, - 0x41, 0xac, 0x32, 0x40, 0xaf, 0x43, 0xa5, 0xed, 0x33, 0x5b, 0xc4, 0x40, 0x1a, 0xf8, 0xbe, 0xb7, - 0x50, 0xe7, 0xc0, 0x23, 0x12, 0x05, 0x7c, 0x14, 0x6a, 0xb2, 0x2a, 0x8e, 0xa9, 0xa0, 0xeb, 0x30, - 0xd8, 0x0e, 0x48, 0x3d, 0x62, 0xe1, 0x39, 0x7a, 0x27, 0xc8, 0x57, 0x0d, 0xaf, 0x88, 0x25, 0x05, - 0xfb, 0xbf, 0x5a, 0x30, 0x91, 0x44, 0x45, 0x1f, 0x86, 0x3e, 0x72, 0x8f, 0x34, 0x44, 0x7f, 0x33, - 0x2f, 0xd9, 0x58, 0xe8, 0xc0, 0x07, 0x80, 0xfe, 0xc7, 0xac, 0x16, 0xba, 0x06, 0x83, 0xf4, 0x86, - 0xbd, 0xaa, 0x42, 0x43, 0x3d, 0x9e, 0x77, 0x4b, 0x2b, 0x56, 0x85, 0x77, 0x4e, 0x14, 0x61, 0x59, - 0x9d, 0x59, 0x4a, 0x35, 0xda, 0x75, 0xfa, 0x78, 0x89, 0x8a, 0xde, 0xd8, 0xeb, 0x8b, 0x35, 0x8e, - 0x24, 0xa8, 0x71, 0x4b, 0x29, 0x59, 0x88, 0x63, 0x22, 0xf6, 0xcf, 0x59, 0x00, 0xdc, 0x30, 0xcc, - 0xf1, 0xb6, 0xc8, 0x09, 0xc8, 0xc9, 0xab, 0xd0, 0x17, 0xb6, 0x49, 0xa3, 0xc8, 0x4c, 0x36, 0xee, - 0x4f, 0xbd, 0x4d, 0x1a, 0xf1, 0x8a, 0xa3, 0xff, 0x30, 0xab, 0x6d, 0x7f, 0x2f, 0xc0, 0x58, 0x8c, - 0xb6, 0x12, 0x91, 0x5d, 0xf4, 0xac, 0x11, 0xa6, 0xe0, 0x5c, 0x22, 0x4c, 0x41, 0x85, 0x61, 0x6b, - 0x22, 0xd9, 0xcf, 0x40, 0x79, 0xd7, 0xb9, 0x27, 0x64, 0x6e, 0x4f, 0x17, 0x77, 0x83, 0xd2, 0x9f, - 0x5d, 0x75, 0xee, 0xf1, 0x67, 0xe9, 0xd3, 0x72, 0x87, 0xac, 0x3a, 0xf7, 0x0e, 0xb9, 0x31, 0x2c, - 0x3b, 0xa5, 0x6f, 0xb8, 0x61, 0xf4, 0xb9, 0xff, 0x1c, 0xff, 0x67, 0xfb, 0x8e, 0x36, 0xc2, 0xda, - 0x72, 0x3d, 0x61, 0xf3, 0xd4, 0x53, 0x5b, 0xae, 0x97, 0x6c, 0xcb, 0xf5, 0x7a, 0x68, 0xcb, 0xf5, - 0xd0, 0x5b, 0x30, 0x28, 0x4c, 0x12, 0x45, 0x58, 0xa0, 0xb9, 0x1e, 0xda, 0x13, 0x16, 0x8d, 0xbc, - 0xcd, 0x39, 0xf9, 0xec, 0x16, 0xa5, 0x5d, 0xdb, 0x95, 0x0d, 0xa2, 0xbf, 0x62, 0xc1, 0x98, 0xf8, - 0x8d, 0xc9, 0x9b, 0x1d, 0x12, 0x46, 0x82, 0x2d, 0xfd, 0x60, 0xef, 0x7d, 0x10, 0x15, 0x79, 0x57, - 0x3e, 0x28, 0xef, 0x19, 0x13, 0xd8, 0xb5, 0x47, 0x89, 0x5e, 0xa0, 0xbf, 0x67, 0xc1, 0xe9, 0x5d, - 0xe7, 0x1e, 0x6f, 0x91, 0x97, 0x61, 0x27, 0x72, 0x7d, 0xa1, 0xda, 0xff, 0x70, 0x6f, 0xd3, 0x9f, - 0xaa, 0xce, 0x3b, 0x29, 0xf5, 0x8f, 0xa7, 0xb3, 0x50, 0xba, 0x76, 0x35, 0xb3, 0x5f, 0xd3, 0x9b, - 0x30, 0x24, 0xd7, 0x5b, 0x86, 0x70, 0xa3, 0xaa, 0xf3, 0xdc, 0x47, 0xb6, 0x08, 0xd5, 0xdd, 0xff, - 0x69, 0x3b, 0x62, 0xad, 0x3d, 0xd4, 0x76, 0x3e, 0x03, 0x23, 0xfa, 0x1a, 0x7b, 0xa8, 0x6d, 0xbd, - 0x09, 0xa7, 0x32, 0xd6, 0xd2, 0x43, 0x6d, 0xf2, 0x2e, 0x9c, 0xcb, 0x5d, 0x1f, 0x0f, 0xb3, 0x61, - 0xfb, 0x2b, 0x96, 0x7e, 0x0e, 0x9e, 0x80, 0xb2, 0x62, 0xd1, 0x54, 0x56, 0x5c, 0x28, 0xde, 0x39, - 0x39, 0x1a, 0x8b, 0x37, 0xf4, 0x4e, 0xd3, 0x53, 0x1d, 0xbd, 0x06, 0x03, 0x2d, 0x5a, 0x22, 0x0d, - 0x5b, 0xed, 0xee, 0x3b, 0x32, 0x66, 0x26, 0x59, 0x79, 0x88, 0x05, 0x05, 0xfb, 0x17, 0x2d, 0xe8, - 0x3b, 0x81, 0x91, 0xc0, 0xe6, 0x48, 0x3c, 0x9b, 0x4b, 0x5a, 0x44, 0x2c, 0x9e, 0xc5, 0xce, 0xdd, - 0xa5, 0x7b, 0x11, 0xf1, 0x42, 0x76, 0x23, 0x67, 0x0e, 0xcc, 0x4f, 0x59, 0x70, 0xea, 0x86, 0xef, - 0x34, 0x17, 0x9c, 0x96, 0xe3, 0x35, 0x48, 0xb0, 0xe2, 0x6d, 0x1d, 0xc9, 0x2a, 0xbb, 0xd4, 0xd5, - 0x2a, 0x7b, 0x51, 0x1a, 0x35, 0xf5, 0xe5, 0xcf, 0x1f, 0xe5, 0xa4, 0x93, 0x81, 0x5b, 0x0c, 0xf3, - 0xdb, 0x6d, 0x40, 0x7a, 0x2f, 0x85, 0x8f, 0x0c, 0x86, 0x41, 0x97, 0xf7, 0x57, 0x4c, 0xe2, 0x93, - 0xd9, 0x1c, 0x6e, 0xea, 0xf3, 0x34, 0xef, 0x0f, 0x5e, 0x80, 0x25, 0x21, 0xfb, 0x25, 0xc8, 0x74, - 0xb4, 0xef, 0x2e, 0x97, 0xb0, 0x3f, 0x0e, 0x93, 0xac, 0xe6, 0x11, 0x25, 0x03, 0x76, 0x42, 0x9a, - 0x9a, 0x11, 0x82, 0xcf, 0xfe, 0xbc, 0x05, 0xe3, 0x6b, 0x89, 0xc8, 0x64, 0x97, 0x98, 0xfe, 0x35, - 0x43, 0x88, 0x5f, 0x67, 0xa5, 0x58, 0x40, 0x8f, 0x5d, 0xc8, 0xf5, 0xe7, 0x16, 0xc4, 0xb1, 0x2f, - 0x4e, 0x80, 0x7d, 0x5b, 0x34, 0xd8, 0xb7, 0x4c, 0x46, 0x56, 0x75, 0x27, 0x8f, 0x7b, 0x43, 0xd7, - 0x55, 0x54, 0xa8, 0x02, 0x1e, 0x36, 0x26, 0xc3, 0x97, 0xe2, 0x98, 0x19, 0x3a, 0x4a, 0xc6, 0x89, - 0xb2, 0x7f, 0xbb, 0x04, 0x48, 0xe1, 0xf6, 0x1c, 0xb5, 0x2a, 0x5d, 0xe3, 0x78, 0xa2, 0x56, 0xed, - 0x01, 0x62, 0x16, 0x04, 0x81, 0xe3, 0x85, 0x9c, 0xac, 0x2b, 0xc4, 0x7a, 0x47, 0x33, 0x4f, 0x98, - 0x16, 0x4d, 0xa2, 0x1b, 0x29, 0x6a, 0x38, 0xa3, 0x05, 0xcd, 0x32, 0xa4, 0xbf, 0x57, 0xcb, 0x90, - 0x81, 0x2e, 0x7e, 0x70, 0x3f, 0x6b, 0xc1, 0xa8, 0x1a, 0xa6, 0x77, 0x88, 0x95, 0xba, 0xea, 0x4f, - 0xce, 0x01, 0x5a, 0xd3, 0xba, 0xcc, 0x2e, 0x96, 0x6f, 0x67, 0xfe, 0x8c, 0x4e, 0xcb, 0x7d, 0x8b, - 0xa8, 0x98, 0x81, 0x33, 0xc2, 0x3f, 0x51, 0x94, 0x1e, 0x1e, 0xcc, 0x8c, 0xaa, 0x7f, 0x3c, 0x46, - 0x71, 0x5c, 0x85, 0x1e, 0xc9, 0xe3, 0x89, 0xa5, 0x88, 0x5e, 0x84, 0xfe, 0xf6, 0xb6, 0x13, 0x92, - 0x84, 0x37, 0x4f, 0x7f, 0x8d, 0x16, 0x1e, 0x1e, 0xcc, 0x8c, 0xa9, 0x0a, 0xac, 0x04, 0x73, 0xec, - 0xde, 0x63, 0x81, 0xa5, 0x17, 0x67, 0xd7, 0x58, 0x60, 0x7f, 0x62, 0x41, 0xdf, 0x9a, 0xdf, 0x3c, - 0x89, 0x23, 0xe0, 0x55, 0xe3, 0x08, 0x78, 0x2c, 0x2f, 0x7c, 0x7c, 0xee, 0xee, 0x5f, 0x4e, 0xec, - 0xfe, 0x0b, 0xb9, 0x14, 0x8a, 0x37, 0xfe, 0x2e, 0x0c, 0xb3, 0xa0, 0xf4, 0xc2, 0x73, 0xe9, 0x79, - 0x63, 0xc3, 0xcf, 0x24, 0x36, 0xfc, 0xb8, 0x86, 0xaa, 0xed, 0xf4, 0xa7, 0x60, 0x50, 0xb8, 0xc2, - 0x24, 0xdd, 0x42, 0x05, 0x2e, 0x96, 0x70, 0xfb, 0x27, 0xca, 0x60, 0x04, 0xc1, 0x47, 0xbf, 0x6c, - 0xc1, 0x6c, 0xc0, 0x4d, 0x64, 0x9b, 0xd5, 0x4e, 0xe0, 0x7a, 0x5b, 0xf5, 0xc6, 0x36, 0x69, 0x76, - 0x5a, 0xae, 0xb7, 0xb5, 0xb2, 0xe5, 0xf9, 0xaa, 0x78, 0xe9, 0x1e, 0x69, 0x74, 0x98, 0xda, 0xad, - 0x4b, 0xc4, 0x7d, 0x65, 0x6a, 0xfe, 0xdc, 0xfd, 0x83, 0x99, 0x59, 0x7c, 0x24, 0xda, 0xf8, 0x88, - 0x7d, 0x41, 0xbf, 0x6e, 0xc1, 0x1c, 0x8f, 0x0d, 0xdf, 0x7b, 0xff, 0x0b, 0x5e, 0xcb, 0x35, 0x49, - 0x2a, 0x26, 0xb2, 0x4e, 0x82, 0xdd, 0x85, 0x0f, 0x89, 0x01, 0x9d, 0xab, 0x1d, 0xad, 0x2d, 0x7c, - 0xd4, 0xce, 0xd9, 0xff, 0xac, 0x0c, 0xa3, 0x22, 0x66, 0x94, 0xb8, 0x03, 0x5e, 0x34, 0x96, 0xc4, - 0xe3, 0x89, 0x25, 0x31, 0x69, 0x20, 0x1f, 0xcf, 0xf1, 0x1f, 0xc2, 0x24, 0x3d, 0x9c, 0xaf, 0x11, - 0x27, 0x88, 0x36, 0x88, 0xc3, 0x0d, 0xbe, 0xca, 0x47, 0x3e, 0xfd, 0x95, 0x7c, 0xf2, 0x46, 0x92, - 0x18, 0x4e, 0xd3, 0xff, 0x56, 0xba, 0x73, 0x3c, 0x98, 0x48, 0x85, 0xfd, 0xfa, 0x04, 0x54, 0x94, - 0x1f, 0x87, 0x38, 0x74, 0x8a, 0xa3, 0xe7, 0x25, 0x29, 0x70, 0xf1, 0x57, 0xec, 0x43, 0x14, 0x93, - 0xb3, 0xff, 0x41, 0xc9, 0x68, 0x90, 0x4f, 0xe2, 0x1a, 0x0c, 0x39, 0x61, 0xe8, 0x6e, 0x79, 0xa4, - 0x59, 0x24, 0xa1, 0x4c, 0x35, 0xc3, 0x7c, 0x69, 0xe6, 0x45, 0x4d, 0xac, 0x68, 0xa0, 0x6b, 0xdc, - 0xac, 0x6e, 0x8f, 0x14, 0x89, 0x27, 0x53, 0xd4, 0x40, 0x1a, 0xde, 0xed, 0x11, 0x2c, 0xea, 0xa3, - 0x4f, 0x72, 0xbb, 0xc7, 0xeb, 0x9e, 0x7f, 0xd7, 0xbb, 0xea, 0xfb, 0x32, 0x2e, 0x43, 0x6f, 0x04, - 0x27, 0xa5, 0xb5, 0xa3, 0xaa, 0x8e, 0x4d, 0x6a, 0xbd, 0xc5, 0xd1, 0xfc, 0x2c, 0x9c, 0xa2, 0xa4, - 0x4d, 0xb7, 0xe9, 0x10, 0x11, 0x18, 0x17, 0x01, 0xc9, 0x64, 0x99, 0x18, 0xbb, 0xcc, 0xa7, 0x9c, - 0x59, 0x3b, 0x16, 0xa4, 0x5f, 0x37, 0x49, 0xe0, 0x24, 0x4d, 0xfb, 0xa7, 0x2d, 0x60, 0x2e, 0xa4, - 0x27, 0xc0, 0x8f, 0x7c, 0xc4, 0xe4, 0x47, 0xa6, 0xf2, 0x06, 0x39, 0x87, 0x15, 0x79, 0x81, 0xaf, - 0xac, 0x5a, 0xe0, 0xdf, 0xdb, 0x17, 0xc6, 0x2a, 0xdd, 0xdf, 0x1f, 0xf6, 0xff, 0xb1, 0xf8, 0x21, - 0xa6, 0xbc, 0x2c, 0xd0, 0x77, 0xc2, 0x50, 0xc3, 0x69, 0x3b, 0x0d, 0x9e, 0xb1, 0x25, 0x57, 0xa2, - 0x67, 0x54, 0x9a, 0x5d, 0x14, 0x35, 0xb8, 0x84, 0x4a, 0x06, 0xb6, 0x1b, 0x92, 0xc5, 0x5d, 0xa5, - 0x52, 0xaa, 0xc9, 0xe9, 0x1d, 0x18, 0x35, 0x88, 0x3d, 0x54, 0x71, 0xc6, 0x77, 0xf2, 0x2b, 0x56, - 0x05, 0x62, 0xdc, 0x85, 0x49, 0x4f, 0xfb, 0x4f, 0x2f, 0x14, 0xf9, 0xb8, 0x7c, 0x6f, 0xb7, 0x4b, - 0x94, 0xdd, 0x3e, 0x9a, 0x77, 0x6a, 0x82, 0x0c, 0x4e, 0x53, 0xb6, 0x7f, 0xd2, 0x82, 0x47, 0x74, - 0x44, 0xcd, 0x01, 0xa6, 0x9b, 0x92, 0xa4, 0x0a, 0x43, 0x7e, 0x9b, 0x04, 0x4e, 0xe4, 0x07, 0xe2, - 0xd6, 0xb8, 0x2c, 0x07, 0xfd, 0xa6, 0x28, 0x3f, 0x14, 0xf1, 0xce, 0x25, 0x75, 0x59, 0x8e, 0x55, - 0x4d, 0xfa, 0xfa, 0x64, 0x83, 0x11, 0x0a, 0x57, 0x27, 0x76, 0x06, 0x30, 0x4d, 0x7a, 0x88, 0x05, - 0xc4, 0xfe, 0xba, 0xc5, 0x17, 0x96, 0xde, 0x75, 0xf4, 0x26, 0x4c, 0xec, 0x3a, 0x51, 0x63, 0x7b, - 0xe9, 0x5e, 0x3b, 0xe0, 0x2a, 0x27, 0x39, 0x4e, 0x4f, 0x77, 0x1b, 0x27, 0xed, 0x23, 0x63, 0x53, - 0xce, 0xd5, 0x04, 0x31, 0x9c, 0x22, 0x8f, 0x36, 0x60, 0x98, 0x95, 0x31, 0x2f, 0xbe, 0xb0, 0x88, - 0x35, 0xc8, 0x6b, 0x4d, 0x19, 0x23, 0xac, 0xc6, 0x74, 0xb0, 0x4e, 0xd4, 0xfe, 0x72, 0x99, 0xef, - 0x76, 0xc6, 0xca, 0x3f, 0x05, 0x83, 0x6d, 0xbf, 0xb9, 0xb8, 0x52, 0xc5, 0x62, 0x16, 0xd4, 0x35, - 0x52, 0xe3, 0xc5, 0x58, 0xc2, 0xd1, 0x65, 0x18, 0x12, 0x3f, 0xa5, 0x8a, 0x90, 0x9d, 0xcd, 0x02, - 0x2f, 0xc4, 0x0a, 0x8a, 0x9e, 0x03, 0x68, 0x07, 0xfe, 0x9e, 0xdb, 0x64, 0xd1, 0x25, 0xca, 0xa6, - 0x1d, 0x51, 0x4d, 0x41, 0xb0, 0x86, 0x85, 0x5e, 0x81, 0xd1, 0x8e, 0x17, 0x72, 0x76, 0x44, 0x8b, - 0x25, 0xab, 0x2c, 0x5c, 0x6e, 0xe9, 0x40, 0x6c, 0xe2, 0xa2, 0x79, 0x18, 0x88, 0x1c, 0x66, 0x17, - 0xd3, 0x9f, 0x6f, 0xee, 0xbb, 0x4e, 0x31, 0xf4, 0xe4, 0x20, 0xb4, 0x02, 0x16, 0x15, 0xd1, 0x27, - 0xa4, 0x43, 0x2d, 0x3f, 0xd8, 0x85, 0x9d, 0x7d, 0x6f, 0x97, 0x80, 0xe6, 0x4e, 0x2b, 0xec, 0xf7, - 0x0d, 0x5a, 0xe8, 0x65, 0x00, 0x72, 0x2f, 0x22, 0x81, 0xe7, 0xb4, 0x94, 0x35, 0x9b, 0xe2, 0x0b, - 0xaa, 0xfe, 0x9a, 0x1f, 0xdd, 0x0a, 0xc9, 0x92, 0xc2, 0xc0, 0x1a, 0xb6, 0xfd, 0xeb, 0x15, 0x80, - 0x98, 0x6f, 0x47, 0x6f, 0xa5, 0x0e, 0xae, 0x67, 0x8a, 0x39, 0xfd, 0xe3, 0x3b, 0xb5, 0xd0, 0xf7, - 0x59, 0x30, 0xec, 0xb4, 0x5a, 0x7e, 0xc3, 0xe1, 0xd1, 0x7e, 0x4b, 0xc5, 0x07, 0xa7, 0x68, 0x7f, - 0x3e, 0xae, 0xc1, 0xbb, 0xf0, 0xbc, 0x5c, 0xa1, 0x1a, 0xa4, 0x6b, 0x2f, 0xf4, 0x86, 0xd1, 0x07, - 0xe4, 0x53, 0xb1, 0x6c, 0x0c, 0xa5, 0x7a, 0x2a, 0x56, 0xd8, 0x1d, 0xa1, 0xbf, 0x12, 0x6f, 0x19, - 0xaf, 0xc4, 0xbe, 0x7c, 0x8f, 0x41, 0x83, 0x7d, 0xed, 0xf6, 0x40, 0x44, 0x35, 0x3d, 0x7a, 0x40, - 0x7f, 0xbe, 0x7b, 0x9e, 0xf6, 0x4e, 0xea, 0x12, 0x39, 0xe0, 0x33, 0x30, 0xde, 0x34, 0x99, 0x00, - 0xb1, 0x12, 0x9f, 0xcc, 0xa3, 0x9b, 0xe0, 0x19, 0xe2, 0x6b, 0x3f, 0x01, 0xc0, 0x49, 0xc2, 0xa8, - 0xc6, 0x83, 0x49, 0xac, 0x78, 0x9b, 0xbe, 0xf0, 0xf5, 0xb0, 0x73, 0xe7, 0x72, 0x3f, 0x8c, 0xc8, - 0x2e, 0xc5, 0x8c, 0x6f, 0xf7, 0x35, 0x51, 0x17, 0x2b, 0x2a, 0xe8, 0x35, 0x18, 0x60, 0xfe, 0x59, - 0xe1, 0xd4, 0x50, 0xbe, 0xc4, 0xd9, 0x8c, 0x8e, 0x16, 0x6f, 0x48, 0xf6, 0x37, 0xc4, 0x82, 0x02, - 0xba, 0x26, 0xbd, 0x1f, 0xc3, 0x15, 0xef, 0x56, 0x48, 0x98, 0xf7, 0x63, 0x65, 0xe1, 0xbd, 0xb1, - 0x63, 0x23, 0x2f, 0xcf, 0x4c, 0x21, 0x66, 0xd4, 0xa4, 0x5c, 0x94, 0xf8, 0x2f, 0x33, 0x93, 0x4d, - 0x41, 0x7e, 0xf7, 0xcc, 0xec, 0x65, 0xf1, 0x70, 0xde, 0x36, 0x49, 0xe0, 0x24, 0x4d, 0xca, 0x91, - 0xf2, 0x5d, 0x2f, 0xbc, 0x45, 0xba, 0x9d, 0x1d, 0xfc, 0x21, 0xce, 0x6e, 0x23, 0x5e, 0x82, 0x45, - 0xfd, 0x13, 0x65, 0x0f, 0xa6, 0x3d, 0x98, 0x48, 0x6e, 0xd1, 0x87, 0xca, 0x8e, 0xfc, 0x41, 0x1f, - 0x8c, 0x99, 0x4b, 0x0a, 0xcd, 0x41, 0x45, 0x10, 0x51, 0xd9, 0x04, 0xd4, 0x2e, 0x59, 0x95, 0x00, - 0x1c, 0xe3, 0xb0, 0x24, 0x12, 0xac, 0xba, 0x66, 0x1e, 0x1c, 0x27, 0x91, 0x50, 0x10, 0xac, 0x61, - 0xd1, 0x87, 0xd5, 0x86, 0xef, 0x47, 0xea, 0x42, 0x52, 0xeb, 0x6e, 0x81, 0x95, 0x62, 0x01, 0xa5, - 0x17, 0xd1, 0x0e, 0x09, 0x3c, 0xd2, 0x32, 0xe3, 0x0e, 0xab, 0x8b, 0xe8, 0xba, 0x0e, 0xc4, 0x26, - 0x2e, 0xbd, 0x4e, 0xfd, 0x90, 0x2d, 0x64, 0xf1, 0x7c, 0x8b, 0xcd, 0xad, 0xeb, 0xdc, 0x01, 0x5b, - 0xc2, 0xd1, 0xc7, 0xe1, 0x11, 0x15, 0x5b, 0x09, 0x73, 0x6d, 0x86, 0x6c, 0x71, 0xc0, 0x90, 0xb6, - 0x3c, 0xb2, 0x98, 0x8d, 0x86, 0xf3, 0xea, 0xa3, 0x57, 0x61, 0x4c, 0xb0, 0xf8, 0x92, 0xe2, 0xa0, - 0x69, 0x61, 0x74, 0xdd, 0x80, 0xe2, 0x04, 0xb6, 0x8c, 0x9c, 0xcc, 0xb8, 0x6c, 0x49, 0x61, 0x28, - 0x1d, 0x39, 0x59, 0x87, 0xe3, 0x54, 0x0d, 0x34, 0x0f, 0xe3, 0x9c, 0x07, 0x73, 0xbd, 0x2d, 0x3e, - 0x27, 0xc2, 0x99, 0x4b, 0x6d, 0xa9, 0x9b, 0x26, 0x18, 0x27, 0xf1, 0xd1, 0x4b, 0x30, 0xe2, 0x04, - 0x8d, 0x6d, 0x37, 0x22, 0x8d, 0xa8, 0x13, 0x70, 0x2f, 0x2f, 0xcd, 0x44, 0x6b, 0x5e, 0x83, 0x61, - 0x03, 0xd3, 0x7e, 0x0b, 0x4e, 0x65, 0x44, 0x66, 0xa0, 0x0b, 0xc7, 0x69, 0xbb, 0xf2, 0x9b, 0x12, - 0x16, 0xce, 0xf3, 0xb5, 0x15, 0xf9, 0x35, 0x1a, 0x16, 0x5d, 0x9d, 0x2c, 0x82, 0x83, 0x96, 0x88, - 0x50, 0xad, 0xce, 0x65, 0x09, 0xc0, 0x31, 0x8e, 0xfd, 0x3f, 0x4a, 0x30, 0x9e, 0xa1, 0x5b, 0x61, - 0xc9, 0xf0, 0x12, 0x8f, 0x94, 0x38, 0xf7, 0x9d, 0x19, 0x88, 0xbb, 0x74, 0x84, 0x40, 0xdc, 0xe5, - 0x6e, 0x81, 0xb8, 0xfb, 0xde, 0x4e, 0x20, 0x6e, 0x73, 0xc4, 0xfa, 0x7b, 0x1a, 0xb1, 0x8c, 0xe0, - 0xdd, 0x03, 0x47, 0x0c, 0xde, 0x6d, 0x0c, 0xfa, 0x60, 0x0f, 0x83, 0xfe, 0xa3, 0x25, 0x98, 0x48, - 0x9a, 0x92, 0x9e, 0x80, 0xdc, 0xf6, 0x35, 0x43, 0x6e, 0x7b, 0xb9, 0x17, 0xe7, 0xdb, 0x5c, 0x19, - 0x2e, 0x4e, 0xc8, 0x70, 0xdf, 0xdf, 0x13, 0xb5, 0x62, 0x79, 0xee, 0xdf, 0x28, 0xc1, 0x99, 0x4c, - 0xef, 0xdf, 0x13, 0x18, 0x9b, 0x9b, 0xc6, 0xd8, 0x3c, 0xdb, 0xb3, 0x63, 0x72, 0xee, 0x00, 0xdd, - 0x49, 0x0c, 0xd0, 0x5c, 0xef, 0x24, 0x8b, 0x47, 0xe9, 0x6b, 0x65, 0xb8, 0x90, 0x59, 0x2f, 0x16, - 0x7b, 0x2e, 0x1b, 0x62, 0xcf, 0xe7, 0x12, 0x62, 0x4f, 0xbb, 0xb8, 0xf6, 0xf1, 0xc8, 0x41, 0x85, - 0x83, 0x2e, 0x0b, 0x33, 0xf0, 0x80, 0x32, 0x50, 0xc3, 0x41, 0x57, 0x11, 0xc2, 0x26, 0xdd, 0x6f, - 0x25, 0xd9, 0xe7, 0xbf, 0xb5, 0xe0, 0x5c, 0xe6, 0xdc, 0x9c, 0x80, 0xac, 0x6b, 0xcd, 0x94, 0x75, - 0x3d, 0xd5, 0xf3, 0x6a, 0xcd, 0x11, 0x7e, 0x7d, 0xb9, 0x3f, 0xe7, 0x5b, 0xd8, 0x4b, 0xfe, 0x26, - 0x0c, 0x3b, 0x8d, 0x06, 0x09, 0xc3, 0x55, 0xbf, 0xa9, 0x62, 0x0d, 0x3f, 0xcb, 0xde, 0x59, 0x71, - 0xf1, 0xe1, 0xc1, 0xcc, 0x74, 0x92, 0x44, 0x0c, 0xc6, 0x3a, 0x05, 0xf4, 0x49, 0x18, 0x0a, 0xc5, - 0xbd, 0x29, 0xe6, 0xfe, 0xf9, 0x1e, 0x07, 0xc7, 0xd9, 0x20, 0x2d, 0x33, 0x18, 0x92, 0x92, 0x54, - 0x28, 0x92, 0x66, 0xe0, 0x94, 0xd2, 0xb1, 0x06, 0x4e, 0x79, 0x0e, 0x60, 0x4f, 0x3d, 0x06, 0x92, - 0xf2, 0x07, 0xed, 0x99, 0xa0, 0x61, 0xa1, 0x8f, 0xc2, 0x44, 0xc8, 0xa3, 0x05, 0x2e, 0xb6, 0x9c, - 0x90, 0xf9, 0xd1, 0x88, 0x55, 0xc8, 0x02, 0x2e, 0xd5, 0x13, 0x30, 0x9c, 0xc2, 0x46, 0xcb, 0xb2, - 0x55, 0x16, 0xda, 0x90, 0x2f, 0xcc, 0x4b, 0x71, 0x8b, 0x22, 0x15, 0xef, 0xe9, 0xe4, 0xf0, 0xb3, - 0x81, 0xd7, 0x6a, 0xa2, 0x4f, 0x02, 0xd0, 0xe5, 0x23, 0xe4, 0x10, 0x83, 0xf9, 0x87, 0x27, 0x3d, - 0x55, 0x9a, 0x99, 0xc6, 0xcd, 0xcc, 0xa7, 0xb6, 0xaa, 0x88, 0x60, 0x8d, 0x20, 0xda, 0x84, 0xd1, - 0xf8, 0x5f, 0x9c, 0xa9, 0xf2, 0x88, 0x2d, 0x30, 0xb9, 0x77, 0x55, 0xa7, 0x83, 0x4d, 0xb2, 0xf6, - 0x8f, 0x0f, 0xc2, 0xa3, 0x05, 0x67, 0x31, 0x9a, 0x37, 0xf5, 0xbd, 0x4f, 0x27, 0x1f, 0xf1, 0xd3, - 0x99, 0x95, 0x8d, 0x57, 0x7d, 0x62, 0xc9, 0x97, 0xde, 0xf6, 0x92, 0xff, 0x21, 0x4b, 0x13, 0xaf, - 0x70, 0xcb, 0xd2, 0x8f, 0x1c, 0xf1, 0x8e, 0x39, 0x46, 0x79, 0xcb, 0x66, 0x86, 0xd0, 0xe2, 0xb9, - 0x9e, 0xbb, 0xd3, 0xbb, 0x14, 0xe3, 0x2b, 0x16, 0x20, 0x21, 0x5e, 0x21, 0x4d, 0xb5, 0xa1, 0x84, - 0x3c, 0xe3, 0xea, 0x51, 0xbf, 0x7f, 0x3e, 0x45, 0x89, 0x8f, 0xc4, 0xcb, 0xf2, 0x32, 0x48, 0x23, - 0x74, 0x1d, 0x93, 0x8c, 0xee, 0xa1, 0x8f, 0xb3, 0x68, 0xba, 0xee, 0x5b, 0x82, 0x03, 0x12, 0x1b, - 0xee, 0x45, 0x11, 0x49, 0x57, 0x95, 0x53, 0x56, 0x37, 0xb3, 0xbb, 0x3a, 0x12, 0x36, 0x48, 0x9d, - 0xec, 0xfb, 0xbb, 0x03, 0x8f, 0xe4, 0x0c, 0xd9, 0x43, 0x7d, 0x86, 0xff, 0x96, 0x05, 0xe7, 0x0b, - 0xc3, 0xc2, 0x7c, 0x13, 0x32, 0x88, 0xf6, 0xe7, 0x2c, 0xc8, 0x9e, 0x6c, 0xc3, 0xac, 0x6c, 0x0e, - 0x2a, 0x0d, 0x5a, 0xa8, 0xf9, 0x01, 0xc7, 0x01, 0x12, 0x24, 0x00, 0xc7, 0x38, 0x86, 0xf5, 0x58, - 0xa9, 0xab, 0xf5, 0xd8, 0xaf, 0x58, 0x90, 0x3a, 0xe4, 0x4f, 0x80, 0xdb, 0x58, 0x31, 0xb9, 0x8d, - 0xf7, 0xf6, 0x32, 0x9a, 0x39, 0x8c, 0xc6, 0x1f, 0x8f, 0xc3, 0xd9, 0x1c, 0xb7, 0xbc, 0x3d, 0x98, - 0xdc, 0x6a, 0x10, 0xd3, 0xc3, 0xba, 0x28, 0xf2, 0x50, 0xa1, 0x3b, 0x36, 0x4b, 0x0e, 0x3b, 0x99, - 0x42, 0xc1, 0xe9, 0x26, 0xd0, 0xe7, 0x2c, 0x38, 0xed, 0xdc, 0x0d, 0x97, 0x28, 0xd7, 0xe8, 0x36, - 0x16, 0x5a, 0x7e, 0x63, 0x87, 0x5e, 0xc9, 0x72, 0x23, 0xbc, 0x90, 0x29, 0xc9, 0xbb, 0x53, 0x4f, - 0xe1, 0x1b, 0xcd, 0xb3, 0x6c, 0xb9, 0x59, 0x58, 0x38, 0xb3, 0x2d, 0x84, 0x45, 0x0a, 0x05, 0xfa, - 0x26, 0x2d, 0x88, 0x01, 0x90, 0xe5, 0x3f, 0xc9, 0xd9, 0x20, 0x09, 0xc1, 0x8a, 0x0e, 0xfa, 0x34, - 0x54, 0xb6, 0xa4, 0xbb, 0x6f, 0x06, 0x9b, 0x15, 0x0f, 0x64, 0xb1, 0x13, 0x34, 0x57, 0xc7, 0x2b, - 0x24, 0x1c, 0x13, 0x45, 0xaf, 0x42, 0xd9, 0xdb, 0x0c, 0x8b, 0x12, 0xce, 0x26, 0xec, 0x2e, 0x79, - 0xa4, 0x8d, 0xb5, 0xe5, 0x3a, 0xa6, 0x15, 0xd1, 0x35, 0x28, 0x07, 0x1b, 0x4d, 0x21, 0x86, 0xce, - 0xdc, 0xa4, 0x78, 0xa1, 0x9a, 0xd3, 0x2b, 0x46, 0x09, 0x2f, 0x54, 0x31, 0x25, 0x81, 0x6a, 0xd0, - 0xcf, 0x7c, 0xd9, 0x04, 0x53, 0x93, 0xf9, 0x7c, 0x2b, 0xf0, 0x09, 0xe5, 0xe1, 0x38, 0x18, 0x02, - 0xe6, 0x84, 0xd0, 0x3a, 0x0c, 0x34, 0x58, 0x72, 0x52, 0xc1, 0xc5, 0x7c, 0x20, 0x53, 0xe0, 0x5c, - 0x90, 0xb5, 0x55, 0xc8, 0x5f, 0x19, 0x06, 0x16, 0xb4, 0x18, 0x55, 0xd2, 0xde, 0xde, 0x0c, 0x45, - 0x32, 0xed, 0x6c, 0xaa, 0x05, 0xc9, 0x88, 0x05, 0x55, 0x86, 0x81, 0x05, 0x2d, 0xf4, 0x32, 0x94, - 0x36, 0x1b, 0xc2, 0x4f, 0x2d, 0x53, 0xf2, 0x6c, 0x06, 0x4b, 0x59, 0x18, 0xb8, 0x7f, 0x30, 0x53, - 0x5a, 0x5e, 0xc4, 0xa5, 0xcd, 0x06, 0x5a, 0x83, 0xc1, 0x4d, 0x1e, 0x5e, 0x41, 0x08, 0x97, 0x9f, - 0xcc, 0x8e, 0xfc, 0x90, 0x8a, 0xc0, 0xc0, 0x7d, 0x9e, 0x04, 0x00, 0x4b, 0x22, 0x2c, 0x23, 0x81, - 0x0a, 0x13, 0x21, 0xa2, 0xd4, 0xcd, 0x1e, 0x2d, 0xb4, 0x07, 0x67, 0x32, 0xe3, 0x60, 0x13, 0x58, - 0xa3, 0x48, 0x57, 0xb5, 0xf3, 0x56, 0x27, 0x60, 0xa1, 0xc0, 0x45, 0x38, 0xa3, 0xcc, 0x55, 0x3d, - 0x2f, 0x91, 0x8a, 0x56, 0xb5, 0x42, 0xc2, 0x31, 0x51, 0xb4, 0x03, 0xa3, 0x7b, 0x61, 0x7b, 0x9b, - 0xc8, 0x2d, 0xcd, 0xa2, 0x1b, 0xe5, 0xf0, 0x47, 0xb7, 0x05, 0xa2, 0x1b, 0x44, 0x1d, 0xa7, 0x95, - 0x3a, 0x85, 0x18, 0x2f, 0x7b, 0x5b, 0x27, 0x86, 0x4d, 0xda, 0x74, 0xf8, 0xdf, 0xec, 0xf8, 0x1b, - 0xfb, 0x11, 0x11, 0xc1, 0xe5, 0x32, 0x87, 0xff, 0x75, 0x8e, 0x92, 0x1e, 0x7e, 0x01, 0xc0, 0x92, - 0x08, 0xba, 0x2d, 0x86, 0x87, 0x9d, 0x9e, 0x13, 0xf9, 0x11, 0x60, 0xe7, 0x25, 0x52, 0xce, 0xa0, - 0xb0, 0xd3, 0x32, 0x26, 0xc5, 0x4e, 0xc9, 0xf6, 0xb6, 0x1f, 0xf9, 0x5e, 0xe2, 0x84, 0x9e, 0xcc, - 0x3f, 0x25, 0x6b, 0x19, 0xf8, 0xe9, 0x53, 0x32, 0x0b, 0x0b, 0x67, 0xb6, 0x85, 0x9a, 0x30, 0xd6, - 0xf6, 0x83, 0xe8, 0xae, 0x1f, 0xc8, 0xf5, 0x85, 0x0a, 0x84, 0x63, 0x06, 0xa6, 0x68, 0x91, 0xc5, - 0x6d, 0x34, 0x21, 0x38, 0x41, 0x13, 0x7d, 0x0c, 0x06, 0xc3, 0x86, 0xd3, 0x22, 0x2b, 0x37, 0xa7, - 0x4e, 0xe5, 0x5f, 0x3f, 0x75, 0x8e, 0x92, 0xb3, 0xba, 0x78, 0x74, 0x0c, 0x8e, 0x82, 0x25, 0x39, - 0xb4, 0x0c, 0xfd, 0x2c, 0xe3, 0x1c, 0x8b, 0x84, 0x98, 0x13, 0xc8, 0x36, 0x65, 0x05, 0xcf, 0xcf, - 0x26, 0x56, 0x8c, 0x79, 0x75, 0xba, 0x07, 0xc4, 0x1b, 0xd1, 0x0f, 0xa7, 0xce, 0xe4, 0xef, 0x01, - 0xf1, 0xb4, 0xbc, 0x59, 0x2f, 0xda, 0x03, 0x0a, 0x09, 0xc7, 0x44, 0xe9, 0xc9, 0x4c, 0x4f, 0xd3, - 0xb3, 0x05, 0xe6, 0x5b, 0xb9, 0x67, 0x29, 0x3b, 0x99, 0xe9, 0x49, 0x4a, 0x49, 0xd8, 0xbf, 0x37, - 0x98, 0xe6, 0x59, 0x98, 0x54, 0xe1, 0x7b, 0xac, 0x94, 0xc2, 0xf9, 0x83, 0xbd, 0x0a, 0x39, 0x8f, - 0xf1, 0x29, 0xf4, 0x39, 0x0b, 0xce, 0xb6, 0x33, 0x3f, 0x44, 0x30, 0x00, 0xbd, 0xc9, 0x4a, 0xf9, - 0xa7, 0xab, 0xa8, 0x99, 0xd9, 0x70, 0x9c, 0xd3, 0x52, 0xf2, 0xb9, 0x59, 0x7e, 0xdb, 0xcf, 0xcd, - 0x55, 0x18, 0x6a, 0xf0, 0xa7, 0x48, 0x61, 0xb2, 0xee, 0xe4, 0xdb, 0x9b, 0xb1, 0x12, 0xe2, 0x0d, - 0xb3, 0x89, 0x15, 0x09, 0xf4, 0xc3, 0x16, 0x9c, 0x4f, 0x76, 0x1d, 0x13, 0x06, 0x16, 0xa1, 0x36, - 0xb9, 0x40, 0x63, 0x59, 0x7c, 0x7f, 0x8a, 0xff, 0x37, 0x90, 0x0f, 0xbb, 0x21, 0xe0, 0xe2, 0xc6, - 0x50, 0x35, 0x43, 0xa2, 0x32, 0x60, 0x6a, 0x91, 0x7a, 0x90, 0xaa, 0xbc, 0x00, 0x23, 0xbb, 0x7e, - 0xc7, 0x8b, 0x84, 0xb5, 0x97, 0xb0, 0x3c, 0x61, 0x16, 0x17, 0xab, 0x5a, 0x39, 0x36, 0xb0, 0x12, - 0xb2, 0x98, 0xa1, 0x07, 0x96, 0xc5, 0xbc, 0x01, 0x23, 0x9e, 0x66, 0x9e, 0x2c, 0xf8, 0x81, 0x4b, - 0xf9, 0x61, 0x72, 0x75, 0x63, 0x66, 0xde, 0x4b, 0xbd, 0x04, 0x1b, 0xd4, 0x4e, 0xd6, 0x0c, 0xec, - 0x4b, 0x56, 0x06, 0x53, 0xcf, 0x45, 0x31, 0x1f, 0x36, 0x45, 0x31, 0x97, 0x92, 0xa2, 0x98, 0x94, - 0x06, 0xc1, 0x90, 0xc2, 0xf4, 0x9e, 0x05, 0xa8, 0xd7, 0x50, 0x9b, 0x76, 0x0b, 0x2e, 0x76, 0xbb, - 0x96, 0x98, 0xd9, 0x5f, 0x53, 0xe9, 0x8b, 0x63, 0xb3, 0xbf, 0xe6, 0x4a, 0x15, 0x33, 0x48, 0xaf, - 0x41, 0x9c, 0xec, 0xff, 0x66, 0x41, 0xb9, 0xe6, 0x37, 0x4f, 0xe0, 0xc1, 0xfb, 0x11, 0xe3, 0xc1, - 0xfb, 0x68, 0xf6, 0x85, 0xd8, 0xcc, 0xd5, 0x7f, 0x2c, 0x25, 0xf4, 0x1f, 0xe7, 0xf3, 0x08, 0x14, - 0x6b, 0x3b, 0x7e, 0xaa, 0x0c, 0xc3, 0x35, 0xbf, 0xa9, 0x6c, 0xee, 0xff, 0xc5, 0x83, 0xd8, 0xdc, - 0xe7, 0xe6, 0xb2, 0xd0, 0x28, 0x33, 0x6b, 0x41, 0xe9, 0x6e, 0xfc, 0x4d, 0x66, 0x7a, 0x7f, 0x87, - 0xb8, 0x5b, 0xdb, 0x11, 0x69, 0x26, 0x3f, 0xe7, 0xe4, 0x4c, 0xef, 0x7f, 0xaf, 0x04, 0xe3, 0x89, - 0xd6, 0x51, 0x0b, 0x46, 0x5b, 0xba, 0x74, 0x5d, 0xac, 0xd3, 0x07, 0x12, 0xcc, 0x0b, 0xd3, 0x65, - 0xad, 0x08, 0x9b, 0xc4, 0xd1, 0x2c, 0x80, 0x52, 0x37, 0x4b, 0xf1, 0x2a, 0xe3, 0xfa, 0x95, 0x3e, - 0x3a, 0xc4, 0x1a, 0x06, 0x7a, 0x11, 0x86, 0x23, 0xbf, 0xed, 0xb7, 0xfc, 0xad, 0xfd, 0xeb, 0x44, - 0xc6, 0xf7, 0x52, 0x06, 0x89, 0xeb, 0x31, 0x08, 0xeb, 0x78, 0xe8, 0x1e, 0x4c, 0x2a, 0x22, 0xf5, - 0x63, 0xd0, 0x38, 0x30, 0xa9, 0xc2, 0x5a, 0x92, 0x22, 0x4e, 0x37, 0x62, 0xff, 0x4c, 0x99, 0x0f, - 0xb1, 0x17, 0xb9, 0xef, 0xee, 0x86, 0x77, 0xf6, 0x6e, 0xf8, 0x9a, 0x05, 0x13, 0xb4, 0x75, 0x66, - 0x6d, 0x25, 0xaf, 0x79, 0x15, 0x98, 0xdb, 0x2a, 0x08, 0xcc, 0x7d, 0x89, 0x9e, 0x9a, 0x4d, 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, 0xfb, 0xb2, 0xe3, 0x76, 0xf3, 0xf0, 0xab, - 0xc2, 0x2e, 0x47, 0x30, 0x5c, 0x5a, 0xf8, 0x55, 0x69, 0xb0, 0x13, 0xe3, 0xd8, 0x5f, 0x29, 0xc3, - 0x48, 0xcd, 0x6f, 0xc6, 0xaa, 0xe6, 0x17, 0x0c, 0x55, 0xf3, 0xc5, 0x84, 0xaa, 0x79, 0x42, 0xc7, - 0x7d, 0x57, 0xb1, 0xfc, 0x8d, 0x52, 0x2c, 0xff, 0x53, 0x8b, 0xcd, 0x5a, 0x75, 0xad, 0xce, 0x8d, - 0xf7, 0xd0, 0x15, 0x18, 0x66, 0x07, 0x0c, 0x73, 0x49, 0x96, 0xfa, 0x57, 0x96, 0x8f, 0x6a, 0x2d, - 0x2e, 0xc6, 0x3a, 0x0e, 0xba, 0x0c, 0x43, 0x21, 0x71, 0x82, 0xc6, 0xb6, 0x3a, 0x5d, 0x85, 0xb2, - 0x94, 0x97, 0x61, 0x05, 0x45, 0xaf, 0xc7, 0x91, 0x3f, 0xcb, 0xf9, 0x2e, 0x8e, 0x7a, 0x7f, 0xf8, - 0x16, 0xc9, 0x0f, 0xf7, 0x69, 0xdf, 0x01, 0x94, 0xc6, 0xef, 0x21, 0x36, 0xdd, 0x8c, 0x19, 0x9b, - 0xae, 0x92, 0x8a, 0x4b, 0xf7, 0x67, 0x16, 0x8c, 0xd5, 0xfc, 0x26, 0xdd, 0xba, 0xdf, 0x4a, 0xfb, - 0x54, 0x0f, 0x7b, 0x3c, 0x50, 0x10, 0xf6, 0xf8, 0x09, 0xe8, 0xaf, 0xf9, 0xcd, 0x95, 0x5a, 0x51, - 0x7c, 0x01, 0xfb, 0x6f, 0x5a, 0x30, 0x58, 0xf3, 0x9b, 0x27, 0xa0, 0x16, 0xf8, 0xb0, 0xa9, 0x16, - 0x78, 0x24, 0x67, 0xdd, 0xe4, 0x68, 0x02, 0xfe, 0x7a, 0x1f, 0x8c, 0xd2, 0x7e, 0xfa, 0x5b, 0x72, - 0x2a, 0x8d, 0x61, 0xb3, 0x7a, 0x18, 0x36, 0xca, 0x85, 0xfb, 0xad, 0x96, 0x7f, 0x37, 0x39, 0xad, - 0xcb, 0xac, 0x14, 0x0b, 0x28, 0x7a, 0x06, 0x86, 0xda, 0x01, 0xd9, 0x73, 0x7d, 0xc1, 0xde, 0x6a, - 0x4a, 0x96, 0x9a, 0x28, 0xc7, 0x0a, 0x83, 0x3e, 0x0b, 0x43, 0xd7, 0xa3, 0x57, 0x79, 0xc3, 0xf7, - 0x9a, 0x5c, 0x72, 0x5e, 0x16, 0xb9, 0x39, 0xb4, 0x72, 0x6c, 0x60, 0xa1, 0x3b, 0x50, 0x61, 0xff, - 0xd9, 0xb1, 0x73, 0xf4, 0x2c, 0xaf, 0x22, 0xeb, 0x9f, 0x20, 0x80, 0x63, 0x5a, 0xe8, 0x39, 0x80, - 0x48, 0xc6, 0xb7, 0x0f, 0x45, 0xb4, 0x35, 0xf5, 0x14, 0x50, 0x91, 0xef, 0x43, 0xac, 0x61, 0xa1, - 0xa7, 0xa1, 0x12, 0x39, 0x6e, 0xeb, 0x86, 0xeb, 0x91, 0x90, 0x49, 0xc4, 0xcb, 0x32, 0xf9, 0x9e, - 0x28, 0xc4, 0x31, 0x9c, 0xb2, 0x62, 0x2c, 0x12, 0x07, 0xcf, 0x11, 0x3d, 0xc4, 0xb0, 0x19, 0x2b, - 0x76, 0x43, 0x95, 0x62, 0x0d, 0x03, 0x6d, 0xc3, 0x63, 0xae, 0xc7, 0xf2, 0x58, 0x90, 0xfa, 0x8e, - 0xdb, 0x5e, 0xbf, 0x51, 0xbf, 0x4d, 0x02, 0x77, 0x73, 0x7f, 0xc1, 0x69, 0xec, 0x10, 0x4f, 0xe6, - 0xef, 0x7c, 0xaf, 0xe8, 0xe2, 0x63, 0x2b, 0x05, 0xb8, 0xb8, 0x90, 0x92, 0xfd, 0x3c, 0x5b, 0xef, - 0x37, 0xeb, 0xe8, 0xfd, 0xc6, 0xd1, 0x71, 0x56, 0x3f, 0x3a, 0x0e, 0x0f, 0x66, 0x06, 0x6e, 0xd6, - 0xb5, 0x40, 0x12, 0x2f, 0xc1, 0x99, 0x9a, 0xdf, 0xac, 0xf9, 0x41, 0xb4, 0xec, 0x07, 0x77, 0x9d, - 0xa0, 0x29, 0x97, 0xd7, 0x8c, 0x0c, 0xa5, 0x41, 0xcf, 0xcf, 0x7e, 0x7e, 0xba, 0x18, 0x61, 0x32, - 0x9e, 0x67, 0x1c, 0xdb, 0x11, 0x1d, 0xc0, 0x1a, 0x8c, 0x77, 0x50, 0x99, 0x60, 0xae, 0x3a, 0x11, - 0x41, 0x37, 0x59, 0x86, 0xeb, 0xf8, 0x1a, 0x15, 0xd5, 0x9f, 0xd2, 0x32, 0x5c, 0xc7, 0xc0, 0xcc, - 0x7b, 0xd7, 0xac, 0x6f, 0xff, 0xf7, 0x7e, 0x76, 0xa2, 0x26, 0xb2, 0x89, 0xa0, 0x4f, 0xc1, 0x58, - 0x48, 0x6e, 0xb8, 0x5e, 0xe7, 0x9e, 0x14, 0x61, 0x14, 0xb8, 0xf0, 0xd5, 0x97, 0x74, 0x4c, 0x2e, - 0x08, 0x35, 0xcb, 0x70, 0x82, 0x1a, 0xda, 0x85, 0xb1, 0xbb, 0xae, 0xd7, 0xf4, 0xef, 0x86, 0x92, - 0xfe, 0x50, 0xbe, 0x3c, 0xf4, 0x0e, 0xc7, 0x4c, 0xf4, 0xd1, 0x68, 0xee, 0x8e, 0x41, 0x0c, 0x27, - 0x88, 0xd3, 0x55, 0x1b, 0x74, 0xbc, 0xf9, 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, 0xe6, 0x7b, 0xd8, 0xf7, 0x23, 0x79, - 0x0e, 0x30, 0x9d, 0xbe, 0x56, 0x8e, 0x0d, 0x2c, 0xb4, 0x0c, 0x28, 0xec, 0xb4, 0xdb, 0x2d, 0x66, - 0x1b, 0xe4, 0xb4, 0x18, 0x29, 0x6e, 0x2f, 0x51, 0xe6, 0xa1, 0x77, 0xeb, 0x29, 0x28, 0xce, 0xa8, - 0x41, 0x0f, 0xf8, 0x4d, 0xd1, 0xd5, 0x7e, 0xd6, 0x55, 0xae, 0x3b, 0xa9, 0xf3, 0x7e, 0x4a, 0x18, - 0x5a, 0x82, 0xc1, 0x70, 0x3f, 0x6c, 0x44, 0x22, 0x52, 0x62, 0x4e, 0xc2, 0xa8, 0x3a, 0x43, 0xd1, - 0xf2, 0x15, 0xf2, 0x2a, 0x58, 0xd6, 0x45, 0x0d, 0x38, 0x25, 0x28, 0x2e, 0x6e, 0x3b, 0x9e, 0x4a, - 0xbf, 0xc3, 0x4d, 0xa4, 0xaf, 0xdc, 0x3f, 0x98, 0x39, 0x25, 0x5a, 0xd6, 0xc1, 0x87, 0x07, 0x33, - 0x67, 0x6b, 0x7e, 0x33, 0x03, 0x82, 0xb3, 0xa8, 0xf1, 0xc5, 0xd7, 0x68, 0xf8, 0xbb, 0xed, 0x5a, - 0xe0, 0x6f, 0xba, 0x2d, 0x52, 0xa4, 0x7f, 0xaa, 0x1b, 0x98, 0x62, 0xf1, 0x19, 0x65, 0x38, 0x41, - 0xcd, 0xfe, 0x4e, 0xc6, 0x04, 0xb1, 0xf4, 0xdc, 0x51, 0x27, 0x20, 0x68, 0x17, 0x46, 0xdb, 0x6c, - 0x9b, 0x88, 0x84, 0x12, 0x62, 0xad, 0xbf, 0xd0, 0xa3, 0x1c, 0xe5, 0x2e, 0xbd, 0x3b, 0x4c, 0x1b, - 0xa3, 0x9a, 0x4e, 0x0e, 0x9b, 0xd4, 0xed, 0xdf, 0x78, 0x84, 0x5d, 0xa3, 0x75, 0x2e, 0x1c, 0x19, - 0x14, 0x1e, 0x19, 0xe2, 0x3d, 0x36, 0x9d, 0x2f, 0xa5, 0x8b, 0xa7, 0x45, 0x78, 0x75, 0x60, 0x59, - 0x17, 0x7d, 0x12, 0xc6, 0xe8, 0xf3, 0x46, 0x5d, 0x65, 0xe1, 0xd4, 0xe9, 0xfc, 0xc8, 0x19, 0x0a, - 0x4b, 0x4f, 0x36, 0xa3, 0x57, 0xc6, 0x09, 0x62, 0xe8, 0x75, 0x66, 0xd3, 0x23, 0x49, 0x97, 0x7a, - 0x21, 0xad, 0x9b, 0xef, 0x48, 0xb2, 0x1a, 0x11, 0xd4, 0x81, 0x53, 0xe9, 0xd4, 0x74, 0xe1, 0x94, - 0x9d, 0xcf, 0x27, 0xa6, 0xb3, 0xcb, 0xc5, 0x59, 0x41, 0xd2, 0xb0, 0x10, 0x67, 0xd1, 0x47, 0x37, - 0x60, 0x54, 0xe4, 0xa8, 0x16, 0x2b, 0xb7, 0x6c, 0x08, 0x0f, 0x47, 0xb1, 0x0e, 0x3c, 0x4c, 0x16, - 0x60, 0xb3, 0x32, 0xda, 0x82, 0xf3, 0x5a, 0xce, 0xa8, 0xab, 0x81, 0xc3, 0x2c, 0x00, 0x5c, 0x76, - 0x9c, 0x6a, 0x17, 0xfc, 0xe3, 0xf7, 0x0f, 0x66, 0xce, 0xaf, 0x17, 0x21, 0xe2, 0x62, 0x3a, 0xe8, - 0x26, 0x9c, 0xe1, 0x7e, 0xdf, 0x55, 0xe2, 0x34, 0x5b, 0xae, 0xa7, 0x38, 0x08, 0xbe, 0xe5, 0xcf, - 0xdd, 0x3f, 0x98, 0x39, 0x33, 0x9f, 0x85, 0x80, 0xb3, 0xeb, 0xa1, 0x0f, 0x43, 0xa5, 0xe9, 0x85, - 0x62, 0x0c, 0x06, 0x8c, 0xb4, 0x5c, 0x95, 0xea, 0x5a, 0x5d, 0x7d, 0x7f, 0xfc, 0x07, 0xc7, 0x15, - 0xd0, 0x16, 0x17, 0x30, 0x2b, 0xb1, 0xc7, 0x60, 0x2a, 0xee, 0x55, 0x52, 0x32, 0x68, 0x78, 0x7e, - 0x72, 0xcd, 0x8a, 0x72, 0x88, 0x30, 0x9c, 0x42, 0x0d, 0xc2, 0xe8, 0x35, 0x40, 0x22, 0xfc, 0xfb, - 0x7c, 0x83, 0x65, 0x2b, 0x61, 0xf2, 0xf8, 0x21, 0xd3, 0x17, 0xb1, 0x9e, 0xc2, 0xc0, 0x19, 0xb5, - 0xd0, 0x35, 0x7a, 0xaa, 0xe8, 0xa5, 0xe2, 0xd4, 0x52, 0x49, 0x14, 0xab, 0xa4, 0x1d, 0x10, 0x66, - 0xd1, 0x64, 0x52, 0xc4, 0x89, 0x7a, 0xa8, 0x09, 0x8f, 0x39, 0x9d, 0xc8, 0x67, 0xb2, 0x7b, 0x13, - 0x75, 0xdd, 0xdf, 0x21, 0x1e, 0x53, 0x9b, 0x0d, 0x2d, 0x5c, 0xa4, 0x2c, 0xca, 0x7c, 0x01, 0x1e, - 0x2e, 0xa4, 0x42, 0x59, 0x4b, 0x95, 0x35, 0x19, 0xcc, 0x68, 0x5e, 0x19, 0x99, 0x93, 0x5f, 0x84, - 0xe1, 0x6d, 0x3f, 0x8c, 0xd6, 0x48, 0x74, 0xd7, 0x0f, 0x76, 0x44, 0x54, 0xda, 0x38, 0xc6, 0x77, - 0x0c, 0xc2, 0x3a, 0x1e, 0x7d, 0x3b, 0x32, 0xa3, 0x8e, 0x95, 0x2a, 0xd3, 0xa7, 0x0f, 0xc5, 0x67, - 0xcc, 0x35, 0x5e, 0x8c, 0x25, 0x5c, 0xa2, 0xae, 0xd4, 0x16, 0x99, 0x6e, 0x3c, 0x81, 0xba, 0x52, - 0x5b, 0xc4, 0x12, 0x4e, 0x97, 0x6b, 0xb8, 0xed, 0x04, 0xa4, 0x16, 0xf8, 0x0d, 0x12, 0x6a, 0x91, - 0xe5, 0x1f, 0xe5, 0x31, 0x77, 0xe9, 0x72, 0xad, 0x67, 0x21, 0xe0, 0xec, 0x7a, 0x88, 0xa4, 0xf3, - 0xa5, 0x8d, 0xe5, 0x2b, 0x35, 0xd2, 0xfc, 0x4c, 0x8f, 0x29, 0xd3, 0x3c, 0x98, 0x50, 0x99, 0xda, - 0x78, 0x94, 0xdd, 0x70, 0x6a, 0x9c, 0xad, 0xed, 0xde, 0x43, 0xf4, 0x2a, 0x35, 0xd1, 0x4a, 0x82, - 0x12, 0x4e, 0xd1, 0x36, 0x02, 0xb6, 0x4d, 0x74, 0x0d, 0xd8, 0x36, 0x07, 0x95, 0xb0, 0xb3, 0xd1, - 0xf4, 0x77, 0x1d, 0xd7, 0x63, 0xba, 0x71, 0xed, 0x11, 0x53, 0x97, 0x00, 0x1c, 0xe3, 0xa0, 0x65, - 0x18, 0x72, 0xa4, 0x0e, 0x08, 0xe5, 0x87, 0xe8, 0x51, 0x9a, 0x1f, 0x1e, 0xb5, 0x42, 0x6a, 0x7d, - 0x54, 0x5d, 0xf4, 0x0a, 0x8c, 0x0a, 0xbf, 0x65, 0x91, 0x24, 0xf4, 0x94, 0xe9, 0x5c, 0x56, 0xd7, - 0x81, 0xd8, 0xc4, 0x45, 0xb7, 0x60, 0x38, 0xf2, 0x5b, 0xcc, 0x43, 0x8a, 0xb2, 0x79, 0x67, 0xf3, - 0x83, 0xcd, 0xad, 0x2b, 0x34, 0x5d, 0xfc, 0xaa, 0xaa, 0x62, 0x9d, 0x0e, 0x5a, 0xe7, 0xeb, 0x9d, - 0xc5, 0x91, 0x27, 0xe1, 0xd4, 0x23, 0xf9, 0x77, 0x92, 0x0a, 0x37, 0x6f, 0x6e, 0x07, 0x51, 0x13, - 0xeb, 0x64, 0xd0, 0x55, 0x98, 0x6c, 0x07, 0xae, 0xcf, 0xd6, 0x84, 0x52, 0xff, 0x4d, 0x99, 0x59, - 0xa3, 0x6a, 0x49, 0x04, 0x9c, 0xae, 0xc3, 0xdc, 0xce, 0x45, 0xe1, 0xd4, 0x39, 0x9e, 0xf9, 0x82, - 0xbf, 0x09, 0x79, 0x19, 0x56, 0x50, 0xb4, 0xca, 0x4e, 0x62, 0x2e, 0xce, 0x98, 0x9a, 0xce, 0x8f, - 0x0a, 0xa4, 0x8b, 0x3d, 0x38, 0xf3, 0xaa, 0xfe, 0xe2, 0x98, 0x02, 0x6a, 0x6a, 0x09, 0x27, 0xe9, - 0x8b, 0x21, 0x9c, 0x7a, 0xac, 0xc0, 0xb2, 0x2e, 0xf1, 0xbc, 0x88, 0x19, 0x02, 0xa3, 0x38, 0xc4, - 0x09, 0x9a, 0xe8, 0xa3, 0x30, 0x21, 0x62, 0x19, 0xc6, 0xc3, 0x74, 0x3e, 0xb6, 0x3b, 0xc7, 0x09, - 0x18, 0x4e, 0x61, 0xf3, 0xcc, 0x13, 0xce, 0x46, 0x8b, 0x88, 0xa3, 0xef, 0x86, 0xeb, 0xed, 0x84, - 0x53, 0x17, 0xd8, 0xf9, 0x20, 0x32, 0x4f, 0x24, 0xa1, 0x38, 0xa3, 0x06, 0x5a, 0x87, 0x89, 0x76, - 0x40, 0xc8, 0x2e, 0x63, 0xf4, 0xc5, 0x7d, 0x36, 0xc3, 0xa3, 0x2e, 0xd0, 0x9e, 0xd4, 0x12, 0xb0, - 0xc3, 0x8c, 0x32, 0x9c, 0xa2, 0x80, 0xee, 0xc2, 0x90, 0xbf, 0x47, 0x82, 0x6d, 0xe2, 0x34, 0xa7, - 0x2e, 0x16, 0xf8, 0x41, 0x88, 0xcb, 0xed, 0xa6, 0xc0, 0x4d, 0x98, 0x0c, 0xc8, 0xe2, 0xee, 0x26, - 0x03, 0xb2, 0x31, 0xf4, 0x23, 0x16, 0x9c, 0x93, 0x5a, 0x86, 0x7a, 0x9b, 0x8e, 0xfa, 0xa2, 0xef, - 0x85, 0x51, 0xc0, 0xe3, 0x04, 0x3c, 0x9e, 0xef, 0x3b, 0xbf, 0x9e, 0x53, 0x49, 0x49, 0x54, 0xcf, - 0xe5, 0x61, 0x84, 0x38, 0xbf, 0x45, 0xb4, 0x08, 0x93, 0x21, 0x89, 0xe4, 0x61, 0x34, 0x1f, 0x2e, - 0xbf, 0x5e, 0x5d, 0x9b, 0x7a, 0x82, 0x07, 0x39, 0xa0, 0x9b, 0xa1, 0x9e, 0x04, 0xe2, 0x34, 0x3e, - 0xba, 0x02, 0x25, 0x3f, 0x9c, 0x7a, 0x6f, 0x41, 0x8e, 0x52, 0xfa, 0x14, 0xe7, 0xa6, 0x63, 0x37, - 0xeb, 0xb8, 0xe4, 0x87, 0xd3, 0xdf, 0x0e, 0x93, 0x29, 0x8e, 0xe1, 0x28, 0xb9, 0x7d, 0xa6, 0x77, - 0x60, 0xd4, 0x98, 0x95, 0x87, 0xaa, 0xa5, 0xfe, 0xd7, 0x83, 0x50, 0x51, 0x1a, 0x4c, 0x34, 0x67, - 0x2a, 0xa6, 0xcf, 0x25, 0x15, 0xd3, 0x43, 0x35, 0xbf, 0x69, 0xe8, 0xa2, 0xd7, 0x33, 0xa2, 0xc1, - 0xe5, 0x9d, 0x01, 0xbd, 0x1b, 0xc8, 0x6b, 0x62, 0xe1, 0x72, 0xcf, 0x1a, 0xee, 0xbe, 0x42, 0x49, - 0xf3, 0x55, 0x98, 0xf4, 0x7c, 0xc6, 0xa6, 0x92, 0xa6, 0xe4, 0x41, 0x18, 0xab, 0x51, 0xd1, 0xc3, - 0xab, 0x24, 0x10, 0x70, 0xba, 0x0e, 0x6d, 0x90, 0xf3, 0x0a, 0x49, 0xd1, 0x36, 0x67, 0x25, 0xb0, - 0x80, 0xa2, 0x27, 0xa0, 0xbf, 0xed, 0x37, 0x57, 0x6a, 0x82, 0x45, 0xd5, 0x62, 0x90, 0x36, 0x57, - 0x6a, 0x98, 0xc3, 0xd0, 0x3c, 0x0c, 0xb0, 0x1f, 0xe1, 0xd4, 0x48, 0x7e, 0x1c, 0x0d, 0x56, 0x43, - 0xcb, 0x9c, 0xc4, 0x2a, 0x60, 0x51, 0x91, 0x89, 0xd8, 0x28, 0x5f, 0xcf, 0x44, 0x6c, 0x83, 0x0f, - 0x28, 0x62, 0x93, 0x04, 0x70, 0x4c, 0x0b, 0xdd, 0x83, 0x33, 0xc6, 0x5b, 0x8a, 0x2f, 0x11, 0x12, - 0x0a, 0x5f, 0xfe, 0x27, 0x0a, 0x1f, 0x51, 0x42, 0x23, 0x7e, 0x5e, 0x74, 0xfa, 0xcc, 0x4a, 0x16, - 0x25, 0x9c, 0xdd, 0x00, 0x6a, 0xc1, 0x64, 0x23, 0xd5, 0xea, 0x50, 0xef, 0xad, 0xaa, 0x09, 0x4d, - 0xb7, 0x98, 0x26, 0x8c, 0x5e, 0x81, 0xa1, 0x37, 0xfd, 0x90, 0x1d, 0xef, 0x82, 0xad, 0x96, 0x8e, - 0xe0, 0x43, 0xaf, 0xdf, 0xac, 0xb3, 0xf2, 0xc3, 0x83, 0x99, 0xe1, 0x9a, 0xdf, 0x94, 0x7f, 0xb1, - 0xaa, 0x80, 0xbe, 0xdf, 0x82, 0xe9, 0xf4, 0x63, 0x4d, 0x75, 0x7a, 0xb4, 0xf7, 0x4e, 0xdb, 0xa2, - 0xd1, 0xe9, 0xa5, 0x5c, 0x72, 0xb8, 0xa0, 0x29, 0xfb, 0x97, 0x2c, 0x26, 0xa8, 0x13, 0x9a, 0x26, - 0x12, 0x76, 0x5a, 0x27, 0x91, 0x30, 0x76, 0xc9, 0x50, 0x82, 0x3d, 0xb0, 0x85, 0xc4, 0x3f, 0xb7, - 0x98, 0x85, 0xc4, 0x09, 0xba, 0x42, 0xbc, 0x0e, 0x43, 0x91, 0x4c, 0xe4, 0x5b, 0x90, 0xe3, 0x56, - 0xeb, 0x14, 0xb3, 0x12, 0x51, 0x4c, 0xae, 0xca, 0xd9, 0xab, 0xc8, 0xd8, 0xff, 0x88, 0xcf, 0x80, - 0x84, 0x9c, 0x80, 0xae, 0xa1, 0x6a, 0xea, 0x1a, 0x66, 0xba, 0x7c, 0x41, 0x8e, 0xce, 0xe1, 0x1f, - 0x9a, 0xfd, 0x66, 0xc2, 0x9d, 0x77, 0xba, 0x69, 0x8e, 0xfd, 0x79, 0x0b, 0x20, 0x0e, 0xf1, 0xdc, - 0x43, 0xaa, 0xb6, 0x97, 0x28, 0x5b, 0xeb, 0x47, 0x7e, 0xc3, 0x6f, 0x09, 0x4d, 0xda, 0x63, 0xb1, - 0xba, 0x83, 0x97, 0x1f, 0x6a, 0xbf, 0xb1, 0xc2, 0x46, 0x33, 0x32, 0xa0, 0x5c, 0x39, 0x56, 0xc0, - 0x19, 0xc1, 0xe4, 0xbe, 0x68, 0xc1, 0xe9, 0x2c, 0xbb, 0x5a, 0xfa, 0x48, 0xe2, 0x62, 0x2e, 0x65, - 0x36, 0xa5, 0x66, 0xf3, 0xb6, 0x28, 0xc7, 0x0a, 0xa3, 0xe7, 0x1c, 0x78, 0x47, 0x8b, 0xad, 0x7c, - 0x13, 0x46, 0x6b, 0x01, 0xd1, 0x2e, 0xd7, 0x57, 0x79, 0x90, 0x02, 0xde, 0x9f, 0x67, 0x8e, 0x1c, - 0xa0, 0xc0, 0xfe, 0x72, 0x09, 0x4e, 0x73, 0xeb, 0x83, 0xf9, 0x3d, 0xdf, 0x6d, 0xd6, 0xfc, 0xa6, - 0xf0, 0x9e, 0xfa, 0x04, 0x8c, 0xb4, 0x35, 0xd9, 0x64, 0x51, 0x9c, 0x50, 0x5d, 0x86, 0x19, 0x4b, - 0x53, 0xf4, 0x52, 0x6c, 0xd0, 0x42, 0x4d, 0x18, 0x21, 0x7b, 0x6e, 0x43, 0xa9, 0xb0, 0x4b, 0x47, - 0xbe, 0xe8, 0x54, 0x2b, 0x4b, 0x1a, 0x1d, 0x6c, 0x50, 0x7d, 0x08, 0x99, 0xa9, 0xed, 0x1f, 0xb3, - 0xe0, 0x91, 0x9c, 0xa8, 0xa2, 0xb4, 0xb9, 0xbb, 0xcc, 0xce, 0x43, 0x2c, 0x5b, 0xd5, 0x1c, 0xb7, - 0xfe, 0xc0, 0x02, 0x8a, 0x3e, 0x06, 0xc0, 0xad, 0x37, 0xe8, 0x2b, 0xbd, 0x5b, 0xf8, 0x45, 0x23, - 0x72, 0x9c, 0x16, 0x04, 0x4c, 0xd6, 0xc7, 0x1a, 0x2d, 0xfb, 0x8b, 0x7d, 0xd0, 0xcf, 0xb3, 0xe8, - 0xd7, 0x60, 0x70, 0x9b, 0xe7, 0x89, 0x29, 0x9c, 0x37, 0x8a, 0x2b, 0x53, 0xcf, 0xc4, 0xf3, 0xa6, - 0x95, 0x62, 0x49, 0x06, 0xad, 0xc2, 0x29, 0x9e, 0xae, 0xa7, 0x55, 0x25, 0x2d, 0x67, 0x5f, 0x8a, - 0xfd, 0x78, 0x6e, 0x59, 0x25, 0xfe, 0x5c, 0x49, 0xa3, 0xe0, 0xac, 0x7a, 0xe8, 0x55, 0x18, 0xa3, - 0xcf, 0x30, 0xbf, 0x13, 0x49, 0x4a, 0x3c, 0x51, 0x8f, 0x7a, 0xf7, 0xad, 0x1b, 0x50, 0x9c, 0xc0, - 0x46, 0xaf, 0xc0, 0x68, 0x3b, 0x25, 0xe0, 0xec, 0x8f, 0x25, 0x01, 0xa6, 0x50, 0xd3, 0xc4, 0x65, - 0xa6, 0xb5, 0x1d, 0x66, 0x48, 0xbc, 0xbe, 0x1d, 0x90, 0x70, 0xdb, 0x6f, 0x35, 0x19, 0xfb, 0xd7, - 0xaf, 0x99, 0xd6, 0x26, 0xe0, 0x38, 0x55, 0x83, 0x52, 0xd9, 0x74, 0xdc, 0x56, 0x27, 0x20, 0x31, - 0x95, 0x01, 0x93, 0xca, 0x72, 0x02, 0x8e, 0x53, 0x35, 0xba, 0x4b, 0x6e, 0x07, 0x8f, 0x47, 0x72, - 0x6b, 0xff, 0xad, 0x12, 0x18, 0x53, 0xfb, 0xad, 0x9b, 0x40, 0x88, 0x7e, 0xd9, 0x56, 0xd0, 0x6e, - 0x08, 0xcb, 0x98, 0xcc, 0x2f, 0x8b, 0xf3, 0x82, 0xf2, 0x2f, 0xa3, 0xff, 0x31, 0xab, 0x45, 0xf7, - 0xf8, 0x99, 0x5a, 0xe0, 0xd3, 0x4b, 0x4e, 0x86, 0xb1, 0x52, 0x16, 0xec, 0x83, 0xd2, 0xbb, 0xb7, - 0x20, 0xe0, 0xa3, 0xb0, 0xf1, 0xe5, 0x14, 0x0c, 0x23, 0x92, 0xba, 0xf0, 0xb5, 0x97, 0x54, 0xd0, - 0x15, 0x18, 0x16, 0x59, 0x61, 0x98, 0xa1, 0x35, 0xdf, 0x4c, 0xcc, 0xe8, 0xa5, 0x1a, 0x17, 0x63, - 0x1d, 0xc7, 0xfe, 0x81, 0x12, 0x9c, 0xca, 0xf0, 0x94, 0xe1, 0xd7, 0xc8, 0x96, 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, 0x42, 0x5f, 0x27, 0x24, 0x32, 0x54, 0xab, 0xba, - 0xb6, 0x99, 0x5a, 0x93, 0x41, 0xe8, 0x33, 0x6a, 0x4b, 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, 0x28, 0xc3, 0xb9, 0x5c, 0xdf, 0x39, 0xda, 0xf5, 0x5d, 0xdf, 0x73, 0x23, 0x5f, - 0x59, 0x13, 0xf1, 0x38, 0x83, 0xa4, 0xbd, 0xbd, 0x2a, 0xca, 0xb1, 0xc2, 0x40, 0x97, 0xa0, 0x9f, - 0x09, 0x45, 0x53, 0x49, 0x58, 0x17, 0xaa, 0x3c, 0xf0, 0x14, 0x07, 0xf7, 0x9c, 0x37, 0xfb, 0x09, - 0xca, 0xc1, 0xf8, 0xad, 0xe4, 0x85, 0x42, 0xbb, 0xeb, 0xfb, 0x2d, 0xcc, 0x80, 0xe8, 0x7d, 0x62, - 0xbc, 0x12, 0xe6, 0x33, 0xd8, 0x69, 0xfa, 0xa1, 0x36, 0x68, 0x4f, 0xc1, 0xe0, 0x0e, 0xd9, 0x0f, - 0x5c, 0x6f, 0x2b, 0x69, 0x56, 0x75, 0x9d, 0x17, 0x63, 0x09, 0x37, 0xb3, 0x06, 0x0e, 0x1e, 0x77, - 0xc2, 0xeb, 0xa1, 0xae, 0xec, 0xc9, 0x0f, 0x95, 0x61, 0x1c, 0x2f, 0x54, 0xdf, 0x9d, 0x88, 0x5b, - 0xe9, 0x89, 0x38, 0xee, 0x84, 0xd7, 0xdd, 0x67, 0xe3, 0xe7, 0x2d, 0x18, 0x67, 0xb9, 0x69, 0x84, - 0x87, 0xbc, 0xeb, 0x7b, 0x27, 0xf0, 0x14, 0x78, 0x02, 0xfa, 0x03, 0xda, 0x68, 0x32, 0xfb, 0x2a, - 0xeb, 0x09, 0xe6, 0x30, 0xf4, 0x18, 0xf4, 0xb1, 0x2e, 0xd0, 0xc9, 0x1b, 0xe1, 0x47, 0x70, 0xd5, - 0x89, 0x1c, 0xcc, 0x4a, 0x59, 0xd8, 0x25, 0x4c, 0xda, 0x2d, 0x97, 0x77, 0x3a, 0x56, 0x59, 0xbf, - 0x33, 0xbc, 0xea, 0x33, 0xbb, 0xf6, 0xf6, 0xc2, 0x2e, 0x65, 0x93, 0x2c, 0x7e, 0x66, 0xff, 0x51, - 0x09, 0x2e, 0x64, 0xd6, 0xeb, 0x39, 0xec, 0x52, 0x71, 0xed, 0x87, 0x99, 0x7d, 0xa4, 0x7c, 0x82, - 0x46, 0xab, 0x7d, 0xbd, 0x72, 0xff, 0xfd, 0x3d, 0x44, 0x43, 0xca, 0x1c, 0xb2, 0x77, 0x48, 0x34, - 0xa4, 0xcc, 0xbe, 0xe5, 0x88, 0x09, 0xfe, 0xbc, 0x94, 0xf3, 0x2d, 0x4c, 0x60, 0x70, 0x99, 0x9e, - 0x33, 0x0c, 0x18, 0xca, 0x47, 0x38, 0x3f, 0x63, 0x78, 0x19, 0x56, 0x50, 0x34, 0x0f, 0xe3, 0xbb, - 0xae, 0x47, 0x0f, 0x9f, 0x7d, 0x93, 0x15, 0x57, 0xc1, 0xea, 0x56, 0x4d, 0x30, 0x4e, 0xe2, 0x23, - 0x57, 0x8b, 0x94, 0xc4, 0xbf, 0xee, 0x95, 0x23, 0xed, 0xba, 0x59, 0x53, 0x9d, 0xaf, 0x46, 0x31, - 0x23, 0x6a, 0xd2, 0xaa, 0x26, 0x27, 0x2a, 0xf7, 0x2e, 0x27, 0x1a, 0xc9, 0x96, 0x11, 0x4d, 0xbf, - 0x02, 0xa3, 0x0f, 0xac, 0x18, 0xb0, 0xbf, 0x56, 0x86, 0x47, 0x0b, 0xb6, 0x3d, 0x3f, 0xeb, 0x8d, - 0x39, 0xd0, 0xce, 0xfa, 0xd4, 0x3c, 0xd4, 0xe0, 0xf4, 0x66, 0xa7, 0xd5, 0xda, 0x67, 0xbe, 0x1c, - 0xa4, 0x29, 0x31, 0x04, 0x4f, 0x29, 0x85, 0x23, 0xa7, 0x97, 0x33, 0x70, 0x70, 0x66, 0x4d, 0xfa, - 0xc4, 0xa2, 0x37, 0xc9, 0xbe, 0x22, 0x95, 0x78, 0x62, 0x61, 0x1d, 0x88, 0x4d, 0x5c, 0x74, 0x15, - 0x26, 0x9d, 0x3d, 0xc7, 0xe5, 0xe1, 0xa6, 0x25, 0x01, 0xfe, 0xc6, 0x52, 0xf2, 0xdc, 0xf9, 0x24, - 0x02, 0x4e, 0xd7, 0x41, 0xaf, 0x01, 0xf2, 0x37, 0x98, 0xc5, 0x77, 0xf3, 0x2a, 0xf1, 0x84, 0xd6, - 0x95, 0xcd, 0x5d, 0x39, 0x3e, 0x12, 0x6e, 0xa6, 0x30, 0x70, 0x46, 0xad, 0x44, 0x44, 0xa0, 0x81, - 0xfc, 0x88, 0x40, 0xc5, 0xe7, 0x62, 0xd7, 0xc4, 0x37, 0xff, 0xc9, 0xa2, 0xd7, 0x17, 0x67, 0xf2, - 0xcd, 0x00, 0x9a, 0xaf, 0x30, 0xab, 0x49, 0x2e, 0xeb, 0xd5, 0xe2, 0xa7, 0x9c, 0xd1, 0xac, 0x26, - 0x63, 0x20, 0x36, 0x71, 0xf9, 0x82, 0x08, 0x63, 0xb7, 0x5d, 0x83, 0xc5, 0x17, 0x51, 0xbe, 0x14, - 0x06, 0xfa, 0x38, 0x0c, 0x36, 0xdd, 0x3d, 0x37, 0x14, 0x92, 0xae, 0x23, 0xab, 0x95, 0xe2, 0x73, - 0xb0, 0xca, 0xc9, 0x60, 0x49, 0xcf, 0xfe, 0xa1, 0x12, 0x8c, 0xca, 0x16, 0x5f, 0xef, 0xf8, 0x91, - 0x73, 0x02, 0xd7, 0xf2, 0x55, 0xe3, 0x5a, 0x7e, 0x5f, 0x51, 0xa8, 0x33, 0xd6, 0xa5, 0xdc, 0xeb, - 0xf8, 0x66, 0xe2, 0x3a, 0x7e, 0xb2, 0x3b, 0xa9, 0xe2, 0x6b, 0xf8, 0x1f, 0x5b, 0x30, 0x69, 0xe0, - 0x9f, 0xc0, 0x6d, 0xb0, 0x6c, 0xde, 0x06, 0x8f, 0x77, 0xfd, 0x86, 0x9c, 0x5b, 0xe0, 0x7b, 0xcb, - 0x89, 0xbe, 0xb3, 0xd3, 0xff, 0x4d, 0xe8, 0xdb, 0x76, 0x82, 0x66, 0x51, 0x6a, 0x87, 0x54, 0xa5, - 0xd9, 0x6b, 0x4e, 0x20, 0xd4, 0xce, 0xcf, 0xc8, 0x51, 0xa7, 0x45, 0x5d, 0x55, 0xce, 0xac, 0x29, - 0xf4, 0x12, 0x0c, 0x84, 0x0d, 0xbf, 0xad, 0x3c, 0x39, 0x2e, 0xb2, 0x81, 0x66, 0x25, 0x87, 0x07, - 0x33, 0xc8, 0x6c, 0x8e, 0x16, 0x63, 0x81, 0x8f, 0x3e, 0x01, 0xa3, 0xec, 0x97, 0xb2, 0x01, 0x2b, - 0xe7, 0x8b, 0x23, 0xea, 0x3a, 0x22, 0x37, 0x90, 0x34, 0x8a, 0xb0, 0x49, 0x6a, 0x7a, 0x0b, 0x2a, - 0xea, 0xb3, 0x1e, 0xaa, 0xde, 0xf6, 0xdf, 0x97, 0xe1, 0x54, 0xc6, 0x9a, 0x43, 0xa1, 0x31, 0x13, - 0x57, 0x7a, 0x5c, 0xaa, 0x6f, 0x73, 0x2e, 0x42, 0xf6, 0x1a, 0x6a, 0x8a, 0xb5, 0xd5, 0x73, 0xa3, - 0xb7, 0x42, 0x92, 0x6c, 0x94, 0x16, 0x75, 0x6f, 0x94, 0x36, 0x76, 0x62, 0x43, 0x4d, 0x1b, 0x52, - 0x3d, 0x7d, 0xa8, 0x73, 0xfa, 0xa7, 0x65, 0x38, 0x9d, 0x15, 0x7d, 0x11, 0x7d, 0x36, 0x91, 0x58, - 0xf4, 0x85, 0x5e, 0xe3, 0x36, 0xf2, 0x6c, 0xa3, 0x22, 0x20, 0xdc, 0xac, 0x99, 0x6a, 0xb4, 0xeb, - 0x30, 0x8b, 0x36, 0x59, 0x48, 0x8a, 0x80, 0x27, 0x84, 0x95, 0xc7, 0xc7, 0x07, 0x7b, 0xee, 0x80, - 0xc8, 0x24, 0x1b, 0x26, 0xec, 0x4b, 0x64, 0x71, 0x77, 0xfb, 0x12, 0xd9, 0xf2, 0xb4, 0x0b, 0xc3, - 0xda, 0xd7, 0x3c, 0xd4, 0x19, 0xdf, 0xa1, 0xb7, 0x95, 0xd6, 0xef, 0x87, 0x3a, 0xeb, 0x3f, 0x66, - 0x41, 0xc2, 0xe5, 0x40, 0x89, 0xc5, 0xac, 0x5c, 0xb1, 0xd8, 0x45, 0xe8, 0x0b, 0xfc, 0x16, 0x49, - 0x66, 0xe0, 0xc4, 0x7e, 0x8b, 0x60, 0x06, 0xa1, 0x18, 0x51, 0x2c, 0xec, 0x18, 0xd1, 0x1f, 0x72, - 0xe2, 0x89, 0xf6, 0x04, 0xf4, 0xb7, 0xc8, 0x1e, 0x69, 0x25, 0x13, 0x25, 0xdd, 0xa0, 0x85, 0x98, - 0xc3, 0xec, 0x9f, 0xef, 0x83, 0xf3, 0x85, 0x41, 0x5d, 0xe8, 0x73, 0x68, 0xcb, 0x89, 0xc8, 0x5d, - 0x67, 0x3f, 0x99, 0xd1, 0xe4, 0x2a, 0x2f, 0xc6, 0x12, 0xce, 0x3c, 0xc9, 0x78, 0x60, 0xf2, 0x84, - 0x10, 0x51, 0xc4, 0x23, 0x17, 0x50, 0x53, 0x28, 0x55, 0x3e, 0x0e, 0xa1, 0xd4, 0x73, 0x00, 0x61, - 0xd8, 0xe2, 0x86, 0x59, 0x4d, 0xe1, 0xa2, 0x16, 0x07, 0xb0, 0xaf, 0xdf, 0x10, 0x10, 0xac, 0x61, - 0xa1, 0x2a, 0x4c, 0xb4, 0x03, 0x3f, 0xe2, 0x32, 0xd9, 0x2a, 0xb7, 0x5d, 0xec, 0x37, 0xe3, 0x69, - 0xd4, 0x12, 0x70, 0x9c, 0xaa, 0x81, 0x5e, 0x84, 0x61, 0x11, 0x63, 0xa3, 0xe6, 0xfb, 0x2d, 0x21, - 0x06, 0x52, 0xe6, 0x7c, 0xf5, 0x18, 0x84, 0x75, 0x3c, 0xad, 0x1a, 0x13, 0xf4, 0x0e, 0x66, 0x56, - 0xe3, 0xc2, 0x5e, 0x0d, 0x2f, 0x11, 0x89, 0x75, 0xa8, 0xa7, 0x48, 0xac, 0xb1, 0x60, 0xac, 0xd2, - 0xb3, 0xde, 0x11, 0xba, 0x8a, 0x92, 0x7e, 0xb6, 0x0f, 0x4e, 0x89, 0x85, 0xf3, 0xb0, 0x97, 0xcb, - 0xad, 0xf4, 0x72, 0x39, 0x0e, 0xd1, 0xd9, 0xbb, 0x6b, 0xe6, 0xa4, 0xd7, 0xcc, 0x0f, 0x5b, 0x60, - 0xb2, 0x57, 0xe8, 0xff, 0xcb, 0x4d, 0x09, 0xf5, 0x62, 0x2e, 0xbb, 0xa6, 0xa2, 0x7a, 0xbe, 0xcd, - 0xe4, 0x50, 0xf6, 0x7f, 0xb4, 0xe0, 0xf1, 0xae, 0x14, 0xd1, 0x12, 0x54, 0x18, 0x0f, 0xa8, 0xbd, - 0xce, 0x9e, 0x54, 0xb6, 0xcd, 0x12, 0x90, 0xc3, 0x92, 0xc6, 0x35, 0xd1, 0x52, 0x2a, 0xf7, 0xd6, - 0x53, 0x19, 0xb9, 0xb7, 0xce, 0x18, 0xc3, 0xf3, 0x80, 0xc9, 0xb7, 0x7e, 0x90, 0xde, 0x38, 0x86, - 0x5f, 0x11, 0xfa, 0xa0, 0x21, 0xf6, 0xb3, 0x13, 0x62, 0x3f, 0x64, 0x62, 0x6b, 0x77, 0xc8, 0x47, - 0x61, 0x82, 0x05, 0xdf, 0x62, 0x96, 0xf6, 0xc2, 0xe3, 0xa9, 0x14, 0x5b, 0xd3, 0xde, 0x48, 0xc0, - 0x70, 0x0a, 0xdb, 0xfe, 0xc3, 0x32, 0x0c, 0xf0, 0xed, 0x77, 0x02, 0x6f, 0xc2, 0xa7, 0xa1, 0xe2, - 0xee, 0xee, 0x76, 0x78, 0x3a, 0xa5, 0x7e, 0xee, 0x1b, 0x4d, 0xe7, 0x69, 0x45, 0x16, 0xe2, 0x18, - 0x8e, 0x96, 0x85, 0xc4, 0xb9, 0x20, 0xbe, 0x27, 0xef, 0xf8, 0x6c, 0xd5, 0x89, 0x1c, 0xce, 0xe0, - 0xa8, 0x7b, 0x36, 0x96, 0x4d, 0xa3, 0x4f, 0x01, 0x84, 0x51, 0xe0, 0x7a, 0x5b, 0xb4, 0x4c, 0x84, - 0x15, 0x7e, 0x7f, 0x01, 0xb5, 0xba, 0x42, 0xe6, 0x34, 0xe3, 0x33, 0x47, 0x01, 0xb0, 0x46, 0x11, - 0xcd, 0x1a, 0x37, 0xfd, 0x74, 0x62, 0xee, 0x80, 0x53, 0x8d, 0xe7, 0x6c, 0xfa, 0x43, 0x50, 0x51, - 0xc4, 0xbb, 0xc9, 0x9f, 0x46, 0x74, 0xb6, 0xe8, 0x23, 0x30, 0x9e, 0xe8, 0xdb, 0x91, 0xc4, 0x57, - 0xbf, 0x60, 0xc1, 0x38, 0xef, 0xcc, 0x92, 0xb7, 0x27, 0x6e, 0x83, 0xb7, 0xe0, 0x74, 0x2b, 0xe3, - 0x54, 0x16, 0xd3, 0xdf, 0xfb, 0x29, 0xae, 0xc4, 0x55, 0x59, 0x50, 0x9c, 0xd9, 0x06, 0xba, 0x4c, - 0x77, 0x1c, 0x3d, 0x75, 0x9d, 0x96, 0x70, 0x95, 0x1e, 0xe1, 0xbb, 0x8d, 0x97, 0x61, 0x05, 0xb5, - 0x7f, 0xc7, 0x82, 0x49, 0xde, 0xf3, 0xeb, 0x64, 0x5f, 0x9d, 0x4d, 0xdf, 0xc8, 0xbe, 0x8b, 0x44, - 0x7e, 0xa5, 0x9c, 0x44, 0x7e, 0xfa, 0xa7, 0x95, 0x0b, 0x3f, 0xed, 0xcb, 0x16, 0x88, 0x15, 0x72, - 0x02, 0x42, 0x88, 0x6f, 0x37, 0x85, 0x10, 0xd3, 0xf9, 0x9b, 0x20, 0x47, 0xfa, 0xf0, 0x67, 0x16, - 0x4c, 0x70, 0x84, 0x58, 0x5b, 0xfe, 0x0d, 0x9d, 0x87, 0x5e, 0xd2, 0x7d, 0x5f, 0x27, 0xfb, 0xeb, - 0x7e, 0xcd, 0x89, 0xb6, 0xb3, 0x3f, 0xca, 0x98, 0xac, 0xbe, 0xc2, 0xc9, 0x6a, 0xca, 0x0d, 0x64, - 0xe4, 0xb9, 0xe9, 0x12, 0x3f, 0xe2, 0xa8, 0x79, 0x6e, 0xec, 0xaf, 0x5b, 0x80, 0x78, 0x33, 0x06, - 0xe3, 0x46, 0xd9, 0x21, 0x56, 0xaa, 0x5d, 0x74, 0xf1, 0xd1, 0xa4, 0x20, 0x58, 0xc3, 0x3a, 0x96, - 0xe1, 0x49, 0x98, 0x3c, 0x94, 0xbb, 0x9b, 0x3c, 0x1c, 0x61, 0x44, 0xff, 0xcd, 0x00, 0x24, 0x7d, - 0xab, 0xd0, 0x6d, 0x18, 0x69, 0x38, 0x6d, 0x67, 0xc3, 0x6d, 0xb9, 0x91, 0x4b, 0xc2, 0x22, 0x7b, - 0xa8, 0x45, 0x0d, 0x4f, 0x28, 0xa9, 0xb5, 0x12, 0x6c, 0xd0, 0x41, 0xb3, 0x00, 0xed, 0xc0, 0xdd, - 0x73, 0x5b, 0x64, 0x8b, 0xc9, 0x4a, 0x58, 0x70, 0x06, 0x6e, 0x9c, 0x25, 0x4b, 0xb1, 0x86, 0x91, - 0xe1, 0xc8, 0x5e, 0x7e, 0xc8, 0x8e, 0xec, 0x70, 0x62, 0x8e, 0xec, 0x7d, 0x47, 0x72, 0x64, 0x1f, - 0x3a, 0xb2, 0x23, 0x7b, 0x7f, 0x4f, 0x8e, 0xec, 0x18, 0xce, 0x4a, 0xde, 0x93, 0xfe, 0x5f, 0x76, - 0x5b, 0x44, 0x3c, 0x38, 0x78, 0x44, 0x89, 0xe9, 0xfb, 0x07, 0x33, 0x67, 0x71, 0x26, 0x06, 0xce, - 0xa9, 0x89, 0x3e, 0x06, 0x53, 0x4e, 0xab, 0xe5, 0xdf, 0x55, 0x93, 0xba, 0x14, 0x36, 0x9c, 0x16, - 0x57, 0x42, 0x0c, 0x32, 0xaa, 0x8f, 0xdd, 0x3f, 0x98, 0x99, 0x9a, 0xcf, 0xc1, 0xc1, 0xb9, 0xb5, - 0xd1, 0x87, 0xa1, 0xd2, 0x0e, 0xfc, 0xc6, 0xaa, 0xe6, 0x00, 0x7a, 0x81, 0x0e, 0x60, 0x4d, 0x16, - 0x1e, 0x1e, 0xcc, 0x8c, 0xaa, 0x3f, 0xec, 0xc2, 0x8f, 0x2b, 0x64, 0x78, 0xa6, 0x0f, 0x1f, 0xab, - 0x67, 0xfa, 0x0e, 0x9c, 0xaa, 0x93, 0xc0, 0x75, 0x5a, 0xee, 0x5b, 0x94, 0x5f, 0x96, 0xe7, 0xd3, - 0x3a, 0x54, 0x82, 0xc4, 0x89, 0xdc, 0x53, 0xcc, 0x4d, 0x2d, 0xe1, 0x88, 0x3c, 0x81, 0x63, 0x42, - 0xf6, 0xff, 0xb6, 0x60, 0x50, 0xf8, 0x52, 0x9d, 0x00, 0xd7, 0x38, 0x6f, 0x68, 0x12, 0x66, 0xb2, - 0x07, 0x8c, 0x75, 0x26, 0x57, 0x87, 0xb0, 0x92, 0xd0, 0x21, 0x3c, 0x5e, 0x44, 0xa4, 0x58, 0x7b, - 0xf0, 0xd7, 0xca, 0x94, 0x7b, 0x37, 0xbc, 0x7a, 0x1f, 0xfe, 0x10, 0xac, 0xc1, 0x60, 0x28, 0xbc, - 0x4a, 0x4b, 0xf9, 0x3e, 0x0d, 0xc9, 0x49, 0x8c, 0xed, 0xd8, 0x84, 0x1f, 0xa9, 0x24, 0x92, 0xe9, - 0xae, 0x5a, 0x7e, 0x88, 0xee, 0xaa, 0xdd, 0xfc, 0x9e, 0xfb, 0x8e, 0xc3, 0xef, 0xd9, 0xfe, 0x2a, - 0xbb, 0x39, 0xf5, 0xf2, 0x13, 0x60, 0xaa, 0xae, 0x9a, 0x77, 0xac, 0x5d, 0xb0, 0xb2, 0x44, 0xa7, - 0x72, 0x98, 0xab, 0x9f, 0xb3, 0xe0, 0x7c, 0xc6, 0x57, 0x69, 0x9c, 0xd6, 0x33, 0x30, 0xe4, 0x74, - 0x9a, 0xae, 0xda, 0xcb, 0x9a, 0x3e, 0x71, 0x5e, 0x94, 0x63, 0x85, 0x81, 0x16, 0x61, 0x92, 0xdc, - 0x6b, 0xbb, 0x5c, 0x95, 0xaa, 0x9b, 0xff, 0x96, 0xb9, 0x03, 0xde, 0x52, 0x12, 0x88, 0xd3, 0xf8, - 0x2a, 0xd6, 0x4c, 0x39, 0x37, 0xd6, 0xcc, 0xdf, 0xb5, 0x60, 0x58, 0xf9, 0x55, 0x3e, 0xf4, 0xd1, - 0xfe, 0xa8, 0x39, 0xda, 0x8f, 0x16, 0x8c, 0x76, 0xce, 0x30, 0xff, 0x56, 0x49, 0xf5, 0xb7, 0xe6, - 0x07, 0x51, 0x0f, 0x1c, 0xdc, 0x83, 0xbb, 0x2e, 0x5c, 0x81, 0x61, 0xa7, 0xdd, 0x96, 0x00, 0x69, - 0x83, 0xc6, 0x22, 0x28, 0xc7, 0xc5, 0x58, 0xc7, 0x51, 0x9e, 0x14, 0xe5, 0x5c, 0x4f, 0x8a, 0x26, - 0x40, 0xe4, 0x04, 0x5b, 0x24, 0xa2, 0x65, 0xc2, 0x64, 0x36, 0xff, 0xbc, 0xe9, 0x44, 0x6e, 0x6b, - 0xd6, 0xf5, 0xa2, 0x30, 0x0a, 0x66, 0x57, 0xbc, 0xe8, 0x66, 0xc0, 0x9f, 0x90, 0x5a, 0xb4, 0x26, - 0x45, 0x0b, 0x6b, 0x74, 0x65, 0x0c, 0x01, 0xd6, 0x46, 0xbf, 0x69, 0xcc, 0xb0, 0x26, 0xca, 0xb1, - 0xc2, 0xb0, 0x3f, 0xc4, 0x6e, 0x1f, 0x36, 0xa6, 0x47, 0x8b, 0x54, 0xf4, 0xf7, 0x47, 0xd4, 0x6c, - 0x30, 0x4d, 0x66, 0x55, 0x8f, 0x87, 0x54, 0x7c, 0xd8, 0xd3, 0x86, 0x75, 0xbf, 0xbe, 0x38, 0x68, - 0x12, 0xfa, 0x8e, 0x94, 0x81, 0xca, 0xb3, 0x5d, 0x6e, 0x8d, 0x23, 0x98, 0xa4, 0xb0, 0x74, 0x2a, - 0x2c, 0xd9, 0xc4, 0x4a, 0x4d, 0xec, 0x0b, 0x2d, 0x9d, 0x8a, 0x00, 0xe0, 0x18, 0x87, 0x32, 0x53, - 0xea, 0x4f, 0x38, 0x85, 0xe2, 0xb0, 0xa2, 0x0a, 0x3b, 0xc4, 0x1a, 0x06, 0x9a, 0x13, 0x02, 0x05, - 0xae, 0x17, 0x78, 0x34, 0x21, 0x50, 0x90, 0xc3, 0xa5, 0x49, 0x81, 0xae, 0xc0, 0xb0, 0xca, 0xa0, - 0x5d, 0xe3, 0x89, 0x8c, 0xc4, 0x32, 0x5b, 0x8a, 0x8b, 0xb1, 0x8e, 0x83, 0xd6, 0x61, 0x3c, 0xe4, - 0x72, 0x36, 0x15, 0xeb, 0x99, 0xcb, 0x2b, 0xdf, 0x2f, 0xad, 0x80, 0xea, 0x26, 0xf8, 0x90, 0x15, - 0xf1, 0xd3, 0x49, 0xfa, 0xf9, 0x27, 0x49, 0xa0, 0x57, 0x61, 0xac, 0xe5, 0x3b, 0xcd, 0x05, 0xa7, - 0xe5, 0x78, 0x0d, 0x36, 0x3e, 0x43, 0x66, 0x22, 0xd6, 0x1b, 0x06, 0x14, 0x27, 0xb0, 0x29, 0xf3, - 0xa6, 0x97, 0x88, 0xf8, 0xe4, 0x8e, 0xb7, 0x45, 0x42, 0x91, 0x0f, 0x99, 0x31, 0x6f, 0x37, 0x72, - 0x70, 0x70, 0x6e, 0x6d, 0xf4, 0x12, 0x8c, 0xc8, 0xcf, 0xd7, 0xc2, 0x62, 0xc4, 0x4e, 0x29, 0x1a, - 0x0c, 0x1b, 0x98, 0xe8, 0x2e, 0x9c, 0x91, 0xff, 0xd7, 0x03, 0x67, 0x73, 0xd3, 0x6d, 0x08, 0x5f, - 0x71, 0xee, 0xbd, 0x3a, 0x2f, 0x5d, 0x2c, 0x97, 0xb2, 0x90, 0x0e, 0x0f, 0x66, 0x2e, 0x8a, 0x51, - 0xcb, 0x84, 0xb3, 0x49, 0xcc, 0xa6, 0x8f, 0x56, 0xe1, 0xd4, 0x36, 0x71, 0x5a, 0xd1, 0xf6, 0xe2, - 0x36, 0x69, 0xec, 0xc8, 0x4d, 0xc7, 0x82, 0x6d, 0x68, 0x0e, 0x1c, 0xd7, 0xd2, 0x28, 0x38, 0xab, - 0x1e, 0x7a, 0x03, 0xa6, 0xda, 0x9d, 0x8d, 0x96, 0x1b, 0x6e, 0xaf, 0xf9, 0x11, 0x33, 0x05, 0x52, - 0x09, 0xb9, 0x45, 0x54, 0x0e, 0x15, 0xce, 0xa4, 0x96, 0x83, 0x87, 0x73, 0x29, 0xa0, 0xb7, 0xe0, - 0x4c, 0x62, 0x31, 0x88, 0xb8, 0x04, 0x63, 0xf9, 0xd9, 0x1e, 0xea, 0x59, 0x15, 0x44, 0x88, 0x8f, - 0x2c, 0x10, 0xce, 0x6e, 0x02, 0xbd, 0x0c, 0xe0, 0xb6, 0x97, 0x9d, 0x5d, 0xb7, 0x45, 0x9f, 0x8b, - 0xa7, 0xd8, 0x3a, 0xa1, 0x4f, 0x07, 0x58, 0xa9, 0xc9, 0x52, 0x7a, 0x3e, 0x8b, 0x7f, 0xfb, 0x58, - 0xc3, 0x46, 0x35, 0x18, 0x13, 0xff, 0xf6, 0xc5, 0xb4, 0x4e, 0xaa, 0x10, 0x00, 0x63, 0xb2, 0x86, - 0x9a, 0x4b, 0x64, 0x96, 0xb0, 0xd9, 0x4b, 0xd4, 0x47, 0x5b, 0x70, 0x5e, 0x66, 0xef, 0xd2, 0xd7, - 0xa9, 0x9c, 0x87, 0x90, 0xa5, 0x59, 0x18, 0xe2, 0xfe, 0x21, 0xf3, 0x45, 0x88, 0xb8, 0x98, 0x0e, - 0xbd, 0xdf, 0xf5, 0xe5, 0xce, 0x3d, 0x68, 0xcf, 0x70, 0xf3, 0x24, 0x7a, 0xbf, 0xdf, 0x48, 0x02, - 0x71, 0x1a, 0x1f, 0x85, 0x70, 0xc6, 0xf5, 0xb2, 0x56, 0xf7, 0x59, 0x46, 0xe8, 0x23, 0xdc, 0x79, - 0xb8, 0x78, 0x65, 0x67, 0xc2, 0xf9, 0xca, 0xce, 0xa4, 0xfd, 0xf6, 0xac, 0xf0, 0x7e, 0xdb, 0xa2, - 0xb5, 0x35, 0x4e, 0x1d, 0x7d, 0x1a, 0x46, 0xf4, 0x0f, 0x13, 0x5c, 0xc7, 0xa5, 0x6c, 0x46, 0x56, - 0x3b, 0x1f, 0x38, 0x9f, 0xaf, 0xce, 0x00, 0x1d, 0x86, 0x0d, 0x8a, 0xa8, 0x91, 0xe1, 0x66, 0x3f, - 0xd7, 0x1b, 0x57, 0xd3, 0xbb, 0x11, 0x1a, 0x81, 0xec, 0x65, 0x8f, 0x6e, 0xc0, 0x50, 0xa3, 0xe5, - 0x12, 0x2f, 0x5a, 0xa9, 0x15, 0xc5, 0xd2, 0x5b, 0x14, 0x38, 0x62, 0x1f, 0x89, 0xac, 0x09, 0xbc, - 0x0c, 0x2b, 0x0a, 0xf6, 0xaf, 0x96, 0x60, 0xa6, 0x4b, 0x0a, 0x8e, 0x84, 0x4a, 0xca, 0xea, 0x49, - 0x25, 0x35, 0x2f, 0xb3, 0xce, 0xaf, 0x25, 0xa4, 0x5d, 0x89, 0x8c, 0xf2, 0xb1, 0xcc, 0x2b, 0x89, - 0xdf, 0xb3, 0x8b, 0x80, 0xae, 0xd5, 0xea, 0xeb, 0xea, 0xe4, 0x62, 0x68, 0xb3, 0xfb, 0x7b, 0x7f, - 0x02, 0xe7, 0x6a, 0x26, 0xed, 0xaf, 0x96, 0xe0, 0x8c, 0x1a, 0xc2, 0x6f, 0xdd, 0x81, 0xbb, 0x95, - 0x1e, 0xb8, 0x63, 0xd0, 0xeb, 0xda, 0x37, 0x61, 0x80, 0x07, 0x07, 0xec, 0x81, 0xf5, 0x7e, 0xc2, - 0x0c, 0xbe, 0xab, 0xb8, 0x3d, 0x23, 0x00, 0xef, 0xf7, 0x5b, 0x30, 0x9e, 0xf0, 0x35, 0x43, 0x58, - 0x73, 0x48, 0x7e, 0x10, 0xf6, 0x38, 0x8b, 0xf1, 0xbe, 0x08, 0x7d, 0xdb, 0x7e, 0x18, 0x25, 0x8d, - 0x3e, 0xae, 0xf9, 0x61, 0x84, 0x19, 0xc4, 0xfe, 0x5d, 0x0b, 0xfa, 0xd7, 0x1d, 0xd7, 0x8b, 0xa4, - 0x82, 0xc0, 0xca, 0x51, 0x10, 0xf4, 0xf2, 0x5d, 0xe8, 0x45, 0x18, 0x20, 0x9b, 0x9b, 0xa4, 0x11, - 0x89, 0x59, 0x95, 0xd1, 0x1c, 0x06, 0x96, 0x58, 0x29, 0xe5, 0x05, 0x59, 0x63, 0xfc, 0x2f, 0x16, - 0xc8, 0xe8, 0x0e, 0x54, 0x22, 0x77, 0x97, 0xcc, 0x37, 0x9b, 0x42, 0x6d, 0xfe, 0x00, 0x11, 0x29, - 0xd6, 0x25, 0x01, 0x1c, 0xd3, 0xb2, 0xbf, 0x50, 0x02, 0x88, 0xa3, 0x2a, 0x75, 0xfb, 0xc4, 0x85, - 0x94, 0x42, 0xf5, 0x52, 0x86, 0x42, 0x15, 0xc5, 0x04, 0x33, 0xb4, 0xa9, 0x6a, 0x98, 0xca, 0x3d, - 0x0d, 0x53, 0xdf, 0x51, 0x86, 0x69, 0x11, 0x26, 0xe3, 0xa8, 0x50, 0x66, 0x50, 0x3c, 0x76, 0x7d, - 0xae, 0x27, 0x81, 0x38, 0x8d, 0x6f, 0x13, 0xb8, 0xa8, 0x82, 0xe3, 0x88, 0x1b, 0x8d, 0x59, 0x65, - 0xeb, 0x0a, 0xea, 0x2e, 0xe3, 0x14, 0x6b, 0x8c, 0x4b, 0xb9, 0x1a, 0xe3, 0x9f, 0xb4, 0xe0, 0x74, - 0xb2, 0x1d, 0xe6, 0xc2, 0xfc, 0x79, 0x0b, 0xce, 0x30, 0xbd, 0x39, 0x6b, 0x35, 0xad, 0xa5, 0x7f, - 0xa1, 0x30, 0xe0, 0x4f, 0x4e, 0x8f, 0xe3, 0xb0, 0x21, 0xab, 0x59, 0xa4, 0x71, 0x76, 0x8b, 0xf6, - 0x7f, 0x28, 0xc1, 0x54, 0x5e, 0xa4, 0x20, 0xe6, 0xb4, 0xe1, 0xdc, 0xab, 0xef, 0x90, 0xbb, 0xc2, - 0x34, 0x3e, 0x76, 0xda, 0xe0, 0xc5, 0x58, 0xc2, 0x93, 0x59, 0x15, 0x4a, 0x3d, 0x66, 0x55, 0xd8, - 0x86, 0xc9, 0xbb, 0xdb, 0xc4, 0xbb, 0xe5, 0x85, 0x4e, 0xe4, 0x86, 0x9b, 0x2e, 0xd3, 0x31, 0xf3, - 0x75, 0x23, 0x53, 0xb1, 0x4e, 0xde, 0x49, 0x22, 0x1c, 0x1e, 0xcc, 0x9c, 0x37, 0x0a, 0xe2, 0x2e, - 0xf3, 0x83, 0x04, 0xa7, 0x89, 0xa6, 0x93, 0x52, 0xf4, 0x3d, 0xc4, 0xa4, 0x14, 0xf6, 0xe7, 0x2d, - 0x38, 0x97, 0x9b, 0x97, 0x18, 0x5d, 0x86, 0x21, 0xa7, 0xed, 0x72, 0x31, 0xbd, 0x38, 0x46, 0x99, - 0x38, 0xa8, 0xb6, 0xc2, 0x85, 0xf4, 0x0a, 0x4a, 0x4f, 0xaf, 0x1d, 0xd7, 0x6b, 0x26, 0x4f, 0xaf, - 0xeb, 0xae, 0xd7, 0xc4, 0x0c, 0xa2, 0x8e, 0xe3, 0x72, 0xde, 0x71, 0x6c, 0x7f, 0x9f, 0x05, 0xc2, - 0xe1, 0xb4, 0x87, 0xb3, 0xfb, 0x13, 0x30, 0xb2, 0x97, 0x4e, 0x5c, 0x75, 0x31, 0xdf, 0x03, 0x57, - 0xa4, 0xab, 0x52, 0x0c, 0x99, 0x91, 0xa4, 0xca, 0xa0, 0x65, 0x37, 0x41, 0x40, 0xab, 0x84, 0x09, - 0xa1, 0xbb, 0xf7, 0xe6, 0x39, 0x80, 0x26, 0xc3, 0x65, 0xd9, 0x2c, 0x4b, 0xe6, 0xcd, 0x5c, 0x55, - 0x10, 0xac, 0x61, 0xd9, 0xff, 0xae, 0x04, 0xc3, 0x32, 0x51, 0x52, 0xc7, 0xeb, 0x45, 0x54, 0x74, - 0xa4, 0xcc, 0xa9, 0x68, 0x0e, 0x2a, 0x4c, 0x96, 0x59, 0x8b, 0x25, 0x6c, 0x4a, 0x92, 0xb0, 0x2a, - 0x01, 0x38, 0xc6, 0xa1, 0xbb, 0x28, 0xec, 0x6c, 0x30, 0xf4, 0x84, 0x7b, 0x64, 0x9d, 0x17, 0x63, - 0x09, 0x47, 0x1f, 0x83, 0x09, 0x5e, 0x2f, 0xf0, 0xdb, 0xce, 0x16, 0xd7, 0x7f, 0xf4, 0xab, 0x98, - 0x13, 0x13, 0xab, 0x09, 0xd8, 0xe1, 0xc1, 0xcc, 0xe9, 0x64, 0x19, 0x53, 0xec, 0xa5, 0xa8, 0x30, - 0x33, 0x27, 0xde, 0x08, 0xdd, 0xfd, 0x29, 0xeb, 0xa8, 0x18, 0x84, 0x75, 0x3c, 0xfb, 0xd3, 0x80, - 0xd2, 0x29, 0xa3, 0xd0, 0x6b, 0xdc, 0xb6, 0xd5, 0x0d, 0x48, 0xb3, 0x48, 0xd1, 0xa7, 0x47, 0x56, - 0x90, 0x9e, 0x4d, 0xbc, 0x16, 0x56, 0xf5, 0xed, 0xbf, 0x58, 0x86, 0x89, 0xa4, 0x2f, 0x37, 0xba, - 0x06, 0x03, 0x9c, 0xf5, 0x10, 0xe4, 0x0b, 0xec, 0x48, 0x34, 0x0f, 0x70, 0x76, 0x08, 0x0b, 0xee, - 0x45, 0xd4, 0x47, 0x6f, 0xc0, 0x70, 0xd3, 0xbf, 0xeb, 0xdd, 0x75, 0x82, 0xe6, 0x7c, 0x6d, 0x45, - 0x2c, 0xe7, 0xcc, 0x87, 0x6d, 0x35, 0x46, 0xd3, 0xbd, 0xca, 0x99, 0xce, 0x34, 0x06, 0x61, 0x9d, - 0x1c, 0x5a, 0x67, 0x71, 0xe6, 0x37, 0xdd, 0xad, 0x55, 0xa7, 0x5d, 0xe4, 0xe8, 0xb0, 0x28, 0x91, - 0x34, 0xca, 0xa3, 0x22, 0x18, 0x3d, 0x07, 0xe0, 0x98, 0x10, 0xfa, 0x2c, 0x9c, 0x0a, 0x73, 0xc4, - 0xed, 0x79, 0x19, 0x04, 0x8b, 0x24, 0xd0, 0x0b, 0x8f, 0xdc, 0x3f, 0x98, 0x39, 0x95, 0x25, 0x98, - 0xcf, 0x6a, 0xc6, 0xfe, 0xe2, 0x69, 0x30, 0x36, 0xb1, 0x91, 0x50, 0xd6, 0x3a, 0xa6, 0x84, 0xb2, - 0x18, 0x86, 0xc8, 0x6e, 0x3b, 0xda, 0xaf, 0xba, 0x41, 0x51, 0x5a, 0xfd, 0x25, 0x81, 0x93, 0xa6, - 0x29, 0x21, 0x58, 0xd1, 0xc9, 0xce, 0xfa, 0x5b, 0xfe, 0x06, 0x66, 0xfd, 0xed, 0x3b, 0xc1, 0xac, - 0xbf, 0x6b, 0x30, 0xb8, 0xe5, 0x46, 0x98, 0xb4, 0x7d, 0xc1, 0xf4, 0x67, 0xae, 0xc3, 0xab, 0x1c, - 0x25, 0x9d, 0x5f, 0x52, 0x00, 0xb0, 0x24, 0x82, 0x5e, 0x53, 0x3b, 0x70, 0x20, 0xff, 0x61, 0x9e, - 0x36, 0x78, 0xc8, 0xdc, 0x83, 0x22, 0xb7, 0xef, 0xe0, 0x83, 0xe6, 0xf6, 0x5d, 0x96, 0x19, 0x79, - 0x87, 0xf2, 0xbd, 0x92, 0x58, 0xc2, 0xdd, 0x2e, 0x79, 0x78, 0x6f, 0xeb, 0x59, 0x8c, 0x2b, 0xf9, - 0x27, 0x81, 0x4a, 0x50, 0xdc, 0x63, 0xee, 0xe2, 0xef, 0xb3, 0xe0, 0x4c, 0x3b, 0x2b, 0xa1, 0xb7, - 0xb0, 0x0d, 0x78, 0xb1, 0xe7, 0x9c, 0xe1, 0x46, 0x83, 0x4c, 0xa6, 0x96, 0x9d, 0x15, 0x3e, 0xbb, - 0x39, 0x3a, 0xd0, 0xc1, 0x46, 0x53, 0xe8, 0xa8, 0x9f, 0xc8, 0x49, 0x82, 0x5c, 0x90, 0xfa, 0x78, - 0x3d, 0x23, 0xe1, 0xee, 0x7b, 0xf3, 0x12, 0xee, 0xf6, 0x9c, 0x66, 0xf7, 0x35, 0x95, 0xfe, 0x78, - 0x34, 0x7f, 0x29, 0xf1, 0xe4, 0xc6, 0x5d, 0x93, 0x1e, 0xbf, 0xa6, 0x92, 0x1e, 0x17, 0xc4, 0x03, - 0xe6, 0x29, 0x8d, 0xbb, 0xa6, 0x3a, 0xd6, 0xd2, 0x15, 0x8f, 0x1f, 0x4f, 0xba, 0x62, 0xe3, 0xaa, - 0xe1, 0x19, 0x73, 0x9f, 0xee, 0x72, 0xd5, 0x18, 0x74, 0x8b, 0x2f, 0x1b, 0x9e, 0x9a, 0x79, 0xf2, - 0x81, 0x52, 0x33, 0xdf, 0xd6, 0x53, 0x1d, 0xa3, 0x2e, 0xb9, 0x7c, 0x29, 0x52, 0x8f, 0x09, 0x8e, - 0x6f, 0xeb, 0x17, 0xe0, 0xa9, 0x7c, 0xba, 0xea, 0x9e, 0x4b, 0xd3, 0xcd, 0xbc, 0x02, 0x53, 0x89, - 0x93, 0x4f, 0x9f, 0x4c, 0xe2, 0xe4, 0x33, 0xc7, 0x9e, 0x38, 0xf9, 0xec, 0x09, 0x24, 0x4e, 0x7e, - 0xe4, 0x04, 0x13, 0x27, 0xdf, 0x66, 0x06, 0x35, 0x3c, 0x6c, 0x8f, 0x88, 0x5f, 0xfc, 0x54, 0x4e, - 0xd4, 0xab, 0x74, 0x6c, 0x1f, 0xfe, 0x71, 0x0a, 0x84, 0x63, 0x52, 0x19, 0x09, 0x99, 0xa7, 0x1e, - 0x42, 0x42, 0xe6, 0xb5, 0x38, 0x21, 0xf3, 0xb9, 0xfc, 0xa9, 0xce, 0x70, 0xc1, 0xc8, 0x49, 0xc3, - 0x7c, 0x5b, 0x4f, 0x9f, 0xfc, 0x68, 0x81, 0xd6, 0x24, 0x4b, 0xf0, 0x58, 0x90, 0x34, 0xf9, 0x55, - 0x9e, 0x34, 0xf9, 0xb1, 0xfc, 0x93, 0x3c, 0x79, 0xdd, 0x19, 0xa9, 0x92, 0x69, 0xbf, 0x54, 0xd8, - 0x4b, 0x16, 0xa9, 0x39, 0xa7, 0x5f, 0x2a, 0x6e, 0x66, 0xba, 0x5f, 0x0a, 0x84, 0x63, 0x52, 0xf6, - 0x0f, 0x94, 0xe0, 0x42, 0xf1, 0x7e, 0x8b, 0xa5, 0xa9, 0xb5, 0x58, 0x89, 0x9c, 0x90, 0xa6, 0xf2, - 0x37, 0x5b, 0x8c, 0xd5, 0x73, 0x14, 0xbf, 0xab, 0x30, 0xa9, 0x7c, 0x37, 0x5a, 0x6e, 0x63, 0x7f, - 0x2d, 0x7e, 0xf9, 0x2a, 0x7f, 0xf7, 0x7a, 0x12, 0x01, 0xa7, 0xeb, 0xa0, 0x79, 0x18, 0x37, 0x0a, - 0x57, 0xaa, 0xe2, 0x6d, 0xa6, 0xc4, 0xb7, 0x75, 0x13, 0x8c, 0x93, 0xf8, 0xf6, 0x97, 0x2c, 0x78, - 0x24, 0x27, 0xe3, 0x60, 0xcf, 0x41, 0xea, 0x36, 0x61, 0xbc, 0x6d, 0x56, 0xed, 0x12, 0x57, 0xd3, - 0xc8, 0x6b, 0xa8, 0xfa, 0x9a, 0x00, 0xe0, 0x24, 0x51, 0xfb, 0xa7, 0x4b, 0x70, 0xbe, 0xd0, 0x18, - 0x11, 0x61, 0x38, 0xbb, 0xb5, 0x1b, 0x3a, 0x8b, 0x01, 0x69, 0x12, 0x2f, 0x72, 0x9d, 0x56, 0xbd, - 0x4d, 0x1a, 0x9a, 0x3c, 0x9c, 0x59, 0xf5, 0x5d, 0x5d, 0xad, 0xcf, 0xa7, 0x31, 0x70, 0x4e, 0x4d, - 0xb4, 0x0c, 0x28, 0x0d, 0x11, 0x33, 0xcc, 0x62, 0x7e, 0xa7, 0xe9, 0xe1, 0x8c, 0x1a, 0xe8, 0x43, - 0x30, 0xaa, 0x8c, 0x1c, 0xb5, 0x19, 0x67, 0x07, 0x3b, 0xd6, 0x01, 0xd8, 0xc4, 0x43, 0x57, 0x78, - 0xd0, 0x78, 0x91, 0x5e, 0x40, 0x08, 0xcf, 0xc7, 0x65, 0x44, 0x78, 0x51, 0x8c, 0x75, 0x9c, 0x85, - 0x97, 0x7e, 0xed, 0xf7, 0x2f, 0xbc, 0xe7, 0x37, 0x7f, 0xff, 0xc2, 0x7b, 0x7e, 0xe7, 0xf7, 0x2f, - 0xbc, 0xe7, 0xbb, 0xee, 0x5f, 0xb0, 0x7e, 0xed, 0xfe, 0x05, 0xeb, 0x37, 0xef, 0x5f, 0xb0, 0x7e, - 0xe7, 0xfe, 0x05, 0xeb, 0xf7, 0xee, 0x5f, 0xb0, 0xbe, 0xf0, 0x07, 0x17, 0xde, 0xf3, 0x09, 0x14, - 0x87, 0x7d, 0x9c, 0xa3, 0xb3, 0x33, 0xb7, 0x77, 0xe5, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0xfc, - 0x1b, 0x96, 0x53, 0xd5, 0x07, 0x01, 0x00, + // 14260 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x69, 0x70, 0x24, 0xd7, + 0x79, 0x98, 0x7a, 0x06, 0xd7, 0x7c, 0xb8, 0xdf, 0x1e, 0xc4, 0x82, 0xdc, 0xc5, 0xb2, 0x29, 0x2d, + 0x97, 0x22, 0x89, 0xd5, 0xf2, 0x90, 0x68, 0x52, 0xa2, 0x05, 0x60, 0x80, 0x5d, 0x70, 0x17, 0xd8, + 0xe1, 0x1b, 0xec, 0xae, 0x24, 0x53, 0x2a, 0x35, 0x66, 0x1e, 0x80, 0x16, 0x66, 0xba, 0x87, 0xdd, + 0x3d, 0xd8, 0x05, 0x23, 0x57, 0x1c, 0xf9, 0x94, 0x8f, 0x94, 0x2a, 0xe5, 0x1c, 0x25, 0xbb, 0x5c, + 0x29, 0xc7, 0x89, 0xad, 0x28, 0x97, 0x23, 0xc7, 0x76, 0x2c, 0x27, 0x76, 0x6e, 0x27, 0x3f, 0x6c, + 0xc7, 0x55, 0xb1, 0x5c, 0xe5, 0x0a, 0x62, 0xaf, 0x53, 0xe5, 0x52, 0x55, 0x62, 0x3b, 0x71, 0xf2, + 0x23, 0x1b, 0x57, 0x9c, 0x7a, 0x67, 0xbf, 0xd7, 0xd7, 0x0c, 0x96, 0x58, 0x88, 0x52, 0xf1, 0xdf, + 0xcc, 0xfb, 0xbe, 0xf7, 0xbd, 0xd7, 0xef, 0xfc, 0xde, 0x77, 0xc2, 0x2b, 0xbb, 0x2f, 0x85, 0xf3, + 0xae, 0x7f, 0x69, 0xb7, 0xbb, 0x49, 0x02, 0x8f, 0x44, 0x24, 0xbc, 0xb4, 0x47, 0xbc, 0xa6, 0x1f, + 0x5c, 0x12, 0x00, 0xa7, 0xe3, 0x5e, 0x6a, 0xf8, 0x01, 0xb9, 0xb4, 0x77, 0xf9, 0xd2, 0x36, 0xf1, + 0x48, 0xe0, 0x44, 0xa4, 0x39, 0xdf, 0x09, 0xfc, 0xc8, 0x47, 0x88, 0xe3, 0xcc, 0x3b, 0x1d, 0x77, + 0x9e, 0xe2, 0xcc, 0xef, 0x5d, 0x9e, 0x7d, 0x76, 0xdb, 0x8d, 0x76, 0xba, 0x9b, 0xf3, 0x0d, 0xbf, + 0x7d, 0x69, 0xdb, 0xdf, 0xf6, 0x2f, 0x31, 0xd4, 0xcd, 0xee, 0x16, 0xfb, 0xc7, 0xfe, 0xb0, 0x5f, + 0x9c, 0xc4, 0xec, 0x0b, 0x71, 0x33, 0x6d, 0xa7, 0xb1, 0xe3, 0x7a, 0x24, 0xd8, 0xbf, 0xd4, 0xd9, + 0xdd, 0x66, 0xed, 0x06, 0x24, 0xf4, 0xbb, 0x41, 0x83, 0x24, 0x1b, 0x2e, 0xac, 0x15, 0x5e, 0x6a, + 0x93, 0xc8, 0xc9, 0xe8, 0xee, 0xec, 0xa5, 0xbc, 0x5a, 0x41, 0xd7, 0x8b, 0xdc, 0x76, 0xba, 0x99, + 0x0f, 0xf6, 0xaa, 0x10, 0x36, 0x76, 0x48, 0xdb, 0x49, 0xd5, 0x7b, 0x3e, 0xaf, 0x5e, 0x37, 0x72, + 0x5b, 0x97, 0x5c, 0x2f, 0x0a, 0xa3, 0x20, 0x59, 0xc9, 0xfe, 0x9a, 0x05, 0xe7, 0x17, 0x6e, 0xd7, + 0x97, 0x5b, 0x4e, 0x18, 0xb9, 0x8d, 0xc5, 0x96, 0xdf, 0xd8, 0xad, 0x47, 0x7e, 0x40, 0x6e, 0xf9, + 0xad, 0x6e, 0x9b, 0xd4, 0xd9, 0x40, 0xa0, 0x67, 0x60, 0x64, 0x8f, 0xfd, 0x5f, 0xad, 0xce, 0x58, + 0xe7, 0xad, 0x8b, 0x95, 0xc5, 0xa9, 0x5f, 0x3b, 0x98, 0x7b, 0xcf, 0xbd, 0x83, 0xb9, 0x91, 0x5b, + 0xa2, 0x1c, 0x2b, 0x0c, 0x74, 0x01, 0x86, 0xb6, 0xc2, 0x8d, 0xfd, 0x0e, 0x99, 0x29, 0x31, 0xdc, + 0x09, 0x81, 0x3b, 0xb4, 0x52, 0xa7, 0xa5, 0x58, 0x40, 0xd1, 0x25, 0xa8, 0x74, 0x9c, 0x20, 0x72, + 0x23, 0xd7, 0xf7, 0x66, 0xca, 0xe7, 0xad, 0x8b, 0x83, 0x8b, 0xd3, 0x02, 0xb5, 0x52, 0x93, 0x00, + 0x1c, 0xe3, 0xd0, 0x6e, 0x04, 0xc4, 0x69, 0xde, 0xf0, 0x5a, 0xfb, 0x33, 0x03, 0xe7, 0xad, 0x8b, + 0x23, 0x71, 0x37, 0xb0, 0x28, 0xc7, 0x0a, 0xc3, 0xfe, 0x62, 0x09, 0x46, 0x16, 0xb6, 0xb6, 0x5c, + 0xcf, 0x8d, 0xf6, 0xd1, 0x2d, 0x18, 0xf3, 0xfc, 0x26, 0x91, 0xff, 0xd9, 0x57, 0x8c, 0x3e, 0x77, + 0x7e, 0x3e, 0xbd, 0x94, 0xe6, 0xd7, 0x35, 0xbc, 0xc5, 0xa9, 0x7b, 0x07, 0x73, 0x63, 0x7a, 0x09, + 0x36, 0xe8, 0x20, 0x0c, 0xa3, 0x1d, 0xbf, 0xa9, 0xc8, 0x96, 0x18, 0xd9, 0xb9, 0x2c, 0xb2, 0xb5, + 0x18, 0x6d, 0x71, 0xf2, 0xde, 0xc1, 0xdc, 0xa8, 0x56, 0x80, 0x75, 0x22, 0x68, 0x13, 0x26, 0xe9, + 0x5f, 0x2f, 0x72, 0x15, 0xdd, 0x32, 0xa3, 0xfb, 0x44, 0x1e, 0x5d, 0x0d, 0x75, 0xf1, 0xc4, 0xbd, + 0x83, 0xb9, 0xc9, 0x44, 0x21, 0x4e, 0x12, 0xb4, 0xdf, 0x82, 0x89, 0x85, 0x28, 0x72, 0x1a, 0x3b, + 0xa4, 0xc9, 0x67, 0x10, 0xbd, 0x00, 0x03, 0x9e, 0xd3, 0x26, 0x62, 0x7e, 0xcf, 0x8b, 0x81, 0x1d, + 0x58, 0x77, 0xda, 0xe4, 0xfe, 0xc1, 0xdc, 0xd4, 0x4d, 0xcf, 0x7d, 0xb3, 0x2b, 0x56, 0x05, 0x2d, + 0xc3, 0x0c, 0x1b, 0x3d, 0x07, 0xd0, 0x24, 0x7b, 0x6e, 0x83, 0xd4, 0x9c, 0x68, 0x47, 0xcc, 0x37, + 0x12, 0x75, 0xa1, 0xaa, 0x20, 0x58, 0xc3, 0xb2, 0xef, 0x42, 0x65, 0x61, 0xcf, 0x77, 0x9b, 0x35, + 0xbf, 0x19, 0xa2, 0x5d, 0x98, 0xec, 0x04, 0x64, 0x8b, 0x04, 0xaa, 0x68, 0xc6, 0x3a, 0x5f, 0xbe, + 0x38, 0xfa, 0xdc, 0xc5, 0xcc, 0x8f, 0x35, 0x51, 0x97, 0xbd, 0x28, 0xd8, 0x5f, 0x7c, 0x44, 0xb4, + 0x37, 0x99, 0x80, 0xe2, 0x24, 0x65, 0xfb, 0x5f, 0x97, 0xe0, 0xd4, 0xc2, 0x5b, 0xdd, 0x80, 0x54, + 0xdd, 0x70, 0x37, 0xb9, 0xc2, 0x9b, 0x6e, 0xb8, 0xbb, 0x1e, 0x8f, 0x80, 0x5a, 0x5a, 0x55, 0x51, + 0x8e, 0x15, 0x06, 0x7a, 0x16, 0x86, 0xe9, 0xef, 0x9b, 0x78, 0x55, 0x7c, 0xf2, 0x09, 0x81, 0x3c, + 0x5a, 0x75, 0x22, 0xa7, 0xca, 0x41, 0x58, 0xe2, 0xa0, 0x35, 0x18, 0x6d, 0xb0, 0x0d, 0xb9, 0xbd, + 0xe6, 0x37, 0x09, 0x9b, 0xcc, 0xca, 0xe2, 0xd3, 0x14, 0x7d, 0x29, 0x2e, 0xbe, 0x7f, 0x30, 0x37, + 0xc3, 0xfb, 0x26, 0x48, 0x68, 0x30, 0xac, 0xd7, 0x47, 0xb6, 0xda, 0x5f, 0x03, 0x8c, 0x12, 0x64, + 0xec, 0xad, 0x8b, 0xda, 0x56, 0x19, 0x64, 0x5b, 0x65, 0x2c, 0x7b, 0x9b, 0xa0, 0xcb, 0x30, 0xb0, + 0xeb, 0x7a, 0xcd, 0x99, 0x21, 0x46, 0xeb, 0x2c, 0x9d, 0xf3, 0x6b, 0xae, 0xd7, 0xbc, 0x7f, 0x30, + 0x37, 0x6d, 0x74, 0x87, 0x16, 0x62, 0x86, 0x6a, 0xff, 0xa9, 0x05, 0x73, 0x0c, 0xb6, 0xe2, 0xb6, + 0x48, 0x8d, 0x04, 0xa1, 0x1b, 0x46, 0xc4, 0x8b, 0x8c, 0x01, 0x7d, 0x0e, 0x20, 0x24, 0x8d, 0x80, + 0x44, 0xda, 0x90, 0xaa, 0x85, 0x51, 0x57, 0x10, 0xac, 0x61, 0xd1, 0x03, 0x21, 0xdc, 0x71, 0x02, + 0xb6, 0xbe, 0xc4, 0xc0, 0xaa, 0x03, 0xa1, 0x2e, 0x01, 0x38, 0xc6, 0x31, 0x0e, 0x84, 0x72, 0xaf, + 0x03, 0x01, 0x7d, 0x04, 0x26, 0xe3, 0xc6, 0xc2, 0x8e, 0xd3, 0x90, 0x03, 0xc8, 0xb6, 0x4c, 0xdd, + 0x04, 0xe1, 0x24, 0xae, 0xfd, 0x77, 0x2d, 0xb1, 0x78, 0xe8, 0x57, 0xbf, 0xc3, 0xbf, 0xd5, 0xfe, + 0x45, 0x0b, 0x86, 0x17, 0x5d, 0xaf, 0xe9, 0x7a, 0xdb, 0xe8, 0xd3, 0x30, 0x42, 0xef, 0xa6, 0xa6, + 0x13, 0x39, 0xe2, 0xdc, 0xfb, 0x80, 0xb6, 0xb7, 0xd4, 0x55, 0x31, 0xdf, 0xd9, 0xdd, 0xa6, 0x05, + 0xe1, 0x3c, 0xc5, 0xa6, 0xbb, 0xed, 0xc6, 0xe6, 0x67, 0x48, 0x23, 0x5a, 0x23, 0x91, 0x13, 0x7f, + 0x4e, 0x5c, 0x86, 0x15, 0x55, 0x74, 0x0d, 0x86, 0x22, 0x27, 0xd8, 0x26, 0x91, 0x38, 0x00, 0x33, + 0x0f, 0x2a, 0x5e, 0x13, 0xd3, 0x1d, 0x49, 0xbc, 0x06, 0x89, 0xaf, 0x85, 0x0d, 0x56, 0x15, 0x0b, + 0x12, 0xf6, 0x8f, 0x0c, 0xc3, 0x99, 0xa5, 0xfa, 0x6a, 0xce, 0xba, 0xba, 0x00, 0x43, 0xcd, 0xc0, + 0xdd, 0x23, 0x81, 0x18, 0x67, 0x45, 0xa5, 0xca, 0x4a, 0xb1, 0x80, 0xa2, 0x97, 0x60, 0x8c, 0x5f, + 0x48, 0x57, 0x1d, 0xaf, 0xd9, 0x92, 0x43, 0x7c, 0x52, 0x60, 0x8f, 0xdd, 0xd2, 0x60, 0xd8, 0xc0, + 0x3c, 0xe4, 0xa2, 0xba, 0x90, 0xd8, 0x8c, 0x79, 0x97, 0xdd, 0xe7, 0x2d, 0x98, 0xe2, 0xcd, 0x2c, + 0x44, 0x51, 0xe0, 0x6e, 0x76, 0x23, 0x12, 0xce, 0x0c, 0xb2, 0x93, 0x6e, 0x29, 0x6b, 0xb4, 0x72, + 0x47, 0x60, 0xfe, 0x56, 0x82, 0x0a, 0x3f, 0x04, 0x67, 0x44, 0xbb, 0x53, 0x49, 0x30, 0x4e, 0x35, + 0x8b, 0xbe, 0xdb, 0x82, 0xd9, 0x86, 0xef, 0x45, 0x81, 0xdf, 0x6a, 0x91, 0xa0, 0xd6, 0xdd, 0x6c, + 0xb9, 0xe1, 0x0e, 0x5f, 0xa7, 0x98, 0x6c, 0xb1, 0x93, 0x20, 0x67, 0x0e, 0x15, 0x92, 0x98, 0xc3, + 0x73, 0xf7, 0x0e, 0xe6, 0x66, 0x97, 0x72, 0x49, 0xe1, 0x82, 0x66, 0xd0, 0x2e, 0x20, 0x7a, 0x95, + 0xd6, 0x23, 0x67, 0x9b, 0xc4, 0x8d, 0x0f, 0xf7, 0xdf, 0xf8, 0xe9, 0x7b, 0x07, 0x73, 0x68, 0x3d, + 0x45, 0x02, 0x67, 0x90, 0x45, 0x6f, 0xc2, 0x49, 0x5a, 0x9a, 0xfa, 0xd6, 0x91, 0xfe, 0x9b, 0x9b, + 0xb9, 0x77, 0x30, 0x77, 0x72, 0x3d, 0x83, 0x08, 0xce, 0x24, 0x8d, 0xbe, 0xcb, 0x82, 0x33, 0xf1, + 0xe7, 0x2f, 0xdf, 0xed, 0x38, 0x5e, 0x33, 0x6e, 0xb8, 0xd2, 0x7f, 0xc3, 0xf4, 0x4c, 0x3e, 0xb3, + 0x94, 0x47, 0x09, 0xe7, 0x37, 0x32, 0xbb, 0x04, 0xa7, 0x32, 0x57, 0x0b, 0x9a, 0x82, 0xf2, 0x2e, + 0xe1, 0x5c, 0x50, 0x05, 0xd3, 0x9f, 0xe8, 0x24, 0x0c, 0xee, 0x39, 0xad, 0xae, 0xd8, 0x28, 0x98, + 0xff, 0x79, 0xb9, 0xf4, 0x92, 0x65, 0xff, 0x9b, 0x32, 0x4c, 0x2e, 0xd5, 0x57, 0x1f, 0x68, 0x17, + 0xea, 0xd7, 0x50, 0xa9, 0xf0, 0x1a, 0x8a, 0x2f, 0xb5, 0x72, 0xee, 0xa5, 0xf6, 0x17, 0x33, 0xb6, + 0xd0, 0x00, 0xdb, 0x42, 0xdf, 0x96, 0xb3, 0x85, 0x8e, 0x78, 0xe3, 0xec, 0xe5, 0xac, 0xa2, 0x41, + 0x36, 0x99, 0x99, 0x1c, 0xcb, 0x75, 0xbf, 0xe1, 0xb4, 0x92, 0x47, 0xdf, 0x21, 0x97, 0xd2, 0xd1, + 0xcc, 0x63, 0x03, 0xc6, 0x96, 0x9c, 0x8e, 0xb3, 0xe9, 0xb6, 0xdc, 0xc8, 0x25, 0x21, 0x7a, 0x12, + 0xca, 0x4e, 0xb3, 0xc9, 0xb8, 0xad, 0xca, 0xe2, 0xa9, 0x7b, 0x07, 0x73, 0xe5, 0x85, 0x26, 0xbd, + 0xf6, 0x41, 0x61, 0xed, 0x63, 0x8a, 0x81, 0xde, 0x0f, 0x03, 0xcd, 0xc0, 0xef, 0xcc, 0x94, 0x18, + 0x26, 0xdd, 0x75, 0x03, 0xd5, 0xc0, 0xef, 0x24, 0x50, 0x19, 0x8e, 0xfd, 0xab, 0x25, 0x78, 0x6c, + 0x89, 0x74, 0x76, 0x56, 0xea, 0x39, 0xe7, 0xf7, 0x45, 0x18, 0x69, 0xfb, 0x9e, 0x1b, 0xf9, 0x41, + 0x28, 0x9a, 0x66, 0x2b, 0x62, 0x4d, 0x94, 0x61, 0x05, 0x45, 0xe7, 0x61, 0xa0, 0x13, 0x33, 0x95, + 0x63, 0x92, 0x21, 0x65, 0xec, 0x24, 0x83, 0x50, 0x8c, 0x6e, 0x48, 0x02, 0xb1, 0x62, 0x14, 0xc6, + 0xcd, 0x90, 0x04, 0x98, 0x41, 0xe2, 0x9b, 0x99, 0xde, 0xd9, 0xe2, 0x84, 0x4e, 0xdc, 0xcc, 0x14, + 0x82, 0x35, 0x2c, 0x54, 0x83, 0x4a, 0x98, 0x98, 0xd9, 0xbe, 0xb6, 0xe9, 0x38, 0xbb, 0xba, 0xd5, + 0x4c, 0xc6, 0x44, 0x8c, 0x1b, 0x65, 0xa8, 0xe7, 0xd5, 0xfd, 0xd5, 0x12, 0x20, 0x3e, 0x84, 0xdf, + 0x64, 0x03, 0x77, 0x33, 0x3d, 0x70, 0xfd, 0x6f, 0x89, 0xa3, 0x1a, 0xbd, 0xff, 0x65, 0xc1, 0x63, + 0x4b, 0xae, 0xd7, 0x24, 0x41, 0xce, 0x02, 0x7c, 0x38, 0x6f, 0xd9, 0xc3, 0x31, 0x0d, 0xc6, 0x12, + 0x1b, 0x38, 0x82, 0x25, 0x66, 0xff, 0xb1, 0x05, 0x88, 0x7f, 0xf6, 0x3b, 0xee, 0x63, 0x6f, 0xa6, + 0x3f, 0xf6, 0x08, 0x96, 0x85, 0x7d, 0x1d, 0x26, 0x96, 0x5a, 0x2e, 0xf1, 0xa2, 0xd5, 0xda, 0x92, + 0xef, 0x6d, 0xb9, 0xdb, 0xe8, 0x65, 0x98, 0x88, 0xdc, 0x36, 0xf1, 0xbb, 0x51, 0x9d, 0x34, 0x7c, + 0x8f, 0xbd, 0x24, 0xad, 0x8b, 0x83, 0x8b, 0xe8, 0xde, 0xc1, 0xdc, 0xc4, 0x86, 0x01, 0xc1, 0x09, + 0x4c, 0xfb, 0x77, 0xe9, 0xf8, 0xf9, 0xed, 0x8e, 0xef, 0x11, 0x2f, 0x5a, 0xf2, 0xbd, 0x26, 0x97, + 0x38, 0xbc, 0x0c, 0x03, 0x11, 0x1d, 0x0f, 0x3e, 0x76, 0x17, 0xe4, 0x46, 0xa1, 0xa3, 0x70, 0xff, + 0x60, 0xee, 0x74, 0xba, 0x06, 0x1b, 0x27, 0x56, 0x07, 0x7d, 0x1b, 0x0c, 0x85, 0x91, 0x13, 0x75, + 0x43, 0x31, 0x9a, 0x8f, 0xcb, 0xd1, 0xac, 0xb3, 0xd2, 0xfb, 0x07, 0x73, 0x93, 0xaa, 0x1a, 0x2f, + 0xc2, 0xa2, 0x02, 0x7a, 0x0a, 0x86, 0xdb, 0x24, 0x0c, 0x9d, 0x6d, 0x79, 0x1b, 0x4e, 0x8a, 0xba, + 0xc3, 0x6b, 0xbc, 0x18, 0x4b, 0x38, 0x7a, 0x02, 0x06, 0x49, 0x10, 0xf8, 0x81, 0xd8, 0xa3, 0xe3, + 0x02, 0x71, 0x70, 0x99, 0x16, 0x62, 0x0e, 0xb3, 0x7f, 0xc3, 0x82, 0x49, 0xd5, 0x57, 0xde, 0xd6, + 0x31, 0xbc, 0x0a, 0x3e, 0x01, 0xd0, 0x90, 0x1f, 0x18, 0xb2, 0xdb, 0x63, 0xf4, 0xb9, 0x0b, 0x99, + 0x17, 0x75, 0x6a, 0x18, 0x63, 0xca, 0xaa, 0x28, 0xc4, 0x1a, 0x35, 0xfb, 0x9f, 0x59, 0x70, 0x22, + 0xf1, 0x45, 0xd7, 0xdd, 0x30, 0x42, 0x6f, 0xa4, 0xbe, 0x6a, 0xbe, 0xbf, 0xaf, 0xa2, 0xb5, 0xd9, + 0x37, 0xa9, 0xa5, 0x2c, 0x4b, 0xb4, 0x2f, 0xba, 0x0a, 0x83, 0x6e, 0x44, 0xda, 0xf2, 0x63, 0x9e, + 0x28, 0xfc, 0x18, 0xde, 0xab, 0x78, 0x46, 0x56, 0x69, 0x4d, 0xcc, 0x09, 0xd8, 0xbf, 0x5a, 0x86, + 0x0a, 0x5f, 0xb6, 0x6b, 0x4e, 0xe7, 0x18, 0xe6, 0xe2, 0x69, 0xa8, 0xb8, 0xed, 0x76, 0x37, 0x72, + 0x36, 0xc5, 0x71, 0x3e, 0xc2, 0xb7, 0xd6, 0xaa, 0x2c, 0xc4, 0x31, 0x1c, 0xad, 0xc2, 0x00, 0xeb, + 0x0a, 0xff, 0xca, 0x27, 0xb3, 0xbf, 0x52, 0xf4, 0x7d, 0xbe, 0xea, 0x44, 0x0e, 0xe7, 0xa4, 0xd4, + 0x3d, 0x42, 0x8b, 0x30, 0x23, 0x81, 0x1c, 0x80, 0x4d, 0xd7, 0x73, 0x82, 0x7d, 0x5a, 0x36, 0x53, + 0x66, 0x04, 0x9f, 0x2d, 0x26, 0xb8, 0xa8, 0xf0, 0x39, 0x59, 0xf5, 0x61, 0x31, 0x00, 0x6b, 0x44, + 0x67, 0x3f, 0x04, 0x15, 0x85, 0x7c, 0x18, 0x86, 0x68, 0xf6, 0x23, 0x30, 0x99, 0x68, 0xab, 0x57, + 0xf5, 0x31, 0x9d, 0x9f, 0xfa, 0x25, 0x76, 0x64, 0x88, 0x5e, 0x2f, 0x7b, 0x7b, 0xe2, 0xc8, 0x7d, + 0x0b, 0x4e, 0xb6, 0x32, 0x4e, 0x32, 0x31, 0xaf, 0xfd, 0x9f, 0x7c, 0x8f, 0x89, 0xcf, 0x3e, 0x99, + 0x05, 0xc5, 0x99, 0x6d, 0x50, 0x1e, 0xc1, 0xef, 0xd0, 0x0d, 0xe2, 0xb4, 0x74, 0x76, 0xfb, 0x86, + 0x28, 0xc3, 0x0a, 0x4a, 0xcf, 0xbb, 0x93, 0xaa, 0xf3, 0xd7, 0xc8, 0x7e, 0x9d, 0xb4, 0x48, 0x23, + 0xf2, 0x83, 0x6f, 0x68, 0xf7, 0xcf, 0xf2, 0xd1, 0xe7, 0xc7, 0xe5, 0xa8, 0x20, 0x50, 0xbe, 0x46, + 0xf6, 0xf9, 0x54, 0xe8, 0x5f, 0x57, 0x2e, 0xfc, 0xba, 0x9f, 0xb5, 0x60, 0x5c, 0x7d, 0xdd, 0x31, + 0x9c, 0x0b, 0x8b, 0xe6, 0xb9, 0x70, 0xb6, 0x70, 0x81, 0xe7, 0x9c, 0x08, 0x5f, 0x2d, 0xc1, 0x19, + 0x85, 0x43, 0xdf, 0x06, 0xfc, 0x8f, 0x58, 0x55, 0x97, 0xa0, 0xe2, 0x29, 0xa9, 0x95, 0x65, 0x8a, + 0x8b, 0x62, 0x99, 0x55, 0x8c, 0x43, 0x59, 0x3c, 0x2f, 0x16, 0x2d, 0x8d, 0xe9, 0xe2, 0x5c, 0x21, + 0xba, 0x5d, 0x84, 0x72, 0xd7, 0x6d, 0x8a, 0x0b, 0xe6, 0x03, 0x72, 0xb4, 0x6f, 0xae, 0x56, 0xef, + 0x1f, 0xcc, 0x3d, 0x9e, 0xa7, 0x4a, 0xa0, 0x37, 0x5b, 0x38, 0x7f, 0x73, 0xb5, 0x8a, 0x69, 0x65, + 0xb4, 0x00, 0x93, 0x52, 0x5b, 0x72, 0x8b, 0xb2, 0x5b, 0xbe, 0x27, 0xee, 0x21, 0x25, 0x93, 0xc5, + 0x26, 0x18, 0x27, 0xf1, 0x51, 0x15, 0xa6, 0x76, 0xbb, 0x9b, 0xa4, 0x45, 0x22, 0xfe, 0xc1, 0xd7, + 0x08, 0x97, 0x58, 0x56, 0xe2, 0x97, 0xd9, 0xb5, 0x04, 0x1c, 0xa7, 0x6a, 0xd8, 0x7f, 0xce, 0xee, + 0x03, 0x31, 0x7a, 0xb5, 0xc0, 0xa7, 0x0b, 0x8b, 0x52, 0xff, 0x46, 0x2e, 0xe7, 0x7e, 0x56, 0xc5, + 0x35, 0xb2, 0xbf, 0xe1, 0x53, 0xce, 0x3c, 0x7b, 0x55, 0x18, 0x6b, 0x7e, 0xa0, 0x70, 0xcd, 0xff, + 0x5c, 0x09, 0x4e, 0xa9, 0x11, 0x30, 0x98, 0xc0, 0x6f, 0xf6, 0x31, 0xb8, 0x0c, 0xa3, 0x4d, 0xb2, + 0xe5, 0x74, 0x5b, 0x91, 0x12, 0x9f, 0x0f, 0x72, 0x15, 0x4a, 0x35, 0x2e, 0xc6, 0x3a, 0xce, 0x21, + 0x86, 0xed, 0x7f, 0x8f, 0xb2, 0x8b, 0x38, 0x72, 0xe8, 0x1a, 0x57, 0xbb, 0xc6, 0xca, 0xdd, 0x35, + 0x4f, 0xc0, 0xa0, 0xdb, 0xa6, 0x8c, 0x59, 0xc9, 0xe4, 0xb7, 0x56, 0x69, 0x21, 0xe6, 0x30, 0xf4, + 0x3e, 0x18, 0x6e, 0xf8, 0xed, 0xb6, 0xe3, 0x35, 0xd9, 0x95, 0x57, 0x59, 0x1c, 0xa5, 0xbc, 0xdb, + 0x12, 0x2f, 0xc2, 0x12, 0x86, 0x1e, 0x83, 0x01, 0x27, 0xd8, 0xe6, 0x32, 0x8c, 0xca, 0xe2, 0x08, + 0x6d, 0x69, 0x21, 0xd8, 0x0e, 0x31, 0x2b, 0xa5, 0x4f, 0xb0, 0x3b, 0x7e, 0xb0, 0xeb, 0x7a, 0xdb, + 0x55, 0x37, 0x10, 0x5b, 0x42, 0xdd, 0x85, 0xb7, 0x15, 0x04, 0x6b, 0x58, 0x68, 0x05, 0x06, 0x3b, + 0x7e, 0x10, 0x85, 0x33, 0x43, 0x6c, 0xb8, 0x1f, 0xcf, 0x39, 0x88, 0xf8, 0xd7, 0xd6, 0xfc, 0x20, + 0x8a, 0x3f, 0x80, 0xfe, 0x0b, 0x31, 0xaf, 0x8e, 0xae, 0xc3, 0x30, 0xf1, 0xf6, 0x56, 0x02, 0xbf, + 0x3d, 0x73, 0x22, 0x9f, 0xd2, 0x32, 0x47, 0xe1, 0xcb, 0x2c, 0xe6, 0x51, 0x45, 0x31, 0x96, 0x24, + 0xd0, 0xb7, 0x41, 0x99, 0x78, 0x7b, 0x33, 0xc3, 0x8c, 0xd2, 0x6c, 0x0e, 0xa5, 0x5b, 0x4e, 0x10, + 0x9f, 0xf9, 0xcb, 0xde, 0x1e, 0xa6, 0x75, 0xd0, 0xc7, 0xa1, 0x22, 0x0f, 0x8c, 0x50, 0x08, 0xeb, + 0x32, 0x17, 0xac, 0x3c, 0x66, 0x30, 0x79, 0xb3, 0xeb, 0x06, 0xa4, 0x4d, 0xbc, 0x28, 0x8c, 0x4f, + 0x48, 0x09, 0x0d, 0x71, 0x4c, 0x0d, 0x7d, 0x5c, 0x4a, 0x88, 0xd7, 0xfc, 0xae, 0x17, 0x85, 0x33, + 0x15, 0xd6, 0xbd, 0x4c, 0xdd, 0xdd, 0xad, 0x18, 0x2f, 0x29, 0x42, 0xe6, 0x95, 0xb1, 0x41, 0x0a, + 0x7d, 0x12, 0xc6, 0xf9, 0x7f, 0xae, 0x01, 0x0b, 0x67, 0x4e, 0x31, 0xda, 0xe7, 0xf3, 0x69, 0x73, + 0xc4, 0xc5, 0x53, 0x82, 0xf8, 0xb8, 0x5e, 0x1a, 0x62, 0x93, 0x1a, 0xc2, 0x30, 0xde, 0x72, 0xf7, + 0x88, 0x47, 0xc2, 0xb0, 0x16, 0xf8, 0x9b, 0x64, 0x06, 0xd8, 0xc0, 0x9c, 0xc9, 0xd6, 0x98, 0xf9, + 0x9b, 0x64, 0x71, 0x9a, 0xd2, 0xbc, 0xae, 0xd7, 0xc1, 0x26, 0x09, 0x74, 0x13, 0x26, 0xe8, 0x8b, + 0xcd, 0x8d, 0x89, 0x8e, 0xf6, 0x22, 0xca, 0xde, 0x55, 0xd8, 0xa8, 0x84, 0x13, 0x44, 0xd0, 0x0d, + 0x18, 0x0b, 0x23, 0x27, 0x88, 0xba, 0x1d, 0x4e, 0xf4, 0x74, 0x2f, 0xa2, 0x4c, 0xe1, 0x5a, 0xd7, + 0xaa, 0x60, 0x83, 0x00, 0x7a, 0x0d, 0x2a, 0x2d, 0x77, 0x8b, 0x34, 0xf6, 0x1b, 0x2d, 0x32, 0x33, + 0xc6, 0xa8, 0x65, 0x1e, 0x2a, 0xd7, 0x25, 0x12, 0xe7, 0x73, 0xd5, 0x5f, 0x1c, 0x57, 0x47, 0xb7, + 0xe0, 0x74, 0x44, 0x82, 0xb6, 0xeb, 0x39, 0xf4, 0x30, 0x10, 0x4f, 0x2b, 0xa6, 0xc8, 0x1c, 0x67, + 0xbb, 0xed, 0x9c, 0x98, 0x8d, 0xd3, 0x1b, 0x99, 0x58, 0x38, 0xa7, 0x36, 0xba, 0x0b, 0x33, 0x19, + 0x10, 0xbf, 0xe5, 0x36, 0xf6, 0x67, 0x4e, 0x32, 0xca, 0x1f, 0x16, 0x94, 0x67, 0x36, 0x72, 0xf0, + 0xee, 0x17, 0xc0, 0x70, 0x2e, 0x75, 0x74, 0x03, 0x26, 0xd9, 0x09, 0x54, 0xeb, 0xb6, 0x5a, 0xa2, + 0xc1, 0x09, 0xd6, 0xe0, 0xfb, 0xe4, 0x7d, 0xbc, 0x6a, 0x82, 0xef, 0x1f, 0xcc, 0x41, 0xfc, 0x0f, + 0x27, 0x6b, 0xa3, 0x4d, 0xa6, 0x33, 0xeb, 0x06, 0x6e, 0xb4, 0x4f, 0xcf, 0x0d, 0x72, 0x37, 0x9a, + 0x99, 0x2c, 0x94, 0x57, 0xe8, 0xa8, 0x4a, 0xb1, 0xa6, 0x17, 0xe2, 0x24, 0x41, 0x7a, 0xa4, 0x86, + 0x51, 0xd3, 0xf5, 0x66, 0xa6, 0xf8, 0xbb, 0x44, 0x9e, 0x48, 0x75, 0x5a, 0x88, 0x39, 0x8c, 0xe9, + 0xcb, 0xe8, 0x8f, 0x1b, 0xf4, 0xe6, 0x9a, 0x66, 0x88, 0xb1, 0xbe, 0x4c, 0x02, 0x70, 0x8c, 0x43, + 0x99, 0xc9, 0x28, 0xda, 0x9f, 0x41, 0x0c, 0x55, 0x1d, 0x2c, 0x1b, 0x1b, 0x1f, 0xc7, 0xb4, 0xdc, + 0xde, 0x84, 0x09, 0x75, 0x10, 0xb2, 0x31, 0x41, 0x73, 0x30, 0xc8, 0xd8, 0x27, 0x21, 0x5d, 0xab, + 0xd0, 0x2e, 0x30, 0xd6, 0x0a, 0xf3, 0x72, 0xd6, 0x05, 0xf7, 0x2d, 0xb2, 0xb8, 0x1f, 0x11, 0xfe, + 0xa6, 0x2f, 0x6b, 0x5d, 0x90, 0x00, 0x1c, 0xe3, 0xd8, 0xff, 0x8f, 0xb3, 0xa1, 0xf1, 0x69, 0xdb, + 0xc7, 0xfd, 0xf2, 0x0c, 0x8c, 0xec, 0xf8, 0x61, 0x44, 0xb1, 0x59, 0x1b, 0x83, 0x31, 0xe3, 0x79, + 0x55, 0x94, 0x63, 0x85, 0x81, 0x5e, 0x81, 0xf1, 0x86, 0xde, 0x80, 0xb8, 0x1c, 0xd5, 0x31, 0x62, + 0xb4, 0x8e, 0x4d, 0x5c, 0xf4, 0x12, 0x8c, 0x30, 0x1b, 0x90, 0x86, 0xdf, 0x12, 0x5c, 0x9b, 0xbc, + 0xe1, 0x47, 0x6a, 0xa2, 0xfc, 0xbe, 0xf6, 0x1b, 0x2b, 0x6c, 0x74, 0x01, 0x86, 0x68, 0x17, 0x56, + 0x6b, 0xe2, 0x5a, 0x52, 0x82, 0xa2, 0xab, 0xac, 0x14, 0x0b, 0xa8, 0xfd, 0x57, 0x4a, 0xda, 0x28, + 0xd3, 0xf7, 0x30, 0x41, 0x35, 0x18, 0xbe, 0xe3, 0xb8, 0x91, 0xeb, 0x6d, 0x0b, 0xfe, 0xe3, 0xa9, + 0xc2, 0x3b, 0x8a, 0x55, 0xba, 0xcd, 0x2b, 0xf0, 0x5b, 0x54, 0xfc, 0xc1, 0x92, 0x0c, 0xa5, 0x18, + 0x74, 0x3d, 0x8f, 0x52, 0x2c, 0xf5, 0x4b, 0x11, 0xf3, 0x0a, 0x9c, 0xa2, 0xf8, 0x83, 0x25, 0x19, + 0xf4, 0x06, 0x80, 0xdc, 0x61, 0xa4, 0x29, 0x6c, 0x2f, 0x9e, 0xe9, 0x4d, 0x74, 0x43, 0xd5, 0x59, + 0x9c, 0xa0, 0x77, 0x74, 0xfc, 0x1f, 0x6b, 0xf4, 0xec, 0x88, 0xf1, 0x69, 0xe9, 0xce, 0xa0, 0xef, + 0xa0, 0x4b, 0xdc, 0x09, 0x22, 0xd2, 0x5c, 0x88, 0xc4, 0xe0, 0xbc, 0xbf, 0xbf, 0x47, 0xca, 0x86, + 0xdb, 0x26, 0xfa, 0x76, 0x10, 0x44, 0x70, 0x4c, 0xcf, 0xfe, 0x85, 0x32, 0xcc, 0xe4, 0x75, 0x97, + 0x2e, 0x3a, 0x72, 0xd7, 0x8d, 0x96, 0x28, 0x7b, 0x65, 0x99, 0x8b, 0x6e, 0x59, 0x94, 0x63, 0x85, + 0x41, 0x67, 0x3f, 0x74, 0xb7, 0xe5, 0x1b, 0x73, 0x30, 0x9e, 0xfd, 0x3a, 0x2b, 0xc5, 0x02, 0x4a, + 0xf1, 0x02, 0xe2, 0x84, 0xc2, 0xb8, 0x47, 0x5b, 0x25, 0x98, 0x95, 0x62, 0x01, 0xd5, 0xa5, 0x5d, + 0x03, 0x3d, 0xa4, 0x5d, 0xc6, 0x10, 0x0d, 0x1e, 0xed, 0x10, 0xa1, 0x4f, 0x01, 0x6c, 0xb9, 0x9e, + 0x1b, 0xee, 0x30, 0xea, 0x43, 0x87, 0xa6, 0xae, 0x98, 0xb3, 0x15, 0x45, 0x05, 0x6b, 0x14, 0xd1, + 0x8b, 0x30, 0xaa, 0x36, 0xe0, 0x6a, 0x95, 0x69, 0x3a, 0x35, 0xcb, 0x91, 0xf8, 0x34, 0xaa, 0x62, + 0x1d, 0xcf, 0xfe, 0x4c, 0x72, 0xbd, 0x88, 0x1d, 0xa0, 0x8d, 0xaf, 0xd5, 0xef, 0xf8, 0x96, 0x8a, + 0xc7, 0xd7, 0xfe, 0x7a, 0x19, 0x26, 0x8d, 0xc6, 0xba, 0x61, 0x1f, 0x67, 0xd6, 0x15, 0x7a, 0x80, + 0x3b, 0x11, 0x11, 0xfb, 0xcf, 0xee, 0xbd, 0x55, 0xf4, 0x43, 0x9e, 0xee, 0x00, 0x5e, 0x1f, 0x7d, + 0x0a, 0x2a, 0x2d, 0x27, 0x64, 0x92, 0x33, 0x22, 0xf6, 0x5d, 0x3f, 0xc4, 0xe2, 0x87, 0x89, 0x13, + 0x46, 0xda, 0xad, 0xc9, 0x69, 0xc7, 0x24, 0xe9, 0x4d, 0x43, 0xf9, 0x13, 0x69, 0x3d, 0xa6, 0x3a, + 0x41, 0x99, 0x98, 0x7d, 0xcc, 0x61, 0xe8, 0x25, 0x18, 0x0b, 0x08, 0x5b, 0x15, 0x4b, 0x94, 0x9b, + 0x63, 0xcb, 0x6c, 0x30, 0x66, 0xfb, 0xb0, 0x06, 0xc3, 0x06, 0x66, 0xfc, 0x36, 0x18, 0x2a, 0x78, + 0x1b, 0x3c, 0x05, 0xc3, 0xec, 0x87, 0x5a, 0x01, 0x6a, 0x36, 0x56, 0x79, 0x31, 0x96, 0xf0, 0xe4, + 0x82, 0x19, 0xe9, 0x6f, 0xc1, 0xd0, 0xd7, 0x87, 0x58, 0xd4, 0x4c, 0xcb, 0x3c, 0xc2, 0x4f, 0x39, + 0xb1, 0xe4, 0xb1, 0x84, 0xd9, 0xef, 0x87, 0x89, 0xaa, 0x43, 0xda, 0xbe, 0xb7, 0xec, 0x35, 0x3b, + 0xbe, 0xeb, 0x45, 0x68, 0x06, 0x06, 0xd8, 0x25, 0xc2, 0x8f, 0x80, 0x01, 0xda, 0x10, 0x66, 0x25, + 0xf6, 0x36, 0x9c, 0xaa, 0xfa, 0x77, 0xbc, 0x3b, 0x4e, 0xd0, 0x5c, 0xa8, 0xad, 0x6a, 0xef, 0xeb, + 0x75, 0xf9, 0xbe, 0xe3, 0x46, 0x5b, 0x99, 0x47, 0xaf, 0x56, 0x93, 0xb3, 0xb5, 0x2b, 0x6e, 0x8b, + 0xe4, 0x48, 0x41, 0xfe, 0x7a, 0xc9, 0x68, 0x29, 0xc6, 0x57, 0x5a, 0x2d, 0x2b, 0x57, 0xab, 0xf5, + 0x3a, 0x8c, 0x6c, 0xb9, 0xa4, 0xd5, 0xc4, 0x64, 0x4b, 0xac, 0xc4, 0x27, 0xf3, 0xed, 0x50, 0x56, + 0x28, 0xa6, 0x94, 0x7a, 0xf1, 0xd7, 0xe1, 0x8a, 0xa8, 0x8c, 0x15, 0x19, 0xb4, 0x0b, 0x53, 0xf2, + 0xc1, 0x20, 0xa1, 0x62, 0x5d, 0x3e, 0x55, 0xf4, 0x0a, 0x31, 0x89, 0x9f, 0xbc, 0x77, 0x30, 0x37, + 0x85, 0x13, 0x64, 0x70, 0x8a, 0x30, 0x7d, 0x0e, 0xb6, 0xe9, 0x09, 0x3c, 0xc0, 0x86, 0x9f, 0x3d, + 0x07, 0xd9, 0xcb, 0x96, 0x95, 0xda, 0x3f, 0x6e, 0xc1, 0x23, 0xa9, 0x91, 0x11, 0x2f, 0xfc, 0x23, + 0x9e, 0x85, 0xe4, 0x8b, 0xbb, 0xd4, 0xfb, 0xc5, 0x6d, 0xff, 0x3d, 0x0b, 0x4e, 0x2e, 0xb7, 0x3b, + 0xd1, 0x7e, 0xd5, 0x35, 0x55, 0x50, 0x1f, 0x82, 0xa1, 0x36, 0x69, 0xba, 0xdd, 0xb6, 0x98, 0xb9, + 0x39, 0x79, 0x4a, 0xad, 0xb1, 0xd2, 0xfb, 0x07, 0x73, 0xe3, 0xf5, 0xc8, 0x0f, 0x9c, 0x6d, 0xc2, + 0x0b, 0xb0, 0x40, 0x67, 0x67, 0xbd, 0xfb, 0x16, 0xb9, 0xee, 0xb6, 0x5d, 0x69, 0x57, 0x54, 0x28, + 0xb3, 0x9b, 0x97, 0x03, 0x3a, 0xff, 0x7a, 0xd7, 0xf1, 0x22, 0x37, 0xda, 0x17, 0xda, 0x23, 0x49, + 0x04, 0xc7, 0xf4, 0xec, 0xaf, 0x59, 0x30, 0x29, 0xd7, 0xfd, 0x42, 0xb3, 0x19, 0x90, 0x30, 0x44, + 0xb3, 0x50, 0x72, 0x3b, 0xa2, 0x97, 0x20, 0x7a, 0x59, 0x5a, 0xad, 0xe1, 0x92, 0xdb, 0x91, 0x6c, + 0x19, 0x3b, 0x08, 0xcb, 0xa6, 0x22, 0xed, 0xaa, 0x28, 0xc7, 0x0a, 0x03, 0x5d, 0x84, 0x11, 0xcf, + 0x6f, 0x72, 0xdb, 0x2e, 0x7e, 0xa5, 0xb1, 0x05, 0xb6, 0x2e, 0xca, 0xb0, 0x82, 0xa2, 0x1a, 0x54, + 0xb8, 0xd9, 0x53, 0xbc, 0x68, 0xfb, 0x32, 0x9e, 0x62, 0x5f, 0xb6, 0x21, 0x6b, 0xe2, 0x98, 0x88, + 0xfd, 0x2b, 0x16, 0x8c, 0xc9, 0x2f, 0xeb, 0x93, 0xe7, 0xa4, 0x5b, 0x2b, 0xe6, 0x37, 0xe3, 0xad, + 0x45, 0x79, 0x46, 0x06, 0x31, 0x58, 0xc5, 0xf2, 0xa1, 0x58, 0xc5, 0xcb, 0x30, 0xea, 0x74, 0x3a, + 0x35, 0x93, 0xcf, 0x64, 0x4b, 0x69, 0x21, 0x2e, 0xc6, 0x3a, 0x8e, 0xfd, 0x63, 0x25, 0x98, 0x90, + 0x5f, 0x50, 0xef, 0x6e, 0x86, 0x24, 0x42, 0x1b, 0x50, 0x71, 0xf8, 0x2c, 0x11, 0xb9, 0xc8, 0x9f, + 0xc8, 0x96, 0x23, 0x18, 0x53, 0x1a, 0x5f, 0xf8, 0x0b, 0xb2, 0x36, 0x8e, 0x09, 0xa1, 0x16, 0x4c, + 0x7b, 0x7e, 0xc4, 0x0e, 0x7f, 0x05, 0x2f, 0x52, 0xed, 0x24, 0xa9, 0x9f, 0x11, 0xd4, 0xa7, 0xd7, + 0x93, 0x54, 0x70, 0x9a, 0x30, 0x5a, 0x96, 0xb2, 0x99, 0x72, 0xbe, 0x30, 0x40, 0x9f, 0xb8, 0x6c, + 0xd1, 0x8c, 0xfd, 0xcb, 0x16, 0x54, 0x24, 0xda, 0x71, 0x68, 0xf1, 0xd6, 0x60, 0x38, 0x64, 0x93, + 0x20, 0x87, 0xc6, 0x2e, 0xea, 0x38, 0x9f, 0xaf, 0xf8, 0x4e, 0xe3, 0xff, 0x43, 0x2c, 0x69, 0x30, + 0xd1, 0xbc, 0xea, 0xfe, 0x3b, 0x44, 0x34, 0xaf, 0xfa, 0x93, 0x73, 0x29, 0xfd, 0x21, 0xeb, 0xb3, + 0x26, 0xeb, 0xa2, 0xac, 0x57, 0x27, 0x20, 0x5b, 0xee, 0xdd, 0x24, 0xeb, 0x55, 0x63, 0xa5, 0x58, + 0x40, 0xd1, 0x1b, 0x30, 0xd6, 0x90, 0x32, 0xd9, 0x78, 0x87, 0x5f, 0x28, 0xd4, 0x0f, 0x28, 0x55, + 0x12, 0x97, 0x85, 0x2c, 0x69, 0xf5, 0xb1, 0x41, 0xcd, 0x34, 0x23, 0x28, 0xf7, 0x32, 0x23, 0x88, + 0xe9, 0xe6, 0x2b, 0xd5, 0x7f, 0xc2, 0x82, 0x21, 0x2e, 0x8b, 0xeb, 0x4f, 0x14, 0xaa, 0x69, 0xd6, + 0xe2, 0xb1, 0xbb, 0x45, 0x0b, 0x85, 0xa6, 0x0c, 0xad, 0x41, 0x85, 0xfd, 0x60, 0xb2, 0xc4, 0x72, + 0xbe, 0xd5, 0x3d, 0x6f, 0x55, 0xef, 0xe0, 0x2d, 0x59, 0x0d, 0xc7, 0x14, 0xec, 0x1f, 0x2d, 0xd3, + 0xd3, 0x2d, 0x46, 0x35, 0x2e, 0x7d, 0xeb, 0xe1, 0x5d, 0xfa, 0xa5, 0x87, 0x75, 0xe9, 0x6f, 0xc3, + 0x64, 0x43, 0xd3, 0xc3, 0xc5, 0x33, 0x79, 0xb1, 0x70, 0x91, 0x68, 0x2a, 0x3b, 0x2e, 0x65, 0x59, + 0x32, 0x89, 0xe0, 0x24, 0x55, 0xf4, 0x1d, 0x30, 0xc6, 0xe7, 0x59, 0xb4, 0xc2, 0x2d, 0x31, 0xde, + 0x97, 0xbf, 0x5e, 0xf4, 0x26, 0xb8, 0x54, 0x4e, 0xab, 0x8e, 0x0d, 0x62, 0xf6, 0x9f, 0x58, 0x80, + 0x96, 0x3b, 0x3b, 0xa4, 0x4d, 0x02, 0xa7, 0x15, 0x8b, 0xd3, 0x7f, 0xd0, 0x82, 0x19, 0x92, 0x2a, + 0x5e, 0xf2, 0xdb, 0x6d, 0xf1, 0x68, 0xc9, 0x79, 0x57, 0x2f, 0xe7, 0xd4, 0x51, 0x6e, 0x09, 0x33, + 0x79, 0x18, 0x38, 0xb7, 0x3d, 0xb4, 0x06, 0x27, 0xf8, 0x2d, 0xa9, 0x00, 0x9a, 0xed, 0xf5, 0xa3, + 0x82, 0xf0, 0x89, 0x8d, 0x34, 0x0a, 0xce, 0xaa, 0x67, 0x7f, 0xcf, 0x18, 0xe4, 0xf6, 0xe2, 0x5d, + 0x3d, 0xc2, 0xbb, 0x7a, 0x84, 0x77, 0xf5, 0x08, 0xef, 0xea, 0x11, 0xde, 0xd5, 0x23, 0x7c, 0xcb, + 0xeb, 0x11, 0xfe, 0xaa, 0x05, 0xa7, 0xd4, 0x35, 0x60, 0x3c, 0x7c, 0x3f, 0x0b, 0x27, 0xf8, 0x76, + 0x5b, 0x6a, 0x39, 0x6e, 0x7b, 0x83, 0xb4, 0x3b, 0x2d, 0x27, 0x92, 0x5a, 0xf7, 0xcb, 0x99, 0x2b, + 0x37, 0x61, 0xb1, 0x6a, 0x54, 0x5c, 0x7c, 0x84, 0x5e, 0x4f, 0x19, 0x00, 0x9c, 0xd5, 0x8c, 0xfd, + 0x0b, 0x23, 0x30, 0xb8, 0xbc, 0x47, 0xbc, 0xe8, 0x18, 0x9e, 0x08, 0x0d, 0x98, 0x70, 0xbd, 0x3d, + 0xbf, 0xb5, 0x47, 0x9a, 0x1c, 0x7e, 0x98, 0x97, 0xec, 0x69, 0x41, 0x7a, 0x62, 0xd5, 0x20, 0x81, + 0x13, 0x24, 0x1f, 0x86, 0x34, 0xf9, 0x0a, 0x0c, 0xf1, 0x43, 0x5c, 0x88, 0x92, 0x33, 0xcf, 0x6c, + 0x36, 0x88, 0xe2, 0x6a, 0x8a, 0x25, 0xdd, 0xfc, 0x92, 0x10, 0xd5, 0xd1, 0x67, 0x60, 0x62, 0xcb, + 0x0d, 0xc2, 0x68, 0xc3, 0x6d, 0x93, 0x30, 0x72, 0xda, 0x9d, 0x07, 0x90, 0x1e, 0xab, 0x71, 0x58, + 0x31, 0x28, 0xe1, 0x04, 0x65, 0xb4, 0x0d, 0xe3, 0x2d, 0x47, 0x6f, 0x6a, 0xf8, 0xd0, 0x4d, 0xa9, + 0xdb, 0xe1, 0xba, 0x4e, 0x08, 0x9b, 0x74, 0xe9, 0x76, 0x6a, 0x30, 0x01, 0xe8, 0x08, 0x13, 0x0b, + 0xa8, 0xed, 0xc4, 0x25, 0x9f, 0x1c, 0x46, 0x19, 0x1d, 0x66, 0x20, 0x5b, 0x31, 0x19, 0x1d, 0xcd, + 0x0c, 0xf6, 0xd3, 0x50, 0x21, 0x74, 0x08, 0x29, 0x61, 0x71, 0xc1, 0x5c, 0xea, 0xaf, 0xaf, 0x6b, + 0x6e, 0x23, 0xf0, 0x4d, 0xb9, 0xfd, 0xb2, 0xa4, 0x84, 0x63, 0xa2, 0x68, 0x09, 0x86, 0x42, 0x12, + 0xb8, 0x24, 0x14, 0x57, 0x4d, 0xc1, 0x34, 0x32, 0x34, 0xee, 0x5b, 0xc2, 0x7f, 0x63, 0x51, 0x95, + 0x2e, 0x2f, 0x87, 0x89, 0x34, 0xd9, 0x65, 0xa0, 0x2d, 0xaf, 0x05, 0x56, 0x8a, 0x05, 0x14, 0xbd, + 0x06, 0xc3, 0x01, 0x69, 0x31, 0xc5, 0xd0, 0x78, 0xff, 0x8b, 0x9c, 0xeb, 0x99, 0x78, 0x3d, 0x2c, + 0x09, 0xa0, 0x6b, 0x80, 0x02, 0x42, 0x19, 0x25, 0xd7, 0xdb, 0x56, 0x66, 0xa3, 0xe2, 0xa0, 0x55, + 0x0c, 0x29, 0x8e, 0x31, 0xa4, 0x9b, 0x0f, 0xce, 0xa8, 0x86, 0xae, 0xc0, 0xb4, 0x2a, 0x5d, 0xf5, + 0xc2, 0xc8, 0xa1, 0x07, 0xdc, 0x24, 0xa3, 0xa5, 0xe4, 0x14, 0x38, 0x89, 0x80, 0xd3, 0x75, 0xec, + 0x2f, 0x59, 0xc0, 0xc7, 0xf9, 0x18, 0x5e, 0xe7, 0xaf, 0x9a, 0xaf, 0xf3, 0x33, 0xb9, 0x33, 0x97, + 0xf3, 0x32, 0xff, 0x92, 0x05, 0xa3, 0xda, 0xcc, 0xc6, 0x6b, 0xd6, 0x2a, 0x58, 0xb3, 0x5d, 0x98, + 0xa2, 0x2b, 0xfd, 0xc6, 0x66, 0x48, 0x82, 0x3d, 0xd2, 0x64, 0x0b, 0xb3, 0xf4, 0x60, 0x0b, 0x53, + 0x99, 0xa8, 0x5d, 0x4f, 0x10, 0xc4, 0xa9, 0x26, 0xec, 0x4f, 0xcb, 0xae, 0x2a, 0x8b, 0xbe, 0x86, + 0x9a, 0xf3, 0x84, 0x45, 0x9f, 0x9a, 0x55, 0x1c, 0xe3, 0xd0, 0xad, 0xb6, 0xe3, 0x87, 0x51, 0xd2, + 0xa2, 0xef, 0xaa, 0x1f, 0x46, 0x98, 0x41, 0xec, 0xe7, 0x01, 0x96, 0xef, 0x92, 0x06, 0x5f, 0xb1, + 0xfa, 0xe3, 0xc1, 0xca, 0x7f, 0x3c, 0xd8, 0xbf, 0x65, 0xc1, 0xc4, 0xca, 0x92, 0x71, 0x73, 0xcd, + 0x03, 0xf0, 0x17, 0xcf, 0xed, 0xdb, 0xeb, 0x52, 0x1d, 0xce, 0x35, 0x9a, 0xaa, 0x14, 0x6b, 0x18, + 0xe8, 0x0c, 0x94, 0x5b, 0x5d, 0x4f, 0x88, 0x0f, 0x87, 0xe9, 0xf5, 0x78, 0xbd, 0xeb, 0x61, 0x5a, + 0xa6, 0xb9, 0x14, 0x94, 0xfb, 0x76, 0x29, 0xe8, 0xe9, 0xda, 0x8f, 0xe6, 0x60, 0xf0, 0xce, 0x1d, + 0xb7, 0xc9, 0x1d, 0x28, 0x85, 0xaa, 0xfe, 0xf6, 0xed, 0xd5, 0x6a, 0x88, 0x79, 0xb9, 0xfd, 0x85, + 0x32, 0xcc, 0xae, 0xb4, 0xc8, 0xdd, 0xb7, 0xe9, 0x44, 0xda, 0xaf, 0x43, 0xc4, 0xe1, 0x04, 0x31, + 0x87, 0x75, 0x7a, 0xe9, 0x3d, 0x1e, 0x5b, 0x30, 0xcc, 0x0d, 0xda, 0xa4, 0x4b, 0xe9, 0x2b, 0x59, + 0xad, 0xe7, 0x0f, 0xc8, 0x3c, 0x37, 0x8c, 0x13, 0x1e, 0x71, 0xea, 0xc2, 0x14, 0xa5, 0x58, 0x12, + 0x9f, 0x7d, 0x19, 0xc6, 0x74, 0xcc, 0x43, 0xb9, 0x9f, 0xfd, 0xa5, 0x32, 0x4c, 0xd1, 0x1e, 0x3c, + 0xd4, 0x89, 0xb8, 0x99, 0x9e, 0x88, 0xa3, 0x76, 0x41, 0xea, 0x3d, 0x1b, 0x6f, 0x24, 0x67, 0xe3, + 0x72, 0xde, 0x6c, 0x1c, 0xf7, 0x1c, 0x7c, 0xb7, 0x05, 0x27, 0x56, 0x5a, 0x7e, 0x63, 0x37, 0xe1, + 0x26, 0xf4, 0x22, 0x8c, 0xd2, 0xe3, 0x38, 0x34, 0x3c, 0xd8, 0x8d, 0x98, 0x06, 0x02, 0x84, 0x75, + 0x3c, 0xad, 0xda, 0xcd, 0x9b, 0xab, 0xd5, 0xac, 0x50, 0x08, 0x02, 0x84, 0x75, 0x3c, 0xfb, 0xd7, + 0x2d, 0x38, 0x7b, 0x65, 0x69, 0x39, 0x5e, 0x8a, 0xa9, 0x68, 0x0c, 0x17, 0x60, 0xa8, 0xd3, 0xd4, + 0xba, 0x12, 0x8b, 0x57, 0xab, 0xac, 0x17, 0x02, 0xfa, 0x4e, 0x89, 0x34, 0x72, 0x13, 0xe0, 0x0a, + 0xae, 0x2d, 0x89, 0x73, 0x57, 0x6a, 0x53, 0xac, 0x5c, 0x6d, 0xca, 0xfb, 0x60, 0x98, 0xde, 0x0b, + 0x6e, 0x43, 0xf6, 0x9b, 0x2b, 0x68, 0x79, 0x11, 0x96, 0x30, 0xfb, 0x67, 0x2c, 0x38, 0x71, 0xc5, + 0x8d, 0xe8, 0xa5, 0x9d, 0x0c, 0x37, 0x40, 0x6f, 0xed, 0xd0, 0x8d, 0xfc, 0x60, 0x3f, 0x19, 0x6e, + 0x00, 0x2b, 0x08, 0xd6, 0xb0, 0xf8, 0x07, 0xed, 0xb9, 0xcc, 0x42, 0xbb, 0x64, 0xea, 0xaf, 0xb0, + 0x28, 0xc7, 0x0a, 0x83, 0x8e, 0x57, 0xd3, 0x0d, 0x98, 0xe8, 0x6f, 0x5f, 0x1c, 0xdc, 0x6a, 0xbc, + 0xaa, 0x12, 0x80, 0x63, 0x1c, 0xfb, 0x8f, 0x2c, 0x98, 0xbb, 0xd2, 0xea, 0x86, 0x11, 0x09, 0xb6, + 0xc2, 0x9c, 0x43, 0xf7, 0x79, 0xa8, 0x10, 0x29, 0x68, 0x17, 0xbd, 0x56, 0x8c, 0xa8, 0x92, 0xc0, + 0xf3, 0xa8, 0x07, 0x0a, 0xaf, 0x0f, 0x5f, 0xc6, 0xc3, 0x39, 0xa3, 0xad, 0x00, 0x22, 0x7a, 0x5b, + 0x7a, 0x18, 0x08, 0xe6, 0x4f, 0xbe, 0x9c, 0x82, 0xe2, 0x8c, 0x1a, 0xf6, 0x8f, 0x5b, 0x70, 0x4a, + 0x7d, 0xf0, 0x3b, 0xee, 0x33, 0xed, 0xaf, 0x94, 0x60, 0xfc, 0xea, 0xc6, 0x46, 0xed, 0x0a, 0x89, + 0xb4, 0x55, 0x59, 0xac, 0x3e, 0xc7, 0x9a, 0x16, 0xb0, 0xe8, 0x8d, 0xd8, 0x8d, 0xdc, 0xd6, 0x3c, + 0x8f, 0x26, 0x34, 0xbf, 0xea, 0x45, 0x37, 0x82, 0x7a, 0x14, 0xb8, 0xde, 0x76, 0xe6, 0x4a, 0x97, + 0x3c, 0x4b, 0x39, 0x8f, 0x67, 0x41, 0xcf, 0xc3, 0x10, 0x0b, 0x67, 0x24, 0x27, 0xe1, 0x51, 0xf5, + 0xc4, 0x62, 0xa5, 0xf7, 0x0f, 0xe6, 0x2a, 0x37, 0xf1, 0x2a, 0xff, 0x83, 0x05, 0x2a, 0xba, 0x09, + 0xa3, 0x3b, 0x51, 0xd4, 0xb9, 0x4a, 0x9c, 0x26, 0x09, 0xe4, 0x29, 0x7b, 0x2e, 0xeb, 0x94, 0xa5, + 0x83, 0xc0, 0xd1, 0xe2, 0x83, 0x29, 0x2e, 0x0b, 0xb1, 0x4e, 0xc7, 0xae, 0x03, 0xc4, 0xb0, 0x23, + 0x52, 0x80, 0xd8, 0x1b, 0x50, 0xa1, 0x9f, 0xbb, 0xd0, 0x72, 0x9d, 0x62, 0x15, 0xf3, 0xd3, 0x50, + 0x91, 0x0a, 0xe4, 0x50, 0xf8, 0x5a, 0xb3, 0x1b, 0x49, 0xea, 0x97, 0x43, 0x1c, 0xc3, 0xed, 0x2d, + 0x38, 0xc9, 0xcc, 0x01, 0x9d, 0x68, 0xc7, 0x58, 0x7d, 0xbd, 0xa7, 0xf9, 0x19, 0xf1, 0x62, 0xe3, + 0x7d, 0x9e, 0xd1, 0xdc, 0x19, 0xc7, 0x24, 0xc5, 0xf8, 0xf5, 0x66, 0x7f, 0x7d, 0x00, 0x1e, 0x5d, + 0xad, 0xe7, 0x87, 0xe3, 0x78, 0x09, 0xc6, 0x38, 0x23, 0x48, 0x27, 0xdd, 0x69, 0x89, 0x76, 0x95, + 0x6c, 0x73, 0x43, 0x83, 0x61, 0x03, 0x13, 0x9d, 0x85, 0xb2, 0xfb, 0xa6, 0x97, 0x74, 0xf6, 0x59, + 0x7d, 0x7d, 0x1d, 0xd3, 0x72, 0x0a, 0xa6, 0x3c, 0x25, 0x3f, 0xac, 0x15, 0x58, 0xf1, 0x95, 0xaf, + 0xc2, 0x84, 0x1b, 0x36, 0x42, 0x77, 0xd5, 0xa3, 0x3b, 0x50, 0xdb, 0xc3, 0x4a, 0x9a, 0x40, 0x3b, + 0xad, 0xa0, 0x38, 0x81, 0xad, 0xdd, 0x1c, 0x83, 0x7d, 0xf3, 0xa5, 0x3d, 0x9d, 0x8f, 0xe9, 0xc1, + 0xde, 0x61, 0x5f, 0x17, 0x32, 0x21, 0xb5, 0x38, 0xd8, 0xf9, 0x07, 0x87, 0x58, 0xc2, 0xe8, 0x53, + 0xad, 0xb1, 0xe3, 0x74, 0x16, 0xba, 0xd1, 0x4e, 0xd5, 0x0d, 0x1b, 0xfe, 0x1e, 0x09, 0xf6, 0xd9, + 0x2b, 0x7b, 0x24, 0x7e, 0xaa, 0x29, 0xc0, 0xd2, 0xd5, 0x85, 0x1a, 0xc5, 0xc4, 0xe9, 0x3a, 0x68, + 0x01, 0x26, 0x65, 0x61, 0x9d, 0x84, 0xec, 0x70, 0x1f, 0x65, 0x64, 0x94, 0xfb, 0x8d, 0x28, 0x56, + 0x44, 0x92, 0xf8, 0x26, 0xeb, 0x0a, 0x47, 0xc1, 0xba, 0x7e, 0x08, 0xc6, 0x5d, 0xcf, 0x8d, 0x5c, + 0x27, 0xf2, 0xb9, 0x86, 0x85, 0x3f, 0xa8, 0x99, 0xe8, 0x78, 0x55, 0x07, 0x60, 0x13, 0xcf, 0xfe, + 0xaf, 0x03, 0x30, 0xcd, 0xa6, 0xed, 0xdd, 0x15, 0xf6, 0xad, 0xb4, 0xc2, 0x6e, 0xa6, 0x57, 0xd8, + 0x51, 0xf0, 0xe4, 0x0f, 0xbc, 0xcc, 0x3e, 0x03, 0x15, 0xe5, 0x71, 0x24, 0x5d, 0x0e, 0xad, 0x1c, + 0x97, 0xc3, 0xde, 0xf7, 0xb2, 0x34, 0xda, 0x2a, 0x67, 0x1a, 0x6d, 0x7d, 0xd9, 0x82, 0x58, 0x65, + 0x80, 0x5e, 0x87, 0x4a, 0xc7, 0x67, 0xb6, 0x88, 0x81, 0x34, 0xf0, 0x7d, 0x6f, 0xa1, 0xce, 0x81, + 0x47, 0x24, 0x0a, 0xf8, 0x28, 0xd4, 0x64, 0x55, 0x1c, 0x53, 0x41, 0xd7, 0x60, 0xb8, 0x13, 0x90, + 0x7a, 0xc4, 0xc2, 0x73, 0xf4, 0x4f, 0x90, 0xaf, 0x1a, 0x5e, 0x11, 0x4b, 0x0a, 0xf6, 0x7f, 0xb3, + 0x60, 0x2a, 0x89, 0x8a, 0x3e, 0x0c, 0x03, 0xe4, 0x2e, 0x69, 0x88, 0xfe, 0x66, 0x5e, 0xb2, 0xb1, + 0xd0, 0x81, 0x0f, 0x00, 0xfd, 0x8f, 0x59, 0x2d, 0x74, 0x15, 0x86, 0xe9, 0x0d, 0x7b, 0x45, 0x85, + 0x86, 0x7a, 0x3c, 0xef, 0x96, 0x56, 0xac, 0x0a, 0xef, 0x9c, 0x28, 0xc2, 0xb2, 0x3a, 0xb3, 0x94, + 0x6a, 0x74, 0xea, 0xf4, 0xf1, 0x12, 0x15, 0xbd, 0xb1, 0x37, 0x96, 0x6a, 0x1c, 0x49, 0x50, 0xe3, + 0x96, 0x52, 0xb2, 0x10, 0xc7, 0x44, 0xec, 0x9f, 0xb3, 0x00, 0xb8, 0x61, 0x98, 0xe3, 0x6d, 0x93, + 0x63, 0x90, 0x93, 0x57, 0x61, 0x20, 0xec, 0x90, 0x46, 0x91, 0x99, 0x6c, 0xdc, 0x9f, 0x7a, 0x87, + 0x34, 0xe2, 0x15, 0x47, 0xff, 0x61, 0x56, 0xdb, 0xfe, 0x5e, 0x80, 0x89, 0x18, 0x6d, 0x35, 0x22, + 0x6d, 0xf4, 0xac, 0x11, 0xa6, 0xe0, 0x4c, 0x22, 0x4c, 0x41, 0x85, 0x61, 0x6b, 0x22, 0xd9, 0xcf, + 0x40, 0xb9, 0xed, 0xdc, 0x15, 0x32, 0xb7, 0xa7, 0x8b, 0xbb, 0x41, 0xe9, 0xcf, 0xaf, 0x39, 0x77, + 0xf9, 0xb3, 0xf4, 0x69, 0xb9, 0x43, 0xd6, 0x9c, 0xbb, 0xf7, 0xb9, 0x31, 0x2c, 0x3b, 0xa5, 0xaf, + 0xbb, 0x61, 0xf4, 0xb9, 0xff, 0x12, 0xff, 0x67, 0xfb, 0x8e, 0x36, 0xc2, 0xda, 0x72, 0x3d, 0x61, + 0xf3, 0xd4, 0x57, 0x5b, 0xae, 0x97, 0x6c, 0xcb, 0xf5, 0xfa, 0x68, 0xcb, 0xf5, 0xd0, 0x5b, 0x30, + 0x2c, 0x4c, 0x12, 0x45, 0x58, 0xa0, 0x4b, 0x7d, 0xb4, 0x27, 0x2c, 0x1a, 0x79, 0x9b, 0x97, 0xe4, + 0xb3, 0x5b, 0x94, 0xf6, 0x6c, 0x57, 0x36, 0x88, 0xfe, 0x9a, 0x05, 0x13, 0xe2, 0x37, 0x26, 0x6f, + 0x76, 0x49, 0x18, 0x09, 0xb6, 0xf4, 0x83, 0xfd, 0xf7, 0x41, 0x54, 0xe4, 0x5d, 0xf9, 0xa0, 0xbc, + 0x67, 0x4c, 0x60, 0xcf, 0x1e, 0x25, 0x7a, 0x81, 0xfe, 0x81, 0x05, 0x27, 0xdb, 0xce, 0x5d, 0xde, + 0x22, 0x2f, 0xc3, 0x4e, 0xe4, 0xfa, 0x42, 0xb5, 0xff, 0xe1, 0xfe, 0xa6, 0x3f, 0x55, 0x9d, 0x77, + 0x52, 0xea, 0x1f, 0x4f, 0x66, 0xa1, 0xf4, 0xec, 0x6a, 0x66, 0xbf, 0x66, 0xb7, 0x60, 0x44, 0xae, + 0xb7, 0x0c, 0xe1, 0x46, 0x55, 0xe7, 0xb9, 0x0f, 0x6d, 0x11, 0xaa, 0xbb, 0xff, 0xd3, 0x76, 0xc4, + 0x5a, 0x7b, 0xa8, 0xed, 0x7c, 0x06, 0xc6, 0xf4, 0x35, 0xf6, 0x50, 0xdb, 0x7a, 0x13, 0x4e, 0x64, + 0xac, 0xa5, 0x87, 0xda, 0xe4, 0x1d, 0x38, 0x93, 0xbb, 0x3e, 0x1e, 0x66, 0xc3, 0xf6, 0x57, 0x2c, + 0xfd, 0x1c, 0x3c, 0x06, 0x65, 0xc5, 0x92, 0xa9, 0xac, 0x38, 0x57, 0xbc, 0x73, 0x72, 0x34, 0x16, + 0x6f, 0xe8, 0x9d, 0xa6, 0xa7, 0x3a, 0x7a, 0x0d, 0x86, 0x5a, 0xb4, 0x44, 0x1a, 0xb6, 0xda, 0xbd, + 0x77, 0x64, 0xcc, 0x4c, 0xb2, 0xf2, 0x10, 0x0b, 0x0a, 0xf6, 0x2f, 0x5a, 0x30, 0x70, 0x0c, 0x23, + 0x81, 0xcd, 0x91, 0x78, 0x36, 0x97, 0xb4, 0x88, 0x58, 0x3c, 0x8f, 0x9d, 0x3b, 0xcb, 0x77, 0x23, + 0xe2, 0x85, 0xec, 0x46, 0xce, 0x1c, 0x98, 0x9f, 0xb2, 0xe0, 0xc4, 0x75, 0xdf, 0x69, 0x2e, 0x3a, + 0x2d, 0xc7, 0x6b, 0x90, 0x60, 0xd5, 0xdb, 0x3e, 0x94, 0x55, 0x76, 0xa9, 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, 0x27, 0xb3, 0x39, 0xdc, + 0xd4, 0xe7, 0x69, 0xde, 0x1f, 0xbc, 0x00, 0x4b, 0x42, 0xf6, 0x4b, 0x90, 0xe9, 0x68, 0xdf, 0x5b, + 0x2e, 0x61, 0x7f, 0x1c, 0xa6, 0x59, 0xcd, 0x43, 0x4a, 0x06, 0xec, 0x84, 0x34, 0x35, 0x23, 0x04, + 0x9f, 0xfd, 0x79, 0x0b, 0x26, 0xd7, 0x13, 0x91, 0xc9, 0x2e, 0x30, 0xfd, 0x6b, 0x86, 0x10, 0xbf, + 0xce, 0x4a, 0xb1, 0x80, 0x1e, 0xb9, 0x90, 0xeb, 0xcf, 0x2d, 0x88, 0x63, 0x5f, 0x1c, 0x03, 0xfb, + 0xb6, 0x64, 0xb0, 0x6f, 0x99, 0x8c, 0xac, 0xea, 0x4e, 0x1e, 0xf7, 0x86, 0xae, 0xa9, 0xa8, 0x50, + 0x05, 0x3c, 0x6c, 0x4c, 0x86, 0x2f, 0xc5, 0x09, 0x33, 0x74, 0x94, 0x8c, 0x13, 0x65, 0xff, 0x76, + 0x09, 0x90, 0xc2, 0xed, 0x3b, 0x6a, 0x55, 0xba, 0xc6, 0xd1, 0x44, 0xad, 0xda, 0x03, 0xc4, 0x2c, + 0x08, 0x02, 0xc7, 0x0b, 0x39, 0x59, 0x57, 0x88, 0xf5, 0x0e, 0x67, 0x9e, 0x30, 0x2b, 0x9a, 0x44, + 0xd7, 0x53, 0xd4, 0x70, 0x46, 0x0b, 0x9a, 0x65, 0xc8, 0x60, 0xbf, 0x96, 0x21, 0x43, 0x3d, 0xfc, + 0xe0, 0x7e, 0xd6, 0x82, 0x71, 0x35, 0x4c, 0xef, 0x10, 0x2b, 0x75, 0xd5, 0x9f, 0x9c, 0x03, 0xb4, + 0xa6, 0x75, 0x99, 0x5d, 0x2c, 0xdf, 0xce, 0xfc, 0x19, 0x9d, 0x96, 0xfb, 0x16, 0x51, 0x31, 0x03, + 0xe7, 0x84, 0x7f, 0xa2, 0x28, 0xbd, 0x7f, 0x30, 0x37, 0xae, 0xfe, 0xf1, 0x18, 0xc5, 0x71, 0x15, + 0x7a, 0x24, 0x4f, 0x26, 0x96, 0x22, 0x7a, 0x11, 0x06, 0x3b, 0x3b, 0x4e, 0x48, 0x12, 0xde, 0x3c, + 0x83, 0x35, 0x5a, 0x78, 0xff, 0x60, 0x6e, 0x42, 0x55, 0x60, 0x25, 0x98, 0x63, 0xf7, 0x1f, 0x0b, + 0x2c, 0xbd, 0x38, 0x7b, 0xc6, 0x02, 0xfb, 0x13, 0x0b, 0x06, 0xd6, 0xfd, 0xe6, 0x71, 0x1c, 0x01, + 0xaf, 0x1a, 0x47, 0xc0, 0x63, 0x79, 0xe1, 0xe3, 0x73, 0x77, 0xff, 0x4a, 0x62, 0xf7, 0x9f, 0xcb, + 0xa5, 0x50, 0xbc, 0xf1, 0xdb, 0x30, 0xca, 0x82, 0xd2, 0x0b, 0xcf, 0xa5, 0xe7, 0x8d, 0x0d, 0x3f, + 0x97, 0xd8, 0xf0, 0x93, 0x1a, 0xaa, 0xb6, 0xd3, 0x9f, 0x82, 0x61, 0xe1, 0x0a, 0x93, 0x74, 0x0b, + 0x15, 0xb8, 0x58, 0xc2, 0xed, 0x9f, 0x28, 0x83, 0x11, 0x04, 0x1f, 0xfd, 0xb2, 0x05, 0xf3, 0x01, + 0x37, 0x91, 0x6d, 0x56, 0xbb, 0x81, 0xeb, 0x6d, 0xd7, 0x1b, 0x3b, 0xa4, 0xd9, 0x6d, 0xb9, 0xde, + 0xf6, 0xea, 0xb6, 0xe7, 0xab, 0xe2, 0xe5, 0xbb, 0xa4, 0xd1, 0x65, 0x6a, 0xb7, 0x1e, 0x11, 0xf7, + 0x95, 0xa9, 0xf9, 0x73, 0xf7, 0x0e, 0xe6, 0xe6, 0xf1, 0xa1, 0x68, 0xe3, 0x43, 0xf6, 0x05, 0xfd, + 0xba, 0x05, 0x97, 0x78, 0x6c, 0xf8, 0xfe, 0xfb, 0x5f, 0xf0, 0x5a, 0xae, 0x49, 0x52, 0x31, 0x91, + 0x0d, 0x12, 0xb4, 0x17, 0x3f, 0x24, 0x06, 0xf4, 0x52, 0xed, 0x70, 0x6d, 0xe1, 0xc3, 0x76, 0xce, + 0xfe, 0x17, 0x65, 0x18, 0x17, 0x31, 0xa3, 0xc4, 0x1d, 0xf0, 0xa2, 0xb1, 0x24, 0x1e, 0x4f, 0x2c, + 0x89, 0x69, 0x03, 0xf9, 0x68, 0x8e, 0xff, 0x10, 0xa6, 0xe9, 0xe1, 0x7c, 0x95, 0x38, 0x41, 0xb4, + 0x49, 0x1c, 0x6e, 0xf0, 0x55, 0x3e, 0xf4, 0xe9, 0xaf, 0xe4, 0x93, 0xd7, 0x93, 0xc4, 0x70, 0x9a, + 0xfe, 0xb7, 0xd2, 0x9d, 0xe3, 0xc1, 0x54, 0x2a, 0xec, 0xd7, 0x27, 0xa0, 0xa2, 0xfc, 0x38, 0xc4, + 0xa1, 0x53, 0x1c, 0x3d, 0x2f, 0x49, 0x81, 0x8b, 0xbf, 0x62, 0x1f, 0xa2, 0x98, 0x9c, 0xfd, 0x8f, + 0x4a, 0x46, 0x83, 0x7c, 0x12, 0xd7, 0x61, 0xc4, 0x09, 0x43, 0x77, 0xdb, 0x23, 0xcd, 0x22, 0x09, + 0x65, 0xaa, 0x19, 0xe6, 0x4b, 0xb3, 0x20, 0x6a, 0x62, 0x45, 0x03, 0x5d, 0xe5, 0x66, 0x75, 0x7b, + 0xa4, 0x48, 0x3c, 0x99, 0xa2, 0x06, 0xd2, 0xf0, 0x6e, 0x8f, 0x60, 0x51, 0x1f, 0x7d, 0x92, 0xdb, + 0x3d, 0x5e, 0xf3, 0xfc, 0x3b, 0xde, 0x15, 0xdf, 0x97, 0x71, 0x19, 0xfa, 0x23, 0x38, 0x2d, 0xad, + 0x1d, 0x55, 0x75, 0x6c, 0x52, 0xeb, 0x2f, 0x8e, 0xe6, 0x67, 0xe1, 0x04, 0x25, 0x6d, 0xba, 0x4d, + 0x87, 0x88, 0xc0, 0xa4, 0x08, 0x48, 0x26, 0xcb, 0xc4, 0xd8, 0x65, 0x3e, 0xe5, 0xcc, 0xda, 0xb1, + 0x20, 0xfd, 0x9a, 0x49, 0x02, 0x27, 0x69, 0xda, 0x3f, 0x6d, 0x01, 0x73, 0x21, 0x3d, 0x06, 0x7e, + 0xe4, 0x23, 0x26, 0x3f, 0x32, 0x93, 0x37, 0xc8, 0x39, 0xac, 0xc8, 0x0b, 0x7c, 0x65, 0xd5, 0x02, + 0xff, 0xee, 0xbe, 0x30, 0x56, 0xe9, 0xfd, 0xfe, 0xb0, 0xff, 0xaf, 0xc5, 0x0f, 0x31, 0xe5, 0x65, + 0x81, 0xbe, 0x13, 0x46, 0x1a, 0x4e, 0xc7, 0x69, 0xf0, 0x8c, 0x2d, 0xb9, 0x12, 0x3d, 0xa3, 0xd2, + 0xfc, 0x92, 0xa8, 0xc1, 0x25, 0x54, 0x32, 0xb0, 0xdd, 0x88, 0x2c, 0xee, 0x29, 0x95, 0x52, 0x4d, + 0xce, 0xee, 0xc2, 0xb8, 0x41, 0xec, 0xa1, 0x8a, 0x33, 0xbe, 0x93, 0x5f, 0xb1, 0x2a, 0x10, 0x63, + 0x1b, 0xa6, 0x3d, 0xed, 0x3f, 0xbd, 0x50, 0xe4, 0xe3, 0xf2, 0xbd, 0xbd, 0x2e, 0x51, 0x76, 0xfb, + 0x68, 0xde, 0xa9, 0x09, 0x32, 0x38, 0x4d, 0xd9, 0xfe, 0x49, 0x0b, 0x1e, 0xd1, 0x11, 0x35, 0x07, + 0x98, 0x5e, 0x4a, 0x92, 0x2a, 0x8c, 0xf8, 0x1d, 0x12, 0x38, 0x91, 0x1f, 0x88, 0x5b, 0xe3, 0xa2, + 0x1c, 0xf4, 0x1b, 0xa2, 0xfc, 0xbe, 0x88, 0x77, 0x2e, 0xa9, 0xcb, 0x72, 0xac, 0x6a, 0xd2, 0xd7, + 0x27, 0x1b, 0x8c, 0x50, 0xb8, 0x3a, 0xb1, 0x33, 0x80, 0x69, 0xd2, 0x43, 0x2c, 0x20, 0xf6, 0xd7, + 0x2d, 0xbe, 0xb0, 0xf4, 0xae, 0xa3, 0x37, 0x61, 0xaa, 0xed, 0x44, 0x8d, 0x9d, 0xe5, 0xbb, 0x9d, + 0x80, 0xab, 0x9c, 0xe4, 0x38, 0x3d, 0xdd, 0x6b, 0x9c, 0xb4, 0x8f, 0x8c, 0x4d, 0x39, 0xd7, 0x12, + 0xc4, 0x70, 0x8a, 0x3c, 0xda, 0x84, 0x51, 0x56, 0xc6, 0xbc, 0xf8, 0xc2, 0x22, 0xd6, 0x20, 0xaf, + 0x35, 0x65, 0x8c, 0xb0, 0x16, 0xd3, 0xc1, 0x3a, 0x51, 0xfb, 0xcb, 0x65, 0xbe, 0xdb, 0x19, 0x2b, + 0xff, 0x14, 0x0c, 0x77, 0xfc, 0xe6, 0xd2, 0x6a, 0x15, 0x8b, 0x59, 0x50, 0xd7, 0x48, 0x8d, 0x17, + 0x63, 0x09, 0x47, 0x17, 0x61, 0x44, 0xfc, 0x94, 0x2a, 0x42, 0x76, 0x36, 0x0b, 0xbc, 0x10, 0x2b, + 0x28, 0x7a, 0x0e, 0xa0, 0x13, 0xf8, 0x7b, 0x6e, 0x93, 0x45, 0x97, 0x28, 0x9b, 0x76, 0x44, 0x35, + 0x05, 0xc1, 0x1a, 0x16, 0x7a, 0x05, 0xc6, 0xbb, 0x5e, 0xc8, 0xd9, 0x11, 0x2d, 0x96, 0xac, 0xb2, + 0x70, 0xb9, 0xa9, 0x03, 0xb1, 0x89, 0x8b, 0x16, 0x60, 0x28, 0x72, 0x98, 0x5d, 0xcc, 0x60, 0xbe, + 0xb9, 0xef, 0x06, 0xc5, 0xd0, 0x93, 0x83, 0xd0, 0x0a, 0x58, 0x54, 0x44, 0x9f, 0x90, 0x0e, 0xb5, + 0xfc, 0x60, 0x17, 0x76, 0xf6, 0xfd, 0x5d, 0x02, 0x9a, 0x3b, 0xad, 0xb0, 0xdf, 0x37, 0x68, 0xa1, + 0x97, 0x01, 0xc8, 0xdd, 0x88, 0x04, 0x9e, 0xd3, 0x52, 0xd6, 0x6c, 0x8a, 0x2f, 0xa8, 0xfa, 0xeb, + 0x7e, 0x74, 0x33, 0x24, 0xcb, 0x0a, 0x03, 0x6b, 0xd8, 0xf6, 0xaf, 0x57, 0x00, 0x62, 0xbe, 0x1d, + 0xbd, 0x95, 0x3a, 0xb8, 0x9e, 0x29, 0xe6, 0xf4, 0x8f, 0xee, 0xd4, 0x42, 0xdf, 0x67, 0xc1, 0xa8, + 0xd3, 0x6a, 0xf9, 0x0d, 0x87, 0x47, 0xfb, 0x2d, 0x15, 0x1f, 0x9c, 0xa2, 0xfd, 0x85, 0xb8, 0x06, + 0xef, 0xc2, 0xf3, 0x72, 0x85, 0x6a, 0x90, 0x9e, 0xbd, 0xd0, 0x1b, 0x46, 0x1f, 0x90, 0x4f, 0xc5, + 0xb2, 0x31, 0x94, 0xea, 0xa9, 0x58, 0x61, 0x77, 0x84, 0xfe, 0x4a, 0xbc, 0x69, 0xbc, 0x12, 0x07, + 0xf2, 0x3d, 0x06, 0x0d, 0xf6, 0xb5, 0xd7, 0x03, 0x11, 0xd5, 0xf4, 0xe8, 0x01, 0x83, 0xf9, 0xee, + 0x79, 0xda, 0x3b, 0xa9, 0x47, 0xe4, 0x80, 0xcf, 0xc0, 0x64, 0xd3, 0x64, 0x02, 0xc4, 0x4a, 0x7c, + 0x32, 0x8f, 0x6e, 0x82, 0x67, 0x88, 0xaf, 0xfd, 0x04, 0x00, 0x27, 0x09, 0xa3, 0x1a, 0x0f, 0x26, + 0xb1, 0xea, 0x6d, 0xf9, 0xc2, 0xd7, 0xc3, 0xce, 0x9d, 0xcb, 0xfd, 0x30, 0x22, 0x6d, 0x8a, 0x19, + 0xdf, 0xee, 0xeb, 0xa2, 0x2e, 0x56, 0x54, 0xd0, 0x6b, 0x30, 0xc4, 0xfc, 0xb3, 0xc2, 0x99, 0x91, + 0x7c, 0x89, 0xb3, 0x19, 0x1d, 0x2d, 0xde, 0x90, 0xec, 0x6f, 0x88, 0x05, 0x05, 0x74, 0x55, 0x7a, + 0x3f, 0x86, 0xab, 0xde, 0xcd, 0x90, 0x30, 0xef, 0xc7, 0xca, 0xe2, 0x7b, 0x63, 0xc7, 0x46, 0x5e, + 0x9e, 0x99, 0x42, 0xcc, 0xa8, 0x49, 0xb9, 0x28, 0xf1, 0x5f, 0x66, 0x26, 0x9b, 0x81, 0xfc, 0xee, + 0x99, 0xd9, 0xcb, 0xe2, 0xe1, 0xbc, 0x65, 0x92, 0xc0, 0x49, 0x9a, 0x94, 0x23, 0xe5, 0xbb, 0x5e, + 0x78, 0x8b, 0xf4, 0x3a, 0x3b, 0xf8, 0x43, 0x9c, 0xdd, 0x46, 0xbc, 0x04, 0x8b, 0xfa, 0xc7, 0xca, + 0x1e, 0xcc, 0x7a, 0x30, 0x95, 0xdc, 0xa2, 0x0f, 0x95, 0x1d, 0xf9, 0x83, 0x01, 0x98, 0x30, 0x97, + 0x14, 0xba, 0x04, 0x15, 0x41, 0x44, 0x65, 0x13, 0x50, 0xbb, 0x64, 0x4d, 0x02, 0x70, 0x8c, 0xc3, + 0x92, 0x48, 0xb0, 0xea, 0x9a, 0x79, 0x70, 0x9c, 0x44, 0x42, 0x41, 0xb0, 0x86, 0x45, 0x1f, 0x56, + 0x9b, 0xbe, 0x1f, 0xa9, 0x0b, 0x49, 0xad, 0xbb, 0x45, 0x56, 0x8a, 0x05, 0x94, 0x5e, 0x44, 0xbb, + 0x24, 0xf0, 0x48, 0xcb, 0x8c, 0x3b, 0xac, 0x2e, 0xa2, 0x6b, 0x3a, 0x10, 0x9b, 0xb8, 0xf4, 0x3a, + 0xf5, 0x43, 0xb6, 0x90, 0xc5, 0xf3, 0x2d, 0x36, 0xb7, 0xae, 0x73, 0x07, 0x6c, 0x09, 0x47, 0x1f, + 0x87, 0x47, 0x54, 0x6c, 0x25, 0xcc, 0xb5, 0x19, 0xb2, 0xc5, 0x21, 0x43, 0xda, 0xf2, 0xc8, 0x52, + 0x36, 0x1a, 0xce, 0xab, 0x8f, 0x5e, 0x85, 0x09, 0xc1, 0xe2, 0x4b, 0x8a, 0xc3, 0xa6, 0x85, 0xd1, + 0x35, 0x03, 0x8a, 0x13, 0xd8, 0x32, 0x72, 0x32, 0xe3, 0xb2, 0x25, 0x85, 0x91, 0x74, 0xe4, 0x64, + 0x1d, 0x8e, 0x53, 0x35, 0xd0, 0x02, 0x4c, 0x72, 0x1e, 0xcc, 0xf5, 0xb6, 0xf9, 0x9c, 0x08, 0x67, + 0x2e, 0xb5, 0xa5, 0x6e, 0x98, 0x60, 0x9c, 0xc4, 0x47, 0x2f, 0xc1, 0x98, 0x13, 0x34, 0x76, 0xdc, + 0x88, 0x34, 0xa2, 0x6e, 0xc0, 0xbd, 0xbc, 0x34, 0x13, 0xad, 0x05, 0x0d, 0x86, 0x0d, 0x4c, 0xfb, + 0x2d, 0x38, 0x91, 0x11, 0x99, 0x81, 0x2e, 0x1c, 0xa7, 0xe3, 0xca, 0x6f, 0x4a, 0x58, 0x38, 0x2f, + 0xd4, 0x56, 0xe5, 0xd7, 0x68, 0x58, 0x74, 0x75, 0xb2, 0x08, 0x0e, 0x5a, 0x22, 0x42, 0xb5, 0x3a, + 0x57, 0x24, 0x00, 0xc7, 0x38, 0xf6, 0xff, 0x2c, 0xc1, 0x64, 0x86, 0x6e, 0x85, 0x25, 0xc3, 0x4b, + 0x3c, 0x52, 0xe2, 0xdc, 0x77, 0x66, 0x20, 0xee, 0xd2, 0x21, 0x02, 0x71, 0x97, 0x7b, 0x05, 0xe2, + 0x1e, 0x78, 0x3b, 0x81, 0xb8, 0xcd, 0x11, 0x1b, 0xec, 0x6b, 0xc4, 0x32, 0x82, 0x77, 0x0f, 0x1d, + 0x32, 0x78, 0xb7, 0x31, 0xe8, 0xc3, 0x7d, 0x0c, 0xfa, 0x8f, 0x96, 0x60, 0x2a, 0x69, 0x4a, 0x7a, + 0x0c, 0x72, 0xdb, 0xd7, 0x0c, 0xb9, 0xed, 0xc5, 0x7e, 0x9c, 0x6f, 0x73, 0x65, 0xb8, 0x38, 0x21, + 0xc3, 0x7d, 0x7f, 0x5f, 0xd4, 0x8a, 0xe5, 0xb9, 0x7f, 0xab, 0x04, 0xa7, 0x32, 0xbd, 0x7f, 0x8f, + 0x61, 0x6c, 0x6e, 0x18, 0x63, 0xf3, 0x6c, 0xdf, 0x8e, 0xc9, 0xb9, 0x03, 0x74, 0x3b, 0x31, 0x40, + 0x97, 0xfa, 0x27, 0x59, 0x3c, 0x4a, 0x5f, 0x2b, 0xc3, 0xb9, 0xcc, 0x7a, 0xb1, 0xd8, 0x73, 0xc5, + 0x10, 0x7b, 0x3e, 0x97, 0x10, 0x7b, 0xda, 0xc5, 0xb5, 0x8f, 0x46, 0x0e, 0x2a, 0x1c, 0x74, 0x59, + 0x98, 0x81, 0x07, 0x94, 0x81, 0x1a, 0x0e, 0xba, 0x8a, 0x10, 0x36, 0xe9, 0x7e, 0x2b, 0xc9, 0x3e, + 0xff, 0xbd, 0x05, 0x67, 0x32, 0xe7, 0xe6, 0x18, 0x64, 0x5d, 0xeb, 0xa6, 0xac, 0xeb, 0xa9, 0xbe, + 0x57, 0x6b, 0x8e, 0xf0, 0xeb, 0xcb, 0x83, 0x39, 0xdf, 0xc2, 0x5e, 0xf2, 0x37, 0x60, 0xd4, 0x69, + 0x34, 0x48, 0x18, 0xae, 0xf9, 0x4d, 0x15, 0x6b, 0xf8, 0x59, 0xf6, 0xce, 0x8a, 0x8b, 0xef, 0x1f, + 0xcc, 0xcd, 0x26, 0x49, 0xc4, 0x60, 0xac, 0x53, 0x40, 0x9f, 0x84, 0x91, 0x50, 0xdc, 0x9b, 0x62, + 0xee, 0x9f, 0xef, 0x73, 0x70, 0x9c, 0x4d, 0xd2, 0x32, 0x83, 0x21, 0x29, 0x49, 0x85, 0x22, 0x69, + 0x06, 0x4e, 0x29, 0x1d, 0x69, 0xe0, 0x94, 0xe7, 0x00, 0xf6, 0xd4, 0x63, 0x20, 0x29, 0x7f, 0xd0, + 0x9e, 0x09, 0x1a, 0x16, 0xfa, 0x28, 0x4c, 0x85, 0x3c, 0x5a, 0xe0, 0x52, 0xcb, 0x09, 0x99, 0x1f, + 0x8d, 0x58, 0x85, 0x2c, 0xe0, 0x52, 0x3d, 0x01, 0xc3, 0x29, 0x6c, 0xb4, 0x22, 0x5b, 0x65, 0xa1, + 0x0d, 0xf9, 0xc2, 0xbc, 0x10, 0xb7, 0x28, 0x52, 0xf1, 0x9e, 0x4c, 0x0e, 0x3f, 0x1b, 0x78, 0xad, + 0x26, 0xfa, 0x24, 0x00, 0x5d, 0x3e, 0x42, 0x0e, 0x31, 0x9c, 0x7f, 0x78, 0xd2, 0x53, 0xa5, 0x99, + 0x69, 0xdc, 0xcc, 0x7c, 0x6a, 0xab, 0x8a, 0x08, 0xd6, 0x08, 0xa2, 0x2d, 0x18, 0x8f, 0xff, 0xc5, + 0x99, 0x2a, 0x0f, 0xd9, 0x02, 0x93, 0x7b, 0x57, 0x75, 0x3a, 0xd8, 0x24, 0x6b, 0xff, 0xf8, 0x30, + 0x3c, 0x5a, 0x70, 0x16, 0xa3, 0x05, 0x53, 0xdf, 0xfb, 0x74, 0xf2, 0x11, 0x3f, 0x9b, 0x59, 0xd9, + 0x78, 0xd5, 0x27, 0x96, 0x7c, 0xe9, 0x6d, 0x2f, 0xf9, 0x1f, 0xb2, 0x34, 0xf1, 0x0a, 0xb7, 0x2c, + 0xfd, 0xc8, 0x21, 0xef, 0x98, 0x23, 0x94, 0xb7, 0x6c, 0x65, 0x08, 0x2d, 0x9e, 0xeb, 0xbb, 0x3b, + 0xfd, 0x4b, 0x31, 0xbe, 0x62, 0x01, 0x12, 0xe2, 0x15, 0xd2, 0x54, 0x1b, 0x4a, 0xc8, 0x33, 0xae, + 0x1c, 0xf6, 0xfb, 0x17, 0x52, 0x94, 0xf8, 0x48, 0xbc, 0x2c, 0x2f, 0x83, 0x34, 0x42, 0xcf, 0x31, + 0xc9, 0xe8, 0x1e, 0xfa, 0x38, 0x8b, 0xa6, 0xeb, 0xbe, 0x25, 0x38, 0x20, 0xb1, 0xe1, 0x5e, 0x14, + 0x91, 0x74, 0x55, 0x39, 0x65, 0x75, 0x33, 0xbb, 0xab, 0x23, 0x61, 0x83, 0xd4, 0xf1, 0xbe, 0xbf, + 0xbb, 0xf0, 0x48, 0xce, 0x90, 0x3d, 0xd4, 0x67, 0xf8, 0x6f, 0x59, 0x70, 0xb6, 0x30, 0x2c, 0xcc, + 0x37, 0x21, 0x83, 0x68, 0x7f, 0xce, 0x82, 0xec, 0xc9, 0x36, 0xcc, 0xca, 0x2e, 0x41, 0xa5, 0x41, + 0x0b, 0x35, 0x3f, 0xe0, 0x38, 0x40, 0x82, 0x04, 0xe0, 0x18, 0xc7, 0xb0, 0x1e, 0x2b, 0xf5, 0xb4, + 0x1e, 0xfb, 0x15, 0x0b, 0x52, 0x87, 0xfc, 0x31, 0x70, 0x1b, 0xab, 0x26, 0xb7, 0xf1, 0xde, 0x7e, + 0x46, 0x33, 0x87, 0xd1, 0xf8, 0xe3, 0x49, 0x38, 0x9d, 0xe3, 0x96, 0xb7, 0x07, 0xd3, 0xdb, 0x0d, + 0x62, 0x7a, 0x58, 0x17, 0x45, 0x1e, 0x2a, 0x74, 0xc7, 0x66, 0xc9, 0x61, 0xa7, 0x53, 0x28, 0x38, + 0xdd, 0x04, 0xfa, 0x9c, 0x05, 0x27, 0x9d, 0x3b, 0xe1, 0x32, 0xe5, 0x1a, 0xdd, 0xc6, 0x62, 0xcb, + 0x6f, 0xec, 0xd2, 0x2b, 0x59, 0x6e, 0x84, 0x17, 0x32, 0x25, 0x79, 0xb7, 0xeb, 0x29, 0x7c, 0xa3, + 0x79, 0x96, 0x2d, 0x37, 0x0b, 0x0b, 0x67, 0xb6, 0x85, 0xb0, 0x48, 0xa1, 0x40, 0xdf, 0xa4, 0x05, + 0x31, 0x00, 0xb2, 0xfc, 0x27, 0x39, 0x1b, 0x24, 0x21, 0x58, 0xd1, 0x41, 0x9f, 0x86, 0xca, 0xb6, + 0x74, 0xf7, 0xcd, 0x60, 0xb3, 0xe2, 0x81, 0x2c, 0x76, 0x82, 0xe6, 0xea, 0x78, 0x85, 0x84, 0x63, + 0xa2, 0xe8, 0x55, 0x28, 0x7b, 0x5b, 0x61, 0x51, 0xc2, 0xd9, 0x84, 0xdd, 0x25, 0x8f, 0xb4, 0xb1, + 0xbe, 0x52, 0xc7, 0xb4, 0x22, 0xba, 0x0a, 0xe5, 0x60, 0xb3, 0x29, 0xc4, 0xd0, 0x99, 0x9b, 0x14, + 0x2f, 0x56, 0x73, 0x7a, 0xc5, 0x28, 0xe1, 0xc5, 0x2a, 0xa6, 0x24, 0x50, 0x0d, 0x06, 0x99, 0x2f, + 0x9b, 0x60, 0x6a, 0x32, 0x9f, 0x6f, 0x05, 0x3e, 0xa1, 0x3c, 0x1c, 0x07, 0x43, 0xc0, 0x9c, 0x10, + 0xda, 0x80, 0xa1, 0x06, 0x4b, 0x4e, 0x2a, 0xb8, 0x98, 0x0f, 0x64, 0x0a, 0x9c, 0x0b, 0xb2, 0xb6, + 0x0a, 0xf9, 0x2b, 0xc3, 0xc0, 0x82, 0x16, 0xa3, 0x4a, 0x3a, 0x3b, 0x5b, 0xa1, 0x48, 0xa6, 0x9d, + 0x4d, 0xb5, 0x20, 0x19, 0xb1, 0xa0, 0xca, 0x30, 0xb0, 0xa0, 0x85, 0x5e, 0x86, 0xd2, 0x56, 0x43, + 0xf8, 0xa9, 0x65, 0x4a, 0x9e, 0xcd, 0x60, 0x29, 0x8b, 0x43, 0xf7, 0x0e, 0xe6, 0x4a, 0x2b, 0x4b, + 0xb8, 0xb4, 0xd5, 0x40, 0xeb, 0x30, 0xbc, 0xc5, 0xc3, 0x2b, 0x08, 0xe1, 0xf2, 0x93, 0xd9, 0x91, + 0x1f, 0x52, 0x11, 0x18, 0xb8, 0xcf, 0x93, 0x00, 0x60, 0x49, 0x84, 0x65, 0x24, 0x50, 0x61, 0x22, + 0x44, 0x94, 0xba, 0xf9, 0xc3, 0x85, 0xf6, 0xe0, 0x4c, 0x66, 0x1c, 0x6c, 0x02, 0x6b, 0x14, 0xe9, + 0xaa, 0x76, 0xde, 0xea, 0x06, 0x2c, 0x14, 0xb8, 0x08, 0x67, 0x94, 0xb9, 0xaa, 0x17, 0x24, 0x52, + 0xd1, 0xaa, 0x56, 0x48, 0x38, 0x26, 0x8a, 0x76, 0x61, 0x7c, 0x2f, 0xec, 0xec, 0x10, 0xb9, 0xa5, + 0x59, 0x74, 0xa3, 0x1c, 0xfe, 0xe8, 0x96, 0x40, 0x74, 0x83, 0xa8, 0xeb, 0xb4, 0x52, 0xa7, 0x10, + 0xe3, 0x65, 0x6f, 0xe9, 0xc4, 0xb0, 0x49, 0x9b, 0x0e, 0xff, 0x9b, 0x5d, 0x7f, 0x73, 0x3f, 0x22, + 0x22, 0xb8, 0x5c, 0xe6, 0xf0, 0xbf, 0xce, 0x51, 0xd2, 0xc3, 0x2f, 0x00, 0x58, 0x12, 0x41, 0xb7, + 0xc4, 0xf0, 0xb0, 0xd3, 0x73, 0x2a, 0x3f, 0x02, 0xec, 0x82, 0x44, 0xca, 0x19, 0x14, 0x76, 0x5a, + 0xc6, 0xa4, 0xd8, 0x29, 0xd9, 0xd9, 0xf1, 0x23, 0xdf, 0x4b, 0x9c, 0xd0, 0xd3, 0xf9, 0xa7, 0x64, + 0x2d, 0x03, 0x3f, 0x7d, 0x4a, 0x66, 0x61, 0xe1, 0xcc, 0xb6, 0x50, 0x13, 0x26, 0x3a, 0x7e, 0x10, + 0xdd, 0xf1, 0x03, 0xb9, 0xbe, 0x50, 0x81, 0x70, 0xcc, 0xc0, 0x14, 0x2d, 0xb2, 0xb8, 0x8d, 0x26, + 0x04, 0x27, 0x68, 0xa2, 0x8f, 0xc1, 0x70, 0xd8, 0x70, 0x5a, 0x64, 0xf5, 0xc6, 0xcc, 0x89, 0xfc, + 0xeb, 0xa7, 0xce, 0x51, 0x72, 0x56, 0x17, 0x8f, 0x8e, 0xc1, 0x51, 0xb0, 0x24, 0x87, 0x56, 0x60, + 0x90, 0x65, 0x9c, 0x63, 0x91, 0x10, 0x73, 0x02, 0xd9, 0xa6, 0xac, 0xe0, 0xf9, 0xd9, 0xc4, 0x8a, + 0x31, 0xaf, 0x4e, 0xf7, 0x80, 0x78, 0x23, 0xfa, 0xe1, 0xcc, 0xa9, 0xfc, 0x3d, 0x20, 0x9e, 0x96, + 0x37, 0xea, 0x45, 0x7b, 0x40, 0x21, 0xe1, 0x98, 0x28, 0x3d, 0x99, 0xe9, 0x69, 0x7a, 0xba, 0xc0, + 0x7c, 0x2b, 0xf7, 0x2c, 0x65, 0x27, 0x33, 0x3d, 0x49, 0x29, 0x09, 0xfb, 0xf7, 0x86, 0xd3, 0x3c, + 0x0b, 0x93, 0x2a, 0x7c, 0x8f, 0x95, 0x52, 0x38, 0x7f, 0xb0, 0x5f, 0x21, 0xe7, 0x11, 0x3e, 0x85, + 0x3e, 0x67, 0xc1, 0xe9, 0x4e, 0xe6, 0x87, 0x08, 0x06, 0xa0, 0x3f, 0x59, 0x29, 0xff, 0x74, 0x15, + 0x35, 0x33, 0x1b, 0x8e, 0x73, 0x5a, 0x4a, 0x3e, 0x37, 0xcb, 0x6f, 0xfb, 0xb9, 0xb9, 0x06, 0x23, + 0x0d, 0xfe, 0x14, 0x29, 0x4c, 0xd6, 0x9d, 0x7c, 0x7b, 0x33, 0x56, 0x42, 0xbc, 0x61, 0xb6, 0xb0, + 0x22, 0x81, 0x7e, 0xd8, 0x82, 0xb3, 0xc9, 0xae, 0x63, 0xc2, 0xc0, 0x22, 0xd4, 0x26, 0x17, 0x68, + 0xac, 0x88, 0xef, 0x4f, 0xf1, 0xff, 0x06, 0xf2, 0xfd, 0x5e, 0x08, 0xb8, 0xb8, 0x31, 0x54, 0xcd, + 0x90, 0xa8, 0x0c, 0x99, 0x5a, 0xa4, 0x3e, 0xa4, 0x2a, 0x2f, 0xc0, 0x58, 0xdb, 0xef, 0x7a, 0x91, + 0xb0, 0xf6, 0x12, 0x96, 0x27, 0xcc, 0xe2, 0x62, 0x4d, 0x2b, 0xc7, 0x06, 0x56, 0x42, 0x16, 0x33, + 0xf2, 0xc0, 0xb2, 0x98, 0x37, 0x60, 0xcc, 0xd3, 0xcc, 0x93, 0x05, 0x3f, 0x70, 0x21, 0x3f, 0x4c, + 0xae, 0x6e, 0xcc, 0xcc, 0x7b, 0xa9, 0x97, 0x60, 0x83, 0xda, 0xf1, 0x9a, 0x81, 0x7d, 0xc9, 0xca, + 0x60, 0xea, 0xb9, 0x28, 0xe6, 0xc3, 0xa6, 0x28, 0xe6, 0x42, 0x52, 0x14, 0x93, 0xd2, 0x20, 0x18, + 0x52, 0x98, 0xfe, 0xb3, 0x00, 0xf5, 0x1b, 0x6a, 0xd3, 0x6e, 0xc1, 0xf9, 0x5e, 0xd7, 0x12, 0x33, + 0xfb, 0x6b, 0x2a, 0x7d, 0x71, 0x6c, 0xf6, 0xd7, 0x5c, 0xad, 0x62, 0x06, 0xe9, 0x37, 0x88, 0x93, + 0xfd, 0xdf, 0x2d, 0x28, 0xd7, 0xfc, 0xe6, 0x31, 0x3c, 0x78, 0x3f, 0x62, 0x3c, 0x78, 0x1f, 0xcd, + 0xbe, 0x10, 0x9b, 0xb9, 0xfa, 0x8f, 0xe5, 0x84, 0xfe, 0xe3, 0x6c, 0x1e, 0x81, 0x62, 0x6d, 0xc7, + 0x4f, 0x95, 0x61, 0xb4, 0xe6, 0x37, 0x95, 0xcd, 0xfd, 0xbf, 0x7a, 0x10, 0x9b, 0xfb, 0xdc, 0x5c, + 0x16, 0x1a, 0x65, 0x66, 0x2d, 0x28, 0xdd, 0x8d, 0xbf, 0xc9, 0x4c, 0xef, 0x6f, 0x13, 0x77, 0x7b, + 0x27, 0x22, 0xcd, 0xe4, 0xe7, 0x1c, 0x9f, 0xe9, 0xfd, 0xef, 0x95, 0x60, 0x32, 0xd1, 0x3a, 0x6a, + 0xc1, 0x78, 0x4b, 0x97, 0xae, 0x8b, 0x75, 0xfa, 0x40, 0x82, 0x79, 0x61, 0xba, 0xac, 0x15, 0x61, + 0x93, 0x38, 0x9a, 0x07, 0x50, 0xea, 0x66, 0x29, 0x5e, 0x65, 0x5c, 0xbf, 0xd2, 0x47, 0x87, 0x58, + 0xc3, 0x40, 0x2f, 0xc2, 0x68, 0xe4, 0x77, 0xfc, 0x96, 0xbf, 0xbd, 0x7f, 0x8d, 0xc8, 0xf8, 0x5e, + 0xca, 0x20, 0x71, 0x23, 0x06, 0x61, 0x1d, 0x0f, 0xdd, 0x85, 0x69, 0x45, 0xa4, 0x7e, 0x04, 0x1a, + 0x07, 0x26, 0x55, 0x58, 0x4f, 0x52, 0xc4, 0xe9, 0x46, 0xec, 0x9f, 0x29, 0xf3, 0x21, 0xf6, 0x22, + 0xf7, 0xdd, 0xdd, 0xf0, 0xce, 0xde, 0x0d, 0x5f, 0xb3, 0x60, 0x8a, 0xb6, 0xce, 0xac, 0xad, 0xe4, + 0x35, 0xaf, 0x02, 0x73, 0x5b, 0x05, 0x81, 0xb9, 0x2f, 0xd0, 0x53, 0xb3, 0xe9, 0x77, 0x23, 0x21, + 0xbb, 0xd3, 0x8e, 0x45, 0x5a, 0x8a, 0x05, 0x54, 0xe0, 0x91, 0x20, 0x10, 0x1e, 0xa2, 0x3a, 0x1e, + 0x09, 0x02, 0x2c, 0xa0, 0x32, 0x6e, 0xf7, 0x40, 0x76, 0xdc, 0x6e, 0x1e, 0x7e, 0x55, 0xd8, 0xe5, + 0x08, 0x86, 0x4b, 0x0b, 0xbf, 0x2a, 0x0d, 0x76, 0x62, 0x1c, 0xfb, 0x2b, 0x65, 0x18, 0xab, 0xf9, + 0xcd, 0x58, 0xd5, 0xfc, 0x82, 0xa1, 0x6a, 0x3e, 0x9f, 0x50, 0x35, 0x4f, 0xe9, 0xb8, 0xef, 0x2a, + 0x96, 0xbf, 0x51, 0x8a, 0xe5, 0x7f, 0x6e, 0xb1, 0x59, 0xab, 0xae, 0xd7, 0xb9, 0xf1, 0x1e, 0xba, + 0x0c, 0xa3, 0xec, 0x80, 0x61, 0x2e, 0xc9, 0x52, 0xff, 0xca, 0xf2, 0x51, 0xad, 0xc7, 0xc5, 0x58, + 0xc7, 0x41, 0x17, 0x61, 0x24, 0x24, 0x4e, 0xd0, 0xd8, 0x51, 0xa7, 0xab, 0x50, 0x96, 0xf2, 0x32, + 0xac, 0xa0, 0xe8, 0xf5, 0x38, 0xf2, 0x67, 0x39, 0xdf, 0xc5, 0x51, 0xef, 0x0f, 0xdf, 0x22, 0xf9, + 0xe1, 0x3e, 0xed, 0xdb, 0x80, 0xd2, 0xf8, 0x7d, 0xc4, 0xa6, 0x9b, 0x33, 0x63, 0xd3, 0x55, 0x52, + 0x71, 0xe9, 0xfe, 0xcc, 0x82, 0x89, 0x9a, 0xdf, 0xa4, 0x5b, 0xf7, 0x5b, 0x69, 0x9f, 0xea, 0x61, + 0x8f, 0x87, 0x0a, 0xc2, 0x1e, 0x3f, 0x01, 0x83, 0x35, 0xbf, 0xb9, 0x5a, 0x2b, 0x8a, 0x2f, 0x60, + 0xff, 0x6d, 0x0b, 0x86, 0x6b, 0x7e, 0xf3, 0x18, 0xd4, 0x02, 0x1f, 0x36, 0xd5, 0x02, 0x8f, 0xe4, + 0xac, 0x9b, 0x1c, 0x4d, 0xc0, 0xdf, 0x1c, 0x80, 0x71, 0xda, 0x4f, 0x7f, 0x5b, 0x4e, 0xa5, 0x31, + 0x6c, 0x56, 0x1f, 0xc3, 0x46, 0xb9, 0x70, 0xbf, 0xd5, 0xf2, 0xef, 0x24, 0xa7, 0x75, 0x85, 0x95, + 0x62, 0x01, 0x45, 0xcf, 0xc0, 0x48, 0x27, 0x20, 0x7b, 0xae, 0x2f, 0xd8, 0x5b, 0x4d, 0xc9, 0x52, + 0x13, 0xe5, 0x58, 0x61, 0xd0, 0x67, 0x61, 0xe8, 0x7a, 0xf4, 0x2a, 0x6f, 0xf8, 0x5e, 0x93, 0x4b, + 0xce, 0xcb, 0x22, 0x37, 0x87, 0x56, 0x8e, 0x0d, 0x2c, 0x74, 0x1b, 0x2a, 0xec, 0x3f, 0x3b, 0x76, + 0x0e, 0x9f, 0xe5, 0x55, 0x64, 0xfd, 0x13, 0x04, 0x70, 0x4c, 0x0b, 0x3d, 0x07, 0x10, 0xc9, 0xf8, + 0xf6, 0xa1, 0x88, 0xb6, 0xa6, 0x9e, 0x02, 0x2a, 0xf2, 0x7d, 0x88, 0x35, 0x2c, 0xf4, 0x34, 0x54, + 0x22, 0xc7, 0x6d, 0x5d, 0x77, 0x3d, 0x12, 0x32, 0x89, 0x78, 0x59, 0x26, 0xdf, 0x13, 0x85, 0x38, + 0x86, 0x53, 0x56, 0x8c, 0x45, 0xe2, 0xe0, 0x39, 0xa2, 0x47, 0x18, 0x36, 0x63, 0xc5, 0xae, 0xab, + 0x52, 0xac, 0x61, 0xa0, 0x1d, 0x78, 0xcc, 0xf5, 0x58, 0x1e, 0x0b, 0x52, 0xdf, 0x75, 0x3b, 0x1b, + 0xd7, 0xeb, 0xb7, 0x48, 0xe0, 0x6e, 0xed, 0x2f, 0x3a, 0x8d, 0x5d, 0xe2, 0xc9, 0xfc, 0x9d, 0xef, + 0x15, 0x5d, 0x7c, 0x6c, 0xb5, 0x00, 0x17, 0x17, 0x52, 0xb2, 0x9f, 0x67, 0xeb, 0xfd, 0x46, 0x1d, + 0xbd, 0xdf, 0x38, 0x3a, 0x4e, 0xeb, 0x47, 0xc7, 0xfd, 0x83, 0xb9, 0xa1, 0x1b, 0x75, 0x2d, 0x90, + 0xc4, 0x4b, 0x70, 0xaa, 0xe6, 0x37, 0x6b, 0x7e, 0x10, 0xad, 0xf8, 0xc1, 0x1d, 0x27, 0x68, 0xca, + 0xe5, 0x35, 0x27, 0x43, 0x69, 0xd0, 0xf3, 0x73, 0x90, 0x9f, 0x2e, 0x46, 0x98, 0x8c, 0xe7, 0x19, + 0xc7, 0x76, 0x48, 0x07, 0xb0, 0x06, 0xe3, 0x1d, 0x54, 0x26, 0x98, 0x2b, 0x4e, 0x44, 0xd0, 0x0d, + 0x96, 0xe1, 0x3a, 0xbe, 0x46, 0x45, 0xf5, 0xa7, 0xb4, 0x0c, 0xd7, 0x31, 0x30, 0xf3, 0xde, 0x35, + 0xeb, 0xdb, 0xff, 0x63, 0x90, 0x9d, 0xa8, 0x89, 0x6c, 0x22, 0xe8, 0x53, 0x30, 0x11, 0x92, 0xeb, + 0xae, 0xd7, 0xbd, 0x2b, 0x45, 0x18, 0x05, 0x2e, 0x7c, 0xf5, 0x65, 0x1d, 0x93, 0x0b, 0x42, 0xcd, + 0x32, 0x9c, 0xa0, 0x86, 0xda, 0x30, 0x71, 0xc7, 0xf5, 0x9a, 0xfe, 0x9d, 0x50, 0xd2, 0x1f, 0xc9, + 0x97, 0x87, 0xde, 0xe6, 0x98, 0x89, 0x3e, 0x1a, 0xcd, 0xdd, 0x36, 0x88, 0xe1, 0x04, 0x71, 0xba, + 0x6a, 0x83, 0xae, 0xb7, 0x10, 0xde, 0x0c, 0x49, 0x20, 0x72, 0x95, 0xb3, 0x55, 0x8b, 0x65, 0x21, + 0x8e, 0xe1, 0x74, 0xd5, 0xb2, 0x3f, 0x57, 0x02, 0xbf, 0xcb, 0x53, 0x57, 0x88, 0x55, 0x8b, 0x55, + 0x29, 0xd6, 0x30, 0xe8, 0xae, 0x66, 0xff, 0xd6, 0x7d, 0x0f, 0xfb, 0x7e, 0x24, 0xcf, 0x01, 0xa6, + 0xd3, 0xd7, 0xca, 0xb1, 0x81, 0x85, 0x56, 0x00, 0x85, 0xdd, 0x4e, 0xa7, 0xc5, 0x6c, 0x83, 0x9c, + 0x16, 0x23, 0xc5, 0xed, 0x25, 0xca, 0x3c, 0xf4, 0x6e, 0x3d, 0x05, 0xc5, 0x19, 0x35, 0xe8, 0x01, + 0xbf, 0x25, 0xba, 0x3a, 0xc8, 0xba, 0xca, 0x75, 0x27, 0x75, 0xde, 0x4f, 0x09, 0x43, 0xcb, 0x30, + 0x1c, 0xee, 0x87, 0x8d, 0x48, 0x44, 0x4a, 0xcc, 0x49, 0x18, 0x55, 0x67, 0x28, 0x5a, 0xbe, 0x42, + 0x5e, 0x05, 0xcb, 0xba, 0xa8, 0x01, 0x27, 0x04, 0xc5, 0xa5, 0x1d, 0xc7, 0x53, 0xe9, 0x77, 0xb8, + 0x89, 0xf4, 0xe5, 0x7b, 0x07, 0x73, 0x27, 0x44, 0xcb, 0x3a, 0xf8, 0xfe, 0xc1, 0xdc, 0xe9, 0x9a, + 0xdf, 0xcc, 0x80, 0xe0, 0x2c, 0x6a, 0x7c, 0xf1, 0x35, 0x1a, 0x7e, 0xbb, 0x53, 0x0b, 0xfc, 0x2d, + 0xb7, 0x45, 0x8a, 0xf4, 0x4f, 0x75, 0x03, 0x53, 0x2c, 0x3e, 0xa3, 0x0c, 0x27, 0xa8, 0xd9, 0xdf, + 0xc9, 0x98, 0x20, 0x96, 0x9e, 0x3b, 0xea, 0x06, 0x04, 0xb5, 0x61, 0xbc, 0xc3, 0xb6, 0x89, 0x48, + 0x28, 0x21, 0xd6, 0xfa, 0x0b, 0x7d, 0xca, 0x51, 0xee, 0xd0, 0xbb, 0xc3, 0xb4, 0x31, 0xaa, 0xe9, + 0xe4, 0xb0, 0x49, 0xdd, 0xfe, 0x8d, 0x47, 0xd8, 0x35, 0x5a, 0xe7, 0xc2, 0x91, 0x61, 0xe1, 0x91, + 0x21, 0xde, 0x63, 0xb3, 0xf9, 0x52, 0xba, 0x78, 0x5a, 0x84, 0x57, 0x07, 0x96, 0x75, 0xd1, 0x27, + 0x61, 0x82, 0x3e, 0x6f, 0xd4, 0x55, 0x16, 0xce, 0x9c, 0xcc, 0x8f, 0x9c, 0xa1, 0xb0, 0xf4, 0x64, + 0x33, 0x7a, 0x65, 0x9c, 0x20, 0x86, 0x5e, 0x67, 0x36, 0x3d, 0x92, 0x74, 0xa9, 0x1f, 0xd2, 0xba, + 0xf9, 0x8e, 0x24, 0xab, 0x11, 0x41, 0x5d, 0x38, 0x91, 0x4e, 0x4d, 0x17, 0xce, 0xd8, 0xf9, 0x7c, + 0x62, 0x3a, 0xbb, 0x5c, 0x9c, 0x15, 0x24, 0x0d, 0x0b, 0x71, 0x16, 0x7d, 0x74, 0x1d, 0xc6, 0x45, + 0x8e, 0x6a, 0xb1, 0x72, 0xcb, 0x86, 0xf0, 0x70, 0x1c, 0xeb, 0xc0, 0xfb, 0xc9, 0x02, 0x6c, 0x56, + 0x46, 0xdb, 0x70, 0x56, 0xcb, 0x19, 0x75, 0x25, 0x70, 0x98, 0x05, 0x80, 0xcb, 0x8e, 0x53, 0xed, + 0x82, 0x7f, 0xfc, 0xde, 0xc1, 0xdc, 0xd9, 0x8d, 0x22, 0x44, 0x5c, 0x4c, 0x07, 0xdd, 0x80, 0x53, + 0xdc, 0xef, 0xbb, 0x4a, 0x9c, 0x66, 0xcb, 0xf5, 0x14, 0x07, 0xc1, 0xb7, 0xfc, 0x99, 0x7b, 0x07, + 0x73, 0xa7, 0x16, 0xb2, 0x10, 0x70, 0x76, 0x3d, 0xf4, 0x61, 0xa8, 0x34, 0xbd, 0x50, 0x8c, 0xc1, + 0x90, 0x91, 0x96, 0xab, 0x52, 0x5d, 0xaf, 0xab, 0xef, 0x8f, 0xff, 0xe0, 0xb8, 0x02, 0xda, 0xe6, + 0x02, 0x66, 0x25, 0xf6, 0x18, 0x4e, 0xc5, 0xbd, 0x4a, 0x4a, 0x06, 0x0d, 0xcf, 0x4f, 0xae, 0x59, + 0x51, 0x0e, 0x11, 0x86, 0x53, 0xa8, 0x41, 0x18, 0xbd, 0x06, 0x48, 0x84, 0x7f, 0x5f, 0x68, 0xb0, + 0x6c, 0x25, 0x4c, 0x1e, 0x3f, 0x62, 0xfa, 0x22, 0xd6, 0x53, 0x18, 0x38, 0xa3, 0x16, 0xba, 0x4a, + 0x4f, 0x15, 0xbd, 0x54, 0x9c, 0x5a, 0x2a, 0x89, 0x62, 0x95, 0x74, 0x02, 0xc2, 0x2c, 0x9a, 0x4c, + 0x8a, 0x38, 0x51, 0x0f, 0x35, 0xe1, 0x31, 0xa7, 0x1b, 0xf9, 0x4c, 0x76, 0x6f, 0xa2, 0x6e, 0xf8, + 0xbb, 0xc4, 0x63, 0x6a, 0xb3, 0x91, 0xc5, 0xf3, 0x94, 0x45, 0x59, 0x28, 0xc0, 0xc3, 0x85, 0x54, + 0x28, 0x6b, 0xa9, 0xb2, 0x26, 0x83, 0x19, 0xcd, 0x2b, 0x23, 0x73, 0xf2, 0x8b, 0x30, 0xba, 0xe3, + 0x87, 0xd1, 0x3a, 0x89, 0xee, 0xf8, 0xc1, 0xae, 0x88, 0x4a, 0x1b, 0xc7, 0xf8, 0x8e, 0x41, 0x58, + 0xc7, 0xa3, 0x6f, 0x47, 0x66, 0xd4, 0xb1, 0x5a, 0x65, 0xfa, 0xf4, 0x91, 0xf8, 0x8c, 0xb9, 0xca, + 0x8b, 0xb1, 0x84, 0x4b, 0xd4, 0xd5, 0xda, 0x12, 0xd3, 0x8d, 0x27, 0x50, 0x57, 0x6b, 0x4b, 0x58, + 0xc2, 0xe9, 0x72, 0x0d, 0x77, 0x9c, 0x80, 0xd4, 0x02, 0xbf, 0x41, 0x42, 0x2d, 0xb2, 0xfc, 0xa3, + 0x3c, 0xe6, 0x2e, 0x5d, 0xae, 0xf5, 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, 0x4c, 0xb2, 0xb5, 0xdd, 0x7f, 0x88, 0x5e, 0xa5, 0x26, 0x5a, 0x4d, 0x50, 0xc2, 0x29, + 0xda, 0x46, 0xc0, 0xb6, 0xa9, 0x9e, 0x01, 0xdb, 0x2e, 0x41, 0x25, 0xec, 0x6e, 0x36, 0xfd, 0xb6, + 0xe3, 0x7a, 0x4c, 0x37, 0xae, 0x3d, 0x62, 0xea, 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, 0x81, 0x71, 0xe1, 0xb7, 0x2c, 0x92, 0x84, 0x9e, 0x30, 0x9d, 0xcb, 0xea, 0x3a, 0x10, 0x9b, + 0xb8, 0xe8, 0x26, 0x8c, 0x46, 0x7e, 0x8b, 0x79, 0x48, 0x51, 0x36, 0xef, 0x74, 0x7e, 0xb0, 0xb9, + 0x0d, 0x85, 0xa6, 0x8b, 0x5f, 0x55, 0x55, 0xac, 0xd3, 0x41, 0x1b, 0x7c, 0xbd, 0xb3, 0x38, 0xf2, + 0x24, 0x9c, 0x79, 0x24, 0xff, 0x4e, 0x52, 0xe1, 0xe6, 0xcd, 0xed, 0x20, 0x6a, 0x62, 0x9d, 0x0c, + 0xba, 0x02, 0xd3, 0x9d, 0xc0, 0xf5, 0xd9, 0x9a, 0x50, 0xea, 0xbf, 0x19, 0x33, 0x6b, 0x54, 0x2d, + 0x89, 0x80, 0xd3, 0x75, 0x98, 0xdb, 0xb9, 0x28, 0x9c, 0x39, 0xc3, 0x33, 0x5f, 0xf0, 0x37, 0x21, + 0x2f, 0xc3, 0x0a, 0x8a, 0xd6, 0xd8, 0x49, 0xcc, 0xc5, 0x19, 0x33, 0xb3, 0xf9, 0x51, 0x81, 0x74, + 0xb1, 0x07, 0x67, 0x5e, 0xd5, 0x5f, 0x1c, 0x53, 0x40, 0x4d, 0x2d, 0xe1, 0x24, 0x7d, 0x31, 0x84, + 0x33, 0x8f, 0x15, 0x58, 0xd6, 0x25, 0x9e, 0x17, 0x31, 0x43, 0x60, 0x14, 0x87, 0x38, 0x41, 0x13, + 0x7d, 0x14, 0xa6, 0x44, 0x2c, 0xc3, 0x78, 0x98, 0xce, 0xc6, 0x76, 0xe7, 0x38, 0x01, 0xc3, 0x29, + 0x6c, 0x9e, 0x79, 0xc2, 0xd9, 0x6c, 0x11, 0x71, 0xf4, 0x5d, 0x77, 0xbd, 0xdd, 0x70, 0xe6, 0x1c, + 0x3b, 0x1f, 0x44, 0xe6, 0x89, 0x24, 0x14, 0x67, 0xd4, 0x40, 0x1b, 0x30, 0xd5, 0x09, 0x08, 0x69, + 0x33, 0x46, 0x5f, 0xdc, 0x67, 0x73, 0x3c, 0xea, 0x02, 0xed, 0x49, 0x2d, 0x01, 0xbb, 0x9f, 0x51, + 0x86, 0x53, 0x14, 0xd0, 0x1d, 0x18, 0xf1, 0xf7, 0x48, 0xb0, 0x43, 0x9c, 0xe6, 0xcc, 0xf9, 0x02, + 0x3f, 0x08, 0x71, 0xb9, 0xdd, 0x10, 0xb8, 0x09, 0x93, 0x01, 0x59, 0xdc, 0xdb, 0x64, 0x40, 0x36, + 0x86, 0x7e, 0xc4, 0x82, 0x33, 0x52, 0xcb, 0x50, 0xef, 0xd0, 0x51, 0x5f, 0xf2, 0xbd, 0x30, 0x0a, + 0x78, 0x9c, 0x80, 0xc7, 0xf3, 0x7d, 0xe7, 0x37, 0x72, 0x2a, 0x29, 0x89, 0xea, 0x99, 0x3c, 0x8c, + 0x10, 0xe7, 0xb7, 0x88, 0x96, 0x60, 0x3a, 0x24, 0x91, 0x3c, 0x8c, 0x16, 0xc2, 0x95, 0xd7, 0xab, + 0xeb, 0x33, 0x4f, 0xf0, 0x20, 0x07, 0x74, 0x33, 0xd4, 0x93, 0x40, 0x9c, 0xc6, 0x47, 0x97, 0xa1, + 0xe4, 0x87, 0x33, 0xef, 0x2d, 0xc8, 0x51, 0x4a, 0x9f, 0xe2, 0xdc, 0x74, 0xec, 0x46, 0x1d, 0x97, + 0xfc, 0x70, 0xf6, 0xdb, 0x61, 0x3a, 0xc5, 0x31, 0x1c, 0x26, 0xb7, 0xcf, 0xec, 0x2e, 0x8c, 0x1b, + 0xb3, 0xf2, 0x50, 0xb5, 0xd4, 0xff, 0x76, 0x18, 0x2a, 0x4a, 0x83, 0x89, 0x2e, 0x99, 0x8a, 0xe9, + 0x33, 0x49, 0xc5, 0xf4, 0x48, 0xcd, 0x6f, 0x1a, 0xba, 0xe8, 0x8d, 0x8c, 0x68, 0x70, 0x79, 0x67, + 0x40, 0xff, 0x06, 0xf2, 0x9a, 0x58, 0xb8, 0xdc, 0xb7, 0x86, 0x7b, 0xa0, 0x50, 0xd2, 0x7c, 0x05, + 0xa6, 0x3d, 0x9f, 0xb1, 0xa9, 0xa4, 0x29, 0x79, 0x10, 0xc6, 0x6a, 0x54, 0xf4, 0xf0, 0x2a, 0x09, + 0x04, 0x9c, 0xae, 0x43, 0x1b, 0xe4, 0xbc, 0x42, 0x52, 0xb4, 0xcd, 0x59, 0x09, 0x2c, 0xa0, 0xe8, + 0x09, 0x18, 0xec, 0xf8, 0xcd, 0xd5, 0x9a, 0x60, 0x51, 0xb5, 0x18, 0xa4, 0xcd, 0xd5, 0x1a, 0xe6, + 0x30, 0xb4, 0x00, 0x43, 0xec, 0x47, 0x38, 0x33, 0x96, 0x1f, 0x47, 0x83, 0xd5, 0xd0, 0x32, 0x27, + 0xb1, 0x0a, 0x58, 0x54, 0x64, 0x22, 0x36, 0xca, 0xd7, 0x33, 0x11, 0xdb, 0xf0, 0x03, 0x8a, 0xd8, + 0x24, 0x01, 0x1c, 0xd3, 0x42, 0x77, 0xe1, 0x94, 0xf1, 0x96, 0xe2, 0x4b, 0x84, 0x84, 0xc2, 0x97, + 0xff, 0x89, 0xc2, 0x47, 0x94, 0xd0, 0x88, 0x9f, 0x15, 0x9d, 0x3e, 0xb5, 0x9a, 0x45, 0x09, 0x67, + 0x37, 0x80, 0x5a, 0x30, 0xdd, 0x48, 0xb5, 0x3a, 0xd2, 0x7f, 0xab, 0x6a, 0x42, 0xd3, 0x2d, 0xa6, + 0x09, 0xa3, 0x57, 0x60, 0xe4, 0x4d, 0x3f, 0x64, 0xc7, 0xbb, 0x60, 0xab, 0xa5, 0x23, 0xf8, 0xc8, + 0xeb, 0x37, 0xea, 0xac, 0xfc, 0xfe, 0xc1, 0xdc, 0x68, 0xcd, 0x6f, 0xca, 0xbf, 0x58, 0x55, 0x40, + 0xdf, 0x6f, 0xc1, 0x6c, 0xfa, 0xb1, 0xa6, 0x3a, 0x3d, 0xde, 0x7f, 0xa7, 0x6d, 0xd1, 0xe8, 0xec, + 0x72, 0x2e, 0x39, 0x5c, 0xd0, 0x94, 0xfd, 0x4b, 0x16, 0x13, 0xd4, 0x09, 0x4d, 0x13, 0x09, 0xbb, + 0xad, 0xe3, 0x48, 0x18, 0xbb, 0x6c, 0x28, 0xc1, 0x1e, 0xd8, 0x42, 0xe2, 0x5f, 0x5a, 0xcc, 0x42, + 0xe2, 0x18, 0x5d, 0x21, 0x5e, 0x87, 0x91, 0x48, 0x26, 0xf2, 0x2d, 0xc8, 0x71, 0xab, 0x75, 0x8a, + 0x59, 0x89, 0x28, 0x26, 0x57, 0xe5, 0xec, 0x55, 0x64, 0xec, 0x7f, 0xc2, 0x67, 0x40, 0x42, 0x8e, + 0x41, 0xd7, 0x50, 0x35, 0x75, 0x0d, 0x73, 0x3d, 0xbe, 0x20, 0x47, 0xe7, 0xf0, 0x8f, 0xcd, 0x7e, + 0x33, 0xe1, 0xce, 0x3b, 0xdd, 0x34, 0xc7, 0xfe, 0xbc, 0x05, 0x10, 0x87, 0x78, 0xee, 0x23, 0x55, + 0xdb, 0x4b, 0x94, 0xad, 0xf5, 0x23, 0xbf, 0xe1, 0xb7, 0x84, 0x26, 0xed, 0xb1, 0x58, 0xdd, 0xc1, + 0xcb, 0xef, 0x6b, 0xbf, 0xb1, 0xc2, 0x46, 0x73, 0x32, 0xa0, 0x5c, 0x39, 0x56, 0xc0, 0x19, 0xc1, + 0xe4, 0xbe, 0x68, 0xc1, 0xc9, 0x2c, 0xbb, 0x5a, 0xfa, 0x48, 0xe2, 0x62, 0x2e, 0x65, 0x36, 0xa5, + 0x66, 0xf3, 0x96, 0x28, 0xc7, 0x0a, 0xa3, 0xef, 0x1c, 0x78, 0x87, 0x8b, 0xad, 0x7c, 0x03, 0xc6, + 0x6b, 0x01, 0xd1, 0x2e, 0xd7, 0x57, 0x79, 0x90, 0x02, 0xde, 0x9f, 0x67, 0x0e, 0x1d, 0xa0, 0xc0, + 0xfe, 0x72, 0x09, 0x4e, 0x72, 0xeb, 0x83, 0x85, 0x3d, 0xdf, 0x6d, 0xd6, 0xfc, 0xa6, 0xf0, 0x9e, + 0xfa, 0x04, 0x8c, 0x75, 0x34, 0xd9, 0x64, 0x51, 0x9c, 0x50, 0x5d, 0x86, 0x19, 0x4b, 0x53, 0xf4, + 0x52, 0x6c, 0xd0, 0x42, 0x4d, 0x18, 0x23, 0x7b, 0x6e, 0x43, 0xa9, 0xb0, 0x4b, 0x87, 0xbe, 0xe8, + 0x54, 0x2b, 0xcb, 0x1a, 0x1d, 0x6c, 0x50, 0x7d, 0x08, 0x99, 0xa9, 0xed, 0x1f, 0xb3, 0xe0, 0x91, + 0x9c, 0xa8, 0xa2, 0xb4, 0xb9, 0x3b, 0xcc, 0xce, 0x43, 0x2c, 0x5b, 0xd5, 0x1c, 0xb7, 0xfe, 0xc0, + 0x02, 0x8a, 0x3e, 0x06, 0xc0, 0xad, 0x37, 0xe8, 0x2b, 0xbd, 0x57, 0xf8, 0x45, 0x23, 0x72, 0x9c, + 0x16, 0x04, 0x4c, 0xd6, 0xc7, 0x1a, 0x2d, 0xfb, 0x8b, 0x03, 0x30, 0xc8, 0xb3, 0xe8, 0xd7, 0x60, + 0x78, 0x87, 0xe7, 0x89, 0x29, 0x9c, 0x37, 0x8a, 0x2b, 0x53, 0xcf, 0xc4, 0xf3, 0xa6, 0x95, 0x62, + 0x49, 0x06, 0xad, 0xc1, 0x09, 0x9e, 0xae, 0xa7, 0x55, 0x25, 0x2d, 0x67, 0x5f, 0x8a, 0xfd, 0x78, + 0x6e, 0x59, 0x25, 0xfe, 0x5c, 0x4d, 0xa3, 0xe0, 0xac, 0x7a, 0xe8, 0x55, 0x98, 0xa0, 0xcf, 0x30, + 0xbf, 0x1b, 0x49, 0x4a, 0x3c, 0x51, 0x8f, 0x7a, 0xf7, 0x6d, 0x18, 0x50, 0x9c, 0xc0, 0x46, 0xaf, + 0xc0, 0x78, 0x27, 0x25, 0xe0, 0x1c, 0x8c, 0x25, 0x01, 0xa6, 0x50, 0xd3, 0xc4, 0x65, 0xa6, 0xb5, + 0x5d, 0x66, 0x48, 0xbc, 0xb1, 0x13, 0x90, 0x70, 0xc7, 0x6f, 0x35, 0x19, 0xfb, 0x37, 0xa8, 0x99, + 0xd6, 0x26, 0xe0, 0x38, 0x55, 0x83, 0x52, 0xd9, 0x72, 0xdc, 0x56, 0x37, 0x20, 0x31, 0x95, 0x21, + 0x93, 0xca, 0x4a, 0x02, 0x8e, 0x53, 0x35, 0x7a, 0x4b, 0x6e, 0x87, 0x8f, 0x46, 0x72, 0x6b, 0xff, + 0x9d, 0x12, 0x18, 0x53, 0xfb, 0xad, 0x9b, 0x40, 0x88, 0x7e, 0xd9, 0x76, 0xd0, 0x69, 0x08, 0xcb, + 0x98, 0xcc, 0x2f, 0x8b, 0xf3, 0x82, 0xf2, 0x2f, 0xa3, 0xff, 0x31, 0xab, 0x45, 0xf7, 0xf8, 0xa9, + 0x5a, 0xe0, 0xd3, 0x4b, 0x4e, 0x86, 0xb1, 0x52, 0x16, 0xec, 0xc3, 0xd2, 0xbb, 0xb7, 0x20, 0xe0, + 0xa3, 0xb0, 0xf1, 0xe5, 0x14, 0x0c, 0x23, 0x92, 0xba, 0xf0, 0xb5, 0x97, 0x54, 0xd0, 0x65, 0x18, + 0x15, 0x59, 0x61, 0x98, 0xa1, 0x35, 0xdf, 0x4c, 0xcc, 0xe8, 0xa5, 0x1a, 0x17, 0x63, 0x1d, 0xc7, + 0xfe, 0x81, 0x12, 0x9c, 0xc8, 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, 0x90, 0x49, 0x3c, 0xcf, 0xc3, 0x40, 0x37, 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, 0x28, 0xc3, 0x99, 0x5c, 0xdf, 0x39, 0xda, 0xf5, 0xb6, 0xef, 0xb9, 0x91, 0xaf, 0xac, 0x89, + 0x78, 0x9c, 0x41, 0xd2, 0xd9, 0x59, 0x13, 0xe5, 0x58, 0x61, 0xa0, 0x0b, 0x30, 0xc8, 0x84, 0xa2, + 0xa9, 0x24, 0xac, 0x8b, 0x55, 0x1e, 0x78, 0x8a, 0x83, 0xfb, 0xce, 0x9b, 0xfd, 0x04, 0xe5, 0x60, + 0xfc, 0x56, 0xf2, 0x42, 0xa1, 0xdd, 0xf5, 0xfd, 0x16, 0x66, 0x40, 0xf4, 0x3e, 0x31, 0x5e, 0x09, + 0xf3, 0x19, 0xec, 0x34, 0xfd, 0x50, 0x1b, 0xb4, 0xa7, 0x60, 0x78, 0x97, 0xec, 0x07, 0xae, 0xb7, + 0x9d, 0x34, 0xab, 0xba, 0xc6, 0x8b, 0xb1, 0x84, 0x9b, 0x59, 0x03, 0x87, 0x8f, 0x3a, 0xe1, 0xf5, + 0x48, 0x4f, 0xf6, 0xe4, 0x87, 0xca, 0x30, 0x89, 0x17, 0xab, 0xef, 0x4e, 0xc4, 0xcd, 0xf4, 0x44, + 0x1c, 0x75, 0xc2, 0xeb, 0xde, 0xb3, 0xf1, 0xf3, 0x16, 0x4c, 0xb2, 0xdc, 0x34, 0xc2, 0x43, 0xde, + 0xf5, 0xbd, 0x63, 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, 0xea, 0x44, 0x0e, + 0x66, 0xa5, 0x2c, 0xec, 0x12, 0x26, 0x9d, 0x96, 0xcb, 0x3b, 0x1d, 0xab, 0xac, 0xdf, 0x19, 0x5e, + 0xf5, 0x99, 0x5d, 0x7b, 0x7b, 0x61, 0x97, 0xb2, 0x49, 0x16, 0x3f, 0xb3, 0xff, 0xa8, 0x04, 0xe7, + 0x32, 0xeb, 0xf5, 0x1d, 0x76, 0xa9, 0xb8, 0xf6, 0xc3, 0xcc, 0x3e, 0x52, 0x3e, 0x46, 0xa3, 0xd5, + 0x81, 0x7e, 0xb9, 0xff, 0xc1, 0x3e, 0xa2, 0x21, 0x65, 0x0e, 0xd9, 0x3b, 0x24, 0x1a, 0x52, 0x66, + 0xdf, 0x72, 0xc4, 0x04, 0x7f, 0x5e, 0xca, 0xf9, 0x16, 0x26, 0x30, 0xb8, 0x48, 0xcf, 0x19, 0x06, + 0x0c, 0xe5, 0x23, 0x9c, 0x9f, 0x31, 0xbc, 0x0c, 0x2b, 0x28, 0x5a, 0x80, 0xc9, 0xb6, 0xeb, 0xd1, + 0xc3, 0x67, 0xdf, 0x64, 0xc5, 0x55, 0xb0, 0xba, 0x35, 0x13, 0x8c, 0x93, 0xf8, 0xc8, 0xd5, 0x22, + 0x25, 0xf1, 0xaf, 0x7b, 0xe5, 0x50, 0xbb, 0x6e, 0xde, 0x54, 0xe7, 0xab, 0x51, 0xcc, 0x88, 0x9a, + 0xb4, 0xa6, 0xc9, 0x89, 0xca, 0xfd, 0xcb, 0x89, 0xc6, 0xb2, 0x65, 0x44, 0xb3, 0xaf, 0xc0, 0xf8, + 0x03, 0x2b, 0x06, 0xec, 0xaf, 0x95, 0xe1, 0xd1, 0x82, 0x6d, 0xcf, 0xcf, 0x7a, 0x63, 0x0e, 0xb4, + 0xb3, 0x3e, 0x35, 0x0f, 0x35, 0x38, 0xb9, 0xd5, 0x6d, 0xb5, 0xf6, 0x99, 0x2f, 0x07, 0x69, 0x4a, + 0x0c, 0xc1, 0x53, 0x4a, 0xe1, 0xc8, 0xc9, 0x95, 0x0c, 0x1c, 0x9c, 0x59, 0x93, 0x3e, 0xb1, 0xe8, + 0x4d, 0xb2, 0xaf, 0x48, 0x25, 0x9e, 0x58, 0x58, 0x07, 0x62, 0x13, 0x17, 0x5d, 0x81, 0x69, 0x67, + 0xcf, 0x71, 0x79, 0xb8, 0x69, 0x49, 0x80, 0xbf, 0xb1, 0x94, 0x3c, 0x77, 0x21, 0x89, 0x80, 0xd3, + 0x75, 0xd0, 0x6b, 0x80, 0xfc, 0x4d, 0x66, 0xf1, 0xdd, 0xbc, 0x42, 0x3c, 0xa1, 0x75, 0x65, 0x73, + 0x57, 0x8e, 0x8f, 0x84, 0x1b, 0x29, 0x0c, 0x9c, 0x51, 0x2b, 0x11, 0x11, 0x68, 0x28, 0x3f, 0x22, + 0x50, 0xf1, 0xb9, 0xd8, 0x33, 0xf1, 0xcd, 0x7f, 0xb6, 0xe8, 0xf5, 0xc5, 0x99, 0x7c, 0x33, 0x80, + 0xe6, 0x2b, 0xcc, 0x6a, 0x92, 0xcb, 0x7a, 0xb5, 0xf8, 0x29, 0xa7, 0x34, 0xab, 0xc9, 0x18, 0x88, + 0x4d, 0x5c, 0xbe, 0x20, 0xc2, 0xd8, 0x6d, 0xd7, 0x60, 0xf1, 0x45, 0x94, 0x2f, 0x85, 0x81, 0x3e, + 0x0e, 0xc3, 0x4d, 0x77, 0xcf, 0x0d, 0x85, 0xa4, 0xeb, 0xd0, 0x6a, 0xa5, 0xf8, 0x1c, 0xac, 0x72, + 0x32, 0x58, 0xd2, 0xb3, 0x7f, 0xa8, 0x04, 0xe3, 0xb2, 0xc5, 0xd7, 0xbb, 0x7e, 0xe4, 0x1c, 0xc3, + 0xb5, 0x7c, 0xc5, 0xb8, 0x96, 0xdf, 0x57, 0x14, 0xea, 0x8c, 0x75, 0x29, 0xf7, 0x3a, 0xbe, 0x91, + 0xb8, 0x8e, 0x9f, 0xec, 0x4d, 0xaa, 0xf8, 0x1a, 0xfe, 0xa7, 0x16, 0x4c, 0x1b, 0xf8, 0xc7, 0x70, + 0x1b, 0xac, 0x98, 0xb7, 0xc1, 0xe3, 0x3d, 0xbf, 0x21, 0xe7, 0x16, 0xf8, 0xde, 0x72, 0xa2, 0xef, + 0xec, 0xf4, 0x7f, 0x13, 0x06, 0x76, 0x9c, 0xa0, 0x59, 0x94, 0xda, 0x21, 0x55, 0x69, 0xfe, 0xaa, + 0x13, 0x08, 0xb5, 0xf3, 0x33, 0x72, 0xd4, 0x69, 0x51, 0x4f, 0x95, 0x33, 0x6b, 0x0a, 0xbd, 0x04, + 0x43, 0x61, 0xc3, 0xef, 0x28, 0x4f, 0x8e, 0xf3, 0x6c, 0xa0, 0x59, 0xc9, 0xfd, 0x83, 0x39, 0x64, + 0x36, 0x47, 0x8b, 0xb1, 0xc0, 0x47, 0x9f, 0x80, 0x71, 0xf6, 0x4b, 0xd9, 0x80, 0x95, 0xf3, 0xc5, + 0x11, 0x75, 0x1d, 0x91, 0x1b, 0x48, 0x1a, 0x45, 0xd8, 0x24, 0x35, 0xbb, 0x0d, 0x15, 0xf5, 0x59, + 0x0f, 0x55, 0x6f, 0xfb, 0x1f, 0xcb, 0x70, 0x22, 0x63, 0xcd, 0xa1, 0xd0, 0x98, 0x89, 0xcb, 0x7d, + 0x2e, 0xd5, 0xb7, 0x39, 0x17, 0x21, 0x7b, 0x0d, 0x35, 0xc5, 0xda, 0xea, 0xbb, 0xd1, 0x9b, 0x21, + 0x49, 0x36, 0x4a, 0x8b, 0x7a, 0x37, 0x4a, 0x1b, 0x3b, 0xb6, 0xa1, 0xa6, 0x0d, 0xa9, 0x9e, 0x3e, + 0xd4, 0x39, 0xfd, 0xd3, 0x32, 0x9c, 0xcc, 0x8a, 0xbe, 0x88, 0x3e, 0x9b, 0x48, 0x2c, 0xfa, 0x42, + 0xbf, 0x71, 0x1b, 0x79, 0xb6, 0x51, 0x11, 0x10, 0x6e, 0xde, 0x4c, 0x35, 0xda, 0x73, 0x98, 0x45, + 0x9b, 0x2c, 0x24, 0x45, 0xc0, 0x13, 0xc2, 0xca, 0xe3, 0xe3, 0x83, 0x7d, 0x77, 0x40, 0x64, 0x92, + 0x0d, 0x13, 0xf6, 0x25, 0xb2, 0xb8, 0xb7, 0x7d, 0x89, 0x6c, 0x79, 0xd6, 0x85, 0x51, 0xed, 0x6b, + 0x1e, 0xea, 0x8c, 0xef, 0xd2, 0xdb, 0x4a, 0xeb, 0xf7, 0x43, 0x9d, 0xf5, 0x1f, 0xb3, 0x20, 0xe1, + 0x72, 0xa0, 0xc4, 0x62, 0x56, 0xae, 0x58, 0xec, 0x3c, 0x0c, 0x04, 0x7e, 0x8b, 0x24, 0x33, 0x70, + 0x62, 0xbf, 0x45, 0x30, 0x83, 0x50, 0x8c, 0x28, 0x16, 0x76, 0x8c, 0xe9, 0x0f, 0x39, 0xf1, 0x44, + 0x7b, 0x02, 0x06, 0x5b, 0x64, 0x8f, 0xb4, 0x92, 0x89, 0x92, 0xae, 0xd3, 0x42, 0xcc, 0x61, 0xf6, + 0xcf, 0x0f, 0xc0, 0xd9, 0xc2, 0xa0, 0x2e, 0xf4, 0x39, 0xb4, 0xed, 0x44, 0xe4, 0x8e, 0xb3, 0x9f, + 0xcc, 0x68, 0x72, 0x85, 0x17, 0x63, 0x09, 0x67, 0x9e, 0x64, 0x3c, 0x30, 0x79, 0x42, 0x88, 0x28, + 0xe2, 0x91, 0x0b, 0xa8, 0x29, 0x94, 0x2a, 0x1f, 0x85, 0x50, 0xea, 0x39, 0x80, 0x30, 0x6c, 0x71, + 0xc3, 0xac, 0xa6, 0x70, 0x51, 0x8b, 0x03, 0xd8, 0xd7, 0xaf, 0x0b, 0x08, 0xd6, 0xb0, 0x50, 0x15, + 0xa6, 0x3a, 0x81, 0x1f, 0x71, 0x99, 0x6c, 0x95, 0xdb, 0x2e, 0x0e, 0x9a, 0xf1, 0x34, 0x6a, 0x09, + 0x38, 0x4e, 0xd5, 0x40, 0x2f, 0xc2, 0xa8, 0x88, 0xb1, 0x51, 0xf3, 0xfd, 0x96, 0x10, 0x03, 0x29, + 0x73, 0xbe, 0x7a, 0x0c, 0xc2, 0x3a, 0x9e, 0x56, 0x8d, 0x09, 0x7a, 0x87, 0x33, 0xab, 0x71, 0x61, + 0xaf, 0x86, 0x97, 0x88, 0xc4, 0x3a, 0xd2, 0x57, 0x24, 0xd6, 0x58, 0x30, 0x56, 0xe9, 0x5b, 0xef, + 0x08, 0x3d, 0x45, 0x49, 0x3f, 0x3b, 0x00, 0x27, 0xc4, 0xc2, 0x79, 0xd8, 0xcb, 0xe5, 0x66, 0x7a, + 0xb9, 0x1c, 0x85, 0xe8, 0xec, 0xdd, 0x35, 0x73, 0xdc, 0x6b, 0xe6, 0x87, 0x2d, 0x30, 0xd9, 0x2b, + 0xf4, 0x17, 0x72, 0x53, 0x42, 0xbd, 0x98, 0xcb, 0xae, 0xa9, 0xa8, 0x9e, 0x6f, 0x33, 0x39, 0x94, + 0xfd, 0x9f, 0x2c, 0x78, 0xbc, 0x27, 0x45, 0xb4, 0x0c, 0x15, 0xc6, 0x03, 0x6a, 0xaf, 0xb3, 0x27, + 0x95, 0x6d, 0xb3, 0x04, 0xe4, 0xb0, 0xa4, 0x71, 0x4d, 0xb4, 0x9c, 0xca, 0xbd, 0xf5, 0x54, 0x46, + 0xee, 0xad, 0x53, 0xc6, 0xf0, 0x3c, 0x60, 0xf2, 0xad, 0x1f, 0xa4, 0x37, 0x8e, 0xe1, 0x57, 0x84, + 0x3e, 0x68, 0x88, 0xfd, 0xec, 0x84, 0xd8, 0x0f, 0x99, 0xd8, 0xda, 0x1d, 0xf2, 0x51, 0x98, 0x62, + 0xc1, 0xb7, 0x98, 0xa5, 0xbd, 0xf0, 0x78, 0x2a, 0xc5, 0xd6, 0xb4, 0xd7, 0x13, 0x30, 0x9c, 0xc2, + 0xb6, 0xff, 0xb0, 0x0c, 0x43, 0x7c, 0xfb, 0x1d, 0xc3, 0x9b, 0xf0, 0x69, 0xa8, 0xb8, 0xed, 0x76, + 0x97, 0xa7, 0x53, 0x1a, 0xe4, 0xbe, 0xd1, 0x74, 0x9e, 0x56, 0x65, 0x21, 0x8e, 0xe1, 0x68, 0x45, + 0x48, 0x9c, 0x0b, 0xe2, 0x7b, 0xf2, 0x8e, 0xcf, 0x57, 0x9d, 0xc8, 0xe1, 0x0c, 0x8e, 0xba, 0x67, + 0x63, 0xd9, 0x34, 0xfa, 0x14, 0x40, 0x18, 0x05, 0xae, 0xb7, 0x4d, 0xcb, 0x44, 0x58, 0xe1, 0xf7, + 0x17, 0x50, 0xab, 0x2b, 0x64, 0x4e, 0x33, 0x3e, 0x73, 0x14, 0x00, 0x6b, 0x14, 0xd1, 0xbc, 0x71, + 0xd3, 0xcf, 0x26, 0xe6, 0x0e, 0x38, 0xd5, 0x78, 0xce, 0x66, 0x3f, 0x04, 0x15, 0x45, 0xbc, 0x97, + 0xfc, 0x69, 0x4c, 0x67, 0x8b, 0x3e, 0x02, 0x93, 0x89, 0xbe, 0x1d, 0x4a, 0x7c, 0xf5, 0x0b, 0x16, + 0x4c, 0xf2, 0xce, 0x2c, 0x7b, 0x7b, 0xe2, 0x36, 0x78, 0x0b, 0x4e, 0xb6, 0x32, 0x4e, 0x65, 0x31, + 0xfd, 0xfd, 0x9f, 0xe2, 0x4a, 0x5c, 0x95, 0x05, 0xc5, 0x99, 0x6d, 0xa0, 0x8b, 0x74, 0xc7, 0xd1, + 0x53, 0xd7, 0x69, 0x09, 0x57, 0xe9, 0x31, 0xbe, 0xdb, 0x78, 0x19, 0x56, 0x50, 0xfb, 0x77, 0x2c, + 0x98, 0xe6, 0x3d, 0xbf, 0x46, 0xf6, 0xd5, 0xd9, 0xf4, 0x8d, 0xec, 0xbb, 0x48, 0xe4, 0x57, 0xca, + 0x49, 0xe4, 0xa7, 0x7f, 0x5a, 0xb9, 0xf0, 0xd3, 0xbe, 0x6c, 0x81, 0x58, 0x21, 0xc7, 0x20, 0x84, + 0xf8, 0x76, 0x53, 0x08, 0x31, 0x9b, 0xbf, 0x09, 0x72, 0xa4, 0x0f, 0x7f, 0x66, 0xc1, 0x14, 0x47, + 0x88, 0xb5, 0xe5, 0xdf, 0xd0, 0x79, 0xe8, 0x27, 0xdd, 0xf7, 0x35, 0xb2, 0xbf, 0xe1, 0xd7, 0x9c, + 0x68, 0x27, 0xfb, 0xa3, 0x8c, 0xc9, 0x1a, 0x28, 0x9c, 0xac, 0xa6, 0xdc, 0x40, 0x46, 0x9e, 0x9b, + 0x1e, 0xf1, 0x23, 0x0e, 0x9b, 0xe7, 0xc6, 0xfe, 0xba, 0x05, 0x88, 0x37, 0x63, 0x30, 0x6e, 0x94, + 0x1d, 0x62, 0xa5, 0xda, 0x45, 0x17, 0x1f, 0x4d, 0x0a, 0x82, 0x35, 0xac, 0x23, 0x19, 0x9e, 0x84, + 0xc9, 0x43, 0xb9, 0xb7, 0xc9, 0xc3, 0x21, 0x46, 0xf4, 0xdf, 0x0d, 0x41, 0xd2, 0xb7, 0x0a, 0xdd, + 0x82, 0xb1, 0x86, 0xd3, 0x71, 0x36, 0xdd, 0x96, 0x1b, 0xb9, 0x24, 0x2c, 0xb2, 0x87, 0x5a, 0xd2, + 0xf0, 0x84, 0x92, 0x5a, 0x2b, 0xc1, 0x06, 0x1d, 0x34, 0x0f, 0xd0, 0x09, 0xdc, 0x3d, 0xb7, 0x45, + 0xb6, 0x99, 0xac, 0x84, 0x05, 0x67, 0xe0, 0xc6, 0x59, 0xb2, 0x14, 0x6b, 0x18, 0x19, 0x8e, 0xec, + 0xe5, 0x87, 0xec, 0xc8, 0x0e, 0xc7, 0xe6, 0xc8, 0x3e, 0x70, 0x28, 0x47, 0xf6, 0x91, 0x43, 0x3b, + 0xb2, 0x0f, 0xf6, 0xe5, 0xc8, 0x8e, 0xe1, 0xb4, 0xe4, 0x3d, 0xe9, 0xff, 0x15, 0xb7, 0x45, 0xc4, + 0x83, 0x83, 0x47, 0x94, 0x98, 0xbd, 0x77, 0x30, 0x77, 0x1a, 0x67, 0x62, 0xe0, 0x9c, 0x9a, 0xe8, + 0x63, 0x30, 0xe3, 0xb4, 0x5a, 0xfe, 0x1d, 0x35, 0xa9, 0xcb, 0x61, 0xc3, 0x69, 0x71, 0x25, 0xc4, + 0x30, 0xa3, 0xfa, 0xd8, 0xbd, 0x83, 0xb9, 0x99, 0x85, 0x1c, 0x1c, 0x9c, 0x5b, 0x1b, 0x7d, 0x18, + 0x2a, 0x9d, 0xc0, 0x6f, 0xac, 0x69, 0x0e, 0xa0, 0xe7, 0xe8, 0x00, 0xd6, 0x64, 0xe1, 0xfd, 0x83, + 0xb9, 0x71, 0xf5, 0x87, 0x5d, 0xf8, 0x71, 0x85, 0x0c, 0xcf, 0xf4, 0xd1, 0x23, 0xf5, 0x4c, 0xdf, + 0x85, 0x13, 0x75, 0x12, 0xb8, 0x4e, 0xcb, 0x7d, 0x8b, 0xf2, 0xcb, 0xf2, 0x7c, 0xda, 0x80, 0x4a, + 0x90, 0x38, 0x91, 0xfb, 0x8a, 0xb9, 0xa9, 0x25, 0x1c, 0x91, 0x27, 0x70, 0x4c, 0xc8, 0xfe, 0x3f, + 0x16, 0x0c, 0x0b, 0x5f, 0xaa, 0x63, 0xe0, 0x1a, 0x17, 0x0c, 0x4d, 0xc2, 0x5c, 0xf6, 0x80, 0xb1, + 0xce, 0xe4, 0xea, 0x10, 0x56, 0x13, 0x3a, 0x84, 0xc7, 0x8b, 0x88, 0x14, 0x6b, 0x0f, 0xfe, 0x46, + 0x99, 0x72, 0xef, 0x86, 0x57, 0xef, 0xc3, 0x1f, 0x82, 0x75, 0x18, 0x0e, 0x85, 0x57, 0x69, 0x29, + 0xdf, 0xa7, 0x21, 0x39, 0x89, 0xb1, 0x1d, 0x9b, 0xf0, 0x23, 0x95, 0x44, 0x32, 0xdd, 0x55, 0xcb, + 0x0f, 0xd1, 0x5d, 0xb5, 0x97, 0xdf, 0xf3, 0xc0, 0x51, 0xf8, 0x3d, 0xdb, 0x5f, 0x65, 0x37, 0xa7, + 0x5e, 0x7e, 0x0c, 0x4c, 0xd5, 0x15, 0xf3, 0x8e, 0xb5, 0x0b, 0x56, 0x96, 0xe8, 0x54, 0x0e, 0x73, + 0xf5, 0x73, 0x16, 0x9c, 0xcd, 0xf8, 0x2a, 0x8d, 0xd3, 0x7a, 0x06, 0x46, 0x9c, 0x6e, 0xd3, 0x55, + 0x7b, 0x59, 0xd3, 0x27, 0x2e, 0x88, 0x72, 0xac, 0x30, 0xd0, 0x12, 0x4c, 0x93, 0xbb, 0x1d, 0x97, + 0xab, 0x52, 0x75, 0xf3, 0xdf, 0x32, 0x77, 0xc0, 0x5b, 0x4e, 0x02, 0x71, 0x1a, 0x5f, 0xc5, 0x9a, + 0x29, 0xe7, 0xc6, 0x9a, 0xf9, 0xfb, 0x16, 0x8c, 0x2a, 0xbf, 0xca, 0x87, 0x3e, 0xda, 0x1f, 0x35, + 0x47, 0xfb, 0xd1, 0x82, 0xd1, 0xce, 0x19, 0xe6, 0xdf, 0x2a, 0xa9, 0xfe, 0xd6, 0xfc, 0x20, 0xea, + 0x83, 0x83, 0x7b, 0x70, 0xd7, 0x85, 0xcb, 0x30, 0xea, 0x74, 0x3a, 0x12, 0x20, 0x6d, 0xd0, 0x58, + 0x04, 0xe5, 0xb8, 0x18, 0xeb, 0x38, 0xca, 0x93, 0xa2, 0x9c, 0xeb, 0x49, 0xd1, 0x04, 0x88, 0x9c, + 0x60, 0x9b, 0x44, 0xb4, 0x4c, 0x98, 0xcc, 0xe6, 0x9f, 0x37, 0xdd, 0xc8, 0x6d, 0xcd, 0xbb, 0x5e, + 0x14, 0x46, 0xc1, 0xfc, 0xaa, 0x17, 0xdd, 0x08, 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, 0xd8, 0xed, 0xc3, 0xc6, 0xf4, 0x70, 0x91, 0x8a, 0xfe, 0xe1, 0x98, 0x9a, 0x0d, 0xa6, 0xc9, + 0xac, 0xea, 0xf1, 0x90, 0x8a, 0x0f, 0x7b, 0xda, 0xb0, 0xee, 0xd7, 0x17, 0x07, 0x4d, 0x42, 0xdf, + 0x91, 0x32, 0x50, 0x79, 0xb6, 0xc7, 0xad, 0x71, 0x08, 0x93, 0x14, 0x96, 0x4e, 0x85, 0x25, 0x9b, + 0x58, 0xad, 0x89, 0x7d, 0xa1, 0xa5, 0x53, 0x11, 0x00, 0x1c, 0xe3, 0x50, 0x66, 0x4a, 0xfd, 0x09, + 0x67, 0x50, 0x1c, 0x56, 0x54, 0x61, 0x87, 0x58, 0xc3, 0x40, 0x97, 0x84, 0x40, 0x81, 0xeb, 0x05, + 0x1e, 0x4d, 0x08, 0x14, 0xe4, 0x70, 0x69, 0x52, 0xa0, 0xcb, 0x30, 0xaa, 0x32, 0x68, 0xd7, 0x78, + 0x22, 0x23, 0xb1, 0xcc, 0x96, 0xe3, 0x62, 0xac, 0xe3, 0xa0, 0x0d, 0x98, 0x0c, 0xb9, 0x9c, 0x4d, + 0xc5, 0x7a, 0xe6, 0xf2, 0xca, 0xf7, 0x4b, 0x2b, 0xa0, 0xba, 0x09, 0xbe, 0xcf, 0x8a, 0xf8, 0xe9, + 0x24, 0xfd, 0xfc, 0x93, 0x24, 0xd0, 0xab, 0x30, 0xd1, 0xf2, 0x9d, 0xe6, 0xa2, 0xd3, 0x72, 0xbc, + 0x06, 0x1b, 0x9f, 0x11, 0x33, 0x11, 0xeb, 0x75, 0x03, 0x8a, 0x13, 0xd8, 0x94, 0x79, 0xd3, 0x4b, + 0x44, 0x7c, 0x72, 0xc7, 0xdb, 0x26, 0xa1, 0xc8, 0x87, 0xcc, 0x98, 0xb7, 0xeb, 0x39, 0x38, 0x38, + 0xb7, 0x36, 0x7a, 0x09, 0xc6, 0xe4, 0xe7, 0x6b, 0x61, 0x31, 0x62, 0xa7, 0x14, 0x0d, 0x86, 0x0d, + 0x4c, 0x74, 0x07, 0x4e, 0xc9, 0xff, 0x1b, 0x81, 0xb3, 0xb5, 0xe5, 0x36, 0x84, 0xaf, 0x38, 0xf7, + 0x5e, 0x5d, 0x90, 0x2e, 0x96, 0xcb, 0x59, 0x48, 0xf7, 0x0f, 0xe6, 0xce, 0x8b, 0x51, 0xcb, 0x84, + 0xb3, 0x49, 0xcc, 0xa6, 0x8f, 0xd6, 0xe0, 0xc4, 0x0e, 0x71, 0x5a, 0xd1, 0xce, 0xd2, 0x0e, 0x69, + 0xec, 0xca, 0x4d, 0xc7, 0x82, 0x6d, 0x68, 0x0e, 0x1c, 0x57, 0xd3, 0x28, 0x38, 0xab, 0x1e, 0x7a, + 0x03, 0x66, 0x3a, 0xdd, 0xcd, 0x96, 0x1b, 0xee, 0xac, 0xfb, 0x11, 0x33, 0x05, 0x52, 0x09, 0xb9, + 0x45, 0x54, 0x0e, 0x15, 0xce, 0xa4, 0x96, 0x83, 0x87, 0x73, 0x29, 0xa0, 0xb7, 0xe0, 0x54, 0x62, + 0x31, 0x88, 0xb8, 0x04, 0x13, 0xf9, 0xd9, 0x1e, 0xea, 0x59, 0x15, 0x44, 0x88, 0x8f, 0x2c, 0x10, + 0xce, 0x6e, 0x02, 0xbd, 0x0c, 0xe0, 0x76, 0x56, 0x9c, 0xb6, 0xdb, 0xa2, 0xcf, 0xc5, 0x13, 0x6c, + 0x9d, 0xd0, 0xa7, 0x03, 0xac, 0xd6, 0x64, 0x29, 0x3d, 0x9f, 0xc5, 0xbf, 0x7d, 0xac, 0x61, 0xa3, + 0x1a, 0x4c, 0x88, 0x7f, 0xfb, 0x62, 0x5a, 0xa7, 0x55, 0x08, 0x80, 0x09, 0x59, 0x43, 0xcd, 0x25, + 0x32, 0x4b, 0xd8, 0xec, 0x25, 0xea, 0xa3, 0x6d, 0x38, 0x2b, 0xb3, 0x77, 0xe9, 0xeb, 0x54, 0xce, + 0x43, 0xc8, 0xd2, 0x2c, 0x8c, 0x70, 0xff, 0x90, 0x85, 0x22, 0x44, 0x5c, 0x4c, 0x87, 0xde, 0xef, + 0xfa, 0x72, 0xe7, 0x1e, 0xb4, 0xa7, 0xb8, 0x79, 0x12, 0xbd, 0xdf, 0xaf, 0x27, 0x81, 0x38, 0x8d, + 0x8f, 0x42, 0x38, 0xe5, 0x7a, 0x59, 0xab, 0xfb, 0x34, 0x23, 0xf4, 0x11, 0xee, 0x3c, 0x5c, 0xbc, + 0xb2, 0x33, 0xe1, 0x7c, 0x65, 0x67, 0xd2, 0x7e, 0x7b, 0x56, 0x78, 0xbf, 0x6d, 0xd1, 0xda, 0x1a, + 0xa7, 0x8e, 0x3e, 0x0d, 0x63, 0xfa, 0x87, 0x09, 0xae, 0xe3, 0x42, 0x36, 0x23, 0xab, 0x9d, 0x0f, + 0x9c, 0xcf, 0x57, 0x67, 0x80, 0x0e, 0xc3, 0x06, 0x45, 0xd4, 0xc8, 0x70, 0xb3, 0xbf, 0xd4, 0x1f, + 0x57, 0xd3, 0xbf, 0x11, 0x1a, 0x81, 0xec, 0x65, 0x8f, 0xae, 0xc3, 0x48, 0xa3, 0xe5, 0x12, 0x2f, + 0x5a, 0xad, 0x15, 0xc5, 0xd2, 0x5b, 0x12, 0x38, 0x62, 0x1f, 0x89, 0xac, 0x09, 0xbc, 0x0c, 0x2b, + 0x0a, 0xf6, 0xaf, 0x96, 0x60, 0xae, 0x47, 0x0a, 0x8e, 0x84, 0x4a, 0xca, 0xea, 0x4b, 0x25, 0xb5, + 0x20, 0xb3, 0xce, 0xaf, 0x27, 0xa4, 0x5d, 0x89, 0x8c, 0xf2, 0xb1, 0xcc, 0x2b, 0x89, 0xdf, 0xb7, + 0x8b, 0x80, 0xae, 0xd5, 0x1a, 0xe8, 0xe9, 0xe4, 0x62, 0x68, 0xb3, 0x07, 0xfb, 0x7f, 0x02, 0xe7, + 0x6a, 0x26, 0xed, 0xaf, 0x96, 0xe0, 0x94, 0x1a, 0xc2, 0x6f, 0xdd, 0x81, 0xbb, 0x99, 0x1e, 0xb8, + 0x23, 0xd0, 0xeb, 0xda, 0x37, 0x60, 0x88, 0x07, 0x07, 0xec, 0x83, 0xf5, 0x7e, 0xc2, 0x0c, 0xbe, + 0xab, 0xb8, 0x3d, 0x23, 0x00, 0xef, 0xf7, 0x5b, 0x30, 0x99, 0xf0, 0x35, 0x43, 0x58, 0x73, 0x48, + 0x7e, 0x10, 0xf6, 0x38, 0x8b, 0xf1, 0x3e, 0x0f, 0x03, 0x3b, 0x7e, 0x18, 0x25, 0x8d, 0x3e, 0xae, + 0xfa, 0x61, 0x84, 0x19, 0xc4, 0xfe, 0x5d, 0x0b, 0x06, 0x37, 0x1c, 0xd7, 0x8b, 0xa4, 0x82, 0xc0, + 0xca, 0x51, 0x10, 0xf4, 0xf3, 0x5d, 0xe8, 0x45, 0x18, 0x22, 0x5b, 0x5b, 0xa4, 0x11, 0x89, 0x59, + 0x95, 0xd1, 0x1c, 0x86, 0x96, 0x59, 0x29, 0xe5, 0x05, 0x59, 0x63, 0xfc, 0x2f, 0x16, 0xc8, 0xe8, + 0x36, 0x54, 0x22, 0xb7, 0x4d, 0x16, 0x9a, 0x4d, 0xa1, 0x36, 0x7f, 0x80, 0x88, 0x14, 0x1b, 0x92, + 0x00, 0x8e, 0x69, 0xd9, 0x5f, 0x28, 0x01, 0xc4, 0x51, 0x95, 0x7a, 0x7d, 0xe2, 0x62, 0x4a, 0xa1, + 0x7a, 0x21, 0x43, 0xa1, 0x8a, 0x62, 0x82, 0x19, 0xda, 0x54, 0x35, 0x4c, 0xe5, 0xbe, 0x86, 0x69, + 0xe0, 0x30, 0xc3, 0xb4, 0x04, 0xd3, 0x71, 0x54, 0x28, 0x33, 0x28, 0x1e, 0xbb, 0x3e, 0x37, 0x92, + 0x40, 0x9c, 0xc6, 0xb7, 0x09, 0x9c, 0x57, 0xc1, 0x71, 0xc4, 0x8d, 0xc6, 0xac, 0xb2, 0x75, 0x05, + 0x75, 0x8f, 0x71, 0x8a, 0x35, 0xc6, 0xa5, 0x5c, 0x8d, 0xf1, 0x4f, 0x5a, 0x70, 0x32, 0xd9, 0x0e, + 0x73, 0x61, 0xfe, 0xbc, 0x05, 0xa7, 0x98, 0xde, 0x9c, 0xb5, 0x9a, 0xd6, 0xd2, 0xbf, 0x50, 0x18, + 0xf0, 0x27, 0xa7, 0xc7, 0x71, 0xd8, 0x90, 0xb5, 0x2c, 0xd2, 0x38, 0xbb, 0x45, 0xfb, 0x7b, 0xca, + 0x30, 0x93, 0x17, 0x29, 0x88, 0x39, 0x6d, 0x38, 0x77, 0xeb, 0xbb, 0xe4, 0x8e, 0x30, 0x8d, 0x8f, + 0x9d, 0x36, 0x78, 0x31, 0x96, 0xf0, 0x64, 0x56, 0x85, 0x52, 0x9f, 0x59, 0x15, 0x76, 0x60, 0xfa, + 0xce, 0x0e, 0xf1, 0x6e, 0x7a, 0xa1, 0x13, 0xb9, 0xe1, 0x96, 0xcb, 0x74, 0xcc, 0x7c, 0xdd, 0xc8, + 0x54, 0xac, 0xd3, 0xb7, 0x93, 0x08, 0xf7, 0x0f, 0xe6, 0xce, 0x1a, 0x05, 0x71, 0x97, 0xf9, 0x41, + 0x82, 0xd3, 0x44, 0xd3, 0x49, 0x29, 0x06, 0x1e, 0x72, 0x52, 0x8a, 0xb6, 0x2b, 0x2c, 0x53, 0xa4, + 0x45, 0x3e, 0x7b, 0x3d, 0xae, 0xa9, 0x52, 0xac, 0x61, 0xd8, 0x9f, 0xb7, 0xe0, 0x4c, 0x6e, 0x1e, + 0x63, 0x74, 0x11, 0x46, 0x9c, 0x8e, 0xcb, 0xc5, 0xfa, 0xe2, 0xd8, 0x65, 0xe2, 0xa3, 0xda, 0x2a, + 0x17, 0xea, 0x2b, 0x28, 0x3d, 0xed, 0x76, 0x5d, 0xaf, 0x99, 0x3c, 0xed, 0xae, 0xb9, 0x5e, 0x13, + 0x33, 0x88, 0x3a, 0xbe, 0xcb, 0x79, 0xc7, 0xb7, 0xfd, 0x7d, 0x16, 0x08, 0x07, 0xd5, 0x3e, 0xce, + 0xfa, 0x4f, 0xc0, 0xd8, 0x5e, 0x3a, 0xd1, 0xd5, 0xf9, 0x7c, 0x8f, 0x5d, 0x91, 0xde, 0x4a, 0x31, + 0x70, 0x46, 0x52, 0x2b, 0x83, 0x96, 0xdd, 0x04, 0x01, 0xad, 0x12, 0x26, 0xb4, 0xee, 0xdd, 0x9b, + 0xe7, 0x00, 0x9a, 0x0c, 0x97, 0x65, 0xbf, 0x2c, 0x99, 0x37, 0x79, 0x55, 0x41, 0xb0, 0x86, 0x65, + 0xff, 0x87, 0x12, 0x8c, 0xca, 0xc4, 0x4a, 0x5d, 0xaf, 0x1f, 0xd1, 0xd2, 0xa1, 0x32, 0xad, 0xa2, + 0x4b, 0x50, 0x61, 0xb2, 0xcf, 0x5a, 0x2c, 0x91, 0x53, 0x92, 0x87, 0x35, 0x09, 0xc0, 0x31, 0x0e, + 0xdd, 0x75, 0x61, 0x77, 0x93, 0xa1, 0x27, 0xdc, 0x29, 0xeb, 0xbc, 0x18, 0x4b, 0x38, 0xfa, 0x18, + 0x4c, 0xf1, 0x7a, 0x81, 0xdf, 0x71, 0xb6, 0xb9, 0xbe, 0x64, 0x50, 0xc5, 0xa8, 0x98, 0x5a, 0x4b, + 0xc0, 0xee, 0x1f, 0xcc, 0x9d, 0x4c, 0x96, 0x31, 0x45, 0x60, 0x8a, 0x0a, 0x33, 0x8b, 0xe2, 0x8d, + 0xd0, 0xd3, 0x22, 0x65, 0x4d, 0x15, 0x83, 0xb0, 0x8e, 0x67, 0x7f, 0x1a, 0x50, 0x3a, 0xc5, 0x14, + 0x7a, 0x8d, 0xdb, 0xc2, 0xba, 0x01, 0x69, 0x16, 0x29, 0x06, 0xf5, 0x48, 0x0c, 0xd2, 0x13, 0x8a, + 0xd7, 0xc2, 0xaa, 0xbe, 0xfd, 0x97, 0xcb, 0x30, 0x95, 0xf4, 0xfd, 0x46, 0x57, 0x61, 0x88, 0xb3, + 0x2a, 0x82, 0x7c, 0x81, 0xdd, 0x89, 0xe6, 0x31, 0xce, 0x0e, 0x6d, 0xc1, 0xed, 0x88, 0xfa, 0xe8, + 0x0d, 0x18, 0x6d, 0xfa, 0x77, 0xbc, 0x3b, 0x4e, 0xd0, 0x5c, 0xa8, 0xad, 0x8a, 0xe5, 0x9c, 0xf9, + 0x10, 0xae, 0xc6, 0x68, 0xba, 0x17, 0x3a, 0xd3, 0xb1, 0xc6, 0x20, 0xac, 0x93, 0x43, 0x1b, 0x2c, + 0x2e, 0xfd, 0x96, 0xbb, 0xbd, 0xe6, 0x74, 0x8a, 0x1c, 0x23, 0x96, 0x24, 0x92, 0x46, 0x79, 0x5c, + 0x04, 0xaf, 0xe7, 0x00, 0x1c, 0x13, 0x42, 0x9f, 0x85, 0x13, 0x61, 0x8e, 0x78, 0x3e, 0x2f, 0xe3, + 0x60, 0x91, 0xc4, 0x7a, 0xf1, 0x91, 0x7b, 0x07, 0x73, 0x27, 0xb2, 0x04, 0xf9, 0x59, 0xcd, 0xd8, + 0x5f, 0x3c, 0x09, 0xc6, 0x26, 0x36, 0x12, 0xd0, 0x5a, 0x47, 0x94, 0x80, 0x16, 0xc3, 0x08, 0x69, + 0x77, 0xa2, 0xfd, 0xaa, 0x1b, 0x14, 0xa5, 0xe1, 0x5f, 0x16, 0x38, 0x69, 0x9a, 0x12, 0x82, 0x15, + 0x9d, 0xec, 0x2c, 0xc1, 0xe5, 0x6f, 0x60, 0x96, 0xe0, 0x81, 0x63, 0xcc, 0x12, 0xbc, 0x0e, 0xc3, + 0xdb, 0x6e, 0x84, 0x49, 0xc7, 0x17, 0x8f, 0x84, 0xcc, 0x75, 0x78, 0x85, 0xa3, 0xa4, 0xf3, 0x51, + 0x0a, 0x00, 0x96, 0x44, 0xd0, 0x6b, 0x6a, 0x07, 0x0e, 0xe5, 0x3f, 0xe4, 0xd3, 0x06, 0x12, 0x99, + 0x7b, 0x50, 0xe4, 0x02, 0x1e, 0x7e, 0xd0, 0x5c, 0xc0, 0x2b, 0x32, 0x83, 0xef, 0x48, 0xbe, 0x17, + 0x13, 0x4b, 0xd0, 0xdb, 0x23, 0x6f, 0xef, 0x2d, 0x3d, 0xeb, 0x71, 0x25, 0xff, 0x24, 0x50, 0x09, + 0x8d, 0xfb, 0xcc, 0x75, 0xfc, 0x7d, 0x16, 0x9c, 0xea, 0x64, 0x25, 0x00, 0x17, 0xb6, 0x04, 0x2f, + 0xf6, 0x9d, 0x63, 0xdc, 0x68, 0x90, 0xc9, 0xe0, 0xb2, 0xb3, 0xc8, 0x67, 0x37, 0x47, 0x07, 0x3a, + 0xd8, 0x6c, 0x0a, 0x9d, 0xf6, 0x13, 0x39, 0x49, 0x93, 0x0b, 0x52, 0x25, 0x6f, 0x64, 0x24, 0xe8, + 0x7d, 0x6f, 0x5e, 0x82, 0xde, 0xbe, 0xd3, 0xf2, 0xbe, 0xa6, 0xd2, 0x25, 0x8f, 0xe7, 0x2f, 0x25, + 0x9e, 0x0c, 0xb9, 0x67, 0x92, 0xe4, 0xd7, 0x54, 0x92, 0xe4, 0x82, 0xf8, 0xc1, 0x3c, 0x05, 0x72, + 0xcf, 0xd4, 0xc8, 0x5a, 0x7a, 0xe3, 0xc9, 0xa3, 0x49, 0x6f, 0x6c, 0x5c, 0x35, 0x3c, 0xc3, 0xee, + 0xd3, 0x3d, 0xae, 0x1a, 0x83, 0x6e, 0xf1, 0x65, 0xc3, 0x53, 0x39, 0x4f, 0x3f, 0x50, 0x2a, 0xe7, + 0x5b, 0x7a, 0x6a, 0x64, 0xd4, 0x23, 0xf7, 0x2f, 0x45, 0xea, 0x33, 0x21, 0xf2, 0x2d, 0xfd, 0x02, + 0x3c, 0x91, 0x4f, 0x57, 0xdd, 0x73, 0x69, 0xba, 0x99, 0x57, 0x60, 0x2a, 0xd1, 0xf2, 0xc9, 0xe3, + 0x49, 0xb4, 0x7c, 0xea, 0xc8, 0x13, 0x2d, 0x9f, 0x3e, 0x86, 0x44, 0xcb, 0x8f, 0x1c, 0x63, 0xa2, + 0xe5, 0x5b, 0xcc, 0x00, 0x87, 0x87, 0xf9, 0x11, 0xf1, 0x8e, 0x9f, 0xca, 0x89, 0x92, 0x95, 0x8e, + 0x05, 0xc4, 0x3f, 0x4e, 0x81, 0x70, 0x4c, 0x2a, 0x23, 0x81, 0xf3, 0xcc, 0x43, 0x48, 0xe0, 0xbc, + 0x1e, 0x27, 0x70, 0x3e, 0x93, 0x3f, 0xd5, 0x19, 0x2e, 0x1b, 0x39, 0x69, 0x9b, 0x6f, 0xe9, 0xe9, + 0x96, 0x1f, 0x2d, 0xd0, 0xb2, 0x64, 0x09, 0x2a, 0x0b, 0x92, 0x2c, 0xbf, 0xca, 0x93, 0x2c, 0x3f, + 0x96, 0x7f, 0x92, 0x27, 0xaf, 0x3b, 0x23, 0xb5, 0x32, 0xed, 0x97, 0x0a, 0x93, 0xc9, 0x22, 0x3b, + 0xe7, 0xf4, 0x4b, 0xc5, 0xd9, 0x4c, 0xf7, 0x4b, 0x81, 0x70, 0x4c, 0xca, 0xfe, 0x81, 0x12, 0x9c, + 0x2b, 0xde, 0x6f, 0xb1, 0xf4, 0xb5, 0x16, 0x2b, 0x9d, 0x13, 0xd2, 0x57, 0xfe, 0x66, 0x8b, 0xb1, + 0xfa, 0x8e, 0xfa, 0x77, 0x05, 0xa6, 0x95, 0xaf, 0x47, 0xcb, 0x6d, 0xec, 0xaf, 0xc7, 0x2f, 0x5f, + 0xe5, 0x1f, 0x5f, 0x4f, 0x22, 0xe0, 0x74, 0x1d, 0xb4, 0x00, 0x93, 0x46, 0xe1, 0x6a, 0x55, 0xbc, + 0xcd, 0x94, 0xb8, 0xb7, 0x6e, 0x82, 0x71, 0x12, 0xdf, 0xfe, 0x92, 0x05, 0x8f, 0xe4, 0x64, 0x28, + 0xec, 0x3b, 0xa8, 0xdd, 0x16, 0x4c, 0x76, 0xcc, 0xaa, 0x3d, 0xe2, 0x70, 0x1a, 0x79, 0x10, 0x55, + 0x5f, 0x13, 0x00, 0x9c, 0x24, 0x6a, 0xff, 0x74, 0x09, 0xce, 0x16, 0x1a, 0x2f, 0x22, 0x0c, 0xa7, + 0xb7, 0xdb, 0xa1, 0xb3, 0x14, 0x90, 0x26, 0xf1, 0x22, 0xd7, 0x69, 0xd5, 0x3b, 0xa4, 0xa1, 0xc9, + 0xcf, 0x99, 0x15, 0xe0, 0x95, 0xb5, 0xfa, 0x42, 0x1a, 0x03, 0xe7, 0xd4, 0x44, 0x2b, 0x80, 0xd2, + 0x10, 0x31, 0xc3, 0x2c, 0x46, 0x78, 0x9a, 0x1e, 0xce, 0xa8, 0x81, 0x3e, 0x04, 0xe3, 0xca, 0x28, + 0x52, 0x9b, 0x71, 0x76, 0xb0, 0x63, 0x1d, 0x80, 0x4d, 0x3c, 0x74, 0x99, 0x07, 0x99, 0x17, 0xe9, + 0x08, 0x84, 0xb0, 0x7d, 0x52, 0x46, 0x90, 0x17, 0xc5, 0x58, 0xc7, 0x59, 0x7c, 0xe9, 0xd7, 0x7e, + 0xff, 0xdc, 0x7b, 0x7e, 0xf3, 0xf7, 0xcf, 0xbd, 0xe7, 0x77, 0x7e, 0xff, 0xdc, 0x7b, 0xbe, 0xeb, + 0xde, 0x39, 0xeb, 0xd7, 0xee, 0x9d, 0xb3, 0x7e, 0xf3, 0xde, 0x39, 0xeb, 0x77, 0xee, 0x9d, 0xb3, + 0x7e, 0xef, 0xde, 0x39, 0xeb, 0x0b, 0x7f, 0x70, 0xee, 0x3d, 0x9f, 0x40, 0x71, 0x98, 0xc8, 0x4b, + 0x74, 0x76, 0x2e, 0xed, 0x5d, 0xfe, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0x1b, 0x9e, 0xe7, 0x8d, + 0x05, 0x08, 0x01, 0x00, } func (m *AWSElasticBlockStoreVolumeSource) Marshal() (dAtA []byte, err error) { @@ -18901,6 +18902,11 @@ func (m *TopologySpreadConstraint) MarshalToSizedBuffer(dAtA []byte) (int, error _ = i var l int _ = l + if m.MinDomains != nil { + i = encodeVarintGenerated(dAtA, i, uint64(*m.MinDomains)) + i-- + dAtA[i] = 0x28 + } if m.LabelSelector != nil { { size, err := m.LabelSelector.MarshalToSizedBuffer(dAtA[:i]) @@ -24084,6 +24090,9 @@ func (m *TopologySpreadConstraint) Size() (n int) { l = m.LabelSelector.Size() n += 1 + l + sovGenerated(uint64(l)) } + if m.MinDomains != nil { + n += 1 + sovGenerated(uint64(*m.MinDomains)) + } return n } @@ -27671,6 +27680,7 @@ func (this *TopologySpreadConstraint) String() string { `TopologyKey:` + fmt.Sprintf("%v", this.TopologyKey) + `,`, `WhenUnsatisfiable:` + fmt.Sprintf("%v", this.WhenUnsatisfiable) + `,`, `LabelSelector:` + strings.Replace(fmt.Sprintf("%v", this.LabelSelector), "LabelSelector", "v1.LabelSelector", 1) + `,`, + `MinDomains:` + valueToStringGenerated(this.MinDomains) + `,`, `}`, }, "") return s @@ -65672,6 +65682,26 @@ func (m *TopologySpreadConstraint) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MinDomains", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.MinDomains = &v 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 456670fff1e..37ec3bcf319 100644 --- a/staging/src/k8s.io/api/core/v1/generated.proto +++ b/staging/src/k8s.io/api/core/v1/generated.proto @@ -5377,15 +5377,18 @@ message TopologySpreadConstraint { // MaxSkew describes the degree to which pods may be unevenly distributed. // When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference // between the number of matching pods in the target topology and the global minimum. + // The global minimum is the minimum number of matching pods in an eligible domain + // or zero if the number of eligible domains is less than MinDomains. // For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same - // labelSelector spread as 1/1/0: + // labelSelector spread as 2/2/1: + // In this case, the global minimum is 1. // +-------+-------+-------+ // | zone1 | zone2 | zone3 | // +-------+-------+-------+ - // | P | P | | + // | P P | P P | P | // +-------+-------+-------+ - // - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 1/1/1; - // scheduling it onto zone1(zone2) would make the ActualSkew(2-0) on zone1(zone2) + // - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; + // scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) // violate MaxSkew(1). // - if MaxSkew is 2, incoming pod can be scheduled onto any zone. // When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence @@ -5397,6 +5400,10 @@ message TopologySpreadConstraint { // and identical values are considered to be in the same topology. // We consider each as a "bucket", and try to put balanced number // of pods into each bucket. + // We define a domain as a particular instance of a topology. + // Also, we define an eligible domain as a domain whose nodes match the node selector. + // e.g. If TopologyKey is "kubernetes.io/hostname", each Node is a domain of that topology. + // And, if TopologyKey is "topology.kubernetes.io/zone", each zone is a domain of that topology. // It's a required field. optional string topologyKey = 2; @@ -5428,6 +5435,33 @@ message TopologySpreadConstraint { // in their corresponding topology domain. // +optional optional k8s.io.apimachinery.pkg.apis.meta.v1.LabelSelector labelSelector = 4; + + // MinDomains indicates a minimum number of eligible domains. + // When the number of eligible domains with matching topology keys is less than minDomains, + // Pod Topology Spread treats "global minimum" as 0, and then the calculation of Skew is performed. + // And when the number of eligible domains with matching topology keys equals or greater than minDomains, + // this value has no effect on scheduling. + // As a result, when the number of eligible domains is less than minDomains, + // scheduler won't schedule more than maxSkew Pods to those domains. + // If value is nil, the constraint behaves as if MinDomains is equal to 1. + // Valid values are integers greater than 0. + // When value is not nil, WhenUnsatisfiable must be DoNotSchedule. + // + // For example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same + // labelSelector spread as 2/2/2: + // +-------+-------+-------+ + // | zone1 | zone2 | zone3 | + // +-------+-------+-------+ + // | P P | P P | P P | + // +-------+-------+-------+ + // The number of domains is less than 5(MinDomains), so "global minimum" is treated as 0. + // In this situation, new pod with the same labelSelector cannot be scheduled, + // because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, + // it will violate MaxSkew. + // + // This is an alpha field and requires enabling MinDomainsInPodTopologySpread feature gate. + // +optional + optional int32 minDomains = 5; } // TypedLocalObjectReference contains enough information to let you locate the diff --git a/staging/src/k8s.io/api/core/v1/types.go b/staging/src/k8s.io/api/core/v1/types.go index 41dae3fba70..164a29d38cd 100644 --- a/staging/src/k8s.io/api/core/v1/types.go +++ b/staging/src/k8s.io/api/core/v1/types.go @@ -3339,15 +3339,18 @@ type TopologySpreadConstraint struct { // MaxSkew describes the degree to which pods may be unevenly distributed. // When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference // between the number of matching pods in the target topology and the global minimum. + // The global minimum is the minimum number of matching pods in an eligible domain + // or zero if the number of eligible domains is less than MinDomains. // For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same - // labelSelector spread as 1/1/0: + // labelSelector spread as 2/2/1: + // In this case, the global minimum is 1. // +-------+-------+-------+ // | zone1 | zone2 | zone3 | // +-------+-------+-------+ - // | P | P | | + // | P P | P P | P | // +-------+-------+-------+ - // - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 1/1/1; - // scheduling it onto zone1(zone2) would make the ActualSkew(2-0) on zone1(zone2) + // - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; + // scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) // violate MaxSkew(1). // - if MaxSkew is 2, incoming pod can be scheduled onto any zone. // When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence @@ -3358,6 +3361,10 @@ type TopologySpreadConstraint struct { // and identical values are considered to be in the same topology. // We consider each as a "bucket", and try to put balanced number // of pods into each bucket. + // We define a domain as a particular instance of a topology. + // Also, we define an eligible domain as a domain whose nodes match the node selector. + // e.g. If TopologyKey is "kubernetes.io/hostname", each Node is a domain of that topology. + // And, if TopologyKey is "topology.kubernetes.io/zone", each zone is a domain of that topology. // It's a required field. TopologyKey string `json:"topologyKey" protobuf:"bytes,2,opt,name=topologyKey"` // WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy @@ -3387,6 +3394,32 @@ type TopologySpreadConstraint struct { // in their corresponding topology domain. // +optional LabelSelector *metav1.LabelSelector `json:"labelSelector,omitempty" protobuf:"bytes,4,opt,name=labelSelector"` + // MinDomains indicates a minimum number of eligible domains. + // When the number of eligible domains with matching topology keys is less than minDomains, + // Pod Topology Spread treats "global minimum" as 0, and then the calculation of Skew is performed. + // And when the number of eligible domains with matching topology keys equals or greater than minDomains, + // this value has no effect on scheduling. + // As a result, when the number of eligible domains is less than minDomains, + // scheduler won't schedule more than maxSkew Pods to those domains. + // If value is nil, the constraint behaves as if MinDomains is equal to 1. + // Valid values are integers greater than 0. + // When value is not nil, WhenUnsatisfiable must be DoNotSchedule. + // + // For example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same + // labelSelector spread as 2/2/2: + // +-------+-------+-------+ + // | zone1 | zone2 | zone3 | + // +-------+-------+-------+ + // | P P | P P | P P | + // +-------+-------+-------+ + // The number of domains is less than 5(MinDomains), so "global minimum" is treated as 0. + // In this situation, new pod with the same labelSelector cannot be scheduled, + // because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, + // it will violate MaxSkew. + // + // This is an alpha field and requires enabling MinDomainsInPodTopologySpread feature gate. + // +optional + MinDomains *int32 `json:"minDomains,omitempty" protobuf:"varint,5,opt,name=minDomains"` } const ( diff --git a/staging/src/k8s.io/api/core/v1/types_swagger_doc_generated.go b/staging/src/k8s.io/api/core/v1/types_swagger_doc_generated.go index 125c37f2dff..d5e30c7ae80 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 @@ -2400,10 +2400,11 @@ func (TopologySelectorTerm) SwaggerDoc() map[string]string { var map_TopologySpreadConstraint = map[string]string{ "": "TopologySpreadConstraint specifies how to spread matching pods among the given topology.", - "maxSkew": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 1/1/0: ", - "topologyKey": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a \"bucket\", and try to put balanced number of pods into each bucket. It's a required field.", + "maxSkew": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. ", + "topologyKey": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a \"bucket\", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes match the node selector. e.g. If TopologyKey is \"kubernetes.io/hostname\", each Node is a domain of that topology. And, if TopologyKey is \"topology.kubernetes.io/zone\", each zone is a domain of that topology. It's a required field.", "whenUnsatisfiable": "WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location,\n but giving higher precedence to topologies that would help reduce the\n skew.\nA constraint is considered \"Unsatisfiable\" for an incoming pod if and only if every possible node assignment for that pod would violate \"MaxSkew\" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: ", "labelSelector": "LabelSelector is used to find matching pods. Pods that match this label selector are counted to determine the number of pods in their corresponding topology domain.", + "minDomains": "MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats \"global minimum\" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule.\n\nFor example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: ", } func (TopologySpreadConstraint) 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 fc951ad44d2..a3fbd14c6c5 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 @@ -5644,6 +5644,11 @@ func (in *TopologySpreadConstraint) DeepCopyInto(out *TopologySpreadConstraint) *out = new(metav1.LabelSelector) (*in).DeepCopyInto(*out) } + if in.MinDomains != nil { + in, out := &in.MinDomains, &out.MinDomains + *out = new(int32) + **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 d35a158f18b..9f1f46c633a 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 @@ -1616,7 +1616,8 @@ ] } ] - } + }, + "minDomains": 5 } ], "setHostnameAsFQDN": true, 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 27e8b3b678ef2a793e1f7b4a823e2c22b9fefdf5..630f4840309d6e13f9bf93eb538f0263a4d0ea19 100644 GIT binary patch delta 59 zcmbR2JJolBG}9NK&3;^Ej7%#%CvOn*XPW8(<}%LR9LxMmnz3ebgnSjd2J0lINjzMe NeI>rLPClo46aa9f6vY4l delta 57 zcmbR0JK1-FG}9-a&3;^Ej7-ZtCvOn*XPWE*<}%LS9LxMmnz3qfgnSk2B&JC`T$_C* LzOzogpn4PlPHz;B 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 1c2fd995c85..bae270f2a8b 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 @@ -849,6 +849,7 @@ spec: matchLabels: matchLabelsKey: matchLabelsValue maxSkew: 1 + minDomains: 5 topologyKey: topologyKeyValue whenUnsatisfiable: whenUnsatisfiableValue volumes: 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 c94b1eccc49..cfeb49ef3ab 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 @@ -1617,7 +1617,8 @@ ] } ] - } + }, + "minDomains": 5 } ], "setHostnameAsFQDN": true, 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 444f49528aa78f8de5e668d44385154ec36f27d6..acfdd47cb0535d63c2b581dfa5622920565caf3c 100644 GIT binary patch delta 62 zcmZ4ByU2Hf3{!*e=0L78M%MM79E?Jf6U6+Orh0%y80T(IVE!e|STi|VzKUIgbrRDg Q9bKYly4AWYl&4FBHjI6IbI2eT{Cy4nmP4xhaFwWha!2C;^v1W3#d=m;U0 QJY1UtB)+pwzNlIQ0F;#!#{d8T delta 60 zcmX@_bJk~q4AW|#&4FBHjI1v_I2eT{Cy4nmP4)nbFwWkb!2C;^v1)R(d=={?rb#?p On*$`ivrfLOS_1%a$`p_Q diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.yaml index e2a4dbd5162..b396f17dc6b 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.ReplicaSet.yaml @@ -849,6 +849,7 @@ spec: matchLabels: matchLabelsKey: matchLabelsValue maxSkew: 1 + minDomains: 5 topologyKey: topologyKeyValue whenUnsatisfiable: whenUnsatisfiableValue volumes: diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.json b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.json index 006116d6368..0813338ad43 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.json +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.json @@ -1617,7 +1617,8 @@ ] } ] - } + }, + "minDomains": 5 } ], "setHostnameAsFQDN": true, diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.pb b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.StatefulSet.pb index 071c0dae7ca6ae88195499038d9c90e4e13ead3b..e891201dc6b9cf202439bb5d5476bd034a115865 100644 GIT binary patch delta 61 zcmbOgGACq$EYr{6O=@L~tnC3Dj6#zW#r&A2dVmBN=Wb49{w2*=GdV`Sid}1UF`Wpd!lVBfu L0w@Ku+8@sb1^N=< delta 50 zcmV-20L}laO{q<{9 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 6d8ba092119..84a687040ac 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 @@ -855,6 +855,7 @@ spec: matchLabels: matchLabelsKey: matchLabelsValue maxSkew: 1 + minDomains: 5 topologyKey: topologyKeyValue whenUnsatisfiable: whenUnsatisfiableValue volumes: 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 682f53035d2..4c360f0aa84 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 @@ -1616,7 +1616,8 @@ ] } ] - } + }, + "minDomains": 5 } ], "setHostnameAsFQDN": true, 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 f5a81a24580430847170ccec2f63c2f1359c0649..a3c1563e5dba2db0d9600b1c893ca237a74433a5 100644 GIT binary patch delta 47 zcmV+~0MP%KO`1)RAOZBTA$I`+sY#RY6;A<`v+4nN0Rf$}Vgvdc0eq8PA9?~P1+&*5 F!3MaT5widQ delta 44 zcmV+{0Mq}PO_)uPAOZ5RA$I`+r%99W6;A<^v+4nN0Rfw{Vgvdc0eX{NA9}OdAHfER CI1zjR 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 2340df31ccf..861d08eeac4 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 @@ -849,6 +849,7 @@ spec: matchLabels: matchLabelsKey: matchLabelsValue maxSkew: 1 + minDomains: 5 topologyKey: topologyKeyValue whenUnsatisfiable: whenUnsatisfiableValue volumes: 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 bebfd6578e1..b1831120f14 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 @@ -1617,7 +1617,8 @@ ] } ] - } + }, + "minDomains": 5 } ], "setHostnameAsFQDN": true, 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 8b2c0518714658866fcffbedae0e4be4b30ae6b3..da76750ec182828fecbf20f246850747e5780e84 100644 GIT binary patch delta 53 zcmV-50LuTRO{YzeAp(F+v+eF`Wpd!lVBfu L0w@Ku+8@gX0|FAw delta 50 zcmV-20L}lWO{GncAp-tPv+e$}Ap)&Tv+eF`Wpd!lVBfu L0w@Ku+8=lZB*YUq delta 50 zcmV-20L}l@Owvq{Ap)yRv+e<{9 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 5bd1c961897..ae1725c873b 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 @@ -855,6 +855,7 @@ spec: matchLabels: matchLabelsKey: matchLabelsValue maxSkew: 1 + minDomains: 5 topologyKey: topologyKeyValue whenUnsatisfiable: whenUnsatisfiableValue volumes: 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 c5bf8aeb1c9..22d420b04a0 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 @@ -1670,7 +1670,8 @@ ] } ] - } + }, + "minDomains": 5 } ], "setHostnameAsFQDN": true, 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 69ae7d44c8f95e0c9387ad71c59bb5dc598dc724..6e66596e9932a2ad45ba84177a646d79b8067d92 100644 GIT binary patch delta 69 zcmX>Ra4KMe6yvIm(&dbdnVa3WxW6yu7G(&dbd8z)a@)Mfhby-}u&k)z#{gHeD;&4FBHjEtR=`xzscrg}hlb2le2|B_~`nH()&#je3RiD?oK*X96; L@2rzAs=fdKQnM6R delta 56 zcmdn(yVG}q7}H$e&4FBHjEwD*`xzscCVN15vo|L&|B_~`nj9@(#X5;;5)aqr0EzFc JlP{~j001$v6dwQp diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.yaml b/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.yaml index 2b0fe8aa983..64fd5a7a0fa 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/batch.v1.Job.yaml @@ -854,6 +854,7 @@ spec: matchLabels: matchLabelsKey: matchLabelsValue maxSkew: 1 + minDomains: 5 topologyKey: topologyKeyValue whenUnsatisfiable: whenUnsatisfiableValue volumes: diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.json b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.json index c7d65a5c4fd..636c0be56e0 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.json +++ b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.json @@ -1670,7 +1670,8 @@ ] } ] - } + }, + "minDomains": 5 } ], "setHostnameAsFQDN": true, diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.pb b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.pb index 73ee3edba10f784266a47cd04db0a56b392e63db..75e60016dcbf47c44ea42d05e89420d627e160bf 100644 GIT binary patch delta 68 zcmX>ba6VvyJmad33gwK9n>8|-m?rUXZT>I$opo}9`dI)c{})gI delta 66 zcmX>fa5i9qJmZRu3gwK98z;|T)Mfhby-~4@k+FTU9diWJWDhWB_GW(8U($?KlerYD USSK+};^Er-U-CQa!!NrHKDfutXc2BXo`&AH6wjEr+PKV|tP T%~&(}fkG9N2J7Z1MK?A8y+agj delta 63 zcmZ4FzrcTjGShdz&3Vjaj74MwBMn{%1V85w79e#-Jo Qnz3r~1BI&1F^X<%0GbFCvj6}9 diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.yaml b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.yaml index fa8298b395b..462c073e8d6 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.JobTemplate.yaml @@ -888,6 +888,7 @@ template: matchLabels: matchLabelsKey: matchLabelsValue maxSkew: 1 + minDomains: 5 topologyKey: topologyKeyValue whenUnsatisfiable: whenUnsatisfiableValue volumes: diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.json b/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.json index 52abc5a9421..1445affa21f 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.json +++ b/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.json @@ -1557,7 +1557,8 @@ ] } ] - } + }, + "minDomains": 5 } ], "setHostnameAsFQDN": true, diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.pb b/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.pb index d60a04186dd6d8faa553ad153d192688b1f8d201..ca99ee9d6b383148c91612038f0a25b1f8945f74 100644 GIT binary patch delta 47 zcmcZ`a6dpW+oG6(i<66~%ut9qAU{Ru Dk=YQx 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 96a3955f097..31bd740caa6 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 @@ -843,6 +843,7 @@ spec: matchLabels: matchLabelsKey: matchLabelsValue maxSkew: 1 + minDomains: 5 topologyKey: topologyKeyValue whenUnsatisfiable: whenUnsatisfiableValue volumes: 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 36ad5fb4d70..d8dbe95decf 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 @@ -1616,7 +1616,8 @@ ] } ] - } + }, + "minDomains": 5 } ], "setHostnameAsFQDN": true, 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 f2d44d5598fe64e842028c60d1c99b69bb8dfd7b..8caf81d6db32a6be44fd82403f7562053b2dc7ca 100644 GIT binary patch delta 48 zcmV-00MGxRO`=VZCIa?Mv+)6T0RgL%p8-$-m9y{xcL4#NvuFeQ8v%TiV;_0~CYyj0Q B5w8FM delta 56 zcmccRbHitXI@4;O%`seMjEpZPFJKH}n(P7L&EA~N{7ag#YI2%<73(CXNjzMeqb0tx JPQIsF0{~k46uSTb 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 2762f4a95fd..50082cdc175 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 @@ -849,6 +849,7 @@ spec: matchLabels: matchLabelsKey: matchLabelsValue maxSkew: 1 + minDomains: 5 topologyKey: topologyKeyValue whenUnsatisfiable: whenUnsatisfiableValue volumes: diff --git a/staging/src/k8s.io/client-go/applyconfigurations/core/v1/topologyspreadconstraint.go b/staging/src/k8s.io/client-go/applyconfigurations/core/v1/topologyspreadconstraint.go index ac8b82eead8..867cc89f20c 100644 --- a/staging/src/k8s.io/client-go/applyconfigurations/core/v1/topologyspreadconstraint.go +++ b/staging/src/k8s.io/client-go/applyconfigurations/core/v1/topologyspreadconstraint.go @@ -30,6 +30,7 @@ type TopologySpreadConstraintApplyConfiguration struct { TopologyKey *string `json:"topologyKey,omitempty"` WhenUnsatisfiable *v1.UnsatisfiableConstraintAction `json:"whenUnsatisfiable,omitempty"` LabelSelector *metav1.LabelSelectorApplyConfiguration `json:"labelSelector,omitempty"` + MinDomains *int32 `json:"minDomains,omitempty"` } // TopologySpreadConstraintApplyConfiguration constructs an declarative configuration of the TopologySpreadConstraint type for use with @@ -69,3 +70,11 @@ func (b *TopologySpreadConstraintApplyConfiguration) WithLabelSelector(value *me b.LabelSelector = value return b } + +// WithMinDomains sets the MinDomains 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 MinDomains field is set to the value of the last call. +func (b *TopologySpreadConstraintApplyConfiguration) WithMinDomains(value int32) *TopologySpreadConstraintApplyConfiguration { + b.MinDomains = &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 824c5e9582e..e17502d3485 100644 --- a/staging/src/k8s.io/client-go/applyconfigurations/internal/internal.go +++ b/staging/src/k8s.io/client-go/applyconfigurations/internal/internal.go @@ -6844,6 +6844,9 @@ var schemaYAML = typed.YAMLObject(`types: type: scalar: numeric default: 0 + - name: minDomains + type: + scalar: numeric - name: topologyKey type: scalar: string