From d71d1952250741e8bef067bab9763c7424a01ec9 Mon Sep 17 00:00:00 2001 From: Per Goncalves da Silva Date: Fri, 29 Jul 2022 11:29:11 -0300 Subject: [PATCH 01/15] Add node affinity and pod (anti)affinity to Subscription spec.config (#250) Signed-off-by: perdasilva Upstream-repository: api Upstream-commit: f8da7254a5aabb477235d297f080af29f7fb0be4 --- .../0000_50_olm_00-subscriptions.crd.yaml | 457 ++++++++++++++++++ .../operators.coreos.com_subscriptions.yaml | 457 ++++++++++++++++++ staging/api/crds/zz_defs.go | 2 +- .../operators/v1alpha1/subscription_types.go | 12 + .../v1alpha1/zz_generated.deepcopy.go | 15 + .../operators.coreos.com_subscriptions.yaml | 457 ++++++++++++++++++ .../operator-framework/api/crds/zz_defs.go | 2 +- .../operators/v1alpha1/subscription_types.go | 12 + .../v1alpha1/zz_generated.deepcopy.go | 15 + 9 files changed, 1427 insertions(+), 2 deletions(-) diff --git a/manifests/0000_50_olm_00-subscriptions.crd.yaml b/manifests/0000_50_olm_00-subscriptions.crd.yaml index ce6b6c9e93..efa67ddfe0 100644 --- a/manifests/0000_50_olm_00-subscriptions.crd.yaml +++ b/manifests/0000_50_olm_00-subscriptions.crd.yaml @@ -175,11 +175,468 @@ spec: optional: description: Specify whether the Secret must be defined type: boolean + 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 nodeSelector: description: 'NodeSelector is a selector which must be true for the pod to fit on a node. Selector which must match a node''s labels for the pod to be scheduled on that node. More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/' type: object additionalProperties: 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 resources: description: 'Resources represents compute resources required by this container. Immutable. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/' type: object diff --git a/staging/api/crds/operators.coreos.com_subscriptions.yaml b/staging/api/crds/operators.coreos.com_subscriptions.yaml index 7bcc8c94f1..0e2bd8d983 100644 --- a/staging/api/crds/operators.coreos.com_subscriptions.yaml +++ b/staging/api/crds/operators.coreos.com_subscriptions.yaml @@ -173,11 +173,468 @@ spec: optional: description: Specify whether the Secret must be defined type: boolean + 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 nodeSelector: description: 'NodeSelector is a selector which must be true for the pod to fit on a node. Selector which must match a node''s labels for the pod to be scheduled on that node. More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/' type: object additionalProperties: 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 resources: description: 'Resources represents compute resources required by this container. Immutable. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/' type: object diff --git a/staging/api/crds/zz_defs.go b/staging/api/crds/zz_defs.go index 3578ef32e0..68b9d3530c 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\x6b\x77\xe3\xb6\xd5\x28\xfc\x3d\xbf\x02\xcb\xed\x5a\xb6\x5b\x49\x9e\xe9\xd3\xd3\xf6\xf8\xe9\x6a\x97\x63\x7b\x52\x9f\xcc\xc5\x67\xec\x24\xeb\x79\xd3\x9c\x16\x22\x21\x09\x35\x09\x30\x00\x28\x8f\x7a\xf9\xef\xef\xc2\xde\x00\x08\x52\x37\x52\x96\x2f\x93\x90\x1f\x92\x31\x05\x80\xc0\xc6\xc6\xbe\x61\x5f\x68\xc1\xbf\x65\x4a\x73\x29\x4e\x09\x2d\x38\xfb\x64\x98\xb0\x7f\xe9\xd1\xdd\x1f\xf4\x88\xcb\x93\xf9\xeb\x2f\xee\xb8\x48\x4f\xc9\x79\xa9\x8d\xcc\x3f\x32\x2d\x4b\x95\xb0\x0b\x36\xe1\x82\x1b\x2e\xc5\x17\x39\x33\x34\xa5\x86\x9e\x7e\x41\x08\x15\x42\x1a\x6a\x5f\x6b\xfb\x27\x21\x89\x14\x46\xc9\x2c\x63\x6a\x38\x65\x62\x74\x57\x8e\xd9\xb8\xe4\x59\xca\x14\x0c\xee\x3f\x3d\x7f\x35\xfa\xc3\xe8\xd5\x17\x84\x24\x8a\x41\xf7\x5b\x9e\x33\x6d\x68\x5e\x9c\x12\x51\x66\xd9\x17\x84\x08\x9a\xb3\x53\xa2\xcb\xb1\x4e\x14\x2f\xe0\x13\x23\x59\x30\x45\x8d\x54\x7a\x94\x48\xc5\xa4\xfd\x5f\xfe\x85\x2e\x58\x62\x3f\x3e\x55\xb2\x2c\x4e\xc9\xca\x36\x38\x9c\x9f\x23\x35\x6c\x2a\x15\xf7\x7f\x13\x32\x24\x32\xcb\xe1\xdf\xb8\xf6\x9b\xe8\xab\xf0\x3a\xe3\xda\x7c\xbd\xf4\xd3\x5b\xae\x0d\xfc\x5c\x64\xa5\xa2\x59\x63\xb6\xf0\x8b\x9e\x49\x65\xde\x57\xdf\xb6\xdf\xd2\xe5\x38\xfe\xb7\x6b\xc8\xc5\xb4\xcc\xa8\xaa\x0f\xf2\x05\x21\x3a\x91\x05\x3b\x25\x30\x46\x41\x13\x96\x7e\x41\x88\x83\xa3\x1b\x73\x48\x68\x9a\xc2\xde\xd0\xec\x5a\x71\x61\x98\x3a\x97\x59\x99\x8b\xf0\x4d\xdb\x26\x65\x61\xd4\x53\x72\x3b\x63\xa4\xa0\xc9\x1d\x9d\x32\xff\xbd\x31\x4b\x89\x91\xa1\x03\x21\xff\xd0\x52\x5c\x53\x33\x3b\x25\x23\x0b\xe2\x91\x85\x60\xf4\x33\xee\xcf\x35\x0e\x12\xbd\x37\x0b\x3b\x5d\x6d\x14\x17\xd3\x4d\x9f\x4f\xa8\xa1\x99\x9c\x12\xc4\x2f\x32\x91\x8a\x98\x19\x23\xf6\x53\x7c\xc2\x59\xea\xe7\xb7\x61\x46\xd8\x75\x69\x4e\x37\xcd\xd7\xad\xa7\x34\xa3\x42\xb0\x8c\xc8\x09\x29\x8b\x94\x1a\xa6\x89\x91\x15\x7c\x36\x83\xc7\x75\x5e\x9a\xcd\xf9\xd2\xfb\x15\xd3\xc1\xa6\xf3\xd7\x34\x2b\x66\xf4\xb5\x7b\xa9\x93\x19\xcb\x69\xb5\x87\xb2\x60\xe2\xec\xfa\xea\xdb\xff\xba\x69\xfc\x40\xea\x4b\x89\x51\x94\xdc\x31\x56\xe8\xea\x50\x90\xb2\xb0\x6b\xb2\x8b\x23\xe3\x05\x31\x8a\x26\x77\x5c\x4c\x61\xe9\x53\x5c\xef\x39\x6e\x8c\x1e\x2d\x4d\x59\x8e\xff\xc1\x12\x13\xbd\x56\xec\xc7\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\x11\xb9\x61\xca\x76\xb4\x07\xb6\xcc\x52\x4b\xc7\xe6\x4c\x19\xa2\x58\x22\xa7\x82\xff\x33\x8c\x06\x20\xb2\x9f\xc9\x2c\x7e\x18\x02\xc7\x4d\xd0\x8c\xcc\x69\x56\xb2\x01\xa1\x22\x25\x39\x5d\x10\xc5\xec\xb8\xa4\x14\xd1\x08\xd0\x44\x8f\xc8\x3b\xa9\x18\xe1\x62\x22\x4f\xc9\xcc\x98\x42\x9f\x9e\x9c\x4c\xb9\xf1\x14\x38\x91\x79\x5e\x0a\x6e\x16\x27\x40\x4c\xf9\xb8\xb4\x1b\x77\x92\xb2\x39\xcb\x4e\x34\x9f\x0e\xa9\x4a\x66\xdc\xb0\xc4\x94\x8a\x9d\xd0\x82\x0f\x61\xb2\x02\x49\x64\x9e\xfe\x42\x39\x9a\xad\x0f\x1b\xe0\x5b\x79\x0e\x88\xa7\x7a\x1b\x61\x6d\x89\x1f\xe1\x9a\x50\xd7\x1d\xd7\x52\x81\xd4\xbe\xb2\x50\xf9\x78\x79\x73\x4b\xfc\x04\x10\xec\x08\xe1\xaa\xa9\xae\x80\x6d\x01\xc5\xc5\x84\x29\x6c\x39\x51\x32\x87\x51\x98\x48\x0b\xc9\x85\x81\x3f\x92\x8c\x33\x61\xec\x31\xcc\xb9\xd1\x80\x73\x4c\x1b\xbb\x0f\x23\x72\x0e\x0c\x88\x8c\x99\x3b\xb0\xe9\x88\x5c\x09\x72\x4e\x73\x96\x9d\x53\xcd\x1e\x1d\xd4\x16\xa2\x7a\x68\xc1\xd7\x1e\xd8\x31\xff\x5c\xee\xb0\x74\xc6\x08\xf1\x0c\x6e\xed\xee\xc4\x07\xfe\xa6\x60\x49\x38\x0e\x54\x90\xb3\xa2\xc8\x78\x82\x18\x6f\x66\xd4\x90\x84\x0a\x0b\x2f\x2e\xb4\xa1\x59\x06\xec\xa4\xd5\x2c\xd6\x9d\x76\x02\x47\xbb\xc1\x1c\xfc\xeb\x25\x0a\x5d\xff\x21\x30\xb5\x46\x8b\x75\x94\xc1\x3e\x8e\xce\x2e\xff\xb0\x01\xe4\x04\x25\x93\x09\x9f\xae\xea\xb6\x16\x96\xe7\xd0\x05\x64\x1a\xca\x85\x76\x43\x94\x0a\xa1\x59\x71\x2a\xcb\xbb\x68\x8d\x6f\x8f\xd6\xce\x6e\x25\x64\xb7\xad\xd9\x3e\x4c\xcc\x57\xff\xd0\x58\xc0\xa5\x98\xe3\x41\xb5\x32\x8b\x25\x72\x4c\xcc\xb9\x92\x22\xb7\x87\x68\x4e\x15\xa7\xe3\xcc\x31\x36\x66\xc9\x17\x9e\x31\x5c\x22\x53\xab\x8e\xd4\x9a\xaf\xe2\x7a\xa8\x52\x74\xb1\xa6\x05\x37\x2c\x5f\xb3\x9a\x55\xd3\xfe\x96\xaa\x88\x4a\x58\xe4\x5d\x35\x75\xe2\x1a\xd8\xa9\x53\x72\x1e\x26\xbe\xf6\x33\x5b\xe0\x8e\xcf\x7a\xdc\xae\x9e\x35\x58\xee\x9f\x6d\x1b\x88\x0f\x70\xfa\x0d\xbf\x37\xc0\x62\x4f\x08\x32\x30\xb6\x12\x1a\x23\xf2\xae\xd4\xb0\x5b\x94\x9c\xff\xed\xea\xe2\xf2\xfd\xed\xd5\x9b\xab\xcb\x8f\xeb\xc1\x41\xb6\x1d\x94\xea\x01\x1a\xdf\x61\xb2\x87\xdf\xfa\x3d\x52\x6c\xc2\x14\x13\x09\xd3\xe4\x97\x47\xdf\x9e\x7d\xfc\xdb\xfb\xb3\x77\x97\xc7\x84\x2a\x46\xd8\xa7\x82\x8a\x94\xa5\xa4\xd4\x9e\x69\x14\x8a\xcd\xb9\x2c\x75\xb6\x70\x94\x2b\x5d\x83\xb4\x4d\x6c\x05\x6e\x4b\xc5\x82\x68\xa6\xe6\x3c\x59\x0d\x22\x3d\x22\x57\x13\x42\x2b\x04\x4a\x02\x86\x5b\x46\x95\xcd\x59\x3a\x80\x61\xc3\xa4\xfd\x77\xb8\x28\x4a\xe3\x19\xde\x3d\xcf\x32\x38\x15\x02\x65\xa5\x74\x44\x2e\x64\x69\xc7\xfb\xe5\x2f\x61\x61\x8a\xa5\x65\x02\x42\xb4\x25\x06\x5c\x4c\xed\x4f\x03\x72\x3f\xe3\xc9\x8c\xd0\x2c\x93\xf7\x1a\x28\x05\xd3\x09\x2d\xfc\xd2\x63\xe8\xe8\x85\x30\xf4\xd3\x29\xe1\x23\x36\x22\x07\xbf\x8c\x7e\x3a\xc0\xaf\x17\x4a\xda\x4f\xa0\x9c\x8c\xb3\xca\xb8\x61\x8a\x66\xe4\x20\x6e\x3d\x22\x97\xf6\x1b\x2c\x8d\xf7\x01\x46\x10\x6c\xce\x94\x5d\x85\xdf\x85\x01\x51\x6c\x4a\x55\x9a\x31\xad\x2d\x9e\xdd\xcf\x98\x99\x31\x14\xc5\x03\xc0\xd8\x27\x6e\x19\xae\x54\x44\x48\x33\x22\x17\x6c\x42\xcb\x0c\x38\x30\x39\x38\x18\x35\x19\xdf\xee\xa8\xf6\x46\xc9\xbc\x03\xba\xdd\xd4\x35\x87\x55\x7b\x7f\xa8\x71\xe4\x1a\x59\xd3\x2c\x25\x7c\xe2\x24\x18\xae\xed\xa2\x08\xcb\x0b\xb3\x68\x73\x68\xb6\xd0\x11\xd2\x9a\x10\x90\xc0\x93\xde\xd1\xe2\x6b\xb6\xf8\xc8\x26\xdb\x9a\x37\xd7\xcf\x32\x96\x58\x42\x49\xee\xd8\x02\xc4\x59\x72\xee\x07\xdc\xbc\x94\x4e\xcb\x21\x2d\xc9\xa3\x7f\x86\x76\x3a\x5b\xdb\xb5\x07\x92\x7d\xee\xd8\xa2\x4d\x33\xb2\xac\xd3\x59\xd0\x00\xaf\xb3\xb0\xda\x0e\x15\xd2\x1e\x65\xfd\xb3\x9d\xa2\xaf\x9c\xdc\x61\x4c\xda\xdd\x39\x35\x2b\x05\xd6\xbb\x72\xcc\x94\x60\x86\x81\xcc\x9a\xca\x44\x5b\x71\x35\x61\x85\xd1\x27\x72\x6e\x29\x1f\xbb\x3f\xb9\x97\xca\x2a\x72\xc3\x7b\x6e\x66\x43\xdc\x55\x7d\x02\x46\x8f\x93\x5f\xc0\xff\xc8\xed\x87\x8b\x0f\xa7\xe4\x2c\x4d\x89\x84\x23\x5e\x6a\x36\x29\x33\x32\xe1\x2c\x4b\xf5\x28\xd2\xba\x06\xa0\x0f\x0c\x48\xc9\xd3\x3f\x6f\x3e\xdc\x3b\x42\x4c\x16\x68\xac\xd8\x01\x6a\x37\x20\x74\x2d\x6a\x74\x2a\x20\xbd\xa5\x50\x56\x45\xb0\x7b\x9e\x3b\xb6\xe8\x18\x4a\x87\x65\x8c\xa5\xcc\x18\x15\x5b\x7a\x00\xd8\xba\x9f\xd9\xc3\xea\xd0\xc2\x08\x1e\x01\x0a\x99\x9e\x12\x5d\x16\x85\x54\x46\x07\x15\x01\x6c\x2e\x83\xfa\x9f\x20\x2f\x0f\xc8\xdf\xc3\xcb\x8c\x8e\x59\xa6\xbf\x3f\x3c\xfc\xe3\xd7\x97\xff\xf3\xa7\xc3\xc3\x1f\xfe\x1e\xff\x1a\x59\xe8\xea\x4d\xd0\xa6\x23\x53\x10\xc2\xdd\x9f\x8e\x8d\x9e\x25\x89\x2c\x85\x71\x3f\x18\x6a\x4a\x3d\x9a\x49\x6d\xae\xae\xc3\x9f\x85\x4c\x9b\x7f\xe9\x2d\x9c\x80\x3c\x2e\xd1\x01\x70\x5e\x53\x33\xdb\x33\xe9\x59\x6f\x8d\x58\xfd\xd4\xb6\xdb\xdb\x27\xdc\x2e\x3b\x83\x84\xfd\xe7\x1b\x3f\x5d\xcb\x81\xee\x15\x37\x86\x09\x90\x3b\x98\xca\x2d\x27\x1e\x58\xcc\xad\xd8\xec\xfc\xf5\xc1\xa3\x10\xaf\x00\xb5\x1d\x16\x07\xb3\x77\x2b\x43\x64\x0e\x84\xd6\x4b\x50\x95\x8e\x74\x76\x7d\xe5\x2d\x33\x7b\x5f\x88\xb7\x37\xbc\x79\xf0\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\x47\x49\x51\x0e\x5c\x83\x51\xce\x72\xa9\x16\xe1\x4f\x56\xcc\x58\x6e\x25\xb6\xa1\x36\x52\xd1\x29\x1b\x84\xee\xd8\x2d\xfc\x85\x1d\x6b\x1f\x58\xee\x8d\x22\x75\x52\x2a\xcb\x3c\xb2\x85\xa7\x20\x2c\x7d\xde\xb3\xe8\xc1\xb4\xe7\xa3\x18\x76\xe3\xfd\x8e\x2c\x37\x68\x8b\xce\xe0\xea\x57\x05\x32\xe4\x5c\x66\x65\xce\xf4\x20\xb0\x27\x94\xd6\xc5\xdc\x4a\x93\x4b\xe6\x9d\xd5\x4f\xc7\xd3\x97\xf2\x39\xd7\x52\xed\xcc\x07\xb9\x33\x79\xca\xd2\x58\x4d\x65\x22\x55\x4e\x4d\x50\x17\x3f\x15\x52\x83\x0e\xe0\x70\xb6\x41\x52\x5e\x1f\xb4\xfa\x6c\x41\x8d\x61\x4a\x9c\x92\xff\x77\xf4\xd7\x5f\xff\x7b\x78\xfc\xe7\xa3\xa3\xef\x5f\x0d\xff\xf7\x0f\xbf\x3e\xfa\xeb\x08\xfe\xf1\xab\xe3\x3f\x1f\xff\xdb\xff\xf1\xeb\xe3\xe3\xa3\xa3\xef\xbf\x7e\xf7\xd5\xed\xf5\xe5\x0f\xfc\xf8\xdf\xdf\x8b\x32\xbf\xc3\xbf\xfe\x7d\xf4\x3d\xbb\xfc\xa1\xe5\x20\xc7\xc7\x7f\xfe\x65\xab\xe9\x51\xb1\xf8\xd0\xe2\xc0\xe3\x33\x74\x1b\xc4\x85\x61\x53\xa6\x3a\xf6\x6a\xbd\xad\x84\x7c\x1a\x56\x42\xdb\x90\x0b\x33\x94\x6a\x88\xdd\x4f\x89\x51\xe5\xf6\x83\x51\x11\xb5\x5d\xf0\xfc\xa3\x3f\xad\x91\x29\xd6\x93\xe6\xbd\x23\xb2\x66\x89\x62\x66\x5f\x1a\x0c\x8e\xe6\xf9\x47\x21\xd3\x43\x4d\xc4\x1a\x33\xe1\xba\x69\xff\x2c\x94\x1a\x2f\x52\x20\xbc\x2a\xce\x3b\x51\x32\x1f\x91\xc8\x2c\x34\xa7\x19\x4f\x7d\xbb\x3b\xb6\x45\xcb\xf5\x4f\xaf\x04\x7d\x5e\x4a\xd0\x0d\xee\xef\xa3\x6b\x40\x4c\xcc\x37\x99\x69\x9a\x36\x5d\xdb\xb6\x6e\x8e\xf6\x02\x94\x91\xa4\x90\x45\x99\x51\xb3\xc6\x6c\xb7\xc2\x36\xed\x70\x5f\x07\x33\xa1\xdd\x68\xb0\x03\x3b\x2a\x97\xaf\x36\x86\x92\xb3\x2c\x23\x5c\xe0\x49\x80\x01\xbc\x35\x4f\x31\x94\x97\x08\x45\x83\xf3\xdc\x4e\xe1\x7e\xc6\x9a\x86\x46\xae\xad\xae\xa3\x0c\x17\xd3\x11\xf9\xce\xfe\x8e\x34\xcb\x99\xc6\xb8\x20\x79\x99\x19\x5e\x64\x8c\x04\x6e\x8b\x36\xb4\xac\x64\x84\x6a\x2d\x13\x4e\x8d\x9b\xb1\xbb\x3f\xd4\xc6\x4f\x1b\x66\x63\xe8\x1d\x98\x42\x13\x96\x32\x91\xb0\x11\xf9\x16\xae\x0b\xc3\x5a\xc7\x56\x18\x04\xf3\x3e\x8c\x41\x49\x5a\xe2\xd5\x0e\xd2\x83\xd5\x63\x5c\xe5\x79\x69\xc0\x50\xfc\x54\x56\x7c\xbb\xe3\xce\x32\x17\x19\xf3\x81\x54\x05\xd1\x9a\xc2\xdd\x83\x9c\x54\xaa\xbb\x7e\x98\xf9\xbe\x1d\xe1\x0d\xe6\xb6\xad\x9c\x6a\x89\xe2\x56\x36\x86\x3a\xa5\x7d\x6a\x8b\x61\x3b\x3a\xfb\x93\xa4\xb1\x1d\xe8\x6b\x7b\xda\xda\xc1\xb8\xd4\x95\x9e\xb6\xb5\x26\x15\x8a\x4d\xf8\xa7\x0e\xf8\x78\x26\x2a\x15\x85\xa7\x4c\x18\xab\x08\x28\x20\xa8\x8a\x15\x4c\x80\x1e\xce\x68\x32\x03\xba\xe0\xa8\x68\x65\x19\x7e\xcc\x1b\x23\x94\x32\xba\x1f\xaf\x9b\x55\x52\x4c\x7f\xb6\x7e\xe2\x67\xcb\xed\xfa\xfe\x0f\x96\x90\x29\x3b\x9b\x80\xc7\xe2\x5a\x11\xbb\x36\xbb\x0b\x86\x2e\x5e\x1a\xba\x12\xea\xfa\x82\xc1\x2e\x2d\x33\x2e\xa6\x44\x95\x56\x26\xf1\x97\x4d\x85\xdc\x72\x2f\xbe\x11\x33\xdb\xe0\x64\x01\xe8\xa4\x58\x7a\x51\xda\x5d\xb9\x09\x33\xb9\x9a\x0a\x19\x5e\x5f\x7e\x62\x49\x69\xb6\x18\x27\x97\x8e\x9b\x5b\x16\x53\xfe\x5e\x91\x4d\x90\x80\xf8\x1f\xec\xfa\x40\x44\xb3\xe0\xd0\xe8\x38\xa2\xa9\xe1\x7a\xb2\x80\xe5\x07\x00\xb1\x4f\x96\xc5\x83\x33\x62\x64\xec\x1b\x2f\x9c\x43\x8f\x45\xcb\x01\x19\x97\x86\x70\x03\xde\x3e\xc9\x4c\x4a\x6d\x49\x0f\xc0\x19\xc6\x9d\x73\x09\xbe\x54\x44\x0a\x66\xe5\xd7\xdc\x1e\x9e\xca\x86\xe1\x87\x47\xe9\xaf\xea\xc6\x35\xc9\xa5\x36\x15\x9c\xec\x1b\x30\x86\x08\x56\x49\x59\x53\xc5\xd0\x4f\x4b\x97\x39\xdc\x6f\x32\x3e\x9d\x19\x3d\xc0\x4b\x56\x30\xf0\x58\x42\x59\x0d\x9b\x33\x66\x15\xd2\x2c\x8b\x6d\xb6\x1e\x05\x50\x61\xcc\x41\xa2\x39\x0a\xaa\xb5\x33\xcf\x0d\x82\x42\xd9\xdc\xb1\x95\xe0\x1a\x10\x66\x92\xd1\xf1\x80\x24\x32\x2f\x4a\xc3\xc0\x83\x24\xb7\xa0\x83\x2b\x5d\xe7\x51\xa5\x64\x39\xc5\x95\xb0\xcc\x7d\xd8\xbb\xb3\xa1\xc9\x15\x6e\xc0\xd3\xd4\xb6\x3e\xc0\xc5\x1d\x78\x0f\x35\x3b\x1c\xc7\x45\xc0\xfa\x72\x6a\x92\x99\xb3\x18\x25\x52\x29\xa6\x0b\x29\xa0\x27\xfc\x72\x59\xcd\xed\xbf\x43\xa7\x23\x7d\x5c\x01\x73\xc6\xa7\x33\x0f\x4b\xaa\xf0\x1e\xba\xbe\x07\x9b\x98\xc8\x76\x49\x93\x6c\x97\x36\x97\xd0\xf9\x4c\xe0\xdd\x6d\x84\x07\xd1\x8e\x19\xa6\xf2\xb0\x6e\xd8\x54\x24\xaa\xb8\x26\x9e\x5b\x01\x9a\x1b\x87\x15\xe4\x15\x39\x02\xb4\xe0\xe6\x50\x03\x8a\x0e\x65\x71\x3c\x22\x67\xe0\x92\xdc\xe2\x03\x42\x86\xf1\xdd\x40\xf6\xa3\x5a\x56\x63\xed\x87\xa5\xb5\x35\x5c\x0c\xdd\x9c\xad\x2a\xb0\xb5\x29\xc2\x60\x4f\xac\xb4\xfa\x6e\x47\x36\x71\x86\xa8\x8a\x52\x80\xa5\xb5\x4c\xe5\x83\x95\xfa\x53\x1d\x83\x71\xf6\x7b\xbe\xf5\xee\x66\xce\x69\x1e\xa2\x1d\x14\xfb\xb3\xa0\x25\xd7\xa1\x50\x23\x3c\xe3\x05\xfc\x7a\xa8\x09\xde\xfc\x75\xb1\xe7\x6c\x3b\x7d\xd5\xd3\xe2\x1c\xae\x5d\xc4\xda\xc9\x3b\x0f\xd2\xb0\xb9\xe0\x8f\xe8\xbd\xeb\xd0\x3b\x76\x80\x8a\xf5\xc0\xb9\xf6\x04\xcf\x65\x6c\xac\x18\xb2\x0a\xe3\x8c\x60\xb6\x91\xf3\xaa\x6d\x39\xd5\x4e\x08\x80\x4f\x17\x3b\x21\x3e\xed\xac\x85\x55\x6b\xbf\xc8\x96\x5d\xba\xe1\x25\x3e\xad\x8d\x8d\xf8\x2c\x89\x0c\x80\x6b\xe8\x4d\x61\x37\x02\x4d\x8f\x6e\x1f\x69\x51\x64\x70\x15\x21\xdb\xee\x02\xe9\x6e\x2f\xc3\xc7\x43\x6a\xe7\xb5\x7c\x8c\x1c\x0c\xed\x72\x0e\x35\x22\x95\x3d\xb1\x33\x5e\x38\xef\x2d\xb4\x4e\x78\x7f\xed\x6f\xc1\x6e\x54\xf9\xd0\x5b\xde\x77\x25\x06\xe4\xbd\x34\xf6\x7f\x97\x60\x03\x1a\x90\x0b\xc9\xf4\x7b\x69\xe0\xcf\x11\xf9\xca\x20\x0e\xbf\x6d\xe9\x75\xf2\x00\xa0\xe0\x3c\x77\x06\xc9\x99\x40\xba\x00\xd6\xb9\xc8\xbb\x1b\x1d\xe7\x40\xa4\xf2\x87\x90\x6b\x72\x25\xac\x90\xe6\x96\x1e\x4c\x5c\xda\x0d\xe1\x65\x79\x21\xc5\x10\x7d\xaa\x56\x8d\x71\x19\x1c\xca\x62\x98\x6d\x18\x6e\xfd\x50\x5f\x81\xcd\xf3\xed\xda\xce\x33\x3a\x67\x95\x3f\x9e\x13\xa2\xbc\x57\x9e\xb7\x02\x82\x13\x7f\xa1\x58\x65\x08\x74\x37\x44\x56\xe8\xe4\x7e\x3c\x0c\x21\xc8\x68\xc2\x52\x92\x82\x88\x87\xee\xf0\xd4\xb0\x29\x4f\x48\xce\xd4\x94\x91\xc2\x72\x81\xee\x3b\xde\x9e\x30\xe3\xd3\x89\x3c\xc7\x1f\x6a\x8d\x5a\xc0\xce\xe0\x46\xfd\x09\x38\x99\xd3\x5f\x7b\x4e\xd6\x73\xb2\xad\x4f\xcf\xc9\x7a\x4e\xb6\x06\x24\x3d\x27\xeb\x39\x59\xfd\x41\xbd\xb0\xa3\x12\xfa\x1d\x9a\x03\x9a\x5a\x27\x70\x44\xef\xb8\x5f\x57\x3f\x2d\x9f\xb8\x71\x44\xe4\x16\x54\x56\x67\x76\x57\x54\x4c\x19\x79\x3d\x7c\xfd\xea\x55\x5b\xe5\xb4\xad\x73\x0a\x7a\xfb\x40\xfb\xff\xfa\xcd\xda\xd6\xeb\x6c\x52\x0f\xb4\x22\x3a\xfc\x0d\x86\xad\x1a\x5f\x5f\x63\x08\x04\x6a\x23\xa4\x21\x39\x33\x84\x9a\x9a\x19\x85\xe7\x6c\xe0\x0d\xab\x2e\x54\x01\xbd\xf5\xbd\x45\x32\x25\x52\x38\xbb\x96\x05\xf6\x68\xb7\x19\x24\x8c\x6a\xf0\x85\x19\xb3\x30\x0b\x99\xdb\xaf\x72\x61\xfc\x51\xb0\x53\x60\x1e\x22\xe4\x88\x8d\xa6\x23\x92\x96\xd0\x8d\x0a\x17\x15\x75\x8c\xb3\xd5\x0b\x6d\x58\x0e\x96\x4d\xa9\xe0\x7f\x76\xda\x46\x81\xcf\x39\x5c\x26\x97\x34\xcb\x16\x84\xcd\x79\x62\xc2\xfa\x20\xce\x91\x1b\x34\x36\x6f\x37\x99\x6d\x65\xf1\xed\xd8\xfa\x70\x09\x4b\xd7\x5f\xba\xb6\xe7\xcc\x4b\x63\x6e\x3b\x6b\x0d\x1e\x86\x33\x1f\xad\x15\x18\xc1\x1f\x16\x6d\xbf\xe8\x1a\x6b\x91\xe8\xc3\xc7\xcd\xa6\x46\xd2\x89\x1a\xb5\xa4\x40\x4d\xd1\xb0\xcc\x32\xbb\xe9\x68\x7d\x5c\x9e\xf4\x0a\xab\x20\x2e\xa3\x86\xa8\x68\x64\x46\x73\xea\xd9\xfb\x0b\x0b\x09\xdb\xe6\x56\x16\x32\x93\xd3\x45\x0c\x59\x58\x11\xd8\x2c\x5d\x5f\x0c\x39\x64\xc1\xe1\xef\x7d\x63\x2b\x7a\x6b\xd8\x96\x85\xf7\x3a\x44\xaf\x43\xb4\x7a\x7a\x1d\xa2\xd7\x21\x7a\x1d\xe2\xe7\xaa\x43\x90\xde\x1a\xd6\x73\x32\x78\x7a\x4e\xd6\xe2\xe9\x39\xd9\xbe\x80\xd2\x73\xb2\x9e\x93\xb5\xfd\xd0\x06\xd4\x8a\x55\xf4\x56\xde\x70\x87\xb1\x26\xd9\xa0\xed\x08\x60\xbf\x7f\x46\x95\x2c\xf6\x89\xb3\xc7\x6c\xc2\x0d\x91\xc2\xb9\x78\x8d\xc8\xcd\x8a\x9e\xc0\x4d\x5d\x8b\xc3\xa0\xba\x35\x07\x6a\x58\x7f\x90\x40\xe1\xa0\x1d\x1d\x2c\x6b\x89\x7b\x4e\xa8\xd6\x7c\x2a\x86\x85\x4c\x87\x76\xb4\x93\x75\xee\x91\x2d\x58\x4a\x9c\x78\x6f\x3b\xed\xde\xba\x53\x85\x4c\x77\x74\x5b\xb4\x20\x5b\xef\xb5\x88\x36\xac\x44\x0e\x33\x09\xf1\x02\x60\x11\xb3\x5d\x7c\x98\x2e\xcd\xd1\xac\x36\x20\xff\x94\x82\xa1\x6b\x9a\x3d\x31\x60\x1c\x43\x4f\xd3\x42\xa6\x47\xfa\x78\xad\x0b\x53\xef\xf5\xd8\x7b\x3d\xbe\x48\xaf\xc7\x19\xd5\xb8\xaf\x8e\xfe\xac\x75\x82\x8c\x0e\xdf\x2d\x53\xf9\x67\xe4\x03\x69\x51\xc4\x6d\x31\x44\xd7\x54\xdb\x88\xab\x4d\xdd\x8d\x06\x4b\xaf\xeb\x6b\x74\x9a\x06\x2c\x84\xa6\x29\x4b\x49\xc1\xd4\x10\xd1\xc2\x12\x72\x91\xae\x58\x9f\x87\xc9\x93\xfb\x32\xd6\xe7\xfe\xc4\x0e\x8d\xf5\x8f\x77\xb4\x16\xc7\x66\xee\x1a\xa5\x7e\x56\xf7\xc6\x6e\xf1\xaf\xc6\x99\xa4\xbf\xde\x7b\x1c\x2c\x70\xff\x6d\x02\x4a\xfd\x69\x6a\xd7\xa0\xc4\xfc\x58\x32\xb5\x20\x72\xce\x54\x25\xea\x47\xc1\xef\xc0\xeb\xb8\x26\x09\xd5\x48\xe9\xbb\x28\xd8\x1d\x14\xcb\xee\x5a\xdc\x6e\xb6\x72\xd2\x84\x43\x73\x98\x7a\xdc\x25\xc2\x68\xa5\xe9\x61\xc5\xbd\x44\x75\x1f\xd1\x7a\x2e\xbb\x08\xbc\x9d\xc5\xdd\x95\x1b\xff\x42\x4d\x12\x64\x37\xb3\x04\xd9\xc9\x34\x41\x3a\x9b\x27\xc8\x2e\x26\x0a\xb2\xa3\x99\x82\x74\x37\x55\x90\xe6\x76\x43\x34\x9b\x76\xc1\xb3\xfb\xb6\x5a\x90\x5d\x95\x74\xb2\xa3\xf5\x62\x69\x79\x01\xfd\xd4\x63\x99\x32\x00\x87\x6b\xd6\x8c\xa7\x02\x50\x77\x4b\xc6\x12\x78\x9c\x09\x80\x83\x1a\xff\x99\xd8\x35\x1e\xdd\xc8\x40\x76\x36\x34\x90\xdd\x8c\x0d\x64\x37\x2c\x00\xd6\xf4\x16\xb4\xfc\x87\x30\x37\x1c\x01\x49\x7b\x4e\x0b\x8b\x00\xff\xb2\x14\x1c\xf6\xe0\x3f\xa4\xa0\x5c\x69\x2b\x63\x39\xab\x50\xfc\x9b\xd3\x74\xe3\x61\xec\x08\x5c\x13\x4b\x6a\xe7\x34\xb3\x3c\x03\x3d\x3c\x9c\xce\x61\x47\x6f\xb2\xd4\x01\xb9\x9f\x59\x4d\xce\x52\x1e\xd4\x44\xb8\x26\x07\x77\x6c\x71\x30\x58\x42\x9a\x83\x2b\x71\x80\xbc\x65\x09\x4d\x02\x23\x82\xa4\x52\x07\xf0\xdb\xc1\x3e\xb9\x70\x47\x86\xd3\xcd\x8c\xb1\xee\xa3\x9d\x92\x85\x40\x3e\x97\xfd\x0a\x7d\xc8\x05\xf0\x9a\xc5\x7f\x41\x57\x0c\x02\x9c\x32\x22\xe6\x10\x7c\x4a\x00\x9f\xe0\x7d\xea\x95\xc8\x52\x44\x59\xdb\xa2\xc1\x90\xc9\x2c\x3b\x36\xb9\x4d\x96\x02\x32\x83\x69\xdb\xc2\x21\x5c\xd4\x19\xda\x8e\xd0\x71\xa4\xe2\x56\x22\x6d\xba\x92\x54\x3d\x40\x76\xcb\x19\x15\x9a\x1c\x78\x9b\x4d\x9c\x0f\xe7\x60\x54\xc5\xbf\x85\x11\x8f\xfe\xf5\x9f\xe3\x5a\xcc\x5b\x35\x60\x2f\xf1\xf6\x12\x6f\x2f\xf1\xf6\x12\x6f\x78\x7a\x89\xf7\xb1\x00\xd4\x4b\xbc\xbd\xc4\xdb\x4b\xbc\xbd\xc4\x8b\x4f\x25\x82\xed\x20\xea\xc6\xf2\x67\x48\xfb\x49\x21\xf7\x32\x4f\x2a\xcf\x22\xdf\x0a\xff\xb5\x5f\xb9\x37\x96\x69\x57\x4b\xbd\xb1\x64\xbc\x24\xdf\x8f\xb6\x88\xb8\x41\x08\x5e\xea\xb9\x59\xfa\x7d\x7e\x0f\xa9\x8e\x78\x10\x19\xd1\x77\x4a\xfd\xe8\xae\x6d\x5d\x91\xaa\x31\xab\xee\x74\x53\x72\xe4\x6f\x15\x8e\x5d\xa5\x86\xfa\x8f\xc2\xf0\x61\xd5\x22\xdc\x33\xc0\xd5\x58\x2d\xb2\xa5\x66\x8e\x5f\x4e\xe4\x5c\xed\x9d\x25\x0d\x4c\xd5\xe6\xc0\xab\x74\x75\x54\x13\x55\x0a\x61\x47\x0d\xde\x00\x8e\x96\x60\x52\x3c\x87\x65\x28\xd8\xc0\x7c\x30\x57\x7f\x80\x50\x74\x57\x87\x59\x6d\xa9\x70\x8e\xf6\x52\xf8\xb2\x1a\x22\x4a\x84\xe9\x10\x10\x56\xc4\xc3\xd7\x47\xe4\x12\x70\x2e\x1e\xd8\x15\x7d\x80\xa2\x1c\x6d\x49\xcd\x63\x07\x1d\xdd\x77\x0e\x3a\x6a\xdc\x49\xf5\x31\x47\x3f\xd1\x98\x23\xf8\x11\x8f\xc9\xde\x83\x8f\x30\x97\xa5\x81\x73\x6c\x41\x15\xb2\x58\xfa\x8b\x77\xfc\x54\x86\xd2\xe0\xc4\x79\x46\xd4\xf1\xd0\x67\x9b\x6b\xe0\x23\x8c\x07\x1e\x58\x1a\x0e\xa6\xf3\x3e\xa0\x59\xe6\x22\x79\xbc\xe8\x88\x2e\x16\xfc\x39\x6e\xce\x2f\x7c\xa1\x34\xaf\x5d\x00\xf1\x38\xb2\x34\x2e\xb3\x9b\x68\xa9\xd5\x06\xe2\x88\x4a\xca\x9c\x79\xf6\x39\xe5\x73\x26\x2a\x0a\x79\xa4\x8f\x8f\x3d\x1f\xde\x2b\xe5\x7e\x14\xca\xfb\xc7\x88\x42\xfe\xa9\x0d\xed\x85\x05\x05\xea\x5b\x81\xaf\xa2\xbd\x4f\xed\x22\xd0\xf6\x8e\xba\xbd\x3e\xdf\xf1\x6e\xfa\x89\xee\xa5\x5f\x76\xdc\xd6\x33\x5a\xe5\x9e\xd2\x1b\xfe\x45\x5b\xe2\x7a\x77\xf8\x56\xcf\xd3\x59\xdb\x9e\xc7\x2b\xfe\x85\x5b\xd8\x9e\xc3\x2b\xbe\xb7\xaa\xad\xdd\x88\x97\xe0\xac\x5e\x7f\x3a\x5b\xd1\x7a\x0b\xda\x4e\x1c\xb3\x03\xa3\x78\x88\xe5\xac\xc3\xee\xef\x70\x47\xdc\xdf\x0f\x3f\xfe\xfd\x70\x2f\x79\x6e\x04\x4c\x2f\x79\xf6\x92\x67\xbb\xa7\x97\x3c\x7b\xc9\xb3\x97\x3c\x7b\xc9\xb3\x97\x3c\x5f\xac\xe4\xd9\x35\x27\x54\x7f\x4f\xbb\xf3\x3d\x6d\x17\x2a\xd0\xfa\xec\x77\xd8\xf3\x4e\xf7\xb2\xfd\x9d\xec\x4b\xb8\x93\x6d\x15\x4c\x2d\x0c\x7f\x48\x40\x75\xbc\x3f\xeb\xa2\xaa\xe9\x5c\xf2\x94\x14\xa5\x71\xb1\xab\x7d\x64\xf5\x2e\x91\xd5\x35\x48\xf7\xe1\xd5\xad\xc2\xab\xd7\xc1\xac\x8f\xb1\xee\x63\xac\x6b\x4f\x1f\x63\xdd\xc7\x58\xf7\x31\xd6\x7d\xc4\xc9\x2e\x0b\x7e\xe1\xd6\x46\xd2\x47\x9c\xd4\x9e\x3e\xe2\x64\xe3\xf2\x5e\xb8\x55\xf2\x41\x00\xea\x23\x4e\xfa\x88\x93\x3e\xe2\xa4\x8f\x38\xc1\xa7\x8f\xb1\x7e\xb1\x77\xe8\xa4\x97\x78\x7b\x89\xb7\x97\x78\x1b\x4f\x2f\xf1\x36\x9f\x5e\xe2\xdd\xf2\xf4\x12\x6f\x2f\xf1\xf6\x12\x6f\x2f\xf1\xe2\xd3\xc7\x58\xf7\x31\xd6\xa4\x8f\xb1\xfe\x5c\xef\xf3\x3b\xee\x74\x1f\x63\xfd\xa8\x31\xd6\xb5\xbb\xe5\xe7\x0b\xb4\xee\x3e\x8d\x3e\xda\xba\x8f\xb6\xee\xa3\xad\xd7\xed\x68\x1f\x6d\xdd\x47\x5b\xf7\x31\x2f\x7d\xcc\xcb\x8a\xa7\x8f\x79\xe9\x63\x5e\x56\x3c\x7d\xcc\x4b\x1f\xf3\xb2\xf6\xe9\x6d\x69\x3f\xb5\x98\x97\x3e\xda\xfa\x25\xdd\x14\xf7\x92\xe7\x46\xc0\xf4\x92\x67\x2f\x79\xb6\x7b\x7a\xc9\xb3\x97\x3c\x7b\xc9\xb3\x97\x3c\x7b\xc9\xf3\xc5\x4a\x9e\x7d\xb4\x75\x1f\x6d\xbd\xea\xe9\x6f\x67\x5f\xc2\xed\xec\xd6\xdd\x0d\x26\xf6\x56\x71\xd6\x87\x1f\x7d\xf3\x58\x62\xf1\xf1\xaa\x2a\xfa\x11\x65\xd5\xa0\xe1\x39\xea\xc8\xd4\x88\x5c\xe5\x79\x69\xe8\x38\x7b\x68\x39\xf0\x9c\x0a\x3a\x65\x43\xf7\xf1\x61\xf8\xf8\x30\x7c\xeb\x21\x15\xc2\xdb\x08\xb7\x19\xcf\xb9\xd9\x78\xc8\xea\xc0\x7b\x0b\xed\xdd\xcb\xb1\xd3\x1f\x72\xfa\x89\xe7\x65\x4e\x68\x2e\x4b\x64\x50\xcb\xe0\xf4\xdb\xbd\x17\x80\xad\x00\x94\x5e\x0b\xa9\x96\xd0\x22\x3b\x31\x9e\x82\x1a\xc3\x94\x38\x25\xff\xef\xe8\xaf\xbf\xfe\xf7\xf0\xf8\xcf\x47\x47\xdf\xbf\x1a\xfe\xef\x1f\x7e\x7d\xf4\xd7\x11\xfc\xe3\x57\xc7\x7f\x3e\xfe\xb7\xff\xe3\xd7\xc7\xc7\x47\x47\xdf\x7f\xfd\xee\xab\xdb\xeb\xcb\x1f\xf8\xf1\xbf\xbf\x17\x65\x7e\x87\x7f\xfd\xfb\xe8\x7b\x76\xf9\x43\xcb\x41\x8e\x8f\xff\xfc\xcb\x8d\xd3\xa2\x62\xf1\x61\xd2\xe2\x1a\xad\x83\x77\xc0\xb0\x3d\x99\xfd\x34\xac\x76\x74\xc8\x85\x19\x4a\x35\xc4\x6e\xa7\x50\xb6\x7f\xa3\x67\x01\xd3\x5d\xf0\xf1\xa3\xeb\xd1\xc4\x48\x2e\xb6\x62\xa4\x0a\x51\xbb\x57\x13\x12\xc6\xe1\x9a\xc8\x9c\x1b\x4b\xcb\x26\x56\x13\xab\x8e\xfd\x80\x70\x63\x09\x2c\x2d\x33\x03\x09\x05\xdc\x59\x80\x68\x74\x0c\xe0\x67\x9f\x8a\x8c\x27\xdc\x64\x8b\x8a\x66\x0f\x30\xd5\xc2\x3d\x47\xdf\x00\x2a\x08\xcf\x0b\x14\xe5\x00\xa7\x87\x9e\x66\x03\x61\xee\xcf\x47\x7f\x3e\x56\x9f\x0f\xbd\xc5\x3c\x5a\x3b\x17\x95\x04\x11\x1b\x1b\x82\x7d\xc1\x62\xb6\x4f\x8b\x01\x72\x0c\xe2\x90\x3d\x0b\xa0\x2e\x5a\xb9\xe1\x23\xb3\xb8\x4c\x6f\x98\xd1\x4e\x72\x80\x1e\x56\xf6\x5f\x32\x7e\x82\x63\xcd\x98\x55\xc2\x27\x9d\x4c\xea\x2d\x52\x56\x64\x72\x61\x91\x7e\x44\xae\x0c\x2a\x9f\x20\x61\x04\x77\x15\xc3\xf2\x22\xa3\x86\x1d\x6a\x9c\xed\x5a\x3b\xd4\x9e\x38\x5f\x17\x2b\xe4\xf3\xda\x1e\x1f\xc7\x23\xe6\x45\x5a\x17\x1f\xc1\x55\x64\xbb\xfd\xb0\xa5\xd5\xb0\xbd\xad\xb0\x95\x85\xf0\xb1\xed\x82\x1d\x94\xa2\xf6\x36\xc0\x97\x6f\xf9\xeb\xb0\xec\xb6\x56\xbe\xde\xb6\xb7\x09\xd4\xcf\xa1\xcb\xb7\xb4\xd9\xf5\x96\xba\x0e\xfc\xe5\x11\x84\xbf\xad\x7b\x69\x64\xc6\x50\x72\x6d\xa7\xbb\xdf\x56\xed\x43\x76\x26\xb4\x41\x45\x23\x6d\x96\x1b\x36\xa1\xeb\x16\x24\x5d\x4a\xca\x04\x62\x8b\x3d\x5b\xd5\xbc\x00\xb5\x8c\xa1\x90\x96\xc9\x48\x3f\x2f\xbb\x71\x62\x41\xec\x9e\x19\x97\x97\x2b\x4a\x54\x65\x14\x78\xe2\xfe\x31\x60\xdb\x80\x81\xfc\xf4\x27\x52\x6a\x6f\x18\x0a\x56\xa2\x80\x21\x7f\xf4\xff\xfa\xd3\xfa\xcd\x6d\xb5\xb5\xed\x18\x1b\x4e\xa9\x83\x80\x71\x09\x1d\x08\x17\x29\x4f\x82\x30\x80\x10\xc0\xb1\x2c\x7c\x60\x59\xde\x4a\x84\xa6\x45\x14\x0b\xc1\x7b\x38\x6a\xac\x9d\x07\x73\xa4\x57\x39\x93\x42\x75\x32\x18\x79\x2f\x9d\x3b\x3a\x1b\x90\x6b\xc8\x68\x55\xbd\x81\x93\xf4\x5e\xa2\x63\x3a\x6b\x23\x87\x6c\xe5\x22\x5b\x19\x7d\x0d\x20\x5f\x57\x4c\x1e\x57\x56\x63\xf2\x15\x06\xd7\x6c\xc3\x9b\x20\x73\xc7\x16\x15\xb3\x71\x22\x04\x90\xfc\x41\x85\x25\x9e\x15\x20\xef\xf8\x6f\x6f\xca\xca\xc7\x5c\xe0\xc7\x70\x68\xbf\x15\x30\xba\x07\xa8\x95\xec\xb2\x0c\x3f\xb3\x0f\x70\xb5\x93\x33\x6a\x30\xfb\xd0\x41\xc6\x08\x54\x72\xb5\x74\x11\x89\x14\x97\x3f\x96\x34\x1b\x91\x8b\x48\x99\x77\xaf\x5c\xa3\x25\xaa\x7e\xcf\xb3\x34\xa1\x0a\x8d\x02\x78\x46\x89\x96\xb8\x7b\xe8\x1f\x9d\x50\x11\x4e\x7b\xb5\x47\x98\xb1\x8d\x14\x54\x19\x9e\x94\x19\x55\xc4\x9e\x85\xa9\x54\x8b\xbd\x40\xb4\x42\x9a\x1b\x96\x48\x91\x76\x4a\x2b\xd7\xec\x1b\xc3\x18\x28\x2b\x53\xdc\x39\x7e\xf3\x9c\x35\x91\xf4\xc8\x25\xdc\x73\xf8\x25\x27\xfe\x54\x87\x23\x56\xb3\x7c\x54\xb7\x14\x5c\x13\x8e\x91\x22\xc7\x11\x79\x0c\xa7\x62\x44\xbe\x5c\x78\x33\x0b\x98\x5c\x9c\xbd\x58\x33\x33\xf0\x49\xfe\x1c\xca\x3a\x60\x57\x07\x6a\x22\x15\x9b\x33\x45\x8e\x52\x09\x7d\x20\x20\xe2\x78\x44\xfe\x3f\xa6\x24\xde\x69\xb0\x29\xfa\xf1\x3b\x14\x0f\x8a\x2b\xa4\x55\x04\xbb\xf9\x2b\x72\x84\x71\x14\x3c\xcf\x59\xca\xa9\x61\xd9\xe2\x18\xf5\x58\x1f\x89\xd1\x66\xeb\xda\x18\x0d\xa2\x70\x9b\xdf\xfd\x76\x43\x4b\x98\x6c\x87\x9d\xfd\x16\x4c\xfc\x35\x52\x83\x56\xff\xc6\x16\x06\x1e\x24\x37\x88\x9b\x91\x78\x19\x5d\x7d\x78\x32\x13\x36\xf8\x1f\x16\x0f\x28\x51\x6c\x0a\x58\x8e\x98\xfb\x40\x1c\x9f\xcb\xac\xcc\xd9\x3b\x59\x8a\xf5\x26\xc1\xda\xc2\xdf\x3a\x25\xfc\xdb\xa8\x23\xe4\x02\x65\xc6\xcb\x6f\x95\x15\xff\x49\xc4\x84\x68\x26\x91\x89\x92\x12\xb0\x4b\x02\x3b\xb7\xe4\x01\x5b\xc1\x3d\x0c\x17\xb1\xcd\xf1\x81\x9c\xbd\x8d\x96\x3c\xc4\xb9\x5c\x53\x33\xdb\xd8\x4a\xd0\x7c\xbd\xe1\xb6\x9d\x08\x11\x3e\xd4\x01\x97\x6d\x73\x0f\x98\xda\xfe\x11\x6a\x1c\x39\x00\xfc\x44\x08\x56\x08\x0a\xdf\x62\xe9\x88\x90\x77\x16\x33\xf1\x46\x0e\xba\x92\xc3\xd3\xc3\xbd\x10\x5f\x5c\x8e\x92\x05\x9d\xd2\x6d\x91\x6e\x4d\x65\xa4\xd1\x95\xa4\xcc\x30\x95\x43\x88\xd2\x4c\xde\xe3\xef\xc8\xb6\x0a\xd7\x8a\xb9\x88\x2e\xc8\x52\x2a\x35\x70\xa5\x08\x18\xfe\xea\x17\xd2\xfa\xde\xd3\x05\xa1\x4a\x96\x22\x75\x52\x53\x20\xa0\xef\x1a\x1f\x7e\x2f\x05\x50\x8a\x52\x5b\x58\xdd\xd6\xa8\xf4\x98\x19\x6a\x8f\xcd\xeb\xd1\xeb\x2d\x91\x86\x2d\x01\x66\x51\xa8\x53\xde\x53\xae\x9b\x96\xc2\xf7\x34\x67\xf1\x99\xd9\xcb\xbc\x14\xa3\xe9\x07\x91\x75\x91\xe5\xde\x21\x7a\x41\xd7\x21\x28\x61\x7c\x02\xb6\xdb\x01\xbe\xba\x57\xdc\xb0\x88\x3c\x1e\x4d\x68\xa6\x21\x1d\x70\x29\x82\x08\x7b\x5c\x17\x41\xa0\x49\x9b\x05\x8d\xa5\xcc\x18\x15\x1b\x5a\xea\x72\xfc\xc0\x73\xe6\x0e\x14\xa0\x5c\x75\xcc\x02\xc2\x1d\xea\x0d\x47\x2e\x5e\xd4\xc1\x01\x39\xc2\x96\x56\x62\x93\xd2\xac\x4d\x36\x1d\xaf\x70\xeb\x96\xb9\x05\x5a\xcd\xba\x8b\x4a\xf2\xa9\xa0\x02\xf2\xe0\xee\x71\xb5\x5f\xb2\x19\x9d\x33\x4d\x34\xcf\x79\x46\x55\x06\x51\x99\x37\x38\x3f\x48\x15\xcd\xc4\x9c\x2b\x29\xc0\x24\x30\xa7\x8a\xd3\x71\x66\xd5\xf4\x09\x53\x4c\x24\x4c\x93\x5f\x1e\x7d\x7b\xf6\xf1\x6f\xef\xcf\xde\x5d\x1e\xc3\x89\x67\x7e\x96\x95\xf6\x17\xcf\x24\x1a\x6e\x2b\xa8\xfd\x3c\x2c\x9c\x80\x46\xf8\x79\x61\x08\xa8\x8f\x1b\xfd\x94\x64\xa5\xe6\xf3\x87\x9e\x26\xfc\xf8\x2e\xac\xba\xc9\xa5\x0b\x99\xde\x14\x2c\x79\x4a\x1e\x5d\xd7\x30\x2c\xa9\x4a\xfd\xa6\x03\x4f\x46\x65\x9f\x62\xda\xef\x31\x23\x34\x49\x98\xd6\x78\xc5\x61\x75\xfb\x8a\x16\x57\x6b\x78\x12\xf6\xbd\x07\xc6\x4c\xef\xf5\x65\x46\xb5\xe1\xc9\x97\x99\x4c\xee\x6e\x8c\x54\x5d\x08\xf5\xe1\xaa\xfe\x35\x78\x0a\x72\xf6\xdd\x0d\xb9\xe0\xfa\x2e\x5c\xc0\x86\x4b\xd3\xd8\x5c\x42\xc9\x5d\x39\x66\x19\x33\x87\x87\x1a\xb9\x5c\x4e\x93\x19\x17\xcc\x33\x38\x61\x4f\x87\xd4\x95\x83\x94\x85\x72\xd7\x3b\x53\x6d\xa4\xa2\x53\x76\xe2\xf0\xf5\x17\xf4\x5e\x33\x9c\xfe\xd8\x4e\xdf\xfe\xcc\x36\xdd\x96\x3e\xca\x3d\x05\x4e\xe6\xea\x62\x4f\x77\x10\x13\x7d\x6b\xe7\xd8\xcd\xb8\x7d\x88\xbd\xbc\xea\x30\xe1\x19\x73\xb1\xe7\x76\xc1\xde\xd9\xc7\x9d\x0a\xd8\xbf\x85\x2c\xc9\x3d\x45\x1d\x19\x28\xe2\x88\xdc\xf2\xe2\x94\x5c\x0a\x5d\x2a\x56\x59\x37\x9a\x43\x71\x4d\x74\x59\x14\x52\x85\x4b\x42\x27\xd5\xa0\x02\x62\xe9\x9e\xd3\xb5\xc8\xe5\x27\x9a\x17\x19\xd3\xa7\xe4\x80\x7d\x32\xbf\x3d\x18\x90\x83\x4f\x13\x6d\xff\x27\xcc\x44\x1f\x8c\xc8\x55\x1e\x6e\xdd\xb9\x70\x49\xcc\xf1\x62\x13\x3b\x58\xd6\x1c\x71\xdd\x47\x41\x17\x72\xfb\xe1\xe2\xc3\x29\xc8\x6e\xa9\x24\xf7\x56\x6c\x83\xc0\x7c\xc2\x94\x92\x4a\x7b\x9a\x10\x81\x01\x78\x4d\x22\xf3\x42\xc9\x9c\x47\x66\x3e\x40\xf7\xcd\xd8\x47\xba\xdd\x73\x80\xf1\x61\xbb\x80\xba\x8c\x0d\xa1\xa3\x47\x88\xe8\x85\x68\x83\x0a\x57\x13\xef\x4c\x81\x5a\xa4\x53\xeb\x61\x38\xd7\xc8\x6e\xbe\x1b\xc5\x12\xb2\x78\xbb\xdf\x48\xe5\x7f\x3a\x49\xd9\xfc\x44\xa7\xf4\xf5\x00\x3e\x83\x7b\xb9\x68\xcc\x89\x6a\x72\xf0\xfa\x60\x44\x6e\x3c\x23\x1e\xc4\x73\xac\xda\x4d\xa4\x0a\x03\x82\x9d\xfd\xd5\x01\x39\x92\x0a\x46\x4e\xa8\x20\x19\xa3\x73\x67\x5b\xc6\xe3\xb6\x40\x75\xf7\x78\xd4\x76\x5b\xf6\x9b\x6f\x03\x9f\x76\x42\xea\xf2\x26\xfa\x7e\xde\x04\xa0\x4a\x86\x66\x8f\x89\x44\x2a\xcc\xc2\xd0\x96\x03\xc3\xd1\xe3\xa2\xa6\x42\x3f\x03\x81\x25\x1d\x84\x5d\x12\x44\x8f\xab\x8b\xae\xd0\xf1\xfd\x40\x07\x12\xfc\xc7\x92\x91\xab\x0b\x4f\xe8\x0a\xa6\x34\xd7\xc6\x1e\xe3\xb4\xc6\xba\x38\xf2\xb3\xa3\xb3\x9c\xfe\x53\x0a\x72\xf9\xe5\x8d\x9b\xc0\xf1\xb3\x82\x6a\x2b\x35\xa0\xff\x2c\x15\xb3\x5c\xb8\x03\x73\x0f\x7d\x9a\x0c\xdd\xbe\x27\x17\xd4\x50\xe4\xeb\xce\xd3\x4a\x54\xa4\xdc\xb2\xec\x31\x17\xa9\xfb\x29\x62\xd8\x4f\xcd\x5b\xed\xee\xbd\xdf\x24\x26\xc5\x0d\xbf\xf9\x78\xb5\x27\x1e\x9c\x00\x31\x9f\xbe\x93\x69\x67\x46\x1c\x75\xf5\xc4\xf7\x2f\x16\xa6\xe7\xf8\x9e\xe4\x76\x4c\xf2\x1e\xea\xfa\x7c\x64\x34\x25\xf6\xfc\xba\x7f\x7e\x67\x75\xcf\xd6\xb4\xaa\x15\x0b\xf1\x00\xec\xb8\x0c\xdf\xcd\x2f\xc1\x6b\xef\xc0\x0b\x2c\xe6\xc0\xb1\x72\xbc\x64\x9c\xc9\x31\x71\xc7\x61\xdf\x73\xff\xe6\xe3\xd5\x0e\x53\xff\xe6\xe3\x95\x9f\xb9\xfd\xa7\x9c\x3c\xdd\xa4\x77\x12\xdf\x2a\xe9\xed\x4d\x43\xdc\xaa\x58\xf2\x3b\x67\xaf\xa7\x4b\x22\x59\x7b\x79\x6c\xb4\x2f\x49\x6c\x9f\x10\xbb\xe3\xa2\x45\x5c\x61\xfd\x94\xd9\x3e\x56\xa1\x40\x5f\xb5\xe8\x1e\xf1\x66\x46\x2d\x61\xa9\xb2\x24\xc1\x3e\xdb\x8d\xd7\x96\x2b\xf8\x1d\xb7\x4a\x20\xd0\x36\x72\xc1\xf0\x96\x33\x3d\xf5\xbe\x03\xa1\xc7\xea\x0e\xef\xc0\x53\x33\x75\xf4\x95\xa0\xe3\x66\x1a\x21\xd8\x11\x5a\x95\x44\xf8\x89\xce\x29\xcf\xe8\x98\x67\x50\x11\x8c\x59\xed\x3e\xf6\x46\xd5\x30\xe5\xbd\x9e\xfa\x1d\x45\x8e\x20\x4e\x2c\x19\xb7\xc8\x91\xfd\xed\x04\x8c\x63\xc7\x23\xa0\x56\xd0\x10\x22\x19\x1a\x42\xc9\xc7\x6d\x42\xc9\xde\xe4\x07\xd8\x01\x7b\x62\xba\x72\x45\xdb\x67\x25\x57\x84\x1f\x6e\x98\x9a\xf3\x84\xbd\x68\xc6\xa8\x59\xa2\x98\x69\xc5\x1a\x01\xbf\xb6\xb6\x6c\xcf\x1c\x1f\x8a\x5c\xe9\xe7\x81\x5c\x04\x5c\x77\x3d\x94\x3b\x2e\xb6\xea\xe8\xf9\x10\x28\x49\xe0\x71\x06\x3f\x35\x5c\x33\x11\xfb\x6e\x1c\xad\x39\x73\xb4\x06\xfa\x5b\x9c\x6b\x53\xdb\xa9\x03\x79\x08\x18\xd1\x75\x55\xbe\x9f\x5f\x14\x92\x40\x78\x4d\x5a\xe0\x62\xeb\x49\x26\xac\x98\x4d\xba\x5c\x89\xdb\x0e\x6f\x6e\xea\x96\xc0\x73\x56\xcc\xc8\x9b\x9b\x15\xc7\x18\x4b\x09\xda\x59\x6b\xb4\x0f\x1e\x6a\x92\xf1\x09\x33\x7c\xcb\x12\x1e\xe1\x20\xe7\x52\x70\x23\x95\xde\xd3\xe1\xf4\xc3\x75\x65\xa8\xbe\x9f\xdd\x59\x5f\x15\xed\x94\xbc\x8b\xde\x52\x92\xc8\x2c\x63\x89\x71\x71\x8d\x00\xde\xd0\x6d\x85\xf2\xc4\x9c\x3d\x60\x74\xf7\x07\x50\x9f\x9c\xa2\x74\x82\x9b\x7b\xf2\xf1\xf2\xec\xe2\xdd\xe5\x28\x4f\x7f\x31\x93\xf7\x43\x23\x87\xa5\x66\x43\x6e\xda\xf2\xc1\xe7\x8b\x44\x2c\xb6\xde\xcf\x90\x15\x06\x19\x33\xb3\x40\xfc\x50\xa0\x23\xde\x29\xf9\x46\xa3\xd7\x02\xd8\x8e\xfc\x9d\x94\x94\x66\x40\x14\x85\xab\x40\x33\xa3\xce\xf4\x54\x66\x19\x42\xdb\x28\xc6\x06\xb1\x2d\x66\x63\x68\x48\xe7\x85\x3d\xd8\x50\x51\x5b\xe0\xe3\xca\x10\x4f\x8f\x70\x5d\x38\xc6\x76\x99\x64\x19\x8a\x55\xcf\x3a\x1c\x6f\x6a\xef\xd1\x70\x66\x66\x16\xaa\x77\x6c\x41\xc0\x11\x78\x22\x95\xc5\x27\x55\xc7\x0d\x66\x12\x58\xfa\x49\xa9\x99\x1a\x39\xb6\xf3\xe4\x60\x6b\xc7\x90\x60\x72\x1f\xd9\xd6\xc8\x9e\xd5\x40\xfb\xc8\x26\xab\x60\xe6\x5e\x87\x0b\x3b\x2f\xaf\xd1\xd2\xcc\x98\x30\x56\xec\xb7\xb4\xcc\x41\x66\x25\x10\x9d\x1f\xf6\x93\x43\xed\x51\xd2\xf7\x6c\xbf\xc5\x5f\x0d\xe4\x58\xf9\x77\xc0\x34\x9d\xcd\x65\x72\x6e\xa5\x6a\x76\x7f\x72\x2f\xd5\x1d\x17\xd3\xe1\x3d\x37\xb3\x21\xae\x53\x9f\x40\x78\xf4\xc9\x2f\x30\xde\x1e\x2d\xf2\x67\x69\xea\x9c\x22\x4a\xcd\x26\x65\xe6\x6a\xa2\x8e\x08\x2d\xf8\xb7\x4c\x69\x2e\xc5\x00\x74\xc7\x01\x29\x79\xfa\xe7\xed\x90\x25\xdd\x70\xd2\x9e\x9a\xae\xe8\x68\xfb\x40\x20\x62\x4c\xe6\x43\x2c\x97\xa2\xa9\x04\x87\x0d\x05\x5b\x51\x43\x34\x9a\xe6\x5c\xbc\xc0\xd3\x99\x70\x91\x6e\x83\x43\xc3\x00\x06\x3d\xea\xa2\x98\x7b\xe7\x0c\xfa\xe1\xde\x90\x7a\x4d\x0a\x92\x39\xfb\x1b\xc4\xfa\xfd\x61\xab\xc3\x97\x2f\xf4\x8f\xd9\x10\xbf\x32\x2c\xd2\x0a\x2a\xfd\x65\xe0\xf2\x0d\xde\x7e\x4d\x4a\x4f\x70\xc5\xb7\xa7\xdd\x26\x4f\x2c\x0d\x3d\xae\x9e\xfb\x24\x80\xea\x22\xf3\x3c\x94\x7b\x57\x34\x13\xd2\xae\x6b\x1f\x7c\x06\xcc\x19\xcf\xa8\xd7\x97\x21\x1d\x3b\x55\x34\x67\x86\x29\x74\x81\x73\x4e\x75\xc2\x45\x27\x7c\x28\x98\xb8\x31\x34\xb9\x6b\x6d\x4d\xef\x39\xee\xb3\x73\xdc\x07\x5f\x05\x7a\x44\xe0\xa9\x15\xef\xdc\x35\x73\xe5\x0a\x84\x07\xe1\x85\x90\x18\x0c\xdd\x7e\x47\x8b\x2e\x56\x0e\xdf\xa7\xc1\x5d\xc3\x6b\x67\xd8\x00\x4f\xb7\x42\x16\x65\x86\x5e\xf6\xdc\x7b\xc1\xed\x87\x1b\xb6\x3f\x03\x8e\x04\xee\x72\x8f\x16\x75\xad\x53\x87\xdc\xbe\x19\x73\x53\x9d\x7b\xcd\x0c\x29\x98\xca\xb9\x0b\xeb\x96\x82\x24\x2e\x2c\x00\xf8\x9a\xe5\x61\x6e\xb8\x88\xe7\x09\x22\x13\x43\x5d\xcc\x0c\x19\x33\x73\xcf\x98\x20\xaf\x5e\xbd\x7a\x05\x72\xc9\xab\xdf\xff\xfe\xf7\x04\xf2\x48\xa4\x2c\xe1\xf9\x72\x43\x68\xf5\xbf\x5e\xbf\x1e\x91\xff\x39\x7b\xf7\x16\xbc\xca\x0a\xa3\xc9\x58\x9a\x99\x1b\xd9\x36\xa8\x75\xd6\x03\xf2\x7f\x6e\x3e\xbc\xf7\xe2\x84\x6e\xfc\x0a\x2a\x48\x58\x5e\xdd\x45\xf0\xd5\xef\x7e\xfb\xdb\x11\xb9\xe0\x0a\xe2\x89\x39\x44\x40\x04\x27\xc8\xc2\x3b\x06\x42\x7a\x9e\x66\x04\xbf\xe3\x20\xce\x49\x38\x87\x6a\x26\x63\x3c\x10\x52\x4c\x32\x9e\x18\xcc\x23\x84\x47\x1f\x01\xed\xb2\x07\x51\x17\xee\xe5\xa4\x08\x98\xdc\x80\x64\xfc\x8e\x91\x89\xfe\x4a\xc9\xb2\xa8\xc2\x1c\x15\xd3\x56\x96\x4d\xa8\x80\xa8\x12\x18\xac\xda\x2b\xcd\xcc\xb3\x3a\x61\xb4\x34\x04\xd5\x70\x10\xfa\x34\x04\x94\x01\x16\xd2\xb8\x63\x8b\x21\xe2\x43\x41\x79\x70\x1c\x84\x3b\x75\xf4\xc2\xae\x13\xef\x84\xa5\xe4\x3c\x9c\x52\x1f\xbb\x52\x28\xf9\x0f\xdc\x2a\xee\x2b\x99\x78\x09\x59\x3b\x99\xcc\x05\x9d\x8a\xc8\xe6\xea\xa3\xf2\x2d\x2f\x74\x11\xff\x51\xfc\xd4\xd5\x24\x0e\xb4\x33\xae\x30\x08\x4b\x21\x16\x6c\xd3\x97\xab\x54\x55\x16\x9b\x34\xee\x6b\x29\x96\x7a\xbb\x2a\x2c\x8e\xfc\xc0\x07\xa9\x0f\x61\xab\xc6\x40\x57\x5c\x17\x00\xe4\xda\x7a\x28\x05\x40\xd4\xbc\x7c\x34\x33\xa5\x03\x0d\x78\x5e\xd9\x6f\x33\xad\x5d\x1c\x51\x4e\xd5\x9d\x55\x12\x1c\x15\x18\x81\xd7\x73\x55\x9f\x24\x54\xf9\x00\x8d\xc2\x95\x59\xf1\x51\x03\xf6\x23\x87\xa3\xd1\x21\x1e\x13\xa9\x88\x36\x54\x39\x9c\xb7\xef\x9f\x29\x5e\xba\xee\x95\x4e\x0b\x4c\x44\x07\xf6\x1c\xcc\xe8\x05\xd1\x67\x95\xb7\x33\x75\x90\x6a\x93\xba\xaf\x63\xe2\xbe\x6e\xd9\x5d\xdb\x67\x76\x1d\xc2\x02\x5a\x34\xed\x9a\xcd\xb5\x43\x26\xd7\x75\xd9\x1a\x1c\x8c\xdd\x49\xe8\x96\x3a\xb7\x43\x52\xd2\xbc\x15\xeb\x5b\x31\xd5\xc3\xdc\x71\xbe\x0f\xdd\x38\x9f\x8b\xd7\x83\x0c\x67\x9f\x0f\xab\xbb\x9a\x60\xa4\x4b\x9d\x74\x39\xd2\x10\x8b\x02\x9e\x82\x45\x61\x2f\x2f\x9a\xa3\xc5\x68\xd3\x96\xaf\xe1\xd3\x85\xbb\xe1\xd3\xee\x62\x02\x9f\x1a\xae\xf9\xdb\x09\x5c\xb4\x23\xa5\x48\x2d\x27\x15\xa8\x20\xd2\xb8\x88\x0e\xcf\x88\xbc\x73\xa4\x16\x91\x8c\x8e\xb5\xcc\x4a\x83\x5d\xab\x1f\x63\x3a\x0c\x83\xfa\x2c\x0b\x40\x7c\x43\xb3\x88\x2a\x03\x3f\x42\x52\xd8\x8e\x40\xe3\xd3\x31\x83\x68\x57\x89\xf4\x27\xa2\x94\x75\x4a\x2f\xe3\x48\x4f\x37\x48\xf9\x6e\xc1\xdb\xf7\x7e\xc6\xdc\x95\x56\xc4\xfd\x2d\xc5\xb1\xe7\x08\x44\x0b\xcf\xc8\x5d\x4a\xb5\xbd\x99\x27\x12\xcd\xbb\xe8\x57\x9a\x93\xa3\xf3\x10\x0e\xe2\xaf\xe3\xaf\x84\x61\x6a\x42\x13\x76\x1c\xeb\x5d\xac\x98\xb1\x9c\x29\xbb\x4c\xd7\xce\xc7\x45\xcc\xa8\x48\x33\x14\xc0\x13\xa6\x00\xf7\xd9\x27\xc3\x94\x05\xc9\xf9\xcd\x15\x49\x15\x9f\x33\xa5\xc9\xd1\x97\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\x47\x16\x95\x80\x40\x03\xcd\x58\xc8\x52\x39\x2b\xfa\x44\x2a\x17\x7b\xa5\xac\xba\x84\x03\x53\x4d\x14\x9b\x5a\x69\x56\x55\xa5\x1d\x92\xac\xb4\x2f\xf6\xea\xce\xf6\x10\x07\xc0\xca\x34\xbb\xc9\x57\x6f\xe2\xa4\x6a\x39\xe7\xa9\x67\x95\x98\x0d\x78\xee\xe3\xc7\x0b\xaa\xa3\x50\x9b\xa8\x76\x65\x04\x58\x94\xd1\x81\xa1\x86\x20\xd6\x9a\xb3\x7f\x6c\x14\x96\x90\xdb\x62\x4b\xee\x83\x8e\x90\x12\x32\x65\xd7\xe5\x38\xe3\x7a\x76\xb3\xa3\x09\x71\xd5\x10\xe8\xac\xb0\x74\xeb\xb7\xd6\x92\xa8\x99\xd0\x1c\x58\x9e\x25\xe3\x96\xe9\x72\x2b\x47\x49\x00\xa2\xef\x1d\x23\xa4\x84\xe8\x8f\x8c\xb9\x0c\x06\xf6\xa7\xf7\xd5\x3c\x5c\x50\x1a\xe6\x2c\x49\xd9\x37\xa2\xa8\xbd\x4f\x68\x96\xe9\x66\xc0\xae\xa7\x98\x28\x7b\xf8\x40\x35\xdc\x53\x6e\xb7\xdb\xcf\x9e\x37\xb2\x5f\xae\x5d\x98\x26\xb9\xc4\x30\x1e\x41\xa4\xf0\x8d\x20\xf5\x8a\xef\x10\x05\x32\x42\xb8\x32\xa0\xcc\xb3\xd6\x17\xe9\xcd\xa5\x4f\xe9\xe4\x19\x67\x40\xaf\xa2\xa1\x6b\x69\x49\x03\x29\xf5\x24\x77\x8b\x53\xc7\x5e\xaf\x15\xf0\x9b\x67\xc6\x28\x3e\x2e\x4d\xf7\x7c\x6f\x8d\xee\xc0\xa6\xad\x22\x02\xa7\x78\xe8\x56\x9f\x44\x28\xea\x34\x84\x70\x16\x96\xcf\x7e\xc5\x73\x80\xdd\xe0\xcb\x43\x4d\x52\x99\x94\x21\x2f\x2c\x00\xad\xba\x40\x6b\x5b\x9b\xa5\xd3\xb9\xda\x35\xd1\x7e\x4b\xf4\x4a\xe5\xbd\xb8\xa7\x2a\x3d\xbb\xde\xe2\x7d\x5f\x67\xe7\x55\xaf\x58\x50\xf2\xaf\x89\x7d\x4f\xc7\xb2\xac\x2a\xdd\xfe\x84\xec\xd5\xab\xd4\x74\x23\x2d\x69\x68\x69\x8f\xee\xaa\xe8\xf7\x26\xee\xde\xc4\x5d\x7b\x76\x31\x71\x5f\xa1\x89\x3b\xce\x83\x5b\x3b\xae\x3e\xbd\x02\xcf\xda\xfa\xf6\x3e\xa6\x95\xf4\xa2\x22\x30\x28\x4d\x35\xfd\xf8\x1b\x02\x1c\x1e\x91\x6a\x6f\x23\xa1\xcf\x53\x20\xe0\xd9\xcf\x6f\x51\x7d\x24\x3b\x29\xac\xae\x95\x54\x8d\xcf\x72\x8a\x76\xf4\x03\xc6\xac\xd4\x78\x29\x11\xdd\x6e\x14\x32\x3d\xc5\x44\x96\x54\x08\x89\xdc\x4f\x0f\x5c\x16\xe8\x81\xd3\xbb\x44\x54\xfc\x02\x93\x50\x7b\xd6\xd8\xd1\x7c\xf6\xe8\x05\xcb\x60\x6d\x5b\xd2\x29\xc5\xcf\x2e\x35\xc8\x2a\xd9\x70\xe7\x22\x55\xae\x7f\xa8\xe0\x91\xcc\x58\x4e\xe1\x9f\x6f\xfc\x02\xec\x89\xb6\x22\x99\x61\x18\xf0\x0d\xc5\xdc\xe5\x64\x50\xf3\x49\x39\x98\xbf\x6e\x51\xf7\xa5\x7a\x76\x2a\xc8\x15\x60\xba\xf3\x72\xaf\x6b\x76\x48\x8b\x7d\xc0\x0f\x33\x4c\x51\xd9\xb8\xbb\x02\x9a\x85\xf0\x79\xd4\xa5\xed\x6e\xd6\xdf\xd5\x9c\x3f\x08\x36\xb2\xcf\x80\xad\xf7\xe6\xfc\xa5\xe7\x09\xcd\xf9\x11\xe1\xf6\xc4\x60\x85\x69\x3f\x36\xb7\x79\xfb\xfe\x98\x79\xb1\x72\x54\x65\x5f\xb3\x28\xe7\x2d\xfb\x52\xd5\xaf\x55\x0f\x47\xa3\xc3\x43\x6f\xef\x77\xf8\x59\x9a\xc9\xf0\x0f\x84\x89\x44\xa6\xb8\xa9\x76\x7c\xa5\x0d\x30\xfd\x4a\x4d\x8f\xe7\x92\xfb\x6f\xc5\x57\xb3\x30\x76\xb7\x2d\xe9\x70\x82\x7d\x4a\x80\x37\x0f\x62\x91\x15\x63\x0c\x29\x06\xdc\x02\x43\x56\x21\xc7\x21\xab\xf2\x25\x58\xb9\x07\xd0\xd2\x97\x4d\x21\x47\xf8\x72\x94\x14\xe5\xc0\x35\x18\xe5\x2c\x97\x6a\x31\x08\x8d\xec\x8f\xb5\x5e\xae\x05\xe6\x9e\x4a\x4a\xa5\x98\x80\x02\x26\x2f\x95\xbf\x7a\x10\x3c\x22\x7b\x0d\x50\x6f\x17\xdd\x56\x3d\xf5\x6d\xad\xee\x00\xc0\x24\x55\x95\x94\x9a\x84\xcc\x26\x7a\x50\xdd\x73\xd8\xb7\x4c\xcc\xc9\x9c\x2a\xdd\x16\xe6\x64\x57\x8e\x9a\xf2\x39\xd7\x0f\x28\xfb\x79\x13\xcc\x3e\x90\x76\xb0\x34\x45\x69\x1c\x75\xf2\xb8\xeb\x33\x35\x05\x9c\x6d\x08\x0e\xaf\x0f\x3a\x7c\xfc\x85\x16\x92\xa9\x3f\xad\xca\xca\xd4\x9f\x6e\x45\x66\x56\xf7\xed\xb8\xf5\x0f\x28\xd0\xd4\x7c\xfc\xd6\xee\x7e\x46\x2a\x26\x53\x25\x06\xf3\x82\xd9\x23\x1c\x02\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\x7d\x70\x6a\x18\x98\x47\xca\xd5\x9e\xa2\x11\x3a\x44\x83\xb2\x94\x97\x79\xe7\x58\x50\xe8\x15\x03\xed\x1e\xb2\x81\xb9\x4c\x62\xfe\xba\xd3\x35\xf3\x89\x15\x69\x72\xe7\x2a\x06\x79\xa8\x22\xef\x8f\x82\x5c\x0e\x0e\x1a\x79\xa0\xc1\x3c\x06\x77\x7f\x32\x65\x16\xe4\xbe\x31\x8e\x5d\x33\x65\xb9\x1a\xe9\xe8\x16\x70\xe4\x1a\x42\xd1\xc6\x77\xc0\x06\x9f\x68\x97\x48\xc7\xc8\x36\xfe\x4f\x06\xe5\xc6\x3a\xfb\xc6\xfb\x8e\x21\x1d\xb4\x04\xc9\x3c\xd4\x45\xcb\x64\x12\xdd\x3d\xd7\x38\x14\x6c\xc3\xa5\x47\x7e\x6f\xbb\xb7\x9b\x61\x47\x45\xf9\x02\x8c\x3e\x99\xc6\x7b\x3d\x9e\x40\x6a\x4b\x90\xe2\x01\x98\x61\x03\x6e\xa3\x2a\x81\xa5\xb6\x5f\x82\xcc\xf3\x51\x9b\xea\x43\xf7\x3e\xc3\xa6\x89\x0a\xb9\xd5\x75\x0f\xfb\xcb\x4d\x58\x59\xa5\xb7\x41\x08\x84\x17\xd4\x75\x09\x62\xa2\xfb\x8a\x13\x97\xe4\x04\xee\xae\xaa\xb2\x68\x21\xb9\xe3\x12\x9a\x09\x9e\xd5\xf1\xcc\xe7\xb2\x0b\x0b\x2f\x85\x73\x34\x58\x42\x9a\xd5\x38\x53\x6a\xa6\x86\xd3\x92\xa7\xbb\x60\xcb\x0b\x66\x80\xad\xd9\x5e\x77\x66\xd7\x91\xc5\x3d\x80\xb1\x05\x47\x8c\x0e\xac\xe1\xa0\xf2\xde\xa8\xf1\x86\x38\x2d\x5e\xdd\x93\x83\x7a\x67\x81\x70\xe4\xfc\x95\xd0\x6d\x50\x6d\x1d\xcf\x48\x16\x89\x0b\xd6\xe5\xb5\x74\x97\x38\x2c\x62\x1e\x38\xb6\x0e\xed\x7f\xbc\x0a\xec\xed\xf9\x63\x36\x91\x55\x85\x14\xd4\x88\x9c\x3b\x6e\xca\x32\x66\xc0\xbb\x96\x85\x4c\xa5\x78\x25\x9c\xcb\xb9\x45\xe6\xbf\x0a\xf2\x8d\xcf\xd9\xcf\x27\xa7\x84\x1e\xd7\x42\x20\x5c\xd5\x19\xc1\x58\x8a\x3e\xba\x59\xf5\x1d\x55\x0a\x3d\x20\xe3\x63\xef\x8f\x02\x27\x4e\x58\xb1\x30\xf3\x12\x2f\xea\xd5\x8a\x59\x00\x40\xd8\xb1\x92\x39\xd1\x82\x16\x7a\x26\x0d\xa8\x86\xb4\xa0\x09\x37\x0b\x62\x14\x4d\xee\xa0\x44\x91\x62\xee\x73\x03\x92\x1c\x3b\xc7\xae\x18\x7c\x75\xb7\x61\x33\x53\xb2\x9c\xce\xc0\x13\x16\x5b\x25\x19\xd5\x7e\xf5\x2b\xfb\x3b\x6d\x47\x93\x74\x21\x68\xce\x93\x90\x35\x50\xc9\x39\xd7\x5c\x3a\x6b\xaf\x1f\xf7\x3a\x64\x86\x43\x0b\xf2\x79\x46\x79\x4e\x8e\x34\x63\xe4\xd2\xa3\x04\xfe\x72\x83\x32\x0d\x5a\x36\x54\xdd\x39\x40\x86\x94\xe6\xc2\x25\x44\xa8\x08\x5c\xb8\xbc\x42\x86\x69\x67\xbe\xf2\xa3\xc7\x61\xbb\x56\xcf\x49\x2a\xb8\xb8\xf7\xa9\x3b\x99\x48\x65\x74\x6b\x79\x76\x7d\xa5\x63\x6d\x04\x71\xcb\xe5\xbd\x83\x1f\x32\x29\xa6\x71\x1a\x81\x0a\x33\xa1\x26\x30\x94\x77\x99\xf3\xb4\xa4\x19\x12\x51\x37\x99\xf3\x9b\x2b\xec\xce\xa7\x33\x33\xbc\x67\x60\x8d\x41\x5e\x53\x9d\x19\xff\x51\xbe\xe4\xad\xc3\x35\x10\x5d\xe3\xac\x09\x68\xd9\xb2\x53\xbb\xa7\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\x41\x28\x9b\x57\x9b\x7c\xeb\x4a\x27\x76\x14\x0e\x0e\xbe\x8b\xcc\x66\xd1\x45\x07\x54\x32\x17\xe9\x90\x66\x16\x73\xae\xbf\x3d\x77\x1e\xce\x78\x10\x6a\x17\xf9\xbe\x0a\x12\x17\x21\x6d\xb6\x95\x19\x56\x1e\x01\x88\x83\x1f\xb3\x14\x88\x46\x5c\x30\xf2\xde\x6a\xc8\x6e\xf3\xae\xbf\x3d\x1f\x10\x3e\x62\x23\xff\x57\x68\xea\xa9\x96\x91\x53\x74\x03\x8c\xab\x68\x8f\x08\x4c\x25\x36\x46\xc5\x7d\xff\xfe\x47\x3b\x49\xfb\xeb\x9f\x86\x7f\x8c\xb2\x8d\xfe\xe9\xef\xae\x8a\xf6\xdf\x1b\x6f\x63\x5f\xb2\x90\x75\xff\xef\xd7\x2e\x2b\xb5\xcb\x59\xfd\x77\x57\x8c\x8b\x09\x63\xe5\xc6\x6b\x09\xb7\xf4\x3c\x45\x6c\x84\x6f\x2b\xf6\x0f\x6f\x58\x04\x30\x05\xa3\x4e\x42\x0d\x13\x40\xa8\x7d\x50\x86\x90\x06\xbb\xbb\xba\xb3\x76\xfe\x47\x60\x12\xc0\xa0\xb2\x01\x31\x52\xc2\x71\xc4\x23\x7f\x26\x08\xf3\xb5\x3a\x71\xad\x00\x0e\xea\x1c\xd5\x3c\xef\xb1\xc3\x5a\x08\x87\x10\x5c\x3b\x0f\x98\xdb\xaf\x84\x34\xbf\x0a\xdb\xef\x5d\x34\x80\xc1\x48\x42\xe7\x92\xfb\x04\xe4\xf6\xa4\x08\xac\xe8\x18\x52\x62\x8f\x17\x24\xe7\xda\xd0\x3b\x36\x22\x37\x96\xb7\xc4\xb7\x61\x08\x3d\x41\x20\x83\x25\x4b\x49\x29\x0c\xcf\xe0\xd7\x6a\x1c\x3b\xe5\x98\xe7\x5c\x4d\x88\x2e\x13\x4b\x5b\x0b\xc5\x86\x9e\x8b\xb9\x56\x4b\xb4\xa0\x5a\xcb\x20\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\x88\xbc\x07\x66\x95\xf9\x2b\x61\x54\x4b\x9c\x01\x53\xb0\x84\x69\x4d\xd5\x62\x00\x89\xdd\x79\x48\x06\xee\x5c\x77\x80\xa3\xe6\x54\x60\x5a\x75\xc5\x12\x29\xb4\x51\x65\x62\xb0\xce\xde\x58\xc9\x3b\x26\x82\xbb\xa0\xdd\xc5\xba\x03\x57\xe5\x3f\x03\xf7\x5d\x92\x24\x33\x2a\xa6\x51\x9d\x9a\x9c\xa6\x00\xfb\xaf\x83\x94\xe3\xd7\x63\x21\x40\x27\x56\xb0\xe0\x06\x40\x31\xb6\x7c\x24\x98\x61\xff\x2a\x42\x3e\x9e\x41\x65\x27\xb5\x4b\xe2\xd9\x16\xda\xd5\x89\x7e\x91\x8e\x46\xbd\x21\xb0\xed\x3d\x3b\x80\xe5\xcc\xd0\x94\x1a\xba\x83\x13\xd8\xbb\xaa\xb8\x9e\xbb\x80\x74\x05\x4e\xc3\xc5\xa4\xe3\x43\x5e\xdc\x92\x05\x8f\xe3\x9f\xe0\x24\xce\x3c\xe4\x21\xe2\xda\x58\x9c\x72\x17\x05\xe8\xdb\x05\xf2\x8c\xaf\x5e\x66\x87\xf7\xa3\x21\xb9\xa8\x4a\x33\x56\xe4\xa4\xdd\x35\x54\x47\x0b\xac\x05\xfd\x0e\x30\xba\xad\xee\xca\x92\xba\x7f\xd7\x4a\x11\x04\xb9\x04\x13\x86\x2b\x16\x87\x9b\x39\xd0\x95\x02\x91\xbc\x01\x44\x80\xf2\x94\x19\x5d\x79\xa8\x20\x1d\xb6\xc4\xc5\xf1\x3b\xa7\x8c\x02\x91\x76\x80\x75\xfa\xdc\x6a\x59\x08\xc1\xae\xa5\xa3\xb3\x96\xf2\x3f\x0a\x5c\x77\x31\x3a\x63\x39\x81\x77\x32\xed\x62\xa7\x6e\x64\xe1\xaf\x86\xa8\xfc\x37\xd1\x13\x57\x83\x52\x8f\x0d\xe0\xb6\x4a\xd7\x82\xe6\x90\xc8\xcd\xe8\x7c\x77\x23\x55\x25\x23\x0d\x43\x2a\x63\xf8\xdc\x10\x3e\x37\x7c\xdd\xde\x98\xd7\xc5\x03\xc4\x3f\xad\x3d\x41\xea\x1f\xe9\x64\x39\xb5\x24\xe5\xa6\xa3\xb9\xb3\x11\x8d\x1c\x46\x70\x34\xdf\xdd\x22\x86\x9b\x5b\x17\xe9\xc0\xb8\xa5\x16\xa7\xe4\x57\x35\x2e\xef\xa4\xa9\xa0\x29\xa1\xa7\xee\x91\x57\x9d\x46\x6e\x2b\x7c\xf0\x79\xbd\xf9\x71\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\xee\x83\x30\x41\x35\xa6\x6e\xf1\x37\x5e\xcc\x15\xce\x5b\x3b\x5e\xf0\x5a\x3e\x13\x0b\x9c\xfa\x45\x04\x5a\x54\x3d\xc9\xd4\x7e\xc8\x4a\x9d\x82\x8e\x33\xbc\x3d\x0e\xcc\x16\xe6\x42\xb3\x7b\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\xaf\xaf\x60\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\x1a\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\xf1\x70\xbe\x61\x69\x90\xae\x5f\xbd\x22\x1b\x88\x4b\x57\xc9\xd8\x0b\x3a\x70\x79\x50\x88\xec\x48\x03\xab\x87\xd2\xaa\xd6\x78\x64\xd8\x73\x92\x82\xf7\xa1\x71\x95\x8e\xc4\xc2\x99\x6e\xe2\x6f\xc5\x03\x84\x53\x42\x8e\x84\x14\x78\x72\xb0\xed\x31\xba\x10\xad\xb1\x4d\x41\x13\x57\xa2\xae\x5e\x21\x34\x3a\xa9\x9e\x49\x70\x91\xda\xad\x03\xca\x0d\x3a\x92\x2e\x93\x84\xb1\xa0\x55\xc7\x25\x6a\xaa\x93\xed\xa6\xec\x4b\x5d\x6a\x09\x49\x5c\xb4\xa1\x59\x56\x69\xb3\x0e\x5c\x12\xf8\x9c\xb7\x00\x46\xec\xaf\x16\x68\xe3\x14\x7b\x28\xa2\x8e\x6e\x2f\xa5\x48\xf0\x0a\x9f\x9b\x85\x9f\xc1\x45\x93\xd5\x83\x1a\xa1\x51\xc9\xe5\x13\xb4\x3b\x45\xea\x40\x00\x26\x90\x26\x57\xc2\xbd\xce\x99\x5c\x6e\x06\x4b\x87\xc6\x34\xb9\xbb\xa7\x2a\x85\x52\xbe\x05\x35\x1c\xd3\x82\x0f\x6a\xc3\x1e\x45\x73\x80\x42\xfa\x31\x16\x1d\x07\xa5\x43\xb3\x90\x82\xba\xfa\x0c\xa1\xa5\x91\x39\x35\x3c\x01\x55\x96\x4f\x22\x2b\x62\x1e\x52\x1a\x36\xca\x0e\x02\x95\x0d\x05\xec\x6f\xf1\x36\x46\x31\x62\xee\x25\xe1\xb9\x95\x10\x28\x94\xd2\x98\x84\x88\x21\x6f\xef\xdc\x34\x53\x2b\x06\x7d\x07\x46\xe6\xa8\x15\x2a\xc9\x56\x85\xd2\x30\x7c\xb0\x68\x06\x53\x9e\x0b\xb9\x19\x34\x18\xb8\xeb\x63\x71\xda\xce\x35\x42\xd5\x81\xdd\x9e\x7b\x66\xe5\x02\xbd\x11\x61\xf5\x68\xd5\x8c\xb0\xa6\xad\x26\x29\xd7\x8d\xc2\xd4\x47\xa9\x92\x45\xe1\x0c\x24\xf9\x71\x73\x46\x70\x6f\xa0\xe6\x4c\x47\xb5\x97\xd1\x54\x3d\x65\x22\x14\x0f\x77\xe9\x2c\xe0\xe4\x36\x3f\x51\x3b\x30\x23\x0c\x08\x3d\x26\xdf\xb8\xa2\x42\x01\x71\x83\xd7\x5d\x2b\xc1\x09\xad\x2d\x4e\x76\xea\x25\x9e\xb6\x4f\x2f\xf1\xf4\x12\xcf\xcf\x5b\xe2\x09\xee\x5e\xbb\x4a\x3b\x95\x8f\x63\xa3\x20\xb9\x77\x06\xa8\x1a\xac\x33\x62\x5c\x4d\xc8\x47\x96\xc8\x39\x53\x48\xe4\xa0\xf0\xa7\xe5\xe5\x6f\x28\xcf\x2c\x89\xf3\xa4\xae\x52\x0f\x21\xa3\x6a\xdd\x34\x17\x69\xe4\x01\x9a\x0e\xcd\x73\x37\x29\x17\xe9\x67\xdb\xbb\x4b\xb2\x42\xb1\x39\x97\xa5\xf6\x2e\x0b\xa5\xc1\x63\xa6\x8d\xe3\xb7\x33\x3e\x0d\x89\xb9\xc3\x55\xa7\x62\x89\x54\x69\x15\x52\xae\x0d\x35\xa5\xae\xc7\x49\x24\x68\x4d\xdb\x9f\x81\x26\xc0\xf1\x91\xa9\xfb\x6e\x94\x14\x3d\x36\x1e\x70\x2a\x0e\xdf\xa2\xcf\x47\x55\x77\xdb\x44\x6e\x28\x95\x0b\x8c\x15\xa1\x4a\xc3\x22\xb4\x72\x08\xd0\x19\xd6\xb5\xa8\xd7\x13\x2c\xdc\x32\x0c\xc3\x0e\x2b\xaf\x93\x16\x19\xd7\xe3\x67\x27\xa8\x93\x07\x04\x78\xc6\xcf\x0b\x76\x3c\x69\x2c\xb6\xbb\xf7\x25\x79\xa0\x07\x26\x79\x88\x17\x26\xd9\xa7\x27\x26\x09\xfe\xdc\x0f\x39\x31\x1f\xbd\x27\x79\xe3\xcc\x38\xc2\xbb\xe9\xcc\xd4\x12\x0a\x84\x71\xb8\xf6\x15\x20\xdd\xb5\x66\x38\x03\x60\x12\x8c\xfd\x81\xdd\x69\x05\x6d\x0e\xef\x2e\xd9\xa7\x90\xf5\x37\x92\x63\xaa\xa2\xda\x46\x82\x07\x42\x5e\x60\x26\x20\x38\x75\x43\xe7\x92\xe5\xb5\xa5\xfe\x04\xf7\x27\xb8\x6d\xff\xe7\x3c\xc1\xe8\xf1\xdc\xc5\x21\xbf\x51\x29\x08\xbb\xbb\x20\x5c\x3a\x66\x19\xf9\xb1\x64\x6a\x41\xac\x10\x54\xb9\xf7\x40\x7a\x63\xcd\x53\xe7\x20\xe3\x8c\x2a\xed\x65\xf6\x27\xe4\xff\x60\xb2\xb9\xfc\x64\x25\x40\x88\x63\x7b\x00\x5d\x6b\x0e\x55\x0f\x55\x46\x68\x05\x08\xc6\x12\x1e\xde\x30\xd6\x64\x3e\x2b\xee\x9d\xbd\xbf\xd8\x4d\xd1\xe9\x76\xa9\x45\x76\xb9\xd8\x5a\x5a\xfc\xd9\x86\x05\x22\x20\xc2\x2f\xf5\x6a\x52\xc1\x14\x41\xee\xd8\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\xfb\xe0\xa5\x06\x34\xad\x39\xe6\xde\xb1\xc5\xa1\x76\x51\x83\x52\xe8\x19\x2f\x7c\x7e\x78\xa0\x04\x0e\x73\xc9\xb7\xe0\x1f\xe0\x87\xc0\x33\x7f\x25\x06\xe4\xbd\x34\xf6\x7f\x97\xe0\x2a\x84\x96\x4a\xc9\xf4\x7b\x69\xe0\xcd\x93\x03\x0b\xa7\xfb\x60\x50\x39\x33\x25\x07\x33\x23\xba\xb4\x41\x7c\x86\x77\x41\x01\x90\xb8\xfb\xd6\x00\x56\xae\xc9\x95\x20\x52\x79\x98\x18\x9f\x3c\x58\xbb\x21\xbc\x6d\x29\xb2\x08\xaf\x18\xc3\x81\x52\xaa\x1a\x24\x37\x0c\x17\x8c\xcb\xdc\xff\x02\xb6\x27\xb0\xc6\x07\xbf\x19\x48\x81\x4b\x0d\x9b\xf2\x84\xe4\x4c\x4d\x21\x3e\x34\x99\xed\xbe\x41\xdd\xe9\x36\x3e\x3b\x51\xef\xf8\xc3\x9d\x31\x03\x58\xdd\x5b\xf0\x5c\x7a\x28\xc3\xc4\x51\x90\x45\xe4\xb4\xb0\x48\xf1\x2f\xcb\x09\x60\x5f\xfe\x03\x29\xab\xf5\x88\x9c\xf9\x82\xa7\xf1\x6f\xce\x8a\x11\x0f\x63\x47\xb0\x32\xfd\x8f\x25\x9f\xd3\x8c\xa1\x3f\x1f\x15\x21\x8d\xa7\x9c\x2c\xb1\xe9\x81\xcb\x5b\x6d\xa9\x54\xb8\x19\x3a\xb8\x63\x8b\x83\xc1\x12\x22\x1d\x5c\x89\x83\x2a\x48\xbb\x86\x3a\x81\xa1\xc1\xa5\xc1\x01\xfc\x76\xb0\x6f\xce\xfe\x4c\xa2\xfd\x0e\x58\xe2\x0c\x42\xe7\x19\xd5\xba\x5b\x7c\x6b\x23\xb4\xa8\x31\xce\xaa\x04\x8c\x37\x51\x9b\x2a\xb8\xc8\x79\x6f\xee\xdd\x9e\x05\x5e\xfe\xdd\x3d\x8d\x3a\x41\x6f\xee\xaa\xa7\xb4\x4f\xdc\xb0\x32\xa1\x18\xa4\x2d\xf0\x31\x1c\xb5\xb8\xb8\xea\x32\x76\x0d\xbc\xbe\x05\xbb\xa2\x9c\xc4\x45\x9e\xb9\x06\x35\x98\xfb\xa8\x0e\x21\x0d\xe1\x22\xc9\x4a\x67\x52\x84\xae\xa0\x44\x77\x15\xf5\x77\x00\xce\x03\x90\xaa\x1a\xc0\x63\x93\xbf\xf6\x5d\x72\xe0\x6d\xde\xd0\xc1\x9d\x68\xb8\xf1\x42\x58\xed\x7b\xad\x93\x2d\xee\x92\xf5\x64\x9c\x49\x5d\xf6\x78\xc3\xc7\x8a\x91\xf3\x19\x15\x82\x65\x51\xb4\xab\x33\x76\x84\x72\x56\x20\x90\xb8\x22\x56\x87\xf5\x2a\x56\x9e\xbe\x89\x10\x5b\xbd\xf7\xda\xc1\x3f\xa5\xa2\x52\x7b\xab\x53\xee\x52\x35\xce\xe4\x3d\x49\x25\xb9\x87\xba\x05\x73\xcb\xb4\xe0\x52\x56\x7b\x76\x17\xcd\x14\x5c\x24\x12\x99\x17\x4a\xe6\x5c\x7b\xe7\x78\xb7\x8d\x7b\x0d\x0d\xcd\xca\x16\x39\x80\xea\x7b\x90\x95\xa2\x9e\x12\xfe\xcd\x39\x31\x54\x4d\x99\xb1\xa3\x11\x51\xe6\x63\xd6\x3a\x7e\xf5\x31\x72\x90\x7d\x4e\x25\x44\xf7\x5b\x04\x0b\xb7\xe1\xbb\xef\xde\x77\x2e\xbd\x5b\xf5\x5c\xb7\xb7\xf7\x52\x65\xe9\x3d\x4f\x91\x45\x6b\x72\x64\x1b\x1f\xbf\xfc\x4a\xb9\xf7\xf7\x3c\xed\x0c\x0e\xe8\x54\x07\x83\xf7\x83\xb2\x60\x20\x00\x07\x57\xe1\x89\x43\x1a\x6d\xe8\x71\x4c\x2e\x39\x46\x17\x41\x7f\x48\x54\x93\x8f\xb9\xa8\x22\xcc\x2a\x30\x5b\x62\x6c\xcf\x8b\x57\x4d\x34\x33\x18\x17\x02\xa1\x15\xd2\xcc\x88\xe6\x79\x99\x19\x2a\x98\x2c\x75\xb6\x68\x8d\x2a\xcf\x03\xea\x49\xc6\x3e\x21\x66\x77\x61\x72\xa1\x53\x9d\xd9\x81\xeb\x4a\x15\x46\xb9\xc4\xed\x2a\xe7\xaa\xf4\x24\x70\xbe\x10\x6e\xc4\x3e\xb1\xc4\x79\x05\x17\x59\x39\xe5\x5b\xc2\x1f\x7e\x66\x59\xcd\xab\x04\xd2\xa5\x66\x55\xa4\x7e\xdb\xba\x2e\x4f\x94\x84\xfc\x79\x39\xfc\xed\xea\x04\xe4\x29\x2b\x98\x48\x21\x25\xda\x9b\x0a\x73\x71\xf2\x7b\x85\x9c\x4b\x2f\xd6\x95\x6a\xf9\xac\x64\x35\x0a\x1e\xb9\x70\xcd\x64\x96\x6a\xc2\x3e\x19\x45\x2d\x61\xca\x2d\x09\x0a\x7d\x26\x84\x8a\xf6\x44\xe6\x65\xa4\x08\x26\x7b\xe7\xf6\x8f\x5b\x2f\xf3\x25\x96\xbc\xac\xd6\xae\x37\x16\xac\x7e\x58\xea\x7a\x24\xc4\xee\xac\xe8\xba\x87\xf0\x8a\x14\xf3\xee\x2b\x75\xcf\xc4\x87\xa5\x9a\xd7\x2b\x92\x6a\x37\x66\xd5\x97\xe9\xfc\x2c\xf2\xce\x4f\x20\x30\xb8\x4b\x12\x26\xd7\xa3\xa1\x51\xbb\x97\xcd\x82\xd0\x1b\x34\x68\x87\xb7\x11\x1f\x80\x8c\xa7\x6e\x20\x17\xd6\x44\xb4\x85\x65\xe5\x3a\x57\x0a\xb1\x8d\x8a\x3d\x46\x16\x71\x6a\xa8\x66\xa6\x9d\x35\xa5\x2e\x3a\x54\x3d\xed\x01\x8c\xf1\xcb\xfd\x84\x59\xec\xc1\x21\xdd\x07\xcb\x92\xe1\x9f\x9c\x94\x21\x6a\x2d\xad\x7c\xe1\xe1\xe3\x93\x34\xb1\x70\x8b\x8c\x63\xa4\x76\x57\x12\x6a\x5a\x97\xdc\x69\xc5\x17\xdc\x0c\xbe\xf9\xa6\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\xbf\xaf\xb5\x4d\x13\x56\x19\xaf\x2e\xb8\xbe\xeb\x92\x8c\x6c\xa9\x73\xfd\x48\x7c\x75\x7e\x49\xdc\xdb\x56\xf6\xa5\x2e\x06\xa6\x87\x66\xc6\x9a\x26\xac\x32\xda\xa6\x5c\xdf\x3d\x79\x59\xf5\x22\x7d\xbf\xcd\x03\xfc\xe9\xec\x5f\x4d\xa9\xd7\xa7\x68\x89\x72\x07\x2d\x64\x49\xee\x5d\xea\x03\x27\x35\xdf\xf2\xe2\x94\x5c\x0a\x5d\x2a\x56\xdd\xdc\x36\x87\xb2\x5c\xf7\x25\x95\x5e\x7f\x10\x96\xbc\x64\xe3\x5b\x41\x95\x01\xf1\xb8\x2b\x1a\x84\x8e\x9e\x3e\x45\x2f\x44\x1b\x3c\xb8\x9a\x78\xc7\xba\x81\x8b\xf1\x0e\x89\xcb\x7c\x23\xbb\xf3\x51\x5a\x93\x78\xaf\xdf\x84\x94\x3f\xe4\x24\x65\xf3\x13\x9d\xd2\xd7\x03\xf8\x8c\x77\x78\xae\xcf\x89\x6a\x72\xf0\xfa\x60\x44\x6e\x78\xce\x33\xaa\xb2\x45\x2d\x15\x73\xd5\xce\x32\x0b\x3f\x20\xdc\xca\xbd\x3a\x20\x47\x52\xc1\xc8\x09\x15\x24\x63\x3e\xa2\xc9\x9d\xb3\x05\xca\x8e\xc7\x4f\x4d\x5c\xc8\xa3\xda\x2f\x91\xce\x74\xc6\x89\xd4\x73\x6c\xc7\x8f\x6a\xe9\x6c\x2e\x2a\x92\xce\x85\xa5\xf3\x23\xf2\xcd\xaa\x42\xe5\x70\x64\x7c\x8b\xe7\x02\xea\xd3\xe8\x7d\x3b\x69\x70\xcb\xe6\xe0\xe7\x03\xd3\x76\x2d\x71\xca\xcd\x47\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\x23\x72\x71\x79\xfd\xf1\xf2\xfc\xec\xf6\xf2\xe2\x94\x7c\xe5\x46\xe2\xb1\x84\x37\x22\xb7\x71\x36\xa8\xc8\xa3\xd7\xa5\xdc\x09\xdf\x1a\x38\x32\x44\x45\x95\xdc\x11\x72\x7c\x50\x41\xae\x04\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\x23\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\x8e\x0e\xbd\x40\x91\x2d\x25\xe1\x0f\x83\xc6\x19\xbd\xea\xc8\x36\x22\xe4\x83\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\xf8\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\xf1\xf2\xec\xe2\xdd\xe5\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\xdf\xaf\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\x3b\xfb\x57\x94\x74\x1b\xf0\xe2\xfd\x87\x5b\xc8\xea\x0b\x17\x5c\x0f\x16\xc2\xed\x07\xe1\xbc\x0d\x87\x43\x30\x19\x1c\xfd\xc3\xca\x93\x69\x76\x4c\xbe\x63\xee\x3b\x12\xd2\x0e\x2b\x28\x05\x34\x93\x21\x07\x2c\xcc\xb5\x82\x2c\xa0\x23\x5e\xef\xbb\x56\x27\xb6\xa5\x95\x95\x90\xd5\xd4\xda\x43\xe5\x53\x4c\xdd\x88\x77\x4c\x4f\x2f\x7b\xee\x91\xec\xef\x4c\xe5\xbc\x69\x75\x15\x7e\x86\x8b\x1f\x4f\x0f\x29\xd1\x8b\x3c\xe3\xe2\xae\xca\x0b\x36\x91\x16\x87\x30\x34\x81\x8b\x3b\x8f\xb1\x8a\xd1\x6c\x3d\xa5\xdc\x05\x3f\xf6\x4a\x25\xcd\x0e\x16\x40\xb0\xd0\xd9\x73\xf6\x17\x7f\xec\xdd\x35\x74\x4c\xe2\x0e\x0e\x5e\xdc\x7a\xb9\xee\x56\x06\xff\x10\x3a\xd4\x68\x9a\x20\x57\x37\xe7\x37\x57\x4f\x6a\xa1\x5e\xc7\x12\x60\x76\xcf\x28\xd5\xf1\x1f\xb7\xdd\x0e\x0f\x49\x56\x6e\x6f\x83\xea\xdd\xb5\x54\x86\x66\x7b\x22\x02\xc9\x8c\x16\x67\xa5\x99\x5d\x70\x0d\x39\x14\xba\x0a\x01\x4b\xfd\x23\x4f\x67\xcc\xdd\xec\x13\x06\x72\x8f\x0e\xae\xdd\xf9\x5f\xce\xae\x09\x2d\xed\xfe\x1a\x97\x5c\x74\xaf\x17\xee\x7e\x66\x37\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\x95\x6f\x01\x57\xc8\xc0\xc5\x97\x3a\x55\xd6\x02\x90\xde\x01\x62\x57\xc2\xca\xda\x34\x61\x0d\x07\xc8\x01\x24\xfd\xc4\xb1\x79\x68\xf3\x47\x67\xa0\x82\xfc\x60\xd9\x9f\x4e\x6b\xa9\xd8\x97\xea\x5a\x78\x2b\x45\x55\x34\x61\xaf\x16\x1f\xfe\x63\x57\xa2\xc0\x7f\x14\x0d\x4b\x1b\x2e\xf0\xff\x96\x34\x43\xc0\xbc\xdf\xb7\x59\xaa\x0e\xe4\xae\xf3\xad\xef\x90\x9b\x7a\xb5\x1d\xef\x83\x96\x5e\x6a\xcc\x3c\x86\xeb\x31\x8a\x0a\x6d\xf7\xa8\xae\x8b\x1d\xba\x8b\xa7\x43\x72\x64\x92\xa2\x75\xed\xfe\x47\x72\x6d\xcf\x4a\x51\x2b\xe4\x0c\x33\xbf\xc5\x6d\x79\x1b\x5c\xdb\xdb\x4e\xf2\x51\xae\x86\x00\xcb\xbb\x5a\x55\x5c\xaf\xb0\x5b\xf1\xba\x90\xf5\x93\xb7\x5c\x1b\x5f\x90\x01\x5e\x70\xed\xf2\x08\x83\xdc\x75\x6d\x15\x39\x5e\xfc\x8d\xa6\xa9\x3a\x45\x2e\xe5\xab\x2f\x2b\x90\xbe\x7c\x92\x2f\x2a\xc2\x5d\xe2\x91\x59\x14\x2e\x01\xe0\xed\xf9\x35\xc1\x02\x29\x7f\xf8\x1d\x56\x7e\xfd\xaf\xdf\xfc\xee\x55\xeb\xed\x7e\x3e\xe7\xf1\x1d\xed\x18\x7b\xbf\x63\x7a\x11\x7e\x83\x35\xff\x40\xbb\x12\x90\x4d\x6e\xd0\x1d\xcf\x52\x56\x77\xd4\x11\xb1\xec\x2e\x07\x7a\xbf\x9b\x04\xd3\xfb\xd9\x3d\xab\x9f\x1d\x09\x11\x25\x48\x24\x3a\xa2\x4b\xdc\x15\x42\x0c\x97\xc9\x0e\x52\x9c\xeb\x97\x47\x71\xb6\xc2\x66\x3b\x16\xd5\xb1\x27\xbe\x8c\xf7\xe5\x6f\x2a\x17\xf6\x8b\xf7\x37\x7f\x7b\x7b\xf6\xe5\xe5\x5b\x98\xa9\xbb\xbf\xb7\xa8\xc1\xc5\xce\xfe\x53\xed\x51\xad\x8d\xf2\xba\x1d\x20\xdd\xae\x65\x44\xe3\x42\x46\x90\xf7\x6f\x6e\xba\xde\xc5\x3c\x54\x40\x17\x93\x56\x6b\x7f\x5a\x6b\x1b\x54\x35\x61\x6a\x7f\xf1\x23\x3b\x1b\xe5\xa2\x44\x5a\x35\xfd\xcb\xee\x14\xce\xf0\xc1\x2a\xd2\xd6\x1d\x20\x2f\xe0\xde\xc1\xae\x17\x61\xb0\xf7\x1b\x87\x47\x82\x55\x5b\x39\x40\x75\x0f\x2c\x3a\xc4\x5e\x5e\x04\xb0\x87\x14\x69\x9b\xb2\x34\xdb\x52\x6b\xa6\x43\xf5\x85\x17\x8a\x29\xc5\xaa\xf4\xcc\x5d\xa8\xd7\xca\x01\x6a\xe5\xca\x6a\x77\x31\xb5\x58\x8a\x75\xe9\xcc\xbd\x87\x02\x75\xca\xab\x2e\x68\xb2\xd7\x82\x2a\xd5\x2b\x7c\x03\x41\xee\x4f\x4f\x00\xe1\xb3\x7b\x74\xa4\x0d\xe3\x75\x45\xe4\xd0\xb1\x19\x25\xd7\x69\x87\x7c\xa1\x8f\x42\xfa\x08\xc4\x38\x9c\xee\x99\xb7\x8f\x3c\xad\xb6\xf3\xdd\x8e\x8a\xce\xbe\x95\x9c\x62\x26\x8d\x14\x3b\x7b\xc9\xaf\xea\x5e\x3f\xd0\xd7\xd0\xe2\xbc\x2a\x63\x13\xd5\x78\x04\x0f\xca\x70\x19\x61\xe5\x39\xcf\x2e\xa4\xf0\xd7\x12\xf5\x4b\x89\x27\x17\x41\xd2\xab\x8b\x3d\x1d\xbe\xcf\x37\xc4\xb3\xab\x31\x78\xaf\xce\x20\x69\xe7\x98\x14\xdb\xc5\x43\xec\xea\xc2\x89\x66\x3e\xe0\x44\x3b\x84\x24\xeb\x31\x72\x6f\xac\x53\x2a\x73\x2f\x55\xf7\x50\xef\x7a\xc7\x86\xaf\x82\xfb\x6d\x29\x14\xeb\x25\x9e\x1e\x9c\xe3\x33\x9f\xa0\x1b\x38\x41\x8d\x04\xe7\xeb\x4e\xd2\x63\x1c\xa4\xe7\x3d\x40\x0f\x65\x54\x8f\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\x03\x82\x59\x96\x73\x5a\xf8\x9a\xdc\xf2\x5e\xdc\x53\x95\x92\xb3\xeb\xab\xfd\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\xfd\xef\x7f\x8f\x95\x95\x52\x96\xf0\x7c\xb9\x21\xb4\xfa\x5f\xaf\x5f\x8f\xc8\xff\x9c\xbd\x7b\x0b\x95\x1f\x0b\xa3\x31\x2b\x09\x8e\x8c\x95\xe0\xa3\xce\x7a\x40\xfe\xcf\xcd\x87\xf7\x55\x99\x98\xfa\xaf\xae\xa0\xb6\x5b\xde\x88\x5c\x44\xfe\x4f\xb1\xa1\x8b\x9a\x99\x2b\x68\x64\x08\x9d\x4c\x10\x31\xc6\xbe\x9c\x2e\x1e\x38\x1f\x3d\x0e\x55\xc1\xb1\xfe\x88\x45\x89\x0c\x1c\xb3\xac\x4a\x8e\xa6\x41\x9f\xd9\x00\xfd\xcc\x60\xac\x40\x26\x61\x2a\x03\xac\x25\x3f\xd1\x50\x85\xa4\x4a\xff\xa7\x98\xb6\x42\xa9\xab\xae\x88\x83\x55\x3b\xa3\x59\xeb\x5c\x0f\x8f\x71\x03\xd4\xba\x3a\x46\xdd\x74\xef\xce\x90\x4f\xdf\xea\x72\x17\x57\x65\xea\xff\x81\xb7\xa1\xdb\x9c\x84\x1f\xe9\x46\xa6\x36\xd7\xeb\x30\x1b\xdc\x3a\x97\x25\xa0\xa2\x13\x34\x93\x50\xc9\x2b\xec\x74\xc5\xc5\xa2\xa2\xf7\xdb\x97\xd2\x39\xf9\x62\xd7\x04\xbc\x48\xa8\xde\xd1\xd6\xe5\x7c\xea\xfe\x22\xbe\x77\x2d\xaf\x02\x1d\xcb\xd2\xf8\x3b\x6c\xf7\x3b\x04\x60\x63\x95\xf5\x0e\x69\x24\x77\xc8\x3c\xb9\x4b\x06\xe2\xce\x49\x4c\xeb\xf7\xcd\xc0\x13\xea\xa2\xc4\x80\x30\x9a\xcc\xc8\x1d\x5b\x0c\x91\x6e\x15\x14\xa2\x79\x00\x2a\x17\x16\x16\xb5\xc2\x27\x55\xed\x1a\x2b\x1f\x3b\x90\x79\xc7\x80\x88\xfb\xf8\x68\x20\x2f\x84\x6a\x27\x2f\xb9\x34\xa2\x22\xb2\x14\xf8\x5c\xd5\x51\x3d\xe2\x90\x37\x14\x8b\x91\xd7\x83\x54\xec\x79\x63\xa9\xed\xa6\x37\x7d\xb9\xf2\x86\xb0\x74\xd0\x71\xb7\x52\x2c\xf5\x76\xc5\xb7\x9d\xf0\x07\x1f\xa4\x3e\x3b\x73\xe4\x51\x01\xe5\xfc\x5c\x25\x27\xd7\xd6\x43\x29\x00\xa2\x16\x44\xa3\x99\x29\x1d\x68\xb0\x5e\x58\x29\x32\xa6\x35\xe1\xb0\xc2\x9c\xaa\x3b\xe6\x13\xc6\xd0\x6c\x44\xae\xed\x24\x43\xfe\x2a\x4c\x8b\x3c\x47\x17\x3b\x7b\x66\xe3\xe8\x20\xfb\x91\xc3\xd1\xe8\x10\x09\xfc\x8a\x58\xa1\x0e\xf8\xb1\x5b\x4e\xdd\x1d\x72\xe9\x36\x4a\x7b\x17\x1a\x33\x03\x5b\x91\x0f\x32\x5f\x4b\x88\x82\x33\x33\xcf\xc0\x68\xeb\x24\x4a\xcb\xcb\xd9\x21\x01\xec\xae\x79\xcb\x77\xc9\x5a\xde\xea\xde\xa2\xfe\xec\x9e\xad\x7c\xa7\x5c\xe5\xeb\x32\x95\xbb\x9d\x72\xa7\xad\x7b\x0e\xe7\x07\xa4\xd8\xce\x3b\xa5\x79\xf5\x4f\xdd\x48\x09\x72\x47\x2d\x4b\x4f\x2b\x19\xd1\x25\x7d\xca\xd8\x67\x25\x14\x5e\x4d\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\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\x4f\xd6\x99\xe4\x01\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\xbe\xda\x49\x03\x88\xfa\xaf\xd1\x01\xe2\x16\x3f\x61\x2d\xe0\x0a\xb5\x80\xb8\xec\xce\x45\xb5\x72\x67\x52\xb6\x64\xe7\xc5\x8b\x91\x4b\xd3\x7e\x63\x89\x65\xec\x74\x5a\xcf\xa1\x87\xc6\x9e\x8a\xac\x46\x79\xf7\xfc\xad\x23\x1c\xe2\x97\x2e\x72\x3e\xa1\xf8\x08\xf0\xe8\x54\x2e\xdd\x3f\xcb\xd5\xec\x60\xb1\xe4\x06\x4a\xdb\xa0\x3e\x18\x29\x96\x85\x4c\x4f\x5d\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\x0f\xa9\x73\x64\x37\x10\x56\x7e\xdd\x75\x17\xc9\x03\xcb\x16\x91\x88\x35\xed\x56\x08\xa5\xb6\xa7\x6e\xa4\x50\xe7\x3d\x99\xb1\x9c\x62\x0e\x3f\xbf\x3c\x4b\x65\xee\x15\x37\x86\x61\x2e\x25\xa6\x72\x4d\xe4\x64\x50\xbb\x33\x38\x98\xbf\x3e\xd8\xa5\x1c\xcc\x03\x2b\xf6\x90\x6a\x17\xf6\x00\x8c\xeb\x9a\xc8\x66\xf1\x1a\x74\x89\x0c\x12\x6f\x8a\x86\x41\xc2\x32\x98\x39\x42\xef\xc9\x17\xbe\x0f\x3d\x6a\x57\xfd\x69\x10\x04\x86\x5e\x7f\xea\xf5\xa7\xbd\xe8\x4f\x11\x63\xf1\x04\x67\x85\x2e\x15\x3b\x0c\x7b\x85\xaa\x0a\x64\x8a\x12\xf0\x58\xd4\xf4\xaa\x94\x54\x75\x8b\x9b\xd5\x87\x0e\xbd\x82\xe5\xf0\xb8\x34\x93\xe1\x1f\x08\x13\x89\x4c\x71\xf3\xed\xf8\x4a\x1b\x10\x6d\x2a\x9d\x24\x9e\x4b\xee\xbf\x15\x5b\xed\x60\xec\x5d\xb7\x6e\x27\x3a\xe0\xaf\x02\xdf\xec\x89\xc1\x57\x6c\x3d\x04\x13\xfb\x5a\xd9\x3e\xd7\x80\xe3\xef\xd5\x25\x24\x96\x95\x06\xe4\xf6\x15\x73\xc9\x11\xbe\x1c\x25\x45\x39\x70\x0d\x46\x39\xcb\xa5\x5a\x0c\x42\x23\xfb\x63\xad\x97\x6b\x71\x0c\x32\x41\x52\x2a\xab\x01\x66\x8b\xcf\x55\x3a\xf0\x00\x7a\x62\xe1\x20\xec\x53\xb7\xa2\x41\xf1\x53\x47\x89\x2a\xa9\x18\xe8\xf7\x55\x11\xa5\x49\x48\x79\xa8\x07\x95\xda\x69\xdf\x32\x31\x27\x73\xaa\x3a\x54\x41\x8f\x9f\x07\xca\x03\x29\x9f\x73\xbd\x5b\xbd\xc3\xc6\xd2\x6f\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\xb3\xa9\x2f\x8c\xcf\x8e\x55\x86\xf1\x79\x68\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\xa2\x83\x86\xee\x26\x3b\xd9\x6d\x5c\x86\xfa\xd5\x26\x1b\xf7\xe3\x4f\xd8\x5a\xb3\xdf\x3b\x5b\x17\x5f\xf8\x33\xbf\xb0\xbd\x71\xf5\x0c\xfa\xdb\xda\x56\x28\xd8\xdf\xd6\xf6\xb7\xb5\xfd\x6d\x6d\x6f\x6d\xe8\xad\x0d\xfd\x6d\x2d\xe9\x6f\x6b\xf7\x02\xc3\xfd\xdd\xd6\xa2\xa8\xb7\xea\xce\xd6\x09\x7b\xd5\x85\xed\x93\xde\xd7\xba\xc2\x3d\x67\x49\x22\x4b\x61\x6e\xe5\x1d\x6b\x7d\xe9\xd0\x90\xff\x97\xc6\x81\x04\x08\x6b\xf4\x81\xe5\xc6\x4f\xa6\x1c\x74\x97\x4a\x3a\xc9\x16\xbb\x48\x15\xb4\x4c\xb9\x95\xfc\x77\x46\x33\x3f\x40\x9c\x9c\x48\xa4\x2c\xad\x7e\x70\x47\xd9\x58\x58\x8f\xc8\x19\x51\x2c\xe1\x05\x77\x65\xe4\x29\xbe\x47\xc4\x0b\xb5\x11\xb8\xd1\x2c\x9b\xb8\x1c\xf5\x22\xae\xf5\x53\xc9\xef\x8e\x0e\xae\xfc\x0c\x72\x28\xe9\x33\x99\xfb\x5a\x48\x8a\xfd\xc3\xb3\x36\x37\x9b\xdb\x78\x84\xd8\xbc\x02\x4b\xa9\x95\x18\x82\x8f\x15\xdc\x05\x58\x3f\xf6\xf1\x67\x9f\x0a\xae\x00\x79\x6f\x58\x22\x45\x9b\x9a\xaa\x6b\x36\x68\x69\xa4\x8a\x3f\x81\x6d\x94\xa5\x24\x2d\x55\xa8\x99\x3a\xa7\x19\x4f\xb9\x59\x84\x5b\x3b\x57\x5e\x8b\xe2\x89\x09\xdb\xa8\x2b\x30\x12\x5a\x14\x4a\xd2\x64\xc6\x74\xf4\x35\x14\x50\x5c\x10\x59\xf0\x7d\xc7\x12\x70\x20\xa3\x40\x1f\xcb\x20\xb3\x05\x51\xd2\xf8\x8b\xf7\x35\x1f\xbc\x8d\x06\x83\xee\xc8\xe5\x8c\x5a\xc0\xed\xbc\x8c\x87\xc0\x59\xf1\x49\xfc\x87\x26\x32\x4b\x7d\x0a\x93\x3f\xbc\xb2\x42\x61\xe2\x70\xd0\x12\x3f\x48\x70\x61\x24\xc9\x2c\xc3\xb6\x04\x71\x7d\xe7\xdf\xfc\x96\xcc\x64\xa9\xf4\x28\x4e\x3a\xf0\x1a\xde\xa1\x7e\xe7\x85\x4a\x43\x32\x46\xb5\x21\xaf\x5f\x91\x9c\x8b\xd2\xf2\xa9\xce\x68\xd3\x5d\x0e\x8a\x24\xa0\xdf\xfd\xb6\x75\xbf\xae\xb2\xcf\x5a\xa9\xa7\xc0\xdc\xc8\x4e\xf4\x71\x27\x09\x03\xe3\x30\xb3\x78\x43\x10\x72\x44\x37\x86\xb6\x30\xf2\x11\xce\xd7\x8f\xa5\x1c\x2f\x4c\x97\x20\x4a\xd7\xa3\x1e\x3d\xf9\x7f\xdd\xcb\x36\xc9\x53\xaa\xdc\x29\x1b\x3f\xfa\x28\x15\x2e\xa6\x5c\x9b\x2d\xf5\x2d\xaa\xf8\xca\x8d\xcd\xda\xb3\x95\xa9\xd5\x0e\x3a\xc6\xca\x40\x1f\x2f\x11\x7b\xdb\x52\x92\x30\x2c\x66\x79\x51\x55\x4a\x12\x12\xdb\x6e\x1d\xfe\x99\x13\x8e\x79\x04\xd9\x43\xd6\xf4\x96\x4b\x6d\x27\x74\x79\x94\xe8\xbc\x56\xec\x56\x3f\x05\x9a\x8b\x29\x26\x39\xcf\xcb\xcc\xf0\x22\xab\xd6\xfd\xd1\x77\x70\x84\x3c\xb6\xb9\xd1\xc8\x4c\x44\x31\xb0\x18\xb3\x4d\x81\x7d\xf2\x28\x8c\xc5\x84\xc1\x5c\xdd\xca\xf2\x83\x82\x2a\x1a\x80\x07\x95\x74\xf5\xb1\x33\xdf\x51\xb8\x51\x74\xe9\x30\x6d\x2f\x9a\x55\x33\x8e\x6e\x91\xf6\x89\x34\x86\x09\x2a\x5a\x98\xaa\xeb\xe9\xb9\xa0\x13\x91\xf7\xc1\x99\x0c\xcb\xa0\x34\xb0\xc5\x09\x35\x5f\xd2\xe4\x8e\x89\x14\x8b\x46\xc1\xb2\xd3\x85\xa0\xb9\xcb\xb6\x15\xd5\xe3\x6e\xf4\xd7\x03\x67\x98\xc0\xf0\x3d\x1f\x66\x8c\x5c\x77\x9f\x30\x28\x75\xe7\x54\x36\xb6\xcb\xb6\x73\xae\xd1\x64\xa3\xf8\x3c\x61\x9e\xff\xdb\x7e\xfb\x9c\xfa\xbc\x45\x2c\xfd\xd2\xe4\xfd\xf6\x44\xf8\x0b\xe4\x3e\x58\xce\x21\xa9\x16\xcd\xec\xd1\x5e\x84\x98\xd1\xc6\xe6\x8e\x17\xfb\xad\x7a\xa3\xc6\x5d\x22\x7f\x0f\xd5\x38\xad\x1f\xe2\x8f\x34\x95\x9a\x7c\x99\xc9\xe4\x8e\x5c\x30\x10\xba\x1e\xb3\x3c\x8b\x1a\xa7\xcf\x99\xc2\x3b\xa7\xd3\x6d\xf7\x6c\x43\x92\x4b\xc1\x8d\x54\x9b\xe9\xc5\xd3\x95\x9d\xec\xd3\x3d\xaf\xcd\x50\x65\xb1\xf9\x25\x27\x7b\xb6\xe8\xd6\x75\xe3\xa1\x53\x50\xcf\xe0\x74\xe2\x2b\x57\x05\x6c\xc7\xb3\xf6\x8b\x99\xbc\x1f\x1a\x39\x2c\x35\x1b\xf2\x16\x17\xba\x1d\x96\x79\xc7\x16\x70\x8b\xdd\x71\xa1\xae\x5b\x4d\x67\x30\x12\x2c\x50\xf0\xde\x72\xee\x8f\x5f\x5e\x7c\xa3\x99\x1a\xc5\x32\xe0\x09\x33\xc9\x49\xc2\x8a\xd9\x89\x1b\xe1\x45\x02\xc5\x13\x91\xae\x50\xf1\xfd\x90\xcd\x24\x32\xcb\x5c\x60\xb6\x9c\x90\x73\x56\xcc\xc2\xc0\x4f\xbd\xea\xe7\xcb\x08\x5c\x48\xd9\x35\x11\xea\xa1\xed\x53\x3f\x44\xf0\x06\xcf\x50\x84\x4c\x6a\xdc\xad\x08\xc5\x53\xa1\xcf\x8b\x2e\xb5\xf9\x88\xc0\x79\xdc\x74\xca\x87\xb5\x7c\xca\xb1\xbf\x67\x3d\x59\xb2\xf7\x18\xa9\x91\xa0\xab\x09\x0a\xdd\x29\x4b\x89\x9c\x33\xa5\x78\xca\x34\x09\x34\x28\xd6\x52\x79\xf6\xd4\x70\xeb\xf3\x36\x3f\x7b\xde\xe6\x1d\xd4\xa1\x43\xd0\x87\x6a\x64\x0a\xde\x2c\x91\x29\x9a\xe6\x5c\xbc\x38\x42\xa5\x13\x9a\xb1\xab\x0f\x1d\xf4\x0f\xd7\xa3\xae\x82\xdc\xb8\x97\x51\xfe\xb4\x2d\x59\xc9\xbe\x0e\x78\x43\x84\x4c\xb7\x99\x54\x1f\x41\x91\x98\x52\xc3\xee\xb7\xb2\xc3\x61\x45\xa8\xb6\xb7\x04\xe1\xf4\x39\x55\x8e\x17\x91\x23\x30\xc2\x79\x4c\x7a\xb6\x4f\xa6\xea\x76\xad\xab\x71\x12\x7b\xc5\xe9\x77\x9b\x49\x77\x3d\x06\x9f\x5d\x5f\x91\xaf\xb0\xf9\x7e\xb3\x17\x2a\x69\x50\x0c\xbc\x90\x39\xe5\x5d\x8b\x6c\x34\xbb\x37\xb3\xaf\xc6\x4b\xb8\x0e\x6d\x89\x6b\x1c\x15\x70\x99\xf0\x69\x69\x75\x3a\xa7\x87\xbd\xa8\x04\x73\x4b\xa2\xcb\xcb\x4d\x30\xf7\xf0\x6a\x10\x91\xc9\xc9\xfb\x45\x56\x12\x8b\xdf\x4a\x60\x25\xe1\x0e\x94\x68\x26\x34\x87\x0b\x99\xe8\x56\xdc\x55\xfa\xc3\xd2\x92\xe8\x04\x89\x22\xce\x80\xbc\x95\x53\x2e\xfc\xe9\x95\xee\xbe\x6e\x42\x79\xd6\x16\x18\xbd\x4c\xf2\xec\x32\x89\xd6\xd9\xa5\xa0\xe3\xac\x8d\xbb\x41\x1d\xd5\x42\x47\xf2\x26\xa3\x53\xc2\xe0\x8f\x93\x94\x6b\xfb\x7f\x72\x73\xf3\x16\x8c\xf0\xa5\xf0\x12\x33\x18\xa8\x1d\xed\x0b\x41\x0a\x78\x10\xf7\x7b\x76\x90\xf4\xec\x90\xfd\x2f\xea\x49\xb8\x48\xed\xc4\xa3\x52\x70\xe8\x24\x05\x2d\x30\x1f\x62\xf0\xf9\x45\xb7\x81\x31\x23\xb7\x33\x9e\xdc\x5d\x47\x76\x77\xa9\xec\x3b\x11\xbd\xaa\x31\xb0\xe6\x6f\xfb\xa4\x96\x6e\xaa\xd7\xdd\x55\xe3\xa8\xa7\xe7\x03\x9e\x60\xdc\xb8\xf5\xc3\x6f\x54\x6b\x99\xf0\xea\xce\x05\x6c\x34\x15\x73\x48\x81\x39\xec\x77\x4d\x20\x1e\x74\x5d\x0e\xca\x1f\x2b\x38\x9a\xdf\x4d\x5f\x1d\x57\xc7\x1c\x8c\x0b\xbf\xea\xbd\x2e\x01\x71\x66\x87\xd4\xe8\x55\xc7\xe5\xd4\xe8\x5e\x18\x6e\x5c\x2c\x78\x37\x75\xb7\x79\x5e\x10\xf3\xb5\x39\x97\xb6\x2f\xa4\x48\x77\xa9\x09\xf7\xb6\xf0\x36\x61\x1b\xab\xd4\xf0\xc6\x6d\x22\xbe\x73\x57\x0d\x70\xe6\x0a\x59\x94\x19\xfa\x73\x3c\x3c\xbf\xbb\xb7\x19\xe3\x77\xf6\x74\xf5\xf0\x14\x59\x4b\x0f\x63\xc7\xde\xee\x9e\xce\x3f\x8d\xdc\xa5\x91\x70\xf7\xea\x77\xbf\xfd\xed\xe7\x9e\xcd\xb4\xad\x0a\xfe\x18\xe9\x4c\x5b\x9a\x68\x57\xc4\x17\x5d\xf5\xf1\x45\x3f\xdf\xf8\xa2\xc7\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\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\x1e\x1c\x53\xd2\x3d\x09\x60\x77\x7b\xda\x2e\x05\xa9\xaa\x9e\x2b\x35\x48\x1f\x54\xee\x73\x8f\x1d\x1e\xea\x28\xb5\x98\x91\xf6\x04\x3e\x89\x42\x42\x3a\x68\x63\x38\xbc\xec\x52\x1b\xd2\xf5\xf9\x70\xd3\xb8\x98\x09\xaf\x9f\xe7\x3e\xe6\xe7\x70\xe1\xd1\xd7\x74\xf9\x4c\x4c\xee\xba\x96\xad\xc5\x5b\x2b\x80\x04\x00\x23\x97\xe3\x38\x4b\x64\x75\x74\xce\xae\xaf\xac\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\x7d\x8f\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\x6b\x08\xc8\xa9\x5a\xd5\x25\x69\x14\xa5\x69\x96\xc9\x7b\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\x1b\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\xe0\x7e\x02\xde\xb0\x90\x65\xb0\x77\x61\x31\xcc\xb0\x3a\xbd\x02\x4e\xef\xab\x1f\x41\x15\x48\xa5\x37\x4d\x0c\xd9\x27\xae\xcd\xf2\x5a\x3c\x88\x7c\x1a\xbc\x7d\xe1\xcd\x5c\x17\x96\x2d\x74\xae\x6a\x57\xeb\x57\x97\x57\xe6\x37\xf0\xd3\x67\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\x25\xd5\x2c\x25\xef\xa8\xa0\x53\xd4\xf7\x8e\x6e\xae\xbf\x7c\x77\x6c\xf7\x15\xf4\xc9\xab\x8b\x95\x17\x6d\x37\xf1\xe0\xef\xf7\x19\x2f\xb2\xb4\xf0\x1d\x58\xd5\x52\xff\x1d\x17\xbf\xd7\x40\x18\x12\xf8\x50\xbb\x64\xbd\x2b\x58\xd0\x75\x33\x84\xb5\x59\xf3\xb3\x41\x60\xe6\x79\xfa\xc0\x2a\x9f\x5c\x68\x43\xb3\xec\x3a\xa3\xe2\xac\x28\x94\x9c\xaf\xd6\xc6\x6b\x73\xf5\x0d\xfd\x4c\xd1\xcd\xc3\xbf\x2c\x10\xf4\x70\x85\x2d\xc8\x55\x35\xfe\x88\x5c\x99\xa0\x85\x4b\x01\x2c\xf5\xe0\xac\x34\x32\xa7\x86\x27\x07\x56\x59\x3f\x78\x47\x45\x49\xb3\x95\x4e\x57\x1b\x97\xb1\x4e\x44\xdc\xd8\x69\x7d\xea\xba\x16\xdd\x36\xca\x1a\x9b\xfb\x1b\xaa\x2c\x75\x3a\xbf\xf9\xb6\x53\x5f\x6d\xa8\x29\x97\xa8\xf0\x06\xce\xb0\x9e\x17\x0c\x49\x46\xb5\xf9\xa6\x48\xed\xa1\x6f\xfc\xba\x89\xe0\x27\xd4\xd0\x4c\x4e\xff\xc2\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\x6f\xa0\xed\xb9\x14\x29\x47\xb3\x23\x18\xd4\xb0\x47\x7d\xdc\xf5\xa8\xb6\xee\xa6\x61\xc3\xdd\x42\x3d\xbb\x66\x34\x9f\x3a\x28\xb0\xd9\xd8\xc9\x97\x33\x7c\x09\x37\xed\xb5\xb9\x2d\x41\x8a\xdc\x09\x2b\x18\x42\x1e\x91\xd5\x64\x6b\xab\x9c\xb0\x4d\x3e\x18\xfa\x3d\xc6\x29\xac\x77\x1c\x1d\xba\x79\xaf\xbb\x83\xd8\x84\x62\xf8\x6c\x97\x2c\x9a\x53\x59\x4f\x53\x57\xe1\x5d\xe8\x86\x91\x2c\x8d\x82\xfc\xb5\x46\xeb\x79\x40\x2b\xc1\xab\x9d\x8c\xd4\x36\xab\x7d\x9d\xd6\x56\x39\xd8\x97\x54\xd9\x16\x12\xe3\x56\xa6\xd5\x32\xb9\x7c\x5d\xb1\xbe\x72\xfe\x7f\xca\xa9\x22\x94\x14\x9c\x61\xf2\x13\x2a\x1c\xb0\x80\xb3\x30\x9a\xba\x97\x96\x83\x59\x95\x10\x7e\x1b\xb8\xcb\x70\x34\x2e\x3b\x5f\x0b\x6f\xa0\xa6\x98\xfc\x03\x2e\x2e\x4e\xbe\x92\xce\xc8\xeb\x82\x74\x2d\x0d\x00\x4e\x3e\x20\xba\x4c\x66\x84\x6a\x3b\x35\x8b\xd0\xf6\xc4\xb3\x51\x4e\x05\x9f\x30\x6d\x46\x21\x4b\xb0\xfe\xfe\x37\x3f\x8c\xc8\x1b\xa9\x88\x73\x54\x1f\xf8\xac\x1a\x6e\x9e\x15\x5e\x70\x8d\x8b\x09\x7d\x2b\xad\xb5\x90\xa9\x9b\xf4\x3d\x4c\xd6\xd0\x3b\xcb\xc3\x70\xb2\x25\x83\xab\x8b\x53\x72\x60\xc5\xc4\xe8\xd3\xff\xb2\x6c\xe9\x3f\x07\xe4\xe8\x1e\x98\xf6\x81\xfd\xf3\x00\x3f\x18\xdc\x26\x63\xa5\xba\xfa\x30\x06\x4b\x2a\x3e\x9d\x32\x85\xea\x23\x81\xa0\xc2\x63\x97\x15\x44\xc8\xa8\xb1\xbf\x94\xae\xd4\xcd\xe6\x44\xbe\xff\xcd\x0f\x07\xe4\xa8\xbe\x2e\xc2\x45\xca\x3e\x91\xdf\xa0\x75\x99\x6b\xbb\xc6\x63\x77\x99\xa3\x17\xc2\xd0\x4f\x76\xcc\x64\x26\x35\x13\xa8\xca\x1b\x49\x66\x74\xce\x88\x96\x56\x03\x66\x59\x36\x74\xb6\x74\x72\x4f\x21\x53\x8b\x07\x25\x04\xd6\x93\x82\x2a\x53\x43\x89\x91\xb3\x90\xc0\xd7\xec\xb6\x4d\x85\xbf\x99\x9e\x70\xe1\xee\xaf\xdc\xcd\x99\xdd\x73\x08\x0c\xc5\x4d\x32\x92\x24\x33\x2a\xa6\x21\x36\x7d\x52\x9a\x52\xb1\x2d\x57\x3f\x2d\xcf\xc0\x1d\x17\x9d\x42\x98\xbf\xe6\xa2\xe9\x54\xb0\xda\xae\x34\xe5\xc6\x47\x45\x38\x5f\x45\xb3\x38\xb1\xbb\xa0\xf8\xb8\x34\x52\xe9\x93\x94\xcd\x59\x76\xa2\xf9\x74\x48\x55\x32\xe3\x86\x25\x76\x59\x27\xb4\xe0\xc3\x44\x0a\xbb\xe3\x90\x95\x21\x4f\x7f\x01\xe5\x4d\x87\x76\xaa\x5b\xb2\x4e\xb7\x5c\xf4\x76\xa3\xda\xb3\x1a\xd3\xf6\xb6\xc6\x16\xf6\xa0\xe5\x85\xa2\x6d\xe6\x09\x56\x0b\x86\x90\x93\xbd\x2c\xd6\x27\x4d\xee\xce\x63\x0e\x5d\x1e\xf0\xa4\x39\x86\x3d\x76\xe8\x40\x02\xa7\xb2\x46\x29\x73\x9a\x22\x29\xa5\x62\xf1\xe8\xc8\x6f\x41\x0a\xe9\xf2\x93\xc5\x10\x86\x90\xd9\x90\x8a\xd4\xfe\x1b\x03\x76\x92\xc5\x5e\x60\x58\xf2\x4e\x84\xe0\x9b\xab\x8b\xa7\x39\x12\x25\xdf\xc3\xa9\x77\xf2\x5a\x4b\x21\x0a\x45\x55\x74\xd4\x50\x25\xf3\x4c\xb3\x2e\xa0\x72\xed\x47\xfd\x6f\x77\xff\x12\xb2\x9d\x6d\x13\xa9\x36\xdf\x9a\x44\xb2\x63\xcb\xf9\xbe\xad\x7a\xc4\x36\x39\x70\xbc\xa2\xda\xb8\xd4\x5a\x3e\x07\x41\x6d\x19\x5e\x41\x01\x06\xb3\xfe\x62\xb8\x15\x0e\x79\x7f\x01\x3b\x91\xe1\xca\x9c\x4b\x49\x50\x4a\xb6\x2b\x50\x95\xfe\x52\xab\x83\x86\x8b\x32\x4c\x1b\x42\xe7\x94\x67\x60\x9d\x97\x63\xcd\xd4\x1c\x0b\x52\xb9\x54\x83\xb4\xa9\x67\xb9\x9a\x13\x28\x46\x3d\x91\xe6\xe3\xd7\xb0\xbc\x2b\x9b\x16\x00\xda\x50\x63\xf6\x6b\x67\xbd\x17\xbd\x07\xd5\xcb\xb5\x3f\xdb\x2f\xec\xa8\xc6\x58\xfc\xfb\x0b\xa3\xca\x8c\x19\x35\xb7\x7c\x13\xdf\x5d\x42\xe9\x5a\xbf\x50\xca\x3d\x20\xf4\x3d\x23\x53\x69\xac\x88\x55\x02\xee\xa3\x4c\x8a\x49\x7d\x02\xa2\x3d\x36\x46\x57\xab\xbc\x55\x14\x42\x7c\xa4\xe8\xb8\xcc\x7a\xc7\xe5\x75\x3a\xe9\xd8\x61\x92\xc1\xd6\x98\x48\x43\x0a\xe6\xf6\x0e\x6f\x33\x80\x02\x3d\xcd\x92\x73\xa6\xf5\xc6\x04\x1b\x75\xef\x42\x6c\x8d\x47\xb9\x71\xb5\x96\xfb\xdf\x30\x2c\xc4\x0a\xd0\x29\x33\x94\x67\xfe\x28\x23\x28\x02\x94\xb6\x51\xd7\x8d\x0b\x54\x8c\xea\x4d\x02\x42\x6d\xd6\x1f\xa1\x31\x4e\x5a\x0a\x36\xbc\x97\x2a\x25\xe7\x34\x67\xd9\x39\xd5\xcc\x8d\x15\x87\xe8\xe1\x1e\x1d\xea\xbd\x4e\x79\xb5\xed\x6b\xcd\x94\xd1\xf8\x53\x99\x84\xe1\xaf\x4a\xc5\xc2\x09\x0e\xbc\x09\xf2\x56\x95\x6c\x40\xde\x58\xee\x35\x20\xdf\x88\x3b\x21\xef\x1f\x36\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\x8a\x09\x17\xdc\xb7\x75\x7a\x57\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\x6f\xbe\x5d\x0f\xec\xb5\xbc\x6f\x1b\x7f\xda\x6e\x96\x7a\xa8\x41\x6a\xeb\x99\xd9\x6a\x84\xea\xcd\x4f\xbd\xf9\xe9\x73\x32\x3f\x6d\xc5\xf8\x4d\x26\xa7\xcf\xc3\xd8\xb4\x75\x89\x9b\x0c\x4c\x2f\xd2\xb4\xd4\x6a\x45\x1b\xcd\x49\x2f\xd6\x90\xb4\x75\x69\x2d\x8d\x47\x3f\x1f\xb3\xd1\x56\x88\x6d\x30\x15\xbd\x40\x23\x51\x1b\x81\x8c\xa5\x6d\xc4\xc4\xab\xa8\x71\x2c\x28\x56\xe5\x2c\xc3\x70\xde\x29\x27\x16\x67\x76\x95\x16\xad\x00\xb7\x75\x6e\x87\x6e\x72\xed\x65\x2f\x27\x30\xba\x62\x8f\x4b\x93\x25\x17\x97\xd7\x1f\x2f\xcf\xcf\x6e\x2f\x2f\x9a\xf2\xdd\x2a\x48\x6f\x91\xc4\x36\xdb\x20\x86\x91\x24\xb6\xa6\x81\x25\xc8\x6b\x7e\xb2\x38\xb0\xe6\xa7\xb2\xe4\xab\x7a\x3d\x5c\x2e\x7c\x10\x97\x7b\x10\xff\xd8\x7e\x3a\xdb\x1e\xcf\x6f\xd0\x71\x8a\x3a\x9f\x33\x2b\xf7\xcc\x64\x96\x6a\xef\xb7\x7a\x75\x11\x22\xa9\xb8\x48\xb2\x32\xb5\xc2\xc5\x37\xdf\x5c\x5d\xe8\x11\x21\x5f\xb2\x84\x96\x1a\xac\x30\xa9\x14\x87\x86\x7c\x78\xff\xf6\x7f\xc0\x1f\x1b\x5a\x0c\x42\x5e\x13\xc8\xca\xcb\x29\x26\x16\x36\x98\xae\x8d\x7c\xc9\x50\x50\x81\x2f\x27\xb4\xb0\x54\x4c\x63\xe5\x0a\x03\xb2\xc8\x8c\x65\x85\xa5\x98\x77\x8c\x54\x19\x54\xed\xc0\x55\x85\x79\xef\x3e\x39\x65\x06\xa3\xae\x36\x79\x48\x6e\x84\xda\x16\x8b\xeb\x03\x6c\xad\x35\xf5\xd1\x69\xe3\xf7\x54\x3b\x8b\xd5\xca\xd9\x6e\xd9\xdf\xed\xf6\x99\xf5\x26\x8e\x35\xc6\x0d\x24\xcf\xf0\xd7\xd2\x9c\xed\x64\x2b\x3b\x06\x3a\x91\x70\xd3\xda\x9a\xba\xde\x0d\x68\x75\x1d\x80\x25\x5b\x06\x6b\x02\xb9\xf6\xe1\xe0\x91\x1d\x4d\xb9\xdd\x5c\xa0\x88\x48\x5a\xab\xfd\xe9\xfc\xe7\xea\xef\xca\x71\xa8\xfe\x5a\xcd\xd7\x59\x64\xc8\xbf\xfe\xf3\xc5\xff\x1f\x00\x00\xff\xff\x9d\xd9\x48\xd2\xa7\x53\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..b203d9a18d 100644 --- a/staging/api/pkg/operators/v1alpha1/subscription_types.go +++ b/staging/api/pkg/operators/v1alpha1/subscription_types.go @@ -84,6 +84,18 @@ type SubscriptionConfig struct { // List of VolumeMounts to set in the container. // +optional VolumeMounts []corev1.VolumeMount `json:"volumeMounts,omitempty"` + + // Describes node affinity scheduling rules for the pod. + // +optional + NodeAffinity *corev1.NodeAffinity `json:"nodeAffinity,omitempty" protobuf:"bytes,1,opt,name=nodeAffinity"` + + // Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)). + // +optional + PodAffinity *corev1.PodAffinity `json:"podAffinity,omitempty" protobuf:"bytes,2,opt,name=podAffinity"` + + // Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)). + // +optional + PodAntiAffinity *corev1.PodAntiAffinity `json:"podAntiAffinity,omitempty" protobuf:"bytes,3,opt,name=podAntiAffinity"` } // 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..8b9a736964 100644 --- a/staging/api/pkg/operators/v1alpha1/zz_generated.deepcopy.go +++ b/staging/api/pkg/operators/v1alpha1/zz_generated.deepcopy.go @@ -1394,6 +1394,21 @@ func (in *SubscriptionConfig) DeepCopyInto(out *SubscriptionConfig) { (*in)[i].DeepCopyInto(&(*out)[i]) } } + if in.NodeAffinity != nil { + in, out := &in.NodeAffinity, &out.NodeAffinity + *out = new(v1.NodeAffinity) + (*in).DeepCopyInto(*out) + } + if in.PodAffinity != nil { + in, out := &in.PodAffinity, &out.PodAffinity + *out = new(v1.PodAffinity) + (*in).DeepCopyInto(*out) + } + if in.PodAntiAffinity != nil { + in, out := &in.PodAntiAffinity, &out.PodAntiAffinity + *out = new(v1.PodAntiAffinity) + (*in).DeepCopyInto(*out) + } } // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SubscriptionConfig. 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..0e2bd8d983 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 @@ -173,11 +173,468 @@ spec: optional: description: Specify whether the Secret must be defined type: boolean + 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 nodeSelector: description: 'NodeSelector is a selector which must be true for the pod to fit on a node. Selector which must match a node''s labels for the pod to be scheduled on that node. More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/' type: object additionalProperties: 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 resources: description: 'Resources represents compute resources required by this container. Immutable. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/' type: object 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..68b9d3530c 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\x6b\x77\xe3\xb6\xd5\x28\xfc\x3d\xbf\x02\xcb\xed\x5a\xb6\x5b\x49\x9e\xe9\xd3\xd3\xf6\xf8\xe9\x6a\x97\x63\x7b\x52\x9f\xcc\xc5\x67\xec\x24\xeb\x79\xd3\x9c\x16\x22\x21\x09\x35\x09\x30\x00\x28\x8f\x7a\xf9\xef\xef\xc2\xde\x00\x08\x52\x37\x52\x96\x2f\x93\x90\x1f\x92\x31\x05\x80\xc0\xc6\xc6\xbe\x61\x5f\x68\xc1\xbf\x65\x4a\x73\x29\x4e\x09\x2d\x38\xfb\x64\x98\xb0\x7f\xe9\xd1\xdd\x1f\xf4\x88\xcb\x93\xf9\xeb\x2f\xee\xb8\x48\x4f\xc9\x79\xa9\x8d\xcc\x3f\x32\x2d\x4b\x95\xb0\x0b\x36\xe1\x82\x1b\x2e\xc5\x17\x39\x33\x34\xa5\x86\x9e\x7e\x41\x08\x15\x42\x1a\x6a\x5f\x6b\xfb\x27\x21\x89\x14\x46\xc9\x2c\x63\x6a\x38\x65\x62\x74\x57\x8e\xd9\xb8\xe4\x59\xca\x14\x0c\xee\x3f\x3d\x7f\x35\xfa\xc3\xe8\xd5\x17\x84\x24\x8a\x41\xf7\x5b\x9e\x33\x6d\x68\x5e\x9c\x12\x51\x66\xd9\x17\x84\x08\x9a\xb3\x53\xa2\xcb\xb1\x4e\x14\x2f\xe0\x13\x23\x59\x30\x45\x8d\x54\x7a\x94\x48\xc5\xa4\xfd\x5f\xfe\x85\x2e\x58\x62\x3f\x3e\x55\xb2\x2c\x4e\xc9\xca\x36\x38\x9c\x9f\x23\x35\x6c\x2a\x15\xf7\x7f\x13\x32\x24\x32\xcb\xe1\xdf\xb8\xf6\x9b\xe8\xab\xf0\x3a\xe3\xda\x7c\xbd\xf4\xd3\x5b\xae\x0d\xfc\x5c\x64\xa5\xa2\x59\x63\xb6\xf0\x8b\x9e\x49\x65\xde\x57\xdf\xb6\xdf\xd2\xe5\x38\xfe\xb7\x6b\xc8\xc5\xb4\xcc\xa8\xaa\x0f\xf2\x05\x21\x3a\x91\x05\x3b\x25\x30\x46\x41\x13\x96\x7e\x41\x88\x83\xa3\x1b\x73\x48\x68\x9a\xc2\xde\xd0\xec\x5a\x71\x61\x98\x3a\x97\x59\x99\x8b\xf0\x4d\xdb\x26\x65\x61\xd4\x53\x72\x3b\x63\xa4\xa0\xc9\x1d\x9d\x32\xff\xbd\x31\x4b\x89\x91\xa1\x03\x21\xff\xd0\x52\x5c\x53\x33\x3b\x25\x23\x0b\xe2\x91\x85\x60\xf4\x33\xee\xcf\x35\x0e\x12\xbd\x37\x0b\x3b\x5d\x6d\x14\x17\xd3\x4d\x9f\x4f\xa8\xa1\x99\x9c\x12\xc4\x2f\x32\x91\x8a\x98\x19\x23\xf6\x53\x7c\xc2\x59\xea\xe7\xb7\x61\x46\xd8\x75\x69\x4e\x37\xcd\xd7\xad\xa7\x34\xa3\x42\xb0\x8c\xc8\x09\x29\x8b\x94\x1a\xa6\x89\x91\x15\x7c\x36\x83\xc7\x75\x5e\x9a\xcd\xf9\xd2\xfb\x15\xd3\xc1\xa6\xf3\xd7\x34\x2b\x66\xf4\xb5\x7b\xa9\x93\x19\xcb\x69\xb5\x87\xb2\x60\xe2\xec\xfa\xea\xdb\xff\xba\x69\xfc\x40\xea\x4b\x89\x51\x94\xdc\x31\x56\xe8\xea\x50\x90\xb2\xb0\x6b\xb2\x8b\x23\xe3\x05\x31\x8a\x26\x77\x5c\x4c\x61\xe9\x53\x5c\xef\x39\x6e\x8c\x1e\x2d\x4d\x59\x8e\xff\xc1\x12\x13\xbd\x56\xec\xc7\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\x11\xb9\x61\xca\x76\xb4\x07\xb6\xcc\x52\x4b\xc7\xe6\x4c\x19\xa2\x58\x22\xa7\x82\xff\x33\x8c\x06\x20\xb2\x9f\xc9\x2c\x7e\x18\x02\xc7\x4d\xd0\x8c\xcc\x69\x56\xb2\x01\xa1\x22\x25\x39\x5d\x10\xc5\xec\xb8\xa4\x14\xd1\x08\xd0\x44\x8f\xc8\x3b\xa9\x18\xe1\x62\x22\x4f\xc9\xcc\x98\x42\x9f\x9e\x9c\x4c\xb9\xf1\x14\x38\x91\x79\x5e\x0a\x6e\x16\x27\x40\x4c\xf9\xb8\xb4\x1b\x77\x92\xb2\x39\xcb\x4e\x34\x9f\x0e\xa9\x4a\x66\xdc\xb0\xc4\x94\x8a\x9d\xd0\x82\x0f\x61\xb2\x02\x49\x64\x9e\xfe\x42\x39\x9a\xad\x0f\x1b\xe0\x5b\x79\x0e\x88\xa7\x7a\x1b\x61\x6d\x89\x1f\xe1\x9a\x50\xd7\x1d\xd7\x52\x81\xd4\xbe\xb2\x50\xf9\x78\x79\x73\x4b\xfc\x04\x10\xec\x08\xe1\xaa\xa9\xae\x80\x6d\x01\xc5\xc5\x84\x29\x6c\x39\x51\x32\x87\x51\x98\x48\x0b\xc9\x85\x81\x3f\x92\x8c\x33\x61\xec\x31\xcc\xb9\xd1\x80\x73\x4c\x1b\xbb\x0f\x23\x72\x0e\x0c\x88\x8c\x99\x3b\xb0\xe9\x88\x5c\x09\x72\x4e\x73\x96\x9d\x53\xcd\x1e\x1d\xd4\x16\xa2\x7a\x68\xc1\xd7\x1e\xd8\x31\xff\x5c\xee\xb0\x74\xc6\x08\xf1\x0c\x6e\xed\xee\xc4\x07\xfe\xa6\x60\x49\x38\x0e\x54\x90\xb3\xa2\xc8\x78\x82\x18\x6f\x66\xd4\x90\x84\x0a\x0b\x2f\x2e\xb4\xa1\x59\x06\xec\xa4\xd5\x2c\xd6\x9d\x76\x02\x47\xbb\xc1\x1c\xfc\xeb\x25\x0a\x5d\xff\x21\x30\xb5\x46\x8b\x75\x94\xc1\x3e\x8e\xce\x2e\xff\xb0\x01\xe4\x04\x25\x93\x09\x9f\xae\xea\xb6\x16\x96\xe7\xd0\x05\x64\x1a\xca\x85\x76\x43\x94\x0a\xa1\x59\x71\x2a\xcb\xbb\x68\x8d\x6f\x8f\xd6\xce\x6e\x25\x64\xb7\xad\xd9\x3e\x4c\xcc\x57\xff\xd0\x58\xc0\xa5\x98\xe3\x41\xb5\x32\x8b\x25\x72\x4c\xcc\xb9\x92\x22\xb7\x87\x68\x4e\x15\xa7\xe3\xcc\x31\x36\x66\xc9\x17\x9e\x31\x5c\x22\x53\xab\x8e\xd4\x9a\xaf\xe2\x7a\xa8\x52\x74\xb1\xa6\x05\x37\x2c\x5f\xb3\x9a\x55\xd3\xfe\x96\xaa\x88\x4a\x58\xe4\x5d\x35\x75\xe2\x1a\xd8\xa9\x53\x72\x1e\x26\xbe\xf6\x33\x5b\xe0\x8e\xcf\x7a\xdc\xae\x9e\x35\x58\xee\x9f\x6d\x1b\x88\x0f\x70\xfa\x0d\xbf\x37\xc0\x62\x4f\x08\x32\x30\xb6\x12\x1a\x23\xf2\xae\xd4\xb0\x5b\x94\x9c\xff\xed\xea\xe2\xf2\xfd\xed\xd5\x9b\xab\xcb\x8f\xeb\xc1\x41\xb6\x1d\x94\xea\x01\x1a\xdf\x61\xb2\x87\xdf\xfa\x3d\x52\x6c\xc2\x14\x13\x09\xd3\xe4\x97\x47\xdf\x9e\x7d\xfc\xdb\xfb\xb3\x77\x97\xc7\x84\x2a\x46\xd8\xa7\x82\x8a\x94\xa5\xa4\xd4\x9e\x69\x14\x8a\xcd\xb9\x2c\x75\xb6\x70\x94\x2b\x5d\x83\xb4\x4d\x6c\x05\x6e\x4b\xc5\x82\x68\xa6\xe6\x3c\x59\x0d\x22\x3d\x22\x57\x13\x42\x2b\x04\x4a\x02\x86\x5b\x46\x95\xcd\x59\x3a\x80\x61\xc3\xa4\xfd\x77\xb8\x28\x4a\xe3\x19\xde\x3d\xcf\x32\x38\x15\x02\x65\xa5\x74\x44\x2e\x64\x69\xc7\xfb\xe5\x2f\x61\x61\x8a\xa5\x65\x02\x42\xb4\x25\x06\x5c\x4c\xed\x4f\x03\x72\x3f\xe3\xc9\x8c\xd0\x2c\x93\xf7\x1a\x28\x05\xd3\x09\x2d\xfc\xd2\x63\xe8\xe8\x85\x30\xf4\xd3\x29\xe1\x23\x36\x22\x07\xbf\x8c\x7e\x3a\xc0\xaf\x17\x4a\xda\x4f\xa0\x9c\x8c\xb3\xca\xb8\x61\x8a\x66\xe4\x20\x6e\x3d\x22\x97\xf6\x1b\x2c\x8d\xf7\x01\x46\x10\x6c\xce\x94\x5d\x85\xdf\x85\x01\x51\x6c\x4a\x55\x9a\x31\xad\x2d\x9e\xdd\xcf\x98\x99\x31\x14\xc5\x03\xc0\xd8\x27\x6e\x19\xae\x54\x44\x48\x33\x22\x17\x6c\x42\xcb\x0c\x38\x30\x39\x38\x18\x35\x19\xdf\xee\xa8\xf6\x46\xc9\xbc\x03\xba\xdd\xd4\x35\x87\x55\x7b\x7f\xa8\x71\xe4\x1a\x59\xd3\x2c\x25\x7c\xe2\x24\x18\xae\xed\xa2\x08\xcb\x0b\xb3\x68\x73\x68\xb6\xd0\x11\xd2\x9a\x10\x90\xc0\x93\xde\xd1\xe2\x6b\xb6\xf8\xc8\x26\xdb\x9a\x37\xd7\xcf\x32\x96\x58\x42\x49\xee\xd8\x02\xc4\x59\x72\xee\x07\xdc\xbc\x94\x4e\xcb\x21\x2d\xc9\xa3\x7f\x86\x76\x3a\x5b\xdb\xb5\x07\x92\x7d\xee\xd8\xa2\x4d\x33\xb2\xac\xd3\x59\xd0\x00\xaf\xb3\xb0\xda\x0e\x15\xd2\x1e\x65\xfd\xb3\x9d\xa2\xaf\x9c\xdc\x61\x4c\xda\xdd\x39\x35\x2b\x05\xd6\xbb\x72\xcc\x94\x60\x86\x81\xcc\x9a\xca\x44\x5b\x71\x35\x61\x85\xd1\x27\x72\x6e\x29\x1f\xbb\x3f\xb9\x97\xca\x2a\x72\xc3\x7b\x6e\x66\x43\xdc\x55\x7d\x02\x46\x8f\x93\x5f\xc0\xff\xc8\xed\x87\x8b\x0f\xa7\xe4\x2c\x4d\x89\x84\x23\x5e\x6a\x36\x29\x33\x32\xe1\x2c\x4b\xf5\x28\xd2\xba\x06\xa0\x0f\x0c\x48\xc9\xd3\x3f\x6f\x3e\xdc\x3b\x42\x4c\x16\x68\xac\xd8\x01\x6a\x37\x20\x74\x2d\x6a\x74\x2a\x20\xbd\xa5\x50\x56\x45\xb0\x7b\x9e\x3b\xb6\xe8\x18\x4a\x87\x65\x8c\xa5\xcc\x18\x15\x5b\x7a\x00\xd8\xba\x9f\xd9\xc3\xea\xd0\xc2\x08\x1e\x01\x0a\x99\x9e\x12\x5d\x16\x85\x54\x46\x07\x15\x01\x6c\x2e\x83\xfa\x9f\x20\x2f\x0f\xc8\xdf\xc3\xcb\x8c\x8e\x59\xa6\xbf\x3f\x3c\xfc\xe3\xd7\x97\xff\xf3\xa7\xc3\xc3\x1f\xfe\x1e\xff\x1a\x59\xe8\xea\x4d\xd0\xa6\x23\x53\x10\xc2\xdd\x9f\x8e\x8d\x9e\x25\x89\x2c\x85\x71\x3f\x18\x6a\x4a\x3d\x9a\x49\x6d\xae\xae\xc3\x9f\x85\x4c\x9b\x7f\xe9\x2d\x9c\x80\x3c\x2e\xd1\x01\x70\x5e\x53\x33\xdb\x33\xe9\x59\x6f\x8d\x58\xfd\xd4\xb6\xdb\xdb\x27\xdc\x2e\x3b\x83\x84\xfd\xe7\x1b\x3f\x5d\xcb\x81\xee\x15\x37\x86\x09\x90\x3b\x98\xca\x2d\x27\x1e\x58\xcc\xad\xd8\xec\xfc\xf5\xc1\xa3\x10\xaf\x00\xb5\x1d\x16\x07\xb3\x77\x2b\x43\x64\x0e\x84\xd6\x4b\x50\x95\x8e\x74\x76\x7d\xe5\x2d\x33\x7b\x5f\x88\xb7\x37\xbc\x79\xf0\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\x47\x49\x51\x0e\x5c\x83\x51\xce\x72\xa9\x16\xe1\x4f\x56\xcc\x58\x6e\x25\xb6\xa1\x36\x52\xd1\x29\x1b\x84\xee\xd8\x2d\xfc\x85\x1d\x6b\x1f\x58\xee\x8d\x22\x75\x52\x2a\xcb\x3c\xb2\x85\xa7\x20\x2c\x7d\xde\xb3\xe8\xc1\xb4\xe7\xa3\x18\x76\xe3\xfd\x8e\x2c\x37\x68\x8b\xce\xe0\xea\x57\x05\x32\xe4\x5c\x66\x65\xce\xf4\x20\xb0\x27\x94\xd6\xc5\xdc\x4a\x93\x4b\xe6\x9d\xd5\x4f\xc7\xd3\x97\xf2\x39\xd7\x52\xed\xcc\x07\xb9\x33\x79\xca\xd2\x58\x4d\x65\x22\x55\x4e\x4d\x50\x17\x3f\x15\x52\x83\x0e\xe0\x70\xb6\x41\x52\x5e\x1f\xb4\xfa\x6c\x41\x8d\x61\x4a\x9c\x92\xff\x77\xf4\xd7\x5f\xff\x7b\x78\xfc\xe7\xa3\xa3\xef\x5f\x0d\xff\xf7\x0f\xbf\x3e\xfa\xeb\x08\xfe\xf1\xab\xe3\x3f\x1f\xff\xdb\xff\xf1\xeb\xe3\xe3\xa3\xa3\xef\xbf\x7e\xf7\xd5\xed\xf5\xe5\x0f\xfc\xf8\xdf\xdf\x8b\x32\xbf\xc3\xbf\xfe\x7d\xf4\x3d\xbb\xfc\xa1\xe5\x20\xc7\xc7\x7f\xfe\x65\xab\xe9\x51\xb1\xf8\xd0\xe2\xc0\xe3\x33\x74\x1b\xc4\x85\x61\x53\xa6\x3a\xf6\x6a\xbd\xad\x84\x7c\x1a\x56\x42\xdb\x90\x0b\x33\x94\x6a\x88\xdd\x4f\x89\x51\xe5\xf6\x83\x51\x11\xb5\x5d\xf0\xfc\xa3\x3f\xad\x91\x29\xd6\x93\xe6\xbd\x23\xb2\x66\x89\x62\x66\x5f\x1a\x0c\x8e\xe6\xf9\x47\x21\xd3\x43\x4d\xc4\x1a\x33\xe1\xba\x69\xff\x2c\x94\x1a\x2f\x52\x20\xbc\x2a\xce\x3b\x51\x32\x1f\x91\xc8\x2c\x34\xa7\x19\x4f\x7d\xbb\x3b\xb6\x45\xcb\xf5\x4f\xaf\x04\x7d\x5e\x4a\xd0\x0d\xee\xef\xa3\x6b\x40\x4c\xcc\x37\x99\x69\x9a\x36\x5d\xdb\xb6\x6e\x8e\xf6\x02\x94\x91\xa4\x90\x45\x99\x51\xb3\xc6\x6c\xb7\xc2\x36\xed\x70\x5f\x07\x33\xa1\xdd\x68\xb0\x03\x3b\x2a\x97\xaf\x36\x86\x92\xb3\x2c\x23\x5c\xe0\x49\x80\x01\xbc\x35\x4f\x31\x94\x97\x08\x45\x83\xf3\xdc\x4e\xe1\x7e\xc6\x9a\x86\x46\xae\xad\xae\xa3\x0c\x17\xd3\x11\xf9\xce\xfe\x8e\x34\xcb\x99\xc6\xb8\x20\x79\x99\x19\x5e\x64\x8c\x04\x6e\x8b\x36\xb4\xac\x64\x84\x6a\x2d\x13\x4e\x8d\x9b\xb1\xbb\x3f\xd4\xc6\x4f\x1b\x66\x63\xe8\x1d\x98\x42\x13\x96\x32\x91\xb0\x11\xf9\x16\xae\x0b\xc3\x5a\xc7\x56\x18\x04\xf3\x3e\x8c\x41\x49\x5a\xe2\xd5\x0e\xd2\x83\xd5\x63\x5c\xe5\x79\x69\xc0\x50\xfc\x54\x56\x7c\xbb\xe3\xce\x32\x17\x19\xf3\x81\x54\x05\xd1\x9a\xc2\xdd\x83\x9c\x54\xaa\xbb\x7e\x98\xf9\xbe\x1d\xe1\x0d\xe6\xb6\xad\x9c\x6a\x89\xe2\x56\x36\x86\x3a\xa5\x7d\x6a\x8b\x61\x3b\x3a\xfb\x93\xa4\xb1\x1d\xe8\x6b\x7b\xda\xda\xc1\xb8\xd4\x95\x9e\xb6\xb5\x26\x15\x8a\x4d\xf8\xa7\x0e\xf8\x78\x26\x2a\x15\x85\xa7\x4c\x18\xab\x08\x28\x20\xa8\x8a\x15\x4c\x80\x1e\xce\x68\x32\x03\xba\xe0\xa8\x68\x65\x19\x7e\xcc\x1b\x23\x94\x32\xba\x1f\xaf\x9b\x55\x52\x4c\x7f\xb6\x7e\xe2\x67\xcb\xed\xfa\xfe\x0f\x96\x90\x29\x3b\x9b\x80\xc7\xe2\x5a\x11\xbb\x36\xbb\x0b\x86\x2e\x5e\x1a\xba\x12\xea\xfa\x82\xc1\x2e\x2d\x33\x2e\xa6\x44\x95\x56\x26\xf1\x97\x4d\x85\xdc\x72\x2f\xbe\x11\x33\xdb\xe0\x64\x01\xe8\xa4\x58\x7a\x51\xda\x5d\xb9\x09\x33\xb9\x9a\x0a\x19\x5e\x5f\x7e\x62\x49\x69\xb6\x18\x27\x97\x8e\x9b\x5b\x16\x53\xfe\x5e\x91\x4d\x90\x80\xf8\x1f\xec\xfa\x40\x44\xb3\xe0\xd0\xe8\x38\xa2\xa9\xe1\x7a\xb2\x80\xe5\x07\x00\xb1\x4f\x96\xc5\x83\x33\x62\x64\xec\x1b\x2f\x9c\x43\x8f\x45\xcb\x01\x19\x97\x86\x70\x03\xde\x3e\xc9\x4c\x4a\x6d\x49\x0f\xc0\x19\xc6\x9d\x73\x09\xbe\x54\x44\x0a\x66\xe5\xd7\xdc\x1e\x9e\xca\x86\xe1\x87\x47\xe9\xaf\xea\xc6\x35\xc9\xa5\x36\x15\x9c\xec\x1b\x30\x86\x08\x56\x49\x59\x53\xc5\xd0\x4f\x4b\x97\x39\xdc\x6f\x32\x3e\x9d\x19\x3d\xc0\x4b\x56\x30\xf0\x58\x42\x59\x0d\x9b\x33\x66\x15\xd2\x2c\x8b\x6d\xb6\x1e\x05\x50\x61\xcc\x41\xa2\x39\x0a\xaa\xb5\x33\xcf\x0d\x82\x42\xd9\xdc\xb1\x95\xe0\x1a\x10\x66\x92\xd1\xf1\x80\x24\x32\x2f\x4a\xc3\xc0\x83\x24\xb7\xa0\x83\x2b\x5d\xe7\x51\xa5\x64\x39\xc5\x95\xb0\xcc\x7d\xd8\xbb\xb3\xa1\xc9\x15\x6e\xc0\xd3\xd4\xb6\x3e\xc0\xc5\x1d\x78\x0f\x35\x3b\x1c\xc7\x45\xc0\xfa\x72\x6a\x92\x99\xb3\x18\x25\x52\x29\xa6\x0b\x29\xa0\x27\xfc\x72\x59\xcd\xed\xbf\x43\xa7\x23\x7d\x5c\x01\x73\xc6\xa7\x33\x0f\x4b\xaa\xf0\x1e\xba\xbe\x07\x9b\x98\xc8\x76\x49\x93\x6c\x97\x36\x97\xd0\xf9\x4c\xe0\xdd\x6d\x84\x07\xd1\x8e\x19\xa6\xf2\xb0\x6e\xd8\x54\x24\xaa\xb8\x26\x9e\x5b\x01\x9a\x1b\x87\x15\xe4\x15\x39\x02\xb4\xe0\xe6\x50\x03\x8a\x0e\x65\x71\x3c\x22\x67\xe0\x92\xdc\xe2\x03\x42\x86\xf1\xdd\x40\xf6\xa3\x5a\x56\x63\xed\x87\xa5\xb5\x35\x5c\x0c\xdd\x9c\xad\x2a\xb0\xb5\x29\xc2\x60\x4f\xac\xb4\xfa\x6e\x47\x36\x71\x86\xa8\x8a\x52\x80\xa5\xb5\x4c\xe5\x83\x95\xfa\x53\x1d\x83\x71\xf6\x7b\xbe\xf5\xee\x66\xce\x69\x1e\xa2\x1d\x14\xfb\xb3\xa0\x25\xd7\xa1\x50\x23\x3c\xe3\x05\xfc\x7a\xa8\x09\xde\xfc\x75\xb1\xe7\x6c\x3b\x7d\xd5\xd3\xe2\x1c\xae\x5d\xc4\xda\xc9\x3b\x0f\xd2\xb0\xb9\xe0\x8f\xe8\xbd\xeb\xd0\x3b\x76\x80\x8a\xf5\xc0\xb9\xf6\x04\xcf\x65\x6c\xac\x18\xb2\x0a\xe3\x8c\x60\xb6\x91\xf3\xaa\x6d\x39\xd5\x4e\x08\x80\x4f\x17\x3b\x21\x3e\xed\xac\x85\x55\x6b\xbf\xc8\x96\x5d\xba\xe1\x25\x3e\xad\x8d\x8d\xf8\x2c\x89\x0c\x80\x6b\xe8\x4d\x61\x37\x02\x4d\x8f\x6e\x1f\x69\x51\x64\x70\x15\x21\xdb\xee\x02\xe9\x6e\x2f\xc3\xc7\x43\x6a\xe7\xb5\x7c\x8c\x1c\x0c\xed\x72\x0e\x35\x22\x95\x3d\xb1\x33\x5e\x38\xef\x2d\xb4\x4e\x78\x7f\xed\x6f\xc1\x6e\x54\xf9\xd0\x5b\xde\x77\x25\x06\xe4\xbd\x34\xf6\x7f\x97\x60\x03\x1a\x90\x0b\xc9\xf4\x7b\x69\xe0\xcf\x11\xf9\xca\x20\x0e\xbf\x6d\xe9\x75\xf2\x00\xa0\xe0\x3c\x77\x06\xc9\x99\x40\xba\x00\xd6\xb9\xc8\xbb\x1b\x1d\xe7\x40\xa4\xf2\x87\x90\x6b\x72\x25\xac\x90\xe6\x96\x1e\x4c\x5c\xda\x0d\xe1\x65\x79\x21\xc5\x10\x7d\xaa\x56\x8d\x71\x19\x1c\xca\x62\x98\x6d\x18\x6e\xfd\x50\x5f\x81\xcd\xf3\xed\xda\xce\x33\x3a\x67\x95\x3f\x9e\x13\xa2\xbc\x57\x9e\xb7\x02\x82\x13\x7f\xa1\x58\x65\x08\x74\x37\x44\x56\xe8\xe4\x7e\x3c\x0c\x21\xc8\x68\xc2\x52\x92\x82\x88\x87\xee\xf0\xd4\xb0\x29\x4f\x48\xce\xd4\x94\x91\xc2\x72\x81\xee\x3b\xde\x9e\x30\xe3\xd3\x89\x3c\xc7\x1f\x6a\x8d\x5a\xc0\xce\xe0\x46\xfd\x09\x38\x99\xd3\x5f\x7b\x4e\xd6\x73\xb2\xad\x4f\xcf\xc9\x7a\x4e\xb6\x06\x24\x3d\x27\xeb\x39\x59\xfd\x41\xbd\xb0\xa3\x12\xfa\x1d\x9a\x03\x9a\x5a\x27\x70\x44\xef\xb8\x5f\x57\x3f\x2d\x9f\xb8\x71\x44\xe4\x16\x54\x56\x67\x76\x57\x54\x4c\x19\x79\x3d\x7c\xfd\xea\x55\x5b\xe5\xb4\xad\x73\x0a\x7a\xfb\x40\xfb\xff\xfa\xcd\xda\xd6\xeb\x6c\x52\x0f\xb4\x22\x3a\xfc\x0d\x86\xad\x1a\x5f\x5f\x63\x08\x04\x6a\x23\xa4\x21\x39\x33\x84\x9a\x9a\x19\x85\xe7\x6c\xe0\x0d\xab\x2e\x54\x01\xbd\xf5\xbd\x45\x32\x25\x52\x38\xbb\x96\x05\xf6\x68\xb7\x19\x24\x8c\x6a\xf0\x85\x19\xb3\x30\x0b\x99\xdb\xaf\x72\x61\xfc\x51\xb0\x53\x60\x1e\x22\xe4\x88\x8d\xa6\x23\x92\x96\xd0\x8d\x0a\x17\x15\x75\x8c\xb3\xd5\x0b\x6d\x58\x0e\x96\x4d\xa9\xe0\x7f\x76\xda\x46\x81\xcf\x39\x5c\x26\x97\x34\xcb\x16\x84\xcd\x79\x62\xc2\xfa\x20\xce\x91\x1b\x34\x36\x6f\x37\x99\x6d\x65\xf1\xed\xd8\xfa\x70\x09\x4b\xd7\x5f\xba\xb6\xe7\xcc\x4b\x63\x6e\x3b\x6b\x0d\x1e\x86\x33\x1f\xad\x15\x18\xc1\x1f\x16\x6d\xbf\xe8\x1a\x6b\x91\xe8\xc3\xc7\xcd\xa6\x46\xd2\x89\x1a\xb5\xa4\x40\x4d\xd1\xb0\xcc\x32\xbb\xe9\x68\x7d\x5c\x9e\xf4\x0a\xab\x20\x2e\xa3\x86\xa8\x68\x64\x46\x73\xea\xd9\xfb\x0b\x0b\x09\xdb\xe6\x56\x16\x32\x93\xd3\x45\x0c\x59\x58\x11\xd8\x2c\x5d\x5f\x0c\x39\x64\xc1\xe1\xef\x7d\x63\x2b\x7a\x6b\xd8\x96\x85\xf7\x3a\x44\xaf\x43\xb4\x7a\x7a\x1d\xa2\xd7\x21\x7a\x1d\xe2\xe7\xaa\x43\x90\xde\x1a\xd6\x73\x32\x78\x7a\x4e\xd6\xe2\xe9\x39\xd9\xbe\x80\xd2\x73\xb2\x9e\x93\xb5\xfd\xd0\x06\xd4\x8a\x55\xf4\x56\xde\x70\x87\xb1\x26\xd9\xa0\xed\x08\x60\xbf\x7f\x46\x95\x2c\xf6\x89\xb3\xc7\x6c\xc2\x0d\x91\xc2\xb9\x78\x8d\xc8\xcd\x8a\x9e\xc0\x4d\x5d\x8b\xc3\xa0\xba\x35\x07\x6a\x58\x7f\x90\x40\xe1\xa0\x1d\x1d\x2c\x6b\x89\x7b\x4e\xa8\xd6\x7c\x2a\x86\x85\x4c\x87\x76\xb4\x93\x75\xee\x91\x2d\x58\x4a\x9c\x78\x6f\x3b\xed\xde\xba\x53\x85\x4c\x77\x74\x5b\xb4\x20\x5b\xef\xb5\x88\x36\xac\x44\x0e\x33\x09\xf1\x02\x60\x11\xb3\x5d\x7c\x98\x2e\xcd\xd1\xac\x36\x20\xff\x94\x82\xa1\x6b\x9a\x3d\x31\x60\x1c\x43\x4f\xd3\x42\xa6\x47\xfa\x78\xad\x0b\x53\xef\xf5\xd8\x7b\x3d\xbe\x48\xaf\xc7\x19\xd5\xb8\xaf\x8e\xfe\xac\x75\x82\x8c\x0e\xdf\x2d\x53\xf9\x67\xe4\x03\x69\x51\xc4\x6d\x31\x44\xd7\x54\xdb\x88\xab\x4d\xdd\x8d\x06\x4b\xaf\xeb\x6b\x74\x9a\x06\x2c\x84\xa6\x29\x4b\x49\xc1\xd4\x10\xd1\xc2\x12\x72\x91\xae\x58\x9f\x87\xc9\x93\xfb\x32\xd6\xe7\xfe\xc4\x0e\x8d\xf5\x8f\x77\xb4\x16\xc7\x66\xee\x1a\xa5\x7e\x56\xf7\xc6\x6e\xf1\xaf\xc6\x99\xa4\xbf\xde\x7b\x1c\x2c\x70\xff\x6d\x02\x4a\xfd\x69\x6a\xd7\xa0\xc4\xfc\x58\x32\xb5\x20\x72\xce\x54\x25\xea\x47\xc1\xef\xc0\xeb\xb8\x26\x09\xd5\x48\xe9\xbb\x28\xd8\x1d\x14\xcb\xee\x5a\xdc\x6e\xb6\x72\xd2\x84\x43\x73\x98\x7a\xdc\x25\xc2\x68\xa5\xe9\x61\xc5\xbd\x44\x75\x1f\xd1\x7a\x2e\xbb\x08\xbc\x9d\xc5\xdd\x95\x1b\xff\x42\x4d\x12\x64\x37\xb3\x04\xd9\xc9\x34\x41\x3a\x9b\x27\xc8\x2e\x26\x0a\xb2\xa3\x99\x82\x74\x37\x55\x90\xe6\x76\x43\x34\x9b\x76\xc1\xb3\xfb\xb6\x5a\x90\x5d\x95\x74\xb2\xa3\xf5\x62\x69\x79\x01\xfd\xd4\x63\x99\x32\x00\x87\x6b\xd6\x8c\xa7\x02\x50\x77\x4b\xc6\x12\x78\x9c\x09\x80\x83\x1a\xff\x99\xd8\x35\x1e\xdd\xc8\x40\x76\x36\x34\x90\xdd\x8c\x0d\x64\x37\x2c\x00\xd6\xf4\x16\xb4\xfc\x87\x30\x37\x1c\x01\x49\x7b\x4e\x0b\x8b\x00\xff\xb2\x14\x1c\xf6\xe0\x3f\xa4\xa0\x5c\x69\x2b\x63\x39\xab\x50\xfc\x9b\xd3\x74\xe3\x61\xec\x08\x5c\x13\x4b\x6a\xe7\x34\xb3\x3c\x03\x3d\x3c\x9c\xce\x61\x47\x6f\xb2\xd4\x01\xb9\x9f\x59\x4d\xce\x52\x1e\xd4\x44\xb8\x26\x07\x77\x6c\x71\x30\x58\x42\x9a\x83\x2b\x71\x80\xbc\x65\x09\x4d\x02\x23\x82\xa4\x52\x07\xf0\xdb\xc1\x3e\xb9\x70\x47\x86\xd3\xcd\x8c\xb1\xee\xa3\x9d\x92\x85\x40\x3e\x97\xfd\x0a\x7d\xc8\x05\xf0\x9a\xc5\x7f\x41\x57\x0c\x02\x9c\x32\x22\xe6\x10\x7c\x4a\x00\x9f\xe0\x7d\xea\x95\xc8\x52\x44\x59\xdb\xa2\xc1\x90\xc9\x2c\x3b\x36\xb9\x4d\x96\x02\x32\x83\x69\xdb\xc2\x21\x5c\xd4\x19\xda\x8e\xd0\x71\xa4\xe2\x56\x22\x6d\xba\x92\x54\x3d\x40\x76\xcb\x19\x15\x9a\x1c\x78\x9b\x4d\x9c\x0f\xe7\x60\x54\xc5\xbf\x85\x11\x8f\xfe\xf5\x9f\xe3\x5a\xcc\x5b\x35\x60\x2f\xf1\xf6\x12\x6f\x2f\xf1\xf6\x12\x6f\x78\x7a\x89\xf7\xb1\x00\xd4\x4b\xbc\xbd\xc4\xdb\x4b\xbc\xbd\xc4\x8b\x4f\x25\x82\xed\x20\xea\xc6\xf2\x67\x48\xfb\x49\x21\xf7\x32\x4f\x2a\xcf\x22\xdf\x0a\xff\xb5\x5f\xb9\x37\x96\x69\x57\x4b\xbd\xb1\x64\xbc\x24\xdf\x8f\xb6\x88\xb8\x41\x08\x5e\xea\xb9\x59\xfa\x7d\x7e\x0f\xa9\x8e\x78\x10\x19\xd1\x77\x4a\xfd\xe8\xae\x6d\x5d\x91\xaa\x31\xab\xee\x74\x53\x72\xe4\x6f\x15\x8e\x5d\xa5\x86\xfa\x8f\xc2\xf0\x61\xd5\x22\xdc\x33\xc0\xd5\x58\x2d\xb2\xa5\x66\x8e\x5f\x4e\xe4\x5c\xed\x9d\x25\x0d\x4c\xd5\xe6\xc0\xab\x74\x75\x54\x13\x55\x0a\x61\x47\x0d\xde\x00\x8e\x96\x60\x52\x3c\x87\x65\x28\xd8\xc0\x7c\x30\x57\x7f\x80\x50\x74\x57\x87\x59\x6d\xa9\x70\x8e\xf6\x52\xf8\xb2\x1a\x22\x4a\x84\xe9\x10\x10\x56\xc4\xc3\xd7\x47\xe4\x12\x70\x2e\x1e\xd8\x15\x7d\x80\xa2\x1c\x6d\x49\xcd\x63\x07\x1d\xdd\x77\x0e\x3a\x6a\xdc\x49\xf5\x31\x47\x3f\xd1\x98\x23\xf8\x11\x8f\xc9\xde\x83\x8f\x30\x97\xa5\x81\x73\x6c\x41\x15\xb2\x58\xfa\x8b\x77\xfc\x54\x86\xd2\xe0\xc4\x79\x46\xd4\xf1\xd0\x67\x9b\x6b\xe0\x23\x8c\x07\x1e\x58\x1a\x0e\xa6\xf3\x3e\xa0\x59\xe6\x22\x79\xbc\xe8\x88\x2e\x16\xfc\x39\x6e\xce\x2f\x7c\xa1\x34\xaf\x5d\x00\xf1\x38\xb2\x34\x2e\xb3\x9b\x68\xa9\xd5\x06\xe2\x88\x4a\xca\x9c\x79\xf6\x39\xe5\x73\x26\x2a\x0a\x79\xa4\x8f\x8f\x3d\x1f\xde\x2b\xe5\x7e\x14\xca\xfb\xc7\x88\x42\xfe\xa9\x0d\xed\x85\x05\x05\xea\x5b\x81\xaf\xa2\xbd\x4f\xed\x22\xd0\xf6\x8e\xba\xbd\x3e\xdf\xf1\x6e\xfa\x89\xee\xa5\x5f\x76\xdc\xd6\x33\x5a\xe5\x9e\xd2\x1b\xfe\x45\x5b\xe2\x7a\x77\xf8\x56\xcf\xd3\x59\xdb\x9e\xc7\x2b\xfe\x85\x5b\xd8\x9e\xc3\x2b\xbe\xb7\xaa\xad\xdd\x88\x97\xe0\xac\x5e\x7f\x3a\x5b\xd1\x7a\x0b\xda\x4e\x1c\xb3\x03\xa3\x78\x88\xe5\xac\xc3\xee\xef\x70\x47\xdc\xdf\x0f\x3f\xfe\xfd\x70\x2f\x79\x6e\x04\x4c\x2f\x79\xf6\x92\x67\xbb\xa7\x97\x3c\x7b\xc9\xb3\x97\x3c\x7b\xc9\xb3\x97\x3c\x5f\xac\xe4\xd9\x35\x27\x54\x7f\x4f\xbb\xf3\x3d\x6d\x17\x2a\xd0\xfa\xec\x77\xd8\xf3\x4e\xf7\xb2\xfd\x9d\xec\x4b\xb8\x93\x6d\x15\x4c\x2d\x0c\x7f\x48\x40\x75\xbc\x3f\xeb\xa2\xaa\xe9\x5c\xf2\x94\x14\xa5\x71\xb1\xab\x7d\x64\xf5\x2e\x91\xd5\x35\x48\xf7\xe1\xd5\xad\xc2\xab\xd7\xc1\xac\x8f\xb1\xee\x63\xac\x6b\x4f\x1f\x63\xdd\xc7\x58\xf7\x31\xd6\x7d\xc4\xc9\x2e\x0b\x7e\xe1\xd6\x46\xd2\x47\x9c\xd4\x9e\x3e\xe2\x64\xe3\xf2\x5e\xb8\x55\xf2\x41\x00\xea\x23\x4e\xfa\x88\x93\x3e\xe2\xa4\x8f\x38\xc1\xa7\x8f\xb1\x7e\xb1\x77\xe8\xa4\x97\x78\x7b\x89\xb7\x97\x78\x1b\x4f\x2f\xf1\x36\x9f\x5e\xe2\xdd\xf2\xf4\x12\x6f\x2f\xf1\xf6\x12\x6f\x2f\xf1\xe2\xd3\xc7\x58\xf7\x31\xd6\xa4\x8f\xb1\xfe\x5c\xef\xf3\x3b\xee\x74\x1f\x63\xfd\xa8\x31\xd6\xb5\xbb\xe5\xe7\x0b\xb4\xee\x3e\x8d\x3e\xda\xba\x8f\xb6\xee\xa3\xad\xd7\xed\x68\x1f\x6d\xdd\x47\x5b\xf7\x31\x2f\x7d\xcc\xcb\x8a\xa7\x8f\x79\xe9\x63\x5e\x56\x3c\x7d\xcc\x4b\x1f\xf3\xb2\xf6\xe9\x6d\x69\x3f\xb5\x98\x97\x3e\xda\xfa\x25\xdd\x14\xf7\x92\xe7\x46\xc0\xf4\x92\x67\x2f\x79\xb6\x7b\x7a\xc9\xb3\x97\x3c\x7b\xc9\xb3\x97\x3c\x7b\xc9\xf3\xc5\x4a\x9e\x7d\xb4\x75\x1f\x6d\xbd\xea\xe9\x6f\x67\x5f\xc2\xed\xec\xd6\xdd\x0d\x26\xf6\x56\x71\xd6\x87\x1f\x7d\xf3\x58\x62\xf1\xf1\xaa\x2a\xfa\x11\x65\xd5\xa0\xe1\x39\xea\xc8\xd4\x88\x5c\xe5\x79\x69\xe8\x38\x7b\x68\x39\xf0\x9c\x0a\x3a\x65\x43\xf7\xf1\x61\xf8\xf8\x30\x7c\xeb\x21\x15\xc2\xdb\x08\xb7\x19\xcf\xb9\xd9\x78\xc8\xea\xc0\x7b\x0b\xed\xdd\xcb\xb1\xd3\x1f\x72\xfa\x89\xe7\x65\x4e\x68\x2e\x4b\x64\x50\xcb\xe0\xf4\xdb\xbd\x17\x80\xad\x00\x94\x5e\x0b\xa9\x96\xd0\x22\x3b\x31\x9e\x82\x1a\xc3\x94\x38\x25\xff\xef\xe8\xaf\xbf\xfe\xf7\xf0\xf8\xcf\x47\x47\xdf\xbf\x1a\xfe\xef\x1f\x7e\x7d\xf4\xd7\x11\xfc\xe3\x57\xc7\x7f\x3e\xfe\xb7\xff\xe3\xd7\xc7\xc7\x47\x47\xdf\x7f\xfd\xee\xab\xdb\xeb\xcb\x1f\xf8\xf1\xbf\xbf\x17\x65\x7e\x87\x7f\xfd\xfb\xe8\x7b\x76\xf9\x43\xcb\x41\x8e\x8f\xff\xfc\xcb\x8d\xd3\xa2\x62\xf1\x61\xd2\xe2\x1a\xad\x83\x77\xc0\xb0\x3d\x99\xfd\x34\xac\x76\x74\xc8\x85\x19\x4a\x35\xc4\x6e\xa7\x50\xb6\x7f\xa3\x67\x01\xd3\x5d\xf0\xf1\xa3\xeb\xd1\xc4\x48\x2e\xb6\x62\xa4\x0a\x51\xbb\x57\x13\x12\xc6\xe1\x9a\xc8\x9c\x1b\x4b\xcb\x26\x56\x13\xab\x8e\xfd\x80\x70\x63\x09\x2c\x2d\x33\x03\x09\x05\xdc\x59\x80\x68\x74\x0c\xe0\x67\x9f\x8a\x8c\x27\xdc\x64\x8b\x8a\x66\x0f\x30\xd5\xc2\x3d\x47\xdf\x00\x2a\x08\xcf\x0b\x14\xe5\x00\xa7\x87\x9e\x66\x03\x61\xee\xcf\x47\x7f\x3e\x56\x9f\x0f\xbd\xc5\x3c\x5a\x3b\x17\x95\x04\x11\x1b\x1b\x82\x7d\xc1\x62\xb6\x4f\x8b\x01\x72\x0c\xe2\x90\x3d\x0b\xa0\x2e\x5a\xb9\xe1\x23\xb3\xb8\x4c\x6f\x98\xd1\x4e\x72\x80\x1e\x56\xf6\x5f\x32\x7e\x82\x63\xcd\x98\x55\xc2\x27\x9d\x4c\xea\x2d\x52\x56\x64\x72\x61\x91\x7e\x44\xae\x0c\x2a\x9f\x20\x61\x04\x77\x15\xc3\xf2\x22\xa3\x86\x1d\x6a\x9c\xed\x5a\x3b\xd4\x9e\x38\x5f\x17\x2b\xe4\xf3\xda\x1e\x1f\xc7\x23\xe6\x45\x5a\x17\x1f\xc1\x55\x64\xbb\xfd\xb0\xa5\xd5\xb0\xbd\xad\xb0\x95\x85\xf0\xb1\xed\x82\x1d\x94\xa2\xf6\x36\xc0\x97\x6f\xf9\xeb\xb0\xec\xb6\x56\xbe\xde\xb6\xb7\x09\xd4\xcf\xa1\xcb\xb7\xb4\xd9\xf5\x96\xba\x0e\xfc\xe5\x11\x84\xbf\xad\x7b\x69\x64\xc6\x50\x72\x6d\xa7\xbb\xdf\x56\xed\x43\x76\x26\xb4\x41\x45\x23\x6d\x96\x1b\x36\xa1\xeb\x16\x24\x5d\x4a\xca\x04\x62\x8b\x3d\x5b\xd5\xbc\x00\xb5\x8c\xa1\x90\x96\xc9\x48\x3f\x2f\xbb\x71\x62\x41\xec\x9e\x19\x97\x97\x2b\x4a\x54\x65\x14\x78\xe2\xfe\x31\x60\xdb\x80\x81\xfc\xf4\x27\x52\x6a\x6f\x18\x0a\x56\xa2\x80\x21\x7f\xf4\xff\xfa\xd3\xfa\xcd\x6d\xb5\xb5\xed\x18\x1b\x4e\xa9\x83\x80\x71\x09\x1d\x08\x17\x29\x4f\x82\x30\x80\x10\xc0\xb1\x2c\x7c\x60\x59\xde\x4a\x84\xa6\x45\x14\x0b\xc1\x7b\x38\x6a\xac\x9d\x07\x73\xa4\x57\x39\x93\x42\x75\x32\x18\x79\x2f\x9d\x3b\x3a\x1b\x90\x6b\xc8\x68\x55\xbd\x81\x93\xf4\x5e\xa2\x63\x3a\x6b\x23\x87\x6c\xe5\x22\x5b\x19\x7d\x0d\x20\x5f\x57\x4c\x1e\x57\x56\x63\xf2\x15\x06\xd7\x6c\xc3\x9b\x20\x73\xc7\x16\x15\xb3\x71\x22\x04\x90\xfc\x41\x85\x25\x9e\x15\x20\xef\xf8\x6f\x6f\xca\xca\xc7\x5c\xe0\xc7\x70\x68\xbf\x15\x30\xba\x07\xa8\x95\xec\xb2\x0c\x3f\xb3\x0f\x70\xb5\x93\x33\x6a\x30\xfb\xd0\x41\xc6\x08\x54\x72\xb5\x74\x11\x89\x14\x97\x3f\x96\x34\x1b\x91\x8b\x48\x99\x77\xaf\x5c\xa3\x25\xaa\x7e\xcf\xb3\x34\xa1\x0a\x8d\x02\x78\x46\x89\x96\xb8\x7b\xe8\x1f\x9d\x50\x11\x4e\x7b\xb5\x47\x98\xb1\x8d\x14\x54\x19\x9e\x94\x19\x55\xc4\x9e\x85\xa9\x54\x8b\xbd\x40\xb4\x42\x9a\x1b\x96\x48\x91\x76\x4a\x2b\xd7\xec\x1b\xc3\x18\x28\x2b\x53\xdc\x39\x7e\xf3\x9c\x35\x91\xf4\xc8\x25\xdc\x73\xf8\x25\x27\xfe\x54\x87\x23\x56\xb3\x7c\x54\xb7\x14\x5c\x13\x8e\x91\x22\xc7\x11\x79\x0c\xa7\x62\x44\xbe\x5c\x78\x33\x0b\x98\x5c\x9c\xbd\x58\x33\x33\xf0\x49\xfe\x1c\xca\x3a\x60\x57\x07\x6a\x22\x15\x9b\x33\x45\x8e\x52\x09\x7d\x20\x20\xe2\x78\x44\xfe\x3f\xa6\x24\xde\x69\xb0\x29\xfa\xf1\x3b\x14\x0f\x8a\x2b\xa4\x55\x04\xbb\xf9\x2b\x72\x84\x71\x14\x3c\xcf\x59\xca\xa9\x61\xd9\xe2\x18\xf5\x58\x1f\x89\xd1\x66\xeb\xda\x18\x0d\xa2\x70\x9b\xdf\xfd\x76\x43\x4b\x98\x6c\x87\x9d\xfd\x16\x4c\xfc\x35\x52\x83\x56\xff\xc6\x16\x06\x1e\x24\x37\x88\x9b\x91\x78\x19\x5d\x7d\x78\x32\x13\x36\xf8\x1f\x16\x0f\x28\x51\x6c\x0a\x58\x8e\x98\xfb\x40\x1c\x9f\xcb\xac\xcc\xd9\x3b\x59\x8a\xf5\x26\xc1\xda\xc2\xdf\x3a\x25\xfc\xdb\xa8\x23\xe4\x02\x65\xc6\xcb\x6f\x95\x15\xff\x49\xc4\x84\x68\x26\x91\x89\x92\x12\xb0\x4b\x02\x3b\xb7\xe4\x01\x5b\xc1\x3d\x0c\x17\xb1\xcd\xf1\x81\x9c\xbd\x8d\x96\x3c\xc4\xb9\x5c\x53\x33\xdb\xd8\x4a\xd0\x7c\xbd\xe1\xb6\x9d\x08\x11\x3e\xd4\x01\x97\x6d\x73\x0f\x98\xda\xfe\x11\x6a\x1c\x39\x00\xfc\x44\x08\x56\x08\x0a\xdf\x62\xe9\x88\x90\x77\x16\x33\xf1\x46\x0e\xba\x92\xc3\xd3\xc3\xbd\x10\x5f\x5c\x8e\x92\x05\x9d\xd2\x6d\x91\x6e\x4d\x65\xa4\xd1\x95\xa4\xcc\x30\x95\x43\x88\xd2\x4c\xde\xe3\xef\xc8\xb6\x0a\xd7\x8a\xb9\x88\x2e\xc8\x52\x2a\x35\x70\xa5\x08\x18\xfe\xea\x17\xd2\xfa\xde\xd3\x05\xa1\x4a\x96\x22\x75\x52\x53\x20\xa0\xef\x1a\x1f\x7e\x2f\x05\x50\x8a\x52\x5b\x58\xdd\xd6\xa8\xf4\x98\x19\x6a\x8f\xcd\xeb\xd1\xeb\x2d\x91\x86\x2d\x01\x66\x51\xa8\x53\xde\x53\xae\x9b\x96\xc2\xf7\x34\x67\xf1\x99\xd9\xcb\xbc\x14\xa3\xe9\x07\x91\x75\x91\xe5\xde\x21\x7a\x41\xd7\x21\x28\x61\x7c\x02\xb6\xdb\x01\xbe\xba\x57\xdc\xb0\x88\x3c\x1e\x4d\x68\xa6\x21\x1d\x70\x29\x82\x08\x7b\x5c\x17\x41\xa0\x49\x9b\x05\x8d\xa5\xcc\x18\x15\x1b\x5a\xea\x72\xfc\xc0\x73\xe6\x0e\x14\xa0\x5c\x75\xcc\x02\xc2\x1d\xea\x0d\x47\x2e\x5e\xd4\xc1\x01\x39\xc2\x96\x56\x62\x93\xd2\xac\x4d\x36\x1d\xaf\x70\xeb\x96\xb9\x05\x5a\xcd\xba\x8b\x4a\xf2\xa9\xa0\x02\xf2\xe0\xee\x71\xb5\x5f\xb2\x19\x9d\x33\x4d\x34\xcf\x79\x46\x55\x06\x51\x99\x37\x38\x3f\x48\x15\xcd\xc4\x9c\x2b\x29\xc0\x24\x30\xa7\x8a\xd3\x71\x66\xd5\xf4\x09\x53\x4c\x24\x4c\x93\x5f\x1e\x7d\x7b\xf6\xf1\x6f\xef\xcf\xde\x5d\x1e\xc3\x89\x67\x7e\x96\x95\xf6\x17\xcf\x24\x1a\x6e\x2b\xa8\xfd\x3c\x2c\x9c\x80\x46\xf8\x79\x61\x08\xa8\x8f\x1b\xfd\x94\x64\xa5\xe6\xf3\x87\x9e\x26\xfc\xf8\x2e\xac\xba\xc9\xa5\x0b\x99\xde\x14\x2c\x79\x4a\x1e\x5d\xd7\x30\x2c\xa9\x4a\xfd\xa6\x03\x4f\x46\x65\x9f\x62\xda\xef\x31\x23\x34\x49\x98\xd6\x78\xc5\x61\x75\xfb\x8a\x16\x57\x6b\x78\x12\xf6\xbd\x07\xc6\x4c\xef\xf5\x65\x46\xb5\xe1\xc9\x97\x99\x4c\xee\x6e\x8c\x54\x5d\x08\xf5\xe1\xaa\xfe\x35\x78\x0a\x72\xf6\xdd\x0d\xb9\xe0\xfa\x2e\x5c\xc0\x86\x4b\xd3\xd8\x5c\x42\xc9\x5d\x39\x66\x19\x33\x87\x87\x1a\xb9\x5c\x4e\x93\x19\x17\xcc\x33\x38\x61\x4f\x87\xd4\x95\x83\x94\x85\x72\xd7\x3b\x53\x6d\xa4\xa2\x53\x76\xe2\xf0\xf5\x17\xf4\x5e\x33\x9c\xfe\xd8\x4e\xdf\xfe\xcc\x36\xdd\x96\x3e\xca\x3d\x05\x4e\xe6\xea\x62\x4f\x77\x10\x13\x7d\x6b\xe7\xd8\xcd\xb8\x7d\x88\xbd\xbc\xea\x30\xe1\x19\x73\xb1\xe7\x76\xc1\xde\xd9\xc7\x9d\x0a\xd8\xbf\x85\x2c\xc9\x3d\x45\x1d\x19\x28\xe2\x88\xdc\xf2\xe2\x94\x5c\x0a\x5d\x2a\x56\x59\x37\x9a\x43\x71\x4d\x74\x59\x14\x52\x85\x4b\x42\x27\xd5\xa0\x02\x62\xe9\x9e\xd3\xb5\xc8\xe5\x27\x9a\x17\x19\xd3\xa7\xe4\x80\x7d\x32\xbf\x3d\x18\x90\x83\x4f\x13\x6d\xff\x27\xcc\x44\x1f\x8c\xc8\x55\x1e\x6e\xdd\xb9\x70\x49\xcc\xf1\x62\x13\x3b\x58\xd6\x1c\x71\xdd\x47\x41\x17\x72\xfb\xe1\xe2\xc3\x29\xc8\x6e\xa9\x24\xf7\x56\x6c\x83\xc0\x7c\xc2\x94\x92\x4a\x7b\x9a\x10\x81\x01\x78\x4d\x22\xf3\x42\xc9\x9c\x47\x66\x3e\x40\xf7\xcd\xd8\x47\xba\xdd\x73\x80\xf1\x61\xbb\x80\xba\x8c\x0d\xa1\xa3\x47\x88\xe8\x85\x68\x83\x0a\x57\x13\xef\x4c\x81\x5a\xa4\x53\xeb\x61\x38\xd7\xc8\x6e\xbe\x1b\xc5\x12\xb2\x78\xbb\xdf\x48\xe5\x7f\x3a\x49\xd9\xfc\x44\xa7\xf4\xf5\x00\x3e\x83\x7b\xb9\x68\xcc\x89\x6a\x72\xf0\xfa\x60\x44\x6e\x3c\x23\x1e\xc4\x73\xac\xda\x4d\xa4\x0a\x03\x82\x9d\xfd\xd5\x01\x39\x92\x0a\x46\x4e\xa8\x20\x19\xa3\x73\x67\x5b\xc6\xe3\xb6\x40\x75\xf7\x78\xd4\x76\x5b\xf6\x9b\x6f\x03\x9f\x76\x42\xea\xf2\x26\xfa\x7e\xde\x04\xa0\x4a\x86\x66\x8f\x89\x44\x2a\xcc\xc2\xd0\x96\x03\xc3\xd1\xe3\xa2\xa6\x42\x3f\x03\x81\x25\x1d\x84\x5d\x12\x44\x8f\xab\x8b\xae\xd0\xf1\xfd\x40\x07\x12\xfc\xc7\x92\x91\xab\x0b\x4f\xe8\x0a\xa6\x34\xd7\xc6\x1e\xe3\xb4\xc6\xba\x38\xf2\xb3\xa3\xb3\x9c\xfe\x53\x0a\x72\xf9\xe5\x8d\x9b\xc0\xf1\xb3\x82\x6a\x2b\x35\xa0\xff\x2c\x15\xb3\x5c\xb8\x03\x73\x0f\x7d\x9a\x0c\xdd\xbe\x27\x17\xd4\x50\xe4\xeb\xce\xd3\x4a\x54\xa4\xdc\xb2\xec\x31\x17\xa9\xfb\x29\x62\xd8\x4f\xcd\x5b\xed\xee\xbd\xdf\x24\x26\xc5\x0d\xbf\xf9\x78\xb5\x27\x1e\x9c\x00\x31\x9f\xbe\x93\x69\x67\x46\x1c\x75\xf5\xc4\xf7\x2f\x16\xa6\xe7\xf8\x9e\xe4\x76\x4c\xf2\x1e\xea\xfa\x7c\x64\x34\x25\xf6\xfc\xba\x7f\x7e\x67\x75\xcf\xd6\xb4\xaa\x15\x0b\xf1\x00\xec\xb8\x0c\xdf\xcd\x2f\xc1\x6b\xef\xc0\x0b\x2c\xe6\xc0\xb1\x72\xbc\x64\x9c\xc9\x31\x71\xc7\x61\xdf\x73\xff\xe6\xe3\xd5\x0e\x53\xff\xe6\xe3\x95\x9f\xb9\xfd\xa7\x9c\x3c\xdd\xa4\x77\x12\xdf\x2a\xe9\xed\x4d\x43\xdc\xaa\x58\xf2\x3b\x67\xaf\xa7\x4b\x22\x59\x7b\x79\x6c\xb4\x2f\x49\x6c\x9f\x10\xbb\xe3\xa2\x45\x5c\x61\xfd\x94\xd9\x3e\x56\xa1\x40\x5f\xb5\xe8\x1e\xf1\x66\x46\x2d\x61\xa9\xb2\x24\xc1\x3e\xdb\x8d\xd7\x96\x2b\xf8\x1d\xb7\x4a\x20\xd0\x36\x72\xc1\xf0\x96\x33\x3d\xf5\xbe\x03\xa1\xc7\xea\x0e\xef\xc0\x53\x33\x75\xf4\x95\xa0\xe3\x66\x1a\x21\xd8\x11\x5a\x95\x44\xf8\x89\xce\x29\xcf\xe8\x98\x67\x50\x11\x8c\x59\xed\x3e\xf6\x46\xd5\x30\xe5\xbd\x9e\xfa\x1d\x45\x8e\x20\x4e\x2c\x19\xb7\xc8\x91\xfd\xed\x04\x8c\x63\xc7\x23\xa0\x56\xd0\x10\x22\x19\x1a\x42\xc9\xc7\x6d\x42\xc9\xde\xe4\x07\xd8\x01\x7b\x62\xba\x72\x45\xdb\x67\x25\x57\x84\x1f\x6e\x98\x9a\xf3\x84\xbd\x68\xc6\xa8\x59\xa2\x98\x69\xc5\x1a\x01\xbf\xb6\xb6\x6c\xcf\x1c\x1f\x8a\x5c\xe9\xe7\x81\x5c\x04\x5c\x77\x3d\x94\x3b\x2e\xb6\xea\xe8\xf9\x10\x28\x49\xe0\x71\x06\x3f\x35\x5c\x33\x11\xfb\x6e\x1c\xad\x39\x73\xb4\x06\xfa\x5b\x9c\x6b\x53\xdb\xa9\x03\x79\x08\x18\xd1\x75\x55\xbe\x9f\x5f\x14\x92\x40\x78\x4d\x5a\xe0\x62\xeb\x49\x26\xac\x98\x4d\xba\x5c\x89\xdb\x0e\x6f\x6e\xea\x96\xc0\x73\x56\xcc\xc8\x9b\x9b\x15\xc7\x18\x4b\x09\xda\x59\x6b\xb4\x0f\x1e\x6a\x92\xf1\x09\x33\x7c\xcb\x12\x1e\xe1\x20\xe7\x52\x70\x23\x95\xde\xd3\xe1\xf4\xc3\x75\x65\xa8\xbe\x9f\xdd\x59\x5f\x15\xed\x94\xbc\x8b\xde\x52\x92\xc8\x2c\x63\x89\x71\x71\x8d\x00\xde\xd0\x6d\x85\xf2\xc4\x9c\x3d\x60\x74\xf7\x07\x50\x9f\x9c\xa2\x74\x82\x9b\x7b\xf2\xf1\xf2\xec\xe2\xdd\xe5\x28\x4f\x7f\x31\x93\xf7\x43\x23\x87\xa5\x66\x43\x6e\xda\xf2\xc1\xe7\x8b\x44\x2c\xb6\xde\xcf\x90\x15\x06\x19\x33\xb3\x40\xfc\x50\xa0\x23\xde\x29\xf9\x46\xa3\xd7\x02\xd8\x8e\xfc\x9d\x94\x94\x66\x40\x14\x85\xab\x40\x33\xa3\xce\xf4\x54\x66\x19\x42\xdb\x28\xc6\x06\xb1\x2d\x66\x63\x68\x48\xe7\x85\x3d\xd8\x50\x51\x5b\xe0\xe3\xca\x10\x4f\x8f\x70\x5d\x38\xc6\x76\x99\x64\x19\x8a\x55\xcf\x3a\x1c\x6f\x6a\xef\xd1\x70\x66\x66\x16\xaa\x77\x6c\x41\xc0\x11\x78\x22\x95\xc5\x27\x55\xc7\x0d\x66\x12\x58\xfa\x49\xa9\x99\x1a\x39\xb6\xf3\xe4\x60\x6b\xc7\x90\x60\x72\x1f\xd9\xd6\xc8\x9e\xd5\x40\xfb\xc8\x26\xab\x60\xe6\x5e\x87\x0b\x3b\x2f\xaf\xd1\xd2\xcc\x98\x30\x56\xec\xb7\xb4\xcc\x41\x66\x25\x10\x9d\x1f\xf6\x93\x43\xed\x51\xd2\xf7\x6c\xbf\xc5\x5f\x0d\xe4\x58\xf9\x77\xc0\x34\x9d\xcd\x65\x72\x6e\xa5\x6a\x76\x7f\x72\x2f\xd5\x1d\x17\xd3\xe1\x3d\x37\xb3\x21\xae\x53\x9f\x40\x78\xf4\xc9\x2f\x30\xde\x1e\x2d\xf2\x67\x69\xea\x9c\x22\x4a\xcd\x26\x65\xe6\x6a\xa2\x8e\x08\x2d\xf8\xb7\x4c\x69\x2e\xc5\x00\x74\xc7\x01\x29\x79\xfa\xe7\xed\x90\x25\xdd\x70\xd2\x9e\x9a\xae\xe8\x68\xfb\x40\x20\x62\x4c\xe6\x43\x2c\x97\xa2\xa9\x04\x87\x0d\x05\x5b\x51\x43\x34\x9a\xe6\x5c\xbc\xc0\xd3\x99\x70\x91\x6e\x83\x43\xc3\x00\x06\x3d\xea\xa2\x98\x7b\xe7\x0c\xfa\xe1\xde\x90\x7a\x4d\x0a\x92\x39\xfb\x1b\xc4\xfa\xfd\x61\xab\xc3\x97\x2f\xf4\x8f\xd9\x10\xbf\x32\x2c\xd2\x0a\x2a\xfd\x65\xe0\xf2\x0d\xde\x7e\x4d\x4a\x4f\x70\xc5\xb7\xa7\xdd\x26\x4f\x2c\x0d\x3d\xae\x9e\xfb\x24\x80\xea\x22\xf3\x3c\x94\x7b\x57\x34\x13\xd2\xae\x6b\x1f\x7c\x06\xcc\x19\xcf\xa8\xd7\x97\x21\x1d\x3b\x55\x34\x67\x86\x29\x74\x81\x73\x4e\x75\xc2\x45\x27\x7c\x28\x98\xb8\x31\x34\xb9\x6b\x6d\x4d\xef\x39\xee\xb3\x73\xdc\x07\x5f\x05\x7a\x44\xe0\xa9\x15\xef\xdc\x35\x73\xe5\x0a\x84\x07\xe1\x85\x90\x18\x0c\xdd\x7e\x47\x8b\x2e\x56\x0e\xdf\xa7\xc1\x5d\xc3\x6b\x67\xd8\x00\x4f\xb7\x42\x16\x65\x86\x5e\xf6\xdc\x7b\xc1\xed\x87\x1b\xb6\x3f\x03\x8e\x04\xee\x72\x8f\x16\x75\xad\x53\x87\xdc\xbe\x19\x73\x53\x9d\x7b\xcd\x0c\x29\x98\xca\xb9\x0b\xeb\x96\x82\x24\x2e\x2c\x00\xf8\x9a\xe5\x61\x6e\xb8\x88\xe7\x09\x22\x13\x43\x5d\xcc\x0c\x19\x33\x73\xcf\x98\x20\xaf\x5e\xbd\x7a\x05\x72\xc9\xab\xdf\xff\xfe\xf7\x04\xf2\x48\xa4\x2c\xe1\xf9\x72\x43\x68\xf5\xbf\x5e\xbf\x1e\x91\xff\x39\x7b\xf7\x16\xbc\xca\x0a\xa3\xc9\x58\x9a\x99\x1b\xd9\x36\xa8\x75\xd6\x03\xf2\x7f\x6e\x3e\xbc\xf7\xe2\x84\x6e\xfc\x0a\x2a\x48\x58\x5e\xdd\x45\xf0\xd5\xef\x7e\xfb\xdb\x11\xb9\xe0\x0a\xe2\x89\x39\x44\x40\x04\x27\xc8\xc2\x3b\x06\x42\x7a\x9e\x66\x04\xbf\xe3\x20\xce\x49\x38\x87\x6a\x26\x63\x3c\x10\x52\x4c\x32\x9e\x18\xcc\x23\x84\x47\x1f\x01\xed\xb2\x07\x51\x17\xee\xe5\xa4\x08\x98\xdc\x80\x64\xfc\x8e\x91\x89\xfe\x4a\xc9\xb2\xa8\xc2\x1c\x15\xd3\x56\x96\x4d\xa8\x80\xa8\x12\x18\xac\xda\x2b\xcd\xcc\xb3\x3a\x61\xb4\x34\x04\xd5\x70\x10\xfa\x34\x04\x94\x01\x16\xd2\xb8\x63\x8b\x21\xe2\x43\x41\x79\x70\x1c\x84\x3b\x75\xf4\xc2\xae\x13\xef\x84\xa5\xe4\x3c\x9c\x52\x1f\xbb\x52\x28\xf9\x0f\xdc\x2a\xee\x2b\x99\x78\x09\x59\x3b\x99\xcc\x05\x9d\x8a\xc8\xe6\xea\xa3\xf2\x2d\x2f\x74\x11\xff\x51\xfc\xd4\xd5\x24\x0e\xb4\x33\xae\x30\x08\x4b\x21\x16\x6c\xd3\x97\xab\x54\x55\x16\x9b\x34\xee\x6b\x29\x96\x7a\xbb\x2a\x2c\x8e\xfc\xc0\x07\xa9\x0f\x61\xab\xc6\x40\x57\x5c\x17\x00\xe4\xda\x7a\x28\x05\x40\xd4\xbc\x7c\x34\x33\xa5\x03\x0d\x78\x5e\xd9\x6f\x33\xad\x5d\x1c\x51\x4e\xd5\x9d\x55\x12\x1c\x15\x18\x81\xd7\x73\x55\x9f\x24\x54\xf9\x00\x8d\xc2\x95\x59\xf1\x51\x03\xf6\x23\x87\xa3\xd1\x21\x1e\x13\xa9\x88\x36\x54\x39\x9c\xb7\xef\x9f\x29\x5e\xba\xee\x95\x4e\x0b\x4c\x44\x07\xf6\x1c\xcc\xe8\x05\xd1\x67\x95\xb7\x33\x75\x90\x6a\x93\xba\xaf\x63\xe2\xbe\x6e\xd9\x5d\xdb\x67\x76\x1d\xc2\x02\x5a\x34\xed\x9a\xcd\xb5\x43\x26\xd7\x75\xd9\x1a\x1c\x8c\xdd\x49\xe8\x96\x3a\xb7\x43\x52\xd2\xbc\x15\xeb\x5b\x31\xd5\xc3\xdc\x71\xbe\x0f\xdd\x38\x9f\x8b\xd7\x83\x0c\x67\x9f\x0f\xab\xbb\x9a\x60\xa4\x4b\x9d\x74\x39\xd2\x10\x8b\x02\x9e\x82\x45\x61\x2f\x2f\x9a\xa3\xc5\x68\xd3\x96\xaf\xe1\xd3\x85\xbb\xe1\xd3\xee\x62\x02\x9f\x1a\xae\xf9\xdb\x09\x5c\xb4\x23\xa5\x48\x2d\x27\x15\xa8\x20\xd2\xb8\x88\x0e\xcf\x88\xbc\x73\xa4\x16\x91\x8c\x8e\xb5\xcc\x4a\x83\x5d\xab\x1f\x63\x3a\x0c\x83\xfa\x2c\x0b\x40\x7c\x43\xb3\x88\x2a\x03\x3f\x42\x52\xd8\x8e\x40\xe3\xd3\x31\x83\x68\x57\x89\xf4\x27\xa2\x94\x75\x4a\x2f\xe3\x48\x4f\x37\x48\xf9\x6e\xc1\xdb\xf7\x7e\xc6\xdc\x95\x56\xc4\xfd\x2d\xc5\xb1\xe7\x08\x44\x0b\xcf\xc8\x5d\x4a\xb5\xbd\x99\x27\x12\xcd\xbb\xe8\x57\x9a\x93\xa3\xf3\x10\x0e\xe2\xaf\xe3\xaf\x84\x61\x6a\x42\x13\x76\x1c\xeb\x5d\xac\x98\xb1\x9c\x29\xbb\x4c\xd7\xce\xc7\x45\xcc\xa8\x48\x33\x14\xc0\x13\xa6\x00\xf7\xd9\x27\xc3\x94\x05\xc9\xf9\xcd\x15\x49\x15\x9f\x33\xa5\xc9\xd1\x97\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\x47\x16\x95\x80\x40\x03\xcd\x58\xc8\x52\x39\x2b\xfa\x44\x2a\x17\x7b\xa5\xac\xba\x84\x03\x53\x4d\x14\x9b\x5a\x69\x56\x55\xa5\x1d\x92\xac\xb4\x2f\xf6\xea\xce\xf6\x10\x07\xc0\xca\x34\xbb\xc9\x57\x6f\xe2\xa4\x6a\x39\xe7\xa9\x67\x95\x98\x0d\x78\xee\xe3\xc7\x0b\xaa\xa3\x50\x9b\xa8\x76\x65\x04\x58\x94\xd1\x81\xa1\x86\x20\xd6\x9a\xb3\x7f\x6c\x14\x96\x90\xdb\x62\x4b\xee\x83\x8e\x90\x12\x32\x65\xd7\xe5\x38\xe3\x7a\x76\xb3\xa3\x09\x71\xd5\x10\xe8\xac\xb0\x74\xeb\xb7\xd6\x92\xa8\x99\xd0\x1c\x58\x9e\x25\xe3\x96\xe9\x72\x2b\x47\x49\x00\xa2\xef\x1d\x23\xa4\x84\xe8\x8f\x8c\xb9\x0c\x06\xf6\xa7\xf7\xd5\x3c\x5c\x50\x1a\xe6\x2c\x49\xd9\x37\xa2\xa8\xbd\x4f\x68\x96\xe9\x66\xc0\xae\xa7\x98\x28\x7b\xf8\x40\x35\xdc\x53\x6e\xb7\xdb\xcf\x9e\x37\xb2\x5f\xae\x5d\x98\x26\xb9\xc4\x30\x1e\x41\xa4\xf0\x8d\x20\xf5\x8a\xef\x10\x05\x32\x42\xb8\x32\xa0\xcc\xb3\xd6\x17\xe9\xcd\xa5\x4f\xe9\xe4\x19\x67\x40\xaf\xa2\xa1\x6b\x69\x49\x03\x29\xf5\x24\x77\x8b\x53\xc7\x5e\xaf\x15\xf0\x9b\x67\xc6\x28\x3e\x2e\x4d\xf7\x7c\x6f\x8d\xee\xc0\xa6\xad\x22\x02\xa7\x78\xe8\x56\x9f\x44\x28\xea\x34\x84\x70\x16\x96\xcf\x7e\xc5\x73\x80\xdd\xe0\xcb\x43\x4d\x52\x99\x94\x21\x2f\x2c\x00\xad\xba\x40\x6b\x5b\x9b\xa5\xd3\xb9\xda\x35\xd1\x7e\x4b\xf4\x4a\xe5\xbd\xb8\xa7\x2a\x3d\xbb\xde\xe2\x7d\x5f\x67\xe7\x55\xaf\x58\x50\xf2\xaf\x89\x7d\x4f\xc7\xb2\xac\x2a\xdd\xfe\x84\xec\xd5\xab\xd4\x74\x23\x2d\x69\x68\x69\x8f\xee\xaa\xe8\xf7\x26\xee\xde\xc4\x5d\x7b\x76\x31\x71\x5f\xa1\x89\x3b\xce\x83\x5b\x3b\xae\x3e\xbd\x02\xcf\xda\xfa\xf6\x3e\xa6\x95\xf4\xa2\x22\x30\x28\x4d\x35\xfd\xf8\x1b\x02\x1c\x1e\x91\x6a\x6f\x23\xa1\xcf\x53\x20\xe0\xd9\xcf\x6f\x51\x7d\x24\x3b\x29\xac\xae\x95\x54\x8d\xcf\x72\x8a\x76\xf4\x03\xc6\xac\xd4\x78\x29\x11\xdd\x6e\x14\x32\x3d\xc5\x44\x96\x54\x08\x89\xdc\x4f\x0f\x5c\x16\xe8\x81\xd3\xbb\x44\x54\xfc\x02\x93\x50\x7b\xd6\xd8\xd1\x7c\xf6\xe8\x05\xcb\x60\x6d\x5b\xd2\x29\xc5\xcf\x2e\x35\xc8\x2a\xd9\x70\xe7\x22\x55\xae\x7f\xa8\xe0\x91\xcc\x58\x4e\xe1\x9f\x6f\xfc\x02\xec\x89\xb6\x22\x99\x61\x18\xf0\x0d\xc5\xdc\xe5\x64\x50\xf3\x49\x39\x98\xbf\x6e\x51\xf7\xa5\x7a\x76\x2a\xc8\x15\x60\xba\xf3\x72\xaf\x6b\x76\x48\x8b\x7d\xc0\x0f\x33\x4c\x51\xd9\xb8\xbb\x02\x9a\x85\xf0\x79\xd4\xa5\xed\x6e\xd6\xdf\xd5\x9c\x3f\x08\x36\xb2\xcf\x80\xad\xf7\xe6\xfc\xa5\xe7\x09\xcd\xf9\x11\xe1\xf6\xc4\x60\x85\x69\x3f\x36\xb7\x79\xfb\xfe\x98\x79\xb1\x72\x54\x65\x5f\xb3\x28\xe7\x2d\xfb\x52\xd5\xaf\x55\x0f\x47\xa3\xc3\x43\x6f\xef\x77\xf8\x59\x9a\xc9\xf0\x0f\x84\x89\x44\xa6\xb8\xa9\x76\x7c\xa5\x0d\x30\xfd\x4a\x4d\x8f\xe7\x92\xfb\x6f\xc5\x57\xb3\x30\x76\xb7\x2d\xe9\x70\x82\x7d\x4a\x80\x37\x0f\x62\x91\x15\x63\x0c\x29\x06\xdc\x02\x43\x56\x21\xc7\x21\xab\xf2\x25\x58\xb9\x07\xd0\xd2\x97\x4d\x21\x47\xf8\x72\x94\x14\xe5\xc0\x35\x18\xe5\x2c\x97\x6a\x31\x08\x8d\xec\x8f\xb5\x5e\xae\x05\xe6\x9e\x4a\x4a\xa5\x98\x80\x02\x26\x2f\x95\xbf\x7a\x10\x3c\x22\x7b\x0d\x50\x6f\x17\xdd\x56\x3d\xf5\x6d\xad\xee\x00\xc0\x24\x55\x95\x94\x9a\x84\xcc\x26\x7a\x50\xdd\x73\xd8\xb7\x4c\xcc\xc9\x9c\x2a\xdd\x16\xe6\x64\x57\x8e\x9a\xf2\x39\xd7\x0f\x28\xfb\x79\x13\xcc\x3e\x90\x76\xb0\x34\x45\x69\x1c\x75\xf2\xb8\xeb\x33\x35\x05\x9c\x6d\x08\x0e\xaf\x0f\x3a\x7c\xfc\x85\x16\x92\xa9\x3f\xad\xca\xca\xd4\x9f\x6e\x45\x66\x56\xf7\xed\xb8\xf5\x0f\x28\xd0\xd4\x7c\xfc\xd6\xee\x7e\x46\x2a\x26\x53\x25\x06\xf3\x82\xd9\x23\x1c\x02\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\x7d\x70\x6a\x18\x98\x47\xca\xd5\x9e\xa2\x11\x3a\x44\x83\xb2\x94\x97\x79\xe7\x58\x50\xe8\x15\x03\xed\x1e\xb2\x81\xb9\x4c\x62\xfe\xba\xd3\x35\xf3\x89\x15\x69\x72\xe7\x2a\x06\x79\xa8\x22\xef\x8f\x82\x5c\x0e\x0e\x1a\x79\xa0\xc1\x3c\x06\x77\x7f\x32\x65\x16\xe4\xbe\x31\x8e\x5d\x33\x65\xb9\x1a\xe9\xe8\x16\x70\xe4\x1a\x42\xd1\xc6\x77\xc0\x06\x9f\x68\x97\x48\xc7\xc8\x36\xfe\x4f\x06\xe5\xc6\x3a\xfb\xc6\xfb\x8e\x21\x1d\xb4\x04\xc9\x3c\xd4\x45\xcb\x64\x12\xdd\x3d\xd7\x38\x14\x6c\xc3\xa5\x47\x7e\x6f\xbb\xb7\x9b\x61\x47\x45\xf9\x02\x8c\x3e\x99\xc6\x7b\x3d\x9e\x40\x6a\x4b\x90\xe2\x01\x98\x61\x03\x6e\xa3\x2a\x81\xa5\xb6\x5f\x82\xcc\xf3\x51\x9b\xea\x43\xf7\x3e\xc3\xa6\x89\x0a\xb9\xd5\x75\x0f\xfb\xcb\x4d\x58\x59\xa5\xb7\x41\x08\x84\x17\xd4\x75\x09\x62\xa2\xfb\x8a\x13\x97\xe4\x04\xee\xae\xaa\xb2\x68\x21\xb9\xe3\x12\x9a\x09\x9e\xd5\xf1\xcc\xe7\xb2\x0b\x0b\x2f\x85\x73\x34\x58\x42\x9a\xd5\x38\x53\x6a\xa6\x86\xd3\x92\xa7\xbb\x60\xcb\x0b\x66\x80\xad\xd9\x5e\x77\x66\xd7\x91\xc5\x3d\x80\xb1\x05\x47\x8c\x0e\xac\xe1\xa0\xf2\xde\xa8\xf1\x86\x38\x2d\x5e\xdd\x93\x83\x7a\x67\x81\x70\xe4\xfc\x95\xd0\x6d\x50\x6d\x1d\xcf\x48\x16\x89\x0b\xd6\xe5\xb5\x74\x97\x38\x2c\x62\x1e\x38\xb6\x0e\xed\x7f\xbc\x0a\xec\xed\xf9\x63\x36\x91\x55\x85\x14\xd4\x88\x9c\x3b\x6e\xca\x32\x66\xc0\xbb\x96\x85\x4c\xa5\x78\x25\x9c\xcb\xb9\x45\xe6\xbf\x0a\xf2\x8d\xcf\xd9\xcf\x27\xa7\x84\x1e\xd7\x42\x20\x5c\xd5\x19\xc1\x58\x8a\x3e\xba\x59\xf5\x1d\x55\x0a\x3d\x20\xe3\x63\xef\x8f\x02\x27\x4e\x58\xb1\x30\xf3\x12\x2f\xea\xd5\x8a\x59\x00\x40\xd8\xb1\x92\x39\xd1\x82\x16\x7a\x26\x0d\xa8\x86\xb4\xa0\x09\x37\x0b\x62\x14\x4d\xee\xa0\x44\x91\x62\xee\x73\x03\x92\x1c\x3b\xc7\xae\x18\x7c\x75\xb7\x61\x33\x53\xb2\x9c\xce\xc0\x13\x16\x5b\x25\x19\xd5\x7e\xf5\x2b\xfb\x3b\x6d\x47\x93\x74\x21\x68\xce\x93\x90\x35\x50\xc9\x39\xd7\x5c\x3a\x6b\xaf\x1f\xf7\x3a\x64\x86\x43\x0b\xf2\x79\x46\x79\x4e\x8e\x34\x63\xe4\xd2\xa3\x04\xfe\x72\x83\x32\x0d\x5a\x36\x54\xdd\x39\x40\x86\x94\xe6\xc2\x25\x44\xa8\x08\x5c\xb8\xbc\x42\x86\x69\x67\xbe\xf2\xa3\xc7\x61\xbb\x56\xcf\x49\x2a\xb8\xb8\xf7\xa9\x3b\x99\x48\x65\x74\x6b\x79\x76\x7d\xa5\x63\x6d\x04\x71\xcb\xe5\xbd\x83\x1f\x32\x29\xa6\x71\x1a\x81\x0a\x33\xa1\x26\x30\x94\x77\x99\xf3\xb4\xa4\x19\x12\x51\x37\x99\xf3\x9b\x2b\xec\xce\xa7\x33\x33\xbc\x67\x60\x8d\x41\x5e\x53\x9d\x19\xff\x51\xbe\xe4\xad\xc3\x35\x10\x5d\xe3\xac\x09\x68\xd9\xb2\x53\xbb\xa7\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\x41\x28\x9b\x57\x9b\x7c\xeb\x4a\x27\x76\x14\x0e\x0e\xbe\x8b\xcc\x66\xd1\x45\x07\x54\x32\x17\xe9\x90\x66\x16\x73\xae\xbf\x3d\x77\x1e\xce\x78\x10\x6a\x17\xf9\xbe\x0a\x12\x17\x21\x6d\xb6\x95\x19\x56\x1e\x01\x88\x83\x1f\xb3\x14\x88\x46\x5c\x30\xf2\xde\x6a\xc8\x6e\xf3\xae\xbf\x3d\x1f\x10\x3e\x62\x23\xff\x57\x68\xea\xa9\x96\x91\x53\x74\x03\x8c\xab\x68\x8f\x08\x4c\x25\x36\x46\xc5\x7d\xff\xfe\x47\x3b\x49\xfb\xeb\x9f\x86\x7f\x8c\xb2\x8d\xfe\xe9\xef\xae\x8a\xf6\xdf\x1b\x6f\x63\x5f\xb2\x90\x75\xff\xef\xd7\x2e\x2b\xb5\xcb\x59\xfd\x77\x57\x8c\x8b\x09\x63\xe5\xc6\x6b\x09\xb7\xf4\x3c\x45\x6c\x84\x6f\x2b\xf6\x0f\x6f\x58\x04\x30\x05\xa3\x4e\x42\x0d\x13\x40\xa8\x7d\x50\x86\x90\x06\xbb\xbb\xba\xb3\x76\xfe\x47\x60\x12\xc0\xa0\xb2\x01\x31\x52\xc2\x71\xc4\x23\x7f\x26\x08\xf3\xb5\x3a\x71\xad\x00\x0e\xea\x1c\xd5\x3c\xef\xb1\xc3\x5a\x08\x87\x10\x5c\x3b\x0f\x98\xdb\xaf\x84\x34\xbf\x0a\xdb\xef\x5d\x34\x80\xc1\x48\x42\xe7\x92\xfb\x04\xe4\xf6\xa4\x08\xac\xe8\x18\x52\x62\x8f\x17\x24\xe7\xda\xd0\x3b\x36\x22\x37\x96\xb7\xc4\xb7\x61\x08\x3d\x41\x20\x83\x25\x4b\x49\x29\x0c\xcf\xe0\xd7\x6a\x1c\x3b\xe5\x98\xe7\x5c\x4d\x88\x2e\x13\x4b\x5b\x0b\xc5\x86\x9e\x8b\xb9\x56\x4b\xb4\xa0\x5a\xcb\x20\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\x88\xbc\x07\x66\x95\xf9\x2b\x61\x54\x4b\x9c\x01\x53\xb0\x84\x69\x4d\xd5\x62\x00\x89\xdd\x79\x48\x06\xee\x5c\x77\x80\xa3\xe6\x54\x60\x5a\x75\xc5\x12\x29\xb4\x51\x65\x62\xb0\xce\xde\x58\xc9\x3b\x26\x82\xbb\xa0\xdd\xc5\xba\x03\x57\xe5\x3f\x03\xf7\x5d\x92\x24\x33\x2a\xa6\x51\x9d\x9a\x9c\xa6\x00\xfb\xaf\x83\x94\xe3\xd7\x63\x21\x40\x27\x56\xb0\xe0\x06\x40\x31\xb6\x7c\x24\x98\x61\xff\x2a\x42\x3e\x9e\x41\x65\x27\xb5\x4b\xe2\xd9\x16\xda\xd5\x89\x7e\x91\x8e\x46\xbd\x21\xb0\xed\x3d\x3b\x80\xe5\xcc\xd0\x94\x1a\xba\x83\x13\xd8\xbb\xaa\xb8\x9e\xbb\x80\x74\x05\x4e\xc3\xc5\xa4\xe3\x43\x5e\xdc\x92\x05\x8f\xe3\x9f\xe0\x24\xce\x3c\xe4\x21\xe2\xda\x58\x9c\x72\x17\x05\xe8\xdb\x05\xf2\x8c\xaf\x5e\x66\x87\xf7\xa3\x21\xb9\xa8\x4a\x33\x56\xe4\xa4\xdd\x35\x54\x47\x0b\xac\x05\xfd\x0e\x30\xba\xad\xee\xca\x92\xba\x7f\xd7\x4a\x11\x04\xb9\x04\x13\x86\x2b\x16\x87\x9b\x39\xd0\x95\x02\x91\xbc\x01\x44\x80\xf2\x94\x19\x5d\x79\xa8\x20\x1d\xb6\xc4\xc5\xf1\x3b\xa7\x8c\x02\x91\x76\x80\x75\xfa\xdc\x6a\x59\x08\xc1\xae\xa5\xa3\xb3\x96\xf2\x3f\x0a\x5c\x77\x31\x3a\x63\x39\x81\x77\x32\xed\x62\xa7\x6e\x64\xe1\xaf\x86\xa8\xfc\x37\xd1\x13\x57\x83\x52\x8f\x0d\xe0\xb6\x4a\xd7\x82\xe6\x90\xc8\xcd\xe8\x7c\x77\x23\x55\x25\x23\x0d\x43\x2a\x63\xf8\xdc\x10\x3e\x37\x7c\xdd\xde\x98\xd7\xc5\x03\xc4\x3f\xad\x3d\x41\xea\x1f\xe9\x64\x39\xb5\x24\xe5\xa6\xa3\xb9\xb3\x11\x8d\x1c\x46\x70\x34\xdf\xdd\x22\x86\x9b\x5b\x17\xe9\xc0\xb8\xa5\x16\xa7\xe4\x57\x35\x2e\xef\xa4\xa9\xa0\x29\xa1\xa7\xee\x91\x57\x9d\x46\x6e\x2b\x7c\xf0\x79\xbd\xf9\x71\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\xee\x83\x30\x41\x35\xa6\x6e\xf1\x37\x5e\xcc\x15\xce\x5b\x3b\x5e\xf0\x5a\x3e\x13\x0b\x9c\xfa\x45\x04\x5a\x54\x3d\xc9\xd4\x7e\xc8\x4a\x9d\x82\x8e\x33\xbc\x3d\x0e\xcc\x16\xe6\x42\xb3\x7b\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\xaf\xaf\x60\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\x1a\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\xf1\x70\xbe\x61\x69\x90\xae\x5f\xbd\x22\x1b\x88\x4b\x57\xc9\xd8\x0b\x3a\x70\x79\x50\x88\xec\x48\x03\xab\x87\xd2\xaa\xd6\x78\x64\xd8\x73\x92\x82\xf7\xa1\x71\x95\x8e\xc4\xc2\x99\x6e\xe2\x6f\xc5\x03\x84\x53\x42\x8e\x84\x14\x78\x72\xb0\xed\x31\xba\x10\xad\xb1\x4d\x41\x13\x57\xa2\xae\x5e\x21\x34\x3a\xa9\x9e\x49\x70\x91\xda\xad\x03\xca\x0d\x3a\x92\x2e\x93\x84\xb1\xa0\x55\xc7\x25\x6a\xaa\x93\xed\xa6\xec\x4b\x5d\x6a\x09\x49\x5c\xb4\xa1\x59\x56\x69\xb3\x0e\x5c\x12\xf8\x9c\xb7\x00\x46\xec\xaf\x16\x68\xe3\x14\x7b\x28\xa2\x8e\x6e\x2f\xa5\x48\xf0\x0a\x9f\x9b\x85\x9f\xc1\x45\x93\xd5\x83\x1a\xa1\x51\xc9\xe5\x13\xb4\x3b\x45\xea\x40\x00\x26\x90\x26\x57\xc2\xbd\xce\x99\x5c\x6e\x06\x4b\x87\xc6\x34\xb9\xbb\xa7\x2a\x85\x52\xbe\x05\x35\x1c\xd3\x82\x0f\x6a\xc3\x1e\x45\x73\x80\x42\xfa\x31\x16\x1d\x07\xa5\x43\xb3\x90\x82\xba\xfa\x0c\xa1\xa5\x91\x39\x35\x3c\x01\x55\x96\x4f\x22\x2b\x62\x1e\x52\x1a\x36\xca\x0e\x02\x95\x0d\x05\xec\x6f\xf1\x36\x46\x31\x62\xee\x25\xe1\xb9\x95\x10\x28\x94\xd2\x98\x84\x88\x21\x6f\xef\xdc\x34\x53\x2b\x06\x7d\x07\x46\xe6\xa8\x15\x2a\xc9\x56\x85\xd2\x30\x7c\xb0\x68\x06\x53\x9e\x0b\xb9\x19\x34\x18\xb8\xeb\x63\x71\xda\xce\x35\x42\xd5\x81\xdd\x9e\x7b\x66\xe5\x02\xbd\x11\x61\xf5\x68\xd5\x8c\xb0\xa6\xad\x26\x29\xd7\x8d\xc2\xd4\x47\xa9\x92\x45\xe1\x0c\x24\xf9\x71\x73\x46\x70\x6f\xa0\xe6\x4c\x47\xb5\x97\xd1\x54\x3d\x65\x22\x14\x0f\x77\xe9\x2c\xe0\xe4\x36\x3f\x51\x3b\x30\x23\x0c\x08\x3d\x26\xdf\xb8\xa2\x42\x01\x71\x83\xd7\x5d\x2b\xc1\x09\xad\x2d\x4e\x76\xea\x25\x9e\xb6\x4f\x2f\xf1\xf4\x12\xcf\xcf\x5b\xe2\x09\xee\x5e\xbb\x4a\x3b\x95\x8f\x63\xa3\x20\xb9\x77\x06\xa8\x1a\xac\x33\x62\x5c\x4d\xc8\x47\x96\xc8\x39\x53\x48\xe4\xa0\xf0\xa7\xe5\xe5\x6f\x28\xcf\x2c\x89\xf3\xa4\xae\x52\x0f\x21\xa3\x6a\xdd\x34\x17\x69\xe4\x01\x9a\x0e\xcd\x73\x37\x29\x17\xe9\x67\xdb\xbb\x4b\xb2\x42\xb1\x39\x97\xa5\xf6\x2e\x0b\xa5\xc1\x63\xa6\x8d\xe3\xb7\x33\x3e\x0d\x89\xb9\xc3\x55\xa7\x62\x89\x54\x69\x15\x52\xae\x0d\x35\xa5\xae\xc7\x49\x24\x68\x4d\xdb\x9f\x81\x26\xc0\xf1\x91\xa9\xfb\x6e\x94\x14\x3d\x36\x1e\x70\x2a\x0e\xdf\xa2\xcf\x47\x55\x77\xdb\x44\x6e\x28\x95\x0b\x8c\x15\xa1\x4a\xc3\x22\xb4\x72\x08\xd0\x19\xd6\xb5\xa8\xd7\x13\x2c\xdc\x32\x0c\xc3\x0e\x2b\xaf\x93\x16\x19\xd7\xe3\x67\x27\xa8\x93\x07\x04\x78\xc6\xcf\x0b\x76\x3c\x69\x2c\xb6\xbb\xf7\x25\x79\xa0\x07\x26\x79\x88\x17\x26\xd9\xa7\x27\x26\x09\xfe\xdc\x0f\x39\x31\x1f\xbd\x27\x79\xe3\xcc\x38\xc2\xbb\xe9\xcc\xd4\x12\x0a\x84\x71\xb8\xf6\x15\x20\xdd\xb5\x66\x38\x03\x60\x12\x8c\xfd\x81\xdd\x69\x05\x6d\x0e\xef\x2e\xd9\xa7\x90\xf5\x37\x92\x63\xaa\xa2\xda\x46\x82\x07\x42\x5e\x60\x26\x20\x38\x75\x43\xe7\x92\xe5\xb5\xa5\xfe\x04\xf7\x27\xb8\x6d\xff\xe7\x3c\xc1\xe8\xf1\xdc\xc5\x21\xbf\x51\x29\x08\xbb\xbb\x20\x5c\x3a\x66\x19\xf9\xb1\x64\x6a\x41\xac\x10\x54\xb9\xf7\x40\x7a\x63\xcd\x53\xe7\x20\xe3\x8c\x2a\xed\x65\xf6\x27\xe4\xff\x60\xb2\xb9\xfc\x64\x25\x40\x88\x63\x7b\x00\x5d\x6b\x0e\x55\x0f\x55\x46\x68\x05\x08\xc6\x12\x1e\xde\x30\xd6\x64\x3e\x2b\xee\x9d\xbd\xbf\xd8\x4d\xd1\xe9\x76\xa9\x45\x76\xb9\xd8\x5a\x5a\xfc\xd9\x86\x05\x22\x20\xc2\x2f\xf5\x6a\x52\xc1\x14\x41\xee\xd8\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\xfb\xe0\xa5\x06\x34\xad\x39\xe6\xde\xb1\xc5\xa1\x76\x51\x83\x52\xe8\x19\x2f\x7c\x7e\x78\xa0\x04\x0e\x73\xc9\xb7\xe0\x1f\xe0\x87\xc0\x33\x7f\x25\x06\xe4\xbd\x34\xf6\x7f\x97\xe0\x2a\x84\x96\x4a\xc9\xf4\x7b\x69\xe0\xcd\x93\x03\x0b\xa7\xfb\x60\x50\x39\x33\x25\x07\x33\x23\xba\xb4\x41\x7c\x86\x77\x41\x01\x90\xb8\xfb\xd6\x00\x56\xae\xc9\x95\x20\x52\x79\x98\x18\x9f\x3c\x58\xbb\x21\xbc\x6d\x29\xb2\x08\xaf\x18\xc3\x81\x52\xaa\x1a\x24\x37\x0c\x17\x8c\xcb\xdc\xff\x02\xb6\x27\xb0\xc6\x07\xbf\x19\x48\x81\x4b\x0d\x9b\xf2\x84\xe4\x4c\x4d\x21\x3e\x34\x99\xed\xbe\x41\xdd\xe9\x36\x3e\x3b\x51\xef\xf8\xc3\x9d\x31\x03\x58\xdd\x5b\xf0\x5c\x7a\x28\xc3\xc4\x51\x90\x45\xe4\xb4\xb0\x48\xf1\x2f\xcb\x09\x60\x5f\xfe\x03\x29\xab\xf5\x88\x9c\xf9\x82\xa7\xf1\x6f\xce\x8a\x11\x0f\x63\x47\xb0\x32\xfd\x8f\x25\x9f\xd3\x8c\xa1\x3f\x1f\x15\x21\x8d\xa7\x9c\x2c\xb1\xe9\x81\xcb\x5b\x6d\xa9\x54\xb8\x19\x3a\xb8\x63\x8b\x83\xc1\x12\x22\x1d\x5c\x89\x83\x2a\x48\xbb\x86\x3a\x81\xa1\xc1\xa5\xc1\x01\xfc\x76\xb0\x6f\xce\xfe\x4c\xa2\xfd\x0e\x58\xe2\x0c\x42\xe7\x19\xd5\xba\x5b\x7c\x6b\x23\xb4\xa8\x31\xce\xaa\x04\x8c\x37\x51\x9b\x2a\xb8\xc8\x79\x6f\xee\xdd\x9e\x05\x5e\xfe\xdd\x3d\x8d\x3a\x41\x6f\xee\xaa\xa7\xb4\x4f\xdc\xb0\x32\xa1\x18\xa4\x2d\xf0\x31\x1c\xb5\xb8\xb8\xea\x32\x76\x0d\xbc\xbe\x05\xbb\xa2\x9c\xc4\x45\x9e\xb9\x06\x35\x98\xfb\xa8\x0e\x21\x0d\xe1\x22\xc9\x4a\x67\x52\x84\xae\xa0\x44\x77\x15\xf5\x77\x00\xce\x03\x90\xaa\x1a\xc0\x63\x93\xbf\xf6\x5d\x72\xe0\x6d\xde\xd0\xc1\x9d\x68\xb8\xf1\x42\x58\xed\x7b\xad\x93\x2d\xee\x92\xf5\x64\x9c\x49\x5d\xf6\x78\xc3\xc7\x8a\x91\xf3\x19\x15\x82\x65\x51\xb4\xab\x33\x76\x84\x72\x56\x20\x90\xb8\x22\x56\x87\xf5\x2a\x56\x9e\xbe\x89\x10\x5b\xbd\xf7\xda\xc1\x3f\xa5\xa2\x52\x7b\xab\x53\xee\x52\x35\xce\xe4\x3d\x49\x25\xb9\x87\xba\x05\x73\xcb\xb4\xe0\x52\x56\x7b\x76\x17\xcd\x14\x5c\x24\x12\x99\x17\x4a\xe6\x5c\x7b\xe7\x78\xb7\x8d\x7b\x0d\x0d\xcd\xca\x16\x39\x80\xea\x7b\x90\x95\xa2\x9e\x12\xfe\xcd\x39\x31\x54\x4d\x99\xb1\xa3\x11\x51\xe6\x63\xd6\x3a\x7e\xf5\x31\x72\x90\x7d\x4e\x25\x44\xf7\x5b\x04\x0b\xb7\xe1\xbb\xef\xde\x77\x2e\xbd\x5b\xf5\x5c\xb7\xb7\xf7\x52\x65\xe9\x3d\x4f\x91\x45\x6b\x72\x64\x1b\x1f\xbf\xfc\x4a\xb9\xf7\xf7\x3c\xed\x0c\x0e\xe8\x54\x07\x83\xf7\x83\xb2\x60\x20\x00\x07\x57\xe1\x89\x43\x1a\x6d\xe8\x71\x4c\x2e\x39\x46\x17\x41\x7f\x48\x54\x93\x8f\xb9\xa8\x22\xcc\x2a\x30\x5b\x62\x6c\xcf\x8b\x57\x4d\x34\x33\x18\x17\x02\xa1\x15\xd2\xcc\x88\xe6\x79\x99\x19\x2a\x98\x2c\x75\xb6\x68\x8d\x2a\xcf\x03\xea\x49\xc6\x3e\x21\x66\x77\x61\x72\xa1\x53\x9d\xd9\x81\xeb\x4a\x15\x46\xb9\xc4\xed\x2a\xe7\xaa\xf4\x24\x70\xbe\x10\x6e\xc4\x3e\xb1\xc4\x79\x05\x17\x59\x39\xe5\x5b\xc2\x1f\x7e\x66\x59\xcd\xab\x04\xd2\xa5\x66\x55\xa4\x7e\xdb\xba\x2e\x4f\x94\x84\xfc\x79\x39\xfc\xed\xea\x04\xe4\x29\x2b\x98\x48\x21\x25\xda\x9b\x0a\x73\x71\xf2\x7b\x85\x9c\x4b\x2f\xd6\x95\x6a\xf9\xac\x64\x35\x0a\x1e\xb9\x70\xcd\x64\x96\x6a\xc2\x3e\x19\x45\x2d\x61\xca\x2d\x09\x0a\x7d\x26\x84\x8a\xf6\x44\xe6\x65\xa4\x08\x26\x7b\xe7\xf6\x8f\x5b\x2f\xf3\x25\x96\xbc\xac\xd6\xae\x37\x16\xac\x7e\x58\xea\x7a\x24\xc4\xee\xac\xe8\xba\x87\xf0\x8a\x14\xf3\xee\x2b\x75\xcf\xc4\x87\xa5\x9a\xd7\x2b\x92\x6a\x37\x66\xd5\x97\xe9\xfc\x2c\xf2\xce\x4f\x20\x30\xb8\x4b\x12\x26\xd7\xa3\xa1\x51\xbb\x97\xcd\x82\xd0\x1b\x34\x68\x87\xb7\x11\x1f\x80\x8c\xa7\x6e\x20\x17\xd6\x44\xb4\x85\x65\xe5\x3a\x57\x0a\xb1\x8d\x8a\x3d\x46\x16\x71\x6a\xa8\x66\xa6\x9d\x35\xa5\x2e\x3a\x54\x3d\xed\x01\x8c\xf1\xcb\xfd\x84\x59\xec\xc1\x21\xdd\x07\xcb\x92\xe1\x9f\x9c\x94\x21\x6a\x2d\xad\x7c\xe1\xe1\xe3\x93\x34\xb1\x70\x8b\x8c\x63\xa4\x76\x57\x12\x6a\x5a\x97\xdc\x69\xc5\x17\xdc\x0c\xbe\xf9\xa6\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\xbf\xaf\xb5\x4d\x13\x56\x19\xaf\x2e\xb8\xbe\xeb\x92\x8c\x6c\xa9\x73\xfd\x48\x7c\x75\x7e\x49\xdc\xdb\x56\xf6\xa5\x2e\x06\xa6\x87\x66\xc6\x9a\x26\xac\x32\xda\xa6\x5c\xdf\x3d\x79\x59\xf5\x22\x7d\xbf\xcd\x03\xfc\xe9\xec\x5f\x4d\xa9\xd7\xa7\x68\x89\x72\x07\x2d\x64\x49\xee\x5d\xea\x03\x27\x35\xdf\xf2\xe2\x94\x5c\x0a\x5d\x2a\x56\xdd\xdc\x36\x87\xb2\x5c\xf7\x25\x95\x5e\x7f\x10\x96\xbc\x64\xe3\x5b\x41\x95\x01\xf1\xb8\x2b\x1a\x84\x8e\x9e\x3e\x45\x2f\x44\x1b\x3c\xb8\x9a\x78\xc7\xba\x81\x8b\xf1\x0e\x89\xcb\x7c\x23\xbb\xf3\x51\x5a\x93\x78\xaf\xdf\x84\x94\x3f\xe4\x24\x65\xf3\x13\x9d\xd2\xd7\x03\xf8\x8c\x77\x78\xae\xcf\x89\x6a\x72\xf0\xfa\x60\x44\x6e\x78\xce\x33\xaa\xb2\x45\x2d\x15\x73\xd5\xce\x32\x0b\x3f\x20\xdc\xca\xbd\x3a\x20\x47\x52\xc1\xc8\x09\x15\x24\x63\x3e\xa2\xc9\x9d\xb3\x05\xca\x8e\xc7\x4f\x4d\x5c\xc8\xa3\xda\x2f\x91\xce\x74\xc6\x89\xd4\x73\x6c\xc7\x8f\x6a\xe9\x6c\x2e\x2a\x92\xce\x85\xa5\xf3\x23\xf2\xcd\xaa\x42\xe5\x70\x64\x7c\x8b\xe7\x02\xea\xd3\xe8\x7d\x3b\x69\x70\xcb\xe6\xe0\xe7\x03\xd3\x76\x2d\x71\xca\xcd\x47\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\x23\x72\x71\x79\xfd\xf1\xf2\xfc\xec\xf6\xf2\xe2\x94\x7c\xe5\x46\xe2\xb1\x84\x37\x22\xb7\x71\x36\xa8\xc8\xa3\xd7\xa5\xdc\x09\xdf\x1a\x38\x32\x44\x45\x95\xdc\x11\x72\x7c\x50\x41\xae\x04\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\x23\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\x8e\x0e\xbd\x40\x91\x2d\x25\xe1\x0f\x83\xc6\x19\xbd\xea\xc8\x36\x22\xe4\x83\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\xf8\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\xf1\xf2\xec\xe2\xdd\xe5\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\xdf\xaf\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\x3b\xfb\x57\x94\x74\x1b\xf0\xe2\xfd\x87\x5b\xc8\xea\x0b\x17\x5c\x0f\x16\xc2\xed\x07\xe1\xbc\x0d\x87\x43\x30\x19\x1c\xfd\xc3\xca\x93\x69\x76\x4c\xbe\x63\xee\x3b\x12\xd2\x0e\x2b\x28\x05\x34\x93\x21\x07\x2c\xcc\xb5\x82\x2c\xa0\x23\x5e\xef\xbb\x56\x27\xb6\xa5\x95\x95\x90\xd5\xd4\xda\x43\xe5\x53\x4c\xdd\x88\x77\x4c\x4f\x2f\x7b\xee\x91\xec\xef\x4c\xe5\xbc\x69\x75\x15\x7e\x86\x8b\x1f\x4f\x0f\x29\xd1\x8b\x3c\xe3\xe2\xae\xca\x0b\x36\x91\x16\x87\x30\x34\x81\x8b\x3b\x8f\xb1\x8a\xd1\x6c\x3d\xa5\xdc\x05\x3f\xf6\x4a\x25\xcd\x0e\x16\x40\xb0\xd0\xd9\x73\xf6\x17\x7f\xec\xdd\x35\x74\x4c\xe2\x0e\x0e\x5e\xdc\x7a\xb9\xee\x56\x06\xff\x10\x3a\xd4\x68\x9a\x20\x57\x37\xe7\x37\x57\x4f\x6a\xa1\x5e\xc7\x12\x60\x76\xcf\x28\xd5\xf1\x1f\xb7\xdd\x0e\x0f\x49\x56\x6e\x6f\x83\xea\xdd\xb5\x54\x86\x66\x7b\x22\x02\xc9\x8c\x16\x67\xa5\x99\x5d\x70\x0d\x39\x14\xba\x0a\x01\x4b\xfd\x23\x4f\x67\xcc\xdd\xec\x13\x06\x72\x8f\x0e\xae\xdd\xf9\x5f\xce\xae\x09\x2d\xed\xfe\x1a\x97\x5c\x74\xaf\x17\xee\x7e\x66\x37\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\x95\x6f\x01\x57\xc8\xc0\xc5\x97\x3a\x55\xd6\x02\x90\xde\x01\x62\x57\xc2\xca\xda\x34\x61\x0d\x07\xc8\x01\x24\xfd\xc4\xb1\x79\x68\xf3\x47\x67\xa0\x82\xfc\x60\xd9\x9f\x4e\x6b\xa9\xd8\x97\xea\x5a\x78\x2b\x45\x55\x34\x61\xaf\x16\x1f\xfe\x63\x57\xa2\xc0\x7f\x14\x0d\x4b\x1b\x2e\xf0\xff\x96\x34\x43\xc0\xbc\xdf\xb7\x59\xaa\x0e\xe4\xae\xf3\xad\xef\x90\x9b\x7a\xb5\x1d\xef\x83\x96\x5e\x6a\xcc\x3c\x86\xeb\x31\x8a\x0a\x6d\xf7\xa8\xae\x8b\x1d\xba\x8b\xa7\x43\x72\x64\x92\xa2\x75\xed\xfe\x47\x72\x6d\xcf\x4a\x51\x2b\xe4\x0c\x33\xbf\xc5\x6d\x79\x1b\x5c\xdb\xdb\x4e\xf2\x51\xae\x86\x00\xcb\xbb\x5a\x55\x5c\xaf\xb0\x5b\xf1\xba\x90\xf5\x93\xb7\x5c\x1b\x5f\x90\x01\x5e\x70\xed\xf2\x08\x83\xdc\x75\x6d\x15\x39\x5e\xfc\x8d\xa6\xa9\x3a\x45\x2e\xe5\xab\x2f\x2b\x90\xbe\x7c\x92\x2f\x2a\xc2\x5d\xe2\x91\x59\x14\x2e\x01\xe0\xed\xf9\x35\xc1\x02\x29\x7f\xf8\x1d\x56\x7e\xfd\xaf\xdf\xfc\xee\x55\xeb\xed\x7e\x3e\xe7\xf1\x1d\xed\x18\x7b\xbf\x63\x7a\x11\x7e\x83\x35\xff\x40\xbb\x12\x90\x4d\x6e\xd0\x1d\xcf\x52\x56\x77\xd4\x11\xb1\xec\x2e\x07\x7a\xbf\x9b\x04\xd3\xfb\xd9\x3d\xab\x9f\x1d\x09\x11\x25\x48\x24\x3a\xa2\x4b\xdc\x15\x42\x0c\x97\xc9\x0e\x52\x9c\xeb\x97\x47\x71\xb6\xc2\x66\x3b\x16\xd5\xb1\x27\xbe\x8c\xf7\xe5\x6f\x2a\x17\xf6\x8b\xf7\x37\x7f\x7b\x7b\xf6\xe5\xe5\x5b\x98\xa9\xbb\xbf\xb7\xa8\xc1\xc5\xce\xfe\x53\xed\x51\xad\x8d\xf2\xba\x1d\x20\xdd\xae\x65\x44\xe3\x42\x46\x90\xf7\x6f\x6e\xba\xde\xc5\x3c\x54\x40\x17\x93\x56\x6b\x7f\x5a\x6b\x1b\x54\x35\x61\x6a\x7f\xf1\x23\x3b\x1b\xe5\xa2\x44\x5a\x35\xfd\xcb\xee\x14\xce\xf0\xc1\x2a\xd2\xd6\x1d\x20\x2f\xe0\xde\xc1\xae\x17\x61\xb0\xf7\x1b\x87\x47\x82\x55\x5b\x39\x40\x75\x0f\x2c\x3a\xc4\x5e\x5e\x04\xb0\x87\x14\x69\x9b\xb2\x34\xdb\x52\x6b\xa6\x43\xf5\x85\x17\x8a\x29\xc5\xaa\xf4\xcc\x5d\xa8\xd7\xca\x01\x6a\xe5\xca\x6a\x77\x31\xb5\x58\x8a\x75\xe9\xcc\xbd\x87\x02\x75\xca\xab\x2e\x68\xb2\xd7\x82\x2a\xd5\x2b\x7c\x03\x41\xee\x4f\x4f\x00\xe1\xb3\x7b\x74\xa4\x0d\xe3\x75\x45\xe4\xd0\xb1\x19\x25\xd7\x69\x87\x7c\xa1\x8f\x42\xfa\x08\xc4\x38\x9c\xee\x99\xb7\x8f\x3c\xad\xb6\xf3\xdd\x8e\x8a\xce\xbe\x95\x9c\x62\x26\x8d\x14\x3b\x7b\xc9\xaf\xea\x5e\x3f\xd0\xd7\xd0\xe2\xbc\x2a\x63\x13\xd5\x78\x04\x0f\xca\x70\x19\x61\xe5\x39\xcf\x2e\xa4\xf0\xd7\x12\xf5\x4b\x89\x27\x17\x41\xd2\xab\x8b\x3d\x1d\xbe\xcf\x37\xc4\xb3\xab\x31\x78\xaf\xce\x20\x69\xe7\x98\x14\xdb\xc5\x43\xec\xea\xc2\x89\x66\x3e\xe0\x44\x3b\x84\x24\xeb\x31\x72\x6f\xac\x53\x2a\x73\x2f\x55\xf7\x50\xef\x7a\xc7\x86\xaf\x82\xfb\x6d\x29\x14\xeb\x25\x9e\x1e\x9c\xe3\x33\x9f\xa0\x1b\x38\x41\x8d\x04\xe7\xeb\x4e\xd2\x63\x1c\xa4\xe7\x3d\x40\x0f\x65\x54\x8f\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\x03\x82\x59\x96\x73\x5a\xf8\x9a\xdc\xf2\x5e\xdc\x53\x95\x92\xb3\xeb\xab\xfd\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\xfd\xef\x7f\x8f\x95\x95\x52\x96\xf0\x7c\xb9\x21\xb4\xfa\x5f\xaf\x5f\x8f\xc8\xff\x9c\xbd\x7b\x0b\x95\x1f\x0b\xa3\x31\x2b\x09\x8e\x8c\x95\xe0\xa3\xce\x7a\x40\xfe\xcf\xcd\x87\xf7\x55\x99\x98\xfa\xaf\xae\xa0\xb6\x5b\xde\x88\x5c\x44\xfe\x4f\xb1\xa1\x8b\x9a\x99\x2b\x68\x64\x08\x9d\x4c\x10\x31\xc6\xbe\x9c\x2e\x1e\x38\x1f\x3d\x0e\x55\xc1\xb1\xfe\x88\x45\x89\x0c\x1c\xb3\xac\x4a\x8e\xa6\x41\x9f\xd9\x00\xfd\xcc\x60\xac\x40\x26\x61\x2a\x03\xac\x25\x3f\xd1\x50\x85\xa4\x4a\xff\xa7\x98\xb6\x42\xa9\xab\xae\x88\x83\x55\x3b\xa3\x59\xeb\x5c\x0f\x8f\x71\x03\xd4\xba\x3a\x46\xdd\x74\xef\xce\x90\x4f\xdf\xea\x72\x17\x57\x65\xea\xff\x81\xb7\xa1\xdb\x9c\x84\x1f\xe9\x46\xa6\x36\xd7\xeb\x30\x1b\xdc\x3a\x97\x25\xa0\xa2\x13\x34\x93\x50\xc9\x2b\xec\x74\xc5\xc5\xa2\xa2\xf7\xdb\x97\xd2\x39\xf9\x62\xd7\x04\xbc\x48\xa8\xde\xd1\xd6\xe5\x7c\xea\xfe\x22\xbe\x77\x2d\xaf\x02\x1d\xcb\xd2\xf8\x3b\x6c\xf7\x3b\x04\x60\x63\x95\xf5\x0e\x69\x24\x77\xc8\x3c\xb9\x4b\x06\xe2\xce\x49\x4c\xeb\xf7\xcd\xc0\x13\xea\xa2\xc4\x80\x30\x9a\xcc\xc8\x1d\x5b\x0c\x91\x6e\x15\x14\xa2\x79\x00\x2a\x17\x16\x16\xb5\xc2\x27\x55\xed\x1a\x2b\x1f\x3b\x90\x79\xc7\x80\x88\xfb\xf8\x68\x20\x2f\x84\x6a\x27\x2f\xb9\x34\xa2\x22\xb2\x14\xf8\x5c\xd5\x51\x3d\xe2\x90\x37\x14\x8b\x91\xd7\x83\x54\xec\x79\x63\xa9\xed\xa6\x37\x7d\xb9\xf2\x86\xb0\x74\xd0\x71\xb7\x52\x2c\xf5\x76\xc5\xb7\x9d\xf0\x07\x1f\xa4\x3e\x3b\x73\xe4\x51\x01\xe5\xfc\x5c\x25\x27\xd7\xd6\x43\x29\x00\xa2\x16\x44\xa3\x99\x29\x1d\x68\xb0\x5e\x58\x29\x32\xa6\x35\xe1\xb0\xc2\x9c\xaa\x3b\xe6\x13\xc6\xd0\x6c\x44\xae\xed\x24\x43\xfe\x2a\x4c\x8b\x3c\x47\x17\x3b\x7b\x66\xe3\xe8\x20\xfb\x91\xc3\xd1\xe8\x10\x09\xfc\x8a\x58\xa1\x0e\xf8\xb1\x5b\x4e\xdd\x1d\x72\xe9\x36\x4a\x7b\x17\x1a\x33\x03\x5b\x91\x0f\x32\x5f\x4b\x88\x82\x33\x33\xcf\xc0\x68\xeb\x24\x4a\xcb\xcb\xd9\x21\x01\xec\xae\x79\xcb\x77\xc9\x5a\xde\xea\xde\xa2\xfe\xec\x9e\xad\x7c\xa7\x5c\xe5\xeb\x32\x95\xbb\x9d\x72\xa7\xad\x7b\x0e\xe7\x07\xa4\xd8\xce\x3b\xa5\x79\xf5\x4f\xdd\x48\x09\x72\x47\x2d\x4b\x4f\x2b\x19\xd1\x25\x7d\xca\xd8\x67\x25\x14\x5e\x4d\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\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\x4f\xd6\x99\xe4\x01\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\xbe\xda\x49\x03\x88\xfa\xaf\xd1\x01\xe2\x16\x3f\x61\x2d\xe0\x0a\xb5\x80\xb8\xec\xce\x45\xb5\x72\x67\x52\xb6\x64\xe7\xc5\x8b\x91\x4b\xd3\x7e\x63\x89\x65\xec\x74\x5a\xcf\xa1\x87\xc6\x9e\x8a\xac\x46\x79\xf7\xfc\xad\x23\x1c\xe2\x97\x2e\x72\x3e\xa1\xf8\x08\xf0\xe8\x54\x2e\xdd\x3f\xcb\xd5\xec\x60\xb1\xe4\x06\x4a\xdb\xa0\x3e\x18\x29\x96\x85\x4c\x4f\x5d\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\x0f\xa9\x73\x64\x37\x10\x56\x7e\xdd\x75\x17\xc9\x03\xcb\x16\x91\x88\x35\xed\x56\x08\xa5\xb6\xa7\x6e\xa4\x50\xe7\x3d\x99\xb1\x9c\x62\x0e\x3f\xbf\x3c\x4b\x65\xee\x15\x37\x86\x61\x2e\x25\xa6\x72\x4d\xe4\x64\x50\xbb\x33\x38\x98\xbf\x3e\xd8\xa5\x1c\xcc\x03\x2b\xf6\x90\x6a\x17\xf6\x00\x8c\xeb\x9a\xc8\x66\xf1\x1a\x74\x89\x0c\x12\x6f\x8a\x86\x41\xc2\x32\x98\x39\x42\xef\xc9\x17\xbe\x0f\x3d\x6a\x57\xfd\x69\x10\x04\x86\x5e\x7f\xea\xf5\xa7\xbd\xe8\x4f\x11\x63\xf1\x04\x67\x85\x2e\x15\x3b\x0c\x7b\x85\xaa\x0a\x64\x8a\x12\xf0\x58\xd4\xf4\xaa\x94\x54\x75\x8b\x9b\xd5\x87\x0e\xbd\x82\xe5\xf0\xb8\x34\x93\xe1\x1f\x08\x13\x89\x4c\x71\xf3\xed\xf8\x4a\x1b\x10\x6d\x2a\x9d\x24\x9e\x4b\xee\xbf\x15\x5b\xed\x60\xec\x5d\xb7\x6e\x27\x3a\xe0\xaf\x02\xdf\xec\x89\xc1\x57\x6c\x3d\x04\x13\xfb\x5a\xd9\x3e\xd7\x80\xe3\xef\xd5\x25\x24\x96\x95\x06\xe4\xf6\x15\x73\xc9\x11\xbe\x1c\x25\x45\x39\x70\x0d\x46\x39\xcb\xa5\x5a\x0c\x42\x23\xfb\x63\xad\x97\x6b\x71\x0c\x32\x41\x52\x2a\xab\x01\x66\x8b\xcf\x55\x3a\xf0\x00\x7a\x62\xe1\x20\xec\x53\xb7\xa2\x41\xf1\x53\x47\x89\x2a\xa9\x18\xe8\xf7\x55\x11\xa5\x49\x48\x79\xa8\x07\x95\xda\x69\xdf\x32\x31\x27\x73\xaa\x3a\x54\x41\x8f\x9f\x07\xca\x03\x29\x9f\x73\xbd\x5b\xbd\xc3\xc6\xd2\x6f\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\xb3\xa9\x2f\x8c\xcf\x8e\x55\x86\xf1\x79\x68\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\xa2\x83\x86\xee\x26\x3b\xd9\x6d\x5c\x86\xfa\xd5\x26\x1b\xf7\xe3\x4f\xd8\x5a\xb3\xdf\x3b\x5b\x17\x5f\xf8\x33\xbf\xb0\xbd\x71\xf5\x0c\xfa\xdb\xda\x56\x28\xd8\xdf\xd6\xf6\xb7\xb5\xfd\x6d\x6d\x6f\x6d\xe8\xad\x0d\xfd\x6d\x2d\xe9\x6f\x6b\xf7\x02\xc3\xfd\xdd\xd6\xa2\xa8\xb7\xea\xce\xd6\x09\x7b\xd5\x85\xed\x93\xde\xd7\xba\xc2\x3d\x67\x49\x22\x4b\x61\x6e\xe5\x1d\x6b\x7d\xe9\xd0\x90\xff\x97\xc6\x81\x04\x08\x6b\xf4\x81\xe5\xc6\x4f\xa6\x1c\x74\x97\x4a\x3a\xc9\x16\xbb\x48\x15\xb4\x4c\xb9\x95\xfc\x77\x46\x33\x3f\x40\x9c\x9c\x48\xa4\x2c\xad\x7e\x70\x47\xd9\x58\x58\x8f\xc8\x19\x51\x2c\xe1\x05\x77\x65\xe4\x29\xbe\x47\xc4\x0b\xb5\x11\xb8\xd1\x2c\x9b\xb8\x1c\xf5\x22\xae\xf5\x53\xc9\xef\x8e\x0e\xae\xfc\x0c\x72\x28\xe9\x33\x99\xfb\x5a\x48\x8a\xfd\xc3\xb3\x36\x37\x9b\xdb\x78\x84\xd8\xbc\x02\x4b\xa9\x95\x18\x82\x8f\x15\xdc\x05\x58\x3f\xf6\xf1\x67\x9f\x0a\xae\x00\x79\x6f\x58\x22\x45\x9b\x9a\xaa\x6b\x36\x68\x69\xa4\x8a\x3f\x81\x6d\x94\xa5\x24\x2d\x55\xa8\x99\x3a\xa7\x19\x4f\xb9\x59\x84\x5b\x3b\x57\x5e\x8b\xe2\x89\x09\xdb\xa8\x2b\x30\x12\x5a\x14\x4a\xd2\x64\xc6\x74\xf4\x35\x14\x50\x5c\x10\x59\xf0\x7d\xc7\x12\x70\x20\xa3\x40\x1f\xcb\x20\xb3\x05\x51\xd2\xf8\x8b\xf7\x35\x1f\xbc\x8d\x06\x83\xee\xc8\xe5\x8c\x5a\xc0\xed\xbc\x8c\x87\xc0\x59\xf1\x49\xfc\x87\x26\x32\x4b\x7d\x0a\x93\x3f\xbc\xb2\x42\x61\xe2\x70\xd0\x12\x3f\x48\x70\x61\x24\xc9\x2c\xc3\xb6\x04\x71\x7d\xe7\xdf\xfc\x96\xcc\x64\xa9\xf4\x28\x4e\x3a\xf0\x1a\xde\xa1\x7e\xe7\x85\x4a\x43\x32\x46\xb5\x21\xaf\x5f\x91\x9c\x8b\xd2\xf2\xa9\xce\x68\xd3\x5d\x0e\x8a\x24\xa0\xdf\xfd\xb6\x75\xbf\xae\xb2\xcf\x5a\xa9\xa7\xc0\xdc\xc8\x4e\xf4\x71\x27\x09\x03\xe3\x30\xb3\x78\x43\x10\x72\x44\x37\x86\xb6\x30\xf2\x11\xce\xd7\x8f\xa5\x1c\x2f\x4c\x97\x20\x4a\xd7\xa3\x1e\x3d\xf9\x7f\xdd\xcb\x36\xc9\x53\xaa\xdc\x29\x1b\x3f\xfa\x28\x15\x2e\xa6\x5c\x9b\x2d\xf5\x2d\xaa\xf8\xca\x8d\xcd\xda\xb3\x95\xa9\xd5\x0e\x3a\xc6\xca\x40\x1f\x2f\x11\x7b\xdb\x52\x92\x30\x2c\x66\x79\x51\x55\x4a\x12\x12\xdb\x6e\x1d\xfe\x99\x13\x8e\x79\x04\xd9\x43\xd6\xf4\x96\x4b\x6d\x27\x74\x79\x94\xe8\xbc\x56\xec\x56\x3f\x05\x9a\x8b\x29\x26\x39\xcf\xcb\xcc\xf0\x22\xab\xd6\xfd\xd1\x77\x70\x84\x3c\xb6\xb9\xd1\xc8\x4c\x44\x31\xb0\x18\xb3\x4d\x81\x7d\xf2\x28\x8c\xc5\x84\xc1\x5c\xdd\xca\xf2\x83\x82\x2a\x1a\x80\x07\x95\x74\xf5\xb1\x33\xdf\x51\xb8\x51\x74\xe9\x30\x6d\x2f\x9a\x55\x33\x8e\x6e\x91\xf6\x89\x34\x86\x09\x2a\x5a\x98\xaa\xeb\xe9\xb9\xa0\x13\x91\xf7\xc1\x99\x0c\xcb\xa0\x34\xb0\xc5\x09\x35\x5f\xd2\xe4\x8e\x89\x14\x8b\x46\xc1\xb2\xd3\x85\xa0\xb9\xcb\xb6\x15\xd5\xe3\x6e\xf4\xd7\x03\x67\x98\xc0\xf0\x3d\x1f\x66\x8c\x5c\x77\x9f\x30\x28\x75\xe7\x54\x36\xb6\xcb\xb6\x73\xae\xd1\x64\xa3\xf8\x3c\x61\x9e\xff\xdb\x7e\xfb\x9c\xfa\xbc\x45\x2c\xfd\xd2\xe4\xfd\xf6\x44\xf8\x0b\xe4\x3e\x58\xce\x21\xa9\x16\xcd\xec\xd1\x5e\x84\x98\xd1\xc6\xe6\x8e\x17\xfb\xad\x7a\xa3\xc6\x5d\x22\x7f\x0f\xd5\x38\xad\x1f\xe2\x8f\x34\x95\x9a\x7c\x99\xc9\xe4\x8e\x5c\x30\x10\xba\x1e\xb3\x3c\x8b\x1a\xa7\xcf\x99\xc2\x3b\xa7\xd3\x6d\xf7\x6c\x43\x92\x4b\xc1\x8d\x54\x9b\xe9\xc5\xd3\x95\x9d\xec\xd3\x3d\xaf\xcd\x50\x65\xb1\xf9\x25\x27\x7b\xb6\xe8\xd6\x75\xe3\xa1\x53\x50\xcf\xe0\x74\xe2\x2b\x57\x05\x6c\xc7\xb3\xf6\x8b\x99\xbc\x1f\x1a\x39\x2c\x35\x1b\xf2\x16\x17\xba\x1d\x96\x79\xc7\x16\x70\x8b\xdd\x71\xa1\xae\x5b\x4d\x67\x30\x12\x2c\x50\xf0\xde\x72\xee\x8f\x5f\x5e\x7c\xa3\x99\x1a\xc5\x32\xe0\x09\x33\xc9\x49\xc2\x8a\xd9\x89\x1b\xe1\x45\x02\xc5\x13\x91\xae\x50\xf1\xfd\x90\xcd\x24\x32\xcb\x5c\x60\xb6\x9c\x90\x73\x56\xcc\xc2\xc0\x4f\xbd\xea\xe7\xcb\x08\x5c\x48\xd9\x35\x11\xea\xa1\xed\x53\x3f\x44\xf0\x06\xcf\x50\x84\x4c\x6a\xdc\xad\x08\xc5\x53\xa1\xcf\x8b\x2e\xb5\xf9\x88\xc0\x79\xdc\x74\xca\x87\xb5\x7c\xca\xb1\xbf\x67\x3d\x59\xb2\xf7\x18\xa9\x91\xa0\xab\x09\x0a\xdd\x29\x4b\x89\x9c\x33\xa5\x78\xca\x34\x09\x34\x28\xd6\x52\x79\xf6\xd4\x70\xeb\xf3\x36\x3f\x7b\xde\xe6\x1d\xd4\xa1\x43\xd0\x87\x6a\x64\x0a\xde\x2c\x91\x29\x9a\xe6\x5c\xbc\x38\x42\xa5\x13\x9a\xb1\xab\x0f\x1d\xf4\x0f\xd7\xa3\xae\x82\xdc\xb8\x97\x51\xfe\xb4\x2d\x59\xc9\xbe\x0e\x78\x43\x84\x4c\xb7\x99\x54\x1f\x41\x91\x98\x52\xc3\xee\xb7\xb2\xc3\x61\x45\xa8\xb6\xb7\x04\xe1\xf4\x39\x55\x8e\x17\x91\x23\x30\xc2\x79\x4c\x7a\xb6\x4f\xa6\xea\x76\xad\xab\x71\x12\x7b\xc5\xe9\x77\x9b\x49\x77\x3d\x06\x9f\x5d\x5f\x91\xaf\xb0\xf9\x7e\xb3\x17\x2a\x69\x50\x0c\xbc\x90\x39\xe5\x5d\x8b\x6c\x34\xbb\x37\xb3\xaf\xc6\x4b\xb8\x0e\x6d\x89\x6b\x1c\x15\x70\x99\xf0\x69\x69\x75\x3a\xa7\x87\xbd\xa8\x04\x73\x4b\xa2\xcb\xcb\x4d\x30\xf7\xf0\x6a\x10\x91\xc9\xc9\xfb\x45\x56\x12\x8b\xdf\x4a\x60\x25\xe1\x0e\x94\x68\x26\x34\x87\x0b\x99\xe8\x56\xdc\x55\xfa\xc3\xd2\x92\xe8\x04\x89\x22\xce\x80\xbc\x95\x53\x2e\xfc\xe9\x95\xee\xbe\x6e\x42\x79\xd6\x16\x18\xbd\x4c\xf2\xec\x32\x89\xd6\xd9\xa5\xa0\xe3\xac\x8d\xbb\x41\x1d\xd5\x42\x47\xf2\x26\xa3\x53\xc2\xe0\x8f\x93\x94\x6b\xfb\x7f\x72\x73\xf3\x16\x8c\xf0\xa5\xf0\x12\x33\x18\xa8\x1d\xed\x0b\x41\x0a\x78\x10\xf7\x7b\x76\x90\xf4\xec\x90\xfd\x2f\xea\x49\xb8\x48\xed\xc4\xa3\x52\x70\xe8\x24\x05\x2d\x30\x1f\x62\xf0\xf9\x45\xb7\x81\x31\x23\xb7\x33\x9e\xdc\x5d\x47\x76\x77\xa9\xec\x3b\x11\xbd\xaa\x31\xb0\xe6\x6f\xfb\xa4\x96\x6e\xaa\xd7\xdd\x55\xe3\xa8\xa7\xe7\x03\x9e\x60\xdc\xb8\xf5\xc3\x6f\x54\x6b\x99\xf0\xea\xce\x05\x6c\x34\x15\x73\x48\x81\x39\xec\x77\x4d\x20\x1e\x74\x5d\x0e\xca\x1f\x2b\x38\x9a\xdf\x4d\x5f\x1d\x57\xc7\x1c\x8c\x0b\xbf\xea\xbd\x2e\x01\x71\x66\x87\xd4\xe8\x55\xc7\xe5\xd4\xe8\x5e\x18\x6e\x5c\x2c\x78\x37\x75\xb7\x79\x5e\x10\xf3\xb5\x39\x97\xb6\x2f\xa4\x48\x77\xa9\x09\xf7\xb6\xf0\x36\x61\x1b\xab\xd4\xf0\xc6\x6d\x22\xbe\x73\x57\x0d\x70\xe6\x0a\x59\x94\x19\xfa\x73\x3c\x3c\xbf\xbb\xb7\x19\xe3\x77\xf6\x74\xf5\xf0\x14\x59\x4b\x0f\x63\xc7\xde\xee\x9e\xce\x3f\x8d\xdc\xa5\x91\x70\xf7\xea\x77\xbf\xfd\xed\xe7\x9e\xcd\xb4\xad\x0a\xfe\x18\xe9\x4c\x5b\x9a\x68\x57\xc4\x17\x5d\xf5\xf1\x45\x3f\xdf\xf8\xa2\xc7\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\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\x1e\x1c\x53\xd2\x3d\x09\x60\x77\x7b\xda\x2e\x05\xa9\xaa\x9e\x2b\x35\x48\x1f\x54\xee\x73\x8f\x1d\x1e\xea\x28\xb5\x98\x91\xf6\x04\x3e\x89\x42\x42\x3a\x68\x63\x38\xbc\xec\x52\x1b\xd2\xf5\xf9\x70\xd3\xb8\x98\x09\xaf\x9f\xe7\x3e\xe6\xe7\x70\xe1\xd1\xd7\x74\xf9\x4c\x4c\xee\xba\x96\xad\xc5\x5b\x2b\x80\x04\x00\x23\x97\xe3\x38\x4b\x64\x75\x74\xce\xae\xaf\xac\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\x7d\x8f\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\x6b\x08\xc8\xa9\x5a\xd5\x25\x69\x14\xa5\x69\x96\xc9\x7b\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\x1b\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\xe0\x7e\x02\xde\xb0\x90\x65\xb0\x77\x61\x31\xcc\xb0\x3a\xbd\x02\x4e\xef\xab\x1f\x41\x15\x48\xa5\x37\x4d\x0c\xd9\x27\xae\xcd\xf2\x5a\x3c\x88\x7c\x1a\xbc\x7d\xe1\xcd\x5c\x17\x96\x2d\x74\xae\x6a\x57\xeb\x57\x97\x57\xe6\x37\xf0\xd3\x67\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\x25\xd5\x2c\x25\xef\xa8\xa0\x53\xd4\xf7\x8e\x6e\xae\xbf\x7c\x77\x6c\xf7\x15\xf4\xc9\xab\x8b\x95\x17\x6d\x37\xf1\xe0\xef\xf7\x19\x2f\xb2\xb4\xf0\x1d\x58\xd5\x52\xff\x1d\x17\xbf\xd7\x40\x18\x12\xf8\x50\xbb\x64\xbd\x2b\x58\xd0\x75\x33\x84\xb5\x59\xf3\xb3\x41\x60\xe6\x79\xfa\xc0\x2a\x9f\x5c\x68\x43\xb3\xec\x3a\xa3\xe2\xac\x28\x94\x9c\xaf\xd6\xc6\x6b\x73\xf5\x0d\xfd\x4c\xd1\xcd\xc3\xbf\x2c\x10\xf4\x70\x85\x2d\xc8\x55\x35\xfe\x88\x5c\x99\xa0\x85\x4b\x01\x2c\xf5\xe0\xac\x34\x32\xa7\x86\x27\x07\x56\x59\x3f\x78\x47\x45\x49\xb3\x95\x4e\x57\x1b\x97\xb1\x4e\x44\xdc\xd8\x69\x7d\xea\xba\x16\xdd\x36\xca\x1a\x9b\xfb\x1b\xaa\x2c\x75\x3a\xbf\xf9\xb6\x53\x5f\x6d\xa8\x29\x97\xa8\xf0\x06\xce\xb0\x9e\x17\x0c\x49\x46\xb5\xf9\xa6\x48\xed\xa1\x6f\xfc\xba\x89\xe0\x27\xd4\xd0\x4c\x4e\xff\xc2\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\x6f\xa0\xed\xb9\x14\x29\x47\xb3\x23\x18\xd4\xb0\x47\x7d\xdc\xf5\xa8\xb6\xee\xa6\x61\xc3\xdd\x42\x3d\xbb\x66\x34\x9f\x3a\x28\xb0\xd9\xd8\xc9\x97\x33\x7c\x09\x37\xed\xb5\xb9\x2d\x41\x8a\xdc\x09\x2b\x18\x42\x1e\x91\xd5\x64\x6b\xab\x9c\xb0\x4d\x3e\x18\xfa\x3d\xc6\x29\xac\x77\x1c\x1d\xba\x79\xaf\xbb\x83\xd8\x84\x62\xf8\x6c\x97\x2c\x9a\x53\x59\x4f\x53\x57\xe1\x5d\xe8\x86\x91\x2c\x8d\x82\xfc\xb5\x46\xeb\x79\x40\x2b\xc1\xab\x9d\x8c\xd4\x36\xab\x7d\x9d\xd6\x56\x39\xd8\x97\x54\xd9\x16\x12\xe3\x56\xa6\xd5\x32\xb9\x7c\x5d\xb1\xbe\x72\xfe\x7f\xca\xa9\x22\x94\x14\x9c\x61\xf2\x13\x2a\x1c\xb0\x80\xb3\x30\x9a\xba\x97\x96\x83\x59\x95\x10\x7e\x1b\xb8\xcb\x70\x34\x2e\x3b\x5f\x0b\x6f\xa0\xa6\x98\xfc\x03\x2e\x2e\x4e\xbe\x92\xce\xc8\xeb\x82\x74\x2d\x0d\x00\x4e\x3e\x20\xba\x4c\x66\x84\x6a\x3b\x35\x8b\xd0\xf6\xc4\xb3\x51\x4e\x05\x9f\x30\x6d\x46\x21\x4b\xb0\xfe\xfe\x37\x3f\x8c\xc8\x1b\xa9\x88\x73\x54\x1f\xf8\xac\x1a\x6e\x9e\x15\x5e\x70\x8d\x8b\x09\x7d\x2b\xad\xb5\x90\xa9\x9b\xf4\x3d\x4c\xd6\xd0\x3b\xcb\xc3\x70\xb2\x25\x83\xab\x8b\x53\x72\x60\xc5\xc4\xe8\xd3\xff\xb2\x6c\xe9\x3f\x07\xe4\xe8\x1e\x98\xf6\x81\xfd\xf3\x00\x3f\x18\xdc\x26\x63\xa5\xba\xfa\x30\x06\x4b\x2a\x3e\x9d\x32\x85\xea\x23\x81\xa0\xc2\x63\x97\x15\x44\xc8\xa8\xb1\xbf\x94\xae\xd4\xcd\xe6\x44\xbe\xff\xcd\x0f\x07\xe4\xa8\xbe\x2e\xc2\x45\xca\x3e\x91\xdf\xa0\x75\x99\x6b\xbb\xc6\x63\x77\x99\xa3\x17\xc2\xd0\x4f\x76\xcc\x64\x26\x35\x13\xa8\xca\x1b\x49\x66\x74\xce\x88\x96\x56\x03\x66\x59\x36\x74\xb6\x74\x72\x4f\x21\x53\x8b\x07\x25\x04\xd6\x93\x82\x2a\x53\x43\x89\x91\xb3\x90\xc0\xd7\xec\xb6\x4d\x85\xbf\x99\x9e\x70\xe1\xee\xaf\xdc\xcd\x99\xdd\x73\x08\x0c\xc5\x4d\x32\x92\x24\x33\x2a\xa6\x21\x36\x7d\x52\x9a\x52\xb1\x2d\x57\x3f\x2d\xcf\xc0\x1d\x17\x9d\x42\x98\xbf\xe6\xa2\xe9\x54\xb0\xda\xae\x34\xe5\xc6\x47\x45\x38\x5f\x45\xb3\x38\xb1\xbb\xa0\xf8\xb8\x34\x52\xe9\x93\x94\xcd\x59\x76\xa2\xf9\x74\x48\x55\x32\xe3\x86\x25\x76\x59\x27\xb4\xe0\xc3\x44\x0a\xbb\xe3\x90\x95\x21\x4f\x7f\x01\xe5\x4d\x87\x76\xaa\x5b\xb2\x4e\xb7\x5c\xf4\x76\xa3\xda\xb3\x1a\xd3\xf6\xb6\xc6\x16\xf6\xa0\xe5\x85\xa2\x6d\xe6\x09\x56\x0b\x86\x90\x93\xbd\x2c\xd6\x27\x4d\xee\xce\x63\x0e\x5d\x1e\xf0\xa4\x39\x86\x3d\x76\xe8\x40\x02\xa7\xb2\x46\x29\x73\x9a\x22\x29\xa5\x62\xf1\xe8\xc8\x6f\x41\x0a\xe9\xf2\x93\xc5\x10\x86\x90\xd9\x90\x8a\xd4\xfe\x1b\x03\x76\x92\xc5\x5e\x60\x58\xf2\x4e\x84\xe0\x9b\xab\x8b\xa7\x39\x12\x25\xdf\xc3\xa9\x77\xf2\x5a\x4b\x21\x0a\x45\x55\x74\xd4\x50\x25\xf3\x4c\xb3\x2e\xa0\x72\xed\x47\xfd\x6f\x77\xff\x12\xb2\x9d\x6d\x13\xa9\x36\xdf\x9a\x44\xb2\x63\xcb\xf9\xbe\xad\x7a\xc4\x36\x39\x70\xbc\xa2\xda\xb8\xd4\x5a\x3e\x07\x41\x6d\x19\x5e\x41\x01\x06\xb3\xfe\x62\xb8\x15\x0e\x79\x7f\x01\x3b\x91\xe1\xca\x9c\x4b\x49\x50\x4a\xb6\x2b\x50\x95\xfe\x52\xab\x83\x86\x8b\x32\x4c\x1b\x42\xe7\x94\x67\x60\x9d\x97\x63\xcd\xd4\x1c\x0b\x52\xb9\x54\x83\xb4\xa9\x67\xb9\x9a\x13\x28\x46\x3d\x91\xe6\xe3\xd7\xb0\xbc\x2b\x9b\x16\x00\xda\x50\x63\xf6\x6b\x67\xbd\x17\xbd\x07\xd5\xcb\xb5\x3f\xdb\x2f\xec\xa8\xc6\x58\xfc\xfb\x0b\xa3\xca\x8c\x19\x35\xb7\x7c\x13\xdf\x5d\x42\xe9\x5a\xbf\x50\xca\x3d\x20\xf4\x3d\x23\x53\x69\xac\x88\x55\x02\xee\xa3\x4c\x8a\x49\x7d\x02\xa2\x3d\x36\x46\x57\xab\xbc\x55\x14\x42\x7c\xa4\xe8\xb8\xcc\x7a\xc7\xe5\x75\x3a\xe9\xd8\x61\x92\xc1\xd6\x98\x48\x43\x0a\xe6\xf6\x0e\x6f\x33\x80\x02\x3d\xcd\x92\x73\xa6\xf5\xc6\x04\x1b\x75\xef\x42\x6c\x8d\x47\xb9\x71\xb5\x96\xfb\xdf\x30\x2c\xc4\x0a\xd0\x29\x33\x94\x67\xfe\x28\x23\x28\x02\x94\xb6\x51\xd7\x8d\x0b\x54\x8c\xea\x4d\x02\x42\x6d\xd6\x1f\xa1\x31\x4e\x5a\x0a\x36\xbc\x97\x2a\x25\xe7\x34\x67\xd9\x39\xd5\xcc\x8d\x15\x87\xe8\xe1\x1e\x1d\xea\xbd\x4e\x79\xb5\xed\x6b\xcd\x94\xd1\xf8\x53\x99\x84\xe1\xaf\x4a\xc5\xc2\x09\x0e\xbc\x09\xf2\x56\x95\x6c\x40\xde\x58\xee\x35\x20\xdf\x88\x3b\x21\xef\x1f\x36\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\x8a\x09\x17\xdc\xb7\x75\x7a\x57\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\x6f\xbe\x5d\x0f\xec\xb5\xbc\x6f\x1b\x7f\xda\x6e\x96\x7a\xa8\x41\x6a\xeb\x99\xd9\x6a\x84\xea\xcd\x4f\xbd\xf9\xe9\x73\x32\x3f\x6d\xc5\xf8\x4d\x26\xa7\xcf\xc3\xd8\xb4\x75\x89\x9b\x0c\x4c\x2f\xd2\xb4\xd4\x6a\x45\x1b\xcd\x49\x2f\xd6\x90\xb4\x75\x69\x2d\x8d\x47\x3f\x1f\xb3\xd1\x56\x88\x6d\x30\x15\xbd\x40\x23\x51\x1b\x81\x8c\xa5\x6d\xc4\xc4\xab\xa8\x71\x2c\x28\x56\xe5\x2c\xc3\x70\xde\x29\x27\x16\x67\x76\x95\x16\xad\x00\xb7\x75\x6e\x87\x6e\x72\xed\x65\x2f\x27\x30\xba\x62\x8f\x4b\x93\x25\x17\x97\xd7\x1f\x2f\xcf\xcf\x6e\x2f\x2f\x9a\xf2\xdd\x2a\x48\x6f\x91\xc4\x36\xdb\x20\x86\x91\x24\xb6\xa6\x81\x25\xc8\x6b\x7e\xb2\x38\xb0\xe6\xa7\xb2\xe4\xab\x7a\x3d\x5c\x2e\x7c\x10\x97\x7b\x10\xff\xd8\x7e\x3a\xdb\x1e\xcf\x6f\xd0\x71\x8a\x3a\x9f\x33\x2b\xf7\xcc\x64\x96\x6a\xef\xb7\x7a\x75\x11\x22\xa9\xb8\x48\xb2\x32\xb5\xc2\xc5\x37\xdf\x5c\x5d\xe8\x11\x21\x5f\xb2\x84\x96\x1a\xac\x30\xa9\x14\x87\x86\x7c\x78\xff\xf6\x7f\xc0\x1f\x1b\x5a\x0c\x42\x5e\x13\xc8\xca\xcb\x29\x26\x16\x36\x98\xae\x8d\x7c\xc9\x50\x50\x81\x2f\x27\xb4\xb0\x54\x4c\x63\xe5\x0a\x03\xb2\xc8\x8c\x65\x85\xa5\x98\x77\x8c\x54\x19\x54\xed\xc0\x55\x85\x79\xef\x3e\x39\x65\x06\xa3\xae\x36\x79\x48\x6e\x84\xda\x16\x8b\xeb\x03\x6c\xad\x35\xf5\xd1\x69\xe3\xf7\x54\x3b\x8b\xd5\xca\xd9\x6e\xd9\xdf\xed\xf6\x99\xf5\x26\x8e\x35\xc6\x0d\x24\xcf\xf0\xd7\xd2\x9c\xed\x64\x2b\x3b\x06\x3a\x91\x70\xd3\xda\x9a\xba\xde\x0d\x68\x75\x1d\x80\x25\x5b\x06\x6b\x02\xb9\xf6\xe1\xe0\x91\x1d\x4d\xb9\xdd\x5c\xa0\x88\x48\x5a\xab\xfd\xe9\xfc\xe7\xea\xef\xca\x71\xa8\xfe\x5a\xcd\xd7\x59\x64\xc8\xbf\xfe\xf3\xc5\xff\x1f\x00\x00\xff\xff\x9d\xd9\x48\xd2\xa7\x53\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..b203d9a18d 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,18 @@ type SubscriptionConfig struct { // List of VolumeMounts to set in the container. // +optional VolumeMounts []corev1.VolumeMount `json:"volumeMounts,omitempty"` + + // Describes node affinity scheduling rules for the pod. + // +optional + NodeAffinity *corev1.NodeAffinity `json:"nodeAffinity,omitempty" protobuf:"bytes,1,opt,name=nodeAffinity"` + + // Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)). + // +optional + PodAffinity *corev1.PodAffinity `json:"podAffinity,omitempty" protobuf:"bytes,2,opt,name=podAffinity"` + + // Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)). + // +optional + PodAntiAffinity *corev1.PodAntiAffinity `json:"podAntiAffinity,omitempty" protobuf:"bytes,3,opt,name=podAntiAffinity"` } // 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..8b9a736964 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,21 @@ func (in *SubscriptionConfig) DeepCopyInto(out *SubscriptionConfig) { (*in)[i].DeepCopyInto(&(*out)[i]) } } + if in.NodeAffinity != nil { + in, out := &in.NodeAffinity, &out.NodeAffinity + *out = new(v1.NodeAffinity) + (*in).DeepCopyInto(*out) + } + if in.PodAffinity != nil { + in, out := &in.PodAffinity, &out.PodAffinity + *out = new(v1.PodAffinity) + (*in).DeepCopyInto(*out) + } + if in.PodAntiAffinity != nil { + in, out := &in.PodAntiAffinity, &out.PodAntiAffinity + *out = new(v1.PodAntiAffinity) + (*in).DeepCopyInto(*out) + } } // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SubscriptionConfig. From 1e69d14e32fd62bebbf1410b2a70ce92e1e8a2ec Mon Sep 17 00:00:00 2001 From: perdasilva Date: Mon, 1 Aug 2022 15:38:25 +0200 Subject: [PATCH 02/15] Revert "Add node affinity and pod (anti)affinity to Subscription spec.config (#250)" This reverts commit f8da7254a5aabb477235d297f080af29f7fb0be4. Upstream-repository: api Upstream-commit: 5490427930e127437fec9224e59cee50405ca131 --- .../0000_50_olm_00-subscriptions.crd.yaml | 457 ------------------ .../operators.coreos.com_subscriptions.yaml | 457 ------------------ staging/api/crds/zz_defs.go | 2 +- .../operators/v1alpha1/subscription_types.go | 12 - .../v1alpha1/zz_generated.deepcopy.go | 15 - .../operators.coreos.com_subscriptions.yaml | 457 ------------------ .../operator-framework/api/crds/zz_defs.go | 2 +- .../operators/v1alpha1/subscription_types.go | 12 - .../v1alpha1/zz_generated.deepcopy.go | 15 - 9 files changed, 2 insertions(+), 1427 deletions(-) diff --git a/manifests/0000_50_olm_00-subscriptions.crd.yaml b/manifests/0000_50_olm_00-subscriptions.crd.yaml index efa67ddfe0..ce6b6c9e93 100644 --- a/manifests/0000_50_olm_00-subscriptions.crd.yaml +++ b/manifests/0000_50_olm_00-subscriptions.crd.yaml @@ -175,468 +175,11 @@ spec: optional: description: Specify whether the Secret must be defined type: boolean - 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 nodeSelector: description: 'NodeSelector is a selector which must be true for the pod to fit on a node. Selector which must match a node''s labels for the pod to be scheduled on that node. More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/' type: object additionalProperties: 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 resources: description: 'Resources represents compute resources required by this container. Immutable. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/' type: object diff --git a/staging/api/crds/operators.coreos.com_subscriptions.yaml b/staging/api/crds/operators.coreos.com_subscriptions.yaml index 0e2bd8d983..7bcc8c94f1 100644 --- a/staging/api/crds/operators.coreos.com_subscriptions.yaml +++ b/staging/api/crds/operators.coreos.com_subscriptions.yaml @@ -173,468 +173,11 @@ spec: optional: description: Specify whether the Secret must be defined type: boolean - 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 nodeSelector: description: 'NodeSelector is a selector which must be true for the pod to fit on a node. Selector which must match a node''s labels for the pod to be scheduled on that node. More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/' type: object additionalProperties: 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 resources: description: 'Resources represents compute resources required by this container. Immutable. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/' type: object diff --git a/staging/api/crds/zz_defs.go b/staging/api/crds/zz_defs.go index 68b9d3530c..3578ef32e0 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\xbd\x6b\x77\xe3\xb6\xd5\x28\xfc\x3d\xbf\x02\xcb\xed\x5a\xb6\x5b\x49\x9e\xe9\xd3\xd3\xf6\xf8\xe9\x6a\x97\x63\x7b\x52\x9f\xcc\xc5\x67\xec\x24\xeb\x79\xd3\x9c\x16\x22\x21\x09\x35\x09\x30\x00\x28\x8f\x7a\xf9\xef\xef\xc2\xde\x00\x08\x52\x37\x52\x96\x2f\x93\x90\x1f\x92\x31\x05\x80\xc0\xc6\xc6\xbe\x61\x5f\x68\xc1\xbf\x65\x4a\x73\x29\x4e\x09\x2d\x38\xfb\x64\x98\xb0\x7f\xe9\xd1\xdd\x1f\xf4\x88\xcb\x93\xf9\xeb\x2f\xee\xb8\x48\x4f\xc9\x79\xa9\x8d\xcc\x3f\x32\x2d\x4b\x95\xb0\x0b\x36\xe1\x82\x1b\x2e\xc5\x17\x39\x33\x34\xa5\x86\x9e\x7e\x41\x08\x15\x42\x1a\x6a\x5f\x6b\xfb\x27\x21\x89\x14\x46\xc9\x2c\x63\x6a\x38\x65\x62\x74\x57\x8e\xd9\xb8\xe4\x59\xca\x14\x0c\xee\x3f\x3d\x7f\x35\xfa\xc3\xe8\xd5\x17\x84\x24\x8a\x41\xf7\x5b\x9e\x33\x6d\x68\x5e\x9c\x12\x51\x66\xd9\x17\x84\x08\x9a\xb3\x53\xa2\xcb\xb1\x4e\x14\x2f\xe0\x13\x23\x59\x30\x45\x8d\x54\x7a\x94\x48\xc5\xa4\xfd\x5f\xfe\x85\x2e\x58\x62\x3f\x3e\x55\xb2\x2c\x4e\xc9\xca\x36\x38\x9c\x9f\x23\x35\x6c\x2a\x15\xf7\x7f\x13\x32\x24\x32\xcb\xe1\xdf\xb8\xf6\x9b\xe8\xab\xf0\x3a\xe3\xda\x7c\xbd\xf4\xd3\x5b\xae\x0d\xfc\x5c\x64\xa5\xa2\x59\x63\xb6\xf0\x8b\x9e\x49\x65\xde\x57\xdf\xb6\xdf\xd2\xe5\x38\xfe\xb7\x6b\xc8\xc5\xb4\xcc\xa8\xaa\x0f\xf2\x05\x21\x3a\x91\x05\x3b\x25\x30\x46\x41\x13\x96\x7e\x41\x88\x83\xa3\x1b\x73\x48\x68\x9a\xc2\xde\xd0\xec\x5a\x71\x61\x98\x3a\x97\x59\x99\x8b\xf0\x4d\xdb\x26\x65\x61\xd4\x53\x72\x3b\x63\xa4\xa0\xc9\x1d\x9d\x32\xff\xbd\x31\x4b\x89\x91\xa1\x03\x21\xff\xd0\x52\x5c\x53\x33\x3b\x25\x23\x0b\xe2\x91\x85\x60\xf4\x33\xee\xcf\x35\x0e\x12\xbd\x37\x0b\x3b\x5d\x6d\x14\x17\xd3\x4d\x9f\x4f\xa8\xa1\x99\x9c\x12\xc4\x2f\x32\x91\x8a\x98\x19\x23\xf6\x53\x7c\xc2\x59\xea\xe7\xb7\x61\x46\xd8\x75\x69\x4e\x37\xcd\xd7\xad\xa7\x34\xa3\x42\xb0\x8c\xc8\x09\x29\x8b\x94\x1a\xa6\x89\x91\x15\x7c\x36\x83\xc7\x75\x5e\x9a\xcd\xf9\xd2\xfb\x15\xd3\xc1\xa6\xf3\xd7\x34\x2b\x66\xf4\xb5\x7b\xa9\x93\x19\xcb\x69\xb5\x87\xb2\x60\xe2\xec\xfa\xea\xdb\xff\xba\x69\xfc\x40\xea\x4b\x89\x51\x94\xdc\x31\x56\xe8\xea\x50\x90\xb2\xb0\x6b\xb2\x8b\x23\xe3\x05\x31\x8a\x26\x77\x5c\x4c\x61\xe9\x53\x5c\xef\x39\x6e\x8c\x1e\x2d\x4d\x59\x8e\xff\xc1\x12\x13\xbd\x56\xec\xc7\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\x11\xb9\x61\xca\x76\xb4\x07\xb6\xcc\x52\x4b\xc7\xe6\x4c\x19\xa2\x58\x22\xa7\x82\xff\x33\x8c\x06\x20\xb2\x9f\xc9\x2c\x7e\x18\x02\xc7\x4d\xd0\x8c\xcc\x69\x56\xb2\x01\xa1\x22\x25\x39\x5d\x10\xc5\xec\xb8\xa4\x14\xd1\x08\xd0\x44\x8f\xc8\x3b\xa9\x18\xe1\x62\x22\x4f\xc9\xcc\x98\x42\x9f\x9e\x9c\x4c\xb9\xf1\x14\x38\x91\x79\x5e\x0a\x6e\x16\x27\x40\x4c\xf9\xb8\xb4\x1b\x77\x92\xb2\x39\xcb\x4e\x34\x9f\x0e\xa9\x4a\x66\xdc\xb0\xc4\x94\x8a\x9d\xd0\x82\x0f\x61\xb2\x02\x49\x64\x9e\xfe\x42\x39\x9a\xad\x0f\x1b\xe0\x5b\x79\x0e\x88\xa7\x7a\x1b\x61\x6d\x89\x1f\xe1\x9a\x50\xd7\x1d\xd7\x52\x81\xd4\xbe\xb2\x50\xf9\x78\x79\x73\x4b\xfc\x04\x10\xec\x08\xe1\xaa\xa9\xae\x80\x6d\x01\xc5\xc5\x84\x29\x6c\x39\x51\x32\x87\x51\x98\x48\x0b\xc9\x85\x81\x3f\x92\x8c\x33\x61\xec\x31\xcc\xb9\xd1\x80\x73\x4c\x1b\xbb\x0f\x23\x72\x0e\x0c\x88\x8c\x99\x3b\xb0\xe9\x88\x5c\x09\x72\x4e\x73\x96\x9d\x53\xcd\x1e\x1d\xd4\x16\xa2\x7a\x68\xc1\xd7\x1e\xd8\x31\xff\x5c\xee\xb0\x74\xc6\x08\xf1\x0c\x6e\xed\xee\xc4\x07\xfe\xa6\x60\x49\x38\x0e\x54\x90\xb3\xa2\xc8\x78\x82\x18\x6f\x66\xd4\x90\x84\x0a\x0b\x2f\x2e\xb4\xa1\x59\x06\xec\xa4\xd5\x2c\xd6\x9d\x76\x02\x47\xbb\xc1\x1c\xfc\xeb\x25\x0a\x5d\xff\x21\x30\xb5\x46\x8b\x75\x94\xc1\x3e\x8e\xce\x2e\xff\xb0\x01\xe4\x04\x25\x93\x09\x9f\xae\xea\xb6\x16\x96\xe7\xd0\x05\x64\x1a\xca\x85\x76\x43\x94\x0a\xa1\x59\x71\x2a\xcb\xbb\x68\x8d\x6f\x8f\xd6\xce\x6e\x25\x64\xb7\xad\xd9\x3e\x4c\xcc\x57\xff\xd0\x58\xc0\xa5\x98\xe3\x41\xb5\x32\x8b\x25\x72\x4c\xcc\xb9\x92\x22\xb7\x87\x68\x4e\x15\xa7\xe3\xcc\x31\x36\x66\xc9\x17\x9e\x31\x5c\x22\x53\xab\x8e\xd4\x9a\xaf\xe2\x7a\xa8\x52\x74\xb1\xa6\x05\x37\x2c\x5f\xb3\x9a\x55\xd3\xfe\x96\xaa\x88\x4a\x58\xe4\x5d\x35\x75\xe2\x1a\xd8\xa9\x53\x72\x1e\x26\xbe\xf6\x33\x5b\xe0\x8e\xcf\x7a\xdc\xae\x9e\x35\x58\xee\x9f\x6d\x1b\x88\x0f\x70\xfa\x0d\xbf\x37\xc0\x62\x4f\x08\x32\x30\xb6\x12\x1a\x23\xf2\xae\xd4\xb0\x5b\x94\x9c\xff\xed\xea\xe2\xf2\xfd\xed\xd5\x9b\xab\xcb\x8f\xeb\xc1\x41\xb6\x1d\x94\xea\x01\x1a\xdf\x61\xb2\x87\xdf\xfa\x3d\x52\x6c\xc2\x14\x13\x09\xd3\xe4\x97\x47\xdf\x9e\x7d\xfc\xdb\xfb\xb3\x77\x97\xc7\x84\x2a\x46\xd8\xa7\x82\x8a\x94\xa5\xa4\xd4\x9e\x69\x14\x8a\xcd\xb9\x2c\x75\xb6\x70\x94\x2b\x5d\x83\xb4\x4d\x6c\x05\x6e\x4b\xc5\x82\x68\xa6\xe6\x3c\x59\x0d\x22\x3d\x22\x57\x13\x42\x2b\x04\x4a\x02\x86\x5b\x46\x95\xcd\x59\x3a\x80\x61\xc3\xa4\xfd\x77\xb8\x28\x4a\xe3\x19\xde\x3d\xcf\x32\x38\x15\x02\x65\xa5\x74\x44\x2e\x64\x69\xc7\xfb\xe5\x2f\x61\x61\x8a\xa5\x65\x02\x42\xb4\x25\x06\x5c\x4c\xed\x4f\x03\x72\x3f\xe3\xc9\x8c\xd0\x2c\x93\xf7\x1a\x28\x05\xd3\x09\x2d\xfc\xd2\x63\xe8\xe8\x85\x30\xf4\xd3\x29\xe1\x23\x36\x22\x07\xbf\x8c\x7e\x3a\xc0\xaf\x17\x4a\xda\x4f\xa0\x9c\x8c\xb3\xca\xb8\x61\x8a\x66\xe4\x20\x6e\x3d\x22\x97\xf6\x1b\x2c\x8d\xf7\x01\x46\x10\x6c\xce\x94\x5d\x85\xdf\x85\x01\x51\x6c\x4a\x55\x9a\x31\xad\x2d\x9e\xdd\xcf\x98\x99\x31\x14\xc5\x03\xc0\xd8\x27\x6e\x19\xae\x54\x44\x48\x33\x22\x17\x6c\x42\xcb\x0c\x38\x30\x39\x38\x18\x35\x19\xdf\xee\xa8\xf6\x46\xc9\xbc\x03\xba\xdd\xd4\x35\x87\x55\x7b\x7f\xa8\x71\xe4\x1a\x59\xd3\x2c\x25\x7c\xe2\x24\x18\xae\xed\xa2\x08\xcb\x0b\xb3\x68\x73\x68\xb6\xd0\x11\xd2\x9a\x10\x90\xc0\x93\xde\xd1\xe2\x6b\xb6\xf8\xc8\x26\xdb\x9a\x37\xd7\xcf\x32\x96\x58\x42\x49\xee\xd8\x02\xc4\x59\x72\xee\x07\xdc\xbc\x94\x4e\xcb\x21\x2d\xc9\xa3\x7f\x86\x76\x3a\x5b\xdb\xb5\x07\x92\x7d\xee\xd8\xa2\x4d\x33\xb2\xac\xd3\x59\xd0\x00\xaf\xb3\xb0\xda\x0e\x15\xd2\x1e\x65\xfd\xb3\x9d\xa2\xaf\x9c\xdc\x61\x4c\xda\xdd\x39\x35\x2b\x05\xd6\xbb\x72\xcc\x94\x60\x86\x81\xcc\x9a\xca\x44\x5b\x71\x35\x61\x85\xd1\x27\x72\x6e\x29\x1f\xbb\x3f\xb9\x97\xca\x2a\x72\xc3\x7b\x6e\x66\x43\xdc\x55\x7d\x02\x46\x8f\x93\x5f\xc0\xff\xc8\xed\x87\x8b\x0f\xa7\xe4\x2c\x4d\x89\x84\x23\x5e\x6a\x36\x29\x33\x32\xe1\x2c\x4b\xf5\x28\xd2\xba\x06\xa0\x0f\x0c\x48\xc9\xd3\x3f\x6f\x3e\xdc\x3b\x42\x4c\x16\x68\xac\xd8\x01\x6a\x37\x20\x74\x2d\x6a\x74\x2a\x20\xbd\xa5\x50\x56\x45\xb0\x7b\x9e\x3b\xb6\xe8\x18\x4a\x87\x65\x8c\xa5\xcc\x18\x15\x5b\x7a\x00\xd8\xba\x9f\xd9\xc3\xea\xd0\xc2\x08\x1e\x01\x0a\x99\x9e\x12\x5d\x16\x85\x54\x46\x07\x15\x01\x6c\x2e\x83\xfa\x9f\x20\x2f\x0f\xc8\xdf\xc3\xcb\x8c\x8e\x59\xa6\xbf\x3f\x3c\xfc\xe3\xd7\x97\xff\xf3\xa7\xc3\xc3\x1f\xfe\x1e\xff\x1a\x59\xe8\xea\x4d\xd0\xa6\x23\x53\x10\xc2\xdd\x9f\x8e\x8d\x9e\x25\x89\x2c\x85\x71\x3f\x18\x6a\x4a\x3d\x9a\x49\x6d\xae\xae\xc3\x9f\x85\x4c\x9b\x7f\xe9\x2d\x9c\x80\x3c\x2e\xd1\x01\x70\x5e\x53\x33\xdb\x33\xe9\x59\x6f\x8d\x58\xfd\xd4\xb6\xdb\xdb\x27\xdc\x2e\x3b\x83\x84\xfd\xe7\x1b\x3f\x5d\xcb\x81\xee\x15\x37\x86\x09\x90\x3b\x98\xca\x2d\x27\x1e\x58\xcc\xad\xd8\xec\xfc\xf5\xc1\xa3\x10\xaf\x00\xb5\x1d\x16\x07\xb3\x77\x2b\x43\x64\x0e\x84\xd6\x4b\x50\x95\x8e\x74\x76\x7d\xe5\x2d\x33\x7b\x5f\x88\xb7\x37\xbc\x79\xf0\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\x47\x49\x51\x0e\x5c\x83\x51\xce\x72\xa9\x16\xe1\x4f\x56\xcc\x58\x6e\x25\xb6\xa1\x36\x52\xd1\x29\x1b\x84\xee\xd8\x2d\xfc\x85\x1d\x6b\x1f\x58\xee\x8d\x22\x75\x52\x2a\xcb\x3c\xb2\x85\xa7\x20\x2c\x7d\xde\xb3\xe8\xc1\xb4\xe7\xa3\x18\x76\xe3\xfd\x8e\x2c\x37\x68\x8b\xce\xe0\xea\x57\x05\x32\xe4\x5c\x66\x65\xce\xf4\x20\xb0\x27\x94\xd6\xc5\xdc\x4a\x93\x4b\xe6\x9d\xd5\x4f\xc7\xd3\x97\xf2\x39\xd7\x52\xed\xcc\x07\xb9\x33\x79\xca\xd2\x58\x4d\x65\x22\x55\x4e\x4d\x50\x17\x3f\x15\x52\x83\x0e\xe0\x70\xb6\x41\x52\x5e\x1f\xb4\xfa\x6c\x41\x8d\x61\x4a\x9c\x92\xff\x77\xf4\xd7\x5f\xff\x7b\x78\xfc\xe7\xa3\xa3\xef\x5f\x0d\xff\xf7\x0f\xbf\x3e\xfa\xeb\x08\xfe\xf1\xab\xe3\x3f\x1f\xff\xdb\xff\xf1\xeb\xe3\xe3\xa3\xa3\xef\xbf\x7e\xf7\xd5\xed\xf5\xe5\x0f\xfc\xf8\xdf\xdf\x8b\x32\xbf\xc3\xbf\xfe\x7d\xf4\x3d\xbb\xfc\xa1\xe5\x20\xc7\xc7\x7f\xfe\x65\xab\xe9\x51\xb1\xf8\xd0\xe2\xc0\xe3\x33\x74\x1b\xc4\x85\x61\x53\xa6\x3a\xf6\x6a\xbd\xad\x84\x7c\x1a\x56\x42\xdb\x90\x0b\x33\x94\x6a\x88\xdd\x4f\x89\x51\xe5\xf6\x83\x51\x11\xb5\x5d\xf0\xfc\xa3\x3f\xad\x91\x29\xd6\x93\xe6\xbd\x23\xb2\x66\x89\x62\x66\x5f\x1a\x0c\x8e\xe6\xf9\x47\x21\xd3\x43\x4d\xc4\x1a\x33\xe1\xba\x69\xff\x2c\x94\x1a\x2f\x52\x20\xbc\x2a\xce\x3b\x51\x32\x1f\x91\xc8\x2c\x34\xa7\x19\x4f\x7d\xbb\x3b\xb6\x45\xcb\xf5\x4f\xaf\x04\x7d\x5e\x4a\xd0\x0d\xee\xef\xa3\x6b\x40\x4c\xcc\x37\x99\x69\x9a\x36\x5d\xdb\xb6\x6e\x8e\xf6\x02\x94\x91\xa4\x90\x45\x99\x51\xb3\xc6\x6c\xb7\xc2\x36\xed\x70\x5f\x07\x33\xa1\xdd\x68\xb0\x03\x3b\x2a\x97\xaf\x36\x86\x92\xb3\x2c\x23\x5c\xe0\x49\x80\x01\xbc\x35\x4f\x31\x94\x97\x08\x45\x83\xf3\xdc\x4e\xe1\x7e\xc6\x9a\x86\x46\xae\xad\xae\xa3\x0c\x17\xd3\x11\xf9\xce\xfe\x8e\x34\xcb\x99\xc6\xb8\x20\x79\x99\x19\x5e\x64\x8c\x04\x6e\x8b\x36\xb4\xac\x64\x84\x6a\x2d\x13\x4e\x8d\x9b\xb1\xbb\x3f\xd4\xc6\x4f\x1b\x66\x63\xe8\x1d\x98\x42\x13\x96\x32\x91\xb0\x11\xf9\x16\xae\x0b\xc3\x5a\xc7\x56\x18\x04\xf3\x3e\x8c\x41\x49\x5a\xe2\xd5\x0e\xd2\x83\xd5\x63\x5c\xe5\x79\x69\xc0\x50\xfc\x54\x56\x7c\xbb\xe3\xce\x32\x17\x19\xf3\x81\x54\x05\xd1\x9a\xc2\xdd\x83\x9c\x54\xaa\xbb\x7e\x98\xf9\xbe\x1d\xe1\x0d\xe6\xb6\xad\x9c\x6a\x89\xe2\x56\x36\x86\x3a\xa5\x7d\x6a\x8b\x61\x3b\x3a\xfb\x93\xa4\xb1\x1d\xe8\x6b\x7b\xda\xda\xc1\xb8\xd4\x95\x9e\xb6\xb5\x26\x15\x8a\x4d\xf8\xa7\x0e\xf8\x78\x26\x2a\x15\x85\xa7\x4c\x18\xab\x08\x28\x20\xa8\x8a\x15\x4c\x80\x1e\xce\x68\x32\x03\xba\xe0\xa8\x68\x65\x19\x7e\xcc\x1b\x23\x94\x32\xba\x1f\xaf\x9b\x55\x52\x4c\x7f\xb6\x7e\xe2\x67\xcb\xed\xfa\xfe\x0f\x96\x90\x29\x3b\x9b\x80\xc7\xe2\x5a\x11\xbb\x36\xbb\x0b\x86\x2e\x5e\x1a\xba\x12\xea\xfa\x82\xc1\x2e\x2d\x33\x2e\xa6\x44\x95\x56\x26\xf1\x97\x4d\x85\xdc\x72\x2f\xbe\x11\x33\xdb\xe0\x64\x01\xe8\xa4\x58\x7a\x51\xda\x5d\xb9\x09\x33\xb9\x9a\x0a\x19\x5e\x5f\x7e\x62\x49\x69\xb6\x18\x27\x97\x8e\x9b\x5b\x16\x53\xfe\x5e\x91\x4d\x90\x80\xf8\x1f\xec\xfa\x40\x44\xb3\xe0\xd0\xe8\x38\xa2\xa9\xe1\x7a\xb2\x80\xe5\x07\x00\xb1\x4f\x96\xc5\x83\x33\x62\x64\xec\x1b\x2f\x9c\x43\x8f\x45\xcb\x01\x19\x97\x86\x70\x03\xde\x3e\xc9\x4c\x4a\x6d\x49\x0f\xc0\x19\xc6\x9d\x73\x09\xbe\x54\x44\x0a\x66\xe5\xd7\xdc\x1e\x9e\xca\x86\xe1\x87\x47\xe9\xaf\xea\xc6\x35\xc9\xa5\x36\x15\x9c\xec\x1b\x30\x86\x08\x56\x49\x59\x53\xc5\xd0\x4f\x4b\x97\x39\xdc\x6f\x32\x3e\x9d\x19\x3d\xc0\x4b\x56\x30\xf0\x58\x42\x59\x0d\x9b\x33\x66\x15\xd2\x2c\x8b\x6d\xb6\x1e\x05\x50\x61\xcc\x41\xa2\x39\x0a\xaa\xb5\x33\xcf\x0d\x82\x42\xd9\xdc\xb1\x95\xe0\x1a\x10\x66\x92\xd1\xf1\x80\x24\x32\x2f\x4a\xc3\xc0\x83\x24\xb7\xa0\x83\x2b\x5d\xe7\x51\xa5\x64\x39\xc5\x95\xb0\xcc\x7d\xd8\xbb\xb3\xa1\xc9\x15\x6e\xc0\xd3\xd4\xb6\x3e\xc0\xc5\x1d\x78\x0f\x35\x3b\x1c\xc7\x45\xc0\xfa\x72\x6a\x92\x99\xb3\x18\x25\x52\x29\xa6\x0b\x29\xa0\x27\xfc\x72\x59\xcd\xed\xbf\x43\xa7\x23\x7d\x5c\x01\x73\xc6\xa7\x33\x0f\x4b\xaa\xf0\x1e\xba\xbe\x07\x9b\x98\xc8\x76\x49\x93\x6c\x97\x36\x97\xd0\xf9\x4c\xe0\xdd\x6d\x84\x07\xd1\x8e\x19\xa6\xf2\xb0\x6e\xd8\x54\x24\xaa\xb8\x26\x9e\x5b\x01\x9a\x1b\x87\x15\xe4\x15\x39\x02\xb4\xe0\xe6\x50\x03\x8a\x0e\x65\x71\x3c\x22\x67\xe0\x92\xdc\xe2\x03\x42\x86\xf1\xdd\x40\xf6\xa3\x5a\x56\x63\xed\x87\xa5\xb5\x35\x5c\x0c\xdd\x9c\xad\x2a\xb0\xb5\x29\xc2\x60\x4f\xac\xb4\xfa\x6e\x47\x36\x71\x86\xa8\x8a\x52\x80\xa5\xb5\x4c\xe5\x83\x95\xfa\x53\x1d\x83\x71\xf6\x7b\xbe\xf5\xee\x66\xce\x69\x1e\xa2\x1d\x14\xfb\xb3\xa0\x25\xd7\xa1\x50\x23\x3c\xe3\x05\xfc\x7a\xa8\x09\xde\xfc\x75\xb1\xe7\x6c\x3b\x7d\xd5\xd3\xe2\x1c\xae\x5d\xc4\xda\xc9\x3b\x0f\xd2\xb0\xb9\xe0\x8f\xe8\xbd\xeb\xd0\x3b\x76\x80\x8a\xf5\xc0\xb9\xf6\x04\xcf\x65\x6c\xac\x18\xb2\x0a\xe3\x8c\x60\xb6\x91\xf3\xaa\x6d\x39\xd5\x4e\x08\x80\x4f\x17\x3b\x21\x3e\xed\xac\x85\x55\x6b\xbf\xc8\x96\x5d\xba\xe1\x25\x3e\xad\x8d\x8d\xf8\x2c\x89\x0c\x80\x6b\xe8\x4d\x61\x37\x02\x4d\x8f\x6e\x1f\x69\x51\x64\x70\x15\x21\xdb\xee\x02\xe9\x6e\x2f\xc3\xc7\x43\x6a\xe7\xb5\x7c\x8c\x1c\x0c\xed\x72\x0e\x35\x22\x95\x3d\xb1\x33\x5e\x38\xef\x2d\xb4\x4e\x78\x7f\xed\x6f\xc1\x6e\x54\xf9\xd0\x5b\xde\x77\x25\x06\xe4\xbd\x34\xf6\x7f\x97\x60\x03\x1a\x90\x0b\xc9\xf4\x7b\x69\xe0\xcf\x11\xf9\xca\x20\x0e\xbf\x6d\xe9\x75\xf2\x00\xa0\xe0\x3c\x77\x06\xc9\x99\x40\xba\x00\xd6\xb9\xc8\xbb\x1b\x1d\xe7\x40\xa4\xf2\x87\x90\x6b\x72\x25\xac\x90\xe6\x96\x1e\x4c\x5c\xda\x0d\xe1\x65\x79\x21\xc5\x10\x7d\xaa\x56\x8d\x71\x19\x1c\xca\x62\x98\x6d\x18\x6e\xfd\x50\x5f\x81\xcd\xf3\xed\xda\xce\x33\x3a\x67\x95\x3f\x9e\x13\xa2\xbc\x57\x9e\xb7\x02\x82\x13\x7f\xa1\x58\x65\x08\x74\x37\x44\x56\xe8\xe4\x7e\x3c\x0c\x21\xc8\x68\xc2\x52\x92\x82\x88\x87\xee\xf0\xd4\xb0\x29\x4f\x48\xce\xd4\x94\x91\xc2\x72\x81\xee\x3b\xde\x9e\x30\xe3\xd3\x89\x3c\xc7\x1f\x6a\x8d\x5a\xc0\xce\xe0\x46\xfd\x09\x38\x99\xd3\x5f\x7b\x4e\xd6\x73\xb2\xad\x4f\xcf\xc9\x7a\x4e\xb6\x06\x24\x3d\x27\xeb\x39\x59\xfd\x41\xbd\xb0\xa3\x12\xfa\x1d\x9a\x03\x9a\x5a\x27\x70\x44\xef\xb8\x5f\x57\x3f\x2d\x9f\xb8\x71\x44\xe4\x16\x54\x56\x67\x76\x57\x54\x4c\x19\x79\x3d\x7c\xfd\xea\x55\x5b\xe5\xb4\xad\x73\x0a\x7a\xfb\x40\xfb\xff\xfa\xcd\xda\xd6\xeb\x6c\x52\x0f\xb4\x22\x3a\xfc\x0d\x86\xad\x1a\x5f\x5f\x63\x08\x04\x6a\x23\xa4\x21\x39\x33\x84\x9a\x9a\x19\x85\xe7\x6c\xe0\x0d\xab\x2e\x54\x01\xbd\xf5\xbd\x45\x32\x25\x52\x38\xbb\x96\x05\xf6\x68\xb7\x19\x24\x8c\x6a\xf0\x85\x19\xb3\x30\x0b\x99\xdb\xaf\x72\x61\xfc\x51\xb0\x53\x60\x1e\x22\xe4\x88\x8d\xa6\x23\x92\x96\xd0\x8d\x0a\x17\x15\x75\x8c\xb3\xd5\x0b\x6d\x58\x0e\x96\x4d\xa9\xe0\x7f\x76\xda\x46\x81\xcf\x39\x5c\x26\x97\x34\xcb\x16\x84\xcd\x79\x62\xc2\xfa\x20\xce\x91\x1b\x34\x36\x6f\x37\x99\x6d\x65\xf1\xed\xd8\xfa\x70\x09\x4b\xd7\x5f\xba\xb6\xe7\xcc\x4b\x63\x6e\x3b\x6b\x0d\x1e\x86\x33\x1f\xad\x15\x18\xc1\x1f\x16\x6d\xbf\xe8\x1a\x6b\x91\xe8\xc3\xc7\xcd\xa6\x46\xd2\x89\x1a\xb5\xa4\x40\x4d\xd1\xb0\xcc\x32\xbb\xe9\x68\x7d\x5c\x9e\xf4\x0a\xab\x20\x2e\xa3\x86\xa8\x68\x64\x46\x73\xea\xd9\xfb\x0b\x0b\x09\xdb\xe6\x56\x16\x32\x93\xd3\x45\x0c\x59\x58\x11\xd8\x2c\x5d\x5f\x0c\x39\x64\xc1\xe1\xef\x7d\x63\x2b\x7a\x6b\xd8\x96\x85\xf7\x3a\x44\xaf\x43\xb4\x7a\x7a\x1d\xa2\xd7\x21\x7a\x1d\xe2\xe7\xaa\x43\x90\xde\x1a\xd6\x73\x32\x78\x7a\x4e\xd6\xe2\xe9\x39\xd9\xbe\x80\xd2\x73\xb2\x9e\x93\xb5\xfd\xd0\x06\xd4\x8a\x55\xf4\x56\xde\x70\x87\xb1\x26\xd9\xa0\xed\x08\x60\xbf\x7f\x46\x95\x2c\xf6\x89\xb3\xc7\x6c\xc2\x0d\x91\xc2\xb9\x78\x8d\xc8\xcd\x8a\x9e\xc0\x4d\x5d\x8b\xc3\xa0\xba\x35\x07\x6a\x58\x7f\x90\x40\xe1\xa0\x1d\x1d\x2c\x6b\x89\x7b\x4e\xa8\xd6\x7c\x2a\x86\x85\x4c\x87\x76\xb4\x93\x75\xee\x91\x2d\x58\x4a\x9c\x78\x6f\x3b\xed\xde\xba\x53\x85\x4c\x77\x74\x5b\xb4\x20\x5b\xef\xb5\x88\x36\xac\x44\x0e\x33\x09\xf1\x02\x60\x11\xb3\x5d\x7c\x98\x2e\xcd\xd1\xac\x36\x20\xff\x94\x82\xa1\x6b\x9a\x3d\x31\x60\x1c\x43\x4f\xd3\x42\xa6\x47\xfa\x78\xad\x0b\x53\xef\xf5\xd8\x7b\x3d\xbe\x48\xaf\xc7\x19\xd5\xb8\xaf\x8e\xfe\xac\x75\x82\x8c\x0e\xdf\x2d\x53\xf9\x67\xe4\x03\x69\x51\xc4\x6d\x31\x44\xd7\x54\xdb\x88\xab\x4d\xdd\x8d\x06\x4b\xaf\xeb\x6b\x74\x9a\x06\x2c\x84\xa6\x29\x4b\x49\xc1\xd4\x10\xd1\xc2\x12\x72\x91\xae\x58\x9f\x87\xc9\x93\xfb\x32\xd6\xe7\xfe\xc4\x0e\x8d\xf5\x8f\x77\xb4\x16\xc7\x66\xee\x1a\xa5\x7e\x56\xf7\xc6\x6e\xf1\xaf\xc6\x99\xa4\xbf\xde\x7b\x1c\x2c\x70\xff\x6d\x02\x4a\xfd\x69\x6a\xd7\xa0\xc4\xfc\x58\x32\xb5\x20\x72\xce\x54\x25\xea\x47\xc1\xef\xc0\xeb\xb8\x26\x09\xd5\x48\xe9\xbb\x28\xd8\x1d\x14\xcb\xee\x5a\xdc\x6e\xb6\x72\xd2\x84\x43\x73\x98\x7a\xdc\x25\xc2\x68\xa5\xe9\x61\xc5\xbd\x44\x75\x1f\xd1\x7a\x2e\xbb\x08\xbc\x9d\xc5\xdd\x95\x1b\xff\x42\x4d\x12\x64\x37\xb3\x04\xd9\xc9\x34\x41\x3a\x9b\x27\xc8\x2e\x26\x0a\xb2\xa3\x99\x82\x74\x37\x55\x90\xe6\x76\x43\x34\x9b\x76\xc1\xb3\xfb\xb6\x5a\x90\x5d\x95\x74\xb2\xa3\xf5\x62\x69\x79\x01\xfd\xd4\x63\x99\x32\x00\x87\x6b\xd6\x8c\xa7\x02\x50\x77\x4b\xc6\x12\x78\x9c\x09\x80\x83\x1a\xff\x99\xd8\x35\x1e\xdd\xc8\x40\x76\x36\x34\x90\xdd\x8c\x0d\x64\x37\x2c\x00\xd6\xf4\x16\xb4\xfc\x87\x30\x37\x1c\x01\x49\x7b\x4e\x0b\x8b\x00\xff\xb2\x14\x1c\xf6\xe0\x3f\xa4\xa0\x5c\x69\x2b\x63\x39\xab\x50\xfc\x9b\xd3\x74\xe3\x61\xec\x08\x5c\x13\x4b\x6a\xe7\x34\xb3\x3c\x03\x3d\x3c\x9c\xce\x61\x47\x6f\xb2\xd4\x01\xb9\x9f\x59\x4d\xce\x52\x1e\xd4\x44\xb8\x26\x07\x77\x6c\x71\x30\x58\x42\x9a\x83\x2b\x71\x80\xbc\x65\x09\x4d\x02\x23\x82\xa4\x52\x07\xf0\xdb\xc1\x3e\xb9\x70\x47\x86\xd3\xcd\x8c\xb1\xee\xa3\x9d\x92\x85\x40\x3e\x97\xfd\x0a\x7d\xc8\x05\xf0\x9a\xc5\x7f\x41\x57\x0c\x02\x9c\x32\x22\xe6\x10\x7c\x4a\x00\x9f\xe0\x7d\xea\x95\xc8\x52\x44\x59\xdb\xa2\xc1\x90\xc9\x2c\x3b\x36\xb9\x4d\x96\x02\x32\x83\x69\xdb\xc2\x21\x5c\xd4\x19\xda\x8e\xd0\x71\xa4\xe2\x56\x22\x6d\xba\x92\x54\x3d\x40\x76\xcb\x19\x15\x9a\x1c\x78\x9b\x4d\x9c\x0f\xe7\x60\x54\xc5\xbf\x85\x11\x8f\xfe\xf5\x9f\xe3\x5a\xcc\x5b\x35\x60\x2f\xf1\xf6\x12\x6f\x2f\xf1\xf6\x12\x6f\x78\x7a\x89\xf7\xb1\x00\xd4\x4b\xbc\xbd\xc4\xdb\x4b\xbc\xbd\xc4\x8b\x4f\x25\x82\xed\x20\xea\xc6\xf2\x67\x48\xfb\x49\x21\xf7\x32\x4f\x2a\xcf\x22\xdf\x0a\xff\xb5\x5f\xb9\x37\x96\x69\x57\x4b\xbd\xb1\x64\xbc\x24\xdf\x8f\xb6\x88\xb8\x41\x08\x5e\xea\xb9\x59\xfa\x7d\x7e\x0f\xa9\x8e\x78\x10\x19\xd1\x77\x4a\xfd\xe8\xae\x6d\x5d\x91\xaa\x31\xab\xee\x74\x53\x72\xe4\x6f\x15\x8e\x5d\xa5\x86\xfa\x8f\xc2\xf0\x61\xd5\x22\xdc\x33\xc0\xd5\x58\x2d\xb2\xa5\x66\x8e\x5f\x4e\xe4\x5c\xed\x9d\x25\x0d\x4c\xd5\xe6\xc0\xab\x74\x75\x54\x13\x55\x0a\x61\x47\x0d\xde\x00\x8e\x96\x60\x52\x3c\x87\x65\x28\xd8\xc0\x7c\x30\x57\x7f\x80\x50\x74\x57\x87\x59\x6d\xa9\x70\x8e\xf6\x52\xf8\xb2\x1a\x22\x4a\x84\xe9\x10\x10\x56\xc4\xc3\xd7\x47\xe4\x12\x70\x2e\x1e\xd8\x15\x7d\x80\xa2\x1c\x6d\x49\xcd\x63\x07\x1d\xdd\x77\x0e\x3a\x6a\xdc\x49\xf5\x31\x47\x3f\xd1\x98\x23\xf8\x11\x8f\xc9\xde\x83\x8f\x30\x97\xa5\x81\x73\x6c\x41\x15\xb2\x58\xfa\x8b\x77\xfc\x54\x86\xd2\xe0\xc4\x79\x46\xd4\xf1\xd0\x67\x9b\x6b\xe0\x23\x8c\x07\x1e\x58\x1a\x0e\xa6\xf3\x3e\xa0\x59\xe6\x22\x79\xbc\xe8\x88\x2e\x16\xfc\x39\x6e\xce\x2f\x7c\xa1\x34\xaf\x5d\x00\xf1\x38\xb2\x34\x2e\xb3\x9b\x68\xa9\xd5\x06\xe2\x88\x4a\xca\x9c\x79\xf6\x39\xe5\x73\x26\x2a\x0a\x79\xa4\x8f\x8f\x3d\x1f\xde\x2b\xe5\x7e\x14\xca\xfb\xc7\x88\x42\xfe\xa9\x0d\xed\x85\x05\x05\xea\x5b\x81\xaf\xa2\xbd\x4f\xed\x22\xd0\xf6\x8e\xba\xbd\x3e\xdf\xf1\x6e\xfa\x89\xee\xa5\x5f\x76\xdc\xd6\x33\x5a\xe5\x9e\xd2\x1b\xfe\x45\x5b\xe2\x7a\x77\xf8\x56\xcf\xd3\x59\xdb\x9e\xc7\x2b\xfe\x85\x5b\xd8\x9e\xc3\x2b\xbe\xb7\xaa\xad\xdd\x88\x97\xe0\xac\x5e\x7f\x3a\x5b\xd1\x7a\x0b\xda\x4e\x1c\xb3\x03\xa3\x78\x88\xe5\xac\xc3\xee\xef\x70\x47\xdc\xdf\x0f\x3f\xfe\xfd\x70\x2f\x79\x6e\x04\x4c\x2f\x79\xf6\x92\x67\xbb\xa7\x97\x3c\x7b\xc9\xb3\x97\x3c\x7b\xc9\xb3\x97\x3c\x5f\xac\xe4\xd9\x35\x27\x54\x7f\x4f\xbb\xf3\x3d\x6d\x17\x2a\xd0\xfa\xec\x77\xd8\xf3\x4e\xf7\xb2\xfd\x9d\xec\x4b\xb8\x93\x6d\x15\x4c\x2d\x0c\x7f\x48\x40\x75\xbc\x3f\xeb\xa2\xaa\xe9\x5c\xf2\x94\x14\xa5\x71\xb1\xab\x7d\x64\xf5\x2e\x91\xd5\x35\x48\xf7\xe1\xd5\xad\xc2\xab\xd7\xc1\xac\x8f\xb1\xee\x63\xac\x6b\x4f\x1f\x63\xdd\xc7\x58\xf7\x31\xd6\x7d\xc4\xc9\x2e\x0b\x7e\xe1\xd6\x46\xd2\x47\x9c\xd4\x9e\x3e\xe2\x64\xe3\xf2\x5e\xb8\x55\xf2\x41\x00\xea\x23\x4e\xfa\x88\x93\x3e\xe2\xa4\x8f\x38\xc1\xa7\x8f\xb1\x7e\xb1\x77\xe8\xa4\x97\x78\x7b\x89\xb7\x97\x78\x1b\x4f\x2f\xf1\x36\x9f\x5e\xe2\xdd\xf2\xf4\x12\x6f\x2f\xf1\xf6\x12\x6f\x2f\xf1\xe2\xd3\xc7\x58\xf7\x31\xd6\xa4\x8f\xb1\xfe\x5c\xef\xf3\x3b\xee\x74\x1f\x63\xfd\xa8\x31\xd6\xb5\xbb\xe5\xe7\x0b\xb4\xee\x3e\x8d\x3e\xda\xba\x8f\xb6\xee\xa3\xad\xd7\xed\x68\x1f\x6d\xdd\x47\x5b\xf7\x31\x2f\x7d\xcc\xcb\x8a\xa7\x8f\x79\xe9\x63\x5e\x56\x3c\x7d\xcc\x4b\x1f\xf3\xb2\xf6\xe9\x6d\x69\x3f\xb5\x98\x97\x3e\xda\xfa\x25\xdd\x14\xf7\x92\xe7\x46\xc0\xf4\x92\x67\x2f\x79\xb6\x7b\x7a\xc9\xb3\x97\x3c\x7b\xc9\xb3\x97\x3c\x7b\xc9\xf3\xc5\x4a\x9e\x7d\xb4\x75\x1f\x6d\xbd\xea\xe9\x6f\x67\x5f\xc2\xed\xec\xd6\xdd\x0d\x26\xf6\x56\x71\xd6\x87\x1f\x7d\xf3\x58\x62\xf1\xf1\xaa\x2a\xfa\x11\x65\xd5\xa0\xe1\x39\xea\xc8\xd4\x88\x5c\xe5\x79\x69\xe8\x38\x7b\x68\x39\xf0\x9c\x0a\x3a\x65\x43\xf7\xf1\x61\xf8\xf8\x30\x7c\xeb\x21\x15\xc2\xdb\x08\xb7\x19\xcf\xb9\xd9\x78\xc8\xea\xc0\x7b\x0b\xed\xdd\xcb\xb1\xd3\x1f\x72\xfa\x89\xe7\x65\x4e\x68\x2e\x4b\x64\x50\xcb\xe0\xf4\xdb\xbd\x17\x80\xad\x00\x94\x5e\x0b\xa9\x96\xd0\x22\x3b\x31\x9e\x82\x1a\xc3\x94\x38\x25\xff\xef\xe8\xaf\xbf\xfe\xf7\xf0\xf8\xcf\x47\x47\xdf\xbf\x1a\xfe\xef\x1f\x7e\x7d\xf4\xd7\x11\xfc\xe3\x57\xc7\x7f\x3e\xfe\xb7\xff\xe3\xd7\xc7\xc7\x47\x47\xdf\x7f\xfd\xee\xab\xdb\xeb\xcb\x1f\xf8\xf1\xbf\xbf\x17\x65\x7e\x87\x7f\xfd\xfb\xe8\x7b\x76\xf9\x43\xcb\x41\x8e\x8f\xff\xfc\xcb\x8d\xd3\xa2\x62\xf1\x61\xd2\xe2\x1a\xad\x83\x77\xc0\xb0\x3d\x99\xfd\x34\xac\x76\x74\xc8\x85\x19\x4a\x35\xc4\x6e\xa7\x50\xb6\x7f\xa3\x67\x01\xd3\x5d\xf0\xf1\xa3\xeb\xd1\xc4\x48\x2e\xb6\x62\xa4\x0a\x51\xbb\x57\x13\x12\xc6\xe1\x9a\xc8\x9c\x1b\x4b\xcb\x26\x56\x13\xab\x8e\xfd\x80\x70\x63\x09\x2c\x2d\x33\x03\x09\x05\xdc\x59\x80\x68\x74\x0c\xe0\x67\x9f\x8a\x8c\x27\xdc\x64\x8b\x8a\x66\x0f\x30\xd5\xc2\x3d\x47\xdf\x00\x2a\x08\xcf\x0b\x14\xe5\x00\xa7\x87\x9e\x66\x03\x61\xee\xcf\x47\x7f\x3e\x56\x9f\x0f\xbd\xc5\x3c\x5a\x3b\x17\x95\x04\x11\x1b\x1b\x82\x7d\xc1\x62\xb6\x4f\x8b\x01\x72\x0c\xe2\x90\x3d\x0b\xa0\x2e\x5a\xb9\xe1\x23\xb3\xb8\x4c\x6f\x98\xd1\x4e\x72\x80\x1e\x56\xf6\x5f\x32\x7e\x82\x63\xcd\x98\x55\xc2\x27\x9d\x4c\xea\x2d\x52\x56\x64\x72\x61\x91\x7e\x44\xae\x0c\x2a\x9f\x20\x61\x04\x77\x15\xc3\xf2\x22\xa3\x86\x1d\x6a\x9c\xed\x5a\x3b\xd4\x9e\x38\x5f\x17\x2b\xe4\xf3\xda\x1e\x1f\xc7\x23\xe6\x45\x5a\x17\x1f\xc1\x55\x64\xbb\xfd\xb0\xa5\xd5\xb0\xbd\xad\xb0\x95\x85\xf0\xb1\xed\x82\x1d\x94\xa2\xf6\x36\xc0\x97\x6f\xf9\xeb\xb0\xec\xb6\x56\xbe\xde\xb6\xb7\x09\xd4\xcf\xa1\xcb\xb7\xb4\xd9\xf5\x96\xba\x0e\xfc\xe5\x11\x84\xbf\xad\x7b\x69\x64\xc6\x50\x72\x6d\xa7\xbb\xdf\x56\xed\x43\x76\x26\xb4\x41\x45\x23\x6d\x96\x1b\x36\xa1\xeb\x16\x24\x5d\x4a\xca\x04\x62\x8b\x3d\x5b\xd5\xbc\x00\xb5\x8c\xa1\x90\x96\xc9\x48\x3f\x2f\xbb\x71\x62\x41\xec\x9e\x19\x97\x97\x2b\x4a\x54\x65\x14\x78\xe2\xfe\x31\x60\xdb\x80\x81\xfc\xf4\x27\x52\x6a\x6f\x18\x0a\x56\xa2\x80\x21\x7f\xf4\xff\xfa\xd3\xfa\xcd\x6d\xb5\xb5\xed\x18\x1b\x4e\xa9\x83\x80\x71\x09\x1d\x08\x17\x29\x4f\x82\x30\x80\x10\xc0\xb1\x2c\x7c\x60\x59\xde\x4a\x84\xa6\x45\x14\x0b\xc1\x7b\x38\x6a\xac\x9d\x07\x73\xa4\x57\x39\x93\x42\x75\x32\x18\x79\x2f\x9d\x3b\x3a\x1b\x90\x6b\xc8\x68\x55\xbd\x81\x93\xf4\x5e\xa2\x63\x3a\x6b\x23\x87\x6c\xe5\x22\x5b\x19\x7d\x0d\x20\x5f\x57\x4c\x1e\x57\x56\x63\xf2\x15\x06\xd7\x6c\xc3\x9b\x20\x73\xc7\x16\x15\xb3\x71\x22\x04\x90\xfc\x41\x85\x25\x9e\x15\x20\xef\xf8\x6f\x6f\xca\xca\xc7\x5c\xe0\xc7\x70\x68\xbf\x15\x30\xba\x07\xa8\x95\xec\xb2\x0c\x3f\xb3\x0f\x70\xb5\x93\x33\x6a\x30\xfb\xd0\x41\xc6\x08\x54\x72\xb5\x74\x11\x89\x14\x97\x3f\x96\x34\x1b\x91\x8b\x48\x99\x77\xaf\x5c\xa3\x25\xaa\x7e\xcf\xb3\x34\xa1\x0a\x8d\x02\x78\x46\x89\x96\xb8\x7b\xe8\x1f\x9d\x50\x11\x4e\x7b\xb5\x47\x98\xb1\x8d\x14\x54\x19\x9e\x94\x19\x55\xc4\x9e\x85\xa9\x54\x8b\xbd\x40\xb4\x42\x9a\x1b\x96\x48\x91\x76\x4a\x2b\xd7\xec\x1b\xc3\x18\x28\x2b\x53\xdc\x39\x7e\xf3\x9c\x35\x91\xf4\xc8\x25\xdc\x73\xf8\x25\x27\xfe\x54\x87\x23\x56\xb3\x7c\x54\xb7\x14\x5c\x13\x8e\x91\x22\xc7\x11\x79\x0c\xa7\x62\x44\xbe\x5c\x78\x33\x0b\x98\x5c\x9c\xbd\x58\x33\x33\xf0\x49\xfe\x1c\xca\x3a\x60\x57\x07\x6a\x22\x15\x9b\x33\x45\x8e\x52\x09\x7d\x20\x20\xe2\x78\x44\xfe\x3f\xa6\x24\xde\x69\xb0\x29\xfa\xf1\x3b\x14\x0f\x8a\x2b\xa4\x55\x04\xbb\xf9\x2b\x72\x84\x71\x14\x3c\xcf\x59\xca\xa9\x61\xd9\xe2\x18\xf5\x58\x1f\x89\xd1\x66\xeb\xda\x18\x0d\xa2\x70\x9b\xdf\xfd\x76\x43\x4b\x98\x6c\x87\x9d\xfd\x16\x4c\xfc\x35\x52\x83\x56\xff\xc6\x16\x06\x1e\x24\x37\x88\x9b\x91\x78\x19\x5d\x7d\x78\x32\x13\x36\xf8\x1f\x16\x0f\x28\x51\x6c\x0a\x58\x8e\x98\xfb\x40\x1c\x9f\xcb\xac\xcc\xd9\x3b\x59\x8a\xf5\x26\xc1\xda\xc2\xdf\x3a\x25\xfc\xdb\xa8\x23\xe4\x02\x65\xc6\xcb\x6f\x95\x15\xff\x49\xc4\x84\x68\x26\x91\x89\x92\x12\xb0\x4b\x02\x3b\xb7\xe4\x01\x5b\xc1\x3d\x0c\x17\xb1\xcd\xf1\x81\x9c\xbd\x8d\x96\x3c\xc4\xb9\x5c\x53\x33\xdb\xd8\x4a\xd0\x7c\xbd\xe1\xb6\x9d\x08\x11\x3e\xd4\x01\x97\x6d\x73\x0f\x98\xda\xfe\x11\x6a\x1c\x39\x00\xfc\x44\x08\x56\x08\x0a\xdf\x62\xe9\x88\x90\x77\x16\x33\xf1\x46\x0e\xba\x92\xc3\xd3\xc3\xbd\x10\x5f\x5c\x8e\x92\x05\x9d\xd2\x6d\x91\x6e\x4d\x65\xa4\xd1\x95\xa4\xcc\x30\x95\x43\x88\xd2\x4c\xde\xe3\xef\xc8\xb6\x0a\xd7\x8a\xb9\x88\x2e\xc8\x52\x2a\x35\x70\xa5\x08\x18\xfe\xea\x17\xd2\xfa\xde\xd3\x05\xa1\x4a\x96\x22\x75\x52\x53\x20\xa0\xef\x1a\x1f\x7e\x2f\x05\x50\x8a\x52\x5b\x58\xdd\xd6\xa8\xf4\x98\x19\x6a\x8f\xcd\xeb\xd1\xeb\x2d\x91\x86\x2d\x01\x66\x51\xa8\x53\xde\x53\xae\x9b\x96\xc2\xf7\x34\x67\xf1\x99\xd9\xcb\xbc\x14\xa3\xe9\x07\x91\x75\x91\xe5\xde\x21\x7a\x41\xd7\x21\x28\x61\x7c\x02\xb6\xdb\x01\xbe\xba\x57\xdc\xb0\x88\x3c\x1e\x4d\x68\xa6\x21\x1d\x70\x29\x82\x08\x7b\x5c\x17\x41\xa0\x49\x9b\x05\x8d\xa5\xcc\x18\x15\x1b\x5a\xea\x72\xfc\xc0\x73\xe6\x0e\x14\xa0\x5c\x75\xcc\x02\xc2\x1d\xea\x0d\x47\x2e\x5e\xd4\xc1\x01\x39\xc2\x96\x56\x62\x93\xd2\xac\x4d\x36\x1d\xaf\x70\xeb\x96\xb9\x05\x5a\xcd\xba\x8b\x4a\xf2\xa9\xa0\x02\xf2\xe0\xee\x71\xb5\x5f\xb2\x19\x9d\x33\x4d\x34\xcf\x79\x46\x55\x06\x51\x99\x37\x38\x3f\x48\x15\xcd\xc4\x9c\x2b\x29\xc0\x24\x30\xa7\x8a\xd3\x71\x66\xd5\xf4\x09\x53\x4c\x24\x4c\x93\x5f\x1e\x7d\x7b\xf6\xf1\x6f\xef\xcf\xde\x5d\x1e\xc3\x89\x67\x7e\x96\x95\xf6\x17\xcf\x24\x1a\x6e\x2b\xa8\xfd\x3c\x2c\x9c\x80\x46\xf8\x79\x61\x08\xa8\x8f\x1b\xfd\x94\x64\xa5\xe6\xf3\x87\x9e\x26\xfc\xf8\x2e\xac\xba\xc9\xa5\x0b\x99\xde\x14\x2c\x79\x4a\x1e\x5d\xd7\x30\x2c\xa9\x4a\xfd\xa6\x03\x4f\x46\x65\x9f\x62\xda\xef\x31\x23\x34\x49\x98\xd6\x78\xc5\x61\x75\xfb\x8a\x16\x57\x6b\x78\x12\xf6\xbd\x07\xc6\x4c\xef\xf5\x65\x46\xb5\xe1\xc9\x97\x99\x4c\xee\x6e\x8c\x54\x5d\x08\xf5\xe1\xaa\xfe\x35\x78\x0a\x72\xf6\xdd\x0d\xb9\xe0\xfa\x2e\x5c\xc0\x86\x4b\xd3\xd8\x5c\x42\xc9\x5d\x39\x66\x19\x33\x87\x87\x1a\xb9\x5c\x4e\x93\x19\x17\xcc\x33\x38\x61\x4f\x87\xd4\x95\x83\x94\x85\x72\xd7\x3b\x53\x6d\xa4\xa2\x53\x76\xe2\xf0\xf5\x17\xf4\x5e\x33\x9c\xfe\xd8\x4e\xdf\xfe\xcc\x36\xdd\x96\x3e\xca\x3d\x05\x4e\xe6\xea\x62\x4f\x77\x10\x13\x7d\x6b\xe7\xd8\xcd\xb8\x7d\x88\xbd\xbc\xea\x30\xe1\x19\x73\xb1\xe7\x76\xc1\xde\xd9\xc7\x9d\x0a\xd8\xbf\x85\x2c\xc9\x3d\x45\x1d\x19\x28\xe2\x88\xdc\xf2\xe2\x94\x5c\x0a\x5d\x2a\x56\x59\x37\x9a\x43\x71\x4d\x74\x59\x14\x52\x85\x4b\x42\x27\xd5\xa0\x02\x62\xe9\x9e\xd3\xb5\xc8\xe5\x27\x9a\x17\x19\xd3\xa7\xe4\x80\x7d\x32\xbf\x3d\x18\x90\x83\x4f\x13\x6d\xff\x27\xcc\x44\x1f\x8c\xc8\x55\x1e\x6e\xdd\xb9\x70\x49\xcc\xf1\x62\x13\x3b\x58\xd6\x1c\x71\xdd\x47\x41\x17\x72\xfb\xe1\xe2\xc3\x29\xc8\x6e\xa9\x24\xf7\x56\x6c\x83\xc0\x7c\xc2\x94\x92\x4a\x7b\x9a\x10\x81\x01\x78\x4d\x22\xf3\x42\xc9\x9c\x47\x66\x3e\x40\xf7\xcd\xd8\x47\xba\xdd\x73\x80\xf1\x61\xbb\x80\xba\x8c\x0d\xa1\xa3\x47\x88\xe8\x85\x68\x83\x0a\x57\x13\xef\x4c\x81\x5a\xa4\x53\xeb\x61\x38\xd7\xc8\x6e\xbe\x1b\xc5\x12\xb2\x78\xbb\xdf\x48\xe5\x7f\x3a\x49\xd9\xfc\x44\xa7\xf4\xf5\x00\x3e\x83\x7b\xb9\x68\xcc\x89\x6a\x72\xf0\xfa\x60\x44\x6e\x3c\x23\x1e\xc4\x73\xac\xda\x4d\xa4\x0a\x03\x82\x9d\xfd\xd5\x01\x39\x92\x0a\x46\x4e\xa8\x20\x19\xa3\x73\x67\x5b\xc6\xe3\xb6\x40\x75\xf7\x78\xd4\x76\x5b\xf6\x9b\x6f\x03\x9f\x76\x42\xea\xf2\x26\xfa\x7e\xde\x04\xa0\x4a\x86\x66\x8f\x89\x44\x2a\xcc\xc2\xd0\x96\x03\xc3\xd1\xe3\xa2\xa6\x42\x3f\x03\x81\x25\x1d\x84\x5d\x12\x44\x8f\xab\x8b\xae\xd0\xf1\xfd\x40\x07\x12\xfc\xc7\x92\x91\xab\x0b\x4f\xe8\x0a\xa6\x34\xd7\xc6\x1e\xe3\xb4\xc6\xba\x38\xf2\xb3\xa3\xb3\x9c\xfe\x53\x0a\x72\xf9\xe5\x8d\x9b\xc0\xf1\xb3\x82\x6a\x2b\x35\xa0\xff\x2c\x15\xb3\x5c\xb8\x03\x73\x0f\x7d\x9a\x0c\xdd\xbe\x27\x17\xd4\x50\xe4\xeb\xce\xd3\x4a\x54\xa4\xdc\xb2\xec\x31\x17\xa9\xfb\x29\x62\xd8\x4f\xcd\x5b\xed\xee\xbd\xdf\x24\x26\xc5\x0d\xbf\xf9\x78\xb5\x27\x1e\x9c\x00\x31\x9f\xbe\x93\x69\x67\x46\x1c\x75\xf5\xc4\xf7\x2f\x16\xa6\xe7\xf8\x9e\xe4\x76\x4c\xf2\x1e\xea\xfa\x7c\x64\x34\x25\xf6\xfc\xba\x7f\x7e\x67\x75\xcf\xd6\xb4\xaa\x15\x0b\xf1\x00\xec\xb8\x0c\xdf\xcd\x2f\xc1\x6b\xef\xc0\x0b\x2c\xe6\xc0\xb1\x72\xbc\x64\x9c\xc9\x31\x71\xc7\x61\xdf\x73\xff\xe6\xe3\xd5\x0e\x53\xff\xe6\xe3\x95\x9f\xb9\xfd\xa7\x9c\x3c\xdd\xa4\x77\x12\xdf\x2a\xe9\xed\x4d\x43\xdc\xaa\x58\xf2\x3b\x67\xaf\xa7\x4b\x22\x59\x7b\x79\x6c\xb4\x2f\x49\x6c\x9f\x10\xbb\xe3\xa2\x45\x5c\x61\xfd\x94\xd9\x3e\x56\xa1\x40\x5f\xb5\xe8\x1e\xf1\x66\x46\x2d\x61\xa9\xb2\x24\xc1\x3e\xdb\x8d\xd7\x96\x2b\xf8\x1d\xb7\x4a\x20\xd0\x36\x72\xc1\xf0\x96\x33\x3d\xf5\xbe\x03\xa1\xc7\xea\x0e\xef\xc0\x53\x33\x75\xf4\x95\xa0\xe3\x66\x1a\x21\xd8\x11\x5a\x95\x44\xf8\x89\xce\x29\xcf\xe8\x98\x67\x50\x11\x8c\x59\xed\x3e\xf6\x46\xd5\x30\xe5\xbd\x9e\xfa\x1d\x45\x8e\x20\x4e\x2c\x19\xb7\xc8\x91\xfd\xed\x04\x8c\x63\xc7\x23\xa0\x56\xd0\x10\x22\x19\x1a\x42\xc9\xc7\x6d\x42\xc9\xde\xe4\x07\xd8\x01\x7b\x62\xba\x72\x45\xdb\x67\x25\x57\x84\x1f\x6e\x98\x9a\xf3\x84\xbd\x68\xc6\xa8\x59\xa2\x98\x69\xc5\x1a\x01\xbf\xb6\xb6\x6c\xcf\x1c\x1f\x8a\x5c\xe9\xe7\x81\x5c\x04\x5c\x77\x3d\x94\x3b\x2e\xb6\xea\xe8\xf9\x10\x28\x49\xe0\x71\x06\x3f\x35\x5c\x33\x11\xfb\x6e\x1c\xad\x39\x73\xb4\x06\xfa\x5b\x9c\x6b\x53\xdb\xa9\x03\x79\x08\x18\xd1\x75\x55\xbe\x9f\x5f\x14\x92\x40\x78\x4d\x5a\xe0\x62\xeb\x49\x26\xac\x98\x4d\xba\x5c\x89\xdb\x0e\x6f\x6e\xea\x96\xc0\x73\x56\xcc\xc8\x9b\x9b\x15\xc7\x18\x4b\x09\xda\x59\x6b\xb4\x0f\x1e\x6a\x92\xf1\x09\x33\x7c\xcb\x12\x1e\xe1\x20\xe7\x52\x70\x23\x95\xde\xd3\xe1\xf4\xc3\x75\x65\xa8\xbe\x9f\xdd\x59\x5f\x15\xed\x94\xbc\x8b\xde\x52\x92\xc8\x2c\x63\x89\x71\x71\x8d\x00\xde\xd0\x6d\x85\xf2\xc4\x9c\x3d\x60\x74\xf7\x07\x50\x9f\x9c\xa2\x74\x82\x9b\x7b\xf2\xf1\xf2\xec\xe2\xdd\xe5\x28\x4f\x7f\x31\x93\xf7\x43\x23\x87\xa5\x66\x43\x6e\xda\xf2\xc1\xe7\x8b\x44\x2c\xb6\xde\xcf\x90\x15\x06\x19\x33\xb3\x40\xfc\x50\xa0\x23\xde\x29\xf9\x46\xa3\xd7\x02\xd8\x8e\xfc\x9d\x94\x94\x66\x40\x14\x85\xab\x40\x33\xa3\xce\xf4\x54\x66\x19\x42\xdb\x28\xc6\x06\xb1\x2d\x66\x63\x68\x48\xe7\x85\x3d\xd8\x50\x51\x5b\xe0\xe3\xca\x10\x4f\x8f\x70\x5d\x38\xc6\x76\x99\x64\x19\x8a\x55\xcf\x3a\x1c\x6f\x6a\xef\xd1\x70\x66\x66\x16\xaa\x77\x6c\x41\xc0\x11\x78\x22\x95\xc5\x27\x55\xc7\x0d\x66\x12\x58\xfa\x49\xa9\x99\x1a\x39\xb6\xf3\xe4\x60\x6b\xc7\x90\x60\x72\x1f\xd9\xd6\xc8\x9e\xd5\x40\xfb\xc8\x26\xab\x60\xe6\x5e\x87\x0b\x3b\x2f\xaf\xd1\xd2\xcc\x98\x30\x56\xec\xb7\xb4\xcc\x41\x66\x25\x10\x9d\x1f\xf6\x93\x43\xed\x51\xd2\xf7\x6c\xbf\xc5\x5f\x0d\xe4\x58\xf9\x77\xc0\x34\x9d\xcd\x65\x72\x6e\xa5\x6a\x76\x7f\x72\x2f\xd5\x1d\x17\xd3\xe1\x3d\x37\xb3\x21\xae\x53\x9f\x40\x78\xf4\xc9\x2f\x30\xde\x1e\x2d\xf2\x67\x69\xea\x9c\x22\x4a\xcd\x26\x65\xe6\x6a\xa2\x8e\x08\x2d\xf8\xb7\x4c\x69\x2e\xc5\x00\x74\xc7\x01\x29\x79\xfa\xe7\xed\x90\x25\xdd\x70\xd2\x9e\x9a\xae\xe8\x68\xfb\x40\x20\x62\x4c\xe6\x43\x2c\x97\xa2\xa9\x04\x87\x0d\x05\x5b\x51\x43\x34\x9a\xe6\x5c\xbc\xc0\xd3\x99\x70\x91\x6e\x83\x43\xc3\x00\x06\x3d\xea\xa2\x98\x7b\xe7\x0c\xfa\xe1\xde\x90\x7a\x4d\x0a\x92\x39\xfb\x1b\xc4\xfa\xfd\x61\xab\xc3\x97\x2f\xf4\x8f\xd9\x10\xbf\x32\x2c\xd2\x0a\x2a\xfd\x65\xe0\xf2\x0d\xde\x7e\x4d\x4a\x4f\x70\xc5\xb7\xa7\xdd\x26\x4f\x2c\x0d\x3d\xae\x9e\xfb\x24\x80\xea\x22\xf3\x3c\x94\x7b\x57\x34\x13\xd2\xae\x6b\x1f\x7c\x06\xcc\x19\xcf\xa8\xd7\x97\x21\x1d\x3b\x55\x34\x67\x86\x29\x74\x81\x73\x4e\x75\xc2\x45\x27\x7c\x28\x98\xb8\x31\x34\xb9\x6b\x6d\x4d\xef\x39\xee\xb3\x73\xdc\x07\x5f\x05\x7a\x44\xe0\xa9\x15\xef\xdc\x35\x73\xe5\x0a\x84\x07\xe1\x85\x90\x18\x0c\xdd\x7e\x47\x8b\x2e\x56\x0e\xdf\xa7\xc1\x5d\xc3\x6b\x67\xd8\x00\x4f\xb7\x42\x16\x65\x86\x5e\xf6\xdc\x7b\xc1\xed\x87\x1b\xb6\x3f\x03\x8e\x04\xee\x72\x8f\x16\x75\xad\x53\x87\xdc\xbe\x19\x73\x53\x9d\x7b\xcd\x0c\x29\x98\xca\xb9\x0b\xeb\x96\x82\x24\x2e\x2c\x00\xf8\x9a\xe5\x61\x6e\xb8\x88\xe7\x09\x22\x13\x43\x5d\xcc\x0c\x19\x33\x73\xcf\x98\x20\xaf\x5e\xbd\x7a\x05\x72\xc9\xab\xdf\xff\xfe\xf7\x04\xf2\x48\xa4\x2c\xe1\xf9\x72\x43\x68\xf5\xbf\x5e\xbf\x1e\x91\xff\x39\x7b\xf7\x16\xbc\xca\x0a\xa3\xc9\x58\x9a\x99\x1b\xd9\x36\xa8\x75\xd6\x03\xf2\x7f\x6e\x3e\xbc\xf7\xe2\x84\x6e\xfc\x0a\x2a\x48\x58\x5e\xdd\x45\xf0\xd5\xef\x7e\xfb\xdb\x11\xb9\xe0\x0a\xe2\x89\x39\x44\x40\x04\x27\xc8\xc2\x3b\x06\x42\x7a\x9e\x66\x04\xbf\xe3\x20\xce\x49\x38\x87\x6a\x26\x63\x3c\x10\x52\x4c\x32\x9e\x18\xcc\x23\x84\x47\x1f\x01\xed\xb2\x07\x51\x17\xee\xe5\xa4\x08\x98\xdc\x80\x64\xfc\x8e\x91\x89\xfe\x4a\xc9\xb2\xa8\xc2\x1c\x15\xd3\x56\x96\x4d\xa8\x80\xa8\x12\x18\xac\xda\x2b\xcd\xcc\xb3\x3a\x61\xb4\x34\x04\xd5\x70\x10\xfa\x34\x04\x94\x01\x16\xd2\xb8\x63\x8b\x21\xe2\x43\x41\x79\x70\x1c\x84\x3b\x75\xf4\xc2\xae\x13\xef\x84\xa5\xe4\x3c\x9c\x52\x1f\xbb\x52\x28\xf9\x0f\xdc\x2a\xee\x2b\x99\x78\x09\x59\x3b\x99\xcc\x05\x9d\x8a\xc8\xe6\xea\xa3\xf2\x2d\x2f\x74\x11\xff\x51\xfc\xd4\xd5\x24\x0e\xb4\x33\xae\x30\x08\x4b\x21\x16\x6c\xd3\x97\xab\x54\x55\x16\x9b\x34\xee\x6b\x29\x96\x7a\xbb\x2a\x2c\x8e\xfc\xc0\x07\xa9\x0f\x61\xab\xc6\x40\x57\x5c\x17\x00\xe4\xda\x7a\x28\x05\x40\xd4\xbc\x7c\x34\x33\xa5\x03\x0d\x78\x5e\xd9\x6f\x33\xad\x5d\x1c\x51\x4e\xd5\x9d\x55\x12\x1c\x15\x18\x81\xd7\x73\x55\x9f\x24\x54\xf9\x00\x8d\xc2\x95\x59\xf1\x51\x03\xf6\x23\x87\xa3\xd1\x21\x1e\x13\xa9\x88\x36\x54\x39\x9c\xb7\xef\x9f\x29\x5e\xba\xee\x95\x4e\x0b\x4c\x44\x07\xf6\x1c\xcc\xe8\x05\xd1\x67\x95\xb7\x33\x75\x90\x6a\x93\xba\xaf\x63\xe2\xbe\x6e\xd9\x5d\xdb\x67\x76\x1d\xc2\x02\x5a\x34\xed\x9a\xcd\xb5\x43\x26\xd7\x75\xd9\x1a\x1c\x8c\xdd\x49\xe8\x96\x3a\xb7\x43\x52\xd2\xbc\x15\xeb\x5b\x31\xd5\xc3\xdc\x71\xbe\x0f\xdd\x38\x9f\x8b\xd7\x83\x0c\x67\x9f\x0f\xab\xbb\x9a\x60\xa4\x4b\x9d\x74\x39\xd2\x10\x8b\x02\x9e\x82\x45\x61\x2f\x2f\x9a\xa3\xc5\x68\xd3\x96\xaf\xe1\xd3\x85\xbb\xe1\xd3\xee\x62\x02\x9f\x1a\xae\xf9\xdb\x09\x5c\xb4\x23\xa5\x48\x2d\x27\x15\xa8\x20\xd2\xb8\x88\x0e\xcf\x88\xbc\x73\xa4\x16\x91\x8c\x8e\xb5\xcc\x4a\x83\x5d\xab\x1f\x63\x3a\x0c\x83\xfa\x2c\x0b\x40\x7c\x43\xb3\x88\x2a\x03\x3f\x42\x52\xd8\x8e\x40\xe3\xd3\x31\x83\x68\x57\x89\xf4\x27\xa2\x94\x75\x4a\x2f\xe3\x48\x4f\x37\x48\xf9\x6e\xc1\xdb\xf7\x7e\xc6\xdc\x95\x56\xc4\xfd\x2d\xc5\xb1\xe7\x08\x44\x0b\xcf\xc8\x5d\x4a\xb5\xbd\x99\x27\x12\xcd\xbb\xe8\x57\x9a\x93\xa3\xf3\x10\x0e\xe2\xaf\xe3\xaf\x84\x61\x6a\x42\x13\x76\x1c\xeb\x5d\xac\x98\xb1\x9c\x29\xbb\x4c\xd7\xce\xc7\x45\xcc\xa8\x48\x33\x14\xc0\x13\xa6\x00\xf7\xd9\x27\xc3\x94\x05\xc9\xf9\xcd\x15\x49\x15\x9f\x33\xa5\xc9\xd1\x97\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\x47\x16\x95\x80\x40\x03\xcd\x58\xc8\x52\x39\x2b\xfa\x44\x2a\x17\x7b\xa5\xac\xba\x84\x03\x53\x4d\x14\x9b\x5a\x69\x56\x55\xa5\x1d\x92\xac\xb4\x2f\xf6\xea\xce\xf6\x10\x07\xc0\xca\x34\xbb\xc9\x57\x6f\xe2\xa4\x6a\x39\xe7\xa9\x67\x95\x98\x0d\x78\xee\xe3\xc7\x0b\xaa\xa3\x50\x9b\xa8\x76\x65\x04\x58\x94\xd1\x81\xa1\x86\x20\xd6\x9a\xb3\x7f\x6c\x14\x96\x90\xdb\x62\x4b\xee\x83\x8e\x90\x12\x32\x65\xd7\xe5\x38\xe3\x7a\x76\xb3\xa3\x09\x71\xd5\x10\xe8\xac\xb0\x74\xeb\xb7\xd6\x92\xa8\x99\xd0\x1c\x58\x9e\x25\xe3\x96\xe9\x72\x2b\x47\x49\x00\xa2\xef\x1d\x23\xa4\x84\xe8\x8f\x8c\xb9\x0c\x06\xf6\xa7\xf7\xd5\x3c\x5c\x50\x1a\xe6\x2c\x49\xd9\x37\xa2\xa8\xbd\x4f\x68\x96\xe9\x66\xc0\xae\xa7\x98\x28\x7b\xf8\x40\x35\xdc\x53\x6e\xb7\xdb\xcf\x9e\x37\xb2\x5f\xae\x5d\x98\x26\xb9\xc4\x30\x1e\x41\xa4\xf0\x8d\x20\xf5\x8a\xef\x10\x05\x32\x42\xb8\x32\xa0\xcc\xb3\xd6\x17\xe9\xcd\xa5\x4f\xe9\xe4\x19\x67\x40\xaf\xa2\xa1\x6b\x69\x49\x03\x29\xf5\x24\x77\x8b\x53\xc7\x5e\xaf\x15\xf0\x9b\x67\xc6\x28\x3e\x2e\x4d\xf7\x7c\x6f\x8d\xee\xc0\xa6\xad\x22\x02\xa7\x78\xe8\x56\x9f\x44\x28\xea\x34\x84\x70\x16\x96\xcf\x7e\xc5\x73\x80\xdd\xe0\xcb\x43\x4d\x52\x99\x94\x21\x2f\x2c\x00\xad\xba\x40\x6b\x5b\x9b\xa5\xd3\xb9\xda\x35\xd1\x7e\x4b\xf4\x4a\xe5\xbd\xb8\xa7\x2a\x3d\xbb\xde\xe2\x7d\x5f\x67\xe7\x55\xaf\x58\x50\xf2\xaf\x89\x7d\x4f\xc7\xb2\xac\x2a\xdd\xfe\x84\xec\xd5\xab\xd4\x74\x23\x2d\x69\x68\x69\x8f\xee\xaa\xe8\xf7\x26\xee\xde\xc4\x5d\x7b\x76\x31\x71\x5f\xa1\x89\x3b\xce\x83\x5b\x3b\xae\x3e\xbd\x02\xcf\xda\xfa\xf6\x3e\xa6\x95\xf4\xa2\x22\x30\x28\x4d\x35\xfd\xf8\x1b\x02\x1c\x1e\x91\x6a\x6f\x23\xa1\xcf\x53\x20\xe0\xd9\xcf\x6f\x51\x7d\x24\x3b\x29\xac\xae\x95\x54\x8d\xcf\x72\x8a\x76\xf4\x03\xc6\xac\xd4\x78\x29\x11\xdd\x6e\x14\x32\x3d\xc5\x44\x96\x54\x08\x89\xdc\x4f\x0f\x5c\x16\xe8\x81\xd3\xbb\x44\x54\xfc\x02\x93\x50\x7b\xd6\xd8\xd1\x7c\xf6\xe8\x05\xcb\x60\x6d\x5b\xd2\x29\xc5\xcf\x2e\x35\xc8\x2a\xd9\x70\xe7\x22\x55\xae\x7f\xa8\xe0\x91\xcc\x58\x4e\xe1\x9f\x6f\xfc\x02\xec\x89\xb6\x22\x99\x61\x18\xf0\x0d\xc5\xdc\xe5\x64\x50\xf3\x49\x39\x98\xbf\x6e\x51\xf7\xa5\x7a\x76\x2a\xc8\x15\x60\xba\xf3\x72\xaf\x6b\x76\x48\x8b\x7d\xc0\x0f\x33\x4c\x51\xd9\xb8\xbb\x02\x9a\x85\xf0\x79\xd4\xa5\xed\x6e\xd6\xdf\xd5\x9c\x3f\x08\x36\xb2\xcf\x80\xad\xf7\xe6\xfc\xa5\xe7\x09\xcd\xf9\x11\xe1\xf6\xc4\x60\x85\x69\x3f\x36\xb7\x79\xfb\xfe\x98\x79\xb1\x72\x54\x65\x5f\xb3\x28\xe7\x2d\xfb\x52\xd5\xaf\x55\x0f\x47\xa3\xc3\x43\x6f\xef\x77\xf8\x59\x9a\xc9\xf0\x0f\x84\x89\x44\xa6\xb8\xa9\x76\x7c\xa5\x0d\x30\xfd\x4a\x4d\x8f\xe7\x92\xfb\x6f\xc5\x57\xb3\x30\x76\xb7\x2d\xe9\x70\x82\x7d\x4a\x80\x37\x0f\x62\x91\x15\x63\x0c\x29\x06\xdc\x02\x43\x56\x21\xc7\x21\xab\xf2\x25\x58\xb9\x07\xd0\xd2\x97\x4d\x21\x47\xf8\x72\x94\x14\xe5\xc0\x35\x18\xe5\x2c\x97\x6a\x31\x08\x8d\xec\x8f\xb5\x5e\xae\x05\xe6\x9e\x4a\x4a\xa5\x98\x80\x02\x26\x2f\x95\xbf\x7a\x10\x3c\x22\x7b\x0d\x50\x6f\x17\xdd\x56\x3d\xf5\x6d\xad\xee\x00\xc0\x24\x55\x95\x94\x9a\x84\xcc\x26\x7a\x50\xdd\x73\xd8\xb7\x4c\xcc\xc9\x9c\x2a\xdd\x16\xe6\x64\x57\x8e\x9a\xf2\x39\xd7\x0f\x28\xfb\x79\x13\xcc\x3e\x90\x76\xb0\x34\x45\x69\x1c\x75\xf2\xb8\xeb\x33\x35\x05\x9c\x6d\x08\x0e\xaf\x0f\x3a\x7c\xfc\x85\x16\x92\xa9\x3f\xad\xca\xca\xd4\x9f\x6e\x45\x66\x56\xf7\xed\xb8\xf5\x0f\x28\xd0\xd4\x7c\xfc\xd6\xee\x7e\x46\x2a\x26\x53\x25\x06\xf3\x82\xd9\x23\x1c\x02\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\x7d\x70\x6a\x18\x98\x47\xca\xd5\x9e\xa2\x11\x3a\x44\x83\xb2\x94\x97\x79\xe7\x58\x50\xe8\x15\x03\xed\x1e\xb2\x81\xb9\x4c\x62\xfe\xba\xd3\x35\xf3\x89\x15\x69\x72\xe7\x2a\x06\x79\xa8\x22\xef\x8f\x82\x5c\x0e\x0e\x1a\x79\xa0\xc1\x3c\x06\x77\x7f\x32\x65\x16\xe4\xbe\x31\x8e\x5d\x33\x65\xb9\x1a\xe9\xe8\x16\x70\xe4\x1a\x42\xd1\xc6\x77\xc0\x06\x9f\x68\x97\x48\xc7\xc8\x36\xfe\x4f\x06\xe5\xc6\x3a\xfb\xc6\xfb\x8e\x21\x1d\xb4\x04\xc9\x3c\xd4\x45\xcb\x64\x12\xdd\x3d\xd7\x38\x14\x6c\xc3\xa5\x47\x7e\x6f\xbb\xb7\x9b\x61\x47\x45\xf9\x02\x8c\x3e\x99\xc6\x7b\x3d\x9e\x40\x6a\x4b\x90\xe2\x01\x98\x61\x03\x6e\xa3\x2a\x81\xa5\xb6\x5f\x82\xcc\xf3\x51\x9b\xea\x43\xf7\x3e\xc3\xa6\x89\x0a\xb9\xd5\x75\x0f\xfb\xcb\x4d\x58\x59\xa5\xb7\x41\x08\x84\x17\xd4\x75\x09\x62\xa2\xfb\x8a\x13\x97\xe4\x04\xee\xae\xaa\xb2\x68\x21\xb9\xe3\x12\x9a\x09\x9e\xd5\xf1\xcc\xe7\xb2\x0b\x0b\x2f\x85\x73\x34\x58\x42\x9a\xd5\x38\x53\x6a\xa6\x86\xd3\x92\xa7\xbb\x60\xcb\x0b\x66\x80\xad\xd9\x5e\x77\x66\xd7\x91\xc5\x3d\x80\xb1\x05\x47\x8c\x0e\xac\xe1\xa0\xf2\xde\xa8\xf1\x86\x38\x2d\x5e\xdd\x93\x83\x7a\x67\x81\x70\xe4\xfc\x95\xd0\x6d\x50\x6d\x1d\xcf\x48\x16\x89\x0b\xd6\xe5\xb5\x74\x97\x38\x2c\x62\x1e\x38\xb6\x0e\xed\x7f\xbc\x0a\xec\xed\xf9\x63\x36\x91\x55\x85\x14\xd4\x88\x9c\x3b\x6e\xca\x32\x66\xc0\xbb\x96\x85\x4c\xa5\x78\x25\x9c\xcb\xb9\x45\xe6\xbf\x0a\xf2\x8d\xcf\xd9\xcf\x27\xa7\x84\x1e\xd7\x42\x20\x5c\xd5\x19\xc1\x58\x8a\x3e\xba\x59\xf5\x1d\x55\x0a\x3d\x20\xe3\x63\xef\x8f\x02\x27\x4e\x58\xb1\x30\xf3\x12\x2f\xea\xd5\x8a\x59\x00\x40\xd8\xb1\x92\x39\xd1\x82\x16\x7a\x26\x0d\xa8\x86\xb4\xa0\x09\x37\x0b\x62\x14\x4d\xee\xa0\x44\x91\x62\xee\x73\x03\x92\x1c\x3b\xc7\xae\x18\x7c\x75\xb7\x61\x33\x53\xb2\x9c\xce\xc0\x13\x16\x5b\x25\x19\xd5\x7e\xf5\x2b\xfb\x3b\x6d\x47\x93\x74\x21\x68\xce\x93\x90\x35\x50\xc9\x39\xd7\x5c\x3a\x6b\xaf\x1f\xf7\x3a\x64\x86\x43\x0b\xf2\x79\x46\x79\x4e\x8e\x34\x63\xe4\xd2\xa3\x04\xfe\x72\x83\x32\x0d\x5a\x36\x54\xdd\x39\x40\x86\x94\xe6\xc2\x25\x44\xa8\x08\x5c\xb8\xbc\x42\x86\x69\x67\xbe\xf2\xa3\xc7\x61\xbb\x56\xcf\x49\x2a\xb8\xb8\xf7\xa9\x3b\x99\x48\x65\x74\x6b\x79\x76\x7d\xa5\x63\x6d\x04\x71\xcb\xe5\xbd\x83\x1f\x32\x29\xa6\x71\x1a\x81\x0a\x33\xa1\x26\x30\x94\x77\x99\xf3\xb4\xa4\x19\x12\x51\x37\x99\xf3\x9b\x2b\xec\xce\xa7\x33\x33\xbc\x67\x60\x8d\x41\x5e\x53\x9d\x19\xff\x51\xbe\xe4\xad\xc3\x35\x10\x5d\xe3\xac\x09\x68\xd9\xb2\x53\xbb\xa7\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\x41\x28\x9b\x57\x9b\x7c\xeb\x4a\x27\x76\x14\x0e\x0e\xbe\x8b\xcc\x66\xd1\x45\x07\x54\x32\x17\xe9\x90\x66\x16\x73\xae\xbf\x3d\x77\x1e\xce\x78\x10\x6a\x17\xf9\xbe\x0a\x12\x17\x21\x6d\xb6\x95\x19\x56\x1e\x01\x88\x83\x1f\xb3\x14\x88\x46\x5c\x30\xf2\xde\x6a\xc8\x6e\xf3\xae\xbf\x3d\x1f\x10\x3e\x62\x23\xff\x57\x68\xea\xa9\x96\x91\x53\x74\x03\x8c\xab\x68\x8f\x08\x4c\x25\x36\x46\xc5\x7d\xff\xfe\x47\x3b\x49\xfb\xeb\x9f\x86\x7f\x8c\xb2\x8d\xfe\xe9\xef\xae\x8a\xf6\xdf\x1b\x6f\x63\x5f\xb2\x90\x75\xff\xef\xd7\x2e\x2b\xb5\xcb\x59\xfd\x77\x57\x8c\x8b\x09\x63\xe5\xc6\x6b\x09\xb7\xf4\x3c\x45\x6c\x84\x6f\x2b\xf6\x0f\x6f\x58\x04\x30\x05\xa3\x4e\x42\x0d\x13\x40\xa8\x7d\x50\x86\x90\x06\xbb\xbb\xba\xb3\x76\xfe\x47\x60\x12\xc0\xa0\xb2\x01\x31\x52\xc2\x71\xc4\x23\x7f\x26\x08\xf3\xb5\x3a\x71\xad\x00\x0e\xea\x1c\xd5\x3c\xef\xb1\xc3\x5a\x08\x87\x10\x5c\x3b\x0f\x98\xdb\xaf\x84\x34\xbf\x0a\xdb\xef\x5d\x34\x80\xc1\x48\x42\xe7\x92\xfb\x04\xe4\xf6\xa4\x08\xac\xe8\x18\x52\x62\x8f\x17\x24\xe7\xda\xd0\x3b\x36\x22\x37\x96\xb7\xc4\xb7\x61\x08\x3d\x41\x20\x83\x25\x4b\x49\x29\x0c\xcf\xe0\xd7\x6a\x1c\x3b\xe5\x98\xe7\x5c\x4d\x88\x2e\x13\x4b\x5b\x0b\xc5\x86\x9e\x8b\xb9\x56\x4b\xb4\xa0\x5a\xcb\x20\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\x88\xbc\x07\x66\x95\xf9\x2b\x61\x54\x4b\x9c\x01\x53\xb0\x84\x69\x4d\xd5\x62\x00\x89\xdd\x79\x48\x06\xee\x5c\x77\x80\xa3\xe6\x54\x60\x5a\x75\xc5\x12\x29\xb4\x51\x65\x62\xb0\xce\xde\x58\xc9\x3b\x26\x82\xbb\xa0\xdd\xc5\xba\x03\x57\xe5\x3f\x03\xf7\x5d\x92\x24\x33\x2a\xa6\x51\x9d\x9a\x9c\xa6\x00\xfb\xaf\x83\x94\xe3\xd7\x63\x21\x40\x27\x56\xb0\xe0\x06\x40\x31\xb6\x7c\x24\x98\x61\xff\x2a\x42\x3e\x9e\x41\x65\x27\xb5\x4b\xe2\xd9\x16\xda\xd5\x89\x7e\x91\x8e\x46\xbd\x21\xb0\xed\x3d\x3b\x80\xe5\xcc\xd0\x94\x1a\xba\x83\x13\xd8\xbb\xaa\xb8\x9e\xbb\x80\x74\x05\x4e\xc3\xc5\xa4\xe3\x43\x5e\xdc\x92\x05\x8f\xe3\x9f\xe0\x24\xce\x3c\xe4\x21\xe2\xda\x58\x9c\x72\x17\x05\xe8\xdb\x05\xf2\x8c\xaf\x5e\x66\x87\xf7\xa3\x21\xb9\xa8\x4a\x33\x56\xe4\xa4\xdd\x35\x54\x47\x0b\xac\x05\xfd\x0e\x30\xba\xad\xee\xca\x92\xba\x7f\xd7\x4a\x11\x04\xb9\x04\x13\x86\x2b\x16\x87\x9b\x39\xd0\x95\x02\x91\xbc\x01\x44\x80\xf2\x94\x19\x5d\x79\xa8\x20\x1d\xb6\xc4\xc5\xf1\x3b\xa7\x8c\x02\x91\x76\x80\x75\xfa\xdc\x6a\x59\x08\xc1\xae\xa5\xa3\xb3\x96\xf2\x3f\x0a\x5c\x77\x31\x3a\x63\x39\x81\x77\x32\xed\x62\xa7\x6e\x64\xe1\xaf\x86\xa8\xfc\x37\xd1\x13\x57\x83\x52\x8f\x0d\xe0\xb6\x4a\xd7\x82\xe6\x90\xc8\xcd\xe8\x7c\x77\x23\x55\x25\x23\x0d\x43\x2a\x63\xf8\xdc\x10\x3e\x37\x7c\xdd\xde\x98\xd7\xc5\x03\xc4\x3f\xad\x3d\x41\xea\x1f\xe9\x64\x39\xb5\x24\xe5\xa6\xa3\xb9\xb3\x11\x8d\x1c\x46\x70\x34\xdf\xdd\x22\x86\x9b\x5b\x17\xe9\xc0\xb8\xa5\x16\xa7\xe4\x57\x35\x2e\xef\xa4\xa9\xa0\x29\xa1\xa7\xee\x91\x57\x9d\x46\x6e\x2b\x7c\xf0\x79\xbd\xf9\x71\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\xee\x83\x30\x41\x35\xa6\x6e\xf1\x37\x5e\xcc\x15\xce\x5b\x3b\x5e\xf0\x5a\x3e\x13\x0b\x9c\xfa\x45\x04\x5a\x54\x3d\xc9\xd4\x7e\xc8\x4a\x9d\x82\x8e\x33\xbc\x3d\x0e\xcc\x16\xe6\x42\xb3\x7b\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\xaf\xaf\x60\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\x1a\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\xf1\x70\xbe\x61\x69\x90\xae\x5f\xbd\x22\x1b\x88\x4b\x57\xc9\xd8\x0b\x3a\x70\x79\x50\x88\xec\x48\x03\xab\x87\xd2\xaa\xd6\x78\x64\xd8\x73\x92\x82\xf7\xa1\x71\x95\x8e\xc4\xc2\x99\x6e\xe2\x6f\xc5\x03\x84\x53\x42\x8e\x84\x14\x78\x72\xb0\xed\x31\xba\x10\xad\xb1\x4d\x41\x13\x57\xa2\xae\x5e\x21\x34\x3a\xa9\x9e\x49\x70\x91\xda\xad\x03\xca\x0d\x3a\x92\x2e\x93\x84\xb1\xa0\x55\xc7\x25\x6a\xaa\x93\xed\xa6\xec\x4b\x5d\x6a\x09\x49\x5c\xb4\xa1\x59\x56\x69\xb3\x0e\x5c\x12\xf8\x9c\xb7\x00\x46\xec\xaf\x16\x68\xe3\x14\x7b\x28\xa2\x8e\x6e\x2f\xa5\x48\xf0\x0a\x9f\x9b\x85\x9f\xc1\x45\x93\xd5\x83\x1a\xa1\x51\xc9\xe5\x13\xb4\x3b\x45\xea\x40\x00\x26\x90\x26\x57\xc2\xbd\xce\x99\x5c\x6e\x06\x4b\x87\xc6\x34\xb9\xbb\xa7\x2a\x85\x52\xbe\x05\x35\x1c\xd3\x82\x0f\x6a\xc3\x1e\x45\x73\x80\x42\xfa\x31\x16\x1d\x07\xa5\x43\xb3\x90\x82\xba\xfa\x0c\xa1\xa5\x91\x39\x35\x3c\x01\x55\x96\x4f\x22\x2b\x62\x1e\x52\x1a\x36\xca\x0e\x02\x95\x0d\x05\xec\x6f\xf1\x36\x46\x31\x62\xee\x25\xe1\xb9\x95\x10\x28\x94\xd2\x98\x84\x88\x21\x6f\xef\xdc\x34\x53\x2b\x06\x7d\x07\x46\xe6\xa8\x15\x2a\xc9\x56\x85\xd2\x30\x7c\xb0\x68\x06\x53\x9e\x0b\xb9\x19\x34\x18\xb8\xeb\x63\x71\xda\xce\x35\x42\xd5\x81\xdd\x9e\x7b\x66\xe5\x02\xbd\x11\x61\xf5\x68\xd5\x8c\xb0\xa6\xad\x26\x29\xd7\x8d\xc2\xd4\x47\xa9\x92\x45\xe1\x0c\x24\xf9\x71\x73\x46\x70\x6f\xa0\xe6\x4c\x47\xb5\x97\xd1\x54\x3d\x65\x22\x14\x0f\x77\xe9\x2c\xe0\xe4\x36\x3f\x51\x3b\x30\x23\x0c\x08\x3d\x26\xdf\xb8\xa2\x42\x01\x71\x83\xd7\x5d\x2b\xc1\x09\xad\x2d\x4e\x76\xea\x25\x9e\xb6\x4f\x2f\xf1\xf4\x12\xcf\xcf\x5b\xe2\x09\xee\x5e\xbb\x4a\x3b\x95\x8f\x63\xa3\x20\xb9\x77\x06\xa8\x1a\xac\x33\x62\x5c\x4d\xc8\x47\x96\xc8\x39\x53\x48\xe4\xa0\xf0\xa7\xe5\xe5\x6f\x28\xcf\x2c\x89\xf3\xa4\xae\x52\x0f\x21\xa3\x6a\xdd\x34\x17\x69\xe4\x01\x9a\x0e\xcd\x73\x37\x29\x17\xe9\x67\xdb\xbb\x4b\xb2\x42\xb1\x39\x97\xa5\xf6\x2e\x0b\xa5\xc1\x63\xa6\x8d\xe3\xb7\x33\x3e\x0d\x89\xb9\xc3\x55\xa7\x62\x89\x54\x69\x15\x52\xae\x0d\x35\xa5\xae\xc7\x49\x24\x68\x4d\xdb\x9f\x81\x26\xc0\xf1\x91\xa9\xfb\x6e\x94\x14\x3d\x36\x1e\x70\x2a\x0e\xdf\xa2\xcf\x47\x55\x77\xdb\x44\x6e\x28\x95\x0b\x8c\x15\xa1\x4a\xc3\x22\xb4\x72\x08\xd0\x19\xd6\xb5\xa8\xd7\x13\x2c\xdc\x32\x0c\xc3\x0e\x2b\xaf\x93\x16\x19\xd7\xe3\x67\x27\xa8\x93\x07\x04\x78\xc6\xcf\x0b\x76\x3c\x69\x2c\xb6\xbb\xf7\x25\x79\xa0\x07\x26\x79\x88\x17\x26\xd9\xa7\x27\x26\x09\xfe\xdc\x0f\x39\x31\x1f\xbd\x27\x79\xe3\xcc\x38\xc2\xbb\xe9\xcc\xd4\x12\x0a\x84\x71\xb8\xf6\x15\x20\xdd\xb5\x66\x38\x03\x60\x12\x8c\xfd\x81\xdd\x69\x05\x6d\x0e\xef\x2e\xd9\xa7\x90\xf5\x37\x92\x63\xaa\xa2\xda\x46\x82\x07\x42\x5e\x60\x26\x20\x38\x75\x43\xe7\x92\xe5\xb5\xa5\xfe\x04\xf7\x27\xb8\x6d\xff\xe7\x3c\xc1\xe8\xf1\xdc\xc5\x21\xbf\x51\x29\x08\xbb\xbb\x20\x5c\x3a\x66\x19\xf9\xb1\x64\x6a\x41\xac\x10\x54\xb9\xf7\x40\x7a\x63\xcd\x53\xe7\x20\xe3\x8c\x2a\xed\x65\xf6\x27\xe4\xff\x60\xb2\xb9\xfc\x64\x25\x40\x88\x63\x7b\x00\x5d\x6b\x0e\x55\x0f\x55\x46\x68\x05\x08\xc6\x12\x1e\xde\x30\xd6\x64\x3e\x2b\xee\x9d\xbd\xbf\xd8\x4d\xd1\xe9\x76\xa9\x45\x76\xb9\xd8\x5a\x5a\xfc\xd9\x86\x05\x22\x20\xc2\x2f\xf5\x6a\x52\xc1\x14\x41\xee\xd8\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\xfb\xe0\xa5\x06\x34\xad\x39\xe6\xde\xb1\xc5\xa1\x76\x51\x83\x52\xe8\x19\x2f\x7c\x7e\x78\xa0\x04\x0e\x73\xc9\xb7\xe0\x1f\xe0\x87\xc0\x33\x7f\x25\x06\xe4\xbd\x34\xf6\x7f\x97\xe0\x2a\x84\x96\x4a\xc9\xf4\x7b\x69\xe0\xcd\x93\x03\x0b\xa7\xfb\x60\x50\x39\x33\x25\x07\x33\x23\xba\xb4\x41\x7c\x86\x77\x41\x01\x90\xb8\xfb\xd6\x00\x56\xae\xc9\x95\x20\x52\x79\x98\x18\x9f\x3c\x58\xbb\x21\xbc\x6d\x29\xb2\x08\xaf\x18\xc3\x81\x52\xaa\x1a\x24\x37\x0c\x17\x8c\xcb\xdc\xff\x02\xb6\x27\xb0\xc6\x07\xbf\x19\x48\x81\x4b\x0d\x9b\xf2\x84\xe4\x4c\x4d\x21\x3e\x34\x99\xed\xbe\x41\xdd\xe9\x36\x3e\x3b\x51\xef\xf8\xc3\x9d\x31\x03\x58\xdd\x5b\xf0\x5c\x7a\x28\xc3\xc4\x51\x90\x45\xe4\xb4\xb0\x48\xf1\x2f\xcb\x09\x60\x5f\xfe\x03\x29\xab\xf5\x88\x9c\xf9\x82\xa7\xf1\x6f\xce\x8a\x11\x0f\x63\x47\xb0\x32\xfd\x8f\x25\x9f\xd3\x8c\xa1\x3f\x1f\x15\x21\x8d\xa7\x9c\x2c\xb1\xe9\x81\xcb\x5b\x6d\xa9\x54\xb8\x19\x3a\xb8\x63\x8b\x83\xc1\x12\x22\x1d\x5c\x89\x83\x2a\x48\xbb\x86\x3a\x81\xa1\xc1\xa5\xc1\x01\xfc\x76\xb0\x6f\xce\xfe\x4c\xa2\xfd\x0e\x58\xe2\x0c\x42\xe7\x19\xd5\xba\x5b\x7c\x6b\x23\xb4\xa8\x31\xce\xaa\x04\x8c\x37\x51\x9b\x2a\xb8\xc8\x79\x6f\xee\xdd\x9e\x05\x5e\xfe\xdd\x3d\x8d\x3a\x41\x6f\xee\xaa\xa7\xb4\x4f\xdc\xb0\x32\xa1\x18\xa4\x2d\xf0\x31\x1c\xb5\xb8\xb8\xea\x32\x76\x0d\xbc\xbe\x05\xbb\xa2\x9c\xc4\x45\x9e\xb9\x06\x35\x98\xfb\xa8\x0e\x21\x0d\xe1\x22\xc9\x4a\x67\x52\x84\xae\xa0\x44\x77\x15\xf5\x77\x00\xce\x03\x90\xaa\x1a\xc0\x63\x93\xbf\xf6\x5d\x72\xe0\x6d\xde\xd0\xc1\x9d\x68\xb8\xf1\x42\x58\xed\x7b\xad\x93\x2d\xee\x92\xf5\x64\x9c\x49\x5d\xf6\x78\xc3\xc7\x8a\x91\xf3\x19\x15\x82\x65\x51\xb4\xab\x33\x76\x84\x72\x56\x20\x90\xb8\x22\x56\x87\xf5\x2a\x56\x9e\xbe\x89\x10\x5b\xbd\xf7\xda\xc1\x3f\xa5\xa2\x52\x7b\xab\x53\xee\x52\x35\xce\xe4\x3d\x49\x25\xb9\x87\xba\x05\x73\xcb\xb4\xe0\x52\x56\x7b\x76\x17\xcd\x14\x5c\x24\x12\x99\x17\x4a\xe6\x5c\x7b\xe7\x78\xb7\x8d\x7b\x0d\x0d\xcd\xca\x16\x39\x80\xea\x7b\x90\x95\xa2\x9e\x12\xfe\xcd\x39\x31\x54\x4d\x99\xb1\xa3\x11\x51\xe6\x63\xd6\x3a\x7e\xf5\x31\x72\x90\x7d\x4e\x25\x44\xf7\x5b\x04\x0b\xb7\xe1\xbb\xef\xde\x77\x2e\xbd\x5b\xf5\x5c\xb7\xb7\xf7\x52\x65\xe9\x3d\x4f\x91\x45\x6b\x72\x64\x1b\x1f\xbf\xfc\x4a\xb9\xf7\xf7\x3c\xed\x0c\x0e\xe8\x54\x07\x83\xf7\x83\xb2\x60\x20\x00\x07\x57\xe1\x89\x43\x1a\x6d\xe8\x71\x4c\x2e\x39\x46\x17\x41\x7f\x48\x54\x93\x8f\xb9\xa8\x22\xcc\x2a\x30\x5b\x62\x6c\xcf\x8b\x57\x4d\x34\x33\x18\x17\x02\xa1\x15\xd2\xcc\x88\xe6\x79\x99\x19\x2a\x98\x2c\x75\xb6\x68\x8d\x2a\xcf\x03\xea\x49\xc6\x3e\x21\x66\x77\x61\x72\xa1\x53\x9d\xd9\x81\xeb\x4a\x15\x46\xb9\xc4\xed\x2a\xe7\xaa\xf4\x24\x70\xbe\x10\x6e\xc4\x3e\xb1\xc4\x79\x05\x17\x59\x39\xe5\x5b\xc2\x1f\x7e\x66\x59\xcd\xab\x04\xd2\xa5\x66\x55\xa4\x7e\xdb\xba\x2e\x4f\x94\x84\xfc\x79\x39\xfc\xed\xea\x04\xe4\x29\x2b\x98\x48\x21\x25\xda\x9b\x0a\x73\x71\xf2\x7b\x85\x9c\x4b\x2f\xd6\x95\x6a\xf9\xac\x64\x35\x0a\x1e\xb9\x70\xcd\x64\x96\x6a\xc2\x3e\x19\x45\x2d\x61\xca\x2d\x09\x0a\x7d\x26\x84\x8a\xf6\x44\xe6\x65\xa4\x08\x26\x7b\xe7\xf6\x8f\x5b\x2f\xf3\x25\x96\xbc\xac\xd6\xae\x37\x16\xac\x7e\x58\xea\x7a\x24\xc4\xee\xac\xe8\xba\x87\xf0\x8a\x14\xf3\xee\x2b\x75\xcf\xc4\x87\xa5\x9a\xd7\x2b\x92\x6a\x37\x66\xd5\x97\xe9\xfc\x2c\xf2\xce\x4f\x20\x30\xb8\x4b\x12\x26\xd7\xa3\xa1\x51\xbb\x97\xcd\x82\xd0\x1b\x34\x68\x87\xb7\x11\x1f\x80\x8c\xa7\x6e\x20\x17\xd6\x44\xb4\x85\x65\xe5\x3a\x57\x0a\xb1\x8d\x8a\x3d\x46\x16\x71\x6a\xa8\x66\xa6\x9d\x35\xa5\x2e\x3a\x54\x3d\xed\x01\x8c\xf1\xcb\xfd\x84\x59\xec\xc1\x21\xdd\x07\xcb\x92\xe1\x9f\x9c\x94\x21\x6a\x2d\xad\x7c\xe1\xe1\xe3\x93\x34\xb1\x70\x8b\x8c\x63\xa4\x76\x57\x12\x6a\x5a\x97\xdc\x69\xc5\x17\xdc\x0c\xbe\xf9\xa6\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\xbf\xaf\xb5\x4d\x13\x56\x19\xaf\x2e\xb8\xbe\xeb\x92\x8c\x6c\xa9\x73\xfd\x48\x7c\x75\x7e\x49\xdc\xdb\x56\xf6\xa5\x2e\x06\xa6\x87\x66\xc6\x9a\x26\xac\x32\xda\xa6\x5c\xdf\x3d\x79\x59\xf5\x22\x7d\xbf\xcd\x03\xfc\xe9\xec\x5f\x4d\xa9\xd7\xa7\x68\x89\x72\x07\x2d\x64\x49\xee\x5d\xea\x03\x27\x35\xdf\xf2\xe2\x94\x5c\x0a\x5d\x2a\x56\xdd\xdc\x36\x87\xb2\x5c\xf7\x25\x95\x5e\x7f\x10\x96\xbc\x64\xe3\x5b\x41\x95\x01\xf1\xb8\x2b\x1a\x84\x8e\x9e\x3e\x45\x2f\x44\x1b\x3c\xb8\x9a\x78\xc7\xba\x81\x8b\xf1\x0e\x89\xcb\x7c\x23\xbb\xf3\x51\x5a\x93\x78\xaf\xdf\x84\x94\x3f\xe4\x24\x65\xf3\x13\x9d\xd2\xd7\x03\xf8\x8c\x77\x78\xae\xcf\x89\x6a\x72\xf0\xfa\x60\x44\x6e\x78\xce\x33\xaa\xb2\x45\x2d\x15\x73\xd5\xce\x32\x0b\x3f\x20\xdc\xca\xbd\x3a\x20\x47\x52\xc1\xc8\x09\x15\x24\x63\x3e\xa2\xc9\x9d\xb3\x05\xca\x8e\xc7\x4f\x4d\x5c\xc8\xa3\xda\x2f\x91\xce\x74\xc6\x89\xd4\x73\x6c\xc7\x8f\x6a\xe9\x6c\x2e\x2a\x92\xce\x85\xa5\xf3\x23\xf2\xcd\xaa\x42\xe5\x70\x64\x7c\x8b\xe7\x02\xea\xd3\xe8\x7d\x3b\x69\x70\xcb\xe6\xe0\xe7\x03\xd3\x76\x2d\x71\xca\xcd\x47\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\x23\x72\x71\x79\xfd\xf1\xf2\xfc\xec\xf6\xf2\xe2\x94\x7c\xe5\x46\xe2\xb1\x84\x37\x22\xb7\x71\x36\xa8\xc8\xa3\xd7\xa5\xdc\x09\xdf\x1a\x38\x32\x44\x45\x95\xdc\x11\x72\x7c\x50\x41\xae\x04\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\x23\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\x8e\x0e\xbd\x40\x91\x2d\x25\xe1\x0f\x83\xc6\x19\xbd\xea\xc8\x36\x22\xe4\x83\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\xf8\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\xf1\xf2\xec\xe2\xdd\xe5\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\xdf\xaf\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\x3b\xfb\x57\x94\x74\x1b\xf0\xe2\xfd\x87\x5b\xc8\xea\x0b\x17\x5c\x0f\x16\xc2\xed\x07\xe1\xbc\x0d\x87\x43\x30\x19\x1c\xfd\xc3\xca\x93\x69\x76\x4c\xbe\x63\xee\x3b\x12\xd2\x0e\x2b\x28\x05\x34\x93\x21\x07\x2c\xcc\xb5\x82\x2c\xa0\x23\x5e\xef\xbb\x56\x27\xb6\xa5\x95\x95\x90\xd5\xd4\xda\x43\xe5\x53\x4c\xdd\x88\x77\x4c\x4f\x2f\x7b\xee\x91\xec\xef\x4c\xe5\xbc\x69\x75\x15\x7e\x86\x8b\x1f\x4f\x0f\x29\xd1\x8b\x3c\xe3\xe2\xae\xca\x0b\x36\x91\x16\x87\x30\x34\x81\x8b\x3b\x8f\xb1\x8a\xd1\x6c\x3d\xa5\xdc\x05\x3f\xf6\x4a\x25\xcd\x0e\x16\x40\xb0\xd0\xd9\x73\xf6\x17\x7f\xec\xdd\x35\x74\x4c\xe2\x0e\x0e\x5e\xdc\x7a\xb9\xee\x56\x06\xff\x10\x3a\xd4\x68\x9a\x20\x57\x37\xe7\x37\x57\x4f\x6a\xa1\x5e\xc7\x12\x60\x76\xcf\x28\xd5\xf1\x1f\xb7\xdd\x0e\x0f\x49\x56\x6e\x6f\x83\xea\xdd\xb5\x54\x86\x66\x7b\x22\x02\xc9\x8c\x16\x67\xa5\x99\x5d\x70\x0d\x39\x14\xba\x0a\x01\x4b\xfd\x23\x4f\x67\xcc\xdd\xec\x13\x06\x72\x8f\x0e\xae\xdd\xf9\x5f\xce\xae\x09\x2d\xed\xfe\x1a\x97\x5c\x74\xaf\x17\xee\x7e\x66\x37\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\x95\x6f\x01\x57\xc8\xc0\xc5\x97\x3a\x55\xd6\x02\x90\xde\x01\x62\x57\xc2\xca\xda\x34\x61\x0d\x07\xc8\x01\x24\xfd\xc4\xb1\x79\x68\xf3\x47\x67\xa0\x82\xfc\x60\xd9\x9f\x4e\x6b\xa9\xd8\x97\xea\x5a\x78\x2b\x45\x55\x34\x61\xaf\x16\x1f\xfe\x63\x57\xa2\xc0\x7f\x14\x0d\x4b\x1b\x2e\xf0\xff\x96\x34\x43\xc0\xbc\xdf\xb7\x59\xaa\x0e\xe4\xae\xf3\xad\xef\x90\x9b\x7a\xb5\x1d\xef\x83\x96\x5e\x6a\xcc\x3c\x86\xeb\x31\x8a\x0a\x6d\xf7\xa8\xae\x8b\x1d\xba\x8b\xa7\x43\x72\x64\x92\xa2\x75\xed\xfe\x47\x72\x6d\xcf\x4a\x51\x2b\xe4\x0c\x33\xbf\xc5\x6d\x79\x1b\x5c\xdb\xdb\x4e\xf2\x51\xae\x86\x00\xcb\xbb\x5a\x55\x5c\xaf\xb0\x5b\xf1\xba\x90\xf5\x93\xb7\x5c\x1b\x5f\x90\x01\x5e\x70\xed\xf2\x08\x83\xdc\x75\x6d\x15\x39\x5e\xfc\x8d\xa6\xa9\x3a\x45\x2e\xe5\xab\x2f\x2b\x90\xbe\x7c\x92\x2f\x2a\xc2\x5d\xe2\x91\x59\x14\x2e\x01\xe0\xed\xf9\x35\xc1\x02\x29\x7f\xf8\x1d\x56\x7e\xfd\xaf\xdf\xfc\xee\x55\xeb\xed\x7e\x3e\xe7\xf1\x1d\xed\x18\x7b\xbf\x63\x7a\x11\x7e\x83\x35\xff\x40\xbb\x12\x90\x4d\x6e\xd0\x1d\xcf\x52\x56\x77\xd4\x11\xb1\xec\x2e\x07\x7a\xbf\x9b\x04\xd3\xfb\xd9\x3d\xab\x9f\x1d\x09\x11\x25\x48\x24\x3a\xa2\x4b\xdc\x15\x42\x0c\x97\xc9\x0e\x52\x9c\xeb\x97\x47\x71\xb6\xc2\x66\x3b\x16\xd5\xb1\x27\xbe\x8c\xf7\xe5\x6f\x2a\x17\xf6\x8b\xf7\x37\x7f\x7b\x7b\xf6\xe5\xe5\x5b\x98\xa9\xbb\xbf\xb7\xa8\xc1\xc5\xce\xfe\x53\xed\x51\xad\x8d\xf2\xba\x1d\x20\xdd\xae\x65\x44\xe3\x42\x46\x90\xf7\x6f\x6e\xba\xde\xc5\x3c\x54\x40\x17\x93\x56\x6b\x7f\x5a\x6b\x1b\x54\x35\x61\x6a\x7f\xf1\x23\x3b\x1b\xe5\xa2\x44\x5a\x35\xfd\xcb\xee\x14\xce\xf0\xc1\x2a\xd2\xd6\x1d\x20\x2f\xe0\xde\xc1\xae\x17\x61\xb0\xf7\x1b\x87\x47\x82\x55\x5b\x39\x40\x75\x0f\x2c\x3a\xc4\x5e\x5e\x04\xb0\x87\x14\x69\x9b\xb2\x34\xdb\x52\x6b\xa6\x43\xf5\x85\x17\x8a\x29\xc5\xaa\xf4\xcc\x5d\xa8\xd7\xca\x01\x6a\xe5\xca\x6a\x77\x31\xb5\x58\x8a\x75\xe9\xcc\xbd\x87\x02\x75\xca\xab\x2e\x68\xb2\xd7\x82\x2a\xd5\x2b\x7c\x03\x41\xee\x4f\x4f\x00\xe1\xb3\x7b\x74\xa4\x0d\xe3\x75\x45\xe4\xd0\xb1\x19\x25\xd7\x69\x87\x7c\xa1\x8f\x42\xfa\x08\xc4\x38\x9c\xee\x99\xb7\x8f\x3c\xad\xb6\xf3\xdd\x8e\x8a\xce\xbe\x95\x9c\x62\x26\x8d\x14\x3b\x7b\xc9\xaf\xea\x5e\x3f\xd0\xd7\xd0\xe2\xbc\x2a\x63\x13\xd5\x78\x04\x0f\xca\x70\x19\x61\xe5\x39\xcf\x2e\xa4\xf0\xd7\x12\xf5\x4b\x89\x27\x17\x41\xd2\xab\x8b\x3d\x1d\xbe\xcf\x37\xc4\xb3\xab\x31\x78\xaf\xce\x20\x69\xe7\x98\x14\xdb\xc5\x43\xec\xea\xc2\x89\x66\x3e\xe0\x44\x3b\x84\x24\xeb\x31\x72\x6f\xac\x53\x2a\x73\x2f\x55\xf7\x50\xef\x7a\xc7\x86\xaf\x82\xfb\x6d\x29\x14\xeb\x25\x9e\x1e\x9c\xe3\x33\x9f\xa0\x1b\x38\x41\x8d\x04\xe7\xeb\x4e\xd2\x63\x1c\xa4\xe7\x3d\x40\x0f\x65\x54\x8f\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\x03\x82\x59\x96\x73\x5a\xf8\x9a\xdc\xf2\x5e\xdc\x53\x95\x92\xb3\xeb\xab\xfd\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\xfd\xef\x7f\x8f\x95\x95\x52\x96\xf0\x7c\xb9\x21\xb4\xfa\x5f\xaf\x5f\x8f\xc8\xff\x9c\xbd\x7b\x0b\x95\x1f\x0b\xa3\x31\x2b\x09\x8e\x8c\x95\xe0\xa3\xce\x7a\x40\xfe\xcf\xcd\x87\xf7\x55\x99\x98\xfa\xaf\xae\xa0\xb6\x5b\xde\x88\x5c\x44\xfe\x4f\xb1\xa1\x8b\x9a\x99\x2b\x68\x64\x08\x9d\x4c\x10\x31\xc6\xbe\x9c\x2e\x1e\x38\x1f\x3d\x0e\x55\xc1\xb1\xfe\x88\x45\x89\x0c\x1c\xb3\xac\x4a\x8e\xa6\x41\x9f\xd9\x00\xfd\xcc\x60\xac\x40\x26\x61\x2a\x03\xac\x25\x3f\xd1\x50\x85\xa4\x4a\xff\xa7\x98\xb6\x42\xa9\xab\xae\x88\x83\x55\x3b\xa3\x59\xeb\x5c\x0f\x8f\x71\x03\xd4\xba\x3a\x46\xdd\x74\xef\xce\x90\x4f\xdf\xea\x72\x17\x57\x65\xea\xff\x81\xb7\xa1\xdb\x9c\x84\x1f\xe9\x46\xa6\x36\xd7\xeb\x30\x1b\xdc\x3a\x97\x25\xa0\xa2\x13\x34\x93\x50\xc9\x2b\xec\x74\xc5\xc5\xa2\xa2\xf7\xdb\x97\xd2\x39\xf9\x62\xd7\x04\xbc\x48\xa8\xde\xd1\xd6\xe5\x7c\xea\xfe\x22\xbe\x77\x2d\xaf\x02\x1d\xcb\xd2\xf8\x3b\x6c\xf7\x3b\x04\x60\x63\x95\xf5\x0e\x69\x24\x77\xc8\x3c\xb9\x4b\x06\xe2\xce\x49\x4c\xeb\xf7\xcd\xc0\x13\xea\xa2\xc4\x80\x30\x9a\xcc\xc8\x1d\x5b\x0c\x91\x6e\x15\x14\xa2\x79\x00\x2a\x17\x16\x16\xb5\xc2\x27\x55\xed\x1a\x2b\x1f\x3b\x90\x79\xc7\x80\x88\xfb\xf8\x68\x20\x2f\x84\x6a\x27\x2f\xb9\x34\xa2\x22\xb2\x14\xf8\x5c\xd5\x51\x3d\xe2\x90\x37\x14\x8b\x91\xd7\x83\x54\xec\x79\x63\xa9\xed\xa6\x37\x7d\xb9\xf2\x86\xb0\x74\xd0\x71\xb7\x52\x2c\xf5\x76\xc5\xb7\x9d\xf0\x07\x1f\xa4\x3e\x3b\x73\xe4\x51\x01\xe5\xfc\x5c\x25\x27\xd7\xd6\x43\x29\x00\xa2\x16\x44\xa3\x99\x29\x1d\x68\xb0\x5e\x58\x29\x32\xa6\x35\xe1\xb0\xc2\x9c\xaa\x3b\xe6\x13\xc6\xd0\x6c\x44\xae\xed\x24\x43\xfe\x2a\x4c\x8b\x3c\x47\x17\x3b\x7b\x66\xe3\xe8\x20\xfb\x91\xc3\xd1\xe8\x10\x09\xfc\x8a\x58\xa1\x0e\xf8\xb1\x5b\x4e\xdd\x1d\x72\xe9\x36\x4a\x7b\x17\x1a\x33\x03\x5b\x91\x0f\x32\x5f\x4b\x88\x82\x33\x33\xcf\xc0\x68\xeb\x24\x4a\xcb\xcb\xd9\x21\x01\xec\xae\x79\xcb\x77\xc9\x5a\xde\xea\xde\xa2\xfe\xec\x9e\xad\x7c\xa7\x5c\xe5\xeb\x32\x95\xbb\x9d\x72\xa7\xad\x7b\x0e\xe7\x07\xa4\xd8\xce\x3b\xa5\x79\xf5\x4f\xdd\x48\x09\x72\x47\x2d\x4b\x4f\x2b\x19\xd1\x25\x7d\xca\xd8\x67\x25\x14\x5e\x4d\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\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\x4f\xd6\x99\xe4\x01\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\xbe\xda\x49\x03\x88\xfa\xaf\xd1\x01\xe2\x16\x3f\x61\x2d\xe0\x0a\xb5\x80\xb8\xec\xce\x45\xb5\x72\x67\x52\xb6\x64\xe7\xc5\x8b\x91\x4b\xd3\x7e\x63\x89\x65\xec\x74\x5a\xcf\xa1\x87\xc6\x9e\x8a\xac\x46\x79\xf7\xfc\xad\x23\x1c\xe2\x97\x2e\x72\x3e\xa1\xf8\x08\xf0\xe8\x54\x2e\xdd\x3f\xcb\xd5\xec\x60\xb1\xe4\x06\x4a\xdb\xa0\x3e\x18\x29\x96\x85\x4c\x4f\x5d\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\x0f\xa9\x73\x64\x37\x10\x56\x7e\xdd\x75\x17\xc9\x03\xcb\x16\x91\x88\x35\xed\x56\x08\xa5\xb6\xa7\x6e\xa4\x50\xe7\x3d\x99\xb1\x9c\x62\x0e\x3f\xbf\x3c\x4b\x65\xee\x15\x37\x86\x61\x2e\x25\xa6\x72\x4d\xe4\x64\x50\xbb\x33\x38\x98\xbf\x3e\xd8\xa5\x1c\xcc\x03\x2b\xf6\x90\x6a\x17\xf6\x00\x8c\xeb\x9a\xc8\x66\xf1\x1a\x74\x89\x0c\x12\x6f\x8a\x86\x41\xc2\x32\x98\x39\x42\xef\xc9\x17\xbe\x0f\x3d\x6a\x57\xfd\x69\x10\x04\x86\x5e\x7f\xea\xf5\xa7\xbd\xe8\x4f\x11\x63\xf1\x04\x67\x85\x2e\x15\x3b\x0c\x7b\x85\xaa\x0a\x64\x8a\x12\xf0\x58\xd4\xf4\xaa\x94\x54\x75\x8b\x9b\xd5\x87\x0e\xbd\x82\xe5\xf0\xb8\x34\x93\xe1\x1f\x08\x13\x89\x4c\x71\xf3\xed\xf8\x4a\x1b\x10\x6d\x2a\x9d\x24\x9e\x4b\xee\xbf\x15\x5b\xed\x60\xec\x5d\xb7\x6e\x27\x3a\xe0\xaf\x02\xdf\xec\x89\xc1\x57\x6c\x3d\x04\x13\xfb\x5a\xd9\x3e\xd7\x80\xe3\xef\xd5\x25\x24\x96\x95\x06\xe4\xf6\x15\x73\xc9\x11\xbe\x1c\x25\x45\x39\x70\x0d\x46\x39\xcb\xa5\x5a\x0c\x42\x23\xfb\x63\xad\x97\x6b\x71\x0c\x32\x41\x52\x2a\xab\x01\x66\x8b\xcf\x55\x3a\xf0\x00\x7a\x62\xe1\x20\xec\x53\xb7\xa2\x41\xf1\x53\x47\x89\x2a\xa9\x18\xe8\xf7\x55\x11\xa5\x49\x48\x79\xa8\x07\x95\xda\x69\xdf\x32\x31\x27\x73\xaa\x3a\x54\x41\x8f\x9f\x07\xca\x03\x29\x9f\x73\xbd\x5b\xbd\xc3\xc6\xd2\x6f\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\xb3\xa9\x2f\x8c\xcf\x8e\x55\x86\xf1\x79\x68\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\xa2\x83\x86\xee\x26\x3b\xd9\x6d\x5c\x86\xfa\xd5\x26\x1b\xf7\xe3\x4f\xd8\x5a\xb3\xdf\x3b\x5b\x17\x5f\xf8\x33\xbf\xb0\xbd\x71\xf5\x0c\xfa\xdb\xda\x56\x28\xd8\xdf\xd6\xf6\xb7\xb5\xfd\x6d\x6d\x6f\x6d\xe8\xad\x0d\xfd\x6d\x2d\xe9\x6f\x6b\xf7\x02\xc3\xfd\xdd\xd6\xa2\xa8\xb7\xea\xce\xd6\x09\x7b\xd5\x85\xed\x93\xde\xd7\xba\xc2\x3d\x67\x49\x22\x4b\x61\x6e\xe5\x1d\x6b\x7d\xe9\xd0\x90\xff\x97\xc6\x81\x04\x08\x6b\xf4\x81\xe5\xc6\x4f\xa6\x1c\x74\x97\x4a\x3a\xc9\x16\xbb\x48\x15\xb4\x4c\xb9\x95\xfc\x77\x46\x33\x3f\x40\x9c\x9c\x48\xa4\x2c\xad\x7e\x70\x47\xd9\x58\x58\x8f\xc8\x19\x51\x2c\xe1\x05\x77\x65\xe4\x29\xbe\x47\xc4\x0b\xb5\x11\xb8\xd1\x2c\x9b\xb8\x1c\xf5\x22\xae\xf5\x53\xc9\xef\x8e\x0e\xae\xfc\x0c\x72\x28\xe9\x33\x99\xfb\x5a\x48\x8a\xfd\xc3\xb3\x36\x37\x9b\xdb\x78\x84\xd8\xbc\x02\x4b\xa9\x95\x18\x82\x8f\x15\xdc\x05\x58\x3f\xf6\xf1\x67\x9f\x0a\xae\x00\x79\x6f\x58\x22\x45\x9b\x9a\xaa\x6b\x36\x68\x69\xa4\x8a\x3f\x81\x6d\x94\xa5\x24\x2d\x55\xa8\x99\x3a\xa7\x19\x4f\xb9\x59\x84\x5b\x3b\x57\x5e\x8b\xe2\x89\x09\xdb\xa8\x2b\x30\x12\x5a\x14\x4a\xd2\x64\xc6\x74\xf4\x35\x14\x50\x5c\x10\x59\xf0\x7d\xc7\x12\x70\x20\xa3\x40\x1f\xcb\x20\xb3\x05\x51\xd2\xf8\x8b\xf7\x35\x1f\xbc\x8d\x06\x83\xee\xc8\xe5\x8c\x5a\xc0\xed\xbc\x8c\x87\xc0\x59\xf1\x49\xfc\x87\x26\x32\x4b\x7d\x0a\x93\x3f\xbc\xb2\x42\x61\xe2\x70\xd0\x12\x3f\x48\x70\x61\x24\xc9\x2c\xc3\xb6\x04\x71\x7d\xe7\xdf\xfc\x96\xcc\x64\xa9\xf4\x28\x4e\x3a\xf0\x1a\xde\xa1\x7e\xe7\x85\x4a\x43\x32\x46\xb5\x21\xaf\x5f\x91\x9c\x8b\xd2\xf2\xa9\xce\x68\xd3\x5d\x0e\x8a\x24\xa0\xdf\xfd\xb6\x75\xbf\xae\xb2\xcf\x5a\xa9\xa7\xc0\xdc\xc8\x4e\xf4\x71\x27\x09\x03\xe3\x30\xb3\x78\x43\x10\x72\x44\x37\x86\xb6\x30\xf2\x11\xce\xd7\x8f\xa5\x1c\x2f\x4c\x97\x20\x4a\xd7\xa3\x1e\x3d\xf9\x7f\xdd\xcb\x36\xc9\x53\xaa\xdc\x29\x1b\x3f\xfa\x28\x15\x2e\xa6\x5c\x9b\x2d\xf5\x2d\xaa\xf8\xca\x8d\xcd\xda\xb3\x95\xa9\xd5\x0e\x3a\xc6\xca\x40\x1f\x2f\x11\x7b\xdb\x52\x92\x30\x2c\x66\x79\x51\x55\x4a\x12\x12\xdb\x6e\x1d\xfe\x99\x13\x8e\x79\x04\xd9\x43\xd6\xf4\x96\x4b\x6d\x27\x74\x79\x94\xe8\xbc\x56\xec\x56\x3f\x05\x9a\x8b\x29\x26\x39\xcf\xcb\xcc\xf0\x22\xab\xd6\xfd\xd1\x77\x70\x84\x3c\xb6\xb9\xd1\xc8\x4c\x44\x31\xb0\x18\xb3\x4d\x81\x7d\xf2\x28\x8c\xc5\x84\xc1\x5c\xdd\xca\xf2\x83\x82\x2a\x1a\x80\x07\x95\x74\xf5\xb1\x33\xdf\x51\xb8\x51\x74\xe9\x30\x6d\x2f\x9a\x55\x33\x8e\x6e\x91\xf6\x89\x34\x86\x09\x2a\x5a\x98\xaa\xeb\xe9\xb9\xa0\x13\x91\xf7\xc1\x99\x0c\xcb\xa0\x34\xb0\xc5\x09\x35\x5f\xd2\xe4\x8e\x89\x14\x8b\x46\xc1\xb2\xd3\x85\xa0\xb9\xcb\xb6\x15\xd5\xe3\x6e\xf4\xd7\x03\x67\x98\xc0\xf0\x3d\x1f\x66\x8c\x5c\x77\x9f\x30\x28\x75\xe7\x54\x36\xb6\xcb\xb6\x73\xae\xd1\x64\xa3\xf8\x3c\x61\x9e\xff\xdb\x7e\xfb\x9c\xfa\xbc\x45\x2c\xfd\xd2\xe4\xfd\xf6\x44\xf8\x0b\xe4\x3e\x58\xce\x21\xa9\x16\xcd\xec\xd1\x5e\x84\x98\xd1\xc6\xe6\x8e\x17\xfb\xad\x7a\xa3\xc6\x5d\x22\x7f\x0f\xd5\x38\xad\x1f\xe2\x8f\x34\x95\x9a\x7c\x99\xc9\xe4\x8e\x5c\x30\x10\xba\x1e\xb3\x3c\x8b\x1a\xa7\xcf\x99\xc2\x3b\xa7\xd3\x6d\xf7\x6c\x43\x92\x4b\xc1\x8d\x54\x9b\xe9\xc5\xd3\x95\x9d\xec\xd3\x3d\xaf\xcd\x50\x65\xb1\xf9\x25\x27\x7b\xb6\xe8\xd6\x75\xe3\xa1\x53\x50\xcf\xe0\x74\xe2\x2b\x57\x05\x6c\xc7\xb3\xf6\x8b\x99\xbc\x1f\x1a\x39\x2c\x35\x1b\xf2\x16\x17\xba\x1d\x96\x79\xc7\x16\x70\x8b\xdd\x71\xa1\xae\x5b\x4d\x67\x30\x12\x2c\x50\xf0\xde\x72\xee\x8f\x5f\x5e\x7c\xa3\x99\x1a\xc5\x32\xe0\x09\x33\xc9\x49\xc2\x8a\xd9\x89\x1b\xe1\x45\x02\xc5\x13\x91\xae\x50\xf1\xfd\x90\xcd\x24\x32\xcb\x5c\x60\xb6\x9c\x90\x73\x56\xcc\xc2\xc0\x4f\xbd\xea\xe7\xcb\x08\x5c\x48\xd9\x35\x11\xea\xa1\xed\x53\x3f\x44\xf0\x06\xcf\x50\x84\x4c\x6a\xdc\xad\x08\xc5\x53\xa1\xcf\x8b\x2e\xb5\xf9\x88\xc0\x79\xdc\x74\xca\x87\xb5\x7c\xca\xb1\xbf\x67\x3d\x59\xb2\xf7\x18\xa9\x91\xa0\xab\x09\x0a\xdd\x29\x4b\x89\x9c\x33\xa5\x78\xca\x34\x09\x34\x28\xd6\x52\x79\xf6\xd4\x70\xeb\xf3\x36\x3f\x7b\xde\xe6\x1d\xd4\xa1\x43\xd0\x87\x6a\x64\x0a\xde\x2c\x91\x29\x9a\xe6\x5c\xbc\x38\x42\xa5\x13\x9a\xb1\xab\x0f\x1d\xf4\x0f\xd7\xa3\xae\x82\xdc\xb8\x97\x51\xfe\xb4\x2d\x59\xc9\xbe\x0e\x78\x43\x84\x4c\xb7\x99\x54\x1f\x41\x91\x98\x52\xc3\xee\xb7\xb2\xc3\x61\x45\xa8\xb6\xb7\x04\xe1\xf4\x39\x55\x8e\x17\x91\x23\x30\xc2\x79\x4c\x7a\xb6\x4f\xa6\xea\x76\xad\xab\x71\x12\x7b\xc5\xe9\x77\x9b\x49\x77\x3d\x06\x9f\x5d\x5f\x91\xaf\xb0\xf9\x7e\xb3\x17\x2a\x69\x50\x0c\xbc\x90\x39\xe5\x5d\x8b\x6c\x34\xbb\x37\xb3\xaf\xc6\x4b\xb8\x0e\x6d\x89\x6b\x1c\x15\x70\x99\xf0\x69\x69\x75\x3a\xa7\x87\xbd\xa8\x04\x73\x4b\xa2\xcb\xcb\x4d\x30\xf7\xf0\x6a\x10\x91\xc9\xc9\xfb\x45\x56\x12\x8b\xdf\x4a\x60\x25\xe1\x0e\x94\x68\x26\x34\x87\x0b\x99\xe8\x56\xdc\x55\xfa\xc3\xd2\x92\xe8\x04\x89\x22\xce\x80\xbc\x95\x53\x2e\xfc\xe9\x95\xee\xbe\x6e\x42\x79\xd6\x16\x18\xbd\x4c\xf2\xec\x32\x89\xd6\xd9\xa5\xa0\xe3\xac\x8d\xbb\x41\x1d\xd5\x42\x47\xf2\x26\xa3\x53\xc2\xe0\x8f\x93\x94\x6b\xfb\x7f\x72\x73\xf3\x16\x8c\xf0\xa5\xf0\x12\x33\x18\xa8\x1d\xed\x0b\x41\x0a\x78\x10\xf7\x7b\x76\x90\xf4\xec\x90\xfd\x2f\xea\x49\xb8\x48\xed\xc4\xa3\x52\x70\xe8\x24\x05\x2d\x30\x1f\x62\xf0\xf9\x45\xb7\x81\x31\x23\xb7\x33\x9e\xdc\x5d\x47\x76\x77\xa9\xec\x3b\x11\xbd\xaa\x31\xb0\xe6\x6f\xfb\xa4\x96\x6e\xaa\xd7\xdd\x55\xe3\xa8\xa7\xe7\x03\x9e\x60\xdc\xb8\xf5\xc3\x6f\x54\x6b\x99\xf0\xea\xce\x05\x6c\x34\x15\x73\x48\x81\x39\xec\x77\x4d\x20\x1e\x74\x5d\x0e\xca\x1f\x2b\x38\x9a\xdf\x4d\x5f\x1d\x57\xc7\x1c\x8c\x0b\xbf\xea\xbd\x2e\x01\x71\x66\x87\xd4\xe8\x55\xc7\xe5\xd4\xe8\x5e\x18\x6e\x5c\x2c\x78\x37\x75\xb7\x79\x5e\x10\xf3\xb5\x39\x97\xb6\x2f\xa4\x48\x77\xa9\x09\xf7\xb6\xf0\x36\x61\x1b\xab\xd4\xf0\xc6\x6d\x22\xbe\x73\x57\x0d\x70\xe6\x0a\x59\x94\x19\xfa\x73\x3c\x3c\xbf\xbb\xb7\x19\xe3\x77\xf6\x74\xf5\xf0\x14\x59\x4b\x0f\x63\xc7\xde\xee\x9e\xce\x3f\x8d\xdc\xa5\x91\x70\xf7\xea\x77\xbf\xfd\xed\xe7\x9e\xcd\xb4\xad\x0a\xfe\x18\xe9\x4c\x5b\x9a\x68\x57\xc4\x17\x5d\xf5\xf1\x45\x3f\xdf\xf8\xa2\xc7\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\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\x1e\x1c\x53\xd2\x3d\x09\x60\x77\x7b\xda\x2e\x05\xa9\xaa\x9e\x2b\x35\x48\x1f\x54\xee\x73\x8f\x1d\x1e\xea\x28\xb5\x98\x91\xf6\x04\x3e\x89\x42\x42\x3a\x68\x63\x38\xbc\xec\x52\x1b\xd2\xf5\xf9\x70\xd3\xb8\x98\x09\xaf\x9f\xe7\x3e\xe6\xe7\x70\xe1\xd1\xd7\x74\xf9\x4c\x4c\xee\xba\x96\xad\xc5\x5b\x2b\x80\x04\x00\x23\x97\xe3\x38\x4b\x64\x75\x74\xce\xae\xaf\xac\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\x7d\x8f\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\x6b\x08\xc8\xa9\x5a\xd5\x25\x69\x14\xa5\x69\x96\xc9\x7b\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\x1b\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\xe0\x7e\x02\xde\xb0\x90\x65\xb0\x77\x61\x31\xcc\xb0\x3a\xbd\x02\x4e\xef\xab\x1f\x41\x15\x48\xa5\x37\x4d\x0c\xd9\x27\xae\xcd\xf2\x5a\x3c\x88\x7c\x1a\xbc\x7d\xe1\xcd\x5c\x17\x96\x2d\x74\xae\x6a\x57\xeb\x57\x97\x57\xe6\x37\xf0\xd3\x67\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\x25\xd5\x2c\x25\xef\xa8\xa0\x53\xd4\xf7\x8e\x6e\xae\xbf\x7c\x77\x6c\xf7\x15\xf4\xc9\xab\x8b\x95\x17\x6d\x37\xf1\xe0\xef\xf7\x19\x2f\xb2\xb4\xf0\x1d\x58\xd5\x52\xff\x1d\x17\xbf\xd7\x40\x18\x12\xf8\x50\xbb\x64\xbd\x2b\x58\xd0\x75\x33\x84\xb5\x59\xf3\xb3\x41\x60\xe6\x79\xfa\xc0\x2a\x9f\x5c\x68\x43\xb3\xec\x3a\xa3\xe2\xac\x28\x94\x9c\xaf\xd6\xc6\x6b\x73\xf5\x0d\xfd\x4c\xd1\xcd\xc3\xbf\x2c\x10\xf4\x70\x85\x2d\xc8\x55\x35\xfe\x88\x5c\x99\xa0\x85\x4b\x01\x2c\xf5\xe0\xac\x34\x32\xa7\x86\x27\x07\x56\x59\x3f\x78\x47\x45\x49\xb3\x95\x4e\x57\x1b\x97\xb1\x4e\x44\xdc\xd8\x69\x7d\xea\xba\x16\xdd\x36\xca\x1a\x9b\xfb\x1b\xaa\x2c\x75\x3a\xbf\xf9\xb6\x53\x5f\x6d\xa8\x29\x97\xa8\xf0\x06\xce\xb0\x9e\x17\x0c\x49\x46\xb5\xf9\xa6\x48\xed\xa1\x6f\xfc\xba\x89\xe0\x27\xd4\xd0\x4c\x4e\xff\xc2\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\x6f\xa0\xed\xb9\x14\x29\x47\xb3\x23\x18\xd4\xb0\x47\x7d\xdc\xf5\xa8\xb6\xee\xa6\x61\xc3\xdd\x42\x3d\xbb\x66\x34\x9f\x3a\x28\xb0\xd9\xd8\xc9\x97\x33\x7c\x09\x37\xed\xb5\xb9\x2d\x41\x8a\xdc\x09\x2b\x18\x42\x1e\x91\xd5\x64\x6b\xab\x9c\xb0\x4d\x3e\x18\xfa\x3d\xc6\x29\xac\x77\x1c\x1d\xba\x79\xaf\xbb\x83\xd8\x84\x62\xf8\x6c\x97\x2c\x9a\x53\x59\x4f\x53\x57\xe1\x5d\xe8\x86\x91\x2c\x8d\x82\xfc\xb5\x46\xeb\x79\x40\x2b\xc1\xab\x9d\x8c\xd4\x36\xab\x7d\x9d\xd6\x56\x39\xd8\x97\x54\xd9\x16\x12\xe3\x56\xa6\xd5\x32\xb9\x7c\x5d\xb1\xbe\x72\xfe\x7f\xca\xa9\x22\x94\x14\x9c\x61\xf2\x13\x2a\x1c\xb0\x80\xb3\x30\x9a\xba\x97\x96\x83\x59\x95\x10\x7e\x1b\xb8\xcb\x70\x34\x2e\x3b\x5f\x0b\x6f\xa0\xa6\x98\xfc\x03\x2e\x2e\x4e\xbe\x92\xce\xc8\xeb\x82\x74\x2d\x0d\x00\x4e\x3e\x20\xba\x4c\x66\x84\x6a\x3b\x35\x8b\xd0\xf6\xc4\xb3\x51\x4e\x05\x9f\x30\x6d\x46\x21\x4b\xb0\xfe\xfe\x37\x3f\x8c\xc8\x1b\xa9\x88\x73\x54\x1f\xf8\xac\x1a\x6e\x9e\x15\x5e\x70\x8d\x8b\x09\x7d\x2b\xad\xb5\x90\xa9\x9b\xf4\x3d\x4c\xd6\xd0\x3b\xcb\xc3\x70\xb2\x25\x83\xab\x8b\x53\x72\x60\xc5\xc4\xe8\xd3\xff\xb2\x6c\xe9\x3f\x07\xe4\xe8\x1e\x98\xf6\x81\xfd\xf3\x00\x3f\x18\xdc\x26\x63\xa5\xba\xfa\x30\x06\x4b\x2a\x3e\x9d\x32\x85\xea\x23\x81\xa0\xc2\x63\x97\x15\x44\xc8\xa8\xb1\xbf\x94\xae\xd4\xcd\xe6\x44\xbe\xff\xcd\x0f\x07\xe4\xa8\xbe\x2e\xc2\x45\xca\x3e\x91\xdf\xa0\x75\x99\x6b\xbb\xc6\x63\x77\x99\xa3\x17\xc2\xd0\x4f\x76\xcc\x64\x26\x35\x13\xa8\xca\x1b\x49\x66\x74\xce\x88\x96\x56\x03\x66\x59\x36\x74\xb6\x74\x72\x4f\x21\x53\x8b\x07\x25\x04\xd6\x93\x82\x2a\x53\x43\x89\x91\xb3\x90\xc0\xd7\xec\xb6\x4d\x85\xbf\x99\x9e\x70\xe1\xee\xaf\xdc\xcd\x99\xdd\x73\x08\x0c\xc5\x4d\x32\x92\x24\x33\x2a\xa6\x21\x36\x7d\x52\x9a\x52\xb1\x2d\x57\x3f\x2d\xcf\xc0\x1d\x17\x9d\x42\x98\xbf\xe6\xa2\xe9\x54\xb0\xda\xae\x34\xe5\xc6\x47\x45\x38\x5f\x45\xb3\x38\xb1\xbb\xa0\xf8\xb8\x34\x52\xe9\x93\x94\xcd\x59\x76\xa2\xf9\x74\x48\x55\x32\xe3\x86\x25\x76\x59\x27\xb4\xe0\xc3\x44\x0a\xbb\xe3\x90\x95\x21\x4f\x7f\x01\xe5\x4d\x87\x76\xaa\x5b\xb2\x4e\xb7\x5c\xf4\x76\xa3\xda\xb3\x1a\xd3\xf6\xb6\xc6\x16\xf6\xa0\xe5\x85\xa2\x6d\xe6\x09\x56\x0b\x86\x90\x93\xbd\x2c\xd6\x27\x4d\xee\xce\x63\x0e\x5d\x1e\xf0\xa4\x39\x86\x3d\x76\xe8\x40\x02\xa7\xb2\x46\x29\x73\x9a\x22\x29\xa5\x62\xf1\xe8\xc8\x6f\x41\x0a\xe9\xf2\x93\xc5\x10\x86\x90\xd9\x90\x8a\xd4\xfe\x1b\x03\x76\x92\xc5\x5e\x60\x58\xf2\x4e\x84\xe0\x9b\xab\x8b\xa7\x39\x12\x25\xdf\xc3\xa9\x77\xf2\x5a\x4b\x21\x0a\x45\x55\x74\xd4\x50\x25\xf3\x4c\xb3\x2e\xa0\x72\xed\x47\xfd\x6f\x77\xff\x12\xb2\x9d\x6d\x13\xa9\x36\xdf\x9a\x44\xb2\x63\xcb\xf9\xbe\xad\x7a\xc4\x36\x39\x70\xbc\xa2\xda\xb8\xd4\x5a\x3e\x07\x41\x6d\x19\x5e\x41\x01\x06\xb3\xfe\x62\xb8\x15\x0e\x79\x7f\x01\x3b\x91\xe1\xca\x9c\x4b\x49\x50\x4a\xb6\x2b\x50\x95\xfe\x52\xab\x83\x86\x8b\x32\x4c\x1b\x42\xe7\x94\x67\x60\x9d\x97\x63\xcd\xd4\x1c\x0b\x52\xb9\x54\x83\xb4\xa9\x67\xb9\x9a\x13\x28\x46\x3d\x91\xe6\xe3\xd7\xb0\xbc\x2b\x9b\x16\x00\xda\x50\x63\xf6\x6b\x67\xbd\x17\xbd\x07\xd5\xcb\xb5\x3f\xdb\x2f\xec\xa8\xc6\x58\xfc\xfb\x0b\xa3\xca\x8c\x19\x35\xb7\x7c\x13\xdf\x5d\x42\xe9\x5a\xbf\x50\xca\x3d\x20\xf4\x3d\x23\x53\x69\xac\x88\x55\x02\xee\xa3\x4c\x8a\x49\x7d\x02\xa2\x3d\x36\x46\x57\xab\xbc\x55\x14\x42\x7c\xa4\xe8\xb8\xcc\x7a\xc7\xe5\x75\x3a\xe9\xd8\x61\x92\xc1\xd6\x98\x48\x43\x0a\xe6\xf6\x0e\x6f\x33\x80\x02\x3d\xcd\x92\x73\xa6\xf5\xc6\x04\x1b\x75\xef\x42\x6c\x8d\x47\xb9\x71\xb5\x96\xfb\xdf\x30\x2c\xc4\x0a\xd0\x29\x33\x94\x67\xfe\x28\x23\x28\x02\x94\xb6\x51\xd7\x8d\x0b\x54\x8c\xea\x4d\x02\x42\x6d\xd6\x1f\xa1\x31\x4e\x5a\x0a\x36\xbc\x97\x2a\x25\xe7\x34\x67\xd9\x39\xd5\xcc\x8d\x15\x87\xe8\xe1\x1e\x1d\xea\xbd\x4e\x79\xb5\xed\x6b\xcd\x94\xd1\xf8\x53\x99\x84\xe1\xaf\x4a\xc5\xc2\x09\x0e\xbc\x09\xf2\x56\x95\x6c\x40\xde\x58\xee\x35\x20\xdf\x88\x3b\x21\xef\x1f\x36\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\x8a\x09\x17\xdc\xb7\x75\x7a\x57\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\x6f\xbe\x5d\x0f\xec\xb5\xbc\x6f\x1b\x7f\xda\x6e\x96\x7a\xa8\x41\x6a\xeb\x99\xd9\x6a\x84\xea\xcd\x4f\xbd\xf9\xe9\x73\x32\x3f\x6d\xc5\xf8\x4d\x26\xa7\xcf\xc3\xd8\xb4\x75\x89\x9b\x0c\x4c\x2f\xd2\xb4\xd4\x6a\x45\x1b\xcd\x49\x2f\xd6\x90\xb4\x75\x69\x2d\x8d\x47\x3f\x1f\xb3\xd1\x56\x88\x6d\x30\x15\xbd\x40\x23\x51\x1b\x81\x8c\xa5\x6d\xc4\xc4\xab\xa8\x71\x2c\x28\x56\xe5\x2c\xc3\x70\xde\x29\x27\x16\x67\x76\x95\x16\xad\x00\xb7\x75\x6e\x87\x6e\x72\xed\x65\x2f\x27\x30\xba\x62\x8f\x4b\x93\x25\x17\x97\xd7\x1f\x2f\xcf\xcf\x6e\x2f\x2f\x9a\xf2\xdd\x2a\x48\x6f\x91\xc4\x36\xdb\x20\x86\x91\x24\xb6\xa6\x81\x25\xc8\x6b\x7e\xb2\x38\xb0\xe6\xa7\xb2\xe4\xab\x7a\x3d\x5c\x2e\x7c\x10\x97\x7b\x10\xff\xd8\x7e\x3a\xdb\x1e\xcf\x6f\xd0\x71\x8a\x3a\x9f\x33\x2b\xf7\xcc\x64\x96\x6a\xef\xb7\x7a\x75\x11\x22\xa9\xb8\x48\xb2\x32\xb5\xc2\xc5\x37\xdf\x5c\x5d\xe8\x11\x21\x5f\xb2\x84\x96\x1a\xac\x30\xa9\x14\x87\x86\x7c\x78\xff\xf6\x7f\xc0\x1f\x1b\x5a\x0c\x42\x5e\x13\xc8\xca\xcb\x29\x26\x16\x36\x98\xae\x8d\x7c\xc9\x50\x50\x81\x2f\x27\xb4\xb0\x54\x4c\x63\xe5\x0a\x03\xb2\xc8\x8c\x65\x85\xa5\x98\x77\x8c\x54\x19\x54\xed\xc0\x55\x85\x79\xef\x3e\x39\x65\x06\xa3\xae\x36\x79\x48\x6e\x84\xda\x16\x8b\xeb\x03\x6c\xad\x35\xf5\xd1\x69\xe3\xf7\x54\x3b\x8b\xd5\xca\xd9\x6e\xd9\xdf\xed\xf6\x99\xf5\x26\x8e\x35\xc6\x0d\x24\xcf\xf0\xd7\xd2\x9c\xed\x64\x2b\x3b\x06\x3a\x91\x70\xd3\xda\x9a\xba\xde\x0d\x68\x75\x1d\x80\x25\x5b\x06\x6b\x02\xb9\xf6\xe1\xe0\x91\x1d\x4d\xb9\xdd\x5c\xa0\x88\x48\x5a\xab\xfd\xe9\xfc\xe7\xea\xef\xca\x71\xa8\xfe\x5a\xcd\xd7\x59\x64\xc8\xbf\xfe\xf3\xc5\xff\x1f\x00\x00\xff\xff\x9d\xd9\x48\xd2\xa7\x53\x02\x00") +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") 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 b203d9a18d..e048d4988c 100644 --- a/staging/api/pkg/operators/v1alpha1/subscription_types.go +++ b/staging/api/pkg/operators/v1alpha1/subscription_types.go @@ -84,18 +84,6 @@ type SubscriptionConfig struct { // List of VolumeMounts to set in the container. // +optional VolumeMounts []corev1.VolumeMount `json:"volumeMounts,omitempty"` - - // Describes node affinity scheduling rules for the pod. - // +optional - NodeAffinity *corev1.NodeAffinity `json:"nodeAffinity,omitempty" protobuf:"bytes,1,opt,name=nodeAffinity"` - - // Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)). - // +optional - PodAffinity *corev1.PodAffinity `json:"podAffinity,omitempty" protobuf:"bytes,2,opt,name=podAffinity"` - - // Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)). - // +optional - PodAntiAffinity *corev1.PodAntiAffinity `json:"podAntiAffinity,omitempty" protobuf:"bytes,3,opt,name=podAntiAffinity"` } // 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 8b9a736964..c094738eed 100644 --- a/staging/api/pkg/operators/v1alpha1/zz_generated.deepcopy.go +++ b/staging/api/pkg/operators/v1alpha1/zz_generated.deepcopy.go @@ -1394,21 +1394,6 @@ func (in *SubscriptionConfig) DeepCopyInto(out *SubscriptionConfig) { (*in)[i].DeepCopyInto(&(*out)[i]) } } - if in.NodeAffinity != nil { - in, out := &in.NodeAffinity, &out.NodeAffinity - *out = new(v1.NodeAffinity) - (*in).DeepCopyInto(*out) - } - if in.PodAffinity != nil { - in, out := &in.PodAffinity, &out.PodAffinity - *out = new(v1.PodAffinity) - (*in).DeepCopyInto(*out) - } - if in.PodAntiAffinity != nil { - in, out := &in.PodAntiAffinity, &out.PodAntiAffinity - *out = new(v1.PodAntiAffinity) - (*in).DeepCopyInto(*out) - } } // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SubscriptionConfig. 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 0e2bd8d983..7bcc8c94f1 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 @@ -173,468 +173,11 @@ spec: optional: description: Specify whether the Secret must be defined type: boolean - 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 nodeSelector: description: 'NodeSelector is a selector which must be true for the pod to fit on a node. Selector which must match a node''s labels for the pod to be scheduled on that node. More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/' type: object additionalProperties: 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 resources: description: 'Resources represents compute resources required by this container. Immutable. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/' type: object 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 68b9d3530c..3578ef32e0 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\xbd\x6b\x77\xe3\xb6\xd5\x28\xfc\x3d\xbf\x02\xcb\xed\x5a\xb6\x5b\x49\x9e\xe9\xd3\xd3\xf6\xf8\xe9\x6a\x97\x63\x7b\x52\x9f\xcc\xc5\x67\xec\x24\xeb\x79\xd3\x9c\x16\x22\x21\x09\x35\x09\x30\x00\x28\x8f\x7a\xf9\xef\xef\xc2\xde\x00\x08\x52\x37\x52\x96\x2f\x93\x90\x1f\x92\x31\x05\x80\xc0\xc6\xc6\xbe\x61\x5f\x68\xc1\xbf\x65\x4a\x73\x29\x4e\x09\x2d\x38\xfb\x64\x98\xb0\x7f\xe9\xd1\xdd\x1f\xf4\x88\xcb\x93\xf9\xeb\x2f\xee\xb8\x48\x4f\xc9\x79\xa9\x8d\xcc\x3f\x32\x2d\x4b\x95\xb0\x0b\x36\xe1\x82\x1b\x2e\xc5\x17\x39\x33\x34\xa5\x86\x9e\x7e\x41\x08\x15\x42\x1a\x6a\x5f\x6b\xfb\x27\x21\x89\x14\x46\xc9\x2c\x63\x6a\x38\x65\x62\x74\x57\x8e\xd9\xb8\xe4\x59\xca\x14\x0c\xee\x3f\x3d\x7f\x35\xfa\xc3\xe8\xd5\x17\x84\x24\x8a\x41\xf7\x5b\x9e\x33\x6d\x68\x5e\x9c\x12\x51\x66\xd9\x17\x84\x08\x9a\xb3\x53\xa2\xcb\xb1\x4e\x14\x2f\xe0\x13\x23\x59\x30\x45\x8d\x54\x7a\x94\x48\xc5\xa4\xfd\x5f\xfe\x85\x2e\x58\x62\x3f\x3e\x55\xb2\x2c\x4e\xc9\xca\x36\x38\x9c\x9f\x23\x35\x6c\x2a\x15\xf7\x7f\x13\x32\x24\x32\xcb\xe1\xdf\xb8\xf6\x9b\xe8\xab\xf0\x3a\xe3\xda\x7c\xbd\xf4\xd3\x5b\xae\x0d\xfc\x5c\x64\xa5\xa2\x59\x63\xb6\xf0\x8b\x9e\x49\x65\xde\x57\xdf\xb6\xdf\xd2\xe5\x38\xfe\xb7\x6b\xc8\xc5\xb4\xcc\xa8\xaa\x0f\xf2\x05\x21\x3a\x91\x05\x3b\x25\x30\x46\x41\x13\x96\x7e\x41\x88\x83\xa3\x1b\x73\x48\x68\x9a\xc2\xde\xd0\xec\x5a\x71\x61\x98\x3a\x97\x59\x99\x8b\xf0\x4d\xdb\x26\x65\x61\xd4\x53\x72\x3b\x63\xa4\xa0\xc9\x1d\x9d\x32\xff\xbd\x31\x4b\x89\x91\xa1\x03\x21\xff\xd0\x52\x5c\x53\x33\x3b\x25\x23\x0b\xe2\x91\x85\x60\xf4\x33\xee\xcf\x35\x0e\x12\xbd\x37\x0b\x3b\x5d\x6d\x14\x17\xd3\x4d\x9f\x4f\xa8\xa1\x99\x9c\x12\xc4\x2f\x32\x91\x8a\x98\x19\x23\xf6\x53\x7c\xc2\x59\xea\xe7\xb7\x61\x46\xd8\x75\x69\x4e\x37\xcd\xd7\xad\xa7\x34\xa3\x42\xb0\x8c\xc8\x09\x29\x8b\x94\x1a\xa6\x89\x91\x15\x7c\x36\x83\xc7\x75\x5e\x9a\xcd\xf9\xd2\xfb\x15\xd3\xc1\xa6\xf3\xd7\x34\x2b\x66\xf4\xb5\x7b\xa9\x93\x19\xcb\x69\xb5\x87\xb2\x60\xe2\xec\xfa\xea\xdb\xff\xba\x69\xfc\x40\xea\x4b\x89\x51\x94\xdc\x31\x56\xe8\xea\x50\x90\xb2\xb0\x6b\xb2\x8b\x23\xe3\x05\x31\x8a\x26\x77\x5c\x4c\x61\xe9\x53\x5c\xef\x39\x6e\x8c\x1e\x2d\x4d\x59\x8e\xff\xc1\x12\x13\xbd\x56\xec\xc7\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\x11\xb9\x61\xca\x76\xb4\x07\xb6\xcc\x52\x4b\xc7\xe6\x4c\x19\xa2\x58\x22\xa7\x82\xff\x33\x8c\x06\x20\xb2\x9f\xc9\x2c\x7e\x18\x02\xc7\x4d\xd0\x8c\xcc\x69\x56\xb2\x01\xa1\x22\x25\x39\x5d\x10\xc5\xec\xb8\xa4\x14\xd1\x08\xd0\x44\x8f\xc8\x3b\xa9\x18\xe1\x62\x22\x4f\xc9\xcc\x98\x42\x9f\x9e\x9c\x4c\xb9\xf1\x14\x38\x91\x79\x5e\x0a\x6e\x16\x27\x40\x4c\xf9\xb8\xb4\x1b\x77\x92\xb2\x39\xcb\x4e\x34\x9f\x0e\xa9\x4a\x66\xdc\xb0\xc4\x94\x8a\x9d\xd0\x82\x0f\x61\xb2\x02\x49\x64\x9e\xfe\x42\x39\x9a\xad\x0f\x1b\xe0\x5b\x79\x0e\x88\xa7\x7a\x1b\x61\x6d\x89\x1f\xe1\x9a\x50\xd7\x1d\xd7\x52\x81\xd4\xbe\xb2\x50\xf9\x78\x79\x73\x4b\xfc\x04\x10\xec\x08\xe1\xaa\xa9\xae\x80\x6d\x01\xc5\xc5\x84\x29\x6c\x39\x51\x32\x87\x51\x98\x48\x0b\xc9\x85\x81\x3f\x92\x8c\x33\x61\xec\x31\xcc\xb9\xd1\x80\x73\x4c\x1b\xbb\x0f\x23\x72\x0e\x0c\x88\x8c\x99\x3b\xb0\xe9\x88\x5c\x09\x72\x4e\x73\x96\x9d\x53\xcd\x1e\x1d\xd4\x16\xa2\x7a\x68\xc1\xd7\x1e\xd8\x31\xff\x5c\xee\xb0\x74\xc6\x08\xf1\x0c\x6e\xed\xee\xc4\x07\xfe\xa6\x60\x49\x38\x0e\x54\x90\xb3\xa2\xc8\x78\x82\x18\x6f\x66\xd4\x90\x84\x0a\x0b\x2f\x2e\xb4\xa1\x59\x06\xec\xa4\xd5\x2c\xd6\x9d\x76\x02\x47\xbb\xc1\x1c\xfc\xeb\x25\x0a\x5d\xff\x21\x30\xb5\x46\x8b\x75\x94\xc1\x3e\x8e\xce\x2e\xff\xb0\x01\xe4\x04\x25\x93\x09\x9f\xae\xea\xb6\x16\x96\xe7\xd0\x05\x64\x1a\xca\x85\x76\x43\x94\x0a\xa1\x59\x71\x2a\xcb\xbb\x68\x8d\x6f\x8f\xd6\xce\x6e\x25\x64\xb7\xad\xd9\x3e\x4c\xcc\x57\xff\xd0\x58\xc0\xa5\x98\xe3\x41\xb5\x32\x8b\x25\x72\x4c\xcc\xb9\x92\x22\xb7\x87\x68\x4e\x15\xa7\xe3\xcc\x31\x36\x66\xc9\x17\x9e\x31\x5c\x22\x53\xab\x8e\xd4\x9a\xaf\xe2\x7a\xa8\x52\x74\xb1\xa6\x05\x37\x2c\x5f\xb3\x9a\x55\xd3\xfe\x96\xaa\x88\x4a\x58\xe4\x5d\x35\x75\xe2\x1a\xd8\xa9\x53\x72\x1e\x26\xbe\xf6\x33\x5b\xe0\x8e\xcf\x7a\xdc\xae\x9e\x35\x58\xee\x9f\x6d\x1b\x88\x0f\x70\xfa\x0d\xbf\x37\xc0\x62\x4f\x08\x32\x30\xb6\x12\x1a\x23\xf2\xae\xd4\xb0\x5b\x94\x9c\xff\xed\xea\xe2\xf2\xfd\xed\xd5\x9b\xab\xcb\x8f\xeb\xc1\x41\xb6\x1d\x94\xea\x01\x1a\xdf\x61\xb2\x87\xdf\xfa\x3d\x52\x6c\xc2\x14\x13\x09\xd3\xe4\x97\x47\xdf\x9e\x7d\xfc\xdb\xfb\xb3\x77\x97\xc7\x84\x2a\x46\xd8\xa7\x82\x8a\x94\xa5\xa4\xd4\x9e\x69\x14\x8a\xcd\xb9\x2c\x75\xb6\x70\x94\x2b\x5d\x83\xb4\x4d\x6c\x05\x6e\x4b\xc5\x82\x68\xa6\xe6\x3c\x59\x0d\x22\x3d\x22\x57\x13\x42\x2b\x04\x4a\x02\x86\x5b\x46\x95\xcd\x59\x3a\x80\x61\xc3\xa4\xfd\x77\xb8\x28\x4a\xe3\x19\xde\x3d\xcf\x32\x38\x15\x02\x65\xa5\x74\x44\x2e\x64\x69\xc7\xfb\xe5\x2f\x61\x61\x8a\xa5\x65\x02\x42\xb4\x25\x06\x5c\x4c\xed\x4f\x03\x72\x3f\xe3\xc9\x8c\xd0\x2c\x93\xf7\x1a\x28\x05\xd3\x09\x2d\xfc\xd2\x63\xe8\xe8\x85\x30\xf4\xd3\x29\xe1\x23\x36\x22\x07\xbf\x8c\x7e\x3a\xc0\xaf\x17\x4a\xda\x4f\xa0\x9c\x8c\xb3\xca\xb8\x61\x8a\x66\xe4\x20\x6e\x3d\x22\x97\xf6\x1b\x2c\x8d\xf7\x01\x46\x10\x6c\xce\x94\x5d\x85\xdf\x85\x01\x51\x6c\x4a\x55\x9a\x31\xad\x2d\x9e\xdd\xcf\x98\x99\x31\x14\xc5\x03\xc0\xd8\x27\x6e\x19\xae\x54\x44\x48\x33\x22\x17\x6c\x42\xcb\x0c\x38\x30\x39\x38\x18\x35\x19\xdf\xee\xa8\xf6\x46\xc9\xbc\x03\xba\xdd\xd4\x35\x87\x55\x7b\x7f\xa8\x71\xe4\x1a\x59\xd3\x2c\x25\x7c\xe2\x24\x18\xae\xed\xa2\x08\xcb\x0b\xb3\x68\x73\x68\xb6\xd0\x11\xd2\x9a\x10\x90\xc0\x93\xde\xd1\xe2\x6b\xb6\xf8\xc8\x26\xdb\x9a\x37\xd7\xcf\x32\x96\x58\x42\x49\xee\xd8\x02\xc4\x59\x72\xee\x07\xdc\xbc\x94\x4e\xcb\x21\x2d\xc9\xa3\x7f\x86\x76\x3a\x5b\xdb\xb5\x07\x92\x7d\xee\xd8\xa2\x4d\x33\xb2\xac\xd3\x59\xd0\x00\xaf\xb3\xb0\xda\x0e\x15\xd2\x1e\x65\xfd\xb3\x9d\xa2\xaf\x9c\xdc\x61\x4c\xda\xdd\x39\x35\x2b\x05\xd6\xbb\x72\xcc\x94\x60\x86\x81\xcc\x9a\xca\x44\x5b\x71\x35\x61\x85\xd1\x27\x72\x6e\x29\x1f\xbb\x3f\xb9\x97\xca\x2a\x72\xc3\x7b\x6e\x66\x43\xdc\x55\x7d\x02\x46\x8f\x93\x5f\xc0\xff\xc8\xed\x87\x8b\x0f\xa7\xe4\x2c\x4d\x89\x84\x23\x5e\x6a\x36\x29\x33\x32\xe1\x2c\x4b\xf5\x28\xd2\xba\x06\xa0\x0f\x0c\x48\xc9\xd3\x3f\x6f\x3e\xdc\x3b\x42\x4c\x16\x68\xac\xd8\x01\x6a\x37\x20\x74\x2d\x6a\x74\x2a\x20\xbd\xa5\x50\x56\x45\xb0\x7b\x9e\x3b\xb6\xe8\x18\x4a\x87\x65\x8c\xa5\xcc\x18\x15\x5b\x7a\x00\xd8\xba\x9f\xd9\xc3\xea\xd0\xc2\x08\x1e\x01\x0a\x99\x9e\x12\x5d\x16\x85\x54\x46\x07\x15\x01\x6c\x2e\x83\xfa\x9f\x20\x2f\x0f\xc8\xdf\xc3\xcb\x8c\x8e\x59\xa6\xbf\x3f\x3c\xfc\xe3\xd7\x97\xff\xf3\xa7\xc3\xc3\x1f\xfe\x1e\xff\x1a\x59\xe8\xea\x4d\xd0\xa6\x23\x53\x10\xc2\xdd\x9f\x8e\x8d\x9e\x25\x89\x2c\x85\x71\x3f\x18\x6a\x4a\x3d\x9a\x49\x6d\xae\xae\xc3\x9f\x85\x4c\x9b\x7f\xe9\x2d\x9c\x80\x3c\x2e\xd1\x01\x70\x5e\x53\x33\xdb\x33\xe9\x59\x6f\x8d\x58\xfd\xd4\xb6\xdb\xdb\x27\xdc\x2e\x3b\x83\x84\xfd\xe7\x1b\x3f\x5d\xcb\x81\xee\x15\x37\x86\x09\x90\x3b\x98\xca\x2d\x27\x1e\x58\xcc\xad\xd8\xec\xfc\xf5\xc1\xa3\x10\xaf\x00\xb5\x1d\x16\x07\xb3\x77\x2b\x43\x64\x0e\x84\xd6\x4b\x50\x95\x8e\x74\x76\x7d\xe5\x2d\x33\x7b\x5f\x88\xb7\x37\xbc\x79\xf0\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\x47\x49\x51\x0e\x5c\x83\x51\xce\x72\xa9\x16\xe1\x4f\x56\xcc\x58\x6e\x25\xb6\xa1\x36\x52\xd1\x29\x1b\x84\xee\xd8\x2d\xfc\x85\x1d\x6b\x1f\x58\xee\x8d\x22\x75\x52\x2a\xcb\x3c\xb2\x85\xa7\x20\x2c\x7d\xde\xb3\xe8\xc1\xb4\xe7\xa3\x18\x76\xe3\xfd\x8e\x2c\x37\x68\x8b\xce\xe0\xea\x57\x05\x32\xe4\x5c\x66\x65\xce\xf4\x20\xb0\x27\x94\xd6\xc5\xdc\x4a\x93\x4b\xe6\x9d\xd5\x4f\xc7\xd3\x97\xf2\x39\xd7\x52\xed\xcc\x07\xb9\x33\x79\xca\xd2\x58\x4d\x65\x22\x55\x4e\x4d\x50\x17\x3f\x15\x52\x83\x0e\xe0\x70\xb6\x41\x52\x5e\x1f\xb4\xfa\x6c\x41\x8d\x61\x4a\x9c\x92\xff\x77\xf4\xd7\x5f\xff\x7b\x78\xfc\xe7\xa3\xa3\xef\x5f\x0d\xff\xf7\x0f\xbf\x3e\xfa\xeb\x08\xfe\xf1\xab\xe3\x3f\x1f\xff\xdb\xff\xf1\xeb\xe3\xe3\xa3\xa3\xef\xbf\x7e\xf7\xd5\xed\xf5\xe5\x0f\xfc\xf8\xdf\xdf\x8b\x32\xbf\xc3\xbf\xfe\x7d\xf4\x3d\xbb\xfc\xa1\xe5\x20\xc7\xc7\x7f\xfe\x65\xab\xe9\x51\xb1\xf8\xd0\xe2\xc0\xe3\x33\x74\x1b\xc4\x85\x61\x53\xa6\x3a\xf6\x6a\xbd\xad\x84\x7c\x1a\x56\x42\xdb\x90\x0b\x33\x94\x6a\x88\xdd\x4f\x89\x51\xe5\xf6\x83\x51\x11\xb5\x5d\xf0\xfc\xa3\x3f\xad\x91\x29\xd6\x93\xe6\xbd\x23\xb2\x66\x89\x62\x66\x5f\x1a\x0c\x8e\xe6\xf9\x47\x21\xd3\x43\x4d\xc4\x1a\x33\xe1\xba\x69\xff\x2c\x94\x1a\x2f\x52\x20\xbc\x2a\xce\x3b\x51\x32\x1f\x91\xc8\x2c\x34\xa7\x19\x4f\x7d\xbb\x3b\xb6\x45\xcb\xf5\x4f\xaf\x04\x7d\x5e\x4a\xd0\x0d\xee\xef\xa3\x6b\x40\x4c\xcc\x37\x99\x69\x9a\x36\x5d\xdb\xb6\x6e\x8e\xf6\x02\x94\x91\xa4\x90\x45\x99\x51\xb3\xc6\x6c\xb7\xc2\x36\xed\x70\x5f\x07\x33\xa1\xdd\x68\xb0\x03\x3b\x2a\x97\xaf\x36\x86\x92\xb3\x2c\x23\x5c\xe0\x49\x80\x01\xbc\x35\x4f\x31\x94\x97\x08\x45\x83\xf3\xdc\x4e\xe1\x7e\xc6\x9a\x86\x46\xae\xad\xae\xa3\x0c\x17\xd3\x11\xf9\xce\xfe\x8e\x34\xcb\x99\xc6\xb8\x20\x79\x99\x19\x5e\x64\x8c\x04\x6e\x8b\x36\xb4\xac\x64\x84\x6a\x2d\x13\x4e\x8d\x9b\xb1\xbb\x3f\xd4\xc6\x4f\x1b\x66\x63\xe8\x1d\x98\x42\x13\x96\x32\x91\xb0\x11\xf9\x16\xae\x0b\xc3\x5a\xc7\x56\x18\x04\xf3\x3e\x8c\x41\x49\x5a\xe2\xd5\x0e\xd2\x83\xd5\x63\x5c\xe5\x79\x69\xc0\x50\xfc\x54\x56\x7c\xbb\xe3\xce\x32\x17\x19\xf3\x81\x54\x05\xd1\x9a\xc2\xdd\x83\x9c\x54\xaa\xbb\x7e\x98\xf9\xbe\x1d\xe1\x0d\xe6\xb6\xad\x9c\x6a\x89\xe2\x56\x36\x86\x3a\xa5\x7d\x6a\x8b\x61\x3b\x3a\xfb\x93\xa4\xb1\x1d\xe8\x6b\x7b\xda\xda\xc1\xb8\xd4\x95\x9e\xb6\xb5\x26\x15\x8a\x4d\xf8\xa7\x0e\xf8\x78\x26\x2a\x15\x85\xa7\x4c\x18\xab\x08\x28\x20\xa8\x8a\x15\x4c\x80\x1e\xce\x68\x32\x03\xba\xe0\xa8\x68\x65\x19\x7e\xcc\x1b\x23\x94\x32\xba\x1f\xaf\x9b\x55\x52\x4c\x7f\xb6\x7e\xe2\x67\xcb\xed\xfa\xfe\x0f\x96\x90\x29\x3b\x9b\x80\xc7\xe2\x5a\x11\xbb\x36\xbb\x0b\x86\x2e\x5e\x1a\xba\x12\xea\xfa\x82\xc1\x2e\x2d\x33\x2e\xa6\x44\x95\x56\x26\xf1\x97\x4d\x85\xdc\x72\x2f\xbe\x11\x33\xdb\xe0\x64\x01\xe8\xa4\x58\x7a\x51\xda\x5d\xb9\x09\x33\xb9\x9a\x0a\x19\x5e\x5f\x7e\x62\x49\x69\xb6\x18\x27\x97\x8e\x9b\x5b\x16\x53\xfe\x5e\x91\x4d\x90\x80\xf8\x1f\xec\xfa\x40\x44\xb3\xe0\xd0\xe8\x38\xa2\xa9\xe1\x7a\xb2\x80\xe5\x07\x00\xb1\x4f\x96\xc5\x83\x33\x62\x64\xec\x1b\x2f\x9c\x43\x8f\x45\xcb\x01\x19\x97\x86\x70\x03\xde\x3e\xc9\x4c\x4a\x6d\x49\x0f\xc0\x19\xc6\x9d\x73\x09\xbe\x54\x44\x0a\x66\xe5\xd7\xdc\x1e\x9e\xca\x86\xe1\x87\x47\xe9\xaf\xea\xc6\x35\xc9\xa5\x36\x15\x9c\xec\x1b\x30\x86\x08\x56\x49\x59\x53\xc5\xd0\x4f\x4b\x97\x39\xdc\x6f\x32\x3e\x9d\x19\x3d\xc0\x4b\x56\x30\xf0\x58\x42\x59\x0d\x9b\x33\x66\x15\xd2\x2c\x8b\x6d\xb6\x1e\x05\x50\x61\xcc\x41\xa2\x39\x0a\xaa\xb5\x33\xcf\x0d\x82\x42\xd9\xdc\xb1\x95\xe0\x1a\x10\x66\x92\xd1\xf1\x80\x24\x32\x2f\x4a\xc3\xc0\x83\x24\xb7\xa0\x83\x2b\x5d\xe7\x51\xa5\x64\x39\xc5\x95\xb0\xcc\x7d\xd8\xbb\xb3\xa1\xc9\x15\x6e\xc0\xd3\xd4\xb6\x3e\xc0\xc5\x1d\x78\x0f\x35\x3b\x1c\xc7\x45\xc0\xfa\x72\x6a\x92\x99\xb3\x18\x25\x52\x29\xa6\x0b\x29\xa0\x27\xfc\x72\x59\xcd\xed\xbf\x43\xa7\x23\x7d\x5c\x01\x73\xc6\xa7\x33\x0f\x4b\xaa\xf0\x1e\xba\xbe\x07\x9b\x98\xc8\x76\x49\x93\x6c\x97\x36\x97\xd0\xf9\x4c\xe0\xdd\x6d\x84\x07\xd1\x8e\x19\xa6\xf2\xb0\x6e\xd8\x54\x24\xaa\xb8\x26\x9e\x5b\x01\x9a\x1b\x87\x15\xe4\x15\x39\x02\xb4\xe0\xe6\x50\x03\x8a\x0e\x65\x71\x3c\x22\x67\xe0\x92\xdc\xe2\x03\x42\x86\xf1\xdd\x40\xf6\xa3\x5a\x56\x63\xed\x87\xa5\xb5\x35\x5c\x0c\xdd\x9c\xad\x2a\xb0\xb5\x29\xc2\x60\x4f\xac\xb4\xfa\x6e\x47\x36\x71\x86\xa8\x8a\x52\x80\xa5\xb5\x4c\xe5\x83\x95\xfa\x53\x1d\x83\x71\xf6\x7b\xbe\xf5\xee\x66\xce\x69\x1e\xa2\x1d\x14\xfb\xb3\xa0\x25\xd7\xa1\x50\x23\x3c\xe3\x05\xfc\x7a\xa8\x09\xde\xfc\x75\xb1\xe7\x6c\x3b\x7d\xd5\xd3\xe2\x1c\xae\x5d\xc4\xda\xc9\x3b\x0f\xd2\xb0\xb9\xe0\x8f\xe8\xbd\xeb\xd0\x3b\x76\x80\x8a\xf5\xc0\xb9\xf6\x04\xcf\x65\x6c\xac\x18\xb2\x0a\xe3\x8c\x60\xb6\x91\xf3\xaa\x6d\x39\xd5\x4e\x08\x80\x4f\x17\x3b\x21\x3e\xed\xac\x85\x55\x6b\xbf\xc8\x96\x5d\xba\xe1\x25\x3e\xad\x8d\x8d\xf8\x2c\x89\x0c\x80\x6b\xe8\x4d\x61\x37\x02\x4d\x8f\x6e\x1f\x69\x51\x64\x70\x15\x21\xdb\xee\x02\xe9\x6e\x2f\xc3\xc7\x43\x6a\xe7\xb5\x7c\x8c\x1c\x0c\xed\x72\x0e\x35\x22\x95\x3d\xb1\x33\x5e\x38\xef\x2d\xb4\x4e\x78\x7f\xed\x6f\xc1\x6e\x54\xf9\xd0\x5b\xde\x77\x25\x06\xe4\xbd\x34\xf6\x7f\x97\x60\x03\x1a\x90\x0b\xc9\xf4\x7b\x69\xe0\xcf\x11\xf9\xca\x20\x0e\xbf\x6d\xe9\x75\xf2\x00\xa0\xe0\x3c\x77\x06\xc9\x99\x40\xba\x00\xd6\xb9\xc8\xbb\x1b\x1d\xe7\x40\xa4\xf2\x87\x90\x6b\x72\x25\xac\x90\xe6\x96\x1e\x4c\x5c\xda\x0d\xe1\x65\x79\x21\xc5\x10\x7d\xaa\x56\x8d\x71\x19\x1c\xca\x62\x98\x6d\x18\x6e\xfd\x50\x5f\x81\xcd\xf3\xed\xda\xce\x33\x3a\x67\x95\x3f\x9e\x13\xa2\xbc\x57\x9e\xb7\x02\x82\x13\x7f\xa1\x58\x65\x08\x74\x37\x44\x56\xe8\xe4\x7e\x3c\x0c\x21\xc8\x68\xc2\x52\x92\x82\x88\x87\xee\xf0\xd4\xb0\x29\x4f\x48\xce\xd4\x94\x91\xc2\x72\x81\xee\x3b\xde\x9e\x30\xe3\xd3\x89\x3c\xc7\x1f\x6a\x8d\x5a\xc0\xce\xe0\x46\xfd\x09\x38\x99\xd3\x5f\x7b\x4e\xd6\x73\xb2\xad\x4f\xcf\xc9\x7a\x4e\xb6\x06\x24\x3d\x27\xeb\x39\x59\xfd\x41\xbd\xb0\xa3\x12\xfa\x1d\x9a\x03\x9a\x5a\x27\x70\x44\xef\xb8\x5f\x57\x3f\x2d\x9f\xb8\x71\x44\xe4\x16\x54\x56\x67\x76\x57\x54\x4c\x19\x79\x3d\x7c\xfd\xea\x55\x5b\xe5\xb4\xad\x73\x0a\x7a\xfb\x40\xfb\xff\xfa\xcd\xda\xd6\xeb\x6c\x52\x0f\xb4\x22\x3a\xfc\x0d\x86\xad\x1a\x5f\x5f\x63\x08\x04\x6a\x23\xa4\x21\x39\x33\x84\x9a\x9a\x19\x85\xe7\x6c\xe0\x0d\xab\x2e\x54\x01\xbd\xf5\xbd\x45\x32\x25\x52\x38\xbb\x96\x05\xf6\x68\xb7\x19\x24\x8c\x6a\xf0\x85\x19\xb3\x30\x0b\x99\xdb\xaf\x72\x61\xfc\x51\xb0\x53\x60\x1e\x22\xe4\x88\x8d\xa6\x23\x92\x96\xd0\x8d\x0a\x17\x15\x75\x8c\xb3\xd5\x0b\x6d\x58\x0e\x96\x4d\xa9\xe0\x7f\x76\xda\x46\x81\xcf\x39\x5c\x26\x97\x34\xcb\x16\x84\xcd\x79\x62\xc2\xfa\x20\xce\x91\x1b\x34\x36\x6f\x37\x99\x6d\x65\xf1\xed\xd8\xfa\x70\x09\x4b\xd7\x5f\xba\xb6\xe7\xcc\x4b\x63\x6e\x3b\x6b\x0d\x1e\x86\x33\x1f\xad\x15\x18\xc1\x1f\x16\x6d\xbf\xe8\x1a\x6b\x91\xe8\xc3\xc7\xcd\xa6\x46\xd2\x89\x1a\xb5\xa4\x40\x4d\xd1\xb0\xcc\x32\xbb\xe9\x68\x7d\x5c\x9e\xf4\x0a\xab\x20\x2e\xa3\x86\xa8\x68\x64\x46\x73\xea\xd9\xfb\x0b\x0b\x09\xdb\xe6\x56\x16\x32\x93\xd3\x45\x0c\x59\x58\x11\xd8\x2c\x5d\x5f\x0c\x39\x64\xc1\xe1\xef\x7d\x63\x2b\x7a\x6b\xd8\x96\x85\xf7\x3a\x44\xaf\x43\xb4\x7a\x7a\x1d\xa2\xd7\x21\x7a\x1d\xe2\xe7\xaa\x43\x90\xde\x1a\xd6\x73\x32\x78\x7a\x4e\xd6\xe2\xe9\x39\xd9\xbe\x80\xd2\x73\xb2\x9e\x93\xb5\xfd\xd0\x06\xd4\x8a\x55\xf4\x56\xde\x70\x87\xb1\x26\xd9\xa0\xed\x08\x60\xbf\x7f\x46\x95\x2c\xf6\x89\xb3\xc7\x6c\xc2\x0d\x91\xc2\xb9\x78\x8d\xc8\xcd\x8a\x9e\xc0\x4d\x5d\x8b\xc3\xa0\xba\x35\x07\x6a\x58\x7f\x90\x40\xe1\xa0\x1d\x1d\x2c\x6b\x89\x7b\x4e\xa8\xd6\x7c\x2a\x86\x85\x4c\x87\x76\xb4\x93\x75\xee\x91\x2d\x58\x4a\x9c\x78\x6f\x3b\xed\xde\xba\x53\x85\x4c\x77\x74\x5b\xb4\x20\x5b\xef\xb5\x88\x36\xac\x44\x0e\x33\x09\xf1\x02\x60\x11\xb3\x5d\x7c\x98\x2e\xcd\xd1\xac\x36\x20\xff\x94\x82\xa1\x6b\x9a\x3d\x31\x60\x1c\x43\x4f\xd3\x42\xa6\x47\xfa\x78\xad\x0b\x53\xef\xf5\xd8\x7b\x3d\xbe\x48\xaf\xc7\x19\xd5\xb8\xaf\x8e\xfe\xac\x75\x82\x8c\x0e\xdf\x2d\x53\xf9\x67\xe4\x03\x69\x51\xc4\x6d\x31\x44\xd7\x54\xdb\x88\xab\x4d\xdd\x8d\x06\x4b\xaf\xeb\x6b\x74\x9a\x06\x2c\x84\xa6\x29\x4b\x49\xc1\xd4\x10\xd1\xc2\x12\x72\x91\xae\x58\x9f\x87\xc9\x93\xfb\x32\xd6\xe7\xfe\xc4\x0e\x8d\xf5\x8f\x77\xb4\x16\xc7\x66\xee\x1a\xa5\x7e\x56\xf7\xc6\x6e\xf1\xaf\xc6\x99\xa4\xbf\xde\x7b\x1c\x2c\x70\xff\x6d\x02\x4a\xfd\x69\x6a\xd7\xa0\xc4\xfc\x58\x32\xb5\x20\x72\xce\x54\x25\xea\x47\xc1\xef\xc0\xeb\xb8\x26\x09\xd5\x48\xe9\xbb\x28\xd8\x1d\x14\xcb\xee\x5a\xdc\x6e\xb6\x72\xd2\x84\x43\x73\x98\x7a\xdc\x25\xc2\x68\xa5\xe9\x61\xc5\xbd\x44\x75\x1f\xd1\x7a\x2e\xbb\x08\xbc\x9d\xc5\xdd\x95\x1b\xff\x42\x4d\x12\x64\x37\xb3\x04\xd9\xc9\x34\x41\x3a\x9b\x27\xc8\x2e\x26\x0a\xb2\xa3\x99\x82\x74\x37\x55\x90\xe6\x76\x43\x34\x9b\x76\xc1\xb3\xfb\xb6\x5a\x90\x5d\x95\x74\xb2\xa3\xf5\x62\x69\x79\x01\xfd\xd4\x63\x99\x32\x00\x87\x6b\xd6\x8c\xa7\x02\x50\x77\x4b\xc6\x12\x78\x9c\x09\x80\x83\x1a\xff\x99\xd8\x35\x1e\xdd\xc8\x40\x76\x36\x34\x90\xdd\x8c\x0d\x64\x37\x2c\x00\xd6\xf4\x16\xb4\xfc\x87\x30\x37\x1c\x01\x49\x7b\x4e\x0b\x8b\x00\xff\xb2\x14\x1c\xf6\xe0\x3f\xa4\xa0\x5c\x69\x2b\x63\x39\xab\x50\xfc\x9b\xd3\x74\xe3\x61\xec\x08\x5c\x13\x4b\x6a\xe7\x34\xb3\x3c\x03\x3d\x3c\x9c\xce\x61\x47\x6f\xb2\xd4\x01\xb9\x9f\x59\x4d\xce\x52\x1e\xd4\x44\xb8\x26\x07\x77\x6c\x71\x30\x58\x42\x9a\x83\x2b\x71\x80\xbc\x65\x09\x4d\x02\x23\x82\xa4\x52\x07\xf0\xdb\xc1\x3e\xb9\x70\x47\x86\xd3\xcd\x8c\xb1\xee\xa3\x9d\x92\x85\x40\x3e\x97\xfd\x0a\x7d\xc8\x05\xf0\x9a\xc5\x7f\x41\x57\x0c\x02\x9c\x32\x22\xe6\x10\x7c\x4a\x00\x9f\xe0\x7d\xea\x95\xc8\x52\x44\x59\xdb\xa2\xc1\x90\xc9\x2c\x3b\x36\xb9\x4d\x96\x02\x32\x83\x69\xdb\xc2\x21\x5c\xd4\x19\xda\x8e\xd0\x71\xa4\xe2\x56\x22\x6d\xba\x92\x54\x3d\x40\x76\xcb\x19\x15\x9a\x1c\x78\x9b\x4d\x9c\x0f\xe7\x60\x54\xc5\xbf\x85\x11\x8f\xfe\xf5\x9f\xe3\x5a\xcc\x5b\x35\x60\x2f\xf1\xf6\x12\x6f\x2f\xf1\xf6\x12\x6f\x78\x7a\x89\xf7\xb1\x00\xd4\x4b\xbc\xbd\xc4\xdb\x4b\xbc\xbd\xc4\x8b\x4f\x25\x82\xed\x20\xea\xc6\xf2\x67\x48\xfb\x49\x21\xf7\x32\x4f\x2a\xcf\x22\xdf\x0a\xff\xb5\x5f\xb9\x37\x96\x69\x57\x4b\xbd\xb1\x64\xbc\x24\xdf\x8f\xb6\x88\xb8\x41\x08\x5e\xea\xb9\x59\xfa\x7d\x7e\x0f\xa9\x8e\x78\x10\x19\xd1\x77\x4a\xfd\xe8\xae\x6d\x5d\x91\xaa\x31\xab\xee\x74\x53\x72\xe4\x6f\x15\x8e\x5d\xa5\x86\xfa\x8f\xc2\xf0\x61\xd5\x22\xdc\x33\xc0\xd5\x58\x2d\xb2\xa5\x66\x8e\x5f\x4e\xe4\x5c\xed\x9d\x25\x0d\x4c\xd5\xe6\xc0\xab\x74\x75\x54\x13\x55\x0a\x61\x47\x0d\xde\x00\x8e\x96\x60\x52\x3c\x87\x65\x28\xd8\xc0\x7c\x30\x57\x7f\x80\x50\x74\x57\x87\x59\x6d\xa9\x70\x8e\xf6\x52\xf8\xb2\x1a\x22\x4a\x84\xe9\x10\x10\x56\xc4\xc3\xd7\x47\xe4\x12\x70\x2e\x1e\xd8\x15\x7d\x80\xa2\x1c\x6d\x49\xcd\x63\x07\x1d\xdd\x77\x0e\x3a\x6a\xdc\x49\xf5\x31\x47\x3f\xd1\x98\x23\xf8\x11\x8f\xc9\xde\x83\x8f\x30\x97\xa5\x81\x73\x6c\x41\x15\xb2\x58\xfa\x8b\x77\xfc\x54\x86\xd2\xe0\xc4\x79\x46\xd4\xf1\xd0\x67\x9b\x6b\xe0\x23\x8c\x07\x1e\x58\x1a\x0e\xa6\xf3\x3e\xa0\x59\xe6\x22\x79\xbc\xe8\x88\x2e\x16\xfc\x39\x6e\xce\x2f\x7c\xa1\x34\xaf\x5d\x00\xf1\x38\xb2\x34\x2e\xb3\x9b\x68\xa9\xd5\x06\xe2\x88\x4a\xca\x9c\x79\xf6\x39\xe5\x73\x26\x2a\x0a\x79\xa4\x8f\x8f\x3d\x1f\xde\x2b\xe5\x7e\x14\xca\xfb\xc7\x88\x42\xfe\xa9\x0d\xed\x85\x05\x05\xea\x5b\x81\xaf\xa2\xbd\x4f\xed\x22\xd0\xf6\x8e\xba\xbd\x3e\xdf\xf1\x6e\xfa\x89\xee\xa5\x5f\x76\xdc\xd6\x33\x5a\xe5\x9e\xd2\x1b\xfe\x45\x5b\xe2\x7a\x77\xf8\x56\xcf\xd3\x59\xdb\x9e\xc7\x2b\xfe\x85\x5b\xd8\x9e\xc3\x2b\xbe\xb7\xaa\xad\xdd\x88\x97\xe0\xac\x5e\x7f\x3a\x5b\xd1\x7a\x0b\xda\x4e\x1c\xb3\x03\xa3\x78\x88\xe5\xac\xc3\xee\xef\x70\x47\xdc\xdf\x0f\x3f\xfe\xfd\x70\x2f\x79\x6e\x04\x4c\x2f\x79\xf6\x92\x67\xbb\xa7\x97\x3c\x7b\xc9\xb3\x97\x3c\x7b\xc9\xb3\x97\x3c\x5f\xac\xe4\xd9\x35\x27\x54\x7f\x4f\xbb\xf3\x3d\x6d\x17\x2a\xd0\xfa\xec\x77\xd8\xf3\x4e\xf7\xb2\xfd\x9d\xec\x4b\xb8\x93\x6d\x15\x4c\x2d\x0c\x7f\x48\x40\x75\xbc\x3f\xeb\xa2\xaa\xe9\x5c\xf2\x94\x14\xa5\x71\xb1\xab\x7d\x64\xf5\x2e\x91\xd5\x35\x48\xf7\xe1\xd5\xad\xc2\xab\xd7\xc1\xac\x8f\xb1\xee\x63\xac\x6b\x4f\x1f\x63\xdd\xc7\x58\xf7\x31\xd6\x7d\xc4\xc9\x2e\x0b\x7e\xe1\xd6\x46\xd2\x47\x9c\xd4\x9e\x3e\xe2\x64\xe3\xf2\x5e\xb8\x55\xf2\x41\x00\xea\x23\x4e\xfa\x88\x93\x3e\xe2\xa4\x8f\x38\xc1\xa7\x8f\xb1\x7e\xb1\x77\xe8\xa4\x97\x78\x7b\x89\xb7\x97\x78\x1b\x4f\x2f\xf1\x36\x9f\x5e\xe2\xdd\xf2\xf4\x12\x6f\x2f\xf1\xf6\x12\x6f\x2f\xf1\xe2\xd3\xc7\x58\xf7\x31\xd6\xa4\x8f\xb1\xfe\x5c\xef\xf3\x3b\xee\x74\x1f\x63\xfd\xa8\x31\xd6\xb5\xbb\xe5\xe7\x0b\xb4\xee\x3e\x8d\x3e\xda\xba\x8f\xb6\xee\xa3\xad\xd7\xed\x68\x1f\x6d\xdd\x47\x5b\xf7\x31\x2f\x7d\xcc\xcb\x8a\xa7\x8f\x79\xe9\x63\x5e\x56\x3c\x7d\xcc\x4b\x1f\xf3\xb2\xf6\xe9\x6d\x69\x3f\xb5\x98\x97\x3e\xda\xfa\x25\xdd\x14\xf7\x92\xe7\x46\xc0\xf4\x92\x67\x2f\x79\xb6\x7b\x7a\xc9\xb3\x97\x3c\x7b\xc9\xb3\x97\x3c\x7b\xc9\xf3\xc5\x4a\x9e\x7d\xb4\x75\x1f\x6d\xbd\xea\xe9\x6f\x67\x5f\xc2\xed\xec\xd6\xdd\x0d\x26\xf6\x56\x71\xd6\x87\x1f\x7d\xf3\x58\x62\xf1\xf1\xaa\x2a\xfa\x11\x65\xd5\xa0\xe1\x39\xea\xc8\xd4\x88\x5c\xe5\x79\x69\xe8\x38\x7b\x68\x39\xf0\x9c\x0a\x3a\x65\x43\xf7\xf1\x61\xf8\xf8\x30\x7c\xeb\x21\x15\xc2\xdb\x08\xb7\x19\xcf\xb9\xd9\x78\xc8\xea\xc0\x7b\x0b\xed\xdd\xcb\xb1\xd3\x1f\x72\xfa\x89\xe7\x65\x4e\x68\x2e\x4b\x64\x50\xcb\xe0\xf4\xdb\xbd\x17\x80\xad\x00\x94\x5e\x0b\xa9\x96\xd0\x22\x3b\x31\x9e\x82\x1a\xc3\x94\x38\x25\xff\xef\xe8\xaf\xbf\xfe\xf7\xf0\xf8\xcf\x47\x47\xdf\xbf\x1a\xfe\xef\x1f\x7e\x7d\xf4\xd7\x11\xfc\xe3\x57\xc7\x7f\x3e\xfe\xb7\xff\xe3\xd7\xc7\xc7\x47\x47\xdf\x7f\xfd\xee\xab\xdb\xeb\xcb\x1f\xf8\xf1\xbf\xbf\x17\x65\x7e\x87\x7f\xfd\xfb\xe8\x7b\x76\xf9\x43\xcb\x41\x8e\x8f\xff\xfc\xcb\x8d\xd3\xa2\x62\xf1\x61\xd2\xe2\x1a\xad\x83\x77\xc0\xb0\x3d\x99\xfd\x34\xac\x76\x74\xc8\x85\x19\x4a\x35\xc4\x6e\xa7\x50\xb6\x7f\xa3\x67\x01\xd3\x5d\xf0\xf1\xa3\xeb\xd1\xc4\x48\x2e\xb6\x62\xa4\x0a\x51\xbb\x57\x13\x12\xc6\xe1\x9a\xc8\x9c\x1b\x4b\xcb\x26\x56\x13\xab\x8e\xfd\x80\x70\x63\x09\x2c\x2d\x33\x03\x09\x05\xdc\x59\x80\x68\x74\x0c\xe0\x67\x9f\x8a\x8c\x27\xdc\x64\x8b\x8a\x66\x0f\x30\xd5\xc2\x3d\x47\xdf\x00\x2a\x08\xcf\x0b\x14\xe5\x00\xa7\x87\x9e\x66\x03\x61\xee\xcf\x47\x7f\x3e\x56\x9f\x0f\xbd\xc5\x3c\x5a\x3b\x17\x95\x04\x11\x1b\x1b\x82\x7d\xc1\x62\xb6\x4f\x8b\x01\x72\x0c\xe2\x90\x3d\x0b\xa0\x2e\x5a\xb9\xe1\x23\xb3\xb8\x4c\x6f\x98\xd1\x4e\x72\x80\x1e\x56\xf6\x5f\x32\x7e\x82\x63\xcd\x98\x55\xc2\x27\x9d\x4c\xea\x2d\x52\x56\x64\x72\x61\x91\x7e\x44\xae\x0c\x2a\x9f\x20\x61\x04\x77\x15\xc3\xf2\x22\xa3\x86\x1d\x6a\x9c\xed\x5a\x3b\xd4\x9e\x38\x5f\x17\x2b\xe4\xf3\xda\x1e\x1f\xc7\x23\xe6\x45\x5a\x17\x1f\xc1\x55\x64\xbb\xfd\xb0\xa5\xd5\xb0\xbd\xad\xb0\x95\x85\xf0\xb1\xed\x82\x1d\x94\xa2\xf6\x36\xc0\x97\x6f\xf9\xeb\xb0\xec\xb6\x56\xbe\xde\xb6\xb7\x09\xd4\xcf\xa1\xcb\xb7\xb4\xd9\xf5\x96\xba\x0e\xfc\xe5\x11\x84\xbf\xad\x7b\x69\x64\xc6\x50\x72\x6d\xa7\xbb\xdf\x56\xed\x43\x76\x26\xb4\x41\x45\x23\x6d\x96\x1b\x36\xa1\xeb\x16\x24\x5d\x4a\xca\x04\x62\x8b\x3d\x5b\xd5\xbc\x00\xb5\x8c\xa1\x90\x96\xc9\x48\x3f\x2f\xbb\x71\x62\x41\xec\x9e\x19\x97\x97\x2b\x4a\x54\x65\x14\x78\xe2\xfe\x31\x60\xdb\x80\x81\xfc\xf4\x27\x52\x6a\x6f\x18\x0a\x56\xa2\x80\x21\x7f\xf4\xff\xfa\xd3\xfa\xcd\x6d\xb5\xb5\xed\x18\x1b\x4e\xa9\x83\x80\x71\x09\x1d\x08\x17\x29\x4f\x82\x30\x80\x10\xc0\xb1\x2c\x7c\x60\x59\xde\x4a\x84\xa6\x45\x14\x0b\xc1\x7b\x38\x6a\xac\x9d\x07\x73\xa4\x57\x39\x93\x42\x75\x32\x18\x79\x2f\x9d\x3b\x3a\x1b\x90\x6b\xc8\x68\x55\xbd\x81\x93\xf4\x5e\xa2\x63\x3a\x6b\x23\x87\x6c\xe5\x22\x5b\x19\x7d\x0d\x20\x5f\x57\x4c\x1e\x57\x56\x63\xf2\x15\x06\xd7\x6c\xc3\x9b\x20\x73\xc7\x16\x15\xb3\x71\x22\x04\x90\xfc\x41\x85\x25\x9e\x15\x20\xef\xf8\x6f\x6f\xca\xca\xc7\x5c\xe0\xc7\x70\x68\xbf\x15\x30\xba\x07\xa8\x95\xec\xb2\x0c\x3f\xb3\x0f\x70\xb5\x93\x33\x6a\x30\xfb\xd0\x41\xc6\x08\x54\x72\xb5\x74\x11\x89\x14\x97\x3f\x96\x34\x1b\x91\x8b\x48\x99\x77\xaf\x5c\xa3\x25\xaa\x7e\xcf\xb3\x34\xa1\x0a\x8d\x02\x78\x46\x89\x96\xb8\x7b\xe8\x1f\x9d\x50\x11\x4e\x7b\xb5\x47\x98\xb1\x8d\x14\x54\x19\x9e\x94\x19\x55\xc4\x9e\x85\xa9\x54\x8b\xbd\x40\xb4\x42\x9a\x1b\x96\x48\x91\x76\x4a\x2b\xd7\xec\x1b\xc3\x18\x28\x2b\x53\xdc\x39\x7e\xf3\x9c\x35\x91\xf4\xc8\x25\xdc\x73\xf8\x25\x27\xfe\x54\x87\x23\x56\xb3\x7c\x54\xb7\x14\x5c\x13\x8e\x91\x22\xc7\x11\x79\x0c\xa7\x62\x44\xbe\x5c\x78\x33\x0b\x98\x5c\x9c\xbd\x58\x33\x33\xf0\x49\xfe\x1c\xca\x3a\x60\x57\x07\x6a\x22\x15\x9b\x33\x45\x8e\x52\x09\x7d\x20\x20\xe2\x78\x44\xfe\x3f\xa6\x24\xde\x69\xb0\x29\xfa\xf1\x3b\x14\x0f\x8a\x2b\xa4\x55\x04\xbb\xf9\x2b\x72\x84\x71\x14\x3c\xcf\x59\xca\xa9\x61\xd9\xe2\x18\xf5\x58\x1f\x89\xd1\x66\xeb\xda\x18\x0d\xa2\x70\x9b\xdf\xfd\x76\x43\x4b\x98\x6c\x87\x9d\xfd\x16\x4c\xfc\x35\x52\x83\x56\xff\xc6\x16\x06\x1e\x24\x37\x88\x9b\x91\x78\x19\x5d\x7d\x78\x32\x13\x36\xf8\x1f\x16\x0f\x28\x51\x6c\x0a\x58\x8e\x98\xfb\x40\x1c\x9f\xcb\xac\xcc\xd9\x3b\x59\x8a\xf5\x26\xc1\xda\xc2\xdf\x3a\x25\xfc\xdb\xa8\x23\xe4\x02\x65\xc6\xcb\x6f\x95\x15\xff\x49\xc4\x84\x68\x26\x91\x89\x92\x12\xb0\x4b\x02\x3b\xb7\xe4\x01\x5b\xc1\x3d\x0c\x17\xb1\xcd\xf1\x81\x9c\xbd\x8d\x96\x3c\xc4\xb9\x5c\x53\x33\xdb\xd8\x4a\xd0\x7c\xbd\xe1\xb6\x9d\x08\x11\x3e\xd4\x01\x97\x6d\x73\x0f\x98\xda\xfe\x11\x6a\x1c\x39\x00\xfc\x44\x08\x56\x08\x0a\xdf\x62\xe9\x88\x90\x77\x16\x33\xf1\x46\x0e\xba\x92\xc3\xd3\xc3\xbd\x10\x5f\x5c\x8e\x92\x05\x9d\xd2\x6d\x91\x6e\x4d\x65\xa4\xd1\x95\xa4\xcc\x30\x95\x43\x88\xd2\x4c\xde\xe3\xef\xc8\xb6\x0a\xd7\x8a\xb9\x88\x2e\xc8\x52\x2a\x35\x70\xa5\x08\x18\xfe\xea\x17\xd2\xfa\xde\xd3\x05\xa1\x4a\x96\x22\x75\x52\x53\x20\xa0\xef\x1a\x1f\x7e\x2f\x05\x50\x8a\x52\x5b\x58\xdd\xd6\xa8\xf4\x98\x19\x6a\x8f\xcd\xeb\xd1\xeb\x2d\x91\x86\x2d\x01\x66\x51\xa8\x53\xde\x53\xae\x9b\x96\xc2\xf7\x34\x67\xf1\x99\xd9\xcb\xbc\x14\xa3\xe9\x07\x91\x75\x91\xe5\xde\x21\x7a\x41\xd7\x21\x28\x61\x7c\x02\xb6\xdb\x01\xbe\xba\x57\xdc\xb0\x88\x3c\x1e\x4d\x68\xa6\x21\x1d\x70\x29\x82\x08\x7b\x5c\x17\x41\xa0\x49\x9b\x05\x8d\xa5\xcc\x18\x15\x1b\x5a\xea\x72\xfc\xc0\x73\xe6\x0e\x14\xa0\x5c\x75\xcc\x02\xc2\x1d\xea\x0d\x47\x2e\x5e\xd4\xc1\x01\x39\xc2\x96\x56\x62\x93\xd2\xac\x4d\x36\x1d\xaf\x70\xeb\x96\xb9\x05\x5a\xcd\xba\x8b\x4a\xf2\xa9\xa0\x02\xf2\xe0\xee\x71\xb5\x5f\xb2\x19\x9d\x33\x4d\x34\xcf\x79\x46\x55\x06\x51\x99\x37\x38\x3f\x48\x15\xcd\xc4\x9c\x2b\x29\xc0\x24\x30\xa7\x8a\xd3\x71\x66\xd5\xf4\x09\x53\x4c\x24\x4c\x93\x5f\x1e\x7d\x7b\xf6\xf1\x6f\xef\xcf\xde\x5d\x1e\xc3\x89\x67\x7e\x96\x95\xf6\x17\xcf\x24\x1a\x6e\x2b\xa8\xfd\x3c\x2c\x9c\x80\x46\xf8\x79\x61\x08\xa8\x8f\x1b\xfd\x94\x64\xa5\xe6\xf3\x87\x9e\x26\xfc\xf8\x2e\xac\xba\xc9\xa5\x0b\x99\xde\x14\x2c\x79\x4a\x1e\x5d\xd7\x30\x2c\xa9\x4a\xfd\xa6\x03\x4f\x46\x65\x9f\x62\xda\xef\x31\x23\x34\x49\x98\xd6\x78\xc5\x61\x75\xfb\x8a\x16\x57\x6b\x78\x12\xf6\xbd\x07\xc6\x4c\xef\xf5\x65\x46\xb5\xe1\xc9\x97\x99\x4c\xee\x6e\x8c\x54\x5d\x08\xf5\xe1\xaa\xfe\x35\x78\x0a\x72\xf6\xdd\x0d\xb9\xe0\xfa\x2e\x5c\xc0\x86\x4b\xd3\xd8\x5c\x42\xc9\x5d\x39\x66\x19\x33\x87\x87\x1a\xb9\x5c\x4e\x93\x19\x17\xcc\x33\x38\x61\x4f\x87\xd4\x95\x83\x94\x85\x72\xd7\x3b\x53\x6d\xa4\xa2\x53\x76\xe2\xf0\xf5\x17\xf4\x5e\x33\x9c\xfe\xd8\x4e\xdf\xfe\xcc\x36\xdd\x96\x3e\xca\x3d\x05\x4e\xe6\xea\x62\x4f\x77\x10\x13\x7d\x6b\xe7\xd8\xcd\xb8\x7d\x88\xbd\xbc\xea\x30\xe1\x19\x73\xb1\xe7\x76\xc1\xde\xd9\xc7\x9d\x0a\xd8\xbf\x85\x2c\xc9\x3d\x45\x1d\x19\x28\xe2\x88\xdc\xf2\xe2\x94\x5c\x0a\x5d\x2a\x56\x59\x37\x9a\x43\x71\x4d\x74\x59\x14\x52\x85\x4b\x42\x27\xd5\xa0\x02\x62\xe9\x9e\xd3\xb5\xc8\xe5\x27\x9a\x17\x19\xd3\xa7\xe4\x80\x7d\x32\xbf\x3d\x18\x90\x83\x4f\x13\x6d\xff\x27\xcc\x44\x1f\x8c\xc8\x55\x1e\x6e\xdd\xb9\x70\x49\xcc\xf1\x62\x13\x3b\x58\xd6\x1c\x71\xdd\x47\x41\x17\x72\xfb\xe1\xe2\xc3\x29\xc8\x6e\xa9\x24\xf7\x56\x6c\x83\xc0\x7c\xc2\x94\x92\x4a\x7b\x9a\x10\x81\x01\x78\x4d\x22\xf3\x42\xc9\x9c\x47\x66\x3e\x40\xf7\xcd\xd8\x47\xba\xdd\x73\x80\xf1\x61\xbb\x80\xba\x8c\x0d\xa1\xa3\x47\x88\xe8\x85\x68\x83\x0a\x57\x13\xef\x4c\x81\x5a\xa4\x53\xeb\x61\x38\xd7\xc8\x6e\xbe\x1b\xc5\x12\xb2\x78\xbb\xdf\x48\xe5\x7f\x3a\x49\xd9\xfc\x44\xa7\xf4\xf5\x00\x3e\x83\x7b\xb9\x68\xcc\x89\x6a\x72\xf0\xfa\x60\x44\x6e\x3c\x23\x1e\xc4\x73\xac\xda\x4d\xa4\x0a\x03\x82\x9d\xfd\xd5\x01\x39\x92\x0a\x46\x4e\xa8\x20\x19\xa3\x73\x67\x5b\xc6\xe3\xb6\x40\x75\xf7\x78\xd4\x76\x5b\xf6\x9b\x6f\x03\x9f\x76\x42\xea\xf2\x26\xfa\x7e\xde\x04\xa0\x4a\x86\x66\x8f\x89\x44\x2a\xcc\xc2\xd0\x96\x03\xc3\xd1\xe3\xa2\xa6\x42\x3f\x03\x81\x25\x1d\x84\x5d\x12\x44\x8f\xab\x8b\xae\xd0\xf1\xfd\x40\x07\x12\xfc\xc7\x92\x91\xab\x0b\x4f\xe8\x0a\xa6\x34\xd7\xc6\x1e\xe3\xb4\xc6\xba\x38\xf2\xb3\xa3\xb3\x9c\xfe\x53\x0a\x72\xf9\xe5\x8d\x9b\xc0\xf1\xb3\x82\x6a\x2b\x35\xa0\xff\x2c\x15\xb3\x5c\xb8\x03\x73\x0f\x7d\x9a\x0c\xdd\xbe\x27\x17\xd4\x50\xe4\xeb\xce\xd3\x4a\x54\xa4\xdc\xb2\xec\x31\x17\xa9\xfb\x29\x62\xd8\x4f\xcd\x5b\xed\xee\xbd\xdf\x24\x26\xc5\x0d\xbf\xf9\x78\xb5\x27\x1e\x9c\x00\x31\x9f\xbe\x93\x69\x67\x46\x1c\x75\xf5\xc4\xf7\x2f\x16\xa6\xe7\xf8\x9e\xe4\x76\x4c\xf2\x1e\xea\xfa\x7c\x64\x34\x25\xf6\xfc\xba\x7f\x7e\x67\x75\xcf\xd6\xb4\xaa\x15\x0b\xf1\x00\xec\xb8\x0c\xdf\xcd\x2f\xc1\x6b\xef\xc0\x0b\x2c\xe6\xc0\xb1\x72\xbc\x64\x9c\xc9\x31\x71\xc7\x61\xdf\x73\xff\xe6\xe3\xd5\x0e\x53\xff\xe6\xe3\x95\x9f\xb9\xfd\xa7\x9c\x3c\xdd\xa4\x77\x12\xdf\x2a\xe9\xed\x4d\x43\xdc\xaa\x58\xf2\x3b\x67\xaf\xa7\x4b\x22\x59\x7b\x79\x6c\xb4\x2f\x49\x6c\x9f\x10\xbb\xe3\xa2\x45\x5c\x61\xfd\x94\xd9\x3e\x56\xa1\x40\x5f\xb5\xe8\x1e\xf1\x66\x46\x2d\x61\xa9\xb2\x24\xc1\x3e\xdb\x8d\xd7\x96\x2b\xf8\x1d\xb7\x4a\x20\xd0\x36\x72\xc1\xf0\x96\x33\x3d\xf5\xbe\x03\xa1\xc7\xea\x0e\xef\xc0\x53\x33\x75\xf4\x95\xa0\xe3\x66\x1a\x21\xd8\x11\x5a\x95\x44\xf8\x89\xce\x29\xcf\xe8\x98\x67\x50\x11\x8c\x59\xed\x3e\xf6\x46\xd5\x30\xe5\xbd\x9e\xfa\x1d\x45\x8e\x20\x4e\x2c\x19\xb7\xc8\x91\xfd\xed\x04\x8c\x63\xc7\x23\xa0\x56\xd0\x10\x22\x19\x1a\x42\xc9\xc7\x6d\x42\xc9\xde\xe4\x07\xd8\x01\x7b\x62\xba\x72\x45\xdb\x67\x25\x57\x84\x1f\x6e\x98\x9a\xf3\x84\xbd\x68\xc6\xa8\x59\xa2\x98\x69\xc5\x1a\x01\xbf\xb6\xb6\x6c\xcf\x1c\x1f\x8a\x5c\xe9\xe7\x81\x5c\x04\x5c\x77\x3d\x94\x3b\x2e\xb6\xea\xe8\xf9\x10\x28\x49\xe0\x71\x06\x3f\x35\x5c\x33\x11\xfb\x6e\x1c\xad\x39\x73\xb4\x06\xfa\x5b\x9c\x6b\x53\xdb\xa9\x03\x79\x08\x18\xd1\x75\x55\xbe\x9f\x5f\x14\x92\x40\x78\x4d\x5a\xe0\x62\xeb\x49\x26\xac\x98\x4d\xba\x5c\x89\xdb\x0e\x6f\x6e\xea\x96\xc0\x73\x56\xcc\xc8\x9b\x9b\x15\xc7\x18\x4b\x09\xda\x59\x6b\xb4\x0f\x1e\x6a\x92\xf1\x09\x33\x7c\xcb\x12\x1e\xe1\x20\xe7\x52\x70\x23\x95\xde\xd3\xe1\xf4\xc3\x75\x65\xa8\xbe\x9f\xdd\x59\x5f\x15\xed\x94\xbc\x8b\xde\x52\x92\xc8\x2c\x63\x89\x71\x71\x8d\x00\xde\xd0\x6d\x85\xf2\xc4\x9c\x3d\x60\x74\xf7\x07\x50\x9f\x9c\xa2\x74\x82\x9b\x7b\xf2\xf1\xf2\xec\xe2\xdd\xe5\x28\x4f\x7f\x31\x93\xf7\x43\x23\x87\xa5\x66\x43\x6e\xda\xf2\xc1\xe7\x8b\x44\x2c\xb6\xde\xcf\x90\x15\x06\x19\x33\xb3\x40\xfc\x50\xa0\x23\xde\x29\xf9\x46\xa3\xd7\x02\xd8\x8e\xfc\x9d\x94\x94\x66\x40\x14\x85\xab\x40\x33\xa3\xce\xf4\x54\x66\x19\x42\xdb\x28\xc6\x06\xb1\x2d\x66\x63\x68\x48\xe7\x85\x3d\xd8\x50\x51\x5b\xe0\xe3\xca\x10\x4f\x8f\x70\x5d\x38\xc6\x76\x99\x64\x19\x8a\x55\xcf\x3a\x1c\x6f\x6a\xef\xd1\x70\x66\x66\x16\xaa\x77\x6c\x41\xc0\x11\x78\x22\x95\xc5\x27\x55\xc7\x0d\x66\x12\x58\xfa\x49\xa9\x99\x1a\x39\xb6\xf3\xe4\x60\x6b\xc7\x90\x60\x72\x1f\xd9\xd6\xc8\x9e\xd5\x40\xfb\xc8\x26\xab\x60\xe6\x5e\x87\x0b\x3b\x2f\xaf\xd1\xd2\xcc\x98\x30\x56\xec\xb7\xb4\xcc\x41\x66\x25\x10\x9d\x1f\xf6\x93\x43\xed\x51\xd2\xf7\x6c\xbf\xc5\x5f\x0d\xe4\x58\xf9\x77\xc0\x34\x9d\xcd\x65\x72\x6e\xa5\x6a\x76\x7f\x72\x2f\xd5\x1d\x17\xd3\xe1\x3d\x37\xb3\x21\xae\x53\x9f\x40\x78\xf4\xc9\x2f\x30\xde\x1e\x2d\xf2\x67\x69\xea\x9c\x22\x4a\xcd\x26\x65\xe6\x6a\xa2\x8e\x08\x2d\xf8\xb7\x4c\x69\x2e\xc5\x00\x74\xc7\x01\x29\x79\xfa\xe7\xed\x90\x25\xdd\x70\xd2\x9e\x9a\xae\xe8\x68\xfb\x40\x20\x62\x4c\xe6\x43\x2c\x97\xa2\xa9\x04\x87\x0d\x05\x5b\x51\x43\x34\x9a\xe6\x5c\xbc\xc0\xd3\x99\x70\x91\x6e\x83\x43\xc3\x00\x06\x3d\xea\xa2\x98\x7b\xe7\x0c\xfa\xe1\xde\x90\x7a\x4d\x0a\x92\x39\xfb\x1b\xc4\xfa\xfd\x61\xab\xc3\x97\x2f\xf4\x8f\xd9\x10\xbf\x32\x2c\xd2\x0a\x2a\xfd\x65\xe0\xf2\x0d\xde\x7e\x4d\x4a\x4f\x70\xc5\xb7\xa7\xdd\x26\x4f\x2c\x0d\x3d\xae\x9e\xfb\x24\x80\xea\x22\xf3\x3c\x94\x7b\x57\x34\x13\xd2\xae\x6b\x1f\x7c\x06\xcc\x19\xcf\xa8\xd7\x97\x21\x1d\x3b\x55\x34\x67\x86\x29\x74\x81\x73\x4e\x75\xc2\x45\x27\x7c\x28\x98\xb8\x31\x34\xb9\x6b\x6d\x4d\xef\x39\xee\xb3\x73\xdc\x07\x5f\x05\x7a\x44\xe0\xa9\x15\xef\xdc\x35\x73\xe5\x0a\x84\x07\xe1\x85\x90\x18\x0c\xdd\x7e\x47\x8b\x2e\x56\x0e\xdf\xa7\xc1\x5d\xc3\x6b\x67\xd8\x00\x4f\xb7\x42\x16\x65\x86\x5e\xf6\xdc\x7b\xc1\xed\x87\x1b\xb6\x3f\x03\x8e\x04\xee\x72\x8f\x16\x75\xad\x53\x87\xdc\xbe\x19\x73\x53\x9d\x7b\xcd\x0c\x29\x98\xca\xb9\x0b\xeb\x96\x82\x24\x2e\x2c\x00\xf8\x9a\xe5\x61\x6e\xb8\x88\xe7\x09\x22\x13\x43\x5d\xcc\x0c\x19\x33\x73\xcf\x98\x20\xaf\x5e\xbd\x7a\x05\x72\xc9\xab\xdf\xff\xfe\xf7\x04\xf2\x48\xa4\x2c\xe1\xf9\x72\x43\x68\xf5\xbf\x5e\xbf\x1e\x91\xff\x39\x7b\xf7\x16\xbc\xca\x0a\xa3\xc9\x58\x9a\x99\x1b\xd9\x36\xa8\x75\xd6\x03\xf2\x7f\x6e\x3e\xbc\xf7\xe2\x84\x6e\xfc\x0a\x2a\x48\x58\x5e\xdd\x45\xf0\xd5\xef\x7e\xfb\xdb\x11\xb9\xe0\x0a\xe2\x89\x39\x44\x40\x04\x27\xc8\xc2\x3b\x06\x42\x7a\x9e\x66\x04\xbf\xe3\x20\xce\x49\x38\x87\x6a\x26\x63\x3c\x10\x52\x4c\x32\x9e\x18\xcc\x23\x84\x47\x1f\x01\xed\xb2\x07\x51\x17\xee\xe5\xa4\x08\x98\xdc\x80\x64\xfc\x8e\x91\x89\xfe\x4a\xc9\xb2\xa8\xc2\x1c\x15\xd3\x56\x96\x4d\xa8\x80\xa8\x12\x18\xac\xda\x2b\xcd\xcc\xb3\x3a\x61\xb4\x34\x04\xd5\x70\x10\xfa\x34\x04\x94\x01\x16\xd2\xb8\x63\x8b\x21\xe2\x43\x41\x79\x70\x1c\x84\x3b\x75\xf4\xc2\xae\x13\xef\x84\xa5\xe4\x3c\x9c\x52\x1f\xbb\x52\x28\xf9\x0f\xdc\x2a\xee\x2b\x99\x78\x09\x59\x3b\x99\xcc\x05\x9d\x8a\xc8\xe6\xea\xa3\xf2\x2d\x2f\x74\x11\xff\x51\xfc\xd4\xd5\x24\x0e\xb4\x33\xae\x30\x08\x4b\x21\x16\x6c\xd3\x97\xab\x54\x55\x16\x9b\x34\xee\x6b\x29\x96\x7a\xbb\x2a\x2c\x8e\xfc\xc0\x07\xa9\x0f\x61\xab\xc6\x40\x57\x5c\x17\x00\xe4\xda\x7a\x28\x05\x40\xd4\xbc\x7c\x34\x33\xa5\x03\x0d\x78\x5e\xd9\x6f\x33\xad\x5d\x1c\x51\x4e\xd5\x9d\x55\x12\x1c\x15\x18\x81\xd7\x73\x55\x9f\x24\x54\xf9\x00\x8d\xc2\x95\x59\xf1\x51\x03\xf6\x23\x87\xa3\xd1\x21\x1e\x13\xa9\x88\x36\x54\x39\x9c\xb7\xef\x9f\x29\x5e\xba\xee\x95\x4e\x0b\x4c\x44\x07\xf6\x1c\xcc\xe8\x05\xd1\x67\x95\xb7\x33\x75\x90\x6a\x93\xba\xaf\x63\xe2\xbe\x6e\xd9\x5d\xdb\x67\x76\x1d\xc2\x02\x5a\x34\xed\x9a\xcd\xb5\x43\x26\xd7\x75\xd9\x1a\x1c\x8c\xdd\x49\xe8\x96\x3a\xb7\x43\x52\xd2\xbc\x15\xeb\x5b\x31\xd5\xc3\xdc\x71\xbe\x0f\xdd\x38\x9f\x8b\xd7\x83\x0c\x67\x9f\x0f\xab\xbb\x9a\x60\xa4\x4b\x9d\x74\x39\xd2\x10\x8b\x02\x9e\x82\x45\x61\x2f\x2f\x9a\xa3\xc5\x68\xd3\x96\xaf\xe1\xd3\x85\xbb\xe1\xd3\xee\x62\x02\x9f\x1a\xae\xf9\xdb\x09\x5c\xb4\x23\xa5\x48\x2d\x27\x15\xa8\x20\xd2\xb8\x88\x0e\xcf\x88\xbc\x73\xa4\x16\x91\x8c\x8e\xb5\xcc\x4a\x83\x5d\xab\x1f\x63\x3a\x0c\x83\xfa\x2c\x0b\x40\x7c\x43\xb3\x88\x2a\x03\x3f\x42\x52\xd8\x8e\x40\xe3\xd3\x31\x83\x68\x57\x89\xf4\x27\xa2\x94\x75\x4a\x2f\xe3\x48\x4f\x37\x48\xf9\x6e\xc1\xdb\xf7\x7e\xc6\xdc\x95\x56\xc4\xfd\x2d\xc5\xb1\xe7\x08\x44\x0b\xcf\xc8\x5d\x4a\xb5\xbd\x99\x27\x12\xcd\xbb\xe8\x57\x9a\x93\xa3\xf3\x10\x0e\xe2\xaf\xe3\xaf\x84\x61\x6a\x42\x13\x76\x1c\xeb\x5d\xac\x98\xb1\x9c\x29\xbb\x4c\xd7\xce\xc7\x45\xcc\xa8\x48\x33\x14\xc0\x13\xa6\x00\xf7\xd9\x27\xc3\x94\x05\xc9\xf9\xcd\x15\x49\x15\x9f\x33\xa5\xc9\xd1\x97\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\x47\x16\x95\x80\x40\x03\xcd\x58\xc8\x52\x39\x2b\xfa\x44\x2a\x17\x7b\xa5\xac\xba\x84\x03\x53\x4d\x14\x9b\x5a\x69\x56\x55\xa5\x1d\x92\xac\xb4\x2f\xf6\xea\xce\xf6\x10\x07\xc0\xca\x34\xbb\xc9\x57\x6f\xe2\xa4\x6a\x39\xe7\xa9\x67\x95\x98\x0d\x78\xee\xe3\xc7\x0b\xaa\xa3\x50\x9b\xa8\x76\x65\x04\x58\x94\xd1\x81\xa1\x86\x20\xd6\x9a\xb3\x7f\x6c\x14\x96\x90\xdb\x62\x4b\xee\x83\x8e\x90\x12\x32\x65\xd7\xe5\x38\xe3\x7a\x76\xb3\xa3\x09\x71\xd5\x10\xe8\xac\xb0\x74\xeb\xb7\xd6\x92\xa8\x99\xd0\x1c\x58\x9e\x25\xe3\x96\xe9\x72\x2b\x47\x49\x00\xa2\xef\x1d\x23\xa4\x84\xe8\x8f\x8c\xb9\x0c\x06\xf6\xa7\xf7\xd5\x3c\x5c\x50\x1a\xe6\x2c\x49\xd9\x37\xa2\xa8\xbd\x4f\x68\x96\xe9\x66\xc0\xae\xa7\x98\x28\x7b\xf8\x40\x35\xdc\x53\x6e\xb7\xdb\xcf\x9e\x37\xb2\x5f\xae\x5d\x98\x26\xb9\xc4\x30\x1e\x41\xa4\xf0\x8d\x20\xf5\x8a\xef\x10\x05\x32\x42\xb8\x32\xa0\xcc\xb3\xd6\x17\xe9\xcd\xa5\x4f\xe9\xe4\x19\x67\x40\xaf\xa2\xa1\x6b\x69\x49\x03\x29\xf5\x24\x77\x8b\x53\xc7\x5e\xaf\x15\xf0\x9b\x67\xc6\x28\x3e\x2e\x4d\xf7\x7c\x6f\x8d\xee\xc0\xa6\xad\x22\x02\xa7\x78\xe8\x56\x9f\x44\x28\xea\x34\x84\x70\x16\x96\xcf\x7e\xc5\x73\x80\xdd\xe0\xcb\x43\x4d\x52\x99\x94\x21\x2f\x2c\x00\xad\xba\x40\x6b\x5b\x9b\xa5\xd3\xb9\xda\x35\xd1\x7e\x4b\xf4\x4a\xe5\xbd\xb8\xa7\x2a\x3d\xbb\xde\xe2\x7d\x5f\x67\xe7\x55\xaf\x58\x50\xf2\xaf\x89\x7d\x4f\xc7\xb2\xac\x2a\xdd\xfe\x84\xec\xd5\xab\xd4\x74\x23\x2d\x69\x68\x69\x8f\xee\xaa\xe8\xf7\x26\xee\xde\xc4\x5d\x7b\x76\x31\x71\x5f\xa1\x89\x3b\xce\x83\x5b\x3b\xae\x3e\xbd\x02\xcf\xda\xfa\xf6\x3e\xa6\x95\xf4\xa2\x22\x30\x28\x4d\x35\xfd\xf8\x1b\x02\x1c\x1e\x91\x6a\x6f\x23\xa1\xcf\x53\x20\xe0\xd9\xcf\x6f\x51\x7d\x24\x3b\x29\xac\xae\x95\x54\x8d\xcf\x72\x8a\x76\xf4\x03\xc6\xac\xd4\x78\x29\x11\xdd\x6e\x14\x32\x3d\xc5\x44\x96\x54\x08\x89\xdc\x4f\x0f\x5c\x16\xe8\x81\xd3\xbb\x44\x54\xfc\x02\x93\x50\x7b\xd6\xd8\xd1\x7c\xf6\xe8\x05\xcb\x60\x6d\x5b\xd2\x29\xc5\xcf\x2e\x35\xc8\x2a\xd9\x70\xe7\x22\x55\xae\x7f\xa8\xe0\x91\xcc\x58\x4e\xe1\x9f\x6f\xfc\x02\xec\x89\xb6\x22\x99\x61\x18\xf0\x0d\xc5\xdc\xe5\x64\x50\xf3\x49\x39\x98\xbf\x6e\x51\xf7\xa5\x7a\x76\x2a\xc8\x15\x60\xba\xf3\x72\xaf\x6b\x76\x48\x8b\x7d\xc0\x0f\x33\x4c\x51\xd9\xb8\xbb\x02\x9a\x85\xf0\x79\xd4\xa5\xed\x6e\xd6\xdf\xd5\x9c\x3f\x08\x36\xb2\xcf\x80\xad\xf7\xe6\xfc\xa5\xe7\x09\xcd\xf9\x11\xe1\xf6\xc4\x60\x85\x69\x3f\x36\xb7\x79\xfb\xfe\x98\x79\xb1\x72\x54\x65\x5f\xb3\x28\xe7\x2d\xfb\x52\xd5\xaf\x55\x0f\x47\xa3\xc3\x43\x6f\xef\x77\xf8\x59\x9a\xc9\xf0\x0f\x84\x89\x44\xa6\xb8\xa9\x76\x7c\xa5\x0d\x30\xfd\x4a\x4d\x8f\xe7\x92\xfb\x6f\xc5\x57\xb3\x30\x76\xb7\x2d\xe9\x70\x82\x7d\x4a\x80\x37\x0f\x62\x91\x15\x63\x0c\x29\x06\xdc\x02\x43\x56\x21\xc7\x21\xab\xf2\x25\x58\xb9\x07\xd0\xd2\x97\x4d\x21\x47\xf8\x72\x94\x14\xe5\xc0\x35\x18\xe5\x2c\x97\x6a\x31\x08\x8d\xec\x8f\xb5\x5e\xae\x05\xe6\x9e\x4a\x4a\xa5\x98\x80\x02\x26\x2f\x95\xbf\x7a\x10\x3c\x22\x7b\x0d\x50\x6f\x17\xdd\x56\x3d\xf5\x6d\xad\xee\x00\xc0\x24\x55\x95\x94\x9a\x84\xcc\x26\x7a\x50\xdd\x73\xd8\xb7\x4c\xcc\xc9\x9c\x2a\xdd\x16\xe6\x64\x57\x8e\x9a\xf2\x39\xd7\x0f\x28\xfb\x79\x13\xcc\x3e\x90\x76\xb0\x34\x45\x69\x1c\x75\xf2\xb8\xeb\x33\x35\x05\x9c\x6d\x08\x0e\xaf\x0f\x3a\x7c\xfc\x85\x16\x92\xa9\x3f\xad\xca\xca\xd4\x9f\x6e\x45\x66\x56\xf7\xed\xb8\xf5\x0f\x28\xd0\xd4\x7c\xfc\xd6\xee\x7e\x46\x2a\x26\x53\x25\x06\xf3\x82\xd9\x23\x1c\x02\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\x7d\x70\x6a\x18\x98\x47\xca\xd5\x9e\xa2\x11\x3a\x44\x83\xb2\x94\x97\x79\xe7\x58\x50\xe8\x15\x03\xed\x1e\xb2\x81\xb9\x4c\x62\xfe\xba\xd3\x35\xf3\x89\x15\x69\x72\xe7\x2a\x06\x79\xa8\x22\xef\x8f\x82\x5c\x0e\x0e\x1a\x79\xa0\xc1\x3c\x06\x77\x7f\x32\x65\x16\xe4\xbe\x31\x8e\x5d\x33\x65\xb9\x1a\xe9\xe8\x16\x70\xe4\x1a\x42\xd1\xc6\x77\xc0\x06\x9f\x68\x97\x48\xc7\xc8\x36\xfe\x4f\x06\xe5\xc6\x3a\xfb\xc6\xfb\x8e\x21\x1d\xb4\x04\xc9\x3c\xd4\x45\xcb\x64\x12\xdd\x3d\xd7\x38\x14\x6c\xc3\xa5\x47\x7e\x6f\xbb\xb7\x9b\x61\x47\x45\xf9\x02\x8c\x3e\x99\xc6\x7b\x3d\x9e\x40\x6a\x4b\x90\xe2\x01\x98\x61\x03\x6e\xa3\x2a\x81\xa5\xb6\x5f\x82\xcc\xf3\x51\x9b\xea\x43\xf7\x3e\xc3\xa6\x89\x0a\xb9\xd5\x75\x0f\xfb\xcb\x4d\x58\x59\xa5\xb7\x41\x08\x84\x17\xd4\x75\x09\x62\xa2\xfb\x8a\x13\x97\xe4\x04\xee\xae\xaa\xb2\x68\x21\xb9\xe3\x12\x9a\x09\x9e\xd5\xf1\xcc\xe7\xb2\x0b\x0b\x2f\x85\x73\x34\x58\x42\x9a\xd5\x38\x53\x6a\xa6\x86\xd3\x92\xa7\xbb\x60\xcb\x0b\x66\x80\xad\xd9\x5e\x77\x66\xd7\x91\xc5\x3d\x80\xb1\x05\x47\x8c\x0e\xac\xe1\xa0\xf2\xde\xa8\xf1\x86\x38\x2d\x5e\xdd\x93\x83\x7a\x67\x81\x70\xe4\xfc\x95\xd0\x6d\x50\x6d\x1d\xcf\x48\x16\x89\x0b\xd6\xe5\xb5\x74\x97\x38\x2c\x62\x1e\x38\xb6\x0e\xed\x7f\xbc\x0a\xec\xed\xf9\x63\x36\x91\x55\x85\x14\xd4\x88\x9c\x3b\x6e\xca\x32\x66\xc0\xbb\x96\x85\x4c\xa5\x78\x25\x9c\xcb\xb9\x45\xe6\xbf\x0a\xf2\x8d\xcf\xd9\xcf\x27\xa7\x84\x1e\xd7\x42\x20\x5c\xd5\x19\xc1\x58\x8a\x3e\xba\x59\xf5\x1d\x55\x0a\x3d\x20\xe3\x63\xef\x8f\x02\x27\x4e\x58\xb1\x30\xf3\x12\x2f\xea\xd5\x8a\x59\x00\x40\xd8\xb1\x92\x39\xd1\x82\x16\x7a\x26\x0d\xa8\x86\xb4\xa0\x09\x37\x0b\x62\x14\x4d\xee\xa0\x44\x91\x62\xee\x73\x03\x92\x1c\x3b\xc7\xae\x18\x7c\x75\xb7\x61\x33\x53\xb2\x9c\xce\xc0\x13\x16\x5b\x25\x19\xd5\x7e\xf5\x2b\xfb\x3b\x6d\x47\x93\x74\x21\x68\xce\x93\x90\x35\x50\xc9\x39\xd7\x5c\x3a\x6b\xaf\x1f\xf7\x3a\x64\x86\x43\x0b\xf2\x79\x46\x79\x4e\x8e\x34\x63\xe4\xd2\xa3\x04\xfe\x72\x83\x32\x0d\x5a\x36\x54\xdd\x39\x40\x86\x94\xe6\xc2\x25\x44\xa8\x08\x5c\xb8\xbc\x42\x86\x69\x67\xbe\xf2\xa3\xc7\x61\xbb\x56\xcf\x49\x2a\xb8\xb8\xf7\xa9\x3b\x99\x48\x65\x74\x6b\x79\x76\x7d\xa5\x63\x6d\x04\x71\xcb\xe5\xbd\x83\x1f\x32\x29\xa6\x71\x1a\x81\x0a\x33\xa1\x26\x30\x94\x77\x99\xf3\xb4\xa4\x19\x12\x51\x37\x99\xf3\x9b\x2b\xec\xce\xa7\x33\x33\xbc\x67\x60\x8d\x41\x5e\x53\x9d\x19\xff\x51\xbe\xe4\xad\xc3\x35\x10\x5d\xe3\xac\x09\x68\xd9\xb2\x53\xbb\xa7\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\x41\x28\x9b\x57\x9b\x7c\xeb\x4a\x27\x76\x14\x0e\x0e\xbe\x8b\xcc\x66\xd1\x45\x07\x54\x32\x17\xe9\x90\x66\x16\x73\xae\xbf\x3d\x77\x1e\xce\x78\x10\x6a\x17\xf9\xbe\x0a\x12\x17\x21\x6d\xb6\x95\x19\x56\x1e\x01\x88\x83\x1f\xb3\x14\x88\x46\x5c\x30\xf2\xde\x6a\xc8\x6e\xf3\xae\xbf\x3d\x1f\x10\x3e\x62\x23\xff\x57\x68\xea\xa9\x96\x91\x53\x74\x03\x8c\xab\x68\x8f\x08\x4c\x25\x36\x46\xc5\x7d\xff\xfe\x47\x3b\x49\xfb\xeb\x9f\x86\x7f\x8c\xb2\x8d\xfe\xe9\xef\xae\x8a\xf6\xdf\x1b\x6f\x63\x5f\xb2\x90\x75\xff\xef\xd7\x2e\x2b\xb5\xcb\x59\xfd\x77\x57\x8c\x8b\x09\x63\xe5\xc6\x6b\x09\xb7\xf4\x3c\x45\x6c\x84\x6f\x2b\xf6\x0f\x6f\x58\x04\x30\x05\xa3\x4e\x42\x0d\x13\x40\xa8\x7d\x50\x86\x90\x06\xbb\xbb\xba\xb3\x76\xfe\x47\x60\x12\xc0\xa0\xb2\x01\x31\x52\xc2\x71\xc4\x23\x7f\x26\x08\xf3\xb5\x3a\x71\xad\x00\x0e\xea\x1c\xd5\x3c\xef\xb1\xc3\x5a\x08\x87\x10\x5c\x3b\x0f\x98\xdb\xaf\x84\x34\xbf\x0a\xdb\xef\x5d\x34\x80\xc1\x48\x42\xe7\x92\xfb\x04\xe4\xf6\xa4\x08\xac\xe8\x18\x52\x62\x8f\x17\x24\xe7\xda\xd0\x3b\x36\x22\x37\x96\xb7\xc4\xb7\x61\x08\x3d\x41\x20\x83\x25\x4b\x49\x29\x0c\xcf\xe0\xd7\x6a\x1c\x3b\xe5\x98\xe7\x5c\x4d\x88\x2e\x13\x4b\x5b\x0b\xc5\x86\x9e\x8b\xb9\x56\x4b\xb4\xa0\x5a\xcb\x20\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\x88\xbc\x07\x66\x95\xf9\x2b\x61\x54\x4b\x9c\x01\x53\xb0\x84\x69\x4d\xd5\x62\x00\x89\xdd\x79\x48\x06\xee\x5c\x77\x80\xa3\xe6\x54\x60\x5a\x75\xc5\x12\x29\xb4\x51\x65\x62\xb0\xce\xde\x58\xc9\x3b\x26\x82\xbb\xa0\xdd\xc5\xba\x03\x57\xe5\x3f\x03\xf7\x5d\x92\x24\x33\x2a\xa6\x51\x9d\x9a\x9c\xa6\x00\xfb\xaf\x83\x94\xe3\xd7\x63\x21\x40\x27\x56\xb0\xe0\x06\x40\x31\xb6\x7c\x24\x98\x61\xff\x2a\x42\x3e\x9e\x41\x65\x27\xb5\x4b\xe2\xd9\x16\xda\xd5\x89\x7e\x91\x8e\x46\xbd\x21\xb0\xed\x3d\x3b\x80\xe5\xcc\xd0\x94\x1a\xba\x83\x13\xd8\xbb\xaa\xb8\x9e\xbb\x80\x74\x05\x4e\xc3\xc5\xa4\xe3\x43\x5e\xdc\x92\x05\x8f\xe3\x9f\xe0\x24\xce\x3c\xe4\x21\xe2\xda\x58\x9c\x72\x17\x05\xe8\xdb\x05\xf2\x8c\xaf\x5e\x66\x87\xf7\xa3\x21\xb9\xa8\x4a\x33\x56\xe4\xa4\xdd\x35\x54\x47\x0b\xac\x05\xfd\x0e\x30\xba\xad\xee\xca\x92\xba\x7f\xd7\x4a\x11\x04\xb9\x04\x13\x86\x2b\x16\x87\x9b\x39\xd0\x95\x02\x91\xbc\x01\x44\x80\xf2\x94\x19\x5d\x79\xa8\x20\x1d\xb6\xc4\xc5\xf1\x3b\xa7\x8c\x02\x91\x76\x80\x75\xfa\xdc\x6a\x59\x08\xc1\xae\xa5\xa3\xb3\x96\xf2\x3f\x0a\x5c\x77\x31\x3a\x63\x39\x81\x77\x32\xed\x62\xa7\x6e\x64\xe1\xaf\x86\xa8\xfc\x37\xd1\x13\x57\x83\x52\x8f\x0d\xe0\xb6\x4a\xd7\x82\xe6\x90\xc8\xcd\xe8\x7c\x77\x23\x55\x25\x23\x0d\x43\x2a\x63\xf8\xdc\x10\x3e\x37\x7c\xdd\xde\x98\xd7\xc5\x03\xc4\x3f\xad\x3d\x41\xea\x1f\xe9\x64\x39\xb5\x24\xe5\xa6\xa3\xb9\xb3\x11\x8d\x1c\x46\x70\x34\xdf\xdd\x22\x86\x9b\x5b\x17\xe9\xc0\xb8\xa5\x16\xa7\xe4\x57\x35\x2e\xef\xa4\xa9\xa0\x29\xa1\xa7\xee\x91\x57\x9d\x46\x6e\x2b\x7c\xf0\x79\xbd\xf9\x71\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\xee\x83\x30\x41\x35\xa6\x6e\xf1\x37\x5e\xcc\x15\xce\x5b\x3b\x5e\xf0\x5a\x3e\x13\x0b\x9c\xfa\x45\x04\x5a\x54\x3d\xc9\xd4\x7e\xc8\x4a\x9d\x82\x8e\x33\xbc\x3d\x0e\xcc\x16\xe6\x42\xb3\x7b\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\xaf\xaf\x60\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\x1a\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\xf1\x70\xbe\x61\x69\x90\xae\x5f\xbd\x22\x1b\x88\x4b\x57\xc9\xd8\x0b\x3a\x70\x79\x50\x88\xec\x48\x03\xab\x87\xd2\xaa\xd6\x78\x64\xd8\x73\x92\x82\xf7\xa1\x71\x95\x8e\xc4\xc2\x99\x6e\xe2\x6f\xc5\x03\x84\x53\x42\x8e\x84\x14\x78\x72\xb0\xed\x31\xba\x10\xad\xb1\x4d\x41\x13\x57\xa2\xae\x5e\x21\x34\x3a\xa9\x9e\x49\x70\x91\xda\xad\x03\xca\x0d\x3a\x92\x2e\x93\x84\xb1\xa0\x55\xc7\x25\x6a\xaa\x93\xed\xa6\xec\x4b\x5d\x6a\x09\x49\x5c\xb4\xa1\x59\x56\x69\xb3\x0e\x5c\x12\xf8\x9c\xb7\x00\x46\xec\xaf\x16\x68\xe3\x14\x7b\x28\xa2\x8e\x6e\x2f\xa5\x48\xf0\x0a\x9f\x9b\x85\x9f\xc1\x45\x93\xd5\x83\x1a\xa1\x51\xc9\xe5\x13\xb4\x3b\x45\xea\x40\x00\x26\x90\x26\x57\xc2\xbd\xce\x99\x5c\x6e\x06\x4b\x87\xc6\x34\xb9\xbb\xa7\x2a\x85\x52\xbe\x05\x35\x1c\xd3\x82\x0f\x6a\xc3\x1e\x45\x73\x80\x42\xfa\x31\x16\x1d\x07\xa5\x43\xb3\x90\x82\xba\xfa\x0c\xa1\xa5\x91\x39\x35\x3c\x01\x55\x96\x4f\x22\x2b\x62\x1e\x52\x1a\x36\xca\x0e\x02\x95\x0d\x05\xec\x6f\xf1\x36\x46\x31\x62\xee\x25\xe1\xb9\x95\x10\x28\x94\xd2\x98\x84\x88\x21\x6f\xef\xdc\x34\x53\x2b\x06\x7d\x07\x46\xe6\xa8\x15\x2a\xc9\x56\x85\xd2\x30\x7c\xb0\x68\x06\x53\x9e\x0b\xb9\x19\x34\x18\xb8\xeb\x63\x71\xda\xce\x35\x42\xd5\x81\xdd\x9e\x7b\x66\xe5\x02\xbd\x11\x61\xf5\x68\xd5\x8c\xb0\xa6\xad\x26\x29\xd7\x8d\xc2\xd4\x47\xa9\x92\x45\xe1\x0c\x24\xf9\x71\x73\x46\x70\x6f\xa0\xe6\x4c\x47\xb5\x97\xd1\x54\x3d\x65\x22\x14\x0f\x77\xe9\x2c\xe0\xe4\x36\x3f\x51\x3b\x30\x23\x0c\x08\x3d\x26\xdf\xb8\xa2\x42\x01\x71\x83\xd7\x5d\x2b\xc1\x09\xad\x2d\x4e\x76\xea\x25\x9e\xb6\x4f\x2f\xf1\xf4\x12\xcf\xcf\x5b\xe2\x09\xee\x5e\xbb\x4a\x3b\x95\x8f\x63\xa3\x20\xb9\x77\x06\xa8\x1a\xac\x33\x62\x5c\x4d\xc8\x47\x96\xc8\x39\x53\x48\xe4\xa0\xf0\xa7\xe5\xe5\x6f\x28\xcf\x2c\x89\xf3\xa4\xae\x52\x0f\x21\xa3\x6a\xdd\x34\x17\x69\xe4\x01\x9a\x0e\xcd\x73\x37\x29\x17\xe9\x67\xdb\xbb\x4b\xb2\x42\xb1\x39\x97\xa5\xf6\x2e\x0b\xa5\xc1\x63\xa6\x8d\xe3\xb7\x33\x3e\x0d\x89\xb9\xc3\x55\xa7\x62\x89\x54\x69\x15\x52\xae\x0d\x35\xa5\xae\xc7\x49\x24\x68\x4d\xdb\x9f\x81\x26\xc0\xf1\x91\xa9\xfb\x6e\x94\x14\x3d\x36\x1e\x70\x2a\x0e\xdf\xa2\xcf\x47\x55\x77\xdb\x44\x6e\x28\x95\x0b\x8c\x15\xa1\x4a\xc3\x22\xb4\x72\x08\xd0\x19\xd6\xb5\xa8\xd7\x13\x2c\xdc\x32\x0c\xc3\x0e\x2b\xaf\x93\x16\x19\xd7\xe3\x67\x27\xa8\x93\x07\x04\x78\xc6\xcf\x0b\x76\x3c\x69\x2c\xb6\xbb\xf7\x25\x79\xa0\x07\x26\x79\x88\x17\x26\xd9\xa7\x27\x26\x09\xfe\xdc\x0f\x39\x31\x1f\xbd\x27\x79\xe3\xcc\x38\xc2\xbb\xe9\xcc\xd4\x12\x0a\x84\x71\xb8\xf6\x15\x20\xdd\xb5\x66\x38\x03\x60\x12\x8c\xfd\x81\xdd\x69\x05\x6d\x0e\xef\x2e\xd9\xa7\x90\xf5\x37\x92\x63\xaa\xa2\xda\x46\x82\x07\x42\x5e\x60\x26\x20\x38\x75\x43\xe7\x92\xe5\xb5\xa5\xfe\x04\xf7\x27\xb8\x6d\xff\xe7\x3c\xc1\xe8\xf1\xdc\xc5\x21\xbf\x51\x29\x08\xbb\xbb\x20\x5c\x3a\x66\x19\xf9\xb1\x64\x6a\x41\xac\x10\x54\xb9\xf7\x40\x7a\x63\xcd\x53\xe7\x20\xe3\x8c\x2a\xed\x65\xf6\x27\xe4\xff\x60\xb2\xb9\xfc\x64\x25\x40\x88\x63\x7b\x00\x5d\x6b\x0e\x55\x0f\x55\x46\x68\x05\x08\xc6\x12\x1e\xde\x30\xd6\x64\x3e\x2b\xee\x9d\xbd\xbf\xd8\x4d\xd1\xe9\x76\xa9\x45\x76\xb9\xd8\x5a\x5a\xfc\xd9\x86\x05\x22\x20\xc2\x2f\xf5\x6a\x52\xc1\x14\x41\xee\xd8\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\xfb\xe0\xa5\x06\x34\xad\x39\xe6\xde\xb1\xc5\xa1\x76\x51\x83\x52\xe8\x19\x2f\x7c\x7e\x78\xa0\x04\x0e\x73\xc9\xb7\xe0\x1f\xe0\x87\xc0\x33\x7f\x25\x06\xe4\xbd\x34\xf6\x7f\x97\xe0\x2a\x84\x96\x4a\xc9\xf4\x7b\x69\xe0\xcd\x93\x03\x0b\xa7\xfb\x60\x50\x39\x33\x25\x07\x33\x23\xba\xb4\x41\x7c\x86\x77\x41\x01\x90\xb8\xfb\xd6\x00\x56\xae\xc9\x95\x20\x52\x79\x98\x18\x9f\x3c\x58\xbb\x21\xbc\x6d\x29\xb2\x08\xaf\x18\xc3\x81\x52\xaa\x1a\x24\x37\x0c\x17\x8c\xcb\xdc\xff\x02\xb6\x27\xb0\xc6\x07\xbf\x19\x48\x81\x4b\x0d\x9b\xf2\x84\xe4\x4c\x4d\x21\x3e\x34\x99\xed\xbe\x41\xdd\xe9\x36\x3e\x3b\x51\xef\xf8\xc3\x9d\x31\x03\x58\xdd\x5b\xf0\x5c\x7a\x28\xc3\xc4\x51\x90\x45\xe4\xb4\xb0\x48\xf1\x2f\xcb\x09\x60\x5f\xfe\x03\x29\xab\xf5\x88\x9c\xf9\x82\xa7\xf1\x6f\xce\x8a\x11\x0f\x63\x47\xb0\x32\xfd\x8f\x25\x9f\xd3\x8c\xa1\x3f\x1f\x15\x21\x8d\xa7\x9c\x2c\xb1\xe9\x81\xcb\x5b\x6d\xa9\x54\xb8\x19\x3a\xb8\x63\x8b\x83\xc1\x12\x22\x1d\x5c\x89\x83\x2a\x48\xbb\x86\x3a\x81\xa1\xc1\xa5\xc1\x01\xfc\x76\xb0\x6f\xce\xfe\x4c\xa2\xfd\x0e\x58\xe2\x0c\x42\xe7\x19\xd5\xba\x5b\x7c\x6b\x23\xb4\xa8\x31\xce\xaa\x04\x8c\x37\x51\x9b\x2a\xb8\xc8\x79\x6f\xee\xdd\x9e\x05\x5e\xfe\xdd\x3d\x8d\x3a\x41\x6f\xee\xaa\xa7\xb4\x4f\xdc\xb0\x32\xa1\x18\xa4\x2d\xf0\x31\x1c\xb5\xb8\xb8\xea\x32\x76\x0d\xbc\xbe\x05\xbb\xa2\x9c\xc4\x45\x9e\xb9\x06\x35\x98\xfb\xa8\x0e\x21\x0d\xe1\x22\xc9\x4a\x67\x52\x84\xae\xa0\x44\x77\x15\xf5\x77\x00\xce\x03\x90\xaa\x1a\xc0\x63\x93\xbf\xf6\x5d\x72\xe0\x6d\xde\xd0\xc1\x9d\x68\xb8\xf1\x42\x58\xed\x7b\xad\x93\x2d\xee\x92\xf5\x64\x9c\x49\x5d\xf6\x78\xc3\xc7\x8a\x91\xf3\x19\x15\x82\x65\x51\xb4\xab\x33\x76\x84\x72\x56\x20\x90\xb8\x22\x56\x87\xf5\x2a\x56\x9e\xbe\x89\x10\x5b\xbd\xf7\xda\xc1\x3f\xa5\xa2\x52\x7b\xab\x53\xee\x52\x35\xce\xe4\x3d\x49\x25\xb9\x87\xba\x05\x73\xcb\xb4\xe0\x52\x56\x7b\x76\x17\xcd\x14\x5c\x24\x12\x99\x17\x4a\xe6\x5c\x7b\xe7\x78\xb7\x8d\x7b\x0d\x0d\xcd\xca\x16\x39\x80\xea\x7b\x90\x95\xa2\x9e\x12\xfe\xcd\x39\x31\x54\x4d\x99\xb1\xa3\x11\x51\xe6\x63\xd6\x3a\x7e\xf5\x31\x72\x90\x7d\x4e\x25\x44\xf7\x5b\x04\x0b\xb7\xe1\xbb\xef\xde\x77\x2e\xbd\x5b\xf5\x5c\xb7\xb7\xf7\x52\x65\xe9\x3d\x4f\x91\x45\x6b\x72\x64\x1b\x1f\xbf\xfc\x4a\xb9\xf7\xf7\x3c\xed\x0c\x0e\xe8\x54\x07\x83\xf7\x83\xb2\x60\x20\x00\x07\x57\xe1\x89\x43\x1a\x6d\xe8\x71\x4c\x2e\x39\x46\x17\x41\x7f\x48\x54\x93\x8f\xb9\xa8\x22\xcc\x2a\x30\x5b\x62\x6c\xcf\x8b\x57\x4d\x34\x33\x18\x17\x02\xa1\x15\xd2\xcc\x88\xe6\x79\x99\x19\x2a\x98\x2c\x75\xb6\x68\x8d\x2a\xcf\x03\xea\x49\xc6\x3e\x21\x66\x77\x61\x72\xa1\x53\x9d\xd9\x81\xeb\x4a\x15\x46\xb9\xc4\xed\x2a\xe7\xaa\xf4\x24\x70\xbe\x10\x6e\xc4\x3e\xb1\xc4\x79\x05\x17\x59\x39\xe5\x5b\xc2\x1f\x7e\x66\x59\xcd\xab\x04\xd2\xa5\x66\x55\xa4\x7e\xdb\xba\x2e\x4f\x94\x84\xfc\x79\x39\xfc\xed\xea\x04\xe4\x29\x2b\x98\x48\x21\x25\xda\x9b\x0a\x73\x71\xf2\x7b\x85\x9c\x4b\x2f\xd6\x95\x6a\xf9\xac\x64\x35\x0a\x1e\xb9\x70\xcd\x64\x96\x6a\xc2\x3e\x19\x45\x2d\x61\xca\x2d\x09\x0a\x7d\x26\x84\x8a\xf6\x44\xe6\x65\xa4\x08\x26\x7b\xe7\xf6\x8f\x5b\x2f\xf3\x25\x96\xbc\xac\xd6\xae\x37\x16\xac\x7e\x58\xea\x7a\x24\xc4\xee\xac\xe8\xba\x87\xf0\x8a\x14\xf3\xee\x2b\x75\xcf\xc4\x87\xa5\x9a\xd7\x2b\x92\x6a\x37\x66\xd5\x97\xe9\xfc\x2c\xf2\xce\x4f\x20\x30\xb8\x4b\x12\x26\xd7\xa3\xa1\x51\xbb\x97\xcd\x82\xd0\x1b\x34\x68\x87\xb7\x11\x1f\x80\x8c\xa7\x6e\x20\x17\xd6\x44\xb4\x85\x65\xe5\x3a\x57\x0a\xb1\x8d\x8a\x3d\x46\x16\x71\x6a\xa8\x66\xa6\x9d\x35\xa5\x2e\x3a\x54\x3d\xed\x01\x8c\xf1\xcb\xfd\x84\x59\xec\xc1\x21\xdd\x07\xcb\x92\xe1\x9f\x9c\x94\x21\x6a\x2d\xad\x7c\xe1\xe1\xe3\x93\x34\xb1\x70\x8b\x8c\x63\xa4\x76\x57\x12\x6a\x5a\x97\xdc\x69\xc5\x17\xdc\x0c\xbe\xf9\xa6\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\xbf\xaf\xb5\x4d\x13\x56\x19\xaf\x2e\xb8\xbe\xeb\x92\x8c\x6c\xa9\x73\xfd\x48\x7c\x75\x7e\x49\xdc\xdb\x56\xf6\xa5\x2e\x06\xa6\x87\x66\xc6\x9a\x26\xac\x32\xda\xa6\x5c\xdf\x3d\x79\x59\xf5\x22\x7d\xbf\xcd\x03\xfc\xe9\xec\x5f\x4d\xa9\xd7\xa7\x68\x89\x72\x07\x2d\x64\x49\xee\x5d\xea\x03\x27\x35\xdf\xf2\xe2\x94\x5c\x0a\x5d\x2a\x56\xdd\xdc\x36\x87\xb2\x5c\xf7\x25\x95\x5e\x7f\x10\x96\xbc\x64\xe3\x5b\x41\x95\x01\xf1\xb8\x2b\x1a\x84\x8e\x9e\x3e\x45\x2f\x44\x1b\x3c\xb8\x9a\x78\xc7\xba\x81\x8b\xf1\x0e\x89\xcb\x7c\x23\xbb\xf3\x51\x5a\x93\x78\xaf\xdf\x84\x94\x3f\xe4\x24\x65\xf3\x13\x9d\xd2\xd7\x03\xf8\x8c\x77\x78\xae\xcf\x89\x6a\x72\xf0\xfa\x60\x44\x6e\x78\xce\x33\xaa\xb2\x45\x2d\x15\x73\xd5\xce\x32\x0b\x3f\x20\xdc\xca\xbd\x3a\x20\x47\x52\xc1\xc8\x09\x15\x24\x63\x3e\xa2\xc9\x9d\xb3\x05\xca\x8e\xc7\x4f\x4d\x5c\xc8\xa3\xda\x2f\x91\xce\x74\xc6\x89\xd4\x73\x6c\xc7\x8f\x6a\xe9\x6c\x2e\x2a\x92\xce\x85\xa5\xf3\x23\xf2\xcd\xaa\x42\xe5\x70\x64\x7c\x8b\xe7\x02\xea\xd3\xe8\x7d\x3b\x69\x70\xcb\xe6\xe0\xe7\x03\xd3\x76\x2d\x71\xca\xcd\x47\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\x23\x72\x71\x79\xfd\xf1\xf2\xfc\xec\xf6\xf2\xe2\x94\x7c\xe5\x46\xe2\xb1\x84\x37\x22\xb7\x71\x36\xa8\xc8\xa3\xd7\xa5\xdc\x09\xdf\x1a\x38\x32\x44\x45\x95\xdc\x11\x72\x7c\x50\x41\xae\x04\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\x23\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\x8e\x0e\xbd\x40\x91\x2d\x25\xe1\x0f\x83\xc6\x19\xbd\xea\xc8\x36\x22\xe4\x83\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\xf8\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\xf1\xf2\xec\xe2\xdd\xe5\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\xdf\xaf\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\x3b\xfb\x57\x94\x74\x1b\xf0\xe2\xfd\x87\x5b\xc8\xea\x0b\x17\x5c\x0f\x16\xc2\xed\x07\xe1\xbc\x0d\x87\x43\x30\x19\x1c\xfd\xc3\xca\x93\x69\x76\x4c\xbe\x63\xee\x3b\x12\xd2\x0e\x2b\x28\x05\x34\x93\x21\x07\x2c\xcc\xb5\x82\x2c\xa0\x23\x5e\xef\xbb\x56\x27\xb6\xa5\x95\x95\x90\xd5\xd4\xda\x43\xe5\x53\x4c\xdd\x88\x77\x4c\x4f\x2f\x7b\xee\x91\xec\xef\x4c\xe5\xbc\x69\x75\x15\x7e\x86\x8b\x1f\x4f\x0f\x29\xd1\x8b\x3c\xe3\xe2\xae\xca\x0b\x36\x91\x16\x87\x30\x34\x81\x8b\x3b\x8f\xb1\x8a\xd1\x6c\x3d\xa5\xdc\x05\x3f\xf6\x4a\x25\xcd\x0e\x16\x40\xb0\xd0\xd9\x73\xf6\x17\x7f\xec\xdd\x35\x74\x4c\xe2\x0e\x0e\x5e\xdc\x7a\xb9\xee\x56\x06\xff\x10\x3a\xd4\x68\x9a\x20\x57\x37\xe7\x37\x57\x4f\x6a\xa1\x5e\xc7\x12\x60\x76\xcf\x28\xd5\xf1\x1f\xb7\xdd\x0e\x0f\x49\x56\x6e\x6f\x83\xea\xdd\xb5\x54\x86\x66\x7b\x22\x02\xc9\x8c\x16\x67\xa5\x99\x5d\x70\x0d\x39\x14\xba\x0a\x01\x4b\xfd\x23\x4f\x67\xcc\xdd\xec\x13\x06\x72\x8f\x0e\xae\xdd\xf9\x5f\xce\xae\x09\x2d\xed\xfe\x1a\x97\x5c\x74\xaf\x17\xee\x7e\x66\x37\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\x95\x6f\x01\x57\xc8\xc0\xc5\x97\x3a\x55\xd6\x02\x90\xde\x01\x62\x57\xc2\xca\xda\x34\x61\x0d\x07\xc8\x01\x24\xfd\xc4\xb1\x79\x68\xf3\x47\x67\xa0\x82\xfc\x60\xd9\x9f\x4e\x6b\xa9\xd8\x97\xea\x5a\x78\x2b\x45\x55\x34\x61\xaf\x16\x1f\xfe\x63\x57\xa2\xc0\x7f\x14\x0d\x4b\x1b\x2e\xf0\xff\x96\x34\x43\xc0\xbc\xdf\xb7\x59\xaa\x0e\xe4\xae\xf3\xad\xef\x90\x9b\x7a\xb5\x1d\xef\x83\x96\x5e\x6a\xcc\x3c\x86\xeb\x31\x8a\x0a\x6d\xf7\xa8\xae\x8b\x1d\xba\x8b\xa7\x43\x72\x64\x92\xa2\x75\xed\xfe\x47\x72\x6d\xcf\x4a\x51\x2b\xe4\x0c\x33\xbf\xc5\x6d\x79\x1b\x5c\xdb\xdb\x4e\xf2\x51\xae\x86\x00\xcb\xbb\x5a\x55\x5c\xaf\xb0\x5b\xf1\xba\x90\xf5\x93\xb7\x5c\x1b\x5f\x90\x01\x5e\x70\xed\xf2\x08\x83\xdc\x75\x6d\x15\x39\x5e\xfc\x8d\xa6\xa9\x3a\x45\x2e\xe5\xab\x2f\x2b\x90\xbe\x7c\x92\x2f\x2a\xc2\x5d\xe2\x91\x59\x14\x2e\x01\xe0\xed\xf9\x35\xc1\x02\x29\x7f\xf8\x1d\x56\x7e\xfd\xaf\xdf\xfc\xee\x55\xeb\xed\x7e\x3e\xe7\xf1\x1d\xed\x18\x7b\xbf\x63\x7a\x11\x7e\x83\x35\xff\x40\xbb\x12\x90\x4d\x6e\xd0\x1d\xcf\x52\x56\x77\xd4\x11\xb1\xec\x2e\x07\x7a\xbf\x9b\x04\xd3\xfb\xd9\x3d\xab\x9f\x1d\x09\x11\x25\x48\x24\x3a\xa2\x4b\xdc\x15\x42\x0c\x97\xc9\x0e\x52\x9c\xeb\x97\x47\x71\xb6\xc2\x66\x3b\x16\xd5\xb1\x27\xbe\x8c\xf7\xe5\x6f\x2a\x17\xf6\x8b\xf7\x37\x7f\x7b\x7b\xf6\xe5\xe5\x5b\x98\xa9\xbb\xbf\xb7\xa8\xc1\xc5\xce\xfe\x53\xed\x51\xad\x8d\xf2\xba\x1d\x20\xdd\xae\x65\x44\xe3\x42\x46\x90\xf7\x6f\x6e\xba\xde\xc5\x3c\x54\x40\x17\x93\x56\x6b\x7f\x5a\x6b\x1b\x54\x35\x61\x6a\x7f\xf1\x23\x3b\x1b\xe5\xa2\x44\x5a\x35\xfd\xcb\xee\x14\xce\xf0\xc1\x2a\xd2\xd6\x1d\x20\x2f\xe0\xde\xc1\xae\x17\x61\xb0\xf7\x1b\x87\x47\x82\x55\x5b\x39\x40\x75\x0f\x2c\x3a\xc4\x5e\x5e\x04\xb0\x87\x14\x69\x9b\xb2\x34\xdb\x52\x6b\xa6\x43\xf5\x85\x17\x8a\x29\xc5\xaa\xf4\xcc\x5d\xa8\xd7\xca\x01\x6a\xe5\xca\x6a\x77\x31\xb5\x58\x8a\x75\xe9\xcc\xbd\x87\x02\x75\xca\xab\x2e\x68\xb2\xd7\x82\x2a\xd5\x2b\x7c\x03\x41\xee\x4f\x4f\x00\xe1\xb3\x7b\x74\xa4\x0d\xe3\x75\x45\xe4\xd0\xb1\x19\x25\xd7\x69\x87\x7c\xa1\x8f\x42\xfa\x08\xc4\x38\x9c\xee\x99\xb7\x8f\x3c\xad\xb6\xf3\xdd\x8e\x8a\xce\xbe\x95\x9c\x62\x26\x8d\x14\x3b\x7b\xc9\xaf\xea\x5e\x3f\xd0\xd7\xd0\xe2\xbc\x2a\x63\x13\xd5\x78\x04\x0f\xca\x70\x19\x61\xe5\x39\xcf\x2e\xa4\xf0\xd7\x12\xf5\x4b\x89\x27\x17\x41\xd2\xab\x8b\x3d\x1d\xbe\xcf\x37\xc4\xb3\xab\x31\x78\xaf\xce\x20\x69\xe7\x98\x14\xdb\xc5\x43\xec\xea\xc2\x89\x66\x3e\xe0\x44\x3b\x84\x24\xeb\x31\x72\x6f\xac\x53\x2a\x73\x2f\x55\xf7\x50\xef\x7a\xc7\x86\xaf\x82\xfb\x6d\x29\x14\xeb\x25\x9e\x1e\x9c\xe3\x33\x9f\xa0\x1b\x38\x41\x8d\x04\xe7\xeb\x4e\xd2\x63\x1c\xa4\xe7\x3d\x40\x0f\x65\x54\x8f\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\x03\x82\x59\x96\x73\x5a\xf8\x9a\xdc\xf2\x5e\xdc\x53\x95\x92\xb3\xeb\xab\xfd\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\xfd\xef\x7f\x8f\x95\x95\x52\x96\xf0\x7c\xb9\x21\xb4\xfa\x5f\xaf\x5f\x8f\xc8\xff\x9c\xbd\x7b\x0b\x95\x1f\x0b\xa3\x31\x2b\x09\x8e\x8c\x95\xe0\xa3\xce\x7a\x40\xfe\xcf\xcd\x87\xf7\x55\x99\x98\xfa\xaf\xae\xa0\xb6\x5b\xde\x88\x5c\x44\xfe\x4f\xb1\xa1\x8b\x9a\x99\x2b\x68\x64\x08\x9d\x4c\x10\x31\xc6\xbe\x9c\x2e\x1e\x38\x1f\x3d\x0e\x55\xc1\xb1\xfe\x88\x45\x89\x0c\x1c\xb3\xac\x4a\x8e\xa6\x41\x9f\xd9\x00\xfd\xcc\x60\xac\x40\x26\x61\x2a\x03\xac\x25\x3f\xd1\x50\x85\xa4\x4a\xff\xa7\x98\xb6\x42\xa9\xab\xae\x88\x83\x55\x3b\xa3\x59\xeb\x5c\x0f\x8f\x71\x03\xd4\xba\x3a\x46\xdd\x74\xef\xce\x90\x4f\xdf\xea\x72\x17\x57\x65\xea\xff\x81\xb7\xa1\xdb\x9c\x84\x1f\xe9\x46\xa6\x36\xd7\xeb\x30\x1b\xdc\x3a\x97\x25\xa0\xa2\x13\x34\x93\x50\xc9\x2b\xec\x74\xc5\xc5\xa2\xa2\xf7\xdb\x97\xd2\x39\xf9\x62\xd7\x04\xbc\x48\xa8\xde\xd1\xd6\xe5\x7c\xea\xfe\x22\xbe\x77\x2d\xaf\x02\x1d\xcb\xd2\xf8\x3b\x6c\xf7\x3b\x04\x60\x63\x95\xf5\x0e\x69\x24\x77\xc8\x3c\xb9\x4b\x06\xe2\xce\x49\x4c\xeb\xf7\xcd\xc0\x13\xea\xa2\xc4\x80\x30\x9a\xcc\xc8\x1d\x5b\x0c\x91\x6e\x15\x14\xa2\x79\x00\x2a\x17\x16\x16\xb5\xc2\x27\x55\xed\x1a\x2b\x1f\x3b\x90\x79\xc7\x80\x88\xfb\xf8\x68\x20\x2f\x84\x6a\x27\x2f\xb9\x34\xa2\x22\xb2\x14\xf8\x5c\xd5\x51\x3d\xe2\x90\x37\x14\x8b\x91\xd7\x83\x54\xec\x79\x63\xa9\xed\xa6\x37\x7d\xb9\xf2\x86\xb0\x74\xd0\x71\xb7\x52\x2c\xf5\x76\xc5\xb7\x9d\xf0\x07\x1f\xa4\x3e\x3b\x73\xe4\x51\x01\xe5\xfc\x5c\x25\x27\xd7\xd6\x43\x29\x00\xa2\x16\x44\xa3\x99\x29\x1d\x68\xb0\x5e\x58\x29\x32\xa6\x35\xe1\xb0\xc2\x9c\xaa\x3b\xe6\x13\xc6\xd0\x6c\x44\xae\xed\x24\x43\xfe\x2a\x4c\x8b\x3c\x47\x17\x3b\x7b\x66\xe3\xe8\x20\xfb\x91\xc3\xd1\xe8\x10\x09\xfc\x8a\x58\xa1\x0e\xf8\xb1\x5b\x4e\xdd\x1d\x72\xe9\x36\x4a\x7b\x17\x1a\x33\x03\x5b\x91\x0f\x32\x5f\x4b\x88\x82\x33\x33\xcf\xc0\x68\xeb\x24\x4a\xcb\xcb\xd9\x21\x01\xec\xae\x79\xcb\x77\xc9\x5a\xde\xea\xde\xa2\xfe\xec\x9e\xad\x7c\xa7\x5c\xe5\xeb\x32\x95\xbb\x9d\x72\xa7\xad\x7b\x0e\xe7\x07\xa4\xd8\xce\x3b\xa5\x79\xf5\x4f\xdd\x48\x09\x72\x47\x2d\x4b\x4f\x2b\x19\xd1\x25\x7d\xca\xd8\x67\x25\x14\x5e\x4d\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\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\x4f\xd6\x99\xe4\x01\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\xbe\xda\x49\x03\x88\xfa\xaf\xd1\x01\xe2\x16\x3f\x61\x2d\xe0\x0a\xb5\x80\xb8\xec\xce\x45\xb5\x72\x67\x52\xb6\x64\xe7\xc5\x8b\x91\x4b\xd3\x7e\x63\x89\x65\xec\x74\x5a\xcf\xa1\x87\xc6\x9e\x8a\xac\x46\x79\xf7\xfc\xad\x23\x1c\xe2\x97\x2e\x72\x3e\xa1\xf8\x08\xf0\xe8\x54\x2e\xdd\x3f\xcb\xd5\xec\x60\xb1\xe4\x06\x4a\xdb\xa0\x3e\x18\x29\x96\x85\x4c\x4f\x5d\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\x0f\xa9\x73\x64\x37\x10\x56\x7e\xdd\x75\x17\xc9\x03\xcb\x16\x91\x88\x35\xed\x56\x08\xa5\xb6\xa7\x6e\xa4\x50\xe7\x3d\x99\xb1\x9c\x62\x0e\x3f\xbf\x3c\x4b\x65\xee\x15\x37\x86\x61\x2e\x25\xa6\x72\x4d\xe4\x64\x50\xbb\x33\x38\x98\xbf\x3e\xd8\xa5\x1c\xcc\x03\x2b\xf6\x90\x6a\x17\xf6\x00\x8c\xeb\x9a\xc8\x66\xf1\x1a\x74\x89\x0c\x12\x6f\x8a\x86\x41\xc2\x32\x98\x39\x42\xef\xc9\x17\xbe\x0f\x3d\x6a\x57\xfd\x69\x10\x04\x86\x5e\x7f\xea\xf5\xa7\xbd\xe8\x4f\x11\x63\xf1\x04\x67\x85\x2e\x15\x3b\x0c\x7b\x85\xaa\x0a\x64\x8a\x12\xf0\x58\xd4\xf4\xaa\x94\x54\x75\x8b\x9b\xd5\x87\x0e\xbd\x82\xe5\xf0\xb8\x34\x93\xe1\x1f\x08\x13\x89\x4c\x71\xf3\xed\xf8\x4a\x1b\x10\x6d\x2a\x9d\x24\x9e\x4b\xee\xbf\x15\x5b\xed\x60\xec\x5d\xb7\x6e\x27\x3a\xe0\xaf\x02\xdf\xec\x89\xc1\x57\x6c\x3d\x04\x13\xfb\x5a\xd9\x3e\xd7\x80\xe3\xef\xd5\x25\x24\x96\x95\x06\xe4\xf6\x15\x73\xc9\x11\xbe\x1c\x25\x45\x39\x70\x0d\x46\x39\xcb\xa5\x5a\x0c\x42\x23\xfb\x63\xad\x97\x6b\x71\x0c\x32\x41\x52\x2a\xab\x01\x66\x8b\xcf\x55\x3a\xf0\x00\x7a\x62\xe1\x20\xec\x53\xb7\xa2\x41\xf1\x53\x47\x89\x2a\xa9\x18\xe8\xf7\x55\x11\xa5\x49\x48\x79\xa8\x07\x95\xda\x69\xdf\x32\x31\x27\x73\xaa\x3a\x54\x41\x8f\x9f\x07\xca\x03\x29\x9f\x73\xbd\x5b\xbd\xc3\xc6\xd2\x6f\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\xb3\xa9\x2f\x8c\xcf\x8e\x55\x86\xf1\x79\x68\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\xa2\x83\x86\xee\x26\x3b\xd9\x6d\x5c\x86\xfa\xd5\x26\x1b\xf7\xe3\x4f\xd8\x5a\xb3\xdf\x3b\x5b\x17\x5f\xf8\x33\xbf\xb0\xbd\x71\xf5\x0c\xfa\xdb\xda\x56\x28\xd8\xdf\xd6\xf6\xb7\xb5\xfd\x6d\x6d\x6f\x6d\xe8\xad\x0d\xfd\x6d\x2d\xe9\x6f\x6b\xf7\x02\xc3\xfd\xdd\xd6\xa2\xa8\xb7\xea\xce\xd6\x09\x7b\xd5\x85\xed\x93\xde\xd7\xba\xc2\x3d\x67\x49\x22\x4b\x61\x6e\xe5\x1d\x6b\x7d\xe9\xd0\x90\xff\x97\xc6\x81\x04\x08\x6b\xf4\x81\xe5\xc6\x4f\xa6\x1c\x74\x97\x4a\x3a\xc9\x16\xbb\x48\x15\xb4\x4c\xb9\x95\xfc\x77\x46\x33\x3f\x40\x9c\x9c\x48\xa4\x2c\xad\x7e\x70\x47\xd9\x58\x58\x8f\xc8\x19\x51\x2c\xe1\x05\x77\x65\xe4\x29\xbe\x47\xc4\x0b\xb5\x11\xb8\xd1\x2c\x9b\xb8\x1c\xf5\x22\xae\xf5\x53\xc9\xef\x8e\x0e\xae\xfc\x0c\x72\x28\xe9\x33\x99\xfb\x5a\x48\x8a\xfd\xc3\xb3\x36\x37\x9b\xdb\x78\x84\xd8\xbc\x02\x4b\xa9\x95\x18\x82\x8f\x15\xdc\x05\x58\x3f\xf6\xf1\x67\x9f\x0a\xae\x00\x79\x6f\x58\x22\x45\x9b\x9a\xaa\x6b\x36\x68\x69\xa4\x8a\x3f\x81\x6d\x94\xa5\x24\x2d\x55\xa8\x99\x3a\xa7\x19\x4f\xb9\x59\x84\x5b\x3b\x57\x5e\x8b\xe2\x89\x09\xdb\xa8\x2b\x30\x12\x5a\x14\x4a\xd2\x64\xc6\x74\xf4\x35\x14\x50\x5c\x10\x59\xf0\x7d\xc7\x12\x70\x20\xa3\x40\x1f\xcb\x20\xb3\x05\x51\xd2\xf8\x8b\xf7\x35\x1f\xbc\x8d\x06\x83\xee\xc8\xe5\x8c\x5a\xc0\xed\xbc\x8c\x87\xc0\x59\xf1\x49\xfc\x87\x26\x32\x4b\x7d\x0a\x93\x3f\xbc\xb2\x42\x61\xe2\x70\xd0\x12\x3f\x48\x70\x61\x24\xc9\x2c\xc3\xb6\x04\x71\x7d\xe7\xdf\xfc\x96\xcc\x64\xa9\xf4\x28\x4e\x3a\xf0\x1a\xde\xa1\x7e\xe7\x85\x4a\x43\x32\x46\xb5\x21\xaf\x5f\x91\x9c\x8b\xd2\xf2\xa9\xce\x68\xd3\x5d\x0e\x8a\x24\xa0\xdf\xfd\xb6\x75\xbf\xae\xb2\xcf\x5a\xa9\xa7\xc0\xdc\xc8\x4e\xf4\x71\x27\x09\x03\xe3\x30\xb3\x78\x43\x10\x72\x44\x37\x86\xb6\x30\xf2\x11\xce\xd7\x8f\xa5\x1c\x2f\x4c\x97\x20\x4a\xd7\xa3\x1e\x3d\xf9\x7f\xdd\xcb\x36\xc9\x53\xaa\xdc\x29\x1b\x3f\xfa\x28\x15\x2e\xa6\x5c\x9b\x2d\xf5\x2d\xaa\xf8\xca\x8d\xcd\xda\xb3\x95\xa9\xd5\x0e\x3a\xc6\xca\x40\x1f\x2f\x11\x7b\xdb\x52\x92\x30\x2c\x66\x79\x51\x55\x4a\x12\x12\xdb\x6e\x1d\xfe\x99\x13\x8e\x79\x04\xd9\x43\xd6\xf4\x96\x4b\x6d\x27\x74\x79\x94\xe8\xbc\x56\xec\x56\x3f\x05\x9a\x8b\x29\x26\x39\xcf\xcb\xcc\xf0\x22\xab\xd6\xfd\xd1\x77\x70\x84\x3c\xb6\xb9\xd1\xc8\x4c\x44\x31\xb0\x18\xb3\x4d\x81\x7d\xf2\x28\x8c\xc5\x84\xc1\x5c\xdd\xca\xf2\x83\x82\x2a\x1a\x80\x07\x95\x74\xf5\xb1\x33\xdf\x51\xb8\x51\x74\xe9\x30\x6d\x2f\x9a\x55\x33\x8e\x6e\x91\xf6\x89\x34\x86\x09\x2a\x5a\x98\xaa\xeb\xe9\xb9\xa0\x13\x91\xf7\xc1\x99\x0c\xcb\xa0\x34\xb0\xc5\x09\x35\x5f\xd2\xe4\x8e\x89\x14\x8b\x46\xc1\xb2\xd3\x85\xa0\xb9\xcb\xb6\x15\xd5\xe3\x6e\xf4\xd7\x03\x67\x98\xc0\xf0\x3d\x1f\x66\x8c\x5c\x77\x9f\x30\x28\x75\xe7\x54\x36\xb6\xcb\xb6\x73\xae\xd1\x64\xa3\xf8\x3c\x61\x9e\xff\xdb\x7e\xfb\x9c\xfa\xbc\x45\x2c\xfd\xd2\xe4\xfd\xf6\x44\xf8\x0b\xe4\x3e\x58\xce\x21\xa9\x16\xcd\xec\xd1\x5e\x84\x98\xd1\xc6\xe6\x8e\x17\xfb\xad\x7a\xa3\xc6\x5d\x22\x7f\x0f\xd5\x38\xad\x1f\xe2\x8f\x34\x95\x9a\x7c\x99\xc9\xe4\x8e\x5c\x30\x10\xba\x1e\xb3\x3c\x8b\x1a\xa7\xcf\x99\xc2\x3b\xa7\xd3\x6d\xf7\x6c\x43\x92\x4b\xc1\x8d\x54\x9b\xe9\xc5\xd3\x95\x9d\xec\xd3\x3d\xaf\xcd\x50\x65\xb1\xf9\x25\x27\x7b\xb6\xe8\xd6\x75\xe3\xa1\x53\x50\xcf\xe0\x74\xe2\x2b\x57\x05\x6c\xc7\xb3\xf6\x8b\x99\xbc\x1f\x1a\x39\x2c\x35\x1b\xf2\x16\x17\xba\x1d\x96\x79\xc7\x16\x70\x8b\xdd\x71\xa1\xae\x5b\x4d\x67\x30\x12\x2c\x50\xf0\xde\x72\xee\x8f\x5f\x5e\x7c\xa3\x99\x1a\xc5\x32\xe0\x09\x33\xc9\x49\xc2\x8a\xd9\x89\x1b\xe1\x45\x02\xc5\x13\x91\xae\x50\xf1\xfd\x90\xcd\x24\x32\xcb\x5c\x60\xb6\x9c\x90\x73\x56\xcc\xc2\xc0\x4f\xbd\xea\xe7\xcb\x08\x5c\x48\xd9\x35\x11\xea\xa1\xed\x53\x3f\x44\xf0\x06\xcf\x50\x84\x4c\x6a\xdc\xad\x08\xc5\x53\xa1\xcf\x8b\x2e\xb5\xf9\x88\xc0\x79\xdc\x74\xca\x87\xb5\x7c\xca\xb1\xbf\x67\x3d\x59\xb2\xf7\x18\xa9\x91\xa0\xab\x09\x0a\xdd\x29\x4b\x89\x9c\x33\xa5\x78\xca\x34\x09\x34\x28\xd6\x52\x79\xf6\xd4\x70\xeb\xf3\x36\x3f\x7b\xde\xe6\x1d\xd4\xa1\x43\xd0\x87\x6a\x64\x0a\xde\x2c\x91\x29\x9a\xe6\x5c\xbc\x38\x42\xa5\x13\x9a\xb1\xab\x0f\x1d\xf4\x0f\xd7\xa3\xae\x82\xdc\xb8\x97\x51\xfe\xb4\x2d\x59\xc9\xbe\x0e\x78\x43\x84\x4c\xb7\x99\x54\x1f\x41\x91\x98\x52\xc3\xee\xb7\xb2\xc3\x61\x45\xa8\xb6\xb7\x04\xe1\xf4\x39\x55\x8e\x17\x91\x23\x30\xc2\x79\x4c\x7a\xb6\x4f\xa6\xea\x76\xad\xab\x71\x12\x7b\xc5\xe9\x77\x9b\x49\x77\x3d\x06\x9f\x5d\x5f\x91\xaf\xb0\xf9\x7e\xb3\x17\x2a\x69\x50\x0c\xbc\x90\x39\xe5\x5d\x8b\x6c\x34\xbb\x37\xb3\xaf\xc6\x4b\xb8\x0e\x6d\x89\x6b\x1c\x15\x70\x99\xf0\x69\x69\x75\x3a\xa7\x87\xbd\xa8\x04\x73\x4b\xa2\xcb\xcb\x4d\x30\xf7\xf0\x6a\x10\x91\xc9\xc9\xfb\x45\x56\x12\x8b\xdf\x4a\x60\x25\xe1\x0e\x94\x68\x26\x34\x87\x0b\x99\xe8\x56\xdc\x55\xfa\xc3\xd2\x92\xe8\x04\x89\x22\xce\x80\xbc\x95\x53\x2e\xfc\xe9\x95\xee\xbe\x6e\x42\x79\xd6\x16\x18\xbd\x4c\xf2\xec\x32\x89\xd6\xd9\xa5\xa0\xe3\xac\x8d\xbb\x41\x1d\xd5\x42\x47\xf2\x26\xa3\x53\xc2\xe0\x8f\x93\x94\x6b\xfb\x7f\x72\x73\xf3\x16\x8c\xf0\xa5\xf0\x12\x33\x18\xa8\x1d\xed\x0b\x41\x0a\x78\x10\xf7\x7b\x76\x90\xf4\xec\x90\xfd\x2f\xea\x49\xb8\x48\xed\xc4\xa3\x52\x70\xe8\x24\x05\x2d\x30\x1f\x62\xf0\xf9\x45\xb7\x81\x31\x23\xb7\x33\x9e\xdc\x5d\x47\x76\x77\xa9\xec\x3b\x11\xbd\xaa\x31\xb0\xe6\x6f\xfb\xa4\x96\x6e\xaa\xd7\xdd\x55\xe3\xa8\xa7\xe7\x03\x9e\x60\xdc\xb8\xf5\xc3\x6f\x54\x6b\x99\xf0\xea\xce\x05\x6c\x34\x15\x73\x48\x81\x39\xec\x77\x4d\x20\x1e\x74\x5d\x0e\xca\x1f\x2b\x38\x9a\xdf\x4d\x5f\x1d\x57\xc7\x1c\x8c\x0b\xbf\xea\xbd\x2e\x01\x71\x66\x87\xd4\xe8\x55\xc7\xe5\xd4\xe8\x5e\x18\x6e\x5c\x2c\x78\x37\x75\xb7\x79\x5e\x10\xf3\xb5\x39\x97\xb6\x2f\xa4\x48\x77\xa9\x09\xf7\xb6\xf0\x36\x61\x1b\xab\xd4\xf0\xc6\x6d\x22\xbe\x73\x57\x0d\x70\xe6\x0a\x59\x94\x19\xfa\x73\x3c\x3c\xbf\xbb\xb7\x19\xe3\x77\xf6\x74\xf5\xf0\x14\x59\x4b\x0f\x63\xc7\xde\xee\x9e\xce\x3f\x8d\xdc\xa5\x91\x70\xf7\xea\x77\xbf\xfd\xed\xe7\x9e\xcd\xb4\xad\x0a\xfe\x18\xe9\x4c\x5b\x9a\x68\x57\xc4\x17\x5d\xf5\xf1\x45\x3f\xdf\xf8\xa2\xc7\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\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\x1e\x1c\x53\xd2\x3d\x09\x60\x77\x7b\xda\x2e\x05\xa9\xaa\x9e\x2b\x35\x48\x1f\x54\xee\x73\x8f\x1d\x1e\xea\x28\xb5\x98\x91\xf6\x04\x3e\x89\x42\x42\x3a\x68\x63\x38\xbc\xec\x52\x1b\xd2\xf5\xf9\x70\xd3\xb8\x98\x09\xaf\x9f\xe7\x3e\xe6\xe7\x70\xe1\xd1\xd7\x74\xf9\x4c\x4c\xee\xba\x96\xad\xc5\x5b\x2b\x80\x04\x00\x23\x97\xe3\x38\x4b\x64\x75\x74\xce\xae\xaf\xac\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\x7d\x8f\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\x6b\x08\xc8\xa9\x5a\xd5\x25\x69\x14\xa5\x69\x96\xc9\x7b\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\x1b\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\xe0\x7e\x02\xde\xb0\x90\x65\xb0\x77\x61\x31\xcc\xb0\x3a\xbd\x02\x4e\xef\xab\x1f\x41\x15\x48\xa5\x37\x4d\x0c\xd9\x27\xae\xcd\xf2\x5a\x3c\x88\x7c\x1a\xbc\x7d\xe1\xcd\x5c\x17\x96\x2d\x74\xae\x6a\x57\xeb\x57\x97\x57\xe6\x37\xf0\xd3\x67\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\x25\xd5\x2c\x25\xef\xa8\xa0\x53\xd4\xf7\x8e\x6e\xae\xbf\x7c\x77\x6c\xf7\x15\xf4\xc9\xab\x8b\x95\x17\x6d\x37\xf1\xe0\xef\xf7\x19\x2f\xb2\xb4\xf0\x1d\x58\xd5\x52\xff\x1d\x17\xbf\xd7\x40\x18\x12\xf8\x50\xbb\x64\xbd\x2b\x58\xd0\x75\x33\x84\xb5\x59\xf3\xb3\x41\x60\xe6\x79\xfa\xc0\x2a\x9f\x5c\x68\x43\xb3\xec\x3a\xa3\xe2\xac\x28\x94\x9c\xaf\xd6\xc6\x6b\x73\xf5\x0d\xfd\x4c\xd1\xcd\xc3\xbf\x2c\x10\xf4\x70\x85\x2d\xc8\x55\x35\xfe\x88\x5c\x99\xa0\x85\x4b\x01\x2c\xf5\xe0\xac\x34\x32\xa7\x86\x27\x07\x56\x59\x3f\x78\x47\x45\x49\xb3\x95\x4e\x57\x1b\x97\xb1\x4e\x44\xdc\xd8\x69\x7d\xea\xba\x16\xdd\x36\xca\x1a\x9b\xfb\x1b\xaa\x2c\x75\x3a\xbf\xf9\xb6\x53\x5f\x6d\xa8\x29\x97\xa8\xf0\x06\xce\xb0\x9e\x17\x0c\x49\x46\xb5\xf9\xa6\x48\xed\xa1\x6f\xfc\xba\x89\xe0\x27\xd4\xd0\x4c\x4e\xff\xc2\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\x6f\xa0\xed\xb9\x14\x29\x47\xb3\x23\x18\xd4\xb0\x47\x7d\xdc\xf5\xa8\xb6\xee\xa6\x61\xc3\xdd\x42\x3d\xbb\x66\x34\x9f\x3a\x28\xb0\xd9\xd8\xc9\x97\x33\x7c\x09\x37\xed\xb5\xb9\x2d\x41\x8a\xdc\x09\x2b\x18\x42\x1e\x91\xd5\x64\x6b\xab\x9c\xb0\x4d\x3e\x18\xfa\x3d\xc6\x29\xac\x77\x1c\x1d\xba\x79\xaf\xbb\x83\xd8\x84\x62\xf8\x6c\x97\x2c\x9a\x53\x59\x4f\x53\x57\xe1\x5d\xe8\x86\x91\x2c\x8d\x82\xfc\xb5\x46\xeb\x79\x40\x2b\xc1\xab\x9d\x8c\xd4\x36\xab\x7d\x9d\xd6\x56\x39\xd8\x97\x54\xd9\x16\x12\xe3\x56\xa6\xd5\x32\xb9\x7c\x5d\xb1\xbe\x72\xfe\x7f\xca\xa9\x22\x94\x14\x9c\x61\xf2\x13\x2a\x1c\xb0\x80\xb3\x30\x9a\xba\x97\x96\x83\x59\x95\x10\x7e\x1b\xb8\xcb\x70\x34\x2e\x3b\x5f\x0b\x6f\xa0\xa6\x98\xfc\x03\x2e\x2e\x4e\xbe\x92\xce\xc8\xeb\x82\x74\x2d\x0d\x00\x4e\x3e\x20\xba\x4c\x66\x84\x6a\x3b\x35\x8b\xd0\xf6\xc4\xb3\x51\x4e\x05\x9f\x30\x6d\x46\x21\x4b\xb0\xfe\xfe\x37\x3f\x8c\xc8\x1b\xa9\x88\x73\x54\x1f\xf8\xac\x1a\x6e\x9e\x15\x5e\x70\x8d\x8b\x09\x7d\x2b\xad\xb5\x90\xa9\x9b\xf4\x3d\x4c\xd6\xd0\x3b\xcb\xc3\x70\xb2\x25\x83\xab\x8b\x53\x72\x60\xc5\xc4\xe8\xd3\xff\xb2\x6c\xe9\x3f\x07\xe4\xe8\x1e\x98\xf6\x81\xfd\xf3\x00\x3f\x18\xdc\x26\x63\xa5\xba\xfa\x30\x06\x4b\x2a\x3e\x9d\x32\x85\xea\x23\x81\xa0\xc2\x63\x97\x15\x44\xc8\xa8\xb1\xbf\x94\xae\xd4\xcd\xe6\x44\xbe\xff\xcd\x0f\x07\xe4\xa8\xbe\x2e\xc2\x45\xca\x3e\x91\xdf\xa0\x75\x99\x6b\xbb\xc6\x63\x77\x99\xa3\x17\xc2\xd0\x4f\x76\xcc\x64\x26\x35\x13\xa8\xca\x1b\x49\x66\x74\xce\x88\x96\x56\x03\x66\x59\x36\x74\xb6\x74\x72\x4f\x21\x53\x8b\x07\x25\x04\xd6\x93\x82\x2a\x53\x43\x89\x91\xb3\x90\xc0\xd7\xec\xb6\x4d\x85\xbf\x99\x9e\x70\xe1\xee\xaf\xdc\xcd\x99\xdd\x73\x08\x0c\xc5\x4d\x32\x92\x24\x33\x2a\xa6\x21\x36\x7d\x52\x9a\x52\xb1\x2d\x57\x3f\x2d\xcf\xc0\x1d\x17\x9d\x42\x98\xbf\xe6\xa2\xe9\x54\xb0\xda\xae\x34\xe5\xc6\x47\x45\x38\x5f\x45\xb3\x38\xb1\xbb\xa0\xf8\xb8\x34\x52\xe9\x93\x94\xcd\x59\x76\xa2\xf9\x74\x48\x55\x32\xe3\x86\x25\x76\x59\x27\xb4\xe0\xc3\x44\x0a\xbb\xe3\x90\x95\x21\x4f\x7f\x01\xe5\x4d\x87\x76\xaa\x5b\xb2\x4e\xb7\x5c\xf4\x76\xa3\xda\xb3\x1a\xd3\xf6\xb6\xc6\x16\xf6\xa0\xe5\x85\xa2\x6d\xe6\x09\x56\x0b\x86\x90\x93\xbd\x2c\xd6\x27\x4d\xee\xce\x63\x0e\x5d\x1e\xf0\xa4\x39\x86\x3d\x76\xe8\x40\x02\xa7\xb2\x46\x29\x73\x9a\x22\x29\xa5\x62\xf1\xe8\xc8\x6f\x41\x0a\xe9\xf2\x93\xc5\x10\x86\x90\xd9\x90\x8a\xd4\xfe\x1b\x03\x76\x92\xc5\x5e\x60\x58\xf2\x4e\x84\xe0\x9b\xab\x8b\xa7\x39\x12\x25\xdf\xc3\xa9\x77\xf2\x5a\x4b\x21\x0a\x45\x55\x74\xd4\x50\x25\xf3\x4c\xb3\x2e\xa0\x72\xed\x47\xfd\x6f\x77\xff\x12\xb2\x9d\x6d\x13\xa9\x36\xdf\x9a\x44\xb2\x63\xcb\xf9\xbe\xad\x7a\xc4\x36\x39\x70\xbc\xa2\xda\xb8\xd4\x5a\x3e\x07\x41\x6d\x19\x5e\x41\x01\x06\xb3\xfe\x62\xb8\x15\x0e\x79\x7f\x01\x3b\x91\xe1\xca\x9c\x4b\x49\x50\x4a\xb6\x2b\x50\x95\xfe\x52\xab\x83\x86\x8b\x32\x4c\x1b\x42\xe7\x94\x67\x60\x9d\x97\x63\xcd\xd4\x1c\x0b\x52\xb9\x54\x83\xb4\xa9\x67\xb9\x9a\x13\x28\x46\x3d\x91\xe6\xe3\xd7\xb0\xbc\x2b\x9b\x16\x00\xda\x50\x63\xf6\x6b\x67\xbd\x17\xbd\x07\xd5\xcb\xb5\x3f\xdb\x2f\xec\xa8\xc6\x58\xfc\xfb\x0b\xa3\xca\x8c\x19\x35\xb7\x7c\x13\xdf\x5d\x42\xe9\x5a\xbf\x50\xca\x3d\x20\xf4\x3d\x23\x53\x69\xac\x88\x55\x02\xee\xa3\x4c\x8a\x49\x7d\x02\xa2\x3d\x36\x46\x57\xab\xbc\x55\x14\x42\x7c\xa4\xe8\xb8\xcc\x7a\xc7\xe5\x75\x3a\xe9\xd8\x61\x92\xc1\xd6\x98\x48\x43\x0a\xe6\xf6\x0e\x6f\x33\x80\x02\x3d\xcd\x92\x73\xa6\xf5\xc6\x04\x1b\x75\xef\x42\x6c\x8d\x47\xb9\x71\xb5\x96\xfb\xdf\x30\x2c\xc4\x0a\xd0\x29\x33\x94\x67\xfe\x28\x23\x28\x02\x94\xb6\x51\xd7\x8d\x0b\x54\x8c\xea\x4d\x02\x42\x6d\xd6\x1f\xa1\x31\x4e\x5a\x0a\x36\xbc\x97\x2a\x25\xe7\x34\x67\xd9\x39\xd5\xcc\x8d\x15\x87\xe8\xe1\x1e\x1d\xea\xbd\x4e\x79\xb5\xed\x6b\xcd\x94\xd1\xf8\x53\x99\x84\xe1\xaf\x4a\xc5\xc2\x09\x0e\xbc\x09\xf2\x56\x95\x6c\x40\xde\x58\xee\x35\x20\xdf\x88\x3b\x21\xef\x1f\x36\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\x8a\x09\x17\xdc\xb7\x75\x7a\x57\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\x6f\xbe\x5d\x0f\xec\xb5\xbc\x6f\x1b\x7f\xda\x6e\x96\x7a\xa8\x41\x6a\xeb\x99\xd9\x6a\x84\xea\xcd\x4f\xbd\xf9\xe9\x73\x32\x3f\x6d\xc5\xf8\x4d\x26\xa7\xcf\xc3\xd8\xb4\x75\x89\x9b\x0c\x4c\x2f\xd2\xb4\xd4\x6a\x45\x1b\xcd\x49\x2f\xd6\x90\xb4\x75\x69\x2d\x8d\x47\x3f\x1f\xb3\xd1\x56\x88\x6d\x30\x15\xbd\x40\x23\x51\x1b\x81\x8c\xa5\x6d\xc4\xc4\xab\xa8\x71\x2c\x28\x56\xe5\x2c\xc3\x70\xde\x29\x27\x16\x67\x76\x95\x16\xad\x00\xb7\x75\x6e\x87\x6e\x72\xed\x65\x2f\x27\x30\xba\x62\x8f\x4b\x93\x25\x17\x97\xd7\x1f\x2f\xcf\xcf\x6e\x2f\x2f\x9a\xf2\xdd\x2a\x48\x6f\x91\xc4\x36\xdb\x20\x86\x91\x24\xb6\xa6\x81\x25\xc8\x6b\x7e\xb2\x38\xb0\xe6\xa7\xb2\xe4\xab\x7a\x3d\x5c\x2e\x7c\x10\x97\x7b\x10\xff\xd8\x7e\x3a\xdb\x1e\xcf\x6f\xd0\x71\x8a\x3a\x9f\x33\x2b\xf7\xcc\x64\x96\x6a\xef\xb7\x7a\x75\x11\x22\xa9\xb8\x48\xb2\x32\xb5\xc2\xc5\x37\xdf\x5c\x5d\xe8\x11\x21\x5f\xb2\x84\x96\x1a\xac\x30\xa9\x14\x87\x86\x7c\x78\xff\xf6\x7f\xc0\x1f\x1b\x5a\x0c\x42\x5e\x13\xc8\xca\xcb\x29\x26\x16\x36\x98\xae\x8d\x7c\xc9\x50\x50\x81\x2f\x27\xb4\xb0\x54\x4c\x63\xe5\x0a\x03\xb2\xc8\x8c\x65\x85\xa5\x98\x77\x8c\x54\x19\x54\xed\xc0\x55\x85\x79\xef\x3e\x39\x65\x06\xa3\xae\x36\x79\x48\x6e\x84\xda\x16\x8b\xeb\x03\x6c\xad\x35\xf5\xd1\x69\xe3\xf7\x54\x3b\x8b\xd5\xca\xd9\x6e\xd9\xdf\xed\xf6\x99\xf5\x26\x8e\x35\xc6\x0d\x24\xcf\xf0\xd7\xd2\x9c\xed\x64\x2b\x3b\x06\x3a\x91\x70\xd3\xda\x9a\xba\xde\x0d\x68\x75\x1d\x80\x25\x5b\x06\x6b\x02\xb9\xf6\xe1\xe0\x91\x1d\x4d\xb9\xdd\x5c\xa0\x88\x48\x5a\xab\xfd\xe9\xfc\xe7\xea\xef\xca\x71\xa8\xfe\x5a\xcd\xd7\x59\x64\xc8\xbf\xfe\xf3\xc5\xff\x1f\x00\x00\xff\xff\x9d\xd9\x48\xd2\xa7\x53\x02\x00") +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") 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 b203d9a18d..e048d4988c 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,18 +84,6 @@ type SubscriptionConfig struct { // List of VolumeMounts to set in the container. // +optional VolumeMounts []corev1.VolumeMount `json:"volumeMounts,omitempty"` - - // Describes node affinity scheduling rules for the pod. - // +optional - NodeAffinity *corev1.NodeAffinity `json:"nodeAffinity,omitempty" protobuf:"bytes,1,opt,name=nodeAffinity"` - - // Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)). - // +optional - PodAffinity *corev1.PodAffinity `json:"podAffinity,omitempty" protobuf:"bytes,2,opt,name=podAffinity"` - - // Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)). - // +optional - PodAntiAffinity *corev1.PodAntiAffinity `json:"podAntiAffinity,omitempty" protobuf:"bytes,3,opt,name=podAntiAffinity"` } // 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 8b9a736964..c094738eed 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,21 +1394,6 @@ func (in *SubscriptionConfig) DeepCopyInto(out *SubscriptionConfig) { (*in)[i].DeepCopyInto(&(*out)[i]) } } - if in.NodeAffinity != nil { - in, out := &in.NodeAffinity, &out.NodeAffinity - *out = new(v1.NodeAffinity) - (*in).DeepCopyInto(*out) - } - if in.PodAffinity != nil { - in, out := &in.PodAffinity, &out.PodAffinity - *out = new(v1.PodAffinity) - (*in).DeepCopyInto(*out) - } - if in.PodAntiAffinity != nil { - in, out := &in.PodAntiAffinity, &out.PodAntiAffinity - *out = new(v1.PodAntiAffinity) - (*in).DeepCopyInto(*out) - } } // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SubscriptionConfig. From 8dddfea293d405dc5e75779bd7e9c50950ba62e5 Mon Sep 17 00:00:00 2001 From: perdasilva Date: Mon, 1 Aug 2022 15:39:57 +0200 Subject: [PATCH 03/15] Add affinity to subscription.config Signed-off-by: perdasilva Upstream-repository: api Upstream-commit: ae4da2a9ec6a5c8e8725f62eecd5c18bb1816658 --- .../0000_50_olm_00-subscriptions.crd.yaml | 461 ++++++++++++++++++ .../operators.coreos.com_subscriptions.yaml | 461 ++++++++++++++++++ staging/api/crds/zz_defs.go | 2 +- .../operators/v1alpha1/subscription_types.go | 6 + .../v1alpha1/zz_generated.deepcopy.go | 5 + .../operators.coreos.com_subscriptions.yaml | 461 ++++++++++++++++++ .../operator-framework/api/crds/zz_defs.go | 2 +- .../operators/v1alpha1/subscription_types.go | 6 + .../v1alpha1/zz_generated.deepcopy.go | 5 + 9 files changed, 1407 insertions(+), 2 deletions(-) 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/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/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. From d89e58aac1feb3d4df4da47cac7d753ee491c8e1 Mon Sep 17 00:00:00 2001 From: Eng Zer Jun Date: Tue, 2 Aug 2022 01:57:08 +0800 Subject: [PATCH 04/15] test: use `T.TempDir` to create temporary test directory (#1004) This commit replaces `ioutil.TempDir` with `t.TempDir` in tests. The directory created by `t.TempDir` is automatically removed when the test and all its subtests complete. Prior to this commit, temporary directory created using `ioutil.TempDir` needs to be removed manually by calling `os.RemoveAll`, which is omitted in some tests. The error handling boilerplate e.g. defer func() { if err := os.RemoveAll(dir); err != nil { t.Fatal(err) } } is also tedious, but `t.TempDir` handles this for us nicely. Reference: https://pkg.go.dev/testing#T.TempDir Signed-off-by: Eng Zer Jun Upstream-repository: operator-registry Upstream-commit: 43e43240dd9c32dcb7742e96afb1ab3fd63a9ce2 --- .../alpha/action/migrate_test.go | 6 +++--- .../alpha/action/render_test.go | 16 ++++++---------- .../alpha/property/property_test.go | 4 +--- staging/operator-registry/pkg/image/mock_test.go | 7 ++----- .../pkg/lib/bundle/generate_test.go | 6 ++---- .../pkg/lib/registry/registry_test.go | 3 +-- .../pkg/registry/populator_test.go | 4 +--- .../pkg/sqlite/conversion_test.go | 8 +------- .../pkg/sqlite/directory_test.go | 9 +-------- 9 files changed, 18 insertions(+), 45 deletions(-) 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 From f68c64a876b8bf9af5bdde6e81dc82a72f9ea17f Mon Sep 17 00:00:00 2001 From: Tim Flannagan Date: Wed, 3 Aug 2022 16:37:09 -0400 Subject: [PATCH 05/15] Makefile,scripts: Refactor tool dependencies (#1001) Signed-off-by: timflannagan Upstream-repository: operator-registry Upstream-commit: 732b5722825e085c045b94fbb5ae36dcb8df59c3 --- staging/operator-registry/Makefile | 37 ++++++++++++++++++++++--- staging/operator-registry/scripts/fetch | 31 --------------------- 2 files changed, 33 insertions(+), 35 deletions(-) delete mode 100755 staging/operator-registry/scripts/fetch 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/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 $@ From 2480e650aae9806569e9265584652273356c253d Mon Sep 17 00:00:00 2001 From: Tim Flannagan Date: Mon, 8 Aug 2022 14:24:33 -0400 Subject: [PATCH 06/15] .github: Remove the unused 'retest' action (#1002) Signed-off-by: timflannagan Upstream-repository: operator-registry Upstream-commit: 33ed9ea30b4daea03435c2ba3839a6ce79894a75 --- .../.github/workflows/retest.yaml | 14 -------------- 1 file changed, 14 deletions(-) delete mode 100644 staging/operator-registry/.github/workflows/retest.yaml 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 }} From 7929c80e8e5be293a8e8cca7e6eeea42b3c65d34 Mon Sep 17 00:00:00 2001 From: Tyler Slaton <54378333+tylerslaton@users.noreply.github.com> Date: Tue, 2 Aug 2022 11:16:15 -0400 Subject: [PATCH 07/15] fix(openshift): use env var instead of clusterversion status (#2817) Get the current OpenShift release version from the RELEASE_VERSION environment variable since the behavior of the original source -- the ClusterVersion desired release status field -- has changed. Signed-off-by: Tyler Slaton Co-authored-by: Nick Hale Upstream-repository: operator-lifecycle-manager Upstream-commit: b2086bd2c5eb9b60370869757c51fa7908d2cde0 From 2f1e138a1ea3b0b191417da4a2bea3c06a00d8ea Mon Sep 17 00:00:00 2001 From: Anik Bhattacharjee Date: Tue, 2 Aug 2022 12:25:13 -0400 Subject: [PATCH 08/15] (psa) make workloads compatible with psa:restricted profile (#2820) * (psa) make workloads compatible with psa:restricted profile With the introduction of [Pod Security Admission](https://kubernetes.io/docs/concepts/security/pod-security-admission/#pod-security-admission-labels-for-namespaces), the reccomeneded best practice is to enforce the Restricted policy of admission (see [1] for more details). This PR *) Lables the olm namespace as `enforce:restricted` *) Labels the operators namespace as `enforce:baseline` (to allow existing CSV deployments without securityContext set to deploy in the namespace, which won't be possible with `enforce:resticted`) *) updates the securityContext of olm workload pods(olm-operator, catalog-operator, and CatalogSource registry pods) to adhere to the `Restricted` policy. *) updates the bundle unpacking job to create a pod that adheres to the `Restricted` policy, so that bundles can be unpacked in the `Restricted` namespace. Signed-off-by: Anik Bhattacharjee * (flaky text fix): GC CSV with wrong namespace annotation The test was modifying the `olm.operatornamespace` to an incorrect value, and checking to make sure that the CSV was garbage collected as a result. However, the olm-controller was copying a fresh copy back into the namespace, so whenever the test was able to get a yes reply to the question "is the CSV gone", in the brief window before it was copied back again, the test was passing. This commit fixes that by making sure that if find a CSV that we expected to be garbage collected, it passes if it determines that the CSV is a fresh copy, and not the one modified before. Signed-off-by: Anik Bhattacharjee Upstream-repository: operator-lifecycle-manager Upstream-commit: 67177c0c822fbe7d554669262c6b4f54bebad17f --- manifests/0000_50_olm_00-namespace.yaml | 14 +- ...operator.deployment.ibm-cloud-managed.yaml | 18 +-- ...000_50_olm_07-olm-operator.deployment.yaml | 18 +-- ...operator.deployment.ibm-cloud-managed.yaml | 20 +-- ...50_olm_08-catalog-operator.deployment.yaml | 20 +-- pkg/manifests/csv.yaml | 18 +-- staging/operator-lifecycle-manager/Dockerfile | 1 + .../Dockerfile.goreleaser | 1 + .../cmd/catalog/main.go | 6 + .../cmd/catalog/start.go | 2 + .../templates/0000_50_olm_00-namespace.yaml | 6 + ...000_50_olm_07-olm-operator.deployment.yaml | 8 + ...50_olm_08-catalog-operator.deployment.yaml | 10 ++ .../_packageserver.deployment-spec.yaml | 12 +- .../operator-lifecycle-manager/e2e.Dockerfile | 1 + .../pkg/controller/bundle/bundle_unpacker.go | 36 ++++- .../controller/bundle/bundle_unpacker_test.go | 153 ++++++++++++++++++ .../controller/operators/catalog/operator.go | 12 +- .../operators/catalog/operator_test.go | 4 +- .../registry/reconciler/configmap.go | 16 +- .../registry/reconciler/configmap_test.go | 8 +- .../controller/registry/reconciler/grpc.go | 16 +- .../registry/reconciler/grpc_test.go | 4 +- .../registry/reconciler/reconciler.go | 42 +++-- .../registry/reconciler/reconciler_test.go | 19 ++- .../test/e2e/operator_groups_e2e_test.go | 43 +++-- .../cmd/catalog/main.go | 6 + .../cmd/catalog/start.go | 2 + .../pkg/controller/bundle/bundle_unpacker.go | 36 ++++- .../controller/operators/catalog/operator.go | 12 +- .../registry/reconciler/configmap.go | 16 +- .../controller/registry/reconciler/grpc.go | 16 +- .../registry/reconciler/reconciler.go | 42 +++-- 33 files changed, 482 insertions(+), 156 deletions(-) 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_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..542d16b628 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,8 @@ 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 +89,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 +104,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..9714d9e815 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,8 @@ 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 +89,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 +105,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/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/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/templates/0000_50_olm_00-namespace.yaml b/staging/operator-lifecycle-manager/deploy/chart/templates/0000_50_olm_00-namespace.yaml index d42268a59b..6575fb2ea4 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,15 @@ apiVersion: v1 kind: Namespace metadata: name: {{ .Values.namespace }} + labels: + pod-security.kubernetes.io/enforce: restricted + pod-security.kubernetes.io/enforce-version: latest --- apiVersion: v1 kind: Namespace metadata: name: {{ .Values.operator_namespace }} + labels: + pod-security.kubernetes.io/enforce: baseline + pod-security.kubernetes.io/enforce-version: latest 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..f3fbe99993 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,8 @@ spec: - --client-ca - /profile-collector-cert/tls.crt {{- end }} + - --set-workload-user-id + - "true" 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/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/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/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..51b07250c7 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 @@ -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) @@ -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/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/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/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/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/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 From a12a958b75f0b7bb5a0bfacecf5e5b1f5acbfa73 Mon Sep 17 00:00:00 2001 From: Per Goncalves da Silva Date: Fri, 5 Aug 2022 20:27:34 +0200 Subject: [PATCH 09/15] Add support for Subscription.config.affinity (#2826) * vendor new o_f/api version Signed-off-by: perdasilva * Update olm controller to handle Subscription.config.affinity Signed-off-by: perdasilva Upstream-repository: operator-lifecycle-manager Upstream-commit: 55230179df33811fce196cca595c474bf4faaeff --- go.mod | 2 +- .../0000_50_olm_00-subscriptions.crd.yaml | 461 ++++++++++++++++ staging/operator-lifecycle-manager/go.mod | 2 +- staging/operator-lifecycle-manager/go.sum | 4 +- .../operators/olm/overrides/config.go | 3 +- .../operators/olm/overrides/initializer.go | 6 +- .../operators/olm/overrides/inject/inject.go | 68 +++ .../olm/overrides/inject/inject_test.go | 504 ++++++++++++++++++ .../operators/olm/overrides/config.go | 3 +- .../operators/olm/overrides/initializer.go | 6 +- .../operators/olm/overrides/inject/inject.go | 68 +++ vendor/modules.txt | 2 +- 12 files changed, 1120 insertions(+), 9 deletions(-) diff --git a/go.mod b/go.mod index 97e9c9f63a..d5d9690d13 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.15.1-0.20220801135701-ae4da2a9ec6a 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/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/go.mod b/staging/operator-lifecycle-manager/go.mod index 8ce2e89a0a..d8b46089e9 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.15.1-0.20220801135701-ae4da2a9ec6a 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..61db239d31 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.15.1-0.20220801135701-ae4da2a9ec6a h1:KrRy9j95k4jHSXkyYUooQdAFju9eeER0izslDBUvcmA= +github.com/operator-framework/api v0.15.1-0.20220801135701-ae4da2a9ec6a/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/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/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/modules.txt b/vendor/modules.txt index ee062bc7a0..4fe350f71c 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.15.1-0.20220801135701-ae4da2a9ec6a => ./staging/api ## explicit; go 1.18 github.com/operator-framework/api/crds github.com/operator-framework/api/pkg/constraints From e9df05eda090f4edfec2cd773ab7a7f3e4eb1a4a Mon Sep 17 00:00:00 2001 From: Anik Bhattacharjee Date: Mon, 8 Aug 2022 12:27:25 -0400 Subject: [PATCH 10/15] (manifests): populate pod security configs dynamically (#2831) This PR: * introduces a chart value that decides if the --set-workload-user-id flag to true or false for the catalog-operator container * introduces chart values to fill in the psa enforce level/version for the namespaces Closes #2827 Signed-off-by: Anik Bhattacharjee Upstream-repository: operator-lifecycle-manager Upstream-commit: f982e2fbeecfcb917665ed760363326e313b2967 --- ...atalog-operator.deployment.ibm-cloud-managed.yaml | 3 +-- .../0000_50_olm_08-catalog-operator.deployment.yaml | 3 +-- .../chart/templates/0000_50_olm_00-namespace.yaml | 12 ++++++++---- .../0000_50_olm_08-catalog-operator.deployment.yaml | 7 +++++-- .../deploy/chart/values.yaml | 9 +++++++++ .../deploy/upstream/values.yaml | 9 +++++++++ 6 files changed, 33 insertions(+), 10 deletions(-) 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 542d16b628..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 @@ -64,8 +64,7 @@ spec: - /srv-cert/tls.key - --client-ca - /profile-collector-cert/tls.crt - - --set-workload-user-id - - "true" + - --set-workload-user-id=true image: quay.io/operator-framework/olm@sha256:de396b540b82219812061d0d753440d5655250c621c753ed1dc67d6154741607 imagePullPolicy: IfNotPresent ports: diff --git a/manifests/0000_50_olm_08-catalog-operator.deployment.yaml b/manifests/0000_50_olm_08-catalog-operator.deployment.yaml index 9714d9e815..53167adeef 100644 --- a/manifests/0000_50_olm_08-catalog-operator.deployment.yaml +++ b/manifests/0000_50_olm_08-catalog-operator.deployment.yaml @@ -64,8 +64,7 @@ spec: - /srv-cert/tls.key - --client-ca - /profile-collector-cert/tls.crt - - --set-workload-user-id - - "true" + - --set-workload-user-id=true image: quay.io/operator-framework/olm@sha256:de396b540b82219812061d0d753440d5655250c621c753ed1dc67d6154741607 imagePullPolicy: IfNotPresent ports: 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 6575fb2ea4..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 @@ -3,8 +3,10 @@ kind: Namespace metadata: name: {{ .Values.namespace }} labels: - pod-security.kubernetes.io/enforce: restricted - pod-security.kubernetes.io/enforce-version: latest + {{- 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 @@ -12,5 +14,7 @@ kind: Namespace metadata: name: {{ .Values.operator_namespace }} labels: - pod-security.kubernetes.io/enforce: baseline - pod-security.kubernetes.io/enforce-version: latest + {{- 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_08-catalog-operator.deployment.yaml b/staging/operator-lifecycle-manager/deploy/chart/templates/0000_50_olm_08-catalog-operator.deployment.yaml index f3fbe99993..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 @@ -84,8 +84,11 @@ spec: - --client-ca - /profile-collector-cert/tls.crt {{- end }} - - --set-workload-user-id - - "true" + {{- 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/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 From 66c1aab7d8a35eea8350f032dd7953d53ced21d3 Mon Sep 17 00:00:00 2001 From: Alexander Greene Date: Mon, 8 Aug 2022 11:14:09 -0700 Subject: [PATCH 11/15] Cleanup conversion webhooks when an operator is uninstalled (#2832) Problem: When uninstalling a CSV, OLM has always avoided deleting the associated CRD as all CRs on cluster are subsequently deleted, possibly resulting in user dataloss. OLM supports defining conversion webhooks within the CSV. On cluster, conversion webhooks are defined with a CRD and point to a service that handles conversion. If the service is unable to fulfill the request, all requests against the CRs associated with the CRD will fail. When uninstalling a CSV, OLM does not remove the conversion webhook from the CRD, meaning that all requests against the CRs associated with the CRD will fail, resulting in at least two concerns: 1. OLM is unable to subsequently reinstall the operator. When installing a CSV, if the CRD already exists and instances of CRs exist as well, OLM performs a series of checks which ensure that none of the CRs are invalidated against the new schema. The existing CRD's conversion webhooks points to a non-existant service, causing the check to fail and preventing installs. 2. Broken conversion webhooks causes kubernete's garbage collection to fail. Solution: When a CSV is deleted, if no CSV exists that is replacing it, set the CRD's conversion strategy to None. Signed-off-by: Alexander Greene Upstream-repository: operator-lifecycle-manager Upstream-commit: 94374983d448c56d031f0493b84b6dce37b84741 --- .../pkg/controller/operators/olm/operator.go | 41 +++++++++++++++++++ .../test/e2e/csv_e2e_test.go | 3 ++ .../test/e2e/webhook_e2e_test.go | 22 +++++++++- .../pkg/controller/operators/olm/operator.go | 41 +++++++++++++++++++ 4 files changed, 106 insertions(+), 1 deletion(-) 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/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/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/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 { From 8d2ab96d1c73d736de7ccc10536c4fc5df0c00a0 Mon Sep 17 00:00:00 2001 From: Joe Lanford Date: Tue, 9 Aug 2022 10:08:14 -0400 Subject: [PATCH 12/15] improve CA and certificate generation (#2834) Recently during an audit on a user's cluster, it was discovered that OLM's certificate generation functionality has a few minor shortcomings. 1) The generated CA and server cert do not include a common name, which causes some tooling to have trouble tracing the cert chain. 2) The generated CA and server cert include unnecessary key usages, which means those certificates can be used for more than their intended purposes. This commit resolves the above issues by ensuring the certificates include common names and by using the minimal key usages necessary. Signed-off-by: Joe Lanford Upstream-repository: operator-lifecycle-manager Upstream-commit: 13fa7be0e153711a9ef6b8c3d4315ce088ad6274 --- .../pkg/controller/certs/certs.go | 8 ++++---- .../pkg/controller/certs/certs.go | 8 ++++---- 2 files changed, 8 insertions(+), 8 deletions(-) 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/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, } From edf863d1fc52d62897753a397f5fa5420c787731 Mon Sep 17 00:00:00 2001 From: grokspawn Date: Tue, 9 Aug 2022 13:11:09 -0500 Subject: [PATCH 13/15] deprecate io/ioutil for io or os (#2835) Signed-off-by: Jordan Keister Upstream-repository: operator-lifecycle-manager Upstream-commit: c312b41e3079b5cb1672120046b376f50cb4246f --- .../pkg/controller/operators/catalog/operator_test.go | 8 ++++---- .../pkg/lib/filemonitor/cabundle_updater.go | 6 +++--- .../pkg/lib/filemonitor/cert_updater_test.go | 3 +-- .../pkg/package-server/storage/subresources.go | 4 ++-- .../test/e2e/ctx/provisioner_kind.go | 3 +-- .../test/e2e/setup_bare_test.go | 3 +-- staging/operator-lifecycle-manager/test/e2e/split/main.go | 3 +-- staging/operator-lifecycle-manager/util/cpb/main.go | 3 +-- .../pkg/lib/filemonitor/cabundle_updater.go | 6 +++--- .../pkg/package-server/storage/subresources.go | 4 ++-- .../operator-lifecycle-manager/util/cpb/main.go | 3 +-- 11 files changed, 20 insertions(+), 26 deletions(-) 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 51b07250c7..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{} @@ -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) 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/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/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/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/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) } From 885fd5a318761b8f467b7bf17e77c80b1d17f383 Mon Sep 17 00:00:00 2001 From: grokspawn Date: Tue, 9 Aug 2022 13:44:11 -0500 Subject: [PATCH 14/15] add grokspawn to OWNERS (#2833) Signed-off-by: Jordan Keister Upstream-repository: operator-lifecycle-manager Upstream-commit: 8a56bcc6e3f9b9e25cbbc003ef17c710622771fa --- staging/operator-lifecycle-manager/OWNERS | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) 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 From 2ea706fa7d23d1cff389fb396e21696c3d30db07 Mon Sep 17 00:00:00 2001 From: Per Goncalves da Silva Date: Wed, 10 Aug 2022 13:35:40 +0200 Subject: [PATCH 15/15] Update o_f/api dependency to v0.16.0 (#2836) Signed-off-by: perdasilva Upstream-repository: operator-lifecycle-manager Upstream-commit: 82d17f39785d0e7fdc0d6b77c35209c5c915bad6 --- go.mod | 2 +- staging/operator-lifecycle-manager/go.mod | 2 +- staging/operator-lifecycle-manager/go.sum | 4 ++-- vendor/modules.txt | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/go.mod b/go.mod index d5d9690d13..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.1-0.20220801135701-ae4da2a9ec6a + 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/staging/operator-lifecycle-manager/go.mod b/staging/operator-lifecycle-manager/go.mod index d8b46089e9..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.1-0.20220801135701-ae4da2a9ec6a + 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 61db239d31..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.1-0.20220801135701-ae4da2a9ec6a h1:KrRy9j95k4jHSXkyYUooQdAFju9eeER0izslDBUvcmA= -github.com/operator-framework/api v0.15.1-0.20220801135701-ae4da2a9ec6a/go.mod h1:kk8xJahHJR3bKqrA+A+1VIrhOTmyV76k+ARv+iV+u1Q= +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/vendor/modules.txt b/vendor/modules.txt index 4fe350f71c..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.1-0.20220801135701-ae4da2a9ec6a => ./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