diff --git a/go.mod b/go.mod index 97e9c9f63a..5921cb049d 100644 --- a/go.mod +++ b/go.mod @@ -12,7 +12,7 @@ require ( github.com/mikefarah/yq/v3 v3.0.0-20201202084205-8846255d1c37 github.com/onsi/ginkgo/v2 v2.1.3 github.com/openshift/api v0.0.0-20200331152225-585af27e34fd - github.com/operator-framework/api v0.15.0 + github.com/operator-framework/api v0.16.0 github.com/operator-framework/operator-lifecycle-manager v0.0.0-00010101000000-000000000000 github.com/operator-framework/operator-registry v1.17.5 github.com/sirupsen/logrus v1.8.1 diff --git a/manifests/0000_50_olm_00-namespace.yaml b/manifests/0000_50_olm_00-namespace.yaml index fc1de8ca9b..d13be75c31 100644 --- a/manifests/0000_50_olm_00-namespace.yaml +++ b/manifests/0000_50_olm_00-namespace.yaml @@ -2,23 +2,27 @@ apiVersion: v1 kind: Namespace metadata: name: openshift-operator-lifecycle-manager + labels: + pod-security.kubernetes.io/enforce: restricted + pod-security.kubernetes.io/enforce-version: latest + openshift.io/scc: "anyuid" + openshift.io/cluster-monitoring: "true" annotations: openshift.io/node-selector: "" workload.openshift.io/allowed: "management" include.release.openshift.io/ibm-cloud-managed: "true" include.release.openshift.io/self-managed-high-availability: "true" - labels: - openshift.io/scc: "anyuid" - openshift.io/cluster-monitoring: "true" --- apiVersion: v1 kind: Namespace metadata: name: openshift-operators + labels: + pod-security.kubernetes.io/enforce: baseline + pod-security.kubernetes.io/enforce-version: latest + openshift.io/scc: "anyuid" annotations: openshift.io/node-selector: "" workload.openshift.io/allowed: "management" include.release.openshift.io/ibm-cloud-managed: "true" include.release.openshift.io/self-managed-high-availability: "true" - labels: - openshift.io/scc: "anyuid" diff --git a/manifests/0000_50_olm_00-subscriptions.crd.yaml b/manifests/0000_50_olm_00-subscriptions.crd.yaml index ce6b6c9e93..8618f9d66b 100644 --- a/manifests/0000_50_olm_00-subscriptions.crd.yaml +++ b/manifests/0000_50_olm_00-subscriptions.crd.yaml @@ -65,6 +65,467 @@ spec: description: SubscriptionConfig contains configuration specified for a subscription. type: object properties: + affinity: + description: If specified, overrides the pod's scheduling constraints. nil sub-attributes will *not* override the original values in the pod.spec for those sub-attributes. Use empty object ({}) to erase original sub-attribute values. + type: object + properties: + nodeAffinity: + description: Describes node affinity scheduling rules for the pod. + type: object + properties: + preferredDuringSchedulingIgnoredDuringExecution: + description: The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred. + type: array + items: + description: An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op). + type: object + required: + - preference + - weight + properties: + preference: + description: A node selector term, associated with the corresponding weight. + type: object + properties: + matchExpressions: + description: A list of node selector requirements by node's labels. + type: array + items: + description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: The label key that the selector applies to. + type: string + operator: + description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. + type: string + values: + description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchFields: + description: A list of node selector requirements by node's fields. + type: array + items: + description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: The label key that the selector applies to. + type: string + operator: + description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. + type: string + values: + description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch. + type: array + items: + type: string + weight: + description: Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100. + type: integer + format: int32 + requiredDuringSchedulingIgnoredDuringExecution: + description: If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node. + type: object + required: + - nodeSelectorTerms + properties: + nodeSelectorTerms: + description: Required. A list of node selector terms. The terms are ORed. + type: array + items: + description: A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm. + type: object + properties: + matchExpressions: + description: A list of node selector requirements by node's labels. + type: array + items: + description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: The label key that the selector applies to. + type: string + operator: + description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. + type: string + values: + description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchFields: + description: A list of node selector requirements by node's fields. + type: array + items: + description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: The label key that the selector applies to. + type: string + operator: + description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. + type: string + values: + description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch. + type: array + items: + type: string + podAffinity: + description: Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)). + type: object + properties: + preferredDuringSchedulingIgnoredDuringExecution: + description: The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. + type: array + items: + description: The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s) + type: object + required: + - podAffinityTerm + - weight + properties: + podAffinityTerm: + description: Required. A pod affinity term, associated with the corresponding weight. + type: object + required: + - topologyKey + properties: + labelSelector: + description: A label query over a set of resources, in this case pods. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaceSelector: + description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaces: + description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace". + type: array + items: + type: string + topologyKey: + description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. + type: string + weight: + description: weight associated with matching the corresponding podAffinityTerm, in the range 1-100. + type: integer + format: int32 + requiredDuringSchedulingIgnoredDuringExecution: + description: If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied. + type: array + items: + description: Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running + type: object + required: + - topologyKey + properties: + labelSelector: + description: A label query over a set of resources, in this case pods. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaceSelector: + description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaces: + description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace". + type: array + items: + type: string + topologyKey: + description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. + type: string + podAntiAffinity: + description: Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)). + type: object + properties: + preferredDuringSchedulingIgnoredDuringExecution: + description: The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. + type: array + items: + description: The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s) + type: object + required: + - podAffinityTerm + - weight + properties: + podAffinityTerm: + description: Required. A pod affinity term, associated with the corresponding weight. + type: object + required: + - topologyKey + properties: + labelSelector: + description: A label query over a set of resources, in this case pods. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaceSelector: + description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaces: + description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace". + type: array + items: + type: string + topologyKey: + description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. + type: string + weight: + description: weight associated with matching the corresponding podAffinityTerm, in the range 1-100. + type: integer + format: int32 + requiredDuringSchedulingIgnoredDuringExecution: + description: If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied. + type: array + items: + description: Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running + type: object + required: + - topologyKey + properties: + labelSelector: + description: A label query over a set of resources, in this case pods. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaceSelector: + description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaces: + description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace". + type: array + items: + type: string + topologyKey: + description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. + type: string env: description: Env is a list of environment variables to set in the container. Cannot be updated. type: array diff --git a/manifests/0000_50_olm_07-olm-operator.deployment.ibm-cloud-managed.yaml b/manifests/0000_50_olm_07-olm-operator.deployment.ibm-cloud-managed.yaml index 2bc94284f2..45f03c3871 100644 --- a/manifests/0000_50_olm_07-olm-operator.deployment.ibm-cloud-managed.yaml +++ b/manifests/0000_50_olm_07-olm-operator.deployment.ibm-cloud-managed.yaml @@ -21,6 +21,11 @@ spec: annotations: target.workload.openshift.io/management: '{"effect": "PreferredDuringScheduling"}' spec: + securityContext: + runAsNonRoot: true + runAsUser: 65534 + seccompProfile: + type: RuntimeDefault serviceAccountName: olm-operator-serviceaccount volumes: - name: srv-cert @@ -31,6 +36,10 @@ spec: secretName: pprof-cert containers: - name: olm-operator + securityContext: + allowPrivilegeEscalation: false + capabilities: + drop: ["ALL"] volumeMounts: - name: srv-cert mountPath: "/srv-cert" @@ -84,10 +93,6 @@ spec: requests: cpu: 10m memory: 160Mi - securityContext: - allowPrivilegeEscalation: false - capabilities: - drop: ["ALL"] nodeSelector: kubernetes.io/os: linux tolerations: @@ -103,8 +108,3 @@ spec: operator: Exists tolerationSeconds: 120 priorityClassName: system-cluster-critical - securityContext: - runAsNonRoot: true - runAsUser: 65534 - seccompProfile: - type: RuntimeDefault diff --git a/manifests/0000_50_olm_07-olm-operator.deployment.yaml b/manifests/0000_50_olm_07-olm-operator.deployment.yaml index 5a7189055f..0185a7b531 100644 --- a/manifests/0000_50_olm_07-olm-operator.deployment.yaml +++ b/manifests/0000_50_olm_07-olm-operator.deployment.yaml @@ -21,6 +21,11 @@ spec: annotations: target.workload.openshift.io/management: '{"effect": "PreferredDuringScheduling"}' spec: + securityContext: + runAsNonRoot: true + runAsUser: 65534 + seccompProfile: + type: RuntimeDefault serviceAccountName: olm-operator-serviceaccount volumes: - name: srv-cert @@ -31,6 +36,10 @@ spec: secretName: pprof-cert containers: - name: olm-operator + securityContext: + allowPrivilegeEscalation: false + capabilities: + drop: ["ALL"] volumeMounts: - name: srv-cert mountPath: "/srv-cert" @@ -84,10 +93,6 @@ spec: requests: cpu: 10m memory: 160Mi - securityContext: - allowPrivilegeEscalation: false - capabilities: - drop: ["ALL"] nodeSelector: kubernetes.io/os: linux node-role.kubernetes.io/master: "" @@ -104,8 +109,3 @@ spec: operator: Exists tolerationSeconds: 120 priorityClassName: system-cluster-critical - securityContext: - runAsNonRoot: true - runAsUser: 65534 - seccompProfile: - type: RuntimeDefault diff --git a/manifests/0000_50_olm_08-catalog-operator.deployment.ibm-cloud-managed.yaml b/manifests/0000_50_olm_08-catalog-operator.deployment.ibm-cloud-managed.yaml index 8149feec7e..18682d8180 100644 --- a/manifests/0000_50_olm_08-catalog-operator.deployment.ibm-cloud-managed.yaml +++ b/manifests/0000_50_olm_08-catalog-operator.deployment.ibm-cloud-managed.yaml @@ -21,6 +21,11 @@ spec: annotations: target.workload.openshift.io/management: '{"effect": "PreferredDuringScheduling"}' spec: + securityContext: + runAsNonRoot: true + runAsUser: 65534 + seccompProfile: + type: RuntimeDefault serviceAccountName: olm-operator-serviceaccount volumes: - name: srv-cert @@ -31,6 +36,10 @@ spec: secretName: pprof-cert containers: - name: catalog-operator + securityContext: + allowPrivilegeEscalation: false + capabilities: + drop: ["ALL"] volumeMounts: - name: srv-cert mountPath: "/srv-cert" @@ -55,6 +64,7 @@ spec: - /srv-cert/tls.key - --client-ca - /profile-collector-cert/tls.crt + - --set-workload-user-id=true image: quay.io/operator-framework/olm@sha256:de396b540b82219812061d0d753440d5655250c621c753ed1dc67d6154741607 imagePullPolicy: IfNotPresent ports: @@ -78,10 +88,6 @@ spec: env: - name: RELEASE_VERSION value: "0.0.1-snapshot" - securityContext: - allowPrivilegeEscalation: false - capabilities: - drop: ["ALL"] nodeSelector: kubernetes.io/os: linux tolerations: @@ -97,8 +103,3 @@ spec: operator: Exists tolerationSeconds: 120 priorityClassName: system-cluster-critical - securityContext: - runAsNonRoot: true - runAsUser: 65534 - seccompProfile: - type: RuntimeDefault diff --git a/manifests/0000_50_olm_08-catalog-operator.deployment.yaml b/manifests/0000_50_olm_08-catalog-operator.deployment.yaml index c44901b064..53167adeef 100644 --- a/manifests/0000_50_olm_08-catalog-operator.deployment.yaml +++ b/manifests/0000_50_olm_08-catalog-operator.deployment.yaml @@ -21,6 +21,11 @@ spec: annotations: target.workload.openshift.io/management: '{"effect": "PreferredDuringScheduling"}' spec: + securityContext: + runAsNonRoot: true + runAsUser: 65534 + seccompProfile: + type: RuntimeDefault serviceAccountName: olm-operator-serviceaccount volumes: - name: srv-cert @@ -31,6 +36,10 @@ spec: secretName: pprof-cert containers: - name: catalog-operator + securityContext: + allowPrivilegeEscalation: false + capabilities: + drop: ["ALL"] volumeMounts: - name: srv-cert mountPath: "/srv-cert" @@ -55,6 +64,7 @@ spec: - /srv-cert/tls.key - --client-ca - /profile-collector-cert/tls.crt + - --set-workload-user-id=true image: quay.io/operator-framework/olm@sha256:de396b540b82219812061d0d753440d5655250c621c753ed1dc67d6154741607 imagePullPolicy: IfNotPresent ports: @@ -78,10 +88,6 @@ spec: env: - name: RELEASE_VERSION value: "0.0.1-snapshot" - securityContext: - allowPrivilegeEscalation: false - capabilities: - drop: ["ALL"] nodeSelector: kubernetes.io/os: linux node-role.kubernetes.io/master: "" @@ -98,8 +104,3 @@ spec: operator: Exists tolerationSeconds: 120 priorityClassName: system-cluster-critical - securityContext: - runAsNonRoot: true - runAsUser: 65534 - seccompProfile: - type: RuntimeDefault diff --git a/pkg/manifests/csv.yaml b/pkg/manifests/csv.yaml index 6b0c595719..d43b1fe652 100644 --- a/pkg/manifests/csv.yaml +++ b/pkg/manifests/csv.yaml @@ -88,6 +88,11 @@ spec: target.workload.openshift.io/management: '{"effect": "PreferredDuringScheduling"}' creationTimestamp: null spec: + securityContext: + runAsNonRoot: true + runAsUser: 65534 + seccompProfile: + type: RuntimeDefault serviceAccountName: olm-operator-serviceaccount nodeSelector: kubernetes.io/os: linux @@ -106,6 +111,10 @@ spec: tolerationSeconds: 120 containers: - name: packageserver + securityContext: + allowPrivilegeEscalation: false + capabilities: + drop: ["ALL"] command: - /bin/package-server - -v=4 @@ -136,10 +145,6 @@ spec: volumeMounts: - name: tmpfs mountPath: /tmp - securityContext: - allowPrivilegeEscalation: false - capabilities: - drop: ["ALL"] volumes: - name: tmpfs emptyDir: {} @@ -154,11 +159,6 @@ spec: values: - packageserver topologyKey: "kubernetes.io/hostname" - securityContext: - runAsNonRoot: true - runAsUser: 65534 - seccompProfile: - type: RuntimeDefault maturity: alpha version: 0.19.0 apiservicedefinitions: diff --git a/staging/api/crds/operators.coreos.com_subscriptions.yaml b/staging/api/crds/operators.coreos.com_subscriptions.yaml index 7bcc8c94f1..3523401502 100644 --- a/staging/api/crds/operators.coreos.com_subscriptions.yaml +++ b/staging/api/crds/operators.coreos.com_subscriptions.yaml @@ -63,6 +63,467 @@ spec: description: SubscriptionConfig contains configuration specified for a subscription. type: object properties: + affinity: + description: If specified, overrides the pod's scheduling constraints. nil sub-attributes will *not* override the original values in the pod.spec for those sub-attributes. Use empty object ({}) to erase original sub-attribute values. + type: object + properties: + nodeAffinity: + description: Describes node affinity scheduling rules for the pod. + type: object + properties: + preferredDuringSchedulingIgnoredDuringExecution: + description: The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred. + type: array + items: + description: An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op). + type: object + required: + - preference + - weight + properties: + preference: + description: A node selector term, associated with the corresponding weight. + type: object + properties: + matchExpressions: + description: A list of node selector requirements by node's labels. + type: array + items: + description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: The label key that the selector applies to. + type: string + operator: + description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. + type: string + values: + description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchFields: + description: A list of node selector requirements by node's fields. + type: array + items: + description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: The label key that the selector applies to. + type: string + operator: + description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. + type: string + values: + description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch. + type: array + items: + type: string + weight: + description: Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100. + type: integer + format: int32 + requiredDuringSchedulingIgnoredDuringExecution: + description: If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node. + type: object + required: + - nodeSelectorTerms + properties: + nodeSelectorTerms: + description: Required. A list of node selector terms. The terms are ORed. + type: array + items: + description: A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm. + type: object + properties: + matchExpressions: + description: A list of node selector requirements by node's labels. + type: array + items: + description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: The label key that the selector applies to. + type: string + operator: + description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. + type: string + values: + description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchFields: + description: A list of node selector requirements by node's fields. + type: array + items: + description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: The label key that the selector applies to. + type: string + operator: + description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. + type: string + values: + description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch. + type: array + items: + type: string + podAffinity: + description: Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)). + type: object + properties: + preferredDuringSchedulingIgnoredDuringExecution: + description: The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. + type: array + items: + description: The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s) + type: object + required: + - podAffinityTerm + - weight + properties: + podAffinityTerm: + description: Required. A pod affinity term, associated with the corresponding weight. + type: object + required: + - topologyKey + properties: + labelSelector: + description: A label query over a set of resources, in this case pods. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaceSelector: + description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaces: + description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace". + type: array + items: + type: string + topologyKey: + description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. + type: string + weight: + description: weight associated with matching the corresponding podAffinityTerm, in the range 1-100. + type: integer + format: int32 + requiredDuringSchedulingIgnoredDuringExecution: + description: If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied. + type: array + items: + description: Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running + type: object + required: + - topologyKey + properties: + labelSelector: + description: A label query over a set of resources, in this case pods. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaceSelector: + description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaces: + description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace". + type: array + items: + type: string + topologyKey: + description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. + type: string + podAntiAffinity: + description: Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)). + type: object + properties: + preferredDuringSchedulingIgnoredDuringExecution: + description: The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. + type: array + items: + description: The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s) + type: object + required: + - podAffinityTerm + - weight + properties: + podAffinityTerm: + description: Required. A pod affinity term, associated with the corresponding weight. + type: object + required: + - topologyKey + properties: + labelSelector: + description: A label query over a set of resources, in this case pods. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaceSelector: + description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaces: + description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace". + type: array + items: + type: string + topologyKey: + description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. + type: string + weight: + description: weight associated with matching the corresponding podAffinityTerm, in the range 1-100. + type: integer + format: int32 + requiredDuringSchedulingIgnoredDuringExecution: + description: If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied. + type: array + items: + description: Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running + type: object + required: + - topologyKey + properties: + labelSelector: + description: A label query over a set of resources, in this case pods. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaceSelector: + description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaces: + description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace". + type: array + items: + type: string + topologyKey: + description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. + type: string env: description: Env is a list of environment variables to set in the container. Cannot be updated. type: array diff --git a/staging/api/crds/zz_defs.go b/staging/api/crds/zz_defs.go index 3578ef32e0..1a607ea5ea 100644 --- a/staging/api/crds/zz_defs.go +++ b/staging/api/crds/zz_defs.go @@ -225,7 +225,7 @@ func operatorsCoreosCom_operatorsYaml() (*asset, error) { return a, nil } -var _operatorsCoreosCom_subscriptionsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x7d\x6b\x73\xe3\xb8\x95\xe8\xf7\xf9\x15\x28\x27\x55\xb6\xb3\x92\xdc\x9d\x9d\x4d\x72\xbd\xa9\xa4\x3c\xb6\x3b\xd1\x4e\xb7\xdb\xdb\x72\xf7\x54\x6e\x92\x9b\x40\x24\x24\x61\x4c\x02\x1c\x00\x94\x5b\x79\xfc\xf7\x5b\x38\x07\x00\x41\xea\x45\xca\xf2\xa3\x67\xcc\x0f\x33\x6d\x0a\x00\x81\x83\x83\xf3\xc2\x79\xd0\x82\x7f\x62\x4a\x73\x29\x4e\x09\x2d\x38\xfb\x6c\x98\xb0\x7f\xe9\xc1\xed\x6f\xf4\x80\xcb\x93\xf9\xeb\xaf\x6e\xb9\x48\x4f\xc9\x79\xa9\x8d\xcc\x3f\x30\x2d\x4b\x95\xb0\x0b\x36\xe1\x82\x1b\x2e\xc5\x57\x39\x33\x34\xa5\x86\x9e\x7e\x45\x08\x15\x42\x1a\x6a\x5f\x6b\xfb\x27\x21\x89\x14\x46\xc9\x2c\x63\xaa\x3f\x65\x62\x70\x5b\x8e\xd9\xb8\xe4\x59\xca\x14\x0c\xee\x3f\x3d\x7f\x35\xf8\xcd\xe0\xd5\x57\x84\x24\x8a\x41\xf7\x1b\x9e\x33\x6d\x68\x5e\x9c\x12\x51\x66\xd9\x57\x84\x08\x9a\xb3\x53\xa2\xcb\xb1\x4e\x14\x2f\xe0\x13\x03\x59\x30\x45\x8d\x54\x7a\x90\x48\xc5\xa4\xfd\x5f\xfe\x95\x2e\x58\x62\x3f\x3e\x55\xb2\x2c\x4e\xc9\xca\x36\x38\x9c\x9f\x23\x35\x6c\x2a\x15\xf7\x7f\x13\xd2\x27\x32\xcb\xe1\xdf\xb8\xf6\x51\xf4\x55\x78\x9d\x71\x6d\xbe\x5d\xfa\xe9\x2d\xd7\x06\x7e\x2e\xb2\x52\xd1\xac\x31\x5b\xf8\x45\xcf\xa4\x32\x57\xd5\xb7\xed\xb7\x74\x39\x8e\xff\xed\x1a\x72\x31\x2d\x33\xaa\xea\x83\x7c\x45\x88\x4e\x64\xc1\x4e\x09\x8c\x51\xd0\x84\xa5\x5f\x11\xe2\xe0\xe8\xc6\xec\x13\x9a\xa6\xb0\x37\x34\xbb\x56\x5c\x18\xa6\xce\x65\x56\xe6\x22\x7c\xd3\xb6\x49\x59\x18\xf5\x94\xdc\xcc\x18\x29\x68\x72\x4b\xa7\xcc\x7f\x6f\xcc\x52\x62\x64\xe8\x40\xc8\xf7\x5a\x8a\x6b\x6a\x66\xa7\x64\x60\x41\x3c\xb0\x10\x8c\x7e\xc6\xfd\xb9\xc6\x41\xa2\xf7\x66\x61\xa7\xab\x8d\xe2\x62\xba\xe9\xf3\x09\x35\x34\x93\x53\x82\xf8\x45\x26\x52\x11\x33\x63\xc4\x7e\x8a\x4f\x38\x4b\xfd\xfc\x36\xcc\x08\xbb\x2e\xcd\x69\xd4\x7c\xdd\x7a\x4a\x33\x2a\x04\xcb\x88\x9c\x90\xb2\x48\xa9\x61\x9a\x18\x59\xc1\x67\x33\x78\x5c\xe7\xa5\xd9\x9c\x2f\xbd\x5f\x31\x1d\x6c\x3a\x7f\x4d\xb3\x62\x46\x5f\xbb\x97\x3a\x99\xb1\x9c\x56\x7b\x28\x0b\x26\xce\xae\x87\x9f\xfe\x73\xd4\xf8\x81\xd4\x97\x12\xa3\x28\xb9\x65\xac\xd0\xd5\xa1\x20\x65\x61\xd7\x64\x17\x47\xc6\x0b\x62\x14\x4d\x6e\xb9\x98\xc2\xd2\xa7\xb8\xde\x73\xdc\x18\x3d\x58\x9a\xb2\x1c\x7f\xcf\x12\x13\xbd\x56\xec\x87\x92\x2b\x96\xc6\x53\xb1\x90\xf5\x24\xa2\xf1\xda\xc2\x29\x7a\x55\x28\x3b\x2d\x13\x9d\x43\x7c\x22\x1a\x55\x7b\xdf\x58\xe6\xa1\x85\x05\xb6\x23\xa9\x25\x4f\x76\xfa\x33\xe6\x0f\x07\x4b\x1d\x00\xed\x76\x9a\x19\xd7\x44\xb1\x42\x31\xcd\x04\x12\x2c\xfb\x9a\x0a\xb7\xa6\x01\x19\x31\x65\x3b\xda\x03\x5b\x66\xa9\xa5\x63\x73\xa6\x0c\x51\x2c\x91\x53\xc1\xff\x11\x46\x03\x10\xd9\xcf\x64\x16\x3f\x0c\x81\xe3\x26\x68\x46\xe6\x34\x2b\x59\x8f\x50\x91\x92\x9c\x2e\x88\x62\x76\x5c\x52\x8a\x68\x04\x68\xa2\x07\xe4\x9d\x54\x8c\x70\x31\x91\xa7\x64\x66\x4c\xa1\x4f\x4f\x4e\xa6\xdc\x78\x0a\x9c\xc8\x3c\x2f\x05\x37\x8b\x13\x20\xa6\x7c\x5c\xda\x8d\x3b\x49\xd9\x9c\x65\x27\x9a\x4f\xfb\x54\x25\x33\x6e\x58\x62\x4a\xc5\x4e\x68\xc1\xfb\x30\x59\x81\x24\x32\x4f\x7f\xa6\x1c\xcd\xd6\x87\x0d\xf0\xad\x3c\x07\xc4\x53\xbd\x8d\xb0\xb6\xc4\x8f\x70\x4d\xa8\xeb\x8e\x6b\xa9\x40\x6a\x5f\x59\xa8\x7c\xb8\x1c\xdd\x10\x3f\x01\x04\x3b\x42\xb8\x6a\xaa\x2b\x60\x5b\x40\x71\x31\x61\x0a\x5b\x4e\x94\xcc\x61\x14\x26\xd2\x42\x72\x61\xe0\x8f\x24\xe3\x4c\x18\x7b\x0c\x73\x6e\x34\xe0\x1c\xd3\xc6\xee\xc3\x80\x9c\x03\x03\x22\x63\xe6\x0e\x6c\x3a\x20\x43\x41\xce\x69\xce\xb2\x73\xaa\xd9\x83\x83\xda\x42\x54\xf7\x2d\xf8\xda\x03\x3b\xe6\x9f\xcb\x1d\x96\xce\x18\x21\x9e\xc1\xad\xdd\x9d\xf8\xc0\x8f\x0a\x96\x84\xe3\x40\x05\x39\x2b\x8a\x8c\x27\x88\xf1\x66\x46\x0d\x49\xa8\xb0\xf0\xe2\x42\x1b\x9a\x65\xc0\x4e\x5a\xcd\x62\xdd\x69\x27\x70\xb4\x1b\xcc\xc1\xbf\x5e\xa2\xd0\xf5\x1f\x02\x53\x6b\xb4\x58\x47\x19\xec\xe3\xe8\xec\xf2\x0f\x1b\x40\x4e\x50\x32\x99\xf0\xe9\xaa\x6e\x6b\x61\x79\x0e\x5d\x40\xa6\xa1\x5c\x68\x37\x44\xa9\x10\x9a\x15\xa7\xb2\xbc\x8b\xd6\xf8\xf6\x60\xed\xec\x56\x42\x76\xdb\x9a\xed\xc3\xc4\x7c\xf5\x0f\x8d\x05\x5c\x8a\x39\x1e\x54\x2b\xb3\x58\x22\xc7\xc4\x9c\x2b\x29\x72\x7b\x88\xe6\x54\x71\x3a\xce\x1c\x63\x63\x96\x7c\xe1\x19\xc3\x25\x32\xb5\xea\x48\xad\xf9\x2a\xae\x87\x2a\x45\x17\x6b\x5a\x70\xc3\xf2\x35\xab\x59\x35\xed\x4f\x54\x45\x54\xc2\x22\xef\xaa\xa9\x13\xd7\xc0\x4e\x9d\x92\xf3\x30\xf1\xb5\x9f\xd9\x02\x77\x7c\xd6\xe3\x76\xf5\xac\xc1\x72\xff\x6c\xdb\x40\x7c\x80\xd3\x6f\xf8\xbd\x01\x16\x7b\x42\x90\x81\xb1\x95\xd0\x18\x90\x77\xa5\x86\xdd\xa2\xe4\xfc\x6f\xc3\x8b\xcb\xab\x9b\xe1\x9b\xe1\xe5\x87\xf5\xe0\x20\xdb\x0e\x4a\xf5\x00\x8d\xef\x30\xd9\xc3\x4f\x7e\x8f\x14\x9b\x30\xc5\x44\xc2\x34\xf9\xf9\xd1\xa7\xb3\x0f\x7f\xbb\x3a\x7b\x77\x79\x4c\xa8\x62\x84\x7d\x2e\xa8\x48\x59\x4a\x4a\xed\x99\x46\xa1\xd8\x9c\xcb\x52\x67\x0b\x47\xb9\xd2\x35\x48\xdb\xc4\x56\xe0\xb6\x54\x2c\x88\x66\x6a\xce\x93\xd5\x20\xd2\x03\x32\x9c\x10\x5a\x21\x50\x12\x30\xdc\x32\xaa\x6c\xce\xd2\x1e\x0c\x1b\x26\xed\xbf\xc3\x45\x51\x1a\xcf\xf0\xee\x78\x96\xc1\xa9\x10\x28\x2b\xa5\x03\x72\x21\x4b\x3b\xde\xcf\x7f\x0e\x0b\x53\x2c\x2d\x13\x10\xa2\x2d\x31\xe0\x62\x6a\x7f\xea\x91\xbb\x19\x4f\x66\x84\x66\x99\xbc\xd3\x40\x29\x98\x4e\x68\xe1\x97\x1e\x43\x47\x2f\x84\xa1\x9f\x4f\x09\x1f\xb0\x01\x39\xf8\x79\xf4\xd3\x01\x7e\xbd\x50\xd2\x7e\x02\xe5\x64\x9c\x55\xc6\x0d\x53\x34\x23\x07\x71\xeb\x01\xb9\xb4\xdf\x60\x69\xbc\x0f\x30\x82\x60\x73\xa6\xec\x2a\xfc\x2e\xf4\x88\x62\x53\xaa\xd2\x8c\x69\x6d\xf1\xec\x6e\xc6\xcc\x8c\xa1\x28\x1e\x00\xc6\x3e\x73\xcb\x70\xa5\x22\x42\x9a\x01\xb9\x60\x13\x5a\x66\xc0\x81\xc9\xc1\xc1\xa0\xc9\xf8\x76\x47\xb5\x37\x4a\xe6\x1d\xd0\x6d\x54\xd7\x1c\x56\xed\xfd\xa1\xc6\x91\x6b\x64\x4d\xb3\x94\xf0\x89\x93\x60\xb8\xb6\x8b\x22\x2c\x2f\xcc\xa2\xcd\xa1\xd9\x42\x47\x48\x6b\x42\x40\x02\x4f\x7a\x47\x8b\x6f\xd9\xe2\x03\x9b\x6c\x6b\xde\x5c\x3f\xcb\x58\x62\x09\x25\xb9\x65\x0b\x10\x67\xc9\xb9\x1f\x70\xf3\x52\x3a\x2d\x87\xb4\x24\x8f\xfe\xe9\xdb\xe9\x6c\x6d\xd7\x1e\x48\xf6\xb9\x65\x8b\x36\xcd\xc8\xb2\x4e\x67\x41\x03\xbc\xce\xc2\x6a\x3b\x54\x48\x7b\x94\xf5\xcf\x76\x8a\xbe\x72\x72\x87\x31\x69\x77\xe7\xd4\xac\x14\x58\x6f\xcb\x31\x53\x82\x19\x06\x32\x6b\x2a\x13\x6d\xc5\xd5\x84\x15\x46\x9f\xc8\xb9\xa5\x7c\xec\xee\xe4\x4e\x2a\xab\xc8\xf5\xef\xb8\x99\xf5\x71\x57\xf5\x09\x18\x3d\x4e\x7e\x06\xff\x23\x37\xef\x2f\xde\x9f\x92\xb3\x34\x25\x12\x8e\x78\xa9\xd9\xa4\xcc\xc8\x84\xb3\x2c\xd5\x83\x48\xeb\xea\x81\x3e\xd0\x23\x25\x4f\x7f\xbf\xf9\x70\xef\x08\x31\x59\xa0\xb1\x62\x07\xa8\x8d\x40\xe8\x5a\xd4\xe8\x54\x40\x7a\x4b\xa1\xac\x8a\x60\xf7\x3c\x77\x6c\xd1\x31\x94\x0e\xcb\x18\x4b\x99\x31\x2a\xb6\xf4\x00\xb0\x75\x3f\xb3\x87\xd5\xa1\x85\x11\x3c\x02\x14\x32\x3d\x25\xba\x2c\x0a\xa9\x8c\x0e\x2a\x02\xd8\x5c\x7a\xf5\x3f\x41\x5e\xee\x91\xbf\x87\x97\x19\x1d\xb3\x4c\xff\xf9\xf0\xf0\xb7\xdf\x5e\xfe\xe9\x77\x87\x87\x7f\xfd\x7b\xfc\x6b\x64\xa1\xab\x37\x41\x9b\x8e\x4c\x41\x08\x77\x7f\x3a\x36\x7a\x96\x24\xb2\x14\xc6\xfd\x60\xa8\x29\xf5\x60\x26\xb5\x19\x5e\x87\x3f\x0b\x99\x36\xff\xd2\x5b\x38\x01\x79\x58\xa2\x03\xe0\xbc\xa6\x66\xb6\x67\xd2\xb3\xde\x1a\xb1\xfa\xa9\x6d\xb7\xb7\x4f\xb8\x5d\x76\x06\x09\xfb\xcf\x37\x7e\xba\x96\x03\xdd\x29\x6e\x0c\x13\x20\x77\x30\x95\x5b\x4e\xdc\xb3\x98\x5b\xb1\xd9\xf9\xeb\x83\x07\x21\x5e\x01\x6a\x3b\x2c\x0e\x66\xef\x56\x86\xc8\x1c\x08\xad\x97\xa0\x2a\x1d\xe9\xec\x7a\xe8\x2d\x33\x7b\x5f\x88\xb7\x37\xbc\xb9\xf7\x99\x0c\x96\x0b\xb7\xac\x20\x69\x9e\x12\x29\xb2\x45\xf8\x5d\x93\x8c\x83\x35\xc2\x0a\xa0\xc1\x22\x71\x84\x2f\x07\x49\x51\xf6\x5c\x83\x41\xce\x72\xa9\x16\xe1\x4f\x56\xcc\x58\x6e\x25\xb6\xbe\x36\x52\xd1\x29\xeb\x85\xee\xd8\x2d\xfc\x85\x1d\x6b\x1f\x58\xee\x8d\x22\x75\x52\x2a\xcb\x3c\xb2\x85\xa7\x20\x2c\x7d\xda\xb3\xe8\xc1\xb4\xe7\xa3\x18\x76\xe3\x6a\x47\x96\x1b\xb4\x45\x67\x70\xf5\xab\x02\x19\x72\x2e\xb3\x32\x67\xba\x17\xd8\x13\x4a\xeb\x62\x6e\xa5\xc9\x25\xf3\xce\xea\xa7\xe3\xe9\x4b\xf9\x9c\x6b\xa9\x76\xe6\x83\xdc\x99\x3c\x65\x69\xac\xa6\x32\x91\x2a\xa7\x26\xa8\x8b\x9f\x0b\xa9\x41\x07\x70\x38\xdb\x20\x29\xaf\x0f\x5a\x7d\xb6\xa0\xc6\x30\x25\x4e\xc9\xff\x3b\xfa\xcb\x7f\xfc\xab\x7f\xfc\xfb\xa3\xa3\x3f\xbf\xea\xff\x9f\xbf\xfe\xc7\xd1\x5f\x06\xf0\x8f\x5f\x1c\xff\xfe\xf8\x5f\xfe\x8f\xff\x38\x3e\x3e\x3a\xfa\xf3\xb7\xef\xfe\x70\x73\x7d\xf9\x57\x7e\xfc\xaf\x3f\x8b\x32\xbf\xc5\xbf\xfe\x75\xf4\x67\x76\xf9\xd7\x96\x83\x1c\x1f\xff\xfe\xe7\xad\xa6\x47\xc5\xe2\x7d\x8b\x03\x8f\x4f\xdf\x6d\x10\x17\x86\x4d\x99\xea\xd8\xab\xf5\xb6\x12\xf2\xb9\x5f\x09\x6d\x7d\x2e\x4c\x5f\xaa\x3e\x76\x3f\x25\x46\x95\xdb\x0f\x46\x45\xd4\x76\xc1\xf3\x0f\xfe\xb4\x46\xa6\x58\x4f\x9a\xf7\x8e\xc8\x9a\x25\x8a\x99\x7d\x69\x30\x38\x9a\xe7\x1f\x85\x4c\x0f\x35\x11\x6b\xcc\x84\xeb\xa6\xfd\x93\x50\x6a\xbc\x48\x81\xf0\xaa\x38\xef\x44\xc9\x7c\x40\x22\xb3\xd0\x9c\x66\x3c\xf5\xed\x6e\xd9\x16\x2d\xd7\x3f\x2f\x4a\xd0\x97\xa5\x04\x8d\x70\x7f\x1f\x5c\x03\x62\x62\xbe\xc9\x4c\xd3\xb4\xe9\xda\xb6\x75\x73\xb4\x17\xa0\x8c\x24\x85\x2c\xca\x8c\x9a\x35\x66\xbb\x15\xb6\x69\x87\xfb\x3a\x98\x09\xed\x46\x83\x1d\xd8\x51\xb9\x7c\xb5\x31\x94\x9c\x65\x19\xe1\x02\x4f\x02\x0c\xe0\xad\x79\x8a\xa1\xbc\x44\x28\x1a\x9c\xe7\x76\x0a\x77\x33\xd6\x34\x34\x72\x6d\x75\x1d\x65\xb8\x98\x0e\xc8\x77\xf6\x77\xa4\x59\xce\x34\xc6\x05\xc9\xcb\xcc\xf0\x22\x63\x24\x70\x5b\xb4\xa1\x65\x25\x23\x54\x6b\x99\x70\x6a\xdc\x8c\xdd\xfd\xa1\x36\x7e\xda\x30\x1b\x43\x6f\xc1\x14\x9a\xb0\x94\x89\x84\x0d\xc8\x27\xb8\x2e\x0c\x6b\x1d\x5b\x61\x10\xcc\xfb\x30\x06\x25\x69\x89\x57\x3b\x48\x0f\x56\x8f\x31\xcc\xf3\xd2\x80\xa1\xf8\xb1\xac\xf8\x76\xc7\x9d\x65\x2e\x32\xe6\x03\xa9\x0a\xa2\x35\x85\xbb\x07\x39\xa9\x54\x77\x7d\x3f\xf3\x7d\x3b\xc2\x1b\xcc\x6d\x5b\x39\xd5\x12\xc5\xad\x6c\x0c\x75\x4a\xfb\xd8\x16\xc3\x76\x74\xf6\x47\x49\x63\x3b\xd0\xd7\xf6\xb4\xb5\x83\x71\xa9\x2b\x3d\x6d\x6b\x4d\x2a\x14\x9b\xf0\xcf\x1d\xf0\xf1\x4c\x54\x2a\x0a\x4f\x99\x30\x56\x11\x50\x40\x50\x15\x2b\x98\x00\x3d\x9c\xd1\x64\x06\x74\xc1\x51\xd1\xca\x32\xfc\x90\x37\x46\x28\x65\x74\x3f\x5e\xa3\x55\x52\xcc\xcb\xd9\xfa\x91\x9f\x2d\xb7\xeb\xfb\x3f\x58\x42\xa6\x0c\x75\x8b\xf5\xca\x75\x63\x1f\xa3\x1e\xce\xcf\xc5\xff\x85\x17\x78\x7e\x92\x56\x7b\x0b\x57\x4e\x85\x84\xb3\x36\xe1\x86\x48\x2b\x11\xd8\xef\x0e\xc8\x68\x45\xcf\x9c\x9a\x64\xe6\x5a\x1c\x1e\x6a\x82\x46\xdb\xe6\x40\x63\x34\x11\xa6\x65\xc6\x52\xe2\x1d\x36\x70\xd0\x8e\x28\x55\x73\x55\x38\xa1\x5a\xf3\xa9\xe8\x17\x32\xed\xdb\xd1\x4e\xd6\x21\x44\x8b\x43\x15\xbb\x1a\x6e\x3f\x58\x5b\xf1\x2a\x18\x27\xda\x6d\xd3\x87\x60\x7f\x8b\x64\x8b\x44\xe6\x45\x69\x58\x64\x9c\x0b\x76\x9d\xf1\x02\x3d\x8b\x22\x19\xb2\x92\x88\xee\x07\xd3\x9c\x0a\x3a\x65\x7d\xf7\xf1\x7e\xf8\x78\x3f\x7c\xeb\x3e\x60\x6e\x43\xb5\xd0\xa4\xb8\xe9\x1c\xd6\x81\xf7\x16\x4d\x96\xf8\x72\xec\x4c\x47\x39\xfd\xcc\xf3\x32\x27\x34\x97\xa5\x00\x99\x6c\x19\x9c\x70\x79\xcd\xd2\xfd\x00\x6c\x05\xa0\xf4\x5a\x48\xb5\x84\x16\xe9\x8c\x98\xe4\xf9\x5a\xb6\x5a\x59\xb4\xba\x59\xb2\x3a\x58\xb0\x76\xb6\x5c\x79\x23\x75\x7b\x7c\xfc\xe0\xed\xe6\x0d\x8c\xe4\x62\x2b\x46\xfa\x03\x0e\xae\x1d\x61\x1c\xae\x89\xcc\xb9\x31\xc1\x25\x2b\x60\x58\x8f\x70\x53\xb3\x7e\xba\xb3\xc0\x27\x48\x63\xb9\x26\xec\xb3\xd5\xa6\x38\x58\xd1\xfd\xad\x45\x0f\xb9\xec\x1d\xd7\x60\x40\xa3\x82\xf0\xbc\xc8\x58\xee\x7d\x48\xfb\x5e\x37\x73\x4e\x06\x2f\xe7\xe3\xe5\x7c\xac\xea\xa4\xbb\xc8\x22\xb1\x18\x82\x86\x82\x31\xcb\x2a\x71\xc4\x62\x76\x21\x53\xed\xe4\x05\x8f\x43\xf6\x2c\x5c\x7e\xe6\x1a\x3c\x71\x3f\x30\xb0\x0c\x8c\x98\xd1\xe4\x6e\x26\x35\xc3\x1e\x54\x31\x37\x4e\xc4\x1a\xbd\x25\x04\xee\x11\xc0\x69\x74\x32\xa9\xb7\x48\x59\x91\xc9\x45\x0e\x92\xed\xd0\xc4\xf2\x4c\x10\x5d\x58\x5e\x64\xd4\xb0\x20\xd8\x6c\xb6\x36\xdc\x9b\xf3\xc1\xd7\x2f\x3f\x5b\x09\x20\x8a\x83\x68\x01\xdb\x66\xc7\xba\x69\xaa\x01\x69\x47\x64\x72\xf4\x59\xbe\x01\x09\xbf\x7a\x03\xd0\x3c\xbb\xba\x58\xef\x20\x49\x5a\x99\x57\xc8\x76\x13\xcb\xd2\x32\xce\x36\x4c\xb5\x21\xbd\xa2\xcf\xaf\xf7\x60\x45\x0f\xf4\x1e\x1a\xaf\x7a\xce\x7d\x2e\x44\x07\x60\x63\xc5\x32\x0c\x7d\x70\x86\x66\xdb\xc8\x79\xae\xef\x47\x23\x6b\x6b\x77\x6f\x63\x73\xef\x87\xc9\xef\x49\x09\x6c\x65\x94\xaf\x6d\x06\x28\xd9\xf1\x51\x05\x97\x23\x0b\x49\xb4\xcf\xbb\x8d\xa0\x45\x91\xc1\x7d\x9d\x6c\xeb\x9b\xd5\x52\x1d\xc3\xe5\x77\x9c\x74\xd8\xf2\xd8\xe1\xd6\xce\xfc\x50\x23\x02\xd8\xd3\x31\xe3\x85\xf3\x66\x44\x6b\x9d\x8f\x5f\xf8\x04\x76\xd4\x2a\xa6\xc4\x9e\x84\xa1\xe8\x91\x2b\x69\xec\xff\x2e\xd1\x26\x6a\xf1\xe6\x42\x32\x7d\x25\x0d\xbc\xd9\xeb\xb2\x71\x2a\x1d\x17\x8d\x9d\xe0\x80\x08\x3c\x93\x60\x90\x8e\x02\x1a\xd0\x57\x14\x48\xa1\x07\x10\xd7\x64\x28\x88\x54\x7e\x75\xc1\xaa\xab\xdd\x10\x5e\x33\x14\x52\xf4\xd1\x8d\x70\xd5\x18\x97\xc1\x87\x32\x86\xc9\x86\xe1\xdc\x50\x37\x96\x02\xe3\x2f\x18\xc2\x92\xd1\x84\xa5\x24\x2d\x61\xd2\x10\x8e\x41\x0d\x9b\xf2\x84\xe4\x4c\x4d\x99\x65\xda\xc9\xac\x2d\xa8\xb7\xd1\x25\x7c\x5a\x50\xa7\x78\xd0\x2d\xfb\x07\x24\xf8\x2d\x70\x89\x6e\x64\x1b\xfb\x20\x79\xcb\x69\x61\xb7\xee\x9f\x96\x8a\x01\xf4\xfe\x4d\x0a\xca\x95\x1e\x90\x33\xef\x7a\x1b\xff\xe6\x6c\x60\xf1\x30\x76\x04\x2b\xf5\xfd\x50\xf2\x39\xcd\x2c\xdd\x44\x01\x8f\xa1\x78\x67\x47\x6f\x32\x8b\x9e\xe3\xa5\xf6\x7c\xa3\xbf\x0b\xd7\xe4\xe0\x96\x2d\x0e\x7a\x4b\xdb\x7d\x30\x14\x07\x48\x5f\x97\x36\x38\x10\x63\xf0\x28\x39\x80\xdf\x0e\xee\xc7\x5f\x1e\x40\xf8\xdb\xba\x97\x46\x66\x4c\xc5\xa1\x9f\x5b\xf6\xf0\xa6\x6a\x0f\x4b\xab\xae\x77\xa3\x91\x1e\xe7\x96\xe2\xc6\x8b\x2d\xf6\x6c\x55\xf3\x02\xd4\x32\x86\x26\x33\xf4\xe2\x76\xf3\x82\x38\x9a\x05\xb1\x7b\x66\x90\xae\x03\x62\x38\x0e\x69\x14\x5c\xfa\xfc\x36\x60\x5b\x8f\x81\xfc\xf4\xbb\xc8\xbf\x1d\xda\xdb\x3f\x02\x86\xfc\xd6\xff\xeb\x77\xf7\x8c\x5b\x68\xc7\xd8\x70\x4a\x1d\x04\x8c\x4b\xe8\x40\xb8\x48\xe1\x82\xc9\x2d\x15\x20\x80\x63\x59\xf8\xc0\xb2\x06\xe4\xd2\x12\x2a\x92\x33\x2a\xb4\x37\x73\xc1\x4d\x54\xd5\x58\xbb\x2b\xb3\x48\xaf\x72\x26\x85\xea\x64\x30\x72\x25\x47\xce\xf6\xd5\x23\xd7\x60\x4b\xad\xde\xc0\x49\xba\x92\x97\x9f\x59\x52\x9a\xb5\x77\x59\x31\xdc\xb6\x72\x91\xad\x8c\xbe\x06\x90\x6f\x2b\x26\x8f\x2b\xab\x31\xf9\x0a\x83\x63\x36\xbf\x11\x32\xb7\x6c\x51\x31\x1b\x27\x42\x00\xc9\xef\x55\x58\xe2\x59\x01\xf2\x8e\xff\xf6\xa6\xac\x7c\xcc\x05\x7e\x0c\x87\xf6\x5b\x01\xa3\x7b\x80\x5a\xc9\x2e\xcb\xf0\x33\xfb\x00\x57\x3b\x39\xa3\x06\xb3\xf7\x1d\x64\x8c\x40\x25\x57\x4b\x17\x91\x48\x71\xf9\x43\x49\xb3\x7a\x10\x82\x7b\xe5\x1a\x2d\x51\xf5\x3b\x9e\xa5\x09\x55\xce\xcb\x0b\xc3\x34\xb5\xc4\xdd\xa3\x40\x08\x12\x2a\xc2\x69\xaf\xf6\x48\xe3\x55\x65\x41\x95\xe1\x49\x99\x51\xe5\x23\xc7\x5b\x05\x0a\x6c\x85\x68\x85\x34\x23\x96\x48\x91\x76\x51\x00\x6e\x9a\x7d\x9b\x77\xad\x05\x53\x5c\xa2\x77\x31\xcf\x59\x13\x49\x8f\xea\x36\x6d\x39\xf1\xa7\x3a\x1c\xb1\x9a\xe5\x03\x62\x33\x3d\xc3\xe3\x53\x21\x15\x4b\x8f\x23\xf2\x18\x4e\xc5\x80\x7c\xb3\xf0\x66\x16\x30\xb9\xb8\xe8\x0a\xcd\x8c\x0f\x84\xf1\x28\xeb\x80\x5d\x1d\xa8\x89\x54\x10\x9c\x72\x94\x4a\x8c\xc8\x98\xf3\xc4\x1c\x0f\xc8\xff\x65\x4a\xc2\xc6\x0b\x36\xa5\x86\xcf\x03\x37\x0d\x8a\xab\x62\xd4\xdd\xe0\xbf\x22\x47\xd0\x8d\xf0\x3c\x67\x29\xa7\x86\x65\x8b\x63\xd4\x63\x19\xd1\x0b\x6d\x58\xde\x66\xeb\xda\x18\x0d\xd0\xd7\x0e\xda\xfe\xea\xeb\x0d\x2d\xbb\xc6\x50\x7d\xf2\x51\x29\x15\x64\xd0\x87\xa0\xb1\x85\x81\x07\xc9\x0d\xe2\x66\xec\x83\xe0\x02\x9b\xbd\x64\x19\x6f\xf0\xf7\x16\x0f\x28\x51\x0c\x32\x10\x38\xcc\xbd\x27\x8e\xa3\x37\xe5\x3b\x59\x8a\xf5\x26\xc1\xda\xc2\xdf\x3a\x25\xfc\x53\xd4\x71\x6d\x94\xe2\xa3\x88\x09\xd1\x4c\x22\x13\x25\x25\x60\x97\x04\x76\x6e\xc9\x03\xb6\xaa\x3c\x51\xb6\x4e\x72\xaf\x11\x89\x30\x97\x2d\x5e\xef\x7b\x89\x5b\x0c\x1f\xea\x80\xcb\xe0\x20\xee\x00\xd3\x88\xdb\x33\x8e\x1c\x00\x7e\x22\x04\x2b\x04\x85\x6f\xb1\xd4\x7b\xb1\x59\x6a\xe0\xba\x92\xc3\xd3\xc3\xbd\x10\x5f\x5c\x8e\x92\x05\x9d\xc2\x79\xea\xb0\xaa\x66\x57\x92\x32\xc3\x54\x0e\x01\xd7\x33\x79\x87\xbf\x23\xdb\x2a\x5c\x2b\x96\x56\xb1\xed\x33\xa9\x81\x2b\xd5\x83\x18\xe1\xfc\xc2\xc5\xe8\x1d\x5d\x10\xaa\x64\x29\x52\x27\x35\x05\x02\xfa\xae\xf1\xe1\x2b\x29\x80\x52\x94\xda\xc2\xea\xa6\x46\xa5\xc7\xcc\x50\x7b\x6c\x5e\x0f\x5e\xbf\xda\x0b\xc0\x3a\xc6\xad\xc2\x6c\x1a\x96\x42\x7f\x57\xee\xcf\xcc\x5e\xe6\xa5\x18\x4d\xdf\x8b\xac\x8b\x2c\xf7\x0e\xd1\x0b\xba\xf6\x41\x09\xe3\x13\xb0\xdd\xf6\xf0\xd5\x9d\xe2\x86\x45\xe4\xf1\x68\x42\x33\xcd\xac\xea\x5e\x8a\x20\xc2\x1e\xd7\x45\x10\x68\xd2\x66\x41\xdb\xfd\x41\x74\x39\xbe\xe7\x39\x73\x07\x0a\x50\xae\x3a\x66\x01\xe1\x0e\xf5\x86\x23\x57\x0f\xee\x24\x47\xd8\xd2\x4a\x6c\x52\x9a\xe3\xfd\x38\x89\xe0\x02\xad\x66\xdd\x45\x25\xf1\x71\xc3\xc5\x1e\x57\xfb\x0d\x9b\xd1\x39\xd3\x44\xf3\x9c\x67\x54\x65\x10\x2b\x38\xc2\xf9\x91\x71\x69\x56\x47\xa0\x77\x8b\x6e\x8e\x67\x12\x0d\xb7\x15\xd4\x7e\x1e\x16\x4e\x40\x23\xfc\xbc\xec\x77\xf2\xd2\x94\x34\xcb\x16\x84\x7d\x4e\xb2\x52\xf3\xf9\x7d\x4f\x93\x8b\x7e\xd8\x81\x55\x37\xb9\x74\x21\xd3\x51\xc1\x92\xc7\xe4\xd1\x75\x0d\xc3\x92\xaa\xd4\x6f\x3a\xf0\x64\x54\xf6\x41\x73\x5f\x80\xe7\x53\x92\x30\xad\xbd\x4f\xe5\x22\xf6\xf3\x0c\x6b\xf8\x52\x12\x0a\xd0\x3b\x7d\x99\x51\x6d\x78\xf2\x4d\x26\x93\xdb\x91\x91\xaa\x53\xcc\xfe\xaa\xfe\x8d\x34\x0c\x67\xdf\x8d\xc8\x05\xd7\xb7\x71\x62\x17\xbc\x34\x8d\xcd\x25\x94\xdc\x96\x63\x96\x31\x73\x78\xa8\x91\xcb\xe5\x34\x99\x71\xc1\x3c\x83\x13\x21\x24\xc5\x29\x7c\x16\xca\x5d\xef\x4c\x5d\xe0\xd3\x89\xc3\xd7\x9f\xd1\x3b\xcd\x70\xfa\x63\x3b\x7d\xfb\x33\x6b\x13\x91\xbe\xd7\x7b\x0a\x9c\xcc\xf0\x62\x4f\x77\x10\x13\x7d\x63\xe7\xd8\xcd\xb8\x7d\x88\xbd\xbc\xea\x30\xe1\x19\x43\x8d\x07\x16\xec\x7d\xd4\xdc\xa9\x80\xfd\x5b\xc8\x92\xdc\x51\xd4\x91\x81\x22\x0e\xc8\x0d\x2f\x4e\xc9\xa5\xd0\xa5\x62\x95\x75\xa3\x39\x14\xd7\x55\x9c\x99\x57\xae\x60\xbf\x51\x01\xb1\x74\xcf\xe9\x5a\xe4\xf2\x33\xcd\x8b\x8c\xe9\x53\x72\xc0\x3e\x9b\xaf\x0f\x7a\xe4\xe0\xf3\x44\xdb\xff\x09\x33\xd1\x07\x03\x32\xcc\xc3\xad\x3b\x24\x02\x52\xcc\x3b\x42\x61\x07\xcb\x9a\x23\xae\xfb\x20\xe8\xe2\x9c\xea\xac\xec\x96\x4a\x72\x87\xf9\x28\x2c\xc1\x67\x4a\x49\x15\xfc\xd0\x23\x30\x00\xaf\x49\x64\x5e\x28\x99\xf3\xc8\xcc\x07\xe8\xbe\x57\x6f\x3b\x30\x3e\x6c\x17\x50\x97\xb1\x21\x74\xf4\x08\x11\xbd\x10\x6d\x50\x61\x38\xf1\xce\x14\xa8\x45\x3a\xb5\x1e\x86\x73\x8d\xec\xe6\xbb\x51\x2c\x21\x8b\xb7\xfb\x4d\x08\xa8\x23\x27\x29\x9b\x9f\xe8\x94\xbe\xee\xc1\x67\xb4\x73\x04\xac\xcf\x89\x6a\x72\xf0\xfa\x60\x40\x46\x9e\x11\xf7\xe2\x39\x56\xed\x26\x52\x85\x01\xc1\xce\xfe\xea\x80\x1c\x49\x05\x23\x27\x54\x90\x8c\xd1\xb9\xb3\x2d\xe3\x71\x5b\xa0\xba\x7b\xdc\x3a\x20\xb2\x6d\x6c\x58\x64\x00\xf8\xcf\x5f\x6e\x69\xdd\x4e\x48\x5d\xde\x44\xdf\xcf\x9b\x00\x54\xe9\x62\x05\x26\x52\xb9\x3c\x20\xa1\x89\x66\x06\x8e\x1e\x17\x35\x15\xfa\x09\x08\x2c\xe9\x18\x4a\xef\xa9\x67\x57\xe8\xf8\x7e\xa0\x03\x09\xfe\x43\xc9\xc8\xf0\x22\x04\xd4\x33\xa5\xb9\x36\xf6\x18\xa7\x35\xd6\xc5\x91\x9f\x1d\x9d\xe5\xf4\x1f\x52\x90\xcb\x6f\x46\x6e\x02\xc7\x4f\x0a\xaa\xad\xd4\x80\xfe\xa3\x54\xcc\x72\xe1\x0e\xcc\x3d\xf4\x69\x32\x74\xfb\x9e\x5c\x50\x43\x91\xaf\x3b\x4f\x2b\x51\x91\x72\xcb\xb2\xc7\x5c\xa4\xee\xa7\x88\x61\x3f\x36\x6f\xb5\xbb\x77\xb5\x49\x4c\x8a\x1b\x7e\xfc\x30\xdc\x13\x0f\x4e\x80\x98\x4f\xdf\xc9\xb4\x33\x23\x8e\xba\x7a\xe2\xfb\x47\x0b\xd3\x73\x7c\x4f\x72\x3b\x26\xb1\xda\x7b\x8f\x7c\x60\x34\x25\xf6\xfc\xba\x7f\x7e\x67\x75\xcf\xd6\xb4\xaa\x15\x0b\xf1\x00\xec\xb8\x0c\xdf\xcd\x2f\x21\xf6\x74\x4f\x2d\xe6\xc0\xb1\x72\xbc\x64\x9c\xc9\x31\x71\xc7\x61\xdf\x73\xff\xf8\x61\xb8\xc3\xd4\x3f\x7e\x18\xfa\x99\xdb\x7f\xca\xc9\xe3\x4d\x7a\x27\xf1\xad\x92\xde\xde\x34\xc4\xad\x8a\x25\x57\x81\x1b\x4d\x91\xac\xbd\x3c\x36\xd8\x97\x24\xb6\x4f\x88\xad\xca\x3f\xb9\x05\x5e\x87\xb6\x8f\x55\x28\xd0\x57\x2d\xba\x47\x1c\xcd\x28\x84\x3e\x87\x80\x3c\xd8\x67\xbb\xf1\xda\x72\x05\xbf\xe3\x56\x09\x04\xda\x46\x2e\x18\xde\x72\xa6\xa7\xde\x77\x20\xf4\x58\xdd\xe1\x1d\x78\x6a\xa6\x8e\xbe\x12\x74\xdc\x4c\x23\x04\x3b\x42\xab\x92\x08\x3f\xd1\x39\xe5\x19\x1d\xf3\x8c\x1b\xe0\xd4\xc7\x83\x9a\x37\xaa\x86\x29\xef\xf5\xd4\xef\x28\x72\x04\x71\x62\xc9\xb8\x45\x8e\xec\x6f\x27\x60\x1c\x3b\x1e\x00\xb5\x82\x86\x33\xa6\x96\x84\x92\x0f\xdb\x84\x92\xbd\xc9\x0f\xb0\x03\xf6\xc4\x74\xe5\x8a\xb6\xcf\x4a\xae\x08\x3f\x8c\x5c\x3e\xb9\xe7\xcc\x18\x31\xd6\xaa\x15\x6b\x04\xfc\xda\xda\xb2\x3d\x73\xbc\x2f\x72\xa5\x5f\x06\x72\x91\x10\xd1\xb6\x03\xff\xac\x3a\x7a\x3e\x04\x4a\x12\x78\x9c\xb9\x68\xb7\x9a\x6b\x26\x62\xdf\xc8\xd1\x1a\x97\x82\x09\xb9\xae\xc5\xb9\x6f\x5b\xa4\x1f\xe8\x92\xb4\xc1\x63\x44\xd7\x55\xf9\x7e\x7e\x51\x48\x02\xe1\x35\x69\x81\x8b\xad\x27\x99\xb0\x62\x36\xe9\x72\x25\x6e\x3b\xbc\x19\xd5\x2d\x81\xe7\xac\x98\x91\x37\xa3\x15\xc7\x18\x60\x0f\xb3\xd6\x68\x1f\x3c\xd4\x24\xe3\x13\x66\xf8\x96\x25\x3c\xc0\x41\xce\xa5\xe0\x46\xaa\xf5\x21\xd0\xa4\xd3\xe1\xf4\xc3\x75\x65\xa8\xbe\x9f\xdd\xd9\x2a\x81\xc8\xbb\xe8\x2d\x25\x89\xcc\x32\x96\xf8\xf4\xd9\x00\xde\xd0\x6d\x85\xf2\xc4\x9c\x3d\x20\x14\x17\x40\x45\xe9\x04\x37\xf7\xe4\xc3\xe5\xd9\xc5\xbb\xcb\x41\x9e\xfe\x6c\x26\xef\xfa\x46\xf6\x4b\xcd\xfa\xbc\x45\x86\x92\xa7\xf3\x5e\xc4\xa7\x68\x95\x30\xab\x69\x90\xc1\x5c\x5f\xef\x7d\xfc\x24\xf9\xa8\xd1\x6b\x01\x6c\x47\xfe\x4e\x4a\x4a\xd3\x23\x8a\xba\x18\x49\xea\x4c\x4f\x65\x96\x21\xb4\x8d\x62\xac\x17\xdb\x62\x36\x86\x86\x74\x5e\xd8\xbd\x0d\x15\xb5\x05\x3e\xac\x0c\xf1\xf8\x08\xd7\x85\x63\x6c\x97\x49\x96\xa1\x58\xf5\xac\xc3\x71\x54\x7b\x8f\x86\x33\x33\xb3\x50\xbd\x65\x0b\x02\x8e\xc0\x13\xa9\x2c\x3e\xa9\x3a\x6e\x30\x93\xc0\xd2\x4f\x4a\xcd\xd4\xc0\xb1\x9d\x47\x07\x5b\x87\x2c\x42\x3b\x24\x6f\x0b\x1d\x57\xc1\xcc\xbd\xae\x32\xfb\x3a\x79\x8d\x96\x66\xc6\x84\xf1\x89\xd1\x1d\x64\x56\x02\xd1\xf9\x61\x3f\x3a\xd4\x5a\x26\x31\xea\x96\x72\xe8\x25\x4d\x4f\x17\x9c\xb4\xa7\xa6\x2b\x3a\xda\x3e\x10\x88\x18\x93\xf9\x10\xcb\xa5\x68\x2a\xc1\x61\x03\x33\xd0\xd5\x10\x8d\xa6\x39\x17\xcf\xf0\x74\x26\x5c\xa4\xdb\xe0\xd0\x30\x80\x41\x8f\xba\x28\xe6\xde\x39\x83\x7e\xb8\x37\xa4\x5e\x93\xc2\x80\x77\x77\x83\x58\xbf\x3f\x6c\x75\xf8\xf2\x85\xfe\x21\xeb\xe3\x57\xfa\x45\x5a\x41\xe5\xe5\x32\x70\xf9\x06\x6f\xbf\x26\xa5\x47\xb8\xe2\xdb\xd3\x6e\x93\x47\x96\x86\x1e\x56\xcf\x7d\x14\x40\x75\x91\x79\xee\xcb\xbd\x2b\x9a\x09\xd5\x5f\xb4\x0f\x3e\xc3\xcc\x66\x58\x46\xc6\xe9\xcb\x16\x1e\x05\x55\x34\x67\x86\x29\x74\x81\x73\x4e\x75\xc2\x45\x27\xbc\x2f\x98\x18\x19\x9a\xdc\xee\x3b\x15\xea\x0b\xc7\x7d\x38\x8e\x7b\xef\xab\x40\x8f\x08\x2e\x2f\xd2\x22\xbe\x45\xe6\xc2\x71\xa1\x67\x42\x62\x42\x3a\xb2\x2e\x56\x8e\x90\x8e\xaa\xce\x5d\xab\xf4\x64\x68\xd8\x00\x4f\xb7\x90\x5f\x0f\x3c\xf8\x11\x0a\xfb\xe1\x86\xed\xcf\x80\x23\x81\xbb\xdc\xa3\x45\x5d\xeb\xd4\x21\xb7\x6f\xc6\xdc\x54\xe7\x5e\x33\x43\x0a\xa6\x72\xee\xc2\xba\xa5\xc0\xca\x82\x2c\x45\xbe\x66\x79\x98\x1b\x2e\xe2\x79\x82\xc8\xc4\xf8\xd2\x5d\x64\xcc\xcc\x1d\x63\x82\xbc\x7a\xf5\xea\x15\xc8\x25\xaf\x7e\xfd\xeb\x5f\x13\xc8\x23\x91\xb2\x84\xe7\xcb\x0d\xa1\xd5\x7f\xbd\x7e\x3d\x20\x7f\x3a\x7b\xf7\x16\xbc\xca\x0a\xa3\xc9\x58\x9a\x99\x1b\xd9\x36\xa8\x75\xd6\x3d\xf2\x3f\xa3\xf7\x57\x5e\x9c\xd0\x8d\x5f\x41\x05\x09\xcb\xab\xbb\x08\xbe\xfa\xd5\xd7\x5f\x0f\xc8\x05\x57\x10\x4f\xcc\x21\x02\x22\x38\x41\x16\xde\x31\x50\x48\xb3\x1c\xc1\xef\x38\x88\x73\x12\xce\xf9\x74\x66\xb0\x06\x14\x20\x4e\xc6\x13\x83\x39\x05\xf1\xe8\x23\xa0\xb5\x0b\x90\x71\xe1\x5e\x4e\x8a\x80\xc9\xf5\x48\xc6\x6f\x19\x99\xe8\x3f\x28\x59\x16\x55\x98\xa3\x62\xda\xca\xb2\xae\xc2\x14\x0e\x56\xed\x95\x66\xe6\x49\x9d\x30\x5a\x1a\x82\x6a\x38\x08\x7d\x1a\x02\x4a\x2f\xe4\x56\xeb\x23\x3e\x14\x94\x07\xc7\x41\xb8\x53\xaf\x65\xf6\x0f\xba\x67\x1a\xe5\x92\xf3\xb1\x2b\x85\x92\xdf\xe3\x56\x71\xe1\xa3\xa0\x9c\x84\xac\x9d\x4c\xe6\x82\x4e\x45\x64\x73\xf5\x51\xf9\x96\x17\xba\x88\xff\x28\x7e\x6a\x38\x89\x03\xed\x20\x2c\x9d\x6b\xfb\x89\x5a\xe2\xcb\x15\x5f\x8e\x4b\x2f\x9a\x99\xc6\x7d\x2d\xc5\x52\x6f\x57\x47\xc5\x91\x1f\x57\x5d\xc7\x85\xb0\x55\x63\xa0\x2b\xae\x0b\x00\x8a\x6a\x36\xd5\x92\xd1\xd5\xbc\x7c\x34\x33\xa5\x03\x0d\x78\x5e\xd9\x6f\x33\xad\x5d\x1c\x51\x4e\xd5\xad\x55\x12\x1c\x15\x18\x80\xd7\xb3\x0e\x31\x4c\x18\x50\x36\x67\xa1\x00\x5f\x1c\x35\x60\x3f\x72\x38\x18\x1c\xe2\x31\x91\x0a\x73\x79\x22\xce\xdb\xf7\x4f\x14\x2f\x5d\xf7\x4a\xa7\x45\x54\x5e\xcf\x95\x2d\xa1\x35\x6f\x67\xea\x20\xd5\x26\x83\x6f\x27\x91\xa6\x5b\x2e\xe4\xb6\xd9\x90\xb1\x65\xd1\xa6\x24\x43\x57\xa9\xaa\x43\xf2\xe4\xf5\xd9\x1a\x1c\x8c\xdd\x49\x68\x97\x16\xb9\x73\x9a\x5f\x82\xee\x1e\xbb\x4c\xf5\x30\x77\x9c\xef\x7d\x37\xce\xe7\xe2\xf5\x6a\xc5\xc1\x9e\x3f\xab\x1b\x4e\x30\xd2\xa5\x4e\xba\x1c\x69\x88\x45\x81\x50\x88\xab\x0a\x7b\x79\xd6\x1c\x2d\x46\x9b\x6e\x89\xe7\xbb\x70\x37\x7c\xda\x5d\x4c\xe0\x53\xc3\x35\x7f\x3b\x81\x8b\x76\xa4\xb4\xa8\x15\xf8\xc8\xd0\x6e\x00\x32\xa6\x3f\x3c\x03\xf2\xce\x91\x5a\x44\x32\x3a\xd6\x32\x2b\x0d\x76\xad\x7e\x8c\xe9\x30\x0c\xea\xb3\x2c\x00\xf1\x0d\xcd\x22\xaa\x6c\xaa\x12\x67\xed\x08\x34\x3e\x1d\x0e\xe7\x4b\xb6\xcf\x07\xcc\xf6\x19\xf2\xd3\xea\x96\xf5\x9a\xf4\x83\xa5\xd7\x4d\x34\xef\xa2\x5f\x69\x4e\x8e\xaa\x32\x21\xfe\x3a\x7e\x28\x0c\x53\x13\x9a\xb0\xe3\x58\xef\x0a\xe5\x58\x82\x8b\x90\x8f\x8b\x98\x51\x91\x66\x28\x80\x27\x4c\x01\xee\xb3\xcf\xae\x50\xf0\xf9\x68\x48\x52\xc5\xa1\x00\xee\xd1\x37\xcc\xca\x8b\x8c\x9a\x52\xb1\x56\xd1\x55\xfb\xf5\xad\x84\x69\xec\x4b\xd3\x83\xc1\xba\xba\xea\x41\x27\x4f\x79\x44\x74\xbe\x2a\x30\x21\x54\x11\xa4\x3a\xd6\x65\x07\x16\x95\x80\x40\x03\xcd\x58\xc8\x52\x39\x2b\xba\xcf\xab\x9a\x48\x65\xd5\x25\x1c\x98\x6a\xa2\xd8\xd4\x4a\xb3\x0a\xc4\x5e\x6c\x91\x95\xf6\xc5\x5e\xdd\xd9\xee\xe3\x00\x58\x99\x66\x37\xf9\xea\x4d\x9c\x54\x2d\xe7\x3c\xf5\xac\x12\x2e\xaa\xaa\xaa\x86\x05\xd5\x51\xa8\x4d\x94\x81\x3e\x02\x2c\xca\xe8\xc0\x50\x43\x10\x6b\xcd\xd9\x3f\x36\x0a\x4b\xc8\x6d\xd1\xa2\x7c\x44\x17\x22\x2c\x53\x76\x5d\x8e\x33\xae\x67\xa3\x1d\x4d\x88\xab\x86\x40\x67\x85\xa5\x5b\xbf\xb5\x96\x44\xcd\x84\xe6\xc0\xf2\x2c\x19\xb7\x4c\x17\xca\x25\x4b\x00\xa2\xef\x1d\x23\xa4\x84\xe8\x8f\x8c\xb9\x0c\x06\xf6\xa7\xab\x6a\x1e\x2e\x28\x0d\x73\x96\xa4\xec\xa3\x28\x6a\xef\x13\x9a\x65\xba\x19\xb0\xeb\x29\x26\xca\x1e\x3e\x50\x0d\xf7\x94\xdb\xed\x0e\x95\x51\x1a\xd9\x2f\xd7\x2e\x4c\x93\x5c\x62\x18\x8f\x20\x52\xf8\x46\x90\x7a\xc5\x77\x88\x02\x19\x21\x5c\x19\x50\x66\xcf\xa5\x23\x5f\xcc\xa5\x0f\x67\x2e\xbd\xaf\x1f\x9e\x0e\x55\xa4\x68\x14\x0d\x5d\x2f\x73\xed\x49\xa9\x27\xb9\x5b\x9c\x3a\xf6\x7a\xad\x80\xdf\x3c\x33\x58\x9a\xbd\x7b\xbe\xb7\x46\x77\x60\xd3\x56\x11\x81\x53\xdc\x77\xab\x4f\x22\x14\x75\x1a\x42\x38\x0b\xcb\x67\xbf\xe2\x39\xc0\x6e\xf0\xe5\xa1\x26\xa9\x4c\xca\x90\x17\x16\x80\x56\x5d\xa0\xb5\xc9\x9e\x48\xba\x9e\xab\xee\x29\xbd\xe2\x8f\x6c\x45\xaf\x54\xde\x89\x3b\xaa\xd2\xb3\xeb\x2d\xde\xf7\x75\x76\x5e\xf5\x8a\x05\x25\xff\x1a\xaa\x00\xd2\xb1\x2c\x4d\x95\x3a\xf4\xc7\x63\xaf\x5e\xa5\xa6\x1b\x69\x49\x43\x4b\x7b\x74\x57\x45\xff\xc5\xc4\xfd\x62\xe2\xae\x3d\xbb\x98\xb8\x87\x68\xe2\x8e\xf3\xe0\xd6\x8e\xab\x4f\xaf\xc0\xb3\xb6\xbe\xbd\x0f\x69\x25\xbd\xa8\x08\x0c\x4a\x53\x4d\x3f\xfe\x86\x00\x87\x47\xa4\xda\xdb\x48\xe8\xf3\x14\x08\x78\xf6\xd3\x5b\x54\x1f\xc8\x4e\xda\xbe\x4e\x31\x3e\xeb\x0a\x09\x6e\xaa\x5b\x0c\x52\x43\x54\x68\xb8\xe7\xb2\x40\xf7\x9c\xde\x25\xd2\xaa\x84\x1f\x26\xa1\xee\x50\xa6\x14\x9f\x8e\xc0\x27\x9d\x37\x80\x74\x2c\x22\x8c\x4f\xd7\xdd\x20\x3b\x14\x14\xc6\xe7\x89\xcb\x0a\xe3\xd3\xd9\xf6\x4d\xba\x97\x18\x5e\xb1\xdc\x87\x2d\x34\xbc\xe3\xd2\x76\x37\xeb\xef\x6a\xce\xef\x55\xe5\xed\x9e\x3f\x5b\x7f\x31\xe7\x2f\x3d\x8f\x68\xce\x8f\x08\xb7\x27\x06\x2b\x4c\xfb\xb1\xb9\xcd\xdb\xf7\xc7\xcc\x8b\x95\x83\x2a\xfb\x9a\x45\x39\x6f\xd9\x97\xaa\x7e\xad\x7a\x38\x18\x1c\x1e\x7a\x7b\xbf\xc3\xcf\xd2\x4c\xfa\xbf\x21\x4c\x24\x32\xc5\x4d\xb5\xe3\x2b\x6d\x80\xe9\x57\x6a\x7a\x3c\x97\xdc\x7f\x2b\xbe\x9a\x85\xb1\xbb\x6d\x49\x87\x13\xdc\xbd\x6c\xf8\x2a\x48\x3f\x46\xf1\xf0\xb8\x44\x78\xbd\x22\x38\xb6\xb8\x4f\x19\xf0\x18\x78\x0f\xce\x5f\x5b\x17\x06\xc7\x67\x17\xf6\xba\x43\x91\x70\x7c\x1e\xb9\x54\x38\x3e\x3b\x71\xd4\x4e\x65\xc3\x57\x2c\xee\xf1\x8a\x87\xe3\xf3\x4c\x0b\xc9\xd4\x9f\x4e\x85\xc4\xf1\xd9\xad\x9c\x78\xbd\x6f\xc7\xad\xdf\x4b\x69\x71\x7c\xba\x15\x18\xc7\x67\xdf\x65\xc6\xf1\x69\x09\x09\x30\x86\x5f\xf0\x4e\xa1\x08\xbe\x4f\xdd\x5d\xd2\xb0\xbc\x90\x8a\xaa\x05\x49\x9d\xad\x61\xb1\x22\x22\x34\x0a\x09\xbd\x77\x6a\x18\x98\x47\xca\xd5\x9e\xa2\x11\x3a\x44\x83\xb2\x94\x97\x6b\xcb\x35\xaf\x03\x1b\xf6\x8a\x81\x76\x07\xd9\xc0\x5c\x26\x31\x7f\xdd\xe9\x9a\xf9\xc4\x8a\x34\xb9\x75\x15\x83\x3c\x54\x91\xf7\x47\x41\x2e\x07\x07\x8d\x3c\xd0\x60\x1e\x83\xbb\x3f\x57\x19\xd1\x37\xc6\xb1\x6b\xa6\x2c\xbc\x0d\x71\x6e\x01\x47\xae\xe1\xb1\x95\x48\xde\x01\x1b\x7c\xa4\x5d\x22\x1d\x23\xdb\xf8\x3f\x18\x94\x1b\xeb\xec\x1b\xef\x3b\x86\x74\xd0\x12\x24\xf3\x50\x17\x2d\x93\x49\x74\xf7\x5c\xe3\x50\xb0\x0d\x97\x1e\xf9\xbd\xed\xde\x6e\x86\x1d\x15\xe5\x0b\x30\xfa\x64\x1a\xef\xf5\x78\x02\xa9\x2d\x41\x8a\x07\x60\x86\x0d\xb8\x89\xaa\x04\x96\xda\x7e\x09\x32\xcf\x47\x6d\xaa\x0f\xdd\xf9\x0c\x9b\x26\x2a\xe4\x56\xd7\x3d\xec\x2f\xa3\xb0\xb2\x4a\x6f\x83\x10\x08\x2f\xa8\xeb\x12\xc4\x44\xf7\x15\x27\x2e\xc9\x09\xdc\x5d\x55\x65\xd1\x42\x72\xc7\x25\x34\x13\x3c\xab\xe3\x99\xcf\x65\x17\x16\x5e\x0a\xe7\x68\xb0\x84\x34\xab\x71\xa6\xd4\x4c\xf5\xa7\x25\x4f\x77\xc1\x96\x67\xcc\x00\x5b\xb3\xbd\xee\xcc\xae\x23\x8b\xbb\x07\x63\x0b\x8e\x18\x1d\x58\xc3\x41\xe5\xbd\x51\xe3\x0d\x71\x5a\xbc\xba\x27\x07\xf5\xce\x02\xe1\xc8\xf9\x2b\xa1\x9b\xa0\xda\x3a\x9e\x91\x2c\x12\x17\xac\xcb\x6b\xe9\x2e\x71\x58\xc4\x3c\x70\x6c\xed\xdb\xff\x78\x15\xd8\xdb\xf3\xc7\x6c\x22\xab\x0a\x29\xa8\x11\x39\x77\xdc\x94\x65\x0c\xca\xc8\xfb\x12\xf5\xb6\x01\x5c\x09\xe7\x72\x6e\x91\xf9\x2f\x82\x7c\xf4\x39\xfb\xf9\xe4\x94\xd0\xe3\x5a\x08\x84\xab\x3a\x23\x18\x4b\xd1\x47\x37\xab\xbe\xa3\x4a\xa1\x7b\x64\x7c\xec\xfd\x51\xe0\xc4\x09\x2b\x16\x66\x5e\xe2\x45\xbd\x5a\x31\x0b\x00\x08\x3b\x56\x32\x27\x5a\xd0\x42\xcf\xa4\x01\xd5\x90\x16\x34\xe1\x66\x41\x8c\xa2\xc9\x2d\x94\x28\x52\xcc\x7d\xae\x47\x92\x63\xe7\xd8\x15\x83\xaf\xee\x36\x6c\x66\x4a\x96\xd3\x19\x78\xc2\x62\xab\x24\xa3\xda\xaf\x7e\x65\x7f\xa7\xed\x68\x92\x2e\x04\xcd\x79\x12\xb2\x06\x2a\x39\xe7\x9a\x4b\x67\xed\xf5\xe3\x5e\x87\xcc\x70\x68\x41\x3e\xcf\x28\xcf\xc9\x91\x66\x8c\x5c\x7a\x94\xc0\x5f\x5c\x19\x7b\xb4\x6c\xa8\xba\x73\x80\x0c\x29\xcd\x85\x4b\x88\x50\x11\xb8\x70\x79\x85\x0c\xd3\xce\x7c\xe5\x47\x8f\xc3\x76\xad\x9e\x93\x54\x70\x71\xef\x53\x77\x32\x91\xca\xe8\xd6\xf2\xec\x7a\xa8\x63\x6d\x04\x71\xcb\xe5\xbd\x83\x1f\x32\x29\xa6\x71\x1a\x81\x0a\x33\x2d\x29\x15\x50\xde\x65\xce\xd3\x92\x66\x48\x44\xdd\x64\xce\x47\x43\xec\xce\xa7\x33\xd3\xbf\x63\x60\x8d\x41\x5e\x53\x9d\x19\xff\x51\xbe\xe4\xad\xc3\x35\x10\x5d\xe3\xac\x09\x68\xd9\xb2\x53\xbb\xa3\x0b\x48\x5b\xe3\x5c\x4c\x6a\x17\xa6\x3e\xb1\x18\x0e\xb1\x0a\xe2\x30\xbd\xb3\x50\xae\xc3\x8a\x0d\x60\xae\xb2\x20\x06\x4c\x5d\x9e\x9b\x05\x7c\x94\x07\x30\xbc\x76\x95\xd9\xa8\xdd\x20\x2b\xdc\x6d\xd6\x65\x1e\x40\x28\x9b\x57\x9b\x7c\xe3\x4a\x27\x76\x14\x0e\x0e\xbe\x8b\xcc\x66\xd1\x45\x87\x3d\x36\x54\xa4\x7d\x9a\x59\xcc\xb9\xfe\x74\xee\x3c\x9c\xf1\x20\xd4\x2e\xf2\x7d\x15\x24\x2e\x42\xda\x6c\x2b\x33\xac\x3c\x02\x10\x07\x3f\x66\x29\x10\x8d\xb8\x60\xe4\x9d\xd5\x90\xdd\xe6\x5d\x7f\x3a\xef\x11\x3e\x60\x03\xff\x57\x68\xea\xa9\x96\x91\x53\x74\x03\x0c\x3e\x9e\x80\x77\x30\x95\xd8\x18\x15\xf7\xfd\xfb\x6f\xed\x24\xed\xaf\xbf\xeb\xff\x36\xca\x36\xfa\xbb\xbf\x5b\x22\xa8\x6c\x83\xfa\xdb\xd8\x97\x2c\x64\xdd\xff\xfb\xb5\xcb\x4a\xed\x72\x56\xff\xdd\x15\xe3\x62\xc2\x58\xb9\xf1\x5a\xc2\x2d\x3d\x4f\x11\x1b\xe1\xdb\x8a\x7d\xef\x0d\x8b\x00\xa6\x60\xd4\x49\xa8\x61\x02\x08\xb5\x0f\xca\x10\xd2\x60\x77\x57\x77\xd6\xce\xff\x08\x4c\x02\x18\x54\xd6\x23\x46\x4a\x38\x8e\x78\xe4\xcf\x04\x61\xbe\x56\x27\xae\x15\xc0\x41\x9d\xa3\x9a\xe7\x3d\x76\x58\x0b\xe1\x10\x82\x6b\xe7\x01\x73\xfb\x85\x90\xe6\x17\x61\xfb\x1b\x55\xc4\xe9\x5c\x72\x9f\x80\xdc\x9e\x14\x81\x15\x1d\x43\x4a\xec\xf1\x82\xe4\x5c\x1b\x7a\xcb\x06\x64\x64\x79\x4b\x7c\x1b\x86\xd0\x13\x04\x32\x58\xb2\x94\x94\xc2\xf0\x0c\x7e\xad\xc6\xb1\x53\x8e\x79\xce\x70\x42\x74\x09\xe5\xcd\x0b\xc5\xfa\x9e\x8b\xb9\x56\x4b\xb4\xa0\x5a\x4b\x2f\x6c\xf6\x8c\xa2\x2e\x50\xa4\xd0\x15\xe0\x41\x85\x43\xaf\x25\x3f\x2e\x3b\x4f\x29\x92\x8a\x73\x01\x30\xf5\x80\x5c\x01\xb3\xca\xfc\x95\x30\xaa\x25\xce\x80\x29\x58\xc2\xb4\xa6\x6a\xd1\x83\xc4\xee\x3c\x24\x03\x77\xae\x3b\xc0\x51\x73\x2a\x30\xad\xba\x62\x89\x14\xda\xa8\x32\x31\x58\x67\x6f\xac\xe4\x2d\x13\xc1\x5d\xd0\xee\x62\xdd\x81\xab\xf2\x9f\x81\xfb\x2e\x49\x92\x19\x15\xd3\xa8\x4e\x4d\x4e\x53\x80\xfd\xb7\x41\xca\xf1\xeb\xb1\x10\xa0\x13\x2b\x58\x70\x03\xa0\x18\x5b\x3e\x12\xcc\xb0\x7f\x11\x21\x1f\x4f\xaf\xb2\x93\xda\x25\xf1\x6c\x0b\xed\xea\x44\xbf\x48\x47\xa3\x5e\x1f\xd8\xf6\x9e\x1d\xc0\x72\x66\x68\x4a\x0d\xdd\xc1\x09\xec\x5d\x55\x5c\xcf\xd7\xd7\xc7\x02\xa7\xe1\x62\xd2\xf1\x21\x2f\x6e\xc9\x82\xc7\xf1\x4f\x70\x12\x67\x1e\xf2\x10\x71\x6d\x2c\x4e\xb9\x8b\x02\xf4\xed\x02\x79\xc6\x57\x2f\xb3\xc3\xfb\xd1\x90\x5c\x54\xa5\x19\x2b\x72\xd2\xee\x1a\xaa\xa3\x05\xd6\x82\x7e\x07\x18\xdd\x54\x77\x65\x49\xdd\xbf\x6b\xa5\x08\x82\x5c\x82\x09\xc3\x15\x8b\xc3\xcd\x1c\xe8\x4a\x81\x48\xde\x00\x22\x40\x79\xca\x8c\xae\x3c\x54\x90\x0e\x5b\xe2\xe2\xf8\x9d\x53\x46\x81\x48\x3b\xc0\x3a\x7d\x6e\xb5\x2c\x84\x60\xd7\xd2\xd1\x59\x4b\xf9\x1f\x04\xae\xbb\x18\x9d\xb1\x9c\xc0\x3b\x99\x76\xb1\x53\x37\xb2\xf0\x57\x43\x54\xfe\x9b\xe8\x89\xab\x41\xa9\xc7\x06\x70\x5b\xa5\x6b\x41\x73\x48\xe4\x66\x74\xbe\xbb\x91\xaa\x92\x91\xfa\x21\x95\x31\x7c\xae\x0f\x9f\xeb\xbf\x6e\x6f\xcc\xeb\xe2\x01\xe2\x9f\xd6\x9e\x20\xf5\x8f\x74\xb2\x9c\x5a\x92\x32\xea\x68\xee\x6c\x44\x23\x87\x11\x1c\xcd\x77\xb7\x88\xe1\xe6\xd6\x45\x3a\x30\x6e\xa9\xc5\x29\xf9\x45\x8d\xcb\x3b\x69\x2a\x68\x4a\xe8\xa9\x7b\xe4\x55\xa7\x81\xdb\x0a\x1f\x7c\x5e\x6f\x7e\xdc\x18\x0c\xc4\x8b\xd5\x1a\x85\xf7\x08\x0e\x22\x9f\x15\xcf\x14\x18\xcf\x7c\xfc\x81\x45\x2f\x25\xb3\x8c\x29\x58\x82\xd3\x9e\x1a\xb7\xe8\x90\xcb\x14\x6d\xba\xbd\xa0\xa2\x06\x19\x53\xb0\xbb\x20\x4c\x50\x8d\xa9\x5b\xfc\x8d\x17\x73\x85\xf3\xd6\x8e\x17\xbc\x96\xcf\xc4\x02\xa7\x7e\x11\x81\x16\x55\x4f\x32\xb5\x1f\xb2\x52\xa7\xa0\xe3\x0c\x6f\x8f\x03\xb3\x85\xb9\xd0\xec\x8e\x2e\x34\xe0\x7d\x25\xcd\x87\xef\xbb\xac\x6a\xd5\xc0\x1f\xd8\x04\x7b\xb7\xbe\x11\xdb\xe9\x4e\x6c\x97\x5b\x31\x08\xa7\xe4\xa2\x8d\x0b\x52\xd5\x61\x63\xe1\x90\xe6\xb3\xcb\x35\x1a\xf8\xa9\xc0\xf5\x79\xb7\x3b\x91\x7a\x9d\xf2\xeb\x21\x0c\xe1\x65\xf2\x29\xfc\xe1\x39\x4e\xb8\x34\x18\x33\x8b\xd5\x55\xa0\x34\x60\x48\xdc\x77\x85\x27\x41\x85\x5a\xdf\x42\x36\x56\x67\x25\x0e\x95\xc6\x14\x03\x4f\x10\xf8\xe2\x00\xca\x11\x50\xb1\x70\x9c\xdc\xcc\xb8\x4a\xfb\x05\x55\x66\x81\xea\x63\xaf\xf6\xb5\xe0\x5e\xdf\x69\xe1\x3b\x5e\xe7\xb4\x4b\x7d\xbc\x16\xc2\xb0\x78\x6f\x1e\x76\xd6\xf9\xb5\x70\x7d\x8c\xf5\xb4\x77\xe0\x5f\xb9\x9e\x38\xb5\xa8\xd7\x08\x9f\x6c\x3d\x69\x4c\x3e\xee\xcf\x37\x2c\x0d\xd2\xf5\xab\x57\x64\x03\x71\xe9\x2a\x19\x7b\x41\x07\x2e\x0f\x0a\x91\x1d\xa9\x67\xf5\x50\x5a\xd5\x1a\x8f\x0c\x7b\x4e\x52\xf0\x3e\x34\xae\xd2\x91\x58\x38\xd3\x4d\xfc\xad\x78\x80\x70\x4a\xc8\x91\x90\x02\x4f\x0e\xb6\x3d\x46\x17\xa2\x35\xb6\x29\x68\xe2\x4a\xd4\xd5\x2b\x84\x46\x27\xd5\x33\x09\x2e\x52\xbb\x75\x40\xb9\x41\x47\xd2\x65\x92\x30\x16\xb4\xea\xb8\x44\x4d\x75\xb2\xdd\x94\x7d\xa9\x4b\x2d\x21\x89\x8b\x36\x34\xcb\x2a\x6d\xd6\x81\x4b\x02\x9f\xf3\x16\xc0\x88\xfd\xd5\x02\x6d\x9c\x62\x0f\x45\xd4\xd1\xed\xa5\x14\x09\x5e\xe1\x73\xb3\xf0\x33\xb8\x68\xb2\x7a\x50\x23\x34\x2a\xb9\x7c\x82\x76\xa7\x48\x1d\x08\xc0\x04\xd2\xe4\x4a\xb8\xd7\x39\x93\xcb\xcd\x60\xe9\xd0\x98\x26\xb7\x77\x54\xa5\x50\xca\xb7\xa0\x86\x63\x5a\xf0\x5e\x6d\xd8\xa3\x68\x0e\x50\x48\x3f\xc6\xa2\xe3\xa0\x74\x68\x16\x52\x50\x57\x9f\x21\xb4\x34\x32\xa7\x86\x27\xa0\xca\xf2\x49\x64\x45\xcc\x43\x4a\xc3\x46\xd9\x41\xa0\xb2\xa1\x80\xfd\x0d\xde\xc6\x28\x46\xcc\x9d\x24\x3c\xb7\x12\x02\x85\x52\x1a\x93\x10\x31\xe4\xed\x9d\x9b\x66\x6a\xc5\xa0\xef\xc0\xc8\x1c\xb5\x42\x25\xd9\xaa\x50\x1a\x86\x0f\x16\xcd\x60\xca\x73\x21\x37\xbd\x06\x03\x77\x7d\x2c\x4e\xdb\xb9\x46\xa8\xda\xb3\xdb\x73\xc7\xac\x5c\xa0\x37\x22\xac\x1e\xac\x9a\x11\xd6\xb4\xd5\x24\xe5\xba\x51\x98\xfa\x28\x55\xb2\x28\x9c\x81\x24\x3f\x6e\xce\x08\xee\x0d\xd4\x9c\xe9\xa8\xf6\x32\x9a\xaa\xa7\x4c\x84\xe2\xe1\x2e\x9d\x05\x9c\xdc\xe6\x27\x6a\x07\x66\x80\x01\xa1\xc7\xe4\xa3\x2b\x2a\x14\x10\x37\x78\xdd\xb5\x12\x9c\xd0\xda\xe2\x64\xa7\x17\x89\xa7\xed\xf3\x22\xf1\xbc\x48\x3c\x3f\x6d\x89\x27\xb8\x7b\xed\x2a\xed\x54\x3e\x8e\x8d\x82\xe4\xde\x19\xa0\x6a\xb0\xce\x88\x31\x9c\x90\x0f\x2c\x91\x73\xa6\x90\xc8\x41\xe1\x4f\xcb\xcb\xdf\x50\x9e\x59\x12\xe7\x49\x5d\xa5\x1e\x42\x46\xd5\xba\x69\x2e\xd2\xc8\x03\x34\x1d\x9a\xe7\x6e\x52\x2e\xd2\xcf\xb6\x77\x97\x64\x85\x62\x73\x2e\x4b\xed\x5d\x16\x4a\x83\xc7\x4c\x1b\xc7\x6f\x67\x7c\x1a\x12\x73\x87\xab\x4e\xc5\x12\xa9\xd2\x2a\xa4\x5c\x1b\x6a\x4a\x5d\x8f\x93\x48\xd0\x9a\xb6\x3f\x03\x4d\x80\xe3\x03\x53\xf7\xdd\x28\x29\x7a\x6c\xdc\xe3\x54\x1c\xbe\x45\x9f\x8f\xaa\xee\xb6\x89\xdc\x50\x2a\x17\x18\x2b\x42\x95\x86\x45\x68\xe5\x10\xa0\x33\xac\x6b\x51\xaf\x27\x58\xb8\xa5\x1f\x86\xed\x57\x5e\x27\x2d\x32\xae\xc7\xcf\x4e\x50\x27\xf7\x08\xf0\x8c\x9f\x67\xec\x78\xd2\x58\x6c\x77\xef\x4b\x72\x4f\x0f\x4c\x72\x1f\x2f\x4c\xb2\x4f\x4f\x4c\x12\xfc\xb9\xef\x73\x62\x3e\x78\x4f\xf2\xc6\x99\x71\x84\x77\xd3\x99\xa9\x25\x14\x08\xe3\x70\xed\x2b\x40\xba\x6b\xcd\x70\x06\xc0\x24\x18\xfb\x03\xbb\xd3\x0a\xda\x1c\xde\x5d\xb2\xcf\x21\xeb\x6f\x24\xc7\x54\x45\xb5\x8d\x04\x0f\x84\xbc\xc0\x4c\x40\x70\xea\xfa\xce\x25\xcb\x6b\x4b\x2f\x27\xf8\xe5\x04\xb7\xed\xff\x94\x27\x18\x3d\x9e\xbb\x38\xe4\x37\x2a\x05\x61\x77\x17\x84\x4b\xc7\x2c\x23\x3f\x94\x4c\x2d\x88\x15\x82\x2a\xf7\x1e\x48\x6f\xac\x79\xea\x1c\x64\x9c\x51\xa5\xbd\xcc\xfe\x88\xfc\x1f\x4c\x36\x97\x9f\xad\x04\x08\x71\x6c\xf7\xa0\x6b\xcd\xa1\xea\xa1\xca\x08\xad\x00\xc1\x58\xc2\xc3\x1b\xc6\x9a\xcc\x67\xc5\xbd\xb3\xab\x8b\xdd\x14\x9d\x6e\x97\x5a\x64\x97\x8b\xad\xa5\xc5\x9f\x6d\x58\x20\x02\x22\xfc\x52\xaf\x26\x15\x4c\x11\xe4\x96\x2d\x7a\xee\x1e\xdc\x65\x6f\xf7\x8d\xd1\x9d\xa3\x9e\x52\xb4\x6d\xaa\x8a\x55\x00\xda\x81\x42\xee\x66\x3d\xc0\xa7\x7d\x12\xca\x7a\x2f\x0f\x84\xae\x84\x78\x67\x12\xde\x29\x59\x65\xfc\xac\x4b\x5c\x89\x38\x01\x19\xf8\xbc\x5f\x73\x40\x03\xf0\xe5\x06\x6a\xd1\x75\x13\xc9\xee\x2a\x30\x3e\x1e\xb0\xf7\x5e\x6a\x40\xd3\x9a\x63\xee\x2d\x5b\x1c\x6a\x17\x35\x28\x85\x9e\xf1\xc2\xe7\x87\x07\x4a\xe0\x30\x97\x7c\x02\xff\x00\x3f\x04\x9e\xf9\xa1\xe8\x91\x2b\x69\xec\xff\x2e\xc1\x55\x08\x2d\x95\x92\xe9\x2b\x69\xe0\xcd\xa3\x03\x0b\xa7\x7b\x6f\x50\x39\x33\x25\x07\x33\x23\xba\xb4\x41\x7c\x86\x77\x41\x01\x90\xb8\xfb\xd6\x00\x56\xae\xc9\x50\x10\xa9\x3c\x4c\x8c\x4f\x1e\xac\xdd\x10\xde\xb6\x14\x59\x84\x57\x8c\xe1\x40\x29\x55\x0d\x92\x1b\x86\x0b\xc6\x65\xee\x7f\x01\xdb\x13\x58\xe3\x83\xdf\x0c\xa4\xc0\xa5\x86\x4d\x79\x42\x72\xa6\xa6\x10\x1f\x9a\xcc\x76\xdf\xa0\xee\x74\x1b\x9f\x9d\xa8\x77\xfc\xe1\xce\x98\x01\xac\xee\x2d\x78\x2e\xdd\x97\x61\xe2\x28\xc8\x22\x72\x5a\x58\xa4\xf8\xa7\xe5\x04\xb0\x2f\xff\x86\x94\xd5\x7a\x40\xce\x7c\xc1\xd3\xf8\x37\x67\xc5\x88\x87\xb1\x23\x58\x99\xfe\x87\x92\xcf\x69\xc6\xd0\x9f\x8f\x8a\x90\xc6\x53\x4e\x96\xd8\x74\xcf\xe5\xad\xb6\x54\x2a\xdc\x0c\x1d\xdc\xb2\xc5\x41\x6f\x09\x91\x0e\x86\xe2\xa0\x0a\xd2\xae\xa1\x4e\x60\x68\x70\x69\x70\x00\xbf\x1d\xec\x9b\xb3\x3f\x91\x68\xbf\x03\x96\x38\x83\xd0\x79\x46\xb5\xee\x16\xdf\xda\x08\x2d\x6a\x8c\xb3\x2a\x01\xe3\x28\x6a\x53\x05\x17\x39\xef\xcd\xbd\xdb\xb3\xc0\xcb\xbf\xbb\xa7\x51\x27\xe8\xcd\x5d\xf5\x94\xf6\x89\x1b\x56\x26\x14\x83\xb4\x05\x3e\x86\xa3\x16\x17\x57\x5d\xc6\xae\x81\xd7\x27\xb0\x2b\xca\x49\x5c\xe4\x99\x6b\x50\x83\xb9\x8f\xea\x10\xd2\x10\x2e\x92\xac\x74\x26\x45\xe8\x0a\x4a\x74\x57\x51\x7f\x07\xe0\xdc\x03\xa9\xaa\x01\x3c\x36\xf9\x6b\xdf\x25\x07\xde\xe6\x0d\x1d\xdc\x89\x86\x1b\x2f\x84\xd5\xbe\xd7\x3a\xd9\xe2\x2e\x59\x4f\xc6\x99\xd4\x65\x8f\x37\x7c\xac\x18\x39\x9f\x51\x21\x58\x16\x45\xbb\x3a\x63\x47\x28\x67\x05\x02\x89\x2b\x62\x75\x58\xaf\x62\xe5\xe9\x9b\x08\xb1\xd5\x7b\xaf\x1d\xfc\x63\x2a\x2a\xb5\xb7\x3a\xe5\x2e\x55\xe3\x4c\xde\x91\x54\x92\x3b\xa8\x5b\x30\xb7\x4c\x0b\x2e\x65\xb5\x67\x77\xd1\x4c\xc1\x45\x22\x91\x79\xa1\x64\xce\xb5\x77\x8e\x77\xdb\xb8\xd7\xd0\xd0\xac\x6c\x91\x03\xa8\xbe\x07\x59\x29\xea\x29\xe1\xdf\x9c\x13\x43\xd5\x94\x19\x3b\x1a\x11\x65\x3e\x66\xad\xe3\x57\x1f\x22\x07\xd9\x97\x54\x42\x74\xbf\x45\xb0\x70\x1b\xbe\xfb\xee\xaa\x73\xe9\xdd\xaa\xe7\xba\xbd\xbd\x93\x2a\x4b\xef\x78\x8a\x2c\x5a\x93\x23\xdb\xf8\xf8\xf9\x57\xca\xbd\xbb\xe3\x69\x67\x70\x40\xa7\x3a\x18\xbc\x1f\x94\x05\x03\x01\x38\xb8\x0a\x4f\x1c\xd2\x68\x43\x8f\x63\x72\xc9\x31\xba\x08\xfa\x43\xa2\x9a\x7c\xcc\x45\x15\x61\x56\x81\xd9\x12\x63\x7b\x5e\xbc\x6a\xa2\x99\xc1\xb8\x10\x08\xad\x90\x66\x46\x34\xcf\xcb\xcc\x50\xc1\x64\xa9\xb3\x45\x6b\x54\x79\x1a\x50\x4f\x32\xf6\x19\x31\xbb\x0b\x93\x0b\x9d\xea\xcc\x0e\x5c\x57\xaa\x30\xca\x25\x6e\x57\x39\x57\xa5\x27\x81\xf3\x85\x70\x23\xf6\x99\x25\xce\x2b\xb8\xc8\xca\x29\xdf\x12\xfe\xf0\x13\xcb\x6a\x5e\x25\x90\x2e\x35\xab\x22\xf5\xdb\xd6\x75\x79\xa4\x24\xe4\x4f\xcb\xe1\x6f\x56\x27\x20\x4f\x59\xc1\x44\x0a\x29\xd1\xde\x54\x98\x8b\x93\xdf\x2b\xe4\x5c\x7a\xb1\xae\x54\xcb\x67\x25\xab\x51\xf0\xc8\x85\x6b\x26\xb3\x54\x13\xf6\xd9\x28\x6a\x09\x53\x6e\x49\x50\xe8\x33\x21\x54\xb4\x27\x32\xcf\x23\x45\x30\xd9\x3b\xb7\x7f\xd8\x7a\x99\xcf\xb1\xe4\x65\xb5\x76\xbd\xb1\x60\xf5\xfd\x52\xd7\x23\x21\x76\x67\x45\xd7\x3d\x84\x57\xa4\x98\x77\x5f\xa9\x7b\x26\xde\x2f\xd5\xbc\x5e\x91\x54\xbb\x31\xab\x97\x32\x9d\x5f\x44\xde\xf9\x09\x04\x06\x77\x49\xc2\xe4\x7a\x34\x34\x6a\xf7\xb2\x59\x10\x7a\x83\x06\xed\xf0\x36\xe2\x03\x90\xf1\xd4\x0d\xe4\xc2\x9a\x88\xb6\xb0\xac\x5c\xe7\x4a\x21\xb6\x51\xb1\x87\xc8\x22\x4e\x0d\xd5\xcc\xb4\xb3\xa6\xd4\x45\x87\xaa\xa7\x3d\x80\x31\x7e\xb9\x9f\x30\x8b\x3d\x38\xa4\xfb\x60\x59\xd2\xff\x9d\x93\x32\x44\xad\xa5\x95\x2f\x3c\x7c\x7c\x92\x26\x16\x6e\x91\x71\x8c\xd4\xee\x4a\x42\x4d\xeb\x92\x3b\xad\xf8\x82\x9b\xc1\xc7\x8f\x9d\x6b\xb9\x46\x3d\xbd\x1c\x02\xff\xae\x03\xc1\xe1\x02\x24\xf2\xe1\x3f\x94\xb1\x3a\x00\xc9\x2d\xc2\xb2\x5d\xfb\x7d\xad\x6d\x9a\xb0\xca\x78\x75\xc1\xf5\x6d\x97\x64\x64\x4b\x9d\xeb\x47\xe2\x0f\xe7\x97\xc4\xbd\x6d\x65\x5f\xea\x62\x60\xba\x6f\x66\xac\x69\xc2\x2a\xa3\x6d\xca\xf5\xed\xa3\x97\x55\x2f\xd2\xab\x6d\x1e\xe0\x8f\x67\xff\x6a\x4a\xbd\x3e\x45\x4b\x94\x3b\x68\x21\x4b\x72\xe7\x52\x1f\x38\xa9\xf9\x86\x17\xa7\xe4\x52\xe8\x52\xb1\xea\xe6\xb6\x39\x94\xe5\xba\xcf\xa9\xf4\xfa\xbd\xb0\xe4\x39\x1b\xdf\x0a\xaa\x0c\x88\xc7\x5d\xd1\x20\x74\xf4\xf4\x29\x7a\x21\xda\xe0\xc1\x70\xe2\x1d\xeb\x7a\x2e\xc6\x3b\x24\x2e\xf3\x8d\xec\xce\x47\x69\x4d\xe2\xbd\x7e\x13\x52\xfe\x90\x93\x94\xcd\x4f\x74\x4a\x5f\xf7\xe0\x33\xde\xe1\xb9\x3e\x27\xaa\xc9\xc1\xeb\x83\x01\x19\xf1\x9c\x67\x54\x65\x8b\x5a\x2a\xe6\xaa\x9d\x65\x16\x7e\x40\xb8\x95\x7b\x75\x40\x8e\xa4\x82\x91\x13\x2a\x48\xc6\x7c\x44\x93\x3b\x67\x0b\x94\x1d\x8f\x1f\x9b\xb8\x90\x07\xb5\x5f\x22\x9d\xe9\x8c\x13\xa9\xe7\xd8\x8e\x1f\xd5\xd2\xd9\x5c\x54\x24\x9d\x0b\x4b\xe7\x07\xe4\xe3\xaa\x42\xe5\x70\x64\x7c\x8b\xa7\x02\xea\xe3\xe8\x7d\x3b\x69\x70\xcb\xe6\xe0\xa7\x03\xd3\x76\x2d\x71\xca\xcd\x07\x56\xc8\x4e\x12\x02\x76\x69\xd8\xe3\xb8\xb1\x2f\xa4\xe6\x90\xa8\x94\x1a\x28\x0b\xac\x0c\x4f\xca\x8c\x5a\xb1\x1a\xad\x71\x03\x72\x71\x79\xfd\xe1\xf2\xfc\xec\xe6\xf2\xe2\x94\xfc\xc1\x8d\xc4\x63\x09\x6f\x40\x6e\xe2\x6c\x50\x91\x47\xaf\x4b\xb9\x13\xbe\xd5\x73\x64\x88\x8a\x2a\xb9\x23\xe4\xf8\xa0\x82\x0c\x05\x37\x55\x7a\x64\xf4\x3b\xcb\xa4\x60\xbe\x7a\x68\x21\x9d\x35\x70\xca\xd1\x1b\x44\xb8\xc1\xec\xcf\xf5\xd1\xe0\x74\x60\xaa\xd5\x30\x95\x2d\x8a\xe0\x03\x88\x16\x15\x70\xf7\x25\xfe\xfb\xfc\xa7\x5d\x65\xdf\x90\x8d\xd6\x07\x38\xa1\xf5\xbf\x7a\x8f\xcc\x20\x24\x66\xf7\xe9\x6e\x56\x94\xb4\x26\x96\xcd\x1c\x0e\x0e\xbd\x40\x91\x2d\x25\xe1\x0f\x83\xc6\x19\xbd\xea\xc8\x36\x20\xe4\xbd\x77\xd9\x86\xd0\xe3\xd5\xf9\xfc\x31\x3b\x44\x94\x15\xbe\x81\xb2\x3e\x30\xa6\x1c\xc7\x1f\x75\x29\xc0\xa6\x7c\xce\x04\x2e\x6c\xbf\x14\xca\x7f\xbe\x73\x75\xb4\x6a\xde\x4e\xff\xf8\xf0\x76\xbf\x33\xc3\xf3\xd7\x79\x5e\xee\xd8\xba\x59\x25\x32\xcf\x31\x5f\xd4\x2c\x04\x18\x56\x31\x82\x81\x2a\xec\x4d\xf3\xc1\xcc\x57\x93\x2d\xc8\xdf\xa0\x67\xbe\x53\x43\xd3\x09\xaf\x5d\x50\x82\xa8\xc4\xdc\xee\x79\x98\x5d\x92\x35\xed\x93\xa7\x38\xd2\x7e\x12\x3e\x7e\xf2\xe1\xf2\xec\xe2\xdd\xe5\x20\x4f\x1f\x9d\xb4\x30\x91\x16\x92\x0b\xa3\xb7\xeb\x37\xdb\xaa\xce\xb4\x27\x3f\xe1\xa3\x5d\xb9\x73\xe8\xe8\x71\xcc\xbf\x88\xf2\xd2\xa5\xcc\x50\x9e\xe9\x68\x0f\x8d\x2c\x64\x26\xa7\xab\xd3\x2f\x77\xd8\x9c\x9f\x61\x7e\x99\x3e\xed\xdb\x5d\xdf\xaf\xa8\xdf\xa6\x8e\x46\x53\xca\xaf\x2a\x62\x57\x6b\x0d\x52\x33\x94\xbb\x78\xa6\xcb\x7d\x10\xe1\x6c\x09\x06\xa8\x48\xc2\x01\xf6\x29\xfb\xaa\x1c\x78\x51\x0d\x9b\xb6\x52\xdb\x43\x83\x6e\xbb\xc0\x66\xe9\xcf\xf6\x42\x45\x75\x98\xf9\x3e\x75\x02\x57\x28\xd6\x0f\xe9\x9a\xa0\xb4\x8a\x54\x11\xc3\x8d\xe9\x9d\xb7\xde\x78\x5b\x0f\xb6\xca\x16\x4d\x2b\x4e\x25\x1f\x05\xd3\x17\xe6\x18\xc8\xb2\x45\x95\x06\xd2\x69\xd1\x74\x8a\x69\x98\x94\x33\x13\x17\x8a\xcf\x79\xc6\xa6\x90\x8a\x95\x8b\x69\x14\xfe\x1a\x07\xcc\xba\xd4\xac\x75\xa3\xeb\x3b\xfb\x57\x94\x74\x1b\xf0\xe2\xea\xfd\x0d\x64\xf5\x85\x0b\xae\x7b\x0b\xe1\xf6\x83\x70\xde\xfa\xfd\x3e\x98\x0c\x8e\xbe\xb7\xf2\x64\x9a\x1d\x93\xef\x98\xfb\x8e\x84\xb4\xc3\x0a\x4a\x01\xcd\x64\xc8\x01\x0b\x73\xad\x20\x0b\xe8\x88\xd7\xfb\xae\xd5\x89\x6d\x69\x65\x25\x64\x35\xb5\xf6\x50\xf9\x14\x53\x37\xe2\x1d\xd3\xe3\xcb\x9e\x7b\x24\xfb\x3b\x53\x39\x6f\x5a\x5d\x85\x9f\xe1\xe2\xc7\xd3\x43\x4a\xf4\x22\xcf\xb8\xb8\xad\xf2\x82\x4d\xa4\xc5\x21\x0c\x4d\xe0\xe2\xd6\x63\xac\x62\x34\x5b\x4f\x29\x77\xc1\x8f\xbd\x52\x49\xb3\x83\x05\x10\x2c\x74\xf6\x9c\xfd\xd1\x1f\x7b\x77\x0d\x1d\x93\xb8\x83\x83\x67\xb7\x5e\xae\xbb\x95\xc1\x3f\x84\x0e\x35\x9a\x26\xc8\x70\x74\x3e\x1a\x3e\xaa\x85\x7a\x1d\x4b\x80\xd9\x3d\xa1\x54\xc7\x7f\xd8\x76\x3b\xdc\x27\x59\xb9\xbd\x0d\xaa\x77\xd7\x52\x19\x9a\xed\x89\x08\x24\x33\x5a\x9c\x95\x66\x76\xc1\x35\xe4\x50\xe8\x2a\x04\x2c\xf5\x8f\x3c\x9d\x31\x77\xb3\x4f\x18\xc8\x3d\x3a\xb8\x76\xe7\x7f\x3c\xbb\x26\xb4\xb4\xfb\x6b\x5c\x72\xd1\xbd\x5e\xb8\xfb\x99\x8d\x30\xc2\x60\xc7\x75\xb9\xde\x5b\x56\xe5\x5b\x3d\xf4\x9a\x1e\xc2\x0f\xf7\xe5\x2e\x02\x68\x28\x52\xb0\x67\x7c\xff\xc0\x05\x37\x9c\x1a\xd9\xb2\x50\x59\x0d\x05\x6a\x7d\x83\x41\xa0\xd4\x46\xe6\x0e\x83\x87\xbe\x05\x5c\x21\x03\x17\x5f\xea\x54\x59\x0b\x40\x7a\x07\x88\x0d\x85\x95\xb5\x69\xc2\x1a\x0e\x90\x3d\x48\xfa\x89\x63\xf3\xd0\xe6\xb7\xce\x40\x05\xf9\xc1\xb2\xdf\x9d\xd6\x52\xb1\x2f\xd5\xb5\xf0\x56\x8a\xaa\x68\xc2\x5e\x2d\x3e\xfc\x87\xae\x44\x81\xff\x20\x1a\x96\x36\x5c\xe0\xff\x96\x34\x43\xc0\x5c\xed\xdb\x2c\x55\x07\x72\xd7\xf9\xd6\x77\xc8\x4d\xbd\xda\x8e\xab\xa0\xa5\x97\x1a\x33\x8f\xe1\x7a\x8c\xa2\x42\xdb\x3d\xaa\xeb\x62\x87\xee\xe2\xe9\x90\x1c\x99\xa4\x68\x5d\xbb\xff\x81\x5c\xdb\xb3\x52\xd4\x0a\x39\xc3\xcc\x6f\x70\x5b\xde\x06\xd7\xf6\xb6\x93\x7c\x90\xab\x21\xc0\xf2\xae\x56\x15\xd7\x2b\xec\x56\xbc\x2e\x64\xfd\xe4\x2d\xd7\xc6\x17\x64\x80\x17\x5c\xbb\x3c\xc2\x20\x77\x5d\x5b\x45\x8e\x17\x7f\xa3\x69\xaa\x4e\x91\x4b\xf9\xea\xcb\x0a\xa4\x2f\x9f\xe4\x8b\x8a\x70\x97\x78\x64\x16\x85\x4b\x00\x78\x73\x7e\x4d\xb0\x40\xca\x6f\x7e\x85\x95\x5f\xff\xf3\x97\xbf\x7a\xd5\x7a\xbb\x9f\xce\x79\x7c\x47\x3b\xc6\xde\xef\x98\x9e\x85\xdf\x60\xcd\x3f\xd0\xae\x04\x64\x93\x11\xba\xe3\x59\xca\xea\x8e\x3a\x22\x96\xdd\xe5\x40\xef\x77\x93\x60\x5e\xfc\xec\x9e\xd4\xcf\x8e\x84\x88\x12\x24\x12\x1d\xd1\x25\xee\x0a\x21\x86\xcb\x64\x07\x29\xce\xf5\xf3\xa3\x38\x5b\x61\xb3\x1d\x8b\xea\xd8\x13\x5f\xc6\xfb\xf2\x37\x95\x0b\xfb\xc5\xd5\xe8\x6f\x6f\xcf\xbe\xb9\x7c\x0b\x33\x75\xf7\xf7\x16\x35\xb8\xd8\xd9\x7f\xaa\x3d\xaa\xb5\x51\x5e\xb7\x03\xa4\xdb\xb5\x8c\x68\x5c\xc8\x08\x72\xf5\x66\xd4\xf5\x2e\xe6\xbe\x02\xba\x98\xb4\x5a\xfb\xe3\x5a\xdb\xa0\xaa\x09\x53\xfb\x8b\x1f\xd9\xd9\x28\x17\x25\xd2\xaa\xe9\x5f\x76\xa7\x70\x86\xf7\x56\x91\xb6\xee\x00\x79\x06\xf7\x0e\x76\xbd\x08\x83\xbd\xdf\x38\x3c\x10\xac\xda\xca\x01\xaa\x7b\x60\xd1\x21\xf6\xf2\x22\x80\x3d\xa4\x48\xdb\x94\xa5\xd9\x96\x5a\x33\x1d\xaa\x2f\x3c\x53\x4c\x29\x56\xa5\x67\xee\x42\xbd\x56\x0e\x50\x2b\x57\x56\xbb\x8b\xa9\xc5\x52\xac\x4b\x67\xee\x3d\x14\xa8\x53\x5e\x75\x41\x93\xbd\x16\x54\xa9\x5e\xe1\x1b\x08\x72\x7f\x7c\x02\x08\x9f\xdd\xa3\x23\x6d\x18\xaf\x2b\x22\x87\x8e\xcd\x28\xb9\x4e\x3b\xe4\x0b\x7d\x14\xd2\x47\x20\xc6\xe1\x74\x4f\xbc\x7d\xe4\x71\xb5\x9d\xef\x76\x54\x74\xf6\xad\xe4\x14\x33\x69\xa4\xd8\xd9\x4b\x7e\x55\xf7\xfa\x81\xbe\x86\x16\xe7\x55\x19\x9b\xa8\xc6\x23\x78\x50\x86\xcb\x08\x2b\xcf\x79\x76\x21\x85\xbf\x96\xa8\x5f\x4a\x3c\xba\x08\x92\x0e\x2f\xf6\x74\xf8\xbe\xdc\x10\xcf\xae\xc6\xe0\xbd\x3a\x83\xa4\x9d\x63\x52\x6c\x17\x0f\xb1\xe1\x85\x13\xcd\x7c\xc0\x89\x76\x08\x49\xd6\x63\xe4\xde\x58\xa7\x54\xe6\x4e\xaa\xee\xa1\xde\xf5\x8e\x0d\x5f\x05\xf7\xdb\x52\x28\xd6\x73\x3c\x3d\x38\xc7\x27\x3e\x41\x23\x38\x41\x8d\x04\xe7\xeb\x4e\xd2\x43\x1c\xa4\xa7\x3d\x40\xf7\x65\x54\x0f\x1b\xe5\xbb\x57\x21\xdd\xa3\x5b\xc7\xa5\xfa\x6e\xce\x98\x60\x37\xa9\xa2\x16\x14\x4c\x2e\xd1\x89\xdb\x1b\x75\x50\x12\x4b\x50\x76\x21\x0c\xbe\x0f\x1a\x70\x31\xd1\x73\x96\x59\xa8\x4a\x11\xa7\x88\x76\x61\xbc\x3d\x82\x59\x96\x73\x5a\xf8\x9a\xdc\xf2\x4e\xdc\x51\x95\x92\xb3\xeb\xe1\x7e\xa8\x41\x07\x3f\x6b\xc4\xa4\x76\x19\xbd\xea\x9e\xd6\x55\x4f\x2c\x73\x33\x63\x50\x5b\x91\x8c\xb9\xd1\x55\x4d\x3f\x66\x62\xbd\xd2\x52\xc1\x70\x97\x65\xcf\xb2\x3d\xb7\x6e\xa4\x88\x61\x0a\x22\x13\x43\x33\x5f\x44\xc0\x95\xc9\x79\xf5\xea\x15\x9a\xc2\x5e\xfd\xfa\xd7\xbf\xc6\xca\x4a\x29\x4b\x78\xbe\xdc\x10\x5a\xfd\xd7\xeb\xd7\x03\xf2\xa7\xb3\x77\x6f\xa1\xf2\x63\x61\x34\x66\x25\xc1\x91\xb1\x12\x7c\xd4\x59\xf7\xc8\xff\x8c\xde\x5f\x55\x65\x62\xea\xbf\xba\x82\xda\x6e\x79\x03\x72\x11\xf9\x3f\xc5\x86\x2e\x6a\x66\xae\xa0\x91\x21\x74\x32\x41\xc4\x18\xfb\x72\xba\x78\xe0\x7c\xf4\x38\x54\x05\xc7\xfa\x23\x16\x25\x32\x70\xcc\xb2\x2a\x39\x9a\x06\x7d\x66\x03\xf4\x33\x83\xb1\x02\x99\x84\xa9\xf4\xb0\x96\xfc\x44\x43\x15\x92\x2a\xfd\x9f\x62\xda\x0a\xa5\xae\xba\x22\x0e\x56\xed\x8c\x66\xad\x73\x3d\x3c\xc4\x0d\x50\xeb\xea\x18\x75\xd3\xbd\x3b\x43\x3e\x7d\xab\xcb\x5d\x5c\x95\xa9\xff\x1e\x6f\x43\xb7\x39\x09\x3f\xd0\x8d\x4c\x6d\xae\xd7\x61\x36\xb8\x75\x2e\x4b\x40\x45\x27\x68\x26\xa1\x92\x57\xd8\xe9\x8a\x8b\x45\x45\xef\xb7\x2f\xa5\x73\xf2\xc5\xae\x09\x78\x91\x50\xbd\xa3\xad\xcb\xf9\xd4\xfd\x45\x7c\xef\x5a\x5e\x05\x3a\x96\xa5\xf1\x77\xd8\xee\x77\x08\xc0\xc6\x2a\xeb\x1d\xd2\x48\xee\x90\x79\x72\x97\x0c\xc4\x9d\x93\x98\xd6\xef\x9b\x81\x27\xd4\x45\x89\x1e\x61\x34\x99\x91\x5b\xb6\xe8\x23\xdd\x2a\x28\x44\xf3\x00\x54\x2e\x2c\x2c\x6a\x85\x4f\xaa\xda\x35\x56\x3e\x76\x20\xf3\x8e\x01\x11\xf7\xf1\xd1\x40\x5e\x08\xd5\x4e\x5e\x72\x69\x44\x45\x64\x29\xf0\xb9\xaa\xa3\x7a\xc4\x21\x6f\x28\x16\x23\xaf\x07\xa9\xd8\xf3\xc6\x52\xdb\x4d\x6f\xfa\x72\xe5\x0d\x61\xe9\xa0\xe3\x6e\xa5\x58\xea\xed\x8a\x6f\x3b\xe1\x0f\x3e\x48\x7d\x76\xe6\xc8\xa3\x02\xca\xf9\xb9\x4a\x4e\xae\xad\x87\x52\x00\x44\x2d\x88\x46\x33\x53\x3a\xd0\x60\xbd\xb0\x52\x64\x4c\x6b\xc2\x61\x85\x39\x55\xb7\xcc\x27\x8c\xa1\xd9\x80\x5c\xdb\x49\x86\xfc\x55\x98\x16\x79\x8e\x2e\x76\xf6\xcc\xc6\xd1\x41\xf6\x23\x87\x83\xc1\x21\x12\xf8\x15\xb1\x42\x1d\xf0\x63\xb7\x9c\xba\x3b\xe4\xd2\x6d\x94\xf6\x2e\x34\x66\x06\xb6\x22\x1f\x64\xbe\x96\x10\x05\x67\x66\x9e\x81\xd1\xd6\x49\x94\x96\x97\xb3\x43\x02\xd8\x5d\xf3\x96\xef\x92\xb5\xbc\xd5\xbd\x45\xfd\xd9\x3d\x5b\xf9\x4e\xb9\xca\xd7\x65\x2a\x77\x3b\xe5\x4e\x5b\xf7\x1c\xce\xf7\x48\xb1\x9d\x77\x4a\xf3\xea\x9f\xba\x91\x12\xe4\x8e\x5a\x96\x9e\x56\x32\xa2\x4b\xfa\x94\xb1\x2f\x4a\x28\x1c\x4e\x56\x55\x9d\xf3\xc1\x82\x91\xbc\xec\x69\xa8\x85\xc0\xd3\x4b\x83\xdd\x6a\xb9\x90\xce\xe2\x61\xf3\xe9\x22\x2e\x36\x9f\x76\x97\x81\xcd\xa7\xae\xb0\x45\x61\x49\x81\xe8\xc7\x5e\xfc\x00\x52\x23\x21\x67\x77\x75\x04\x07\xe4\x9d\x63\x0a\x88\x8c\x74\xac\x65\x56\x9a\x10\xc9\xb4\x82\x63\xc0\xa0\x3e\xc3\x37\x86\x94\xfa\x66\x11\xff\x00\xce\x89\x64\xb9\x2b\x2b\xc1\x67\xa7\x23\xde\xb5\xe6\xde\x8f\xd6\x99\xe4\x1e\x30\xf4\xa2\xc4\xce\x70\xf4\x03\x84\xbc\x13\xde\x97\xba\x26\xe3\x80\x27\x89\xd1\x28\x40\x79\x71\xc5\x15\x7a\xea\xbc\xc4\x76\x56\x1b\x37\x57\x67\x98\x38\xbb\x1e\xee\xa4\x01\x44\xfd\xd7\xe8\x00\x71\x8b\x1f\xb1\x16\x30\x44\x2d\x20\x2e\xbb\x73\x51\xad\xdc\x99\x94\x2d\xd9\x79\xf6\x62\xe4\xd2\xb4\xdf\x58\x62\x19\x3b\x9d\xd6\x73\xe8\xa1\xb1\xa7\x22\xab\x51\xde\x3d\x7f\xeb\x08\x87\xf8\xb9\x8b\x9c\x8f\x28\x3e\x02\x3c\x3a\x95\x4b\xf7\xcf\x72\x35\x3b\x58\x2c\x19\x41\x69\x1b\xd4\x07\x23\xc5\xb2\x90\xe9\xa9\x2b\x25\x2d\x84\xc4\x02\x72\xba\x87\xb5\x71\x74\x0f\x15\x46\x2b\x45\x44\x77\xc5\x2a\x32\xb9\xef\x2c\x37\xec\x54\xe5\xe8\x3e\x75\x8e\xec\x06\xc2\xca\xaf\xbb\xee\x22\xb9\x67\xd9\x22\x12\xb1\xa6\xdd\x0a\xa1\xd4\xf6\xd4\x8d\x14\xea\xbc\x27\x33\x96\x53\xcc\xe1\xe7\x97\x67\xa9\xcc\x9d\xe2\xc6\x30\xcc\xa5\xc4\x54\xae\x89\x9c\xf4\x6a\x77\x06\x07\xf3\xd7\x07\xbb\x94\x83\xb9\x67\xc5\x1e\x52\xed\xc2\x1e\x80\x71\x5d\x13\xd9\x2c\x5e\x83\x2e\x91\x41\xe2\x4d\xd1\x30\x48\x58\x06\x33\x47\xe8\x3d\xfa\xc2\xf7\xa1\x47\xed\xaa\x3f\xf5\x82\xc0\xf0\xa2\x3f\xbd\xe8\x4f\x7b\xd1\x9f\x22\xc6\xe2\x09\xce\x0a\x5d\x2a\x76\x18\xf6\x0a\x55\x15\xc8\x14\x25\xe0\xb1\xa8\xe9\x55\x29\xa9\xea\x16\x37\xab\x0f\x1d\x7a\x05\xcb\xe1\x71\x69\x26\xfd\xdf\x10\x26\x12\x99\xe2\xe6\xdb\xf1\x95\x36\x20\xda\x54\x3a\x49\x3c\x97\xdc\x7f\x2b\xb6\xda\xc1\xd8\xbb\x6e\xdd\x4e\x74\xc0\x5f\x05\xbe\xd9\x13\x83\xaf\xd8\x7a\x08\x26\xf6\xb5\xb2\x7d\xae\x01\xc7\xdf\xab\x4b\x48\x2c\x2b\x0d\xc8\xed\x2b\xe6\x92\x23\x7c\x39\x48\x8a\xb2\xe7\x1a\x0c\x72\x96\x4b\xb5\xe8\x85\x46\xf6\xc7\x5a\x2f\xd7\xe2\x18\x64\x82\xa4\x54\x56\x03\xcc\x16\x5f\xaa\x74\xe0\x01\xf4\xc8\xc2\x41\xd8\xa7\x6e\x45\x83\xe2\xa7\x8e\x12\x55\x52\x31\xd0\xef\xab\x22\x4a\x93\x90\xf2\x50\xf7\x2a\xb5\xd3\xbe\x65\x62\x4e\xe6\x54\x75\xa8\x82\x1e\x3f\xf7\x94\x07\x52\x3e\xe7\x7a\xb7\x7a\x87\x8d\xa5\x8f\x1c\xd3\x40\xbb\x8e\x2c\x4d\x51\x1a\x47\x29\xfd\xa9\xf0\x21\xf3\xe1\x34\x34\x84\xa2\xd7\x07\x3b\x4d\xe3\x8b\xa9\x2f\x8c\xcf\x8e\x55\x86\xf1\xb9\x6f\xad\xe1\xfa\x28\x3b\xa3\xcd\x5e\x2b\x87\xfb\xc7\xa3\xc5\x3e\xce\x61\xc5\x22\xab\x3c\x0f\x5e\x38\x7d\xa4\x83\x86\xee\x26\x3b\xd9\x6d\x5c\x86\xfa\xd5\x26\x1b\xf7\xe3\x8f\xd8\x5a\xb3\xdf\x3b\x5b\x17\x5f\xf8\x13\xbf\xb0\x1d\xb9\x7a\x06\x2f\xb7\xb5\xad\x50\xf0\xe5\xb6\xf6\xe5\xb6\xf6\xe5\xb6\xf6\xc5\xda\xf0\x62\x6d\x78\xb9\xad\x25\x2f\xb7\xb5\x7b\x81\xe1\xfe\x6e\x6b\x51\xd4\x5b\x75\x67\xeb\x84\xbd\xea\xc2\xf6\x51\xef\x6b\x5d\xe1\x9e\xb3\x24\x91\xa5\x30\x37\xf2\x96\xb5\xbe\x74\x68\xc8\xff\x4b\xe3\x40\x02\x84\x35\xfa\xc0\x72\xe3\x47\x53\x0e\xba\x4b\x25\x9d\x64\x8b\x5d\xa4\x0a\x5a\xa6\xdc\x4a\xfe\x3b\xa3\x99\x1f\x20\x4e\x4e\x24\x52\x96\x56\x3f\xb8\xa3\x6c\x2c\xac\x07\xe4\x8c\x28\x96\xf0\x82\xbb\x32\xf2\x14\xdf\x23\xe2\x85\xda\x08\xdc\x68\x96\x4d\x5c\x8e\x7a\x11\xd7\xfa\xa9\xe4\x77\x47\x07\x57\x7e\x06\x39\x94\xf4\x99\xcc\x7d\x2d\x24\xc5\xbe\xf7\xac\xcd\xcd\xe6\x26\x1e\x21\x36\xaf\xc0\x52\x6a\x25\x86\xe0\x63\x05\x77\x01\xd6\x0f\x7d\xfc\xd9\xe7\x82\x2b\x40\xde\x11\x4b\xa4\x68\x53\x53\x75\xcd\x06\x2d\x8d\x54\xf1\x27\xb0\x8d\xb2\x94\xa4\xa5\x0a\x35\x53\xe7\x34\xe3\x29\x37\x8b\x70\x6b\xe7\xca\x6b\x51\x3c\x31\x61\x1b\x75\x05\x46\x42\x8b\x42\x49\x9a\xcc\x98\x8e\xbe\x86\x02\x8a\x0b\x22\x0b\xbe\xef\x58\x02\x0e\x64\x14\xe8\x63\x19\x64\xb6\x20\x4a\x1a\x7f\xf1\xbe\xe6\x83\x37\xd1\x60\xd0\x1d\xb9\x9c\x51\x0b\xb8\x9d\x97\xf1\x10\x38\x2b\x3e\x89\xff\xd0\x44\x66\xa9\x4f\x61\xf2\x9b\x57\x56\x28\x4c\x1c\x0e\x5a\xe2\x07\x09\x2e\x8c\x24\x99\x65\xd8\x96\x20\xae\xef\xfc\xcb\xaf\xc9\x4c\x96\x4a\x0f\xe2\xa4\x03\xaf\xe1\x1d\xea\x77\x5e\xa8\x34\x24\x63\x54\x1b\xf2\xfa\x15\xc9\xb9\x28\x2d\x9f\xea\x8c\x36\xdd\xe5\xa0\x48\x02\xfa\xd5\xd7\xad\xfb\x75\x95\x7d\xd6\x4a\x3d\x05\xe6\x46\x76\xa2\x8f\x3b\x49\x18\x18\x87\x99\xc5\x1b\x82\x90\x23\xba\x31\xb4\x85\x91\x0f\x70\xbe\x7e\x28\xe5\x78\x61\xba\x04\x51\xba\x1e\xf5\xe8\xc9\xff\x75\x2f\xdb\x24\x4f\xa9\x72\xa7\x6c\xfc\xe8\x83\x54\xb8\x98\x72\x6d\xb6\xd4\xb7\xa8\xe2\x2b\x37\x36\x6b\xcf\x56\xa6\x56\x3b\xe8\x18\x2b\x03\x7d\xbc\x44\xec\x6d\x4b\x49\xc2\xb0\x98\xe5\x45\x55\x29\x49\x48\x6c\xbb\x75\xf8\x27\x4e\x38\xe6\x11\x64\x0f\x59\xd3\x5b\x2e\xb5\x9d\xd0\xe5\x51\xa2\xf3\x5a\xb1\x5b\xfd\x14\x68\x2e\xa6\x98\xe4\x3c\x2f\x33\xc3\x8b\xac\x5a\xf7\x07\xdf\xc1\x11\xf2\xd8\xe6\x46\x23\x33\x11\xc5\xc0\x62\xcc\x36\x05\xf6\xc9\xa3\x30\x16\x13\x06\x73\x75\x2b\xcb\x0f\x0a\xaa\x68\x00\x1e\x54\xd2\xd5\xc7\xce\x7c\x47\xe1\x46\xd1\xa5\xc3\xb4\xbd\x68\x56\xcd\x38\xba\x45\xda\x27\xd2\x18\x26\xa8\x68\x61\xaa\xae\xa7\xe7\x82\x4e\x44\xde\x05\x67\x32\x2c\x83\xd2\xc0\x16\x27\xd4\x7c\x43\x93\x5b\x26\x52\x2c\x1a\x05\xcb\x4e\x17\x82\xe6\x2e\xdb\x56\x54\x8f\xbb\xd1\x5f\xf7\x9c\x61\x02\xc3\xf7\x7c\x98\x31\x72\xdd\x7d\xc2\xa0\xd4\x9d\x53\xd9\xd8\x2e\xdb\xce\xb9\x46\x93\x8d\xe2\xf3\x84\x79\xfe\x6f\xfb\xed\x73\xea\xf3\x16\xb1\xf4\x4b\x93\xf7\xdb\x13\xe1\x2f\x90\xfb\x60\x39\x87\xa4\x5a\x34\xb3\x47\x7b\x11\x62\x46\x1b\x9b\x3b\x5e\xec\xb7\xea\x8d\x1a\x77\x89\xfc\x3d\x54\xe3\xb4\x7e\x88\x3f\xd0\x54\x6a\xf2\x4d\x26\x93\x5b\x72\xc1\x40\xe8\x7a\xc8\xf2\x2c\x6a\x9c\x3e\x65\x0a\xef\x9c\x4e\xb7\xdd\xb3\xf5\x49\x2e\x05\x37\x52\x6d\xa6\x17\x8f\x57\x76\xf2\x25\xdd\xf3\xda\x0c\x55\x16\x9b\x9f\x73\xb2\x67\x8b\x6e\x5d\x37\x1e\x3a\x05\xf5\x0c\x4e\x27\xbe\x72\x55\xc0\x76\x3c\x6b\x3f\x9b\xc9\xbb\xbe\x91\xfd\x52\xb3\x3e\x6f\x71\xa1\xdb\x61\x99\xb7\x6c\x01\xb7\xd8\x1d\x17\xea\xba\xd5\x74\x06\x23\xc1\x02\x05\xef\x2d\xe7\xfe\xf0\xcd\xc5\x47\xcd\xd4\x20\x96\x01\x4f\x98\x49\x4e\x12\x56\xcc\x4e\xdc\x08\xcf\x12\x28\x9e\x88\x74\x85\x8a\xef\x87\x6c\x26\x91\x59\xe6\x02\xb3\xe5\x84\x9c\xb3\x62\x16\x06\x7e\xec\x55\x3f\x5d\x46\xe0\x42\xca\xae\x89\x50\x0f\x6d\x9f\xfa\x21\x82\x37\x78\x86\x22\x64\x52\xe3\x6e\x45\x28\x1e\x0b\x7d\x9e\x75\xa9\xcd\x07\x04\xce\xc3\xa6\x53\x3e\xac\xe5\x53\x8e\xfd\x3d\xeb\xc9\x92\xbd\xc7\x48\x8d\x04\x0d\x27\x28\x74\xa7\x2c\x25\x72\xce\x94\xe2\x29\xd3\x24\xd0\xa0\x58\x4b\xe5\xd9\x63\xc3\xed\x25\x6f\xf3\x93\xe7\x6d\xde\x41\x1d\x3a\x04\x7d\xa8\x46\xa6\xe0\xcd\x12\x99\xa2\x69\xce\xc5\xb3\x23\x54\x3a\xa1\x19\x1b\xbe\xef\xa0\x7f\xb8\x1e\x75\x15\x64\xe4\x5e\x46\xf9\xd3\xb6\x64\x25\xfb\x36\xe0\x0d\x11\x32\xdd\x66\x52\x7d\x00\x45\x62\x4a\x0d\xbb\xdb\xca\x0e\xfb\x15\xa1\xda\xde\x12\x84\xd3\xa7\x54\x39\x9e\x45\x8e\xc0\x08\xe7\x31\xe9\xd9\x3e\x99\xaa\xdb\xb5\xae\xc6\x49\xec\x15\xa7\xdf\x6d\x26\xdd\xf5\x18\x7c\x76\x3d\x24\x7f\xc0\xe6\xfb\xcd\x5e\xa8\xa4\x41\x31\xf0\x42\xe6\x94\x77\x2d\xb2\xd1\xec\xde\xcc\xbe\x1a\x2f\xe1\x3a\xb4\x25\xae\x71\x54\xc0\x65\xc2\xa7\xa5\xd5\xe9\x9c\x1e\xf6\xac\x12\xcc\x2d\x89\x2e\xcf\x37\xc1\xdc\xfd\xab\x41\x44\x26\x27\xef\x17\x59\x49\x2c\x7e\x2b\x81\x95\x84\x3b\x50\xa2\x99\xd0\x1c\x2e\x64\xa2\x5b\x71\x57\xe9\x0f\x4b\x4b\xa2\x13\x24\x8a\x38\x3d\xf2\x56\x4e\xb9\xf0\xa7\x57\xba\xfb\xba\x09\xe5\x59\x5b\x60\xbc\xc8\x24\x4f\x2e\x93\x68\x9d\x5d\x0a\x3a\xce\xda\xb8\x1b\xd4\x51\x2d\x74\x24\x6f\x32\x3a\x25\x0c\xfe\x38\x49\xb9\xb6\xff\x27\xa3\xd1\x5b\x30\xc2\x97\xc2\x4b\xcc\x60\xa0\x76\xb4\x2f\x04\x29\xe0\x41\xdc\xef\xd9\x41\xd2\xb3\x43\xf6\xbf\xa8\x27\xe1\x22\xb5\x13\x8f\x4a\xc1\xa1\x93\x14\xb4\xc0\x7c\x88\xc1\xe7\x17\xdd\x06\xc6\x8c\xdc\xcc\x78\x72\x7b\x1d\xd9\xdd\xa5\xb2\xef\x44\xf4\xaa\xc6\xc0\x9a\xbf\xed\x93\x5a\xba\xa9\x5e\x77\x57\x8d\xa3\x9e\x9e\x0f\x78\x82\x31\x72\xeb\x87\xdf\xa8\xd6\x32\xe1\xd5\x9d\x0b\xd8\x68\x2a\xe6\x90\x02\x73\xd8\xef\x9a\x40\x3c\xe8\xba\x1c\x94\x3f\x56\x70\x34\xbf\x9b\xbe\x3a\xae\x8e\x39\x18\x17\x7e\xd5\x7b\x5d\x02\xe2\xcc\x0e\xa9\xd1\xab\x8e\xcb\xa9\xd1\xbd\x30\xdc\xb8\x58\xf0\x6e\xea\x6e\xf3\xbc\x20\xe6\x6b\x73\x2e\x6d\x5f\x48\x91\xee\x52\x13\xee\x6d\xe1\x6d\xc2\x36\x56\xa9\xe1\x8d\xdb\x44\x7c\xe7\xae\x1a\xe0\xcc\x15\xb2\x28\x33\xf4\xe7\xb8\x7f\x7e\x77\x6f\x33\xc6\xef\xec\xe9\xea\xe1\x31\xb2\x96\x1e\xc6\x8e\xbd\xdd\x3d\x9d\x7f\x1c\xb9\x4b\x23\xe1\xee\xd5\xaf\xbe\xfe\xfa\x4b\xcf\x66\xda\x56\x05\x7f\x88\x74\xa6\x2d\x4d\xb4\x2b\xe2\x8b\x86\x2f\xf1\x45\x3f\xdd\xf8\xa2\x87\xcf\x42\xbb\xe7\x08\xa2\x8e\xbe\xb9\xdd\xfc\x72\xdb\xc7\x08\xb5\xf6\xde\xed\xea\xb9\xdb\x21\x0a\x68\xbf\xb1\x3f\x9d\x7d\x59\xbb\xc4\xf9\xbc\x44\xf7\xfc\x58\xa3\x7b\x76\xf1\x65\xed\x1e\xc9\xd3\xc5\x87\xf5\xc7\x18\xb5\xd3\xe1\x70\xb6\x8f\x2e\xb9\x77\x4c\x49\xf7\x24\x80\xdd\xed\x69\xbb\x14\xa4\xaa\x7a\xae\xd4\x20\x7d\x50\xb9\xcf\x3d\x76\x78\xa8\xa3\xd4\x62\x46\xda\x13\xf8\x28\x0a\x09\xe9\xa0\x8d\xe1\xf0\xb2\x4b\x6d\x48\xd7\xe7\xfd\xa8\x71\x31\x13\x5e\x3f\xcd\x7d\xcc\x4f\xe1\xc2\xe3\xa5\xa6\xcb\x17\x62\x72\xd7\xb5\x6c\x2d\xde\x5a\x01\x24\x00\x18\xb9\x1c\xc7\x59\x22\xab\xa3\x73\x76\x3d\xb4\x3a\x38\x84\x11\xd1\x4c\x0f\xc8\x0a\x3e\xef\xcd\xa5\x4e\x2e\xf0\xfc\x9d\x1a\xc3\xf2\xc2\xb4\xdf\xf5\x17\x8b\xfb\x93\x5b\xdc\xf7\x68\x01\x9c\x95\x39\x15\x7d\x7b\xa2\xc0\xe6\x5e\xbb\xad\x6b\x50\xe6\x01\x71\x67\x07\xd9\x13\x58\x40\x20\xb8\xa0\x5e\xd8\x98\x46\x65\x2e\x1f\xc6\xec\x09\x63\xef\xbc\x72\xe4\xab\x8d\x93\x96\xc8\x25\x87\x57\xb7\x9c\x00\x05\x7f\xa8\x22\xe6\x5c\x53\xc3\xcd\x8c\x21\x0f\xbf\x86\x80\x9c\xaa\x55\x5d\x92\x46\x51\x9a\x66\x99\xbc\xc3\x6f\xc7\x7c\xcd\x42\xdf\xce\xc5\x45\x9a\x8d\x19\xc9\xb9\xd5\xd1\x9d\x81\x35\x9e\x0e\x5e\x99\x5a\x89\x9c\x29\x14\x78\x95\xbb\x6c\x1b\x31\xe3\x36\x0a\x36\xda\xea\xb7\x02\x1d\xc2\xed\xbf\xbd\x57\x11\x7c\xdb\xd3\x84\x31\x9b\xd1\x39\x97\xa5\xc2\xde\x46\x92\x03\xf7\x13\xf0\x86\x85\x2c\x83\xbd\x0b\x8b\x61\x86\xd5\xe9\x15\x70\xba\xaa\x7e\x04\x55\x20\x95\xde\x34\xd1\x67\x9f\xb9\x36\xcb\x6b\xf1\x20\xf2\x69\xf0\xf6\x85\x37\x73\x5d\x58\xb6\xd0\xb9\xaa\x5d\xad\x5f\x5d\x5e\x99\x8f\xe0\xa7\x2f\xa8\xa6\xdd\xd6\xec\xae\x8f\x26\x02\xfd\x04\xc5\x9f\x70\x13\x96\xf1\x64\xd1\xb9\xdc\x5b\xa3\xb7\x27\xda\x3a\xdc\xa1\xd9\xf7\xe4\x1b\xaa\x59\x4a\xde\x51\x41\xa7\xa8\xef\x1d\x8d\xae\xbf\x79\x77\x6c\xf7\x15\xf4\xc9\xe1\xc5\xca\x8b\xb6\x51\x3c\xf8\xd5\x3e\xe3\x45\x96\x16\xbe\x03\xab\x5a\xea\xbf\xe3\xe2\xf7\x1a\x08\x43\x02\x1f\x6a\x97\xac\x77\x05\x0b\xba\x6e\x86\xb0\x36\x6b\x7e\x36\x08\xcc\x3c\x4f\xef\x59\xe5\x93\x0b\x6d\x68\x96\x5d\x67\x54\x9c\x15\x85\x92\xf3\xd5\xda\x78\x6d\xae\xbe\xa1\x9f\x29\xba\x79\xf8\x97\x05\x82\x1e\xae\xb0\x05\x19\x56\xe3\x0f\xc8\xd0\x04\x2d\x5c\x0a\x60\xa9\x07\x67\xa5\x91\x39\x35\x3c\x39\xb0\xca\xfa\xc1\x3b\x2a\x4a\x9a\xad\x74\xba\xda\xb8\x8c\x75\x22\xe2\xc6\x4e\xeb\x53\xd7\xb5\xe8\xb6\x51\xd6\xd8\xdc\xdf\x50\x65\xa9\xd3\xf9\xe8\x53\xa7\xbe\xda\x50\x53\x2e\x51\xe1\x0d\x9c\x61\x3d\x2f\xe8\x93\x8c\x6a\xf3\xb1\x48\xed\xa1\x6f\xfc\xba\x89\xe0\x27\xd4\xd0\x4c\x4e\xff\xc8\x68\xb6\x1a\xc3\x6b\x78\x72\x1e\xb7\xf6\x06\x28\x77\xe1\x5f\x8e\x43\xc3\x43\x4d\xac\x80\xed\x63\xe0\x15\xcb\xd8\x9c\x0a\xe3\xbb\x63\x71\x75\x7d\xe8\xd6\x0f\x58\xc4\x2b\xe3\x6b\xca\x0c\x53\x39\x17\xf5\x31\x47\xd0\xf6\x5c\x8a\x94\xa3\xd9\x11\x0c\x6a\xd8\xa3\x3e\xee\x7a\x54\x5b\x77\xd3\xb0\xe1\x6e\xa1\x9e\x5d\x33\x9a\x4f\x1d\x14\xd8\x6c\xec\xe4\xcb\x19\xbe\x84\x9b\xf6\xda\xdc\x96\x20\x45\x6e\x85\x15\x0c\x21\x8f\xc8\x6a\xb2\xb5\x55\x4e\xd8\x26\x1f\xf4\xfd\x1e\xe3\x14\xd6\x3b\x8e\xf6\xdd\xbc\xd7\xdd\x41\x6c\x42\x31\x7c\xb6\x4b\x16\xcd\xa9\xac\xa7\xa9\xab\xf0\x2e\x74\xc3\x48\x96\x46\x41\xfe\x5a\xa3\xf5\x3c\xa0\x95\xe0\xd5\x4e\x46\x6a\x9b\xd5\xbe\x4e\x6b\xab\x1c\xec\x4b\xaa\x6c\x0b\x89\x71\x2b\xd3\x6a\x99\x5c\xbe\xae\x58\x0f\x9d\xff\x9f\x72\xaa\x08\x25\x05\x67\x98\xfc\x84\x0a\x07\x2c\xe0\x2c\x8c\xa6\xee\xa5\xe5\x60\x56\x25\x84\xdf\x7a\xee\x32\x1c\x8d\xcb\xce\xd7\xc2\x1b\xa8\x29\x26\xff\x80\x8b\x8b\x93\x3f\x48\x67\xe4\x75\x41\xba\x96\x06\x00\x27\xef\x11\x5d\x26\x33\x42\xb5\x9d\x9a\x45\x68\x7b\xe2\xd9\x20\xa7\x82\x4f\x98\x36\x83\x90\x25\x58\xff\xf9\x97\x7f\x1d\x90\x37\x52\x11\xe7\xa8\xde\xf3\x59\x35\xdc\x3c\x2b\xbc\xe0\x1a\x17\x13\xfa\x56\x5a\x6b\x21\x53\x37\xe9\x3b\x98\xac\xa1\xb7\x96\x87\xe1\x64\x4b\x06\x57\x17\xa7\xe4\xc0\x8a\x89\xd1\xa7\xff\x69\xd9\xd2\xbf\x0f\xc8\xd1\x1d\x30\xed\x03\xfb\xe7\x01\x7e\x30\xb8\x4d\xc6\x4a\x75\xf5\x61\x0c\x96\x54\x7c\x3a\x65\x0a\xd5\x47\x02\x41\x85\xc7\x2e\x2b\x88\x90\x51\x63\x7f\x29\x5d\xa9\x9b\xcd\x89\xfc\xf9\x97\x7f\x3d\x20\x47\xf5\x75\x11\x2e\x52\xf6\x99\xfc\x12\xad\xcb\x5c\xdb\x35\x1e\xbb\xcb\x1c\xbd\x10\x86\x7e\xb6\x63\x26\x33\xa9\x99\x40\x55\xde\x48\x32\xa3\x73\x46\xb4\xb4\x1a\x30\xcb\xb2\xbe\xb3\xa5\x93\x3b\x0a\x99\x5a\x3c\x28\x21\xb0\x9e\x14\x54\x99\x1a\x4a\x0c\x9c\x85\x04\xbe\x66\xb7\x6d\x2a\xfc\xcd\xf4\x84\x0b\x77\x7f\xe5\x6e\xce\xec\x9e\x43\x60\x28\x6e\x92\x91\x24\x99\x51\x31\x0d\xb1\xe9\x93\xd2\x94\x8a\x6d\xb9\xfa\x69\x79\x06\x6e\xb9\xe8\x14\xc2\xfc\x2d\x17\x4d\xa7\x82\xd5\x76\xa5\x29\x37\x3e\x2a\xc2\xf9\x2a\x9a\xc5\x89\xdd\x05\xc5\xc7\xa5\x91\x4a\x9f\xa4\x6c\xce\xb2\x13\xcd\xa7\x7d\xaa\x92\x19\x37\x2c\xb1\xcb\x3a\xa1\x05\xef\x27\x52\xd8\x1d\x87\xac\x0c\x79\xfa\x33\x28\x6f\xda\xb7\x53\xdd\x92\x75\xba\xe5\xa2\xb7\x1b\xd5\x9e\xd4\x98\xb6\xb7\x35\xb6\xb0\x07\x2d\x2f\x14\x6d\x33\x8f\xb0\x5a\x30\x84\x9c\xec\x65\xb1\x3e\x69\x72\x77\x1e\x73\xe8\xf2\x80\x27\xcd\x31\xec\xb1\x43\x07\x12\x38\x95\x35\x4a\x99\xd3\x14\x49\x29\x15\x8b\x07\x47\x7e\x0b\x52\x48\x97\x9f\x2c\xfa\x30\x84\xcc\xfa\x54\xa4\xf6\xdf\x18\xb0\x93\x2c\xf6\x02\xc3\x92\x77\x22\x04\x1f\x87\x17\x8f\x73\x24\x4a\xbe\x87\x53\xef\xe4\xb5\x96\x42\x14\x8a\xaa\xe8\xa8\xa1\x4a\xe6\x99\x66\x5d\x40\xe5\xda\x8f\xfa\xdf\xee\xfe\x25\x64\x3b\xdb\x26\x52\x6d\xbe\x35\x89\x64\xc7\x96\xf3\x7d\x5b\xf5\x88\x6d\x72\xe0\x78\x45\xb5\x71\xa9\xb5\x7c\x0e\x82\xda\x32\xbc\x82\x02\x0c\x66\xfd\xc5\x70\x2b\x1c\xf2\xfe\x02\x76\x22\xfd\x95\x39\x97\x92\xa0\x94\x6c\x57\xa0\x2a\xfd\xa5\x56\x07\x0d\x17\x65\x98\x36\x84\xce\x29\xcf\xc0\x3a\x2f\xc7\x9a\xa9\x39\x16\xa4\x72\xa9\x06\x69\x53\xcf\x72\x35\x27\x50\x8c\x7a\x24\xcd\xc7\xaf\x61\x79\x57\x36\x2d\x00\xb4\xa1\xc6\xec\xd7\xce\x7a\x2f\x7a\x0f\xaa\x97\x6b\x7f\xb6\x5f\xd8\x51\x8d\xb1\xf8\xf7\x47\x46\x95\x19\x33\x6a\x6e\xf8\x26\xbe\xbb\x84\xd2\xb5\x7e\xa1\x94\x7b\x40\xe8\x3b\x46\xa6\xd2\x58\x11\xab\x04\xdc\x47\x99\x14\x93\xfa\x04\x44\x7b\x68\x8c\xae\x56\x79\xa3\x28\x84\xf8\x48\xd1\x71\x99\xf5\x8e\xcb\xeb\x74\xd2\xb1\xc3\x24\x83\xad\x31\x91\x86\x14\xcc\xed\x1d\xde\x66\x00\x05\x7a\x9c\x25\xe7\x4c\xeb\x8d\x09\x36\xea\xde\x85\xd8\x1a\x8f\x72\xe3\x6a\x2d\xf7\xbf\x61\x58\x88\x15\xa0\x53\x66\x28\xcf\xfc\x51\x46\x50\x04\x28\x6d\xa3\xae\x1b\x17\xa8\x18\xd5\x9b\x04\x84\xda\xac\x3f\x40\x63\x9c\xb4\x14\xac\x7f\x27\x55\x4a\xce\x69\xce\xb2\x73\xaa\x99\x1b\x2b\x0e\xd1\xc3\x3d\x3a\xd4\x7b\x9d\xf2\x6a\xdb\xd7\x9a\x29\xa3\xf1\xa7\x32\x09\xc3\x5f\x95\x8a\x85\x13\xec\x79\x13\xe4\x8d\x2a\x59\x8f\xbc\xb1\xdc\xab\x47\x3e\x8a\x5b\x21\xef\xee\x37\x57\xb3\xf1\x16\xa4\x36\xd3\xd8\xfd\xc3\xa7\xd5\xa9\x19\x7c\xc2\x74\x77\x9c\x91\x23\xf8\x6b\x4c\x8d\x75\x66\x13\x9a\xfa\x19\xd9\x7f\x2e\x99\xa0\xac\xa2\xa8\xe4\x54\x31\x8d\x99\x6b\x56\x26\x49\x6c\x6b\x72\xfe\x03\x13\x2e\xb8\x6f\xeb\xf4\x86\xab\x7a\xf9\x99\x7a\xbe\x36\xad\x7e\x71\xfb\xed\x3e\x56\x64\x2b\x45\x8d\xcd\x1e\x81\xd1\x44\xd7\x18\x9f\xd6\xcd\x70\xb5\xd1\x29\xe2\x7a\x51\x5b\x14\x4a\x36\x59\x47\xfd\xea\xce\x47\x9f\xd6\x03\x7b\x2d\xef\xdb\xc6\x9f\xb6\x9b\xa5\xee\x6b\x90\xda\x7a\x66\xb6\x1a\xa1\x5e\xcc\x4f\x2f\xe6\xa7\x2f\xc9\xfc\xb4\x15\xe3\x37\x99\x9c\xbe\x0c\x63\xd3\xd6\x25\x6e\x32\x30\x3d\x4b\xd3\x52\xab\x15\x6d\x34\x27\x3d\x5b\x43\xd2\xd6\xa5\xb5\x34\x1e\xfd\x74\xcc\x46\x5b\x21\xb6\xc1\x54\xf4\x0c\x8d\x44\x6d\x04\x32\x96\xb6\x11\x13\x87\x51\xe3\x58\x50\xac\xca\x59\x86\xe1\xbc\x53\x4e\x2c\xce\xec\x2a\x2d\x5a\x01\x6e\xeb\xdc\x0e\xdd\xe4\xda\xcb\x5e\x4e\x60\x74\xc5\x1e\x97\x26\x4b\x2e\x2e\xaf\x3f\x5c\x9e\x9f\xdd\x5c\x5e\x34\xe5\xbb\x55\x90\xde\x22\x89\x6d\xb6\x41\xf4\x23\x49\x6c\x4d\x03\x4b\x90\xd7\xfc\x64\x71\x60\xcd\x4f\x65\xc9\x57\xf5\xba\xbf\x5c\x78\x2f\x2e\x77\x2f\xfe\xb1\xfd\x74\xb6\x3d\x9e\x1f\xd1\x71\x8a\x3a\x9f\x33\x2b\xf7\xcc\x64\x96\x6a\xef\xb7\x3a\xbc\x08\x91\x54\x5c\x24\x59\x99\x5a\xe1\xe2\xe3\xc7\xe1\x85\x1e\x10\xf2\x0d\x4b\x68\xa9\xc1\x0a\x93\x4a\x71\x68\xc8\xfb\xab\xb7\x7f\x02\x7f\x6c\x68\xd1\x0b\x79\x4d\x20\x2b\x2f\xa7\x98\x58\xd8\x60\xba\x36\xf2\x0d\x43\x41\x05\xbe\x9c\xd0\xc2\x52\x31\x8d\x95\x2b\x0c\xc8\x22\x33\x96\x15\x96\x62\xde\x32\x52\x65\x50\xb5\x03\x57\x15\xe6\xbd\xfb\xe4\x94\x19\x8c\xba\xda\xe4\x21\xb9\x11\x6a\x5b\x2c\xae\xf7\xb0\xb5\xd6\xd4\x47\xa7\x8d\xdf\x51\xed\x2c\x56\x2b\x67\xbb\x65\x7f\xb7\xdb\x67\xd6\x9b\x38\xd6\x18\x37\x90\x3c\xc3\x5f\x4b\x73\xb6\x93\xad\xec\x18\xe8\x44\xc2\x4d\x6b\x6b\xea\x7a\x37\xa0\xd5\x75\x00\x96\x6c\x19\xac\x09\xe4\xda\x87\x83\x47\x76\x34\xe5\x76\x73\x81\x22\x22\x69\xad\xf6\xa7\xf3\x9f\xab\xbf\x2b\xc7\xa1\xfa\x6b\x35\x5f\x67\x91\x21\xff\xfc\xf7\x57\xff\x3f\x00\x00\xff\xff\xbb\x99\xbb\xd7\xde\xb1\x01\x00") +var _operatorsCoreosCom_subscriptionsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\xbd\x7b\x73\xe3\xb8\x95\x38\xfa\xff\x7c\x0a\x94\x93\x2a\xdb\x59\x49\xee\xce\xe6\x97\xe4\xf6\xa6\xb2\xe5\xb1\xdd\x13\xff\xa6\xbb\xc7\xdb\x76\xcf\xd4\xde\x6c\xee\x06\x22\x21\x09\x31\x09\x70\x00\x50\x6e\xe5\xf1\xdd\x6f\xe1\x1c\x00\x04\xa9\x17\x29\xc9\x8f\x9e\x21\xff\x98\x69\x53\x00\x08\x1c\x1c\x9c\x17\xce\x83\x16\xfc\x7b\xa6\x34\x97\xe2\x0d\xa1\x05\x67\x9f\x0d\x13\xf6\x2f\x3d\xba\xff\xbd\x1e\x71\x79\x36\x7f\xfd\xd5\x3d\x17\xe9\x1b\x72\x51\x6a\x23\xf3\x8f\x4c\xcb\x52\x25\xec\x92\x4d\xb8\xe0\x86\x4b\xf1\x55\xce\x0c\x4d\xa9\xa1\x6f\xbe\x22\x84\x0a\x21\x0d\xb5\xaf\xb5\xfd\x93\x90\x44\x0a\xa3\x64\x96\x31\x35\x9c\x32\x31\xba\x2f\xc7\x6c\x5c\xf2\x2c\x65\x0a\x06\xf7\x9f\x9e\xbf\x1a\xfd\x7e\xf4\xea\x2b\x42\x12\xc5\xa0\xfb\x1d\xcf\x99\x36\x34\x2f\xde\x10\x51\x66\xd9\x57\x84\x08\x9a\xb3\x37\x44\x97\x63\x9d\x28\x5e\xc0\x27\x46\xb2\x60\x8a\x1a\xa9\xf4\x28\x91\x8a\x49\xfb\xbf\xfc\x2b\x5d\xb0\xc4\x7e\x7c\xaa\x64\x59\xbc\x21\x2b\xdb\xe0\x70\x7e\x8e\xd4\xb0\xa9\x54\xdc\xff\x4d\xc8\x90\xc8\x2c\x87\x7f\xe3\xda\x6f\xa3\xaf\xc2\xeb\x8c\x6b\xf3\xed\xd2\x4f\xef\xb8\x36\xf0\x73\x91\x95\x8a\x66\x8d\xd9\xc2\x2f\x7a\x26\x95\xf9\x50\x7d\xdb\x7e\x4b\x97\xe3\xf8\xdf\xae\x21\x17\xd3\x32\xa3\xaa\x3e\xc8\x57\x84\xe8\x44\x16\xec\x0d\x81\x31\x0a\x9a\xb0\xf4\x2b\x42\x1c\x1c\xdd\x98\x43\x42\xd3\x14\xf6\x86\x66\x37\x8a\x0b\xc3\xd4\x85\xcc\xca\x5c\x84\x6f\xda\x36\x29\x0b\xa3\xbe\x21\x77\x33\x46\x0a\x9a\xdc\xd3\x29\xf3\xdf\x1b\xb3\x94\x18\x19\x3a\x10\xf2\x37\x2d\xc5\x0d\x35\xb3\x37\x64\x64\x41\x3c\xb2\x10\x8c\x7e\xc6\xfd\xb9\xc1\x41\xa2\xf7\x66\x61\xa7\xab\x8d\xe2\x62\xba\xe9\xf3\x09\x35\x34\x93\x53\x82\xf8\x45\x26\x52\x11\x33\x63\xc4\x7e\x8a\x4f\x38\x4b\xfd\xfc\x36\xcc\x08\xbb\x2e\xcd\xe9\xb6\xf9\xba\xf5\x94\x66\x54\x08\x96\x11\x39\x21\x65\x91\x52\xc3\x34\x31\xb2\x82\xcf\x66\xf0\xb8\xce\x4b\xb3\xb9\x58\x7a\xbf\x62\x3a\xd8\x74\xfe\x9a\x66\xc5\x8c\xbe\x76\x2f\x75\x32\x63\x39\xad\xf6\x50\x16\x4c\x9c\xdf\x5c\x7f\xff\xef\xb7\x8d\x1f\x48\x7d\x29\x31\x8a\x92\x7b\xc6\x0a\x5d\x1d\x0a\x52\x16\x76\x4d\x76\x71\x64\xbc\x20\x46\xd1\xe4\x9e\x8b\x29\x2c\x7d\x8a\xeb\xbd\xc0\x8d\xd1\xa3\xa5\x29\xcb\xf1\xdf\x58\x62\xa2\xd7\x8a\xfd\x58\x72\xc5\xd2\x78\x2a\x16\xb2\x9e\x44\x34\x5e\x5b\x38\x45\xaf\x0a\x65\xa7\x65\xa2\x73\x88\x4f\x44\xa3\x6a\xef\x1b\xcb\x3c\xb6\xb0\xc0\x76\x24\xb5\xe4\xc9\x4e\x7f\xc6\xfc\xe1\x60\xa9\x03\xa0\xdd\x4e\x33\xe3\x9a\x28\x56\x28\xa6\x99\x40\x82\x65\x5f\x53\xe1\xd6\x34\x22\xb7\x4c\xd9\x8e\xf6\xc0\x96\x59\x6a\xe9\xd8\x9c\x29\x43\x14\x4b\xe4\x54\xf0\xbf\x87\xd1\x00\x44\xf6\x33\x99\xc5\x0f\x43\xe0\xb8\x09\x9a\x91\x39\xcd\x4a\x36\x20\x54\xa4\x24\xa7\x0b\xa2\x98\x1d\x97\x94\x22\x1a\x01\x9a\xe8\x11\x79\x2f\x15\x23\x5c\x4c\xe4\x1b\x32\x33\xa6\xd0\x6f\xce\xce\xa6\xdc\x78\x0a\x9c\xc8\x3c\x2f\x05\x37\x8b\x33\x20\xa6\x7c\x5c\xda\x8d\x3b\x4b\xd9\x9c\x65\x67\x9a\x4f\x87\x54\x25\x33\x6e\x58\x62\x4a\xc5\xce\x68\xc1\x87\x30\x59\x81\x24\x32\x4f\x7f\xa1\x1c\xcd\xd6\xc7\x0d\xf0\xad\x3c\x07\xc4\x53\xbd\x8d\xb0\xb6\xc4\x8f\x70\x4d\xa8\xeb\x8e\x6b\xa9\x40\x6a\x5f\x59\xa8\x7c\xbc\xba\xbd\x23\x7e\x02\x08\x76\x84\x70\xd5\x54\x57\xc0\xb6\x80\xe2\x62\xc2\x14\xb6\x9c\x28\x99\xc3\x28\x4c\xa4\x85\xe4\xc2\xc0\x1f\x49\xc6\x99\x30\xf6\x18\xe6\xdc\x68\xc0\x39\xa6\x8d\xdd\x87\x11\xb9\x00\x06\x44\xc6\xcc\x1d\xd8\x74\x44\xae\x05\xb9\xa0\x39\xcb\x2e\xa8\x66\x8f\x0e\x6a\x0b\x51\x3d\xb4\xe0\x6b\x0f\xec\x98\x7f\x2e\x77\x58\x3a\x63\x84\x78\x06\xb7\x76\x77\xe2\x03\x7f\x5b\xb0\x24\x1c\x07\x2a\xc8\x79\x51\x64\x3c\x41\x8c\x37\x33\x6a\x48\x42\x85\x85\x17\x17\xda\xd0\x2c\x03\x76\xd2\x6a\x16\xeb\x4e\x3b\x81\xa3\xdd\x60\x0e\xfe\xf5\x12\x85\xae\xff\x10\x98\x5a\xa3\xc5\x3a\xca\x60\x1f\x47\x67\x97\x7f\xd8\x00\x72\x82\x92\xc9\x84\x4f\x57\x75\x5b\x0b\xcb\x0b\xe8\x02\x32\x0d\xe5\x42\xbb\x21\x4a\x85\xd0\xac\x38\x95\xe5\x5d\xb4\xc6\xb7\x47\x6b\x67\xb7\x12\xb2\xdb\xd6\x6c\x1f\x3a\x01\x09\x6c\xb1\xfa\xd7\xc6\x2a\xae\x27\xd5\xf4\x06\x44\xce\x99\x52\x3c\x75\xf4\xb1\x90\xe9\xb1\x06\x6a\x96\x96\x19\xd0\x7e\x29\xb4\x51\x94\xc3\xd1\x14\x3c\xb3\x2b\x19\x52\x83\xe7\x81\x69\xf2\xc0\xb3\x8c\xfc\x4a\x48\xf3\xab\x30\x12\x0c\x24\x15\x9f\xf2\x40\xfa\x34\xe1\xc2\x8f\x0f\x1c\xd1\xb1\x74\xa9\x59\x63\xc0\x11\xf9\xa4\x19\x61\x79\x61\x16\x9e\x38\x9c\xfc\xe3\x5f\xa7\x96\xb0\x32\x45\x75\x34\x70\xad\x9f\x27\x9f\x6b\xd6\xbf\x05\xbc\x6d\x40\x6c\x1f\x21\x53\x76\xbe\x05\xd4\x4b\xe0\xbe\x64\x28\x21\x68\xe8\x1e\xb6\x2a\x06\xb2\x2a\x33\xa6\x83\x94\x63\x61\xb4\x61\xf0\x16\x6b\x69\xbb\x1e\x6c\xc7\x26\x4c\x29\x96\x5e\x96\xf6\x68\xdc\x86\x59\x5d\x4f\x85\x0c\xaf\xaf\x3e\xb3\xa4\x34\x2b\xb8\xee\xc6\xa5\x5b\xb9\xc9\x2d\x93\x29\x44\x15\xfc\x1c\x88\x4e\xee\x07\xbb\x5e\x60\x9c\x16\x3c\x1a\xe9\x90\xa6\x86\xeb\xc9\x02\xc0\x11\x00\xc6\x3e\x5b\x26\x01\xb2\x6d\x74\xbe\xac\xa0\x02\xfc\x81\xb3\x2c\x1d\x90\x71\x69\x08\x37\xc0\x3c\x92\x99\xb4\xf8\x45\x11\xee\x30\xee\x9c\x4b\x60\xcd\x44\x0a\x8b\x49\x24\xb7\x1c\x00\x44\x00\x16\x0f\x3f\x82\x99\x57\xdd\xb8\x26\xb9\xd4\xa6\x82\x95\x7d\x03\x58\x2e\x18\x79\xe0\x66\x06\x7f\x4c\xad\xba\x62\xd9\xbe\x2e\x73\x3b\xe8\x03\xe3\xd3\x99\xd1\x03\xc2\x47\x6c\x04\xbb\xcb\x68\x32\x8b\x86\xcd\x19\x33\x9a\xd0\x2c\xf3\x53\x88\x51\x02\xe9\x69\x6e\x79\x22\x39\x09\x4c\xd3\x31\xb8\x41\xa0\xb7\xcd\x5d\x5b\x09\xae\x01\x61\x26\x19\x9d\x0e\x48\x22\xf3\xc2\x9e\x16\x0a\x73\x1c\x2f\x08\x37\x56\xf6\x43\x06\xad\x64\x39\xc5\x95\xb0\xcc\x7d\xd8\x4b\x47\x00\x5c\x10\x5f\xac\x36\x21\xa6\xe4\x08\x17\x77\xe4\x05\x1e\x3b\x1c\xc7\x45\xc0\xfa\x72\x6a\x92\x99\xa3\x29\x89\x54\x8a\xe9\x42\x0a\xe8\x09\xbf\x5c\x55\x73\xfb\x8f\xd0\xe9\x44\x9f\x56\xc0\x9c\xf1\xe9\xcc\xc3\x92\x2a\xa4\x29\xf5\x3d\xd8\x74\x46\xaa\x73\x42\x95\xa2\x8b\x2d\x2d\xb9\x61\xf9\x96\x53\xb2\x84\xda\xe7\xc2\x11\xa9\x0a\x27\xa2\xdd\x33\x4c\xe5\x01\x06\xb0\xc1\x70\x5c\x35\xae\x8f\xe7\x96\xed\x72\xe3\x30\x84\xbc\x22\x27\x80\x22\xdc\x1c\x6b\x40\xd7\xa1\x2c\x4e\x47\xe4\x1c\xb4\xdd\x16\x1f\x10\x32\x8c\xef\x06\xb2\x1f\xd5\xb2\x1a\x6b\xeb\xda\x5a\x12\x15\x7c\xd6\xf3\xfa\xe5\x67\xe8\xe6\xcf\xc4\x0a\x56\xbf\xaa\x39\xc2\x64\x6b\xd3\xb6\xe4\xcd\xb7\xf6\x73\x68\xd3\xba\xb9\xd5\x88\xd2\x9a\x65\x2c\x31\x96\x46\x33\x95\x0f\x08\xd5\x5a\x26\xdc\x8a\x95\x15\xd2\xd6\x31\x1d\x57\xb2\x1d\xf6\xa4\x2b\xfc\x49\xe7\xf5\xdb\xa7\x79\xf0\xda\xf6\x5b\x82\x46\xc6\xb5\xb1\x94\xa1\x0e\x95\x1a\xc1\x1a\x2f\xe0\xd7\x63\x4d\x32\x3a\x66\xd9\x5a\xbe\xbc\xfc\xb4\x3f\xb5\xd5\xd3\xf2\xfc\xae\x5d\xd0\xda\x85\x38\xa5\x26\x6c\x3c\x88\xc8\x5e\xe0\x43\x89\x63\x40\x28\xb9\x67\x0b\xd4\xed\xac\xca\xe8\x94\x69\x6c\xac\x18\xb2\x1b\x8b\x1c\xf7\x6c\x01\x8d\x36\x4b\x2a\xeb\x61\xd2\x01\x39\xf0\xe9\x72\x4c\xab\x67\x68\x27\xda\xb1\x87\x5f\x74\x87\x6e\xdd\xf1\x17\x9f\x7b\xb6\x51\xf2\x5a\xf5\x2c\x89\x24\x80\x93\xb0\x1f\xb0\x49\xc0\xbf\xfc\x1e\x53\xab\x12\x81\xad\xa3\xcb\x0e\x91\x6d\x0a\xc6\xa6\xc7\x43\x6f\xaf\x75\x7d\x0c\x1a\x34\x22\xe4\xb1\x46\xe4\xb3\x27\x7d\xc6\xc1\xae\x63\x31\x19\x0e\xae\x37\x35\x7c\x4f\x33\x9e\x46\xe6\x1f\xcb\x67\xaf\xc5\x80\x7c\x90\xc6\xfe\xef\xea\x33\xd7\x56\x7c\xb9\x94\x4c\x7f\x90\x06\xfe\x1c\x91\x6f\x0c\xe2\xfa\xbb\x96\x94\xed\x00\x00\xc2\xf9\xee\x05\x9e\x73\x81\x34\xc5\x2e\x3f\x36\x52\xe8\x91\x55\x87\x40\x94\xf3\x07\x97\x6b\x72\x2d\xac\x70\xe8\xc0\x00\x66\x23\x54\x62\x70\x88\xbc\xd4\x60\x55\x10\x52\x0c\x41\x06\x58\x39\x06\x42\xcf\x8e\x13\xc3\x6f\xc3\x70\xeb\x87\xfa\xc6\xd8\x61\xde\xad\xed\x3c\xa3\x73\x10\xe9\xb8\x98\x66\x41\x78\x1b\x90\x87\x19\x4f\x66\x28\x75\x83\x4e\x6f\x98\x2a\x14\xb3\x0c\x8b\x82\xf6\x6f\xdf\x4c\x99\xb2\xc2\x2e\xf7\xe3\xa1\x25\x2c\xa3\x09\x4b\x49\x0a\xa2\x25\x5a\x75\xa8\x61\x53\x9e\x90\x9c\xa9\x29\x23\x85\xe5\x24\xbb\xed\x7e\x37\xc2\x8e\x4f\x67\xf2\x1e\x7f\xb0\x13\xba\x01\x8b\x7c\x6b\x65\xdd\x27\xe2\x8e\x20\x57\xf7\xdc\xb1\xe7\x8e\x8d\xa7\xe7\x8e\xe1\xe9\xb9\xe3\x96\xa7\xe7\x8e\x3d\x77\x7c\x74\xee\x88\xba\xec\x0e\xca\xf3\x0f\x68\xe2\x68\x6a\xcb\xc0\x69\xfd\xbd\x50\x5d\x6d\xb6\xfc\xe6\xd6\x11\x9c\x3b\x50\xb5\x9d\xed\x58\x51\x31\x65\xe4\xf5\xf0\xf5\xab\x57\x5d\x94\x6a\xb7\x91\xad\x7a\x4c\xa4\xca\xa9\x81\x3e\xff\xfe\xeb\x8d\x3d\xd6\xd9\xdf\x0e\x60\x35\x75\x38\x1e\x0c\x79\x35\xd9\x61\x8d\xe1\x13\xa8\x93\x90\x86\xe4\xcc\x10\x6a\x6a\xa6\x22\x9e\xb3\x81\x37\x2c\x23\xc2\xbb\x6b\x31\x6f\x81\x4d\x89\x14\xce\x8e\x67\x81\x3f\xda\x6d\x06\x09\xa3\x9a\x59\x4a\x3a\x66\x61\x16\x32\xb7\x5f\xe5\xc2\xf8\xe3\x62\xa7\xc0\x3c\x54\xc8\x09\x1b\x4d\x47\x24\x2d\xa1\x1b\x15\xee\x9e\xee\x14\x67\xab\x17\xda\xb0\x1c\x2c\xb9\x52\xc1\xff\xec\xb4\x8d\x5a\xc0\x5d\xc0\x9c\x09\x53\xd2\x2c\x5b\x10\x36\xe7\x89\x09\xeb\x83\x6b\x42\x6e\xd0\xd8\xde\xce\x44\xd8\x4a\x74\x68\x2f\x2e\x0c\x97\x30\x58\x6f\xe9\xd3\x85\xdb\x2f\x8d\xdd\xe6\x4c\x36\x78\x21\xae\x64\xb4\x56\x58\x35\x76\x5c\xb4\x81\xc3\x3f\x01\xb9\xbe\xfb\xb8\xdd\xe4\x4a\x3a\x53\xb2\x0e\xd4\xab\x29\x96\x96\x59\x66\x11\x03\xad\xb0\xcb\x0b\x58\x61\x1d\xc5\x25\xd5\x90\x19\x0d\xef\x68\x62\x3e\xff\x70\x69\xa1\x62\xdb\xdc\xc9\x42\x66\x72\xba\x88\x21\x0d\x2b\x03\xdb\xad\xeb\x8b\xb7\x7a\x28\x34\x58\xf4\xfb\xd0\xd8\x9a\xde\xf2\xd7\x5b\xfe\x7a\xdd\x66\xe9\xe9\x75\x9b\xf0\xf4\xba\xcd\x96\xa7\xd7\x6d\x7a\xdd\xa6\xb7\xfc\x91\x9e\x3b\x6e\x80\x49\xcf\x1d\x49\xcf\x1d\xd7\xae\xab\xe7\x8e\x1b\xc1\xd3\x73\xc7\x9e\x3b\xae\x7a\x0a\x99\xee\xe1\xe8\x58\xc8\x74\x83\x9f\x23\x5a\x7d\x12\x39\xcc\x64\x42\x8d\x73\x04\xb7\x5d\x9c\x9d\x4f\xd3\x1c\x0d\x51\x03\xf2\x77\x29\x18\x3a\xaf\xd9\xbd\x01\x73\x92\x34\x33\xa6\x6c\xf3\x13\x7d\xba\xd1\xb1\xa9\xf7\x93\xec\xfd\x24\x5f\xbc\x9f\xe4\x8c\x6a\xdc\x57\x24\x4a\xeb\xdd\x26\xa3\x03\x79\xc7\x54\xfe\x85\x7a\x4d\x5a\x74\x71\xdb\x0d\x21\x36\xd5\x96\xe2\xca\x53\x77\x5f\xc0\xd2\x9b\xfa\x7a\x9d\xbc\x0c\x8b\xa2\x69\xca\x52\x52\x30\x35\x44\x14\x91\x64\xc2\x45\xba\x62\xad\x1e\x3e\xcf\xea\xfd\x58\x5f\xc7\x33\xba\x40\xd6\x27\xb2\x83\xcd\x35\x36\x1c\xd7\x28\xfc\x8b\x70\x88\xec\x2a\xd5\x0f\x89\x71\x46\xde\x6f\x5b\xca\xf5\xdd\x45\x73\x10\xa8\xbd\x49\x78\x77\xbd\x12\xc4\xf2\x1f\x4b\xa6\x16\x10\x63\x51\x09\xac\x21\x98\xcb\xdd\x91\x71\x4d\x12\xaa\x91\x53\x74\x55\x2d\x3b\xaa\x51\xbb\xe9\x29\xbb\x5b\xa2\x49\x13\x2e\xcd\xa1\x50\x27\xf5\x3a\x38\xc2\x6c\xa5\x12\xbe\xe2\x16\xa0\xb2\xfe\x77\x9a\xcf\xae\xa2\xdb\x4e\x82\xdb\x4a\xa4\x78\xc1\xca\x39\xd9\x5d\x41\x27\x3b\x2b\xe9\x64\x27\x45\x9d\xec\xaa\xac\x93\x3d\x14\x76\xb2\x9b\xd2\x4e\x9a\xa8\x60\x77\xc8\x49\x59\x8f\xa3\xbf\x93\x7d\x54\x54\xb2\x87\x1e\x4f\x9a\x4b\x0d\x68\xaa\x1e\x4b\xa9\x07\x5c\xaf\xe9\xf5\x4f\x0d\xac\xdd\x74\x7a\xd2\x04\x95\x8f\xba\x03\x85\xf6\x0b\xd1\xf0\x9f\x44\xdd\x26\x7b\xa9\xdc\x64\x77\xb5\x9b\xec\x8e\x19\xc0\xea\xde\xc1\x75\xea\xbe\x0c\x13\x47\x41\x16\x91\xd3\xc2\x22\xc5\x3f\x2c\x27\x80\x7d\xf9\x17\x29\x28\x57\xda\xca\x77\xce\x66\x12\xff\xe6\xb4\xf3\x78\x18\x3b\x02\xd7\xc4\x92\xea\x39\xcd\x2c\xef\x41\x3f\x0e\xa7\x17\xd9\xd1\x9b\x6c\x7a\x40\x1e\x20\xea\xd3\x52\x29\xd4\x96\xb8\x26\x47\xf7\x6c\x71\x34\x58\x42\xa4\xa3\x6b\x71\x84\x3c\x6a\x09\x75\x02\x43\x93\x22\x5b\x90\x23\xf8\xed\xe8\xd0\x9c\x7d\x07\xc6\x15\x27\xdb\xd8\x95\x2f\xec\x80\x25\xc2\xc7\x4a\x1f\x5e\xd8\x44\x2e\x82\x17\x1b\xfe\x2b\xba\x62\x30\xe0\x6a\x11\x31\x97\xe0\x35\x02\x38\x06\xef\x53\xaf\xfc\x96\xc2\xa5\x56\x00\xdd\xb5\x1a\x0c\x99\xd4\xb2\x4b\x93\xdb\x78\x29\x98\x06\xc1\x8e\x05\x13\x51\xd4\x19\xda\x8e\xd0\x1d\xa4\xe2\x76\x22\x6d\x3a\x88\x54\x3d\x40\x46\xcc\x19\x15\x9a\x1c\x79\xdb\xd3\xb1\xae\x5a\x1c\x8d\xaa\xe8\xbe\x30\x22\x04\x21\xc7\x11\x7d\xd5\x80\xbd\xa4\xdd\x4b\xda\xbd\xa4\xdd\xa1\x57\x2f\x69\xaf\x7f\x7a\x49\xbb\xc3\xd3\x4b\xda\xbd\xa4\xbd\xe9\xc3\xbd\xa4\xdd\x4b\xda\xdb\x3f\xbe\x9b\xa4\xbd\xab\x9f\x50\x2c\xf7\xba\xcb\x39\xcc\x9c\x45\x0d\x4f\x2a\x1f\x22\xdf\x0a\xff\x75\x58\x79\x3b\x96\xa5\x57\x4b\xdb\xb1\x44\xbe\xa4\x5b\x8c\xb6\x88\xd6\x41\xf8\x5e\xea\xb9\x59\xea\x7e\x59\xbe\x50\x3b\xe0\x46\x74\xa1\xb0\x23\x72\xdc\xf9\xab\x70\x97\x69\x6e\xcc\xaa\x7b\xf2\x94\x9c\xf8\x1b\x97\x53\x0b\x7c\x21\x4d\xfd\x47\x61\xf8\xb0\x6a\x11\xee\x60\xe0\x7a\xb1\x16\x6f\x53\xbb\x96\x08\xb7\xee\xe1\xa6\xb8\xda\x4f\x4b\x42\x98\xaa\xcd\x81\x6b\x97\x40\x0c\xbc\x25\x54\x29\x84\x1d\x55\x0a\x7f\x7d\x8c\x34\x07\x13\xc0\x39\xcc\x43\x61\x09\xe6\x03\x12\x53\x05\xa5\xe8\xbe\x93\x1a\xcc\xb9\xe7\x5c\xf9\xa5\x70\x37\xa2\xf6\x8d\xbf\xf5\xf5\x48\x09\x2b\xe2\xe1\xeb\x23\x72\x05\x78\x18\x0f\xcc\x35\xc0\x87\x66\x99\x7c\xe8\x42\x92\x9e\x2a\x2c\xea\xa1\x73\x58\x54\xe3\xfe\xae\x8f\x8a\xfa\x99\x44\x45\xc1\x8f\x78\x84\x0e\x1e\x1e\x45\x7e\x98\x31\xc0\x22\xc5\x00\x54\x79\x99\x19\x5e\x54\xbe\x52\x1a\x3f\x95\xa1\x94\x39\x71\x9e\x27\x75\xbc\xb4\x5f\xa3\xc9\xac\x89\x9f\x30\x1e\xf8\x56\x69\x38\xb4\xce\xbb\x83\x66\x99\x8b\x29\xf2\x22\x29\xba\xb0\xf0\xe7\xf6\x4c\xb8\xf4\x59\x11\xbd\x36\x03\x44\xe6\xc4\xd2\xc2\x6c\xe1\x32\xd5\x6d\x20\xa2\xa8\x14\xcd\x99\x67\xbd\x53\x3e\x67\xa2\xa2\xa4\x27\xfa\xf4\xd4\xf3\xf0\x83\x52\xf8\x47\xa1\xd0\x7f\x88\x28\xe9\x1f\xdb\xd0\x68\x58\x50\xa0\xd2\x15\xf8\x2a\x1a\xfd\x9c\x2e\x18\x5d\xee\xf9\xbb\xd9\x18\x76\xb8\xdf\x7f\xc2\xbb\xfd\x2f\x27\xb2\xec\x99\x2d\x8c\xcf\xe1\x5b\xff\xe2\xad\x8a\xbd\x73\x7d\xf5\xec\xeb\x5c\xff\xe8\x96\xc3\xe7\xf5\xb1\xff\x02\xac\x85\xcf\xe9\x63\xdf\x5b\x08\x37\x6e\xca\x4b\x73\x7d\xaf\x3f\x3b\x59\x04\x7b\x6b\xe0\xce\x5c\xb8\x23\xc3\xd9\xd7\x0a\xd8\x11\x23\x76\xbc\x67\xef\xef\xd8\x9f\xe6\x8e\xbd\x97\x78\x5b\x3e\xbd\xc4\xbb\x16\x28\xbd\xc4\x4b\x7a\x89\x77\xdb\xf2\x7a\x89\x77\x23\x78\x7a\x89\x77\xe3\xa6\xf4\x12\x6f\x2f\xf1\x92\x2f\x4d\xe2\xdd\x25\x4b\x57\x7f\xd7\xbd\xd7\x5d\x77\x57\x6a\xd1\x89\x46\x74\xc4\x83\xce\x77\xdb\xfd\xbd\xf6\x4b\xb9\xd7\x6e\x1d\xf0\x2f\x0c\xdf\x37\xe8\x3f\xde\xab\x75\x91\xff\x74\x2e\x79\x4a\x8a\xd2\xb8\x78\xea\x3e\xfa\xff\x10\xd1\xff\x35\xc8\xf7\x29\x00\x5a\xa5\x00\x58\x07\xb3\x3e\x0f\x40\x9f\x07\xe0\xc0\x97\xd0\x7d\x1e\x80\x3e\x0f\x40\x9f\x07\xc0\x3f\x7d\x74\x12\xe9\xa3\x93\x5a\x3d\x7d\x74\xd2\xfa\xa7\x8f\x4e\x7a\xb1\xd6\x57\xd2\x47\x27\xbd\x6c\x4b\x2c\xe9\xa3\x93\x7a\xeb\x6c\xcb\x8d\xfa\x02\xa3\x93\xfa\x3c\x00\x2f\xd5\x47\x81\xf4\x92\x76\x2f\x69\xf7\x92\x76\x2f\x69\x6f\x7e\x7a\x49\xbb\xc3\xd3\x4b\xda\xbd\xa4\xbd\xe9\xc3\xbd\xa4\xdd\x4b\xda\xdb\x3f\xde\xe7\x01\xf8\x82\x7c\x23\x48\x9f\x07\xa0\xf7\x97\xe8\xf3\x00\xfc\x7c\xf3\x00\xd4\xee\xee\x9f\x2f\x19\x40\xf7\x69\xf4\x19\x01\xfa\x8c\x00\x7d\x46\x80\x3e\x23\x80\x7f\xfa\x8c\x00\xf8\xbc\x24\x5b\x63\x1f\x1f\xb5\x16\x28\x7d\x7c\x14\xe9\xe3\xa3\xb6\x2d\xef\x0b\xb0\x1b\xf6\xf1\x51\x2f\xd0\x56\xd8\xc7\x47\xf5\x76\xc1\xe6\xe6\x7c\x21\xf1\x51\x7d\x46\x80\x97\x78\xdb\xde\x4b\xbc\x2d\x9f\x5e\xe2\x5d\x0b\x94\x5e\xe2\x25\xbd\xc4\xbb\x6d\x79\xbd\xc4\xbb\x11\x3c\xbd\xc4\xbb\x71\x53\x7a\x89\xb7\x97\x78\xc9\x97\x26\xf1\xf6\x19\x01\xfa\x8c\x00\x7d\x46\x80\x2f\xf1\x86\x7b\xeb\x4e\x33\x31\x5f\xb7\xa7\xb5\x5d\xbc\x12\xf3\xba\x9e\xc2\xc4\x9c\x2b\x29\x80\x02\xcf\xa9\xe2\x74\x9c\xc1\x49\x05\x89\xc7\xc1\xdf\xd1\x4f\xa6\x46\xe4\x82\x0a\x77\xd1\x8a\x37\x99\x6b\xe7\xbf\x1d\xf1\xb7\xa0\x7a\x73\xda\xdf\xd3\xba\xa8\x26\x56\x4e\x9d\xb8\x06\x76\xea\x94\x5c\x84\x89\xaf\xfd\x4c\x2b\x02\xde\x46\x3f\x18\x02\x72\xae\x6d\xd0\x4e\x8a\xb7\x43\x6c\x3e\x9b\x35\xb0\x7c\xa0\x79\x15\xe2\xbf\x02\x1a\x23\xf2\xde\x49\x48\x94\x5c\xfc\xef\xf5\xe5\xd5\x87\xbb\xeb\xb7\xd7\x57\x1f\x37\x23\x5d\x4b\xb2\x02\x07\xa9\xc3\x64\x8f\xbf\xf7\x7b\x04\x61\xde\x4c\x58\x0a\xfc\xcb\x93\xef\xcf\x3f\xfe\xef\x87\xf3\xf7\x57\xa7\xc0\x7e\xd9\xe7\x82\x8a\x94\xa5\xa4\xd4\x9e\x24\x14\x8a\xcd\xb9\x2c\x75\xb6\x08\xc7\x7b\x35\xd2\x36\xb1\xd5\x29\x9a\x0b\xa2\x99\x9a\xf3\x64\x35\x88\x50\x8a\xa5\x15\x02\x25\x01\xc3\x15\xd3\x32\x9b\xb3\x14\x65\x8d\x30\x69\xff\x1d\x2e\x8a\xd2\x78\x89\x18\x5c\x10\xec\xa9\x10\xc9\x8c\x8a\x29\x4b\x47\xe4\x52\x96\x76\xbc\x5f\xfe\x12\x16\xa6\x58\x5a\x26\xc8\xeb\xa8\x17\x98\x7e\x39\xf0\x94\xc4\xd2\x02\x8d\x69\x14\x74\x42\x0b\xbf\xf4\x18\x3a\x7a\x21\x0c\xfd\xfc\x06\xef\xe0\x8f\x7e\x19\xfd\x74\xe4\x53\x50\x48\xfb\x09\xa4\x47\x38\xab\x0c\xb2\x1f\x64\xe4\x28\x6e\x3d\x22\x57\xf6\x1b\x2c\x8d\xf7\x01\x5d\x28\xd8\x9c\x29\x90\xa7\xdd\x2e\x0c\x88\x62\x53\xaa\xd2\x8c\x69\x70\x1e\x78\x98\x31\x48\xe7\x81\x12\x96\x03\x18\x0b\xd2\xba\x90\x66\x44\x2e\xd9\x84\x96\x99\x01\x1a\x72\x74\x34\x3a\x3e\x18\xaa\xbd\x55\x72\x4b\xf0\x7b\x0d\xdd\x6e\x31\xa9\xc4\x44\xaa\xb5\xc7\xe3\xd8\x99\x26\x6a\x64\x4d\x5b\x4e\xe2\x34\x3d\x4f\xab\x51\xbf\x68\xb1\x92\x16\x82\x60\x7b\x75\x3e\x91\x62\xc2\xa7\xef\x69\xf1\x2d\x5b\x7c\x64\x93\x8e\xde\x10\xc8\x44\x9d\x4e\x0b\x0c\xcc\x92\x43\x1c\x70\x3b\xd3\x79\xc4\xbb\xfc\x36\x46\x93\x6e\x36\x8f\xd6\x96\x8e\xa5\x94\x16\xc8\xf4\x1d\xfb\x3e\x60\x72\x9e\xea\xd9\x4e\xd1\x57\x4e\xee\x38\x26\xed\xee\x9c\x9a\x11\x79\x2f\xc1\x25\x67\x22\xdf\x90\x99\x31\x85\x7e\x73\x76\x76\x5f\x8e\x99\x12\xcc\x30\x3d\xe2\xf2\x2c\x95\x89\x3e\x4b\xa4\x48\x58\x61\xf4\x99\x9c\x5b\xca\xc7\x1e\xce\x1e\xa4\xba\xe7\x62\x3a\xb4\x92\xce\x10\x77\x55\x9f\x81\x30\x75\xf6\x0b\x94\xd8\xef\xbe\xbb\xfc\xee\x0d\x39\x4f\x53\x97\xb1\xa7\xd4\x6c\x52\x66\x2e\x7b\xc7\x88\xd0\x82\x7f\xcf\x94\x55\xca\x06\xe4\x9e\x8b\x74\x40\x4a\x9e\xfe\xe7\xe6\xc3\xbd\x23\xc4\x64\x81\xba\xd1\x0e\x50\xbb\x05\x41\x71\x51\xa3\x53\x01\xe9\x2d\x85\xe2\x46\xc3\x9e\x7b\xc3\x81\x63\x28\x1d\x96\x31\x96\x32\x63\x54\x6c\xe9\x01\x60\xeb\x7e\x66\x8f\xab\x43\x8b\x5a\x8e\x43\x80\x42\xa6\x6f\x88\x2e\x8b\x42\x2a\xa3\x49\xce\x0c\x4d\xa9\xa1\x23\xbb\x73\x83\xfa\x9f\x20\x1c\x0f\xc8\x5f\xc3\x4b\x90\x70\xf5\x9f\x8f\x8f\xff\xf0\xed\xd5\x7f\xff\xf1\xf8\xf8\x2f\x7f\x8d\x7f\x05\xb2\x87\xa6\xae\x7a\x13\x2b\x72\x8f\xac\xb8\xfb\x01\xbe\x01\x7f\x3a\x36\x7a\x9e\x24\xb2\x14\xc6\xfd\x60\xa8\x29\xf5\x68\x26\xb5\xb9\xbe\x09\x7f\x16\x32\x6d\xfe\xa5\xb7\x70\x02\xf2\xb8\x44\x07\xc0\x79\x43\xcd\xec\xc0\xa4\xa7\x3a\x17\x3b\xa0\xab\xeb\x19\x67\x48\xca\x29\xfc\xf3\xad\x9f\xae\xe5\x40\x0f\x8a\x1b\xc3\x04\xc8\x1d\xe0\x77\x27\x27\x03\x8b\xb9\x15\x9b\x9d\xbf\xee\xa4\x8e\xb6\x3e\x8a\x01\x6a\x3b\x2c\x0e\x66\xef\x56\x86\xc8\x1c\x08\xed\xb2\x5e\x77\x7e\x73\x4d\xe6\x08\x8d\x83\x2f\xc4\x7b\x61\xbd\xdd\xfb\x4c\x86\x4c\x55\x6e\x59\x41\xd2\x7c\x83\x96\xa5\xe0\xef\x45\x32\x9e\x73\x67\x00\x76\x59\xad\x34\x39\xc1\x97\xa3\xa4\x28\x07\xae\xc1\x28\x67\xb9\x54\x8b\xf0\x27\x2b\x66\x2c\xb7\x12\xdb\x50\x1b\xa9\xe8\x94\x0d\x42\x77\xec\x16\xfe\xc2\x8e\xb5\x0f\x2c\xf7\x46\x91\x3a\x29\x95\x65\x1e\xd9\xc2\x53\x10\x96\x3e\xef\x59\xf4\x60\x3a\xf0\x51\x0c\xbb\xf1\x61\x47\x96\x1b\xb4\x45\x64\xda\x61\x55\x20\x43\xce\x65\x56\xe6\x4c\x0f\x02\x7b\x42\x69\x5d\xcc\xad\x34\xa9\x1f\x85\x11\xa6\x7c\xce\xf5\x4e\xf7\xd3\xb7\xc1\x52\x07\x26\xb2\xd2\x58\x4d\x05\x9d\xc1\xa3\x8c\x70\x52\x83\x0e\x10\x7c\x14\x6b\x24\xe5\xf5\x51\xbb\xdb\x57\x6a\x0c\x53\xe2\x0d\xf9\xff\x4e\xfe\xe7\xdf\xfe\x39\x3c\xfd\xcf\x93\x93\x3f\xbf\x1a\xfe\x3f\x7f\xf9\xb7\x93\xff\x19\xc1\x3f\x7e\x75\xfa\x9f\xa7\xff\xf4\x7f\xfc\xdb\xe9\xe9\xc9\xc9\x9f\xbf\x7d\xff\xcd\xdd\xcd\xd5\x5f\xf8\xe9\x3f\xff\x2c\xca\xfc\x1e\xff\xfa\xe7\xc9\x9f\xd9\xd5\x5f\x5a\x0e\x72\x7a\xfa\x9f\xbf\x6c\x35\x3d\x2a\x16\xdf\xb5\x38\xf0\xf8\x0c\x77\xf0\xb0\xaf\x7a\x75\x30\xd0\x7f\x1e\x56\x42\xdb\x90\x0b\x33\x94\x6a\x88\xdd\xdf\x10\xa3\xca\xed\x07\xa3\x22\x6a\xbb\xe0\xb9\x4f\x07\xf6\xa6\x22\x68\x81\x34\x1f\x1c\x91\x35\x4b\x14\x33\x87\xd2\x60\x70\x34\xcf\x3f\x1a\x26\xd9\x5e\xa9\xa9\x94\x9a\x60\x97\x04\x78\x55\x9c\x77\xa2\x64\x3e\x22\x91\x59\x68\x0e\x37\x99\xae\xdd\x3d\xdb\xa2\xe5\xfa\xa7\x57\x82\xbe\x2c\x25\xe8\x16\xf7\xf7\xd1\x35\x20\x26\xe6\x9b\xcc\x34\x4d\x9b\xee\x5b\x08\x65\x89\xcd\xd1\x5e\x80\x32\x92\x14\xb2\x28\x33\x6a\xd6\x98\xed\x56\xd8\xa6\x1d\xee\x57\xb7\x00\x76\xa3\xc1\x0e\xec\xa8\x5c\xbe\xda\x18\x4a\xce\xb3\x8c\x70\x81\x27\x01\x06\xf0\xd6\x3c\xc5\x50\x5e\x22\x14\x0d\xce\x73\x3b\x85\x07\x17\x70\x13\x19\x1a\xb9\xb6\xba\x8e\x32\x60\xf1\x87\x80\x1c\xa4\x59\xce\x34\xc6\x45\x15\x96\x13\xb8\x6d\xb8\xa5\x5c\x99\x7f\x31\xa3\xda\xf8\x69\xc3\x6c\x0c\xbd\x07\x53\x68\xc2\x52\x26\x12\x06\x2e\x08\x25\xab\xd6\x3a\xb6\xc2\x20\x98\xf7\x61\x0c\x4a\xd2\xb2\xc8\x78\x62\xe1\x67\x67\xb2\x7a\x8c\xeb\x3c\x2f\x0d\x18\x8a\x9f\xca\x8a\x6f\x77\xfc\xd6\xa7\x7b\x0d\xc6\x7c\x20\x55\x41\xb4\x0e\xde\x16\x41\x75\xd7\xfb\x99\xef\xdb\x11\xde\x60\x6e\xdb\xca\xa9\x96\x28\x6e\x65\x63\xa8\x53\xda\xa7\xb6\x18\xb6\xa3\xb3\x3f\x49\x1a\xdb\x81\xbe\xb6\xa7\xad\x1d\x8c\x4b\x5d\xe9\x69\x5b\x6b\x52\xa1\xd8\x84\x7f\xee\x80\x8f\xe7\xa2\x52\x51\x78\xca\x84\xb1\x8a\x00\x64\xa6\x2e\x14\x2b\x98\x48\x43\xb8\x1f\x38\x78\x89\xfa\x3a\x1e\xf5\xc6\x08\xa5\x8c\xee\xc7\xeb\x76\x95\x14\xd3\x9f\xad\x9f\xf8\xd9\x72\xbb\x7e\xf8\x83\x25\x64\xba\xd5\xf9\xbb\xb1\x8f\x51\x8f\x86\xa7\xab\x4b\xff\xed\x26\x69\xb5\xb7\x70\xe5\x54\xc8\x14\x73\x5c\x9b\xca\x09\x61\x44\x6e\x57\xf4\x04\x5f\x03\xd7\xe2\xf8\x58\xa3\x5b\x82\x6e\x0e\xd4\x88\x6e\x46\xcf\x04\x1c\xb4\x23\x4a\x21\xab\x2b\x15\x58\x7e\xcf\xa8\xd6\x7c\x2a\x86\x85\x4c\x21\x2f\xf7\xd9\x3a\x84\x68\x71\xa8\xba\x79\x36\x6d\xc5\xab\x60\x9c\x68\xb7\x4d\x1f\x83\xfd\x2d\x92\x2d\x7c\x46\x78\x15\xfd\xe8\xec\x3a\xde\x8f\x3e\x92\x21\x2b\x89\x68\x3f\x98\xe6\x54\xd0\x29\x1b\xba\x8f\x0f\xc3\xc7\x87\xe1\x5b\xfb\x80\xb9\x0d\xd5\x42\x93\x62\xeb\xb2\x10\xc7\xef\xd0\x64\x99\x86\xf2\x10\xe8\xbf\xf7\x99\xe7\x65\x4e\x68\x2e\x4b\x74\xd1\x5b\x06\xa7\x77\x64\x39\x08\xc0\x56\x00\x4a\xaf\x85\x54\x4b\x68\x91\x9d\x5c\xee\x5e\xa8\x65\xab\x95\x45\xab\x9b\x25\xab\x83\x05\x6b\x67\xcb\x95\x37\x52\xb7\xc7\xc7\x8f\xde\x6e\xde\xc0\x48\x2e\xb6\x62\xa4\x0a\xf9\xee\xaf\x27\x24\x8c\xc3\x35\x91\x39\x37\xc6\x19\x74\x69\x75\xec\x07\x84\x9b\x9a\xf5\xd3\x9d\x05\xa8\xf7\x80\x25\x32\xd8\x67\xab\x4d\x71\xb0\xa2\xfb\x5b\x8b\x01\x72\xd9\x07\x8e\xd9\x21\xa8\x20\x3c\x2f\xd0\x99\x15\x70\x7a\xe8\x75\x33\xe7\x64\xd0\x9f\x8f\xfe\x7c\xac\xea\xa4\xbb\xc8\x22\xb1\x18\x52\x79\x30\x06\x71\xc4\x62\xb6\x2f\x3c\x03\x1e\x9a\x88\x43\xf6\x2c\x80\x13\x3d\x17\x53\xf2\x91\x81\x65\xe0\x96\x19\xed\x7c\x22\xa1\x07\x55\x6c\x39\xc4\xcc\x5b\x42\x82\xab\x2d\x9d\x4c\xea\x2d\x52\x56\x64\x72\x91\x83\x64\x7b\x6d\x62\x79\x26\x88\x2e\x2c\x2f\x32\x6a\x58\x10\x6c\x36\x5b\x1b\xf6\xe6\x7c\x5d\xe2\xbb\x9e\x37\xa2\xab\x9d\x77\x70\x0b\x9f\xe0\x97\x1f\xa7\xd5\x5a\x23\x6b\x6b\x77\x6f\x63\x73\x6f\x19\x6f\xd5\x5e\x09\x6c\x65\x94\x7f\xec\x28\xaa\x4e\xea\x58\xdb\x48\xa9\x97\x1f\x1b\xd5\x61\xd9\x6d\xe3\x9f\xfa\x88\xa7\x4d\xa0\x6e\x17\xb5\xd0\x3a\x62\xa1\xd5\xfe\xb5\x8c\x5c\xea\x63\x95\x3a\xf0\x97\x47\x10\xfe\xb6\xee\xa5\x91\x19\x43\xc9\xb5\x9d\xee\x7e\x57\xb5\x0f\xf5\xcf\xf0\x7a\x37\x1a\xe9\x69\x6e\x29\xee\xbc\xd8\x62\xcf\x56\x35\x2f\x40\x2d\x63\x28\x14\x3b\x33\xd2\xcf\xcb\x6e\x9c\x58\x10\xbb\x67\xc6\x55\xbe\x8b\x4a\xc1\x19\x05\x97\x3e\x7f\x08\xd8\x36\x60\x20\x3f\xfd\x31\xf2\x6f\x0f\xf1\x2f\x01\x43\xfe\xe0\xff\xf5\xc7\x3d\xe3\x16\xda\x31\x36\x9c\x52\x07\x01\xe3\x0a\x3a\x10\x2e\x52\xb8\x60\x72\x4b\x05\x08\xe0\x58\x16\x3e\xb0\x2c\x1f\xff\x82\x81\x54\xce\xcc\x05\x37\x51\x55\x63\xed\xae\xcc\x22\xbd\xca\x99\x14\xaa\x93\xc1\xc8\x07\xe9\x92\x12\xb2\x01\xb9\x01\x5b\x6a\xf5\x06\x4e\xd2\x07\x89\xe9\x09\xd7\xde\x65\xc5\x70\xdb\xca\x45\xb6\x32\xfa\x1a\x40\xbe\xad\x98\x3c\xae\xac\xc6\xe4\x2b\x0c\xae\x45\xc2\x6d\x82\xcc\x3d\x5b\x54\xcc\xc6\x89\x10\x40\xf2\x07\x15\x96\x78\x56\x80\xbc\xe3\x3f\xbc\x29\x2b\x1f\x73\x81\x1f\xc3\xa1\xfd\x56\xc0\xe8\x1e\xa0\x56\xb2\xcb\x32\xfc\xcc\x21\xc0\xd5\x4e\xce\xa8\xc1\xec\xbb\x0e\x32\x46\xa0\x92\xab\xa5\x8b\x48\xa4\xb8\xfa\xb1\xa4\x59\x3d\x08\xc1\xbd\x72\x8d\x96\xa8\xfa\x03\xcf\xd2\x84\x2a\xe7\xe5\x05\x67\x94\x68\x89\xbb\x87\x59\xf1\x12\x2a\xc2\x69\xaf\xf6\x08\xeb\x20\x92\x82\x2a\xc3\x93\x32\xa3\x8a\xd8\xb3\x30\x95\xaa\x55\xa0\xc0\x56\x88\x56\x48\x73\xcb\x12\x29\xd2\x2e\x0a\xc0\x5d\xb3\x6f\xf3\xae\xb5\x60\x8a\xbb\x74\x7f\x3c\x67\x4d\x24\x3d\xa9\xdb\xb4\xe5\xc4\x9f\xea\x70\xc4\x6a\x96\x8f\x2a\x26\x93\x6b\xc2\x31\x5f\xe8\x69\x44\x1e\xc3\xa9\x18\x91\xaf\x17\xde\xcc\x02\x26\x17\x17\x5d\xa1\x99\xf1\x81\x30\x1e\x65\x1d\xb0\xab\x03\x35\x91\x0a\x82\x53\x4e\x52\x89\x11\x19\x73\x9e\x98\xd3\x11\xf9\x7f\x99\x92\x18\xc1\xc9\xa6\x98\xbd\xd1\xa1\x78\x50\x5c\xa1\x70\x29\xdc\xe0\xbf\x22\x27\x98\x49\x93\xe7\x39\x4b\x39\x35\x2c\x5b\x9c\xa2\x1e\xeb\x73\x71\xb6\xd9\xba\x36\x46\x83\x28\xf1\xea\x6f\x7f\xb3\xa1\x65\xd7\x18\xaa\xef\x7d\x54\x4a\x05\x19\xf4\x21\x68\x6c\x61\xe0\x41\x72\x83\xb8\x19\xfb\x20\x54\x41\x9d\x9e\xcc\x84\x0d\xfe\x9b\xc5\x03\x4a\x14\x9b\x02\x96\x23\xe6\xee\x89\xe3\xe8\x4d\xf9\x5e\x96\x62\xbd\x49\xb0\xb6\xf0\x77\x4e\x09\xff\x3e\xea\xb8\x36\x4a\xf1\x49\xc4\x84\x68\x26\x91\x89\x92\x12\xb0\x4b\x02\x3b\xb7\xe4\x01\x5b\x55\x9e\x28\x5b\x27\x79\xd0\x88\x44\x98\xcb\x16\xaf\xf7\x83\xc4\x2d\x86\x0f\x75\xc0\x65\x70\x10\x77\x80\x69\xc4\xed\x19\x47\x0e\x00\x3f\x11\x82\x15\x82\xc2\xb7\x58\xea\xbd\xd8\x30\xd6\x18\xba\x92\xe3\x37\xc7\x07\x21\xbe\xb8\x1c\x25\x0b\x3a\xa5\xdb\xf3\x1d\xd7\x95\x91\x46\x57\x92\x32\xc3\x54\x0e\x89\x69\x67\xf2\x01\x7f\x47\xb6\x55\xb8\x56\xcc\xe5\xf4\xb5\xab\x9d\x49\x0d\x5c\xa9\x1e\xc4\x08\xe7\x17\x2e\x46\x1f\xe8\x82\x50\x25\x4b\x91\x3a\xa9\x29\x10\xd0\xf7\x8d\x0f\x7f\x90\x02\x28\x45\xa9\x2d\xac\xee\x6a\x54\x7a\xcc\x0c\xb5\xc7\xe6\xf5\xe8\xf5\x96\xdc\xd3\x2d\x01\xd6\x31\x6e\x15\x66\xd3\xb0\x14\xfa\xbb\x72\x7f\x66\x0e\x32\x2f\xc5\x68\xfa\x9d\xc8\xba\xc8\x72\xef\x11\xbd\xa0\xeb\x10\x94\x30\x3e\x01\xdb\xed\x00\x5f\x3d\x28\x6e\x58\x44\x1e\x4f\x26\x34\xd3\x50\x70\xbb\x14\x41\x84\x3d\xad\x8b\x20\xd0\xa4\xcd\x82\xb6\xfb\x83\xe8\x72\xbc\xe7\x39\x73\x07\x0a\x50\xae\x3a\x66\x01\xe1\x8e\xf5\x86\x23\x57\x0f\xee\x24\x27\xd8\xd2\x4a\x6c\x52\x9a\x8d\xe5\xdd\xdb\x3b\x89\xe0\x02\xad\x66\xdd\x45\x25\xf1\x71\xc3\xc5\x01\x57\xfb\x35\x9b\xd1\x39\xd3\x44\xf3\x9c\x67\x54\x65\x10\x2b\x78\x8b\xf3\x83\x62\xec\x2b\x23\xd0\xbb\x45\x37\xc7\x33\x89\x86\xdb\x0a\x6a\x3f\x0f\x0b\x27\xa0\x11\x7e\x5e\x98\x04\xdc\x67\x0e\xff\x9c\x64\xa5\xe6\xf3\x7d\x4f\x93\x8b\x7e\xd8\x81\x55\x37\xb9\x74\x21\xd3\xdb\x82\x25\x4f\xc9\xa3\xeb\x1a\x86\x25\x55\xa9\xdf\x74\xe0\xc9\xa8\xec\x53\x2c\xac\x3f\x66\x84\x26\x09\xd3\xda\xfb\x54\x2e\x62\x3f\xcf\xb0\x86\x2f\x25\xa1\x00\x7d\xd0\x57\x19\xd5\x86\x27\x5f\x67\x32\xb9\xbf\x35\x52\x75\x8a\xd9\x5f\xd5\xbf\x91\x86\xe1\xfc\x87\x5b\x72\xc9\xf5\x7d\x14\x4d\xe0\x2e\x4d\x63\x73\x09\x25\xf7\xe5\x98\x65\xcc\x1c\x1f\x6b\xe4\x72\x39\x4d\x66\x5c\x30\xcf\xe0\x44\x08\x49\x71\x0a\x9f\x85\x72\xd7\x3b\x53\x17\xf8\x74\xe6\xf0\xf5\x17\xf4\x41\x33\x9c\xfe\xd8\x4e\xdf\xfe\xcc\xda\x44\xa4\x1f\xf4\x9e\x02\x27\x73\x7d\x79\xa0\x3b\x88\x89\xbe\xb3\x73\xec\x66\xdc\x3e\xc6\x5e\x5e\x75\x98\xf0\x8c\xb9\xea\x03\x76\xc1\xde\x47\xcd\x9d\x0a\xd8\xbf\x85\x2c\xc9\x03\x45\x1d\x19\x28\xe2\x88\xdc\xf1\xe2\x0d\xb9\x12\xba\x54\xac\xb2\x6e\x34\x87\xe2\xba\x8a\x33\xf3\xca\x15\xec\x37\x2a\x20\x96\xee\x39\x5d\x8b\x5c\x7d\xa6\x79\x91\x31\xfd\x86\x1c\xb1\xcf\xe6\x37\x47\x03\x72\xf4\x79\xa2\xed\xff\x84\x99\xe8\xa3\x11\xb9\xce\xc3\xad\x3b\x17\x13\xa6\x14\xf3\x8e\x50\xd8\xc1\xb2\xe6\x88\xeb\x3e\x0a\xba\x38\xa7\x3a\x2b\xbb\xa5\x92\x3c\x60\x3e\x0a\x4b\xf0\x99\x52\x52\x05\x3f\xf4\x08\x0c\xc0\x6b\x12\x99\x17\x4a\xe6\x3c\x32\xf3\x01\xba\x1f\xd4\xdb\x0e\x8c\x0f\x6d\x0a\x72\x34\xb1\x21\x74\xf4\x08\x11\xbd\x10\x6d\x50\xe1\x7a\xe2\x9d\x29\x50\x8b\x74\x6a\x3d\x0c\xe7\x1a\xd9\xcd\x77\xa3\x58\x42\x16\x6f\xf7\xdb\x10\x50\x47\xce\x52\x36\x3f\xd3\x29\x7d\x3d\x80\xcf\x68\xe7\x08\x58\x9f\x13\xd5\xe4\xe8\xf5\xd1\x88\xdc\x7a\x46\x3c\x88\xe7\x58\xb5\x9b\x48\x15\x06\x04\x3b\xfb\xab\x23\x72\x22\x15\x8c\x9c\x50\x41\x32\x46\xe7\xce\xb6\x8c\xc7\x6d\x81\xea\xee\x69\xeb\x80\xc8\xb6\xb1\x61\xed\x2b\xaf\xb4\x15\x52\x97\x37\xd1\xf7\xf3\x26\x00\x55\xba\x58\x81\x89\x54\x2e\x0f\x48\x68\xa2\x99\x81\xa3\xc7\x45\x4d\x85\x7e\x06\x02\x4b\x3a\x86\xd2\x7b\xea\xd9\x15\x3a\xbe\x1f\xe8\x40\x82\xff\x58\x32\x72\x7d\x19\x02\xea\x99\xd2\x5c\x1b\x7b\x8c\xd3\x1a\xeb\xe2\xc8\xcf\x4e\xce\x73\xfa\x77\x29\xc8\xd5\xd7\xb7\x6e\x02\xa7\xcf\x0a\xaa\xad\xd4\x80\xfe\xbd\x54\xcc\x72\xe1\x0e\xcc\x3d\xf4\x69\x32\x74\xfb\x9e\x5c\x52\x43\x91\xaf\x3b\x4f\x2b\x51\x91\x72\xcb\xb2\xc7\x5c\xa4\xee\xa7\x88\x61\x3f\x35\x6f\xb5\xbb\xf7\x61\x93\x98\x14\x37\xfc\xf4\xf1\xfa\x40\x3c\x38\x01\x62\x3e\x7d\x2f\xd3\xce\x8c\x38\xea\xea\x89\xef\x9f\x2c\x4c\x2f\xf0\x3d\xc9\xed\x98\xc4\x6a\xef\x03\xf2\x91\xd1\x94\xd8\xf3\xeb\xfe\xf9\x83\xd5\x3d\x5b\xd3\xaa\x56\x2c\xc4\x03\xb0\xe3\x32\x7c\x37\xbf\x84\xd8\xd3\x3d\xb5\x98\x03\xc7\xca\xf1\x92\x71\x26\xc7\xc4\x1d\x87\x43\xcf\xfd\xd3\xc7\xeb\x1d\xa6\xfe\xe9\xe3\xb5\x9f\xb9\xfd\xa7\x9c\x3c\xdd\xa4\x77\x12\xdf\x2a\xe9\xed\x6d\x43\xdc\xaa\x58\x72\x15\xb8\xd1\x14\xc9\xda\xcb\x63\xa3\x43\x49\x62\x87\x84\xd8\x3d\x17\x2d\xa2\x70\xeb\xa7\xcc\xf6\xb1\x0a\x05\xfa\xaa\x45\xf7\x88\xb7\x33\x0a\xa1\xcf\x21\x20\x0f\xf6\xd9\x6e\xbc\xb6\x5c\xc1\xef\xb8\x55\x02\x81\xb6\x91\x4b\x86\xb7\x9c\xe9\x1b\xef\x3b\x10\x7a\xac\xee\xf0\x1e\x3c\x35\x53\x47\x5f\x09\x3a\x6e\xa6\x11\x82\x9d\xa0\x55\x49\x84\x9f\xe8\x9c\xf2\x8c\x8e\x79\xc6\x21\x95\xba\xd5\xee\x63\x6f\x54\x0d\x53\x3e\xe8\xa9\xdf\x51\xe4\x08\xe2\xc4\x92\x71\x8b\x9c\xd8\xdf\xce\xc0\x38\x76\x3a\x02\x6a\x05\x0d\x21\x47\x63\x43\x28\xf9\xb8\x4d\x28\x39\x98\xfc\x00\x3b\x60\x4f\x4c\x57\xae\x68\xfb\xac\xe4\x8a\xf0\xc3\xad\xcb\x27\xf7\x92\x19\x23\xc6\x5a\xb5\x62\x8d\x80\x5f\x5b\x5b\xb6\x67\x8e\xfb\x22\x57\xfa\x65\x20\x17\x09\x11\x6d\x3b\xf0\xcf\xaa\xa3\xe7\x43\xa0\x24\x81\xc7\x99\x8b\x76\xab\xb9\x66\x22\xf6\xdd\x3a\x5a\xe3\x52\x30\x21\xd7\xb5\x38\xd7\xa6\x2e\x5a\x97\xa4\x0d\x1e\x23\xba\xae\xca\xf7\xf3\x8b\x42\x12\x08\xaf\x49\x0b\x5c\x6c\x3d\xc9\x84\x15\xb3\x49\x97\x2b\x71\xdb\xe1\xed\x6d\xdd\x12\x78\xc1\x8a\x19\x79\x7b\xbb\xe2\x18\x03\xec\x61\xd6\x1a\xed\x83\xc7\x9a\x64\x7c\xc2\x0c\xdf\xb2\x84\x47\x38\xc8\xb9\x14\xdc\x48\xb5\x3e\x04\x9a\x74\x3a\x9c\x7e\xb8\xae\x0c\xd5\xf7\xb3\x3b\x5b\x25\x10\x79\x1f\xbd\xa5\x24\x91\x59\xc6\x12\xe3\x52\x5a\x01\x78\x43\xb7\x15\xca\x13\x73\xf6\x80\xd1\xfd\xef\x41\x7d\x72\x8a\xd2\x19\x6e\xee\xd9\xc7\xab\xf3\xcb\xf7\x57\xa3\x3c\xfd\xc5\x4c\x3e\x0c\x8d\x1c\x96\x9a\x0d\x79\x8b\x0c\x25\xcf\xe7\xbd\x88\x4f\xd1\x2a\x61\x56\xd3\x20\x83\xb9\xbe\xbe\xf3\xf1\x93\xe4\x93\x46\xaf\x05\xb0\x1d\xf9\x3b\x29\x29\xcd\x80\x28\xea\x62\x24\xa9\x33\x3d\x95\x59\x86\xd0\x36\x8a\xb1\x41\x6c\x8b\xd9\x18\x1a\xd2\x79\x61\x7b\x1b\x2a\x6a\x0b\x7c\x5c\x19\xe2\xe9\x11\xae\x0b\xc7\xd8\x2e\x93\x2c\x43\xb1\xea\x59\x87\xe3\x6d\xed\x3d\x1a\xce\xcc\xcc\x42\xf5\x9e\x2d\x08\x38\x02\x4f\xa4\xb2\xf8\xa4\xea\xb8\xc1\x4c\x02\x4b\x3f\x2b\x35\x53\x23\xc7\x76\x9e\x1c\x6c\x1d\xb2\x08\xed\x90\xbc\x2d\x74\x5c\x05\x33\xf7\xba\xca\xec\xeb\xe4\x35\x5a\x9a\x19\x13\xc6\x8a\xfd\x96\x96\x39\xc8\xac\x04\xa2\xf3\xc3\x7e\x72\xa8\xb5\x4c\x62\xd4\x2d\xe5\x50\x9f\xa6\xa7\x0b\x4e\xda\x53\xd3\x15\x1d\x6d\x1f\x08\x44\x8c\xc9\x7c\x88\xe5\x52\x34\x95\xe0\xb0\x81\x19\xe8\x6a\x88\x46\xd3\x9c\x8b\x17\x78\x3a\x13\x2e\xd2\x6d\x70\x68\x18\xc0\xa0\x47\x5d\x14\x73\xef\x9c\x41\x3f\xdc\x1b\x52\xaf\x49\x61\xc0\xbb\xbb\x41\xac\xdf\x1f\xb6\x3a\x7c\xf9\x42\xff\x98\x0d\xf1\x2b\xc3\x22\xad\xa0\xd2\x5f\x06\x2e\xdf\xe0\x1d\xd6\xa4\xf4\x04\x57\x7c\x07\xda\x6d\xf2\xc4\xd2\xd0\xe3\xea\xb9\x4f\x02\xa8\x2e\x32\xcf\xbe\xdc\xbb\xa2\x99\x50\x78\x5f\xfb\xe0\x33\xcc\x6c\x06\x67\xd4\xeb\xcb\x50\x90\x9f\x2a\x9a\x33\xc3\x14\xba\xc0\x39\xa7\x3a\xe1\xa2\x13\xbe\x2b\x98\xb8\x35\x34\xb9\x3f\x74\x2a\xd4\x9e\xe3\x3e\x1e\xc7\xdd\xfb\x2a\xd0\x23\x82\xcb\x8b\xb4\x88\x6f\x91\xb9\x70\x5c\xe8\x85\x90\x98\x90\x8e\xac\x8b\x95\x23\xa4\xa3\xaa\x73\xd7\x2a\x3d\x19\x1a\x36\xc0\xd3\x2d\xe4\xd7\x03\x0f\x7e\x84\xc2\x61\xb8\x61\xfb\x33\xe0\x48\xe0\x2e\xf7\x68\x51\xd7\x3a\x75\xc8\xed\x9b\x31\x37\xd5\xb9\xd7\xcc\x90\x82\xa9\x9c\xbb\xb0\x6e\x29\x48\xe2\xc2\x02\x80\xaf\x59\x1e\xe6\x86\x8b\x78\x9e\x20\x32\x31\xd4\xc5\xcc\x90\x31\x33\x0f\x8c\x09\xf2\xea\xd5\xab\x57\x20\x97\xbc\xfa\xdd\xef\x7e\x47\x20\x8f\x44\xca\x12\x9e\x2f\x37\x84\x56\xff\xe7\xf5\xeb\x11\xf9\xef\xf3\xf7\xef\xc0\xab\xac\x30\x9a\x8c\xa5\x99\xb9\x91\x6d\x83\x5a\x67\x3d\x20\xff\xf7\xf6\xbb\x0f\x5e\x9c\xd0\x8d\x5f\x41\x05\x09\xcb\xab\xbb\x08\xbe\xfa\xed\x6f\x7e\x33\x22\x97\x5c\x41\x3c\x31\x87\x08\x88\xe0\x04\x59\x78\xc7\x40\x28\x3c\xd4\x8c\xe0\x77\x1c\xc4\x39\x09\xe7\x7c\x3a\x03\x00\xd8\x03\x21\xc5\x24\xe3\x89\xc1\x9c\x82\x78\xf4\x11\xd0\xae\x2e\x12\x75\xe1\x5e\x4e\x8a\x80\xc9\x0d\x48\xc6\xef\x19\x99\xe8\x6f\x94\x2c\x8b\x2a\xcc\x51\x31\x6d\x65\xd9\x84\x0a\x88\x2a\x81\xc1\xaa\xbd\xd2\xcc\x3c\xab\x13\x46\x4b\x43\x50\x0d\x07\xa1\x4f\x43\x40\x19\x84\xdc\x6a\x43\xc4\x87\x82\xf2\xe0\x38\x08\x77\xea\xb5\xcc\xfe\x41\xf7\x4c\xa3\x5c\x72\x3e\x76\xa5\x50\xf2\x6f\xb8\x55\x5c\xf8\x28\x28\x27\x21\x6b\x27\x93\xb9\xa0\x53\x11\xd9\x5c\x7d\x54\xbe\xe5\x85\x2e\xe2\x3f\x8a\x9f\xba\x9e\xc4\x81\x76\x10\x96\x8e\xe5\xd5\x6a\x89\x2f\x57\x7c\xb9\x4a\xd6\x6e\xb1\x49\xe3\xbe\x96\x62\xa9\xb7\xab\xa3\xe2\xc8\x8f\xab\xae\xe3\x42\xd8\xaa\x31\xd0\x15\xd7\x05\x00\x45\x35\x9b\x6a\xc9\xe8\x6a\x5e\x3e\x9a\x99\xd2\x81\x06\x3c\xaf\xec\xb7\x99\xd6\x2e\x8e\x28\xa7\xea\xde\x2a\x09\x8e\x0a\x8c\xc0\xeb\x59\x87\x18\x26\x0c\x28\x9b\xa3\xb1\x3c\xa7\x8b\x5a\xd4\x80\xfd\xc8\xf1\x68\x74\x8c\xc7\x44\x2a\xcc\xe5\x89\x38\x6f\xdf\x3f\x53\xbc\x74\xdd\x2b\x9d\x16\x58\x76\x0f\xec\x39\xae\x6c\x09\xad\x79\x3b\x53\x07\xa9\x36\x19\x7c\x3b\x96\x2d\xec\x56\x1f\xb7\x7d\x5d\xdc\x21\x2c\xa0\x45\xd3\xae\x35\x70\x3b\xd4\xbe\x5d\x97\xad\xc1\xc1\xd8\x9d\x84\xb6\x15\x21\x3b\xe7\x02\xcf\x5b\xb1\xbe\x15\x53\x3d\xce\x1d\xe7\xfb\xae\x1b\xe7\x73\xf1\x7a\xb5\xe2\x60\x2f\x9f\xd5\x5d\x4f\x30\xd2\xa5\x4e\xba\x1c\x69\x88\x45\x81\x50\x88\xab\x0a\x7b\x79\xd1\x1c\x2d\x46\x9b\x6e\x89\xe7\xbb\x70\x37\x7c\xda\x5d\x4c\xe0\x53\xc3\x35\x7f\x3b\x81\x8b\x76\xa4\xb4\xa8\x15\xf8\xc8\xd0\x6e\x00\x32\xa6\x3f\x3c\x23\xf2\xde\x91\x5a\x44\x32\x3a\xd6\x32\x2b\x0d\x76\xad\x7e\x8c\xe9\x30\x0c\xea\xb3\x2c\x00\xf1\x0d\xcd\x22\xaa\x6c\xaa\x12\x67\xed\x08\x34\x3e\x1d\x0e\x67\x9f\xed\xf3\x11\xb3\x7d\x86\xfc\xb4\xba\x65\xbd\x26\xfd\x68\xe9\x75\x13\xcd\xbb\xe8\x57\x9a\x93\x93\xaa\x4c\x88\xbf\x8e\xbf\x16\x86\xa9\x09\x4d\xd8\x69\xac\x77\x85\x72\x2c\xc1\x45\xc8\xc7\x45\xcc\xa8\x48\x33\x14\xc0\x13\xa6\x00\xf7\xd9\x67\xc3\x94\x05\xc9\xc5\xed\x35\x49\x15\x9f\x33\xa5\xc9\xc9\xd7\xcc\xca\x8b\x8c\x9a\x52\xb1\x56\xd1\x55\x87\xf5\xad\x84\x69\x1c\x4a\xd3\x83\xc1\xba\xba\xea\x41\x27\x4f\x79\x44\x74\xbe\x2a\x30\x21\x54\x11\xa4\x3a\xd6\x65\x47\x16\x95\x80\x40\x03\xcd\x58\xc8\x52\x39\x2b\xba\xcf\xab\x9a\x48\x65\xd5\x25\x1c\x98\x6a\xa2\xd8\xd4\x4a\xb3\xca\x17\x1b\x66\x24\xc9\x4a\xfb\xe2\xa0\xee\x6c\xfb\x38\x00\x56\xa6\xd9\x4d\xbe\x7a\x13\x27\x55\xcb\x39\x4f\x3d\xab\xc4\xda\xc7\xa1\xaa\x61\x41\x75\x14\x6a\x13\x65\xa0\x8f\x00\x8b\x32\x3a\x30\xd4\x10\xc4\x5a\x73\xf6\x8f\x8d\xc2\x12\x72\x5b\xb4\x28\x1f\xd1\x85\x08\xcb\x94\xdd\x94\xe3\x8c\xeb\xd9\xed\x8e\x26\xc4\x55\x43\xa0\xb3\xc2\xd2\xad\xdf\x5a\x4b\xa2\x66\x42\x73\x60\x79\x96\x8c\x5b\xa6\xcb\xad\x1c\x25\x01\x88\xbe\x77\x8c\x90\x12\xa2\x3f\x32\xe6\x32\x18\xd8\x9f\x3e\x54\xf3\x70\x41\x69\x98\xb3\x24\x65\x9f\x44\x51\x7b\x9f\xd0\x2c\xd3\xcd\x80\x5d\x4f\x31\x51\xf6\xf0\x81\x6a\xb8\xa7\xdc\x6e\x77\xa8\x8c\xd2\xc8\x7e\xb9\x76\x61\x9a\xe4\x12\xc3\x78\x04\x91\xc2\x37\x82\xd4\x2b\xbe\x43\x14\xc8\x08\xe1\xca\x80\x32\x07\x2e\x1d\xd9\x9b\x4b\x1f\xcf\x5c\xba\xaf\x1f\x5e\x5c\xef\xbd\x8a\x86\xae\xa5\x25\x0d\xa4\xd4\x93\xdc\x2d\x4e\x1d\x07\xbd\x56\xc0\x6f\x9e\x1b\xa3\xf8\xb8\x34\xdd\xf3\xbd\x35\xba\x03\x9b\xb6\x8a\x08\x9c\xe2\xa1\x5b\x7d\x12\xa1\xa8\xd3\x10\xc2\x59\x58\x3e\xfb\x15\xcf\x01\x76\x83\x2f\x8f\x35\x49\x65\x52\x86\xbc\xb0\x00\xb4\xea\x02\xad\x4d\xf6\x44\xd2\xf5\x5c\x75\x4f\xe9\x15\x7f\x64\x2b\x7a\xa5\xf2\x41\x3c\x50\x95\x9e\xdf\x6c\xf1\xbe\xaf\xb3\xf3\xaa\x57\x2c\x28\xf9\xd7\x50\x05\x90\x8e\x65\x69\xaa\xd4\xa1\x3f\x1d\x7b\xf5\x2a\x35\xdd\x48\x4b\x1a\x5a\xda\xa3\xbb\x2a\xfa\xbd\x89\xbb\x37\x71\xd7\x9e\x5d\x4c\xdc\xd7\x68\xe2\x8e\xf3\xe0\xd6\x8e\xab\x4f\xaf\xc0\xb3\xb6\xbe\xbd\x8f\x69\x25\xbd\xac\x08\x0c\x4a\x53\x4d\x3f\xfe\x86\x00\x87\x47\xa4\xda\xdb\x48\xe8\xf3\x14\x08\x78\xf6\xf3\x5b\x54\x1f\xc9\x4e\xda\xbe\x4e\x31\x3e\xeb\x0a\x09\x6e\xaa\x5b\x0c\x52\x43\x54\x68\x78\xe0\xb2\x40\x0f\x9c\xde\x25\xd2\xaa\x84\x1f\x26\xa1\xee\x50\xa6\x14\x9f\x8e\xc0\x27\x9d\x37\x80\x74\x2c\x22\x8c\x4f\xd7\xdd\x20\x3b\x14\x14\xc6\xe7\x99\xcb\x0a\xe3\xd3\xd9\xf6\x4d\xba\x97\x18\x5e\xb1\xdc\xc7\x2d\x34\xbc\xe3\xd2\x76\x37\xeb\xef\x6a\xce\x1f\x54\xe5\xed\x5e\x3e\x5b\xef\xcd\xf9\x4b\xcf\x13\x9a\xf3\x23\xc2\xed\x89\xc1\x0a\xd3\x7e\x6c\x6e\xf3\xf6\xfd\x31\xf3\x62\xe5\xa8\xca\xbe\x66\x51\xce\x5b\xf6\xa5\xaa\x5f\xab\x1e\x8f\x46\xc7\xc7\xde\xde\xef\xf0\xb3\x34\x93\xe1\xef\x09\x13\x89\x4c\x71\x53\xed\xf8\x4a\x1b\x60\xfa\x95\x9a\x1e\xcf\x25\xf7\xdf\x8a\xaf\x66\x61\xec\x6e\x5b\xd2\xe1\x04\x77\x2f\x1b\xbe\x0a\xd2\x4f\x51\x3c\x3c\x2e\x11\x5e\xaf\x08\x8e\x2d\xf6\x29\x03\x1e\x03\xef\xd1\xf9\x6b\xeb\xc2\xe0\xf8\xec\xc2\x5e\x77\x28\x12\x8e\xcf\x13\x97\x0a\xc7\x67\x27\x8e\xda\xa9\x6c\xf8\x8a\xc5\x3d\x5d\xf1\x70\x7c\x5e\x68\x21\x99\xfa\xd3\xa9\x90\x38\x3e\xbb\x95\x13\xaf\xf7\xed\xb8\xf5\x07\x29\x2d\x8e\x4f\xb7\x02\xe3\xf8\x1c\xba\xcc\x38\x3e\x2d\x21\x01\xc6\xf0\x4b\xde\x29\x14\xc1\xf7\xa9\xbb\x4b\x1a\x96\x17\x52\x51\xb5\x20\xa9\xb3\x35\x2c\x56\x44\x84\x46\x21\xa1\x7b\xa7\x86\x81\x79\xa4\x5c\x1d\x28\x1a\xa1\x43\x34\x28\x4b\x79\xb9\xb6\x5c\xf3\x3a\xb0\x61\xaf\x18\x68\x0f\x90\x0d\xcc\x65\x12\xf3\xd7\x9d\xae\x99\x4f\xac\x48\x93\x7b\x57\x31\xc8\x43\x15\x79\x7f\x14\xe4\x72\x74\xd4\xc8\x03\x0d\xe6\x31\xb8\xfb\x73\x95\x11\x7d\x63\x1c\xbb\x66\xca\xc2\xdb\x10\xe7\x16\x70\xe2\x1a\x9e\x5a\x89\xe4\x3d\xb0\xc1\x27\xda\x25\xd2\x31\xb2\x8d\xff\x9d\x41\xb9\xb1\xce\xbe\xf1\xbe\x63\x48\x07\x2d\x41\x32\x0f\x75\xd1\x32\x99\x44\x77\xcf\x35\x0e\x05\xdb\x70\xe5\x91\xdf\xdb\xee\xed\x66\xd8\x51\x51\xbe\x00\xa3\x4f\xa6\xf1\x5e\x8f\x27\x90\xda\x12\xa4\x78\x00\x66\xd8\x80\xbb\xa8\x4a\x60\xa9\xed\x97\x20\xf3\x7c\xd4\xa6\xfa\xd0\x83\xcf\xb0\x69\xa2\x42\x6e\x75\xdd\xc3\xfe\x72\x1b\x56\x56\xe9\x6d\x10\x02\xe1\x05\x75\x5d\x82\x98\xe8\xbe\xe2\xc4\x25\x39\x81\xbb\xab\xaa\x2c\x5a\x48\xee\xb8\x84\x66\x82\x67\x75\x3c\xf3\xb9\xec\xc2\xc2\x4b\xe1\x1c\x0d\x96\x90\x66\x35\xce\x94\x9a\xa9\xe1\xb4\xe4\xe9\x2e\xd8\xf2\x82\x19\x60\x6b\xb6\xd7\x9d\xd9\x75\x64\x71\x7b\x30\xb6\xe0\x88\xd1\x81\x35\x1c\x55\xde\x1b\x35\xde\x10\xa7\xc5\xab\x7b\x72\x50\xef\x2c\x10\x8e\x9c\xbf\x12\xba\x0b\xaa\xad\xe3\x19\xc9\x22\x71\xc1\xba\xbc\x96\xee\x12\x87\x45\xcc\x03\xc7\xd6\xa1\xfd\x8f\x57\x81\xbd\x3d\x7f\xcc\x26\xb2\xaa\x90\x82\x1a\x91\x73\xc7\x4d\x59\xc6\xa0\x8c\xbc\x2f\x51\x6f\x1b\xc0\x95\x70\x2e\xe7\x16\x99\xff\x47\x90\x4f\x3e\x67\x3f\x9f\xbc\x21\xf4\xb4\x16\x02\xe1\xaa\xce\x08\xc6\x52\xf4\xd1\xcd\xaa\xef\xa8\x52\xe8\x01\x19\x9f\x7a\x7f\x14\x38\x71\xc2\x8a\x85\x99\x97\x78\x51\xaf\x56\xcc\x02\x00\xc2\x8e\x95\xcc\x89\x16\xb4\xd0\x33\x69\x40\x35\xa4\x05\x4d\xb8\x59\x10\xa3\x68\x72\x0f\x25\x8a\x14\x73\x9f\x1b\x90\xe4\xd4\x39\x76\xc5\xe0\xab\xbb\x0d\x9b\x99\x92\xe5\x74\x06\x9e\xb0\xd8\x2a\xc9\xa8\xf6\xab\x5f\xd9\xdf\x69\x3b\x9a\xa4\x0b\x41\x73\x9e\x84\xac\x81\x4a\xce\xb9\xe6\xd2\x59\x7b\xfd\xb8\x37\x21\x33\x1c\x5a\x90\x2f\x32\xca\x73\x72\xa2\x19\x23\x57\x1e\x25\xf0\x17\x57\xc6\x1e\x2d\x1b\xaa\xee\x1c\x20\x43\x4a\x73\xe1\x12\x22\x54\x04\x2e\x5c\x5e\x21\xc3\xb4\x33\x5f\xf9\xd1\xd3\xb0\x5d\xab\xe7\x24\x15\x5c\xdc\xfb\xd4\x9d\x4c\xa4\x32\xba\xb5\x3c\xbf\xb9\xd6\xb1\x36\x82\xb8\xe5\xf2\xde\xc1\x0f\x99\x14\xd3\x38\x8d\x40\x85\x99\x96\x94\x0a\x28\xef\x32\xe7\x69\x49\x33\x24\xa2\x6e\x32\x17\xb7\xd7\xd8\x9d\x4f\x67\x66\xf8\xc0\xc0\x1a\x83\xbc\xa6\x3a\x33\xfe\xa3\x7c\xc9\x5b\x87\x6b\x20\xba\xc6\x59\x13\xd0\xb2\x65\xa7\xf6\x40\x17\x90\xb6\xc6\xb9\x98\xd4\x2e\x4c\x7d\x62\x31\x1c\x62\x15\xc4\x61\x7a\xe7\xa1\x5c\x87\x15\x1b\xc0\x5c\x65\x41\x0c\x98\xba\x3c\x37\x0b\xf8\x28\x0f\x60\x78\xed\x2a\xb3\x51\xbb\x41\x56\xb8\xdb\xac\xcb\x3c\x82\x50\x36\xaf\x36\xf9\xce\x95\x4e\xec\x28\x1c\x1c\xfd\x10\x99\xcd\xa2\x8b\x0e\x7b\x6c\xa8\x48\x87\x34\xb3\x98\x73\xf3\xfd\x85\xf3\x70\xc6\x83\x50\xbb\xc8\xf7\x55\x90\xb8\x08\x69\xb3\xad\xcc\xb0\xf2\x08\x40\x1c\xfc\x98\xa5\x40\x34\xe2\x82\x91\x0f\x56\x43\x76\x9b\x77\xf3\xfd\xc5\x80\xf0\x11\x1b\xf9\xbf\x42\x53\x4f\xb5\x8c\x9c\xa2\x1b\x60\xf0\xf1\x04\xbc\x83\xa9\xc4\xc6\xa8\xb8\xef\x5f\xff\x60\x27\x69\x7f\xfd\xe3\xf0\x0f\x51\xb6\xd1\x3f\xfe\xd5\x12\x41\x65\x1b\xd4\xdf\xc6\xbe\x64\x21\xeb\xfe\x5f\x6f\x5c\x56\x6a\x97\xb3\xfa\xaf\xae\x18\x17\x13\xc6\xca\x8d\x37\x12\x6e\xe9\x79\x8a\xd8\x08\xdf\x56\xec\x6f\xde\xb0\x08\x60\x0a\x46\x9d\x84\x1a\x26\x80\x50\xfb\xa0\x0c\x21\x0d\x76\x77\x75\x67\xed\xfc\x4f\xc0\x24\x80\x41\x65\x03\x62\xa4\x84\xe3\x88\x47\xfe\x5c\x10\xe6\x6b\x75\xe2\x5a\x01\x1c\xd4\x39\xaa\x79\xde\x63\x87\xb5\x10\x0e\x21\xb8\x76\x1e\x30\xb7\x5f\x09\x69\x7e\x15\xb6\xbf\x51\x45\x9c\xce\x25\xf7\x09\xc8\xed\x49\x11\x58\xd1\x31\xa4\xc4\x1e\x2f\x48\xce\xb5\xa1\xf7\x6c\x44\x6e\x2d\x6f\x89\x6f\xc3\x10\x7a\x82\x40\x06\x4b\x96\x92\x52\x18\x9e\xc1\xaf\xd5\x38\x76\xca\x31\xcf\xb9\x9e\x10\x5d\x42\x79\xf3\x42\xb1\xa1\xe7\x62\xae\xd5\x12\x2d\xa8\xd6\x32\x08\x9b\x3d\xa3\xa8\x0b\x14\x29\x74\x05\x78\x50\xe1\xd0\x6b\xc9\x8f\xcb\xce\x53\x8a\xa4\xe2\x5c\x00\x4c\x3d\x22\x1f\x80\x59\x65\xfe\x4a\x18\xd5\x12\x67\xc0\x14\x2c\x61\x5a\x53\xb5\x18\x40\x62\x77\x1e\x92\x81\x3b\xd7\x1d\xe0\xa8\x39\x15\x98\x56\x5d\xb1\x44\x0a\x6d\x54\x99\x18\xac\xb3\x37\x56\xf2\x9e\x89\xe0\x2e\x68\x77\xb1\xee\xc0\x55\xf9\xcf\xc0\x7d\x97\x24\xc9\x8c\x8a\x69\x54\xa7\x26\xa7\x29\xc0\xfe\xdb\x20\xe5\xf8\xf5\x58\x08\xd0\x89\x15\x2c\xb8\x01\x50\x8c\x2d\x1f\x09\x66\xd8\xff\x11\x21\x1f\xcf\xa0\xb2\x93\xda\x25\xf1\x6c\x0b\xed\xea\x44\xbf\x48\x47\xa3\xde\x10\xd8\xf6\x81\x1d\xc0\x72\x66\x68\x4a\x0d\xdd\xc1\x09\xec\x7d\x55\x5c\xcf\xd7\xd7\xc7\x02\xa7\xe1\x62\xd2\xf1\x21\x2f\x6e\xc9\x82\xc7\xf1\x4f\x70\x12\x67\x1e\xf2\x10\x71\x6d\x2c\x4e\xb9\x8b\x02\xf4\xed\x02\x79\xc6\x57\x2f\xb3\xc3\xfb\xd1\x90\x5c\x54\xa5\x19\x2b\x72\xd2\xee\x1a\xaa\xa3\x05\xd6\x82\x7e\x07\x18\xdd\x55\x77\x65\x49\xdd\xbf\x6b\xa5\x08\x82\x5c\x82\x09\xc3\x15\x8b\xc3\xcd\x1c\xe8\x4a\x81\x48\xde\x00\x22\x40\x79\xca\x8c\xae\x3c\x54\x90\x0e\x5b\xe2\xe2\xf8\x9d\x53\x46\x81\x48\x3b\xc0\x3a\x7d\x6e\xb5\x2c\x84\x60\xd7\xd2\xd1\x59\x4b\xf9\x1f\x05\xae\xbb\x18\x9d\xb1\x9c\xc0\x7b\x99\x76\xb1\x53\x37\xb2\xf0\x57\x43\x54\xfe\x9b\xe8\x89\xab\x41\xa9\xc7\x06\x70\x5b\xa5\x6b\x41\x73\x48\xe4\x66\x74\xbe\xbb\x91\xaa\x92\x91\x86\x21\x95\x31\x7c\x6e\x08\x9f\x1b\xbe\x6e\x6f\xcc\xeb\xe2\x01\xe2\x9f\xd6\x9e\x20\xf5\x8f\x74\xb2\x9c\x5a\x92\x72\xdb\xd1\xdc\xd9\x88\x46\x0e\x23\x38\x9a\xef\x6e\x11\xc3\xcd\xad\x8b\x74\x60\xdc\x52\x8b\x37\xe4\x57\x35\x2e\xef\xa4\xa9\xa0\x29\xa1\xa7\xee\x89\x57\x9d\x46\x6e\x2b\x7c\xf0\x79\xbd\xf9\x69\x63\x30\x10\x2f\x56\x6b\x14\xde\x23\x38\x88\x7c\x56\x3c\x53\x60\x3c\xf3\xf1\x07\x16\xbd\x94\xcc\x32\xa6\x60\x09\x4e\x7b\x6a\xdc\xa2\x43\x2e\x53\xb4\xe9\x0e\x82\x8a\x1a\x64\x4c\xc1\x1e\x82\x30\x41\x35\xa6\x6e\xf1\x37\x5e\xcc\x15\xce\x5b\x3b\x5e\xf0\x5a\x3e\x17\x0b\x9c\xfa\x65\x04\x5a\x54\x3d\xc9\xd4\x7e\xc8\x4a\x9d\x82\x8e\x33\xbc\x3d\x0e\xcc\x16\xe6\x42\xb3\x07\xba\xd0\x80\xf7\x95\x34\x1f\xbe\xef\xb2\xaa\x55\x03\x7f\x64\x13\xec\xdd\xfa\x46\x6c\xa7\x3b\xb1\x5d\x6e\xc5\x20\x9c\x92\x8b\x36\x2e\x48\x55\x87\x8d\x85\x43\x9a\xcf\x2e\xd7\x68\xe0\xa7\x02\xd7\xe7\xdd\xee\x44\xea\x75\xca\x6f\xae\x61\x08\x2f\x93\x4f\xe1\x0f\xcf\x71\xc2\xa5\xc1\x98\x59\xac\xae\x02\xa5\x01\x43\xe2\xbe\x2b\x3c\x09\x2a\xd4\xfa\x16\xb2\xb1\x3a\x2b\x71\xa8\x34\xa6\x18\x78\x82\xc0\x17\x47\x50\x8e\x80\x8a\x85\xe3\xe4\x66\xc6\x55\x3a\x2c\xa8\x32\x0b\x54\x1f\x07\xb5\xaf\x05\xf7\xfa\x4e\x0b\xdf\xf1\x3a\xa7\x5d\xea\xe3\xb5\x10\x86\xc5\x7b\xf3\xb0\xb3\xce\xaf\x85\xeb\x53\xac\xa7\xbd\x03\xff\xca\xf5\xc4\xa9\x45\xbd\x46\xf8\x6c\xeb\x49\x63\xf2\xb1\x3f\xdf\xb0\x34\x48\xd7\xaf\x5e\x91\x0d\xc4\xa5\xab\x64\xec\x05\x1d\xb8\x3c\x28\x44\x76\xa4\x81\xd5\x43\x69\x55\x6b\x3c\x32\xec\x39\x49\xc1\xfb\xd0\xb8\x4a\x47\x62\xe1\x4c\x37\xf1\xb7\xe2\x01\xc2\x29\x21\x27\x42\x0a\x3c\x39\xd8\xf6\x14\x5d\x88\xd6\xd8\xa6\xa0\x89\x2b\x51\x57\xaf\x10\x1a\x9d\x54\xcf\x24\xb8\x48\xed\xd6\x01\xe5\x06\x1d\x49\x97\x49\xc2\x58\xd0\xaa\xe3\x12\x35\xd5\xc9\x76\x53\xf6\xa5\x2e\xb5\x84\x24\x2e\xda\xd0\x2c\xab\xb4\x59\x07\x2e\x09\x7c\xce\x5b\x00\x23\xf6\x57\x0b\xb4\x71\x8a\x3d\x14\x51\x47\xb7\x97\x52\x24\x78\x85\xcf\xcd\xc2\xcf\xe0\xb2\xc9\xea\x41\x8d\xd0\xa8\xe4\xf2\x09\xda\x9d\x22\x75\x20\x00\x13\x48\x93\x2b\xe1\x5e\xe7\x4c\x2e\x37\x83\xa5\x43\x63\x9a\xdc\x3f\x50\x95\x42\x29\xdf\x82\x1a\x8e\x69\xc1\x07\xb5\x61\x4f\xa2\x39\x40\x21\xfd\x18\x8b\x4e\x83\xd2\xa1\x59\x48\x41\x5d\x7d\x86\xd0\xd2\xc8\x9c\x1a\x9e\x80\x2a\xcb\x27\x91\x15\x31\x0f\x29\x0d\x1b\x65\x07\x81\xca\x86\x02\xf6\x77\x78\x1b\xa3\x18\x31\x0f\x92\xf0\xdc\x4a\x08\x14\x4a\x69\x4c\x42\xc4\x90\xb7\x77\x6e\x9a\xa9\x15\x83\x7e\x00\x23\x73\xd4\x0a\x95\x64\xab\x42\x69\x18\x3e\x58\x34\x83\x29\xcf\x85\xdc\x0c\x1a\x0c\xdc\xf5\xb1\x38\x6d\xe7\x1a\xa1\xea\xc0\x6e\xcf\x03\xb3\x72\x81\xde\x88\xb0\x7a\xb4\x6a\x46\x58\xd3\x56\x93\x94\xeb\x46\x61\xea\x93\x54\xc9\xa2\x70\x06\x92\xfc\xb4\x39\x23\xb8\x37\x50\x73\xa6\xa3\xda\xcb\x68\xaa\x9e\x32\x11\x8a\x87\xbb\x74\x16\x70\x72\x9b\x9f\xa8\x1d\x98\x11\x06\x84\x9e\x92\x4f\xae\xa8\x50\x40\xdc\xe0\x75\xd7\x4a\x70\x42\x6b\x8b\x93\x9d\x7a\x89\xa7\xed\xd3\x4b\x3c\xbd\xc4\xf3\xf3\x96\x78\x82\xbb\xd7\xae\xd2\x4e\xe5\xe3\xd8\x28\x48\xee\x9d\x01\xaa\x06\xeb\x8c\x18\xd7\x13\xf2\x91\x25\x72\xce\x14\x12\x39\x28\xfc\x69\x79\xf9\x5b\xca\x33\x4b\xe2\x3c\xa9\xab\xd4\x43\xc8\xa8\x5a\x37\xcd\x45\x1a\x79\x80\xa6\x43\xf3\xdc\x4d\xca\x45\xfa\xd9\xf6\xee\x92\xac\x50\x6c\xce\x65\xa9\xbd\xcb\x42\x69\xf0\x98\x69\xe3\xf8\xed\x8c\x4f\x43\x62\xee\x70\xd5\xa9\x58\x22\x55\x5a\x85\x94\x6b\x43\x4d\xa9\xeb\x71\x12\x09\x5a\xd3\x0e\x67\xa0\x09\x70\x7c\x64\xea\xbe\x1b\x25\x45\x8f\x8d\x3d\x4e\xc5\xf1\x3b\xf4\xf9\xa8\xea\x6e\x9b\xc8\x0d\xa5\x72\x81\xb1\x22\x54\x69\x58\x84\x56\x0e\x01\x3a\xc3\xba\x16\xf5\x7a\x86\x85\x5b\x86\x61\xd8\x61\xe5\x75\xd2\x22\xe3\x7a\xfc\xec\x04\x75\xb2\x47\x80\x67\xfc\xbc\x60\xc7\x93\xc6\x62\xbb\x7b\x5f\x92\x3d\x3d\x30\xc9\x3e\x5e\x98\xe4\x90\x9e\x98\x24\xf8\x73\xef\x73\x62\x3e\x7a\x4f\xf2\xc6\x99\x71\x84\x77\xd3\x99\xa9\x25\x14\x08\xe3\x70\xed\x2b\x40\xba\x6b\xcd\x70\x06\xc0\x24\x18\xfb\x03\xbb\xd3\x0a\xda\x1c\xde\x5d\xb2\xcf\x21\xeb\x6f\x24\xc7\x54\x45\xb5\x8d\x04\x0f\x84\xbc\xc0\x4c\x40\x70\xea\x86\xce\x25\xcb\x6b\x4b\xfd\x09\xee\x4f\x70\xdb\xfe\xcf\x79\x82\xd1\xe3\xb9\x8b\x43\x7e\xa3\x52\x10\x76\x77\x41\xb8\x74\xcc\x32\xf2\x63\xc9\xd4\x82\x58\x21\xa8\x72\xef\x81\xf4\xc6\x9a\xa7\xce\x41\xc6\x19\x55\xda\xcb\xec\x4f\xc8\xff\xc1\x64\x73\xf5\xd9\x4a\x80\x10\xc7\xb6\x07\x5d\x6b\x0e\x55\x0f\x55\x46\x68\x05\x08\xc6\x12\x1e\xde\x30\xd6\x64\x3e\x2b\xee\x9d\x7f\xb8\xdc\x4d\xd1\xe9\x76\xa9\x45\x76\xb9\xd8\x5a\x5a\xfc\xf9\x86\x05\x22\x20\xc2\x2f\xf5\x6a\x52\xc1\x14\x41\xee\xd9\x62\xe0\xee\xc1\x5d\xf6\x76\xdf\x18\xdd\x39\xea\x29\x45\xdb\xa6\xaa\x58\x05\xa0\x1d\x28\xe4\x6e\xd6\x03\x7c\xda\x27\xa1\xac\xf7\xf2\x40\xe8\x4a\x88\x77\x26\xe1\x9d\x92\x55\xc6\xcf\xba\xc4\x95\x88\x13\x90\x81\xcf\xfb\x35\x07\x34\x00\x5f\x6e\xa0\x16\x5d\x37\x91\xec\xae\x02\xe3\xe3\x01\xbb\xf7\x52\x03\x9a\xd6\x1c\x73\xef\xd9\xe2\x58\xbb\xa8\x41\x29\xf4\x8c\x17\x3e\x3f\x3c\x50\x02\x87\xb9\xe4\x7b\xf0\x0f\xf0\x43\xe0\x99\xbf\x16\x03\xf2\x41\x1a\xfb\xbf\x2b\x70\x15\x42\x4b\xa5\x64\xfa\x83\x34\xf0\xe6\xc9\x81\x85\xd3\xdd\x1b\x54\xce\x4c\xc9\xc1\xcc\x88\x2e\x6d\x10\x9f\xe1\x5d\x50\x00\x24\xee\xbe\x35\x80\x95\x6b\x72\x2d\x88\x54\x1e\x26\xc6\x27\x0f\xd6\x6e\x08\x6f\x5b\x8a\x2c\xc2\x2b\xc6\x70\xa0\x94\xaa\x06\xc9\x0d\xc3\x05\xe3\x32\xf7\xbf\x80\xed\x09\xac\xf1\xc1\x6f\x06\x52\xe0\x52\xc3\xa6\x3c\x21\x39\x53\x53\x88\x0f\x4d\x66\xbb\x6f\x50\x77\xba\x8d\xcf\x4e\xd4\x3b\xfe\x70\x67\xcc\x00\x56\xf7\x0e\x3c\x97\xf6\x65\x98\x38\x0a\xb2\x88\x9c\x16\x16\x29\xfe\x61\x39\x01\xec\xcb\xbf\x20\x65\xb5\x1e\x91\x73\x5f\xf0\x34\xfe\xcd\x59\x31\xe2\x61\xec\x08\x56\xa6\xff\xb1\xe4\x73\x9a\x31\xf4\xe7\xa3\x22\xa4\xf1\x94\x93\x25\x36\x3d\x70\x79\xab\x2d\x95\x0a\x37\x43\x47\xf7\x6c\x71\x34\x58\x42\xa4\xa3\x6b\x71\x54\x05\x69\xd7\x50\x27\x30\x34\xb8\x34\x38\x82\xdf\x8e\x0e\xcd\xd9\x9f\x49\xb4\xdf\x01\x4b\x9c\x41\xe8\x22\xa3\x5a\x77\x8b\x6f\x6d\x84\x16\x35\xc6\x59\x95\x80\xf1\x36\x6a\x53\x05\x17\x39\xef\xcd\x83\xdb\xb3\xc0\xcb\xbf\xbb\xa7\x51\x27\xe8\xcd\x5d\xf5\x94\xf6\x89\x1b\x56\x26\x14\x83\xb4\x05\x3e\x86\xa3\x16\x17\x57\x5d\xc6\xae\x81\xd7\xf7\x60\x57\x94\x93\xb8\xc8\x33\xd7\xa0\x06\x73\x1f\xd5\x21\xa4\x21\x5c\x24\x59\xe9\x4c\x8a\xd0\x15\x94\xe8\xae\xa2\xfe\x0e\xc0\xd9\x03\xa9\xaa\x01\x3c\x36\xf9\x6b\xdf\x25\x07\xde\xe6\x0d\x1d\xdc\x89\x86\x1b\x2f\x84\xd5\xa1\xd7\x3a\xd9\xe2\x2e\x59\x4f\xc6\x99\xd4\x65\x8f\xb7\x7c\xac\x18\xb9\x98\x51\x21\x58\x16\x45\xbb\x3a\x63\x47\x28\x67\x05\x02\x89\x2b\x62\x75\x5c\xaf\x62\xe5\xe9\x9b\x08\xb1\xd5\x07\xaf\x1d\xfc\x53\x2a\x2a\x75\xb0\x3a\xe5\x2e\x55\xe3\x4c\x3e\x90\x54\x92\x07\xa8\x5b\x30\xb7\x4c\x0b\x2e\x65\xb5\x67\x77\xd1\x4c\xc1\x45\x22\x91\x79\xa1\x64\xce\xb5\x77\x8e\x77\xdb\x78\xd0\xd0\xd0\xac\x6c\x91\x03\xa8\xbe\x07\x59\x29\xea\x29\xe1\xdf\x5e\x10\x43\xd5\x94\x19\x3b\x1a\x11\x65\x3e\x66\xad\xe3\x57\x1f\x23\x07\xd9\x97\x54\x42\xf4\xb0\x45\xb0\x70\x1b\x7e\xf8\xe1\x43\xe7\xd2\xbb\x55\xcf\x75\x7b\xfb\x20\x55\x96\x3e\xf0\x14\x59\xb4\x26\x27\xb6\xf1\xe9\xcb\xaf\x94\xfb\xf0\xc0\xd3\xce\xe0\x80\x4e\x75\x30\x78\x3f\x28\x0b\x06\x02\x70\x70\x15\x9e\x38\xa4\xd1\x86\x1e\xa7\xe4\x8a\x63\x74\x11\xf4\x87\x44\x35\xf9\x98\x8b\x2a\xc2\xac\x02\xb3\x25\xc6\xf6\xbc\x78\xd5\x44\x33\x83\x71\x21\x10\x5a\x21\xcd\x8c\x68\x9e\x97\x99\xa1\x82\xc9\x52\x67\x8b\xd6\xa8\xf2\x3c\xa0\x9e\x64\xec\x33\x62\x76\x17\x26\x17\x3a\xd5\x99\x1d\xb8\xae\x54\x61\x94\x4b\xdc\xae\x72\xae\x4a\xcf\x02\xe7\x0b\xe1\x46\xec\x33\x4b\x9c\x57\x70\x91\x95\x53\xbe\x25\xfc\xe1\x67\x96\xd5\xbc\x4a\x20\x5d\x6a\x56\x45\xea\xb7\xad\xeb\xf2\x44\x49\xc8\x9f\x97\xc3\xdf\xad\x4e\x40\x9e\xb2\x82\x89\x14\x52\xa2\xbd\xad\x30\x17\x27\x7f\x50\xc8\xb9\xf4\x62\x5d\xa9\x96\xcf\x4a\x56\xa3\xe0\x91\x0b\xd7\x4c\x66\xa9\x26\xec\xb3\x51\xd4\x12\xa6\xdc\x92\xa0\xd0\x67\x42\xa8\x68\x4f\x64\x5e\x46\x8a\x60\x72\x70\x6e\xff\xb8\xf5\x32\x5f\x62\xc9\xcb\x6a\xed\x7a\x63\xc1\xea\xfd\x52\xd7\x23\x21\x76\x67\x45\xd7\x3d\x84\x57\xa4\x98\x77\x5f\xa9\x7b\x26\xee\x97\x6a\x5e\xaf\x48\xaa\xdd\x98\x55\x5f\xa6\xf3\x8b\xc8\x3b\x3f\x81\xc0\xe0\x2e\x49\x98\x5c\x8f\x86\x46\xed\x5e\x36\x0b\x42\x6f\xd0\xa0\x1d\xde\x46\x7c\x00\x32\x9e\xba\x81\x5c\x58\x13\xd1\x16\x96\x95\xeb\x5c\x29\xc4\x36\x2a\xf6\x18\x59\xc4\xa9\xa1\x9a\x99\x76\xd6\x94\xba\xe8\x50\xf5\xb4\x07\x30\xc6\x2f\xf7\x13\x66\xb1\x07\x87\x74\x1f\x2c\x4b\x86\x7f\x74\x52\x86\xa8\xb5\xb4\xf2\x85\x87\x8f\x4f\xd2\xc4\xc2\x2d\x32\x8e\x91\xda\x5d\x49\xa8\x69\x5d\x72\xa7\x15\x5f\x70\x33\xf8\xf4\xa9\x73\x2d\xd7\xa8\xa7\x97\x43\xe0\xdf\x75\x20\x38\x5c\x80\x44\x3e\xfc\xc7\x32\x56\x07\x20\xb9\x45\x58\xb6\x6b\x7f\xa8\xb5\x4d\x13\x56\x19\xaf\x2e\xb9\xbe\xef\x92\x8c\x6c\xa9\x73\xfd\x48\x7c\x73\x71\x45\xdc\xdb\x56\xf6\xa5\x2e\x06\xa6\x7d\x33\x63\x4d\x13\x56\x19\x6d\x53\xae\xef\x9f\xbc\xac\x7a\x91\x7e\xd8\xe6\x01\xfe\x74\xf6\xaf\xa6\xd4\xeb\x53\xb4\x44\xb9\x83\x16\xb2\x24\x0f\x2e\xf5\x81\x93\x9a\xef\x78\xf1\x86\x5c\x09\x5d\x2a\x56\xdd\xdc\x36\x87\xb2\x5c\xf7\x25\x95\x5e\xdf\x0b\x4b\x5e\xb2\xf1\xad\xa0\xca\x80\x78\xdc\x15\x0d\x42\x47\x4f\x9f\xa2\x17\xa2\x0d\x1e\x5c\x4f\xbc\x63\xdd\xc0\xc5\x78\x87\xc4\x65\xbe\x91\xdd\xf9\x28\xad\x49\xbc\xd7\x6f\x43\xca\x1f\x72\x96\xb2\xf9\x99\x4e\xe9\xeb\x01\x7c\xc6\x3b\x3c\xd7\xe7\x44\x35\x39\x7a\x7d\x34\x22\xb7\x3c\xe7\x19\x55\xd9\xa2\x96\x8a\xb9\x6a\x67\x99\x85\x1f\x10\x6e\xe5\x5e\x1d\x91\x13\xa9\x60\xe4\x84\x0a\x92\x31\x1f\xd1\xe4\xce\xd9\x02\x65\xc7\xd3\xa7\x26\x2e\xe4\x51\xed\x97\x48\x67\x3a\xe3\x44\xea\x39\xb6\xe3\x47\xb5\x74\x36\x97\x15\x49\xe7\xc2\xd2\xf9\x11\xf9\xb4\xaa\x50\x39\x1c\x19\xdf\xe2\xb9\x80\xfa\x34\x7a\xdf\x4e\x1a\xdc\xb2\x39\xf8\xf9\xc0\xb4\x5d\x4b\x9c\x72\xf3\x91\x15\xb2\x93\x84\x80\x5d\x1a\xf6\x38\x6e\xec\x0b\xa9\x39\x24\x2a\xa5\x06\xca\x02\x2b\xc3\x93\x32\xa3\x56\xac\x46\x6b\xdc\x88\x5c\x5e\xdd\x7c\xbc\xba\x38\xbf\xbb\xba\x7c\x43\xbe\x71\x23\xf1\x58\xc2\x1b\x91\xbb\x38\x1b\x54\xe4\xd1\xeb\x52\xee\x84\x6f\x0d\x1c\x19\xa2\xa2\x4a\xee\x08\x39\x3e\xa8\x20\xd7\x82\x9b\x2a\x3d\x32\xfa\x9d\x65\x52\x30\x5f\x3d\xb4\x90\xce\x1a\x38\xe5\xe8\x0d\x22\xdc\x60\xf6\xe7\xfa\x68\x70\x3a\x30\xd5\x6a\x98\xca\x16\x45\xf0\x11\x44\x8b\x0a\xb8\x87\x12\xff\x7d\xfe\xd3\xae\xb2\x6f\xc8\x46\xeb\x03\x9c\xd0\xfa\x5f\xbd\x47\x66\x10\x12\xb3\xfb\x74\x37\x2b\x4a\x5a\x13\xcb\x66\x8e\x47\xc7\x5e\xa0\xc8\x96\x92\xf0\x87\x41\xe3\x8c\x5e\x75\x64\x1b\x11\xf2\x9d\x77\xd9\x86\xd0\xe3\xd5\xf9\xfc\x31\x3b\x44\x94\x15\xbe\x81\xb2\x3e\x30\xa6\x1c\xc7\x1f\x75\x29\xc0\xa6\x7c\xce\x04\x2e\xec\xb0\x14\xca\x7f\xbe\x73\x75\xb4\x6a\xde\x4e\xff\xf8\xf8\xee\xb0\x33\xc3\xf3\xd7\x79\x5e\xee\xd8\xba\x59\x25\x32\xcf\x31\x5f\xd4\x2c\x04\x18\x56\x31\x82\x81\x2a\x1c\x4c\xf3\xc1\xcc\x57\x93\x2d\xc8\xdf\xa0\x67\xbe\x53\x43\xd3\x09\xaf\x5d\x50\x82\xa8\xc4\xdc\xee\x79\x98\x5d\x92\x35\xed\x93\xa7\x38\xd2\x7e\x16\x3e\x7e\xf6\xf1\xea\xfc\xf2\xfd\xd5\x28\x4f\x9f\x9c\xb4\x30\x91\x16\x92\x0b\xa3\xb7\xeb\x37\xdb\xaa\xce\xb4\x27\x3f\xe1\xa3\x5d\xb9\x73\xe8\xe8\x71\xcc\xbf\x88\xf2\xd2\xa5\xcc\x50\x9e\xe9\x68\x0f\x8d\x2c\x64\x26\xa7\xab\xd3\x2f\x77\xd8\x9c\x5f\x60\x7e\x99\x21\x1d\xda\x5d\x3f\xac\xa8\xdf\xa6\x8e\x46\x53\xca\xaf\x2a\x62\x57\x6b\x0d\x52\x33\x94\xbb\x78\xa1\xcb\x7d\x14\xe1\x6c\x09\x06\xa8\x48\xc2\x01\xf6\x29\xfb\xaa\x1c\x78\x51\x0d\x9b\xb6\x52\xdb\x63\x83\x6e\xbb\xc0\x66\xe9\xcf\xf6\x42\x45\x75\x98\xf9\x3e\x75\x02\x57\x28\x36\x0c\xe9\x9a\xa0\xb4\x8a\x54\x11\xc3\x8d\xe9\x9d\xb7\xde\x78\x5b\x0f\xb6\xca\x16\x4d\x2b\x4e\x25\x1f\x05\xd3\x17\xe6\x18\xc8\xb2\x45\x95\x06\xd2\x69\xd1\x74\x8a\x69\x98\x94\x33\x13\x17\x8a\xcf\x79\xc6\xa6\x90\x8a\x95\x8b\x69\x14\xfe\x1a\x07\xcc\xba\xd4\xac\x75\xa3\xeb\x7b\xfb\x57\x94\x74\x1b\xf0\xe2\xc3\x77\x77\x90\xd5\x17\x2e\xb8\xf6\x16\xc2\xed\x07\xe1\xbc\x0d\x87\x43\x30\x19\x9c\xfc\xcd\xca\x93\x69\x76\x4a\x7e\x60\xee\x3b\x12\xd2\x0e\x2b\x28\x05\x34\x93\x21\x07\x2c\xcc\xb5\x82\x2c\xa0\x23\x5e\xef\xbb\x56\x67\xb6\xa5\x95\x95\x90\xd5\xd4\xda\x43\xe5\x53\x4c\xdd\x88\x77\x4c\x4f\x2f\x7b\x1e\x90\xec\xef\x4c\xe5\xbc\x69\x75\x15\x7e\x86\x8b\x1f\x4f\x0f\x29\xd1\x8b\x3c\xe3\xe2\xbe\xca\x0b\x36\x91\x16\x87\x30\x34\x81\x8b\x7b\x8f\xb1\x8a\xd1\x6c\x3d\xa5\xdc\x05\x3f\x0e\x4a\x25\xcd\x0e\x16\x40\xb0\xd0\xd9\x73\xf6\x27\x7f\xec\xdd\x35\x74\x4c\xe2\x8e\x8e\x5e\xdc\x7a\xb9\xee\x56\x06\xff\x18\x3a\xd4\x68\x9a\x20\xd7\xb7\x17\xb7\xd7\x4f\x6a\xa1\x5e\xc7\x12\x60\x76\xcf\x28\xd5\xf1\x1f\xb7\xdd\x0e\x0f\x49\x56\x6e\x6f\x83\xea\xdd\x8d\x54\x86\x66\x07\x22\x02\xc9\x8c\x16\xe7\xa5\x99\x5d\x72\x0d\x39\x14\xba\x0a\x01\x4b\xfd\x23\x4f\x67\xcc\xdd\xec\x13\x06\x72\x8f\x0e\xae\xdd\xc5\x9f\xce\x6f\x08\x2d\xed\xfe\x1a\x97\x5c\xf4\xa0\x17\xee\x7e\x66\xb7\x18\x61\xb0\xe3\xba\x5c\xef\x2d\xab\xf2\xad\x1e\x7b\x4d\x8f\xe1\x87\xdb\xdf\x45\x00\x0d\x45\x0a\xf6\x82\xef\x1f\xb8\xe0\x86\x53\x23\x5b\x16\x2a\xab\xa1\x40\xad\x6f\x30\x08\x94\xda\xc8\xdc\x61\xf0\xb5\x6f\x01\x57\xc8\xc0\xc5\x97\x3a\x55\xd6\x02\x90\xde\x01\x62\xd7\xc2\xca\xda\x34\x61\x0d\x07\xc8\x01\x24\xfd\xc4\xb1\x79\x68\xf3\x07\x67\xa0\x82\xfc\x60\xd9\x1f\xdf\xd4\x52\xb1\x2f\xd5\xb5\xf0\x56\x8a\xaa\x68\xc2\x41\x2d\x3e\xfc\xc7\xae\x44\x81\xff\x28\x1a\x96\x36\x5c\xe0\x7f\x95\x34\x43\xc0\x7c\x38\xb4\x59\xaa\x0e\xe4\xae\xf3\xad\xef\x90\x9b\x7a\xb5\x1d\x1f\x82\x96\x5e\x6a\xcc\x3c\x86\xeb\x31\x8a\x0a\x6d\xf7\xa8\xae\x8b\x1d\xbb\x8b\xa7\x63\x72\x62\x92\xa2\x75\xed\xfe\x47\x72\x6d\xcf\x4a\x51\x2b\xe4\x0c\x33\xbf\xc3\x6d\x79\x17\x5c\xdb\xdb\x4e\xf2\x51\xae\x86\x00\xcb\xbb\x5a\x55\x5c\xaf\xb0\x5b\xf1\xba\x90\xf5\x93\x77\x5c\x1b\x5f\x90\x01\x5e\x70\xed\xf2\x08\x83\xdc\x75\x63\x15\x39\x5e\xfc\x2f\x4d\x53\xf5\x06\xb9\x94\xaf\xbe\xac\x40\xfa\xf2\x49\xbe\xa8\x08\x77\x89\x27\x66\x51\xb8\x04\x80\x77\x17\x37\x04\x0b\xa4\xfc\xfe\xb7\x58\xf9\xf5\xdf\x7f\xfd\xdb\x57\xad\xb7\xfb\xf9\x9c\xc7\x77\xb4\x63\x1c\xfc\x8e\xe9\x45\xf8\x0d\xd6\xfc\x03\xed\x4a\x40\x36\xb9\x45\x77\x3c\x4b\x59\xdd\x51\x47\xc4\xb2\xbb\x1c\xe8\xfd\x6e\x12\x4c\xef\x67\xf7\xac\x7e\x76\x24\x44\x94\x20\x91\xe8\x88\x2e\x71\x57\x08\x31\x5c\x26\x3b\x48\x71\x6e\x5e\x1e\xc5\xd9\x0a\x9b\xed\x58\x54\xc7\x9e\xf8\x32\xde\x97\xbf\xa9\x5c\xd8\x2f\x3f\xdc\xfe\xef\xbb\xf3\xaf\xaf\xde\xc1\x4c\xdd\xfd\xbd\x45\x0d\x2e\x76\xf6\x9f\x6a\x8f\x6a\x6d\x94\xd7\xed\x00\xe9\x76\x2d\x23\x1a\x17\x32\x82\x7c\x78\x7b\xdb\xf5\x2e\x66\x5f\x01\x5d\x4c\x5a\xad\xfd\x69\xad\x6d\x50\xd5\x84\xa9\xc3\xc5\x8f\xec\x6c\x94\x8b\x12\x69\xd5\xf4\x2f\xbb\x53\x38\xc3\xbd\x55\xa4\xad\x3b\x40\x5e\xc0\xbd\x83\x5d\x2f\xc2\xe0\xe0\x37\x0e\x8f\x04\xab\xb6\x72\x80\xea\x1e\x58\x74\x8c\xbd\xbc\x08\x60\x0f\x29\xd2\x36\x65\x69\xb6\xa5\xd6\x4c\x87\xea\x0b\x2f\x14\x53\x8a\x55\xe9\x99\xbb\x50\xaf\x95\x03\xd4\xca\x95\xd5\xee\x62\x6a\xb1\x14\xeb\xd2\x99\x7b\x0f\x05\xea\x94\x57\x5d\xd0\xe4\xa0\x05\x55\xaa\x57\xf8\x06\x82\xdc\x9f\x9e\x00\xc2\x67\x0f\xe8\x48\x1b\xc6\xeb\x8a\xc8\xa1\x63\x33\x4a\xae\xd3\x0e\xf9\x42\x1f\x85\xf4\x11\x88\x71\x38\xdd\x33\x6f\x1f\x79\x5a\x6d\xe7\x87\x1d\x15\x9d\x43\x2b\x39\xc5\x4c\x1a\x29\x76\xf6\x92\x5f\xd5\xbd\x7e\xa0\x6f\xa0\xc5\x45\x55\xc6\x26\xaa\xf1\x08\x1e\x94\xe1\x32\xc2\xca\x73\x9e\x5d\x48\xe1\xaf\x25\xea\x97\x12\x4f\x2e\x82\xa4\xd7\x97\x07\x3a\x7c\x5f\x6e\x88\x67\x57\x63\xf0\x41\x9d\x41\xd2\xce\x31\x29\xb6\x8b\x87\xd8\xf5\xa5\x13\xcd\x7c\xc0\x89\x76\x08\x49\xd6\x63\xe4\xc1\x58\xa7\x54\xe6\x41\xaa\xee\xa1\xde\xf5\x8e\x0d\x5f\x05\xf7\xdb\x52\x28\xd6\x4b\x3c\x3d\x38\xc7\x67\x3e\x41\xb7\x70\x82\x1a\x09\xce\xd7\x9d\xa4\xc7\x38\x48\xcf\x7b\x80\xf6\x65\x54\x8f\x1b\xe5\x7b\x50\x21\xdd\xa3\x5b\xc7\xa5\xfa\x6e\xce\x98\x60\x37\xa9\xa2\x16\x14\x4c\x2e\xd1\x89\x3b\x18\x75\x50\x12\x4b\x50\x76\x21\x0c\xbe\x0f\x1a\x70\x31\xd1\x73\x96\x59\xa8\x4a\x11\xa7\x88\x76\x61\xbc\x03\x82\x59\x96\x73\x5a\xf8\x9a\xdc\xf2\x41\x3c\x50\x95\x92\xf3\x9b\xeb\xc3\x50\x83\x0e\x7e\xd6\x88\x49\xed\x32\x7a\xd5\x3d\xad\xab\x9e\x58\xe6\x66\xc6\xa0\xb6\x22\x19\x73\xa3\xab\x9a\x7e\xcc\xc4\x7a\xa5\xa5\x82\xe1\x2e\xcb\x9e\x65\x7b\x6e\xdd\x48\x11\xc3\x14\x44\x26\x86\x66\xbe\x88\x80\x2b\x93\xf3\xea\xd5\x2b\x34\x85\xbd\xfa\xdd\xef\x7e\x87\x95\x95\x52\x96\xf0\x7c\xb9\x21\xb4\xfa\x3f\xaf\x5f\x8f\xc8\x7f\x9f\xbf\x7f\x07\x95\x1f\x0b\xa3\x31\x2b\x09\x8e\x8c\x95\xe0\xa3\xce\x7a\x40\xfe\xef\xed\x77\x1f\xaa\x32\x31\xf5\x5f\x5d\x41\x6d\xb7\xbc\x11\xb9\x8c\xfc\x9f\x62\x43\x17\x35\x33\x57\xd0\xc8\x10\x3a\x99\x20\x62\x8c\x7d\x39\x5d\x3c\x70\x3e\x7a\x1c\xaa\x82\x63\xfd\x11\x8b\x12\x19\x38\x66\x59\x95\x1c\x4d\x83\x3e\xb3\x01\xfa\x99\xc1\x58\x81\x4c\xc2\x54\x06\x58\x4b\x7e\xa2\xa1\x0a\x49\x95\xfe\x4f\x31\x6d\x85\x52\x57\x5d\x11\x07\xab\x76\x46\xb3\xd6\xb9\x1e\x1e\xe3\x06\xa8\x75\x75\x8c\xba\xe9\xde\x9d\x21\x9f\xbe\xd5\xe5\x2e\xae\xca\xd4\xff\x0d\x6f\x43\xb7\x39\x09\x3f\xd2\x8d\x4c\x6d\xae\x37\x61\x36\xb8\x75\x2e\x4b\x40\x45\x27\x68\x26\xa1\x92\x57\xd8\xe9\x8a\x8b\x45\x45\xef\xb7\x2f\xa5\x73\xf2\xc5\xae\x09\x78\x91\x50\xbd\xa7\xad\xcb\xf9\xd4\xfd\x45\x7c\xef\x5a\x5e\x05\x3a\x96\xa5\xf1\x77\xd8\xee\x77\x08\xc0\xc6\x2a\xeb\x1d\xd2\x48\xee\x90\x79\x72\x97\x0c\xc4\x9d\x93\x98\xd6\xef\x9b\x81\x27\xd4\x45\x89\x01\x61\x34\x99\x91\x7b\xb6\x18\x22\xdd\x2a\x28\x44\xf3\x00\x54\x2e\x2d\x2c\x6a\x85\x4f\xaa\xda\x35\x56\x3e\x76\x20\xf3\x8e\x01\x11\xf7\xf1\xd1\x40\x5e\x08\xd5\x4e\x5e\x72\x69\x44\x45\x64\x29\xf0\xb9\xaa\xa3\x7a\xc4\x21\x6f\x28\x16\x23\xaf\x07\xa9\xd8\xf3\xc6\x52\xdb\x4d\x6f\xfa\x72\xe5\x0d\x61\xe9\xa0\xe3\x6e\xa5\x58\xea\xed\x8a\x6f\x3b\xe1\x0f\x3e\x48\x7d\x76\xe6\xc8\xa3\x02\xca\xf9\xb9\x4a\x4e\xae\xad\x87\x52\x00\x44\x2d\x88\x46\x33\x53\x3a\xd0\x60\xbd\xb0\x52\x64\x4c\x6b\xc2\x61\x85\x39\x55\xf7\xcc\x27\x8c\xa1\xd9\x88\xdc\xd8\x49\x86\xfc\x55\x98\x16\x79\x8e\x2e\x76\xf6\xcc\xc6\xd1\x41\xf6\x23\xc7\xa3\xd1\x31\x12\xf8\x15\xb1\x42\x1d\xf0\x63\xb7\x9c\xba\x3b\xe4\xd2\x6d\x94\xf6\x2e\x34\x66\x06\xb6\x22\x1f\x64\xbe\x96\x10\x05\x67\x66\x9e\x81\xd1\xd6\x49\x94\x96\x97\xb3\x43\x02\xd8\x5d\xf3\x96\xef\x92\xb5\xbc\xd5\xbd\x45\xfd\xd9\x3d\x5b\xf9\x4e\xb9\xca\xd7\x65\x2a\x77\x3b\xe5\x4e\x5b\xf7\x1c\xce\x7b\xa4\xd8\xce\x3b\xa5\x79\xf5\x4f\xdd\x48\x09\x72\x47\x2d\x4b\x4f\x2b\x19\xd1\x25\x7d\xca\xd8\x17\x25\x14\x5e\x4f\x56\x55\x9d\xf3\xc1\x82\x91\xbc\xec\x69\xa8\x85\xc0\xf3\x4b\x83\xdd\x6a\xb9\x90\xce\xe2\x61\xf3\xe9\x22\x2e\x36\x9f\x76\x97\x81\xcd\xa7\xae\xb0\x45\x61\x49\x81\xe8\xc7\x5e\xfc\x00\x52\x23\x21\x67\x77\x75\x04\x47\xe4\xbd\x63\x0a\x88\x8c\x74\xac\x65\x56\x9a\x10\xc9\xb4\x82\x63\xc0\xa0\x3e\xc3\x37\x86\x94\xfa\x66\x11\xff\x00\xce\x89\x64\xb9\x2b\x2b\xc1\x67\xa7\x23\xde\xb5\xe6\xde\x4f\xd6\x99\x64\x0f\x18\x7a\x51\x62\x67\x38\xfa\x01\x42\xde\x09\xef\x4b\x5d\x93\x71\xc0\x93\xc4\x68\x14\xa0\xbc\xb8\xe2\x0a\x3d\x75\x5e\x62\x3b\xab\x8d\x9b\xab\x33\x4c\x9c\xdf\x5c\xef\xa4\x01\x44\xfd\xd7\xe8\x00\x71\x8b\x9f\xb0\x16\x70\x8d\x5a\x40\x5c\x76\xe7\xb2\x5a\xb9\x33\x29\x5b\xb2\xf3\xe2\xc5\xc8\xa5\x69\xbf\xb5\xc4\x32\x76\x3a\xad\xe7\xd0\x43\x63\x4f\x45\x56\xa3\xbc\x7b\xfe\xd6\x11\x0e\xf1\x4b\x17\x39\x9f\x50\x7c\x04\x78\x74\x2a\x97\xee\x9f\xe5\x6a\x76\xb0\x58\x72\x0b\xa5\x6d\x50\x1f\x8c\x14\xcb\x42\xa6\x6f\x5c\x29\x69\x21\x24\x16\x90\xd3\x03\xac\x8d\xa3\x07\xa8\x30\x5a\x29\x22\xba\x2b\x56\x91\xc9\x7d\x67\xb9\x61\xa7\x2a\x47\xfb\xd4\x39\xb2\x1b\x08\x2b\xbf\xe9\xba\x8b\x64\xcf\xb2\x45\x24\x62\x4d\xbb\x15\x42\xa9\xed\xa9\x1b\x29\xd4\x79\x4f\x66\x2c\xa7\x98\xc3\xcf\x2f\xcf\x52\x99\x07\xc5\x8d\x61\x98\x4b\x89\xa9\x5c\x13\x39\x19\xd4\xee\x0c\x8e\xe6\xaf\x8f\x76\x29\x07\xb3\x67\xc5\x1e\x52\xed\xc2\x01\x80\x71\x53\x13\xd9\x2c\x5e\x83\x2e\x91\x41\xe2\x4d\xd1\x30\x48\x58\x06\x33\x47\xe8\x3d\xf9\xc2\x0f\xa1\x47\xed\xaa\x3f\x0d\x82\xc0\xd0\xeb\x4f\xbd\xfe\x74\x10\xfd\x29\x62\x2c\x9e\xe0\xac\xd0\xa5\x62\x87\x61\xaf\x50\x55\x81\x4c\x51\x02\x1e\x8b\x9a\x5e\x95\x92\xaa\x6e\x71\xb3\xfa\xd0\xb1\x57\xb0\x1c\x1e\x97\x66\x32\xfc\x3d\x61\x22\x91\x29\x6e\xbe\x1d\x5f\x69\x03\xa2\x4d\xa5\x93\xc4\x73\xc9\xfd\xb7\x62\xab\x1d\x8c\xbd\xeb\xd6\xed\x44\x07\xfc\x55\xe0\xdb\x03\x31\xf8\x8a\xad\x87\x60\x62\x5f\x2b\xdb\xe7\x1a\x70\xfc\xbd\xba\x84\xc4\xb2\xd2\x80\xdc\xbe\x62\x2e\x39\xc1\x97\xa3\xa4\x28\x07\xae\xc1\x28\x67\xb9\x54\x8b\x41\x68\x64\x7f\xac\xf5\x72\x2d\x4e\x41\x26\x48\x4a\x65\x35\xc0\x6c\xf1\xa5\x4a\x07\x1e\x40\x4f\x2c\x1c\x84\x7d\xea\x56\x34\x28\x7e\xea\x28\x51\x25\x15\x03\xfd\xbe\x2a\xa2\x34\x09\x29\x0f\xf5\xa0\x52\x3b\xed\x5b\x26\xe6\x64\x4e\x55\x87\x2a\xe8\xf1\xb3\xa7\x3c\x90\xf2\x39\xd7\xbb\xd5\x3b\x6c\x2c\xfd\xd6\x31\x0d\xb4\xeb\xc8\xd2\x14\xa5\x71\x94\xd2\x9f\x0a\x1f\x32\x1f\x4e\x43\x43\x28\x7a\x7d\xb4\xd3\x34\xbe\x98\xfa\xc2\xf8\xec\x58\x65\x18\x9f\x7d\x6b\x0d\xd7\x47\xd9\x19\x6d\x0e\x5a\x39\xdc\x3f\x1e\x2d\x0e\x71\x0e\x2b\x16\x59\xe5\x79\xf0\xc2\xe9\x13\x1d\x34\x74\x37\xd9\xc9\x6e\xe3\x32\xd4\xaf\x36\xd9\xb8\x1f\x7f\xc2\xd6\x9a\xc3\xde\xd9\xba\xf8\xc2\x9f\xf9\x85\xed\xad\xab\x67\xd0\xdf\xd6\xb6\x42\xc1\xfe\xb6\xb6\xbf\xad\xed\x6f\x6b\x7b\x6b\x43\x6f\x6d\xe8\x6f\x6b\x49\x7f\x5b\x7b\x10\x18\x1e\xee\xb6\x16\x45\xbd\x55\x77\xb6\x4e\xd8\xab\x2e\x6c\x9f\xf4\xbe\xd6\x15\xee\x39\x4f\x12\x59\x0a\x73\x27\xef\x59\xeb\x4b\x87\x86\xfc\xbf\x34\x0e\x24\x40\x58\xa3\x0f\x2c\x37\x7e\x32\xe5\xa0\xbb\x54\xd2\x49\xb6\xd8\x45\xaa\xa0\x65\xca\xad\xe4\xbf\x33\x9a\xf9\x01\xe2\xe4\x44\x22\x65\x69\xf5\x83\x3b\xca\xc6\xc2\x7a\x44\xce\x89\x62\x09\x2f\xb8\x2b\x23\x4f\xf1\x3d\x22\x5e\xa8\x8d\xc0\x8d\x66\xd9\xc4\xe5\xa8\x17\x71\xad\x9f\x4a\x7e\x77\x74\x70\xe5\x67\x90\x43\x49\x9f\xc9\xdc\xd7\x42\x52\xec\x6f\x9e\xb5\xb9\xd9\xdc\xc5\x23\xc4\xe6\x15\x58\x4a\xad\xc4\x10\x7c\xac\xe0\x2e\xc0\xfa\xb1\x8f\x3f\xfb\x5c\x70\x05\xc8\x7b\xcb\x12\x29\xda\xd4\x54\x5d\xb3\x41\x4b\x23\x55\xfc\x09\x6c\xa3\x2c\x25\x69\xa9\x42\xcd\xd4\x39\xcd\x78\xca\xcd\x22\xdc\xda\xb9\xf2\x5a\x14\x4f\x4c\xd8\x46\x5d\x81\x91\xd0\xa2\x50\x92\x26\x33\xa6\xa3\xaf\xa1\x80\xe2\x82\xc8\x82\xef\x3b\x96\x80\x03\x19\x05\xfa\x58\x06\x99\x2d\x88\x92\xc6\x5f\xbc\xaf\xf9\xe0\x5d\x34\x18\x74\x47\x2e\x67\xd4\x02\x6e\xe7\x65\x3c\x04\xce\x8a\x4f\xe2\x3f\x34\x91\x59\xea\x53\x98\xfc\xfe\x95\x15\x0a\x13\x87\x83\x96\xf8\x41\x82\x0b\x23\x49\x66\x19\xb6\x25\x88\xeb\x3b\xff\xfa\x37\x64\x26\x4b\xa5\x47\x71\xd2\x81\xd7\xf0\x0e\xf5\x3b\x2f\x54\x1a\x92\x31\xaa\x0d\x79\xfd\x8a\xe4\x5c\x94\x96\x4f\x75\x46\x9b\xee\x72\x50\x24\x01\xfd\xf6\x37\xad\xfb\x75\x95\x7d\xd6\x4a\x3d\x05\xe6\x46\x76\xa2\x8f\x3b\x49\x18\x18\x87\x99\xc5\x1b\x82\x90\x23\xba\x31\xb4\x85\x91\x8f\x70\xbe\x7e\x2c\xe5\x78\x61\xba\x04\x51\xba\x1e\xf5\xe8\xc9\xff\x72\x2f\xdb\x24\x4f\xa9\x72\xa7\x6c\xfc\xe8\xa3\x54\xb8\x98\x72\x6d\xb6\xd4\xb7\xa8\xe2\x2b\x37\x36\x6b\xcf\x56\xa6\x56\x3b\xe8\x18\x2b\x03\x7d\xbc\x44\xec\x6d\x4b\x49\xc2\xb0\x98\xe5\x65\x55\x29\x49\x48\x6c\xbb\x75\xf8\x67\x4e\x38\xe6\x11\xe4\x00\x59\xd3\x5b\x2e\xb5\x9d\xd0\xe5\x51\xa2\xf3\x5a\xb1\x5b\xfd\x14\x68\x2e\xa6\x98\xe4\x3c\x2f\x33\xc3\x8b\xac\x5a\xf7\x47\xdf\xc1\x11\xf2\xd8\xe6\x46\x23\x33\x11\xc5\xc0\x62\xcc\x36\x05\xf6\xc9\x93\x30\x16\x13\x06\x73\x75\x2b\xcb\x0f\x0a\xaa\x68\x00\x1e\x54\xd2\xd5\xa7\xce\x7c\x47\xe1\x46\xd1\xa5\xc3\xb4\xbd\x68\x56\xcd\x38\xba\x45\x3a\x24\xd2\x18\x26\xa8\x68\x61\xaa\xae\xa7\xe7\x82\x4e\x44\x3e\x04\x67\x32\x2c\x83\xd2\xc0\x16\x27\xd4\x7c\x4d\x93\x7b\x26\x52\x2c\x1a\x05\xcb\x4e\x17\x82\xe6\x2e\xdb\x56\x54\x8f\xbb\xd1\x5f\x0f\x9c\x61\x02\xc3\xf7\x7c\x98\x31\x72\xdd\x43\xc2\xa0\xd4\x9d\x53\xd9\xd8\x2e\xdb\xce\xb9\x46\x93\x8d\xe2\xf3\x84\x79\xfe\x6f\xfb\x1d\x72\xea\xf3\x16\xb1\xf4\x4b\x93\xf7\xdb\x13\xe1\x2f\x90\xfb\x60\x39\x87\xa4\x5a\x34\xb3\x47\x7b\x11\x62\x46\x1b\x9b\x3b\x5e\x1c\xb6\xea\x8d\x1a\x77\x89\xfc\x3d\x56\xe3\xb4\x7e\x88\x3f\xd2\x54\x6a\xf2\x75\x26\x93\x7b\x72\xc9\x40\xe8\x7a\xcc\xf2\x2c\x6a\x9c\x3e\x67\x0a\xef\x9c\x4e\xb7\xdd\xb3\x0d\x49\x2e\x05\x37\x52\x6d\xa6\x17\x4f\x57\x76\xb2\x4f\xf7\xbc\x36\x43\x95\xc5\xe6\x97\x9c\xec\xd9\xa2\x5b\xd7\x8d\x87\x4e\x41\x3d\x83\xd3\x89\xaf\x5c\x15\xb0\x1d\xcf\xda\x2f\x66\xf2\x61\x68\xe4\xb0\xd4\x6c\xc8\x5b\x5c\xe8\x76\x58\xe6\x3d\x5b\xc0\x2d\x76\xc7\x85\xba\x6e\x35\x9d\xc1\x48\xb0\x40\xc1\x7b\xcb\xb9\x3f\x7e\x7d\xf9\x49\x33\x35\x8a\x65\xc0\x33\x66\x92\xb3\x84\x15\xb3\x33\x37\xc2\x8b\x04\x8a\x27\x22\x5d\xa1\xe2\xfb\x21\x9b\x49\x64\x96\xb9\xc0\x6c\x39\x21\x17\xac\x98\x85\x81\x9f\x7a\xd5\xcf\x97\x11\xb8\x90\xb2\x6b\x22\xd4\x63\xdb\xa7\x7e\x88\xe0\x0d\x9e\xa1\x08\x99\xd4\xb8\x5b\x11\x8a\xa7\x42\x9f\x17\x5d\x6a\xf3\x11\x81\xf3\xb8\xe9\x94\x8f\x6b\xf9\x94\x63\x7f\xcf\x7a\xb2\x64\xef\x31\x52\x23\x41\xd7\x13\x14\xba\x53\x96\x12\x39\x67\x4a\xf1\x94\x69\x12\x68\x50\xac\xa5\xf2\xec\xa9\xe1\xd6\xe7\x6d\x7e\xf6\xbc\xcd\x3b\xa8\x43\xc7\xa0\x0f\xd5\xc8\x14\xbc\x59\x22\x53\x34\xcd\xb9\x78\x71\x84\x4a\x27\x34\x63\xd7\xdf\x75\xd0\x3f\x5c\x8f\xba\x0a\x72\xeb\x5e\x46\xf9\xd3\xb6\x64\x25\xfb\x36\xe0\x0d\x11\x32\xdd\x66\x52\x7d\x04\x45\x62\x4a\x0d\x7b\xd8\xca\x0e\x87\x15\xa1\xda\xde\x12\x84\xd3\xe7\x54\x39\x5e\x44\x8e\xc0\x08\xe7\x31\xe9\xd9\x21\x99\xaa\xdb\xb5\xae\xc6\x49\xec\x15\xa7\xdf\x6d\x26\xdd\xf5\x18\x7c\x7e\x73\x4d\xbe\xc1\xe6\x87\xcd\x5e\xa8\xa4\x41\x31\xf0\x52\xe6\x94\x77\x2d\xb2\xd1\xec\xde\xcc\xbe\x1a\x2f\xe1\x26\xb4\x25\xae\x71\x54\xc0\x65\xc2\xa7\xa5\xd5\xe9\x9c\x1e\xf6\xa2\x12\xcc\x2d\x89\x2e\x2f\x37\xc1\xdc\xfe\xd5\x20\x22\x93\x93\xf7\x8b\xac\x24\x16\xbf\x95\xc0\x4a\xc2\x1d\x28\xd1\x4c\x68\x0e\x17\x32\xd1\xad\xb8\xab\xf4\x87\xa5\x25\xd1\x09\x12\x45\x9c\x01\x79\x27\xa7\x5c\xf8\xd3\x2b\xdd\x7d\xdd\x84\xf2\xac\x2d\x30\x7a\x99\xe4\xd9\x65\x12\xad\xb3\x2b\x41\xc7\x59\x1b\x77\x83\x3a\xaa\x85\x8e\xe4\x6d\x46\xa7\x84\xc1\x1f\x67\x29\xd7\xf6\xff\xe4\xf6\xf6\x1d\x18\xe1\x4b\xe1\x25\x66\x30\x50\x3b\xda\x17\x82\x14\xf0\x20\x1e\xf6\xec\x20\xe9\xd9\x21\xfb\x5f\xd4\x93\x70\x91\xda\x89\x47\xa5\xe0\xd0\x49\x0a\x5a\x60\x3e\xc4\xe0\xf3\x8b\x6e\x03\x63\x46\xee\x66\x3c\xb9\xbf\x89\xec\xee\x52\xd9\x77\x22\x7a\x55\x63\x60\xcd\xdf\x0e\x49\x2d\xdd\x54\x6f\xba\xab\xc6\x51\x4f\xcf\x07\x3c\xc1\xb8\x75\xeb\x87\xdf\xa8\xd6\x32\xe1\xd5\x9d\x0b\xd8\x68\x2a\xe6\x90\x02\x73\x38\xec\x9a\x40\x3c\xe8\xba\x1c\x94\x3f\x56\x70\x34\xbf\x9b\xbe\x3a\xae\x8e\x39\x18\x17\x7e\xd5\x07\x5d\x02\xe2\xcc\x0e\xa9\xd1\xab\x8e\xcb\xa9\xd1\xbd\x30\xdc\xb8\x58\xf0\x6e\xea\x6e\xf3\xbc\x20\xe6\x6b\x73\x2e\x6d\x5f\x48\x91\xee\x52\x13\x1e\x6c\xe1\x6d\xc2\x36\x56\xa9\xe1\x8d\xdb\x44\x7c\xe7\xae\x1a\xe0\xcc\x15\xb2\x28\x33\xf4\xe7\xd8\x3f\xbf\xbb\xb7\x19\xe3\x77\x0e\x74\xf5\xf0\x14\x59\x4b\x8f\x63\xc7\xde\xee\x9e\xce\x3f\x8d\xdc\xa5\x91\x70\xf7\xea\xb7\xbf\xf9\xcd\x97\x9e\xcd\xb4\xad\x0a\xfe\x18\xe9\x4c\x5b\x9a\x68\x57\xc4\x17\x5d\xf7\xf1\x45\x3f\xdf\xf8\xa2\xc7\xcf\x42\x7b\xe0\x08\xa2\x8e\xbe\xb9\xdd\xfc\x72\xdb\xc7\x08\xb5\xf6\xde\xed\xea\xb9\xdb\x21\x0a\xe8\xb0\xb1\x3f\x9d\x7d\x59\xbb\xc4\xf9\xf4\xd1\x3d\x3f\xd5\xe8\x9e\x5d\x7c\x59\xbb\x47\xf2\x74\xf1\x61\xfd\x29\x46\xed\x74\x38\x9c\xed\xa3\x4b\xf6\x8e\x29\xe9\x9e\x04\xb0\xbb\x3d\x6d\x97\x82\x54\x55\xcf\x95\x1a\xa4\x0f\x2a\xf7\xb9\xc7\x8e\x8f\x75\x94\x5a\xcc\x48\x7b\x02\x9f\x44\x21\x21\x1d\xb4\x31\x1c\x5e\x76\xa9\x0d\xe9\xfa\x7c\x77\xdb\xb8\x98\x09\xaf\x9f\xe7\x3e\xe6\xe7\x70\xe1\xd1\xd7\x74\xf9\x42\x4c\xee\xba\x96\xad\xc5\x5b\x2b\x80\x04\x00\x23\x97\xe3\x38\x4b\x64\x75\x74\xce\x6f\xae\xad\x0e\x0e\x61\x44\x34\xd3\x23\xb2\x82\xcf\x7b\x73\xa9\x93\x0b\x3c\x7f\xa7\xc6\xb0\xbc\x30\xed\x77\xbd\xb7\xb8\x3f\xbb\xc5\xfd\x80\x16\xc0\x59\x99\x53\x31\xb4\x27\x0a\x6c\xee\xb5\xdb\xba\x06\x65\x1e\x11\x77\x76\x90\x3d\x81\x05\x04\x82\x0b\xea\x85\x8d\x69\x54\xe6\xf2\x71\xcc\x9e\x30\xf6\xce\x2b\x47\xbe\xda\x38\x69\x89\x5c\x72\x78\x75\xcb\x09\x50\xf0\x87\x2a\x62\xce\x35\x35\xdc\xcc\x18\xf2\xf0\x1b\x08\xc8\xa9\x5a\xd5\x25\x69\x14\xa5\x69\x96\xc9\x07\xfc\x76\xcc\xd7\x2c\xf4\xed\x5c\x5c\xa4\xd9\x98\x91\x9c\x5b\x1d\xdd\x19\x58\xe3\xe9\xe0\x95\xa9\x95\xc8\x99\x42\x81\x57\xb9\xcb\xb6\x5b\x66\xdc\x46\xc1\x46\x5b\xfd\x56\xa0\x43\xb8\xfd\xb7\xf7\x2a\x82\x6f\x7b\x9a\x30\x66\x33\x3a\xe7\xb2\x54\xd8\xdb\x48\x72\xe4\x7e\x02\xde\xb0\x90\x65\xb0\x77\x61\x31\xcc\xb0\x3a\xbd\x02\x4e\x1f\xaa\x1f\x41\x15\x48\xa5\x37\x4d\x0c\xd9\x67\xae\xcd\xf2\x5a\x3c\x88\x7c\x1a\xbc\x43\xe1\xcd\x5c\x17\x96\x2d\x74\xae\x6a\x57\xeb\x57\x97\x57\xe6\xb7\xf0\xd3\x17\x54\xd3\x6e\x6b\x76\xd7\x27\x13\x81\x7e\x86\xe2\x4f\xb8\x09\xcb\x78\xb2\xe8\x5c\xee\xad\xd1\xdb\x13\x6d\x1d\xee\xd0\xec\x7b\xf2\x35\xd5\x2c\x25\xef\xa9\xa0\x53\xd4\xf7\x4e\x6e\x6f\xbe\x7e\x7f\x6a\xf7\x15\xf4\xc9\xeb\xcb\x95\x17\x6d\xb7\xf1\xe0\x1f\x0e\x19\x2f\xb2\xb4\xf0\x1d\x58\xd5\x52\xff\x1d\x17\x7f\xd0\x40\x18\x12\xf8\x50\xbb\x64\xbd\x2b\x58\xd0\x4d\x33\x84\xb5\x59\xf3\xb3\x41\x60\xe6\x79\xba\x67\x95\x4f\x2e\xb4\xa1\x59\x76\x93\x51\x71\x5e\x14\x4a\xce\x57\x6b\xe3\xb5\xb9\xfa\x86\x7e\xa6\xe8\xe6\xe1\x5f\x16\x08\x7a\xb8\xc2\x16\xe4\xba\x1a\x7f\x44\xae\x4d\xd0\xc2\xa5\x00\x96\x7a\x74\x5e\x1a\x99\x53\xc3\x93\x23\xab\xac\x1f\xbd\xa7\xa2\xa4\xd9\x4a\xa7\xab\x8d\xcb\x58\x27\x22\x6e\xec\xb4\x3e\x75\x5d\x8b\x6e\x1b\x65\x8d\xcd\xfd\x0d\x55\x96\x3a\x5d\xdc\x7e\xdf\xa9\xaf\x36\xd4\x94\x4b\x54\x78\x03\x67\x58\xcf\x0b\x86\x24\xa3\xda\x7c\x2a\x52\x7b\xe8\x1b\xbf\x6e\x22\xf8\x09\x35\x34\x93\xd3\x3f\x31\x9a\xad\xc6\xf0\x1a\x9e\x5c\xc4\xad\xbd\x01\xca\x5d\xf8\x97\xe3\xd0\xf0\x58\x13\x2b\x60\xfb\x18\x78\xc5\x32\x36\xa7\xc2\xf8\xee\x58\x5c\x5d\x1f\xbb\xf5\x03\x16\xf1\xca\xf8\x9a\x32\xc3\x54\xce\x45\x7d\xcc\x5b\x68\x7b\x21\x45\xca\xd1\xec\x08\x06\x35\xec\x51\x1f\x77\x3d\xaa\xad\xbb\x69\xd8\x70\xb7\x50\xcf\xae\x19\xcd\xa7\x0e\x0a\x6c\x36\x76\xf2\xe5\x0c\x5f\xc2\x4d\x7b\x6d\x6e\x4b\x90\x22\xf7\xc2\x0a\x86\x90\x47\x64\x35\xd9\xda\x2a\x27\x6c\x93\x0f\x86\x7e\x8f\x71\x0a\xeb\x1d\x47\x87\x6e\xde\xeb\xee\x20\x36\xa1\x18\x3e\xdb\x25\x8b\xe6\x54\xd6\xd3\xd4\x55\x78\x17\xba\x61\x24\x4b\xa3\x20\x7f\xad\xd1\x7a\x1e\xd0\x4a\xf0\x6a\x27\x23\xb5\xcd\x6a\x5f\xa7\xb5\x55\x0e\xf6\x25\x55\xb6\x85\xc4\xb8\x95\x69\xb5\x4c\x2e\x5f\x57\xac\xaf\x9d\xff\x9f\x72\xaa\x08\x25\x05\x67\x98\xfc\x84\x0a\x07\x2c\xe0\x2c\x8c\xa6\xee\xa5\xe5\x60\x56\x25\x84\xdf\x06\xee\x32\x1c\x8d\xcb\xce\xd7\xc2\x1b\xa8\x29\x26\xff\x80\x8b\x8b\xb3\x6f\xa4\x33\xf2\xba\x20\x5d\x4b\x03\x80\x93\x0f\x88\x2e\x93\x19\xa1\xda\x4e\xcd\x22\xb4\x3d\xf1\x6c\x94\x53\xc1\x27\x4c\x9b\x51\xc8\x12\xac\xff\xfc\xeb\xbf\x8c\xc8\x5b\xa9\x88\x73\x54\x1f\xf8\xac\x1a\x6e\x9e\x15\x5e\x70\x8d\x8b\x09\x7d\x2b\xad\xb5\x90\xa9\x9b\xf4\x03\x4c\xd6\xd0\x7b\xcb\xc3\x70\xb2\x25\x83\xab\x8b\x37\xe4\xc8\x8a\x89\xd1\xa7\xff\x61\xd9\xd2\xbf\x8e\xc8\xc9\x03\x30\xed\x23\xfb\xe7\x11\x7e\x30\xb8\x4d\xc6\x4a\x75\xf5\x61\x0c\x96\x54\x7c\x3a\x65\x0a\xd5\x47\x02\x41\x85\xa7\x2e\x2b\x88\x90\x51\x63\x7f\x29\x5d\xa9\x9b\xcd\x89\xfc\xf9\xd7\x7f\x39\x22\x27\xf5\x75\x11\x2e\x52\xf6\x99\xfc\x1a\xad\xcb\x5c\xdb\x35\x9e\xba\xcb\x1c\xbd\x10\x86\x7e\xb6\x63\x26\x33\xa9\x99\x40\x55\xde\x48\x32\xa3\x73\x46\xb4\xb4\x1a\x30\xcb\xb2\xa1\xb3\xa5\x93\x07\x0a\x99\x5a\x3c\x28\x21\xb0\x9e\x14\x54\x99\x1a\x4a\x8c\x9c\x85\x04\xbe\x66\xb7\x6d\x2a\xfc\xcd\xf4\x84\x0b\x77\x7f\xe5\x6e\xce\xec\x9e\x43\x60\x28\x6e\x92\x91\x24\x99\x51\x31\x0d\xb1\xe9\x93\xd2\x94\x8a\x6d\xb9\xfa\x69\x79\x06\xee\xb9\xe8\x14\xc2\xfc\x2d\x17\x4d\xa7\x82\xd5\x76\xa5\x29\x37\x3e\x2a\xc2\xf9\x2a\x9a\xc5\x99\xdd\x05\xc5\xc7\xa5\x91\x4a\x9f\xa5\x6c\xce\xb2\x33\xcd\xa7\x43\xaa\x92\x19\x37\x2c\xb1\xcb\x3a\xa3\x05\x1f\x26\x52\xd8\x1d\x87\xac\x0c\x79\xfa\x0b\x28\x6f\x3a\xb4\x53\xdd\x92\x75\xba\xe5\xa2\xb7\x1b\xd5\x9e\xd5\x98\x76\xb0\x35\xb6\xb0\x07\x2d\x2f\x14\x6d\x33\x4f\xb0\x5a\x30\x84\x9c\x1d\x64\xb1\x3e\x69\x72\x77\x1e\x73\xec\xf2\x80\x27\xcd\x31\xec\xb1\x43\x07\x12\x38\x95\x35\x4a\x99\xd3\x14\x49\x29\x15\x8b\x47\x47\x7e\x0b\x52\x48\x97\x9f\x2c\x86\x30\x84\xcc\x86\x54\xa4\xf6\xdf\x18\xb0\x93\x2c\x0e\x02\xc3\x92\x77\x22\x04\x9f\xae\x2f\x9f\xe6\x48\x94\xfc\x00\xa7\xde\xc9\x6b\x2d\x85\x28\x14\x55\xd1\x51\x43\x95\xcc\x33\xcd\xba\x80\xca\xb5\x1f\xf5\x3f\xdc\xfd\x4b\xc8\x76\xb6\x4d\xa4\xda\x7c\x6b\x12\xc9\x8e\x2d\xe7\xfb\xae\xea\x11\xdb\xe4\xc0\xf1\x8a\x6a\xe3\x52\x6b\xf9\x1c\x04\xb5\x65\x78\x05\x05\x18\xcc\xfa\x8b\xe1\x56\x38\xe4\xfd\x05\xec\x44\x86\x2b\x73\x2e\x25\x41\x29\xd9\xae\x40\x55\xfa\x4b\xad\x0e\x1a\x2e\xca\x30\x6d\x08\x9d\x53\x9e\x81\x75\x5e\x8e\x35\x53\x73\x2c\x48\xe5\x52\x0d\xd2\xa6\x9e\xe5\x6a\x4e\xa0\x18\xf5\x44\x9a\x8f\x5f\xc3\xf2\xae\x6c\x5a\x00\x68\x43\x8d\xd9\xaf\x9d\xf5\x41\xf4\x1e\x54\x2f\xd7\xfe\x6c\xbf\xb0\xa3\x1a\x63\xf1\xef\x4f\x8c\x2a\x33\x66\xd4\xdc\xf1\x4d\x7c\x77\x09\xa5\x6b\xfd\x42\x29\xf7\x80\xd0\x0f\x8c\x4c\xa5\xb1\x22\x56\x09\xb8\x8f\x32\x29\x26\xf5\x09\x88\xf6\xd8\x18\x5d\xad\xf2\x4e\x51\x08\xf1\x91\xa2\xe3\x32\xeb\x1d\x97\xd7\xe9\xa4\x63\x87\x49\x06\x5b\x63\x22\x0d\x29\x98\xdb\x3b\xbc\xcd\x00\x0a\xf4\x34\x4b\xce\x99\xd6\x1b\x13\x6c\xd4\xbd\x0b\xb1\x35\x1e\xe5\xc6\xd5\x5a\xee\x7f\xc3\xb0\x10\x2b\x40\xa7\xcc\x50\x9e\xf9\xa3\x8c\xa0\x08\x50\xda\x46\x5d\x37\x2e\x50\x31\xaa\x37\x09\x08\xb5\x59\x7f\x84\xc6\x38\x69\x29\xd8\xf0\x41\xaa\x94\x5c\xd0\x9c\x65\x17\x54\x33\x37\x56\x1c\xa2\x87\x7b\x74\xac\x0f\x3a\xe5\xd5\xb6\xaf\x35\x53\x46\xe3\x4f\x65\x12\x86\xbf\x2a\x15\x0b\x27\x38\xf0\x26\xc8\x3b\x55\xb2\x01\x79\x6b\xb9\xd7\x80\x7c\x12\xf7\x42\x3e\xec\x37\x57\xb3\xf1\x16\xa4\x36\xd3\xd8\xfd\xc3\xa7\xd5\xa9\x19\x7c\xc2\x74\x77\x9c\x91\x23\xf8\x6b\x4c\x8d\x75\x66\x13\x9a\xfa\x19\xd9\x7f\x2e\x99\xa0\xac\xa2\xa8\xe4\x54\x31\x8d\x99\x6b\x56\x26\x49\x6c\x6b\x72\xfe\x86\x09\x17\xdc\xb7\x75\x7a\xd7\xab\x7a\xf9\x99\x7a\xbe\x36\xad\x7e\x71\xfb\xed\x3e\x56\x64\x2b\x45\x8d\xcd\x1e\x81\xd1\x44\xd7\x18\x9f\xd6\xcd\x70\xb5\xd1\x29\xe2\x7a\x51\x5b\x14\x4a\x36\x59\x47\xfd\xea\x2e\x6e\xbf\x5f\x0f\xec\xb5\xbc\x6f\x1b\x7f\xda\x6e\x96\xda\xd7\x20\xb5\xf5\xcc\x6c\x35\x42\xf5\xe6\xa7\xde\xfc\xf4\x25\x99\x9f\xb6\x62\xfc\x26\x93\xd3\x97\x61\x6c\xda\xba\xc4\x4d\x06\xa6\x17\x69\x5a\x6a\xb5\xa2\x8d\xe6\xa4\x17\x6b\x48\xda\xba\xb4\x96\xc6\xa3\x9f\x8f\xd9\x68\x2b\xc4\x36\x98\x8a\x5e\xa0\x91\xa8\x8d\x40\xc6\xd2\x36\x62\xe2\x75\xd4\x38\x16\x14\xab\x72\x96\x61\x38\xef\x94\x13\x8b\x33\xbb\x4a\x8b\x56\x80\xdb\x3a\xb7\x63\x37\xb9\xf6\xb2\x97\x13\x18\x5d\xb1\xc7\xa5\xc9\x92\xcb\xab\x9b\x8f\x57\x17\xe7\x77\x57\x97\x4d\xf9\x6e\x15\xa4\xb7\x48\x62\x9b\x6d\x10\xc3\x48\x12\x5b\xd3\xc0\x12\xe4\x35\x3f\x59\x1c\x58\xf3\x53\x59\xf2\x55\xbd\xf6\x97\x0b\xf7\xe2\x72\x7b\xf1\x8f\xed\xa7\xb3\xed\xf1\xfc\x84\x8e\x53\xd4\xf9\x9c\x59\xb9\x67\x26\xb3\x54\x7b\xbf\xd5\xeb\xcb\x10\x49\xc5\x45\x92\x95\xa9\x15\x2e\x3e\x7d\xba\xbe\xd4\x23\x42\xbe\x66\x09\x2d\x35\x58\x61\x52\x29\x8e\x0d\xf9\xee\xc3\xbb\xff\x06\x7f\x6c\x68\x31\x08\x79\x4d\x20\x2b\x2f\xa7\x98\x58\xd8\x60\xba\x36\xf2\x35\x43\x41\x05\xbe\x9c\xd0\xc2\x52\x31\x8d\x95\x2b\x0c\xc8\x22\x33\x96\x15\x96\x62\xde\x33\x52\x65\x50\xb5\x03\x57\x15\xe6\xbd\xfb\xe4\x94\x19\x8c\xba\xda\xe4\x21\xb9\x11\x6a\x5b\x2c\xae\x7b\xd8\x5a\x6b\xea\xa3\xd3\xc6\x1f\xa8\x76\x16\xab\x95\xb3\xdd\xb2\xbf\xdb\xed\x33\xeb\x4d\x1c\x6b\x8c\x1b\x48\x9e\xe1\xaf\xa5\x39\xdb\xc9\x56\x76\x0c\x74\x22\xe1\xa6\xb5\x35\x75\xbd\x1b\xd0\xea\x3a\x00\x4b\xb6\x0c\xd6\x04\x72\xed\xc3\xc1\x23\x3b\x9a\x72\xbb\xb9\x40\x11\x91\xb4\x56\xfb\xd3\xf9\xcf\xd5\xdf\x95\xe3\x50\xfd\xb5\x9a\xaf\xb3\xc8\x90\x7f\xfc\xeb\xab\xff\x3f\x00\x00\xff\xff\x01\xa8\x18\xd1\x2e\x5c\x02\x00") func operatorsCoreosCom_subscriptionsYamlBytes() ([]byte, error) { return bindataRead( diff --git a/staging/api/pkg/operators/v1alpha1/subscription_types.go b/staging/api/pkg/operators/v1alpha1/subscription_types.go index e048d4988c..900cc46577 100644 --- a/staging/api/pkg/operators/v1alpha1/subscription_types.go +++ b/staging/api/pkg/operators/v1alpha1/subscription_types.go @@ -84,6 +84,12 @@ type SubscriptionConfig struct { // List of VolumeMounts to set in the container. // +optional VolumeMounts []corev1.VolumeMount `json:"volumeMounts,omitempty"` + + // If specified, overrides the pod's scheduling constraints. + // nil sub-attributes will *not* override the original values in the pod.spec for those sub-attributes. + // Use empty object ({}) to erase original sub-attribute values. + // +optional + Affinity *corev1.Affinity `json:"affinity,omitempty" protobuf:"bytes,18,opt,name=affinity"` } // SubscriptionConditionType indicates an explicit state condition about a Subscription in "abnormal-true" diff --git a/staging/api/pkg/operators/v1alpha1/zz_generated.deepcopy.go b/staging/api/pkg/operators/v1alpha1/zz_generated.deepcopy.go index c094738eed..e26ddea616 100644 --- a/staging/api/pkg/operators/v1alpha1/zz_generated.deepcopy.go +++ b/staging/api/pkg/operators/v1alpha1/zz_generated.deepcopy.go @@ -1394,6 +1394,11 @@ func (in *SubscriptionConfig) DeepCopyInto(out *SubscriptionConfig) { (*in)[i].DeepCopyInto(&(*out)[i]) } } + if in.Affinity != nil { + in, out := &in.Affinity, &out.Affinity + *out = new(v1.Affinity) + (*in).DeepCopyInto(*out) + } } // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SubscriptionConfig. diff --git a/staging/operator-lifecycle-manager/Dockerfile b/staging/operator-lifecycle-manager/Dockerfile index 961037796a..b28073b651 100644 --- a/staging/operator-lifecycle-manager/Dockerfile +++ b/staging/operator-lifecycle-manager/Dockerfile @@ -33,6 +33,7 @@ COPY --from=builder /build/bin/olm /bin/olm COPY --from=builder /build/bin/catalog /bin/catalog COPY --from=builder /build/bin/package-server /bin/package-server COPY --from=builder /build/bin/cpb /bin/cpb +USER 1001 EXPOSE 8080 EXPOSE 5443 CMD ["/bin/olm"] diff --git a/staging/operator-lifecycle-manager/Dockerfile.goreleaser b/staging/operator-lifecycle-manager/Dockerfile.goreleaser index 6a3238d015..a117f6623e 100644 --- a/staging/operator-lifecycle-manager/Dockerfile.goreleaser +++ b/staging/operator-lifecycle-manager/Dockerfile.goreleaser @@ -10,4 +10,5 @@ COPY package-server /bin/package-server COPY cpb /bin/cpb EXPOSE 8080 EXPOSE 5443 +USER 1001 ENTRYPOINT ["/bin/olm"] diff --git a/staging/operator-lifecycle-manager/OWNERS b/staging/operator-lifecycle-manager/OWNERS index b50656f1c4..a8513ce6dd 100644 --- a/staging/operator-lifecycle-manager/OWNERS +++ b/staging/operator-lifecycle-manager/OWNERS @@ -9,6 +9,7 @@ approvers: - dinhxuanvu - timflannagan - perdasilva + - grokspawn # review == this code is good /lgtm reviewers: - ecordell @@ -24,5 +25,6 @@ reviewers: - joelanford - timflannagan - perdasilva -# Bugzilla component -component: "OLM" + - akihikokuroda + - oceanc80 + - grokspawn diff --git a/staging/operator-lifecycle-manager/cmd/catalog/main.go b/staging/operator-lifecycle-manager/cmd/catalog/main.go index ead86cd763..20134d71d2 100644 --- a/staging/operator-lifecycle-manager/cmd/catalog/main.go +++ b/staging/operator-lifecycle-manager/cmd/catalog/main.go @@ -30,6 +30,7 @@ const ( defaultOPMImage = "quay.io/operator-framework/upstream-opm-builder:latest" defaultUtilImage = "quay.io/operator-framework/olm:latest" defaultOperatorName = "" + defaultWorkLoadUserID = int64(1001) ) // config flags defined globally so that they appear on the test binary as well @@ -83,6 +84,10 @@ func (o *options) run(ctx context.Context, logger *logrus.Logger) error { return fmt.Errorf("error configuring client: %s", err.Error()) } + workloadUserID := int64(-1) + if o.setWorkloadUserID { + workloadUserID = defaultWorkLoadUserID + } // TODO(tflannag): Use options pattern for catalog operator // Create a new instance of the operator. op, err := catalog.NewOperator( @@ -98,6 +103,7 @@ func (o *options) run(ctx context.Context, logger *logrus.Logger) error { k8sscheme.Scheme, o.installPlanTimeout, o.bundleUnpackTimeout, + workloadUserID, ) if err != nil { return fmt.Errorf("error configuring catalog operator: %s", err.Error()) diff --git a/staging/operator-lifecycle-manager/cmd/catalog/start.go b/staging/operator-lifecycle-manager/cmd/catalog/start.go index 45a0953c08..7161131880 100644 --- a/staging/operator-lifecycle-manager/cmd/catalog/start.go +++ b/staging/operator-lifecycle-manager/cmd/catalog/start.go @@ -25,6 +25,7 @@ type options struct { tlsKeyPath string tlsCertPath string clientCAPath string + setWorkloadUserID bool installPlanTimeout time.Duration bundleUnpackTimeout time.Duration @@ -66,6 +67,7 @@ func newRootCmd() *cobra.Command { cmd.Flags().StringVar(&o.opmImage, "opmImage", defaultOPMImage, "the image to use for unpacking bundle content with opm") cmd.Flags().StringVar(&o.utilImage, "util-image", defaultUtilImage, "an image containing custom olm utilities") cmd.Flags().StringVar(&o.writeStatusName, "writeStatusName", defaultOperatorName, "ClusterOperator name in which to write status, set to \"\" to disable.") + cmd.Flags().BoolVar(&o.setWorkloadUserID, "set-workload-user-id", false, "set user ID for all workloads (registry pods/bundle unpack jobs to default 1001") cmd.Flags().BoolVar(&o.debug, "debug", false, "use debug log level") cmd.Flags().BoolVar(&o.version, "version", false, "displays the olm version") diff --git a/staging/operator-lifecycle-manager/deploy/chart/crds/0000_50_olm_00-subscriptions.crd.yaml b/staging/operator-lifecycle-manager/deploy/chart/crds/0000_50_olm_00-subscriptions.crd.yaml index 7bcc8c94f1..3523401502 100644 --- a/staging/operator-lifecycle-manager/deploy/chart/crds/0000_50_olm_00-subscriptions.crd.yaml +++ b/staging/operator-lifecycle-manager/deploy/chart/crds/0000_50_olm_00-subscriptions.crd.yaml @@ -63,6 +63,467 @@ spec: description: SubscriptionConfig contains configuration specified for a subscription. type: object properties: + affinity: + description: If specified, overrides the pod's scheduling constraints. nil sub-attributes will *not* override the original values in the pod.spec for those sub-attributes. Use empty object ({}) to erase original sub-attribute values. + type: object + properties: + nodeAffinity: + description: Describes node affinity scheduling rules for the pod. + type: object + properties: + preferredDuringSchedulingIgnoredDuringExecution: + description: The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred. + type: array + items: + description: An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op). + type: object + required: + - preference + - weight + properties: + preference: + description: A node selector term, associated with the corresponding weight. + type: object + properties: + matchExpressions: + description: A list of node selector requirements by node's labels. + type: array + items: + description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: The label key that the selector applies to. + type: string + operator: + description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. + type: string + values: + description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchFields: + description: A list of node selector requirements by node's fields. + type: array + items: + description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: The label key that the selector applies to. + type: string + operator: + description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. + type: string + values: + description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch. + type: array + items: + type: string + weight: + description: Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100. + type: integer + format: int32 + requiredDuringSchedulingIgnoredDuringExecution: + description: If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node. + type: object + required: + - nodeSelectorTerms + properties: + nodeSelectorTerms: + description: Required. A list of node selector terms. The terms are ORed. + type: array + items: + description: A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm. + type: object + properties: + matchExpressions: + description: A list of node selector requirements by node's labels. + type: array + items: + description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: The label key that the selector applies to. + type: string + operator: + description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. + type: string + values: + description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchFields: + description: A list of node selector requirements by node's fields. + type: array + items: + description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: The label key that the selector applies to. + type: string + operator: + description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. + type: string + values: + description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch. + type: array + items: + type: string + podAffinity: + description: Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)). + type: object + properties: + preferredDuringSchedulingIgnoredDuringExecution: + description: The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. + type: array + items: + description: The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s) + type: object + required: + - podAffinityTerm + - weight + properties: + podAffinityTerm: + description: Required. A pod affinity term, associated with the corresponding weight. + type: object + required: + - topologyKey + properties: + labelSelector: + description: A label query over a set of resources, in this case pods. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaceSelector: + description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaces: + description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace". + type: array + items: + type: string + topologyKey: + description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. + type: string + weight: + description: weight associated with matching the corresponding podAffinityTerm, in the range 1-100. + type: integer + format: int32 + requiredDuringSchedulingIgnoredDuringExecution: + description: If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied. + type: array + items: + description: Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running + type: object + required: + - topologyKey + properties: + labelSelector: + description: A label query over a set of resources, in this case pods. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaceSelector: + description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaces: + description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace". + type: array + items: + type: string + topologyKey: + description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. + type: string + podAntiAffinity: + description: Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)). + type: object + properties: + preferredDuringSchedulingIgnoredDuringExecution: + description: The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. + type: array + items: + description: The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s) + type: object + required: + - podAffinityTerm + - weight + properties: + podAffinityTerm: + description: Required. A pod affinity term, associated with the corresponding weight. + type: object + required: + - topologyKey + properties: + labelSelector: + description: A label query over a set of resources, in this case pods. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaceSelector: + description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaces: + description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace". + type: array + items: + type: string + topologyKey: + description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. + type: string + weight: + description: weight associated with matching the corresponding podAffinityTerm, in the range 1-100. + type: integer + format: int32 + requiredDuringSchedulingIgnoredDuringExecution: + description: If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied. + type: array + items: + description: Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running + type: object + required: + - topologyKey + properties: + labelSelector: + description: A label query over a set of resources, in this case pods. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaceSelector: + description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaces: + description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace". + type: array + items: + type: string + topologyKey: + description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. + type: string env: description: Env is a list of environment variables to set in the container. Cannot be updated. type: array diff --git a/staging/operator-lifecycle-manager/deploy/chart/templates/0000_50_olm_00-namespace.yaml b/staging/operator-lifecycle-manager/deploy/chart/templates/0000_50_olm_00-namespace.yaml index d42268a59b..1ee5727899 100644 --- a/staging/operator-lifecycle-manager/deploy/chart/templates/0000_50_olm_00-namespace.yaml +++ b/staging/operator-lifecycle-manager/deploy/chart/templates/0000_50_olm_00-namespace.yaml @@ -2,9 +2,19 @@ apiVersion: v1 kind: Namespace metadata: name: {{ .Values.namespace }} + labels: + {{- if .Values.namespace_psa }} + pod-security.kubernetes.io/enforce: {{ .Values.namespace_psa.enforceLevel }} + pod-security.kubernetes.io/enforce-version: {{ .Values.namespace_psa.enforceVersion }} + {{- end }} --- apiVersion: v1 kind: Namespace metadata: name: {{ .Values.operator_namespace }} + labels: + {{- if .Values.operator_namespace_psa }} + pod-security.kubernetes.io/enforce: {{ .Values.operator_namespace_psa.enforceLevel }} + pod-security.kubernetes.io/enforce-version: {{ .Values.operator_namespace_psa.enforceVersion }} + {{- end }} diff --git a/staging/operator-lifecycle-manager/deploy/chart/templates/0000_50_olm_07-olm-operator.deployment.yaml b/staging/operator-lifecycle-manager/deploy/chart/templates/0000_50_olm_07-olm-operator.deployment.yaml index b71fbebd0d..825d39f0df 100644 --- a/staging/operator-lifecycle-manager/deploy/chart/templates/0000_50_olm_07-olm-operator.deployment.yaml +++ b/staging/operator-lifecycle-manager/deploy/chart/templates/0000_50_olm_07-olm-operator.deployment.yaml @@ -17,6 +17,10 @@ spec: labels: app: olm-operator spec: + securityContext: + runAsNonRoot: true + seccompProfile: + type: RuntimeDefault serviceAccountName: olm-operator-serviceaccount {{- if or .Values.olm.tlsSecret .Values.olm.clientCASecret }} volumes: @@ -33,6 +37,10 @@ spec: {{- end }} containers: - name: olm-operator + securityContext: + allowPrivilegeEscalation: false + capabilities: + drop: [ "ALL" ] {{- if or .Values.olm.tlsSecret .Values.olm.clientCASecret }} volumeMounts: {{- end }} diff --git a/staging/operator-lifecycle-manager/deploy/chart/templates/0000_50_olm_08-catalog-operator.deployment.yaml b/staging/operator-lifecycle-manager/deploy/chart/templates/0000_50_olm_08-catalog-operator.deployment.yaml index e71ffb38b1..48e882d4ee 100644 --- a/staging/operator-lifecycle-manager/deploy/chart/templates/0000_50_olm_08-catalog-operator.deployment.yaml +++ b/staging/operator-lifecycle-manager/deploy/chart/templates/0000_50_olm_08-catalog-operator.deployment.yaml @@ -17,6 +17,10 @@ spec: labels: app: catalog-operator spec: + securityContext: + runAsNonRoot: true + seccompProfile: + type: RuntimeDefault serviceAccountName: olm-operator-serviceaccount {{- if or .Values.catalog.tlsSecret .Values.catalog.clientCASecret }} volumes: @@ -33,6 +37,10 @@ spec: {{- end }} containers: - name: catalog-operator + securityContext: + allowPrivilegeEscalation: false + capabilities: + drop: [ "ALL" ] {{- if or .Values.catalog.tlsSecret .Values.catalog.clientCASecret }} volumeMounts: {{- end }} @@ -76,6 +84,11 @@ spec: - --client-ca - /profile-collector-cert/tls.crt {{- end }} + {{- if eq .Values.catalog.setWorkloadUserID true }} + - --set-workload-user-id=true + {{- else }} + - --set-workload-user-id=false + {{ end }} image: {{ .Values.catalog.image.ref }} imagePullPolicy: {{ .Values.catalog.image.pullPolicy }} ports: diff --git a/staging/operator-lifecycle-manager/deploy/chart/templates/_packageserver.deployment-spec.yaml b/staging/operator-lifecycle-manager/deploy/chart/templates/_packageserver.deployment-spec.yaml index 6121a85bb5..75cdc5b508 100644 --- a/staging/operator-lifecycle-manager/deploy/chart/templates/_packageserver.deployment-spec.yaml +++ b/staging/operator-lifecycle-manager/deploy/chart/templates/_packageserver.deployment-spec.yaml @@ -14,6 +14,10 @@ spec: labels: app: packageserver spec: + securityContext: + runAsNonRoot: true + seccompProfile: + type: RuntimeDefault serviceAccountName: olm-operator-serviceaccount {{- if .Values.package.nodeSelector }} nodeSelector: @@ -25,6 +29,10 @@ spec: {{- end }} containers: - name: packageserver + securityContext: + allowPrivilegeEscalation: false + capabilities: + drop: [ "ALL" ] command: - /bin/package-server - -v=4 @@ -61,10 +69,6 @@ spec: resources: {{ toYaml .Values.package.resources | indent 10 }} {{- end }} - {{- if .Values.package.securityContext }} - securityContext: - runAsUser: {{ .Values.package.securityContext.runAsUser }} - {{- end }} volumeMounts: - name: tmpfs mountPath: /tmp diff --git a/staging/operator-lifecycle-manager/deploy/chart/values.yaml b/staging/operator-lifecycle-manager/deploy/chart/values.yaml index cf4706edc8..be60b34593 100644 --- a/staging/operator-lifecycle-manager/deploy/chart/values.yaml +++ b/staging/operator-lifecycle-manager/deploy/chart/values.yaml @@ -1,7 +1,15 @@ rbacApiVersion: rbac.authorization.k8s.io namespace: operator-lifecycle-manager +# see https://kubernetes.io/docs/concepts/security/pod-security-admission/ for more details +namespace_psa: + enforceLevel: restricted + enforceVersion: latest catalog_namespace: operator-lifecycle-manager operator_namespace: operators +# see https://kubernetes.io/docs/concepts/security/pod-security-admission/ for more details +operator_namespace_psa: + enforceLevel: baseline + enforceVersion: latest minKubeVersion: 1.11.0 writeStatusName: '""' imagestream: false @@ -25,6 +33,7 @@ olm: memory: 160Mi catalog: + setWorkloadUserID: true replicaCount: 1 commandArgs: --configmapServerImage=quay.io/operator-framework/configmap-operator-registry:latest image: diff --git a/staging/operator-lifecycle-manager/deploy/upstream/values.yaml b/staging/operator-lifecycle-manager/deploy/upstream/values.yaml index ccfa1e0166..dbe19f2296 100644 --- a/staging/operator-lifecycle-manager/deploy/upstream/values.yaml +++ b/staging/operator-lifecycle-manager/deploy/upstream/values.yaml @@ -1,8 +1,16 @@ installType: upstream rbacApiVersion: rbac.authorization.k8s.io namespace: olm +# see https://kubernetes.io/docs/concepts/security/pod-security-admission/ for more details +namespace_psa: + enforceLevel: restricted + enforceVersion: latest catalog_namespace: olm operator_namespace: operators +# see https://kubernetes.io/docs/concepts/security/pod-security-admission/ for more details +operator_namespace_psa: + enforceLevel: baseline + enforceVersion: latest imagestream: false writeStatusName: '""' writePackageServerStatusName: "" @@ -14,6 +22,7 @@ olm: service: internalPort: 8080 catalog: + setWorkloadUserID: true replicaCount: 1 image: ref: quay.io/operator-framework/olm@sha256:e74b2ac57963c7f3ba19122a8c31c9f2a0deb3c0c5cac9e5323ccffd0ca198ed diff --git a/staging/operator-lifecycle-manager/e2e.Dockerfile b/staging/operator-lifecycle-manager/e2e.Dockerfile index 6428974668..4f450f2d9a 100644 --- a/staging/operator-lifecycle-manager/e2e.Dockerfile +++ b/staging/operator-lifecycle-manager/e2e.Dockerfile @@ -3,4 +3,5 @@ FROM busybox COPY olm catalog package-server wait cpb /bin/ EXPOSE 8080 EXPOSE 5443 +USER 1001 CMD ["/bin/olm"] diff --git a/staging/operator-lifecycle-manager/go.mod b/staging/operator-lifecycle-manager/go.mod index 8ce2e89a0a..fd86bb7a08 100644 --- a/staging/operator-lifecycle-manager/go.mod +++ b/staging/operator-lifecycle-manager/go.mod @@ -24,7 +24,7 @@ require ( github.com/onsi/gomega v1.18.1 github.com/openshift/api v0.0.0-20200331152225-585af27e34fd github.com/openshift/client-go v0.0.0-20200326155132-2a6cd50aedd0 - github.com/operator-framework/api v0.15.0 + github.com/operator-framework/api v0.16.0 github.com/operator-framework/operator-registry v1.17.5 github.com/otiai10/copy v1.2.0 github.com/pkg/errors v0.9.1 diff --git a/staging/operator-lifecycle-manager/go.sum b/staging/operator-lifecycle-manager/go.sum index ce37514c1a..f571581867 100644 --- a/staging/operator-lifecycle-manager/go.sum +++ b/staging/operator-lifecycle-manager/go.sum @@ -1078,8 +1078,8 @@ github.com/openshift/client-go v0.0.0-20200326155132-2a6cd50aedd0/go.mod h1:uUQ4 github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= github.com/openzipkin/zipkin-go v0.1.6/go.mod h1:QgAqvLzwWbR/WpD4A3cGpPtJrZXNIiJc5AZX7/PBEpw= github.com/operator-framework/api v0.7.1/go.mod h1:L7IvLd/ckxJEJg/t4oTTlnHKAJIP/p51AvEslW3wYdY= -github.com/operator-framework/api v0.15.0 h1:4f9i0drtqHj7ykLoHxv92GR43S7MmQHhmFQkfm5YaGI= -github.com/operator-framework/api v0.15.0/go.mod h1:scnY9xqSeCsOdtJtNoHIXd7OtHZ14gj1hkDA4+DlgLY= +github.com/operator-framework/api v0.16.0 h1:swUOhVv7QDszxBTwYM8QAtyeqI4EQHNVAiKMS+xjakY= +github.com/operator-framework/api v0.16.0/go.mod h1:kk8xJahHJR3bKqrA+A+1VIrhOTmyV76k+ARv+iV+u1Q= github.com/operator-framework/operator-registry v1.17.5 h1:LR8m1rFz5Gcyje8WK6iYt+gIhtzqo52zMRALdmTYHT0= github.com/operator-framework/operator-registry v1.17.5/go.mod h1:sRQIgDMZZdUcmHltzyCnM6RUoDF+WS8Arj1BQIARDS8= github.com/otiai10/copy v1.2.0 h1:HvG945u96iNadPoG2/Ja2+AUJeW5YuFQMixq9yirC+k= diff --git a/staging/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker.go b/staging/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker.go index 55665aada6..bf797ba1fd 100644 --- a/staging/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker.go +++ b/staging/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker.go @@ -22,6 +22,7 @@ import ( listersbatchv1 "k8s.io/client-go/listers/batch/v1" listerscorev1 "k8s.io/client-go/listers/core/v1" listersrbacv1 "k8s.io/client-go/listers/rbac/v1" + "k8s.io/utils/pointer" "github.com/operator-framework/api/pkg/operators/reference" operatorsv1alpha1 "github.com/operator-framework/api/pkg/operators/v1alpha1" @@ -101,6 +102,11 @@ func (c *ConfigMapUnpacker) job(cmRef *corev1.ObjectReference, bundlePath string // See: https://kubernetes.io/docs/concepts/workloads/controllers/job/#pod-backoff-failure-policy RestartPolicy: corev1.RestartPolicyNever, ImagePullSecrets: secrets, + SecurityContext: &corev1.PodSecurityContext{ + SeccompProfile: &corev1.SeccompProfile{ + Type: corev1.SeccompProfileTypeRuntimeDefault, + }, + }, Containers: []corev1.Container{ { Name: "extract", @@ -129,6 +135,12 @@ func (c *ConfigMapUnpacker) job(cmRef *corev1.ObjectReference, bundlePath string corev1.ResourceMemory: resource.MustParse("50Mi"), }, }, + SecurityContext: &corev1.SecurityContext{ + AllowPrivilegeEscalation: pointer.Bool(false), + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, + }, }, }, InitContainers: []corev1.Container{ @@ -148,6 +160,12 @@ func (c *ConfigMapUnpacker) job(cmRef *corev1.ObjectReference, bundlePath string corev1.ResourceMemory: resource.MustParse("50Mi"), }, }, + SecurityContext: &corev1.SecurityContext{ + AllowPrivilegeEscalation: pointer.Bool(false), + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, + }, }, { Name: "pull", @@ -170,6 +188,12 @@ func (c *ConfigMapUnpacker) job(cmRef *corev1.ObjectReference, bundlePath string corev1.ResourceMemory: resource.MustParse("50Mi"), }, }, + SecurityContext: &corev1.SecurityContext{ + AllowPrivilegeEscalation: pointer.Bool(false), + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, + }, }, }, Volumes: []corev1.Volume{ @@ -193,7 +217,10 @@ func (c *ConfigMapUnpacker) job(cmRef *corev1.ObjectReference, bundlePath string job.SetNamespace(cmRef.Namespace) job.SetName(cmRef.Name) job.SetOwnerReferences([]metav1.OwnerReference{ownerRef(cmRef)}) - + if c.runAsUser > 0 { + job.Spec.Template.Spec.SecurityContext.RunAsUser = &c.runAsUser + job.Spec.Template.Spec.SecurityContext.RunAsNonRoot = pointer.Bool(true) + } // By default the BackoffLimit is set to 6 which with exponential backoff 10s + 20s + 40s ... // translates to ~10m of waiting time. // We want to fail faster than that when we have repeated failures from the bundle unpack pod @@ -246,6 +273,7 @@ type ConfigMapUnpacker struct { loader *configmap.BundleLoader now func() metav1.Time unpackTimeout time.Duration + runAsUser int64 } type ConfigMapUnpackerOption func(*ConfigMapUnpacker) @@ -335,6 +363,12 @@ func WithNow(now func() metav1.Time) ConfigMapUnpackerOption { } } +func WithUserID(id int64) ConfigMapUnpackerOption { + return func(unpacker *ConfigMapUnpacker) { + unpacker.runAsUser = id + } +} + func (c *ConfigMapUnpacker) apply(options ...ConfigMapUnpackerOption) { for _, option := range options { option(c) diff --git a/staging/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker_test.go b/staging/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker_test.go index 4e580ffc36..85fe2bbf62 100644 --- a/staging/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker_test.go +++ b/staging/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker_test.go @@ -15,6 +15,7 @@ import ( "k8s.io/apimachinery/pkg/runtime" "k8s.io/client-go/informers" k8sfake "k8s.io/client-go/kubernetes/fake" + "k8s.io/utils/pointer" operatorsv1alpha1 "github.com/operator-framework/api/pkg/operators/v1alpha1" crfake "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/fake" @@ -32,6 +33,7 @@ const ( opmImage = "opm-image" utilImage = "util-image" bundlePath = "bundle-path" + runAsUser = 1001 ) func TestConfigMapUnpacker(t *testing.T) { @@ -220,6 +222,13 @@ func TestConfigMapUnpacker(t *testing.T) { Spec: corev1.PodSpec{ RestartPolicy: corev1.RestartPolicyNever, ImagePullSecrets: []corev1.LocalObjectReference{{Name: "my-secret"}}, + SecurityContext: &corev1.PodSecurityContext{ + RunAsNonRoot: pointer.Bool(true), + RunAsUser: pointer.Int64(runAsUser), + SeccompProfile: &corev1.SeccompProfile{ + Type: corev1.SeccompProfileTypeRuntimeDefault, + }, + }, Containers: []corev1.Container{ { Name: "extract", @@ -243,6 +252,12 @@ func TestConfigMapUnpacker(t *testing.T) { corev1.ResourceMemory: resource.MustParse("50Mi"), }, }, + SecurityContext: &corev1.SecurityContext{ + AllowPrivilegeEscalation: pointer.Bool(false), + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, + }, }, }, InitContainers: []corev1.Container{ @@ -262,6 +277,12 @@ func TestConfigMapUnpacker(t *testing.T) { corev1.ResourceMemory: resource.MustParse("50Mi"), }, }, + SecurityContext: &corev1.SecurityContext{ + AllowPrivilegeEscalation: pointer.Bool(false), + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, + }, }, { Name: "pull", @@ -284,6 +305,12 @@ func TestConfigMapUnpacker(t *testing.T) { corev1.ResourceMemory: resource.MustParse("50Mi"), }, }, + SecurityContext: &corev1.SecurityContext{ + AllowPrivilegeEscalation: pointer.Bool(false), + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, + }, }, }, Volumes: []corev1.Volume{ @@ -397,6 +424,13 @@ func TestConfigMapUnpacker(t *testing.T) { }, Spec: corev1.PodSpec{ RestartPolicy: corev1.RestartPolicyNever, + SecurityContext: &corev1.PodSecurityContext{ + RunAsNonRoot: pointer.Bool(true), + RunAsUser: pointer.Int64(runAsUser), + SeccompProfile: &corev1.SeccompProfile{ + Type: corev1.SeccompProfileTypeRuntimeDefault, + }, + }, Containers: []corev1.Container{ { Name: "extract", @@ -420,6 +454,12 @@ func TestConfigMapUnpacker(t *testing.T) { corev1.ResourceMemory: resource.MustParse("50Mi"), }, }, + SecurityContext: &corev1.SecurityContext{ + AllowPrivilegeEscalation: pointer.Bool(false), + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, + }, }, }, InitContainers: []corev1.Container{ @@ -439,6 +479,12 @@ func TestConfigMapUnpacker(t *testing.T) { corev1.ResourceMemory: resource.MustParse("50Mi"), }, }, + SecurityContext: &corev1.SecurityContext{ + AllowPrivilegeEscalation: pointer.Bool(false), + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, + }, }, { Name: "pull", @@ -461,6 +507,12 @@ func TestConfigMapUnpacker(t *testing.T) { corev1.ResourceMemory: resource.MustParse("50Mi"), }, }, + SecurityContext: &corev1.SecurityContext{ + AllowPrivilegeEscalation: pointer.Bool(false), + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, + }, }, }, Volumes: []corev1.Volume{ @@ -615,6 +667,13 @@ func TestConfigMapUnpacker(t *testing.T) { }, Spec: corev1.PodSpec{ RestartPolicy: corev1.RestartPolicyNever, + SecurityContext: &corev1.PodSecurityContext{ + RunAsNonRoot: pointer.Bool(true), + RunAsUser: pointer.Int64(runAsUser), + SeccompProfile: &corev1.SeccompProfile{ + Type: corev1.SeccompProfileTypeRuntimeDefault, + }, + }, Containers: []corev1.Container{ { Name: "extract", @@ -638,6 +697,12 @@ func TestConfigMapUnpacker(t *testing.T) { corev1.ResourceMemory: resource.MustParse("50Mi"), }, }, + SecurityContext: &corev1.SecurityContext{ + AllowPrivilegeEscalation: pointer.Bool(false), + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, + }, }, }, InitContainers: []corev1.Container{ @@ -657,6 +722,12 @@ func TestConfigMapUnpacker(t *testing.T) { corev1.ResourceMemory: resource.MustParse("50Mi"), }, }, + SecurityContext: &corev1.SecurityContext{ + AllowPrivilegeEscalation: pointer.Bool(false), + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, + }, }, { Name: "pull", @@ -679,6 +750,12 @@ func TestConfigMapUnpacker(t *testing.T) { corev1.ResourceMemory: resource.MustParse("50Mi"), }, }, + SecurityContext: &corev1.SecurityContext{ + AllowPrivilegeEscalation: pointer.Bool(false), + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, + }, }, }, Volumes: []corev1.Volume{ @@ -827,6 +904,13 @@ func TestConfigMapUnpacker(t *testing.T) { }, Spec: corev1.PodSpec{ RestartPolicy: corev1.RestartPolicyNever, + SecurityContext: &corev1.PodSecurityContext{ + RunAsNonRoot: pointer.Bool(true), + RunAsUser: pointer.Int64(runAsUser), + SeccompProfile: &corev1.SeccompProfile{ + Type: corev1.SeccompProfileTypeRuntimeDefault, + }, + }, Containers: []corev1.Container{ { Name: "extract", @@ -850,6 +934,12 @@ func TestConfigMapUnpacker(t *testing.T) { corev1.ResourceMemory: resource.MustParse("50Mi"), }, }, + SecurityContext: &corev1.SecurityContext{ + AllowPrivilegeEscalation: pointer.Bool(false), + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, + }, }, }, InitContainers: []corev1.Container{ @@ -869,6 +959,12 @@ func TestConfigMapUnpacker(t *testing.T) { corev1.ResourceMemory: resource.MustParse("50Mi"), }, }, + SecurityContext: &corev1.SecurityContext{ + AllowPrivilegeEscalation: pointer.Bool(false), + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, + }, }, { Name: "pull", @@ -891,6 +987,12 @@ func TestConfigMapUnpacker(t *testing.T) { corev1.ResourceMemory: resource.MustParse("50Mi"), }, }, + SecurityContext: &corev1.SecurityContext{ + AllowPrivilegeEscalation: pointer.Bool(false), + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, + }, }, }, Volumes: []corev1.Volume{ @@ -1009,6 +1111,13 @@ func TestConfigMapUnpacker(t *testing.T) { }, Spec: corev1.PodSpec{ RestartPolicy: corev1.RestartPolicyNever, + SecurityContext: &corev1.PodSecurityContext{ + RunAsNonRoot: pointer.Bool(true), + RunAsUser: pointer.Int64(runAsUser), + SeccompProfile: &corev1.SeccompProfile{ + Type: corev1.SeccompProfileTypeRuntimeDefault, + }, + }, Containers: []corev1.Container{ { Name: "extract", @@ -1032,6 +1141,12 @@ func TestConfigMapUnpacker(t *testing.T) { corev1.ResourceMemory: resource.MustParse("50Mi"), }, }, + SecurityContext: &corev1.SecurityContext{ + AllowPrivilegeEscalation: pointer.Bool(false), + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, + }, }, }, InitContainers: []corev1.Container{ @@ -1051,6 +1166,12 @@ func TestConfigMapUnpacker(t *testing.T) { corev1.ResourceMemory: resource.MustParse("50Mi"), }, }, + SecurityContext: &corev1.SecurityContext{ + AllowPrivilegeEscalation: pointer.Bool(false), + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, + }, }, { Name: "pull", @@ -1073,6 +1194,12 @@ func TestConfigMapUnpacker(t *testing.T) { corev1.ResourceMemory: resource.MustParse("50Mi"), }, }, + SecurityContext: &corev1.SecurityContext{ + AllowPrivilegeEscalation: pointer.Bool(false), + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, + }, }, }, Volumes: []corev1.Volume{ @@ -1202,6 +1329,13 @@ func TestConfigMapUnpacker(t *testing.T) { }, Spec: corev1.PodSpec{ RestartPolicy: corev1.RestartPolicyNever, + SecurityContext: &corev1.PodSecurityContext{ + RunAsNonRoot: pointer.Bool(true), + RunAsUser: pointer.Int64(runAsUser), + SeccompProfile: &corev1.SeccompProfile{ + Type: corev1.SeccompProfileTypeRuntimeDefault, + }, + }, Containers: []corev1.Container{ { Name: "extract", @@ -1225,6 +1359,12 @@ func TestConfigMapUnpacker(t *testing.T) { corev1.ResourceMemory: resource.MustParse("50Mi"), }, }, + SecurityContext: &corev1.SecurityContext{ + AllowPrivilegeEscalation: pointer.Bool(false), + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, + }, }, }, InitContainers: []corev1.Container{ @@ -1244,6 +1384,12 @@ func TestConfigMapUnpacker(t *testing.T) { corev1.ResourceMemory: resource.MustParse("50Mi"), }, }, + SecurityContext: &corev1.SecurityContext{ + AllowPrivilegeEscalation: pointer.Bool(false), + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, + }, }, { Name: "pull", @@ -1266,6 +1412,12 @@ func TestConfigMapUnpacker(t *testing.T) { corev1.ResourceMemory: resource.MustParse("50Mi"), }, }, + SecurityContext: &corev1.SecurityContext{ + AllowPrivilegeEscalation: pointer.Bool(false), + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, + }, }, }, Volumes: []corev1.Volume{ @@ -1341,6 +1493,7 @@ func TestConfigMapUnpacker(t *testing.T) { WithUtilImage(utilImage), WithNow(now), WithUnpackTimeout(defaultUnpackDuration), + WithUserID(int64(runAsUser)), ) require.NoError(t, err) diff --git a/staging/operator-lifecycle-manager/pkg/controller/certs/certs.go b/staging/operator-lifecycle-manager/pkg/controller/certs/certs.go index e000ab2c5e..9ece822314 100644 --- a/staging/operator-lifecycle-manager/pkg/controller/certs/certs.go +++ b/staging/operator-lifecycle-manager/pkg/controller/certs/certs.go @@ -71,13 +71,13 @@ func GenerateCA(notAfter time.Time, organization string) (*KeyPair, error) { caDetails := &x509.Certificate{ SerialNumber: serial, Subject: pkix.Name{ + CommonName: fmt.Sprintf("olm-selfsigned-%x", serial), Organization: []string{organization}, }, NotBefore: notBefore, NotAfter: notAfter, IsCA: true, - ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth}, - KeyUsage: x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign, + KeyUsage: x509.KeyUsageCertSign, BasicConstraintsValid: true, } @@ -120,12 +120,12 @@ func CreateSignedServingPair(notAfter time.Time, organization string, ca *KeyPai certDetails := &x509.Certificate{ SerialNumber: serial, Subject: pkix.Name{ + CommonName: hosts[0], Organization: []string{organization}, }, NotBefore: notBefore, NotAfter: notAfter, - ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth}, - KeyUsage: x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign, + ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth}, BasicConstraintsValid: true, DNSNames: hosts, } diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/operator.go b/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/operator.go index 658cd93a34..536d51bece 100644 --- a/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/operator.go +++ b/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/operator.go @@ -125,7 +125,7 @@ type Operator struct { type CatalogSourceSyncFunc func(logger *logrus.Entry, in *v1alpha1.CatalogSource) (out *v1alpha1.CatalogSource, continueSync bool, syncError error) // NewOperator creates a new Catalog Operator. -func NewOperator(ctx context.Context, kubeconfigPath string, clock utilclock.Clock, logger *logrus.Logger, resync time.Duration, configmapRegistryImage, opmImage, utilImage string, operatorNamespace string, scheme *runtime.Scheme, installPlanTimeout time.Duration, bundleUnpackTimeout time.Duration) (*Operator, error) { +func NewOperator(ctx context.Context, kubeconfigPath string, clock utilclock.Clock, logger *logrus.Logger, resync time.Duration, configmapRegistryImage, opmImage, utilImage string, operatorNamespace string, scheme *runtime.Scheme, installPlanTimeout time.Duration, bundleUnpackTimeout time.Duration, workloadUserID int64) (*Operator, error) { resyncPeriod := queueinformer.ResyncWithJitter(resync, 0.2) config, err := clientcmd.BuildConfigFromFlags("", kubeconfigPath) if err != nil { @@ -194,7 +194,7 @@ func NewOperator(ctx context.Context, kubeconfigPath string, clock utilclock.Clo op.sources = grpc.NewSourceStore(logger, 10*time.Second, 10*time.Minute, op.syncSourceState) op.sourceInvalidator = resolver.SourceProviderFromRegistryClientProvider(op.sources, logger) resolverSourceProvider := NewOperatorGroupToggleSourceProvider(op.sourceInvalidator, logger, op.lister.OperatorsV1().OperatorGroupLister()) - op.reconciler = reconciler.NewRegistryReconcilerFactory(lister, opClient, configmapRegistryImage, op.now, ssaClient) + op.reconciler = reconciler.NewRegistryReconcilerFactory(lister, opClient, configmapRegistryImage, op.now, ssaClient, workloadUserID) res := resolver.NewOperatorStepResolver(lister, crClient, operatorNamespace, resolverSourceProvider, logger) op.resolver = resolver.NewInstrumentedResolver(res, metrics.RegisterDependencyResolutionSuccess, metrics.RegisterDependencyResolutionFailure) @@ -433,6 +433,7 @@ func NewOperator(ctx context.Context, kubeconfigPath string, clock utilclock.Clo bundle.WithUtilImage(utilImage), bundle.WithNow(op.now), bundle.WithUnpackTimeout(op.bundleUnpackTimeout), + bundle.WithUserID(workloadUserID), ) if err != nil { return nil, err @@ -1404,13 +1405,6 @@ type UnpackedBundleReference struct { Properties string `json:"properties"` } -/* unpackBundles makes one walk through the bundlelookups and attempts to progress them -Returns: - unpacked: bool - If the bundle was successfully unpacked - out: *v1alpha1.InstallPlan - the resulting installPlan - error: error -*/ - func (o *Operator) unpackBundles(plan *v1alpha1.InstallPlan) (bool, *v1alpha1.InstallPlan, error) { out := plan.DeepCopy() unpacked := true diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/operator_test.go b/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/operator_test.go index b7e2431480..8c46883bed 100644 --- a/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/operator_test.go +++ b/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/operator_test.go @@ -5,8 +5,8 @@ import ( "encoding/json" "errors" "fmt" - "io/ioutil" "math/rand" + "os" "reflect" "strings" "testing" @@ -1353,7 +1353,7 @@ func TestCompetingCRDOwnersExist(t *testing.T) { func TestValidateExistingCRs(t *testing.T) { unstructuredForFile := func(file string) *unstructured.Unstructured { - data, err := ioutil.ReadFile(file) + data, err := os.ReadFile(file) require.NoError(t, err) dec := utilyaml.NewYAMLOrJSONDecoder(strings.NewReader(string(data)), 30) k8sFile := &unstructured.Unstructured{} @@ -1362,7 +1362,7 @@ func TestValidateExistingCRs(t *testing.T) { } unversionedCRDForV1beta1File := func(file string) *apiextensions.CustomResourceDefinition { - data, err := ioutil.ReadFile(file) + data, err := os.ReadFile(file) require.NoError(t, err) dec := utilyaml.NewYAMLOrJSONDecoder(strings.NewReader(string(data)), 30) k8sFile := &apiextensionsv1beta1.CustomResourceDefinition{} @@ -1606,7 +1606,7 @@ func NewFakeOperator(ctx context.Context, namespace string, namespaces []string, } applier := controllerclient.NewFakeApplier(s, "testowner") - op.reconciler = reconciler.NewRegistryReconcilerFactory(lister, op.opClient, "test:pod", op.now, applier) + op.reconciler = reconciler.NewRegistryReconcilerFactory(lister, op.opClient, "test:pod", op.now, applier, 1001) } op.RunInformers(ctx) @@ -1744,7 +1744,7 @@ func objectReference(name string) *corev1.ObjectReference { } func yamlFromFilePath(t *testing.T, fileName string) string { - yaml, err := ioutil.ReadFile(fileName) + yaml, err := os.ReadFile(fileName) require.NoError(t, err) return string(yaml) @@ -1758,7 +1758,7 @@ func toManifest(t *testing.T, obj runtime.Object) string { } func pod(s v1alpha1.CatalogSource) *corev1.Pod { - pod := reconciler.Pod(&s, "registry-server", s.Spec.Image, s.GetName(), s.GetLabels(), s.GetAnnotations(), 5, 10) + pod := reconciler.Pod(&s, "registry-server", s.Spec.Image, s.GetName(), s.GetLabels(), s.GetAnnotations(), 5, 10, 1001) ownerutil.AddOwner(pod, &s, false, false) return pod } diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/olm/operator.go b/staging/operator-lifecycle-manager/pkg/controller/operators/olm/operator.go index d33945aee8..e0741dbb83 100644 --- a/staging/operator-lifecycle-manager/pkg/controller/operators/olm/operator.go +++ b/staging/operator-lifecycle-manager/pkg/controller/operators/olm/operator.go @@ -11,6 +11,7 @@ import ( admissionregistrationv1 "k8s.io/api/admissionregistration/v1" corev1 "k8s.io/api/core/v1" rbacv1 "k8s.io/api/rbac/v1" + apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" extinf "k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions" apierrors "k8s.io/apimachinery/pkg/api/errors" "k8s.io/apimachinery/pkg/api/meta" @@ -1121,6 +1122,46 @@ func (a *Operator) handleClusterServiceVersionDeletion(obj interface{}) { logger.WithError(err).Warnf("failed to requeue gc event: %v", webhook) } } + + // Conversion webhooks are defined within a CRD. + // In an effort to prevent customer dataloss, OLM does not delete CRDs associated with a CSV when it is deleted. + // Deleting a CSV that introduced a conversion webhook removes the deployment that serviced the conversion webhook calls. + // If a conversion webhook is defined and the service isn't available, all requests against the CR associated with the CRD will fail. + // This ultimately breaks kubernetes garbage collection and prevents OLM from reinstalling the CSV as CR validation against the new CRD's + // openapiv3 schema fails. + // As such, when a CSV is deleted OLM will check if it is being replaced. If the CSV is not being replaced, OLM will remove the conversion + // webhook from the CRD definition. + csvs, err := a.lister.OperatorsV1alpha1().ClusterServiceVersionLister().ClusterServiceVersions(clusterServiceVersion.GetNamespace()).List(labels.Everything()) + if err != nil { + logger.Errorf("error listing csvs: %v\n", err) + } + for _, csv := range csvs { + if csv.Spec.Replaces == clusterServiceVersion.GetName() { + return + } + } + + for _, desc := range clusterServiceVersion.Spec.WebhookDefinitions { + if desc.Type != v1alpha1.ConversionWebhook || len(desc.ConversionCRDs) == 0 { + continue + } + + for i, crdName := range desc.ConversionCRDs { + crd, err := a.lister.APIExtensionsV1().CustomResourceDefinitionLister().Get(crdName) + if err != nil { + logger.Errorf("error getting CRD %v which was defined in CSVs spec.WebhookDefinition[%d]: %v\n", crdName, i, err) + continue + } + + copy := crd.DeepCopy() + copy.Spec.Conversion.Strategy = apiextensionsv1.NoneConverter + copy.Spec.Conversion.Webhook = nil + + if _, err = a.opClient.ApiextensionsInterface().ApiextensionsV1().CustomResourceDefinitions().Update(context.TODO(), copy, metav1.UpdateOptions{}); err != nil { + logger.Errorf("error updating conversion strategy for CRD %v: %v\n", crdName, err) + } + } + } } func (a *Operator) removeDanglingChildCSVs(csv *v1alpha1.ClusterServiceVersion) error { diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/config.go b/staging/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/config.go index 7ed0c8ee57..bd3e2acb94 100644 --- a/staging/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/config.go +++ b/staging/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/config.go @@ -16,7 +16,7 @@ type operatorConfig struct { logger *logrus.Logger } -func (o *operatorConfig) GetConfigOverrides(ownerCSV ownerutil.Owner) (envVarOverrides []corev1.EnvVar, volumeOverrides []corev1.Volume, volumeMountOverrides []corev1.VolumeMount, tolerationOverrides []corev1.Toleration, resourcesOverride *corev1.ResourceRequirements, nodeSelectorOverride map[string]string, err error) { +func (o *operatorConfig) GetConfigOverrides(ownerCSV ownerutil.Owner) (envVarOverrides []corev1.EnvVar, volumeOverrides []corev1.Volume, volumeMountOverrides []corev1.VolumeMount, tolerationOverrides []corev1.Toleration, resourcesOverride *corev1.ResourceRequirements, nodeSelectorOverride map[string]string, affinity *corev1.Affinity, err error) { list, listErr := o.lister.OperatorsV1alpha1().SubscriptionLister().Subscriptions(ownerCSV.GetNamespace()).List(labels.Everything()) if listErr != nil { err = fmt.Errorf("failed to list subscription namespace=%s - %v", ownerCSV.GetNamespace(), listErr) @@ -40,6 +40,7 @@ func (o *operatorConfig) GetConfigOverrides(ownerCSV ownerutil.Owner) (envVarOve tolerationOverrides = owner.Spec.Config.Tolerations resourcesOverride = owner.Spec.Config.Resources nodeSelectorOverride = owner.Spec.Config.NodeSelector + affinity = owner.Spec.Config.Affinity return } diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/initializer.go b/staging/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/initializer.go index f8007368f7..12881bcc97 100644 --- a/staging/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/initializer.go +++ b/staging/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/initializer.go @@ -45,7 +45,7 @@ func (d *DeploymentInitializer) initialize(ownerCSV ownerutil.Owner, deployment var envVarOverrides, proxyEnvVar, merged []corev1.EnvVar var err error - envVarOverrides, volumeOverrides, volumeMountOverrides, tolerationOverrides, resourcesOverride, nodeSelectorOverride, err := d.config.GetConfigOverrides(ownerCSV) + envVarOverrides, volumeOverrides, volumeMountOverrides, tolerationOverrides, resourcesOverride, nodeSelectorOverride, affinity, err := d.config.GetConfigOverrides(ownerCSV) if err != nil { err = fmt.Errorf("failed to get subscription pod configuration - %v", err) return err @@ -92,6 +92,10 @@ func (d *DeploymentInitializer) initialize(ownerCSV ownerutil.Owner, deployment return fmt.Errorf("failed to inject nodeSelector into deployment spec name=%s - %v", deployment.Name, err) } + if err = inject.OverrideDeploymentAffinity(podSpec, affinity); err != nil { + return fmt.Errorf("failed to inject affinity into deployment spec name=%s - %s", deployment.Name, err) + } + return nil } diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/inject/inject.go b/staging/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/inject/inject.go index 0eaa1532ac..50432767c9 100644 --- a/staging/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/inject/inject.go +++ b/staging/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/inject/inject.go @@ -230,3 +230,71 @@ func InjectNodeSelectorIntoDeployment(podSpec *corev1.PodSpec, nodeSelector map[ return nil } + +// OverrideDeploymentAffinity will override the corev1.Affinity defined in the Deployment +// with the given corev1.Affinity. Any nil top-level sub-attributes (e.g. NodeAffinity, PodAffinity, and PodAntiAffinity) +// will be ignored. Hint: to overwrite those top-level attributes, empty them out. I.e. use the empty/default object ({}) +// e.g. NodeAffinity{}. In yaml: +// affinity: +// nodeAffinity: {} +// podAffinity: {} +// podAntiAffinity: {} +// will completely remove the deployment podSpec.affinity and is equivalent to +// affinity: {} +func OverrideDeploymentAffinity(podSpec *corev1.PodSpec, affinity *corev1.Affinity) error { + if podSpec == nil { + return errors.New("no pod spec provided") + } + + if affinity == nil { + return nil + } + + // if podSpec.Affinity is nil or empty/default then completely override podSpec.Affinity with overrides + if podSpec.Affinity == nil || reflect.DeepEqual(podSpec.Affinity, &corev1.Affinity{}) { + if reflect.DeepEqual(affinity, &corev1.Affinity{}) { + podSpec.Affinity = nil + } else { + podSpec.Affinity = affinity + } + return nil + } + + // if overriding affinity is empty/default then nil out podSpec.Affinity + if reflect.DeepEqual(affinity, &corev1.Affinity{}) { + podSpec.Affinity = nil + return nil + } + + // override podSpec.Affinity each attribute as necessary nilling out any default/empty overrides on the podSpec + if affinity.NodeAffinity != nil { + if reflect.DeepEqual(affinity.NodeAffinity, &corev1.NodeAffinity{}) { + podSpec.Affinity.NodeAffinity = nil + } else { + podSpec.Affinity.NodeAffinity = affinity.NodeAffinity + } + } + + if affinity.PodAffinity != nil { + if reflect.DeepEqual(affinity.PodAffinity, &corev1.PodAffinity{}) { + podSpec.Affinity.PodAffinity = nil + } else { + podSpec.Affinity.PodAffinity = affinity.PodAffinity + } + } + + if affinity.PodAntiAffinity != nil { + if reflect.DeepEqual(affinity.PodAntiAffinity, &corev1.PodAntiAffinity{}) { + podSpec.Affinity = nil + } else { + podSpec.Affinity.PodAntiAffinity = affinity.PodAntiAffinity + } + } + + // special case: if after being overridden, podSpec is the same as default/empty then nil it out + if reflect.DeepEqual(&corev1.Affinity{}, podSpec.Affinity) { + podSpec.Affinity = nil + } + + return nil +} diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/inject/inject_test.go b/staging/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/inject/inject_test.go index 3c4f6d36da..9e21883c98 100644 --- a/staging/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/inject/inject_test.go +++ b/staging/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/inject/inject_test.go @@ -1,6 +1,8 @@ package inject_test import ( + "fmt" + "reflect" "testing" "github.com/stretchr/testify/assert" @@ -784,3 +786,505 @@ func TestInjectNodeSelectorIntoDeployment(t *testing.T) { }) } } + +func TestOverrideDeploymentAffinity(t *testing.T) { + tests := []struct { + name string + podSpec *corev1.PodSpec + affinity *corev1.Affinity + expected *corev1.PodSpec + expectedErr error + }{ + { + // Nil PodSpec is injected with an Affinity + // Expected: PodSpec is nil + // ExpectedErr: "no pod spec provided" + name: "WithNilPodSpec", + podSpec: nil, + affinity: &corev1.Affinity{}, + expected: nil, + expectedErr: fmt.Errorf("no pod spec provided"), + }, + { + // Affinity is overrides PodSpec with no Affinity + // Expected: Affinity is defined in the PodSpec + // ExpectedErr: nil + name: "WithPodSpecWithNoAffinity", + podSpec: &corev1.PodSpec{}, + affinity: &corev1.Affinity{ + NodeAffinity: &corev1.NodeAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: &corev1.NodeSelector{ + NodeSelectorTerms: []corev1.NodeSelectorTerm{ + { + MatchFields: []corev1.NodeSelectorRequirement{ + { + Key: "key", + Operator: corev1.NodeSelectorOpIn, + Values: []string{"val1", "val2"}, + }, + }, + }, + }, + }, + }, + }, + expected: &corev1.PodSpec{ + Affinity: &corev1.Affinity{ + NodeAffinity: &corev1.NodeAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: &corev1.NodeSelector{ + NodeSelectorTerms: []corev1.NodeSelectorTerm{ + { + MatchFields: []corev1.NodeSelectorRequirement{ + { + Key: "key", + Operator: corev1.NodeSelectorOpIn, + Values: []string{"val1", "val2"}, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + // Affinity with NodeAffinity overrides PodSpec with NodeAffinity, PodAffinity, PodAntiAffinity + // Expected: PodSpec Affinity has overridden NodeAffinity, but not PodAffinity, PodAntiAffinity + // ExpectedErr: nil + name: "OnlyOverrideNodeAffinity", + podSpec: &corev1.PodSpec{ + Affinity: &corev1.Affinity{ + NodeAffinity: &corev1.NodeAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: &corev1.NodeSelector{ + NodeSelectorTerms: []corev1.NodeSelectorTerm{ + { + MatchFields: []corev1.NodeSelectorRequirement{ + { + Key: "key", + Operator: corev1.NodeSelectorOpIn, + Values: []string{"val1", "val2"}, + }, + }, + }, + }, + }, + }, + PodAffinity: &corev1.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []corev1.PodAffinityTerm{ + { + TopologyKey: "topKey", + Namespaces: []string{"ns1", "ns2"}, + }, + }, + }, + PodAntiAffinity: &corev1.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []corev1.PodAffinityTerm{ + { + TopologyKey: "topKey2", + Namespaces: []string{"n3", "ns4"}, + }, + }, + }, + }, + }, + affinity: &corev1.Affinity{ + NodeAffinity: &corev1.NodeAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: &corev1.NodeSelector{ + NodeSelectorTerms: []corev1.NodeSelectorTerm{ + { + MatchFields: []corev1.NodeSelectorRequirement{ + { + Key: "anotherKey", + Operator: corev1.NodeSelectorOpExists, + Values: []string{"val3"}, + }, + }, + }, + }, + }, + }, + }, + expected: &corev1.PodSpec{ + Affinity: &corev1.Affinity{ + NodeAffinity: &corev1.NodeAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: &corev1.NodeSelector{ + NodeSelectorTerms: []corev1.NodeSelectorTerm{ + { + MatchFields: []corev1.NodeSelectorRequirement{ + { + Key: "anotherKey", + Operator: corev1.NodeSelectorOpExists, + Values: []string{"val3"}, + }, + }, + }, + }, + }, + }, + PodAffinity: &corev1.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []corev1.PodAffinityTerm{ + { + TopologyKey: "topKey", + Namespaces: []string{"ns1", "ns2"}, + }, + }, + }, + PodAntiAffinity: &corev1.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []corev1.PodAffinityTerm{ + { + TopologyKey: "topKey2", + Namespaces: []string{"n3", "ns4"}, + }, + }, + }, + }, + }, + }, + { + // Affinity with NodeAffinity, empty PodAffinity overrides PodSpec with NodeAffinity, PodAffinity, PodAntiAffinity + // Expected: PodSpec Affinity has overridden NodeAffinity, PodAffinity, but not PodAntiAffinity + // ExpectedErr: nil + name: "OverrideNodeAffinityEmptyPodAffinity", + podSpec: &corev1.PodSpec{ + Affinity: &corev1.Affinity{ + NodeAffinity: &corev1.NodeAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: &corev1.NodeSelector{ + NodeSelectorTerms: []corev1.NodeSelectorTerm{ + { + MatchFields: []corev1.NodeSelectorRequirement{ + { + Key: "key", + Operator: corev1.NodeSelectorOpIn, + Values: []string{"val1", "val2"}, + }, + }, + }, + }, + }, + }, + PodAffinity: &corev1.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []corev1.PodAffinityTerm{ + { + TopologyKey: "topKey", + Namespaces: []string{"ns1", "ns2"}, + }, + }, + }, + PodAntiAffinity: &corev1.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []corev1.PodAffinityTerm{ + { + TopologyKey: "topKey2", + Namespaces: []string{"n3", "ns4"}, + }, + }, + }, + }, + }, + affinity: &corev1.Affinity{ + NodeAffinity: &corev1.NodeAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: &corev1.NodeSelector{ + NodeSelectorTerms: []corev1.NodeSelectorTerm{ + { + MatchFields: []corev1.NodeSelectorRequirement{ + { + Key: "anotherKey", + Operator: corev1.NodeSelectorOpExists, + Values: []string{"val3"}, + }, + }, + }, + }, + }, + }, + PodAffinity: &corev1.PodAffinity{}, + }, + expected: &corev1.PodSpec{ + Affinity: &corev1.Affinity{ + NodeAffinity: &corev1.NodeAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: &corev1.NodeSelector{ + NodeSelectorTerms: []corev1.NodeSelectorTerm{ + { + MatchFields: []corev1.NodeSelectorRequirement{ + { + Key: "anotherKey", + Operator: corev1.NodeSelectorOpExists, + Values: []string{"val3"}, + }, + }, + }, + }, + }, + }, + PodAffinity: nil, + PodAntiAffinity: &corev1.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []corev1.PodAffinityTerm{ + { + TopologyKey: "topKey2", + Namespaces: []string{"n3", "ns4"}, + }, + }, + }, + }, + }, + }, + { + // Affinity with NodeAffinity, PodAffinity overrides PodSpec with nil NodeAffinity, nil PodAffinity, PodAntiAffinity + // Expected: PodSpec Affinity has overridden NodeAffinity, PodAffinity, but not PodAntiAffinity + // ExpectedErr: nil + name: "OverridesNilPodSpecAttributes", + podSpec: &corev1.PodSpec{ + Affinity: &corev1.Affinity{ + PodAntiAffinity: &corev1.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []corev1.PodAffinityTerm{ + { + TopologyKey: "topKey2", + Namespaces: []string{"n3", "ns4"}, + }, + }, + }, + }, + }, + affinity: &corev1.Affinity{ + NodeAffinity: &corev1.NodeAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: &corev1.NodeSelector{ + NodeSelectorTerms: []corev1.NodeSelectorTerm{ + { + MatchFields: []corev1.NodeSelectorRequirement{ + { + Key: "anotherKey", + Operator: corev1.NodeSelectorOpExists, + Values: []string{"val3"}, + }, + }, + }, + }, + }, + }, + PodAffinity: &corev1.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []corev1.PodAffinityTerm{ + { + TopologyKey: "topKey", + Namespaces: []string{"ns1", "ns2"}, + }, + }, + }, + }, + expected: &corev1.PodSpec{ + Affinity: &corev1.Affinity{ + NodeAffinity: &corev1.NodeAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: &corev1.NodeSelector{ + NodeSelectorTerms: []corev1.NodeSelectorTerm{ + { + MatchFields: []corev1.NodeSelectorRequirement{ + { + Key: "anotherKey", + Operator: corev1.NodeSelectorOpExists, + Values: []string{"val3"}, + }, + }, + }, + }, + }, + }, + PodAffinity: &corev1.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []corev1.PodAffinityTerm{ + { + TopologyKey: "topKey", + Namespaces: []string{"ns1", "ns2"}, + }, + }, + }, + PodAntiAffinity: &corev1.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []corev1.PodAffinityTerm{ + { + TopologyKey: "topKey2", + Namespaces: []string{"n3", "ns4"}, + }, + }, + }, + }, + }, + }, + { + // Empty Affinity overrides PodSpec with NodeAffinity, PodAffinity, PodAntiAffinity + // Expected: PodSpec Affinity is nil + // ExpectedErr: nil + name: "EmptyAffinity", + podSpec: &corev1.PodSpec{ + Affinity: &corev1.Affinity{ + NodeAffinity: &corev1.NodeAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: &corev1.NodeSelector{ + NodeSelectorTerms: []corev1.NodeSelectorTerm{ + { + MatchFields: []corev1.NodeSelectorRequirement{ + { + Key: "key", + Operator: corev1.NodeSelectorOpIn, + Values: []string{"val1", "val2"}, + }, + }, + }, + }, + }, + }, + PodAffinity: &corev1.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []corev1.PodAffinityTerm{ + { + TopologyKey: "topKey", + Namespaces: []string{"ns1", "ns2"}, + }, + }, + }, + PodAntiAffinity: &corev1.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []corev1.PodAffinityTerm{ + { + TopologyKey: "topKey2", + Namespaces: []string{"n3", "ns4"}, + }, + }, + }, + }, + }, + affinity: &corev1.Affinity{}, + expected: &corev1.PodSpec{ + Affinity: nil, + }, + }, + { + // Empty Affinity NodeAffinity, and PodAffinity + // overrides PodSpec with NodeAffinity, and PodAffinity + // Expected: PodSpec Affinity is nil + // ExpectedErr: nil + name: "Nil/EmptyAffinityAreEquivalent", + podSpec: &corev1.PodSpec{ + Affinity: &corev1.Affinity{ + NodeAffinity: &corev1.NodeAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: &corev1.NodeSelector{ + NodeSelectorTerms: []corev1.NodeSelectorTerm{ + { + MatchFields: []corev1.NodeSelectorRequirement{ + { + Key: "key", + Operator: corev1.NodeSelectorOpIn, + Values: []string{"val1", "val2"}, + }, + }, + }, + }, + }, + }, + PodAffinity: &corev1.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []corev1.PodAffinityTerm{ + { + TopologyKey: "topKey", + Namespaces: []string{"ns1", "ns2"}, + }, + }, + }, + }, + }, + affinity: &corev1.Affinity{ + NodeAffinity: &corev1.NodeAffinity{}, + PodAffinity: &corev1.PodAffinity{}, + }, + expected: &corev1.PodSpec{ + Affinity: nil, + }, + }, + { + // Nil Affinity overrides nothing PodSpec + // Expected: PodSpec unaffected + // ExpectedErr: nil + name: "EmptyAffinity", + podSpec: &corev1.PodSpec{ + Affinity: &corev1.Affinity{ + NodeAffinity: &corev1.NodeAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: &corev1.NodeSelector{ + NodeSelectorTerms: []corev1.NodeSelectorTerm{ + { + MatchFields: []corev1.NodeSelectorRequirement{ + { + Key: "key", + Operator: corev1.NodeSelectorOpIn, + Values: []string{"val1", "val2"}, + }, + }, + }, + }, + }, + }, + PodAffinity: &corev1.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []corev1.PodAffinityTerm{ + { + TopologyKey: "topKey", + Namespaces: []string{"ns1", "ns2"}, + }, + }, + }, + PodAntiAffinity: &corev1.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []corev1.PodAffinityTerm{ + { + TopologyKey: "topKey2", + Namespaces: []string{"n3", "ns4"}, + }, + }, + }, + }, + }, + affinity: nil, + expected: &corev1.PodSpec{ + Affinity: &corev1.Affinity{ + NodeAffinity: &corev1.NodeAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: &corev1.NodeSelector{ + NodeSelectorTerms: []corev1.NodeSelectorTerm{ + { + MatchFields: []corev1.NodeSelectorRequirement{ + { + Key: "key", + Operator: corev1.NodeSelectorOpIn, + Values: []string{"val1", "val2"}, + }, + }, + }, + }, + }, + }, + PodAffinity: &corev1.PodAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []corev1.PodAffinityTerm{ + { + TopologyKey: "topKey", + Namespaces: []string{"ns1", "ns2"}, + }, + }, + }, + PodAntiAffinity: &corev1.PodAntiAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: []corev1.PodAffinityTerm{ + { + TopologyKey: "topKey2", + Namespaces: []string{"n3", "ns4"}, + }, + }, + }, + }, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := inject.OverrideDeploymentAffinity(tt.podSpec, tt.affinity) + + podSpecWant := tt.expected + podSpecGot := tt.podSpec + + assert.Equal(t, tt.expectedErr, err) + assert.Equal(t, podSpecWant, podSpecGot) + }) + } +} + +func TestAffinityAPIChanges(t *testing.T) { + value := reflect.ValueOf(corev1.Affinity{}) + assert.Equal(t, 3, value.NumField(), "It seems the corev1.Affinity API has changed. Please revisit the inject.OverrideDeploymentAffinity implementation") +} diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/configmap.go b/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/configmap.go index 0f8518d4c5..f264d1bee3 100644 --- a/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/configmap.go +++ b/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/configmap.go @@ -23,6 +23,7 @@ import ( // configMapCatalogSourceDecorator wraps CatalogSource to add additional methods type configMapCatalogSourceDecorator struct { *v1alpha1.CatalogSource + runAsUser int64 } const ( @@ -101,7 +102,7 @@ func (s *configMapCatalogSourceDecorator) Service() *corev1.Service { } func (s *configMapCatalogSourceDecorator) Pod(image string) *corev1.Pod { - pod := Pod(s.CatalogSource, "configmap-registry-server", image, "", s.Labels(), s.Annotations(), 5, 5) + pod := Pod(s.CatalogSource, "configmap-registry-server", image, "", s.Labels(), s.Annotations(), 5, 5, s.runAsUser) pod.Spec.ServiceAccountName = s.GetName() + ConfigMapServerPostfix pod.Spec.Containers[0].Command = []string{"configmap-server", "-c", s.Spec.ConfigMap, "-n", s.GetNamespace()} ownerutil.AddOwner(pod, s.CatalogSource, false, false) @@ -162,10 +163,11 @@ func (s *configMapCatalogSourceDecorator) RoleBinding() *rbacv1.RoleBinding { } type ConfigMapRegistryReconciler struct { - now nowFunc - Lister operatorlister.OperatorLister - OpClient operatorclient.ClientInterface - Image string + now nowFunc + Lister operatorlister.OperatorLister + OpClient operatorclient.ClientInterface + Image string + createPodAsUser int64 } var _ RegistryEnsurer = &ConfigMapRegistryReconciler{} @@ -240,7 +242,7 @@ func (c *ConfigMapRegistryReconciler) currentPodsWithCorrectResourceVersion(sour // EnsureRegistryServer ensures that all components of registry server are up to date. func (c *ConfigMapRegistryReconciler) EnsureRegistryServer(catalogSource *v1alpha1.CatalogSource) error { - source := configMapCatalogSourceDecorator{catalogSource} + source := configMapCatalogSourceDecorator{catalogSource, c.createPodAsUser} image := c.Image if source.Spec.SourceType == "grpc" { @@ -389,7 +391,7 @@ func (c *ConfigMapRegistryReconciler) ensureService(source configMapCatalogSourc // CheckRegistryServer returns true if the given CatalogSource is considered healthy; false otherwise. func (c *ConfigMapRegistryReconciler) CheckRegistryServer(catalogSource *v1alpha1.CatalogSource) (healthy bool, err error) { - source := configMapCatalogSourceDecorator{catalogSource} + source := configMapCatalogSourceDecorator{catalogSource, c.createPodAsUser} image := c.Image if source.Spec.SourceType == "grpc" { diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/configmap_test.go b/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/configmap_test.go index ddd0218661..281217a1bf 100644 --- a/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/configmap_test.go +++ b/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/configmap_test.go @@ -30,6 +30,7 @@ import ( const ( registryImageName = "test:image" + runAsUser = 1001 testNamespace = "testns" ) @@ -104,6 +105,7 @@ func fakeReconcilerFactory(t *testing.T, stopc <-chan struct{}, options ...fakeR OpClient: opClientFake, Lister: lister, ConfigMapServerImage: config.configMapServerImage, + createPodAsUser: runAsUser, } var hasSyncedCheckFns []cache.InformerSynced @@ -186,7 +188,7 @@ func objectsForCatalogSource(catsrc *v1alpha1.CatalogSource) []runtime.Object { var objs []runtime.Object switch catsrc.Spec.SourceType { case v1alpha1.SourceTypeInternal, v1alpha1.SourceTypeConfigmap: - decorated := configMapCatalogSourceDecorator{catsrc} + decorated := configMapCatalogSourceDecorator{catsrc, runAsUser} objs = clientfake.AddSimpleGeneratedNames( clientfake.AddSimpleGeneratedName(decorated.Pod(registryImageName)), decorated.Service(), @@ -196,7 +198,7 @@ func objectsForCatalogSource(catsrc *v1alpha1.CatalogSource) []runtime.Object { ) case v1alpha1.SourceTypeGrpc: if catsrc.Spec.Image != "" { - decorated := grpcCatalogSourceDecorator{catsrc} + decorated := grpcCatalogSourceDecorator{catsrc, runAsUser} objs = clientfake.AddSimpleGeneratedNames( decorated.Pod(catsrc.GetName()), decorated.Service(), @@ -451,7 +453,7 @@ func TestConfigMapRegistryReconciler(t *testing.T) { } // if no error, the reconciler should create the same set of kube objects every time - decorated := configMapCatalogSourceDecorator{tt.in.catsrc} + decorated := configMapCatalogSourceDecorator{tt.in.catsrc, runAsUser} pod := decorated.Pod(registryImageName) listOptions := metav1.ListOptions{LabelSelector: labels.SelectorFromSet(labels.Set{CatalogSourceLabelKey: tt.in.catsrc.GetName()}).String()} diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/grpc.go b/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/grpc.go index 4f63cc87aa..93e28e6286 100644 --- a/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/grpc.go +++ b/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/grpc.go @@ -32,6 +32,7 @@ const ( // grpcCatalogSourceDecorator wraps CatalogSource to add additional methods type grpcCatalogSourceDecorator struct { *v1alpha1.CatalogSource + createPodAsUser int64 } type UpdateNotReadyErr struct { @@ -122,16 +123,17 @@ func (s *grpcCatalogSourceDecorator) ServiceAccount() *corev1.ServiceAccount { } func (s *grpcCatalogSourceDecorator) Pod(saName string) *corev1.Pod { - pod := Pod(s.CatalogSource, "registry-server", s.Spec.Image, saName, s.Labels(), s.Annotations(), 5, 10) + pod := Pod(s.CatalogSource, "registry-server", s.Spec.Image, saName, s.Labels(), s.Annotations(), 5, 10, s.createPodAsUser) ownerutil.AddOwner(pod, s.CatalogSource, false, false) return pod } type GrpcRegistryReconciler struct { - now nowFunc - Lister operatorlister.OperatorLister - OpClient operatorclient.ClientInterface - SSAClient *controllerclient.ServerSideApplier + now nowFunc + Lister operatorlister.OperatorLister + OpClient operatorclient.ClientInterface + SSAClient *controllerclient.ServerSideApplier + createPodAsUser int64 } var _ RegistryReconciler = &GrpcRegistryReconciler{} @@ -198,7 +200,7 @@ func (c *GrpcRegistryReconciler) currentPodsWithCorrectImageAndSpec(source grpcC // EnsureRegistryServer ensures that all components of registry server are up to date. func (c *GrpcRegistryReconciler) EnsureRegistryServer(catalogSource *v1alpha1.CatalogSource) error { - source := grpcCatalogSourceDecorator{catalogSource} + source := grpcCatalogSourceDecorator{catalogSource, c.createPodAsUser} // if service status is nil, we force create every object to ensure they're created the first time overwrite := source.Status.RegistryServiceStatus == nil || !isRegistryServiceStatusValid(&source) @@ -447,7 +449,7 @@ func (c *GrpcRegistryReconciler) removePods(pods []*corev1.Pod, namespace string // CheckRegistryServer returns true if the given CatalogSource is considered healthy; false otherwise. func (c *GrpcRegistryReconciler) CheckRegistryServer(catalogSource *v1alpha1.CatalogSource) (healthy bool, err error) { - source := grpcCatalogSourceDecorator{catalogSource} + source := grpcCatalogSourceDecorator{catalogSource, c.createPodAsUser} // Check on registry resources // TODO: add gRPC health check if len(c.currentPodsWithCorrectImageAndSpec(source, source.ServiceAccount().GetName())) < 1 || diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/grpc_test.go b/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/grpc_test.go index 42a2bde3ad..c219329b3d 100644 --- a/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/grpc_test.go +++ b/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/grpc_test.go @@ -331,7 +331,7 @@ func TestGrpcRegistryReconciler(t *testing.T) { } // Check for resource existence - decorated := grpcCatalogSourceDecorator{tt.in.catsrc} + decorated := grpcCatalogSourceDecorator{tt.in.catsrc, runAsUser} pod := decorated.Pod(tt.in.catsrc.GetName()) service := decorated.Service() sa := decorated.ServiceAccount() @@ -421,7 +421,7 @@ func TestRegistryPodPriorityClass(t *testing.T) { require.NoError(t, err) // Check for resource existence - decorated := grpcCatalogSourceDecorator{tt.in.catsrc} + decorated := grpcCatalogSourceDecorator{tt.in.catsrc, runAsUser} pod := decorated.Pod(tt.in.catsrc.GetName()) listOptions := metav1.ListOptions{LabelSelector: labels.SelectorFromSet(labels.Set{CatalogSourceLabelKey: tt.in.catsrc.GetName()}).String()} outPods, podErr := client.KubernetesInterface().CoreV1().Pods(pod.GetNamespace()).List(context.TODO(), listOptions) diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/reconciler.go b/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/reconciler.go index 6089d2e777..45bf8dcba4 100644 --- a/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/reconciler.go +++ b/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/reconciler.go @@ -10,6 +10,7 @@ import ( "k8s.io/apimachinery/pkg/api/resource" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/rand" + "k8s.io/utils/pointer" operatorsv1alpha1 "github.com/operator-framework/api/pkg/operators/v1alpha1" controllerclient "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/controller-runtime/client" @@ -61,6 +62,7 @@ type registryReconcilerFactory struct { OpClient operatorclient.ClientInterface ConfigMapServerImage string SSAClient *controllerclient.ServerSideApplier + createPodAsUser int64 } // ReconcilerForSource returns a RegistryReconciler based on the configuration of the given CatalogSource. @@ -69,18 +71,20 @@ func (r *registryReconcilerFactory) ReconcilerForSource(source *operatorsv1alpha switch source.Spec.SourceType { case operatorsv1alpha1.SourceTypeInternal, operatorsv1alpha1.SourceTypeConfigmap: return &ConfigMapRegistryReconciler{ - now: r.now, - Lister: r.Lister, - OpClient: r.OpClient, - Image: r.ConfigMapServerImage, + now: r.now, + Lister: r.Lister, + OpClient: r.OpClient, + Image: r.ConfigMapServerImage, + createPodAsUser: r.createPodAsUser, } case operatorsv1alpha1.SourceTypeGrpc: if source.Spec.Image != "" { return &GrpcRegistryReconciler{ - now: r.now, - Lister: r.Lister, - OpClient: r.OpClient, - SSAClient: r.SSAClient, + now: r.now, + Lister: r.Lister, + OpClient: r.OpClient, + SSAClient: r.SSAClient, + createPodAsUser: r.createPodAsUser, } } else if source.Spec.Address != "" { return &GrpcAddressRegistryReconciler{ @@ -92,17 +96,18 @@ func (r *registryReconcilerFactory) ReconcilerForSource(source *operatorsv1alpha } // NewRegistryReconcilerFactory returns an initialized RegistryReconcilerFactory. -func NewRegistryReconcilerFactory(lister operatorlister.OperatorLister, opClient operatorclient.ClientInterface, configMapServerImage string, now nowFunc, ssaClient *controllerclient.ServerSideApplier) RegistryReconcilerFactory { +func NewRegistryReconcilerFactory(lister operatorlister.OperatorLister, opClient operatorclient.ClientInterface, configMapServerImage string, now nowFunc, ssaClient *controllerclient.ServerSideApplier, createPodAsUser int64) RegistryReconcilerFactory { return ®istryReconcilerFactory{ now: now, Lister: lister, OpClient: opClient, ConfigMapServerImage: configMapServerImage, SSAClient: ssaClient, + createPodAsUser: createPodAsUser, } } -func Pod(source *operatorsv1alpha1.CatalogSource, name string, image string, saName string, labels map[string]string, annotations map[string]string, readinessDelay int32, livenessDelay int32) *corev1.Pod { +func Pod(source *operatorsv1alpha1.CatalogSource, name string, image string, saName string, labels map[string]string, annotations map[string]string, readinessDelay int32, livenessDelay int32, runAsUser int64) *corev1.Pod { // Ensure the catalog image is always pulled if the image is not based on a digest, measured by whether an "@" is included. // See https://github.com/docker/distribution/blob/master/reference/reference.go for more info. // This means recreating non-digest based catalog pods will result in the latest version of the catalog content being delivered on-cluster. @@ -125,8 +130,6 @@ func Pod(source *operatorsv1alpha1.CatalogSource, name string, image string, saN podAnnotations[key] = value } - readOnlyRootFilesystem := false - pod := &corev1.Pod{ ObjectMeta: metav1.ObjectMeta{ GenerateName: source.GetName() + "-", @@ -179,7 +182,11 @@ func Pod(source *operatorsv1alpha1.CatalogSource, name string, image string, saN }, }, SecurityContext: &corev1.SecurityContext{ - ReadOnlyRootFilesystem: &readOnlyRootFilesystem, + ReadOnlyRootFilesystem: pointer.Bool(false), + AllowPrivilegeEscalation: pointer.Bool(false), + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, }, ImagePullPolicy: pullPolicy, TerminationMessagePolicy: corev1.TerminationMessageFallbackToLogsOnError, @@ -188,10 +195,19 @@ func Pod(source *operatorsv1alpha1.CatalogSource, name string, image string, saN NodeSelector: map[string]string{ "kubernetes.io/os": "linux", }, + SecurityContext: &corev1.PodSecurityContext{ + SeccompProfile: &corev1.SeccompProfile{ + Type: corev1.SeccompProfileTypeRuntimeDefault, + }, + }, ServiceAccountName: saName, }, } + if runAsUser > 0 { + pod.Spec.SecurityContext.RunAsUser = &runAsUser + pod.Spec.SecurityContext.RunAsNonRoot = pointer.Bool(true) + } // Override scheduling options if specified if source.Spec.GrpcPodConfig != nil { grpcPodConfig := source.Spec.GrpcPodConfig diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/reconciler_test.go b/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/reconciler_test.go index ad9c82c6de..1ed7eed2fa 100644 --- a/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/reconciler_test.go +++ b/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/reconciler_test.go @@ -10,6 +10,8 @@ import ( "github.com/operator-framework/api/pkg/operators/v1alpha1" ) +const workloadUserID = 1001 + func TestPodNodeSelector(t *testing.T) { catsrc := &v1alpha1.CatalogSource{ ObjectMeta: metav1.ObjectMeta{ @@ -21,7 +23,7 @@ func TestPodNodeSelector(t *testing.T) { key := "kubernetes.io/os" value := "linux" - gotCatSrcPod := Pod(catsrc, "hello", "busybox", "", map[string]string{}, map[string]string{}, int32(0), int32(0)) + gotCatSrcPod := Pod(catsrc, "hello", "busybox", "", map[string]string{}, map[string]string{}, int32(0), int32(0), int64(workloadUserID)) gotCatSrcPodSelector := gotCatSrcPod.Spec.NodeSelector if gotCatSrcPodSelector[key] != value { @@ -69,7 +71,7 @@ func TestPullPolicy(t *testing.T) { } for _, tt := range table { - p := Pod(source, "catalog", tt.image, "", nil, nil, int32(0), int32(0)) + p := Pod(source, "catalog", tt.image, "", nil, nil, int32(0), int32(0), int64(workloadUserID)) policy := p.Spec.Containers[0].ImagePullPolicy if policy != tt.policy { t.Fatalf("expected pull policy %s for image %s", tt.policy, tt.image) @@ -79,8 +81,13 @@ func TestPullPolicy(t *testing.T) { func TestPodContainerSecurityContext(t *testing.T) { expectedReadOnlyRootFilesystem := false + allowPrivilegeEscalation := false expectedContainerSecCtx := &corev1.SecurityContext{ - ReadOnlyRootFilesystem: &expectedReadOnlyRootFilesystem, + ReadOnlyRootFilesystem: &expectedReadOnlyRootFilesystem, + AllowPrivilegeEscalation: &allowPrivilegeEscalation, + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, } catsrc := &v1alpha1.CatalogSource{ @@ -90,7 +97,7 @@ func TestPodContainerSecurityContext(t *testing.T) { }, } - gotPod := Pod(catsrc, "hello", "busybox", "", map[string]string{}, map[string]string{}, int32(0), int32(0)) + gotPod := Pod(catsrc, "hello", "busybox", "", map[string]string{}, map[string]string{}, int32(0), int32(0), int64(workloadUserID)) gotContainerSecCtx := gotPod.Spec.Containers[0].SecurityContext require.Equal(t, expectedContainerSecCtx, gotContainerSecCtx) } @@ -115,7 +122,7 @@ func TestPodAvoidsConcurrentWrite(t *testing.T) { "annotation": "somethingelse", } - gotPod := Pod(catsrc, "hello", "busybox", "", labels, annotations, int32(0), int32(0)) + gotPod := Pod(catsrc, "hello", "busybox", "", labels, annotations, int32(0), int32(0), int64(workloadUserID)) // check labels and annotations point to different addresses between parameters and what's in the pod require.NotEqual(t, &labels, &gotPod.Labels) @@ -295,7 +302,7 @@ func TestPodSchedulingOverrides(t *testing.T) { } for _, testCase := range testCases { - pod := Pod(testCase.catalogSource, "hello", "busybox", "", map[string]string{}, testCase.annotations, int32(0), int32(0)) + pod := Pod(testCase.catalogSource, "hello", "busybox", "", map[string]string{}, testCase.annotations, int32(0), int32(0), int64(workloadUserID)) require.Equal(t, testCase.expectedNodeSelectors, pod.Spec.NodeSelector) require.Equal(t, testCase.expectedPriorityClassName, pod.Spec.PriorityClassName) require.Equal(t, testCase.expectedTolerations, pod.Spec.Tolerations) diff --git a/staging/operator-lifecycle-manager/pkg/lib/filemonitor/cabundle_updater.go b/staging/operator-lifecycle-manager/pkg/lib/filemonitor/cabundle_updater.go index 4fcee4e457..58f577ef45 100644 --- a/staging/operator-lifecycle-manager/pkg/lib/filemonitor/cabundle_updater.go +++ b/staging/operator-lifecycle-manager/pkg/lib/filemonitor/cabundle_updater.go @@ -2,7 +2,7 @@ package filemonitor import ( "crypto/x509" - "io/ioutil" + "os" "sync" "github.com/fsnotify/fsnotify" @@ -16,7 +16,7 @@ type certPoolStore struct { } func NewCertPoolStore(clientCAPath string) (*certPoolStore, error) { - pem, err := ioutil.ReadFile(clientCAPath) + pem, err := os.ReadFile(clientCAPath) if err != nil { return nil, err } @@ -31,7 +31,7 @@ func NewCertPoolStore(clientCAPath string) (*certPoolStore, error) { } func (c *certPoolStore) storeCABundle(clientCAPath string) error { - pem, err := ioutil.ReadFile(clientCAPath) + pem, err := os.ReadFile(clientCAPath) if err == nil { c.mutex.Lock() defer c.mutex.Unlock() diff --git a/staging/operator-lifecycle-manager/pkg/lib/filemonitor/cert_updater_test.go b/staging/operator-lifecycle-manager/pkg/lib/filemonitor/cert_updater_test.go index 022b22fc30..039e5ceac2 100644 --- a/staging/operator-lifecycle-manager/pkg/lib/filemonitor/cert_updater_test.go +++ b/staging/operator-lifecycle-manager/pkg/lib/filemonitor/cert_updater_test.go @@ -6,7 +6,6 @@ import ( "crypto/x509" "fmt" "html" - "io/ioutil" "net" "net/http" "os" @@ -88,7 +87,7 @@ func TestOLMGetCertRotationFn(t *testing.T) { } }() - caCert, err := ioutil.ReadFile(caCrt) + caCert, err := os.ReadFile(caCrt) require.NoError(t, err) caCertPool := x509.NewCertPool() caCertPool.AppendCertsFromPEM(caCert) diff --git a/staging/operator-lifecycle-manager/pkg/package-server/storage/subresources.go b/staging/operator-lifecycle-manager/pkg/package-server/storage/subresources.go index 45d30bd59b..455da45dc6 100644 --- a/staging/operator-lifecycle-manager/pkg/package-server/storage/subresources.go +++ b/staging/operator-lifecycle-manager/pkg/package-server/storage/subresources.go @@ -3,7 +3,7 @@ package storage import ( "context" "encoding/base64" - "io/ioutil" + "io" "net/http" "strconv" "strings" @@ -68,7 +68,7 @@ func (s *LogoStorage) Connect(ctx context.Context, name string, options runtime. etag := `"` + strings.Join([]string{name, pkgChannel.Name, pkgChannel.CurrentCSV}, ".") + `"` reader := base64.NewDecoder(base64.StdEncoding, strings.NewReader(data)) - imgBytes, _ := ioutil.ReadAll(reader) + imgBytes, _ := io.ReadAll(reader) return imgBytes, mimeType, etag } diff --git a/staging/operator-lifecycle-manager/test/e2e/csv_e2e_test.go b/staging/operator-lifecycle-manager/test/e2e/csv_e2e_test.go index 1216e88684..5afda922dc 100644 --- a/staging/operator-lifecycle-manager/test/e2e/csv_e2e_test.go +++ b/staging/operator-lifecycle-manager/test/e2e/csv_e2e_test.go @@ -4206,6 +4206,9 @@ func findLastEvent(events *corev1.EventList) (event corev1.Event) { func buildCSVCleanupFunc(c operatorclient.ClientInterface, crc versioned.Interface, csv operatorsv1alpha1.ClusterServiceVersion, namespace string, deleteCRDs, deleteAPIServices bool) cleanupFunc { return func() { err := crc.OperatorsV1alpha1().ClusterServiceVersions(namespace).Delete(context.TODO(), csv.GetName(), metav1.DeleteOptions{}) + if err != nil && apierrors.IsNotFound(err) { + err = nil + } Expect(err).ShouldNot(HaveOccurred()) if deleteCRDs { diff --git a/staging/operator-lifecycle-manager/test/e2e/ctx/provisioner_kind.go b/staging/operator-lifecycle-manager/test/e2e/ctx/provisioner_kind.go index 27f6d7c78c..6ac0ab976c 100644 --- a/staging/operator-lifecycle-manager/test/e2e/ctx/provisioner_kind.go +++ b/staging/operator-lifecycle-manager/test/e2e/ctx/provisioner_kind.go @@ -7,7 +7,6 @@ import ( "encoding/csv" "flag" "fmt" - "io/ioutil" "os" "path/filepath" "strings" @@ -78,7 +77,7 @@ func (kl kindLogAdapter) V(level log.Level) log.InfoLogger { } func Provision(ctx *TestContext) (func(), error) { - dir, err := ioutil.TempDir("", "kind.") + dir, err := os.MkdirTemp("", "kind.") if err != nil { return nil, fmt.Errorf("failed to create temporary directory: %s", err.Error()) } diff --git a/staging/operator-lifecycle-manager/test/e2e/operator_groups_e2e_test.go b/staging/operator-lifecycle-manager/test/e2e/operator_groups_e2e_test.go index 413374eb8f..553db457ea 100644 --- a/staging/operator-lifecycle-manager/test/e2e/operator_groups_e2e_test.go +++ b/staging/operator-lifecycle-manager/test/e2e/operator_groups_e2e_test.go @@ -1799,8 +1799,7 @@ var _ = Describe("Operator Group", func() { // Versions of OLM at 0.14.1 and older had a bug that would place the wrong namespace annotation on copied CSVs, // preventing them from being GCd. This ensures that any leftover CSVs in that state are properly cleared up. - // issue: https://github.com/operator-framework/operator-lifecycle-manager/issues/2644 - It("[FLAKE] cleanup csvs with bad owner operator groups", func() { + It("cleanup csvs with bad namespace annotation", func() { csvName := genName("another-csv-") // must be lowercase for DNS-1123 validation @@ -2013,18 +2012,28 @@ var _ = Describe("Operator Group", func() { return false, nil }) require.NoError(GinkgoT(), err) - - // Give copied CSV a bad operatorgroup annotation - updateCSV := func() error { - fetchedCSV, err := crc.OperatorsV1alpha1().ClusterServiceVersions(otherNamespaceName).Get(context.TODO(), csvName, metav1.GetOptions{}) - require.NoError(GinkgoT(), err) + GinkgoT().Log("Copied CSV showed up in other namespace, giving copied CSV a bad OpertorGroup annotation") + err = wait.Poll(pollInterval, pollDuration, func() (bool, error) { + fetchedCSV, fetchErr := crc.OperatorsV1alpha1().ClusterServiceVersions(otherNamespaceName).Get(context.TODO(), csvName, metav1.GetOptions{}) + if fetchErr != nil { + return false, fetchErr + } fetchedCSV.Annotations[v1.OperatorGroupNamespaceAnnotationKey] = fetchedCSV.GetNamespace() - _, err = crc.OperatorsV1alpha1().ClusterServiceVersions(otherNamespaceName).Update(context.TODO(), fetchedCSV, metav1.UpdateOptions{}) - return err - } - require.NoError(GinkgoT(), retry.RetryOnConflict(retry.DefaultBackoff, updateCSV)) - - // wait for CSV to be gc'd + _, updateErr := crc.OperatorsV1alpha1().ClusterServiceVersions(otherNamespaceName).Update(context.TODO(), fetchedCSV, metav1.UpdateOptions{}) + if updateErr != nil { + return false, updateErr + } + updatedCSV, updatedfetchErr := crc.OperatorsV1alpha1().ClusterServiceVersions(otherNamespaceName).Get(context.TODO(), csvName, metav1.GetOptions{}) + if updatedfetchErr != nil { + return false, updatedfetchErr + } + if updatedCSV.Annotations[v1.OperatorGroupNamespaceAnnotationKey] == fetchedCSV.GetNamespace() { + return true, nil + } + return false, nil + }) + require.NoError(GinkgoT(), err) + GinkgoT().Log("Done updating copied CSV with bad annotation OperatorGroup, waiting for CSV to be gc'd") err = wait.Poll(pollInterval, 2*pollDuration, func() (bool, error) { csv, fetchErr := crc.OperatorsV1alpha1().ClusterServiceVersions(otherNamespaceName).Get(context.TODO(), csvName, metav1.GetOptions{}) if fetchErr != nil { @@ -2034,8 +2043,12 @@ var _ = Describe("Operator Group", func() { GinkgoT().Logf("Error (in %v): %v", opGroupNamespace, fetchErr.Error()) return false, fetchErr } - GinkgoT().Logf("%#v", csv.Annotations) - GinkgoT().Logf(csv.GetNamespace()) + // The CSV with the wrong annotation could have been replaced with a new copied CSV by this time + // If we find a CSV in the namespace, and it contains the correct annotation, it means the CSV + // with the wrong annotation was GCed + if csv.Annotations[v1.OperatorGroupNamespaceAnnotationKey] != csv.GetNamespace() { + return true, nil + } return false, nil }) require.NoError(GinkgoT(), err) diff --git a/staging/operator-lifecycle-manager/test/e2e/setup_bare_test.go b/staging/operator-lifecycle-manager/test/e2e/setup_bare_test.go index 354e41cf68..f21ae71a98 100644 --- a/staging/operator-lifecycle-manager/test/e2e/setup_bare_test.go +++ b/staging/operator-lifecycle-manager/test/e2e/setup_bare_test.go @@ -7,7 +7,6 @@ import ( "context" "flag" "io" - "io/ioutil" "os" "strings" "testing" @@ -65,7 +64,7 @@ func TestMain(m *testing.M) { testNamespace = *namespace if testNamespace == "" { - testNamespaceBytes, err := ioutil.ReadFile("e2e.namespace") + testNamespaceBytes, err := os.ReadFile("e2e.namespace") if err != nil || testNamespaceBytes == nil { panic("no namespace set") } diff --git a/staging/operator-lifecycle-manager/test/e2e/split/main.go b/staging/operator-lifecycle-manager/test/e2e/split/main.go index 30745d0cab..1637fdb567 100644 --- a/staging/operator-lifecycle-manager/test/e2e/split/main.go +++ b/staging/operator-lifecycle-manager/test/e2e/split/main.go @@ -4,7 +4,6 @@ import ( "flag" "fmt" "io" - "io/ioutil" "log" "math" "os" @@ -106,7 +105,7 @@ func findDescribes(logger logrus.FieldLogger, dir string) ([]string, error) { return nil, err } for _, match := range matches { - b, err := ioutil.ReadFile(match) + b, err := os.ReadFile(match) if err != nil { return nil, err } diff --git a/staging/operator-lifecycle-manager/test/e2e/webhook_e2e_test.go b/staging/operator-lifecycle-manager/test/e2e/webhook_e2e_test.go index 4b80b9e626..8726f7c3e3 100644 --- a/staging/operator-lifecycle-manager/test/e2e/webhook_e2e_test.go +++ b/staging/operator-lifecycle-manager/test/e2e/webhook_e2e_test.go @@ -639,6 +639,7 @@ var _ = Describe("CSVs with a Webhook", func() { }).Should(Equal(2)) }) When("Installed from a catalog Source", func() { + const csvName = "webhook-operator.v0.0.1" var cleanupCSV cleanupFunc var cleanupCatSrc cleanupFunc var cleanupSubscription cleanupFunc @@ -687,7 +688,7 @@ var _ = Describe("CSVs with a Webhook", func() { defer cleanupSubscription() // Wait for webhook-operator v2 csv to succeed - csv, err := awaitCSV(crc, source.GetNamespace(), "webhook-operator.v0.0.1", csvSucceededChecker) + csv, err := awaitCSV(crc, source.GetNamespace(), csvName, csvSucceededChecker) require.NoError(GinkgoT(), err) cleanupCSV = buildCSVCleanupFunc(c, crc, *csv, source.GetNamespace(), true, true) @@ -775,6 +776,25 @@ var _ = Describe("CSVs with a Webhook", func() { require.True(GinkgoT(), ok, "Unable to get spec.conversion.valid of v2 object") require.True(GinkgoT(), v2SpecConversionMutate) require.True(GinkgoT(), v2SpecConversionValid) + + // Check that conversion strategies are disabled after uninstalling the operator. + err = crc.OperatorsV1alpha1().ClusterServiceVersions(generatedNamespace.GetName()).Delete(context.TODO(), csvName, metav1.DeleteOptions{}) + require.NoError(GinkgoT(), err) + + Eventually(func() error { + crd, err := c.ApiextensionsInterface().ApiextensionsV1().CustomResourceDefinitions().Get(context.TODO(), "webhooktests.webhook.operators.coreos.io", metav1.GetOptions{}) + if err != nil { + return err + } + + if crd.Spec.Conversion.Strategy != apiextensionsv1.NoneConverter { + return fmt.Errorf("conversion strategy is not NoneConverter") + } + if crd.Spec.Conversion.Webhook != nil { + return fmt.Errorf("webhook is not nil") + } + return nil + }).Should(Succeed()) }) }) When("WebhookDescription has conversionCRDs field", func() { diff --git a/staging/operator-lifecycle-manager/util/cpb/main.go b/staging/operator-lifecycle-manager/util/cpb/main.go index ae9912bf97..5b1769bb37 100644 --- a/staging/operator-lifecycle-manager/util/cpb/main.go +++ b/staging/operator-lifecycle-manager/util/cpb/main.go @@ -2,7 +2,6 @@ package main import ( "fmt" - "io/ioutil" "os" "path/filepath" @@ -118,7 +117,7 @@ func getMetadata() (m *metadata, err error) { m.annotationsFile = path // Unmarshal metadata - content, err := ioutil.ReadFile(path) + content, err := os.ReadFile(path) if err != nil { return fmt.Errorf("couldn't get content of annotations.yaml file: %s", path) } diff --git a/staging/operator-registry/.github/workflows/retest.yaml b/staging/operator-registry/.github/workflows/retest.yaml deleted file mode 100644 index 5886e8946c..0000000000 --- a/staging/operator-registry/.github/workflows/retest.yaml +++ /dev/null @@ -1,14 +0,0 @@ -on: - issue_comment: - types: [created] - -jobs: - rerun_pr_tests: - name: rerun_pr_tests - if: ${{ github.event.issue.pull_request }} - runs-on: ubuntu-20.04 - steps: - - uses: estroz/rerun-actions@main - with: - repo_token: ${{ secrets.GITHUB_TOKEN }} - comment_id: ${{ github.event.comment.id }} diff --git a/staging/operator-registry/Makefile b/staging/operator-registry/Makefile index d96b94a3b8..7ea7aef2ea 100644 --- a/staging/operator-registry/Makefile +++ b/staging/operator-registry/Makefile @@ -115,8 +115,8 @@ clean: @rm -rf ./bin .PHONY: e2e -e2e: - $(GO) run github.com/onsi/ginkgo/v2/ginkgo --v --randomize-all --progress --trace --randomize-suites --race $(if $(TEST),-focus '$(TEST)') $(TAGS) ./test/e2e -- $(if $(SKIPTLS),-skip-tls-verify true) $(if $(USEHTTP),-use-http true) +e2e: ginkgo + $(GINKGO) --v --randomize-all --progress --trace --randomize-suites --race $(if $(TEST),-focus '$(TEST)') $(TAGS) ./test/e2e -- $(if $(SKIPTLS),-skip-tls-verify true) $(if $(USEHTTP),-use-http true) .PHONY: release export OPM_IMAGE_REPO ?= quay.io/operator-framework/opm @@ -137,8 +137,8 @@ export LATEST_IMAGE_OR_EMPTY ?= $(shell \ && [ "$(shell echo -e "$(OPM_VERSION)\n$(LATEST_TAG)" | sort -rV | head -n1)" == "$(OPM_VERSION)" ] \ && echo "$(OPM_IMAGE_REPO):latest" || echo "") release: RELEASE_ARGS ?= release --rm-dist --snapshot -f release/goreleaser.$(shell go env GOOS).yaml -release: - ./scripts/fetch goreleaser 1.4.1 && ./bin/goreleaser $(RELEASE_ARGS) +release: goreleaser + $(GORELEASER) $(RELEASE_ARGS) # tagged-or-empty returns $(OPM_IMAGE_REPO):$(1) when HEAD is assigned a non-prerelease semver tag, # otherwise the empty string. An empty string causes goreleaser to skip building @@ -150,3 +150,32 @@ $(shell \ && git describe --tags --exact-match HEAD >/dev/null 2>&1 \ && echo "$(OPM_IMAGE_REPO):$(1)" || echo "" ) endef + +################ +# Hack / Tools # +################ + +GO_INSTALL_OPTS ?= "-mod=mod" + +## Location to install dependencies to +LOCALBIN ?= $(shell pwd)/bin +$(LOCALBIN): + mkdir -p $(LOCALBIN) + +## Tool Binaries +GORELEASER ?= $(LOCALBIN)/goreleaser +GINKGO ?= $(LOCALBIN)/ginkgo + +## Tool Versions +GORELEASER_VERSION ?= v1.8.3 +GINKGO_VERSION ?= v2.1.3 + +.PHONY: goreleaser +goreleaser: $(GORELEASER) ## Download goreleaser locally if necessary. +$(GORELEASER): $(LOCALBIN) + GOBIN=$(LOCALBIN) go install $(GO_INSTALL_OPTS) github.com/goreleaser/goreleaser@$(GORELEASER_VERSION) + +.PHONY: ginkgo +ginkgo: $(GINKGO) ## Download ginkgo locally if necessary. +$(GINKGO): $(LOCALBIN) + GOBIN=$(LOCALBIN) go install $(GO_INSTALL_OPTS) github.com/onsi/ginkgo/v2/ginkgo@$(GINKGO_VERSION) diff --git a/staging/operator-registry/alpha/action/migrate_test.go b/staging/operator-registry/alpha/action/migrate_test.go index 1296cf80d0..ecaa0b3675 100644 --- a/staging/operator-registry/alpha/action/migrate_test.go +++ b/staging/operator-registry/alpha/action/migrate_test.go @@ -37,7 +37,7 @@ func TestMigrate(t *testing.T) { err := generateSqliteFile(dbFile, sqliteBundles) require.NoError(t, err) - reg, err := newMigrateRegistry(sqliteBundles) + reg, err := newMigrateRegistry(t, sqliteBundles) require.NoError(t, err) specs := []spec{ @@ -118,8 +118,8 @@ func TestMigrate(t *testing.T) { } } -func newMigrateRegistry(imageMap map[image.Reference]string) (image.Registry, error) { - subSqliteImage, err := generateSqliteFS(imageMap) +func newMigrateRegistry(t *testing.T, imageMap map[image.Reference]string) (image.Registry, error) { + subSqliteImage, err := generateSqliteFS(t, imageMap) if err != nil { return nil, err } diff --git a/staging/operator-registry/alpha/action/render_test.go b/staging/operator-registry/alpha/action/render_test.go index e36872a89d..c3385dabd9 100644 --- a/staging/operator-registry/alpha/action/render_test.go +++ b/staging/operator-registry/alpha/action/render_test.go @@ -33,7 +33,7 @@ func TestRender(t *testing.T) { assertion require.ErrorAssertionFunc } - reg, err := newRegistry() + reg, err := newRegistry(t) require.NoError(t, err) foov1csv, err := bundleImageV1.ReadFile("testdata/foo-bundle-v0.1.0/manifests/foo.v0.1.0.csv.yaml") require.NoError(t, err) @@ -563,7 +563,7 @@ func TestAllowRefMask(t *testing.T) { expectErr error } - reg, err := newRegistry() + reg, err := newRegistry(t) require.NoError(t, err) dir := t.TempDir() @@ -766,13 +766,13 @@ var bundleImageV2NoCSVRelatedImages embed.FS //go:embed testdata/foo-index-v0.2.0-declcfg/foo/* var declcfgImage embed.FS -func newRegistry() (image.Registry, error) { +func newRegistry(t *testing.T) (image.Registry, error) { imageMap := map[image.Reference]string{ image.SimpleReference("test.registry/foo-operator/foo-bundle:v0.1.0"): "testdata/foo-bundle-v0.1.0", image.SimpleReference("test.registry/foo-operator/foo-bundle:v0.2.0"): "testdata/foo-bundle-v0.2.0", } - subSqliteImage, err := generateSqliteFS(imageMap) + subSqliteImage, err := generateSqliteFS(t, imageMap) if err != nil { return nil, err } @@ -828,12 +828,8 @@ func newRegistry() (image.Registry, error) { }, nil } -func generateSqliteFS(imageMap map[image.Reference]string) (fs.FS, error) { - dir, err := os.MkdirTemp("", "opm-render-test-") - if err != nil { - return nil, err - } - defer os.RemoveAll(dir) +func generateSqliteFS(t *testing.T, imageMap map[image.Reference]string) (fs.FS, error) { + dir := t.TempDir() dbFile := filepath.Join(dir, "index.db") if err := generateSqliteFile(dbFile, imageMap); err != nil { diff --git a/staging/operator-registry/alpha/property/property_test.go b/staging/operator-registry/alpha/property/property_test.go index 8c24f80166..8a05c450bd 100644 --- a/staging/operator-registry/alpha/property/property_test.go +++ b/staging/operator-registry/alpha/property/property_test.go @@ -209,9 +209,7 @@ func TestFile_GetData(t *testing.T) { for _, s := range specs { t.Run(s.name, func(t *testing.T) { - dir, err := ioutil.TempDir("", "operator-registry-test-file-") - require.NoError(t, err) - defer os.RemoveAll(dir) + dir := t.TempDir() if s.createFile != nil { require.NoError(t, s.createFile(dir)) diff --git a/staging/operator-registry/pkg/image/mock_test.go b/staging/operator-registry/pkg/image/mock_test.go index 6846e57acf..8829a2240e 100644 --- a/staging/operator-registry/pkg/image/mock_test.go +++ b/staging/operator-registry/pkg/image/mock_test.go @@ -2,7 +2,6 @@ package image import ( "context" - "io/ioutil" "os" "path/filepath" "testing" @@ -16,9 +15,7 @@ func TestMockRegistry(t *testing.T) { dne := SimpleReference("dne") ctx := context.Background() - tmpDir, err := ioutil.TempDir("", "reg-test-mock-") - require.NoError(t, err) - defer os.RemoveAll(tmpDir) + tmpDir := t.TempDir() r := MockRegistry{ RemoteImages: map[Reference]*MockImage{ @@ -44,7 +41,7 @@ func TestMockRegistry(t *testing.T) { // Test unpack and labels of unpulled ref require.Error(t, r.Unpack(ctx, exists, tmpDir)) - _, err = r.Labels(ctx, exists) + _, err := r.Labels(ctx, exists) require.Error(t, err) // Test pull of existing ref diff --git a/staging/operator-registry/pkg/lib/bundle/generate_test.go b/staging/operator-registry/pkg/lib/bundle/generate_test.go index 1464407ee9..814493eef7 100644 --- a/staging/operator-registry/pkg/lib/bundle/generate_test.go +++ b/staging/operator-registry/pkg/lib/bundle/generate_test.go @@ -181,8 +181,7 @@ COPY x/y/z /metadata/ } func TestCopyYamlOutput(t *testing.T) { - testOutputDir, _ := ioutil.TempDir("./", "test-generate") - defer os.RemoveAll(testOutputDir) + testOutputDir := t.TempDir() testContent := []byte{0, 1, 0, 0} testManifestDir := "./testdata/generate/manifests" @@ -224,8 +223,7 @@ func TestCopyYamlOutput_NoOutputDir(t *testing.T) { } func TestCopyYamlOutput_NestedCopy(t *testing.T) { - testOutputDir, _ := ioutil.TempDir("./", "test-generate") - defer os.RemoveAll(testOutputDir) + testOutputDir := t.TempDir() testContent := []byte{0, 1, 0, 0} testManifestDir := "./testdata/generate/nested_manifests" diff --git a/staging/operator-registry/pkg/lib/registry/registry_test.go b/staging/operator-registry/pkg/lib/registry/registry_test.go index b92a088d93..e55614ea25 100644 --- a/staging/operator-registry/pkg/lib/registry/registry_test.go +++ b/staging/operator-registry/pkg/lib/registry/registry_test.go @@ -630,8 +630,7 @@ func TestCheckForBundles(t *testing.T) { for _, tt := range tests { t.Run(tt.description, func(t *testing.T) { - tmpdir, err := os.MkdirTemp(".", "tmpdir-*") - defer os.RemoveAll(tmpdir) + tmpdir := t.TempDir() db, cleanup := CreateTestDb(t) defer cleanup() load, err := sqlite.NewSQLLiteLoader(db) diff --git a/staging/operator-registry/pkg/registry/populator_test.go b/staging/operator-registry/pkg/registry/populator_test.go index 1666f58632..b7b83a27fd 100644 --- a/staging/operator-registry/pkg/registry/populator_test.go +++ b/staging/operator-registry/pkg/registry/populator_test.go @@ -1184,9 +1184,7 @@ func TestDeprecatePackage(t *testing.T) { } func TestAddAfterDeprecate(t *testing.T) { - tmpdir, err := os.MkdirTemp(".", "add-after-deprecate-*") - require.NoError(t, err) - defer os.RemoveAll(tmpdir) + tmpdir := t.TempDir() /* (0.1) 0.1.2 <- 0.1.1 <- 0.1.0 diff --git a/staging/operator-registry/pkg/sqlite/conversion_test.go b/staging/operator-registry/pkg/sqlite/conversion_test.go index 8d80fb8607..659fce4841 100644 --- a/staging/operator-registry/pkg/sqlite/conversion_test.go +++ b/staging/operator-registry/pkg/sqlite/conversion_test.go @@ -2,8 +2,6 @@ package sqlite import ( "context" - "io/ioutil" - "os" "path/filepath" "testing" @@ -12,11 +10,7 @@ import ( ) func TestToModel(t *testing.T) { - tmpDir, err := ioutil.TempDir("", "server_test-") - if err != nil { - logrus.Fatal(err) - } - defer os.RemoveAll(tmpDir) + tmpDir := t.TempDir() dbPath := filepath.Join(tmpDir, "test.db") db, err := Open(dbPath) diff --git a/staging/operator-registry/pkg/sqlite/directory_test.go b/staging/operator-registry/pkg/sqlite/directory_test.go index 2df0c33a14..d9a41ef588 100644 --- a/staging/operator-registry/pkg/sqlite/directory_test.go +++ b/staging/operator-registry/pkg/sqlite/directory_test.go @@ -2,7 +2,6 @@ package sqlite import ( "context" - "io/ioutil" "os" "path/filepath" "testing" @@ -38,13 +37,7 @@ func TestDirectoryLoaderWithBadPackageData(t *testing.T) { require.NoError(t, store.Migrate(context.TODO())) // Copy golden manifests to a temp dir - dir, err := ioutil.TempDir("testdata", "manifests-") - require.NoError(t, err) - defer func() { - if err := os.RemoveAll(dir); err != nil { - t.Fatal(err) - } - }() + dir := t.TempDir() require.NoError(t, copy.Copy("./testdata/loader_data", dir)) // Point the first channel at a CSV that doesn't exist diff --git a/staging/operator-registry/scripts/fetch b/staging/operator-registry/scripts/fetch deleted file mode 100755 index 3a5b8dabae..0000000000 --- a/staging/operator-registry/scripts/fetch +++ /dev/null @@ -1,31 +0,0 @@ -#!/usr/bin/env bash - -ROOT="$( git rev-parse --show-toplevel )" - -fetch() { - local tool=$1; shift - local ver=$1; shift - - local ver_cmd="" - local tool_fetch_cmd="" - case "$tool" in - "golangci-lint") - ver_cmd="${ROOT}/bin/golangci-lint --version 2>/dev/null | cut -d\" \" -f4" - fetch_cmd="curl -sSfL \"https://raw.githubusercontent.com/golangci/golangci-lint/v${ver}/install.sh\" | sh -s -- -b \"${ROOT}/bin\" \"v${ver}\"" - ;; - "goreleaser") - ver_cmd="${ROOT}/bin/goreleaser --version 2>/dev/null | grep 'goreleaser version' | cut -d' ' -f3" - fetch_cmd="GOBIN=${ROOT}/bin go install github.com/goreleaser/goreleaser@v${ver}" - ;; - *) - echo "unknown tool $tool" - return 1 - ;; - esac - - if [[ "${ver}" != "$(eval ${ver_cmd})" ]]; then - echo "${tool} missing or not version '${ver}', downloading..." - eval ${fetch_cmd} - fi -} -fetch $@ diff --git a/vendor/github.com/operator-framework/api/crds/operators.coreos.com_subscriptions.yaml b/vendor/github.com/operator-framework/api/crds/operators.coreos.com_subscriptions.yaml index 7bcc8c94f1..3523401502 100644 --- a/vendor/github.com/operator-framework/api/crds/operators.coreos.com_subscriptions.yaml +++ b/vendor/github.com/operator-framework/api/crds/operators.coreos.com_subscriptions.yaml @@ -63,6 +63,467 @@ spec: description: SubscriptionConfig contains configuration specified for a subscription. type: object properties: + affinity: + description: If specified, overrides the pod's scheduling constraints. nil sub-attributes will *not* override the original values in the pod.spec for those sub-attributes. Use empty object ({}) to erase original sub-attribute values. + type: object + properties: + nodeAffinity: + description: Describes node affinity scheduling rules for the pod. + type: object + properties: + preferredDuringSchedulingIgnoredDuringExecution: + description: The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred. + type: array + items: + description: An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op). + type: object + required: + - preference + - weight + properties: + preference: + description: A node selector term, associated with the corresponding weight. + type: object + properties: + matchExpressions: + description: A list of node selector requirements by node's labels. + type: array + items: + description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: The label key that the selector applies to. + type: string + operator: + description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. + type: string + values: + description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchFields: + description: A list of node selector requirements by node's fields. + type: array + items: + description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: The label key that the selector applies to. + type: string + operator: + description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. + type: string + values: + description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch. + type: array + items: + type: string + weight: + description: Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100. + type: integer + format: int32 + requiredDuringSchedulingIgnoredDuringExecution: + description: If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node. + type: object + required: + - nodeSelectorTerms + properties: + nodeSelectorTerms: + description: Required. A list of node selector terms. The terms are ORed. + type: array + items: + description: A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm. + type: object + properties: + matchExpressions: + description: A list of node selector requirements by node's labels. + type: array + items: + description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: The label key that the selector applies to. + type: string + operator: + description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. + type: string + values: + description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchFields: + description: A list of node selector requirements by node's fields. + type: array + items: + description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: The label key that the selector applies to. + type: string + operator: + description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. + type: string + values: + description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch. + type: array + items: + type: string + podAffinity: + description: Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)). + type: object + properties: + preferredDuringSchedulingIgnoredDuringExecution: + description: The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. + type: array + items: + description: The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s) + type: object + required: + - podAffinityTerm + - weight + properties: + podAffinityTerm: + description: Required. A pod affinity term, associated with the corresponding weight. + type: object + required: + - topologyKey + properties: + labelSelector: + description: A label query over a set of resources, in this case pods. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaceSelector: + description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaces: + description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace". + type: array + items: + type: string + topologyKey: + description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. + type: string + weight: + description: weight associated with matching the corresponding podAffinityTerm, in the range 1-100. + type: integer + format: int32 + requiredDuringSchedulingIgnoredDuringExecution: + description: If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied. + type: array + items: + description: Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running + type: object + required: + - topologyKey + properties: + labelSelector: + description: A label query over a set of resources, in this case pods. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaceSelector: + description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaces: + description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace". + type: array + items: + type: string + topologyKey: + description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. + type: string + podAntiAffinity: + description: Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)). + type: object + properties: + preferredDuringSchedulingIgnoredDuringExecution: + description: The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. + type: array + items: + description: The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s) + type: object + required: + - podAffinityTerm + - weight + properties: + podAffinityTerm: + description: Required. A pod affinity term, associated with the corresponding weight. + type: object + required: + - topologyKey + properties: + labelSelector: + description: A label query over a set of resources, in this case pods. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaceSelector: + description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaces: + description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace". + type: array + items: + type: string + topologyKey: + description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. + type: string + weight: + description: weight associated with matching the corresponding podAffinityTerm, in the range 1-100. + type: integer + format: int32 + requiredDuringSchedulingIgnoredDuringExecution: + description: If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied. + type: array + items: + description: Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running + type: object + required: + - topologyKey + properties: + labelSelector: + description: A label query over a set of resources, in this case pods. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaceSelector: + description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces. + type: object + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. The requirements are ANDed. + type: array + items: + description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + type: object + required: + - key + - operator + properties: + key: + description: key is the label key that the selector applies to. + type: string + operator: + description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + type: array + items: + type: string + matchLabels: + description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + additionalProperties: + type: string + namespaces: + description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace". + type: array + items: + type: string + topologyKey: + description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. + type: string env: description: Env is a list of environment variables to set in the container. Cannot be updated. type: array diff --git a/vendor/github.com/operator-framework/api/crds/zz_defs.go b/vendor/github.com/operator-framework/api/crds/zz_defs.go index 3578ef32e0..1a607ea5ea 100644 --- a/vendor/github.com/operator-framework/api/crds/zz_defs.go +++ b/vendor/github.com/operator-framework/api/crds/zz_defs.go @@ -225,7 +225,7 @@ func operatorsCoreosCom_operatorsYaml() (*asset, error) { return a, nil } -var _operatorsCoreosCom_subscriptionsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x7d\x6b\x73\xe3\xb8\x95\xe8\xf7\xf9\x15\x28\x27\x55\xb6\xb3\x92\xdc\x9d\x9d\x4d\x72\xbd\xa9\xa4\x3c\xb6\x3b\xd1\x4e\xb7\xdb\xdb\x72\xf7\x54\x6e\x92\x9b\x40\x24\x24\x61\x4c\x02\x1c\x00\x94\x5b\x79\xfc\xf7\x5b\x38\x07\x00\x41\xea\x45\xca\xf2\xa3\x67\xcc\x0f\x33\x6d\x0a\x00\x81\x83\x83\xf3\xc2\x79\xd0\x82\x7f\x62\x4a\x73\x29\x4e\x09\x2d\x38\xfb\x6c\x98\xb0\x7f\xe9\xc1\xed\x6f\xf4\x80\xcb\x93\xf9\xeb\xaf\x6e\xb9\x48\x4f\xc9\x79\xa9\x8d\xcc\x3f\x30\x2d\x4b\x95\xb0\x0b\x36\xe1\x82\x1b\x2e\xc5\x57\x39\x33\x34\xa5\x86\x9e\x7e\x45\x08\x15\x42\x1a\x6a\x5f\x6b\xfb\x27\x21\x89\x14\x46\xc9\x2c\x63\xaa\x3f\x65\x62\x70\x5b\x8e\xd9\xb8\xe4\x59\xca\x14\x0c\xee\x3f\x3d\x7f\x35\xf8\xcd\xe0\xd5\x57\x84\x24\x8a\x41\xf7\x1b\x9e\x33\x6d\x68\x5e\x9c\x12\x51\x66\xd9\x57\x84\x08\x9a\xb3\x53\xa2\xcb\xb1\x4e\x14\x2f\xe0\x13\x03\x59\x30\x45\x8d\x54\x7a\x90\x48\xc5\xa4\xfd\x5f\xfe\x95\x2e\x58\x62\x3f\x3e\x55\xb2\x2c\x4e\xc9\xca\x36\x38\x9c\x9f\x23\x35\x6c\x2a\x15\xf7\x7f\x13\xd2\x27\x32\xcb\xe1\xdf\xb8\xf6\x51\xf4\x55\x78\x9d\x71\x6d\xbe\x5d\xfa\xe9\x2d\xd7\x06\x7e\x2e\xb2\x52\xd1\xac\x31\x5b\xf8\x45\xcf\xa4\x32\x57\xd5\xb7\xed\xb7\x74\x39\x8e\xff\xed\x1a\x72\x31\x2d\x33\xaa\xea\x83\x7c\x45\x88\x4e\x64\xc1\x4e\x09\x8c\x51\xd0\x84\xa5\x5f\x11\xe2\xe0\xe8\xc6\xec\x13\x9a\xa6\xb0\x37\x34\xbb\x56\x5c\x18\xa6\xce\x65\x56\xe6\x22\x7c\xd3\xb6\x49\x59\x18\xf5\x94\xdc\xcc\x18\x29\x68\x72\x4b\xa7\xcc\x7f\x6f\xcc\x52\x62\x64\xe8\x40\xc8\xf7\x5a\x8a\x6b\x6a\x66\xa7\x64\x60\x41\x3c\xb0\x10\x8c\x7e\xc6\xfd\xb9\xc6\x41\xa2\xf7\x66\x61\xa7\xab\x8d\xe2\x62\xba\xe9\xf3\x09\x35\x34\x93\x53\x82\xf8\x45\x26\x52\x11\x33\x63\xc4\x7e\x8a\x4f\x38\x4b\xfd\xfc\x36\xcc\x08\xbb\x2e\xcd\x69\xd4\x7c\xdd\x7a\x4a\x33\x2a\x04\xcb\x88\x9c\x90\xb2\x48\xa9\x61\x9a\x18\x59\xc1\x67\x33\x78\x5c\xe7\xa5\xd9\x9c\x2f\xbd\x5f\x31\x1d\x6c\x3a\x7f\x4d\xb3\x62\x46\x5f\xbb\x97\x3a\x99\xb1\x9c\x56\x7b\x28\x0b\x26\xce\xae\x87\x9f\xfe\x73\xd4\xf8\x81\xd4\x97\x12\xa3\x28\xb9\x65\xac\xd0\xd5\xa1\x20\x65\x61\xd7\x64\x17\x47\xc6\x0b\x62\x14\x4d\x6e\xb9\x98\xc2\xd2\xa7\xb8\xde\x73\xdc\x18\x3d\x58\x9a\xb2\x1c\x7f\xcf\x12\x13\xbd\x56\xec\x87\x92\x2b\x96\xc6\x53\xb1\x90\xf5\x24\xa2\xf1\xda\xc2\x29\x7a\x55\x28\x3b\x2d\x13\x9d\x43\x7c\x22\x1a\x55\x7b\xdf\x58\xe6\xa1\x85\x05\xb6\x23\xa9\x25\x4f\x76\xfa\x33\xe6\x0f\x07\x4b\x1d\x00\xed\x76\x9a\x19\xd7\x44\xb1\x42\x31\xcd\x04\x12\x2c\xfb\x9a\x0a\xb7\xa6\x01\x19\x31\x65\x3b\xda\x03\x5b\x66\xa9\xa5\x63\x73\xa6\x0c\x51\x2c\x91\x53\xc1\xff\x11\x46\x03\x10\xd9\xcf\x64\x16\x3f\x0c\x81\xe3\x26\x68\x46\xe6\x34\x2b\x59\x8f\x50\x91\x92\x9c\x2e\x88\x62\x76\x5c\x52\x8a\x68\x04\x68\xa2\x07\xe4\x9d\x54\x8c\x70\x31\x91\xa7\x64\x66\x4c\xa1\x4f\x4f\x4e\xa6\xdc\x78\x0a\x9c\xc8\x3c\x2f\x05\x37\x8b\x13\x20\xa6\x7c\x5c\xda\x8d\x3b\x49\xd9\x9c\x65\x27\x9a\x4f\xfb\x54\x25\x33\x6e\x58\x62\x4a\xc5\x4e\x68\xc1\xfb\x30\x59\x81\x24\x32\x4f\x7f\xa6\x1c\xcd\xd6\x87\x0d\xf0\xad\x3c\x07\xc4\x53\xbd\x8d\xb0\xb6\xc4\x8f\x70\x4d\xa8\xeb\x8e\x6b\xa9\x40\x6a\x5f\x59\xa8\x7c\xb8\x1c\xdd\x10\x3f\x01\x04\x3b\x42\xb8\x6a\xaa\x2b\x60\x5b\x40\x71\x31\x61\x0a\x5b\x4e\x94\xcc\x61\x14\x26\xd2\x42\x72\x61\xe0\x8f\x24\xe3\x4c\x18\x7b\x0c\x73\x6e\x34\xe0\x1c\xd3\xc6\xee\xc3\x80\x9c\x03\x03\x22\x63\xe6\x0e\x6c\x3a\x20\x43\x41\xce\x69\xce\xb2\x73\xaa\xd9\x83\x83\xda\x42\x54\xf7\x2d\xf8\xda\x03\x3b\xe6\x9f\xcb\x1d\x96\xce\x18\x21\x9e\xc1\xad\xdd\x9d\xf8\xc0\x8f\x0a\x96\x84\xe3\x40\x05\x39\x2b\x8a\x8c\x27\x88\xf1\x66\x46\x0d\x49\xa8\xb0\xf0\xe2\x42\x1b\x9a\x65\xc0\x4e\x5a\xcd\x62\xdd\x69\x27\x70\xb4\x1b\xcc\xc1\xbf\x5e\xa2\xd0\xf5\x1f\x02\x53\x6b\xb4\x58\x47\x19\xec\xe3\xe8\xec\xf2\x0f\x1b\x40\x4e\x50\x32\x99\xf0\xe9\xaa\x6e\x6b\x61\x79\x0e\x5d\x40\xa6\xa1\x5c\x68\x37\x44\xa9\x10\x9a\x15\xa7\xb2\xbc\x8b\xd6\xf8\xf6\x60\xed\xec\x56\x42\x76\xdb\x9a\xed\xc3\xc4\x7c\xf5\x0f\x8d\x05\x5c\x8a\x39\x1e\x54\x2b\xb3\x58\x22\xc7\xc4\x9c\x2b\x29\x72\x7b\x88\xe6\x54\x71\x3a\xce\x1c\x63\x63\x96\x7c\xe1\x19\xc3\x25\x32\xb5\xea\x48\xad\xf9\x2a\xae\x87\x2a\x45\x17\x6b\x5a\x70\xc3\xf2\x35\xab\x59\x35\xed\x4f\x54\x45\x54\xc2\x22\xef\xaa\xa9\x13\xd7\xc0\x4e\x9d\x92\xf3\x30\xf1\xb5\x9f\xd9\x02\x77\x7c\xd6\xe3\x76\xf5\xac\xc1\x72\xff\x6c\xdb\x40\x7c\x80\xd3\x6f\xf8\xbd\x01\x16\x7b\x42\x90\x81\xb1\x95\xd0\x18\x90\x77\xa5\x86\xdd\xa2\xe4\xfc\x6f\xc3\x8b\xcb\xab\x9b\xe1\x9b\xe1\xe5\x87\xf5\xe0\x20\xdb\x0e\x4a\xf5\x00\x8d\xef\x30\xd9\xc3\x4f\x7e\x8f\x14\x9b\x30\xc5\x44\xc2\x34\xf9\xf9\xd1\xa7\xb3\x0f\x7f\xbb\x3a\x7b\x77\x79\x4c\xa8\x62\x84\x7d\x2e\xa8\x48\x59\x4a\x4a\xed\x99\x46\xa1\xd8\x9c\xcb\x52\x67\x0b\x47\xb9\xd2\x35\x48\xdb\xc4\x56\xe0\xb6\x54\x2c\x88\x66\x6a\xce\x93\xd5\x20\xd2\x03\x32\x9c\x10\x5a\x21\x50\x12\x30\xdc\x32\xaa\x6c\xce\xd2\x1e\x0c\x1b\x26\xed\xbf\xc3\x45\x51\x1a\xcf\xf0\xee\x78\x96\xc1\xa9\x10\x28\x2b\xa5\x03\x72\x21\x4b\x3b\xde\xcf\x7f\x0e\x0b\x53\x2c\x2d\x13\x10\xa2\x2d\x31\xe0\x62\x6a\x7f\xea\x91\xbb\x19\x4f\x66\x84\x66\x99\xbc\xd3\x40\x29\x98\x4e\x68\xe1\x97\x1e\x43\x47\x2f\x84\xa1\x9f\x4f\x09\x1f\xb0\x01\x39\xf8\x79\xf4\xd3\x01\x7e\xbd\x50\xd2\x7e\x02\xe5\x64\x9c\x55\xc6\x0d\x53\x34\x23\x07\x71\xeb\x01\xb9\xb4\xdf\x60\x69\xbc\x0f\x30\x82\x60\x73\xa6\xec\x2a\xfc\x2e\xf4\x88\x62\x53\xaa\xd2\x8c\x69\x6d\xf1\xec\x6e\xc6\xcc\x8c\xa1\x28\x1e\x00\xc6\x3e\x73\xcb\x70\xa5\x22\x42\x9a\x01\xb9\x60\x13\x5a\x66\xc0\x81\xc9\xc1\xc1\xa0\xc9\xf8\x76\x47\xb5\x37\x4a\xe6\x1d\xd0\x6d\x54\xd7\x1c\x56\xed\xfd\xa1\xc6\x91\x6b\x64\x4d\xb3\x94\xf0\x89\x93\x60\xb8\xb6\x8b\x22\x2c\x2f\xcc\xa2\xcd\xa1\xd9\x42\x47\x48\x6b\x42\x40\x02\x4f\x7a\x47\x8b\x6f\xd9\xe2\x03\x9b\x6c\x6b\xde\x5c\x3f\xcb\x58\x62\x09\x25\xb9\x65\x0b\x10\x67\xc9\xb9\x1f\x70\xf3\x52\x3a\x2d\x87\xb4\x24\x8f\xfe\xe9\xdb\xe9\x6c\x6d\xd7\x1e\x48\xf6\xb9\x65\x8b\x36\xcd\xc8\xb2\x4e\x67\x41\x03\xbc\xce\xc2\x6a\x3b\x54\x48\x7b\x94\xf5\xcf\x76\x8a\xbe\x72\x72\x87\x31\x69\x77\xe7\xd4\xac\x14\x58\x6f\xcb\x31\x53\x82\x19\x06\x32\x6b\x2a\x13\x6d\xc5\xd5\x84\x15\x46\x9f\xc8\xb9\xa5\x7c\xec\xee\xe4\x4e\x2a\xab\xc8\xf5\xef\xb8\x99\xf5\x71\x57\xf5\x09\x18\x3d\x4e\x7e\x06\xff\x23\x37\xef\x2f\xde\x9f\x92\xb3\x34\x25\x12\x8e\x78\xa9\xd9\xa4\xcc\xc8\x84\xb3\x2c\xd5\x83\x48\xeb\xea\x81\x3e\xd0\x23\x25\x4f\x7f\xbf\xf9\x70\xef\x08\x31\x59\xa0\xb1\x62\x07\xa8\x8d\x40\xe8\x5a\xd4\xe8\x54\x40\x7a\x4b\xa1\xac\x8a\x60\xf7\x3c\x77\x6c\xd1\x31\x94\x0e\xcb\x18\x4b\x99\x31\x2a\xb6\xf4\x00\xb0\x75\x3f\xb3\x87\xd5\xa1\x85\x11\x3c\x02\x14\x32\x3d\x25\xba\x2c\x0a\xa9\x8c\x0e\x2a\x02\xd8\x5c\x7a\xf5\x3f\x41\x5e\xee\x91\xbf\x87\x97\x19\x1d\xb3\x4c\xff\xf9\xf0\xf0\xb7\xdf\x5e\xfe\xe9\x77\x87\x87\x7f\xfd\x7b\xfc\x6b\x64\xa1\xab\x37\x41\x9b\x8e\x4c\x41\x08\x77\x7f\x3a\x36\x7a\x96\x24\xb2\x14\xc6\xfd\x60\xa8\x29\xf5\x60\x26\xb5\x19\x5e\x87\x3f\x0b\x99\x36\xff\xd2\x5b\x38\x01\x79\x58\xa2\x03\xe0\xbc\xa6\x66\xb6\x67\xd2\xb3\xde\x1a\xb1\xfa\xa9\x6d\xb7\xb7\x4f\xb8\x5d\x76\x06\x09\xfb\xcf\x37\x7e\xba\x96\x03\xdd\x29\x6e\x0c\x13\x20\x77\x30\x95\x5b\x4e\xdc\xb3\x98\x5b\xb1\xd9\xf9\xeb\x83\x07\x21\x5e\x01\x6a\x3b\x2c\x0e\x66\xef\x56\x86\xc8\x1c\x08\xad\x97\xa0\x2a\x1d\xe9\xec\x7a\xe8\x2d\x33\x7b\x5f\x88\xb7\x37\xbc\xb9\xf7\x99\x0c\x96\x0b\xb7\xac\x20\x69\x9e\x12\x29\xb2\x45\xf8\x5d\x93\x8c\x83\x35\xc2\x0a\xa0\xc1\x22\x71\x84\x2f\x07\x49\x51\xf6\x5c\x83\x41\xce\x72\xa9\x16\xe1\x4f\x56\xcc\x58\x6e\x25\xb6\xbe\x36\x52\xd1\x29\xeb\x85\xee\xd8\x2d\xfc\x85\x1d\x6b\x1f\x58\xee\x8d\x22\x75\x52\x2a\xcb\x3c\xb2\x85\xa7\x20\x2c\x7d\xda\xb3\xe8\xc1\xb4\xe7\xa3\x18\x76\xe3\x6a\x47\x96\x1b\xb4\x45\x67\x70\xf5\xab\x02\x19\x72\x2e\xb3\x32\x67\xba\x17\xd8\x13\x4a\xeb\x62\x6e\xa5\xc9\x25\xf3\xce\xea\xa7\xe3\xe9\x4b\xf9\x9c\x6b\xa9\x76\xe6\x83\xdc\x99\x3c\x65\x69\xac\xa6\x32\x91\x2a\xa7\x26\xa8\x8b\x9f\x0b\xa9\x41\x07\x70\x38\xdb\x20\x29\xaf\x0f\x5a\x7d\xb6\xa0\xc6\x30\x25\x4e\xc9\xff\x3b\xfa\xcb\x7f\xfc\xab\x7f\xfc\xfb\xa3\xa3\x3f\xbf\xea\xff\x9f\xbf\xfe\xc7\xd1\x5f\x06\xf0\x8f\x5f\x1c\xff\xfe\xf8\x5f\xfe\x8f\xff\x38\x3e\x3e\x3a\xfa\xf3\xb7\xef\xfe\x70\x73\x7d\xf9\x57\x7e\xfc\xaf\x3f\x8b\x32\xbf\xc5\xbf\xfe\x75\xf4\x67\x76\xf9\xd7\x96\x83\x1c\x1f\xff\xfe\xe7\xad\xa6\x47\xc5\xe2\x7d\x8b\x03\x8f\x4f\xdf\x6d\x10\x17\x86\x4d\x99\xea\xd8\xab\xf5\xb6\x12\xf2\xb9\x5f\x09\x6d\x7d\x2e\x4c\x5f\xaa\x3e\x76\x3f\x25\x46\x95\xdb\x0f\x46\x45\xd4\x76\xc1\xf3\x0f\xfe\xb4\x46\xa6\x58\x4f\x9a\xf7\x8e\xc8\x9a\x25\x8a\x99\x7d\x69\x30\x38\x9a\xe7\x1f\x85\x4c\x0f\x35\x11\x6b\xcc\x84\xeb\xa6\xfd\x93\x50\x6a\xbc\x48\x81\xf0\xaa\x38\xef\x44\xc9\x7c\x40\x22\xb3\xd0\x9c\x66\x3c\xf5\xed\x6e\xd9\x16\x2d\xd7\x3f\x2f\x4a\xd0\x97\xa5\x04\x8d\x70\x7f\x1f\x5c\x03\x62\x62\xbe\xc9\x4c\xd3\xb4\xe9\xda\xb6\x75\x73\xb4\x17\xa0\x8c\x24\x85\x2c\xca\x8c\x9a\x35\x66\xbb\x15\xb6\x69\x87\xfb\x3a\x98\x09\xed\x46\x83\x1d\xd8\x51\xb9\x7c\xb5\x31\x94\x9c\x65\x19\xe1\x02\x4f\x02\x0c\xe0\xad\x79\x8a\xa1\xbc\x44\x28\x1a\x9c\xe7\x76\x0a\x77\x33\xd6\x34\x34\x72\x6d\x75\x1d\x65\xb8\x98\x0e\xc8\x77\xf6\x77\xa4\x59\xce\x34\xc6\x05\xc9\xcb\xcc\xf0\x22\x63\x24\x70\x5b\xb4\xa1\x65\x25\x23\x54\x6b\x99\x70\x6a\xdc\x8c\xdd\xfd\xa1\x36\x7e\xda\x30\x1b\x43\x6f\xc1\x14\x9a\xb0\x94\x89\x84\x0d\xc8\x27\xb8\x2e\x0c\x6b\x1d\x5b\x61\x10\xcc\xfb\x30\x06\x25\x69\x89\x57\x3b\x48\x0f\x56\x8f\x31\xcc\xf3\xd2\x80\xa1\xf8\xb1\xac\xf8\x76\xc7\x9d\x65\x2e\x32\xe6\x03\xa9\x0a\xa2\x35\x85\xbb\x07\x39\xa9\x54\x77\x7d\x3f\xf3\x7d\x3b\xc2\x1b\xcc\x6d\x5b\x39\xd5\x12\xc5\xad\x6c\x0c\x75\x4a\xfb\xd8\x16\xc3\x76\x74\xf6\x47\x49\x63\x3b\xd0\xd7\xf6\xb4\xb5\x83\x71\xa9\x2b\x3d\x6d\x6b\x4d\x2a\x14\x9b\xf0\xcf\x1d\xf0\xf1\x4c\x54\x2a\x0a\x4f\x99\x30\x56\x11\x50\x40\x50\x15\x2b\x98\x00\x3d\x9c\xd1\x64\x06\x74\xc1\x51\xd1\xca\x32\xfc\x90\x37\x46\x28\x65\x74\x3f\x5e\xa3\x55\x52\xcc\xcb\xd9\xfa\x91\x9f\x2d\xb7\xeb\xfb\x3f\x58\x42\xa6\x0c\x75\x8b\xf5\xca\x75\x63\x1f\xa3\x1e\xce\xcf\xc5\xff\x85\x17\x78\x7e\x92\x56\x7b\x0b\x57\x4e\x85\x84\xb3\x36\xe1\x86\x48\x2b\x11\xd8\xef\x0e\xc8\x68\x45\xcf\x9c\x9a\x64\xe6\x5a\x1c\x1e\x6a\x82\x46\xdb\xe6\x40\x63\x34\x11\xa6\x65\xc6\x52\xe2\x1d\x36\x70\xd0\x8e\x28\x55\x73\x55\x38\xa1\x5a\xf3\xa9\xe8\x17\x32\xed\xdb\xd1\x4e\xd6\x21\x44\x8b\x43\x15\xbb\x1a\x6e\x3f\x58\x5b\xf1\x2a\x18\x27\xda\x6d\xd3\x87\x60\x7f\x8b\x64\x8b\x44\xe6\x45\x69\x58\x64\x9c\x0b\x76\x9d\xf1\x02\x3d\x8b\x22\x19\xb2\x92\x88\xee\x07\xd3\x9c\x0a\x3a\x65\x7d\xf7\xf1\x7e\xf8\x78\x3f\x7c\xeb\x3e\x60\x6e\x43\xb5\xd0\xa4\xb8\xe9\x1c\xd6\x81\xf7\x16\x4d\x96\xf8\x72\xec\x4c\x47\x39\xfd\xcc\xf3\x32\x27\x34\x97\xa5\x00\x99\x6c\x19\x9c\x70\x79\xcd\xd2\xfd\x00\x6c\x05\xa0\xf4\x5a\x48\xb5\x84\x16\xe9\x8c\x98\xe4\xf9\x5a\xb6\x5a\x59\xb4\xba\x59\xb2\x3a\x58\xb0\x76\xb6\x5c\x79\x23\x75\x7b\x7c\xfc\xe0\xed\xe6\x0d\x8c\xe4\x62\x2b\x46\xfa\x03\x0e\xae\x1d\x61\x1c\xae\x89\xcc\xb9\x31\xc1\x25\x2b\x60\x58\x8f\x70\x53\xb3\x7e\xba\xb3\xc0\x27\x48\x63\xb9\x26\xec\xb3\xd5\xa6\x38\x58\xd1\xfd\xad\x45\x0f\xb9\xec\x1d\xd7\x60\x40\xa3\x82\xf0\xbc\xc8\x58\xee\x7d\x48\xfb\x5e\x37\x73\x4e\x06\x2f\xe7\xe3\xe5\x7c\xac\xea\xa4\xbb\xc8\x22\xb1\x18\x82\x86\x82\x31\xcb\x2a\x71\xc4\x62\x76\x21\x53\xed\xe4\x05\x8f\x43\xf6\x2c\x5c\x7e\xe6\x1a\x3c\x71\x3f\x30\xb0\x0c\x8c\x98\xd1\xe4\x6e\x26\x35\xc3\x1e\x54\x31\x37\x4e\xc4\x1a\xbd\x25\x04\xee\x11\xc0\x69\x74\x32\xa9\xb7\x48\x59\x91\xc9\x45\x0e\x92\xed\xd0\xc4\xf2\x4c\x10\x5d\x58\x5e\x64\xd4\xb0\x20\xd8\x6c\xb6\x36\xdc\x9b\xf3\xc1\xd7\x2f\x3f\x5b\x09\x20\x8a\x83\x68\x01\xdb\x66\xc7\xba\x69\xaa\x01\x69\x47\x64\x72\xf4\x59\xbe\x01\x09\xbf\x7a\x03\xd0\x3c\xbb\xba\x58\xef\x20\x49\x5a\x99\x57\xc8\x76\x13\xcb\xd2\x32\xce\x36\x4c\xb5\x21\xbd\xa2\xcf\xaf\xf7\x60\x45\x0f\xf4\x1e\x1a\xaf\x7a\xce\x7d\x2e\x44\x07\x60\x63\xc5\x32\x0c\x7d\x70\x86\x66\xdb\xc8\x79\xae\xef\x47\x23\x6b\x6b\x77\x6f\x63\x73\xef\x87\xc9\xef\x49\x09\x6c\x65\x94\xaf\x6d\x06\x28\xd9\xf1\x51\x05\x97\x23\x0b\x49\xb4\xcf\xbb\x8d\xa0\x45\x91\xc1\x7d\x9d\x6c\xeb\x9b\xd5\x52\x1d\xc3\xe5\x77\x9c\x74\xd8\xf2\xd8\xe1\xd6\xce\xfc\x50\x23\x02\xd8\xd3\x31\xe3\x85\xf3\x66\x44\x6b\x9d\x8f\x5f\xf8\x04\x76\xd4\x2a\xa6\xc4\x9e\x84\xa1\xe8\x91\x2b\x69\xec\xff\x2e\xd1\x26\x6a\xf1\xe6\x42\x32\x7d\x25\x0d\xbc\xd9\xeb\xb2\x71\x2a\x1d\x17\x8d\x9d\xe0\x80\x08\x3c\x93\x60\x90\x8e\x02\x1a\xd0\x57\x14\x48\xa1\x07\x10\xd7\x64\x28\x88\x54\x7e\x75\xc1\xaa\xab\xdd\x10\x5e\x33\x14\x52\xf4\xd1\x8d\x70\xd5\x18\x97\xc1\x87\x32\x86\xc9\x86\xe1\xdc\x50\x37\x96\x02\xe3\x2f\x18\xc2\x92\xd1\x84\xa5\x24\x2d\x61\xd2\x10\x8e\x41\x0d\x9b\xf2\x84\xe4\x4c\x4d\x99\x65\xda\xc9\xac\x2d\xa8\xb7\xd1\x25\x7c\x5a\x50\xa7\x78\xd0\x2d\xfb\x07\x24\xf8\x2d\x70\x89\x6e\x64\x1b\xfb\x20\x79\xcb\x69\x61\xb7\xee\x9f\x96\x8a\x01\xf4\xfe\x4d\x0a\xca\x95\x1e\x90\x33\xef\x7a\x1b\xff\xe6\x6c\x60\xf1\x30\x76\x04\x2b\xf5\xfd\x50\xf2\x39\xcd\x2c\xdd\x44\x01\x8f\xa1\x78\x67\x47\x6f\x32\x8b\x9e\xe3\xa5\xf6\x7c\xa3\xbf\x0b\xd7\xe4\xe0\x96\x2d\x0e\x7a\x4b\xdb\x7d\x30\x14\x07\x48\x5f\x97\x36\x38\x10\x63\xf0\x28\x39\x80\xdf\x0e\xee\xc7\x5f\x1e\x40\xf8\xdb\xba\x97\x46\x66\x4c\xc5\xa1\x9f\x5b\xf6\xf0\xa6\x6a\x0f\x4b\xab\xae\x77\xa3\x91\x1e\xe7\x96\xe2\xc6\x8b\x2d\xf6\x6c\x55\xf3\x02\xd4\x32\x86\x26\x33\xf4\xe2\x76\xf3\x82\x38\x9a\x05\xb1\x7b\x66\x90\xae\x03\x62\x38\x0e\x69\x14\x5c\xfa\xfc\x36\x60\x5b\x8f\x81\xfc\xf4\xbb\xc8\xbf\x1d\xda\xdb\x3f\x02\x86\xfc\xd6\xff\xeb\x77\xf7\x8c\x5b\x68\xc7\xd8\x70\x4a\x1d\x04\x8c\x4b\xe8\x40\xb8\x48\xe1\x82\xc9\x2d\x15\x20\x80\x63\x59\xf8\xc0\xb2\x06\xe4\xd2\x12\x2a\x92\x33\x2a\xb4\x37\x73\xc1\x4d\x54\xd5\x58\xbb\x2b\xb3\x48\xaf\x72\x26\x85\xea\x64\x30\x72\x25\x47\xce\xf6\xd5\x23\xd7\x60\x4b\xad\xde\xc0\x49\xba\x92\x97\x9f\x59\x52\x9a\xb5\x77\x59\x31\xdc\xb6\x72\x91\xad\x8c\xbe\x06\x90\x6f\x2b\x26\x8f\x2b\xab\x31\xf9\x0a\x83\x63\x36\xbf\x11\x32\xb7\x6c\x51\x31\x1b\x27\x42\x00\xc9\xef\x55\x58\xe2\x59\x01\xf2\x8e\xff\xf6\xa6\xac\x7c\xcc\x05\x7e\x0c\x87\xf6\x5b\x01\xa3\x7b\x80\x5a\xc9\x2e\xcb\xf0\x33\xfb\x00\x57\x3b\x39\xa3\x06\xb3\xf7\x1d\x64\x8c\x40\x25\x57\x4b\x17\x91\x48\x71\xf9\x43\x49\xb3\x7a\x10\x82\x7b\xe5\x1a\x2d\x51\xf5\x3b\x9e\xa5\x09\x55\xce\xcb\x0b\xc3\x34\xb5\xc4\xdd\xa3\x40\x08\x12\x2a\xc2\x69\xaf\xf6\x48\xe3\x55\x65\x41\x95\xe1\x49\x99\x51\xe5\x23\xc7\x5b\x05\x0a\x6c\x85\x68\x85\x34\x23\x96\x48\x91\x76\x51\x00\x6e\x9a\x7d\x9b\x77\xad\x05\x53\x5c\xa2\x77\x31\xcf\x59\x13\x49\x8f\xea\x36\x6d\x39\xf1\xa7\x3a\x1c\xb1\x9a\xe5\x03\x62\x33\x3d\xc3\xe3\x53\x21\x15\x4b\x8f\x23\xf2\x18\x4e\xc5\x80\x7c\xb3\xf0\x66\x16\x30\xb9\xb8\xe8\x0a\xcd\x8c\x0f\x84\xf1\x28\xeb\x80\x5d\x1d\xa8\x89\x54\x10\x9c\x72\x94\x4a\x8c\xc8\x98\xf3\xc4\x1c\x0f\xc8\xff\x65\x4a\xc2\xc6\x0b\x36\xa5\x86\xcf\x03\x37\x0d\x8a\xab\x62\xd4\xdd\xe0\xbf\x22\x47\xd0\x8d\xf0\x3c\x67\x29\xa7\x86\x65\x8b\x63\xd4\x63\x19\xd1\x0b\x6d\x58\xde\x66\xeb\xda\x18\x0d\xd0\xd7\x0e\xda\xfe\xea\xeb\x0d\x2d\xbb\xc6\x50\x7d\xf2\x51\x29\x15\x64\xd0\x87\xa0\xb1\x85\x81\x07\xc9\x0d\xe2\x66\xec\x83\xe0\x02\x9b\xbd\x64\x19\x6f\xf0\xf7\x16\x0f\x28\x51\x0c\x32\x10\x38\xcc\xbd\x27\x8e\xa3\x37\xe5\x3b\x59\x8a\xf5\x26\xc1\xda\xc2\xdf\x3a\x25\xfc\x53\xd4\x71\x6d\x94\xe2\xa3\x88\x09\xd1\x4c\x22\x13\x25\x25\x60\x97\x04\x76\x6e\xc9\x03\xb6\xaa\x3c\x51\xb6\x4e\x72\xaf\x11\x89\x30\x97\x2d\x5e\xef\x7b\x89\x5b\x0c\x1f\xea\x80\xcb\xe0\x20\xee\x00\xd3\x88\xdb\x33\x8e\x1c\x00\x7e\x22\x04\x2b\x04\x85\x6f\xb1\xd4\x7b\xb1\x59\x6a\xe0\xba\x92\xc3\xd3\xc3\xbd\x10\x5f\x5c\x8e\x92\x05\x9d\xc2\x79\xea\xb0\xaa\x66\x57\x92\x32\xc3\x54\x0e\x01\xd7\x33\x79\x87\xbf\x23\xdb\x2a\x5c\x2b\x96\x56\xb1\xed\x33\xa9\x81\x2b\xd5\x83\x18\xe1\xfc\xc2\xc5\xe8\x1d\x5d\x10\xaa\x64\x29\x52\x27\x35\x05\x02\xfa\xae\xf1\xe1\x2b\x29\x80\x52\x94\xda\xc2\xea\xa6\x46\xa5\xc7\xcc\x50\x7b\x6c\x5e\x0f\x5e\xbf\xda\x0b\xc0\x3a\xc6\xad\xc2\x6c\x1a\x96\x42\x7f\x57\xee\xcf\xcc\x5e\xe6\xa5\x18\x4d\xdf\x8b\xac\x8b\x2c\xf7\x0e\xd1\x0b\xba\xf6\x41\x09\xe3\x13\xb0\xdd\xf6\xf0\xd5\x9d\xe2\x86\x45\xe4\xf1\x68\x42\x33\xcd\xac\xea\x5e\x8a\x20\xc2\x1e\xd7\x45\x10\x68\xd2\x66\x41\xdb\xfd\x41\x74\x39\xbe\xe7\x39\x73\x07\x0a\x50\xae\x3a\x66\x01\xe1\x0e\xf5\x86\x23\x57\x0f\xee\x24\x47\xd8\xd2\x4a\x6c\x52\x9a\xe3\xfd\x38\x89\xe0\x02\xad\x66\xdd\x45\x25\xf1\x71\xc3\xc5\x1e\x57\xfb\x0d\x9b\xd1\x39\xd3\x44\xf3\x9c\x67\x54\x65\x10\x2b\x38\xc2\xf9\x91\x71\x69\x56\x47\xa0\x77\x8b\x6e\x8e\x67\x12\x0d\xb7\x15\xd4\x7e\x1e\x16\x4e\x40\x23\xfc\xbc\xec\x77\xf2\xd2\x94\x34\xcb\x16\x84\x7d\x4e\xb2\x52\xf3\xf9\x7d\x4f\x93\x8b\x7e\xd8\x81\x55\x37\xb9\x74\x21\xd3\x51\xc1\x92\xc7\xe4\xd1\x75\x0d\xc3\x92\xaa\xd4\x6f\x3a\xf0\x64\x54\xf6\x41\x73\x5f\x80\xe7\x53\x92\x30\xad\xbd\x4f\xe5\x22\xf6\xf3\x0c\x6b\xf8\x52\x12\x0a\xd0\x3b\x7d\x99\x51\x6d\x78\xf2\x4d\x26\x93\xdb\x91\x91\xaa\x53\xcc\xfe\xaa\xfe\x8d\x34\x0c\x67\xdf\x8d\xc8\x05\xd7\xb7\x71\x62\x17\xbc\x34\x8d\xcd\x25\x94\xdc\x96\x63\x96\x31\x73\x78\xa8\x91\xcb\xe5\x34\x99\x71\xc1\x3c\x83\x13\x21\x24\xc5\x29\x7c\x16\xca\x5d\xef\x4c\x5d\xe0\xd3\x89\xc3\xd7\x9f\xd1\x3b\xcd\x70\xfa\x63\x3b\x7d\xfb\x33\x6b\x13\x91\xbe\xd7\x7b\x0a\x9c\xcc\xf0\x62\x4f\x77\x10\x13\x7d\x63\xe7\xd8\xcd\xb8\x7d\x88\xbd\xbc\xea\x30\xe1\x19\x43\x8d\x07\x16\xec\x7d\xd4\xdc\xa9\x80\xfd\x5b\xc8\x92\xdc\x51\xd4\x91\x81\x22\x0e\xc8\x0d\x2f\x4e\xc9\xa5\xd0\xa5\x62\x95\x75\xa3\x39\x14\xd7\x55\x9c\x99\x57\xae\x60\xbf\x51\x01\xb1\x74\xcf\xe9\x5a\xe4\xf2\x33\xcd\x8b\x8c\xe9\x53\x72\xc0\x3e\x9b\xaf\x0f\x7a\xe4\xe0\xf3\x44\xdb\xff\x09\x33\xd1\x07\x03\x32\xcc\xc3\xad\x3b\x24\x02\x52\xcc\x3b\x42\x61\x07\xcb\x9a\x23\xae\xfb\x20\xe8\xe2\x9c\xea\xac\xec\x96\x4a\x72\x87\xf9\x28\x2c\xc1\x67\x4a\x49\x15\xfc\xd0\x23\x30\x00\xaf\x49\x64\x5e\x28\x99\xf3\xc8\xcc\x07\xe8\xbe\x57\x6f\x3b\x30\x3e\x6c\x17\x50\x97\xb1\x21\x74\xf4\x08\x11\xbd\x10\x6d\x50\x61\x38\xf1\xce\x14\xa8\x45\x3a\xb5\x1e\x86\x73\x8d\xec\xe6\xbb\x51\x2c\x21\x8b\xb7\xfb\x4d\x08\xa8\x23\x27\x29\x9b\x9f\xe8\x94\xbe\xee\xc1\x67\xb4\x73\x04\xac\xcf\x89\x6a\x72\xf0\xfa\x60\x40\x46\x9e\x11\xf7\xe2\x39\x56\xed\x26\x52\x85\x01\xc1\xce\xfe\xea\x80\x1c\x49\x05\x23\x27\x54\x90\x8c\xd1\xb9\xb3\x2d\xe3\x71\x5b\xa0\xba\x7b\xdc\x3a\x20\xb2\x6d\x6c\x58\x64\x00\xf8\xcf\x5f\x6e\x69\xdd\x4e\x48\x5d\xde\x44\xdf\xcf\x9b\x00\x54\xe9\x62\x05\x26\x52\xb9\x3c\x20\xa1\x89\x66\x06\x8e\x1e\x17\x35\x15\xfa\x09\x08\x2c\xe9\x18\x4a\xef\xa9\x67\x57\xe8\xf8\x7e\xa0\x03\x09\xfe\x43\xc9\xc8\xf0\x22\x04\xd4\x33\xa5\xb9\x36\xf6\x18\xa7\x35\xd6\xc5\x91\x9f\x1d\x9d\xe5\xf4\x1f\x52\x90\xcb\x6f\x46\x6e\x02\xc7\x4f\x0a\xaa\xad\xd4\x80\xfe\xa3\x54\xcc\x72\xe1\x0e\xcc\x3d\xf4\x69\x32\x74\xfb\x9e\x5c\x50\x43\x91\xaf\x3b\x4f\x2b\x51\x91\x72\xcb\xb2\xc7\x5c\xa4\xee\xa7\x88\x61\x3f\x36\x6f\xb5\xbb\x77\xb5\x49\x4c\x8a\x1b\x7e\xfc\x30\xdc\x13\x0f\x4e\x80\x98\x4f\xdf\xc9\xb4\x33\x23\x8e\xba\x7a\xe2\xfb\x47\x0b\xd3\x73\x7c\x4f\x72\x3b\x26\xb1\xda\x7b\x8f\x7c\x60\x34\x25\xf6\xfc\xba\x7f\x7e\x67\x75\xcf\xd6\xb4\xaa\x15\x0b\xf1\x00\xec\xb8\x0c\xdf\xcd\x2f\x21\xf6\x74\x4f\x2d\xe6\xc0\xb1\x72\xbc\x64\x9c\xc9\x31\x71\xc7\x61\xdf\x73\xff\xf8\x61\xb8\xc3\xd4\x3f\x7e\x18\xfa\x99\xdb\x7f\xca\xc9\xe3\x4d\x7a\x27\xf1\xad\x92\xde\xde\x34\xc4\xad\x8a\x25\x57\x81\x1b\x4d\x91\xac\xbd\x3c\x36\xd8\x97\x24\xb6\x4f\x88\xad\xca\x3f\xb9\x05\x5e\x87\xb6\x8f\x55\x28\xd0\x57\x2d\xba\x47\x1c\xcd\x28\x84\x3e\x87\x80\x3c\xd8\x67\xbb\xf1\xda\x72\x05\xbf\xe3\x56\x09\x04\xda\x46\x2e\x18\xde\x72\xa6\xa7\xde\x77\x20\xf4\x58\xdd\xe1\x1d\x78\x6a\xa6\x8e\xbe\x12\x74\xdc\x4c\x23\x04\x3b\x42\xab\x92\x08\x3f\xd1\x39\xe5\x19\x1d\xf3\x8c\x1b\xe0\xd4\xc7\x83\x9a\x37\xaa\x86\x29\xef\xf5\xd4\xef\x28\x72\x04\x71\x62\xc9\xb8\x45\x8e\xec\x6f\x27\x60\x1c\x3b\x1e\x00\xb5\x82\x86\x33\xa6\x96\x84\x92\x0f\xdb\x84\x92\xbd\xc9\x0f\xb0\x03\xf6\xc4\x74\xe5\x8a\xb6\xcf\x4a\xae\x08\x3f\x8c\x5c\x3e\xb9\xe7\xcc\x18\x31\xd6\xaa\x15\x6b\x04\xfc\xda\xda\xb2\x3d\x73\xbc\x2f\x72\xa5\x5f\x06\x72\x91\x10\xd1\xb6\x03\xff\xac\x3a\x7a\x3e\x04\x4a\x12\x78\x9c\xb9\x68\xb7\x9a\x6b\x26\x62\xdf\xc8\xd1\x1a\x97\x82\x09\xb9\xae\xc5\xb9\x6f\x5b\xa4\x1f\xe8\x92\xb4\xc1\x63\x44\xd7\x55\xf9\x7e\x7e\x51\x48\x02\xe1\x35\x69\x81\x8b\xad\x27\x99\xb0\x62\x36\xe9\x72\x25\x6e\x3b\xbc\x19\xd5\x2d\x81\xe7\xac\x98\x91\x37\xa3\x15\xc7\x18\x60\x0f\xb3\xd6\x68\x1f\x3c\xd4\x24\xe3\x13\x66\xf8\x96\x25\x3c\xc0\x41\xce\xa5\xe0\x46\xaa\xf5\x21\xd0\xa4\xd3\xe1\xf4\xc3\x75\x65\xa8\xbe\x9f\xdd\xd9\x2a\x81\xc8\xbb\xe8\x2d\x25\x89\xcc\x32\x96\xf8\xf4\xd9\x00\xde\xd0\x6d\x85\xf2\xc4\x9c\x3d\x20\x14\x17\x40\x45\xe9\x04\x37\xf7\xe4\xc3\xe5\xd9\xc5\xbb\xcb\x41\x9e\xfe\x6c\x26\xef\xfa\x46\xf6\x4b\xcd\xfa\xbc\x45\x86\x92\xa7\xf3\x5e\xc4\xa7\x68\x95\x30\xab\x69\x90\xc1\x5c\x5f\xef\x7d\xfc\x24\xf9\xa8\xd1\x6b\x01\x6c\x47\xfe\x4e\x4a\x4a\xd3\x23\x8a\xba\x18\x49\xea\x4c\x4f\x65\x96\x21\xb4\x8d\x62\xac\x17\xdb\x62\x36\x86\x86\x74\x5e\xd8\xbd\x0d\x15\xb5\x05\x3e\xac\x0c\xf1\xf8\x08\xd7\x85\x63\x6c\x97\x49\x96\xa1\x58\xf5\xac\xc3\x71\x54\x7b\x8f\x86\x33\x33\xb3\x50\xbd\x65\x0b\x02\x8e\xc0\x13\xa9\x2c\x3e\xa9\x3a\x6e\x30\x93\xc0\xd2\x4f\x4a\xcd\xd4\xc0\xb1\x9d\x47\x07\x5b\x87\x2c\x42\x3b\x24\x6f\x0b\x1d\x57\xc1\xcc\xbd\xae\x32\xfb\x3a\x79\x8d\x96\x66\xc6\x84\xf1\x89\xd1\x1d\x64\x56\x02\xd1\xf9\x61\x3f\x3a\xd4\x5a\x26\x31\xea\x96\x72\xe8\x25\x4d\x4f\x17\x9c\xb4\xa7\xa6\x2b\x3a\xda\x3e\x10\x88\x18\x93\xf9\x10\xcb\xa5\x68\x2a\xc1\x61\x03\x33\xd0\xd5\x10\x8d\xa6\x39\x17\xcf\xf0\x74\x26\x5c\xa4\xdb\xe0\xd0\x30\x80\x41\x8f\xba\x28\xe6\xde\x39\x83\x7e\xb8\x37\xa4\x5e\x93\xc2\x80\x77\x77\x83\x58\xbf\x3f\x6c\x75\xf8\xf2\x85\xfe\x21\xeb\xe3\x57\xfa\x45\x5a\x41\xe5\xe5\x32\x70\xf9\x06\x6f\xbf\x26\xa5\x47\xb8\xe2\xdb\xd3\x6e\x93\x47\x96\x86\x1e\x56\xcf\x7d\x14\x40\x75\x91\x79\xee\xcb\xbd\x2b\x9a\x09\xd5\x5f\xb4\x0f\x3e\xc3\xcc\x66\x58\x46\xc6\xe9\xcb\x16\x1e\x05\x55\x34\x67\x86\x29\x74\x81\x73\x4e\x75\xc2\x45\x27\xbc\x2f\x98\x18\x19\x9a\xdc\xee\x3b\x15\xea\x0b\xc7\x7d\x38\x8e\x7b\xef\xab\x40\x8f\x08\x2e\x2f\xd2\x22\xbe\x45\xe6\xc2\x71\xa1\x67\x42\x62\x42\x3a\xb2\x2e\x56\x8e\x90\x8e\xaa\xce\x5d\xab\xf4\x64\x68\xd8\x00\x4f\xb7\x90\x5f\x0f\x3c\xf8\x11\x0a\xfb\xe1\x86\xed\xcf\x80\x23\x81\xbb\xdc\xa3\x45\x5d\xeb\xd4\x21\xb7\x6f\xc6\xdc\x54\xe7\x5e\x33\x43\x0a\xa6\x72\xee\xc2\xba\xa5\xc0\xca\x82\x2c\x45\xbe\x66\x79\x98\x1b\x2e\xe2\x79\x82\xc8\xc4\xf8\xd2\x5d\x64\xcc\xcc\x1d\x63\x82\xbc\x7a\xf5\xea\x15\xc8\x25\xaf\x7e\xfd\xeb\x5f\x13\xc8\x23\x91\xb2\x84\xe7\xcb\x0d\xa1\xd5\x7f\xbd\x7e\x3d\x20\x7f\x3a\x7b\xf7\x16\xbc\xca\x0a\xa3\xc9\x58\x9a\x99\x1b\xd9\x36\xa8\x75\xd6\x3d\xf2\x3f\xa3\xf7\x57\x5e\x9c\xd0\x8d\x5f\x41\x05\x09\xcb\xab\xbb\x08\xbe\xfa\xd5\xd7\x5f\x0f\xc8\x05\x57\x10\x4f\xcc\x21\x02\x22\x38\x41\x16\xde\x31\x50\x48\xb3\x1c\xc1\xef\x38\x88\x73\x12\xce\xf9\x74\x66\xb0\x06\x14\x20\x4e\xc6\x13\x83\x39\x05\xf1\xe8\x23\xa0\xb5\x0b\x90\x71\xe1\x5e\x4e\x8a\x80\xc9\xf5\x48\xc6\x6f\x19\x99\xe8\x3f\x28\x59\x16\x55\x98\xa3\x62\xda\xca\xb2\xae\xc2\x14\x0e\x56\xed\x95\x66\xe6\x49\x9d\x30\x5a\x1a\x82\x6a\x38\x08\x7d\x1a\x02\x4a\x2f\xe4\x56\xeb\x23\x3e\x14\x94\x07\xc7\x41\xb8\x53\xaf\x65\xf6\x0f\xba\x67\x1a\xe5\x92\xf3\xb1\x2b\x85\x92\xdf\xe3\x56\x71\xe1\xa3\xa0\x9c\x84\xac\x9d\x4c\xe6\x82\x4e\x45\x64\x73\xf5\x51\xf9\x96\x17\xba\x88\xff\x28\x7e\x6a\x38\x89\x03\xed\x20\x2c\x9d\x6b\xfb\x89\x5a\xe2\xcb\x15\x5f\x8e\x4b\x2f\x9a\x99\xc6\x7d\x2d\xc5\x52\x6f\x57\x47\xc5\x91\x1f\x57\x5d\xc7\x85\xb0\x55\x63\xa0\x2b\xae\x0b\x00\x8a\x6a\x36\xd5\x92\xd1\xd5\xbc\x7c\x34\x33\xa5\x03\x0d\x78\x5e\xd9\x6f\x33\xad\x5d\x1c\x51\x4e\xd5\xad\x55\x12\x1c\x15\x18\x80\xd7\xb3\x0e\x31\x4c\x18\x50\x36\x67\xa1\x00\x5f\x1c\x35\x60\x3f\x72\x38\x18\x1c\xe2\x31\x91\x0a\x73\x79\x22\xce\xdb\xf7\x4f\x14\x2f\x5d\xf7\x4a\xa7\x45\x54\x5e\xcf\x95\x2d\xa1\x35\x6f\x67\xea\x20\xd5\x26\x83\x6f\x27\x91\xa6\x5b\x2e\xe4\xb6\xd9\x90\xb1\x65\xd1\xa6\x24\x43\x57\xa9\xaa\x43\xf2\xe4\xf5\xd9\x1a\x1c\x8c\xdd\x49\x68\x97\x16\xb9\x73\x9a\x5f\x82\xee\x1e\xbb\x4c\xf5\x30\x77\x9c\xef\x7d\x37\xce\xe7\xe2\xf5\x6a\xc5\xc1\x9e\x3f\xab\x1b\x4e\x30\xd2\xa5\x4e\xba\x1c\x69\x88\x45\x81\x50\x88\xab\x0a\x7b\x79\xd6\x1c\x2d\x46\x9b\x6e\x89\xe7\xbb\x70\x37\x7c\xda\x5d\x4c\xe0\x53\xc3\x35\x7f\x3b\x81\x8b\x76\xa4\xb4\xa8\x15\xf8\xc8\xd0\x6e\x00\x32\xa6\x3f\x3c\x03\xf2\xce\x91\x5a\x44\x32\x3a\xd6\x32\x2b\x0d\x76\xad\x7e\x8c\xe9\x30\x0c\xea\xb3\x2c\x00\xf1\x0d\xcd\x22\xaa\x6c\xaa\x12\x67\xed\x08\x34\x3e\x1d\x0e\xe7\x4b\xb6\xcf\x07\xcc\xf6\x19\xf2\xd3\xea\x96\xf5\x9a\xf4\x83\xa5\xd7\x4d\x34\xef\xa2\x5f\x69\x4e\x8e\xaa\x32\x21\xfe\x3a\x7e\x28\x0c\x53\x13\x9a\xb0\xe3\x58\xef\x0a\xe5\x58\x82\x8b\x90\x8f\x8b\x98\x51\x91\x66\x28\x80\x27\x4c\x01\xee\xb3\xcf\xae\x50\xf0\xf9\x68\x48\x52\xc5\xa1\x00\xee\xd1\x37\xcc\xca\x8b\x8c\x9a\x52\xb1\x56\xd1\x55\xfb\xf5\xad\x84\x69\xec\x4b\xd3\x83\xc1\xba\xba\xea\x41\x27\x4f\x79\x44\x74\xbe\x2a\x30\x21\x54\x11\xa4\x3a\xd6\x65\x07\x16\x95\x80\x40\x03\xcd\x58\xc8\x52\x39\x2b\xba\xcf\xab\x9a\x48\x65\xd5\x25\x1c\x98\x6a\xa2\xd8\xd4\x4a\xb3\x0a\xc4\x5e\x6c\x91\x95\xf6\xc5\x5e\xdd\xd9\xee\xe3\x00\x58\x99\x66\x37\xf9\xea\x4d\x9c\x54\x2d\xe7\x3c\xf5\xac\x12\x2e\xaa\xaa\xaa\x86\x05\xd5\x51\xa8\x4d\x94\x81\x3e\x02\x2c\xca\xe8\xc0\x50\x43\x10\x6b\xcd\xd9\x3f\x36\x0a\x4b\xc8\x6d\xd1\xa2\x7c\x44\x17\x22\x2c\x53\x76\x5d\x8e\x33\xae\x67\xa3\x1d\x4d\x88\xab\x86\x40\x67\x85\xa5\x5b\xbf\xb5\x96\x44\xcd\x84\xe6\xc0\xf2\x2c\x19\xb7\x4c\x17\xca\x25\x4b\x00\xa2\xef\x1d\x23\xa4\x84\xe8\x8f\x8c\xb9\x0c\x06\xf6\xa7\xab\x6a\x1e\x2e\x28\x0d\x73\x96\xa4\xec\xa3\x28\x6a\xef\x13\x9a\x65\xba\x19\xb0\xeb\x29\x26\xca\x1e\x3e\x50\x0d\xf7\x94\xdb\xed\x0e\x95\x51\x1a\xd9\x2f\xd7\x2e\x4c\x93\x5c\x62\x18\x8f\x20\x52\xf8\x46\x90\x7a\xc5\x77\x88\x02\x19\x21\x5c\x19\x50\x66\xcf\xa5\x23\x5f\xcc\xa5\x0f\x67\x2e\xbd\xaf\x1f\x9e\x0e\x55\xa4\x68\x14\x0d\x5d\x2f\x73\xed\x49\xa9\x27\xb9\x5b\x9c\x3a\xf6\x7a\xad\x80\xdf\x3c\x33\x58\x9a\xbd\x7b\xbe\xb7\x46\x77\x60\xd3\x56\x11\x81\x53\xdc\x77\xab\x4f\x22\x14\x75\x1a\x42\x38\x0b\xcb\x67\xbf\xe2\x39\xc0\x6e\xf0\xe5\xa1\x26\xa9\x4c\xca\x90\x17\x16\x80\x56\x5d\xa0\xb5\xc9\x9e\x48\xba\x9e\xab\xee\x29\xbd\xe2\x8f\x6c\x45\xaf\x54\xde\x89\x3b\xaa\xd2\xb3\xeb\x2d\xde\xf7\x75\x76\x5e\xf5\x8a\x05\x25\xff\x1a\xaa\x00\xd2\xb1\x2c\x4d\x95\x3a\xf4\xc7\x63\xaf\x5e\xa5\xa6\x1b\x69\x49\x43\x4b\x7b\x74\x57\x45\xff\xc5\xc4\xfd\x62\xe2\xae\x3d\xbb\x98\xb8\x87\x68\xe2\x8e\xf3\xe0\xd6\x8e\xab\x4f\xaf\xc0\xb3\xb6\xbe\xbd\x0f\x69\x25\xbd\xa8\x08\x0c\x4a\x53\x4d\x3f\xfe\x86\x00\x87\x47\xa4\xda\xdb\x48\xe8\xf3\x14\x08\x78\xf6\xd3\x5b\x54\x1f\xc8\x4e\xda\xbe\x4e\x31\x3e\xeb\x0a\x09\x6e\xaa\x5b\x0c\x52\x43\x54\x68\xb8\xe7\xb2\x40\xf7\x9c\xde\x25\xd2\xaa\x84\x1f\x26\xa1\xee\x50\xa6\x14\x9f\x8e\xc0\x27\x9d\x37\x80\x74\x2c\x22\x8c\x4f\xd7\xdd\x20\x3b\x14\x14\xc6\xe7\x89\xcb\x0a\xe3\xd3\xd9\xf6\x4d\xba\x97\x18\x5e\xb1\xdc\x87\x2d\x34\xbc\xe3\xd2\x76\x37\xeb\xef\x6a\xce\xef\x55\xe5\xed\x9e\x3f\x5b\x7f\x31\xe7\x2f\x3d\x8f\x68\xce\x8f\x08\xb7\x27\x06\x2b\x4c\xfb\xb1\xb9\xcd\xdb\xf7\xc7\xcc\x8b\x95\x83\x2a\xfb\x9a\x45\x39\x6f\xd9\x97\xaa\x7e\xad\x7a\x38\x18\x1c\x1e\x7a\x7b\xbf\xc3\xcf\xd2\x4c\xfa\xbf\x21\x4c\x24\x32\xc5\x4d\xb5\xe3\x2b\x6d\x80\xe9\x57\x6a\x7a\x3c\x97\xdc\x7f\x2b\xbe\x9a\x85\xb1\xbb\x6d\x49\x87\x13\xdc\xbd\x6c\xf8\x2a\x48\x3f\x46\xf1\xf0\xb8\x44\x78\xbd\x22\x38\xb6\xb8\x4f\x19\xf0\x18\x78\x0f\xce\x5f\x5b\x17\x06\xc7\x67\x17\xf6\xba\x43\x91\x70\x7c\x1e\xb9\x54\x38\x3e\x3b\x71\xd4\x4e\x65\xc3\x57\x2c\xee\xf1\x8a\x87\xe3\xf3\x4c\x0b\xc9\xd4\x9f\x4e\x85\xc4\xf1\xd9\xad\x9c\x78\xbd\x6f\xc7\xad\xdf\x4b\x69\x71\x7c\xba\x15\x18\xc7\x67\xdf\x65\xc6\xf1\x69\x09\x09\x30\x86\x5f\xf0\x4e\xa1\x08\xbe\x4f\xdd\x5d\xd2\xb0\xbc\x90\x8a\xaa\x05\x49\x9d\xad\x61\xb1\x22\x22\x34\x0a\x09\xbd\x77\x6a\x18\x98\x47\xca\xd5\x9e\xa2\x11\x3a\x44\x83\xb2\x94\x97\x6b\xcb\x35\xaf\x03\x1b\xf6\x8a\x81\x76\x07\xd9\xc0\x5c\x26\x31\x7f\xdd\xe9\x9a\xf9\xc4\x8a\x34\xb9\x75\x15\x83\x3c\x54\x91\xf7\x47\x41\x2e\x07\x07\x8d\x3c\xd0\x60\x1e\x83\xbb\x3f\x57\x19\xd1\x37\xc6\xb1\x6b\xa6\x2c\xbc\x0d\x71\x6e\x01\x47\xae\xe1\xb1\x95\x48\xde\x01\x1b\x7c\xa4\x5d\x22\x1d\x23\xdb\xf8\x3f\x18\x94\x1b\xeb\xec\x1b\xef\x3b\x86\x74\xd0\x12\x24\xf3\x50\x17\x2d\x93\x49\x74\xf7\x5c\xe3\x50\xb0\x0d\x97\x1e\xf9\xbd\xed\xde\x6e\x86\x1d\x15\xe5\x0b\x30\xfa\x64\x1a\xef\xf5\x78\x02\xa9\x2d\x41\x8a\x07\x60\x86\x0d\xb8\x89\xaa\x04\x96\xda\x7e\x09\x32\xcf\x47\x6d\xaa\x0f\xdd\xf9\x0c\x9b\x26\x2a\xe4\x56\xd7\x3d\xec\x2f\xa3\xb0\xb2\x4a\x6f\x83\x10\x08\x2f\xa8\xeb\x12\xc4\x44\xf7\x15\x27\x2e\xc9\x09\xdc\x5d\x55\x65\xd1\x42\x72\xc7\x25\x34\x13\x3c\xab\xe3\x99\xcf\x65\x17\x16\x5e\x0a\xe7\x68\xb0\x84\x34\xab\x71\xa6\xd4\x4c\xf5\xa7\x25\x4f\x77\xc1\x96\x67\xcc\x00\x5b\xb3\xbd\xee\xcc\xae\x23\x8b\xbb\x07\x63\x0b\x8e\x18\x1d\x58\xc3\x41\xe5\xbd\x51\xe3\x0d\x71\x5a\xbc\xba\x27\x07\xf5\xce\x02\xe1\xc8\xf9\x2b\xa1\x9b\xa0\xda\x3a\x9e\x91\x2c\x12\x17\xac\xcb\x6b\xe9\x2e\x71\x58\xc4\x3c\x70\x6c\xed\xdb\xff\x78\x15\xd8\xdb\xf3\xc7\x6c\x22\xab\x0a\x29\xa8\x11\x39\x77\xdc\x94\x65\x0c\xca\xc8\xfb\x12\xf5\xb6\x01\x5c\x09\xe7\x72\x6e\x91\xf9\x2f\x82\x7c\xf4\x39\xfb\xf9\xe4\x94\xd0\xe3\x5a\x08\x84\xab\x3a\x23\x18\x4b\xd1\x47\x37\xab\xbe\xa3\x4a\xa1\x7b\x64\x7c\xec\xfd\x51\xe0\xc4\x09\x2b\x16\x66\x5e\xe2\x45\xbd\x5a\x31\x0b\x00\x08\x3b\x56\x32\x27\x5a\xd0\x42\xcf\xa4\x01\xd5\x90\x16\x34\xe1\x66\x41\x8c\xa2\xc9\x2d\x94\x28\x52\xcc\x7d\xae\x47\x92\x63\xe7\xd8\x15\x83\xaf\xee\x36\x6c\x66\x4a\x96\xd3\x19\x78\xc2\x62\xab\x24\xa3\xda\xaf\x7e\x65\x7f\xa7\xed\x68\x92\x2e\x04\xcd\x79\x12\xb2\x06\x2a\x39\xe7\x9a\x4b\x67\xed\xf5\xe3\x5e\x87\xcc\x70\x68\x41\x3e\xcf\x28\xcf\xc9\x91\x66\x8c\x5c\x7a\x94\xc0\x5f\x5c\x19\x7b\xb4\x6c\xa8\xba\x73\x80\x0c\x29\xcd\x85\x4b\x88\x50\x11\xb8\x70\x79\x85\x0c\xd3\xce\x7c\xe5\x47\x8f\xc3\x76\xad\x9e\x93\x54\x70\x71\xef\x53\x77\x32\x91\xca\xe8\xd6\xf2\xec\x7a\xa8\x63\x6d\x04\x71\xcb\xe5\xbd\x83\x1f\x32\x29\xa6\x71\x1a\x81\x0a\x33\x2d\x29\x15\x50\xde\x65\xce\xd3\x92\x66\x48\x44\xdd\x64\xce\x47\x43\xec\xce\xa7\x33\xd3\xbf\x63\x60\x8d\x41\x5e\x53\x9d\x19\xff\x51\xbe\xe4\xad\xc3\x35\x10\x5d\xe3\xac\x09\x68\xd9\xb2\x53\xbb\xa3\x0b\x48\x5b\xe3\x5c\x4c\x6a\x17\xa6\x3e\xb1\x18\x0e\xb1\x0a\xe2\x30\xbd\xb3\x50\xae\xc3\x8a\x0d\x60\xae\xb2\x20\x06\x4c\x5d\x9e\x9b\x05\x7c\x94\x07\x30\xbc\x76\x95\xd9\xa8\xdd\x20\x2b\xdc\x6d\xd6\x65\x1e\x40\x28\x9b\x57\x9b\x7c\xe3\x4a\x27\x76\x14\x0e\x0e\xbe\x8b\xcc\x66\xd1\x45\x87\x3d\x36\x54\xa4\x7d\x9a\x59\xcc\xb9\xfe\x74\xee\x3c\x9c\xf1\x20\xd4\x2e\xf2\x7d\x15\x24\x2e\x42\xda\x6c\x2b\x33\xac\x3c\x02\x10\x07\x3f\x66\x29\x10\x8d\xb8\x60\xe4\x9d\xd5\x90\xdd\xe6\x5d\x7f\x3a\xef\x11\x3e\x60\x03\xff\x57\x68\xea\xa9\x96\x91\x53\x74\x03\x0c\x3e\x9e\x80\x77\x30\x95\xd8\x18\x15\xf7\xfd\xfb\x6f\xed\x24\xed\xaf\xbf\xeb\xff\x36\xca\x36\xfa\xbb\xbf\x5b\x22\xa8\x6c\x83\xfa\xdb\xd8\x97\x2c\x64\xdd\xff\xfb\xb5\xcb\x4a\xed\x72\x56\xff\xdd\x15\xe3\x62\xc2\x58\xb9\xf1\x5a\xc2\x2d\x3d\x4f\x11\x1b\xe1\xdb\x8a\x7d\xef\x0d\x8b\x00\xa6\x60\xd4\x49\xa8\x61\x02\x08\xb5\x0f\xca\x10\xd2\x60\x77\x57\x77\xd6\xce\xff\x08\x4c\x02\x18\x54\xd6\x23\x46\x4a\x38\x8e\x78\xe4\xcf\x04\x61\xbe\x56\x27\xae\x15\xc0\x41\x9d\xa3\x9a\xe7\x3d\x76\x58\x0b\xe1\x10\x82\x6b\xe7\x01\x73\xfb\x85\x90\xe6\x17\x61\xfb\x1b\x55\xc4\xe9\x5c\x72\x9f\x80\xdc\x9e\x14\x81\x15\x1d\x43\x4a\xec\xf1\x82\xe4\x5c\x1b\x7a\xcb\x06\x64\x64\x79\x4b\x7c\x1b\x86\xd0\x13\x04\x32\x58\xb2\x94\x94\xc2\xf0\x0c\x7e\xad\xc6\xb1\x53\x8e\x79\xce\x70\x42\x74\x09\xe5\xcd\x0b\xc5\xfa\x9e\x8b\xb9\x56\x4b\xb4\xa0\x5a\x4b\x2f\x6c\xf6\x8c\xa2\x2e\x50\xa4\xd0\x15\xe0\x41\x85\x43\xaf\x25\x3f\x2e\x3b\x4f\x29\x92\x8a\x73\x01\x30\xf5\x80\x5c\x01\xb3\xca\xfc\x95\x30\xaa\x25\xce\x80\x29\x58\xc2\xb4\xa6\x6a\xd1\x83\xc4\xee\x3c\x24\x03\x77\xae\x3b\xc0\x51\x73\x2a\x30\xad\xba\x62\x89\x14\xda\xa8\x32\x31\x58\x67\x6f\xac\xe4\x2d\x13\xc1\x5d\xd0\xee\x62\xdd\x81\xab\xf2\x9f\x81\xfb\x2e\x49\x92\x19\x15\xd3\xa8\x4e\x4d\x4e\x53\x80\xfd\xb7\x41\xca\xf1\xeb\xb1\x10\xa0\x13\x2b\x58\x70\x03\xa0\x18\x5b\x3e\x12\xcc\xb0\x7f\x11\x21\x1f\x4f\xaf\xb2\x93\xda\x25\xf1\x6c\x0b\xed\xea\x44\xbf\x48\x47\xa3\x5e\x1f\xd8\xf6\x9e\x1d\xc0\x72\x66\x68\x4a\x0d\xdd\xc1\x09\xec\x5d\x55\x5c\xcf\xd7\xd7\xc7\x02\xa7\xe1\x62\xd2\xf1\x21\x2f\x6e\xc9\x82\xc7\xf1\x4f\x70\x12\x67\x1e\xf2\x10\x71\x6d\x2c\x4e\xb9\x8b\x02\xf4\xed\x02\x79\xc6\x57\x2f\xb3\xc3\xfb\xd1\x90\x5c\x54\xa5\x19\x2b\x72\xd2\xee\x1a\xaa\xa3\x05\xd6\x82\x7e\x07\x18\xdd\x54\x77\x65\x49\xdd\xbf\x6b\xa5\x08\x82\x5c\x82\x09\xc3\x15\x8b\xc3\xcd\x1c\xe8\x4a\x81\x48\xde\x00\x22\x40\x79\xca\x8c\xae\x3c\x54\x90\x0e\x5b\xe2\xe2\xf8\x9d\x53\x46\x81\x48\x3b\xc0\x3a\x7d\x6e\xb5\x2c\x84\x60\xd7\xd2\xd1\x59\x4b\xf9\x1f\x04\xae\xbb\x18\x9d\xb1\x9c\xc0\x3b\x99\x76\xb1\x53\x37\xb2\xf0\x57\x43\x54\xfe\x9b\xe8\x89\xab\x41\xa9\xc7\x06\x70\x5b\xa5\x6b\x41\x73\x48\xe4\x66\x74\xbe\xbb\x91\xaa\x92\x91\xfa\x21\x95\x31\x7c\xae\x0f\x9f\xeb\xbf\x6e\x6f\xcc\xeb\xe2\x01\xe2\x9f\xd6\x9e\x20\xf5\x8f\x74\xb2\x9c\x5a\x92\x32\xea\x68\xee\x6c\x44\x23\x87\x11\x1c\xcd\x77\xb7\x88\xe1\xe6\xd6\x45\x3a\x30\x6e\xa9\xc5\x29\xf9\x45\x8d\xcb\x3b\x69\x2a\x68\x4a\xe8\xa9\x7b\xe4\x55\xa7\x81\xdb\x0a\x1f\x7c\x5e\x6f\x7e\xdc\x18\x0c\xc4\x8b\xd5\x1a\x85\xf7\x08\x0e\x22\x9f\x15\xcf\x14\x18\xcf\x7c\xfc\x81\x45\x2f\x25\xb3\x8c\x29\x58\x82\xd3\x9e\x1a\xb7\xe8\x90\xcb\x14\x6d\xba\xbd\xa0\xa2\x06\x19\x53\xb0\xbb\x20\x4c\x50\x8d\xa9\x5b\xfc\x8d\x17\x73\x85\xf3\xd6\x8e\x17\xbc\x96\xcf\xc4\x02\xa7\x7e\x11\x81\x16\x55\x4f\x32\xb5\x1f\xb2\x52\xa7\xa0\xe3\x0c\x6f\x8f\x03\xb3\x85\xb9\xd0\xec\x8e\x2e\x34\xe0\x7d\x25\xcd\x87\xef\xbb\xac\x6a\xd5\xc0\x1f\xd8\x04\x7b\xb7\xbe\x11\xdb\xe9\x4e\x6c\x97\x5b\x31\x08\xa7\xe4\xa2\x8d\x0b\x52\xd5\x61\x63\xe1\x90\xe6\xb3\xcb\x35\x1a\xf8\xa9\xc0\xf5\x79\xb7\x3b\x91\x7a\x9d\xf2\xeb\x21\x0c\xe1\x65\xf2\x29\xfc\xe1\x39\x4e\xb8\x34\x18\x33\x8b\xd5\x55\xa0\x34\x60\x48\xdc\x77\x85\x27\x41\x85\x5a\xdf\x42\x36\x56\x67\x25\x0e\x95\xc6\x14\x03\x4f\x10\xf8\xe2\x00\xca\x11\x50\xb1\x70\x9c\xdc\xcc\xb8\x4a\xfb\x05\x55\x66\x81\xea\x63\xaf\xf6\xb5\xe0\x5e\xdf\x69\xe1\x3b\x5e\xe7\xb4\x4b\x7d\xbc\x16\xc2\xb0\x78\x6f\x1e\x76\xd6\xf9\xb5\x70\x7d\x8c\xf5\xb4\x77\xe0\x5f\xb9\x9e\x38\xb5\xa8\xd7\x08\x9f\x6c\x3d\x69\x4c\x3e\xee\xcf\x37\x2c\x0d\xd2\xf5\xab\x57\x64\x03\x71\xe9\x2a\x19\x7b\x41\x07\x2e\x0f\x0a\x91\x1d\xa9\x67\xf5\x50\x5a\xd5\x1a\x8f\x0c\x7b\x4e\x52\xf0\x3e\x34\xae\xd2\x91\x58\x38\xd3\x4d\xfc\xad\x78\x80\x70\x4a\xc8\x91\x90\x02\x4f\x0e\xb6\x3d\x46\x17\xa2\x35\xb6\x29\x68\xe2\x4a\xd4\xd5\x2b\x84\x46\x27\xd5\x33\x09\x2e\x52\xbb\x75\x40\xb9\x41\x47\xd2\x65\x92\x30\x16\xb4\xea\xb8\x44\x4d\x75\xb2\xdd\x94\x7d\xa9\x4b\x2d\x21\x89\x8b\x36\x34\xcb\x2a\x6d\xd6\x81\x4b\x02\x9f\xf3\x16\xc0\x88\xfd\xd5\x02\x6d\x9c\x62\x0f\x45\xd4\xd1\xed\xa5\x14\x09\x5e\xe1\x73\xb3\xf0\x33\xb8\x68\xb2\x7a\x50\x23\x34\x2a\xb9\x7c\x82\x76\xa7\x48\x1d\x08\xc0\x04\xd2\xe4\x4a\xb8\xd7\x39\x93\xcb\xcd\x60\xe9\xd0\x98\x26\xb7\x77\x54\xa5\x50\xca\xb7\xa0\x86\x63\x5a\xf0\x5e\x6d\xd8\xa3\x68\x0e\x50\x48\x3f\xc6\xa2\xe3\xa0\x74\x68\x16\x52\x50\x57\x9f\x21\xb4\x34\x32\xa7\x86\x27\xa0\xca\xf2\x49\x64\x45\xcc\x43\x4a\xc3\x46\xd9\x41\xa0\xb2\xa1\x80\xfd\x0d\xde\xc6\x28\x46\xcc\x9d\x24\x3c\xb7\x12\x02\x85\x52\x1a\x93\x10\x31\xe4\xed\x9d\x9b\x66\x6a\xc5\xa0\xef\xc0\xc8\x1c\xb5\x42\x25\xd9\xaa\x50\x1a\x86\x0f\x16\xcd\x60\xca\x73\x21\x37\xbd\x06\x03\x77\x7d\x2c\x4e\xdb\xb9\x46\xa8\xda\xb3\xdb\x73\xc7\xac\x5c\xa0\x37\x22\xac\x1e\xac\x9a\x11\xd6\xb4\xd5\x24\xe5\xba\x51\x98\xfa\x28\x55\xb2\x28\x9c\x81\x24\x3f\x6e\xce\x08\xee\x0d\xd4\x9c\xe9\xa8\xf6\x32\x9a\xaa\xa7\x4c\x84\xe2\xe1\x2e\x9d\x05\x9c\xdc\xe6\x27\x6a\x07\x66\x80\x01\xa1\xc7\xe4\xa3\x2b\x2a\x14\x10\x37\x78\xdd\xb5\x12\x9c\xd0\xda\xe2\x64\xa7\x17\x89\xa7\xed\xf3\x22\xf1\xbc\x48\x3c\x3f\x6d\x89\x27\xb8\x7b\xed\x2a\xed\x54\x3e\x8e\x8d\x82\xe4\xde\x19\xa0\x6a\xb0\xce\x88\x31\x9c\x90\x0f\x2c\x91\x73\xa6\x90\xc8\x41\xe1\x4f\xcb\xcb\xdf\x50\x9e\x59\x12\xe7\x49\x5d\xa5\x1e\x42\x46\xd5\xba\x69\x2e\xd2\xc8\x03\x34\x1d\x9a\xe7\x6e\x52\x2e\xd2\xcf\xb6\x77\x97\x64\x85\x62\x73\x2e\x4b\xed\x5d\x16\x4a\x83\xc7\x4c\x1b\xc7\x6f\x67\x7c\x1a\x12\x73\x87\xab\x4e\xc5\x12\xa9\xd2\x2a\xa4\x5c\x1b\x6a\x4a\x5d\x8f\x93\x48\xd0\x9a\xb6\x3f\x03\x4d\x80\xe3\x03\x53\xf7\xdd\x28\x29\x7a\x6c\xdc\xe3\x54\x1c\xbe\x45\x9f\x8f\xaa\xee\xb6\x89\xdc\x50\x2a\x17\x18\x2b\x42\x95\x86\x45\x68\xe5\x10\xa0\x33\xac\x6b\x51\xaf\x27\x58\xb8\xa5\x1f\x86\xed\x57\x5e\x27\x2d\x32\xae\xc7\xcf\x4e\x50\x27\xf7\x08\xf0\x8c\x9f\x67\xec\x78\xd2\x58\x6c\x77\xef\x4b\x72\x4f\x0f\x4c\x72\x1f\x2f\x4c\xb2\x4f\x4f\x4c\x12\xfc\xb9\xef\x73\x62\x3e\x78\x4f\xf2\xc6\x99\x71\x84\x77\xd3\x99\xa9\x25\x14\x08\xe3\x70\xed\x2b\x40\xba\x6b\xcd\x70\x06\xc0\x24\x18\xfb\x03\xbb\xd3\x0a\xda\x1c\xde\x5d\xb2\xcf\x21\xeb\x6f\x24\xc7\x54\x45\xb5\x8d\x04\x0f\x84\xbc\xc0\x4c\x40\x70\xea\xfa\xce\x25\xcb\x6b\x4b\x2f\x27\xf8\xe5\x04\xb7\xed\xff\x94\x27\x18\x3d\x9e\xbb\x38\xe4\x37\x2a\x05\x61\x77\x17\x84\x4b\xc7\x2c\x23\x3f\x94\x4c\x2d\x88\x15\x82\x2a\xf7\x1e\x48\x6f\xac\x79\xea\x1c\x64\x9c\x51\xa5\xbd\xcc\xfe\x88\xfc\x1f\x4c\x36\x97\x9f\xad\x04\x08\x71\x6c\xf7\xa0\x6b\xcd\xa1\xea\xa1\xca\x08\xad\x00\xc1\x58\xc2\xc3\x1b\xc6\x9a\xcc\x67\xc5\xbd\xb3\xab\x8b\xdd\x14\x9d\x6e\x97\x5a\x64\x97\x8b\xad\xa5\xc5\x9f\x6d\x58\x20\x02\x22\xfc\x52\xaf\x26\x15\x4c\x11\xe4\x96\x2d\x7a\xee\x1e\xdc\x65\x6f\xf7\x8d\xd1\x9d\xa3\x9e\x52\xb4\x6d\xaa\x8a\x55\x00\xda\x81\x42\xee\x66\x3d\xc0\xa7\x7d\x12\xca\x7a\x2f\x0f\x84\xae\x84\x78\x67\x12\xde\x29\x59\x65\xfc\xac\x4b\x5c\x89\x38\x01\x19\xf8\xbc\x5f\x73\x40\x03\xf0\xe5\x06\x6a\xd1\x75\x13\xc9\xee\x2a\x30\x3e\x1e\xb0\xf7\x5e\x6a\x40\xd3\x9a\x63\xee\x2d\x5b\x1c\x6a\x17\x35\x28\x85\x9e\xf1\xc2\xe7\x87\x07\x4a\xe0\x30\x97\x7c\x02\xff\x00\x3f\x04\x9e\xf9\xa1\xe8\x91\x2b\x69\xec\xff\x2e\xc1\x55\x08\x2d\x95\x92\xe9\x2b\x69\xe0\xcd\xa3\x03\x0b\xa7\x7b\x6f\x50\x39\x33\x25\x07\x33\x23\xba\xb4\x41\x7c\x86\x77\x41\x01\x90\xb8\xfb\xd6\x00\x56\xae\xc9\x50\x10\xa9\x3c\x4c\x8c\x4f\x1e\xac\xdd\x10\xde\xb6\x14\x59\x84\x57\x8c\xe1\x40\x29\x55\x0d\x92\x1b\x86\x0b\xc6\x65\xee\x7f\x01\xdb\x13\x58\xe3\x83\xdf\x0c\xa4\xc0\xa5\x86\x4d\x79\x42\x72\xa6\xa6\x10\x1f\x9a\xcc\x76\xdf\xa0\xee\x74\x1b\x9f\x9d\xa8\x77\xfc\xe1\xce\x98\x01\xac\xee\x2d\x78\x2e\xdd\x97\x61\xe2\x28\xc8\x22\x72\x5a\x58\xa4\xf8\xa7\xe5\x04\xb0\x2f\xff\x86\x94\xd5\x7a\x40\xce\x7c\xc1\xd3\xf8\x37\x67\xc5\x88\x87\xb1\x23\x58\x99\xfe\x87\x92\xcf\x69\xc6\xd0\x9f\x8f\x8a\x90\xc6\x53\x4e\x96\xd8\x74\xcf\xe5\xad\xb6\x54\x2a\xdc\x0c\x1d\xdc\xb2\xc5\x41\x6f\x09\x91\x0e\x86\xe2\xa0\x0a\xd2\xae\xa1\x4e\x60\x68\x70\x69\x70\x00\xbf\x1d\xec\x9b\xb3\x3f\x91\x68\xbf\x03\x96\x38\x83\xd0\x79\x46\xb5\xee\x16\xdf\xda\x08\x2d\x6a\x8c\xb3\x2a\x01\xe3\x28\x6a\x53\x05\x17\x39\xef\xcd\xbd\xdb\xb3\xc0\xcb\xbf\xbb\xa7\x51\x27\xe8\xcd\x5d\xf5\x94\xf6\x89\x1b\x56\x26\x14\x83\xb4\x05\x3e\x86\xa3\x16\x17\x57\x5d\xc6\xae\x81\xd7\x27\xb0\x2b\xca\x49\x5c\xe4\x99\x6b\x50\x83\xb9\x8f\xea\x10\xd2\x10\x2e\x92\xac\x74\x26\x45\xe8\x0a\x4a\x74\x57\x51\x7f\x07\xe0\xdc\x03\xa9\xaa\x01\x3c\x36\xf9\x6b\xdf\x25\x07\xde\xe6\x0d\x1d\xdc\x89\x86\x1b\x2f\x84\xd5\xbe\xd7\x3a\xd9\xe2\x2e\x59\x4f\xc6\x99\xd4\x65\x8f\x37\x7c\xac\x18\x39\x9f\x51\x21\x58\x16\x45\xbb\x3a\x63\x47\x28\x67\x05\x02\x89\x2b\x62\x75\x58\xaf\x62\xe5\xe9\x9b\x08\xb1\xd5\x7b\xaf\x1d\xfc\x63\x2a\x2a\xb5\xb7\x3a\xe5\x2e\x55\xe3\x4c\xde\x91\x54\x92\x3b\xa8\x5b\x30\xb7\x4c\x0b\x2e\x65\xb5\x67\x77\xd1\x4c\xc1\x45\x22\x91\x79\xa1\x64\xce\xb5\x77\x8e\x77\xdb\xb8\xd7\xd0\xd0\xac\x6c\x91\x03\xa8\xbe\x07\x59\x29\xea\x29\xe1\xdf\x9c\x13\x43\xd5\x94\x19\x3b\x1a\x11\x65\x3e\x66\xad\xe3\x57\x1f\x22\x07\xd9\x97\x54\x42\x74\xbf\x45\xb0\x70\x1b\xbe\xfb\xee\xaa\x73\xe9\xdd\xaa\xe7\xba\xbd\xbd\x93\x2a\x4b\xef\x78\x8a\x2c\x5a\x93\x23\xdb\xf8\xf8\xf9\x57\xca\xbd\xbb\xe3\x69\x67\x70\x40\xa7\x3a\x18\xbc\x1f\x94\x05\x03\x01\x38\xb8\x0a\x4f\x1c\xd2\x68\x43\x8f\x63\x72\xc9\x31\xba\x08\xfa\x43\xa2\x9a\x7c\xcc\x45\x15\x61\x56\x81\xd9\x12\x63\x7b\x5e\xbc\x6a\xa2\x99\xc1\xb8\x10\x08\xad\x90\x66\x46\x34\xcf\xcb\xcc\x50\xc1\x64\xa9\xb3\x45\x6b\x54\x79\x1a\x50\x4f\x32\xf6\x19\x31\xbb\x0b\x93\x0b\x9d\xea\xcc\x0e\x5c\x57\xaa\x30\xca\x25\x6e\x57\x39\x57\xa5\x27\x81\xf3\x85\x70\x23\xf6\x99\x25\xce\x2b\xb8\xc8\xca\x29\xdf\x12\xfe\xf0\x13\xcb\x6a\x5e\x25\x90\x2e\x35\xab\x22\xf5\xdb\xd6\x75\x79\xa4\x24\xe4\x4f\xcb\xe1\x6f\x56\x27\x20\x4f\x59\xc1\x44\x0a\x29\xd1\xde\x54\x98\x8b\x93\xdf\x2b\xe4\x5c\x7a\xb1\xae\x54\xcb\x67\x25\xab\x51\xf0\xc8\x85\x6b\x26\xb3\x54\x13\xf6\xd9\x28\x6a\x09\x53\x6e\x49\x50\xe8\x33\x21\x54\xb4\x27\x32\xcf\x23\x45\x30\xd9\x3b\xb7\x7f\xd8\x7a\x99\xcf\xb1\xe4\x65\xb5\x76\xbd\xb1\x60\xf5\xfd\x52\xd7\x23\x21\x76\x67\x45\xd7\x3d\x84\x57\xa4\x98\x77\x5f\xa9\x7b\x26\xde\x2f\xd5\xbc\x5e\x91\x54\xbb\x31\xab\x97\x32\x9d\x5f\x44\xde\xf9\x09\x04\x06\x77\x49\xc2\xe4\x7a\x34\x34\x6a\xf7\xb2\x59\x10\x7a\x83\x06\xed\xf0\x36\xe2\x03\x90\xf1\xd4\x0d\xe4\xc2\x9a\x88\xb6\xb0\xac\x5c\xe7\x4a\x21\xb6\x51\xb1\x87\xc8\x22\x4e\x0d\xd5\xcc\xb4\xb3\xa6\xd4\x45\x87\xaa\xa7\x3d\x80\x31\x7e\xb9\x9f\x30\x8b\x3d\x38\xa4\xfb\x60\x59\xd2\xff\x9d\x93\x32\x44\xad\xa5\x95\x2f\x3c\x7c\x7c\x92\x26\x16\x6e\x91\x71\x8c\xd4\xee\x4a\x42\x4d\xeb\x92\x3b\xad\xf8\x82\x9b\xc1\xc7\x8f\x9d\x6b\xb9\x46\x3d\xbd\x1c\x02\xff\xae\x03\xc1\xe1\x02\x24\xf2\xe1\x3f\x94\xb1\x3a\x00\xc9\x2d\xc2\xb2\x5d\xfb\x7d\xad\x6d\x9a\xb0\xca\x78\x75\xc1\xf5\x6d\x97\x64\x64\x4b\x9d\xeb\x47\xe2\x0f\xe7\x97\xc4\xbd\x6d\x65\x5f\xea\x62\x60\xba\x6f\x66\xac\x69\xc2\x2a\xa3\x6d\xca\xf5\xed\xa3\x97\x55\x2f\xd2\xab\x6d\x1e\xe0\x8f\x67\xff\x6a\x4a\xbd\x3e\x45\x4b\x94\x3b\x68\x21\x4b\x72\xe7\x52\x1f\x38\xa9\xf9\x86\x17\xa7\xe4\x52\xe8\x52\xb1\xea\xe6\xb6\x39\x94\xe5\xba\xcf\xa9\xf4\xfa\xbd\xb0\xe4\x39\x1b\xdf\x0a\xaa\x0c\x88\xc7\x5d\xd1\x20\x74\xf4\xf4\x29\x7a\x21\xda\xe0\xc1\x70\xe2\x1d\xeb\x7a\x2e\xc6\x3b\x24\x2e\xf3\x8d\xec\xce\x47\x69\x4d\xe2\xbd\x7e\x13\x52\xfe\x90\x93\x94\xcd\x4f\x74\x4a\x5f\xf7\xe0\x33\xde\xe1\xb9\x3e\x27\xaa\xc9\xc1\xeb\x83\x01\x19\xf1\x9c\x67\x54\x65\x8b\x5a\x2a\xe6\xaa\x9d\x65\x16\x7e\x40\xb8\x95\x7b\x75\x40\x8e\xa4\x82\x91\x13\x2a\x48\xc6\x7c\x44\x93\x3b\x67\x0b\x94\x1d\x8f\x1f\x9b\xb8\x90\x07\xb5\x5f\x22\x9d\xe9\x8c\x13\xa9\xe7\xd8\x8e\x1f\xd5\xd2\xd9\x5c\x54\x24\x9d\x0b\x4b\xe7\x07\xe4\xe3\xaa\x42\xe5\x70\x64\x7c\x8b\xa7\x02\xea\xe3\xe8\x7d\x3b\x69\x70\xcb\xe6\xe0\xa7\x03\xd3\x76\x2d\x71\xca\xcd\x07\x56\xc8\x4e\x12\x02\x76\x69\xd8\xe3\xb8\xb1\x2f\xa4\xe6\x90\xa8\x94\x1a\x28\x0b\xac\x0c\x4f\xca\x8c\x5a\xb1\x1a\xad\x71\x03\x72\x71\x79\xfd\xe1\xf2\xfc\xec\xe6\xf2\xe2\x94\xfc\xc1\x8d\xc4\x63\x09\x6f\x40\x6e\xe2\x6c\x50\x91\x47\xaf\x4b\xb9\x13\xbe\xd5\x73\x64\x88\x8a\x2a\xb9\x23\xe4\xf8\xa0\x82\x0c\x05\x37\x55\x7a\x64\xf4\x3b\xcb\xa4\x60\xbe\x7a\x68\x21\x9d\x35\x70\xca\xd1\x1b\x44\xb8\xc1\xec\xcf\xf5\xd1\xe0\x74\x60\xaa\xd5\x30\x95\x2d\x8a\xe0\x03\x88\x16\x15\x70\xf7\x25\xfe\xfb\xfc\xa7\x5d\x65\xdf\x90\x8d\xd6\x07\x38\xa1\xf5\xbf\x7a\x8f\xcc\x20\x24\x66\xf7\xe9\x6e\x56\x94\xb4\x26\x96\xcd\x1c\x0e\x0e\xbd\x40\x91\x2d\x25\xe1\x0f\x83\xc6\x19\xbd\xea\xc8\x36\x20\xe4\xbd\x77\xd9\x86\xd0\xe3\xd5\xf9\xfc\x31\x3b\x44\x94\x15\xbe\x81\xb2\x3e\x30\xa6\x1c\xc7\x1f\x75\x29\xc0\xa6\x7c\xce\x04\x2e\x6c\xbf\x14\xca\x7f\xbe\x73\x75\xb4\x6a\xde\x4e\xff\xf8\xf0\x76\xbf\x33\xc3\xf3\xd7\x79\x5e\xee\xd8\xba\x59\x25\x32\xcf\x31\x5f\xd4\x2c\x04\x18\x56\x31\x82\x81\x2a\xec\x4d\xf3\xc1\xcc\x57\x93\x2d\xc8\xdf\xa0\x67\xbe\x53\x43\xd3\x09\xaf\x5d\x50\x82\xa8\xc4\xdc\xee\x79\x98\x5d\x92\x35\xed\x93\xa7\x38\xd2\x7e\x12\x3e\x7e\xf2\xe1\xf2\xec\xe2\xdd\xe5\x20\x4f\x1f\x9d\xb4\x30\x91\x16\x92\x0b\xa3\xb7\xeb\x37\xdb\xaa\xce\xb4\x27\x3f\xe1\xa3\x5d\xb9\x73\xe8\xe8\x71\xcc\xbf\x88\xf2\xd2\xa5\xcc\x50\x9e\xe9\x68\x0f\x8d\x2c\x64\x26\xa7\xab\xd3\x2f\x77\xd8\x9c\x9f\x61\x7e\x99\x3e\xed\xdb\x5d\xdf\xaf\xa8\xdf\xa6\x8e\x46\x53\xca\xaf\x2a\x62\x57\x6b\x0d\x52\x33\x94\xbb\x78\xa6\xcb\x7d\x10\xe1\x6c\x09\x06\xa8\x48\xc2\x01\xf6\x29\xfb\xaa\x1c\x78\x51\x0d\x9b\xb6\x52\xdb\x43\x83\x6e\xbb\xc0\x66\xe9\xcf\xf6\x42\x45\x75\x98\xf9\x3e\x75\x02\x57\x28\xd6\x0f\xe9\x9a\xa0\xb4\x8a\x54\x11\xc3\x8d\xe9\x9d\xb7\xde\x78\x5b\x0f\xb6\xca\x16\x4d\x2b\x4e\x25\x1f\x05\xd3\x17\xe6\x18\xc8\xb2\x45\x95\x06\xd2\x69\xd1\x74\x8a\x69\x98\x94\x33\x13\x17\x8a\xcf\x79\xc6\xa6\x90\x8a\x95\x8b\x69\x14\xfe\x1a\x07\xcc\xba\xd4\xac\x75\xa3\xeb\x3b\xfb\x57\x94\x74\x1b\xf0\xe2\xea\xfd\x0d\x64\xf5\x85\x0b\xae\x7b\x0b\xe1\xf6\x83\x70\xde\xfa\xfd\x3e\x98\x0c\x8e\xbe\xb7\xf2\x64\x9a\x1d\x93\xef\x98\xfb\x8e\x84\xb4\xc3\x0a\x4a\x01\xcd\x64\xc8\x01\x0b\x73\xad\x20\x0b\xe8\x88\xd7\xfb\xae\xd5\x89\x6d\x69\x65\x25\x64\x35\xb5\xf6\x50\xf9\x14\x53\x37\xe2\x1d\xd3\xe3\xcb\x9e\x7b\x24\xfb\x3b\x53\x39\x6f\x5a\x5d\x85\x9f\xe1\xe2\xc7\xd3\x43\x4a\xf4\x22\xcf\xb8\xb8\xad\xf2\x82\x4d\xa4\xc5\x21\x0c\x4d\xe0\xe2\xd6\x63\xac\x62\x34\x5b\x4f\x29\x77\xc1\x8f\xbd\x52\x49\xb3\x83\x05\x10\x2c\x74\xf6\x9c\xfd\xd1\x1f\x7b\x77\x0d\x1d\x93\xb8\x83\x83\x67\xb7\x5e\xae\xbb\x95\xc1\x3f\x84\x0e\x35\x9a\x26\xc8\x70\x74\x3e\x1a\x3e\xaa\x85\x7a\x1d\x4b\x80\xd9\x3d\xa1\x54\xc7\x7f\xd8\x76\x3b\xdc\x27\x59\xb9\xbd\x0d\xaa\x77\xd7\x52\x19\x9a\xed\x89\x08\x24\x33\x5a\x9c\x95\x66\x76\xc1\x35\xe4\x50\xe8\x2a\x04\x2c\xf5\x8f\x3c\x9d\x31\x77\xb3\x4f\x18\xc8\x3d\x3a\xb8\x76\xe7\x7f\x3c\xbb\x26\xb4\xb4\xfb\x6b\x5c\x72\xd1\xbd\x5e\xb8\xfb\x99\x8d\x30\xc2\x60\xc7\x75\xb9\xde\x5b\x56\xe5\x5b\x3d\xf4\x9a\x1e\xc2\x0f\xf7\xe5\x2e\x02\x68\x28\x52\xb0\x67\x7c\xff\xc0\x05\x37\x9c\x1a\xd9\xb2\x50\x59\x0d\x05\x6a\x7d\x83\x41\xa0\xd4\x46\xe6\x0e\x83\x87\xbe\x05\x5c\x21\x03\x17\x5f\xea\x54\x59\x0b\x40\x7a\x07\x88\x0d\x85\x95\xb5\x69\xc2\x1a\x0e\x90\x3d\x48\xfa\x89\x63\xf3\xd0\xe6\xb7\xce\x40\x05\xf9\xc1\xb2\xdf\x9d\xd6\x52\xb1\x2f\xd5\xb5\xf0\x56\x8a\xaa\x68\xc2\x5e\x2d\x3e\xfc\x87\xae\x44\x81\xff\x20\x1a\x96\x36\x5c\xe0\xff\x96\x34\x43\xc0\x5c\xed\xdb\x2c\x55\x07\x72\xd7\xf9\xd6\x77\xc8\x4d\xbd\xda\x8e\xab\xa0\xa5\x97\x1a\x33\x8f\xe1\x7a\x8c\xa2\x42\xdb\x3d\xaa\xeb\x62\x87\xee\xe2\xe9\x90\x1c\x99\xa4\x68\x5d\xbb\xff\x81\x5c\xdb\xb3\x52\xd4\x0a\x39\xc3\xcc\x6f\x70\x5b\xde\x06\xd7\xf6\xb6\x93\x7c\x90\xab\x21\xc0\xf2\xae\x56\x15\xd7\x2b\xec\x56\xbc\x2e\x64\xfd\xe4\x2d\xd7\xc6\x17\x64\x80\x17\x5c\xbb\x3c\xc2\x20\x77\x5d\x5b\x45\x8e\x17\x7f\xa3\x69\xaa\x4e\x91\x4b\xf9\xea\xcb\x0a\xa4\x2f\x9f\xe4\x8b\x8a\x70\x97\x78\x64\x16\x85\x4b\x00\x78\x73\x7e\x4d\xb0\x40\xca\x6f\x7e\x85\x95\x5f\xff\xf3\x97\xbf\x7a\xd5\x7a\xbb\x9f\xce\x79\x7c\x47\x3b\xc6\xde\xef\x98\x9e\x85\xdf\x60\xcd\x3f\xd0\xae\x04\x64\x93\x11\xba\xe3\x59\xca\xea\x8e\x3a\x22\x96\xdd\xe5\x40\xef\x77\x93\x60\x5e\xfc\xec\x9e\xd4\xcf\x8e\x84\x88\x12\x24\x12\x1d\xd1\x25\xee\x0a\x21\x86\xcb\x64\x07\x29\xce\xf5\xf3\xa3\x38\x5b\x61\xb3\x1d\x8b\xea\xd8\x13\x5f\xc6\xfb\xf2\x37\x95\x0b\xfb\xc5\xd5\xe8\x6f\x6f\xcf\xbe\xb9\x7c\x0b\x33\x75\xf7\xf7\x16\x35\xb8\xd8\xd9\x7f\xaa\x3d\xaa\xb5\x51\x5e\xb7\x03\xa4\xdb\xb5\x8c\x68\x5c\xc8\x08\x72\xf5\x66\xd4\xf5\x2e\xe6\xbe\x02\xba\x98\xb4\x5a\xfb\xe3\x5a\xdb\xa0\xaa\x09\x53\xfb\x8b\x1f\xd9\xd9\x28\x17\x25\xd2\xaa\xe9\x5f\x76\xa7\x70\x86\xf7\x56\x91\xb6\xee\x00\x79\x06\xf7\x0e\x76\xbd\x08\x83\xbd\xdf\x38\x3c\x10\xac\xda\xca\x01\xaa\x7b\x60\xd1\x21\xf6\xf2\x22\x80\x3d\xa4\x48\xdb\x94\xa5\xd9\x96\x5a\x33\x1d\xaa\x2f\x3c\x53\x4c\x29\x56\xa5\x67\xee\x42\xbd\x56\x0e\x50\x2b\x57\x56\xbb\x8b\xa9\xc5\x52\xac\x4b\x67\xee\x3d\x14\xa8\x53\x5e\x75\x41\x93\xbd\x16\x54\xa9\x5e\xe1\x1b\x08\x72\x7f\x7c\x02\x08\x9f\xdd\xa3\x23\x6d\x18\xaf\x2b\x22\x87\x8e\xcd\x28\xb9\x4e\x3b\xe4\x0b\x7d\x14\xd2\x47\x20\xc6\xe1\x74\x4f\xbc\x7d\xe4\x71\xb5\x9d\xef\x76\x54\x74\xf6\xad\xe4\x14\x33\x69\xa4\xd8\xd9\x4b\x7e\x55\xf7\xfa\x81\xbe\x86\x16\xe7\x55\x19\x9b\xa8\xc6\x23\x78\x50\x86\xcb\x08\x2b\xcf\x79\x76\x21\x85\xbf\x96\xa8\x5f\x4a\x3c\xba\x08\x92\x0e\x2f\xf6\x74\xf8\xbe\xdc\x10\xcf\xae\xc6\xe0\xbd\x3a\x83\xa4\x9d\x63\x52\x6c\x17\x0f\xb1\xe1\x85\x13\xcd\x7c\xc0\x89\x76\x08\x49\xd6\x63\xe4\xde\x58\xa7\x54\xe6\x4e\xaa\xee\xa1\xde\xf5\x8e\x0d\x5f\x05\xf7\xdb\x52\x28\xd6\x73\x3c\x3d\x38\xc7\x27\x3e\x41\x23\x38\x41\x8d\x04\xe7\xeb\x4e\xd2\x43\x1c\xa4\xa7\x3d\x40\xf7\x65\x54\x0f\x1b\xe5\xbb\x57\x21\xdd\xa3\x5b\xc7\xa5\xfa\x6e\xce\x98\x60\x37\xa9\xa2\x16\x14\x4c\x2e\xd1\x89\xdb\x1b\x75\x50\x12\x4b\x50\x76\x21\x0c\xbe\x0f\x1a\x70\x31\xd1\x73\x96\x59\xa8\x4a\x11\xa7\x88\x76\x61\xbc\x3d\x82\x59\x96\x73\x5a\xf8\x9a\xdc\xf2\x4e\xdc\x51\x95\x92\xb3\xeb\xe1\x7e\xa8\x41\x07\x3f\x6b\xc4\xa4\x76\x19\xbd\xea\x9e\xd6\x55\x4f\x2c\x73\x33\x63\x50\x5b\x91\x8c\xb9\xd1\x55\x4d\x3f\x66\x62\xbd\xd2\x52\xc1\x70\x97\x65\xcf\xb2\x3d\xb7\x6e\xa4\x88\x61\x0a\x22\x13\x43\x33\x5f\x44\xc0\x95\xc9\x79\xf5\xea\x15\x9a\xc2\x5e\xfd\xfa\xd7\xbf\xc6\xca\x4a\x29\x4b\x78\xbe\xdc\x10\x5a\xfd\xd7\xeb\xd7\x03\xf2\xa7\xb3\x77\x6f\xa1\xf2\x63\x61\x34\x66\x25\xc1\x91\xb1\x12\x7c\xd4\x59\xf7\xc8\xff\x8c\xde\x5f\x55\x65\x62\xea\xbf\xba\x82\xda\x6e\x79\x03\x72\x11\xf9\x3f\xc5\x86\x2e\x6a\x66\xae\xa0\x91\x21\x74\x32\x41\xc4\x18\xfb\x72\xba\x78\xe0\x7c\xf4\x38\x54\x05\xc7\xfa\x23\x16\x25\x32\x70\xcc\xb2\x2a\x39\x9a\x06\x7d\x66\x03\xf4\x33\x83\xb1\x02\x99\x84\xa9\xf4\xb0\x96\xfc\x44\x43\x15\x92\x2a\xfd\x9f\x62\xda\x0a\xa5\xae\xba\x22\x0e\x56\xed\x8c\x66\xad\x73\x3d\x3c\xc4\x0d\x50\xeb\xea\x18\x75\xd3\xbd\x3b\x43\x3e\x7d\xab\xcb\x5d\x5c\x95\xa9\xff\x1e\x6f\x43\xb7\x39\x09\x3f\xd0\x8d\x4c\x6d\xae\xd7\x61\x36\xb8\x75\x2e\x4b\x40\x45\x27\x68\x26\xa1\x92\x57\xd8\xe9\x8a\x8b\x45\x45\xef\xb7\x2f\xa5\x73\xf2\xc5\xae\x09\x78\x91\x50\xbd\xa3\xad\xcb\xf9\xd4\xfd\x45\x7c\xef\x5a\x5e\x05\x3a\x96\xa5\xf1\x77\xd8\xee\x77\x08\xc0\xc6\x2a\xeb\x1d\xd2\x48\xee\x90\x79\x72\x97\x0c\xc4\x9d\x93\x98\xd6\xef\x9b\x81\x27\xd4\x45\x89\x1e\x61\x34\x99\x91\x5b\xb6\xe8\x23\xdd\x2a\x28\x44\xf3\x00\x54\x2e\x2c\x2c\x6a\x85\x4f\xaa\xda\x35\x56\x3e\x76\x20\xf3\x8e\x01\x11\xf7\xf1\xd1\x40\x5e\x08\xd5\x4e\x5e\x72\x69\x44\x45\x64\x29\xf0\xb9\xaa\xa3\x7a\xc4\x21\x6f\x28\x16\x23\xaf\x07\xa9\xd8\xf3\xc6\x52\xdb\x4d\x6f\xfa\x72\xe5\x0d\x61\xe9\xa0\xe3\x6e\xa5\x58\xea\xed\x8a\x6f\x3b\xe1\x0f\x3e\x48\x7d\x76\xe6\xc8\xa3\x02\xca\xf9\xb9\x4a\x4e\xae\xad\x87\x52\x00\x44\x2d\x88\x46\x33\x53\x3a\xd0\x60\xbd\xb0\x52\x64\x4c\x6b\xc2\x61\x85\x39\x55\xb7\xcc\x27\x8c\xa1\xd9\x80\x5c\xdb\x49\x86\xfc\x55\x98\x16\x79\x8e\x2e\x76\xf6\xcc\xc6\xd1\x41\xf6\x23\x87\x83\xc1\x21\x12\xf8\x15\xb1\x42\x1d\xf0\x63\xb7\x9c\xba\x3b\xe4\xd2\x6d\x94\xf6\x2e\x34\x66\x06\xb6\x22\x1f\x64\xbe\x96\x10\x05\x67\x66\x9e\x81\xd1\xd6\x49\x94\x96\x97\xb3\x43\x02\xd8\x5d\xf3\x96\xef\x92\xb5\xbc\xd5\xbd\x45\xfd\xd9\x3d\x5b\xf9\x4e\xb9\xca\xd7\x65\x2a\x77\x3b\xe5\x4e\x5b\xf7\x1c\xce\xf7\x48\xb1\x9d\x77\x4a\xf3\xea\x9f\xba\x91\x12\xe4\x8e\x5a\x96\x9e\x56\x32\xa2\x4b\xfa\x94\xb1\x2f\x4a\x28\x1c\x4e\x56\x55\x9d\xf3\xc1\x82\x91\xbc\xec\x69\xa8\x85\xc0\xd3\x4b\x83\xdd\x6a\xb9\x90\xce\xe2\x61\xf3\xe9\x22\x2e\x36\x9f\x76\x97\x81\xcd\xa7\xae\xb0\x45\x61\x49\x81\xe8\xc7\x5e\xfc\x00\x52\x23\x21\x67\x77\x75\x04\x07\xe4\x9d\x63\x0a\x88\x8c\x74\xac\x65\x56\x9a\x10\xc9\xb4\x82\x63\xc0\xa0\x3e\xc3\x37\x86\x94\xfa\x66\x11\xff\x00\xce\x89\x64\xb9\x2b\x2b\xc1\x67\xa7\x23\xde\xb5\xe6\xde\x8f\xd6\x99\xe4\x1e\x30\xf4\xa2\xc4\xce\x70\xf4\x03\x84\xbc\x13\xde\x97\xba\x26\xe3\x80\x27\x89\xd1\x28\x40\x79\x71\xc5\x15\x7a\xea\xbc\xc4\x76\x56\x1b\x37\x57\x67\x98\x38\xbb\x1e\xee\xa4\x01\x44\xfd\xd7\xe8\x00\x71\x8b\x1f\xb1\x16\x30\x44\x2d\x20\x2e\xbb\x73\x51\xad\xdc\x99\x94\x2d\xd9\x79\xf6\x62\xe4\xd2\xb4\xdf\x58\x62\x19\x3b\x9d\xd6\x73\xe8\xa1\xb1\xa7\x22\xab\x51\xde\x3d\x7f\xeb\x08\x87\xf8\xb9\x8b\x9c\x8f\x28\x3e\x02\x3c\x3a\x95\x4b\xf7\xcf\x72\x35\x3b\x58\x2c\x19\x41\x69\x1b\xd4\x07\x23\xc5\xb2\x90\xe9\xa9\x2b\x25\x2d\x84\xc4\x02\x72\xba\x87\xb5\x71\x74\x0f\x15\x46\x2b\x45\x44\x77\xc5\x2a\x32\xb9\xef\x2c\x37\xec\x54\xe5\xe8\x3e\x75\x8e\xec\x06\xc2\xca\xaf\xbb\xee\x22\xb9\x67\xd9\x22\x12\xb1\xa6\xdd\x0a\xa1\xd4\xf6\xd4\x8d\x14\xea\xbc\x27\x33\x96\x53\xcc\xe1\xe7\x97\x67\xa9\xcc\x9d\xe2\xc6\x30\xcc\xa5\xc4\x54\xae\x89\x9c\xf4\x6a\x77\x06\x07\xf3\xd7\x07\xbb\x94\x83\xb9\x67\xc5\x1e\x52\xed\xc2\x1e\x80\x71\x5d\x13\xd9\x2c\x5e\x83\x2e\x91\x41\xe2\x4d\xd1\x30\x48\x58\x06\x33\x47\xe8\x3d\xfa\xc2\xf7\xa1\x47\xed\xaa\x3f\xf5\x82\xc0\xf0\xa2\x3f\xbd\xe8\x4f\x7b\xd1\x9f\x22\xc6\xe2\x09\xce\x0a\x5d\x2a\x76\x18\xf6\x0a\x55\x15\xc8\x14\x25\xe0\xb1\xa8\xe9\x55\x29\xa9\xea\x16\x37\xab\x0f\x1d\x7a\x05\xcb\xe1\x71\x69\x26\xfd\xdf\x10\x26\x12\x99\xe2\xe6\xdb\xf1\x95\x36\x20\xda\x54\x3a\x49\x3c\x97\xdc\x7f\x2b\xb6\xda\xc1\xd8\xbb\x6e\xdd\x4e\x74\xc0\x5f\x05\xbe\xd9\x13\x83\xaf\xd8\x7a\x08\x26\xf6\xb5\xb2\x7d\xae\x01\xc7\xdf\xab\x4b\x48\x2c\x2b\x0d\xc8\xed\x2b\xe6\x92\x23\x7c\x39\x48\x8a\xb2\xe7\x1a\x0c\x72\x96\x4b\xb5\xe8\x85\x46\xf6\xc7\x5a\x2f\xd7\xe2\x18\x64\x82\xa4\x54\x56\x03\xcc\x16\x5f\xaa\x74\xe0\x01\xf4\xc8\xc2\x41\xd8\xa7\x6e\x45\x83\xe2\xa7\x8e\x12\x55\x52\x31\xd0\xef\xab\x22\x4a\x93\x90\xf2\x50\xf7\x2a\xb5\xd3\xbe\x65\x62\x4e\xe6\x54\x75\xa8\x82\x1e\x3f\xf7\x94\x07\x52\x3e\xe7\x7a\xb7\x7a\x87\x8d\xa5\x8f\x1c\xd3\x40\xbb\x8e\x2c\x4d\x51\x1a\x47\x29\xfd\xa9\xf0\x21\xf3\xe1\x34\x34\x84\xa2\xd7\x07\x3b\x4d\xe3\x8b\xa9\x2f\x8c\xcf\x8e\x55\x86\xf1\xb9\x6f\xad\xe1\xfa\x28\x3b\xa3\xcd\x5e\x2b\x87\xfb\xc7\xa3\xc5\x3e\xce\x61\xc5\x22\xab\x3c\x0f\x5e\x38\x7d\xa4\x83\x86\xee\x26\x3b\xd9\x6d\x5c\x86\xfa\xd5\x26\x1b\xf7\xe3\x8f\xd8\x5a\xb3\xdf\x3b\x5b\x17\x5f\xf8\x13\xbf\xb0\x1d\xb9\x7a\x06\x2f\xb7\xb5\xad\x50\xf0\xe5\xb6\xf6\xe5\xb6\xf6\xe5\xb6\xf6\xc5\xda\xf0\x62\x6d\x78\xb9\xad\x25\x2f\xb7\xb5\x7b\x81\xe1\xfe\x6e\x6b\x51\xd4\x5b\x75\x67\xeb\x84\xbd\xea\xc2\xf6\x51\xef\x6b\x5d\xe1\x9e\xb3\x24\x91\xa5\x30\x37\xf2\x96\xb5\xbe\x74\x68\xc8\xff\x4b\xe3\x40\x02\x84\x35\xfa\xc0\x72\xe3\x47\x53\x0e\xba\x4b\x25\x9d\x64\x8b\x5d\xa4\x0a\x5a\xa6\xdc\x4a\xfe\x3b\xa3\x99\x1f\x20\x4e\x4e\x24\x52\x96\x56\x3f\xb8\xa3\x6c\x2c\xac\x07\xe4\x8c\x28\x96\xf0\x82\xbb\x32\xf2\x14\xdf\x23\xe2\x85\xda\x08\xdc\x68\x96\x4d\x5c\x8e\x7a\x11\xd7\xfa\xa9\xe4\x77\x47\x07\x57\x7e\x06\x39\x94\xf4\x99\xcc\x7d\x2d\x24\xc5\xbe\xf7\xac\xcd\xcd\xe6\x26\x1e\x21\x36\xaf\xc0\x52\x6a\x25\x86\xe0\x63\x05\x77\x01\xd6\x0f\x7d\xfc\xd9\xe7\x82\x2b\x40\xde\x11\x4b\xa4\x68\x53\x53\x75\xcd\x06\x2d\x8d\x54\xf1\x27\xb0\x8d\xb2\x94\xa4\xa5\x0a\x35\x53\xe7\x34\xe3\x29\x37\x8b\x70\x6b\xe7\xca\x6b\x51\x3c\x31\x61\x1b\x75\x05\x46\x42\x8b\x42\x49\x9a\xcc\x98\x8e\xbe\x86\x02\x8a\x0b\x22\x0b\xbe\xef\x58\x02\x0e\x64\x14\xe8\x63\x19\x64\xb6\x20\x4a\x1a\x7f\xf1\xbe\xe6\x83\x37\xd1\x60\xd0\x1d\xb9\x9c\x51\x0b\xb8\x9d\x97\xf1\x10\x38\x2b\x3e\x89\xff\xd0\x44\x66\xa9\x4f\x61\xf2\x9b\x57\x56\x28\x4c\x1c\x0e\x5a\xe2\x07\x09\x2e\x8c\x24\x99\x65\xd8\x96\x20\xae\xef\xfc\xcb\xaf\xc9\x4c\x96\x4a\x0f\xe2\xa4\x03\xaf\xe1\x1d\xea\x77\x5e\xa8\x34\x24\x63\x54\x1b\xf2\xfa\x15\xc9\xb9\x28\x2d\x9f\xea\x8c\x36\xdd\xe5\xa0\x48\x02\xfa\xd5\xd7\xad\xfb\x75\x95\x7d\xd6\x4a\x3d\x05\xe6\x46\x76\xa2\x8f\x3b\x49\x18\x18\x87\x99\xc5\x1b\x82\x90\x23\xba\x31\xb4\x85\x91\x0f\x70\xbe\x7e\x28\xe5\x78\x61\xba\x04\x51\xba\x1e\xf5\xe8\xc9\xff\x75\x2f\xdb\x24\x4f\xa9\x72\xa7\x6c\xfc\xe8\x83\x54\xb8\x98\x72\x6d\xb6\xd4\xb7\xa8\xe2\x2b\x37\x36\x6b\xcf\x56\xa6\x56\x3b\xe8\x18\x2b\x03\x7d\xbc\x44\xec\x6d\x4b\x49\xc2\xb0\x98\xe5\x45\x55\x29\x49\x48\x6c\xbb\x75\xf8\x27\x4e\x38\xe6\x11\x64\x0f\x59\xd3\x5b\x2e\xb5\x9d\xd0\xe5\x51\xa2\xf3\x5a\xb1\x5b\xfd\x14\x68\x2e\xa6\x98\xe4\x3c\x2f\x33\xc3\x8b\xac\x5a\xf7\x07\xdf\xc1\x11\xf2\xd8\xe6\x46\x23\x33\x11\xc5\xc0\x62\xcc\x36\x05\xf6\xc9\xa3\x30\x16\x13\x06\x73\x75\x2b\xcb\x0f\x0a\xaa\x68\x00\x1e\x54\xd2\xd5\xc7\xce\x7c\x47\xe1\x46\xd1\xa5\xc3\xb4\xbd\x68\x56\xcd\x38\xba\x45\xda\x27\xd2\x18\x26\xa8\x68\x61\xaa\xae\xa7\xe7\x82\x4e\x44\xde\x05\x67\x32\x2c\x83\xd2\xc0\x16\x27\xd4\x7c\x43\x93\x5b\x26\x52\x2c\x1a\x05\xcb\x4e\x17\x82\xe6\x2e\xdb\x56\x54\x8f\xbb\xd1\x5f\xf7\x9c\x61\x02\xc3\xf7\x7c\x98\x31\x72\xdd\x7d\xc2\xa0\xd4\x9d\x53\xd9\xd8\x2e\xdb\xce\xb9\x46\x93\x8d\xe2\xf3\x84\x79\xfe\x6f\xfb\xed\x73\xea\xf3\x16\xb1\xf4\x4b\x93\xf7\xdb\x13\xe1\x2f\x90\xfb\x60\x39\x87\xa4\x5a\x34\xb3\x47\x7b\x11\x62\x46\x1b\x9b\x3b\x5e\xec\xb7\xea\x8d\x1a\x77\x89\xfc\x3d\x54\xe3\xb4\x7e\x88\x3f\xd0\x54\x6a\xf2\x4d\x26\x93\x5b\x72\xc1\x40\xe8\x7a\xc8\xf2\x2c\x6a\x9c\x3e\x65\x0a\xef\x9c\x4e\xb7\xdd\xb3\xf5\x49\x2e\x05\x37\x52\x6d\xa6\x17\x8f\x57\x76\xf2\x25\xdd\xf3\xda\x0c\x55\x16\x9b\x9f\x73\xb2\x67\x8b\x6e\x5d\x37\x1e\x3a\x05\xf5\x0c\x4e\x27\xbe\x72\x55\xc0\x76\x3c\x6b\x3f\x9b\xc9\xbb\xbe\x91\xfd\x52\xb3\x3e\x6f\x71\xa1\xdb\x61\x99\xb7\x6c\x01\xb7\xd8\x1d\x17\xea\xba\xd5\x74\x06\x23\xc1\x02\x05\xef\x2d\xe7\xfe\xf0\xcd\xc5\x47\xcd\xd4\x20\x96\x01\x4f\x98\x49\x4e\x12\x56\xcc\x4e\xdc\x08\xcf\x12\x28\x9e\x88\x74\x85\x8a\xef\x87\x6c\x26\x91\x59\xe6\x02\xb3\xe5\x84\x9c\xb3\x62\x16\x06\x7e\xec\x55\x3f\x5d\x46\xe0\x42\xca\xae\x89\x50\x0f\x6d\x9f\xfa\x21\x82\x37\x78\x86\x22\x64\x52\xe3\x6e\x45\x28\x1e\x0b\x7d\x9e\x75\xa9\xcd\x07\x04\xce\xc3\xa6\x53\x3e\xac\xe5\x53\x8e\xfd\x3d\xeb\xc9\x92\xbd\xc7\x48\x8d\x04\x0d\x27\x28\x74\xa7\x2c\x25\x72\xce\x94\xe2\x29\xd3\x24\xd0\xa0\x58\x4b\xe5\xd9\x63\xc3\xed\x25\x6f\xf3\x93\xe7\x6d\xde\x41\x1d\x3a\x04\x7d\xa8\x46\xa6\xe0\xcd\x12\x99\xa2\x69\xce\xc5\xb3\x23\x54\x3a\xa1\x19\x1b\xbe\xef\xa0\x7f\xb8\x1e\x75\x15\x64\xe4\x5e\x46\xf9\xd3\xb6\x64\x25\xfb\x36\xe0\x0d\x11\x32\xdd\x66\x52\x7d\x00\x45\x62\x4a\x0d\xbb\xdb\xca\x0e\xfb\x15\xa1\xda\xde\x12\x84\xd3\xa7\x54\x39\x9e\x45\x8e\xc0\x08\xe7\x31\xe9\xd9\x3e\x99\xaa\xdb\xb5\xae\xc6\x49\xec\x15\xa7\xdf\x6d\x26\xdd\xf5\x18\x7c\x76\x3d\x24\x7f\xc0\xe6\xfb\xcd\x5e\xa8\xa4\x41\x31\xf0\x42\xe6\x94\x77\x2d\xb2\xd1\xec\xde\xcc\xbe\x1a\x2f\xe1\x3a\xb4\x25\xae\x71\x54\xc0\x65\xc2\xa7\xa5\xd5\xe9\x9c\x1e\xf6\xac\x12\xcc\x2d\x89\x2e\xcf\x37\xc1\xdc\xfd\xab\x41\x44\x26\x27\xef\x17\x59\x49\x2c\x7e\x2b\x81\x95\x84\x3b\x50\xa2\x99\xd0\x1c\x2e\x64\xa2\x5b\x71\x57\xe9\x0f\x4b\x4b\xa2\x13\x24\x8a\x38\x3d\xf2\x56\x4e\xb9\xf0\xa7\x57\xba\xfb\xba\x09\xe5\x59\x5b\x60\xbc\xc8\x24\x4f\x2e\x93\x68\x9d\x5d\x0a\x3a\xce\xda\xb8\x1b\xd4\x51\x2d\x74\x24\x6f\x32\x3a\x25\x0c\xfe\x38\x49\xb9\xb6\xff\x27\xa3\xd1\x5b\x30\xc2\x97\xc2\x4b\xcc\x60\xa0\x76\xb4\x2f\x04\x29\xe0\x41\xdc\xef\xd9\x41\xd2\xb3\x43\xf6\xbf\xa8\x27\xe1\x22\xb5\x13\x8f\x4a\xc1\xa1\x93\x14\xb4\xc0\x7c\x88\xc1\xe7\x17\xdd\x06\xc6\x8c\xdc\xcc\x78\x72\x7b\x1d\xd9\xdd\xa5\xb2\xef\x44\xf4\xaa\xc6\xc0\x9a\xbf\xed\x93\x5a\xba\xa9\x5e\x77\x57\x8d\xa3\x9e\x9e\x0f\x78\x82\x31\x72\xeb\x87\xdf\xa8\xd6\x32\xe1\xd5\x9d\x0b\xd8\x68\x2a\xe6\x90\x02\x73\xd8\xef\x9a\x40\x3c\xe8\xba\x1c\x94\x3f\x56\x70\x34\xbf\x9b\xbe\x3a\xae\x8e\x39\x18\x17\x7e\xd5\x7b\x5d\x02\xe2\xcc\x0e\xa9\xd1\xab\x8e\xcb\xa9\xd1\xbd\x30\xdc\xb8\x58\xf0\x6e\xea\x6e\xf3\xbc\x20\xe6\x6b\x73\x2e\x6d\x5f\x48\x91\xee\x52\x13\xee\x6d\xe1\x6d\xc2\x36\x56\xa9\xe1\x8d\xdb\x44\x7c\xe7\xae\x1a\xe0\xcc\x15\xb2\x28\x33\xf4\xe7\xb8\x7f\x7e\x77\x6f\x33\xc6\xef\xec\xe9\xea\xe1\x31\xb2\x96\x1e\xc6\x8e\xbd\xdd\x3d\x9d\x7f\x1c\xb9\x4b\x23\xe1\xee\xd5\xaf\xbe\xfe\xfa\x4b\xcf\x66\xda\x56\x05\x7f\x88\x74\xa6\x2d\x4d\xb4\x2b\xe2\x8b\x86\x2f\xf1\x45\x3f\xdd\xf8\xa2\x87\xcf\x42\xbb\xe7\x08\xa2\x8e\xbe\xb9\xdd\xfc\x72\xdb\xc7\x08\xb5\xf6\xde\xed\xea\xb9\xdb\x21\x0a\x68\xbf\xb1\x3f\x9d\x7d\x59\xbb\xc4\xf9\xbc\x44\xf7\xfc\x58\xa3\x7b\x76\xf1\x65\xed\x1e\xc9\xd3\xc5\x87\xf5\xc7\x18\xb5\xd3\xe1\x70\xb6\x8f\x2e\xb9\x77\x4c\x49\xf7\x24\x80\xdd\xed\x69\xbb\x14\xa4\xaa\x7a\xae\xd4\x20\x7d\x50\xb9\xcf\x3d\x76\x78\xa8\xa3\xd4\x62\x46\xda\x13\xf8\x28\x0a\x09\xe9\xa0\x8d\xe1\xf0\xb2\x4b\x6d\x48\xd7\xe7\xfd\xa8\x71\x31\x13\x5e\x3f\xcd\x7d\xcc\x4f\xe1\xc2\xe3\xa5\xa6\xcb\x17\x62\x72\xd7\xb5\x6c\x2d\xde\x5a\x01\x24\x00\x18\xb9\x1c\xc7\x59\x22\xab\xa3\x73\x76\x3d\xb4\x3a\x38\x84\x11\xd1\x4c\x0f\xc8\x0a\x3e\xef\xcd\xa5\x4e\x2e\xf0\xfc\x9d\x1a\xc3\xf2\xc2\xb4\xdf\xf5\x17\x8b\xfb\x93\x5b\xdc\xf7\x68\x01\x9c\x95\x39\x15\x7d\x7b\xa2\xc0\xe6\x5e\xbb\xad\x6b\x50\xe6\x01\x71\x67\x07\xd9\x13\x58\x40\x20\xb8\xa0\x5e\xd8\x98\x46\x65\x2e\x1f\xc6\xec\x09\x63\xef\xbc\x72\xe4\xab\x8d\x93\x96\xc8\x25\x87\x57\xb7\x9c\x00\x05\x7f\xa8\x22\xe6\x5c\x53\xc3\xcd\x8c\x21\x0f\xbf\x86\x80\x9c\xaa\x55\x5d\x92\x46\x51\x9a\x66\x99\xbc\xc3\x6f\xc7\x7c\xcd\x42\xdf\xce\xc5\x45\x9a\x8d\x19\xc9\xb9\xd5\xd1\x9d\x81\x35\x9e\x0e\x5e\x99\x5a\x89\x9c\x29\x14\x78\x95\xbb\x6c\x1b\x31\xe3\x36\x0a\x36\xda\xea\xb7\x02\x1d\xc2\xed\xbf\xbd\x57\x11\x7c\xdb\xd3\x84\x31\x9b\xd1\x39\x97\xa5\xc2\xde\x46\x92\x03\xf7\x13\xf0\x86\x85\x2c\x83\xbd\x0b\x8b\x61\x86\xd5\xe9\x15\x70\xba\xaa\x7e\x04\x55\x20\x95\xde\x34\xd1\x67\x9f\xb9\x36\xcb\x6b\xf1\x20\xf2\x69\xf0\xf6\x85\x37\x73\x5d\x58\xb6\xd0\xb9\xaa\x5d\xad\x5f\x5d\x5e\x99\x8f\xe0\xa7\x2f\xa8\xa6\xdd\xd6\xec\xae\x8f\x26\x02\xfd\x04\xc5\x9f\x70\x13\x96\xf1\x64\xd1\xb9\xdc\x5b\xa3\xb7\x27\xda\x3a\xdc\xa1\xd9\xf7\xe4\x1b\xaa\x59\x4a\xde\x51\x41\xa7\xa8\xef\x1d\x8d\xae\xbf\x79\x77\x6c\xf7\x15\xf4\xc9\xe1\xc5\xca\x8b\xb6\x51\x3c\xf8\xd5\x3e\xe3\x45\x96\x16\xbe\x03\xab\x5a\xea\xbf\xe3\xe2\xf7\x1a\x08\x43\x02\x1f\x6a\x97\xac\x77\x05\x0b\xba\x6e\x86\xb0\x36\x6b\x7e\x36\x08\xcc\x3c\x4f\xef\x59\xe5\x93\x0b\x6d\x68\x96\x5d\x67\x54\x9c\x15\x85\x92\xf3\xd5\xda\x78\x6d\xae\xbe\xa1\x9f\x29\xba\x79\xf8\x97\x05\x82\x1e\xae\xb0\x05\x19\x56\xe3\x0f\xc8\xd0\x04\x2d\x5c\x0a\x60\xa9\x07\x67\xa5\x91\x39\x35\x3c\x39\xb0\xca\xfa\xc1\x3b\x2a\x4a\x9a\xad\x74\xba\xda\xb8\x8c\x75\x22\xe2\xc6\x4e\xeb\x53\xd7\xb5\xe8\xb6\x51\xd6\xd8\xdc\xdf\x50\x65\xa9\xd3\xf9\xe8\x53\xa7\xbe\xda\x50\x53\x2e\x51\xe1\x0d\x9c\x61\x3d\x2f\xe8\x93\x8c\x6a\xf3\xb1\x48\xed\xa1\x6f\xfc\xba\x89\xe0\x27\xd4\xd0\x4c\x4e\xff\xc8\x68\xb6\x1a\xc3\x6b\x78\x72\x1e\xb7\xf6\x06\x28\x77\xe1\x5f\x8e\x43\xc3\x43\x4d\xac\x80\xed\x63\xe0\x15\xcb\xd8\x9c\x0a\xe3\xbb\x63\x71\x75\x7d\xe8\xd6\x0f\x58\xc4\x2b\xe3\x6b\xca\x0c\x53\x39\x17\xf5\x31\x47\xd0\xf6\x5c\x8a\x94\xa3\xd9\x11\x0c\x6a\xd8\xa3\x3e\xee\x7a\x54\x5b\x77\xd3\xb0\xe1\x6e\xa1\x9e\x5d\x33\x9a\x4f\x1d\x14\xd8\x6c\xec\xe4\xcb\x19\xbe\x84\x9b\xf6\xda\xdc\x96\x20\x45\x6e\x85\x15\x0c\x21\x8f\xc8\x6a\xb2\xb5\x55\x4e\xd8\x26\x1f\xf4\xfd\x1e\xe3\x14\xd6\x3b\x8e\xf6\xdd\xbc\xd7\xdd\x41\x6c\x42\x31\x7c\xb6\x4b\x16\xcd\xa9\xac\xa7\xa9\xab\xf0\x2e\x74\xc3\x48\x96\x46\x41\xfe\x5a\xa3\xf5\x3c\xa0\x95\xe0\xd5\x4e\x46\x6a\x9b\xd5\xbe\x4e\x6b\xab\x1c\xec\x4b\xaa\x6c\x0b\x89\x71\x2b\xd3\x6a\x99\x5c\xbe\xae\x58\x0f\x9d\xff\x9f\x72\xaa\x08\x25\x05\x67\x98\xfc\x84\x0a\x07\x2c\xe0\x2c\x8c\xa6\xee\xa5\xe5\x60\x56\x25\x84\xdf\x7a\xee\x32\x1c\x8d\xcb\xce\xd7\xc2\x1b\xa8\x29\x26\xff\x80\x8b\x8b\x93\x3f\x48\x67\xe4\x75\x41\xba\x96\x06\x00\x27\xef\x11\x5d\x26\x33\x42\xb5\x9d\x9a\x45\x68\x7b\xe2\xd9\x20\xa7\x82\x4f\x98\x36\x83\x90\x25\x58\xff\xf9\x97\x7f\x1d\x90\x37\x52\x11\xe7\xa8\xde\xf3\x59\x35\xdc\x3c\x2b\xbc\xe0\x1a\x17\x13\xfa\x56\x5a\x6b\x21\x53\x37\xe9\x3b\x98\xac\xa1\xb7\x96\x87\xe1\x64\x4b\x06\x57\x17\xa7\xe4\xc0\x8a\x89\xd1\xa7\xff\x69\xd9\xd2\xbf\x0f\xc8\xd1\x1d\x30\xed\x03\xfb\xe7\x01\x7e\x30\xb8\x4d\xc6\x4a\x75\xf5\x61\x0c\x96\x54\x7c\x3a\x65\x0a\xd5\x47\x02\x41\x85\xc7\x2e\x2b\x88\x90\x51\x63\x7f\x29\x5d\xa9\x9b\xcd\x89\xfc\xf9\x97\x7f\x3d\x20\x47\xf5\x75\x11\x2e\x52\xf6\x99\xfc\x12\xad\xcb\x5c\xdb\x35\x1e\xbb\xcb\x1c\xbd\x10\x86\x7e\xb6\x63\x26\x33\xa9\x99\x40\x55\xde\x48\x32\xa3\x73\x46\xb4\xb4\x1a\x30\xcb\xb2\xbe\xb3\xa5\x93\x3b\x0a\x99\x5a\x3c\x28\x21\xb0\x9e\x14\x54\x99\x1a\x4a\x0c\x9c\x85\x04\xbe\x66\xb7\x6d\x2a\xfc\xcd\xf4\x84\x0b\x77\x7f\xe5\x6e\xce\xec\x9e\x43\x60\x28\x6e\x92\x91\x24\x99\x51\x31\x0d\xb1\xe9\x93\xd2\x94\x8a\x6d\xb9\xfa\x69\x79\x06\x6e\xb9\xe8\x14\xc2\xfc\x2d\x17\x4d\xa7\x82\xd5\x76\xa5\x29\x37\x3e\x2a\xc2\xf9\x2a\x9a\xc5\x89\xdd\x05\xc5\xc7\xa5\x91\x4a\x9f\xa4\x6c\xce\xb2\x13\xcd\xa7\x7d\xaa\x92\x19\x37\x2c\xb1\xcb\x3a\xa1\x05\xef\x27\x52\xd8\x1d\x87\xac\x0c\x79\xfa\x33\x28\x6f\xda\xb7\x53\xdd\x92\x75\xba\xe5\xa2\xb7\x1b\xd5\x9e\xd4\x98\xb6\xb7\x35\xb6\xb0\x07\x2d\x2f\x14\x6d\x33\x8f\xb0\x5a\x30\x84\x9c\xec\x65\xb1\x3e\x69\x72\x77\x1e\x73\xe8\xf2\x80\x27\xcd\x31\xec\xb1\x43\x07\x12\x38\x95\x35\x4a\x99\xd3\x14\x49\x29\x15\x8b\x07\x47\x7e\x0b\x52\x48\x97\x9f\x2c\xfa\x30\x84\xcc\xfa\x54\xa4\xf6\xdf\x18\xb0\x93\x2c\xf6\x02\xc3\x92\x77\x22\x04\x1f\x87\x17\x8f\x73\x24\x4a\xbe\x87\x53\xef\xe4\xb5\x96\x42\x14\x8a\xaa\xe8\xa8\xa1\x4a\xe6\x99\x66\x5d\x40\xe5\xda\x8f\xfa\xdf\xee\xfe\x25\x64\x3b\xdb\x26\x52\x6d\xbe\x35\x89\x64\xc7\x96\xf3\x7d\x5b\xf5\x88\x6d\x72\xe0\x78\x45\xb5\x71\xa9\xb5\x7c\x0e\x82\xda\x32\xbc\x82\x02\x0c\x66\xfd\xc5\x70\x2b\x1c\xf2\xfe\x02\x76\x22\xfd\x95\x39\x97\x92\xa0\x94\x6c\x57\xa0\x2a\xfd\xa5\x56\x07\x0d\x17\x65\x98\x36\x84\xce\x29\xcf\xc0\x3a\x2f\xc7\x9a\xa9\x39\x16\xa4\x72\xa9\x06\x69\x53\xcf\x72\x35\x27\x50\x8c\x7a\x24\xcd\xc7\xaf\x61\x79\x57\x36\x2d\x00\xb4\xa1\xc6\xec\xd7\xce\x7a\x2f\x7a\x0f\xaa\x97\x6b\x7f\xb6\x5f\xd8\x51\x8d\xb1\xf8\xf7\x47\x46\x95\x19\x33\x6a\x6e\xf8\x26\xbe\xbb\x84\xd2\xb5\x7e\xa1\x94\x7b\x40\xe8\x3b\x46\xa6\xd2\x58\x11\xab\x04\xdc\x47\x99\x14\x93\xfa\x04\x44\x7b\x68\x8c\xae\x56\x79\xa3\x28\x84\xf8\x48\xd1\x71\x99\xf5\x8e\xcb\xeb\x74\xd2\xb1\xc3\x24\x83\xad\x31\x91\x86\x14\xcc\xed\x1d\xde\x66\x00\x05\x7a\x9c\x25\xe7\x4c\xeb\x8d\x09\x36\xea\xde\x85\xd8\x1a\x8f\x72\xe3\x6a\x2d\xf7\xbf\x61\x58\x88\x15\xa0\x53\x66\x28\xcf\xfc\x51\x46\x50\x04\x28\x6d\xa3\xae\x1b\x17\xa8\x18\xd5\x9b\x04\x84\xda\xac\x3f\x40\x63\x9c\xb4\x14\xac\x7f\x27\x55\x4a\xce\x69\xce\xb2\x73\xaa\x99\x1b\x2b\x0e\xd1\xc3\x3d\x3a\xd4\x7b\x9d\xf2\x6a\xdb\xd7\x9a\x29\xa3\xf1\xa7\x32\x09\xc3\x5f\x95\x8a\x85\x13\xec\x79\x13\xe4\x8d\x2a\x59\x8f\xbc\xb1\xdc\xab\x47\x3e\x8a\x5b\x21\xef\xee\x37\x57\xb3\xf1\x16\xa4\x36\xd3\xd8\xfd\xc3\xa7\xd5\xa9\x19\x7c\xc2\x74\x77\x9c\x91\x23\xf8\x6b\x4c\x8d\x75\x66\x13\x9a\xfa\x19\xd9\x7f\x2e\x99\xa0\xac\xa2\xa8\xe4\x54\x31\x8d\x99\x6b\x56\x26\x49\x6c\x6b\x72\xfe\x03\x13\x2e\xb8\x6f\xeb\xf4\x86\xab\x7a\xf9\x99\x7a\xbe\x36\xad\x7e\x71\xfb\xed\x3e\x56\x64\x2b\x45\x8d\xcd\x1e\x81\xd1\x44\xd7\x18\x9f\xd6\xcd\x70\xb5\xd1\x29\xe2\x7a\x51\x5b\x14\x4a\x36\x59\x47\xfd\xea\xce\x47\x9f\xd6\x03\x7b\x2d\xef\xdb\xc6\x9f\xb6\x9b\xa5\xee\x6b\x90\xda\x7a\x66\xb6\x1a\xa1\x5e\xcc\x4f\x2f\xe6\xa7\x2f\xc9\xfc\xb4\x15\xe3\x37\x99\x9c\xbe\x0c\x63\xd3\xd6\x25\x6e\x32\x30\x3d\x4b\xd3\x52\xab\x15\x6d\x34\x27\x3d\x5b\x43\xd2\xd6\xa5\xb5\x34\x1e\xfd\x74\xcc\x46\x5b\x21\xb6\xc1\x54\xf4\x0c\x8d\x44\x6d\x04\x32\x96\xb6\x11\x13\x87\x51\xe3\x58\x50\xac\xca\x59\x86\xe1\xbc\x53\x4e\x2c\xce\xec\x2a\x2d\x5a\x01\x6e\xeb\xdc\x0e\xdd\xe4\xda\xcb\x5e\x4e\x60\x74\xc5\x1e\x97\x26\x4b\x2e\x2e\xaf\x3f\x5c\x9e\x9f\xdd\x5c\x5e\x34\xe5\xbb\x55\x90\xde\x22\x89\x6d\xb6\x41\xf4\x23\x49\x6c\x4d\x03\x4b\x90\xd7\xfc\x64\x71\x60\xcd\x4f\x65\xc9\x57\xf5\xba\xbf\x5c\x78\x2f\x2e\x77\x2f\xfe\xb1\xfd\x74\xb6\x3d\x9e\x1f\xd1\x71\x8a\x3a\x9f\x33\x2b\xf7\xcc\x64\x96\x6a\xef\xb7\x3a\xbc\x08\x91\x54\x5c\x24\x59\x99\x5a\xe1\xe2\xe3\xc7\xe1\x85\x1e\x10\xf2\x0d\x4b\x68\xa9\xc1\x0a\x93\x4a\x71\x68\xc8\xfb\xab\xb7\x7f\x02\x7f\x6c\x68\xd1\x0b\x79\x4d\x20\x2b\x2f\xa7\x98\x58\xd8\x60\xba\x36\xf2\x0d\x43\x41\x05\xbe\x9c\xd0\xc2\x52\x31\x8d\x95\x2b\x0c\xc8\x22\x33\x96\x15\x96\x62\xde\x32\x52\x65\x50\xb5\x03\x57\x15\xe6\xbd\xfb\xe4\x94\x19\x8c\xba\xda\xe4\x21\xb9\x11\x6a\x5b\x2c\xae\xf7\xb0\xb5\xd6\xd4\x47\xa7\x8d\xdf\x51\xed\x2c\x56\x2b\x67\xbb\x65\x7f\xb7\xdb\x67\xd6\x9b\x38\xd6\x18\x37\x90\x3c\xc3\x5f\x4b\x73\xb6\x93\xad\xec\x18\xe8\x44\xc2\x4d\x6b\x6b\xea\x7a\x37\xa0\xd5\x75\x00\x96\x6c\x19\xac\x09\xe4\xda\x87\x83\x47\x76\x34\xe5\x76\x73\x81\x22\x22\x69\xad\xf6\xa7\xf3\x9f\xab\xbf\x2b\xc7\xa1\xfa\x6b\x35\x5f\x67\x91\x21\xff\xfc\xf7\x57\xff\x3f\x00\x00\xff\xff\xbb\x99\xbb\xd7\xde\xb1\x01\x00") +var _operatorsCoreosCom_subscriptionsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\xbd\x7b\x73\xe3\xb8\x95\x38\xfa\xff\x7c\x0a\x94\x93\x2a\xdb\x59\x49\xee\xce\xe6\x97\xe4\xf6\xa6\xb2\xe5\xb1\xdd\x13\xff\xa6\xbb\xc7\xdb\x76\xcf\xd4\xde\x6c\xee\x06\x22\x21\x09\x31\x09\x70\x00\x50\x6e\xe5\xf1\xdd\x6f\xe1\x1c\x00\x04\xa9\x17\x29\xc9\x8f\x9e\x21\xff\x98\x69\x53\x00\x08\x1c\x1c\x9c\x17\xce\x83\x16\xfc\x7b\xa6\x34\x97\xe2\x0d\xa1\x05\x67\x9f\x0d\x13\xf6\x2f\x3d\xba\xff\xbd\x1e\x71\x79\x36\x7f\xfd\xd5\x3d\x17\xe9\x1b\x72\x51\x6a\x23\xf3\x8f\x4c\xcb\x52\x25\xec\x92\x4d\xb8\xe0\x86\x4b\xf1\x55\xce\x0c\x4d\xa9\xa1\x6f\xbe\x22\x84\x0a\x21\x0d\xb5\xaf\xb5\xfd\x93\x90\x44\x0a\xa3\x64\x96\x31\x35\x9c\x32\x31\xba\x2f\xc7\x6c\x5c\xf2\x2c\x65\x0a\x06\xf7\x9f\x9e\xbf\x1a\xfd\x7e\xf4\xea\x2b\x42\x12\xc5\xa0\xfb\x1d\xcf\x99\x36\x34\x2f\xde\x10\x51\x66\xd9\x57\x84\x08\x9a\xb3\x37\x44\x97\x63\x9d\x28\x5e\xc0\x27\x46\xb2\x60\x8a\x1a\xa9\xf4\x28\x91\x8a\x49\xfb\xbf\xfc\x2b\x5d\xb0\xc4\x7e\x7c\xaa\x64\x59\xbc\x21\x2b\xdb\xe0\x70\x7e\x8e\xd4\xb0\xa9\x54\xdc\xff\x4d\xc8\x90\xc8\x2c\x87\x7f\xe3\xda\x6f\xa3\xaf\xc2\xeb\x8c\x6b\xf3\xed\xd2\x4f\xef\xb8\x36\xf0\x73\x91\x95\x8a\x66\x8d\xd9\xc2\x2f\x7a\x26\x95\xf9\x50\x7d\xdb\x7e\x4b\x97\xe3\xf8\xdf\xae\x21\x17\xd3\x32\xa3\xaa\x3e\xc8\x57\x84\xe8\x44\x16\xec\x0d\x81\x31\x0a\x9a\xb0\xf4\x2b\x42\x1c\x1c\xdd\x98\x43\x42\xd3\x14\xf6\x86\x66\x37\x8a\x0b\xc3\xd4\x85\xcc\xca\x5c\x84\x6f\xda\x36\x29\x0b\xa3\xbe\x21\x77\x33\x46\x0a\x9a\xdc\xd3\x29\xf3\xdf\x1b\xb3\x94\x18\x19\x3a\x10\xf2\x37\x2d\xc5\x0d\x35\xb3\x37\x64\x64\x41\x3c\xb2\x10\x8c\x7e\xc6\xfd\xb9\xc1\x41\xa2\xf7\x66\x61\xa7\xab\x8d\xe2\x62\xba\xe9\xf3\x09\x35\x34\x93\x53\x82\xf8\x45\x26\x52\x11\x33\x63\xc4\x7e\x8a\x4f\x38\x4b\xfd\xfc\x36\xcc\x08\xbb\x2e\xcd\xe9\xb6\xf9\xba\xf5\x94\x66\x54\x08\x96\x11\x39\x21\x65\x91\x52\xc3\x34\x31\xb2\x82\xcf\x66\xf0\xb8\xce\x4b\xb3\xb9\x58\x7a\xbf\x62\x3a\xd8\x74\xfe\x9a\x66\xc5\x8c\xbe\x76\x2f\x75\x32\x63\x39\xad\xf6\x50\x16\x4c\x9c\xdf\x5c\x7f\xff\xef\xb7\x8d\x1f\x48\x7d\x29\x31\x8a\x92\x7b\xc6\x0a\x5d\x1d\x0a\x52\x16\x76\x4d\x76\x71\x64\xbc\x20\x46\xd1\xe4\x9e\x8b\x29\x2c\x7d\x8a\xeb\xbd\xc0\x8d\xd1\xa3\xa5\x29\xcb\xf1\xdf\x58\x62\xa2\xd7\x8a\xfd\x58\x72\xc5\xd2\x78\x2a\x16\xb2\x9e\x44\x34\x5e\x5b\x38\x45\xaf\x0a\x65\xa7\x65\xa2\x73\x88\x4f\x44\xa3\x6a\xef\x1b\xcb\x3c\xb6\xb0\xc0\x76\x24\xb5\xe4\xc9\x4e\x7f\xc6\xfc\xe1\x60\xa9\x03\xa0\xdd\x4e\x33\xe3\x9a\x28\x56\x28\xa6\x99\x40\x82\x65\x5f\x53\xe1\xd6\x34\x22\xb7\x4c\xd9\x8e\xf6\xc0\x96\x59\x6a\xe9\xd8\x9c\x29\x43\x14\x4b\xe4\x54\xf0\xbf\x87\xd1\x00\x44\xf6\x33\x99\xc5\x0f\x43\xe0\xb8\x09\x9a\x91\x39\xcd\x4a\x36\x20\x54\xa4\x24\xa7\x0b\xa2\x98\x1d\x97\x94\x22\x1a\x01\x9a\xe8\x11\x79\x2f\x15\x23\x5c\x4c\xe4\x1b\x32\x33\xa6\xd0\x6f\xce\xce\xa6\xdc\x78\x0a\x9c\xc8\x3c\x2f\x05\x37\x8b\x33\x20\xa6\x7c\x5c\xda\x8d\x3b\x4b\xd9\x9c\x65\x67\x9a\x4f\x87\x54\x25\x33\x6e\x58\x62\x4a\xc5\xce\x68\xc1\x87\x30\x59\x81\x24\x32\x4f\x7f\xa1\x1c\xcd\xd6\xc7\x0d\xf0\xad\x3c\x07\xc4\x53\xbd\x8d\xb0\xb6\xc4\x8f\x70\x4d\xa8\xeb\x8e\x6b\xa9\x40\x6a\x5f\x59\xa8\x7c\xbc\xba\xbd\x23\x7e\x02\x08\x76\x84\x70\xd5\x54\x57\xc0\xb6\x80\xe2\x62\xc2\x14\xb6\x9c\x28\x99\xc3\x28\x4c\xa4\x85\xe4\xc2\xc0\x1f\x49\xc6\x99\x30\xf6\x18\xe6\xdc\x68\xc0\x39\xa6\x8d\xdd\x87\x11\xb9\x00\x06\x44\xc6\xcc\x1d\xd8\x74\x44\xae\x05\xb9\xa0\x39\xcb\x2e\xa8\x66\x8f\x0e\x6a\x0b\x51\x3d\xb4\xe0\x6b\x0f\xec\x98\x7f\x2e\x77\x58\x3a\x63\x84\x78\x06\xb7\x76\x77\xe2\x03\x7f\x5b\xb0\x24\x1c\x07\x2a\xc8\x79\x51\x64\x3c\x41\x8c\x37\x33\x6a\x48\x42\x85\x85\x17\x17\xda\xd0\x2c\x03\x76\xd2\x6a\x16\xeb\x4e\x3b\x81\xa3\xdd\x60\x0e\xfe\xf5\x12\x85\xae\xff\x10\x98\x5a\xa3\xc5\x3a\xca\x60\x1f\x47\x67\x97\x7f\xd8\x00\x72\x82\x92\xc9\x84\x4f\x57\x75\x5b\x0b\xcb\x0b\xe8\x02\x32\x0d\xe5\x42\xbb\x21\x4a\x85\xd0\xac\x38\x95\xe5\x5d\xb4\xc6\xb7\x47\x6b\x67\xb7\x12\xb2\xdb\xd6\x6c\x1f\x3a\x01\x09\x6c\xb1\xfa\xd7\xc6\x2a\xae\x27\xd5\xf4\x06\x44\xce\x99\x52\x3c\x75\xf4\xb1\x90\xe9\xb1\x06\x6a\x96\x96\x19\xd0\x7e\x29\xb4\x51\x94\xc3\xd1\x14\x3c\xb3\x2b\x19\x52\x83\xe7\x81\x69\xf2\xc0\xb3\x8c\xfc\x4a\x48\xf3\xab\x30\x12\x0c\x24\x15\x9f\xf2\x40\xfa\x34\xe1\xc2\x8f\x0f\x1c\xd1\xb1\x74\xa9\x59\x63\xc0\x11\xf9\xa4\x19\x61\x79\x61\x16\x9e\x38\x9c\xfc\xe3\x5f\xa7\x96\xb0\x32\x45\x75\x34\x70\xad\x9f\x27\x9f\x6b\xd6\xbf\x05\xbc\x6d\x40\x6c\x1f\x21\x53\x76\xbe\x05\xd4\x4b\xe0\xbe\x64\x28\x21\x68\xe8\x1e\xb6\x2a\x06\xb2\x2a\x33\xa6\x83\x94\x63\x61\xb4\x61\xf0\x16\x6b\x69\xbb\x1e\x6c\xc7\x26\x4c\x29\x96\x5e\x96\xf6\x68\xdc\x86\x59\x5d\x4f\x85\x0c\xaf\xaf\x3e\xb3\xa4\x34\x2b\xb8\xee\xc6\xa5\x5b\xb9\xc9\x2d\x93\x29\x44\x15\xfc\x1c\x88\x4e\xee\x07\xbb\x5e\x60\x9c\x16\x3c\x1a\xe9\x90\xa6\x86\xeb\xc9\x02\xc0\x11\x00\xc6\x3e\x5b\x26\x01\xb2\x6d\x74\xbe\xac\xa0\x02\xfc\x81\xb3\x2c\x1d\x90\x71\x69\x08\x37\xc0\x3c\x92\x99\xb4\xf8\x45\x11\xee\x30\xee\x9c\x4b\x60\xcd\x44\x0a\x8b\x49\x24\xb7\x1c\x00\x44\x00\x16\x0f\x3f\x82\x99\x57\xdd\xb8\x26\xb9\xd4\xa6\x82\x95\x7d\x03\x58\x2e\x18\x79\xe0\x66\x06\x7f\x4c\xad\xba\x62\xd9\xbe\x2e\x73\x3b\xe8\x03\xe3\xd3\x99\xd1\x03\xc2\x47\x6c\x04\xbb\xcb\x68\x32\x8b\x86\xcd\x19\x33\x9a\xd0\x2c\xf3\x53\x88\x51\x02\xe9\x69\x6e\x79\x22\x39\x09\x4c\xd3\x31\xb8\x41\xa0\xb7\xcd\x5d\x5b\x09\xae\x01\x61\x26\x19\x9d\x0e\x48\x22\xf3\xc2\x9e\x16\x0a\x73\x1c\x2f\x08\x37\x56\xf6\x43\x06\xad\x64\x39\xc5\x95\xb0\xcc\x7d\xd8\x4b\x47\x00\x5c\x10\x5f\xac\x36\x21\xa6\xe4\x08\x17\x77\xe4\x05\x1e\x3b\x1c\xc7\x45\xc0\xfa\x72\x6a\x92\x99\xa3\x29\x89\x54\x8a\xe9\x42\x0a\xe8\x09\xbf\x5c\x55\x73\xfb\x8f\xd0\xe9\x44\x9f\x56\xc0\x9c\xf1\xe9\xcc\xc3\x92\x2a\xa4\x29\xf5\x3d\xd8\x74\x46\xaa\x73\x42\x95\xa2\x8b\x2d\x2d\xb9\x61\xf9\x96\x53\xb2\x84\xda\xe7\xc2\x11\xa9\x0a\x27\xa2\xdd\x33\x4c\xe5\x01\x06\xb0\xc1\x70\x5c\x35\xae\x8f\xe7\x96\xed\x72\xe3\x30\x84\xbc\x22\x27\x80\x22\xdc\x1c\x6b\x40\xd7\xa1\x2c\x4e\x47\xe4\x1c\xb4\xdd\x16\x1f\x10\x32\x8c\xef\x06\xb2\x1f\xd5\xb2\x1a\x6b\xeb\xda\x5a\x12\x15\x7c\xd6\xf3\xfa\xe5\x67\xe8\xe6\xcf\xc4\x0a\x56\xbf\xaa\x39\xc2\x64\x6b\xd3\xb6\xe4\xcd\xb7\xf6\x73\x68\xd3\xba\xb9\xd5\x88\xd2\x9a\x65\x2c\x31\x96\x46\x33\x95\x0f\x08\xd5\x5a\x26\xdc\x8a\x95\x15\xd2\xd6\x31\x1d\x57\xb2\x1d\xf6\xa4\x2b\xfc\x49\xe7\xf5\xdb\xa7\x79\xf0\xda\xf6\x5b\x82\x46\xc6\xb5\xb1\x94\xa1\x0e\x95\x1a\xc1\x1a\x2f\xe0\xd7\x63\x4d\x32\x3a\x66\xd9\x5a\xbe\xbc\xfc\xb4\x3f\xb5\xd5\xd3\xf2\xfc\xae\x5d\xd0\xda\x85\x38\xa5\x26\x6c\x3c\x88\xc8\x5e\xe0\x43\x89\x63\x40\x28\xb9\x67\x0b\xd4\xed\xac\xca\xe8\x94\x69\x6c\xac\x18\xb2\x1b\x8b\x1c\xf7\x6c\x01\x8d\x36\x4b\x2a\xeb\x61\xd2\x01\x39\xf0\xe9\x72\x4c\xab\x67\x68\x27\xda\xb1\x87\x5f\x74\x87\x6e\xdd\xf1\x17\x9f\x7b\xb6\x51\xf2\x5a\xf5\x2c\x89\x24\x80\x93\xb0\x1f\xb0\x49\xc0\xbf\xfc\x1e\x53\xab\x12\x81\xad\xa3\xcb\x0e\x91\x6d\x0a\xc6\xa6\xc7\x43\x6f\xaf\x75\x7d\x0c\x1a\x34\x22\xe4\xb1\x46\xe4\xb3\x27\x7d\xc6\xc1\xae\x63\x31\x19\x0e\xae\x37\x35\x7c\x4f\x33\x9e\x46\xe6\x1f\xcb\x67\xaf\xc5\x80\x7c\x90\xc6\xfe\xef\xea\x33\xd7\x56\x7c\xb9\x94\x4c\x7f\x90\x06\xfe\x1c\x91\x6f\x0c\xe2\xfa\xbb\x96\x94\xed\x00\x00\xc2\xf9\xee\x05\x9e\x73\x81\x34\xc5\x2e\x3f\x36\x52\xe8\x91\x55\x87\x40\x94\xf3\x07\x97\x6b\x72\x2d\xac\x70\xe8\xc0\x00\x66\x23\x54\x62\x70\x88\xbc\xd4\x60\x55\x10\x52\x0c\x41\x06\x58\x39\x06\x42\xcf\x8e\x13\xc3\x6f\xc3\x70\xeb\x87\xfa\xc6\xd8\x61\xde\xad\xed\x3c\xa3\x73\x10\xe9\xb8\x98\x66\x41\x78\x1b\x90\x87\x19\x4f\x66\x28\x75\x83\x4e\x6f\x98\x2a\x14\xb3\x0c\x8b\x82\xf6\x6f\xdf\x4c\x99\xb2\xc2\x2e\xf7\xe3\xa1\x25\x2c\xa3\x09\x4b\x49\x0a\xa2\x25\x5a\x75\xa8\x61\x53\x9e\x90\x9c\xa9\x29\x23\x85\xe5\x24\xbb\xed\x7e\x37\xc2\x8e\x4f\x67\xf2\x1e\x7f\xb0\x13\xba\x01\x8b\x7c\x6b\x65\xdd\x27\xe2\x8e\x20\x57\xf7\xdc\xb1\xe7\x8e\x8d\xa7\xe7\x8e\xe1\xe9\xb9\xe3\x96\xa7\xe7\x8e\x3d\x77\x7c\x74\xee\x88\xba\xec\x0e\xca\xf3\x0f\x68\xe2\x68\x6a\xcb\xc0\x69\xfd\xbd\x50\x5d\x6d\xb6\xfc\xe6\xd6\x11\x9c\x3b\x50\xb5\x9d\xed\x58\x51\x31\x65\xe4\xf5\xf0\xf5\xab\x57\x5d\x94\x6a\xb7\x91\xad\x7a\x4c\xa4\xca\xa9\x81\x3e\xff\xfe\xeb\x8d\x3d\xd6\xd9\xdf\x0e\x60\x35\x75\x38\x1e\x0c\x79\x35\xd9\x61\x8d\xe1\x13\xa8\x93\x90\x86\xe4\xcc\x10\x6a\x6a\xa6\x22\x9e\xb3\x81\x37\x2c\x23\xc2\xbb\x6b\x31\x6f\x81\x4d\x89\x14\xce\x8e\x67\x81\x3f\xda\x6d\x06\x09\xa3\x9a\x59\x4a\x3a\x66\x61\x16\x32\xb7\x5f\xe5\xc2\xf8\xe3\x62\xa7\xc0\x3c\x54\xc8\x09\x1b\x4d\x47\x24\x2d\xa1\x1b\x15\xee\x9e\xee\x14\x67\xab\x17\xda\xb0\x1c\x2c\xb9\x52\xc1\xff\xec\xb4\x8d\x5a\xc0\x5d\xc0\x9c\x09\x53\xd2\x2c\x5b\x10\x36\xe7\x89\x09\xeb\x83\x6b\x42\x6e\xd0\xd8\xde\xce\x44\xd8\x4a\x74\x68\x2f\x2e\x0c\x97\x30\x58\x6f\xe9\xd3\x85\xdb\x2f\x8d\xdd\xe6\x4c\x36\x78\x21\xae\x64\xb4\x56\x58\x35\x76\x5c\xb4\x81\xc3\x3f\x01\xb9\xbe\xfb\xb8\xdd\xe4\x4a\x3a\x53\xb2\x0e\xd4\xab\x29\x96\x96\x59\x66\x11\x03\xad\xb0\xcb\x0b\x58\x61\x1d\xc5\x25\xd5\x90\x19\x0d\xef\x68\x62\x3e\xff\x70\x69\xa1\x62\xdb\xdc\xc9\x42\x66\x72\xba\x88\x21\x0d\x2b\x03\xdb\xad\xeb\x8b\xb7\x7a\x28\x34\x58\xf4\xfb\xd0\xd8\x9a\xde\xf2\xd7\x5b\xfe\x7a\xdd\x66\xe9\xe9\x75\x9b\xf0\xf4\xba\xcd\x96\xa7\xd7\x6d\x7a\xdd\xa6\xb7\xfc\x91\x9e\x3b\x6e\x80\x49\xcf\x1d\x49\xcf\x1d\xd7\xae\xab\xe7\x8e\x1b\xc1\xd3\x73\xc7\x9e\x3b\xae\x7a\x0a\x99\xee\xe1\xe8\x58\xc8\x74\x83\x9f\x23\x5a\x7d\x12\x39\xcc\x64\x42\x8d\x73\x04\xb7\x5d\x9c\x9d\x4f\xd3\x1c\x0d\x51\x03\xf2\x77\x29\x18\x3a\xaf\xd9\xbd\x01\x73\x92\x34\x33\xa6\x6c\xf3\x13\x7d\xba\xd1\xb1\xa9\xf7\x93\xec\xfd\x24\x5f\xbc\x9f\xe4\x8c\x6a\xdc\x57\x24\x4a\xeb\xdd\x26\xa3\x03\x79\xc7\x54\xfe\x85\x7a\x4d\x5a\x74\x71\xdb\x0d\x21\x36\xd5\x96\xe2\xca\x53\x77\x5f\xc0\xd2\x9b\xfa\x7a\x9d\xbc\x0c\x8b\xa2\x69\xca\x52\x52\x30\x35\x44\x14\x91\x64\xc2\x45\xba\x62\xad\x1e\x3e\xcf\xea\xfd\x58\x5f\xc7\x33\xba\x40\xd6\x27\xb2\x83\xcd\x35\x36\x1c\xd7\x28\xfc\x8b\x70\x88\xec\x2a\xd5\x0f\x89\x71\x46\xde\x6f\x5b\xca\xf5\xdd\x45\x73\x10\xa8\xbd\x49\x78\x77\xbd\x12\xc4\xf2\x1f\x4b\xa6\x16\x10\x63\x51\x09\xac\x21\x98\xcb\xdd\x91\x71\x4d\x12\xaa\x91\x53\x74\x55\x2d\x3b\xaa\x51\xbb\xe9\x29\xbb\x5b\xa2\x49\x13\x2e\xcd\xa1\x50\x27\xf5\x3a\x38\xc2\x6c\xa5\x12\xbe\xe2\x16\xa0\xb2\xfe\x77\x9a\xcf\xae\xa2\xdb\x4e\x82\xdb\x4a\xa4\x78\xc1\xca\x39\xd9\x5d\x41\x27\x3b\x2b\xe9\x64\x27\x45\x9d\xec\xaa\xac\x93\x3d\x14\x76\xb2\x9b\xd2\x4e\x9a\xa8\x60\x77\xc8\x49\x59\x8f\xa3\xbf\x93\x7d\x54\x54\xb2\x87\x1e\x4f\x9a\x4b\x0d\x68\xaa\x1e\x4b\xa9\x07\x5c\xaf\xe9\xf5\x4f\x0d\xac\xdd\x74\x7a\xd2\x04\x95\x8f\xba\x03\x85\xf6\x0b\xd1\xf0\x9f\x44\xdd\x26\x7b\xa9\xdc\x64\x77\xb5\x9b\xec\x8e\x19\xc0\xea\xde\xc1\x75\xea\xbe\x0c\x13\x47\x41\x16\x91\xd3\xc2\x22\xc5\x3f\x2c\x27\x80\x7d\xf9\x17\x29\x28\x57\xda\xca\x77\xce\x66\x12\xff\xe6\xb4\xf3\x78\x18\x3b\x02\xd7\xc4\x92\xea\x39\xcd\x2c\xef\x41\x3f\x0e\xa7\x17\xd9\xd1\x9b\x6c\x7a\x40\x1e\x20\xea\xd3\x52\x29\xd4\x96\xb8\x26\x47\xf7\x6c\x71\x34\x58\x42\xa4\xa3\x6b\x71\x84\x3c\x6a\x09\x75\x02\x43\x93\x22\x5b\x90\x23\xf8\xed\xe8\xd0\x9c\x7d\x07\xc6\x15\x27\xdb\xd8\x95\x2f\xec\x80\x25\xc2\xc7\x4a\x1f\x5e\xd8\x44\x2e\x82\x17\x1b\xfe\x2b\xba\x62\x30\xe0\x6a\x11\x31\x97\xe0\x35\x02\x38\x06\xef\x53\xaf\xfc\x96\xc2\xa5\x56\x00\xdd\xb5\x1a\x0c\x99\xd4\xb2\x4b\x93\xdb\x78\x29\x98\x06\xc1\x8e\x05\x13\x51\xd4\x19\xda\x8e\xd0\x1d\xa4\xe2\x76\x22\x6d\x3a\x88\x54\x3d\x40\x46\xcc\x19\x15\x9a\x1c\x79\xdb\xd3\xb1\xae\x5a\x1c\x8d\xaa\xe8\xbe\x30\x22\x04\x21\xc7\x11\x7d\xd5\x80\xbd\xa4\xdd\x4b\xda\xbd\xa4\xdd\xa1\x57\x2f\x69\xaf\x7f\x7a\x49\xbb\xc3\xd3\x4b\xda\xbd\xa4\xbd\xe9\xc3\xbd\xa4\xdd\x4b\xda\xdb\x3f\xbe\x9b\xa4\xbd\xab\x9f\x50\x2c\xf7\xba\xcb\x39\xcc\x9c\x45\x0d\x4f\x2a\x1f\x22\xdf\x0a\xff\x75\x58\x79\x3b\x96\xa5\x57\x4b\xdb\xb1\x44\xbe\xa4\x5b\x8c\xb6\x88\xd6\x41\xf8\x5e\xea\xb9\x59\xea\x7e\x59\xbe\x50\x3b\xe0\x46\x74\xa1\xb0\x23\x72\xdc\xf9\xab\x70\x97\x69\x6e\xcc\xaa\x7b\xf2\x94\x9c\xf8\x1b\x97\x53\x0b\x7c\x21\x4d\xfd\x47\x61\xf8\xb0\x6a\x11\xee\x60\xe0\x7a\xb1\x16\x6f\x53\xbb\x96\x08\xb7\xee\xe1\xa6\xb8\xda\x4f\x4b\x42\x98\xaa\xcd\x81\x6b\x97\x40\x0c\xbc\x25\x54\x29\x84\x1d\x55\x0a\x7f\x7d\x8c\x34\x07\x13\xc0\x39\xcc\x43\x61\x09\xe6\x03\x12\x53\x05\xa5\xe8\xbe\x93\x1a\xcc\xb9\xe7\x5c\xf9\xa5\x70\x37\xa2\xf6\x8d\xbf\xf5\xf5\x48\x09\x2b\xe2\xe1\xeb\x23\x72\x05\x78\x18\x0f\xcc\x35\xc0\x87\x66\x99\x7c\xe8\x42\x92\x9e\x2a\x2c\xea\xa1\x73\x58\x54\xe3\xfe\xae\x8f\x8a\xfa\x99\x44\x45\xc1\x8f\x78\x84\x0e\x1e\x1e\x45\x7e\x98\x31\xc0\x22\xc5\x00\x54\x79\x99\x19\x5e\x54\xbe\x52\x1a\x3f\x95\xa1\x94\x39\x71\x9e\x27\x75\xbc\xb4\x5f\xa3\xc9\xac\x89\x9f\x30\x1e\xf8\x56\x69\x38\xb4\xce\xbb\x83\x66\x99\x8b\x29\xf2\x22\x29\xba\xb0\xf0\xe7\xf6\x4c\xb8\xf4\x59\x11\xbd\x36\x03\x44\xe6\xc4\xd2\xc2\x6c\xe1\x32\xd5\x6d\x20\xa2\xa8\x14\xcd\x99\x67\xbd\x53\x3e\x67\xa2\xa2\xa4\x27\xfa\xf4\xd4\xf3\xf0\x83\x52\xf8\x47\xa1\xd0\x7f\x88\x28\xe9\x1f\xdb\xd0\x68\x58\x50\xa0\xd2\x15\xf8\x2a\x1a\xfd\x9c\x2e\x18\x5d\xee\xf9\xbb\xd9\x18\x76\xb8\xdf\x7f\xc2\xbb\xfd\x2f\x27\xb2\xec\x99\x2d\x8c\xcf\xe1\x5b\xff\xe2\xad\x8a\xbd\x73\x7d\xf5\xec\xeb\x5c\xff\xe8\x96\xc3\xe7\xf5\xb1\xff\x02\xac\x85\xcf\xe9\x63\xdf\x5b\x08\x37\x6e\xca\x4b\x73\x7d\xaf\x3f\x3b\x59\x04\x7b\x6b\xe0\xce\x5c\xb8\x23\xc3\xd9\xd7\x0a\xd8\x11\x23\x76\xbc\x67\xef\xef\xd8\x9f\xe6\x8e\xbd\x97\x78\x5b\x3e\xbd\xc4\xbb\x16\x28\xbd\xc4\x4b\x7a\x89\x77\xdb\xf2\x7a\x89\x77\x23\x78\x7a\x89\x77\xe3\xa6\xf4\x12\x6f\x2f\xf1\x92\x2f\x4d\xe2\xdd\x25\x4b\x57\x7f\xd7\xbd\xd7\x5d\x77\x57\x6a\xd1\x89\x46\x74\xc4\x83\xce\x77\xdb\xfd\xbd\xf6\x4b\xb9\xd7\x6e\x1d\xf0\x2f\x0c\xdf\x37\xe8\x3f\xde\xab\x75\x91\xff\x74\x2e\x79\x4a\x8a\xd2\xb8\x78\xea\x3e\xfa\xff\x10\xd1\xff\x35\xc8\xf7\x29\x00\x5a\xa5\x00\x58\x07\xb3\x3e\x0f\x40\x9f\x07\xe0\xc0\x97\xd0\x7d\x1e\x80\x3e\x0f\x40\x9f\x07\xc0\x3f\x7d\x74\x12\xe9\xa3\x93\x5a\x3d\x7d\x74\xd2\xfa\xa7\x8f\x4e\x7a\xb1\xd6\x57\xd2\x47\x27\xbd\x6c\x4b\x2c\xe9\xa3\x93\x7a\xeb\x6c\xcb\x8d\xfa\x02\xa3\x93\xfa\x3c\x00\x2f\xd5\x47\x81\xf4\x92\x76\x2f\x69\xf7\x92\x76\x2f\x69\x6f\x7e\x7a\x49\xbb\xc3\xd3\x4b\xda\xbd\xa4\xbd\xe9\xc3\xbd\xa4\xdd\x4b\xda\xdb\x3f\xde\xe7\x01\xf8\x82\x7c\x23\x48\x9f\x07\xa0\xf7\x97\xe8\xf3\x00\xfc\x7c\xf3\x00\xd4\xee\xee\x9f\x2f\x19\x40\xf7\x69\xf4\x19\x01\xfa\x8c\x00\x7d\x46\x80\x3e\x23\x80\x7f\xfa\x8c\x00\xf8\xbc\x24\x5b\x63\x1f\x1f\xb5\x16\x28\x7d\x7c\x14\xe9\xe3\xa3\xb6\x2d\xef\x0b\xb0\x1b\xf6\xf1\x51\x2f\xd0\x56\xd8\xc7\x47\xf5\x76\xc1\xe6\xe6\x7c\x21\xf1\x51\x7d\x46\x80\x97\x78\xdb\xde\x4b\xbc\x2d\x9f\x5e\xe2\x5d\x0b\x94\x5e\xe2\x25\xbd\xc4\xbb\x6d\x79\xbd\xc4\xbb\x11\x3c\xbd\xc4\xbb\x71\x53\x7a\x89\xb7\x97\x78\xc9\x97\x26\xf1\xf6\x19\x01\xfa\x8c\x00\x7d\x46\x80\x2f\xf1\x86\x7b\xeb\x4e\x33\x31\x5f\xb7\xa7\xb5\x5d\xbc\x12\xf3\xba\x9e\xc2\xc4\x9c\x2b\x29\x80\x02\xcf\xa9\xe2\x74\x9c\xc1\x49\x05\x89\xc7\xc1\xdf\xd1\x4f\xa6\x46\xe4\x82\x0a\x77\xd1\x8a\x37\x99\x6b\xe7\xbf\x1d\xf1\xb7\xa0\x7a\x73\xda\xdf\xd3\xba\xa8\x26\x56\x4e\x9d\xb8\x06\x76\xea\x94\x5c\x84\x89\xaf\xfd\x4c\x2b\x02\xde\x46\x3f\x18\x02\x72\xae\x6d\xd0\x4e\x8a\xb7\x43\x6c\x3e\x9b\x35\xb0\x7c\xa0\x79\x15\xe2\xbf\x02\x1a\x23\xf2\xde\x49\x48\x94\x5c\xfc\xef\xf5\xe5\xd5\x87\xbb\xeb\xb7\xd7\x57\x1f\x37\x23\x5d\x4b\xb2\x02\x07\xa9\xc3\x64\x8f\xbf\xf7\x7b\x04\x61\xde\x4c\x58\x0a\xfc\xcb\x93\xef\xcf\x3f\xfe\xef\x87\xf3\xf7\x57\xa7\xc0\x7e\xd9\xe7\x82\x8a\x94\xa5\xa4\xd4\x9e\x24\x14\x8a\xcd\xb9\x2c\x75\xb6\x08\xc7\x7b\x35\xd2\x36\xb1\xd5\x29\x9a\x0b\xa2\x99\x9a\xf3\x64\x35\x88\x50\x8a\xa5\x15\x02\x25\x01\xc3\x15\xd3\x32\x9b\xb3\x14\x65\x8d\x30\x69\xff\x1d\x2e\x8a\xd2\x78\x89\x18\x5c\x10\xec\xa9\x10\xc9\x8c\x8a\x29\x4b\x47\xe4\x52\x96\x76\xbc\x5f\xfe\x12\x16\xa6\x58\x5a\x26\xc8\xeb\xa8\x17\x98\x7e\x39\xf0\x94\xc4\xd2\x02\x8d\x69\x14\x74\x42\x0b\xbf\xf4\x18\x3a\x7a\x21\x0c\xfd\xfc\x06\xef\xe0\x8f\x7e\x19\xfd\x74\xe4\x53\x50\x48\xfb\x09\xa4\x47\x38\xab\x0c\xb2\x1f\x64\xe4\x28\x6e\x3d\x22\x57\xf6\x1b\x2c\x8d\xf7\x01\x5d\x28\xd8\x9c\x29\x90\xa7\xdd\x2e\x0c\x88\x62\x53\xaa\xd2\x8c\x69\x70\x1e\x78\x98\x31\x48\xe7\x81\x12\x96\x03\x18\x0b\xd2\xba\x90\x66\x44\x2e\xd9\x84\x96\x99\x01\x1a\x72\x74\x34\x3a\x3e\x18\xaa\xbd\x55\x72\x4b\xf0\x7b\x0d\xdd\x6e\x31\xa9\xc4\x44\xaa\xb5\xc7\xe3\xd8\x99\x26\x6a\x64\x4d\x5b\x4e\xe2\x34\x3d\x4f\xab\x51\xbf\x68\xb1\x92\x16\x82\x60\x7b\x75\x3e\x91\x62\xc2\xa7\xef\x69\xf1\x2d\x5b\x7c\x64\x93\x8e\xde\x10\xc8\x44\x9d\x4e\x0b\x0c\xcc\x92\x43\x1c\x70\x3b\xd3\x79\xc4\xbb\xfc\x36\x46\x93\x6e\x36\x8f\xd6\x96\x8e\xa5\x94\x16\xc8\xf4\x1d\xfb\x3e\x60\x72\x9e\xea\xd9\x4e\xd1\x57\x4e\xee\x38\x26\xed\xee\x9c\x9a\x11\x79\x2f\xc1\x25\x67\x22\xdf\x90\x99\x31\x85\x7e\x73\x76\x76\x5f\x8e\x99\x12\xcc\x30\x3d\xe2\xf2\x2c\x95\x89\x3e\x4b\xa4\x48\x58\x61\xf4\x99\x9c\x5b\xca\xc7\x1e\xce\x1e\xa4\xba\xe7\x62\x3a\xb4\x92\xce\x10\x77\x55\x9f\x81\x30\x75\xf6\x0b\x94\xd8\xef\xbe\xbb\xfc\xee\x0d\x39\x4f\x53\x97\xb1\xa7\xd4\x6c\x52\x66\x2e\x7b\xc7\x88\xd0\x82\x7f\xcf\x94\x55\xca\x06\xe4\x9e\x8b\x74\x40\x4a\x9e\xfe\xe7\xe6\xc3\xbd\x23\xc4\x64\x81\xba\xd1\x0e\x50\xbb\x05\x41\x71\x51\xa3\x53\x01\xe9\x2d\x85\xe2\x46\xc3\x9e\x7b\xc3\x81\x63\x28\x1d\x96\x31\x96\x32\x63\x54\x6c\xe9\x01\x60\xeb\x7e\x66\x8f\xab\x43\x8b\x5a\x8e\x43\x80\x42\xa6\x6f\x88\x2e\x8b\x42\x2a\xa3\x49\xce\x0c\x4d\xa9\xa1\x23\xbb\x73\x83\xfa\x9f\x20\x1c\x0f\xc8\x5f\xc3\x4b\x90\x70\xf5\x9f\x8f\x8f\xff\xf0\xed\xd5\x7f\xff\xf1\xf8\xf8\x2f\x7f\x8d\x7f\x05\xb2\x87\xa6\xae\x7a\x13\x2b\x72\x8f\xac\xb8\xfb\x01\xbe\x01\x7f\x3a\x36\x7a\x9e\x24\xb2\x14\xc6\xfd\x60\xa8\x29\xf5\x68\x26\xb5\xb9\xbe\x09\x7f\x16\x32\x6d\xfe\xa5\xb7\x70\x02\xf2\xb8\x44\x07\xc0\x79\x43\xcd\xec\xc0\xa4\xa7\x3a\x17\x3b\xa0\xab\xeb\x19\x67\x48\xca\x29\xfc\xf3\xad\x9f\xae\xe5\x40\x0f\x8a\x1b\xc3\x04\xc8\x1d\xe0\x77\x27\x27\x03\x8b\xb9\x15\x9b\x9d\xbf\xee\xa4\x8e\xb6\x3e\x8a\x01\x6a\x3b\x2c\x0e\x66\xef\x56\x86\xc8\x1c\x08\xed\xb2\x5e\x77\x7e\x73\x4d\xe6\x08\x8d\x83\x2f\xc4\x7b\x61\xbd\xdd\xfb\x4c\x86\x4c\x55\x6e\x59\x41\xd2\x7c\x83\x96\xa5\xe0\xef\x45\x32\x9e\x73\x67\x00\x76\x59\xad\x34\x39\xc1\x97\xa3\xa4\x28\x07\xae\xc1\x28\x67\xb9\x54\x8b\xf0\x27\x2b\x66\x2c\xb7\x12\xdb\x50\x1b\xa9\xe8\x94\x0d\x42\x77\xec\x16\xfe\xc2\x8e\xb5\x0f\x2c\xf7\x46\x91\x3a\x29\x95\x65\x1e\xd9\xc2\x53\x10\x96\x3e\xef\x59\xf4\x60\x3a\xf0\x51\x0c\xbb\xf1\x61\x47\x96\x1b\xb4\x45\x64\xda\x61\x55\x20\x43\xce\x65\x56\xe6\x4c\x0f\x02\x7b\x42\x69\x5d\xcc\xad\x34\xa9\x1f\x85\x11\xa6\x7c\xce\xf5\x4e\xf7\xd3\xb7\xc1\x52\x07\x26\xb2\xd2\x58\x4d\x05\x9d\xc1\xa3\x8c\x70\x52\x83\x0e\x10\x7c\x14\x6b\x24\xe5\xf5\x51\xbb\xdb\x57\x6a\x0c\x53\xe2\x0d\xf9\xff\x4e\xfe\xe7\xdf\xfe\x39\x3c\xfd\xcf\x93\x93\x3f\xbf\x1a\xfe\x3f\x7f\xf9\xb7\x93\xff\x19\xc1\x3f\x7e\x75\xfa\x9f\xa7\xff\xf4\x7f\xfc\xdb\xe9\xe9\xc9\xc9\x9f\xbf\x7d\xff\xcd\xdd\xcd\xd5\x5f\xf8\xe9\x3f\xff\x2c\xca\xfc\x1e\xff\xfa\xe7\xc9\x9f\xd9\xd5\x5f\x5a\x0e\x72\x7a\xfa\x9f\xbf\x6c\x35\x3d\x2a\x16\xdf\xb5\x38\xf0\xf8\x0c\x77\xf0\xb0\xaf\x7a\x75\x30\xd0\x7f\x1e\x56\x42\xdb\x90\x0b\x33\x94\x6a\x88\xdd\xdf\x10\xa3\xca\xed\x07\xa3\x22\x6a\xbb\xe0\xb9\x4f\x07\xf6\xa6\x22\x68\x81\x34\x1f\x1c\x91\x35\x4b\x14\x33\x87\xd2\x60\x70\x34\xcf\x3f\x1a\x26\xd9\x5e\xa9\xa9\x94\x9a\x60\x97\x04\x78\x55\x9c\x77\xa2\x64\x3e\x22\x91\x59\x68\x0e\x37\x99\xae\xdd\x3d\xdb\xa2\xe5\xfa\xa7\x57\x82\xbe\x2c\x25\xe8\x16\xf7\xf7\xd1\x35\x20\x26\xe6\x9b\xcc\x34\x4d\x9b\xee\x5b\x08\x65\x89\xcd\xd1\x5e\x80\x32\x92\x14\xb2\x28\x33\x6a\xd6\x98\xed\x56\xd8\xa6\x1d\xee\x57\xb7\x00\x76\xa3\xc1\x0e\xec\xa8\x5c\xbe\xda\x18\x4a\xce\xb3\x8c\x70\x81\x27\x01\x06\xf0\xd6\x3c\xc5\x50\x5e\x22\x14\x0d\xce\x73\x3b\x85\x07\x17\x70\x13\x19\x1a\xb9\xb6\xba\x8e\x32\x60\xf1\x87\x80\x1c\xa4\x59\xce\x34\xc6\x45\x15\x96\x13\xb8\x6d\xb8\xa5\x5c\x99\x7f\x31\xa3\xda\xf8\x69\xc3\x6c\x0c\xbd\x07\x53\x68\xc2\x52\x26\x12\x06\x2e\x08\x25\xab\xd6\x3a\xb6\xc2\x20\x98\xf7\x61\x0c\x4a\xd2\xb2\xc8\x78\x62\xe1\x67\x67\xb2\x7a\x8c\xeb\x3c\x2f\x0d\x18\x8a\x9f\xca\x8a\x6f\x77\xfc\xd6\xa7\x7b\x0d\xc6\x7c\x20\x55\x41\xb4\x0e\xde\x16\x41\x75\xd7\xfb\x99\xef\xdb\x11\xde\x60\x6e\xdb\xca\xa9\x96\x28\x6e\x65\x63\xa8\x53\xda\xa7\xb6\x18\xb6\xa3\xb3\x3f\x49\x1a\xdb\x81\xbe\xb6\xa7\xad\x1d\x8c\x4b\x5d\xe9\x69\x5b\x6b\x52\xa1\xd8\x84\x7f\xee\x80\x8f\xe7\xa2\x52\x51\x78\xca\x84\xb1\x8a\x00\x64\xa6\x2e\x14\x2b\x98\x48\x43\xb8\x1f\x38\x78\x89\xfa\x3a\x1e\xf5\xc6\x08\xa5\x8c\xee\xc7\xeb\x76\x95\x14\xd3\x9f\xad\x9f\xf8\xd9\x72\xbb\x7e\xf8\x83\x25\x64\xba\xd5\xf9\xbb\xb1\x8f\x51\x8f\x86\xa7\xab\x4b\xff\xed\x26\x69\xb5\xb7\x70\xe5\x54\xc8\x14\x73\x5c\x9b\xca\x09\x61\x44\x6e\x57\xf4\x04\x5f\x03\xd7\xe2\xf8\x58\xa3\x5b\x82\x6e\x0e\xd4\x88\x6e\x46\xcf\x04\x1c\xb4\x23\x4a\x21\xab\x2b\x15\x58\x7e\xcf\xa8\xd6\x7c\x2a\x86\x85\x4c\x21\x2f\xf7\xd9\x3a\x84\x68\x71\xa8\xba\x79\x36\x6d\xc5\xab\x60\x9c\x68\xb7\x4d\x1f\x83\xfd\x2d\x92\x2d\x7c\x46\x78\x15\xfd\xe8\xec\x3a\xde\x8f\x3e\x92\x21\x2b\x89\x68\x3f\x98\xe6\x54\xd0\x29\x1b\xba\x8f\x0f\xc3\xc7\x87\xe1\x5b\xfb\x80\xb9\x0d\xd5\x42\x93\x62\xeb\xb2\x10\xc7\xef\xd0\x64\x99\x86\xf2\x10\xe8\xbf\xf7\x99\xe7\x65\x4e\x68\x2e\x4b\x74\xd1\x5b\x06\xa7\x77\x64\x39\x08\xc0\x56\x00\x4a\xaf\x85\x54\x4b\x68\x91\x9d\x5c\xee\x5e\xa8\x65\xab\x95\x45\xab\x9b\x25\xab\x83\x05\x6b\x67\xcb\x95\x37\x52\xb7\xc7\xc7\x8f\xde\x6e\xde\xc0\x48\x2e\xb6\x62\xa4\x0a\xf9\xee\xaf\x27\x24\x8c\xc3\x35\x91\x39\x37\xc6\x19\x74\x69\x75\xec\x07\x84\x9b\x9a\xf5\xd3\x9d\x05\xa8\xf7\x80\x25\x32\xd8\x67\xab\x4d\x71\xb0\xa2\xfb\x5b\x8b\x01\x72\xd9\x07\x8e\xd9\x21\xa8\x20\x3c\x2f\xd0\x99\x15\x70\x7a\xe8\x75\x33\xe7\x64\xd0\x9f\x8f\xfe\x7c\xac\xea\xa4\xbb\xc8\x22\xb1\x18\x52\x79\x30\x06\x71\xc4\x62\xb6\x2f\x3c\x03\x1e\x9a\x88\x43\xf6\x2c\x80\x13\x3d\x17\x53\xf2\x91\x81\x65\xe0\x96\x19\xed\x7c\x22\xa1\x07\x55\x6c\x39\xc4\xcc\x5b\x42\x82\xab\x2d\x9d\x4c\xea\x2d\x52\x56\x64\x72\x91\x83\x64\x7b\x6d\x62\x79\x26\x88\x2e\x2c\x2f\x32\x6a\x58\x10\x6c\x36\x5b\x1b\xf6\xe6\x7c\x5d\xe2\xbb\x9e\x37\xa2\xab\x9d\x77\x70\x0b\x9f\xe0\x97\x1f\xa7\xd5\x5a\x23\x6b\x6b\x77\x6f\x63\x73\x6f\x19\x6f\xd5\x5e\x09\x6c\x65\x94\x7f\xec\x28\xaa\x4e\xea\x58\xdb\x48\xa9\x97\x1f\x1b\xd5\x61\xd9\x6d\xe3\x9f\xfa\x88\xa7\x4d\xa0\x6e\x17\xb5\xd0\x3a\x62\xa1\xd5\xfe\xb5\x8c\x5c\xea\x63\x95\x3a\xf0\x97\x47\x10\xfe\xb6\xee\xa5\x91\x19\x43\xc9\xb5\x9d\xee\x7e\x57\xb5\x0f\xf5\xcf\xf0\x7a\x37\x1a\xe9\x69\x6e\x29\xee\xbc\xd8\x62\xcf\x56\x35\x2f\x40\x2d\x63\x28\x14\x3b\x33\xd2\xcf\xcb\x6e\x9c\x58\x10\xbb\x67\xc6\x55\xbe\x8b\x4a\xc1\x19\x05\x97\x3e\x7f\x08\xd8\x36\x60\x20\x3f\xfd\x31\xf2\x6f\x0f\xf1\x2f\x01\x43\xfe\xe0\xff\xf5\xc7\x3d\xe3\x16\xda\x31\x36\x9c\x52\x07\x01\xe3\x0a\x3a\x10\x2e\x52\xb8\x60\x72\x4b\x05\x08\xe0\x58\x16\x3e\xb0\x2c\x1f\xff\x82\x81\x54\xce\xcc\x05\x37\x51\x55\x63\xed\xae\xcc\x22\xbd\xca\x99\x14\xaa\x93\xc1\xc8\x07\xe9\x92\x12\xb2\x01\xb9\x01\x5b\x6a\xf5\x06\x4e\xd2\x07\x89\xe9\x09\xd7\xde\x65\xc5\x70\xdb\xca\x45\xb6\x32\xfa\x1a\x40\xbe\xad\x98\x3c\xae\xac\xc6\xe4\x2b\x0c\xae\x45\xc2\x6d\x82\xcc\x3d\x5b\x54\xcc\xc6\x89\x10\x40\xf2\x07\x15\x96\x78\x56\x80\xbc\xe3\x3f\xbc\x29\x2b\x1f\x73\x81\x1f\xc3\xa1\xfd\x56\xc0\xe8\x1e\xa0\x56\xb2\xcb\x32\xfc\xcc\x21\xc0\xd5\x4e\xce\xa8\xc1\xec\xbb\x0e\x32\x46\xa0\x92\xab\xa5\x8b\x48\xa4\xb8\xfa\xb1\xa4\x59\x3d\x08\xc1\xbd\x72\x8d\x96\xa8\xfa\x03\xcf\xd2\x84\x2a\xe7\xe5\x05\x67\x94\x68\x89\xbb\x87\x59\xf1\x12\x2a\xc2\x69\xaf\xf6\x08\xeb\x20\x92\x82\x2a\xc3\x93\x32\xa3\x8a\xd8\xb3\x30\x95\xaa\x55\xa0\xc0\x56\x88\x56\x48\x73\xcb\x12\x29\xd2\x2e\x0a\xc0\x5d\xb3\x6f\xf3\xae\xb5\x60\x8a\xbb\x74\x7f\x3c\x67\x4d\x24\x3d\xa9\xdb\xb4\xe5\xc4\x9f\xea\x70\xc4\x6a\x96\x8f\x2a\x26\x93\x6b\xc2\x31\x5f\xe8\x69\x44\x1e\xc3\xa9\x18\x91\xaf\x17\xde\xcc\x02\x26\x17\x17\x5d\xa1\x99\xf1\x81\x30\x1e\x65\x1d\xb0\xab\x03\x35\x91\x0a\x82\x53\x4e\x52\x89\x11\x19\x73\x9e\x98\xd3\x11\xf9\x7f\x99\x92\x18\xc1\xc9\xa6\x98\xbd\xd1\xa1\x78\x50\x5c\xa1\x70\x29\xdc\xe0\xbf\x22\x27\x98\x49\x93\xe7\x39\x4b\x39\x35\x2c\x5b\x9c\xa2\x1e\xeb\x73\x71\xb6\xd9\xba\x36\x46\x83\x28\xf1\xea\x6f\x7f\xb3\xa1\x65\xd7\x18\xaa\xef\x7d\x54\x4a\x05\x19\xf4\x21\x68\x6c\x61\xe0\x41\x72\x83\xb8\x19\xfb\x20\x54\x41\x9d\x9e\xcc\x84\x0d\xfe\x9b\xc5\x03\x4a\x14\x9b\x02\x96\x23\xe6\xee\x89\xe3\xe8\x4d\xf9\x5e\x96\x62\xbd\x49\xb0\xb6\xf0\x77\x4e\x09\xff\x3e\xea\xb8\x36\x4a\xf1\x49\xc4\x84\x68\x26\x91\x89\x92\x12\xb0\x4b\x02\x3b\xb7\xe4\x01\x5b\x55\x9e\x28\x5b\x27\x79\xd0\x88\x44\x98\xcb\x16\xaf\xf7\x83\xc4\x2d\x86\x0f\x75\xc0\x65\x70\x10\x77\x80\x69\xc4\xed\x19\x47\x0e\x00\x3f\x11\x82\x15\x82\xc2\xb7\x58\xea\xbd\xd8\x30\xd6\x18\xba\x92\xe3\x37\xc7\x07\x21\xbe\xb8\x1c\x25\x0b\x3a\xa5\xdb\xf3\x1d\xd7\x95\x91\x46\x57\x92\x32\xc3\x54\x0e\x89\x69\x67\xf2\x01\x7f\x47\xb6\x55\xb8\x56\xcc\xe5\xf4\xb5\xab\x9d\x49\x0d\x5c\xa9\x1e\xc4\x08\xe7\x17\x2e\x46\x1f\xe8\x82\x50\x25\x4b\x91\x3a\xa9\x29\x10\xd0\xf7\x8d\x0f\x7f\x90\x02\x28\x45\xa9\x2d\xac\xee\x6a\x54\x7a\xcc\x0c\xb5\xc7\xe6\xf5\xe8\xf5\x96\xdc\xd3\x2d\x01\xd6\x31\x6e\x15\x66\xd3\xb0\x14\xfa\xbb\x72\x7f\x66\x0e\x32\x2f\xc5\x68\xfa\x9d\xc8\xba\xc8\x72\xef\x11\xbd\xa0\xeb\x10\x94\x30\x3e\x01\xdb\xed\x00\x5f\x3d\x28\x6e\x58\x44\x1e\x4f\x26\x34\xd3\x50\x70\xbb\x14\x41\x84\x3d\xad\x8b\x20\xd0\xa4\xcd\x82\xb6\xfb\x83\xe8\x72\xbc\xe7\x39\x73\x07\x0a\x50\xae\x3a\x66\x01\xe1\x8e\xf5\x86\x23\x57\x0f\xee\x24\x27\xd8\xd2\x4a\x6c\x52\x9a\x8d\xe5\xdd\xdb\x3b\x89\xe0\x02\xad\x66\xdd\x45\x25\xf1\x71\xc3\xc5\x01\x57\xfb\x35\x9b\xd1\x39\xd3\x44\xf3\x9c\x67\x54\x65\x10\x2b\x78\x8b\xf3\x83\x62\xec\x2b\x23\xd0\xbb\x45\x37\xc7\x33\x89\x86\xdb\x0a\x6a\x3f\x0f\x0b\x27\xa0\x11\x7e\x5e\x98\x04\xdc\x67\x0e\xff\x9c\x64\xa5\xe6\xf3\x7d\x4f\x93\x8b\x7e\xd8\x81\x55\x37\xb9\x74\x21\xd3\xdb\x82\x25\x4f\xc9\xa3\xeb\x1a\x86\x25\x55\xa9\xdf\x74\xe0\xc9\xa8\xec\x53\x2c\xac\x3f\x66\x84\x26\x09\xd3\xda\xfb\x54\x2e\x62\x3f\xcf\xb0\x86\x2f\x25\xa1\x00\x7d\xd0\x57\x19\xd5\x86\x27\x5f\x67\x32\xb9\xbf\x35\x52\x75\x8a\xd9\x5f\xd5\xbf\x91\x86\xe1\xfc\x87\x5b\x72\xc9\xf5\x7d\x14\x4d\xe0\x2e\x4d\x63\x73\x09\x25\xf7\xe5\x98\x65\xcc\x1c\x1f\x6b\xe4\x72\x39\x4d\x66\x5c\x30\xcf\xe0\x44\x08\x49\x71\x0a\x9f\x85\x72\xd7\x3b\x53\x17\xf8\x74\xe6\xf0\xf5\x17\xf4\x41\x33\x9c\xfe\xd8\x4e\xdf\xfe\xcc\xda\x44\xa4\x1f\xf4\x9e\x02\x27\x73\x7d\x79\xa0\x3b\x88\x89\xbe\xb3\x73\xec\x66\xdc\x3e\xc6\x5e\x5e\x75\x98\xf0\x8c\xb9\xea\x03\x76\xc1\xde\x47\xcd\x9d\x0a\xd8\xbf\x85\x2c\xc9\x03\x45\x1d\x19\x28\xe2\x88\xdc\xf1\xe2\x0d\xb9\x12\xba\x54\xac\xb2\x6e\x34\x87\xe2\xba\x8a\x33\xf3\xca\x15\xec\x37\x2a\x20\x96\xee\x39\x5d\x8b\x5c\x7d\xa6\x79\x91\x31\xfd\x86\x1c\xb1\xcf\xe6\x37\x47\x03\x72\xf4\x79\xa2\xed\xff\x84\x99\xe8\xa3\x11\xb9\xce\xc3\xad\x3b\x17\x13\xa6\x14\xf3\x8e\x50\xd8\xc1\xb2\xe6\x88\xeb\x3e\x0a\xba\x38\xa7\x3a\x2b\xbb\xa5\x92\x3c\x60\x3e\x0a\x4b\xf0\x99\x52\x52\x05\x3f\xf4\x08\x0c\xc0\x6b\x12\x99\x17\x4a\xe6\x3c\x32\xf3\x01\xba\x1f\xd4\xdb\x0e\x8c\x0f\x6d\x0a\x72\x34\xb1\x21\x74\xf4\x08\x11\xbd\x10\x6d\x50\xe1\x7a\xe2\x9d\x29\x50\x8b\x74\x6a\x3d\x0c\xe7\x1a\xd9\xcd\x77\xa3\x58\x42\x16\x6f\xf7\xdb\x10\x50\x47\xce\x52\x36\x3f\xd3\x29\x7d\x3d\x80\xcf\x68\xe7\x08\x58\x9f\x13\xd5\xe4\xe8\xf5\xd1\x88\xdc\x7a\x46\x3c\x88\xe7\x58\xb5\x9b\x48\x15\x06\x04\x3b\xfb\xab\x23\x72\x22\x15\x8c\x9c\x50\x41\x32\x46\xe7\xce\xb6\x8c\xc7\x6d\x81\xea\xee\x69\xeb\x80\xc8\xb6\xb1\x61\xed\x2b\xaf\xb4\x15\x52\x97\x37\xd1\xf7\xf3\x26\x00\x55\xba\x58\x81\x89\x54\x2e\x0f\x48\x68\xa2\x99\x81\xa3\xc7\x45\x4d\x85\x7e\x06\x02\x4b\x3a\x86\xd2\x7b\xea\xd9\x15\x3a\xbe\x1f\xe8\x40\x82\xff\x58\x32\x72\x7d\x19\x02\xea\x99\xd2\x5c\x1b\x7b\x8c\xd3\x1a\xeb\xe2\xc8\xcf\x4e\xce\x73\xfa\x77\x29\xc8\xd5\xd7\xb7\x6e\x02\xa7\xcf\x0a\xaa\xad\xd4\x80\xfe\xbd\x54\xcc\x72\xe1\x0e\xcc\x3d\xf4\x69\x32\x74\xfb\x9e\x5c\x52\x43\x91\xaf\x3b\x4f\x2b\x51\x91\x72\xcb\xb2\xc7\x5c\xa4\xee\xa7\x88\x61\x3f\x35\x6f\xb5\xbb\xf7\x61\x93\x98\x14\x37\xfc\xf4\xf1\xfa\x40\x3c\x38\x01\x62\x3e\x7d\x2f\xd3\xce\x8c\x38\xea\xea\x89\xef\x9f\x2c\x4c\x2f\xf0\x3d\xc9\xed\x98\xc4\x6a\xef\x03\xf2\x91\xd1\x94\xd8\xf3\xeb\xfe\xf9\x83\xd5\x3d\x5b\xd3\xaa\x56\x2c\xc4\x03\xb0\xe3\x32\x7c\x37\xbf\x84\xd8\xd3\x3d\xb5\x98\x03\xc7\xca\xf1\x92\x71\x26\xc7\xc4\x1d\x87\x43\xcf\xfd\xd3\xc7\xeb\x1d\xa6\xfe\xe9\xe3\xb5\x9f\xb9\xfd\xa7\x9c\x3c\xdd\xa4\x77\x12\xdf\x2a\xe9\xed\x6d\x43\xdc\xaa\x58\x72\x15\xb8\xd1\x14\xc9\xda\xcb\x63\xa3\x43\x49\x62\x87\x84\xd8\x3d\x17\x2d\xa2\x70\xeb\xa7\xcc\xf6\xb1\x0a\x05\xfa\xaa\x45\xf7\x88\xb7\x33\x0a\xa1\xcf\x21\x20\x0f\xf6\xd9\x6e\xbc\xb6\x5c\xc1\xef\xb8\x55\x02\x81\xb6\x91\x4b\x86\xb7\x9c\xe9\x1b\xef\x3b\x10\x7a\xac\xee\xf0\x1e\x3c\x35\x53\x47\x5f\x09\x3a\x6e\xa6\x11\x82\x9d\xa0\x55\x49\x84\x9f\xe8\x9c\xf2\x8c\x8e\x79\xc6\x21\x95\xba\xd5\xee\x63\x6f\x54\x0d\x53\x3e\xe8\xa9\xdf\x51\xe4\x08\xe2\xc4\x92\x71\x8b\x9c\xd8\xdf\xce\xc0\x38\x76\x3a\x02\x6a\x05\x0d\x21\x47\x63\x43\x28\xf9\xb8\x4d\x28\x39\x98\xfc\x00\x3b\x60\x4f\x4c\x57\xae\x68\xfb\xac\xe4\x8a\xf0\xc3\xad\xcb\x27\xf7\x92\x19\x23\xc6\x5a\xb5\x62\x8d\x80\x5f\x5b\x5b\xb6\x67\x8e\xfb\x22\x57\xfa\x65\x20\x17\x09\x11\x6d\x3b\xf0\xcf\xaa\xa3\xe7\x43\xa0\x24\x81\xc7\x99\x8b\x76\xab\xb9\x66\x22\xf6\xdd\x3a\x5a\xe3\x52\x30\x21\xd7\xb5\x38\xd7\xa6\x2e\x5a\x97\xa4\x0d\x1e\x23\xba\xae\xca\xf7\xf3\x8b\x42\x12\x08\xaf\x49\x0b\x5c\x6c\x3d\xc9\x84\x15\xb3\x49\x97\x2b\x71\xdb\xe1\xed\x6d\xdd\x12\x78\xc1\x8a\x19\x79\x7b\xbb\xe2\x18\x03\xec\x61\xd6\x1a\xed\x83\xc7\x9a\x64\x7c\xc2\x0c\xdf\xb2\x84\x47\x38\xc8\xb9\x14\xdc\x48\xb5\x3e\x04\x9a\x74\x3a\x9c\x7e\xb8\xae\x0c\xd5\xf7\xb3\x3b\x5b\x25\x10\x79\x1f\xbd\xa5\x24\x91\x59\xc6\x12\xe3\x52\x5a\x01\x78\x43\xb7\x15\xca\x13\x73\xf6\x80\xd1\xfd\xef\x41\x7d\x72\x8a\xd2\x19\x6e\xee\xd9\xc7\xab\xf3\xcb\xf7\x57\xa3\x3c\xfd\xc5\x4c\x3e\x0c\x8d\x1c\x96\x9a\x0d\x79\x8b\x0c\x25\xcf\xe7\xbd\x88\x4f\xd1\x2a\x61\x56\xd3\x20\x83\xb9\xbe\xbe\xf3\xf1\x93\xe4\x93\x46\xaf\x05\xb0\x1d\xf9\x3b\x29\x29\xcd\x80\x28\xea\x62\x24\xa9\x33\x3d\x95\x59\x86\xd0\x36\x8a\xb1\x41\x6c\x8b\xd9\x18\x1a\xd2\x79\x61\x7b\x1b\x2a\x6a\x0b\x7c\x5c\x19\xe2\xe9\x11\xae\x0b\xc7\xd8\x2e\x93\x2c\x43\xb1\xea\x59\x87\xe3\x6d\xed\x3d\x1a\xce\xcc\xcc\x42\xf5\x9e\x2d\x08\x38\x02\x4f\xa4\xb2\xf8\xa4\xea\xb8\xc1\x4c\x02\x4b\x3f\x2b\x35\x53\x23\xc7\x76\x9e\x1c\x6c\x1d\xb2\x08\xed\x90\xbc\x2d\x74\x5c\x05\x33\xf7\xba\xca\xec\xeb\xe4\x35\x5a\x9a\x19\x13\xc6\x8a\xfd\x96\x96\x39\xc8\xac\x04\xa2\xf3\xc3\x7e\x72\xa8\xb5\x4c\x62\xd4\x2d\xe5\x50\x9f\xa6\xa7\x0b\x4e\xda\x53\xd3\x15\x1d\x6d\x1f\x08\x44\x8c\xc9\x7c\x88\xe5\x52\x34\x95\xe0\xb0\x81\x19\xe8\x6a\x88\x46\xd3\x9c\x8b\x17\x78\x3a\x13\x2e\xd2\x6d\x70\x68\x18\xc0\xa0\x47\x5d\x14\x73\xef\x9c\x41\x3f\xdc\x1b\x52\xaf\x49\x61\xc0\xbb\xbb\x41\xac\xdf\x1f\xb6\x3a\x7c\xf9\x42\xff\x98\x0d\xf1\x2b\xc3\x22\xad\xa0\xd2\x5f\x06\x2e\xdf\xe0\x1d\xd6\xa4\xf4\x04\x57\x7c\x07\xda\x6d\xf2\xc4\xd2\xd0\xe3\xea\xb9\x4f\x02\xa8\x2e\x32\xcf\xbe\xdc\xbb\xa2\x99\x50\x78\x5f\xfb\xe0\x33\xcc\x6c\x06\x67\xd4\xeb\xcb\x50\x90\x9f\x2a\x9a\x33\xc3\x14\xba\xc0\x39\xa7\x3a\xe1\xa2\x13\xbe\x2b\x98\xb8\x35\x34\xb9\x3f\x74\x2a\xd4\x9e\xe3\x3e\x1e\xc7\xdd\xfb\x2a\xd0\x23\x82\xcb\x8b\xb4\x88\x6f\x91\xb9\x70\x5c\xe8\x85\x90\x98\x90\x8e\xac\x8b\x95\x23\xa4\xa3\xaa\x73\xd7\x2a\x3d\x19\x1a\x36\xc0\xd3\x2d\xe4\xd7\x03\x0f\x7e\x84\xc2\x61\xb8\x61\xfb\x33\xe0\x48\xe0\x2e\xf7\x68\x51\xd7\x3a\x75\xc8\xed\x9b\x31\x37\xd5\xb9\xd7\xcc\x90\x82\xa9\x9c\xbb\xb0\x6e\x29\x48\xe2\xc2\x02\x80\xaf\x59\x1e\xe6\x86\x8b\x78\x9e\x20\x32\x31\xd4\xc5\xcc\x90\x31\x33\x0f\x8c\x09\xf2\xea\xd5\xab\x57\x20\x97\xbc\xfa\xdd\xef\x7e\x47\x20\x8f\x44\xca\x12\x9e\x2f\x37\x84\x56\xff\xe7\xf5\xeb\x11\xf9\xef\xf3\xf7\xef\xc0\xab\xac\x30\x9a\x8c\xa5\x99\xb9\x91\x6d\x83\x5a\x67\x3d\x20\xff\xf7\xf6\xbb\x0f\x5e\x9c\xd0\x8d\x5f\x41\x05\x09\xcb\xab\xbb\x08\xbe\xfa\xed\x6f\x7e\x33\x22\x97\x5c\x41\x3c\x31\x87\x08\x88\xe0\x04\x59\x78\xc7\x40\x28\x3c\xd4\x8c\xe0\x77\x1c\xc4\x39\x09\xe7\x7c\x3a\x03\x00\xd8\x03\x21\xc5\x24\xe3\x89\xc1\x9c\x82\x78\xf4\x11\xd0\xae\x2e\x12\x75\xe1\x5e\x4e\x8a\x80\xc9\x0d\x48\xc6\xef\x19\x99\xe8\x6f\x94\x2c\x8b\x2a\xcc\x51\x31\x6d\x65\xd9\x84\x0a\x88\x2a\x81\xc1\xaa\xbd\xd2\xcc\x3c\xab\x13\x46\x4b\x43\x50\x0d\x07\xa1\x4f\x43\x40\x19\x84\xdc\x6a\x43\xc4\x87\x82\xf2\xe0\x38\x08\x77\xea\xb5\xcc\xfe\x41\xf7\x4c\xa3\x5c\x72\x3e\x76\xa5\x50\xf2\x6f\xb8\x55\x5c\xf8\x28\x28\x27\x21\x6b\x27\x93\xb9\xa0\x53\x11\xd9\x5c\x7d\x54\xbe\xe5\x85\x2e\xe2\x3f\x8a\x9f\xba\x9e\xc4\x81\x76\x10\x96\x8e\xe5\xd5\x6a\x89\x2f\x57\x7c\xb9\x4a\xd6\x6e\xb1\x49\xe3\xbe\x96\x62\xa9\xb7\xab\xa3\xe2\xc8\x8f\xab\xae\xe3\x42\xd8\xaa\x31\xd0\x15\xd7\x05\x00\x45\x35\x9b\x6a\xc9\xe8\x6a\x5e\x3e\x9a\x99\xd2\x81\x06\x3c\xaf\xec\xb7\x99\xd6\x2e\x8e\x28\xa7\xea\xde\x2a\x09\x8e\x0a\x8c\xc0\xeb\x59\x87\x18\x26\x0c\x28\x9b\xa3\xb1\x3c\xa7\x8b\x5a\xd4\x80\xfd\xc8\xf1\x68\x74\x8c\xc7\x44\x2a\xcc\xe5\x89\x38\x6f\xdf\x3f\x53\xbc\x74\xdd\x2b\x9d\x16\x58\x76\x0f\xec\x39\xae\x6c\x09\xad\x79\x3b\x53\x07\xa9\x36\x19\x7c\x3b\x96\x2d\xec\x56\x1f\xb7\x7d\x5d\xdc\x21\x2c\xa0\x45\xd3\xae\x35\x70\x3b\xd4\xbe\x5d\x97\xad\xc1\xc1\xd8\x9d\x84\xb6\x15\x21\x3b\xe7\x02\xcf\x5b\xb1\xbe\x15\x53\x3d\xce\x1d\xe7\xfb\xae\x1b\xe7\x73\xf1\x7a\xb5\xe2\x60\x2f\x9f\xd5\x5d\x4f\x30\xd2\xa5\x4e\xba\x1c\x69\x88\x45\x81\x50\x88\xab\x0a\x7b\x79\xd1\x1c\x2d\x46\x9b\x6e\x89\xe7\xbb\x70\x37\x7c\xda\x5d\x4c\xe0\x53\xc3\x35\x7f\x3b\x81\x8b\x76\xa4\xb4\xa8\x15\xf8\xc8\xd0\x6e\x00\x32\xa6\x3f\x3c\x23\xf2\xde\x91\x5a\x44\x32\x3a\xd6\x32\x2b\x0d\x76\xad\x7e\x8c\xe9\x30\x0c\xea\xb3\x2c\x00\xf1\x0d\xcd\x22\xaa\x6c\xaa\x12\x67\xed\x08\x34\x3e\x1d\x0e\x67\x9f\xed\xf3\x11\xb3\x7d\x86\xfc\xb4\xba\x65\xbd\x26\xfd\x68\xe9\x75\x13\xcd\xbb\xe8\x57\x9a\x93\x93\xaa\x4c\x88\xbf\x8e\xbf\x16\x86\xa9\x09\x4d\xd8\x69\xac\x77\x85\x72\x2c\xc1\x45\xc8\xc7\x45\xcc\xa8\x48\x33\x14\xc0\x13\xa6\x00\xf7\xd9\x67\xc3\x94\x05\xc9\xc5\xed\x35\x49\x15\x9f\x33\xa5\xc9\xc9\xd7\xcc\xca\x8b\x8c\x9a\x52\xb1\x56\xd1\x55\x87\xf5\xad\x84\x69\x1c\x4a\xd3\x83\xc1\xba\xba\xea\x41\x27\x4f\x79\x44\x74\xbe\x2a\x30\x21\x54\x11\xa4\x3a\xd6\x65\x47\x16\x95\x80\x40\x03\xcd\x58\xc8\x52\x39\x2b\xba\xcf\xab\x9a\x48\x65\xd5\x25\x1c\x98\x6a\xa2\xd8\xd4\x4a\xb3\xca\x17\x1b\x66\x24\xc9\x4a\xfb\xe2\xa0\xee\x6c\xfb\x38\x00\x56\xa6\xd9\x4d\xbe\x7a\x13\x27\x55\xcb\x39\x4f\x3d\xab\xc4\xda\xc7\xa1\xaa\x61\x41\x75\x14\x6a\x13\x65\xa0\x8f\x00\x8b\x32\x3a\x30\xd4\x10\xc4\x5a\x73\xf6\x8f\x8d\xc2\x12\x72\x5b\xb4\x28\x1f\xd1\x85\x08\xcb\x94\xdd\x94\xe3\x8c\xeb\xd9\xed\x8e\x26\xc4\x55\x43\xa0\xb3\xc2\xd2\xad\xdf\x5a\x4b\xa2\x66\x42\x73\x60\x79\x96\x8c\x5b\xa6\xcb\xad\x1c\x25\x01\x88\xbe\x77\x8c\x90\x12\xa2\x3f\x32\xe6\x32\x18\xd8\x9f\x3e\x54\xf3\x70\x41\x69\x98\xb3\x24\x65\x9f\x44\x51\x7b\x9f\xd0\x2c\xd3\xcd\x80\x5d\x4f\x31\x51\xf6\xf0\x81\x6a\xb8\xa7\xdc\x6e\x77\xa8\x8c\xd2\xc8\x7e\xb9\x76\x61\x9a\xe4\x12\xc3\x78\x04\x91\xc2\x37\x82\xd4\x2b\xbe\x43\x14\xc8\x08\xe1\xca\x80\x32\x07\x2e\x1d\xd9\x9b\x4b\x1f\xcf\x5c\xba\xaf\x1f\x5e\x5c\xef\xbd\x8a\x86\xae\xa5\x25\x0d\xa4\xd4\x93\xdc\x2d\x4e\x1d\x07\xbd\x56\xc0\x6f\x9e\x1b\xa3\xf8\xb8\x34\xdd\xf3\xbd\x35\xba\x03\x9b\xb6\x8a\x08\x9c\xe2\xa1\x5b\x7d\x12\xa1\xa8\xd3\x10\xc2\x59\x58\x3e\xfb\x15\xcf\x01\x76\x83\x2f\x8f\x35\x49\x65\x52\x86\xbc\xb0\x00\xb4\xea\x02\xad\x4d\xf6\x44\xd2\xf5\x5c\x75\x4f\xe9\x15\x7f\x64\x2b\x7a\xa5\xf2\x41\x3c\x50\x95\x9e\xdf\x6c\xf1\xbe\xaf\xb3\xf3\xaa\x57\x2c\x28\xf9\xd7\x50\x05\x90\x8e\x65\x69\xaa\xd4\xa1\x3f\x1d\x7b\xf5\x2a\x35\xdd\x48\x4b\x1a\x5a\xda\xa3\xbb\x2a\xfa\xbd\x89\xbb\x37\x71\xd7\x9e\x5d\x4c\xdc\xd7\x68\xe2\x8e\xf3\xe0\xd6\x8e\xab\x4f\xaf\xc0\xb3\xb6\xbe\xbd\x8f\x69\x25\xbd\xac\x08\x0c\x4a\x53\x4d\x3f\xfe\x86\x00\x87\x47\xa4\xda\xdb\x48\xe8\xf3\x14\x08\x78\xf6\xf3\x5b\x54\x1f\xc9\x4e\xda\xbe\x4e\x31\x3e\xeb\x0a\x09\x6e\xaa\x5b\x0c\x52\x43\x54\x68\x78\xe0\xb2\x40\x0f\x9c\xde\x25\xd2\xaa\x84\x1f\x26\xa1\xee\x50\xa6\x14\x9f\x8e\xc0\x27\x9d\x37\x80\x74\x2c\x22\x8c\x4f\xd7\xdd\x20\x3b\x14\x14\xc6\xe7\x99\xcb\x0a\xe3\xd3\xd9\xf6\x4d\xba\x97\x18\x5e\xb1\xdc\xc7\x2d\x34\xbc\xe3\xd2\x76\x37\xeb\xef\x6a\xce\x1f\x54\xe5\xed\x5e\x3e\x5b\xef\xcd\xf9\x4b\xcf\x13\x9a\xf3\x23\xc2\xed\x89\xc1\x0a\xd3\x7e\x6c\x6e\xf3\xf6\xfd\x31\xf3\x62\xe5\xa8\xca\xbe\x66\x51\xce\x5b\xf6\xa5\xaa\x5f\xab\x1e\x8f\x46\xc7\xc7\xde\xde\xef\xf0\xb3\x34\x93\xe1\xef\x09\x13\x89\x4c\x71\x53\xed\xf8\x4a\x1b\x60\xfa\x95\x9a\x1e\xcf\x25\xf7\xdf\x8a\xaf\x66\x61\xec\x6e\x5b\xd2\xe1\x04\x77\x2f\x1b\xbe\x0a\xd2\x4f\x51\x3c\x3c\x2e\x11\x5e\xaf\x08\x8e\x2d\xf6\x29\x03\x1e\x03\xef\xd1\xf9\x6b\xeb\xc2\xe0\xf8\xec\xc2\x5e\x77\x28\x12\x8e\xcf\x13\x97\x0a\xc7\x67\x27\x8e\xda\xa9\x6c\xf8\x8a\xc5\x3d\x5d\xf1\x70\x7c\x5e\x68\x21\x99\xfa\xd3\xa9\x90\x38\x3e\xbb\x95\x13\xaf\xf7\xed\xb8\xf5\x07\x29\x2d\x8e\x4f\xb7\x02\xe3\xf8\x1c\xba\xcc\x38\x3e\x2d\x21\x01\xc6\xf0\x4b\xde\x29\x14\xc1\xf7\xa9\xbb\x4b\x1a\x96\x17\x52\x51\xb5\x20\xa9\xb3\x35\x2c\x56\x44\x84\x46\x21\xa1\x7b\xa7\x86\x81\x79\xa4\x5c\x1d\x28\x1a\xa1\x43\x34\x28\x4b\x79\xb9\xb6\x5c\xf3\x3a\xb0\x61\xaf\x18\x68\x0f\x90\x0d\xcc\x65\x12\xf3\xd7\x9d\xae\x99\x4f\xac\x48\x93\x7b\x57\x31\xc8\x43\x15\x79\x7f\x14\xe4\x72\x74\xd4\xc8\x03\x0d\xe6\x31\xb8\xfb\x73\x95\x11\x7d\x63\x1c\xbb\x66\xca\xc2\xdb\x10\xe7\x16\x70\xe2\x1a\x9e\x5a\x89\xe4\x3d\xb0\xc1\x27\xda\x25\xd2\x31\xb2\x8d\xff\x9d\x41\xb9\xb1\xce\xbe\xf1\xbe\x63\x48\x07\x2d\x41\x32\x0f\x75\xd1\x32\x99\x44\x77\xcf\x35\x0e\x05\xdb\x70\xe5\x91\xdf\xdb\xee\xed\x66\xd8\x51\x51\xbe\x00\xa3\x4f\xa6\xf1\x5e\x8f\x27\x90\xda\x12\xa4\x78\x00\x66\xd8\x80\xbb\xa8\x4a\x60\xa9\xed\x97\x20\xf3\x7c\xd4\xa6\xfa\xd0\x83\xcf\xb0\x69\xa2\x42\x6e\x75\xdd\xc3\xfe\x72\x1b\x56\x56\xe9\x6d\x10\x02\xe1\x05\x75\x5d\x82\x98\xe8\xbe\xe2\xc4\x25\x39\x81\xbb\xab\xaa\x2c\x5a\x48\xee\xb8\x84\x66\x82\x67\x75\x3c\xf3\xb9\xec\xc2\xc2\x4b\xe1\x1c\x0d\x96\x90\x66\x35\xce\x94\x9a\xa9\xe1\xb4\xe4\xe9\x2e\xd8\xf2\x82\x19\x60\x6b\xb6\xd7\x9d\xd9\x75\x64\x71\x7b\x30\xb6\xe0\x88\xd1\x81\x35\x1c\x55\xde\x1b\x35\xde\x10\xa7\xc5\xab\x7b\x72\x50\xef\x2c\x10\x8e\x9c\xbf\x12\xba\x0b\xaa\xad\xe3\x19\xc9\x22\x71\xc1\xba\xbc\x96\xee\x12\x87\x45\xcc\x03\xc7\xd6\xa1\xfd\x8f\x57\x81\xbd\x3d\x7f\xcc\x26\xb2\xaa\x90\x82\x1a\x91\x73\xc7\x4d\x59\xc6\xa0\x8c\xbc\x2f\x51\x6f\x1b\xc0\x95\x70\x2e\xe7\x16\x99\xff\x47\x90\x4f\x3e\x67\x3f\x9f\xbc\x21\xf4\xb4\x16\x02\xe1\xaa\xce\x08\xc6\x52\xf4\xd1\xcd\xaa\xef\xa8\x52\xe8\x01\x19\x9f\x7a\x7f\x14\x38\x71\xc2\x8a\x85\x99\x97\x78\x51\xaf\x56\xcc\x02\x00\xc2\x8e\x95\xcc\x89\x16\xb4\xd0\x33\x69\x40\x35\xa4\x05\x4d\xb8\x59\x10\xa3\x68\x72\x0f\x25\x8a\x14\x73\x9f\x1b\x90\xe4\xd4\x39\x76\xc5\xe0\xab\xbb\x0d\x9b\x99\x92\xe5\x74\x06\x9e\xb0\xd8\x2a\xc9\xa8\xf6\xab\x5f\xd9\xdf\x69\x3b\x9a\xa4\x0b\x41\x73\x9e\x84\xac\x81\x4a\xce\xb9\xe6\xd2\x59\x7b\xfd\xb8\x37\x21\x33\x1c\x5a\x90\x2f\x32\xca\x73\x72\xa2\x19\x23\x57\x1e\x25\xf0\x17\x57\xc6\x1e\x2d\x1b\xaa\xee\x1c\x20\x43\x4a\x73\xe1\x12\x22\x54\x04\x2e\x5c\x5e\x21\xc3\xb4\x33\x5f\xf9\xd1\xd3\xb0\x5d\xab\xe7\x24\x15\x5c\xdc\xfb\xd4\x9d\x4c\xa4\x32\xba\xb5\x3c\xbf\xb9\xd6\xb1\x36\x82\xb8\xe5\xf2\xde\xc1\x0f\x99\x14\xd3\x38\x8d\x40\x85\x99\x96\x94\x0a\x28\xef\x32\xe7\x69\x49\x33\x24\xa2\x6e\x32\x17\xb7\xd7\xd8\x9d\x4f\x67\x66\xf8\xc0\xc0\x1a\x83\xbc\xa6\x3a\x33\xfe\xa3\x7c\xc9\x5b\x87\x6b\x20\xba\xc6\x59\x13\xd0\xb2\x65\xa7\xf6\x40\x17\x90\xb6\xc6\xb9\x98\xd4\x2e\x4c\x7d\x62\x31\x1c\x62\x15\xc4\x61\x7a\xe7\xa1\x5c\x87\x15\x1b\xc0\x5c\x65\x41\x0c\x98\xba\x3c\x37\x0b\xf8\x28\x0f\x60\x78\xed\x2a\xb3\x51\xbb\x41\x56\xb8\xdb\xac\xcb\x3c\x82\x50\x36\xaf\x36\xf9\xce\x95\x4e\xec\x28\x1c\x1c\xfd\x10\x99\xcd\xa2\x8b\x0e\x7b\x6c\xa8\x48\x87\x34\xb3\x98\x73\xf3\xfd\x85\xf3\x70\xc6\x83\x50\xbb\xc8\xf7\x55\x90\xb8\x08\x69\xb3\xad\xcc\xb0\xf2\x08\x40\x1c\xfc\x98\xa5\x40\x34\xe2\x82\x91\x0f\x56\x43\x76\x9b\x77\xf3\xfd\xc5\x80\xf0\x11\x1b\xf9\xbf\x42\x53\x4f\xb5\x8c\x9c\xa2\x1b\x60\xf0\xf1\x04\xbc\x83\xa9\xc4\xc6\xa8\xb8\xef\x5f\xff\x60\x27\x69\x7f\xfd\xe3\xf0\x0f\x51\xb6\xd1\x3f\xfe\xd5\x12\x41\x65\x1b\xd4\xdf\xc6\xbe\x64\x21\xeb\xfe\x5f\x6f\x5c\x56\x6a\x97\xb3\xfa\xaf\xae\x18\x17\x13\xc6\xca\x8d\x37\x12\x6e\xe9\x79\x8a\xd8\x08\xdf\x56\xec\x6f\xde\xb0\x08\x60\x0a\x46\x9d\x84\x1a\x26\x80\x50\xfb\xa0\x0c\x21\x0d\x76\x77\x75\x67\xed\xfc\x4f\xc0\x24\x80\x41\x65\x03\x62\xa4\x84\xe3\x88\x47\xfe\x5c\x10\xe6\x6b\x75\xe2\x5a\x01\x1c\xd4\x39\xaa\x79\xde\x63\x87\xb5\x10\x0e\x21\xb8\x76\x1e\x30\xb7\x5f\x09\x69\x7e\x15\xb6\xbf\x51\x45\x9c\xce\x25\xf7\x09\xc8\xed\x49\x11\x58\xd1\x31\xa4\xc4\x1e\x2f\x48\xce\xb5\xa1\xf7\x6c\x44\x6e\x2d\x6f\x89\x6f\xc3\x10\x7a\x82\x40\x06\x4b\x96\x92\x52\x18\x9e\xc1\xaf\xd5\x38\x76\xca\x31\xcf\xb9\x9e\x10\x5d\x42\x79\xf3\x42\xb1\xa1\xe7\x62\xae\xd5\x12\x2d\xa8\xd6\x32\x08\x9b\x3d\xa3\xa8\x0b\x14\x29\x74\x05\x78\x50\xe1\xd0\x6b\xc9\x8f\xcb\xce\x53\x8a\xa4\xe2\x5c\x00\x4c\x3d\x22\x1f\x80\x59\x65\xfe\x4a\x18\xd5\x12\x67\xc0\x14\x2c\x61\x5a\x53\xb5\x18\x40\x62\x77\x1e\x92\x81\x3b\xd7\x1d\xe0\xa8\x39\x15\x98\x56\x5d\xb1\x44\x0a\x6d\x54\x99\x18\xac\xb3\x37\x56\xf2\x9e\x89\xe0\x2e\x68\x77\xb1\xee\xc0\x55\xf9\xcf\xc0\x7d\x97\x24\xc9\x8c\x8a\x69\x54\xa7\x26\xa7\x29\xc0\xfe\xdb\x20\xe5\xf8\xf5\x58\x08\xd0\x89\x15\x2c\xb8\x01\x50\x8c\x2d\x1f\x09\x66\xd8\xff\x11\x21\x1f\xcf\xa0\xb2\x93\xda\x25\xf1\x6c\x0b\xed\xea\x44\xbf\x48\x47\xa3\xde\x10\xd8\xf6\x81\x1d\xc0\x72\x66\x68\x4a\x0d\xdd\xc1\x09\xec\x7d\x55\x5c\xcf\xd7\xd7\xc7\x02\xa7\xe1\x62\xd2\xf1\x21\x2f\x6e\xc9\x82\xc7\xf1\x4f\x70\x12\x67\x1e\xf2\x10\x71\x6d\x2c\x4e\xb9\x8b\x02\xf4\xed\x02\x79\xc6\x57\x2f\xb3\xc3\xfb\xd1\x90\x5c\x54\xa5\x19\x2b\x72\xd2\xee\x1a\xaa\xa3\x05\xd6\x82\x7e\x07\x18\xdd\x55\x77\x65\x49\xdd\xbf\x6b\xa5\x08\x82\x5c\x82\x09\xc3\x15\x8b\xc3\xcd\x1c\xe8\x4a\x81\x48\xde\x00\x22\x40\x79\xca\x8c\xae\x3c\x54\x90\x0e\x5b\xe2\xe2\xf8\x9d\x53\x46\x81\x48\x3b\xc0\x3a\x7d\x6e\xb5\x2c\x84\x60\xd7\xd2\xd1\x59\x4b\xf9\x1f\x05\xae\xbb\x18\x9d\xb1\x9c\xc0\x7b\x99\x76\xb1\x53\x37\xb2\xf0\x57\x43\x54\xfe\x9b\xe8\x89\xab\x41\xa9\xc7\x06\x70\x5b\xa5\x6b\x41\x73\x48\xe4\x66\x74\xbe\xbb\x91\xaa\x92\x91\x86\x21\x95\x31\x7c\x6e\x08\x9f\x1b\xbe\x6e\x6f\xcc\xeb\xe2\x01\xe2\x9f\xd6\x9e\x20\xf5\x8f\x74\xb2\x9c\x5a\x92\x72\xdb\xd1\xdc\xd9\x88\x46\x0e\x23\x38\x9a\xef\x6e\x11\xc3\xcd\xad\x8b\x74\x60\xdc\x52\x8b\x37\xe4\x57\x35\x2e\xef\xa4\xa9\xa0\x29\xa1\xa7\xee\x89\x57\x9d\x46\x6e\x2b\x7c\xf0\x79\xbd\xf9\x69\x63\x30\x10\x2f\x56\x6b\x14\xde\x23\x38\x88\x7c\x56\x3c\x53\x60\x3c\xf3\xf1\x07\x16\xbd\x94\xcc\x32\xa6\x60\x09\x4e\x7b\x6a\xdc\xa2\x43\x2e\x53\xb4\xe9\x0e\x82\x8a\x1a\x64\x4c\xc1\x1e\x82\x30\x41\x35\xa6\x6e\xf1\x37\x5e\xcc\x15\xce\x5b\x3b\x5e\xf0\x5a\x3e\x17\x0b\x9c\xfa\x65\x04\x5a\x54\x3d\xc9\xd4\x7e\xc8\x4a\x9d\x82\x8e\x33\xbc\x3d\x0e\xcc\x16\xe6\x42\xb3\x07\xba\xd0\x80\xf7\x95\x34\x1f\xbe\xef\xb2\xaa\x55\x03\x7f\x64\x13\xec\xdd\xfa\x46\x6c\xa7\x3b\xb1\x5d\x6e\xc5\x20\x9c\x92\x8b\x36\x2e\x48\x55\x87\x8d\x85\x43\x9a\xcf\x2e\xd7\x68\xe0\xa7\x02\xd7\xe7\xdd\xee\x44\xea\x75\xca\x6f\xae\x61\x08\x2f\x93\x4f\xe1\x0f\xcf\x71\xc2\xa5\xc1\x98\x59\xac\xae\x02\xa5\x01\x43\xe2\xbe\x2b\x3c\x09\x2a\xd4\xfa\x16\xb2\xb1\x3a\x2b\x71\xa8\x34\xa6\x18\x78\x82\xc0\x17\x47\x50\x8e\x80\x8a\x85\xe3\xe4\x66\xc6\x55\x3a\x2c\xa8\x32\x0b\x54\x1f\x07\xb5\xaf\x05\xf7\xfa\x4e\x0b\xdf\xf1\x3a\xa7\x5d\xea\xe3\xb5\x10\x86\xc5\x7b\xf3\xb0\xb3\xce\xaf\x85\xeb\x53\xac\xa7\xbd\x03\xff\xca\xf5\xc4\xa9\x45\xbd\x46\xf8\x6c\xeb\x49\x63\xf2\xb1\x3f\xdf\xb0\x34\x48\xd7\xaf\x5e\x91\x0d\xc4\xa5\xab\x64\xec\x05\x1d\xb8\x3c\x28\x44\x76\xa4\x81\xd5\x43\x69\x55\x6b\x3c\x32\xec\x39\x49\xc1\xfb\xd0\xb8\x4a\x47\x62\xe1\x4c\x37\xf1\xb7\xe2\x01\xc2\x29\x21\x27\x42\x0a\x3c\x39\xd8\xf6\x14\x5d\x88\xd6\xd8\xa6\xa0\x89\x2b\x51\x57\xaf\x10\x1a\x9d\x54\xcf\x24\xb8\x48\xed\xd6\x01\xe5\x06\x1d\x49\x97\x49\xc2\x58\xd0\xaa\xe3\x12\x35\xd5\xc9\x76\x53\xf6\xa5\x2e\xb5\x84\x24\x2e\xda\xd0\x2c\xab\xb4\x59\x07\x2e\x09\x7c\xce\x5b\x00\x23\xf6\x57\x0b\xb4\x71\x8a\x3d\x14\x51\x47\xb7\x97\x52\x24\x78\x85\xcf\xcd\xc2\xcf\xe0\xb2\xc9\xea\x41\x8d\xd0\xa8\xe4\xf2\x09\xda\x9d\x22\x75\x20\x00\x13\x48\x93\x2b\xe1\x5e\xe7\x4c\x2e\x37\x83\xa5\x43\x63\x9a\xdc\x3f\x50\x95\x42\x29\xdf\x82\x1a\x8e\x69\xc1\x07\xb5\x61\x4f\xa2\x39\x40\x21\xfd\x18\x8b\x4e\x83\xd2\xa1\x59\x48\x41\x5d\x7d\x86\xd0\xd2\xc8\x9c\x1a\x9e\x80\x2a\xcb\x27\x91\x15\x31\x0f\x29\x0d\x1b\x65\x07\x81\xca\x86\x02\xf6\x77\x78\x1b\xa3\x18\x31\x0f\x92\xf0\xdc\x4a\x08\x14\x4a\x69\x4c\x42\xc4\x90\xb7\x77\x6e\x9a\xa9\x15\x83\x7e\x00\x23\x73\xd4\x0a\x95\x64\xab\x42\x69\x18\x3e\x58\x34\x83\x29\xcf\x85\xdc\x0c\x1a\x0c\xdc\xf5\xb1\x38\x6d\xe7\x1a\xa1\xea\xc0\x6e\xcf\x03\xb3\x72\x81\xde\x88\xb0\x7a\xb4\x6a\x46\x58\xd3\x56\x93\x94\xeb\x46\x61\xea\x93\x54\xc9\xa2\x70\x06\x92\xfc\xb4\x39\x23\xb8\x37\x50\x73\xa6\xa3\xda\xcb\x68\xaa\x9e\x32\x11\x8a\x87\xbb\x74\x16\x70\x72\x9b\x9f\xa8\x1d\x98\x11\x06\x84\x9e\x92\x4f\xae\xa8\x50\x40\xdc\xe0\x75\xd7\x4a\x70\x42\x6b\x8b\x93\x9d\x7a\x89\xa7\xed\xd3\x4b\x3c\xbd\xc4\xf3\xf3\x96\x78\x82\xbb\xd7\xae\xd2\x4e\xe5\xe3\xd8\x28\x48\xee\x9d\x01\xaa\x06\xeb\x8c\x18\xd7\x13\xf2\x91\x25\x72\xce\x14\x12\x39\x28\xfc\x69\x79\xf9\x5b\xca\x33\x4b\xe2\x3c\xa9\xab\xd4\x43\xc8\xa8\x5a\x37\xcd\x45\x1a\x79\x80\xa6\x43\xf3\xdc\x4d\xca\x45\xfa\xd9\xf6\xee\x92\xac\x50\x6c\xce\x65\xa9\xbd\xcb\x42\x69\xf0\x98\x69\xe3\xf8\xed\x8c\x4f\x43\x62\xee\x70\xd5\xa9\x58\x22\x55\x5a\x85\x94\x6b\x43\x4d\xa9\xeb\x71\x12\x09\x5a\xd3\x0e\x67\xa0\x09\x70\x7c\x64\xea\xbe\x1b\x25\x45\x8f\x8d\x3d\x4e\xc5\xf1\x3b\xf4\xf9\xa8\xea\x6e\x9b\xc8\x0d\xa5\x72\x81\xb1\x22\x54\x69\x58\x84\x56\x0e\x01\x3a\xc3\xba\x16\xf5\x7a\x86\x85\x5b\x86\x61\xd8\x61\xe5\x75\xd2\x22\xe3\x7a\xfc\xec\x04\x75\xb2\x47\x80\x67\xfc\xbc\x60\xc7\x93\xc6\x62\xbb\x7b\x5f\x92\x3d\x3d\x30\xc9\x3e\x5e\x98\xe4\x90\x9e\x98\x24\xf8\x73\xef\x73\x62\x3e\x7a\x4f\xf2\xc6\x99\x71\x84\x77\xd3\x99\xa9\x25\x14\x08\xe3\x70\xed\x2b\x40\xba\x6b\xcd\x70\x06\xc0\x24\x18\xfb\x03\xbb\xd3\x0a\xda\x1c\xde\x5d\xb2\xcf\x21\xeb\x6f\x24\xc7\x54\x45\xb5\x8d\x04\x0f\x84\xbc\xc0\x4c\x40\x70\xea\x86\xce\x25\xcb\x6b\x4b\xfd\x09\xee\x4f\x70\xdb\xfe\xcf\x79\x82\xd1\xe3\xb9\x8b\x43\x7e\xa3\x52\x10\x76\x77\x41\xb8\x74\xcc\x32\xf2\x63\xc9\xd4\x82\x58\x21\xa8\x72\xef\x81\xf4\xc6\x9a\xa7\xce\x41\xc6\x19\x55\xda\xcb\xec\x4f\xc8\xff\xc1\x64\x73\xf5\xd9\x4a\x80\x10\xc7\xb6\x07\x5d\x6b\x0e\x55\x0f\x55\x46\x68\x05\x08\xc6\x12\x1e\xde\x30\xd6\x64\x3e\x2b\xee\x9d\x7f\xb8\xdc\x4d\xd1\xe9\x76\xa9\x45\x76\xb9\xd8\x5a\x5a\xfc\xf9\x86\x05\x22\x20\xc2\x2f\xf5\x6a\x52\xc1\x14\x41\xee\xd9\x62\xe0\xee\xc1\x5d\xf6\x76\xdf\x18\xdd\x39\xea\x29\x45\xdb\xa6\xaa\x58\x05\xa0\x1d\x28\xe4\x6e\xd6\x03\x7c\xda\x27\xa1\xac\xf7\xf2\x40\xe8\x4a\x88\x77\x26\xe1\x9d\x92\x55\xc6\xcf\xba\xc4\x95\x88\x13\x90\x81\xcf\xfb\x35\x07\x34\x00\x5f\x6e\xa0\x16\x5d\x37\x91\xec\xae\x02\xe3\xe3\x01\xbb\xf7\x52\x03\x9a\xd6\x1c\x73\xef\xd9\xe2\x58\xbb\xa8\x41\x29\xf4\x8c\x17\x3e\x3f\x3c\x50\x02\x87\xb9\xe4\x7b\xf0\x0f\xf0\x43\xe0\x99\xbf\x16\x03\xf2\x41\x1a\xfb\xbf\x2b\x70\x15\x42\x4b\xa5\x64\xfa\x83\x34\xf0\xe6\xc9\x81\x85\xd3\xdd\x1b\x54\xce\x4c\xc9\xc1\xcc\x88\x2e\x6d\x10\x9f\xe1\x5d\x50\x00\x24\xee\xbe\x35\x80\x95\x6b\x72\x2d\x88\x54\x1e\x26\xc6\x27\x0f\xd6\x6e\x08\x6f\x5b\x8a\x2c\xc2\x2b\xc6\x70\xa0\x94\xaa\x06\xc9\x0d\xc3\x05\xe3\x32\xf7\xbf\x80\xed\x09\xac\xf1\xc1\x6f\x06\x52\xe0\x52\xc3\xa6\x3c\x21\x39\x53\x53\x88\x0f\x4d\x66\xbb\x6f\x50\x77\xba\x8d\xcf\x4e\xd4\x3b\xfe\x70\x67\xcc\x00\x56\xf7\x0e\x3c\x97\xf6\x65\x98\x38\x0a\xb2\x88\x9c\x16\x16\x29\xfe\x61\x39\x01\xec\xcb\xbf\x20\x65\xb5\x1e\x91\x73\x5f\xf0\x34\xfe\xcd\x59\x31\xe2\x61\xec\x08\x56\xa6\xff\xb1\xe4\x73\x9a\x31\xf4\xe7\xa3\x22\xa4\xf1\x94\x93\x25\x36\x3d\x70\x79\xab\x2d\x95\x0a\x37\x43\x47\xf7\x6c\x71\x34\x58\x42\xa4\xa3\x6b\x71\x54\x05\x69\xd7\x50\x27\x30\x34\xb8\x34\x38\x82\xdf\x8e\x0e\xcd\xd9\x9f\x49\xb4\xdf\x01\x4b\x9c\x41\xe8\x22\xa3\x5a\x77\x8b\x6f\x6d\x84\x16\x35\xc6\x59\x95\x80\xf1\x36\x6a\x53\x05\x17\x39\xef\xcd\x83\xdb\xb3\xc0\xcb\xbf\xbb\xa7\x51\x27\xe8\xcd\x5d\xf5\x94\xf6\x89\x1b\x56\x26\x14\x83\xb4\x05\x3e\x86\xa3\x16\x17\x57\x5d\xc6\xae\x81\xd7\xf7\x60\x57\x94\x93\xb8\xc8\x33\xd7\xa0\x06\x73\x1f\xd5\x21\xa4\x21\x5c\x24\x59\xe9\x4c\x8a\xd0\x15\x94\xe8\xae\xa2\xfe\x0e\xc0\xd9\x03\xa9\xaa\x01\x3c\x36\xf9\x6b\xdf\x25\x07\xde\xe6\x0d\x1d\xdc\x89\x86\x1b\x2f\x84\xd5\xa1\xd7\x3a\xd9\xe2\x2e\x59\x4f\xc6\x99\xd4\x65\x8f\xb7\x7c\xac\x18\xb9\x98\x51\x21\x58\x16\x45\xbb\x3a\x63\x47\x28\x67\x05\x02\x89\x2b\x62\x75\x5c\xaf\x62\xe5\xe9\x9b\x08\xb1\xd5\x07\xaf\x1d\xfc\x53\x2a\x2a\x75\xb0\x3a\xe5\x2e\x55\xe3\x4c\x3e\x90\x54\x92\x07\xa8\x5b\x30\xb7\x4c\x0b\x2e\x65\xb5\x67\x77\xd1\x4c\xc1\x45\x22\x91\x79\xa1\x64\xce\xb5\x77\x8e\x77\xdb\x78\xd0\xd0\xd0\xac\x6c\x91\x03\xa8\xbe\x07\x59\x29\xea\x29\xe1\xdf\x5e\x10\x43\xd5\x94\x19\x3b\x1a\x11\x65\x3e\x66\xad\xe3\x57\x1f\x23\x07\xd9\x97\x54\x42\xf4\xb0\x45\xb0\x70\x1b\x7e\xf8\xe1\x43\xe7\xd2\xbb\x55\xcf\x75\x7b\xfb\x20\x55\x96\x3e\xf0\x14\x59\xb4\x26\x27\xb6\xf1\xe9\xcb\xaf\x94\xfb\xf0\xc0\xd3\xce\xe0\x80\x4e\x75\x30\x78\x3f\x28\x0b\x06\x02\x70\x70\x15\x9e\x38\xa4\xd1\x86\x1e\xa7\xe4\x8a\x63\x74\x11\xf4\x87\x44\x35\xf9\x98\x8b\x2a\xc2\xac\x02\xb3\x25\xc6\xf6\xbc\x78\xd5\x44\x33\x83\x71\x21\x10\x5a\x21\xcd\x8c\x68\x9e\x97\x99\xa1\x82\xc9\x52\x67\x8b\xd6\xa8\xf2\x3c\xa0\x9e\x64\xec\x33\x62\x76\x17\x26\x17\x3a\xd5\x99\x1d\xb8\xae\x54\x61\x94\x4b\xdc\xae\x72\xae\x4a\xcf\x02\xe7\x0b\xe1\x46\xec\x33\x4b\x9c\x57\x70\x91\x95\x53\xbe\x25\xfc\xe1\x67\x96\xd5\xbc\x4a\x20\x5d\x6a\x56\x45\xea\xb7\xad\xeb\xf2\x44\x49\xc8\x9f\x97\xc3\xdf\xad\x4e\x40\x9e\xb2\x82\x89\x14\x52\xa2\xbd\xad\x30\x17\x27\x7f\x50\xc8\xb9\xf4\x62\x5d\xa9\x96\xcf\x4a\x56\xa3\xe0\x91\x0b\xd7\x4c\x66\xa9\x26\xec\xb3\x51\xd4\x12\xa6\xdc\x92\xa0\xd0\x67\x42\xa8\x68\x4f\x64\x5e\x46\x8a\x60\x72\x70\x6e\xff\xb8\xf5\x32\x5f\x62\xc9\xcb\x6a\xed\x7a\x63\xc1\xea\xfd\x52\xd7\x23\x21\x76\x67\x45\xd7\x3d\x84\x57\xa4\x98\x77\x5f\xa9\x7b\x26\xee\x97\x6a\x5e\xaf\x48\xaa\xdd\x98\x55\x5f\xa6\xf3\x8b\xc8\x3b\x3f\x81\xc0\xe0\x2e\x49\x98\x5c\x8f\x86\x46\xed\x5e\x36\x0b\x42\x6f\xd0\xa0\x1d\xde\x46\x7c\x00\x32\x9e\xba\x81\x5c\x58\x13\xd1\x16\x96\x95\xeb\x5c\x29\xc4\x36\x2a\xf6\x18\x59\xc4\xa9\xa1\x9a\x99\x76\xd6\x94\xba\xe8\x50\xf5\xb4\x07\x30\xc6\x2f\xf7\x13\x66\xb1\x07\x87\x74\x1f\x2c\x4b\x86\x7f\x74\x52\x86\xa8\xb5\xb4\xf2\x85\x87\x8f\x4f\xd2\xc4\xc2\x2d\x32\x8e\x91\xda\x5d\x49\xa8\x69\x5d\x72\xa7\x15\x5f\x70\x33\xf8\xf4\xa9\x73\x2d\xd7\xa8\xa7\x97\x43\xe0\xdf\x75\x20\x38\x5c\x80\x44\x3e\xfc\xc7\x32\x56\x07\x20\xb9\x45\x58\xb6\x6b\x7f\xa8\xb5\x4d\x13\x56\x19\xaf\x2e\xb9\xbe\xef\x92\x8c\x6c\xa9\x73\xfd\x48\x7c\x73\x71\x45\xdc\xdb\x56\xf6\xa5\x2e\x06\xa6\x7d\x33\x63\x4d\x13\x56\x19\x6d\x53\xae\xef\x9f\xbc\xac\x7a\x91\x7e\xd8\xe6\x01\xfe\x74\xf6\xaf\xa6\xd4\xeb\x53\xb4\x44\xb9\x83\x16\xb2\x24\x0f\x2e\xf5\x81\x93\x9a\xef\x78\xf1\x86\x5c\x09\x5d\x2a\x56\xdd\xdc\x36\x87\xb2\x5c\xf7\x25\x95\x5e\xdf\x0b\x4b\x5e\xb2\xf1\xad\xa0\xca\x80\x78\xdc\x15\x0d\x42\x47\x4f\x9f\xa2\x17\xa2\x0d\x1e\x5c\x4f\xbc\x63\xdd\xc0\xc5\x78\x87\xc4\x65\xbe\x91\xdd\xf9\x28\xad\x49\xbc\xd7\x6f\x43\xca\x1f\x72\x96\xb2\xf9\x99\x4e\xe9\xeb\x01\x7c\xc6\x3b\x3c\xd7\xe7\x44\x35\x39\x7a\x7d\x34\x22\xb7\x3c\xe7\x19\x55\xd9\xa2\x96\x8a\xb9\x6a\x67\x99\x85\x1f\x10\x6e\xe5\x5e\x1d\x91\x13\xa9\x60\xe4\x84\x0a\x92\x31\x1f\xd1\xe4\xce\xd9\x02\x65\xc7\xd3\xa7\x26\x2e\xe4\x51\xed\x97\x48\x67\x3a\xe3\x44\xea\x39\xb6\xe3\x47\xb5\x74\x36\x97\x15\x49\xe7\xc2\xd2\xf9\x11\xf9\xb4\xaa\x50\x39\x1c\x19\xdf\xe2\xb9\x80\xfa\x34\x7a\xdf\x4e\x1a\xdc\xb2\x39\xf8\xf9\xc0\xb4\x5d\x4b\x9c\x72\xf3\x91\x15\xb2\x93\x84\x80\x5d\x1a\xf6\x38\x6e\xec\x0b\xa9\x39\x24\x2a\xa5\x06\xca\x02\x2b\xc3\x93\x32\xa3\x56\xac\x46\x6b\xdc\x88\x5c\x5e\xdd\x7c\xbc\xba\x38\xbf\xbb\xba\x7c\x43\xbe\x71\x23\xf1\x58\xc2\x1b\x91\xbb\x38\x1b\x54\xe4\xd1\xeb\x52\xee\x84\x6f\x0d\x1c\x19\xa2\xa2\x4a\xee\x08\x39\x3e\xa8\x20\xd7\x82\x9b\x2a\x3d\x32\xfa\x9d\x65\x52\x30\x5f\x3d\xb4\x90\xce\x1a\x38\xe5\xe8\x0d\x22\xdc\x60\xf6\xe7\xfa\x68\x70\x3a\x30\xd5\x6a\x98\xca\x16\x45\xf0\x11\x44\x8b\x0a\xb8\x87\x12\xff\x7d\xfe\xd3\xae\xb2\x6f\xc8\x46\xeb\x03\x9c\xd0\xfa\x5f\xbd\x47\x66\x10\x12\xb3\xfb\x74\x37\x2b\x4a\x5a\x13\xcb\x66\x8e\x47\xc7\x5e\xa0\xc8\x96\x92\xf0\x87\x41\xe3\x8c\x5e\x75\x64\x1b\x11\xf2\x9d\x77\xd9\x86\xd0\xe3\xd5\xf9\xfc\x31\x3b\x44\x94\x15\xbe\x81\xb2\x3e\x30\xa6\x1c\xc7\x1f\x75\x29\xc0\xa6\x7c\xce\x04\x2e\xec\xb0\x14\xca\x7f\xbe\x73\x75\xb4\x6a\xde\x4e\xff\xf8\xf8\xee\xb0\x33\xc3\xf3\xd7\x79\x5e\xee\xd8\xba\x59\x25\x32\xcf\x31\x5f\xd4\x2c\x04\x18\x56\x31\x82\x81\x2a\x1c\x4c\xf3\xc1\xcc\x57\x93\x2d\xc8\xdf\xa0\x67\xbe\x53\x43\xd3\x09\xaf\x5d\x50\x82\xa8\xc4\xdc\xee\x79\x98\x5d\x92\x35\xed\x93\xa7\x38\xd2\x7e\x16\x3e\x7e\xf6\xf1\xea\xfc\xf2\xfd\xd5\x28\x4f\x9f\x9c\xb4\x30\x91\x16\x92\x0b\xa3\xb7\xeb\x37\xdb\xaa\xce\xb4\x27\x3f\xe1\xa3\x5d\xb9\x73\xe8\xe8\x71\xcc\xbf\x88\xf2\xd2\xa5\xcc\x50\x9e\xe9\x68\x0f\x8d\x2c\x64\x26\xa7\xab\xd3\x2f\x77\xd8\x9c\x5f\x60\x7e\x99\x21\x1d\xda\x5d\x3f\xac\xa8\xdf\xa6\x8e\x46\x53\xca\xaf\x2a\x62\x57\x6b\x0d\x52\x33\x94\xbb\x78\xa1\xcb\x7d\x14\xe1\x6c\x09\x06\xa8\x48\xc2\x01\xf6\x29\xfb\xaa\x1c\x78\x51\x0d\x9b\xb6\x52\xdb\x63\x83\x6e\xbb\xc0\x66\xe9\xcf\xf6\x42\x45\x75\x98\xf9\x3e\x75\x02\x57\x28\x36\x0c\xe9\x9a\xa0\xb4\x8a\x54\x11\xc3\x8d\xe9\x9d\xb7\xde\x78\x5b\x0f\xb6\xca\x16\x4d\x2b\x4e\x25\x1f\x05\xd3\x17\xe6\x18\xc8\xb2\x45\x95\x06\xd2\x69\xd1\x74\x8a\x69\x98\x94\x33\x13\x17\x8a\xcf\x79\xc6\xa6\x90\x8a\x95\x8b\x69\x14\xfe\x1a\x07\xcc\xba\xd4\xac\x75\xa3\xeb\x7b\xfb\x57\x94\x74\x1b\xf0\xe2\xc3\x77\x77\x90\xd5\x17\x2e\xb8\xf6\x16\xc2\xed\x07\xe1\xbc\x0d\x87\x43\x30\x19\x9c\xfc\xcd\xca\x93\x69\x76\x4a\x7e\x60\xee\x3b\x12\xd2\x0e\x2b\x28\x05\x34\x93\x21\x07\x2c\xcc\xb5\x82\x2c\xa0\x23\x5e\xef\xbb\x56\x67\xb6\xa5\x95\x95\x90\xd5\xd4\xda\x43\xe5\x53\x4c\xdd\x88\x77\x4c\x4f\x2f\x7b\x1e\x90\xec\xef\x4c\xe5\xbc\x69\x75\x15\x7e\x86\x8b\x1f\x4f\x0f\x29\xd1\x8b\x3c\xe3\xe2\xbe\xca\x0b\x36\x91\x16\x87\x30\x34\x81\x8b\x7b\x8f\xb1\x8a\xd1\x6c\x3d\xa5\xdc\x05\x3f\x0e\x4a\x25\xcd\x0e\x16\x40\xb0\xd0\xd9\x73\xf6\x27\x7f\xec\xdd\x35\x74\x4c\xe2\x8e\x8e\x5e\xdc\x7a\xb9\xee\x56\x06\xff\x18\x3a\xd4\x68\x9a\x20\xd7\xb7\x17\xb7\xd7\x4f\x6a\xa1\x5e\xc7\x12\x60\x76\xcf\x28\xd5\xf1\x1f\xb7\xdd\x0e\x0f\x49\x56\x6e\x6f\x83\xea\xdd\x8d\x54\x86\x66\x07\x22\x02\xc9\x8c\x16\xe7\xa5\x99\x5d\x72\x0d\x39\x14\xba\x0a\x01\x4b\xfd\x23\x4f\x67\xcc\xdd\xec\x13\x06\x72\x8f\x0e\xae\xdd\xc5\x9f\xce\x6f\x08\x2d\xed\xfe\x1a\x97\x5c\xf4\xa0\x17\xee\x7e\x66\xb7\x18\x61\xb0\xe3\xba\x5c\xef\x2d\xab\xf2\xad\x1e\x7b\x4d\x8f\xe1\x87\xdb\xdf\x45\x00\x0d\x45\x0a\xf6\x82\xef\x1f\xb8\xe0\x86\x53\x23\x5b\x16\x2a\xab\xa1\x40\xad\x6f\x30\x08\x94\xda\xc8\xdc\x61\xf0\xb5\x6f\x01\x57\xc8\xc0\xc5\x97\x3a\x55\xd6\x02\x90\xde\x01\x62\xd7\xc2\xca\xda\x34\x61\x0d\x07\xc8\x01\x24\xfd\xc4\xb1\x79\x68\xf3\x07\x67\xa0\x82\xfc\x60\xd9\x1f\xdf\xd4\x52\xb1\x2f\xd5\xb5\xf0\x56\x8a\xaa\x68\xc2\x41\x2d\x3e\xfc\xc7\xae\x44\x81\xff\x28\x1a\x96\x36\x5c\xe0\x7f\x95\x34\x43\xc0\x7c\x38\xb4\x59\xaa\x0e\xe4\xae\xf3\xad\xef\x90\x9b\x7a\xb5\x1d\x1f\x82\x96\x5e\x6a\xcc\x3c\x86\xeb\x31\x8a\x0a\x6d\xf7\xa8\xae\x8b\x1d\xbb\x8b\xa7\x63\x72\x62\x92\xa2\x75\xed\xfe\x47\x72\x6d\xcf\x4a\x51\x2b\xe4\x0c\x33\xbf\xc3\x6d\x79\x17\x5c\xdb\xdb\x4e\xf2\x51\xae\x86\x00\xcb\xbb\x5a\x55\x5c\xaf\xb0\x5b\xf1\xba\x90\xf5\x93\x77\x5c\x1b\x5f\x90\x01\x5e\x70\xed\xf2\x08\x83\xdc\x75\x63\x15\x39\x5e\xfc\x2f\x4d\x53\xf5\x06\xb9\x94\xaf\xbe\xac\x40\xfa\xf2\x49\xbe\xa8\x08\x77\x89\x27\x66\x51\xb8\x04\x80\x77\x17\x37\x04\x0b\xa4\xfc\xfe\xb7\x58\xf9\xf5\xdf\x7f\xfd\xdb\x57\xad\xb7\xfb\xf9\x9c\xc7\x77\xb4\x63\x1c\xfc\x8e\xe9\x45\xf8\x0d\xd6\xfc\x03\xed\x4a\x40\x36\xb9\x45\x77\x3c\x4b\x59\xdd\x51\x47\xc4\xb2\xbb\x1c\xe8\xfd\x6e\x12\x4c\xef\x67\xf7\xac\x7e\x76\x24\x44\x94\x20\x91\xe8\x88\x2e\x71\x57\x08\x31\x5c\x26\x3b\x48\x71\x6e\x5e\x1e\xc5\xd9\x0a\x9b\xed\x58\x54\xc7\x9e\xf8\x32\xde\x97\xbf\xa9\x5c\xd8\x2f\x3f\xdc\xfe\xef\xbb\xf3\xaf\xaf\xde\xc1\x4c\xdd\xfd\xbd\x45\x0d\x2e\x76\xf6\x9f\x6a\x8f\x6a\x6d\x94\xd7\xed\x00\xe9\x76\x2d\x23\x1a\x17\x32\x82\x7c\x78\x7b\xdb\xf5\x2e\x66\x5f\x01\x5d\x4c\x5a\xad\xfd\x69\xad\x6d\x50\xd5\x84\xa9\xc3\xc5\x8f\xec\x6c\x94\x8b\x12\x69\xd5\xf4\x2f\xbb\x53\x38\xc3\xbd\x55\xa4\xad\x3b\x40\x5e\xc0\xbd\x83\x5d\x2f\xc2\xe0\xe0\x37\x0e\x8f\x04\xab\xb6\x72\x80\xea\x1e\x58\x74\x8c\xbd\xbc\x08\x60\x0f\x29\xd2\x36\x65\x69\xb6\xa5\xd6\x4c\x87\xea\x0b\x2f\x14\x53\x8a\x55\xe9\x99\xbb\x50\xaf\x95\x03\xd4\xca\x95\xd5\xee\x62\x6a\xb1\x14\xeb\xd2\x99\x7b\x0f\x05\xea\x94\x57\x5d\xd0\xe4\xa0\x05\x55\xaa\x57\xf8\x06\x82\xdc\x9f\x9e\x00\xc2\x67\x0f\xe8\x48\x1b\xc6\xeb\x8a\xc8\xa1\x63\x33\x4a\xae\xd3\x0e\xf9\x42\x1f\x85\xf4\x11\x88\x71\x38\xdd\x33\x6f\x1f\x79\x5a\x6d\xe7\x87\x1d\x15\x9d\x43\x2b\x39\xc5\x4c\x1a\x29\x76\xf6\x92\x5f\xd5\xbd\x7e\xa0\x6f\xa0\xc5\x45\x55\xc6\x26\xaa\xf1\x08\x1e\x94\xe1\x32\xc2\xca\x73\x9e\x5d\x48\xe1\xaf\x25\xea\x97\x12\x4f\x2e\x82\xa4\xd7\x97\x07\x3a\x7c\x5f\x6e\x88\x67\x57\x63\xf0\x41\x9d\x41\xd2\xce\x31\x29\xb6\x8b\x87\xd8\xf5\xa5\x13\xcd\x7c\xc0\x89\x76\x08\x49\xd6\x63\xe4\xc1\x58\xa7\x54\xe6\x41\xaa\xee\xa1\xde\xf5\x8e\x0d\x5f\x05\xf7\xdb\x52\x28\xd6\x4b\x3c\x3d\x38\xc7\x67\x3e\x41\xb7\x70\x82\x1a\x09\xce\xd7\x9d\xa4\xc7\x38\x48\xcf\x7b\x80\xf6\x65\x54\x8f\x1b\xe5\x7b\x50\x21\xdd\xa3\x5b\xc7\xa5\xfa\x6e\xce\x98\x60\x37\xa9\xa2\x16\x14\x4c\x2e\xd1\x89\x3b\x18\x75\x50\x12\x4b\x50\x76\x21\x0c\xbe\x0f\x1a\x70\x31\xd1\x73\x96\x59\xa8\x4a\x11\xa7\x88\x76\x61\xbc\x03\x82\x59\x96\x73\x5a\xf8\x9a\xdc\xf2\x41\x3c\x50\x95\x92\xf3\x9b\xeb\xc3\x50\x83\x0e\x7e\xd6\x88\x49\xed\x32\x7a\xd5\x3d\xad\xab\x9e\x58\xe6\x66\xc6\xa0\xb6\x22\x19\x73\xa3\xab\x9a\x7e\xcc\xc4\x7a\xa5\xa5\x82\xe1\x2e\xcb\x9e\x65\x7b\x6e\xdd\x48\x11\xc3\x14\x44\x26\x86\x66\xbe\x88\x80\x2b\x93\xf3\xea\xd5\x2b\x34\x85\xbd\xfa\xdd\xef\x7e\x87\x95\x95\x52\x96\xf0\x7c\xb9\x21\xb4\xfa\x3f\xaf\x5f\x8f\xc8\x7f\x9f\xbf\x7f\x07\x95\x1f\x0b\xa3\x31\x2b\x09\x8e\x8c\x95\xe0\xa3\xce\x7a\x40\xfe\xef\xed\x77\x1f\xaa\x32\x31\xf5\x5f\x5d\x41\x6d\xb7\xbc\x11\xb9\x8c\xfc\x9f\x62\x43\x17\x35\x33\x57\xd0\xc8\x10\x3a\x99\x20\x62\x8c\x7d\x39\x5d\x3c\x70\x3e\x7a\x1c\xaa\x82\x63\xfd\x11\x8b\x12\x19\x38\x66\x59\x95\x1c\x4d\x83\x3e\xb3\x01\xfa\x99\xc1\x58\x81\x4c\xc2\x54\x06\x58\x4b\x7e\xa2\xa1\x0a\x49\x95\xfe\x4f\x31\x6d\x85\x52\x57\x5d\x11\x07\xab\x76\x46\xb3\xd6\xb9\x1e\x1e\xe3\x06\xa8\x75\x75\x8c\xba\xe9\xde\x9d\x21\x9f\xbe\xd5\xe5\x2e\xae\xca\xd4\xff\x0d\x6f\x43\xb7\x39\x09\x3f\xd2\x8d\x4c\x6d\xae\x37\x61\x36\xb8\x75\x2e\x4b\x40\x45\x27\x68\x26\xa1\x92\x57\xd8\xe9\x8a\x8b\x45\x45\xef\xb7\x2f\xa5\x73\xf2\xc5\xae\x09\x78\x91\x50\xbd\xa7\xad\xcb\xf9\xd4\xfd\x45\x7c\xef\x5a\x5e\x05\x3a\x96\xa5\xf1\x77\xd8\xee\x77\x08\xc0\xc6\x2a\xeb\x1d\xd2\x48\xee\x90\x79\x72\x97\x0c\xc4\x9d\x93\x98\xd6\xef\x9b\x81\x27\xd4\x45\x89\x01\x61\x34\x99\x91\x7b\xb6\x18\x22\xdd\x2a\x28\x44\xf3\x00\x54\x2e\x2d\x2c\x6a\x85\x4f\xaa\xda\x35\x56\x3e\x76\x20\xf3\x8e\x01\x11\xf7\xf1\xd1\x40\x5e\x08\xd5\x4e\x5e\x72\x69\x44\x45\x64\x29\xf0\xb9\xaa\xa3\x7a\xc4\x21\x6f\x28\x16\x23\xaf\x07\xa9\xd8\xf3\xc6\x52\xdb\x4d\x6f\xfa\x72\xe5\x0d\x61\xe9\xa0\xe3\x6e\xa5\x58\xea\xed\x8a\x6f\x3b\xe1\x0f\x3e\x48\x7d\x76\xe6\xc8\xa3\x02\xca\xf9\xb9\x4a\x4e\xae\xad\x87\x52\x00\x44\x2d\x88\x46\x33\x53\x3a\xd0\x60\xbd\xb0\x52\x64\x4c\x6b\xc2\x61\x85\x39\x55\xf7\xcc\x27\x8c\xa1\xd9\x88\xdc\xd8\x49\x86\xfc\x55\x98\x16\x79\x8e\x2e\x76\xf6\xcc\xc6\xd1\x41\xf6\x23\xc7\xa3\xd1\x31\x12\xf8\x15\xb1\x42\x1d\xf0\x63\xb7\x9c\xba\x3b\xe4\xd2\x6d\x94\xf6\x2e\x34\x66\x06\xb6\x22\x1f\x64\xbe\x96\x10\x05\x67\x66\x9e\x81\xd1\xd6\x49\x94\x96\x97\xb3\x43\x02\xd8\x5d\xf3\x96\xef\x92\xb5\xbc\xd5\xbd\x45\xfd\xd9\x3d\x5b\xf9\x4e\xb9\xca\xd7\x65\x2a\x77\x3b\xe5\x4e\x5b\xf7\x1c\xce\x7b\xa4\xd8\xce\x3b\xa5\x79\xf5\x4f\xdd\x48\x09\x72\x47\x2d\x4b\x4f\x2b\x19\xd1\x25\x7d\xca\xd8\x17\x25\x14\x5e\x4f\x56\x55\x9d\xf3\xc1\x82\x91\xbc\xec\x69\xa8\x85\xc0\xf3\x4b\x83\xdd\x6a\xb9\x90\xce\xe2\x61\xf3\xe9\x22\x2e\x36\x9f\x76\x97\x81\xcd\xa7\xae\xb0\x45\x61\x49\x81\xe8\xc7\x5e\xfc\x00\x52\x23\x21\x67\x77\x75\x04\x47\xe4\xbd\x63\x0a\x88\x8c\x74\xac\x65\x56\x9a\x10\xc9\xb4\x82\x63\xc0\xa0\x3e\xc3\x37\x86\x94\xfa\x66\x11\xff\x00\xce\x89\x64\xb9\x2b\x2b\xc1\x67\xa7\x23\xde\xb5\xe6\xde\x4f\xd6\x99\x64\x0f\x18\x7a\x51\x62\x67\x38\xfa\x01\x42\xde\x09\xef\x4b\x5d\x93\x71\xc0\x93\xc4\x68\x14\xa0\xbc\xb8\xe2\x0a\x3d\x75\x5e\x62\x3b\xab\x8d\x9b\xab\x33\x4c\x9c\xdf\x5c\xef\xa4\x01\x44\xfd\xd7\xe8\x00\x71\x8b\x9f\xb0\x16\x70\x8d\x5a\x40\x5c\x76\xe7\xb2\x5a\xb9\x33\x29\x5b\xb2\xf3\xe2\xc5\xc8\xa5\x69\xbf\xb5\xc4\x32\x76\x3a\xad\xe7\xd0\x43\x63\x4f\x45\x56\xa3\xbc\x7b\xfe\xd6\x11\x0e\xf1\x4b\x17\x39\x9f\x50\x7c\x04\x78\x74\x2a\x97\xee\x9f\xe5\x6a\x76\xb0\x58\x72\x0b\xa5\x6d\x50\x1f\x8c\x14\xcb\x42\xa6\x6f\x5c\x29\x69\x21\x24\x16\x90\xd3\x03\xac\x8d\xa3\x07\xa8\x30\x5a\x29\x22\xba\x2b\x56\x91\xc9\x7d\x67\xb9\x61\xa7\x2a\x47\xfb\xd4\x39\xb2\x1b\x08\x2b\xbf\xe9\xba\x8b\x64\xcf\xb2\x45\x24\x62\x4d\xbb\x15\x42\xa9\xed\xa9\x1b\x29\xd4\x79\x4f\x66\x2c\xa7\x98\xc3\xcf\x2f\xcf\x52\x99\x07\xc5\x8d\x61\x98\x4b\x89\xa9\x5c\x13\x39\x19\xd4\xee\x0c\x8e\xe6\xaf\x8f\x76\x29\x07\xb3\x67\xc5\x1e\x52\xed\xc2\x01\x80\x71\x53\x13\xd9\x2c\x5e\x83\x2e\x91\x41\xe2\x4d\xd1\x30\x48\x58\x06\x33\x47\xe8\x3d\xf9\xc2\x0f\xa1\x47\xed\xaa\x3f\x0d\x82\xc0\xd0\xeb\x4f\xbd\xfe\x74\x10\xfd\x29\x62\x2c\x9e\xe0\xac\xd0\xa5\x62\x87\x61\xaf\x50\x55\x81\x4c\x51\x02\x1e\x8b\x9a\x5e\x95\x92\xaa\x6e\x71\xb3\xfa\xd0\xb1\x57\xb0\x1c\x1e\x97\x66\x32\xfc\x3d\x61\x22\x91\x29\x6e\xbe\x1d\x5f\x69\x03\xa2\x4d\xa5\x93\xc4\x73\xc9\xfd\xb7\x62\xab\x1d\x8c\xbd\xeb\xd6\xed\x44\x07\xfc\x55\xe0\xdb\x03\x31\xf8\x8a\xad\x87\x60\x62\x5f\x2b\xdb\xe7\x1a\x70\xfc\xbd\xba\x84\xc4\xb2\xd2\x80\xdc\xbe\x62\x2e\x39\xc1\x97\xa3\xa4\x28\x07\xae\xc1\x28\x67\xb9\x54\x8b\x41\x68\x64\x7f\xac\xf5\x72\x2d\x4e\x41\x26\x48\x4a\x65\x35\xc0\x6c\xf1\xa5\x4a\x07\x1e\x40\x4f\x2c\x1c\x84\x7d\xea\x56\x34\x28\x7e\xea\x28\x51\x25\x15\x03\xfd\xbe\x2a\xa2\x34\x09\x29\x0f\xf5\xa0\x52\x3b\xed\x5b\x26\xe6\x64\x4e\x55\x87\x2a\xe8\xf1\xb3\xa7\x3c\x90\xf2\x39\xd7\xbb\xd5\x3b\x6c\x2c\xfd\xd6\x31\x0d\xb4\xeb\xc8\xd2\x14\xa5\x71\x94\xd2\x9f\x0a\x1f\x32\x1f\x4e\x43\x43\x28\x7a\x7d\xb4\xd3\x34\xbe\x98\xfa\xc2\xf8\xec\x58\x65\x18\x9f\x7d\x6b\x0d\xd7\x47\xd9\x19\x6d\x0e\x5a\x39\xdc\x3f\x1e\x2d\x0e\x71\x0e\x2b\x16\x59\xe5\x79\xf0\xc2\xe9\x13\x1d\x34\x74\x37\xd9\xc9\x6e\xe3\x32\xd4\xaf\x36\xd9\xb8\x1f\x7f\xc2\xd6\x9a\xc3\xde\xd9\xba\xf8\xc2\x9f\xf9\x85\xed\xad\xab\x67\xd0\xdf\xd6\xb6\x42\xc1\xfe\xb6\xb6\xbf\xad\xed\x6f\x6b\x7b\x6b\x43\x6f\x6d\xe8\x6f\x6b\x49\x7f\x5b\x7b\x10\x18\x1e\xee\xb6\x16\x45\xbd\x55\x77\xb6\x4e\xd8\xab\x2e\x6c\x9f\xf4\xbe\xd6\x15\xee\x39\x4f\x12\x59\x0a\x73\x27\xef\x59\xeb\x4b\x87\x86\xfc\xbf\x34\x0e\x24\x40\x58\xa3\x0f\x2c\x37\x7e\x32\xe5\xa0\xbb\x54\xd2\x49\xb6\xd8\x45\xaa\xa0\x65\xca\xad\xe4\xbf\x33\x9a\xf9\x01\xe2\xe4\x44\x22\x65\x69\xf5\x83\x3b\xca\xc6\xc2\x7a\x44\xce\x89\x62\x09\x2f\xb8\x2b\x23\x4f\xf1\x3d\x22\x5e\xa8\x8d\xc0\x8d\x66\xd9\xc4\xe5\xa8\x17\x71\xad\x9f\x4a\x7e\x77\x74\x70\xe5\x67\x90\x43\x49\x9f\xc9\xdc\xd7\x42\x52\xec\x6f\x9e\xb5\xb9\xd9\xdc\xc5\x23\xc4\xe6\x15\x58\x4a\xad\xc4\x10\x7c\xac\xe0\x2e\xc0\xfa\xb1\x8f\x3f\xfb\x5c\x70\x05\xc8\x7b\xcb\x12\x29\xda\xd4\x54\x5d\xb3\x41\x4b\x23\x55\xfc\x09\x6c\xa3\x2c\x25\x69\xa9\x42\xcd\xd4\x39\xcd\x78\xca\xcd\x22\xdc\xda\xb9\xf2\x5a\x14\x4f\x4c\xd8\x46\x5d\x81\x91\xd0\xa2\x50\x92\x26\x33\xa6\xa3\xaf\xa1\x80\xe2\x82\xc8\x82\xef\x3b\x96\x80\x03\x19\x05\xfa\x58\x06\x99\x2d\x88\x92\xc6\x5f\xbc\xaf\xf9\xe0\x5d\x34\x18\x74\x47\x2e\x67\xd4\x02\x6e\xe7\x65\x3c\x04\xce\x8a\x4f\xe2\x3f\x34\x91\x59\xea\x53\x98\xfc\xfe\x95\x15\x0a\x13\x87\x83\x96\xf8\x41\x82\x0b\x23\x49\x66\x19\xb6\x25\x88\xeb\x3b\xff\xfa\x37\x64\x26\x4b\xa5\x47\x71\xd2\x81\xd7\xf0\x0e\xf5\x3b\x2f\x54\x1a\x92\x31\xaa\x0d\x79\xfd\x8a\xe4\x5c\x94\x96\x4f\x75\x46\x9b\xee\x72\x50\x24\x01\xfd\xf6\x37\xad\xfb\x75\x95\x7d\xd6\x4a\x3d\x05\xe6\x46\x76\xa2\x8f\x3b\x49\x18\x18\x87\x99\xc5\x1b\x82\x90\x23\xba\x31\xb4\x85\x91\x8f\x70\xbe\x7e\x2c\xe5\x78\x61\xba\x04\x51\xba\x1e\xf5\xe8\xc9\xff\x72\x2f\xdb\x24\x4f\xa9\x72\xa7\x6c\xfc\xe8\xa3\x54\xb8\x98\x72\x6d\xb6\xd4\xb7\xa8\xe2\x2b\x37\x36\x6b\xcf\x56\xa6\x56\x3b\xe8\x18\x2b\x03\x7d\xbc\x44\xec\x6d\x4b\x49\xc2\xb0\x98\xe5\x65\x55\x29\x49\x48\x6c\xbb\x75\xf8\x67\x4e\x38\xe6\x11\xe4\x00\x59\xd3\x5b\x2e\xb5\x9d\xd0\xe5\x51\xa2\xf3\x5a\xb1\x5b\xfd\x14\x68\x2e\xa6\x98\xe4\x3c\x2f\x33\xc3\x8b\xac\x5a\xf7\x47\xdf\xc1\x11\xf2\xd8\xe6\x46\x23\x33\x11\xc5\xc0\x62\xcc\x36\x05\xf6\xc9\x93\x30\x16\x13\x06\x73\x75\x2b\xcb\x0f\x0a\xaa\x68\x00\x1e\x54\xd2\xd5\xa7\xce\x7c\x47\xe1\x46\xd1\xa5\xc3\xb4\xbd\x68\x56\xcd\x38\xba\x45\x3a\x24\xd2\x18\x26\xa8\x68\x61\xaa\xae\xa7\xe7\x82\x4e\x44\x3e\x04\x67\x32\x2c\x83\xd2\xc0\x16\x27\xd4\x7c\x4d\x93\x7b\x26\x52\x2c\x1a\x05\xcb\x4e\x17\x82\xe6\x2e\xdb\x56\x54\x8f\xbb\xd1\x5f\x0f\x9c\x61\x02\xc3\xf7\x7c\x98\x31\x72\xdd\x43\xc2\xa0\xd4\x9d\x53\xd9\xd8\x2e\xdb\xce\xb9\x46\x93\x8d\xe2\xf3\x84\x79\xfe\x6f\xfb\x1d\x72\xea\xf3\x16\xb1\xf4\x4b\x93\xf7\xdb\x13\xe1\x2f\x90\xfb\x60\x39\x87\xa4\x5a\x34\xb3\x47\x7b\x11\x62\x46\x1b\x9b\x3b\x5e\x1c\xb6\xea\x8d\x1a\x77\x89\xfc\x3d\x56\xe3\xb4\x7e\x88\x3f\xd2\x54\x6a\xf2\x75\x26\x93\x7b\x72\xc9\x40\xe8\x7a\xcc\xf2\x2c\x6a\x9c\x3e\x67\x0a\xef\x9c\x4e\xb7\xdd\xb3\x0d\x49\x2e\x05\x37\x52\x6d\xa6\x17\x4f\x57\x76\xb2\x4f\xf7\xbc\x36\x43\x95\xc5\xe6\x97\x9c\xec\xd9\xa2\x5b\xd7\x8d\x87\x4e\x41\x3d\x83\xd3\x89\xaf\x5c\x15\xb0\x1d\xcf\xda\x2f\x66\xf2\x61\x68\xe4\xb0\xd4\x6c\xc8\x5b\x5c\xe8\x76\x58\xe6\x3d\x5b\xc0\x2d\x76\xc7\x85\xba\x6e\x35\x9d\xc1\x48\xb0\x40\xc1\x7b\xcb\xb9\x3f\x7e\x7d\xf9\x49\x33\x35\x8a\x65\xc0\x33\x66\x92\xb3\x84\x15\xb3\x33\x37\xc2\x8b\x04\x8a\x27\x22\x5d\xa1\xe2\xfb\x21\x9b\x49\x64\x96\xb9\xc0\x6c\x39\x21\x17\xac\x98\x85\x81\x9f\x7a\xd5\xcf\x97\x11\xb8\x90\xb2\x6b\x22\xd4\x63\xdb\xa7\x7e\x88\xe0\x0d\x9e\xa1\x08\x99\xd4\xb8\x5b\x11\x8a\xa7\x42\x9f\x17\x5d\x6a\xf3\x11\x81\xf3\xb8\xe9\x94\x8f\x6b\xf9\x94\x63\x7f\xcf\x7a\xb2\x64\xef\x31\x52\x23\x41\xd7\x13\x14\xba\x53\x96\x12\x39\x67\x4a\xf1\x94\x69\x12\x68\x50\xac\xa5\xf2\xec\xa9\xe1\xd6\xe7\x6d\x7e\xf6\xbc\xcd\x3b\xa8\x43\xc7\xa0\x0f\xd5\xc8\x14\xbc\x59\x22\x53\x34\xcd\xb9\x78\x71\x84\x4a\x27\x34\x63\xd7\xdf\x75\xd0\x3f\x5c\x8f\xba\x0a\x72\xeb\x5e\x46\xf9\xd3\xb6\x64\x25\xfb\x36\xe0\x0d\x11\x32\xdd\x66\x52\x7d\x04\x45\x62\x4a\x0d\x7b\xd8\xca\x0e\x87\x15\xa1\xda\xde\x12\x84\xd3\xe7\x54\x39\x5e\x44\x8e\xc0\x08\xe7\x31\xe9\xd9\x21\x99\xaa\xdb\xb5\xae\xc6\x49\xec\x15\xa7\xdf\x6d\x26\xdd\xf5\x18\x7c\x7e\x73\x4d\xbe\xc1\xe6\x87\xcd\x5e\xa8\xa4\x41\x31\xf0\x52\xe6\x94\x77\x2d\xb2\xd1\xec\xde\xcc\xbe\x1a\x2f\xe1\x26\xb4\x25\xae\x71\x54\xc0\x65\xc2\xa7\xa5\xd5\xe9\x9c\x1e\xf6\xa2\x12\xcc\x2d\x89\x2e\x2f\x37\xc1\xdc\xfe\xd5\x20\x22\x93\x93\xf7\x8b\xac\x24\x16\xbf\x95\xc0\x4a\xc2\x1d\x28\xd1\x4c\x68\x0e\x17\x32\xd1\xad\xb8\xab\xf4\x87\xa5\x25\xd1\x09\x12\x45\x9c\x01\x79\x27\xa7\x5c\xf8\xd3\x2b\xdd\x7d\xdd\x84\xf2\xac\x2d\x30\x7a\x99\xe4\xd9\x65\x12\xad\xb3\x2b\x41\xc7\x59\x1b\x77\x83\x3a\xaa\x85\x8e\xe4\x6d\x46\xa7\x84\xc1\x1f\x67\x29\xd7\xf6\xff\xe4\xf6\xf6\x1d\x18\xe1\x4b\xe1\x25\x66\x30\x50\x3b\xda\x17\x82\x14\xf0\x20\x1e\xf6\xec\x20\xe9\xd9\x21\xfb\x5f\xd4\x93\x70\x91\xda\x89\x47\xa5\xe0\xd0\x49\x0a\x5a\x60\x3e\xc4\xe0\xf3\x8b\x6e\x03\x63\x46\xee\x66\x3c\xb9\xbf\x89\xec\xee\x52\xd9\x77\x22\x7a\x55\x63\x60\xcd\xdf\x0e\x49\x2d\xdd\x54\x6f\xba\xab\xc6\x51\x4f\xcf\x07\x3c\xc1\xb8\x75\xeb\x87\xdf\xa8\xd6\x32\xe1\xd5\x9d\x0b\xd8\x68\x2a\xe6\x90\x02\x73\x38\xec\x9a\x40\x3c\xe8\xba\x1c\x94\x3f\x56\x70\x34\xbf\x9b\xbe\x3a\xae\x8e\x39\x18\x17\x7e\xd5\x07\x5d\x02\xe2\xcc\x0e\xa9\xd1\xab\x8e\xcb\xa9\xd1\xbd\x30\xdc\xb8\x58\xf0\x6e\xea\x6e\xf3\xbc\x20\xe6\x6b\x73\x2e\x6d\x5f\x48\x91\xee\x52\x13\x1e\x6c\xe1\x6d\xc2\x36\x56\xa9\xe1\x8d\xdb\x44\x7c\xe7\xae\x1a\xe0\xcc\x15\xb2\x28\x33\xf4\xe7\xd8\x3f\xbf\xbb\xb7\x19\xe3\x77\x0e\x74\xf5\xf0\x14\x59\x4b\x8f\x63\xc7\xde\xee\x9e\xce\x3f\x8d\xdc\xa5\x91\x70\xf7\xea\xb7\xbf\xf9\xcd\x97\x9e\xcd\xb4\xad\x0a\xfe\x18\xe9\x4c\x5b\x9a\x68\x57\xc4\x17\x5d\xf7\xf1\x45\x3f\xdf\xf8\xa2\xc7\xcf\x42\x7b\xe0\x08\xa2\x8e\xbe\xb9\xdd\xfc\x72\xdb\xc7\x08\xb5\xf6\xde\xed\xea\xb9\xdb\x21\x0a\xe8\xb0\xb1\x3f\x9d\x7d\x59\xbb\xc4\xf9\xf4\xd1\x3d\x3f\xd5\xe8\x9e\x5d\x7c\x59\xbb\x47\xf2\x74\xf1\x61\xfd\x29\x46\xed\x74\x38\x9c\xed\xa3\x4b\xf6\x8e\x29\xe9\x9e\x04\xb0\xbb\x3d\x6d\x97\x82\x54\x55\xcf\x95\x1a\xa4\x0f\x2a\xf7\xb9\xc7\x8e\x8f\x75\x94\x5a\xcc\x48\x7b\x02\x9f\x44\x21\x21\x1d\xb4\x31\x1c\x5e\x76\xa9\x0d\xe9\xfa\x7c\x77\xdb\xb8\x98\x09\xaf\x9f\xe7\x3e\xe6\xe7\x70\xe1\xd1\xd7\x74\xf9\x42\x4c\xee\xba\x96\xad\xc5\x5b\x2b\x80\x04\x00\x23\x97\xe3\x38\x4b\x64\x75\x74\xce\x6f\xae\xad\x0e\x0e\x61\x44\x34\xd3\x23\xb2\x82\xcf\x7b\x73\xa9\x93\x0b\x3c\x7f\xa7\xc6\xb0\xbc\x30\xed\x77\xbd\xb7\xb8\x3f\xbb\xc5\xfd\x80\x16\xc0\x59\x99\x53\x31\xb4\x27\x0a\x6c\xee\xb5\xdb\xba\x06\x65\x1e\x11\x77\x76\x90\x3d\x81\x05\x04\x82\x0b\xea\x85\x8d\x69\x54\xe6\xf2\x71\xcc\x9e\x30\xf6\xce\x2b\x47\xbe\xda\x38\x69\x89\x5c\x72\x78\x75\xcb\x09\x50\xf0\x87\x2a\x62\xce\x35\x35\xdc\xcc\x18\xf2\xf0\x1b\x08\xc8\xa9\x5a\xd5\x25\x69\x14\xa5\x69\x96\xc9\x07\xfc\x76\xcc\xd7\x2c\xf4\xed\x5c\x5c\xa4\xd9\x98\x91\x9c\x5b\x1d\xdd\x19\x58\xe3\xe9\xe0\x95\xa9\x95\xc8\x99\x42\x81\x57\xb9\xcb\xb6\x5b\x66\xdc\x46\xc1\x46\x5b\xfd\x56\xa0\x43\xb8\xfd\xb7\xf7\x2a\x82\x6f\x7b\x9a\x30\x66\x33\x3a\xe7\xb2\x54\xd8\xdb\x48\x72\xe4\x7e\x02\xde\xb0\x90\x65\xb0\x77\x61\x31\xcc\xb0\x3a\xbd\x02\x4e\x1f\xaa\x1f\x41\x15\x48\xa5\x37\x4d\x0c\xd9\x67\xae\xcd\xf2\x5a\x3c\x88\x7c\x1a\xbc\x43\xe1\xcd\x5c\x17\x96\x2d\x74\xae\x6a\x57\xeb\x57\x97\x57\xe6\xb7\xf0\xd3\x17\x54\xd3\x6e\x6b\x76\xd7\x27\x13\x81\x7e\x86\xe2\x4f\xb8\x09\xcb\x78\xb2\xe8\x5c\xee\xad\xd1\xdb\x13\x6d\x1d\xee\xd0\xec\x7b\xf2\x35\xd5\x2c\x25\xef\xa9\xa0\x53\xd4\xf7\x4e\x6e\x6f\xbe\x7e\x7f\x6a\xf7\x15\xf4\xc9\xeb\xcb\x95\x17\x6d\xb7\xf1\xe0\x1f\x0e\x19\x2f\xb2\xb4\xf0\x1d\x58\xd5\x52\xff\x1d\x17\x7f\xd0\x40\x18\x12\xf8\x50\xbb\x64\xbd\x2b\x58\xd0\x4d\x33\x84\xb5\x59\xf3\xb3\x41\x60\xe6\x79\xba\x67\x95\x4f\x2e\xb4\xa1\x59\x76\x93\x51\x71\x5e\x14\x4a\xce\x57\x6b\xe3\xb5\xb9\xfa\x86\x7e\xa6\xe8\xe6\xe1\x5f\x16\x08\x7a\xb8\xc2\x16\xe4\xba\x1a\x7f\x44\xae\x4d\xd0\xc2\xa5\x00\x96\x7a\x74\x5e\x1a\x99\x53\xc3\x93\x23\xab\xac\x1f\xbd\xa7\xa2\xa4\xd9\x4a\xa7\xab\x8d\xcb\x58\x27\x22\x6e\xec\xb4\x3e\x75\x5d\x8b\x6e\x1b\x65\x8d\xcd\xfd\x0d\x55\x96\x3a\x5d\xdc\x7e\xdf\xa9\xaf\x36\xd4\x94\x4b\x54\x78\x03\x67\x58\xcf\x0b\x86\x24\xa3\xda\x7c\x2a\x52\x7b\xe8\x1b\xbf\x6e\x22\xf8\x09\x35\x34\x93\xd3\x3f\x31\x9a\xad\xc6\xf0\x1a\x9e\x5c\xc4\xad\xbd\x01\xca\x5d\xf8\x97\xe3\xd0\xf0\x58\x13\x2b\x60\xfb\x18\x78\xc5\x32\x36\xa7\xc2\xf8\xee\x58\x5c\x5d\x1f\xbb\xf5\x03\x16\xf1\xca\xf8\x9a\x32\xc3\x54\xce\x45\x7d\xcc\x5b\x68\x7b\x21\x45\xca\xd1\xec\x08\x06\x35\xec\x51\x1f\x77\x3d\xaa\xad\xbb\x69\xd8\x70\xb7\x50\xcf\xae\x19\xcd\xa7\x0e\x0a\x6c\x36\x76\xf2\xe5\x0c\x5f\xc2\x4d\x7b\x6d\x6e\x4b\x90\x22\xf7\xc2\x0a\x86\x90\x47\x64\x35\xd9\xda\x2a\x27\x6c\x93\x0f\x86\x7e\x8f\x71\x0a\xeb\x1d\x47\x87\x6e\xde\xeb\xee\x20\x36\xa1\x18\x3e\xdb\x25\x8b\xe6\x54\xd6\xd3\xd4\x55\x78\x17\xba\x61\x24\x4b\xa3\x20\x7f\xad\xd1\x7a\x1e\xd0\x4a\xf0\x6a\x27\x23\xb5\xcd\x6a\x5f\xa7\xb5\x55\x0e\xf6\x25\x55\xb6\x85\xc4\xb8\x95\x69\xb5\x4c\x2e\x5f\x57\xac\xaf\x9d\xff\x9f\x72\xaa\x08\x25\x05\x67\x98\xfc\x84\x0a\x07\x2c\xe0\x2c\x8c\xa6\xee\xa5\xe5\x60\x56\x25\x84\xdf\x06\xee\x32\x1c\x8d\xcb\xce\xd7\xc2\x1b\xa8\x29\x26\xff\x80\x8b\x8b\xb3\x6f\xa4\x33\xf2\xba\x20\x5d\x4b\x03\x80\x93\x0f\x88\x2e\x93\x19\xa1\xda\x4e\xcd\x22\xb4\x3d\xf1\x6c\x94\x53\xc1\x27\x4c\x9b\x51\xc8\x12\xac\xff\xfc\xeb\xbf\x8c\xc8\x5b\xa9\x88\x73\x54\x1f\xf8\xac\x1a\x6e\x9e\x15\x5e\x70\x8d\x8b\x09\x7d\x2b\xad\xb5\x90\xa9\x9b\xf4\x03\x4c\xd6\xd0\x7b\xcb\xc3\x70\xb2\x25\x83\xab\x8b\x37\xe4\xc8\x8a\x89\xd1\xa7\xff\x61\xd9\xd2\xbf\x8e\xc8\xc9\x03\x30\xed\x23\xfb\xe7\x11\x7e\x30\xb8\x4d\xc6\x4a\x75\xf5\x61\x0c\x96\x54\x7c\x3a\x65\x0a\xd5\x47\x02\x41\x85\xa7\x2e\x2b\x88\x90\x51\x63\x7f\x29\x5d\xa9\x9b\xcd\x89\xfc\xf9\xd7\x7f\x39\x22\x27\xf5\x75\x11\x2e\x52\xf6\x99\xfc\x1a\xad\xcb\x5c\xdb\x35\x9e\xba\xcb\x1c\xbd\x10\x86\x7e\xb6\x63\x26\x33\xa9\x99\x40\x55\xde\x48\x32\xa3\x73\x46\xb4\xb4\x1a\x30\xcb\xb2\xa1\xb3\xa5\x93\x07\x0a\x99\x5a\x3c\x28\x21\xb0\x9e\x14\x54\x99\x1a\x4a\x8c\x9c\x85\x04\xbe\x66\xb7\x6d\x2a\xfc\xcd\xf4\x84\x0b\x77\x7f\xe5\x6e\xce\xec\x9e\x43\x60\x28\x6e\x92\x91\x24\x99\x51\x31\x0d\xb1\xe9\x93\xd2\x94\x8a\x6d\xb9\xfa\x69\x79\x06\xee\xb9\xe8\x14\xc2\xfc\x2d\x17\x4d\xa7\x82\xd5\x76\xa5\x29\x37\x3e\x2a\xc2\xf9\x2a\x9a\xc5\x99\xdd\x05\xc5\xc7\xa5\x91\x4a\x9f\xa5\x6c\xce\xb2\x33\xcd\xa7\x43\xaa\x92\x19\x37\x2c\xb1\xcb\x3a\xa3\x05\x1f\x26\x52\xd8\x1d\x87\xac\x0c\x79\xfa\x0b\x28\x6f\x3a\xb4\x53\xdd\x92\x75\xba\xe5\xa2\xb7\x1b\xd5\x9e\xd5\x98\x76\xb0\x35\xb6\xb0\x07\x2d\x2f\x14\x6d\x33\x4f\xb0\x5a\x30\x84\x9c\x1d\x64\xb1\x3e\x69\x72\x77\x1e\x73\xec\xf2\x80\x27\xcd\x31\xec\xb1\x43\x07\x12\x38\x95\x35\x4a\x99\xd3\x14\x49\x29\x15\x8b\x47\x47\x7e\x0b\x52\x48\x97\x9f\x2c\x86\x30\x84\xcc\x86\x54\xa4\xf6\xdf\x18\xb0\x93\x2c\x0e\x02\xc3\x92\x77\x22\x04\x9f\xae\x2f\x9f\xe6\x48\x94\xfc\x00\xa7\xde\xc9\x6b\x2d\x85\x28\x14\x55\xd1\x51\x43\x95\xcc\x33\xcd\xba\x80\xca\xb5\x1f\xf5\x3f\xdc\xfd\x4b\xc8\x76\xb6\x4d\xa4\xda\x7c\x6b\x12\xc9\x8e\x2d\xe7\xfb\xae\xea\x11\xdb\xe4\xc0\xf1\x8a\x6a\xe3\x52\x6b\xf9\x1c\x04\xb5\x65\x78\x05\x05\x18\xcc\xfa\x8b\xe1\x56\x38\xe4\xfd\x05\xec\x44\x86\x2b\x73\x2e\x25\x41\x29\xd9\xae\x40\x55\xfa\x4b\xad\x0e\x1a\x2e\xca\x30\x6d\x08\x9d\x53\x9e\x81\x75\x5e\x8e\x35\x53\x73\x2c\x48\xe5\x52\x0d\xd2\xa6\x9e\xe5\x6a\x4e\xa0\x18\xf5\x44\x9a\x8f\x5f\xc3\xf2\xae\x6c\x5a\x00\x68\x43\x8d\xd9\xaf\x9d\xf5\x41\xf4\x1e\x54\x2f\xd7\xfe\x6c\xbf\xb0\xa3\x1a\x63\xf1\xef\x4f\x8c\x2a\x33\x66\xd4\xdc\xf1\x4d\x7c\x77\x09\xa5\x6b\xfd\x42\x29\xf7\x80\xd0\x0f\x8c\x4c\xa5\xb1\x22\x56\x09\xb8\x8f\x32\x29\x26\xf5\x09\x88\xf6\xd8\x18\x5d\xad\xf2\x4e\x51\x08\xf1\x91\xa2\xe3\x32\xeb\x1d\x97\xd7\xe9\xa4\x63\x87\x49\x06\x5b\x63\x22\x0d\x29\x98\xdb\x3b\xbc\xcd\x00\x0a\xf4\x34\x4b\xce\x99\xd6\x1b\x13\x6c\xd4\xbd\x0b\xb1\x35\x1e\xe5\xc6\xd5\x5a\xee\x7f\xc3\xb0\x10\x2b\x40\xa7\xcc\x50\x9e\xf9\xa3\x8c\xa0\x08\x50\xda\x46\x5d\x37\x2e\x50\x31\xaa\x37\x09\x08\xb5\x59\x7f\x84\xc6\x38\x69\x29\xd8\xf0\x41\xaa\x94\x5c\xd0\x9c\x65\x17\x54\x33\x37\x56\x1c\xa2\x87\x7b\x74\xac\x0f\x3a\xe5\xd5\xb6\xaf\x35\x53\x46\xe3\x4f\x65\x12\x86\xbf\x2a\x15\x0b\x27\x38\xf0\x26\xc8\x3b\x55\xb2\x01\x79\x6b\xb9\xd7\x80\x7c\x12\xf7\x42\x3e\xec\x37\x57\xb3\xf1\x16\xa4\x36\xd3\xd8\xfd\xc3\xa7\xd5\xa9\x19\x7c\xc2\x74\x77\x9c\x91\x23\xf8\x6b\x4c\x8d\x75\x66\x13\x9a\xfa\x19\xd9\x7f\x2e\x99\xa0\xac\xa2\xa8\xe4\x54\x31\x8d\x99\x6b\x56\x26\x49\x6c\x6b\x72\xfe\x86\x09\x17\xdc\xb7\x75\x7a\xd7\xab\x7a\xf9\x99\x7a\xbe\x36\xad\x7e\x71\xfb\xed\x3e\x56\x64\x2b\x45\x8d\xcd\x1e\x81\xd1\x44\xd7\x18\x9f\xd6\xcd\x70\xb5\xd1\x29\xe2\x7a\x51\x5b\x14\x4a\x36\x59\x47\xfd\xea\x2e\x6e\xbf\x5f\x0f\xec\xb5\xbc\x6f\x1b\x7f\xda\x6e\x96\xda\xd7\x20\xb5\xf5\xcc\x6c\x35\x42\xf5\xe6\xa7\xde\xfc\xf4\x25\x99\x9f\xb6\x62\xfc\x26\x93\xd3\x97\x61\x6c\xda\xba\xc4\x4d\x06\xa6\x17\x69\x5a\x6a\xb5\xa2\x8d\xe6\xa4\x17\x6b\x48\xda\xba\xb4\x96\xc6\xa3\x9f\x8f\xd9\x68\x2b\xc4\x36\x98\x8a\x5e\xa0\x91\xa8\x8d\x40\xc6\xd2\x36\x62\xe2\x75\xd4\x38\x16\x14\xab\x72\x96\x61\x38\xef\x94\x13\x8b\x33\xbb\x4a\x8b\x56\x80\xdb\x3a\xb7\x63\x37\xb9\xf6\xb2\x97\x13\x18\x5d\xb1\xc7\xa5\xc9\x92\xcb\xab\x9b\x8f\x57\x17\xe7\x77\x57\x97\x4d\xf9\x6e\x15\xa4\xb7\x48\x62\x9b\x6d\x10\xc3\x48\x12\x5b\xd3\xc0\x12\xe4\x35\x3f\x59\x1c\x58\xf3\x53\x59\xf2\x55\xbd\xf6\x97\x0b\xf7\xe2\x72\x7b\xf1\x8f\xed\xa7\xb3\xed\xf1\xfc\x84\x8e\x53\xd4\xf9\x9c\x59\xb9\x67\x26\xb3\x54\x7b\xbf\xd5\xeb\xcb\x10\x49\xc5\x45\x92\x95\xa9\x15\x2e\x3e\x7d\xba\xbe\xd4\x23\x42\xbe\x66\x09\x2d\x35\x58\x61\x52\x29\x8e\x0d\xf9\xee\xc3\xbb\xff\x06\x7f\x6c\x68\x31\x08\x79\x4d\x20\x2b\x2f\xa7\x98\x58\xd8\x60\xba\x36\xf2\x35\x43\x41\x05\xbe\x9c\xd0\xc2\x52\x31\x8d\x95\x2b\x0c\xc8\x22\x33\x96\x15\x96\x62\xde\x33\x52\x65\x50\xb5\x03\x57\x15\xe6\xbd\xfb\xe4\x94\x19\x8c\xba\xda\xe4\x21\xb9\x11\x6a\x5b\x2c\xae\x7b\xd8\x5a\x6b\xea\xa3\xd3\xc6\x1f\xa8\x76\x16\xab\x95\xb3\xdd\xb2\xbf\xdb\xed\x33\xeb\x4d\x1c\x6b\x8c\x1b\x48\x9e\xe1\xaf\xa5\x39\xdb\xc9\x56\x76\x0c\x74\x22\xe1\xa6\xb5\x35\x75\xbd\x1b\xd0\xea\x3a\x00\x4b\xb6\x0c\xd6\x04\x72\xed\xc3\xc1\x23\x3b\x9a\x72\xbb\xb9\x40\x11\x91\xb4\x56\xfb\xd3\xf9\xcf\xd5\xdf\x95\xe3\x50\xfd\xb5\x9a\xaf\xb3\xc8\x90\x7f\xfc\xeb\xab\xff\x3f\x00\x00\xff\xff\x01\xa8\x18\xd1\x2e\x5c\x02\x00") func operatorsCoreosCom_subscriptionsYamlBytes() ([]byte, error) { return bindataRead( diff --git a/vendor/github.com/operator-framework/api/pkg/operators/v1alpha1/subscription_types.go b/vendor/github.com/operator-framework/api/pkg/operators/v1alpha1/subscription_types.go index e048d4988c..900cc46577 100644 --- a/vendor/github.com/operator-framework/api/pkg/operators/v1alpha1/subscription_types.go +++ b/vendor/github.com/operator-framework/api/pkg/operators/v1alpha1/subscription_types.go @@ -84,6 +84,12 @@ type SubscriptionConfig struct { // List of VolumeMounts to set in the container. // +optional VolumeMounts []corev1.VolumeMount `json:"volumeMounts,omitempty"` + + // If specified, overrides the pod's scheduling constraints. + // nil sub-attributes will *not* override the original values in the pod.spec for those sub-attributes. + // Use empty object ({}) to erase original sub-attribute values. + // +optional + Affinity *corev1.Affinity `json:"affinity,omitempty" protobuf:"bytes,18,opt,name=affinity"` } // SubscriptionConditionType indicates an explicit state condition about a Subscription in "abnormal-true" diff --git a/vendor/github.com/operator-framework/api/pkg/operators/v1alpha1/zz_generated.deepcopy.go b/vendor/github.com/operator-framework/api/pkg/operators/v1alpha1/zz_generated.deepcopy.go index c094738eed..e26ddea616 100644 --- a/vendor/github.com/operator-framework/api/pkg/operators/v1alpha1/zz_generated.deepcopy.go +++ b/vendor/github.com/operator-framework/api/pkg/operators/v1alpha1/zz_generated.deepcopy.go @@ -1394,6 +1394,11 @@ func (in *SubscriptionConfig) DeepCopyInto(out *SubscriptionConfig) { (*in)[i].DeepCopyInto(&(*out)[i]) } } + if in.Affinity != nil { + in, out := &in.Affinity, &out.Affinity + *out = new(v1.Affinity) + (*in).DeepCopyInto(*out) + } } // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SubscriptionConfig. diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/catalog/main.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/catalog/main.go index ead86cd763..20134d71d2 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/catalog/main.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/catalog/main.go @@ -30,6 +30,7 @@ const ( defaultOPMImage = "quay.io/operator-framework/upstream-opm-builder:latest" defaultUtilImage = "quay.io/operator-framework/olm:latest" defaultOperatorName = "" + defaultWorkLoadUserID = int64(1001) ) // config flags defined globally so that they appear on the test binary as well @@ -83,6 +84,10 @@ func (o *options) run(ctx context.Context, logger *logrus.Logger) error { return fmt.Errorf("error configuring client: %s", err.Error()) } + workloadUserID := int64(-1) + if o.setWorkloadUserID { + workloadUserID = defaultWorkLoadUserID + } // TODO(tflannag): Use options pattern for catalog operator // Create a new instance of the operator. op, err := catalog.NewOperator( @@ -98,6 +103,7 @@ func (o *options) run(ctx context.Context, logger *logrus.Logger) error { k8sscheme.Scheme, o.installPlanTimeout, o.bundleUnpackTimeout, + workloadUserID, ) if err != nil { return fmt.Errorf("error configuring catalog operator: %s", err.Error()) diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/catalog/start.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/catalog/start.go index 45a0953c08..7161131880 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/catalog/start.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/catalog/start.go @@ -25,6 +25,7 @@ type options struct { tlsKeyPath string tlsCertPath string clientCAPath string + setWorkloadUserID bool installPlanTimeout time.Duration bundleUnpackTimeout time.Duration @@ -66,6 +67,7 @@ func newRootCmd() *cobra.Command { cmd.Flags().StringVar(&o.opmImage, "opmImage", defaultOPMImage, "the image to use for unpacking bundle content with opm") cmd.Flags().StringVar(&o.utilImage, "util-image", defaultUtilImage, "an image containing custom olm utilities") cmd.Flags().StringVar(&o.writeStatusName, "writeStatusName", defaultOperatorName, "ClusterOperator name in which to write status, set to \"\" to disable.") + cmd.Flags().BoolVar(&o.setWorkloadUserID, "set-workload-user-id", false, "set user ID for all workloads (registry pods/bundle unpack jobs to default 1001") cmd.Flags().BoolVar(&o.debug, "debug", false, "use debug log level") cmd.Flags().BoolVar(&o.version, "version", false, "displays the olm version") diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker.go index 55665aada6..bf797ba1fd 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker.go @@ -22,6 +22,7 @@ import ( listersbatchv1 "k8s.io/client-go/listers/batch/v1" listerscorev1 "k8s.io/client-go/listers/core/v1" listersrbacv1 "k8s.io/client-go/listers/rbac/v1" + "k8s.io/utils/pointer" "github.com/operator-framework/api/pkg/operators/reference" operatorsv1alpha1 "github.com/operator-framework/api/pkg/operators/v1alpha1" @@ -101,6 +102,11 @@ func (c *ConfigMapUnpacker) job(cmRef *corev1.ObjectReference, bundlePath string // See: https://kubernetes.io/docs/concepts/workloads/controllers/job/#pod-backoff-failure-policy RestartPolicy: corev1.RestartPolicyNever, ImagePullSecrets: secrets, + SecurityContext: &corev1.PodSecurityContext{ + SeccompProfile: &corev1.SeccompProfile{ + Type: corev1.SeccompProfileTypeRuntimeDefault, + }, + }, Containers: []corev1.Container{ { Name: "extract", @@ -129,6 +135,12 @@ func (c *ConfigMapUnpacker) job(cmRef *corev1.ObjectReference, bundlePath string corev1.ResourceMemory: resource.MustParse("50Mi"), }, }, + SecurityContext: &corev1.SecurityContext{ + AllowPrivilegeEscalation: pointer.Bool(false), + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, + }, }, }, InitContainers: []corev1.Container{ @@ -148,6 +160,12 @@ func (c *ConfigMapUnpacker) job(cmRef *corev1.ObjectReference, bundlePath string corev1.ResourceMemory: resource.MustParse("50Mi"), }, }, + SecurityContext: &corev1.SecurityContext{ + AllowPrivilegeEscalation: pointer.Bool(false), + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, + }, }, { Name: "pull", @@ -170,6 +188,12 @@ func (c *ConfigMapUnpacker) job(cmRef *corev1.ObjectReference, bundlePath string corev1.ResourceMemory: resource.MustParse("50Mi"), }, }, + SecurityContext: &corev1.SecurityContext{ + AllowPrivilegeEscalation: pointer.Bool(false), + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, + }, }, }, Volumes: []corev1.Volume{ @@ -193,7 +217,10 @@ func (c *ConfigMapUnpacker) job(cmRef *corev1.ObjectReference, bundlePath string job.SetNamespace(cmRef.Namespace) job.SetName(cmRef.Name) job.SetOwnerReferences([]metav1.OwnerReference{ownerRef(cmRef)}) - + if c.runAsUser > 0 { + job.Spec.Template.Spec.SecurityContext.RunAsUser = &c.runAsUser + job.Spec.Template.Spec.SecurityContext.RunAsNonRoot = pointer.Bool(true) + } // By default the BackoffLimit is set to 6 which with exponential backoff 10s + 20s + 40s ... // translates to ~10m of waiting time. // We want to fail faster than that when we have repeated failures from the bundle unpack pod @@ -246,6 +273,7 @@ type ConfigMapUnpacker struct { loader *configmap.BundleLoader now func() metav1.Time unpackTimeout time.Duration + runAsUser int64 } type ConfigMapUnpackerOption func(*ConfigMapUnpacker) @@ -335,6 +363,12 @@ func WithNow(now func() metav1.Time) ConfigMapUnpackerOption { } } +func WithUserID(id int64) ConfigMapUnpackerOption { + return func(unpacker *ConfigMapUnpacker) { + unpacker.runAsUser = id + } +} + func (c *ConfigMapUnpacker) apply(options ...ConfigMapUnpackerOption) { for _, option := range options { option(c) diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/certs/certs.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/certs/certs.go index e000ab2c5e..9ece822314 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/certs/certs.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/certs/certs.go @@ -71,13 +71,13 @@ func GenerateCA(notAfter time.Time, organization string) (*KeyPair, error) { caDetails := &x509.Certificate{ SerialNumber: serial, Subject: pkix.Name{ + CommonName: fmt.Sprintf("olm-selfsigned-%x", serial), Organization: []string{organization}, }, NotBefore: notBefore, NotAfter: notAfter, IsCA: true, - ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth}, - KeyUsage: x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign, + KeyUsage: x509.KeyUsageCertSign, BasicConstraintsValid: true, } @@ -120,12 +120,12 @@ func CreateSignedServingPair(notAfter time.Time, organization string, ca *KeyPai certDetails := &x509.Certificate{ SerialNumber: serial, Subject: pkix.Name{ + CommonName: hosts[0], Organization: []string{organization}, }, NotBefore: notBefore, NotAfter: notAfter, - ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth}, - KeyUsage: x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign, + ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth}, BasicConstraintsValid: true, DNSNames: hosts, } diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/operator.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/operator.go index 658cd93a34..536d51bece 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/operator.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/operator.go @@ -125,7 +125,7 @@ type Operator struct { type CatalogSourceSyncFunc func(logger *logrus.Entry, in *v1alpha1.CatalogSource) (out *v1alpha1.CatalogSource, continueSync bool, syncError error) // NewOperator creates a new Catalog Operator. -func NewOperator(ctx context.Context, kubeconfigPath string, clock utilclock.Clock, logger *logrus.Logger, resync time.Duration, configmapRegistryImage, opmImage, utilImage string, operatorNamespace string, scheme *runtime.Scheme, installPlanTimeout time.Duration, bundleUnpackTimeout time.Duration) (*Operator, error) { +func NewOperator(ctx context.Context, kubeconfigPath string, clock utilclock.Clock, logger *logrus.Logger, resync time.Duration, configmapRegistryImage, opmImage, utilImage string, operatorNamespace string, scheme *runtime.Scheme, installPlanTimeout time.Duration, bundleUnpackTimeout time.Duration, workloadUserID int64) (*Operator, error) { resyncPeriod := queueinformer.ResyncWithJitter(resync, 0.2) config, err := clientcmd.BuildConfigFromFlags("", kubeconfigPath) if err != nil { @@ -194,7 +194,7 @@ func NewOperator(ctx context.Context, kubeconfigPath string, clock utilclock.Clo op.sources = grpc.NewSourceStore(logger, 10*time.Second, 10*time.Minute, op.syncSourceState) op.sourceInvalidator = resolver.SourceProviderFromRegistryClientProvider(op.sources, logger) resolverSourceProvider := NewOperatorGroupToggleSourceProvider(op.sourceInvalidator, logger, op.lister.OperatorsV1().OperatorGroupLister()) - op.reconciler = reconciler.NewRegistryReconcilerFactory(lister, opClient, configmapRegistryImage, op.now, ssaClient) + op.reconciler = reconciler.NewRegistryReconcilerFactory(lister, opClient, configmapRegistryImage, op.now, ssaClient, workloadUserID) res := resolver.NewOperatorStepResolver(lister, crClient, operatorNamespace, resolverSourceProvider, logger) op.resolver = resolver.NewInstrumentedResolver(res, metrics.RegisterDependencyResolutionSuccess, metrics.RegisterDependencyResolutionFailure) @@ -433,6 +433,7 @@ func NewOperator(ctx context.Context, kubeconfigPath string, clock utilclock.Clo bundle.WithUtilImage(utilImage), bundle.WithNow(op.now), bundle.WithUnpackTimeout(op.bundleUnpackTimeout), + bundle.WithUserID(workloadUserID), ) if err != nil { return nil, err @@ -1404,13 +1405,6 @@ type UnpackedBundleReference struct { Properties string `json:"properties"` } -/* unpackBundles makes one walk through the bundlelookups and attempts to progress them -Returns: - unpacked: bool - If the bundle was successfully unpacked - out: *v1alpha1.InstallPlan - the resulting installPlan - error: error -*/ - func (o *Operator) unpackBundles(plan *v1alpha1.InstallPlan) (bool, *v1alpha1.InstallPlan, error) { out := plan.DeepCopy() unpacked := true diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operator.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operator.go index d33945aee8..e0741dbb83 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operator.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operator.go @@ -11,6 +11,7 @@ import ( admissionregistrationv1 "k8s.io/api/admissionregistration/v1" corev1 "k8s.io/api/core/v1" rbacv1 "k8s.io/api/rbac/v1" + apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" extinf "k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions" apierrors "k8s.io/apimachinery/pkg/api/errors" "k8s.io/apimachinery/pkg/api/meta" @@ -1121,6 +1122,46 @@ func (a *Operator) handleClusterServiceVersionDeletion(obj interface{}) { logger.WithError(err).Warnf("failed to requeue gc event: %v", webhook) } } + + // Conversion webhooks are defined within a CRD. + // In an effort to prevent customer dataloss, OLM does not delete CRDs associated with a CSV when it is deleted. + // Deleting a CSV that introduced a conversion webhook removes the deployment that serviced the conversion webhook calls. + // If a conversion webhook is defined and the service isn't available, all requests against the CR associated with the CRD will fail. + // This ultimately breaks kubernetes garbage collection and prevents OLM from reinstalling the CSV as CR validation against the new CRD's + // openapiv3 schema fails. + // As such, when a CSV is deleted OLM will check if it is being replaced. If the CSV is not being replaced, OLM will remove the conversion + // webhook from the CRD definition. + csvs, err := a.lister.OperatorsV1alpha1().ClusterServiceVersionLister().ClusterServiceVersions(clusterServiceVersion.GetNamespace()).List(labels.Everything()) + if err != nil { + logger.Errorf("error listing csvs: %v\n", err) + } + for _, csv := range csvs { + if csv.Spec.Replaces == clusterServiceVersion.GetName() { + return + } + } + + for _, desc := range clusterServiceVersion.Spec.WebhookDefinitions { + if desc.Type != v1alpha1.ConversionWebhook || len(desc.ConversionCRDs) == 0 { + continue + } + + for i, crdName := range desc.ConversionCRDs { + crd, err := a.lister.APIExtensionsV1().CustomResourceDefinitionLister().Get(crdName) + if err != nil { + logger.Errorf("error getting CRD %v which was defined in CSVs spec.WebhookDefinition[%d]: %v\n", crdName, i, err) + continue + } + + copy := crd.DeepCopy() + copy.Spec.Conversion.Strategy = apiextensionsv1.NoneConverter + copy.Spec.Conversion.Webhook = nil + + if _, err = a.opClient.ApiextensionsInterface().ApiextensionsV1().CustomResourceDefinitions().Update(context.TODO(), copy, metav1.UpdateOptions{}); err != nil { + logger.Errorf("error updating conversion strategy for CRD %v: %v\n", crdName, err) + } + } + } } func (a *Operator) removeDanglingChildCSVs(csv *v1alpha1.ClusterServiceVersion) error { diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/config.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/config.go index 7ed0c8ee57..bd3e2acb94 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/config.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/config.go @@ -16,7 +16,7 @@ type operatorConfig struct { logger *logrus.Logger } -func (o *operatorConfig) GetConfigOverrides(ownerCSV ownerutil.Owner) (envVarOverrides []corev1.EnvVar, volumeOverrides []corev1.Volume, volumeMountOverrides []corev1.VolumeMount, tolerationOverrides []corev1.Toleration, resourcesOverride *corev1.ResourceRequirements, nodeSelectorOverride map[string]string, err error) { +func (o *operatorConfig) GetConfigOverrides(ownerCSV ownerutil.Owner) (envVarOverrides []corev1.EnvVar, volumeOverrides []corev1.Volume, volumeMountOverrides []corev1.VolumeMount, tolerationOverrides []corev1.Toleration, resourcesOverride *corev1.ResourceRequirements, nodeSelectorOverride map[string]string, affinity *corev1.Affinity, err error) { list, listErr := o.lister.OperatorsV1alpha1().SubscriptionLister().Subscriptions(ownerCSV.GetNamespace()).List(labels.Everything()) if listErr != nil { err = fmt.Errorf("failed to list subscription namespace=%s - %v", ownerCSV.GetNamespace(), listErr) @@ -40,6 +40,7 @@ func (o *operatorConfig) GetConfigOverrides(ownerCSV ownerutil.Owner) (envVarOve tolerationOverrides = owner.Spec.Config.Tolerations resourcesOverride = owner.Spec.Config.Resources nodeSelectorOverride = owner.Spec.Config.NodeSelector + affinity = owner.Spec.Config.Affinity return } diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/initializer.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/initializer.go index f8007368f7..12881bcc97 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/initializer.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/initializer.go @@ -45,7 +45,7 @@ func (d *DeploymentInitializer) initialize(ownerCSV ownerutil.Owner, deployment var envVarOverrides, proxyEnvVar, merged []corev1.EnvVar var err error - envVarOverrides, volumeOverrides, volumeMountOverrides, tolerationOverrides, resourcesOverride, nodeSelectorOverride, err := d.config.GetConfigOverrides(ownerCSV) + envVarOverrides, volumeOverrides, volumeMountOverrides, tolerationOverrides, resourcesOverride, nodeSelectorOverride, affinity, err := d.config.GetConfigOverrides(ownerCSV) if err != nil { err = fmt.Errorf("failed to get subscription pod configuration - %v", err) return err @@ -92,6 +92,10 @@ func (d *DeploymentInitializer) initialize(ownerCSV ownerutil.Owner, deployment return fmt.Errorf("failed to inject nodeSelector into deployment spec name=%s - %v", deployment.Name, err) } + if err = inject.OverrideDeploymentAffinity(podSpec, affinity); err != nil { + return fmt.Errorf("failed to inject affinity into deployment spec name=%s - %s", deployment.Name, err) + } + return nil } diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/inject/inject.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/inject/inject.go index 0eaa1532ac..50432767c9 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/inject/inject.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/inject/inject.go @@ -230,3 +230,71 @@ func InjectNodeSelectorIntoDeployment(podSpec *corev1.PodSpec, nodeSelector map[ return nil } + +// OverrideDeploymentAffinity will override the corev1.Affinity defined in the Deployment +// with the given corev1.Affinity. Any nil top-level sub-attributes (e.g. NodeAffinity, PodAffinity, and PodAntiAffinity) +// will be ignored. Hint: to overwrite those top-level attributes, empty them out. I.e. use the empty/default object ({}) +// e.g. NodeAffinity{}. In yaml: +// affinity: +// nodeAffinity: {} +// podAffinity: {} +// podAntiAffinity: {} +// will completely remove the deployment podSpec.affinity and is equivalent to +// affinity: {} +func OverrideDeploymentAffinity(podSpec *corev1.PodSpec, affinity *corev1.Affinity) error { + if podSpec == nil { + return errors.New("no pod spec provided") + } + + if affinity == nil { + return nil + } + + // if podSpec.Affinity is nil or empty/default then completely override podSpec.Affinity with overrides + if podSpec.Affinity == nil || reflect.DeepEqual(podSpec.Affinity, &corev1.Affinity{}) { + if reflect.DeepEqual(affinity, &corev1.Affinity{}) { + podSpec.Affinity = nil + } else { + podSpec.Affinity = affinity + } + return nil + } + + // if overriding affinity is empty/default then nil out podSpec.Affinity + if reflect.DeepEqual(affinity, &corev1.Affinity{}) { + podSpec.Affinity = nil + return nil + } + + // override podSpec.Affinity each attribute as necessary nilling out any default/empty overrides on the podSpec + if affinity.NodeAffinity != nil { + if reflect.DeepEqual(affinity.NodeAffinity, &corev1.NodeAffinity{}) { + podSpec.Affinity.NodeAffinity = nil + } else { + podSpec.Affinity.NodeAffinity = affinity.NodeAffinity + } + } + + if affinity.PodAffinity != nil { + if reflect.DeepEqual(affinity.PodAffinity, &corev1.PodAffinity{}) { + podSpec.Affinity.PodAffinity = nil + } else { + podSpec.Affinity.PodAffinity = affinity.PodAffinity + } + } + + if affinity.PodAntiAffinity != nil { + if reflect.DeepEqual(affinity.PodAntiAffinity, &corev1.PodAntiAffinity{}) { + podSpec.Affinity = nil + } else { + podSpec.Affinity.PodAntiAffinity = affinity.PodAntiAffinity + } + } + + // special case: if after being overridden, podSpec is the same as default/empty then nil it out + if reflect.DeepEqual(&corev1.Affinity{}, podSpec.Affinity) { + podSpec.Affinity = nil + } + + return nil +} diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/reconciler/configmap.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/reconciler/configmap.go index 0f8518d4c5..f264d1bee3 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/reconciler/configmap.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/reconciler/configmap.go @@ -23,6 +23,7 @@ import ( // configMapCatalogSourceDecorator wraps CatalogSource to add additional methods type configMapCatalogSourceDecorator struct { *v1alpha1.CatalogSource + runAsUser int64 } const ( @@ -101,7 +102,7 @@ func (s *configMapCatalogSourceDecorator) Service() *corev1.Service { } func (s *configMapCatalogSourceDecorator) Pod(image string) *corev1.Pod { - pod := Pod(s.CatalogSource, "configmap-registry-server", image, "", s.Labels(), s.Annotations(), 5, 5) + pod := Pod(s.CatalogSource, "configmap-registry-server", image, "", s.Labels(), s.Annotations(), 5, 5, s.runAsUser) pod.Spec.ServiceAccountName = s.GetName() + ConfigMapServerPostfix pod.Spec.Containers[0].Command = []string{"configmap-server", "-c", s.Spec.ConfigMap, "-n", s.GetNamespace()} ownerutil.AddOwner(pod, s.CatalogSource, false, false) @@ -162,10 +163,11 @@ func (s *configMapCatalogSourceDecorator) RoleBinding() *rbacv1.RoleBinding { } type ConfigMapRegistryReconciler struct { - now nowFunc - Lister operatorlister.OperatorLister - OpClient operatorclient.ClientInterface - Image string + now nowFunc + Lister operatorlister.OperatorLister + OpClient operatorclient.ClientInterface + Image string + createPodAsUser int64 } var _ RegistryEnsurer = &ConfigMapRegistryReconciler{} @@ -240,7 +242,7 @@ func (c *ConfigMapRegistryReconciler) currentPodsWithCorrectResourceVersion(sour // EnsureRegistryServer ensures that all components of registry server are up to date. func (c *ConfigMapRegistryReconciler) EnsureRegistryServer(catalogSource *v1alpha1.CatalogSource) error { - source := configMapCatalogSourceDecorator{catalogSource} + source := configMapCatalogSourceDecorator{catalogSource, c.createPodAsUser} image := c.Image if source.Spec.SourceType == "grpc" { @@ -389,7 +391,7 @@ func (c *ConfigMapRegistryReconciler) ensureService(source configMapCatalogSourc // CheckRegistryServer returns true if the given CatalogSource is considered healthy; false otherwise. func (c *ConfigMapRegistryReconciler) CheckRegistryServer(catalogSource *v1alpha1.CatalogSource) (healthy bool, err error) { - source := configMapCatalogSourceDecorator{catalogSource} + source := configMapCatalogSourceDecorator{catalogSource, c.createPodAsUser} image := c.Image if source.Spec.SourceType == "grpc" { diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/reconciler/grpc.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/reconciler/grpc.go index 4f63cc87aa..93e28e6286 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/reconciler/grpc.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/reconciler/grpc.go @@ -32,6 +32,7 @@ const ( // grpcCatalogSourceDecorator wraps CatalogSource to add additional methods type grpcCatalogSourceDecorator struct { *v1alpha1.CatalogSource + createPodAsUser int64 } type UpdateNotReadyErr struct { @@ -122,16 +123,17 @@ func (s *grpcCatalogSourceDecorator) ServiceAccount() *corev1.ServiceAccount { } func (s *grpcCatalogSourceDecorator) Pod(saName string) *corev1.Pod { - pod := Pod(s.CatalogSource, "registry-server", s.Spec.Image, saName, s.Labels(), s.Annotations(), 5, 10) + pod := Pod(s.CatalogSource, "registry-server", s.Spec.Image, saName, s.Labels(), s.Annotations(), 5, 10, s.createPodAsUser) ownerutil.AddOwner(pod, s.CatalogSource, false, false) return pod } type GrpcRegistryReconciler struct { - now nowFunc - Lister operatorlister.OperatorLister - OpClient operatorclient.ClientInterface - SSAClient *controllerclient.ServerSideApplier + now nowFunc + Lister operatorlister.OperatorLister + OpClient operatorclient.ClientInterface + SSAClient *controllerclient.ServerSideApplier + createPodAsUser int64 } var _ RegistryReconciler = &GrpcRegistryReconciler{} @@ -198,7 +200,7 @@ func (c *GrpcRegistryReconciler) currentPodsWithCorrectImageAndSpec(source grpcC // EnsureRegistryServer ensures that all components of registry server are up to date. func (c *GrpcRegistryReconciler) EnsureRegistryServer(catalogSource *v1alpha1.CatalogSource) error { - source := grpcCatalogSourceDecorator{catalogSource} + source := grpcCatalogSourceDecorator{catalogSource, c.createPodAsUser} // if service status is nil, we force create every object to ensure they're created the first time overwrite := source.Status.RegistryServiceStatus == nil || !isRegistryServiceStatusValid(&source) @@ -447,7 +449,7 @@ func (c *GrpcRegistryReconciler) removePods(pods []*corev1.Pod, namespace string // CheckRegistryServer returns true if the given CatalogSource is considered healthy; false otherwise. func (c *GrpcRegistryReconciler) CheckRegistryServer(catalogSource *v1alpha1.CatalogSource) (healthy bool, err error) { - source := grpcCatalogSourceDecorator{catalogSource} + source := grpcCatalogSourceDecorator{catalogSource, c.createPodAsUser} // Check on registry resources // TODO: add gRPC health check if len(c.currentPodsWithCorrectImageAndSpec(source, source.ServiceAccount().GetName())) < 1 || diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/reconciler/reconciler.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/reconciler/reconciler.go index 6089d2e777..45bf8dcba4 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/reconciler/reconciler.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/reconciler/reconciler.go @@ -10,6 +10,7 @@ import ( "k8s.io/apimachinery/pkg/api/resource" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/rand" + "k8s.io/utils/pointer" operatorsv1alpha1 "github.com/operator-framework/api/pkg/operators/v1alpha1" controllerclient "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/controller-runtime/client" @@ -61,6 +62,7 @@ type registryReconcilerFactory struct { OpClient operatorclient.ClientInterface ConfigMapServerImage string SSAClient *controllerclient.ServerSideApplier + createPodAsUser int64 } // ReconcilerForSource returns a RegistryReconciler based on the configuration of the given CatalogSource. @@ -69,18 +71,20 @@ func (r *registryReconcilerFactory) ReconcilerForSource(source *operatorsv1alpha switch source.Spec.SourceType { case operatorsv1alpha1.SourceTypeInternal, operatorsv1alpha1.SourceTypeConfigmap: return &ConfigMapRegistryReconciler{ - now: r.now, - Lister: r.Lister, - OpClient: r.OpClient, - Image: r.ConfigMapServerImage, + now: r.now, + Lister: r.Lister, + OpClient: r.OpClient, + Image: r.ConfigMapServerImage, + createPodAsUser: r.createPodAsUser, } case operatorsv1alpha1.SourceTypeGrpc: if source.Spec.Image != "" { return &GrpcRegistryReconciler{ - now: r.now, - Lister: r.Lister, - OpClient: r.OpClient, - SSAClient: r.SSAClient, + now: r.now, + Lister: r.Lister, + OpClient: r.OpClient, + SSAClient: r.SSAClient, + createPodAsUser: r.createPodAsUser, } } else if source.Spec.Address != "" { return &GrpcAddressRegistryReconciler{ @@ -92,17 +96,18 @@ func (r *registryReconcilerFactory) ReconcilerForSource(source *operatorsv1alpha } // NewRegistryReconcilerFactory returns an initialized RegistryReconcilerFactory. -func NewRegistryReconcilerFactory(lister operatorlister.OperatorLister, opClient operatorclient.ClientInterface, configMapServerImage string, now nowFunc, ssaClient *controllerclient.ServerSideApplier) RegistryReconcilerFactory { +func NewRegistryReconcilerFactory(lister operatorlister.OperatorLister, opClient operatorclient.ClientInterface, configMapServerImage string, now nowFunc, ssaClient *controllerclient.ServerSideApplier, createPodAsUser int64) RegistryReconcilerFactory { return ®istryReconcilerFactory{ now: now, Lister: lister, OpClient: opClient, ConfigMapServerImage: configMapServerImage, SSAClient: ssaClient, + createPodAsUser: createPodAsUser, } } -func Pod(source *operatorsv1alpha1.CatalogSource, name string, image string, saName string, labels map[string]string, annotations map[string]string, readinessDelay int32, livenessDelay int32) *corev1.Pod { +func Pod(source *operatorsv1alpha1.CatalogSource, name string, image string, saName string, labels map[string]string, annotations map[string]string, readinessDelay int32, livenessDelay int32, runAsUser int64) *corev1.Pod { // Ensure the catalog image is always pulled if the image is not based on a digest, measured by whether an "@" is included. // See https://github.com/docker/distribution/blob/master/reference/reference.go for more info. // This means recreating non-digest based catalog pods will result in the latest version of the catalog content being delivered on-cluster. @@ -125,8 +130,6 @@ func Pod(source *operatorsv1alpha1.CatalogSource, name string, image string, saN podAnnotations[key] = value } - readOnlyRootFilesystem := false - pod := &corev1.Pod{ ObjectMeta: metav1.ObjectMeta{ GenerateName: source.GetName() + "-", @@ -179,7 +182,11 @@ func Pod(source *operatorsv1alpha1.CatalogSource, name string, image string, saN }, }, SecurityContext: &corev1.SecurityContext{ - ReadOnlyRootFilesystem: &readOnlyRootFilesystem, + ReadOnlyRootFilesystem: pointer.Bool(false), + AllowPrivilegeEscalation: pointer.Bool(false), + Capabilities: &corev1.Capabilities{ + Drop: []corev1.Capability{"ALL"}, + }, }, ImagePullPolicy: pullPolicy, TerminationMessagePolicy: corev1.TerminationMessageFallbackToLogsOnError, @@ -188,10 +195,19 @@ func Pod(source *operatorsv1alpha1.CatalogSource, name string, image string, saN NodeSelector: map[string]string{ "kubernetes.io/os": "linux", }, + SecurityContext: &corev1.PodSecurityContext{ + SeccompProfile: &corev1.SeccompProfile{ + Type: corev1.SeccompProfileTypeRuntimeDefault, + }, + }, ServiceAccountName: saName, }, } + if runAsUser > 0 { + pod.Spec.SecurityContext.RunAsUser = &runAsUser + pod.Spec.SecurityContext.RunAsNonRoot = pointer.Bool(true) + } // Override scheduling options if specified if source.Spec.GrpcPodConfig != nil { grpcPodConfig := source.Spec.GrpcPodConfig diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/lib/filemonitor/cabundle_updater.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/lib/filemonitor/cabundle_updater.go index 4fcee4e457..58f577ef45 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/lib/filemonitor/cabundle_updater.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/lib/filemonitor/cabundle_updater.go @@ -2,7 +2,7 @@ package filemonitor import ( "crypto/x509" - "io/ioutil" + "os" "sync" "github.com/fsnotify/fsnotify" @@ -16,7 +16,7 @@ type certPoolStore struct { } func NewCertPoolStore(clientCAPath string) (*certPoolStore, error) { - pem, err := ioutil.ReadFile(clientCAPath) + pem, err := os.ReadFile(clientCAPath) if err != nil { return nil, err } @@ -31,7 +31,7 @@ func NewCertPoolStore(clientCAPath string) (*certPoolStore, error) { } func (c *certPoolStore) storeCABundle(clientCAPath string) error { - pem, err := ioutil.ReadFile(clientCAPath) + pem, err := os.ReadFile(clientCAPath) if err == nil { c.mutex.Lock() defer c.mutex.Unlock() diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/storage/subresources.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/storage/subresources.go index 45d30bd59b..455da45dc6 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/storage/subresources.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/storage/subresources.go @@ -3,7 +3,7 @@ package storage import ( "context" "encoding/base64" - "io/ioutil" + "io" "net/http" "strconv" "strings" @@ -68,7 +68,7 @@ func (s *LogoStorage) Connect(ctx context.Context, name string, options runtime. etag := `"` + strings.Join([]string{name, pkgChannel.Name, pkgChannel.CurrentCSV}, ".") + `"` reader := base64.NewDecoder(base64.StdEncoding, strings.NewReader(data)) - imgBytes, _ := ioutil.ReadAll(reader) + imgBytes, _ := io.ReadAll(reader) return imgBytes, mimeType, etag } diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/util/cpb/main.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/util/cpb/main.go index ae9912bf97..5b1769bb37 100644 --- a/vendor/github.com/operator-framework/operator-lifecycle-manager/util/cpb/main.go +++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/util/cpb/main.go @@ -2,7 +2,6 @@ package main import ( "fmt" - "io/ioutil" "os" "path/filepath" @@ -118,7 +117,7 @@ func getMetadata() (m *metadata, err error) { m.annotationsFile = path // Unmarshal metadata - content, err := ioutil.ReadFile(path) + content, err := os.ReadFile(path) if err != nil { return fmt.Errorf("couldn't get content of annotations.yaml file: %s", path) } diff --git a/vendor/modules.txt b/vendor/modules.txt index ee062bc7a0..5753922b17 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -633,7 +633,7 @@ github.com/openshift/client-go/config/informers/externalversions/config github.com/openshift/client-go/config/informers/externalversions/config/v1 github.com/openshift/client-go/config/informers/externalversions/internalinterfaces github.com/openshift/client-go/config/listers/config/v1 -# github.com/operator-framework/api v0.15.0 => ./staging/api +# github.com/operator-framework/api v0.16.0 => ./staging/api ## explicit; go 1.18 github.com/operator-framework/api/crds github.com/operator-framework/api/pkg/constraints