From af595a44aefcbf01dfad82c40af2e97346c938d9 Mon Sep 17 00:00:00 2001 From: Yuan Wang Date: Tue, 1 Jul 2025 02:33:00 +0000 Subject: [PATCH] Add container restart rules to API --- api/openapi-spec/swagger.json | 59 +- api/openapi-spec/v3/api__v1_openapi.json | 74 +- .../v3/apis__apps__v1_openapi.json | 74 +- .../v3/apis__batch__v1_openapi.json | 74 +- pkg/api/pod/util.go | 47 + pkg/api/pod/util_test.go | 205 ++ pkg/api/v1/pod/util.go | 87 + pkg/api/v1/pod/util_test.go | 327 ++ pkg/apis/core/types.go | 102 +- pkg/apis/core/v1/zz_generated.conversion.go | 68 + pkg/apis/core/validation/validation.go | 146 +- pkg/apis/core/validation/validation_test.go | 382 ++- pkg/apis/core/zz_generated.deepcopy.go | 56 + pkg/features/kube_features.go | 11 + pkg/generated/openapi/zz_generated.openapi.go | 141 +- .../src/k8s.io/api/core/v1/generated.pb.go | 3050 ++++++++++------- .../src/k8s.io/api/core/v1/generated.proto | 66 +- staging/src/k8s.io/api/core/v1/types.go | 88 +- .../core/v1/types_swagger_doc_generated.go | 26 +- .../api/core/v1/zz_generated.deepcopy.go | 56 + .../api/testdata/HEAD/apps.v1.DaemonSet.json | 33 + .../api/testdata/HEAD/apps.v1.DaemonSet.pb | Bin 11310 -> 11415 bytes .../api/testdata/HEAD/apps.v1.DaemonSet.yaml | 18 + .../api/testdata/HEAD/apps.v1.Deployment.json | 33 + .../api/testdata/HEAD/apps.v1.Deployment.pb | Bin 11325 -> 11430 bytes .../api/testdata/HEAD/apps.v1.Deployment.yaml | 18 + .../api/testdata/HEAD/apps.v1.ReplicaSet.json | 33 + .../api/testdata/HEAD/apps.v1.ReplicaSet.pb | Bin 11242 -> 11347 bytes .../api/testdata/HEAD/apps.v1.ReplicaSet.yaml | 18 + .../testdata/HEAD/apps.v1.StatefulSet.json | 33 + .../api/testdata/HEAD/apps.v1.StatefulSet.pb | Bin 12411 -> 12516 bytes .../testdata/HEAD/apps.v1.StatefulSet.yaml | 18 + .../HEAD/apps.v1beta1.Deployment.json | 33 + .../testdata/HEAD/apps.v1beta1.Deployment.pb | Bin 11334 -> 11439 bytes .../HEAD/apps.v1beta1.Deployment.yaml | 18 + .../HEAD/apps.v1beta1.StatefulSet.json | 33 + .../testdata/HEAD/apps.v1beta1.StatefulSet.pb | Bin 12416 -> 12521 bytes .../HEAD/apps.v1beta1.StatefulSet.yaml | 18 + .../testdata/HEAD/apps.v1beta2.DaemonSet.json | 33 + .../testdata/HEAD/apps.v1beta2.DaemonSet.pb | Bin 11315 -> 11420 bytes .../testdata/HEAD/apps.v1beta2.DaemonSet.yaml | 18 + .../HEAD/apps.v1beta2.Deployment.json | 33 + .../testdata/HEAD/apps.v1beta2.Deployment.pb | Bin 11330 -> 11435 bytes .../HEAD/apps.v1beta2.Deployment.yaml | 18 + .../HEAD/apps.v1beta2.ReplicaSet.json | 33 + .../testdata/HEAD/apps.v1beta2.ReplicaSet.pb | Bin 11247 -> 11352 bytes .../HEAD/apps.v1beta2.ReplicaSet.yaml | 18 + .../HEAD/apps.v1beta2.StatefulSet.json | 33 + .../testdata/HEAD/apps.v1beta2.StatefulSet.pb | Bin 12416 -> 12521 bytes .../HEAD/apps.v1beta2.StatefulSet.yaml | 18 + .../api/testdata/HEAD/batch.v1.CronJob.json | 33 + .../api/testdata/HEAD/batch.v1.CronJob.pb | Bin 11903 -> 12008 bytes .../api/testdata/HEAD/batch.v1.CronJob.yaml | 18 + .../api/testdata/HEAD/batch.v1.Job.json | 33 + .../k8s.io/api/testdata/HEAD/batch.v1.Job.pb | Bin 11529 -> 11634 bytes .../api/testdata/HEAD/batch.v1.Job.yaml | 18 + .../testdata/HEAD/batch.v1beta1.CronJob.json | 33 + .../testdata/HEAD/batch.v1beta1.CronJob.pb | Bin 11908 -> 12013 bytes .../testdata/HEAD/batch.v1beta1.CronJob.yaml | 18 + .../k8s.io/api/testdata/HEAD/core.v1.Pod.json | 33 + .../k8s.io/api/testdata/HEAD/core.v1.Pod.pb | Bin 12525 -> 12630 bytes .../k8s.io/api/testdata/HEAD/core.v1.Pod.yaml | 18 + .../testdata/HEAD/core.v1.PodTemplate.json | 33 + .../api/testdata/HEAD/core.v1.PodTemplate.pb | Bin 11076 -> 11181 bytes .../testdata/HEAD/core.v1.PodTemplate.yaml | 18 + .../HEAD/core.v1.ReplicationController.json | 33 + .../HEAD/core.v1.ReplicationController.pb | Bin 11198 -> 11303 bytes .../HEAD/core.v1.ReplicationController.yaml | 18 + .../HEAD/extensions.v1beta1.DaemonSet.json | 33 + .../HEAD/extensions.v1beta1.DaemonSet.pb | Bin 11323 -> 11428 bytes .../HEAD/extensions.v1beta1.DaemonSet.yaml | 18 + .../HEAD/extensions.v1beta1.Deployment.json | 33 + .../HEAD/extensions.v1beta1.Deployment.pb | Bin 11340 -> 11445 bytes .../HEAD/extensions.v1beta1.Deployment.yaml | 18 + .../HEAD/extensions.v1beta1.ReplicaSet.json | 33 + .../HEAD/extensions.v1beta1.ReplicaSet.pb | Bin 11253 -> 11358 bytes .../HEAD/extensions.v1beta1.ReplicaSet.yaml | 18 + .../applyconfigurations/core/v1/container.go | 14 + .../core/v1/containerrestartrule.go | 52 + .../v1/containerrestartruleonexitcodes.go | 54 + .../core/v1/ephemeralcontainer.go | 13 + .../core/v1/ephemeralcontainercommon.go | 14 + .../applyconfigurations/internal/internal.go | 33 + .../client-go/applyconfigurations/utils.go | 4 + .../reference/versioned_feature_list.yaml | 6 + 85 files changed, 5017 insertions(+), 1281 deletions(-) create mode 100644 staging/src/k8s.io/client-go/applyconfigurations/core/v1/containerrestartrule.go create mode 100644 staging/src/k8s.io/client-go/applyconfigurations/core/v1/containerrestartruleonexitcodes.go diff --git a/api/openapi-spec/swagger.json b/api/openapi-spec/swagger.json index 3f135fd3149..f508c7b0d44 100644 --- a/api/openapi-spec/swagger.json +++ b/api/openapi-spec/swagger.json @@ -6529,9 +6529,17 @@ "description": "Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/" }, "restartPolicy": { - "description": "RestartPolicy defines the restart behavior of individual containers in a pod. This field may only be set for init containers, and the only allowed value is \"Always\". For non-init containers or when this field is not specified, the restart behavior is defined by the Pod's restart policy and the container type. Setting the RestartPolicy as \"Always\" for the init container will have the following effect: this init container will be continually restarted on exit until all regular containers have terminated. Once all regular containers have completed, all init containers with restartPolicy \"Always\" will be shut down. This lifecycle differs from normal init containers and is often referred to as a \"sidecar\" container. Although this init container still starts in the init container sequence, it does not wait for the container to complete before proceeding to the next init container. Instead, the next init container starts immediately after this init container is started, or after any startupProbe has successfully completed.", + "description": "RestartPolicy defines the restart behavior of individual containers in a pod. This overrides the pod-level restart policy. When this field is not specified, the restart behavior is defined by the Pod's restart policy and the container type. Additionally, setting the RestartPolicy as \"Always\" for the init container will have the following effect: this init container will be continually restarted on exit until all regular containers have terminated. Once all regular containers have completed, all init containers with restartPolicy \"Always\" will be shut down. This lifecycle differs from normal init containers and is often referred to as a \"sidecar\" container. Although this init container still starts in the init container sequence, it does not wait for the container to complete before proceeding to the next init container. Instead, the next init container starts immediately after this init container is started, or after any startupProbe has successfully completed.", "type": "string" }, + "restartPolicyRules": { + "description": "Represents a list of rules to be checked to determine if the container should be restarted on exit. The rules are evaluated in order. Once a rule matches a container exit condition, the remaining rules are ignored. If no rule matches the container exit condition, the Container-level restart policy determines the whether the container is restarted or not. Constraints on the rules: - At most 20 rules are allowed. - Rules can have the same action. - Identical rules are not forbidden in validations. When rules are specified, container MUST set RestartPolicy explicitly even it if matches the Pod's RestartPolicy.", + "items": { + "$ref": "#/definitions/io.k8s.api.core.v1.ContainerRestartRule" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, "securityContext": { "$ref": "#/definitions/io.k8s.api.core.v1.SecurityContext", "description": "SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/" @@ -6664,6 +6672,45 @@ ], "type": "object" }, + "io.k8s.api.core.v1.ContainerRestartRule": { + "description": "ContainerRestartRule describes how a container exit is handled.", + "properties": { + "action": { + "description": "Specifies the action taken on a container exit if the requirements are satisfied. The only possible value is \"Restart\" to restart the container.", + "type": "string" + }, + "exitCodes": { + "$ref": "#/definitions/io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes", + "description": "Represents the exit codes to check on container exits." + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes": { + "description": "ContainerRestartRuleOnExitCodes describes the condition for handling an exited container based on its exit codes.", + "properties": { + "operator": { + "description": "Represents the relationship between the container exit code(s) and the specified values. Possible values are: - In: the requirement is satisfied if the container exit code is in the\n set of specified values.\n- NotIn: the requirement is satisfied if the container exit code is\n not in the set of specified values.", + "type": "string" + }, + "values": { + "description": "Specifies the set of values to check for container exit codes. At most 255 elements are allowed.", + "items": { + "format": "int32", + "type": "integer" + }, + "type": "array", + "x-kubernetes-list-type": "set" + } + }, + "required": [ + "operator" + ], + "type": "object" + }, "io.k8s.api.core.v1.ContainerState": { "description": "ContainerState holds a possible state of container. Only one of its members may be specified. If none of them is specified, the default one is ContainerStateWaiting.", "properties": { @@ -7244,9 +7291,17 @@ "description": "Resources are not allowed for ephemeral containers. Ephemeral containers use spare resources already allocated to the pod." }, "restartPolicy": { - "description": "Restart policy for the container to manage the restart behavior of each container within a pod. This may only be set for init containers. You cannot set this field on ephemeral containers.", + "description": "Restart policy for the container to manage the restart behavior of each container within a pod. You cannot set this field on ephemeral containers.", "type": "string" }, + "restartPolicyRules": { + "description": "Represents a list of rules to be checked to determine if the container should be restarted on exit. You cannot set this field on ephemeral containers.", + "items": { + "$ref": "#/definitions/io.k8s.api.core.v1.ContainerRestartRule" + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, "securityContext": { "$ref": "#/definitions/io.k8s.api.core.v1.SecurityContext", "description": "Optional: SecurityContext defines the security options the ephemeral container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext." diff --git a/api/openapi-spec/v3/api__v1_openapi.json b/api/openapi-spec/v3/api__v1_openapi.json index 43415059e37..e1a70575ee4 100644 --- a/api/openapi-spec/v3/api__v1_openapi.json +++ b/api/openapi-spec/v3/api__v1_openapi.json @@ -1252,9 +1252,22 @@ "description": "Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/" }, "restartPolicy": { - "description": "RestartPolicy defines the restart behavior of individual containers in a pod. This field may only be set for init containers, and the only allowed value is \"Always\". For non-init containers or when this field is not specified, the restart behavior is defined by the Pod's restart policy and the container type. Setting the RestartPolicy as \"Always\" for the init container will have the following effect: this init container will be continually restarted on exit until all regular containers have terminated. Once all regular containers have completed, all init containers with restartPolicy \"Always\" will be shut down. This lifecycle differs from normal init containers and is often referred to as a \"sidecar\" container. Although this init container still starts in the init container sequence, it does not wait for the container to complete before proceeding to the next init container. Instead, the next init container starts immediately after this init container is started, or after any startupProbe has successfully completed.", + "description": "RestartPolicy defines the restart behavior of individual containers in a pod. This overrides the pod-level restart policy. When this field is not specified, the restart behavior is defined by the Pod's restart policy and the container type. Additionally, setting the RestartPolicy as \"Always\" for the init container will have the following effect: this init container will be continually restarted on exit until all regular containers have terminated. Once all regular containers have completed, all init containers with restartPolicy \"Always\" will be shut down. This lifecycle differs from normal init containers and is often referred to as a \"sidecar\" container. Although this init container still starts in the init container sequence, it does not wait for the container to complete before proceeding to the next init container. Instead, the next init container starts immediately after this init container is started, or after any startupProbe has successfully completed.", "type": "string" }, + "restartPolicyRules": { + "description": "Represents a list of rules to be checked to determine if the container should be restarted on exit. The rules are evaluated in order. Once a rule matches a container exit condition, the remaining rules are ignored. If no rule matches the container exit condition, the Container-level restart policy determines the whether the container is restarted or not. Constraints on the rules: - At most 20 rules are allowed. - Rules can have the same action. - Identical rules are not forbidden in validations. When rules are specified, container MUST set RestartPolicy explicitly even it if matches the Pod's RestartPolicy.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRule" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, "securityContext": { "allOf": [ { @@ -1410,6 +1423,50 @@ ], "type": "object" }, + "io.k8s.api.core.v1.ContainerRestartRule": { + "description": "ContainerRestartRule describes how a container exit is handled.", + "properties": { + "action": { + "description": "Specifies the action taken on a container exit if the requirements are satisfied. The only possible value is \"Restart\" to restart the container.", + "type": "string" + }, + "exitCodes": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes" + } + ], + "description": "Represents the exit codes to check on container exits." + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes": { + "description": "ContainerRestartRuleOnExitCodes describes the condition for handling an exited container based on its exit codes.", + "properties": { + "operator": { + "description": "Represents the relationship between the container exit code(s) and the specified values. Possible values are: - In: the requirement is satisfied if the container exit code is in the\n set of specified values.\n- NotIn: the requirement is satisfied if the container exit code is\n not in the set of specified values.", + "type": "string" + }, + "values": { + "description": "Specifies the set of values to check for container exit codes. At most 255 elements are allowed.", + "items": { + "default": 0, + "format": "int32", + "type": "integer" + }, + "type": "array", + "x-kubernetes-list-type": "set" + } + }, + "required": [ + "operator" + ], + "type": "object" + }, "io.k8s.api.core.v1.ContainerState": { "description": "ContainerState holds a possible state of container. Only one of its members may be specified. If none of them is specified, the default one is ContainerStateWaiting.", "properties": { @@ -2190,9 +2247,22 @@ "description": "Resources are not allowed for ephemeral containers. Ephemeral containers use spare resources already allocated to the pod." }, "restartPolicy": { - "description": "Restart policy for the container to manage the restart behavior of each container within a pod. This may only be set for init containers. You cannot set this field on ephemeral containers.", + "description": "Restart policy for the container to manage the restart behavior of each container within a pod. You cannot set this field on ephemeral containers.", "type": "string" }, + "restartPolicyRules": { + "description": "Represents a list of rules to be checked to determine if the container should be restarted on exit. You cannot set this field on ephemeral containers.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRule" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, "securityContext": { "allOf": [ { diff --git a/api/openapi-spec/v3/apis__apps__v1_openapi.json b/api/openapi-spec/v3/apis__apps__v1_openapi.json index 98c90805f1f..38150b94d1c 100644 --- a/api/openapi-spec/v3/apis__apps__v1_openapi.json +++ b/api/openapi-spec/v3/apis__apps__v1_openapi.json @@ -1890,9 +1890,22 @@ "description": "Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/" }, "restartPolicy": { - "description": "RestartPolicy defines the restart behavior of individual containers in a pod. This field may only be set for init containers, and the only allowed value is \"Always\". For non-init containers or when this field is not specified, the restart behavior is defined by the Pod's restart policy and the container type. Setting the RestartPolicy as \"Always\" for the init container will have the following effect: this init container will be continually restarted on exit until all regular containers have terminated. Once all regular containers have completed, all init containers with restartPolicy \"Always\" will be shut down. This lifecycle differs from normal init containers and is often referred to as a \"sidecar\" container. Although this init container still starts in the init container sequence, it does not wait for the container to complete before proceeding to the next init container. Instead, the next init container starts immediately after this init container is started, or after any startupProbe has successfully completed.", + "description": "RestartPolicy defines the restart behavior of individual containers in a pod. This overrides the pod-level restart policy. When this field is not specified, the restart behavior is defined by the Pod's restart policy and the container type. Additionally, setting the RestartPolicy as \"Always\" for the init container will have the following effect: this init container will be continually restarted on exit until all regular containers have terminated. Once all regular containers have completed, all init containers with restartPolicy \"Always\" will be shut down. This lifecycle differs from normal init containers and is often referred to as a \"sidecar\" container. Although this init container still starts in the init container sequence, it does not wait for the container to complete before proceeding to the next init container. Instead, the next init container starts immediately after this init container is started, or after any startupProbe has successfully completed.", "type": "string" }, + "restartPolicyRules": { + "description": "Represents a list of rules to be checked to determine if the container should be restarted on exit. The rules are evaluated in order. Once a rule matches a container exit condition, the remaining rules are ignored. If no rule matches the container exit condition, the Container-level restart policy determines the whether the container is restarted or not. Constraints on the rules: - At most 20 rules are allowed. - Rules can have the same action. - Identical rules are not forbidden in validations. When rules are specified, container MUST set RestartPolicy explicitly even it if matches the Pod's RestartPolicy.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRule" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, "securityContext": { "allOf": [ { @@ -2028,6 +2041,50 @@ ], "type": "object" }, + "io.k8s.api.core.v1.ContainerRestartRule": { + "description": "ContainerRestartRule describes how a container exit is handled.", + "properties": { + "action": { + "description": "Specifies the action taken on a container exit if the requirements are satisfied. The only possible value is \"Restart\" to restart the container.", + "type": "string" + }, + "exitCodes": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes" + } + ], + "description": "Represents the exit codes to check on container exits." + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes": { + "description": "ContainerRestartRuleOnExitCodes describes the condition for handling an exited container based on its exit codes.", + "properties": { + "operator": { + "description": "Represents the relationship between the container exit code(s) and the specified values. Possible values are: - In: the requirement is satisfied if the container exit code is in the\n set of specified values.\n- NotIn: the requirement is satisfied if the container exit code is\n not in the set of specified values.", + "type": "string" + }, + "values": { + "description": "Specifies the set of values to check for container exit codes. At most 255 elements are allowed.", + "items": { + "default": 0, + "format": "int32", + "type": "integer" + }, + "type": "array", + "x-kubernetes-list-type": "set" + } + }, + "required": [ + "operator" + ], + "type": "object" + }, "io.k8s.api.core.v1.DownwardAPIProjection": { "description": "Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.", "properties": { @@ -2353,9 +2410,22 @@ "description": "Resources are not allowed for ephemeral containers. Ephemeral containers use spare resources already allocated to the pod." }, "restartPolicy": { - "description": "Restart policy for the container to manage the restart behavior of each container within a pod. This may only be set for init containers. You cannot set this field on ephemeral containers.", + "description": "Restart policy for the container to manage the restart behavior of each container within a pod. You cannot set this field on ephemeral containers.", "type": "string" }, + "restartPolicyRules": { + "description": "Represents a list of rules to be checked to determine if the container should be restarted on exit. You cannot set this field on ephemeral containers.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRule" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, "securityContext": { "allOf": [ { diff --git a/api/openapi-spec/v3/apis__batch__v1_openapi.json b/api/openapi-spec/v3/apis__batch__v1_openapi.json index 95e0848d129..7b74a3d83ed 100644 --- a/api/openapi-spec/v3/apis__batch__v1_openapi.json +++ b/api/openapi-spec/v3/apis__batch__v1_openapi.json @@ -1229,9 +1229,22 @@ "description": "Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/" }, "restartPolicy": { - "description": "RestartPolicy defines the restart behavior of individual containers in a pod. This field may only be set for init containers, and the only allowed value is \"Always\". For non-init containers or when this field is not specified, the restart behavior is defined by the Pod's restart policy and the container type. Setting the RestartPolicy as \"Always\" for the init container will have the following effect: this init container will be continually restarted on exit until all regular containers have terminated. Once all regular containers have completed, all init containers with restartPolicy \"Always\" will be shut down. This lifecycle differs from normal init containers and is often referred to as a \"sidecar\" container. Although this init container still starts in the init container sequence, it does not wait for the container to complete before proceeding to the next init container. Instead, the next init container starts immediately after this init container is started, or after any startupProbe has successfully completed.", + "description": "RestartPolicy defines the restart behavior of individual containers in a pod. This overrides the pod-level restart policy. When this field is not specified, the restart behavior is defined by the Pod's restart policy and the container type. Additionally, setting the RestartPolicy as \"Always\" for the init container will have the following effect: this init container will be continually restarted on exit until all regular containers have terminated. Once all regular containers have completed, all init containers with restartPolicy \"Always\" will be shut down. This lifecycle differs from normal init containers and is often referred to as a \"sidecar\" container. Although this init container still starts in the init container sequence, it does not wait for the container to complete before proceeding to the next init container. Instead, the next init container starts immediately after this init container is started, or after any startupProbe has successfully completed.", "type": "string" }, + "restartPolicyRules": { + "description": "Represents a list of rules to be checked to determine if the container should be restarted on exit. The rules are evaluated in order. Once a rule matches a container exit condition, the remaining rules are ignored. If no rule matches the container exit condition, the Container-level restart policy determines the whether the container is restarted or not. Constraints on the rules: - At most 20 rules are allowed. - Rules can have the same action. - Identical rules are not forbidden in validations. When rules are specified, container MUST set RestartPolicy explicitly even it if matches the Pod's RestartPolicy.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRule" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, "securityContext": { "allOf": [ { @@ -1367,6 +1380,50 @@ ], "type": "object" }, + "io.k8s.api.core.v1.ContainerRestartRule": { + "description": "ContainerRestartRule describes how a container exit is handled.", + "properties": { + "action": { + "description": "Specifies the action taken on a container exit if the requirements are satisfied. The only possible value is \"Restart\" to restart the container.", + "type": "string" + }, + "exitCodes": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes" + } + ], + "description": "Represents the exit codes to check on container exits." + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes": { + "description": "ContainerRestartRuleOnExitCodes describes the condition for handling an exited container based on its exit codes.", + "properties": { + "operator": { + "description": "Represents the relationship between the container exit code(s) and the specified values. Possible values are: - In: the requirement is satisfied if the container exit code is in the\n set of specified values.\n- NotIn: the requirement is satisfied if the container exit code is\n not in the set of specified values.", + "type": "string" + }, + "values": { + "description": "Specifies the set of values to check for container exit codes. At most 255 elements are allowed.", + "items": { + "default": 0, + "format": "int32", + "type": "integer" + }, + "type": "array", + "x-kubernetes-list-type": "set" + } + }, + "required": [ + "operator" + ], + "type": "object" + }, "io.k8s.api.core.v1.DownwardAPIProjection": { "description": "Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.", "properties": { @@ -1692,9 +1749,22 @@ "description": "Resources are not allowed for ephemeral containers. Ephemeral containers use spare resources already allocated to the pod." }, "restartPolicy": { - "description": "Restart policy for the container to manage the restart behavior of each container within a pod. This may only be set for init containers. You cannot set this field on ephemeral containers.", + "description": "Restart policy for the container to manage the restart behavior of each container within a pod. You cannot set this field on ephemeral containers.", "type": "string" }, + "restartPolicyRules": { + "description": "Represents a list of rules to be checked to determine if the container should be restarted on exit. You cannot set this field on ephemeral containers.", + "items": { + "allOf": [ + { + "$ref": "#/components/schemas/io.k8s.api.core.v1.ContainerRestartRule" + } + ], + "default": {} + }, + "type": "array", + "x-kubernetes-list-type": "atomic" + }, "securityContext": { "allOf": [ { diff --git a/pkg/api/pod/util.go b/pkg/api/pod/util.go index 81d81932e05..215b1dafbaa 100644 --- a/pkg/api/pod/util.go +++ b/pkg/api/pod/util.go @@ -426,6 +426,7 @@ func GetValidationOptionsFromPodSpecAndMeta(podSpec, oldPodSpec *api.PodSpec, po AllowMatchLabelKeysInPodTopologySpreadSelectorMerge: utilfeature.DefaultFeatureGate.Enabled(features.MatchLabelKeysInPodTopologySpreadSelectorMerge), OldPodViolatesMatchLabelKeysValidation: false, OldPodViolatesLegacyMatchLabelKeysValidation: false, + AllowContainerRestartPolicyRules: utilfeature.DefaultFeatureGate.Enabled(features.ContainerRestartRules), } // If old spec uses relaxed validation or enabled the RelaxedEnvironmentVariableValidation feature gate, @@ -470,6 +471,8 @@ func GetValidationOptionsFromPodSpecAndMeta(podSpec, oldPodSpec *api.PodSpec, po opts.AllowPodLifecycleSleepActionZeroValue = opts.AllowPodLifecycleSleepActionZeroValue || podLifecycleSleepActionZeroValueInUse(oldPodSpec) // If oldPod has resize policy set on the restartable init container, we must allow it opts.AllowSidecarResizePolicy = opts.AllowSidecarResizePolicy || hasRestartableInitContainerResizePolicy(oldPodSpec) + + opts.AllowContainerRestartPolicyRules = opts.AllowContainerRestartPolicyRules || containerRestartRulesInUse(oldPodSpec) } if oldPodMeta != nil && !opts.AllowInvalidPodDeletionCost { // This is an update, so validate only if the existing object was valid. @@ -746,6 +749,10 @@ func dropDisabledFields( // For other types of containers, validateContainers will handle them. } + if !utilfeature.DefaultFeatureGate.Enabled(features.ContainerRestartRules) && !containerRestartRulesInUse(oldPodSpec) { + dropContainerRestartRules(podSpec) + } + if !utilfeature.DefaultFeatureGate.Enabled(features.RecursiveReadOnlyMounts) && !rroInUse(oldPodSpec) { for i := range podSpec.Containers { for j := range podSpec.Containers[i].VolumeMounts { @@ -1690,3 +1697,43 @@ func ApparmorFieldForAnnotation(annotation string) *api.AppArmorProfile { // length or if the annotation has an unrecognized value return nil } + +func dropContainerRestartRules(podSpec *api.PodSpec) { + if podSpec == nil { + return + } + for i, c := range podSpec.InitContainers { + if c.RestartPolicy != nil && *c.RestartPolicy != api.ContainerRestartPolicyAlways { + podSpec.InitContainers[i].RestartPolicy = nil + } + podSpec.InitContainers[i].RestartPolicyRules = nil + } + for i := range podSpec.Containers { + podSpec.Containers[i].RestartPolicy = nil + podSpec.Containers[i].RestartPolicyRules = nil + } + for i := range podSpec.EphemeralContainers { + podSpec.EphemeralContainers[i].RestartPolicy = nil + podSpec.EphemeralContainers[i].RestartPolicyRules = nil + } +} + +func containerRestartRulesInUse(oldPodSpec *api.PodSpec) bool { + if oldPodSpec == nil { + return false + } + for _, c := range oldPodSpec.InitContainers { + if c.RestartPolicy != nil && *c.RestartPolicy != api.ContainerRestartPolicyAlways { + return true + } + if len(c.RestartPolicyRules) > 0 { + return true + } + } + for _, c := range oldPodSpec.Containers { + if c.RestartPolicy != nil { + return true + } + } + return false +} diff --git a/pkg/api/pod/util_test.go b/pkg/api/pod/util_test.go index 82347573d55..922617ec0ef 100644 --- a/pkg/api/pod/util_test.go +++ b/pkg/api/pod/util_test.go @@ -5886,3 +5886,208 @@ func TestPodFileKeyRefInUse(t *testing.T) { }) } } + +func TestValidateContainerRestartRulesOption(t *testing.T) { + policyNever := api.ContainerRestartPolicyNever + testCases := []struct { + name string + oldPodSpec *api.PodSpec + featureEnabled bool + want bool + }{ + { + name: "feature enabled", + featureEnabled: true, + want: true, + }, + { + name: "feature disabled", + featureEnabled: false, + want: false, + }, + { + name: "old pod spec has regular containers with restart policy", + oldPodSpec: &api.PodSpec{ + Containers: []api.Container{{ + RestartPolicy: &policyNever, + }}, + }, + featureEnabled: false, + want: true, + }, + { + name: "old pod spec has regular containers with restart policy rules", + oldPodSpec: &api.PodSpec{ + Containers: []api.Container{{ + RestartPolicy: &policyNever, + RestartPolicyRules: []api.ContainerRestartRule{{ + Action: api.ContainerRestartRuleActionRestart, + ExitCodes: &api.ContainerRestartRuleOnExitCodes{ + Operator: api.ContainerRestartRuleOnExitCodesOpIn, + Values: []int32{42}, + }, + }}, + }}, + }, + featureEnabled: false, + want: true, + }, + { + name: "old pod spec has init containers with restart policy", + oldPodSpec: &api.PodSpec{ + InitContainers: []api.Container{{ + RestartPolicy: &policyNever, + }}, + }, + featureEnabled: false, + want: true, + }, + { + name: "old pod spec has regular containers with restart policy rules", + oldPodSpec: &api.PodSpec{ + InitContainers: []api.Container{{ + RestartPolicy: &policyNever, + RestartPolicyRules: []api.ContainerRestartRule{{ + Action: api.ContainerRestartRuleActionRestart, + ExitCodes: &api.ContainerRestartRuleOnExitCodes{ + Operator: api.ContainerRestartRuleOnExitCodesOpIn, + Values: []int32{42}, + }, + }}, + }}, + }, + featureEnabled: false, + want: true, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.ContainerRestartRules, tc.featureEnabled) + // The new pod doesn't impact the outcome. + gotOptions := GetValidationOptionsFromPodSpecAndMeta(nil, tc.oldPodSpec, nil, nil) + if tc.want != gotOptions.AllowContainerRestartPolicyRules { + t.Errorf("unexpected diff, want: %v, got: %v", tc.want, gotOptions.AllowInvalidPodDeletionCost) + } + }) + } +} + +func Test_dropContainerRestartRules(t *testing.T) { + var ( + always = api.ContainerRestartPolicyAlways + rules = []api.ContainerRestartRule{{ + Action: api.ContainerRestartRuleActionRestart, + ExitCodes: &api.ContainerRestartRuleOnExitCodes{ + Operator: api.ContainerRestartRuleOnExitCodesOpIn, + Values: []int32{42}, + }, + }} + ) + + initContainerWithRules := &api.Pod{ + Spec: api.PodSpec{ + InitContainers: []api.Container{{ + RestartPolicy: &always, + RestartPolicyRules: rules, + }}, + }, + } + initContainerWithoutRules := &api.Pod{ + Spec: api.PodSpec{ + InitContainers: []api.Container{{ + RestartPolicy: &always, + }}, + }, + } + regularContainerWithRules := &api.Pod{ + Spec: api.PodSpec{ + Containers: []api.Container{{ + RestartPolicy: &always, + RestartPolicyRules: rules, + }}, + }, + } + regularContainerWithoutRules := &api.Pod{ + Spec: api.PodSpec{ + Containers: []api.Container{{}}, + }, + } + ephemeralContainerWithRules := &api.Pod{ + Spec: api.PodSpec{ + EphemeralContainers: []api.EphemeralContainer{{ + EphemeralContainerCommon: api.EphemeralContainerCommon{ + RestartPolicy: &always, + RestartPolicyRules: rules, + }, + }}, + }, + } + ephemeralContainerWithoutRules := &api.Pod{ + Spec: api.PodSpec{ + EphemeralContainers: []api.EphemeralContainer{{}}, + }, + } + + cases := []struct { + name string + oldPod *api.Pod + newPod *api.Pod + featureEnabled bool + expected *api.Pod + }{ + { + name: "drop init container rules", + newPod: initContainerWithRules, + expected: initContainerWithoutRules, + }, + { + name: "drop regular container rules", + newPod: regularContainerWithRules, + expected: regularContainerWithoutRules, + }, + { + name: "drop ephemeral container rules", + newPod: ephemeralContainerWithRules, + expected: ephemeralContainerWithoutRules, + }, + { + name: "not drop init container rules when feature gate enabled", + newPod: initContainerWithRules, + featureEnabled: true, + expected: initContainerWithRules, + }, + { + name: "not drop regular container rules when feature gate enabled", + newPod: regularContainerWithRules, + featureEnabled: true, + expected: regularContainerWithRules, + }, + { + name: "not drop regular container rules when old container has rules", + oldPod: regularContainerWithRules, + newPod: regularContainerWithRules, + expected: regularContainerWithRules, + }, + } + + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.ContainerRestartRules, tc.featureEnabled) + + oldPod := tc.oldPod.DeepCopy() + newPod := tc.newPod.DeepCopy() + wantPod := tc.expected + DropDisabledPodFields(newPod, oldPod) + + // old pod should never be changed + if diff := cmp.Diff(oldPod, tc.oldPod); diff != "" { + t.Errorf("old pod changed: %s", diff) + } + + if diff := cmp.Diff(wantPod, newPod); diff != "" { + t.Errorf("new pod changed (- want, + got): %s", diff) + } + }) + } +} diff --git a/pkg/api/v1/pod/util.go b/pkg/api/v1/pod/util.go index 2f116582848..6d79457150c 100644 --- a/pkg/api/v1/pod/util.go +++ b/pkg/api/v1/pod/util.go @@ -396,6 +396,93 @@ func IsRestartableInitContainer(initContainer *v1.Container) bool { return *initContainer.RestartPolicy == v1.ContainerRestartPolicyAlways } +// IsContainerRestartable returns true if the container can be restarted. A container can be +// restarted if it has a pod-level restart policy "Always" or "OnFailure" and not override by +// container-level restart policy, or a container-level restart policy "Always" or "OnFailure", +// or a container level restart rule with action "Restart". +func IsContainerRestartable(pod v1.PodSpec, container v1.Container) bool { + if container.RestartPolicy != nil { + for _, rule := range container.RestartPolicyRules { + if rule.Action == v1.ContainerRestartRuleActionRestart { + return true + } + } + return *container.RestartPolicy != v1.ContainerRestartPolicyNever + } + return pod.RestartPolicy != v1.RestartPolicyNever +} + +// ContainerShouldRestart checks if a container should be restarted by its restart policy. +// First, the container-level restartPolicyRules are evaluated in order. An action is taken if any +// rules are matched. Second, the container-level restart policy is used. Lastly, if no container +// level policy are specified, pod-level restart policy is used. +func ContainerShouldRestart(container v1.Container, pod v1.PodSpec, exitCode int32) bool { + if container.RestartPolicy != nil { + rule, ok := findMatchingContainerRestartRule(container, exitCode) + if ok { + switch rule.Action { + case v1.ContainerRestartRuleActionRestart: + return true + default: + // Do nothing, fallback to container-level restart policy. + } + } + + // Check container-level restart policy if no rules matched. + switch *container.RestartPolicy { + case v1.ContainerRestartPolicyAlways: + return true + case v1.ContainerRestartPolicyOnFailure: + return exitCode != 0 + case v1.ContainerRestartPolicyNever: + return false + default: + // Do nothing, fallback to pod-level restart policy. + } + } + + switch pod.RestartPolicy { + case v1.RestartPolicyAlways: + return true + case v1.RestartPolicyOnFailure: + return exitCode != 0 + case v1.RestartPolicyNever: + return false + default: + // Default policy is Always, so we return true here. + return true + } +} + +// findMatchingContainerRestartRule returns a rule and true if the exitCode matched +// one of the restart rules for the given container. Returns and empty rule and +// false if no rules matched. +func findMatchingContainerRestartRule(container v1.Container, exitCode int32) (rule v1.ContainerRestartRule, found bool) { + for _, rule := range container.RestartPolicyRules { + if rule.ExitCodes != nil { + exitCodeMatched := false + for _, code := range rule.ExitCodes.Values { + if code == exitCode { + exitCodeMatched = true + } + } + switch rule.ExitCodes.Operator { + case v1.ContainerRestartRuleOnExitCodesOpIn: + if exitCodeMatched { + return rule, true + } + case v1.ContainerRestartRuleOnExitCodesOpNotIn: + if !exitCodeMatched { + return rule, true + } + default: + // Do nothing, continue to the next rule. + } + } + } + return v1.ContainerRestartRule{}, false +} + // CalculatePodStatusObservedGeneration calculates the observedGeneration for the pod status. // This is used to track the generation of the pod that was observed by the kubelet. // The observedGeneration is set to the pod's generation when the feature gate diff --git a/pkg/api/v1/pod/util_test.go b/pkg/api/v1/pod/util_test.go index 986405ad640..50c3e05461e 100644 --- a/pkg/api/v1/pod/util_test.go +++ b/pkg/api/v1/pod/util_test.go @@ -1172,3 +1172,330 @@ func TestCalculatePodConditionObservedGeneration(t *testing.T) { }) } } + +func TestIsContainerRestartable(t *testing.T) { + var ( + containerRestartPolicyAlways = v1.ContainerRestartPolicyAlways + containerRestartPolicyOnFailure = v1.ContainerRestartPolicyOnFailure + containerRestartPolicyNever = v1.ContainerRestartPolicyNever + ) + + testCases := []struct { + name string + podSpec v1.PodSpec + container v1.Container + expected bool + }{ + { + name: "Container: Rule action 'Restart' should always be true", + podSpec: v1.PodSpec{RestartPolicy: v1.RestartPolicyNever}, + container: v1.Container{ + RestartPolicy: &containerRestartPolicyNever, + RestartPolicyRules: []v1.ContainerRestartRule{ + {Action: v1.ContainerRestartRuleActionRestart}, + }, + }, + expected: true, + }, + { + name: "Container: Policy 'Always' is restartable", + podSpec: v1.PodSpec{RestartPolicy: v1.RestartPolicyNever}, + container: v1.Container{ + RestartPolicy: &containerRestartPolicyAlways, + }, + expected: true, + }, + { + name: "Container: Policy 'OnFailure' is restartable", + podSpec: v1.PodSpec{RestartPolicy: v1.RestartPolicyNever}, + container: v1.Container{ + RestartPolicy: &containerRestartPolicyOnFailure, + }, + expected: true, + }, + { + name: "Container: Policy 'Never' is not restartable", + podSpec: v1.PodSpec{RestartPolicy: v1.RestartPolicyAlways}, + container: v1.Container{ + RestartPolicy: &containerRestartPolicyNever, + }, + expected: false, + }, + { + name: "Pod Fallback: Policy 'Always' is restartable", + podSpec: v1.PodSpec{RestartPolicy: v1.RestartPolicyAlways}, + container: v1.Container{}, + expected: true, + }, + { + name: "Pod Fallback: Policy 'OnFailure' is restartable", + podSpec: v1.PodSpec{RestartPolicy: v1.RestartPolicyOnFailure}, + container: v1.Container{}, + expected: true, + }, + { + name: "Pod Fallback: Policy 'Never' is not restartable", + podSpec: v1.PodSpec{RestartPolicy: v1.RestartPolicyNever}, + container: v1.Container{}, + expected: false, + }, + { + name: "Pod Fallback: Default empty policy is restartable (since it's not 'Never')", + podSpec: v1.PodSpec{}, + container: v1.Container{}, + expected: true, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + got := IsContainerRestartable(tc.podSpec, tc.container) + if got != tc.expected { + t.Errorf("IsContainerRestartable() = %v, want %v", got, tc.expected) + } + }) + } +} + +func TestContainerHasRestartablePolicy(t *testing.T) { + var ( + containerRestartPolicyAlways = v1.ContainerRestartPolicyAlways + containerRestartPolicyOnFailure = v1.ContainerRestartPolicyOnFailure + containerRestartPolicyNever = v1.ContainerRestartPolicyNever + ) + + testCases := []struct { + name string + container v1.Container + podSpec v1.PodSpec + exitCode int32 + expected bool + }{ + { + name: "Rule: 'In' operator matches with 'Restart' action", + container: v1.Container{ + RestartPolicy: &containerRestartPolicyNever, + RestartPolicyRules: []v1.ContainerRestartRule{ + { + Action: v1.ContainerRestartRuleActionRestart, + ExitCodes: &v1.ContainerRestartRuleOnExitCodes{ + Operator: v1.ContainerRestartRuleOnExitCodesOpIn, + Values: []int32{42, 50, 60}, + }, + }, + }, + }, + exitCode: 42, + expected: true, + }, + { + name: "Rule: 'NotIn' operator matches with 'Restart' action", + container: v1.Container{ + RestartPolicy: &containerRestartPolicyNever, + RestartPolicyRules: []v1.ContainerRestartRule{ + { + Action: v1.ContainerRestartRuleActionRestart, + ExitCodes: &v1.ContainerRestartRuleOnExitCodes{ + Operator: v1.ContainerRestartRuleOnExitCodesOpNotIn, + Values: []int32{0, 1, 2}, + }, + }, + }, + }, + exitCode: 99, + expected: true, + }, + { + name: "Rule: 'In' operator does not match, should fall back to container policy", + container: v1.Container{ + RestartPolicy: &containerRestartPolicyNever, + RestartPolicyRules: []v1.ContainerRestartRule{ + { + Action: v1.ContainerRestartRuleActionRestart, + ExitCodes: &v1.ContainerRestartRuleOnExitCodes{ + Operator: v1.ContainerRestartRuleOnExitCodesOpIn, + Values: []int32{10, 20}, + }, + }, + }, + }, + exitCode: 30, + expected: false, + }, + { + name: "Rule: 'NotIn' operator does not match, should fall back to container policy", + container: v1.Container{ + RestartPolicy: &containerRestartPolicyNever, + RestartPolicyRules: []v1.ContainerRestartRule{ + { + Action: v1.ContainerRestartRuleActionRestart, + ExitCodes: &v1.ContainerRestartRuleOnExitCodes{ + Operator: v1.ContainerRestartRuleOnExitCodesOpNotIn, + Values: []int32{10, 20}, + }, + }, + }, + }, + exitCode: 10, + expected: false, + }, + { + name: "Container Policy: 'Always'", + container: v1.Container{RestartPolicy: &containerRestartPolicyAlways}, + podSpec: v1.PodSpec{RestartPolicy: v1.RestartPolicyNever}, + exitCode: 0, + expected: true, + }, + { + name: "Container Policy: 'OnFailure' with exit code 0", + container: v1.Container{RestartPolicy: &containerRestartPolicyOnFailure}, + podSpec: v1.PodSpec{RestartPolicy: v1.RestartPolicyNever}, + exitCode: 0, + expected: false, + }, + { + name: "Container Policy: 'OnFailure' with non-zero exit code", + container: v1.Container{RestartPolicy: &containerRestartPolicyOnFailure}, + podSpec: v1.PodSpec{RestartPolicy: v1.RestartPolicyNever}, + exitCode: 1, + expected: true, + }, + { + name: "Container Policy: 'Never' should return false", + container: v1.Container{RestartPolicy: &containerRestartPolicyNever}, + podSpec: v1.PodSpec{RestartPolicy: v1.RestartPolicyAlways}, + exitCode: 1, + expected: false, + }, + // --- Scenarios for Pod-Level Restart Policy (Lowest Priority) --- + { + name: "Pod Policy: Fallback to pod 'Always'", + container: v1.Container{}, + podSpec: v1.PodSpec{RestartPolicy: v1.RestartPolicyAlways}, + exitCode: 0, + expected: true, + }, + { + name: "Pod Policy: Fallback to pod 'OnFailure' with non-zero exit code", + container: v1.Container{}, + podSpec: v1.PodSpec{RestartPolicy: v1.RestartPolicyOnFailure}, + exitCode: 1, + expected: true, + }, + { + name: "Pod Policy: Fallback to pod 'Never'", + container: v1.Container{}, + podSpec: v1.PodSpec{RestartPolicy: v1.RestartPolicyNever}, + exitCode: 1, + expected: false, + }, + { + name: "Pod Policy: Fallback with no policies specified should return true", + container: v1.Container{}, + podSpec: v1.PodSpec{}, + exitCode: 0, + expected: true, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + // Execute the function under test + got := ContainerShouldRestart(tc.container, tc.podSpec, tc.exitCode) + + // Assert the result + if got != tc.expected { + t.Errorf("ContainerHasRestartablePolicy() = %v, want %v", got, tc.expected) + } + }) + } +} + +func TestFindMatchingContainerRestartRule(t *testing.T) { + ruleIn := v1.ContainerRestartRule{ + Action: v1.ContainerRestartRuleActionRestart, + ExitCodes: &v1.ContainerRestartRuleOnExitCodes{ + Operator: v1.ContainerRestartRuleOnExitCodesOpIn, + Values: []int32{42, 50, 60}, + }, + } + ruleNotIn := v1.ContainerRestartRule{ + Action: v1.ContainerRestartRuleActionRestart, + ExitCodes: &v1.ContainerRestartRuleOnExitCodes{ + Operator: v1.ContainerRestartRuleOnExitCodesOpNotIn, + Values: []int32{0, 1, 2}, + }, + } + ruleIn42 := v1.ContainerRestartRule{ + Action: v1.ContainerRestartRuleActionRestart, + ExitCodes: &v1.ContainerRestartRuleOnExitCodes{ + Operator: v1.ContainerRestartRuleOnExitCodesOpIn, + Values: []int32{42}, + }, + } + emptyRule := v1.ContainerRestartRule{} + + testCases := []struct { + name string + container v1.Container + exitCode int32 + expectedFound bool + expectedRule v1.ContainerRestartRule + }{ + { + name: "a rule with op In matches", + container: v1.Container{ + RestartPolicyRules: []v1.ContainerRestartRule{ruleIn}, + }, + exitCode: 42, + expectedFound: true, + expectedRule: ruleIn, + }, + { + name: "a rule with op NotIn matches", + container: v1.Container{ + RestartPolicyRules: []v1.ContainerRestartRule{ruleNotIn}, + }, + exitCode: 99, + expectedFound: true, + expectedRule: ruleNotIn, + }, + { + name: "matches the first rule if two rules both matched", + container: v1.Container{ + RestartPolicyRules: []v1.ContainerRestartRule{ruleIn, ruleIn42}, + }, + exitCode: 42, + expectedFound: true, + expectedRule: ruleIn, + }, + { + name: "no rules matched", + container: v1.Container{ + RestartPolicyRules: []v1.ContainerRestartRule{ruleIn}, + }, + exitCode: 100, + expectedFound: false, + expectedRule: emptyRule, + }, + { + name: "no rules defined", + container: v1.Container{}, + exitCode: 0, + expectedFound: false, + expectedRule: emptyRule, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + rule, found := findMatchingContainerRestartRule(tc.container, tc.exitCode) + if found != tc.expectedFound { + t.Errorf("FindMatchingContainerRestartRule() found = %v, want %v", found, tc.expectedFound) + } + if !reflect.DeepEqual(rule, tc.expectedRule) { + t.Errorf("FindMatchingContainerRestartRule() rule = %+v, want %+v", rule, tc.expectedRule) + } + }) + } +} diff --git a/pkg/apis/core/types.go b/pkg/apis/core/types.go index 32707e245d2..505ed9e04c1 100644 --- a/pkg/apis/core/types.go +++ b/pkg/apis/core/types.go @@ -2655,10 +2655,15 @@ type Container struct { // +optional ResizePolicy []ContainerResizePolicy // RestartPolicy defines the restart behavior of individual containers in a pod. - // This field may only be set for init containers, and the only allowed value is "Always". - // For non-init containers or when this field is not specified, + // This overrides the pod-level restart policy. When this field is not specified, // the restart behavior is defined by the Pod's restart policy and the container type. - // Setting the RestartPolicy as "Always" for the init container will have the following effect: + // If restartPolicyRules are specified, the container-level restartPolicy is also + // required as the "default" policy if no rules matched. The restartPolicyRules takes + // precedence over the container-level restart policies. This is an alpha-level feature + // and is controlled by the feature gate "ContainerRestartRules". If the feature is + // not enabled, the only allowed value is "Always". + // Additionally, setting the RestartPolicy as "Always" for the init container will + // have the following effect: // this init container will be continually restarted on // exit until all regular containers have terminated. Once all regular // containers have completed, all init containers with restartPolicy "Always" @@ -2672,6 +2677,23 @@ type Container struct { // +featureGate=SidecarContainers // +optional RestartPolicy *ContainerRestartPolicy + // Represents a list of rules to be checked to determine if the + // container should be restarted on exit. The rules are evaluated in + // order. Once a rule matches a container exit condition, the remaining + // rules are ignored. If no rule matches the container exit condition, + // the Container-level restart policy determines the whether the container + // is restarted or not. This is an alpha-level feature, and controlled by + // the feature gate "ContainerRestartRules". If the feature is not enabled, + // this field is not allowed. Constraints on the rules: + // - At most 20 rules are allowed. + // - Rules can have the same action. + // - Identical rules are not forbidden in validations. + // When rules are specified, container MUST set RestartPolicy explicitly + // even it if matches the Pod's RestartPolicy. + // +featureGate=ContainerRestartRules + // +optional + // +listType=atomic + RestartPolicyRules []ContainerRestartRule // +optional VolumeMounts []VolumeMount // volumeDevices is the list of block devices to be used by the container. @@ -3192,11 +3214,63 @@ const ( ) // ContainerRestartPolicy is the restart policy for a single container. -// This may only be set for init containers and only allowed value is "Always". +// The only allowed values are "Always", "Never", and "OnFailure". type ContainerRestartPolicy string const ( - ContainerRestartPolicyAlways ContainerRestartPolicy = "Always" + ContainerRestartPolicyAlways ContainerRestartPolicy = "Always" + ContainerRestartPolicyNever ContainerRestartPolicy = "Never" + ContainerRestartPolicyOnFailure ContainerRestartPolicy = "OnFailure" +) + +// ContainerRestartRule describes how a container exit is handled. +type ContainerRestartRule struct { + // Specifies the action taken on a container exit if the requirements + // are satisfied. The only possible value is "Restart" to restart the + // container. + // +required + Action ContainerRestartRuleAction + + // Represents the exit codes to check on container exits. + // +optional + ExitCodes *ContainerRestartRuleOnExitCodes +} + +// ContainerRestartRuleAction describes the action to take when the +// container exits. +type ContainerRestartRuleAction string + +// The only valid action is Restart. +const ( + ContainerRestartRuleActionRestart ContainerRestartRuleAction = "Restart" +) + +// ContainerRestartRuleOnExitCodes describes the condition +// for handling an exited container based on its exit codes. +type ContainerRestartRuleOnExitCodes struct { + // Represents the relationship between the container exit code(s) and the + // specified values. Possible values are: + // - In: the requirement is satisfied if the container exit code is in the + // set of specified values. + // - NotIn: the requirement is satisfied if the container exit code is + // not in the set of specified values. + // +required + Operator ContainerRestartRuleOnExitCodesOperator + + // Specifies the set of values to check for container exit codes. + // At most 255 elements are allowed. + // +optional + // +listType=set + Values []int32 +} + +// ContainerRestartRuleOnExitCodesOperator describes the operator +// to take for the exit codes. +type ContainerRestartRuleOnExitCodesOperator string + +const ( + ContainerRestartRuleOnExitCodesOpIn ContainerRestartRuleOnExitCodesOperator = "In" + ContainerRestartRuleOnExitCodesOpNotIn ContainerRestartRuleOnExitCodesOperator = "NotIn" ) // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object @@ -4278,12 +4352,24 @@ type EphemeralContainerCommon struct { // +optional ResizePolicy []ContainerResizePolicy // Restart policy for the container to manage the restart behavior of each - // container within a pod. - // This may only be set for init containers. You cannot set this field on - // ephemeral containers. + // container within a pod. Must be specified if restartPolicyRules are used. + // You cannot set this field on ephemeral containers. // +featureGate=SidecarContainers // +optional RestartPolicy *ContainerRestartPolicy + // Represents a list of rules to be checked to determine if the + // container should be restarted on exit. The rules are evaluated in + // order. Once a rule matches a container exit condition, the remaining + // rules are ignored. If no rule matches the container exit condition, + // the Pod-level restart policy determines the whether the container + // is restarted or not. Constraints on the rules: + // - At most 20 rules are allowed. + // - Rules can have the same action. + // - Identical rules are not forbidden in validations. + // +featureGate=ContainerRestartRules + // +optional + // +listType=atomic + RestartPolicyRules []ContainerRestartRule // Pod volumes to mount into the container's filesystem. Subpath mounts are not allowed for ephemeral containers. // +optional VolumeMounts []VolumeMount diff --git a/pkg/apis/core/v1/zz_generated.conversion.go b/pkg/apis/core/v1/zz_generated.conversion.go index 36b18734b9e..686662199df 100644 --- a/pkg/apis/core/v1/zz_generated.conversion.go +++ b/pkg/apis/core/v1/zz_generated.conversion.go @@ -362,6 +362,26 @@ func RegisterConversions(s *runtime.Scheme) error { }); err != nil { return err } + if err := s.AddGeneratedConversionFunc((*corev1.ContainerRestartRule)(nil), (*core.ContainerRestartRule)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1_ContainerRestartRule_To_core_ContainerRestartRule(a.(*corev1.ContainerRestartRule), b.(*core.ContainerRestartRule), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*core.ContainerRestartRule)(nil), (*corev1.ContainerRestartRule)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_core_ContainerRestartRule_To_v1_ContainerRestartRule(a.(*core.ContainerRestartRule), b.(*corev1.ContainerRestartRule), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*corev1.ContainerRestartRuleOnExitCodes)(nil), (*core.ContainerRestartRuleOnExitCodes)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1_ContainerRestartRuleOnExitCodes_To_core_ContainerRestartRuleOnExitCodes(a.(*corev1.ContainerRestartRuleOnExitCodes), b.(*core.ContainerRestartRuleOnExitCodes), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*core.ContainerRestartRuleOnExitCodes)(nil), (*corev1.ContainerRestartRuleOnExitCodes)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_core_ContainerRestartRuleOnExitCodes_To_v1_ContainerRestartRuleOnExitCodes(a.(*core.ContainerRestartRuleOnExitCodes), b.(*corev1.ContainerRestartRuleOnExitCodes), scope) + }); err != nil { + return err + } if err := s.AddGeneratedConversionFunc((*corev1.ContainerState)(nil), (*core.ContainerState)(nil), func(a, b interface{}, scope conversion.Scope) error { return Convert_v1_ContainerState_To_core_ContainerState(a.(*corev1.ContainerState), b.(*core.ContainerState), scope) }); err != nil { @@ -3190,6 +3210,7 @@ func autoConvert_v1_Container_To_core_Container(in *corev1.Container, out *core. } out.ResizePolicy = *(*[]core.ContainerResizePolicy)(unsafe.Pointer(&in.ResizePolicy)) out.RestartPolicy = (*core.ContainerRestartPolicy)(unsafe.Pointer(in.RestartPolicy)) + out.RestartPolicyRules = *(*[]core.ContainerRestartRule)(unsafe.Pointer(&in.RestartPolicyRules)) out.VolumeMounts = *(*[]core.VolumeMount)(unsafe.Pointer(&in.VolumeMounts)) out.VolumeDevices = *(*[]core.VolumeDevice)(unsafe.Pointer(&in.VolumeDevices)) out.LivenessProbe = (*core.Probe)(unsafe.Pointer(in.LivenessProbe)) @@ -3225,6 +3246,7 @@ func autoConvert_core_Container_To_v1_Container(in *core.Container, out *corev1. } out.ResizePolicy = *(*[]corev1.ContainerResizePolicy)(unsafe.Pointer(&in.ResizePolicy)) out.RestartPolicy = (*corev1.ContainerRestartPolicy)(unsafe.Pointer(in.RestartPolicy)) + out.RestartPolicyRules = *(*[]corev1.ContainerRestartRule)(unsafe.Pointer(&in.RestartPolicyRules)) out.VolumeMounts = *(*[]corev1.VolumeMount)(unsafe.Pointer(&in.VolumeMounts)) out.VolumeDevices = *(*[]corev1.VolumeDevice)(unsafe.Pointer(&in.VolumeDevices)) out.LivenessProbe = (*corev1.Probe)(unsafe.Pointer(in.LivenessProbe)) @@ -3318,6 +3340,50 @@ func Convert_core_ContainerResizePolicy_To_v1_ContainerResizePolicy(in *core.Con return autoConvert_core_ContainerResizePolicy_To_v1_ContainerResizePolicy(in, out, s) } +func autoConvert_v1_ContainerRestartRule_To_core_ContainerRestartRule(in *corev1.ContainerRestartRule, out *core.ContainerRestartRule, s conversion.Scope) error { + out.Action = core.ContainerRestartRuleAction(in.Action) + out.ExitCodes = (*core.ContainerRestartRuleOnExitCodes)(unsafe.Pointer(in.ExitCodes)) + return nil +} + +// Convert_v1_ContainerRestartRule_To_core_ContainerRestartRule is an autogenerated conversion function. +func Convert_v1_ContainerRestartRule_To_core_ContainerRestartRule(in *corev1.ContainerRestartRule, out *core.ContainerRestartRule, s conversion.Scope) error { + return autoConvert_v1_ContainerRestartRule_To_core_ContainerRestartRule(in, out, s) +} + +func autoConvert_core_ContainerRestartRule_To_v1_ContainerRestartRule(in *core.ContainerRestartRule, out *corev1.ContainerRestartRule, s conversion.Scope) error { + out.Action = corev1.ContainerRestartRuleAction(in.Action) + out.ExitCodes = (*corev1.ContainerRestartRuleOnExitCodes)(unsafe.Pointer(in.ExitCodes)) + return nil +} + +// Convert_core_ContainerRestartRule_To_v1_ContainerRestartRule is an autogenerated conversion function. +func Convert_core_ContainerRestartRule_To_v1_ContainerRestartRule(in *core.ContainerRestartRule, out *corev1.ContainerRestartRule, s conversion.Scope) error { + return autoConvert_core_ContainerRestartRule_To_v1_ContainerRestartRule(in, out, s) +} + +func autoConvert_v1_ContainerRestartRuleOnExitCodes_To_core_ContainerRestartRuleOnExitCodes(in *corev1.ContainerRestartRuleOnExitCodes, out *core.ContainerRestartRuleOnExitCodes, s conversion.Scope) error { + out.Operator = core.ContainerRestartRuleOnExitCodesOperator(in.Operator) + out.Values = *(*[]int32)(unsafe.Pointer(&in.Values)) + return nil +} + +// Convert_v1_ContainerRestartRuleOnExitCodes_To_core_ContainerRestartRuleOnExitCodes is an autogenerated conversion function. +func Convert_v1_ContainerRestartRuleOnExitCodes_To_core_ContainerRestartRuleOnExitCodes(in *corev1.ContainerRestartRuleOnExitCodes, out *core.ContainerRestartRuleOnExitCodes, s conversion.Scope) error { + return autoConvert_v1_ContainerRestartRuleOnExitCodes_To_core_ContainerRestartRuleOnExitCodes(in, out, s) +} + +func autoConvert_core_ContainerRestartRuleOnExitCodes_To_v1_ContainerRestartRuleOnExitCodes(in *core.ContainerRestartRuleOnExitCodes, out *corev1.ContainerRestartRuleOnExitCodes, s conversion.Scope) error { + out.Operator = corev1.ContainerRestartRuleOnExitCodesOperator(in.Operator) + out.Values = *(*[]int32)(unsafe.Pointer(&in.Values)) + return nil +} + +// Convert_core_ContainerRestartRuleOnExitCodes_To_v1_ContainerRestartRuleOnExitCodes is an autogenerated conversion function. +func Convert_core_ContainerRestartRuleOnExitCodes_To_v1_ContainerRestartRuleOnExitCodes(in *core.ContainerRestartRuleOnExitCodes, out *corev1.ContainerRestartRuleOnExitCodes, s conversion.Scope) error { + return autoConvert_core_ContainerRestartRuleOnExitCodes_To_v1_ContainerRestartRuleOnExitCodes(in, out, s) +} + func autoConvert_v1_ContainerState_To_core_ContainerState(in *corev1.ContainerState, out *core.ContainerState, s conversion.Scope) error { out.Waiting = (*core.ContainerStateWaiting)(unsafe.Pointer(in.Waiting)) out.Running = (*core.ContainerStateRunning)(unsafe.Pointer(in.Running)) @@ -3838,6 +3904,7 @@ func autoConvert_v1_EphemeralContainerCommon_To_core_EphemeralContainerCommon(in } out.ResizePolicy = *(*[]core.ContainerResizePolicy)(unsafe.Pointer(&in.ResizePolicy)) out.RestartPolicy = (*core.ContainerRestartPolicy)(unsafe.Pointer(in.RestartPolicy)) + out.RestartPolicyRules = *(*[]core.ContainerRestartRule)(unsafe.Pointer(&in.RestartPolicyRules)) out.VolumeMounts = *(*[]core.VolumeMount)(unsafe.Pointer(&in.VolumeMounts)) out.VolumeDevices = *(*[]core.VolumeDevice)(unsafe.Pointer(&in.VolumeDevices)) out.LivenessProbe = (*core.Probe)(unsafe.Pointer(in.LivenessProbe)) @@ -3873,6 +3940,7 @@ func autoConvert_core_EphemeralContainerCommon_To_v1_EphemeralContainerCommon(in } out.ResizePolicy = *(*[]corev1.ContainerResizePolicy)(unsafe.Pointer(&in.ResizePolicy)) out.RestartPolicy = (*corev1.ContainerRestartPolicy)(unsafe.Pointer(in.RestartPolicy)) + out.RestartPolicyRules = *(*[]corev1.ContainerRestartRule)(unsafe.Pointer(&in.RestartPolicyRules)) out.VolumeMounts = *(*[]corev1.VolumeMount)(unsafe.Pointer(&in.VolumeMounts)) out.VolumeDevices = *(*[]corev1.VolumeDevice)(unsafe.Pointer(&in.VolumeDevices)) out.LivenessProbe = (*corev1.Probe)(unsafe.Pointer(in.LivenessProbe)) diff --git a/pkg/apis/core/validation/validation.go b/pkg/apis/core/validation/validation.go index f294ff3d072..480a37cd6ef 100644 --- a/pkg/apis/core/validation/validation.go +++ b/pkg/apis/core/validation/validation.go @@ -54,6 +54,7 @@ import ( "k8s.io/kubernetes/pkg/apis/certificates" apiservice "k8s.io/kubernetes/pkg/api/service" + podutil "k8s.io/kubernetes/pkg/api/v1/pod" "k8s.io/kubernetes/pkg/apis/core" "k8s.io/kubernetes/pkg/apis/core/helper" "k8s.io/kubernetes/pkg/apis/core/helper/qos" @@ -3238,18 +3239,30 @@ func validateProbe(probe *core.Probe, gracePeriod *int64, fldPath *field.Path, o return allErrs } -func validateInitContainerRestartPolicy(restartPolicy *core.ContainerRestartPolicy, fldPath *field.Path) field.ErrorList { +func validateInitContainerRestartPolicy(restartPolicy *core.ContainerRestartPolicy, restartRules []core.ContainerRestartRule, fldPath *field.Path, opts PodValidationOptions) field.ErrorList { var allErrors field.ErrorList if restartPolicy == nil { return allErrors } - switch *restartPolicy { - case core.ContainerRestartPolicyAlways: - break - default: - validValues := []core.ContainerRestartPolicy{core.ContainerRestartPolicyAlways} - allErrors = append(allErrors, field.NotSupported(fldPath, *restartPolicy, validValues)) + if opts.AllowContainerRestartPolicyRules { + switch *restartPolicy { + case core.ContainerRestartPolicyAlways: + // Sidecar containers should not have restart policy rules + if len(restartRules) > 0 { + allErrors = append(allErrors, field.Forbidden(fldPath.Child("restartPolicyRules"), "restartPolicyRules are not allowed for init containers with restart policy Always")) + } + default: + allErrors = append(allErrors, validateContainerRestartPolicy(restartPolicy, restartRules, fldPath)...) + } + } else { + switch *restartPolicy { + case core.ContainerRestartPolicyAlways: + break + default: + validValues := []core.ContainerRestartPolicy{core.ContainerRestartPolicyAlways} + allErrors = append(allErrors, field.NotSupported(fldPath.Child("restartPolicy"), *restartPolicy, validValues)) + } } return allErrors @@ -3567,6 +3580,59 @@ func validateResizePolicy(policyList []core.ContainerResizePolicy, fldPath *fiel return allErrors } +var supportedContainerRestartPolicies = sets.New( + core.ContainerRestartPolicyAlways, + core.ContainerRestartPolicyNever, + core.ContainerRestartPolicyOnFailure, +) + +var supportedContainerRestartPolicyOperators = sets.New( + core.ContainerRestartRuleOnExitCodesOpIn, + core.ContainerRestartRuleOnExitCodesOpNotIn, +) + +// validateContainerRestartPolicy checks the container-level restartPolicy and restartPolicyRules are valid for +// regular containers and non-sidecar init containers. +func validateContainerRestartPolicy(policy *core.ContainerRestartPolicy, rules []core.ContainerRestartRule, fldPath *field.Path) field.ErrorList { + var allErrs field.ErrorList + restartPolicyFld := fldPath.Child("restartPolicy") + if policy == nil { + if len(rules) == 0 { + return allErrs + } else { + allErrs = append(allErrs, field.Required(restartPolicyFld, "must specify restartPolicy when restart rules are used")) + } + } else if !supportedContainerRestartPolicies.Has(*policy) { + allErrs = append(allErrs, field.NotSupported(restartPolicyFld, *policy, sets.List(supportedContainerRestartPolicies))) + } + + if len(rules) > 20 { + allErrs = append(allErrs, field.TooLong(fldPath.Child("restartPolicyRules"), rules, 20)) + } + for i, rule := range rules { + policyRulesFld := fldPath.Child("restartPolicyRules").Index(i) + + if rule.Action != core.ContainerRestartRuleActionRestart { + validActions := []core.ContainerRestartRuleAction{core.ContainerRestartRuleActionRestart} + allErrs = append(allErrs, field.NotSupported(policyRulesFld.Child("action"), rule.Action, validActions)) + } + + if rule.ExitCodes != nil { + exitCodesFld := policyRulesFld.Child("exitCodes") + if !supportedContainerRestartPolicyOperators.Has(rule.ExitCodes.Operator) { + allErrs = append(allErrs, field.NotSupported(exitCodesFld.Child("operator"), rule.ExitCodes.Operator, sets.List(supportedContainerRestartPolicyOperators))) + } + + if len(rule.ExitCodes.Values) > 255 { + allErrs = append(allErrs, field.TooLong(exitCodesFld.Child("values"), rule.ExitCodes.Values, 255)) + } + } else { + allErrs = append(allErrs, field.Required(policyRulesFld.Child("exitCodes"), "must be specified")) + } + } + return allErrs +} + // validateEphemeralContainers is called by pod spec and template validation to validate the list of ephemeral containers. // Note that this is called for pod template even though ephemeral containers aren't allowed in pod templates. func validateEphemeralContainers(ephemeralContainers []core.EphemeralContainer, containers, initContainers []core.Container, volumes map[string]core.VolumeSource, podClaimNames sets.Set[string], fldPath *field.Path, opts PodValidationOptions, podRestartPolicy *core.RestartPolicy, hostUsers bool) field.ErrorList { @@ -3668,7 +3734,7 @@ func validateInitContainers(containers []core.Container, os *core.PodOS, regular restartAlways := false // Apply the validation specific to init containers if ctr.RestartPolicy != nil { - allErrs = append(allErrs, validateInitContainerRestartPolicy(ctr.RestartPolicy, idxPath.Child("restartPolicy"))...) + allErrs = append(allErrs, validateInitContainerRestartPolicy(ctr.RestartPolicy, ctr.RestartPolicyRules, idxPath, opts)...) restartAlways = *ctr.RestartPolicy == core.ContainerRestartPolicyAlways } @@ -3888,8 +3954,9 @@ func validateContainers(containers []core.Container, os *core.PodOS, volumes map allErrs = append(allErrs, validateReadinessProbe(ctr.ReadinessProbe, gracePeriod, path.Child("readinessProbe"), opts)...) allErrs = append(allErrs, validateStartupProbe(ctr.StartupProbe, gracePeriod, path.Child("startupProbe"), opts)...) - // These fields are disallowed for regular containers - if ctr.RestartPolicy != nil { + if opts.AllowContainerRestartPolicyRules { + allErrs = append(allErrs, validateContainerRestartPolicy(ctr.RestartPolicy, ctr.RestartPolicyRules, path)...) + } else if ctr.RestartPolicy != nil { allErrs = append(allErrs, field.Forbidden(path.Child("restartPolicy"), "may not be set for non-init containers")) } } @@ -4294,6 +4361,8 @@ type PodValidationOptions struct { OldPodViolatesLegacyMatchLabelKeysValidation bool // Allows containers to consume environment variables via environment variable files. AllowEnvFilesValidation bool + // Allows containers have restart policy and restart policy rules. + AllowContainerRestartPolicyRules bool } // validatePodMetadataAndSpec tests if required fields in the pod.metadata and pod.spec are set, @@ -5613,8 +5682,38 @@ func ValidatePodUpdate(newPod, oldPod *core.Pod, opts PodValidationOptions) fiel } // ValidateContainerStateTransition test to if any illegal container state transitions are being attempted -func ValidateContainerStateTransition(newStatuses, oldStatuses []core.ContainerStatus, fldpath *field.Path, restartPolicy core.RestartPolicy) field.ErrorList { +func ValidateContainerStateTransition(newStatuses, oldStatuses []core.ContainerStatus, fldPath *field.Path, podSpec core.PodSpec) field.ErrorList { allErrs := field.ErrorList{} + if utilfeature.DefaultFeatureGate.Enabled(features.ContainerRestartRules) { + v1PodSpec := &v1.PodSpec{} + err := corev1.Convert_core_PodSpec_To_v1_PodSpec(&podSpec, v1PodSpec, nil) + if err != nil { + allErrs = append(allErrs, field.InternalError(fldPath, fmt.Errorf("invalid %q: %v", fldPath, err.Error()))) + } + for i, oldStatus := range oldStatuses { + // Skip any container that is not terminated + if oldStatus.State.Terminated == nil { + continue + } + for _, newStatus := range newStatuses { + if newStatus.Name == oldStatus.Name && newStatus.State.Terminated == nil { + allowed := false + for _, c := range v1PodSpec.Containers { + if c.Name == oldStatus.Name { + allowed = podutil.ContainerShouldRestart(c, *v1PodSpec, oldStatus.State.Terminated.ExitCode) + break + } + } + if !allowed { + allErrs = append(allErrs, field.Forbidden(fldPath.Index(i).Child("state"), "may not be transitioned to non-terminated state")) + } + break + } + } + } + return allErrs + } + restartPolicy := podSpec.RestartPolicy // If we should always restart, containers are allowed to leave the terminated state if restartPolicy == core.RestartPolicyAlways { return allErrs @@ -5630,7 +5729,7 @@ func ValidateContainerStateTransition(newStatuses, oldStatuses []core.ContainerS } for _, newStatus := range newStatuses { if oldStatus.Name == newStatus.Name && newStatus.State.Terminated == nil { - allErrs = append(allErrs, field.Forbidden(fldpath.Index(i).Child("state"), "may not be transitioned to non-terminated state")) + allErrs = append(allErrs, field.Forbidden(fldPath.Index(i).Child("state"), "may not be transitioned to non-terminated state")) } } } @@ -5677,6 +5776,24 @@ func ValidateInitContainerStateTransition(newStatuses, oldStatuses []core.Contai return allErrs } +// ValidateEphemeralContainerStateTransition test to if any ephemeral containers are transitioned +// from terminated state to non-terminated state. +func ValidateEphemeralContainerStateTransition(newStatuses, oldStatuses []core.ContainerStatus, fldpath *field.Path) field.ErrorList { + allErrs := field.ErrorList{} + for i, oldStatus := range oldStatuses { + // Skip any container that is not terminated + if oldStatus.State.Terminated == nil { + continue + } + for _, newStatus := range newStatuses { + if oldStatus.Name == newStatus.Name && newStatus.State.Terminated == nil { + allErrs = append(allErrs, field.Forbidden(fldpath.Index(i).Child("state"), "may not be transitioned to non-terminated state")) + } + } + } + return allErrs +} + // ValidatePodStatusUpdate checks for changes to status that shouldn't occur in normal operation. func ValidatePodStatusUpdate(newPod, oldPod *core.Pod, opts PodValidationOptions) field.ErrorList { fldPath := field.NewPath("metadata") @@ -5709,10 +5826,9 @@ func ValidatePodStatusUpdate(newPod, oldPod *core.Pod, opts PodValidationOptions // // If pod should not restart, make sure the status update does not transition // any terminated containers to a non-terminated state. - allErrs = append(allErrs, ValidateContainerStateTransition(newPod.Status.ContainerStatuses, oldPod.Status.ContainerStatuses, fldPath.Child("containerStatuses"), oldPod.Spec.RestartPolicy)...) + allErrs = append(allErrs, ValidateContainerStateTransition(newPod.Status.ContainerStatuses, oldPod.Status.ContainerStatuses, fldPath.Child("containerStatuses"), oldPod.Spec)...) allErrs = append(allErrs, ValidateInitContainerStateTransition(newPod.Status.InitContainerStatuses, oldPod.Status.InitContainerStatuses, fldPath.Child("initContainerStatuses"), &oldPod.Spec)...) - // The kubelet will never restart ephemeral containers, so treat them like they have an implicit RestartPolicyNever. - allErrs = append(allErrs, ValidateContainerStateTransition(newPod.Status.EphemeralContainerStatuses, oldPod.Status.EphemeralContainerStatuses, fldPath.Child("ephemeralContainerStatuses"), core.RestartPolicyNever)...) + allErrs = append(allErrs, ValidateEphemeralContainerStateTransition(newPod.Status.EphemeralContainerStatuses, oldPod.Status.EphemeralContainerStatuses, fldPath.Child("ephemeralContainerStatuses"))...) allErrs = append(allErrs, validatePodResourceClaimStatuses(newPod.Status.ResourceClaimStatuses, newPod.Spec.ResourceClaims, fldPath.Child("resourceClaimStatuses"))...) if newIPErrs := validatePodIPs(newPod, oldPod); len(newIPErrs) > 0 { diff --git a/pkg/apis/core/validation/validation_test.go b/pkg/apis/core/validation/validation_test.go index 0f1560641f7..d5de38b2a7d 100644 --- a/pkg/apis/core/validation/validation_test.go +++ b/pkg/apis/core/validation/validation_test.go @@ -60,8 +60,8 @@ const ( var ( containerRestartPolicyAlways = core.ContainerRestartPolicyAlways - containerRestartPolicyOnFailure = core.ContainerRestartPolicy("OnFailure") - containerRestartPolicyNever = core.ContainerRestartPolicy("Never") + containerRestartPolicyOnFailure = core.ContainerRestartPolicyOnFailure + containerRestartPolicyNever = core.ContainerRestartPolicyNever containerRestartPolicyInvalid = core.ContainerRestartPolicy("invalid") containerRestartPolicyEmpty = core.ContainerRestartPolicy("") defaultGracePeriod = ptr.To[int64](30) @@ -22382,6 +22382,9 @@ func TestValidateOSFields(t *testing.T) { "Containers[*].ResizePolicy[*].RestartPolicy", "Containers[*].ResizePolicy[*].ResourceName", "Containers[*].RestartPolicy", + "Containers[*].RestartPolicyRules[*].Action", + "Containers[*].RestartPolicyRules[*].ExitCodes.Operator", + "Containers[*].RestartPolicyRules[*].ExitCodes.Values[*]", "Containers[*].SecurityContext.RunAsNonRoot", "Containers[*].Stdin", "Containers[*].StdinOnce", @@ -22409,6 +22412,9 @@ func TestValidateOSFields(t *testing.T) { "EphemeralContainers[*].EphemeralContainerCommon.ResizePolicy[*].RestartPolicy", "EphemeralContainers[*].EphemeralContainerCommon.ResizePolicy[*].ResourceName", "EphemeralContainers[*].EphemeralContainerCommon.RestartPolicy", + "EphemeralContainers[*].EphemeralContainerCommon.RestartPolicyRules[*].Action", + "EphemeralContainers[*].EphemeralContainerCommon.RestartPolicyRules[*].ExitCodes.Operator", + "EphemeralContainers[*].EphemeralContainerCommon.RestartPolicyRules[*].ExitCodes.Values[*]", "EphemeralContainers[*].EphemeralContainerCommon.Stdin", "EphemeralContainers[*].EphemeralContainerCommon.StdinOnce", "EphemeralContainers[*].EphemeralContainerCommon.TTY", @@ -22439,6 +22445,9 @@ func TestValidateOSFields(t *testing.T) { "InitContainers[*].ResizePolicy[*].RestartPolicy", "InitContainers[*].ResizePolicy[*].ResourceName", "InitContainers[*].RestartPolicy", + "InitContainers[*].RestartPolicyRules[*].Action", + "InitContainers[*].RestartPolicyRules[*].ExitCodes.Operator", + "InitContainers[*].RestartPolicyRules[*].ExitCodes.Values[*]", "InitContainers[*].Stdin", "InitContainers[*].StdinOnce", "InitContainers[*].TTY", @@ -28609,3 +28618,372 @@ func TestValidateFileKeyRefVolume(t *testing.T) { }) } } + +func TestValidateContainerRestartPolicy(t *testing.T) { + volumeDevices := make(map[string]core.VolumeSource) + podOS := &core.PodOS{Name: core.OSName(v1.Linux)} + capabilities.ResetForTest() + capabilities.Initialize(capabilities.Capabilities{ + AllowPrivileged: true, + }) + podRestartPolicyAlways := core.RestartPolicyAlways + + successCases := []struct { + Name string + RestartPolicy *core.ContainerRestartPolicy + RestartPolicyRules []core.ContainerRestartRule + }{ + { + Name: "no-restart-policy-and-rules", + }, + { + Name: "restart-policy-always", + RestartPolicy: &containerRestartPolicyAlways, + }, { + Name: "restart-policy-never", + RestartPolicy: &containerRestartPolicyNever, + }, { + Name: "restart-policy-on-failure", + RestartPolicy: &containerRestartPolicyOnFailure, + }, { + Name: "restart-policy-rules", + RestartPolicy: &containerRestartPolicyNever, + RestartPolicyRules: []core.ContainerRestartRule{{ + Action: "Restart", + ExitCodes: &core.ContainerRestartRuleOnExitCodes{ + Operator: "In", + Values: []int32{42}, + }, + }}, + }, + } + + for _, tc := range successCases { + t.Run(tc.Name, func(t *testing.T) { + containers := []core.Container{{ + Name: "name", + Image: "image", + ImagePullPolicy: "IfNotPresent", + TerminationMessagePolicy: "File", + RestartPolicy: tc.RestartPolicy, + RestartPolicyRules: tc.RestartPolicyRules, + }} + opts := PodValidationOptions{ + AllowContainerRestartPolicyRules: true, + } + errs := validateContainers(containers, podOS, volumeDevices, nil, defaultGracePeriod, field.NewPath("containers"), opts, &podRestartPolicyAlways, noUserNamespace) + if len(errs) > 0 { + t.Errorf("Unexpected error(s): %v", errs) + } + }) + } + + errorCases := []struct { + Name string + RestartPolicy *core.ContainerRestartPolicy + RestartPolicyRules []core.ContainerRestartRule + ExpectedErrors field.ErrorList + }{ + { + Name: "invalid container restart policy", + RestartPolicy: &containerRestartPolicyInvalid, + ExpectedErrors: field.ErrorList{{ + Type: field.ErrorTypeNotSupported, + Field: "containers[0].restartPolicy", + BadValue: containerRestartPolicyInvalid, + }}, + }, + { + Name: "empty container restart policy", + RestartPolicy: &containerRestartPolicyEmpty, + ExpectedErrors: field.ErrorList{{ + Type: field.ErrorTypeNotSupported, + Field: "containers[0].restartPolicy", + BadValue: containerRestartPolicyEmpty, + }}, + }, + { + Name: "missing container restart policy when restart rules are specified", + RestartPolicyRules: []core.ContainerRestartRule{{ + Action: "Restart", + ExitCodes: &core.ContainerRestartRuleOnExitCodes{ + Operator: "In", + Values: []int32{42}, + }, + }}, + ExpectedErrors: field.ErrorList{{ + Type: field.ErrorTypeRequired, Field: "containers[0].restartPolicy", BadValue: "", + }}, + }, + { + Name: "invalid action", + RestartPolicy: &containerRestartPolicyNever, + RestartPolicyRules: []core.ContainerRestartRule{{ + Action: "invalid", + ExitCodes: &core.ContainerRestartRuleOnExitCodes{ + Operator: "In", + Values: []int32{42}, + }, + }}, + ExpectedErrors: field.ErrorList{{ + Type: field.ErrorTypeNotSupported, + Field: "containers[0].restartPolicyRules[0].action", + BadValue: core.ContainerRestartRuleAction("invalid"), + }}, + }, + { + Name: "empty action", + RestartPolicy: &containerRestartPolicyNever, + RestartPolicyRules: []core.ContainerRestartRule{{ + Action: "", + ExitCodes: &core.ContainerRestartRuleOnExitCodes{ + Operator: "In", + Values: []int32{42}, + }, + }}, + ExpectedErrors: field.ErrorList{{ + Type: field.ErrorTypeNotSupported, + Field: "containers[0].restartPolicyRules[0].action", + BadValue: core.ContainerRestartRuleAction(""), + }}, + }, + { + Name: "empty ExitCodes", + RestartPolicy: &containerRestartPolicyNever, + RestartPolicyRules: []core.ContainerRestartRule{{ + Action: "Restart", + }}, + ExpectedErrors: field.ErrorList{{ + Type: field.ErrorTypeRequired, + Field: "containers[0].restartPolicyRules[0].exitCodes", + BadValue: "", + }}, + }, + { + Name: "invalid ExitCodes Operator", + RestartPolicy: &containerRestartPolicyNever, + RestartPolicyRules: []core.ContainerRestartRule{{ + Action: "Restart", + ExitCodes: &core.ContainerRestartRuleOnExitCodes{ + Operator: "invalid", + Values: []int32{42}, + }, + }}, + ExpectedErrors: field.ErrorList{{ + Type: field.ErrorTypeNotSupported, + Field: "containers[0].restartPolicyRules[0].exitCodes.operator", + BadValue: core.ContainerRestartRuleOnExitCodesOperator("invalid"), + }}, + }, + { + Name: "empty ExitCodes Operator", + RestartPolicy: &containerRestartPolicyNever, + RestartPolicyRules: []core.ContainerRestartRule{{ + Action: "Restart", + ExitCodes: &core.ContainerRestartRuleOnExitCodes{ + Operator: "", + Values: []int32{42}, + }, + }}, + ExpectedErrors: field.ErrorList{{ + Type: field.ErrorTypeNotSupported, + Field: "containers[0].restartPolicyRules[0].exitCodes.operator", + BadValue: core.ContainerRestartRuleOnExitCodesOperator(""), + }}, + }, + } + + for _, tc := range errorCases { + t.Run(tc.Name, func(t *testing.T) { + containers := []core.Container{{ + Name: "name", + Image: "image", + ImagePullPolicy: "IfNotPresent", + TerminationMessagePolicy: "File", + RestartPolicy: tc.RestartPolicy, + RestartPolicyRules: tc.RestartPolicyRules, + }} + opts := PodValidationOptions{ + AllowContainerRestartPolicyRules: true, + } + errs := validateContainers(containers, podOS, volumeDevices, nil, defaultGracePeriod, field.NewPath("containers"), opts, &podRestartPolicyAlways, noUserNamespace) + if len(errs) == 0 { + t.Fatal("expected error but received none") + } + + if diff := cmp.Diff(tc.ExpectedErrors, errs, cmpopts.IgnoreFields(field.Error{}, "Detail")); diff != "" { + t.Errorf("unexpected diff in errors (-want, +got):\n%s", diff) + t.Errorf("INFO: all errors:\n%s", prettyErrorList(errs)) + } + }) + } + + // test cases sidecar containers + cases := []struct { + title string + restartPolicyRules []core.ContainerRestartRule + expectedErrors field.ErrorList + }{ + { + "sidecar containers without restart policy rules", + nil, + nil, + }, + { + "restart policy rules are not supported with restart policy Always", + []core.ContainerRestartRule{{ + Action: core.ContainerRestartRuleActionRestart, + ExitCodes: &core.ContainerRestartRuleOnExitCodes{ + Operator: core.ContainerRestartRuleOnExitCodesOpIn, + Values: []int32{1}, + }, + }}, + field.ErrorList{{Type: field.ErrorTypeForbidden, Field: "initContainers[0].restartPolicyRules", BadValue: ""}}, + }, + } + + for _, tc := range cases { + t.Run(tc.title, func(t *testing.T) { + containers := []core.Container{{ + Name: "name", + Image: "image", + ImagePullPolicy: "IfNotPresent", + TerminationMessagePolicy: "File", + RestartPolicy: &containerRestartPolicyAlways, + RestartPolicyRules: tc.restartPolicyRules, + }} + opts := PodValidationOptions{ + AllowContainerRestartPolicyRules: true, + } + errs := validateInitContainers(containers, podOS, nil, volumeDevices, nil, defaultGracePeriod, field.NewPath("initContainers"), opts, &podRestartPolicyAlways, noUserNamespace) + if tc.expectedErrors == nil { + if len(errs) > 0 { + t.Errorf("unexpected errors: %v", prettyErrorList(errs)) + } + } else if len(errs) == 0 { + t.Fatal("expected error but received none") + } + + if diff := cmp.Diff(tc.expectedErrors, errs, cmpopts.IgnoreFields(field.Error{}, "Detail")); diff != "" { + t.Errorf("unexpected diff in errors (-want, +got):\n%s", diff) + t.Errorf("INFO: all errors:\n%s", prettyErrorList(errs)) + } + }) + } +} + +func TestValidateContainerStateTransition(t *testing.T) { + var ( + containerRestartPolicyAlways = core.ContainerRestartPolicyAlways + containerRestartPolicyNever = core.ContainerRestartPolicyNever + ) + runningState := core.ContainerState{Running: &core.ContainerStateRunning{}} + terminatedState := func(exitCode int32) core.ContainerState { + return core.ContainerState{Terminated: &core.ContainerStateTerminated{ExitCode: exitCode}} + } + + container1 := core.Container{Name: "c1", Image: "image"} + container1RestartNever := core.Container{Name: "c1", Image: "image", RestartPolicy: &containerRestartPolicyNever} + container1RestartAlways := core.Container{Name: "c1", Image: "image", RestartPolicy: &containerRestartPolicyAlways} + container1RestartRuleIn42 := core.Container{ + Name: "c1", + Image: "image", + RestartPolicy: &containerRestartPolicyNever, + RestartPolicyRules: []core.ContainerRestartRule{ + { + Action: core.ContainerRestartRuleActionRestart, + ExitCodes: &core.ContainerRestartRuleOnExitCodes{ + Operator: "In", + Values: []int32{42}, + }, + }, + }, + } + + testCases := []struct { + name string + podSpec core.PodSpec + oldStatuses []core.ContainerStatus + newStatuses []core.ContainerStatus + expectErr bool + }{ + { + name: "feature enabled, not terminated", + podSpec: core.PodSpec{RestartPolicy: core.RestartPolicyNever, Containers: []core.Container{container1RestartNever}}, + oldStatuses: []core.ContainerStatus{{Name: "c1", State: runningState}}, + newStatuses: []core.ContainerStatus{{Name: "c1", State: runningState}}, + expectErr: false, + }, + { + name: "feature enabled, restart allowed by pod policy 'Always'", + podSpec: core.PodSpec{RestartPolicy: core.RestartPolicyAlways, Containers: []core.Container{container1}}, + oldStatuses: []core.ContainerStatus{{Name: "c1", State: terminatedState(0)}}, + newStatuses: []core.ContainerStatus{{Name: "c1", State: runningState}}, + expectErr: false, + }, + { + name: "feature enabled, restart allowed by pod policy 'OnFailure' with exit 1", + podSpec: core.PodSpec{RestartPolicy: core.RestartPolicyOnFailure, Containers: []core.Container{container1}}, + oldStatuses: []core.ContainerStatus{{Name: "c1", State: terminatedState(1)}}, + newStatuses: []core.ContainerStatus{{Name: "c1", State: runningState}}, + expectErr: false, + }, + { + name: "feature enabled, restart not allowed by pod policy 'OnFailure' with exit 0", + podSpec: core.PodSpec{RestartPolicy: core.RestartPolicyOnFailure, Containers: []core.Container{container1}}, + oldStatuses: []core.ContainerStatus{{Name: "c1", State: terminatedState(0)}}, + newStatuses: []core.ContainerStatus{{Name: "c1", State: runningState}}, + expectErr: true, + }, + { + name: "feature enabled, restart not allowed by pod policy 'Never', with transition", + podSpec: core.PodSpec{RestartPolicy: core.RestartPolicyNever, Containers: []core.Container{container1}}, + oldStatuses: []core.ContainerStatus{{Name: "c1", State: terminatedState(0)}}, + newStatuses: []core.ContainerStatus{{Name: "c1", State: runningState}}, + expectErr: true, + }, + { + name: "feature enabled, restart allowed by container policy 'Always'", + podSpec: core.PodSpec{RestartPolicy: core.RestartPolicyNever, Containers: []core.Container{container1RestartAlways}}, + oldStatuses: []core.ContainerStatus{{Name: "c1", State: terminatedState(0)}}, + newStatuses: []core.ContainerStatus{{Name: "c1", State: runningState}}, + expectErr: false, + }, + { + name: "feature enabled, restart not allowed by container policy 'Never'", + podSpec: core.PodSpec{RestartPolicy: core.RestartPolicyAlways, Containers: []core.Container{container1RestartNever}}, + oldStatuses: []core.ContainerStatus{{Name: "c1", State: terminatedState(0)}}, + newStatuses: []core.ContainerStatus{{Name: "c1", State: runningState}}, + expectErr: true, + }, + { + name: "feature enabled, restart allowed by container rule", + podSpec: core.PodSpec{RestartPolicy: core.RestartPolicyNever, Containers: []core.Container{container1RestartRuleIn42}}, + oldStatuses: []core.ContainerStatus{{Name: "c1", State: terminatedState(42)}}, + newStatuses: []core.ContainerStatus{{Name: "c1", State: runningState}}, + expectErr: false, + }, + { + name: "feature enabled, restart not allowed by container rule mismatch", + podSpec: core.PodSpec{RestartPolicy: core.RestartPolicyNever, Containers: []core.Container{container1RestartRuleIn42}}, + oldStatuses: []core.ContainerStatus{{Name: "c1", State: terminatedState(1)}}, + newStatuses: []core.ContainerStatus{{Name: "c1", State: runningState}}, + expectErr: true, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.ContainerRestartRules, true) + + errs := ValidateContainerStateTransition(tc.newStatuses, tc.oldStatuses, field.NewPath("field"), tc.podSpec) + + if tc.expectErr && len(errs) == 0 { + t.Errorf("Unexpected success") + } + if !tc.expectErr && len(errs) > 0 { + t.Errorf("Unexpected error(s): %v", errs) + } + }) + } +} diff --git a/pkg/apis/core/zz_generated.deepcopy.go b/pkg/apis/core/zz_generated.deepcopy.go index a062ae98c1f..388c321b8d3 100644 --- a/pkg/apis/core/zz_generated.deepcopy.go +++ b/pkg/apis/core/zz_generated.deepcopy.go @@ -829,6 +829,13 @@ func (in *Container) DeepCopyInto(out *Container) { *out = new(ContainerRestartPolicy) **out = **in } + if in.RestartPolicyRules != nil { + in, out := &in.RestartPolicyRules, &out.RestartPolicyRules + *out = make([]ContainerRestartRule, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } if in.VolumeMounts != nil { in, out := &in.VolumeMounts, &out.VolumeMounts *out = make([]VolumeMount, len(*in)) @@ -932,6 +939,48 @@ func (in *ContainerResizePolicy) DeepCopy() *ContainerResizePolicy { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ContainerRestartRule) DeepCopyInto(out *ContainerRestartRule) { + *out = *in + if in.ExitCodes != nil { + in, out := &in.ExitCodes, &out.ExitCodes + *out = new(ContainerRestartRuleOnExitCodes) + (*in).DeepCopyInto(*out) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ContainerRestartRule. +func (in *ContainerRestartRule) DeepCopy() *ContainerRestartRule { + if in == nil { + return nil + } + out := new(ContainerRestartRule) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ContainerRestartRuleOnExitCodes) DeepCopyInto(out *ContainerRestartRuleOnExitCodes) { + *out = *in + if in.Values != nil { + in, out := &in.Values, &out.Values + *out = make([]int32, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ContainerRestartRuleOnExitCodes. +func (in *ContainerRestartRuleOnExitCodes) DeepCopy() *ContainerRestartRuleOnExitCodes { + if in == nil { + return nil + } + out := new(ContainerRestartRuleOnExitCodes) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *ContainerState) DeepCopyInto(out *ContainerState) { *out = *in @@ -1511,6 +1560,13 @@ func (in *EphemeralContainerCommon) DeepCopyInto(out *EphemeralContainerCommon) *out = new(ContainerRestartPolicy) **out = **in } + if in.RestartPolicyRules != nil { + in, out := &in.RestartPolicyRules, &out.RestartPolicyRules + *out = make([]ContainerRestartRule, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } if in.VolumeMounts != nil { in, out := &in.VolumeMounts, &out.VolumeMounts *out = make([]VolumeMount, len(*in)) diff --git a/pkg/features/kube_features.go b/pkg/features/kube_features.go index 937ce0b0be7..27526fc5d87 100644 --- a/pkg/features/kube_features.go +++ b/pkg/features/kube_features.go @@ -136,6 +136,13 @@ const ( // Enables container Checkpoint support in the kubelet ContainerCheckpoint featuregate.Feature = "ContainerCheckpoint" + // onwer: @yuanwang04 + // kep: https://kep.k8s.io/5307 + // + // Supports container restart policy and container restart policy rules to override the pod restart policy. + // Enable a single container to restart even if the pod has restart policy "Never". + ContainerRestartRules featuregate.Feature = "ContainerRestartRules" + // owner: @sreeram-venkitesh // // Enables configuring custom stop signals for containers from container lifecycle @@ -1131,6 +1138,10 @@ var defaultVersionedKubernetesFeatureGates = map[featuregate.Feature]featuregate {Version: version.MustParse("1.30"), Default: true, PreRelease: featuregate.Beta}, }, + ContainerRestartRules: { + {Version: version.MustParse("1.34"), Default: false, PreRelease: featuregate.Alpha}, + }, + ContainerStopSignals: { {Version: version.MustParse("1.33"), Default: false, PreRelease: featuregate.Alpha}, }, diff --git a/pkg/generated/openapi/zz_generated.openapi.go b/pkg/generated/openapi/zz_generated.openapi.go index 21889c1cf62..3e1ab1f466e 100644 --- a/pkg/generated/openapi/zz_generated.openapi.go +++ b/pkg/generated/openapi/zz_generated.openapi.go @@ -442,6 +442,8 @@ func GetOpenAPIDefinitions(ref common.ReferenceCallback) map[string]common.OpenA "k8s.io/api/core/v1.ContainerImage": schema_k8sio_api_core_v1_ContainerImage(ref), "k8s.io/api/core/v1.ContainerPort": schema_k8sio_api_core_v1_ContainerPort(ref), "k8s.io/api/core/v1.ContainerResizePolicy": schema_k8sio_api_core_v1_ContainerResizePolicy(ref), + "k8s.io/api/core/v1.ContainerRestartRule": schema_k8sio_api_core_v1_ContainerRestartRule(ref), + "k8s.io/api/core/v1.ContainerRestartRuleOnExitCodes": schema_k8sio_api_core_v1_ContainerRestartRuleOnExitCodes(ref), "k8s.io/api/core/v1.ContainerState": schema_k8sio_api_core_v1_ContainerState(ref), "k8s.io/api/core/v1.ContainerStateRunning": schema_k8sio_api_core_v1_ContainerStateRunning(ref), "k8s.io/api/core/v1.ContainerStateTerminated": schema_k8sio_api_core_v1_ContainerStateTerminated(ref), @@ -22285,11 +22287,30 @@ func schema_k8sio_api_core_v1_Container(ref common.ReferenceCallback) common.Ope }, "restartPolicy": { SchemaProps: spec.SchemaProps{ - Description: "RestartPolicy defines the restart behavior of individual containers in a pod. This field may only be set for init containers, and the only allowed value is \"Always\". For non-init containers or when this field is not specified, the restart behavior is defined by the Pod's restart policy and the container type. Setting the RestartPolicy as \"Always\" for the init container will have the following effect: this init container will be continually restarted on exit until all regular containers have terminated. Once all regular containers have completed, all init containers with restartPolicy \"Always\" will be shut down. This lifecycle differs from normal init containers and is often referred to as a \"sidecar\" container. Although this init container still starts in the init container sequence, it does not wait for the container to complete before proceeding to the next init container. Instead, the next init container starts immediately after this init container is started, or after any startupProbe has successfully completed.", + Description: "RestartPolicy defines the restart behavior of individual containers in a pod. This overrides the pod-level restart policy. When this field is not specified, the restart behavior is defined by the Pod's restart policy and the container type. Additionally, setting the RestartPolicy as \"Always\" for the init container will have the following effect: this init container will be continually restarted on exit until all regular containers have terminated. Once all regular containers have completed, all init containers with restartPolicy \"Always\" will be shut down. This lifecycle differs from normal init containers and is often referred to as a \"sidecar\" container. Although this init container still starts in the init container sequence, it does not wait for the container to complete before proceeding to the next init container. Instead, the next init container starts immediately after this init container is started, or after any startupProbe has successfully completed.", Type: []string{"string"}, Format: "", }, }, + "restartPolicyRules": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-list-type": "atomic", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "Represents a list of rules to be checked to determine if the container should be restarted on exit. The rules are evaluated in order. Once a rule matches a container exit condition, the remaining rules are ignored. If no rule matches the container exit condition, the Container-level restart policy determines the whether the container is restarted or not. Constraints on the rules: - At most 20 rules are allowed. - Rules can have the same action. - Identical rules are not forbidden in validations. When rules are specified, container MUST set RestartPolicy explicitly even it if matches the Pod's RestartPolicy.", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("k8s.io/api/core/v1.ContainerRestartRule"), + }, + }, + }, + }, + }, "volumeMounts": { VendorExtensible: spec.VendorExtensible{ Extensions: spec.Extensions{ @@ -22417,7 +22438,7 @@ func schema_k8sio_api_core_v1_Container(ref common.ReferenceCallback) common.Ope }, }, Dependencies: []string{ - "k8s.io/api/core/v1.ContainerPort", "k8s.io/api/core/v1.ContainerResizePolicy", "k8s.io/api/core/v1.EnvFromSource", "k8s.io/api/core/v1.EnvVar", "k8s.io/api/core/v1.Lifecycle", "k8s.io/api/core/v1.Probe", "k8s.io/api/core/v1.ResourceRequirements", "k8s.io/api/core/v1.SecurityContext", "k8s.io/api/core/v1.VolumeDevice", "k8s.io/api/core/v1.VolumeMount"}, + "k8s.io/api/core/v1.ContainerPort", "k8s.io/api/core/v1.ContainerResizePolicy", "k8s.io/api/core/v1.ContainerRestartRule", "k8s.io/api/core/v1.EnvFromSource", "k8s.io/api/core/v1.EnvVar", "k8s.io/api/core/v1.Lifecycle", "k8s.io/api/core/v1.Probe", "k8s.io/api/core/v1.ResourceRequirements", "k8s.io/api/core/v1.SecurityContext", "k8s.io/api/core/v1.VolumeDevice", "k8s.io/api/core/v1.VolumeMount"}, } } @@ -22543,6 +22564,76 @@ func schema_k8sio_api_core_v1_ContainerResizePolicy(ref common.ReferenceCallback } } +func schema_k8sio_api_core_v1_ContainerRestartRule(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "ContainerRestartRule describes how a container exit is handled.", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "action": { + SchemaProps: spec.SchemaProps{ + Description: "Specifies the action taken on a container exit if the requirements are satisfied. The only possible value is \"Restart\" to restart the container.", + Type: []string{"string"}, + Format: "", + }, + }, + "exitCodes": { + SchemaProps: spec.SchemaProps{ + Description: "Represents the exit codes to check on container exits.", + Ref: ref("k8s.io/api/core/v1.ContainerRestartRuleOnExitCodes"), + }, + }, + }, + Required: []string{"action"}, + }, + }, + Dependencies: []string{ + "k8s.io/api/core/v1.ContainerRestartRuleOnExitCodes"}, + } +} + +func schema_k8sio_api_core_v1_ContainerRestartRuleOnExitCodes(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "ContainerRestartRuleOnExitCodes describes the condition for handling an exited container based on its exit codes.", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "operator": { + SchemaProps: spec.SchemaProps{ + Description: "Represents the relationship between the container exit code(s) and the specified values. Possible values are: - In: the requirement is satisfied if the container exit code is in the\n set of specified values.\n- NotIn: the requirement is satisfied if the container exit code is\n not in the set of specified values.", + Type: []string{"string"}, + Format: "", + }, + }, + "values": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-list-type": "set", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "Specifies the set of values to check for container exit codes. At most 255 elements are allowed.", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: 0, + Type: []string{"integer"}, + Format: "int32", + }, + }, + }, + }, + }, + }, + Required: []string{"operator"}, + }, + }, + } +} + func schema_k8sio_api_core_v1_ContainerState(ref common.ReferenceCallback) common.OpenAPIDefinition { return common.OpenAPIDefinition{ Schema: spec.Schema{ @@ -23600,11 +23691,30 @@ func schema_k8sio_api_core_v1_EphemeralContainer(ref common.ReferenceCallback) c }, "restartPolicy": { SchemaProps: spec.SchemaProps{ - Description: "Restart policy for the container to manage the restart behavior of each container within a pod. This may only be set for init containers. You cannot set this field on ephemeral containers.", + Description: "Restart policy for the container to manage the restart behavior of each container within a pod. You cannot set this field on ephemeral containers.", Type: []string{"string"}, Format: "", }, }, + "restartPolicyRules": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-list-type": "atomic", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "Represents a list of rules to be checked to determine if the container should be restarted on exit. You cannot set this field on ephemeral containers.", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("k8s.io/api/core/v1.ContainerRestartRule"), + }, + }, + }, + }, + }, "volumeMounts": { VendorExtensible: spec.VendorExtensible{ Extensions: spec.Extensions{ @@ -23739,7 +23849,7 @@ func schema_k8sio_api_core_v1_EphemeralContainer(ref common.ReferenceCallback) c }, }, Dependencies: []string{ - "k8s.io/api/core/v1.ContainerPort", "k8s.io/api/core/v1.ContainerResizePolicy", "k8s.io/api/core/v1.EnvFromSource", "k8s.io/api/core/v1.EnvVar", "k8s.io/api/core/v1.Lifecycle", "k8s.io/api/core/v1.Probe", "k8s.io/api/core/v1.ResourceRequirements", "k8s.io/api/core/v1.SecurityContext", "k8s.io/api/core/v1.VolumeDevice", "k8s.io/api/core/v1.VolumeMount"}, + "k8s.io/api/core/v1.ContainerPort", "k8s.io/api/core/v1.ContainerResizePolicy", "k8s.io/api/core/v1.ContainerRestartRule", "k8s.io/api/core/v1.EnvFromSource", "k8s.io/api/core/v1.EnvVar", "k8s.io/api/core/v1.Lifecycle", "k8s.io/api/core/v1.Probe", "k8s.io/api/core/v1.ResourceRequirements", "k8s.io/api/core/v1.SecurityContext", "k8s.io/api/core/v1.VolumeDevice", "k8s.io/api/core/v1.VolumeMount"}, } } @@ -23908,11 +24018,30 @@ func schema_k8sio_api_core_v1_EphemeralContainerCommon(ref common.ReferenceCallb }, "restartPolicy": { SchemaProps: spec.SchemaProps{ - Description: "Restart policy for the container to manage the restart behavior of each container within a pod. This may only be set for init containers. You cannot set this field on ephemeral containers.", + Description: "Restart policy for the container to manage the restart behavior of each container within a pod. You cannot set this field on ephemeral containers.", Type: []string{"string"}, Format: "", }, }, + "restartPolicyRules": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-list-type": "atomic", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "Represents a list of rules to be checked to determine if the container should be restarted on exit. You cannot set this field on ephemeral containers.", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("k8s.io/api/core/v1.ContainerRestartRule"), + }, + }, + }, + }, + }, "volumeMounts": { VendorExtensible: spec.VendorExtensible{ Extensions: spec.Extensions{ @@ -24040,7 +24169,7 @@ func schema_k8sio_api_core_v1_EphemeralContainerCommon(ref common.ReferenceCallb }, }, Dependencies: []string{ - "k8s.io/api/core/v1.ContainerPort", "k8s.io/api/core/v1.ContainerResizePolicy", "k8s.io/api/core/v1.EnvFromSource", "k8s.io/api/core/v1.EnvVar", "k8s.io/api/core/v1.Lifecycle", "k8s.io/api/core/v1.Probe", "k8s.io/api/core/v1.ResourceRequirements", "k8s.io/api/core/v1.SecurityContext", "k8s.io/api/core/v1.VolumeDevice", "k8s.io/api/core/v1.VolumeMount"}, + "k8s.io/api/core/v1.ContainerPort", "k8s.io/api/core/v1.ContainerResizePolicy", "k8s.io/api/core/v1.ContainerRestartRule", "k8s.io/api/core/v1.EnvFromSource", "k8s.io/api/core/v1.EnvVar", "k8s.io/api/core/v1.Lifecycle", "k8s.io/api/core/v1.Probe", "k8s.io/api/core/v1.ResourceRequirements", "k8s.io/api/core/v1.SecurityContext", "k8s.io/api/core/v1.VolumeDevice", "k8s.io/api/core/v1.VolumeMount"}, } } 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 2ece4c209cf..7e7e7081100 100644 --- a/staging/src/k8s.io/api/core/v1/generated.pb.go +++ b/staging/src/k8s.io/api/core/v1/generated.pb.go @@ -945,10 +945,66 @@ func (m *ContainerResizePolicy) XXX_DiscardUnknown() { var xxx_messageInfo_ContainerResizePolicy proto.InternalMessageInfo +func (m *ContainerRestartRule) Reset() { *m = ContainerRestartRule{} } +func (*ContainerRestartRule) ProtoMessage() {} +func (*ContainerRestartRule) Descriptor() ([]byte, []int) { + return fileDescriptor_6c07b07c062484ab, []int{32} +} +func (m *ContainerRestartRule) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ContainerRestartRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ContainerRestartRule) XXX_Merge(src proto.Message) { + xxx_messageInfo_ContainerRestartRule.Merge(m, src) +} +func (m *ContainerRestartRule) XXX_Size() int { + return m.Size() +} +func (m *ContainerRestartRule) XXX_DiscardUnknown() { + xxx_messageInfo_ContainerRestartRule.DiscardUnknown(m) +} + +var xxx_messageInfo_ContainerRestartRule proto.InternalMessageInfo + +func (m *ContainerRestartRuleOnExitCodes) Reset() { *m = ContainerRestartRuleOnExitCodes{} } +func (*ContainerRestartRuleOnExitCodes) ProtoMessage() {} +func (*ContainerRestartRuleOnExitCodes) Descriptor() ([]byte, []int) { + return fileDescriptor_6c07b07c062484ab, []int{33} +} +func (m *ContainerRestartRuleOnExitCodes) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ContainerRestartRuleOnExitCodes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ContainerRestartRuleOnExitCodes) XXX_Merge(src proto.Message) { + xxx_messageInfo_ContainerRestartRuleOnExitCodes.Merge(m, src) +} +func (m *ContainerRestartRuleOnExitCodes) XXX_Size() int { + return m.Size() +} +func (m *ContainerRestartRuleOnExitCodes) XXX_DiscardUnknown() { + xxx_messageInfo_ContainerRestartRuleOnExitCodes.DiscardUnknown(m) +} + +var xxx_messageInfo_ContainerRestartRuleOnExitCodes proto.InternalMessageInfo + func (m *ContainerState) Reset() { *m = ContainerState{} } func (*ContainerState) ProtoMessage() {} func (*ContainerState) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{32} + return fileDescriptor_6c07b07c062484ab, []int{34} } func (m *ContainerState) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -976,7 +1032,7 @@ var xxx_messageInfo_ContainerState proto.InternalMessageInfo func (m *ContainerStateRunning) Reset() { *m = ContainerStateRunning{} } func (*ContainerStateRunning) ProtoMessage() {} func (*ContainerStateRunning) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{33} + return fileDescriptor_6c07b07c062484ab, []int{35} } func (m *ContainerStateRunning) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1004,7 +1060,7 @@ var xxx_messageInfo_ContainerStateRunning proto.InternalMessageInfo func (m *ContainerStateTerminated) Reset() { *m = ContainerStateTerminated{} } func (*ContainerStateTerminated) ProtoMessage() {} func (*ContainerStateTerminated) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{34} + return fileDescriptor_6c07b07c062484ab, []int{36} } func (m *ContainerStateTerminated) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1032,7 +1088,7 @@ var xxx_messageInfo_ContainerStateTerminated proto.InternalMessageInfo func (m *ContainerStateWaiting) Reset() { *m = ContainerStateWaiting{} } func (*ContainerStateWaiting) ProtoMessage() {} func (*ContainerStateWaiting) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{35} + return fileDescriptor_6c07b07c062484ab, []int{37} } func (m *ContainerStateWaiting) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1060,7 +1116,7 @@ var xxx_messageInfo_ContainerStateWaiting proto.InternalMessageInfo func (m *ContainerStatus) Reset() { *m = ContainerStatus{} } func (*ContainerStatus) ProtoMessage() {} func (*ContainerStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{36} + return fileDescriptor_6c07b07c062484ab, []int{38} } func (m *ContainerStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1088,7 +1144,7 @@ var xxx_messageInfo_ContainerStatus proto.InternalMessageInfo func (m *ContainerUser) Reset() { *m = ContainerUser{} } func (*ContainerUser) ProtoMessage() {} func (*ContainerUser) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{37} + return fileDescriptor_6c07b07c062484ab, []int{39} } func (m *ContainerUser) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1116,7 +1172,7 @@ var xxx_messageInfo_ContainerUser proto.InternalMessageInfo func (m *DaemonEndpoint) Reset() { *m = DaemonEndpoint{} } func (*DaemonEndpoint) ProtoMessage() {} func (*DaemonEndpoint) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{38} + return fileDescriptor_6c07b07c062484ab, []int{40} } func (m *DaemonEndpoint) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1144,7 +1200,7 @@ var xxx_messageInfo_DaemonEndpoint proto.InternalMessageInfo func (m *DownwardAPIProjection) Reset() { *m = DownwardAPIProjection{} } func (*DownwardAPIProjection) ProtoMessage() {} func (*DownwardAPIProjection) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{39} + return fileDescriptor_6c07b07c062484ab, []int{41} } func (m *DownwardAPIProjection) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1172,7 +1228,7 @@ var xxx_messageInfo_DownwardAPIProjection proto.InternalMessageInfo func (m *DownwardAPIVolumeFile) Reset() { *m = DownwardAPIVolumeFile{} } func (*DownwardAPIVolumeFile) ProtoMessage() {} func (*DownwardAPIVolumeFile) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{40} + return fileDescriptor_6c07b07c062484ab, []int{42} } func (m *DownwardAPIVolumeFile) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1200,7 +1256,7 @@ var xxx_messageInfo_DownwardAPIVolumeFile proto.InternalMessageInfo func (m *DownwardAPIVolumeSource) Reset() { *m = DownwardAPIVolumeSource{} } func (*DownwardAPIVolumeSource) ProtoMessage() {} func (*DownwardAPIVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{41} + return fileDescriptor_6c07b07c062484ab, []int{43} } func (m *DownwardAPIVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1228,7 +1284,7 @@ var xxx_messageInfo_DownwardAPIVolumeSource proto.InternalMessageInfo func (m *EmptyDirVolumeSource) Reset() { *m = EmptyDirVolumeSource{} } func (*EmptyDirVolumeSource) ProtoMessage() {} func (*EmptyDirVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{42} + return fileDescriptor_6c07b07c062484ab, []int{44} } func (m *EmptyDirVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1256,7 +1312,7 @@ var xxx_messageInfo_EmptyDirVolumeSource proto.InternalMessageInfo func (m *EndpointAddress) Reset() { *m = EndpointAddress{} } func (*EndpointAddress) ProtoMessage() {} func (*EndpointAddress) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{43} + return fileDescriptor_6c07b07c062484ab, []int{45} } func (m *EndpointAddress) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1284,7 +1340,7 @@ var xxx_messageInfo_EndpointAddress proto.InternalMessageInfo func (m *EndpointPort) Reset() { *m = EndpointPort{} } func (*EndpointPort) ProtoMessage() {} func (*EndpointPort) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{44} + return fileDescriptor_6c07b07c062484ab, []int{46} } func (m *EndpointPort) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1312,7 +1368,7 @@ var xxx_messageInfo_EndpointPort proto.InternalMessageInfo func (m *EndpointSubset) Reset() { *m = EndpointSubset{} } func (*EndpointSubset) ProtoMessage() {} func (*EndpointSubset) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{45} + return fileDescriptor_6c07b07c062484ab, []int{47} } func (m *EndpointSubset) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1340,7 +1396,7 @@ var xxx_messageInfo_EndpointSubset proto.InternalMessageInfo func (m *Endpoints) Reset() { *m = Endpoints{} } func (*Endpoints) ProtoMessage() {} func (*Endpoints) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{46} + return fileDescriptor_6c07b07c062484ab, []int{48} } func (m *Endpoints) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1368,7 +1424,7 @@ var xxx_messageInfo_Endpoints proto.InternalMessageInfo func (m *EndpointsList) Reset() { *m = EndpointsList{} } func (*EndpointsList) ProtoMessage() {} func (*EndpointsList) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{47} + return fileDescriptor_6c07b07c062484ab, []int{49} } func (m *EndpointsList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1396,7 +1452,7 @@ var xxx_messageInfo_EndpointsList proto.InternalMessageInfo func (m *EnvFromSource) Reset() { *m = EnvFromSource{} } func (*EnvFromSource) ProtoMessage() {} func (*EnvFromSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{48} + return fileDescriptor_6c07b07c062484ab, []int{50} } func (m *EnvFromSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1424,7 +1480,7 @@ var xxx_messageInfo_EnvFromSource proto.InternalMessageInfo func (m *EnvVar) Reset() { *m = EnvVar{} } func (*EnvVar) ProtoMessage() {} func (*EnvVar) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{49} + return fileDescriptor_6c07b07c062484ab, []int{51} } func (m *EnvVar) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1452,7 +1508,7 @@ var xxx_messageInfo_EnvVar proto.InternalMessageInfo func (m *EnvVarSource) Reset() { *m = EnvVarSource{} } func (*EnvVarSource) ProtoMessage() {} func (*EnvVarSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{50} + return fileDescriptor_6c07b07c062484ab, []int{52} } func (m *EnvVarSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1480,7 +1536,7 @@ var xxx_messageInfo_EnvVarSource proto.InternalMessageInfo func (m *EphemeralContainer) Reset() { *m = EphemeralContainer{} } func (*EphemeralContainer) ProtoMessage() {} func (*EphemeralContainer) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{51} + return fileDescriptor_6c07b07c062484ab, []int{53} } func (m *EphemeralContainer) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1508,7 +1564,7 @@ var xxx_messageInfo_EphemeralContainer proto.InternalMessageInfo func (m *EphemeralContainerCommon) Reset() { *m = EphemeralContainerCommon{} } func (*EphemeralContainerCommon) ProtoMessage() {} func (*EphemeralContainerCommon) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{52} + return fileDescriptor_6c07b07c062484ab, []int{54} } func (m *EphemeralContainerCommon) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1536,7 +1592,7 @@ var xxx_messageInfo_EphemeralContainerCommon proto.InternalMessageInfo func (m *EphemeralVolumeSource) Reset() { *m = EphemeralVolumeSource{} } func (*EphemeralVolumeSource) ProtoMessage() {} func (*EphemeralVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{53} + return fileDescriptor_6c07b07c062484ab, []int{55} } func (m *EphemeralVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1564,7 +1620,7 @@ var xxx_messageInfo_EphemeralVolumeSource proto.InternalMessageInfo func (m *Event) Reset() { *m = Event{} } func (*Event) ProtoMessage() {} func (*Event) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{54} + return fileDescriptor_6c07b07c062484ab, []int{56} } func (m *Event) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1592,7 +1648,7 @@ var xxx_messageInfo_Event proto.InternalMessageInfo func (m *EventList) Reset() { *m = EventList{} } func (*EventList) ProtoMessage() {} func (*EventList) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{55} + return fileDescriptor_6c07b07c062484ab, []int{57} } func (m *EventList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1620,7 +1676,7 @@ var xxx_messageInfo_EventList proto.InternalMessageInfo func (m *EventSeries) Reset() { *m = EventSeries{} } func (*EventSeries) ProtoMessage() {} func (*EventSeries) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{56} + return fileDescriptor_6c07b07c062484ab, []int{58} } func (m *EventSeries) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1648,7 +1704,7 @@ var xxx_messageInfo_EventSeries proto.InternalMessageInfo func (m *EventSource) Reset() { *m = EventSource{} } func (*EventSource) ProtoMessage() {} func (*EventSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{57} + return fileDescriptor_6c07b07c062484ab, []int{59} } func (m *EventSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1676,7 +1732,7 @@ var xxx_messageInfo_EventSource proto.InternalMessageInfo func (m *ExecAction) Reset() { *m = ExecAction{} } func (*ExecAction) ProtoMessage() {} func (*ExecAction) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{58} + return fileDescriptor_6c07b07c062484ab, []int{60} } func (m *ExecAction) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1704,7 +1760,7 @@ var xxx_messageInfo_ExecAction proto.InternalMessageInfo func (m *FCVolumeSource) Reset() { *m = FCVolumeSource{} } func (*FCVolumeSource) ProtoMessage() {} func (*FCVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{59} + return fileDescriptor_6c07b07c062484ab, []int{61} } func (m *FCVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1732,7 +1788,7 @@ var xxx_messageInfo_FCVolumeSource proto.InternalMessageInfo func (m *FileKeySelector) Reset() { *m = FileKeySelector{} } func (*FileKeySelector) ProtoMessage() {} func (*FileKeySelector) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{60} + return fileDescriptor_6c07b07c062484ab, []int{62} } func (m *FileKeySelector) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1760,7 +1816,7 @@ var xxx_messageInfo_FileKeySelector proto.InternalMessageInfo func (m *FlexPersistentVolumeSource) Reset() { *m = FlexPersistentVolumeSource{} } func (*FlexPersistentVolumeSource) ProtoMessage() {} func (*FlexPersistentVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{61} + return fileDescriptor_6c07b07c062484ab, []int{63} } func (m *FlexPersistentVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1788,7 +1844,7 @@ var xxx_messageInfo_FlexPersistentVolumeSource proto.InternalMessageInfo func (m *FlexVolumeSource) Reset() { *m = FlexVolumeSource{} } func (*FlexVolumeSource) ProtoMessage() {} func (*FlexVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{62} + return fileDescriptor_6c07b07c062484ab, []int{64} } func (m *FlexVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1816,7 +1872,7 @@ var xxx_messageInfo_FlexVolumeSource proto.InternalMessageInfo func (m *FlockerVolumeSource) Reset() { *m = FlockerVolumeSource{} } func (*FlockerVolumeSource) ProtoMessage() {} func (*FlockerVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{63} + return fileDescriptor_6c07b07c062484ab, []int{65} } func (m *FlockerVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1844,7 +1900,7 @@ var xxx_messageInfo_FlockerVolumeSource proto.InternalMessageInfo func (m *GCEPersistentDiskVolumeSource) Reset() { *m = GCEPersistentDiskVolumeSource{} } func (*GCEPersistentDiskVolumeSource) ProtoMessage() {} func (*GCEPersistentDiskVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{64} + return fileDescriptor_6c07b07c062484ab, []int{66} } func (m *GCEPersistentDiskVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1872,7 +1928,7 @@ var xxx_messageInfo_GCEPersistentDiskVolumeSource proto.InternalMessageInfo func (m *GRPCAction) Reset() { *m = GRPCAction{} } func (*GRPCAction) ProtoMessage() {} func (*GRPCAction) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{65} + return fileDescriptor_6c07b07c062484ab, []int{67} } func (m *GRPCAction) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1900,7 +1956,7 @@ var xxx_messageInfo_GRPCAction proto.InternalMessageInfo func (m *GitRepoVolumeSource) Reset() { *m = GitRepoVolumeSource{} } func (*GitRepoVolumeSource) ProtoMessage() {} func (*GitRepoVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{66} + return fileDescriptor_6c07b07c062484ab, []int{68} } func (m *GitRepoVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1928,7 +1984,7 @@ var xxx_messageInfo_GitRepoVolumeSource proto.InternalMessageInfo func (m *GlusterfsPersistentVolumeSource) Reset() { *m = GlusterfsPersistentVolumeSource{} } func (*GlusterfsPersistentVolumeSource) ProtoMessage() {} func (*GlusterfsPersistentVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{67} + return fileDescriptor_6c07b07c062484ab, []int{69} } func (m *GlusterfsPersistentVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1956,7 +2012,7 @@ var xxx_messageInfo_GlusterfsPersistentVolumeSource proto.InternalMessageInfo func (m *GlusterfsVolumeSource) Reset() { *m = GlusterfsVolumeSource{} } func (*GlusterfsVolumeSource) ProtoMessage() {} func (*GlusterfsVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{68} + return fileDescriptor_6c07b07c062484ab, []int{70} } func (m *GlusterfsVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1984,7 +2040,7 @@ var xxx_messageInfo_GlusterfsVolumeSource proto.InternalMessageInfo func (m *HTTPGetAction) Reset() { *m = HTTPGetAction{} } func (*HTTPGetAction) ProtoMessage() {} func (*HTTPGetAction) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{69} + return fileDescriptor_6c07b07c062484ab, []int{71} } func (m *HTTPGetAction) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2012,7 +2068,7 @@ var xxx_messageInfo_HTTPGetAction proto.InternalMessageInfo func (m *HTTPHeader) Reset() { *m = HTTPHeader{} } func (*HTTPHeader) ProtoMessage() {} func (*HTTPHeader) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{70} + return fileDescriptor_6c07b07c062484ab, []int{72} } func (m *HTTPHeader) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2040,7 +2096,7 @@ var xxx_messageInfo_HTTPHeader proto.InternalMessageInfo func (m *HostAlias) Reset() { *m = HostAlias{} } func (*HostAlias) ProtoMessage() {} func (*HostAlias) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{71} + return fileDescriptor_6c07b07c062484ab, []int{73} } func (m *HostAlias) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2068,7 +2124,7 @@ var xxx_messageInfo_HostAlias proto.InternalMessageInfo func (m *HostIP) Reset() { *m = HostIP{} } func (*HostIP) ProtoMessage() {} func (*HostIP) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{72} + return fileDescriptor_6c07b07c062484ab, []int{74} } func (m *HostIP) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2096,7 +2152,7 @@ var xxx_messageInfo_HostIP proto.InternalMessageInfo func (m *HostPathVolumeSource) Reset() { *m = HostPathVolumeSource{} } func (*HostPathVolumeSource) ProtoMessage() {} func (*HostPathVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{73} + return fileDescriptor_6c07b07c062484ab, []int{75} } func (m *HostPathVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2124,7 +2180,7 @@ var xxx_messageInfo_HostPathVolumeSource proto.InternalMessageInfo func (m *ISCSIPersistentVolumeSource) Reset() { *m = ISCSIPersistentVolumeSource{} } func (*ISCSIPersistentVolumeSource) ProtoMessage() {} func (*ISCSIPersistentVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{74} + return fileDescriptor_6c07b07c062484ab, []int{76} } func (m *ISCSIPersistentVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2152,7 +2208,7 @@ var xxx_messageInfo_ISCSIPersistentVolumeSource proto.InternalMessageInfo func (m *ISCSIVolumeSource) Reset() { *m = ISCSIVolumeSource{} } func (*ISCSIVolumeSource) ProtoMessage() {} func (*ISCSIVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{75} + return fileDescriptor_6c07b07c062484ab, []int{77} } func (m *ISCSIVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2180,7 +2236,7 @@ var xxx_messageInfo_ISCSIVolumeSource proto.InternalMessageInfo func (m *ImageVolumeSource) Reset() { *m = ImageVolumeSource{} } func (*ImageVolumeSource) ProtoMessage() {} func (*ImageVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{76} + return fileDescriptor_6c07b07c062484ab, []int{78} } func (m *ImageVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2208,7 +2264,7 @@ var xxx_messageInfo_ImageVolumeSource proto.InternalMessageInfo func (m *KeyToPath) Reset() { *m = KeyToPath{} } func (*KeyToPath) ProtoMessage() {} func (*KeyToPath) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{77} + return fileDescriptor_6c07b07c062484ab, []int{79} } func (m *KeyToPath) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2236,7 +2292,7 @@ var xxx_messageInfo_KeyToPath proto.InternalMessageInfo func (m *Lifecycle) Reset() { *m = Lifecycle{} } func (*Lifecycle) ProtoMessage() {} func (*Lifecycle) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{78} + return fileDescriptor_6c07b07c062484ab, []int{80} } func (m *Lifecycle) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2264,7 +2320,7 @@ var xxx_messageInfo_Lifecycle proto.InternalMessageInfo func (m *LifecycleHandler) Reset() { *m = LifecycleHandler{} } func (*LifecycleHandler) ProtoMessage() {} func (*LifecycleHandler) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{79} + return fileDescriptor_6c07b07c062484ab, []int{81} } func (m *LifecycleHandler) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2292,7 +2348,7 @@ var xxx_messageInfo_LifecycleHandler proto.InternalMessageInfo func (m *LimitRange) Reset() { *m = LimitRange{} } func (*LimitRange) ProtoMessage() {} func (*LimitRange) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{80} + return fileDescriptor_6c07b07c062484ab, []int{82} } func (m *LimitRange) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2320,7 +2376,7 @@ var xxx_messageInfo_LimitRange proto.InternalMessageInfo func (m *LimitRangeItem) Reset() { *m = LimitRangeItem{} } func (*LimitRangeItem) ProtoMessage() {} func (*LimitRangeItem) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{81} + return fileDescriptor_6c07b07c062484ab, []int{83} } func (m *LimitRangeItem) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2348,7 +2404,7 @@ var xxx_messageInfo_LimitRangeItem proto.InternalMessageInfo func (m *LimitRangeList) Reset() { *m = LimitRangeList{} } func (*LimitRangeList) ProtoMessage() {} func (*LimitRangeList) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{82} + return fileDescriptor_6c07b07c062484ab, []int{84} } func (m *LimitRangeList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2376,7 +2432,7 @@ var xxx_messageInfo_LimitRangeList proto.InternalMessageInfo func (m *LimitRangeSpec) Reset() { *m = LimitRangeSpec{} } func (*LimitRangeSpec) ProtoMessage() {} func (*LimitRangeSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{83} + return fileDescriptor_6c07b07c062484ab, []int{85} } func (m *LimitRangeSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2404,7 +2460,7 @@ var xxx_messageInfo_LimitRangeSpec proto.InternalMessageInfo func (m *LinuxContainerUser) Reset() { *m = LinuxContainerUser{} } func (*LinuxContainerUser) ProtoMessage() {} func (*LinuxContainerUser) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{84} + return fileDescriptor_6c07b07c062484ab, []int{86} } func (m *LinuxContainerUser) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2432,7 +2488,7 @@ var xxx_messageInfo_LinuxContainerUser proto.InternalMessageInfo func (m *List) Reset() { *m = List{} } func (*List) ProtoMessage() {} func (*List) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{85} + return fileDescriptor_6c07b07c062484ab, []int{87} } func (m *List) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2460,7 +2516,7 @@ var xxx_messageInfo_List proto.InternalMessageInfo func (m *LoadBalancerIngress) Reset() { *m = LoadBalancerIngress{} } func (*LoadBalancerIngress) ProtoMessage() {} func (*LoadBalancerIngress) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{86} + return fileDescriptor_6c07b07c062484ab, []int{88} } func (m *LoadBalancerIngress) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2488,7 +2544,7 @@ var xxx_messageInfo_LoadBalancerIngress proto.InternalMessageInfo func (m *LoadBalancerStatus) Reset() { *m = LoadBalancerStatus{} } func (*LoadBalancerStatus) ProtoMessage() {} func (*LoadBalancerStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{87} + return fileDescriptor_6c07b07c062484ab, []int{89} } func (m *LoadBalancerStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2516,7 +2572,7 @@ var xxx_messageInfo_LoadBalancerStatus proto.InternalMessageInfo func (m *LocalObjectReference) Reset() { *m = LocalObjectReference{} } func (*LocalObjectReference) ProtoMessage() {} func (*LocalObjectReference) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{88} + return fileDescriptor_6c07b07c062484ab, []int{90} } func (m *LocalObjectReference) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2544,7 +2600,7 @@ var xxx_messageInfo_LocalObjectReference proto.InternalMessageInfo func (m *LocalVolumeSource) Reset() { *m = LocalVolumeSource{} } func (*LocalVolumeSource) ProtoMessage() {} func (*LocalVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{89} + return fileDescriptor_6c07b07c062484ab, []int{91} } func (m *LocalVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2572,7 +2628,7 @@ var xxx_messageInfo_LocalVolumeSource proto.InternalMessageInfo func (m *ModifyVolumeStatus) Reset() { *m = ModifyVolumeStatus{} } func (*ModifyVolumeStatus) ProtoMessage() {} func (*ModifyVolumeStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{90} + return fileDescriptor_6c07b07c062484ab, []int{92} } func (m *ModifyVolumeStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2600,7 +2656,7 @@ var xxx_messageInfo_ModifyVolumeStatus proto.InternalMessageInfo func (m *NFSVolumeSource) Reset() { *m = NFSVolumeSource{} } func (*NFSVolumeSource) ProtoMessage() {} func (*NFSVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{91} + return fileDescriptor_6c07b07c062484ab, []int{93} } func (m *NFSVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2628,7 +2684,7 @@ var xxx_messageInfo_NFSVolumeSource proto.InternalMessageInfo func (m *Namespace) Reset() { *m = Namespace{} } func (*Namespace) ProtoMessage() {} func (*Namespace) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{92} + return fileDescriptor_6c07b07c062484ab, []int{94} } func (m *Namespace) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2656,7 +2712,7 @@ var xxx_messageInfo_Namespace proto.InternalMessageInfo func (m *NamespaceCondition) Reset() { *m = NamespaceCondition{} } func (*NamespaceCondition) ProtoMessage() {} func (*NamespaceCondition) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{93} + return fileDescriptor_6c07b07c062484ab, []int{95} } func (m *NamespaceCondition) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2684,7 +2740,7 @@ var xxx_messageInfo_NamespaceCondition proto.InternalMessageInfo func (m *NamespaceList) Reset() { *m = NamespaceList{} } func (*NamespaceList) ProtoMessage() {} func (*NamespaceList) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{94} + return fileDescriptor_6c07b07c062484ab, []int{96} } func (m *NamespaceList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2712,7 +2768,7 @@ var xxx_messageInfo_NamespaceList proto.InternalMessageInfo func (m *NamespaceSpec) Reset() { *m = NamespaceSpec{} } func (*NamespaceSpec) ProtoMessage() {} func (*NamespaceSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{95} + return fileDescriptor_6c07b07c062484ab, []int{97} } func (m *NamespaceSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2740,7 +2796,7 @@ var xxx_messageInfo_NamespaceSpec proto.InternalMessageInfo func (m *NamespaceStatus) Reset() { *m = NamespaceStatus{} } func (*NamespaceStatus) ProtoMessage() {} func (*NamespaceStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{96} + return fileDescriptor_6c07b07c062484ab, []int{98} } func (m *NamespaceStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2768,7 +2824,7 @@ var xxx_messageInfo_NamespaceStatus proto.InternalMessageInfo func (m *Node) Reset() { *m = Node{} } func (*Node) ProtoMessage() {} func (*Node) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{97} + return fileDescriptor_6c07b07c062484ab, []int{99} } func (m *Node) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2796,7 +2852,7 @@ var xxx_messageInfo_Node proto.InternalMessageInfo func (m *NodeAddress) Reset() { *m = NodeAddress{} } func (*NodeAddress) ProtoMessage() {} func (*NodeAddress) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{98} + return fileDescriptor_6c07b07c062484ab, []int{100} } func (m *NodeAddress) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2824,7 +2880,7 @@ var xxx_messageInfo_NodeAddress proto.InternalMessageInfo func (m *NodeAffinity) Reset() { *m = NodeAffinity{} } func (*NodeAffinity) ProtoMessage() {} func (*NodeAffinity) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{99} + return fileDescriptor_6c07b07c062484ab, []int{101} } func (m *NodeAffinity) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2852,7 +2908,7 @@ var xxx_messageInfo_NodeAffinity proto.InternalMessageInfo func (m *NodeCondition) Reset() { *m = NodeCondition{} } func (*NodeCondition) ProtoMessage() {} func (*NodeCondition) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{100} + return fileDescriptor_6c07b07c062484ab, []int{102} } func (m *NodeCondition) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2880,7 +2936,7 @@ var xxx_messageInfo_NodeCondition proto.InternalMessageInfo func (m *NodeConfigSource) Reset() { *m = NodeConfigSource{} } func (*NodeConfigSource) ProtoMessage() {} func (*NodeConfigSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{101} + return fileDescriptor_6c07b07c062484ab, []int{103} } func (m *NodeConfigSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2908,7 +2964,7 @@ var xxx_messageInfo_NodeConfigSource proto.InternalMessageInfo func (m *NodeConfigStatus) Reset() { *m = NodeConfigStatus{} } func (*NodeConfigStatus) ProtoMessage() {} func (*NodeConfigStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{102} + return fileDescriptor_6c07b07c062484ab, []int{104} } func (m *NodeConfigStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2936,7 +2992,7 @@ var xxx_messageInfo_NodeConfigStatus proto.InternalMessageInfo func (m *NodeDaemonEndpoints) Reset() { *m = NodeDaemonEndpoints{} } func (*NodeDaemonEndpoints) ProtoMessage() {} func (*NodeDaemonEndpoints) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{103} + return fileDescriptor_6c07b07c062484ab, []int{105} } func (m *NodeDaemonEndpoints) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2964,7 +3020,7 @@ var xxx_messageInfo_NodeDaemonEndpoints proto.InternalMessageInfo func (m *NodeFeatures) Reset() { *m = NodeFeatures{} } func (*NodeFeatures) ProtoMessage() {} func (*NodeFeatures) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{104} + return fileDescriptor_6c07b07c062484ab, []int{106} } func (m *NodeFeatures) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2992,7 +3048,7 @@ var xxx_messageInfo_NodeFeatures proto.InternalMessageInfo func (m *NodeList) Reset() { *m = NodeList{} } func (*NodeList) ProtoMessage() {} func (*NodeList) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{105} + return fileDescriptor_6c07b07c062484ab, []int{107} } func (m *NodeList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3020,7 +3076,7 @@ var xxx_messageInfo_NodeList proto.InternalMessageInfo func (m *NodeProxyOptions) Reset() { *m = NodeProxyOptions{} } func (*NodeProxyOptions) ProtoMessage() {} func (*NodeProxyOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{106} + return fileDescriptor_6c07b07c062484ab, []int{108} } func (m *NodeProxyOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3048,7 +3104,7 @@ var xxx_messageInfo_NodeProxyOptions proto.InternalMessageInfo func (m *NodeRuntimeHandler) Reset() { *m = NodeRuntimeHandler{} } func (*NodeRuntimeHandler) ProtoMessage() {} func (*NodeRuntimeHandler) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{107} + return fileDescriptor_6c07b07c062484ab, []int{109} } func (m *NodeRuntimeHandler) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3076,7 +3132,7 @@ var xxx_messageInfo_NodeRuntimeHandler proto.InternalMessageInfo func (m *NodeRuntimeHandlerFeatures) Reset() { *m = NodeRuntimeHandlerFeatures{} } func (*NodeRuntimeHandlerFeatures) ProtoMessage() {} func (*NodeRuntimeHandlerFeatures) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{108} + return fileDescriptor_6c07b07c062484ab, []int{110} } func (m *NodeRuntimeHandlerFeatures) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3104,7 +3160,7 @@ var xxx_messageInfo_NodeRuntimeHandlerFeatures proto.InternalMessageInfo func (m *NodeSelector) Reset() { *m = NodeSelector{} } func (*NodeSelector) ProtoMessage() {} func (*NodeSelector) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{109} + return fileDescriptor_6c07b07c062484ab, []int{111} } func (m *NodeSelector) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3132,7 +3188,7 @@ var xxx_messageInfo_NodeSelector proto.InternalMessageInfo func (m *NodeSelectorRequirement) Reset() { *m = NodeSelectorRequirement{} } func (*NodeSelectorRequirement) ProtoMessage() {} func (*NodeSelectorRequirement) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{110} + return fileDescriptor_6c07b07c062484ab, []int{112} } func (m *NodeSelectorRequirement) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3160,7 +3216,7 @@ var xxx_messageInfo_NodeSelectorRequirement proto.InternalMessageInfo func (m *NodeSelectorTerm) Reset() { *m = NodeSelectorTerm{} } func (*NodeSelectorTerm) ProtoMessage() {} func (*NodeSelectorTerm) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{111} + return fileDescriptor_6c07b07c062484ab, []int{113} } func (m *NodeSelectorTerm) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3188,7 +3244,7 @@ var xxx_messageInfo_NodeSelectorTerm proto.InternalMessageInfo func (m *NodeSpec) Reset() { *m = NodeSpec{} } func (*NodeSpec) ProtoMessage() {} func (*NodeSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{112} + return fileDescriptor_6c07b07c062484ab, []int{114} } func (m *NodeSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3216,7 +3272,7 @@ var xxx_messageInfo_NodeSpec proto.InternalMessageInfo func (m *NodeStatus) Reset() { *m = NodeStatus{} } func (*NodeStatus) ProtoMessage() {} func (*NodeStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{113} + return fileDescriptor_6c07b07c062484ab, []int{115} } func (m *NodeStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3244,7 +3300,7 @@ var xxx_messageInfo_NodeStatus proto.InternalMessageInfo func (m *NodeSwapStatus) Reset() { *m = NodeSwapStatus{} } func (*NodeSwapStatus) ProtoMessage() {} func (*NodeSwapStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{114} + return fileDescriptor_6c07b07c062484ab, []int{116} } func (m *NodeSwapStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3272,7 +3328,7 @@ var xxx_messageInfo_NodeSwapStatus proto.InternalMessageInfo func (m *NodeSystemInfo) Reset() { *m = NodeSystemInfo{} } func (*NodeSystemInfo) ProtoMessage() {} func (*NodeSystemInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{115} + return fileDescriptor_6c07b07c062484ab, []int{117} } func (m *NodeSystemInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3300,7 +3356,7 @@ var xxx_messageInfo_NodeSystemInfo proto.InternalMessageInfo func (m *ObjectFieldSelector) Reset() { *m = ObjectFieldSelector{} } func (*ObjectFieldSelector) ProtoMessage() {} func (*ObjectFieldSelector) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{116} + return fileDescriptor_6c07b07c062484ab, []int{118} } func (m *ObjectFieldSelector) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3328,7 +3384,7 @@ var xxx_messageInfo_ObjectFieldSelector proto.InternalMessageInfo func (m *ObjectReference) Reset() { *m = ObjectReference{} } func (*ObjectReference) ProtoMessage() {} func (*ObjectReference) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{117} + return fileDescriptor_6c07b07c062484ab, []int{119} } func (m *ObjectReference) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3356,7 +3412,7 @@ var xxx_messageInfo_ObjectReference proto.InternalMessageInfo func (m *PersistentVolume) Reset() { *m = PersistentVolume{} } func (*PersistentVolume) ProtoMessage() {} func (*PersistentVolume) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{118} + return fileDescriptor_6c07b07c062484ab, []int{120} } func (m *PersistentVolume) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3384,7 +3440,7 @@ var xxx_messageInfo_PersistentVolume proto.InternalMessageInfo func (m *PersistentVolumeClaim) Reset() { *m = PersistentVolumeClaim{} } func (*PersistentVolumeClaim) ProtoMessage() {} func (*PersistentVolumeClaim) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{119} + return fileDescriptor_6c07b07c062484ab, []int{121} } func (m *PersistentVolumeClaim) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3412,7 +3468,7 @@ var xxx_messageInfo_PersistentVolumeClaim proto.InternalMessageInfo func (m *PersistentVolumeClaimCondition) Reset() { *m = PersistentVolumeClaimCondition{} } func (*PersistentVolumeClaimCondition) ProtoMessage() {} func (*PersistentVolumeClaimCondition) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{120} + return fileDescriptor_6c07b07c062484ab, []int{122} } func (m *PersistentVolumeClaimCondition) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3440,7 +3496,7 @@ var xxx_messageInfo_PersistentVolumeClaimCondition proto.InternalMessageInfo func (m *PersistentVolumeClaimList) Reset() { *m = PersistentVolumeClaimList{} } func (*PersistentVolumeClaimList) ProtoMessage() {} func (*PersistentVolumeClaimList) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{121} + return fileDescriptor_6c07b07c062484ab, []int{123} } func (m *PersistentVolumeClaimList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3468,7 +3524,7 @@ var xxx_messageInfo_PersistentVolumeClaimList proto.InternalMessageInfo func (m *PersistentVolumeClaimSpec) Reset() { *m = PersistentVolumeClaimSpec{} } func (*PersistentVolumeClaimSpec) ProtoMessage() {} func (*PersistentVolumeClaimSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{122} + return fileDescriptor_6c07b07c062484ab, []int{124} } func (m *PersistentVolumeClaimSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3496,7 +3552,7 @@ var xxx_messageInfo_PersistentVolumeClaimSpec proto.InternalMessageInfo func (m *PersistentVolumeClaimStatus) Reset() { *m = PersistentVolumeClaimStatus{} } func (*PersistentVolumeClaimStatus) ProtoMessage() {} func (*PersistentVolumeClaimStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{123} + return fileDescriptor_6c07b07c062484ab, []int{125} } func (m *PersistentVolumeClaimStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3524,7 +3580,7 @@ var xxx_messageInfo_PersistentVolumeClaimStatus proto.InternalMessageInfo func (m *PersistentVolumeClaimTemplate) Reset() { *m = PersistentVolumeClaimTemplate{} } func (*PersistentVolumeClaimTemplate) ProtoMessage() {} func (*PersistentVolumeClaimTemplate) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{124} + return fileDescriptor_6c07b07c062484ab, []int{126} } func (m *PersistentVolumeClaimTemplate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3552,7 +3608,7 @@ var xxx_messageInfo_PersistentVolumeClaimTemplate proto.InternalMessageInfo func (m *PersistentVolumeClaimVolumeSource) Reset() { *m = PersistentVolumeClaimVolumeSource{} } func (*PersistentVolumeClaimVolumeSource) ProtoMessage() {} func (*PersistentVolumeClaimVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{125} + return fileDescriptor_6c07b07c062484ab, []int{127} } func (m *PersistentVolumeClaimVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3580,7 +3636,7 @@ var xxx_messageInfo_PersistentVolumeClaimVolumeSource proto.InternalMessageInfo func (m *PersistentVolumeList) Reset() { *m = PersistentVolumeList{} } func (*PersistentVolumeList) ProtoMessage() {} func (*PersistentVolumeList) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{126} + return fileDescriptor_6c07b07c062484ab, []int{128} } func (m *PersistentVolumeList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3608,7 +3664,7 @@ var xxx_messageInfo_PersistentVolumeList proto.InternalMessageInfo func (m *PersistentVolumeSource) Reset() { *m = PersistentVolumeSource{} } func (*PersistentVolumeSource) ProtoMessage() {} func (*PersistentVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{127} + return fileDescriptor_6c07b07c062484ab, []int{129} } func (m *PersistentVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3636,7 +3692,7 @@ var xxx_messageInfo_PersistentVolumeSource proto.InternalMessageInfo func (m *PersistentVolumeSpec) Reset() { *m = PersistentVolumeSpec{} } func (*PersistentVolumeSpec) ProtoMessage() {} func (*PersistentVolumeSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{128} + return fileDescriptor_6c07b07c062484ab, []int{130} } func (m *PersistentVolumeSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3664,7 +3720,7 @@ var xxx_messageInfo_PersistentVolumeSpec proto.InternalMessageInfo func (m *PersistentVolumeStatus) Reset() { *m = PersistentVolumeStatus{} } func (*PersistentVolumeStatus) ProtoMessage() {} func (*PersistentVolumeStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{129} + return fileDescriptor_6c07b07c062484ab, []int{131} } func (m *PersistentVolumeStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3692,7 +3748,7 @@ var xxx_messageInfo_PersistentVolumeStatus proto.InternalMessageInfo func (m *PhotonPersistentDiskVolumeSource) Reset() { *m = PhotonPersistentDiskVolumeSource{} } func (*PhotonPersistentDiskVolumeSource) ProtoMessage() {} func (*PhotonPersistentDiskVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{130} + return fileDescriptor_6c07b07c062484ab, []int{132} } func (m *PhotonPersistentDiskVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3720,7 +3776,7 @@ var xxx_messageInfo_PhotonPersistentDiskVolumeSource proto.InternalMessageInfo func (m *Pod) Reset() { *m = Pod{} } func (*Pod) ProtoMessage() {} func (*Pod) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{131} + return fileDescriptor_6c07b07c062484ab, []int{133} } func (m *Pod) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3748,7 +3804,7 @@ var xxx_messageInfo_Pod proto.InternalMessageInfo func (m *PodAffinity) Reset() { *m = PodAffinity{} } func (*PodAffinity) ProtoMessage() {} func (*PodAffinity) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{132} + return fileDescriptor_6c07b07c062484ab, []int{134} } func (m *PodAffinity) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3776,7 +3832,7 @@ var xxx_messageInfo_PodAffinity proto.InternalMessageInfo func (m *PodAffinityTerm) Reset() { *m = PodAffinityTerm{} } func (*PodAffinityTerm) ProtoMessage() {} func (*PodAffinityTerm) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{133} + return fileDescriptor_6c07b07c062484ab, []int{135} } func (m *PodAffinityTerm) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3804,7 +3860,7 @@ var xxx_messageInfo_PodAffinityTerm proto.InternalMessageInfo func (m *PodAntiAffinity) Reset() { *m = PodAntiAffinity{} } func (*PodAntiAffinity) ProtoMessage() {} func (*PodAntiAffinity) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{134} + return fileDescriptor_6c07b07c062484ab, []int{136} } func (m *PodAntiAffinity) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3832,7 +3888,7 @@ var xxx_messageInfo_PodAntiAffinity proto.InternalMessageInfo func (m *PodAttachOptions) Reset() { *m = PodAttachOptions{} } func (*PodAttachOptions) ProtoMessage() {} func (*PodAttachOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{135} + return fileDescriptor_6c07b07c062484ab, []int{137} } func (m *PodAttachOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3860,7 +3916,7 @@ var xxx_messageInfo_PodAttachOptions proto.InternalMessageInfo func (m *PodCertificateProjection) Reset() { *m = PodCertificateProjection{} } func (*PodCertificateProjection) ProtoMessage() {} func (*PodCertificateProjection) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{136} + return fileDescriptor_6c07b07c062484ab, []int{138} } func (m *PodCertificateProjection) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3888,7 +3944,7 @@ var xxx_messageInfo_PodCertificateProjection proto.InternalMessageInfo func (m *PodCondition) Reset() { *m = PodCondition{} } func (*PodCondition) ProtoMessage() {} func (*PodCondition) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{137} + return fileDescriptor_6c07b07c062484ab, []int{139} } func (m *PodCondition) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3916,7 +3972,7 @@ var xxx_messageInfo_PodCondition proto.InternalMessageInfo func (m *PodDNSConfig) Reset() { *m = PodDNSConfig{} } func (*PodDNSConfig) ProtoMessage() {} func (*PodDNSConfig) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{138} + return fileDescriptor_6c07b07c062484ab, []int{140} } func (m *PodDNSConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3944,7 +4000,7 @@ var xxx_messageInfo_PodDNSConfig proto.InternalMessageInfo func (m *PodDNSConfigOption) Reset() { *m = PodDNSConfigOption{} } func (*PodDNSConfigOption) ProtoMessage() {} func (*PodDNSConfigOption) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{139} + return fileDescriptor_6c07b07c062484ab, []int{141} } func (m *PodDNSConfigOption) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3972,7 +4028,7 @@ var xxx_messageInfo_PodDNSConfigOption proto.InternalMessageInfo func (m *PodExecOptions) Reset() { *m = PodExecOptions{} } func (*PodExecOptions) ProtoMessage() {} func (*PodExecOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{140} + return fileDescriptor_6c07b07c062484ab, []int{142} } func (m *PodExecOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4000,7 +4056,7 @@ var xxx_messageInfo_PodExecOptions proto.InternalMessageInfo func (m *PodIP) Reset() { *m = PodIP{} } func (*PodIP) ProtoMessage() {} func (*PodIP) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{141} + return fileDescriptor_6c07b07c062484ab, []int{143} } func (m *PodIP) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4028,7 +4084,7 @@ var xxx_messageInfo_PodIP proto.InternalMessageInfo func (m *PodList) Reset() { *m = PodList{} } func (*PodList) ProtoMessage() {} func (*PodList) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{142} + return fileDescriptor_6c07b07c062484ab, []int{144} } func (m *PodList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4056,7 +4112,7 @@ var xxx_messageInfo_PodList proto.InternalMessageInfo func (m *PodLogOptions) Reset() { *m = PodLogOptions{} } func (*PodLogOptions) ProtoMessage() {} func (*PodLogOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{143} + return fileDescriptor_6c07b07c062484ab, []int{145} } func (m *PodLogOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4084,7 +4140,7 @@ var xxx_messageInfo_PodLogOptions proto.InternalMessageInfo func (m *PodOS) Reset() { *m = PodOS{} } func (*PodOS) ProtoMessage() {} func (*PodOS) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{144} + return fileDescriptor_6c07b07c062484ab, []int{146} } func (m *PodOS) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4112,7 +4168,7 @@ var xxx_messageInfo_PodOS proto.InternalMessageInfo func (m *PodPortForwardOptions) Reset() { *m = PodPortForwardOptions{} } func (*PodPortForwardOptions) ProtoMessage() {} func (*PodPortForwardOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{145} + return fileDescriptor_6c07b07c062484ab, []int{147} } func (m *PodPortForwardOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4140,7 +4196,7 @@ var xxx_messageInfo_PodPortForwardOptions proto.InternalMessageInfo func (m *PodProxyOptions) Reset() { *m = PodProxyOptions{} } func (*PodProxyOptions) ProtoMessage() {} func (*PodProxyOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{146} + return fileDescriptor_6c07b07c062484ab, []int{148} } func (m *PodProxyOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4168,7 +4224,7 @@ var xxx_messageInfo_PodProxyOptions proto.InternalMessageInfo func (m *PodReadinessGate) Reset() { *m = PodReadinessGate{} } func (*PodReadinessGate) ProtoMessage() {} func (*PodReadinessGate) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{147} + return fileDescriptor_6c07b07c062484ab, []int{149} } func (m *PodReadinessGate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4196,7 +4252,7 @@ var xxx_messageInfo_PodReadinessGate proto.InternalMessageInfo func (m *PodResourceClaim) Reset() { *m = PodResourceClaim{} } func (*PodResourceClaim) ProtoMessage() {} func (*PodResourceClaim) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{148} + return fileDescriptor_6c07b07c062484ab, []int{150} } func (m *PodResourceClaim) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4224,7 +4280,7 @@ var xxx_messageInfo_PodResourceClaim proto.InternalMessageInfo func (m *PodResourceClaimStatus) Reset() { *m = PodResourceClaimStatus{} } func (*PodResourceClaimStatus) ProtoMessage() {} func (*PodResourceClaimStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{149} + return fileDescriptor_6c07b07c062484ab, []int{151} } func (m *PodResourceClaimStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4252,7 +4308,7 @@ var xxx_messageInfo_PodResourceClaimStatus proto.InternalMessageInfo func (m *PodSchedulingGate) Reset() { *m = PodSchedulingGate{} } func (*PodSchedulingGate) ProtoMessage() {} func (*PodSchedulingGate) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{150} + return fileDescriptor_6c07b07c062484ab, []int{152} } func (m *PodSchedulingGate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4280,7 +4336,7 @@ var xxx_messageInfo_PodSchedulingGate proto.InternalMessageInfo func (m *PodSecurityContext) Reset() { *m = PodSecurityContext{} } func (*PodSecurityContext) ProtoMessage() {} func (*PodSecurityContext) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{151} + return fileDescriptor_6c07b07c062484ab, []int{153} } func (m *PodSecurityContext) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4308,7 +4364,7 @@ var xxx_messageInfo_PodSecurityContext proto.InternalMessageInfo func (m *PodSignature) Reset() { *m = PodSignature{} } func (*PodSignature) ProtoMessage() {} func (*PodSignature) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{152} + return fileDescriptor_6c07b07c062484ab, []int{154} } func (m *PodSignature) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4336,7 +4392,7 @@ var xxx_messageInfo_PodSignature proto.InternalMessageInfo func (m *PodSpec) Reset() { *m = PodSpec{} } func (*PodSpec) ProtoMessage() {} func (*PodSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{153} + return fileDescriptor_6c07b07c062484ab, []int{155} } func (m *PodSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4364,7 +4420,7 @@ var xxx_messageInfo_PodSpec proto.InternalMessageInfo func (m *PodStatus) Reset() { *m = PodStatus{} } func (*PodStatus) ProtoMessage() {} func (*PodStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{154} + return fileDescriptor_6c07b07c062484ab, []int{156} } func (m *PodStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4392,7 +4448,7 @@ var xxx_messageInfo_PodStatus proto.InternalMessageInfo func (m *PodStatusResult) Reset() { *m = PodStatusResult{} } func (*PodStatusResult) ProtoMessage() {} func (*PodStatusResult) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{155} + return fileDescriptor_6c07b07c062484ab, []int{157} } func (m *PodStatusResult) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4420,7 +4476,7 @@ var xxx_messageInfo_PodStatusResult proto.InternalMessageInfo func (m *PodTemplate) Reset() { *m = PodTemplate{} } func (*PodTemplate) ProtoMessage() {} func (*PodTemplate) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{156} + return fileDescriptor_6c07b07c062484ab, []int{158} } func (m *PodTemplate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4448,7 +4504,7 @@ var xxx_messageInfo_PodTemplate proto.InternalMessageInfo func (m *PodTemplateList) Reset() { *m = PodTemplateList{} } func (*PodTemplateList) ProtoMessage() {} func (*PodTemplateList) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{157} + return fileDescriptor_6c07b07c062484ab, []int{159} } func (m *PodTemplateList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4476,7 +4532,7 @@ var xxx_messageInfo_PodTemplateList proto.InternalMessageInfo func (m *PodTemplateSpec) Reset() { *m = PodTemplateSpec{} } func (*PodTemplateSpec) ProtoMessage() {} func (*PodTemplateSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{158} + return fileDescriptor_6c07b07c062484ab, []int{160} } func (m *PodTemplateSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4504,7 +4560,7 @@ var xxx_messageInfo_PodTemplateSpec proto.InternalMessageInfo func (m *PortStatus) Reset() { *m = PortStatus{} } func (*PortStatus) ProtoMessage() {} func (*PortStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{159} + return fileDescriptor_6c07b07c062484ab, []int{161} } func (m *PortStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4532,7 +4588,7 @@ var xxx_messageInfo_PortStatus proto.InternalMessageInfo func (m *PortworxVolumeSource) Reset() { *m = PortworxVolumeSource{} } func (*PortworxVolumeSource) ProtoMessage() {} func (*PortworxVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{160} + return fileDescriptor_6c07b07c062484ab, []int{162} } func (m *PortworxVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4560,7 +4616,7 @@ var xxx_messageInfo_PortworxVolumeSource proto.InternalMessageInfo func (m *Preconditions) Reset() { *m = Preconditions{} } func (*Preconditions) ProtoMessage() {} func (*Preconditions) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{161} + return fileDescriptor_6c07b07c062484ab, []int{163} } func (m *Preconditions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4588,7 +4644,7 @@ var xxx_messageInfo_Preconditions proto.InternalMessageInfo func (m *PreferAvoidPodsEntry) Reset() { *m = PreferAvoidPodsEntry{} } func (*PreferAvoidPodsEntry) ProtoMessage() {} func (*PreferAvoidPodsEntry) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{162} + return fileDescriptor_6c07b07c062484ab, []int{164} } func (m *PreferAvoidPodsEntry) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4616,7 +4672,7 @@ var xxx_messageInfo_PreferAvoidPodsEntry proto.InternalMessageInfo func (m *PreferredSchedulingTerm) Reset() { *m = PreferredSchedulingTerm{} } func (*PreferredSchedulingTerm) ProtoMessage() {} func (*PreferredSchedulingTerm) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{163} + return fileDescriptor_6c07b07c062484ab, []int{165} } func (m *PreferredSchedulingTerm) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4644,7 +4700,7 @@ var xxx_messageInfo_PreferredSchedulingTerm proto.InternalMessageInfo func (m *Probe) Reset() { *m = Probe{} } func (*Probe) ProtoMessage() {} func (*Probe) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{164} + return fileDescriptor_6c07b07c062484ab, []int{166} } func (m *Probe) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4672,7 +4728,7 @@ var xxx_messageInfo_Probe proto.InternalMessageInfo func (m *ProbeHandler) Reset() { *m = ProbeHandler{} } func (*ProbeHandler) ProtoMessage() {} func (*ProbeHandler) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{165} + return fileDescriptor_6c07b07c062484ab, []int{167} } func (m *ProbeHandler) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4700,7 +4756,7 @@ var xxx_messageInfo_ProbeHandler proto.InternalMessageInfo func (m *ProjectedVolumeSource) Reset() { *m = ProjectedVolumeSource{} } func (*ProjectedVolumeSource) ProtoMessage() {} func (*ProjectedVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{166} + return fileDescriptor_6c07b07c062484ab, []int{168} } func (m *ProjectedVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4728,7 +4784,7 @@ var xxx_messageInfo_ProjectedVolumeSource proto.InternalMessageInfo func (m *QuobyteVolumeSource) Reset() { *m = QuobyteVolumeSource{} } func (*QuobyteVolumeSource) ProtoMessage() {} func (*QuobyteVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{167} + return fileDescriptor_6c07b07c062484ab, []int{169} } func (m *QuobyteVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4756,7 +4812,7 @@ var xxx_messageInfo_QuobyteVolumeSource proto.InternalMessageInfo func (m *RBDPersistentVolumeSource) Reset() { *m = RBDPersistentVolumeSource{} } func (*RBDPersistentVolumeSource) ProtoMessage() {} func (*RBDPersistentVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{168} + return fileDescriptor_6c07b07c062484ab, []int{170} } func (m *RBDPersistentVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4784,7 +4840,7 @@ var xxx_messageInfo_RBDPersistentVolumeSource proto.InternalMessageInfo func (m *RBDVolumeSource) Reset() { *m = RBDVolumeSource{} } func (*RBDVolumeSource) ProtoMessage() {} func (*RBDVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{169} + return fileDescriptor_6c07b07c062484ab, []int{171} } func (m *RBDVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4812,7 +4868,7 @@ var xxx_messageInfo_RBDVolumeSource proto.InternalMessageInfo func (m *RangeAllocation) Reset() { *m = RangeAllocation{} } func (*RangeAllocation) ProtoMessage() {} func (*RangeAllocation) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{170} + return fileDescriptor_6c07b07c062484ab, []int{172} } func (m *RangeAllocation) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4840,7 +4896,7 @@ var xxx_messageInfo_RangeAllocation proto.InternalMessageInfo func (m *ReplicationController) Reset() { *m = ReplicationController{} } func (*ReplicationController) ProtoMessage() {} func (*ReplicationController) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{171} + return fileDescriptor_6c07b07c062484ab, []int{173} } func (m *ReplicationController) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4868,7 +4924,7 @@ var xxx_messageInfo_ReplicationController proto.InternalMessageInfo func (m *ReplicationControllerCondition) Reset() { *m = ReplicationControllerCondition{} } func (*ReplicationControllerCondition) ProtoMessage() {} func (*ReplicationControllerCondition) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{172} + return fileDescriptor_6c07b07c062484ab, []int{174} } func (m *ReplicationControllerCondition) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4896,7 +4952,7 @@ var xxx_messageInfo_ReplicationControllerCondition proto.InternalMessageInfo func (m *ReplicationControllerList) Reset() { *m = ReplicationControllerList{} } func (*ReplicationControllerList) ProtoMessage() {} func (*ReplicationControllerList) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{173} + return fileDescriptor_6c07b07c062484ab, []int{175} } func (m *ReplicationControllerList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4924,7 +4980,7 @@ var xxx_messageInfo_ReplicationControllerList proto.InternalMessageInfo func (m *ReplicationControllerSpec) Reset() { *m = ReplicationControllerSpec{} } func (*ReplicationControllerSpec) ProtoMessage() {} func (*ReplicationControllerSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{174} + return fileDescriptor_6c07b07c062484ab, []int{176} } func (m *ReplicationControllerSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4952,7 +5008,7 @@ var xxx_messageInfo_ReplicationControllerSpec proto.InternalMessageInfo func (m *ReplicationControllerStatus) Reset() { *m = ReplicationControllerStatus{} } func (*ReplicationControllerStatus) ProtoMessage() {} func (*ReplicationControllerStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{175} + return fileDescriptor_6c07b07c062484ab, []int{177} } func (m *ReplicationControllerStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4980,7 +5036,7 @@ var xxx_messageInfo_ReplicationControllerStatus proto.InternalMessageInfo func (m *ResourceClaim) Reset() { *m = ResourceClaim{} } func (*ResourceClaim) ProtoMessage() {} func (*ResourceClaim) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{176} + return fileDescriptor_6c07b07c062484ab, []int{178} } func (m *ResourceClaim) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5008,7 +5064,7 @@ var xxx_messageInfo_ResourceClaim proto.InternalMessageInfo func (m *ResourceFieldSelector) Reset() { *m = ResourceFieldSelector{} } func (*ResourceFieldSelector) ProtoMessage() {} func (*ResourceFieldSelector) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{177} + return fileDescriptor_6c07b07c062484ab, []int{179} } func (m *ResourceFieldSelector) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5036,7 +5092,7 @@ var xxx_messageInfo_ResourceFieldSelector proto.InternalMessageInfo func (m *ResourceHealth) Reset() { *m = ResourceHealth{} } func (*ResourceHealth) ProtoMessage() {} func (*ResourceHealth) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{178} + return fileDescriptor_6c07b07c062484ab, []int{180} } func (m *ResourceHealth) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5064,7 +5120,7 @@ var xxx_messageInfo_ResourceHealth proto.InternalMessageInfo func (m *ResourceQuota) Reset() { *m = ResourceQuota{} } func (*ResourceQuota) ProtoMessage() {} func (*ResourceQuota) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{179} + return fileDescriptor_6c07b07c062484ab, []int{181} } func (m *ResourceQuota) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5092,7 +5148,7 @@ var xxx_messageInfo_ResourceQuota proto.InternalMessageInfo func (m *ResourceQuotaList) Reset() { *m = ResourceQuotaList{} } func (*ResourceQuotaList) ProtoMessage() {} func (*ResourceQuotaList) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{180} + return fileDescriptor_6c07b07c062484ab, []int{182} } func (m *ResourceQuotaList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5120,7 +5176,7 @@ var xxx_messageInfo_ResourceQuotaList proto.InternalMessageInfo func (m *ResourceQuotaSpec) Reset() { *m = ResourceQuotaSpec{} } func (*ResourceQuotaSpec) ProtoMessage() {} func (*ResourceQuotaSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{181} + return fileDescriptor_6c07b07c062484ab, []int{183} } func (m *ResourceQuotaSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5148,7 +5204,7 @@ var xxx_messageInfo_ResourceQuotaSpec proto.InternalMessageInfo func (m *ResourceQuotaStatus) Reset() { *m = ResourceQuotaStatus{} } func (*ResourceQuotaStatus) ProtoMessage() {} func (*ResourceQuotaStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{182} + return fileDescriptor_6c07b07c062484ab, []int{184} } func (m *ResourceQuotaStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5176,7 +5232,7 @@ var xxx_messageInfo_ResourceQuotaStatus proto.InternalMessageInfo func (m *ResourceRequirements) Reset() { *m = ResourceRequirements{} } func (*ResourceRequirements) ProtoMessage() {} func (*ResourceRequirements) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{183} + return fileDescriptor_6c07b07c062484ab, []int{185} } func (m *ResourceRequirements) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5204,7 +5260,7 @@ var xxx_messageInfo_ResourceRequirements proto.InternalMessageInfo func (m *ResourceStatus) Reset() { *m = ResourceStatus{} } func (*ResourceStatus) ProtoMessage() {} func (*ResourceStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{184} + return fileDescriptor_6c07b07c062484ab, []int{186} } func (m *ResourceStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5232,7 +5288,7 @@ var xxx_messageInfo_ResourceStatus proto.InternalMessageInfo func (m *SELinuxOptions) Reset() { *m = SELinuxOptions{} } func (*SELinuxOptions) ProtoMessage() {} func (*SELinuxOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{185} + return fileDescriptor_6c07b07c062484ab, []int{187} } func (m *SELinuxOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5260,7 +5316,7 @@ var xxx_messageInfo_SELinuxOptions proto.InternalMessageInfo func (m *ScaleIOPersistentVolumeSource) Reset() { *m = ScaleIOPersistentVolumeSource{} } func (*ScaleIOPersistentVolumeSource) ProtoMessage() {} func (*ScaleIOPersistentVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{186} + return fileDescriptor_6c07b07c062484ab, []int{188} } func (m *ScaleIOPersistentVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5288,7 +5344,7 @@ var xxx_messageInfo_ScaleIOPersistentVolumeSource proto.InternalMessageInfo func (m *ScaleIOVolumeSource) Reset() { *m = ScaleIOVolumeSource{} } func (*ScaleIOVolumeSource) ProtoMessage() {} func (*ScaleIOVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{187} + return fileDescriptor_6c07b07c062484ab, []int{189} } func (m *ScaleIOVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5316,7 +5372,7 @@ var xxx_messageInfo_ScaleIOVolumeSource proto.InternalMessageInfo func (m *ScopeSelector) Reset() { *m = ScopeSelector{} } func (*ScopeSelector) ProtoMessage() {} func (*ScopeSelector) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{188} + return fileDescriptor_6c07b07c062484ab, []int{190} } func (m *ScopeSelector) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5344,7 +5400,7 @@ var xxx_messageInfo_ScopeSelector proto.InternalMessageInfo func (m *ScopedResourceSelectorRequirement) Reset() { *m = ScopedResourceSelectorRequirement{} } func (*ScopedResourceSelectorRequirement) ProtoMessage() {} func (*ScopedResourceSelectorRequirement) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{189} + return fileDescriptor_6c07b07c062484ab, []int{191} } func (m *ScopedResourceSelectorRequirement) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5372,7 +5428,7 @@ var xxx_messageInfo_ScopedResourceSelectorRequirement proto.InternalMessageInfo func (m *SeccompProfile) Reset() { *m = SeccompProfile{} } func (*SeccompProfile) ProtoMessage() {} func (*SeccompProfile) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{190} + return fileDescriptor_6c07b07c062484ab, []int{192} } func (m *SeccompProfile) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5400,7 +5456,7 @@ var xxx_messageInfo_SeccompProfile proto.InternalMessageInfo func (m *Secret) Reset() { *m = Secret{} } func (*Secret) ProtoMessage() {} func (*Secret) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{191} + return fileDescriptor_6c07b07c062484ab, []int{193} } func (m *Secret) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5428,7 +5484,7 @@ var xxx_messageInfo_Secret proto.InternalMessageInfo func (m *SecretEnvSource) Reset() { *m = SecretEnvSource{} } func (*SecretEnvSource) ProtoMessage() {} func (*SecretEnvSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{192} + return fileDescriptor_6c07b07c062484ab, []int{194} } func (m *SecretEnvSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5456,7 +5512,7 @@ var xxx_messageInfo_SecretEnvSource proto.InternalMessageInfo func (m *SecretKeySelector) Reset() { *m = SecretKeySelector{} } func (*SecretKeySelector) ProtoMessage() {} func (*SecretKeySelector) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{193} + return fileDescriptor_6c07b07c062484ab, []int{195} } func (m *SecretKeySelector) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5484,7 +5540,7 @@ var xxx_messageInfo_SecretKeySelector proto.InternalMessageInfo func (m *SecretList) Reset() { *m = SecretList{} } func (*SecretList) ProtoMessage() {} func (*SecretList) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{194} + return fileDescriptor_6c07b07c062484ab, []int{196} } func (m *SecretList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5512,7 +5568,7 @@ var xxx_messageInfo_SecretList proto.InternalMessageInfo func (m *SecretProjection) Reset() { *m = SecretProjection{} } func (*SecretProjection) ProtoMessage() {} func (*SecretProjection) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{195} + return fileDescriptor_6c07b07c062484ab, []int{197} } func (m *SecretProjection) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5540,7 +5596,7 @@ var xxx_messageInfo_SecretProjection proto.InternalMessageInfo func (m *SecretReference) Reset() { *m = SecretReference{} } func (*SecretReference) ProtoMessage() {} func (*SecretReference) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{196} + return fileDescriptor_6c07b07c062484ab, []int{198} } func (m *SecretReference) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5568,7 +5624,7 @@ var xxx_messageInfo_SecretReference proto.InternalMessageInfo func (m *SecretVolumeSource) Reset() { *m = SecretVolumeSource{} } func (*SecretVolumeSource) ProtoMessage() {} func (*SecretVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{197} + return fileDescriptor_6c07b07c062484ab, []int{199} } func (m *SecretVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5596,7 +5652,7 @@ var xxx_messageInfo_SecretVolumeSource proto.InternalMessageInfo func (m *SecurityContext) Reset() { *m = SecurityContext{} } func (*SecurityContext) ProtoMessage() {} func (*SecurityContext) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{198} + return fileDescriptor_6c07b07c062484ab, []int{200} } func (m *SecurityContext) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5624,7 +5680,7 @@ var xxx_messageInfo_SecurityContext proto.InternalMessageInfo func (m *SerializedReference) Reset() { *m = SerializedReference{} } func (*SerializedReference) ProtoMessage() {} func (*SerializedReference) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{199} + return fileDescriptor_6c07b07c062484ab, []int{201} } func (m *SerializedReference) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5652,7 +5708,7 @@ var xxx_messageInfo_SerializedReference proto.InternalMessageInfo func (m *Service) Reset() { *m = Service{} } func (*Service) ProtoMessage() {} func (*Service) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{200} + return fileDescriptor_6c07b07c062484ab, []int{202} } func (m *Service) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5680,7 +5736,7 @@ var xxx_messageInfo_Service proto.InternalMessageInfo func (m *ServiceAccount) Reset() { *m = ServiceAccount{} } func (*ServiceAccount) ProtoMessage() {} func (*ServiceAccount) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{201} + return fileDescriptor_6c07b07c062484ab, []int{203} } func (m *ServiceAccount) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5708,7 +5764,7 @@ var xxx_messageInfo_ServiceAccount proto.InternalMessageInfo func (m *ServiceAccountList) Reset() { *m = ServiceAccountList{} } func (*ServiceAccountList) ProtoMessage() {} func (*ServiceAccountList) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{202} + return fileDescriptor_6c07b07c062484ab, []int{204} } func (m *ServiceAccountList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5736,7 +5792,7 @@ var xxx_messageInfo_ServiceAccountList proto.InternalMessageInfo func (m *ServiceAccountTokenProjection) Reset() { *m = ServiceAccountTokenProjection{} } func (*ServiceAccountTokenProjection) ProtoMessage() {} func (*ServiceAccountTokenProjection) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{203} + return fileDescriptor_6c07b07c062484ab, []int{205} } func (m *ServiceAccountTokenProjection) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5764,7 +5820,7 @@ var xxx_messageInfo_ServiceAccountTokenProjection proto.InternalMessageInfo func (m *ServiceList) Reset() { *m = ServiceList{} } func (*ServiceList) ProtoMessage() {} func (*ServiceList) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{204} + return fileDescriptor_6c07b07c062484ab, []int{206} } func (m *ServiceList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5792,7 +5848,7 @@ var xxx_messageInfo_ServiceList proto.InternalMessageInfo func (m *ServicePort) Reset() { *m = ServicePort{} } func (*ServicePort) ProtoMessage() {} func (*ServicePort) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{205} + return fileDescriptor_6c07b07c062484ab, []int{207} } func (m *ServicePort) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5820,7 +5876,7 @@ var xxx_messageInfo_ServicePort proto.InternalMessageInfo func (m *ServiceProxyOptions) Reset() { *m = ServiceProxyOptions{} } func (*ServiceProxyOptions) ProtoMessage() {} func (*ServiceProxyOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{206} + return fileDescriptor_6c07b07c062484ab, []int{208} } func (m *ServiceProxyOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5848,7 +5904,7 @@ var xxx_messageInfo_ServiceProxyOptions proto.InternalMessageInfo func (m *ServiceSpec) Reset() { *m = ServiceSpec{} } func (*ServiceSpec) ProtoMessage() {} func (*ServiceSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{207} + return fileDescriptor_6c07b07c062484ab, []int{209} } func (m *ServiceSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5876,7 +5932,7 @@ var xxx_messageInfo_ServiceSpec proto.InternalMessageInfo func (m *ServiceStatus) Reset() { *m = ServiceStatus{} } func (*ServiceStatus) ProtoMessage() {} func (*ServiceStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{208} + return fileDescriptor_6c07b07c062484ab, []int{210} } func (m *ServiceStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5904,7 +5960,7 @@ var xxx_messageInfo_ServiceStatus proto.InternalMessageInfo func (m *SessionAffinityConfig) Reset() { *m = SessionAffinityConfig{} } func (*SessionAffinityConfig) ProtoMessage() {} func (*SessionAffinityConfig) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{209} + return fileDescriptor_6c07b07c062484ab, []int{211} } func (m *SessionAffinityConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5932,7 +5988,7 @@ var xxx_messageInfo_SessionAffinityConfig proto.InternalMessageInfo func (m *SleepAction) Reset() { *m = SleepAction{} } func (*SleepAction) ProtoMessage() {} func (*SleepAction) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{210} + return fileDescriptor_6c07b07c062484ab, []int{212} } func (m *SleepAction) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5960,7 +6016,7 @@ var xxx_messageInfo_SleepAction proto.InternalMessageInfo func (m *StorageOSPersistentVolumeSource) Reset() { *m = StorageOSPersistentVolumeSource{} } func (*StorageOSPersistentVolumeSource) ProtoMessage() {} func (*StorageOSPersistentVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{211} + return fileDescriptor_6c07b07c062484ab, []int{213} } func (m *StorageOSPersistentVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5988,7 +6044,7 @@ var xxx_messageInfo_StorageOSPersistentVolumeSource proto.InternalMessageInfo func (m *StorageOSVolumeSource) Reset() { *m = StorageOSVolumeSource{} } func (*StorageOSVolumeSource) ProtoMessage() {} func (*StorageOSVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{212} + return fileDescriptor_6c07b07c062484ab, []int{214} } func (m *StorageOSVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6016,7 +6072,7 @@ var xxx_messageInfo_StorageOSVolumeSource proto.InternalMessageInfo func (m *Sysctl) Reset() { *m = Sysctl{} } func (*Sysctl) ProtoMessage() {} func (*Sysctl) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{213} + return fileDescriptor_6c07b07c062484ab, []int{215} } func (m *Sysctl) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6044,7 +6100,7 @@ var xxx_messageInfo_Sysctl proto.InternalMessageInfo func (m *TCPSocketAction) Reset() { *m = TCPSocketAction{} } func (*TCPSocketAction) ProtoMessage() {} func (*TCPSocketAction) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{214} + return fileDescriptor_6c07b07c062484ab, []int{216} } func (m *TCPSocketAction) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6072,7 +6128,7 @@ var xxx_messageInfo_TCPSocketAction proto.InternalMessageInfo func (m *Taint) Reset() { *m = Taint{} } func (*Taint) ProtoMessage() {} func (*Taint) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{215} + return fileDescriptor_6c07b07c062484ab, []int{217} } func (m *Taint) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6100,7 +6156,7 @@ var xxx_messageInfo_Taint proto.InternalMessageInfo func (m *Toleration) Reset() { *m = Toleration{} } func (*Toleration) ProtoMessage() {} func (*Toleration) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{216} + return fileDescriptor_6c07b07c062484ab, []int{218} } func (m *Toleration) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6128,7 +6184,7 @@ var xxx_messageInfo_Toleration proto.InternalMessageInfo func (m *TopologySelectorLabelRequirement) Reset() { *m = TopologySelectorLabelRequirement{} } func (*TopologySelectorLabelRequirement) ProtoMessage() {} func (*TopologySelectorLabelRequirement) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{217} + return fileDescriptor_6c07b07c062484ab, []int{219} } func (m *TopologySelectorLabelRequirement) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6156,7 +6212,7 @@ var xxx_messageInfo_TopologySelectorLabelRequirement proto.InternalMessageInfo func (m *TopologySelectorTerm) Reset() { *m = TopologySelectorTerm{} } func (*TopologySelectorTerm) ProtoMessage() {} func (*TopologySelectorTerm) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{218} + return fileDescriptor_6c07b07c062484ab, []int{220} } func (m *TopologySelectorTerm) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6184,7 +6240,7 @@ var xxx_messageInfo_TopologySelectorTerm proto.InternalMessageInfo func (m *TopologySpreadConstraint) Reset() { *m = TopologySpreadConstraint{} } func (*TopologySpreadConstraint) ProtoMessage() {} func (*TopologySpreadConstraint) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{219} + return fileDescriptor_6c07b07c062484ab, []int{221} } func (m *TopologySpreadConstraint) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6212,7 +6268,7 @@ var xxx_messageInfo_TopologySpreadConstraint proto.InternalMessageInfo func (m *TypedLocalObjectReference) Reset() { *m = TypedLocalObjectReference{} } func (*TypedLocalObjectReference) ProtoMessage() {} func (*TypedLocalObjectReference) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{220} + return fileDescriptor_6c07b07c062484ab, []int{222} } func (m *TypedLocalObjectReference) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6240,7 +6296,7 @@ var xxx_messageInfo_TypedLocalObjectReference proto.InternalMessageInfo func (m *TypedObjectReference) Reset() { *m = TypedObjectReference{} } func (*TypedObjectReference) ProtoMessage() {} func (*TypedObjectReference) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{221} + return fileDescriptor_6c07b07c062484ab, []int{223} } func (m *TypedObjectReference) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6268,7 +6324,7 @@ var xxx_messageInfo_TypedObjectReference proto.InternalMessageInfo func (m *Volume) Reset() { *m = Volume{} } func (*Volume) ProtoMessage() {} func (*Volume) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{222} + return fileDescriptor_6c07b07c062484ab, []int{224} } func (m *Volume) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6296,7 +6352,7 @@ var xxx_messageInfo_Volume proto.InternalMessageInfo func (m *VolumeDevice) Reset() { *m = VolumeDevice{} } func (*VolumeDevice) ProtoMessage() {} func (*VolumeDevice) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{223} + return fileDescriptor_6c07b07c062484ab, []int{225} } func (m *VolumeDevice) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6324,7 +6380,7 @@ var xxx_messageInfo_VolumeDevice proto.InternalMessageInfo func (m *VolumeMount) Reset() { *m = VolumeMount{} } func (*VolumeMount) ProtoMessage() {} func (*VolumeMount) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{224} + return fileDescriptor_6c07b07c062484ab, []int{226} } func (m *VolumeMount) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6352,7 +6408,7 @@ var xxx_messageInfo_VolumeMount proto.InternalMessageInfo func (m *VolumeMountStatus) Reset() { *m = VolumeMountStatus{} } func (*VolumeMountStatus) ProtoMessage() {} func (*VolumeMountStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{225} + return fileDescriptor_6c07b07c062484ab, []int{227} } func (m *VolumeMountStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6380,7 +6436,7 @@ var xxx_messageInfo_VolumeMountStatus proto.InternalMessageInfo func (m *VolumeNodeAffinity) Reset() { *m = VolumeNodeAffinity{} } func (*VolumeNodeAffinity) ProtoMessage() {} func (*VolumeNodeAffinity) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{226} + return fileDescriptor_6c07b07c062484ab, []int{228} } func (m *VolumeNodeAffinity) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6408,7 +6464,7 @@ var xxx_messageInfo_VolumeNodeAffinity proto.InternalMessageInfo func (m *VolumeProjection) Reset() { *m = VolumeProjection{} } func (*VolumeProjection) ProtoMessage() {} func (*VolumeProjection) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{227} + return fileDescriptor_6c07b07c062484ab, []int{229} } func (m *VolumeProjection) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6436,7 +6492,7 @@ var xxx_messageInfo_VolumeProjection proto.InternalMessageInfo func (m *VolumeResourceRequirements) Reset() { *m = VolumeResourceRequirements{} } func (*VolumeResourceRequirements) ProtoMessage() {} func (*VolumeResourceRequirements) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{228} + return fileDescriptor_6c07b07c062484ab, []int{230} } func (m *VolumeResourceRequirements) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6464,7 +6520,7 @@ var xxx_messageInfo_VolumeResourceRequirements proto.InternalMessageInfo func (m *VolumeSource) Reset() { *m = VolumeSource{} } func (*VolumeSource) ProtoMessage() {} func (*VolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{229} + return fileDescriptor_6c07b07c062484ab, []int{231} } func (m *VolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6492,7 +6548,7 @@ var xxx_messageInfo_VolumeSource proto.InternalMessageInfo func (m *VsphereVirtualDiskVolumeSource) Reset() { *m = VsphereVirtualDiskVolumeSource{} } func (*VsphereVirtualDiskVolumeSource) ProtoMessage() {} func (*VsphereVirtualDiskVolumeSource) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{230} + return fileDescriptor_6c07b07c062484ab, []int{232} } func (m *VsphereVirtualDiskVolumeSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6520,7 +6576,7 @@ var xxx_messageInfo_VsphereVirtualDiskVolumeSource proto.InternalMessageInfo func (m *WeightedPodAffinityTerm) Reset() { *m = WeightedPodAffinityTerm{} } func (*WeightedPodAffinityTerm) ProtoMessage() {} func (*WeightedPodAffinityTerm) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{231} + return fileDescriptor_6c07b07c062484ab, []int{233} } func (m *WeightedPodAffinityTerm) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6548,7 +6604,7 @@ var xxx_messageInfo_WeightedPodAffinityTerm proto.InternalMessageInfo func (m *WindowsSecurityContextOptions) Reset() { *m = WindowsSecurityContextOptions{} } func (*WindowsSecurityContextOptions) ProtoMessage() {} func (*WindowsSecurityContextOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_6c07b07c062484ab, []int{232} + return fileDescriptor_6c07b07c062484ab, []int{234} } func (m *WindowsSecurityContextOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6610,6 +6666,8 @@ func init() { proto.RegisterType((*ContainerImage)(nil), "k8s.io.api.core.v1.ContainerImage") proto.RegisterType((*ContainerPort)(nil), "k8s.io.api.core.v1.ContainerPort") proto.RegisterType((*ContainerResizePolicy)(nil), "k8s.io.api.core.v1.ContainerResizePolicy") + proto.RegisterType((*ContainerRestartRule)(nil), "k8s.io.api.core.v1.ContainerRestartRule") + proto.RegisterType((*ContainerRestartRuleOnExitCodes)(nil), "k8s.io.api.core.v1.ContainerRestartRuleOnExitCodes") proto.RegisterType((*ContainerState)(nil), "k8s.io.api.core.v1.ContainerState") proto.RegisterType((*ContainerStateRunning)(nil), "k8s.io.api.core.v1.ContainerStateRunning") proto.RegisterType((*ContainerStateTerminated)(nil), "k8s.io.api.core.v1.ContainerStateTerminated") @@ -6845,1033 +6903,1041 @@ func init() { } var fileDescriptor_6c07b07c062484ab = []byte{ - // 16415 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0xbd, 0x6b, 0x90, 0x1c, 0xc9, - 0x79, 0x20, 0xc6, 0xea, 0x9e, 0xe7, 0x37, 0xef, 0x1c, 0x3c, 0x1a, 0xb3, 0x00, 0x1a, 0x5b, 0xbb, - 0x8b, 0xc5, 0xbe, 0x06, 0xc4, 0x3e, 0xb8, 0xe0, 0xee, 0x72, 0xb5, 0xf3, 0x04, 0x66, 0x81, 0x19, - 0xf4, 0x66, 0x0f, 0x00, 0x72, 0xb9, 0xe4, 0xb1, 0xd0, 0x9d, 0x33, 0x53, 0x9c, 0xee, 0xaa, 0xde, - 0xaa, 0xea, 0x01, 0x06, 0xe6, 0x85, 0x74, 0x3c, 0x8b, 0x77, 0xa4, 0xe4, 0x08, 0xc6, 0x85, 0xef, - 0xce, 0x41, 0x5d, 0xdc, 0x8f, 0xf3, 0xdd, 0x49, 0x32, 0xad, 0xb3, 0x68, 0xc9, 0x92, 0x2c, 0xea, - 0x65, 0x5b, 0x8e, 0x90, 0xfd, 0x43, 0x96, 0x14, 0x61, 0x52, 0x61, 0x85, 0x47, 0xe6, 0xd8, 0x0a, - 0x05, 0x7f, 0x58, 0x52, 0xc8, 0xfe, 0x61, 0x4f, 0xc8, 0xe6, 0x45, 0x3e, 0x2b, 0xb3, 0x1e, 0xdd, - 0x3d, 0x58, 0x60, 0xb8, 0x64, 0xec, 0xbf, 0xee, 0xfc, 0xbe, 0xfc, 0x32, 0x2b, 0x9f, 0x5f, 0x7e, - 0x4f, 0xb0, 0xb7, 0x2f, 0x87, 0xb3, 0xae, 0x7f, 0xd1, 0x69, 0xb9, 0x17, 0x6b, 0x7e, 0x40, 0x2e, - 0xee, 0x5c, 0xba, 0xb8, 0x49, 0x3c, 0x12, 0x38, 0x11, 0xa9, 0xcf, 0xb6, 0x02, 0x3f, 0xf2, 0x11, - 0xe2, 0x38, 0xb3, 0x4e, 0xcb, 0x9d, 0xa5, 0x38, 0xb3, 0x3b, 0x97, 0x66, 0x5e, 0xd8, 0x74, 0xa3, - 0xad, 0xf6, 0x9d, 0xd9, 0x9a, 0xdf, 0xbc, 0xb8, 0xe9, 0x6f, 0xfa, 0x17, 0x19, 0xea, 0x9d, 0xf6, - 0x06, 0xfb, 0xc7, 0xfe, 0xb0, 0x5f, 0x9c, 0xc4, 0xcc, 0xcb, 0x71, 0x33, 0x4d, 0xa7, 0xb6, 0xe5, - 0x7a, 0x24, 0xd8, 0xbd, 0xd8, 0xda, 0xde, 0x64, 0xed, 0x06, 0x24, 0xf4, 0xdb, 0x41, 0x8d, 0x24, - 0x1b, 0xee, 0x58, 0x2b, 0xbc, 0xd8, 0x24, 0x91, 0x93, 0xd1, 0xdd, 0x99, 0x8b, 0x79, 0xb5, 0x82, - 0xb6, 0x17, 0xb9, 0xcd, 0x74, 0x33, 0x9f, 0xe8, 0x56, 0x21, 0xac, 0x6d, 0x91, 0xa6, 0x93, 0xaa, - 0xf7, 0x52, 0x5e, 0xbd, 0x76, 0xe4, 0x36, 0x2e, 0xba, 0x5e, 0x14, 0x46, 0x41, 0xb2, 0x92, 0xfd, - 0x5d, 0x0b, 0xce, 0xcd, 0xdd, 0xae, 0x2e, 0x35, 0x9c, 0x30, 0x72, 0x6b, 0xf3, 0x0d, 0xbf, 0xb6, - 0x5d, 0x8d, 0xfc, 0x80, 0xdc, 0xf2, 0x1b, 0xed, 0x26, 0xa9, 0xb2, 0x81, 0x40, 0xcf, 0xc3, 0xd0, - 0x0e, 0xfb, 0xbf, 0xb2, 0x58, 0xb2, 0xce, 0x59, 0x17, 0x86, 0xe7, 0x27, 0xff, 0x60, 0xaf, 0xfc, - 0xb1, 0xfd, 0xbd, 0xf2, 0xd0, 0x2d, 0x51, 0x8e, 0x15, 0x06, 0x3a, 0x0f, 0x03, 0x1b, 0xe1, 0xfa, - 0x6e, 0x8b, 0x94, 0x0a, 0x0c, 0x77, 0x5c, 0xe0, 0x0e, 0x2c, 0x57, 0x69, 0x29, 0x16, 0x50, 0x74, - 0x11, 0x86, 0x5b, 0x4e, 0x10, 0xb9, 0x91, 0xeb, 0x7b, 0xa5, 0xe2, 0x39, 0xeb, 0x42, 0xff, 0xfc, - 0x94, 0x40, 0x1d, 0xae, 0x48, 0x00, 0x8e, 0x71, 0x68, 0x37, 0x02, 0xe2, 0xd4, 0x6f, 0x78, 0x8d, - 0xdd, 0x52, 0xdf, 0x39, 0xeb, 0xc2, 0x50, 0xdc, 0x0d, 0x2c, 0xca, 0xb1, 0xc2, 0xb0, 0xbf, 0x51, - 0x80, 0xa1, 0xb9, 0x8d, 0x0d, 0xd7, 0x73, 0xa3, 0x5d, 0x74, 0x0b, 0x46, 0x3d, 0xbf, 0x4e, 0xe4, - 0x7f, 0xf6, 0x15, 0x23, 0x2f, 0x9e, 0x9b, 0x4d, 0x2f, 0xa5, 0xd9, 0x35, 0x0d, 0x6f, 0x7e, 0x72, - 0x7f, 0xaf, 0x3c, 0xaa, 0x97, 0x60, 0x83, 0x0e, 0xc2, 0x30, 0xd2, 0xf2, 0xeb, 0x8a, 0x6c, 0x81, - 0x91, 0x2d, 0x67, 0x91, 0xad, 0xc4, 0x68, 0xf3, 0x13, 0xfb, 0x7b, 0xe5, 0x11, 0xad, 0x00, 0xeb, - 0x44, 0xd0, 0x1d, 0x98, 0xa0, 0x7f, 0xbd, 0xc8, 0x55, 0x74, 0x8b, 0x8c, 0xee, 0x13, 0x79, 0x74, - 0x35, 0xd4, 0xf9, 0xe9, 0xfd, 0xbd, 0xf2, 0x44, 0xa2, 0x10, 0x27, 0x09, 0xda, 0x3f, 0x6b, 0xc1, - 0xc4, 0x5c, 0xab, 0x35, 0x17, 0x34, 0xfd, 0xa0, 0x12, 0xf8, 0x1b, 0x6e, 0x83, 0xa0, 0x57, 0xa1, - 0x2f, 0xa2, 0xb3, 0xc6, 0x67, 0xf8, 0x09, 0x31, 0xb4, 0x7d, 0x74, 0xae, 0x0e, 0xf6, 0xca, 0xd3, - 0x09, 0x74, 0x36, 0x95, 0xac, 0x02, 0x7a, 0x0b, 0x26, 0x1b, 0x7e, 0xcd, 0x69, 0x6c, 0xf9, 0x61, - 0x24, 0xa0, 0x62, 0xea, 0x8f, 0xed, 0xef, 0x95, 0x27, 0xaf, 0x27, 0x60, 0x38, 0x85, 0x6d, 0xdf, - 0x87, 0xf1, 0xb9, 0x28, 0x72, 0x6a, 0x5b, 0xa4, 0xce, 0x17, 0x14, 0x7a, 0x19, 0xfa, 0x3c, 0xa7, - 0x29, 0x3b, 0x73, 0x4e, 0x76, 0x66, 0xcd, 0x69, 0xd2, 0xce, 0x4c, 0xde, 0xf4, 0xdc, 0xf7, 0xdb, - 0x62, 0x91, 0xd2, 0x32, 0xcc, 0xb0, 0xd1, 0x8b, 0x00, 0x75, 0xb2, 0xe3, 0xd6, 0x48, 0xc5, 0x89, - 0xb6, 0x44, 0x1f, 0x90, 0xa8, 0x0b, 0x8b, 0x0a, 0x82, 0x35, 0x2c, 0xfb, 0x1e, 0x0c, 0xcf, 0xed, - 0xf8, 0x6e, 0xbd, 0xe2, 0xd7, 0x43, 0xb4, 0x0d, 0x13, 0xad, 0x80, 0x6c, 0x90, 0x40, 0x15, 0x95, - 0xac, 0x73, 0xc5, 0x0b, 0x23, 0x2f, 0x5e, 0xc8, 0x1c, 0x7b, 0x13, 0x75, 0xc9, 0x8b, 0x82, 0xdd, - 0xf9, 0x93, 0xa2, 0xbd, 0x89, 0x04, 0x14, 0x27, 0x29, 0xdb, 0xbf, 0x5f, 0x80, 0xe3, 0x73, 0xf7, - 0xdb, 0x01, 0x59, 0x74, 0xc3, 0xed, 0xe4, 0x86, 0xab, 0xbb, 0xe1, 0xf6, 0x5a, 0x3c, 0x02, 0x6a, - 0xa5, 0x2f, 0x8a, 0x72, 0xac, 0x30, 0xd0, 0x0b, 0x30, 0x48, 0x7f, 0xdf, 0xc4, 0x2b, 0xe2, 0x93, - 0xa7, 0x05, 0xf2, 0xc8, 0xa2, 0x13, 0x39, 0x8b, 0x1c, 0x84, 0x25, 0x0e, 0x5a, 0x85, 0x91, 0x1a, - 0x3b, 0x1f, 0x36, 0x57, 0xfd, 0x3a, 0x61, 0x6b, 0x6b, 0x78, 0xfe, 0x39, 0x8a, 0xbe, 0x10, 0x17, - 0x1f, 0xec, 0x95, 0x4b, 0xbc, 0x6f, 0x82, 0x84, 0x06, 0xc3, 0x7a, 0x7d, 0x64, 0xab, 0xed, 0xde, - 0xc7, 0x28, 0x41, 0xc6, 0x56, 0xbf, 0xa0, 0xed, 0xdc, 0x7e, 0xb6, 0x73, 0x47, 0xb3, 0x77, 0x2d, - 0xba, 0x04, 0x7d, 0xdb, 0xae, 0x57, 0x2f, 0x0d, 0x30, 0x5a, 0x67, 0xe8, 0x9c, 0x5f, 0x73, 0xbd, - 0xfa, 0xc1, 0x5e, 0x79, 0xca, 0xe8, 0x0e, 0x2d, 0xc4, 0x0c, 0xd5, 0xfe, 0xbf, 0x2c, 0x28, 0x33, - 0xd8, 0xb2, 0xdb, 0x20, 0x15, 0x12, 0x84, 0x6e, 0x18, 0x11, 0x2f, 0x32, 0x06, 0xf4, 0x45, 0x80, - 0x90, 0xd4, 0x02, 0x12, 0x69, 0x43, 0xaa, 0x16, 0x46, 0x55, 0x41, 0xb0, 0x86, 0x45, 0xcf, 0xa7, - 0x70, 0xcb, 0x09, 0xd8, 0xfa, 0x12, 0x03, 0xab, 0xce, 0xa7, 0xaa, 0x04, 0xe0, 0x18, 0xc7, 0x38, - 0x9f, 0x8a, 0xdd, 0xce, 0x27, 0xf4, 0x29, 0x98, 0x88, 0x1b, 0x0b, 0x5b, 0x4e, 0x4d, 0x0e, 0x20, - 0xdb, 0xc1, 0x55, 0x13, 0x84, 0x93, 0xb8, 0xf6, 0x7f, 0x66, 0x89, 0xc5, 0x43, 0xbf, 0xfa, 0x43, - 0xfe, 0xad, 0xf6, 0x6f, 0x58, 0x30, 0x38, 0xef, 0x7a, 0x75, 0xd7, 0xdb, 0x44, 0x5f, 0x80, 0x21, - 0x7a, 0x55, 0xd6, 0x9d, 0xc8, 0x11, 0xc7, 0xf0, 0xc7, 0xb5, 0xbd, 0xa5, 0x6e, 0xae, 0xd9, 0xd6, - 0xf6, 0x26, 0x2d, 0x08, 0x67, 0x29, 0x36, 0xdd, 0x6d, 0x37, 0xee, 0x7c, 0x91, 0xd4, 0xa2, 0x55, - 0x12, 0x39, 0xf1, 0xe7, 0xc4, 0x65, 0x58, 0x51, 0x45, 0xd7, 0x60, 0x20, 0x72, 0x82, 0x4d, 0x12, - 0x89, 0xf3, 0x38, 0xf3, 0xdc, 0xe4, 0x35, 0x31, 0xdd, 0x91, 0xc4, 0xab, 0x91, 0xf8, 0x96, 0x5a, - 0x67, 0x55, 0xb1, 0x20, 0x61, 0xff, 0x7f, 0x83, 0x70, 0x6a, 0xa1, 0xba, 0x92, 0xb3, 0xae, 0xce, - 0xc3, 0x40, 0x3d, 0x70, 0x77, 0x48, 0x20, 0xc6, 0x59, 0x51, 0x59, 0x64, 0xa5, 0x58, 0x40, 0xd1, - 0x65, 0x18, 0xe5, 0xf7, 0xe3, 0x55, 0xc7, 0xab, 0xc7, 0xc7, 0xa3, 0xc0, 0x1e, 0xbd, 0xa5, 0xc1, - 0xb0, 0x81, 0x79, 0xc8, 0x45, 0x75, 0x3e, 0xb1, 0x19, 0xf3, 0xee, 0xde, 0xaf, 0x5a, 0x30, 0xc9, - 0x9b, 0x99, 0x8b, 0xa2, 0xc0, 0xbd, 0xd3, 0x8e, 0x48, 0x58, 0xea, 0x67, 0x27, 0xdd, 0x42, 0xd6, - 0x68, 0xe5, 0x8e, 0xc0, 0xec, 0xad, 0x04, 0x15, 0x7e, 0x08, 0x96, 0x44, 0xbb, 0x93, 0x49, 0x30, - 0x4e, 0x35, 0x8b, 0xfe, 0xa1, 0x05, 0x33, 0x35, 0xdf, 0x8b, 0x02, 0xbf, 0xd1, 0x20, 0x41, 0xa5, - 0x7d, 0xa7, 0xe1, 0x86, 0x5b, 0x7c, 0x9d, 0x62, 0xb2, 0xc1, 0x4e, 0x82, 0x9c, 0x39, 0x54, 0x48, - 0x62, 0x0e, 0xcf, 0xee, 0xef, 0x95, 0x67, 0x16, 0x72, 0x49, 0xe1, 0x0e, 0xcd, 0xa0, 0x6d, 0x40, - 0xf4, 0x66, 0xaf, 0x46, 0xce, 0x26, 0x89, 0x1b, 0x1f, 0xec, 0xbd, 0xf1, 0x13, 0xfb, 0x7b, 0x65, - 0xb4, 0x96, 0x22, 0x81, 0x33, 0xc8, 0xa2, 0xf7, 0xe1, 0x18, 0x2d, 0x4d, 0x7d, 0xeb, 0x50, 0xef, - 0xcd, 0x95, 0xf6, 0xf7, 0xca, 0xc7, 0xd6, 0x32, 0x88, 0xe0, 0x4c, 0xd2, 0xe8, 0xa7, 0x2c, 0x38, - 0x15, 0x7f, 0xfe, 0xd2, 0xbd, 0x96, 0xe3, 0xd5, 0xe3, 0x86, 0x87, 0x7b, 0x6f, 0x98, 0x9e, 0xc9, - 0xa7, 0x16, 0xf2, 0x28, 0xe1, 0xfc, 0x46, 0x90, 0x07, 0xd3, 0xb4, 0x6b, 0xc9, 0xb6, 0xa1, 0xf7, - 0xb6, 0x4f, 0xee, 0xef, 0x95, 0xa7, 0xd7, 0xd2, 0x34, 0x70, 0x16, 0xe1, 0x99, 0x05, 0x38, 0x9e, - 0xb9, 0x3a, 0xd1, 0x24, 0x14, 0xb7, 0x09, 0x67, 0x02, 0x87, 0x31, 0xfd, 0x89, 0x8e, 0x41, 0xff, - 0x8e, 0xd3, 0x68, 0x8b, 0x8d, 0x89, 0xf9, 0x9f, 0xd7, 0x0a, 0x97, 0x2d, 0xfb, 0xbf, 0x2f, 0xc2, - 0xc4, 0x42, 0x75, 0xe5, 0x81, 0x76, 0xbd, 0x7e, 0xed, 0x15, 0x3a, 0x5e, 0x7b, 0xf1, 0x25, 0x5a, - 0xcc, 0xbd, 0x44, 0x7f, 0x32, 0x63, 0xcb, 0xf6, 0xb1, 0x2d, 0xfb, 0xc9, 0x9c, 0x2d, 0xfb, 0x90, - 0x37, 0xea, 0x4e, 0xce, 0xaa, 0xed, 0x67, 0x13, 0x98, 0xc9, 0x21, 0x31, 0xde, 0x2f, 0x79, 0xd4, - 0x1e, 0x72, 0xe9, 0x3e, 0x9c, 0x79, 0xac, 0xc1, 0xe8, 0x82, 0xd3, 0x72, 0xee, 0xb8, 0x0d, 0x37, - 0x72, 0x49, 0x88, 0x9e, 0x86, 0xa2, 0x53, 0xaf, 0x33, 0xee, 0x6e, 0x78, 0xfe, 0xf8, 0xfe, 0x5e, - 0xb9, 0x38, 0x57, 0xa7, 0x6c, 0x06, 0x28, 0xac, 0x5d, 0x4c, 0x31, 0xd0, 0xb3, 0xd0, 0x57, 0x0f, - 0xfc, 0x56, 0xa9, 0xc0, 0x30, 0xe9, 0x2e, 0xef, 0x5b, 0x0c, 0xfc, 0x56, 0x02, 0x95, 0xe1, 0xd8, - 0xbf, 0x57, 0x80, 0xd3, 0x0b, 0xa4, 0xb5, 0xb5, 0x5c, 0xcd, 0xb9, 0x2f, 0x2e, 0xc0, 0x50, 0xd3, - 0xf7, 0xdc, 0xc8, 0x0f, 0x42, 0xd1, 0x34, 0x5b, 0x11, 0xab, 0xa2, 0x0c, 0x2b, 0x28, 0x3a, 0x07, - 0x7d, 0xad, 0x98, 0x89, 0x1d, 0x95, 0x0c, 0x30, 0x63, 0x5f, 0x19, 0x84, 0x62, 0xb4, 0x43, 0x12, - 0x88, 0x15, 0xa3, 0x30, 0x6e, 0x86, 0x24, 0xc0, 0x0c, 0x12, 0x73, 0x02, 0x94, 0x47, 0x10, 0x37, - 0x42, 0x82, 0x13, 0xa0, 0x10, 0xac, 0x61, 0xa1, 0x0a, 0x0c, 0x87, 0x89, 0x99, 0xed, 0x69, 0x6b, - 0x8e, 0x31, 0x56, 0x41, 0xcd, 0x64, 0x4c, 0xc4, 0xb8, 0xc1, 0x06, 0xba, 0xb2, 0x0a, 0xdf, 0x2e, - 0x00, 0xe2, 0x43, 0xf8, 0x23, 0x36, 0x70, 0x37, 0xd3, 0x03, 0xd7, 0xfb, 0x96, 0x78, 0x58, 0xa3, - 0xf7, 0x7f, 0x5b, 0x70, 0x7a, 0xc1, 0xf5, 0xea, 0x24, 0xc8, 0x59, 0x80, 0x8f, 0xe6, 0x29, 0x7f, - 0x38, 0x26, 0xc5, 0x58, 0x62, 0x7d, 0x0f, 0x61, 0x89, 0xd9, 0x7f, 0x6d, 0x01, 0xe2, 0x9f, 0xfd, - 0xa1, 0xfb, 0xd8, 0x9b, 0xe9, 0x8f, 0x7d, 0x08, 0xcb, 0xc2, 0xbe, 0x0e, 0xe3, 0x0b, 0x0d, 0x97, - 0x78, 0xd1, 0x4a, 0x65, 0xc1, 0xf7, 0x36, 0xdc, 0x4d, 0xf4, 0x1a, 0x8c, 0x47, 0x6e, 0x93, 0xf8, - 0xed, 0xa8, 0x4a, 0x6a, 0xbe, 0xc7, 0x5e, 0xae, 0xd6, 0x85, 0xfe, 0x79, 0xb4, 0xbf, 0x57, 0x1e, - 0x5f, 0x37, 0x20, 0x38, 0x81, 0x69, 0xff, 0x5b, 0x7a, 0x6e, 0x35, 0xda, 0x61, 0x44, 0x82, 0xf5, - 0xa0, 0x1d, 0x46, 0xf3, 0x6d, 0xca, 0x7b, 0x56, 0x02, 0x9f, 0x76, 0xc7, 0xf5, 0x3d, 0x74, 0xda, - 0x78, 0x8e, 0x0f, 0xc9, 0xa7, 0xb8, 0x78, 0x76, 0xcf, 0x02, 0x84, 0xee, 0xa6, 0x47, 0x02, 0xed, - 0xf9, 0x30, 0xce, 0xb6, 0x8a, 0x2a, 0xc5, 0x1a, 0x06, 0x6a, 0xc0, 0x58, 0xc3, 0xb9, 0x43, 0x1a, - 0x55, 0xd2, 0x20, 0xb5, 0xc8, 0x0f, 0x84, 0x7c, 0xe3, 0xa5, 0xde, 0xde, 0x01, 0xd7, 0xf5, 0xaa, - 0xf3, 0x53, 0xfb, 0x7b, 0xe5, 0x31, 0xa3, 0x08, 0x9b, 0xc4, 0xe9, 0xd1, 0xe1, 0xb7, 0xe8, 0x57, - 0x38, 0x0d, 0xfd, 0xf1, 0x79, 0x43, 0x94, 0x61, 0x05, 0x55, 0x47, 0x47, 0x5f, 0xde, 0xd1, 0x61, - 0xff, 0x19, 0x5d, 0x68, 0x7e, 0xb3, 0xe5, 0x7b, 0xc4, 0x8b, 0x16, 0x7c, 0xaf, 0xce, 0x25, 0x53, - 0xaf, 0x19, 0xa2, 0x93, 0xf3, 0x09, 0xd1, 0xc9, 0x89, 0x74, 0x0d, 0x4d, 0x7a, 0xf2, 0x49, 0x18, - 0x08, 0x23, 0x27, 0x6a, 0x87, 0x62, 0xe0, 0x1e, 0x97, 0xcb, 0xae, 0xca, 0x4a, 0x0f, 0xf6, 0xca, - 0x13, 0xaa, 0x1a, 0x2f, 0xc2, 0xa2, 0x02, 0x7a, 0x06, 0x06, 0x9b, 0x24, 0x0c, 0x9d, 0x4d, 0xc9, - 0x36, 0x4c, 0x88, 0xba, 0x83, 0xab, 0xbc, 0x18, 0x4b, 0x38, 0x7a, 0x02, 0xfa, 0x49, 0x10, 0xf8, - 0x81, 0xf8, 0xb6, 0x31, 0x81, 0xd8, 0xbf, 0x44, 0x0b, 0x31, 0x87, 0xd9, 0xff, 0x93, 0x05, 0x13, - 0xaa, 0xaf, 0xbc, 0xad, 0x23, 0x78, 0xae, 0xbd, 0x0b, 0x50, 0x93, 0x1f, 0x18, 0xb2, 0x6b, 0x76, - 0xe4, 0xc5, 0xf3, 0x99, 0x1c, 0x4d, 0x6a, 0x18, 0x63, 0xca, 0xaa, 0x28, 0xc4, 0x1a, 0x35, 0xfb, - 0xb7, 0x2d, 0x98, 0x4e, 0x7c, 0xd1, 0x75, 0x37, 0x8c, 0xd0, 0x7b, 0xa9, 0xaf, 0x9a, 0xed, 0x71, - 0xf1, 0xb9, 0x21, 0xff, 0x26, 0xb5, 0xe7, 0x65, 0x89, 0xf6, 0x45, 0x57, 0xa1, 0xdf, 0x8d, 0x48, - 0x53, 0x7e, 0xcc, 0x13, 0x1d, 0x3f, 0x86, 0xf7, 0x2a, 0x9e, 0x91, 0x15, 0x5a, 0x13, 0x73, 0x02, - 0xf6, 0xef, 0x15, 0x61, 0x98, 0xef, 0xef, 0x55, 0xa7, 0x75, 0x04, 0x73, 0xf1, 0x1c, 0x0c, 0xbb, - 0xcd, 0x66, 0x3b, 0x72, 0xee, 0x88, 0x7b, 0x6f, 0x88, 0x9f, 0x41, 0x2b, 0xb2, 0x10, 0xc7, 0x70, - 0xb4, 0x02, 0x7d, 0xac, 0x2b, 0xfc, 0x2b, 0x9f, 0xce, 0xfe, 0x4a, 0xd1, 0xf7, 0xd9, 0x45, 0x27, - 0x72, 0x38, 0xcb, 0xa9, 0xf6, 0x15, 0x2d, 0xc2, 0x8c, 0x04, 0x72, 0x00, 0xee, 0xb8, 0x9e, 0x13, - 0xec, 0xd2, 0xb2, 0x52, 0x91, 0x11, 0x7c, 0xa1, 0x33, 0xc1, 0x79, 0x85, 0xcf, 0xc9, 0xaa, 0x0f, - 0x8b, 0x01, 0x58, 0x23, 0x3a, 0xf3, 0x2a, 0x0c, 0x2b, 0xe4, 0xc3, 0x70, 0x8e, 0x33, 0x9f, 0x82, - 0x89, 0x44, 0x5b, 0xdd, 0xaa, 0x8f, 0xea, 0x8c, 0xe7, 0x6f, 0xb2, 0x23, 0x43, 0xf4, 0x7a, 0xc9, - 0xdb, 0x11, 0x77, 0xd3, 0x7d, 0x38, 0xd6, 0xc8, 0x38, 0xf2, 0xc5, 0xbc, 0xf6, 0x7e, 0x45, 0x9c, - 0x16, 0x9f, 0x7d, 0x2c, 0x0b, 0x8a, 0x33, 0xdb, 0x30, 0x4e, 0xc4, 0x42, 0xa7, 0x13, 0x91, 0x9e, - 0x77, 0xc7, 0x54, 0xe7, 0xaf, 0x91, 0x5d, 0x75, 0xa8, 0xfe, 0x30, 0xbb, 0x7f, 0x86, 0x8f, 0x3e, - 0x3f, 0x2e, 0x47, 0x04, 0x81, 0xe2, 0x35, 0xb2, 0xcb, 0xa7, 0x42, 0xff, 0xba, 0x62, 0xc7, 0xaf, - 0xfb, 0x96, 0x05, 0x63, 0xea, 0xeb, 0x8e, 0xe0, 0x5c, 0x98, 0x37, 0xcf, 0x85, 0x33, 0x1d, 0x17, - 0x78, 0xce, 0x89, 0xf0, 0xed, 0x02, 0x9c, 0x52, 0x38, 0xf4, 0x11, 0xc5, 0xff, 0x88, 0x55, 0x75, - 0x11, 0x86, 0x3d, 0x25, 0x4e, 0xb4, 0x4c, 0x39, 0x5e, 0x2c, 0x4c, 0x8c, 0x71, 0xe8, 0x95, 0xe7, - 0xc5, 0x97, 0xf6, 0xa8, 0x2e, 0x67, 0x17, 0x97, 0xfb, 0x3c, 0x14, 0xdb, 0x6e, 0x5d, 0x5c, 0x30, - 0x1f, 0x97, 0xa3, 0x7d, 0x73, 0x65, 0xf1, 0x60, 0xaf, 0xfc, 0x78, 0x9e, 0xca, 0x89, 0xde, 0x6c, - 0xe1, 0xec, 0xcd, 0x95, 0x45, 0x4c, 0x2b, 0xa3, 0x39, 0x98, 0x90, 0x5a, 0xb5, 0x5b, 0x94, 0x2f, - 0xf5, 0x3d, 0x71, 0x0f, 0x29, 0x61, 0x39, 0x36, 0xc1, 0x38, 0x89, 0x8f, 0x16, 0x61, 0x72, 0xbb, - 0x7d, 0x87, 0x34, 0x48, 0xc4, 0x3f, 0xf8, 0x1a, 0xe1, 0xa2, 0xe4, 0xe1, 0xf8, 0x09, 0x7b, 0x2d, - 0x01, 0xc7, 0xa9, 0x1a, 0xf6, 0x0f, 0xd8, 0x7d, 0x20, 0x46, 0x4f, 0xe3, 0x6f, 0x7e, 0x98, 0xcb, - 0xb9, 0x97, 0x55, 0x71, 0x8d, 0xec, 0xae, 0xfb, 0x94, 0x0f, 0xc9, 0x5e, 0x15, 0xc6, 0x9a, 0xef, - 0xeb, 0xb8, 0xe6, 0x7f, 0xb5, 0x00, 0xc7, 0xd5, 0x08, 0x18, 0xdc, 0xf2, 0x8f, 0xfa, 0x18, 0x5c, - 0x82, 0x91, 0x3a, 0xd9, 0x70, 0xda, 0x8d, 0x48, 0xe9, 0x35, 0xfa, 0xb9, 0xaa, 0x6d, 0x31, 0x2e, - 0xc6, 0x3a, 0xce, 0x21, 0x86, 0xed, 0x97, 0xc6, 0xd8, 0x45, 0x1c, 0x39, 0x74, 0x8d, 0xab, 0x5d, - 0x63, 0xe5, 0xee, 0x9a, 0x27, 0xa0, 0xdf, 0x6d, 0x52, 0xc6, 0xac, 0x60, 0xf2, 0x5b, 0x2b, 0xb4, - 0x10, 0x73, 0x18, 0x7a, 0x0a, 0x06, 0x6b, 0x7e, 0xb3, 0xe9, 0x78, 0x75, 0x76, 0xe5, 0x0d, 0xcf, - 0x8f, 0x50, 0xde, 0x6d, 0x81, 0x17, 0x61, 0x09, 0xa3, 0xcc, 0xb7, 0x13, 0x6c, 0x72, 0x61, 0x8f, - 0x60, 0xbe, 0xe7, 0x82, 0xcd, 0x10, 0xb3, 0x52, 0xfa, 0x56, 0xbd, 0xeb, 0x07, 0xdb, 0xae, 0xb7, - 0xb9, 0xe8, 0x06, 0x62, 0x4b, 0xa8, 0xbb, 0xf0, 0xb6, 0x82, 0x60, 0x0d, 0x0b, 0x2d, 0x43, 0x7f, - 0xcb, 0x0f, 0xa2, 0xb0, 0x34, 0xc0, 0x86, 0xfb, 0xf1, 0x9c, 0x83, 0x88, 0x7f, 0x6d, 0xc5, 0x0f, - 0xa2, 0xf8, 0x03, 0xe8, 0xbf, 0x10, 0xf3, 0xea, 0xe8, 0x3a, 0x0c, 0x12, 0x6f, 0x67, 0x39, 0xf0, - 0x9b, 0xa5, 0xe9, 0x7c, 0x4a, 0x4b, 0x1c, 0x85, 0x2f, 0xb3, 0x98, 0x47, 0x15, 0xc5, 0x58, 0x92, - 0x40, 0x9f, 0x84, 0x22, 0xf1, 0x76, 0x4a, 0x83, 0x8c, 0xd2, 0x4c, 0x0e, 0xa5, 0x5b, 0x4e, 0x10, - 0x9f, 0xf9, 0x4b, 0xde, 0x0e, 0xa6, 0x75, 0xd0, 0x67, 0x60, 0x58, 0x1e, 0x18, 0xa1, 0x90, 0xa2, - 0x66, 0x2e, 0x58, 0x79, 0xcc, 0x60, 0xf2, 0x7e, 0xdb, 0x0d, 0x48, 0x93, 0x78, 0x51, 0x18, 0x9f, - 0x90, 0x12, 0x1a, 0xe2, 0x98, 0x1a, 0xaa, 0xc1, 0x68, 0x40, 0x42, 0xf7, 0x3e, 0xa9, 0xf8, 0x0d, - 0xb7, 0xb6, 0x5b, 0x3a, 0xc9, 0xba, 0xf7, 0x4c, 0xc7, 0x21, 0xc3, 0x5a, 0x85, 0x58, 0xca, 0xaf, - 0x97, 0x62, 0x83, 0x28, 0x7a, 0x07, 0xc6, 0x02, 0x12, 0x46, 0x4e, 0x10, 0x89, 0x56, 0x4a, 0x4a, - 0x2b, 0x37, 0x86, 0x75, 0x00, 0x7f, 0x4e, 0xc4, 0xcd, 0xc4, 0x10, 0x6c, 0x52, 0x40, 0x9f, 0x91, - 0x2a, 0x87, 0x55, 0xbf, 0xed, 0x45, 0x61, 0x69, 0x98, 0xf5, 0x3b, 0x53, 0x37, 0x7d, 0x2b, 0xc6, - 0x4b, 0xea, 0x24, 0x78, 0x65, 0x6c, 0x90, 0x42, 0x9f, 0x83, 0x31, 0xfe, 0x9f, 0xab, 0x54, 0xc3, - 0xd2, 0x71, 0x46, 0xfb, 0x5c, 0x3e, 0x6d, 0x8e, 0x38, 0x7f, 0x5c, 0x10, 0x1f, 0xd3, 0x4b, 0x43, - 0x6c, 0x52, 0x43, 0x18, 0xc6, 0x1a, 0xee, 0x0e, 0xf1, 0x48, 0x18, 0x56, 0x02, 0xff, 0x0e, 0x11, - 0x12, 0xe2, 0x53, 0xd9, 0x2a, 0x58, 0xff, 0x0e, 0x11, 0x8f, 0x40, 0xbd, 0x0e, 0x36, 0x49, 0xa0, - 0x9b, 0x30, 0x4e, 0x9f, 0xe4, 0x6e, 0x4c, 0x74, 0xa4, 0x1b, 0x51, 0xf6, 0x70, 0xc6, 0x46, 0x25, - 0x9c, 0x20, 0x82, 0x6e, 0xc0, 0x28, 0x1b, 0xf3, 0x76, 0x8b, 0x13, 0x3d, 0xd1, 0x8d, 0x28, 0x33, - 0x28, 0xa8, 0x6a, 0x55, 0xb0, 0x41, 0x00, 0xbd, 0x0d, 0xc3, 0x0d, 0x77, 0x83, 0xd4, 0x76, 0x6b, - 0x0d, 0x52, 0x1a, 0x65, 0xd4, 0x32, 0x0f, 0xc3, 0xeb, 0x12, 0x89, 0xf3, 0xe7, 0xea, 0x2f, 0x8e, - 0xab, 0xa3, 0x5b, 0x70, 0x22, 0x22, 0x41, 0xd3, 0xf5, 0x1c, 0x7a, 0x88, 0x89, 0x27, 0x21, 0xd3, - 0x8c, 0x8f, 0xb1, 0xd5, 0x75, 0x56, 0xcc, 0xc6, 0x89, 0xf5, 0x4c, 0x2c, 0x9c, 0x53, 0x1b, 0xdd, - 0x83, 0x52, 0x06, 0x84, 0xaf, 0xdb, 0x63, 0x8c, 0xf2, 0x1b, 0x82, 0x72, 0x69, 0x3d, 0x07, 0xef, - 0xa0, 0x03, 0x0c, 0xe7, 0x52, 0x47, 0x37, 0x60, 0x82, 0x9d, 0x9c, 0x95, 0x76, 0xa3, 0x21, 0x1a, - 0x1c, 0x67, 0x0d, 0x3e, 0x25, 0xf9, 0x88, 0x15, 0x13, 0x7c, 0xb0, 0x57, 0x86, 0xf8, 0x1f, 0x4e, - 0xd6, 0x46, 0x77, 0x98, 0x12, 0xb6, 0x1d, 0xb8, 0xd1, 0x2e, 0xdd, 0x55, 0xe4, 0x5e, 0x54, 0x9a, - 0xe8, 0x28, 0x90, 0xd2, 0x51, 0x95, 0xa6, 0x56, 0x2f, 0xc4, 0x49, 0x82, 0xf4, 0x2a, 0x08, 0xa3, - 0xba, 0xeb, 0x95, 0x26, 0xf9, 0x7b, 0x4a, 0x9e, 0xa4, 0x55, 0x5a, 0x88, 0x39, 0x8c, 0x29, 0x60, - 0xe9, 0x8f, 0x1b, 0xf4, 0xc6, 0x9d, 0x62, 0x88, 0xb1, 0x02, 0x56, 0x02, 0x70, 0x8c, 0x43, 0x99, - 0xe0, 0x28, 0xda, 0x2d, 0x21, 0x86, 0xaa, 0x0e, 0xc4, 0xf5, 0xf5, 0xcf, 0x60, 0x5a, 0x6e, 0xdf, - 0x81, 0x71, 0x75, 0x4c, 0xb0, 0x31, 0x41, 0x65, 0xe8, 0x67, 0x6c, 0x9f, 0x10, 0x9f, 0x0e, 0xd3, - 0x2e, 0x30, 0x96, 0x10, 0xf3, 0x72, 0xd6, 0x05, 0xf7, 0x3e, 0x99, 0xdf, 0x8d, 0x08, 0x97, 0x45, - 0x14, 0xb5, 0x2e, 0x48, 0x00, 0x8e, 0x71, 0xec, 0xff, 0x9f, 0xb3, 0xcf, 0xf1, 0x2d, 0xd1, 0xc3, - 0xbd, 0xf8, 0x3c, 0x0c, 0x31, 0xc3, 0x0f, 0x3f, 0xe0, 0xda, 0xd9, 0xfe, 0x98, 0x61, 0xbe, 0x2a, - 0xca, 0xb1, 0xc2, 0x40, 0xaf, 0xc3, 0x58, 0x4d, 0x6f, 0x40, 0x5c, 0xea, 0xea, 0x18, 0x31, 0x5a, - 0xc7, 0x26, 0x2e, 0xba, 0x0c, 0x43, 0xcc, 0xc6, 0xa9, 0xe6, 0x37, 0x04, 0xb7, 0x29, 0x39, 0x93, - 0xa1, 0x8a, 0x28, 0x3f, 0xd0, 0x7e, 0x63, 0x85, 0x8d, 0xce, 0xc3, 0x00, 0xed, 0xc2, 0x4a, 0x45, - 0x5c, 0xa7, 0x4a, 0x12, 0x78, 0x95, 0x95, 0x62, 0x01, 0xb5, 0x7f, 0xdb, 0x62, 0xbc, 0x54, 0xfa, - 0xcc, 0x47, 0x57, 0xd9, 0xa5, 0xc1, 0x6e, 0x10, 0x4d, 0x0b, 0xff, 0xa4, 0x76, 0x13, 0x28, 0xd8, - 0x41, 0xe2, 0x3f, 0x36, 0x6a, 0xa2, 0x77, 0x93, 0x37, 0x03, 0x67, 0x28, 0x5e, 0x96, 0x43, 0x90, - 0xbc, 0x1d, 0x1e, 0x8b, 0xaf, 0x38, 0xda, 0x9f, 0x4e, 0x57, 0x84, 0xfd, 0x4f, 0x0a, 0xda, 0x2a, - 0xa9, 0x46, 0x4e, 0x44, 0x50, 0x05, 0x06, 0xef, 0x3a, 0x6e, 0xe4, 0x7a, 0x9b, 0x82, 0xef, 0xeb, - 0x7c, 0xd1, 0xb1, 0x4a, 0xb7, 0x79, 0x05, 0xce, 0xbd, 0x88, 0x3f, 0x58, 0x92, 0xa1, 0x14, 0x83, - 0xb6, 0xe7, 0x51, 0x8a, 0x85, 0x5e, 0x29, 0x62, 0x5e, 0x81, 0x53, 0x14, 0x7f, 0xb0, 0x24, 0x83, - 0xde, 0x03, 0x90, 0x27, 0x04, 0xa9, 0x0b, 0xd9, 0xe1, 0xf3, 0xdd, 0x89, 0xae, 0xab, 0x3a, 0x5c, - 0x38, 0x19, 0xff, 0xc7, 0x1a, 0x3d, 0x3b, 0xd2, 0xe6, 0x54, 0xef, 0x0c, 0xfa, 0x2c, 0xdd, 0xa2, - 0x4e, 0x10, 0x91, 0xfa, 0x5c, 0x24, 0x06, 0xe7, 0xd9, 0xde, 0x1e, 0x87, 0xeb, 0x6e, 0x93, 0xe8, - 0xdb, 0x59, 0x10, 0xc1, 0x31, 0x3d, 0xfb, 0xd7, 0x8b, 0x50, 0xca, 0xeb, 0x2e, 0xdd, 0x34, 0xe4, - 0x9e, 0x1b, 0x2d, 0x50, 0xb6, 0xd6, 0x32, 0x37, 0xcd, 0x92, 0x28, 0xc7, 0x0a, 0x83, 0xae, 0xde, - 0xd0, 0xdd, 0x94, 0x6f, 0xfb, 0xfe, 0x78, 0xf5, 0x56, 0x59, 0x29, 0x16, 0x50, 0x8a, 0x17, 0x10, - 0x27, 0x14, 0xc6, 0x77, 0xda, 0x2a, 0xc7, 0xac, 0x14, 0x0b, 0xa8, 0x2e, 0x65, 0xec, 0xeb, 0x22, - 0x65, 0x34, 0x86, 0xa8, 0xff, 0xe1, 0x0e, 0x11, 0xfa, 0x3c, 0xc0, 0x86, 0xeb, 0xb9, 0xe1, 0x16, - 0xa3, 0x3e, 0x70, 0x68, 0xea, 0x8a, 0x29, 0x5e, 0x56, 0x54, 0xb0, 0x46, 0x11, 0xbd, 0x02, 0x23, - 0xea, 0x00, 0x59, 0x59, 0x64, 0xaa, 0x7f, 0xcd, 0x94, 0x2a, 0x3e, 0x4d, 0x17, 0xb1, 0x8e, 0x67, - 0x7f, 0x31, 0xb9, 0x5e, 0xc4, 0x0e, 0xd0, 0xc6, 0xd7, 0xea, 0x75, 0x7c, 0x0b, 0x9d, 0xc7, 0xd7, - 0xfe, 0xe3, 0x61, 0x98, 0x30, 0x1a, 0x6b, 0x87, 0x3d, 0x9c, 0xb9, 0x57, 0xe8, 0x05, 0xe4, 0x44, - 0x44, 0xec, 0x3f, 0xbb, 0xfb, 0x56, 0xd1, 0x2f, 0x29, 0xba, 0x03, 0x78, 0x7d, 0xf4, 0x79, 0x18, - 0x6e, 0x38, 0x21, 0x93, 0x58, 0x12, 0xb1, 0xef, 0x7a, 0x21, 0x16, 0x3f, 0x08, 0x9d, 0x30, 0xd2, - 0x6e, 0x7d, 0x4e, 0x3b, 0x26, 0x49, 0x6f, 0x4a, 0xca, 0x5f, 0x49, 0xeb, 0x4e, 0xd5, 0x09, 0xca, - 0x84, 0xed, 0x62, 0x0e, 0x43, 0x97, 0xd9, 0xd1, 0x4a, 0x57, 0xc5, 0x02, 0xe5, 0x46, 0xd9, 0x32, - 0xeb, 0x37, 0x98, 0x6c, 0x05, 0xc3, 0x06, 0x66, 0xfc, 0x26, 0x1b, 0xe8, 0xf0, 0x26, 0x7b, 0x06, - 0x06, 0xd9, 0x0f, 0xb5, 0x02, 0xd4, 0x6c, 0xac, 0xf0, 0x62, 0x2c, 0xe1, 0xc9, 0x05, 0x33, 0xd4, - 0xdb, 0x82, 0xa1, 0xaf, 0x3e, 0xb1, 0xa8, 0x99, 0xd9, 0xc5, 0x10, 0x3f, 0xe5, 0xc4, 0x92, 0xc7, - 0x12, 0x86, 0x7e, 0xde, 0x02, 0xe4, 0x34, 0xe8, 0x6b, 0x99, 0x16, 0xab, 0xc7, 0x0d, 0x30, 0x56, - 0xfb, 0xf5, 0xae, 0xc3, 0xde, 0x0e, 0x67, 0xe7, 0x52, 0xb5, 0xb9, 0xa4, 0xf4, 0x35, 0xd1, 0x45, - 0x94, 0x46, 0xd0, 0x2f, 0xa3, 0xeb, 0x6e, 0x18, 0x7d, 0xf9, 0xcf, 0x13, 0x97, 0x53, 0x46, 0x97, - 0xd0, 0x4d, 0xfd, 0xf1, 0x35, 0x72, 0xc8, 0xc7, 0xd7, 0x58, 0xee, 0xc3, 0xeb, 0xef, 0x25, 0x1e, - 0x30, 0xa3, 0xec, 0xcb, 0x9f, 0xea, 0xf2, 0x80, 0x11, 0xe2, 0xf4, 0x5e, 0x9e, 0x31, 0x15, 0xa1, - 0x07, 0x1e, 0x63, 0x5d, 0xee, 0xfc, 0x08, 0xbe, 0x19, 0x92, 0x60, 0xfe, 0x94, 0x54, 0x13, 0x1f, - 0xe8, 0xbc, 0x87, 0xa6, 0x37, 0xfe, 0x29, 0x0b, 0x4a, 0xe9, 0x01, 0xe2, 0x5d, 0x2a, 0x8d, 0xb3, - 0xfe, 0xdb, 0x9d, 0x46, 0x46, 0x74, 0x5e, 0x9a, 0xbb, 0x96, 0xe6, 0x72, 0x68, 0xe1, 0xdc, 0x56, - 0xd0, 0x65, 0x80, 0x30, 0xf2, 0x5b, 0xfc, 0xac, 0x67, 0xcc, 0xec, 0x30, 0x33, 0xb8, 0x80, 0xaa, - 0x2a, 0x3d, 0x88, 0xef, 0x02, 0x0d, 0x77, 0xa6, 0x0d, 0x27, 0x73, 0x56, 0x4c, 0x86, 0xbc, 0x7b, - 0x51, 0x97, 0x77, 0x77, 0x91, 0x92, 0xce, 0xca, 0x39, 0x9d, 0x7d, 0xa7, 0xed, 0x78, 0x91, 0x1b, - 0xed, 0xea, 0xf2, 0x71, 0x0f, 0xcc, 0xa1, 0x44, 0x9f, 0x83, 0xfe, 0x86, 0xeb, 0xb5, 0xef, 0x89, - 0x3b, 0xf6, 0x7c, 0xf6, 0xf3, 0xc7, 0x6b, 0xdf, 0x33, 0x27, 0xa7, 0x4c, 0xb7, 0x32, 0x2b, 0x3f, - 0xd8, 0x2b, 0xa3, 0x34, 0x02, 0xe6, 0x54, 0xed, 0x67, 0x61, 0x7c, 0xd1, 0x21, 0x4d, 0xdf, 0x5b, - 0xf2, 0xea, 0x2d, 0xdf, 0xf5, 0x22, 0x54, 0x82, 0x3e, 0xc6, 0x5c, 0xf2, 0xab, 0xb5, 0x8f, 0x0e, - 0x3e, 0x66, 0x25, 0xf6, 0x26, 0x1c, 0x5f, 0xf4, 0xef, 0x7a, 0x77, 0x9d, 0xa0, 0x3e, 0x57, 0x59, - 0xd1, 0xe4, 0x85, 0x6b, 0x52, 0x5e, 0x65, 0xe5, 0x4b, 0x03, 0xb4, 0x9a, 0x7c, 0x11, 0x2e, 0xbb, - 0x0d, 0x92, 0x23, 0xd5, 0xfd, 0xe7, 0x05, 0xa3, 0xa5, 0x18, 0x5f, 0xe9, 0x24, 0xad, 0x5c, 0x73, - 0x86, 0x77, 0x60, 0x68, 0xc3, 0x25, 0x8d, 0x3a, 0x26, 0x1b, 0x62, 0x36, 0x9e, 0xce, 0x37, 0x78, - 0x5c, 0xa6, 0x98, 0x4a, 0x79, 0xca, 0xa4, 0x5d, 0xcb, 0xa2, 0x32, 0x56, 0x64, 0xd0, 0x36, 0x4c, - 0xca, 0x39, 0x93, 0x50, 0x71, 0xde, 0x3f, 0xd3, 0x69, 0xf9, 0x9a, 0xc4, 0x99, 0xf1, 0x37, 0x4e, - 0x90, 0xc1, 0x29, 0xc2, 0xe8, 0x34, 0xf4, 0x35, 0x29, 0x67, 0xd3, 0xc7, 0x86, 0x9f, 0x89, 0xb7, - 0x98, 0xa4, 0x8e, 0x95, 0xda, 0xff, 0xc2, 0x82, 0x93, 0xa9, 0x91, 0x11, 0x12, 0xcb, 0x87, 0x3c, - 0x0b, 0x49, 0x09, 0x62, 0xa1, 0xbb, 0x04, 0xd1, 0xfe, 0xcf, 0x2d, 0x38, 0xb6, 0xd4, 0x6c, 0x45, - 0xbb, 0x8b, 0xae, 0x69, 0x7b, 0xf0, 0x2a, 0x0c, 0x34, 0x49, 0xdd, 0x6d, 0x37, 0xc5, 0xcc, 0x95, - 0xe5, 0xed, 0xbf, 0xca, 0x4a, 0xe9, 0x09, 0x52, 0x8d, 0xfc, 0xc0, 0xd9, 0x24, 0xbc, 0x00, 0x0b, - 0x74, 0xc6, 0x43, 0xb9, 0xf7, 0xc9, 0x75, 0xb7, 0xe9, 0x46, 0x0f, 0xb6, 0xbb, 0x84, 0xd9, 0x80, - 0x24, 0x82, 0x63, 0x7a, 0xf6, 0x77, 0x2d, 0x98, 0x90, 0xeb, 0x7e, 0xae, 0x5e, 0x0f, 0x48, 0x18, - 0xa2, 0x19, 0x28, 0xb8, 0x2d, 0xd1, 0x4b, 0x10, 0xbd, 0x2c, 0xac, 0x54, 0x70, 0xc1, 0x6d, 0xc9, - 0xe7, 0x1a, 0x63, 0x30, 0x8a, 0xa6, 0x05, 0xc5, 0x55, 0x51, 0x8e, 0x15, 0x06, 0xba, 0x00, 0x43, - 0x9e, 0x5f, 0xe7, 0x2f, 0x1e, 0xa1, 0x43, 0xa7, 0x98, 0x6b, 0xa2, 0x0c, 0x2b, 0x28, 0xaa, 0xc0, - 0x30, 0xb7, 0xaf, 0x8d, 0x17, 0x6d, 0x4f, 0x56, 0xba, 0xec, 0xcb, 0xd6, 0x65, 0x4d, 0x1c, 0x13, - 0xb1, 0x7f, 0xd7, 0x82, 0x51, 0xf9, 0x65, 0x3d, 0xbe, 0x45, 0xe9, 0xd6, 0x8a, 0xdf, 0xa1, 0xf1, - 0xd6, 0xa2, 0x6f, 0x49, 0x06, 0x31, 0x9e, 0x90, 0xc5, 0x43, 0x3d, 0x21, 0x2f, 0xc1, 0x88, 0xd3, - 0x6a, 0x55, 0xcc, 0xf7, 0x27, 0x5b, 0x4a, 0x73, 0x71, 0x31, 0xd6, 0x71, 0xec, 0x9f, 0x2b, 0xc0, - 0xb8, 0xfc, 0x82, 0x6a, 0xfb, 0x4e, 0x48, 0x22, 0xb4, 0x0e, 0xc3, 0x0e, 0x9f, 0x25, 0x22, 0x17, - 0xf9, 0x13, 0xd9, 0x72, 0x51, 0x63, 0x4a, 0x63, 0x46, 0x7a, 0x4e, 0xd6, 0xc6, 0x31, 0x21, 0xd4, - 0x80, 0x29, 0xcf, 0x8f, 0x18, 0x53, 0xa5, 0xe0, 0x9d, 0x54, 0xd5, 0x49, 0xea, 0xa7, 0x04, 0xf5, - 0xa9, 0xb5, 0x24, 0x15, 0x9c, 0x26, 0x8c, 0x96, 0xa4, 0xac, 0xb9, 0x98, 0x2f, 0x24, 0xd4, 0x27, - 0x2e, 0x5b, 0xd4, 0x6c, 0xff, 0x96, 0x05, 0xc3, 0x12, 0xed, 0x28, 0xac, 0x12, 0x56, 0x61, 0x30, - 0x64, 0x93, 0x20, 0x87, 0xc6, 0xee, 0xd4, 0x71, 0x3e, 0x5f, 0x31, 0xaf, 0xc8, 0xff, 0x87, 0x58, - 0xd2, 0x60, 0xaa, 0x46, 0xd5, 0xfd, 0x0f, 0x89, 0xaa, 0x51, 0xf5, 0x27, 0xe7, 0x52, 0xfa, 0x4b, - 0xd6, 0x67, 0x4d, 0x76, 0x4f, 0x9f, 0x34, 0xad, 0x80, 0x6c, 0xb8, 0xf7, 0x92, 0x4f, 0x9a, 0x0a, - 0x2b, 0xc5, 0x02, 0x8a, 0xde, 0x83, 0xd1, 0x9a, 0xd4, 0x31, 0xc5, 0x3b, 0xfc, 0x7c, 0x47, 0x7d, - 0xa7, 0x52, 0x8d, 0x73, 0x19, 0xe9, 0x82, 0x56, 0x1f, 0x1b, 0xd4, 0x4c, 0xfb, 0xb1, 0x62, 0x37, - 0xfb, 0xb1, 0x98, 0x6e, 0xbe, 0x35, 0xd5, 0xbf, 0xb4, 0x60, 0x80, 0xeb, 0x16, 0x7a, 0x53, 0xed, - 0x68, 0x96, 0x02, 0xf1, 0xd8, 0xdd, 0xa2, 0x85, 0x82, 0xb3, 0x41, 0xab, 0x30, 0xcc, 0x7e, 0x30, - 0xdd, 0x48, 0x31, 0xdf, 0xdb, 0x8c, 0xb7, 0xaa, 0x77, 0xf0, 0x96, 0xac, 0x86, 0x63, 0x0a, 0xf6, - 0xf7, 0x8b, 0xf4, 0x74, 0x8b, 0x51, 0x8d, 0x4b, 0xdf, 0x7a, 0x74, 0x97, 0x7e, 0xe1, 0x51, 0x5d, - 0xfa, 0x9b, 0x30, 0x51, 0xd3, 0xec, 0x0a, 0xe2, 0x99, 0xbc, 0xd0, 0x71, 0x91, 0x68, 0x26, 0x08, - 0x5c, 0xfa, 0xba, 0x60, 0x12, 0xc1, 0x49, 0xaa, 0xe8, 0xb3, 0x30, 0xca, 0xe7, 0x59, 0xb4, 0xc2, - 0x4d, 0xf0, 0x9e, 0xca, 0x5f, 0x2f, 0x7a, 0x13, 0x5c, 0x5a, 0xaf, 0x55, 0xc7, 0x06, 0x31, 0x54, - 0x05, 0xd8, 0x70, 0x1b, 0x44, 0x90, 0xee, 0x60, 0x2d, 0xbb, 0xcc, 0xb1, 0x14, 0xe1, 0x71, 0x2e, - 0x87, 0x90, 0x55, 0xb1, 0x46, 0xc6, 0xfe, 0x1b, 0x0b, 0xd0, 0x52, 0x6b, 0x8b, 0x34, 0x49, 0xe0, - 0x34, 0x62, 0x9d, 0xe3, 0xd7, 0x2c, 0x28, 0x91, 0x54, 0xf1, 0x82, 0xdf, 0x6c, 0x0a, 0x09, 0x43, - 0x8e, 0x10, 0x6c, 0x29, 0xa7, 0x4e, 0xfc, 0xca, 0xc8, 0xc3, 0xc0, 0xb9, 0xed, 0xa1, 0x55, 0x98, - 0xe6, 0x57, 0xaf, 0x02, 0x68, 0xa6, 0x7f, 0x8f, 0x09, 0xc2, 0xd3, 0xeb, 0x69, 0x14, 0x9c, 0x55, - 0xcf, 0xfe, 0xad, 0x31, 0xc8, 0xed, 0xc5, 0x47, 0xca, 0xd6, 0x8f, 0x94, 0xad, 0x1f, 0x29, 0x5b, - 0x3f, 0x52, 0xb6, 0x7e, 0xa4, 0x6c, 0xfd, 0x48, 0xd9, 0xfa, 0x21, 0x55, 0xb6, 0xfe, 0x53, 0x0b, - 0x8e, 0xab, 0xeb, 0xcb, 0x90, 0x02, 0x7c, 0x09, 0xa6, 0xf9, 0x76, 0x5b, 0x68, 0x38, 0x6e, 0x73, - 0x9d, 0x34, 0x5b, 0x0d, 0x27, 0x92, 0x26, 0x55, 0x97, 0x32, 0x57, 0x6e, 0xc2, 0x6f, 0xc3, 0xa8, - 0xc8, 0x1d, 0xe0, 0x32, 0x00, 0x38, 0xab, 0x19, 0xfb, 0xd7, 0x87, 0xa0, 0x7f, 0x69, 0x87, 0x78, - 0xd1, 0x11, 0xbc, 0x97, 0x6a, 0x30, 0xee, 0x7a, 0x3b, 0x7e, 0x63, 0x87, 0xd4, 0x39, 0xfc, 0x30, - 0xcf, 0xfa, 0x13, 0x82, 0xf4, 0xf8, 0x8a, 0x41, 0x02, 0x27, 0x48, 0x3e, 0x0a, 0x95, 0xd5, 0x15, - 0x18, 0xe0, 0x97, 0x8f, 0x60, 0xdf, 0x32, 0xcf, 0x6c, 0x36, 0x88, 0xe2, 0x4a, 0x8d, 0xd5, 0x69, - 0xfc, 0x72, 0x13, 0xd5, 0xd1, 0x17, 0x61, 0x7c, 0xc3, 0x0d, 0xc2, 0x68, 0xdd, 0x6d, 0xd2, 0xab, - 0xa1, 0xd9, 0x7a, 0x00, 0x15, 0x95, 0x1a, 0x87, 0x65, 0x83, 0x12, 0x4e, 0x50, 0x46, 0x9b, 0x30, - 0xd6, 0x70, 0xf4, 0xa6, 0x06, 0x0f, 0xdd, 0x94, 0xba, 0x1d, 0xae, 0xeb, 0x84, 0xb0, 0x49, 0x97, - 0x6e, 0xa7, 0x1a, 0xd3, 0xb2, 0x0c, 0x31, 0x19, 0x89, 0xda, 0x4e, 0x5c, 0xbd, 0xc2, 0x61, 0x94, - 0x41, 0x63, 0xde, 0x0f, 0xc3, 0x26, 0x83, 0xa6, 0xf9, 0x38, 0x7c, 0x01, 0x86, 0x09, 0x1d, 0x42, - 0x4a, 0x58, 0x5c, 0x30, 0x17, 0x7b, 0xeb, 0xeb, 0xaa, 0x5b, 0x0b, 0x7c, 0x53, 0x39, 0xb8, 0x24, - 0x29, 0xe1, 0x98, 0x28, 0x5a, 0x80, 0x81, 0x90, 0x04, 0xae, 0x52, 0x40, 0x74, 0x98, 0x46, 0x86, - 0xc6, 0x3d, 0x2c, 0xf9, 0x6f, 0x2c, 0xaa, 0xd2, 0xe5, 0xe5, 0x30, 0xf9, 0x2e, 0xbb, 0x0c, 0xb4, - 0xe5, 0x35, 0xc7, 0x4a, 0xb1, 0x80, 0xa2, 0xb7, 0x61, 0x30, 0x20, 0x0d, 0xa6, 0x7d, 0x1e, 0xeb, - 0x7d, 0x91, 0x73, 0x65, 0x36, 0xaf, 0x87, 0x25, 0x01, 0x74, 0x0d, 0x50, 0x40, 0x28, 0x83, 0xe7, - 0x7a, 0x9b, 0xca, 0x27, 0x40, 0x1c, 0xb4, 0x8a, 0x91, 0xc6, 0x31, 0x86, 0x74, 0xae, 0xc5, 0x19, - 0xd5, 0xd0, 0x15, 0x98, 0x52, 0xa5, 0x2b, 0x5e, 0x18, 0x39, 0xf4, 0x80, 0xe3, 0x3a, 0x00, 0x25, - 0xb4, 0xc1, 0x49, 0x04, 0x9c, 0xae, 0x63, 0xff, 0xa2, 0x05, 0x7c, 0x9c, 0x8f, 0x40, 0x54, 0xf1, - 0xa6, 0x29, 0xaa, 0x38, 0x95, 0x3b, 0x73, 0x39, 0x62, 0x8a, 0x5f, 0xb4, 0x60, 0x44, 0x9b, 0xd9, - 0x78, 0xcd, 0x5a, 0x1d, 0xd6, 0x6c, 0x1b, 0x26, 0xe9, 0x4a, 0xbf, 0x71, 0x27, 0x24, 0xc1, 0x0e, - 0xa9, 0xb3, 0x85, 0x59, 0x78, 0xb0, 0x85, 0xa9, 0xec, 0x8f, 0xaf, 0x27, 0x08, 0xe2, 0x54, 0x13, - 0xf6, 0x17, 0x64, 0x57, 0x95, 0xb9, 0x76, 0x4d, 0xcd, 0x79, 0xc2, 0x5c, 0x5b, 0xcd, 0x2a, 0x8e, - 0x71, 0xe8, 0x56, 0xdb, 0xf2, 0xc3, 0x28, 0x69, 0xae, 0x7d, 0xd5, 0x0f, 0x23, 0xcc, 0x20, 0xf6, - 0x4b, 0x00, 0x4b, 0xf7, 0x48, 0x8d, 0xaf, 0x58, 0xfd, 0xd1, 0x63, 0xe5, 0x3f, 0x7a, 0xec, 0x3f, - 0xb1, 0x60, 0x7c, 0x79, 0xc1, 0xb8, 0xb9, 0x66, 0x01, 0xf8, 0x4b, 0xed, 0xf6, 0xed, 0x35, 0x69, - 0x33, 0xc4, 0xcd, 0x26, 0x54, 0x29, 0xd6, 0x30, 0xd0, 0x29, 0x28, 0x36, 0xda, 0x9e, 0x90, 0xa5, - 0x0e, 0xd2, 0xeb, 0xf1, 0x7a, 0xdb, 0xc3, 0xb4, 0x4c, 0x73, 0xac, 0x2b, 0xf6, 0xec, 0x58, 0xd7, - 0x35, 0xbe, 0x0f, 0x2a, 0x43, 0xff, 0xdd, 0xbb, 0x6e, 0x9d, 0x87, 0x2d, 0x10, 0xf6, 0x4c, 0xb7, - 0x6f, 0xaf, 0x2c, 0x86, 0x98, 0x97, 0xdb, 0xbf, 0x6c, 0xc1, 0x44, 0xe2, 0xdd, 0x4d, 0xdf, 0x6f, - 0x3b, 0x2a, 0x68, 0x4c, 0x32, 0x36, 0x86, 0x16, 0x4e, 0x46, 0xc3, 0xea, 0xc1, 0xa1, 0x54, 0x38, - 0x24, 0x14, 0x7b, 0x70, 0x48, 0xe8, 0x6c, 0x65, 0xfc, 0xf5, 0x22, 0xcc, 0x2c, 0x37, 0xc8, 0xbd, - 0x0f, 0x18, 0x6d, 0xa2, 0x57, 0x4f, 0xc6, 0xc3, 0x09, 0xd2, 0x0e, 0xeb, 0xad, 0xda, 0x7d, 0x0a, - 0x37, 0x60, 0x90, 0x7f, 0xba, 0x8c, 0x3d, 0x91, 0xa9, 0xd6, 0xce, 0x1f, 0x90, 0x59, 0x3e, 0x84, - 0x42, 0xad, 0xad, 0xee, 0x78, 0x51, 0x8a, 0x25, 0xf1, 0x99, 0xd7, 0x60, 0x54, 0xc7, 0x3c, 0x94, - 0xdf, 0xf8, 0x3f, 0x28, 0xc2, 0x24, 0xed, 0xc1, 0x23, 0x9d, 0x88, 0x9b, 0xe9, 0x89, 0x78, 0xd8, - 0xbe, 0xc3, 0xdd, 0x67, 0xe3, 0xbd, 0xe4, 0x6c, 0x5c, 0xca, 0x9b, 0x8d, 0xa3, 0x9e, 0x83, 0x7f, - 0x68, 0xc1, 0xf4, 0x72, 0xc3, 0xaf, 0x6d, 0x27, 0xfc, 0x7b, 0x5f, 0x81, 0x11, 0x7a, 0x83, 0x84, - 0x46, 0xa8, 0x1b, 0x23, 0xf8, 0x91, 0x00, 0x61, 0x1d, 0x4f, 0xab, 0x76, 0xf3, 0xe6, 0xca, 0x62, - 0x56, 0xcc, 0x24, 0x01, 0xc2, 0x3a, 0x9e, 0xfd, 0x87, 0x16, 0x9c, 0xb9, 0xb2, 0xb0, 0x14, 0x2f, - 0xc5, 0x54, 0xd8, 0xa6, 0xf3, 0x30, 0xd0, 0xaa, 0x6b, 0x5d, 0x89, 0xc5, 0xe3, 0x8b, 0xac, 0x17, - 0x02, 0xfa, 0x61, 0x89, 0x90, 0x76, 0x13, 0xe0, 0x0a, 0xae, 0x2c, 0x88, 0xab, 0x42, 0x6a, 0xc3, - 0xac, 0x5c, 0x6d, 0xd8, 0x53, 0x30, 0x48, 0xaf, 0x32, 0xb7, 0x26, 0xfb, 0xcd, 0x0d, 0x57, 0x78, - 0x11, 0x96, 0x30, 0xfb, 0x17, 0x2c, 0x98, 0xbe, 0xe2, 0x46, 0x94, 0xcf, 0x48, 0xc6, 0x25, 0xa2, - 0x8c, 0x46, 0xe8, 0x46, 0x7e, 0xb0, 0x9b, 0x3c, 0x7b, 0xb1, 0x82, 0x60, 0x0d, 0x8b, 0x7f, 0xd0, - 0x8e, 0xcb, 0x3c, 0x86, 0x0a, 0xa6, 0xfe, 0x11, 0x8b, 0x72, 0xac, 0x30, 0xe8, 0x78, 0xd5, 0xdd, - 0x80, 0x9d, 0xf4, 0xf2, 0x34, 0x56, 0xe3, 0xb5, 0x28, 0x01, 0x38, 0xc6, 0xb1, 0xff, 0xca, 0x82, - 0xf2, 0x15, 0xee, 0xf7, 0xbc, 0x11, 0xe6, 0x1c, 0xba, 0x2f, 0xc1, 0x30, 0x91, 0x8a, 0x12, 0xd1, - 0x6b, 0xc5, 0x3b, 0x2b, 0x0d, 0x0a, 0x0f, 0x8f, 0xa4, 0xf0, 0x7a, 0xb8, 0x33, 0x0e, 0xe7, 0x45, - 0xbe, 0x0c, 0x88, 0xe8, 0x6d, 0xe9, 0xf1, 0xa2, 0x58, 0xe0, 0x99, 0xa5, 0x14, 0x14, 0x67, 0xd4, - 0xb0, 0xff, 0x85, 0x05, 0xc7, 0xd5, 0x07, 0x7f, 0xe8, 0x3e, 0xd3, 0xfe, 0x95, 0x02, 0x8c, 0x5d, - 0x5d, 0x5f, 0xaf, 0x5c, 0x21, 0x91, 0xb6, 0x2a, 0x3b, 0x9b, 0x3f, 0x60, 0x4d, 0x8b, 0xdb, 0xe9, - 0x59, 0xdb, 0x8e, 0xdc, 0xc6, 0x2c, 0x8f, 0x82, 0x38, 0xbb, 0xe2, 0x45, 0x37, 0x82, 0x6a, 0x14, - 0xb8, 0xde, 0x66, 0xe6, 0x4a, 0x97, 0x6c, 0x56, 0x31, 0x8f, 0xcd, 0x42, 0x2f, 0xc1, 0x00, 0x0b, - 0xc3, 0x28, 0x27, 0xe1, 0x31, 0xf5, 0x2a, 0x64, 0xa5, 0x07, 0x7b, 0xe5, 0xe1, 0x9b, 0x78, 0x85, - 0xff, 0xc1, 0x02, 0x15, 0xdd, 0x84, 0x91, 0xad, 0x28, 0x6a, 0x5d, 0x25, 0x4e, 0x9d, 0x04, 0xf2, - 0x94, 0x3d, 0x9b, 0x75, 0xca, 0xd2, 0x41, 0xe0, 0x68, 0xf1, 0xc1, 0x14, 0x97, 0x85, 0x58, 0xa7, - 0x63, 0x57, 0x01, 0x62, 0xd8, 0x43, 0x52, 0x60, 0xd9, 0xeb, 0x30, 0x4c, 0x3f, 0x77, 0xae, 0xe1, - 0x3a, 0x9d, 0x4d, 0x04, 0x9e, 0x83, 0x61, 0x69, 0x00, 0x10, 0x8a, 0x20, 0x29, 0xec, 0x46, 0x92, - 0xf6, 0x01, 0x21, 0x8e, 0xe1, 0xf6, 0x93, 0x20, 0x6c, 0xa8, 0x3b, 0x91, 0xb4, 0x37, 0xe0, 0x18, - 0x33, 0x06, 0x77, 0xa2, 0x2d, 0x63, 0x8d, 0x76, 0x5f, 0x0c, 0xcf, 0x8b, 0xa7, 0x68, 0x41, 0xd9, - 0x3d, 0x49, 0x27, 0xfc, 0x51, 0x49, 0x31, 0x7e, 0x96, 0xda, 0xdf, 0xef, 0x83, 0xc7, 0x56, 0xaa, - 0xf9, 0xd1, 0xbd, 0x2e, 0xc3, 0x28, 0xe7, 0x70, 0xe9, 0xd2, 0x70, 0x1a, 0xa2, 0x5d, 0x25, 0xb4, - 0x5d, 0xd7, 0x60, 0xd8, 0xc0, 0xa4, 0x1c, 0xa1, 0xfb, 0xbe, 0x97, 0x74, 0x51, 0x5d, 0x79, 0x67, - 0x0d, 0xd3, 0x72, 0x0a, 0xa6, 0xcc, 0x32, 0x3f, 0xd2, 0x15, 0x58, 0x31, 0xcc, 0x6f, 0xc2, 0xb8, - 0x1b, 0xd6, 0x42, 0x77, 0xc5, 0xa3, 0xfb, 0x54, 0xdb, 0xe9, 0x4a, 0x4c, 0x42, 0x3b, 0xad, 0xa0, - 0x38, 0x81, 0xad, 0xdd, 0x2f, 0xfd, 0x3d, 0x33, 0xdc, 0x5d, 0x63, 0x8b, 0xd0, 0xe3, 0xbf, 0xc5, - 0xbe, 0x2e, 0x64, 0x5a, 0x03, 0x71, 0xfc, 0xf3, 0x0f, 0x0e, 0xb1, 0x84, 0xd1, 0x37, 0x68, 0x6d, - 0xcb, 0x69, 0xcd, 0xb5, 0xa3, 0xad, 0x45, 0x37, 0xac, 0xf9, 0x3b, 0x24, 0xd8, 0x65, 0xe2, 0x83, - 0xa1, 0xf8, 0x0d, 0xaa, 0x00, 0x0b, 0x57, 0xe7, 0x2a, 0x14, 0x13, 0xa7, 0xeb, 0xa0, 0x39, 0x98, - 0x90, 0x85, 0x55, 0x12, 0xb2, 0x2b, 0x60, 0x84, 0x91, 0x51, 0x4e, 0xa3, 0xa2, 0x58, 0x11, 0x49, - 0xe2, 0x9b, 0x0c, 0x2e, 0x3c, 0x0c, 0x06, 0xf7, 0x55, 0x18, 0x73, 0x3d, 0x37, 0x72, 0x9d, 0xc8, - 0xe7, 0x2a, 0x2f, 0x2e, 0x29, 0x60, 0x32, 0xf1, 0x15, 0x1d, 0x80, 0x4d, 0x3c, 0xfb, 0xff, 0xe8, - 0x83, 0x29, 0x36, 0x6d, 0x1f, 0xad, 0xb0, 0x1f, 0xa7, 0x15, 0x76, 0x33, 0xbd, 0xc2, 0x1e, 0x06, - 0xe7, 0xfe, 0xc0, 0xcb, 0xec, 0x2b, 0x16, 0x4c, 0x31, 0xb1, 0xbc, 0xb1, 0xcc, 0x2e, 0xc2, 0x70, - 0x60, 0xf8, 0xf3, 0x0e, 0xeb, 0x7a, 0x38, 0xe9, 0x9a, 0x1b, 0xe3, 0xa0, 0xb7, 0x00, 0x5a, 0xb1, - 0xd8, 0xbf, 0x60, 0x04, 0x61, 0x85, 0x5c, 0x89, 0xbf, 0x56, 0xc7, 0xfe, 0x22, 0x0c, 0x2b, 0x87, - 0x5d, 0xf9, 0x40, 0xb6, 0x72, 0x1e, 0xc8, 0xdd, 0xd9, 0x08, 0x69, 0x23, 0x58, 0xcc, 0xb4, 0x11, - 0xfc, 0x0b, 0x0b, 0x62, 0xa5, 0x0c, 0x7a, 0x07, 0x86, 0x5b, 0x3e, 0x33, 0x29, 0x0f, 0xa4, 0x9f, - 0xc6, 0x93, 0x1d, 0xb5, 0x3a, 0x3c, 0xd2, 0x62, 0xc0, 0xa7, 0xa3, 0x22, 0xab, 0xe2, 0x98, 0x0a, - 0xba, 0x06, 0x83, 0xad, 0x80, 0x54, 0x23, 0x16, 0x06, 0xac, 0x77, 0x82, 0x7c, 0xf9, 0xf2, 0x8a, - 0x58, 0x52, 0x48, 0x58, 0xe8, 0x16, 0x7b, 0xb7, 0xd0, 0xb5, 0xff, 0x5d, 0x01, 0x26, 0x93, 0x8d, - 0xa0, 0x37, 0xa0, 0x8f, 0xdc, 0x23, 0x35, 0xf1, 0xa5, 0x99, 0xdc, 0x44, 0x2c, 0x10, 0xe2, 0x43, - 0x47, 0xff, 0x63, 0x56, 0x0b, 0x5d, 0x85, 0x41, 0xca, 0x4a, 0x5c, 0x51, 0xc1, 0x32, 0x1f, 0xcf, - 0x63, 0x47, 0x14, 0x4f, 0xc6, 0x3f, 0x4b, 0x14, 0x61, 0x59, 0x9d, 0x99, 0xf4, 0xd5, 0x5a, 0x55, - 0xfa, 0x4a, 0x8b, 0x3a, 0x09, 0x13, 0xd6, 0x17, 0x2a, 0x1c, 0x49, 0x50, 0xe3, 0x26, 0x7d, 0xb2, - 0x10, 0xc7, 0x44, 0xd0, 0x5b, 0xd0, 0x1f, 0x36, 0x08, 0x69, 0x09, 0x9b, 0x8d, 0x4c, 0x91, 0x6e, - 0x95, 0x22, 0x08, 0x4a, 0x4c, 0x04, 0xc4, 0x0a, 0x30, 0xaf, 0x68, 0xff, 0xaa, 0x05, 0xc0, 0x6d, - 0x20, 0x1d, 0x6f, 0x93, 0x1c, 0x81, 0x16, 0x64, 0x11, 0xfa, 0xc2, 0x16, 0xa9, 0x75, 0xf2, 0xb4, - 0x88, 0xfb, 0x53, 0x6d, 0x91, 0x5a, 0xbc, 0xda, 0xe9, 0x3f, 0xcc, 0x6a, 0xdb, 0x3f, 0x0d, 0x30, - 0x1e, 0xa3, 0xad, 0x44, 0xa4, 0x89, 0x5e, 0x30, 0x22, 0x0c, 0x9d, 0x4a, 0x44, 0x18, 0x1a, 0x66, - 0xd8, 0x9a, 0xc0, 0xfd, 0x8b, 0x50, 0x6c, 0x3a, 0xf7, 0x84, 0x44, 0xf5, 0xb9, 0xce, 0xdd, 0xa0, - 0xf4, 0x67, 0x57, 0x9d, 0x7b, 0xfc, 0x05, 0xff, 0x9c, 0xdc, 0x9d, 0xab, 0xce, 0xbd, 0xae, 0xde, - 0x00, 0xb4, 0x11, 0xd6, 0x96, 0xeb, 0x09, 0xf3, 0xbe, 0x9e, 0xda, 0x72, 0xbd, 0x64, 0x5b, 0xae, - 0xd7, 0x43, 0x5b, 0xae, 0x87, 0xee, 0xc3, 0xa0, 0xb0, 0xbe, 0x15, 0xa1, 0x0f, 0x2f, 0xf6, 0xd0, - 0x9e, 0x30, 0xde, 0xe5, 0x6d, 0x5e, 0x94, 0x12, 0x0a, 0x51, 0xda, 0xb5, 0x5d, 0xd9, 0x20, 0xfa, - 0x67, 0x16, 0x8c, 0x8b, 0xdf, 0x98, 0xbc, 0xdf, 0x26, 0x61, 0x24, 0x38, 0xf8, 0x4f, 0xf4, 0xde, - 0x07, 0x51, 0x91, 0x77, 0xe5, 0x13, 0xf2, 0xb2, 0x35, 0x81, 0x5d, 0x7b, 0x94, 0xe8, 0x05, 0xfa, - 0x77, 0x16, 0x1c, 0x6b, 0x3a, 0xf7, 0x78, 0x8b, 0xbc, 0x0c, 0x3b, 0x91, 0xeb, 0x0b, 0x83, 0x93, - 0x37, 0x7a, 0x9b, 0xfe, 0x54, 0x75, 0xde, 0x49, 0xa9, 0x5d, 0x3e, 0x96, 0x85, 0xd2, 0xb5, 0xab, - 0x99, 0xfd, 0x9a, 0xd9, 0x80, 0x21, 0xb9, 0xde, 0x1e, 0xa5, 0x6b, 0x01, 0x6b, 0x47, 0xac, 0xb5, - 0x47, 0xda, 0xce, 0x17, 0x61, 0x54, 0x5f, 0x63, 0x8f, 0xb4, 0xad, 0xf7, 0x61, 0x3a, 0x63, 0x2d, - 0x3d, 0xd2, 0x26, 0xef, 0xc2, 0xa9, 0xdc, 0xf5, 0xf1, 0x48, 0x5d, 0x43, 0x7e, 0xc5, 0xd2, 0xcf, - 0xc1, 0x23, 0x50, 0x45, 0x2d, 0x98, 0xaa, 0xa8, 0xb3, 0x9d, 0x77, 0x4e, 0x8e, 0x3e, 0xea, 0x3d, - 0xbd, 0xd3, 0xf4, 0x54, 0x47, 0x6f, 0xc3, 0x40, 0x83, 0x96, 0x48, 0x1b, 0x6e, 0xbb, 0xfb, 0x8e, - 0x8c, 0x39, 0x6a, 0x56, 0x1e, 0x62, 0x41, 0xc1, 0xfe, 0x86, 0x05, 0x19, 0xce, 0x2d, 0x94, 0xc3, - 0x6a, 0xbb, 0x75, 0x36, 0x24, 0xc5, 0x98, 0xc3, 0x52, 0x01, 0x78, 0xce, 0x40, 0x71, 0xd3, 0xad, - 0x0b, 0xaf, 0x6e, 0x05, 0xbe, 0x42, 0xc1, 0x9b, 0x6e, 0x1d, 0x2d, 0x03, 0x0a, 0xdb, 0xad, 0x56, - 0x83, 0xd9, 0x68, 0x39, 0x8d, 0x2b, 0x81, 0xdf, 0x6e, 0x71, 0x83, 0xed, 0x22, 0x17, 0x2f, 0x55, - 0x53, 0x50, 0x9c, 0x51, 0xc3, 0xfe, 0x0d, 0x0b, 0xfa, 0x8e, 0x60, 0x9a, 0xb0, 0x39, 0x4d, 0x2f, - 0xe4, 0x92, 0x16, 0x19, 0x33, 0x66, 0xb1, 0x73, 0x77, 0xe9, 0x5e, 0x44, 0xbc, 0x90, 0x31, 0x1c, - 0x99, 0xb3, 0xb6, 0x67, 0xc1, 0xf4, 0x75, 0xdf, 0xa9, 0xcf, 0x3b, 0x0d, 0xc7, 0xab, 0x91, 0x60, - 0xc5, 0xdb, 0x3c, 0x94, 0x77, 0x44, 0xa1, 0xab, 0x77, 0xc4, 0x65, 0x18, 0x70, 0x5b, 0x5a, 0xc8, - 0xfd, 0x73, 0x74, 0x76, 0x57, 0x2a, 0x22, 0xda, 0x3e, 0x32, 0x1a, 0x67, 0xa5, 0x58, 0xe0, 0xd3, - 0x65, 0xc9, 0x2d, 0x08, 0xfb, 0xf2, 0x97, 0x25, 0x7d, 0x25, 0x25, 0x43, 0xc9, 0x19, 0x06, 0xf4, - 0x5b, 0x60, 0x34, 0x21, 0xdc, 0xc5, 0x30, 0x0c, 0xba, 0xfc, 0x4b, 0xc5, 0xda, 0x7c, 0x3a, 0xfb, - 0xf5, 0x92, 0x1a, 0x18, 0xcd, 0x2f, 0x92, 0x17, 0x60, 0x49, 0xc8, 0xbe, 0x0c, 0x99, 0xa1, 0x7f, - 0xba, 0x4b, 0xa6, 0xec, 0xcf, 0xc0, 0x14, 0xab, 0x79, 0x48, 0xa9, 0x8f, 0x9d, 0x90, 0xa7, 0x67, - 0x44, 0x4f, 0xb6, 0xff, 0x17, 0x0b, 0xd0, 0xaa, 0x5f, 0x77, 0x37, 0x76, 0x05, 0x71, 0xfe, 0xfd, - 0xef, 0x43, 0x99, 0x3f, 0xab, 0x93, 0x11, 0x86, 0x17, 0x1a, 0x4e, 0x18, 0x6a, 0xb2, 0xfc, 0xa7, - 0x45, 0xbb, 0xe5, 0xf5, 0xce, 0xe8, 0xb8, 0x1b, 0x3d, 0xf4, 0x4e, 0x22, 0xe0, 0xe3, 0x27, 0x53, - 0x01, 0x1f, 0x9f, 0xce, 0x34, 0x02, 0x4a, 0xf7, 0x5e, 0x06, 0x82, 0xb4, 0xbf, 0x6a, 0xc1, 0xc4, - 0x5a, 0x22, 0x62, 0xee, 0x79, 0x66, 0x11, 0x91, 0xa1, 0xa3, 0xaa, 0xb2, 0x52, 0x2c, 0xa0, 0x0f, - 0x5d, 0x86, 0xfb, 0x03, 0x0b, 0xe2, 0x50, 0x63, 0x47, 0xc0, 0x72, 0x2f, 0x18, 0x2c, 0x77, 0xe6, - 0xf3, 0x45, 0x75, 0x27, 0x8f, 0xe3, 0x46, 0xd7, 0xd4, 0x9c, 0x74, 0x78, 0xb9, 0xc4, 0x64, 0xf8, - 0x3e, 0x1b, 0x37, 0x27, 0x4e, 0xcd, 0xc6, 0x77, 0x0a, 0x80, 0x14, 0x6e, 0xcf, 0x41, 0x42, 0xd3, - 0x35, 0x1e, 0x4e, 0x90, 0xd0, 0x1d, 0x40, 0xcc, 0xa6, 0x27, 0x70, 0xbc, 0x90, 0x93, 0x75, 0x85, - 0xd4, 0xfa, 0x70, 0x06, 0x43, 0x33, 0xd2, 0x6b, 0xf8, 0x7a, 0x8a, 0x1a, 0xce, 0x68, 0x41, 0xb3, - 0xd5, 0xea, 0xef, 0xd5, 0x56, 0x6b, 0xa0, 0x8b, 0xfb, 0xfb, 0xb7, 0x2c, 0x18, 0x53, 0xc3, 0xf4, - 0x21, 0x71, 0xa2, 0x51, 0xfd, 0xc9, 0xb9, 0x57, 0x2a, 0x5a, 0x97, 0x19, 0x33, 0xf0, 0x13, 0x2c, - 0x8c, 0x81, 0xd3, 0x70, 0xef, 0x13, 0x15, 0xcb, 0xba, 0x2c, 0xc2, 0x12, 0x88, 0xd2, 0x83, 0xbd, - 0xf2, 0x98, 0xfa, 0xc7, 0xed, 0x11, 0xe2, 0x2a, 0xf6, 0xbf, 0xa6, 0x9b, 0xdd, 0x5c, 0x8a, 0xe8, - 0x15, 0xe8, 0x6f, 0x6d, 0x39, 0x21, 0x49, 0x38, 0x1b, 0xf6, 0x57, 0x68, 0xe1, 0xc1, 0x5e, 0x79, - 0x5c, 0x55, 0x60, 0x25, 0x98, 0x63, 0xf7, 0x1e, 0x7a, 0x35, 0xbd, 0x38, 0xbb, 0x86, 0x5e, 0xfd, - 0x1b, 0x0b, 0xfa, 0xd6, 0xe8, 0xed, 0xf5, 0xe8, 0x8f, 0x80, 0x37, 0x8d, 0x23, 0xe0, 0x74, 0x5e, - 0x56, 0xa7, 0xdc, 0xdd, 0xbf, 0x9c, 0xd8, 0xfd, 0x67, 0x73, 0x29, 0x74, 0xde, 0xf8, 0x4d, 0x18, - 0x61, 0xb9, 0xa2, 0x84, 0x63, 0xe5, 0x4b, 0xc6, 0x86, 0x2f, 0x27, 0x36, 0xfc, 0x84, 0x86, 0xaa, - 0xed, 0xf4, 0x67, 0x60, 0x50, 0x78, 0xea, 0x25, 0xa3, 0x41, 0x08, 0x5c, 0x2c, 0xe1, 0xf6, 0xbf, - 0x2c, 0x82, 0x91, 0x9b, 0x0a, 0xfd, 0x96, 0x05, 0xb3, 0x01, 0x37, 0xb6, 0xaf, 0x2f, 0xb6, 0x03, - 0xd7, 0xdb, 0xac, 0xd6, 0xb6, 0x48, 0xbd, 0xdd, 0x70, 0xbd, 0xcd, 0x95, 0x4d, 0xcf, 0x57, 0xc5, - 0x4b, 0xf7, 0x48, 0xad, 0xcd, 0xb4, 0xca, 0x5d, 0x12, 0x61, 0x29, 0x87, 0x95, 0x17, 0xf7, 0xf7, - 0xca, 0xb3, 0xf8, 0x50, 0xb4, 0xf1, 0x21, 0xfb, 0x82, 0xfe, 0xd0, 0x82, 0x8b, 0x3c, 0x47, 0x52, - 0xef, 0xfd, 0xef, 0x20, 0xe1, 0xa8, 0x48, 0x52, 0x31, 0x91, 0x75, 0x12, 0x34, 0xe7, 0x5f, 0x15, - 0x03, 0x7a, 0xb1, 0x72, 0xb8, 0xb6, 0xf0, 0x61, 0x3b, 0x67, 0xff, 0x37, 0x45, 0x18, 0x13, 0x21, - 0x3a, 0xc5, 0x1d, 0xf0, 0x8a, 0xb1, 0x24, 0x1e, 0x4f, 0x2c, 0x89, 0x29, 0x03, 0xf9, 0xe1, 0x1c, - 0xff, 0x21, 0x4c, 0xd1, 0xc3, 0xf9, 0x2a, 0x71, 0x82, 0xe8, 0x0e, 0x71, 0xb8, 0x09, 0x66, 0xf1, - 0xd0, 0xa7, 0xbf, 0x12, 0xac, 0x5f, 0x4f, 0x12, 0xc3, 0x69, 0xfa, 0x3f, 0x4e, 0x77, 0x8e, 0x07, - 0x93, 0xa9, 0x28, 0xab, 0xef, 0xc2, 0xb0, 0x72, 0x33, 0x13, 0x87, 0x4e, 0xe7, 0x60, 0xc5, 0x49, - 0x0a, 0x5c, 0xe8, 0x19, 0xbb, 0x38, 0xc6, 0xe4, 0xec, 0x5f, 0x2e, 0x18, 0x0d, 0xf2, 0x49, 0x5c, - 0x83, 0x21, 0x27, 0x64, 0x01, 0xd4, 0xeb, 0x9d, 0x24, 0xda, 0xa9, 0x66, 0x98, 0x9d, 0xd9, 0x9c, - 0xa8, 0x89, 0x15, 0x0d, 0x74, 0x95, 0x1b, 0xba, 0xee, 0x90, 0x4e, 0xe2, 0xec, 0x14, 0x35, 0x90, - 0xa6, 0xb0, 0x3b, 0x04, 0x8b, 0xfa, 0xe8, 0x73, 0xdc, 0x12, 0xf9, 0x9a, 0xe7, 0xdf, 0xf5, 0xae, - 0xf8, 0xbe, 0x0c, 0xc7, 0xd4, 0x1b, 0xc1, 0x29, 0x69, 0x7f, 0xac, 0xaa, 0x63, 0x93, 0x5a, 0x6f, - 0x61, 0xcb, 0xbf, 0x04, 0x2c, 0x27, 0x8c, 0x19, 0xd5, 0x21, 0x44, 0x04, 0x26, 0x44, 0xfc, 0x57, - 0x59, 0x26, 0xc6, 0x2e, 0xf3, 0xf9, 0x6d, 0xd6, 0x8e, 0x35, 0x40, 0xd7, 0x4c, 0x12, 0x38, 0x49, - 0xd3, 0xde, 0xe2, 0x87, 0xf0, 0x32, 0x71, 0xa2, 0x76, 0x40, 0x42, 0xf4, 0x69, 0x28, 0xa5, 0x5f, - 0xc6, 0x42, 0x91, 0x62, 0x31, 0xee, 0xf9, 0xf4, 0xfe, 0x5e, 0xb9, 0x54, 0xcd, 0xc1, 0xc1, 0xb9, - 0xb5, 0xed, 0x9f, 0xb7, 0x80, 0xf9, 0xd2, 0x1f, 0x01, 0xe7, 0xf3, 0x29, 0x93, 0xf3, 0x29, 0xe5, - 0x4d, 0x67, 0x0e, 0xd3, 0xf3, 0x32, 0x5f, 0xc3, 0x95, 0xc0, 0xbf, 0xb7, 0x2b, 0xac, 0xbe, 0xba, - 0x3f, 0xe3, 0xec, 0xaf, 0x5b, 0xc0, 0x12, 0x28, 0x61, 0xfe, 0x6a, 0x97, 0x0a, 0x8e, 0xee, 0x06, - 0x0d, 0x9f, 0x86, 0xa1, 0x0d, 0x31, 0xfc, 0x19, 0x42, 0x27, 0xa3, 0xc3, 0x26, 0x6d, 0x39, 0x69, - 0xc2, 0x27, 0x56, 0xfc, 0xc3, 0x8a, 0x9a, 0xfd, 0x5f, 0x58, 0x30, 0x93, 0x5f, 0x0d, 0xdd, 0x84, - 0x93, 0x01, 0xa9, 0xb5, 0x83, 0x90, 0x6e, 0x09, 0xf1, 0x00, 0x12, 0x1e, 0x60, 0x7c, 0xaa, 0x1f, - 0xdb, 0xdf, 0x2b, 0x9f, 0xc4, 0xd9, 0x28, 0x38, 0xaf, 0x2e, 0x7a, 0x0d, 0xc6, 0xdb, 0x21, 0xe7, - 0xfc, 0x18, 0xd3, 0x15, 0x8a, 0x28, 0xdd, 0xcc, 0x49, 0xea, 0xa6, 0x01, 0xc1, 0x09, 0x4c, 0xfb, - 0xef, 0xf3, 0xe5, 0xa8, 0x2c, 0x5e, 0x9b, 0x30, 0xe5, 0x69, 0xff, 0xe9, 0x0d, 0x28, 0x9f, 0xfa, - 0x4f, 0x76, 0xbb, 0xf5, 0xd9, 0x75, 0xa9, 0x79, 0xfb, 0x27, 0xc8, 0xe0, 0x34, 0x65, 0xfb, 0x5f, - 0x59, 0x70, 0x52, 0x47, 0xd4, 0x7c, 0xff, 0xba, 0x69, 0x01, 0x17, 0x61, 0xc8, 0x6f, 0x91, 0xc0, - 0x89, 0xfc, 0x40, 0x5c, 0x73, 0x17, 0xe4, 0x0a, 0xbd, 0x21, 0xca, 0x0f, 0x44, 0xe2, 0x20, 0x49, - 0x5d, 0x96, 0x63, 0x55, 0x13, 0xd9, 0x30, 0xc0, 0x04, 0x88, 0xa1, 0xf0, 0xf2, 0x64, 0x87, 0x16, - 0xb3, 0x6c, 0x09, 0xb1, 0x80, 0xd8, 0xdf, 0xb7, 0xf8, 0xfa, 0xd4, 0xbb, 0x8e, 0xde, 0x87, 0xc9, - 0xa6, 0x13, 0xd5, 0xb6, 0x96, 0xee, 0xb5, 0x02, 0xae, 0xdc, 0x95, 0xe3, 0xf4, 0x5c, 0xb7, 0x71, - 0xd2, 0x3e, 0x32, 0xb6, 0x06, 0x5f, 0x4d, 0x10, 0xc3, 0x29, 0xf2, 0xe8, 0x0e, 0x8c, 0xb0, 0x32, - 0xe6, 0x15, 0x1d, 0x76, 0xe2, 0x65, 0xf2, 0x5a, 0x53, 0xc6, 0x41, 0xab, 0x31, 0x1d, 0xac, 0x13, - 0xb5, 0xbf, 0x59, 0xe4, 0x87, 0x06, 0x7b, 0x7b, 0x3c, 0x03, 0x83, 0x2d, 0xbf, 0xbe, 0xb0, 0xb2, - 0x88, 0xc5, 0x2c, 0xa8, 0x7b, 0xaf, 0xc2, 0x8b, 0xb1, 0x84, 0xa3, 0x0b, 0x30, 0x24, 0x7e, 0x4a, - 0x65, 0x3c, 0xdb, 0x23, 0x02, 0x2f, 0xc4, 0x0a, 0x8a, 0x5e, 0x04, 0x68, 0x05, 0xfe, 0x8e, 0x5b, - 0x67, 0x51, 0xb0, 0x8a, 0xa6, 0x5d, 0x5f, 0x45, 0x41, 0xb0, 0x86, 0x85, 0x5e, 0x87, 0xb1, 0xb6, - 0x17, 0x72, 0xfe, 0x49, 0xcb, 0x35, 0xa0, 0x2c, 0xce, 0x6e, 0xea, 0x40, 0x6c, 0xe2, 0xa2, 0x39, - 0x18, 0x88, 0x1c, 0x66, 0xa7, 0xd6, 0x9f, 0xef, 0x31, 0xb0, 0x4e, 0x31, 0xf4, 0xac, 0x7e, 0xb4, - 0x02, 0x16, 0x15, 0xd1, 0xbb, 0x32, 0x40, 0x01, 0xbf, 0x89, 0x84, 0xab, 0x4e, 0x6f, 0xb7, 0x96, - 0x16, 0x9e, 0x40, 0xb8, 0x00, 0x19, 0xb4, 0xd0, 0x6b, 0x00, 0xe4, 0x5e, 0x44, 0x02, 0xcf, 0x69, - 0x28, 0xeb, 0x52, 0xc5, 0xc8, 0x2c, 0xfa, 0x6b, 0x7e, 0x74, 0x33, 0x24, 0x4b, 0x0a, 0x03, 0x6b, - 0xd8, 0xf6, 0x4f, 0x8f, 0x00, 0xc4, 0x0f, 0x0d, 0x74, 0x1f, 0x86, 0x6a, 0x4e, 0xcb, 0xa9, 0xf1, - 0x94, 0xb5, 0xc5, 0x3c, 0x17, 0xef, 0xb8, 0xc6, 0xec, 0x82, 0x40, 0xe7, 0xca, 0x1b, 0x19, 0xae, - 0x7d, 0x48, 0x16, 0x77, 0x55, 0xd8, 0xa8, 0xf6, 0xd0, 0x57, 0x2c, 0x18, 0x11, 0x51, 0xa6, 0xd8, - 0x0c, 0x15, 0xf2, 0xf5, 0x6d, 0x5a, 0xfb, 0x73, 0x71, 0x0d, 0xde, 0x85, 0x97, 0xe4, 0x0a, 0xd5, - 0x20, 0x5d, 0x7b, 0xa1, 0x37, 0x8c, 0x3e, 0x2e, 0xdf, 0xb6, 0x45, 0x63, 0x28, 0xd5, 0xdb, 0x76, - 0x98, 0x5d, 0x35, 0xfa, 0xb3, 0xf6, 0xa6, 0xf1, 0xac, 0xed, 0xcb, 0x77, 0x96, 0x36, 0xf8, 0xed, - 0x6e, 0x2f, 0x5a, 0x54, 0xd1, 0xa3, 0xb1, 0xf4, 0xe7, 0x7b, 0xf8, 0x6a, 0x0f, 0xbb, 0x2e, 0x91, - 0x58, 0xbe, 0x08, 0x13, 0x75, 0x93, 0x6b, 0x11, 0x2b, 0xf1, 0xe9, 0x3c, 0xba, 0x09, 0x26, 0x27, - 0xe6, 0x53, 0x12, 0x00, 0x9c, 0x24, 0x8c, 0x2a, 0x3c, 0x38, 0xcf, 0x8a, 0xb7, 0xe1, 0x0b, 0x77, - 0x31, 0x3b, 0x77, 0x2e, 0x77, 0xc3, 0x88, 0x34, 0x29, 0x66, 0xcc, 0x24, 0xac, 0x89, 0xba, 0x58, - 0x51, 0x41, 0x6f, 0xc3, 0x00, 0x73, 0xf1, 0x0c, 0x4b, 0x43, 0xf9, 0x6a, 0x0d, 0x33, 0x0a, 0x6d, - 0xbc, 0x21, 0xd9, 0xdf, 0x10, 0x0b, 0x0a, 0xe8, 0xaa, 0x74, 0xa0, 0x0e, 0x57, 0xbc, 0x9b, 0x21, - 0x61, 0x0e, 0xd4, 0xc3, 0xf3, 0x4f, 0xc6, 0xbe, 0xd1, 0xbc, 0x3c, 0x33, 0xf7, 0xaf, 0x51, 0x93, - 0xb2, 0x7d, 0xe2, 0xbf, 0x4c, 0x29, 0x2c, 0x62, 0xe6, 0x65, 0x76, 0xcf, 0x4c, 0x3b, 0x1c, 0x0f, - 0xe7, 0x2d, 0x93, 0x04, 0x4e, 0xd2, 0xa4, 0x2c, 0x34, 0xdf, 0xf5, 0xc2, 0xe1, 0xac, 0xdb, 0xd9, - 0xc1, 0x25, 0x07, 0xec, 0x36, 0xe2, 0x25, 0x58, 0xd4, 0x47, 0x2e, 0x4c, 0x04, 0x06, 0x7b, 0x21, - 0x43, 0xdd, 0x9d, 0xef, 0x8d, 0x89, 0xd1, 0x92, 0x28, 0x98, 0x64, 0x70, 0x92, 0x2e, 0x7a, 0x5b, - 0x63, 0x94, 0xc6, 0x3a, 0xbf, 0xfc, 0xbb, 0xb1, 0x46, 0x33, 0xdb, 0x30, 0x66, 0x1c, 0x36, 0x8f, - 0x54, 0x05, 0xe9, 0xc1, 0x64, 0xf2, 0x64, 0x79, 0xa4, 0x9a, 0xc7, 0xd7, 0x60, 0x9c, 0x6d, 0x84, - 0xbb, 0x4e, 0x4b, 0x1c, 0xc5, 0x17, 0x8c, 0xa3, 0xd8, 0xba, 0x50, 0xe4, 0x03, 0x23, 0x87, 0x20, - 0x3e, 0x38, 0xed, 0x7f, 0xd3, 0x2f, 0x2a, 0xab, 0x5d, 0x84, 0x2e, 0xc2, 0xb0, 0xe8, 0x80, 0xca, - 0x44, 0xa6, 0x0e, 0x86, 0x55, 0x09, 0xc0, 0x31, 0x0e, 0x4b, 0x40, 0xc7, 0xaa, 0x6b, 0x1e, 0x0a, - 0x71, 0x02, 0x3a, 0x05, 0xc1, 0x1a, 0x16, 0x7d, 0xfc, 0xde, 0xf1, 0xfd, 0x48, 0xdd, 0xc1, 0x6a, - 0xab, 0xcd, 0xb3, 0x52, 0x2c, 0xa0, 0xf4, 0xee, 0xdd, 0x26, 0x81, 0x47, 0x1a, 0x66, 0x2a, 0x0e, - 0x75, 0xf7, 0x5e, 0xd3, 0x81, 0xd8, 0xc4, 0xa5, 0x1c, 0x84, 0x1f, 0xb2, 0xbd, 0x2b, 0x9e, 0xd8, - 0xb1, 0xc7, 0x47, 0x95, 0x87, 0xdb, 0x90, 0x70, 0xf4, 0x19, 0x38, 0xa9, 0xc2, 0x5e, 0x8a, 0x95, - 0x29, 0x5b, 0x1c, 0x30, 0x24, 0x62, 0x27, 0x17, 0xb2, 0xd1, 0x70, 0x5e, 0x7d, 0xf4, 0x26, 0x8c, - 0x8b, 0x67, 0x98, 0xa4, 0x38, 0x68, 0x9a, 0x2f, 0x5e, 0x33, 0xa0, 0x38, 0x81, 0x2d, 0x93, 0x89, - 0xb0, 0xf7, 0x89, 0xa4, 0x30, 0x94, 0x4e, 0x26, 0xa2, 0xc3, 0x71, 0xaa, 0x06, 0x9a, 0x83, 0x09, - 0xce, 0x76, 0xba, 0xde, 0x26, 0x9f, 0x13, 0xe1, 0x02, 0xab, 0x36, 0xe4, 0x0d, 0x13, 0x8c, 0x93, - 0xf8, 0xe8, 0x32, 0x8c, 0x3a, 0x41, 0x6d, 0xcb, 0x8d, 0x48, 0x8d, 0xee, 0x2a, 0x66, 0x41, 0xa8, - 0xd9, 0x7f, 0xce, 0x69, 0x30, 0x6c, 0x60, 0xa2, 0xb7, 0xa0, 0x2f, 0xbc, 0xeb, 0xb4, 0xc4, 0xe9, - 0x93, 0x7f, 0x94, 0xab, 0x15, 0xcc, 0x4d, 0xbf, 0xe8, 0x7f, 0xcc, 0x6a, 0xda, 0xf7, 0x61, 0x3a, - 0x23, 0x3c, 0x10, 0x5d, 0x7a, 0x4e, 0xcb, 0x95, 0xa3, 0x92, 0x70, 0xd3, 0x98, 0xab, 0xac, 0xc8, - 0xf1, 0xd0, 0xb0, 0xe8, 0xfa, 0x66, 0x61, 0x84, 0xb4, 0xb4, 0xeb, 0x6a, 0x7d, 0x2f, 0x4b, 0x00, - 0x8e, 0x71, 0xec, 0xbf, 0x2d, 0xc0, 0x44, 0x86, 0x7a, 0x90, 0xa5, 0xfe, 0x4e, 0xbc, 0xf3, 0xe2, - 0x4c, 0xdf, 0x66, 0x76, 0x9b, 0xc2, 0x21, 0xb2, 0xdb, 0x14, 0xbb, 0x65, 0xb7, 0xe9, 0xfb, 0x20, - 0xd9, 0x6d, 0xcc, 0x11, 0xeb, 0xef, 0x69, 0xc4, 0x32, 0x32, 0xe2, 0x0c, 0x1c, 0x32, 0x23, 0x8e, - 0x31, 0xe8, 0x83, 0x3d, 0x0c, 0xfa, 0x7f, 0x5c, 0x80, 0xc9, 0xa4, 0x66, 0xf1, 0x08, 0xa4, 0xf3, - 0x6f, 0x1b, 0xd2, 0xf9, 0x0b, 0xbd, 0x04, 0x3d, 0xc8, 0x95, 0xd4, 0xe3, 0x84, 0xa4, 0xfe, 0xd9, - 0x9e, 0xa8, 0x75, 0x96, 0xda, 0xff, 0xa7, 0x05, 0x38, 0x9e, 0xa9, 0x70, 0x3d, 0x82, 0xb1, 0xb9, - 0x61, 0x8c, 0xcd, 0x0b, 0x3d, 0x07, 0x84, 0xc8, 0x1d, 0xa0, 0xdb, 0x89, 0x01, 0xba, 0xd8, 0x3b, - 0xc9, 0xce, 0xa3, 0xf4, 0xdd, 0x22, 0x9c, 0xcd, 0xac, 0x17, 0x0b, 0xb7, 0x97, 0x0d, 0xe1, 0xf6, - 0x8b, 0x09, 0xe1, 0xb6, 0xdd, 0xb9, 0xf6, 0xc3, 0x91, 0x76, 0x8b, 0xc0, 0x08, 0x2c, 0xbc, 0xcb, - 0x03, 0x4a, 0xba, 0x8d, 0xc0, 0x08, 0x8a, 0x10, 0x36, 0xe9, 0xfe, 0x38, 0x49, 0xb8, 0xff, 0x07, - 0x0b, 0x4e, 0x65, 0xce, 0xcd, 0x11, 0xc8, 0x19, 0xd7, 0x4c, 0x39, 0xe3, 0x33, 0x3d, 0xaf, 0xd6, - 0x1c, 0xc1, 0xe3, 0x57, 0x07, 0x72, 0xbe, 0x85, 0x89, 0x3f, 0x6e, 0xc0, 0x88, 0x53, 0xab, 0x91, - 0x30, 0x5c, 0xf5, 0xeb, 0x2a, 0x11, 0xc6, 0x0b, 0xec, 0x71, 0x1a, 0x17, 0x1f, 0xec, 0x95, 0x67, - 0x92, 0x24, 0x62, 0x30, 0xd6, 0x29, 0xa0, 0xcf, 0xc1, 0x50, 0x28, 0x73, 0x98, 0xf6, 0x3d, 0x78, - 0x0e, 0x53, 0xc6, 0x49, 0x2a, 0xf1, 0x8e, 0x22, 0x89, 0xfe, 0x9e, 0x1e, 0x68, 0xab, 0x83, 0x60, - 0x93, 0x77, 0xf2, 0x01, 0xc2, 0x6d, 0x99, 0xee, 0xf0, 0xc5, 0x9e, 0xdc, 0xe1, 0xdf, 0x82, 0xc9, - 0x90, 0x07, 0xae, 0x8d, 0x4d, 0x64, 0xf8, 0x5a, 0x64, 0xb1, 0xff, 0xaa, 0x09, 0x18, 0x4e, 0x61, - 0xa3, 0x65, 0xd9, 0x2a, 0x33, 0x86, 0xe2, 0xcb, 0xf3, 0x7c, 0xdc, 0xa2, 0x30, 0x88, 0x3a, 0x96, - 0x9c, 0x04, 0x36, 0xfc, 0x5a, 0x4d, 0xf4, 0x39, 0x00, 0xba, 0x88, 0x84, 0x08, 0x67, 0x30, 0xff, - 0x08, 0xa5, 0x67, 0x4b, 0x3d, 0xd3, 0x03, 0x83, 0x45, 0x34, 0x58, 0x54, 0x44, 0xb0, 0x46, 0x10, - 0x39, 0x30, 0x16, 0xff, 0x8b, 0xb3, 0xf3, 0x5f, 0xc8, 0x6d, 0x21, 0x49, 0x9c, 0xa9, 0x37, 0x16, - 0x75, 0x12, 0xd8, 0xa4, 0x88, 0x3e, 0x0b, 0xa7, 0x76, 0x72, 0xed, 0x8e, 0x38, 0x2f, 0xc9, 0xd2, - 0xed, 0xe7, 0x5b, 0x1b, 0xe5, 0xd7, 0xb7, 0xff, 0x47, 0x80, 0xc7, 0x3a, 0x9c, 0xf4, 0x68, 0xce, - 0xb4, 0x19, 0x78, 0x2e, 0x29, 0x57, 0x99, 0xc9, 0xac, 0x6c, 0x08, 0x5a, 0x12, 0x1b, 0xaa, 0xf0, - 0x81, 0x37, 0xd4, 0xcf, 0x58, 0xda, 0x33, 0x8b, 0x5b, 0x94, 0x7f, 0xea, 0x90, 0x37, 0xd8, 0x43, - 0x14, 0x81, 0x6d, 0x64, 0xc8, 0x91, 0x5e, 0xec, 0xb9, 0x3b, 0xbd, 0x0b, 0x96, 0x7e, 0x25, 0x3b, - 0xd4, 0x3f, 0x17, 0x31, 0x5d, 0x39, 0xec, 0xf7, 0x1f, 0x55, 0xd8, 0xff, 0xef, 0x58, 0x70, 0x2a, - 0x55, 0xcc, 0xfb, 0x40, 0x42, 0x11, 0x58, 0x70, 0xed, 0x03, 0x77, 0x5e, 0x12, 0xe4, 0xdf, 0x70, - 0x55, 0x7c, 0xc3, 0xa9, 0x5c, 0xbc, 0x64, 0xd7, 0xbf, 0xf6, 0xe7, 0xe5, 0x69, 0xd6, 0x80, 0x89, - 0x88, 0xf3, 0xbb, 0x8e, 0x5a, 0x70, 0xae, 0xd6, 0x0e, 0x82, 0x78, 0xb1, 0x66, 0x6c, 0x4e, 0xfe, - 0x5a, 0x7c, 0x72, 0x7f, 0xaf, 0x7c, 0x6e, 0xa1, 0x0b, 0x2e, 0xee, 0x4a, 0x0d, 0x79, 0x80, 0x9a, - 0x29, 0xeb, 0x3e, 0x76, 0x00, 0xe4, 0x48, 0x81, 0xd2, 0xb6, 0x80, 0xdc, 0x4e, 0x37, 0xc3, 0x46, - 0x30, 0x83, 0xf2, 0xd1, 0xca, 0x6e, 0x7e, 0x38, 0x79, 0x05, 0x66, 0xae, 0xc3, 0xd9, 0xce, 0x8b, - 0xe9, 0x50, 0x21, 0x28, 0xfe, 0xc4, 0x82, 0x33, 0x1d, 0x43, 0xb3, 0xfd, 0x08, 0x3e, 0x16, 0xec, - 0x2f, 0x5b, 0xf0, 0x78, 0x66, 0x8d, 0xa4, 0xf3, 0x60, 0x8d, 0x16, 0x6a, 0xc6, 0xb0, 0x71, 0x90, - 0x22, 0x09, 0xc0, 0x31, 0x8e, 0x61, 0x2f, 0x5a, 0xe8, 0x6a, 0x2f, 0xfa, 0xbb, 0x16, 0xa4, 0xae, - 0xfa, 0x23, 0xe0, 0x3c, 0x57, 0x4c, 0xce, 0xf3, 0xc9, 0x5e, 0x46, 0x33, 0x87, 0xe9, 0xfc, 0xeb, - 0x09, 0x38, 0x91, 0xe3, 0x41, 0xbe, 0x03, 0x53, 0x9b, 0x35, 0x62, 0x86, 0x0c, 0xe9, 0x14, 0xfd, - 0xaf, 0x63, 0x7c, 0x91, 0xf9, 0xe3, 0xfb, 0x7b, 0xe5, 0xa9, 0x14, 0x0a, 0x4e, 0x37, 0x81, 0xbe, - 0x6c, 0xc1, 0x31, 0xe7, 0x6e, 0xb8, 0x44, 0x5f, 0x10, 0x6e, 0x6d, 0xbe, 0xe1, 0xd7, 0xb6, 0x29, - 0x63, 0x26, 0xb7, 0xd5, 0xcb, 0x99, 0xa2, 0xf0, 0xdb, 0xd5, 0x14, 0xbe, 0xd1, 0x7c, 0x69, 0x7f, - 0xaf, 0x7c, 0x2c, 0x0b, 0x0b, 0x67, 0xb6, 0x85, 0xb0, 0xc8, 0xf5, 0xe6, 0x44, 0x5b, 0x9d, 0x82, - 0xda, 0x64, 0xb9, 0xfa, 0x73, 0x96, 0x58, 0x42, 0xb0, 0xa2, 0x83, 0xbe, 0x00, 0xc3, 0x9b, 0x32, - 0x7e, 0x45, 0x06, 0xcb, 0x1d, 0x0f, 0x64, 0xe7, 0xa8, 0x1e, 0xdc, 0x00, 0x47, 0x21, 0xe1, 0x98, - 0x28, 0x7a, 0x13, 0x8a, 0xde, 0x46, 0xd8, 0x29, 0x98, 0x73, 0xc2, 0xd2, 0x9a, 0x47, 0xbb, 0x5a, - 0x5b, 0xae, 0x62, 0x5a, 0x11, 0x5d, 0x85, 0x62, 0x70, 0xa7, 0x2e, 0xf4, 0x38, 0x99, 0x9b, 0x14, - 0xcf, 0x2f, 0xe6, 0xf4, 0x8a, 0x51, 0xc2, 0xf3, 0x8b, 0x98, 0x92, 0x40, 0x15, 0xe8, 0x67, 0x6e, - 0xd7, 0x82, 0xb5, 0xcd, 0x7c, 0xca, 0x77, 0x08, 0x5f, 0xc0, 0xfd, 0x21, 0x19, 0x02, 0xe6, 0x84, - 0xd0, 0x3a, 0x0c, 0xd4, 0x5c, 0xaf, 0x4e, 0x02, 0xc1, 0xcb, 0x7e, 0x3c, 0x53, 0x63, 0xc3, 0x30, - 0x72, 0x68, 0x72, 0x05, 0x06, 0xc3, 0xc0, 0x82, 0x16, 0xa3, 0x4a, 0x5a, 0x5b, 0x1b, 0xf2, 0xc6, - 0xca, 0xa6, 0x4a, 0x5a, 0x5b, 0xcb, 0xd5, 0x8e, 0x54, 0x19, 0x06, 0x16, 0xb4, 0xd0, 0x6b, 0x50, - 0xd8, 0xa8, 0x09, 0x97, 0xea, 0x4c, 0xf1, 0xa6, 0x19, 0xb0, 0x6c, 0x7e, 0x60, 0x7f, 0xaf, 0x5c, - 0x58, 0x5e, 0xc0, 0x85, 0x8d, 0x1a, 0x5a, 0x83, 0xc1, 0x0d, 0x1e, 0x2f, 0x48, 0xc8, 0x47, 0x9f, - 0xce, 0x0e, 0x65, 0x94, 0x0a, 0x29, 0xc4, 0x7d, 0x5b, 0x05, 0x00, 0x4b, 0x22, 0x2c, 0xf5, 0x98, - 0x8a, 0x7b, 0x24, 0x22, 0xc5, 0xce, 0x1e, 0x2e, 0x56, 0x95, 0x08, 0xf9, 0xad, 0xa8, 0x60, 0x8d, - 0x22, 0x5d, 0xd5, 0xce, 0xfd, 0x76, 0xc0, 0x72, 0x93, 0x08, 0xc5, 0x4c, 0xe6, 0xaa, 0x9e, 0x93, - 0x48, 0x9d, 0x56, 0xb5, 0x42, 0xc2, 0x31, 0x51, 0xb4, 0x0d, 0x63, 0x3b, 0x61, 0x6b, 0x8b, 0xc8, - 0x2d, 0xcd, 0x22, 0x0c, 0xe6, 0x70, 0xb3, 0xb7, 0x04, 0xa2, 0x1b, 0x44, 0x6d, 0xa7, 0x91, 0x3a, - 0x85, 0xd8, 0xb3, 0xe6, 0x96, 0x4e, 0x0c, 0x9b, 0xb4, 0xe9, 0xf0, 0xbf, 0xdf, 0xf6, 0xef, 0xec, - 0x46, 0x44, 0x04, 0x78, 0xcd, 0x1c, 0xfe, 0x77, 0x38, 0x4a, 0x7a, 0xf8, 0x05, 0x00, 0x4b, 0x22, - 0xe8, 0x96, 0x18, 0x1e, 0x76, 0x7a, 0x4e, 0xe6, 0x87, 0xa4, 0x9f, 0x93, 0x48, 0x39, 0x83, 0xc2, - 0x4e, 0xcb, 0x98, 0x14, 0x3b, 0x25, 0x5b, 0x5b, 0x7e, 0xe4, 0x7b, 0x89, 0x13, 0x7a, 0x2a, 0xff, - 0x94, 0xac, 0x64, 0xe0, 0xa7, 0x4f, 0xc9, 0x2c, 0x2c, 0x9c, 0xd9, 0x16, 0xaa, 0xc3, 0x78, 0xcb, - 0x0f, 0xa2, 0xbb, 0x7e, 0x20, 0xd7, 0x17, 0xea, 0x20, 0x28, 0x35, 0x30, 0x45, 0x8b, 0xcc, 0x2c, - 0xc8, 0x84, 0xe0, 0x04, 0x4d, 0xf4, 0x69, 0x18, 0x0c, 0x6b, 0x4e, 0x83, 0xac, 0xdc, 0x28, 0x4d, - 0xe7, 0x5f, 0x3f, 0x55, 0x8e, 0x92, 0xb3, 0xba, 0x78, 0xb8, 0x27, 0x8e, 0x82, 0x25, 0x39, 0xb4, - 0x0c, 0xfd, 0x2c, 0xa5, 0x37, 0x8b, 0x46, 0x9c, 0x13, 0x59, 0x3f, 0xe5, 0xd4, 0xc3, 0xcf, 0x26, - 0x56, 0x8c, 0x79, 0x75, 0xba, 0x07, 0x84, 0xa4, 0xc0, 0x0f, 0x4b, 0xc7, 0xf3, 0xf7, 0x80, 0x10, - 0x30, 0xdc, 0xa8, 0x76, 0xda, 0x03, 0x0a, 0x09, 0xc7, 0x44, 0xe9, 0xc9, 0x4c, 0x4f, 0xd3, 0x13, - 0x1d, 0x0c, 0x36, 0x73, 0xcf, 0x52, 0x76, 0x32, 0xd3, 0x93, 0x94, 0x92, 0xb0, 0x7f, 0x7b, 0x28, - 0xcd, 0xb3, 0x30, 0x09, 0xd3, 0x7f, 0x68, 0xa5, 0x2c, 0x36, 0x3e, 0xd1, 0xab, 0xc0, 0xfb, 0x21, - 0x3e, 0x5c, 0xbf, 0x6c, 0xc1, 0x89, 0x56, 0xe6, 0x87, 0x08, 0x06, 0xa0, 0x37, 0xb9, 0x39, 0xff, - 0x74, 0x15, 0xb9, 0x3a, 0x1b, 0x8e, 0x73, 0x5a, 0x4a, 0x0a, 0x07, 0x8a, 0x1f, 0x58, 0x38, 0xb0, - 0x0a, 0x43, 0x35, 0xfe, 0x92, 0x93, 0x69, 0x1c, 0x7a, 0x8a, 0xbb, 0xca, 0xf5, 0xb4, 0xa2, 0x22, - 0x56, 0x24, 0xd0, 0xcf, 0x5a, 0x70, 0x26, 0xd9, 0x75, 0x4c, 0x18, 0x58, 0x98, 0x6b, 0x72, 0xb1, - 0xd6, 0xb2, 0xf8, 0xfe, 0x14, 0xff, 0x6f, 0x20, 0x1f, 0x74, 0x43, 0xc0, 0x9d, 0x1b, 0x43, 0x8b, - 0x19, 0x72, 0xb5, 0x01, 0x53, 0x27, 0xd9, 0x83, 0x6c, 0xed, 0x65, 0x18, 0x6d, 0xfa, 0x6d, 0x2f, - 0x12, 0x56, 0x97, 0xc2, 0x74, 0x8b, 0x99, 0x2c, 0xad, 0x6a, 0xe5, 0xd8, 0xc0, 0x4a, 0x48, 0xe4, - 0x86, 0x1e, 0x58, 0x22, 0xf7, 0x1e, 0x8c, 0x7a, 0x9a, 0x43, 0x42, 0xa7, 0x17, 0xac, 0x90, 0x2e, - 0x6a, 0xd8, 0xbc, 0x97, 0x7a, 0x09, 0x36, 0xa8, 0x75, 0x96, 0x96, 0xc1, 0x07, 0x93, 0x96, 0x1d, - 0xe9, 0x93, 0xd8, 0xfe, 0xa5, 0x42, 0xc6, 0x8b, 0x81, 0x4b, 0xe5, 0xde, 0x30, 0xa5, 0x72, 0xe7, - 0x93, 0x52, 0xb9, 0x94, 0xaa, 0xca, 0x10, 0xc8, 0xf5, 0x9e, 0x4b, 0xb4, 0xe7, 0x58, 0xda, 0xff, - 0xc0, 0x82, 0x93, 0x4c, 0xf7, 0x41, 0x1b, 0xf8, 0xc0, 0xfa, 0x0e, 0x66, 0x10, 0x7b, 0x3d, 0x9b, - 0x1c, 0xce, 0x6b, 0xc7, 0x6e, 0xc0, 0xb9, 0x6e, 0xf7, 0x2e, 0xb3, 0x2f, 0xae, 0x2b, 0xf3, 0x8a, - 0xd8, 0xbe, 0xb8, 0xbe, 0xb2, 0x88, 0x19, 0xa4, 0xd7, 0xb0, 0x8b, 0xf6, 0xff, 0x69, 0x41, 0xb1, - 0xe2, 0xd7, 0x8f, 0xe0, 0x45, 0xff, 0x29, 0xe3, 0x45, 0xff, 0x58, 0xf6, 0x8d, 0x5f, 0xcf, 0x55, - 0xf6, 0x2d, 0x25, 0x94, 0x7d, 0x67, 0xf2, 0x08, 0x74, 0x56, 0xed, 0xfd, 0xeb, 0x22, 0x8c, 0x54, - 0xfc, 0xba, 0xda, 0x67, 0xff, 0xdd, 0x83, 0xb8, 0x11, 0xe5, 0x66, 0x0f, 0xd3, 0x28, 0x33, 0x7b, - 0x62, 0x19, 0xf5, 0xe2, 0x47, 0xcc, 0x9b, 0xe8, 0x36, 0x71, 0x37, 0xb7, 0x22, 0x52, 0x4f, 0x7e, - 0xce, 0xd1, 0x79, 0x13, 0x7d, 0xaf, 0x08, 0x13, 0x89, 0xd6, 0x51, 0x03, 0xc6, 0x1a, 0xba, 0x2a, - 0x49, 0xac, 0xd3, 0x07, 0xd2, 0x42, 0x09, 0x6f, 0x0c, 0xad, 0x08, 0x9b, 0xc4, 0xd1, 0x2c, 0x80, - 0xa7, 0xdb, 0xa4, 0xab, 0x98, 0xd0, 0x9a, 0x3d, 0xba, 0x86, 0x81, 0x5e, 0x81, 0x91, 0xc8, 0x6f, - 0xf9, 0x0d, 0x7f, 0x73, 0xf7, 0x9a, 0x8a, 0x8f, 0xac, 0x4c, 0x96, 0xd7, 0x63, 0x10, 0xd6, 0xf1, - 0xd0, 0x3d, 0x98, 0x52, 0x44, 0xaa, 0x0f, 0x41, 0xbd, 0xc6, 0xc4, 0x26, 0x6b, 0x49, 0x8a, 0x38, - 0xdd, 0x08, 0x7a, 0x0d, 0xc6, 0x99, 0xed, 0x34, 0xab, 0x7f, 0x8d, 0xec, 0xca, 0xe0, 0xd2, 0x8c, - 0xc3, 0x5e, 0x35, 0x20, 0x38, 0x81, 0x89, 0x16, 0x60, 0xaa, 0xe9, 0x86, 0x89, 0xea, 0x03, 0xac, - 0x3a, 0xeb, 0xc0, 0x6a, 0x12, 0x88, 0xd3, 0xf8, 0xf6, 0x2f, 0x88, 0x39, 0xf6, 0x22, 0xf7, 0xa3, - 0xed, 0xf8, 0xe1, 0xde, 0x8e, 0xdf, 0xb5, 0x60, 0x92, 0xb6, 0xce, 0x0c, 0x42, 0x25, 0x23, 0xa5, - 0xd2, 0x8f, 0x58, 0x1d, 0xd2, 0x8f, 0x9c, 0xa7, 0xc7, 0x76, 0xdd, 0x6f, 0x47, 0x42, 0x3a, 0xaa, - 0x9d, 0xcb, 0xb4, 0x14, 0x0b, 0xa8, 0xc0, 0x23, 0x41, 0x20, 0xbc, 0xee, 0x75, 0x3c, 0x12, 0x04, - 0x58, 0x40, 0x65, 0x76, 0x92, 0xbe, 0xec, 0xec, 0x24, 0x3c, 0xc8, 0xbc, 0xb0, 0xa3, 0x13, 0x2c, - 0xad, 0x16, 0x64, 0x5e, 0x1a, 0xd8, 0xc5, 0x38, 0xf6, 0x3f, 0x2b, 0x42, 0xa9, 0xe2, 0xd7, 0x17, - 0x48, 0x10, 0xb9, 0x1b, 0x6e, 0xcd, 0x89, 0x88, 0x96, 0xf9, 0xf6, 0x45, 0x00, 0xe6, 0x44, 0x16, - 0x64, 0x45, 0x50, 0xaf, 0x2a, 0x08, 0xd6, 0xb0, 0x28, 0x57, 0xb2, 0x4d, 0x76, 0xb5, 0x9b, 0x57, - 0x71, 0x25, 0xd7, 0x78, 0x31, 0x96, 0x70, 0x74, 0x9d, 0x85, 0x32, 0x5a, 0xba, 0xd7, 0x72, 0x03, - 0x9e, 0x23, 0x9c, 0xd4, 0x7c, 0xaf, 0x1e, 0x8a, 0xc0, 0x6f, 0x25, 0x11, 0x88, 0x28, 0x05, 0xc7, - 0x99, 0xb5, 0x50, 0x05, 0x8e, 0xd5, 0x02, 0x52, 0x27, 0x5e, 0xe4, 0x3a, 0x8d, 0xf9, 0xb6, 0x57, - 0x6f, 0xf0, 0x94, 0x3c, 0x7d, 0x46, 0x2e, 0xcf, 0x63, 0x0b, 0x19, 0x38, 0x38, 0xb3, 0xa6, 0xf8, - 0x14, 0x46, 0xa4, 0x3f, 0xf5, 0x29, 0xac, 0x9e, 0x84, 0xb3, 0xc6, 0xe3, 0x21, 0x5c, 0xd8, 0x72, - 0x5c, 0x8f, 0xd5, 0x1b, 0x48, 0x34, 0x9e, 0x81, 0x83, 0x33, 0x6b, 0xda, 0x3f, 0x28, 0xc2, 0x28, - 0x9d, 0x18, 0x65, 0x71, 0xf3, 0xb2, 0x61, 0x71, 0x73, 0x2e, 0x61, 0x71, 0x33, 0xa9, 0xe3, 0x6a, - 0xf6, 0x35, 0x6f, 0x03, 0xf2, 0x45, 0x52, 0x82, 0x2b, 0xc4, 0x23, 0x7c, 0xc8, 0x98, 0x90, 0xb1, - 0x18, 0xdb, 0xa3, 0xdc, 0x48, 0x61, 0xe0, 0x8c, 0x5a, 0x1f, 0xd9, 0xea, 0x1c, 0xad, 0xad, 0xce, - 0xef, 0x58, 0x6c, 0x05, 0x2c, 0xae, 0x55, 0xb9, 0x11, 0x39, 0xba, 0x04, 0x23, 0xec, 0x1a, 0x63, - 0xb1, 0x3c, 0xa4, 0x49, 0x0b, 0xcb, 0x33, 0xbb, 0x16, 0x17, 0x63, 0x1d, 0x07, 0x5d, 0x80, 0xa1, - 0x90, 0x38, 0x41, 0x6d, 0x4b, 0xdd, 0xe1, 0xc2, 0xfe, 0x84, 0x97, 0x61, 0x05, 0x45, 0xef, 0xc4, - 0x11, 0xe1, 0x8b, 0xf9, 0x16, 0xe9, 0x7a, 0x7f, 0xf8, 0x39, 0x98, 0x1f, 0x06, 0xde, 0xbe, 0x0d, - 0x28, 0x8d, 0xdf, 0x83, 0x8b, 0x5f, 0xd9, 0x8c, 0x59, 0x3c, 0x9c, 0x8a, 0x57, 0xfc, 0x77, 0x16, - 0x8c, 0x57, 0xfc, 0x3a, 0x3d, 0x9f, 0x7f, 0x9c, 0x0e, 0x63, 0x3d, 0x83, 0xc7, 0x40, 0x87, 0x0c, - 0x1e, 0x4f, 0x40, 0x7f, 0xc5, 0xaf, 0x77, 0x89, 0xab, 0xfc, 0x6f, 0x2c, 0x18, 0xac, 0xf8, 0xf5, - 0x23, 0xd0, 0xae, 0xbd, 0x61, 0x6a, 0xd7, 0x4e, 0xe6, 0xac, 0x9b, 0x1c, 0x85, 0xda, 0xef, 0xf7, - 0xc1, 0x18, 0xed, 0xa7, 0xbf, 0x29, 0xa7, 0xd2, 0x18, 0x36, 0xab, 0x87, 0x61, 0xa3, 0x6f, 0x3d, - 0xbf, 0xd1, 0xf0, 0xef, 0x26, 0xa7, 0x75, 0x99, 0x95, 0x62, 0x01, 0x45, 0xcf, 0xc3, 0x50, 0x2b, - 0x20, 0x3b, 0xae, 0x2f, 0x1e, 0x51, 0x9a, 0xae, 0xb2, 0x22, 0xca, 0xb1, 0xc2, 0x40, 0x2f, 0xc3, - 0x68, 0xe8, 0x7a, 0x94, 0x61, 0xe4, 0xb7, 0x52, 0x1f, 0x3b, 0x33, 0x79, 0x9a, 0x39, 0xad, 0x1c, - 0x1b, 0x58, 0xe8, 0x36, 0x0c, 0xb3, 0xff, 0xec, 0xd8, 0xe9, 0x3f, 0xf4, 0xb1, 0x23, 0xb2, 0x79, - 0x0b, 0x02, 0x38, 0xa6, 0x45, 0xef, 0xe2, 0x48, 0xa6, 0x6a, 0x0a, 0x45, 0x7c, 0x5d, 0x75, 0x17, - 0xab, 0x24, 0x4e, 0x21, 0xd6, 0xb0, 0xd0, 0x73, 0x30, 0x1c, 0x39, 0x6e, 0xe3, 0xba, 0xeb, 0x31, - 0x23, 0x0d, 0xda, 0x7f, 0x91, 0x54, 0x5b, 0x14, 0xe2, 0x18, 0x4e, 0x19, 0x7e, 0x16, 0x76, 0x6c, - 0x7e, 0x37, 0x12, 0xa9, 0x1e, 0x8b, 0x9c, 0xe1, 0xbf, 0xae, 0x4a, 0xb1, 0x86, 0x81, 0xb6, 0xe0, - 0xb4, 0xeb, 0xb1, 0x94, 0x6c, 0xa4, 0xba, 0xed, 0xb6, 0xd6, 0xaf, 0x57, 0x6f, 0x91, 0xc0, 0xdd, - 0xd8, 0x9d, 0x77, 0x6a, 0xdb, 0xc4, 0xab, 0x33, 0x79, 0xd0, 0xd0, 0xfc, 0x93, 0xa2, 0x8b, 0xa7, - 0x57, 0x3a, 0xe0, 0xe2, 0x8e, 0x94, 0x90, 0x4d, 0xb7, 0x63, 0x40, 0x9c, 0xa6, 0x10, 0xfc, 0xf0, - 0x74, 0x4e, 0xac, 0x04, 0x0b, 0x88, 0xfd, 0x12, 0xdb, 0x13, 0x37, 0xaa, 0xe8, 0x59, 0xe3, 0x78, - 0x39, 0xa1, 0x1f, 0x2f, 0x07, 0x7b, 0xe5, 0x81, 0x1b, 0x55, 0x2d, 0x04, 0xd5, 0x65, 0x38, 0x5e, - 0xf1, 0xeb, 0x15, 0x3f, 0x88, 0x96, 0xfd, 0xe0, 0xae, 0x13, 0xd4, 0xe5, 0x12, 0x2c, 0xcb, 0x20, - 0x5c, 0xf4, 0x8c, 0xed, 0xe7, 0x27, 0x90, 0x11, 0x60, 0xeb, 0x25, 0xc6, 0xba, 0x1f, 0xd2, 0xe7, - 0xb9, 0xc6, 0x98, 0x48, 0x95, 0xf8, 0xf0, 0x8a, 0x13, 0x11, 0x74, 0x03, 0xc6, 0x6a, 0xfa, 0xb5, - 0x2d, 0xaa, 0x3f, 0x23, 0x2f, 0x3b, 0xe3, 0x4e, 0xcf, 0xbc, 0xe7, 0xcd, 0xfa, 0xf6, 0x77, 0x2c, - 0xd1, 0x0a, 0x17, 0x49, 0x71, 0xe3, 0xe6, 0xee, 0x67, 0xee, 0x02, 0x4c, 0x05, 0x7a, 0x15, 0xcd, - 0x48, 0xf0, 0x38, 0xcf, 0x24, 0x95, 0x00, 0xe2, 0x34, 0x3e, 0xfa, 0x2c, 0x9c, 0x32, 0x0a, 0xa5, - 0xbd, 0x84, 0x96, 0x24, 0x9e, 0x09, 0xed, 0x70, 0x1e, 0x12, 0xce, 0xaf, 0x6f, 0xff, 0x24, 0x9c, - 0x48, 0x7e, 0x97, 0x10, 0xa3, 0x3d, 0xe0, 0xd7, 0x15, 0x0e, 0xf7, 0x75, 0xf6, 0x2b, 0x30, 0x55, - 0xf1, 0xb5, 0x00, 0x23, 0x6c, 0xfe, 0xba, 0xc7, 0x39, 0xfb, 0xe5, 0x21, 0x76, 0x0d, 0x26, 0xb2, - 0x19, 0xa2, 0xcf, 0xc3, 0x78, 0x48, 0x58, 0x70, 0x3f, 0x29, 0xbe, 0xed, 0x10, 0xb0, 0xa0, 0xba, - 0xa4, 0x63, 0xf2, 0x27, 0xaa, 0x59, 0x86, 0x13, 0xd4, 0x50, 0x13, 0xc6, 0xef, 0xba, 0x5e, 0xdd, - 0xbf, 0x1b, 0x4a, 0xfa, 0x43, 0xf9, 0xba, 0xa0, 0xdb, 0x1c, 0x33, 0xd1, 0x47, 0xa3, 0xb9, 0xdb, - 0x06, 0x31, 0x9c, 0x20, 0x4e, 0x8f, 0x9a, 0xa0, 0xed, 0xcd, 0x85, 0x37, 0x43, 0x12, 0x88, 0xd0, - 0x83, 0xec, 0xa8, 0xc1, 0xb2, 0x10, 0xc7, 0x70, 0x7a, 0xd4, 0xb0, 0x3f, 0x2c, 0xe2, 0x01, 0x3b, - 0xcb, 0xc4, 0x51, 0x83, 0x55, 0x29, 0xd6, 0x30, 0xe8, 0x51, 0xcc, 0xfe, 0xad, 0xf9, 0x1e, 0xf6, - 0xfd, 0x48, 0x1e, 0xde, 0x2c, 0xf5, 0xab, 0x56, 0x8e, 0x0d, 0xac, 0x9c, 0x40, 0x87, 0x7d, 0x87, - 0x0d, 0x74, 0x88, 0xa2, 0x0e, 0x41, 0x1e, 0x78, 0xa8, 0xee, 0xcb, 0x9d, 0x82, 0x3c, 0x1c, 0x3c, - 0x50, 0x00, 0x08, 0xca, 0x0b, 0x6c, 0x88, 0x01, 0xea, 0xe7, 0x91, 0x1c, 0x99, 0xb6, 0xba, 0xca, - 0x47, 0x47, 0xc2, 0xd0, 0x12, 0x0c, 0x86, 0xbb, 0x61, 0x2d, 0x6a, 0x84, 0x9d, 0xd2, 0xfb, 0x56, - 0x19, 0x8a, 0x96, 0xb2, 0x9e, 0x57, 0xc1, 0xb2, 0x2e, 0xaa, 0xc1, 0xb4, 0xa0, 0xb8, 0xb0, 0xe5, - 0x78, 0x2a, 0xe9, 0x28, 0x37, 0x4b, 0xbd, 0xb4, 0xbf, 0x57, 0x9e, 0x16, 0x2d, 0xeb, 0xe0, 0x83, - 0xbd, 0x32, 0xdd, 0x92, 0x19, 0x10, 0x9c, 0x45, 0x8d, 0x2f, 0xf9, 0x5a, 0xcd, 0x6f, 0xb6, 0x2a, - 0x81, 0xbf, 0xe1, 0x36, 0x48, 0x27, 0x8d, 0x7f, 0xd5, 0xc0, 0x14, 0x4b, 0xde, 0x28, 0xc3, 0x09, - 0x6a, 0xe8, 0x0e, 0x4c, 0x38, 0xad, 0xd6, 0x5c, 0xd0, 0xf4, 0x03, 0xd9, 0xc0, 0x48, 0xbe, 0xea, - 0x68, 0xce, 0x44, 0xe5, 0x39, 0x47, 0x13, 0x85, 0x38, 0x49, 0x90, 0x0e, 0x94, 0xd8, 0x68, 0xc6, - 0x40, 0x8d, 0xc5, 0x03, 0x25, 0xf6, 0x65, 0xc6, 0x40, 0x65, 0x40, 0x70, 0x16, 0x35, 0xfb, 0xef, - 0x33, 0xc6, 0x9f, 0x05, 0x02, 0x67, 0xfe, 0x5f, 0x4d, 0x18, 0x6b, 0xb1, 0x63, 0x5f, 0xe4, 0x03, - 0x14, 0x47, 0xc5, 0xcb, 0x3d, 0x4a, 0xa8, 0xef, 0xb2, 0x8c, 0xc6, 0x86, 0xa5, 0x72, 0x45, 0x27, - 0x87, 0x4d, 0xea, 0xf6, 0x5f, 0xcc, 0x30, 0xd6, 0xb1, 0xca, 0xc5, 0xce, 0x83, 0xc2, 0x1b, 0x56, - 0x08, 0x9a, 0x66, 0xf2, 0x15, 0x3c, 0xf1, 0xfa, 0x12, 0x1e, 0xb5, 0x58, 0xd6, 0x45, 0x9f, 0x83, - 0x71, 0xd7, 0x73, 0xe3, 0x4c, 0xe0, 0x61, 0xe9, 0x58, 0x7e, 0x98, 0x35, 0x85, 0xa5, 0xe7, 0x0a, - 0xd5, 0x2b, 0xe3, 0x04, 0x31, 0xf4, 0x0e, 0x33, 0xde, 0x95, 0xa4, 0x0b, 0xbd, 0x90, 0xd6, 0xed, - 0x74, 0x25, 0x59, 0x8d, 0x08, 0x6a, 0xc3, 0x74, 0x3a, 0x23, 0x7a, 0x58, 0xb2, 0xf3, 0xdf, 0x46, - 0xe9, 0xa4, 0xe6, 0x71, 0x52, 0xc7, 0x34, 0x2c, 0xc4, 0x59, 0xf4, 0xd1, 0xf5, 0x64, 0xbe, 0xea, - 0xa2, 0xa1, 0x1a, 0x4a, 0xe5, 0xac, 0x1e, 0xeb, 0x98, 0xaa, 0x7a, 0x13, 0xce, 0x68, 0x29, 0x7f, - 0xaf, 0x04, 0x0e, 0x33, 0x1e, 0x73, 0xd9, 0x6d, 0xa4, 0x31, 0xb5, 0x8f, 0xef, 0xef, 0x95, 0xcf, - 0xac, 0x77, 0x42, 0xc4, 0x9d, 0xe9, 0xa0, 0x1b, 0x70, 0x9c, 0x07, 0x09, 0x5a, 0x24, 0x4e, 0xbd, - 0xe1, 0x7a, 0x8a, 0x6b, 0xe6, 0x67, 0xd7, 0xa9, 0xfd, 0xbd, 0xf2, 0xf1, 0xb9, 0x2c, 0x04, 0x9c, - 0x5d, 0x0f, 0xbd, 0x01, 0xc3, 0x75, 0x4f, 0x9e, 0xb2, 0x03, 0x46, 0x56, 0xe5, 0xe1, 0xc5, 0xb5, - 0xaa, 0xfa, 0xfe, 0xf8, 0x0f, 0x8e, 0x2b, 0xa0, 0x4d, 0xae, 0x9b, 0x54, 0x02, 0xe5, 0xc1, 0x54, - 0xec, 0xd8, 0xa4, 0xce, 0xc5, 0x88, 0xba, 0xc1, 0x95, 0xf2, 0xca, 0x33, 0xd3, 0x08, 0xc8, 0x61, - 0x10, 0x46, 0x6f, 0x03, 0x12, 0xa9, 0xb0, 0xe6, 0x6a, 0x2c, 0xd9, 0xa4, 0x66, 0x30, 0xac, 0x44, - 0x08, 0xd5, 0x14, 0x06, 0xce, 0xa8, 0x85, 0xae, 0xd2, 0xe3, 0x51, 0x2f, 0x15, 0xc7, 0xaf, 0xca, - 0xdd, 0xbf, 0x48, 0x5a, 0x01, 0x61, 0x36, 0xae, 0x26, 0x45, 0x9c, 0xa8, 0x87, 0xea, 0x70, 0xda, - 0x69, 0x47, 0x3e, 0x53, 0xfb, 0x9a, 0xa8, 0xeb, 0xfe, 0x36, 0xf1, 0x98, 0xc5, 0xc5, 0x10, 0x8b, - 0x49, 0x7b, 0x7a, 0xae, 0x03, 0x1e, 0xee, 0x48, 0x85, 0x3e, 0xa7, 0xe8, 0x58, 0x68, 0x1a, 0x59, - 0x23, 0x80, 0x00, 0x37, 0x53, 0x90, 0x18, 0xe8, 0x15, 0x18, 0xd9, 0xf2, 0xc3, 0x68, 0x8d, 0x44, - 0x77, 0xfd, 0x60, 0x5b, 0xe4, 0xde, 0x88, 0xf3, 0x1d, 0xc5, 0x20, 0xac, 0xe3, 0xa1, 0x67, 0x60, - 0x90, 0xd9, 0x03, 0xae, 0x2c, 0xb2, 0xbb, 0x76, 0x28, 0x3e, 0x63, 0xae, 0xf2, 0x62, 0x2c, 0xe1, - 0x12, 0x75, 0xa5, 0xb2, 0xc0, 0x8e, 0xe3, 0x04, 0xea, 0x4a, 0x65, 0x01, 0x4b, 0x38, 0x5d, 0xae, - 0xe1, 0x96, 0x13, 0x90, 0x4a, 0xe0, 0xd7, 0x48, 0xa8, 0x65, 0xd9, 0x7a, 0x8c, 0x67, 0x16, 0xa1, - 0xcb, 0xb5, 0x9a, 0x85, 0x80, 0xb3, 0xeb, 0x21, 0x92, 0x4e, 0x77, 0x3d, 0x9e, 0xaf, 0x0f, 0x4f, - 0xb3, 0x83, 0x3d, 0x66, 0xbc, 0xf6, 0x60, 0x52, 0x25, 0xda, 0xe6, 0xb9, 0x44, 0xc2, 0xd2, 0x04, - 0x5b, 0xdb, 0xbd, 0x27, 0x22, 0x51, 0x16, 0x06, 0x2b, 0x09, 0x4a, 0x38, 0x45, 0xdb, 0x08, 0x7a, - 0x3c, 0xd9, 0x35, 0xe8, 0xf1, 0x45, 0x18, 0x0e, 0xdb, 0x77, 0xea, 0x7e, 0xd3, 0x71, 0x3d, 0x66, - 0x56, 0xa5, 0x3d, 0xdc, 0xab, 0x12, 0x80, 0x63, 0x1c, 0xb4, 0x0c, 0x43, 0x8e, 0x34, 0x1f, 0x40, - 0xf9, 0xf1, 0x1c, 0x95, 0xd1, 0x00, 0x0f, 0x71, 0x26, 0x0d, 0x06, 0x54, 0x5d, 0xf4, 0x3a, 0x8c, - 0x89, 0x98, 0x31, 0x42, 0x54, 0x3d, 0x6d, 0x7a, 0xb9, 0x57, 0x75, 0x20, 0x36, 0x71, 0xd1, 0x4d, - 0x18, 0x89, 0xfc, 0x86, 0x90, 0x71, 0x86, 0xa5, 0x13, 0xf9, 0x61, 0x97, 0xd7, 0x15, 0x9a, 0xae, - 0xd8, 0x52, 0x55, 0xb1, 0x4e, 0x07, 0xad, 0xf3, 0xf5, 0xce, 0x72, 0x6a, 0x91, 0xb0, 0x74, 0x32, - 0xff, 0x4e, 0x52, 0xa9, 0xb7, 0xcc, 0xed, 0x20, 0x6a, 0x62, 0x9d, 0x0c, 0xba, 0x02, 0x53, 0xad, - 0xc0, 0xf5, 0xd9, 0x9a, 0x50, 0xe6, 0x10, 0x25, 0x33, 0xe9, 0x6f, 0x25, 0x89, 0x80, 0xd3, 0x75, - 0x58, 0xc8, 0x1f, 0x51, 0x58, 0x3a, 0xc5, 0xb3, 0x00, 0x72, 0x39, 0x08, 0x2f, 0xc3, 0x0a, 0x8a, - 0x56, 0xd9, 0x49, 0xcc, 0x45, 0x78, 0xa5, 0x99, 0xfc, 0x40, 0x12, 0xba, 0xa8, 0x8f, 0xf3, 0xfe, - 0xea, 0x2f, 0x8e, 0x29, 0xa0, 0x3a, 0xc4, 0xa9, 0xfe, 0xe9, 0x0b, 0x2a, 0x2c, 0x9d, 0xee, 0x60, - 0x94, 0x9d, 0x78, 0x2e, 0xc7, 0x0c, 0x81, 0x51, 0x1c, 0xe2, 0x04, 0x4d, 0xf4, 0x16, 0x4c, 0x8a, - 0x78, 0x18, 0xf1, 0x30, 0x9d, 0x89, 0x1d, 0xd7, 0x70, 0x02, 0x86, 0x53, 0xd8, 0x3c, 0x0b, 0x9f, - 0x73, 0xa7, 0x41, 0xc4, 0xd1, 0x77, 0xdd, 0xf5, 0xb6, 0xc3, 0xd2, 0x59, 0x76, 0x3e, 0x88, 0x2c, - 0x7c, 0x49, 0x28, 0xce, 0xa8, 0x81, 0xd6, 0x61, 0xb2, 0x15, 0x10, 0xd2, 0x64, 0xef, 0x24, 0x71, - 0x9f, 0x95, 0x79, 0xc4, 0x2b, 0xda, 0x93, 0x4a, 0x02, 0x76, 0x90, 0x51, 0x86, 0x53, 0x14, 0xd0, - 0x5d, 0x18, 0xf2, 0x77, 0x48, 0xb0, 0x45, 0x9c, 0x7a, 0xe9, 0x5c, 0x07, 0x77, 0x4a, 0x71, 0xb9, - 0xdd, 0x10, 0xb8, 0x09, 0x6b, 0x33, 0x59, 0xdc, 0xdd, 0xda, 0x4c, 0x36, 0x86, 0xfe, 0x23, 0x0b, - 0x4e, 0x49, 0xfd, 0x6d, 0xb5, 0x45, 0x47, 0x7d, 0xc1, 0xf7, 0xc2, 0x28, 0xe0, 0x31, 0x9a, 0x1e, - 0xcf, 0x8f, 0x5b, 0xb4, 0x9e, 0x53, 0x49, 0x69, 0x11, 0x4e, 0xe5, 0x61, 0x84, 0x38, 0xbf, 0x45, - 0xfa, 0xb2, 0x0f, 0x49, 0x24, 0x0f, 0xa3, 0xb9, 0x70, 0xf9, 0x9d, 0xc5, 0xb5, 0xd2, 0x13, 0x3c, - 0xc0, 0x14, 0xdd, 0x0c, 0xd5, 0x24, 0x10, 0xa7, 0xf1, 0xd1, 0x25, 0x28, 0xf8, 0x61, 0xe9, 0x49, - 0xb6, 0xb6, 0x4f, 0xe5, 0x8c, 0xe3, 0x8d, 0x2a, 0xb7, 0x3a, 0xbe, 0x51, 0xc5, 0x05, 0x3f, 0x94, - 0x99, 0xf0, 0xe8, 0x73, 0x36, 0x2c, 0x3d, 0xc5, 0x65, 0xce, 0x32, 0x13, 0x1e, 0x2b, 0xc4, 0x31, - 0x1c, 0x6d, 0xc1, 0x44, 0x68, 0x88, 0x0d, 0xc2, 0xd2, 0x79, 0x36, 0x52, 0x4f, 0xe5, 0x4d, 0x9a, - 0x81, 0xad, 0xa5, 0xa8, 0x32, 0xa9, 0xe0, 0x24, 0x59, 0xbe, 0xbb, 0x34, 0xc1, 0x45, 0x58, 0x7a, - 0xba, 0xcb, 0xee, 0xd2, 0x90, 0xf5, 0xdd, 0xa5, 0xd3, 0xc0, 0x09, 0x9a, 0xe8, 0xa6, 0xee, 0xab, - 0x7a, 0x21, 0xdf, 0x82, 0x35, 0xd3, 0x4b, 0x75, 0x2c, 0xd7, 0x43, 0xf5, 0x2d, 0x98, 0x94, 0x77, - 0x09, 0x5d, 0x99, 0x81, 0x5b, 0x27, 0xa5, 0x67, 0xe2, 0x4d, 0x7b, 0x35, 0x01, 0xc3, 0x29, 0xec, - 0x99, 0x9f, 0x80, 0xa9, 0x14, 0x1f, 0x77, 0x18, 0xd7, 0x9f, 0x99, 0x6d, 0x18, 0x33, 0xf6, 0xca, - 0x23, 0xb5, 0x0c, 0xfb, 0xa7, 0x00, 0xc3, 0xca, 0x62, 0x27, 0x47, 0x53, 0x37, 0xf5, 0x40, 0x9a, - 0xba, 0x8b, 0xa6, 0x61, 0xd9, 0xa9, 0xa4, 0x61, 0xd9, 0x50, 0xc5, 0xaf, 0x1b, 0xb6, 0x64, 0xeb, - 0x19, 0xc1, 0xa1, 0xf3, 0x4e, 0xf9, 0xde, 0x7d, 0x1d, 0x35, 0x65, 0x57, 0xb1, 0x67, 0x0b, 0xb5, - 0xbe, 0x8e, 0xfa, 0xb3, 0x2b, 0x30, 0xe5, 0xf9, 0xec, 0x21, 0x42, 0xea, 0x92, 0xcb, 0x64, 0xcc, - 0xe4, 0xb0, 0x1e, 0xbc, 0x30, 0x81, 0x80, 0xd3, 0x75, 0x68, 0x83, 0x9c, 0x1b, 0x4c, 0x2a, 0xec, - 0x38, 0xb3, 0x88, 0x05, 0x94, 0x3e, 0x80, 0xf9, 0xaf, 0xb0, 0x34, 0x99, 0xff, 0x00, 0xe6, 0x95, - 0x92, 0x1c, 0x67, 0x28, 0x39, 0x4e, 0xa6, 0x9f, 0x6a, 0xf9, 0xf5, 0x95, 0x8a, 0x78, 0xcb, 0x68, - 0x69, 0x1b, 0xea, 0x2b, 0x15, 0xcc, 0x61, 0x68, 0x0e, 0x06, 0xd8, 0x0f, 0x19, 0x14, 0x2a, 0xef, - 0x2c, 0x5a, 0xa9, 0x68, 0xe9, 0x86, 0x59, 0x05, 0x2c, 0x2a, 0x32, 0xfd, 0x03, 0x7d, 0x00, 0x32, - 0xfd, 0xc3, 0xe0, 0x03, 0xea, 0x1f, 0x24, 0x01, 0x1c, 0xd3, 0x42, 0xf7, 0xe0, 0xb8, 0xf1, 0xe8, - 0x56, 0xce, 0x9f, 0x90, 0x6f, 0x7f, 0x92, 0x40, 0x9e, 0x3f, 0x23, 0x3a, 0x7d, 0x7c, 0x25, 0x8b, - 0x12, 0xce, 0x6e, 0x00, 0x35, 0x60, 0xaa, 0x96, 0x6a, 0x75, 0xa8, 0xf7, 0x56, 0xd5, 0xba, 0x48, - 0xb7, 0x98, 0x26, 0x8c, 0x5e, 0x87, 0xa1, 0xf7, 0x7d, 0x6e, 0x2b, 0x2a, 0xde, 0x5f, 0x32, 0x74, - 0xd1, 0xd0, 0x3b, 0x37, 0xaa, 0xac, 0xfc, 0x60, 0xaf, 0x3c, 0x52, 0xf1, 0xeb, 0xf2, 0x2f, 0x56, - 0x15, 0xd0, 0x3f, 0xb2, 0x60, 0x26, 0xfd, 0xaa, 0x57, 0x9d, 0x1e, 0xeb, 0xbd, 0xd3, 0xb6, 0x68, - 0x74, 0x66, 0x29, 0x97, 0x1c, 0xee, 0xd0, 0x14, 0xfa, 0x24, 0xdd, 0x4f, 0xa1, 0x7b, 0x9f, 0x3b, - 0x7f, 0x68, 0xba, 0x7a, 0xcc, 0x4a, 0x0f, 0xf6, 0xca, 0x13, 0xfc, 0xf8, 0x77, 0xef, 0xab, 0x04, - 0x13, 0xbc, 0x02, 0xfa, 0x49, 0x38, 0x1e, 0xa4, 0xa5, 0xec, 0x44, 0xbe, 0x34, 0x9e, 0xed, 0xe5, - 0x2a, 0x49, 0x4e, 0x38, 0xce, 0x22, 0x88, 0xb3, 0xdb, 0xb1, 0x7f, 0xd3, 0x62, 0xda, 0x15, 0xd1, - 0x2d, 0x12, 0xb6, 0x1b, 0xd1, 0x11, 0xd8, 0x67, 0x2e, 0x19, 0xd6, 0x0d, 0x0f, 0x6c, 0x60, 0xf9, - 0xdf, 0x5a, 0xcc, 0xc0, 0xf2, 0x08, 0x5d, 0x45, 0xdf, 0x81, 0xa1, 0x48, 0xb4, 0x26, 0xba, 0x9e, - 0x67, 0x0c, 0x26, 0x3b, 0xc5, 0x8c, 0x4c, 0xd5, 0x4b, 0x4e, 0x96, 0x62, 0x45, 0xc6, 0xfe, 0xaf, - 0xf8, 0x0c, 0x48, 0xc8, 0x11, 0x28, 0x91, 0x17, 0x4d, 0x25, 0x72, 0xb9, 0xcb, 0x17, 0xe4, 0x28, - 0x93, 0xff, 0x4b, 0xb3, 0xdf, 0x4c, 0x82, 0xf9, 0x61, 0xb7, 0xec, 0xb5, 0xbf, 0x6a, 0x01, 0xc4, - 0x19, 0x7d, 0x7a, 0xc8, 0xcd, 0x7e, 0x99, 0xbe, 0xdd, 0xfc, 0xc8, 0xaf, 0xf9, 0x0d, 0xa1, 0xc4, - 0x3a, 0x1d, 0xeb, 0xb1, 0x79, 0xf9, 0x81, 0xf6, 0x1b, 0x2b, 0x6c, 0x54, 0x96, 0x21, 0xb6, 0x8b, - 0xb1, 0x65, 0x85, 0x11, 0x5e, 0xfb, 0x1b, 0x16, 0x1c, 0xcb, 0xf2, 0x3b, 0x42, 0xcf, 0xc3, 0x10, - 0x97, 0xe5, 0x2a, 0xab, 0x6b, 0x35, 0x9b, 0xb7, 0x44, 0x39, 0x56, 0x18, 0x3d, 0x27, 0xbd, 0x3f, - 0x5c, 0xb6, 0x99, 0x1b, 0x30, 0x56, 0x09, 0x88, 0xc6, 0x5f, 0xbc, 0x19, 0x27, 0xc2, 0x1a, 0x9e, - 0x7f, 0xfe, 0xd0, 0xc1, 0xbc, 0xec, 0x6f, 0x16, 0xe0, 0x18, 0xb7, 0x1d, 0x9c, 0xdb, 0xf1, 0xdd, - 0x7a, 0xc5, 0xaf, 0x0b, 0x6f, 0xf1, 0x77, 0x61, 0xb4, 0xa5, 0x09, 0xe0, 0x3b, 0x65, 0x4e, 0xd0, - 0x05, 0xf5, 0xb1, 0xc8, 0x50, 0x2f, 0xc5, 0x06, 0x2d, 0x54, 0x87, 0x51, 0xb2, 0xe3, 0xd6, 0x94, - 0x6d, 0x52, 0xe1, 0xd0, 0x97, 0xb4, 0x6a, 0x65, 0x49, 0xa3, 0x83, 0x0d, 0xaa, 0x3d, 0x5b, 0xfc, - 0x6b, 0x2c, 0x5a, 0x5f, 0x17, 0x7b, 0xa4, 0x9f, 0xb3, 0xe0, 0x64, 0x4e, 0x9e, 0x05, 0xda, 0xdc, - 0x5d, 0x66, 0xa5, 0x29, 0x96, 0xad, 0x6a, 0x8e, 0xdb, 0x6e, 0x62, 0x01, 0x45, 0x9f, 0x06, 0x68, - 0xc5, 0xd9, 0x69, 0xbb, 0x04, 0xa4, 0x37, 0x42, 0x53, 0x6b, 0x51, 0x86, 0x55, 0x12, 0x5b, 0x8d, - 0x96, 0xfd, 0x8d, 0x3e, 0xe8, 0x67, 0x66, 0x60, 0xa8, 0x02, 0x83, 0x5b, 0x3c, 0x08, 0x66, 0xc7, - 0x79, 0xa3, 0xb8, 0x32, 0xaa, 0x66, 0x3c, 0x6f, 0x5a, 0x29, 0x96, 0x64, 0xd0, 0x2a, 0x4c, 0xf3, - 0xcc, 0xbb, 0x8d, 0x45, 0xd2, 0x70, 0x76, 0xa5, 0x6c, 0xbb, 0xc0, 0x3e, 0x55, 0xc9, 0xf8, 0x57, - 0xd2, 0x28, 0x38, 0xab, 0x1e, 0x7a, 0x13, 0xc6, 0x23, 0xb7, 0x49, 0xfc, 0x76, 0x64, 0x5a, 0x3c, - 0xaa, 0xe7, 0xd7, 0xba, 0x01, 0xc5, 0x09, 0x6c, 0xf4, 0x3a, 0x8c, 0xb5, 0x52, 0x52, 0xfc, 0xfe, - 0x58, 0xdc, 0x65, 0x4a, 0xee, 0x4d, 0x5c, 0xe6, 0x7a, 0xd4, 0x66, 0x8e, 0x56, 0xeb, 0x5b, 0x01, - 0x09, 0xb7, 0xfc, 0x46, 0x9d, 0x71, 0xc0, 0xfd, 0x9a, 0xeb, 0x51, 0x02, 0x8e, 0x53, 0x35, 0x28, - 0x95, 0x0d, 0xc7, 0x6d, 0xb4, 0x03, 0x12, 0x53, 0x19, 0x30, 0xa9, 0x2c, 0x27, 0xe0, 0x38, 0x55, - 0xa3, 0xbb, 0x7a, 0x62, 0xf0, 0xe1, 0xa8, 0x27, 0xec, 0x7f, 0x5b, 0x00, 0x63, 0x6a, 0x7f, 0x8c, - 0x13, 0xe9, 0xbe, 0x01, 0x7d, 0x9b, 0x41, 0xab, 0x26, 0x4c, 0x1e, 0x33, 0xbf, 0xec, 0x0a, 0xae, - 0x2c, 0xe8, 0x5f, 0x46, 0xff, 0x63, 0x56, 0x8b, 0xee, 0xf1, 0xe3, 0xc2, 0x00, 0x58, 0xc6, 0xc9, - 0x55, 0x1e, 0x7e, 0x83, 0xf2, 0xc5, 0xdf, 0x21, 0xa2, 0xbc, 0x70, 0x53, 0x52, 0x26, 0xc4, 0x9a, - 0xca, 0x59, 0xbc, 0xf7, 0x25, 0x15, 0x74, 0x09, 0x46, 0x44, 0x6e, 0x53, 0xe6, 0x88, 0xc6, 0x37, - 0x13, 0xb3, 0x66, 0x5c, 0x8c, 0x8b, 0xb1, 0x8e, 0x63, 0xff, 0xe3, 0x02, 0x4c, 0x67, 0x78, 0x12, - 0xf3, 0x6b, 0x64, 0xd3, 0x0d, 0xa3, 0x60, 0x37, 0x79, 0x39, 0x61, 0x51, 0x8e, 0x15, 0x06, 0x3d, - 0xab, 0xf8, 0x45, 0x95, 0xbc, 0x9c, 0x84, 0xa7, 0x9e, 0x80, 0x1e, 0xee, 0x72, 0xa2, 0xd7, 0x76, - 0x3b, 0x24, 0x32, 0x79, 0x85, 0xba, 0xb6, 0x99, 0xe9, 0x03, 0x83, 0xd0, 0x27, 0xe0, 0xa6, 0xd2, - 0xe7, 0x6b, 0x4f, 0x40, 0xae, 0xd1, 0xe7, 0x30, 0xda, 0xb9, 0x88, 0x78, 0x8e, 0x17, 0x89, 0x87, - 0x62, 0x1c, 0xd4, 0x9c, 0x95, 0x62, 0x01, 0xb5, 0xbf, 0x5e, 0x84, 0x53, 0xb9, 0xb1, 0x05, 0x68, - 0xd7, 0x9b, 0xbe, 0xe7, 0x46, 0xbe, 0x32, 0x13, 0xe5, 0x81, 0xcc, 0x49, 0x6b, 0x6b, 0x55, 0x94, - 0x63, 0x85, 0x81, 0xce, 0x43, 0x3f, 0x93, 0xfc, 0x27, 0xf3, 0x1a, 0xe2, 0xf9, 0x45, 0x1e, 0xe6, - 0x95, 0x83, 0xb5, 0x5b, 0xbd, 0xd8, 0xf1, 0x56, 0x7f, 0x82, 0x72, 0x30, 0x7e, 0x23, 0x79, 0xa1, - 0xd0, 0xee, 0xfa, 0x7e, 0x03, 0x33, 0x20, 0x7a, 0x4a, 0x8c, 0x57, 0xc2, 0x2e, 0x12, 0x3b, 0x75, - 0x3f, 0xd4, 0x06, 0x8d, 0xdb, 0x60, 0x07, 0xae, 0xb7, 0x99, 0xb4, 0x97, 0xbd, 0xc6, 0x8b, 0xb1, - 0x84, 0xd3, 0xbd, 0x14, 0xa7, 0x67, 0x1f, 0xcc, 0xdf, 0x4b, 0x2a, 0x09, 0x7b, 0xd7, 0xcc, 0xec, - 0xfa, 0x0a, 0x18, 0xea, 0xca, 0x9e, 0xfc, 0x4c, 0x11, 0x26, 0xf0, 0xfc, 0xe2, 0x47, 0x13, 0x71, - 0x33, 0x3d, 0x11, 0x0f, 0x23, 0x4f, 0xfe, 0xe1, 0x66, 0xe3, 0xd7, 0x2c, 0x98, 0x60, 0x19, 0x56, - 0x45, 0x60, 0x20, 0xd7, 0xf7, 0x8e, 0xe0, 0x29, 0xf0, 0x04, 0xf4, 0x07, 0xb4, 0x51, 0x31, 0x83, - 0x6a, 0x8f, 0xb3, 0x9e, 0x60, 0x0e, 0x43, 0xa7, 0xa1, 0x8f, 0x75, 0x81, 0x4e, 0xde, 0x28, 0x3f, - 0x82, 0x17, 0x9d, 0xc8, 0xc1, 0xac, 0x94, 0x85, 0x28, 0xc5, 0xa4, 0xd5, 0x70, 0x79, 0xa7, 0x63, - 0xbb, 0x8c, 0x0f, 0x47, 0xd4, 0xa1, 0xcc, 0xae, 0x7d, 0xb0, 0x10, 0xa5, 0xd9, 0x24, 0x3b, 0x3f, - 0xb3, 0xff, 0xaa, 0x00, 0x67, 0x33, 0xeb, 0xf5, 0x1c, 0xa2, 0xb4, 0x73, 0xed, 0x47, 0x99, 0x8f, - 0xb1, 0x78, 0x84, 0xde, 0x08, 0x7d, 0xbd, 0x72, 0xff, 0xfd, 0x3d, 0x44, 0x0e, 0xcd, 0x1c, 0xb2, - 0x0f, 0x49, 0xe4, 0xd0, 0xcc, 0xbe, 0xe5, 0x88, 0x09, 0x7e, 0x50, 0xc8, 0xf9, 0x16, 0x26, 0x30, - 0xb8, 0x40, 0xcf, 0x19, 0x06, 0x0c, 0xe5, 0x23, 0x9c, 0x9f, 0x31, 0xbc, 0x0c, 0x2b, 0x28, 0x9a, - 0x83, 0x89, 0xa6, 0xeb, 0xd1, 0xc3, 0x67, 0xd7, 0x64, 0xc5, 0x95, 0xc2, 0x66, 0xd5, 0x04, 0xe3, - 0x24, 0x3e, 0x72, 0xb5, 0xa8, 0xa2, 0xfc, 0xeb, 0x5e, 0x3f, 0xd4, 0xae, 0x9b, 0x35, 0x6d, 0x56, - 0xd4, 0x28, 0x66, 0x44, 0x18, 0x5d, 0xd5, 0xe4, 0x44, 0xc5, 0xde, 0xe5, 0x44, 0xa3, 0xd9, 0x32, - 0xa2, 0x99, 0xd7, 0x61, 0xec, 0x81, 0xf5, 0x2c, 0xf6, 0x77, 0x8b, 0xf0, 0x58, 0x87, 0x6d, 0xcf, - 0xcf, 0x7a, 0x63, 0x0e, 0xb4, 0xb3, 0x3e, 0x35, 0x0f, 0x15, 0x38, 0xb6, 0xd1, 0x6e, 0x34, 0x76, - 0x99, 0x6f, 0x25, 0xa9, 0x4b, 0x0c, 0xc1, 0x53, 0x2a, 0xef, 0xab, 0xe5, 0x0c, 0x1c, 0x9c, 0x59, - 0x93, 0x3e, 0xb1, 0xe8, 0x4d, 0xb2, 0xab, 0x48, 0x25, 0x9e, 0x58, 0x58, 0x07, 0x62, 0x13, 0x17, - 0x5d, 0x81, 0x29, 0x67, 0xc7, 0x71, 0x79, 0x3e, 0x1b, 0x49, 0x80, 0xbf, 0xb1, 0x94, 0x2c, 0x7a, - 0x2e, 0x89, 0x80, 0xd3, 0x75, 0x72, 0x54, 0x42, 0xc5, 0x07, 0x52, 0x09, 0x99, 0xf1, 0x2d, 0x07, - 0xf2, 0xe3, 0x5b, 0x76, 0x3e, 0x17, 0xbb, 0xa6, 0x02, 0x7d, 0x0f, 0xc6, 0x0e, 0x6b, 0x7b, 0xfe, - 0x0c, 0x0c, 0x06, 0x3c, 0xd7, 0x7c, 0xd2, 0x65, 0x50, 0xa6, 0xa0, 0x97, 0x70, 0xfb, 0x7f, 0xb5, - 0x40, 0xc9, 0x92, 0xcd, 0x50, 0xf6, 0xaf, 0x33, 0x43, 0x7a, 0x2e, 0x05, 0xd7, 0xdc, 0x15, 0x8f, - 0x6b, 0x86, 0xf4, 0x31, 0x10, 0x9b, 0xb8, 0x7c, 0xb9, 0x85, 0x71, 0xd0, 0x14, 0xe3, 0x01, 0x21, - 0x74, 0x98, 0x0a, 0x03, 0x7d, 0x06, 0x06, 0xeb, 0xee, 0x8e, 0x1b, 0x0a, 0x39, 0xda, 0xa1, 0x75, - 0x80, 0xf1, 0xf7, 0x2d, 0x72, 0x32, 0x58, 0xd2, 0xb3, 0xff, 0x89, 0x05, 0x4a, 0xf9, 0x7a, 0x95, - 0x38, 0x8d, 0x68, 0x0b, 0xbd, 0x05, 0x20, 0x29, 0x28, 0xd9, 0x9b, 0x34, 0x09, 0x03, 0xac, 0x20, - 0x07, 0xc6, 0x3f, 0xac, 0xd5, 0x41, 0x6f, 0xc2, 0xc0, 0x16, 0xa3, 0x25, 0xbe, 0xed, 0xbc, 0x52, - 0x75, 0xb1, 0xd2, 0x83, 0xbd, 0xf2, 0x31, 0xb3, 0x4d, 0x79, 0x8b, 0xf1, 0x5a, 0xf6, 0xcf, 0x14, - 0xe2, 0x39, 0x7d, 0xa7, 0xed, 0x47, 0xce, 0x11, 0x70, 0x22, 0x57, 0x0c, 0x4e, 0xe4, 0xa9, 0x4e, - 0xda, 0x65, 0xd6, 0xa5, 0x5c, 0x0e, 0xe4, 0x46, 0x82, 0x03, 0x79, 0xba, 0x3b, 0xa9, 0xce, 0x9c, - 0xc7, 0x7f, 0x6d, 0xc1, 0x94, 0x81, 0x7f, 0x04, 0x17, 0xe0, 0xb2, 0x79, 0x01, 0x3e, 0xde, 0xf5, - 0x1b, 0x72, 0x2e, 0xbe, 0x9f, 0x2e, 0x26, 0xfa, 0xce, 0x2e, 0xbc, 0xf7, 0xa1, 0x6f, 0xcb, 0x09, - 0xea, 0xe2, 0x5d, 0x7f, 0xb1, 0xa7, 0xb1, 0x9e, 0xbd, 0xea, 0x04, 0xc2, 0x9c, 0xe4, 0x79, 0x39, - 0xea, 0xb4, 0xa8, 0xab, 0x29, 0x09, 0x6b, 0x0a, 0x5d, 0x86, 0x81, 0xb0, 0xe6, 0xb7, 0x94, 0x57, - 0x22, 0xcb, 0x8f, 0x5f, 0x65, 0x25, 0x07, 0x7b, 0x65, 0x64, 0x36, 0x47, 0x8b, 0xb1, 0xc0, 0x47, - 0xef, 0xc2, 0x18, 0xfb, 0xa5, 0x6c, 0x3b, 0x8b, 0xf9, 0x12, 0x98, 0xaa, 0x8e, 0xc8, 0x0d, 0x9f, - 0x8d, 0x22, 0x6c, 0x92, 0x9a, 0xd9, 0x84, 0x61, 0xf5, 0x59, 0x8f, 0x54, 0xf3, 0xff, 0xc7, 0x45, - 0x98, 0xce, 0x58, 0x73, 0x28, 0x34, 0x66, 0xe2, 0x52, 0x8f, 0x4b, 0xf5, 0x03, 0xce, 0x45, 0xc8, - 0x1e, 0x80, 0x75, 0xb1, 0xb6, 0x7a, 0x6e, 0xf4, 0x66, 0x48, 0x92, 0x8d, 0xd2, 0xa2, 0xee, 0x8d, - 0xd2, 0xc6, 0x8e, 0x6c, 0xa8, 0x69, 0x43, 0xaa, 0xa7, 0x8f, 0x74, 0x4e, 0x7f, 0xa7, 0x0f, 0x8e, - 0x65, 0x19, 0xbc, 0xa0, 0x2f, 0xc1, 0x00, 0x73, 0x9b, 0x93, 0x82, 0xb3, 0x97, 0x7b, 0x35, 0x95, - 0x99, 0x65, 0x9e, 0x77, 0x22, 0x1a, 0xf2, 0xac, 0x3c, 0x8e, 0x78, 0x61, 0xd7, 0x61, 0x16, 0x6d, - 0xb2, 0x28, 0x65, 0xe2, 0xf6, 0x94, 0xc7, 0xc7, 0x27, 0x7a, 0xee, 0x80, 0xb8, 0x7f, 0xc3, 0x84, - 0xdd, 0x98, 0x2c, 0xee, 0x6e, 0x37, 0x26, 0x5b, 0x46, 0x2b, 0x30, 0x50, 0xe3, 0x06, 0x49, 0xc5, - 0xee, 0x47, 0x18, 0xb7, 0x46, 0x52, 0x07, 0xb0, 0xb0, 0x42, 0x12, 0x04, 0x66, 0x5c, 0x18, 0xd1, - 0x06, 0xe6, 0x91, 0x2e, 0x9e, 0x6d, 0x7a, 0xf1, 0x69, 0x43, 0xf0, 0x48, 0x17, 0xd0, 0x3f, 0xd7, - 0xee, 0x7e, 0x71, 0x1e, 0x7c, 0xdc, 0xe0, 0x9d, 0x4e, 0x27, 0x9c, 0x19, 0x13, 0xfb, 0x8a, 0xf1, - 0x52, 0x55, 0x33, 0x8d, 0x40, 0x6e, 0x2e, 0x34, 0xf3, 0xc2, 0xef, 0x9c, 0x3a, 0xc0, 0xfe, 0x39, - 0x0b, 0x12, 0xee, 0x66, 0x4a, 0xdc, 0x69, 0xe5, 0x8a, 0x3b, 0xcf, 0x41, 0x5f, 0xe0, 0x37, 0x24, - 0x3f, 0xa5, 0x30, 0xb0, 0xdf, 0x20, 0x98, 0x41, 0x28, 0x46, 0x14, 0x0b, 0xb1, 0x46, 0xf5, 0x07, - 0xba, 0x78, 0x7a, 0x3f, 0x01, 0xfd, 0x0d, 0xb2, 0x43, 0x1a, 0xc9, 0x94, 0xc0, 0xd7, 0x69, 0x21, - 0xe6, 0x30, 0xfb, 0xd7, 0xfa, 0xe0, 0x4c, 0xc7, 0x60, 0x86, 0x94, 0xc1, 0xdc, 0x74, 0x22, 0x72, - 0xd7, 0xd9, 0x4d, 0xa6, 0xc2, 0xbc, 0xc2, 0x8b, 0xb1, 0x84, 0x33, 0xd7, 0x6f, 0x9e, 0xde, 0x29, - 0x21, 0x1c, 0x16, 0x59, 0x9d, 0x04, 0xd4, 0x14, 0x36, 0x16, 0x1f, 0x86, 0xb0, 0xf1, 0x45, 0x80, - 0x30, 0x6c, 0x70, 0xab, 0xd2, 0xba, 0xf0, 0x29, 0x8f, 0x83, 0x6d, 0x54, 0xaf, 0x0b, 0x08, 0xd6, - 0xb0, 0xd0, 0x22, 0x4c, 0xb6, 0x02, 0x3f, 0xe2, 0xb2, 0xf6, 0x45, 0x6e, 0x78, 0xdd, 0x6f, 0xc6, - 0x91, 0xab, 0x24, 0xe0, 0x38, 0x55, 0x03, 0xbd, 0x02, 0x23, 0x22, 0xb6, 0x5c, 0xc5, 0xf7, 0x1b, - 0x42, 0xbc, 0xa7, 0x6c, 0x91, 0xab, 0x31, 0x08, 0xeb, 0x78, 0x5a, 0x35, 0x26, 0xc0, 0x1f, 0xcc, - 0xac, 0xc6, 0x85, 0xf8, 0x1a, 0x5e, 0x22, 0x0f, 0xc5, 0x50, 0x4f, 0x79, 0x28, 0x62, 0x81, 0xe7, - 0x70, 0xcf, 0xfa, 0x64, 0xe8, 0x2a, 0x22, 0xfc, 0x56, 0x1f, 0x4c, 0x8b, 0x85, 0xf3, 0xa8, 0x97, - 0xcb, 0xcd, 0xf4, 0x72, 0x79, 0x18, 0x22, 0xd1, 0x8f, 0xd6, 0xcc, 0x51, 0xaf, 0x99, 0x9f, 0xb5, - 0xc0, 0xe4, 0x21, 0xd1, 0x7f, 0x90, 0x9b, 0x4b, 0xf8, 0x95, 0x5c, 0x9e, 0x34, 0x0e, 0x52, 0xff, - 0xc1, 0xb2, 0x0a, 0xdb, 0xff, 0xb3, 0x05, 0x8f, 0x77, 0xa5, 0x88, 0x96, 0x60, 0x98, 0x31, 0xba, - 0xda, 0xbb, 0xf8, 0x69, 0xe5, 0x98, 0x21, 0x01, 0x39, 0x7c, 0x77, 0x5c, 0x13, 0x2d, 0xa5, 0x92, - 0x36, 0x3f, 0x93, 0x91, 0xb4, 0xf9, 0xb8, 0x31, 0x3c, 0x0f, 0x98, 0xb5, 0xf9, 0x6b, 0xf4, 0xc6, - 0x31, 0xbd, 0x3b, 0x3f, 0x61, 0x88, 0x73, 0xed, 0x84, 0x38, 0x17, 0x99, 0xd8, 0xda, 0x1d, 0xf2, - 0x16, 0x4c, 0xb2, 0xa0, 0xb3, 0xcc, 0x4d, 0x48, 0xb8, 0x85, 0x16, 0x62, 0xab, 0xe2, 0xeb, 0x09, - 0x18, 0x4e, 0x61, 0xdb, 0x7f, 0x59, 0x84, 0x01, 0xbe, 0xfd, 0x8e, 0xe0, 0xe1, 0xfb, 0x1c, 0x0c, - 0xbb, 0xcd, 0x66, 0x9b, 0xe7, 0xe1, 0xed, 0x8f, 0x0d, 0xcb, 0x57, 0x64, 0x21, 0x8e, 0xe1, 0x68, - 0x59, 0x68, 0x12, 0x3a, 0xc4, 0xb5, 0xe7, 0x1d, 0x9f, 0x5d, 0x74, 0x22, 0x87, 0x73, 0x71, 0xea, - 0x9e, 0x8d, 0x75, 0x0e, 0xe8, 0xf3, 0x00, 0x61, 0x14, 0xb8, 0xde, 0x26, 0x2d, 0x13, 0xc9, 0x4f, - 0x9e, 0xed, 0x40, 0xad, 0xaa, 0x90, 0x39, 0xcd, 0xf8, 0xcc, 0x51, 0x00, 0xac, 0x51, 0x44, 0xb3, - 0xc6, 0x4d, 0x3f, 0x93, 0x98, 0x3b, 0xe0, 0x54, 0xe3, 0x39, 0x9b, 0x79, 0x15, 0x86, 0x15, 0xf1, - 0x6e, 0x72, 0xc5, 0x51, 0x9d, 0x61, 0xfb, 0x14, 0x4c, 0x24, 0xfa, 0x76, 0x28, 0xb1, 0xe4, 0xaf, - 0x5b, 0x30, 0xc1, 0x3b, 0xb3, 0xe4, 0xed, 0x88, 0xdb, 0xe0, 0x3e, 0x1c, 0x6b, 0x64, 0x9c, 0xca, - 0x62, 0xfa, 0x7b, 0x3f, 0xc5, 0x95, 0x18, 0x32, 0x0b, 0x8a, 0x33, 0xdb, 0x40, 0x17, 0xe8, 0x8e, - 0xa3, 0xa7, 0xae, 0xd3, 0x10, 0xb1, 0x4d, 0x46, 0xf9, 0x6e, 0xe3, 0x65, 0x58, 0x41, 0xed, 0x3f, - 0xb5, 0x60, 0x8a, 0xf7, 0xfc, 0x1a, 0xd9, 0x55, 0x67, 0xd3, 0x0f, 0xb3, 0xef, 0x22, 0x03, 0x7c, - 0x21, 0x27, 0x03, 0xbc, 0xfe, 0x69, 0xc5, 0x8e, 0x9f, 0xf6, 0x4d, 0x0b, 0xc4, 0x0a, 0x39, 0x02, - 0x49, 0xcb, 0x4f, 0x98, 0x92, 0x96, 0x99, 0xfc, 0x4d, 0x90, 0x23, 0x62, 0xf9, 0x3b, 0x0b, 0x26, - 0x39, 0x82, 0x16, 0x48, 0xed, 0x87, 0x39, 0x0f, 0xf3, 0xe6, 0x17, 0x65, 0x9a, 0xb5, 0x5e, 0x23, - 0xbb, 0xeb, 0x7e, 0xc5, 0x89, 0xb6, 0xb2, 0x3f, 0xca, 0x98, 0xac, 0xbe, 0x8e, 0x93, 0x55, 0x97, - 0x1b, 0xc8, 0xc8, 0xf5, 0xd9, 0x45, 0x00, 0x7c, 0xd8, 0x5c, 0x9f, 0xf6, 0xf7, 0x2d, 0x40, 0xbc, - 0x19, 0x83, 0x71, 0xa3, 0xec, 0x10, 0x2b, 0xcd, 0x8c, 0x57, 0xa7, 0x20, 0x58, 0xc3, 0x7a, 0x28, - 0xc3, 0x93, 0x30, 0x65, 0x29, 0x76, 0x37, 0x65, 0x39, 0xc4, 0x88, 0x7e, 0x73, 0x10, 0x92, 0x8e, - 0xa1, 0xe8, 0x16, 0x8c, 0xd6, 0x9c, 0x96, 0x73, 0xc7, 0x6d, 0xb8, 0x91, 0x4b, 0xc2, 0x4e, 0x76, - 0x6e, 0x0b, 0x1a, 0x9e, 0x30, 0x3e, 0xd0, 0x4a, 0xb0, 0x41, 0x07, 0xcd, 0x02, 0xb4, 0x02, 0x77, - 0xc7, 0x6d, 0x90, 0x4d, 0x26, 0x10, 0x62, 0xd1, 0x94, 0xb8, 0xd1, 0x9d, 0x2c, 0xc5, 0x1a, 0x46, - 0x46, 0x10, 0x93, 0xe2, 0x23, 0x0e, 0x62, 0x02, 0x47, 0x16, 0xc4, 0xa4, 0xef, 0x50, 0x41, 0x4c, - 0x86, 0x0e, 0x1d, 0xc4, 0xa4, 0xbf, 0xa7, 0x20, 0x26, 0x18, 0x4e, 0x48, 0xde, 0x93, 0xfe, 0x5f, - 0x76, 0x1b, 0x44, 0x3c, 0x38, 0x78, 0x08, 0xa8, 0x99, 0xfd, 0xbd, 0xf2, 0x09, 0x9c, 0x89, 0x81, - 0x73, 0x6a, 0xa2, 0x4f, 0x43, 0xc9, 0x69, 0x34, 0xfc, 0xbb, 0x6a, 0x52, 0x97, 0xc2, 0x9a, 0xd3, - 0x88, 0x23, 0x03, 0x0e, 0xcd, 0x9f, 0xde, 0xdf, 0x2b, 0x97, 0xe6, 0x72, 0x70, 0x70, 0x6e, 0x6d, - 0xf4, 0x06, 0x0c, 0xb7, 0x02, 0xbf, 0xb6, 0xaa, 0x79, 0xaf, 0x9f, 0xa5, 0x03, 0x58, 0x91, 0x85, - 0x07, 0x7b, 0xe5, 0x31, 0xf5, 0x87, 0x5d, 0xf8, 0x71, 0x85, 0x8c, 0xf8, 0x20, 0x23, 0x8f, 0x3a, - 0x3e, 0xc8, 0xe8, 0x43, 0x8e, 0x0f, 0x62, 0x6f, 0xc3, 0x74, 0x95, 0x04, 0xae, 0xd3, 0x70, 0xef, - 0x53, 0x9e, 0x5c, 0x9e, 0x81, 0xeb, 0x30, 0x1c, 0x24, 0x4e, 0xfd, 0x9e, 0xe2, 0xd9, 0x6b, 0x72, - 0x19, 0x79, 0xca, 0xc7, 0x84, 0xec, 0xff, 0xd7, 0x82, 0x41, 0xe1, 0x6c, 0x7a, 0x04, 0x9c, 0xe9, - 0x9c, 0xa1, 0x92, 0x29, 0x67, 0x4f, 0x0a, 0xeb, 0x4c, 0xae, 0x32, 0x66, 0x25, 0xa1, 0x8c, 0x79, - 0xbc, 0x13, 0x91, 0xce, 0x6a, 0x98, 0xff, 0xa4, 0x48, 0x5f, 0x08, 0x46, 0xd8, 0x83, 0x47, 0x3f, - 0x04, 0x6b, 0x30, 0x18, 0x0a, 0xb7, 0xfb, 0x42, 0xbe, 0x2f, 0x4f, 0x72, 0x12, 0x63, 0x1b, 0x48, - 0xe1, 0x68, 0x2f, 0x89, 0x64, 0xfa, 0xf3, 0x17, 0x1f, 0xa1, 0x3f, 0x7f, 0xb7, 0xc0, 0x10, 0x7d, - 0x0f, 0x23, 0x30, 0x84, 0xfd, 0x6d, 0x76, 0x3b, 0xeb, 0xe5, 0x47, 0xc0, 0xb8, 0x5d, 0x31, 0xef, - 0x71, 0xbb, 0xc3, 0xca, 0x12, 0x9d, 0xca, 0x61, 0xe0, 0x7e, 0xd5, 0x82, 0x33, 0x19, 0x5f, 0xa5, - 0x71, 0x73, 0xcf, 0xc3, 0x90, 0xd3, 0xae, 0xbb, 0x6a, 0x2f, 0x6b, 0xda, 0xe2, 0x39, 0x51, 0x8e, - 0x15, 0x06, 0x5a, 0x80, 0x29, 0x92, 0x0a, 0x71, 0xcb, 0x23, 0x64, 0x31, 0x0f, 0xe5, 0x74, 0x7c, - 0xdb, 0x34, 0xbe, 0x0a, 0x2e, 0x57, 0xcc, 0x0d, 0x2e, 0xf7, 0x4b, 0x16, 0x8c, 0x28, 0xc7, 0xf3, - 0x47, 0x3e, 0xda, 0x6f, 0x99, 0xa3, 0xfd, 0x58, 0x87, 0xd1, 0xce, 0x19, 0xe6, 0x3f, 0x29, 0xa8, - 0xfe, 0x56, 0xfc, 0x20, 0xea, 0x81, 0x4b, 0x7c, 0x70, 0xb7, 0x97, 0x4b, 0x30, 0xe2, 0xb4, 0x5a, - 0x12, 0x20, 0xed, 0x17, 0x59, 0x76, 0x92, 0xb8, 0x18, 0xeb, 0x38, 0xca, 0x0b, 0xa7, 0x98, 0xeb, - 0x85, 0x53, 0x07, 0x88, 0x9c, 0x60, 0x93, 0x44, 0xb4, 0x4c, 0x98, 0x5b, 0xe7, 0x9f, 0x37, 0xed, - 0xc8, 0x6d, 0xcc, 0xba, 0x5e, 0x14, 0x46, 0xc1, 0xec, 0x8a, 0x17, 0xdd, 0x08, 0xf8, 0x33, 0x55, - 0x0b, 0xe1, 0xa8, 0x68, 0x61, 0x8d, 0xae, 0x0c, 0xb2, 0xc2, 0xda, 0xe8, 0x37, 0x0d, 0x61, 0xd6, - 0x44, 0x39, 0x56, 0x18, 0xf6, 0xab, 0xec, 0xf6, 0x61, 0x63, 0x7a, 0xb8, 0xd0, 0x84, 0x7f, 0x35, - 0xaa, 0x66, 0x83, 0xa9, 0x84, 0x17, 0xf5, 0x00, 0x88, 0x9d, 0x0f, 0x7b, 0xda, 0xb0, 0xee, 0xcf, - 0x1a, 0x47, 0x49, 0x44, 0x9f, 0x4d, 0x19, 0x37, 0xbd, 0xd0, 0xe5, 0xd6, 0x38, 0x84, 0x39, 0x13, - 0x4b, 0x55, 0xc8, 0x12, 0xb9, 0xad, 0x54, 0xc4, 0xbe, 0xd0, 0x52, 0x15, 0x0a, 0x00, 0x8e, 0x71, - 0x28, 0xc3, 0xa6, 0xfe, 0x84, 0x25, 0x14, 0x47, 0xb4, 0x57, 0xd8, 0x21, 0xd6, 0x30, 0xd0, 0x45, - 0x21, 0xb4, 0xe0, 0xba, 0x87, 0xc7, 0x12, 0x42, 0x0b, 0x39, 0x5c, 0x9a, 0xa4, 0xe9, 0x12, 0x8c, - 0x90, 0x7b, 0x11, 0x09, 0x3c, 0xa7, 0x41, 0x5b, 0xe8, 0x8f, 0xe3, 0xf3, 0x2e, 0xc5, 0xc5, 0x58, - 0xc7, 0x41, 0xeb, 0x30, 0x11, 0x72, 0x59, 0x9e, 0xca, 0xa3, 0xc2, 0x65, 0xa2, 0xcf, 0x2a, 0x97, - 0x7f, 0x13, 0x7c, 0xc0, 0x8a, 0xf8, 0xe9, 0x24, 0x03, 0xa1, 0x24, 0x49, 0xa0, 0x37, 0x61, 0xbc, - 0xe1, 0x3b, 0xf5, 0x79, 0xa7, 0xe1, 0x78, 0x35, 0x36, 0x3e, 0x43, 0x46, 0x34, 0xcc, 0xf1, 0xeb, - 0x06, 0x14, 0x27, 0xb0, 0x29, 0x83, 0xa8, 0x97, 0x88, 0xdc, 0x3f, 0x8e, 0xb7, 0x49, 0xc2, 0xd2, - 0x30, 0xfb, 0x2a, 0xc6, 0x20, 0x5e, 0xcf, 0xc1, 0xc1, 0xb9, 0xb5, 0xd1, 0x65, 0x18, 0x95, 0x9f, - 0xaf, 0xc5, 0x0d, 0x8a, 0x1d, 0x9a, 0x34, 0x18, 0x36, 0x30, 0x51, 0x08, 0xc7, 0xe5, 0xff, 0xf5, - 0xc0, 0xd9, 0xd8, 0x70, 0x6b, 0x22, 0x98, 0x06, 0x77, 0xfe, 0xfe, 0x94, 0xf4, 0x34, 0x5d, 0xca, - 0x42, 0x3a, 0xd8, 0x2b, 0x9f, 0x16, 0xa3, 0x96, 0x09, 0xc7, 0xd9, 0xb4, 0xd1, 0x2a, 0x4c, 0x73, - 0x1b, 0x98, 0x85, 0x2d, 0x52, 0xdb, 0x96, 0x1b, 0x8e, 0x71, 0x8d, 0x9a, 0xe3, 0xcf, 0xd5, 0x34, - 0x0a, 0xce, 0xaa, 0x87, 0xde, 0x83, 0x52, 0xab, 0x7d, 0xa7, 0xe1, 0x86, 0x5b, 0x6b, 0x7e, 0xc4, - 0x4c, 0xc8, 0xe6, 0xea, 0xf5, 0x80, 0x84, 0xdc, 0x37, 0x98, 0x5d, 0xbd, 0x32, 0xd6, 0x53, 0x25, - 0x07, 0x0f, 0xe7, 0x52, 0x40, 0xf7, 0xe1, 0x78, 0x62, 0x21, 0x88, 0xa0, 0x2d, 0xe3, 0xf9, 0x59, - 0xd4, 0xaa, 0x59, 0x15, 0x44, 0xfc, 0xa3, 0x2c, 0x10, 0xce, 0x6e, 0x02, 0xbd, 0x06, 0xe0, 0xb6, - 0x96, 0x9d, 0xa6, 0xdb, 0xa0, 0xcf, 0xd1, 0x69, 0xb6, 0x46, 0xe8, 0xd3, 0x04, 0x56, 0x2a, 0xb2, - 0x94, 0x9e, 0xcd, 0xe2, 0xdf, 0x2e, 0xd6, 0xb0, 0xd1, 0x75, 0x18, 0x17, 0xff, 0x76, 0xc5, 0x94, - 0x4e, 0xa9, 0x84, 0xbb, 0xe3, 0xb2, 0x86, 0x9a, 0xc7, 0x44, 0x09, 0x4e, 0xd4, 0x45, 0x9b, 0x70, - 0x46, 0x66, 0xfb, 0xd5, 0xd7, 0xa7, 0x9c, 0x83, 0x90, 0xa5, 0x2e, 0x1b, 0xe2, 0x3e, 0x45, 0x73, - 0x9d, 0x10, 0x71, 0x67, 0x3a, 0xf4, 0x5e, 0xd7, 0x97, 0x39, 0xf7, 0x18, 0x3f, 0x1e, 0xc7, 0x14, - 0xbd, 0x9e, 0x04, 0xe2, 0x34, 0x3e, 0xf2, 0xe1, 0xb8, 0xeb, 0x65, 0xad, 0xea, 0x13, 0x8c, 0xd0, - 0x27, 0xb9, 0xb3, 0x7c, 0xe7, 0x15, 0x9d, 0x09, 0xc7, 0xd9, 0x74, 0xd1, 0x0a, 0x4c, 0x47, 0xbc, - 0x60, 0xd1, 0x0d, 0x79, 0x66, 0x24, 0xfa, 0xec, 0x3b, 0xc9, 0x9a, 0x3b, 0x49, 0x57, 0xf3, 0x7a, - 0x1a, 0x8c, 0xb3, 0xea, 0x7c, 0x30, 0x03, 0xd0, 0xef, 0x58, 0xb4, 0xb6, 0xc6, 0xe8, 0xa3, 0x2f, - 0xc0, 0xa8, 0x3e, 0x3e, 0x82, 0x69, 0x39, 0x9f, 0xcd, 0x07, 0x6b, 0xc7, 0x0b, 0x7f, 0x26, 0xa8, - 0x23, 0x44, 0x87, 0x61, 0x83, 0x22, 0xaa, 0x65, 0x04, 0xb9, 0xb8, 0xd8, 0x1b, 0x53, 0xd4, 0xbb, - 0xfd, 0x23, 0x81, 0xec, 0x9d, 0x83, 0xae, 0xc3, 0x50, 0xad, 0xe1, 0x12, 0x2f, 0x5a, 0xa9, 0x74, - 0x0a, 0xf5, 0xba, 0x20, 0x70, 0xc4, 0x56, 0x14, 0x09, 0xcd, 0x78, 0x19, 0x56, 0x14, 0xec, 0xcb, - 0x30, 0x52, 0x6d, 0x10, 0xd2, 0xe2, 0x7e, 0x5c, 0xe8, 0x19, 0xf6, 0x30, 0x61, 0xac, 0xa5, 0xc5, - 0x58, 0x4b, 0xfd, 0xcd, 0xc1, 0x98, 0x4a, 0x09, 0xb7, 0x7f, 0xaf, 0x00, 0xe5, 0x2e, 0x79, 0xf5, - 0x12, 0xfa, 0x36, 0xab, 0x27, 0x7d, 0xdb, 0x1c, 0x4c, 0xc4, 0xff, 0x74, 0x51, 0x9e, 0x32, 0x86, - 0xbe, 0x65, 0x82, 0x71, 0x12, 0xbf, 0x67, 0xbf, 0x16, 0x5d, 0x65, 0xd7, 0xd7, 0xd5, 0x33, 0xcb, - 0x50, 0xd5, 0xf7, 0xf7, 0xfe, 0xf6, 0xce, 0x55, 0xbb, 0xda, 0xdf, 0x2e, 0xc0, 0x71, 0x35, 0x84, - 0x3f, 0xbe, 0x03, 0x77, 0x33, 0x3d, 0x70, 0x0f, 0x41, 0x69, 0x6d, 0xdf, 0x80, 0x01, 0x1e, 0x7f, - 0xb6, 0x07, 0x9e, 0xff, 0x09, 0x33, 0x15, 0x80, 0x62, 0x33, 0x8d, 0x74, 0x00, 0xff, 0xc8, 0x82, - 0x89, 0x84, 0x83, 0x24, 0xc2, 0x9a, 0x17, 0xfd, 0x83, 0xf0, 0xe5, 0x59, 0x1c, 0xff, 0x39, 0xe8, - 0xdb, 0xf2, 0x95, 0x91, 0xb2, 0xc2, 0xb8, 0xea, 0x87, 0x11, 0x66, 0x10, 0xfb, 0xcf, 0x2c, 0xe8, - 0x5f, 0x77, 0x5c, 0x2f, 0x92, 0xda, 0x0f, 0x2b, 0x47, 0xfb, 0xd1, 0xcb, 0x77, 0xa1, 0x57, 0x60, - 0x80, 0x6c, 0x6c, 0x90, 0x5a, 0x24, 0x66, 0x55, 0x46, 0xd3, 0x18, 0x58, 0x62, 0xa5, 0x94, 0x09, - 0x65, 0x8d, 0xf1, 0xbf, 0x58, 0x20, 0xa3, 0xdb, 0x30, 0x1c, 0xb9, 0x4d, 0x32, 0x57, 0xaf, 0x0b, - 0x9b, 0x80, 0x07, 0x08, 0x01, 0xb3, 0x2e, 0x09, 0xe0, 0x98, 0x96, 0xfd, 0xf5, 0x02, 0x40, 0x1c, - 0xef, 0xae, 0xdb, 0x27, 0xce, 0xa7, 0xb4, 0xc5, 0xe7, 0x33, 0xb4, 0xc5, 0x28, 0x26, 0x98, 0xa1, - 0x2a, 0x56, 0xc3, 0x54, 0xec, 0x69, 0x98, 0xfa, 0x0e, 0x33, 0x4c, 0x0b, 0x30, 0x15, 0xc7, 0xeb, - 0x33, 0xc3, 0x95, 0xb2, 0xfb, 0x7b, 0x3d, 0x09, 0xc4, 0x69, 0x7c, 0x9b, 0xc0, 0x39, 0x15, 0xb6, - 0x4c, 0xdc, 0x85, 0xcc, 0x95, 0x40, 0xd7, 0xbe, 0x77, 0x19, 0xa7, 0x58, 0x1d, 0x5e, 0xc8, 0x55, - 0x87, 0xff, 0x2b, 0x0b, 0x8e, 0x25, 0xdb, 0x61, 0x7e, 0xf7, 0x5f, 0xb5, 0xe0, 0x78, 0x9c, 0x56, - 0x2a, 0x6d, 0x82, 0xf0, 0x72, 0xc7, 0x50, 0x6c, 0x39, 0x3d, 0x8e, 0xc3, 0xb6, 0xac, 0x66, 0x91, - 0xc6, 0xd9, 0x2d, 0xda, 0xff, 0x4f, 0x1f, 0x94, 0xf2, 0x62, 0xb8, 0x31, 0x4f, 0x23, 0xe7, 0x5e, - 0x75, 0x9b, 0xdc, 0x15, 0xfe, 0x1c, 0xb1, 0xa7, 0x11, 0x2f, 0xc6, 0x12, 0x9e, 0xcc, 0x24, 0x56, - 0xe8, 0x31, 0x93, 0xd8, 0x16, 0x4c, 0xdd, 0xdd, 0x22, 0xde, 0x4d, 0x2f, 0x74, 0x22, 0x37, 0xdc, - 0x70, 0x99, 0x02, 0x9d, 0xaf, 0x9b, 0xd7, 0xa4, 0xd7, 0xc5, 0xed, 0x24, 0xc2, 0xc1, 0x5e, 0xf9, - 0x8c, 0x51, 0x10, 0x77, 0x99, 0x1f, 0x24, 0x38, 0x4d, 0x34, 0x9d, 0x88, 0xad, 0xef, 0x11, 0x27, - 0x62, 0x6b, 0xba, 0xc2, 0xec, 0x46, 0xba, 0x91, 0xb0, 0x67, 0xeb, 0xaa, 0x2a, 0xc5, 0x1a, 0x06, - 0xfa, 0x1c, 0x20, 0x3d, 0x93, 0xa6, 0x11, 0x42, 0xf7, 0x85, 0xfd, 0xbd, 0x32, 0x5a, 0x4b, 0x41, - 0x0f, 0xf6, 0xca, 0xd3, 0xb4, 0x74, 0xc5, 0xa3, 0xcf, 0xdf, 0x38, 0xee, 0x60, 0x06, 0x21, 0x74, - 0x1b, 0x26, 0x69, 0x29, 0xdb, 0x51, 0x32, 0x3e, 0x2f, 0x7f, 0xb2, 0x3e, 0xb7, 0xbf, 0x57, 0x9e, - 0x5c, 0x4b, 0xc0, 0xf2, 0x48, 0xa7, 0x88, 0x64, 0xe4, 0x63, 0x1b, 0xea, 0x35, 0x1f, 0x9b, 0xfd, - 0x55, 0x0b, 0x4e, 0xd1, 0x0b, 0xae, 0x7e, 0x3d, 0x47, 0x8b, 0xee, 0xb4, 0x5c, 0xae, 0xa7, 0x11, - 0x57, 0x0d, 0x93, 0xd5, 0x55, 0x56, 0xb8, 0x96, 0x46, 0x41, 0xe9, 0x09, 0xbf, 0xed, 0x7a, 0xf5, - 0xe4, 0x09, 0x7f, 0xcd, 0xf5, 0xea, 0x98, 0x41, 0xd4, 0x95, 0x55, 0xcc, 0x8d, 0xf7, 0xff, 0x2d, - 0xba, 0x57, 0x69, 0x5f, 0x7e, 0xa8, 0xdd, 0x40, 0xcf, 0xe9, 0x3a, 0x55, 0x61, 0x3e, 0x99, 0xab, - 0x4f, 0xfd, 0x8a, 0x05, 0xc2, 0xfb, 0xbd, 0x87, 0x3b, 0xf9, 0x5d, 0x18, 0xdd, 0x49, 0x67, 0x19, - 0x3e, 0x97, 0x1f, 0x0e, 0x40, 0xe4, 0x16, 0x56, 0x2c, 0xba, 0x91, 0x51, 0xd8, 0xa0, 0x65, 0xd7, - 0x41, 0x40, 0x17, 0x09, 0xd3, 0x6a, 0x74, 0xef, 0xcd, 0x8b, 0x00, 0x75, 0x86, 0xcb, 0xf2, 0x6d, - 0x15, 0x4c, 0x8e, 0x6b, 0x51, 0x41, 0xb0, 0x86, 0x65, 0xff, 0x42, 0x11, 0x46, 0x64, 0x56, 0xdb, - 0xb6, 0xd7, 0x8b, 0xec, 0x51, 0x67, 0x9c, 0x0a, 0x5d, 0x19, 0xa7, 0xf7, 0x60, 0x2a, 0x20, 0xb5, - 0x76, 0x10, 0xba, 0x3b, 0x44, 0x82, 0xc5, 0x26, 0x99, 0xe5, 0xe9, 0x26, 0x12, 0xc0, 0x03, 0x16, - 0x22, 0x2b, 0x51, 0xc8, 0x94, 0xc6, 0x69, 0x42, 0xe8, 0x22, 0x0c, 0x33, 0xd1, 0x7b, 0x25, 0x16, - 0x08, 0x2b, 0xc1, 0xd7, 0xaa, 0x04, 0xe0, 0x18, 0x87, 0x3d, 0x0e, 0xda, 0x77, 0xb4, 0x64, 0x68, - 0xf1, 0xe3, 0x80, 0x17, 0x63, 0x09, 0x47, 0x9f, 0x86, 0x49, 0x5e, 0x2f, 0xf0, 0x5b, 0xce, 0x26, - 0x57, 0x09, 0xf6, 0xab, 0xf0, 0x3a, 0x93, 0xab, 0x09, 0xd8, 0xc1, 0x5e, 0xf9, 0x58, 0xb2, 0x8c, - 0x75, 0x3b, 0x45, 0x85, 0x59, 0xfe, 0xf1, 0x46, 0xe8, 0x9d, 0x91, 0x32, 0x18, 0x8c, 0x41, 0x58, - 0xc7, 0xb3, 0xff, 0xd6, 0x82, 0x29, 0x6d, 0xaa, 0x7a, 0xce, 0xf8, 0x61, 0x0c, 0x52, 0xa1, 0x87, - 0x41, 0x3a, 0x5c, 0xb4, 0x87, 0xcc, 0x19, 0xee, 0x7b, 0x48, 0x33, 0x6c, 0x7f, 0x01, 0x50, 0x3a, - 0x65, 0x32, 0x7a, 0x9b, 0x1b, 0xf2, 0xbb, 0x01, 0xa9, 0x77, 0x52, 0xf8, 0xeb, 0x91, 0x73, 0xa4, - 0xe7, 0x2a, 0xaf, 0x85, 0x55, 0x7d, 0xfb, 0x6f, 0xfb, 0x60, 0x32, 0x19, 0xab, 0x03, 0x5d, 0x85, - 0x01, 0xce, 0xa5, 0x0b, 0xf2, 0x1d, 0xec, 0xc9, 0xb4, 0x08, 0x1f, 0x3c, 0x1b, 0x0f, 0xe7, 0xee, - 0x45, 0x7d, 0xf4, 0x1e, 0x8c, 0xd4, 0xfd, 0xbb, 0xde, 0x5d, 0x27, 0xa8, 0xcf, 0x55, 0x56, 0xc4, - 0x09, 0x91, 0x29, 0x80, 0x5a, 0x8c, 0xd1, 0xf4, 0xa8, 0x21, 0xcc, 0x76, 0x22, 0x06, 0x61, 0x9d, - 0x1c, 0x5a, 0x67, 0x09, 0xa2, 0x36, 0xdc, 0xcd, 0x55, 0xa7, 0xd5, 0xc9, 0xab, 0x6b, 0x41, 0x22, - 0x69, 0x94, 0xc7, 0x44, 0x16, 0x29, 0x0e, 0xc0, 0x31, 0x21, 0xf4, 0x25, 0x98, 0x0e, 0x73, 0x54, - 0x62, 0x79, 0x19, 0xf4, 0x3b, 0x69, 0x89, 0xb8, 0x30, 0x25, 0x4b, 0x79, 0x96, 0xd5, 0x0c, 0xba, - 0x07, 0x48, 0x88, 0x9e, 0xd7, 0x83, 0x76, 0x18, 0xf1, 0x2c, 0x84, 0xe2, 0xd1, 0xf5, 0xf1, 0x6c, - 0x39, 0x41, 0x12, 0x5b, 0x6b, 0x9b, 0x05, 0x28, 0x4e, 0x63, 0xe0, 0x8c, 0x36, 0xd0, 0x16, 0x8c, - 0xb7, 0x8c, 0x04, 0x90, 0x6c, 0x6f, 0xe6, 0x44, 0xf1, 0xcd, 0x4b, 0x15, 0xc9, 0x6f, 0x69, 0x13, - 0x8a, 0x13, 0x74, 0xed, 0xaf, 0xf4, 0xc1, 0x8c, 0xcc, 0x86, 0x9e, 0xe1, 0x27, 0xf3, 0x65, 0x2b, - 0xe1, 0x28, 0xf3, 0x5a, 0xfe, 0x95, 0xf2, 0xc8, 0xdc, 0x65, 0xbe, 0x96, 0x76, 0x97, 0x79, 0xe3, - 0x90, 0xdd, 0x78, 0x68, 0x4e, 0x33, 0x3f, 0xb6, 0x9e, 0x2e, 0xfb, 0xc7, 0xc0, 0x60, 0x02, 0x10, - 0xe6, 0x71, 0xe6, 0x2b, 0x52, 0x49, 0x95, 0x23, 0x68, 0xb8, 0x2a, 0x70, 0x0c, 0xb6, 0x62, 0x54, - 0x46, 0xa3, 0x67, 0x27, 0xba, 0xa2, 0x43, 0x69, 0x92, 0x66, 0x2b, 0xda, 0x5d, 0x74, 0x03, 0xd1, - 0xe3, 0x4c, 0x9a, 0x4b, 0x02, 0x27, 0x4d, 0x53, 0x42, 0xb0, 0xa2, 0x83, 0x76, 0x60, 0x6a, 0x93, - 0xc5, 0x96, 0xd2, 0x12, 0x93, 0x8b, 0x13, 0x28, 0xf3, 0x84, 0xb8, 0xb2, 0xb0, 0x94, 0x9f, 0xc5, - 0x9c, 0x3f, 0x33, 0x53, 0x28, 0x38, 0xdd, 0x04, 0xdd, 0x1a, 0xc7, 0x9c, 0xbb, 0xe1, 0x52, 0xc3, - 0x09, 0x23, 0xb7, 0x36, 0xdf, 0xf0, 0x6b, 0xdb, 0xd5, 0xc8, 0x0f, 0x64, 0x62, 0xcb, 0xcc, 0x57, - 0xde, 0xdc, 0xed, 0x6a, 0x0a, 0xdf, 0x68, 0x9e, 0x25, 0x58, 0xcd, 0xc2, 0xc2, 0x99, 0x6d, 0xa1, - 0x35, 0x18, 0xdc, 0x74, 0x23, 0x4c, 0x5a, 0xbe, 0x38, 0x97, 0x32, 0x0f, 0xdd, 0x2b, 0x1c, 0xc5, - 0x68, 0x89, 0xc5, 0xbe, 0x12, 0x00, 0x2c, 0x89, 0xa0, 0xb7, 0xd5, 0x75, 0x33, 0x90, 0x2f, 0xea, - 0x4d, 0x5b, 0xf9, 0x65, 0x5e, 0x38, 0x6f, 0x42, 0xd1, 0xdb, 0x08, 0x3b, 0x45, 0xfd, 0x59, 0x5b, - 0x36, 0x24, 0x75, 0xf3, 0x83, 0xf4, 0x11, 0xbe, 0xb6, 0x5c, 0xc5, 0xb4, 0x22, 0x73, 0xb0, 0x0d, - 0x6b, 0xa1, 0x2b, 0x92, 0x64, 0x65, 0xfa, 0x1b, 0xaf, 0x54, 0x17, 0xaa, 0x2b, 0x06, 0x0d, 0x16, - 0x3f, 0x91, 0x15, 0x63, 0x5e, 0x1d, 0xdd, 0x82, 0xe1, 0x4d, 0x7e, 0xc4, 0x6e, 0xf0, 0xf0, 0xb1, - 0x39, 0xd7, 0xde, 0x15, 0x89, 0x64, 0xd0, 0x63, 0x97, 0x93, 0x02, 0xe1, 0x98, 0x14, 0xfa, 0x8a, - 0x05, 0xc7, 0x5b, 0x09, 0x59, 0x2d, 0x73, 0x8b, 0x13, 0x06, 0x71, 0x99, 0xae, 0x06, 0x95, 0xac, - 0x0a, 0x46, 0x83, 0x4c, 0xd1, 0x93, 0x89, 0x86, 0xb3, 0x9b, 0xa3, 0x03, 0x1d, 0xdc, 0xa9, 0x77, - 0xca, 0xab, 0x94, 0x08, 0x81, 0xc4, 0x07, 0x1a, 0xcf, 0x2f, 0x62, 0x5a, 0x11, 0xad, 0x03, 0x6c, - 0x34, 0x88, 0x88, 0x2d, 0x29, 0xcc, 0xaf, 0x32, 0xf9, 0x8c, 0x65, 0x85, 0x25, 0xe8, 0xb0, 0x37, - 0x6f, 0x5c, 0x8a, 0x35, 0x3a, 0x74, 0x29, 0xd5, 0x5c, 0xaf, 0x4e, 0x02, 0xa6, 0x46, 0xcb, 0x59, - 0x4a, 0x0b, 0x0c, 0x23, 0xbd, 0x94, 0x78, 0x39, 0x16, 0x14, 0x18, 0x2d, 0xd2, 0xda, 0xda, 0x08, - 0x3b, 0x65, 0xf0, 0x58, 0x20, 0xad, 0xad, 0xc4, 0x82, 0xe2, 0xb4, 0x58, 0x39, 0x16, 0x14, 0xe8, - 0x96, 0xd9, 0xa0, 0x1b, 0x88, 0x04, 0xa5, 0x89, 0xfc, 0x2d, 0xb3, 0xcc, 0x51, 0xd2, 0x5b, 0x46, - 0x00, 0xb0, 0x24, 0x82, 0x3e, 0x6f, 0xf2, 0x55, 0x93, 0x8c, 0xe6, 0x73, 0x5d, 0xf8, 0x2a, 0x83, - 0x6e, 0x67, 0xce, 0xea, 0x35, 0x28, 0x6c, 0xd4, 0x98, 0xfa, 0x2d, 0x47, 0x3b, 0xb1, 0xbc, 0x60, - 0x50, 0x63, 0x11, 0xf1, 0x97, 0x17, 0x70, 0x61, 0xa3, 0x46, 0x97, 0xbe, 0x73, 0xbf, 0x1d, 0x90, - 0x65, 0xb7, 0x41, 0x44, 0x36, 0x8f, 0xcc, 0xa5, 0x3f, 0x27, 0x91, 0xd2, 0x4b, 0x5f, 0x81, 0x70, - 0x4c, 0x8a, 0xd2, 0x8d, 0xb9, 0xbd, 0xe9, 0x7c, 0xba, 0x8a, 0xa9, 0x4b, 0xd3, 0xcd, 0xe4, 0xf7, - 0xb6, 0x61, 0x6c, 0x27, 0x6c, 0x6d, 0x11, 0x79, 0x2a, 0x32, 0xc5, 0x60, 0x4e, 0x4c, 0x8c, 0x5b, - 0x02, 0xd1, 0x0d, 0xa2, 0xb6, 0xd3, 0x48, 0x1d, 0xe4, 0x4c, 0x88, 0x73, 0x4b, 0x27, 0x86, 0x4d, - 0xda, 0x74, 0x21, 0xbc, 0xcf, 0x03, 0xd7, 0x31, 0x15, 0x61, 0xce, 0x42, 0xc8, 0x88, 0x6d, 0xc7, - 0x17, 0x82, 0x00, 0x60, 0x49, 0x44, 0x0d, 0x36, 0xbb, 0x80, 0x4e, 0x74, 0x19, 0xec, 0x54, 0x7f, - 0xe3, 0xc1, 0x66, 0x17, 0x4e, 0x4c, 0x8a, 0x5d, 0x34, 0xad, 0x2d, 0x3f, 0xf2, 0xbd, 0xc4, 0x25, - 0x77, 0x32, 0xff, 0xa2, 0xa9, 0x64, 0xe0, 0xa7, 0x2f, 0x9a, 0x2c, 0x2c, 0x9c, 0xd9, 0x16, 0xfd, - 0xb8, 0x96, 0x8c, 0x41, 0x28, 0x32, 0x8e, 0x3c, 0x93, 0x13, 0xc2, 0x33, 0x1d, 0xa8, 0x90, 0x7f, - 0x9c, 0x02, 0xe1, 0x98, 0x14, 0xaa, 0x53, 0x4e, 0x57, 0x8f, 0x6d, 0xcb, 0x32, 0xa7, 0xe4, 0xf0, - 0x05, 0x59, 0x51, 0x70, 0x25, 0x97, 0xab, 0x43, 0x70, 0x82, 0x26, 0xb3, 0x11, 0xe4, 0x4e, 0x85, - 0x2c, 0xb1, 0x4a, 0xce, 0x54, 0x67, 0xf8, 0x1d, 0xf2, 0xa9, 0x16, 0x00, 0x2c, 0x89, 0xd0, 0xd1, - 0x10, 0xae, 0x70, 0x7e, 0xc8, 0xf2, 0x13, 0xe5, 0xa9, 0xf2, 0xb3, 0x14, 0x52, 0x32, 0xa0, 0xbb, - 0x00, 0xe1, 0x98, 0x14, 0x3d, 0xc9, 0xe9, 0x85, 0x77, 0x3a, 0xff, 0x24, 0x4f, 0x5e, 0x77, 0xec, - 0x24, 0xa7, 0x97, 0x5d, 0x51, 0x5c, 0x75, 0x2a, 0xfe, 0x38, 0xcb, 0xad, 0x92, 0xd3, 0x2f, 0x15, - 0xc0, 0x3c, 0xdd, 0x2f, 0x05, 0xc2, 0x31, 0x29, 0x76, 0x15, 0xb3, 0x20, 0x78, 0x67, 0x3b, 0x5c, - 0xc5, 0x14, 0x21, 0xe3, 0x2a, 0xd6, 0x82, 0xe4, 0xd9, 0xff, 0xb8, 0x00, 0x67, 0x3b, 0xef, 0xdb, - 0x58, 0x5b, 0x57, 0x89, 0xad, 0xa3, 0x12, 0xda, 0x3a, 0x2e, 0x3b, 0x8a, 0xb1, 0x7a, 0x0e, 0x6d, - 0x7c, 0x05, 0xa6, 0x94, 0xe3, 0x63, 0xc3, 0xad, 0xed, 0x6a, 0x09, 0x55, 0x55, 0x10, 0xa0, 0x6a, - 0x12, 0x01, 0xa7, 0xeb, 0xa0, 0x39, 0x98, 0x30, 0x0a, 0x57, 0x16, 0x85, 0xa0, 0x21, 0xce, 0x0a, - 0x62, 0x82, 0x71, 0x12, 0xdf, 0xfe, 0x45, 0x0b, 0x4e, 0xf2, 0x40, 0xbc, 0xa4, 0x5e, 0xf1, 0xeb, - 0x52, 0xa2, 0x70, 0xa8, 0xc8, 0xbd, 0x1b, 0x30, 0xd1, 0x32, 0xab, 0x76, 0x09, 0x36, 0xae, 0xa3, - 0xc6, 0x7d, 0x4d, 0x00, 0x70, 0x92, 0xa8, 0xfd, 0xf3, 0x05, 0x38, 0xd3, 0xd1, 0x92, 0x1f, 0x61, - 0x38, 0xb1, 0xd9, 0x0c, 0x9d, 0x38, 0x91, 0x7f, 0xb5, 0x45, 0x6a, 0x9a, 0xbe, 0x95, 0x99, 0xc4, - 0x5f, 0x59, 0xad, 0xce, 0xa5, 0x31, 0x70, 0x4e, 0x4d, 0xb4, 0x0c, 0x28, 0x0d, 0x11, 0x33, 0xcc, - 0x1e, 0xd3, 0x69, 0x7a, 0x38, 0xa3, 0x06, 0x7a, 0x15, 0xc6, 0x94, 0x87, 0x80, 0x36, 0xe3, 0xec, - 0x82, 0xc0, 0x3a, 0x00, 0x9b, 0x78, 0xe8, 0x12, 0x4f, 0x17, 0x25, 0x12, 0x8b, 0x09, 0xe5, 0xec, - 0x84, 0xcc, 0x05, 0x25, 0x8a, 0xb1, 0x8e, 0x33, 0x7f, 0xf9, 0x0f, 0xbe, 0x77, 0xf6, 0x63, 0x7f, - 0xf4, 0xbd, 0xb3, 0x1f, 0xfb, 0xd3, 0xef, 0x9d, 0xfd, 0xd8, 0x4f, 0xed, 0x9f, 0xb5, 0xfe, 0x60, - 0xff, 0xac, 0xf5, 0x47, 0xfb, 0x67, 0xad, 0x3f, 0xdd, 0x3f, 0x6b, 0xfd, 0x6f, 0xfb, 0x67, 0xad, - 0xaf, 0xff, 0xef, 0x67, 0x3f, 0xf6, 0x2e, 0x8a, 0x63, 0x61, 0x5f, 0xa4, 0xb3, 0x73, 0x71, 0xe7, - 0xd2, 0xbf, 0x0f, 0x00, 0x00, 0xff, 0xff, 0x92, 0x1b, 0xe7, 0xc0, 0x7a, 0x29, 0x01, 0x00, + // 16534 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0xbd, 0x5b, 0x90, 0x5c, 0xc9, + 0x75, 0x20, 0xc6, 0x5b, 0xd5, 0xcf, 0xd3, 0xef, 0x6c, 0x3c, 0x0a, 0x3d, 0x00, 0x0a, 0x73, 0x67, + 0x06, 0x83, 0x79, 0x35, 0x88, 0x79, 0x70, 0xc0, 0x99, 0xe1, 0x68, 0xfa, 0x09, 0xf4, 0x00, 0xdd, + 0xa8, 0xc9, 0x6a, 0x00, 0xe4, 0x70, 0xc8, 0xe5, 0x45, 0x55, 0x76, 0xf7, 0x65, 0x57, 0xdd, 0x5b, + 0x73, 0xef, 0xad, 0x06, 0x1a, 0xe6, 0x86, 0xb4, 0x5c, 0x8b, 0xbb, 0xa4, 0xe4, 0x08, 0xc6, 0x86, + 0x77, 0xd7, 0x41, 0x6d, 0xe8, 0x63, 0x5f, 0x92, 0x4c, 0xef, 0x5a, 0x5c, 0xc9, 0x2b, 0x59, 0xd4, + 0xcb, 0xb6, 0x1c, 0x21, 0xfb, 0x43, 0x96, 0x14, 0x61, 0x52, 0x61, 0x85, 0x5b, 0x66, 0xdb, 0x0a, + 0x05, 0x3f, 0x2c, 0x29, 0x64, 0x7f, 0xd8, 0x1d, 0xb2, 0xb9, 0x91, 0xcf, 0x9b, 0x79, 0x1f, 0x55, + 0xd5, 0x18, 0xa0, 0x39, 0x64, 0xcc, 0x5f, 0x55, 0x9e, 0x93, 0x27, 0xf3, 0xe6, 0xe3, 0xe4, 0xc9, + 0x73, 0x4e, 0x9e, 0x03, 0xf6, 0xf6, 0xe5, 0x70, 0xd6, 0xf5, 0x2f, 0x3a, 0x2d, 0xf7, 0x62, 0xcd, + 0x0f, 0xc8, 0xc5, 0x9d, 0x4b, 0x17, 0x37, 0x89, 0x47, 0x02, 0x27, 0x22, 0xf5, 0xd9, 0x56, 0xe0, + 0x47, 0x3e, 0x42, 0x1c, 0x67, 0xd6, 0x69, 0xb9, 0xb3, 0x14, 0x67, 0x76, 0xe7, 0xd2, 0xcc, 0x0b, + 0x9b, 0x6e, 0xb4, 0xd5, 0xbe, 0x33, 0x5b, 0xf3, 0x9b, 0x17, 0x37, 0xfd, 0x4d, 0xff, 0x22, 0x43, + 0xbd, 0xd3, 0xde, 0x60, 0xff, 0xd8, 0x1f, 0xf6, 0x8b, 0x93, 0x98, 0x79, 0x39, 0x6e, 0xa6, 0xe9, + 0xd4, 0xb6, 0x5c, 0x8f, 0x04, 0xbb, 0x17, 0x5b, 0xdb, 0x9b, 0xac, 0xdd, 0x80, 0x84, 0x7e, 0x3b, + 0xa8, 0x91, 0x64, 0xc3, 0x1d, 0x6b, 0x85, 0x17, 0x9b, 0x24, 0x72, 0x32, 0xba, 0x3b, 0x73, 0x31, + 0xaf, 0x56, 0xd0, 0xf6, 0x22, 0xb7, 0x99, 0x6e, 0xe6, 0x13, 0xdd, 0x2a, 0x84, 0xb5, 0x2d, 0xd2, + 0x74, 0x52, 0xf5, 0x5e, 0xca, 0xab, 0xd7, 0x8e, 0xdc, 0xc6, 0x45, 0xd7, 0x8b, 0xc2, 0x28, 0x48, + 0x56, 0xb2, 0xbf, 0x6b, 0xc1, 0xb9, 0xb9, 0xdb, 0xd5, 0xa5, 0x86, 0x13, 0x46, 0x6e, 0x6d, 0xbe, + 0xe1, 0xd7, 0xb6, 0xab, 0x91, 0x1f, 0x90, 0x5b, 0x7e, 0xa3, 0xdd, 0x24, 0x55, 0x36, 0x10, 0xe8, + 0x79, 0x18, 0xda, 0x61, 0xff, 0x57, 0x16, 0x4b, 0xd6, 0x39, 0xeb, 0xc2, 0xf0, 0xfc, 0xe4, 0xef, + 0xef, 0x95, 0x3f, 0xb6, 0xbf, 0x57, 0x1e, 0xba, 0x25, 0xca, 0xb1, 0xc2, 0x40, 0xe7, 0x61, 0x60, + 0x23, 0x5c, 0xdf, 0x6d, 0x91, 0x52, 0x81, 0xe1, 0x8e, 0x0b, 0xdc, 0x81, 0xe5, 0x2a, 0x2d, 0xc5, + 0x02, 0x8a, 0x2e, 0xc2, 0x70, 0xcb, 0x09, 0x22, 0x37, 0x72, 0x7d, 0xaf, 0x54, 0x3c, 0x67, 0x5d, + 0xe8, 0x9f, 0x9f, 0x12, 0xa8, 0xc3, 0x15, 0x09, 0xc0, 0x31, 0x0e, 0xed, 0x46, 0x40, 0x9c, 0xfa, + 0x0d, 0xaf, 0xb1, 0x5b, 0xea, 0x3b, 0x67, 0x5d, 0x18, 0x8a, 0xbb, 0x81, 0x45, 0x39, 0x56, 0x18, + 0xf6, 0x37, 0x0a, 0x30, 0x34, 0xb7, 0xb1, 0xe1, 0x7a, 0x6e, 0xb4, 0x8b, 0x6e, 0xc1, 0xa8, 0xe7, + 0xd7, 0x89, 0xfc, 0xcf, 0xbe, 0x62, 0xe4, 0xc5, 0x73, 0xb3, 0xe9, 0xa5, 0x34, 0xbb, 0xa6, 0xe1, + 0xcd, 0x4f, 0xee, 0xef, 0x95, 0x47, 0xf5, 0x12, 0x6c, 0xd0, 0x41, 0x18, 0x46, 0x5a, 0x7e, 0x5d, + 0x91, 0x2d, 0x30, 0xb2, 0xe5, 0x2c, 0xb2, 0x95, 0x18, 0x6d, 0x7e, 0x62, 0x7f, 0xaf, 0x3c, 0xa2, + 0x15, 0x60, 0x9d, 0x08, 0xba, 0x03, 0x13, 0xf4, 0xaf, 0x17, 0xb9, 0x8a, 0x6e, 0x91, 0xd1, 0x7d, + 0x22, 0x8f, 0xae, 0x86, 0x3a, 0x3f, 0xbd, 0xbf, 0x57, 0x9e, 0x48, 0x14, 0xe2, 0x24, 0x41, 0xfb, + 0x67, 0x2d, 0x98, 0x98, 0x6b, 0xb5, 0xe6, 0x82, 0xa6, 0x1f, 0x54, 0x02, 0x7f, 0xc3, 0x6d, 0x10, + 0xf4, 0x2a, 0xf4, 0x45, 0x74, 0xd6, 0xf8, 0x0c, 0x3f, 0x21, 0x86, 0xb6, 0x8f, 0xce, 0xd5, 0xc1, + 0x5e, 0x79, 0x3a, 0x81, 0xce, 0xa6, 0x92, 0x55, 0x40, 0x6f, 0xc1, 0x64, 0xc3, 0xaf, 0x39, 0x8d, + 0x2d, 0x3f, 0x8c, 0x04, 0x54, 0x4c, 0xfd, 0xb1, 0xfd, 0xbd, 0xf2, 0xe4, 0xf5, 0x04, 0x0c, 0xa7, + 0xb0, 0xed, 0xfb, 0x30, 0x3e, 0x17, 0x45, 0x4e, 0x6d, 0x8b, 0xd4, 0xf9, 0x82, 0x42, 0x2f, 0x43, + 0x9f, 0xe7, 0x34, 0x65, 0x67, 0xce, 0xc9, 0xce, 0xac, 0x39, 0x4d, 0xda, 0x99, 0xc9, 0x9b, 0x9e, + 0xfb, 0x7e, 0x5b, 0x2c, 0x52, 0x5a, 0x86, 0x19, 0x36, 0x7a, 0x11, 0xa0, 0x4e, 0x76, 0xdc, 0x1a, + 0xa9, 0x38, 0xd1, 0x96, 0xe8, 0x03, 0x12, 0x75, 0x61, 0x51, 0x41, 0xb0, 0x86, 0x65, 0xdf, 0x83, + 0xe1, 0xb9, 0x1d, 0xdf, 0xad, 0x57, 0xfc, 0x7a, 0x88, 0xb6, 0x61, 0xa2, 0x15, 0x90, 0x0d, 0x12, + 0xa8, 0xa2, 0x92, 0x75, 0xae, 0x78, 0x61, 0xe4, 0xc5, 0x0b, 0x99, 0x63, 0x6f, 0xa2, 0x2e, 0x79, + 0x51, 0xb0, 0x3b, 0x7f, 0x52, 0xb4, 0x37, 0x91, 0x80, 0xe2, 0x24, 0x65, 0xfb, 0xf7, 0x0a, 0x70, + 0x7c, 0xee, 0x7e, 0x3b, 0x20, 0x8b, 0x6e, 0xb8, 0x9d, 0xdc, 0x70, 0x75, 0x37, 0xdc, 0x5e, 0x8b, + 0x47, 0x40, 0xad, 0xf4, 0x45, 0x51, 0x8e, 0x15, 0x06, 0x7a, 0x01, 0x06, 0xe9, 0xef, 0x9b, 0x78, + 0x45, 0x7c, 0xf2, 0xb4, 0x40, 0x1e, 0x59, 0x74, 0x22, 0x67, 0x91, 0x83, 0xb0, 0xc4, 0x41, 0xab, + 0x30, 0x52, 0x63, 0xfc, 0x61, 0x73, 0xd5, 0xaf, 0x13, 0xb6, 0xb6, 0x86, 0xe7, 0x9f, 0xa3, 0xe8, + 0x0b, 0x71, 0xf1, 0xc1, 0x5e, 0xb9, 0xc4, 0xfb, 0x26, 0x48, 0x68, 0x30, 0xac, 0xd7, 0x47, 0xb6, + 0xda, 0xee, 0x7d, 0x8c, 0x12, 0x64, 0x6c, 0xf5, 0x0b, 0xda, 0xce, 0xed, 0x67, 0x3b, 0x77, 0x34, + 0x7b, 0xd7, 0xa2, 0x4b, 0xd0, 0xb7, 0xed, 0x7a, 0xf5, 0xd2, 0x00, 0xa3, 0x75, 0x86, 0xce, 0xf9, + 0x35, 0xd7, 0xab, 0x1f, 0xec, 0x95, 0xa7, 0x8c, 0xee, 0xd0, 0x42, 0xcc, 0x50, 0xed, 0xff, 0xcb, + 0x82, 0x32, 0x83, 0x2d, 0xbb, 0x0d, 0x52, 0x21, 0x41, 0xe8, 0x86, 0x11, 0xf1, 0x22, 0x63, 0x40, + 0x5f, 0x04, 0x08, 0x49, 0x2d, 0x20, 0x91, 0x36, 0xa4, 0x6a, 0x61, 0x54, 0x15, 0x04, 0x6b, 0x58, + 0x94, 0x3f, 0x85, 0x5b, 0x4e, 0xc0, 0xd6, 0x97, 0x18, 0x58, 0xc5, 0x9f, 0xaa, 0x12, 0x80, 0x63, + 0x1c, 0x83, 0x3f, 0x15, 0xbb, 0xf1, 0x27, 0xf4, 0x29, 0x98, 0x88, 0x1b, 0x0b, 0x5b, 0x4e, 0x4d, + 0x0e, 0x20, 0xdb, 0xc1, 0x55, 0x13, 0x84, 0x93, 0xb8, 0xf6, 0x7f, 0x6e, 0x89, 0xc5, 0x43, 0xbf, + 0xfa, 0x43, 0xfe, 0xad, 0xf6, 0xaf, 0x5b, 0x30, 0x38, 0xef, 0x7a, 0x75, 0xd7, 0xdb, 0x44, 0x5f, + 0x80, 0x21, 0x7a, 0x54, 0xd6, 0x9d, 0xc8, 0x11, 0x6c, 0xf8, 0xe3, 0xda, 0xde, 0x52, 0x27, 0xd7, + 0x6c, 0x6b, 0x7b, 0x93, 0x16, 0x84, 0xb3, 0x14, 0x9b, 0xee, 0xb6, 0x1b, 0x77, 0xbe, 0x48, 0x6a, + 0xd1, 0x2a, 0x89, 0x9c, 0xf8, 0x73, 0xe2, 0x32, 0xac, 0xa8, 0xa2, 0x6b, 0x30, 0x10, 0x39, 0xc1, + 0x26, 0x89, 0x04, 0x3f, 0xce, 0xe4, 0x9b, 0xbc, 0x26, 0xa6, 0x3b, 0x92, 0x78, 0x35, 0x12, 0x9f, + 0x52, 0xeb, 0xac, 0x2a, 0x16, 0x24, 0xec, 0xff, 0x6f, 0x10, 0x4e, 0x2d, 0x54, 0x57, 0x72, 0xd6, + 0xd5, 0x79, 0x18, 0xa8, 0x07, 0xee, 0x0e, 0x09, 0xc4, 0x38, 0x2b, 0x2a, 0x8b, 0xac, 0x14, 0x0b, + 0x28, 0xba, 0x0c, 0xa3, 0xfc, 0x7c, 0xbc, 0xea, 0x78, 0xf5, 0x98, 0x3d, 0x0a, 0xec, 0xd1, 0x5b, + 0x1a, 0x0c, 0x1b, 0x98, 0x87, 0x5c, 0x54, 0xe7, 0x13, 0x9b, 0x31, 0xef, 0xec, 0xfd, 0xaa, 0x05, + 0x93, 0xbc, 0x99, 0xb9, 0x28, 0x0a, 0xdc, 0x3b, 0xed, 0x88, 0x84, 0xa5, 0x7e, 0xc6, 0xe9, 0x16, + 0xb2, 0x46, 0x2b, 0x77, 0x04, 0x66, 0x6f, 0x25, 0xa8, 0x70, 0x26, 0x58, 0x12, 0xed, 0x4e, 0x26, + 0xc1, 0x38, 0xd5, 0x2c, 0xfa, 0xfb, 0x16, 0xcc, 0xd4, 0x7c, 0x2f, 0x0a, 0xfc, 0x46, 0x83, 0x04, + 0x95, 0xf6, 0x9d, 0x86, 0x1b, 0x6e, 0xf1, 0x75, 0x8a, 0xc9, 0x06, 0xe3, 0x04, 0x39, 0x73, 0xa8, + 0x90, 0xc4, 0x1c, 0x9e, 0xdd, 0xdf, 0x2b, 0xcf, 0x2c, 0xe4, 0x92, 0xc2, 0x1d, 0x9a, 0x41, 0xdb, + 0x80, 0xe8, 0xc9, 0x5e, 0x8d, 0x9c, 0x4d, 0x12, 0x37, 0x3e, 0xd8, 0x7b, 0xe3, 0x27, 0xf6, 0xf7, + 0xca, 0x68, 0x2d, 0x45, 0x02, 0x67, 0x90, 0x45, 0xef, 0xc3, 0x31, 0x5a, 0x9a, 0xfa, 0xd6, 0xa1, + 0xde, 0x9b, 0x2b, 0xed, 0xef, 0x95, 0x8f, 0xad, 0x65, 0x10, 0xc1, 0x99, 0xa4, 0xd1, 0x4f, 0x59, + 0x70, 0x2a, 0xfe, 0xfc, 0xa5, 0x7b, 0x2d, 0xc7, 0xab, 0xc7, 0x0d, 0x0f, 0xf7, 0xde, 0x30, 0xe5, + 0xc9, 0xa7, 0x16, 0xf2, 0x28, 0xe1, 0xfc, 0x46, 0x90, 0x07, 0xd3, 0xb4, 0x6b, 0xc9, 0xb6, 0xa1, + 0xf7, 0xb6, 0x4f, 0xee, 0xef, 0x95, 0xa7, 0xd7, 0xd2, 0x34, 0x70, 0x16, 0xe1, 0x99, 0x05, 0x38, + 0x9e, 0xb9, 0x3a, 0xd1, 0x24, 0x14, 0xb7, 0x09, 0x17, 0x02, 0x87, 0x31, 0xfd, 0x89, 0x8e, 0x41, + 0xff, 0x8e, 0xd3, 0x68, 0x8b, 0x8d, 0x89, 0xf9, 0x9f, 0xd7, 0x0a, 0x97, 0x2d, 0xfb, 0xbf, 0x2f, + 0xc2, 0xc4, 0x42, 0x75, 0xe5, 0x81, 0x76, 0xbd, 0x7e, 0xec, 0x15, 0x3a, 0x1e, 0x7b, 0xf1, 0x21, + 0x5a, 0xcc, 0x3d, 0x44, 0x7f, 0x32, 0x63, 0xcb, 0xf6, 0xb1, 0x2d, 0xfb, 0xc9, 0x9c, 0x2d, 0xfb, + 0x90, 0x37, 0xea, 0x4e, 0xce, 0xaa, 0xed, 0x67, 0x13, 0x98, 0x29, 0x21, 0x31, 0xd9, 0x2f, 0xc9, + 0x6a, 0x0f, 0xb9, 0x74, 0x1f, 0xce, 0x3c, 0xd6, 0x60, 0x74, 0xc1, 0x69, 0x39, 0x77, 0xdc, 0x86, + 0x1b, 0xb9, 0x24, 0x44, 0x4f, 0x43, 0xd1, 0xa9, 0xd7, 0x99, 0x74, 0x37, 0x3c, 0x7f, 0x7c, 0x7f, + 0xaf, 0x5c, 0x9c, 0xab, 0x53, 0x31, 0x03, 0x14, 0xd6, 0x2e, 0xa6, 0x18, 0xe8, 0x59, 0xe8, 0xab, + 0x07, 0x7e, 0xab, 0x54, 0x60, 0x98, 0x74, 0x97, 0xf7, 0x2d, 0x06, 0x7e, 0x2b, 0x81, 0xca, 0x70, + 0xec, 0xdf, 0x2d, 0xc0, 0xe9, 0x05, 0xd2, 0xda, 0x5a, 0xae, 0xe6, 0x9c, 0x17, 0x17, 0x60, 0xa8, + 0xe9, 0x7b, 0x6e, 0xe4, 0x07, 0xa1, 0x68, 0x9a, 0xad, 0x88, 0x55, 0x51, 0x86, 0x15, 0x14, 0x9d, + 0x83, 0xbe, 0x56, 0x2c, 0xc4, 0x8e, 0x4a, 0x01, 0x98, 0x89, 0xaf, 0x0c, 0x42, 0x31, 0xda, 0x21, + 0x09, 0xc4, 0x8a, 0x51, 0x18, 0x37, 0x43, 0x12, 0x60, 0x06, 0x89, 0x25, 0x01, 0x2a, 0x23, 0x88, + 0x13, 0x21, 0x21, 0x09, 0x50, 0x08, 0xd6, 0xb0, 0x50, 0x05, 0x86, 0xc3, 0xc4, 0xcc, 0xf6, 0xb4, + 0x35, 0xc7, 0x98, 0xa8, 0xa0, 0x66, 0x32, 0x26, 0x62, 0x9c, 0x60, 0x03, 0x5d, 0x45, 0x85, 0x6f, + 0x17, 0x00, 0xf1, 0x21, 0xfc, 0x11, 0x1b, 0xb8, 0x9b, 0xe9, 0x81, 0xeb, 0x7d, 0x4b, 0x3c, 0xac, + 0xd1, 0xfb, 0xbf, 0x2d, 0x38, 0xbd, 0xe0, 0x7a, 0x75, 0x12, 0xe4, 0x2c, 0xc0, 0x47, 0x73, 0x95, + 0x3f, 0x9c, 0x90, 0x62, 0x2c, 0xb1, 0xbe, 0x87, 0xb0, 0xc4, 0xec, 0xbf, 0xb2, 0x00, 0xf1, 0xcf, + 0xfe, 0xd0, 0x7d, 0xec, 0xcd, 0xf4, 0xc7, 0x3e, 0x84, 0x65, 0x61, 0x5f, 0x87, 0xf1, 0x85, 0x86, + 0x4b, 0xbc, 0x68, 0xa5, 0xb2, 0xe0, 0x7b, 0x1b, 0xee, 0x26, 0x7a, 0x0d, 0xc6, 0x23, 0xb7, 0x49, + 0xfc, 0x76, 0x54, 0x25, 0x35, 0xdf, 0x63, 0x37, 0x57, 0xeb, 0x42, 0xff, 0x3c, 0xda, 0xdf, 0x2b, + 0x8f, 0xaf, 0x1b, 0x10, 0x9c, 0xc0, 0xb4, 0xff, 0x35, 0xe5, 0x5b, 0x8d, 0x76, 0x18, 0x91, 0x60, + 0x3d, 0x68, 0x87, 0xd1, 0x7c, 0x9b, 0xca, 0x9e, 0x95, 0xc0, 0xa7, 0xdd, 0x71, 0x7d, 0x0f, 0x9d, + 0x36, 0xae, 0xe3, 0x43, 0xf2, 0x2a, 0x2e, 0xae, 0xdd, 0xb3, 0x00, 0xa1, 0xbb, 0xe9, 0x91, 0x40, + 0xbb, 0x3e, 0x8c, 0xb3, 0xad, 0xa2, 0x4a, 0xb1, 0x86, 0x81, 0x1a, 0x30, 0xd6, 0x70, 0xee, 0x90, + 0x46, 0x95, 0x34, 0x48, 0x2d, 0xf2, 0x03, 0xa1, 0xdf, 0x78, 0xa9, 0xb7, 0x7b, 0xc0, 0x75, 0xbd, + 0xea, 0xfc, 0xd4, 0xfe, 0x5e, 0x79, 0xcc, 0x28, 0xc2, 0x26, 0x71, 0xca, 0x3a, 0xfc, 0x16, 0xfd, + 0x0a, 0xa7, 0xa1, 0x5f, 0x3e, 0x6f, 0x88, 0x32, 0xac, 0xa0, 0x8a, 0x75, 0xf4, 0xe5, 0xb1, 0x0e, + 0xfb, 0x4f, 0xe9, 0x42, 0xf3, 0x9b, 0x2d, 0xdf, 0x23, 0x5e, 0xb4, 0xe0, 0x7b, 0x75, 0xae, 0x99, + 0x7a, 0xcd, 0x50, 0x9d, 0x9c, 0x4f, 0xa8, 0x4e, 0x4e, 0xa4, 0x6b, 0x68, 0xda, 0x93, 0x4f, 0xc2, + 0x40, 0x18, 0x39, 0x51, 0x3b, 0x14, 0x03, 0xf7, 0xb8, 0x5c, 0x76, 0x55, 0x56, 0x7a, 0xb0, 0x57, + 0x9e, 0x50, 0xd5, 0x78, 0x11, 0x16, 0x15, 0xd0, 0x33, 0x30, 0xd8, 0x24, 0x61, 0xe8, 0x6c, 0x4a, + 0xb1, 0x61, 0x42, 0xd4, 0x1d, 0x5c, 0xe5, 0xc5, 0x58, 0xc2, 0xd1, 0x13, 0xd0, 0x4f, 0x82, 0xc0, + 0x0f, 0xc4, 0xb7, 0x8d, 0x09, 0xc4, 0xfe, 0x25, 0x5a, 0x88, 0x39, 0xcc, 0xfe, 0x9f, 0x2c, 0x98, + 0x50, 0x7d, 0xe5, 0x6d, 0x1d, 0xc1, 0x75, 0xed, 0x5d, 0x80, 0x9a, 0xfc, 0xc0, 0x90, 0x1d, 0xb3, + 0x23, 0x2f, 0x9e, 0xcf, 0x94, 0x68, 0x52, 0xc3, 0x18, 0x53, 0x56, 0x45, 0x21, 0xd6, 0xa8, 0xd9, + 0xbf, 0x65, 0xc1, 0x74, 0xe2, 0x8b, 0xae, 0xbb, 0x61, 0x84, 0xde, 0x4b, 0x7d, 0xd5, 0x6c, 0x8f, + 0x8b, 0xcf, 0x0d, 0xf9, 0x37, 0xa9, 0x3d, 0x2f, 0x4b, 0xb4, 0x2f, 0xba, 0x0a, 0xfd, 0x6e, 0x44, + 0x9a, 0xf2, 0x63, 0x9e, 0xe8, 0xf8, 0x31, 0xbc, 0x57, 0xf1, 0x8c, 0xac, 0xd0, 0x9a, 0x98, 0x13, + 0xb0, 0x7f, 0xb7, 0x08, 0xc3, 0x7c, 0x7f, 0xaf, 0x3a, 0xad, 0x23, 0x98, 0x8b, 0xe7, 0x60, 0xd8, + 0x6d, 0x36, 0xdb, 0x91, 0x73, 0x47, 0x9c, 0x7b, 0x43, 0x9c, 0x07, 0xad, 0xc8, 0x42, 0x1c, 0xc3, + 0xd1, 0x0a, 0xf4, 0xb1, 0xae, 0xf0, 0xaf, 0x7c, 0x3a, 0xfb, 0x2b, 0x45, 0xdf, 0x67, 0x17, 0x9d, + 0xc8, 0xe1, 0x22, 0xa7, 0xda, 0x57, 0xb4, 0x08, 0x33, 0x12, 0xc8, 0x01, 0xb8, 0xe3, 0x7a, 0x4e, + 0xb0, 0x4b, 0xcb, 0x4a, 0x45, 0x46, 0xf0, 0x85, 0xce, 0x04, 0xe7, 0x15, 0x3e, 0x27, 0xab, 0x3e, + 0x2c, 0x06, 0x60, 0x8d, 0xe8, 0xcc, 0xab, 0x30, 0xac, 0x90, 0x0f, 0x23, 0x39, 0xce, 0x7c, 0x0a, + 0x26, 0x12, 0x6d, 0x75, 0xab, 0x3e, 0xaa, 0x0b, 0x9e, 0xbf, 0xc1, 0x58, 0x86, 0xe8, 0xf5, 0x92, + 0xb7, 0x23, 0xce, 0xa6, 0xfb, 0x70, 0xac, 0x91, 0xc1, 0xf2, 0xc5, 0xbc, 0xf6, 0x7e, 0x44, 0x9c, + 0x16, 0x9f, 0x7d, 0x2c, 0x0b, 0x8a, 0x33, 0xdb, 0x30, 0x38, 0x62, 0xa1, 0x13, 0x47, 0xa4, 0xfc, + 0xee, 0x98, 0xea, 0xfc, 0x35, 0xb2, 0xab, 0x98, 0xea, 0x0f, 0xb3, 0xfb, 0x67, 0xf8, 0xe8, 0x73, + 0x76, 0x39, 0x22, 0x08, 0x14, 0xaf, 0x91, 0x5d, 0x3e, 0x15, 0xfa, 0xd7, 0x15, 0x3b, 0x7e, 0xdd, + 0xb7, 0x2c, 0x18, 0x53, 0x5f, 0x77, 0x04, 0x7c, 0x61, 0xde, 0xe4, 0x0b, 0x67, 0x3a, 0x2e, 0xf0, + 0x1c, 0x8e, 0xf0, 0xed, 0x02, 0x9c, 0x52, 0x38, 0xf4, 0x12, 0xc5, 0xff, 0x88, 0x55, 0x75, 0x11, + 0x86, 0x3d, 0xa5, 0x4e, 0xb4, 0x4c, 0x3d, 0x5e, 0xac, 0x4c, 0x8c, 0x71, 0xe8, 0x91, 0xe7, 0xc5, + 0x87, 0xf6, 0xa8, 0xae, 0x67, 0x17, 0x87, 0xfb, 0x3c, 0x14, 0xdb, 0x6e, 0x5d, 0x1c, 0x30, 0x1f, + 0x97, 0xa3, 0x7d, 0x73, 0x65, 0xf1, 0x60, 0xaf, 0xfc, 0x78, 0x9e, 0xc9, 0x89, 0x9e, 0x6c, 0xe1, + 0xec, 0xcd, 0x95, 0x45, 0x4c, 0x2b, 0xa3, 0x39, 0x98, 0x90, 0x56, 0xb5, 0x5b, 0x54, 0x2e, 0xf5, + 0x3d, 0x71, 0x0e, 0x29, 0x65, 0x39, 0x36, 0xc1, 0x38, 0x89, 0x8f, 0x16, 0x61, 0x72, 0xbb, 0x7d, + 0x87, 0x34, 0x48, 0xc4, 0x3f, 0xf8, 0x1a, 0xe1, 0xaa, 0xe4, 0xe1, 0xf8, 0x0a, 0x7b, 0x2d, 0x01, + 0xc7, 0xa9, 0x1a, 0xf6, 0x0f, 0xd8, 0x79, 0x20, 0x46, 0x4f, 0x93, 0x6f, 0x7e, 0x98, 0xcb, 0xb9, + 0x97, 0x55, 0x71, 0x8d, 0xec, 0xae, 0xfb, 0x54, 0x0e, 0xc9, 0x5e, 0x15, 0xc6, 0x9a, 0xef, 0xeb, + 0xb8, 0xe6, 0x7f, 0xb5, 0x00, 0xc7, 0xd5, 0x08, 0x18, 0xd2, 0xf2, 0x8f, 0xfa, 0x18, 0x5c, 0x82, + 0x91, 0x3a, 0xd9, 0x70, 0xda, 0x8d, 0x48, 0xd9, 0x35, 0xfa, 0xb9, 0xa9, 0x6d, 0x31, 0x2e, 0xc6, + 0x3a, 0xce, 0x21, 0x86, 0xed, 0x5f, 0x8c, 0xb3, 0x83, 0x38, 0x72, 0xe8, 0x1a, 0x57, 0xbb, 0xc6, + 0xca, 0xdd, 0x35, 0x4f, 0x40, 0xbf, 0xdb, 0xa4, 0x82, 0x59, 0xc1, 0x94, 0xb7, 0x56, 0x68, 0x21, + 0xe6, 0x30, 0xf4, 0x14, 0x0c, 0xd6, 0xfc, 0x66, 0xd3, 0xf1, 0xea, 0xec, 0xc8, 0x1b, 0x9e, 0x1f, + 0xa1, 0xb2, 0xdb, 0x02, 0x2f, 0xc2, 0x12, 0x46, 0x85, 0x6f, 0x27, 0xd8, 0xe4, 0xca, 0x1e, 0x21, + 0x7c, 0xcf, 0x05, 0x9b, 0x21, 0x66, 0xa5, 0xf4, 0xae, 0x7a, 0xd7, 0x0f, 0xb6, 0x5d, 0x6f, 0x73, + 0xd1, 0x0d, 0xc4, 0x96, 0x50, 0x67, 0xe1, 0x6d, 0x05, 0xc1, 0x1a, 0x16, 0x5a, 0x86, 0xfe, 0x96, + 0x1f, 0x44, 0x61, 0x69, 0x80, 0x0d, 0xf7, 0xe3, 0x39, 0x8c, 0x88, 0x7f, 0x6d, 0xc5, 0x0f, 0xa2, + 0xf8, 0x03, 0xe8, 0xbf, 0x10, 0xf3, 0xea, 0xe8, 0x3a, 0x0c, 0x12, 0x6f, 0x67, 0x39, 0xf0, 0x9b, + 0xa5, 0xe9, 0x7c, 0x4a, 0x4b, 0x1c, 0x85, 0x2f, 0xb3, 0x58, 0x46, 0x15, 0xc5, 0x58, 0x92, 0x40, + 0x9f, 0x84, 0x22, 0xf1, 0x76, 0x4a, 0x83, 0x8c, 0xd2, 0x4c, 0x0e, 0xa5, 0x5b, 0x4e, 0x10, 0xf3, + 0xfc, 0x25, 0x6f, 0x07, 0xd3, 0x3a, 0xe8, 0x33, 0x30, 0x2c, 0x19, 0x46, 0x28, 0xb4, 0xa8, 0x99, + 0x0b, 0x56, 0xb2, 0x19, 0x4c, 0xde, 0x6f, 0xbb, 0x01, 0x69, 0x12, 0x2f, 0x0a, 0x63, 0x0e, 0x29, + 0xa1, 0x21, 0x8e, 0xa9, 0xa1, 0x1a, 0x8c, 0x06, 0x24, 0x74, 0xef, 0x93, 0x8a, 0xdf, 0x70, 0x6b, + 0xbb, 0xa5, 0x93, 0xac, 0x7b, 0xcf, 0x74, 0x1c, 0x32, 0xac, 0x55, 0x88, 0xb5, 0xfc, 0x7a, 0x29, + 0x36, 0x88, 0xa2, 0x77, 0x60, 0x2c, 0x20, 0x61, 0xe4, 0x04, 0x91, 0x68, 0xa5, 0xa4, 0xac, 0x72, + 0x63, 0x58, 0x07, 0xf0, 0xeb, 0x44, 0xdc, 0x4c, 0x0c, 0xc1, 0x26, 0x05, 0x14, 0x01, 0x32, 0x0a, + 0x70, 0xbb, 0x41, 0xc2, 0xd2, 0xa9, 0x7c, 0x6b, 0x66, 0x92, 0x2c, 0xad, 0x30, 0x3f, 0x23, 0x3a, + 0x8f, 0x70, 0x8a, 0x16, 0xce, 0xa0, 0x8f, 0x3e, 0x23, 0x0d, 0x1d, 0xab, 0x7e, 0xdb, 0x8b, 0xc2, + 0xd2, 0x30, 0x6b, 0x2f, 0xd3, 0x22, 0x7e, 0x2b, 0xc6, 0x4b, 0x5a, 0x42, 0x78, 0x65, 0x6c, 0x90, + 0x42, 0x9f, 0x83, 0x31, 0xfe, 0x9f, 0x1b, 0x72, 0xc3, 0xd2, 0x71, 0x46, 0xfb, 0x5c, 0x3e, 0x6d, + 0x8e, 0x38, 0x7f, 0x5c, 0x10, 0x1f, 0xd3, 0x4b, 0x43, 0x6c, 0x52, 0x43, 0x18, 0xc6, 0x1a, 0xee, + 0x0e, 0xf1, 0x48, 0x18, 0x56, 0x02, 0xff, 0x0e, 0x11, 0x7a, 0xe9, 0x53, 0xd9, 0x86, 0x5f, 0xff, + 0x0e, 0x11, 0x57, 0x4f, 0xbd, 0x0e, 0x36, 0x49, 0xa0, 0x9b, 0x30, 0x1e, 0x10, 0xa7, 0xee, 0xc6, + 0x44, 0x47, 0xba, 0x11, 0x65, 0xd7, 0x75, 0x6c, 0x54, 0xc2, 0x09, 0x22, 0xe8, 0x06, 0x8c, 0xb2, + 0x81, 0x6f, 0xb7, 0x38, 0xd1, 0x13, 0xdd, 0x88, 0x32, 0x37, 0x86, 0xaa, 0x56, 0x05, 0x1b, 0x04, + 0xd0, 0xdb, 0x30, 0xdc, 0x70, 0x37, 0x48, 0x6d, 0xb7, 0xd6, 0x20, 0xa5, 0x51, 0x46, 0x2d, 0x93, + 0x05, 0x5f, 0x97, 0x48, 0xfc, 0x56, 0xa0, 0xfe, 0xe2, 0xb8, 0x3a, 0xba, 0x05, 0x27, 0x22, 0x12, + 0x34, 0x5d, 0xcf, 0xa1, 0xac, 0x53, 0x5c, 0x44, 0x99, 0x3d, 0x7e, 0x8c, 0xad, 0xe9, 0xb3, 0x62, + 0x36, 0x4e, 0xac, 0x67, 0x62, 0xe1, 0x9c, 0xda, 0xe8, 0x1e, 0x94, 0x32, 0x20, 0x7c, 0xb7, 0x1c, + 0x63, 0x94, 0xdf, 0x10, 0x94, 0x4b, 0xeb, 0x39, 0x78, 0x07, 0x1d, 0x60, 0x38, 0x97, 0x3a, 0xba, + 0x01, 0x13, 0x8c, 0x5f, 0x57, 0xda, 0x8d, 0x86, 0x68, 0x70, 0x9c, 0x35, 0xf8, 0x94, 0x94, 0x5e, + 0x56, 0x4c, 0xf0, 0xc1, 0x5e, 0x19, 0xe2, 0x7f, 0x38, 0x59, 0x1b, 0xdd, 0x61, 0xa6, 0xdf, 0x76, + 0xe0, 0x46, 0xbb, 0x74, 0xd3, 0x91, 0x7b, 0x51, 0x69, 0xa2, 0xa3, 0x1a, 0x4c, 0x47, 0x55, 0xf6, + 0x61, 0xbd, 0x10, 0x27, 0x09, 0xd2, 0x03, 0x28, 0x8c, 0xea, 0xae, 0x57, 0x9a, 0xe4, 0xb7, 0x38, + 0xc9, 0xbf, 0xab, 0xb4, 0x10, 0x73, 0x18, 0x33, 0xfb, 0xd2, 0x1f, 0x37, 0xe8, 0x39, 0x3f, 0xc5, + 0x10, 0x63, 0xb3, 0xaf, 0x04, 0xe0, 0x18, 0x87, 0x8a, 0xde, 0x51, 0xb4, 0x5b, 0x42, 0x0c, 0x55, + 0xb1, 0xe1, 0xf5, 0xf5, 0xcf, 0x60, 0x5a, 0x6e, 0xdf, 0x81, 0x71, 0xc5, 0x45, 0xd8, 0x98, 0xa0, + 0x32, 0xf4, 0x33, 0x61, 0x53, 0x28, 0x6d, 0x87, 0x69, 0x17, 0x98, 0x20, 0x8a, 0x79, 0x39, 0xeb, + 0x82, 0x7b, 0x9f, 0xcc, 0xef, 0x46, 0x84, 0x6b, 0x40, 0x8a, 0x5a, 0x17, 0x24, 0x00, 0xc7, 0x38, + 0xf6, 0xff, 0xcf, 0x85, 0xf6, 0xf8, 0x6c, 0xea, 0xe1, 0x34, 0x7e, 0x1e, 0x86, 0x98, 0xbb, 0x89, + 0x1f, 0x70, 0x9b, 0x70, 0x7f, 0x2c, 0xa6, 0x5f, 0x15, 0xe5, 0x58, 0x61, 0xa0, 0xd7, 0x61, 0xac, + 0xa6, 0x37, 0x20, 0x44, 0x09, 0xc5, 0x46, 0x8c, 0xd6, 0xb1, 0x89, 0x8b, 0x2e, 0xc3, 0x10, 0xf3, + 0xac, 0xaa, 0xf9, 0x0d, 0x21, 0xe3, 0x4a, 0x79, 0x68, 0xa8, 0x22, 0xca, 0x0f, 0xb4, 0xdf, 0x58, + 0x61, 0xa3, 0xf3, 0x30, 0x40, 0xbb, 0xb0, 0x52, 0x11, 0x87, 0xb8, 0xd2, 0x3f, 0x5e, 0x65, 0xa5, + 0x58, 0x40, 0xed, 0xdf, 0xb2, 0x98, 0x04, 0x97, 0x3e, 0x69, 0xd0, 0x55, 0x76, 0x54, 0xb1, 0x73, + 0x4b, 0xb3, 0xfd, 0x3f, 0xa9, 0x9d, 0x3f, 0x0a, 0x76, 0x90, 0xf8, 0x8f, 0x8d, 0x9a, 0xe8, 0xdd, + 0xe4, 0x79, 0xc4, 0xc5, 0x98, 0x97, 0xe5, 0x10, 0x24, 0xcf, 0xa4, 0xc7, 0xe2, 0x83, 0x95, 0xf6, + 0xa7, 0xd3, 0xc1, 0x64, 0xff, 0x36, 0xbf, 0x53, 0xa6, 0xce, 0x1a, 0xb4, 0x08, 0x03, 0x0e, 0x13, + 0xc7, 0x45, 0xc7, 0x9f, 0x97, 0x03, 0x30, 0xc7, 0x4a, 0x0f, 0x84, 0x71, 0x37, 0x59, 0x8f, 0x43, + 0xb1, 0xa8, 0x8b, 0xbe, 0x00, 0xc3, 0xe4, 0x9e, 0x1b, 0x2d, 0xf8, 0x75, 0xb1, 0xa0, 0x4c, 0xc5, + 0x62, 0xc7, 0xe3, 0xee, 0x86, 0xb7, 0x24, 0xab, 0x72, 0x0e, 0xa7, 0xfe, 0xe2, 0x98, 0xa8, 0xfd, + 0xf3, 0x16, 0x94, 0xbb, 0xd4, 0x46, 0xb7, 0xa9, 0x64, 0x49, 0x02, 0x27, 0xf2, 0xa5, 0x91, 0xf0, + 0x75, 0xb9, 0x0c, 0x6e, 0x88, 0xf2, 0x83, 0xbd, 0xf2, 0xd3, 0x5d, 0xc8, 0x48, 0x54, 0xac, 0x88, + 0x21, 0x1b, 0x06, 0x98, 0x6e, 0x81, 0x8b, 0xca, 0xfd, 0xdc, 0x52, 0x78, 0x8b, 0x95, 0x60, 0x01, + 0xb1, 0xff, 0x51, 0x41, 0xdb, 0x87, 0xd5, 0xc8, 0x89, 0x08, 0xaa, 0xc0, 0xe0, 0x5d, 0xc7, 0x8d, + 0x5c, 0x6f, 0x53, 0xc8, 0xf3, 0x9d, 0x05, 0x18, 0x56, 0xe9, 0x36, 0xaf, 0xc0, 0xa5, 0x52, 0xf1, + 0x07, 0x4b, 0x32, 0x94, 0x62, 0xd0, 0xf6, 0x3c, 0x4a, 0xb1, 0xd0, 0x2b, 0x45, 0xcc, 0x2b, 0x70, + 0x8a, 0xe2, 0x0f, 0x96, 0x64, 0xd0, 0x7b, 0x00, 0x92, 0x07, 0x93, 0xba, 0xd0, 0x09, 0x3f, 0xdf, + 0x9d, 0xe8, 0xba, 0xaa, 0xc3, 0x95, 0xce, 0xf1, 0x7f, 0xac, 0xd1, 0xb3, 0x23, 0x6d, 0xd7, 0xe8, + 0x9d, 0x41, 0x9f, 0xa5, 0x4c, 0xd0, 0x09, 0x22, 0x52, 0x9f, 0x8b, 0xc4, 0xe0, 0x3c, 0xdb, 0xdb, + 0xa5, 0x7f, 0xdd, 0x6d, 0x12, 0x9d, 0x61, 0x0a, 0x22, 0x38, 0xa6, 0x67, 0xff, 0x5a, 0x11, 0x4a, + 0x79, 0xdd, 0xa5, 0x6c, 0x49, 0xae, 0x2a, 0xa1, 0xac, 0x57, 0x6c, 0x49, 0x2e, 0x01, 0xac, 0x30, + 0x28, 0x7f, 0x08, 0xdd, 0x4d, 0xa9, 0xb3, 0xe9, 0x8f, 0xf9, 0x43, 0x95, 0x95, 0x62, 0x01, 0xa5, + 0x78, 0x01, 0x71, 0x42, 0xe1, 0x54, 0xa9, 0xf1, 0x11, 0xcc, 0x4a, 0xb1, 0x80, 0xea, 0xda, 0xe3, + 0xbe, 0x2e, 0xda, 0x63, 0x63, 0x88, 0xfa, 0x1f, 0xee, 0x10, 0xa1, 0xcf, 0x03, 0x6c, 0xb8, 0x9e, + 0x1b, 0x6e, 0x31, 0xea, 0x03, 0x87, 0xa6, 0xae, 0x2e, 0x3b, 0xcb, 0x8a, 0x0a, 0xd6, 0x28, 0xa2, + 0x57, 0x60, 0x44, 0xb1, 0xe8, 0x95, 0x45, 0xe6, 0xd2, 0xa1, 0xb9, 0xc8, 0xc5, 0xe7, 0xd5, 0x22, + 0xd6, 0xf1, 0xec, 0x2f, 0x26, 0xd7, 0x8b, 0xd8, 0x01, 0xda, 0xf8, 0x5a, 0xbd, 0x8e, 0x6f, 0xa1, + 0xf3, 0xf8, 0xda, 0x7f, 0x34, 0x0c, 0x13, 0x46, 0x63, 0xed, 0xb0, 0x87, 0x53, 0xed, 0x0a, 0x3d, + 0xe2, 0x9d, 0x88, 0x88, 0xfd, 0x67, 0x77, 0xdf, 0x2a, 0xba, 0x18, 0x40, 0x77, 0x00, 0xaf, 0x8f, + 0x3e, 0x0f, 0xc3, 0x0d, 0x27, 0x64, 0x9a, 0x68, 0x22, 0xf6, 0x5d, 0x2f, 0xc4, 0xe2, 0x8b, 0xbe, + 0x13, 0x46, 0x9a, 0x5c, 0xc5, 0x69, 0xc7, 0x24, 0xa9, 0x2c, 0x42, 0x25, 0x58, 0xe9, 0xb5, 0xab, + 0x3a, 0x41, 0xc5, 0xdc, 0x5d, 0xcc, 0x61, 0xe8, 0x32, 0x3b, 0xbc, 0xe8, 0xaa, 0x58, 0xa0, 0xf2, + 0x3e, 0x5b, 0x66, 0xfd, 0xc6, 0xe5, 0x49, 0xc1, 0xb0, 0x81, 0x19, 0xdf, 0xb5, 0x07, 0x3a, 0xdc, + 0xb5, 0x9f, 0x81, 0x41, 0xf6, 0x43, 0xad, 0x00, 0x35, 0x1b, 0x2b, 0xbc, 0x18, 0x4b, 0x78, 0x72, + 0xc1, 0x0c, 0xf5, 0xb6, 0x60, 0xe8, 0x6d, 0x5e, 0x2c, 0x6a, 0xe6, 0x4e, 0x33, 0xc4, 0xb9, 0x9c, + 0x58, 0xf2, 0x58, 0xc2, 0xd0, 0x2f, 0x58, 0x80, 0x9c, 0x46, 0xc3, 0xaf, 0x31, 0x0e, 0xa5, 0x2e, + 0xad, 0xc0, 0x2e, 0x33, 0xaf, 0x77, 0x1d, 0xf6, 0x76, 0x38, 0x3b, 0x97, 0xaa, 0xcd, 0x35, 0xe0, + 0xaf, 0xc9, 0xbb, 0x5a, 0x1a, 0x41, 0x3f, 0xee, 0xaf, 0xbb, 0x61, 0xf4, 0xe5, 0x3f, 0x4b, 0x1c, + 0xff, 0x19, 0x5d, 0x42, 0x37, 0xf5, 0x4b, 0xf5, 0xc8, 0x21, 0x2f, 0xd5, 0x63, 0xb9, 0x17, 0xea, + 0xbf, 0x93, 0xb8, 0x22, 0x8e, 0xb2, 0x2f, 0x7f, 0xaa, 0xcb, 0x15, 0x51, 0x98, 0x49, 0x7a, 0xb9, + 0x28, 0x56, 0x84, 0x7d, 0x7f, 0x8c, 0x75, 0xb9, 0xb3, 0x72, 0xe3, 0x66, 0x48, 0x82, 0xf9, 0x53, + 0xd2, 0xfc, 0x7f, 0xa0, 0x4b, 0x77, 0x9a, 0x3f, 0xc0, 0x4f, 0x59, 0x50, 0x4a, 0x0f, 0x10, 0xef, + 0x52, 0x69, 0x9c, 0xf5, 0xdf, 0xee, 0x34, 0x32, 0xa2, 0xf3, 0xd2, 0x8d, 0xb9, 0x34, 0x97, 0x43, + 0x0b, 0xe7, 0xb6, 0x82, 0x2e, 0x03, 0x84, 0x91, 0xdf, 0xe2, 0xbc, 0x9e, 0x5d, 0x17, 0x86, 0x99, + 0x23, 0x0d, 0x54, 0x55, 0xe9, 0x41, 0x7c, 0x16, 0x68, 0xb8, 0x33, 0x6d, 0x38, 0x99, 0xb3, 0x62, + 0x32, 0xec, 0x18, 0x8b, 0xba, 0x1d, 0xa3, 0x8b, 0xf6, 0x7b, 0x56, 0xce, 0xe9, 0xec, 0x3b, 0x6d, + 0xc7, 0x8b, 0xdc, 0x68, 0x57, 0xb7, 0x7b, 0x78, 0x60, 0x0e, 0x25, 0xfa, 0x1c, 0xf4, 0x37, 0x5c, + 0xaf, 0x7d, 0x4f, 0x9c, 0xb1, 0xe7, 0xb3, 0x2f, 0x98, 0x5e, 0xfb, 0x9e, 0x39, 0x39, 0x65, 0xba, + 0x95, 0x59, 0xf9, 0xc1, 0x5e, 0x19, 0xa5, 0x11, 0x30, 0xa7, 0x6a, 0x3f, 0x0b, 0xe3, 0x8b, 0x0e, + 0x69, 0xfa, 0xde, 0x92, 0x57, 0x6f, 0xf9, 0xae, 0x17, 0xa1, 0x12, 0xf4, 0x31, 0xf1, 0x9d, 0x1f, + 0xad, 0x7d, 0x74, 0xf0, 0x31, 0x2b, 0xb1, 0x37, 0xe1, 0xf8, 0xa2, 0x7f, 0xd7, 0xbb, 0xeb, 0x04, + 0xf5, 0xb9, 0xca, 0x8a, 0xa6, 0x07, 0x5e, 0x93, 0x7a, 0x48, 0x2b, 0x5f, 0xcb, 0xa3, 0xd5, 0xe4, + 0x8b, 0x70, 0xd9, 0x6d, 0x90, 0x1c, 0x6d, 0xfd, 0x3f, 0x2d, 0x18, 0x2d, 0xc5, 0xf8, 0xca, 0xd6, + 0x6c, 0xe5, 0xba, 0xa9, 0xbc, 0x03, 0x43, 0x1b, 0x2e, 0x69, 0xd4, 0x31, 0xd9, 0x10, 0xb3, 0xf1, + 0x74, 0xbe, 0x23, 0xeb, 0x32, 0xc5, 0x54, 0x46, 0x71, 0xa6, 0xc5, 0x5c, 0x16, 0x95, 0xb1, 0x22, + 0x83, 0xb6, 0x61, 0x52, 0xce, 0x99, 0x84, 0x0a, 0x7e, 0xff, 0x4c, 0xa7, 0xe5, 0x6b, 0x12, 0x67, + 0x4e, 0xfd, 0x38, 0x41, 0x06, 0xa7, 0x08, 0xa3, 0xd3, 0xd0, 0xd7, 0xa4, 0x92, 0x4d, 0x1f, 0x1b, + 0x7e, 0xa6, 0xb6, 0x64, 0x1a, 0x58, 0x56, 0x6a, 0xff, 0x33, 0x0b, 0x4e, 0xa6, 0x46, 0x46, 0x68, + 0xa2, 0x1f, 0xf2, 0x2c, 0x24, 0x35, 0xc3, 0x85, 0xee, 0x9a, 0x61, 0xfb, 0xbf, 0xb0, 0xe0, 0xd8, + 0x52, 0xb3, 0x15, 0xed, 0x2e, 0xba, 0xa6, 0x4f, 0xc9, 0xab, 0x30, 0xd0, 0x24, 0x75, 0xb7, 0xdd, + 0x14, 0x33, 0x57, 0x96, 0xa7, 0xff, 0x2a, 0x2b, 0xa5, 0x1c, 0xa4, 0x1a, 0xf9, 0x81, 0xb3, 0x49, + 0x78, 0x01, 0x16, 0xe8, 0x4c, 0x86, 0x72, 0xef, 0x93, 0xeb, 0x6e, 0xd3, 0x8d, 0x1e, 0x6c, 0x77, + 0x09, 0x77, 0x10, 0x49, 0x04, 0xc7, 0xf4, 0xec, 0xef, 0x5a, 0x30, 0x21, 0xd7, 0xfd, 0x5c, 0xbd, + 0x1e, 0x90, 0x30, 0x44, 0x33, 0x50, 0x70, 0x5b, 0xa2, 0x97, 0x20, 0x7a, 0x59, 0x58, 0xa9, 0xe0, + 0x82, 0xdb, 0x92, 0x17, 0x62, 0x26, 0x60, 0x14, 0x4d, 0xcf, 0x98, 0xab, 0xa2, 0x1c, 0x2b, 0x0c, + 0x74, 0x01, 0x86, 0x3c, 0xbf, 0xce, 0xef, 0x94, 0xc2, 0x37, 0x82, 0x62, 0xae, 0x89, 0x32, 0xac, + 0xa0, 0xa8, 0x02, 0xc3, 0xdc, 0x6f, 0x3a, 0x5e, 0xb4, 0x3d, 0x79, 0x5f, 0xb3, 0x2f, 0x5b, 0x97, + 0x35, 0x71, 0x4c, 0xc4, 0xfe, 0x1d, 0x0b, 0x46, 0xe5, 0x97, 0xf5, 0x78, 0xdb, 0xa7, 0x5b, 0x2b, + 0xbe, 0xe9, 0xc7, 0x5b, 0x8b, 0xde, 0xd6, 0x19, 0xc4, 0xb8, 0xa4, 0x17, 0x0f, 0x75, 0x49, 0xbf, + 0x04, 0x23, 0x4e, 0xab, 0x55, 0x31, 0x6f, 0xf8, 0x6c, 0x29, 0xcd, 0xc5, 0xc5, 0x58, 0xc7, 0xb1, + 0x7f, 0xae, 0x00, 0xe3, 0xf2, 0x0b, 0xaa, 0xed, 0x3b, 0x21, 0x89, 0xd0, 0x3a, 0x0c, 0x3b, 0x7c, + 0x96, 0x88, 0x5c, 0xe4, 0x4f, 0x64, 0xeb, 0xbb, 0x8d, 0x29, 0x8d, 0x05, 0xe9, 0x39, 0x59, 0x1b, + 0xc7, 0x84, 0x50, 0x03, 0xa6, 0x3c, 0x3f, 0x62, 0x42, 0x95, 0x82, 0x77, 0x72, 0x41, 0x48, 0x52, + 0x3f, 0x25, 0xa8, 0x4f, 0xad, 0x25, 0xa9, 0xe0, 0x34, 0x61, 0xb4, 0x24, 0x6d, 0x08, 0xc5, 0x7c, + 0x35, 0xac, 0x3e, 0x71, 0xd9, 0x26, 0x04, 0xfb, 0x37, 0x2d, 0x18, 0x96, 0x68, 0x47, 0xe1, 0x6d, + 0xb2, 0x0a, 0x83, 0x21, 0x9b, 0x04, 0x39, 0x34, 0x76, 0xa7, 0x8e, 0xf3, 0xf9, 0x8a, 0x65, 0x45, + 0xfe, 0x3f, 0xc4, 0x92, 0x06, 0x33, 0x21, 0xab, 0xee, 0x7f, 0x48, 0x4c, 0xc8, 0xaa, 0x3f, 0x39, + 0x87, 0xd2, 0x5f, 0xb0, 0x3e, 0x6b, 0x36, 0x19, 0x7a, 0xa5, 0x69, 0x05, 0x64, 0xc3, 0xbd, 0x97, + 0xbc, 0xd2, 0x54, 0x58, 0x29, 0x16, 0x50, 0xf4, 0x1e, 0x8c, 0xd6, 0xa4, 0xed, 0x30, 0xde, 0xe1, + 0xe7, 0x3b, 0xda, 0xb1, 0x95, 0xcb, 0x03, 0xd7, 0x42, 0x2f, 0x68, 0xf5, 0xb1, 0x41, 0xcd, 0xf4, + 0x0b, 0x2c, 0x76, 0xf3, 0x0b, 0x8c, 0xe9, 0xe6, 0x7b, 0xc9, 0xfd, 0xbc, 0x05, 0x03, 0xdc, 0x66, + 0xd4, 0x9b, 0xc9, 0x4e, 0xf3, 0x00, 0x89, 0xc7, 0x8e, 0x29, 0x57, 0x84, 0x64, 0x83, 0x56, 0x61, + 0x98, 0xfd, 0x60, 0x36, 0xaf, 0x62, 0xfe, 0x2b, 0x42, 0xde, 0xaa, 0xde, 0xc1, 0x5b, 0xb2, 0x1a, + 0x8e, 0x29, 0xd8, 0xdf, 0x2f, 0x52, 0xee, 0x16, 0xa3, 0x1a, 0x87, 0xbe, 0xf5, 0xe8, 0x0e, 0xfd, + 0xc2, 0xa3, 0x3a, 0xf4, 0x37, 0x61, 0xa2, 0xa6, 0xf9, 0x8b, 0xc4, 0x33, 0x79, 0xa1, 0xe3, 0x22, + 0xd1, 0x5c, 0x4b, 0xb8, 0x7e, 0x7b, 0xc1, 0x24, 0x82, 0x93, 0x54, 0xd1, 0x67, 0x61, 0x94, 0xcf, + 0xb3, 0x68, 0x85, 0xbb, 0x56, 0x3e, 0x95, 0xbf, 0x5e, 0xf4, 0x26, 0xb8, 0x3d, 0x44, 0xab, 0x8e, + 0x0d, 0x62, 0xa8, 0x0a, 0xb0, 0xe1, 0x36, 0x88, 0x20, 0xdd, 0xc1, 0x0b, 0x7a, 0x99, 0x63, 0x29, + 0xc2, 0xe3, 0x5c, 0x0f, 0x21, 0xab, 0x62, 0x8d, 0x8c, 0xfd, 0xd7, 0x16, 0xa0, 0xa5, 0xd6, 0x16, + 0x69, 0x92, 0xc0, 0x69, 0xc4, 0xb6, 0xe4, 0xaf, 0x59, 0x50, 0x22, 0xa9, 0xe2, 0x05, 0xbf, 0xd9, + 0x14, 0x1a, 0x86, 0x1c, 0x25, 0xd8, 0x52, 0x4e, 0x9d, 0xf8, 0x96, 0x91, 0x87, 0x81, 0x73, 0xdb, + 0x43, 0xab, 0x30, 0xcd, 0x8f, 0x5e, 0x05, 0xd0, 0x5c, 0x3a, 0x1f, 0x13, 0x84, 0xa7, 0xd7, 0xd3, + 0x28, 0x38, 0xab, 0x9e, 0xfd, 0xef, 0xc6, 0x21, 0xb7, 0x17, 0x1f, 0x19, 0xd1, 0x3f, 0x32, 0xa2, + 0x7f, 0x64, 0x44, 0xff, 0xc8, 0x88, 0xfe, 0x91, 0x11, 0xfd, 0x23, 0x23, 0xfa, 0x47, 0x46, 0x74, + 0xcd, 0x88, 0xfe, 0x8f, 0x2d, 0x38, 0xae, 0x0e, 0x4d, 0x43, 0xf7, 0xf0, 0x25, 0x98, 0xe6, 0xdb, + 0x6d, 0xa1, 0xe1, 0xb8, 0xcd, 0x75, 0xd2, 0x6c, 0x35, 0x9c, 0x48, 0x3a, 0xe8, 0x5d, 0xca, 0x5c, + 0xb9, 0x89, 0x57, 0x40, 0x46, 0x45, 0xfe, 0x9c, 0x32, 0x03, 0x80, 0xb3, 0x9a, 0xb1, 0x7f, 0x6d, + 0x08, 0xfa, 0x97, 0x76, 0x88, 0x17, 0x1d, 0xc1, 0x2d, 0xad, 0x06, 0xe3, 0xae, 0xb7, 0xe3, 0x37, + 0x76, 0x48, 0x9d, 0xc3, 0x0f, 0xa3, 0x4c, 0x38, 0x21, 0x48, 0x8f, 0xaf, 0x18, 0x24, 0x70, 0x82, + 0xe4, 0xa3, 0x30, 0x94, 0x5d, 0x81, 0x01, 0x7e, 0xe4, 0x09, 0xa1, 0x31, 0x93, 0x67, 0xb3, 0x41, + 0x14, 0x07, 0x79, 0x6c, 0xc4, 0xe3, 0x47, 0xaa, 0xa8, 0x8e, 0xbe, 0x08, 0xe3, 0x1b, 0x6e, 0x10, + 0x46, 0xeb, 0x6e, 0x93, 0x9e, 0x0f, 0xcd, 0xd6, 0x03, 0x18, 0xc6, 0xd4, 0x38, 0x2c, 0x1b, 0x94, + 0x70, 0x82, 0x32, 0xda, 0x84, 0xb1, 0x86, 0xa3, 0x37, 0x35, 0x78, 0xe8, 0xa6, 0xd4, 0xe9, 0x70, + 0x5d, 0x27, 0x84, 0x4d, 0xba, 0x74, 0x3b, 0xd5, 0x98, 0x6d, 0x67, 0x88, 0x69, 0x66, 0xd4, 0x76, + 0xe2, 0x46, 0x1d, 0x0e, 0xa3, 0x62, 0x21, 0x7b, 0x4b, 0x33, 0x6c, 0x8a, 0x85, 0xda, 0x8b, 0x99, + 0x2f, 0xc0, 0x30, 0xa1, 0x43, 0x48, 0x09, 0x8b, 0x03, 0xe6, 0x62, 0x6f, 0x7d, 0x5d, 0x75, 0x6b, + 0x81, 0x6f, 0x9a, 0x24, 0x97, 0x24, 0x25, 0x1c, 0x13, 0x45, 0x0b, 0x30, 0x10, 0x92, 0xc0, 0x55, + 0x66, 0x8f, 0x0e, 0xd3, 0xc8, 0xd0, 0xb8, 0x15, 0x9e, 0xff, 0xc6, 0xa2, 0x2a, 0x5d, 0x5e, 0xc2, + 0x9d, 0x61, 0xd4, 0x5c, 0x5e, 0x09, 0x87, 0x85, 0xb7, 0x61, 0x30, 0x20, 0x0d, 0x66, 0xf3, 0x1e, + 0xeb, 0x7d, 0x91, 0x73, 0x13, 0x3a, 0xaf, 0x87, 0x25, 0x01, 0x74, 0x8d, 0xca, 0x2b, 0x54, 0xac, + 0x74, 0xbd, 0x4d, 0xf5, 0xc2, 0x44, 0x30, 0x5a, 0x25, 0xbe, 0xe3, 0x18, 0x43, 0x3e, 0xd5, 0xc6, + 0x19, 0xd5, 0xd0, 0x15, 0x98, 0x52, 0xa5, 0x2b, 0x5e, 0x18, 0x39, 0x94, 0xc1, 0x71, 0xcb, 0x83, + 0x52, 0x15, 0xe1, 0x24, 0x02, 0x4e, 0xd7, 0xb1, 0x7f, 0xc9, 0x02, 0x3e, 0xce, 0x47, 0xa0, 0x20, + 0x79, 0xd3, 0x54, 0x90, 0x9c, 0xca, 0x9d, 0xb9, 0x1c, 0xe5, 0xc8, 0x2f, 0x59, 0x30, 0xa2, 0xcd, + 0x6c, 0xbc, 0x66, 0xad, 0x0e, 0x6b, 0xb6, 0x0d, 0x93, 0x74, 0xa5, 0xdf, 0xb8, 0x13, 0x92, 0x60, + 0x87, 0xd4, 0xd9, 0xc2, 0x2c, 0x3c, 0xd8, 0xc2, 0x54, 0xde, 0xec, 0xd7, 0x13, 0x04, 0x71, 0xaa, + 0x09, 0xfb, 0x0b, 0xb2, 0xab, 0xca, 0xf9, 0xbf, 0xa6, 0xe6, 0x3c, 0xe1, 0xfc, 0xaf, 0x66, 0x15, + 0xc7, 0x38, 0x74, 0xab, 0x6d, 0xf9, 0x61, 0x94, 0x74, 0xfe, 0xbf, 0xea, 0x87, 0x11, 0x66, 0x10, + 0xfb, 0x25, 0x80, 0xa5, 0x7b, 0xa4, 0xc6, 0x57, 0xac, 0x7e, 0xd5, 0xb2, 0xf2, 0xaf, 0x5a, 0xf6, + 0x1f, 0x5b, 0x30, 0xbe, 0xbc, 0x60, 0x9c, 0x5c, 0xb3, 0x00, 0xfc, 0x7e, 0x78, 0xfb, 0xf6, 0x9a, + 0xf4, 0x05, 0xe3, 0xce, 0x1a, 0xaa, 0x14, 0x6b, 0x18, 0xe8, 0x14, 0x14, 0x1b, 0x6d, 0x4f, 0x68, + 0x70, 0x07, 0xe9, 0xf1, 0x78, 0xbd, 0xed, 0x61, 0x5a, 0xa6, 0x3d, 0xd3, 0x2c, 0xf6, 0xfc, 0x4c, + 0xb3, 0x6b, 0xb4, 0x28, 0x54, 0x86, 0xfe, 0xbb, 0x77, 0xdd, 0x3a, 0x0f, 0x82, 0x21, 0xfc, 0xd4, + 0x6e, 0xdf, 0x5e, 0x59, 0x0c, 0x31, 0x2f, 0xb7, 0x7f, 0xd9, 0x82, 0x89, 0xc4, 0x6d, 0x9f, 0xde, + 0x1a, 0x77, 0x54, 0x08, 0xa2, 0x64, 0xa4, 0x15, 0x2d, 0x38, 0x91, 0x86, 0xd5, 0xc3, 0xf3, 0x64, + 0xf1, 0xbc, 0xa5, 0xd8, 0xc3, 0xf3, 0x96, 0xce, 0x3e, 0xeb, 0x5f, 0x2f, 0xc2, 0xcc, 0x72, 0x83, + 0xdc, 0xfb, 0x80, 0xb1, 0x4b, 0x7a, 0x7d, 0x17, 0x7b, 0x38, 0xf5, 0xdd, 0x61, 0xdf, 0x3e, 0x77, + 0x9f, 0xc2, 0x0d, 0x18, 0xe4, 0x9f, 0x2e, 0x23, 0x99, 0x64, 0x1a, 0xd3, 0xf3, 0x07, 0x64, 0x96, + 0x0f, 0xa1, 0x30, 0xa6, 0xab, 0x33, 0x5e, 0x94, 0x62, 0x49, 0x7c, 0xe6, 0x35, 0x18, 0xd5, 0x31, + 0x0f, 0x15, 0x85, 0xe0, 0xef, 0x15, 0x61, 0x92, 0xf6, 0xe0, 0x91, 0x4e, 0xc4, 0xcd, 0xf4, 0x44, + 0x3c, 0xec, 0x97, 0xe8, 0xdd, 0x67, 0xe3, 0xbd, 0xe4, 0x6c, 0x5c, 0xca, 0x9b, 0x8d, 0xa3, 0x9e, + 0x83, 0xbf, 0x6f, 0xc1, 0xf4, 0x72, 0xc3, 0xaf, 0x6d, 0x27, 0x5e, 0x8b, 0xbf, 0x02, 0x23, 0xf4, + 0x04, 0x09, 0x8d, 0xc0, 0x49, 0x46, 0x28, 0x2d, 0x01, 0xc2, 0x3a, 0x9e, 0x56, 0xed, 0xe6, 0xcd, + 0x95, 0xc5, 0xac, 0x08, 0x5c, 0x02, 0x84, 0x75, 0x3c, 0xfb, 0x0f, 0x2c, 0x38, 0x73, 0x65, 0x61, + 0x29, 0x5e, 0x8a, 0xa9, 0x20, 0x60, 0xe7, 0x61, 0xa0, 0x55, 0xd7, 0xba, 0x12, 0x2b, 0xe5, 0x17, + 0x59, 0x2f, 0x04, 0xf4, 0xc3, 0x12, 0x6f, 0xef, 0x26, 0xc0, 0x15, 0x5c, 0x59, 0x10, 0x47, 0x85, + 0xb4, 0xc1, 0x59, 0xb9, 0x36, 0xb8, 0xa7, 0x60, 0x90, 0x1e, 0x65, 0x6e, 0x4d, 0xf6, 0x9b, 0xbb, + 0xcb, 0xf0, 0x22, 0x2c, 0x61, 0xf6, 0x2f, 0x5a, 0x30, 0x7d, 0xc5, 0x8d, 0xa8, 0x9c, 0x91, 0x8c, + 0x72, 0x45, 0x05, 0x8d, 0xd0, 0x8d, 0xfc, 0x60, 0x37, 0xc9, 0x7b, 0xb1, 0x82, 0x60, 0x0d, 0x8b, + 0x7f, 0xd0, 0x8e, 0xcb, 0xde, 0x9f, 0x15, 0x4c, 0xab, 0x27, 0x16, 0xe5, 0x58, 0x61, 0xd0, 0xf1, + 0xaa, 0xbb, 0x01, 0xe3, 0xf4, 0x92, 0x1b, 0xab, 0xf1, 0x5a, 0x94, 0x00, 0x1c, 0xe3, 0xd8, 0x7f, + 0x69, 0x41, 0xf9, 0x0a, 0x7f, 0x45, 0xbf, 0x11, 0xe6, 0x30, 0xdd, 0x97, 0x60, 0x98, 0x48, 0xf3, + 0x8c, 0xe8, 0xb5, 0x92, 0x9d, 0x95, 0xdd, 0x86, 0x07, 0xdb, 0x52, 0x78, 0x3d, 0x9c, 0x19, 0x87, + 0x8b, 0x49, 0xb0, 0x0c, 0x88, 0xe8, 0x6d, 0xe9, 0xd1, 0xc7, 0x58, 0x18, 0xa3, 0xa5, 0x14, 0x14, + 0x67, 0xd4, 0xb0, 0xff, 0x99, 0x05, 0xc7, 0xd5, 0x07, 0x7f, 0xe8, 0x3e, 0xd3, 0xfe, 0x95, 0x02, + 0x8c, 0x5d, 0x5d, 0x5f, 0xaf, 0x5c, 0x21, 0x91, 0xb6, 0x2a, 0x3b, 0x3b, 0x5d, 0x60, 0xcd, 0x76, + 0xdc, 0xe9, 0x5a, 0xdb, 0x8e, 0xdc, 0xc6, 0x2c, 0x8f, 0xa9, 0x39, 0xbb, 0xe2, 0x45, 0x37, 0x82, + 0x6a, 0x14, 0xb8, 0xde, 0x66, 0xe6, 0x4a, 0x97, 0x62, 0x56, 0x31, 0x4f, 0xcc, 0x42, 0x2f, 0xc1, + 0x00, 0x0b, 0xea, 0x29, 0x27, 0xe1, 0x31, 0x75, 0x2b, 0x64, 0xa5, 0x07, 0x7b, 0xe5, 0xe1, 0x9b, + 0x78, 0x85, 0xff, 0xc1, 0x02, 0x15, 0xdd, 0x84, 0x91, 0xad, 0x28, 0x6a, 0x5d, 0x25, 0x4e, 0x9d, + 0x04, 0x92, 0xcb, 0x9e, 0xcd, 0xe2, 0xb2, 0x74, 0x10, 0x38, 0x5a, 0xcc, 0x98, 0xe2, 0xb2, 0x10, + 0xeb, 0x74, 0xec, 0x2a, 0x40, 0x0c, 0x7b, 0x48, 0x66, 0x33, 0x7b, 0x1d, 0x86, 0xe9, 0xe7, 0xce, + 0x35, 0x5c, 0xa7, 0xb3, 0x63, 0xc2, 0x73, 0x30, 0x2c, 0xdd, 0x0e, 0x42, 0x11, 0x72, 0x87, 0x9d, + 0x48, 0xd2, 0x2b, 0x21, 0xc4, 0x31, 0xdc, 0x7e, 0x12, 0x84, 0x6f, 0x7c, 0x27, 0x92, 0xf6, 0x06, + 0x1c, 0x63, 0x4e, 0xfe, 0x4e, 0xb4, 0x65, 0xac, 0xd1, 0xee, 0x8b, 0xe1, 0x79, 0x71, 0x15, 0x2d, + 0x28, 0x6f, 0x2b, 0x19, 0xd2, 0x61, 0x54, 0x52, 0x8c, 0xaf, 0xa5, 0xf6, 0xf7, 0xfb, 0xe0, 0xb1, + 0x95, 0x6a, 0x7e, 0xac, 0xb8, 0xcb, 0x30, 0xca, 0x25, 0x5c, 0xba, 0x34, 0x9c, 0x86, 0x68, 0x57, + 0x29, 0x6d, 0xd7, 0x35, 0x18, 0x36, 0x30, 0xa9, 0x44, 0xe8, 0xbe, 0xef, 0x25, 0x1f, 0x3c, 0xaf, + 0xbc, 0xb3, 0x86, 0x69, 0x39, 0x05, 0x53, 0x61, 0x99, 0xb3, 0x74, 0x05, 0x56, 0x02, 0xf3, 0x9b, + 0x30, 0xee, 0x86, 0xb5, 0xd0, 0x5d, 0xf1, 0xe8, 0x3e, 0xd5, 0x76, 0xba, 0x52, 0x93, 0xd0, 0x4e, + 0x2b, 0x28, 0x4e, 0x60, 0x6b, 0xe7, 0x4b, 0x7f, 0xcf, 0x02, 0x77, 0xd7, 0x48, 0x35, 0x94, 0xfd, + 0xb7, 0xd8, 0xd7, 0x85, 0xcc, 0x56, 0x21, 0xd8, 0x3f, 0xff, 0xe0, 0x10, 0x4b, 0x18, 0xbd, 0x83, + 0xd6, 0xb6, 0x9c, 0xd6, 0x5c, 0x3b, 0xda, 0x5a, 0x74, 0xc3, 0x9a, 0xbf, 0x43, 0x82, 0x5d, 0xa6, + 0x3e, 0x18, 0x8a, 0xef, 0xa0, 0x0a, 0xb0, 0x70, 0x75, 0xae, 0x42, 0x31, 0x71, 0xba, 0x0e, 0x9a, + 0x83, 0x09, 0x59, 0x58, 0x25, 0x21, 0x3b, 0x02, 0x46, 0x18, 0x19, 0xf5, 0x04, 0x59, 0x14, 0x2b, + 0x22, 0x49, 0x7c, 0x53, 0xc0, 0x85, 0x87, 0x21, 0xe0, 0xbe, 0x0a, 0x63, 0xae, 0xe7, 0x46, 0xae, + 0x13, 0xf9, 0xdc, 0xd0, 0xc6, 0x35, 0x05, 0x4c, 0x27, 0xbe, 0xa2, 0x03, 0xb0, 0x89, 0x67, 0xff, + 0x1f, 0x7d, 0x30, 0xc5, 0xa6, 0xed, 0xa3, 0x15, 0xf6, 0xe3, 0xb4, 0xc2, 0x6e, 0xa6, 0x57, 0xd8, + 0xc3, 0x90, 0xdc, 0x1f, 0x78, 0x99, 0x7d, 0xc5, 0x82, 0x29, 0xa6, 0x96, 0x37, 0x96, 0xd9, 0x45, + 0x18, 0x0e, 0x8c, 0xd7, 0xe1, 0xc3, 0xba, 0xf5, 0x4f, 0x3e, 0xf4, 0x8e, 0x71, 0xd0, 0x5b, 0x00, + 0xad, 0x58, 0xed, 0x5f, 0x30, 0x42, 0xfa, 0x42, 0xae, 0xc6, 0x5f, 0xab, 0x63, 0x7f, 0x11, 0x86, + 0xd5, 0xf3, 0x6f, 0x79, 0x41, 0xb6, 0x72, 0x2e, 0xc8, 0xdd, 0xc5, 0x08, 0xe9, 0x99, 0x58, 0xcc, + 0xf4, 0x4c, 0xfc, 0x73, 0x0b, 0x62, 0xa3, 0x0c, 0x7a, 0x07, 0x86, 0x5b, 0x3e, 0x73, 0x64, 0x0f, + 0xe4, 0xeb, 0x90, 0x27, 0x3b, 0x5a, 0x75, 0x78, 0xdc, 0xce, 0x80, 0x4f, 0x47, 0x45, 0x56, 0xc5, + 0x31, 0x15, 0x74, 0x0d, 0x06, 0x5b, 0x01, 0xa9, 0x46, 0x2c, 0xa8, 0x5c, 0xef, 0x04, 0xf9, 0xf2, + 0xe5, 0x15, 0xb1, 0xa4, 0x90, 0xf0, 0x0b, 0x2e, 0xf6, 0xee, 0x17, 0x6c, 0xff, 0xdb, 0x02, 0x4c, + 0x26, 0x1b, 0x41, 0x6f, 0x40, 0x1f, 0xb9, 0x47, 0x6a, 0xe2, 0x4b, 0x33, 0xa5, 0x89, 0x58, 0x21, + 0xc4, 0x87, 0x8e, 0xfe, 0xc7, 0xac, 0x16, 0xba, 0x0a, 0x83, 0x54, 0x94, 0xb8, 0xa2, 0x42, 0xaf, + 0x3e, 0x9e, 0x27, 0x8e, 0x28, 0x99, 0x8c, 0x7f, 0x96, 0x28, 0xc2, 0xb2, 0x3a, 0x73, 0x24, 0xac, + 0xb5, 0xaa, 0xf4, 0x96, 0x16, 0x75, 0x52, 0x26, 0xac, 0x2f, 0x54, 0x38, 0x92, 0xa0, 0xc6, 0x1d, + 0x09, 0x65, 0x21, 0x8e, 0x89, 0xa0, 0xb7, 0xa0, 0x3f, 0x6c, 0x10, 0xd2, 0x12, 0x9e, 0x22, 0x99, + 0x2a, 0xdd, 0x2a, 0x45, 0x10, 0x94, 0x98, 0x0a, 0x88, 0x15, 0x60, 0x5e, 0xd1, 0xfe, 0x55, 0x0b, + 0x80, 0x7b, 0x5e, 0x3a, 0xde, 0x26, 0x39, 0x02, 0x2b, 0xc8, 0x22, 0xf4, 0x85, 0x2d, 0x52, 0xeb, + 0xf4, 0xbe, 0x23, 0xee, 0x4f, 0xb5, 0x45, 0x6a, 0xf1, 0x6a, 0xa7, 0xff, 0x30, 0xab, 0x6d, 0xff, + 0x34, 0xc0, 0x78, 0x8c, 0xb6, 0x12, 0x91, 0x26, 0x7a, 0xc1, 0x88, 0x57, 0x75, 0x2a, 0x11, 0xaf, + 0x6a, 0x98, 0x61, 0x6b, 0x0a, 0xf7, 0x2f, 0x42, 0xb1, 0xe9, 0xdc, 0x13, 0x1a, 0xd5, 0xe7, 0x3a, + 0x77, 0x83, 0xd2, 0x9f, 0x5d, 0x75, 0xee, 0xf1, 0x1b, 0xfc, 0x73, 0x72, 0x77, 0xae, 0x3a, 0xf7, + 0xba, 0xbe, 0x41, 0xa0, 0x8d, 0xb0, 0xb6, 0x5c, 0x4f, 0x38, 0x15, 0xf6, 0xd4, 0x96, 0xeb, 0x25, + 0xdb, 0x72, 0xbd, 0x1e, 0xda, 0x72, 0x3d, 0x74, 0x1f, 0x06, 0x85, 0xcf, 0xaf, 0x08, 0xa4, 0x79, + 0xb1, 0x87, 0xf6, 0x84, 0xcb, 0x30, 0x6f, 0xf3, 0xa2, 0xd4, 0x50, 0x88, 0xd2, 0xae, 0xed, 0xca, + 0x06, 0xd1, 0x3f, 0xb1, 0x60, 0x5c, 0xfc, 0xc6, 0xe4, 0xfd, 0x36, 0x09, 0x23, 0x21, 0xc1, 0x7f, + 0xa2, 0xf7, 0x3e, 0x88, 0x8a, 0xbc, 0x2b, 0x9f, 0x90, 0x87, 0xad, 0x09, 0xec, 0xda, 0xa3, 0x44, + 0x2f, 0xd0, 0xbf, 0xb5, 0xe0, 0x58, 0xd3, 0xb9, 0xc7, 0x5b, 0xe4, 0x65, 0xd8, 0x89, 0x5c, 0x5f, + 0xb8, 0xb9, 0xbc, 0xd1, 0xdb, 0xf4, 0xa7, 0xaa, 0xf3, 0x4e, 0x4a, 0xeb, 0xf2, 0xb1, 0x2c, 0x94, + 0xae, 0x5d, 0xcd, 0xec, 0xd7, 0xcc, 0x06, 0x0c, 0xc9, 0xf5, 0xf6, 0x28, 0x1f, 0x34, 0xb0, 0x76, + 0xc4, 0x5a, 0x7b, 0xa4, 0xed, 0x7c, 0x11, 0x46, 0xf5, 0x35, 0xf6, 0x48, 0xdb, 0x7a, 0x1f, 0xa6, + 0x33, 0xd6, 0xd2, 0x23, 0x6d, 0xf2, 0x2e, 0x9c, 0xca, 0x5d, 0x1f, 0x8f, 0xf4, 0x41, 0xca, 0xaf, + 0x58, 0x3a, 0x1f, 0x3c, 0x02, 0x53, 0xd4, 0x82, 0x69, 0x8a, 0x3a, 0xdb, 0x79, 0xe7, 0xe4, 0xd8, + 0xa3, 0xde, 0xd3, 0x3b, 0x4d, 0xb9, 0x3a, 0x7a, 0x1b, 0x06, 0x1a, 0xb4, 0x44, 0x7a, 0x8e, 0xdb, + 0xdd, 0x77, 0x64, 0x2c, 0x51, 0xb3, 0xf2, 0x10, 0x0b, 0x0a, 0xf6, 0x37, 0x2c, 0xc8, 0x78, 0x52, + 0x43, 0x25, 0xac, 0xb6, 0x5b, 0x67, 0x43, 0x52, 0x8c, 0x25, 0x2c, 0x15, 0xce, 0xe9, 0x0c, 0x14, + 0x37, 0xdd, 0xba, 0x78, 0xad, 0xaf, 0xc0, 0x57, 0x28, 0x78, 0xd3, 0xad, 0xa3, 0x65, 0x40, 0x61, + 0xbb, 0xd5, 0x6a, 0x30, 0xcf, 0x30, 0xa7, 0x71, 0x25, 0xf0, 0xdb, 0x2d, 0xee, 0x26, 0x5e, 0xe4, + 0xea, 0xa5, 0x6a, 0x0a, 0x8a, 0x33, 0x6a, 0xd8, 0xbf, 0x6e, 0x41, 0xdf, 0x11, 0x4c, 0x13, 0x36, + 0xa7, 0xe9, 0x85, 0x5c, 0xd2, 0x22, 0xff, 0xca, 0x2c, 0x76, 0xee, 0x2e, 0xdd, 0x8b, 0x88, 0x17, + 0x32, 0x81, 0x23, 0x73, 0xd6, 0xf6, 0x2c, 0x98, 0xbe, 0xee, 0x3b, 0xf5, 0x79, 0xa7, 0xe1, 0x78, + 0x35, 0x12, 0xac, 0x78, 0x9b, 0x87, 0x7a, 0x93, 0x51, 0xe8, 0xfa, 0x26, 0xe3, 0x32, 0x0c, 0xb8, + 0x2d, 0x2d, 0x81, 0xc3, 0x39, 0x3a, 0xbb, 0x2b, 0x15, 0x91, 0xbb, 0x01, 0x19, 0x8d, 0xb3, 0x52, + 0x2c, 0xf0, 0xe9, 0xb2, 0xe4, 0x7e, 0x8b, 0x7d, 0xf9, 0xcb, 0x92, 0xde, 0x92, 0x92, 0x81, 0x09, + 0x0d, 0xb7, 0xfd, 0x2d, 0x30, 0x9a, 0x10, 0x8f, 0xd4, 0x30, 0x0c, 0xba, 0xfc, 0x4b, 0xc5, 0xda, + 0x7c, 0x3a, 0xfb, 0xf6, 0x92, 0x1a, 0x18, 0xed, 0x35, 0x26, 0x2f, 0xc0, 0x92, 0x90, 0x7d, 0x19, + 0x32, 0x03, 0x49, 0x75, 0xd7, 0x4c, 0xd9, 0x9f, 0x81, 0x29, 0x56, 0xf3, 0x90, 0x5a, 0x1f, 0x3b, + 0xa1, 0x4f, 0xcf, 0x88, 0xc5, 0x6d, 0xff, 0x2f, 0x16, 0xa0, 0x55, 0xbf, 0xee, 0x6e, 0xec, 0x0a, + 0xe2, 0xfc, 0xfb, 0xdf, 0x87, 0x32, 0xbf, 0x56, 0x27, 0xe3, 0x55, 0x2f, 0x34, 0x9c, 0x30, 0xd4, + 0x74, 0xf9, 0x4f, 0x8b, 0x76, 0xcb, 0xeb, 0x9d, 0xd1, 0x71, 0x37, 0x7a, 0xe8, 0x9d, 0x44, 0xf8, + 0xd0, 0x4f, 0xa6, 0xc2, 0x87, 0x3e, 0x9d, 0xe9, 0x04, 0x94, 0xee, 0xbd, 0x0c, 0x2b, 0x6a, 0x7f, + 0xd5, 0x82, 0x89, 0xb5, 0x44, 0xfc, 0xe5, 0xf3, 0xcc, 0x23, 0x22, 0xc3, 0x46, 0x55, 0x65, 0xa5, + 0x58, 0x40, 0x1f, 0xba, 0x0e, 0xf7, 0x07, 0x16, 0xc4, 0x81, 0xeb, 0x8e, 0x40, 0xe4, 0x5e, 0x30, + 0x44, 0xee, 0xcc, 0xeb, 0x8b, 0xea, 0x4e, 0x9e, 0xc4, 0x8d, 0xae, 0xa9, 0x39, 0xe9, 0x70, 0x73, + 0x89, 0xc9, 0xf0, 0x7d, 0x36, 0x6e, 0x4e, 0x9c, 0x9a, 0x8d, 0xef, 0x14, 0x00, 0x29, 0xdc, 0x9e, + 0x43, 0xce, 0xa6, 0x6b, 0x3c, 0x9c, 0x90, 0xb3, 0x3b, 0x80, 0x98, 0x4f, 0x4f, 0xe0, 0x78, 0x21, + 0x27, 0xeb, 0x0a, 0xad, 0xf5, 0xe1, 0x1c, 0x86, 0x94, 0x4b, 0xec, 0xf5, 0x14, 0x35, 0x9c, 0xd1, + 0x82, 0xe6, 0xab, 0xd5, 0xdf, 0xab, 0xaf, 0xd6, 0x40, 0x97, 0x47, 0xf7, 0xdf, 0xb2, 0x60, 0x4c, + 0x0d, 0xd3, 0x87, 0xe4, 0xe9, 0x8e, 0xea, 0x4f, 0xce, 0xb9, 0x52, 0xd1, 0xba, 0xcc, 0x84, 0x81, + 0x9f, 0x60, 0xc1, 0x13, 0x9c, 0x86, 0x7b, 0x9f, 0xa8, 0xc8, 0xe8, 0x65, 0x11, 0x0c, 0x41, 0x94, + 0x1e, 0xec, 0x95, 0xc7, 0xd4, 0x3f, 0xee, 0x8f, 0x10, 0x57, 0xb1, 0xff, 0x25, 0xdd, 0xec, 0xe6, + 0x52, 0x44, 0xaf, 0x40, 0x7f, 0x6b, 0xcb, 0x09, 0x49, 0xe2, 0x89, 0x63, 0x7f, 0x85, 0x16, 0x1e, + 0xec, 0x95, 0xc7, 0x55, 0x05, 0x56, 0x82, 0x39, 0x76, 0xef, 0x81, 0x7c, 0xd3, 0x8b, 0xb3, 0x6b, + 0x20, 0xdf, 0xbf, 0xb6, 0xa0, 0x6f, 0x8d, 0x9e, 0x5e, 0x8f, 0x9e, 0x05, 0xbc, 0x69, 0xb0, 0x80, + 0xd3, 0x79, 0x39, 0xc2, 0x72, 0x77, 0xff, 0x72, 0x62, 0xf7, 0x9f, 0xcd, 0xa5, 0xd0, 0x79, 0xe3, + 0x37, 0x61, 0x84, 0x65, 0x1e, 0x13, 0xcf, 0x39, 0x5f, 0x32, 0x36, 0x7c, 0x39, 0xb1, 0xe1, 0x27, + 0x34, 0x54, 0x6d, 0xa7, 0x3f, 0x03, 0x83, 0xe2, 0x7d, 0x60, 0x32, 0x06, 0x85, 0xc0, 0xc5, 0x12, + 0x6e, 0xff, 0x7c, 0x11, 0x8c, 0x4c, 0x67, 0xe8, 0x37, 0x2d, 0x98, 0x0d, 0xb8, 0x8b, 0x7f, 0x7d, + 0xb1, 0x1d, 0xb8, 0xde, 0x66, 0xb5, 0xb6, 0x45, 0xea, 0xed, 0x86, 0xeb, 0x6d, 0xae, 0x6c, 0x7a, + 0xbe, 0x2a, 0x5e, 0xba, 0x47, 0x6a, 0x6d, 0x15, 0xb7, 0xa7, 0x43, 0x5a, 0x35, 0xf5, 0x4c, 0xe6, + 0xc5, 0xfd, 0xbd, 0xf2, 0x2c, 0x3e, 0x14, 0x6d, 0x7c, 0xc8, 0xbe, 0xa0, 0x3f, 0xb0, 0xe0, 0x22, + 0xcf, 0xb8, 0xd5, 0x7b, 0xff, 0x3b, 0x68, 0x38, 0x2a, 0x92, 0x54, 0x4c, 0x64, 0x9d, 0x04, 0xcd, + 0xf9, 0x57, 0xc5, 0x80, 0x5e, 0xac, 0x1c, 0xae, 0x2d, 0x7c, 0xd8, 0xce, 0xd9, 0xff, 0x4d, 0x11, + 0xc6, 0x44, 0xc0, 0x57, 0x71, 0x06, 0xbc, 0x62, 0x2c, 0x89, 0xc7, 0x13, 0x4b, 0x62, 0xca, 0x40, + 0x7e, 0x38, 0xec, 0x3f, 0x84, 0x29, 0xca, 0x9c, 0xaf, 0x12, 0x27, 0x88, 0xee, 0x10, 0x87, 0xbb, + 0x60, 0x16, 0x0f, 0xcd, 0xfd, 0x95, 0x62, 0xfd, 0x7a, 0x92, 0x18, 0x4e, 0xd3, 0xff, 0x71, 0x3a, + 0x73, 0x3c, 0x98, 0x4c, 0xc5, 0xec, 0x7d, 0x17, 0x86, 0xd5, 0xe3, 0x36, 0xc1, 0x74, 0x3a, 0x87, + 0xbe, 0x4e, 0x52, 0xe0, 0x4a, 0xcf, 0xf8, 0x61, 0x65, 0x4c, 0xce, 0xfe, 0xe5, 0x82, 0xd1, 0x20, + 0x9f, 0xc4, 0x35, 0x18, 0x72, 0x42, 0x16, 0x8e, 0xbf, 0xde, 0x49, 0xa3, 0x9d, 0x6a, 0x86, 0xf9, + 0x99, 0xcd, 0x89, 0x9a, 0x58, 0xd1, 0x40, 0x57, 0xb9, 0xa3, 0xeb, 0x0e, 0xe9, 0xa4, 0xce, 0x4e, + 0x51, 0x03, 0xe9, 0x0a, 0xbb, 0x43, 0xb0, 0xa8, 0x8f, 0x3e, 0xc7, 0x3d, 0x91, 0xaf, 0x79, 0xfe, + 0x5d, 0xef, 0x8a, 0xef, 0xcb, 0x20, 0x50, 0xbd, 0x11, 0x9c, 0x92, 0xfe, 0xc7, 0xaa, 0x3a, 0x36, + 0xa9, 0xf5, 0x16, 0x04, 0xff, 0x4b, 0xc0, 0x32, 0x0c, 0x99, 0xb1, 0x24, 0x42, 0x44, 0x60, 0x42, + 0x44, 0x13, 0x96, 0x65, 0x62, 0xec, 0x32, 0xaf, 0xdf, 0x66, 0xed, 0xd8, 0x02, 0x74, 0xcd, 0x24, + 0x81, 0x93, 0x34, 0xed, 0x2d, 0xce, 0x84, 0x97, 0x89, 0x13, 0xb5, 0x03, 0x12, 0xa2, 0x4f, 0x43, + 0x29, 0x7d, 0x33, 0x16, 0x86, 0x14, 0x8b, 0x49, 0xcf, 0xa7, 0xf7, 0xf7, 0xca, 0xa5, 0x6a, 0x0e, + 0x0e, 0xce, 0xad, 0x6d, 0xff, 0x82, 0x05, 0xec, 0x05, 0xff, 0x11, 0x48, 0x3e, 0x9f, 0x32, 0x25, + 0x9f, 0x52, 0xde, 0x74, 0xe6, 0x08, 0x3d, 0x2f, 0xf3, 0x35, 0x5c, 0x09, 0xfc, 0x7b, 0xbb, 0xc2, + 0xeb, 0xab, 0xfb, 0x35, 0xce, 0xfe, 0xba, 0x05, 0x2c, 0x1d, 0x17, 0xe6, 0xb7, 0x76, 0x69, 0xe0, + 0xe8, 0xee, 0xd0, 0xf0, 0x69, 0x18, 0xda, 0x10, 0xc3, 0x9f, 0xa1, 0x74, 0x32, 0x3a, 0x6c, 0xd2, + 0x96, 0x93, 0x26, 0x5e, 0xe2, 0x8a, 0x7f, 0x58, 0x51, 0xb3, 0xff, 0x4b, 0x0b, 0x66, 0xf2, 0xab, + 0xa1, 0x9b, 0x70, 0x32, 0x20, 0xb5, 0x76, 0x10, 0xd2, 0x2d, 0x21, 0x2e, 0x40, 0xe2, 0x05, 0x18, + 0x9f, 0xea, 0xc7, 0xf6, 0xf7, 0xca, 0x27, 0x71, 0x36, 0x0a, 0xce, 0xab, 0x8b, 0x5e, 0x83, 0xf1, + 0x76, 0xc8, 0x25, 0x3f, 0x26, 0x74, 0x85, 0x22, 0xe6, 0x3b, 0x7b, 0x24, 0x75, 0xd3, 0x80, 0xe0, + 0x04, 0xa6, 0xfd, 0x77, 0xf9, 0x72, 0x54, 0x1e, 0xaf, 0x4d, 0x98, 0xf2, 0xb4, 0xff, 0xf4, 0x04, + 0x94, 0x57, 0xfd, 0x27, 0xbb, 0x9d, 0xfa, 0xec, 0xb8, 0xd4, 0x62, 0x0c, 0x24, 0xc8, 0xe0, 0x34, + 0x65, 0xfb, 0x9f, 0x5b, 0x70, 0x52, 0x47, 0xd4, 0x5e, 0x1c, 0x76, 0xb3, 0x02, 0x2e, 0x6a, 0x01, + 0xf8, 0xf8, 0x31, 0x77, 0x21, 0x23, 0x00, 0xdf, 0x31, 0x9d, 0x7a, 0xc7, 0x68, 0x7b, 0xfc, 0x6d, + 0x69, 0x56, 0xb4, 0xbd, 0xef, 0x5b, 0x7c, 0x7d, 0xea, 0x5d, 0x47, 0xef, 0xc3, 0x64, 0xd3, 0x89, + 0x6a, 0x5b, 0x4b, 0xf7, 0x5a, 0x01, 0x37, 0xee, 0xca, 0x71, 0x7a, 0xae, 0xdb, 0x38, 0x69, 0x1f, + 0x19, 0x7b, 0x83, 0xaf, 0x26, 0x88, 0xe1, 0x14, 0x79, 0x74, 0x07, 0x46, 0x58, 0x19, 0x7b, 0x8b, + 0x1d, 0x76, 0x92, 0x65, 0xf2, 0x5a, 0x53, 0xce, 0x41, 0xab, 0x31, 0x1d, 0xac, 0x13, 0xb5, 0xbf, + 0x59, 0xe4, 0x4c, 0x83, 0xdd, 0x3d, 0x9e, 0x81, 0xc1, 0x96, 0x5f, 0x5f, 0x58, 0x59, 0xc4, 0x62, + 0x16, 0xd4, 0xb9, 0x57, 0xe1, 0xc5, 0x58, 0xc2, 0xd1, 0x05, 0x18, 0x12, 0x3f, 0xa5, 0x31, 0x9e, + 0xed, 0x11, 0x81, 0x17, 0x62, 0x05, 0x45, 0x2f, 0x02, 0xb4, 0x02, 0x7f, 0xc7, 0xad, 0xb3, 0xd8, + 0x5b, 0x45, 0xd3, 0xaf, 0xaf, 0xa2, 0x20, 0x58, 0xc3, 0x42, 0xaf, 0xc3, 0x58, 0xdb, 0x0b, 0xb9, + 0xfc, 0xa4, 0x65, 0xae, 0x50, 0x1e, 0x67, 0x37, 0x75, 0x20, 0x36, 0x71, 0xd1, 0x1c, 0x0c, 0x44, + 0x0e, 0xf3, 0x53, 0xeb, 0xcf, 0x7f, 0x31, 0xb0, 0x4e, 0x31, 0xf4, 0x1c, 0x91, 0xb4, 0x02, 0x16, + 0x15, 0xd1, 0xbb, 0x32, 0x2c, 0x02, 0x3f, 0x89, 0xc4, 0x53, 0x9d, 0xde, 0x4e, 0x2d, 0x2d, 0x28, + 0x82, 0x78, 0x02, 0x64, 0xd0, 0x42, 0xaf, 0x01, 0x90, 0x7b, 0x11, 0x09, 0x3c, 0xa7, 0xa1, 0xbc, + 0x4b, 0x95, 0x20, 0xb3, 0xe8, 0xaf, 0xf9, 0xd1, 0xcd, 0x90, 0x2c, 0x29, 0x0c, 0xac, 0x61, 0xdb, + 0x3f, 0x3d, 0x02, 0x10, 0x5f, 0x34, 0xd0, 0x7d, 0x18, 0xaa, 0x39, 0x2d, 0xa7, 0xc6, 0x13, 0x20, + 0x17, 0xf3, 0x1e, 0x96, 0xc7, 0x35, 0x66, 0x17, 0x04, 0x3a, 0x37, 0xde, 0xc8, 0xe0, 0xff, 0x43, + 0xb2, 0xb8, 0xab, 0xc1, 0x46, 0xb5, 0x87, 0xbe, 0x62, 0xc1, 0x88, 0x88, 0x6d, 0xc5, 0x66, 0xa8, + 0x90, 0x6f, 0x6f, 0xd3, 0xda, 0x9f, 0x8b, 0x6b, 0xf0, 0x2e, 0xbc, 0x24, 0x57, 0xa8, 0x06, 0xe9, + 0xda, 0x0b, 0xbd, 0x61, 0xf4, 0x71, 0x79, 0xb7, 0x2d, 0x1a, 0x43, 0xa9, 0xee, 0xb6, 0xc3, 0xec, + 0xa8, 0xd1, 0xaf, 0xb5, 0x37, 0x8d, 0x6b, 0x6d, 0x5f, 0xfe, 0x13, 0x6d, 0x43, 0xde, 0xee, 0x76, + 0xa3, 0x45, 0x15, 0x3d, 0x06, 0x4c, 0x7f, 0xfe, 0x0b, 0x5f, 0xed, 0x62, 0xd7, 0x25, 0xfe, 0xcb, + 0x17, 0x61, 0xa2, 0x6e, 0x4a, 0x2d, 0x62, 0x25, 0x3e, 0x9d, 0x47, 0x37, 0x21, 0xe4, 0xc4, 0x72, + 0x4a, 0x02, 0x80, 0x93, 0x84, 0x51, 0x85, 0x87, 0x04, 0x5a, 0xf1, 0x36, 0x7c, 0xf1, 0x5c, 0xcc, + 0xce, 0x9d, 0xcb, 0xdd, 0x30, 0x22, 0x4d, 0x8a, 0x19, 0x0b, 0x09, 0x6b, 0xa2, 0x2e, 0x56, 0x54, + 0xd0, 0xdb, 0x30, 0xc0, 0x9e, 0x78, 0x86, 0xa5, 0xa1, 0x7c, 0xb3, 0x86, 0x19, 0x5d, 0x38, 0xde, + 0x90, 0xec, 0x6f, 0x88, 0x05, 0x05, 0x74, 0x55, 0x3e, 0xa0, 0x0e, 0x57, 0xbc, 0x9b, 0x21, 0x61, + 0x0f, 0xa8, 0x87, 0xe7, 0x9f, 0x8c, 0xdf, 0x46, 0xf3, 0xf2, 0xcc, 0x4c, 0xd2, 0x46, 0x4d, 0x2a, + 0xf6, 0x89, 0xff, 0x32, 0x41, 0xb5, 0x88, 0xd4, 0x97, 0xd9, 0x3d, 0x33, 0x89, 0x75, 0x3c, 0x9c, + 0xb7, 0x4c, 0x12, 0x38, 0x49, 0x93, 0x8a, 0xd0, 0x7c, 0xd7, 0x8b, 0x07, 0x67, 0xdd, 0x78, 0x07, + 0xd7, 0x1c, 0xb0, 0xd3, 0x88, 0x97, 0x60, 0x51, 0x1f, 0xb9, 0x30, 0x11, 0x18, 0xe2, 0x85, 0x0c, + 0xb0, 0x77, 0xbe, 0x37, 0x21, 0x46, 0x4b, 0xc9, 0x61, 0x92, 0xc1, 0x49, 0xba, 0xe8, 0x6d, 0x4d, + 0x50, 0x1a, 0xeb, 0x7c, 0xf3, 0xef, 0x26, 0x1a, 0xcd, 0x6c, 0xc3, 0x98, 0xc1, 0x6c, 0x1e, 0xa9, + 0x09, 0xd2, 0x83, 0xc9, 0x24, 0x67, 0x79, 0xa4, 0x96, 0xc7, 0xd7, 0x60, 0x9c, 0x6d, 0x84, 0xbb, + 0x4e, 0x4b, 0xb0, 0xe2, 0x0b, 0x06, 0x2b, 0xb6, 0x2e, 0x14, 0xf9, 0xc0, 0xc8, 0x21, 0x88, 0x19, + 0xa7, 0xfd, 0xaf, 0xfa, 0x45, 0x65, 0xb5, 0x8b, 0xd0, 0x45, 0x18, 0x16, 0x1d, 0x50, 0x79, 0xed, + 0x14, 0x63, 0x58, 0x95, 0x00, 0x1c, 0xe3, 0xb0, 0x74, 0x86, 0xac, 0xba, 0xf6, 0x42, 0x21, 0x4e, + 0x67, 0xa8, 0x20, 0x58, 0xc3, 0xa2, 0x97, 0xdf, 0x3b, 0xbe, 0x1f, 0xa9, 0x33, 0x58, 0x6d, 0xb5, + 0x79, 0x56, 0x8a, 0x05, 0x94, 0x9e, 0xbd, 0xdb, 0x24, 0xf0, 0x48, 0xc3, 0x4c, 0xec, 0xa2, 0xce, + 0xde, 0x6b, 0x3a, 0x10, 0x9b, 0xb8, 0x54, 0x82, 0xf0, 0x43, 0xb6, 0x77, 0xc5, 0x15, 0x3b, 0x7e, + 0xf1, 0x51, 0xe5, 0x41, 0x3e, 0x24, 0x1c, 0x7d, 0x06, 0x4e, 0xaa, 0x60, 0x9b, 0x62, 0x65, 0xca, + 0x16, 0x07, 0x0c, 0x8d, 0xd8, 0xc9, 0x85, 0x6c, 0x34, 0x9c, 0x57, 0x1f, 0xbd, 0x09, 0xe3, 0xe2, + 0x1a, 0x26, 0x29, 0x0e, 0x9a, 0xee, 0x8b, 0xd7, 0x0c, 0x28, 0x4e, 0x60, 0xcb, 0xd4, 0x34, 0xec, + 0x7e, 0x22, 0x29, 0x0c, 0xa5, 0x53, 0xd3, 0xe8, 0x70, 0x9c, 0xaa, 0x81, 0xe6, 0x60, 0x82, 0x8b, + 0x9d, 0xae, 0xb7, 0xc9, 0xe7, 0x44, 0x3c, 0x81, 0x55, 0x1b, 0xf2, 0x86, 0x09, 0xc6, 0x49, 0x7c, + 0x74, 0x19, 0x46, 0x9d, 0xa0, 0xb6, 0xe5, 0x46, 0xa4, 0x46, 0x77, 0x15, 0xf3, 0x20, 0xd4, 0xfc, + 0x3f, 0xe7, 0x34, 0x18, 0x36, 0x30, 0xd1, 0x5b, 0xd0, 0x17, 0xde, 0x75, 0x5a, 0x82, 0xfb, 0xe4, + 0xb3, 0x72, 0xb5, 0x82, 0xb9, 0xeb, 0x17, 0xfd, 0x8f, 0x59, 0x4d, 0xfb, 0x3e, 0x4c, 0x67, 0x04, + 0x25, 0xa2, 0x4b, 0xcf, 0x69, 0xb9, 0x72, 0x54, 0x12, 0xcf, 0x34, 0xe6, 0x2a, 0x2b, 0x72, 0x3c, + 0x34, 0x2c, 0xba, 0xbe, 0x59, 0xf0, 0x22, 0x2d, 0x89, 0xbf, 0x5a, 0xdf, 0xcb, 0x12, 0x80, 0x63, + 0x1c, 0xfb, 0x6f, 0x0a, 0x30, 0x91, 0x61, 0x1e, 0x64, 0x89, 0xe4, 0x13, 0xf7, 0xbc, 0x38, 0x6f, + 0xbc, 0x99, 0x2b, 0xa9, 0x70, 0x88, 0x5c, 0x49, 0xc5, 0x6e, 0xb9, 0x92, 0xfa, 0x3e, 0x48, 0xae, + 0x24, 0x73, 0xc4, 0xfa, 0x7b, 0x1a, 0xb1, 0x8c, 0xfc, 0x4a, 0x03, 0x87, 0xcc, 0xaf, 0x64, 0x0c, + 0xfa, 0x60, 0x0f, 0x83, 0xfe, 0x9f, 0x16, 0x60, 0x32, 0x69, 0x59, 0x3c, 0x02, 0xed, 0xfc, 0xdb, + 0x86, 0x76, 0xfe, 0x42, 0x2f, 0x41, 0x0f, 0x72, 0x35, 0xf5, 0x38, 0xa1, 0xa9, 0x7f, 0xb6, 0x27, + 0x6a, 0x9d, 0xb5, 0xf6, 0xff, 0xa2, 0x00, 0xc7, 0x33, 0x0d, 0xae, 0x47, 0x30, 0x36, 0x37, 0x8c, + 0xb1, 0x79, 0xa1, 0xe7, 0x80, 0x10, 0xb9, 0x03, 0x74, 0x3b, 0x31, 0x40, 0x17, 0x7b, 0x27, 0xd9, + 0x79, 0x94, 0xbe, 0x5b, 0x84, 0xb3, 0x99, 0xf5, 0x62, 0xe5, 0xf6, 0xb2, 0xa1, 0xdc, 0x7e, 0x31, + 0xa1, 0xdc, 0xb6, 0x3b, 0xd7, 0x7e, 0x38, 0xda, 0x6e, 0x11, 0x18, 0x81, 0x85, 0x77, 0x79, 0x40, + 0x4d, 0xb7, 0x11, 0x18, 0x41, 0x11, 0xc2, 0x26, 0xdd, 0x1f, 0x27, 0x0d, 0xf7, 0xff, 0x60, 0xc1, + 0xa9, 0xcc, 0xb9, 0x39, 0x02, 0x3d, 0xe3, 0x9a, 0xa9, 0x67, 0x7c, 0xa6, 0xe7, 0xd5, 0x9a, 0xa3, + 0x78, 0xfc, 0xea, 0x40, 0xce, 0xb7, 0x30, 0xf5, 0xc7, 0x0d, 0x18, 0x71, 0x6a, 0x35, 0x12, 0x86, + 0xab, 0x2c, 0xd5, 0x04, 0xb7, 0xbd, 0xbe, 0xc0, 0x2e, 0xa7, 0x71, 0xf1, 0xc1, 0x5e, 0x79, 0x26, + 0x49, 0x22, 0x06, 0x63, 0x9d, 0x02, 0xfa, 0x1c, 0x0c, 0x85, 0x32, 0x23, 0x6e, 0xdf, 0x83, 0x67, + 0xc4, 0x65, 0x92, 0xa4, 0x52, 0xef, 0x28, 0x92, 0xe8, 0xef, 0xe8, 0xe1, 0xbd, 0x3a, 0x28, 0x36, + 0x79, 0x27, 0x1f, 0x20, 0xc8, 0x97, 0xf9, 0x1c, 0xbe, 0xd8, 0xd3, 0x73, 0xf8, 0xb7, 0x60, 0x32, + 0xe4, 0xe1, 0x72, 0x63, 0x17, 0x19, 0xbe, 0x16, 0x59, 0xc4, 0xc1, 0x6a, 0x02, 0x86, 0x53, 0xd8, + 0x68, 0x59, 0xb6, 0xca, 0x9c, 0xa1, 0xf8, 0xf2, 0x3c, 0x1f, 0xb7, 0x28, 0x1c, 0xa2, 0x8e, 0x25, + 0x27, 0x81, 0x0d, 0xbf, 0x56, 0x13, 0x7d, 0x0e, 0x80, 0x2e, 0x22, 0xa1, 0xc2, 0x19, 0xcc, 0x67, + 0xa1, 0x94, 0xb7, 0xd4, 0x33, 0x5f, 0x60, 0xb0, 0x88, 0x06, 0x8b, 0x8a, 0x08, 0xd6, 0x08, 0x22, + 0x07, 0xc6, 0xe2, 0x7f, 0x98, 0x6c, 0x74, 0x0a, 0xb0, 0xc6, 0x5a, 0x48, 0x12, 0x67, 0xe6, 0x8d, + 0x45, 0x9d, 0x04, 0x36, 0x29, 0xa2, 0xcf, 0xc2, 0xa9, 0x9d, 0x5c, 0xbf, 0x23, 0x2e, 0x4b, 0x9e, + 0xd9, 0xdf, 0x2b, 0x9f, 0xca, 0xf7, 0x36, 0xca, 0xaf, 0x6f, 0xff, 0x8f, 0x00, 0x8f, 0x75, 0xe0, + 0xf4, 0x68, 0xce, 0xf4, 0x19, 0x78, 0x2e, 0xa9, 0x57, 0x99, 0xc9, 0xac, 0x6c, 0x28, 0x5a, 0x12, + 0x1b, 0xaa, 0xf0, 0x81, 0x37, 0xd4, 0xcf, 0x58, 0xda, 0x35, 0x8b, 0x7b, 0x94, 0x7f, 0xea, 0x90, + 0x27, 0xd8, 0x43, 0x54, 0x81, 0x6d, 0x64, 0xe8, 0x91, 0x5e, 0xec, 0xb9, 0x3b, 0xbd, 0x2b, 0x96, + 0x7e, 0x25, 0x3b, 0xc1, 0x00, 0x57, 0x31, 0x5d, 0x39, 0xec, 0xf7, 0x1f, 0x55, 0xb2, 0x81, 0xef, + 0x58, 0x70, 0x2a, 0x55, 0xcc, 0xfb, 0x40, 0x42, 0x11, 0xce, 0x70, 0xed, 0x03, 0x77, 0x5e, 0x12, + 0xe4, 0xdf, 0x70, 0x55, 0x7c, 0xc3, 0xa9, 0x5c, 0xbc, 0x64, 0xd7, 0xbf, 0xf6, 0x67, 0xe5, 0x69, + 0xd6, 0x80, 0x89, 0x88, 0xf3, 0xbb, 0x8e, 0x5a, 0x70, 0xae, 0xd6, 0x0e, 0x82, 0x78, 0xb1, 0x66, + 0x6c, 0x4e, 0x7e, 0x5b, 0x7c, 0x72, 0x7f, 0xaf, 0x7c, 0x6e, 0xa1, 0x0b, 0x2e, 0xee, 0x4a, 0x0d, + 0x79, 0x80, 0x9a, 0x29, 0xef, 0x3e, 0xc6, 0x00, 0x72, 0xb4, 0x40, 0x69, 0x5f, 0x40, 0xee, 0xa7, + 0x9b, 0xe1, 0x23, 0x98, 0x41, 0xf9, 0x68, 0x75, 0x37, 0x3f, 0x9c, 0x6c, 0x06, 0x33, 0xd7, 0xe1, + 0x6c, 0xe7, 0xc5, 0x74, 0xa8, 0x10, 0x14, 0x7f, 0x6c, 0xc1, 0x99, 0x8e, 0xa1, 0xd9, 0x7e, 0x04, + 0x2f, 0x0b, 0xf6, 0x97, 0x2d, 0x78, 0x3c, 0xb3, 0x46, 0xf2, 0xf1, 0x60, 0x8d, 0x16, 0x6a, 0xce, + 0xb0, 0x71, 0x90, 0x22, 0x09, 0xc0, 0x31, 0x8e, 0xe1, 0x2f, 0x5a, 0xe8, 0xea, 0x2f, 0xfa, 0x3b, + 0x16, 0xa4, 0x8e, 0xfa, 0x23, 0x90, 0x3c, 0x57, 0x4c, 0xc9, 0xf3, 0xc9, 0x5e, 0x46, 0x33, 0x47, + 0xe8, 0xfc, 0xab, 0x09, 0x38, 0x91, 0xf3, 0x82, 0x7c, 0x07, 0xa6, 0x36, 0x6b, 0xc4, 0x0c, 0x19, + 0xd2, 0x29, 0xfa, 0x5f, 0xc7, 0xf8, 0x22, 0xf3, 0xc7, 0xf7, 0xf7, 0xca, 0x53, 0x29, 0x14, 0x9c, + 0x6e, 0x02, 0x7d, 0xd9, 0x82, 0x63, 0xce, 0xdd, 0x70, 0x89, 0xde, 0x20, 0xdc, 0xda, 0x7c, 0xc3, + 0xaf, 0x6d, 0x53, 0xc1, 0x4c, 0x6e, 0xab, 0x97, 0x33, 0x55, 0xe1, 0xb7, 0xab, 0x29, 0x7c, 0xa3, + 0xf9, 0xd2, 0xfe, 0x5e, 0xf9, 0x58, 0x16, 0x16, 0xce, 0x6c, 0x0b, 0x61, 0x91, 0xc3, 0xcf, 0x89, + 0xb6, 0x3a, 0x05, 0xb5, 0xc9, 0x7a, 0xea, 0xcf, 0x45, 0x62, 0x09, 0xc1, 0x8a, 0x0e, 0xfa, 0x02, + 0x0c, 0x6f, 0xca, 0xf8, 0x15, 0x19, 0x22, 0x77, 0x3c, 0x90, 0x9d, 0xa3, 0x7a, 0x70, 0x07, 0x1c, + 0x85, 0x84, 0x63, 0xa2, 0xe8, 0x4d, 0x28, 0x7a, 0x1b, 0x61, 0xa7, 0x10, 0xd2, 0x09, 0x4f, 0x6b, + 0x1e, 0xed, 0x6a, 0x6d, 0xb9, 0x8a, 0x69, 0x45, 0x74, 0x15, 0x8a, 0xc1, 0x9d, 0xba, 0xb0, 0xe3, + 0x64, 0x6e, 0x52, 0x3c, 0xbf, 0x98, 0xd3, 0x2b, 0x46, 0x09, 0xcf, 0x2f, 0x62, 0x4a, 0x02, 0x55, + 0xa0, 0x9f, 0x3d, 0xbb, 0x16, 0xa2, 0x6d, 0xe6, 0x55, 0xbe, 0x43, 0xf8, 0x02, 0xfe, 0x1e, 0x92, + 0x21, 0x60, 0x4e, 0x08, 0xad, 0xc3, 0x40, 0xcd, 0xf5, 0xea, 0x24, 0x10, 0xb2, 0xec, 0xc7, 0x33, + 0x2d, 0x36, 0x0c, 0x23, 0x87, 0x26, 0x37, 0x60, 0x30, 0x0c, 0x2c, 0x68, 0x31, 0xaa, 0xa4, 0xb5, + 0xb5, 0x21, 0x4f, 0xac, 0x6c, 0xaa, 0xa4, 0xb5, 0xb5, 0x5c, 0xed, 0x48, 0x95, 0x61, 0x60, 0x41, + 0x0b, 0xbd, 0x06, 0x85, 0x8d, 0x9a, 0x78, 0x52, 0x9d, 0xa9, 0xde, 0x34, 0x03, 0x96, 0xcd, 0x0f, + 0xec, 0xef, 0x95, 0x0b, 0xcb, 0x0b, 0xb8, 0xb0, 0x51, 0x43, 0x6b, 0x30, 0xb8, 0xc1, 0xe3, 0x05, + 0x09, 0xfd, 0xe8, 0xd3, 0xd9, 0xa1, 0x8c, 0x52, 0x21, 0x85, 0xf8, 0xdb, 0x56, 0x01, 0xc0, 0x92, + 0x08, 0x4b, 0x78, 0xa6, 0xe2, 0x1e, 0x89, 0x48, 0xb1, 0xb3, 0x87, 0x8b, 0x55, 0x25, 0x02, 0x8d, + 0x2b, 0x2a, 0x58, 0xa3, 0x48, 0x57, 0xb5, 0x73, 0xbf, 0x1d, 0xb0, 0x8c, 0x28, 0xc2, 0x30, 0x93, + 0xb9, 0xaa, 0xe7, 0x24, 0x52, 0xa7, 0x55, 0xad, 0x90, 0x70, 0x4c, 0x14, 0x6d, 0xc3, 0xd8, 0x4e, + 0xd8, 0xda, 0x22, 0x72, 0x4b, 0xb3, 0x08, 0x83, 0x39, 0xd2, 0xec, 0x2d, 0x81, 0xe8, 0x06, 0x51, + 0xdb, 0x69, 0xa4, 0xb8, 0x10, 0xbb, 0xd6, 0xdc, 0xd2, 0x89, 0x61, 0x93, 0x36, 0x1d, 0xfe, 0xf7, + 0xdb, 0xfe, 0x9d, 0xdd, 0x88, 0x88, 0x00, 0xaf, 0x99, 0xc3, 0xff, 0x0e, 0x47, 0x49, 0x0f, 0xbf, + 0x00, 0x60, 0x49, 0x04, 0xdd, 0x12, 0xc3, 0xc3, 0xb8, 0xe7, 0x64, 0x7e, 0x20, 0xfc, 0x39, 0x89, + 0x94, 0x33, 0x28, 0x8c, 0x5b, 0xc6, 0xa4, 0x18, 0x97, 0x6c, 0x6d, 0xf9, 0x91, 0xef, 0x25, 0x38, + 0xf4, 0x54, 0x3e, 0x97, 0xac, 0x64, 0xe0, 0xa7, 0xb9, 0x64, 0x16, 0x16, 0xce, 0x6c, 0x0b, 0xd5, + 0x61, 0xbc, 0xe5, 0x07, 0xd1, 0x5d, 0x3f, 0x90, 0xeb, 0x0b, 0x75, 0x50, 0x94, 0x1a, 0x98, 0xa2, + 0x45, 0xe6, 0x16, 0x64, 0x42, 0x70, 0x82, 0x26, 0xfa, 0x34, 0x0c, 0x86, 0x35, 0xa7, 0x41, 0x56, + 0x6e, 0x94, 0xa6, 0xf3, 0x8f, 0x9f, 0x2a, 0x47, 0xc9, 0x59, 0x5d, 0x3c, 0xdc, 0x13, 0x47, 0xc1, + 0x92, 0x1c, 0x5a, 0x86, 0x7e, 0x96, 0x20, 0x9e, 0x45, 0x23, 0xce, 0x89, 0xe7, 0x9f, 0x7a, 0xd4, + 0xc3, 0x79, 0x13, 0x2b, 0xc6, 0xbc, 0x3a, 0xdd, 0x03, 0x42, 0x53, 0xe0, 0x87, 0xa5, 0xe3, 0xf9, + 0x7b, 0x40, 0x28, 0x18, 0x6e, 0x54, 0x3b, 0xed, 0x01, 0x85, 0x84, 0x63, 0xa2, 0x94, 0x33, 0x53, + 0x6e, 0x7a, 0xa2, 0x83, 0xc3, 0x66, 0x2e, 0x2f, 0x65, 0x9c, 0x99, 0x72, 0x52, 0x4a, 0xc2, 0xfe, + 0xad, 0xa1, 0xb4, 0xcc, 0xc2, 0x34, 0x4c, 0xff, 0xb1, 0x95, 0xf2, 0xd8, 0xf8, 0x44, 0xaf, 0x0a, + 0xef, 0x87, 0x78, 0x71, 0xfd, 0xb2, 0x05, 0x27, 0x5a, 0x99, 0x1f, 0x22, 0x04, 0x80, 0xde, 0xf4, + 0xe6, 0xfc, 0xd3, 0x55, 0xe4, 0xea, 0x6c, 0x38, 0xce, 0x69, 0x29, 0xa9, 0x1c, 0x28, 0x7e, 0x60, + 0xe5, 0xc0, 0x2a, 0x0c, 0xd5, 0xf8, 0x4d, 0x4e, 0x26, 0x8f, 0xe8, 0x29, 0xee, 0x2a, 0xb7, 0xd3, + 0x8a, 0x8a, 0x58, 0x91, 0x40, 0x3f, 0x6b, 0xc1, 0x99, 0x64, 0xd7, 0x31, 0x61, 0x60, 0xe1, 0xae, + 0xc9, 0xd5, 0x5a, 0xcb, 0xe2, 0xfb, 0x53, 0xf2, 0xbf, 0x81, 0x7c, 0xd0, 0x0d, 0x01, 0x77, 0x6e, + 0x0c, 0x2d, 0x66, 0xe8, 0xd5, 0x06, 0x4c, 0x9b, 0x64, 0x0f, 0xba, 0xb5, 0x97, 0x61, 0xb4, 0xe9, + 0xb7, 0xbd, 0x48, 0x78, 0x5d, 0x0a, 0xd7, 0x2d, 0xe6, 0xb2, 0xb4, 0xaa, 0x95, 0x63, 0x03, 0x2b, + 0xa1, 0x91, 0x1b, 0x7a, 0x60, 0x8d, 0xdc, 0x7b, 0x30, 0xea, 0x69, 0x0f, 0x12, 0x3a, 0xdd, 0x60, + 0x85, 0x76, 0x51, 0xc3, 0xe6, 0xbd, 0xd4, 0x4b, 0xb0, 0x41, 0xad, 0xb3, 0xb6, 0x0c, 0x3e, 0x98, + 0xb6, 0xec, 0x48, 0xaf, 0xc4, 0xf6, 0xbf, 0x29, 0x64, 0xdc, 0x18, 0xb8, 0x56, 0xee, 0x0d, 0x53, + 0x2b, 0x77, 0x3e, 0xa9, 0x95, 0x4b, 0x99, 0xaa, 0x0c, 0x85, 0x5c, 0xef, 0x19, 0x4c, 0x7b, 0x8e, + 0xa5, 0xfd, 0xf7, 0x2c, 0x38, 0xc9, 0x6c, 0x1f, 0xb4, 0x81, 0x0f, 0x6c, 0xef, 0x60, 0x0e, 0xb1, + 0xd7, 0xb3, 0xc9, 0xe1, 0xbc, 0x76, 0xec, 0x06, 0x9c, 0xeb, 0x76, 0xee, 0x32, 0xff, 0xe2, 0xba, + 0x72, 0xaf, 0x88, 0xfd, 0x8b, 0xeb, 0x2b, 0x8b, 0x98, 0x41, 0x7a, 0x0d, 0xbb, 0x68, 0xff, 0x9f, + 0x16, 0x14, 0x2b, 0x7e, 0xfd, 0x08, 0x6e, 0xf4, 0x9f, 0x32, 0x6e, 0xf4, 0x8f, 0x65, 0x9f, 0xf8, + 0xf5, 0x5c, 0x63, 0xdf, 0x52, 0xc2, 0xd8, 0x77, 0x26, 0x8f, 0x40, 0x67, 0xd3, 0xde, 0xbf, 0x2c, + 0xc2, 0x48, 0xc5, 0xaf, 0xab, 0x7d, 0xf6, 0xdf, 0x3d, 0xc8, 0x33, 0xa2, 0xdc, 0x9c, 0x65, 0x1a, + 0x65, 0xe6, 0x4f, 0x2c, 0xa3, 0x5e, 0xfc, 0x88, 0xbd, 0x26, 0xba, 0x4d, 0xdc, 0xcd, 0xad, 0x88, + 0xd4, 0x93, 0x9f, 0x73, 0x74, 0xaf, 0x89, 0xbe, 0x57, 0x84, 0x89, 0x44, 0xeb, 0xa8, 0x01, 0x63, + 0x0d, 0xdd, 0x94, 0x24, 0xd6, 0xe9, 0x03, 0x59, 0xa1, 0xc4, 0x6b, 0x0c, 0xad, 0x08, 0x9b, 0xc4, + 0xd1, 0x2c, 0x80, 0xa7, 0xfb, 0xa4, 0xab, 0x98, 0xd0, 0x9a, 0x3f, 0xba, 0x86, 0x81, 0x5e, 0x81, + 0x91, 0xc8, 0x6f, 0xf9, 0x0d, 0x7f, 0x73, 0xf7, 0x9a, 0x8a, 0x8f, 0xac, 0x5c, 0x96, 0xd7, 0x63, + 0x10, 0xd6, 0xf1, 0xd0, 0x3d, 0x98, 0x52, 0x44, 0xaa, 0x0f, 0xc1, 0xbc, 0xc6, 0xd4, 0x26, 0x6b, + 0x49, 0x8a, 0x38, 0xdd, 0x08, 0x7a, 0x0d, 0xc6, 0x99, 0xef, 0x34, 0xab, 0x7f, 0x8d, 0xec, 0xca, + 0xe0, 0xd2, 0x4c, 0xc2, 0x5e, 0x35, 0x20, 0x38, 0x81, 0x89, 0x16, 0x60, 0xaa, 0xe9, 0x86, 0x89, + 0xea, 0x03, 0xac, 0x3a, 0xeb, 0xc0, 0x6a, 0x12, 0x88, 0xd3, 0xf8, 0xf6, 0x2f, 0x8a, 0x39, 0xf6, + 0x22, 0xf7, 0xa3, 0xed, 0xf8, 0xe1, 0xde, 0x8e, 0xdf, 0xb5, 0x60, 0x92, 0xb6, 0xce, 0x1c, 0x42, + 0xa5, 0x20, 0xa5, 0xd2, 0x8f, 0x58, 0x1d, 0xd2, 0x8f, 0x9c, 0xa7, 0x6c, 0xbb, 0xee, 0xb7, 0x23, + 0xa1, 0x1d, 0xd5, 0xf8, 0x32, 0x2d, 0xc5, 0x02, 0x2a, 0xf0, 0x48, 0x10, 0x88, 0x57, 0xf7, 0x3a, + 0x1e, 0x09, 0x02, 0x2c, 0xa0, 0x32, 0x3b, 0x49, 0x5f, 0x76, 0x76, 0x12, 0x1e, 0x64, 0x5e, 0xf8, + 0xd1, 0x09, 0x91, 0x56, 0x0b, 0x32, 0x2f, 0x1d, 0xec, 0x62, 0x1c, 0xfb, 0x9f, 0x14, 0xa1, 0x54, + 0xf1, 0xeb, 0x0b, 0x24, 0x88, 0xdc, 0x0d, 0xb7, 0xe6, 0x44, 0x44, 0xcb, 0xb7, 0xfb, 0x22, 0x00, + 0x7b, 0x44, 0x16, 0x64, 0x45, 0x50, 0xaf, 0x2a, 0x08, 0xd6, 0xb0, 0xa8, 0x54, 0xb2, 0x4d, 0x76, + 0xb5, 0x93, 0x57, 0x49, 0x25, 0xd7, 0x78, 0x31, 0x96, 0x70, 0x74, 0x9d, 0x85, 0x32, 0x5a, 0xba, + 0xd7, 0x72, 0x03, 0x9e, 0x99, 0x9c, 0xd4, 0x7c, 0xaf, 0x1e, 0x8a, 0xc0, 0x6f, 0x25, 0x11, 0x88, + 0x28, 0x05, 0xc7, 0x99, 0xb5, 0x50, 0x05, 0x8e, 0xd5, 0x02, 0x52, 0x27, 0x5e, 0xe4, 0x3a, 0x8d, + 0xf9, 0xb6, 0x57, 0x6f, 0xf0, 0x94, 0x3c, 0x7d, 0x46, 0x06, 0xd1, 0x63, 0x0b, 0x19, 0x38, 0x38, + 0xb3, 0xa6, 0xf8, 0x14, 0x46, 0xa4, 0x3f, 0xf5, 0x29, 0xac, 0x9e, 0x84, 0xb3, 0xc6, 0xe3, 0x21, + 0x5c, 0xd8, 0x72, 0x5c, 0x8f, 0xd5, 0x1b, 0x48, 0x34, 0x9e, 0x81, 0x83, 0x33, 0x6b, 0xda, 0x3f, + 0x28, 0xc2, 0x28, 0x9d, 0x18, 0xe5, 0x71, 0xf3, 0xb2, 0xe1, 0x71, 0x73, 0x2e, 0xe1, 0x71, 0x33, + 0xa9, 0xe3, 0x6a, 0xfe, 0x35, 0x6f, 0x03, 0xf2, 0x45, 0x52, 0x82, 0x2b, 0xc4, 0x23, 0x7c, 0xc8, + 0x98, 0x92, 0xb1, 0x18, 0xfb, 0xa3, 0xdc, 0x48, 0x61, 0xe0, 0x8c, 0x5a, 0x1f, 0xf9, 0xea, 0x1c, + 0xad, 0xaf, 0xce, 0x6f, 0x5b, 0x6c, 0x05, 0x2c, 0xae, 0x55, 0xb9, 0x13, 0x39, 0xba, 0x04, 0x23, + 0xec, 0x18, 0x63, 0xb1, 0x3c, 0xa4, 0x4b, 0x0b, 0xcb, 0x6e, 0xbb, 0x16, 0x17, 0x63, 0x1d, 0x07, + 0x5d, 0x80, 0xa1, 0x90, 0x38, 0x41, 0x6d, 0x4b, 0x9d, 0xe1, 0xc2, 0xff, 0x84, 0x97, 0x61, 0x05, + 0x45, 0xef, 0xc4, 0x11, 0xe1, 0x8b, 0xf9, 0x1e, 0xe9, 0x7a, 0x7f, 0x38, 0x1f, 0xcc, 0x0f, 0x03, + 0x6f, 0xdf, 0x06, 0x94, 0xc6, 0xef, 0xe1, 0x89, 0x5f, 0xd9, 0x8c, 0x59, 0x3c, 0x9c, 0x8a, 0x57, + 0xfc, 0xb7, 0x16, 0x8c, 0x57, 0xfc, 0x3a, 0xe5, 0xcf, 0x3f, 0x4e, 0xcc, 0x58, 0xcf, 0xe0, 0x31, + 0xd0, 0x21, 0x83, 0xc7, 0x13, 0xd0, 0x5f, 0xf1, 0xeb, 0x5d, 0xe2, 0x2a, 0xff, 0x2b, 0x0b, 0x06, + 0x2b, 0x7e, 0xfd, 0x08, 0xac, 0x6b, 0x6f, 0x98, 0xd6, 0xb5, 0x93, 0x39, 0xeb, 0x26, 0xc7, 0xa0, + 0xf6, 0x7b, 0x7d, 0x30, 0x46, 0xfb, 0xe9, 0x6f, 0xca, 0xa9, 0x34, 0x86, 0xcd, 0xea, 0x61, 0xd8, + 0xe8, 0x5d, 0xcf, 0x6f, 0x34, 0xfc, 0xbb, 0xc9, 0x69, 0x5d, 0x66, 0xa5, 0x58, 0x40, 0xd1, 0xf3, + 0x30, 0xd4, 0x0a, 0xc8, 0x8e, 0xeb, 0x8b, 0x4b, 0x94, 0x66, 0xab, 0xac, 0x88, 0x72, 0xac, 0x30, + 0xd0, 0xcb, 0x30, 0x1a, 0xba, 0x1e, 0x15, 0x18, 0xf9, 0xa9, 0xd4, 0xc7, 0x78, 0x26, 0x4f, 0x33, + 0xa7, 0x95, 0x63, 0x03, 0x0b, 0xdd, 0x86, 0x61, 0xf6, 0x9f, 0xb1, 0x9d, 0xfe, 0x43, 0xb3, 0x1d, + 0x91, 0x43, 0x5c, 0x10, 0xc0, 0x31, 0x2d, 0x7a, 0x16, 0x47, 0x32, 0x55, 0x53, 0x28, 0xe2, 0xeb, + 0xaa, 0xb3, 0x58, 0x25, 0x71, 0x0a, 0xb1, 0x86, 0x85, 0x9e, 0x83, 0xe1, 0xc8, 0x71, 0x1b, 0xd7, + 0x5d, 0x8f, 0x39, 0x69, 0xd0, 0xfe, 0x8b, 0x54, 0xde, 0xa2, 0x10, 0xc7, 0x70, 0x2a, 0xf0, 0xb3, + 0xb0, 0x63, 0xf3, 0xbb, 0x91, 0x48, 0x30, 0x59, 0xe4, 0x02, 0xff, 0x75, 0x55, 0x8a, 0x35, 0x0c, + 0xb4, 0x05, 0xa7, 0x5d, 0x8f, 0xa5, 0x64, 0x23, 0xd5, 0x6d, 0xb7, 0xb5, 0x7e, 0xbd, 0x7a, 0x8b, + 0x04, 0xee, 0xc6, 0xee, 0xbc, 0x53, 0xdb, 0x26, 0x5e, 0x9d, 0xe9, 0x83, 0x86, 0xe6, 0x9f, 0x14, + 0x5d, 0x3c, 0xbd, 0xd2, 0x01, 0x17, 0x77, 0xa4, 0x84, 0x6c, 0xba, 0x1d, 0x03, 0xe2, 0x34, 0x85, + 0xe2, 0x87, 0xa7, 0x73, 0x62, 0x25, 0x58, 0x40, 0xec, 0x97, 0xd8, 0x9e, 0xb8, 0x51, 0x45, 0xcf, + 0x1a, 0xec, 0xe5, 0x84, 0xce, 0x5e, 0x0e, 0xf6, 0xca, 0x03, 0x37, 0xaa, 0x5a, 0x08, 0xaa, 0xcb, + 0x70, 0xbc, 0xe2, 0xd7, 0x2b, 0x7e, 0x10, 0x2d, 0xfb, 0xc1, 0x5d, 0x27, 0xa8, 0xcb, 0x25, 0x58, + 0x96, 0x41, 0xb8, 0x28, 0x8f, 0xed, 0xe7, 0x1c, 0xc8, 0x08, 0xb0, 0xf5, 0x12, 0x13, 0xdd, 0x0f, + 0xf9, 0xe6, 0xb9, 0xc6, 0x84, 0x48, 0x95, 0xf8, 0xf0, 0x8a, 0x13, 0x11, 0x74, 0x03, 0xc6, 0x6a, + 0xfa, 0xb1, 0x2d, 0xaa, 0x3f, 0x23, 0x0f, 0x3b, 0xe3, 0x4c, 0xcf, 0x3c, 0xe7, 0xcd, 0xfa, 0xf6, + 0x77, 0x2c, 0xd1, 0x0a, 0x57, 0x49, 0x71, 0xe7, 0xe6, 0xee, 0x3c, 0x77, 0x01, 0xa6, 0x02, 0xbd, + 0x8a, 0xe6, 0x24, 0x78, 0x9c, 0x67, 0x92, 0x4a, 0x00, 0x71, 0x1a, 0x1f, 0x7d, 0x16, 0x4e, 0x19, + 0x85, 0xd2, 0x5f, 0x42, 0x4b, 0x4d, 0xcf, 0x94, 0x76, 0x38, 0x0f, 0x09, 0xe7, 0xd7, 0xb7, 0x7f, + 0x12, 0x4e, 0x24, 0xbf, 0x4b, 0xa8, 0xd1, 0x1e, 0xf0, 0xeb, 0x0a, 0x87, 0xfb, 0x3a, 0xfb, 0x15, + 0x98, 0xaa, 0xf8, 0x5a, 0x80, 0x11, 0x36, 0x7f, 0xdd, 0xe3, 0x9c, 0xfd, 0xf2, 0x10, 0x3b, 0x06, + 0x13, 0xd9, 0x0c, 0xd1, 0xe7, 0x61, 0x3c, 0x24, 0x2c, 0xb8, 0x9f, 0x54, 0xdf, 0x76, 0x08, 0x58, + 0x50, 0x5d, 0xd2, 0x31, 0xf9, 0x15, 0xd5, 0x2c, 0xc3, 0x09, 0x6a, 0xa8, 0x09, 0xe3, 0x77, 0x5d, + 0xaf, 0xee, 0xdf, 0x0d, 0x25, 0xfd, 0xa1, 0x7c, 0x5b, 0xd0, 0x6d, 0x8e, 0x99, 0xe8, 0xa3, 0xd1, + 0xdc, 0x6d, 0x83, 0x18, 0x4e, 0x10, 0xa7, 0xac, 0x26, 0x68, 0x7b, 0x73, 0xe1, 0xcd, 0x90, 0x04, + 0x22, 0xf4, 0x20, 0x63, 0x35, 0x58, 0x16, 0xe2, 0x18, 0x4e, 0x59, 0x0d, 0xfb, 0xc3, 0x22, 0x1e, + 0x30, 0x5e, 0x26, 0x58, 0x0d, 0x56, 0xa5, 0x58, 0xc3, 0xa0, 0xac, 0x98, 0xfd, 0x5b, 0xf3, 0x3d, + 0xec, 0xfb, 0x91, 0x64, 0xde, 0x2c, 0xe1, 0xac, 0x56, 0x8e, 0x0d, 0xac, 0x9c, 0x40, 0x87, 0x7d, + 0x87, 0x0d, 0x74, 0x88, 0xa2, 0x0e, 0x41, 0x1e, 0x78, 0xa8, 0xee, 0xcb, 0x9d, 0x82, 0x3c, 0x1c, + 0x3c, 0x50, 0x00, 0x08, 0x2a, 0x0b, 0x6c, 0x88, 0x01, 0xea, 0xe7, 0x91, 0x1c, 0x99, 0xb5, 0xba, + 0xca, 0x47, 0x47, 0xc2, 0xd0, 0x12, 0x0c, 0x86, 0xbb, 0x61, 0x2d, 0x6a, 0x84, 0x9d, 0x92, 0x0a, + 0x57, 0x19, 0x8a, 0x96, 0x28, 0x9f, 0x57, 0xc1, 0xb2, 0x2e, 0xaa, 0xc1, 0xb4, 0xa0, 0xb8, 0xb0, + 0xe5, 0x78, 0x2a, 0xe9, 0x28, 0x77, 0x4b, 0xbd, 0xb4, 0xbf, 0x57, 0x9e, 0x16, 0x2d, 0xeb, 0xe0, + 0x83, 0xbd, 0x32, 0xdd, 0x92, 0x19, 0x10, 0x9c, 0x45, 0x8d, 0x2f, 0xf9, 0x5a, 0xcd, 0x6f, 0xb6, + 0x2a, 0x81, 0xbf, 0xe1, 0x36, 0x48, 0x27, 0x8b, 0x7f, 0xd5, 0xc0, 0x14, 0x4b, 0xde, 0x28, 0xc3, + 0x09, 0x6a, 0xe8, 0x0e, 0x4c, 0x38, 0xad, 0xd6, 0x5c, 0xd0, 0xf4, 0x03, 0xd9, 0xc0, 0x48, 0xbe, + 0xe9, 0x68, 0xce, 0x44, 0xe5, 0x39, 0x47, 0x13, 0x85, 0x38, 0x49, 0x90, 0x0e, 0x94, 0xd8, 0x68, + 0xc6, 0x40, 0x8d, 0xc5, 0x03, 0x25, 0xf6, 0x65, 0xc6, 0x40, 0x65, 0x40, 0x70, 0x16, 0x35, 0xfb, + 0xef, 0x32, 0xc1, 0x9f, 0x05, 0x02, 0x67, 0xef, 0xbf, 0x9a, 0x30, 0xd6, 0x62, 0x6c, 0x5f, 0xe4, + 0x03, 0x14, 0xac, 0xe2, 0xe5, 0x1e, 0x35, 0xd4, 0x77, 0x59, 0xc2, 0x63, 0xc3, 0x53, 0xb9, 0xa2, + 0x93, 0xc3, 0x26, 0x75, 0xfb, 0xcf, 0x67, 0x98, 0xe8, 0x58, 0xe5, 0x6a, 0xe7, 0x41, 0xf1, 0x1a, + 0x56, 0x28, 0x9a, 0x66, 0xf2, 0x0d, 0x3c, 0xf1, 0xfa, 0x12, 0x2f, 0x6a, 0xb1, 0xac, 0x8b, 0x3e, + 0x07, 0xe3, 0xae, 0xe7, 0xc6, 0xf9, 0xc7, 0xc3, 0xd2, 0xb1, 0xfc, 0x30, 0x6b, 0x0a, 0x4b, 0xcf, + 0x15, 0xaa, 0x57, 0xc6, 0x09, 0x62, 0xe8, 0x1d, 0xe6, 0xbc, 0x2b, 0x49, 0x17, 0x7a, 0x21, 0xad, + 0xfb, 0xe9, 0x4a, 0xb2, 0x1a, 0x11, 0xd4, 0x86, 0xe9, 0x74, 0x1e, 0xf6, 0xb0, 0x64, 0xe7, 0xdf, + 0x8d, 0xd2, 0xa9, 0xd4, 0xe3, 0xa4, 0x8e, 0x69, 0x58, 0x88, 0xb3, 0xe8, 0xa3, 0xeb, 0xc9, 0x2c, + 0xd9, 0x45, 0xc3, 0x34, 0x94, 0xca, 0x94, 0x3d, 0xd6, 0x31, 0x41, 0xf6, 0x26, 0x9c, 0xd1, 0x52, + 0xfe, 0x5e, 0x09, 0x1c, 0xe6, 0x3c, 0xe6, 0xb2, 0xd3, 0x48, 0x13, 0x6a, 0x1f, 0xdf, 0xdf, 0x2b, + 0x9f, 0x59, 0xef, 0x84, 0x88, 0x3b, 0xd3, 0x41, 0x37, 0xe0, 0x38, 0x0f, 0x12, 0xb4, 0x48, 0x9c, + 0x7a, 0xc3, 0xf5, 0x94, 0xd4, 0xcc, 0x79, 0xd7, 0xa9, 0xfd, 0xbd, 0xf2, 0xf1, 0xb9, 0x2c, 0x04, + 0x9c, 0x5d, 0x0f, 0xbd, 0x01, 0xc3, 0x75, 0x4f, 0x72, 0xd9, 0x01, 0x23, 0xab, 0xf2, 0xf0, 0xe2, + 0x5a, 0x55, 0x7d, 0x7f, 0xfc, 0x07, 0xc7, 0x15, 0xd0, 0x26, 0xb7, 0x4d, 0x2a, 0x85, 0xf2, 0x60, + 0x2a, 0x76, 0x6c, 0xd2, 0xe6, 0x62, 0x44, 0xdd, 0xe0, 0x46, 0x79, 0xf5, 0x32, 0xd3, 0x08, 0xc8, + 0x61, 0x10, 0x46, 0x6f, 0x03, 0x12, 0xa9, 0xb0, 0xe6, 0x6a, 0x2c, 0xd9, 0xa4, 0xe6, 0x30, 0xac, + 0x54, 0x08, 0xd5, 0x14, 0x06, 0xce, 0xa8, 0x85, 0xae, 0x52, 0xf6, 0xa8, 0x97, 0x0a, 0xf6, 0x2b, + 0x55, 0x3d, 0xa5, 0x45, 0xd2, 0x0a, 0x08, 0xf3, 0x71, 0x35, 0x29, 0xe2, 0x44, 0x3d, 0x54, 0x87, + 0xd3, 0x4e, 0x3b, 0xf2, 0x99, 0xd9, 0xd7, 0x44, 0x5d, 0xf7, 0xb7, 0x89, 0xc7, 0x3c, 0x2e, 0x86, + 0x58, 0x4c, 0xda, 0xd3, 0x73, 0x1d, 0xf0, 0x70, 0x47, 0x2a, 0xf4, 0x3a, 0x45, 0xc7, 0x42, 0xb3, + 0xc8, 0x1a, 0x01, 0x04, 0xb8, 0x9b, 0x82, 0xc4, 0x40, 0xaf, 0xc0, 0xc8, 0x96, 0x1f, 0x46, 0x6b, + 0x24, 0xba, 0xeb, 0x07, 0xdb, 0x22, 0xf7, 0x46, 0x9c, 0xef, 0x28, 0x06, 0x61, 0x1d, 0x0f, 0x3d, + 0x03, 0x83, 0xcc, 0x1f, 0x70, 0x65, 0x91, 0x9d, 0xb5, 0x43, 0x31, 0x8f, 0xb9, 0xca, 0x8b, 0xb1, + 0x84, 0x4b, 0xd4, 0x95, 0xca, 0x02, 0x63, 0xc7, 0x09, 0xd4, 0x95, 0xca, 0x02, 0x96, 0x70, 0xba, + 0x5c, 0xc3, 0x2d, 0x27, 0x20, 0x95, 0xc0, 0xaf, 0x91, 0x50, 0xcb, 0xb2, 0xf5, 0x18, 0xcf, 0x2c, + 0x42, 0x97, 0x6b, 0x35, 0x0b, 0x01, 0x67, 0xd7, 0x43, 0x24, 0x9d, 0xee, 0x7a, 0x3c, 0xdf, 0x1e, + 0x9e, 0x16, 0x07, 0x7b, 0xcc, 0x78, 0xed, 0xc1, 0xa4, 0x4a, 0xb4, 0xcd, 0x73, 0x89, 0x84, 0xa5, + 0x89, 0xfc, 0x74, 0xf7, 0x99, 0xcf, 0x60, 0x94, 0x87, 0xc1, 0x4a, 0x82, 0x12, 0x4e, 0xd1, 0x36, + 0x82, 0x1e, 0x4f, 0x76, 0x0d, 0x7a, 0x7c, 0x11, 0x86, 0xc3, 0xf6, 0x9d, 0xba, 0xdf, 0x74, 0x5c, + 0x8f, 0xb9, 0x55, 0x69, 0x17, 0xf7, 0xaa, 0x04, 0xe0, 0x18, 0x07, 0x2d, 0xc3, 0x90, 0x23, 0xdd, + 0x07, 0x50, 0x7e, 0x3c, 0x47, 0xe5, 0x34, 0xc0, 0x43, 0x9c, 0x49, 0x87, 0x01, 0x55, 0x17, 0xbd, + 0x0e, 0x63, 0x22, 0x66, 0x8c, 0x50, 0x55, 0x4f, 0x9b, 0xaf, 0xdc, 0xab, 0x3a, 0x10, 0x9b, 0xb8, + 0xe8, 0x26, 0x8c, 0x44, 0x7e, 0x43, 0xe8, 0x38, 0xc3, 0xd2, 0x89, 0xfc, 0xb0, 0xcb, 0xeb, 0x0a, + 0x4d, 0x37, 0x6c, 0xa9, 0xaa, 0x58, 0xa7, 0x83, 0xd6, 0xf9, 0x7a, 0x67, 0x39, 0xb5, 0x48, 0x58, + 0x3a, 0x99, 0x7f, 0x26, 0xa9, 0xd4, 0x5b, 0xe6, 0x76, 0x10, 0x35, 0xb1, 0x4e, 0x06, 0x5d, 0x81, + 0xa9, 0x56, 0xe0, 0xfa, 0x6c, 0x4d, 0x28, 0x77, 0x88, 0x92, 0x99, 0xf4, 0xb7, 0x92, 0x44, 0xc0, + 0xe9, 0x3a, 0x2c, 0xe4, 0x8f, 0x28, 0x2c, 0x9d, 0xe2, 0x59, 0x00, 0xb9, 0x1e, 0x84, 0x97, 0x61, + 0x05, 0x45, 0xab, 0x8c, 0x13, 0x73, 0x15, 0x5e, 0x69, 0x26, 0x3f, 0x90, 0x84, 0xae, 0xea, 0xe3, + 0xb2, 0xbf, 0xfa, 0x8b, 0x63, 0x0a, 0xa8, 0x0e, 0x71, 0xaa, 0x7f, 0x7a, 0x83, 0x0a, 0x4b, 0xa7, + 0x3b, 0x38, 0x65, 0x27, 0xae, 0xcb, 0xb1, 0x40, 0x60, 0x14, 0x87, 0x38, 0x41, 0x13, 0xbd, 0x05, + 0x93, 0x22, 0x1e, 0x46, 0x3c, 0x4c, 0x67, 0xe2, 0x87, 0x6b, 0x38, 0x01, 0xc3, 0x29, 0x6c, 0x9e, + 0x85, 0xcf, 0xb9, 0xd3, 0x20, 0x82, 0xf5, 0x5d, 0x77, 0xbd, 0xed, 0xb0, 0x74, 0x96, 0xf1, 0x07, + 0x91, 0x85, 0x2f, 0x09, 0xc5, 0x19, 0x35, 0xd0, 0x3a, 0x4c, 0xb6, 0x02, 0x42, 0x9a, 0xec, 0x9e, + 0x24, 0xce, 0xb3, 0x32, 0x8f, 0x78, 0x45, 0x7b, 0x52, 0x49, 0xc0, 0x0e, 0x32, 0xca, 0x70, 0x8a, + 0x02, 0xba, 0x0b, 0x43, 0xfe, 0x0e, 0x09, 0xb6, 0x88, 0x53, 0x2f, 0x9d, 0xeb, 0xf0, 0x9c, 0x52, + 0x1c, 0x6e, 0x37, 0x04, 0x6e, 0xc2, 0xdb, 0x4c, 0x16, 0x77, 0xf7, 0x36, 0x93, 0x8d, 0xa1, 0xff, + 0xc4, 0x82, 0x53, 0xd2, 0x7e, 0x5b, 0x6d, 0xd1, 0x51, 0x5f, 0xf0, 0xbd, 0x30, 0x0a, 0x78, 0x8c, + 0xa6, 0xc7, 0xf3, 0xe3, 0x16, 0xad, 0xe7, 0x54, 0x52, 0x56, 0x84, 0x53, 0x79, 0x18, 0x21, 0xce, + 0x6f, 0x91, 0xde, 0xec, 0x43, 0x12, 0x49, 0x66, 0x34, 0x17, 0x2e, 0xbf, 0xb3, 0xb8, 0x56, 0x7a, + 0x82, 0x07, 0x98, 0xa2, 0x9b, 0xa1, 0x9a, 0x04, 0xe2, 0x34, 0x3e, 0xba, 0x04, 0x05, 0x3f, 0x2c, + 0x3d, 0xc9, 0xd6, 0xf6, 0xa9, 0x9c, 0x71, 0xbc, 0x51, 0xe5, 0x5e, 0xc7, 0x37, 0xaa, 0xb8, 0xe0, + 0x87, 0x32, 0x13, 0x1e, 0xbd, 0xce, 0x86, 0xa5, 0xa7, 0xb8, 0xce, 0x59, 0x66, 0xc2, 0x63, 0x85, + 0x38, 0x86, 0xa3, 0x2d, 0x98, 0x08, 0x0d, 0xb5, 0x41, 0x58, 0x3a, 0xcf, 0x46, 0xea, 0xa9, 0xbc, + 0x49, 0x33, 0xb0, 0xb5, 0x14, 0x55, 0x26, 0x15, 0x9c, 0x24, 0xcb, 0x77, 0x97, 0xa6, 0xb8, 0x08, + 0x4b, 0x4f, 0x77, 0xd9, 0x5d, 0x1a, 0xb2, 0xbe, 0xbb, 0x74, 0x1a, 0x38, 0x41, 0x13, 0xdd, 0xd4, + 0xdf, 0xaa, 0x5e, 0xc8, 0xf7, 0x60, 0xcd, 0x7c, 0xa5, 0x3a, 0x96, 0xfb, 0x42, 0xf5, 0x2d, 0x98, + 0x94, 0x67, 0x09, 0x5d, 0x99, 0x81, 0x5b, 0x27, 0xa5, 0x67, 0xe2, 0x4d, 0x7b, 0x35, 0x01, 0xc3, + 0x29, 0xec, 0x99, 0x9f, 0x80, 0xa9, 0x94, 0x1c, 0x77, 0x98, 0xa7, 0x3f, 0x33, 0xdb, 0x30, 0x66, + 0xec, 0x95, 0x47, 0xea, 0x19, 0xf6, 0x8f, 0x01, 0x86, 0x95, 0xc7, 0x4e, 0x8e, 0xa5, 0x6e, 0xea, + 0x81, 0x2c, 0x75, 0x17, 0x4d, 0xc7, 0xb2, 0x53, 0x49, 0xc7, 0xb2, 0xa1, 0x8a, 0x5f, 0x37, 0x7c, + 0xc9, 0xd6, 0x33, 0x82, 0x43, 0xe7, 0x71, 0xf9, 0xde, 0xdf, 0x3a, 0x6a, 0xc6, 0xae, 0x62, 0xcf, + 0x1e, 0x6a, 0x7d, 0x1d, 0xed, 0x67, 0x57, 0x60, 0xca, 0xf3, 0xd9, 0x45, 0x84, 0xd4, 0xa5, 0x94, + 0xc9, 0x84, 0xc9, 0x61, 0x3d, 0x78, 0x61, 0x02, 0x01, 0xa7, 0xeb, 0xd0, 0x06, 0xb9, 0x34, 0x98, + 0x34, 0xd8, 0x71, 0x61, 0x11, 0x0b, 0x28, 0xbd, 0x00, 0xf3, 0x5f, 0x61, 0x69, 0x32, 0xff, 0x02, + 0xcc, 0x2b, 0x25, 0x25, 0xce, 0x50, 0x4a, 0x9c, 0xcc, 0x3e, 0xd5, 0xf2, 0xeb, 0x2b, 0x15, 0x71, + 0x97, 0xd1, 0xd2, 0x36, 0xd4, 0x57, 0x2a, 0x98, 0xc3, 0xd0, 0x1c, 0x0c, 0xb0, 0x1f, 0x32, 0x28, + 0x54, 0x1e, 0x2f, 0x5a, 0xa9, 0x68, 0xe9, 0x86, 0x59, 0x05, 0x2c, 0x2a, 0x32, 0xfb, 0x03, 0xbd, + 0x00, 0x32, 0xfb, 0xc3, 0xe0, 0x03, 0xda, 0x1f, 0x24, 0x01, 0x1c, 0xd3, 0x42, 0xf7, 0xe0, 0xb8, + 0x71, 0xe9, 0x56, 0x8f, 0x3f, 0x21, 0xdf, 0xff, 0x24, 0x81, 0x3c, 0x7f, 0x46, 0x74, 0xfa, 0xf8, + 0x4a, 0x16, 0x25, 0x9c, 0xdd, 0x00, 0x6a, 0xc0, 0x54, 0x2d, 0xd5, 0xea, 0x50, 0xef, 0xad, 0xaa, + 0x75, 0x91, 0x6e, 0x31, 0x4d, 0x18, 0xbd, 0x0e, 0x43, 0xef, 0xfb, 0xdc, 0x57, 0x54, 0xdc, 0xbf, + 0x64, 0xe8, 0xa2, 0xa1, 0x77, 0x6e, 0x54, 0x59, 0xf9, 0xc1, 0x5e, 0x79, 0xa4, 0xe2, 0xd7, 0xe5, + 0x5f, 0xac, 0x2a, 0xa0, 0x7f, 0x60, 0xc1, 0x4c, 0xfa, 0x56, 0xaf, 0x3a, 0x3d, 0xd6, 0x7b, 0xa7, + 0x6d, 0xd1, 0xe8, 0xcc, 0x52, 0x2e, 0x39, 0xdc, 0xa1, 0x29, 0xf4, 0x49, 0xba, 0x9f, 0x42, 0xf7, + 0x3e, 0x7f, 0xfc, 0xa1, 0xd9, 0xea, 0x31, 0x2b, 0x3d, 0xd8, 0x2b, 0x4f, 0x70, 0xf6, 0xef, 0xde, + 0x57, 0x09, 0x26, 0x78, 0x05, 0xf4, 0x93, 0x70, 0x3c, 0x48, 0x6b, 0xd9, 0x89, 0xbc, 0x69, 0x3c, + 0xdb, 0xcb, 0x51, 0x92, 0x9c, 0x70, 0x9c, 0x45, 0x10, 0x67, 0xb7, 0x63, 0xff, 0x86, 0xc5, 0xac, + 0x2b, 0xa2, 0x5b, 0x24, 0x6c, 0x37, 0xa2, 0x23, 0xf0, 0xcf, 0x5c, 0x32, 0xbc, 0x1b, 0x1e, 0xd8, + 0xc1, 0xf2, 0xbf, 0xb5, 0x98, 0x83, 0xe5, 0x11, 0x3e, 0x15, 0x7d, 0x07, 0x86, 0x22, 0xd1, 0x9a, + 0xe8, 0x7a, 0x9e, 0x33, 0x98, 0xec, 0x14, 0x73, 0x32, 0x55, 0x37, 0x39, 0x59, 0x8a, 0x15, 0x19, + 0xfb, 0xbf, 0xe2, 0x33, 0x20, 0x21, 0x47, 0x60, 0x44, 0x5e, 0x34, 0x8d, 0xc8, 0xe5, 0x2e, 0x5f, + 0x90, 0x63, 0x4c, 0xfe, 0x77, 0x66, 0xbf, 0x99, 0x06, 0xf3, 0xc3, 0xee, 0xd9, 0x6b, 0x7f, 0xd5, + 0x02, 0x88, 0x33, 0xfa, 0xf4, 0x90, 0x9b, 0xfd, 0x32, 0xbd, 0xbb, 0xf9, 0x91, 0x5f, 0xf3, 0x1b, + 0xc2, 0x88, 0x75, 0x3a, 0xb6, 0x63, 0xf3, 0xf2, 0x03, 0xed, 0x37, 0x56, 0xd8, 0xa8, 0x2c, 0x43, + 0x6c, 0x17, 0x63, 0xcf, 0x0a, 0x23, 0xbc, 0xf6, 0x37, 0x2c, 0x38, 0x96, 0xf5, 0xee, 0x08, 0x3d, + 0x0f, 0x43, 0x5c, 0x97, 0xab, 0xbc, 0xae, 0xd5, 0x6c, 0xde, 0x12, 0xe5, 0x58, 0x61, 0xf4, 0x9c, + 0xf4, 0xfe, 0x70, 0xd9, 0x66, 0x6e, 0xc0, 0x58, 0x25, 0x20, 0x9a, 0x7c, 0xf1, 0x66, 0x9c, 0x08, + 0x6b, 0x78, 0xfe, 0xf9, 0x43, 0x07, 0xf3, 0xb2, 0xbf, 0x59, 0x80, 0x63, 0xdc, 0x77, 0x70, 0x6e, + 0xc7, 0x77, 0xeb, 0x15, 0xbf, 0x2e, 0x5e, 0x8b, 0xbf, 0x0b, 0xa3, 0x2d, 0x4d, 0x01, 0xdf, 0x29, + 0x73, 0x82, 0xae, 0xa8, 0x8f, 0x55, 0x86, 0x7a, 0x29, 0x36, 0x68, 0xa1, 0x3a, 0x8c, 0x92, 0x1d, + 0xb7, 0xa6, 0x7c, 0x93, 0x0a, 0x87, 0x3e, 0xa4, 0x55, 0x2b, 0x4b, 0x1a, 0x1d, 0x6c, 0x50, 0xed, + 0xd9, 0xe3, 0x5f, 0x13, 0xd1, 0xfa, 0xba, 0xf8, 0x23, 0xfd, 0x9c, 0x05, 0x27, 0x73, 0xf2, 0x2c, + 0xd0, 0xe6, 0xee, 0x32, 0x2f, 0x4d, 0xb1, 0x6c, 0x55, 0x73, 0xdc, 0x77, 0x13, 0x0b, 0x28, 0xfa, + 0x34, 0x40, 0x2b, 0xce, 0x4e, 0xdb, 0x25, 0x20, 0xbd, 0x11, 0x9a, 0x5a, 0x8b, 0x32, 0xac, 0x92, + 0xd8, 0x6a, 0xb4, 0xec, 0x6f, 0xf4, 0x41, 0x3f, 0x73, 0x03, 0x43, 0x15, 0x18, 0xdc, 0xe2, 0x41, + 0x30, 0x3b, 0xce, 0x1b, 0xc5, 0x95, 0x51, 0x35, 0xe3, 0x79, 0xd3, 0x4a, 0xb1, 0x24, 0x83, 0x56, + 0x61, 0x9a, 0x67, 0xde, 0x6d, 0x2c, 0x92, 0x86, 0xb3, 0x2b, 0x75, 0xdb, 0x05, 0xf6, 0xa9, 0x4a, + 0xc7, 0xbf, 0x92, 0x46, 0xc1, 0x59, 0xf5, 0xd0, 0x9b, 0x30, 0x1e, 0xb9, 0x4d, 0xe2, 0xb7, 0x23, + 0xd3, 0xe3, 0x51, 0x5d, 0xbf, 0xd6, 0x0d, 0x28, 0x4e, 0x60, 0xa3, 0xd7, 0x61, 0xac, 0x95, 0xd2, + 0xe2, 0xf7, 0xc7, 0xea, 0x2e, 0x53, 0x73, 0x6f, 0xe2, 0xb2, 0xa7, 0x47, 0x6d, 0xf6, 0xd0, 0x6a, + 0x7d, 0x2b, 0x20, 0xe1, 0x96, 0xdf, 0xa8, 0x33, 0x09, 0xb8, 0x5f, 0x7b, 0x7a, 0x94, 0x80, 0xe3, + 0x54, 0x0d, 0x4a, 0x65, 0xc3, 0x71, 0x1b, 0xed, 0x80, 0xc4, 0x54, 0x06, 0x4c, 0x2a, 0xcb, 0x09, + 0x38, 0x4e, 0xd5, 0xe8, 0x6e, 0x9e, 0x18, 0x7c, 0x38, 0xe6, 0x09, 0xfb, 0x5f, 0x17, 0xc0, 0x98, + 0xda, 0x1f, 0xe3, 0x44, 0xba, 0x6f, 0x40, 0xdf, 0x66, 0xd0, 0xaa, 0x09, 0x97, 0xc7, 0xcc, 0x2f, + 0xbb, 0x82, 0x2b, 0x0b, 0xfa, 0x97, 0xd1, 0xff, 0x98, 0xd5, 0xa2, 0x7b, 0xfc, 0xb8, 0x70, 0x00, + 0x96, 0x71, 0x72, 0xd5, 0x0b, 0xbf, 0x41, 0x79, 0xe3, 0xef, 0x10, 0x51, 0x5e, 0x3c, 0x53, 0x52, + 0x2e, 0xc4, 0x9a, 0xc9, 0x59, 0xdc, 0xf7, 0x25, 0x15, 0x74, 0x09, 0x46, 0x44, 0x6e, 0x53, 0xf6, + 0x10, 0x8d, 0x6f, 0x26, 0xe6, 0xcd, 0xb8, 0x18, 0x17, 0x63, 0x1d, 0xc7, 0xfe, 0x87, 0x05, 0x98, + 0xce, 0x78, 0x49, 0xcc, 0x8f, 0x91, 0x4d, 0x37, 0x8c, 0x82, 0xdd, 0xe4, 0xe1, 0x84, 0x45, 0x39, + 0x56, 0x18, 0x94, 0x57, 0xf1, 0x83, 0x2a, 0x79, 0x38, 0x89, 0x97, 0x7a, 0x02, 0x7a, 0xb8, 0xc3, + 0x89, 0x1e, 0xdb, 0xed, 0x90, 0xc8, 0xe4, 0x15, 0xea, 0xd8, 0x66, 0xae, 0x0f, 0x0c, 0x42, 0xaf, + 0x80, 0x9b, 0xca, 0x9e, 0xaf, 0x5d, 0x01, 0xb9, 0x45, 0x9f, 0xc3, 0x68, 0xe7, 0x22, 0xe2, 0x39, + 0x5e, 0x24, 0x2e, 0x8a, 0x71, 0x50, 0x73, 0x56, 0x8a, 0x05, 0xd4, 0xfe, 0x7a, 0x11, 0x4e, 0xe5, + 0xc6, 0x16, 0xa0, 0x5d, 0x6f, 0xfa, 0x9e, 0x1b, 0xf9, 0xca, 0x4d, 0x94, 0x07, 0x32, 0x27, 0xad, + 0xad, 0x55, 0x51, 0x8e, 0x15, 0x06, 0x3a, 0x0f, 0xfd, 0x4c, 0xf3, 0x9f, 0xcc, 0x6b, 0x88, 0xe7, + 0x17, 0x79, 0x98, 0x57, 0x0e, 0xd6, 0x4e, 0xf5, 0x62, 0xc7, 0x53, 0xfd, 0x09, 0x2a, 0xc1, 0xf8, + 0x8d, 0xe4, 0x81, 0x42, 0xbb, 0xeb, 0xfb, 0x0d, 0xcc, 0x80, 0xe8, 0x29, 0x31, 0x5e, 0x09, 0xbf, + 0x48, 0xec, 0xd4, 0xfd, 0x50, 0x1b, 0x34, 0xee, 0x83, 0x1d, 0xb8, 0xde, 0x66, 0xd2, 0x5f, 0xf6, + 0x1a, 0x2f, 0xc6, 0x12, 0x4e, 0xf7, 0x52, 0x9c, 0x9e, 0x7d, 0x30, 0x7f, 0x2f, 0xa9, 0x24, 0xec, + 0x5d, 0x33, 0xb3, 0xeb, 0x2b, 0x60, 0xa8, 0xab, 0x78, 0xf2, 0x33, 0x45, 0x98, 0xc0, 0xf3, 0x8b, + 0x1f, 0x4d, 0xc4, 0xcd, 0xf4, 0x44, 0x3c, 0x8c, 0x3c, 0xf9, 0x87, 0x9b, 0x8d, 0x7f, 0x6f, 0xc1, + 0x04, 0xcb, 0xb0, 0x2a, 0x02, 0x03, 0xb9, 0xbe, 0x77, 0x04, 0x57, 0x81, 0x27, 0xa0, 0x3f, 0xa0, + 0x8d, 0x8a, 0x19, 0x54, 0x7b, 0x9c, 0xf5, 0x04, 0x73, 0x18, 0x3a, 0x0d, 0x7d, 0xac, 0x0b, 0x74, + 0xf2, 0x46, 0x39, 0x0b, 0x5e, 0x74, 0x22, 0x07, 0xb3, 0x52, 0x16, 0xa2, 0x14, 0x93, 0x56, 0xc3, + 0xe5, 0x9d, 0x8e, 0xfd, 0x32, 0x3e, 0x1c, 0x51, 0x87, 0x32, 0xbb, 0xf6, 0xc1, 0x42, 0x94, 0x66, + 0x93, 0xec, 0x7c, 0xcd, 0xfe, 0xcb, 0x02, 0x9c, 0xcd, 0xac, 0xd7, 0x73, 0x88, 0xd2, 0xce, 0xb5, + 0x1f, 0x65, 0x3e, 0xc6, 0xe2, 0x11, 0xbe, 0x46, 0xe8, 0xeb, 0x55, 0xfa, 0xef, 0xef, 0x21, 0x72, + 0x68, 0xe6, 0x90, 0x7d, 0x48, 0x22, 0x87, 0x66, 0xf6, 0x2d, 0x47, 0x4d, 0xf0, 0x83, 0x42, 0xce, + 0xb7, 0x30, 0x85, 0xc1, 0x05, 0xca, 0x67, 0x18, 0x30, 0x94, 0x97, 0x70, 0xce, 0x63, 0x78, 0x19, + 0x56, 0x50, 0x34, 0x07, 0x13, 0x4d, 0xd7, 0xa3, 0xcc, 0x67, 0xd7, 0x14, 0xc5, 0x95, 0xc1, 0x66, + 0xd5, 0x04, 0xe3, 0x24, 0x3e, 0x72, 0xb5, 0xa8, 0xa2, 0xfc, 0xeb, 0x5e, 0x3f, 0xd4, 0xae, 0x9b, + 0x35, 0x7d, 0x56, 0xd4, 0x28, 0x66, 0x44, 0x18, 0x5d, 0xd5, 0xf4, 0x44, 0xc5, 0xde, 0xf5, 0x44, + 0xa3, 0xd9, 0x3a, 0xa2, 0x99, 0xd7, 0x61, 0xec, 0x81, 0xed, 0x2c, 0xf6, 0x77, 0x8b, 0xf0, 0x58, + 0x87, 0x6d, 0xcf, 0x79, 0xbd, 0x31, 0x07, 0x1a, 0xaf, 0x4f, 0xcd, 0x43, 0x05, 0x8e, 0x6d, 0xb4, + 0x1b, 0x8d, 0x5d, 0xf6, 0xb6, 0x92, 0xd4, 0x25, 0x86, 0x90, 0x29, 0xd5, 0xeb, 0xab, 0xe5, 0x0c, + 0x1c, 0x9c, 0x59, 0x93, 0x5e, 0xb1, 0xe8, 0x49, 0xb2, 0xab, 0x48, 0x25, 0xae, 0x58, 0x58, 0x07, + 0x62, 0x13, 0x17, 0x5d, 0x81, 0x29, 0x67, 0xc7, 0x71, 0x79, 0x3e, 0x1b, 0x49, 0x80, 0xdf, 0xb1, + 0x94, 0x2e, 0x7a, 0x2e, 0x89, 0x80, 0xd3, 0x75, 0x72, 0x4c, 0x42, 0xc5, 0x07, 0x32, 0x09, 0x99, + 0xf1, 0x2d, 0x07, 0xf2, 0xe3, 0x5b, 0x76, 0xe6, 0x8b, 0x5d, 0x53, 0x81, 0xbe, 0x07, 0x63, 0x87, + 0xf5, 0x3d, 0x7f, 0x06, 0x06, 0x03, 0x9e, 0x6b, 0x3e, 0xf9, 0x64, 0x50, 0xa6, 0xa0, 0x97, 0x70, + 0xfb, 0x7f, 0xb5, 0x40, 0xe9, 0x92, 0xcd, 0x50, 0xf6, 0xaf, 0x33, 0x47, 0x7a, 0xae, 0x05, 0xd7, + 0x9e, 0x2b, 0x1e, 0xd7, 0x1c, 0xe9, 0x63, 0x20, 0x36, 0x71, 0xf9, 0x72, 0x0b, 0xe3, 0xa0, 0x29, + 0xc6, 0x05, 0x42, 0xd8, 0x30, 0x15, 0x06, 0xfa, 0x0c, 0x0c, 0xd6, 0xdd, 0x1d, 0x37, 0x14, 0x7a, + 0xb4, 0x43, 0xdb, 0x00, 0xe3, 0xef, 0x5b, 0xe4, 0x64, 0xb0, 0xa4, 0x67, 0xff, 0x23, 0x0b, 0x94, + 0xf1, 0xf5, 0x2a, 0x71, 0x1a, 0xd1, 0x16, 0x7a, 0x0b, 0x40, 0x52, 0x50, 0xba, 0x37, 0xe9, 0x12, + 0x06, 0x58, 0x41, 0x0e, 0x8c, 0x7f, 0x58, 0xab, 0x83, 0xde, 0x84, 0x81, 0x2d, 0x46, 0x4b, 0x7c, + 0xdb, 0x79, 0x65, 0xea, 0x62, 0xa5, 0x07, 0x7b, 0xe5, 0x63, 0x66, 0x9b, 0xf2, 0x14, 0xe3, 0xb5, + 0xec, 0x9f, 0x29, 0xc4, 0x73, 0xfa, 0x4e, 0xdb, 0x8f, 0x9c, 0x23, 0x90, 0x44, 0xae, 0x18, 0x92, + 0xc8, 0x53, 0x9d, 0xac, 0xcb, 0xac, 0x4b, 0xb9, 0x12, 0xc8, 0x8d, 0x84, 0x04, 0xf2, 0x74, 0x77, + 0x52, 0x9d, 0x25, 0x8f, 0xff, 0xda, 0x82, 0x29, 0x03, 0xff, 0x08, 0x0e, 0xc0, 0x65, 0xf3, 0x00, + 0x7c, 0xbc, 0xeb, 0x37, 0xe4, 0x1c, 0x7c, 0x3f, 0x5d, 0x4c, 0xf4, 0x9d, 0x1d, 0x78, 0xef, 0x43, + 0xdf, 0x96, 0x13, 0xd4, 0xc5, 0xbd, 0xfe, 0x62, 0x4f, 0x63, 0x3d, 0x7b, 0xd5, 0x09, 0x84, 0x3b, + 0xc9, 0xf3, 0x72, 0xd4, 0x69, 0x51, 0x57, 0x57, 0x12, 0xd6, 0x14, 0xba, 0x0c, 0x03, 0x61, 0xcd, + 0x6f, 0xa9, 0x57, 0x89, 0x2c, 0x3f, 0x7e, 0x95, 0x95, 0x1c, 0xec, 0x95, 0x91, 0xd9, 0x1c, 0x2d, + 0xc6, 0x02, 0x1f, 0xbd, 0x0b, 0x63, 0xec, 0x97, 0xf2, 0xed, 0x2c, 0xe6, 0x6b, 0x60, 0xaa, 0x3a, + 0x22, 0x77, 0x7c, 0x36, 0x8a, 0xb0, 0x49, 0x6a, 0x66, 0x13, 0x86, 0xd5, 0x67, 0x3d, 0x52, 0xcb, + 0xff, 0x1f, 0x15, 0x61, 0x3a, 0x63, 0xcd, 0xa1, 0xd0, 0x98, 0x89, 0x4b, 0x3d, 0x2e, 0xd5, 0x0f, + 0x38, 0x17, 0x21, 0xbb, 0x00, 0xd6, 0xc5, 0xda, 0xea, 0xb9, 0xd1, 0x9b, 0x21, 0x49, 0x36, 0x4a, + 0x8b, 0xba, 0x37, 0x4a, 0x1b, 0x3b, 0xb2, 0xa1, 0xa6, 0x0d, 0xa9, 0x9e, 0x3e, 0xd2, 0x39, 0xfd, + 0xed, 0x3e, 0x38, 0x96, 0xe5, 0xf0, 0x82, 0xbe, 0x04, 0x03, 0xec, 0xd9, 0x9c, 0x54, 0x9c, 0xbd, + 0xdc, 0xab, 0xab, 0xcc, 0x2c, 0x7b, 0x79, 0x27, 0xa2, 0x21, 0xcf, 0x4a, 0x76, 0xc4, 0x0b, 0xbb, + 0x0e, 0xb3, 0x68, 0x93, 0x45, 0x29, 0x13, 0xa7, 0xa7, 0x64, 0x1f, 0x9f, 0xe8, 0xb9, 0x03, 0xe2, + 0xfc, 0x0d, 0x13, 0x7e, 0x63, 0xb2, 0xb8, 0xbb, 0xdf, 0x98, 0x6c, 0x19, 0xad, 0xc0, 0x40, 0x8d, + 0x3b, 0x24, 0x15, 0xbb, 0xb3, 0x30, 0xee, 0x8d, 0xa4, 0x18, 0xb0, 0xf0, 0x42, 0x12, 0x04, 0x66, + 0x5c, 0x18, 0xd1, 0x06, 0xe6, 0x91, 0x2e, 0x9e, 0x6d, 0x7a, 0xf0, 0x69, 0x43, 0xf0, 0x48, 0x17, + 0xd0, 0x3f, 0xd5, 0xce, 0x7e, 0xc1, 0x0f, 0x3e, 0x6e, 0xc8, 0x4e, 0xa7, 0x13, 0x8f, 0x19, 0x13, + 0xfb, 0x8a, 0xc9, 0x52, 0x55, 0x33, 0x8d, 0x40, 0x6e, 0x2e, 0x34, 0xf3, 0xc0, 0xef, 0x9c, 0x3a, + 0xc0, 0xfe, 0x39, 0x0b, 0x12, 0xcf, 0xcd, 0x94, 0xba, 0xd3, 0xca, 0x55, 0x77, 0x9e, 0x83, 0xbe, + 0xc0, 0x6f, 0x48, 0x79, 0x4a, 0x61, 0x60, 0xbf, 0x41, 0x30, 0x83, 0x50, 0x8c, 0x28, 0x56, 0x62, + 0x8d, 0xea, 0x17, 0x74, 0x71, 0xf5, 0x7e, 0x02, 0xfa, 0x1b, 0x64, 0x87, 0x34, 0x92, 0x29, 0x81, + 0xaf, 0xd3, 0x42, 0xcc, 0x61, 0xf6, 0xbf, 0xef, 0x83, 0x33, 0x1d, 0x83, 0x19, 0x52, 0x01, 0x73, + 0xd3, 0x89, 0xc8, 0x5d, 0x67, 0x37, 0x99, 0x0a, 0xf3, 0x0a, 0x2f, 0xc6, 0x12, 0xce, 0x9e, 0x7e, + 0xf3, 0xf4, 0x4e, 0x09, 0xe5, 0xb0, 0xc8, 0xea, 0x24, 0xa0, 0xa6, 0xb2, 0xb1, 0xf8, 0x30, 0x94, + 0x8d, 0x2f, 0x02, 0x84, 0x61, 0x83, 0x7b, 0x95, 0xd6, 0xc5, 0x9b, 0xf2, 0x38, 0xd8, 0x46, 0xf5, + 0xba, 0x80, 0x60, 0x0d, 0x0b, 0x2d, 0xc2, 0x64, 0x2b, 0xf0, 0x23, 0xae, 0x6b, 0x5f, 0xe4, 0x8e, + 0xd7, 0xfd, 0x66, 0x1c, 0xb9, 0x4a, 0x02, 0x8e, 0x53, 0x35, 0xd0, 0x2b, 0x30, 0x22, 0x62, 0xcb, + 0x55, 0x7c, 0xbf, 0x21, 0xd4, 0x7b, 0xca, 0x17, 0xb9, 0x1a, 0x83, 0xb0, 0x8e, 0xa7, 0x55, 0x63, + 0x0a, 0xfc, 0xc1, 0xcc, 0x6a, 0x5c, 0x89, 0xaf, 0xe1, 0x25, 0xf2, 0x50, 0x0c, 0xf5, 0x94, 0x87, + 0x22, 0x56, 0x78, 0x0e, 0xf7, 0x6c, 0x4f, 0x86, 0xae, 0x2a, 0xc2, 0x6f, 0xf5, 0xc1, 0xb4, 0x58, + 0x38, 0x8f, 0x7a, 0xb9, 0xdc, 0x4c, 0x2f, 0x97, 0x87, 0xa1, 0x12, 0xfd, 0x68, 0xcd, 0x1c, 0xf5, + 0x9a, 0xf9, 0x59, 0x0b, 0x4c, 0x19, 0x12, 0xfd, 0x47, 0xb9, 0xb9, 0x84, 0x5f, 0xc9, 0x95, 0x49, + 0xe3, 0x20, 0xf5, 0x1f, 0x2c, 0xab, 0xb0, 0xfd, 0x3f, 0x5b, 0xf0, 0x78, 0x57, 0x8a, 0x68, 0x09, + 0x86, 0x99, 0xa0, 0xab, 0xdd, 0x8b, 0x9f, 0x56, 0x0f, 0x33, 0x24, 0x20, 0x47, 0xee, 0x8e, 0x6b, + 0xa2, 0xa5, 0x54, 0xd2, 0xe6, 0x67, 0x32, 0x92, 0x36, 0x1f, 0x37, 0x86, 0xe7, 0x01, 0xb3, 0x36, + 0x7f, 0x8d, 0x9e, 0x38, 0xe6, 0xeb, 0xce, 0x4f, 0x18, 0xea, 0x5c, 0x3b, 0xa1, 0xce, 0x45, 0x26, + 0xb6, 0x76, 0x86, 0xbc, 0x05, 0x93, 0x2c, 0xe8, 0x2c, 0x7b, 0x26, 0x24, 0x9e, 0x85, 0x16, 0x62, + 0xaf, 0xe2, 0xeb, 0x09, 0x18, 0x4e, 0x61, 0xdb, 0x7f, 0x51, 0x84, 0x01, 0xbe, 0xfd, 0x8e, 0xe0, + 0xe2, 0xfb, 0x1c, 0x0c, 0xbb, 0xcd, 0x66, 0x9b, 0xe7, 0xe1, 0xed, 0x8f, 0x1d, 0xcb, 0x57, 0x64, + 0x21, 0x8e, 0xe1, 0x68, 0x59, 0x58, 0x12, 0x3a, 0xc4, 0xb5, 0xe7, 0x1d, 0x9f, 0x5d, 0x74, 0x22, + 0x87, 0x4b, 0x71, 0xea, 0x9c, 0x8d, 0x6d, 0x0e, 0xe8, 0xf3, 0x00, 0x61, 0x14, 0xb8, 0xde, 0x26, + 0x2d, 0x13, 0xc9, 0x4f, 0x9e, 0xed, 0x40, 0xad, 0xaa, 0x90, 0x39, 0xcd, 0x98, 0xe7, 0x28, 0x00, + 0xd6, 0x28, 0xa2, 0x59, 0xe3, 0xa4, 0x9f, 0x49, 0xcc, 0x1d, 0x70, 0xaa, 0xf1, 0x9c, 0xcd, 0xbc, + 0x0a, 0xc3, 0x8a, 0x78, 0x37, 0xbd, 0xe2, 0xa8, 0x2e, 0xb0, 0x7d, 0x0a, 0x26, 0x12, 0x7d, 0x3b, + 0x94, 0x5a, 0xf2, 0xd7, 0x2c, 0x98, 0xe0, 0x9d, 0x59, 0xf2, 0x76, 0xc4, 0x69, 0x70, 0x1f, 0x8e, + 0x35, 0x32, 0xb8, 0xb2, 0x98, 0xfe, 0xde, 0xb9, 0xb8, 0x52, 0x43, 0x66, 0x41, 0x71, 0x66, 0x1b, + 0xe8, 0x02, 0xdd, 0x71, 0x94, 0xeb, 0x3a, 0x0d, 0x11, 0xdb, 0x64, 0x94, 0xef, 0x36, 0x5e, 0x86, + 0x15, 0xd4, 0xfe, 0x13, 0x0b, 0xa6, 0x78, 0xcf, 0xaf, 0x91, 0x5d, 0xc5, 0x9b, 0x7e, 0x98, 0x7d, + 0x17, 0x19, 0xe0, 0x0b, 0x39, 0x19, 0xe0, 0xf5, 0x4f, 0x2b, 0x76, 0xfc, 0xb4, 0x6f, 0x5a, 0x20, + 0x56, 0xc8, 0x11, 0x68, 0x5a, 0x7e, 0xc2, 0xd4, 0xb4, 0xcc, 0xe4, 0x6f, 0x82, 0x1c, 0x15, 0xcb, + 0xdf, 0x5a, 0x30, 0xc9, 0x11, 0xb4, 0x40, 0x6a, 0x3f, 0xcc, 0x79, 0x98, 0x37, 0xbf, 0x28, 0xd3, + 0xad, 0xf5, 0x1a, 0xd9, 0x5d, 0xf7, 0x2b, 0x4e, 0xb4, 0x95, 0xfd, 0x51, 0xc6, 0x64, 0xf5, 0x75, + 0x9c, 0xac, 0xba, 0xdc, 0x40, 0x46, 0xae, 0xcf, 0x2e, 0x0a, 0xe0, 0xc3, 0xe6, 0xfa, 0xb4, 0xbf, + 0x6f, 0x01, 0xe2, 0xcd, 0x18, 0x82, 0x1b, 0x15, 0x87, 0x58, 0x69, 0x66, 0xbc, 0x3a, 0x05, 0xc1, + 0x1a, 0xd6, 0x43, 0x19, 0x9e, 0x84, 0x2b, 0x4b, 0xb1, 0xbb, 0x2b, 0xcb, 0x21, 0x46, 0xf4, 0x9b, + 0x83, 0x90, 0x7c, 0x18, 0x8a, 0x6e, 0xc1, 0x68, 0xcd, 0x69, 0x39, 0x77, 0xdc, 0x86, 0x1b, 0xb9, + 0x24, 0xec, 0xe4, 0xe7, 0xb6, 0xa0, 0xe1, 0x09, 0xe7, 0x03, 0xad, 0x04, 0x1b, 0x74, 0xd0, 0x2c, + 0x40, 0x2b, 0x70, 0x77, 0xdc, 0x06, 0xd9, 0x64, 0x0a, 0x21, 0x16, 0x4d, 0x89, 0x3b, 0xdd, 0xc9, + 0x52, 0xac, 0x61, 0x64, 0x04, 0x31, 0x29, 0x3e, 0xe2, 0x20, 0x26, 0x70, 0x64, 0x41, 0x4c, 0xfa, + 0x0e, 0x15, 0xc4, 0x64, 0xe8, 0xd0, 0x41, 0x4c, 0xfa, 0x7b, 0x0a, 0x62, 0x82, 0xe1, 0x84, 0x94, + 0x3d, 0xe9, 0xff, 0x65, 0xb7, 0x41, 0xc4, 0x85, 0x83, 0x87, 0x80, 0x9a, 0xd9, 0xdf, 0x2b, 0x9f, + 0xc0, 0x99, 0x18, 0x38, 0xa7, 0x26, 0xfa, 0x34, 0x94, 0x9c, 0x46, 0xc3, 0xbf, 0xab, 0x26, 0x75, + 0x29, 0xac, 0x39, 0x8d, 0x38, 0x32, 0xe0, 0xd0, 0xfc, 0xe9, 0xfd, 0xbd, 0x72, 0x69, 0x2e, 0x07, + 0x07, 0xe7, 0xd6, 0x46, 0x6f, 0xc0, 0x70, 0x2b, 0xf0, 0x6b, 0xab, 0xda, 0xeb, 0xf5, 0xb3, 0x74, + 0x00, 0x2b, 0xb2, 0xf0, 0x60, 0xaf, 0x3c, 0xa6, 0xfe, 0xb0, 0x03, 0x3f, 0xae, 0x90, 0x11, 0x1f, + 0x64, 0xe4, 0x51, 0xc7, 0x07, 0x19, 0x7d, 0xc8, 0xf1, 0x41, 0xec, 0x6d, 0x98, 0xae, 0x92, 0xc0, + 0x75, 0x1a, 0xee, 0x7d, 0x2a, 0x93, 0x4b, 0x1e, 0xb8, 0x0e, 0xc3, 0x41, 0x82, 0xeb, 0xf7, 0x14, + 0xcf, 0x5e, 0xd3, 0xcb, 0x48, 0x2e, 0x1f, 0x13, 0xb2, 0xff, 0x5f, 0x0b, 0x06, 0xc5, 0x63, 0xd3, + 0x23, 0x90, 0x4c, 0xe7, 0x0c, 0x93, 0x4c, 0x39, 0x7b, 0x52, 0x58, 0x67, 0x72, 0x8d, 0x31, 0x2b, + 0x09, 0x63, 0xcc, 0xe3, 0x9d, 0x88, 0x74, 0x36, 0xc3, 0xfc, 0x67, 0x45, 0x7a, 0x43, 0x30, 0xc2, + 0x1e, 0x3c, 0xfa, 0x21, 0x58, 0x83, 0xc1, 0x50, 0x3c, 0xbb, 0x2f, 0xe4, 0xbf, 0xe5, 0x49, 0x4e, + 0x62, 0xec, 0x03, 0x29, 0x1e, 0xda, 0x4b, 0x22, 0x99, 0xef, 0xf9, 0x8b, 0x8f, 0xf0, 0x3d, 0x7f, + 0xb7, 0xc0, 0x10, 0x7d, 0x0f, 0x23, 0x30, 0x84, 0xfd, 0x6d, 0x76, 0x3a, 0xeb, 0xe5, 0x47, 0x20, + 0xb8, 0x5d, 0x31, 0xcf, 0x71, 0xbb, 0xc3, 0xca, 0x12, 0x9d, 0xca, 0x11, 0xe0, 0x7e, 0xd5, 0x82, + 0x33, 0x19, 0x5f, 0xa5, 0x49, 0x73, 0xcf, 0xc3, 0x90, 0xd3, 0xae, 0xbb, 0x6a, 0x2f, 0x6b, 0xd6, + 0xe2, 0x39, 0x51, 0x8e, 0x15, 0x06, 0x5a, 0x80, 0x29, 0x92, 0x0a, 0x71, 0xcb, 0x23, 0x64, 0xb1, + 0x17, 0xca, 0xe9, 0xf8, 0xb6, 0x69, 0x7c, 0x15, 0x5c, 0xae, 0x98, 0x1b, 0x5c, 0xee, 0xdf, 0x58, + 0x30, 0xa2, 0x1e, 0x9e, 0x3f, 0xf2, 0xd1, 0x7e, 0xcb, 0x1c, 0xed, 0xc7, 0x3a, 0x8c, 0x76, 0xce, + 0x30, 0xff, 0x71, 0x41, 0xf5, 0xb7, 0xe2, 0x07, 0x51, 0x0f, 0x52, 0xe2, 0x83, 0x3f, 0x7b, 0xb9, + 0x04, 0x23, 0x4e, 0xab, 0x25, 0x01, 0xd2, 0x7f, 0x91, 0x65, 0x27, 0x89, 0x8b, 0xb1, 0x8e, 0xa3, + 0x5e, 0xe1, 0x14, 0x73, 0x5f, 0xe1, 0xd4, 0x01, 0x22, 0x27, 0xd8, 0x24, 0x11, 0x2d, 0x13, 0xee, + 0xd6, 0xf9, 0xfc, 0xa6, 0x1d, 0xb9, 0x8d, 0x59, 0xd7, 0x8b, 0xc2, 0x28, 0x98, 0x5d, 0xf1, 0xa2, + 0x1b, 0x01, 0xbf, 0xa6, 0x6a, 0x21, 0x1c, 0x15, 0x2d, 0xac, 0xd1, 0x95, 0x41, 0x56, 0x58, 0x1b, + 0xfd, 0xa6, 0x23, 0xcc, 0x9a, 0x28, 0xc7, 0x0a, 0xc3, 0x7e, 0x95, 0x9d, 0x3e, 0x6c, 0x4c, 0x0f, + 0x17, 0x9a, 0xf0, 0x2f, 0x47, 0xd5, 0x6c, 0x30, 0x93, 0xf0, 0xa2, 0x1e, 0x00, 0xb1, 0x33, 0xb3, + 0xa7, 0x0d, 0xeb, 0xef, 0x59, 0xe3, 0x28, 0x89, 0xe8, 0xb3, 0x29, 0xe7, 0xa6, 0x17, 0xba, 0x9c, + 0x1a, 0x87, 0x70, 0x67, 0x62, 0xa9, 0x0a, 0x59, 0x22, 0xb7, 0x95, 0x8a, 0xd8, 0x17, 0x5a, 0xaa, + 0x42, 0x01, 0xc0, 0x31, 0x0e, 0x15, 0xd8, 0xd4, 0x9f, 0xb0, 0x84, 0xe2, 0x88, 0xf6, 0x0a, 0x3b, + 0xc4, 0x1a, 0x06, 0xba, 0x28, 0x94, 0x16, 0xdc, 0xf6, 0xf0, 0x58, 0x42, 0x69, 0x21, 0x87, 0x4b, + 0xd3, 0x34, 0x5d, 0x82, 0x11, 0x72, 0x2f, 0x22, 0x81, 0xe7, 0x34, 0x68, 0x0b, 0xfd, 0x71, 0x7c, + 0xde, 0xa5, 0xb8, 0x18, 0xeb, 0x38, 0x68, 0x1d, 0x26, 0x42, 0xae, 0xcb, 0x53, 0x79, 0x54, 0xb8, + 0x4e, 0xf4, 0x59, 0xf5, 0xe4, 0xdf, 0x04, 0x1f, 0xb0, 0x22, 0xce, 0x9d, 0x64, 0x20, 0x94, 0x24, + 0x09, 0xf4, 0x26, 0x8c, 0x37, 0x7c, 0xa7, 0x3e, 0xef, 0x34, 0x1c, 0xaf, 0xc6, 0xc6, 0x67, 0xc8, + 0x88, 0x86, 0x39, 0x7e, 0xdd, 0x80, 0xe2, 0x04, 0x36, 0x15, 0x10, 0xf5, 0x12, 0x91, 0xfb, 0xc7, + 0xf1, 0x36, 0x49, 0x58, 0x1a, 0x66, 0x5f, 0xc5, 0x04, 0xc4, 0xeb, 0x39, 0x38, 0x38, 0xb7, 0x36, + 0xba, 0x0c, 0xa3, 0xf2, 0xf3, 0xb5, 0xb8, 0x41, 0xf1, 0x83, 0x26, 0x0d, 0x86, 0x0d, 0x4c, 0x14, + 0xc2, 0x71, 0xf9, 0x7f, 0x3d, 0x70, 0x36, 0x36, 0xdc, 0x9a, 0x08, 0xa6, 0xc1, 0x1f, 0x7f, 0x7f, + 0x4a, 0xbe, 0x34, 0x5d, 0xca, 0x42, 0x3a, 0xd8, 0x2b, 0x9f, 0x16, 0xa3, 0x96, 0x09, 0xc7, 0xd9, + 0xb4, 0xd1, 0x2a, 0x4c, 0x73, 0x1f, 0x98, 0x85, 0x2d, 0x52, 0xdb, 0x96, 0x1b, 0x8e, 0x49, 0x8d, + 0xda, 0xc3, 0x9f, 0xab, 0x69, 0x14, 0x9c, 0x55, 0x0f, 0xbd, 0x07, 0xa5, 0x56, 0xfb, 0x4e, 0xc3, + 0x0d, 0xb7, 0xd6, 0xfc, 0x88, 0xb9, 0x90, 0xcd, 0xd5, 0xeb, 0x01, 0x09, 0xf9, 0xdb, 0x60, 0x76, + 0xf4, 0xca, 0x58, 0x4f, 0x95, 0x1c, 0x3c, 0x9c, 0x4b, 0x01, 0xdd, 0x87, 0xe3, 0x89, 0x85, 0x20, + 0x82, 0xb6, 0x8c, 0xe7, 0x67, 0x51, 0xab, 0x66, 0x55, 0x10, 0xf1, 0x8f, 0xb2, 0x40, 0x38, 0xbb, + 0x09, 0xf4, 0x1a, 0x80, 0xdb, 0x5a, 0x76, 0x9a, 0x6e, 0x83, 0x5e, 0x47, 0xa7, 0xd9, 0x1a, 0xa1, + 0x57, 0x13, 0x58, 0xa9, 0xc8, 0x52, 0xca, 0x9b, 0xc5, 0xbf, 0x5d, 0xac, 0x61, 0xa3, 0xeb, 0x30, + 0x2e, 0xfe, 0xed, 0x8a, 0x29, 0x9d, 0x52, 0x09, 0x77, 0xc7, 0x65, 0x0d, 0x35, 0x8f, 0x89, 0x12, + 0x9c, 0xa8, 0x8b, 0x36, 0xe1, 0x8c, 0xcc, 0xf6, 0xab, 0xaf, 0x4f, 0x39, 0x07, 0x21, 0x4b, 0x5d, + 0x36, 0xc4, 0xdf, 0x14, 0xcd, 0x75, 0x42, 0xc4, 0x9d, 0xe9, 0xd0, 0x73, 0x5d, 0x5f, 0xe6, 0xfc, + 0xc5, 0xf8, 0xf1, 0x38, 0xa6, 0xe8, 0xf5, 0x24, 0x10, 0xa7, 0xf1, 0x91, 0x0f, 0xc7, 0x5d, 0x2f, + 0x6b, 0x55, 0x9f, 0x60, 0x84, 0x3e, 0xc9, 0x1f, 0xcb, 0x77, 0x5e, 0xd1, 0x99, 0x70, 0x9c, 0x4d, + 0x17, 0xad, 0xc0, 0x74, 0xc4, 0x0b, 0x16, 0xdd, 0x90, 0x67, 0x46, 0xa2, 0xd7, 0xbe, 0x93, 0xac, + 0xb9, 0x93, 0x74, 0x35, 0xaf, 0xa7, 0xc1, 0x38, 0xab, 0xce, 0x07, 0x73, 0x00, 0xfd, 0x8e, 0x45, + 0x6b, 0x6b, 0x82, 0x3e, 0xfa, 0x02, 0x8c, 0xea, 0xe3, 0x23, 0x84, 0x96, 0xf3, 0xd9, 0x72, 0xb0, + 0xc6, 0x5e, 0xf8, 0x35, 0x41, 0xb1, 0x10, 0x1d, 0x86, 0x0d, 0x8a, 0xa8, 0x96, 0x11, 0xe4, 0xe2, + 0x62, 0x6f, 0x42, 0x51, 0xef, 0xfe, 0x8f, 0x04, 0xb2, 0x77, 0x0e, 0xba, 0x0e, 0x43, 0xb5, 0x86, + 0x4b, 0xbc, 0x68, 0xa5, 0xd2, 0x29, 0xd4, 0xeb, 0x82, 0xc0, 0x11, 0x5b, 0x51, 0x24, 0x34, 0xe3, + 0x65, 0x58, 0x51, 0xb0, 0x2f, 0xc3, 0x48, 0xb5, 0x41, 0x48, 0x8b, 0xbf, 0xe3, 0x42, 0xcf, 0xb0, + 0x8b, 0x09, 0x13, 0x2d, 0x2d, 0x26, 0x5a, 0xea, 0x77, 0x0e, 0x26, 0x54, 0x4a, 0xb8, 0xfd, 0xbb, + 0x05, 0x28, 0x77, 0xc9, 0xab, 0x97, 0xb0, 0xb7, 0x59, 0x3d, 0xd9, 0xdb, 0xe6, 0x60, 0x22, 0xfe, + 0xa7, 0xab, 0xf2, 0x94, 0x33, 0xf4, 0x2d, 0x13, 0x8c, 0x93, 0xf8, 0x3d, 0xbf, 0x6b, 0xd1, 0x4d, + 0x76, 0x7d, 0x5d, 0x5f, 0x66, 0x19, 0xa6, 0xfa, 0xfe, 0xde, 0xef, 0xde, 0xb9, 0x66, 0x57, 0xfb, + 0xdb, 0x05, 0x38, 0xae, 0x86, 0xf0, 0xc7, 0x77, 0xe0, 0x6e, 0xa6, 0x07, 0xee, 0x21, 0x18, 0xad, + 0xed, 0x1b, 0x30, 0xc0, 0xe3, 0xcf, 0xf6, 0x20, 0xf3, 0x3f, 0x61, 0xa6, 0x02, 0x50, 0x62, 0xa6, + 0x91, 0x0e, 0xe0, 0x1f, 0x58, 0x30, 0x91, 0x78, 0x20, 0x89, 0xb0, 0xf6, 0x8a, 0xfe, 0x41, 0xe4, + 0xf2, 0x2c, 0x89, 0xff, 0x1c, 0xf4, 0x6d, 0xf9, 0xca, 0x49, 0x59, 0x61, 0x5c, 0xf5, 0xc3, 0x08, + 0x33, 0x88, 0xfd, 0xa7, 0x16, 0xf4, 0xaf, 0x3b, 0xae, 0x17, 0x49, 0xeb, 0x87, 0x95, 0x63, 0xfd, + 0xe8, 0xe5, 0xbb, 0xd0, 0x2b, 0x30, 0x40, 0x36, 0x36, 0x48, 0x2d, 0x12, 0xb3, 0x2a, 0xa3, 0x69, + 0x0c, 0x2c, 0xb1, 0x52, 0x2a, 0x84, 0xb2, 0xc6, 0xf8, 0x5f, 0x2c, 0x90, 0xd1, 0x6d, 0x18, 0x8e, + 0xdc, 0x26, 0x99, 0xab, 0xd7, 0x85, 0x4f, 0xc0, 0x03, 0x84, 0x80, 0x59, 0x97, 0x04, 0x70, 0x4c, + 0xcb, 0xfe, 0x7a, 0x01, 0x20, 0x8e, 0x77, 0xd7, 0xed, 0x13, 0xe7, 0x53, 0xd6, 0xe2, 0xf3, 0x19, + 0xd6, 0x62, 0x14, 0x13, 0xcc, 0x30, 0x15, 0xab, 0x61, 0x2a, 0xf6, 0x34, 0x4c, 0x7d, 0x87, 0x19, + 0xa6, 0x05, 0x98, 0x8a, 0xe3, 0xf5, 0x99, 0xe1, 0x4a, 0xd9, 0xf9, 0xbd, 0x9e, 0x04, 0xe2, 0x34, + 0xbe, 0x4d, 0xe0, 0x9c, 0x0a, 0x5b, 0x26, 0xce, 0x42, 0xf6, 0x94, 0x40, 0xb7, 0xbe, 0x77, 0x19, + 0xa7, 0xd8, 0x1c, 0x5e, 0xc8, 0x35, 0x87, 0xff, 0x73, 0x0b, 0x8e, 0x25, 0xdb, 0x61, 0xef, 0xee, + 0xbf, 0x6a, 0xc1, 0xf1, 0x38, 0xad, 0x54, 0xda, 0x05, 0xe1, 0xe5, 0x8e, 0xa1, 0xd8, 0x72, 0x7a, + 0x1c, 0x87, 0x6d, 0x59, 0xcd, 0x22, 0x8d, 0xb3, 0x5b, 0xb4, 0xff, 0x9f, 0x3e, 0x28, 0xe5, 0xc5, + 0x70, 0x63, 0x2f, 0x8d, 0x9c, 0x7b, 0xd5, 0x6d, 0x72, 0x57, 0xbc, 0xe7, 0x88, 0x5f, 0x1a, 0xf1, + 0x62, 0x2c, 0xe1, 0xc9, 0x4c, 0x62, 0x85, 0x1e, 0x33, 0x89, 0x6d, 0xc1, 0xd4, 0xdd, 0x2d, 0xe2, + 0xdd, 0xf4, 0x42, 0x27, 0x72, 0xc3, 0x0d, 0x97, 0x19, 0xd0, 0xf9, 0xba, 0x79, 0x4d, 0xbe, 0xba, + 0xb8, 0x9d, 0x44, 0x38, 0xd8, 0x2b, 0x9f, 0x31, 0x0a, 0xe2, 0x2e, 0x73, 0x46, 0x82, 0xd3, 0x44, + 0xd3, 0x89, 0xd8, 0xfa, 0x1e, 0x71, 0x22, 0xb6, 0xa6, 0x2b, 0xdc, 0x6e, 0xe4, 0x33, 0x12, 0x76, + 0x6d, 0x5d, 0x55, 0xa5, 0x58, 0xc3, 0x40, 0x9f, 0x03, 0xa4, 0x67, 0xd2, 0x34, 0x42, 0xe8, 0xbe, + 0xb0, 0xbf, 0x57, 0x46, 0x6b, 0x29, 0xe8, 0xc1, 0x5e, 0x79, 0x9a, 0x96, 0xae, 0x78, 0xf4, 0xfa, + 0x1b, 0xc7, 0x1d, 0xcc, 0x20, 0x84, 0x6e, 0xc3, 0x24, 0x2d, 0x65, 0x3b, 0x4a, 0xc6, 0xe7, 0xe5, + 0x57, 0xd6, 0xe7, 0xf6, 0xf7, 0xca, 0x93, 0x6b, 0x09, 0x58, 0x1e, 0xe9, 0x14, 0x91, 0x8c, 0x7c, + 0x6c, 0x43, 0xbd, 0xe6, 0x63, 0xb3, 0xbf, 0x6a, 0xc1, 0x29, 0x7a, 0xc0, 0xd5, 0xaf, 0xe7, 0x58, + 0xd1, 0x9d, 0x96, 0xcb, 0xed, 0x34, 0xe2, 0xa8, 0x61, 0xba, 0xba, 0xca, 0x0a, 0xb7, 0xd2, 0x28, + 0x28, 0xe5, 0xf0, 0xdb, 0xae, 0x57, 0x4f, 0x72, 0xf8, 0x6b, 0xae, 0x57, 0xc7, 0x0c, 0xa2, 0x8e, + 0xac, 0x62, 0x6e, 0xbc, 0xff, 0x6f, 0xd1, 0xbd, 0x4a, 0xfb, 0xf2, 0x43, 0xed, 0x06, 0x7a, 0x4e, + 0xb7, 0xa9, 0x0a, 0xf7, 0xc9, 0x5c, 0x7b, 0xea, 0x57, 0x2c, 0x10, 0xaf, 0xdf, 0x7b, 0x38, 0x93, + 0xdf, 0x85, 0xd1, 0x9d, 0x74, 0x96, 0xe1, 0x73, 0xf9, 0xe1, 0x00, 0x44, 0x6e, 0x61, 0x25, 0xa2, + 0x1b, 0x19, 0x85, 0x0d, 0x5a, 0x76, 0x1d, 0x04, 0x74, 0x91, 0x30, 0xab, 0x46, 0xf7, 0xde, 0xbc, + 0x08, 0x50, 0x67, 0xb8, 0x2c, 0xdf, 0x56, 0xc1, 0x94, 0xb8, 0x16, 0x15, 0x04, 0x6b, 0x58, 0xf6, + 0x2f, 0x16, 0x61, 0x44, 0x66, 0xb5, 0x6d, 0x7b, 0xbd, 0xe8, 0x1e, 0x75, 0xc1, 0xa9, 0xd0, 0x55, + 0x70, 0x7a, 0x0f, 0xa6, 0x02, 0x52, 0x6b, 0x07, 0xa1, 0xbb, 0x43, 0x24, 0x58, 0x6c, 0x92, 0x59, + 0x9e, 0x6e, 0x22, 0x01, 0x3c, 0x60, 0x21, 0xb2, 0x12, 0x85, 0xcc, 0x68, 0x9c, 0x26, 0x84, 0x2e, + 0xc2, 0x30, 0x53, 0xbd, 0x57, 0x62, 0x85, 0xb0, 0x52, 0x7c, 0xad, 0x4a, 0x00, 0x8e, 0x71, 0xd8, + 0xe5, 0xa0, 0x7d, 0x47, 0x4b, 0x86, 0x16, 0x5f, 0x0e, 0x78, 0x31, 0x96, 0x70, 0xf4, 0x69, 0x98, + 0xe4, 0xf5, 0x02, 0xbf, 0xe5, 0x6c, 0x72, 0x93, 0x60, 0xbf, 0x0a, 0xaf, 0x33, 0xb9, 0x9a, 0x80, + 0x1d, 0xec, 0x95, 0x8f, 0x25, 0xcb, 0x58, 0xb7, 0x53, 0x54, 0x98, 0xe7, 0x1f, 0x6f, 0x84, 0x9e, + 0x19, 0x29, 0x87, 0xc1, 0x18, 0x84, 0x75, 0x3c, 0xfb, 0x6f, 0x2c, 0x98, 0xd2, 0xa6, 0xaa, 0xe7, + 0x8c, 0x1f, 0xc6, 0x20, 0x15, 0x7a, 0x18, 0xa4, 0xc3, 0x45, 0x7b, 0xc8, 0x9c, 0xe1, 0xbe, 0x87, + 0x34, 0xc3, 0xf6, 0x17, 0x00, 0xa5, 0x53, 0x26, 0xa3, 0xb7, 0xb9, 0x23, 0xbf, 0x1b, 0x90, 0x7a, + 0x27, 0x83, 0xbf, 0x1e, 0x39, 0x47, 0xbe, 0x5c, 0xe5, 0xb5, 0xb0, 0xaa, 0x6f, 0xff, 0x4d, 0x1f, + 0x4c, 0x26, 0x63, 0x75, 0xa0, 0xab, 0x30, 0xc0, 0xa5, 0x74, 0x41, 0xbe, 0x83, 0x3f, 0x99, 0x16, + 0xe1, 0x83, 0x67, 0xe3, 0xe1, 0xd2, 0xbd, 0xa8, 0x8f, 0xde, 0x83, 0x91, 0xba, 0x7f, 0xd7, 0xbb, + 0xeb, 0x04, 0xf5, 0xb9, 0xca, 0x8a, 0xe0, 0x10, 0x99, 0x0a, 0xa8, 0xc5, 0x18, 0x4d, 0x8f, 0x1a, + 0xc2, 0x7c, 0x27, 0x62, 0x10, 0xd6, 0xc9, 0xa1, 0x75, 0x96, 0x20, 0x6a, 0xc3, 0xdd, 0x5c, 0x75, + 0x5a, 0x9d, 0x5e, 0x75, 0x2d, 0x48, 0x24, 0x8d, 0xf2, 0x98, 0xc8, 0x22, 0xc5, 0x01, 0x38, 0x26, + 0x84, 0xbe, 0x04, 0xd3, 0x61, 0x8e, 0x49, 0x2c, 0x2f, 0x83, 0x7e, 0x27, 0x2b, 0x11, 0x57, 0xa6, + 0x64, 0x19, 0xcf, 0xb2, 0x9a, 0x41, 0xf7, 0x00, 0x09, 0xd5, 0xf3, 0x7a, 0xd0, 0x0e, 0x23, 0x9e, + 0x85, 0x50, 0x5c, 0xba, 0x3e, 0x9e, 0xad, 0x27, 0x48, 0x62, 0x6b, 0x6d, 0xb3, 0x00, 0xc5, 0x69, + 0x0c, 0x9c, 0xd1, 0x06, 0xda, 0x82, 0xf1, 0x96, 0x91, 0x00, 0x92, 0xed, 0xcd, 0x9c, 0x28, 0xbe, + 0x79, 0xa9, 0x22, 0xf9, 0x29, 0x6d, 0x42, 0x71, 0x82, 0xae, 0xfd, 0x95, 0x3e, 0x98, 0x91, 0xd9, + 0xd0, 0x33, 0xde, 0xc9, 0x7c, 0xd9, 0x4a, 0x3c, 0x94, 0x79, 0x2d, 0xff, 0x48, 0x79, 0x64, 0xcf, + 0x65, 0xbe, 0x96, 0x7e, 0x2e, 0xf3, 0xc6, 0x21, 0xbb, 0xf1, 0xd0, 0x1e, 0xcd, 0xfc, 0xd8, 0xbe, + 0x74, 0xd9, 0x3f, 0x06, 0x86, 0x10, 0x80, 0x30, 0x8f, 0x33, 0x5f, 0x91, 0x46, 0xaa, 0x1c, 0x45, + 0xc3, 0x55, 0x81, 0x63, 0x88, 0x15, 0xa3, 0x32, 0x1a, 0x3d, 0xe3, 0xe8, 0x8a, 0x0e, 0xa5, 0x49, + 0x9a, 0xad, 0x68, 0x77, 0xd1, 0x0d, 0x44, 0x8f, 0x33, 0x69, 0x2e, 0x09, 0x9c, 0x34, 0x4d, 0x09, + 0xc1, 0x8a, 0x0e, 0xda, 0x81, 0xa9, 0x4d, 0x16, 0x5b, 0x4a, 0x4b, 0x4c, 0x2e, 0x38, 0x50, 0x26, + 0x87, 0xb8, 0xb2, 0xb0, 0x94, 0x9f, 0xc5, 0x9c, 0x5f, 0x33, 0x53, 0x28, 0x38, 0xdd, 0x04, 0xdd, + 0x1a, 0xc7, 0x9c, 0xbb, 0xe1, 0x52, 0xc3, 0x09, 0x23, 0xb7, 0x36, 0xdf, 0xf0, 0x6b, 0xdb, 0xd5, + 0xc8, 0x0f, 0x64, 0x62, 0xcb, 0xcc, 0x5b, 0xde, 0xdc, 0xed, 0x6a, 0x0a, 0xdf, 0x68, 0x9e, 0x25, + 0x58, 0xcd, 0xc2, 0xc2, 0x99, 0x6d, 0xa1, 0x35, 0x18, 0xdc, 0x74, 0x23, 0x4c, 0x5a, 0xbe, 0xe0, + 0x4b, 0x99, 0x4c, 0xf7, 0x0a, 0x47, 0x31, 0x5a, 0x62, 0xb1, 0xaf, 0x04, 0x00, 0x4b, 0x22, 0xe8, + 0x6d, 0x75, 0xdc, 0x0c, 0xe4, 0xab, 0x7a, 0xd3, 0x5e, 0x7e, 0x99, 0x07, 0xce, 0x9b, 0x50, 0xf4, + 0x36, 0xc2, 0x4e, 0x51, 0x7f, 0xd6, 0x96, 0x0d, 0x4d, 0xdd, 0xfc, 0x20, 0xbd, 0x84, 0xaf, 0x2d, + 0x57, 0x31, 0xad, 0xc8, 0x1e, 0xd8, 0x86, 0xb5, 0xd0, 0x15, 0x49, 0xb2, 0x32, 0xdf, 0x1b, 0xaf, + 0x54, 0x17, 0xaa, 0x2b, 0x06, 0x0d, 0x16, 0x3f, 0x91, 0x15, 0x63, 0x5e, 0x1d, 0xdd, 0x82, 0xe1, + 0x4d, 0xce, 0x62, 0x37, 0x78, 0xf8, 0xd8, 0x9c, 0x63, 0xef, 0x8a, 0x44, 0x32, 0xe8, 0xb1, 0xc3, + 0x49, 0x81, 0x70, 0x4c, 0x0a, 0x7d, 0xc5, 0x82, 0xe3, 0xad, 0x84, 0xae, 0x96, 0x3d, 0x8b, 0x13, + 0x0e, 0x71, 0x99, 0x4f, 0x0d, 0x2a, 0x59, 0x15, 0x8c, 0x06, 0x99, 0xa1, 0x27, 0x13, 0x0d, 0x67, + 0x37, 0x47, 0x07, 0x3a, 0xb8, 0x53, 0xef, 0x94, 0x57, 0x29, 0x11, 0x02, 0x89, 0x0f, 0x34, 0x9e, + 0x5f, 0xc4, 0xb4, 0x22, 0x5a, 0x07, 0xd8, 0x68, 0x10, 0x11, 0x5b, 0x52, 0xb8, 0x5f, 0x65, 0xca, + 0x19, 0xcb, 0x0a, 0x4b, 0xd0, 0x61, 0x77, 0xde, 0xb8, 0x14, 0x6b, 0x74, 0xe8, 0x52, 0xaa, 0xb9, + 0x5e, 0x9d, 0x04, 0xcc, 0x8c, 0x96, 0xb3, 0x94, 0x16, 0x18, 0x46, 0x7a, 0x29, 0xf1, 0x72, 0x2c, + 0x28, 0x30, 0x5a, 0xa4, 0xb5, 0xb5, 0x11, 0x76, 0xca, 0xe0, 0xb1, 0x40, 0x5a, 0x5b, 0x89, 0x05, + 0xc5, 0x69, 0xb1, 0x72, 0x2c, 0x28, 0xd0, 0x2d, 0xb3, 0x41, 0x37, 0x10, 0x09, 0x4a, 0x13, 0xf9, + 0x5b, 0x66, 0x99, 0xa3, 0xa4, 0xb7, 0x8c, 0x00, 0x60, 0x49, 0x04, 0x7d, 0xde, 0x94, 0xab, 0x26, + 0x19, 0xcd, 0xe7, 0xba, 0xc8, 0x55, 0x06, 0xdd, 0xce, 0x92, 0xd5, 0x6b, 0x50, 0xd8, 0xa8, 0x31, + 0xf3, 0x5b, 0x8e, 0x75, 0x62, 0x79, 0xc1, 0xa0, 0xc6, 0x22, 0xe2, 0x2f, 0x2f, 0xe0, 0xc2, 0x46, + 0x8d, 0x2e, 0x7d, 0xe7, 0x7e, 0x3b, 0x20, 0xcb, 0x6e, 0x83, 0x88, 0x6c, 0x1e, 0x99, 0x4b, 0x7f, + 0x4e, 0x22, 0xa5, 0x97, 0xbe, 0x02, 0xe1, 0x98, 0x14, 0xa5, 0x1b, 0x4b, 0x7b, 0xd3, 0xf9, 0x74, + 0x95, 0x50, 0x97, 0xa6, 0x9b, 0x29, 0xef, 0x6d, 0xc3, 0xd8, 0x4e, 0xd8, 0xda, 0x22, 0x92, 0x2b, + 0x32, 0xc3, 0x60, 0x4e, 0x4c, 0x8c, 0x5b, 0x02, 0xd1, 0x0d, 0xa2, 0xb6, 0xd3, 0x48, 0x31, 0x72, + 0xa6, 0xc4, 0xb9, 0xa5, 0x13, 0xc3, 0x26, 0x6d, 0xba, 0x10, 0xde, 0xe7, 0x81, 0xeb, 0x98, 0x89, + 0x30, 0x67, 0x21, 0x64, 0xc4, 0xb6, 0xe3, 0x0b, 0x41, 0x00, 0xb0, 0x24, 0xa2, 0x06, 0x9b, 0x1d, + 0x40, 0x27, 0xba, 0x0c, 0x76, 0xaa, 0xbf, 0xf1, 0x60, 0xb3, 0x03, 0x27, 0x26, 0xc5, 0x0e, 0x9a, + 0xd6, 0x96, 0x1f, 0xf9, 0x5e, 0xe2, 0x90, 0x3b, 0x99, 0x7f, 0xd0, 0x54, 0x32, 0xf0, 0xd3, 0x07, + 0x4d, 0x16, 0x16, 0xce, 0x6c, 0x8b, 0x7e, 0x5c, 0x4b, 0xc6, 0x20, 0x14, 0x19, 0x47, 0x9e, 0xc9, + 0x09, 0xe1, 0x99, 0x0e, 0x54, 0xc8, 0x3f, 0x4e, 0x81, 0x70, 0x4c, 0x0a, 0xd5, 0xa9, 0xa4, 0xab, + 0xc7, 0xb6, 0x65, 0x99, 0x53, 0x72, 0xe4, 0x82, 0xac, 0x28, 0xb8, 0x52, 0xca, 0xd5, 0x21, 0x38, + 0x41, 0x93, 0xf9, 0x08, 0xf2, 0x47, 0x85, 0x2c, 0xb1, 0x4a, 0xce, 0x54, 0x67, 0xbc, 0x3b, 0xe4, + 0x53, 0x2d, 0x00, 0x58, 0x12, 0xa1, 0xa3, 0x21, 0x9e, 0xc2, 0xf9, 0x21, 0xcb, 0x4f, 0x94, 0x67, + 0xca, 0xcf, 0x32, 0x48, 0xc9, 0x80, 0xee, 0x02, 0x84, 0x63, 0x52, 0x94, 0x93, 0xd3, 0x03, 0xef, + 0x74, 0x3e, 0x27, 0x4f, 0x1e, 0x77, 0x8c, 0x93, 0xd3, 0xc3, 0xae, 0x28, 0x8e, 0x3a, 0x15, 0x7f, + 0x9c, 0xe5, 0x56, 0xc9, 0xe9, 0x97, 0x0a, 0x60, 0x9e, 0xee, 0x97, 0x02, 0xe1, 0x98, 0x14, 0x3b, + 0x8a, 0x59, 0x10, 0xbc, 0xb3, 0x1d, 0x8e, 0x62, 0x8a, 0x90, 0x71, 0x14, 0x6b, 0x41, 0xf2, 0xec, + 0x7f, 0x58, 0x80, 0xb3, 0x9d, 0xf7, 0x6d, 0x6c, 0xad, 0xab, 0xc4, 0xde, 0x51, 0x09, 0x6b, 0x1d, + 0xd7, 0x1d, 0xc5, 0x58, 0x3d, 0x87, 0x36, 0xbe, 0x02, 0x53, 0xea, 0xe1, 0x63, 0xc3, 0xad, 0xed, + 0x6a, 0x09, 0x55, 0x55, 0x10, 0xa0, 0x6a, 0x12, 0x01, 0xa7, 0xeb, 0xa0, 0x39, 0x98, 0x30, 0x0a, + 0x57, 0x16, 0x85, 0xa2, 0x21, 0xce, 0x0a, 0x62, 0x82, 0x71, 0x12, 0xdf, 0xfe, 0x25, 0x0b, 0x4e, + 0xf2, 0x40, 0xbc, 0xa4, 0x5e, 0xf1, 0xeb, 0x52, 0xa3, 0x70, 0xa8, 0xc8, 0xbd, 0x1b, 0x30, 0xd1, + 0x32, 0xab, 0x76, 0x09, 0x36, 0xae, 0xa3, 0xc6, 0x7d, 0x4d, 0x00, 0x70, 0x92, 0xa8, 0xfd, 0x0b, + 0x05, 0x38, 0xd3, 0xd1, 0x93, 0x1f, 0x61, 0x38, 0xb1, 0xd9, 0x0c, 0x9d, 0x38, 0x91, 0x7f, 0xb5, + 0x45, 0x6a, 0x9a, 0xbd, 0x95, 0xb9, 0xc4, 0x5f, 0x59, 0xad, 0xce, 0xa5, 0x31, 0x70, 0x4e, 0x4d, + 0xb4, 0x0c, 0x28, 0x0d, 0x11, 0x33, 0xcc, 0x2e, 0xd3, 0x69, 0x7a, 0x38, 0xa3, 0x06, 0x7a, 0x15, + 0xc6, 0xd4, 0x0b, 0x01, 0x6d, 0xc6, 0xd9, 0x01, 0x81, 0x75, 0x00, 0x36, 0xf1, 0xd0, 0x25, 0x9e, + 0x2e, 0x4a, 0x24, 0x16, 0x13, 0xc6, 0xd9, 0x09, 0x99, 0x0b, 0x4a, 0x14, 0x63, 0x1d, 0x67, 0xfe, + 0xf2, 0xef, 0x7f, 0xef, 0xec, 0xc7, 0xfe, 0xf0, 0x7b, 0x67, 0x3f, 0xf6, 0x27, 0xdf, 0x3b, 0xfb, + 0xb1, 0x9f, 0xda, 0x3f, 0x6b, 0xfd, 0xfe, 0xfe, 0x59, 0xeb, 0x0f, 0xf7, 0xcf, 0x5a, 0x7f, 0xb2, + 0x7f, 0xd6, 0xfa, 0xdf, 0xf6, 0xcf, 0x5a, 0x5f, 0xff, 0xdf, 0xcf, 0x7e, 0xec, 0x5d, 0x14, 0xc7, + 0xc2, 0xbe, 0x48, 0x67, 0xe7, 0xe2, 0xce, 0xa5, 0xff, 0x10, 0x00, 0x00, 0xff, 0xff, 0x3a, 0x8b, + 0x4b, 0x61, 0xc8, 0x2b, 0x01, 0x00, } func (m *AWSElasticBlockStoreVolumeSource) Marshal() (dAtA []byte, err error) { @@ -9417,6 +9483,22 @@ func (m *Container) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if len(m.RestartPolicyRules) > 0 { + for iNdEx := len(m.RestartPolicyRules) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.RestartPolicyRules[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xca + } + } if m.RestartPolicy != nil { i -= len(*m.RestartPolicy) copy(dAtA[i:], *m.RestartPolicy) @@ -9783,6 +9865,81 @@ func (m *ContainerResizePolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *ContainerRestartRule) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ContainerRestartRule) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ContainerRestartRule) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ExitCodes != nil { + { + size, err := m.ExitCodes.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + i -= len(m.Action) + copy(dAtA[i:], m.Action) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Action))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *ContainerRestartRuleOnExitCodes) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ContainerRestartRuleOnExitCodes) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ContainerRestartRuleOnExitCodes) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Values) > 0 { + for iNdEx := len(m.Values) - 1; iNdEx >= 0; iNdEx-- { + i = encodeVarintGenerated(dAtA, i, uint64(m.Values[iNdEx])) + i-- + dAtA[i] = 0x10 + } + } + i -= len(m.Operator) + copy(dAtA[i:], m.Operator) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Operator))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + func (m *ContainerState) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -10873,6 +11030,22 @@ func (m *EphemeralContainerCommon) MarshalToSizedBuffer(dAtA []byte) (int, error _ = i var l int _ = l + if len(m.RestartPolicyRules) > 0 { + for iNdEx := len(m.RestartPolicyRules) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.RestartPolicyRules[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xca + } + } if m.RestartPolicy != nil { i -= len(*m.RestartPolicy) copy(dAtA[i:], *m.RestartPolicy) @@ -22676,6 +22849,12 @@ func (m *Container) Size() (n int) { l = len(*m.RestartPolicy) n += 2 + l + sovGenerated(uint64(l)) } + if len(m.RestartPolicyRules) > 0 { + for _, e := range m.RestartPolicyRules { + l = e.Size() + n += 2 + l + sovGenerated(uint64(l)) + } + } return n } @@ -22725,6 +22904,37 @@ func (m *ContainerResizePolicy) Size() (n int) { return n } +func (m *ContainerRestartRule) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Action) + n += 1 + l + sovGenerated(uint64(l)) + if m.ExitCodes != nil { + l = m.ExitCodes.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *ContainerRestartRuleOnExitCodes) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Operator) + n += 1 + l + sovGenerated(uint64(l)) + if len(m.Values) > 0 { + for _, e := range m.Values { + n += 1 + sovGenerated(uint64(e)) + } + } + return n +} + func (m *ContainerState) Size() (n int) { if m == nil { return 0 @@ -23216,6 +23426,12 @@ func (m *EphemeralContainerCommon) Size() (n int) { l = len(*m.RestartPolicy) n += 2 + l + sovGenerated(uint64(l)) } + if len(m.RestartPolicyRules) > 0 { + for _, e := range m.RestartPolicyRules { + l = e.Size() + n += 2 + l + sovGenerated(uint64(l)) + } + } return n } @@ -27683,6 +27899,11 @@ func (this *Container) String() string { repeatedStringForResizePolicy += strings.Replace(strings.Replace(f.String(), "ContainerResizePolicy", "ContainerResizePolicy", 1), `&`, ``, 1) + "," } repeatedStringForResizePolicy += "}" + repeatedStringForRestartPolicyRules := "[]ContainerRestartRule{" + for _, f := range this.RestartPolicyRules { + repeatedStringForRestartPolicyRules += strings.Replace(strings.Replace(f.String(), "ContainerRestartRule", "ContainerRestartRule", 1), `&`, ``, 1) + "," + } + repeatedStringForRestartPolicyRules += "}" s := strings.Join([]string{`&Container{`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`, `Image:` + fmt.Sprintf("%v", this.Image) + `,`, @@ -27708,6 +27929,7 @@ func (this *Container) String() string { `StartupProbe:` + strings.Replace(this.StartupProbe.String(), "Probe", "Probe", 1) + `,`, `ResizePolicy:` + repeatedStringForResizePolicy + `,`, `RestartPolicy:` + valueToStringGenerated(this.RestartPolicy) + `,`, + `RestartPolicyRules:` + repeatedStringForRestartPolicyRules + `,`, `}`, }, "") return s @@ -27748,6 +27970,28 @@ func (this *ContainerResizePolicy) String() string { }, "") return s } +func (this *ContainerRestartRule) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ContainerRestartRule{`, + `Action:` + fmt.Sprintf("%v", this.Action) + `,`, + `ExitCodes:` + strings.Replace(this.ExitCodes.String(), "ContainerRestartRuleOnExitCodes", "ContainerRestartRuleOnExitCodes", 1) + `,`, + `}`, + }, "") + return s +} +func (this *ContainerRestartRuleOnExitCodes) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ContainerRestartRuleOnExitCodes{`, + `Operator:` + fmt.Sprintf("%v", this.Operator) + `,`, + `Values:` + fmt.Sprintf("%v", this.Values) + `,`, + `}`, + }, "") + return s +} func (this *ContainerState) String() string { if this == nil { return "nil" @@ -28084,6 +28328,11 @@ func (this *EphemeralContainerCommon) String() string { repeatedStringForResizePolicy += strings.Replace(strings.Replace(f.String(), "ContainerResizePolicy", "ContainerResizePolicy", 1), `&`, ``, 1) + "," } repeatedStringForResizePolicy += "}" + repeatedStringForRestartPolicyRules := "[]ContainerRestartRule{" + for _, f := range this.RestartPolicyRules { + repeatedStringForRestartPolicyRules += strings.Replace(strings.Replace(f.String(), "ContainerRestartRule", "ContainerRestartRule", 1), `&`, ``, 1) + "," + } + repeatedStringForRestartPolicyRules += "}" s := strings.Join([]string{`&EphemeralContainerCommon{`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`, `Image:` + fmt.Sprintf("%v", this.Image) + `,`, @@ -28109,6 +28358,7 @@ func (this *EphemeralContainerCommon) String() string { `StartupProbe:` + strings.Replace(this.StartupProbe.String(), "Probe", "Probe", 1) + `,`, `ResizePolicy:` + repeatedStringForResizePolicy + `,`, `RestartPolicy:` + valueToStringGenerated(this.RestartPolicy) + `,`, + `RestartPolicyRules:` + repeatedStringForRestartPolicyRules + `,`, `}`, }, "") return s @@ -36753,6 +37003,40 @@ func (m *Container) Unmarshal(dAtA []byte) error { s := ContainerRestartPolicy(dAtA[iNdEx:postIndex]) m.RestartPolicy = &s iNdEx = postIndex + case 25: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RestartPolicyRules", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RestartPolicyRules = append(m.RestartPolicyRules, ContainerRestartRule{}) + if err := m.RestartPolicyRules[len(m.RestartPolicyRules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) @@ -37173,6 +37457,282 @@ func (m *ContainerResizePolicy) Unmarshal(dAtA []byte) error { } return nil } +func (m *ContainerRestartRule) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ContainerRestartRule: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ContainerRestartRule: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Action = ContainerRestartRuleAction(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExitCodes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ExitCodes == nil { + m.ExitCodes = &ContainerRestartRuleOnExitCodes{} + } + if err := m.ExitCodes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ContainerRestartRuleOnExitCodes) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ContainerRestartRuleOnExitCodes: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ContainerRestartRuleOnExitCodes: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Operator = ContainerRestartRuleOnExitCodesOperator(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType == 0 { + 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.Values = append(m.Values, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(m.Values) == 0 { + m.Values = make([]int32, 0, elementCount) + } + for iNdEx < postIndex { + 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.Values = append(m.Values, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType) + } + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *ContainerState) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -41198,6 +41758,40 @@ func (m *EphemeralContainerCommon) Unmarshal(dAtA []byte) error { s := ContainerRestartPolicy(dAtA[iNdEx:postIndex]) m.RestartPolicy = &s iNdEx = postIndex + case 25: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RestartPolicyRules", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RestartPolicyRules = append(m.RestartPolicyRules, ContainerRestartRule{}) + if err := m.RestartPolicyRules[len(m.RestartPolicyRules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) diff --git a/staging/src/k8s.io/api/core/v1/generated.proto b/staging/src/k8s.io/api/core/v1/generated.proto index 0570afdb0b3..907fe27cac6 100644 --- a/staging/src/k8s.io/api/core/v1/generated.proto +++ b/staging/src/k8s.io/api/core/v1/generated.proto @@ -768,10 +768,10 @@ message Container { repeated ContainerResizePolicy resizePolicy = 23; // RestartPolicy defines the restart behavior of individual containers in a pod. - // This field may only be set for init containers, and the only allowed value is "Always". - // For non-init containers or when this field is not specified, + // This overrides the pod-level restart policy. When this field is not specified, // the restart behavior is defined by the Pod's restart policy and the container type. - // Setting the RestartPolicy as "Always" for the init container will have the following effect: + // Additionally, setting the RestartPolicy as "Always" for the init container will + // have the following effect: // this init container will be continually restarted on // exit until all regular containers have terminated. Once all regular // containers have completed, all init containers with restartPolicy "Always" @@ -786,6 +786,22 @@ message Container { // +optional optional string restartPolicy = 24; + // Represents a list of rules to be checked to determine if the + // container should be restarted on exit. The rules are evaluated in + // order. Once a rule matches a container exit condition, the remaining + // rules are ignored. If no rule matches the container exit condition, + // the Container-level restart policy determines the whether the container + // is restarted or not. Constraints on the rules: + // - At most 20 rules are allowed. + // - Rules can have the same action. + // - Identical rules are not forbidden in validations. + // When rules are specified, container MUST set RestartPolicy explicitly + // even it if matches the Pod's RestartPolicy. + // +featureGate=ContainerRestartRules + // +optional + // +listType=atomic + repeated ContainerRestartRule restartPolicyRules = 25; + // Pod volumes to mount into the container's filesystem. // Cannot be updated. // +optional @@ -942,6 +958,39 @@ message ContainerResizePolicy { optional string restartPolicy = 2; } +// ContainerRestartRule describes how a container exit is handled. +message ContainerRestartRule { + // Specifies the action taken on a container exit if the requirements + // are satisfied. The only possible value is "Restart" to restart the + // container. + // +required + optional string action = 1; + + // Represents the exit codes to check on container exits. + // +optional + // +oneOf=when + optional ContainerRestartRuleOnExitCodes exitCodes = 2; +} + +// ContainerRestartRuleOnExitCodes describes the condition +// for handling an exited container based on its exit codes. +message ContainerRestartRuleOnExitCodes { + // Represents the relationship between the container exit code(s) and the + // specified values. Possible values are: + // - In: the requirement is satisfied if the container exit code is in the + // set of specified values. + // - NotIn: the requirement is satisfied if the container exit code is + // not in the set of specified values. + // +required + optional string operator = 1; + + // Specifies the set of values to check for container exit codes. + // At most 255 elements are allowed. + // +optional + // +listType=set + repeated int32 values = 2; +} + // ContainerState holds a possible state of container. // Only one of its members may be specified. // If none of them is specified, the default one is ContainerStateWaiting. @@ -1519,12 +1568,19 @@ message EphemeralContainerCommon { // Restart policy for the container to manage the restart behavior of each // container within a pod. - // This may only be set for init containers. You cannot set this field on - // ephemeral containers. + // You cannot set this field on ephemeral containers. // +featureGate=SidecarContainers // +optional optional string restartPolicy = 24; + // Represents a list of rules to be checked to determine if the + // container should be restarted on exit. You cannot set this field on + // ephemeral containers. + // +featureGate=ContainerRestartRules + // +optional + // +listType=atomic + repeated ContainerRestartRule restartPolicyRules = 25; + // Pod volumes to mount into the container's filesystem. Subpath mounts are not allowed for ephemeral containers. // Cannot be updated. // +optional diff --git a/staging/src/k8s.io/api/core/v1/types.go b/staging/src/k8s.io/api/core/v1/types.go index 5b4602e1dbb..47065f79f79 100644 --- a/staging/src/k8s.io/api/core/v1/types.go +++ b/staging/src/k8s.io/api/core/v1/types.go @@ -2974,10 +2974,10 @@ type Container struct { // +listType=atomic ResizePolicy []ContainerResizePolicy `json:"resizePolicy,omitempty" protobuf:"bytes,23,rep,name=resizePolicy"` // RestartPolicy defines the restart behavior of individual containers in a pod. - // This field may only be set for init containers, and the only allowed value is "Always". - // For non-init containers or when this field is not specified, + // This overrides the pod-level restart policy. When this field is not specified, // the restart behavior is defined by the Pod's restart policy and the container type. - // Setting the RestartPolicy as "Always" for the init container will have the following effect: + // Additionally, setting the RestartPolicy as "Always" for the init container will + // have the following effect: // this init container will be continually restarted on // exit until all regular containers have terminated. Once all regular // containers have completed, all init containers with restartPolicy "Always" @@ -2991,6 +2991,21 @@ type Container struct { // +featureGate=SidecarContainers // +optional RestartPolicy *ContainerRestartPolicy `json:"restartPolicy,omitempty" protobuf:"bytes,24,opt,name=restartPolicy,casttype=ContainerRestartPolicy"` + // Represents a list of rules to be checked to determine if the + // container should be restarted on exit. The rules are evaluated in + // order. Once a rule matches a container exit condition, the remaining + // rules are ignored. If no rule matches the container exit condition, + // the Container-level restart policy determines the whether the container + // is restarted or not. Constraints on the rules: + // - At most 20 rules are allowed. + // - Rules can have the same action. + // - Identical rules are not forbidden in validations. + // When rules are specified, container MUST set RestartPolicy explicitly + // even it if matches the Pod's RestartPolicy. + // +featureGate=ContainerRestartRules + // +optional + // +listType=atomic + RestartPolicyRules []ContainerRestartRule `json:"restartPolicyRules,omitempty" protobuf:"bytes,25,rep,name=restartPolicyRules"` // Pod volumes to mount into the container's filesystem. // Cannot be updated. // +optional @@ -3620,11 +3635,64 @@ const ( ) // ContainerRestartPolicy is the restart policy for a single container. -// This may only be set for init containers and only allowed value is "Always". +// The only allowed values are "Always", "Never", and "OnFailure". type ContainerRestartPolicy string const ( - ContainerRestartPolicyAlways ContainerRestartPolicy = "Always" + ContainerRestartPolicyAlways ContainerRestartPolicy = "Always" + ContainerRestartPolicyNever ContainerRestartPolicy = "Never" + ContainerRestartPolicyOnFailure ContainerRestartPolicy = "OnFailure" +) + +// ContainerRestartRule describes how a container exit is handled. +type ContainerRestartRule struct { + // Specifies the action taken on a container exit if the requirements + // are satisfied. The only possible value is "Restart" to restart the + // container. + // +required + Action ContainerRestartRuleAction `json:"action,omitempty" proto:"bytes,1,opt,name=action" protobuf:"bytes,1,opt,name=action,casttype=ContainerRestartRuleAction"` + + // Represents the exit codes to check on container exits. + // +optional + // +oneOf=when + ExitCodes *ContainerRestartRuleOnExitCodes `json:"exitCodes,omitempty" proto:"bytes,2,opt,name=exitCodes" protobuf:"bytes,2,opt,name=exitCodes"` +} + +// ContainerRestartRuleAction describes the action to take when the +// container exits. +type ContainerRestartRuleAction string + +// The only valid action is Restart. +const ( + ContainerRestartRuleActionRestart ContainerRestartRuleAction = "Restart" +) + +// ContainerRestartRuleOnExitCodes describes the condition +// for handling an exited container based on its exit codes. +type ContainerRestartRuleOnExitCodes struct { + // Represents the relationship between the container exit code(s) and the + // specified values. Possible values are: + // - In: the requirement is satisfied if the container exit code is in the + // set of specified values. + // - NotIn: the requirement is satisfied if the container exit code is + // not in the set of specified values. + // +required + Operator ContainerRestartRuleOnExitCodesOperator `json:"operator,omitempty" proto:"bytes,1,opt,name=operator" protobuf:"bytes,1,opt,name=operator,casttype=ContainerRestartRuleOnExitCodesOperator"` + + // Specifies the set of values to check for container exit codes. + // At most 255 elements are allowed. + // +optional + // +listType=set + Values []int32 `json:"values,omitempty" proto:"varint,2,rep,name=values" protobuf:"varint,2,rep,name=values"` +} + +// ContainerRestartRuleOnExitCodesOperator describes the operator +// to take for the exit codes. +type ContainerRestartRuleOnExitCodesOperator string + +const ( + ContainerRestartRuleOnExitCodesOpIn ContainerRestartRuleOnExitCodesOperator = "In" + ContainerRestartRuleOnExitCodesOpNotIn ContainerRestartRuleOnExitCodesOperator = "NotIn" ) // DNSPolicy defines how a pod's DNS will be configured. @@ -4984,11 +5052,17 @@ type EphemeralContainerCommon struct { ResizePolicy []ContainerResizePolicy `json:"resizePolicy,omitempty" protobuf:"bytes,23,rep,name=resizePolicy"` // Restart policy for the container to manage the restart behavior of each // container within a pod. - // This may only be set for init containers. You cannot set this field on - // ephemeral containers. + // You cannot set this field on ephemeral containers. // +featureGate=SidecarContainers // +optional RestartPolicy *ContainerRestartPolicy `json:"restartPolicy,omitempty" protobuf:"bytes,24,opt,name=restartPolicy,casttype=ContainerRestartPolicy"` + // Represents a list of rules to be checked to determine if the + // container should be restarted on exit. You cannot set this field on + // ephemeral containers. + // +featureGate=ContainerRestartRules + // +optional + // +listType=atomic + RestartPolicyRules []ContainerRestartRule `json:"restartPolicyRules,omitempty" protobuf:"bytes,25,rep,name=restartPolicyRules"` // Pod volumes to mount into the container's filesystem. Subpath mounts are not allowed for ephemeral containers. // Cannot be updated. // +optional 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 1e2526f3612..ae271efe628 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 @@ -360,7 +360,8 @@ var map_Container = map[string]string{ "env": "List of environment variables to set in the container. Cannot be updated.", "resources": "Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/", "resizePolicy": "Resources resize policy for the container.", - "restartPolicy": "RestartPolicy defines the restart behavior of individual containers in a pod. This field may only be set for init containers, and the only allowed value is \"Always\". For non-init containers or when this field is not specified, the restart behavior is defined by the Pod's restart policy and the container type. Setting the RestartPolicy as \"Always\" for the init container will have the following effect: this init container will be continually restarted on exit until all regular containers have terminated. Once all regular containers have completed, all init containers with restartPolicy \"Always\" will be shut down. This lifecycle differs from normal init containers and is often referred to as a \"sidecar\" container. Although this init container still starts in the init container sequence, it does not wait for the container to complete before proceeding to the next init container. Instead, the next init container starts immediately after this init container is started, or after any startupProbe has successfully completed.", + "restartPolicy": "RestartPolicy defines the restart behavior of individual containers in a pod. This overrides the pod-level restart policy. When this field is not specified, the restart behavior is defined by the Pod's restart policy and the container type. Additionally, setting the RestartPolicy as \"Always\" for the init container will have the following effect: this init container will be continually restarted on exit until all regular containers have terminated. Once all regular containers have completed, all init containers with restartPolicy \"Always\" will be shut down. This lifecycle differs from normal init containers and is often referred to as a \"sidecar\" container. Although this init container still starts in the init container sequence, it does not wait for the container to complete before proceeding to the next init container. Instead, the next init container starts immediately after this init container is started, or after any startupProbe has successfully completed.", + "restartPolicyRules": "Represents a list of rules to be checked to determine if the container should be restarted on exit. The rules are evaluated in order. Once a rule matches a container exit condition, the remaining rules are ignored. If no rule matches the container exit condition, the Container-level restart policy determines the whether the container is restarted or not. Constraints on the rules: - At most 20 rules are allowed. - Rules can have the same action. - Identical rules are not forbidden in validations. When rules are specified, container MUST set RestartPolicy explicitly even it if matches the Pod's RestartPolicy.", "volumeMounts": "Pod volumes to mount into the container's filesystem. Cannot be updated.", "volumeDevices": "volumeDevices is the list of block devices to be used by the container.", "livenessProbe": "Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes", @@ -413,6 +414,26 @@ func (ContainerResizePolicy) SwaggerDoc() map[string]string { return map_ContainerResizePolicy } +var map_ContainerRestartRule = map[string]string{ + "": "ContainerRestartRule describes how a container exit is handled.", + "action": "Specifies the action taken on a container exit if the requirements are satisfied. The only possible value is \"Restart\" to restart the container.", + "exitCodes": "Represents the exit codes to check on container exits.", +} + +func (ContainerRestartRule) SwaggerDoc() map[string]string { + return map_ContainerRestartRule +} + +var map_ContainerRestartRuleOnExitCodes = map[string]string{ + "": "ContainerRestartRuleOnExitCodes describes the condition for handling an exited container based on its exit codes.", + "operator": "Represents the relationship between the container exit code(s) and the specified values. Possible values are: - In: the requirement is satisfied if the container exit code is in the\n set of specified values.\n- NotIn: the requirement is satisfied if the container exit code is\n not in the set of specified values.", + "values": "Specifies the set of values to check for container exit codes. At most 255 elements are allowed.", +} + +func (ContainerRestartRuleOnExitCodes) SwaggerDoc() map[string]string { + return map_ContainerRestartRuleOnExitCodes +} + var map_ContainerState = map[string]string{ "": "ContainerState holds a possible state of container. Only one of its members may be specified. If none of them is specified, the default one is ContainerStateWaiting.", "waiting": "Details about a waiting container", @@ -651,7 +672,8 @@ var map_EphemeralContainerCommon = map[string]string{ "env": "List of environment variables to set in the container. Cannot be updated.", "resources": "Resources are not allowed for ephemeral containers. Ephemeral containers use spare resources already allocated to the pod.", "resizePolicy": "Resources resize policy for the container.", - "restartPolicy": "Restart policy for the container to manage the restart behavior of each container within a pod. This may only be set for init containers. You cannot set this field on ephemeral containers.", + "restartPolicy": "Restart policy for the container to manage the restart behavior of each container within a pod. You cannot set this field on ephemeral containers.", + "restartPolicyRules": "Represents a list of rules to be checked to determine if the container should be restarted on exit. You cannot set this field on ephemeral containers.", "volumeMounts": "Pod volumes to mount into the container's filesystem. Subpath mounts are not allowed for ephemeral containers. Cannot be updated.", "volumeDevices": "volumeDevices is the list of block devices to be used by the container.", "livenessProbe": "Probes are not allowed for ephemeral containers.", 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 3c65e07c96f..38a40ff2d18 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 @@ -829,6 +829,13 @@ func (in *Container) DeepCopyInto(out *Container) { *out = new(ContainerRestartPolicy) **out = **in } + if in.RestartPolicyRules != nil { + in, out := &in.RestartPolicyRules, &out.RestartPolicyRules + *out = make([]ContainerRestartRule, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } if in.VolumeMounts != nil { in, out := &in.VolumeMounts, &out.VolumeMounts *out = make([]VolumeMount, len(*in)) @@ -932,6 +939,48 @@ func (in *ContainerResizePolicy) DeepCopy() *ContainerResizePolicy { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ContainerRestartRule) DeepCopyInto(out *ContainerRestartRule) { + *out = *in + if in.ExitCodes != nil { + in, out := &in.ExitCodes, &out.ExitCodes + *out = new(ContainerRestartRuleOnExitCodes) + (*in).DeepCopyInto(*out) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ContainerRestartRule. +func (in *ContainerRestartRule) DeepCopy() *ContainerRestartRule { + if in == nil { + return nil + } + out := new(ContainerRestartRule) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ContainerRestartRuleOnExitCodes) DeepCopyInto(out *ContainerRestartRuleOnExitCodes) { + *out = *in + if in.Values != nil { + in, out := &in.Values, &out.Values + *out = make([]int32, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ContainerRestartRuleOnExitCodes. +func (in *ContainerRestartRuleOnExitCodes) DeepCopy() *ContainerRestartRuleOnExitCodes { + if in == nil { + return nil + } + out := new(ContainerRestartRuleOnExitCodes) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *ContainerState) DeepCopyInto(out *ContainerState) { *out = *in @@ -1511,6 +1560,13 @@ func (in *EphemeralContainerCommon) DeepCopyInto(out *EphemeralContainerCommon) *out = new(ContainerRestartPolicy) **out = **in } + if in.RestartPolicyRules != nil { + in, out := &in.RestartPolicyRules, &out.RestartPolicyRules + *out = make([]ContainerRestartRule, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } if in.VolumeMounts != nil { in, out := &in.VolumeMounts, &out.VolumeMounts *out = make([]VolumeMount, len(*in)) 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 ef00ff55526..6d0dcb9035d 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 @@ -593,6 +593,17 @@ } ], "restartPolicy": "restartPolicyValue", + "restartPolicyRules": [ + { + "action": "actionValue", + "exitCodes": { + "operator": "operatorValue", + "values": [ + 2 + ] + } + } + ], "volumeMounts": [ { "name": "nameValue", @@ -896,6 +907,17 @@ } ], "restartPolicy": "restartPolicyValue", + "restartPolicyRules": [ + { + "action": "actionValue", + "exitCodes": { + "operator": "operatorValue", + "values": [ + 2 + ] + } + } + ], "volumeMounts": [ { "name": "nameValue", @@ -1199,6 +1221,17 @@ } ], "restartPolicy": "restartPolicyValue", + "restartPolicyRules": [ + { + "action": "actionValue", + "exitCodes": { + "operator": "operatorValue", + "values": [ + 2 + ] + } + } + ], "volumeMounts": [ { "name": "nameValue", 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 a4818e2acf57d8cf4bf55a7a892056bf78fdc860..5ce7c1d6fa7b3a4677a33e06b2e2e7c062774fec 100644 GIT binary patch delta 196 zcmZ1%F+FmEG~>68GO3JAdqXEXNcuCa4B04~!pL+uaI+QjEH1{+n=Pa-vZ#oGHzltnY=+v ZYO|)&4n~#2d7D-RBLJcuL81Tv delta 73 zcmbOpxh`UYG-K~ZnN&umDWW1(lN5u3!WJ?>rk6 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 49c75908eaf..1180b32af98 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 @@ -350,6 +350,12 @@ spec: requests: requestsKey: "0" restartPolicy: restartPolicyValue + restartPolicyRules: + - action: actionValue + exitCodes: + operator: operatorValue + values: + - 2 securityContext: allowPrivilegeEscalation: true appArmorProfile: @@ -572,6 +578,12 @@ spec: requests: requestsKey: "0" restartPolicy: restartPolicyValue + restartPolicyRules: + - action: actionValue + exitCodes: + operator: operatorValue + values: + - 2 securityContext: allowPrivilegeEscalation: true appArmorProfile: @@ -797,6 +809,12 @@ spec: requests: requestsKey: "0" restartPolicy: restartPolicyValue + restartPolicyRules: + - action: actionValue + exitCodes: + operator: operatorValue + values: + - 2 securityContext: allowPrivilegeEscalation: true appArmorProfile: 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 ca1c7f321eb..d2a93e6cc9a 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 @@ -594,6 +594,17 @@ } ], "restartPolicy": "restartPolicyValue", + "restartPolicyRules": [ + { + "action": "actionValue", + "exitCodes": { + "operator": "operatorValue", + "values": [ + 2 + ] + } + } + ], "volumeMounts": [ { "name": "nameValue", @@ -897,6 +908,17 @@ } ], "restartPolicy": "restartPolicyValue", + "restartPolicyRules": [ + { + "action": "actionValue", + "exitCodes": { + "operator": "operatorValue", + "values": [ + 2 + ] + } + } + ], "volumeMounts": [ { "name": "nameValue", @@ -1200,6 +1222,17 @@ } ], "restartPolicy": "restartPolicyValue", + "restartPolicyRules": [ + { + "action": "actionValue", + "exitCodes": { + "operator": "operatorValue", + "values": [ + 2 + ] + } + } + ], "volumeMounts": [ { "name": "nameValue", 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 943eff1f4d3982d620f915cd7be1028468b5f879..1cde4fc61f19b73e258256bb4d64d39ed1cbc900 100644 GIT binary patch delta 191 zcmdlRu`F_e3{y+wM!6J5*2AG3j6#$5^Y}7LtqcK)FdYuuY|A{0i}CYjYw3$@DyJ9~ zxVRIOOEUBG!V+^zQ-uV%c=HQVixNxni@*W`Oj45@MT9r+6{%%|YEmXb(`Fu}8;mRy P__!eU5T#|ORtqBlp6WjY delta 95 zcmZ1$xi?~h4Abn0jdCfBthYiq7=crV0si@#Yt#7A2PC7l8!?n4~5*iU@DsD^kk_)uc>>rp-J`HyBwa P@Nq%xAxg_mEki~CCt*Kt delta 95 zcmcZ{@hW_R4AY75jdCfBtW!fc7=crV0si@#Yt#7A2PC7l8!?m^QBxnaDWu|9HwB2!1?<~xijjI75)IT(c|uaoj+mRcDC7GgRaxY>z$78m2^%?{ER*_2N) zDsXWpCYNO9=Y=Kal%@&^a`EODq!uNX0VxLwA FBLKAaKXU*8 delta 91 zcmZ1{wiRobC<^|d*jI0l1IT(c|ub1*=mRcDC7GgRaxY?O`78m2^&5qI+*_2N) zDsXWpCYNO9=Y=Kal%@&^a`EODq!uNXiLvzFtSYG<08R|-C7ll E0D1X6n*aa+ delta 87 zcmbOexjABj0%Pw+#Z*S-DUu{v^sB2!D`<~xijjI4)4IT(c|uaoj+mRcDC7GgRaxY>z$78m2^%?{ER*_2N) zDsXWpCYNO9=Y=Kal%@&^a`EODq!uNX0VxLwE FBLJz6KVJX< delta 91 zcmZ1-c_?CnBGc@M&37167+G(Ha4-r@z9{9(EOj6lEW~sxV6zkREH1_ioA2^oWZQgE kWFi}s&9;J(aTBA-WJ7VO&E-lv7+K!(azRz8Yqu~004j+g-~a#s diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.yaml index e3a8414bbe0..8eba35a2b83 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.Deployment.yaml @@ -358,6 +358,12 @@ spec: requests: requestsKey: "0" restartPolicy: restartPolicyValue + restartPolicyRules: + - action: actionValue + exitCodes: + operator: operatorValue + values: + - 2 securityContext: allowPrivilegeEscalation: true appArmorProfile: @@ -580,6 +586,12 @@ spec: requests: requestsKey: "0" restartPolicy: restartPolicyValue + restartPolicyRules: + - action: actionValue + exitCodes: + operator: operatorValue + values: + - 2 securityContext: allowPrivilegeEscalation: true appArmorProfile: @@ -805,6 +817,12 @@ spec: requests: requestsKey: "0" restartPolicy: restartPolicyValue + restartPolicyRules: + - action: actionValue + exitCodes: + operator: operatorValue + values: + - 2 securityContext: allowPrivilegeEscalation: true appArmorProfile: diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.ReplicaSet.json b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.ReplicaSet.json index e8430756218..53d19e86b0b 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.ReplicaSet.json +++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.ReplicaSet.json @@ -595,6 +595,17 @@ } ], "restartPolicy": "restartPolicyValue", + "restartPolicyRules": [ + { + "action": "actionValue", + "exitCodes": { + "operator": "operatorValue", + "values": [ + 2 + ] + } + } + ], "volumeMounts": [ { "name": "nameValue", @@ -898,6 +909,17 @@ } ], "restartPolicy": "restartPolicyValue", + "restartPolicyRules": [ + { + "action": "actionValue", + "exitCodes": { + "operator": "operatorValue", + "values": [ + 2 + ] + } + } + ], "volumeMounts": [ { "name": "nameValue", @@ -1201,6 +1223,17 @@ } ], "restartPolicy": "restartPolicyValue", + "restartPolicyRules": [ + { + "action": "actionValue", + "exitCodes": { + "operator": "operatorValue", + "values": [ + 2 + ] + } + } + ], "volumeMounts": [ { "name": "nameValue", diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.ReplicaSet.pb b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.ReplicaSet.pb index 2d9cdca2c2b876234319570600179ee68666b46b..8d1be4d0b563073806aeea631430641a66061338 100644 GIT binary patch delta 188 zcmaDKej{RnBGbl*&37167+L>?a4-r@UMJ{wiRobC<^|d*jI0l1IT(c|ub1*=mRcDC7GgRaxY?O`78m2^&5qI+*_2N) zDsXWpCYNO9=Y=Kal%@&^a`EODq!uNXQ^u_ZelckFYU*w!Dw_K7^3V} zz~-wgv$z;9Y%bux$hJ8}Y$6+!&9;J(aTBA-TKXcJ$|*(#F7CwS zlFaGK-7x!sg#H c7uhyvicMsLvEM7-U}SmA%LSF%ucOBV00KKBr2qf` diff --git a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.yaml b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.yaml index e7b7ecb4fb9..90eb8120b3f 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/batch.v1beta1.CronJob.yaml @@ -410,6 +410,12 @@ spec: requests: requestsKey: "0" restartPolicy: restartPolicyValue + restartPolicyRules: + - action: actionValue + exitCodes: + operator: operatorValue + values: + - 2 securityContext: allowPrivilegeEscalation: true appArmorProfile: @@ -632,6 +638,12 @@ spec: requests: requestsKey: "0" restartPolicy: restartPolicyValue + restartPolicyRules: + - action: actionValue + exitCodes: + operator: operatorValue + values: + - 2 securityContext: allowPrivilegeEscalation: true appArmorProfile: @@ -857,6 +869,12 @@ spec: requests: requestsKey: "0" restartPolicy: restartPolicyValue + restartPolicyRules: + - action: actionValue + exitCodes: + operator: operatorValue + values: + - 2 securityContext: allowPrivilegeEscalation: true appArmorProfile: 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 a86cc01dc33..5d44f52d4df 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 @@ -535,6 +535,17 @@ } ], "restartPolicy": "restartPolicyValue", + "restartPolicyRules": [ + { + "action": "actionValue", + "exitCodes": { + "operator": "operatorValue", + "values": [ + 2 + ] + } + } + ], "volumeMounts": [ { "name": "nameValue", @@ -838,6 +849,17 @@ } ], "restartPolicy": "restartPolicyValue", + "restartPolicyRules": [ + { + "action": "actionValue", + "exitCodes": { + "operator": "operatorValue", + "values": [ + 2 + ] + } + } + ], "volumeMounts": [ { "name": "nameValue", @@ -1141,6 +1163,17 @@ } ], "restartPolicy": "restartPolicyValue", + "restartPolicyRules": [ + { + "action": "actionValue", + "exitCodes": { + "operator": "operatorValue", + "values": [ + 2 + ] + } + } + ], "volumeMounts": [ { "name": "nameValue", 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 127795fbeae1519a75c3fe92f2f1d2065b262bc4..d436a08e6f70994fe41f3fc05fcde86569e9ccec 100644 GIT binary patch delta 198 zcmaExcr8gN+oG6(i<66~%ut9qAU{RuK+Oo(f{}3(qse4N aZmG@b3Og8CCh&1VY*Z#f^X4xaKiL6R)*FtWVm<$@^K9IN@09ROYw9RvUX diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.yaml b/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.yaml index be913c1a7ca..8a368be8001 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/core.v1.Pod.yaml @@ -306,6 +306,12 @@ spec: requests: requestsKey: "0" restartPolicy: restartPolicyValue + restartPolicyRules: + - action: actionValue + exitCodes: + operator: operatorValue + values: + - 2 securityContext: allowPrivilegeEscalation: true appArmorProfile: @@ -528,6 +534,12 @@ spec: requests: requestsKey: "0" restartPolicy: restartPolicyValue + restartPolicyRules: + - action: actionValue + exitCodes: + operator: operatorValue + values: + - 2 securityContext: allowPrivilegeEscalation: true appArmorProfile: @@ -753,6 +765,12 @@ spec: requests: requestsKey: "0" restartPolicy: restartPolicyValue + restartPolicyRules: + - action: actionValue + exitCodes: + operator: operatorValue + values: + - 2 securityContext: allowPrivilegeEscalation: true appArmorProfile: diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.json b/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.json index 9cbe661c254..b665fdd23c2 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.json +++ b/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.json @@ -578,6 +578,17 @@ } ], "restartPolicy": "restartPolicyValue", + "restartPolicyRules": [ + { + "action": "actionValue", + "exitCodes": { + "operator": "operatorValue", + "values": [ + 2 + ] + } + } + ], "volumeMounts": [ { "name": "nameValue", @@ -881,6 +892,17 @@ } ], "restartPolicy": "restartPolicyValue", + "restartPolicyRules": [ + { + "action": "actionValue", + "exitCodes": { + "operator": "operatorValue", + "values": [ + 2 + ] + } + } + ], "volumeMounts": [ { "name": "nameValue", @@ -1184,6 +1206,17 @@ } ], "restartPolicy": "restartPolicyValue", + "restartPolicyRules": [ + { + "action": "actionValue", + "exitCodes": { + "operator": "operatorValue", + "values": [ + 2 + ] + } + } + ], "volumeMounts": [ { "name": "nameValue", diff --git a/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.pb b/staging/src/k8s.io/api/testdata/HEAD/core.v1.PodTemplate.pb index 55f522f81a3684243813fe9a33a989dac1a96308..eac7bca8913510e6821eece47b017008b91b93ce 100644 GIT binary patch delta 186 zcmX>Swl;i%1XF+b<_5+TMy8b^5c+W7=4VW^xEMcgZsfhlrhJM~fr~paxg;|`FDx;q zG*w8Di#NX@wJ5P9zX&WKz_d9?WFi|>y(SUrS1>YeVlTu{CmnI#WmFM$HsPrsJWL`xyh7R)&CihXXfzFwf#*{Jhys`XZakDMke@?!@Gh z%>2Bt#GKMpAwe$Q{DRb?#FG3Xuz&!Q)Z~RC!kbTs)UrV}X%eAn1ta4oMw7`Od89U* XEA3!pnZU;du~C@_&6|&Cbua<|8rMRN delta 80 zcmdlQc_w0lI@A1!jhZQpO!q=2_cI1E9S8>VZUt=iV4lUrcwuv<^hGvCsmTjPgg3ty ZsbzzTY>rjB!N~HKmkXj`v#xdrBLK(}9ohf@ diff --git a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.yaml b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.yaml index 6a80319b2b7..7a42f9927a7 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.yaml +++ b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.Deployment.yaml @@ -360,6 +360,12 @@ spec: requests: requestsKey: "0" restartPolicy: restartPolicyValue + restartPolicyRules: + - action: actionValue + exitCodes: + operator: operatorValue + values: + - 2 securityContext: allowPrivilegeEscalation: true appArmorProfile: @@ -582,6 +588,12 @@ spec: requests: requestsKey: "0" restartPolicy: restartPolicyValue + restartPolicyRules: + - action: actionValue + exitCodes: + operator: operatorValue + values: + - 2 securityContext: allowPrivilegeEscalation: true appArmorProfile: @@ -807,6 +819,12 @@ spec: requests: requestsKey: "0" restartPolicy: restartPolicyValue + restartPolicyRules: + - action: actionValue + exitCodes: + operator: operatorValue + values: + - 2 securityContext: allowPrivilegeEscalation: true appArmorProfile: diff --git a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.json b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.json index 67b64e0ee57..7a31a723031 100644 --- a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.json +++ b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.json @@ -595,6 +595,17 @@ } ], "restartPolicy": "restartPolicyValue", + "restartPolicyRules": [ + { + "action": "actionValue", + "exitCodes": { + "operator": "operatorValue", + "values": [ + 2 + ] + } + } + ], "volumeMounts": [ { "name": "nameValue", @@ -898,6 +909,17 @@ } ], "restartPolicy": "restartPolicyValue", + "restartPolicyRules": [ + { + "action": "actionValue", + "exitCodes": { + "operator": "operatorValue", + "values": [ + 2 + ] + } + } + ], "volumeMounts": [ { "name": "nameValue", @@ -1201,6 +1223,17 @@ } ], "restartPolicy": "restartPolicyValue", + "restartPolicyRules": [ + { + "action": "actionValue", + "exitCodes": { + "operator": "operatorValue", + "values": [ + 2 + ] + } + } + ], "volumeMounts": [ { "name": "nameValue", diff --git a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.pb b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.ReplicaSet.pb index d0de3196ff81ff3701c4a0583c25c5ba0312a391..89749c919c7dc9edf1946f1c1d68d5104e4fec7b 100644 GIT binary patch delta 196 zcmewwelKEzI@898jhZQpjQ=M0F$OWM3;}VN4hL@bV4lUr_<6IN^hGw6Q;Z5++=rjB!N~HKmkXj`v#z!wBLKYQ9bEtb 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 2be68fcae06..1bd12ba887a 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 @@ -350,6 +350,12 @@ spec: requests: requestsKey: "0" restartPolicy: restartPolicyValue + restartPolicyRules: + - action: actionValue + exitCodes: + operator: operatorValue + values: + - 2 securityContext: allowPrivilegeEscalation: true appArmorProfile: @@ -572,6 +578,12 @@ spec: requests: requestsKey: "0" restartPolicy: restartPolicyValue + restartPolicyRules: + - action: actionValue + exitCodes: + operator: operatorValue + values: + - 2 securityContext: allowPrivilegeEscalation: true appArmorProfile: @@ -797,6 +809,12 @@ spec: requests: requestsKey: "0" restartPolicy: restartPolicyValue + restartPolicyRules: + - action: actionValue + exitCodes: + operator: operatorValue + values: + - 2 securityContext: allowPrivilegeEscalation: true appArmorProfile: diff --git a/staging/src/k8s.io/client-go/applyconfigurations/core/v1/container.go b/staging/src/k8s.io/client-go/applyconfigurations/core/v1/container.go index eed5f7d0273..4694b12fa28 100644 --- a/staging/src/k8s.io/client-go/applyconfigurations/core/v1/container.go +++ b/staging/src/k8s.io/client-go/applyconfigurations/core/v1/container.go @@ -36,6 +36,7 @@ type ContainerApplyConfiguration struct { Resources *ResourceRequirementsApplyConfiguration `json:"resources,omitempty"` ResizePolicy []ContainerResizePolicyApplyConfiguration `json:"resizePolicy,omitempty"` RestartPolicy *corev1.ContainerRestartPolicy `json:"restartPolicy,omitempty"` + RestartPolicyRules []ContainerRestartRuleApplyConfiguration `json:"restartPolicyRules,omitempty"` VolumeMounts []VolumeMountApplyConfiguration `json:"volumeMounts,omitempty"` VolumeDevices []VolumeDeviceApplyConfiguration `json:"volumeDevices,omitempty"` LivenessProbe *ProbeApplyConfiguration `json:"livenessProbe,omitempty"` @@ -169,6 +170,19 @@ func (b *ContainerApplyConfiguration) WithRestartPolicy(value corev1.ContainerRe return b } +// WithRestartPolicyRules adds the given value to the RestartPolicyRules field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the RestartPolicyRules field. +func (b *ContainerApplyConfiguration) WithRestartPolicyRules(values ...*ContainerRestartRuleApplyConfiguration) *ContainerApplyConfiguration { + for i := range values { + if values[i] == nil { + panic("nil value passed to WithRestartPolicyRules") + } + b.RestartPolicyRules = append(b.RestartPolicyRules, *values[i]) + } + return b +} + // WithVolumeMounts adds the given value to the VolumeMounts field in the declarative configuration // and returns the receiver, so that objects can be build by chaining "With" function invocations. // If called multiple times, values provided by each call will be appended to the VolumeMounts field. diff --git a/staging/src/k8s.io/client-go/applyconfigurations/core/v1/containerrestartrule.go b/staging/src/k8s.io/client-go/applyconfigurations/core/v1/containerrestartrule.go new file mode 100644 index 00000000000..6ec09000f97 --- /dev/null +++ b/staging/src/k8s.io/client-go/applyconfigurations/core/v1/containerrestartrule.go @@ -0,0 +1,52 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1 + +import ( + corev1 "k8s.io/api/core/v1" +) + +// ContainerRestartRuleApplyConfiguration represents a declarative configuration of the ContainerRestartRule type for use +// with apply. +type ContainerRestartRuleApplyConfiguration struct { + Action *corev1.ContainerRestartRuleAction `json:"action,omitempty"` + ExitCodes *ContainerRestartRuleOnExitCodesApplyConfiguration `json:"exitCodes,omitempty"` +} + +// ContainerRestartRuleApplyConfiguration constructs a declarative configuration of the ContainerRestartRule type for use with +// apply. +func ContainerRestartRule() *ContainerRestartRuleApplyConfiguration { + return &ContainerRestartRuleApplyConfiguration{} +} + +// WithAction sets the Action 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 Action field is set to the value of the last call. +func (b *ContainerRestartRuleApplyConfiguration) WithAction(value corev1.ContainerRestartRuleAction) *ContainerRestartRuleApplyConfiguration { + b.Action = &value + return b +} + +// WithExitCodes sets the ExitCodes 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 ExitCodes field is set to the value of the last call. +func (b *ContainerRestartRuleApplyConfiguration) WithExitCodes(value *ContainerRestartRuleOnExitCodesApplyConfiguration) *ContainerRestartRuleApplyConfiguration { + b.ExitCodes = value + return b +} diff --git a/staging/src/k8s.io/client-go/applyconfigurations/core/v1/containerrestartruleonexitcodes.go b/staging/src/k8s.io/client-go/applyconfigurations/core/v1/containerrestartruleonexitcodes.go new file mode 100644 index 00000000000..6bfd9619dfa --- /dev/null +++ b/staging/src/k8s.io/client-go/applyconfigurations/core/v1/containerrestartruleonexitcodes.go @@ -0,0 +1,54 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1 + +import ( + corev1 "k8s.io/api/core/v1" +) + +// ContainerRestartRuleOnExitCodesApplyConfiguration represents a declarative configuration of the ContainerRestartRuleOnExitCodes type for use +// with apply. +type ContainerRestartRuleOnExitCodesApplyConfiguration struct { + Operator *corev1.ContainerRestartRuleOnExitCodesOperator `json:"operator,omitempty"` + Values []int32 `json:"values,omitempty"` +} + +// ContainerRestartRuleOnExitCodesApplyConfiguration constructs a declarative configuration of the ContainerRestartRuleOnExitCodes type for use with +// apply. +func ContainerRestartRuleOnExitCodes() *ContainerRestartRuleOnExitCodesApplyConfiguration { + return &ContainerRestartRuleOnExitCodesApplyConfiguration{} +} + +// WithOperator sets the Operator 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 Operator field is set to the value of the last call. +func (b *ContainerRestartRuleOnExitCodesApplyConfiguration) WithOperator(value corev1.ContainerRestartRuleOnExitCodesOperator) *ContainerRestartRuleOnExitCodesApplyConfiguration { + b.Operator = &value + return b +} + +// WithValues adds the given value to the Values field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Values field. +func (b *ContainerRestartRuleOnExitCodesApplyConfiguration) WithValues(values ...int32) *ContainerRestartRuleOnExitCodesApplyConfiguration { + for i := range values { + b.Values = append(b.Values, values[i]) + } + return b +} diff --git a/staging/src/k8s.io/client-go/applyconfigurations/core/v1/ephemeralcontainer.go b/staging/src/k8s.io/client-go/applyconfigurations/core/v1/ephemeralcontainer.go index 4b74439fc10..d41c985366c 100644 --- a/staging/src/k8s.io/client-go/applyconfigurations/core/v1/ephemeralcontainer.go +++ b/staging/src/k8s.io/client-go/applyconfigurations/core/v1/ephemeralcontainer.go @@ -147,6 +147,19 @@ func (b *EphemeralContainerApplyConfiguration) WithRestartPolicy(value corev1.Co return b } +// WithRestartPolicyRules adds the given value to the RestartPolicyRules field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the RestartPolicyRules field. +func (b *EphemeralContainerApplyConfiguration) WithRestartPolicyRules(values ...*ContainerRestartRuleApplyConfiguration) *EphemeralContainerApplyConfiguration { + for i := range values { + if values[i] == nil { + panic("nil value passed to WithRestartPolicyRules") + } + b.EphemeralContainerCommonApplyConfiguration.RestartPolicyRules = append(b.EphemeralContainerCommonApplyConfiguration.RestartPolicyRules, *values[i]) + } + return b +} + // WithVolumeMounts adds the given value to the VolumeMounts field in the declarative configuration // and returns the receiver, so that objects can be build by chaining "With" function invocations. // If called multiple times, values provided by each call will be appended to the VolumeMounts field. diff --git a/staging/src/k8s.io/client-go/applyconfigurations/core/v1/ephemeralcontainercommon.go b/staging/src/k8s.io/client-go/applyconfigurations/core/v1/ephemeralcontainercommon.go index d5d13d27a07..cd9bf08fa69 100644 --- a/staging/src/k8s.io/client-go/applyconfigurations/core/v1/ephemeralcontainercommon.go +++ b/staging/src/k8s.io/client-go/applyconfigurations/core/v1/ephemeralcontainercommon.go @@ -36,6 +36,7 @@ type EphemeralContainerCommonApplyConfiguration struct { Resources *ResourceRequirementsApplyConfiguration `json:"resources,omitempty"` ResizePolicy []ContainerResizePolicyApplyConfiguration `json:"resizePolicy,omitempty"` RestartPolicy *corev1.ContainerRestartPolicy `json:"restartPolicy,omitempty"` + RestartPolicyRules []ContainerRestartRuleApplyConfiguration `json:"restartPolicyRules,omitempty"` VolumeMounts []VolumeMountApplyConfiguration `json:"volumeMounts,omitempty"` VolumeDevices []VolumeDeviceApplyConfiguration `json:"volumeDevices,omitempty"` LivenessProbe *ProbeApplyConfiguration `json:"livenessProbe,omitempty"` @@ -169,6 +170,19 @@ func (b *EphemeralContainerCommonApplyConfiguration) WithRestartPolicy(value cor return b } +// WithRestartPolicyRules adds the given value to the RestartPolicyRules field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the RestartPolicyRules field. +func (b *EphemeralContainerCommonApplyConfiguration) WithRestartPolicyRules(values ...*ContainerRestartRuleApplyConfiguration) *EphemeralContainerCommonApplyConfiguration { + for i := range values { + if values[i] == nil { + panic("nil value passed to WithRestartPolicyRules") + } + b.RestartPolicyRules = append(b.RestartPolicyRules, *values[i]) + } + return b +} + // WithVolumeMounts adds the given value to the VolumeMounts field in the declarative configuration // and returns the receiver, so that objects can be build by chaining "With" function invocations. // If called multiple times, values provided by each call will be appended to the VolumeMounts field. 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 8a827c167a7..a7abe83da3b 100644 --- a/staging/src/k8s.io/client-go/applyconfigurations/internal/internal.go +++ b/staging/src/k8s.io/client-go/applyconfigurations/internal/internal.go @@ -5333,6 +5333,12 @@ var schemaYAML = typed.YAMLObject(`types: - name: restartPolicy type: scalar: string + - name: restartPolicyRules + type: + list: + elementType: + namedType: io.k8s.api.core.v1.ContainerRestartRule + elementRelationship: atomic - name: securityContext type: namedType: io.k8s.api.core.v1.SecurityContext @@ -5416,6 +5422,27 @@ var schemaYAML = typed.YAMLObject(`types: type: scalar: string default: "" +- name: io.k8s.api.core.v1.ContainerRestartRule + map: + fields: + - name: action + type: + scalar: string + - name: exitCodes + type: + namedType: io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes +- name: io.k8s.api.core.v1.ContainerRestartRuleOnExitCodes + map: + fields: + - name: operator + type: + scalar: string + - name: values + type: + list: + elementType: + scalar: numeric + elementRelationship: associative - name: io.k8s.api.core.v1.ContainerState map: fields: @@ -5781,6 +5808,12 @@ var schemaYAML = typed.YAMLObject(`types: - name: restartPolicy type: scalar: string + - name: restartPolicyRules + type: + list: + elementType: + namedType: io.k8s.api.core.v1.ContainerRestartRule + elementRelationship: atomic - name: securityContext type: namedType: io.k8s.api.core.v1.SecurityContext diff --git a/staging/src/k8s.io/client-go/applyconfigurations/utils.go b/staging/src/k8s.io/client-go/applyconfigurations/utils.go index d2ca116b611..8d1a396b1ea 100644 --- a/staging/src/k8s.io/client-go/applyconfigurations/utils.go +++ b/staging/src/k8s.io/client-go/applyconfigurations/utils.go @@ -726,6 +726,10 @@ func ForKind(kind schema.GroupVersionKind) interface{} { return &applyconfigurationscorev1.ContainerPortApplyConfiguration{} case corev1.SchemeGroupVersion.WithKind("ContainerResizePolicy"): return &applyconfigurationscorev1.ContainerResizePolicyApplyConfiguration{} + case corev1.SchemeGroupVersion.WithKind("ContainerRestartRule"): + return &applyconfigurationscorev1.ContainerRestartRuleApplyConfiguration{} + case corev1.SchemeGroupVersion.WithKind("ContainerRestartRuleOnExitCodes"): + return &applyconfigurationscorev1.ContainerRestartRuleOnExitCodesApplyConfiguration{} case corev1.SchemeGroupVersion.WithKind("ContainerState"): return &applyconfigurationscorev1.ContainerStateApplyConfiguration{} case corev1.SchemeGroupVersion.WithKind("ContainerStateRunning"): diff --git a/test/compatibility_lifecycle/reference/versioned_feature_list.yaml b/test/compatibility_lifecycle/reference/versioned_feature_list.yaml index ae50a933aa7..4de2739f57c 100644 --- a/test/compatibility_lifecycle/reference/versioned_feature_list.yaml +++ b/test/compatibility_lifecycle/reference/versioned_feature_list.yaml @@ -261,6 +261,12 @@ lockToDefault: false preRelease: Beta version: "1.30" +- name: ContainerRestartRules + versionedSpecs: + - default: false + lockToDefault: false + preRelease: Alpha + version: "1.34" - name: ContainerStopSignals versionedSpecs: - default: false