diff --git a/src/adapter/src/catalog.rs b/src/adapter/src/catalog.rs index 6797407f6e57d..455d4c8ae2e88 100644 --- a/src/adapter/src/catalog.rs +++ b/src/adapter/src/catalog.rs @@ -518,14 +518,51 @@ impl Catalog { Fut: Future, { let persist_client = PersistClient::new_for_tests().await; - let environmentd_id = Uuid::new_v4(); + let organization_id = Uuid::new_v4(); let bootstrap_args = test_bootstrap_args(); - let catalog = Self::open_debug_catalog(persist_client, environmentd_id, &bootstrap_args) + let catalog = Self::open_debug_catalog(persist_client, organization_id, &bootstrap_args) .await .expect("can open debug catalog"); f(catalog).await } + /// Like [`Catalog::with_debug`], but the catalog created believes that bootstrap is still + /// in progress. + pub async fn with_debug_in_bootstrap(f: F) -> T + where + F: FnOnce(Catalog) -> Fut, + Fut: Future, + { + let persist_client = PersistClient::new_for_tests().await; + let organization_id = Uuid::new_v4(); + let bootstrap_args = test_bootstrap_args(); + let mut catalog = + Self::open_debug_catalog(persist_client.clone(), organization_id, &bootstrap_args) + .await + .expect("can open debug catalog"); + + // Replace `storage` in `catalog` with one that doesn't think bootstrap is over. + let now = SYSTEM_TIME.clone(); + let openable_storage = TestCatalogStateBuilder::new(persist_client) + .with_organization_id(organization_id) + .with_default_deploy_generation() + .build() + .await + .expect("can create durable catalog"); + let mut storage = openable_storage + .open(now(), &bootstrap_args) + .await + .expect("can open durable catalog"); + // Drain updates. + let _ = storage + .sync_to_current_updates() + .await + .expect("can sync to current updates"); + catalog.storage = Arc::new(tokio::sync::Mutex::new(storage)); + + f(catalog).await + } + /// Opens a debug catalog. /// /// See [`Catalog::with_debug`]. @@ -718,13 +755,17 @@ impl Catalog { #[cfg(test)] pub async fn allocate_system_id(&self) -> Result<(CatalogItemId, GlobalId), Error> { use mz_ore::collections::CollectionExt; - self.storage() - .await - .allocate_system_ids(1) - .await - .maybe_terminate("allocating system ids") - .map(|ids| ids.into_element()) - .err_into() + + let mut storage = self.storage().await; + let mut txn = storage.transaction().await?; + let id = txn + .allocate_system_item_ids(1) + .maybe_terminate("allocating system ids")? + .into_element(); + // Drain transaction. + let _ = txn.get_and_commit_op_updates(); + txn.commit().await?; + Ok(id) } /// Get the next system item ID without allocating it. diff --git a/src/adapter/src/catalog/open.rs b/src/adapter/src/catalog/open.rs index 8fd7bb8324bcb..3201c1241c0c6 100644 --- a/src/adapter/src/catalog/open.rs +++ b/src/adapter/src/catalog/open.rs @@ -28,9 +28,7 @@ use mz_catalog::config::{ClusterReplicaSizeMap, StateConfig}; use mz_catalog::durable::objects::{ SystemObjectDescription, SystemObjectMapping, SystemObjectUniqueIdentifier, }; -use mz_catalog::durable::{ - ClusterVariant, ClusterVariantManaged, Transaction, SYSTEM_CLUSTER_ID_ALLOC_KEY, -}; +use mz_catalog::durable::{ClusterVariant, ClusterVariantManaged, Transaction}; use mz_catalog::expr_cache::{ ExpressionCacheConfig, ExpressionCacheHandle, GlobalExpressions, LocalExpressions, }; @@ -632,6 +630,8 @@ impl Catalog { ); } + catalog.storage().await.mark_bootstrap_complete(); + Ok(OpenCatalogResult { catalog, storage_collections_to_drop, @@ -772,6 +772,10 @@ impl Catalog { let (new_item_id, new_global_id) = match id { CatalogItemId::System(_) => txn.allocate_system_item_ids(1)?.into_element(), + CatalogItemId::IntrospectionSourceIndex(id) => ( + CatalogItemId::IntrospectionSourceIndex(id), + GlobalId::IntrospectionSourceIndex(id), + ), CatalogItemId::User(_) => txn.allocate_user_item_ids(1)?.into_element(), _ => unreachable!("can't migrate id: {id}"), }; @@ -1222,10 +1226,7 @@ fn add_new_builtin_clusters_migration( if !cluster_names.contains(builtin_cluster.name) { let cluster_size = builtin_cluster_sizes.get_size(builtin_cluster.name)?; let cluster_allocation = cluster_sizes.get_allocation_by_name(&cluster_size)?; - let id = txn.get_and_increment_id(SYSTEM_CLUSTER_ID_ALLOC_KEY.to_string())?; - let id = ClusterId::System(id); txn.insert_system_cluster( - id, builtin_cluster.name, vec![], builtin_cluster.privileges.to_vec(), @@ -1265,13 +1266,9 @@ fn add_new_remove_old_builtin_introspection_source_migration( } } - let new_ids = txn.allocate_system_item_ids(usize_to_u64(new_logs.len()))?; - let new_entries = new_logs - .into_iter() - .zip_eq(new_ids) - .map(|(log, (item_id, gid))| (log, item_id, gid)); - - for (log, item_id, gid) in new_entries { + for log in new_logs { + let (item_id, gid) = + Transaction::allocate_introspection_source_index_id(&cluster.id, log.variant); new_indexes.push((cluster.id, log.name.to_string(), item_id, gid)); } @@ -1757,7 +1754,7 @@ mod builtin_migration_tests { } async fn run_test_case(test_case: BuiltinMigrationTestCase) { - Catalog::with_debug(|mut catalog| async move { + Catalog::with_debug_in_bootstrap(|mut catalog| async move { let mut item_id_mapping = BTreeMap::new(); let mut name_mapping = BTreeMap::new(); diff --git a/src/adapter/src/catalog/transact.rs b/src/adapter/src/catalog/transact.rs index 8d7c7a7d6c598..b0f0f4ae707c1 100644 --- a/src/adapter/src/catalog/transact.rs +++ b/src/adapter/src/catalog/transact.rs @@ -32,7 +32,6 @@ use mz_catalog::memory::objects::{ use mz_catalog::SYSTEM_CONN_ID; use mz_controller::clusters::{ManagedReplicaLocation, ReplicaConfig, ReplicaLocation}; use mz_controller_types::{ClusterId, ReplicaId}; -use mz_ore::cast::usize_to_u64; use mz_ore::collections::HashSet; use mz_ore::instrument; use mz_ore::now::EpochMillis; @@ -56,6 +55,7 @@ use mz_sql::session::vars::{Value as VarValue, VarInput}; use mz_sql::{rbac, DEFAULT_SCHEMA}; use mz_sql_parser::ast::{QualifiedReplica, Value}; use mz_storage_client::controller::StorageController; +use timely::Container; use tracing::{info, trace}; use crate::catalog::{ @@ -903,12 +903,19 @@ impl Catalog { let privileges: Vec<_> = merge_mz_acl_items(owner_privileges.into_iter().chain(default_privileges)) .collect(); - let introspection_source_ids = - tx.allocate_system_item_ids(usize_to_u64(introspection_sources.len()))?; + let introspection_source_ids: Vec<_> = introspection_sources + .iter() + .map(|introspection_source| { + Transaction::allocate_introspection_source_index_id( + &id, + introspection_source.variant, + ) + }) + .collect(); let introspection_sources = introspection_sources .into_iter() - .zip_eq(introspection_source_ids.into_iter()) + .zip_eq(introspection_source_ids) .map(|(log, (item_id, gid))| (log, item_id, gid)) .collect(); diff --git a/src/adapter/src/coord.rs b/src/adapter/src/coord.rs index 1f6b168f31d48..bdab547960915 100644 --- a/src/adapter/src/coord.rs +++ b/src/adapter/src/coord.rs @@ -2301,7 +2301,8 @@ impl Coordinator { let id_too_large = match id { CatalogItemId::System(id) => *id >= next_system_item_id, CatalogItemId::User(id) => *id >= next_user_item_id, - CatalogItemId::Transient(_) => false, + CatalogItemId::IntrospectionSourceIndex(_) + | CatalogItemId::Transient(_) => false, }; if id_too_large { info!( diff --git a/src/buf.yaml b/src/buf.yaml index 7d95c86b18247..4f8eb808adc55 100644 --- a/src/buf.yaml +++ b/src/buf.yaml @@ -30,6 +30,8 @@ breaking: # reason: does currently not require backward-compatibility - catalog/protos/objects_v72.proto # reason: does currently not require backward-compatibility + - catalog/protos/objects_v73.proto + # reason: does currently not require backward-compatibility - cluster-client/src/client.proto # reason: does currently not require backward-compatibility - compute-client/src/logging.proto diff --git a/src/catalog/protos/hashes.json b/src/catalog/protos/hashes.json index 644d9f46bdd89..9275319365237 100644 --- a/src/catalog/protos/hashes.json +++ b/src/catalog/protos/hashes.json @@ -1,7 +1,7 @@ [ { "name": "objects.proto", - "md5": "2d781c72c4a56b13dfb1b4215f3614f0" + "md5": "9404d316bbf1ffa30c1fe7b37180c936" }, { "name": "objects_v67.proto", @@ -26,5 +26,9 @@ { "name": "objects_v72.proto", "md5": "b21cb2b1b41649c78405731e53560d59" + }, + { + "name": "objects_v73.proto", + "md5": "4e64aa50e0cc6dc6cb9e5ef05be0dc08" } ] diff --git a/src/catalog/protos/objects.proto b/src/catalog/protos/objects.proto index 42a9cfcbdbf07..47cc57b98d25e 100644 --- a/src/catalog/protos/objects.proto +++ b/src/catalog/protos/objects.proto @@ -78,12 +78,12 @@ message ClusterIntrospectionSourceIndexKey { } message ClusterIntrospectionSourceIndexValue { - // TODO(parkmycar): Ideally this is a SystemCatalogItemId but making this change panics 0dt + // TODO(parkmycar): Ideally this is a IntrospectionSourceCatalogItemId but making this change panics 0dt // upgrades if there were new builtin objects added since the older version of Materialize - // doesn't know how to read the new SystemCatalogItemId type. + // doesn't know how to read the new IntrospectionSourceCatalogItemId type. uint64 index_id = 1; uint32 oid = 2; - SystemGlobalId global_id = 3; + IntrospectionSourceIndexGlobalId global_id = 3; } message ClusterReplicaKey { @@ -307,6 +307,8 @@ message CatalogItemId { uint64 system = 1; uint64 user = 2; uint64 transient = 3; + // This needs to be 5 to match the GlobalId tag. + uint64 introspection_source_index = 5; } } @@ -315,12 +317,18 @@ message SystemCatalogItemId { uint64 value = 1; } +/// A newtype wrapper for a `CatalogItemId` that is always in the "introspection source index" namespace. +message IntrospectionSourceIndexCatalogItemId { + uint64 value = 1; +} + message GlobalId { oneof value { uint64 system = 1; uint64 user = 2; uint64 transient = 3; Empty explain = 4; + uint64 introspection_source_index = 5; } } @@ -329,10 +337,15 @@ message SystemGlobalId { uint64 value = 1; } +/// A newtype wrapper for a `GlobalId` that is always in the "introspection source index" namespace. +message IntrospectionSourceIndexGlobalId { + uint64 value = 1; +} + message ClusterId { oneof value { - uint64 system = 1; - uint64 user = 2; + uint32 system = 1; + uint32 user = 2; } } diff --git a/src/catalog/protos/objects_v73.proto b/src/catalog/protos/objects_v73.proto new file mode 100644 index 0000000000000..2a8de42d391d3 --- /dev/null +++ b/src/catalog/protos/objects_v73.proto @@ -0,0 +1,1074 @@ +// Copyright Materialize, Inc. and contributors. All rights reserved. +// +// Use of this software is governed by the Business Source License +// included in the LICENSE file. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0. + +// This protobuf file defines the types we store in the Stash. +// +// Before and after modifying this file, make sure you have a snapshot of the before version, +// e.g. a copy of this file named 'objects_v{CATALOG_VERSION}.proto', and a snapshot of the file +// after your modifications, e.g. 'objects_v{CATALOG_VERSION + 1}.proto'. Then you can write a +// migration using these two files, and no matter how the types change in the future, we'll always +// have these snapshots to facilitate the migration. + +// buf breaking: ignore (does currently not require backward-compatibility) + +syntax = "proto3"; + +package objects_v73; + +message ConfigKey { + string key = 1; +} + +message ConfigValue { + uint64 value = 1; +} + +message SettingKey { + string name = 1; +} + +message SettingValue { + string value = 1; +} + +message IdAllocKey { + string name = 1; +} + +message IdAllocValue { + uint64 next_id = 1; +} + +message GidMappingKey { + string schema_name = 1; + CatalogItemType object_type = 2; + string object_name = 3; +} + +message GidMappingValue { + // TODO(parkmycar): Ideally this is a SystemCatalogItemId but making this change panics 0dt + // upgrades if there were new builtin objects added since the older version of Materialize + // doesn't know how to read the new SystemCatalogItemId type. + uint64 id = 1; + string fingerprint = 2; + SystemGlobalId global_id = 3; +} + +message ClusterKey { + ClusterId id = 1; +} + +message ClusterValue { + reserved 2; + string name = 1; + RoleId owner_id = 3; + repeated MzAclItem privileges = 4; + ClusterConfig config = 5; +} + +message ClusterIntrospectionSourceIndexKey { + ClusterId cluster_id = 1; + string name = 2; +} + +message ClusterIntrospectionSourceIndexValue { + // TODO(parkmycar): Ideally this is a IntrospectionSourceCatalogItemId but making this change panics 0dt + // upgrades if there were new builtin objects added since the older version of Materialize + // doesn't know how to read the new IntrospectionSourceCatalogItemId type. + uint64 index_id = 1; + uint32 oid = 2; + IntrospectionSourceIndexGlobalId global_id = 3; +} + +message ClusterReplicaKey { + ReplicaId id = 1; +} + +message ClusterReplicaValue { + ClusterId cluster_id = 1; + string name = 2; + ReplicaConfig config = 3; + RoleId owner_id = 4; +} + +message DatabaseKey { + DatabaseId id = 1; +} + +message DatabaseValue { + string name = 1; + RoleId owner_id = 2; + repeated MzAclItem privileges = 3; + uint32 oid = 4; +} + +message SchemaKey { + SchemaId id = 1; +} + +message SchemaValue { + DatabaseId database_id = 1; + string name = 2; + RoleId owner_id = 3; + repeated MzAclItem privileges = 4; + uint32 oid = 5; +} + +message ItemKey { + CatalogItemId gid = 1; +} + +message ItemValue { + SchemaId schema_id = 1; + string name = 2; + CatalogItem definition = 3; + RoleId owner_id = 4; + repeated MzAclItem privileges = 5; + uint32 oid = 6; + GlobalId global_id = 7; + repeated ItemVersion extra_versions = 8; +} + +message ItemVersion { + GlobalId global_id = 1; + Version version = 2; +} + +message RoleKey { + RoleId id = 1; +} + +message RoleValue { + string name = 1; + RoleAttributes attributes = 2; + RoleMembership membership = 3; + RoleVars vars = 4; + uint32 oid = 5; +} + +message NetworkPolicyKey { + NetworkPolicyId id = 1; +} + +message NetworkPolicyValue { + string name = 1; + repeated NetworkPolicyRule rules = 2; + RoleId owner_id = 3; + repeated MzAclItem privileges = 4; + uint32 oid = 5; +} + +message ServerConfigurationKey { + string name = 1; +} + +message ServerConfigurationValue { + string value = 1; +} + +message AuditLogKey { + oneof event { + AuditLogEventV1 v1 = 1; + } +} + +message CommentKey { + oneof object { + CatalogItemId table = 1; + CatalogItemId view = 2; + CatalogItemId materialized_view = 4; + CatalogItemId source = 5; + CatalogItemId sink = 6; + CatalogItemId index = 7; + CatalogItemId func = 8; + CatalogItemId connection = 9; + CatalogItemId type = 10; + CatalogItemId secret = 11; + CatalogItemId continual_task = 17; + RoleId role = 12; + DatabaseId database = 13; + ResolvedSchema schema = 14; + ClusterId cluster = 15; + ClusterReplicaId cluster_replica = 16; + NetworkPolicyId network_policy = 18; + } + oneof sub_component { + uint64 column_pos = 3; + } +} + +message CommentValue { + string comment = 1; +} + +message SourceReferencesKey { + CatalogItemId source = 1; +} + +message SourceReferencesValue { + repeated SourceReference references = 1; + EpochMillis updated_at = 2; +} + +message SourceReference { + string name = 1; + optional string namespace = 2; + repeated string columns = 3; +} + +message StorageCollectionMetadataKey { + GlobalId id = 1; +} + +// This value is stored transparently, however, it should only ever be +// manipulated by the storage controller. +message StorageCollectionMetadataValue { + string shard = 1; +} + +// This value is stored transparently, however, it should only ever be +// manipulated by the storage controller. +message UnfinalizedShardKey { + string shard = 1; +} + +// This value is stored transparently, however, it should only ever be +// manipulated by the storage controller. +message TxnWalShardValue { + string shard = 1; +} + +// ---- Common Types +// +// Note: Normally types like this would go in some sort of `common.proto` file, but we want to keep +// our proto definitions in a single file to make snapshotting easier, hence them living here. + +message Empty { + /* purposefully empty */ +} + +// In protobuf a "None" string is the same thing as an empty string. To get the same semantics of +// an `Option` from Rust, we need to wrap a string in a message. +message StringWrapper { + string inner = 1; +} + +message Duration { + uint64 secs = 1; + uint32 nanos = 2; +} + +message EpochMillis { + uint64 millis = 1; +} + +// Opaque timestamp type that is specific to Materialize. +message Timestamp { + uint64 internal = 1; +} + +message Version { + uint64 value = 2; +} + +enum CatalogItemType { + CATALOG_ITEM_TYPE_UNKNOWN = 0; + CATALOG_ITEM_TYPE_TABLE = 1; + CATALOG_ITEM_TYPE_SOURCE = 2; + CATALOG_ITEM_TYPE_SINK = 3; + CATALOG_ITEM_TYPE_VIEW = 4; + CATALOG_ITEM_TYPE_MATERIALIZED_VIEW = 5; + CATALOG_ITEM_TYPE_INDEX = 6; + CATALOG_ITEM_TYPE_TYPE = 7; + CATALOG_ITEM_TYPE_FUNC = 8; + CATALOG_ITEM_TYPE_SECRET = 9; + CATALOG_ITEM_TYPE_CONNECTION = 10; + CATALOG_ITEM_TYPE_CONTINUAL_TASK = 11; +} + +message CatalogItem { + message V1 { + string create_sql = 1; + } + + oneof value { + V1 v1 = 1; + } +} + +message CatalogItemId { + oneof value { + uint64 system = 1; + uint64 user = 2; + uint64 transient = 3; + // This needs to be 5 to match the GlobalId tag. + uint64 introspection_source_index = 5; + } +} + +/// A newtype wrapper for a `CatalogItemId` that is always in the "system" namespace. +message SystemCatalogItemId { + uint64 value = 1; +} + +/// A newtype wrapper for a `CatalogItemId` that is always in the "introspection source index" namespace. +message IntrospectionSourceIndexCatalogItemId { + uint64 value = 1; +} + +message GlobalId { + oneof value { + uint64 system = 1; + uint64 user = 2; + uint64 transient = 3; + Empty explain = 4; + uint64 introspection_source_index = 5; + } +} + +/// A newtype wrapper for a `GlobalId` that is always in the "system" namespace. +message SystemGlobalId { + uint64 value = 1; +} + +/// A newtype wrapper for a `GlobalId` that is always in the "introspection source index" namespace. +message IntrospectionSourceIndexGlobalId { + uint64 value = 1; +} + +message ClusterId { + oneof value { + uint32 system = 1; + uint32 user = 2; + } +} + +message DatabaseId { + oneof value { + uint64 system = 1; + uint64 user = 2; + } +} + +message ResolvedDatabaseSpecifier { + oneof spec { + Empty ambient = 1; + DatabaseId id = 2; + } +} + +message SchemaId { + oneof value { + uint64 system = 1; + uint64 user = 2; + } +} + +message SchemaSpecifier { + oneof spec { + Empty temporary = 1; + SchemaId id = 2; + } +} + +message ResolvedSchema { + ResolvedDatabaseSpecifier database = 1; + SchemaSpecifier schema = 2; +} + +message ReplicaId { + oneof value { + uint64 system = 1; + uint64 user = 2; + } +} + +message ClusterReplicaId { + ClusterId cluster_id = 1; + ReplicaId replica_id = 2; +} + +message NetworkPolicyId { + oneof value { + uint64 system = 1; + uint64 user = 2; + } +} + +message ReplicaLogging { + bool log_logging = 1; + Duration interval = 2; +} + +message OptimizerFeatureOverride { + string name = 1; + string value = 2; +} + +message ClusterScheduleRefreshOptions { + Duration rehydration_time_estimate = 1; +} + +message ClusterSchedule { + oneof value { + Empty manual = 1; + ClusterScheduleRefreshOptions refresh = 2; + } +} + +message ClusterConfig { + message ManagedCluster { + string size = 1; + uint32 replication_factor = 2; + repeated string availability_zones = 3; + ReplicaLogging logging = 4; + bool disk = 6; + repeated OptimizerFeatureOverride optimizer_feature_overrides = 7; + ClusterSchedule schedule = 8; + } + + oneof variant { + Empty unmanaged = 1; + ManagedCluster managed = 2; + } + optional string workload_class = 3; +} + +message ReplicaConfig { + message UnmanagedLocation { + repeated string storagectl_addrs = 1; + repeated string storage_addrs = 2; + repeated string computectl_addrs = 3; + repeated string compute_addrs = 4; + uint64 workers = 5; + } + + message ManagedLocation { + string size = 1; + optional string availability_zone = 2; + bool disk = 4; + bool internal = 5; + optional string billed_as = 6; + bool pending = 7; + } + + oneof location { + UnmanagedLocation unmanaged = 1; + ManagedLocation managed = 2; + } + ReplicaLogging logging = 3; +} + +message RoleId { + oneof value { + uint64 system = 1; + uint64 user = 2; + Empty public = 3; + uint64 predefined = 4; + } +} + +message RoleAttributes { + bool inherit = 1; +} + +message RoleMembership { + message Entry { + RoleId key = 1; + RoleId value = 2; + } + + repeated Entry map = 1; +} + +message RoleVars { + message SqlSet { + repeated string entries = 1; + } + + message Entry { + string key = 1; + oneof val { + string flat = 2; + SqlSet sql_set = 3; + } + } + + repeated Entry entries = 1; +} + +message NetworkPolicyRule { + string name = 1; + oneof action { + Empty allow = 2; + } + oneof direction { + Empty ingress = 3; + } + string address = 4; +} + +message AclMode { + // A bit flag representing all the privileges that can be granted to a role. + uint64 bitflags = 1; +} + +message MzAclItem { + RoleId grantee = 1; + RoleId grantor = 2; + AclMode acl_mode = 3; +} + +enum ObjectType { + OBJECT_TYPE_UNKNOWN = 0; + OBJECT_TYPE_TABLE = 1; + OBJECT_TYPE_VIEW = 2; + OBJECT_TYPE_MATERIALIZED_VIEW = 3; + OBJECT_TYPE_SOURCE = 4; + OBJECT_TYPE_SINK = 5; + OBJECT_TYPE_INDEX = 6; + OBJECT_TYPE_TYPE = 7; + OBJECT_TYPE_ROLE = 8; + OBJECT_TYPE_CLUSTER = 9; + OBJECT_TYPE_CLUSTER_REPLICA = 10; + OBJECT_TYPE_SECRET = 11; + OBJECT_TYPE_CONNECTION = 12; + OBJECT_TYPE_DATABASE = 13; + OBJECT_TYPE_SCHEMA = 14; + OBJECT_TYPE_FUNC = 15; + OBJECT_TYPE_CONTINUAL_TASK = 16; + OBJECT_TYPE_NETWORK_POLICY = 17; +} + +message DefaultPrivilegesKey { + RoleId role_id = 1; + DatabaseId database_id = 2; + SchemaId schema_id = 3; + ObjectType object_type = 4; + RoleId grantee = 5; +} + +message DefaultPrivilegesValue { + AclMode privileges = 1; +} + +message SystemPrivilegesKey { + RoleId grantee = 1; + RoleId grantor = 2; +} + +message SystemPrivilegesValue { + AclMode acl_mode = 1; +} + +message AuditLogEventV1 { + enum EventType { + EVENT_TYPE_UNKNOWN = 0; + EVENT_TYPE_CREATE = 1; + EVENT_TYPE_DROP = 2; + EVENT_TYPE_ALTER = 3; + EVENT_TYPE_GRANT = 4; + EVENT_TYPE_REVOKE = 5; + EVENT_TYPE_COMMENT = 6; + } + + enum ObjectType { + OBJECT_TYPE_UNKNOWN = 0; + OBJECT_TYPE_CLUSTER = 1; + OBJECT_TYPE_CLUSTER_REPLICA = 2; + OBJECT_TYPE_CONNECTION = 3; + OBJECT_TYPE_DATABASE = 4; + OBJECT_TYPE_FUNC = 5; + OBJECT_TYPE_INDEX = 6; + OBJECT_TYPE_MATERIALIZED_VIEW = 7; + OBJECT_TYPE_ROLE = 8; + OBJECT_TYPE_SECRET = 9; + OBJECT_TYPE_SCHEMA = 10; + OBJECT_TYPE_SINK = 11; + OBJECT_TYPE_SOURCE = 12; + OBJECT_TYPE_TABLE = 13; + OBJECT_TYPE_TYPE = 14; + OBJECT_TYPE_VIEW = 15; + OBJECT_TYPE_SYSTEM = 16; + OBJECT_TYPE_CONTINUAL_TASK = 17; + OBJECT_TYPE_NETWORK_POLICY = 18; + } + + message IdFullNameV1 { + string id = 1; + FullNameV1 name = 2; + } + + message FullNameV1 { + string database = 1; + string schema = 2; + string item = 3; + } + + message IdNameV1 { + string id = 1; + string name = 2; + } + + message RenameClusterV1 { + string id = 1; + string old_name = 2; + string new_name = 3; + } + + message RenameClusterReplicaV1 { + string cluster_id = 1; + string replica_id = 2; + string old_name = 3; + string new_name = 4; + } + + message RenameItemV1 { + string id = 1; + FullNameV1 old_name = 2; + FullNameV1 new_name = 3; + } + + message CreateClusterReplicaV1 { + string cluster_id = 1; + string cluster_name = 2; + StringWrapper replica_id = 3; + string replica_name = 4; + string logical_size = 5; + bool disk = 6; + optional string billed_as = 7; + bool internal = 8; + } + + message CreateClusterReplicaV2 { + string cluster_id = 1; + string cluster_name = 2; + StringWrapper replica_id = 3; + string replica_name = 4; + string logical_size = 5; + bool disk = 6; + optional string billed_as = 7; + bool internal = 8; + CreateOrDropClusterReplicaReasonV1 reason = 9; + SchedulingDecisionsWithReasonsV1 scheduling_policies = 10; + } + + message CreateClusterReplicaV3 { + string cluster_id = 1; + string cluster_name = 2; + StringWrapper replica_id = 3; + string replica_name = 4; + string logical_size = 5; + bool disk = 6; + optional string billed_as = 7; + bool internal = 8; + CreateOrDropClusterReplicaReasonV1 reason = 9; + SchedulingDecisionsWithReasonsV2 scheduling_policies = 10; + } + + message DropClusterReplicaV1 { + string cluster_id = 1; + string cluster_name = 2; + StringWrapper replica_id = 3; + string replica_name = 4; + } + + message DropClusterReplicaV2 { + string cluster_id = 1; + string cluster_name = 2; + StringWrapper replica_id = 3; + string replica_name = 4; + CreateOrDropClusterReplicaReasonV1 reason = 5; + SchedulingDecisionsWithReasonsV1 scheduling_policies = 6; + } + + message DropClusterReplicaV3 { + string cluster_id = 1; + string cluster_name = 2; + StringWrapper replica_id = 3; + string replica_name = 4; + CreateOrDropClusterReplicaReasonV1 reason = 5; + SchedulingDecisionsWithReasonsV2 scheduling_policies = 6; + } + + message CreateOrDropClusterReplicaReasonV1 { + oneof reason { + Empty Manual = 1; + Empty Schedule = 2; + Empty System = 3; + } + } + + message SchedulingDecisionsWithReasonsV1 { + RefreshDecisionWithReasonV1 on_refresh = 1; + } + + message SchedulingDecisionsWithReasonsV2 { + RefreshDecisionWithReasonV2 on_refresh = 1; + } + + message RefreshDecisionWithReasonV1 { + oneof decision { + Empty On = 1; + Empty Off = 2; + } + repeated string objects_needing_refresh = 3; + string rehydration_time_estimate = 4; + } + + message RefreshDecisionWithReasonV2 { + oneof decision { + Empty On = 1; + Empty Off = 2; + } + repeated string objects_needing_refresh = 3; + repeated string objects_needing_compaction = 5; + string rehydration_time_estimate = 4; + } + + message CreateSourceSinkV1 { + string id = 1; + FullNameV1 name = 2; + StringWrapper size = 3; + } + + message CreateSourceSinkV2 { + string id = 1; + FullNameV1 name = 2; + StringWrapper size = 3; + string external_type = 4; + } + + message CreateSourceSinkV3 { + string id = 1; + FullNameV1 name = 2; + string external_type = 3; + } + + message CreateSourceSinkV4 { + string id = 1; + StringWrapper cluster_id = 2; + FullNameV1 name = 3; + string external_type = 4; + } + + message CreateIndexV1 { + string id = 1; + string cluster_id = 2; + FullNameV1 name = 3; + } + + message CreateMaterializedViewV1 { + string id = 1; + string cluster_id = 2; + FullNameV1 name = 3; + } + + message AlterSourceSinkV1 { + string id = 1; + FullNameV1 name = 2; + StringWrapper old_size = 3; + StringWrapper new_size = 4; + } + + message AlterSetClusterV1 { + string id = 1; + FullNameV1 name = 2; + StringWrapper old_cluster = 3; + StringWrapper new_cluster = 4; + } + + message GrantRoleV1 { + string role_id = 1; + string member_id = 2; + string grantor_id = 3; + } + + message GrantRoleV2 { + string role_id = 1; + string member_id = 2; + string grantor_id = 3; + string executed_by = 4; + } + + message RevokeRoleV1 { + string role_id = 1; + string member_id = 2; + } + + message RevokeRoleV2 { + string role_id = 1; + string member_id = 2; + string grantor_id = 3; + string executed_by = 4; + } + + message UpdatePrivilegeV1 { + string object_id = 1; + string grantee_id = 2; + string grantor_id = 3; + string privileges = 4; + } + + message AlterDefaultPrivilegeV1 { + string role_id = 1; + StringWrapper database_id = 2; + StringWrapper schema_id = 3; + string grantee_id = 4; + string privileges = 5; + } + + message UpdateOwnerV1 { + string object_id = 1; + string old_owner_id = 2; + string new_owner_id = 3; + } + + message SchemaV1 { + string id = 1; + string name = 2; + string database_name = 3; + } + + message SchemaV2 { + string id = 1; + string name = 2; + StringWrapper database_name = 3; + } + + message RenameSchemaV1 { + string id = 1; + optional string database_name = 2; + string old_name = 3; + string new_name = 4; + } + + message UpdateItemV1 { + string id = 1; + FullNameV1 name = 2; + } + + message AlterRetainHistoryV1 { + string id = 1; + optional string old_history = 2; + optional string new_history = 3; + } + + message ToNewIdV1 { + string id = 1; + string new_id = 2; + } + + message FromPreviousIdV1 { + string id = 1; + string previous_id = 2; + } + + message SetV1 { + string name = 1; + optional string value = 2; + } + + message RotateKeysV1 { + string id = 1; + string name = 2; + } + + uint64 id = 1; + EventType event_type = 2; + ObjectType object_type = 3; + StringWrapper user = 4; + EpochMillis occurred_at = 5; + + // next-id: 40 + oneof details { + CreateClusterReplicaV1 create_cluster_replica_v1 = 6; + CreateClusterReplicaV2 create_cluster_replica_v2 = 33; + CreateClusterReplicaV3 create_cluster_replica_v3 = 41; + DropClusterReplicaV1 drop_cluster_replica_v1 = 7; + DropClusterReplicaV2 drop_cluster_replica_v2 = 34; + DropClusterReplicaV3 drop_cluster_replica_v3 = 42; + CreateSourceSinkV1 create_source_sink_v1 = 8; + CreateSourceSinkV2 create_source_sink_v2 = 9; + AlterSourceSinkV1 alter_source_sink_v1 = 10; + AlterSetClusterV1 alter_set_cluster_v1 = 25; + GrantRoleV1 grant_role_v1 = 11; + GrantRoleV2 grant_role_v2 = 12; + RevokeRoleV1 revoke_role_v1 = 13; + RevokeRoleV2 revoke_role_v2 = 14; + UpdatePrivilegeV1 update_privilege_v1 = 22; + AlterDefaultPrivilegeV1 alter_default_privilege_v1 = 23; + UpdateOwnerV1 update_owner_v1 = 24; + IdFullNameV1 id_full_name_v1 = 15; + RenameClusterV1 rename_cluster_v1 = 20; + RenameClusterReplicaV1 rename_cluster_replica_v1 = 21; + RenameItemV1 rename_item_v1 = 16; + IdNameV1 id_name_v1 = 17; + SchemaV1 schema_v1 = 18; + SchemaV2 schema_v2 = 19; + RenameSchemaV1 rename_schema_v1 = 27; + UpdateItemV1 update_item_v1 = 26; + CreateSourceSinkV3 create_source_sink_v3 = 29; + AlterRetainHistoryV1 alter_retain_history_v1 = 30; + ToNewIdV1 to_new_id_v1 = 31; + FromPreviousIdV1 from_previous_id_v1 = 32; + SetV1 set_v1 = 35; + Empty reset_all_v1 = 36; + RotateKeysV1 rotate_keys_v1 = 37; + CreateSourceSinkV4 create_source_sink_v4 = 38; + CreateIndexV1 create_index_v1 = 39; + CreateMaterializedViewV1 create_materialized_view_v1 = 40; + } +} + +// Wrapper of key-values used by the persist implementation to serialize the catalog. +message StateUpdateKind { + reserved "Epoch"; + + message AuditLog { + AuditLogKey key = 1; + } + + message Cluster { + ClusterKey key = 1; + ClusterValue value = 2; + } + + message ClusterReplica { + ClusterReplicaKey key = 1; + ClusterReplicaValue value = 2; + } + + message Comment { + CommentKey key = 1; + CommentValue value = 2; + } + + message Config { + ConfigKey key = 1; + ConfigValue value = 2; + } + + message Database { + DatabaseKey key = 1; + DatabaseValue value = 2; + } + + message DefaultPrivileges { + DefaultPrivilegesKey key = 1; + DefaultPrivilegesValue value = 2; + } + + message FenceToken { + uint64 deploy_generation = 1; + int64 epoch = 2; + } + + message IdAlloc { + IdAllocKey key = 1; + IdAllocValue value = 2; + } + + message ClusterIntrospectionSourceIndex { + ClusterIntrospectionSourceIndexKey key = 1; + ClusterIntrospectionSourceIndexValue value = 2; + } + + message Item { + ItemKey key = 1; + ItemValue value = 2; + } + + message Role { + RoleKey key = 1; + RoleValue value = 2; + } + + message NetworkPolicy { + NetworkPolicyKey key = 1; + NetworkPolicyValue value = 2; + } + + message Schema { + SchemaKey key = 1; + SchemaValue value = 2; + } + + message Setting { + SettingKey key = 1; + SettingValue value = 2; + } + + message ServerConfiguration { + ServerConfigurationKey key = 1; + ServerConfigurationValue value = 2; + } + + message SourceReferences { + SourceReferencesKey key = 1; + SourceReferencesValue value = 2; + } + + message GidMapping { + GidMappingKey key = 1; + GidMappingValue value = 2; + } + + message SystemPrivileges { + SystemPrivilegesKey key = 1; + SystemPrivilegesValue value = 2; + } + + message StorageCollectionMetadata { + StorageCollectionMetadataKey key = 1; + StorageCollectionMetadataValue value = 2; + } + + message UnfinalizedShard { + UnfinalizedShardKey key = 1; + } + + message TxnWalShard { + TxnWalShardValue value = 1; + } + + reserved 15; + reserved "storage_usage"; + reserved 19; + reserved "timestamp"; + reserved 22; + reserved "persist_txn_shard"; + reserved 8; + reserved "epoch"; + + oneof kind { + AuditLog audit_log = 1; + Cluster cluster = 2; + ClusterReplica cluster_replica = 3; + Comment comment = 4; + Config config = 5; + Database database = 6; + DefaultPrivileges default_privileges = 7; + IdAlloc id_alloc = 9; + ClusterIntrospectionSourceIndex cluster_introspection_source_index = 10; + Item item = 11; + Role role = 12; + Schema schema = 13; + Setting setting = 14; + ServerConfiguration server_configuration = 16; + GidMapping gid_mapping = 17; + SystemPrivileges system_privileges = 18; + StorageCollectionMetadata storage_collection_metadata = 20; + UnfinalizedShard unfinalized_shard = 21; + TxnWalShard txn_wal_shard = 23; + SourceReferences source_references = 24; + FenceToken fence_token = 25; + NetworkPolicy network_policy = 26; + } +} diff --git a/src/catalog/src/durable.rs b/src/catalog/src/durable.rs index e547808ddbbd4..d466279c86073 100644 --- a/src/catalog/src/durable.rs +++ b/src/catalog/src/durable.rs @@ -16,14 +16,14 @@ use std::time::Duration; use async_trait::async_trait; use mz_audit_log::VersionedEvent; -use uuid::Uuid; - use mz_controller_types::ClusterId; use mz_ore::collections::CollectionExt; use mz_ore::metrics::MetricsRegistry; use mz_ore::now::EpochMillis; use mz_persist_client::PersistClient; use mz_repr::{CatalogItemId, GlobalId}; +use mz_sql::catalog::CatalogError as SqlCatalogError; +use uuid::Uuid; use crate::config::ClusterReplicaSizeMap; use crate::durable::debug::{DebugCatalogState, Trace}; @@ -203,6 +203,9 @@ pub trait ReadOnlyDurableCatalogState: Debug + Send { /// Politely releases all external resources that can only be released in an async context. async fn expire(self: Box); + /// Returns true if the system bootstrapping process is complete, false otherwise. + fn is_bootstrap_complete(&self) -> bool; + /// Get all audit log events. /// /// Results are guaranteed to be sorted by ID. @@ -271,6 +274,9 @@ pub trait DurableCatalogState: ReadOnlyDurableCatalogState { /// Returns true if the catalog is opened is savepoint mode, false otherwise. fn is_savepoint(&self) -> bool; + /// Marks the bootstrap process as complete. + fn mark_bootstrap_complete(&mut self); + /// Creates a new durable catalog state transaction. async fn transaction(&mut self) -> Result; @@ -299,18 +305,6 @@ pub trait DurableCatalogState: ReadOnlyDurableCatalogState { Ok(ids) } - /// Allocates and returns `amount` system [`CatalogItemId`]s. - async fn allocate_system_ids( - &mut self, - amount: u64, - ) -> Result, CatalogError> { - let id = self.allocate_id(SYSTEM_ITEM_ALLOC_KEY, amount).await?; - Ok(id - .into_iter() - .map(|id| (CatalogItemId::System(id), GlobalId::System(id))) - .collect()) - } - /// Allocates and returns both a user [`CatalogItemId`] and [`GlobalId`]. async fn allocate_user_id(&mut self) -> Result<(CatalogItemId, GlobalId), CatalogError> { let id = self.allocate_id(USER_ITEM_ALLOC_KEY, 1).await?; @@ -321,7 +315,10 @@ pub trait DurableCatalogState: ReadOnlyDurableCatalogState { /// Allocates and returns a user [`ClusterId`]. async fn allocate_user_cluster_id(&mut self) -> Result { let id = self.allocate_id(USER_CLUSTER_ID_ALLOC_KEY, 1).await?; - let id = id.into_element(); + let id: u32 = id + .into_element() + .try_into() + .map_err(|_| SqlCatalogError::IdExhaustion)?; Ok(ClusterId::User(id)) } } diff --git a/src/catalog/src/durable/initialize.rs b/src/catalog/src/durable/initialize.rs index e559c01d87926..1c10472c750ab 100644 --- a/src/catalog/src/durable/initialize.rs +++ b/src/catalog/src/durable/initialize.rs @@ -247,7 +247,7 @@ pub(crate) async fn initialize( (USER_ROLE_ID_ALLOC_KEY.to_string(), DEFAULT_ALLOCATOR_ID), ( USER_CLUSTER_ID_ALLOC_KEY.to_string(), - DEFAULT_USER_CLUSTER_ID.inner_id() + 1, + (DEFAULT_USER_CLUSTER_ID.inner_id() + 1).into(), ), ( SYSTEM_CLUSTER_ID_ALLOC_KEY.to_string(), diff --git a/src/catalog/src/durable/objects.rs b/src/catalog/src/durable/objects.rs index 5852b1042082c..e6bb869ce84fb 100644 --- a/src/catalog/src/durable/objects.rs +++ b/src/catalog/src/durable/objects.rs @@ -338,11 +338,11 @@ impl DurableType for IntrospectionSourceIndex { catalog_id: self .item_id .try_into() - .expect("cluster introspection source index mapping must be a System ID"), + .expect("cluster introspection source index mapping must be an Introspection Source Index ID"), global_id: self .index_id .try_into() - .expect("cluster introspection source index mapping must be a System ID"), + .expect("cluster introspection source index mapping must be a Introspection Source Index ID"), oid: self.oid, }, ) @@ -603,6 +603,7 @@ impl TryFrom for SystemCatalogItemId { fn try_from(val: CatalogItemId) -> Result { match val { CatalogItemId::System(x) => Ok(SystemCatalogItemId(x)), + CatalogItemId::IntrospectionSourceIndex(_) => Err("introspection_source_index"), CatalogItemId::User(_) => Err("user"), CatalogItemId::Transient(_) => Err("transient"), } @@ -615,6 +616,31 @@ impl From for CatalogItemId { } } +/// A newtype wrapper for [`CatalogItemId`] that is only for the "introspection source index" namespace. +#[derive(Debug, Copy, Clone, Ord, PartialOrd, PartialEq, Eq)] +pub struct IntrospectionSourceIndexCatalogItemId(u64); + +impl TryFrom for IntrospectionSourceIndexCatalogItemId { + type Error = &'static str; + + fn try_from(val: CatalogItemId) -> Result { + match val { + CatalogItemId::System(_) => Err("system"), + CatalogItemId::IntrospectionSourceIndex(x) => { + Ok(IntrospectionSourceIndexCatalogItemId(x)) + } + CatalogItemId::User(_) => Err("user"), + CatalogItemId::Transient(_) => Err("transient"), + } + } +} + +impl From for CatalogItemId { + fn from(val: IntrospectionSourceIndexCatalogItemId) -> Self { + CatalogItemId::IntrospectionSourceIndex(val.0) + } +} + /// A newtype wrapper for [`GlobalId`] that is only for the "system" namespace. #[derive(Debug, Copy, Clone, Ord, PartialOrd, PartialEq, Eq)] pub struct SystemGlobalId(u64); @@ -625,6 +651,7 @@ impl TryFrom for SystemGlobalId { fn try_from(val: GlobalId) -> Result { match val { GlobalId::System(x) => Ok(SystemGlobalId(x)), + GlobalId::IntrospectionSourceIndex(_) => Err("introspection_source_index"), GlobalId::User(_) => Err("user"), GlobalId::Transient(_) => Err("transient"), GlobalId::Explain => Err("explain"), @@ -638,6 +665,30 @@ impl From for GlobalId { } } +/// A newtype wrapper for [`GlobalId`] that is only for the "introspection source index" namespace. +#[derive(Debug, Copy, Clone, Ord, PartialOrd, PartialEq, Eq)] +pub struct IntrospectionSourceIndexGlobalId(u64); + +impl TryFrom for IntrospectionSourceIndexGlobalId { + type Error = &'static str; + + fn try_from(val: GlobalId) -> Result { + match val { + GlobalId::System(_) => Err("system"), + GlobalId::IntrospectionSourceIndex(x) => Ok(IntrospectionSourceIndexGlobalId(x)), + GlobalId::User(_) => Err("user"), + GlobalId::Transient(_) => Err("transient"), + GlobalId::Explain => Err("explain"), + } + } +} + +impl From for GlobalId { + fn from(val: IntrospectionSourceIndexGlobalId) -> Self { + GlobalId::IntrospectionSourceIndex(val.0) + } +} + #[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq, Hash)] pub struct SystemObjectDescription { pub schema_name: String, @@ -1164,8 +1215,8 @@ pub struct ClusterIntrospectionSourceIndexKey { #[derive(Debug, Clone, PartialOrd, PartialEq, Eq, Ord)] pub struct ClusterIntrospectionSourceIndexValue { - pub(crate) catalog_id: SystemCatalogItemId, - pub(crate) global_id: SystemGlobalId, + pub(crate) catalog_id: IntrospectionSourceIndexCatalogItemId, + pub(crate) global_id: IntrospectionSourceIndexGlobalId, pub(crate) oid: u32, } diff --git a/src/catalog/src/durable/objects/serialization.rs b/src/catalog/src/durable/objects/serialization.rs index 323c33e05ba3d..89c14f323f148 100644 --- a/src/catalog/src/durable/objects/serialization.rs +++ b/src/catalog/src/durable/objects/serialization.rs @@ -50,8 +50,9 @@ use crate::durable::objects::{ AuditLogKey, ClusterIntrospectionSourceIndexKey, ClusterIntrospectionSourceIndexValue, ClusterKey, ClusterReplicaKey, ClusterReplicaValue, ClusterValue, CommentKey, CommentValue, ConfigKey, ConfigValue, DatabaseKey, DatabaseValue, DefaultPrivilegesKey, - DefaultPrivilegesValue, GidMappingKey, GidMappingValue, IdAllocKey, IdAllocValue, ItemKey, - ItemValue, NetworkPolicyKey, NetworkPolicyValue, RoleKey, RoleValue, SchemaKey, SchemaValue, + DefaultPrivilegesValue, GidMappingKey, GidMappingValue, IdAllocKey, IdAllocValue, + IntrospectionSourceIndexCatalogItemId, IntrospectionSourceIndexGlobalId, ItemKey, ItemValue, + NetworkPolicyKey, NetworkPolicyValue, RoleKey, RoleValue, SchemaKey, SchemaValue, ServerConfigurationKey, ServerConfigurationValue, SettingKey, SettingValue, SourceReference, SourceReferencesKey, SourceReferencesValue, StorageCollectionMetadataKey, StorageCollectionMetadataValue, SystemCatalogItemId, SystemGlobalId, SystemPrivilegesKey, @@ -419,7 +420,7 @@ impl RustType proto: proto::ClusterIntrospectionSourceIndexValue, ) -> Result { Ok(ClusterIntrospectionSourceIndexValue { - catalog_id: SystemCatalogItemId(proto.index_id), + catalog_id: IntrospectionSourceIndexCatalogItemId(proto.index_id), global_id: proto .global_id .into_rust_if_some("ClusterIntrospectionSourceIndexValue::global_id")?, @@ -1620,6 +1621,9 @@ impl RustType for CatalogItemId { proto::CatalogItemId { value: Some(match self { CatalogItemId::System(x) => proto::catalog_item_id::Value::System(*x), + CatalogItemId::IntrospectionSourceIndex(x) => { + proto::catalog_item_id::Value::IntrospectionSourceIndex(*x) + } CatalogItemId::User(x) => proto::catalog_item_id::Value::User(*x), CatalogItemId::Transient(x) => proto::catalog_item_id::Value::Transient(*x), }), @@ -1629,6 +1633,9 @@ impl RustType for CatalogItemId { fn from_proto(proto: proto::CatalogItemId) -> Result { match proto.value { Some(proto::catalog_item_id::Value::System(x)) => Ok(CatalogItemId::System(x)), + Some(proto::catalog_item_id::Value::IntrospectionSourceIndex(x)) => { + Ok(CatalogItemId::IntrospectionSourceIndex(x)) + } Some(proto::catalog_item_id::Value::User(x)) => Ok(CatalogItemId::User(x)), Some(proto::catalog_item_id::Value::Transient(x)) => Ok(CatalogItemId::Transient(x)), None => Err(TryFromProtoError::missing_field("CatalogItemId::kind")), @@ -1646,11 +1653,28 @@ impl RustType for SystemCatalogItemId { } } +impl RustType + for IntrospectionSourceIndexCatalogItemId +{ + fn into_proto(&self) -> proto::IntrospectionSourceIndexCatalogItemId { + proto::IntrospectionSourceIndexCatalogItemId { value: self.0 } + } + + fn from_proto( + proto: proto::IntrospectionSourceIndexCatalogItemId, + ) -> Result { + Ok(IntrospectionSourceIndexCatalogItemId(proto.value)) + } +} + impl RustType for GlobalId { fn into_proto(&self) -> proto::GlobalId { proto::GlobalId { value: Some(match self { GlobalId::System(x) => proto::global_id::Value::System(*x), + GlobalId::IntrospectionSourceIndex(x) => { + proto::global_id::Value::IntrospectionSourceIndex(*x) + } GlobalId::User(x) => proto::global_id::Value::User(*x), GlobalId::Transient(x) => proto::global_id::Value::Transient(*x), GlobalId::Explain => proto::global_id::Value::Explain(Default::default()), @@ -1661,6 +1685,9 @@ impl RustType for GlobalId { fn from_proto(proto: proto::GlobalId) -> Result { match proto.value { Some(proto::global_id::Value::System(x)) => Ok(GlobalId::System(x)), + Some(proto::global_id::Value::IntrospectionSourceIndex(x)) => { + Ok(GlobalId::IntrospectionSourceIndex(x)) + } Some(proto::global_id::Value::User(x)) => Ok(GlobalId::User(x)), Some(proto::global_id::Value::Transient(x)) => Ok(GlobalId::Transient(x)), Some(proto::global_id::Value::Explain(_)) => Ok(GlobalId::Explain), @@ -1679,6 +1706,18 @@ impl RustType for SystemGlobalId { } } +impl RustType for IntrospectionSourceIndexGlobalId { + fn into_proto(&self) -> proto::IntrospectionSourceIndexGlobalId { + proto::IntrospectionSourceIndexGlobalId { value: self.0 } + } + + fn from_proto( + proto: proto::IntrospectionSourceIndexGlobalId, + ) -> Result { + Ok(IntrospectionSourceIndexGlobalId(proto.value)) + } +} + impl RustType for VersionedEvent { fn into_proto(&self) -> proto::audit_log_key::Event { match self { diff --git a/src/catalog/src/durable/persist.rs b/src/catalog/src/durable/persist.rs index f409444fe44a4..d8b5a01ff7845 100644 --- a/src/catalog/src/durable/persist.rs +++ b/src/catalog/src/durable/persist.rs @@ -381,6 +381,8 @@ pub(crate) struct PersistHandle> { fenceable_token: FenceableToken, /// The semantic version of the current binary. catalog_content_version: semver::Version, + /// Flag to indicate if bootstrap is complete. + bootstrap_complete: bool, /// Metrics for the persist catalog. metrics: Arc, } @@ -1065,6 +1067,7 @@ impl UnopenedPersistCatalogState { upper, fenceable_token: FenceableToken::new(deploy_generation), catalog_content_version: version, + bootstrap_complete: false, metrics, }; // If the snapshot is not consolidated, and we see multiple epoch values while applying the @@ -1202,6 +1205,7 @@ impl UnopenedPersistCatalogState { snapshot: Vec::new(), update_applier: CatalogStateInner::new(), catalog_content_version: self.catalog_content_version, + bootstrap_complete: false, metrics: self.metrics, }; catalog.metrics.collection_entries.reset(); @@ -1561,6 +1565,10 @@ impl ReadOnlyDurableCatalogState for PersistCatalogState { self.expire().await } + fn is_bootstrap_complete(&self) -> bool { + self.bootstrap_complete + } + async fn get_audit_logs(&mut self) -> Result, CatalogError> { self.sync_to_current_upper().await?; let audit_logs: Vec<_> = self @@ -1660,6 +1668,10 @@ impl DurableCatalogState for PersistCatalogState { matches!(self.mode, Mode::Savepoint) } + fn mark_bootstrap_complete(&mut self) { + self.bootstrap_complete = true; + } + #[mz_ore::instrument(level = "debug")] async fn transaction(&mut self) -> Result { self.metrics.transactions_started.inc(); diff --git a/src/catalog/src/durable/transaction.rs b/src/catalog/src/durable/transaction.rs index 2edb6d7248715..55e752bccfda2 100644 --- a/src/catalog/src/durable/transaction.rs +++ b/src/catalog/src/durable/transaction.rs @@ -15,6 +15,7 @@ use anyhow::anyhow; use derivative::Derivative; use itertools::Itertools; use mz_audit_log::VersionedEvent; +use mz_compute_client::logging::{ComputeLog, DifferentialLog, LogVariant, TimelyLog}; use mz_controller_types::{ClusterId, ReplicaId}; use mz_ore::cast::{u64_to_usize, usize_to_u64}; use mz_ore::collections::{CollectionExt, HashSet}; @@ -60,9 +61,9 @@ use crate::durable::{ CatalogError, DefaultPrivilege, DurableCatalogError, DurableCatalogState, NetworkPolicy, Snapshot, SystemConfiguration, AUDIT_LOG_ID_ALLOC_KEY, BUILTIN_MIGRATION_SHARD_KEY, CATALOG_CONTENT_VERSION_KEY, DATABASE_ID_ALLOC_KEY, EXPRESSION_CACHE_SHARD_KEY, OID_ALLOC_KEY, - SCHEMA_ID_ALLOC_KEY, STORAGE_USAGE_ID_ALLOC_KEY, SYSTEM_ITEM_ALLOC_KEY, - SYSTEM_REPLICA_ID_ALLOC_KEY, USER_ITEM_ALLOC_KEY, USER_NETWORK_POLICY_ID_ALLOC_KEY, - USER_REPLICA_ID_ALLOC_KEY, USER_ROLE_ID_ALLOC_KEY, + SCHEMA_ID_ALLOC_KEY, STORAGE_USAGE_ID_ALLOC_KEY, SYSTEM_CLUSTER_ID_ALLOC_KEY, + SYSTEM_ITEM_ALLOC_KEY, SYSTEM_REPLICA_ID_ALLOC_KEY, USER_ITEM_ALLOC_KEY, + USER_NETWORK_POLICY_ID_ALLOC_KEY, USER_REPLICA_ID_ALLOC_KEY, USER_ROLE_ID_ALLOC_KEY, }; use crate::memory::objects::{StateDiff, StateUpdate, StateUpdateKind}; @@ -393,7 +394,6 @@ impl<'a> Transaction<'a> { /// Panics if any introspection source id is not a system id pub fn insert_system_cluster( &mut self, - cluster_id: ClusterId, cluster_name: &str, introspection_source_indexes: Vec<(&'static BuiltinLog, CatalogItemId, GlobalId)>, privileges: Vec, @@ -401,6 +401,11 @@ impl<'a> Transaction<'a> { config: ClusterConfig, temporary_oids: &HashSet, ) -> Result<(), CatalogError> { + let cluster_id = self.get_and_increment_id(SYSTEM_CLUSTER_ID_ALLOC_KEY.to_string())?; + let cluster_id = cluster_id + .try_into() + .map_err(|_| SqlCatalogError::IdExhaustion)?; + let cluster_id = ClusterId::System(cluster_id); self.insert_cluster( cluster_id, cluster_name, @@ -700,6 +705,11 @@ impl<'a> Transaction<'a> { key: String, amount: u64, ) -> Result, CatalogError> { + assert!( + key != SYSTEM_ITEM_ALLOC_KEY || !self.durable_catalog.is_bootstrap_complete(), + "system item IDs cannot be allocated outside of bootstrap" + ); + let current_id = self .id_allocator .items() @@ -727,6 +737,10 @@ impl<'a> Transaction<'a> { &mut self, amount: u64, ) -> Result, CatalogError> { + assert!( + !self.durable_catalog.is_bootstrap_complete(), + "we can only allocate system item IDs during bootstrap" + ); Ok(self .get_and_increment_id_by(SYSTEM_ITEM_ALLOC_KEY.to_string(), amount)? .into_iter() @@ -735,6 +749,90 @@ impl<'a> Transaction<'a> { .collect()) } + /// Allocates an ID for an introspection source index. These IDs are deterministically derived + /// from the `cluster_id` and `log_variant`. + /// + /// Introspection source indexes are a special edge case of items. They are considered system + /// items, but they are the only system item that can be created by the user at any time. All + /// other system items can only be created by the system during the startup of an upgrade. + /// + /// Furthermore, all other system item IDs are allocated deterministically in the same order + /// during startup. Therefore, all read-only `environmentd` processes during an upgrade will + /// allocate the same system IDs to the same items, and due to the way catalog fencing works, + /// only one of them can successfully write the IDs down to the catalog. This removes the need + /// for `environmentd` processes to coordinate system IDs allocated during read-only mode. + /// + /// Since introspection IDs can be allocated at any time, read-only instances would either need + /// to coordinate across processes when allocating a new ID or allocate them deterministically. + /// We opted to allocate the IDs deterministically to avoid the overhead of coordination. + /// + /// Introspection source index IDs are 64 bit integers, with the following format (not to + /// scale): + /// + /// --------------------------------------------------------------------------- + /// | Cluster ID Variant | Cluster ID Inner Value | Empty Space | Log Variant | + /// |--------------------|------------------------|-------------|-------------| + /// | 8-bits | 32-bits | 8-bits | 16-bits | + /// --------------------------------------------------------------------------- + /// + /// Cluster ID Variant: A unique number indicating the variant of cluster the index belongs + /// to. + /// Cluster ID Inner Value: A per variant unique number indicating the cluster the index + /// belongs to. + /// Log Variant: A unique number indicating the log variant this index is on. + pub fn allocate_introspection_source_index_id( + cluster_id: &ClusterId, + log_variant: LogVariant, + ) -> (CatalogItemId, GlobalId) { + let cluster_variant: u8 = match cluster_id { + ClusterId::System(_) => 1, + ClusterId::User(_) => 2, + }; + let cluster_id: u32 = cluster_id.inner_id(); + let log_variant: u16 = match log_variant { + LogVariant::Timely(TimelyLog::Operates) => 1, + LogVariant::Timely(TimelyLog::Channels) => 2, + LogVariant::Timely(TimelyLog::Elapsed) => 3, + LogVariant::Timely(TimelyLog::Histogram) => 4, + LogVariant::Timely(TimelyLog::Addresses) => 5, + LogVariant::Timely(TimelyLog::Parks) => 6, + LogVariant::Timely(TimelyLog::MessagesSent) => 7, + LogVariant::Timely(TimelyLog::MessagesReceived) => 8, + LogVariant::Timely(TimelyLog::Reachability) => 9, + LogVariant::Timely(TimelyLog::BatchesSent) => 10, + LogVariant::Timely(TimelyLog::BatchesReceived) => 11, + LogVariant::Differential(DifferentialLog::ArrangementBatches) => 12, + LogVariant::Differential(DifferentialLog::ArrangementRecords) => 13, + LogVariant::Differential(DifferentialLog::Sharing) => 14, + LogVariant::Differential(DifferentialLog::BatcherRecords) => 15, + LogVariant::Differential(DifferentialLog::BatcherSize) => 16, + LogVariant::Differential(DifferentialLog::BatcherCapacity) => 17, + LogVariant::Differential(DifferentialLog::BatcherAllocations) => 18, + LogVariant::Compute(ComputeLog::DataflowCurrent) => 19, + LogVariant::Compute(ComputeLog::FrontierCurrent) => 20, + LogVariant::Compute(ComputeLog::PeekCurrent) => 21, + LogVariant::Compute(ComputeLog::PeekDuration) => 22, + LogVariant::Compute(ComputeLog::ImportFrontierCurrent) => 23, + LogVariant::Compute(ComputeLog::ArrangementHeapSize) => 24, + LogVariant::Compute(ComputeLog::ArrangementHeapCapacity) => 25, + LogVariant::Compute(ComputeLog::ArrangementHeapAllocations) => 26, + LogVariant::Compute(ComputeLog::ShutdownDuration) => 27, + LogVariant::Compute(ComputeLog::ErrorCount) => 28, + LogVariant::Compute(ComputeLog::HydrationTime) => 29, + LogVariant::Compute(ComputeLog::LirMapping) => 30, + LogVariant::Compute(ComputeLog::DataflowGlobal) => 31, + }; + + let mut id: u64 = u64::from(cluster_variant) << 56; + id |= u64::from(cluster_id) << 24; + id |= u64::from(log_variant); + + ( + CatalogItemId::IntrospectionSourceIndex(id), + GlobalId::IntrospectionSourceIndex(id), + ) + } + pub fn allocate_user_item_ids( &mut self, amount: u64, @@ -3562,4 +3660,55 @@ mod tests { assert_eq!(db_owner, db.owner_id); assert_eq!(db_privileges, db.privileges); } + + #[mz_ore::test] + fn test_allocate_introspection_source_index_id() { + let cluster_variant: u8 = 0b0000_0001; + let cluster_id_inner: u32 = 0b1010_1101_0000_1011_1111_1001_0110_1010; + let timely_messages_received_log_variant: u16 = 0b0000_0000_0000_1000; + + let cluster_id = ClusterId::System(cluster_id_inner); + let log_variant = LogVariant::Timely(TimelyLog::MessagesReceived); + + let introspection_source_index_id: u64 = + 0b0000_0001_1010_1101_0000_1011_1111_1001_0110_1010_0000_0000_0000_0000_0000_1000; + + // Sanity check that `introspection_source_index_id` contains `cluster_variant`. + { + let mut cluster_variant_mask = 0xFF << 56; + cluster_variant_mask &= introspection_source_index_id; + cluster_variant_mask >>= 56; + assert_eq!(cluster_variant_mask, u64::from(cluster_variant)); + } + + // Sanity check that `introspection_source_index_id` contains `cluster_id_inner`. + { + let mut cluster_id_inner_mask = 0xFFFF_FFFF << 24; + cluster_id_inner_mask &= introspection_source_index_id; + cluster_id_inner_mask >>= 24; + assert_eq!(cluster_id_inner_mask, u64::from(cluster_id_inner)); + } + + // Sanity check that `introspection_source_index_id` contains `timely_messages_received_log_variant`. + { + let mut log_variant_mask = 0xFFFF; + log_variant_mask &= introspection_source_index_id; + assert_eq!( + log_variant_mask, + u64::from(timely_messages_received_log_variant) + ); + } + + let (catalog_item_id, global_id) = + Transaction::allocate_introspection_source_index_id(&cluster_id, log_variant); + + assert_eq!( + catalog_item_id, + CatalogItemId::IntrospectionSourceIndex(introspection_source_index_id) + ); + assert_eq!( + global_id, + GlobalId::IntrospectionSourceIndex(introspection_source_index_id) + ); + } } diff --git a/src/catalog/src/durable/upgrade.rs b/src/catalog/src/durable/upgrade.rs index 10005b87e7944..7434d93aaa9d1 100644 --- a/src/catalog/src/durable/upgrade.rs +++ b/src/catalog/src/durable/upgrade.rs @@ -180,14 +180,14 @@ macro_rules! objects { } } -objects!(v67, v68, v69, v70, v71, v72); +objects!(v67, v68, v69, v70, v71, v72, v73); /// The current version of the `Catalog`. /// /// We will initialize new `Catalog`es with this version, and migrate existing `Catalog`es to this /// version. Whenever the `Catalog` changes, e.g. the protobufs we serialize in the `Catalog` /// change, we need to bump this version. -pub const CATALOG_VERSION: u64 = 72; +pub const CATALOG_VERSION: u64 = 73; /// The minimum `Catalog` version number that we support migrating from. /// @@ -204,6 +204,7 @@ mod v68_to_v69; mod v69_to_v70; mod v70_to_v71; mod v71_to_v72; +mod v72_to_v73; /// Describes a single action to take during a migration from `V1` to `V2`. #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)] @@ -287,6 +288,7 @@ async fn run_upgrade( 69 => run_versioned_upgrade(unopened_catalog_state, version, v69_to_v70::upgrade).await, 70 => run_versioned_upgrade(unopened_catalog_state, version, v70_to_v71::upgrade).await, 71 => run_versioned_upgrade(unopened_catalog_state, version, v71_to_v72::upgrade).await, + 72 => run_versioned_upgrade(unopened_catalog_state, version, v72_to_v73::upgrade).await, // Up-to-date, no migration needed! CATALOG_VERSION => Ok(CATALOG_VERSION), diff --git a/src/catalog/src/durable/upgrade/snapshots/objects_v73.txt b/src/catalog/src/durable/upgrade/snapshots/objects_v73.txt new file mode 100644 index 0000000000000..f58e6ad8d6061 --- /dev/null +++ b/src/catalog/src/durable/upgrade/snapshots/objects_v73.txt @@ -0,0 +1,100 @@ +CnAKbroBawoVCgRraW5kEg1CC1R4bldhbFNoYXJkClIKBXZhbHVlEkm6AUYKRAoFc2hhcmQSO0I5XEN28JGKjWDwn4W8LkbgtIbigIngsrPOhsOIezoqbiJm4LqEIuGAqOCzoyfwnqSa8JG/gHjwnoS7 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 +ClwKWroBVwolChFkZXBsb3lfZ2VuZXJhdGlvbhIQwgENCgsBCEIxIZNgdpYBbAoYCgVlcG9jaBIPwgEMCgqFmYgTlSIEYEONChQKBGtpbmQSDEIKRmVuY2VUb2tlbg== +CnEKb7oBbAoUCgNrZXkSDboBCgoICgJpZBICCAQKIwoEa2luZBIbQhlTdG9yYWdlQ29sbGVjdGlvbk1ldGFkYXRhCi8KBXZhbHVlEia6ASMKIQoFc2hhcmQSGEIW6qyG8LGrpGd24bWpwqXDiuCpmickcA== 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 +ClsKWboBVgoiCgNrZXkSG7oBGAoWCgJpZBIQugENCgsKBXZhbHVlEgIIBAojCgRraW5kEhtCGVN0b3JhZ2VDb2xsZWN0aW9uTWV0YWRhdGEKCwoFdmFsdWUSAggE +Cm0Ka7oBaAo/CgNrZXkSOLoBNQozCgJpZBItugEqCigKBXZhbHVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwFiQWZkR0gVEoicChgKBGtpbmQSEEIOQ2x1c3RlclJlcGxpY2EKCwoFdmFsdWUSAggE +CvEBCu4BugHqAQqCAQoDa2V5Enu6AXgKPAoLb2JqZWN0X25hbWUSLUIrXO+svvCav73hv7PwkKeD0ajhiqcxVSpSL8i6OisqWix0JUzvv70lPW0gRAoZCgtvYmplY3RfdHlwZRIKwgEHCgVTOAFjbAodCgtzY2hlbWFfbmFtZRIOQgzgqLU/8JCWjToqYEAKFAoEa2luZBIMQgpHaWRNYXBwaW5nCk0KBXZhbHVlEkS6AUEKFgoLZmluZ2VycHJpbnQSB0IFJ/CQhI4KDwoJZ2xvYmFsX2lkEgIIBAoWCgJpZBIQwgENCgsBBBCZkDdUYYdYHA== +CjEKL7oBLAoJCgNrZXkSAggEChIKBGtpbmQSCkIIRGF0YWJhc2UKCwoFdmFsdWUSAggE +CsFJCr5JugG6SQpDCgNrZXkSPLoBOQo3CgNnaWQSMLoBLQorCgV2YWx1ZRIiugEfCh0KCVRyYW5zaWVudBIQwgENCgsBV4OYiIM1lQdCnAoOCgRraW5kEgZCBEl0ZW0K4kgKBXZhbHVlEthIugHUSAoQCgpkZWZpbml0aW9uEgIIBArQEgoOZXh0cmFfdmVyc2lvbnMSvRKyAbkSCj+6ATwKDwoJZ2xvYmFsX2lkEgIIBAopCgd2ZXJzaW9uEh66ARsKGQoFdmFsdWUSEMIBDQoLAUmSgEVRcWcQQHwKI7oBIAoPCglnbG9iYWxfaWQSAggECg0KB3ZlcnNpb24SAggECjG6AS4KHQoJZ2xvYmFsX2lkEhC6AQ0KCwoFdmFsdWUSAggECg0KB3ZlcnNpb24SAggECiO6ASAKDwoJZ2xvYmFsX2lkEgIIBAoNCgd2ZXJzaW9uEgIIBAoxugEuCh0KCWdsb2JhbF9pZBIQugENCgsKBXZhbHVlEgIIBAoNCgd2ZXJzaW9uEgIIBApdugFaCi4KCWdsb2JhbF9pZBIhugEeChwKBXZhbHVlEhO6ARAKDgoHRXhwbGFpbhIDugEACigKB3ZlcnNpb24SHboBGgoYCgV2YWx1ZRIPwgEMCgokCWWTAjE0KZcsCj66ATsKDwoJZ2xvYmFsX2lkEgIIBAooCgd2ZXJzaW9uEh26ARoKGAoFdmFsdWUSD8IBDAoKMCAZeAMBc4IGTApQugFNCjwKCWdsb2JhbF9pZBIvugEsCioKBXZhbHVlEiG6AR4KHAoJVHJhbnNpZW50Eg/CAQwKCiVjkSNWc2AjRUwKDQoHdmVyc2lvbhICCAQKYLoBXQpMCglnbG9iYWxfaWQSP7oBPAo6CgV2YWx1ZRIxugEuCiwKGEludHJvc3BlY3Rpb25Tb3VyY2VJbmRleBIQwgENCgsBdSUQUIaFdmUzjAoNCgd2ZXJzaW9uEgIIBApJugFGCg8KCWdsb2JhbF9pZBICCAQKMwoHdmVyc2lvbhIougElCiMKBXZhbHVlEhrCARcKCgNEZjVHQZRzQCwQ////////////AQp7ugF4CksKCWdsb2JhbF9pZBI+ugE7CjkKBXZhbHVlEjC6AS0KKwoYSW50cm9zcGVjdGlvblNvdXJjZUluZGV4Eg/CAQwKChUIaXF4gISCYxwKKQoHdmVyc2lvbhIeugEbChkKBXZhbHVlEhDCAQ0KCwEgIndjR2ZjlyB8Cma6AWMKNwoJZ2xvYmFsX2lkEiq6AScKJQoFdmFsdWUSHLoBGQoXCgRVc2VyEg/CAQwKCpdSQXFYMoRICTwKKAoHdmVyc2lvbhIdugEaChgKBXZhbHVlEg/CAQwKChkXA1JnAxV4mFwKMboBLgodCglnbG9iYWxfaWQSELoBDQoLCgV2YWx1ZRICCAQKDQoHdmVyc2lvbhICCAQKP7oBPAoPCglnbG9iYWxfaWQSAggECikKB3ZlcnNpb24SHroBGwoZCgV2YWx1ZRIQwgENCgsBaXKEKHYQEDYQXAojugEgCg8KCWdsb2JhbF9pZBICCAQKDQoHdmVyc2lvbhICCAQKProBOwoPCglnbG9iYWxfaWQSAggECigKB3ZlcnNpb24SHboBGgoYCgV2YWx1ZRIPwgEMCgpmOENUh4ckOCEsCjG6AS4KHQoJZ2xvYmFsX2lkEhC6AQ0KCwoFdmFsdWUSAggECg0KB3ZlcnNpb24SAggECiO6ASAKDwoJZ2xvYmFsX2lkEgIIBAoNCgd2ZXJzaW9uEgIIBAo/ugE8Cg8KCWdsb2JhbF9pZBICCAQKKQoHdmVyc2lvbhIeugEbChkKBXZhbHVlEhDCAQ0KCwEkZyNhAkGIKTd8Cj66ATsKDwoJZ2xvYmFsX2lkEgIIBAooCgd2ZXJzaW9uEh26ARoKGAoFdmFsdWUSD8IBDAoKkhKXKVMShjcELAojugEgCg8KCWdsb2JhbF9pZBICCAQKDQoHdmVyc2lvbhICCAQKI7oBIAoPCglnbG9iYWxfaWQSAggECg0KB3ZlcnNpb24SAggECjG6AS4KHQoJZ2xvYmFsX2lkEhC6AQ0KCwoFdmFsdWUSAggECg0KB3ZlcnNpb24SAggECkK6AT8KLgoJZ2xvYmFsX2lkEiG6AR4KHAoFdmFsdWUSE7oBEAoOCgdFeHBsYWluEgO6AQAKDQoHdmVyc2lvbhICCAQKX7oBXApLCglnbG9iYWxfaWQSProBOwo5CgV2YWx1ZRIwugEtCisKGEludHJvc3BlY3Rpb25Tb3VyY2VJbmRleBIPwgEMCgpjZYeWAYkxRQOMCg0KB3ZlcnNpb24SAggECj+6ATwKDwoJZ2xvYmFsX2lkEgIIBAopCgd2ZXJzaW9uEh66ARsKGQoFdmFsdWUSEMIBDQoLAWGCWYCRl1MzUxwKfLoBeQpMCglnbG9iYWxfaWQSP7oBPAo6CgV2YWx1ZRIxugEuCiwKGEludHJvc3BlY3Rpb25Tb3VyY2VJbmRleBIQwgENCgsBKHh1cEEyFzZVHAopCgd2ZXJzaW9uEh66ARsKGQoFdmFsdWUSEMIBDQoLAUKZZjRVghQxVhwKI7oBIAoPCglnbG9iYWxfaWQSAggECg0KB3ZlcnNpb24SAggECiO6ASAKDwoJZ2xvYmFsX2lkEgIIBAoNCgd2ZXJzaW9uEgIIBAp6ugF3CksKCWdsb2JhbF9pZBI+ugE7CjkKBXZhbHVlEjC6AS0KKwoYSW50cm9zcGVjdGlvblNvdXJjZUluZGV4Eg/CAQwKChhFUkIVIhEzlFwKKAoHdmVyc2lvbhIdugEaChgKBXZhbHVlEg/CAQwKCkmBKSEFYnkAMkwKMboBLgodCglnbG9iYWxfaWQSELoBDQoLCgV2YWx1ZRICCAQKDQoHdmVyc2lvbhICCAQKS7oBSAo3CglnbG9iYWxfaWQSKroBJwolCgV2YWx1ZRIcugEZChcKBFVzZXISD8IBDAoKc4RTBiY2JpeCHAoNCgd2ZXJzaW9uEgIIBApNugFKCh0KCWdsb2JhbF9pZBIQugENCgsKBXZhbHVlEgIIBAopCgd2ZXJzaW9uEh66ARsKGQoFdmFsdWUSEMIBDQoLAXiSNGWHM0JpgZwKTLoBSQodCglnbG9iYWxfaWQSELoBDQoLCgV2YWx1ZRICCAQKKAoHdmVyc2lvbhIdugEaChgKBXZhbHVlEg/CAQwKCoCEhXFGADeYYGwKTboBSgodCglnbG9iYWxfaWQSELoBDQoLCgV2YWx1ZRICCAQKKQoHdmVyc2lvbhIeugEbChkKBXZhbHVlEhDCAQ0KCwGCeXJZYggYWHMsCg8KCWdsb2JhbF9pZBICCAQKIQoEbmFtZRIZQhd78JCyrOGlsmPgsK3wnrqiXOCpi+CqiAoRCgNvaWQSCsIBBwoFISMySHwKHAoIb3duZXJfaWQSELoBDQoLCgV2YWx1ZRICCAQK6DQKCnByaXZpbGVnZXMS2TSyAdU0CmC6AV0KDgoIYWNsX21vZGUSAggECjwKB2dyYW50ZWUSMboBLgosCgV2YWx1ZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAVkHSCdxSVMRcpwKDQoHZ3JhbnRvchICCAQKP7oBPAoOCghhY2xfbW9kZRICCAQKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAoNCgdncmFudG9yEgIIBApdugFaCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKkzeZiTlVkDVCXAoNCgdncmFudGVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECne6AXQKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgqEmEQ2BIlAOSN8CjUKB2dyYW50ZWUSKroBJwolCgV2YWx1ZRIcugEZChcKBFVzZXISD8IBDAoKZxdAWCmAM5QCnAoNCgdncmFudG9yEgIIBAprugFoCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKJ4lZdmk0FVYoXAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKP7oBPAoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBAoxugEuCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAo/ugE8Cg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECj+6ATwKDgoIYWNsX21vZGUSAggEChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKDQoHZ3JhbnRvchICCAQKULoBTQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwESaRgWkhkHNnRMCg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECm66AWsKDgoIYWNsX21vZGUSAggECjwKB2dyYW50ZWUSMboBLgosCgV2YWx1ZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLARkkZyQBaJclBYwKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBApnugFkCg4KCGFjbF9tb2RlEgIIBAo1CgdncmFudGVlEiq6AScKJQoFdmFsdWUSHLoBGQoXCgRVc2VyEg/CAQwKCiMwk2UHV3aQVowKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBApnugFkCg4KCGFjbF9tb2RlEgIIBAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECjUKB2dyYW50b3ISKroBJwolCgV2YWx1ZRIcugEZChcKBFVzZXISD8IBDAoKWVdSRRUllpKGLAo/ugE8Cg4KCGFjbF9tb2RlEgIIBAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECg0KB2dyYW50b3ISAggECmi6AWUKDgoIYWNsX21vZGUSAggECjYKB2dyYW50ZWUSK7oBKAomCgV2YWx1ZRIdugEaChgKBFVzZXISEMIBDQoLAQWGA3RpR0mRJTwKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBAp+ugF7Ci0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAWA5BIAkdHAQcDwKOwoHZ3JhbnRlZRIwugEtCisKBXZhbHVlEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgpRlykmCYCDmFhsCg0KB2dyYW50b3ISAggECpcBugGTAQo2CghhY2xfbW9kZRIqugEnCiUKCGJpdGZsYWdzEhnCARYKCQExaRUjeZNRPBD8//////////8BChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKPAoHZ3JhbnRvchIxugEuCiwKBXZhbHVlEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBhDmWMiNzlXAEfAo/ugE8Cg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECp4BugGaAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwEUYUUgBkg2Y0CMCisKB2dyYW50ZWUSILoBHQobCgV2YWx1ZRISugEPCg0KBlB1YmxpYxIDugEACjwKB2dyYW50b3ISMboBLgosCgV2YWx1ZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAVMzGQSYiXVgYnwKP7oBPAoOCghhY2xfbW9kZRICCAQKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAoNCgdncmFudG9yEgIIBApdugFaCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKcZE3iGUGVxdTLAoNCgdncmFudGVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECjG6AS4KDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECmm6AWYKDgoIYWNsX21vZGUSAggECjcKB2dyYW50ZWUSLLoBKQonCgV2YWx1ZRIeugEbChkKBlN5c3RlbRIPwgEMCgpUmYRoCGJkh4M8ChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKeboBdgosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCkhBd1AxRkKURowKDQoHZ3JhbnRlZRICCAQKNwoHZ3JhbnRvchIsugEpCicKBXZhbHVlEh66ARsKGQoGU3lzdGVtEg/CAQwKChACNDFiknkJhRwKjgG6AYoBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLARaFA1hpJUd5ZWwKPAoHZ3JhbnRlZRIxugEuCiwKBXZhbHVlEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBIZUBE0IJMAAgnAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggEClu6AVgKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECjcKB2dyYW50b3ISLLoBKQonCgV2YWx1ZRIeugEbChkKBlN5c3RlbRIPwgEMCgqVd5UXYwgymWGMCj+6ATwKDgoIYWNsX21vZGUSAggEChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKDQoHZ3JhbnRvchICCAQKP7oBPAoOCghhY2xfbW9kZRICCAQKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAoNCgdncmFudG9yEgIIBAqHAboBgwEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgo4U0kDI1cQaZgsChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKNgoHZ3JhbnRvchIrugEoCiYKBXZhbHVlEh26ARoKGAoEVXNlchIQwgENCgsBQTUYMTeCRDmTLApPugFMCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKlpaSY4mChTYIHAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBApsugFpCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAWFnEkllZwNlJCwKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECoQBugGAAQo3CghhY2xfbW9kZRIrugEoCiYKCGJpdGZsYWdzEhrCARcKCgkYE5GYdRY1l5wQ////////////AQoNCgdncmFudGVlEgIIBAo2CgdncmFudG9yEiu6ASgKJgoFdmFsdWUSHboBGgoYCgRVc2VyEhDCAQ0KCwEZUkIXiChmmQc8CjG6AS4KDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECl26AVoKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgo3FVNnByZlhYCcChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKDQoHZ3JhbnRvchICCAQKULoBTQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwExQQUVeRF0eTF8Cg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECogBugGEAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwEYR3UYBGCYVlJcChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKNgoHZ3JhbnRvchIrugEoCiYKBXZhbHVlEh26ARoKGAoEVXNlchIQwgENCgsBhDeAQXYCRlVZfAqRAboBjQEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgqHkhIhhVZ0gWGMCkAKB2dyYW50ZWUSNboBMgowCgV2YWx1ZRInugEkCiIKBFVzZXISGsIBFwoKFWkVOXgnZJBDXBD///////////8BChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKP7oBPAoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBApPugFMCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKV4cABEKCQwR3bAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAo/ugE8Cg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECjG6AS4KDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggEClq6AVcKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECjYKB2dyYW50b3ISK7oBKAomCgV2YWx1ZRIdugEaChgKBFVzZXISEMIBDQoLAXYzMwYJAURVmIwKP7oBPAoOCghhY2xfbW9kZRICCAQKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAoNCgdncmFudG9yEgIIBAoxugEuCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBApcugFZCg4KCGFjbF9tb2RlEgIIBAo4CgdncmFudGVlEi26ASoKKAoFdmFsdWUSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLATGXAwUgYZg0cUwKDQoHZ3JhbnRvchICCAQKXroBWwotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFmg0EnSIYTIxZcChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKDQoHZ3JhbnRvchICCAQKjQG6AYkBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKg2UxJHRzk3RVjAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECjwKB2dyYW50b3ISMboBLgosCgV2YWx1ZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAXhChIVkhYZpQmwKXboBWgosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCpGECWd3JGmImEwKDQoHZ3JhbnRlZRICCAQKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBAoxugEuCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBApbugFYCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAo3CgdncmFudG9yEiy6ASkKJwoFdmFsdWUSHroBGwoZCgZTeXN0ZW0SD8IBDAoKeIQHM2WCmBhSjApdugFaCg4KCGFjbF9tb2RlEgIIBAorCgdncmFudGVlEiC6AR0KGwoFdmFsdWUSEroBDwoNCgZQdWJsaWMSA7oBAAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECogBugGEAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwESiFQBVhKEKJNMChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKNgoHZ3JhbnRvchIrugEoCiYKBXZhbHVlEh26ARoKGAoEVXNlchIQwgENCgsBA3ExZ2M1aJhWfAqIAboBhAEKDgoIYWNsX21vZGUSAggECjgKB2dyYW50ZWUSLboBKgooCgV2YWx1ZRIfugEcChoKBlN5c3RlbRIQwgENCgsBVWKDOAFYdIh4XAo4CgdncmFudG9yEi26ASoKKAoFdmFsdWUSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAWmFiBdykDhmFCwKXLoBWQoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKOAoHZ3JhbnRvchItugEqCigKBXZhbHVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwF4Rnh3VCFYaXA8Cn26AXoKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpnJ3WJliOUhFA8Cg0KB2dyYW50ZWUSAggECjsKB2dyYW50b3ISMLoBLQorCgV2YWx1ZRIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKkAFYJoACB2lZLApNugFKCg4KCGFjbF9tb2RlEgIIBAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKXboBWgosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCoUlQHUHBJl3IRwKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAoNCgdncmFudG9yEgIIBApbugFYCg4KCGFjbF9tb2RlEgIIBAo3CgdncmFudGVlEiy6ASkKJwoFdmFsdWUSHroBGwoZCgZTeXN0ZW0SD8IBDAoKOAAmkGglgUUBbAoNCgdncmFudG9yEgIIBApuugFrCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLATIGCSKXSRYQJZwKKwoHZ3JhbnRlZRIgugEdChsKBXZhbHVlEhK6AQ8KDQoGUHVibGljEgO6AQAKDQoHZ3JhbnRvchICCAQKXboBWgosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKChQAMyR4gwA1lTwKDQoHZ3JhbnRlZRICCAQKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBApaugFXCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAo2CgdncmFudG9yEiu6ASgKJgoFdmFsdWUSHboBGgoYCgRVc2VyEhDCAQ0KCwFGOZNyeBAJZjZ8Cme6AWQKDgoIYWNsX21vZGUSAggECjUKB2dyYW50ZWUSKroBJwolCgV2YWx1ZRIcugEZChcKBFVzZXISD8IBDAoKdTI4A3NWV3cmXAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggEClC6AU0KLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBYXFoZ2FpdXRjnAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBApaugFXCjcKCGFjbF9tb2RlEiu6ASgKJgoIYml0ZmxhZ3MSGsIBFwoKCIOImDmWQYRBXBD///////////8BCg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECmS6AWEKDgoIYWNsX21vZGUSAggECkAKB2dyYW50ZWUSNboBMgowCgV2YWx1ZRInugEkCiIKBFVzZXISGsIBFwoKBlYIU0RHYykCnBD///////////8BCg0KB2dyYW50b3ISAggECn+6AXwKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBMUVSQCFGk3MULAoNCgdncmFudGVlEgIIBAo8CgdncmFudG9yEjG6AS4KLAoFdmFsdWUSI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwEHKHBEOTIlgShMCj+6ATwKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKP7oBPAoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBApPugFMCg4KCGFjbF9tb2RlEgIIBAorCgdncmFudGVlEiC6AR0KGwoFdmFsdWUSEroBDwoNCgZQdWJsaWMSA7oBAAoNCgdncmFudG9yEgIIBAo/ugE8Cg4KCGFjbF9tb2RlEgIIBAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECg0KB2dyYW50b3ISAggECjG6AS4KDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECl66AVsKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBgkR5iTd0cjeYnAoNCgdncmFudGVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECh0KCXNjaGVtYV9pZBIQugENCgsKBXZhbHVlEgIIBA== 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 +CoACCv0BugH5AQriAQoDa2V5EtoBugHWAQrTAQoFZXZlbnQSyQG6AcUBCsIBCgJWMRK7AboBtwEKDQoHZGV0YWlscxICCAQKGQoKZXZlbnRfdHlwZRILwgEICgYCBRKFgzwKFgoCaWQSEMIBDQoLAXmBVEGZhBInUCwKGgoLb2JqZWN0X3R5cGUSC8IBCAoGAXeUUyM8Ci0KC29jY3VycmVkX2F0Eh66ARsKGQoGbWlsbGlzEg/CAQwKCkcZAlSIlZGReHwKKAoEdXNlchIgugEdChsKBWlubmVyEhJCEGpWa+CuiPCeuLnwm4SyJSUKEgoEa2luZBIKQghBdWRpdExvZw== +CowBCokBugGFAQoJCgNrZXkSAggECikKBGtpbmQSIUIfQ2x1c3RlckludHJvc3BlY3Rpb25Tb3VyY2VJbmRleApNCgV2YWx1ZRJEugFBCg8KCWdsb2JhbF9pZBICCAQKGwoIaW5kZXhfaWQSD8IBDAoKA5VJgzOCkFVGHAoRCgNvaWQSCsIBBwoFOGCHJmw= +CmEKX7oBXAouCgNrZXkSJ7oBJAoiCgRuYW1lEhpCGFAkXmgkZiIy8JGLgOC1lmTwnriA4aeUeQodCgRraW5kEhVCE1NlcnZlckNvbmZpZ3VyYXRpb24KCwoFdmFsdWUSAggE +ClsKWboBVgokChFkZXBsb3lfZ2VuZXJhdGlvbhIPwgEMCgowRkZVhwaCYoUcChgKBWVwb2NoEg/CAQwKCnOBSHBzOAeQMUwKFAoEa2luZBIMQgpGZW5jZVRva2Vu +CjIKMLoBLQoXCgNrZXkSELoBDQoLCgVldmVudBICCAQKEgoEa2luZBIKQghBdWRpdExvZw== +CikKJ7oBJAoVCgRraW5kEg1CC1R4bldhbFNoYXJkCgsKBXZhbHVlEgIIBA== +Ci8KLboBKgoJCgNrZXkSAggEChAKBGtpbmQSCEIGU2NoZW1hCgsKBXZhbHVlEgIIBA== +Ci8KLboBKgoJCgNrZXkSAggEChAKBGtpbmQSCEIGU2NoZW1hCgsKBXZhbHVlEgIIBA== +Cm4KbLoBaQoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ29tbWVudApJCgV2YWx1ZRJAugE9CjsKB2NvbW1lbnQSMEIuOe+/vcOSIicxPHQm8J64g+C1jDXhn6UxMUfwkaaleuCssy894Kaqwrrgp4FvaQ== +Ck0KS7oBSAoUCgNrZXkSDboBCgoICgJpZBICCAQKIwoEa2luZBIbQhlTdG9yYWdlQ29sbGVjdGlvbk1ldGFkYXRhCgsKBXZhbHVlEgIIBA== +CmEKX7oBXAo9CgNrZXkSNroBMwoxCgNnaWQSKroBJwolCgV2YWx1ZRIcugEZChcKBFVzZXISD8IBDAoKhTAXAlmAlmAwjAoOCgRraW5kEgZCBEl0ZW0KCwoFdmFsdWUSAggE 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 +CqcBCqQBugGgAQoxCgNrZXkSKroBJwolCgRuYW1lEh1CG/CRtqFTUty14KyeQ+GqmDNgYFw+Pz0m4bGTcQodCgRraW5kEhVCE1NlcnZlckNvbmZpZ3VyYXRpb24KTAoFdmFsdWUSQ7oBQAo+CgV2YWx1ZRI1QjPDpyXwkYKdeyozPe+/vWV9e/CRvrAu8J65p0Eq77+GwqThqbdEJuCwlHvwkYqKYjLRqCI= +CkgKRroBQwoJCgNrZXkSAggECikKBGtpbmQSIUIfQ2x1c3RlckludHJvc3BlY3Rpb25Tb3VyY2VJbmRleAoLCgV2YWx1ZRICCAQ= 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 +CiQKIroBHwoJCgNrZXkSAggEChIKBGtpbmQSCkIIQXVkaXRMb2c= +CmQKYroBXwoiCgNrZXkSG7oBGAoWCgNrZXkSD0INJOCyuC024rqYOuK2uQoQCgRraW5kEghCBkNvbmZpZwonCgV2YWx1ZRIeugEbChkKBXZhbHVlEhDCAQ0KCwFhhyFYGXgmmIKM +CkoKSLoBRQoJCgNrZXkSAggEChAKBGtpbmQSCEIGQ29uZmlnCiYKBXZhbHVlEh26ARoKGAoFdmFsdWUSD8IBDAoKAWF0EjRpVHWJfA== +CmMKYboBXgoJCgNrZXkSAggEChEKBGtpbmQSCUIHU2V0dGluZwo+CgV2YWx1ZRI1ugEyCjAKBXZhbHVlEidCJWDCtu+uk1nwkK6s4LqM8JOFsu+/vci68J2Soi86IvCfobYiw4A= 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 +CiwKKroBJwoJCgNrZXkSAggEChoKBGtpbmQSEkIQVW5maW5hbGl6ZWRTaGFyZA== +Ck0KS7oBSAoUCgNrZXkSDboBCgoICgJpZBICCAQKIwoEa2luZBIbQhlTdG9yYWdlQ29sbGVjdGlvbk1ldGFkYXRhCgsKBXZhbHVlEgIIBA== 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 +Ci0KK7oBKAoJCgNrZXkSAggECg4KBGtpbmQSBkIEUm9sZQoLCgV2YWx1ZRICCAQ= +CjEKL7oBLAoJCgNrZXkSAggEChIKBGtpbmQSCkIIRGF0YWJhc2UKCwoFdmFsdWUSAggE +CikKJ7oBJAoVCgRraW5kEg1CC1R4bldhbFNoYXJkCgsKBXZhbHVlEgIIBA== +CjEKL7oBLAoJCgNrZXkSAggEChIKBGtpbmQSCkIIRGF0YWJhc2UKCwoFdmFsdWUSAggE +CoYPCoMPugH/DgoJCgNrZXkSAggEChIKBGtpbmQSCkIIRGF0YWJhc2UK3Q4KBXZhbHVlEtMOugHPDgoXCgRuYW1lEg9CDcOpbOGqkfCQv6LRqC8KEgoDb2lkEgvCAQgKBgIENRAiLAoOCghvd25lcl9pZBICCAQKjw4KCnByaXZpbGVnZXMSgA6yAfwNCl66AVsKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBd4GVKRGYZgGGnAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECg0KB2dyYW50b3ISAggECm66AWsKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBI2A0EYVJJXRIbAorCgdncmFudGVlEiC6AR0KGwoFdmFsdWUSEroBDwoNCgZQdWJsaWMSA7oBAAoNCgdncmFudG9yEgIIBApZugFWCg4KCGFjbF9tb2RlEgIIBAo1CgdncmFudGVlEiq6AScKJQoFdmFsdWUSHLoBGQoXCgRVc2VyEg/CAQwKClZxE4NAQVghESwKDQoHZ3JhbnRvchICCAQKfroBewotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwF2WUNwJhlCGSVsCg0KB2dyYW50ZWUSAggECjsKB2dyYW50b3ISMLoBLQorCgV2YWx1ZRIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKlUdieCEIBmAkLApdugFaCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKFAiWkoWZAXdZfAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECg0KB2dyYW50b3ISAggECj+6ATwKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKULoBTQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwE4ABWYFDARRRacCg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECk+6AUwKDgoIYWNsX21vZGUSAggECisKB2dyYW50ZWUSILoBHQobCgV2YWx1ZRISugEPCg0KBlB1YmxpYxIDugEACg0KB2dyYW50b3ISAggECmi6AWUKNwoIYWNsX21vZGUSK7oBKAomCghiaXRmbGFncxIawgEXCgoBQnQQFJVClCE8EP///////////wEKDQoHZ3JhbnRlZRICCAQKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBApaugFXCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAo2CgdncmFudG9yEiu6ASgKJgoFdmFsdWUSHboBGgoYCgRVc2VyEhDCAQ0KCwECFZaBMigyR1AsCm26AWoKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgoRVXKFVJIgJlacCisKB2dyYW50ZWUSILoBHQobCgV2YWx1ZRISugEPCg0KBlB1YmxpYxIDugEACg0KB2dyYW50b3ISAggECl66AVsKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBQxGWlGcUSWVzTAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECg0KB2dyYW50b3ISAggECnq6AXcKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgoUUZUhAFhjkwCcCjgKB2dyYW50ZWUSLboBKgooCgV2YWx1ZRIfugEcChoKBlN5c3RlbRIQwgENCgsBR0mDOTQxc5WXnAoNCgdncmFudG9yEgIIBApnugFkCg4KCGFjbF9tb2RlEgIIBAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECjUKB2dyYW50b3ISKroBJwolCgV2YWx1ZRIcugEZChcKBFVzZXISD8IBDAoKBhAWU4BIkRODPApcugFZCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAo4CgdncmFudG9yEi26ASoKKAoFdmFsdWUSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLATQxMpRGeYgWc0wKMboBLgoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKbroBawoOCghhY2xfbW9kZRICCAQKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAo8CgdncmFudG9yEjG6AS4KLAoFdmFsdWUSI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwEGJDRhJyhxQwI8Cl66AVsKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBOEVodANIaZABbAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECg0KB2dyYW50b3ISAggECjG6AS4KDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggE +CtEBCs4BugHKAQoJCgNrZXkSAggEChAKBGtpbmQSCEIGU2NoZW1hCqoBCgV2YWx1ZRKgAboBnAEKPAoLZGF0YWJhc2VfaWQSLboBKgooCgV2YWx1ZRIfugEcChoKBlN5c3RlbRIQwgENCgsBI0ZQMXAxeRcYPAolCgRuYW1lEh1CG/CepIdc8J6AoVzvv73wkIC1J/CfgLQ98J2VjwoSCgNvaWQSC8IBCAoGBCSTFQlMCg4KCG93bmVyX2lkEgIIBAoRCgpwcml2aWxlZ2VzEgOyAQA= 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 +ClwKWroBVwoYCgNrZXkSEboBDgoMCgRuYW1lEgRCAkonChEKBGtpbmQSCUIHSWRBbGxvYwooCgV2YWx1ZRIfugEcChoKB25leHRfaWQSD8IBDAoKKSSUJXU1dygBHA== +CjgKNroBMwoUCgNrZXkSDboBCgoICgJpZBICCAQKDgoEa2luZBIGQgRSb2xlCgsKBXZhbHVlEgIIBA== +Cr8DCrwDugG4AwoJCgNrZXkSAggEChgKBGtpbmQSEEIOQ2x1c3RlclJlcGxpY2EKkAMKBXZhbHVlEoYDugGCAwozCgpjbHVzdGVyX2lkEiW6ASIKIAoFdmFsdWUSF7oBFAoSCgRVc2VyEgrCAQcKBQkEllacCo0CCgZjb25maWcSggK6Af4BCsgBCghsb2NhdGlvbhK7AboBtwEKtAEKB01hbmFnZWQSqAG6AaQBChcKEWF2YWlsYWJpbGl0eV96b25lEgIIBAo5CgliaWxsZWRfYXMSLEIq4KqL4oG78J2SpUjwn6aI4K+Q4Ky1U10hwq/wn5+w8JKQqjBML1PwkbaVCgoKBGRpc2sSAggDCg4KCGludGVybmFsEgIIAwoNCgdwZW5kaW5nEgIIAgojCgRzaXplEhtCGSfgq5B20agmPPCRiptZJ2Av4K+BZyfqnJ4KMQoHbG9nZ2luZxImugEjCg4KCGludGVydmFsEgIIBAoRCgtsb2dfbG9nZ2luZxICCAIKHQoEbmFtZRIVQhPgqINcWCUpIiUk0ajCpe+/vSo5ChwKCG93bmVyX2lkEhC6AQ0KCwoFdmFsdWUSAggE +CqkBCqYBugGiAQpoCgNrZXkSYboBXgoeCgpjbHVzdGVyX2lkEhC6AQ0KCwoFdmFsdWUSAggECjwKBG5hbWUSNEIyw5kuXMi6Osi6J1dN8JCWlPCeubQv4aWhSy4kP1YqTDfIuuCxg0U4PfCflbRV0agmZl8KKQoEa2luZBIhQh9DbHVzdGVySW50cm9zcGVjdGlvblNvdXJjZUluZGV4CgsKBXZhbHVlEgIIBA== +CjkKN7oBNAoVCgNrZXkSDroBCwoJCgNnaWQSAggECg4KBGtpbmQSBkIESXRlbQoLCgV2YWx1ZRICCAQ= +CooBCocBugGDAQopCgNrZXkSIroBHwodCgRuYW1lEhVCE8i6NmnhnaDwko2NyLogbsOXyLoKHQoEa2luZBIVQhNTZXJ2ZXJDb25maWd1cmF0aW9uCjcKBXZhbHVlEi66ASsKKQoFdmFsdWUSIEIeRkk68J2WsXvwn5W08KuftifgoaXvrL5cKy8u4Y26 +Ci8KLboBKgoJCgNrZXkSAggEChAKBGtpbmQSCEIGQ29uZmlnCgsKBXZhbHVlEgIIBA== +CikKJ7oBJAoVCgRraW5kEg1CC1R4bldhbFNoYXJkCgsKBXZhbHVlEgIIBA== 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 +Ci8KLboBKgoJCgNrZXkSAggEChAKBGtpbmQSCEIGQ29uZmlnCgsKBXZhbHVlEgIIBA== +CpkBCpYBugGSAQoJCgNrZXkSAggECg4KBGtpbmQSBkIEUm9sZQp1CgV2YWx1ZRJsugFpCiAKCmF0dHJpYnV0ZXMSEroBDwoNCgdpbmhlcml0EgIIAgoQCgptZW1iZXJzaGlwEgIIBAoTCgRuYW1lEgtCCSZF4Z2C4K2LJwoSCgNvaWQSC8IBCAoGAwdoJJhMCgoKBHZhcnMSAggE +CjMKMboBLgoJCgNrZXkSAggEChQKBGtpbmQSDEIKR2lkTWFwcGluZwoLCgV2YWx1ZRICCAQ= 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 +CmgKZroBYwoJCgNrZXkSAggEChoKBGtpbmQSEkIQU3lzdGVtUHJpdmlsZWdlcwo6CgV2YWx1ZRIxugEuCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKQhFCiJAhFiRJXA== +Cl4KXLoBWQoVCgRraW5kEg1CC1R4bldhbFNoYXJkCkAKBXZhbHVlEje6ATQKMgoFc2hhcmQSKUIn8J65iyRAJDw58JC6q/CeuYLgtrTgtYZ8W2Bc77+9XHpk4K+Q4K6P +CtsBCtgBugHUAQqUAQoDa2V5EowBugGIAQoRCgtkYXRhYmFzZV9pZBICCAQKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAoaCgtvYmplY3RfdHlwZRILwgEICgYBNCkkdZ0KGwoHcm9sZV9pZBIQugENCgsKBXZhbHVlEgIIBAodCglzY2hlbWFfaWQSELoBDQoLCgV2YWx1ZRICCAQKGwoEa2luZBITQhFEZWZhdWx0UHJpdmlsZWdlcwoeCgV2YWx1ZRIVugESChAKCnByaXZpbGVnZXMSAggE +CkgKRroBQwoJCgNrZXkSAggECikKBGtpbmQSIUIfQ2x1c3RlckludHJvc3BlY3Rpb25Tb3VyY2VJbmRleAoLCgV2YWx1ZRICCAQ= +ClYKVLoBUQomCgNrZXkSH7oBHAoaCgZzb3VyY2USELoBDQoLCgV2YWx1ZRICCAQKGgoEa2luZBISQhBTb3VyY2VSZWZlcmVuY2VzCgsKBXZhbHVlEgIIBA== +Ck4KTLoBSQoJCgNrZXkSAggEChEKBGtpbmQSCUIHSWRBbGxvYwopCgV2YWx1ZRIgugEdChsKB25leHRfaWQSEMIBDQoLAWEjOSZyUyCVKYw= +CkoKSLoBRQoJCgNrZXkSAggEChAKBGtpbmQSCEIGQ29uZmlnCiYKBXZhbHVlEh26ARoKGAoFdmFsdWUSD8IBDAoKAZgFCSEYk2YynA== +Cq0BCqoBugGmAQpsCgNrZXkSZboBYgoeCgpjbHVzdGVyX2lkEhC6AQ0KCwoFdmFsdWUSAggECkAKBG5hbWUSOEI26qKtL3s8ZCbCpcKl8J64uyp18JGpulBrReOHuyfIumDwnqOS8J65juCgnzzwnrmk8JC5tjoqCikKBGtpbmQSIUIfQ2x1c3RlckludHJvc3BlY3Rpb25Tb3VyY2VJbmRleAoLCgV2YWx1ZRICCAQ= +CjMKMboBLgoJCgNrZXkSAggEChQKBGtpbmQSDEIKR2lkTWFwcGluZwoLCgV2YWx1ZRICCAQ= +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHSWRBbGxvYwoLCgV2YWx1ZRICCAQ= +ClUKU7oBUAoJCgNrZXkSAggEChAKBGtpbmQSCEIGQ29uZmlnCjEKBXZhbHVlEii6ASUKIwoFdmFsdWUSGsIBFwoKBTV5YUhXWHaBjBD///////////8B +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ2x1c3RlcgoLCgV2YWx1ZRICCAQ= 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 +ClMKUboBTgoZCgNrZXkSEroBDwoNCgRuYW1lEgVCAyrDjAoRCgRraW5kEglCB1NldHRpbmcKHgoFdmFsdWUSFboBEgoQCgV2YWx1ZRIHQgVSYMKvLw== +CpYBCpMBugGPAQpVCgNrZXkSTroBSwoeCgpjbHVzdGVyX2lkEhC6AQ0KCwoFdmFsdWUSAggECikKBG5hbWUSIUIf6qem0agk8JCOq8OT8J+VtPCQqJ7wlr+kSlxg8J6LjAopCgRraW5kEiFCH0NsdXN0ZXJJbnRyb3NwZWN0aW9uU291cmNlSW5kZXgKCwoFdmFsdWUSAggE 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 +CqYBCqMBugGfAQoJCgNrZXkSAggEChQKBGtpbmQSDEIKR2lkTWFwcGluZwp8CgV2YWx1ZRJzugFwCioKC2ZpbmdlcnByaW50EhtCGc6gQ+GtszLgu5LgoZ7hip3DpOCmkPCegKkKKwoJZ2xvYmFsX2lkEh66ARsKGQoFdmFsdWUSEMIBDQoLASaViWkhYDZIJYwKFQoCaWQSD8IBDAoKEAUZiZlkCDMSjA== +CkoKSLoBRQoJCgNrZXkSAggEChoKBGtpbmQSEkIQU3lzdGVtUHJpdmlsZWdlcwocCgV2YWx1ZRITugEQCg4KCGFjbF9tb2RlEgIIBA== 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 +ClsKWboBVgokChFkZXBsb3lfZ2VuZXJhdGlvbhIPwgEMCgoGCJSIISWWhhEcChgKBWVwb2NoEg/CAQwKCidXkUFUWXlgg40KFAoEa2luZBIMQgpGZW5jZVRva2Vu +CpboCwqS6Au6AY3oCwpUCgNrZXkSTboBSgpICgZzb3VyY2USProBOwo5CgV2YWx1ZRIwugEtCisKGEludHJvc3BlY3Rpb25Tb3VyY2VJbmRleBIPwgEMCgpGmBETQwloRkmcChoKBGtpbmQSEkIQU291cmNlUmVmZXJlbmNlcwqX5wsKBXZhbHVlEoznC7oBh+cLCvHmCwoKcmVmZXJlbmNlcxLh5guyAdzmCwrWAboB0gEKjgEKB2NvbHVtbnMSggGyAX8KGUIXeyp6QWFsQ8Kse9GobvCQpKzDkUDvv70KM0IxcyfwkI6g8J6lnvCRh6Vcwrnvv706QuGdoOCis+qsrj3qkr7gt6Yqb+C0j07goZ4/PQoOQgxy8JCtu+Csh+CsrXkKF0IVJ+ChuD7Iuicn77+9JMOhPMi6PipcCgRCAnJ7Ci4KBG5hbWUSJkIkJvCQgIjvrYHgrJDwkJaUyLrwnZG4wqUkPHtpPCVgJVwl77+CCg8KCW5hbWVzcGFjZRICCAQK8xO6Ae8TCsoTCgdjb2x1bW5zEr4TsgG6EwoaQhgiN+Chs8KhTO+/ve+/vVxo6q+YWOKBm1MKEUIPSOGoqybgr5DCpfCehY4gChxCGlzwnYye8J65qvCbsp4oPFwkISLwkbyEw4E/CipCKCRRwrdV8J64suqSuGPwnqST8JCKhuCnoOGsruCvkCY48J65nfCeuqUKGEIW26UvWvCdmZ1uMPCQi63CpfCdvKfIugoiQiAi8J6Fj/CesoHCpcKlI+GNsPCQjqPgs4hc8JG/r++/vQoqQigm4K2nNuODpuGdsz/OhsKlcirhvZnRqHTwn6myJ1nwkLmy8JC6l9GoCiBCHiclyLoq4LqC4raiw6XwkKmW4LeW8JGcouKRg8i6OgoJQgdz8JuFksi6CilCJ0Us8JC/iy8qJSfwr6ONyLpowqXRqGnwkZebYDw6J00sYMi68J+rpAozQjEi8J2Vhisu77myN/CRjaxPdD0z8JatnuG+lCInPeGvnsi68J+FgeCmqjjqn5c8w4QsCitCKeK0mMKl6qCnP9GoP+C5gUBw4LemUyzhqaQkXHAuXteld2fgrILwnam8Ci1CKz7hvZEmezTwkICoNDU9LnQ/e+G9m1Hwm4Wl8JCWle+/mvCQv6/gp4zvv70KHEIaw6vWjjvwnriL8J6lnlzgpr9P8JCniTbCpXEKNUIzPFwkJfCQhJ5FL/CWvpvqor3IuvCRvZHgqoPgqJDgtIrwkJGLP++/veqlpOCzij7gqpFrCjZCNEnwkaSh4KqY4KexZTMlwqXwkKiG77+9dsOz8JCrgzEpMy848JCihcOJQeOEiteVJuKBmVoKIUIfXeCguOOEjuCzoGvCpSYvIi7CpeC6kDzwn62Y8JCkvwoQQg5D4YqLw5skdCYvOsKrWwowQi4/77+94LOGOsOp4LqIyLrwnoqe4KivWFzwnaeqazzgqINZwqXhraXvrbQ/77+9CidCJSIkIvCflbTCpfCflbTwkKO0O/CflbTOjPCRtKfwnou/NnvgoZ4KDUILWCLhv7RGUuC2uy8KJkIk6p6fLeGNui/hg41NPDzhvZfCpe+/veC7gW3hn7jRqHvhlI8xCiRCIl9d4omTLkTwkYu3IyQgPfCdjbQ54LeK8J2Sqifvv73CpUAKNUIzKlxPPF/gr5BcL+GciDgn77+9L+Cxh9Goe2DgoqsjRDxg8JuxgOCzqFpuNcOc8JaugsKlCjVCMzwqIvCRto7gq41cdjzwn6KwJCXDuPCav7bvv4XigInhuI8te+qpjTxq77+98J2SnuqgtwoPQg0xNyfwkY2IYCrwnZWLCg1CC+CpkcO+e/CehLQ2Ch9CHci6YO+3jzJcJlLXk+C1vvCeuZ9yfmA8P3Tit5wkCgNCAUUKOUI34KGbPeqjgFxcJ/CWqakgJPCWqZw6wqXwnbylIj0q8JCKgyMv8Jq/suqsofCQroDgq5Ao4K6QXwoiQiDwkbyMwr4+XTguN0x74rStNypa4LqOJfCfrqNN8J66kAogQh7wn5W0Ti/vv73wn5W0W0XwnrqiePCflbQj15Tgs4gKL0ItIvCRtIAnJfCeubngqonwkKiWL+CqpHkm4KeI4LiKez084KuQ8JCEgnPwnZKmCkdCRTo/8JGNl+GzteCuozxU8J+VtPCeuYtOJXTwn6m5JeCrheC4l+CwvOKrrijIuiXqpaXgso8l4LOeKmTmu4ol4KeX8J+VtAogQh5NXPCehYVlwqVMaeC8vO+/vT3wkY2rzoU5IvCRiowKD0IN0ajhpbTwnoWO4K2VSgoEQgLCpQoLQgkm8JCouD/grpUKLUIrPSrwkbS94K2cPNGoPXIkXCcmL2B7ZnsrJsKl8J+buyp57Z+6J+CykGFDJAonQiXwkY2xPSfwkIqv0ah94KKH4LqETzLwnYWHPOC2u9Go8JCHkDwqCghCBuqpjOGeiQoxQi8qVT8l6pKT4aak8JGDouqivXhgLGDwkLGIROCvij/wlr+xKuCti+G0qfCQk7UiewoMQgprTCLgt4oq4reWCipCKDxg8JG0gOGkmO+/vcKi44ef6qa+KvCRtoHRqFFgJHrvrYN2PfCfgq0KLUIrUPCQp5wiKuC6jjk60ajgp6Y/JuC8oMKl8JGNiDpRYFdg8JCWtnvgqZ7Xswo2QjQkWCDvv73wkJGsTsKle/CflbRO4rCNMe+slCTigqo28JG+sOCuo8i68JGMryHNveCru1wkCkBCPsKn8J2Sv/CQlb3wnrmX8J+CuuCmrSXwkIGJU+Ctou+/m/Cdgrg5J/CWq7Vf8J6KnPCdjLTIul45QfCRh4dXChhCFuGogtGoXOK0p0jho5zgsIws4aq8eyIKLUIr4LWeL++/vTxP8JCVhS7igIg84ZieSeCotiTgqLwiJDlU4Z6MOfCRnIEueAoRQg/wkJaj8J+VtCbgq7zjgbYKCUIHMsi6Ui8/YAomQiRmWNGo8J+VtDzwkKee8J6Lv2A1W/CeuZkuLnvwkLSyb2t7xZ4KHkIcw5zwkJW6yLrwkYezw4TCpSBW8J+DjyV78JCyqgoKQgjwkbSI77+9KgoEQgJPPQoZQhcn77+9LlzCruG8sjzwn5W0YOGPuMOeYAoPQg0nbuCtou+/vfCdlYR7ChBCDlxpe+Gzhl7wkJa26qe8CitCKXtEIirDslg6Q8i6JD8kaPCfiKzwnp+oPCrwnqWeRi/DvVdhJeC3nMKlCg1CC2su77+9L2Ff4q6QCiNCIc2s77+94Kis4YuFbPCfhKXDi1l48J+VtPCRmZEv8J+vsQocQhrRqHrvubR04Ye0wqVT4reA8JGKjTQ98JCgqwo2QjQoyLo5Y1XwkL+C4YmvJ0nqn5NWTvCQqppy8J2qnCp24ayfSCZqw4vwnLy/POG1ksi6Jj89CkJCQO+/vT1gJvCRnYTwkLKCJWM68J64tyTwkJa88J+giCrwkJa04YmYe8i68JCTruK6k++/vUXvqaM9al/RqOCqry4KJ0Il77+94YuAdCnCpSZzInLwkaSRPDxl8JCggtWrYHJHZsOZ8J2UuwocQho6WSbwkZqV8J2gvU9jVuCniNGoOynDtTrRqAorQil5InY24aWAeipV8J2UjvCRpJ3wn5W04K2fTUnwn4CAeyLwnZSQ8JGKiwoEQgIqIgo6Qjgq8JCVmPCeuLfwn5W0a+K3i03wkL20Pci6ez/guqUuLiLgqLzjiITwkJWTwqVt4LqlPF4iP+CnrQoHQgXwmr++VAocQhp5J/CfpoEi8JCns/CfgbAn4bOD77+l8J2SrAoOQgwl0agzZvCfoZngsJAKHkIc4KG4beKRiDonb+GktuC0gu+tpCfvv5pgP1IgcwoPCgRuYW1lEgdCBfCRpLh0Cg8KCW5hbWVzcGFjZRICCAQKxg66AcIOCvkNCgdjb2x1bW5zEu0NsgHpDQo1QjPhnaUlMuKGk2zwkKiGXPCfnr4q8JGKiDoq4K+58JGcnWHwn5W0J2vit5bwkJaU8J64sToKIEIe4KCUNmAm8JuFkfCQqJDgvKFMRsKlJ8KvYGnhp5k4Ch1CGy4lbOG+t1dg0ajwn5W0LvCYophq0ajwnYSMQwooQibwn6uofOC6mFDigJUnYNGo76yBw6Lvv71CLXvgsI8/8JCdi+CthwocQhrgr4c58JGIsjpjKvCRmrdTP8KlLznwm4WVUAoSQhDgqKzguo7gu5fwkZORPG9qCj1COyciYPCfrr3CoMKkQ2piNPCQhqDwnoKPPOGKoeGMtOCjgC7Ctlzwn5W0eWQl8J+Ap9Go4LqEe1w/wqYkCiRCIibRqPCflbQrP3kn77+98JCAmkTwn5W0wq4mwqXhp4gkcjwKEkIQS/Cxn6bCpSrwn5W0NTfIugovQi0l4KeX8JGMg++/luODkc6b4oGwJci6Ji/hirzwkaS4RFXjg5p6Osi6cfCRtaUKPkI8OHgw766+4LSO4oGwSsKl8Juyk2PitoAqIjwmbOK3jvCYtIfhlo1A8J+VtCc9Kz1RNeK0j/CflbTwm4WVCipCKPCeiq7wm7G6WuGPrl/hnbLhiYvwkL6C8J+rjioq15zgqKTwkZqlN3kKMkIweyTCpTpE8JuFkTfwkaKz8J+VtHPwkb2PXFzwkL2y8J6LvzwhPS7vv71EXGAlPVBMCi9CLe+/kuGJjCRY0bIm4LKSNzLgrpPvv71bOvCQsIIq4K65PCJccyTqoqUlIiEsbAo5QjfwkLCr4Ym2wqVcb+CrrMi6JWAx8J6An8Kx8J+VtHbRqEI9c8i68KyOkuK3iSpOYPCQoLg8IjdmChpCGCFmIlzwn6m4wrJL8J2SnmA644iCYOCwvgooQiYmPz1M4Ky3PyU34oGxJjFNPNGo77+cNC7wkYSu8J6fumgvYMi6IwoMQgoxU++svCbvv70nCiZCJPCQs6RPIvCRiql78KqltiLgsaEu8JGZlkAqy6HgvrMl8JGmswoOQgxeeC4kSfCXsbHgqK0KHUIbeUVgLHJwJCQjcvCcvYLCpfCrn6zhnKkyPMOpCjJCMDRZUlY6SDEkOkYhItiZL/CQqIbql7nwnZWGQEMz76yC8JG7t+Gmnz3vv73gprYqMAodQhs5XGAlKj17SfCfn6M8L3PDrCIu8JGDtsKnPyIKOEI20ah4TUA3aOKAkCU84b2bXvCdkr3wkYOzw5nwn5W08JORlPCeuLTwn4mEJC88Tjwv4YmcW3svCgZCBOCulD0KGEIW6qW3Pz86yLrwn5W0L1nwnp+y8J66mgooQibvv4cmb0nRqHvCpT0q8JGThT09LCfwkKO7wqU6PiciSOGfqNWsewoUQhLgrrNn8Ja/pCXIuuCnsMOyPHUKRkJE8J6fqOCnjjxXJOqfkXvwkZOW8JGytfCRpKJR8JGxgCLihb3Iunvwmr+y77+9azx7Jj0k8JG2kO+/g3RrL/CWrarhoJAKF0IV8J+VtHLwkYin4LSGJvCRjZ/RqMOuCgNCASYKRkJE4a2u4raqJnDCpfCQppZz8J+VtOqsodGo8J64u/CTiKBs8J6fqSY68J6AhPCQqaXIuj/IuiLwkYiW6qeSXGDVmuqspFQKJ0IlNy4vWHvgrLY/KOqkmmNsXjvhiYwldGDwkJ6l6qyV6qm68Kqfigo7Qjl74L+RJVnwkpCp4LeKZu+/pfCegIAq8JapkvCvoJJowqUkfDohw5bwlq234LuSNGDqqYgu8K+nvG0KF0IVL/CWv7Aw8Jy8gS7gqobqr7Fc4Z2ECh5CHPCeuILgtpDwn5W0yLrCpS4reyot76y8L+GqoyoKB0IFJyXgv4YKEUIP4Le04reFT+qnhmDwkZKAChpCGCUnIT8kVjo/wqXvv73DrHPRqPCeuKcmMwo1QjMv8J+AqUzwkYqRZfCQlpRe8JC5qOCsjE92PDQ8YfCRjZcq8JuImMOhVyA/8J66k/CQvJYKNEIy7Z+STyTwkK6uyLpc0ah74rO/wqXvv71oYPCRga3vv71yyLoq6q+a8J2LiGjvvIFByLoKAkIACj1CO2lAPDJH8Jq/vSTqrJLwn4Cj8J+qkPCRm4jwkLCcJu+tgEzhtpLqk53DoPCbhZVgXDon6qK/8J+Cv0RZCiJCICkm4LW3yLrhiZol8J65l9+9YOCuqjZE77+qaGDwnp+hCjRCMuC7n/Cdga7gu4wk4rWwPeCrjFzwnrmXP8KlPEzgqLzDu18kJvCeuaQvLyM1JXzwn5W0Cg9CDe+/veGdq8i6Jn1HICoKH0IdyLom8J+ev/CRvZTgqrLwn4GXw7bvv71wOvCWroYKAkIAChQKBG5hbWUSDEIKcyU6Oj7wkI2RZAouCgluYW1lc3BhY2USIUIfw40vw4zwn5+w76qoIuC/gO+/vTon8JGDgFnwn4G0fgq/D7oBuw8K6g4KB2NvbHVtbnMS3g6yAdoOChNCEeGpsFokLsKl8J65m+2et8KlCjFCL+Gzh/CepZ/wkKusLS4pPmLwn4OdJeC1hjpGKOCnocKlVfCdjafwkYeK8J+VtMi6ChxCGiXIuj1B8J65r0nwkKmg4LeuamFSPy7gtr0qCgJCAAoKQghhJj3wmLSAfQooQibgqpx7P/CbsbFnPcKlPzzwkYGzPSXRqOGNp/CQjabwkbag77+9YAoXQhVbPzZmTU1zduCvkOCxmiXfgOC0jmwKN0I1OlZUbvCdlqx7c/CRpJDwnqWf8J2Ivig/S33wnZS+JzxrOuGztnvwkr+m8JC0iMK+wqVbSnwKKUInR/CflbTwlryYZe+spPCfgI8rJT3hpr3wkKSR8JG1lyJo8Jq/sE9cCjFCL1fvv70u4K+64Kie8J+VtNGoLuCvivCeu7DDjmDit4jIuuCzi/CflbQ84YuA4LSTCiBCHvCRh4xufcKlcHl7w5zgqpEjyLokwq7jgJ9g8JGMtwpHQkXwn6ux1b0k8J+VtHnwm7KZKT/CpWQmY1Twn4mHPeC1myrhpJ7wkaq44KqK8JCDmeChnuC1i/CRtZAmYSwsRfCQgYPvraUKH0Id8JKTlW7grI9e4aq18JCHty8yUy7wkKiV4LqEP34KK0IpLmxLIuKFoHsnez/wn5W0YOGllj4iJFzigpXwkbWTJidXZuCxmfCflbQKNkI0ZvCfgrpY4K6DJeCqi3p4IuGiqsOFQvCRjYjhqbJMJT9o4rO/8JCjo1/hs7LwkJW8Y86MYAoXQhVl4La98JGKim4u8JG0hOK2rm150agKE0IR8JGkhSQ68J6Fji7wkJaxbycKLkIs8J60mOGksz/vt7HgsIov77+9czrDpDEq8JGNnSgq4KCzTCEsI2A9JMOLwrMKQkJA4LqK4aS277mdw6Q976y+IiM98J2LhHzwkIaZ8J2UjlzwkYyQwqXWjvCQj4g8UD9qw6/wnriAP8Kl8J64pzxJPApFQkMmXGjRqOC2ifCRqYfwn4mB4K2g8JariCLqqbPIutGo4oKV4LuDJeG9m/CfrbVl4LOmTSrhoJXvv73wnrmLJeG/tC1UCiBCHiU28J+VtCpJR/Cesp108J6EqG/qrKrvtq9Y8JGKiwoRQg9TXO+5oELgq4lgJ++5qT0KBUID0ahdCiFCH1JUWCBXYCXgsIpfUHrwn5W0yLrgraHhv7TwkIu5JSQKO0I5JPCflbQmSfCei7/vv70k8JuxtfCbhLJ68JuKkTo+4a+H8J+VtCJ0VFx9J3bgsYwq4KO0Siou4Y6lCjZCNCrDl+Cjieqfk2rgs5Z88J+qhvCRtIZz4LeW76m/Py9cWi/wn6y+b/CWqYVe8J6ymvCdkq8KGkIYwqXwmK+B77+98JCkiGDwn5W0ZPCfq4QkCghCBiR68JCouAoGQgTqoYZ3Cj1CO+CorHwmyLrDifCQpKjwkYS48J66oSXwkKS/yLpFYXJBV/CRjK0k8J2Imu+/vWDIulzwnLy28J+vtSJoCi9CLU5jYPCRsYDwkYiQJ/CflbQ98JCphyw977+9KiR60ajhs4fwn5+gKngi8JGKjAohQh9d8J2Uu/CRtaFLyLpB8JGylMO4afCQnYTgsqvwkJWhCitCKe+suvCflbRPV0zCtPCfoIgv77+98J+qkEQv4K65Rz8/NPCegKPwn5y3Ch5CHDzwlquxSGAzPCZ7WWwpNSpg8JG2kyU9L++sky8KQ0JBZzjwkaSpXOKqrzg94aCV0ahg4KGm8JGwvsK2Vy7groU84LeWMScn8JG0iPCRjarwnrqCeuCznuGJmOGftvCehLwKFEISRS7wkIGVTcOo8J6Kq1wkPW9MCgJCAAooQiY3Ok/wnruwIl4kTz9K76yE8J28pjnwkICs0ahnKiRg8J+VtOqhlQotQis4fuCyiCY8ZGZ78J64p+qsqfCQlrMnX/CflbTwn5W0L3XwkKuvYsi66pqnCjxCOuCnl03wkIqvyLpEyLrwkKmuVfCeuZ1X4LqB4KmeM96wKSI6MfCQoqzgq4Twlq6B77e4w6fwkJa1w50KNEIydCfguqU24LCw4ZCKYyLvrYAq8J+VtDrhp4bwkJOPJGvhv6pxL+GdoSjvv73it5Xgto0KAkIAChdCFV0n6qaPeD0k8J+VtCd9P3Xwn5W0PAoNQgs6PzUk4LOdXe+/vQo/Qj0/8J+isGd7L3t9Olngv4U68J+HqT/wkbGx8J64pyZtSC/hv55ZLvCflbTqqZN2KvCepZTgqoLwkKmUem49CixCKidf4LGd0ah58J+igfCeuZTwkoCTJkYuJXDwn6+w4ZyR4b2d8JGKgTQ/dAoPQg1g8Jy9qvCflbTwkbSFCiFCHyPwn6uB4oC48JGZkHvwkKKpRTwmJVcs4K6/feK1sCoKFEISXfCQqYjCvWl28J+JkHHwkK2+ChpCGDp+OuGNt24u4bGuKu+7su+/vSJy6p+TKgoVQhPDui7wkY2XNy/Cou+/veGfsS88CghCBuCunO+/vQo7CgRuYW1lEjNCMTwnK1J98JORhmQk8Ja9hFzwn62a8J2VhvCRjYAp0ajhsL/IuvCdjJ0uwqXwkpGwK1wKDwoJbmFtZXNwYWNlEgIIBAq+BroBugYKhAYKB2NvbHVtbnMS+AWyAfQFChxCGtGow50/Mifvv71oX+Crh9+/7KWHL+CvizVcCgdCBSbCpSZxCjhCNj3wkKioLiXgqq0y8J+CpuGsnnMpUuGktyTwkbGq8Ja+kjwtS+OGnjJ8V/CdlYE/PPCegJsqYgoRQg8mPMi6L8O1OljDiPCQgL0KGkIY77+9VCUn8JG1pPCQlrbhvZkubC3wlq2hCjFCL/CRjYPhpLhcP+KRguCrusOOPDbgsK7RqEdvZci64Y2j8J65gkzhiaXRqFHRqDwqCh1CGyXwnrm8WTrtn7U14Kqz4Y+94Y6E8JGWgiLCrAocQhrwkIWJ86CHhfCRirfwkY2X8JCWoWB8JHvIugoRQg/wkKuN8J67sCLgro/RqD0KHkIc77+98Ja/oeODnEvhoYsk4reM77+94KujVnRcXQosQipwJci6OvCYtIZk8JCdpl7wnZOBP/CWv7A78JORh8OV8J6jjE5x8J+VtDMKMEIu4La9JfCfm7MuXybsoJjwnZKiPTDguoQ6eyXhv7k84K6yS/CflbTwn6GQNj11UQoKQghle++/vcOaPApEQkJ7L/CeuYnIuvCRhIo9XCbwkY2LJD9oefCdlYbwkaSRLjrwnYSw4YmRIMOsIj/wkZuJO/CSv6Au4K6+L++thPCRhIcKPUI78J2ihjo74b+O4LuG0ahMyLrvv73CoOK3t/CbspV7VPCQuo4i8J28lu+2v3JQ8J6Cj2bwn4KhwqXgrI8KHEIaIj3iuozCpe+/vSfhpZDgtpvgvK5HP+CvkD8KKEImIGDwn6CdJSHwnZCI8J+VtHRg4LOeKibwkY2I77+bIvCav7DgqrIKNUIzQPCflbTitrXhnLTqn5Nc8J65izbRqCRryLpILvCRo49AIyTwkL658JGnlfCRm4NYISYnCj5CPCrwn5W08JGNjS4i8JGko3rwkJ2E8Jq/vfCflbRZ4oKXLtiT4LOHXO+/veqSmC4u8J2VhvCflbTwkYebJgoPQg17JicmWjxgdOC3iidlChYKBG5hbWUSDkIM4Z+KM0vwkbanXDskChkKCW5hbWVzcGFjZRIMQgrCpSfisa3wmr+9CpITugGOEwqkEgoHY29sdW1ucxKYErIBlBIKGUIXNCfXsPCQrKVAyLo9e1c2ez3hvrzvtqwKBUIDwqVBCjJCMOCulVpgJC484bGwcnQ/8J+VtE7wnYisOzHwnLyH8J65r8OZ4K6KU8K6WvCrnaJ7ZQpDQkF34KupP8i6L2bwkJW54oGR4KmmP+GciHPvv71g4ry74Kuw8JCpliQn8JeMs1XgsIRVXvCQqYDwkICB6q+38JasoAo/Qj0s8JCWnvCRtYDgrp9c8J+VtCZxwqVr4KmRKVA84YaCL27hoIYk4b2d4LeW8JGEu2Q/MPCeuKI6R/CRg7g6Cg9CDfCdi4h7e2098J2Soj8KAkIACgdCBXcqw4IiChRCEsOW4Kia8J+VtPCRnKs7T+CqtQoGQgRt77+9CiBCHvCQja/wkYyz8JCKjyXRqOCxmljitK3wnrux8JGMhgovQi1LXmPgsYbRqCIz8J+VtGDvv73wnYiyyLo6Q+CxnSRcXChgw47IuuCzhiLvvbkKJEIiJlU/XPCdkpQn8LC8s++/vUwz8JCSp/CQqLrqr7cnSeC6swonQiXwlqux8JGKtOCssPCQoqdd4Kit8J+VtPCRjI/wkYyB8JC6rSQkCgdCBfCegKEmCj1CO+K1kOqjkD4u8Jq/vfCbsbQp4byq77+9ViAwPDrwr6K1J05vdfCflbR74ZyDw6U9PyXwkbS64LOgPyAqCh9CHfCflbQkIlxbIioycS/gt4YlyLrvv71lzox7XHZCCkBCPlvwqrq24bKc4Kmt8J+VtPCeuKRT8J+qgVVN77+T76uI4YON4oCW8J6KqibwkLC0UuqrruC9o+K3mjkg0ahsCjdCNT9T1JzCpTIu4LuWJHJ4P+Gmuns18JuFpTsnWXleUvCdlJPCpcKlLl3wnZe28J6fofCfqqUnCjpCOO+5qeK2svCRmaVPJC9mci4/8J2qqEnqr7fVqCLwnri5LvCRjas4dCRV4rWw4oK+QeyerTxlKickCgpCCEEk77+94KiWChJCECfIuuOBuiZwL+Cyg++/lyYKOEI2KjBZKeCunFjCoO+/vfCfq7E88J+VtEoi77+9cuC0i/CdvKfwlq2l77+9IlpUQEbgroMnJmUqCgdCBSd7WUptCgNCAS8KAkIACjxCOkVA8J6fpSI/OmgkOl3CpT3hqqXwnruxL/CdkqYi4K2WPynvtJE/TOGJqD178JuynO+2ou+/oCLgr40KCkIIKmBgKi1BOC8KLUIrSe+/vVog8JCgmzd24ra9YOGFrnsqWS898JC8pWbhvqzgr5dFJsi68J2Suwo1QjPgsIM8UjzwkYyMWGDwkKSlSXt7T/CRpJbvuaXCvj/CpT1OOnvwn5W0wqXRqFJz77+9XFAKOkI4yLrwnrSfXCd7Jsi6PV888JG1p9GoJWXwkYOe0ah8Pmw/8J66qPCRga1wQ++/vU8uyLpreeOHhzcKAkIACkFCP3tcyLritoVgXOCmrT0v8JC9ivCbhZLvv73wnrqHe3tA8JGmoDfwkbGVJPCQvJhML+GMlPCeuYnwn5W08K+grQoLQgngrZ/wnoCByLoKN0I14pGKMPCQvoFtby894L+Q4K2D4o2v4oKMYjd1PV3wnrmX4Yuc4Yqz4LGLP++/vWDgrIlMcnEKHkIcJPCflbQic1zhoI3wkpOPQXUq4bC9OjwxbuCulAoyQjAsfjzCruKFgDzwn5W0Pycn8J64udGoIlxXKHHwkJaVLvCQlpx18Ja9kvCeuaHCpWAKJEIiL/CdlYTgq5Bf8J+DqkLwkLqsPVwnOlTCpeGxhMKl8JGIjwoCQgAKIkIg8JORjCsvKsKlIvCQhppwwrnjhYHIujpfwqXwkJaOLlYKMEIuT8i6SmBE8JCWkmDwm7Kf77+9JngqXCIuV/CegaXgpo8ifvCav7VsWuGxueGJkAoDQgFqCitCKWrhi4BxLvCQqZZVPmDwlqyL8JatlCXhoIrhupN777+98JGWu/CeuZ01CkhCRvCdprYr8J+VtFzhgqDOhOC1izw64Kavzb8i8J+VtCrwn5W0w5R78JGXj/CQnro/J/Cei7Twn5W04Zy0w6AkOkzIunvgrooKFUITwqVBVci68J+TikrhpbTiv7N+OgoeQhzgt5MiPy8x8J2Uj/CQrqzRqCJc8JC6rSThjJNJCi1CKzxMP2oq8J2Vhsi6XPCQlrjwkKiOaMOXXTguP+CmjyUm0ahaIip6Zu+5lWYKB0IF8JCPiiwKFEIS4LqY8J+VtPCeuZ/vv70u4o6AChtCGT1h0ajwkoSe8J+qp0/DtSY6Y/CforHigYUKMUIvYPCRsac94Lym8J28ki/RqCfvub3hvJl7YT3wkIea0ag/PPCWq5lvw4HqrKrCpTsKLEIqw6VwVvCRpL3ikbBfRyc6JPCbsp17XPCflbR4YCh9P9eh8J+VtHrwkK6bChlCFzvwn5W0RlzwnZCxSD/gsqDgoaXwnrqTChZCFDzRqD/hirTqopYvXCxN8JCCriImCh5CHG4jwqXEleG/jDE80ajgqpRRwqXDrmdMe/CWq6MKB0IFJPCRjYsKB0IFd+KChSQKJUIjwqXwkISN4Kqv77meOz3wnYugbvCdiYRYP8i6N+Cmt27hvrkKCUIHJD9cJicuJwo9Qjvgr5Dwn6Wy8J64t1VcdvCeuaQl8J2UvPCflbTCpeOHsuKBh8OqL/CYl6gjODJmyLrwkr6jW/CRhIhJLgovQi0mKvCflbTgvrfgqodge3vqo7gnUS/RqO+/vfCeuZHwkY2X8J+rmuKugnXis70KJ0Il4LeK8J+VtO+qsi/wnbyC4KecOeCpnmgv77+9ccKl4raV8JC+hgoHQgXOmj1RIgobQhnwkIeXfSVlYD0v8JG1oCbhjL7vv73gtKVDCgpCCPCeuZnwnYitCh1CG+CvjSo1YOGtt08uP8K1YD3hsYkq8JCMuuC2pQogQh5+8JGIi15EZ27CpeGbpPCQkJ1pw5BxwqXRqDM3PyMKMEIudfCQi7Twn6uXJiU8YPCRg7Pwnou/1oXgp4jgrpPIujo7I8OaJFw64La98J+CqAorQilHyLozLyrwkYihIvCSvpdg8Jars1zvv706JPCdl5Dvv73wm7ClKuGktQpICgRuYW1lEkBCPmAn8J+giU3wn5W0Oijwnriv8JCAmuC3luOIlMi6SfCRtITwnriiJmBc8JCglTwuwrhgw7bhna5uPE7gq5BSChsKCW5hbWVzcGFjZRIOQgzqr7Lwn6mxdWngu5wK7xO6AesTCpYTCgdjb2x1bW5zEooTsgGGEwojQiE/TyLwkKSn4KmzLsK24LGCM2Bn4reDwqXit4t74oOePzMKHUIbb1zito7CpfCRhbNF4aWzc/CflbTgrprwn5W0CgpCCHhgNDDwpLW3Cg1CC15x8J+VtGXwkKiyCgNCAVIKIEIe4LKs8J6frXLwkairdWJbPz8twqHwn5W0KiZc4Z2vChZCFOCwj0vwn6ukLvCQjJfhirM9Ij8kCgJCAAooQibwkYyQwqUkLjM64b+5JXskIStg8J2Vj0vitr7wkbCG44Oc8Jq/sQo2QjQgVXcn8JCsuvCQgLZ7yLpbJcKl8J2euj8qJuC1qfCokL7vv70m0agk8JuFpyRfZHNZ4LWPCipCKEdc8J2Eme+/piLwn4ar86CHn0NFUTrwnrmLPfCRhYFdSu+/veCmsiQKNEIywqUie0pc8JCnmDzwkYSy4K2dVe+5qSLitpZrYCU8e+CvufCqoqHhpYAkXPCQhpvhvZkKNUIz4b++Jzsi4K6qOiTwnqS3aT3gu4rito1pUFzwn6Kw8JGEuPCfobkk4LOy8J2okiRdKEIqCi5CLO+/q1zDs3BBOlbqo5gh6qKOR3glwqIi4b2dJCrgrIPhiZjDgeKuiFTwlrqLCg9CDTImyLritrQsyLrgro4KBEICPyUKF0IV8JCgvCokWCV04LGWP3Aq8J2VjmhSCgdCBScg4K6VCiBCHvCQhJVO0ajwn5W077+944edxJrwnZKiW3TwkaS3eQoMQgrwmr+wMMOYJnsyCiRCIiLitqVOXPCRpYTDh1xTKmZbe++spOKxgFhZ77+F8JCery4KOkI48JORieG+hyo/8JCGoHThpYDwm4Wm4K6J4LaM4KyBJWDwkKiXXCbvv73jgI/wmKSiw4RcJnvigZ4KQEI+W+CulcKlccKlYvCetLV7KNGoRzrgt7TgqpM98JCold2/Ksi6OFzhvYrwkJOl8JGxvCHwkJSRJuCxgdGob10KD0INLnbgoag4bvCflbQ6ZQoIQgbqn5XgprIKMkIw8J2SovCflbTitq1L0ajgqo1g8JC0hvCQi7t74KyJJkjvrJXwn5W08Ja8m/CQqLo/CitCKV9I8JGcpeGPnzpsyLpY8J+JkCzwlquB4Luc8JaqoMi68JCnr3Ur44SVCiBCHicnO03wnZSW0ahg8J2GqD/CpSRQKlUia3gvLzdefAo1QjPwn5u4wqXhiox2PXt+8Kyir++/vfCeubXisrFoZi5KM2Qn8JatoC7gt4rgrpzCpcKlOnAKRkJEwqVzSuCykHvgpojwn5W0yLpgTO+/vfCfjLJqwqXigbAv8JOIuzhY8JuykyTvrYEkMT/wkJK08J+qk/CQnafihJvgqLAKJUIj4KaywqXCo+C2iOCrkCYmJmJc8K+hreGpmV/wn5W0P++/vToKGUIX0ajwn5W08J2SpUgu4ay5wqUuZ2x7yLoKB0IF8JG8jmgKGEIWIvCRjZfqobdG4LeS8JCTpmku8JuDsAoaQhhlYC4k8J+VtEdWwqXgqo/CpVM88J+VtCQKLUIrXMi68JGEskPwkbCFNyYn6qmqLkMi8JGMq9Goei/wkbKHJOCxoeKFrFA9Qwo8Qjrwm7KQ8JG1pPCbsbpqe8i68JOGhkc8Kj1V6qeEw5ZcXDnvv7xT8JCBkdGo6p+TPe+rgsOkaSTvv71gCjxCOt+h4amU77+9zb89XDDvv73wnoCkPTpj4rWv8JGMuColdFwvw5YlRFwl8JattmTvv70q8JGmpvCRl5IKJ0IlPMKl4bCIP9God/CRtL018Jq/skIobfCRsIhcQF/gt4JA8JGFqAoLQglt0ajwnrS9w5UKOEI2P8i6JHM4e/CygJUqUDFo8JCVizpUez8m8JCOnCov8JG7reCxoUvwnYOAzb884Y27csOl4KmzCjhCNuCriOG+r9Gow7jwkbWj8JC/rjrgqrNL8JG0usO5MvCeupE8PS/hmYxFJsi6PWrwm7KSP+CjqwoWQhTwnqWe4b+oc0HwkYqM4Z2yMO+suQoUQhJX8JGRgfCeuLkl8J+VtPCQk40KFUITOlXwkKyeYOqmjFvvv70qP+K0rQoSQhAsRmskP3jqpK1AecO9Zsi6CjtCOSfwkKiG77ePTeGTnMOCMeGlgHvCpSY/ceCnn1xwJ/CQqKvwkJ60JSJP4LqEUzzwlq6HVPCQq7FZJgoMQgpJ77+9afCdlIgvCgJCAAoYQhbgppvwn5W0SDvCpfCRsbPwnoCAY3FFCi5CLHzhiZRn8JGcqyLhqILRqPCQqYPgqZElXfCQsrDIuuCylU/wn6CJ4KaPPSc9CiRCIj3RqOGnlWbvv71BUuGPvFzgsrnigbDIuiciK3l6fvCeoK4KPkI8TVJh4K6e8J+CrCROZvCQrprvv73hsKVB6qC34Ki8Lzp04KGI8JCgt/CQrpngqLzgu4snOuGPimcq4b2dCiNCITzvuYrwmr+78JCgiCQn8JCegOKRh17igbrit5FW8J6BnQo4Qjbhp6oqO+CouTxkYOCunPCQrLMn8J66pvCbgYjgsIc68JC6sFVgazQ9L/CQrZXwn5W0JfCeupYKQUI/WfCehYHhjo7wn5W08J+VtHRy77+96qKOIiXRqGDwkJa44bydfeC1j2DwkK2B4LeeYMKwaTpu8J+VtOGklCovChhCFkrwn5W0YCJ08JCSqPCQgrnwnZWB0agKO0I5dic6PMi68JCgt2fIumYi8J+VtPCWpLPhvZsn4Y288JG1sPCfr7gke+GktHvgr4Hwm7Kfdi/wn4mkCidCJfCQgK4/4LK2cfCfgbRZfO+uqjrvv70mZuOGsOCugl1iXMKlKjoKPUI78J+VtEtpLiUl4LeKIlzhrZ1ePfCQlpFo4LaMYPCWqqfwn56nPz/wlr6XOuGpu/CRtaU9eyrCuPCcvpcKD0INKi3wkKyqfOqtlzUnZwo/Qj3vv70kUC/gq5AmXOC3suCrhSrwkaefwqVoOvCRjZdi4YmY8J66p/CRsZDhg7M88J2LpHslMi3hi4DwkaCtCjtCOfCQoK7wkbG5ZvCWq4Z78J2UrSfitK0uX9GobNGo8JG2luCovPCRoIx2w6siRz/vv73wnYSG8J6xuQodQhvqlZ0iPOCtlzxEaMOGUlx70agiWsKle1bRqC4KE0IR8J2VgGBc4KiB0ajgt6Y8ICUKO0I58J64tDpn77i18J2XpXLwkZiN6qK98JCqg3dzyLrwlqupw5Em4Lecw586ceCrsDwiLu+/vWMuwqU9Cj8KBG5hbWUSN0I1YPCQo6sjQfCeuINK8J2EhMi6JvCdlbPvv73gqopw4KefRXtMNS46PfCflbTwkKiS4Z2gPS8KDwoJbmFtZXNwYWNlEgIIBArPF7oByxcKzhYKB2NvbHVtbnMSwhayAb4WCjFCLzs98JCWt/CdjZHwnZWGPCYk8J+JocKlyLpZ8JCUlsi6aCRhaC/CpXHwn5+w44SJCjhCNmBvTjlcOu+sqS8l4K2d8J2SsCJqYE/wlr2cJz3CpcO8dfCRpqfvv71pLuqfk3Iv8J+VtDxCWQoIQgbwnrmOJ3sKF0IV8JCygSUuJyLwkKSMV+GnqnXgt4YkCjJCMDgk8JCNqkkv77+90agqKiQ/XvCTkYbwkKuUK/CRpJY8Lu+/ve+/vWzwkJaZ8J+VtAo3QjUi4aGk8JuygCFBSPCWqaXwkaS4KuGMiuCssCHwkZGhSfCfg61cOjwqWilGwqlgUlwk77+oJQo5QjciLmk64KmROfCfh7RDbi/hoJF1JlrIuvCQgKVgP2Un8J+glPCflbQk77me8J+VtPCRmqTwmr+9CgJCAAo2QjTDgOCxjfCQnYnDnDhyKj098JG0usK277+98J+hreChimbwn4CoesKnyLrwnYeDKiTwn6GXChBCDk9gbOCni2A5YCjhpI8lCjFCLy7wlquy8J65vkHgrKTwn5W0XOCuiuCvkMi6N+GDjeK1sPCeuZnwn4K+8JGWqSc6Cg5CDFxbTPCRsYPvv5pxVgoRQg/vv73wkLqr4LWH8J+JkXAKQUI/8JCOt23wkZyi4LueXSbwkJS4cmA/w4/wkI2hwqUuMCQq762D8JG0gHvhn7ZJ8J+IkXvwmr+9XPCflbTHtScqCgpCCO+slGrwkI2aChFCD/CQvI7vrL7CpTzhgYDOuAo3QjUzPHR7w4Ql77+cbVzvv708JTbRqOCxg/CRsbQ/8J2SuNaOJvCflbTCpfCWrZ3wm4Wl8JCohQoMQgoibPCei6zwnZOACgtCCdGoJ++qkCJ7IAoFQgPvv70KDEIK77+94Kec8JuyngoGQgTgu4pICgdCBS81XC8wCidCJTotXNmeVci64LOKceC0jzdaYVbwnZK28JizkldLcjbCpfCQtJcKOkI44oSt8JGNi2Zhe+GJoEbgvb3wnaK6JTMnPeqnpvCrnr3CpXzgroLCpeqshjrwnrm58JuynfCQsK4KBEICJy4KM0Ix8JGMkCLij4Ng8JG1pfCWvZg8w7hFYPCen7UibSXqo5fDrlw6NfCRtqbhoJLwn5W0PAooQiYsPXtZTy8q8Jq/sfCRloU/8JC6sS5SOk3CpSThpp7vv7054YqKJgoDQgE5ChVCE/Cav71c4LyCRMi6IDrDsDU8w70KEUIP8J64ufCQkopaJ/CflbRICjFCLz0kaTRl4LGAPOCojyQ9OjzCpSdcLl8q8JCggiHvv714d3Dwn4K677+9aGNP6pmZChxCGvCQqJJg1bgvauCshuGqgOCshj9Bw7fwkIyuCi1CK/CflbTwkIyd8J65kj/gp4hcw5/wkKqCJ8i60ahZLj/CpW5aP/CQoZkmYGoKJ0Il8Jasgljvs5Yge+CrvmDhjbfwn52IXO+/vfCflbTwnrqu8J+gogo0QjJCQOCupF9B8JGnm/CWuYVFJuGzl/Cfmrsu44iO8JCgvPCbsL0kOGdh0ahAPSfwn5W0ewoVQhPgtJbDgsKlLD3gsqxaVjrwsY+3Ci5CLC7CpXnvrIM977+9Ki7wkauwyLrgsrbgr7Lwnri10agk8JGHlyI/OvCdvIg8Ci9CLeK3iSc98JC8peCru/CRsJN04KyDLiXwn5W0Pzlw8JGAlHdW2JY/4LGIPO+/vQoGQgTwkKCICiBCHjU4wrU6TPCRsbB1aeC+sj19XFJLPVzhn4cm77yaKAotQitYU8Om8J65pPCeo5E6PDwvwqU9WiY88Ja+hTbwkKmoIilR8JCosEVe5L64CglCB045P/CRsrIKFUITNuGMlci6PMK56pug8J65nS4kPAo2QjRgPEtXJD9j44C4P+GdsiYk8J65ny/CpSfita/RqFbDuvCQqZU877+TLvCRsbVwIiIu4Z+nChdCFWThqqEqYGBdUzwp8JCWnvCRiqlkPAo2QjTwkLyCbGDwkKOqYCZiwr/hiYvig6V8PHRMw5Fk8JGRlCQxdPCdg5RCJz1IUy/gqIol0ahQCglCB/CRgovgqoMKIEIe4ruZYCYiLuCquDQk4LOHUiXCpT/wkKSpwqXwkaScCgVCAy4iPwokQiI9IuqcuybgqLg6V1w8Qj89yLpUyLou0ahZ6pO7PcOA0ahCCiZCJPCeuLki77aw269xJuqSkXcl6qWFw6wvYEXgt4o64KmcXEQiJgoGQgQ1JnRcCitCKfCdnKThib8i4aST8J2Fre+/vcKjYOGPlnDIuvCeuKQ/XS7vv7094q6KChFCD+CsufCfr7NvOipF4oGwJApIQkZpQ1nRqPCdlIk+8JCunG/hiaXwkLqwcu+/vSLgq6LgqK0s4rqO44WW8JG0ui/wkKSl77+9yLrgs4fDgsOUPPCfnIQiw6E/CgJCAAoyQjDgs6MuJyI98JCVunfwkYqFIkHigLjwnYy94b2dPDo/8Juygjgu8J+VtGc9PPCbhacKBkIE8Ja5jgoKQgjwkKGP8JGMhwoJQgfgq6DwkYqICgZCBPCWv7EKB0IFIS46e18KPEI68J+fsPCegIMlUfCfoqd74KiqZCR58JGKgm3wnYegXF848K+jvuCmqvCWqb3grr7gtoNl8JGkieCzogoCQgAKJUIj4Z2ow6nwnZK78J+VtDsuLjol8JGKqcO20ahqbeGkiThYQj4KAkIACjRCMiDgrZxXw6Uv8JG2i2DwkYO177+9wqVXPWBCReC3rDsm8JCLrPCen6vwn5W0M+K1r9iuCi5CLPCRpIbwn5W04KizLuqgiVknyLrwnZSpP/CRvrB7TCLvv73wkaS9ey3vrYFLChdCFfCeuY7hiZg9Im48euCts0d7wqU9MgouQiwmIsi6L1XgraJ7ZC/hi6HwnqWeKsi68JG0uiLgs7HwkbCV4LaCeyVc4KGedQoCQgAKHUIbIuC6vUnqppgvavCQpLYqPfCQvJDgrrIqOsK7ChRCEkIsQmrwkaWBU2zIukZBPStJXAojQiHiu5dr77+9MFo9ZuCouSvIumR3c1rwkZed4YmNOvCdk4MKFkIUXPCQlrPis7xH4ZuiSDzDsCfhv5sKDUIL4Yq6SeCxruKCmiUKAkIACgVCA8KlRQofQh1d4Keu4b+sOjU877+98J2qne+/vSLhv73vv7zCpQogQh7gsZY/8JC/iGAq8JCyjyZg4KecL1xe4pCZeVzCrj8KF0IVWVJge/CRtbdE3bgvPUZg4b2b4LS0ChFCD3ku4bOCfNaPwqV7ezg7RQo5QjdoTsKlUPCRiog9PzfCr/CforF1OuC3kPCeuYvhoIwq4KeMYjDhs6zgrpx88JuFlfCRtIjwnZWKCjBCLtGo4Ki8J1/wnZ+68J6kquC2tuGks++/vcOK4Y+94K6p8JC6sPCeuZvDnEZvUU0KF0IVJ/CQnoAl4LK/4ra5QUvwnpOgP9GoChJCEEnwn5W08J+VtHvwnYCFYDwKNEIywq7wkoyi772pLuCpke+/vfCQmI3gvoNs8JGyk0Pwn5W04Kiz4LKaL1ktw5jqqJDejSoKJ0IlKmZ1dznwkKCMPSVxJvCQlphj0ahJR1dWU/CfiaTwkKuw8K2TsgouQizDpWBt77+9Pzpg8JCkjtGo4Yq0Py7CuPCWq4Ek4LeKccKlYEnwnoCkYHxYKgoOQgzwnoCkI9S7YPCflbQKQEI+VeKCk82+77ePJeG9kC/gvazqkpfvqoQqwqV34oCd8J6Lvzo+Ly3CpfCRiqkiYzLhnbNcRvCQrpsje1zhlqcKHkIcP10zPfCRhYZ1fsKl4r+w0ag9w77DnG7wnZmJXAo3CgRuYW1lEi9CLXPwn5W0wqVq4KmH4aqUOvCRpLjstavRqMKlOyTDgjrhm4EqJ+CyjlYk8J6Lvwo/CgluYW1lc3BhY2USMkIwPC7wkJazJ8KlNiYkYC9p8JGXiWY5KnzqrZEkfeC3mWpgWuqsoXs3cD/wkLqtx4EnCrIbugGuGwq7GgoHY29sdW1ucxKvGrIBqxoKMUIvR/CRiqPvv706cvCQo6vCpTQuIsKpXOCzi/Ceub480ajwn5upOWwg8J28gSbCpUEKFkIU4reePHVg4LKPOjgo4L6+K8OHYGAKCEIGKjvwkK2HCkBCPiXRqC/wnoWE4oCGL0tqVGDwkKeYOntF8J6Cj/Cdma/RqCXRqC8k0ahc8JGLtifwkaqNaeOGgD3guoQ64aW0CipCKPCQhKHwnaOE8Ji0gEZEwrc/IeK0ge+/vTrwm7G78JaphH5w8JGDsjoKMEIu8JGxnfCflbR7OS4iQy5oKvCeuZfhuZonLiQmdz3wkKi/L2068J+VtHYoJCE6UAooQiYqPfCQrq/Iui8i4oGNYOCvjXfwkb6wP3xpJ/CflbTwkaWVN9aPMQo0QjIhJ/CQi65aIuC6h2vwnYWhWzzhg4cn8JC8i+KBvT/gprI38J6fu09SdHskIvCQgLBJPQofQh3wn5W08JC0tvCQqIXwnZWPIlw5PFw6WPCRtIlJUgoTQhHwn5+k8JG0vXs8Lu+/huGorgoDQgFmCiJCIOC9qeCtjeOIh3vgs4xudvCflbTitoXgtrrhqpJQ4K6aCipCKGpMIXrwnrie8JCUjXlWcD9O8JuFpvCQrqk34rStKsKlOe+/vUHgp5cKMEIuPSdoQ+KCji4z8JCOuOK/umxgMTxQ8JGpvS1Y4K2d8J+ggnfCpXhlLtefYCE8YgoVQhMuwqXwn6Kj8JCskSo8wqXwlr6aCgJCAAo0QjLwnYuL0ajwlrqMPi1uXCTqo7PhrbDwn5W0PVJsJys14aaz77+a8K+nksSXVGjwkZ2AKgo9QjvRqPCeuoPwnZmw8J2Eve2ZgfCQqIYvyLp74KmH8J+shvCflbTwkLS4ZT0qQDwp8JGcuD3wkbGe8JCsiwoVQhNeMfCeuZ9R4KycJiDwnZyFyLpQCjhCNsi64LeuYfCRhYVgLyXtkL1xYzrRqPCQgYbDuy7CpSImPuK3ilttKT3gprLwkKiV4K618JGMuQopQic6PC5BLVrwkZmYKvCflbTwn6m3YGpC8J+buPCfgrgn8J+VtCTCpToKLkIs8J65iSfwkYycOlxb4KefXPCeuZQ90ajCuuC7niJcJW3wnoCq8J6fq/CflbQKAkIACjpCOCrwkKS/8J+FufCRpZTwnrqmXG/Iumkq8J+vuVY5yLoiMyoqQPCdvIUm6qyGKj9PSHF3ezp74p6bCjBCLidRJTdxJ07grpLhvZnwr6KFIuCoguG+rvCQqJ4977+9OiLgtJDRqHvwkbWDJScKFEIS4aiI8J65kvCflbQ84KqQfsi6CjNCMV7hvKVSwr/hj7jvvYouWu+tgTzwkaSS8JCipyI/XPCRq6154b+B8JC6hCo2J+C/kTYKNEIy4KmMVOquoOGwrC898JGFsC7wkbundyjCpeCtl/CWqpRHw43wnrmX4L+ayLp74LqlPCYKLEIqYfCeuZJaVDjgq4w8L++/vUjigbElZFzDiz86fTlv8Ja/ojAlwrnwkIqKCg5CDGDcozpXfHPwrbCUNgpDQkHwkIGbLsi68KyftPCRg4LitKfinqUq4KaQPzYuIDDCpXXgqIFD8J64gfCfiaBi4YqcJci6KvCQo7QqUGYuVO+/ggoUQhLwm4WVJc6MZyRwyLrwnrqyPz0KQUI/8J+tq+qrpvCek6LjhYM/4r+6yLpDYfCflbTwnY2NPyXIunc8Zmfvv73CpfCQgJhXRyZ977mq8J+VtCbgtakiCjhCNl5FWeCwjsi60ajwmLSH4Z+Ybi4v4LWsZPCQjKDit5ptbko6IuC2kuqcliUib+GdsuKDmC17PwovQi064LWs4KmeJyfDseGlhC0u4auHduC3lvCWqZrgrIdPWzTRqMO7PVjwkYS5cCIKM0IxW/CQubnisJXIusKl4aWA4KuN7Z69J0Pgu53gsrzwmr+74Lae4Ymu8J6LgWg8wqXRqAoTQhHDncKn4b2bd++/vVLvv71NfAo5Qjfwn5W0Klwle3zIunvwkIaUKTvIujXiuYvwkaS36qaz4Y688JetsfCQq6sm4KayJ/CRp6DihIBgCgtCCeCpmcOSLuChqgoNQgvvv73wnZ6/e9aPewofQh3RqOCuv2M88JCTsnTqkpJ74KuhIjpbPXQnJj8uawo8QjrwkIKUL2QqaWBgyLov8J+VtHkkUvCei7TCpVHwkbyI8J66gCbgrKzRqOCoj3tV4K6TJvCRpLfwnp+pCjlCN/CQi6tCWXhx17Mh4ZSxZ/CQnKtcPC/hvZnita8lMCrvuZvwn6+44K2IKNGoP+GyveGcomFMXnsKBEICezMKF0IV8Jy8tlgnIno8w6bwn5W06qWPc3M6CiNCIWkk4LmWJ/CQqLBlJfCRtL0vLnvhp7V1XPCYtIDCpStaSQoeQhxYJWAqVeGJki5j8JGTlcOG3L95ccOjKiVi4aKHCjFCL2BgXeCnnSRLVSTDq/CflbRiwqVAP3vgqoI/77+96qW0IPCQnoTCqlzCpSJ7ad+MCi1CK/CQobHwkYqaWSXwn6+ycfCRsYMoJUdD77+UPiIl8J6AgTA/XFxdJfCQp4UKPEI64aio4ra64K6fRXTIumrIuiXhvLPhsaBZ6qmT4ay34b2Z77+9w44l4b6basOP6qmU8JCoouGglztHJgoGQgThsqI9CjRCMsO2Wl7qq61bwqXwnrKT4LKOLyYs4K2dL/Cdjaxe4KmC6qC2PfCeuZvwkZGKa1wwwqUiCkVCQy/gtZUkyLrhvZTvv70lanfwnrinWfCeuI7vuZU94YyqQeqUr3bvv73CpeGMlSIz8JGyjPCfq5Litq3gv5bwkbKdLiQKB0IFIkPgqqIKCUIH8J66p8K2LAohQh8v77+9IfCQvZhtP+C2gvCfgYdmPT8l8JGNjWrwkaSJCg1CC/OghJbwkL6C4KOSCitCKWwlSTQlyLphIvCflbQv4LuKXOCwpD3wkbKvSu+/vfCfqoAlTDcmLz0iCgtCCV7wkbGU4oCJNwocQhpBKuK1r0Ey86CFoyIk4aa/8JGNiOGiqiRJJwonQiUqOvCegJzgsYfho4fCpT7hs4DwkZmZ8JGSieG/j/Cbg67hsIUvChJCEDEk8JGBni9LJOGmpvCvpbAKL0ItMDzwm4ur4Y6Ee+qtuvCQv7ND8JCPkSUmVvCRl4vhrJHwlqmjKuC6pW5EPSIiCj9CPeCsguCznfCfg6RZIuGski/wm4WVw5Bg8JC5vO+/vSrwn5W08JGZlmRT4K6D8JCkv/CbsZlAMvCRm4bgp6AKKkIoXD9YYj8/IvCflbQm8JGcoWzgs53wn6uP8JGlmXljJSrwn5W0PSRILwopQidcQOCxleCqs8On8JG0gSsm8JCzmvCQnY7grppc4aCEJ+Guoz3gp4cKE0IR8Jq/uTzDpExgJ/Cen6ZqJ3oKG0IZNTs/beCunsOP8JCgiCQ8Oi/wsYSb8JG8iwo2QjTvrqrvrLrwn4ipIvCQrJDhs4U94b+zUVwkwqUl8J+iq/CdkakuZk7wnoWHJGV80ajwn5W0ChZCFFw88J+vtu+/vfCei4LwkYa84LGHChZCFFwr4K6D8J2amnBcdDlcyLo44a6RCjNCMXtAyLrwnoS0YOC7nSrhipThnaPhv43wnZyeIOGcpC4n0agkL+uyjfCQjL3DqfCRmawKN0I14KmM4LGMS1wvTuGjnMKlICYl8J+ujX3IuvCdjaBaOkXRqFou8JGIi/CQtLXwkKi5XOGnrWcKPUI7YOCxoinwkb+tJ++/veC3mi/hi4Pwlq2T7JKeTeC7nPCQnYRcwqVq8JCOvPCeuaI8XXLhnaDwn5W0XC4KDkIMPSJ34LG+Y3vwnqWeCgxCCvCvo7RgJOGeliUKKEIm4KmI4rSFw6Mn77+9JTjwkKiF8K6oqO+/vXJu4LC5Ly4/KfCflbQKJUIj8J2IuCoi0ajwn5+wJF7CpT/DitiWJdyqYOGLhETIuvCflbQKB0IF8J+VtEsKPEI68JGKiirwn5+wX3Iv2IvwkYeIYCTDle+/vS8k8J6BpWDRqCbwnY2myLrRqO+/vSPhq43hjoFf4LC8ewo4QjYj4bypN8O/PC80JDjwkJOH8JC5vHYvJ+C3lmDwm4WS8JCgpPCQkKnhvIwvL+GnmTvwkJaXYCQKLkIscibRqO+/k8OiP2E/bTzIuvCRjYvgvYsl77+9Im/hiYvwkaSzX/CQi7DCpT4KQEI+8J2UoX48PPCQo7A6PD8/8JCAqlw8e/CdlYrwlq2dTOGqlUxY77qt7IKwW3peJvCbsobwkbWoyLpgI+Czlj0KDkIM8JCes/CQnoPhs5JHCktCSSfCpXVXR+CgsO+/vSpW8JGMrErgupTitbDvrLziuYzwn5W077ad8JCAgC/gtYcvJn1X77+94K6O8J6fqvCQoIjIusK+4YuAw4EKFEISQ/CflbQmdMi6Z+GDjSh8J3FOCghCBiTCpVx1RAoTQhHwnoqoPmHCqDdx8JORhnkkZQo8CgRuYW1lEjRCMjHguIXhvLbwkYC5KvCesqbRqPCdkqrwnaqc6qyUYPCRi7jgtYZjLmQk4LOr8J+VtC42CjAKCW5hbWVzcGFjZRIjQiFm4b2ZUC8/JPCflbRoKi7CpTp74KqvP/Cfgo4nJFoicSsKhAu6AYALCosKCgdjb2x1bW5zEv8JsgH7CQo8QjojYS0y8JGlkFXwkaWA4K2IJXvwkbS8wqXUukQu4Luc44W+M0PwkLKPb0onIu+/ve+tgVjqqp7wnqSQCiZCJEZcXCbwn5W0yLrwkbSCeeGKnOC0gFzIujPCpfCflbQ4ZihCOAoRQg/wn66F8JC+tO+/veCvhicKJUIjXNGo8JG/qfCflbQnPXzgqZzgu5880ajhs6468JaqifCQv7YKNEIyJOChofCRgpdG6p+YyLp5XCXwkZC6XPCQuo9OSXZHKvCWrbQqXCUqPPCQlpTgsq88MXkKQEI+OSTwnLy6JjPwnbyoyLrvubRB4LSiXyF28JKUs9GoyLo8OvCeuKFdLng+6q2xbu+/vUDDkTzhi4DjhoTvv70KG0IZ77+T77+98JCKpOKWuD/wnaqtXyRnNSXIugoSQhB4SXfgroInNmHgrprhvbU/CihCJjHdsDrihY578J+rs0ngt5rvrJY2w48q4KqqJDrCoDAmTSTwnqSSCi5CLO+/vSoi6qC2Z++/vfCepZ4n8J+JiCXgrr7wn5W076qRXCg84YqKe86GZEdzCjJCMCpmb8ORPyxyNCvgsq/qrI0n4bGkZvCQlrgiw57CpfCdvJxk4K2g4L6v4aitKuGmtAoPQg3hg4fIuvCWranvrLtDCgpCCCLCtC/qqZknCjJCMOG9mzrgsI4kdiU8ffOghq1fYF7wnrmUYmdyPDx88JCklvCQsq48PD84T/CxsqRUMAoGQgRLOmZJCidCJXrCpVwu8JGMiFxcOVzwkr6l8JCojEsoYD9i4LWH4KmALyfqoKEKEkIQ4a6R8J+HplV7OvCRpLjRqAolQiM/T+OFkn1XafCRjYwm4Kec4LeKJ/CflbTgsL3DmeCvkO+/vQomQiTgtp/hirA8Ji9cOiQkJW0lcltcNTZBMi4n8K+jitGoJvCflbQKPkI8JeG1lOChnvCrn6Ns0ajqqYMi8JCTuvCRv4gv8J2Vi1El5Ju0wqXwnqOW8JC/g/CfqanRqOCyjvCQgJUyCjNCMeGek0Q/8J64guCzhtGow5jwkauiJ/CflbThnaJx8J2UljzwkbyD8J+cqOquok86JH4KEEIO8JCdh8KlXkYl0ag6JUYKFEIS4b+YYj4n8J60n1w9PVzigqInCjNCMTTwkYiGe34u77miY/CRtpRC8J6AlPCRjYg0YPCbhaXgprLwnZSPNvCQqJfgrZ3grKYKLEIqwqUscifhuKZP4KeA8J64rOGqg/CRharwkaOLceGHgvCQlpXIuiXwlq2gCgNCAWgKGEIWPyAl8JCgt308fD8k76yqTDrirblUTgo4QjbwkJ6E4KiP8JCUmyRByLrwnoKP4K6c4K+QyLp7LnVc8JCWlfCfiLjgtrYlTlJrIvCWv7EvbGcKOUI3w5N98J65h/CeuIBM8JGMtvCRjZ/DvUrhjonDtU7hoYrgta/wn6CEXHomZEzCpSE88J2gk++/vQohQh/qoLUuOldOUT0q8J2Uu2s88JCgoyfjhJI/LvCQsYQqCixCKu+/ve+/vcKlXuqgpSp7KvCRjYzwn6uB8JG0iPCWra5Xw5Fb8J+isNGoNgpHQkXwkaS3L+CtliDDmSck8JGZk+K0reGkpE9s8J2FlfCrn7MvOdGo8KaZtO+/vfCdgZ4uPfCbhaTwkYywKuC+rfCfq7A9ZyQKD0INb2xcOUs78J28peC6ggozCgRuYW1lEitCKeGngGbvrYPwkISz8JCKlS7wkKypJyF1KsOD4LC58J+VtEngprJG6pKsCjsKCW5hbWVzcGFjZRIuQiw98JCUt/CQjoNc8JGMgi/wkK6GwrzwkpGyKn7wm7KeJOK8sy5KwrhgOuOAmAq7DboBtw0K0gwKB2NvbHVtbnMSxgyyAcIMCjlCN/CWqoPvv73vpafIuuGeujwnL1Q9Ve+/vS8y8JGFoD1zLysqyLrgq5DqpYRE8Jy8vuGhnvCdgbkKPkI8J+CoreCgvci64KyhW8Km8JGkrWBNLyIu8J2Ss/CQlp8125/hnafwkLOgOUYj4KG64b2bXDrqpL/itqtgChdCFeKDkyQxSi7RqDzwkYeO4YuA8JGykgoJQgfvv73wnYOqCgNCAScKJUIjwqV+NcKl4Kqt4K2h6qCqZPCQpL/gpotBJOCmkFzwkYOceywKKUIn0ag9SjvgrpTwnqWYYPCeuJjil5MmMz8u8J+VtOqsrCTqrrc94K6eCjhCNiUmS+CxpiIpQu+4piVV0ajwkpGyV2AiZfCdkp8n77ePw60q4KqDJOCrqCLgqJk98JCSsmInUgomQiTwkIag77+98JGNl8OhXCjqrIl7alvguojwnrqa4rajyLplYjIKHUIbKHbgp5xPecOx44SRaGbwkJaN4Kmbe09cJSQiCgJCAApAQj4/8J+VtPCQqJdcRybgtY7wkK2E8J65j/CdkqxC8K+ogiXwn5W08JCsmTxG4rWvJHDgrZbigpHvuas+wqrDqwolQiPwnrmbJj8nXuG8tULwn5W08J65lCYwJPCflbRlJm/wnrmPYAoRQg9geCYw0ahG4LeKw5nqpbcKPkI8yLo98J+qgGDgr4cixZTwkIC8Z/CWuZbwn5W0JPCdk4Pitrk4Ly7CpfCQjYDRqCnqmpthwqU8SPCflbQ8CgxCCmjvv70u8JasvEEKA0IBJAofQh09yLrwkKi1JyzwkIWh77+9Yygk8JG8lyVfyLpCSAoUQhLIujw/JHV7MMO4yLpc4b2pyLoKNUIzYiUiyLrqp5Enw4PwkaeI0ahc8J65h+K3nOCqs8OqLj3wn5W08LKInPCQoLwmPWLvqpEoCg9CDXvwn6CA8Jy8rHkk0agKQUI/76yfwqXRqPCQhpTqrKEo4bOB4LuA4ZKJM/Cego/wkr+yXPCeuKfRqO+/vT3wqqyT4KmN4K6+77+sKvCdlI5YCg1CC+Gop+GLg/CRu65ZCjZCNOCxlnLDkD3wkY2N8JCpgCXwnrinKjtx4KahJ/CQhbFgwqXvt4/wnqWGWCTwkbCc4LaGJDQKLkIs8Jy8hS5gOuK1r/CdjbIvJ8OR8J+VtFzwkYyoJu+/vVwycPCWq4Lvuavvv70KAkIACkBCPvCRpJUl8JGag/CQo7XvrKrgoZkgPOC6glXqqZbvrILwkYiH8J67sVxg4byi8J2Vjj8le/CeuII2Mci64KmRCjRCMtGoYPCav7ttOnInwqXwkKCId0Dvv73grZVy8JGxmEXitr0uLPCflbRd4aGGXDngvoBDCidCJeqpjHs6RD89WfCdkrHCoeK2u+C1tSsi8J+JgvCQlqbIumvgtIoKI0Ih4LKF77iSWfCdhq7wnrmRLzxgJu+5s/Cdk4Lwn5W04oeXCi1CK1RG8JGMhz/hi4BeTSLgqpHgs5bwkLqrIeGJjC7qp7HCtPCfq6fwnrqGIXgKAkIACjtCOSTwkJ2PQiJ0LyU14K2d8JGrqMi66qeTXHLwkZuAwqXwlqul8J+VtEDit5g6w7/wnoqf8J6kiCdaKgonQiXitqxeJ1PhpbRuPSZ6IvCflbTiurY/8J+DhzDwn6qB8J6ElFxMCidCJfCQoojvv71L4LmM1YwmOuGljPCeub7wkIupPeGer++slSvhoIgKJ0IlKiU9KuCpiOC/kVtk77+977+94aC2WmLwnrmo8J65m2AkIkc8JQoJQgfgoZ5gPTEqCidCJeCmsuqapPCehY884KuA44S+PfCQm63DgfCQi4zvqaAl8JCHuHsKI0IhQV0yJmbwkY2QPy/gv4lm0ajwkZyx77+94KyP6q2AZEE/ChNCES/wkJWw4KiY8KuepeC1jyYuCjVCM+C/kmDwkZmZXPCRsq/CpfCdkqU6IvCRnKbDhPCego8qaNy0wqV3OnYmPGY8QNGow5cqMQoqQig68JGkiWDqp5km4Lqlw4zguqU4aOGgi+G9nXknO/CWvbwuKCXwn5W0CjdCNTBwIjzwkaC58J65nWxPKsi6ae+/vcKlPyPwnaW54LGv4Kqy8JapiO+/vS/wkaSJ44GI77+9CkkKBG5hbWUSQUI/ez978JGNqeCrue+/vfCYtITwkaSoJici4LmQ8JCEnDXimLfhg4fvv73Dv1w7QOCwjzxe8JCrjPCeuLLwkI6dChUKCW5hbWVzcGFjZRIIQgbCpSU9J2QKqQ66AaUOCu4NCgdjb2x1bW5zEuINsgHeDQoeQhzwkbGU8JGDslc6Ly7wnZSNOOGds2Y6JS8/4aCLCghCBvCen6ElewohQh/CpXHvv70x8JGbhlg9KCfwlq2kImokPOG/tvCforE4ChhCFnLRqNGoYPCWrLlJYizDvvCRmJfCpSQKJkIk8Kufo312WDx5YPCRpLjwkKS/MPCRjIh7bGQ8PWEl8J6Ekj0mCjFCL+GqluC2pkjRqFnwnZSNfMKlMt2QUfCeuIM54YauJCXwkYqIKfCflbTitLnwnZWCCiJCIPCQlrF1QyYhOkt7JVxNw78iIuGMlCcmY8i64aqAOi97ChNCETsw8J+VtHrvv64qc3kvw6Q6CipCKPCQvYIh8JCiqvCfoocqZVgq0ajwm4WVwqVTKuGGmT/wlqmmw7fvrbgKI0IhYO+/vSVrLlQkKuKCmOCnhzAvM+CzlmZX8J+rjkPvrII/CidCJW0/b/CRgYsvOsi60ago8J2UpXZcZC8/bVzIuiYibCXRqPCfn7AKFEIS8JGoteCpnD3wkYGzP/CQs6xICjJCMCpca1x5dvCRipTqkqdcJMOy8J+Cpci68JGIhzNjSifwnrmRJT9f0ajIulvwnrmbLAoaQhgpJcOSKDwn4LWGwrTgrZbwn5W08J66oScKHEIa0ajCpeK3lj9X8JCwmjM+K1/gpJV8SmNUPFAKQEI+Q/CRgadDNFDwkIaQOyjCpXQ/8Juwpjpy8JarsfCQqIVV4Kiy8J2Uo+G+qiol4aqE8JigstGo4LKP8JGMszMKCEIGWuC7k8i6ChFCDyrIunPvt4886qyl4LeKQQoSQhBD8JCBiCfwn6GSSj3vv70kCgtCCeChiyU66qmVXAoMQgpzYvCeuaFx4KSsCkFCP8i6JC/igqTwkKyIOvCRjLI9YvCQlrNa4aGaYDxSUSXguprgrY04V+GdsHLwkbWUV0lg4LOMJvCRiqc68JCnhAoVQhMvJj88JPCQvIjwkKC4Ju2etci6CjBCLjxxcdGoKvCfooIr77+91rouIjjOiMKl8J+VtDrwn5W08J+foO+soNGobPCflbQKD0INOULgqajCpeCun2p9IgoEQgJ5Jgo6QjgkU/CRjYwqWOCpq3Dgq43qn5DqrKxOw6NH8J6Ao+qpjEfwkaSS4rqoej/CpfCQuq084K6D4q+mLgoCQgAKKkIoRfCdkLjDuNGo4LqlJsi6Y+C2hS/gtrAuLWDhnIzwn4Oe8J65lGrIugotQisl8J2Spi7vv73wnZuNSMOn8JGFs2Dgobngq4094KyCIuC+ifCQsYc6RMKlCg1CC+CgtvCflbThrK4nChNCET9oPeCukvCflbTwn5W04rS3CiRCIu+ulD8kYeCsj/CRh69k4Y261og5O++/ksi6JS/gr5ArPGUKP0I98J+VtPCdkqJy8JGElCrNojFV8J2QkCTwnYiRS+GLgiUuSUVIXEfiroEk8J2Tu1Hvv6bwkK2ZeyYlOuCvggojQiHgvownTCkqOnlaJXPwkKGA4KGoey7wkKmG8J+imPCQrIoKOUI3SMOfYEUl8J6Fjz0i0ag/8JG1gy/jhKUyPFbvsa098J6fvtGo8JGIgzjwn5W0JWAne1w08JC6rQpAQj4x4K2L8JGZofCWvIXIukt28JCAgOqkuuG/uOK6jmDwkKm8YMO38J+VtOCnjvCflbRo8J6ApPCflbTgso8mMgo3QjUq8J2Uh8i6L+C/iTIm8J65lCY/KsOV6qylJz3qr7RA8KGlqkHwkJuZ4LyYJsKo76iAe3ZcSQoKQgjCpT3wnouragoEQgJYOAorQinwlJeW8Ja/o8OyTVM68J6FiDDvv73CpcKmIeC1h/Cei67DsuG9iVM9aAoIQgbOivCQoLgKQkJAde+/vSZcKjzwkJ2i4LGdw7HwkaubRfCdkqnwn4iR4oOWJE3wkbyM4ZyuUMi6JfCflbTqr7bgrJvwkL+HTOK7rQo7Qjngr5dPICt8YyTwkKyrLyfwnrik8J+boSXCoeqlsuqsiu+sgz8myLon8JG2keG8sci6MXkvNjxfwqYKTUJL8J+OrvCdi6glfOCopvCRvJs8Lzw/Ilsk8J6AquGtuOqUg/CRjLPwn5W0e1zwn5W08JGHpfCRiJ0mUfCeuYLwkYiEJfCflbTwm4SyCjlCN1Qu4K+Q8J+hlkrvv73wkYyJR3TCvE3Cvizhp5HhqbvIuuCtjF54VsKlJSUiXvCeuYc38J2Spl8KCUIHLkjvrqLCvgokQiIk4bC/UjrhiZHwkKGxeyZFPfCQjpDCpfCRjIAv8JGkj8OmCg9CDW48fmA0XO+/vfCcvYQKG0IZ8JGnjmU8Ij3hs6DiuoNh8J6AgvCYtII4bwoeCgRuYW1lEhZCFEjgroN+2JYl8JGsgSbwn4KiYCptChIKCW5hbWVzcGFjZRIFQgM/OnsK9Q66AfEOCqoOCgdjb2x1bW5zEp4OsgGaDgpEQkLvv73RqOGygvCRpKDwkbWl8J2SqeCvt/CQtLbqqpp8XPCRpqDIuuGPvVwhTe+/vfCbsLDRqMKldyYmXOG/tj/hrJwKM0IxJS7gso7vv73wn5W08JGNkPCdlJs4JeG9mT3CpS5FReGkuuG9mWAmcWTwkLKF8JGMswoWQhTwnrmk77+EJT1rJeGmsipDJGAnXAoUQhIwwr7DpOKLiSc9Pntr4aiXL1wKNEIy8J65ufCdmqEjQvCRp5Qu8J+VtOCrjGDwnriBOfCegJ558J6ToPCQgKpQVPCRi7kvc24KF0IVcCfwnrm7PDkq8JOPuTwzwqbvt49cCgpCCPCRmarwnqWeCjVCM1zgq4sn8JCtql/CpTxWYCYmQTzgraMv4Kux8Ji0huCqi+CqvPCeuYLwnoCpL+qsjeGPuwoqQih0w5Ai8J+VtCQoJj898JCykTzgrobwnZSO4ral4b+Z4YqLbCFbKtaqCgxCCjrwnoqtRGLqrIUKDEIKyLo90ajhnapgYAojQiHgso/Cr/CQrJAnen1LbnvgvqXwkIGd4Le0OSLhj7Pgs7MKEEIOe3vwkbuiY/CRpqfgrqMKL0It4LGd8Jy9nuG9n/CQhILwkKiP4K6cffCRioPgs7E64bGP8JCgsfCQuozhpKRjCg1CC2fvv70/YFPhiaJgCh1CGyfVtPCQvL/gqpDwn6uWPElaePCXh7sv8JaqnAo3QjVc77+p0agr8JGan/Cei57wnriB0agqYPCRsanIusKzwqUl4oKnPPCfgItJe/CRhL3gt5Y8IgoQQg7gt7Mmw7Jg8J28qDpcSAoeQhzwnZK78J+JoC8uK2A98JCtuyV7JyY9Im3wn5W0CiZCJDzqnJnivJ86PSTwlqq9cOqhqtyv8J2SsXvvv73ijJzgt54iNQpAQj4/JvCeurpg8J+Dhe+stOCrrF7vv73hq4A/SVPwkbaX8JGMtfCesrB4yLomdMOzSSXwnrmJJfCRsaYr8J64uQo6Qjgm8JCEgWAlLfCdmpItJsKk4LeKZ+Coti5c8J28qnXgq5DCtlV0P3tN8J2TvsKl4aCCPdGo8JSYvgoGQgQ6c3s/Ci1CK+Gft+qcnfCeuLl4e1AkK/Cfq7LgqaxuWPCRjaIg8J+VtDI877+9LG3DsUYKJUIj4K+X8JC5s/CflbRkJFhhL+GXrD8k8J6Eu+CoueCigkI/XC8KL0It8J+VtOCsgT1u77+aJPCflbTwmr+26qqJPeKCoi/isZxcyLpm4aK68JGcjMi6CgtCCfCWqabDoS8veAolQiNgzoTgu4AmRl3wlquDMntLeO+/vSU8Os6M8J+VtOC7hiY3PwpEQkLguo9HXPCflbQv4KmcwqXRqH7vubEq6qC18J65kfCQupY6aXYk8JG2kPCego9Lw4Twq7mh8JGDslw14L6+4KaGeUYKFUIT8J+Dj+CxhvCQh7HwlJGkJeqotQoWQhQ/JMKlJHrCpiok8J+fsDE2w5AqaQoxQi89dMKlLnrwnri3RiovPCHwn6CB8JCVsOCqjDvDqeqdjcKlN3Z7JyUrJu+/veCrowogQh7gq6hYIvCfqoPDi+CunlHgtYjRqMKl8J2EquqgkyYKNkI0XHZ377+98J+Ctirwm7KeP0whQi7hvabwn5W0wqrgpqwiciXwn4WwYHV4ez7wn4mk17JuPgofQh0i8J+VtDol4KiXw5E7P0Ai77+94Ke6bSHwnoqtJgoKQgjwnrq20ajIugobQhlpaD3wnoS0UyXwkIefM1Ljg6B7LuGgj3ckCg5CDGM9fHtc8JuJpcOiYAoWQhRna/CRsonwmJmW4LK4Sm3wkZyBPwoOQgzwnrmUfEou6qyNwqUKQEI+wqV2KvCflbRi8J+fovCQgIfDu/CRjKLgqLxR8J2LoPCbsoJgaz8uLnQ/8J6ftu+/veGkjuqjpj7vv73gsYAKBEICJWAKCkIIdW9TUy9g2JEKL0ItRSVa4q6p6qKqyLo3XOK0mDx7fOChosKlUSbIukHwkLSxw4/wkaWX4K2H44iJCjdCNSVWKuGKmFXCpWnwkY2QJmk6avCdlJPgqZnwnrmR77+lXGDhvrrgsZZcVeGzsfCRjaPwn4aDCjtCOfCRnIDjgLjgsYfigZ9v76SqRtGoIvCRsp1rJe+/vfCdqq3wmr+zaCYk4razd+qgtfOghL3vv70nUwodQhvhv6zgra/wkYqTZTrhiYrwkaa7Q9Go8J2Wnm4KL0Ite8i6wqV38J+VtC8/6qGI4LOWJUrgprLwkJaVJ/Ceo5Pwn6e3YzNA6qyR4KyLCilCJ0A94ouO8J2Ao+GlgFxd4KiDwqVQdsORyLrwn4K3KvCQgKxq0ahVVwoxQi8iIj06J/CWvazDrj1FXS4w8J+VtPCflbTCpXfwn5W0YPCQpJXgs7I9eVwk8JCgiAoVCgRuYW1lEg1CC/CQrbJpS2om4ri5CisKCW5hbWVzcGFjZRIeQhxA6qi28JGMu++/vVtdJeCzlfCQo7Q9PH0qeDVnCtADugHMAwr8AgoHY29sdW1ucxLwArIB7AIKIEIe8JGMs3tBUj0naE834rOo8JCtuiYiIiR78J2Er2FRCh9CHfCWranDmy4jwqVeJirIuuCqkPCRjIgm77+9wrgkCjBCLiHwkJa7e+Cqkci6M++/he+/vfCeuKI6IiXwkKS/c/CRsLk9czxc8K+nsW3Ds04KOUI38J66tingtYHwn5+nI8KlZHx7Jy49PDo6yLrIuvCfoaZ7JHw7IuCguT3wnYul6qe377+9NnDIugoPQg1HJ/CdvJ3hqqbCrGBACjpCOHo98J2ViuGls2Qqey7vuaQv4LqBesKl8J+VtDAl8J2qnu+5slkrRdGoUULwkZyj8JuyhtGoLS8qCjdCNeGPleC/ksKlQ1zgtZQuJuCntfCflbQ8QMKlLci6c0nhvZN7InNcRiY8KlXgqL7gp5zwkaSWCjRCMj/grYLwnqSuPHRfLjrwlrm0XfCdlL7vu7sg0ahzLuKAvl4qPWLgqI8v77+94LODezswChoKBG5hbWUSEkIQQVzhn6g68JGXmlfRqD8mYAovCgluYW1lc3BhY2USIkIgOeCnnOKxsj7wn56Xw4zvv70v4KuwLitg8JuFkCIvJjwKrxO6AasTCv8SCgdjb2x1bW5zEvMSsgHvEgonQiVHaSInMnsqJWvhir568J+buPCQoLwmIuCxneGMqzNW77+F6pu3ChRCEiXwkbaVPHnRqPCflbRgPOCyswo2QjTDhOqsq/CdkrtDYPCfgY3wkbKE762zQCXwkKmGyLprJGM8Ju+suMi68J+VtCfhm6fwkY2MCiVCI3bwkbKrYCtyVlzIuvCRpZIqJSU/8JC9slxg4a2z8J+CocOQChBCDjPgoaLCsj3wnL6/L3ZgCi1CK/CQipBTYETwkby/LuCyj3t7W/CegKov8K+nilwp4r+wwqXgposuJ/CQo7AKIkIgYEXCpeGMlHHvv702PDLwnrqNItGo8J6Aici6zpXhiZwKOEI24YuAT2wm4KmRwqXwkbaRQlJQRzoi8J64tO+/vVht8J6KpUsiKO2euVwq8J6Fj0oqXD4q4LOzCgJCAApDQkHwlJGXQcK58JGBg/CWuoNv4oOiQfCWo54x4YqLZE9SPSfgs5Z88JGHsDouOk3gq4xcMfCRiqgq8J2VgfCRhLYqUwoRQg8qW+qiuD/wnZWGWuCvi08KMkIw4KeNTeK/uPCWv7Dwnrm777mb4Ki2XMKl4aGoeXnvv709eCRjIsi6OuChslfwkLKgCkRCQvCQgL3wnZS34LeDP8Ore1nwkL61IjnOjsK/4LSJ8J+VtOCnhz/wnruw8JGNl/CQlbHwkYyD8J+qhPCQqYbwn5W0bQo0QjJ48JCggWAues28dSJcJzfwkK6v8JCTnsKlPCRj8JGFhz3vpZQ9Lio58JComeK2quqqhgolQiPwkbaTJeGltOqsiy/RqMOvR2fgs50k8J+imEvIuuC6hmbIugo2QjTIuio1LfCdhIRbPCfwkYeDUkvhv7h54bybKkLvv73DqmDgpYnWjfCRsq7wn6mj8JC/okdcCgRCAlwtCiZCJEg9IuKfreCwjCXwkKusX/CRiIRQe++uhVw68JCVsVPvv73IugoDQgEiCgpCCMOOIOCpkSUlCjpCOPCtqbMkOjzhg4fwpZKNOCLguog9PfCflbRnJGg18JartPCQjrQqJXEu77a2P/CQgYJDRT1z0aguCj9CPVxE4YuZ8JCetPCRjYdrJCvRqOG/gHvwn5W0yrjwkbSf8JuEsu+/vfCQgJLwkYqjXnvdrn7gupzCpfCflbQKE0IRSWDwkJahTOCqrSrhv7d7MSYKF0IVQyrwnZKrPz3wnYuRV07wkKeI4KCdCghCBnsuStGoRwoGQgTikYMqCj1COz/gvr8iP+G9nWkv8JGysPCbspwu8JGIsPCRjIJV4bCXfSRcJu+skyI8w49uaydcIOGLgC7qroHgsIlNCghCBlgl0ah7ZwpKQkjDrcKlfPCUlp/Iulvwn5W0LfCQp5x78J2Cq/CRjaIl8JCEgcKpJ/CflbTwnYWgOsON8JCjpWNg4YmcJFw/e2BD8Juyh/CbhacKN0I1YHPwmJ+l4K6w8JCumlPgsL11PeCuuT3ijIjwkbapQ/CflbQkWiE2bSXwnZS9YeCuqvCRg54KLkIs8JCGnC/CtsKlJOG/nzPgu5XDmPCfiZA8L+CxpzzgqLh0Mz3wkbWnZeCnjEEKN0I18JGkhW3OsybgsaPgq4kmKioue/CRsKlow7oh8JGmpGs88J6ktlzwn5W0KvCflbQ98JOJnUoKHUIb77SuKnsmbvCRu7Zg8J+VtNiLY/Cfg63wkYqICgJCAAoyQjDhvZ3gp53wkZGdKnU9SHUmfvCfiYQ4J+CpkU/wn5W00ajwn5W035vCpfCdkp8/JnsKAkIAChFCDzhwXD/hs7IwLT7wnoWPPgohQh/hs4FnwqVRb8i6wqVo4LS7QvCRhLYlPXsv4LeyaGQ1CkRCQvCRtbp2Y/CflbTjgL/wkYy44oOrTOCmtvCdhInwn5W08JGNjPCfhanwkJa7NMi6w7hs77+94LSqW/CtqJBD4rSnOgoPQg0/VuC7hmIqOu+/vU46CjhCNiBaP/CRios8VeK8m+G9i25xLz3wl5qp0ahOL++/vSQ1OvCQrK9m4Yq08JORjyfvrYThv41yKApCQkB78J+VtEAte/CfiLLvt7PwnYSfJVk3KvCeuaHwnrqhdPCWqo4i4KqCKkwnJ+C0nSXwn5W01LXwkaak8J65mci6CiJCIHtk8J6KqSgv4rSt8J6EquGJtTwgL9Go4b2bYNGody9uCghCBi4kwqLbvwo0QjLwn4OEbHU58Ji0giwiPCIlIuG/iFPhsrTqoYXwnrKlL/CQgLXCtHzhv5gm77+9LuGOigpIQkbwnrmfLjXgqLMqJybwn5W08JG9jfCWoJbwlr2T77+K8JGlgy444LajPSTwnoCn8JGbgeGMp+KCriHwn6uiYj3gu4YnJyIkChFCD/Ceuaftn4V7Jn1OPmB2awpDQkHwkYOn77+9w5HhsJ/grLMxwqslJdGoaj1D4oGUwqXwkbWueeGLgD3gro7hoY9gdvCRm4HguZY4UOCmpU/vv70seQogQh7hrbbwkZaiWsKgLicnY1xM8J2Suy4qXC/guoJdPSQKP0I9LvCWqb0lIiYlVW7wnZGz4YmY4rij8JCBiOGEvd2C8JCEgXdU8J2dlfCdlL3hirljYCLwkYyd8JGDgdejYwoXQhU8fS7wn5W04oGeyLo/aCHwmr+5wqUKGkIY8JORgCZ7XT/wkIu0SiIl4LqE77+90ahpCkRCQsOW8JGMh/CRpqbwkaSl8JGHqDrwn5W04LqR4o+Q4bOu0ajZsPCQqJfwnaql766+4LGAaVgiMPCQjZ7vv6ljPWdESAoNQgskPfCRga8lRj1gRQofQh1vLixlIip7OuCnoPCWv7BpSvCeipE84aCLdcOSOgoUQhIhPOCktuCpjWzCpT/hrJbRqCgKSUJHQ/CQgZxOQy7RqPCRpI3wnrmZ4KqD4Kq/IeC2k/CQlrAx8JGxpHrvv73wnoKPP3dgLeKqtzc96qygXPCRjJDvt4/qrKjgvpEKJkIkMz48PDBPP2BQ4aGs77+9XCfgrIHgv5EuXPCRsrJ3JjTgr7Y6CiJCICZg4Z6FXC4n4KyvWu+4guK4nsO+e2kn8Ji0gC/wnriiCjlCN2YjLiE977+98Ja+lvCfq5NQYirwkbaRduCzqW7wkYKvciYkR+C5jOCxjX3wlr+x4La7PCXgsb0KMEIu4K6eT/CRmZLRqMi6LvCRtoZg8JGLtmDhj7jCtPCQqLgk8K6HiMi6e2jhna4+IgoWCgRuYW1lEg5CDPCQlrxsNFzwlqu1LwoPCgluYW1lc3BhY2USAggECucHugHjBwqWBwoHY29sdW1ucxKKB7IBhgcKD0IN4YOHwqrwkKuddCZoYAoWQhQuIiojKeGLk/CflbRxeSd8ZOGNuQoYQhYm8JGDtyLvv71q4byY8JGkt8KmUFBgChVCE+CwjvCflbQ84KaQyLrwkaSWPCYKGUIXLi8ncPCflbR5P+C6hPCeuqJA8JCAoT0KCEIGJD1D6p+RCidCJWwq8J2Sok/jhLTwn5W04L6NKkvwkKSD8JC6ojrgt7TIuvCeuKcKG0IZK/CQgJ3IulHwlqy8UGrhgZXwn6W08JGRoQoHQgUuP1xpZgowQi5e8JG2pj97XPCav7Lgrp/gtrFD8JC/gCkqTPCfqLJPIisu8JCgmyXwnZKiLsOACjZCNDxiIjgvw7hg8KyHgz4/w4BgUEY9JvCflbTwkIaTP+G/ukXwkK6r76yz4Ymxw5g1aFzgqK0KEUIP8J6folN6Ps288JGNtCo/CipCKHrwkau20ajwkbWgRjwi8J2SvfCfm6JS4aW08JGgkCl7QCQk4aqBOjQKCUIHYDpkX1widwo3QjXvv70l8JCSusi68J6fueCytl8lJeGJrSLhqIVM8J+rsUQnfuCrieGyuvCQpL9zNjRfIjdQWgoIQgYnPDxdyLoKE0IRVn7wkaqf0agvPOODkPCRsrEKLUIr8J+VtPCQqLLhpYAw8JCesvCRhIEq8JGMsyLhv69oUPCQoLxhYSRJ8JarhQo4QjY98JapnTYuJm3grYt08J65t8i6MWQqZmbqoYDwlr6RPHU/wqXwkIqh77+9ITw/0ah044KSMnEKOkI4wqUv4aCx8JCtrTw80ajwnZSJYPCflbQ98J64p++/vXvwkaq/4KGebPCfq4DwkbCOIuCunNGoYGAKC0IJ8JChj/CQvrxJCgNCAUEKPEI68J64qSo6JPCdjL0uwqw/LuCvjEDIusi6ZvCRiKY60ajwn6CGJmLgsZ3wkZCJ4LeKIe+svsKl0agiLwozQjHCpVzDkj/wq42yIMOgSCfwlrmV4YqyPeCzlVzhpIvhg4ci8JKLhy1kW9Go8JuygGh7CgVCA2HDngoCQgAKFUITZ/Cen6Y6WCQlIj3wkaS78J65ggopQic/S+C7hnR28LGivT3wnoS8JWYi8JGKmy8qLirgsJQi8JGNo/CWuYQKEkIQXO+qicKlPGTwnYuI4KmCJQofQh3wmr+28J6jh/CflbTwkbaVTibwnoSj4KODPT87bgo3CgRuYW1lEi9CLWDwlr2WJfCfgaTguoooPGd78JGkicKlyLo8eyLwkL+16qeQ8J+VtFplJy4wewoPCgluYW1lc3BhY2USAggECoARugH8EArDEAoHY29sdW1ucxK3ELIBsxAKLEIq4Z2wWTjhvZtZfWMs77+9XPCRsZs84aCC8J2AqGPvrIM7J/CeuZHwkJW3CjpCOPCeuZfDsci64L2i8J+VtCfwmr+xwqXgq4UvPO+/vfCQhZkk8JGxlPCbsbbgraBRYMOQJzx7Xz8qCidCJT06J30pUmXhs5Y8OkUh4K+X4KyIT/CQlqzvu6zwkIGBe+C1tGwKCkIIUS/gp6hAKkYKP0I9wq88w7jgtoF+8J+VtPCbsp7gqZE0KvCQoYjhmK0/4oeT77+9JDrwn5W077+9KvCfm6BpOsKo8J+JkOG9nQoJQgfIulYvWEF3CidCJfCegIon4rGYyLokffCeuoTbmuCtlVwmfci6QWUqdjkmPfCRsagKHEIa77mZwqVb4KeCLfCQlpBV77+98Jy8lSfvv70KQUI/4LOdJns6Lj/wn5W0Uifwn5yByLrwlr6aPGDwkYaX4KqqLy9g8J+CoeG/s/CRta4uLvCQqJbgtKfwn6aLNU4zCgRCAiUjCiZCJD8uairita/wn5+idu+/veC3hfCRg5BL6qWhffCRmqRRw5RYZgooQiY/0ah78J6ln2ZN4K6cwqUl4LOVw5zjgJNs4oGx8JCRiSNkWlzCpQoKQgjIuifgrZY/ewobQhlOIlxi8JCDmeC2vfCflbRg8J6KqSHwkL29ChlCFzfDs1bqp6Uk8J+JoCZc8JGLtjrgs4t9CgpCCPCQqI5W4KamCg9CDSfwnY2o8J+VtOOAujoKM0Ix8J6AhSou8J6FjvCeuZQmP8i60ajvv70iITTgrp8lfVhgOmY6ezzYp+G0vDU/8JGytQoCQgAKD0IN8J65tybhsLIq8JGdhQohQh/wn56IVSAy8J2qnDExSUXwm7Kf4Zyw16XDiPCQsLB7CghCBuCpnuGdrwoRQg9geyZgJFlkYjw88J+bq2AKG0IZ4LCkJvCRhYXvv6XIukQ6w7Dwn6uB4KmLewofQh1K44WBNlPwn5W04ra4Py4qJ3tU4KecJfCRtqZyYAowQi5gINGoXcKlw4Q+7Z+QXHThiY3wkZOYzbrqq6DgqoPwkKusRsKl4aKeTnrwnrmuCh9CHTop4bK9LD/wq5+4wqXwkYCxJeC6iSlgL8KlZTogCgZCBCY63oUKJ0IlPeqdnOC8tPCen6PjkYM677+9wqvhqqki77+9J+CupDop8JGsgQotQivwn5uz4rSt1o9gY8KlZi7wkbWyS2rhiZsi8JGKpPCQvoJy8J+VtPCQnrQnCjlCN0A6wqVAN305X+CvhllcLuKBsCThr7Mv8JarsfCfiaI8wqU6d/Ceo44q6qyDZi8uyLon8Ja+ljoKMkIw8JGNkPCvpa8kw7/hirPwkKSfw7DCpXvvv702POG9gy4/cSfitK0kLlzCpe2fqH1sCglCBz3Iusi6JS8KIUIfJO+us8Kl8J+VtFvvrJfRqCo68J64u8OnJ8OZ8J6LvwoJQgdINcKl4KaQCglCB++/vfCdhYgKJkIkXDrhnIjvv70q4LaCItGoKiLCqS7goYlJfeqfviLwkZqQ77+9Ch1CGzzgoLDDiFd6T+Gcgz3wnrK0PyLRqOGdsMO6Igo3QjXRqCTwnYa677i4WSLwsoe9L+CqhcKv4YeLYXEv8JKKrPCeuIgk4Lud8JuymVJeZfCRtIg6LwpEQkI8L8Kl4Z+kMkzqnZrgpq498JCdlfCdqp/wlqmUPS/wkJ6APyVT8J+EkvCQlKUqbu2frXvvrYp78JCkqy7wkISCIjwKNUIz4r+6JfCQgY0n8JOCiSrwkYu0YvCeuolcasKlPHvwkIe58JCth9+ML9yu4ZyVJiYxPMKlCgVCA++6mwo7QjljyLpOe8K08J66p/Cen6lHWTxiV8i6eznqma3wkaWGz4IvWy7wnZ2FLy7hppbgqrU2ZfCQoIUsPS8KFkIUw79GL3vwnrmSVfCRioPWlPCQuokKMEIuSOKIuGDwn5W0Li8iXPCQj5Av4bK98JGyteCtjMKySfCav70naiLgv5F14oOibwoFQgM4ImcKLEIqe/CbhJHgrYJK8J+VtCjwnrqj8J2QoyfwnZK78JCphNGo0ag8Ilzhv6duCgNCAScKIEIefFUu4K+vVTnwkKS/bmB7JvCQkqDwkaSZJj3wn4miCg5CDD8sRtGoJ13hi5DIugoJQgctJe+/vTM0CgxCCnpU8JCnttGoYiUKKUInKmDhrZQ0JDzvv73wkISBwqUq77+9wqXwnoWAMeC3nTc/P8i64b6zCiFCHz3hsJ1QKsKlyLrCpcKl8JuFpeCutjrwkJm+WyJlKiQKOUI30ajCtfCQvrB74KqRwqXqr7hccnAgJnXRqOGqt1hi4b2d8JasgvCRnJ4kyLol77+9OuC3lmTIugocQhrwnoWOXfCQsLzwkKaXP/CflbTRqGDhvZHDmQpAQj7wkKyu6qOPzqBD77+9S+C6o0Xvv71i8JCWlXvwkbaAWlzDuDrwlr2cNipLcuK0jC/hvZ0n8J+VtO+/vTLfiAoYQhbvv73wnoCgMnlVNjxLJ+CovPCetLleCgtCCeGLi+Cnl+CovAoSQhDhoJbwn5W0wqXikYAi77+9CkBCPuGKjGQl8J+ip+C3kuK1r/CehY9jJipqYTIi8JCzuiLCpdGo8J2qnkoybT/wnrKH8JGNkCHwkJ2lyLonP3QmCglCB/CflbTguooKHkIc4LuX4KaMwqUv4rWvPCIlJeChoWZQbci6JuCguwoUQhI9PeGJvvCRp5/wkJa7IeCssyAKEEIOwqNB4aqmPfCeuZlgeHgKCEIG4reMPVNgCgJCAAojCgRuYW1lEhtCGSQ60ajvrITCpTrvuanwn4iW4LG58J60k24KDwoJbmFtZXNwYWNlEgIIBAqOGboBihkKrhgKB2NvbHVtbnMSohiyAZ4YCi9CLWElO3tg76y+IjXwnZS80ajDvvCRtass4Z2y8JGmvHNGJO+/vXHwkZCT8J65iQoDQgFFCjxCOj3hkoxJ8J+VtPCRvrB7enNF8JGylMOsPfCRvJDwnaqe8J+ppfCRg7AvXFbCpS7CoeC3imoi8JGWiT8KQkJA8JCLuVJzO/CQs58iYV/wnYy0e/CRvIhh4KuJwqUvevCQvZLwm7GzXCXigpw977+UYPCeuZ3wkKiGYPCeuoHDrgoWQhTikYphOtW5L+CzjfCdlYvwkaOVLwovQi1AUCRE4b+J4LqCOnc9PS/JlPCdlY/wkIeZbPCflbQi8J+VtOK2uDrqoLPit50KBkIEJMi6cwoeQhzvv71YJfCRmqHwnriALvCRtaLvrL5BOjrwlqa6Ck5CTPCflbQq4b6B8JCegGrwkJWVeHpe8JG1lvCRjJDwkKCI4bC1JVrwnLys77+9JvCQuoI98JGxmj5n8J+VtD9qT/CflbThnYXwnZKlUWAKMEIu8J2Sou+2ujxc44S58J66p1Ltn4JcyLpN6p+XOfCRjZ/wnoWG0ajgu5LIujpAYAozQjEsOO+5pPCflbQ/0ajwkZ2F8JCVvz494LOG44S077+9wqXgrpk98J+VtCLgoZQm77+HChFCD/CQnoh7PW7wn5W08J6ipwovQi0l4aW0QeGnqmAn8JCeufCRjYsuJXrwlr+kOuC6pWDwkYyy8JCNmT/igbppcSQKFEISwrnwn5W08JG7rnLvv73gu44vCkBCPuChozrgp5fwkJ2n0ahsTyAqL8K98JG0iDoxzofwkbCN76a+ezzwm4WkffCYtIV7W/CfqbYzWypg8JGkvSYvCjFCL2En8JGwkGDwkI6k4aORWlYv8J65i/CQvLvWqeGfgSbtn7nwkI+T8J6KqiAl4LOeCgxCCmhr8JGMs+C5myQKOEI2JC860agq8Jits3TRqCdnYGAm6ranJ++/vTPCoNu/4K6p4LCA4LGM0ajgv47wkYiKdGDgqpFgCgdCBVzwn5W0Cj1COzx8efCQjoF58Ja5k17wn5W0JijIuuKCkCzwn5W0wqUqdj1XJPCQoIjwkZaQ8J66sjrDm/Cdqpsv4bSrCiFCH/CRiojwlq2f8J65meCzg++/vXjwn5+w8JG9heCskFwKI0IhbPCegZ4u8JG/guChnvCRtqjgrofwkJa74LK+Lidtw651CkdCRfCQmafwkKiBPfCeuqPvr5My8J+rpTAo8J+hk3s6IvCRioTjhK3wnp+rXOCwj2AqIifwn527Uzrqr7XwkKS/PFxg8JGWsgoaQhhpV/CQo7Twn5+wYOC3kmA58JCWlUk8ImAKIEIe8J66pT1K8J6Ao33RqFjwkJ6VPDrhraFLXEfjgZVgCidCJcONS/CqqLJC8J64gzzgrq7wn4mRJsOn6qCbQ/CRv6DIuuOCnVMKLEIqK/CRsaBI8JatnfCflbQ4RPCRha/qrY3wkJaUVjBKOuCqtuCphzoiPci6CjdCNfCRvJt0YCZV8J65n8KlyLo97Z6/8JCdgz3wkbS68J64hfCetKIi4KuuPeC/g/CcvLUqeyVqCidCJSVgK/Cek67RqC498J2Ujsi6YDwiPXDwnYOWP2wkavCRjLzhs4QKMkIwVMK6OjzCpeGtnGEq4oCE4amC77m+U/CRi6VZbj3gp408YuqslD8iVC0k6qOZYMi6CgJCAAoHQgVQ77+aWAoJQgcvSn7wn6+KChVCE++/veCoh+qfkfCQhI3hprQ90agKCkIISkJBJeqrpjcKAkIACk9CTfCdgaBTQ2AvIty6J/CflbTgt57wkbyBLvCeuqPwn6+K8J6jk/CRtIZu8JCwglLcnVzhvKDwkYa+8JCmsFPwn6mS8J+VtOC0jjzgp6YvCgpCCDtFPfCflbRgCitCKTrwkKyp8JKUszhcOicvPWAuOu+/vW7grYThvZ3hrpQi8JGagCXwn5W0ChpCGD4iwqU84Y2oJsi60ajwkYGS8J66puCyvAoXQhUvKi/DqvCfgrPwkJKmwqXwkLqZVVkKLUIr8JG0vOK3gOGdsyrgu5zwkYOk8J2SouGksSYmcuCpgiTwnrmicOChpSTIugokQiLgtrpLLjoxe+qdrCQpJl97LiUmJPCflbTwkKOq4aWyJVQkCiZCJG/guojwn5WhWvCQo7XCpeKIgNGo4K6jKvCRjLXRqCRMRyduYAoyQjDgspR216Yv4b2J4KyqL+K1r/CRiorDoUl+wrNtJvCQoIjhv6lf8JORiPCUlq8qay4KOUI38J+Fu20yVvCfiYjwnoWPJOGpg+qrtvCQoITCpeqhlPCRgLQuKjQ+4Ka5w7vwn5W0QznhqakuZgoIQgYkJ/CWqaUKMEIuauGKtdGoLysi4aS276yXwqU9OvCRoLLCqyfCpeCxgy854ray4Kyyw5088JC8pQo2QjQmXPCeuKTwn5W0fTPwkYSNdeqgteGhkDw98JGkt/CRjLfwkZuG4LGm8J6llz9oIeGogC9HChRCEuCjnCl0OfCQu79n26Av8JCjtAotQislXHzwkYGY4LyJIu+/vfCRiojgrpAp4b+84reV4aCA8JCGoOGtlC/wnp+tCkdCRTzgr4h14amq8JGjqi5c8J6kqcK98JKUpT3hop83ecOs4LKx8JCWjyp+aUXwkKiTwqXwkI+U8J2qo+C1jm/grrk0aMKlTQowQi4k77+9ZdGocMKvPPCQj5LwnrmfU3Xwn4K4PfCRsYDwkLqJ8JG1oj7IuvCRi6UmCgtCCT8lTE86L++/vQoqQiguLy8nyLpzPFDgqrM5JyLIuu+/veC2uyBg8JCplOGmkF0iYM6MZyUrCgNCASQKI0IhQOGdgi7DpvCeuLnhiq1gReGOhXvwkYyy8J+qhjpg4LuWCkJCQO+/veC1hvCQqI88wqXDnOC3ljp78J+VtCU8P8O077+937Eh4K6kUuqrrfCflbR5LvCeuYnCpS4/8J+VtPCetJ4KI0IhwqXwn5W08JChrOCpm+CvkPCRu63wkpGycj/DiSLwkIqECglCB8KmbdqTNEkKAkIACiNCIWU9MOG9jDrwkaeg4K+KKibDkz1vJeGHpdGoSDPwnrmCJwoCQgAKRUJD8J+VtD3wn6CV4q6KJvCQurBD8JG0ieCwveCyt+C3luK2q33wlquHVvCRtLrwkpGz8JCFjfCeuLvgoLMj4KaM8J2UlAoWQhQnPyfwkYqNXfCen67qmo1nw6E8JgoJQgfhrr/wkISqChlCF++/vTfvv71cWEk98JOAl+Ggk+C3nci6ChNCESspXCvhvZDisqHhsbrDoMi6CjxCOj1g8JChgiQm86CHqeCgtdGo8J+VtMKlJlHwnrmCP/CWrZc1PuGliPCQrq8vJy88ZSrwkbGXYCTRqHgKC0IJ4KaQL3F84KmBChtCGTbwn5W04Katw58qJD/wn5W0XCImU/CRsagKN0I14rawXGDigq7Yisi68J66qUDwm4qsc3w8JNGofTFtyLom4oKzb/CWq4UneHcu7Z+Bc/CRqKMKCkIIISok4Kq4PEQKVUJT4reA4K6y8JGkliY98J2UjtS48JCokOGKjSXwkbKGyLp18J2SomDwkLqr8JKQl/Cei5wvPPCRhLlXJl/wn4ml8J+VtNGoJPCeuZ/Cv/CbiYXjgLcKNEIy8JargvCQh7nwkbWhIkjwkJa2KuGLgz3wkJiRPe+/qfCQoLwnR++/vXBZPeGfouC8tDcKGkIYPSbRqPCeo4ngp7NzJS9BL/CQqIA6J3h7ChJCEC4k4KuILTnwkb2LPPCQnoQKLEIqYC1sKuC+oO+spSVHOjo6JOGPoicn0ajwnrSQYOqlrj7wlr+i8JG/pdGoChJCEOOIhO+/vci68JCmv2AsyLoKEkIQ37rig5rwn5W0ey578J2Grwo5Qjdl8JapovCQkYLwn5W08JCni8ONYFkk4reK8JCOqTpg8J2SsSRg6qqKaeCxmfCRtLo60ajwkpKsCi9CLfCRrITwkbym8J28lXvwkJ2hekLCpfCRjKU98JGAmErtnr5zTOCxmSTwn5W0Lwo5Qjc7bj0nPMi68JGMg+CurtGo4Y6Z4K6kP0jgtY3grr8/eXgkIjrDiuCnlz3hraEkYOGPuuC/kUl9Cj4KBG5hbWUSNkI04YmY4KiQ8JarkWFQ8JG0lPCQsYXwkK6a8JCphfCflbRgUyvwnqSn44OCyLrwn5W08J+pqQoXCgluYW1lc3BhY2USCkIIYCTwkb6w26UKtQ66AbEOCrwNCgdjb2x1bW5zErANsgGsDQocQhrwn6uiL2Bc4oGVzb87YFzCpXVFTTxgOEHCuAoMQgpF8JGCm/CRsKE3CiVCI1wm0agvdCYlIC/wsICKw57wnYSmyLrhqaLwkaSO8JG+sGlLCiBCHlQjQMKl8JCzjz09LvCRqpch4K2xbU3qmZsle++qpgo2QjTih40vPfCWvb3wn4K3PSYkJfCflbThqa52KvCQg7HwkZyo8JGyoSYm8JCtoFTwnoC94KCwCgVCA+K8lQoqQigkJSTDimHqqZZ78J66jfCQoqnwnrmdRTzwkKiWbSZ4P++/vdaO4ratCiFCH+CnoVzVlD8qPSQ0ey7grZVcJi/wlr+h8JCtjPCdlJoKH0IdYPCflbQu8JGaqlow6pqJPvCdqq/ig6dx4K2IK10KNUIz8Jq/sPCRpYMkLsi64Ley8J+rlOKCrT06PCUkJz994L+D4b6t8JCokCTIuuGJlPCdhKk/CiZCJCo/SfCQgrfwoJOyJD3wqqm18JCEofCRgr8iXPCdjKAjyLpCJAoyQjBc8J65j0A/yLoqJ0554LaJRCbhjYBk8JC6mW178J+gouC2t8i68JCgt+CmiUtJwqUKHEIaUCTqp5/wkZaq4KiuyLrqqrLwkYeJJiThv6AKSUJHL/CeuoXIumAm8JGFm+GwnyrDhi028JGlmeCquSDwnrmi8JGmoeK3kvCQgZDvv70zPz7gu4bDmsi6LvCQs5Lvv6kyICLiupkKHUIbLdGo4LK44b2d1Y0vyLp7XvCWp6Y9Nyrwn6+4CjpCOO+/vS958J+rsSYgJOqfkeGlhm1gSyc/NPCQh7NyOtK5XCDvv73gqL4nbsKk4LuGIvCQja7wkYKkCjJCMClccyHvqpdcMcKsw6fhnbDDq+qslvCfgrxZwqXRqOGJmDZy8J+VtCRR8J6jkic8JAopQicn8JGKiMi6w4kvwqXvv73wnZKmInpg4LCQJjLwnaqj77+9PHA/aCQKDUIL8J2SvToh4KedR3gKDkIMwqUkXFzwnri1RmsmCkZCRPCYtIB7Li/wn5W0YzRUJfCRpJbCpe+/veC7luKNnvCRioZ577+977+tYTvvv73Ctyjvv70k8JCwgPCQkqkvJvCRnLQ8CgVCA+GcsQopQick8JGXi/Cav70q8JC6sFzwsJSWPCrgtoPwkKiR8J+Fnsi6Ue+/jWUKHUIb4Yq9PdGoYOCunzzCpS4k8JGshvCQo7VOwqVNCiJCIPCdjJjhs6zDryXwkLqwLy9R8JCSj+CxlcKl77+9bT9lCiFCH3YnJTpgYD0qXCbwkoGAT/Csuo7hna/wlq2eP0UkezoKCUIHYNGo8J2NgwoFQgPgs6IKBEICwqUKAkIAChNCEW/wnZSf8JCyo+C7iFl+KsO8CjRCMn1dXOCmrOCyi8KsJvCei597JSIq8JG+sC486qal8JGytTwi8J6fruGcj/CegJTvv71gChBCDiXwn4mi4a2oXD3wkKCDCh9CHSvwkJOL8JCVgWDwkJ6yMWBTOPCdlLxcL+GKjVxwCkJCQO+/vW0l8J2Su1dpeybwn6+0JjLwkaStKzzhiZrwnYWl77+q8J+VtEnhvbRnJvCehY7wkKy+77+9Jj4vPPCRpqMKPEI68JCMh2c64reJIsKl4KOSKms877+9NPCbg77grqPwnZS+UjI677+98J+CoCc8fvCdqp3wkbaT4q6RPwpHQkXwn4mga/CflbTwkLCJ4YqNKD8lNuGznCc08J+VtCU9JWdv8JG9lPCeubQ68J+kkdGo8Jq/t0zwkaST1p/hqJMq8J6EnyoKIEIeLmnwkISB4LqE77+9YOCqqvCQoIEw4KqFS2Twn6GzChFCD23gu43WnfCfrqsm8JKRgwo+Qjzwk4G+34XwnYeXKOCuriXhiozOlyfCpeGWt/CQq40iZXTwkY2g4KaFLntb4LKyyLolPfCQo7TwnoudXjgKF0IV8Jy8ufCdhZVg77+94LGdVvCRi7d7ChtCGeOCpDrwnrmUbTvCpdGoJ/CRjbJI8JCWtHkKMEIu0ahcePCdjZM5e3vwnrmiJ8O5cvCQoaI5IiTwkJa4MTzwkIWI8J+rkPCRioMuKgoWQhTCpWAuVzXwkYWb8KuejSrwkK2Tego2QjRV8J6Fj8KoJXvwkJWw6qW7JtGofCXwkbakXPCWuZA6PCpcfOK1pe+3tSjDoDrIuj/vrYA0CipCKOCumj868JCtnTYk4YKe8J60gfCegJ5tJXtRLyfgsZ3wnoCRTOCmnSoKE0IR4a2JyLo+X+Coh++/vW/vv70KMQoEbmFtZRIpQid+JjjvrL7wlquraeGcsOGPuvCQnaHgrppg8J2qnjwl4KqTO/CQrJMKPQoJbmFtZXNwYWNlEjBCLuGitELwn6eEPCU9afCek5c4XHZE8JuxsOGLjH464KiBcvCRg5nwn56t8J65h3MKkhS6AY4UCuYTCgdjb2x1bW5zEtoTsgHWEwoYQhbwkaS/77+9fVE6YMO68JCuqvCQnYIsCipCKCg7aCXwkKO06p+X8JCuhFzwkbWUyLrgsZrVvCzgtIvwm4WROvCvp4EKKkIo4LGH4LOd4oKb4Ke0SmNUwqV08JC8vWBuOjrwnrik4LaVw47wn5W0JAoNQgsvU+qnrjp5PFwqVwoSQhDwkKGvJdufJ18rJD/Dlk5dCjZCNPCQgYdcXC8vXOGdpOK6jjomIsKl8J6EgNqc4LeU76qU8J65keC3liLVsWDRqG3wn6uRIiIKPEI6fOGJmPCQi4Tvv70lPS4k8J2Lqi5W8JGomntdP1Dwkb2WQiXwm4WQJ+qgkV8kPOC0jyUr8JGkpsKgOgoQQg7wkaiKP1gl0ag/8J+VtAokQiLwkaOtyLo9ISV9LuK2gXt8YPCfn5dqKsOC4aSZJ+GksiIqCjdCNTrvv70wyLrgrYd7yLrhi74qXHbCueCqq/CRvI8/8J+JiPCdkLt7MkLDuuC1tfCeuYJBezxtCh1CGy4lY+qhkeqaiOC9kvCRi7jsk5XwnrmdMFwkJQozQjHhirTwm4WnLUTiroE9IPCei78uKipAJCTRqDZE8J+VtHLwkYyP8JGNl++/vcKrNlUmCiZCJD1WbD3wkYuzOkMvQuCipvCXgrxcPSnvuJQiwqnihLFgIOC3igoCQgAKAkIAChxCGjp6R/CWvbI/efCehLjgtr08Rci6IvCdi5N3CkFCP/CRmaRgYuGkpPCdk6/Dmj9yJcOAaPCQpIQ80ajwkbW9V/CRtYDivIrgo6w8Kjrgu4bgr4o8PT0iOuCns+qkqwopQifCpSXwkKC34oOe4LGN4LONyLpU4byZ8JG2kUrwnZSc8J66ojxJXCoKLEIqT0Bi4aOlw6nqn5ZZ4bOE8J+VtOGJmPCRg7fwkYqNJ8i68J65kV47e8i6CjtCOVXwm4Wn0ag8yqDwnYa+wqXgoZ4iQCbwkb6wPSZB8JCugOCxoznDkvCeuLvwnriq8JGMo+C/ilVpbAoYQhYuNy5e4raVJvCRqbrwkKqO8J64p3trCgtCCXvRqGAk8J64hgomQiTwnoS5J2BxyLpg6qO18JGWnC9FP355am/itKUp8JORj8O0IUsKPkI8JvCRo5XgqZ4uY++/vdGo8JC5pPCeuZLhnY0u8JC0kPCepZlQUPCRmZAh77iHOj/RqEnwm7KDL/CQkKdOCjFCL+Cst1HIuksz8JaijOCsvW9Q8J+VtF/qqqAl8J65iT09TeCqj+GLgPCfh7Dwr6WDCj1CO+CziO+/vfCQu77wnruwKu+/vTDIuuCyuGVXMTjitbB0JOKDmktc8KudtfCflbQu8JC6rPCegJ9cJSomCipCKPCRjKTCpfCehY49cfCflbTgroZ34L+IPGpgyLrwkYydKSpsPGHhraQKAkIACiVCIzXWjzzwkLSCTC8gJzDgtLrqrpDgsZk18JCetdGoPfCRvrBcCj1COyPwkY2NJ27jgL/vv6NV77+9X+C1q27IulwtPOqpjC8wJfCfm7pjP+OFozvwnoSybTnWszo98J2IksKlCh1CGyrwkJ6CPNGoXD/wkaSJwrfwkYey44Gq8JCnlQofQh0h17Jd4L2G4Ki476yESvCQlrxw8J+VtPCRjKbDuApIQkbvv5sqZ++/vfCflbTwkJaV8J65jWvgsYvgoadAO/CeuZt78J+cpfCWrIJoXvCQrYbCsUjCo+GmsiLwlq2TJTzRqOCmkCVBCiVCIzo/PzzRqO+1myRf0ajwnrmO8J+giFzCpeCoryUuUci61LhECipCKDo/8J+VtD/wn4Ce4Ymd8J65vPCWv7B48JarleC7nPCdkqLgr5fhu7EKEEIOYH46XDrDu1pXwqUpwqUKFkIUdT/gro42OPCepZ/hsr96JCAv0agKEkIQIjM177mzL0HwnrmZ4oSdOgoxQi/gqLXvv70i4KuM8KugkCXIumlcw4fgsZhmJlXvv70q4LOW8J2IlfCfgINp4oGXTAo5Qjfwnrmd4b+MyLpfKk97fOCyvOC+kFwuKlElLyTwnrmXYHvjgoxc8J66q/CflbR2UiI/77m077mqCghCBiXwnZKiPAoHQgXjgrDDqwoyQjBF4KqKYCQ68J66r1Dgs6h3IuCvre+/ve+/vfCfoZYs0ajwlrmwPy578J67sdGo0agKK0IpeOGDhy/wmr++JipgJyU6TyTwn6mqJeCqs/CforEx8J2Su8KlLlXvtpkKDkIMJfCeuaLwkIGYbn1LCh9CHe+/vXlh8JCuqfCdvIg/Ons84aa+8JCrrfCQhIJcCiBCHsKlZ++5n/CQgZbvv70qPfCeiptZbOCzhPCQpL/RqAotQitCVDzwn6mD4LqBVzph8J6fojxoe1TgqrjitqIkRyB4w4JCPe+5q++tgyUkCidCJS55fnBcNtGoXvCRp5xR8JCrsPCqrbY2JPCRsrImJWA98JCNrlwKAkIACidCJT4v8JGcufCRsZVO8J+JkC7wrIW4cjDwn5urdiBcKidcwqVVYHwKL0It4K2HcHvgrYgt4ZOnNjxTIfCRpqRQOkMx4Ky/wqUnKsKo8J2VgSLwkJyV4bysCg9CDWPwnrmJwqXvv71c0agKH0Id8JC5oCAmJXs94Yu5Je+6mPCRvZHhio1gP3RSbSoKC0IJyLrqqYlALkVBCipCKGDwkKyxbyoiw7Twn5W044aue03wnrqS8JCEgeCmqj0l4KuM0ahvLCQKH0IdPCbwn5W0JWfXkPCdkp8mP/Csg48qUfCflbThraYKH0Id4KyBLnl2aXIuduCihCdVZEDwn5u78J+psjHtnrQKGUIX8J2bo3PqqK7IulJs8J+fsPCWobBcXFwKGUIX8JGklsi60ag/w6pDJMOHLuqtmyVOYC8KO0I58J2Vm/CflbQ28JCEgPCRoKLwnqSF4KeNcPCeuZfhi4Dvv7178JG2g+Cri3siazDhqpZRXeCtq8OcCglCB/Cei5MvJioKFUIT0ag96peAJyQ/8JCokkpq8J65lAodQhvwkYyF4b2R4Z2pePCvoJEl4Yup4LCe8JGIri8KMkIwJy4o8KWRhlxnIuG6gDrvv70/Wz8uUSU9YuC6guCriMOfS3nqoqzCpfCei6sn4oifChJCEGA60agm6qGMPXNgIlxgPigKNEIyWmBieHs/0ajgqY3qopYpL3xYay1I8J+VtGR477+9YGdI8Jq/sz3wn5+w8JC8nmvIulwKHEIaYPCdjaIk8J65i/CRl5XqrKMkXD1x4aWx3JAKHkIcYPCRtqRmYCYy4b+b0ajit4tBJCfCpU928J65hwojQiFgwrUv4Ku6WT8me+GNgCQmLsObYCUj8J+VtGDwkJamPXcKEgoEbmFtZRIKQgjgtavwkbSIKgoPCgluYW1lc3BhY2USAggECqwRugGoEQrPEAoHY29sdW1ucxLDELIBvxAKOUI3KfCWubfwkbKk4LOv4bCKJNiyw6Tgs54uZSRAbyIiNcKoJ3vgq688eX7gprfwn6CAwqXwkL+HRQoTQhHqp5JJPCoiNi0/P9+Z8J2UlgoRQg/wkYS5P/CdnJQi4KuDM2IKIUIf8JGHsHTwkIC94LeC77+C4K2NNu+tgC4/8JORlWAnYApDQkFUw5zhiZrjgqjwn4mjPSsv77+9wqViOD3wkayA4b+YPC488JCurPCRhLzgprjwnrmqw5BM4KmCIsO68J+VtC7CpQoQQg5cS/Cfm7d377mk8J6AnQoYQhbhoJR78JG1ksO8IvCetKMi8J2Nri8qCjpCOOCxiyLqn5XgoJBG8J2Viix4Jlw8OiJHe+K2vCQq8JGDoTjZgOC0jnvCpeC6pcKoNPCRpJbwkamZCiFCHybDtT1WJDHCsS7iupVu6qaqb1zgqolw4Y2ww5bgqYwKEkIQOk1GwqVT6qKCLyI6LuGNqwowQi46PWDhjZrgq5Bl4KmM4b6pwqEm6qeYTHEkyLpc4YmTPHLRqOCwh/CeuLfwnZWGCixCKvCflbTwkI6XVzzwlqmSPOCqvCfgp7Ei8J+VtCQv4KKIXCvwnri1IiQvKgoEQgIvbgoPQg0l8J+VtF89JX0977ePCitCKV3CpSnvrL4wOMOeXPCQoLzwmr+w8JGygnjvv73wkaOWwqXIukcqYNGoCipCKETYmfCeuLbVuj8/Lkduc03RqMi6wqXqq6lgXCfwn5W04oOlPfCRsIQKFkIUYD3gp7jwnZaXXPCQh5YvKWUiJDoKD0INbVwlYGgiYFxu8JGNlwotQisiYzZiKMKlLi498J2Upz1+wqUi8J2HnvCegKovVdaS8JCMv0Y28J+bqsKlChhCFuCxnfCflbRcLz3gvLPwnrinJPCdlIkKDEIK4LeKX/CeuY86RQoRQg97a1zqp4TDmvCQkqVFyLoKNkI0SvCQgZPit5olw6Thoppk8JG/oSThqqs8KizwkbKU4ae0PSVewqXisr/wkIuz4b+g8JiglQorQik8wqXRqPCeiqLwn5+wOCLwn4Cn8J+VtNGoLj3wnrSj76y+Tj9cQu+/vQovQi1S4KSqe1XDs/CQk4Ig4ayjYC4qL+CokEfvv7zhqpVx4a6sJ+Ctn/Cen6I4P2AKO0I5SfCRmoRA4b2dYntA8J65gj3Dr0pxJS8hey/wnrm1VD3wkKiGJ/CRtpZaJfCdkrV28JKEmfCbhZBgCjZCNG3gqLzwkainXUXhv7NR8JChvNGo8J+JhMKs4aaQ4Z+0c2dK8JCouOC9jS9lOuGcsibCpX0KNkI08J6jkz3wkY2oSdGoPCFgIiLwnZerMeCpi/CRtIQ9Lz9K4KujL/CxvqIi8J2SnvCRjJkqXAoyQjB8UyonVFo/e/CRnJLwm7KC0ag8IuG9kfCYqq5gYEHDqGhz4aWzWuCxoPCRkZrIulEKGkIY4LOePT3iv7PigpsmZDvgsYvwkY2xb8KlCjVCMy9SwqVcOlzhprfiuZtnbS/wkLyW8JKRsFw6Ol7gtJDwn5W0Lsi64LqHWVzwn6uowqUiPAoxQi/wkJaYJkzgtr3wn5W0euGfp0nCtmjCvEDwm7KcLuqgsuGhjzzqqZbIuiQl8JCjvAooQibIulxLPsi6Kk1HXF0l4L274K2h4LqlLvCflbRpJXnvv73wlr6fYAo2QjTwnZWC4ryDLvCeuobgrp7hv6vwkbGg4r+1JD/vv73hvZvwn5W08J+CsiLvqoZ7J/CQvIhcCgxCCirgpqrgr4vCpS8KH0Id8JGEieCqnsKlLuChnvCflbTvrL5fV/CQpJMkXHEKHUIb4Ki88JCgg2QvQy0944OEIj0nPMi6MiYp76y8CkZCRMKl77+9IvCWrZwka3vvrJ8vwqXgrpk+8JCphTcl8JGbhPCdmYsnyLrhp5pcSyTvrLxXR/CQq6zwn4mQdDrqq7bwn5W0CitCKfCav7fitqwpwqUlLzwv8J6Cj/CRtqnwkJaeLuqfkWnwn6mpLmDCuMOPCjBCLmAidk3IuiTwn5W08J+fp2HwlquEXPCQjr9zUvCflKLWj10uPVtZP/CflbThiZMKJkIk4a2Z77+94Z6gaiU6KD9RWtGoUPCegKM80ag68Ja/seKlvsKvCilCJ/CflbRBLTxH77+98J64nuCsgdGoaSom4K2D4K2sKj14ejrjiIHRqAoVQhMpfvCbsJXvraVcKOK3ifCflbRgCjtCOSLvuJZ34ai6MuCxjUHwkbS60ajwnZS2YGXhs7XVmvCRg7Twnp+gyLrwn5W0LfCen7wkXeqgszPCpQorQikmKiXgrbdt0ahPL3HwnrmCPOqsofCegJfgt4DgsLAiS+Ggou+8g3suPAomQiTCuz7vv70tc0/gs6zwnrqALzzCpVbwkJOl4LOjJMKlIvCfnqUKAkIACgVCA00lPQoYQhZryLps4K6+YDrvv5zwkYqiwqVgyLp0Cj9CPVU64am28J+JoHs/dPCfgq7CpfCQsIMv8JCLgCrhoIdcVznhpoXwm4esJGDgp5fwkbGy8JGHsSbqqormsbgKBUIDQMOECg9CDVnvubM68JCWrCXRqCAKFUITOjzwnp+x8J+rgzkx0ajRqDxMKAoUQhLwkZizYPCQhLHwnYaJXD/grq8KAkIACixCKlBG8Jq/sD/hn6Fg4Y6l8J2Lqe+/vUPwkbWkP/Cfpr3hpLp7JiYl8JGDggo7QjlwPDQiZWIk4L2qJOOEmEM94b2NKvCflbQ+8JCWj3fwn5W0MOKAhfCQs5g8wqVjOfCQub5B8JCVsj8KBkIE4Y6nIgogCgRuYW1lEhhCFiYm4oCy0ahh8J2IkT3vv73IuuCtnyoKMgoJbmFtZXNwYWNlEiVCI1w9e/CcvIclLeqqkCJc4bOq8JCrssi6PSUvQuGjqSUwcM6bCp8RugGbEQrWEAoHY29sdW1ucxLKELIBxhAKMkIwQ1w9PCTvv714J/CQrJXIunFw4KiQdvCQvLsuyLrgsaPwn5W0XEjCpsO78JGCtyclCjFCL/CQtJY9TkVu4Ka+6qyJPT8tPEl78JGyoO+3j1zwkJalfUtmJ0/wkLybJkfwnrq3Cg1CC1HwkIyNPWMqJsi6CihCJkQmSlc3Uyvhv7c6ay/wkamA4Ky58JCLsD078J+hkkxFOvCQpr4/CixCKvCQoLc6TlHDu/CeurJLJ9Go4LucyLp944WU4LyDNl7qp4pm4YGebzxZdwo+Qjzwkauu77+90ah78JGkiVdF8JCirzzDsSTwn4inP++/vfCdkqXCtu+sgPCRjIEw4b+94KqzKvCQrKzhiZsKC0IJL/CflbRZ4KuhCkBCPvCfoIPgr5B0JCrgqZsn4LOCbPCQipo6zqMi8JCAv8KmPz9D0ah38LCWjeCuju+8g++3jz/wn5W0UTpq0ag6Ch5CHGNz8J65keCrhybgtYd7e3vwkI6d4Yqa77+jIk4KFEISaWDCpUw8K1rgqrJtwqVVT1wuCghCBiVJL+C4iAocQhpOLETwn4e/PHvgp5zgp6xH4KaQJO+svu+3jwo5QjfVsC7CpcOe8J+VtCfCpWXgqYhxIuCxmXTgt7N0OG4lwq/CpSPgq77ig5XgrorwkJGlL+CpniYqCjNCMSV78J+VtOK2j8K7wqXDg8ag8JCWml3wnoCpXyJc4LGd4Lyww67Nu/CRjIY/XuCokFsKOEI24YKE8JC0tXdD8JCTsUA/cXsr8J2VgCon8JCirC9cPTThh6vwkaWCOsO4IOC3ru+/isO1IXUuCihCJtGowqJc0ajwnYSEOSIl8J2SsmXwk5GG4LWnPCMv8JGajj0qUyZUCjZCNOCxo/CQgKDgu599e+CznfCflbRPJ1MvyLovLypQyLo88J+VtC/gsZbgt7IkJS/Iulk6wrgKCEIG44iAImNZCiNCISQ6w71iJyIv8J+VtOGevyIt8J66ufCRmJI3LPCQnrg6LgoCQgAKH0Id4LeWTSXwn52LwrVA8JGDtVgvYFwmJE7gt4XvuKUKGUIX8Ja8q0zwkJ6BJSI/UCfDt++/vT8rPiQKE0IR8JG1ky/CseCnizU2ODrgq4kKHEIaXFXCpTzDln7vv70n8KuglERA6p+RYCritpYKDkIMPXtP8JapkzzwrZ6qCgNCAS4KBkIE7Z+YbAoPQg0l6qWh8J65guK3kGQmChJCEEPwsbyQYC8iw4QiTFHgt5IKQkJA4Kqc8JGktOGNuz/UufCRgaPwkKa96LWNQ3toPfCflbQvKi/iupngvYvgsJDwnoCA4oKjL2Dwlr+w7Yq7e+CupAoxQi97cOGdrzzikYJKYD3CuPCdhqV+JSTWlvCRtpEx4YuMLibCuCJMJCXgs5Xiq5cnPQoGQgTwkbS/CgxCCnvwkpGfXPCflbQKMkIw0ah78J65guG/siLwk4G58JGMsPCRmZg9OvCRjKB7Ly7gqpDDvfCflbTwnLyma1JjCiBCHuqjgiXwq6CSPFXwkamSevCQlrtcLifIuiow4LCcJAoeQhw4wqXwsI23MPCRhLYmYSfwkYC1JnHRqOC3ky4/CjFCL/CRhInvv6AnbS/wn4KkY1B7wqXIusKlIeCsiO+/vSbwkbaQU3cmOiUqJUI6UnFgChhCFuCos8i6Jic9wqXwnoCk77+9yLozQTUKLUIryLp7ez0kwqXDpzByw6JzSMKl4K6GJ1Q8XPCRsIHgtr050ajit4LVhtGoeQo4QjZCfPCdiKwu8J+VtCd78JGMvMi6Z8O2PyJ78J66p2NgYGlaRPCRpYVTWknwn5W08Jatpkrtn6oKDkIMI8KpwqjwnYay4YmTCi9CLWDhjqk/JFM8PGFcYOGmuiBtRipWyLpEwqVbJjpyKiIy8J6Es8i64aOA8J64rAozQjHhpYAmJnHwsoCMTysn4KmBcD0t8JuFpz/wkbaU8JGMtcKl8JGkifCQhYntn53wkKiFCi5CLEEg8J65iyfhh53hir1cQnvwkKC8XGLwkI2EYFzhsqJE4rajJfCdja3wnYWRCi5CLHt68LCxoCReIiRA4KeLT/CRtL3hiZUi4Ky/SeC3invwnrqMVfCRjLAuIj8iCgZCBPCQlJ0KN0I18JG/njzgqp7wkaCwUyXqnLwnaCdcJC7wkYi7JFPgtIskPeGzg8i6yLoucygm4Y6Y4KqsPScKKkIoIT3wm4WSw5RsNTov8JCUvfCfm6LwkbS88J+Prirwn6KacCc+0ag9NAosQio64KuL4KmRfvCRgrXIuu+sqXvwkLOi44S4Mz/gsaHvv73wnZSvPeGzg1YKMUIvLOCqsmgv8J+In1wuLmbvv73jh53RqC9pOuOAqvCeuZ9k8JC0sVYl8JCZh+Cqj3wKC0IJyLok0agk4b28Ci5CLDrCufCWrZIu4oGYWGDvv708T+GJmj3wnZK7PWBjL3PgppBz8Jatljvgu4o9CgtCCcOPKk9o4LGdRAoCQgAKJEIifTrwkJ6CJmHwkI2nPDrwkL+CTeKAny7hqpPwnYaTQydzewoSQhAuKihcYsKlM/CdlJY/4KeNCiBCHmjwkKiZemHRqDzgrZUv8JCSqS8zJkXgtYbCoWBMJgoqQijDhXvwn4KnRO+pvC8pyLon8J+VtPCRg5YyQDo88J+VtMOzP+K2sD9FChtCGfCdi689Oj9H77+98JOHrPCbhaVVLsi6eioKK0IpUPCflbTwkLm88JG0iVxrw53gs4baoipRMy/wk46VJ/CdlL0g8JCoukUKCEIGesKlwqU9ChJCEDp7fjow4KeL4aCL8J64gG0KKQoEbmFtZRIhQh/wlrmRSOGksF4l77+98JCSuci6XPCQq6AmZVwxeytgChUKCW5hbWVzcGFjZRIIQgbvv73qqYcKnwq6AZsKCvsJCgdjb2x1bW5zEu8JsgHrCQoCQgAKAkIACjRCMk/gv5jhvZnflXdjPXvwnoC28J6iq2sl77+9KvCek54vcCJTJe+/veK0njsq4LmU4Yq8CiRCInnwkaS344egPCU/8Ja8quqvpeCttD3vuJnwn5W0cipgYH0KO0I58JCmhPCRpJV2PD08Iiniv7A68J6fuF5n6qCSXOCvhy/wkbCG8J6Ai/CfnIngrYwkYDAvfOqrrD8uCjFCL07wnrqmMzrvrq5W4oCVd+CsvFIkKvCeuYJQP8O3PTwvTj/guoRRw4R7L/Cfgq06CiRCIlbgu4Y6wqV1MifwkJOsSuKDgGQn4LOjIjrwn6um0ajhpZwKH0IdLyTqqakiXPCQoLcmaNGo8K6QpfCcvYMk77+90agKEUIP6puYbPCeuIPwkLmkwqczCjxCOvCdi47wkKml8JKTsvCRi7Dwn5W0XFcu67K48JGNi/CeuKLhvblcS2A9Ju+/veG2vyTgu5w/e9GoUDQKEkIQN1PhoIjRqErvv70i8JGBvwoUQhLwkKCEPTov4KuN8J64tnsvey8KCEIGfT9177+9CidCJSQu8JCOjMOY4aeYWX4qXOCouVJl4LC4L2I94oGOJiYkLn1pKiYKBkIE77+9Mgo+QjzwlquX2YVEPHvvrbngsLZecfCeuZIu8JGptMi6JOC6hvCRsb/RqDolLCXihbTGufCflbTwn4Kr0ajigYEKIEIePiQiKlwuUMKl6p+V77+afioudcOSPOGnl3vwlqaiCitCKSQ8J1jjh4hLwqXCpT11U/CQjqlYPO+/vV7gsYY/QG3vv73qpqMi4LeWCgtCCXsl8J65nVMhUApCQkDwkpGI8J6fqNGob+GPuyLwnrmx8J+VtOC2lPCflbR6JeCvh+OmjeGJi3vqp6w98J+VtPCeuKLwnZm5PeCshXh6ChJCEPCxn71hc0vgq4s84LueyLoKK0Ip4rag4b+a8J+Dgnvgs55SPGXwnqSq8J65h+CorcOA0ajwnpOj0ah5JWoKJkIk4aqQyLoww5nwn5W0Zjwi76iH77+9L0LwkbCC4Ki2JPCQhpUvCjZCNOGdsvCfkr4q8J+Ine+/vfCRv5siXOK3jC7wn5W08J6Cj2fwkI+SJ+KJqTQnwqVV8J+JkDYKQEI+8J67sS9kJCrwkLOcfHvgt7Qg8JChmuC6n/CQgZs2YETwn5W0P/CflbQqJNakwqXgrq/gt5Z+L0c8fT3igqIKHEIa4aKUwr88WOGloPCdlY7wkZyUWfCflbQvRn4KPEI6e+qfkVrjhJMuPHMkYCTOiPCQrYTwkKCZ4K2VPFzhoIPvv715zbt5PFLvt7/wn6yg8JCipyQn8J6FjwoCQgAKJEIi8JGkj/CRjKU6JDov4LqC8J+rpO+/vSAv4K2WatGo8J+rtwojQiHhg41CKuCxnTwrcPCRmIJbJVbgspBDLjritrgy8JapqV4KCkIIP/CSvqThhYsKNkI0bkbhvZ0uIuCxhOKRg9Go8J+VtPCflbQm8JG2kOCmkMi6JC57VT0/JeG9ncKlcvCflbQ0NwohQh8nJPCWq7Ik8JGDti8n8J66lc+iPnt7VuGhlj3wn6GSCkNCQVw4I0hgw7/wn6Kx8J65pO+tgfCRv4bjgaTwkIerOT838J+BlPCei67hraBP8JGbg/CeuKTgvYDwn5W0QyQnYMKlCgoKBG5hbWUSAkIACg8KCW5hbWVzcGFjZRICCAQK7AO6AegDCvwCCgdjb2x1bW5zEvACsgHsAgozQjHhqbQvQ3N7PVThnYnwlqqZ8JGkt/CflbRB8J+VtPCRiovwnZKs8Jy+kdGo8JKEi0YnCg1CCyd5JTxe4KGn6q2oCihCJicqe3tc8J2GmfCflbTwn5W077+9Klg3eDvwnrm68J6lkl404b2VCi1CK0Lhvb3wm4WVXCI9J+qvuSQu8JGlli7RqFxo8Jauii/vv73wnrmRMeGPjVUKMEIuVj9K4aqt4rWw4Kef8JG2kD3qn5cp77+94LeKw6jwnqC64oms8J+Cp2/it4QrJgoyQjDCpfCfooNtTWBcXEo26qyD4bKo8J66qTxs44SjPt2V4KaL8Jy8q++/vSlI8JCyjmwKD0INYyVL8JG9lvCRpYDWjwoCQgAKS0JJ8JCepyTwnqSM8JCzslzguprRqPCQp4vqn5nho45c8JCghFzigrDqp5bgorU94b+04b+I8JGkt/CRsYFo4oCxOS9gJ/CflbR7bQoFQgPhvqMKCgoEbmFtZRICQgAKWwoJbmFtZXNwYWNlEk5CTGjwkaisYPCei6Dwn5W0PfCRjaZcPz3grInwnrmk8Jy8iO+uu/CdjKsmJfCRpJLwnYuhInIqIlHCufCdkrtk8J6Ao/CflbQ6avCRjIAKqxO6AacTCpcSCgdjb2x1bW5zEosSsgGHEgouQiwsKmDwn6KHJCTwkIuEJ/CRiqIvw6nwnrqJMD974pWkTPCWqanhjJLwnZ6wYAogQh4mYPCforDCsT1WPCQ9N/CfoqBLRci6JlJU8J+vsj0KNkI0J/CRhbQoeknwmLSCJSLhiq8neC4t4K6kSi3wkYqIeeCmmC7vqb9vVVLwnruwY+CzqOCsswolQiPRqNGoU1wp4amd8J2ZlHtMXOOAv/CSlJQ18JG0v/Cav7PRqAoIQgbwkZmBfCYKDkIMJnHRqMKlXDhMbMi6CjBCLuGlskdn77+976yrIjokIk/gqYHhppbwnrmXOnto4KqtIm7cvvCfqbXwkKSwPF0KD0IN8J6fpci6bS8mIkVEIgo6QjjwkKOrOibwnruw4La977+P8Jappivvv73qqZJxwqV4PC57OuqsqCpISDrwn56ycELwkKSSa1xWKgomQiQ/V0DCueGwsfCfm5zwkYuX4rSnRiQlfSouIvCRjIDwk5CDOlwKEEIO8Jarp+CunPCRkpwu0agKBUIDImBTCgNCAUUKEkIQ4r+04Kakd/CQp4098JGFoAouQizhs50nKlzwlr+x4Le04rqPL+GWjCnhkIcrImQlbV/wn5+wPPCQoLzwn5+pIgo/Qj0i8JappuGgrCvwkJaVwqXRqGA8JCJPwqVg6qCG8J2Ely7hgozwkYqIXCnhp5fDiTzwkYOVPSfhiZjwkbS6CgVCA+Czlgo5Qjfqn5dcIvCQhJrDoCDwkKuF8JCVoy8n8J6KknB4PcOlLuChvuGaqUYq8J6llcKlMfCfqoMx44W2CgRCAtGoCi1CK+GKlX0iJPCflbTwnrmfPSJR6qa14bOyw4DRqPCRqKJh8JKToiovc/CeuZQKM0Ix8JCAneGPpCXwkLyn8J+VtPCQqbtb8J+VtPCdm7TwnYiK6qCs6qml8JGEhyTgt4oiJAo0QjLhvbzvv73hqIYo4KqN8J65iWMm4oGw8JCeg+CotTrhqqLwkJa8euGyruCuniIl4qSjPQocQhrwnrqm4oKHOm3qqK5I8J+VtPCQgYUkw5M8TAowQi7CtyYiaU/RqOqfkeCxncO6OvCdi4h7OlthWCdl4LW5b/CRjYcpJPCtkYPwnrqSCi5CLCbhrZB7Zz/CpS/grLJB4LKtO/CWv7HwnrmHLn7hvLkmw5Lqm5Vy4aWw4pGBCixCKibhg4dge3vDoSc/RvCSgarDqmDwn5W08JaqvsKwLnLgr5fvv70i8K2ntgoDQgEqCgNCAVwKLUIrWDHwnZWP4KCLL20uIjxcK2kkVMO2KeC3niVmw7fRqDwvKid3ZtGo8JuFkAo+Qjx74Ki8KvCflbRXJmbqp6k6ezwo4bi06qeY8JGLuSZM8JGMrPCRqpnCpWXNvuC3rsOo4KuNJTbwkaS3Ln0KI0IhfCbwkb2IKlEl8J+CoO+/vV17wqxXbDom7Z+FJD1jKVotCjpCOFjgsZ3wkIOt8J2RkfCcvZDwnam477+9JNGo4LeD8JappvCforHDizNg8JC6sPCflbTwn5W077+9Ch9CHeK2ofCeuakkP3t7Ksi6YMi6dzbwlr6SLnvRqMORCkRCQvCeubnwn5W06qWjPyxTPD8/4LeGfOGdstGo8J6LqCYmwrPwkYuxyLrCufCbhZXwkaS34oK18J+iqfCdkqpQ8JCohgoPQg1qfOCuqCsnKuGkuz97CjdCNWDgt5bwkKCA8J2EpfCRmYQ6766d8JCinGvhvJwufjI9XPCdkqZgIsO08J+VtPCQlrAl4LGMCgNCAWIKB0IFJfCRsIMKPkI88JCojExg8J+qhDgmb+CujvCflbThpIRc8JuFkOqsgWDgroPhoItWLSThvrDgoq/igIbDisK74YmU4aWAChRCEvCQpKo54LKE4re4wqXwnrqULgoNQgvwlJS3J3Z9J+C5lgowQi4m8JCSpuGxhCLtn6AiWXNbwqUuJirDvMK9LvCflbQm4Kit4KyGPT0+WkEn4aioCg9CDUXwn6ub4raq8J6An0cKG0IZ4KGm4aS4PSLgp4tSYC5h8KufviRyyLrIugpFQkPwnL2vPMOX8J67seKihCYl3LpI4KaP4KmRJ/CQsK9KV/CdlIo9R+C0jkp5b++/vPCRvrDRqERid++5qV/wn6GX4aqjCg9CDSRX8JC6hu+4ofCehY4KOEI277+98JGNkPCQk4xg8JGygyIm8J2SouCovCU7Oiol8JCtn2DhjZ89yLrgpo/RqOubkvCflbRbCg9CDS55wqXwkJOgcfCRqYMKDUILPVx0Kz3RqPCeuaQKFkIUP/CQlp1cOVwiVvCQhpt276mBXCoKIEIeO++/vSHqn5ck8Jars+qnklrwnrmiXO+9smDwmr+3CiZCJDVVeTbwnYuP8JGymfCfiJXCr+OFs/CflbQ68JGNiCfwkZqBRAohQh/Cpe+/vfCflbTCpS57Jyfwn4KmIC/wn6G6Ij/wn6u4ChBCDn7wnoCmQ+CzsVLwkKmzCjxCOiDwm7KYKkngtoMz8J+VtO+/veCrjfCRmZLwnZWf05xnOi7gsYdUJSrgsKBT4YKP6q2/4LSrLWbhs4YKVkJUWWBM77+9ZuCpjOC2guqSrT3wkb6w8J+JpCRh8JariXnwkI2C4KG04rSnJeGlnfCQj47groI/4b668JCtu+KjpvCWrZwn4KqG8JCyjPOghp/wkKC8CjJCMFzwkYS+N8i6PCdhXOqfkEjguoIqWCXwkbCKIuCrv++tgfCRjYzgqKol8J+fsOCoswo9QjtVJfCbh6bwkYaxYOC+imnCpeGLlPCegKp68J64u++/vXElM2fgtqFF8J+VtMKiXFpV4Kiy8JC/hMKlawoCQgAKMEIuP+qmsXHwkbal8JCiiybIunki8JGMi++/veCylk1uey/wnoKPXCzwlr6T4pGKJgo3QjU6dibwkICA8JC8htqUw4vhiZgmw5slU0vguZLwkKSFLuCqkcKlLuGLgOGzhj8g766z8J65mQpBQj9t4Z2z8JG0tCQl4bCM4LKQVeK3hW7wkbaU8JC0gTXgq73wkbanMMKla+CugsK94LSP8JCDriV5Olo5Vj/hmJ8KUAoEbmFtZRJIQkbgq4d3ZVXwkKicw5klL/CQi4pJJzhlwqXwkYeMOOqlku+/veCqnjR5yLpc8JuynvCQtJ7gqJDwkYSARsOo8J65nVHwkbCGCjkKCW5hbWVzcGFjZRIsQipMTT1sPEXqnI0kJD/gr4bwnaqj8J+VtPCQtItn4KygUeGqguCnl2IubTwKhQO6AYEDCqcCCgdjb2x1bW5zEpsCsgGXAgoxQi8qcDAvJfCQlY/igIPIuirhv7pX8JGZkVx6JknguqV38JGNoOGJmDx94aWAwr0/XgovQi0vwqXhib5Zw4zwnrmU76yUey7qn5ku6qm+8J+VtHsvQjPwn5W08JGmq/CflbQKJEIi4KOAKiJ68J+VtPCRtbnigqZse++5iT0kPPCRvYfIuj9BJQoZQhd7J0Xvv73wkZyW8J+ut/CRqatc8J2HgQouQiw6KiYlPz0/4LuVL2A94KyzUe+/vfCRmaMu7YekL/CeuqfqnqDqr7DIuuG9ogoNQgsv4Kiqcy/wkLqbaQoXQhXwn5W0deGwj++/vS494L+O0ajCpFsKGEIW8LCbvlzCpUg2fGDgqZFeJ9GoJSciOQo0CgRuYW1lEixCKvCRnKgvYzo9XOC9ozxHLz1gb8i68JGMh2pEJVzwkIu40ajIuj8h8JartQofCgluYW1lc3BhY2USEkIQe+CmiPCeuKHwkISq8J+puwq2ELoBshAK0w8KB2NvbHVtbnMSxw+yAcMPCjVCM2PRqDLwkLSg35hmR8OpUPCfiKfwnrmXY+G/rDzYt+GMlfCRgJsm0ajwn5+wSSTgprwpLgopQic5J+G9i+GctXoqUeGknC4o8J+VtOClkSrDnWY8KvCWv6TRqPCRpI8KEEIOXD3IunzigpvwkYGGdC8KJkIkQvCQpL/gq4Ui8JCjocKl8JGypzwi8JGlgOCqrz1d4LGi4bO6ChBCDuCtne+/veGbivCflbQlCjVCM1nRqOK0nmhLPygn8J64pCLwkIW28JGsgSTwkIGB8J+fsDkn4Kay8JuFpzxs6paQPz9kSQoGQgTwnrm+CiRCIu+/veCpi+CzjWXRqOCoqvCQqYF7Zzwv8JGcsW8+8JGTkS4KJEIi1o7Cs+C6iSJFOl3hqrwqdfCeub7grp9B4KeXKfCfiYZ7ZwoxQi90wqXit4JgJi9c77+9YX0kZe+/veC6hOqnkvCmvJ1yXDrCpfCRjIF5KibhvZVMWgohQh89OOGlsSPCsfCRsILguqXitpQ6ZvCegKPwnZK74YOHCgpCCHRn4KuNQsi6CiVCIzzhvJnwkaSJ8JeSnDzwn5W0ZfCflbRg8JGkkC/RqMi66qOZCh5CHEU+44e98J66oVNc6qC3LzR7JHbit4R9IPCfgrcKM0IxJy5gKnnwkLSnK9Go8JCMiS/vv73IusOfOvCQpoZO8J65nSfgpq7RqF/wkb+O4aG2Pwo1QjMw8JKQvuKGtD8i77+9O3tWYDZLJvCRsK3wkJW3RuK1r2RVyLrRqC57cjvwlquEXPCflbQKM0IxLDpNZPCRmZDRqD01QuG9meCxlToqVi574LmR8JCBh8OH8J+erzgwPe+/vSE477+9SwobQhku8JG0vTbgu58l4K+G4KaQPy4t4Z2N4KavCihCJvCRiKrwm4WV8JCWlPCflbR7IlHwnZWO6qyWSkxcJHUuKirgqY0lChdCFSbwkKGQXOK2tWzrsbrwkbKvJ2NNZAomQiTwn5W077+9aE066p+34reV8JCGoEIkPSJ7PfCRnL7wnZKe0agKFEIS8JGKg1zwkZqwReCqoD/RqCpYCj1CO+KBsci60ajivITwn5W0fu+/vTvvv70nKuGmmiXwkb+ZeFfigIQqw6LwkJ2FMfCegJ880ajwn5W0OnleCi1CK+K2pG/wkYy7KkbguYPqoYck4YuFyLrwkIea4LepwqXwkYSsPVxcbPCQlKEKAkIAChNCEfCRmZThmrrwkZauMn5g4LGoCjBCLiEv77+98JCHoUvwnZK7YWxF8J+fsCbvuahVPci64KqjwqU9Ue+9guCqkPCRjLMKE0IRdOCrgfCfr7TguITvv73gqK0KF0IVIT7wnrmy0ajCpUTwnrmHKi/wnqWeCjlCN+OEl0t64bOz8JCTjeK3nWbvubAuJOGknFbIuvCQgKHwnoWIJ9Go4aeT4aKbSfCQlZR74Lqh0agKKUInMEslb2Pgr5fwnrik4Kyy8J+JkDpP8JGDt2rwm7KTJmnwkJ2hUNeHChBCDjUn4K+NK+qdtCdgL92PCipCKPCQkqDvv7198KuesD/wkYqN4ral4KqiZeCriS/wkKumwrbwn5W0PXsKLUIrQfCepK5r8J65l/CQk54mWu+/vTokJvCeub7wkbyVIi7wkYSF1qdR8Ja9oQotQitn6p+TPeGdjjDRqPCRnYQqe8i6aPCeubvwkI6AeSfvv706fE3gqZHIuiRCCiVCI2Am4KeH6paBMVwlcC97w6N7L8i6JOC1iz/IujFffSIzYMKlCgpCCG94Uj08PSdgChVCEyo64LuNYmVg8J+rguCrusKzYGsKDkIMyLrqrI1FwqUgJj9SCjxCOjt98JCdgvCQlpTwnqKQPOGNs2jIuvCdkJdlImDIuiPwnrik0agz8J64ti/gtYgqw5PwkaSN8JCBgXoKH0Iddz3RtC4qwqVm6piQ4Ymb8JC0smDwkLSyJfCQlrUKPEI64LuMyLritZho8JC0oOGdq01g0ag8IDcvLi7wnriiPfCWq4F7Tsi68J65pPCRsoTRqCUiPcKl8J65ggoqQihcbsOIT/CeuZck77+9fvCdvKlGTCfqqo5qPz8/X2bgqILDoFdj4rifCkxCSiEpK8KlPfCRvYfwlq2Zw4bqoLTwnoSd8JuygSrwkKC8fGLwkYqS8JGpgeCnhFxW4K2H77+98J2UrWg64LOH8JCWuy7gprjwlryDCjZCNDLwkbGyw4In8JGypPCSkbLwkbWo8J6khvCdqqM9JPCQnoNv4LqN8J2LqOK2q+K2oO+5sTkKIEIeU/CbspTvv71DUeC3lvCdqKN78J2SqXEqP1XpuoZ1CjRCMu+5tDphyLrDrO+ukuC/lNGoJn44wqXvv6570agm76eSPfCRpKnwkaSEXGB2R8OL4Yq4ChdCFWBYP/CRtojwnoGo8JGbhSQvP1w/JwoJQgfhpJfvv70nCjBCLuColCAmXzc9e3tC8JGcnmrhv7fwkYqFe+CrkCrDv/CfgJffj8OnVG1aQeqvtGsKDUIL4b2pYzwkOm09eSoKP0I9PO+/vfCbsp7wlq2pOk/vqprDrzHiv7TNvOC0hPCRkZ8i4Ki1wqU+8JCiqvCRh4Bc26jOleCxr+CrguGJnAoLQglY4KaQPvCqqLEKA0IBJApJCgRuYW1lEkFCPz/wkbKMYyXgoarvt4/wkJCd0ahy4b2iUi4qJ2A58J6fs1DhvZ3Iuu+5qScq4Kqs8J6FgGPwn6mz8J65lC7RqAoPCgluYW1lc3BhY2USAggECusUugHnFAqnFAoHY29sdW1ucxKbFLIBlxQKAkIACgxCCj3wn5W0OuOChz8KDUILP27gsalTe+CunDwKKkIoLuCovD86JipYP+qtpPCdlJzhnbLslofhp5XCpVxhwqUv4KuD8J2HpQowQi5ZPWTgqLM96p2E8JGHofCbsbHqr7l7IDvIuvCflbQiQCbwkaKn4K2nJj9Q4oWrCjpCOE1cKjrCpfCbhLIqwqlMN+qjmfCQlrTwnqWV8JGpgSfwnqKYOeCmq8KlIeG9nSVHXD/wn6+x6pKVCihCJvCRpLjCsDzRqCp+PtWR8J6ln3x7J/Cdi6EmZiXwkJ6z8JC5stGoCg9CDfCRg7DhnbLwn5W0Lj4KOEI2dSTCoNGoWkFO8JGjiC7vvIvwkJGCJ2BY8JCkv/CeuZTCqkjhjINc8J65qcOEfuCwmPCRp6E8CidCJeGsmCfwkZmRXuqhhuGNsFXDrPCRgq4/8JGkjDrhv4rwkZyOyLoKIUIfXPCfgJMswqVtYD998J+FrOCxvvCQiqNQ0ajihZlceAopQifpgIBk8JGckFFGJSbwnrit8LCylmo8e9Go8J+mnCTwkLOvPPCWqZEKJkIkYyLwn6GhZiI8SOKBsElNYCYj6p+T4K6P77+98J6fvS89bCUoCjZCNDZzIsKlw45caPCRtpAm76yDwqU6KjrhiZh18JGDueCsg/Cfm7xQwrzwkYydMuqYnvCRtpEKKEIm8J+bszo277+9Onxw8J2Suci68JG1oSrwn4ONOic/NOKApPCQqIUKNkI0S9GoK0rwn5W0JvCflbThiZVJYDzit6QiKjwqw7zwkKCFLGg977+9PPCTkYQ8cNGo8J2MjgoFQgPgvKsKFEISL+GLhVPgrI8qRz9LPTbwkYWWCixCKnrwn5W08JKSoDXwnri2JOGBkF15JPCflbTwnZKlNlwp8JGMs++1iuGKlwoNQgtqUVLCpSUuWz0nPwokQiLCuu+/vci6w79z4LG84LaMPeCmrVw84b+zIvCRjJvwnZK0CglCB8i64KmeSDwKAkIACgNCAVAKNUIzwqUn4LqB77+94KiCPPCRpqXwkaSP4KCy4K2N8JGKhTfgsYck8JGgnu+3jyglLiY84L68ChJCEH3gt5Ze8JCWp/CfrqfIumMKHEIa4LGVIi8mfPCRtapK8JCSoVbwkK6a8JKRsC8KOUI38JG0vci6buCyj+K6lTrwn5W08JarhF/vv73is71mJCUmTj/RqFxIUUbjgYUpe1DwnZWG8JC/qQoOQgw1Si/hvaYkzodqJy4KBUIDJV09ChlCFyrzoISzyLp5L/Cdkp/hv5rwnrqiXMKlCglCByQkPeCxlUAKGUIXw6Qk8JGBmuC+lvCTiLVROuKbiuC2vXcKLEIqJfCQrZou77mkw4tOw7vwnoCbJC/wkbWiIzMpwqVALcK2ZDMm0ajwkISBCktCSdGoMO2fmuC/miZI4oCiItGo4KyzIuC3n/CQnrZC8J6Ag07gqLJG4LGqwqVB8JuEsjEv8J65jy/wkIyNwqXvv4vgsIXvv73vv70KB0IF8JCPiS4KBkIEJOCsiQowQi4lTHvwkaC54aWWYFRcLi9oK1E94L+EQ2Xwnrin8JCqiEYqLvCRnIA9e1jwnZSICgRCAjBcCjdCNT088JuEsvCeuKzwkaCpWmTwkLqrLz7wsKK8wqUvKMi6yLo8WyjwkKyE8J2LoiU88KqmkidcCjJCMGwuJ/CeualK4YqNffCRsrHwn56/J/CflbQ26qif8J+qv/CeoJjwkYyKPdGoXErIugoUQhIjXDrwnriZX/CRkoQiL++/ozwKLEIqTCXgrIFSaTzjhaBfKn0k8J+gpPCfm6bRqDbguohFJfCQoLd74LeKP8O+ChpCGDoz4YSCaeC3k8KkZj8/UPCeopEnL0EsIgoPQg1YR0Xgs5438J+JpSZdCjJCMEzCrllm4Z2gwqXwkbaRJvCRsLpMOPCQi4bwn5W0ZSfwnoCE4reMw4xMP1w88JCkjQokQiIiNHXgvown4rajLy8/W+GdiPCfnbVcJGBH8J+Jhy574aSxCipCKF8kT/CflbQ/KTps8JCWijrwkbWjN/CflbTwkbCX8J65nfCbspDgrLUKC0IJP+GNnfCQv6p7ChdCFeC+ue+ss3jitqTwnYut4rStwqUvewo3QjVaX3IyyLolYMi64LGYJMO/8J64rOCtnOK2tuGJneCykCRWRnokJi/wkbWn6qOS8JCouOG9lgoHQgXwn5W0JgotQisqU37IuiVgJe+/veCzhybwkaSm44a6Yci6XOCrvCc8w4wz8JGRnmkqwqVmCjFCL37qrLgk8JGMvWAmP/CQnp3vv73wnrmUJ2pG8J+djfCeuZHwkpKG8J+uoOGojSdJCk9CTUpVfj8/8JGNpuqatiHwkIGD8J+Mh/CdnIgn4K6fL/CQurHwn6mrIy7Dm/CehY7wn4KjIu+/vfCegZAk8J60pOqsiy7grojwlr+i4LaTCixCKjI20ajwkISA8J64pypcP++/vfCQv4g/JTzvtqLDnCbgs4fwm4SyXGLRqAoRQg/wn5W0JPCRirfwq6KdJ1wKJEIi4Yq+fVw+P/CRkKt1dfCdgJhmJuCpkfCRtLopZiZF8JCNhgohQh8/J3Pwn5W00ajRqCwiPFzwkYOg6p+W4KyM0ag84aaTCjdCNfCQo6HwkY2H6q2INTrgp6Dwn5W0w7QjIPCfgrrwkISAPCYk8JCphjjwkYiHw4slIvCflbRgChRCEi/hipMl4b+d4Ki54am0P++/qwosQipc8JCggS3IuuCmm2nCpSRe8JGkuOCokPCRioVFw6oyJuCsmHTNv0AuPCoKIEIeZ2zwnZKI8JCGl/CdjIrCo++/vSomPeqsoPCflbQuCjRCMvCRmZHgsZg/8JGMj1x74oKI4Y+O4LGCee+3jzNg4LOHTci6wqVi8J65nyXwkYyBeSM9CjVCM+ChlD89Uy7wkaC4YOCquCZc77+9P9Go77iK8J64p1rgs4vwn6mj4YyoL2VI8JCAhWs4YQoIQgZnOvCfoZMKDUILP1LwkbSJyLokwqUKO0I5XNGo8J6frvCflbTwnrmX4K+B8JatnTrwkKC8difwnriiJeGsg/CRk5Up8JC/rDhpSEg/wqXqrKFTCiBCHmDwn4KrM++/vXs/8J+qkkMnPy7iu7Phn6dHNeCqkAo2QjTwkI6U4L6WXMKl4KeNPSIr8J+VtEw64Kyz8J65pCTwn5W0eybwkKS/JOOHky89w7LwnZWGCgxCCl8qO/CflbQ2Oi4KJEIiJe+/m3w8JuCmsnoyU+G8s/CRjKF78J+VtD7vubFgV+OHgQoDQgFECihCJuG8mu+/vfCQqotgU8OZ8JCplfCRiKglJPCflbTIuu+thC7wnrmfCjBCLiXwkbGzwrDwnoKPZVw9J0hW4YmyIjbwkKKA8JC/o+GkoOOGmiIl8JCWuOKBsC8KKgoEbmFtZRIiQiAnw6rhqbwl4L+CL0Uq8J60jmAz4LOv8JCnkuCnh8O5MQoPCgluYW1lc3BhY2USAggECu4MugHqDAq6DAoHY29sdW1ucxKuDLIBqgwKM0Ix8JGxt1Qq8JGBoz8i6qyLQ1tv8J2NqcKlXOCog+CwkMKlVzp8Jy7Cr/CeuKQ88LGmvgojQiFa77i26p+VPT97KvCnuY04aeGnsjjwkYqI8J+VtPCfn7AKPkI88JCWiPCdlJI6wqU/Xzoq4LuGTO+sg3vhqZHvv73vuasm8JCdpHLwn6uFNeK3g/CehYdYUfCWvZJBJTguCjFCL/CQgZ3RqPCdvKfqqZjgsY19LyTjhbbDrj7wn5W06qmYKOGcgOqSsvCeuLLgrppWCi5CLPCWv6Fw8J2Vg+K9uOGllHsn8J+ipCpiJCUmeyIrLl7wlqu0fiLDjSXgtr1DCiBCHvCQoLwq4ZuxImBTPOCugmBb8J+VtGAge+CpgO+8vAoFQgMlPzoKMEIuOC0v8JCtpCZgyLrwkJ2n4LGNXz8k8J64ouG/liZ8YCrDqVou8J65u8Op77+KVQo+QjzgqYdURj1l8JCnuCrDuvCRtpHIuuC7iDzIuldgVSskPV0qJ/CQpIw577+98J6ApOqgtuC7iD168JCNuCIKREJCbXjCpfCRrIFk8JCguHrwn5W0w7PwkYql8J+VtOqomUQ88JuynlPhj7tgyLou4r6H6qe08JivnfCRsotRLmThvbtwChdCFXPhrYHgs69tKl3gqZrCs1DwkbaYJAorQikzccOT8JCKmHvwm7G88J+VtFfwn5W0JOCrqlzwkYyP8J+fqfCRoIY8KAobQhknPCLwlqmKzbvIuvCQs67wkY2HQ8OvJypzChpCGF/goYcqYOGtkEDOiS468JuFkXsl8JGFnQo0QjLgqZHwkbSJWT8i8JCgt+qqgyR7P3rigJ1Z0ajDlOC2vWThqqAlLDzhp5NxLvCeiqh7OgoHQgXwn5W0OAoeQhw377+98JCBgWTCpWDgv5bgsLIkJ3gm6pu00ahoCgZCBPCRqLYKK0Ip8JuKgHHCq+qgsS4n4KuHNXku4KecKkzgsrZEXD9qPMOJ4YK0du+/lDYKBEICyLoKSkJIKvCfronwkaCU8JGyoPCRtZTIuvCegKpK6qmF77+9KvCforAl77+9eFzwkLqw6qyK8JCnqiLqpYN60ajwn5W08JartHYlL2A8CiRCImTwkLOEPi/IujM8JHvwkY2d4LSO8K2UkfCQoIPgsL4sP1cKNUIzYPCQqLhc76yBIC/wkZmZcfCen6vDnnvwn5W0P1zwlqKjLy9aYGDwn5W08JCgsuC+hVt5CjFCL+G9m/CQpIci4bOe4Zq5JSnjhI0/4KiQJWMm8KC5rTouJjQ98JG0uu+/vDpOw7pgCgNCAUkKDkIM77ePXDAkLuGdkDp6CiJCIGlgL0fgppox4b+2POCnlyowPi7wn5W0PmnRqMKl4KavCkdCRdebJPCfgqE/PeG9m/CRtqLhjJTitqXwkpGGVi7wnZKs8J2UivCfhIjwnoKPwrbwn5W08JGmqkknOuGklDxc6p6JRG3Iugo7QjkqyLrIukdFe+CtgyV+4ZuQOvCRtajhpYA8Jsi68J64pGYnXk/wnri78JGAnOCzoiolZOCqq+G9m3sKB0IFbuCskHsKJEIiKu+/vULwnZWPU/CQlrvwnZSa8JGcj3vwkKCbyLpGIi/RqAo6QjjIuvCRtZciIyTwkZKs4L67ZOCylCJ74byi8JC/hWLCpfCQhpAl77+9c+qhoeK7scOFXOCukO+5pQozQjHqnKFg4oCU4Ki144iW8J2UvPCeuZQld++/vUrIusOv4bypLuC3kiU8Ji3hnocw4Yq0CjFCL/CRsILCpdGoMu+/vSfhv73wkI6NbGDgprI6e+GJmio78J28pvCeubLvv73wn5W0ChZCFHvhrLPwlq2SQD/hi4DqpbdDQsKlCj1CO/CRoLpO8J2SpkQq0ajwkY2oKsi68JGkiT897Z+64LOKRWAqe8OM8J+IstGoyLpI8J+VtMOmPVwiL8KlChtCGSp78J+VtGIlw54uJVFJX+C6pUQ6TyfIui4KEkIQeykvJTHcn07wkpG0LyrIugo7QjnzoIS8afCUkLLgobDwnritIiRKMU3wkICALkpo8J+VtDoq4KyC8Ja+kCJ9P3vwkKOsbmY2PEQqKkMKGgoEbmFtZRISQhDwkKSkceCvtVovLynwmLSACg8KCW5hbWVzcGFjZRICCAQKyBW6AcQVCssUCgdjb2x1bW5zEr8UsgG7FAouQixx8JCWs3vwkL6zXCzqq7TwkZGf77+94Ki88JCtgOCzrPCeuZvgt4rDoeGiggpBQj85yLpcYO+/jCTwnrmf4LqJeHvwnrmRenU/Jy/itKci8J+VtNGoIvCRjZ/ikJ088J6ih9Go8J+pqmTgq4zis4IKJ0Il8J6ApmDwn5W06q2BJfCRsq8mKCwi1bLwkKSrWvCdlY7Dm0XIugoyQjDigYgr77mXw5Iy8JCWnSdfNu+/ve+/vS/gsKbhqpVTw6LwkIC8eyVAMFsx8JG2lD0KGEIWXOG/k/CQjatDJlwl8JCNhiQz4rStewohQh/wkpKlJuChj+qfkeC7jih34KaQ6qex1o5H4K2H4b2dCkZCRPCflbQ7OfCQv6nwn6uaPSUk8JCdpXU84K6PXG068JapjOqntOG9my/hrbou8JCjtOqpkCI88J6EtfCRp5rhi4Dwm4WRChZCFDZc77+9auG+kSTit57lmLHwn5W0ChRCEuG9pSvDnsONJ/CflbTwq562JAoyQjBBwqVGPWR18JCMilY6JlQ9PPCWv6Ik8J+hkOCqvPCQhpU94Kmy8Jars/CeuYslPnsKMUIvwqXgtZ4vwqVhL/CQq7Fg8JGMgiJPdz8/8JGcokjgqoPwkJOEVjpU8J6lluCovHwKCUIH77mo8J2SogovQi1f4L6jU+Ctpi5y8JC0s+K3lWB+L+GKte+/vfCQlLVkKuKBsFvhj5knay5gS1AKGEIW8JGKgOC2lVEu8JCsqifXh3zgq6EiXAooQiZg4K+XSknDpX1xVD86w4Xgp6Lwn6qW4YuqZyXgrIfDvVpgPnEkcwonQiUvc0tc8JGyreK2tVrRqD/wkYO5XCbgrLhc4o6N6qeWJMK4V8KlCgJCAAohQh834Lq477+9yLoi4rSl8J+Bon3jgKhB4aq/8JCOlV48Ch5CHCfIukLgs5464aazey8n8JCFiPCdpoIvcmPgs68KOkI4Itq4e/CegYQqMi9APWF88J6Lp/CQm58mw7IiQDrwkKC34aSOIsK+77iA6q6xJzzIuvCeuZ/grLwKHkIc8JGNs+qrrHtgYFYv8KmJn2k68Ja5peCsijxgeQojQiHgq4wifvCeuKfwlqqI8JGBsj8/8J67sWw7M+Csg1pWeyQKKEImL2Hwn4Cy77+9XDEi8JORjOGfsVTwkYGy8J+grj/wkJ2k4K+Q1pYKKUIn0agm8JGGqXo8LnMk8JCetljwsK2BfeGenibvv73wn6+5PcKz4KeICj1CO++5ot2sKWTvv71F4aqjfnLgtLgn8JGNpirIuiXgrrA+PHXwq6ykPEnwkJ2lLl88JC9O8J2ptPCfnpMuChhCFiUmbC4u4LGhLsO5cfCfm7Xhg4fgqZ4KLkIsO03wkICz8J65neCyveCpgGBU4Lac8JCgiNGoUj/hqoV777+9wqVFey5LdkQKGkIYaSUnPvCflbR98J+VtMKl0agvNHTwnpORCi5CLFAk8Ja+l3zCuvCQqLQlPyTwn56w0ajwkKCu8J2LkTMkIntN8JisrsKlJcKlCgNCAUwKH0IdLz166qGg8JCpiD098Ja/sS7vv7024by9LyRpPD8KNkI0L8OTXMi6Lzsr4K6eJiTDliTqr6Uq4LeK8JuFp2rigb7wkKuj8J+VtClKYF1cKu+/vVzZlgolQiPCpeKznibIuu+/vSnDvT3Dj3sk4LOiIm568J+VtPCRhqo9KQopQicv8JGKjEPwkLSxejlcffCeuoNFOkBLwqXRqDrwn6qx8JGquPCWrZAKTEJK8JOMuU9Y8JGMgiXwn66L8J2Fmu+/vXjqo4IiKvCRmaThsIvDlfCetIRn8JGTkfCRp6Iv8J+VtCE/PCfDn9God8Oi8JGZpG3igJkKCUIH77+98Ja/sAowQi5nI3zwkJKjWMKy8J64tkbwnLy8Py9P4Ky/4LamPScm4oGAwrVgw6Qk4LKoJFJgCgRCAi9pCkVCQ/CRjIHwmKedayJDPSrwkb2W77+94LuCW2Pgpp/RqDsvw6Mq8J6EmuChsuCoteCktCXguph14KyyJO+/vUzwnrq7cCYKJ0IlJci6OksjKkjRqMOQOjAi77+9LjvDqe+psXvDqOChveCtnOCqhwocQho/4K+X8J2Ul1Lwn5W08JCAkcOp77+9JuC5lQo3QjXwn5W04YeI8J+VtPCen6ngqKpg4Ly7RcKlNVdpYD/vuapBKe+/vW7wkpGd8JChjVshJsi6XAoaQhjwq6WoR+GjsuC1lDkoYOGNpSjwkKmBLj8KHkIc6qmMKi96ICLDteK6hjoiJDxvJfCRjbLwnrinVwoUQhIl4YmT4LGmU2vwn5W0USAiXzIKG0IZ77+9YO+/vci6Tnjjgo06PC88LPCQoIFDfgosQio0fvCeuZI4XFVEdvCdkqrhg4fhu5nOhuC7lXbitqJcXFDwnrmX4La9Ly4KJkIkINGoY+qqontj8J6lmSTRqCl0Lmjwnrqm8JGirmjwkaSWIjooCghCBj/RqOGmjwoPQg0qPzpD0ahvKiJo6qC3CjhCNi5cJPCRsbgnXsi64KuH0ahNw6DivILgravhqqsn8JCkk/CQgYFgPCl7IvCYtIDwkYqL4LGWMgpJQkciJSXwn5W0Wlrwm7Kfd+Gqg/CShbTwlqyZYz/wkbyH0ahg4LK28JGni/CQtJXRqOGpm+KBvVzCpfCQvLfCpeC3tCov8K2glwo5QjcicU/hvZM/eC/wlrqKRkzRqPCRpKBcWu+/vfCtqqnwlq2g8J+ugsKlIiXIuuKlhDgvJvCRsIZgCgpCCCQpe++/vTUqCixCKipSKvCRtoMww6wnS1TRqCfwn5W04b+aQSJ7VHsnLCjwkLSkyLrwkYOBMQoVQhMn0ajwkZecWTxiTVXwkKG3eDhXCidCJSJgMOOGnyozPS5CzpZH8J65vvCeuaTvv71g766bLTHwnrmJYCUKEkIQL2XIukHwkbS84LuG4rSneQopQifwnougYvCbiLnCojMpe0/hiZDvu6nwnZSP8JGEpci6L13OnvCeuZsKCUIHdXsiPS/RqAo8QjrDsD1jciov8J+bnfCdg53wn4CkyLrwnYuEV1w98JuylOGCmy/qq6Lwnp+jeSvhr6Hgqozgqobwn5W0ChpCGOCtnC5SJC3grrHwkYWlXOCshiE/4LOhPwoxQi9l8JGFkC4mzp/guobvrqYiezbIuuCxoS/wkZmo4Kan4LGj4YmMTeqvufCRjYfIugoWQhQx8JG2o+CvhuCun3o/cTHwn5W0MgoFQgPIunsKD0INLiolTj3wnYumIix7YAoYQhZUL/CRi7Pwn6CDLj0vSfCRhYLwn5uyChFCD0A/4b2A6qW1J3Y68Jq/vQoDQgE8Ci5CLG/qrIYm4oSt4Z2yIvCeurFNJzLhtJBjYyov8Jy8s+Crgsi6PdGo8JGouFxgCilCJztkPNGoPPCSgYPgt7Pgq7zCpcK+8J+VtGBH76y7JOCmvPCRpZHCpQo6CgRuYW1lEjJCMCXhoI3vrYTDhiLqp5Twlq2d8J2NqvCegJ7CpeC2rtqoTShddCXCpVfwkbCD4b+7cAo4CgluYW1lc3BhY2USK0Ip4KWD8J6FhMKl8JGNsErvv73iu5Eqe+Cqg++/vXVy8JCui9Go8JCegikK6Bm6AeQZCvEYCgdjb2x1bW5zEuUYsgHhGAoiQiA64Y+6w79YJybwn6GVV++/vci6w4hAR+C2vfCflbQnegoWQhRP8JGqleGqmUFzYzPDrG06Sci6XAoUQhIiw61g8J2QhyPwn6e1wqBSJHYKCEIGIvCfoZF8ChFCD/CRtpHgqrdNayZIJj8qKgo3QjXgrrc877+9XOGwvF5ML86GZvCeuo7itqYn4b2dMjTDrvCRp6F76qeM8J64guOImsKl8J64rAo2QjR7LtGo8JCGlSXwkKOg4Yq80ajRqDzIulk8KuGnrSTgq6J08JCeglx1VfCbsp9IYG5FMCUkCgZCBDdvNk4KDEIK8J+isXFGdci6LwpFQkMm8J2QgC89XCU9IvCQrqwu8JCjtPCRpJ/wkaS38J+ro9GoWNGoXvCeuYnIujritIQ88J+rseKBh/CQlp4l8JC/sX0vCk1CS/CWvoIlKvCWqabgt4rwnZWBSj/wnoqU8J65osi6Oy8u8J2Lp/CesqLvv71v8J2NovCRg4Bc4aa8yLrwn6u3OvCeuLvwkIC977+9ZQoaQhgm4YuF77+9JOGJjWDCpEHRqHDwkbS6UT0KEEIO4oKVIfCQoIgvzoxlPyQKKEIm8J+inH3Co++/vfCRgZN38JGKiu+7q+C2iCYvQF1NL25H4KiiPEgKOEI2wr8lJGDwkYqm8J+VtPCdkprDl1Hhipwq8J+VtO+/pfCRpLjhirNs0ah7PWrwnriZU/CRmatoChtCGe+slOCwkPCdkqLDmyU/SfCeuYfwm4WROmMKFEIS4bOAdOqoidGoKfCek6DwkIytCiNCIfCRjbDRqFw4PfCQkKzgpbR7KSpRJiLwkKmFJDon8JGMpApCQkDwnYurI/Cdkr7wn6qc8K+likUkdPCfkqnwn5W08Ja8oiDvuKVcXsOz8JCghWDDmDxG8JGEpeCsn/CQoLgr4L6bCkNCQWAqP/CRp6Jd8J65h+qojuqXruG/ueG+ncKlT3ngsILwkJWz8JC+geCgu++3jyfIuvCflbTgtKvwkYys4KqDe8i6ChZCFOGDjSfvuIPwkaS4QD1dbMOs4KyFCgpCCCMiJ/Cfno1MCgxCCvCeuYtn77mpwqUKLEIqKsOL4rSt4LWLYOCzh+qqtyXwn5W0yLo9aci6K+Gklj3CpT/vuao8JzolCg5CDC7grpw/8J+VtCZgbwpIQkbwkYyB4YuAYCc38JGpuNGoXFzwkYyLdFok4YqD8JGGv/CQs4jwkZKr6qCK8KufgSbwnYSJVuOFs/CRi7Dvv73hv7PwnoCTChBCDkLgrqPgtYZc4LKy4oGwCjJCMCrwnrmX8JajlcOm4b2Jw5JbJ/CQgLkq4pGE8J+YpfCdoIY9O+KFrycrOuCuvlgqewodQhth8JGMskjhpLHwn5W0a9Go8J67se+/vTF3PyUKJEIiJUXwnoCW4Zys8J6jjyZZ8J2GgtGoPzo6w7fwnoKPX+qitwofQh3vrIXwnZK/8JCAtHHRqDzwkbS68JG+sC86TCrfgQoSQhBVaz1C4Ley8JuFkvCfq4Q9CjBCLi5v4oG1Myct8JarhfCRp5938J65mSTCpTvwkaSJJPCRtLrRqOCziOCqtTrhpZUKEUIPRUPwn6yr0agv4L63Q3BtCghCBiRc8JG0iAo9QjvwkICN8J2UmM6M4K+L4rSnSCTwm4WR8J65lzzwkYOx4K6aUmos8JapofCRpLg34ZuNOfCRiIN9KlwzPAoRQg/wnZ+08JCWkfCei78/VUIKIEIebe+/vfCdi4oqRl99UPCek5Twnoum4raqWT/wkKO0Cg9CDTgnPjYm8J+VtD4/ai4KBkIE8JGDtAoUQhI88J6Ao37hiZglcT/goaciw7MKE0IRPVLvv73CpfCQjLg9YOOHtn0KEkIQ6qyKbfCfoZTRqD8977qnIgoxQi888JG0ksi6w4Ul6qyB1q5u8J+VtColOvCdh6bwnpOgwqPgsZjwnbyL4aKZ8J2NtQoaQhjwnqWeyLrvuLTwnZKp4Z+mJ/CRgr5gwqUKBkIEJ9GoJQoSQhDwkYW04YuK8JCouWDhnIYkCitCKc6W8J+ghPCRu7dz4bGOcvCSkrnitIBYyLo/POCnnPCdlIrwlqqU4Ky3CkRCQi16PiLwn5W0c1xAyLpHJlbwn5W0O/CSvqpiJvCQjYfhpKQn4KmR8J2SqcOEP+KAkvCflbR74Z2kX/CfgLTwkKuRWAoDQgE7ChpCGHt48J+VtFxcw7TRqCritYjgp7XgqLlNKgo3QjUp8JCMnnDwnrm7KeCsino68J65lPCfm7rvuKHwnL+C8JatoOChkzHwn5W0OuC6gSEi8JarhAoCQgAKRUJDQCUkJiR7KtGo4Ky90ajqo71J8J+VtPCRtpPwkY2Q8JC+suGJnfCWvLnwkbC8RPCbhZVA4L6a8J+VtCPgpq7wnaisagpBQj/wn5W0yLoq8J64pPCQuq1S4LGEWOC6hPCQqLg/4KGQ8J2VgfCfmILwnZKm4YyUPD864KifJPCRjY0k17DgvIgKO0I54q6G77+94LCILi/wkKiWwqUmJOqrpvCfqps8Y++5qyo9fe+/vWgrPy4m8JGNsT3wkKi4OkDgrpxHChNCESTIuvCflbQ/Ly46c/CWrZY6CiFCH/CeuLbgs6AlR3Pvt49gQu+/qHrCrCXwnZK78JCUjDkKEEIO44WpefCQv7Dvv70h2KQKL0Itwq57wqUofSrDmuC3j2YnUEvwnrmN8JOBjCfgt5F7YzHgqoI9PUrwkbaT4KeICiBCHidDe2DgqoNW8JGmpkjgrYTvuIJ14ra+44GPRCDCvgobQhnDgci64KGhIiZDOiIuPyfwnrS94byb4KygChxCGsi6fEkqPNSzNSJUPG/wn5+lZHJ0TuCruiYjChRCEjbwn6678J+pqfCWq6zikYJvLgo3QjXRqHs94Ku84LSAYPCdlYMn4Y2scPCdqp3wkZqbMnXitKdNMDUm8J2VjtGoQEfCpO+/vVJ4TgoGQgTwkLOKCiZCJFVvL/CbhrIiUnvhjaHwnZKePz3vv70/J3tMSCR78JGno+CzlQoJQgfwkKC4TTpkCiRCIuKDqD3wnrmZPWBcNvCehY9w8J6Cj1w8LiouXPCflbTitrEKPkI8Q+GnmEkkI/CdiJ0q8JGNrDzwkK2OJSIqLjRcT+++pVbwkIC88J+VtHRZYEVU8J6Cj/CfoqhO8J+Bmz88CjZCNHvit5vgtKbwkYqZ8J+isfCeuLvgsYTgs5Xvv7174LCzLsi6LXbwlrmJdfCdi7I8Ku+tgDwKGUIXIiVVKj7qrLXqn5jwkKiBwqXDhfCeuqcKM0IxdOC+oPCQp7x7PfCRtb/ivq5E8JCGmiYnL2c66q2MbTPRqFPDr+C3mkzqn5ck77+9JQobQhnDuS/wn6CGXifdrGw8NipD8JCrr8Kx4KGeCjFCL/CflbRBYSbvv73wn6CmJkBgXOC6hCrwkKC8yLok8J+mkGBc8JGmsjzOn21g1YhdCjZCNMi6SiLgrZwkw43wnrm88JKRsntXOzEv0ahH8JGsgPCQgZgn6qqEOCVcImDCr140JibgtZoKOkI4TE3itK094KywJifwmLSB8JG+sCrCpeCnjWsvbfCQvb1z8JGwuy/wkJ6T8J+VtPCRu7E78J6gsCQKKEImdCUqLzfgrIN28J+VtEbCpSfwnrmiYO+/vPCego8iIsi6w7VvU3sKL0It4LGM44C5Ijc944e88JC0udGo8JGTlD8uZ8OXTDgkS2A9c2Ik8JCguGAq4b21ChlCFyLwkauy8JGGgvCeo4zwkKOsPfCRp51OCkBCPjw84K6FwqVv6pqT8J64ovCepZHgq4zvv73gsqzwm7KXP/CeuqzwlrqQ4bObLjwoaHs38J65kSXvv71d4KyyCiRCIiQ6WT3vv73igIkkevCRjaZ76quv8JuFpHhgLi4i8JCSoVsKLEIqYCTgq4nwn5W0JGwxe/CQhorvv70qPeCoh++/vfCbhLLgsL7DjTzwnriOCjhCNnbwn5W0e/CWrIrwnrmb8JiwtPCflbRgw6EwWvCflbTgsZjgrLU/Ij3wkZaO8J6ln8i68JCjtQokQiLwkIex8J+goS7wkLOZ8JGKiG/it5TwkL63PfCflbRAZVUnCghCBj3DkOCwjgoRQg9m0agqLz1f76606p+Rw6kKD0INe+qpmcObVfCeuZInJQoaQhjisbwqJz1cOvCen6tPe20/8J2VjPCUkKIKMAoEbmFtZRIoQiYuImJqJmIq8JCCnuGoiCVqRidi4KeL8JCyku+/oSzwkbaR4K+GKgo8CgluYW1lc3BhY2USL0ItJ3vwnrin8J+DifCSkIQ0IiLhr58kffCRm4Vg4KG0wqNgPCZe77+9w6886qmTCtgMugHUDAryCwoHY29sdW1ucxLmC7IB4gsKA0IBKQoNQgvwkZed8JCgnuqdhQoDQgF1CjNCMcKhWeC6pfCWvp9tKuKKnS4/8J6fqjLwnZSHfDo/LWs877+90ahM8J+IgjzRqD0vWTwKIUIf8J+VtOqsk1zvv71g8JGMj+KFojzhi4B7eVs68JGNlwoiQiA88J65m/CRi5ZzXGVK4LK2IvCQqKrwkYuJ8J+usNGoKgobQhl3Lyfwn5W0LzovJH17yLoz8KyinyTwnYuqCitCKSfwnZK7LMKlXlXqqrrqrJFrW+GlgHvhi4A64Ku68JG2kCLwkL+0KtGoCgVCAypSLwoRQg9mWCRc4KKC4bGUTz9EKisKA0IBUAoLQgngr6stYFngqYwKGEIW4La90ahh8J6fq+CqkHJHdFrIui57PAocQhrqp7lQek7tn4tgJVzgq7nwnYSe4LKQYnN+IgpFQkPCoiRwyLrwkaah7Zqu8J+VtCRZ8Ja/osOzP8K/OlPjg6pF8JGnnPCdlI3RqPCQvIdJ8J65m+Cwk1nwnLyc4KqmyLo/CidCJSpf8JCWvOOCjyJCe9GoUVY/4L26U8O+4Z2ibOGwvfCfgYzjgJkKBkIE8JCguAoKQggv762B8JCzngoMQgrgoaDwkL6zKjwmCjNCMULgqqRsIuGQhDrwkYOAPPCeuZdFJMi6c1xv8J+gvO+/vT/CpS7CouKAk+Cjj8i6LiYKRUJDRm8u8Jq/veqtvvCRgLDgurMuwqBm8J2VgDEv0ajwn5W08J+bpyA8PGbitLQnKyrwnrSz4reW8J+imkdPadGo8JCRjgoCQgAKOUI3wrfwn5W0e0UiL3c9V2XwkYqSKsKlOi5f8J+vtPCbhZXvv71BQvCfgKcv77+98JGYiihD44K3LwoaQhgldHkn8J+VtN+E8JGKoCXhv7Qu8JGHqEIKL0ItSypL4K6aYGDig64mZfCQlZdg44WnZSTwnrS477ePe8Kl8JG9kOGJmzzwkZCkCixCKvCQoqo64KGWKuGKjOCunCXvv73wkJqQ4YmM0ajwkaSJ4L6gJfCen6lvKgoYQhZ5SCM98J65tyRP4K+I0ajvv73wnoWPCgJCAAoHQgVy8J2NqwoUQhIvyLrwn5uhb2Un8J60rvCQnoEKJ0IlP++/vdGGJfCQirTwkLyT8J6kkz/iv7bwnZWG8J6kj+GjlmbOjAoMQgprKiclKsi677+9CixCKlEk8Ji0heGkuta8P/CQupwucvCbspLwkZmr77+9d+GMrPCdmJXhv7h9OgolQiPvt77RqFQv4Kuh8JGkpidQ0ah24aa0wqXwkZi78JGZkuqnmAo4Qjbwn5W0e3tg8Ji0hTRjaj3vv73wkbKr77+9MuCijNW077+9L/CflbQqKWfgrK4k77+94K+QbSYKAkIACjxCOnvit4su8J+DhyfqoKNiL+G9neGFpi/gpojwkbap4Z6s8K+mplzIusKlOkUmLz3wkZKzw7fgrp90PC4KC0IJUPCegJzwkbGjCiZCJFwjyLrIuuC3sipVJPCWuYjgqpHwn5W04YuA4KidL/CRpqdIMQoCQgAKNUIzPCXwkLSEXPCeuZ1b8JCgvHQmRW4vJ++/vcKl4KmB8Ja9kci64amkw4DwkbaQ8JGEqiR1CilCJyoj8JGGrCd98J64nPCRoLjwkYqI8J+BlOCzqFNG4LWbMXXwkaSWJgoeQhzwkY2e8J2ctOGgg3F74LqELjDvv71x4KSk4K6aCgRCAj0yCgRCAsOFChZCFPCbhZB777i9KiPwkb6w4KmcXCpcCjZCNOCmtvCehLrwkbyqb1xcZDp64reE8JGIh3vqrKDguKXwnrm+8JGkrDrgt7JALvCego9qwqUKFEISbtGoIm1OJfCRqpjwkKiRQi4kCgdCBXFdPcOBChpCGETvv70qPH3wnoCkcPCRpKw2Xz/CpXtZLgo4QjZiZ2VUR/Cqro9Q8JuFlfCQjqlcwqXRqHTDmPCfm7Im4ralJVnRqCImWzDwnLypLCJg0agiw48KBEICa14KFQoEbmFtZRINQgsy4b2VwqVHO2BvUwpGCgluYW1lc3BhY2USOUI3J/CTiIsk4K6fOm/wn4mQ6qeVMmfwnpOk4ruVP3vtn43vv71j8JC6jvCQrbEm4aWyJSrwnp+qUQqBHroB/R0KmB0KB2NvbHVtbnMSjB2yAYgdChRCEk8qe2vwn6mkyLrvv70q8JGNlwouQiw94bOt4oaATPCav73IukLRqCfUuXQl4Z2gIiQ6LvCegIHvuIvgrYjCpSQiXQoKQgjwkYqi8JGFrgodQhsyYOOAuOC3svCRtIjwnZqiyLomP+G/tNGowrQKLUIrJ++/vXspe3AkL1DCpeCgsfCav7jwkLCIXGDwnaekZidsYcOgKmfwnrqtaQopQifvrIMq4Z6QL/CRm4TwkJSyQj3isqs/JvCTgKIsJOC7hMi6PzlVJGIKJEIi4LGh4Y+8PyTwn5W0IkDDmDzwnrm+UOqliifgor/wnZSPOAo3QjXwn4OVRdWfXdGoLi4i8J+Dgmxm0ahm8J6yguGDh+Cuoyom4K6QJlnwn66U8JGCvyo68JGIuAooQiZ3yLpT8J+VtMKlVV/qoZLwm4uxeXjCq20m8KqgmOC3lljwkISKMAo+QjxzwqwlL0DguY0nfNGo4KqYbTrRqPCdkqJLOuChnuqftfCeuaQz8JaqmeC3nlzgsYctwqU88JGDpybvv70KOkI44KG4Iu+7qSbwk5GMLCQnQD3wnrin4KqQJ+Gxgjzgs64kL1EmIfCdlL7wlqu1SEDwnrmSOtGow5oKEUIPL+qsv2DhpoDiurLwkIywChxCGtGoSnsncyc/8J+VtCbwnZWLYPCQlpDwkIulCjZCNMKlJSJgUGTDqlTikIFWbX3wn6eyPSfgso9ML+qVhlzDneCtguCzoGhDZD0n8JCsj/CeuIEKLkIs8J6fquCmqyVW4LqC4Z+4Jy884byYVvCThKw90ag6L++/vWhg4reMP+GqqXIKOEI2YOCwme+/veCnh07Dje+/vSZB4KmNZcOuPMi64aqZLk4+4aCDInslwqXRqCIu77+9fi9N4K6cCjxCOvCeuZ9JPuGkpPCflbTwkL240ajwnrmkOsOFwrRj0agl6p+YXPCQk659ezpR4LGLXPCTipdMXMi6bWUKGUIX8JCgrT/gu50nJvCRpIlI8J+vtPCeuawKFUIT4Y+mYOqTgNGo8J2LoS7wnZSZIgobQhlH8JCov8i6TF5EPvCRmK4/LvCfg4vgsL4vCitCKfCRjKzwlr6Z0agnw6rgs4Y/X8OSwqUwayXDkSMmaVwq8J6AhCXhiZYiCi5CLPCcvpvwkYS9YTo8Oe+/veCnnSbitIk/J8OsyLrit4jwm7KV8J6Cj/CQlrgkChZCFDrwlq2XM186Lu+/vSc6Ku+/hcKlCkNCQUPDkcKl8J6kpS/guoEx8J2SolJ1PPCflbRNOu+/vfCflbTqlZzvrLhz8JCouFxUSvCflbRYL0zIuvCav7fwnrmbCgNCASQKEEIOwqU88JSTqzw94pWTw7EKH0IdOi7it4oq4KaQ4Lud4Le0wrTwkbKyezA94rSnzb4KNEIyWeqhg+CmvD7wkL6wJi9qTGDwkpOc8JGkifCfhq3wkYqK8JCunHhcw4oq8JKRh+K3jTwKBEICZyIKGUIX8JCeij8/WuCnlyssPPCWvZE0LPCRjLgKNkI0VWIm8JCijCfgoaByKj0kcPCRjJDwkbKpwqXwnrSk8JChn8KkJUQkOiLwkYqNIPCQqIYkaAoIQgZg8JG1llIKLkIs8J+VtHsu4b2U8J+IuPCWqaRV0aglIiIuTPCQq5gu4LaOOuqasULigJsiyLoKA0IBOgoyQjA6dSJF8J2UiSEiw5Q5yLpLfEXqqpkqw4gnQjoi77+91o7gtrrwmr+94LqB77+9LkEKHUIbZigt8J+VtOGmjSTwnYuJ8JGKgDrCq1nwnrKMCiRCIuC6hyQ0YD1GYC868JCTrVPgt5Y9bW3wn6mnU+KuhiouInUKHUIb77+98JCiqOqkllpR6qmC4LS/PT084YqK4bGvCihCJlzwlqmYwqs/Jz9E8J6fu++/vT/RqE/wnYuPJcKlYCQl8JGmsjtFCjlCN/Cdkqp74Kumc1xF4LKPOy3wkZq48J+VtOGKjSbgs54v8J+VtPCflbRZP++svipcdCI9yLrIuicKPUI7XPCRqbPgqIF1JPCflbRe8JargV7tnrsn4aeTOvCSkLUm8JGNkDkvXG3wm7KcTzwmyLrwnrqhKvCespcKF0IVIjzvv71c4aSh8JGkieCnl/CQoak8CkBCPtGo6pO1JvCQoIIq8J65mVcv8JCygCbgqa9U8JGNlzhF8J+JhPCdhoDwnaqkeiJ18JGcuyIi8JCplvCRsIh6CjtCOfCRtaM/4ZyxOiLguoHvv71zKuCwn/Cfrqnvv70vKj9c8J6llOCzh3k1wqXwkZmp8JCBgPCfqbRzIgodQhtwO1wmYtO2YN6k8JGKjS7CqeKXrcKlLi/qp5UKRUJD4L6a8JGCsNGo4YqN8JGXk1xLJuCwhuCskCVcwqUvKvCRtIkkdOKRiCXvv73wnoCeOlNXyLo6Ilzwn6mo77+98JG0vApKQkjCpTrwnrmi8J2RnX7RqD3hv7vhrIh18JuFkPCWqYBIJvCQjbl1w4jhn7jwlJWDYSTwm7KW8J+VtPCeuIo/8J+VtG7wkaePL20KF0IV4LSEXPCflbTwn5u04LGdKvCflbRZChRCEkHwnL2pLicxLy8nwqxcPSrOhwoCQgAKIkIg6qyWIsi60agsZl/wkKCIXjBD8JuFkeCxrHvgsIDhg40KRUJD4ram4La98JCrrzrhqoDwkY2INC9w4busJDdawrR14LqE8J6ll3guKvCQhbM677+9XOGksOGnliDwkYqDNzrwkZy9MgoeQhx84ZawJ9GodHvRqPCflbRL8J2qm+qsiyY877+9CjhCNvCdhIjvv5ZoPU/gq6HWj3YkRS7wkICgL1zRqOG9mS7wkIGL4KeIKvCQvbRJ8J+opSJfUOCstwodQhvwkbKuPe+/vWdFOC4/4Z2yLPCdkqbhv5cqKz8KA0IBTwosQiouLz1YOns1OsOgYG/vrYThqbdV4Kae77+9w6Pgqrbhm6rwnZKp8J+VtCIKPkI88JartcKke006JvCWv6EiLuqjkPCfgrXwkICw4La976SF8JCkvz3hmq0mYCUnVEY88J65j++/rfCRkKxJCjZCNOC+vCVSJl3wlquI8J+VtFzhvJnwn5W0RSrCpfCflbTgqYLIunBX4KmLPPCRjbR24KaQXkQKOkI48J+VtPCegKNs8JC5vPCQgIQwXCY88J+rgNGoP/Cfn6VczoXwnqWewqkq27TwkpGNOkYrOu+/vXwKEUIP4rSn8J6fuCLRqD3wn5+hChVCE+GNt04nw4vitLchSjrwnp+uX00KPEI68J66t/Cdi44qQkkk4YGZeVEz0agyw6VgJPCRk5Pwn5W0PeK+q/Cfhbtw8JG1p0Z8PT/wkaS+8J+VtAoqQig1PD08ImA8wqvqoaVDJyZzPeqpgifWjS5ce8i677+94YOHIfCdnb5XCi5CLOCzjcO/e9aY6qCxJSLwnY2iVvCRtb7wmr+y4KuxZWAv8JGHrPCQnaVg4rqACjdCNWReJDwlP15+8Ji0gfCQlaHCpTUlIjTvv719KvCuia/qnrMidiLguok64LSH4ZyieiXwnYScChFCD+C6pfCRi7jgsrwxVcOtJQoKQggmJ+C6gmHDogpNQkvDrfCRpLvIuibwnoKP4Y2N4K6JZPCflbRgVCbwn5W08JCouGAlW+KBhOC2veCpi+GOge+5hHZwcu+5ml7wlr2+47iY8J2SrifvrocKLEIqa9GoRkvwn4KxSyUu0ajDn/CWqYHhupYnyLo/77SUyLrvv6bwn4OjJ3tKCgZCBPCQlpQKLEIq4ZuCIibdhDTwkZmq8JeylXLCpWDqooHgpq1G8JCok3s/XOC/invwq4S2CjpCOO+/vfCfobR6wqXwkIevYfCwroQsMdGoanzitrrRqPCeuLvwkKCo8J2Su33wn56dLifhrp/wkZeaChVCEzzwn5W0JCvwlqqLJfCQs5rvv70KCEIGw6TCpUh8CjdCNcOcODvwkaS44aekayXDoSLhnakuJyY90agmPyUiKPCfiaDIuuCxnfCWrZxia/CQjrx6QWA9CkRCQvCdo4B3JWHwn5W0SXvwkICQ4aeTKiTiu4fvsbrgsIXwnrmZ8JCojtGo8J+vtPCfq6Bhc+G/oci60ag9yLpBw4MwbQoCQgAKPEI68JGwg/CRu7LvrL7wkI696quc77+9PfCdkr7wnrinyLrIuvCbhLJaLz1BJ/CeuZTwnZOGXD7Cpz3Iugo2QjRH8J+imFnwkLy97Z694Ku877+9Rl3hg43gqLw98JGyg0gu8JCPifOghJNcPOCroCI4eyYlChxCGj9OyLo5VeCzsT3wn6ulwqXwkbyA8J+VtNGoCjtCOdmSPybRqPCTiprwm7KR4aWx8J2cuOK0p++/vdGoIj9f4K+Qw40/0ag4JVIgJX3DizDwkb6wwqVGPQorQinwn5W0ZcKl8J67sGNcTCfwr6ed8J2LrDxgOvCRjLwiUfCen67hobRfbwo3QjV76qyp8J66hU1q6qeu4LeTYCXgrYdcLSciLyTgrIEl0ahM4LeW8JG0g+CtoXM8XnIt8J+VtAoXQhUm77+9aPCdkrvwkIWrPHUy8J+VtCcKFkIU8JGkhSprX/CQqaNlNMi6SuCqsnQKKkIo8J67sSUm8JCol/CeurjCpe+/vfCQgJbtn4Lwnri7JjxqKTo98JCSuwoYQhbqmZDwkJaG4LKJe/Cfq7Pqn5DwkIGLCjhCNsKl4bybdPCQrYjwnrqlIjzwnqS+JSQ6PTIlSGou4bGHQfCQlbHCqtGoJeCsuCXwkI2W4LOjXAoKQghgc/CflbTDqwo4QjbwkICJ8J+JgeCroW7wkbS6TD3wnbyJ4La9JuCzsvCRjYcmbDRe44CcXOCumTTgt4rIusKlJ2QKBkIEXCRJXAotQitM8JGBnzVoJHdgYO+/vfCQtLjguoZcOvCdlKbVp/CQnrc6yLrDqi7wn5W0CjsKBG5hbWUSM0Ixcci6T/CRlqbwn6KGLuGlsCXvv7138JG0p+C2tuGfoCXwkJ2jW+CxoDo8PSQgWHs9KAojCgluYW1lc3BhY2USFkIUL++/ve+/vTrwnoWD4LanJ+Gkgm8K6w26AecNCqANCgdjb2x1bW5zEpQNsgGQDQoaQhhq8JCLonZrUid7V2Y64ra4IiThv7zgoaYKCkII8J65hyQxVScKREJC8JCrkTwkJvCQhacq4KuQ0ajwnrip77+94LudyLpPIGBv4KaqVvCRtacu8JKUnuCziC3DpvCQqJbwnYem4YuA77+VCipCKCd08JGNl+Gik8i6ZiU78JCbui9T8J65n/CRvIfRqHE8L2rgrrDDhHIKK0IpSTd88JGNg2tWXuCrh0ol8JCohSbitKdlYPCepZMoezrit5Y/JybqrJQKOkI44LqI4KGj4Ki8J+qfkEYpOiTgrZfqn5hp8J+ovSBE44e0dGYv4LOxdT7wkJKkPeGJmColw4fIumAKKkIoOuqoiiI88JuLkOK3kSLwkISTJ/CRi7Eq8JapqMOMLyR78J2Cjz88JAoTQhHDr9GofOGKi/CeurvwnrmpKgpDQkHgs6DCqfCeub5o8JCLjUnRqC4iQ0PqpqPgtoHwq5aARMO+JiLwkICpYCIlJfCav7PwkYqE4KuC8JGkvOK3iz97PwoCQgAKOUI3M0jwnoGRJFzRqOK0p/CfqJpcXCTwnrqh4aSWLzXwnYiDPeCqqj09YDo6PeKCi/CQhpwh8JuygAoOQgzhp5nwkbGAa1o3JHcKNEIy4LOo8J+VtPCRio068JCug+Cxljw7L/CflbTwn4mRVSPwkKiF0ajwnZKvQyLqp6vgqYwKFUITw7k94LOA4LGdyLrRqGTwkYqKOwpIQkbwkaWD4KuI8JCKok/wkYS6NSYy8JuFleCxo/CflbRs4rC/MlzwkbyVb3HIuvCRiovgsr7wnrqFQfCeuKFc8J2UvDw+ZT97CgxCCjE94bOp4KuA0agKREJCW1/wkIurNSLwkLKc8JCWnNGo8JCWrsi686CFviQqKkTCpSfhvYDgsoLvv73vv73gpqzwlqu0JyRDw7l78JC0mGluCj5CPPCRtoDwkKaee0okPfCRvYbwkIqWR8K/XCInJfCRsqRb8JC6sPCQuoZg4rWdOPCRhLvwkL6AKvCRq5I6bwo3QjVF8JGDn++/vSrhqq3RqOCorC/vrL5l4LC/XNGoNOGmluCth/CRnI8v44SX3788PyRgL+CnoQokQiJJIvCQup3WsSRg8J+fpETCrvCbsblwKvCQgIjwkbWzJy0uChtCGVbgq6PqrJY+77mZJi5a8JuylX7wnZS9wqUKFkIU4KasL/CdlYbDtHt08JCKolrhoIcKCUIH0ajDq8KlKQo7Qjngs6884Yu68J+VtO+/vSbIujrwnp+64YmQ8JGWs+GfpHsnyLrwnoCj4LaD4Ka+ecOcfT9cOvCfh6gKBUID4KiQCkJCQCfIuvCfiaLRqEDqqZY8JeCziMi68J+VtMKl8JCdoD/IuvCQoqgq8JGbgTzhi4Dwr6ClTTrhsao9IlVcK/CRmoUKCkIIeznwnoCkNSYKAkIACjhCNuC/mnDgs7Hwn6+B77+9Qeqntlg04KGewrfgqq/wnrm+LvCflbRp4KC6YPCflbQiaOCrrj0vLgoGQgTiuqpvCg5CDOC6iHvwkaWFJeqvsQobQhkqYPCQmqPiu4LRqPCQvrvDtSbwn6uW6p+TCh9CHeG/uMOzc+qgie+svjp8PfCQhpQi8JGxtyXwkKiVCkFCP++sgvCWva1M77+98JGNgnJh8JGWmuCuiPCRsJjtn409yLon4LW3OvCeuKHwnZK26qe+8JuEskfwnaqo8JG+sAooQiY66qC1JcOqXCbCpdGoS/CRkZ3igqhtJTDvrYHgtorIuvCQurBPUAoTQhEjSvCbsYE68J2fhCpySOGsiwouQizqrI3iupbwkKei8J65jXI44KuQWMKlP9GoLy7hvY1cTzritqHOh/CbhZUiPwo/Qj09w73wkYOA77+9KH7RqDx78JGlleCsveGMqi970ah677+94KeB8JCguD3wkZa+XE17OtGo77+9yLrwkbKnCghCBvCRnJ0/JwoeQhxTUvCRp5904Ka+wrjwn4KxOuCzljwmcCHwkby4ChtCGS9c8J6BpyVpLPCflbTwkK2Y4rasIfCeub4KMkIw8JatoPCQoKpSLuCoifCbhZFaPPCdpZbvv73vt48m8J+buOGAoj3wn5W0JGol4LeQChtCGcKle2AhWTDwn4emwqTCvPCWro9Q8JC+sFEKD0IN77mhw5Q/JfCRsJInewoGQgTwn5W0CiBCHuqssOGfqPCRnLU9YD9I4LGK4K6/P2DIuiYnJ2NjJQoxCgRuYW1lEilCJ/CflbQuw6vwkau44rWPQ1o9Je+/oO+/vOC7n+CmvOGiqk0nP10uKwoPCgluYW1lc3BhY2USAggECv0MugH5DAqcDAoHY29sdW1ucxKQDLIBjAwKNkI0PGAkyLomLfCRkaEt8J2UkuC/hiTwkJ2V8JuFlfCdlYbvv71SIvCWvp3wkJagOfCdk7bRqAoHQgXhv5vRqAo8QjrwkYqBYvCRtLxcJGjwkY2Q4Kuu8JG7ovCRpInwnbypTHnigoI8XOC8mypN4aq0yLpg8JCwtOCuqNezCitCKV/wkYKx8JCWpzdcJMKl8JGMsiEpJe+/veCqrXgmaTzhirwq8JCeoSJcCiJCIO+/vfCdiKnqn5Yv4aWy6qCD4aSdJuCxnT3gsInguocmCjpCOOKEqlzRqPCei78uw6ove/CQv7bioJNubeCzoXg/8J65nT3gsaJlNvCQurDwnZKq4KyzwqXwkbaQCgNCATQKG0IZI3vwlr+w4rWD4ZyI6p2kLyonXOCsjNGoPAouQixG8J6AnD/gsao9NHs2QS92PXAl4KmeXPCRtahgPD8n4aan8JCohTkkJuGLiQoWQhQnMOCule+upfCSk4c9Je+ptci6UAoXQhXXny8mPeG/r+G/meKRgyRzUGjgsaAKPkI88JCWjeCxrcKr77+9eO+sgvCRtLrguoE/8J64reCquGAl8J65nT9bPD3wkKiGLvCbgZrhia9JPyLwkYqgChxCGtGo6qqdWcOdyLo/4b2d8JGNkCR9LkBcYGt7CgJCAAo4QjYq8J+VtH1s8J+VtNGo8Jy8kPCWrobCpeGJi9GoIeC3tOGKi+Gls/CYr68k8JCeuXskbkB+eycKPkI8Je+/vSXgp4hq8J+VtEpgR3I6S++/vSLwnrmCLz068J2XlFbgtr1g77+98J64oiQm8J2NreK/tfCSkK1cCjBCLkc8J1xp8J6EuSjhvoMy8J66gOqfkFzwkIesfEBqeU/hrqp72JBVJyAkZuqhn2gKAkIACgdCBXvRqDdgCjxCOvCdi5HgraEifvCRvYk8Lzzvv708cfCQo6DikYUnJnoueybgtbRTe/CQvIvwn6+Awr/qp7578J+ummsKS0JJM/CepYDwlqmi77urKuK3kuCtleGJi/CRpIkk6qyK8J6frS83SMKl8J64m+CyrFwi8JCCvPCQqZjhj7jwn5W0MzzDnvCQqLpTLgoJQgfvrKTgqI9KCiRCIuOFqMK8QOG9l0bDs3Av8JOEuCjwn5W0UCzqoLDwkbaoT3gKK0IpWXTiuIDqoLZbMSd3e/CflbQ8YMOkPfCbsJTRqERC8JCrlCLCpfCRm4AKGkIY4Yuq4LGvPUDiuo1SOvCWqZnhgKNw4KyCChlCF9GoKjzgrZfgp5x9Kk/gvY3gqLLwkb6wCiVCI2bhi4vCveGBlGHgrargt5rwkIyNJ+CsvOqjjvCbirA/PCsmCjVCM14l8JCWjD3wnoKP77+9YPCRtYLgraN9KjrCsy5FcXPwkYS4w4Xwnp+ryLpgM10m8JC5rQoXQhV7YD1vKjpmXMi6wq9A4LOHJntvS1EKBkIE4K2dJwozQjHXsynwkIC4PScqRzM8J8OxJX5q4LuD8JGNndGo0ajRqGnRqFjwkbSJMyUnSvCQgYxcCgZCBHtcwqUKMUIv8JapoMO1ciQnPHss8JGMrUdTOiFw8J64hfCQnqRcKvCegIvwn5W0avCflbTIumEKE0IR4YmdOmJv8JGIgVzCpfCRvZAKGEIW4KiV0ahF8JC7vWrDqmo96qqY77ePJgpAQj7wnrmJaeC6ilTwn5W0PlrgsJTqqqE/XPCQnqLwnoWG6qWm8JCTg+GomSLwn4GYKtGociLwkY2H8J+DlkQ8QQoaQhguPuC3iuGglOGqlnTRqMKl8JKFm/CbhLIKO0I5w6DDqT8kPPCflbQkQXZdL+C6rcKl8J28p+qThjDhj7rivrvVkvCfoYMvOuGfqU3wkZuH76uRbsOgCiNCIfCRsKbwkIqaJPCRjLXIunvwkb+e8J+qriXgo7rvv73VvQoQQg7vrYEu4Y6T8Jisg+CvkAoGQgR76qusCi1CKz0pyLrhvZkkL9yZXO+/vfCRhbRP0ajgs5YpyLrCpeCvtXHWjWBE8Jq/s1IKGUIXXMi68J65jzngrJAnefCdkrtRMSXvv70KRwoEbmFtZRI/Qj3IunXwrKSgwqXCpfCQnprwkJuXzoTwkISBWdGoLSda8JGMq2Im8JCAqjgk8J+rofCQjYnqp7Lhs4NlVTp7Cg8KCW5hbWVzcGFjZRICCAQKsw+6Aa8PCogPCgdjb2x1bW5zEvwOsgH4Dgo6Qjg/LvCfq7Nn8JKTtMi6RPCQk7rRqOCihSXwkKutXzvwnp+r6qCr8JC6reCkoDrOlmM8PS5cPe+/vQo0QjLwnrmJYPCRkZ1SYzo88J6Cj2d88JCwvDrgp6178J+hmfCRjLjgrIzhn6FZKDIsPz0/Lwo3QjUnNF1s1o7hjpUkRvCQtLEuL/CYsIjwnL2YXu+uuOCzg/CRtpPRqCXwkaahL/CRvZbDqXpHfQoWQhR7wqXwlr+g6piWe8KlyLrgqZ5gRQoIQgbwqY2ieiIKNEIyyLpn4Ki2XFXwn5+q8J+dqvCbi6JwL/CdkqLgqrNg8JCHt++/vcOEOnDwkpSuwqXgsr0KCEIG4LqU77+9CgNCAVEKL0It77+9QiZA44Gb4KiCYO+/qU/igbEi0aht8J+VtOC3tPCQg5JwInbgs7PRqF1gChZCFCXIujw1OvCQjIrhio03PSbwn5W0CiVCI+CuuVxXfvCQnKliIiZgOiZXPfCfh6Y6yLouPHvgs5bvv70uCkZCROKys86MWi4v4K+Q4LeDJj3wnL6we8Kl8J+rpPCRtJ/IuvCQvKcmMOCsrOCtiOCyvPCQlYbhiprhqbzvv73wn5W0wqVUCjFCL/CbgYlEKibhiaA7L8KoJXXvuIcvPfCQgJEzdC7qn5NR8J+VtETqn5jgsJzgp58gChFCD/Cdkp8q6qOVyongrr8+LwoVQhMiM++/vUc84Z6L8JCWlDTwp7KyCjdCNXPjh4jgpofwkKKnR+CsvTo7IsKlW2PwkJ2LemHgqLxceyQuJnjwmK+XP/CeubHIukciOsi6ChpCGFtqe8Kld/CRp5/IujzCscKwYu+/nOCsrQoqQijhpLXhn7N76pmSMvCeuYLwq7CO4KyVPyI/WvCfiaPwl5S0cVHwnp+mCjtCOfCRnL/wkYSUYfCQgZYoLy864ZG30agme/CRmJritpTgqrLwkaSW8JGMs/CcvLo/OPCQoq5i8JCAjQorQinDvfCRjIbgp4tMJvCQjJ3wn5W08JGZk+CoqybRqCvwkJaoSjrhv7svPwoWQhTRqMKlwqV88JGFpuCpjXvwnqGNQwoJQgdF77+9yLpYCjJCMH7wn5W04KqkU1on4Zyw4b2h4KyCdyoiMS5XICXwkZeVUSbgvI80w7Z+P8O9JiXOjAoDQgEkCh1CG3ZFw4zIuvCdkp45JuGKiiVf8J2SpvCfiYfIugo8QjrwkbaTPMKlaSREXPCRq7Mi4Z2s4YONJD/goJRw2IshyLorXOGjp/CdlIrwkISCKvCcvaDwn4K3PCpaCiVCI/CflbQuMci68J+grVHhrbjwkYqj8JGkvT8n8J2Sqy9Z0ahRCjxCOnXCpeqfkyfwnZWGL1UpRXvhnpcqwqXwnZWGwqXwnrqZ8JCdoHvwkKe04Ymy8J+VtCzqp6cv4KqPwqsKHkIce1Il8J64g0p1JGbwnZS9aCbhvZvwn4Gr4KiIcwoVQhN54Kme8JGylUo/J+GJmDjhip5cCjpCOD3guZTwnrq0VDEuJFYnJfCRtqYu6p+T6qe3dSBO8JCTgdGo1bzigqI/77+98JGNsz8uYPCQnYJhCgdCBS9aU2AuCiFCHyLwlquEbiIvZPCQqZUuL1zwn5ybLzrwkaS4IOGJjDwKI0Ih4rSt168kLyzhna5fJvCRmIfinIxqJkLhp4DwkK6NfcKlCkBCPuKDrPCRk5M88J+VtPOghZ3wnp+tSeGNpjrRqFA18Jq/vlxAIlEieOGdquCpgPCQlq5SWuG9ovCflbQ84b+PChNCEXlKyLpg8JuEssKl8J+VtCgnCgdCBeCzlWtVCgJCAAohQh97Ki/wn5+wbPCeuYLhvJgxKiDwkI62afCQj4gi4KqCChpCGCk88JGThUrguoRYK2Aqw4PwkbCUSiQyYAoEQgLRqApBQj/vv73CpeCpgj/gso/vrYE88JCigURn4KiyYCUu8J+fldGo8JGMhlU48Juwki/RqCdd8JarmuC7kEzgprchQVYKGkIY77+sXeGwvC7gt6zCtsi6YCRW8JOHusi6CiBCHnbwnrm6PGZuwqPwkYep8J+IgvCRjbRc4LOiIuK3jgoeQhxM0ag84reZfNGo8J67se+/vXZgRTolRCfwnp+uCgNCAT0KMUIvPPCWv6TCpe+/hlzgt7RgOjAhPi/vvIQmdFzwkIGD1o7wkYaS77+GXnoqyLpOP28KFUITOifCpcKlyLrwq5+u8JGlg9GoXwoqQijCpSQq8K+mqzEiyLov8JCDs35oyLpW8J65nVzwkZyq4b2K8J2TnyddCiBCHlVz4oamYC/gtYoz8J+trfCQv7Av8JCgiEpILm3DowowQi4u8J28i3Bp4KG84LGgJMKl4LGLWiU+0agl8J64uzxc77+9cPCQroJlOcKl4Z+yCilCJ8WqdSXvv70n4LKC8J+buu+/rCfwn5W04YmNYEhNPDojyLo4c05XJAoaQhgvR/CegKkr8JCBgeCuh8K8JfCRjLPgq5AKIkIgLuC7izrwkIyyJmIlL/Ceuq3iiIXwkb+AJ3XUufCflbQKEQoEbmFtZRIJQgfwkbKOJkYmCg8KCW5hbWVzcGFjZRICCAQK0Ri6Ac0YCocYCgdjb2x1bW5zEvsXsgH3FwoiQiBu0agi8J66qT/wm7KGPVl7ZvCSvqbvv70l4Y2K4Y6KYQoZQhdWJOCxjCXwm7G6Q/CRvLDRqOChkOGBuAoyQjAgw7TgrIl34aqnOMW0VeC3ssOue+K6n1BELuK9uz9+4KmeevCeuaQkPyTwkaSWcTwKGEIW1o3wkJW68JG0usK96qCOJiUm8JG8oQoUQhJc8JC5vU/vt4/wnrihfvCfgq0KKkIoLi860ahrb+CoqvCfq4LwnLy04rSY8J64tMKl8J+VtOG/j+CouF1cOgoUQhJC8JCoj2/gpohG4aKU6qOTJGkKMkIw8J6AhfCQq5JtJeC3r3nwn4K88JCumXcn8JGEpmfRqCPwnrmHMzooKvCQhqBk4KiaCj9CPfCRga4lQjx04aCF8J6lkeOEjT3RqGIwJOCvpzZHbuK6nmDwkLqe8Jq/vVzgqZpXwrNiMybgqagl8JG1pyQKBkIE8J6EnwokQiI68J2VgHjwkJW3OuG9m0Lwlq2R8J2UmfCRo4TDpPCQhLF5ChNCEfCdvIg98J2VgCfDjXUu6q+CChhCFsOe4K2IPTzwn5W04Z2LJci64LK5RyYKOEI28J+VtDJGYCVtYC3gqYcu8J+JkOChpfCQoIQ68J+VtOCiglzIuu+/vfCRhpZkaH1L4LaDw4Q1CgVCA+GdigouQiwtyLoqQC4/4YmYPTQ94bOHyLp8NCp0XCXwkauN4Kif4LOKRm/gsJPwkYqQXAo5QjfwkKiNUDs/LvCQp4NgNHon8JKRsuC0meGKuOK/tvCeuZfvt7vwkJ62dFxgJMOyKuCngGAlwqkiCitCKSpvP0LwkbS6RCc+eDMn77+9OvCforE8Qz06yLpXeeCpnsi6YC7wkKiiCiFCH28qe8i68J+CvfCRg5DwnrmyYGYweeCxmOCwjmHgsa0KGEIWw7XqrJQkJMKlyLoq8JGEtzon4Yq8QAoUQhLRqNGo4LmBReCrjS5cPNuyWC4KHEIaOjzhvYg9e1vhoKBcJGkx77+9Z+qsoF9fKikKN0I14La9RPCdhqTwn6GnWjzhnpXgr4JCKTzwnZKl8JGKi/CRipB+Lci64auLw59kJdGo8J+VtCkKLUIrPy7wn6CK8J+VtPCeuLkq77+94bK+77+9PPCRtaRge/CRp43gupDvt4/RqApKQkg8RTrIuuCtiPCRpKI8w4Xqkp4+8J+st/CeuYLwnqSt8Ji0hj088JCFpiw/8J+rs/Cfq6RIJvCdkrJcUj7RqNGo8JCnhH3hqpAKAkIACiZCJC9xX8i64b+NXPCRg6HwlryXP17hg43IunV+IsKlcD3wnZKqJwoYQhZUw6TwkK2N4LOs4LKx4LCnbWAq4LOCCgdCBeC6hGAlCgpCCPCRjJPCqD9cChlCF/CflbR677+9wqU6a+qvsHE0XDouIiJVCilCJ3Xwn6GXP+qqoCrwkL2z8J+VtPCeuqfCqnvwkbWW4ZCBOvCfgrfOhAomQiTwnaqdY/CQsKfwkY2XNn1aL/CRsZR9PuqnusKl77+9dvCflbQKCUIHL3AtwqVTcQoTQhFFWCY98J6fsnRXP+CwhtGoJgoxQi9g8J6Cj2LqrKIje+CwjyLwnp+uP+GqhVLwnrmk8Jq/sj/wkLSb8Ja/oV474KGeWAo/Qj0u4rSt4LCALPCRjY3goJ0r77myXPCflbTwnZK7LyXwn5W0yLp78JatnTQvXPCroZfbqvCflbTvv71BLjBrCh5CHCZ644G4JVzvv73RqOK2lVEw8J65i3svIu+4iCQKNUIzIz138J6AkCY9TWBGXfCRiojgq5Dgt5bwkI+UKjp71onwn6GU6qeSJyzDpkfgsrbgvoklChlCF3ozPChB4Zq0J+CqrO+/oSpQN2kuwqU9Ch1CG+CqqPCdlLg3W2g/PzwvwqQ/77azXWPwnp+uPAoLQgnwkbaIbHvhvZkKCUIHPS7wkICqcAoeQhzwq52B8JCtkPCQi4LgsaBpw6DgrIci4b2bKmEuCiVCI/CWvpw90aglZlxd8J+VtMOswqV6PeGLgEonc/CflbTwnoKPCiNCIWDgv5Fh0ajvv70v0ajhgqPgr4HitrY6OvCQuaMm8KiglQoqQigrOiLDp+C8gPCetKc/8JCgkci6XeK2vUVWLj1gcT1SKu+/vT150ahtCgJCAAoCQgAKPkI8SfCRvYvmpq3vv71f8J2LjsKle1Twn6Gp8JKQvPCdma/wn5W08J+qg0hDLENh8JG7qeCzjFwu4oKcYDlBCjdCNVskVkTvubDwn5W08J+Co+C1p/CRjYhOeOOIjTDhpIzgsK/grIHgt5Y94L+I8JGkjMi6PDwvChNCEXt5MWjgq77guIlc4ZyK4K6OCgpCCPCQgLjqpallCilCJ0gmZiRc4Lee4KiC8JCuriXwkZOT8J65qOC0iPCQqYRg86CFlEtgKgoGQgTwkKuwCjZCNC7wkI6/JuqsgTzwkI6NwqUq8J+psUYvJuGApPCQlq9cIvCSk7N7N/CRjLAnWlov8J+VtFQKDUILZy7wkKGtKvCfm58KFkIU8J+VtDNc8JGNtPCdlL5FR+CmslwKCkII8JCrhOGdr1wKIkIg77O+J/Cfr7fwn5W0YPCQvb3wnL6WOCZg4YyZZ3jRqD0KIUIf8JG9iiI84LOGPXvwkICa4K6f4LGj8JCHnipz8J+VtAo4QjbgqInwnL26eyY9LmHgp4Lvv7080ah+4rW/aC5POu+/qTx98LGJjvCQgYzwkISAPD9mLyQhwqUKJEIi8J6BoGviu5EmR/CRqrY6JOGLhU/RqOGgiCPhirPwm7G5PwomQiRPL3Lgs4PwkbCELmckJvCQloM08JGGuvCWro1P4K6j4K+QUmAKEkIQJvCesqjhqokq4KqR8JamlgosQio84Z+xJPCRtpDvv70odvCdhonRqPCRtaIv8JGXgOC3ilxDPeCvjOCqkUwKE0IRKeKrgeC2gfCQnrIiOipvwqUKLUIr8J+VtPCeoKbhvZ0nyLrwkKC4UNGo4KSAPU5TPOKEluCtiPCeuILgprDYhwoPQg0kKmTgqYd9P/CfopYnChpCGOG9kMKlXPCav77wkISAwr4n4Lez8J65two2QjTwkaSW8JGQvCrwkaWYPCQ84raL4b6a77+94LuEP/CRnIo/Jz9fS+CvjXvvv73iv7DhjpZgChxCGsOA77+9cPCbsoPgqKcg8J+VtPCRsrTIunskCjhCNmzwkIqt4KG94KuqZ8OfLuqtnC7wkLSP6p+QJ1zwkYW0JfCQjIR9eTnwkKiF8J65lPCRmafRqAoDQgElCiFCHydpc/CQvJfwkIqk0ajwnZOyOFQ/0ahke23vv73gppQKLEIq8JGKpG0nJSXwkIy1IPCdlYQ/JcKlX/CQoIhUPOCrvzfIuiXIumHwkKyfChtCGXpj8JGKlk1c8JCAhOCzo1bwn6KxPVRqZyMKQkJA8Jy8iHXgs6E/yLojwqXgq5AkXvCWq4kiciUuwrw577mU26QkyLrwnLy46qaUWlhgdS7wkai44LKv4YOH8J2qnQonQiVcRzo/ND/wkJa78J+unuGko0s6cCRTe/CRjZDwkbaXJkMv77+OCiBCHsKlJElMJPCflbTwm4WmOjzwkKCfZO+svuCrkMOGMwoIQgbhsIHRqEoKNUIzPNGowqVtTG/CpfCdlJZfYPCQo77wkJqp4Ym48Jy8u2pcJXsq77+9PmR8XnQlcTwoIi88CiZCJD0gwqVTLT3vv73it5Al77a1L/Ceo5bwm4WQMvCRjY3qoZk/YAokQiJTOiXDlHvwkKut8J2hlz9lOvCQoqrvv70lJ8i68JC6mlwgCj9CPfCfm6IiLfCRiojqrrx74Kqz8JGktyLDrvCQjpda77iU4aef4oCR8J2qnyRdV/CfgpA4J/CdkqUkcHs+L2UKQkJAJCA68JGLt2/wkKCc6qyDXEkq4Yu2Ii/wlr+kNWTDtfCRko7ihJ3wkbGU4LWPw4rRqOGSry7qp7vYkztK8JGygAoMQgrigpwvOm7wnoCqCglCB+Cosjrhq4QKAkIACh1CG++/vfCflbQ/e2s/4KaP8JappuK3iyQlXDxdXgooCgRuYW1lEiBCHuGLi0E94KyD8J+VtCQ944W4NfCRp6AqL9Wx4LOxJQoXCgluYW1lc3BhY2USCkII8J64tsORQVYKrhi6AaoYCt0XCgdjb2x1bW5zEtEXsgHNFwoMQgos8JGllOGkqFY8ChFCDz1o4K6zwqV1X+OEk+C4kgoIQgZrVSokIi4KIUIfwqU8w7Ptn7nwlqyP8JGsgvCei53vrbLwnrqiS+C4sgo6QjjCpVfirb1T77+96q+077+9WDrVt3omyLpfdu+shS1cPeCvjfCWrofgrr8m4LuZ4LGHKnvvt71cPAouQizCpcKldCTwn5W0L08mw7zwkZ2FdPCfgqZDJ/Cdi4xcyLrwnri5YmPIuiVcLgo1QjPCpe+/ve+/ve+3u+qjv/Ceu7A/4r2TSSbwkYK8az9rOnB18KOZqfCetJFgIkknYHom3L4KE0IR8J65p+G/qOC9jvCfm6AlXDgKNUIzTdGo4LuG8JGNs07CpX0n4KqWTvCflbTguoE717FXT2BgJCo344W24Zuf8J65p+C7hkIiCihCJi3wkKS/RvCegKbvv73woYmEIj0i77ah6qyGZDoi8JCHqc6GI0Z9CjhCNkTCpXPgup8zL3DgsYAmW/CQgJXwnrm+0ah0wqXgqrbvuqvwkK6q0ah9InRga/Ceo4vhqbo8IgopQifvt7hlbG3wkZy54Lym4LuGOjxJXGxgPfCRlr4vIiJg4Z2LZTzig6gKOUI336Qiwrg/duK2girwnYCD6q+awrrgsotsYiov8JOCkjrhmbjRqHvqn5DhopRcPfCRkqkz8JuKuQohQh/wnrmR8J+VtMKlMuCqlTvwlqie8JGkhjw26qmByLoqCgJCAAoJQgfigpMm4K6QChpCGOqum2DhiZZc4reZYOCrgDFa4KmNJOOElgotQivwkbGB4Kaw8JatmSU34Kuie/CeuI/wkKKvVuqXr3x1PeCtoHtUNDzwnZOCCh9CHSt2LvCfq4IvWy896qGZK1zqn5HwkZuA0ajgrodZCgZCBCR7Pz0KQEI+QSrvv73vvorwppqnd+G9mcKlR3Hwn5+nXcOj77+98J6Fj/Ceo4xG4aeqTuCzhtGo6qWjXPCSkZTwkY2XcX4KPEI68J64ojg9PCTwkKCe4LGuOPCRsIfwkbKdLvCQqLrCpT5gPCFYLuGLmjgmJ8i6Lci68Jy8mfCeuYsqZQotQivwkLKq4b6RaXPigbw6Rj06IDUvMi/wkKiFLtGoJHAtw5F74reUwqXwkpOvCkRCQiVF8J+DkXsl8JGkheC0juCroe+/veCugmDwnoSN4Z+hZ+GqqFZuYDs/PV3hjo/gprzwnoSPJS3DmcOYJ+qlreCtlwo4Qjbgt5/DiOCshiQj4Ki48JCouXbCpeGfoOCzseGLv/CdkZI/8J64u/CflbTDnMKl8J66ruCskHMKA0IBJAonQiU8w7rwkYS+J++/vV8l8JC5qcOlYWDqm5XwkI2Uw4zIujvwn5W0CgNCAWYKNUIzKlZA8J2Noj9KZvCfq7EiXSoqP+Goq+CohvCQoLd74LOj8J+co8i6esOmw50qyLo/4aqxCgJCAAodQhvgp6fvqb/wn4K08JColuC6gmvitKfColDhn7UKBkIEMOCqogpBQj/vrLnwkYyz8J2Vj+Csg2nvv73hv6dN4L6iKvCQkZ06ezok8LG9gPCRvI9SPPCdhbIkwqPwnYS6LvCQvrB7OioKOUI3I++4u/CQjZPwkoWISy9L8J6LkkjwkpGEV+C2tfCfqohjZTwuJFzCpfCdiLI677+9PXU98JCkvwoWQhRG8J65lG/wkISALeCtnPCeuKdVYAocQhrwkKO04KaMw4DCpci6PCR78KqgkTzDnyfRqAodQhvIusOYJi7wkpSj4LqJJ/Cek5rCtz9AXO+/hCUKEUIPPe+8iCR7wqVc8JCjrFRKCjJCMMi6YOK0p/CRiItgSsOoYD5cKvCflbTwkKySwqXgqK7wnrqnOC5D15nwnYul77+9ewoJQgcmIkbwkYy8CiBCHk5QTCTwlqmaOvCQnYTwkISA8J+isWAi44eeYeCviAohQh/wkpGwO8i6MuC1iHxNLj3grqovLybwnYildi7wnoS3ChZCFHvCsuqoo1RH4KC84b2dVCPwkYywCjJCMCfwnZKiyLrwkISA4a+E4rStS/CQprV7VO+2sWfvv70leyov6qug77+9T/CQoLxxLgosQirIuk574Ky1QPCfna97Zsi6PMOYN+KvgWMvdci68JC/hG/wkKCPJVUnw5IKO0I5JeqUkDrDosKlJ3vwm4CRXWbwkLOv8J+JkcOM8J+ggDLwnYicVCjDui5lQVrwkKmH8JG2li/gqZF5CkFCP3044K6ZZ/CepZkj8J2GmPCfq5NRwqVWPSrwn5W0OjYsdOCulfCRnJ4i8JC5tNGo4K6fVci64rWU8JC0nC5iPQotQivIukRhRzAq8J65mWA9L3XhqK1QeyUiSsOe4YmwJFTwkL+Hwr0kP2zwkJaZChFCD+CnoFHwnriwUeCsiuCziAo4QjYt8JGMh1s/cOCzoy4vPMi6YC808J6llSR06qyr8JarsPCRjZdtdvCeuZ3Ct0Que2/wkaehLUcKO0I5JTol0ajwkYyzYsOjYCfRqHsv8JuFkPCQtKY58J6Ao+C7mDw94K+XL+C3s2LCpfCeuZ1cZy7wkIGYChBCDkbwl4i6OuOEh3sv4Y2vChxCGjrqppzigpMn8J+VtOGPgmzwlqun4KqVJFwqCipCKCR+PPCQkqA8SeCotvCRu6Np6qmkfPCRpIQmwr8nWfCRnLsmbMObSm8KKEImQPCQlpo/LiRzVnLIunvqqYnvv73itqZ38JatoeC1i0hY8JGMqzkKCkIIQl3Iui3iiYcKEkIQ77+98J2LoSLwm4WVJiVgYAo+QjzCpSrwkYOT0ag9J/CRpLgn4aqAb+Cyi8OrOPCRpIlt8J6BiPCRnLBMQ+Cmssi68J+DjHzDoH08YPCRirIKJUIjPeG9lirRqD/wkaS38JCpudGo8JGBgPCflbRUeynCs/CdlYAKOUI3wqXwkIC94KaqIvCeuY/wkJK2YPCQjpMmJ+Cqs2wiIlzwnrikVPCRp41IQfCRg6Tgu4zwkKmTYgoZQhfgsbjhgq7wn5W04Ki88JKIj2DDjkzDnAoHQgUi8JCirQoTQhEl8J64qfCQlqrgrLJ78JGMsgoiQiAq8J2ho+CyjiolXOGwv/CegKfDnfCflbTwnoS78J+VtApJQkfCsOGKuz078JCHp++/vTzhnajwn5W0O/CQpL/hsafwkK6ZJ+K0rTzgu43wn4mQQPCRtaVgPyfCpT3wnZKfZcKl8J2Epj/CpQoDQgFwCiJCIC5e2awiMXnhg4fwn5W0P3g94Kyy4byZTy4lwrTvtp80CjpCOPCdi4MqOuCvkCUq8JChgDdDPz1wP/CQnYROJCPDuHvDmuGwm8OhVlMkyLp7R9Gow5Lhjpfwn5W0Cg9CDUfwn5W0Lj3CtD0kcyoKBUID0ahcCiFCH+KBsO+/vfCQgZbwnp+0yLrgsJA6w4I2JO+/veGJnEYKKEImJPCflbTgrZbvv706yLpILyTwkbGwL/CRvrDhqqt7b8OeMictOlQKSkJI77+9YPCQlpQ/4LOpaCV78J+VtGPwnZKp8J+VtFEvLkw88JCpg/Cego/hvr3wnqWePuqiheCsmlVR8Jy8qvCRjZDCpfCeuZdcCixCKi/CpSUoXi8iZfCflbQ/8JCGoPCeuYnCtjw/8JGIsPCxvL9sPeqdmE9mLgo2QjRQcD9tUvCfq5dC8JGlmGjwlr6Pw6Bh4KiP8JCEgdGo8J2Sol08aiPgq61w8JG2o+Gdp9GoChNCEVzwkJaQP8OF8J2GgjbwnY2mChJCEHTIutGoM3HhnbDwn5W0Z24KJkIkYeCuiOCxoWwl4r2r4rWBcfCSkK3gsaLwmr+94reCyLo84KqNCjBCLiR1L9eC4bWyNHsl0agn8JCVkvCRtqnwkK6BwqUmWfCQnadgMXnwkJa1PfCflbQKCUIHPSbwn5W0QwohQh8u4KanXEtVwqU8TyEmJ3Ym4Yq44LOeJOGls8K5762ECiBCHlM1XD/wkYyB8JG1l+qsiipkYH3qoaVpPPCfq7U6JQo3CgRuYW1lEi9CLTzwnrm5MFxJKj/wn5W03LLgp6N58JCAtSo8JkBR8JGKiEfhg43wn4Oa8J65kgoPCgluYW1lc3BhY2USAggECtENugHNDQqpDQoHY29sdW1ucxKdDbIBmQ0KDUILdvCdqpwqPfCRmI0KEUIP77+9WvCflbTwkZyZ4KGgCiZCJPCflbRE8JGklj/goLc8J/CQk7rwkLS2UfCQh6FL4K+QLC5ScwoxQi8l4Yy38J+VtFw8TXtWLy5d4oGWe0DwkZyjecKlL9i+4oKOLvCQgK7wkLSjcGDDqwoJQgc66qyrPMi6ChBCDmonyLogUO+/vSfwn5W0ChFCD/Cfq6XIuiTgqK7vv5MvdwoFQgMldEMKPUI7T8O68JCPki0iNfCflbRvdEVcMfCfoZFv0aPis5Iub2Umw5Jc77+9POCqpu+lkzzwnrmHdeqjjuCqskYKGEIW8JCAiibvv73CquGLgvCfgqzqqZUvPwoUQhLvv70me3svKD0qReK1sOG/kC4KDkIMMDwnaSTgprBn77e5Cj5CPHZR8JGNjPCRg7ngtrnwkYekIj/wkIekPfCRjLLgroI/8JGNkCVT4oGxwqAk4LCnVCrwnZScKsi6eCLDsAogQh7wkb2BJ2DgoLTqkpTgrqNg0ag8QCbRqCQmJy7RqCcKGUIXe25e8JG1oy7guK8g8J+VtCRLKeChoX0KCkII8J+VtCQnLyoKQ0JBdyTCpSXwkIu04KqDwqF7SfCQj5DwkZCqZfCQgYw/e1En8JCLsGDwkYiQK/Ogh5bgq5Dwn5W0NOChnm468J67sXYKKUInWjzhpabCpUx6P/CRjKtReybqrKg44LKs8JG1gT9KVUIu4KmA4K2gChpCGPCQno5c8JCWuPCfrozgtIvqrKtc4YKNewonQiVe8J6jjVfwkJaUd1zRqCJJOWDgr4vwkKS/PPCQvLFOwqUqRsK1CjdCNdGoJCR74ay/yLor6qy6dMKl8J64uy46KmXwn5W0feG/oci6R3LIuu+/veC2s1zwlq6HYERvCgdCBXvwnZKsChZCFFwlPMKzNF1wIi8jLlxaMOCpmsOgChFCD3vgqZHDvjTwn4e6cGZlbAoNQgvwnrmS4KSN8JG0vAouQiwiIvCRtI/RqMKl4b+ZPjnDoiXgoYXwn5a8UeCuqV4i8KuXkci64aax4Ki8JgoxQi9l77+94aqHM8KmPCLgs4w6w5vgroPhna4uPCfIusKrYMOF4rqZ8JCdo2HwkIGEPgoyQjA/fOC3svCQgJIhbfCQnoLwkLSY8J6TnOqluD7Iuj97YjplwqV+8JCVt/CRoI1ZYzQKN0I1KvCehYckYCPqrIXwkbaQ8JGDt8i68J67sEwn6p+ZwqHhpLoiw5ok8J+VtOCsvTzgr5dXYzoKQkJA1o5cNzQ78JGkjuCwji7wnrmL8J+ElTfgs6YiYmI+4LGMWHvhiZLiro5gLfCQoqov8JCtnfCRmI8j8JGJgTLRqAonQiUiyLpc8JGkj+C3lDp5PDrgtbR78J6AkDpSXzbwn5W00ag9P8KlCgJCAAogQh4nw7s/Y/Cfn7A64KqKQuGClCc7RiIqL2fIuvCRtpAKEEIO4KeoSybwlr6X8J+VtFYKEkIQPfCQg6HIutGoJvCXsJs9bgoJQgdLL/CUlaYnChNCEVp+Kuqnq3zgq4td4LCj4K6OCjlCNzJD8JCVuCYn8J+VtNGo4KiCwqnwnrinyLrwnoWB8J65knsu0agiN+G9mVomMvCRsYPgqZ4/PHoKBEICIiUKMEIu6qe08J2UlFfhjozDmnvqrJYiUXvUuO+ztOCuqPCdpYliJGhg8JGNsHk68J67sQo1QjPCpSLRqPCRhZTgrZxr8J+FnNGoXMOy4Ked4K6jPjw8P2DwlqS28J6Ao8K4POqtmfCen6oKBUIDJWs6ChdCFfCRjY3CpSNP8JK+qeqgkT/gqphMfgoxQi/RqOqrnFx3NtGo8JGllGdpJvCflbQ977+9YPCeubAmPyTjhK4k762Ae/CeuZvCvQoQQg7wn4iuLkLwkK6vwqXCpQo7Qjngs5bDnfCdi6NfIvCfq4/hiazRqOOAhO+/hfCWq6XwkICXL1Nl8J65vvCdvJbvu6LRqC7wkYKrPTgKLUIr0ajwkZiSXzom8JG1g3lq8JGkt1xSeyrqqY1C4aWU8J+iknFXIipcXzouPQoUQhJ8RD0uafCei78x77+9UyrCpS4KMUIvIjrwnLy9Ml/wkISBOm3hp5fwkKywJC8neyV5QvCbhaU1IuCmrSQvWy/vv71lyLoKPUI7w7AkyLrCpfCQsqolLkbqpaci6qmiJzbwnaqlOPCegKTqrJEkKC5K77mpQCcmbvCdlJbwkbCHyLosKyYKDgoEbmFtZRIGQgTwnrmUCg8KCW5hbWVzcGFjZRICCAQKng26AZoNCtsMCgdjb2x1bW5zEs8MsgHLDApCQkBy4LGMKOCujmTjgrEnP/Cego9yw4Hwl7qlJO+/veCqstWV8J64p/CRiIzwkbaifHbwkZOR8J2qmycu8J+VtMuOCh1CG8KlJPCdlYtY4rSTNGAiwqfwkKO0PH5sKS8wXAo3QjXwkK6r0agiLvCflbTwn5W0JCpKNvCQoLfwkIq/JCjgtbvvv71Q4ram4YON4Z2uJOqpjOCorgoYQhbqpJTgrZw6yLpGyLpX8J+VtMOz4LGmChRCEuC2gvCQlrDguIdm77+98JG8owoOQgw6Lz/gtI4p8J2Uij0KHkIc8J2DlibgppDgq6cu8JKQtWbwn5W08JGMsMKlVgoWQhTvrYThqa9i4K+H77ig8JGNrCXRqAozQjHwn6qB8JC9tCXvvJcvPeuGnSRpPz9x8J+vs8i6OXYq4K6JIiolIMKkYzpyKvCfqaAmChhCFng94ryDJ2cvP2XgrbNkTSZg8JGctWUKM0Ix4LqEJ++/veC3ivCRoJckP/CQqIbwkaSW4K2gISXwkKeN8J+VtDDIuvCeuo0i0ajCpQoKQgjgt4p5JeCsjwoDQgEuCgZCBGBBJSoKG0IZ4oGwKlNR77aV8JG1p++/vWAqYFbwnY2uPAoHQgXiv7hoIgoMQgpcLz97yLrwkYyaCg1CCy9cOHvCtPCRrIB5CjdCNWDRqO+/vfCQuq1wXFDigLsnfvCeuqM8JyvgorYyJ/CeuY/IuuCusSIl8J6AlNGoL9CL4LGpCiRCIvCflbRISiU/8JatlSQm8J+rsSbgrqrwnqS4ZvCflbRbJjcKRkJE8JCooeGlsS/wkIecP+qZolwmwqVCyLokJvCeuphO8J2LpeC+pVcu8JGxld2RLybwmKS6wqUk4aGoefCflbTCqfCRi5AKGkIY77+9Jz3wn5+jSXLwnYiX6qe6J0U1WyQmChxCGvCQlrPwkbWYU/CRkZ8vNeCujuKvlz3wkaWFChRCEuCsgVLgq6Hwnrm+biLDgDl6IgoPQg0kyLrwkL6w77+LVU0mCidCJeqonDvDgcKpZSV48J6AtvCflbQ6YHtcJPCQqbsi4KiwdfCeuYIKE0IRKlIvdeCmrfCQv4g+KvCRjLIKIkIgeeG+t8i68JKRs+OApD1XIPCRjL3djSrgqZ4nVTowSEgKREJCyLrwkKyc8JCtmS5M8JGokyTwnZCe4K+Q8JCUoVrwlr2eez/wnY2uw6w/QvCflbTikYrwkI2iXE14M/CQk6Lwn5W0Cj1CO3TwkY2MJ/CbsKbjgY7DrfCbhLLfnjrvv73wkbytJeK2vnAiIvCRjYh24q26deCmq++/vfCQg5hJLsKlCi5CLDfwkYyQe+K4t8OALlQ6QfCdiJPvv71gYDxsJlzguongrobvv73Iujvwkb2SCiZCJPCRmo0ic3rwn5W076iJ0ajwkbSJ4amlJyVJw6XwkZi24LCPPAolQiPwkICB8J2SuyrwkYuwJeK2suK0rfCQtLDDgXs14LaVWu+/vQoFQgMqe3UKJkIkaS4oZPCbiLxXyLp78J6AjOG1l9Go4b2jLCrvv70lJ1zhnZM3CgdCBeOEmDxJCiJCINGoLu+0lPCWv6Lgt5RcJns8e/CRoJFc8Jy+v2zwnZOBChRCEvCQqZAqIifwnp+wUSfwnrikRAoXQhUvLjsqfuKuhfCRpJXiroI6LnnRqEoKOEI2Pj/igIPwn5W077+9KibRqPCdiLI677+9YOGJmDs9YWA/JeCxmOK/tm/igpF7OuCovHYqX3gvCh5CHMKlwrIr8JG9gMOZT3BOXDoweeCqq/CRgr7vuZwKO0I5U/CdhIsqY0Y6LkrgoZ47Iu+3j++/veCmhsKyJuCosy4iLiIua2LhvZ0twrnwkKC3P/CQgI/wn4mECiFCH3vwkKuz4aqEKiojJHVc8J2Tg2QjUNai4Ka94LCYyLoKC0IJYOC3nCrwnri0ChRCEjpzLvCRpK/igqnwnrSqKuCqtwo5Qjc977+9yLo5wrXgsZ0mIsi6Ii7wkbuo4Ki58JCAsH7wlr+wOl/gqYt04KqcwrbqmJLwkKOsYFwnCiVCI/CQgIcuKuKGnvCQqIZRPEthJzjgr4pc4Y+7aVzwkKieSjIvCh1CG1Dgs4bhvarIuvCWqabwkL+177ORLWcw6q+yPQopCgRuYW1lEiFCH/CRiognPzo/wqVeNVvwkYSy8JGlhDrRqCXwkLKfJlAKDwoJbmFtZXNwYWNlEgIIBArlB7oB4QcK/QYKB2NvbHVtbnMS8QayAe0GChhCFsOQJ+GJlFLgrLYi8J2FoiXgsYvgt7QKKEIm4Z+iYMKlwqXwlq2fJj0uJyw/PS9Z6qyr8J+oti9pLuC7nvCfnK8KFEISN/CflbQv8JC6nnVcw6fwkIGXChBCDuCunPCfiZA6JdGo77+9CjdCNS8x8JG0gmTgrpUz8J+VtOC3nPCdkqJbJMKlYvCQqIbwkaOKL0rgtILhn7nwkKyZXGDwkKmQChZCFOC0heqlrdy7TGPDneCquF/gr5coCjJCMMi6w4rgsqAnLi8qd/CQlpRwcNGo8JGpr2AqYjrCpUN78JCjte+/veK2vHTwn4OPWwo0QjLwkKOs8JuygzxYw7PwnYCT17RbPfCfnYXCpD3wkYKb8JCzvu+/vUTwkKOofGA18JCpmAogQh4oK1rwm4uE4Z2TffCcvILjhqQ2Kix7VDYq6q24KkAKO0I5T1k44KuuPydZ8Ja/o+CrkPCfhb7vv73CrmdUVe+/lPCQlJAuKvCeuYkuY1zvv70ie0zwkbC46pqMChVCE28l0ahGYFxMLu+/vVRR8J6AqCYKH0Id77+94KGTKuGlsMi68J6En3fwkKi58J64p8KlfF8KGUIXyLrwkISCaF/wn4OJyLpj0ajvv701YGAKL0It8J6EteGKulvvv5figbDgs4bqn7khJfCfg4LIuiTwkKC88J2qrPCQnZDwn6+wCjFCL+C1rjUiIibitoPIuj3IuuKQktGoWM+7OuCmijx83Izqn5lQ8JGIsyYmPSI84K2ICkBCPlzgsINF4K+QLkto17Ik8JGRndGo8JarhWA/KiYnPPCRq4U6JG/wlqmB8J+VtOCxlnJc8Ji0gTXwkIuDwqU8ChhCFjXwkYqIOj/wq5StwqVW4oKoS/CdiI8KLEIqOfCbsZnwkamFcfCdkqk/PSUneyQs8J+VtFkmcvCRjJpg8J65jzcn4oK6CjlCN+qsoHtH8JGNiFzitoPgorw6IsKr8J6BhfCRiojwkbu14LCO8JuykHvhn6bqrLjvv71g4KemNSQKDEIK4Ked4b2B8JuAiQoTQhFoIsi6a1A6TfCRtYUnP+K3jgoNQgsu8J+JgCc88J+VtAoNQgsk4b2xN/CYtITRqAooQiYi8JidkcO/eeCpmi984LauJfCQlrwqKkHwkLmq8JKUkDrwq52IPwpECgRuYW1lEjxCOvCfl7dPe/CWrJLhq4ds4YON6qyV4LeKP+GLhOG9tiwv8JCFhDrwkL+qKnEuaz86dC7wn6CJ8JGwqD0KGQoJbmFtZXNwYWNlEgxCCn7hm5bRqHhcKiIKohO6AZ4TCtQSCgdjb2x1bW5zEsgSsgHEEgoEQgLCpQoZQhfwkKS/8Ja9nSVu8Ja9j+qcliJc4rOoXAoJQgdxOvCQhqBcCgNCAS4KOEI2JfCfrKLwkLqbLz3qr7ki4LKr77+D8J67sfCQhqDIuvCeuqYqYPCRsJjwkbGwJfCeuZ/wkZqtCjNCMVwlduChk0pr776M4pKma/Ogh5PwnoGSWi408JCMvOCxmkgs4KyPQD3it4lcPeKDqlgKIEIeIT3itrvwnqOUw7VSKtGoPPCRjLJd86CHiTzwkaajCgRCAi0iCgtCCSnCpfCeupYpZQo+QjzhqYg98JGKiPCQtLjRqC/wkaCv77+swqVc8J+dvzrvtpgq8J+rsPCeuYfhmqnwkJ2Qw7omw6JOJfCesq0KDUILwqUuWyJae0Xhg4EKC0IJevCfiZEm4KiBCkBCPvCQhILitK1T4LOG8JCTouG9me+svC/wn5W0Ju+/vfCfhbAi4oKV4LOz0ag6JypQOPCflbTIuvCflbRq4KqRCitCKfCQq67vv73RqC7DtTHhoYTwlqub4YOH4LSEyLrhoKbIukA9SkpgKlVtCglCBzUiw445JkEKE0IR4YqW4YySXGwqLiA9OyR7wqUKKkIoKvCQgIIq4LeKSOKwhDzFm0E6JyXCtHrgt4VcIuG/mmPDnV0s8JCBhgoWQhThrJc6YG9GLi1a77mr77+9bHItIgoCQgAKMEIuP/CQoaLgtKdg8JCHui4vw5nwkaWSasi6wqgvL0TwpKqy8JCAtCo9JNGoYDwnLAoEQgJsIQoKQgjgs7Mm8J6fqwoTQhHwkZOUPGLvv717M0bwnZWNNAoCQgAKHUIb8Jq/vT3wl7SPTlUnPe+/vfCQrpnwn5W04Y+9CjJCMC7wn4mAJy8uIuKCmi8n8J+VtOCtlVxpJOCutyrwkKiwUlZPIuCnnCciLiVQJz1yIgo+Qjw8wqUv1Y5ROfCRsIjwkKSWaSfigpDgpolcSCXqn5Mq0ajwkKer8JGjrC5g4LC/L+Cwj+qtiiY68J+IgCYKCkII4K2WJSrgu5YKD0INXO2fo/CRqrzwn6+1JgpEQkLvt493L2Dqqb0v8J2Uj+Cxhz09XC/ivaPDmD3it6N68J+qgfCQraosP/CdvKfwm4WlOvCWp6lEYUrwkZmW4LqKfG4KR0JFZvCrn6o8wqXwn5W0e+Cho8KoLuCzoVxg77iW8JG/j1wiXOCwtPCdqpwg4LeW8J+VtPCflbQnOsi6JyTwkbuqUVzwkYaYCjpCOPCepZ7RqMK0PfCdja3DiMi6XD/wkbKrUTBU0ajwnrqRPOyViCLik7Ev8J+VtOqfke+/vfCQubZACjNCMfCQhZN5cPCQjIbhi5HwkYyeXPCQsI/hi4Ay4KCy4KquLPCQpL9Gw7zgrZUkKW99w6cKKkIoeTrwnZSS6qmMwqIm4b2dJPCXgKA6eyfwkZmW4rWw8J66o9Go77+9LgoiQiA38JCGk8Kr8JGFmFzgpr5wTzrhn6Hgr5A/TWbCpS8hewo/Qj3wkJ2ENiIlJWAkIiLvv7088J+vgUw8Jdez8JGNl8KlQT3Iuj/wnri5e+Cpnkbgr4A88J+VtOqZq/CRiI09ChlCF9Go8J+VtD8kJCYk4raq8J+ervCRpJYiCh5CHHvwkZeGKOC2g/CQoqs68JCUkPCQipY64Z2uwqUKDkIM8J+VtD3IuvCeuYlcCidCJfCQlJNg77+94bG88JG0uiYiYCVRKuOEp+CzlfCdm41OLirvt48KB0IF4oKveSYKLkIs4reF4Z2wLsKle+C7jj3hg4dIOu+/vTvRqPCWvYV7YGPhv4xVR+CmslzDuEUKG0IZZNGoPVgje2DwkIqT8JCdgyrwnriC8J+VtApBQj978JGqvS4u8JCAhuC6s/CbhLIvyLp78J2Uh2AiJ/Ceu7FKL8OYJzpnOXvhirTwnZWXwqVHJu+2uMKl8J2qnzoKOUI36qC50agv8JGclV840ajigIXzoISm8J2qp++/vfCRspnDl++tg/CflbThvL/CpTU6L9GoKu+/nAodQhvhpYAke3w68JKSoPCehJ/wn4mR4Lep8J+VtGgKO0I5JS/wnoqg44afY+CtofCQo7Twnri1wqUuNifwkaS8NifDlEAp4KmIw5Z+POCtnci68JGMnWhaw4VhCiBCHi7wkKi44oOjLiXit5bwkbai8JCdh8Kl8J+VtGUnYAoEQgIuXAoEQgJ6XgoxQi/wm7KCPGDwkIuiKnEvSUdgyLo/aS89aSLvuagm8J6kh0wl4K6IPyDvv71UPzzCpQoPQg0l77+98JasqPCfqbsnCkBCPkfwnZuBJfCeuZvwkpSqPFUk4LKOIvCeua7vv717ePCQtLc6PfCRjLd74LK9RPCQlIp98JCGoOG3oT1f77+9CiZCJGZw4b+04K+we/CeuprwkLOVPT17JH57OsKlXPCQpKh0wqUuLAojQiFYcO+/vVvvv73CuPCRpJZDKicmMFlNPXnvv71v8J+VtDsKP0I98J2SniLwkKS/77+9IyYk36M/77+9Z/CRtLpuZPCav7l74LK5e/CQp69pJ+GJv/CRqInNvkd7XMKlPcKlTQoJQgcmaiIvwqV5Cj1CO+GglWAlKsi6VeCnl/CQpL86JeCuqifwnoCkPeqgs9GoyLrgsZ3wkKiiIsK78JC9tfCQqJPwnqWZ6qevCjZCNFR7Pz8/Oio/Je+4kHHqoogmMeChqSxt8J+rsScnOuqsjjDwnoCJ8JConCoq8JG0uuCmvyQKNUIz8J+VtMi6L8OwU11C8JChuXs/4LWI4L638JGatDpJP+C7iy/htq86wqXgqYxZ4LuGYsKlChFCDy/igbXCv/CRmajwkIaAPQpQQk7wnrmC4LOy4LGWPyfCtOCth0XigrfwkYqmQvCegZ4y8JGAp/CWvpUi8JGMsuOGr/CYtIDCpSLwn6CEIvCeursm8J65i++/vVIm4KilwqUKKEImyLpAafCegKAoZvCWuZR9KuCmnNGo4KuLdCLwkIC88JGxpvCQk7QKKkIocvCRo5Er4KeNXPCdkp8k8J2SuyfqppHwkY2H0ajwlr2m8J64tuGkqgoXQhVX4ay18J+vsHhe8JCguOC3mfCeuYkKKUInQVNB4b+X4KizR/CflbTgs6Lhp5Yi4LSTYHMl16Fc4KeiTlw977+GCiUKBG5hbWUSHUIbbOqVsiVq8JCNmXs/4r+2e1jgqYdURCLwkLyNCh4KCW5hbWVzcGFjZRIRQg/gq7pc4rSn8J6Lv3LRqDUK3BK6AdgSCuURCgdjb2x1bW5zEtkRsgHVEQo2QjRB4KmAwqUmXPCfgrIuWTrgs68uSsi68JGKjOCykPCeuKck8Ja/sWZge8i64aWY8J2Wmi97CjpCOCov4LSG77+l4b+YOk/jhbUv8JCPiPCdkrhtYC/wn5W0PPCRsIjwkYukP/CfqaUi8JCBg03wkaSWCh5CHC7wlr+iKHtgYCUu0ajhv5p7WCTwnaqfbvCfiZEKDEIKI+KAgybwkaamMQoxQi/wkaaiWSJlKj/wn5W0IvCQioV28J6fpSA/YPCQurAmw7Tvv717N2bhqoThm6ZgWQoiQiDDh+qpmSQ88J+ruCTwkamBVPCQj4t7P/CQs58gcyTIugoPQg1V77+98J66oi/wnoCkCklCRzwldfCQs6ok4Luc8J+VtPCeuqNKJyTit6tC8J2IqT0n8JGrnVdv4L6ByLrwnZSR77+9wqU58JatkMi68J+giPCflbTwkYyQCi1CK/CYq7F6QVwl8JGNjeCqqvCQhIE6Tz1qyLpc4KibPHvwnri78J+fsOKAm3QKAkIACj9CPT1+WcKlYOqsq+GEm+GfsOCgvk8v8J65iyc7Ji7grq5g8J2ViyQk27nwnZK74reO6q+16qOZwrQkLOGcpyoKMUIvP/CQrbAv8JCGmNGoIjxgbSrqn7XIuiYndCXhna48POCpqGAl8J6FjuGJpeKDgGsKH0IdLULwn5W0L/CRq5nqrJPDqXvRqC9o77+9XOC1iysKQkJA4LuGVsKl4K6k4ra18Kyutz0kJ2B88J6gqlxW8JCpliIn8J+RqnV7JO+/pTckJiRh4LWI8J+rhfCdlJPCpeGCnQoxQi898J+VtHcq4Y6N8JGNjTDgro/irocjwqXgrpkvOvCRi5ArXPCflbQl8J2RqOGgiAofQh084Yq6JiIuRV0w0ajwkIuMwqV6wqV1UtGo8JGysgotQisv4r+zPXY84LGZ8J+il0YkX/CflbTDq3nvv73hsazgo7UvViTCsO+/gi1dChVCE3jwn6uo8JGkkUEiInbDp0g6yLoKKUInyLo8eyc88JCAv8i68JCWnsOqQFzhnatqyLrgsrcnPS5NPfCWrYRiCipCKMKl8JCWleCmqu+/vfCfnr5cw4TRqG7DvS9gOuC6hCZbe0tCZeCxomIKCEIGRjhjKsKlCkVCQ+Cxh/CeubE7PF3wm4WV4KS+4LuG4rO5Iitr0ajwn5W0MfCQqLgn8J2Sj1zwkYy3IvCeuZsnJOCur1cv77+8w57CpSQKL0ItwqluOzzwn4e28Jq/sOGLhCIk0ajIumDhvZvgr60v4Yun8JGkvirgt5DwkbS6CitCKdajJtGo8JCAo/CQjLHwnruw8JG1hkPwkKmRRjrgt7NKSfCfqpA377iQChVCE86M8JCOpeGfqMOg4LOyUSnvrKkKNkI08J+bqUfgqoE/Jil68J+rgiXwkZmSfFZ3eyo2YGnhvZkvPy8l8JCEpFzgt5ZBOsi68J+qhQosQirRqD948JCWszct8J66kj9iY/CQmb0i4b2b4rSnPcOZP/CdhZDDuD3vrKkKFEIS0ahZ8J+VtPCRp5RU0ah5dXthCh5CHGMjPPCbhZXiupknTTrwkKiSLyLwn5W0dOGfsCQKBkIEZz8mJwoiQiDigpfgroLCpSQlLsi64K6a4KmNPCYqwqXwm7Gx8J2SngorQilJ8JG1pCQhcnQuWsi6YGA84b+ONHsiwqXwkICF4YmN77mIREPvrKkqLQoQQg7DqfCflbRKXGDitK3CtwoWQhTguoLitJQvYCc/MuGkt+GdheGjhAoGQgTwkYeLCj1CO+Gds9Gow51cL/CWq4jIuvCQrq7wkbKNLlwqPVHhjrLhoLshJ1xy8JuEsnzwkICv77+9PzEiP8i64L+WChxCGisi4YmMyLrwn4CP4L2yIirhnZLgt4Q6JCY/CiZCJGXgqInwn5W0P/Cdi6w8P++1tCfwkL608J+VtCFIVdGo8JCojwovQi3wnoSVyLpLVyRe8J+VtDNtOe+/vGBF4K+HXFzhsLvwkYiAOiRbdS/wkYiIJzkKNUIz8JG/iHFtJ8KlNnHwkaSM6qWg4oGwOuC6iCfwkYyzPeqgtidE4K+XYjvvv706I+CnnCo8CiNCISfgtKkkOCHgprgu4L2z8J6kuksv77mqL1zwnrihRcKlewoHQgU48J+VtApCQkDvv6XwnoCqwqXqqprwkYOX14E8XOOAs+CqiuGhgStVVEXIuntOwqU9L++/veCxoXsmL/CQpJMiwqXhi4BY4KGeCilCJ/CQtLPgqZzhibpoLsK4fO+/vT8l0ahTPS7vrKTwkLm9ccKl8J64tQofQh0v8J+VtCbhv7Pwn4Cq8J65h1xyPFZkLiVYfOC6iAo4QjbitZfwn5W0UT/wnoCccz89KtGo6qe08JG+sElqYOGfpOCxmsKlR+G/vCUm4KmewqVr4KuwekYKHkIcYDp18JChki7hg41Q8J+isVzgsr7wn6miJWrRqAo8Qjrwlq6M4K2cdS5+8JCSv3540agv8J+gg0s9bNGozofgs6rgrolJYzw88JGFm/CeuZLgroXwnaqf27w/ChtCGWBb8J+VtClg4q6O4b2baGAlOiLhppzvv70KJEIi8J65n9GoLPCRhajzoISR8JG0jmB7L2rwkbCwJCUu8JCohQoCQgAKJkIkIjwpK+qnmUXwn6qDKvCRiojRqCRjIu+/vSQuYsi64K2sNdGoCjpCOPCfqoEuJywlRcKl8JGpvyZi8J65i+GxreqslGvqn5PwnrmfX2DRqDbhtYxbP+qpgOqfky4t77G/ChdCFSo8IiteTi5GdtGo6p+Z8JG0oC8xYAoVQhPgvY18Sy4qPOK0p23Dhkpc4aCVCiJCIEomIntQ8JGDgVw/IvCfm7xd8JODtOKBsWoiJyzhvKsuCkdCRUU8VcKqJ1/wkKi48JG2lCRf77+98Ja/o+qspPCdlLYx8JCWuFc+8J65ty7wnbyDe/CQuqbwn4OwL+Cukz1xLi4v8KyQvAoJQgfwkJW44Yq1CicKBG5hbWUSH0IdOvCdg4Xwnrm0YEvRqCluNybwkY2hTEcg8J+rjycKRQoJbmFtZXNwYWNlEjhCNuqhotGoV2Y/SU7Iund98JGFpvCegaHqrJVJ76yT4Kyy4oqe8J64ovCRk5ngvZ7Iui7CpeqnrwqhGLoBnRgKvxcKB2NvbHVtbnMSsxeyAa8XCh9CHeGxh/CbhZXvv71kd8Kl4LGALGBc4LuGJeOElT0kCkBCPj1q8J6Tse+/jmDwmJCNXF7wnri5KuGJjC/gsYbwkaSl8JG1lfCehLjwnZSKJj57K2c7RsKz8JCOivCRgr5ICi9CLfCRpLjhjJMq76y+LkN0cT/CpXvwnrm+24wl8JCWvD3hvZnhg6Dwn4Ok8J+VtAoXQhUvNCFvwqXgtYHhpIzgpovwkI6BZioKCEIG8JCujjR7CgdCBci6KH4nCgZCBFxuJ0QKIEIe4LOI0ajjhbF48J64ouqsg/CRtpXgp51hPMKl4r+3Ch5CHCbwnZClI1fwn5W04YyT4YqKKi8wOPCfh7bgt4YKI0Ih8J+isHVg8JGMgVQqJ07gqYcqWuqasDokNjUgdvCWqZ57Ch5CHPCfoqbwkY2n8JCpkPCsk7o98JC8sUvgr6h7ZlwKNkI0P2su4rWJ8J2Sv8K58J+VtPCRjLUqK++5o+K2skU68J65rjDwkJaZ8JKQn/CflbRH4Yq8LwoTQhHgrr5pJlgi4KC977+98JCBhwoFQgPvv70KOUI3L9Go8JGKjDMv8JGwoyQi8JSUo+CzolY6ZPCbhabwnqS6aSJfeyXgp5fqoqTwkL2JUV3wlq6LIgoqQihxYPCQqpZUJuG/hmvhv6x78J60qO+/vfCQvbbikYhv4YmM0aguNnEyCgdCBWBW4LGsCj5CPPCei78lKuGKuOCvi247RiDwnZSf8J2RluKAkeCouXRaSzhDUPCeua3wkbWi8J+fqtGoePCfnIEiPyY8IgpBQj/DqvCfq6LjhKfCpXg68J+VtD/wkJKTQkM9JO+/vSbDtCDwkbKv4K6T8JGNsfCflbRgL3vigZzwn5e3O/CQoqoKC0IJKknWjXvwnoGXCkhCRk1w8J2LouCngSvgrLlc4Z6wJuCwrSUm8JCSqfCQj4PwkJKk8J65n09r8J+VtNGoONGo8J6Lv/CetJ3wkYyPw47CpTzgr4YKFEIS8J+rl+KEu0vwnLyrJz/wnZSUCgZCBOG9kSEKHEIaYGBcJ1U9W++/hD3vv73wm4Cx8J6xtGDgrZUKGkIYKvCRmaxi8JGSkSbRqPCdlYYq8J+VtD9cCkRCQvCQnYA98LGYuCbvv73wn5W0SSLhjIPgq6gmfkXwnoCE77+9fCdcOuq0ruCrkPCQgIJ7bjot8JCgiO+/vSQi4K+IIgogQh7RqGQ8JuCotm/CpWFo4LW98J2EhNGo77qC8J+VtCwKL0Ite1wkwr0j4Ki1PS0saj1rIuG/suCshjbwkIC98J+isCbwkbS9JHvwnp+ze3ssCj5CPDM017Is8JGGoz/Cr+GfpOKlji0k4LeCJ++ot++pqeqsgdGo8J2FgSYqJOqeoPCfq7RoefCRiqB8OuCrpgosQiopOu+qk+GdruCmrWVcJkR5JHXwkK2UYOGckFzwkYq5cirRqOChoPCdnpAKQkJA0ajDhPCQpoM9YOqfl1fgqL8zIvCRtahfw6fhsJtHIcKl8JCosfCfkZzwnZ6V4KiBWSrhnIZ777+S8JGMhz1cKgo7Qjl3OibwkIGHdyrRqPCxnrzwkLywaifwkKmAyLptIjXqr7Ba76yX8JCnnuK1iC4vLOC3qPCdvKnguoIKHEIaVnbhsphWLuOAjmzCovCfrbvwkaK58JattjUKKkIo4L+K8LGPlPCRjYjwnriC8J65gkXqqbLgpoY9eDrwnZSXP/CdjLNUKgoHQgXgt6kidQoeQhwq4LGVJ++shci68JCtgT3wn5W0LjTRqG8qRmclCi9CLfCdkavqrIUiJGXwkKC8W8KlJ++/veC7iVzqmJAuwqVcyLrwkL2COiTCpXE/XAoVQhMlTVzwkJ6iJy/gsqrwlqmvKNGoCgxCCvCfqqAk8JG+sCoKBUID4oGwCj9CPfCQq5DhnKvgrr9dIibgtaZWKSfwnYunYCDhrYTCpfCdhJ5DTeCtoi48UPCfnKB78JCWg+K6rTM68JCLsCIKGkIYNOC0kCThirvwn6+z8JCajz0uJCpB0ahcCkFCPz83JfCQqYR58J66p+qtn3BgafCflbThjbA9wqXwkpGx6q+44LOz8JCWgyPDu/CflbQq8JCoocKlfsKldmovOwoIQgZ24ruaazsKPUI7JClyPSJg8J+VtPCRvILhvYpXP8i644SG0ahtRVw64bOU4K2L77+90ajgsaHwkKah4aOL4Z2rYUvtnrIKMEIuTSfwm4WVIdGowqUvJyou8J65qizvt7hgJiXironCpdGo77+9LyrDuDrwkJ6OJgoMQgoicMi6OvCRioh5CjlCN/Cfq5bwkJaUXGfigqvgqpHwkL+z8JG8sCrwkISA4KiBZu+sgirCpW4gJXt74am44bGgPci63LUKP0I9w6EvLzzjhpbDkvCbirdL8JG1mOCuqTzDlDps8JCuhVvwnrmtReOBi/Cdi6ol77+kJfCeuYIlLsKl8J+rtgoTQhHhnZIt8JCLhWnwnrmfSeKimgomQiQ2WOOBhfCfg48+PvCeuKQq4LGdYPCQhqDhsYgnPOCumiVmJSUKCUIH8J+VtHslPgocQhpmOnEzQifwmr+9IyXgpq7grp4q8Ja+heK1sAooQibitrIgJPCdg7PwkLyE8Ja8ojvwkY2Q8J6lmU1NXGHRqCLvv70rYAogQh5oXmsl17TwkbG/YDoq8Jy8sVzRqMK94rStbiLvv70KO0I56qOQ4aqrJSrhg4098JCAliLgqrbwkbC98JGbhsK2PfCfoIQk8J65vmDqm6vwkYGyQ+CshW/IujpRCgdCBSolU9GoChdCFfCeuZvgqLxD4ruBL+qplCbwnrmSJwoWQhRna2pQyLo/JiR0STRy77+9eyLIugovQi0iIl/vv73RqPCRiovgppDwkYqKJOG+m+ODoEt7PFcvPXsl762EOvCRioh2YFQKCEIG0rvvv70kCkFCP2DwnYuoYybwmr+58JGNiGBF8J65l/CRgK8uVsKlWTzwlq2fUV0lJeqSlzHwn5W0L8OePlzigbhg8J+bsMi6Ogo3QjXhiZM6JsKlwqXwkbWTcz9v4YOH4LWMSfCfnKzwkKqR8JG0iPCbsoMn4KeLe+Chp+OEl8KmUAozQjFCJOCottGo4L+TPe+/veCxvPCRtqFgzoThp5U6dPCegKYuPSTgoKYq8J2NssKl6qGJCitCKeC9mfCegJHgsZ3Dszwqez/wkLqsYT9cL1wuKksuLSDDjXLwm4WVM8OYCjpCOFzwnqWROvCSv5rvv70p4Ki8aibwkJaV77+94ruQbDpgJ8OI4Y6ELyfhiZMlL/CfnpFu0ajwnZK7CjVCM2DwkYyDPfCflbQ/IvCepZ8nPOCng+C2oiJX77+98J6AhW3gqIjit4DwkIC8ZzQgd+CvrAoqQijwkbS977+9JmBc0ajwnriy8JC0teC2ilc88JuFlfCQlpIt8J+gtzo/CiFCH+C6pSch8J2Vhj1aJHF78JCMufCYtIAmOCoiK8KlPzwKBkIE8J64pAoYQhZg6p+9dNaH8JuEsljwkKeJXGXguoQ6CgtCCfCRp4/Iujo/aQosQiokTTtMJOC6hCQq8J6Lv2DRqHXgqZ5cXHtnXEJjIn7igpHvv4ome/CQk6YKIkIgP8i68J60l0BYdeC4m2vwkKmI4Kq3P0Rs4aagL/CRmaEKIkIgIioqKsKl4LWCKmAk8JColjU2yLrRqD3RqGvwkIagJlEKMEIu8JCUoyrDtvCfoZPRqPCRsZIl8J+VtCo9LuKAiD/gsK/wnZKLUD46yLpk8J+VtAoLQglcVeOBjDoifioKB0IFUDoiKiYKEEIO77+94bOGJfCeu7HvrL4KAkIACj5CPDZuJCpR8JuFp/CQnoFMLvCeuKfIun1bYOC8smfguqXwnZWCWvCRsYLCuPCRsYJg0ag88Je+pSQ8Is6MMAoFQgM6w4sKHUIbalRZLzPwm4Wm4L+T8JCPk+qkhSLwkaSE4YuLCkgKBG5hbWUSQEI+L1B7KvCQgrE6XTrigpvwnZaP4LGa8J+Ik+CyvTzwn6CeNfCRsp7wkbKIbPCRg5wmfuGygu+/vfCRtIbhvZkKDwoJbmFtZXNwYWNlEgIIBAqxEroBrRIK1xEKB2NvbHVtbnMSyxGyAccRCjBCLvCeuYIk4aWx0agqRPCflbTIuu+ss2o5PfCRhJ0mJcKl77a18JatoMKlS/CQkI4KJEIi8J+hgyovRXDigpvbrEYgXFxcJPCdg4BJVGAuXOqlrjPDiAoIQgbwnYuxSD8KD0IN8J6klT0/JGB7eSpeQApCQkDCpfCRprM977arXFzgvrY0wqUm8J+Qo+C0iPCdqp8uJfCRjYdcwqVg8JCbqDw/3Jnvv71V8JGgofCeuZ8/d8KlCjdCNSfwnri5NWfwkbyTKmB74YON4oCZIi0qOiXcrsi64YuDJ/Ceurbwn5W04K2X8JCiq+GNn3ZiCjFCLyckJ3Y9VyNJe0LDruCziNGoJfCRjYtXJSpJ4b6s4LuZL/CbsoXwkoyaJ2DwnrqjCjpCOPCen77wnZWLVCQ/w68iU/Ceoqth8J66ovCdm7Y9zox7Kkvwn6uE4LeDRFXqrI5U8JCOhPCeuaQuCipCKPCfiaLwnYuiPHZx8Ja/sUk8ZuCvjfCflbRx8JGBmCJRw5DRqDPDuy8KJUIj4YON4LSHPnbhoIdcyLpL4ripQ1Mu8JakiFXwn56iXCgvezIKHUIb8JGnnCVgKvCQqpEk77+98JGqhvCRiIXhnYNMCihCJvCSv6ZsJeqpuPCfrqIpwqXitqJkOEMi8J28mifIuvCYtIHwkKO1CgpCCCU9JT/Dh1hTCgNCAVoKNkI08J6lnip08JasqvCRgJrgrqPwkpOI4LGYNy8lKvCeuaIl77+9J2gmKvCfm6s/RyZR8JuFkAoyQjBBwqXvv71d8Ja8nijwkKS/P+GjmPCRkrhXLzpKyLrhpKl6On3wlq2sZOC4r0k6SCcKL0It4Kiy8Jihk++5sPCeuLnwnrmZ4LGL4KiC8J+gg/CSkp9F4LWU4b+jJ1zwnoCNCgZCBGXCpWAKKUIn6q6FPS/grarwkJaFIV11LibCp1clJ+Cxozzgt4Mmey9PezHwkZOVCiVCI3tg4KayJMi68JCouOC3q3fOjyRodPCQoLw98JGkiToqTSJ7CgZCBCrhu7gKBEICZlgKSEJG4KmNPzrgsLbwkKKs8JGMg/CeuZfwn6GY8Ja8p1zwkKmGRfCdkp7vv7wjOsi677+98J+VtD0sKvCbhaXwnrSvZEYmNiZtJgo+Qjxn4K2hV+C2uSIuw4hHP/CbhZUq8JG/pfCRu7ThqpPqrJTRqCrDoHxE8J2QjeK2q/CeuqNzcuCopfCWvbkKD0IN8J+bncKl8J+VtGl8XAoZQhfgr5DwkIC/cGXwn6KxYOGcgOKFmS4vZAoTQhE9YMKlNSfwkL688JGNsuGBjgpFQkPwnZmK4bCUKuC2g/Cdkb4lb1R58JC6rCbwm7G5wqR7JSXwkbSEJ/CQhIFbP1HqmJXwkYqKyLo18J+mnsi6afCQkYYlCjZCNHlv0ahl8J+qgMi68JCGoGw64bKBSy7hiqQvw5bwkbS64Z+TSfCfm7QlOFc88J65mUwqyLoKG0IZ8JORj9Go8J+VtDwlPD9i8J+esiQ6QC8iJwoTQhF177+98J6Aj+CunD/wsYuzYAoQQg7Yn/CQoIgkYCvwkaWEYAoIQgbwnrmHLzcKNEIyKmYk4LOdyLouOvCWqZPhsq12bfCRmp3wkbGB4Z+nKsKlXz958J+VtPCeo5I/OTphbCIKNEIyR8KlYH5caDw1w4IiYfCWra084Zyr8J6AlMK48J+hleCvjMO1XPCRpqMkeUrvv70n0agKGUIX4aSHROCio1figbBm8JGTk/Cen6ZXYC8KIUIfa+CyjuKAn1zwnoCLXOCxmuqhpE0m8J2NpT1E8JGIjwooQiYlwqUvLTfwn5W0LiXwkKue8JGwrC8k8J+VtFQ4zpcuYyLwkKCYRQopQidVwqVqwrti8J2UqmTCpdiPJ3klLkxw8JargT8t8J+VtDpw8J+rtyMKBUIDKsOpCiJCICI84aabJOGMlSUvLydKJfCQhpgkJlQk0ag0efCWrbRgCk5CTMOL8J65ucKl8J+VtM6F77+98JCnsPCeuZvwn5W0c/CRhKzvroQx8J6frfCQj4lP6qabKi/grbbiuohGYDzqrL/vuYc86p+XKnPXtFwKHEIa4r+z8J+fpPCflbRDM157XD9wOl/goqTDkD8KI0IhZ/Ceo5PwnrmH8J65vj/wkKC48J+VtOCkjfCRiJHqo5c6CgNCASsKKUInOuGDjSI6an4/Q/CflbTIusKlZO+/vS5mZ8arRlnCqvCfgrQvPci6ChFCDy11PWDgqIHgprcl1ao4KwozQjHwkKeb8JCihT3OhvCQq4Yv0ahaOsKvPzfgpoYyU/CQuoExLfCflbTwn5ugJz/wn5W0CjpCODDwkY2DTkfwkKO18JGyp+qtpPCfiJrRqCrqkpM/PSrhi4nwnLyyeyrRqCYl77+98JGMh1jwlqmPChZCFOGojTBcIfCbsbBcb/CflbQv6qeWCgNCATkKM0IxJvCQoIVAL9uU8JGyoGDDgvCegKTwkJasLuGMnizhsbTDnC5HYHt78J+qsiYuQlnCtgomQiQrPSI/PPCegJA8I1w64Lyz8J2LqXhg4LC18J65n2Iqe+GDhyUKIEIePuGJmG/grpxl8J28hiTCpfCYsJ4g4Kyye/CdlJAiChdCFXYk8J6folzwlq2uTyUlTvCfr7fDgQo3QjXwkYanJlQ64K6ZOuCsh3kkQU/hhIfwnoqb8Ji0gOCvkH5vOjThpaTvv73wq7Op8J65mci6TgoSQhDCpTwl8J65oj/DozzwkbSJChhCFmDIujrIukw+MuCghO+/vfCRtpTqopkKM0Ix8JCEjM6MfOG8pSXwnrmZbOCzsuCviFzhrKbvv73hjbXhjI/RqPCQgI/wkpG08JuFpAo1QjM88JCHnELwlr+g77+98JCEqUhUwqVcJ1Lwn5W08K2nsPCdnaDhqJM9Ijw9QDfwl6KReyIKDUILP/CfoIU8O/CflbQKFEISLlnwkZmnfHtGeyDwlqqBKt29ChYKBG5hbWUSDkIMJtGoezUxR/CQiq1+CjkKCW5hbWVzcGFjZRIsQirwnp+6PD06VCfCpT0nZGbvv70l77+9dSbwkaWZ8Jq/vfCflbRcJWDCpioK7gq6AeoKCvAJCgdjb2x1bW5zEuQJsgHgCQobQhnwm4WV4LaTXDfRqDLvv4Pwnp+5KHMl77+9CitCKeC5iiUkOuGisGDXsXJBaOG9jcORJydIVtGo4reC8Jy9kHYnOvCRq64nCgJCAApDQkEkXFzhqoI0YWY6PuGql+C+uOGdryrwn4Oj8JCAm0BFelLwkL2S6qe2JvCetIlQVi8x8J6Ao/CQgYHwnZK977CMTgo8QjrCpfCQgL1xaCThv5JZ6qySRPCWroRQXuCmrjwi4LuI8J2Su/Cespom8JGjkvCQoLEkJ3smwrHhqLQ6ChxCGljgrojhrIkienvIuuqqkCFgcSUuOiYuw4skChRCEldP8J+VtCYyJPCQlo3wkIurXAoxQi/RqCLwkKeV8J+bsWDwkIWxKtGoIiUiUvCdlKk077+90ajwm7GlNvCflbTCpWBlJAooQibvqqMiPSbwkJCawqXwkJWacu+/gy97JO+/jCLwnrmL4K6k8JG0vwoUQhJbPPCfg4Z0Vci6d++/jMK9PGkKBkIEe+GKqgonQiXwn5W0wqUrR9aT4ra5L/CflbTwmr+9dzPgs4dUJC8l8JGNiGA8Cj9CPeCpi2Bc4amQLyUt4a6hJ9GoZWll77+S4Kq/w4jRqOOHlPCRjavIuuC3rfCRmaou4oK6KvCfqbl74LuGwqUKMEIu4aqhYCfwkaCHeypc4byh4KiQwqXvv71P8J+inOG/s/CWrZVKLEbwkayG8J6CjwoiQiBF8J65gjY9RD9g76iVyLrgq4cw8JCLg+K2qybwn46gKgodQhvwkKC8Pz7wkJW14KiXWSQ/Nsi6OkBgJfCen6MKQEI+8JGLsfCRjLh2IvCQlo/jh5jwnouuP/CehYEi8JG2qCbwkIC8LuKStnNdKCdWyLok8JCqnCTwsLSgJXtAWGEKF0IV77+94bKvPfCfoZDwm4mFNjHwkaSJCgVCA1wvXAo9Qjt2UEPhjpIlJzrwm7CdSSTwsbmvP8OyYFLiv7DgracmdeCxlfCQv7U9LuOFsOGDh/CRoKfwkJaJTOKAiQoUQhIv8JGZq/CQioVxZz1ywrkkLiUKA0IBewo2QjRvzIw8fuqtonTwn4SuKvCRnYBtJi/qprtUP/CQlZ3IuifRqGk68JapieCmssOC8JCWvCIiChdCFcKl4aObL8KrLj3wmKOhP0nwnZWLMgpGQkRg8J6AoeCmpfCQh5bhipbgpoU38J+VtOGymTBD8J+nuTPCpWzwn5+wU/CRgqThv6Dhv6/wkYyuw6BZwqMy4Kal4K6jJgozQjEx4Yq9Uk3DiSXRqCdNVz/wlJacNfCQlpzwnbyq4KqfXPCek6cqIiJpPTrDoS/wkZGhChVCE+qguV9cP+Gdr+GxhfCWrb3IuiQKJUIj8JuGiuG9k+GKtFnwnrmXSzJR76yrJOCvs/CShKnDjC9gUSQKNEIyJO+osCZaUu+/vUFe8JCugsK7e/CflbTwkbGR4Kq/6qmJJirwn5W08JGIj/CeuKc60agKM0IxLjw9IvCQnonwkKCwSWB7XOGlgCPvv4/goZ7DkF0+cPCQhK/gsZjvv73hj5/ilbN+SgorQilw8JCEguCxp+qsjSdSaGnwkY2d8JGws/CeuYc/LzrwnrmPe+Gdr3toLwofQh1fZvCfnI7it4XCpS7vv73wkY2nJTfgpo/wnoWEawo+CgRuYW1lEjZCNPCfqbtpOuGKn2Be8JGyh9GoMeG9nTovKTooJCd7e+CxrizvuaolP/CflbTDvD/gtIXvt48KNQoJbmFtZXNwYWNlEihCJiNa8JaplW9p8J65r/CQj5R3TCc8R/CQnY4i77+9wqXwkJGT4ZyFCv0GugH5BgqmBgoHY29sdW1ucxKaBrIBlgYKFkIUXEjvv73wnrmpJsi6X8i68J64pFMKNEIyJSovwr3wmr+3KjUm76yF4b+IJ33wkbChVvCflbTwnoKPTCfRqMOBKD/DkuKLhDQnJSwKN0I1QvCQooxj8J60skhE8JGLkvCRtaLwkYStblxWIMOh8J64tPCRtInCpTMu4oCEI3xJOsKlbicKGUIXJfCeuYLDrsKm8JCokEksdizCpfCRpI8KD0INImEvXFx14b+TT8OqcQorQinwn6CG76qaJkLwn66W8JCVsSQuKuC3tOGOk1xeIuC1qDvwkIeQ8J6lngolQiPwkJ2NJSLDrDrgrbLgrK1Ke1s9LtaKTCrvv43vv7114aCTJAotQivwn5W08J28mTHwn6CD44GTTD3IukZwOvCfm6DgsZ028J+VtOChkeCznScvCitCKV3wkaST8J6frvCQoaBLJTclOsO+8JC8hkhq8JCKgCInTTxtOk/vv6kvCjhCNnDguZbhnbImJFnwnrSD4KiPIvCRsZJdOS4i8J+VtGA9wqXwkpGw8JGlg/CQh503fWzwkZquYQoZQhfwkKuFPCrqqZZf8JComvCeuY964ZyBUAoWQhQi4K6ve2zwn5W0ckxdJHs68J6FgwoaQhjvt4808JGalOC7iuGKjD838J65vvCQnoMKMkIwfOKwoXt1J/CQnY5TafCQj4rzoIWtJuC1hvCRtahC8JGKiPCQp40q8J2UifCdkp8sCjJCMGg/8J+VtOODueGlsW3qqZhB6qeZyLrRqMOM4aWw8J+VtPCfq5o277+9bOqspuK2hAoSQhAvYGTwn6qEYOGgqC9OQC09CgpCCCVBJkPvv70/ChhCFjw6LWDwnrii77+9VUNcXPCUkrbhrLkKGUIXwqU8L37wn5W08Jq/sfCav7NDfjTgqLIKPUI78J2UssO076uZ8J+eiy/CpfCeurIucVp78J64p8WCdDovwqVbJPCdqq5MwqdUUC/wn6GZ0ag04b2WJE0KLEIq4Lqs8JCWhO+/hfCbhadUKvCflbQhLTzwkKC8P07wn5W0P/CRo4Vo77+9Cj0KBG5hbWUSNUIz8J2Uvjzwnrik4KC18JCUpvCSkbM8Oe+/vT/CrD4qJzDiro9xQz3wn6iaw4Bk8JC/tCE6Cg8KCW5hbWVzcGFjZRICCAQK2xK6AdcSCpMSCgdjb2x1bW5zEocSsgGDEgopQifiroHgsJDwn6uOP++thFntn4XhsYDIuvCQrb7guoQmMu+/vfCeuYkKJkIkVsO7wqXDoy9AYiBWInfwnrmf4oSA6qmASkZy8J65t/CRpIE9ChRCEjYn0ajbj2ZQL3QueyV+wqXDnQoEQgI9LgpJQkfgv4Zg8JariDJcJTnwnZio8JatkOCwtuCugjzwkKC8wqUv4rWv8JC6sDzvv73wm7KCOlzita/gs6PwnZyxXPCWvpDhpbFydQo8QjrwnrmH4Z+WOvCQqJB2PmTgqq3DmmAq4Lqp4LGdwqUkYfCQoLcuVlteVE8z8JCdg8i68JCjv/CflbRgChVCE3Je8JC9uGBF8JuFktGoJj9WIkcKKEIm4aWzwqXhvL8u8J+AlDg88JuKjWDwkYyu0ajwn5W0TfCQi6nvtJ4KKUInOizwnZWDYS46e0/wm4SyLvCav7lhZz17bPCdvIsk8J+VtC41Klw9CjpCOCDhsbIqXHs6MvCRtLrwmr++wqU9Q2B+PGfwnp+tOirCsCbhvJgu4aCW4LuZ8JC0tPCen6TwkJWFCipCKFomVuC1j+CziO+3j/CflbThnIxcK1Hgr4YkPSck0ajwkIOKOmPvv5cKMUIv4L6cP/CflbRmYHwlT/CeuYnRqCXiuoEzwqUk0ajwm7Cp4KC3PXsiQjpgL05gPnUKA0IBPgonQiXCpeClnC7wkLqxOXtu4YyUdUTvubRwJ2knMVzgt4p0wqUq4L64Cj1CO/CeuYnwn5W04KWMKfCQnrLwnqOH8JuFpvCfoIfgobV7yLom8JGMkD4k77+9TyY84reaZnts44Sq0ahgCjdCNeCwjydeOlfgroZMSCAiP0Ny8JGWhvCRiI3gsZ3wnY24L/CflbQ/0ajwkJWY8JCpgPCeuZdFCgxCCsOM77SWfGlC0agKAkIACjpCOCLwkZyN8J2SrPCdkrs6UnhyIuC3mifitr57PVtNJHVG0ajhnaVi8J2UtD978JCiq/CRpLTRqHI/ChJCEHJT8J6lgOC7hmDgqZHCpSYKL0It8KiHgtGo8JCsoDE3SeCosvCQvL014oGSXPCQrqnhv5s877+9Q1xuYGDCpTAkChpCGHt40ajgq5AzZuCuqXAn6qyCJeqnozwkTgpGQkTgrpDCpSfwnri5IvCQo7QucfCQtLXgsq9u4aWAJmAkJuKCpS5S4aSR4LG3R++tgeOBqfCRi7Dwn5uoVvCen6jDiCRcfgoVQhPwnrikL23gr4bwkISlw6w94LedCj1CO/Cdk4E/8J+smGEvwqVYYOCqqPCvp7YkI8K2yLrwnrq3ei49JPCRgZvwlr+x8JGLtiXvrKPgqJXwkKiVCh9CHVtR8JGKle+kk2o/fCBueSfIukI6JnjwkbaX4auHCghCBi7wn6m0Uwo5QjciRvCRiovgvZvwnoKPJy9y4bK+8J+VtOqqr9GoZ/CrsrvwkbKlIvCfq5rwnrqjJuG9myLgtpB8CjJCMCfwnoSG4YmK8JGNp27ckFMqXPCepLAl8JGQt28/zbpkwqA9Ju+/vfCbspQ9PcOrOgoXQhXvv7xs8JCFvSLvv73qopnwkr6re30KKUIn6p+RJzzgrIFb4rSnL0Hwn6mt4LCQPHsq8J2Fsiwi77+9dCJA4LCFChxCGuCri/CQjK7RqCZFJfCdlL3wn6Kxe35A4aitCidCJfCRpZTwlr+iXiXhqoPWpjU/4LOI8JuEsnI98JGHs1xh8JGcq0sKCEIGKkclWsi6CgVCAyk8RwoaQhjhjoZc8JGyqjzgrrIy4K6Z8JuFpFzhg4cKOkI4PyokJ2Hwnp+t6qep86CGreGghCUlXjx3a0jgrL4+L+G9m8KlwqXwkZCj4Kqd8Ja5uUXhg43igpIKLUIr8JCNh1zCsCfwnrm+zb3vv7088JG0vGRBXj0k4YuAJMK6KvCQgLl58J64pwoMQgrwnYO0MTo8J3t3ChpCGCLql4h74byp8J60pidc05JgwqXwmJmhZQoFQgNNJkEKK0Ip8J+Tg2Tqn5Zv0ajDqkzgtI7CpXE9e1zwn5W08J6xsXxcPOChnvCTj6MKDkIMKFzIumkmc3Dwkam7ChpCGH3hnYbhgaTvv4vIuuGJi+qmpcOc8J66jAo5QjdvL2AiyLouRuqdivCQrK7wkb2B8JGksvCeuqImeyUqyLrwkbSCJmxaQiIiL9Wnw4Rb8J2LqipFCkFCP0TDqC7DlMO1Ki7wkLmv8JCGoCRdJEfwkK6szoQl8JCiivCeuafwkbuy4oOgw6BN8J+epSc+TCI84reF8JGynQoCQgAKFUITey/vvq88KuCrqDHOhdGo8JG9kQouQizwnrqMLi8qLuGwvCjwnouJQD3wkYa4ROC/j/Cen6VxYSLitqMj8J+ghuGmvQoxQi868JCUoMKlWfCQqZFcIG3vv73wkKGq8JGNsCThirjwkYyLKjw48JG0kjrwnZK1IgoIQgbDv+C/jD0KE0IR77+9XPCRmJvhsbAiLmA9ZDEKF0IVOmdcJ8KlS++/vfCQgZzwnrqJWjwiCg9CDT3qpaHwnrmRPCfCpWAKLUIrJPCflbRDJzdxw6MvIjo/4Ky/XOCttPCQo6UiUvCRtpbwnrmkPcKyKuGdswo4QjZc8J+VtPCflbThpbMlJ/CSk7jwkIqOXDJybnvwnoqRwqU8POOEmW0q8J2TjdGoTfCWv7B2L30KOkI48Japi/CRi7kj4K6P8J2Spn5+4KuJ8JC5tGUoYF0iSvCeuYc3bci68JCguCQ/8JCygOqvse+/vTwKF0IV4LaC8JCVvlZI4LKIKuCsgsi6YENgClBCTtGo8JGNq/CRtIjwnriD4aeY4KyDIibhoJjDmfCehI09Ii7wnrmxJ/CQspJm8JCmnSUu4K6k77+9YCHwnZSQ4aeq8J6lniXgroJ78JCzkgo+QjzgqrPCpSrgqpZce/CflbTvv709yLrCpXAi4YqXJuC6hPCWrI9mUydqMfCflbTwlryK4KyP8JCpmPCRsbEKHkIcw5vwnrinL/CRvrA6Mj3gs6N177+94Z+gWHpgKAoTQhEkJio/8JGkleKCgsKl8Jq/uAouCgRuYW1lEiZCJCkmIvCRsp0iUE7wm4eF6qivbe+/vfCfoIrgqonwnoCg8JGFnwoPCgluYW1lc3BhY2USAggECs0SugHJEgrOEQoHY29sdW1ucxLCEbIBvhEKL0Itw7JLKi804YySc/CQo6nCv/CQlrwne8KhSkI6JS9qYvCehYXigoJyUSbwnaquChtCGeCmqismVNGo8J+BmS3wkICdJjsl8JCWvCoKA0IBWgoHQgU98J+VtAoOQgx78JCWlPCQlbMm0agKK0Ip77+9Lng/e+qXqlwq76m8PPCdk4HwkbaT8J6AgTnCstGoXXTCpfCfq6QKIkIgbfCdnJvgsagvJ+CzqnBc6qur4Kqz4a6JPS8lOOCgu00KMUIvIiQ06pq18J+JkPCRpI7wnoKPyLrhhrM/JC9Z4amlPyQ8XDkxOyU68J6AoGcmL0EKE0IR8Jy8n/CRhZbgrLI+eyVdZj4KEkIQ8JCArzvwkbCIIcKgL+C6qgoSQhBkPT/wnZOcJyQ+wqXgrrImChpCGFNTKvCQqJfIutGo6qipPWDwk4+/8JGSjAoKQgjigIbwkZygYwoLQgnwnrmU8JCDonQKC0IJJuG0gVzwkL2HCgdCBSXvv70uCkRCQlIu8JGNkNiQe07wkKC88JCojHvCrvCQlrXRqOC3n/CRtIgxw7LCpWMi8JCOkOGtvsKoLi50LvCeuZ0mJuGDhyrCpwoMQgp3JfCRjZfwn4GcCiZCJHonzozwn5W08JOJrO+/lPCRiqnwnrm+8JCAsiLwkJ6E8J2SnwoSQhAlJsOS6qaWcfCeuoYmemRhChJCEC4qMeGfqfCfgIRp4aGjwqUKDkIM0ajXo0NvL2Dwn5W0Ch9CHSYlL+Cwn3vvv73wnrmLyLrhn7Pwn5W0QCc/4b2ICglCByfhoa8/WkIKIUIfIiJA4YyVZOGdsydhPO+/ve+/vTrwnqWY8J+VtGc6Lwo0QjJR8JGFqlLwkYOQLiTRqDJw8JGoiTrRqPCQqLov8J6jifCxtLw/8J+VtOGxhPCRtIvWjwo8QjoqJuCpmSIsIvCRvYHVnFzwkKuWV2zgrIzwm4Wl8J+VtOG9m1bIuinwrYSESGI8OSp44La4JXTwnZScCiFCH+Gsne+/vWpwdfCWvpUqRSrhv6F7OuqijuGolEbtn6kKDkIM4LqC4Z6/LsKu6qmBChFCD/CehYHgs50n4LqlLjdxVAoaQhg6NfCQgZU84LGd8J+IlfCen6IkYPCeuKkKP0I9IvCflbTwm7KI0agnSeGJnG4/8J6jjEDIujzwlr+i8J2UnPCfp5Q/4YqK4LOmcvCQloRALsi68JC0ouKCpwoeQhxL8JORk+C2gnTwnZKiOfCeu7Bcd3Z7QeCxrFwlChhCFuqhqDzgpo/wkKy+8JCrqz8qXvCWroYKHUIbPGUz8J6Ene+tpPCQurB8wqs6PEDwkYay4LOHCjdCNUQw8JGAk/CeuZc/YD3gt7PvrII/8JORiPCQhqA08JCOnWAoY++/vT3DteC3guCign7wlr+jChZCFCF7S++9n3s88J6Aglzwlqqie8i6CklCR+K2pOGrgsOGw5t14KGg8JCNqu+/veqnkOCyrXvwkI6RJCU6Jt6uUnvwkZmUP3jwn6C3e1zwnrmoZ/CQgpvwmr+9wq7vrrktChVCEy7RqPCdkqJw4LqOIn08XGAqfioKMUIv8JG9mSc8TPCQhYxxS+KAkPCRqKrjgb88KvCeoJrhpZg8yLrRqEZhci7wn4OLwqUKEUIPdiThv6Zq8J+VtD86JS88CgJCAAolQiPhpYDwlryT8JCTp3DwmImC8JK/ji/hrqDgtY49eyYvJT9aPQohQh/wkL+CJz3wkaSD8JGNhyI24oG44Yq08JGjq+GtuSonChpCGGNeP+CsgzpfL+CzgdGo8JGCrUU8KWA8JQoHQgU/J0wmLgo3QjXwkY2f8JG1hCbijI7wnqOIQ3JiPC/IuvCRsItmwqVwW3zwnrm+w5vwnrqpwqXwkIGS6qGEPAoHQgUv8JCdoQokQiLRqMOucj3iuJdB8J65n/CRk5LwnaqjJ3LvrL7DsGBgdi4mChZCFD/CrnvIuvCQh5g7MDo6beK0u8KlChRCEmDCpeKEjirIulAq0ajgoZQiewoaQhjhp5coRPCfrYHvv73gsIs88JCAj/Cdpa8KJEIi4aCGXiXekcK/YPCQlZVbPGJx77mXePCbgrbIutGo8JG1kwoYQhZCKlJc4Kmy8Ji0gWI/Kmsqez3hjpd7Cg5CDDk/YeqpiMi6bj3CpQoGQgTzoISeCgxCCjzwnrmO8J65olwKK0IpJ37wn5W08JGxn9GoLsKl77+9QWDvv71ORC0vTzLwkICGyLrqrKk/yLoKKEImPV988JCirCYkKj8u8Kqtj/CWvp48wr7gsI/DnyDXs3xhw5cvKnsKKEImwqVZ4KmeOHXgpqEq8J64uS7wn5W0e+OGkvCfm6cv8J2DmvCegIUKPEI68J2NqPCWqqfwkKeE4KaQ4LGK4Z2G8JCiqmB+SmY/dlJAYcOq3pt6au+/vSJzRyZDXOG9nUwlfO+/vQoTQhFUXDt88J64tEzhjY1g8JG2kAosQirwkaSJRPCflbR9aOG9k/CRu6rwnqWe77ePw5TgrolYJCQw8JCWseGfty8KFEISYGTgp6k9yLpcLzzwnYuDIk06CjBCLjjRqPCQgLzwkISqOi5e4aSm4b+O4LeQYOCri+C7jPCflbThp4NK8J6lkcKlVSYKHEIaaPCRl4pWQCTCsUDgo5c/8J66iPCego8+w7QKJkIk8J+HsfCRiqIm8J+qh+GPuvCdiLrwn6+y8JCAuuGJnfCWqakgCkxCSiFMJOGdrlnwkYS98J2elyTwnrKY8Jauge+uvCfIuiXwkKiG8JGCs2zRqOCrpj3wnrKfSu+/vfCeo5Dwn6qaQOCwguC3njwx44SOCitCKS484Z2zPy/wkb2BXCfgp5fwnrinYOC6ieCrjSo84b+YPS7wkJWJ77+bCjJCMC98L1w/PFsq4oC9Zu+sstGoIvCQpKh7NjDbj/CflbQvIjrgqIM/yLoqMvCQsofIugoOQgziuqgnw5lhJ/CWqZ0KLwoEbmFtZRInQiXvv71MIifvtp7hjYom8JGTk/CcvKNw4KyFLmAnyLo8OvCfq6N7CkUKCW5hbWVzcGFjZRI4QjY2Jydc4L+aP/CflbTOlFvhvJzwq5aP4reD0ahg8J65iyRMT1zDhGwu76+u8J+VtMOeXO+/pToKuAS6AbQECv8DCgdjb2x1bW5zEvMDsgHvAwolQiPgr5A3cCbwnrquOkMkSvCcvKfwlqq36quv8JGTlC7CpeK/tQpCQkDwkLKyJuGupfCflbQ98JCWrk5FQ+C6uyLDp/CQrabisagnwqXhvZnwkJak4KmpZfCflbThnIQg8JCOmD3jhbp2CgpCCMOTUjo64LK2ChtCGcOtPmDwkJShwqVaJVwuPtGoZX3qrKQiXCQKFkIUKGI8VXzhi4XgtY7wkam/IvCWq7QKCkIIPOGkjfCQro4KFUITwqXwkIem4KuHw5Q44Key8JCMogo2QjQiKkTitrHwnp+q8J2UnFzwkKGF8JCGmj1m1o3RqMO08JCdoUrvv71s64KAWE/vtJA9w5M9ChNCEVzwnZKlPW41LfCWqaNG77+9CiNCIT/wkIGE8JCSsiQ7fPCQnqY6O/CQqYHCs+G4n1Ek8JCwtQo8Qjrwn6KwV+Cxh+CmkGR+XEInKjzgsI/wkbSv8J6Bh/CRtIHwnoWD8JCAoirjgJ9p4YuD0ahld9Go4KuNChhCFvCeub46yLrCpeC7giBcXGN4LSregGcKH0Idesi6TiJi4KyDLOKDgPCRnYYl4KGHwrI64b66SjUKCUIHW+Gfhi8/VwooQiZoPXsx4Kiy4qOs4ZyOTFwiXCczPvCRioHhophceyLIuj0/JO+tgQocCgRuYW1lEhRCEifwm7GhyLoq8JGCulw88JCPiQoSCgluYW1lc3BhY2USBUID4oKwCsYVugHCFQrEFAoHY29sdW1ucxK4FLIBtBQKC0IJ8J+clFhQ4YySCgJCAAo2QjTwkKO08JGmpsKjd8Kl8JCks/CYtITqoZNgXvCRgr5I8JatqHRK6qOZJvCRtIY6XPOghYktCiRCIvCfn7AlL0w18J+bsPCQrq5cXSvDlSpw4K+r8JC6seCulSgKBUIDXC5NCgZCBDwqYGYKP0I9JPCQnq1RKcOo8JGNiDHIutGo8J+VtHck4KeX4Y6UJPCdqqTwkJaIPvCRsbDwnZKlLu+/vSRRXVxj8JCouAodQhssJ/CRtLo94K2cJEPwn6GuZCTwkbCE4KmcIiIKBUIDKkA1CgtCCci68JCtsmBqewolQiPwlq2gPDzwkaCGKjrwnqWYwqLwnrmX8JGbgigqLyPwkZGeJAoRQg894oKiWSTwm4Cr4r+2ez8KHUIbPylpVj/CpeGkquG/jTok8JGRnfCdkrk44b6qCghCBlgvVFx7IgocQhriu6HhvLApTeCuqjUtRntwLvCeuKxcL+qntwo/Qj3wkJa34LOiPe+/veC4qS8p8JGrnPCRvYHwkbSJ8JGyje+/vTrhiY3it7VS776k6qemPHzwn5W08J+Fsi12CiFCH/CeuLtrbuCsjzo90ajgso/hsJol4KmMa1o0wqXgtrcKFUITe8i677+94b+2dXsk4aa+WSPCpQokQiLwmLSC8J65nS7wnrSr4KizJjw7IvCflbRq4aWAX+CqoTwqCh9CHUrwkbyDJl0qe1xR4K+Nwrk60agt0ajigrgnJDolCidCJeGqpeCpnuCyjuGdsz0qJOGdsvCRq7TwkKC4RTzCpdGoQDo9WSQKB0IFYCRTKiYKJ0IlVms88JCohc6H4LezIlMm4K6VZloj4LOWLmxYI2DwkLS4MSLdlAo1QjPgu4LwkJa78Jy8tvCRjLgvccOl8J6ln+2esShU8J+VtGDwkZ2D4YmYYPCflbQ8JmUqOiYKEEIOPOGlsPCfgIIl8JCBiikKLkIs8JCAgjoqJvCQnro64Z2wdDAm4aONOWDCpVttJfCSlLjwkYqAP++/vSfgp6oKI0IhJn7wkZyEKi3guoIuO0En4KyBwqV+Invwn6m04LGMNUpoCjhCNvCRvIngoIEqL2BS8JC/qHsmajw9L0jhgLM98JGxs9amItGoYHfCpWEk8J+VtFxs4LC98Jy8two+Qjx7P+qsqfCQgIVTPcKy8J+Dhy/wnaqf8JGklirwlr2l44Ow8JG1gHcvUsi6PyokLiZJPfCegJhNVPCQvI8KGEIWJifwkJa8PMK14K2W4LOj8J66tjhWMQo5Qjcla+C3muG/gmxQ4aKEe/CflbTIuu+/quC3gvCQjpJ677+9SyTvv70h4KuN0ajDu+GDjT1pczAvCjxCOsK944ScWyUu8J2Smy5hwqXwnrmZVCfwkYiX8JGbiPCfhY3RqOCzhvCQkpdgU0vgsYYjKvCbhZXvv70KT0JN4YqXPVLwnruwJHAg8J+bp1rig6tpUHjCtfCdkqXigoYn4LuC77+98JGEt+GnlSXwn6m34Kuq8KePrTzwnri78J+VtMOI8J+VtPCegKAKBEICXEUKBkIEKCwmewo0QjIizozgsIvRqOCzlibwkICu8J+rg/CRjajRqPCUlqUq8Ja8k9Goez9NYPCRipngu5MuPAoRQg/wnriK0ah7Lz3htblYw4UKAkIAChpCGMOn44WdwqXRqO+/vUZgY/CRjKtF8JargAo+QjxifEvvv73DqmtHLuCqvfCQnYvhvYpi77+9Tm7hoK188JCmiuG6hirwn6uoJMKl4Lud4LeY77+9Wi7gu4YKRkJEXNGo8J+ggfCfqrNt4KW5PPCRspN0did7KvCRjJDwnrmJPD9UIvCdkbtg4b2L8JGZolXgrYIx8JCzjvCflbRcKPCRtKgKE0IRb2tqPMi6ZeCss/CWq4EuQCUKPkI8w4pUe1xMJidcw4bvrLjwn5W0PG48PCTgq5DwkKyI8JCkpu+/vfCdkr4k4KeuX++/vWTwkIyt8J+VtD9KCiVCI/CQk55MLmDwq4ea8JGmpu+3j+CoiuGdiO+/veGGheGPuSVYCkhCRiJA8JGlkuC0liQpIuCujvCdhK3qn5M76qGFKmBNPHbwkYyBwrHwkIuCbuChpvCQnaDwkKuZ0ajVg/CRtoki0ajwkbChIjoKOUI3IzskKlwoZFzgq4xz8J6hqT0n8JCqiD8vRsKiWPCflbTwkbaRJlnhvZkv77+94aCkRFfwn4mQLwonQiXgprjCvVguUci6Rip28J+HtuGdruCsr1vwk4KoNSLgtoJr4rStChFCD/CQnaDitrjjgatWYOCmoAoCQgAKAkIACgJCAApEQkLIuvCdlYAv8J+VtPCfrqLwkZyIQyYkJeCssyJTYPCeuLThn6fDm3hyP++/vXvitJ7wn6qA8JG+sPCWppjqqYk/JjQKOEI2W/CWvpHwkaCIXOK2qidw4K6f8K+loyrwnZS+4rqAP1wqWl3wnrmLei978JG0uvCdkqbhj4s6CjdCNeCru/CRtqTwkK6Z4reF8JCzpfCRpKPvv73wnZSHPzHRqEEq0ahV4Kyha2Qv76uPQnfRqEFGChBCDi5P6qmSXFxcYFXDpsOdCitCKSQ9TGom4aqx8J2FosOaffCRjZfhiZvwlq6FO+CqkTd4JlxgKvCRkIt2CiZCJGB477+94Lma8Jq/uu+/ve+/vSrwn5W0IGR9wqXRqGg8TOCpmQoaQhgi6qeZXvCSv5fRqD7wnrSL8JGKiOCpjUMKDkIMVTpk4reTIvCflbRgChBCDntCPMKl8JG+sPCQtLIiCjdCNe+svuqhlvCQnoMq4KijwqXgtqolOlIuXD8t77+98J2Mp1wl4KaHceKCgFXgrInvuKTwkaalCj9CPeCrrSJbUHzvv73wnrmuKzxXLvCRmL1d8JCAsnA1Iifgp7suR++sl/CflbQk8J64ivCQoLwlJWDwn5W0SykKIEIeYPCdlYZZKuCzjeGLhCTwnZ2Fej0/XD3vv73hp4IqCgxCCiLwkYem8J65gkUKJkIkfDwi6qyl4b2dPGLgqYjvuJFqe2rvvZjwkICkcybIuu+/lEhgCjZCNHtW4q6EzozwnqCP8JCVueCmt/CeuZvwnoWI8J+VtMi64L6GJlF7LmBSVS7RqD/hqojgooUKG0IZ4Y634rSt4ZuQW/CRsKXwnrmfwqUn8JC6sAorQinqoLk88JCWuycu7Z+jL1w98J+VtPCRpZYnJPCQqIYmXPCWv6DwkbaXMAoNQgtcYMKld2A8IuqsrgoLQgngt7JrLjk6WEgKKkIo4K6K8JGMgnvgu43qpLI4KUEkP8i6Ym/Iui4m8JSVoPCehIU8JHsmRgo4QjY9yLo6dT088JChhCUv4K+u4o+TXPCflbR74ruIOuG/mFAvJPCRsJjhjqwq8JGAsyJFOvCfq5YKD0INZ/CQoLdrcGA3UeColgoIQgYmVFFCXDwKBkIE4YqNXAoHQgV1fOCtggouCgRuYW1lEiZCJPCQoKo50ajwkJaP8J+CuVIuJUllKuKXhyxjIkbgra7wnrmSJApJCgluYW1lc3BhY2USPEI64Ki2PvCeuYnwn5W0JyTwkJ6vYvCei5Nl8JGMt/CfgqrwkYy44KiiXC/wnYSTJ0vRqEdT8J65u++/vQrRDboBzQ0KkQ0KB2NvbHVtbnMShQ2yAYENChxCGiJXw6UvUfCfoIZcJzwkTvCen63graDwkYqNChBCDk098J6Cj++4qPCRiIY8CkNCQfCRjYcj8J+VtOGCkC7hsbLwnrqC8JCpkyokYEvwkLmwVzDwnqG28JGjrkEk8J6Cj/Cvp6o9X0jRqOC0iiXgpq8xCiJCIOG/lz7DslrwkJaGOkzwkYyPyLonPPCeuILwnaqpwrE/CjRCMnt78J2bsyfhqbPwn5W08JCeg+GgjcKlJOC6pU7hnYPvv73wn5W00agq8J64pPCQnrMqCglCByLwn6+1PS4KNEIyP146PfCQlZvwn6mjdsi64ras8JGKpPCfgqks8J+VtOGLmy5pwqVG8J+VtPCQnaJcLiYKOkI48J+VtPCflbQ8U0BGJtmFw7o/76WMezzIuiJc8J+roeKBsSXwnrmpPzM8KuG9uzLhv7g8w4XCsXwKJEIiwqUryLo/LOC2ukrwn4eq4b2b77+9L2wl4aqj76yCKGnDmApAQj4yYMi677+9Y2FJ8J+vsj5gXNGo8J+gqSbgq6Lgs4x7JvCcvLngsa7grZbwm4Wn1Ztgfj8l8JGKi2jCpeCuggoIQgY34Y2YLicKK0IpYHE94b+Y4ZyRP9GoP/CRjZc6Lypc8JCQqVUq4oCHOvCWv7F68JCmnSoKK0Ip6qyk0ajit5XDnGw9L/CeuY3wnris4aq536vDpOOAufCeuYLRqGAmyLoKDkIM77+9KWLwnrmbVMOOCi1CK+qfkybCpcKl8JCWu+CngfCQi6nIui9rwqXqkqlB8J2SokJL8J64uzrDij4KGkIYevCQlpp68JG1qPCflbQgXELhv7MiSjknCjFCLzzwn5W0U8OQTyQ88JGNjGAu4b628J2Gk/Cav7Dwnrq38JGRnuGqreC6m2d9w7daChxCGj4m8J65n+CyuVc94Z2mODwr4rSn8JGZrFRuCidCJTgnd/CRjIN7QPCav7kkNOGjsSY725fIujxsKfCei7/hioxcw50KEEIOwqXgsIc6cj9g8JCsujwKHUIbSj08czrhnozwn5yVJWfwkLmtIsOjUSxX4aqECh1CG3vwnZyVKERy77qZ8JCWjsi6VWDgtITvv73RqAopQifhjZ7wn5W0wqUiY3Zh0ahBJfCQra3vrb5aW++/vPCRmKrIuu+/vTwKM0IxRy0ve9WZeOCoqjpWMCTwkb2Y8KeUkFknP8ON8JKUnUV+W+C4gvCRp6PCv+G9jcK0WwoGQgTwkbS9CjFCL11G8J2Fv0ZWICpEcE3gt5HgvJjRqPCQo7Twn6uy8JCLskJbJPCQjZVTRHt+4oG7CiNCIWFgNTzgq7rgrYNYe9GoOuGJm9ee8J64ovCRm4Mm8JG0iQpEQkIiLdGo8KqzpS4qPCTgp6tP4p+X8J65nfCcvo/goanvtY/wkaqXwqXhvr0k8J+VtCrwnZqjwqVgYPCflbTvv73hsLIKEEIO8J+VtOCzrmhjL/CdmZUKL0It8JGgqiJzKi468J+VtPCdiIdgJWbwkJW3aPCQk6c88J+VtHshJ+GdssKlJ8KvCjtCOdGoKjJX4LKm77+9K+CunDjwm7KT8J6Fj++/vXJ70rrwkZec8LCQhdGoPmnRqEngq5Dqp5Bd8J2SrAopQifwkZyC77+9Q+ChuPCQkqUyJPCei6Z+T0Hvv73wkZOY4KauTlvitKcKKEImXCZ7eyrCrGcuyLrIuiYu8JGGoy4vKsKl0ajhqZ0mUu+/vWU8YCQKIUIfJ+CpnlEnwqV3cGDqo7ovWsKlw4HwnZOAI/CRrIZXfAoYQhbwnrqiPTsgyLrgrIovw5TwnrmURHA9CgRCAixgCgdCBT8k4LOGCkRCQtGo4LS38JG1kXvwkL6xRXBp8Ja+nibgsKV7wqXwnoCB77+9Qci68JGkkuC6jeCqhzTwnY2vUPCdlY4q8J+VtCs4ZgoRQg9gTuCriS8uXCfwkYyByLoKPkI88J2VjcKxIVxlPyLhirVl8J+VtDvwkKy6KvCRg7grViPwn6Cr4Kqa8JCphCfRqD8hXFXvrpAv8JG0q1Z5Cg9CDSLgtK0yXk5iPPCRioEKEEIOUeC1h/CQlonhpp1gLywKNEIyIio4Osi6VHzwn5W04LWNe+C2tuC6mvCcvLw08J+BlUHCtlnit57wnoCh4bCt77+9TigKKUIn4YmbZVPvuLrwnri5XVU58J2EieGPvUPgoL468J+VtCjvv73gsLA0CiUKBG5hbWUSHUIbPVwv8JGEjWfisJnirofwkYux0ajIuvCRtaQpChAKCW5hbWVzcGFjZRIDQgEnCtoUugHWFAr5EwoHY29sdW1ucxLtE7IB6RMKO0I5OkTDn/CRsLrhsp57zaDwkKyl4ZyN4LGLXOGqqeK2qOqsqkzgsI7CpSA9LvCfnItrczh34aeS4ryHChFCDzw88JCKlC8qPfCbsbPRqAo/Qj0i8JGEsDTwkYWHw68nYUIi4YywfTzwkYSb4aSoXG0/N/CeuZnvv5Pwlr6X8JGbgTxwJy/wnqKLdfCWqaQtCgxCCkLgt5t7POCwgSoKRkJEbPCflbThpJjCpfCRp6Ftw77itqk9VjTjgJ48WSfhpKJD8JKRo8K68JCWtybwkLKjXvCeuJIkYF4swqXwlqmkLvCbsoEKOEI28JG8in0uw55Z8J+ikMKl8JCwjfCen6p+77+ge/CflbTIuiLgqLzwn6GS8J+kjNWEL/CepZ9xCjVCM/CbhafIuvCflbQmPfCeuZ8/8JCTmiTgqLLIuvCRpInCr/CflbQqPS/wkYyPQ2gp8JGTmQoWQhThgpkpL/Cfg47wkYKI4bKIJOCpkQovQi1LYPCRhq9cQ/Cfnapc4Y+sP+qgjMOKOXsk8JCDt/CehLhg8J+qp2B98JGykjAKCUIH77+98J+VtAoaQhjvv73wnYicYSXhpLDvrJ7wkYScPfCwkYUKA0IBcgo7Qjkibyc98JGMtiXwkLqo4Kme4K6KYPCdhYA/8JGwg/Ceub5L44e5w6BOSfCWq7DwkYqaUi8qZeGilFoKCUIH4aCZ8JCTgwpKQkg68JCnhyzvv73vv73wn4mh44SXPXPwnZSa4Kq4MfCRjZc/P/CRk5XCpeGkqn7hvrrhv7bgs4rIuuK0sSrwkKqBPD/wmKagw7MKPUI7M+Gfp+qnjD1c8J6gp1w/JO+/vSQv8JGir1x44Yq4IV3gsY168JGMkOGNvMKleSRgwqUu4b+04KeMYzEKMUIvLnvgsaAlYHVIOzR38JCjsuG9gOCzsTpRJCon8JuwqPCeua5uMlQgLsO7SvCRmaAKHUIbXEDwnp+kIvCdqqHgrbRtRVvIuuGdg+C6jMOKCk5CTO+6ijzhpoUu8J+VtPCWv7Higrvwlr6bYCbwkYyrPeCwr9+6XfCRtYMnKDAk77ab8JGksyrRqPCegIjwkbyQ4K6J8J+VtFxp8JGwk3sKEkIQ8JCMh3vwkKSLIkwi8JCNtwoaQhgn6qOPQ2kk8JCuq/CQgKRIyLrwnoWBdXsKLEIqOvCeuIol8J65ouC6rz3hiZvitrRcR/CRjYAgRX0n4K6C76yUbE7wn4ewCilCJ/CepZ8/yLonOS7wlqmPL+C6hD/IujXCpSUv4LeWWiXgu4HwkZmmcQoaQhhK8Ja+n9GoOsi6TlzRqDLwn5W08Jq/vVwKOEI28J+AnT/guog60ajwnZStPWw6Ki/qmq1+0agi8JKBk9GoL2A4yLrOhUBLWMKlwqVIPPCWv6M/CiBCHntE8JCVuPCeuLkuXCQ8IlxC4YeUe+GLg8ON8J28qAoZQhdczb1ILz/CvvCdkrF+4Kq54LuOY+CumQorQikk8J+VtC4qJvCQqZjvv71cJiA08JCumnA98JarhvCQhKDgtpTCvNGoOwoUQhJ+XHlWPPCfr7Ql8JCMiivgs7MKRUJDKi7gpKHhvbTIuuCtiC7gqLwjW+CuuT/wn5W0PHvvv7wn8J+BpvCWq4DitqHwkbyb77Op6qOOW8i6WD/wkbag8JCWuwoYQhY8JPCQqIUhJjzhpYA77Z61eyTwn52eChdCFSfIuio54LmM2qdB4LCQe0LwnrikbAo7QjlnYTxcIvCQqJvgrZ1+4Ki88J2Vii7wkaSmLj1f4YGTKvCRpInwnrmhcfCWupg1OyUiNuC3ivCdkp4KQUI/8JGkq/CeuIx78J65lz3wn6uy8JC6sPCav74l8JG0vyfgt4A9JlTgqKHwnrmNfCfgsIIn8JuykeODtVzhsq5ZChBCDuGLufCRprnwkIGB4YONChNCESJccPCflbTwlqSpPF4kQ8KlChFCD+K2qeCpmzrwkKmR4b6oTgo8Qjrgs4h68J2Uqe+/vMOqYPCeuLlEPfCRjZ7wnaCsJi4i4KqzXPCRmqvqrKwiYCrwnYST4KmePCMk4KyzChVCE0gkY+KDoj4m8JGxm2Dgq4Pvv70KBkIEdOCosgpJQkfwm7KY8J65uvCRmZNgPPCQpqnwn5W0yLrgrZzwkaK8PfCfn7AuLiLhvZnRqOGJpu+/vfCflbTwkZCww746P8i60ajhvZs2cgo8Qjoj0ag44ZyT8J+VtCfIuvCRtYDgp6Mt8J64rSIne3HwkKiXyLo68JKGs2I/P2Dwn5W0d3clc03wnrikCgVCA+C3ngowQi5E4ae0dvCRrIcn8JG1lCdvXDx3VS84e/CRjL/wkbKyLn7gr5Bc4Yq5SEA/JH48CjFCL3U/XCVpPeK3kjw8X++/vUPhjos78J2QtC/gqrxY8J+HpmHgrpxeKPCfiKLgsYpcCiRCIuCogyLCpdGoL1DCpS5UJiLwkLqsJVvwlqqy0ajigJZqwrsKNUIz4K2h77+9YCZgIuCjkfCRnKpcIuCzssi68Juyg+GDh2RcQyRcJjLwlq6H4KyvL/CflbRfCiBCHvCfgI9t6p+R44ePxYLwlr+wyLo1zb3Dtk1cYC93YgokQiLwkJW4w4LwnZSc4YuAL+CovOGzgyU6wqXwkZaW4Kq34aG0CjVCMz1FL0ov8JKEo8i6PPCQvroqwqXXg3V7RW7Iun7tnrxZJvCeuZlL8JGMuSVKUlPDoS4vLAoCQgAKFEISL0Q6yLrqmaZc8JCThiLwkI6tCjRCMjnwnrS9w7k48JGNjHInPe+/veqhp/CRtIVf8JG/iivDontgaci64raqJj3qrKDgsZpZChJCEPCeuaE/8JC8uD124KuQw6YKJ0IlwqVHQO+3jyLCpTFh8J2LsWDwkYSzQMK9NvCfiZDhiY3wn4mhYgo/Qj0677+9fT9g8JG2iy5gTyVv8J+VtDws4pqz8JGKiEcl8J2EmSrwkYqG8JCAqjzwn5W08JGNn/Cfm7zgp4cuCipCKGImP3vwkKi6JiJrJ2Ai6p+RPWNcJ/CflbTwkKi48J+fsMi6LkIiLz8KFkIUw5fvv719P/CfqoQqJ+Gch/Ctia8KG0IZaVwn8J6BjXtg8JGkuyt1P+K4gD0/8J+huAorQikkJfCfq5jwkY2XcPCflbRxwqUiTTkn8JCKuV5tPeGcq/CbspZg8J+isQoaQhhc8JG0ukEvPHtBLlngpqrIuuG0ueC2qVAKPUI78J65pOKwoy/wmr++Ii7wkYqfPPCRkopc8JCAseC1meG/kjXgr6h4JfCRjZdqcVk/w5BE4bK0L0wzIjwKIkIgPeGguiLCpfCRg7bCpeK2tvCek5Va8JCBl/CeuZfhpYYKCUIHWjzwn6GgUApFCgRuYW1lEj1COz/iuLZrLz8iayYlJPCQkI/vv73igpvvrJXIuvCRl5on0ajvu4kuPDrDsOCqg+qpkSTwnaKkPeqrqi5sChEKCW5hbWVzcGFjZRIEQgJjewqgBLoBnAQK2AMKB2NvbHVtbnMSzAOyAcgDCg1CC+C6lyRxJ27wnrmdChFCD/CQgIBi8Jilu196IuGJmAoOQgw/8Jq/vfCfn6ngs7IKJ0IlfcK8XCrhnJRg8JGKiMi66qmeLVzgraBI4La98JGnm8Of8J+gkgo4QjbDkFjgqbYmIjwq8JCVt+CsmyQ/w5Twn5W0cOCos++/veG6ncOT15bVnOC+vC94IjBcWSzqp68KJUIj8J+rpO+/vfCQpL/RqO+/vfCroJ06IiIkMypBNOCov/CQlpoKMkIwLzl78J65vsKl8JG1h3Thg5I/IvCeo4wmSvCRjLwzLzjiu69WPMi68JCEgPCeuZ88CiVCIzrwn4i16qeXP8i6Sy4yeStv8J+vg+CrkPCRnJQ7cD894LiCCglCB8KlyLrqrKkKH0IdYOCqjN6Oe/CflbTwnrmk8J6fuPCfr7RCwqUyOCoKQEI+L/CeipHwnZOCXO+nv/CQnoNc4L2VPMKlyLom4aeF6pSAYiXDoCLwnrmSOFw+4q6RKuCrqeKCvlw9RPCRtYEKIEIe8J2LrOCogvCQub498J+usFzhpp3wkIC9XOKBuXsuChdCFX07yLrigJ5BSfCQrbI8LlMq8JGnowoGQgTwn6mxCi4KBG5hbWUSJkIkJ/CdkLPwkIuC8J+VtEQu76yDX+CkqT3wn6uzdPCdqp9+dCQiCg8KCW5hbWVzcGFjZRICCAQK9hu6AfIbCr4bCgdjb2x1bW5zErIbsgGuGwolQiM/4Kqy8J+VtPCfgrXRqPCQpLbwkaSA4LK1Y8OqPz/CpVx7JAoIQgYmMsi6KlUKP0I9YH06LiTIuknitKfhi4IvJfCfgbFVPdGo77+bP/CSkbTwnLyjYE1XyLrwm7GQw7bwkaak8J+hmfCfpqwkfgoZQhfCpWHwlr6e8J2UjSw3PE7gqLzwkYyFLwoKQgjwn4O0K+GtvAoqQijIuuGfkeGLiydwXCIuJSFj8J67sVFM8JuynTrIulcrRj8uZvCQgrsyCipCKCfwkaSYI+qsjGBLJUTwnrmOQEV2IWBcLyTguog9VuK3jeCzlu+/vXsKNEIyIuGqhOK3geC7gSfwmr+yP+Gdh0FkJm/CueC9kuCvivCeuqLit4M6e8KlyLo/PWAuTyMKHkIcYNaPyLpdYXdgZjPwnZKi8J+qnvCRvK5EP+C6qgo0QjLwkZeQe1Qk0ajgqrNbSfCQo7VW4b28cjY38J65h2rwnrihKEjwn5W0fPCbiaTwkIOFJAoFQgPqqroKM0Ix4KG8w7LRqHs8JC/wkKurIDxB8JCgvPCfr7AnQns9PMKyJSkve/CQgpbwnrmhXC86IgpRQk868J+VtOGzoCHIunzwnbyHYOK7p/CQjZFc4aa24b+4J/Cto4bhrZThsK7IuvCRg5TwkKO04KqL44GI8KysivCQvrrwkbCF8JGqjW9DJj0/Ci1CK+GjmlvwkI6qdOCss+C3sjt6yLoqLmTwkL+A8Ja8oSYuKvCQiq7gra/hiZsKM0IxaTzCpS/hnY0hJj1ROvCRiJThqqHwkKSNPci6J/CRjInwkIGEZO+/veK2tCc2JDolKgo9QjvwkK2k4KiDPTg/YOGDh1w8c/CQv7HwkaCsX+GPu+Gquzxl8JGkkPCQuqkiOz/wlqmm4pGG8JCejURFcwpIQkbhv7PhvJk5RuGnl/CRjY3iv7g8ecKoJPCRnL4tPeGstjLwkI6I8JCkhPCfg68w4LK30ajvrIHIujTwn5u7OsOZ4KyGfUhyCj1CO1p3JOC2vSom4YqE4LCQ8JCKjeCtoknwkYOkUMOGNeC+uWJfP2AlKuCniPCQgYHwnp+98Jq/ufCRjK88CjtCOfCeuYk644CUMF084rWvw6ZOLfCWrZPvv70iPTzKhcKyIuG/m/CQrpngoZ7RqOG+v/CYk7fIuiQlPQo8Qjrhjok6IuCzouC6h1wiN/CRjZDwkKS/ceGJlSV08JCVh/CehY/wn4KqbmAm8JGMs2DwnoCY4KGne0olCiBCHmot4KaGZHThop5PPeCovvCbsLtF8J6AoOCtoO+/vQoWQhThqaDwn6uO4K+X4KmB17LwnZKmNwotQivwkbC5ctGo4Ku5QuGKiiVBLvCQvKU/L+CmsvCetKsnyLpuTPCRgrfwnaqfCgtCCfCRjJU98JuFlQoMQgrwkYqmZ/CQiqU/ChdCFfCfqr/wkJaFJ0Lvv7198JKQjnHRqAoxQi/hraJ777+jLnnhp5FgXPCfiYHwk4KnyLrwkaSJwqUy8JGcoi7wkaS4YMOBWDdzMQoSQhDgtIpJwrDwkL+KJyXhjoltCjpCOHfvuq18UHskKUwv76itJz/wnrmNL8K+OuGKisKl8KufnD99c/CeuqLRqMKlOPCflbThjpQmwqV1CgxCCj17JFHRqHs8NSQKMkIw4am08JCur/CfiZEzSi7CpeGnmDEk4Ka3Zi/wmr+1w6ovJWlh8J67se+/vT/wnruxCgdCBSXwnbyqCiBCHuCqj9GoWPCesrHwkKCFYOGalz08OkUq4YmY8JChhAorQinhvJ1KKvCfm7Hvv73wkYyQKu+wnyUvKvCQuq0q8Juxusi68JGsgCYkXAojQiE+4reD8Jatlz8/wqV5e++/vVYi8J66kCRgSknRqPCQsosKE0IR3avhqKfIuuCuqjpSX++/vScKNUIzZDo88J64u/OghKNM8J2MnFwm77mr8JCBgC97UScuL0Uh8J+VtMi6Pci6U0A8PS/wkKiRChRCEuGwsMKl8JGXg3siw7hcw41pWgouQixu6piDIjrvvb1c77+9IvCQvLtiJO+/vXA/4Kage2nwnrmXLisqYDrCtSRYJAoQQg498J6Toj3wnaqh8J6AuApAQj4nU+K2sXY9762DwqXzoIS1SCvqp49gO2xD4LmI4q6ATvCQqIwn4rSt4K6fL3TvsLAk8J2UlCDhiZon8J2UuwovQi1Q8Ja8tPCWqaU8SPCRtaHwkLyTTeC2uuG+qiYl77+9Uibwlq21XsO7OD3hsJMKPEI68JG0uuCuhsOO8J67sOGPjU9cPD1xyLrgqIfqoYE6yLrgu5/Iujxca8OewqXvv73gtqLwrIWe8JGApQohQh9rPzrqqrtg0ahJSeCijSHigZBg4aWb8JGGm1DIuiYuCjRCMvCQqJclPGM6aiJgPeGKtSHgp7Rhe/CflbQkb/CSjJxG8JuEsjpw4aSMQy3gt5Lwn4SqCg9CDeGds20vQTonL0vRqC4KM0IxJCrhi4AnSHjvv73wnrmSLntdLj8uUz94Kk4k8J+VtPCdhL134oKy4YmdKlXpgLfCpQoFQgPgqpAKDUIL8JKUs+Gdh8KlS2AKKUInPGwvPzskO+CzqVzwn52xeu+7lfCeuZtqJ/CQlp3wnrmkZcOw6qiKChdCFSPgu5/vv70lYi7wnZS4V8K+KiI/JwohQh9K8J65giTwkKarKlngrIPvv5XqpapzNeCtiCpo44CuCjNCMdWxUmsv14d6JybDo1zgq4N3Jjpc8KytryTgp4TwkKyh8J+VtEol4ayo4b2ZLPCRg4IKJEIi4LGdJuCxveqnkTgmQ/CfnpMqUil7ey/hjaQ6ez8/VkrDrwoPQg3hv6BY4LWtQ/Cfnp1CCiBCHvCeuZ3gqafwkaWXyLpiXFXwkI6d8J64ue+sreCxowoGQgTCpSI/Ch5CHNGo8JGco2jwkYyH4KeM76yXTu+/veK3qyrIuj8KOkI4wqXwkbui4rOs4KyH8JCol/CflbTIumAnLThbwqXCoXtg77+98JCjtDdZXDPDtOCyhi4lPzPhmqkKD0IN4YC686CGiyJZ8J6fuQoGQgTwnZK7CihCJvCRtql4cOC6hCjhg5rwkI6577+9JvCflbTwkI2o8JGFgFxc77eHChxCGlVcIfCfqJHCuFguJDoh0ajcjci6ZXfhpIF1Ch5CHOC4uDoiPSLwkZGd4LOu77+94bOU4Zy0P/CeuZsKE0IRT/CRjII40agkJvCeuZtdJk4KN0I1Llwk8JCDi/CdkqouJfCQla/wlr2w8Jatlj3wnrqH4YCqbDxu8J+VtPCQg4huRuK0u3fgrL8KHUIb4Kej8J+VtOCnoibwkJ2m8J+CsjomPlzgtIhdCg9CDUlgeSLvv71Xa/CfrpYKMUIvIvCQqLrwm7GYNj85RFonyLokS/CtgaBfWeC0h/CQoqdc8J+co/CflbTwnoWIXEYKDEIK4b+ycOqsheOBnAozQjFgNnvgrJXwn5W00agmQVPwkaqI8JGmsOGlgPCRsL7wkKSLw5lvONGoWVLgqIXgtoF7Cg5CDPCeub4kdCck8JCWmAofQh3DgD9v4LuKyLrwlr+wWCZzWEY/O1VgYGAu8J6KoAo0QjI54LSH8J+Im2Dwn4aWJ8KuPUTCsvCRpZhDL2Lwn5yPYkNzLmVc8J6ApvCflbQ9LOCzogolQiMv8Ja+nDomwqVgISV0JSfwkLKowqVTyLrgs4vwkIOu8JCVuQoTQhFEyLrwsIy5JS/jgZxb4K2WPwoJQgfwkJOFIsi6CjVCM/CQlojCo8Ku4K6Ce0nitqtcOmzgpr5dLkBWYdGoRS7CpT9Vd23wlquxKiLitq5s8J65mwoKQgjgtoLhsrN+LgoWQhThvrpY8Jatm/CfgrHwkYSZL++/vQopQicgWDxC4a6+J37gt48tblLwnpOaL+GJp8OdO+C6gfCQlLs68JGjvycKCEIGYPCQk61gCg5CDPCfoLg/KigsOipMWAorQil76qulOvCWvZw7MuCvl1zwn5W0UeODtvCeuqMkZ3Hhv7LguKpW4aCHZwowQi7hjKkq8J65me+/vSUl4KeI8JapuiTwnYSb1L86ReCojyTguqrDgeCnoOCqgi5xCh5CHErwkpGw8J+ioy/go4vIuk89Wk7wkaWG4rqGTD0KHUIbfOGlgD868JaqlMi6QnQj0ajvv702JyLwlquwCjRCMirwm4KPe+qmru+/vXt3TPCflbTSpfCQgIPwnrmRYU0wcyIiSznIuuGDh+CnqcKlw7lcCkJCQHVgK+CwvlwqesKp4LqE8JCohvCfq4Xgop4maPCeuaTwkJOT8JCirj9gJ/CdhIg8KTUh8JGmoSrgtYo/0ahrw5IKNUIzX+CykPCWvbTwkaq+NyI86q+04Yq68JGmpXtce13wkb2UyLritrlG6qyWcuC6qkjwkLCwCi9CLWPIuj3wmr+53owz8J6kiDkvJzTVhybjgIrgu5jwkb+c8JGnovCQoLLgv45gfAozQjE2fe+spGPjhrHgsabwkYyrUvCQjZ7IuvCRtItxb3084KakQvCRrIAj8J2VgcKl4KCzChtCGVYiXXHwn5W04KyD4oObKnIuUTrhnbLhibwKIkIgJ/CflbRR8JCuqy514ZG34KqP8JGYh0/RqDzDpSfWjycKHgoEbmFtZRIWQhTvv717YGLwnrmuPFU4JtavP+CxggoPCgluYW1lc3BhY2USAggECtgIugHUCAr0BwoHY29sdW1ucxLoB7IB5AcKHEIaYSTwn5+h8KmWtVtFSsKlJfCdkqIsLnBRJFsKDEIK6qyuayRTez0nQAoCQgAKHUIbKvCSkos68J2LrUpc4Z2z4aCEI+GMg/CRtbp1CjdCNVYnPO+/ve+/vTrhobNY4LK+eWtT8Jappj/wnqWW4LWW77+cMW8q4KiXTlfDi2LDnMOM76y8CgpCCC8t4aq277+9ChVCEyY64Lud8J+VtGnwn5uKXGk/wqUKAkIACihCJsi6KvCQqIAm8JG/liNeXHtcPCXDmeCrou+mk13CpfCWvp/wkIu5CjlCNyc6P+CrkEphKvCQtLDwnriG8JGovy8v8J+VtPCvo4TitIMkJuCrrfCbhZLhiYolKfCQrKPgqJcKFEISJ0nwkZabwqV1T++/veCst8i6CitCKVXwkZOXdSUl77+9YfCSlJAv4b2bw4Em8J6lleqhqi4qPfCQqJ3gsrdxCiBCHmVF8JCHonjhi4Dwr6CaRnfvuZg88J65pCLgsZY/LgoOQgzCpWwqLyJcWVjvv70KNUIz8JGNjNGoW/CflbQo8JCOpyTCpcKqOmRmXPCehYjwkJab6qmH4Ya376yVw7HqrL7gp50lCj5CPO+/vXMqLWNwUGkvIj9g8JCAuvCQvrbgpLcqOjzwnrqG4oKY8J+VtPCeuLLDhXtw4YSaZuGPuiTCpeC2gQoLQgloOsi64aq2YD0KMkIwZcOAP3t0w4jwkJW08JCgvO2fjHtQ8J2Ipm/wnrmk4Ka58JGNniJ78JCcj+K1rzV7CiFCH/CYrJcz8JGxniLwn4mHXEfwkIaW4b+Hw5cs8JuxvD8KDUIL8J+VtGfIuvCflbQKLEIqyLou8JCWvOqnnyLDjHDwkK2TOuGzhvCQnYJy4LCMP/CRpLhFcWc/4Z2SChZCFDpjwqFAPOKLpfCfr7IgXjku4aKVCgtCCTxGX1nwlr+hKgo3QjXwkZajQcOh44aHYDfvv70p4LOx8J+JkcOr8JCEq/CcvbXCoPCeuZsrJsKl4Zqxe/CRsZvCpQoxQi/wkIGF4LWI8JCzolfDneqghio8Jnvqp7Hwn4miOjou1rQiNiUve/CQlLDwnoKPNAopQifIujzwnZWEPOCvjPCRpIklSPCQlrZN4Ki14b+jYWk64oKa0ajguZUKHkIcJG1iKjd8aCprKi5eOC5X4LOHfjzgt6pV6qiSLgo3QjXwq62O8J+rgyd0TvCdoIQq8JGmoD1a8JGLgTwiPeGjr18w8J+VtPCfrrTwkYei0ajgpos1JgosQirgqagl8J6Ai/CQk4fCq/CRtLx7JuCviCQ9W3bgt4rgp705UC3hvqvvrJcKKwoEbmFtZRIjQiHwn66zJjjwnoCCKOCxjPCepZ4vWPCWvo/wnZWEbfCfoZUKLgoJbmFtZXNwYWNlEiFCHz9UVz3CpfCeubTvrLU9Xj8qPu+/vci677iMMvCrn6wKghS6Af4TCqUTCgdjb2x1bW5zEpkTsgGVEwojQiHitqone2vwkbaQTcKle3vDiPCRtIYlItGoV0DwkJmAMnYKAkIACiZCJCZK3JA7OO+ujOqjjybgq4sv77+9e1xEYD0n8J+rkG0v4beqJAoCQgAKIEIe8J65ncKj4KeXazzwn5W0zpBH8JG0vSQmcOGqk0IiCgRCAsOiCiJCIHtiPydcP/CQgI3wn6uh76yX8JGKnOCmhyXqrInCpUUmCiJCIMOla8KlPMKlJ/CWv7F8w7rCpT1Q8J+Ap1wi8J+VtD1mCgVCA+C7hgoeQhwq4aWA4Kiu4LWm77+976y4wqUuJnfOnNGo4K62CjVCM+CouD3wm7G8aSXvv70/VvCQlaDvv70gTOCsjy198J+rlyBP8J+VtCLgs6jjgIB7Rc6MaAopQid4fvCepZbwn5W04L+R8JGDsPCflbQ94Ymc8J2SqlFb4oKtLdGoaFAKUEJO6p+9J/CTkZLioI/vv73wn5ucUC7wkKa08JGFhmBB762B4Ka84LaD4Zyz8J6BoCXDpfCdlYZY4oCTL3TwsJOT8Ja+nSbhpIDgtoHwnqWVCj5CPC99KuGvgDo/JtGoP/CQqLpgRPCRpLfwkLOiRuyasFzgvo5g8J+VtCbhj7jwkKeNKmA14reJ8JGkqD9jPAoWQhRA8JG+sPCRiogmJDxBZHvwkK6vewotQivDi2Akw5ZH8Jq/se+/vS7IuuC3mzzwkYyf4rSRP1Xwlqu18J64rMKlKT8mCipCKF/grpnwkbWjL/CRiojhv5YmZifCpSfWlHTgq7BA8J6AnS7wkZyzOiYKEEIO77+9VGArw5JXKOG8nF8KNUIzPWDwnqWVacKlLycpbW8kwqXRqO+4lC/hv7bhvYsmw7fhnKUn8J6KmXfhr4XjgqPwkY2MCj5CPD3gr6t5MyrDuuKFmeGkjzs6TeGlpTzwkYyA4aOqYuqqjTnwm7KZzpHwkpGkamjhnaXqrYfzoIWZ8J+DgwogQh7hiqhkwqXDuSvwnrqBLErhv7IlJCTRqMi68J2LjSIKI0Ih4LevXFzho7TwkYiDVtGo4rSn6q6PPfCflbTihYTIumR7CidCJUM/Vsi64L+POj3wnYuoez8rw6pc8JKTvPCRkKtx8J+VtO+/vXsKP0I9UO+/vSbwkYWFe/CeuaRF2rbwnoS8NifCpfCQk4NcJfCQoZTDrSY9YOqUivCQqZdJ8KuginFidOCvjS/dhgosQirwnp+mQPCRio3vv71E8JCGoFsk4bK+P1zgsYE94Z2IJDzgpbtJPfCfqaYKOUI3yLon8J+VtDZlXG5KMtKj8J+VtO+/vXvCpd2yJWNFPVTcvFzCpeCyjuK2suCoqj3RqOK2ucOQJQoOQgzwnYGV8J65iyVNJToKCEIGUUHgsIxDCjhCNsOXJfCQo68kbz0u8JCQoCQmyLouS1zwlqmkRSTgtY/wkK6bwqUnL3nqnp4/PdWMZz5gw6TDoAoZQhc64LOx8J+VtCRWe0l98JCghVl0OuCuowoSQhBgPSo677+9PvCfq5HwnZOHCi1CK2jwnoWCwqXIuj/iu5Pgs4hc8J2RtSU68J6Fj+GfsCXwnZSTw5rvv71cLDwKDEIK4rake+CqqioxWQo6Qjgn4byYQ/CWq7Hfqi3qlpbhr5o/8JGKkjzwnqOHP+CssvCRjK9SJS4qUe+sqV8kwqgv7Z+D8JGqggo3QjVVwqVf4K6H8J6fqmDCsO+5qDzwkaiYQiZgWPCdkaBvR0XvuZs/cvCRsIPwk4qmJHsnKOG+jgoCQgAKQEI+PSQkfDjwkZyKansk8JGcqj/qqZQlwqVe8JGbhkXwkaSP8J28p+CysSfgrp5aOsi6XHDgrqjgpqvCpeGJi0AKPEI6LW8vLkBc27Am4KmI8J+IkeCuqdGoZVE64LWj8J+JkOGftvCWv6Hwmr+777+9e1bgt6sjJG9c4La6PwoHQgU/YO+/vQobQhk56qif4YuFLN6k8J+hmTrwnrmJ4K6oJ09cCjZCNCon77+94LeDJSov8JGWhuCmsD7wn5W08JasvSRgJ/Cfg7Al17Pvt7cp4aWz8Ja6mk97XjsKKUInI/CflbQ/JvCeuZ9YP/CRsKEnJNGoJci6POC6hMOtw7nvtrAnKj1RCkdCRfCQlrjslq3grJA/8J2Su/CdvKhewrrwm7GGSjrctuCovO+5sUNmXEHwkK6c6p2t77mqLyRg4KyPfvCdnadYKvCbhZBvbAoCQgAKFUITJNGow7nCpWvRqM2/8J6Am++/jgpFQkPwkICVyLouXOKAl08n8JGMiGrwnri74Kau8JuLieqfk/CflbRgJvCRjLUnImB38J2SpvCfrJsnYVDwnriYXPCen7FgCjBCLlvgrIk6QSnwkY2z8JGdguGgg/CQlrXwnrmLTz0qXzwkO19sXfCRg7JSQOC0ii4KLkIs8J2UmOGPvfCRsKcnLFbgt4Im4LKOaSXwn6CD8JC9ufCQqJ/vv71be/CQgocKIkIgWe+/ksOP4K6c8J2Tp+K3k2Xwn5+q77+9K8KlLuCqj1oKO0I577qHXHJX8JCknzbDiErwkbSO8JGGmPCQoJYvT+C1lOGwlPCfq5bDjfCego96IuGigNGoWNGo76ydCgxCCkPwkaqVJfCfgIoKMkIwITxFQfCRpLfgrIlSL/Cdkp498J6Ao1/wsoi9JfCRtaFcWSTqpbk6dWnirpJb77+LCg1CC3FIzb0iJ1rIuio6CgtCCS/wmLSC77+OJgoJQgfgs6Lwn4mRCjNCMXV18JG0veGxje+sk/CRtYd5XOGdqMyZ8JCql2wqbExW4YqqKvCQp5fFkT8/4LGdYjwKPUI7YOKCkvCeuKI80aglIeC6pSbwnoWOZWrvv73wn6CLIS3vt48/8JGKmuGJmO+thCrRqPCQlofit4zCrDwKOkI47Z+be8i66puFWz068JGwiCrigLw8cy8l4rStPS/IuirOn/CQvJEia1zgp4fwkKShYOGJm8OnV1wKO0I58JGxgHthXPCehYfwnoCkLF3CpfCRqJXDkfCRhohYJ+CzoUduZEzwmr+38J65qDzwkbWgZC7grZclChdCFWDwkYyzbdGoc+C1hsKl8JC/pVM6LgoYQhbvv5rwnZKKKuK3gtGoJzDRqPCSlIw9Cj5CPFM9yLrwkIebX1YiJSU04amkJWXwm4WQ8JGKpcOh8J+VtC7gsYjgtoHgt5Z3Uj3wn6+y77iIW2BnVGXCpQoVQhPhi6hw8JuBoGTir7p7762BJXQuCg1CCyrDrVw+P/CQnoIkCkAKBG5hbWUSOEI28JCphSrwkYWk8JCBgvCWq7Xvv702JCLwkIS78JGpkSIn8KuejOK3gCrwkJ2AKOC2uPCQuqwkChIKCW5hbWVzcGFjZRIFQgPgu4gK9gm6AfIJCpgJCgdjb2x1bW5zEowJsgGICQoXQhUkLsKz4L2Je1DguJAkP+CznSbCvmAKHkIcOfCRh7DwkbCO8J+hs00v8JGwh/CRhq498JCFkQoCQgAKL0It6qmS4Zui6pKi8JK/iC4u8JSYoELwkoOk8JKRsPCdkqZVUPCdvJnCpT4lXDxcCg1CCy5FJ/CQurDwkbC5CjdCNfCflbQ9P/CQg6nwnZGS4rqde3s986CHr27wlr6PJjvCq/CRpIA8Jj3wnZydZ3xh8JG+sHFQCgJCAAoxQi/IuuCml/Cfn48kIlnDlMKl4KqPSPCdkp/Iuk/zoIa7LyXRqPCRjZDDuvCRiqDenAobQhkvLnvOmGzIulDwkKaPYMKlyLrCq8KlwqUqCjlCN3vIuiLgsaLgpolrYmngsZkn0ajvuZUk4KGeOvCQup8r8JCGmvCflbQn8J64ouGCrMi677+9JmgKEkIQ4LGd8J+ggkMiP/CflbTIugoeQhw8cSou4KyzJfCflbTqqZQ9KPCeuKtDcT09JVxdCghCBifhv4M8MwogQh4k8JGct9GoRsKlIvCQoI1LYS3wnZKiJy/RqCZMdS4KNUIzPS5B77+98JCtifCRjahM4K6qyLrwkaSJJsO+Snx7Qe+3j+Gds+GojCcm4KGhwqnwkYy3CkRCQlvwkJ6u0ajwnoCUNOGLuvCWqKPgtYYmMu+/vS8kJOq8oTw9PFzwnrq74ZuD4KmvZ3LjhJAiKPCRgb9B4KuC8JuFpwoSQhDCtci68JCpllLvv73wnZKfCihCJidk8JKRs/CdgoTvprFX76y+K8KlSDVI77+94rSn8J2SrOCotXwqCgtCCSQ1YD1W8JKRtAoKQgjhqbLwn4KkTAoTQhHwn5W0J+qslu+/vTxc4K6QUgoLQgngtbk+e/CeorkKGkIY8JGYhVkk8JGWiCrwlqmePEcxMSTwlry4CjZCNG0uOifwn5W08JGxgfCQrpkiNFkpyLrvv70/afCen7AhYMOkW/CdhIMlWD8iKuG8pyLRqCQKCUIH8J+HuDk8SwodQhvhjqrwnYiNXj3vt49E7Z+EezbwnYejKjVryLoKGkIYP+Gikci66YqmdOChv1widkDhv7Lwn5W0CkFCP/CQrYMwT/CegJ3zoIeW8JGcnuGfglQq8JGamvCRqoPwkIuzZ+CxljrOnXHwn4aeXCXgrrRZ8JCBhC0zYMi6XgooQiYq4K+X8LCFuHfgsosu8JGonGknJCLIusK077+98J+VtE1NwrPNvwoRQg8k77+94Z+z4LqEJHvDm20KCEIGd07wn5W0CilCJyfvv73hvJvguoEiPVx78Ja8ml420agmLvCRmaIn8J2St++ooyQ9PAopQifwkaWX8JCkljXhvK9cLVjwkbK1JSYnwqVBOiImIvCRh4dMXMOiJyIKGkIYYCJcd2Q/J++/veGfojrwkIyy8JCSpzwkCi5CLFzIum0/R/CeuZ1l8JChiFYqw4I38J2SovCRjIzgsZon8JC5oci68JuFpMi6ChpCGHbwn6yLNT8/8JGNhOC7ly471L7wkYyqPQoJQgfhj6/gvZ1fCkQKBG5hbWUSPEI6zorqrqDwkICzJjo/8J6ku+K3kNGo8JCysXJg4Lez8J28qGV7a++3j++/g1pGeGAlcl7wm4ux8J60mwoPCgluYW1lc3BhY2USAggECr0XugG5Fwr+FgoHY29sdW1ucxLyFrIB7hYKBkIE8JChkAocQhrwnL2ELCY98J2Iu8i6UfCei793J+OEkkHCpQocQhrvrIM6YPCbirrRqPCQvrzgt5Jy4LGj8JCWjwo6Qjg5KTsnPfCdi6Xwn6qY44WtKvCRvIw8L1ngrpxw4r+68JG1huCorSQ6L8Ou8Jito/CdpIxgyLo/UworQinwnqC3XOCmiSfZmMOD8J+Di++shVk6LiHhi4BqcXDwn5W0PMKlJ2AncQoOQgzvv73qqKjgoJYnOCYKJUIj4LqG8J65kVB28J64t9Go8J6AncKl8JCEgD/Dgi/qkrRmyLoKREJCXe+/vS9ZcCTgq4su0ahE8JCdhuGpqvCdk5wqJeGxsmAkJvCflbRd4K2BYOOEnG3wkKGZ8JCOmyXwnZSQczPwr6iKCi1CK/CQjrpF4La7Ly9OYCI/Lkk8Vi5W4aaPbyLhnYzDuFVqYe+stCc8PUbitbAKFkIU6qyM8J2VhvCQjrkyOvCYtIc9TyAKO0I5IuC2uOCrofCegJZcJi/gsaM96quzSVzwkJa8IjzhvYla8JGNjGA/8J+sm/CflbTwkKuV4KegcVMmCi9CLfCWq4MlJyLWluOErXtg8JuwsfCQqZPvqqZpMV4977m+4Z2w8J2Rj+K2pj3DjAoVQhPwkLKpNvCflbTwnrKcTS/wkK2hCjBCLvCQlrnit5LwnoS7J+CpmS9gIjzwkYqPSnXwnrqhb2Um8JG0iTpv4ZuYZmDhoJIKNkI0Q8i68J2SmCU6ReGmgyxDXjwvw7VIVlMkXPCRtpMz4Yyq8JGNtCIm8J+vstGoQvCRgL/CpQotQismOsKl4LGi4YSJXMi64b2ddidUIvCflbRUKsK/RPCRhYB776yWUj3wkKyyChFCD+C/ivCQspUm4KmROTw6WAovQi0zZGngopjitaRc8J+VtD3DrPCQq7VcSlIvTOGkh/CRjI9MYDo64Z2M8JG0gCoKMkIwaci6yLrhvat+wqXwq5m8WvCQnIbwnqWY8JGylPCRjJ7vv70vavCdkp9LPT/wkLqrCjJCMPCQqYA34LSP8JGDgPCtgIE/alZGP+K3luqpkELgrppq4reiw6fvv73wkL628J+VtAo9Qjt1LyIlXl1M77+9e++4kjrRqPCRpIkqKiI6e3vvv70sJFDwkYy74K+X8J+rsOGKtGs/4LOp8JKRs+GfmAoyQjA9yLokSSfwkKGBwqVgVfCflbTqn5Hwn4mQ8JG0iOCytjHOhDIvajVO8J+FvWTgp4gKS0JJ8Ji0h3Qk8JCGoPCeuY7Iuifvv71U8J+XlyTigIkk44ShVOC0ju+slcKpImA18LG4hMO74K6Q8J6Ao3vwkZeB8JCAvOChsF0kPwoVQhPwkY20V/CflbTwnbyqVCbhvJp7CgZCBPCTi4EKK0IpJS97w4c/dzvwkYWe4Ka9Z0zwlq6C8JGMgeCunPCdkqplJCPhi4DgvqgKB0IF8JCRujAKM0IxNfCeubxIVfCflbRlRMi6eD3vtaY98JaplOGgme+/veC0kGNVdz0/PPCeuaHwn5W0OgoXQhU64LSrV/CQjZ5c6qmFYPCfgqk8Kl4KPkI8LuCqtVM6Z++/ve+/vW3qqZI/O++/vSbwkLSkP+qlpPCdjJpD8J+VtHci8JCWvPCWvoUk8JSYlPCflbQnChxCGjA88J+CiFpcXCXRqHo+KjrwnLyCPWQ6IGhCCgRCAsi6Cg5CDNugYD1BOuGqteC0kAoRQg/vv71fYCPhg403yLrgsosKAkIAChhCFiom8JGnpDrwkpS18J6lmfCRi7UnyLoKNUIzyZvjgb3wkbSD4b+y4Kq28JuFlduj8J2LqyY/wqjRqC7wkJOrw6R78J+hgzrwkaSV4oWfCi9CLfCdlZDHgPCQjZTwn5W0PSpv4LKY4YmY0ajgr4w9U/CRtZBAQCQ/TPCRgK8qIgogQh5Aejg80agiROG9m/Cfqojgprda4KGedOCrr+qhrjwKQkJA8JC0t+CvgvCflbTvu7pQw77wkKmt77+9NC5cPDoi4LW48Juyn/CRnKgv4b2N4LCB4b2ZJeCntOCqkD0kNOC2rwoiQiAvKvCQlbjDjNGo8JGytvCRi7HwrYOwyLrqobZFIi7RqAoEQgJyLgo3QjVNP0rhiZHwmr+94aS5e3BcWOy+sz9RVT3gp4vgt7JDYPCqrJhI4Z+1IuCqpvCQgL1rwqVwPAoJQgfgrp8m0ahpCghCBj8iw5l1eworQinwnYi6JjwpJCfgpqrqp6thXk7wnZSc8JChqm8qcWA/JTfqr7XwkLKAUgooQiZSWDsme/CRgbDIuuCzgns0LvCRg7Eq8J65mVwnJ24+JeCzs+C9pQo+QjxCau+6jvCflbQn8J2It3LhsL7qn5bvv71w4Kav762D8JCojuqsqCnhjpkkJXbhnaAu4oKHIiLikYDhnJMKNUIzWvCdhr3wkJaU8JCMhTY/P/CdlK/gs4TgoZrgqrzCpWjwn5W08JCniiI8JfCflbTCpdGoCilCJyXgrZw/c/CfnpnCrE/vv70nJ3w6JfCYqaDvvoUr8J+isSLwnoKPNgo5Qjds8J65klQ8SUhrP+G/iEsqwqXgsrjwkIqH6q6077+E37EiQCbSk3BcJUDDqe+shTrwkYqW4b+XChlCF+Gfg2574LWN8J2UkyprIsKlay5lJV89Ch1CG0U88J2Uj+Cnh3vvv70tWm1NLeCovGBQdOCnnQoFQgNNwqUKQkJAPGDwnZmLWWDgs7E9e+GjridQe9Go8JCssj1kL/CflbQ/8J+DofCflbRuJ/CQrq3IuvCRpLfitrjitr4lNuGJjQolQiN8L/CRtYLzoISHyLoiQO+/vTHwkayJ8J+ulCxWUCTWrHvCpQo+QjzwkIqo8JCBnSRX8JCdgSI94b+mLzrwkKeGSO+/veCps+Gcs3InXkzIuuCsj/CRhoolL/CQqYhjyLpgSCYKEUIP76y+POCzqyvwr6GvJiIoChJCEEXitKfvuao/azgiP+GggT0KAkIACg1CC3LYi/CQrb/wkbGCCidCJSYnP0nhqqbwn5+lXMK6PfCflbThnaBfLzHDiyrwkZmlw7MnJCwKKUInw5XRqPCfg4jCpVTwnbyo3J9Z4K6VJVhE4K6j8JGKgy/RqG7wn5W0CglCB/CRv5rCr2sKC0IJKlzNojrDhWAjCh1CGyThj7glw4k8OmAq8Ja/oXsl44iR8J+VtDwiKgooQibwsa26IuCnnWBGV/CdvIgkwqXgvpQkOjwn8JGMrmfhq4zqrq3NugoDQgEqChVCE+Czle+/vfCQp48lPDp0w53Cvy4KGkIYYOCvkOGyvSfIuiUvPSbwnpOmUj/go4NICkJCQEpdLk0hTmXwnrin8JG+sMKlRz/wmr+98J+VtOCjji898J2SuOCmjCbvqIU4RS/RqPCRioDRqOCrgNiMRMOmw7MKB0IFRMKlODoKIUIf8Kq5rvCflbTvv6h1T/CRp413NSQvPyPDk/CfoZXciAoCQgAKLUIrLnHwkbysXO+/vcKlTUYiOvCQq4Vf77+9W++tn+CxiMKlTOCrkHLIui/CpQoHQgXitYrDhwoEQgLIugolQiMm4YONYOCnjSo6XGDCpe+/veGoi+GmnNasLzxkKsi68J2NtgoHQgXwn4KGWAolQiPCpfCQlqztnr3DkzZ74Kmz4Yq8KHtI4K+KLyUqIvCdhLowdwoWQhTgs6gkMyYyOl7wnL+AOiXvv73DnwodQhs3JvCflbRCYGbwsZmX8JGyqcOvfkwkwr9qej8KA0IBXwoHQgXwn6+3LwozQjHwm7KePXsm8J2IneCwikPwkI+OJT/IuiXgvKNg8J+fpUXqkqEqPWTwr6eo8JCpgElyChlCFzcnwrzwlq298JCLiiLhvZlB4LeQPHAiCiUKBG5hbWUSHUIb8J2SuyHwkYKuXCIr8J+VtCbhi4vCpeCsi3IvCg8KCW5hbWVzcGFjZRICCAQKxgi6AcIICpYICgdjb2x1bW5zEooIsgGGCAoVQhMqaj1p8JC6sEzhqq1gNTYqwqVcChNCEcO54LqK8JCZt2AnIC7wkIOdCiBCHi/CpX0u8JGEoE9J8J+VtO+/veKCkFku4K+68JGKhQobQhktKXzwn5W026wuXvCeuYd78JCTrEElNz85CkJCQPCRioxf8JC6geCqtybgt5Dvv73grKrwkYqIYHNMP+qphzzwkYCZKiJo4LqvJ+C1tzzvv70k4Kmt4aCHPPCdkIIKNEIyQFtQ8J67sEvjhLF4OnkiIT/gqK7RqOCuo/CdlYbhpINTJOOEssi6eida8JG8gyfigLYKGkIYRT3iupc6ey8i77qjL/CdjJYu77Kg4b+yCiNCIcKlNfCWv7Bo8JCon/CWrZzqpbHRqE7qpag977+94KugLgoCQgAKTEJK4Y6YJCrwkLO6LiLwnZST4LWIPGrIuuCxrtaO8J65iSbqqZnIunhQS9Go8J6AhPCeuZnwm4SyJPCQuazwn4i18J6AquC1vfCRrIkKIEIeNXBaJvCfrLzRqGglLfCRvrDwkK6rWOCkkeGgp18iCkpCSFw64ZyQPDbwnrmRP/CflbTCpfCfgqAqNPCflbTwkK6sJ++5ovCRoIUn0ag98J2Uu8i68J2qnHvwnrqS8J2LpSrIuuCzsmDDjwoCQgAKA0IBQwpJQkfwkLqswqUme9Go4Kia4KyQ8JCkryrwkbS66qucUeC4mFw977+98JGYi/CTg6PhspAv4pOzSnjwkYyyPVzvv71u8JGMkMO5YAojQiFBPeCmhfCQi6Qk4oKBLikkXOqnskHguq0/8JCnmOChnnsKGkIYe/CflbTwnrik4KmHLuOHiyfwnZKl4byyCixCKnnwnLycw4TiuongtY8uOlnwkZmmey898JC9uXlgIuK9tMKh4aWA8J6fowpBQj914reUUC/qkpbwn6CH8J6EgvCRqodmOtGoLyfvtJjCpWAvX+CuvvCflbTwkIC8Zy/hna5w8J+VtFkn8J+poT0KHEIa8J2UuSdrLmxJKyfguok677+98J+VtOqplkkKDEIK8JuxsHs20agiLwo+Qjw8KnklR/CQqJbwkaeP8JChjyIl8JC/gnMk4LemZ/CRvYzIujrCuH5FIdGoTvCesrA96p+R4LeF4auFJj4KHUIbOuG/iWsk8J64u+K3nj4yXO+/vSo5eyTwkZKACiNCIeC+jC8qPG8qKuCmli4pMU/qp6/wkbW+8JGZojol8J+VtAoGQgRzeD8+CgJCAApAQj5Ge04lw43wkKmI8J+VtPCWprpg0ajqpZHwlr6RcNGoQyJbyLo8TkAlXSs68J66iO+/veOEruCqqjzwkKGMJwoaQhh9WPCdmZ3Yk+qZv+Coskwk8J+VtMi6KiQKFgoEbmFtZRIOQgwn8JGNkCTwkbSJey4KDwoJbmFtZXNwYWNlEgIIBAqnAboBowEKKQoHY29sdW1ucxIesgEbChlCF/CRjbDgs6Mv8JGZlUbgprI88K+jhlw5CjwKBG5hbWUSNEIywqUkUiM/YCd76qq78JC9s2Ai8JGCrk3wkbKAIy/wkYOA1ptJJvCflbRr8JGmpWUwPXsKOAoJbmFtZXNwYWNlEitCKS86XC7RqPCesqkqKG3wkb6wKiMu8K+huz7wnoCMJ++/vTzqrIw/L8KsCv0RugH5EQrTEQoHY29sdW1ucxLHEbIBwxEKHEIaw73wrZqgWzore+CrkHvwkKCu8JCkh/CeuJ0KLUIrYO+/vU06R3ZTOlvhv5Y38JGnoVDwn5W0JfCeuLQ7L+GjtVzwkJOk8JC0sApBQj808JGor/CQlrtuKWDgt5nwnYeG4oG2Ii7gs6FE6p+X8J2VjuGhqC/wlqqF8J+ChPCfn6NgSj1c8J+rgT3vv70KG0IZcUXgu4Z+OuCxrOGJilMrLtGoPPCeuY8lXAoiQiAkVyZMNMi66qmHXO+/vXbvt78uIsOtXCc0ceK2vuGGgwoPQg3wnoCK4rSnLz/wnqSVChlCF2VgOlFcKyTiv7vwlrm+TdGoTlfwnriiChZCFDzDrTop8JCohl3goohEMyzvv5w9Cg1CCzvqn5A18JCirU4vCgVCA+GdowoNQgvDtsO/JDp94LGNWAo6Qjjgsp/qrKDwkZCWaMi6bzXCvfCQrY468J65hy4jPTIzYfCbsplmw5VaWSfwnoWH8J+ptTV78JCWuwpCQkDSjuCzp9GoLuCnl+CtnC/CpVsiL8KlLvCRu7Al8JGpnsK9ezxm8JG1vcKlUe+8u/CRtZnwkaSv4La1L+OIhiBrChRCEvCflbTwn5W08JG2kMO/4reWLQosQio88Jaro9GoJTR78J6yhXZxYOqfv/CXoJXgur3wkKiF4L6gJ1zwkbWhSmMKNEIyzorwkI2mKvCfoZBc0ag6Ou+/vSYs8JG+sPCRg4LwkJaUXMOpfUXDoy/gpr3jgJV8ZlMKHkIcLvCfr7TwlrmV8JCwrCbIulziv7s60ajwn6G5OgojQiHwn5W04oKx8J64u/CQgZTCpUw64K2fdkxAPz1Q4LCPbHEKHEIa8J+VtMKl8JarhyfwkKiM8J+VtOGqt+CysCcKG0IZ8J+VtGXwkYSzwrzwnqWf0ajCpWDwlr6TLwoQQg7wkJ6D1o1TRkLwkJa7PAoMQgp74rWwJ3vwkIWVCidCJSfgpo/CpfCflbQi8J+VtMO0XOGLicO48Ja/sF4iOsi64rSnL1QKIkIgXHwi77+9JkPwkJ6maPCWro7hm6c+76qJ8JGNsmrigrEKF0IVPmBwbSfwnou/4L26WNGoP2DwkLGECiJCIOCuqCfIujzDvvCRmKbwn5W0KuC8mOCumSVg4Y6rPDpcCgdCBe+/vci6CilCJ/CeuYJg4Y27OlkvPPCflbTwkJW9bPCcvYLwlrqFIuK3ieC3heC3igowQi7wnriDTi7IuvCflbRhwqUlJlHwkYuRPfCRkqJN8J66oztNeyRtYeGkt/CfiaJ5CjxCOvCRiqM88JC5tPCRirhT4aWUWlzwnrux8JOAkCriuJB7Iirwkbyzw6PCvvCfh70lLci60ajDjsi6w64KJkIkI3Tgvp7CsFsk8J6LtSU66qyB8Jy8oUHhn6jgtrTCpSJe4K6VCg5CDDrwkYOC4YuR4KiPPAo6Qjjwnrin8JG0oSU84LC/JsOt4b2ZLuGku9Go8JuAk++/vfCQj4vCpfCRjJA6w4MnLiThir3qnI1mTgoxQi/wkbKx8JG7pPCYqbPwkIC4QScgLsKo4ra1Zsi6VjwkYj/wnriX4LeWUO+qt+CmkAoLQgk68J2UiPCfqoMKS0JJ4LuXYFXvv73wkISAeu+tgy4/Jyvvv73wnYWt4bOAQeqnknvIuvCRpLhz8J+VtPCQnoA/LuCuivCdhppo8Jq/vvCQrpo9LuCvkAoGQgQnNGF7CgdCBe+/vSpkCjdCNfCRiqXqm5Pgqq/wm7KQKz3wnri0QT3Cvj3wkKeO2YkkPfCflbR38J+Hp0fgqIIn0ajwn4KjCjtCOfCQoIHvsplj8Ja/sSXIulUqJS5977+96qejdeC1tPCQhIFSJVpnJibhvZ3vv4J74LWwJfCQqYNcYgo7Qjlg8J+VtGTwkYKwwqU/ez498JG0iD3isKVs86CEl+CmrU4t4Ki50ag7yLrIuj/wkYO1QfCRjYzhppUKFkIUPMKl8KG+mWDSvPCfiKnDuvCdlJcKM0IxPPCfooZgRi7wnLy9KvCQq4LCvTE8Jk4iJ8i60agl8JGZq+GIj/CeuoB1SW1gwqc/YAo7Qjkz8J6Cj3km1p/hrIpbJeCquT9c77+98J2VhvCQh5Hwnrm+6qe2dS/wkLSy8JGZpnvvv5vgoZngpokKH0Id8J66qO+/ve+/vfOghb0me2HwkLS4XmNHXF/gp4cKHEIaZz3gqZts8JGysXvvuaAk4KyzLy4l8JCRljoKLEIq8JC+g+C0kOCpmiogZEtK8JGklvCflbTCpS7wkamCYC5Q27FSwqUqe8KwCj5CPMqP8Ja/oOC1rXlmZnBUJuG9l/CflbQ64LezZeCytvCvo47Dg/CRgosqcFTwkYqIQEPhna7vv73CpS48UAodQhtKSOCzozxk4LSF8J65ieGOhjrhi54oPPCdgpIKJkIkeyJceNGo8JGguVkkOmMlP+CunPCei7RV4rqFKiUvXNGoPT8mCj5CPPCdlLMuOmbvv73qn5cmwqXguoJkIF/Dqz/Cvy/wkbWl8J+isPCRnKQnPTxHS/CeuqbwnY2ubT/wnrmXXAosQipwVybDlvCepZ42LtGoO/Cfm7JIKn0vLjbXm0TwlquzdyUiKjrwkKiOJkkKKUIn8JCAk9uw77qKKuCwpfCeuaE28JCAnGh7LCQ9wqVCdPCesp7wkJKkCiVCI+Gqgy5Mw4R7LsOu4r+zJz1P8JGMkOGKqOGKrSJcJjFKJEpECidCJT9fIvCQoIQm8J+VtFwtyYzgqatgXPCepZM9wqhr8JuJusKlKiYKMEIuOifgrIZ7Xe+6m/CRi7LRqOC1lvCflbTwn5W0bHfwkLSdWj3IuiU88J+VtCTCpQoSQhA9JvCfgY8iKvCcvo3wn4KmCgNCAT8KJUIj8J+qrvCbsp9S0ahcae+/vfCei7/gr4jhiZjCpyfwnoqmOGAKHUIbJlw88J2NsOCxiy7wlqmz7Z66KCTwnp+g4LGmCgJCAAoOCgRuYW1lEgZCBPCflbQKEQoJbmFtZXNwYWNlEgRCAk97CuAHugHcBwqiBwoHY29sdW1ucxKWB7IBkgcKLEIqOSTgupPwn5W04oy0LzNc8J66peGlgGAsLjUgSmsi0agm4rag7Z+F4ZuJCiVCI1vwn62G8JGygCI88J+VtOGpjeCotfCdg6VkYCZ1fXt74KuiCkdCRfCQqJ7gtY87LfCQhILwkbyL8J64ufCRhaDwnrikKigw8JGciuGusT/wnqGL8JG9jWDCpUMu8J+bquqaq13hnbN7YC4/PAoDQgEqChRCEuCslPCdlYzgrpzDjOCqs8OfXAokQiJnPFw8ciTwn5W08J64pGbwkIGT8J+JpD/gs6DgsrzwkIKaCgZCBGU6wqUKQEI+dC7wkIagL9Go8JCojz178J+rhC3WucKl8JGDki/wnoKP4KyIQWjDrjzwkJaC766q4b+qZe+svicnKtGvwqUKK0IpL+C9u/CQjp3Dhe+/vS/wkaSJwqTwnpOSIVHCpSbwnbyD8JGNi/CehLgKCkII4bme6qWPZSoKAkIACiZCJFJ14am/8J+VtMOI8JGCskXhv5vhqJ7hg40vecOT8JGWpSdGQwoLQgnwnZie4K6CyLoKRUJD6qm7JFAv4r+7e/CfgqXRqCgk8JGFhX4lJ1zCoPCQj4Ey8J+VtPCflbTvqrPwkKOrIF/eqPCdhb/wkpGweyYp8KufvAoLQglTYHvCpeGisCQKL0ItPG0l4LedLvCdi4cnJD9BUkzhoJLitZ/Iukl68J6FgPCQqYRK4Ky34KqDJmBGCjxCOiLwkb2V4LOmLy7wkYqmP2Lih57wkLyy4LGh6qePV/Cav7bwkJmsPXFGKi8qyLou8Jy8iEo9yLrhvZIKEkIQPGwx77mx4LCqJfCdkZ1BewoFQgMkcDIKJ0IlXC9jYOCtiPCeuZcrb2FX8J+VtPCWrZnwkKC8SF4/KtGo8JCGoAobQhnwkKOhYCrgro8/4aeaR0N0WiUv4rar77+9CgRCAkJgCjBCLjrDsCrhoITDq2Bh4Kuh8J6jimAgT1k6OsOTfCZdPfCQqYjDrOC3mydcWeqmnSoKMkIwePCWqok28JCohvCQhqDCq+K3iMOqJ+G9m+C3hm1gKDxBOuGVuXvgr4d7IT3wnrmfCipCKCrCpdGoJzrwkbS6NCLCqOOFj/Cen60/4LueL1R4JPCQvobwnpO1PycKCUIHXPCRl4bbugouQizgtb/hvZ3DuWgqLiZ20ajwnrmk8JGBo0Pgp5zitI3wnZCY8K2BrH08yLoiPQoOCgRuYW1lEgZCBNGoYEoKJQoJbmFtZXNwYWNlEhhCFuCsgXMx4K6jKiDwkJaaOvCfhaPgprAKixi6AYcYCuwWCgdjb2x1bW5zEuAWsgHcFgowQi49x5RkwqLPl0El4Y2tLj17JSTDu/CetKzRqPCen6DwkYi44LmY4aSEc/CflbQkChxCGj5xLvCQios68J+gmkxe8J65mVPhq4Jc4KqvChNCEdGoPNGo77eA8J66p3Ut4KedChhCFvCQnaQ68J2Sqlzgrqrwn5W0yLpgJk0KPUI78J2qoSxYcCRD8J65i/CRtLom4b+EKkPwkYiQ8JG9hiUi0ajwnqOP8J6EsOOBlOCmvi7wsIuZbeCuqF4KAkIACkdCRfCflYRLTm/gsZU68JC0tj/wkIqb8JG9iGBQ0ag/L0Dwm4WQ8JKLsMO64Ku777+GSOqvmnvwn4+gV/CegJ/iu45c8J2UoAo5Qjfvv4978J2JhC9E8J+VtCcm8JGkt05CPE0l86CEny7grpxzdfCRjIlP0ajvrLhcYGgk8JCjtCI9ChVCE0pNLz7itbDwkKexNiLwkI21KnYKFUIT8JSQhS9g8JCjoTnvv70k4rSnKgoaQhg5YPCeuqE9QWDCpV0y4KmNPyXgrIIlJ2AKS0JJ8J65ueGtnPCdiIIuL9Go8JC/sSTwnri10agmw4fwkZC7czrgtZ0n8JGlgF/gvpnvv71HaPCdkp5p8J2Gn++/vWTwnaC+WSHVoQo8Qjom0ajgqLnvv73Dkm3itq4wKfCQkbYkK/CflbTwnZ2yPeCwuC/wnoWO4Kug8J2VisKlS2Mg4KqzYFwvCiBCHmLgs65p8JCplUbRqNGocmhjLOG9meC0hi/vv71rdwopQico4LOdRu+/veCrkOGysPCeuItb4rapSci6Ij3gqLjhiZXRqPCWv6EKFUITbeCumT85JOK0pyfwn5W08J64igopQic58JKRnWPCpe+4qOKFkmvwn5W08J65nfCRvIEm4Y2Q8J65nT/qr7EKF0IV8JGDmuGPu++1le+/vXvgtb/wkKyBCjhCNvCRg6ZpKkF08JGatj10XOC6oWBccT/wkbWiyLrCpWZMJOOHomHIulkn4KuQIvCQsoQ/e8Klfgo9QjtcXOGktUHwkYOz8JK+uvCRl5pdJeGmp/CRtKki8J+Ehs6MXj8mYCo8POGXm0hJ4YiD4LCKJ++/veCsmAodQhs78JCejXsqJeOAnOG/uFfhna9h4KqRQX7OjCIKK0Ip4KaQPzLvuas2KiJc8JCunFwq76y58JColfCflbTiurwqyLo98J28pSIKEEIOw4XgprbigorwkYO5YC8KBkIEPuCshwoIQgbwn6KwU2EKJUIjJC57NsKl1oY/S++/vcKl8JC6sUBfRT09zoxEJCs8b+CxnT8KEUIPOvCfg6I+J/CRpLLwn4mQCj9CPcKlacKl4b+M8JGakGDwkLCn4oKw8JCeg2Xwn6KxYPCfg7RI8J+buX3goLgle+Cugy4wOMi68J+EtE9OyLoKFUIT4K6C8JC0isKvKksmJsOi4LqfJwo1QjPwkIGUKirDrVLIuuGdsuK1lDzgsJAlYyzwn6CF4bOc8JK+ncKlOlfjga1cLvCRg7I6KlwKK0Ip4LSC8JG1gDPNv2AnXMi6yLrvpJ4k8JCSpfCQqYFW8J+ircOHIvCfn5gKJEIiJjwqyLo84oCw4YuAyLrwnrmLPeGnoCVtw7Hwm7KDIsi6cAo/Qj3IuvCQq7HRqPCRjL9oOvCfn7Ak0ag/4KiB8JGcneCroGAmJy9K8JGanz8k4YqLdSTwnZKi8Jq/ufCdjKA8Ch1CGzzwmr+9TD3wkK6EXCQ6afCRsplg8JCMseGkpQoSQhDhpqk9U37wn5W0MnBjwqVgCi1CK/CflbQi8JGNjeGdi/CRgaYie1filp/grppi6p+Q8JGYq+G+tzZVw44qwqUKHkIcYWTDgEMk8J+Hq/CQlIhRaci6OV/wnrmd8JGNlwo/Qj3wlr2n8J+VtOCrgnvDq8K4LvCQkJ0n4b2b4K2M4Z2E77+9RG08eCkuQ8K4wqXvv71Kw6PRqFXwr6eJSiIiCgJCAAofQh0ne2MqOmg+8J65iTd+w6dcwqVO8J65u2ngqo8iYAo6QjgkXHXwkJKmRiLwnZKp4byp0agn4K2IPSLwkKuxZzx7YPCRjZfDr++/vfCQjaJu4K+QfCrwkZCALwpGQkR34LSPPy/igZbIulzCpfCRh7LwkKC3wrfigbF84K+KRC7vv717IuqsqPCQuq3wkJ6zXCrQmvCQs59C8JGQolwm77+9agoPQg3wn4CqNeGMkyQi0aglCi1CK/CeuptmPyJt8KqquvCfiaBgaPCflbTgtog68JGNsuCriUh48JCetlxVyLoKGkIYJe+tvu+/vWAqLyJcZiXwkbyXL/CfqbN2Ci5CLOCngS7wn5W08J+VtOGsqPCdlYYkNtGo8J65t3koejxGbvCfqoBIZWdg4KKGCi5CLE488J+bqvCfg4zwkISs4Z+34rmZe/CdlI/wkK6A8J+goCRaIiLhj4XwnZOOCihCJlRL8J2FlGDwlq6OIkfgrYfwkLOV8J64u/CSk7PwkaqGYDXwnou/CjZCNOGKtTU64reAXOGvgz1RJuCulSfhnKvwm4Wl8Ja5vPCfoZXhtaDwkLCT6qWvIvCfn7BiXHUKFUIT4a+GPy8q4aWNLiQ9yLo8PO+/qgoLQgnqo4888JGSny4KCEIG0ahGJWI+CgpCCGY6aPCTkZQ9CjRCMu+sgCDhn6nvuabCpfCRk5AlLzgvw5VBIm3gqIh7Y/CRm4PgrKzhsKLiupdu8J+VtDt7ChRCEuCsgSkmeu+/vfCQq6zgqYwiaQoGQgTwnp+uCh5CHMi6JO+/vfCav77wkIWVVOCskC7RqMK38JGXiCcKNkI04KuA4ayK8JGkifCeuYsiOn1a8JCdleqlivCwq5ngu5TwnrmhK+qloyRB8J2UnDcifV3DkAo+Qjzwm4K2PPCRjJDgprfgpYzvrYjwkK2E0ajitrJgIvCav7064LGE77aZ4aWA8JCYoirwkb2XJNGoP+K2jyYKB0IF8JCgvGwKE0IRaeCxhiol8Ja/oCk9LPCfoZIKREJCPHDtn7bwn4+cyLrwnZSnOvCRioE9dC7hppjOkPCegKTtn4XwkZGd4r+5feC6pSZce8Kk77SX8JGNsCEyJeGJnVxcChRCEsKlJy/wkKSNdl40P/Cbsp3CpQpLQknwnri58JCdifCWorHwnouf4YuQ4KC1T9al6q+yXSrqpaEmQEvwnY2m4YCdQVrgqZrDgvCRhqfwraCK4ralJfCRpqLRqFXwnYuTCi1CK+KVq/CQp4siLzJD8J2VrcO90ajCpeC3hC4u8J+VtHPitKfgqId7Y+yvrVsKI0Ih8J+CtfCQjrnwkJSbPOCuqj898J+fsPCeuYsjPfCeuLtLCiFCH1jwnYuvYO+/vSI0bzzwm4WRPSrwn5W0J/CRkrngroIKMUIv8JCekfCeuYsq8JCouPCRspJ5yLpc8JGMhl3wkJ614Ki+8Jq/vSVcTeGJiuGekD0KQEI+8JCFqzxXPeG+mOCosnLvv71U4Lq9M/CQqYTwkJa777+9T/CRjZci4KmNLvCRjZBcJT3gtIInJXsuwqnhnaoKMUIvPT896qabOmkiPHd6JvCQrpvgp7FGJfCRsbAnTEdc4LGY8JGNl/CeuZngrZ3vv4QKEUIP8J+VtMi64b2ZZMOp4LOWChFCD3XCtCfgrLXIusKlYeCotQpEQkLqrpMn8JGMkH7wkKO7TuK/lT1KL3XvuZfqr5BIwr3wkY2s8JGkp+K0m8i68JG7p3XwkbS6M/CQpL9HSfCfp4jgppAKIkIgQibgt5JLXDo6diQi4LSOVCU6w6Fi4aGG4K6kSmNQIi4KGEIWRjjwkLS58K+ijiIlcCLDjsOy8JuFlQoRQg/CpVwqLGzwq4uPd/CdpaEKNQoEbmFtZRItQis8L+qgt+K/sPCdqp3Yj+Cvl0/IuldU4Lqve+GytjFgby8qw57RqPCepZYvCl8KCW5hbWVzcGFjZRJSQlDwkJa4KMi6VXvwnrmC8J2SovCeuaTikYjwnYGk4LaI8JG0kGsmJyXwkJ6BNfCdlJlm8J+VtCLgqZ7gt4bgq4Pwnp+rXPCfoK/guqV2KuGmvgrvDLoB6wwKogwKB2NvbHVtbnMSlgyyAZIMCjFCL+CotSVgwqUqMk428J6TkEfwkKic8JGNlzzCpT8uPPCbsbkq8JC6sD8y6qmVXD0qChRCEifwnL2iw6bwlqObNsi6Tl48JgoRQg9V8J+VtDwvQ++/vSrgoYUKAkIACg5CDDHgpp998JCWtkAhIgoCQgAKFkIUOjw6PSR+JS8iInbgv5ArbfCdvKgKDkIMQPCRtLzwnrmbWXsqCi9CLcK/w7jgsY3RqDvwn5W0cSXgtYZTJS4lPOOEhS7wkKalXO+/jCDwk5GM8J66pQowQi4mbvCQnabwlqu0Sjw8Iirqpa0zbVFQ8JGSgOC6gfCQqJDgqrUnfuC0sUXwkYyCCghCBjjwnaqfVgojQiEvPeqZgiJ4OuK3nGDwlr2edWDwn6uwe/CdgbrDuvCQgJcKHUIb8J6imD0uKmLqpbXwn6CHJfCTg74uc+G+vsOqCkRCQu+1lCU/XPCdnaEm4LW74K6C8JaricOVSOC6hPCWq4B04Yy5UeCisOKAvC7guoFQ8J2EkmPwn5W0M/CQhIIsJDPCpQoGQgRsJSs6ChdCFS/vv71M77+9IuC0ieKOmjMrIeGJmgoIQgZp8JCArWgKMUIv4Ky2X+Cyry/wkYqNVfCflbTCpXLgu50nW0NZ4Kizzojgt4rwnrmLe/CRg7dcYUgKMUIv4aqTS+GMk/CRtpEq8JGpoSclIeqosfCesb/gqZ4nSybIuvCego9FJiThvpLgrpwKPUI78JGysjomZOCnlydMT++/vUIqJ0JU8J65i/CQoIjIusKlJ1jwnruw4LWHyLpa8J2Iv+CgosKpQjo8YSYKD0INUC7CrCU9MNWcwqVQPAoWQhQuaD1NKWBi762EPMKw8JCPkTptegozQjFj8JCGoDpbIj/gq6Lgt4Q4YOGfpkkr6p2QPeK2pibhvYN74KqsVCTgtY1o6qyE4ra2CgRCAmA8ChRCEipB4L2nwqUxzozan2DIutGoJgomQiTigprwnrSoXe+/vXtbJT3wn5OY4KuQXe+/vXXhpKdc4LKr2pkKOkI4fu+4jvCRi7A94K6SwqU38JG1r+qflfCRtqfwkY2Ncz0u8J6Lv+C1u/Crn64n8J6Ai/CeuJHgtrEKMEIu4YqLdO+/vcOwJvCfprPIusKlW0Hgp5zwnri58JCAunRb8JCAkcK6UMOxMyQkcAomQiRoJz/wkaaiPOCmhjfwnrmd4K6eJfCehYXRqDU54KedPfCWv7EKGkIYInfwkbaR8JGYuXZKPGDhrYB2TSTwn6uECihCJvCyjYIq4KC4wqVXJPCflbRZe0fwn5W08JCyjyHrpLkpP3Nl4KiqChxCGvCQk4El8JKRrvCQnqMi8JKRoybwkau04YCLCkVCQ1jwnrin8JCgvCjwnrmdLsKl8JGBgDVv8JCps/Cfq5decMKlc/CQmYPCpeCkhPCbhLLwkbukPOOInfCeuYInYOGmsjsKIEIecvCdg5bwkaOUecOX8J+VtPCQlrjwn6CF8JCWlCcgCidCJTpd4Z2zSCJk0ajDse+thGxa4rajMC7wnrmZ8J+DinUo8JGKkDwKEkIQ8K+liPCdhITgvqJQTeCvigoZQhfhvZvRqFzgqYzCpV0/M2fwm7KF4La1JQoCQgAKCUIHIvCQgZtsLgoIQgYnXPCQpIEKOUI3ffCegKbwkY2IIio/4b+HPOGLpHTwkI2mwro68J6Lg+C6hCYv4YONwqTCpfCcvKvwkYCkSOqSqQoWQhTwnrSEZiolwqUwPCbDlnku8LC7mQpGQkTRqHvwkaSNeVPIuirwnYiG8JGmpTLqpbHwkKGOw6XgrKpZ4b6MJfCesongq6LwkYqVee+kv++9gMKm8JGroC9D8J+VtAoxQi9Q4LWN8JG0gCLvv73wkKmw8JCiqSRB8J+AoSQl8J+VtPCdlJHqp6nwnp+26p+VKgoHQgVLVcObZQohQh9PJfCflbThiZvwkY2H4Kme8J65nfCRjYzqrIvprIFTCj1COyDhq4JD8JGMqiZva/CQjrNmKuK0pz9M4LGjw7su4Yq58J64pDDwnri7w7ggVE7qpaV9wqXgv5DwkaS7CjMKBG5hbWUSK0Ip4KWBKi7vrL7wkbKN4aOD4aqkJzLwnZKi8JConycuIuGkoyQ6wqXgsYwKDwoJbmFtZXNwYWNlEgIIBAqTGroBjxoKiBkKB2NvbHVtbnMS/BiyAfgYCjZCNGDwkb2ALz3vv73CpfCQtJTwkJaU77+o4aKhL0BgLlEn4aajJvCepJDwkaa24KuELtGoT2AKDEIK6pmg4K6e4rStMwoGQgTwlqypChRCEiXwkZmn8JGkhmBs8J6Fh1xfPwoaQhjwkbKDXOG/ruCugifwkJOPP+Cti/CQqLoKIkIge/OghLA8w53wn5W0KvCeuZJoXCcq6qmDUGUl4LOpwqwKHkIcL1F1wqXRqOCvjPCbhLJCfCBJJMK18JG1p+C8hwobQhnhv6/hp6NJfidk8J65uSLwnri78Ja5lzpTCh1CG8i6PF1M15RP76y+YeqnkmJKJGnhi4RI4Y2ONgoIQgZcOlkqIiUKAkIACitCKfCQubvvrYE6Indi4KayeGAn4b6hTmMpKVzwkbWD8J6AlD3Iutev4by/ChxCGjxX44SqPWs8LvCQgK/vv45V4Y6ALzom4oG2CjRCMuC6iiHwkYyw6pSKe+qtqCRD8JGNsWriroNJyLrwnYWy8JCFvMOl4bKZ4bOCJMi6ItGoChFCD/CwgL5lbFzwkYO0Ve+/vQogQh5T3IZg8JCgiErgp53vv7174auHYER68JCmqCVmLyoKLkIsP3BAIjrLreGbjuKwsVgnI/CeuYcv8J2SvXsn6rOu8J65kS/qqpDgpqXvprQKMUIv4LeSPGBI8JGwiOGKusi64oOqOyRZLvCQoIhxLiVq8Jy8kPCflbRV4b+4du+ymiUKHkIcY/CWqaTwkZa7TOCnlz1+8Ja/oyLCpXR9IlxNJQoNQgvgt606UfCeuZ01Jwo5QjfwkIGM4Kme77ePOjrwlq2c8J2Umljgrr7wkK6uMVEl0ajwlJe/4bOX8J+vt/CQhKzIui5n4ZqqCh9CHSfwkIag8Jq/vV57wqXgrbDDjCTgrLZTOtGowqVgCjRCMvCRg4LgqpHhiKLwkpGy4K+yyLrgrqQlairhgoLgspA1e1RbIktc8JGNl8i6JuGngTxSCgtCCeGdg/CeuofDhQoEQgLRqAoCQgAKMUIvUdGo4aqXJuC1hyYzKfCdlInwn5W0L9GoNydcPy/wkKGD4b2EJns/Ji9ifOGJmyQKC0IJ8JGQk+CshXs6CidCJXPwkYOy8J2VjeCyi/CQgL3vv71PPPCeu7DqpaDwkbK2w6/qpaAKIEIeQ++ssNGoyLpcIiLIuiJH8J+VtD/gq5BHTXNUS3ZcCiJCIOGPvDo6OuCmnj9oVCbRqHt065mO77+u8J6Ao2AvyLpcCjNCMdaVP1bIusi6dlwv4ra78JCNgvCRm4LgprJ88JGWjCohSCUv4K+tyLp14KitLvCWqaAKKUInOOCpmfCQo69AIjpR77mRXCVA4K+KN8K2JiLwkKCTPPCRtqI6PGB0Ch1CG0DwkJuK4oCEYjpC4Kiw4bas4LK3Kj1U8JCAoQoUQhJsR/CWrJbwkZuD4LOGeuCnoW8KHUIb4bOme/CQsoPgpowu8JGnpO+3jyoi4KaLXMKlCiNCIVfIusKvOmDwkYSNLTsqafCeuaJ7YOC6ikTwnrmUXlFRPgonQiU86qiC8JGomvCflbRk4La94LOo4YuC8J+qk/Ceub7wnrqj4LSOCjhCNjThn6VcPCPwn5W0eyLvv70i8J+VtPCQj4p8PPCdmq5T8J+CjfCQrqp7TFvgooF7PdGo8JCWuQopQifwn5W08JuEsiIz8JCMoS45WOKRgyXqqb4iyLo8Jj3wn4ah4Yq+zbwKFkIU4ZyARlLgsLfgr5cv8J64ue+/vS4KJ0IlyLpkQMOAO8KyIiM0cfCQopUlez3wnrmkKi/wkL27yLo3JDwlJwo5QjfwkaeIYPCQqI4u8JG0hSbhjqfwkK2Nwrg64KeL77maVHzCpdWFL2Lfv++quzpTJD/CqWDgqLI8Cg1CC/Cflp9JJmLwraiFCiRCIj9oePCWv7En4Z+4KXJh8JC6hz3DpyLIuk3Cqi3wnoukRCoKBUIDOy8/CgJCAAotQit5UCdG8JGLsDrRqPCQi47wkbC58J65pD/IuuKElyp7Q+CxneCwo/CflbR7CjdCNX1U4LKON/CfqrZRyLrwlqyUPfCcvYThv4Jhd1AmKk/hiY0kaC4lwqU8JeGlqyTIuiZTyLpsCixCKvCfn6lY8JChtcKlZTw6UC0v8JCumXUv8J2duS49bvCeuILqpod7Z8OdJgoJQgdoLmDwnbyRCgZCBO+slzwKNUIz4aqtJ+C2veCwsvCdvJpPwqVv4Y+z77+9OmIme8KlffCfh6bWj++vkzzvt4/vuanvroMkCg9CDfCRpKl30ah38J65h3MKAkIACi9CLWbwkYGn4LGVLvCfg4dnbkXgtr3gu4vqvZHwkL27w6E9IyI8yLrwnrmbZMKlegogQh5mPG5EVi8zfcO68J65myLwkamcUjNyM/CRkZ3vv70KBkIEJSTYjQoJQgfvv73wkIuQChVCE/CRtJPwkb2M8Ja/oi9qRiY8ai0KKkIoPeCgsi90XvCdqps98JC5qPCTkYngsZbvv71ISk/gsK46JeCwgmBNSQorQinwn5W0J2p84bOZPGnvv73hlqM/bPCdjbRp4K2wcDzwkY2IJ/CQtJwvOgotQit78J2LsFx98J+vsEYh8JGcmlzwkaizw5prRnBxyLokKmsq8Jatnnlg4Y6wCilCJ1vgq4fCpWjvv70uQfCeuLsnYeCnl/CRpqHwnp+pNW/wnrmX4KaJPAoKQgh2bfCfiII8ewoiQiAkKkh7wqUmw7JeX/CRg5zwn4mDfuCmjOKCmOC3lDwiLgowQi7CpUJwXvCeuZtWIjzwkKqZZTok8J+JgTzRqGAvL0fwkbGEWmDvvbLIuuK2tFc/ChhCFsKlXi8m77+94KeHTy/jhLQvefCRgYAKLUIrJMi6IiRr8J+VtCpc8JuInUAiZMi6XC/wkYGBRfCfq5PguoEh8J+JkMi6YAogQh50Ju+/vfCRmJRu8Jq/uz3wn5W00ajhvZnqq7PgsI4KGkIYIvCRmLg8PVxcPS7wm4OK8J+htPCbhZBRChRCEvCeuY3wkK2awqXquI/IusO2RQoOQgzhnKR78Ja8qvCdkr4KOEI20ajwmLSEW/CWv6LwkKCIa8i6w68l77+9cj974K6V8J67sfCQuaXwn5W0wqDhnapc4K+mJyY/CihCJi/gr43CpcKm8J2UiHQ6N++/ve+/vVJmw77wnrik4aeawqXwkJ6eCgJCAAoXQhXVjCfwnrmfKi7Wq8Ki4ayb8JCkv0YKCUIHXPCRsqwlKgoZQhckyLrwkK2y8J2Ql2DhjJXiirPCuu+/vQoPQg1V4KiQ8J6Ko2DhjolXCi1CK31bP1FgwqpZPOC/muKBk0Twn5W08J2Su0jgsZlx8J65gi7wnYSP4K+GMy4KFEIS4rWjwqXCpSLIumPwn6CRN9ezCidCJS4mLSrhpKDiuLslw4F78J+bvOCzgUfwnrmkYuCupNGo8JChjCQKLkIs8JGwhC5gyLrCpdGoOuqhjCJ78JCWoeqgueK1r/CQnoDwnZKe77+90ahAKy8KK0Ip8JCTpfCcvJxgXVwuKsi68JG9h/CRvrDhvJxVJ/CQq57grZ/wn4KIJHcKKUIn8J+VtG7CoOG9jOOFgvCRjY0z6JOPwqV18J+VtOCpkeCrkPCsjolvCgJCAAoeQhxn8J2Vj1x7JUclyLrIuvCfoqEq8JG1qCLCuMO7CjdCNfCQgKYuV+qgsCImP1XwnaCoUCXwnYuJJz8lcjrCpVx74LqKXOCxmci6wqVcKu+sk2DwkICBCiRCIvCRhqQ68Ja/sCou4r6rXCTCpfCRsoVxJS8lXDVV4YerPCQKJEIi8J+VtOG9rvCQlpUlY3dxeybgt6jwkIC50ajhvYhS77+9LAoHQgU9KmBvUQoMQgolJkU84aCRwqV7Ch9CHTkuPcK30ajgqpA78Ja/oC4l8JCYrkrvv73CuTxCCi5CLCUnJS/gq4FcPMi6djrgt5HwnZWGMMKmwqUi4LCYUSp+J8Kl4LSOYFzwnrinCjJCMD/wn6CxXHVj4aS5Xkzvv71TZy9c8JGygzTDpVE/4K6yL21gUS58OuCogS4v8JGnnQo4QjYl8JuymcKl3LLCpVTwkLS4Li7wkKCIfl0qUPCRnKZ877+M4b+r8JCKgvCfoZNOKm3wkKenJDoKOUI3JPCeuLt78J64jVg7NPCRiojwm7Kf8JKQiPCen61S8J2UsPCegKN7Z+CmtyVz8Jars0FRJuC2ggoJQgdl4LOy4b+9CkEKBG5hbWUSOUI3J+Gds3vwkJ2RZt+zNW/wn6uOXOKFvSIiOvCRiJzwkY2fVeG9nequnFIk8J+JoiI2Oj11VOGbsAo/CgluYW1lc3BhY2USMkIw8Jq/seCqgUvwm4WVN+CuiMKlNlrRqCfwkKiMOnpD8JGTkTppa/CQv67qr7TwkaS9CqUEugGhBAriAwoHY29sdW1ucxLWA7IB0gMKI0Ih8JCSiy5cQsOle/CRprlcJcKsfHs6OtGoJeK0rci6J3tECh5CHHsqLvCRsZ3hi5Hwq62IM/CegalhPPCeuqY9P3sKIUIfY0LvrLHwkJKSKci6VeCqs/CWqYUn8JGws/CfqaM/aAoHQgU68J+rpwpAQj4uJfCQqYEiJjzwl7qT8J+Cqy/wkYyu4aSgL+G/utGoLijgoI3vv73CpV0qPy8i4oOg4Ym14KiTyLrwlr+wWQoHQgXwnrm+JAojQiHhspQm8JCAuu+svvCRpL4m8J2ShS4777+90agkL+Covj4KOEI2P/Cfm7kncDThnYfguoFf8J+YjCXwkKmuW+C7kNiN8JuEi/Cdk5fwkJOe8JGQuH4v77+94KuECgZCBMi6OScKFUITNSc7w5R08J65l0HwkY2q8J+VtAoIQgbguqrgtJAKGkIY8J+VtPCQj5I68J+gnOCxp3om4Ki54KmZCj1COyrOjOCznSYqSC5gI8KxSDXhqI7wkYeVe3vvuKEq8JKQjWbigING8Juyn1PCpfCQqKRyw7bwkJaq4LeUCjFCL/CRmpYj2KvgrLbwnoGb8J2UtETwnrmLLirwkYyGeeK6gPCfqaF74LWiwqXIuiQuCikKBG5hbWUSIUIf8K2WlHZVOvCRhZHRqDpyNyZC8J+VtMKlPFHwkKeaJgoPCgluYW1lc3BhY2USAggECscRugHDEQr2EAoHY29sdW1ucxLqELIB5hAKPkI88JG8j2fit41VTvCdlJ8n4Ky+JOGQuci6SCLhi4NrwqnVuvCfqq1JTUjwlr6X2I7vuoXwlqmj4LON44e/CjlCN+C6hsKlNPCflbTCpeC6gi5WJuK7peC6r2dN8J+VtGZgyLo68JGkg0ghKvCwq4fRqCYnJ8i6dT8KBUIDOtGoCgxCCuCrvnkn8JCysCIKMEIueyzwkbuhXPCeua50PGdLPyEv77+Dd++/veCvgfCRnYNDLmjwkaWX8J+VtFcuTworQingtrMwOsOA4KyZLi/IuvCRnLIm4KmzwqLgpp3vrII/w6cq8J6EgGNhZAo4QjbwkZyje/CfoZRaY33wnZSK8JGnknAkYD0/8JaugsKl4ZulePCflbTwkbS6PzbwnYuRP2A8anIKNEIyyLovXSY98J64pPCRgqY/LiZFwqU3QDwsey8/SD0i4rSt8JCOmGcma8K1O2DIuvCQpL8KLkIsSMi64bOgQsi6IvCRp5xA0aglJC9g4KmAIuC3imDqqYZ32ZrCpVzwmr+6LycKCEIGcSk/JcO9Ci5CLOC0iDrwnoGeLGTIukM/4rqK4ra58JCQinvgoYY/XNGoWz3hjYLvv70nLi4lCgpCCD8xyLrit5UkCg1CC0nwnZ6GwqXwlqm3CkBCPkE64bCBw4DwkbKqIiTit4vwkICKO8i6UTY9J3o2zozwkZiASfCQq5wi8JCTquaHp/Cfq5s94q6LLkrwkJaUCgVCAyI/bAoPQg3jhJMk8J+VtPCRioElCitCKfCbiK4iOtGoyLo9w4FR4LemwrFQYO+tgfCdvJ7gsaA/77eP8J+IoyQkChFCDz8wU+CnnEQvw7Pwn6CFNQoCQgAKIEIeKvCRl4vDvmvwnZKi8J6ApOCmoeGdslZm0ajwkbu2Cg5CDPCeuYvCpW0qQHY8JgodQhvwkYeb4KeI8JC6rT0udeCtnOCumnYgP3DgsYEKQEI+8KOqhj/hvYl24KyyTk8mdntS8J+VtNGoJGDwkIGd4LqIOuOBr3zIuvCeuKd5bj7ivaJawq7wkYS34oKrNWAKAkIACixCKidvTuK0rSRgdvCflbR1KvCRhKTvv73Iui7wnLywRURc4Lee8J67sH0lewo8Qjpx8JCUgXsn8JCklWAh8J65u/CesprwkKGg8J+VtPCeurd+yLrgqLjgt7TguoJTUWA9XHJa4rWvIjY6CitCKSsnPGDis7/wm4Wlb8OzSeKAsu+/veG9mXJ3OiLRqHPwnoCjUOGklC8nCg5CDPCeoavhv7LwkK6qewoYQhbwn5W0MC/vv5rwk5GG8J+vuPCeuYcuCgJCAAoMQgotY2U7LnlQ4K2XCiZCJD1r4K+Q7Z+pJyQ9J2DgrIzCpSU6LyY67Z+QL+CosvCQurF7ewokQiLwkYyq8J6lkDwiW/CRjY3wkICi4YmQ4L6W8J+VtFAn76qdCglCB3sie2XCuj0KEkIQOvCWvb5nwqVEePCflbRFYAoVQhNFIjV40ajCr/CflbTOlci64aylCgRCAmA8ChNCEeC7huGSkfCRo67igbFcIyo8CkdCRThW4K+58JGysG/wkYyzVeChkiFbKuGxgHsi8J6AnMOHJfCeuYs7bHjwn5W08JGKjfCQipTDlCLwkbaQ8JGHiz8w8J6EuQoOQgzRqHskOifwkayDPV0KBUIDaCQmCjVCM1sm4Ka4M3x7OUPwnZSKKklgOiLwm7G8LVxl8J65pPCRnIDwn5W02ot3JPCvoJzRqOCxnQojQiEi8JCPjEZNVdGoJe+/vdGo4aCsP/CRtacqZ1h1fvCfgr4KJEIiRnQ68Jy+pllga2fwkYu2WT0q77+977+977+9TfCeuapgegoRQg/hs7kqJUzwkbaRQ+Cvl3QKIUIf8JCUkCLhnLLwkISW44ieMPCRpLRgJPCeuIHwk5GFJQoVQhPwkYerJMKlLPCQlpU9wqfgqpNgCgpCCPCeuY1I4L2rCj5CPOCxgDPvv6bCpT3IuuCwllA+XPCfgYDwnqWZOkvwn5W0a+C7hvCRsKbgroVz4LeSXuCokGrDmmDwnZK7LAoTQhEi4K6zYOqbqHDCpe+/vd+4ZwoRQg86Jz7Cpe+/vWDwkK241YwKNUIz77iZ4rmPNuCrv8O9QDxg8J2UsnsuTS49KTrwn5+l8JCrjCY04Z+yPznIukDDiUDwkb2DChdCFSp6JfCRg5deXjbwkJaV8J64qylqPAoDQgFZCgpCCFFbOuqjlD86CgRCAsKlCiRCIvCQtLUl4aeCPDrCpTpg8JGpsT06JiYmbDrDnVxfSTV3JWMKL0It4L+I77+96q+48J64rXvwq7SOyLoke20u8J2Lg28l0ajhnaRY4Kmm8JGYtci6Ch1CG8i64aSi8J6jke+shlBL8JGBsyrwnZ2S8JG+sAo7QjklNdGoXfCflbQu8JCToisk77+9NPCav7t68J65i+GpmyQqMfCRtKTgsZ0n0agv8JGRnuC0jOCmsnsKR0JFYF5leOC8tvCRioxC6p+R8Juxu/CkpYnwkaeaV+GOgvCbsoNKw6zwn4emK/CbiYPwn6+zYC9wQfCfgq7DtyDCuyZY0ag6CkhCRi9v8JCikC7graFg8JuAgvCflbRg8JGThUHwkLKbP+qknS4ie+Cgs/CflbRu8JC5o8Kh8JGFhDrRqOK1r8OoIVfRqPCRhLoKLUIr4Z2v4oOXXEQi8J6fqE4nOnjwkYyVIiUmIsONUnjIuuCtljxQPO+/veK0pwo1QjPRqHc38J6FjibgprZnIm5uPT/gs7LwkbyA8JuxuuC3rE9i77+9KkjqrKpeOibIuvCxtKEKIUIf3Iziv7Hwn4miKEc/yLpvOUEr4Ki5ODzwkICK8J+VtAo3CgRuYW1lEi9CLe+onCIk8J+DluCpjPCRgaNG8J+htuC6hO+9iXPwn5W08JCeufCfqoHCokVMKQoPCgluYW1lc3BhY2USAggECvAQugHsEAq7EAoHY29sdW1ucxKvELIBqxAKKkIoJ3vhoLd7XFPCpfCRnIfgqL7IusKl8JORgy568J+VtPCRtb83w6HDkAofQh3hi4AvYicnOGA6YCbjgL86e8KlJ3tVMTEq8J2VggodQhvqk4HgoLR7WvCQqatc8J+qhj8lJCXwkbK2JioKD0INX0rwmr+98JGopuGfoAojQiE/8JCuheChvOCxrzw/8JG0vDfgrI/wnrm777+9OiY6wrAKM0Ix77+98Jy8qOCotTrgt5PDrCVtVSVDTSXwkYyA4aqGY/Cen7nNvfCQnoDitLY/KcOraQoPQg0q4LWIJz/wn5W04KanCjNCMSrwnLyz76ysL/CflbTgpqpcIuCnjfCdh54hyLo94LWb8J66jjXIuvCflbR7S3tcZCwKKkIo4a68JDx1yLokWcOMbCfwnZOyYyLgrZc8P2hl8JGgoci6Ti/wkbSISQooQiZeJ+CnoSR7fj/wkJ2A8Jarl/CWqaM8J+K2oPCQs6LwnqC48J2SqgooQibjhK/CpUfvrIVLWNGo8JG8pypcM/CflbRcP8KlKmQ9LS5LJC8/RwoSQhBWOFjwkZecOTrwnrqn4ae/CkdCReCnncKlWtGoQTY+JfCflbTwn5W04reB8JCpviAm8J2NlvCQoIE877+9YFonJXdb8J+VtOCznmDvv73CpSrwkLyO8JatpwoCQgAKOEI2ey46JyfwkIqv8J2Emci6TXXhi6dc4KKnYDrwn5W08JGoqifwm7KHw7h6PO+2ki9SKvCWq4JpCj1CO/CRjI/IuiTCpfCfp5Thn6jwnZKf8JC6sMi64K6kLCbwnrihWPCQiorwm4GsNkrwkKGUeHlNbOGwpi0nCj5CPOCunuK2qCdwPeCss/CRm4RZLuqtv9Go4Kei8J+bgeKCrGBUJe2fsz190ahy6qSQYT074LqJ4aqX8J65hwocQhrwn5W0P++/vT/wsoK0cTTgrpkk8JGEl1lvJQoOQgxoJ8i6TyFHwqXgvaYKK0Ip8J28nPCeuYJg77+98JCiqWQk0ahTIlEiLj9WdT9x8J+VtCXwkLCtLnkKJ0IlYCon8JGDsTJS4rSO4KuQ44mDSPCeuYfhvZtAWFw84bie4bKIPworQilcLfCRjIFgai8uP1tgPzJiwr3RqM6MJCrDiyd58J2WgPCdk5co8JuFlQouQizrnZ/wnri5wqXhi5Pgv4/vv73wkaSJ4K6+JSLCpfCdlYFjKmDDlCJp8J64oQocQhpyKkPwn6C9eypz77+98JG0vcKlImo/LuGytAokQiJWRi49IuCsiGDCtEIiUdGoXnXwn5W08J65p+ODs9Go6qmSCglCByR7WeCzhHcKPUI78J+bqOKRgiXCpfCYtIhPYPCRjKo0IvCRjLc/JOOCieK2q+C6hvCdk4F7JfCRg4F24oCJXDfwkKexL1kKH0Id8J2No/CeuqHgq7rhp7It77+94Z2BIlxHd+GckCUKHEIa4Kqy77+94rapOvCRgabwn6GQ8JCOhsOiJFsKMkIwJWngrqR9XCbwkYWadvCflbQ/77+9RlnwkbGE44eA8J6Cj/CesqbYiuGmsTtlN0YmCh5CHOqfkHY80ahS8JGckdGoeWvvv70v4oCFJy4/ey4KHkIc4LaI4KuuPe+/vSLCpfCRioh4J++/hfCeu7EvLgofQh3wkpG0JvCdvKd74rauP8i6LyVt6qCdSvCflbTIugo6Qjjwl6GZ77+98J+VtC/wkYOyJyQmwqrIulkiKi7wkYuwOiYi8JGklfCQiqQ/JuG9jDkqdNGo77+9NwoSQhDwnp+5JzjwkLCbNVDguoR1CgdCBWbwlr+xCiRCIvCeo5Yv6qeSWjXvv73ho4x20ajwnYeE8JatlirjgILhv4wKE0IR77+98JuAqvCRtIHwn6+0wqUKCEIGKvCehYYiCgtCCfCWppTwn5W0cwoCQgAKLkIsSCrgt4Eu4oS0YE3RqGHRqF1J8JCEnOGJmPCen6RNVOCkgCZkKivVrvCeu7AKEUIPJyXwnrmH8J6Lv+CxnV0lCjVCMzxi8JG0gfCeuZFbYuCqilxZQU3wkIStIGXwkYuxbTBq4KiB4Zqw4YmK4LeDe0nwn4OIXAocQhpcJeG3iuCunnEmVCfwn5+wJyo9RPCehLx9MwoeQhwrJSbCpeC7jS8na86JIk7hv6c84KmRNyTwm7CiCjtCOeG6t3tmIn5P8J64p+CpmfCSlKs94LOeaCw/Li7wkYqAPzTwlq2VJzJ7SPCRtLo64Z2BwqUnPO+/vQoHQgUt4K6IIgo8QjomWiXwn4mR8J65pPCQp6Aj8J6kjTJr4LS78JGshfCbsbvhpYDwkbSI4LuK8J65nfCespbwnZK7RiVUChBCDu+/vfCRpYViP9GoZmA/CjJCMFBgXFTwsbCu8J+hkPCRtIHwnrm2OsKl8JCKj+CnhzEvL/CflbThiofwkr6m8J+JoAoTQhHwn4iX8JCCrOGfkvCfiKBveQoeQhwm6p+RwqU88J+fsHtJ8J65mXPgvr9B8JCSjzx7ChZCFPCflbTwnYikLyI/UcOP8JCPjyQqCipCKCIpWuCpjFzIui/grK7tmqLhn7I/JvCRm4nwn5W08J+VtDzvv715LVgKHEIaJuCpniYv4Yq9Uy5BwqUwJiXRqPCRqJYifFMKAkIAChtCGWA/XNGo0ah9O++/veCvitGoKiZA8J2UmjoKRkJE8JGKm+OHo/Cdi43itYo7wqU96oyz8J6ln/CdkqXqrKDwnrik8J67sWBWQ+GkpDwlOs+d4Lqv77+94oCK4K2ccjIkJkgKGwoEbmFtZRITQhHgs5Z58JSRhjw9N+KPouG/twoPCgluYW1lc3BhY2USAggECoYYugGCGArdFwoHY29sdW1ucxLRF7IBzRcKJEIiyLo977eCflwiYHvcpmMk8J6FgNGoRC/itqjwnrikPc2/ewo5QjfZnVwu8JCVsS4kKDpp8JCHqSfwnZSI4YqeMV898JGyqT1fJdiLNvCdi4kl4oOeX3ciyLrwkI2EChZCFPCeuZl28J6Tk/Cfq5TwnoCkYSJfChFCD2EuYOGKrvCQqIYr8J2XhAolQiPvv71aw5Z6eEPwkbS88JCTqNuq0ajCpfCdlLJTwqs6XDovLgoKQgjwkpGy8Jy8sgofQh1FO/CdlInhvbdO8J65qCJq4Zq/8J+nryY4MiYlJAonQiUu77+94KqJ4rKIeEpH4b+L6qui0ajCpfCeuZfhv7LigqLwn4OECjtCOSJF8JGMuT5MOn09PydtcHvwkI22wqUvwqVxXPCQgKBr8JCTrENt8JG/p/CRjZ7wkYqIw4bCtMeXSgoHQgU8JuCnvgoCQgAKMUIv8JGSuHt41o3DgScoQ1wlPD/RqPCeuZTCpfCehLHCpuqgtDPwq56R8JGDlvCQrpkKE0IRw4ZoyLo/RFjgtYdvI/CQurAKH0IdyLpQw5fiq5I8Ki8i4aeYRDhiJvCegKAlTmLqn5MKJUIj8J6fqC8u8JatqlzCpfCRtIA8Pyrig5F88J+ho/CeuKJeIj0KLUIr8J65uyXCpWzwkb+GcUsqw7JoJPCRjYck4Z6Vw5bvrYPwm7KcwqXIuj1iVworQikq4KaQ4rSnInHvrJM2P1zwmK2x8J65vvCRnJA68JuFleG9mS8nUyY8ewoVQhPwkZydIiLIumAxNyIhPPCeuZcvCkVCQ1Xvv73wk4WbyLom6qS6c+GoifCfhaUxdeCskDrwkZmk8J65u/CRpqbCpXxi4Kmc8JaknMi6P2fwnoqUSjU/4KmAMSQKF0IVYPCdnLvwkY2Q8J2VjOCwtuKCpSVBCidCJXXhv7c8N+qahSXgprLwkI+Uwr0n4YyTXyXwkaaga+CzjPCfoIoKKkIofuCrkH7gvL3wkKC4Pzwi6qGoSCZc76y+4LG58JG/peqsizE98JC8gAooQibwkpSQLmYpYC7vrJVO8JGKiGBgfD1gfOCzh2DwkY2QYC8vKlxaOQoRQg/wn5W0XOGfkGB18J2IjyYKG0IZ4LGh0agmQ2Y1TlzwnaqbPF588J+VtHAgbQoUQhJdYS4/Ki5dfuCwkDpjLvCdk4AKB0IF4YmTPCYKIEIe4Kmn4bGEQfCRjYwm4LCMKkPhpp7gqY0/ITpJYM6HCg1CC3Tvv73vrL4tL8i6Ch9CHSHgqYfwn5W0XOCmn+C2jmxW4b2L8J+brCrwkI6XCipCKOC3mzwuLyovfu+3j3E/QGBT0ajgrbfCpFwmKmA98JCohnTwkY2z3JIKMkIw8J+qvGAkJCTgp7TqoIjgu54qTeC3ivCfn7BceT928JCWuzLDr/CQjblQXyfvv705ChlCF/CRsoDgrLx4061eLjxKwqIk1bg24YeoCjJCMPCYqbzgurImLik68JCilSVc8J2hrO+qjyckXzolR+KCo8KlIuK/u3ki1rzCr+K/uQoGQgTwnqOQCgNCAWIKH0Ide2Dhvr1tdi7wnp+pKiXwkI+DdzogUPCRjaZJVG8KCUIHJTxc8JCWiQpCQkDqkr7wn5W0yLok77+LLsOe8Jaqo/CQqKcqNvCQlrslIVDIuuC2ryLwnLy0T/CRpJMl6qyuQ+K2oUI2PPCQuqUxCjlCN/CdkqJc8JGklvCdkqXvv4Ng8JGDtuGrgyIiee+/vfCWrZbqoqTit5hnUHsoW2Bw8J+pu2RtJEEKT0JN77+9L2DwnZSH6qmHK/CWq7JxNPCeuIHgqanwnrSo8JCBlXnwn5W0PC7wkaSJQmDiuo0nL/CQv6A/77+98J6jiDnwkbGF4LOxyLrgtYcKEUIPyLovdfCfqbsi77+9IiQqCihCJmhPJCDvv73UqPCRg6TCplDwmr++8JGLsuG/sjpsRvCRpLjwkJaQCixCKiZbeD0le0wn8J+DrCQy8JasmMi68JCjpSjvv457Y+qfk1IndCoo4KeIKgomQiTwkYKp8JGKhnEnU+GkqUUkMPCRtaNGLSrIunHwkKmHwqUyOlQKGkIYdPCQp4zvv7024aqD0ahgWn3grbAuYMK6CgZCBPCRpIkKK0IpYCRCdsi677ex8JORjyVD8J65lOG+n3NIJPCSlYM88JGMgfCRvrAmfSEKBEICSyQKIkIgwqXwm4Syw41n8JGRny7wkKC8SOG9qMi68J+ghPCeuo0KFEIS8J+VtOCumSngqq/itqoq77ePChxCGu+3uPCflbTwkYyC6qmLwqklLyfgs6bwkKa8CjdCNTxePCvwn6u1LmBXOkNA8Jars3Dwnrm+PfCRjbHIuuCuvi7jhLY88JG0r0Tgs5VWyLp14bObCkVCQyXwkY2w4rSn4KaM8JGklnk9RvCRjIHwn5W03I0i8J2MuTp58JCokOqlrNGoJXw6LtGo8J64teGIq9mX8JGwsD3gqrMKREJC8JGmpPCeuZvwlr2ZR+GJmPCdi4FeOuqvm/Cesbs9aC7wkb2L0ahqwrbqnZREw5LIuu+/vSUyeyI7e/CdjaQl77+9CjlCN++3j0JvLjzgqLZj4LqIX+GDh/CfnLQv8JK+q+KDqeGJmMi6J/CUk77gq7pJ8JG/r0TRqDR3JSIKQkJAZS/gsrfwkaKt8JCojzo98JCopOClk07wlr+x0ag9JkgtyLrgrYTwkbS60ag6e/Cfq7XwnoS5UvCQi6PwkbSFLgohQh/wlq2z4Z2u8J+bsllIXOCuv/CRkZ7hoJTwn4OV6qyjCj1COy7wn4Ok4KqPLzNr8JG2l/CfqbRNwqVJ4KmRJsKlPdGo8J2HhDwl8JG1seCtiDzwkbS6JfCcvrFr77+8Cj9CPeCss8KlPyon4KejMfCRjJov4LyG4Y2n8Ji0hlzCpSdgYCvwnrmxw6zcqO+8pWviroYlW3Xqp7NH64i0IlwKGEIWZEVl77+9UD/vv73Cpz570ajitYUlLQoyQjDjgoVn4KmBYfCQqIzqn5HCpfCdkrbwkJW28JCukPCfg4o8PMOY8J6Aoe+/vXtPbkAKF0IV4K6I4KmB77+S8J+phfCxqozwkJa7CjdCNfCflbTgt4AnZSTwnri2avCQrbAiOn5c8JG+sPCen6QiZTfwkY2mdvCTkZU/8JColzkvXtWWCi1CK2Yq8JGIh9Go8JGkqfCfq5Lwn6mlSuGJkvCRjJvRqPCeua88Ki8me/CRgr4KFEIS4ra7WX1c8J6frfCQoIHwn5W0CgpCCGMqXSF84b+HCgtCCfCflbTwn6GxIgoCQgAKCEIG4Kqg76yFCkNCQfCRvYVa8JGgmsK78J66jXNg4LGH8JapiOGck+Csr1jitKcn8JGlgWYlXGnhg4fVpfCeu7BE77+F8JGyrlrRqDwkChFCDz99IUdQ4K+XwqUnwq4lNwoeQhzIuiY60agke2Yv4L+J8JGmoznRqNGoOyLwkaiuCjFCL1Vcb/CdvJgn4LOKP0hYKiLwkYCHblwlyLrRqEjwnZOBISU877+98J+VtF0kPUM8CipCKC8rT/CRhIXhqqskKsO+Wsi6RvCRio8zMsOWVk5Aw6bwnrmC8J64oScKKkIocuGfsCZjJyRmKuG/s8KlPvCRl4wmP/CfiKnwn6GY8J65tE5c8JG8jAoEQgLRqAoJQgfhj4zwkaazCg1CCzouPFzDhDPwn5W0CjVCM+C6sz9oLjw/OjxmaWHgu5Nv8J+VtMKlL/CeuKTimaXwnqWSJci6w7Hwkb6wfnsq8J66hwovQi0yJGkqQCLwkb6w0ajCv+GKvVA/TE/vv71gP9Go77+94oeU4YqGJOG9s3ZYbikKCkIIw4nwkYqKTi4KP0I98JC0gj8n8J+VtFzwkYqIPlMlPPCflbTRqCQ88J+VtDkmwqXgqLPgrKzwkaSW77+9wqVu8LGymDzigLTNuwovQi0n4K6qwqVwKm1cLsKlKjDwkJKCfHDhvLRgPfCRjYzvuJgqe2xP8J60kcKldUoKDwoEbmFtZRIHQgXgrpo9JAoPCgluYW1lc3BhY2USAggECvcaugHzGgr5GQoHY29sdW1ucxLtGbIB6RkKH0IdPGDwn5W0Jz/vv7168JOOqPCehIbwn5W08J6FiH4KPUI7du+sseGyr8Kq44SQQTLwkKGA8JGDoTrgrpw9wqxW4aWA8JCunCfwkZmnLeCxoeCoj0Ii8J2ToeOIhyoKMEIu4LKWPMKl8J2SpvCQkqnRqMK0IjjgsorgrLU0Z/CflbTvv73gu5Lwk4618JarnwocQho9NmDCpSJLcfCcvrThsL1LVfCeuYnvv717XgoKQghc8JGZqlw8fgorQilI4Ki1JC7wnp+uP/CegJY9e9GoLuCmj0ok258kwqXgqIF8Pzw9P++knwoGQgTwkr6VCjRCMibwnrmNOjhEKvCgjqcnITTwlr+wJPCQlYLgu4bwnri0RWzgrY3gsoQqUUQqbHt4OS8/CjxCOjwu4La9R++tnGfwnqWe4K6ZOjzwkaWFfOCvl+ChpuK/tyTwnqWDPipcVPCfhqotYifCuOCqsvCdlLkKH0IdffCfiK5g4rStw6VWYsK6PUs34LWhL++qrWHgqqoKHkIcPTjgo6N2aiouPC7itbBA4La9cmfqn5l0XDp+KQoDQgEuChFCD8i6b/CfoIHhjrgq8J+rlAoiQiDhia3gtJXgpo/wn6mlU2DgqrJ7JC5mJng4WPCegKjDugoRQg8mN8i6LvCRpLU64KCCwqUKK0Ip8J+eg1w8cvCWq7V1JT7wn5W0ej3DkiTwnqOWN9Go4bC88JGklS8/w64KL0ItRiLwkbWle/CRtaXwkaSJXNGoWTdAOfCQgJrwm4eC8JColcO78J2SvzTwkom+ChpCGFoiayVg8JGqglBc8JGjkC7RqCXwnZS2aQoTQhHXsTrwkKOsPG7vv70g4KecXAosQirwnoCpNSrvv73wkbCoQFfRqCbCoX1+R+Crvjrwn5W04LGawqV28J2Sql8KO0I58J+VtGAq4LifLifwkZi/8JCBhGNxNdGo6qyK8JGNgirvv73CvCrhn7JtQ+OIkiLwkbCAaHti4ZCRCkRCQtGo8JGbgmU8JS0rPyxzbSfgqLguLy/wkLqwyLrwnruw6qyJ8J2SqmAl8JatgfCWvpLhopg6L+qpieGyveC/me+/vQooQibhn6TimqhX8JuygSZU4b+QMvCrg7HhvZvwkI2nOmAu77+98Ji0hgogQh7qooTwkKOnw53wkZKRPfCQq6Q/IuGnsVjvv73gt5kKCUIHP084UsO3YwopQicjIi9h4KqR8JGklcOP8JCnl+CxmXsk4a2RdfCdhqfwkIGSO/CRloUKDkIMLzxn8JGMiSUmKDxWCgZCBMi61rkKQUI/Zzxs4LCCJvCRjZfDoi/wm7Kc8J65ofCQnaV3P+GJmOCziDnhv5vgqLzwkKyQ4KaLXMi6IvCdkqLgrLPwn5W0ChtCGcOsPfCdqp3grrlg8JC/i0fqoI898J+punYKNUIzYuCsici6fSQiw4okM8i6Oi5BPTzDh/CQpK804Ky9YyRXclZtKvCfgJ0i8J6jldGoOsKlCjJCMFrgrrDDjjHwnrqxXD3Dt+CzrEfwnqWR0ahCWFTgsZ1KVVThj4sv1o7wlquz44WsIgokQiLCufCfnIxg4K6kPWBKYyfvv70nUHs+4rmFIsKldXrwkJ6TCjZCNETgsrUkJiZmPz0m4bCyNeGcjHLIuj0l8J+rpuG9m+C0gmtc8JCKl/CXnaVgIuG/q/CQrbgKHUIbK8OqYCrgp4NzOXvwkYuxe/CRpI3wn4epVMK8Cg1CC1lze/Crnox7IS9uCg9CDcOGfT048J65n3fhv5sKBEICJ08KKEIm4rex8JuBmC/RqC/hv7InfSV7wqUm4b2dyLo9L2B7VeChi+CovDYKQUI/4Z2NKuKCv+G9nfCQoIjCpSIvYOGomCLWiScx4bGG0ahJ77+976yi77+9eNev8JuCkmHwoLWqe8KvbFvIunBeCjBCLi91wqXwlqyOL03gs7NEOiIw76aIKjpgdUA5eHvhg4cne2DgrrVc8J6ftvCdhKEKGUIX8Jy8gn4nJOCsvEbhg407IGFt8J+HqkEKFUIT8J2VhteE4rqMJC/gqp894La9NApDQkE54rag4KiPPOG+r++/vfCRtaAv77+9dvCRl47RqOK2rPCQoqvCvyYq4LOH4oC8yLrwn6qIP9GoXvCQj43igbBcJgogQh4mIu+4i8O2NXpde1svYFzwkKKq4aGL8JGXhmXvuZoKG0IZRGA/4KqzIyfwm7KeL1wi8JarhV1rJMi6MgosQirRqDXRqD3qo4UqJ/Cen6PihIjwkJSZ4KmeLvCRu63jgqZg8JGiv+CnjjYKQUI/8JC6qy/hqoQtQToq8JGZovCRi7lS8J2DsvCdha7vv73gt4Xvv7178JGFgMOH0ahgOvCfm6rwkZuG4Y6m4YqyCitCKeCovOqfkfCflbQ94bysIy5zSuC0p3sj0ajqrILwkZmT4LK26qyK4YONChZCFO2etyfguoI6VfCeuZnCpci6JtaWCj5CPGDRqPCfgbbhsYZi4LSO4aeT8J+iqD3wkYCcSzo7wqVGKu+/veGppX7vv73wn5W04YmMwr0l4ay5MEpXLAoQQg4nbDwq4reE4b6O8JGkgQoxQi9z8J+VtPCRg7Mm8JG1heK6jeC2gfCeuIjir6rgt5nhrqMzP3bwr6ea6qG1RuCkvQoFQgM/yLoKNEIy4LqCdfCflbQuYSTwkaCtRzsiYybRqCVQKn3hiZFgVHVcyLp34b2JQeCouCXgu4ZcNioKS0JJL/CQkrlE8JGwhPCQmaB08JGxg+K1k++/vSci4KiI8Jq/ulPqoYZP4Yy28JG+sMOX7Z+EIj9g8JGNkPCeuYvwn4Ky0ajwn4mRKgo3QjXqooc/XOCmhfCdnb5PPeCpsfCRgqrgrKov4rOQOvCdk6TCpeGJpnA9bXFr8JGKiGBsIuK1sAo1QjMuOkklL8KlPfCbspXhqb8l4YmkJ3vwkYO2yLrjg6/hna7wnbym8JC+tsOlTPCav7PDglgKPkI8es67KjzwnqWTfPCRjLngp5zwkLKNbF3IusKxe3nwnrmx8J6foibit5ptPOGdsnvwkbWn77+9w6NTYCU9CjNCMWl0XEQiaO+4r8i6W+C7jXvwlquGXDh7wqVXJzg38JGNizZc8J6Apnk8UTfwn6KSwqUKE0IRfjoua0guNi8neyLwkI22KSYKHUIbUjRCb/CRnLzwk4GQJvCQsIEm4b2ZXOCpnmBcCidCJSZPPSXRqDDRqPCflbTwnZOTJ3thwqU8Pci6RSHIuuG/jPCWuYkKDkIMwqU6PSXwnbyq4LebCjNCMUknTzzwn5W0LvCfqabwn5W04LGv4bOCRdGoOlY/LiYl4aGeT+CrjOC7lOCpke+/kkkKLkIsOidy77+9PfCQrK/gtIEiXPCQkqFVXfCRjI8x8J65ke+5ofCQipZgUvCQq58KGEIWJuCph+Cvl0/wkYqP4aWM8J2UuFomcgoPQg3gu4bwkJWvIC454b64CkFCP/CRi7HIuvCQv6B7JvCQoLjDt/CWuo/gqoXqrKTwnoqt8J6Cj++/vcKlRyZc8JGZqDAudkzwkb6wZjk6yLpsYAoNQgsveypc4YmMPEfDvworQik9LvCdkIwn6qy/JXvhiZhk4L6h4oCiyLovZXkqJi/wkYqL77+9NUtnKgoRQg/Cq0nCpeC0iOCoj+qplzgKGUIX8JCOk2XwnZGAZXY4PXZZKi48e3XguYkKIUIfwqXgp4cr8JC6gnbfsuGkqW/wnriBw5jIusOyKlw9LgoeQhxw8KuNvS5g8JCyiU4/4pmS4LqxVjwhdVzIui99Cg1CC/CRiost4Kej4YmVCkJCQDJSa/CQhYDgu4Y/TvCRsIHwkIO5Xtu44oGYw6El4K+IwqBcLvCQgYTgp5128J65mXjwnZKPXfCSk5/wkISfJj0KLEIqSfCRjbBL4Ki8PcOx8J+CouC2gUDhoZw5Ij/IulnwkKKvZzfgrKPgpoUvChtCGWAtPDpRLSTgqovitrHIuioldu+sgvCRioEKKUIn76uOfvCcvLA68JCurS/gq6MvTTPvv45COsOO8JCZqMi68J2Fozw7Cg1CC86Mw5PIuu+sudGoCjVCM/CWq4TwkIGVPTYnPPCTh5/wkLKIXPCQqKjDg+qfmPCdqpzwn5W0JiTDvvCeuZfwkZOVWgoRQg888JG2mPCQoJvIuvCRhpwKQkJA8JGKpmBA8JCohsi64p+QLsKvUS/wkbuqLTPhpLrwkKmAM3t81o4zW3A81ZDwlq6F8J+VtPCeuY8i4Ky1feCxggoZQhfivpHDrfCdkrvgrqRr4LmHKvCWv6QuJgoKQghUKnVqXCphPQoxQi/wkbuq0ajdsnnwlq2ce1fjg7RJRTY9JC/wkZK+76yW4oCSwqU+IkYmLic/cSE1ewodCgRuYW1lEhVCE/CRtLxK0ahg4aCBdzwnXHskwqsKVgoJbmFtZXNwYWNlEklCR+CovCRO8Ja/pPCWo7Pgs4DwkKurJifwn5W0J/CWrafgt4HwkJO04rStYuCihlzgrL7wnrmiRMOSPWR5Sj868JGbg+CsiyouCoAbugH8Ggq4GgoHY29sdW1ucxKsGrIBqBoKOkI4aEkuLfCflbTwkbGCwrTwkL2+YPCtqolgXjvgqYI8XOGko+CmuOCqt/CfhIjwnLyXT/CWvpYmw4UKCkII8J2SnvCRq6cKE0IR8JuykfCeuZTCqT1O4aWxeTEKI0Ih8Jy+nyDwkKa88JGIicOm0ah28JCkmFbwkLqs8J+VtFZ5Cj1CO1wiL13wnrqn0ajOjCon8J+VtD/wkYei8JasucKvLlLqrZo84LWH4KqQbuCwluGyruCumSZg4LOI6p+8CjtCOTzwn4Wy77mUPfCWvL/jhIjDveqfk++/vfCQgqE+8J6Lv1jwkYK/4Ymcw7HhnKBTJS/Dh2VcQTpONAoFQgPvuasKN0I1w6TgsaclOjhSwqUmwrZwZz3wnri18JCjpy/gq4QkJci68J2UnPCbi5NMNPCRh6w8N/CRjIwKH0IdLyU6UNGo4bOoe+OEn/CQlo8r4Lee76yWyLpcwqUKK0IpYMOwSj3wnZK78J6CjybwlquhJylm0ahf8Jq/tiRc4bycKOCpqSRbe28KJUIjL8Kl4ZyE4bypJ9GoXGBNyLpd8J65i/CcvL88S+CmruCyi24KHUIbyLrvv708M0jwnri2wqUyQsOL8J6ypOqnlXU3CiNCIfCegI9L77+96qyryLrwn5W08J6Eu3vwkYq78JGHqCbIugovQi1LKMi6XPCehYU1Zi7hnaTwkZKIPPCSgK498J6fplXwnZKfddGoKkEkLuGJsiUKGUIX4Zu1JiZc8J64u+G8rVThjIfwkJaJMykKA0IBbQolQiMvVTo977qKL+GAkPCRhZsq4b2ZbcO94Le0yLrwkaOi8JGkkQoJQgd78J+gi8i6CglCBz1c4omePz8KBUIDIyV8Ch1CG+C7mfCQgL0nJCAqODbCriTDi8KzYEHgsYvCpQo2QjR077+98Jq/si90InvwkJaVLDrwkIC64LuG8J6irkHwn6GSJPCeuLVh8J+isS9ZP/CRtYA8ChRCEnZN8JCkiCR00ajwn5W0JSdCJAolQiM9eO+/veCxnT0lJSfDlC4kLz3DqMKw24hKIsKsIlnCpeGPuAozQjEiPSY68JGbhm3wkYyy8JCniVzDgCZg4L6KWT9TcvCeuqHRqHvwkbKkPyc/aD/wkJO2Cj9CPSZAXPCRp6Ik8Jq/szzIum/wkYyG8JONn/CfoaA+4Y214KeL4K2zJ1c84LmFXNufKeCzsnsh8JamseGnk1IKKUInZjzvtqfwnrmUyLo04LOv6qC2LUwtJ/CdlIfwq6W1JOC3lvCflbRSCjVCM9Go8JGBrdeyIiRcPTJX8JGNkO+5qdeR4LqBRfCQhKzIuuCziiXwnZSPfSTgt5vvv71cXAonQiXguKfwkKC3cifgqLnhgZHwnqWfXMi60ajwq5+KJSVx4L2J4YqFCgpCCMi6PCRJPT0mChRCEuqsqjpc8JGHn/Cdo6Lwn5+wLgolQiMvV+qvtfCWq5M9762BeeG9iGLgq4PDsOCsnXDgrqR727QnPwoCQgAKK0Ip4LeWJyfvv4rvv5wiZuCvl0XCpeKAiCcqw7Lhna5hcidY8JGmo/CRvrAKHEIaJCcy6qyR4KmNLj95PeGpsCRcPXlgavCfn6IKBEICPnYKNUIz4Ki4wq7IutGoJzrhv5ck4Kiz6qSlZzxcPyImP3TwkYK/auGmtPCfoZbgqJDwlqCRIk9cCidCJT8nNj176qyu8Ji0gOWohvCQk7NPLiIs6p+TP/CQvb7wn5W0wqUKL0It8J6llSfDkiZyby1U4K6ZIi7wr6W16qWP1rLwkbWoZyVB8J+VtMK74q67Py1gCh9CHfCQroIn4La0RPCfr7DRqNGo77+9J+Glq/CQv4I8ChxCGiLwkaSVdOGOhSd7eifhi7Rcw48kIvCQqYFlChBCDiLwkIGX8J65ovCRkZ0qChVCEyQq8JGMs1wnJ+CqjOCqq/CWqaYKGEIW4La2JeCynPCflbTwkL264KeHQeCukAoDQgEnCjNCMVsv4rqO4b2IWCTwn4OObmpzP+qpiiXjgKF7yLonJfCRi7hVwqUu8JCLuHFcLfCbspkKFUITM/CdlIjwn6yGyLrwkYy9YOCrvQocQhrwnrmb0ajDofCQnaPwnoKPKVLgsqtA8JuCtwoVQhPwn5W0L1rwn5W0XPCehKoiQS4uCjZCNGfCpTzgqorgq77hsYh76q2EVCJ9w4riuJha8JCsoPCQpIHIuuqjjibIuuGdje+/veKfqW4KNkI0J/CRjZfhpqQk8JCpk3QiLuCgu++/veCovlDhpLrqoYZw8J+VtE3wnZOCIU7Iuj0meu+3hQorQil78JC9v92Je8OlbT0nJ2Dgt5wkcz9TR0Be8JG0umB+MWLRqG1Q8JGMjwoKQgjwkZmXJsK+JAo/Qj3wn5W04rqbyLrRqHguVdqIePCcvIw/w7jCpfCfiYTwnoqSYPCRh7NcJzXhirPwkZOC8J65mfCQjIfRqCVqChlCF+GLlSQ/NPCQjpbjgqpa0ajgtYbwlq2RCj1CO/Cfpqc98JCwj3gv8JCuq+G/svCflbRsIkLwkICDeyXqrKwz4K6KLFvqqZI86qmHNC4iYHvwnaqb7Z+2CiZCJPCQjrkqeSfwkaSJXTbhg41IPVwlJyot4K64N/CdhZjhiZhKMAo0QjLCpfCRtLor8JCiqyEn4bOCZC4i8J2dnlp30ahg77+9JuCogn7IuuCumi5g4aewOuqfkApKQkjRqPCfn6vwm4WRayTwnoCB77+90ahc8J2Fmz0m4LOy8J+VtFh78JCGi/Cdk7/gp6Ni8JCMiyJ18Ja+mDtcKfCbsbMqYOCrgioKEkIQSdGo44CvMu+/m8O9J2BcPQopQifwnY2vR/CQoJPwkbyufWc144O/8J64ssKl6pmCZS4xwqUu1o9aLXwKDEIK8J65izx7JuGJmAoOQgxFVWPwlr+j4KyIfTwKGUIX8J65slwsIsORJPCQq5IlReGLgvCWq5kKMUIvKnt7Qi5J8JCVhvCfiaLfpuKBsFPvv73wkZOA8JGkk17wkKCeMSN9P+CqkDngu4YKNkI0LmZ48JaugHDwkJW/JeGBiSYkIvCfopUqPTB7wqXwm4Wk8J2fpVAt8J+etSdn8J6Cj8Kldgo6Qjgv0ago4KuIIuKttnEn8J2EoPCdjIDCpUpy0ag/XOCuv+CngvCbhZXwn5W0V+qspmBvyLonSuGYhwoQQg7qrIswSfCfn7Bq8JKJggonQiUxNu+/vfCWqoo9LyLwn4CJ3KLwkbKzIi5fKifIuvCRi7PhsL1KCh5CHC484oCJ8J+gg0Pwn6uAIvCav7Vw8JGDpDfvuIcKJEIi8JCjtSIiaCRgOFzwnoWO0ag94b2S8JG0vPCRjYg6PVk8PwoqQih34KaLIkrhjqY8MC7CpT/wkJ2N4bGhwrQnQc2GwqXwnaSD8JuFpCVlChFCD/CQh65WLvCdlJPwkbWFNwpHQkXgprJn4KGmeDDgq6Ez4K6O8J64ueCtrVhQ8JGMgVHhqqJ78J6fo0o88JC6q0nwkYK5YiXvubzhsbvqn5Xwnrqi8JCYqHEKBUID4Z+gChpCGEc2ZGAuSuqgt1w68JCNhMi68J+utOqnlQojQiFDSS/gppDIuuC0pCrhn6YuKlwh8JColmB7diZ7J1IuTmoKDUILb2fwn4icQXI/w4EKHkIcLyXgrY3wm4WV77+9J0LwnYuOw5tq8JasrCLCpQo+Qjw68JOHsPCegIAi8JarsiUlIcKlWifwnZWG4KuQ8J+VtGE28J+dpmnhoJnRqPCeuIs84YuA8JGKg9GoJz8KP0I98J6Am+G9m8i68J+VtHvwkL2N8JGZl9Go4aqX8J+htm/gprJyJ0Pwnrm+Vz1zJSXgtYpOPnA88Ja+lWBTegpMQkrwnoSzP+CijPCRvIfwnZKCYCRz8J66pfCQnaEj4K6javCQlbRSXkdu8J2qovCflbQkZz5I8J+Dgybvv73gp53wm4Sy4aqG8KGCmwoMQgpxbG0v8J+pkj0uCg9CDfCeuLXwmLSA8JC/oicKBEICe0sKIEIeP/CRjbEv8KudptaP8JCrqyVNa8KlaOqjmHHitIJ7Ci9CLT/RqPCdqpx7XH3hp7sne/CfgrrIuibhi44xQfCRmKHgro4/4b+YPFDCpcOaOQoQQg7wnrSTKuKzkOGulj0mJQopQifRqPCRtZI9LXvgrILdk0nwkK2p8Japoi9Y8J2Gk/CRjazwnoCoWj8KCUIHJXJ88JGNkAoVQhPgrp5be/CflbThip3grYvwn6unChpCGDM0RfCflbTvv5IiJ++/vcKk4KumST/CpQoCQgAKHUIb8J+VtCLRqOG/iOGtlTzgrpPIujzwn4KJ4L2fCghCBuK0v+G9uwoKQgh9JeKClzvIugotQisv4ayCwqXwnrinXE7Wj17wnZWMw7fwnoKPPSg9ZmAl77+98J+JhSzCqj5hChdCFXk+4YuA4Kmn8JuFkuCqgci6SOCoqgouCgRuYW1lEiZCJPCflbTIuuGdpnfguoRgwqV6LiTCpXY94b+iOuC/l/CRv6E2MAoPCgluYW1lc3BhY2USAggECroEugG2BArtAwoHY29sdW1ucxLhA7IB3QMKC0IJ8J+VtC0l4rWjCh9CHU174rqF4Kqu8JCOvGrwn5W0L+G+mPCRgZLwkYyeCgNCAXQKAkIACkFCP8KlKOCrkHrhj5bwnoCD8JGMmci66qmQPy5B8J6ln+KAuGbCpWEu8JGnpNGow5o04LuG8JCNktGoLmBc8J2prgopQicv4LKoMm/CpWzgqYs/T0taK/CflbQ9ayXwkayD8JGks2AqXG4meT8KPEI6P+qSoSVMJyZ64Ku+77+9PSZj8JOHhyRg8JGwuCTCs+CtnPCRprVpPnvwkK2D8JuGmioobPCRtYBgdgotQism8JG9g/CetJfIul3Ct0QqMOKAteC7iuKAgDzwnZKiL/CeuLk3Ty7wkK6rCgVCA3vCpQoXQhXwkLKQPHrwkLm7MyIn4YyS8J64pycKAkIACiFCH0TwnrmX8J+VtFThqpHgqrU686CHk/CegJbwnqSFWS8KEEIOTzrwnZWAVe+6jz3gsIgKDEIKe2/wnrmHLl/CpQoWQhRc6qaD8J2Uh2zwkIaQ4Lev8J66oQo0QjLwnZWGejzwkLqsOfCWvJBnO1zwqqavVi9PL3vgrobIulnwkKa94LqxMfCeuqw84oSMIgoQQg4vZS8mw5Jq4L+D8JG0iAoCQgAKMwoEbmFtZRIrQinwkbCS8JCouPCRhKHhq4zwkY2NIy48aWpC4KqzJjJR0ajgq4zwnYaXLAoPCgluYW1lc3BhY2USAggECvodugH2HQqdHQoHY29sdW1ucxKRHbIBjR0KAkIACiRCIndI8J65sXx4YCc9OuqSlPCflbTvv73jiJjgs51y4K2c15YKJkIk8J2Ej27wkIq1afCxkqR9d1E9fTrhoo7CpfCRtZci762B4LCmCiFCHyTDiiDwkY2z4LCO4b2hYPCQvoYk0ag1c+KCvfCflbQKHEIa4rCM8J+vh8Oh1o7gtKrvv70ie2Dwn46QP1oKHUIbQ+C0jD0nw6Jj8JCWlPCQkJUv8J2qn++/vV86CgxCCltRek/qoapQImIKNkI04aq+8JGSj2Ap8JGZkPCRsLp7ISE6Jy/vv7xseznwn5W04K6S8JCWs1Hvv70me+GnkMi6TQoJQgcoMEQg4KqQCjZCNOCppiXvv6Z0JOG9uPCdjbgi76yXQTJsTeCxoDw877+98J6Fg/CdkrsvN/CRiojwkYyQw5gKIEIeInEiLuGglvCRtafCpfCQvL7gpoxGYGDgv4xcPcKlCipCKD/wkKSoTG7wqJG8bsKlbe+/vfCen6Qn6pqf4reQPuGLhOCnnUzRqFwKG0IZ8JGll0Uv4LaI77+9VUlgJfCRjLB7ZG1fLwozQjFxw4Ikaz/wnYeE76yWP+CmhmDIutGoWnUuw6Zm4bGFSSLwkYiB4b+CZSThnIDvrYEmCi9CLS/ig50/8Kufljp84LmP8JCtilE66qeo77+9IuG/uyLwkKC8PPCQqIYm4KGXaAoJQgfwn5W0RiVLCixCKmBm4KC2WDplXy/wnrmXcCbgp5x7wqXgvoPqpq4y4oSGIj3wkYqLw7E9fgovQi3wkIuD4b2U8JuyiG7DrFPhgYwiM+G9pPCQgItmLtaZw5IiXHXwnp+pJsi6PD8KPEI6JvCRvYhs4recXuC3nnlc8J+VtD9I8J+AlDU96qyN8J+Dg27wkYOh4reBWnsm8JORhTrwkKi48Jahkgo4QjbwnrikLyfwnqWfIPCwu4ngt5Qi6q6dwqgiW1MnP+GHtlbwlqmBfmwlJci6OmvCpfCQubUkwqUKMUIvPGDIui/hqJPwkpCpanNCRE7vv4Yk8JGKpEEu4Ky48J65j3sv4KCp4Ki44redwqUKO0I58JGkkEAl8J6fqXLCpW/Doeqgs/Cego/grZXwnZ2FJOG/ji7wlrqQIiQiVmQ90ah5LCdC4K6e4bu9Ck5CTPCen6Ev8JC6rSYg8JGNh2rwn5W0yLrIukLRqPCQrq7wkI6ASTwq8JKRovCWroXvv73DiXdH8JCdpu+/veGho/Cfh7MuNeCwilPvrLgKRkJEOvCQjrTwkKmAw5HRqFzwkb+F8J+fsOCroOC2tFDgrpTwn5+wJ+C3k8OPeuCysT3itqPgqrLCtSpD8JG1mS/gqolhJTwKKkIo4KyM8J+BkyDhoJIz4KeX8JCellzvv73qrJZW8JGnoDvgs6gmcMKlJgoLQgl78JCnqfCQurEKKEImJfCRjLcoYDxhfsKjUeK0rSImNHsvPfCdlJfgp5zgv4Jgw4MlwqUKGkIYe/CfiJ/wn5W0SGA/77+9PsK58JCVnsO5ChVCE0pX4rag8J2QmcKlRD8/dPCRgLgKNUIz8JCRmuCngnsl4LeKJHtIyLrDnGDwk5GKPeOCjibwkZmQ8J+hoyrRqPCRqYRWwqXwkKeICkBCPvCdjK7vv70nPFHhqal4wqXguoTwn5W0Kl/wnZK28JGDgSAuWPCRjY3vv71COj3wlq2RMS/wkIGJw57wn5W0CglCB2Dqn5cuwr8KIkIg4r6y4La94oK34aWU4K6ZIvCRjYjwn5W08J2SoinIujUKG0IZ6qmKV/CeuIDqmrwne8OPP2I/4YqvPzxwPAo1QjPwkbKd77+96qyrL0nhnbJcKsKkYHzRqNGo4b648J+DgnvIulzCpfCRlqXhn6gm0ahrw5cKGkIY4Kyye++/vfCRjY3wnoSfL/CeuKHvvLJTChFCDz3igJrwkZKcJE8/8J6AoQoJQgfRqOCxiDpyCh5CHMKvLeCpkShUJSolLWHigrdr8JGKgGDwkK6cPCIKCUIH4K2XSuC2vQo+QjzgrYhrfPCRhL4v4KauS3wk0ajIunvwkYGJ4Ka2w4DwkJakeyQjwrh7LuGxuGrgu5zRqO+kgm0uWyLqr7kKI0Ih4Kyn8JKRsDxVbHUgdPCfiKvCpVzwkJWQXH4qKvCRpIlrCiRCIvCeuLdeyLo78JCAuu+/ruGdsuG8rntl8JORh3tn4KyQJS8KFkIU4rWw8JCnvSLvrKDCoOCtl/CRnKAKOkI48JGBr2jwkJGlW0g9L+CttcKlJOCog/CepKwkXi0nPFRCwqXgq5AnSVfwkbSJLmBc4Y2d77+9eXsKHkIc8JCPj/Crl6guQTE84b2V8J+qkzPIujXwnoCYKgolQiN7yLo/LljRqGPRqDc+6qWoPfCYtIg64Z2zPCowPuC7lmBcXAolQiNEeypg4K2V44Cq4K6a8J60nyLwpJSfJOqgq33wkaazJMKlJwobQhnvv70x4aqH8JG2ok7wn6KxemAiQUphXNGoChVCE8OM8JaohvCfn6ouLdaPPvCQoIgKAkIACiFCHyc9JCTwkLqx8KujsuGLrCbvv70/JH3wn5W04LK/wrIKPUI7Mz7hor1QOnzvv73wnoWIJ8K1Oj8/ROConVzIusK14LuE8JCknyfgqpHwlqyK8JGMh2AlJeCnjCUuLkEKLEIq8J2dk+CovOqtvi4v77mx6q+04raiJsKl3Yrvv71DX0jwmr+9P2Q94rajCiVCI++/vSUkOipA8JKUu/CfiLrjhKko4K6CQyIn8JGIg3PNvD1yCiVCIy/gq4w8PWDgqYhK7Z+44bCf4reWe2A6PeGlgMKlImTgtJAiCj9CPXE/TOGKvvCfqofvv71o8J6fsfCRsb7hopXCofCflbQkP+G9m1Pvv73wnZSUIvCRi7N7JGA/b3HwlJewOlYKIUIf762v0ajwlqqkJOGfoO+oo+CykHtce1x7JlDwkYOjJQoqQijCpU9gYF8/SvCQhpo/L/CQnohmYfCRtpUtwqfIuvCdjKl9w5bwpJ2hChxCGifwkZOTOfCRq7YvYnFEezbRqCLvpqku4KmLCh5CHFxzJHbgqrMoRiXqo5Eq6q6Rw5LwkKuuJ+K0rSIKJUIjXPCQoINse/CQrYB7JCRESfCfm7zqqLXhm6zwnZKlajrhiY0KD0INwqQkcci6IuCuhSUkLgoxQi9KL3fwkKiGXnAldS7VvfCfoaxm8JGklUbwn5W0ZSbqn5PvuaYn4K6cTVxc8JCqkQoxQi8q8JGsh++/vSfvv71gdXU0M2QlODd0YWYmbuCxluG9mzxcZfCRjbMm77+98J2LrQoTQhHCpyXitrzitK3gt5Zc762DUAolQiPwnZS3WOK1hfCflbRmw6PiuZBE4K6QwqVNL2V46qOQJyrDnQokQiJ78Jq/veqhl2A8ROCriOC3svCdkbXwm7KH8Jarg2h14KyBCjNCMfCdlYPDrvCQhpXgroYnKvCRnYUv4oWzeyTwm7Kc0ajwkIyS4K+B4aqXe2Ei4pGJLzoKFEISXOCmmE/hv4PhqpM/aEjhv5E9ChFCD24mJFXwkZKt4aKDRTU9JQozQjHwkIag4LqlJVQu8JGHosKlUfCWv6DwnoWP8JColeqZtT8k6qOSLz17TjzwkbS60ahGCjBCLvCQgYNDLsK4PSTCpeC2vSoiPDwl4r6ueTox8J2atDzIuuCxh+C2pWHIujXvv70KIUIfJivhj7M84aC2csOKPz7DnWDRqEzwnZK28J+VtD0iPQo8Qjo98JuwkHJyOjfwkKC8Uzzwn6ml4KmvJvCRmpsiJEDIuj7wkr+pceCzgSU+a3vwkKuu4KmRPfCWrLYlCkRCQvCRgIZg8J+VtPCWp7TgrZ8pOuC3hcOdJX3guoTDmz0kOvCfqatp4LGV8JCYoXnwnYya4KyP8J65uiHwnrmL8JCEgAocQhovXT9b0aglIvCfqLHgvJHRqDpz8J+VtC9rTwpCQkDwnYyB4KedJ0fwkYOyXiLwkKiOwqUlwqVYKkUi4rWvfdGo8JuEgGtI0ahgLvCRnKvgt5R8IuCniD/wnrmJ77+9CiNCIfCQjLtDJfCQlqXwkJ6E6qWvPCThnbIqW0fwnYSs4K6CYAoXQhU18JauhyIkJnvgsa9S8JCUjPCQh6sKLUIr77+rITciPX3gqIMq8J+ev8Kl0ajDmtGowqVQZ/CeuKEkUD7wkIagKlxrPQojQiElO3XwkbKzJXvwkb6wKn3qrIHwkY2I8J2TgfCWq6xHPyQKQ0JBLmZBJ/Cei7jwkZypdUbwm7GxyLrwkJ6477+9QfCQjbNk8JarmuCssvCQgZfCpeqoiDgn8J2VgfCbhZDgpo/hraIKD0IN4K+XUfCRtIk3YCPDgAo8Qjrigpbwlr2zIXPvt4/vv73CrEsqOi/hir3vt498eyTit4p74ZuGNC0k4Zy0ZuG/njzwn5W04LGVJF9OChlCFyPgs7FJ8JCWhsi6PeK/sjrwnrmJTcOyCjFCL1x78J66lCTwn56g4LK9KvCsiptHKnXCpTrRqPCbspTwkKuf4KqQ4Ky2NS/wkIuGChhCFsKlLiR7wqjDifCeo5M98JCylOOEkkgKKUInRjpowqUu4oGxPyXvv73wkJ2UL8O/e9WI16Lgrorwn4CM4Ked4Ky8ChhCFkBTJPCegI3wkICL8JCwiuqfk/CQnYkKBkIE3aMiJgotQitA4KiQO1pcLvCRpLjvv708Jeqfk0pYW0lzOsOqePCflbTIulbvv73Dqlx7Cg9CDeCuqCUu8JCKg/CRhacKJ0Il4LOh4KujLz/CpfCRpZBjQE0nJPCdkp5teyY6MvCQsYRD8JCCmgo2QjQl44WE77ePPeCysCbgoY7jhqnwn52Uc8OMPV938JGNiybDvzPgoagiLiZReE8qOsKlwqVgChBCDvCWrIN7ItGoJeGcry90ChFCD++soOGtq1zhv6Xvv73RqApDCgRuYW1lEjtCOfCRiojgvrthYz3gqpHDiETwnoCf8K2UvMKl4amu4aCD4Kec4rauw5LwkI+CTuGIn095PcO18J+VtAoPCgluYW1lc3BhY2USAggECsYYugHCGArGFwoHY29sdW1ucxK6F7IBthcKJUIjKiJT8JCsg+KFn0wm8J+Htis/4KiKJzfwnYaqyLpYJSvqqYsKI0IhV/Cfoa8lXO+/ivCeurXwkbaUwqVN8J+guU5ceeG/qHljCghCBi4iX+qslgotQivwkYGl44SkJeC3rV1Eau+5qz054rWfZPCRjI/vv70mLzps4KqB8JKRpMKlCilCJ/CRtYLwnrKh4K2cfe+/vUZn168sLvCRjZfwkKmEZ8i6LyLwkIqCLgoMQgpnJeGyuuGLo2pdChdCFVzwn5W08JCLj/CflbTCpWl58JKRsgpEQkIk44K2PFTRqPCfgq3wkJa28J2Vi/CQqLIkJ/CeuZTwn5W0a++/veGssDXwkY2X0ah6YPCQk6XwnoCgLzx7Kifvu7YKCEIGMvCRpqU/CixCKi/vtJ0iXCJjPfCRvYEnYPCfg4Evez9zSe+tg/CRjYfgtoZLKkY/8J+VtAosQirCvfCRtYB8JfCei7/DnmDhjJQjJERaUWUx8J+JkeKkklI/LkTwn5y3yLoKKEImPO+/vfCcvIEqJCJY8JGNs+qhoTxoTyfRqCLit4nCpPCQh6w8cikKTEJKSSLgroPCqPCQi6E7ZfCRvZDgt5Twn6qI8J+VtOC1ty7wkYuzyLrCqNGoNOCojy9HYPCQi4Np8J66keCooy/wnrmpLvCRnIUlw7EKH0Id8J+gkSVcduCro8OW4KarJC7gqqg6P/CWqY3gvLkKIkIgPfCQqL/vv73wn5W0w4vwnqWe77+9yLrOjCok0ajDnzoKKEIm8J6KoPCeuLlg6pOF0ajwkayAP2Pgu4s88JKRm3vhvazgqZHIumAKM0Ix4K6TJfCRnKUmYkMqYPCdi7PgvLTwkI2q6qGHOHsk8J+VtMi64LqlJj8zwqU8NsOWVQo5Qjc6OmvRqPCfqYE98JC/ici6wqU/8J2Su+C1vfCRv45W8J+VtEh9OkUtPO++qfCRjLLwkKCA4K+KCgNCASIKM0Ixe+Cng/CWv7DCpdGo4Ky34LuCLOCygDDgqYvguKE9YC/hs57hvKZ7aeGcsTNhXOK/uwo+QjwqIvCRvrDqn5El8JCWqVw88J6AquCqrsK4ddGoL/CQkJHIukLhqYXwmr+xJ9GoIm/gqLjDrVrwkI2gyLoKKUIn8JGKsy43OtGobfCRrIAw0ajqkp88VUPvsazgp7rwnp+oSe+/vcOTCiNCIXfgqZHqqowpOD9nbvCfpqAkQOCruy3wnZOe0ah3RuGPuQoaQhjhjpnvtKwne1LwkI6A44WE77+9YOqukCYKB0IF8JuLkDsKJ0Ilbz0l8JCkhvCfqpA/wqrIuuC3kci68JGrqvCQk7snLjpz4rqnPQouQiw84Y6r8JGisfCQjpnCv+CuiHw/Oic8SzrwnriPJvCQoIgs8J+VtCXhprYqLwobQhki8J2RteC1hirwkY2Q4KeDPGxvQGDhirJ7ChxCGiTIuj1h4b+YS/CRg4LDtCTRqNGoPPCWqoxZCjtCOV8hJPCetLslw5Z1PCrwn6uD8JapiC/wn4KmPT3wnrm+Lsi6XFzvv73gt4p3cFXCpSVgw4A68JGrgQovQi3wlq6C4LWfUS59dfCQqoI5XOCunvCQnoDhqrgu8JGNjD3wkZGg4Ku8O++/vScKEUIPKcK577+94ae6JCfwmKOHCjJCMMi677moLeOGqPCRkZ17O+G9kzrgr4rqo63hoJhpwqXwnrqA4LOy77+b8J64p+CvpwpAQj5z4b2ZyLrwlqe58J6AoMi64ZuK0ag/8JGWiiY/8J65jTrwkZCLPiTwnrmd8J65tfCegax7Nkw6LvCQvb06PQooQibCpTDwkIWCePCRsIcq4Ka4Lj1cIvCRgahKSPCRtLXijovhnaPIugpAQj4vJ+GfssW08J65l++4qT/RqFok4ra8Vy7wl6Wn8J6AoD184YmYyLpE8JKRii7wkISeK/CflbRjSCVO8JGMggoTQhHgspDgtKhN8J+OkGDwkbaQfAodQhs6Lkzgq4zwlqqU8Ja+hCrwn5W0dOqfk2DhpJwKJUIjPOOCqD4/L+GLrCrwn6G177+iLnvgtbM88J+IgjpDYFjqrqwKOUI3IvCQlbDwkYqyfeK3lCTgqIk/8JGKhnvRqD0hXEhMWuGlsSpU4KGQ8JCdhOGjl+GktyjwkLqnTwoUQhIvYvCQi4DRqDQ64K65KvCRjagKLEIqLsO+4aOCfuC7nuKuiHd9XCUiJWkv4rSKeFfwlqq6KiQq77+9L0BiSDwlCjZCNPCQgIPhi4IvNPCRjZciaSUvL+CvkCQ/LvCRg7Hwn5W0fT9VXPCeuYk8yLrwnrmheyrikYYKIEIe4LWKOmTwkZKN77+98JCoueCvtDBT8JCNrPCfrbQkChdCFWHvqK3wn5W0ekPwkK6DTFY6IVw8awoVQhNcXGDDueqprvCTkYpNJU014LeyChdCFeCnh9y46pmgOiXIuvCRjKgz4Y6DfgoNQgvvv6rwn5W0I+C3hAoWQhRk8JGDtkYzJsOP8JG1pci6UiZ6KgoyQjAn6qyoKj098JCouOGhlvCeub7wkZeBPWbwkbSA8JCCtSbIujrwn5W0PHYrJ/CWrZQKJkIkPPCRhLvwkbWiOfCRpLN0wqXwn5yB8JCqgvCWqYwvdeKAoyV3CkVCQ+qloTzwkbaT8J+gr9Go8JC5pjZ74Ym98J+PlPCRqIclUSBnJj8pR2VMwrIqb/Cfn7Bg8J6EhMOK4K6I4YmY8JCjqyIKA0IBLgoQQg5hPybgt5bIuijCpSZdUwozQjHwn6KVeVzwkJOL8J2VjcWo4L2Zw4F8QuC3qD0k4raw8JGkieqsrvCek7g/ZvCek6tXCidCJeGoqjpcwqXDqVxaVDUi6qyh76iu8JCUlz8iYFXwkZaLOlosKEEKMEIuLtGoXOG8qeCrgeKxp3FuJPCQrZzWsSLwn5688JC7vSfwnYWfdW3grL3wkoiAVQotQit7W/CWqYHwm4exL9ywOkxkLlTRqELgq4jwkL6FfTxN8Ja/pCZuVuGJjDowCh9CHVw9Xci6ZyzwkKydIfCQhbc60ajgr5cm4YmL4K6fCjRCMkTgrZYk4K6+8J2ciSpa4LGow49vaCUpwqHwn5W0XkNq4b2zU+GzmdySPOGfgci6Lz89ChhCFuCun+CtnfCRtIjvrKXgrqQi8JC6sHMKHUIbzbrwkbGw4aqJw6nCpS7qp6Qy8JCdjWA8Ojs8ChpCGCzgsKs9OVssyLol8Juxu1zhmrcm4b63Kgo9Qjvwkb+f4b2bJiRc8J2HheGqpsi6L/CfnKtCTWDwkaWSOjbCpyXCpMKlYGAv4LqHIlwiJvCflbQy4Y2tJwoOQgzCvGxo4Ki8bPCflbQKM0IxwqXgqobwkKiWKvCeoLtIPScmPXMmOjrDv/CeuZlaOvCek5ps8JGsgHvRqCFg4K+MKgoLQglLKvCegKBfwqQKIkIg8J2cqlgkeSfgsL/gsYZBVOKDkWA6PeGqqXti8Ja5mCUKGEIWJC428JGZrOG9mfCQo71c8JG8uu2frQonQiUwKF7hna/gp5dN4b2bNvCQp4BsMtWL8JG8qu+5sD7wkKeGYdGoCktCSfCfm7h7w4DwnoCow77gqIPwkYyvXXDwn5W08JCrtfCQlrs6O/Cdqp7DnvCWqpEv4Yq5JXvCpUJc44OdJznwnZK4KifCo/CQkacKIUIfOsKlOiQx8J2Arj/jh47wkLmrJMi6NuKAkzI+77+9Lwo3QjXwn6Cf8JCgkOCrjVbgrL5S8JG1huKCqNGoYCpj4Z+lL/CRg7Yn0ahgJvCeuacq4b2bwqV6aQoJQgfwkK2jdcOOCg9CDSbwkLmzOuCrv8i6YD0KJ0Il8J2Er3B7KPCRsJLwn5W0O8i68J65n1BrP+Gwie+/vVrwkIWJJAouQizVi/CWv6TwkJSQfuC1tPCflbTvv70+wqUkP+qfkMKlIvCRnLzCtPCWra48PwoEQgIvKgoPQg0ucT/wkaWAwqU8eicqCjYKBG5hbWUSLkIs762cLjDgqLMiKi/CpcKl4a+P8JGMiG7hpKlv8JCOneCruyJBSz81J/CflbQKPwoJbmFtZXNwYWNlEjJCMC/qpbvgs5bCvm/CpT3wm4WkwqXigIR74aC54aaX8JCgv3spJ/CRgr4/Oj3hkqknfAqWBLoBkgQK5QMKB2NvbHVtbnMS2QOyAdUDCh5CHPCen7nhvYw84b+9Imfwnp+y8KuVpywmXHfgtJAKREJC8JGMhvCdlLDhiYvgq5BrLvCfq5Uv8KuCgOGqmSbDgfCYg4/IusOlSyUkKllaXPCQhKbwkYqI8Jy8vTpyXPCQoIg8ChhCFuCttPCRpqQqKD9KQdGoYE3IukUkL10KGkIY8J2LjMi6P/CRmac8JOKNgvCeuIrwkIGFChhCFvCeuZLDiCcu0ajgqqbRqO+4uuGggSsKEEIOS++/vGrwm7CRP2Dhp6sKJEIi8JatocO8a+OEo3dg8J2RjC5uYOCyhyThpYDwkbSBJeyesgohQh8m77+9KDrwnrqv8JCAvWDwnYiOJ0R38JGwufCdlYw9ChpCGOCsr1Vb8J2SpvCespMv8JuynDgiPTolJQoeQhw6aygiaTokJuK2vPCbho8lVS7wn5W04KmRwqUiCjlCN1Thja428J2UmHBePXZL4oW4Jci6M/CegJPwlr6S8JCKmGUmwq7Ium5FwqUoaOK6kOK3nGE6bjwKS0JJ6q6V4oGwOi8u4KeX77+9SvCRmIXhm4rIui8v8JGNkPCQnrjDo3rql7zhsL3RqOK0l+CtjMi68J2Uh8i6PT3vrJZX4ama77+9JwoPCgRuYW1lEgdCBT9h4reQChcKCW5hbWVzcGFjZRIKQgjhj7rDveOChArRA7oBzQMK/QIKB2NvbHVtbnMS8QKyAe0CCh1CGy1y4LqGMPCWqacqe/CRsL1ccO+/veGhtSImLwouQiwlaNGoadGoTlzwn4OH8JCUn/CeuoB78J2TsTQiPSLhsIDwnqGH4LeFLMKlVgodQhsnLfCdhofSlvCRqrlc7Z6x8J+CtWTwkLyzVzoKMkIw8JaqquCorzrgr5DgsLbwnZOBPVhc8JGwgeCsuCVgdPCRmKTqqYk14K6cJj13LXtLCiJCIMOd4YmyJfCRmorwn5W04K6x8JGMuCfzoIeV8J+iml4kCjpCOPCeuqXwkYOy8JuDpfCfn7AwPT1zYPCdlYHwkIaSTvCetLVbJPCfoZhi4YyUP8Kl3JXwnp+uIEFeChZCFHvwnZiDS2ki8J6Lv+C7hjzgqo8mCjFCLy9gyLrwn5W04aa+bCLCpWAm8JGLsXt78JCHne+/veGKsvCav73wkKy6Ojnwm7G7CgdCBfCQq7I8ChVCE2A/SynIuljwnZKe4LGaPyLhpKgKOgoEbmFtZRIyQjA84b2dMTTwn6qsXHvwnrmhwqXDvzxY77mySnvwn5W0c/CRpYY6UWnqoYk/0ajvt7EKDwoJbmFtZXNwYWNlEgIIBAqqF7oBphcK/RYKB2NvbHVtbnMS8RayAe0WChJCECpH4YmYTD7gqqzvvYcvL1wKN0I1POCunsKlPHrwn4eo0ajCtiLwnrm8WSXhvZvwkr+g4aqB4Lezw6N7L+CogeGKjdGo8J6Ani8KGUIX8JOAlSLwkJa2SXgkJHviuqokc++qoSUKIUIfIuCppz/wn5W08JuFlT9DT+C+u/CWv7DwkICIJCI/OgorQilb8Ja+gCbgponIukngppAu0ahcXC/gtrPgrI8/4KqtPEzgsYzgrK8/OgpCQkAqXcO74KmI0ajCpfCQtJ0iLmIq4oGxcCY98J66qCNg0ahtP+Cwq/CRpKwy4Kay4LWs8JGDtOKDoSjwn4mk4reICjpCOHzwn5+w8J+VtOCmkO2fme+/vTrwn4KLPC7gtrN5XO+/vUtDw57wn4e+4K+XWe+/vUd9wqdtcGUvCjRCMmBgXVnCpfCRmadJ8J64oirciu+/j8i6IjouJPCen6tr6qKmwqUnJjbvv70uwqEu4YmUCgRCAsKzCh1CGybwnZKewrdZKi9+4LOdMVzwnri7wqVZKuGKsgooQiZ38J28qS8uYiUr76y1XMi64Y6U5560OyrwmKi34K6D4Z2nJCVVNwoRQg/wnZKpUXDgq64oXcK6yLoKL0ItyLp4X/CRtavwkZC0W1xyIiHwnZSq4a2c4K6qLlZVwqzDmiR7XPCRnKvgoZ4tCkBCPvCdlZAmbOCohvCRpZnwm4Wn4K62LuqnqmXwnouywqXwn5W0P/CQnaJ8RMi64KiVw4UqM0DwnZWBMyvwkJOhCiVCIyYi4aGXQns6762DJmvwkKiSYOC2g/CRvKfhrYLgqJjivYAlCh5CHD1v8J+VtFzhspjguKfwkK2OJHvvqrvwkbSIRXUKBkIE4b2LewojQiHhiZ3DuXNnPT/wkbyFPy/RqOC1tC4uNH573LXDgvCQoaUKGUIXXkZibTrhppbDnOCmhiU98JGLhkngtZwKBUIDfioqChtCGci6yLpg77eP8J6fseCwvu+/glDwkb+AIjoKFkIU4LGgLsKlIjU8JDpmPyDgqIVyWEYKO0I5LvCbsobwmLSA77+94Ki4PcKl8J64p/CQjp/gra1cPT3RqPCfh7o8Oi97eV/wn5W0L3s6PTrRqCYvCh1CG+qsjfCflbQ8J05ZP3fgrqNgR1zwn5W04b6/TQolQiPgsYfgsYRl4LCgyLon0ahBXOCnnfCRsJ9p0ah9KkPCpTojUgoeQhwj8J2QrmNtLD/gqqBcJ3J70ahbwqPIuuC2vUgnChhCFmN0YPCflbRjIkovSCVa8JG1py97OmkKPUI78JCFpeqjlfCRsIcq77+9yLrYv2kwRsOF8J2VhmBF8J6LjvCQlZEiKC4mK1bwkYu52bcuw4Dhi7wlL3MKCEIG77+9dyo/CjVCMy5gwqV1PSQ8JfCRpqXCtGDitqrwkKyQ8J6Cj/CRtJXwn4id8JChkuCtnPCehLDil5RXOgo5QjcvJDFVQSbwnrm+YPCRjK0kJnt7YPCdp5zwnrqr8J+iseGtr/CdkqXwnqOW4Z2RWFVcXC93e9GoCgpCCPCetJLwkZecCkBCPj91KirvrL48JDrwn5+w8JatkHvhqYjwkIagP+CqhXs6V/Cfnonhv7M/8J+DqvCRtqngrZZ+8J66ovCRor9hCi9CLSRO8J+VtD3vv73vv73wn5W0Pe+slj/wr6WJePCRpLjgoLDwkr+eLy5hRloqYAoIQgYm4a2+PDgKM0Ix4Z+2MsOk6qWmYHrwnrqJOvCeorbwnoCqPyPwkouJU8i68JGZpTrgsJ3vuarRqEwvSwoPQg0o4bycL+K7mDo/4LOKCgxCCuKAhC9zMjpnJVwKG0IZeydwPOC3svCav7Z78JC6rT97w4kmbeCmqwoRQg8t8J+fsHvwlquI8J+VtDsKKUInM8KkJCfgqL7wnY2pXPCRjaclwqXwkIGBadiK8J65vFzit5jfpci6CgZCBGDitKcKFEISR9WMZSIq4KuJ8J+VtCpVKWd6CgxCCm7wlr2eavCeuYIKP0I9IkbwkaS3PHbRqDp8JCQi8J+vsiYu4Ku64raVVz1t4K+GXDrwkK2r4KiB8Jq/sPCeub4zR8Kp8JGrnOGJmAoPQg0iYvCQppgvUeC2lTpOCi1CK1wp8J64t0rCpinigYVMQfCflbRcyLrjhJ1MKmdc3ILRqPCRvIrwkZGeKC0KKEIm4Ky1Q+Gql/CQlpQ2e/CQj5AqwqU9NS/wnZOW8J60pCbhvZvhvroKNEIyKsO04Kqd8JuynyfCpfCegKrDqGzwkaej8JGKii7wkaKuKirihbVEYMONa0/wkKymKXMKPkI8WOCqk++tkuCwjuC0hlwm4b2RWeCwvCbgoagnJCJDIuKtviouWi/wkJ2KdFzhvYov8J2Lhsi64Kin4aaOChtCGcOIfS7wnoCUL0XwkLqNOT4i4aqT8JGMj1UKOUI3JXRgVTwzJk8vey/wkbKsXMKz77+9JWDwnpOn3KzhprDgq5AuPyQudvCQrpnwkbal8J+VtNGoSAoWQhTgu4Twn5W08JCtriXgsZ1z8JuxtgokQiIv8J+fsFzgqZs88J65i0bgrrZmJvCQhIFK4LiZ0ajwkaS4CjJCMO+/vVLwkaO/4aGrKmDWql9Zai7wnaqtJtGoOuG7uOCqpn7IuvCQhaPhv4I88J+VtAoIQgZvLvCRsowKDUILYWom77+98J+euWQKJEIi8JGklS7hsbgmPTphwr1b4Ky5NOChgy/wn5W08J+qpjoiYAoPQg0iw7Qm77e78Jasl1A/ChVCE/CRmag98JCnmjbZq/CdlY/gtYcKIUIfRHtfKvCRsZ0kR/CeuaRv77mw8JGSvlsmKkFgPycqewoCQgAKMkIwcci6bN6QO2zguJhu8Ja8sPCbhaUqXPCQoKB2N8O2JSUl4aaXeCVNLEJIRConZFdHCjxCOvCfm6IkLj3CpfCUkK06JFBiKCElJOC3luCth/CRqbNN8JG1qPCQob0s8J6AqDp4LmDwn5W08Ja5ijoKCUIHez0/MTvXswoFQgNDPDMKGUIXKC868JaslPCehYEuw4nwn5W0PVPDpkQKMEIuWeCxiOOInCQiKCIn4aS6P+qirSRP4KmbL2DwnrmZ4KCne0pcLFrDjvCQoLhOTQodQhvwn5uk4Z2Ra/Cego80XCQ677+9fnh7YCRwOnsKSkJI8J6FhvCflbTIuvCWq4dgQkrwkYKnYOGLpU1o8J+qhCLwkJ2k4Y+9cG7vuKd5Xyom4LetQFjhm5fwkJaqOuqnrvCeubfwkZedCiRCImzwkLqsL/CRnYF+fsi64KqvOvCdkqvhpYDwkJaJevCRiJsKDUIL8JCmpTQ344KsUFEKAkIACidCJdGocUfqp5jRqPCfiYPitKBcwqXwnqSWJ1fvuY3vv73gpqvRqC4KK0Ip4bOHTio/NeCotu+/veqpieqspOCosiritrl3XD97wrtXQfCdk5zqppwKPEI68JCOgyfDsD3itKc9JtGoJ8i68J65gibRqNGoQEnwkKi48JCTq3vguqXwnriIXT7hnLFcIsi68Ja9iAosQiogPGY3Ij8i8JCyrmZdQNGo8JCujOCvhyUmXC578JCAtPCdlY3qm5x8US8KGkIYzolc8JGxsPCWrJPwn5W044Kb8JGlmEJgChdCFT0+8KiFqD3vrLk9JjHwn6KE77+9LgoIQgbgrINcJj0KLEIqWuK0p/CRg6IxXCPwkJGuJfCRiJku4r+wPSTjiIzDsHJi0ahaQT3wkJafChRCEsi6wqjgvYcqamcn77+9XCYlQwoeQhzIuvCfq5ZsfTVZP8i6OCLwkKmXRvCdvKpc4LCICiZCJPCbgbcvJiFc4ra8Ol5OJFxFXPCQlpXwnLyw8JGNqNGoZic6LgoGQgRg4LudChMKBG5hbWUSC0IJYci6XPCflbQiCg8KCW5hbWVzcGFjZRICCAQKlwe6AZMHCsgGCgdjb2x1bW5zErwGsgG4Bgo+Qjx96p+RXGJr8JG1mGw644iaOuCri/CRiKVrfMKlzozRqD1Gb+CwncKkKe+/vfCSib3it5LwkJ2i8J+fj18KHUIb8J+AjfCRioBcLjw6PS5BZiI+PHvgs4zhqbpaCjFCLz4yJGbwkYCaYjrwnoCAU/Ceuakk4KuDJvCflbQ8Klzqq67wn6eCIi7wlrme4rWwCilCJ+CxnTV1TMKsK/Cfqrzhmqks4Z+pYyEq8J+VtMi68J+fhCXwkI2EQgo5Qjfvv71mJeCwiWAlLj9HOD/CpcOZKjzvv73wn6qCJOOAnUwsJe2fksO48JGLkThcYfCeuLZcJMK/CiNCIdGo8Jairsi68J+rlHFOcuGPn07wkKKo8J65ny5QLuGqowosQipt4b+gektgWFYmwqUi4rayyLo8PWDwnqKYPOqrtOKujiM28J64i/CisbwKJEIi8J6AqfCRsIgo4LCIaiPwn4Sn8J+hpPCRkqs9J/CQrYnRqAo2QjRgdsi6aSrwkYuf4L6FJvCRjYTwnoCjyLpcceCtlsKlLMKuwrDCpT8q4K+X4b+IXGvwkKC8CjVCMznhoZ9c8J2SpeCzlTzgsL7qopjwlqqJ4YmKRz834LKq77+9w47wnrihPPCepIg5NeC6uQobQhkq4bycP/Crnbol6pK18JGMj1nDpF46Lls8CihCJuC1vzzRqMi68JGsgPCSkIQ/4K6yOiQ1wrfhpI1jLCfvv47Djsi6CgtCCeCoieG9iDzCpAotQis68Ke1v1sy4reJO/CflbTwnoCXJsi6dllo77+9d/CeuYvRqOCwgNGoSyQ9CjlCN0AhPS/vv73wm4GB4aa+8J+gmCJg8J+VtD/wkIGDLkzwn6yHXm0lJPCflbRiPW1g6qmr6qyLezgKE0IRLsi6Wi7hiZjwm7KCwqDRqCUKNEIy4LG8JNGoJ/Cbg5BVYGDIuvCfoqE/wqU48JCWuWwmUn1B4ratyLpBYDs8wqU6LlzgtYYKGUIXYPCQnrhd8JGIj117JPCego80PD9VXiQKMkIwbPCQhKgh8JCikUfhmqgg8JGMryde8JCooWBC8J64tEvDslzwkayA4LeaKjzwkY2jCjUKBG5hbWUSLUIr44GZesKlIlzvv6IqPzxYP2Q/YD8q8J6LjDrhprTgprnwnrux4bKo8JuxtAoPCgluYW1lc3BhY2USAggECrAHugGsBwrRBgoHY29sdW1ucxLFBrIBwQYKFUITL2AnLlfIui04XMOW4YONJ+CnqAoHQgXwnoCpYAouQiw6fHnhoIt70aglcyLwkJ2OJfCflbTgoLM90ahgZeCpkfCQvZjwn5W0MSbIugozQjFu8J2LkyYv77+94Lq14KyyKiJ3REVw8Ja+lmE4wqXwkLyWJns+77+9XOOCiCZo4KuDCj5CPCRnyLrRqFHDlC1V8JGkjvCQnrXhs6Pwm7KV4LOG6qOT4Y2m4LK38JGqm/CRtZXgrZYlL/CYtIEuZSvCpQoZQhfwnrmo77+9IlLwnrqjyLrIujw10ahuPgoPQg3ihKfwkK6qZiXwmr+wCh1CGy7Co+CniD89Ju+thMOidy88Uzo3YCo68Ja+nQpCQkB6POGLg+G9iC7wkaCKPeCrokXVgyUvRMKl8J6lmU/wnLyKQfCeuLvvv5LwkLOGe/CflbQo8Jappz9fNz0vIsK3CkVCQyVaJyNgOuCwsz8uWeG/oeCzliTwkZaNciYvOvCRorTRqPCehKvwnrmL4LaD8J65juKCmOC7gcO64aqkZ+K2svCRiogKQEI+L8O48JCOkSI9JeGfiC8/8JGysfCflbQuPSIuMPCdi6/vuZzwkLm6w6ov4aqCXPCRtIAqwqU54KqBP0TRqHoKPkI8yLp7XDEqMlrwlJWUUOCuh+GLgPCdgrvruZ1DdSbhiZjhp4U9SWDwnYuNTz8u0agn4bK/8J65glnvv71CCi5CLHd94b+08JCkjj078JKUmeCwkGF2e2BY8J65unvwn5W0OX0v8J6LtOCyhMKlCgtCCScnXeCwhCRcIAosQip7cXxewqU9OiZP0ajguoR7XvCeuqHIuvCSk4/wkI2j8J66qCU/VeGKunsKKUIne/CWqZTwkpSDb2vwnrii77+9eVwtUid0ZWBqLu+/mtGoW0nwkJaCCkRCQvCQnqXwnrmXXG/wm4GOXDHwn6qHIvCfg4JG4YmT4oGxLDoqXF3hjI7wkI+K8KqfsF7gu4Yl8JGEnPCWuYjvv71YOApGQkTvt4/igrzwkI6POj9UdPCQqYHwkZuF8JarsuCovPCfoZHCpeCslfCQqZZgUsO3JypKU0Xvv73wnL6P8JGNjO+/vT/DkgoWCgRuYW1lEg5CDD7gq4wmezrwkI6VTwo+CgluYW1lc3BhY2USMUIvPXvhqqhCLyVaQPCdha9H4KiJYO+/vT9CVeiLqzrwm4Klw6Bz8JCjtU4/VCbvv64KgQ+6Af0OCtMOCgdjb2x1bW5zEscOsgHDDgpCQkB+4KGD8Ja/sVbtnrxgPjpUIfCQhIIqTSThiZXCuPCQh5nCpeCtqXzwn5W0aDNq8J65neCovzvhrKzhpoY64YOHCidCJTrwkYCNPzohcmDwn5u0PPCRjY07XnQi8JCRiW/irpg/8JCnqiQKIkIge+CumiVAL+GJmOCziCdGP/CQlZ/wn5W0MsKlZfCSvpcKOEI2POCngOC+ki5C4KeLfNiG1LEs0agy4q28J+qlpnMp8J+BpmAnYuCpkfCRi7PwlquQKz/qoqo6CgtCCfCRpLx08JC9iQosQirCpU/vv73wm7G04LK1MF5gKeC7gMKn8JGTlvCRiobvubPCpSVvJHbhv6QKQkJA8J+VtPCWqqBpQNGoM+CumfCQqJbOjO+/vVDwn4K7L/CWrZxa8JGIvy55NNmkYSIv8JCouPCbipsqLvCeuZ19JQo0QjIr4LW+KvCRsprCpfCQqIUnJz124YqqKPCRnJQ9VCLCoeCxnU0u8JK/sSfqoKDCpcKlPwoeQhxoZeC1ii5JSSLwnoCkcVpY8JCqkEvwnoWPU8KlCgRCAsO3Cj1COyw6Me+2uOGnkCJAP3bvv4VqLvCbh5LvubHIuiTguLRIZsOb4K6I8JCAleKDnExS4KaQPWBg8KufoWAkCipCKPCeuZ178JCNmWDwn5+wIuCxgy5E4La9JMObwqXgsZ0/XHVPXPCRjJgKGEIW76uUU+GNnvCQlrQh8Jatm1x8Jci6NgoxQi/hnbMl4LG9OsOy8JC8tCfDvE8v0ag68Ja/olXhprlGJO+spyTgtoMm0ahk4Y+BOwotQivwkJW5J+CqmSIn8J65iTouXMOiwqXgsI7wkY2HUifCpe2fjDPwm7Gy77+8ChlCF8OBaC1lOcKlIMi68Ja+nOGghFxRclN7ChBCDifwkYyQOvCQvbRh4KiTCkRCQk/gsokm4LuR4Z+oL+GsluC9vvCQoJ89J8i68J64tnvwsaCB8K+nsT1Gw4/vv71dNOCtjOCgvcO6OvCQgpdx8J64uwo6QjhT77+9YXngso9r4b68JfCRipd977q3L/CdkrTRqPCfn6Jc4KiQZuK2k1zDrUrIuvCQk4pfODzDnwoYQhbwkIulN31t8J66pyTwm7KC4LKvOi48Ci1CK/CflbThs5Fg77+9Ziwm8JatllXwn5W077+94KuqN3tgZFzwq5+5KvCRnKIKMkIw8J+VtHXwnrmLIOKzvCPqrKjwkZKye+CupG0nyLokyLritbDCpXvgt5A/KvCfobdkCgpCCO+/vSZBLicnCkBCPi87MeGJnTzvv73CpTTwn5W08J64teGlsWDgsaHwlqqOwqVcP+GtmCrwnri5Oj0nfWMx8JCepvCcvrPCpSRMCixCKsOo8J+upTzwnZiaJ3BELHs9IHc4WzQ64Ka/J/CdlYNF8J+JkPCRjI93YgobQhk/QDzgt5Eq4K6OYuqflsK5wqV777+977+9CilCJ0Hitofwmr+5Pz/ivYLgrbbqpp7vrJfgq43wnrmbJEhfP2Ar8J2etwonQiU/VPCeuKF28K+huD88w4Tgtr3wkLKG8JOKs08l8JGWiz3wkaSWChdCFfCflbRcM/CRiojwkJ2m8J6FjiLRqAoIQgbCufCeuKQKEkIQ8JCKhOqshSXita8m4LuGJgoVQhMvw7nhnbPgr4FgPyThjocm4reSCiJCINqxXPCQuawq8JCCkcOtL1olw4LwkaS+Lmg/Jk7wnrmOCj5CPDE1beG/h1Xgt4HwkaSpw5PwnrmL8JCOlM6M77+90agq8JCguD8lICnhoIw26quh4K6jNeCxqeGNqtGoNAoYQhYkezzwkbGl8JGYr/CQvI3wq5+2eCA9CkBCPipM8JGckvCflbQjVSog8JGKjSdhaCo/wqXwkKS/JfCRjaJmNUjDiuqsheC5jCfqrKzwkY2L8JapuyTwkYqhCldCVTBB8JC8ku+/vSJr4Lis76y68J2TrsKl4Kyye+G0hHk88JiImPCRrIbwm4Se8JCgnPCQo6Pgr6/wnoKP4oGwZPCdi4vwkYWF6qyh4Lee4Kug8JGytlEKGEIW77+9e/CdkavvrKBcTvCflbQq8JChgAoEQgIuJAoSQhDqrKrCpVTwm4qh8JCCpG9XCihCJuCuo+GqkGDwkL638J65tS5Ye/CdlYTwkKuP4Kme8J2MjOqsplw/CgtCCUnCvTpN8J+fqAoaQhjigq/vrZ/wkbCHTCYkSuCruiI+ZO+/vSIKSUJH4LKO8J+bpiXCqfCflbThm47zoIWs0ajwnrKZe2/gt4ol8J+VtC7DqFhD8JKRseOHnO+lq+Csj/Cdnrsl77+9XPCdvKZcJyIKEkIQ0agiYOKCjuGlsHQm8J65mQoDQgFZCiJCIC9cUPCdjbBLXHHitbA94KeN8JGLp2BSIsKlJTpa4L22CiVCIyZbNidaL3s9SOCyn/CRkaDhp5rwn5W08J+fkid6MHvqn5E/ChQKBG5hbWUSDEIKaT3gqK8lWnHDogoPCgluYW1lc3BhY2USAggECsYPugHCDwrPDgoHY29sdW1ucxLDDrIBvw4KAkIACgNCAX4KL0ItPSZ7JjDhip8/SuCmnG8/8JCkv1M68J+VtOCts+K3ns6p8J+BvC9V8JCjtGAqChRCEnB7S0/gp53wlr+iJVwm8J2ctgoXQhXwn6CKbmzwnrmJyLo/LtGoSSc5JmYKN0I1JyzhvYrwnrmUJOC7huaPqC488JCyn9u3Pc6GUvCdhqMuMfCdkZ98L8KlIjp48Jq/vfCWvIkKN0I1bX7RqPCRp5MvSirgqLN0KvCUk7cm0ajwkaeb8K6loyVdXSRB8LKHlfCRk5Dwn5W08Jq/ujMKMkIw4LK8YExi4KyQKsi6dDpr8J+VtC/qorVmJSci8J+vgMOJJS8s8J+VtHsvfHHRqMi6CiZCJNGo8JGMqn09eeCote+/vfCav70uPT/CpUQ9yLojRcKlUOGMkgoZQhfRqGZ+PS7wkJOewqXwnrSh77+p8J+VtAojQiFIYHnwn5W04Ki18JGkvyole3sr4Z+pXD8j8JCHsPCfm6oKAkIACgpCCOK1pPCfooEqCgxCCvCehY8hUc6MwqUKHEIaaHN88JGmpS466qW1w6o8bdGoLuCuqvCQprUKGUIX4KCsPvCRqbvwn5W0L1w9LCYk8J2SpTcKJEIiV/Cen6s6PT/wkpG04b6nV8i6IlhcPCPhvZPDuMi66qyNXAo/Qj0/4aKacSZL0ajwnZK7w4bigbA1OeCrovCrn6l6LvCQtIZ2Ssi60ahcYEDCsjoiwq/wnZS9Z/CegITwnoCqCglCB8Klw58nJWAKQkJA8JCEkMi68J+psHnhrZ17wrXhqqnCpSbwkZyCezlBe/CflbRu8J+fsCrwkbyoSci64LOiJPCRjI880ahc4KiHPAosQipDc3ck8Juxt1ojJiIw6qC44KGibCrgpojwn5W0L1F7yLomMO+slPCWvpsKC0IJe/CQhpM9Wy4/CjpCODoi0ajwm7KEPSZN4Ly6OiTwnoGpw4Nc4LSPKXsoPOqso/CRtawv8J2qoSXwkbWUbuC/mislLMOcChdCFSpe6qWz4rSj4b+ZOlJtwrDhpao1PwoHQgUo8JCAiQoHQgXwraavLgodQhtcTDgu4YyTKuCus++/vTDwlqmM8JCohu+/vXkKMkIw77+94Keg8J65l/Cav7V78JCEgGBrPGRtYMKmPXQ54LOhb00nPDzwn4KqZFRI4YuCCg5CDPCRqbZXM+K2pOCouAohQh9WdPCWqZbwnqKeLzrvv6jIusOCRuK3mD086qeq4KqyCitCKWbwkbKpJsKpPjzhpbAmPPCetLvRqPCQlrs7N8KlR+CugkMm4LGa4oGQCjtCOS49feK3iypc8JGWmuCujjQmPSZuJmDqrZsm4LOiZ2RNXOCrh2Dwk5GJLPCWq7QuwqPwr6KvKuK2pgokQiI/P+GKuSU6L1oqXyUv8JChhELwn5W08JGKjCTvrYHwkKiPCjtCOcK94byZPO+/vWA6OvCdkqJHOmB74LuGyLrgt7M68JGKsFw7KjAuwqXinLovfDlu4oKayLo68JCWlAomQiQnKiIiPcKlwqUiQ+GLgMKlWyfwkZeGKibDr1Lgrqou8J6gs1wKNUIzVzrCpeCqgsOiYs6M4buv8JGlkCQgw4zIuvCQpJAufvCWv7BA8Ja+lCd58JGbhiY/4b+WCgJCAAo/Qj0kTCvwn5uxL0FH4YOH8JCtuS9gw4tgIu2fu/CdhITCpfCXqboi4bC+e0o/MvCRm4E8Rc6467y+IvCQgYBGCj1COzDqrLo9wrdsw7Hwnp+3L1zIui/vv73Iuifwn5W04KecPfCdqqNlMifvv71CwqUh8J+gvOGAgSfqr7giCgNCAVMKTEJKP/CRpLdK77+k4K2MXCIm4Kiw4Z+lyLo9JXXwkKSNwqXhp5Hwn5W08J+VtOCosuODme+/vcKlYC866piA8JGMkOG/tOC6hDzgtLQKJUIjP/CQiqA5OvCRtqfwnp+pYHLwnrqD4KaWLuCqsuCosDfcvD8KN0I1XvCehLDwkai0NPCQgZnrhbRI4b+z4KyM4oKqICHwkLmiIuCwvS8q4K6V77+9duCoufCeuakKMkIwKk/RqDzXsGI98JGwgyQ/8JCos+C6hjzgsKPCrDwl77+98JGNkPCbsaTgqLwuM9ySCjNCMS5fLmvwn6uZbuCyvil4ItGocXLwkZOUIvCfoJYyXCbhiZDwkKCT6qmT4L+M6qmTKj0KCEIG4Y6Pe2U4CjJCMGR7Ku+/kvCWv7F78JGaplxl0ahE8Jq/t+GDh0dS762E4K6vbvCWqqPhsr1m8JuCmQoPQg0qOkEuUSDwn6mkwqV7CjBCLvCflbTwkamUXfCQgY0iT1dNbC/vv73IujzDqsOYasi68JGNqUI9XCLhi43ipogKJ0IlXO+/vPCfoIZd8J2SoiLwnqWe77md44ib8JCrguC3r/CRh6MmOQobQhnwkKulOdGoTHh5J8K+PfCQoLzgrobwkZGfClIKBG5hbWUSSkJI8JG0uuKBseGkpci6yLpDIi7RqPCRg6QnPMKl8JCNlz/grbVP6pKoPPCQgKzwkIOpwrXwkKiP4ryWOuC4uTll8JCjp/CQg5M/ChoKCW5hbWVzcGFjZRINQgsnRD/gqLMww7RcOgrqA7oB5gMK+gIKB2NvbHVtbnMS7gKyAeoCCiNCIfCego9ge/CeuZ3wkbapYOK3rvCRsYDwkJa8PC4+JuqgsQoeQhzwn6+3LTzwkJW/8J+ts3vwkYy5zph80ahh77+9CiRCIiTgsKUk4Ku68JGckvCRsqJte/CflbQu8JCdo25vUsKlPS8KEkIQ77+9efCRpIQrIkbDmO+/vQolQiNrN+Cznnfwm7KZPO+/vWoiN3sk6qmY8JCguGA/LjzwkJ6CJgosQirgu5/qmo8mP8OYJfCfoIds8JCMkC7gr5d8SfCeuKfvv73gr4pM0ajCpToKMkIwICEq4LuCViDhna9KPPCWq4nwlq2QTyZ4JNW7WX7gq7nguL9CZHtiyLrwm7GweiY3ChpCGCfhsKMqKfCflbTIuvCdi7Hho6riuowqLwoPQg094aCX8J2Fl/CRpL0vCh5CHFLDj17wkJK74KuqM+CslD8kPvCeobIvOyJvOjwKE0IRw71EYMOw8Ja9t8O38JCMkDoKVgoEbmFtZRJOQkzwkLmlJfCQq7PfiWfRqPCWrZlJ8JGMmvCdkqLwkJafNuqUpfCdlKfCpSc48JGKiPCQgrkiJnvwkIy1J3Q677+944e/8J65uvCQobZ7Cg8KCW5hbWVzcGFjZRICCAQKoxG6AZ8RCvsQCgdjb2x1bW5zEu8QsgHrEAoIQgYq77+9IkcKA0IBLwoHQgU68JCjtQoFQgPCpyQKQEI+44ajQi5c8JCAvPCdlLV1PDA6azxg8J+VtGXwkKGE8J2qnEE/ZUjwn4Oj8JGMs/CWpbxs0ajwnZG30ahpJXsKKUInbu+/vTzvv70u4Ki+UT9CVuOBrPCfoqJwJSLwn5W0Ol0n8J+XjNKYCgNCAVwKOkI4L/CRo6bwkYu08JCMsTDIuiEn6qylay7wkam88JGZlOKRiDVlIHHDsjslW+Gds/CRjYgm4LuDVzoKLUIrRFzwkZeB4Z2wXOC0jz/zoIeSPVZYPFkm8J+gifCflbRxP/CRsKfwkJOdVgoQQg7gqrPgupXqoLMiTFwiOAoVQhNp8JCehXV88J+VtO+pv1B1zog/Ck9CTeCxiDzhv5LwkL+G4aK6KfCflbTqrKM98J2qqi9n8J6Cj2jwmKKzzofwkYuwJOK2rfCQpKHwnrq0d+Cxh/CcvLopLyTwkpGw0ajwkYO0CiZCJCrvpI5kJOCokPCtjoZ3XPCRtagmQj8iPMi6wqU/cNGo8J2SvgpBQj/RqH7wnoGjP1du8JG2pMKl4rio8KuduFzgt4rwnoCKP/CflbQn6qmU8J+VtCokJj0n8J65gvCRtpXwnqWee24KEUIPJzwuPCon4rSP4bCSZy8qCkFCP/CfpYomaMKl4LmQa/CeuLZdU/CQqJLigbHwm4WVyLrwkaS3X/Cfn6EvJOCqkVxR6qCIJOqftjpGfMi68Ja8iwoPQg0qYO+/vWU9wrwiwqY6CilCJzpbJO+zvuK2gFzwkKa34b2N4Y6LJVxlcOGLgGAiXOCqs0RT8J2LgQo0QjLwlryCecKlIkXCpW3wnLy48J+VtE9v4KiGP/CcvrgmZjxYPuCviDHwnoCB8J+VtGQhJAoFQgPvv70KF0IVeTxgNCRY8J+RstGoN+GqhzDwnrmdCjJCMOGMlVg54ra98J2qn/CWrbNiPzonXSotScKlPMKmPH3wnp+pXD/IusK88Juyh+CvhgoUQhI6yLpLIio9aE9m77+9PCUkJmQKG0IZXM2/fCc6LzxgJu+6i/CRm4TCqnA18JuBhgo5QjfhvK7wn5W0NmngtpAiOivvv6xKJ/CQsLIvP++5nPCdlI7qn5N7YCRPJ+Cwjzwl8J+fhUngqLg7CjRCMvCRqKhGa/Cav7cs8JGKiPCQoIgvP/CdhZfvv70uPCg/wrjgraJl8J6An8On8JajiSRxCkdCRfCfoZDCqfCfhIngroh7Sinwn6GWYCXwkbCD8J+qhPCQrprwn5W08JuFu++/vVjwnaqdTj/RqOC3mfCeip9P4KOF1p89RAoiQiAq8JCunFngoLTgu54i4b624Lql8J+VtCJM8JC6sXtgJgoqQijCvvCfiaXIuvCfiaDRqOqtj8Ku4YuUJ9aD4Kat4aGaJiMqUPCen61ACjFCL/CeuLlB8JCkv0Tqn5F78Jq/u/CQtLDDvXsn8J+VtOCoueCzhvCflbTwkKeC4Y6QCgNCASUKJEIiLvCQraJF4KKn4Z2uRfCflbRdw4U/8J65mTrgp6JM8J+ggQo6Qjgi4LqaaeqcvmDgrZ3gqr1cYtGo4LaR8J60oSdzTW5bRDwiw7Dgt6s6wqXvuatMzpdOOmDwnZKePAogQh568J65jS7wnrSwKi8qJz8hOsK54b66JFwtJvCSkpkKC0IJU2VxOlMsKsKlCj5CPO+sgcOqOOCnsPCRv6Q/4ZyH8JG1pfCRlpfgspcqRGfeiT8u8JCTjW3Cpe+shSpg6qayPfCeuZ/wm4WlawoVQhNW8JGNs8i6JNGocG4i8JGyo1wqCjRCMsKlLiouJ9Goe1LDhe+/vfCfgr3RqD8q4Z2zJOGHqvCRjJBh8JGNhyonRCl4dV0m4Ym+Ch1CG/CfoZfhvZ0nPci6Pjzwn6GR8Jy8kMKz8Jq/tQoUQhLwn6Cz77+977+KWnUo8JCWrioKOkI4Ji/IuvCRjYwoNlAu8J+bnmTCpeC+uC5mLuCghlVcLuqsrfCQi609w6jwn6m08J+VtDxO4Z+lTDwKHEIa8JG/pWDCpfCQuqtdXMKlRfCQgKjwm4WVL3oKKEIm4oGNKu+5sOK5jyYn8JapoPCfg4xT8J+vsvCfrapUwqhTOSbitqoKQUI/ZDFgVj1Z0ah94oGx8J2qnT0/4aSmw7wl8Jaqu1rRqOK2qPCQoa/vv73wn5W0YPCflbQ6JfCflbQ9e8Kp4LeKCi5CLCvwn5W0TXEvV+GxrOqhh3jIuuqfk+OCpPCeuaRoXcKi4Ki5yLpZU+GKvDw/CgZCBPCflbQKDUILfU7vt4/Iuj1EzpMKFUIT8KutoOCujvCQuaY8b0lf8J66hwo/Qj0mwqAlUcOzQPCflbTwkZKoJPCego9c8J+VtDzwkJ6CJPCQtLZPPEwkKvCfhJ7wnYuq4KmMJPCbhLLwkbWCCkdCRfCQlpJM4ae577+9JPCXm7/gt5PgqLbwkYihQVzCpeCqoyZu8JCLq++slvCflbRgL/CflbTwkpG08JCUksi68JGMgCY9bQo0QjLwlr+w8J+puC9i77+98J+VtC7Iuj8lTD8qXGFaP+K3o+GJmOGOkeOCqOCuv/Cek7VHPQovQi3wkY2I8J+bonvhoqLCpfCrnpxYe+GpuyfwkbaR8J+EiHt78LG4i/CeuIF9R0wKLkIs8JCWleC6ivCav7o/Ji/wkKeF1Ljwn5W0LvCQqLonPfCRjI/wkJacw4fjgZQKMEIu4Lqd8JCkuOCxhjpu8JCurfCQp6574oCFdDfhqY1xyLrwlrqZNGPwn5W08J+VtAosQirIumc8O++/vcKvdlrhiqHwn6uEP8i6WE3wnriubsOzSvCflbRcNG/vv70KDgoEbmFtZRIGQgQwe0xBCg8KCW5hbWVzcGFjZRICCAQK0wm6Ac8JCuAICgdjb2x1bW5zEtQIsgHQCAo5Qjfvt48lyLrwlqOoZnM98JKUsmfwm7KdIvCflbR9KiJrXvCRiIA/XMKlKlrhqbPvrYBP44S/4bGDCixCKs268JuDhHrDpSox77mrdvCfg4XjhJfqnYvRqO+/vTzvp7zDplw8KXA6KgoMQgrikoY977+XWS4nCgZCBOGzpzQKAkIACjxCOvCRipEv8JGEu1x04LGE8JCohuGwrz3IumTvv73gs6BzwqXwlq2sPOKukuG/s9GoNFrgrqR7ZCUqYzoKF0IV4ZykIsi6Pi7wnZSIXOGlgGPvvblgCj5CPN23YEHCpWfwkaWWKOCro/CQh5LwnoqkwqVc77+977+UdyYq4aeS6qir4LuCXOCzhvCeub7wkYqge+CzsgoXQhXqoLUn8J+bumQsdmDDo/CRu7jgsZ0KHEIadmDhsZ9E8JGnoCrCpU9O4KOX4oKsMO+/vTgKE0IR77+94LOsbzxIM8Kl8JatvkcKMEIueysvw4nwnoCQL+C8hWDwkJ6ywqXeriXgraI98JCWrFvhqohY8JGkgyXwkbS6PQo+QjzjhKFz8J2En+GnliQk77+94KGewqMi8JCms0zvv71jIPCTj6E98J65kt268J6LiFpgOkZjOklD8JOEkyQKPEI64LC2wqVhbj094aa+RPCRorvwkLSm4KyuyLoiPT7wn6aCJ+GdgsKlUic6P+GfuSpQ8JuGqfCflbR1NAoOQgzqn5Ng4K6ZLnXgp4sKJkIkYPCRirrRqPCRgajwq56d0ajwn5GQ154uPmDgqJDgrY3wkbWoCipCKD0q8JCUl/CQk6Zv4YON8J2Aueqoo17vrLhjI+GdjCTgrJ7wkL2xNjoKO0I5YDrvtqPwk4mVLy3wkKCILiw/JT/wnoChaPCdqp4u4Z+lYPCQpL/CpfCQhoTwkJahc8KlP2Y8VFxxCiZCJGfwn6msZci68JuwpuC1h+CinHrwn4e98JC9u+GAkCRaLu+/vQo+Qjw98J6ktuqflzzwn5W0OuGJnOC3lnzCpfCbsphrJCQ60ajIuiI8UvCesofwnYup8JColXk9UvCRmoLhsKgKQEI+4LqEJ/CQlJXhg43vv70vRy5cPyLhv68/bfCRjbPwnrm+yLok0ajgr4bwnZCjR0XwkbWB8JCFvirhpI7hpoEKB0IFSfCRhoMKAkIACipCKGxEwqvwn4OnQfCQh7PRqE1O4aabJ2B2OeCqqz0/S1zCpfCeuIZrJDoKFkIUYEHDmVwi8J66qfCQuqFiZC9W1LsKJUIjYCvwkai68Ja+lSXgraw8JyThpKZw76yAOmDDj+G9mTwxWmoKLkIsQnNcXPCRsYLwkYSr4Yq7JuC/mTwq4LOK77+94byvdlDRqDrwkYGI6q2kWmsKIkIgcGDDoyPCq+C0jsKl8JGNo/CRjLbCqCbwnZGlwqXhlaAKIUIf8JCTou+/vT3wkbyA4KaHYGpNaCdY4YmTfcKlfuC6qQo7CgRuYW1lEjNCMeGaol1Y8JGBhl4kXPCego9zKj1g4LKz77+98J6Lvzrvt4/wn5W04aOqPWYvw4YuaCYKLQoJbmFtZXNwYWNlEiBCHkjwkKCi8J+VtPCen609PC42VfCQvLPwm7KTUmA6KgrqB7oB5gcKvgcKB2NvbHVtbnMSsgeyAa4HChBCDiHhnqJccCJsKjDvuZwjCgpCCDrwkbGTPS8lCjBCLkHvtqU6JMi6LvCflbTgsYjhp5MlWvCRipsn8J6Kl0JF3qLwn5GHw4ouKvCRg7UKPkI877+98JG/myd7KmDwnZO244e78JGMrSTqlIh48JCghHsiJiXwkKC8QiZSPOC3svCdm7rhv75CdEU/ODo5CkNCQdGoOvCQm6XwkaWXw7jwkYih3oXDreG9kmwiXW3wkYyr4LKWKuCsg+Coj1rvuYLIumAuMOCmrfCRhazwkb2Q77+9CjdCNeGjsCReXOGJmPCRhrt8PC5GdcKlOjxEwqjwkI6ZKuCuk++/vPCRhYXwn5W04K2IcSUp4K63ChFCD+qWvfCfiZFkJuqiuFhoPwoMQgrwn5u5evCdlYM6Ci9CLeCrvVzwnruxXOC7hivgpq3wkIGDUVzwlryZRSHwn6qXYD/wkZGP4YmWe+GohgoyQjDqr7nRqCTvrKc2QvCQhpFk4KerL0clUCVE8JKRsVw9ZXEu8J2SpfCRgr8nw4RaYGgKEkIQ8Ja5pXs98J+Il8K/KEc+cgofQh3hhqZlJiQn8Jars0vwlr+iJznwlr+w77+98JG1gwoVQhPgrprwn6en4b+077+9w55cNUFPCjRCMtGoYMKlTjg8cmDwkKmYLCYk8JCOpy7wkY2QP+CwstGoKfCQgL3wn6CIJOC2nfCQhKA9CgpCCOCsgu+/vTpcCj1CO/CvoI4y6p+T4aCMwqXhiYvDnMi6JvCQkr7vv71g8JGFkzfCouGptPCflbTguYjwkJaPOsKlcD3wn5W0CjJCMPCbspnwnrKgJiRN8JuynCov8J+VtGzIuldS8JCUvsOPwqU977+9I+C3mXRt4YqyWwogQh4q8JGMvvCQp5p78J64g+CzsvCflbTqo6zgvKEvLicKSkJI8JGEnfCdkqlvPOCmmnvwkKSsJvCeuZTwnZK7w7hRUSZb8JChtS7jhZrwkLyPe+Czg9Go8JCLhlbwn5W044aj8J66pmbwn4OsCgRCAsKlCgVCAycmJAobQhnwkaObJzzwn5W0T++1uj1N8Jq/sfCfnppQCidCJeC1s8i6wqXtnrpQ4bK3w4574ae64Ka34KyMwqM/8JargW/vv70KDEIKY3wlwqXwnp+2YQo0QjI28JCSoSol8J66oyLgtIcqSDrwn5W06q+58J2VhiJnJeGLhT3graDCpfCQk6jhn7LCpQoSQhDgqIfCpTrwn6qGLtGo4LK5ChIKBG5hbWUSCkII8JCWu/CQpIQKDwoJbmFtZXNwYWNlEgIIBAq0DroBsA4K/Q0KB2NvbHVtbnMS8Q2yAe0NCihCJirhiaEsPPCfoKI84KGeU0578J2ps2cv8JCtgvCRsJls77+VQ2s9CilCJ/CehY7wn5W04KqQOSY8KtGow7Q8QD0vdDDhs4AvWERB8JGwhOC2tQoeQhzhv7clPGritqrwnqSPXC5S8J65vvCQlo7Cry8lCgRCAmwmCitCKfCRp5zwkZOSZeCyqvCflbQ0XHlS8J2Uri/DnSdNYMKl4b2d8JGDtkh4CkNCQWrvv71c8JiZk/CdlY9QeFlo8J+VtH7wlq2bKHs98JCouPCeuKIvJPCegLhZIvCRsbjtnrXwkJyz4reSTPCeuo17CjZCNCFc0ajDqsKvKi4yKtWVKXfwkbS/UU4lYOCqrOGxrGnwkZy2L/Ccvod70ajwn6ulJD/qqZEKOkI4L3AkISfwkpCGasOg8JGqvTpqJyXwnoGnIuCpgO+/vT084Lqo8JGFhvCfpr/hvZs98JC/rHRg0agKPkI8PC9o4YmMKiTCpXHwnaiSJyUg4K+X8JGkveGDh/CehY7CqvCQtKd9J1cu8Ja+n+K0pz0lwqbvqpE3P3slCjhCNvCQkJZDe+GylOC7mTcn4b+zS8i68JCjtC/wkJSgJ+CnqeC6pT068JCKquC6s/CWvaUkJiUzegoKQgjwn5W08JGZkwoRQg/gsaInJCrvrL7IuuCnjTwKIUIfwqU6X2AldG4v4KaJ44eeKPCQq4Q/JTrvv71gcjFYSgoDQgEiCiFCH/Cfoqtl8JGMrsKlOlbwnp+uKlbigqfwn6KhJPCRnKkKCkII4bGyTlc6JG4KA0IBNwo3QjVPIlxe4LSQb+Czs0hP8J+VtPCSkIHwkJ654KaPTDoiMfCSkZTguY1J6p+T8JCWuSrgt4psQwomQiR8bT3wnruw4L+F8JGMpGki8JGKiiTwnri1w4/qn5YvOiY9Vz0KOkI4OSLwkb6w4KyyPSfwkbS98JGMkEngqqzgro7hiqU64LCP8J+ejvCdlLE5PCk/fPCRtZXgsJngvqwKDUIL4LOxP3vCpfCfgr8KA0IBTwozQjHwnrii4Z2yPUPwmLGu8JGKhCo0ezrwkYux8J2SotGowqlF77+98J66tndRUeC1h8KlCjpCOFNlJ/CQlLDwkYifPO+/vXs98J+VtOqvtPCRiogmWSE1Lmfhio3hrq9DyLo04KmL77+944O60ah7CjZCNPCQpL9kbCV76puiSSQuMPCfopsve/CeuLvwlq2SLiU/8J+ghkrwlqep8JG7ouGihfCQlI4KFUIT4K+XXGnwn5W08J6gkiTgv4U8XApFQkPDlOKAkfCWrZhU8JatleqSlCfwkKi4YWHhj7o08J+skeKAlVDhpYTvrIQwPPCehYPwkKKt8J+VtM2+0agi8JC/oyR2CjFCL2g94LKH6qCD4LGH8JGKkCXqrKTwn6mlIvCfq6F2YkR9VSohwqV74LeKbyp7fci6Ci5CLCIiQ+ComPCehYHRqMKj4K6qOeqBjTzgsZnDoGHvv71NPztP8J6AgHvwnYumCjNCMfCdkoU6ONGo8JCWoe2es2AlVi5716UuXCJcwqUmONGoJMO/IiXgrpA/6pKYJvCRsYMKKkIoKjw9PThz4b2JPMK78JCGmvCRkZ3Yj2DDiyI/WUBMTHtfJ2lxVeqphgo8QjrwnrqES+C2k1l74LOIyLo8IeGimWDwnaafRVA14LWMYPCRsIQuIeC5g8i6bEzwlr+j4Lq24K6e4LGICj1COzrtn6rwm4Wk76yUIlvDtDXgpo8/Ku+sucO34LeW0ahseXvwnrik8J6Fj/CbspxD8J+VtC9eyLrhv757Ch1CG2zwnp+8yLpsUTzwkKO8XPCQo7Vc4LeW0ahgYAoEQgJgJwohQh8/Jz3gu4YpPDFc8J+VtDngurVNyLrit4TCpfCRkox7Ch9CHVzqm4TqqZdq8J+EhyInM0F7ZPCQnoAsOsK6MD0uCjZCNOK1sD/hirtgKO+/veC1odGowqUl8JCBkcKl8JGkhvCflbTwn5W07Z6+YF/gsrzwnYuyPUcKJEIi4KGea0l7JvCRpq/CpTnqraTgs4hVJMi6PCjwkpS1JSRgSgoZQhcwP/CQo7VzKvCflbQ78J6FiPCdiKBNJwoiQiAk8JCWpVzgp5fwkI6hdci6IG3wnrmu8JuynHh7a2d7UAooQiZq4rWvVyXRqE/wkKCIKS7DvfCRsKomQvCeuZ1rMjJMJytSLy7RqAoVQhMvPD/qpq7CpfCfoagiYCDwnrmdCjBCLm9SZsKp8JC/ssi6IzYuKsi64K+H8J2XgCU6KPCRjYcqKvCdhpHwkbanKvCfq7cKI0IhSSLwkKiw8J65gvCflbTwnoWBYFAv4KmIPPCflbRcIFAoCh0KBG5hbWUSFUITJSThqqbCpT8mW+Ctl9Go8JGDtwoPCgluYW1lc3BhY2USAggECsAYugG8GAqVGAoHY29sdW1ucxKJGLIBhRgKSUJH4LOHL/CegIMkYSLCpe+/vfCQk4hHPOGnmCfwkIuN4L+EReC7g/CflbTwn5W0PDvwnLy68J2SosOQ4a2qReKukuGwsTrhv5YKFkIUJDo68J+VtCpaa+Gpse+5nfCeuLkKKkIo4LCIRPCQi7Lgt7Ik8J66o0ngt5bwkbSD8J2YuOC5gFfgrLAmW++/vQo8Qjo44K6kwqF78J65lCopVfCflbRa8J2TjSVgWuG/hj9S8JG1kSTwn5W0W37CvvCQq4Y6XDLwmr++JtyvChpCGOqnt8KlST/DmyRaPci6Rsi6wq/wkYyCOQofQh3hsLA24rujKuCsiPCRjZDwn6uVInEnJCfwnL2EeQohQh90bcKkJyt3JvCflbTwn5W00ahJJS49Q1g/8JORjVxSChtCGSViOirwn5W0Jsi68J64qirwkYyPJ0kuTEMKCkIIwrXqp6hDwqUKGkIYLfCRp4884LK28JGIiTol4q6N4LGY4Y6OCjdCNTXRqOGPuHDwnZO1TfCfgqDwkKmRPfCwnqHCpeGfuF9VMz/Dkyp78J2InSTgqLI84aqEVCYiCjJCMOGKp1w777+9akPwnrik17BEYFzwnaSuOnvwkKmD4aS5L0Aq8JCumS5g8JGwh1R7RwoFQgM/XCYKOkI4UvCflbQ8IsKl4KG9JS/wlq6OefCQi6ThjbB1SvCdkp/wkKiGIj3CpcKl8JGIr017JWfDtvCRi7UKBUIDWFA/Ci5CLD/gqqzwkJ2RL/CQjaLwkLSbIvCav7I9NOCovlHDo8KqNiUq4aKYVPCRl5gvChdCFSfvv67grK9J8J+VtOGqhX7igpwmbQoXQhU/OvCSkarqrInqn5Pqor4qJjHitYoKAkIAChVCE++/vCJLKu+/vUJYfPCQkpbgp4cKFEISPfCRrIjCpT928J64pOCzlVRcCjtCOXTvuZ084qKne1jvv73wn4iZen7wn5W0LmrwlqqYY8KlyLpi77+94KyyL2nCpTgqVM6+6qyD8JC9uApBQj9577+98J+VtCp78JChg/CQrpk/PD3Iulsk8J+VtPCegIZ9ffCfq7Eu4aGoXMi6ZCbgp6IucOG8nT0m8JCejC8KL0It8J2UiCbgrILvv73gs7Ek8J2UvOGguPCRsL3jgJ5cNtel77+91anDp8i6RkglCjZCNCliPSLhv7zwkIC1Zzxg8K2TmfCQiown8JGFp+GKvuC7i28+TvCQhI4k77+98J6AqeCgvC8KPkI8P+Csg2Dwnrux8JCkliTqk4A/8JG2hHsoIuqdkj8h77+9Se+/vWA+yLpPPGZa76y+4YuRw7hRavCQnrU9CiBCHvCav7rIum3wnrqVRvCWv6Aiw60h8J+VtPCQj4JcIgo4QjbCouG/l8KlPHtsyLrIunFb8J6Tnjw84ribe/CWro7wkY2X6puHRsKl8J64lFzvv70vJVzjh40KN0I1wqVR4KC3PSThqpHIumzwkbS94LmWNj3wn5CrJ+GatMOqIO+stOC7gT9+JjMi8JGNl+GqoCYKJ0IlJvCehYngsKcuN/CRsp/wnriD4oSy77+jWfCWvpQqyLrwsaWQNApEQkJ14YGS4LOd8JGwqdGoKlolOsKpV+Csj03DplrwkpC6L+CwifCRgaw8ZfCRtLrwkLGF4LOt4bCt4aeBOvCRpqMi0agKHUIb8J64u0QuRmDgpIouPHvqoJRT0ajhvZlPQTwvChVCEycudiTgs6lVPfCQgJLwnrm3JWgKDkIMevCeubvRqFbwnoC+CjBCLuC0kD/gpr89XOKzpCVmOuGOtuC7knrwnri5Xivgp7Xwlq2w4aOZ77+9NcKlJTsKIEIePnvCpT9HYDgqYOGyq3t5JPCeuptU4aS276y+J8OGCi1CKyrqqKvhnbPCpWZCKHZqe/CQrZIve+KDl1zgsZbwnZWG8JarpdiSW/CQnpcKEkIQe/CRnJd6JCbwn5W0wqU8LQoUQhLIuvCWrZvwqYOkJ2jwnYSi0agKIkIg77iNN8i64reG4oGxwqXwkbSJ4YuAw5Mr8JG2qXbvv70KSUJHRfCflbQlJeCsqvCfq4Lvv706PSJsw6NWa8OQ77+98JGkkGPqqIThjojwnriF4YuD4LeWJ/CQpKUi8JuyheCxoPCeuJckwqUKL0ItXDrwkYqxJSUn4aaRUi7hi4R5OuOEnvCdqq/gt4LivoxeOvCQnYHwnris4YaXCgJCAAoTQhE6WuGRlUBzR/CQgZgmOjlgPwo6Qjh676y7yLpm8JCWkPCfgq3wkYyJ8JCdoe+/vSQs8J+EnS8m4b+6JzzwnYyB8J6AnjwvyLpDyLoqLgomQiThvZvRqCXiobgm8J+Ahuqnq00nyLrwm7KcevCRjLcqPWp7yLoKJkIk8JGkrvCfg6E98J6Lg/CRg4J74Z2C44SOM/CRqYbwkZmkPScvCg1CC/CegIHgpZPwn5W0CjdCNVJPNvCQtIEn8J2QluGKiuCxqPCwlJhIWfCen7hAXFwvJci68JC8geKEnD/wnZK0w4TwnaqeCj5CPPCdhrQ1Wm3hvZ3CtTPwkIux4reIPPCfgqPgs6DIusi6aO+/nPCRmZZrOnPXsfCdkp7RqHdg8LKOqybDpQpBQj/wn5W0J9GoLnXhn6BZ6qaE8J64ou+svsOyPdGoQFXvuJDgrqPwn5W04Ki/0ag98JCWjci6JTPwnrmkUyngsr8KLEIq0ajwsZqB4KqR8JGMq+CrkD/RqPCQqJdlU/CRtaDwkbSAQmrwkLmt2JFeCiZCJPCfm7jwlqmd6q2PMPCeuY4nXFjvv73itqwk77+9IiHwkbWnPQoaQhjwlry04KyGQeGKptGoIk4/77+9L13gq6kKOEI24rKAJfCRq698w4jwkY2QwrEmJGfCpeCxonLwnZKEJ37wkIunNi5x0ahAPyRm8J66p+CunmAqCiVCI8Kl6qyE4KuFLiLwkbWG8JarhSdqLPCflbThp5rjhLTgt4VLCi5CLFzgqYx78J6kvVRzQSbwkbS6wqovM/CeuY8mJfCqu5vhprlc44aqVUbwn5ykCjZCNC89S1zwk4CU8JGLh1x777+9UjzIuuC2hUAn8JGKojXvrIPIujzvrLrwn4e9Z+C3si/groIKBEICJC8KKkIo17IibSBsOjwi8JuylPCRv5Tvv7154b+9LvCQs78uUCUuwqkyfeGwuwoXQhV0OnvwkbWqP8KlXHbhvbfwlryDYEAKEkIQ4Zqi35AgesKlayQ5wqrCtgolQiPDjiDgoanWj/Cei5rhnbDgvpxHei7gtqsnd1Av8J6AoyrIugo3QjXgtY468JGZkPCflbQ/8JCNkcOtbGE88J65hyTOjy0qIuqlqe+5sip58J+VtPCQsq5t8J+VtAo4Qjbigb3gu5zYiiVc8JGDtj/RqOGthjzgsIVWePCdkZRkJvCfm57wn5W0PDnwnoSw8JC6nvCfra0KIUIfw7508JCkgz3CrDzwkYKi8Ji0h++/vfCfoZYmL+G8rAozQjE0MC7wn5W0InPqoLHwnqKhSfCflbQv44COenVfN2A477+9J1HwkbS8PPCQi7vgraEiCgxCClU86qyFeOC/hHMKMEIuZUHXluGfteC2rybwnoKPLj/gqYc+PCUkKsi61Yo/evCWv7Dwq5+ZOuGdru+svgoxQi96M++qv/CeuZ/wn6yxUEZwO2EnPEZ24LqHJzx0ROqcksOrYlzqqbritrpO8JG7pwobQhnwkYGY4oizJ8i6POCostGoJGAvJvCQnYs4ChtCGWZs8JCohUXwn4mDPzR13phFXeGYv1jgprIKMEIuXCY6yLrvv6rwlqac4LGq8J6AgOCvjTolLCpPevCegI9j0ag7aSTguoFXW+C2gQobQhnhi4DguoR8Iiw6wqXvv5Q/L+CoiHnhg40qCjVCM2DwnruwJC/htq9d8J+VtDxcL+C9m+qnkO+/veGxmvCflbTwn5ucLmAu8Jy9nXIn77+9IgogQh7wn5W0V+C9jyJd0agvMz3DsvCeuLvgqoN58JC9giAKNkI0LmRh4amH86CGkSLwkaiXwqXDr+C2pNGo77+9ITxxJtGoNCElOu+5q/CdmrAkXi4nyLpcLAoRCgRuYW1lEglCB/CepKd7JSYKDwoJbmFtZXNwYWNlEgIIBArHBLoBwwQK+gMKB2NvbHVtbnMS7gOyAeoDCiFCH/CRjY07L9Go8JCrtj9CP/CdlJRgXFzwnrmUPPCRjIIKAkIAChlCFz3wnYKgyLov8JCouMK7wqXwnZq4PC5JChlCFyTgqYfwkJOG0ajwkayC8J65iy7wnrmLCkZCRPCYsqRC8JGlglLgpqXDgMKl8JCouO+/hfCfgb4/yLokKirgrok2L+Czqm7ihJY9XvCRtbzhvZRBUFLwkJK777+9wqUnCjNCMUbvubHwn6iA8Jarpy46JuCzglrvuasn4LS+8J6Cj9Gow55c8J6jiDwlViY68JCntmwKDEIK8JGcncKlRuGPjgoLQgnwkLqr8JG0hi8KCEIGUlTOkk8tCg9CDfCetJkvXS5gL/CQioYKRkJE4LGI6rKs8JCBh37IukjwkJShP+C8int7OvCRmaLwn4GewqUiP8KlbWcu8JCrnTfRqPCdlYYu8J66oSQ28JGysvCeuaoKCkII8JCLuPCflbQKQEI+8J+VtPCWrKnwkKmnfWAowqPgobjwkbS84K6cKmlcV8OG4oCi4r+1IiZe6qGcRVzwkYWSRVrqnqtgMELvt4EKQkJATCvwnqSwV08q4aKoLjt7XeG9m++tufCbgIZcJfCepZ86YOGkkUXzoIaC8J+pu+qpii7wnZWG8J+VtFhI4ramSQoeCgRuYW1lEhZCFPCQh57wkbKXP8OkJEl58J+VtCQ0CiQKCW5hbWVzcGFjZRIXQhXvv73jhKrgqLzit5F88J66iT/gupEKhhi6AYIYCsQXCgdjb2x1bW5zErgXsgG0FwoUQhIw8JuynDtc4amLMuCpkSN20agKPkI8LO+/vSrwn4emyLpgw5hN8J6kiC5PPUDit5rgsq4m8J+qmiZwQ/CQj5Lvv73grqpVJuC9ifCflbTgrpx7CglCB08q8J+VtFIKOEI2P3fwn4OI8JG1lfCflbQ64KCzPe+/veCwou+/vT3hnbA8wqvwnoqQ4bGHYPCWrZk8cMKve3tJCgdCBfCdkqV3CjpCOOGhp+C/mvCWqaYnJzXguqVNY+C6hyknYFxgLtGo8J65jyo8VuGhnybwnYSJS/CRnKBJJz0vRdGoChNCEcK/e+GAiUjhp4IuIuqgq145ChBCDvCbspdb8J+IoUzRqEkmCgZCBPCen60KOkI44KyCUzrwkKi6SifIus6PIVovP/CRkI5s8JORkCLvs5s/T+Cxo/CQqZUvIjw/6p2W8J+VtPCYtIEKREJCXPCflbQuXeKAsCrwn6uQwqXwkJatw73grL7wnZWAyLrwmLOHIyXwl4S/dPCflbQ0w7TwnrmC7Z+58J6Lk1N4eDJfCkRCQuCnl8KlYCIu8J+VtOOFhDwn4K+Kw4bwnri7PSfgv4VcXOGPmy/wkY2e4KGeevCRtpHIuiLwn5W08J65iWBcJe+/vQodQhvgt5vhv5tbKvCeuZJM8J6EhNGobGxL8JCoqXAKHUIbQfCQppIiwrw9IiLhirnhoIg/77+9KvCRm4J4CkVCQ8KlJSRc44C88JCBgNGoZmp777+98JColvCRtafwn5W0M/CQk5NhwqXwlquC77+9LyTwkJq0yLrwnoS6OkMmIuK3m0AKAkIAChZCFPCfqbPwnoCT8J+VtMK8TGDRqEUnChRCEiXvv70mIDpO8J67sSdu8JG2kAoHQgUqQWAgcwoGQgRw4ZuGCjpCOOioluGJmPCQo783OvCflbTgqLhtMz7wkYKwLjcyJEXqnbVRTfCdk6QmL+Csg+CwmuGvje2esjRqChpCGCRaLuKvj/CfgKbqq6MrS/CQurAlesKjJAojQiHwnri2IilgbScxOuC7ji4vYO+/m/CRspY/W/CdvKjvv70KC0IJ4LuGdjfwkKukCgpCCOCug/Ceuqc/CjNCMSIuJzA/bDrwkI+N8JGBljLhratc8JCWvPCfq4IiOmzwn4er4YON77exU8O1aPCRjKwKPkI84LGGRe+/vWzCpSYy8JGjocKl8JarkNGoLkNMZ2Dgu4bCuyUm8Jy+j/CQtIrCpVfCvuGJmFwi4KmeJCpkCjRCMihXJFIn4K+Lej0l4LuI8J+rpiLwnriK4K6e8JCen3w98JCHsifvrKdcQkDwkJa74rqKCgxCCsi68LC1jPCQs5oKS0JJLyc84LSFPMOKIDzwkbWo4LuA4KGVKjDwn4Ss8JCMlO+sg+qghe+/veK2kOC3nfCegIMvQfCfg6PCpfCRtqPgr5An77+96qOZOgoDQgFUCglCB+CpqfCSkZwKN0I1OjjwkaSEUz1C6reIJijgpIw98JCFkHtcJuCtiz8/aURaNj9+PC518J65ouK0rXvRqPCRmrUKRkJENGPwnZK48J2Tg+qspUY9WvCRmapu8J+qv/CbgLBf8JG+sD0mwqXRqO+/kz8nyLpo77+uOOGKte+/vfCeuIHwkZyiOnoKCUIHe8Kl8JGkjwoKQgjwn5W0b8i6JQohQh8qWfCvo57CpeK3hC/wn6q/8J+VtCLhtJbCosi64LezChNCEVovJSLwn5W07Z+2JNGoc8OjChlCF/CegIXgsrhH8JC5qVLwnZKv6qORPX0kChhCFk5FdT1c8JGBpPCdk4PwnqWVVSrgq7wKQUI/Isi6Um3grY17w7jwn4GGSTc4YF908J2VhvCeoJXwn5W08JCWvDvvrLknwqVMIuGojyfhvqY/8JGRncKl4YqACjNCMS/wn6+0PDzwkKC8d34rP/CfnK9u4K6c8J+VtEZcw59qPXLwmLK6L3dg8J65qPCRjLUKH0Id8J6AoyYk4K+Q8JG0gPCQmJg28J+fsOqtjiLqqJcKBUIDO2AnCj1COybqqYbwkKmYJSpQ4K6a4aCQ17I6yLrwkayFJOGekSfwnoCp8Jarsz8mYHLgrp7wkpSJPcO+6qqg6qeRCg1CC+C7kvCdjabwn5W0Ch5CHNyGKiRnyLo68JGlln5nLjgrwqVc8JCMofCQlrcKOUI3ZeK3jvCfoZDqoI3CpS464Yq0JeGygCgtTPCRpJAiP11+77+9auqshS/hiZ06Oio6JcOzIuG9kwopQifwlquh4LSJ8JCWueGfmDw8KvCfn7BDdk1m8J66oyJ977+9KsK8XDYKDEIKez3wnrmU8J6BmgoVQhPwkL2R4pGG4LuS0ahs8JGxg2w9CiBCHjUu8J+vuOK0ilxg4ra4Ij3gqrPhj7wk8JChiCIuIgokQiIjwqVL8J6fvDowIMKn4r+VI+GLjeCuiXttY+CwhELwkZiKCi9CLUfgvaLDs/CehJ9ULi9mJTjhvZ3vrYNgPycm4Zqn8JCGm+KBsOCxujbDuuG8oQoGQgRcPntqCjFCLyhsIfCQj5Lwn5W0XDty4K6jZfCflbTgqYBe8JG8hyd3IuK2tvCqoKHwnZKiPci6CiBCHlQ4Ok8ubsKk8JGgnVnwnrqCOu+nvyhhyLrCpS5gewo6Qjhw6qyp77m077+a4YuD8J+JpWUpP/Cen6lzJfCTkZHIumDgp7Tgq5A08J65vuGDhz3wkbWl8J2UlgoEQgJSfQoHQgXqn5A9ZQoqQijwkZGhWyUuJ/CeuYfirb8nUWdmXE9n0ajwn6qB8Kq5lSXwnZSJaDxcCglCB8OvJOqSmGoKL0ItOO+/vdGo8J+qiOOCgfCeuKE66qWP8JGMni9JYCZ7OiY28JGwiPCRkZ/wkLm4CgtCCT9cR+C2qyZ7XAo6QjgvP3tOP/CflbThoITgprLhnrLCrGR78J+VtHbwkK6cJfCdlYAh8J6AhOGDhy7hoqQnWFdw8JC5vQolQiN777698JGAk/CWv7HhvZvqr4VEZOGnl3MnPHnDh3tTKOCxnQoDQgEqCiNCIeqgivCQlo864aW0I/CeuYvguofwnZK9avCflbQvOnskQAo0QjLwkZmS8J66mO+8p1xBK/CQqYLRqPCQgJLCpXvwkJaM4LGVKlPqrK7CpdGoLvCfg6LfuQoEQgI8cAo5QjckIuquoGPwkIy68JGWj0XgqrMl8JG0uvCehJovbcKl77+9PC8iw6FTJvCfrZzwkJOLZDxb4LSQCgZCBPCQvbAKAkIACiJCIPCdhbLDpSoqP3fgqZElYPCfhoPwnaiAJvCflbQ/4amxCjhCNvCQqb0n8J+VtETCpSo/w4PhvZUq77+WJu+/vfCQlbYpR/CdjathcSQ0e+Csszxcw7PwkY2QMgoqQijwkICI15HgqK3wlqet4Yq58J+VtOC3psKlc0bwkYKZTzPwn4K2dVxgCiBCHkIl6p+38J2Ns8i64K6pYCcq8JK+lSTwkYWU8J+DiQoCQgAKGkIYPO+wluGJivCeupngrKJE8JG8gSrwnai7CjlCNyfwkaST77+9PMK8YPCQprPCpS9f17HgsabwkYaiJyQiw4fwlqm2Jns5w6NQ4K6kSsKoOtaALnkKIUIfyLrgrYgq8JGalCjwn5W0wqUhXPCego8iJ1pY4b2SUAo6QjjwkJabcvCRiozwn5W04K2EIV4i4LOL8JONm2Rk4K204LGYM/CWq4fwkaWWIid7LuCiiCUiIN2GXAocQho78J65nTBMasi6beCtoPCeuKpX4LqB8Ja5nAoXQhXhg4fwm7C2Ii89wqk0IuGmvOC0kH0KCkIIPS7hnbDCpT8KCkII4bGOyLo8Uy0KLUIrcELwnYieKnE+JvCflbTwkZaHPMi6OyDhr74v8JG8geGJi2Dwn4Km4ruxJgo1QjM2J/CQloZnSNGoK1o44LGdPTIu8J65mfCdorR38JCdpOGgi3zCpUs4OjkuVi5k8JCohXYKAkIACgRCAl5bCiUKBG5hbWUSHUIbLyRUyLo6YCfotIjwn5W06pKR8J+JkCpYXGAvChIKCW5hbWVzcGFjZRIFQgPRqDcKwAS6AbwECt8DCgdjb2x1bW5zEtMDsgHPAwoUQhLhn4vwnrmb4KCn4K+IP+OBmXIKPUI78J+HvvCeuZ3qoLHgsY3wn5+DPOGutz87QUrgqrjIuickJTM3JOGuuNGoYHtR4LCx8J2cjyVgby7hmosKPEI66p2H77+r4LqlR+GKuu+/vVwmIkQmw7l7YzjhoptQRDrwnZSRXeCuuC5DZfCflbTIuvCRtpHhiZI6Jwo7QjngqYvCpeG+uPCeuJ0v8JGjoW13w57gspAlP+GnmCxH8JGRoFNCUnNkOkpK8J64nPCeuKfqoqImPCcKOkI4JnzCpSLitZ0877+98JGMk9GoIsOJ8JGqnOKJg1bIuiVqOmPwkLqC8J65iTM84a2176yV8J+rkS8KN0I1Yixc0ahs4b2W8J2Tg/CWq5Iu4Kyv8J2Rg+GysMKlOt+WbFA9bTrwnYiQPHtnJz/it4g/OigKH0IdXPCQlqzwnrmsTCZW4a20KvCQjpXDrljRqFrCpSEKLEIqUvCbsobwkbGCYGJoJOChnmjwlqyN4Ymd4KqyPfCdqbngoaHhm4hLSsi6Ch9CHSfwkaORyLoqZuCmj0wl8JG0mibWvSfIutiVP0Q+ChhCFnXguqsmOTrwkpGLKm89Xi4l8Jq/vSIKRwoEbmFtZRI/Qj1v8JCrtjzwkYS58J+VtDdsw6hc8J+ekVxHKGo60ahnPT/CpSJc4LuY77+98JCWrydlPHLCuvCQqZbwn5W0Cg8KCW5hbWVzcGFjZRICCAQKnAK6AZgCCpcBCgdjb2x1bW5zEosBsgGHAQoWQhRySuCgjcO1P0nvv7zhpYzwkpG0PwpBQj954rSdRPCst4kvaCJceybwkLS24Y+dOl3hjYvwkY2XLy7iuY/gqLXIuuKDpD8m8J2Ii3vgtI8m0ah48JGMhSEKAkIACiZCJGjgqLnwn5W00ag944K14LKOcuCpi+CqkeG+iWnwkJ6HZOCwoQpECgRuYW1lEjxCOuqpkcOYdvCUl4ht8J2UmOGzgjzCpci68J+VtPCRjLLwkIyu8J+CpPCWrb7vv73vv73wnaqe8JCOq34KNgoJbmFtZXNwYWNlEilCJ/CRjZDwkYK+ezzwnYWBOiJBL3LCpT0tSTzwkICufnPCpXrgsYouYArPG7oByxsK6hoKB2NvbHVtbnMS3hqyAdoaCj5CPOCmn3svwqXhg4fgqLnwn6uhTvCflbQqJjwiItGo4aqUX8OZ0aguOtGo4Lue8JG0icKlS++/hj3wkbKGeQotQitrZPCeuLXwkbWTJfCeuKFU8J+fjT/wn4e/LmknZlpg4LK24b+7ez/gvoI8CgdCBSFs4KChCh9CHfCen6XhpJbhrbI/4LeYLibCpWUuOnrit5Dwnrm6ChVCE/CQs609YMK4a8Kl8Je0sOGmpz0KLEIqYHRc0ajwkKiGPTzwnrmi8JG0ut+kyLrwnrikbizhn4DgtY3vv70j4YmbCjVCM/CRqIsnJdGowqUvL/CWqaHwkYSh4LaBIm57UkvwnoWO8JG7qPCesrAmwqTwkbaU77+9WwofQh3wn6qI8Ja9kGAvPe+/vcOw8JCTti/gob/igbBCIAo8Qjrwn5W0Ssi6cydjZfCRnKHhp5PwkIC9bSZ7LOC3guCugiZ+Si7wkK6c77+9JTrwnrmNZGDDjfCRhLk4Cg9CDT3hoINi8JGKgSfvv70KHUIbXPCQpL9A4K+XcGAv44a/Li7wnaqo8Juyhjw9CjpCOCLwkbun8JCSv/Cdgbfhl4DhtIJq8JGNqvCdkIInfScmQVHwnZSS8JCKgWfwkZa7J8Ko8J65i0tZCi9CLfCeuLdTVNGoS+Cruy4vyLovPOChnnw977+9OljhqKUm4Lud4ra977+94LOecQocQhrwnZSF8JuxtmpsOypALuKAp/CQobPhvZtvIgoDQgE0CitCKUJa77+kMDPwn5W0QHPwnYul8LKKp++/vVzvv43wkI2KYz8q8J2UhzoqCjBCLnspO/CRhYQqMVhn8J64pC3iuoPDn8OHLiRxJSLhqqklwqXgr4bXsCrgrL/grYgKOkI4RfCflbTRqCY6W0F7Szo1YfCRtIAn8JG8mvCfnqkv8JuDqty28JGkhDHhnaYqP+qsjSTvv709cy8KJ0IlbDLwnqCeI23gqZzwkKiW77+9Lio3c/CeuKfRqD1d4L+B8J+isAokQiI7PyVW76y+4bSw8JariHc08JGkhj0yXH3hnbLhoqPwkKC3ChRCEnsuKirRqDoo8JuylvCRtZZWSwpFQkPihaQubcOt4LqH762EP1LwkZOZUnc9JO+/vfCRsq8m0ajvv73gqIPwnrmL8JG1pSfqo5HwnYGZIi80T/CWvbjwn6KxChBCDu+/vcOXXO+5mPCQiqwnCihCJmHwn5W04KaF0ahCc/CQlojvv709JuGJjfCfoZU077+scmLwkKm6CjZCNCVe0ahg6qCyPMi6NvCRu6h7PeCtoTdSL1PwnrmHe8OvPfCeuanvv70n4oKvY09ke+Cosi4KDkIMWMOP6qyCJi5qYMOyCjlCN++/vVzqopoxL/CQlbHwn5+V4Kmp4Kq/P0Xwp7C5UMaH6qyoP1wvbOCym3Lwlq6EWGA6VyRZ0agKHUIb8J+isCUiezkj8J+VtEPwkJ2DOVVUJE7wn6KwCjBCLvCfoKrgt4MmKMKlP/CRtpA/8JapnEzCpdGoT+CytjpgyLrwkYOySvCepZ5zyLoKAkIACktCSUFoKeK2qC/vv73gtr3vv73wmr+24Kiq8JCUjFhm4rWv8JGjn3vwnp+jwqXCpeKRg8O177+98JCWuPCRv4DwkayDPHYqKfCfoIoKGkIY4LqlOSduUlwuI+GLg1whJPCRjbB24a66CjNCMdGobnAlY+C7imDwn5W0VTvCpTMiwqXwn663JfCRtYA677mr77iHwrI8dvCQhIBv3ZQKEUIPTCTwkKCEKnA88JG+sCh+ChNCESclw4g3RvCRtpAn8JCeg1xZChtCGeCxnfCfq7gk4Ki/PPCbiZUv8J+mv1Mie3wKQEI+0ajRqCYi8JCSoe+3j/CRjIPGiOCoj2bRqCcke0ElJ/CQjLHihaUo8J2eqsOh8J+Is+KBvMKuay0qP/CeuIMKHUIb8J60ifCfqajRqEDwkJSKXOG+tsKmLj8nKi5cCkFCP1bwkIagJVtx0ajwkYKYPeC3tGvvv70/Rzzvv5Lwn5W0X/CRsIXwn5W08JG0mi86L0bCpfCRpIQ88JCgteqnlQohQh/wnZmBJlHCoirRqOqvt/CRjIzRqCXwkbWRa2fwnrS3CglCB+C1j29GKigKJEIiPCRH0ah18JGMgXLwnriNLj0xwqXwnZS8L9Go4pGAe0N2OgoOQgzIumLwnriqJuqinXMKPEI68J+VtCcv6q21w75t4q6c1oAmJvCQh7LwkbWTKj8gyLrwnYuQ0ag4YCI677+9LtGo4Y2se+Cxmi7CrgozQjEh8JCdoyIu8JuynfCfgKFgez/wkZym8JG1kz/CqirwkKS/6qyuUXvwkIWlJVzwkZmqCh5CHHhQ8J66gfCRlokz8JKRsWAnQeG+ticlLlzgqY0KBkIEIuCqswotQivhnYLvv70vJuGqkio677CNSybCpeGLgHtZJPCQoYnhj7kvJlYua+C3imk9CjhCNvCeuZ/CovCflbQlNDom4rWv8JG0oVc64KuINvCdlYbRqD0iICdI4oCc4YqL8J+VtD3wkaaqLwoiQiDgpaLgqrUlwrZV8J2Gh+CttypA8J64u2E9VCTgs55xPAopQifgpokiYyLIuvCQo6rwnou/PWBa4LaBe+OFsPCRtIBEXPCflbRqTkEKHkIcImDwkZyl8J+puz3wnZWGaTzvv7114Kiy8J65two1QjPwkJW4e/CQrqtI4aGz8Jq/veOAtS5lTFwu8J2qpeCqhvCflbRAJOCytiXgr5fDhnvCpSQKFUITXFnwnoCjUz/wkLSC4LqC8JGkoAoCQgAKPEI6OlM4w7tg8JCBjd2GLvCQqZJJTzrwnrmUYOqolyrwkb+s4oKaL07guIvwnYCeJeG9kuGNjEHCpe+/vQojQiEn8JG2lHZNKlPvv70vafCfqbrgt4TwkJ2De++4tT0iL1QKGUIX6p+Z8JGDtsi6YvCRjKrhvZvIuifjiJMKAkIACh5CHDwkOyVce/CWv7Hwn4OnJTIv8JCBmiRDQu+/vSIKNkI0P1oi4L2dXO+svuGqsy8rJT/wkJ65LlXDhDNc8JKTmdGoS2PgoLIo4KaydkHwn5W0PXt+PwohQh9WLu+9rfCflbQ9JVHgu4JcfvCQuao9Invitqok6qGJCgxCCvCRh6t7L+K6sSsKC0IJczrwkbKZUTxvCjVCM/CWqaJx4oS9PlVlLzRgSFXRqOK2pPCbspXhpYDgraMt4KuDJPCTkZJgMSbhvZ3RqEkqKgoCQgAKAkIACgNCASYKKEImeyJU8JGNtHBUdeGctfCfn6Dvv71DKvCfiaJM77+9PcOvfCk0yLoKKkIo8JCSpvCdlIlv4Kq3bvCflbR1RC/wnZSUJ2DgsIln4raRKj0k77+9JgomQiTqo7DwkICpVj3wn6mo4Led4am877+9avCfoITgrqlJMjxqMSAKHEIa8JGklvCbsoLwn5W0KiJJwqXwkJ2iP+GDjTsKPkI8Sj3Ct0BowrjwkKS/TfCRnI3Cqy/wn5W0XGM2LvCRhYLqnKA/0ajDr3fRqDxpw4bhpJrvv73CtfCqu617ChJCEG3wsI688J65h/CdhLJZL1wKOEI26YipR+C1hifwkbChPX468JCehOCunPCehY8kfdGoYOG9q1lHMnAvw7UkIuCxiuCmssi6bnt7CjlCNzrvv6zwnZKX8JGMifCWublv8J+VtOCvhu+/vSfhprnDjuCokCrgqrPqkqw8RvCeuJXhnarRqCkKLkIs77+9L1PwkYOB4auE4K2WJ/CRvYXwm7KS8JGKjXttNS874L+S8J2Su/CflbQKT0JN8JCznuGNpWvCpVfDg++/vci68J+VtPCRqJY/PC7wnrm68J+fpcKl4KC58J+rhPCRl4/gqIhEW/CRkrPwnp+uLvCQsYbgt5Z9PfCRkogKCkII8J+VtOGfmmAKE0IRKiZF8Ja5rvCdmqDwlr6aIl8KB0IF8JuFpjwKMUIvSPCdkp/wn5yt8J+GhTE/0ahg8JCOqvCeo4PDlFwh8JC8i1xOIuK3mfCeuIHhiosKM0IxWPCeuaLqpocl8JGyofCWvobwnZS3RyfgrKxh4LqHSSXRqCfigqQ9JPCRjbHwn5W0RgoLQgnwkKCIdj8iXCIKFEIS4rO8J0Lwnri5e+GyhiVRbcK4CihCJlZYXjfwkbKDQEzwn5W0ZSI577ig4Ki4XC7wn4OE77+98JGEoV8iCipCKCcg8J+HuTPhsJY6JzzwlquFP+CpjPCRjZBBIvCflbTgu5hMMifgqIkKUkJQPnvwnrmb4KGi8J6Fh/CegIHgtrPDtOK/tSTgs6PgqIjwkKOh8JCpgDrqp5F3w6A04La1KvCfq7DwnZKi8JCAtvCRpZQmP/CRtas9PHLgsJkKMkIw8J64u3vwkJW2UWBgLmjhiZrwn5yJYPCdmLA90ahZTvCRpIIxayd+NOGvqHXwkJ6bChhCFvCflbRTIuChnnPwnrmNOz91XC/grqQKKkIoJCswKDZIYPCQoIXwnrmxPCpJJzAn6qyr4YuEefCflbQlOiLwnaqqPApLCgRuYW1lEkNCQSVzXOC6gvCflbTDqCTwn5W0POKAlCLwn5W08JarsOGhl2Bc6qaWJfCRjaDwlquZ8J+VtPCfqoQp4Ku/UCV74LuGCg8KCW5hbWVzcGFjZRICCAQK6R26AeUdCqUdCgdjb2x1bW5zEpkdsgGVHQo1QjPhkKAh77mxYPCflbTwkJaV77+9IjDwrLer76ygL+CijPCQp6Ei8Jy8pTo88Jy8iOK6sGAKKEImJD3wnZK20ajwnrq6K/CbsbNPKvCQgZUmOvCflbQkXCdF76yUeyQKEkIQ0ajgq63CsvCen65A8JC6rApFQkNM8J64pEDDrjx7ICQlYTEs8J+fo2Xgr4cg8J+VtMKl8JCUiFnCpUQ/8Ja/oX3hvZ3wkKa88J2Fj+Cyj8OQ8JappcOqCh5CHOCxh2k/LirgrYh7Y0Im8LGwviYiPHto8JGSmjoKMkIwe8i677+9e+CouC7wm4WlIi7gtITigbDitqEqMOGghPCQtLlh8KugimnwkLqK4LOeCkJCQOGkqCTjh7rwkbWT8Jappicn8JCoo9ex8J2VguGKvfCRg7ElOjcp8JGMh1zwkIq7LPCWq6fgtrTwkbWV8JarkV8KI0IhLz7wkYiGLCjRqGci77+9Tkpg4LOAJU7ivalqw6jit4prCkBCPjrwkbyBKmtc8J+VtGDIusaXe+CqleG/mVck6qShaEzWjc6M8J+qgsi6w4rgoZDgq6Mm6qSXOvCfgrnit41cCi9CLSLvv706WCDIuj/gu4gmclzqp4x4PW7wkKmX4bGALzzwkbCDcvCQgKZxcD9YJAogQh4xXC5h4Lezd8OR2aRr8JCWn1w6wqUuJmjqqZgucnMKNkI0L/CSk6Hhi7fCpdi68J+hrvCRsJJcKvCRiowi8JSYgTrCvfCegKTvv70nQjfDhD038J+VtAoZQhfqpK/wnZS4Ol7wnYyDInjgrIM9NuCxiwouQiw68J+JpDrwlqih8J65m0o9ZmVc4Yu0VfCQrovvv708L+GovlLgqZHvv73CpQoLQgk6w4k94LqE26YKOUI34LueXDw9JSoqJe+7geCxq0rgspDgsrk88JGDsTrwkJaJdUY8JiUi8J6fri/wkbS8M3s686CEmQo/Qj3vrLThi4U0NHkkP1zhjozwkJaZL/CRiJbwkLqxMeqsoiThn7XigZhG4K2WLWA8be+/vci6JFx1wqXwkaeRCkFCPytcSvCflbRg8J+VtCtK4b2d8JCumTrqlaLitKfgtI7wkaCv77+96qmVJH084K+HyLritrrjg6574aepLilzLwo5QjdG8Juxs+Czsu+/luCuilPhvZnCpS7WlPCbsp3igpfwnrih4oCA4L+ON8i6772v0ajwm4mk4LGNChlCF1Twn5u5Ji0u8J+VtD9+OuGnkvCYrYR6CghCBmAiJD8jWAozQjEy77+977e4L8KlO3vDhPCeupRqLW9nVfCflbTgoLdKMCrRqPCcvqPhvKrCpWA8P0JrCjBCLlzDoXokJyXCqDok8JGNh1/wnoKP4Ke8w5lp8JCohS9AwrPwsKy88JuHnPCxvrMKH0Id8JGnosO0KfCeu7BO8J2SnlnRqMOyPNGoXOGqoDoKKUIn4Z2z8JGymFLhpLlZIsKiyLpHX0rwkYCiyLpR8JCgvPCRrIZDJz9QChhCFnoncfCeuack6pWqUz0/IjlhPFDvv70KFkIUPe+/vSVVfFwlO+CttTB7XPCeuY4KMEIu8JuFpvCbg7xcLy894LOWdfCRiojgpo/ihIDgprJ5XDpIT8i68J6Esybwlq2wfAoLQgk8JPCfnqvqqZAKDEIKSjPhvZnis717dgoMQgoi8JGgpWA14Y+7Ci1CKyZs8JuFpcOW8JG0gkfwkYyP4LqBReqshfCRg5PCpfCQgIdJw6xSJy5gbiQKNEIy4K2BSn1x8JGkgfCWuZfwm4WSdGBrMOCqgci6Jk49XOC/hScqyLrwkY2mcfCen7fgq7kKHkIcXFntnrxw8JGMh/CflbTwlqupTNGo4LqC4L6AbAovQi1FMeGhplzwnrq1LCY84KqsSCrwnrm+XMOeyLrwnZK7R/CfgpJceyHtn4AhJCUKF0IV8JCehfCQkJIu4bC+JvCflbTDpy9hCjxCOuChnikqJfCSkbLwnYuowrPgu4bgrpkqJCF84LeZ4L6pyLrwkYq4c8OH8J65tHvwrYeCPC7CpSdZe1kKE0IR4Z+h77+98Ja/sVEuKntrKmUKH0IddPCRtpE68JCjtUTqk4Y7Ue+/vfCdjZbhj5l7JCoKJ0Ile+CxmeCovuCgniV3cuC2tGjivarwlqunLuCmivCWv6Fg8J+VtAo1QjPwnqOSwr4uJeK3kiPgs41a4LuO4K6CVfCeuprvv70vLPCRhJY8PXbgoYl7JC5PPWHgr5cKDkIMKuGJpvCWv7DwlrypCh1CGzxgKvCRmqhTWPCRprzvqqV7JVQlZ/CdjLBWLwoVQhPwn6uFeuGdhi7vv70l8JGKiD0mCihCJirwnpO1ezovJD/wnrmk4K2I8JCSouGJvyVaaeqZjCxZJWYiWGU7CjpCOEbwkZqj4KiDUFs98JGMj3siYDxuV/CRmZLjgYlg8J2Loy9z4LqBJU3wn5W0IuCznSVVVjXwkpGyCjRCMj/pn7hJwrTwn5W0YfCeuZQuYPCQo7Ig8JGMiTrgrJTwkYqVLzx74LKJ8J+rsuCool4pChBCDvCdlYJVJSl7yLo94Y6OCixCKvCQvoFW8J+VtC01YPCQjI/hs7Hwn4OVJVtV6qygT0oq4YqH8JCUkkYucgoPQg1c4rWk4K6SOvCQvbg/CilCJ/CdlJdRwqXwnoCceu+/vSTgr6bwkJ2n8J+VtC468Jy+riVb8J2HggomQiTIukHgu4TgrZw9PPCYirXjhIgm8JGcofCfqa3itqPwnrmUJCoKD0INKiRL77mj4K6z8J+otQoCQgAKHkIcTy5dUOCwvfCdi6giNSTit44m3ZngtrPwmr+3ewoEQgIlPQoFQgPIunsKRUJD8J6frSNb6qeUJ/CeuaEi4K6p8J65neqfk/CQlZ0g77G9L/CRpKzgqpNGJcKlYPCegJMmWznwnrm6eTrCpTlwOu+4sAoDQgFMCjtCOTw/MS3igorgs5Vrb3vIuuGwvHFHanrCpVpZPz7wnp+i77+98J+VtOCxpvCQsKc877m0L0bwkKGKLgoVQhMkJvCRvY7vv71tL+Gqk1Pwn4OJCkNCQfCfoYTwkZah8JGkgXrvv73wkLORIlzwkJaV4K6TJNGoQfCWrb3wnoChJ8KlVyrigIB0Zi7Dpz0m8JG0iOCwqz9qCgJCAAoHQgUvai4nIgowQi4i4rSEL/Ceub5nW3V+KtGoXCXwlr208J2qpMOePe+/vSYwNTM+w4Y9yLpfJ9ebCjtCOSYu8J+rpfCeuIN7PTMn8J65uWRs8J6ftOG9nS4nez/hqbTwkKO9wqXvv70pLuCmiPCdi6zwkK6rcgo+QjwxOsK3JvCRtZTgrJsnXmDhpYA/VfCeuZIn8KuYg/CeuZlzyLpR8J66iCTgsI/DuOGchT3qrKwl8J6AoyIKI0IhXCpSJnXwsoqAIuqfmOGAleGKi+C4rC7RqPCYtIPwkKShChNCET888JuyhCRcPfCQhpXwkKiGCj1COyIiJsKlwqXvpqLhnqM/UiLvt4/hv54i4Kme8J2LgDtg77+98Jq/sjzwkaeQJDBcyLpu8J2YiyXwkaajCj1COyTwlqW+4KqsJT8lPeCghPCfnIM/yLrRqC7IuuCrgzoiK8KlKvCRjItubOCovPCeuZ0s8JasrD8qXMKlCgRCAiZPCg5CDHgm8JG0vGDwkZClbgpBQj/wkY2QJ+C7nvCehYlRJirwmK6x8J+VtEfvv71z4b2d4Yma8J+VtCtc8JGkgDrDuknwkYy18J+rhdGoJPCWvK4KA0IBYQo2QjRoJyTwkZeWLm0/RSTOiM6PJfCflbTwnZSoevCflbTwkKCIOmkq8JGkle+/vUN18JCAqzpcCixCKiLhobXhsqTwkICT8Jq/veC3lvCRtahMLuCuj1zwkbyuOm9g8J2LqizIugo9QjvwnYCQbPCQgII876y48J+VtCbhiZzIujTqqaIl8JC6sDwv0ajqqK4oR+Cvh8Oa6qyS4aWx77+98JGnoAoPQg3gqpvwm4GQ0ajwkYywCkBCPkok8JGMvfCfg5ngoZPRqOC7iCbqrKFFcDHwnrqiyLritrPwkr+pPyY/alzhpbAkbe+/veCxnSXwnrmH77mzChtCGTw4YC4mL+G9mz1z8J+VtPCQsK3gqZ7vv6QKK0Ip4rqRw4Hgr40iJyrvv73wkKCELysq8J2ery454Y68QmDwnZWC8JihnCwKGkIYYNyTPFYzwqV1L/CQkJM0KsO58J+lpmBMCi1CKyU+VPCflbQv8JGDsOCqqy7wn6qo8Jq/unAke+CuqtS48J+Isltj8JC6lTgKOEI2JuCpnuqvtzzCpSbwm4Wm8J+hkSIvJeC4qyngrKPwkIyv4Ymb4K6c8JCVnSxJyLrwkY2fUz97Cg9CDcKl4LqCJPCQqJdcYioKKUIn8J6knfCRtYUveXvgsKvwmr+2Qjon4aeTJz0uImAhJjpdJy87XCVyChNCETxgcmBj8J2TgyHvpa/wnriGClBCTnvIuvCRjIHvv70mSyTht4nwkLOw77e34L2T8JGMgeC1rTpg4Y6h4LuA4Kei8JGWl/CRtadcQPCRmZLwn6Kwey/qorFZJuConsOM8JGklgoTQhHIutGo8JarsD/hvZ3wn5W0PApFQkMn4KeHPFPhm5pD8JGcjSLqrKXgprlZKiTwkaejL/CfoZPwm4mJRHt6JGDwkZ2G8JCEouGfo/CRsbVHPS7wnrii4a2WCixCKuOEr+qpmPCRtqNgJlwk8J+VtMOD4reY8J+WnMOzYjfwn6uEJGlfJmYnZQoTQhFjJSUv4pGBw4LwkYyBUeCuowoTQhE6d3ElXiTwkKik4Y6Dw7R2PAoDQgEpChFCD/CcvKLhqaXgqIIv8JG0ugogQh7gs53wkbWR8JG9he+/vU88bixPPfCehIpiYNaXKmMKHEIa8J65l/CRsYQt77+98J2NseCzoiLhuYtPJkMKGQoEbmFtZRIRQg/igrjwnp+pJ+Gnk1zgtp0KIAoJbmFtZXNwYWNlEhNCEeCumnLDs+GLieGihsi6LjolCp4NugGaDQrjDAoHY29sdW1ucxLXDLIB0wwKNUIz8J+VtPCdlKHwnZGk8J2Fq0g58J+VtC5z8JCOvCcvMGTgprnwkKuO8J+VtO+/veCwvTJxCjdCNU4iIkzwm4OVRPCQjLzgqK3wnYuCQTon8JGLtPCRpZbwkIuo04IlP2BBJicn8JCpoO+5psi6ChZCFF0kKm/wkai8P+G9m1zhjqHwkaamCiFCHy4vU0k8TCQvJ++sueGKs23ivpwl0ah7RuC7jEfjgpIKJUIjd+GJiyHwm4Wl8JC6q8i64KiC4KGCO8i6YPCRrIF7ePCdkp4KIEIeSiTjgbQjL/CtrZckZu+svOGPrfCegKPwkbSI4KyMCkFCPyRnNuC7ivCQkqbwn5W08JC0gfCfnovwlqmjJPCRsp9b4YmK8J2Em/CRmowuOirDuOCmsiouIdGoJHtL8JGFqAoXQhVGa/CepKlm8J+VtCbhi6fwm7CWJSIKIEIeWijvtZDwkI+B6q+08J66g3xrL+Cmrjxc8J+vhzpiCiZCJFDRqDw5blnCpS5VPSRcYlvwkKiF8JCFiOGdsDwmOjHvv70iWwooQiYmL2Dit5bjg6/wn4OF4oKyalciJDzwkYyzQipsKjzhsYFe6qyjYAoqQijwkKuy4Yu2YPCeuLk6Q8Kl76y+4b2dezzRqPCegLBNIuCnnUHwm7KFChtCGSkq77+9JsKl6qy5762jJyPqpbTwkZa/P30KHkIc77+90ajvv73qp5MkZyLwkJaubGLgrJBw4LGBewonQiUkLjdc2IvIukrwkbC/K/CRtInvv71+8J6TqSfhqofvv73wkYqECitCKVbwkY2Q4Ki54LCAJS/gr4rqqZXwm7Ke4aKhbTgxNWDgq43vrJ1gKUJcCjJCMPCQlIzwnrmL4Kme8J64u8i6PDzwnrit8J6KkSZE8JC+gUHgqLIrXSdcc10nZu+/vQodQhtgw4fhpqoiwrrwkY2X77+tQcO1Pntk8JCQriAKN0I18J+VtO+/vfCbhaVuLkotXiXwkZmWY+KRguGguG/qlK3Djz/wkb6ww4/RqOOFrCU/KS/vv70KKUInYcKgL/CRi7Zk8J65tWZ0WtGoPPCRp6NVVUzRqPCQq67wkbSG4YySCg5CDOGDh++/vfCfiYM6JwoRQg9V8J+fsPCflbRgPS/CpS4KIkIgyLrwnZCVIjRY4K6K6qmSeeGyvyPwq62+yLrgqYzvv70KPUI78J6Cj05rR1d7yLrIuuqlvOqsjSjgs4fwnZWC4Ky+PSLgqZFrP/CflbTwnZWG6qySfPCRiJDgtbTRqGcKEkIQ4Z2hMWXgr4g/Nl7wkLm0Pgo9QjtrLuKBv/CQrafigLPwqqKRP03RqCQzLnxMJibgsZZw8J2El/CeuZnRqOCquDzDpfCRjLPwkJSeP+GKuAoaQhgm4KqQ8JCMonh08JGjvz/wnqG7WfCQo7QKAkIACgxCCuCuvkBDL2Y9LyYKCEIG0ajIuj9vChhCFlwufSLwnoWASiIuP/Cfgb8uafCdqp4KGkIYJ01F4oKIdGs8Z9GoJOqvue+/vfCQnoUuCgRCAtGoCh5CHPCfh6xdatGo4b2NOuCuhiLRqD95dj7qpILRqDwKKkIo6qSmJuCurydoUTztn7dHJOCuj3zWjWXwkbKJwq4mJjXgrJhXLmB7XAoxQi8m8J65m++/vfCflbQq8JCeszDRqC3wkZGd8J+VtMKxSSzRqC8l8JCeuXZQ8JCgrgokQiIm8J65neGkhPCQqLJ9LkE9OvCRjIHwkISA8JCgvC3wkLyQCi9CLfCegKfqlq8iJS8iPilsP/CflbTvv73wlr6a8JGyjfCRiorigbDwlqqQ4YuZJAoXQhVY4oKv4Yq6ODnwkKa1PSYlP+CovEMKGEIWLsKjPXonJPCQrJLivorhjqhr8J66mgojQiE5WfCQgJnwkayAc/CRsIove28iPPCRjLZaKkEqXPCflbQKMkIwJvCQsowvXPCdnZcqXeC1ru2fkcOB76y+44ezPGvRqDDwkYykJFxh4LqIdPCQgZs8ChpCGDrgraPIuuCnglRr6p+W8J65oiJJRmDDmQoOQgw4JjzwkK2kIvCRjKoKPEI64LqCSXdPwqPIusKl4Ymb8J65jvCRpqvhg4fwkYqEJDot8J6fsXgk8J2LjOCvinsqXC5N8J+CqOCnhwoSCgRuYW1lEgpCCPCeuZvwkIKxCh4KCW5hbWVzcGFjZRIRQg8v4b6WLVQ68JattGDCpVwKsA26AawNCrcMCgdjb2x1bW5zEqsMsgGnDAo7QjlqyLrvv706P0XwnZKl4reUTGtm8JGknPCdkqxce/CQrpw/ZPCbhaRjyLpnW3tXXPCQjpk6d++/vXgKGEIWXOK2peCxgCJ67Kqs77+98JCSlMOrbwojQiF8JD8tJSfRqOK0pzwv0ahWeSYwPPCQjodncWLgq7nig5MKJEIi8JaugT3wkaakPPCdkas8P9Go8J2qnydE4rSn4ZWN4b2LUQoPQg0/QeCsiT3qp7LwkJySChBCDmTvv71X8JC6sVLfkdGoCktCSci6XPCfgrbwkbGyVmvCue+rjCU/8JCWu+CzlfCWrZhc4rqo4Z+oJPCfhKjwn5W0Iuqfk/CQq7E68JCei/CQqYUqwr1j4LWNVlYKI0IhIi/wn5W04LaWaeS3iXsu4aSgWSTCq3lcRvCeu7HwlqmhCjxCOuCxo/CeuLXgu5Dgs4bRqDxaP1A9RSJc8J2SnlwiRuGfs1XwkJ2GOjzwlJKcL+Chvivvv7178J+CsiIKKkIo3odMPC9gIeCpiPCSh5JzKnPRqCvIuiolduC7jCdiRPCeuYcu8JGMswolQiPgsboiYPCRoLlb4Z+nYPCfn7Bh6pKf8J2NpdGo8KuehTxeJAoeQhwufcKqJdGoPfCflbQ/M+C9gjoi8J6jk/Ceua46CgNCAScKBUID77+9CjZCNMOKWj3goZAu8JGZp8O5JvCRtIkq8Ji0gVx78J2LrG1W8J+VtC7grKYi8JGrpTRWO/CdkI8KB0IF8JCphiIKN0I1XDp48J+JpCLRqMi68Ja6ik46JmzgtLHRqOGzg/CQio9P8Ja8liLwlquSZil6VvCQrqngppkKLkIseO+/vSI/JDrwn5uza+CummAu0ahi8JCsojoxJyg/4Kindifwn5W08JGMt2AKNEIy8JGyllDgt7PwnrmHQiLgqpDhs5IuJi8uPnVlIvCflbRtLVzwkaqwNu+/pCQ/wqXWkysKHEIaw6rwn5W08JCphirgqK4uPD96P1Eq8J+VtGEKJEIi77+9JS/wn6WsUGBkeyomP+GcruC3kvCfn6vwnp+2JOCouAo9QjvIuuC2ovCeubrRgPCRtqA9JC/hqqfqt5zhp6AuwqXwkJOEPvCbsKPgspQmYPCRiIjwn5+M4reaLu+/vQpGQkTwn6iX4KGe4bCfMVzRqNGo8JCOveK2gkou6qOUJi5r8JGklcOlLvCWrovwn6qAIzwmJmHwlquV4rStKtGo8J64teChlwoJQgd04Ymd44C0CjJCMPCflbQ84LOdSHvwnrikJdGoNcK8e++/hzzgsK/IuiIx77+9dsKl8JG1oO+/veGCowouQizDqX554LKqPyrgrofivpJFKvCWrZfwnZK7UvCbhZUn8JGNkC9xUC0q8J+dlwosQioi77+9biYkIOCzsj0hyLrhjpRcUe+5s8KrICYnZ1PRqDxEOOCpgj/gs4YKNkI08J6LsvCdlYZ7JPCeiqAqPOGJjXsv4K6jYSLguqUke2DCpV3Djy7vv73CpTrvv71qb+C/jwo8Qjo6ffCeuac84L+O4K6c4oSEYCQ2w4p+Insnw4nDi8Oq8J2Um1zwkJWLTcOQ8J6AiuC1mPCRqKclyLpJChZCFMOoKjcn4aSE8JG0vNGoLidhSj8/CghCBnslRu+/vQoNQgs8e++/vUjvv6k/PAo8QjpD8J2FkfCcvJYi762EfPCeuZQuL+Cnh/CbhZVb4aqD8J65vuqin27gqZHwnqWWXj7gvrTvv73wn5W0Cg5CDCLwnZSW8JCWlHtGPgoGQgQuLnl8ChxCGl5q8JG2i+C3lMi68JCov8i6Ik8ibFfwkJSbCg1CCzjwn5CxLknwnoC3CkVCQ/CWrZvhqYLvv73wkKe48JGkt/CQkLbwmLSC4K6GJeCqrfCfqoHhi4AkPfCRjYsl8JG8iPCRvrDVhmhcUcKl77uiXCQKGkIYefCWrozwkKCILDpCPfCRiozwn6uF4LeCCgRCAiY8ChFCD/CQnrZ18JGDsPCQj40nYAocQho58JGnoVThipHhp5bDuWUiL/CRtpVf8JattgolQiPwkLqw2J8nOjo18J64ovCQraXwnoCjXOC0mHtXdMKlIjo8fQo3CgRuYW1lEi9CLWjirbpOZ/CflbTCpeG/vXlc76y6JPCflbQu4LSYLUTvvKPqrKw64bK044GObAo3CgluYW1lc3BhY2USKkIo8J2SiMK54amHbi/vv7zgoYok766QYCZfYeKCmvCfnIw6OU0j8Ja/pAqiGLoBnhgK9hcKB2NvbHVtbnMS6heyAeYXCgZCBMK2JicKAkIACilCJ/CegJ9iSlBow7R0X9Go76mVV2BH8JGbh+CgoPCQloBTLkfgrponMwodQhvgtoI7bPCRsLlNffCQj4s5ItGoeOGjleOBiCIKM0Ix4Ki8PDpy77+98Juynj9q8JCEsvCWrbDwn4aHc96SYPCQqbXwkJWINGVQ4reQYEvDvQo/Qj0477+98J2NhfCQnI/vv73wkI2j0ajwkKiVQjzvrITwn6238JGEknAk8Jy/gyMvyLo/4Kuw4Z2K8J+rqGcmCjNCMS878JGXiUQnPCrwnrmh8J2qniR78JOAjuK6pTV5JPCflbRO4a2mPFw38J+VtPCehY8KDEIK0ajRqMi6IUBaTAofQh3graxFNfCcva5cOvCRip86wqXwkL+keci6NCYqYAo3QjXitqZ+bmNgPzJD8J+VtOGkh3Tgr5c/4LOx8J64su+/veCmjzIuVSbgqqrwkb6wJMOPKuCzrAopQifhvYxg0ag/8JCrrOG9mzw6K/CRg6Z8RyTRqF06fOCvhiJNP1Y8eCYKLUIr8JCBme+zliJ38Je3sTrwkLy7Lzp18J+HssO88JuLhsi6yLrwn5+wQ8K1eApOQkzvv73goZolJ/CQuaJs76258JG9hfCav7V87Z66LvCflbRD4aS44aqI8Jarh+GdrmnwnYiV8JCUvCbqq5/vubHwn4OKw47DiPCflbR1CilCJ2hR0ah4MeCph/CQubwl6qylP2DCpSpn8JCihHDIuj16YD178J2EvAo2QjRIe+GJg+C1iybwkYyuJPCRjI/wnrmSYO+/vVzCp/Cfg4rvrZXCpcK6KuGPvPCQlbJwwqUkChBCDvCQjJd9Olk677+9Rci6CglCB0Dwmr+xwqUKLkIswqXho4vigpRow6rCpfCRjZfwlqK5yLovPHsmJPCroJBxPPCfgrRvP++nsS4KNEIyVXt9wqUv8JCAmeK6luC3ikBd8J60k2BgXyJt8J6jkyUlInvwn5W0ZFjhnbDwnZqVKXEKD0INUCfwn5W0e+qomkY7KgoMQgpwRVjwkIag6p+9CkBCPvCRi53wn5W0Qj1gS1U8OGXwkpGz8JKJsfCfqrTvvqrwkK6I4LKI77+96p2qYmDwkbC/LvCbspzCpTrwnruxCkdCRXl68J64iOGJmPCdk6zgpqzwkJK9Xj/guYtcceCoueK9ivCfqaTwnpOtwqXwn5W0UE0u0ahXw6Tqn5Dwnaqddiss8JGTkgoNQgvDiNGoWmPvv70qbApKQkjvrKTwn5W04b+Ge/CQgLZ78J+puXvwkLyUyLpn8JGwgyrwkZ2AR2/RqPCRirTCpWYqKuCytfCqoaXqq6XgqKrwn6uo4LqlyLoKGUIXXDjRqCbwkJSD8JCggS7wkKu1w67gobsKGEIWP20qaj/RqOCyj/CQlp/vuLM38JGHhAoXQhXirow68J65i1zwnYuC77+9fSTIuj8KE0IR6qC0fC/hi5XIuvCQjYXCtj0KBEICJ1QKPkI88J+FnPCQgYHgrKrCpcKl8J64gybgvKF0QCwv8LCtsS8677+9P3A/8J6fuC/wn6+xJPCRp6Twnbyc4a6LCgJCAAomQiRS8J2XtEbIulpd8J66qDcyLyY6VfCdjaXigY1DPWBjZeqhrT8KNEIyLmBmJ/Crk5zCpUngv4nRqFpF0ag98JG2o/CSkLs8JmDwnYKbISQ8JfCWq4VgS/CbhLIKIEIeeyfwkJaQa9GoJiHhqpl5XCE6wqXIuuGlnC/wn5W0CgxCCifgrLXIuuK3nksKNUIz8JCTqOqTg0438J66kiVc762DJnZSeU494bOD0ahU8J+isOCwp1dKPeGfsOu/muGkiMKlCkVCQyTzoIafQD0w8J6Ap/CeuLl7yLpj1pMsJuqgnOOFquG/pVXwkaSNIvCQs5/gs6w9PPCflbTwnoCq77mw0ahZKvCRgacKLkIs8J2Sqz/wlr+xTfCRhYHvrKg/8J2AkD1iXDLwnrmX4KmbTDon8J6yjiXhqq0KEUIP6p+R1Y0lUj/CpSdC77+9CgpCCC4l4LyYJXI8ChlCF3I/4LezJC/wnrqjZPCQlpFcN/CRqak8ChJCECrgtY3gt4rwnZSzYPCflbQKEEIO44e28JCMjOCmkCTCpSQKPUI7J3XhjZLgqrcidMOYw4AnROGlmm5g8J+CqybRqDrgp51gJ+KWpjjqo6rhmq7hvZ3IuvCRp5PgrIzvv70KGEIWw7XwkaamNzjgr67vrYDvv5clwq41KgoWQhRcXS7grYg8ZuKtu+CwtfCQjrNtRAomQiTIujpg4LCO4aqTPDJg4L2iIsOV8J+VtC88Njc6XOOGoO+tgSoKHUIbPdaNaUx1Ik1q5KOM8JGIluCrv1Z0RfCeuolBChZCFCImKm/CpVzwnaqbScKl4Y+4fHVgCiRCIvCRpYXhoJV277+9PPCav71C8JGMgPCRgKR5JSY/fj3hsIgKGkIYIkZGyLonyLrhp5fwk5GTe/CegJ/wkbWgCjlCN2BW4KSZJj7vv7068JatnyYkbPCQhJNg8J66pinCpeqhh+CpjNGoJjzhoJZCLjDwnZK71oQ9WFUKBEIC0agKNEIyOirwk4KLMOGov++ksPCeuqjwkJalZEsiw7jwn5W0L+G9k2DwkJS18J+VtCVv4YqaJC0KOUI38JGZoV8ncfCRjLDgqrZRTTbwnrmp4Kqu8JGci0DwkYyBd/CflbQgJi/wkZeSd/CWqaXNvuCvlwohQh954LGY4KiF0aguOuCjkuqfkD3wnrmUIvCSkbDhs4A5CjhCNktAJeCyk2kkYPCfm6jwkZOTPjkuOm7wkL+A4oKrPPCQlrE/77+977+9YE7wnrmq4K6eWC48TQo6QjhqJyYnyLrwkY2X8J+puER78J6AnDXvv70k8JCpkuCovEU98JKRsPCRpIxm4Liw8J+VtPCdkrtAewo4QjbRqD1PYO+/vWHitLAy4Key4KyC4KehPCQk0ajhvZ3wkbCR8J+VtDzwkbS6YDrwnrmR4ZepKngKNkI0cz0uafCRsKnwnrm38JCWlfCWq4hRIkDqparwnoCFPCLhn7Tgspw077+9Lk9A4ruS77+9WwocQhrwn4CQe2NKw5zwn5W04LCB8JCjoGBm8J6EtgoOQgw/JuCrvG3wn4e0Ii8KHUIbPzzwkKifw78nyLrCpu+/vWDwkKm8Je+/vUUvCiNCIUFge/Cfh6x78JG1oci68JCKljo08JGBnHTDnfCQirU7JgoNQgvDrtmX77+9aiYlXAo5QjcwJPCeuZl58J+ItFUi77+96q+xR2El0ajqp6YvSsKlSvCSiIDwnYyrwqUpIvCfoJV7OuK3jDlJChpCGPCQtLcnwqU84LeZYG46wq/RqPCQoLw/UAoJQgfvrL4qJUR7Ch1CG0NmTu+/vT/vv5LwkbCNJEhyPVDwn4Ku8J6frgo6Qjjwn5W0XfCeuKc98Jatv/CWvZdxYDovItGoJ0zwkYeze9Gow53wkKC877+98J66sH0ie1wl4K2MXAoXQhVke1wnKfCfl7BgXV0lKTrIuvCflbQKPkI88JGLs/CRq6964b6o77+9L2cuPHslJfCRtavgqK0+4LONLOGmiS/zoIa18JGokTHRqGkuJfCeupPwkIW3Ch5CHCTwn5W08JCTqO+/vSHwn6KlbeG+j2sqa8OYJzoKHEIaJCrwlr6aIuqghuCxo/CfgbvhvZtpVMWdITkKBUIDPS48CipCKD8uwqXRqOCruyQ98Ja/o2Ng6q+zyLrRqPCdjbgn8J+isSpFSPCQp4YKEUIPYFnwkLS1Jy3vubNs4K+MCilCJ/CRsJAv8J6Lt8O5bHZFMOC+qMi644iS77+9P/CRtYBqIjY9R++/vQowQi57X1pczozwkYK+Pe+/vSUuw41pIkEkKvCRpqYr4KeO8Kudq/Cts4JtL/CRqrYlCiFCH/CRgZdnPCXIuvCRtII8Lnhh8JGllVwq8J+rtM6ENjsKGUIXwqXwm7KdyLrwkaWDL+C/mTwqJSfhv74KGEIWYElb4Ky3IkTwkaOb8JCUvCIkzbpkKQoSCgRuYW1lEgpCCCQ94YmU4YuQCg8KCW5hbWVzcGFjZRICCAQKEAoKdXBkYXRlZF9hdBICCAQ= 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 +CmcKZboBYgolChFkZXBsb3lfZ2VuZXJhdGlvbhIQwgENCgsBA4ZRYFaCZoVmjAojCgVlcG9jaBIawgEXCgoIcVMhAxJxVYlsEP///////////wEKFAoEa2luZBIMQgpGZW5jZVRva2Vu +Cl0KW7oBWAo3CgNrZXkSMLoBLQorCgNrZXkSJEIi4KiqYiDhvJx78J+VtMKl8J65gnZCLjrwlr+iyLrwkI6KLwoQCgRraW5kEghCBkNvbmZpZwoLCgV2YWx1ZRICCAQ= +CjIKMLoBLQoXCgNrZXkSELoBDQoLCgVldmVudBICCAQKEgoEa2luZBIKQghBdWRpdExvZw== +CoMBCoABugF9ClIKA2tleRJLugFICg0KB2dyYW50ZWUSAggECjcKB2dyYW50b3ISLLoBKQonCgV2YWx1ZRIeugEbChkKBlN5c3RlbRIPwgEMCgqZdhMjlFZRMxaMChoKBGtpbmQSEkIQU3lzdGVtUHJpdmlsZWdlcwoLCgV2YWx1ZRICCAQ= +CiQKIroBHwoJCgNrZXkSAggEChIKBGtpbmQSCkIIQXVkaXRMb2c= +Cn4KfLoBeQpXCgNrZXkSULoBTQpLCgRuYW1lEkNCQSUv8JG1oPCeipgh8JGSuk988JC/ovCQjr7vrZlCXCfjh7Qm77m0M/CRqJjgqbEuyLp24KiFVCrwm7KXPD5p6qyiChEKBGtpbmQSCUIHSWRBbGxvYwoLCgV2YWx1ZRICCAQ= +CnsKeboBdgpICgNrZXkSQboBPgo8CgRuYW1lEjRCMvCflbTwnp+o4LuEw5lgLyXwkI+OVuCtjUxaeDNj8JCGkfCbhIvgp6MnYOCrjVzCsV0kCh0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgoLCgV2YWx1ZRICCAQ= +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHSWRBbGxvYwoLCgV2YWx1ZRICCAQ= +CkgKRroBQwoJCgNrZXkSAggECikKBGtpbmQSIUIfQ2x1c3RlckludHJvc3BlY3Rpb25Tb3VyY2VJbmRleAoLCgV2YWx1ZRICCAQ= +CjYKNLoBMQoJCgNrZXkSAggEChcKBGtpbmQSD0INTmV0d29ya1BvbGljeQoLCgV2YWx1ZRICCAQ= +CpEBCo4BugGKAQpKCgNrZXkSQ7oBQAo+CgRuYW1lEjZCNPCeuY7wm7KWd/CQlpTwkbG+4KqbPS9aPV7hn7ngpL5eLuOFh2AhJsK3Kuqfl+Cxg/CflbQKEQoEa2luZBIJQgdJZEFsbG9jCikKBXZhbHVlEiC6AR0KGwoHbmV4dF9pZBIQwgENCgsBcoEkd3CTYjdTfA== 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 +CmEKX7oBXAo6CgNrZXkSM7oBMAouCgJpZBIougElCiMKBXZhbHVlEhq6ARcKFQoGU3lzdGVtEgvCAQgKBgFTITQyfAoRCgRraW5kEglCB0NsdXN0ZXIKCwoFdmFsdWUSAggE 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 +CjMKMboBLgoJCgNrZXkSAggEChQKBGtpbmQSDEIKR2lkTWFwcGluZwoLCgV2YWx1ZRICCAQ= +CjkKN7oBNAoVCgNrZXkSDroBCwoJCgNnaWQSAggECg4KBGtpbmQSBkIESXRlbQoLCgV2YWx1ZRICCAQ= +CmcKZboBYgojCgNrZXkSHLoBGQoXCgRuYW1lEg9CDUjwn5W0QeGXpHtbJyQKEQoEa2luZBIJQgdJZEFsbG9jCigKBXZhbHVlEh+6ARwKGgoHbmV4dF9pZBIPwgEMCgqVhyWFFkeCBVcs +CnwKeroBdwo3CgNrZXkSMLoBLQorCgRuYW1lEiNCIUk68J+bufCdqpx777+9ICbRqOK2oDbgsYwxJ0DwnqG3dAoRCgRraW5kEglCB0lkQWxsb2MKKQoFdmFsdWUSILoBHQobCgduZXh0X2lkEhDCAQ0KCwFhNjRlFAeCKDFs +CsYBCsMBugG/AQqSAQoDa2V5EooBugGGAQo5CgtkYXRhYmFzZV9pZBIqugEnCiUKBXZhbHVlEhy6ARkKFwoEVXNlchIPwgEMCgp0VYdleXRYEAc8Cg0KB2dyYW50ZWUSAggEChoKC29iamVjdF90eXBlEgvCAQgKBgFzYnaFfQoNCgdyb2xlX2lkEgIIBAoPCglzY2hlbWFfaWQSAggEChsKBGtpbmQSE0IRRGVmYXVsdFByaXZpbGVnZXMKCwoFdmFsdWUSAggE +CmUKY7oBYAokChFkZXBsb3lfZ2VuZXJhdGlvbhIPwgEMCgpJlJZiaXIpQFKMCiIKBWVwb2NoEhnCARYKCXJJlAIDYXBZjBD///////////8BChQKBGtpbmQSDEIKRmVuY2VUb2tlbg== +Cj8KPboBOgocCgNrZXkSFboBEgoQCgVzaGFyZBIHQgUvVXzDgwoaCgRraW5kEhJCEFVuZmluYWxpemVkU2hhcmQ= +CksKSboBRgoJCgNrZXkSAggECh0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgoaCgV2YWx1ZRIRugEOCgwKBXZhbHVlEgNCAWY= diff --git a/src/catalog/src/durable/upgrade/v72_to_v73.rs b/src/catalog/src/durable/upgrade/v72_to_v73.rs new file mode 100644 index 0000000000000..6010f672a100d --- /dev/null +++ b/src/catalog/src/durable/upgrade/v72_to_v73.rs @@ -0,0 +1,251 @@ +// Copyright Materialize, Inc. and contributors. All rights reserved. +// +// Use of this software is governed by the Business Source License +// included in the LICENSE file. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0. + +use mz_proto::wire_compatible; +use mz_proto::wire_compatible::WireCompatible; + +use crate::durable::upgrade::MigrationAction; +use crate::durable::upgrade::{objects_v72 as v72, objects_v73 as v73}; + +wire_compatible!(v72::ClusterValue with v73::ClusterValue); +wire_compatible!(v72::ClusterReplicaKey with v73::ClusterReplicaKey); +wire_compatible!(v72::ReplicaConfig with v73::ReplicaConfig); +wire_compatible!(v72::CommentValue with v73::CommentValue); +wire_compatible!(v72::RoleId with v73::RoleId); +wire_compatible!(v72::ReplicaId with v73::ReplicaId); +wire_compatible!(v72::DatabaseId with v73::DatabaseId); +wire_compatible!(v72::ResolvedSchema with v73::ResolvedSchema); +wire_compatible!(v72::NetworkPolicyId with v73::NetworkPolicyId); + +/// Adds the introspection source index global ID variant. Included in this change is shortening +/// cluster IDs from 64 bits to 32 bits. +pub fn upgrade( + snapshot: Vec, +) -> Vec> { + let mut migrations = Vec::new(); + + for update in snapshot { + match update.kind { + // Attempting to duplicate the introspection source index ID allocation logic in this + // file would be extremely cumbersome and error-prone. Instead, we delete all existing + // introspection source indexes and let the builtin migration code recreate them with + // the new correct IDs. + Some(v72::state_update_kind::Kind::ClusterIntrospectionSourceIndex(_)) => { + let migration = MigrationAction::Delete(update); + migrations.push(migration); + } + Some(v72::state_update_kind::Kind::Comment(comment)) => { + let new_comment = (&comment).into(); + let old = v72::StateUpdateKind { + kind: Some(v72::state_update_kind::Kind::Comment(comment)), + }; + let new = v73::StateUpdateKind { + kind: Some(v73::state_update_kind::Kind::Comment(new_comment)), + }; + let migration = MigrationAction::Update(old, new); + migrations.push(migration); + } + Some(v72::state_update_kind::Kind::ClusterReplica(cluster_replica)) => { + let new_cluster_replica = (&cluster_replica).into(); + let old = v72::StateUpdateKind { + kind: Some(v72::state_update_kind::Kind::ClusterReplica( + cluster_replica, + )), + }; + let new = v73::StateUpdateKind { + kind: Some(v73::state_update_kind::Kind::ClusterReplica( + new_cluster_replica, + )), + }; + let migration = MigrationAction::Update(old, new); + migrations.push(migration); + } + Some(v72::state_update_kind::Kind::Cluster(cluster)) => { + let new_cluster = (&cluster).into(); + let old = v72::StateUpdateKind { + kind: Some(v72::state_update_kind::Kind::Cluster(cluster)), + }; + let new = v73::StateUpdateKind { + kind: Some(v73::state_update_kind::Kind::Cluster(new_cluster)), + }; + let migration = MigrationAction::Update(old, new); + migrations.push(migration); + } + _ => {} + } + } + + migrations +} + +// COMMENTS + +impl From<&v72::state_update_kind::Comment> for v73::state_update_kind::Comment { + fn from(comment: &v72::state_update_kind::Comment) -> Self { + let key = comment.key.as_ref().map(Into::into); + let value = comment.value.as_ref().map(WireCompatible::convert); + Self { key, value } + } +} + +impl From<&v72::CommentKey> for v73::CommentKey { + fn from(comment_key: &v72::CommentKey) -> Self { + let object = comment_key.object.as_ref().map(Into::into); + let sub_component = comment_key.sub_component.as_ref().map(Into::into); + Self { + object, + sub_component, + } + } +} + +impl From<&v72::comment_key::SubComponent> for v73::comment_key::SubComponent { + fn from(sub_component: &v72::comment_key::SubComponent) -> Self { + match sub_component { + v72::comment_key::SubComponent::ColumnPos(p) => { + v73::comment_key::SubComponent::ColumnPos(*p) + } + } + } +} + +impl From<&v72::comment_key::Object> for v73::comment_key::Object { + fn from(object: &v72::comment_key::Object) -> Self { + match object { + v72::comment_key::Object::Table(id) => v73::comment_key::Object::Table(id.into()), + v72::comment_key::Object::View(id) => v73::comment_key::Object::View(id.into()), + v72::comment_key::Object::MaterializedView(id) => { + v73::comment_key::Object::MaterializedView(id.into()) + } + v72::comment_key::Object::Source(id) => v73::comment_key::Object::Source(id.into()), + v72::comment_key::Object::Sink(id) => v73::comment_key::Object::Sink(id.into()), + v72::comment_key::Object::Index(id) => v73::comment_key::Object::Index(id.into()), + v72::comment_key::Object::Func(id) => v73::comment_key::Object::Func(id.into()), + v72::comment_key::Object::Connection(id) => { + v73::comment_key::Object::Connection(id.into()) + } + v72::comment_key::Object::Type(id) => v73::comment_key::Object::Type(id.into()), + v72::comment_key::Object::Secret(id) => v73::comment_key::Object::Secret(id.into()), + v72::comment_key::Object::ContinualTask(id) => { + v73::comment_key::Object::ContinualTask(id.into()) + } + v72::comment_key::Object::Role(id) => { + v73::comment_key::Object::Role(WireCompatible::convert(id)) + } + v72::comment_key::Object::Database(id) => { + v73::comment_key::Object::Database(WireCompatible::convert(id)) + } + v72::comment_key::Object::Schema(id) => { + v73::comment_key::Object::Schema(WireCompatible::convert(id)) + } + v72::comment_key::Object::Cluster(id) => v73::comment_key::Object::Cluster(id.into()), + v72::comment_key::Object::ClusterReplica(id) => { + v73::comment_key::Object::ClusterReplica(id.into()) + } + v72::comment_key::Object::NetworkPolicy(id) => { + v73::comment_key::Object::NetworkPolicy(WireCompatible::convert(id)) + } + } + } +} + +impl From<&v72::ClusterReplicaId> for v73::ClusterReplicaId { + fn from(cluster_replica_id: &v72::ClusterReplicaId) -> Self { + let cluster_id = cluster_replica_id.cluster_id.as_ref().map(Into::into); + let replica_id = cluster_replica_id + .replica_id + .as_ref() + .map(WireCompatible::convert); + Self { + cluster_id, + replica_id, + } + } +} + +// CLUSTER REPLICAS + +impl From<&v72::state_update_kind::ClusterReplica> for v73::state_update_kind::ClusterReplica { + fn from(cluster_replica: &v72::state_update_kind::ClusterReplica) -> Self { + let key = cluster_replica.key.as_ref().map(WireCompatible::convert); + let value = cluster_replica.value.as_ref().map(Into::into); + Self { key, value } + } +} + +impl From<&v72::ClusterReplicaValue> for v73::ClusterReplicaValue { + fn from(value: &v72::ClusterReplicaValue) -> Self { + let cluster_id = value.cluster_id.as_ref().map(Into::into); + let name = value.name.clone(); + let config = value.config.as_ref().map(WireCompatible::convert); + let owner_id = value.owner_id.as_ref().map(WireCompatible::convert); + Self { + cluster_id, + name, + config, + owner_id, + } + } +} + +// CLUSTERS + +impl From<&v72::state_update_kind::Cluster> for v73::state_update_kind::Cluster { + fn from(cluster: &v72::state_update_kind::Cluster) -> Self { + let key = cluster.key.as_ref().map(Into::into); + let value = cluster.value.as_ref().map(WireCompatible::convert); + Self { key, value } + } +} + +impl From<&v72::ClusterKey> for v73::ClusterKey { + fn from(cluster_key: &v72::ClusterKey) -> Self { + let id = cluster_key.id.as_ref().map(Into::into); + Self { id } + } +} + +// MISC + +impl From<&v72::ClusterId> for v73::ClusterId { + fn from(id: &v72::ClusterId) -> Self { + let value = id.value.map(|value| match value { + v72::cluster_id::Value::System(id) => { + v73::cluster_id::Value::System(migrate_cluster_id(id)) + } + v72::cluster_id::Value::User(id) => { + v73::cluster_id::Value::User(migrate_cluster_id(id)) + } + }); + Self { value } + } +} + +impl From<&v72::CatalogItemId> for v73::CatalogItemId { + fn from(id: &v72::CatalogItemId) -> Self { + let value = id.value.as_ref().map(Into::into); + Self { value } + } +} + +impl From<&v72::catalog_item_id::Value> for v73::catalog_item_id::Value { + fn from(value: &v72::catalog_item_id::Value) -> Self { + match value { + v72::catalog_item_id::Value::System(id) => v73::catalog_item_id::Value::System(*id), + v72::catalog_item_id::Value::User(id) => v73::catalog_item_id::Value::User(*id), + v72::catalog_item_id::Value::Transient(id) => { + v73::catalog_item_id::Value::Transient(*id) + } + } + } +} + +fn migrate_cluster_id(id: u64) -> u32 { + id.try_into().expect("cluster ID will not exceed u32") +} diff --git a/src/repr/src/catalog_item_id.proto b/src/repr/src/catalog_item_id.proto index 4ab5dbde85e51..d794f981f4f3b 100644 --- a/src/repr/src/catalog_item_id.proto +++ b/src/repr/src/catalog_item_id.proto @@ -18,5 +18,7 @@ message ProtoCatalogItemId { uint64 system = 1; uint64 user = 2; uint64 transient = 3; + // This needs to be 5 to match the GlobalId tag. + uint64 introspection_source_index = 5; } } diff --git a/src/repr/src/catalog_item_id.rs b/src/repr/src/catalog_item_id.rs index 0f99b3d92b749..61124886a6753 100644 --- a/src/repr/src/catalog_item_id.rs +++ b/src/repr/src/catalog_item_id.rs @@ -36,6 +36,8 @@ include!(concat!(env!("OUT_DIR"), "/mz_repr.catalog_item_id.rs")); pub enum CatalogItemId { /// System namespace. System(u64), + /// Introspection Source Index namespace. + IntrospectionSourceIndex(u64), /// User namespace. User(u64), /// Transient item. @@ -45,7 +47,10 @@ pub enum CatalogItemId { impl CatalogItemId { /// Reports whether this ID is in the system namespace. pub fn is_system(&self) -> bool { - matches!(self, CatalogItemId::System(_)) + matches!( + self, + CatalogItemId::System(_) | CatalogItemId::IntrospectionSourceIndex(_) + ) } /// Reports whether this ID is in the user namespace. @@ -69,6 +74,7 @@ impl FromStr for CatalogItemId { let val: u64 = s[1..].parse()?; match s.chars().next().unwrap() { 's' => Ok(CatalogItemId::System(val)), + 'i' => Ok(CatalogItemId::IntrospectionSourceIndex(val)), 'u' => Ok(CatalogItemId::User(val)), 't' => Ok(CatalogItemId::Transient(val)), _ => Err(anyhow!("couldn't parse id {}", s)), @@ -80,6 +86,7 @@ impl fmt::Display for CatalogItemId { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { CatalogItemId::System(id) => write!(f, "s{}", id), + CatalogItemId::IntrospectionSourceIndex(id) => write!(f, "i{}", id), CatalogItemId::User(id) => write!(f, "u{}", id), CatalogItemId::Transient(id) => write!(f, "t{}", id), } @@ -92,6 +99,7 @@ impl RustType for CatalogItemId { ProtoCatalogItemId { kind: Some(match self { CatalogItemId::System(x) => System(*x), + CatalogItemId::IntrospectionSourceIndex(x) => IntrospectionSourceIndex(*x), CatalogItemId::User(x) => User(*x), CatalogItemId::Transient(x) => Transient(*x), }), @@ -102,6 +110,7 @@ impl RustType for CatalogItemId { use proto_catalog_item_id::Kind::*; match proto.kind { Some(System(x)) => Ok(CatalogItemId::System(x)), + Some(IntrospectionSourceIndex(x)) => Ok(CatalogItemId::IntrospectionSourceIndex(x)), Some(User(x)) => Ok(CatalogItemId::User(x)), Some(Transient(x)) => Ok(CatalogItemId::Transient(x)), None => Err(TryFromProtoError::missing_field("ProtoCatalogItemId::kind")), @@ -141,6 +150,10 @@ mod tests { match (og, rnd) { (GlobalId::User(x), CatalogItemId::User(y)) => assert_eq!(x, y), (GlobalId::System(x), CatalogItemId::System(y)) => assert_eq!(x, y), + ( + GlobalId::IntrospectionSourceIndex(x), + CatalogItemId::IntrospectionSourceIndex(y), + ) => assert_eq!(x, y), (GlobalId::Transient(x), CatalogItemId::Transient(y)) => assert_eq!(x, y), (gid, item) => panic!("{gid:?} turned into {item:?}"), } @@ -150,6 +163,7 @@ mod tests { proptest::strategy::Union::new(vec![ Just(GlobalId::User(inner)), Just(GlobalId::System(inner)), + Just(GlobalId::IntrospectionSourceIndex(inner)), Just(GlobalId::Transient(inner)), ]) }); diff --git a/src/repr/src/global_id.proto b/src/repr/src/global_id.proto index 8c9731dafcde6..2cd66b23a4e8b 100644 --- a/src/repr/src/global_id.proto +++ b/src/repr/src/global_id.proto @@ -19,5 +19,6 @@ message ProtoGlobalId { uint64 user = 2; uint64 transient = 3; google.protobuf.Empty explain = 4; + uint64 introspection_source_index = 5; } } diff --git a/src/repr/src/global_id.rs b/src/repr/src/global_id.rs index 5fc60312fdd21..a825b489d8c19 100644 --- a/src/repr/src/global_id.rs +++ b/src/repr/src/global_id.rs @@ -54,6 +54,8 @@ include!(concat!(env!("OUT_DIR"), "/mz_repr.global_id.rs")); pub enum GlobalId { /// System namespace. System(u64), + /// Introspection Source Index namespace. + IntrospectionSourceIndex(u64), /// User namespace. User(u64), /// Transient namespace. @@ -62,10 +64,15 @@ pub enum GlobalId { Explain, } +static_assertions::assert_eq_size!(GlobalId, [u8; 16]); + impl GlobalId { /// Reports whether this ID is in the system namespace. pub fn is_system(&self) -> bool { - matches!(self, GlobalId::System(_)) + matches!( + self, + GlobalId::System(_) | GlobalId::IntrospectionSourceIndex(_) + ) } /// Reports whether this ID is in the user namespace. @@ -92,6 +99,7 @@ impl FromStr for GlobalId { let val: u64 = s[1..].parse()?; match s.chars().next().unwrap() { 's' => Ok(GlobalId::System(val)), + 'i' => Ok(GlobalId::IntrospectionSourceIndex(val)), 'u' => Ok(GlobalId::User(val)), 't' => Ok(GlobalId::Transient(val)), _ => Err(anyhow!("couldn't parse id {}", s)), @@ -103,6 +111,7 @@ impl fmt::Display for GlobalId { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { GlobalId::System(id) => write!(f, "s{}", id), + GlobalId::IntrospectionSourceIndex(id) => write!(f, "i{}", id), GlobalId::User(id) => write!(f, "u{}", id), GlobalId::Transient(id) => write!(f, "t{}", id), GlobalId::Explain => write!(f, "Explained Query"), @@ -116,6 +125,7 @@ impl RustType for GlobalId { ProtoGlobalId { kind: Some(match self { GlobalId::System(x) => System(*x), + GlobalId::IntrospectionSourceIndex(x) => IntrospectionSourceIndex(*x), GlobalId::User(x) => User(*x), GlobalId::Transient(x) => Transient(*x), GlobalId::Explain => Explain(()), @@ -127,6 +137,7 @@ impl RustType for GlobalId { use proto_global_id::Kind::*; match proto.kind { Some(System(x)) => Ok(GlobalId::System(x)), + Some(IntrospectionSourceIndex(x)) => Ok(GlobalId::IntrospectionSourceIndex(x)), Some(User(x)) => Ok(GlobalId::User(x)), Some(Transient(x)) => Ok(GlobalId::Transient(x)), Some(Explain(_)) => Ok(GlobalId::Explain), diff --git a/src/storage-types/src/collections.proto b/src/storage-types/src/collections.proto index c6ece95f015ed..b2aabae046a94 100644 --- a/src/storage-types/src/collections.proto +++ b/src/storage-types/src/collections.proto @@ -19,6 +19,7 @@ message GlobalId { uint64 user = 2; uint64 transient = 3; google.protobuf.Empty explain = 4; + uint64 introspection_source_index = 5; } } diff --git a/src/storage-types/src/collections.rs b/src/storage-types/src/collections.rs index 9ad3366530bbc..059ca1a8e5746 100644 --- a/src/storage-types/src/collections.rs +++ b/src/storage-types/src/collections.rs @@ -22,6 +22,9 @@ impl RustType for RustGlobalId { GlobalId { value: Some(match self { RustGlobalId::System(x) => global_id::Value::System(*x), + RustGlobalId::IntrospectionSourceIndex(x) => { + global_id::Value::IntrospectionSourceIndex(*x) + } RustGlobalId::User(x) => global_id::Value::User(*x), RustGlobalId::Transient(x) => global_id::Value::Transient(*x), RustGlobalId::Explain => global_id::Value::Explain(Default::default()), @@ -32,6 +35,9 @@ impl RustType for RustGlobalId { fn from_proto(proto: GlobalId) -> Result { match proto.value { Some(global_id::Value::System(x)) => Ok(RustGlobalId::System(x)), + Some(global_id::Value::IntrospectionSourceIndex(x)) => { + Ok(RustGlobalId::IntrospectionSourceIndex(x)) + } Some(global_id::Value::User(x)) => Ok(RustGlobalId::User(x)), Some(global_id::Value::Transient(x)) => Ok(RustGlobalId::Transient(x)), Some(global_id::Value::Explain(_)) => Ok(RustGlobalId::Explain), diff --git a/src/storage-types/src/instances.proto b/src/storage-types/src/instances.proto index 8417b6b769ef8..89ee7ff7bc63d 100644 --- a/src/storage-types/src/instances.proto +++ b/src/storage-types/src/instances.proto @@ -13,7 +13,7 @@ package mz_storage_types.instances; message ProtoStorageInstanceId { oneof kind { - uint64 system = 1; - uint64 user = 2; + uint32 system = 1; + uint32 user = 2; } } diff --git a/src/storage-types/src/instances.rs b/src/storage-types/src/instances.rs index 75c4114eb210a..54ac849d53f85 100644 --- a/src/storage-types/src/instances.rs +++ b/src/storage-types/src/instances.rs @@ -25,13 +25,13 @@ include!(concat!(env!("OUT_DIR"), "/mz_storage_types.instances.rs")); )] pub enum StorageInstanceId { /// A system storage instance. - System(u64), + System(u32), /// A user storage instance. - User(u64), + User(u32), } impl StorageInstanceId { - pub fn inner_id(&self) -> u64 { + pub fn inner_id(&self) -> u32 { match self { StorageInstanceId::System(id) | StorageInstanceId::User(id) => *id, } @@ -53,7 +53,7 @@ impl FromStr for StorageInstanceId { if s.len() < 2 { bail!("couldn't parse compute instance id {}", s); } - let val: u64 = s[1..].parse()?; + let val: u32 = s[1..].parse()?; match s.chars().next().unwrap() { 's' => Ok(Self::System(val)), 'u' => Ok(Self::User(val)), diff --git a/test/sqllogictest/sqlite b/test/sqllogictest/sqlite index 262d86a2a2073..11e43fd53e51c 160000 --- a/test/sqllogictest/sqlite +++ b/test/sqllogictest/sqlite @@ -1 +1 @@ -Subproject commit 262d86a2a2073c7a707beaa34be283d3b0ead301 +Subproject commit 11e43fd53e51c95fe26310157f737e8e0e8e57d1 diff --git a/test/testdrive/catalog.td b/test/testdrive/catalog.td index 801712c53dfef..4d78ea7772882 100644 --- a/test/testdrive/catalog.td +++ b/test/testdrive/catalog.td @@ -795,7 +795,7 @@ test_table "" 61 # There is one entry in mz_indexes for each field_number/expression of the index. -> SELECT COUNT(id) FROM mz_indexes WHERE id LIKE 's%' +> SELECT COUNT(id) FROM mz_indexes WHERE id LIKE 's%' OR id LIKE 'i%' 242 # Create a second schema with the same table name as above diff --git a/test/testdrive/hydration-status.td b/test/testdrive/hydration-status.td index d79339904b3c7..026210543d6e1 100644 --- a/test/testdrive/hydration-status.td +++ b/test/testdrive/hydration-status.td @@ -34,13 +34,13 @@ FROM mz_internal.mz_compute_hydration_statuses h JOIN mz_cluster_replicas r ON (r.id = h.replica_id) WHERE r.name LIKE 'hydrated_test%'; -s true +i true > SELECT DISTINCT left(h.object_id, 1), h.hydrated FROM mz_internal.mz_hydration_statuses h JOIN mz_cluster_replicas r ON (r.id = h.replica_id) WHERE r.name LIKE 'hydrated_test%'; -s true +i true # No operator-level hydration status logging for introspection dataflows. > SELECT DISTINCT left(h.object_id, 1), h.hydrated @@ -61,7 +61,7 @@ s true JOIN mz_objects o ON (o.id = h.object_id) WHERE r.name LIKE 'hydrated_test%' AND - o.id NOT LIKE 's%'; + o.id NOT LIKE 'i%'; idx hydrated_test_1 true true mv hydrated_test_1 true true mv_const hydrated_test_1 true false @@ -72,7 +72,7 @@ mv_const hydrated_test_1 true false JOIN mz_objects o ON (o.id = h.object_id) WHERE r.name LIKE 'hydrated_test%' AND - o.id NOT LIKE 's%'; + o.id NOT LIKE 'i%'; idx hydrated_test_1 true mv hydrated_test_1 true mv_const hydrated_test_1 true @@ -83,7 +83,7 @@ mv_const hydrated_test_1 true JOIN mz_objects o ON (o.id = h.object_id) WHERE r.name LIKE 'hydrated_test%' AND - o.id NOT LIKE 's%' + o.id NOT LIKE 'i%' GROUP BY o.name, r.name; idx hydrated_test_1 true mv hydrated_test_1 true @@ -99,7 +99,7 @@ mv_const hydrated_test_1 true JOIN mz_objects o ON (o.id = h.object_id) WHERE r.name LIKE 'hydrated_test%' AND - o.id NOT LIKE 's%'; + o.id NOT LIKE 'i%'; idx hydrated_test_1 true true idx hydrated_test_2 true true mv hydrated_test_1 true true @@ -113,7 +113,7 @@ mv_const hydrated_test_2 true false JOIN mz_objects o ON (o.id = h.object_id) WHERE r.name LIKE 'hydrated_test%' AND - o.id NOT LIKE 's%'; + o.id NOT LIKE 'i%'; idx hydrated_test_1 true idx hydrated_test_2 true mv hydrated_test_1 true @@ -148,7 +148,7 @@ mv_const hydrated_test_1 true JOIN mz_objects o ON (o.id = h.object_id) WHERE r.name LIKE 'hydrated_test%' AND - o.id NOT LIKE 's%'; + o.id NOT LIKE 'i%'; idx hydrated_test_2 true true mv hydrated_test_2 true true mv_const hydrated_test_2 true false @@ -159,7 +159,7 @@ mv_const hydrated_test_2 true false JOIN mz_objects o ON (o.id = h.object_id) WHERE r.name LIKE 'hydrated_test%' AND - o.id NOT LIKE 's%'; + o.id NOT LIKE 'i%'; idx hydrated_test_2 true mv hydrated_test_2 true mv_const hydrated_test_2 true @@ -183,7 +183,7 @@ mv hydrated_test_2 true JOIN mz_objects o ON (o.id = h.object_id) WHERE r.name LIKE 'hydrated_test%' AND - o.id NOT LIKE 's%'; + o.id NOT LIKE 'i%'; > SELECT o.name, r.name, h.hydrated FROM mz_internal.mz_hydration_statuses h @@ -191,7 +191,7 @@ mv hydrated_test_2 true JOIN mz_objects o ON (o.id = h.object_id) WHERE r.name LIKE 'hydrated_test%' AND - o.id NOT LIKE 's%'; + o.id NOT LIKE 'i%'; > SELECT o.name, r.name, bool_and(h.hydrated) FROM mz_internal.mz_compute_operator_hydration_statuses h @@ -212,7 +212,7 @@ mv hydrated_test_2 true JOIN mz_objects o ON (o.id = h.object_id) WHERE r.name LIKE 'hydrated_test%' AND - o.id NOT LIKE 's%'; + o.id NOT LIKE 'i%'; idx hydrated_test_3 true true mv hydrated_test_3 true true mv_const hydrated_test_3 true false @@ -223,7 +223,7 @@ mv_const hydrated_test_3 true false JOIN mz_objects o ON (o.id = h.object_id) WHERE r.name LIKE 'hydrated_test%' AND - o.id NOT LIKE 's%'; + o.id NOT LIKE 'i%'; idx hydrated_test_3 true mv hydrated_test_3 true mv_const hydrated_test_3 true @@ -248,7 +248,7 @@ mv hydrated_test_3 true JOIN mz_objects o ON (o.id = h.object_id) WHERE r.name LIKE 'hydrated_test%' AND - o.id NOT LIKE 's%'; + o.id NOT LIKE 'i%'; mv hydrated_test_3 true true > SELECT o.name, r.name, h.hydrated @@ -257,7 +257,7 @@ mv hydrated_test_3 true true JOIN mz_objects o ON (o.id = h.object_id) WHERE r.name LIKE 'hydrated_test%' AND - o.id NOT LIKE 's%'; + o.id NOT LIKE 'i%'; mv hydrated_test_3 true > SELECT o.name, r.name, bool_and(h.hydrated) @@ -303,7 +303,7 @@ mv hydrated_test_3 true JOIN mz_objects o ON (o.id = h.object_id) WHERE r.name LIKE 'hydrated_test%' AND - o.id NOT LIKE 's%'; + o.id NOT LIKE 'i%'; mv hydrated_test_3 true src hydrated_test_3 true snk hydrated_test_3 true @@ -318,7 +318,7 @@ snk hydrated_test_3 true JOIN mz_objects o ON (o.id = h.object_id) WHERE r.name LIKE 'hydrated_test%' AND - o.id NOT LIKE 's%'; + o.id NOT LIKE 'i%'; # Test adding new replicas. @@ -330,7 +330,7 @@ snk hydrated_test_3 true JOIN mz_objects o ON (o.id = h.object_id) WHERE r.name LIKE 'hydrated_test%' AND - o.id NOT LIKE 's%'; + o.id NOT LIKE 'i%'; mv hydrated_test_4 true src hydrated_test_4 true snk hydrated_test_4 true @@ -347,7 +347,7 @@ snk hydrated_test_4 true JOIN mz_objects o ON (o.id = h.object_id) WHERE r.name LIKE 'hydrated_test%' AND - o.id NOT LIKE 's%'; + o.id NOT LIKE 'i%'; # Test hydration status reporting with WMR dataflows. @@ -382,7 +382,7 @@ snk hydrated_test_4 true JOIN mz_objects o ON (o.id = h.object_id) WHERE r.name LIKE 'hydrated_test%' AND - o.id NOT LIKE 's%'; + o.id NOT LIKE 'i%'; mv_wmr hydrated_test_4 true true mv_wmr_const hydrated_test_4 true false mv_wmr_stuck hydrated_test_4 false false @@ -393,7 +393,7 @@ mv_wmr_stuck hydrated_test_4 false false JOIN mz_objects o ON (o.id = h.object_id) WHERE r.name LIKE 'hydrated_test%' AND - o.id NOT LIKE 's%'; + o.id NOT LIKE 'i%'; mv_wmr hydrated_test_4 true mv_wmr_const hydrated_test_4 true mv_wmr_stuck hydrated_test_4 false