diff --git a/Cargo.lock b/Cargo.lock index 07cf47339d80d..b7a52b972ecb3 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4700,6 +4700,7 @@ dependencies = [ "maplit", "mz-adapter-types", "mz-audit-log", + "mz-auth", "mz-build-info", "mz-catalog", "mz-cloud-provider", @@ -4829,6 +4830,20 @@ dependencies = [ "workspace-hack", ] +[[package]] +name = "mz-auth" +version = "0.0.0" +dependencies = [ + "base64 0.22.1", + "mz-ore", + "openssl", + "proptest", + "proptest-derive", + "serde", + "static_assertions", + "workspace-hack", +] + [[package]] name = "mz-avro" version = "0.7.0" @@ -4989,6 +5004,7 @@ dependencies = [ "itertools 0.12.1", "mz-adapter-types", "mz-audit-log", + "mz-auth", "mz-build-info", "mz-build-tools", "mz-catalog-protos", @@ -6568,6 +6584,7 @@ dependencies = [ "itertools 0.12.1", "mz-adapter", "mz-adapter-types", + "mz-auth", "mz-frontegg-auth", "mz-ore", "mz-pgcopy", @@ -6977,6 +6994,7 @@ dependencies = [ "mz-adapter-types", "mz-arrow-util", "mz-audit-log", + "mz-auth", "mz-build-info", "mz-ccsr", "mz-cloud-provider", @@ -8884,6 +8902,8 @@ version = "1.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "14cae93065090804185d3b75f0bf93b8eeda30c7a9b4a33d3bdb3988d6229e50" dependencies = [ + "bit-set", + "bit-vec", "bitflags 2.4.1", "lazy_static", "num-traits", @@ -8891,6 +8911,8 @@ dependencies = [ "rand_chacha 0.3.0", "rand_xorshift", "regex-syntax 0.8.5", + "rusty-fork", + "tempfile", "unarray", ] @@ -9068,6 +9090,12 @@ dependencies = [ "winapi", ] +[[package]] +name = "quick-error" +version = "1.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0" + [[package]] name = "quick-xml" version = "0.31.0" @@ -9704,6 +9732,18 @@ version = "1.0.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "97477e48b4cf8603ad5f7aaf897467cf42ab4218a38ef76fb14c2d6773a6d6a8" +[[package]] +name = "rusty-fork" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb3dcc6e454c328bb824492db107ab7c0ae8fcffe4ad210136ef014458c1bc4f" +dependencies = [ + "fnv", + "quick-error", + "tempfile", + "wait-timeout", +] + [[package]] name = "ryu" version = "1.0.20" @@ -12369,6 +12409,8 @@ dependencies = [ "aws-smithy-types", "axum", "axum-core", + "bit-set", + "bit-vec", "bitflags 2.4.1", "bstr", "byteorder", @@ -12446,6 +12488,7 @@ dependencies = [ "postgres-types", "predicates 3.1.3", "proc-macro2", + "proptest", "proptest-derive", "prost", "prost-reflect", diff --git a/Cargo.toml b/Cargo.toml index db20d73ed8ad0..0f6e73c85fc6e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -7,6 +7,7 @@ members = [ "src/alloc-default", "src/arrow-util", "src/audit-log", + "src/auth", "src/avro", "src/aws-secrets-controller", "src/aws-util", @@ -236,6 +237,7 @@ default-members = [ "src/workspace-hack", "test/metabase/smoketest", "test/test-util", + "src/auth", ] exclude = [ diff --git a/WORKSPACE b/WORKSPACE index 8603b562adb4b..9edce5d7c4dbd 100644 --- a/WORKSPACE +++ b/WORKSPACE @@ -704,6 +704,7 @@ crates_repository( "//:test/metabase/smoketest/Cargo.toml", "//:test/test-util/Cargo.toml", "//:misc/bazel/cargo-gazelle/Cargo.toml", + "//:src/auth/Cargo.toml", ], rust_version = RUST_VERSION, # Restricting the set of platform triples we support _greatly_ reduces the diff --git a/src/adapter-types/src/dyncfgs.rs b/src/adapter-types/src/dyncfgs.rs index f42b23ddf71c9..5785f396b6ceb 100644 --- a/src/adapter-types/src/dyncfgs.rs +++ b/src/adapter-types/src/dyncfgs.rs @@ -118,6 +118,13 @@ pub const ENABLE_MULTI_REPLICA_SOURCES: Config = Config::new( "Enable multi-replica sources.", ); +/// Whether to enable self-managed authentication. +pub const ENABLE_SELF_MANAGED_AUTH: Config = Config::new( + "enable_self_managed_auth", + false, + "Enable self-managed authentication.", +); + pub const CONSTRAINT_BASED_TIMESTAMP_SELECTION: Config<&'static str> = Config::new( "constraint_based_timestamp_selection", ConstraintBasedTimestampSelection::const_default().as_str(), @@ -148,6 +155,7 @@ pub fn all_dyncfgs(configs: ConfigSet) -> ConfigSet { .add(&ENABLE_CONTINUAL_TASK_BUILTINS) .add(&ENABLE_EXPRESSION_CACHE) .add(&ENABLE_MULTI_REPLICA_SOURCES) + .add(&ENABLE_SELF_MANAGED_AUTH) .add(&CONSTRAINT_BASED_TIMESTAMP_SELECTION) .add(&PERSIST_FAST_PATH_ORDER) } diff --git a/src/adapter/BUILD.bazel b/src/adapter/BUILD.bazel index 89e35fc23f182..fd9138ab244b6 100644 --- a/src/adapter/BUILD.bazel +++ b/src/adapter/BUILD.bazel @@ -34,6 +34,7 @@ rust_library( deps = [ "//src/adapter-types:mz_adapter_types", "//src/audit-log:mz_audit_log", + "//src/auth:mz_auth", "//src/build-info:mz_build_info", "//src/catalog:mz_catalog", "//src/cloud-provider:mz_cloud_provider", @@ -104,6 +105,7 @@ rust_test( deps = [ "//src/adapter-types:mz_adapter_types", "//src/audit-log:mz_audit_log", + "//src/auth:mz_auth", "//src/build-info:mz_build_info", "//src/catalog:mz_catalog", "//src/cloud-provider:mz_cloud_provider", @@ -153,6 +155,7 @@ rust_doc_test( deps = [ "//src/adapter-types:mz_adapter_types", "//src/audit-log:mz_audit_log", + "//src/auth:mz_auth", "//src/build-info:mz_build_info", "//src/catalog:mz_catalog", "//src/cloud-provider:mz_cloud_provider", @@ -223,6 +226,7 @@ rust_test( ":mz_adapter", "//src/adapter-types:mz_adapter_types", "//src/audit-log:mz_audit_log", + "//src/auth:mz_auth", "//src/build-info:mz_build_info", "//src/catalog:mz_catalog", "//src/cloud-provider:mz_cloud_provider", @@ -293,6 +297,7 @@ rust_test( ":mz_adapter", "//src/adapter-types:mz_adapter_types", "//src/audit-log:mz_audit_log", + "//src/auth:mz_auth", "//src/build-info:mz_build_info", "//src/catalog:mz_catalog", "//src/cloud-provider:mz_cloud_provider", @@ -363,6 +368,7 @@ rust_test( ":mz_adapter", "//src/adapter-types:mz_adapter_types", "//src/audit-log:mz_audit_log", + "//src/auth:mz_auth", "//src/build-info:mz_build_info", "//src/catalog:mz_catalog", "//src/cloud-provider:mz_cloud_provider", diff --git a/src/adapter/Cargo.toml b/src/adapter/Cargo.toml index acfa9c1537a55..e3fd0e538aa31 100644 --- a/src/adapter/Cargo.toml +++ b/src/adapter/Cargo.toml @@ -32,6 +32,7 @@ launchdarkly-server-sdk = { version = "2.5.1", default-features = false } maplit = "1.0.2" mz-adapter-types = { path = "../adapter-types" } mz-audit-log = { path = "../audit-log" } +mz-auth = { path = "../auth" } mz-build-info = { path = "../build-info" } mz-catalog = { path = "../catalog" } mz-cloud-provider = { path = "../cloud-provider", default-features = false } diff --git a/src/adapter/src/catalog.rs b/src/adapter/src/catalog.rs index 7d80b81e77f0c..2a22dc4affa07 100644 --- a/src/adapter/src/catalog.rs +++ b/src/adapter/src/catalog.rs @@ -41,7 +41,7 @@ use mz_catalog::expr_cache::{ExpressionCacheHandle, GlobalExpressions, LocalExpr use mz_catalog::memory::error::{Error, ErrorKind}; use mz_catalog::memory::objects::{ CatalogCollectionEntry, CatalogEntry, CatalogItem, Cluster, ClusterReplica, Database, - NetworkPolicy, Role, Schema, + NetworkPolicy, Role, RoleAuth, Schema, }; use mz_compute_types::dataflows::DataflowDescription; use mz_controller::clusters::ReplicaLocation; @@ -1114,6 +1114,10 @@ impl Catalog { self.state.try_get_role_by_name(role_name) } + pub fn try_get_role_auth_by_id(&self, id: &RoleId) -> Option<&RoleAuth> { + self.state.try_get_role_auth_by_id(id) + } + /// Creates a new schema in the `Catalog` for temporary items /// indicated by the TEMPORARY or TEMP keywords. pub fn create_temporary_schema( diff --git a/src/adapter/src/catalog/apply.rs b/src/adapter/src/catalog/apply.rs index 3044f9de8a4ff..95c5d290ba814 100644 --- a/src/adapter/src/catalog/apply.rs +++ b/src/adapter/src/catalog/apply.rs @@ -24,13 +24,14 @@ use mz_catalog::builtin::{ BUILTIN_LOG_LOOKUP, BUILTIN_LOOKUP, Builtin, BuiltinLog, BuiltinTable, BuiltinView, }; use mz_catalog::durable::objects::{ - ClusterKey, DatabaseKey, DurableType, ItemKey, NetworkPolicyKey, RoleKey, SchemaKey, + ClusterKey, DatabaseKey, DurableType, ItemKey, NetworkPolicyKey, RoleAuthKey, RoleKey, + SchemaKey, }; use mz_catalog::durable::{CatalogError, SystemObjectMapping}; use mz_catalog::memory::error::{Error, ErrorKind}; use mz_catalog::memory::objects::{ CatalogEntry, CatalogItem, Cluster, ClusterReplica, DataSourceDesc, Database, Func, Index, Log, - NetworkPolicy, Role, Schema, Source, StateDiff, StateUpdate, StateUpdateKind, Table, + NetworkPolicy, Role, RoleAuth, Schema, Source, StateDiff, StateUpdate, StateUpdateKind, Table, TableDataSource, TemporaryItem, Type, UpdateFrom, }; use mz_compute_types::config::ComputeReplicaConfig; @@ -75,6 +76,7 @@ use crate::util::index_sql; #[derive(Debug, Clone, Default)] struct InProgressRetractions { roles: BTreeMap, + role_auths: BTreeMap, databases: BTreeMap, schemas: BTreeMap, clusters: BTreeMap, @@ -214,6 +216,9 @@ impl CatalogState { StateUpdateKind::Role(role) => { self.apply_role_update(role, diff, retractions); } + StateUpdateKind::RoleAuth(role_auth) => { + self.apply_role_auth_update(role_auth, diff, retractions); + } StateUpdateKind::Database(database) => { self.apply_database_update(database, diff, retractions); } @@ -283,6 +288,22 @@ impl CatalogState { Ok(()) } + #[instrument(level = "debug")] + fn apply_role_auth_update( + &mut self, + role_auth: mz_catalog::durable::RoleAuth, + diff: StateDiff, + retractions: &mut InProgressRetractions, + ) { + apply_with_update( + &mut self.role_auth_by_id, + role_auth, + |role_auth| role_auth.role_id, + diff, + &mut retractions.role_auths, + ); + } + #[instrument(level = "debug")] fn apply_role_update( &mut self, @@ -1256,7 +1277,8 @@ impl CatalogState { .pack_network_policy_update(&policy.id, diff) .expect("could not pack audit log update"), StateUpdateKind::StorageCollectionMetadata(_) - | StateUpdateKind::UnfinalizedShard(_) => Vec::new(), + | StateUpdateKind::UnfinalizedShard(_) + | StateUpdateKind::RoleAuth(_) => Vec::new(), } } @@ -1814,6 +1836,7 @@ fn sort_updates_inner(updates: Vec) -> Vec { let diff = update.diff.clone(); match update.kind { StateUpdateKind::Role(_) + | StateUpdateKind::RoleAuth(_) | StateUpdateKind::Database(_) | StateUpdateKind::Schema(_) | StateUpdateKind::DefaultPrivilege(_) diff --git a/src/adapter/src/catalog/consistency.rs b/src/adapter/src/catalog/consistency.rs index b9fe454c1fe87..daaa6ae5d3b28 100644 --- a/src/adapter/src/catalog/consistency.rs +++ b/src/adapter/src/catalog/consistency.rs @@ -186,6 +186,11 @@ impl CatalogState { } } } + for (role_id, _) in &self.role_auth_by_id { + if !self.roles_by_id.contains_key(role_id) { + inconsistencies.push(RoleInconsistency::RoleAuth(role_id.clone())); + } + } for (default_priv, privileges) in self.default_privileges.iter() { if !self.roles_by_id.contains_key(&default_priv.role_id) { inconsistencies.push(RoleInconsistency::DefaultPrivilege(default_priv.clone())); @@ -647,6 +652,7 @@ enum RoleInconsistency { Cluster(ClusterId, RoleId), ClusterReplica(ClusterId, ReplicaId, RoleId), DefaultPrivilege(DefaultPrivilegeObject), + RoleAuth(RoleId), DefaultPrivilegeItem { grantor: RoleId, grantee: RoleId, diff --git a/src/adapter/src/catalog/open.rs b/src/adapter/src/catalog/open.rs index 222ff9772802f..b5cd4551989f8 100644 --- a/src/adapter/src/catalog/open.rs +++ b/src/adapter/src/catalog/open.rs @@ -142,6 +142,7 @@ impl Catalog { roles_by_name: BTreeMap::new(), roles_by_id: BTreeMap::new(), network_policies_by_id: BTreeMap::new(), + role_auth_by_id: BTreeMap::new(), network_policies_by_name: BTreeMap::new(), system_configuration, default_privileges: DefaultPrivileges::default(), @@ -266,6 +267,7 @@ impl Catalog { for (kind, ts, diff) in updates { match kind { BootstrapStateUpdateKind::Role(_) + | BootstrapStateUpdateKind::RoleAuth(_) | BootstrapStateUpdateKind::Database(_) | BootstrapStateUpdateKind::Schema(_) | BootstrapStateUpdateKind::DefaultPrivilege(_) diff --git a/src/adapter/src/catalog/state.rs b/src/adapter/src/catalog/state.rs index c92a7a0b6962a..b1e448cf07084 100644 --- a/src/adapter/src/catalog/state.rs +++ b/src/adapter/src/catalog/state.rs @@ -32,8 +32,8 @@ use mz_catalog::memory::error::{Error, ErrorKind}; use mz_catalog::memory::objects::{ CatalogCollectionEntry, CatalogEntry, CatalogItem, Cluster, ClusterReplica, CommentsMap, Connection, DataSourceDesc, Database, DefaultPrivileges, Index, MaterializedView, - NetworkPolicy, Role, Schema, Secret, Sink, Source, SourceReferences, Table, TableDataSource, - Type, View, + NetworkPolicy, Role, RoleAuth, Schema, Secret, Sink, Source, SourceReferences, Table, + TableDataSource, Type, View, }; use mz_controller::clusters::{ ManagedReplicaAvailabilityZones, ManagedReplicaLocation, ReplicaAllocation, ReplicaLocation, @@ -129,6 +129,8 @@ pub struct CatalogState { pub(super) network_policies_by_name: BTreeMap, #[serde(serialize_with = "mz_ore::serde::map_key_to_string")] pub(super) network_policies_by_id: BTreeMap, + #[serde(serialize_with = "mz_ore::serde::map_key_to_string")] + pub(super) role_auth_by_id: BTreeMap, #[serde(skip)] pub(super) system_configuration: SystemVars, @@ -277,6 +279,7 @@ impl CatalogState { roles_by_name: Default::default(), roles_by_id: Default::default(), network_policies_by_id: Default::default(), + role_auth_by_id: Default::default(), config: CatalogConfig { start_time: Default::default(), start_instant: Instant::now(), @@ -863,6 +866,10 @@ impl CatalogState { .map(|id| &self.roles_by_id[id]) } + pub(super) fn try_get_role_auth_by_id(&self, id: &RoleId) -> Option<&RoleAuth> { + self.role_auth_by_id.get(id) + } + pub(super) fn try_get_network_policy_by_name( &self, policy_name: &str, diff --git a/src/adapter/src/client.rs b/src/adapter/src/client.rs index 3934c79619469..25cf86ae8deec 100644 --- a/src/adapter/src/client.rs +++ b/src/adapter/src/client.rs @@ -21,6 +21,7 @@ use derivative::Derivative; use futures::{Stream, StreamExt}; use itertools::Itertools; use mz_adapter_types::connection::{ConnectionId, ConnectionIdType}; +use mz_auth::password::Password; use mz_build_info::BuildInfo; use mz_compute_types::ComputeInstanceId; use mz_ore::channel::OneshotReceiverExt; @@ -47,7 +48,9 @@ use tracing::error; use uuid::Uuid; use crate::catalog::Catalog; -use crate::command::{CatalogDump, CatalogSnapshot, Command, ExecuteResponse, Response}; +use crate::command::{ + AuthResponse, CatalogDump, CatalogSnapshot, Command, ExecuteResponse, Response, +}; use crate::coord::{Coordinator, ExecuteContextExtra}; use crate::error::AdapterError; use crate::metrics::Metrics; @@ -148,6 +151,22 @@ impl Client { Session::new(self.build_info, config, self.metrics().session_metrics()) } + /// Preforms an authentication check for the given user. + pub async fn authenticate( + &self, + user: &String, + password: &Password, + ) -> Result { + let (tx, rx) = oneshot::channel(); + self.send(Command::AuthenticatePassword { + role_name: user.to_string(), + password: Some(password.clone()), + tx, + }); + let response = rx.await.expect("sender dropped")?; + Ok(response) + } + /// Upgrades this client to a session client. /// /// A session is a connection that has successfully negotiated parameters, @@ -366,6 +385,7 @@ Issue a SQL query to get started. Need help? user: SUPPORT_USER.name.clone(), client_ip: None, external_metadata_rx: None, + internal_user_metadata: None, helm_chart_version: None, }); let mut session_client = self.startup(session).await?; @@ -872,6 +892,7 @@ impl SessionClient { Command::Execute { .. } => typ = Some("execute"), Command::GetWebhook { .. } => typ = Some("webhook"), Command::Startup { .. } + | Command::AuthenticatePassword { .. } | Command::CatalogSnapshot { .. } | Command::Commit { .. } | Command::CancelRequest { .. } diff --git a/src/adapter/src/command.rs b/src/adapter/src/command.rs index b48190755cfe2..368b88776e7a6 100644 --- a/src/adapter/src/command.rs +++ b/src/adapter/src/command.rs @@ -16,6 +16,7 @@ use std::sync::Arc; use derivative::Derivative; use enum_kinds::EnumKind; use mz_adapter_types::connection::{ConnectionId, ConnectionIdType}; +use mz_auth::password::Password; use mz_compute_types::ComputeInstanceId; use mz_ore::collections::CollectionExt; use mz_ore::soft_assert_no_log; @@ -66,6 +67,12 @@ pub enum Command { notice_tx: mpsc::UnboundedSender, }, + AuthenticatePassword { + tx: oneshot::Sender>, + role_name: String, + password: Option, + }, + Execute { portal_name: String, session: Session, @@ -140,6 +147,7 @@ impl Command { Command::Execute { session, .. } | Command::Commit { session, .. } => Some(session), Command::CancelRequest { .. } | Command::Startup { .. } + | Command::AuthenticatePassword { .. } | Command::CatalogSnapshot { .. } | Command::PrivilegedCancelRequest { .. } | Command::GetWebhook { .. } @@ -157,6 +165,7 @@ impl Command { Command::Execute { session, .. } | Command::Commit { session, .. } => Some(session), Command::CancelRequest { .. } | Command::Startup { .. } + | Command::AuthenticatePassword { .. } | Command::CatalogSnapshot { .. } | Command::PrivilegedCancelRequest { .. } | Command::GetWebhook { .. } @@ -193,6 +202,16 @@ pub struct StartupResponse { pub catalog: Arc, } +/// The response to [`Client::authenticate`](crate::Client::authenticate). +#[derive(Derivative)] +#[derivative(Debug)] +pub struct AuthResponse { + /// RoleId for the user. + pub role_id: RoleId, + /// If the user is a superuser. + pub superuser: bool, +} + // Facile implementation for `StartupResponse`, which does not use the `allowed` // feature of `ClientTransmitter`. impl Transmittable for StartupResponse { diff --git a/src/adapter/src/config/backend.rs b/src/adapter/src/config/backend.rs index fa6a52329bbbc..e51f9540b92bc 100644 --- a/src/adapter/src/config/backend.rs +++ b/src/adapter/src/config/backend.rs @@ -34,6 +34,7 @@ impl SystemParameterBackend { user: SYSTEM_USER.name.clone(), client_ip: None, external_metadata_rx: None, + internal_user_metadata: None, helm_chart_version: None, }); let session_client = client.startup(session).await?; diff --git a/src/adapter/src/coord.rs b/src/adapter/src/coord.rs index 1bd561b19dbea..d25b215ceacc5 100644 --- a/src/adapter/src/coord.rs +++ b/src/adapter/src/coord.rs @@ -352,6 +352,7 @@ impl Message { Command::RetireExecute { .. } => "command-retire_execute", Command::CheckConsistency { .. } => "command-check_consistency", Command::Dump { .. } => "command-dump", + Command::AuthenticatePassword { .. } => "command-auth_check", }, Message::ControllerReady => "controller_ready", Message::PurifiedStatementReady(_) => "purified_statement_ready", diff --git a/src/adapter/src/coord/command_handler.rs b/src/adapter/src/coord/command_handler.rs index 62a4f89fe7d38..ce69a9822a851 100644 --- a/src/adapter/src/coord/command_handler.rs +++ b/src/adapter/src/coord/command_handler.rs @@ -12,6 +12,7 @@ use differential_dataflow::lattice::Lattice; use mz_adapter_types::dyncfgs::ALLOW_USER_SESSIONS; +use mz_auth::password::Password; use mz_repr::namespaces::MZ_INTERNAL_SCHEMA; use mz_sql::session::metadata::SessionMetadata; use std::collections::{BTreeMap, BTreeSet}; @@ -58,7 +59,7 @@ use tokio::sync::{mpsc, oneshot}; use tracing::{Instrument, debug_span, info, warn}; use tracing_opentelemetry::OpenTelemetrySpanExt; -use crate::command::{CatalogSnapshot, Command, ExecuteResponse, StartupResponse}; +use crate::command::{AuthResponse, CatalogSnapshot, Command, ExecuteResponse, StartupResponse}; use crate::coord::appends::PendingWriteTxn; use crate::coord::{ ConnMeta, Coordinator, DeferredPlanStatement, Message, PendingTxn, PlanStatement, PlanValidity, @@ -110,6 +111,15 @@ impl Coordinator { .await; } + Command::AuthenticatePassword { + tx, + role_name, + password, + } => { + self.handle_authenticate_password(tx, role_name, password) + .await; + } + Command::Execute { portal_name, session, @@ -236,6 +246,45 @@ impl Coordinator { .boxed_local() } + #[mz_ore::instrument(level = "debug")] + async fn handle_authenticate_password( + &mut self, + tx: oneshot::Sender>, + role_name: String, + password: Option, + ) { + let Some(password) = password else { + // The user did not provide a password. + let _ = tx.send(Err(AdapterError::AuthenticationError)); + return; + }; + + if let Some(role) = self.catalog().try_get_role_by_name(role_name.as_str()) { + if !role.attributes.login.unwrap_or(false) { + // The user is not allowed to login. + let _ = tx.send(Err(AdapterError::AuthenticationError)); + return; + } + if let Some(auth) = self.catalog().try_get_role_auth_by_id(&role.id) { + if let Some(hash) = &auth.password_hash { + let _ = match mz_auth::hash::scram256_verify(&password, hash) { + Ok(_) => tx.send(Ok(AuthResponse { + role_id: role.id, + superuser: role.attributes.superuser.unwrap_or(false), + })), + Err(_) => tx.send(Err(AdapterError::AuthenticationError)), + }; + return; + } + } + // Authentication failed due to incorrect password or missing password hash. + let _ = tx.send(Err(AdapterError::AuthenticationError)); + } else { + // The user does not exist. + let _ = tx.send(Err(AdapterError::AuthenticationError)); + } + } + #[mz_ore::instrument(level = "debug")] async fn handle_startup( &mut self, diff --git a/src/adapter/src/coord/sequencer/inner.rs b/src/adapter/src/coord/sequencer/inner.rs index c4d71d58fdeb3..ae93585b15d66 100644 --- a/src/adapter/src/coord/sequencer/inner.rs +++ b/src/adapter/src/coord/sequencer/inner.rs @@ -22,7 +22,7 @@ use itertools::Itertools; use maplit::btreeset; use mz_adapter_types::compaction::CompactionWindow; use mz_adapter_types::connection::ConnectionId; -use mz_adapter_types::dyncfgs::ENABLE_MULTI_REPLICA_SOURCES; +use mz_adapter_types::dyncfgs::{ENABLE_MULTI_REPLICA_SOURCES, ENABLE_SELF_MANAGED_AUTH}; use mz_catalog::memory::objects::{ CatalogItem, Cluster, Connection, DataSourceDesc, Sink, Source, Table, TableDataSource, Type, }; @@ -52,7 +52,7 @@ use mz_sql::ast::{CreateSubsourceStatement, MySqlConfigOptionName, UnresolvedIte use mz_sql::catalog::{ CatalogCluster, CatalogClusterReplica, CatalogDatabase, CatalogError, CatalogItem as SqlCatalogItem, CatalogItemType, CatalogRole, CatalogSchema, CatalogTypeDetails, - ErrorMessageObjectDescription, ObjectType, RoleVars, SessionCatalog, + ErrorMessageObjectDescription, ObjectType, RoleAttributes, RoleVars, SessionCatalog, }; use mz_sql::names::{ Aug, ObjectId, QualifiedItemName, ResolvedDatabaseSpecifier, ResolvedIds, ResolvedItemName, @@ -986,12 +986,29 @@ impl Coordinator { } } + /// Validates the role attributes for a `CREATE ROLE` statement. + fn validate_role_attributes(&self, attributes: &RoleAttributes) -> Result<(), AdapterError> { + if !ENABLE_SELF_MANAGED_AUTH.get(self.catalog().system_config().dyncfgs()) { + if attributes.superuser.is_some() + || attributes.password.is_some() + || attributes.login.is_some() + { + return Err(AdapterError::UnavailableFeature { + feature: "SUPERUSER, PASSWORD, and LOGIN attributes".to_string(), + docs: Some("https://materialize.com/docs/sql/create-role/#details".to_string()), + }); + } + } + Ok(()) + } + #[instrument] pub(super) async fn sequence_create_role( &mut self, conn_id: Option<&ConnectionId>, plan::CreateRolePlan { name, attributes }: plan::CreateRolePlan, ) -> Result { + self.validate_role_attributes(&attributes.clone())?; let op = catalog::Op::CreateRole { name, attributes }; self.catalog_transact_conn(conn_id, vec![op]) .await @@ -3383,10 +3400,28 @@ impl Coordinator { // Apply our updates. match option { PlannedAlterRoleOption::Attributes(attrs) => { + self.validate_role_attributes(&attrs.clone().into())?; + if let Some(inherit) = attrs.inherit { attributes.inherit = inherit; } + if let Some(password) = attrs.password { + attributes.password = Some(password); + } + + if let Some(superuser) = attrs.superuser { + attributes.superuser = Some(superuser); + } + + if let Some(login) = attrs.login { + attributes.login = Some(login); + } + + if attrs.nopassword.unwrap_or(false) { + attributes.password = None; + } + if let Some(notice) = self.should_emit_rbac_notice(session) { notices.push(notice); } diff --git a/src/adapter/src/coord/validity.rs b/src/adapter/src/coord/validity.rs index 91c75e1d9ab10..15f95234f11f3 100644 --- a/src/adapter/src/coord/validity.rs +++ b/src/adapter/src/coord/validity.rs @@ -223,6 +223,7 @@ mod tests { user, client_ip: None, external_metadata_rx: None, + internal_user_metadata: None, helm_chart_version: None, }, metrics.session_metrics(), diff --git a/src/adapter/src/error.rs b/src/adapter/src/error.rs index 0eda5fdc28eb1..bcf0cc2d40048 100644 --- a/src/adapter/src/error.rs +++ b/src/adapter/src/error.rs @@ -175,6 +175,13 @@ pub enum AdapterError { Unstructured(anyhow::Error), /// The named feature is not supported and will (probably) not be. Unsupported(&'static str), + /// Some feature isn't available for a (potentially opaque) reason. + /// For example, in cloud Self-Managed auth features aren't available, + /// but we don't want to mention self managed auth. + UnavailableFeature { + feature: String, + docs: Option, + }, /// Attempted to read from log sources without selecting a target replica. UntargetedLogRead { log_names: Vec, @@ -231,6 +238,13 @@ pub enum AdapterError { /// read-only mode. ReadOnly, AlterClusterTimeout, + /// Authentication error. This is specifically for self-managed auth + /// and can generally encompass things like "incorrect password" or + /// what have you. We intentionally limit the fidelity of the error + /// we return to avoid allowing an attacker to, for example, + /// enumerate users by spraying login attempts and differentiating + /// between a "no such user" and "incorrect password" error. + AuthenticationError, } impl AdapterError { @@ -522,6 +536,7 @@ impl AdapterError { AdapterError::UnknownClusterReplica { .. } => SqlState::UNDEFINED_OBJECT, AdapterError::UnrecognizedConfigurationParam(_) => SqlState::UNDEFINED_OBJECT, AdapterError::Unsupported(..) => SqlState::FEATURE_NOT_SUPPORTED, + AdapterError::UnavailableFeature { .. } => SqlState::FEATURE_NOT_SUPPORTED, AdapterError::Unstructured(_) => SqlState::INTERNAL_ERROR, AdapterError::UntargetedLogRead { .. } => SqlState::FEATURE_NOT_SUPPORTED, AdapterError::DDLTransactionRace => SqlState::T_R_SERIALIZATION_FAILURE, @@ -550,6 +565,7 @@ impl AdapterError { // transactions. AdapterError::ReadOnly => SqlState::READ_ONLY_SQL_TRANSACTION, AdapterError::AlterClusterTimeout => SqlState::QUERY_CANCELED, + AdapterError::AuthenticationError => SqlState::INVALID_AUTHORIZATION_SPECIFICATION, } } @@ -784,6 +800,19 @@ impl fmt::Display for AdapterError { AdapterError::AlterClusterTimeout => { write!(f, "canceling statement, provided timeout lapsed") } + AdapterError::AuthenticationError => { + write!(f, "authentication error") + } + AdapterError::UnavailableFeature { feature, docs } => { + write!(f, "{} is not supported in this environment.", feature)?; + if let Some(docs) = docs { + write!( + f, + " For more information consult the documentation at {docs}" + )?; + } + Ok(()) + } } } } diff --git a/src/adapter/src/session.rs b/src/adapter/src/session.rs index ba36395275a6c..7d4ee9041fc59 100644 --- a/src/adapter/src/session.rs +++ b/src/adapter/src/session.rs @@ -29,7 +29,7 @@ use mz_ore::metrics::{MetricsFutureExt, MetricsRegistry}; use mz_ore::now::{EpochMillis, NowFn}; use mz_pgwire_common::Format; use mz_repr::role_id::RoleId; -use mz_repr::user::ExternalUserMetadata; +use mz_repr::user::{ExternalUserMetadata, InternalUserMetadata}; use mz_repr::{CatalogItemId, Datum, Row, RowIterator, ScalarType, TimestampManipulation}; use mz_sql::ast::{AstInfo, Raw, Statement, TransactionAccessMode}; use mz_sql::plan::{Params, PlanContext, QueryWhen, StatementDesc}; @@ -204,6 +204,8 @@ pub struct SessionConfig { /// An optional receiver that the session will periodically check for /// updates to a user's external metadata. pub external_metadata_rx: Option>, + /// The metadata of the user associated with the session. + pub internal_user_metadata: Option, /// Helm chart version pub helm_chart_version: Option, } @@ -287,6 +289,7 @@ impl Session { user: SYSTEM_USER.name.clone(), client_ip: None, external_metadata_rx: None, + internal_user_metadata: None, helm_chart_version: None, }, metrics, @@ -303,6 +306,7 @@ impl Session { user, client_ip, mut external_metadata_rx, + internal_user_metadata, helm_chart_version, }: SessionConfig, metrics: SessionMetrics, @@ -311,6 +315,7 @@ impl Session { let default_cluster = INTERNAL_USER_NAME_TO_DEFAULT_CLUSTER.get(&user); let user = User { name: user, + internal_metadata: internal_user_metadata, external_metadata: external_metadata_rx .as_mut() .map(|rx| rx.borrow_and_update().clone()), diff --git a/src/auth/BUILD.bazel b/src/auth/BUILD.bazel new file mode 100644 index 0000000000000..18952a0127d1e --- /dev/null +++ b/src/auth/BUILD.bazel @@ -0,0 +1,82 @@ +# Code generated by cargo-gazelle DO NOT EDIT + +# Copyright Materialize, Inc. and contributors. All rights reserved. +# +# Use of this software is governed by the Business Source License +# included in the LICENSE file at the root of this repository. +# +# 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. + +load("@crates_io//:defs.bzl", "aliases", "all_crate_deps") +load("@rules_rust//cargo:defs.bzl", "extract_cargo_lints") +load("@rules_rust//rust:defs.bzl", "rust_doc_test", "rust_library", "rust_test") + +package(default_visibility = ["//visibility:public"]) + +rust_library( + name = "mz_auth", + srcs = glob(["src/**/*.rs"]), + aliases = aliases( + normal = True, + proc_macro = True, + ), + compile_data = [], + crate_features = ["default"], + data = [], + lint_config = ":lints", + proc_macro_deps = [] + all_crate_deps(proc_macro = True), + rustc_env = {}, + rustc_flags = [], + version = "0.0.0", + deps = ["//src/ore:mz_ore"] + all_crate_deps(normal = True), +) + +alias( + name = "auth", + actual = "mz_auth", +) + +rust_test( + name = "mz_auth_lib_tests", + size = "medium", + aliases = aliases( + normal = True, + normal_dev = True, + proc_macro = True, + proc_macro_dev = True, + ), + compile_data = [], + crate = ":mz_auth", + crate_features = ["default"], + data = [], + env = {}, + lint_config = ":lints", + proc_macro_deps = [] + all_crate_deps( + proc_macro = True, + proc_macro_dev = True, + ), + rustc_env = {}, + rustc_flags = [], + version = "0.0.0", + deps = ["//src/ore:mz_ore"] + all_crate_deps( + normal = True, + normal_dev = True, + ), +) + +rust_doc_test( + name = "mz_auth_doc_test", + crate = ":mz_auth", + deps = ["//src/ore:mz_ore"] + all_crate_deps( + normal = True, + normal_dev = True, + ), +) + +extract_cargo_lints( + name = "lints", + manifest = "Cargo.toml", + workspace = "@//:Cargo.toml", +) diff --git a/src/auth/Cargo.toml b/src/auth/Cargo.toml new file mode 100644 index 0000000000000..f9272b0bfa108 --- /dev/null +++ b/src/auth/Cargo.toml @@ -0,0 +1,23 @@ +[package] +name = "mz-auth" +description = "Shared authentication logic." +version = "0.0.0" +edition.workspace = true +rust-version.workspace = true +publish = false + +[lints] +workspace = true + +[dependencies] +base64 = "0.22.1" +mz-ore = { path = "../ore", features = ["test"] } +workspace-hack = { version = "0.0.0", path = "../workspace-hack", optional = true } +serde = "1.0.219" +proptest-derive = "0.5.1" +proptest = "1.6.0" +static_assertions = "1.1" +openssl = { version = "0.10.71", features = ["vendored"] } + +[features] +default = ["workspace-hack"] diff --git a/src/auth/src/hash.rs b/src/auth/src/hash.rs new file mode 100644 index 0000000000000..924872f61510c --- /dev/null +++ b/src/auth/src/hash.rs @@ -0,0 +1,249 @@ +// 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. + +// Clippy misreads some doc comments as HTML tags, so we disable the lint +#![allow(rustdoc::invalid_html_tags)] + +use std::fmt::Display; +use std::num::NonZeroU32; + +use base64::prelude::*; + +use crate::password::Password; + +/// The default iteration count as suggested by +/// +const DEFAULT_ITERATIONS: NonZeroU32 = NonZeroU32::new(600_000).unwrap(); + +/// The default salt size, which isn't currently configurable. +const DEFAULT_SALT_SIZE: usize = 32; + +const SHA256_OUTPUT_LEN: usize = 32; + +/// The options for hashing a password +pub struct HashOpts { + /// The number of iterations to use for PBKDF2 + pub iterations: NonZeroU32, + /// The salt to use for PBKDF2. It is up to the caller to + /// ensure that however the salt is generated, it is cryptographically + /// secure. + pub salt: [u8; DEFAULT_SALT_SIZE], +} + +pub struct PasswordHash { + /// The salt used for hashing + pub salt: [u8; DEFAULT_SALT_SIZE], + /// The number of iterations used for hashing + pub iterations: NonZeroU32, + /// The hash of the password. + /// This is the result of PBKDF2 with SHA256 + pub hash: [u8; SHA256_OUTPUT_LEN], +} + +#[derive(Debug)] +pub enum VerifyError { + MalformedHash, + InvalidPassword, + Hash(HashError), +} + +#[derive(Debug)] +pub enum HashError { + Openssl(openssl::error::ErrorStack), +} + +/// Hashes a password using PBKDF2 with SHA256 +/// and a random salt. +pub fn hash_password(password: &Password) -> Result { + let mut salt = [0u8; DEFAULT_SALT_SIZE]; + openssl::rand::rand_bytes(&mut salt).map_err(HashError::Openssl)?; + + let hash = hash_password_inner( + &HashOpts { + iterations: DEFAULT_ITERATIONS, + salt, + }, + password.to_string().as_bytes(), + )?; + + Ok(PasswordHash { + salt, + iterations: DEFAULT_ITERATIONS, + hash, + }) +} + +/// Hashes a password using PBKDF2 with SHA256 +/// and the given options. +pub fn hash_password_with_opts( + opts: &HashOpts, + password: &Password, +) -> Result { + let hash = hash_password_inner(opts, password.to_string().as_bytes())?; + + Ok(PasswordHash { + salt: opts.salt, + iterations: opts.iterations, + hash, + }) +} + +/// Hashes a password using PBKDF2 with SHA256, +/// and returns it in the SCRAM-SHA-256 format. +/// The format is SCRAM-SHA-256$:$: +pub fn scram256_hash(password: &Password) -> Result { + let hashed_password = hash_password(password)?; + Ok(scram256_hash_inner(hashed_password).to_string()) +} + +/// Verifies a password against a SCRAM-SHA-256 hash. +pub fn scram256_verify(password: &Password, hashed_password: &str) -> Result<(), VerifyError> { + let opts = scram256_parse_opts(hashed_password)?; + let hashed = hash_password_with_opts(&opts, password).map_err(VerifyError::Hash)?; + let scram = scram256_hash_inner(hashed); + if *hashed_password == scram.to_string() { + Ok(()) + } else { + Err(VerifyError::InvalidPassword) + } +} + +/// Parses a SCRAM-SHA-256 hash and returns the options used to create it. +fn scram256_parse_opts(hashed_password: &str) -> Result { + let parts: Vec<&str> = hashed_password.split('$').collect(); + if parts.len() != 3 { + return Err(VerifyError::MalformedHash); + } + let scheme = parts[0]; + if scheme != "SCRAM-SHA-256" { + return Err(VerifyError::MalformedHash); + } + let auth_info = parts[1].split(':').collect::>(); + if auth_info.len() != 2 { + return Err(VerifyError::MalformedHash); + } + let auth_value = parts[2].split(':').collect::>(); + if auth_value.len() != 2 { + return Err(VerifyError::MalformedHash); + } + + let iterations = auth_info[0] + .parse::() + .map_err(|_| VerifyError::MalformedHash)?; + + let salt = BASE64_STANDARD + .decode(auth_info[1]) + .map_err(|_| VerifyError::MalformedHash)?; + + let salt = salt.try_into().map_err(|_| VerifyError::MalformedHash)?; + + Ok(HashOpts { + iterations: NonZeroU32::new(iterations).ok_or(VerifyError::MalformedHash)?, + salt, + }) +} + +/// The SCRAM-SHA-256 hash +struct ScramSha256Hash { + /// The number of iterations used for hashing + iterations: NonZeroU32, + /// The salt used for hashing + salt: [u8; 32], + /// The server key + server_key: [u8; SHA256_OUTPUT_LEN], + /// The client key + client_key: [u8; SHA256_OUTPUT_LEN], +} + +impl Display for ScramSha256Hash { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!( + f, + "SCRAM-SHA-256${}:{}${}:{}", + self.iterations, + BASE64_STANDARD.encode(&self.salt), + BASE64_STANDARD.encode(&self.client_key), + BASE64_STANDARD.encode(&self.server_key) + ) + } +} + +fn scram256_hash_inner(hashed_password: PasswordHash) -> ScramSha256Hash { + let signing_key = openssl::pkey::PKey::hmac(&hashed_password.hash).unwrap(); + let mut signer = + openssl::sign::Signer::new(openssl::hash::MessageDigest::sha256(), &signing_key).unwrap(); + signer.update(b"Client Key").unwrap(); + let client_key = signer.sign_to_vec().unwrap(); + let mut signer = + openssl::sign::Signer::new(openssl::hash::MessageDigest::sha256(), &signing_key).unwrap(); + signer.update(b"Server Key").unwrap(); + let server_key = signer.sign_to_vec().unwrap(); + + ScramSha256Hash { + iterations: hashed_password.iterations, + salt: hashed_password.salt, + server_key: server_key.try_into().unwrap(), + client_key: client_key.try_into().unwrap(), + } +} + +fn hash_password_inner( + opts: &HashOpts, + password: &[u8], +) -> Result<[u8; SHA256_OUTPUT_LEN], HashError> { + let mut salted_password = [0u8; SHA256_OUTPUT_LEN]; + openssl::pkcs5::pbkdf2_hmac( + password, + &opts.salt, + opts.iterations.get().try_into().unwrap(), + openssl::hash::MessageDigest::sha256(), + &mut salted_password, + ) + .map_err(HashError::Openssl)?; + Ok(salted_password) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[mz_ore::test] + fn test_hash_password() { + let password = "password".to_string(); + let hashed_password = hash_password(&password.into()).expect("Failed to hash password"); + assert_eq!(hashed_password.iterations, DEFAULT_ITERATIONS); + assert_eq!(hashed_password.salt.len(), DEFAULT_SALT_SIZE); + assert_eq!(hashed_password.hash.len(), SHA256_OUTPUT_LEN); + } + + #[mz_ore::test] + fn test_scram256_hash() { + let password = "password".into(); + let scram_hash = scram256_hash(&password).expect("Failed to hash password"); + + let res = scram256_verify(&password, &scram_hash); + assert!(res.is_ok()); + let res = scram256_verify(&"wrong_password".into(), &scram_hash); + assert!(res.is_err()); + } + + #[mz_ore::test] + fn test_scram256_parse_opts() { + let salt = "9bkIQQjQ7f1OwPsXZGC/YfIkbZsOMDXK0cxxvPBaSfM="; + let hashed_password = format!("SCRAM-SHA-256$600000:{}$client-key:server-key", salt); + let opts = scram256_parse_opts(&hashed_password); + + assert!(opts.is_ok()); + let opts = opts.unwrap(); + assert_eq!(opts.iterations, DEFAULT_ITERATIONS); + assert_eq!(opts.salt.len(), DEFAULT_SALT_SIZE); + let decoded_salt = BASE64_STANDARD.decode(salt).expect("Failed to decode salt"); + assert_eq!(opts.salt, decoded_salt.as_ref()); + } +} diff --git a/src/auth/src/lib.rs b/src/auth/src/lib.rs new file mode 100644 index 0000000000000..174a798681d2f --- /dev/null +++ b/src/auth/src/lib.rs @@ -0,0 +1,11 @@ +// 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. + +pub mod hash; +pub mod password; diff --git a/src/auth/src/password.rs b/src/auth/src/password.rs new file mode 100644 index 0000000000000..946a3705e9455 --- /dev/null +++ b/src/auth/src/password.rs @@ -0,0 +1,44 @@ +// 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 proptest_derive::Arbitrary; +use serde::{Deserialize, Serialize}; +use std::fmt::{Debug, Display}; + +use static_assertions::assert_not_impl_all; + +///Password is a String wrapper type that does not implement Display or Debug +#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, PartialOrd, Ord, Arbitrary)] +pub struct Password(pub String); + +assert_not_impl_all!(Password: Display); + +impl From for Password { + fn from(password: String) -> Self { + Password(password) + } +} + +impl From<&str> for Password { + fn from(password: &str) -> Self { + Password(password.to_string()) + } +} + +impl ToString for Password { + fn to_string(&self) -> String { + self.0.clone() + } +} + +impl Debug for Password { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "Password(****)") + } +} diff --git a/src/buf.yaml b/src/buf.yaml index 17a50406e49fd..2304df4f0fc71 100644 --- a/src/buf.yaml +++ b/src/buf.yaml @@ -32,6 +32,8 @@ breaking: # reason: does currently not require backward-compatibility - catalog-protos/protos/objects_v73.proto # reason: does currently not require backward-compatibility + - catalog-protos/protos/objects_v74.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-debug/src/main.rs b/src/catalog-debug/src/main.rs index feabc28e34a99..d56ee1a393189 100644 --- a/src/catalog-debug/src/main.rs +++ b/src/catalog-debug/src/main.rs @@ -34,8 +34,8 @@ use mz_catalog::durable::debug::{ AuditLogCollection, ClusterCollection, ClusterIntrospectionSourceIndexCollection, ClusterReplicaCollection, Collection, CollectionTrace, CollectionType, CommentCollection, ConfigCollection, DatabaseCollection, DebugCatalogState, DefaultPrivilegeCollection, - IdAllocatorCollection, ItemCollection, NetworkPolicyCollection, RoleCollection, - SchemaCollection, SettingCollection, SourceReferencesCollection, + IdAllocatorCollection, ItemCollection, NetworkPolicyCollection, RoleAuthCollection, + RoleCollection, SchemaCollection, SettingCollection, SourceReferencesCollection, StorageCollectionMetadataCollection, SystemConfigurationCollection, SystemItemMappingCollection, SystemPrivilegeCollection, Trace, TxnWalShardCollection, UnfinalizedShardsCollection, @@ -291,6 +291,7 @@ macro_rules! for_collection { CollectionType::Item => $fn::($($arg),*).await?, CollectionType::NetworkPolicy => $fn::($($arg),*).await?, CollectionType::Role => $fn::($($arg),*).await?, + CollectionType::RoleAuth => $fn::($($arg),*).await?, CollectionType::Schema => $fn::($($arg),*).await?, CollectionType::Setting => $fn::($($arg),*).await?, CollectionType::SourceReferences => $fn::($($arg),*).await?, @@ -436,6 +437,7 @@ async fn dump( items, network_policies, roles, + role_auth, schemas, settings, source_references, @@ -489,6 +491,7 @@ async fn dump( consolidate, ); dump_col(&mut data, roles, &ignore, stats_only, consolidate); + dump_col(&mut data, role_auth, &ignore, stats_only, consolidate); dump_col(&mut data, schemas, &ignore, stats_only, consolidate); dump_col(&mut data, settings, &ignore, stats_only, consolidate); dump_col( diff --git a/src/catalog-protos/protos/hashes.json b/src/catalog-protos/protos/hashes.json index 968d7a7e53a16..fb73f62a75073 100644 --- a/src/catalog-protos/protos/hashes.json +++ b/src/catalog-protos/protos/hashes.json @@ -1,7 +1,7 @@ [ { "name": "objects.proto", - "md5": "65c8ec9661c8a207bc9eb5af098fa98f" + "md5": "1ee448278aa47b301388844a9a8e58c0" }, { "name": "objects_v67.proto", @@ -30,5 +30,9 @@ { "name": "objects_v73.proto", "md5": "d5d1a8c6b1aa8212245cfd343a3b8417" + }, + { + "name": "objects_v74.proto", + "md5": "f8dd1defd3b20c13ecca54b0321d5d25" } ] diff --git a/src/catalog-protos/protos/objects.proto b/src/catalog-protos/protos/objects.proto index 37b099171dff3..774daf7c48a8f 100644 --- a/src/catalog-protos/protos/objects.proto +++ b/src/catalog-protos/protos/objects.proto @@ -152,6 +152,15 @@ message RoleValue { uint32 oid = 5; } +message RoleAuthKey { + RoleId id = 1; +} + +message RoleAuthValue { + optional string password_hash = 1; + EpochMillis updated_at = 2; +} + message NetworkPolicyKey { NetworkPolicyId id = 1; } @@ -475,6 +484,8 @@ message RoleId { message RoleAttributes { bool inherit = 1; + optional bool superuser = 2; + optional bool login = 3; } message RoleMembership { @@ -989,6 +1000,11 @@ message StateUpdateKind { RoleValue value = 2; } + message RoleAuth { + RoleAuthKey key = 1; + RoleAuthValue value = 2; + } + message NetworkPolicy { NetworkPolicyKey key = 1; NetworkPolicyValue value = 2; @@ -1069,5 +1085,6 @@ message StateUpdateKind { SourceReferences source_references = 24; FenceToken fence_token = 25; NetworkPolicy network_policy = 26; + RoleAuth role_auth = 27; } } diff --git a/src/catalog-protos/protos/objects_v74.proto b/src/catalog-protos/protos/objects_v74.proto new file mode 100644 index 0000000000000..fc7a8b423f5ac --- /dev/null +++ b/src/catalog-protos/protos/objects_v74.proto @@ -0,0 +1,1090 @@ +// 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_v74; + +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 RoleAuthKey { + RoleId id = 1; +} + +message RoleAuthValue { + optional string password_hash = 1; + EpochMillis updated_at = 2; +} + +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; + uint64 introspection_source_index = 4; + } +} + +/// 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 { + uint64 system = 1; + uint64 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; + optional bool superuser = 2; + optional bool login = 3; +} + +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 RoleAuth { + RoleAuthKey key = 1; + RoleAuthValue 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; + RoleAuth role_auth = 27; + } +} diff --git a/src/catalog-protos/src/lib.rs b/src/catalog-protos/src/lib.rs index afa882d656a0b..9a075a405be7a 100644 --- a/src/catalog-protos/src/lib.rs +++ b/src/catalog-protos/src/lib.rs @@ -24,7 +24,7 @@ pub mod serialization; /// We will initialize new `Catalog`s with this version, and migrate existing `Catalog`s 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 = 73; +pub const CATALOG_VERSION: u64 = 74; /// The minimum `Catalog` version number that we support migrating from. /// @@ -46,7 +46,7 @@ macro_rules! proto_objects { }; } -proto_objects!(v67, v68, v69, v70, v71, v72, v73); +proto_objects!(v67, v68, v69, v70, v71, v72, v73, v74); #[cfg(test)] mod tests { diff --git a/src/catalog-protos/src/serialization.rs b/src/catalog-protos/src/serialization.rs index 07fa47f2dd5c8..8f97be4c42f4b 100644 --- a/src/catalog-protos/src/serialization.rs +++ b/src/catalog-protos/src/serialization.rs @@ -116,6 +116,8 @@ impl RustType for RoleAttributes { fn into_proto(&self) -> crate::objects::RoleAttributes { crate::objects::RoleAttributes { inherit: self.inherit, + superuser: self.superuser, + login: self.login, } } @@ -123,6 +125,8 @@ impl RustType for RoleAttributes { let mut attributes = RoleAttributes::new(); attributes.inherit = proto.inherit; + attributes.superuser = proto.superuser; + attributes.login = proto.login; Ok(attributes) } diff --git a/src/catalog/BUILD.bazel b/src/catalog/BUILD.bazel index f0b4fdb7411e3..e14cb2cff84a4 100644 --- a/src/catalog/BUILD.bazel +++ b/src/catalog/BUILD.bazel @@ -33,6 +33,7 @@ rust_library( deps = [ "//src/adapter-types:mz_adapter_types", "//src/audit-log:mz_audit_log", + "//src/auth:mz_auth", "//src/build-info:mz_build_info", "//src/catalog-protos:mz_catalog_protos", "//src/cloud-resources:mz_cloud_resources", @@ -89,6 +90,7 @@ rust_test( deps = [ "//src/adapter-types:mz_adapter_types", "//src/audit-log:mz_audit_log", + "//src/auth:mz_auth", "//src/build-info:mz_build_info", "//src/build-tools:mz_build_tools", "//src/catalog-protos:mz_catalog_protos", @@ -125,6 +127,7 @@ rust_doc_test( deps = [ "//src/adapter-types:mz_adapter_types", "//src/audit-log:mz_audit_log", + "//src/auth:mz_auth", "//src/build-info:mz_build_info", "//src/build-tools:mz_build_tools", "//src/catalog-protos:mz_catalog_protos", @@ -182,6 +185,7 @@ rust_test( ":mz_catalog", "//src/adapter-types:mz_adapter_types", "//src/audit-log:mz_audit_log", + "//src/auth:mz_auth", "//src/build-info:mz_build_info", "//src/build-tools:mz_build_tools", "//src/catalog-protos:mz_catalog_protos", @@ -239,6 +243,7 @@ rust_test( ":mz_catalog", "//src/adapter-types:mz_adapter_types", "//src/audit-log:mz_audit_log", + "//src/auth:mz_auth", "//src/build-info:mz_build_info", "//src/build-tools:mz_build_tools", "//src/catalog-protos:mz_catalog_protos", @@ -296,6 +301,7 @@ rust_test( ":mz_catalog", "//src/adapter-types:mz_adapter_types", "//src/audit-log:mz_audit_log", + "//src/auth:mz_auth", "//src/build-info:mz_build_info", "//src/build-tools:mz_build_tools", "//src/catalog-protos:mz_catalog_protos", diff --git a/src/catalog/Cargo.toml b/src/catalog/Cargo.toml index 93705528acdda..a12759ce976df 100644 --- a/src/catalog/Cargo.toml +++ b/src/catalog/Cargo.toml @@ -24,6 +24,7 @@ ipnet = "2.11.0" itertools = "0.12.1" mz-adapter-types = { path = "../adapter-types" } mz-audit-log = { path = "../audit-log" } +mz-auth = { path = "../auth" } mz-build-info = { path = "../build-info" } mz-catalog-protos = { path = "../catalog-protos" } mz-cloud-resources = { path = "../cloud-resources" } diff --git a/src/catalog/src/durable.rs b/src/catalog/src/durable.rs index 089efb991eb52..3f896331a02b2 100644 --- a/src/catalog/src/durable.rs +++ b/src/catalog/src/durable.rs @@ -35,8 +35,9 @@ use crate::durable::objects::{AuditLog, Snapshot}; pub use crate::durable::objects::{ Cluster, ClusterConfig, ClusterReplica, ClusterVariant, ClusterVariantManaged, Comment, Database, DefaultPrivilege, IntrospectionSourceIndex, Item, NetworkPolicy, ReplicaConfig, - ReplicaLocation, Role, Schema, SourceReference, SourceReferences, StorageCollectionMetadata, - SystemConfiguration, SystemObjectDescription, SystemObjectMapping, UnfinalizedShard, + ReplicaLocation, Role, RoleAuth, Schema, SourceReference, SourceReferences, + StorageCollectionMetadata, SystemConfiguration, SystemObjectDescription, SystemObjectMapping, + UnfinalizedShard, }; pub use crate::durable::persist::shard_id; use crate::durable::persist::{Timestamp, UnopenedPersistCatalogState}; diff --git a/src/catalog/src/durable/debug.rs b/src/catalog/src/durable/debug.rs index a66eb4a773a8f..5586053e8bc69 100644 --- a/src/catalog/src/durable/debug.rs +++ b/src/catalog/src/durable/debug.rs @@ -65,6 +65,7 @@ pub enum CollectionType { Item, NetworkPolicy, Role, + RoleAuth, Schema, Setting, SourceReferences, @@ -215,6 +216,14 @@ collection_impl!({ trace_field: roles, update: StateUpdateKind::Role, }); +collection_impl!({ + name: RoleAuthCollection, + key: proto::RoleAuthKey, + value: proto::RoleAuthValue, + collection_type: CollectionType::RoleAuth, + trace_field: role_auth, + update: StateUpdateKind::RoleAuth, +}); collection_impl!({ name: SchemaCollection, key: proto::SchemaKey, @@ -331,6 +340,7 @@ pub struct Trace { pub items: CollectionTrace, pub network_policies: CollectionTrace, pub roles: CollectionTrace, + pub role_auth: CollectionTrace, pub schemas: CollectionTrace, pub settings: CollectionTrace, pub source_references: CollectionTrace, @@ -357,6 +367,7 @@ impl Trace { items: CollectionTrace::new(), network_policies: CollectionTrace::new(), roles: CollectionTrace::new(), + role_auth: CollectionTrace::new(), schemas: CollectionTrace::new(), settings: CollectionTrace::new(), source_references: CollectionTrace::new(), @@ -383,6 +394,7 @@ impl Trace { items, network_policies, roles, + role_auth, schemas, settings, source_references, @@ -405,6 +417,7 @@ impl Trace { items.sort(); network_policies.sort(); roles.sort(); + role_auth.sort(); schemas.sort(); settings.sort(); source_references.sort(); diff --git a/src/catalog/src/durable/objects.rs b/src/catalog/src/durable/objects.rs index 7b8dadc02f2d6..69ab75fc113e4 100644 --- a/src/catalog/src/durable/objects.rs +++ b/src/catalog/src/durable/objects.rs @@ -209,6 +209,44 @@ impl DurableType for Role { } } +#[derive(Debug, Clone, Ord, PartialOrd, PartialEq, Eq)] +pub struct RoleAuth { + pub role_id: RoleId, + pub password_hash: Option, + pub updated_at: u64, +} + +impl DurableType for RoleAuth { + type Key = RoleAuthKey; + type Value = RoleAuthValue; + + fn into_key_value(self) -> (Self::Key, Self::Value) { + ( + RoleAuthKey { + role_id: self.role_id, + }, + RoleAuthValue { + password_hash: self.password_hash, + updated_at: self.updated_at, + }, + ) + } + + fn from_key_value(key: Self::Key, value: Self::Value) -> Self { + Self { + role_id: key.role_id, + password_hash: value.password_hash, + updated_at: value.updated_at, + } + } + + fn key(&self) -> Self::Key { + RoleAuthKey { + role_id: self.role_id, + } + } +} + #[derive(Debug, Clone, Ord, PartialOrd, PartialEq, Eq)] pub struct NetworkPolicy { pub name: String, @@ -1112,6 +1150,7 @@ pub struct Snapshot { pub databases: BTreeMap, pub schemas: BTreeMap, pub roles: BTreeMap, + pub role_auth: BTreeMap, pub items: BTreeMap, pub comments: BTreeMap, pub clusters: BTreeMap, @@ -1443,6 +1482,20 @@ pub struct SystemPrivilegesValue { pub(crate) acl_mode: AclMode, } +#[derive(Debug, Clone, PartialOrd, PartialEq, Eq, Ord, Hash)] +pub struct RoleAuthKey { + // TODO(auth): Depending on what the future holds, here is where + // we might also want to key by a `version` field. + // That way we can store password versions or what have you. + pub(crate) role_id: RoleId, +} + +#[derive(Debug, Clone, PartialOrd, PartialEq, Eq, Ord, Hash)] +pub struct RoleAuthValue { + pub(crate) password_hash: Option, + pub(crate) updated_at: u64, +} + #[cfg(test)] mod test { use mz_proto::{ProtoType, RustType}; diff --git a/src/catalog/src/durable/objects/serialization.rs b/src/catalog/src/durable/objects/serialization.rs index 80f44f4080776..41b0b04ef2103 100644 --- a/src/catalog/src/durable/objects/serialization.rs +++ b/src/catalog/src/durable/objects/serialization.rs @@ -29,6 +29,8 @@ use crate::durable::{ ClusterConfig, ClusterVariant, ClusterVariantManaged, ReplicaConfig, ReplicaLocation, }; +use super::{RoleAuthKey, RoleAuthValue}; + pub mod proto { pub use mz_catalog_protos::objects::*; } @@ -621,6 +623,40 @@ impl RustType for RoleValue { } } +impl RustType for RoleAuthKey { + fn into_proto(&self) -> proto::RoleAuthKey { + proto::RoleAuthKey { + id: Some(self.role_id.into_proto()), + } + } + + fn from_proto(proto: proto::RoleAuthKey) -> Result { + Ok(RoleAuthKey { + role_id: proto.id.into_rust_if_some("RoleAuthKey::id")?, + }) + } +} + +impl RustType for RoleAuthValue { + fn into_proto(&self) -> proto::RoleAuthValue { + proto::RoleAuthValue { + password_hash: self.password_hash.clone(), + updated_at: Some(proto::EpochMillis { + millis: self.updated_at, + }), + } + } + + fn from_proto(proto: proto::RoleAuthValue) -> Result { + Ok(RoleAuthValue { + password_hash: proto.password_hash, + updated_at: proto + .updated_at + .into_rust_if_some("RoleAuthValue::updated_at")?, + }) + } +} + impl RustType for NetworkPolicyKey { fn into_proto(&self) -> proto::NetworkPolicyKey { proto::NetworkPolicyKey { diff --git a/src/catalog/src/durable/objects/state_update.rs b/src/catalog/src/durable/objects/state_update.rs index 7e3041a41eafb..12f4be1e02515 100644 --- a/src/catalog/src/durable/objects/state_update.rs +++ b/src/catalog/src/durable/objects/state_update.rs @@ -137,6 +137,7 @@ impl StateUpdate { items, comments, roles, + role_auth, clusters, cluster_replicas, network_policies, @@ -160,6 +161,7 @@ impl StateUpdate { let items = from_batch(items, StateUpdateKind::Item); let comments = from_batch(comments, StateUpdateKind::Comment); let roles = from_batch(roles, StateUpdateKind::Role); + let role_auth = from_batch(role_auth, StateUpdateKind::RoleAuth); let clusters = from_batch(clusters, StateUpdateKind::Cluster); let cluster_replicas = from_batch(cluster_replicas, StateUpdateKind::ClusterReplica); let network_policies = from_batch(network_policies, StateUpdateKind::NetworkPolicy); @@ -190,6 +192,7 @@ impl StateUpdate { .chain(items) .chain(comments) .chain(roles) + .chain(role_auth) .chain(clusters) .chain(cluster_replicas) .chain(network_policies) @@ -231,6 +234,7 @@ pub enum StateUpdateKind { Item(proto::ItemKey, proto::ItemValue), NetworkPolicy(proto::NetworkPolicyKey, proto::NetworkPolicyValue), Role(proto::RoleKey, proto::RoleValue), + RoleAuth(proto::RoleAuthKey, proto::RoleAuthValue), Schema(proto::SchemaKey, proto::SchemaValue), Setting(proto::SettingKey, proto::SettingValue), SourceReferences(proto::SourceReferencesKey, proto::SourceReferencesValue), @@ -266,6 +270,7 @@ impl StateUpdateKind { StateUpdateKind::Item(_, _) => Some(CollectionType::Item), StateUpdateKind::NetworkPolicy(_, _) => Some(CollectionType::NetworkPolicy), StateUpdateKind::Role(_, _) => Some(CollectionType::Role), + StateUpdateKind::RoleAuth(_, _) => Some(CollectionType::RoleAuth), StateUpdateKind::Schema(_, _) => Some(CollectionType::Schema), StateUpdateKind::Setting(_, _) => Some(CollectionType::Setting), StateUpdateKind::SourceReferences(_, _) => Some(CollectionType::SourceReferences), @@ -473,6 +478,10 @@ impl TryFrom<&StateUpdateKind> for Option { let role = into_durable(key, value)?; Some(memory::objects::StateUpdateKind::Role(role)) } + StateUpdateKind::RoleAuth(key, value) => { + let role_auth = into_durable(key, value)?; + Some(memory::objects::StateUpdateKind::RoleAuth(role_auth)) + } StateUpdateKind::Schema(key, value) => { let schema = into_durable(key, value)?; Some(memory::objects::StateUpdateKind::Schema(schema)) @@ -664,6 +673,12 @@ impl RustType for StateUpdateKind { value: Some(value), }) } + StateUpdateKind::RoleAuth(key, value) => { + proto::state_update_kind::Kind::RoleAuth(proto::state_update_kind::RoleAuth { + key: Some(key), + value: Some(value), + }) + } StateUpdateKind::Schema(key, value) => { proto::state_update_kind::Kind::Schema(proto::state_update_kind::Schema { key: Some(key), @@ -870,6 +885,17 @@ impl RustType for StateUpdateKind { TryFromProtoError::missing_field("state_update_kind::Role::value") })?, ), + proto::state_update_kind::Kind::RoleAuth(proto::state_update_kind::RoleAuth { + key, + value, + }) => StateUpdateKind::RoleAuth( + key.ok_or_else(|| { + TryFromProtoError::missing_field("state_update_kind::RoleAuth::key") + })?, + value.ok_or_else(|| { + TryFromProtoError::missing_field("state_update_kind::RoleAuth::value") + })?, + ), proto::state_update_kind::Kind::Schema(proto::state_update_kind::Schema { key, value, diff --git a/src/catalog/src/durable/persist.rs b/src/catalog/src/durable/persist.rs index 50c667f4cc547..66bcce1e7f993 100644 --- a/src/catalog/src/durable/persist.rs +++ b/src/catalog/src/durable/persist.rs @@ -636,7 +636,6 @@ impl> PersistHandle { } } ListenEvent::Updates(batch_updates) => { - debug!("syncing updates {batch_updates:?}"); for update in batch_updates { let update: StateUpdate = update.into(); updates.entry(update.ts).or_default().push(update); @@ -860,6 +859,9 @@ impl> PersistHandle { StateUpdateKind::TxnWalShard((), value) => { apply(&mut snapshot.txn_wal_shard, &(), value, diff); } + StateUpdateKind::RoleAuth(key, value) => { + apply(&mut snapshot.role_auth, key, value, diff); + } } } f(snapshot) @@ -1995,6 +1997,7 @@ impl Trace { StateUpdateKind::TxnWalShard((), v) => { trace.txn_wal_shard.values.push((((), v), ts, diff)) } + StateUpdateKind::RoleAuth(k, v) => trace.role_auth.values.push(((k, v), ts, diff)), } } trace diff --git a/src/catalog/src/durable/transaction.rs b/src/catalog/src/durable/transaction.rs index e14254669f4ac..84fd1181deb42 100644 --- a/src/catalog/src/durable/transaction.rs +++ b/src/catalog/src/durable/transaction.rs @@ -19,6 +19,7 @@ use mz_compute_client::logging::{ComputeLog, DifferentialLog, LogVariant, Timely use mz_controller_types::{ClusterId, ReplicaId}; use mz_ore::cast::{u64_to_usize, usize_to_u64}; use mz_ore::collections::{CollectionExt, HashSet}; +use mz_ore::now::SYSTEM_TIME; use mz_ore::vec::VecExt; use mz_ore::{soft_assert_no_log, soft_assert_or_log}; use mz_persist_types::ShardId; @@ -82,6 +83,7 @@ pub struct Transaction<'a> { items: TableTransaction, comments: TableTransaction, roles: TableTransaction, + role_auth: TableTransaction, clusters: TableTransaction, cluster_replicas: TableTransaction, introspection_sources: @@ -115,6 +117,7 @@ impl<'a> Transaction<'a> { databases, schemas, roles, + role_auth, items, comments, clusters, @@ -158,6 +161,7 @@ impl<'a> Transaction<'a> { roles: TableTransaction::new_with_uniqueness_fn(roles, |a: &RoleValue, b| { a.name == b.name })?, + role_auth: TableTransaction::new(role_auth)?, clusters: TableTransaction::new_with_uniqueness_fn(clusters, |a: &ClusterValue, b| { a.name == b.name })?, @@ -350,6 +354,24 @@ impl<'a> Transaction<'a> { vars: RoleVars, oid: u32, ) -> Result<(), CatalogError> { + if let Some(ref password) = attributes.password { + let hash = + mz_auth::hash::scram256_hash(password).expect("password hash should be valid"); + match self.role_auth.insert( + RoleAuthKey { role_id: id }, + RoleAuthValue { + password_hash: Some(hash), + updated_at: SYSTEM_TIME(), + }, + self.op_id, + ) { + Ok(_) => {} + Err(_) => { + return Err(SqlCatalogError::RoleAlreadyExists(name).into()); + } + } + } + match self.roles.insert( RoleKey { id }, RoleValue { @@ -1150,11 +1172,31 @@ impl<'a> Transaction<'a> { return Ok(()); } - let to_remove = roles + let to_remove_keys = roles + .iter() + .map(|role_id| RoleKey { id: *role_id }) + .collect::>(); + + let to_remove_roles = to_remove_keys .iter() - .map(|role_id| (RoleKey { id: *role_id }, None)) + .map(|role_key| (role_key.clone(), None)) .collect(); - let mut prev = self.roles.set_many(to_remove, self.op_id)?; + + let mut prev = self.roles.set_many(to_remove_roles, self.op_id)?; + + let to_remove_role_auth = to_remove_keys + .iter() + .map(|role_key| { + ( + RoleAuthKey { + role_id: role_key.id, + }, + None, + ) + }) + .collect(); + + let mut role_auth_prev = self.role_auth.set_many(to_remove_role_auth, self.op_id)?; prev.retain(|_k, v| v.is_none()); if !prev.is_empty() { @@ -1162,6 +1204,10 @@ impl<'a> Transaction<'a> { return Err(SqlCatalogError::UnknownRole(err).into()); } + role_auth_prev.retain(|_k, v| v.is_none()); + // The reason we don't to the same check as above is that the role auth table + // is not required to have all roles in the role table. + Ok(()) } @@ -1429,13 +1475,42 @@ impl<'a> Transaction<'a> { /// DO NOT call this function in a loop, implement and use some `Self::update_roles` instead. /// You should model it after [`Self::update_items`]. pub fn update_role(&mut self, id: RoleId, role: Role) -> Result<(), CatalogError> { - let updated = + let key = RoleKey { id }; + if self.roles.get(&key).is_some() { + let auth_key = RoleAuthKey { role_id: id }; + + if let Some(ref password) = role.attributes.password { + let hash = + mz_auth::hash::scram256_hash(password).expect("password hash should be valid"); + let value = RoleAuthValue { + password_hash: Some(hash), + updated_at: SYSTEM_TIME(), + }; + + if self.role_auth.get(&auth_key).is_some() { + self.role_auth + .update_by_key(auth_key.clone(), value, self.op_id)?; + } else { + self.role_auth.insert(auth_key.clone(), value, self.op_id)?; + } + } else if self.role_auth.get(&auth_key).is_some() { + // If the role is being updated to not have a password, we need to + // remove the password hash from the role_auth catalog. + let value = RoleAuthValue { + password_hash: None, + updated_at: SYSTEM_TIME(), + }; + + self.role_auth + .update_by_key(auth_key.clone(), value, self.op_id)?; + } + self.roles - .update_by_key(RoleKey { id }, role.into_key_value().1, self.op_id)?; - if updated { + .update_by_key(key, role.into_key_value().1, self.op_id)?; + Ok(()) } else { - Err(SqlCatalogError::UnknownItem(id.to_string()).into()) + Err(SqlCatalogError::UnknownRole(id.to_string()).into()) } } @@ -2193,6 +2268,7 @@ impl<'a> Transaction<'a> { items, comments, roles, + role_auth, clusters, network_policies, cluster_replicas, @@ -2220,6 +2296,11 @@ impl<'a> Transaction<'a> { StateUpdateKind::Role, self.op_id, )) + .chain(get_collection_op_updates( + role_auth, + StateUpdateKind::RoleAuth, + self.op_id, + )) .chain(get_collection_op_updates( databases, StateUpdateKind::Database, @@ -2339,6 +2420,7 @@ impl<'a> Transaction<'a> { items: self.items.pending(), comments: self.comments.pending(), roles: self.roles.pending(), + role_auth: self.role_auth.pending(), clusters: self.clusters.pending(), cluster_replicas: self.cluster_replicas.pending(), network_policies: self.network_policies.pending(), @@ -2383,6 +2465,7 @@ impl<'a> Transaction<'a> { items, comments, roles, + role_auth, clusters, cluster_replicas, network_policies, @@ -2408,6 +2491,7 @@ impl<'a> Transaction<'a> { differential_dataflow::consolidation::consolidate_updates(items); differential_dataflow::consolidation::consolidate_updates(comments); differential_dataflow::consolidation::consolidate_updates(roles); + differential_dataflow::consolidation::consolidate_updates(role_auth); differential_dataflow::consolidation::consolidate_updates(clusters); differential_dataflow::consolidation::consolidate_updates(cluster_replicas); differential_dataflow::consolidation::consolidate_updates(network_policies); @@ -2478,6 +2562,8 @@ impl<'a> Transaction<'a> { use crate::durable::async_trait; +use super::objects::{RoleAuthKey, RoleAuthValue}; + #[async_trait] impl StorageTxn for Transaction<'_> { fn get_collection_metadata(&self) -> BTreeMap { @@ -2598,6 +2684,7 @@ pub struct TransactionBatch { pub(crate) items: Vec<(proto::ItemKey, proto::ItemValue, Diff)>, pub(crate) comments: Vec<(proto::CommentKey, proto::CommentValue, Diff)>, pub(crate) roles: Vec<(proto::RoleKey, proto::RoleValue, Diff)>, + pub(crate) role_auth: Vec<(proto::RoleAuthKey, proto::RoleAuthValue, Diff)>, pub(crate) clusters: Vec<(proto::ClusterKey, proto::ClusterValue, Diff)>, pub(crate) cluster_replicas: Vec<(proto::ClusterReplicaKey, proto::ClusterReplicaValue, Diff)>, pub(crate) network_policies: Vec<(proto::NetworkPolicyKey, proto::NetworkPolicyValue, Diff)>, @@ -2650,6 +2737,7 @@ impl TransactionBatch { items, comments, roles, + role_auth, clusters, cluster_replicas, network_policies, @@ -2673,6 +2761,7 @@ impl TransactionBatch { && items.is_empty() && comments.is_empty() && roles.is_empty() + && role_auth.is_empty() && clusters.is_empty() && cluster_replicas.is_empty() && network_policies.is_empty() @@ -2761,6 +2850,7 @@ mod unique_name { StorageCollectionMetadataValue, SystemPrivilegesValue, TxnWalShardValue, + RoleAuthValue, ); #[cfg(test)] diff --git a/src/catalog/src/durable/upgrade.rs b/src/catalog/src/durable/upgrade.rs index 4b417ee21b60c..4d02c7c2317eb 100644 --- a/src/catalog/src/durable/upgrade.rs +++ b/src/catalog/src/durable/upgrade.rs @@ -188,7 +188,7 @@ macro_rules! objects { } } -objects!(v67, v68, v69, v70, v71, v72, v73); +objects!(v67, v68, v69, v70, v71, v72, v73, v74); /// The current version of the `Catalog`. pub use mz_catalog_protos::CATALOG_VERSION; @@ -206,6 +206,7 @@ mod v69_to_v70; mod v70_to_v71; mod v71_to_v72; mod v72_to_v73; +mod v73_to_v74; /// Describes a single action to take during a migration from `V1` to `V2`. #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)] @@ -342,6 +343,15 @@ async fn run_upgrade( ) .await } + 73 => { + run_versioned_upgrade( + unopened_catalog_state, + version, + commit_ts, + v73_to_v74::upgrade, + ) + .await + } // Up-to-date, no migration needed! CATALOG_VERSION => Ok((CATALOG_VERSION, commit_ts)), diff --git a/src/catalog/src/durable/upgrade/snapshots/objects_v74.txt b/src/catalog/src/durable/upgrade/snapshots/objects_v74.txt new file mode 100644 index 0000000000000..27193094b4802 --- /dev/null +++ b/src/catalog/src/durable/upgrade/snapshots/objects_v74.txt @@ -0,0 +1,100 @@ +CnAKbroBawoVCgRraW5kEg1CC1R4bldhbFNoYXJkClIKBXZhbHVlEkm6AUYKRAoFc2hhcmQSO0I5XEN28JGKjWDwn4W8LkbgtIbigIngsrPOhsOIezoqbiJm4LqEIuGAqOCzoyfwnqSa8JG/gHjwnoS7 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 +CjYKNLoBMQoJCgNrZXkSAggEChcKBGtpbmQSD0INTmV0d29ya1BvbGljeQoLCgV2YWx1ZRICCAQ= +CmsKaboBZgoJCgNrZXkSAggEChsKBGtpbmQSE0IRRGVmYXVsdFByaXZpbGVnZXMKPAoFdmFsdWUSM7oBMAouCgpwcml2aWxlZ2VzEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKIAh1kwOEhAAgHA== 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 +Ci8KLboBKgoJCgNrZXkSAggEChAKBGtpbmQSCEIGQ29uZmlnCgsKBXZhbHVlEgIIBA== +CnAKbroBawoJCgNrZXkSAggEChIKBGtpbmQSCkIIUm9sZUF1dGgKSgoFdmFsdWUSQboBPgoqCg1wYXNzd29yZF9oYXNoEhlCF1cnfOC0lOG/jColP+Cgnj3grpzwkIqlChAKCnVwZGF0ZWRfYXQSAggE +CnYKdLoBcQoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ29tbWVudApRCgV2YWx1ZRJIugFFCkMKB2NvbW1lbnQSOEI2YTnisYzwkKCo1rrwkZmQ0ahvJ/Cfr7c9cVl74KeALS/wnrmq77+9P0Xwmr+9YCVJ77+WUCZ6 +CkoKSLoBRQoJCgNrZXkSAggEChAKBGtpbmQSCEIGQ29uZmlnCiYKBXZhbHVlEh26ARoKGAoFdmFsdWUSD8IBDAoKhgNSWFEDByYBTA== +CkkKR7oBRAoWCgNrZXkSD7oBDAoKCgRuYW1lEgJCAAodCgRraW5kEhVCE1NlcnZlckNvbmZpZ3VyYXRpb24KCwoFdmFsdWUSAggE +Ci0KK7oBKAoJCgNrZXkSAggECg4KBGtpbmQSBkIEUm9sZQoLCgV2YWx1ZRICCAQ= +ClYKVLoBUQoVCgNrZXkSDroBCwoJCgNrZXkSAkIAChAKBGtpbmQSCEIGQ29uZmlnCiYKBXZhbHVlEh26ARoKGAoFdmFsdWUSD8IBDAoKgpY4ORlpZFWIXA== +CuEBCt4BugHaAQqtAQoDa2V5EqUBugGhAQofCgtkYXRhYmFzZV9pZBIQugENCgsKBXZhbHVlEgIIBAo1CgdncmFudGVlEiq6AScKJQoFdmFsdWUSHLoBGQoXCgRVc2VyEg/CAQwKCpOEMYIRkFlgKUwKGQoLb2JqZWN0X3R5cGUSCsIBBwoFOWIyVU0KGwoHcm9sZV9pZBIQugENCgsKBXZhbHVlEgIIBAoPCglzY2hlbWFfaWQSAggEChsKBGtpbmQSE0IRRGVmYXVsdFByaXZpbGVnZXMKCwoFdmFsdWUSAggE +CjkKN7oBNAoJCgNrZXkSAggEChoKBGtpbmQSEkIQU3lzdGVtUHJpdmlsZWdlcwoLCgV2YWx1ZRICCAQ= +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHU2V0dGluZwoLCgV2YWx1ZRICCAQ= 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 +CqEHCp4HugGaBwoUCgNrZXkSDboBCgoICgJpZBICCAQKEQoEa2luZBIJQgdDbHVzdGVyCu4GCgV2YWx1ZRLkBroB4AYKewoGY29uZmlnEnG6AW4KIAoHdmFyaWFudBIVugESChAKCVVubWFuYWdlZBIDugEACkoKDndvcmtsb2FkX2NsYXNzEjhCNjHhpbQ7W8KlJMKl4bOwcz1g77+s77+9MuC2j/CRsK978JGTl++soOGLuuOIhi4ie9aOLuGLgAoWCgRuYW1lEg5CDEbwm4WSP+Cvlyk6JwpBCghvd25lcl9pZBI1ugEyCjAKBXZhbHVlEie6ASQKIgoEVXNlchIawgEXCgoCd0iFeJdSSJFsEP///////////wEKhQUKCnByaXZpbGVnZXMS9gSyAfIECnW6AXIKNgoIYWNsX21vZGUSKroBJwolCghiaXRmbGFncxIZwgEWCgkTZomYB1ZGEnwQ/v//////////AQobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKrgG6AaoBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKMlNxYQFGlXYVbAo8CgdncmFudGVlEjG6AS4KLAoFdmFsdWUSI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwECBpZhNGIDcEM8CjwKB2dyYW50b3ISMboBLgosCgV2YWx1ZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLARdllhKYWHUiiJwKTboBSgoOCghhY2xfbW9kZRICCAQKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggEClm6AVYKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECjUKB2dyYW50b3ISKroBJwolCgV2YWx1ZRIcugEZChcKBFVzZXISD8IBDAoKVBKTklVnBnc4XApdugFaCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKEkAXGCFWYhIDLAoNCgdncmFudGVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECj+6ATwKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQ= +CjkKN7oBNAoVCgNrZXkSDroBCwoJCgNnaWQSAggECg4KBGtpbmQSBkIESXRlbQoLCgV2YWx1ZRICCAQ= +CsECCr4CugG6AgrRAQoDa2V5EskBugHFAQpGCgtkYXRhYmFzZV9pZBI3ugE0CjIKBXZhbHVlEim6ASYKJAoGU3lzdGVtEhrCARcKChKHJ3IQGFl0dFwQ////////////AQoNCgdncmFudGVlEgIIBAokCgtvYmplY3RfdHlwZRIVwgESCgUWCYk5fBD///////////8BCg0KB3JvbGVfaWQSAggECjcKCXNjaGVtYV9pZBIqugEnCiUKBXZhbHVlEhy6ARkKFwoEVXNlchIPwgEMCgpjQScSJClzFpIsChsKBGtpbmQSE0IRRGVmYXVsdFByaXZpbGVnZXMKRwoFdmFsdWUSProBOwo5Cgpwcml2aWxlZ2VzEiu6ASgKJgoIYml0ZmxhZ3MSGsIBFwoKAYEykGI0FkMYnBD+//////////8B +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ2x1c3RlcgoLCgV2YWx1ZRICCAQ= +CkYKRLoBQQogCgNrZXkSGboBFgoUCgNrZXkSDUIL77GLe21RfVxrJC0KEAoEa2luZBIIQgZDb25maWcKCwoFdmFsdWUSAggE +CjoKOLoBNQoJCgNrZXkSAggEChsKBGtpbmQSE0IRRGVmYXVsdFByaXZpbGVnZXMKCwoFdmFsdWUSAggE +CmgKZroBYwpBCgNrZXkSOroBNwo1CgRuYW1lEi1CK/CRg7TgtbZJ8JGKnSdaNfCflbR5Jy5X8JCphtmKauGMlGfwq52x0ajRqEMKEQoEa2luZBIJQgdJZEFsbG9jCgsKBXZhbHVlEgIIBA== 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 +CtEBCs4BugHKAQqkAQoDa2V5EpwBugGYAQpBCgtvYmplY3RfbmFtZRIyQjAlSEzCsDoxJiYjSyfwnZK9L++/k/CQop7hv6Yi4K2d8JC+tO+/vVNZL/CfqaoqOyAKGgoLb2JqZWN0X3R5cGUSC8IBCAoGASBEN0htCjcKC3NjaGVtYV9uYW1lEihCJuGqk2DwkaWS4rahJtGo8J66qOGKmC7RqNGo8J+Bv3vwn62s4KqyChQKBGtpbmQSDEIKR2lkTWFwcGluZwoLCgV2YWx1ZRICCAQ= +CikKJ7oBJAoVCgRraW5kEg1CC1R4bldhbFNoYXJkCgsKBXZhbHVlEgIIBA== +CrABCq0BugGpAQpCCgNrZXkSO7oBOAo2CgJpZBIwugEtCisKBXZhbHVlEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgqDEhZJRzJ3dlccChIKBGtpbmQSCkIIUm9sZUF1dGgKTwoFdmFsdWUSRroBQwoTCg1wYXNzd29yZF9oYXNoEgIIBAosCgp1cGRhdGVkX2F0Eh66ARsKGQoGbWlsbGlzEg/CAQwKChJYSYlEGWFViIw= +ClwKWroBVwolChFkZXBsb3lfZ2VuZXJhdGlvbhIQwgENCgsBCHeQmAlpIFNmjAoYCgVlcG9jaBIPwgEMCgoQYTOXYCMFNDKMChQKBGtpbmQSDEIKRmVuY2VUb2tlbg== +CjkKN7oBNAoVCgNrZXkSDroBCwoJCgNnaWQSAggECg4KBGtpbmQSBkIESXRlbQoLCgV2YWx1ZRICCAQ= +CiwKKroBJwoJCgNrZXkSAggEChoKBGtpbmQSEkIQVW5maW5hbGl6ZWRTaGFyZA== +CnYKdLoBcQpGCgNrZXkSP7oBPAorCgdncmFudGVlEiC6AR0KGwoFdmFsdWUSEroBDwoNCgZQdWJsaWMSA7oBAAoNCgdncmFudG9yEgIIBAoaCgRraW5kEhJCEFN5c3RlbVByaXZpbGVnZXMKCwoFdmFsdWUSAggE +CjYKNLoBMQoJCgNrZXkSAggEChcKBGtpbmQSD0INTmV0d29ya1BvbGljeQoLCgV2YWx1ZRICCAQ= +CkoKSLoBRQoJCgNrZXkSAggEChAKBGtpbmQSCEIGQ29uZmlnCiYKBXZhbHVlEh26ARoKGAoFdmFsdWUSD8IBDAoKRUBDeEdXRhERXA== +CmIKYLoBXQo8CgNrZXkSNboBMgowCgJpZBIqugEnCiUKBXZhbHVlEhy6ARkKFwoEVXNlchIPwgEMCgpyZAYBIwZkY3eMChAKBGtpbmQSCEIGU2NoZW1hCgsKBXZhbHVlEgIIBA== +Ck4KTLoBSQoJCgNrZXkSAggEChEKBGtpbmQSCUIHSWRBbGxvYwopCgV2YWx1ZRIgugEdChsKB25leHRfaWQSEMIBDQoLAQOIFmA1UIVQl1w= +CocBCoQBugGAAQpVCgNrZXkSTroBSwpJCgZzb3VyY2USP7oBPAo6CgV2YWx1ZRIxugEuCiwKGEludHJvc3BlY3Rpb25Tb3VyY2VJbmRleBIQwgENCgsBJzMSRHVSlFRwnAoaCgRraW5kEhJCEFNvdXJjZVJlZmVyZW5jZXMKCwoFdmFsdWUSAggE +CjMKMboBLgoJCgNrZXkSAggEChQKBGtpbmQSDEIKR2lkTWFwcGluZwoLCgV2YWx1ZRICCAQ= +CmcKZboBYgpDCgNrZXkSPLoBOQo3CgNnaWQSMLoBLQorCgV2YWx1ZRIiugEfCh0KCVRyYW5zaWVudBIQwgENCgsBQmWCBVMxAEg3LAoOCgRraW5kEgZCBEl0ZW0KCwoFdmFsdWUSAggE +Ci0KK7oBKAoJCgNrZXkSAggECg4KBGtpbmQSBkIEUm9sZQoLCgV2YWx1ZRICCAQ= +CjcKNboBMgoJCgNrZXkSAggEChgKBGtpbmQSEEIOQ2x1c3RlclJlcGxpY2EKCwoFdmFsdWUSAggE +CjsKOboBNgoVCgNrZXkSDroBCwoJCgNrZXkSAkIAChAKBGtpbmQSCEIGQ29uZmlnCgsKBXZhbHVlEgIIBA== +Ci0KK7oBKAoJCgNrZXkSAggECg4KBGtpbmQSBkIESXRlbQoLCgV2YWx1ZRICCAQ= +CiwKKroBJwoJCgNrZXkSAggEChoKBGtpbmQSEkIQVW5maW5hbGl6ZWRTaGFyZA== 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 +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHU2V0dGluZwoLCgV2YWx1ZRICCAQ= +CjsKOboBNgoUCgNrZXkSDboBCgoICgJpZBICCAQKEQoEa2luZBIJQgdDbHVzdGVyCgsKBXZhbHVlEgIIBA== +CpM7CpA7ugGMOwo9CgNrZXkSNroBMwoxCgJpZBIrugEoCiYKBXZhbHVlEh26ARoKGAoEVXNlchIQwgENCgsBIQYnZmaRRHRoHAoQCgRraW5kEghCBlNjaGVtYQq4OgoFdmFsdWUSrjq6Aao6ChEKC2RhdGFiYXNlX2lkEgIIBAoyCgRuYW1lEipCKD3hiYrgrqnwn4G3JfCav7Ezw5EkT/CRqYQkLzzCpSLwk5GM8Ja5rG0KEQoDb2lkEgrCAQcKBSNmmIgsCg4KCG93bmVyX2lkEgIIBAq9OQoKcHJpdmlsZWdlcxKuObIBqjkKWboBVgoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKNQoHZ3JhbnRvchIqugEnCiUKBXZhbHVlEhy6ARkKFwoEVXNlchIPwgEMCgpzQjYiAWFZQHBcCnu6AXgKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBcIZ3ZJB5KZc3PAoNCgdncmFudGVlEgIIBAo4CgdncmFudG9yEi26ASoKKAoFdmFsdWUSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLASNBICJmMwGQSIwKXroBWwotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFWgoNkl0ICADJsChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKDQoHZ3JhbnRvchICCAQKbboBagosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCpkpKUcIEQaAAywKDQoHZ3JhbnRlZRICCAQKKwoHZ3JhbnRvchIgugEdChsKBXZhbHVlEhK6AQ8KDQoGUHVibGljEgO6AQAKT7oBTAosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCpEohkaEcjIJUxwKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKP7oBPAoOCghhY2xfbW9kZRICCAQKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAoNCgdncmFudG9yEgIIBAoxugEuCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBApougFlCjcKCGFjbF9tb2RlEiu6ASgKJgoIYml0ZmxhZ3MSGsIBFwoKEgEpUGRBiVkhXBD///////////8BChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKDQoHZ3JhbnRvchICCAQKXroBWwotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwEjFiRCZ1UlJ3EsCg0KB2dyYW50ZWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKMboBLgoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKTboBSgoOCghhY2xfbW9kZRICCAQKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECo0BugGJAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwEkYiVEVxUZCQhMCjsKB2dyYW50ZWUSMLoBLQorCgV2YWx1ZRIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKdElBdEhkFHlxLAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECmC6AV0KDgoIYWNsX21vZGUSAggECjwKB2dyYW50ZWUSMboBLgosCgV2YWx1ZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAUUzVJIoIocjczwKDQoHZ3JhbnRvchICCAQKT7oBTAosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCiJkGVZkMUAXFWwKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKeboBdgoOCghhY2xfbW9kZRICCAQKKwoHZ3JhbnRlZRIgugEdChsKBXZhbHVlEhK6AQ8KDQoGUHVibGljEgO6AQAKNwoHZ3JhbnRvchIsugEpCicKBXZhbHVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCiY2aJiXJ3eWV0wKeroBdwotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFoJxRQiCNyElR8CjcKB2dyYW50ZWUSLLoBKQonCgV2YWx1ZRIeugEbChkKBlN5c3RlbRIPwgEMCgpDRGgHQ2VgJXJMCg0KB2dyYW50b3ISAggEClC6AU0KLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBNlSXkJk1WTAEjAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBApPugFMCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAorCgdncmFudG9yEiC6AR0KGwoFdmFsdWUSEroBDwoNCgZQdWJsaWMSA7oBAApdugFaCg4KCGFjbF9tb2RlEgIIBAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECisKB2dyYW50b3ISILoBHQobCgV2YWx1ZRISugEPCg0KBlB1YmxpYxIDugEACk26AUoKDgoIYWNsX21vZGUSAggEChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBApPugFMCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKdyQDlRmCmXZULAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAqUAboBkAEKDgoIYWNsX21vZGUSAggECjwKB2dyYW50ZWUSMboBLgosCgV2YWx1ZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLASKJECEwUVmCc0wKQAoHZ3JhbnRvchI1ugEyCjAKBXZhbHVlEie6ASQKIgoEVXNlchIawgEXCgoCATSSAEJyOXCMEP///////////wEKP7oBPAoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBAoxugEuCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAqOAboBigEKNwoIYWNsX21vZGUSK7oBKAomCghiaXRmbGFncxIawgEXCgoRgmAxACCZdCdsEP///////////wEKQAoHZ3JhbnRlZRI1ugEyCjAKBXZhbHVlEie6ASQKIgoEVXNlchIawgEXCgoCKAiEFxY4MAQsEP///////////wEKDQoHZ3JhbnRvchICCAQKbLoBaQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwEyh5YGIyYDRmZ8ChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBAp+ugF7Cg4KCGFjbF9tb2RlEgIIBAo8CgdncmFudGVlEjG6AS4KLAoFdmFsdWUSI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwEoiQk1OCd2QxF8CisKB2dyYW50b3ISILoBHQobCgV2YWx1ZRISugEPCg0KBlB1YmxpYxIDugEACjG6AS4KDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECmi6AWUKNwoIYWNsX21vZGUSK7oBKAomCghiaXRmbGFncxIawgEXCgoGKXUXiAUUdVF8EP///////////wEKDQoHZ3JhbnRlZRICCAQKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBApeugFbCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAShjE0GXSUhykHwKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAoNCgdncmFudG9yEgIIBAoxugEuCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBApfugFcCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAo7CgdncmFudG9yEjC6AS0KKwoFdmFsdWUSIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCmgZJhaUmCgwImwKeLoBdQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCiJXJndImFBXBXwKNgoHZ3JhbnRlZRIrugEoCiYKBXZhbHVlEh26ARoKGAoEVXNlchIQwgENCgsBaDGJABlldRlHPAoNCgdncmFudG9yEgIIBAp4ugF1Ci0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLARVQkXIHJ5RUV3wKDQoHZ3JhbnRlZRICCAQKNQoHZ3JhbnRvchIqugEnCiUKBXZhbHVlEhy6ARkKFwoEVXNlchIPwgEMCgpZRSeFcSNCI0I8Clu6AVgKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECjcKB2dyYW50b3ISLLoBKQonCgV2YWx1ZRIeugEbChkKBlN5c3RlbRIPwgEMCgp5UyFFBwKYSTAsCl+6AVwKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECjsKB2dyYW50b3ISMLoBLQorCgV2YWx1ZRIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKYYdUckeVhGBJXApNugFKCg4KCGFjbF9tb2RlEgIIBAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKT7oBTAosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCgMEOURgMZkhCBwKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKULoBTQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwEDiXIXRgQCJjYcCg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECn+6AXwKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBFxiThzJlhAVELAoNCgdncmFudGVlEgIIBAo8CgdncmFudG9yEjG6AS4KLAoFdmFsdWUSI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwFUYmE3YjeQd2RcCjG6AS4KDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggEClu6AVgKDgoIYWNsX21vZGUSAggECjcKB2dyYW50ZWUSLLoBKQonCgV2YWx1ZRIeugEbChkKBlN5c3RlbRIPwgEMCgonZYgxE1mHVYicCg0KB2dyYW50b3ISAggECokBugGFAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCkVjgEMHJUEBlowKOAoHZ3JhbnRlZRItugEqCigKBXZhbHVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwFlSFJJGYQCAgZ8ChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKa7oBaAosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCoAgdxggOARFBpwKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECne6AXQKDgoIYWNsX21vZGUSAggECjUKB2dyYW50ZWUSKroBJwolCgV2YWx1ZRIcugEZChcKBFVzZXISD8IBDAoKMwGBA1MyI5IjbAorCgdncmFudG9yEiC6AR0KGwoFdmFsdWUSEroBDwoNCgZQdWJsaWMSA7oBAApfugFcCg4KCGFjbF9tb2RlEgIIBAo7CgdncmFudGVlEjC6AS0KKwoFdmFsdWUSIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCjh2ZIF5CWUiMWwKDQoHZ3JhbnRvchICCAQKXboBWgoOCghhY2xfbW9kZRICCAQKKwoHZ3JhbnRlZRIgugEdChsKBXZhbHVlEhK6AQ8KDQoGUHVibGljEgO6AQAKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBAp8ugF5CisKCGFjbF9tb2RlEh+6ARwKGgoIYml0ZmxhZ3MSDsIBCwoJiQJGeTQVgmlMCg0KB2dyYW50ZWUSAggECjsKB2dyYW50b3ISMLoBLQorCgV2YWx1ZRIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKFjhFhIR3NmCBjApuugFrCg4KCGFjbF9tb2RlEgIIBAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECjwKB2dyYW50b3ISMboBLgosCgV2YWx1ZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLARgkmFMzlDY5QhwKMboBLgoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKaLoBZQoOCghhY2xfbW9kZRICCAQKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAo2CgdncmFudG9yEiu6ASgKJgoFdmFsdWUSHboBGgoYCgRVc2VyEhDCAQ0KCwFGICUGGUZxBYN8Ck26AUoKDgoIYWNsX21vZGUSAggEChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBAo/ugE8Cg4KCGFjbF9tb2RlEgIIBAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECg0KB2dyYW50b3ISAggECl+6AVwKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECjsKB2dyYW50b3ISMLoBLQorCgV2YWx1ZRIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKOBMmMhZzN2eZjAqEAboBgAEKNgoIYWNsX21vZGUSKroBJwolCghiaXRmbGFncxIZwgEWCglXFRRVYWByCIwQ/v//////////AQo3CgdncmFudGVlEiy6ASkKJwoFdmFsdWUSHroBGwoZCgZTeXN0ZW0SD8IBDAoKhHgWACdXl2RRHAoNCgdncmFudG9yEgIIBAprugFoCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKKEZiJSFBA0gULAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKXroBWwotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwEhI3GFYTFgAYZsCg0KB2dyYW50ZWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKnAG6AZgBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKlGRiYkAUeDZ0LAorCgdncmFudGVlEiC6AR0KGwoFdmFsdWUSEroBDwoNCgZQdWJsaWMSA7oBAAo7CgdncmFudG9yEjC6AS0KKwoFdmFsdWUSIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCjY2EkZBeVV1CXwKeLoBdQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKClBwAEAZVSgTAnwKNgoHZ3JhbnRlZRIrugEoCiYKBXZhbHVlEh26ARoKGAoEVXNlchIQwgENCgsBCVOEaVVnInVwnAoNCgdncmFudG9yEgIIBApqugFnCg4KCGFjbF9tb2RlEgIIBAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECjgKB2dyYW50b3ISLboBKgooCgV2YWx1ZRIfugEcChoKBlN5c3RlbRIQwgENCgsBVgUoRJZ2hnOHjAoxugEuCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAqnAboBowEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgqCg2k4QgFzkhUsCjsKB2dyYW50ZWUSMLoBLQorCgV2YWx1ZRIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKNXKTSFdUQEcinAo2CgdncmFudG9yEiu6ASgKJgoFdmFsdWUSHboBGgoYCgRVc2VyEhDCAQ0KCwEUMpgkWTlmZDMsCj+6ATwKDgoIYWNsX21vZGUSAggEChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKDQoHZ3JhbnRvchICCAQKP7oBPAoOCghhY2xfbW9kZRICCAQKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAoNCgdncmFudG9yEgIIBApaugFXCjcKCGFjbF9tb2RlEiu6ASgKJgoIYml0ZmxhZ3MSGsIBFwoKGAeQdAFxRphDfBD///////////8BCg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECny6AXkKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBCTl2hgk3F3gnTAorCgdncmFudGVlEiC6AR0KGwoFdmFsdWUSEroBDwoNCgZQdWJsaWMSA7oBAAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECpgBugGUAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwEQgGQolBWQI5icCjYKB2dyYW50ZWUSK7oBKAomCgV2YWx1ZRIdugEaChgKBFVzZXISEMIBDQoLARgZZSNXYQA3gpwKKwoHZ3JhbnRvchIgugEdChsKBXZhbHVlEhK6AQ8KDQoGUHVibGljEgO6AQAKULoBTQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFGeZIQcIhWYGKMCg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECjG6AS4KDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggEClC6AU0KLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBJxBYhEZBIRSXXAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAp/ugF8Ci0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAWEUhJmQcDRiFZwKDQoHZ3JhbnRlZRICCAQKPAoHZ3JhbnRvchIxugEuCiwKBXZhbHVlEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBGUdgN3YmV4N4bApQugFNCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLATNQRhkkVhWZeXwKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKMboBLgoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKMboBLgoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKe7oBeAosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCgMZlTIYchRxh5wKKwoHZ3JhbnRlZRIgugEdChsKBXZhbHVlEhK6AQ8KDQoGUHVibGljEgO6AQAKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBApcugFZCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAo4CgdncmFudG9yEi26ASoKKAoFdmFsdWUSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAUiABVI2OGYzN5w= +CjgKNroBMwoUCgNrZXkSDboBCgoICgJpZBICCAQKDgoEa2luZBIGQgRSb2xlCgsKBXZhbHVlEgIIBA== +Cn8KfboBegpACgNrZXkSOboBNgo0CgRuYW1lEixCKlYmyLrvv73wkr67RcKl6pyBwqXwnria8JCtnPCQuq3RqPCbibYm8JCWuQoRCgRraW5kEglCB1NldHRpbmcKIwoFdmFsdWUSGroBFwoVCgV2YWx1ZRIMQgritoFXUHvDi8Kl +CjsKOboBNgoUCgNrZXkSDboBCgoICgJpZBICCAQKEQoEa2luZBIJQgdDbHVzdGVyCgsKBXZhbHVlEgIIBA== +ClwKWroBVwolChFkZXBsb3lfZ2VuZXJhdGlvbhIQwgENCgsBZJA0higyYpmJHAoYCgVlcG9jaBIPwgEMCgogQ4cGMBUIhxBdChQKBGtpbmQSDEIKRmVuY2VUb2tlbg== +ClgKVroBUwooCgNrZXkSIboBHgoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAoaCgRraW5kEhJCEFN5c3RlbVByaXZpbGVnZXMKCwoFdmFsdWUSAggE +CtCLBQrMiwW6AceLBQoYCgNrZXkSEboBDgoMCgZzb3VyY2USAggEChoKBGtpbmQSEkIQU291cmNlUmVmZXJlbmNlcwqNiwUKBXZhbHVlEoKLBboB/YoFCsuKBQoKcmVmZXJlbmNlcxK7igWyAbaKBQrTB7oBzwcKpAcKB2NvbHVtbnMSmAeyAZQHCj9CPVzwkJao3LVZ77mmJvCfoqrwkIuH8J+tmzxgw4pI8J+orD86TikqQCTgqYFK6p+Wa/CRsq/CtlxVXMi6yLoKA0IBPQotQis/aDvivLxydz3gq6E84reZcmDhjrkiIH0ie/CQi6dN8J64oS854KmR4q6KCkhCRuGnkzrgrJlc77mp4Y6HPvCQkZLwkb6w4KyydOqqtyLwkaut4Zyp76yT77mo8JGXiPCQgqFP4aWzanvwn5W0aC/IumAkVjoKG0IZ8J6ypGYiwrtS6p+TPWdf4KmbeyIkVSInIgosQirwn5W0dvCWvJo8S1glJ2tNKiXgqYA28Ja/sfCWvpUl4KGeZSQ90ahiw6QKG0IZJfCfn6HqoYPwkbSJPvCRio3wnbylJjvIugoCQgAKIUIf8J64ovCbsoLhqZxT8J+VtCUn4K6e4a2X8J66iC8qIQo4QjbhraLwn5W0XOOEnXMjJPCRirsl8J+VtGV88J2NpibgrIoiL04v8J+bsCrgq40uLj/qr5viv5QKDkIMKvCdkJEi4b2RWcOuCkRCQvCQh60uJcOJwrzgppovOfCegZFCwqXgq7vwkL28YuCwrvCav7FS8J+isfCQgJRlyLrwn5W0PGfwkbKtJzx84KiKPQobQhnwnZWKZ/CepJXgprLwkZal4KGe8JGWiWIqChlCF/CQlrsnJMi644aOZHvRqFxTwqLwkYGdCgtCCVwl4Yq5YOGsmwoCQgAKCUIH4KmIYGYiLgoaQhhW77+9IivwnrmwOmVuTTrwn5yTSFtNWH0KK0Ip4rWv4aCEJF1gPDrRqOChhSbgqYdgKvCfoZLwnaqe15vwkbWnX/CdkqsKKUIn8JCwiPCflbTwn5W0wrXwkJ6Cw6XvrIBg8J+VtPCegII68J2UvFw0Cj9CPVFRyLp3c/CdhYJqIOC8lOCks/CRsIVD4o6j77+9OmPwkIGR4K6cwqB7S0Ym8JCwrHLwnZCpwqVL8J+VtEQKHEIa3LUt4rqS8JC5p++/vV8xJPCRgIrhuKYmyLoKHUIbLvCflbThqbvwkLCm8JGwg0vgr4wnUHTwkam+CjFCL+KyoPCRpZdoZOGdsOCqsvCfg4PhjJPwkYS5UyciL+ChpypGJOG9m+CouSRdTtGoCjtCOTrRqEtP0ajwnZu+WcOAOXJi8JG1pz3vrLtx8J65qSoq8JCdknTwnZKAL/CQlLXCpXBRb21B8J6BmwoVCgRuYW1lEg1CCz0n8J2EoTrqopdmCg8KCW5hbWVzcGFjZRICCAQK/xq6AfsaCo0aCgdjb2x1bW5zEoEasgH9GQo2QjTwn4e3VPCflbQlXsOO8JCPkPCfq5LgqZol4KmL15pbKibwkKCb4LqC8JGkifCeoJzwkbKvCiZCJPCdvIgv4rukw4Lwn4e+8JCNgMKlJ/CRjZfqrYFNJSZ7JuG8mQotQivColrgq4No8J2Lr1w14b2dfvCeuKp08JG0mXM/8JCWoDrvv71UeTpgZsOQCkRCQmEuIEPwn5W077my8JaqviUkw4o96qqE8JGLlfCQrZlK8J+hgSLwn5W0J/CQsozgrqlcyLokUid77Z65Ksi68J65nwomQiQuXD/hoLEv8Jq/tyUuRj9TJyLCpypl8J2niCU48J65tOqsg1sKPkI84LKzInVrLeqore+/vT8l8J65vvCforDwlqmUJ+OHjy4k8JCOk8i6X8KywqLho6zhioxbRHsqOuCpnmB8CjdCNfCeooE/8JGypeC7huGxiHvwlr2IUuK3iHUzw6tXfe+/kuCohvCflbTwn5W0V1/ikYlg4KmeChVCE8O9NCDwn4mgX/CQv6/wkKC8wqUKP0I98JCAtPCflbTgvqPwnp+q0ag64bmMe+qnt3lOXCfDnPCQo7XgrIg94raqe9aoQuGkkvCdlLZe8JCVuVQlLwoGQgTitaAlCgNCAUkKPUI78JGMtj8g8J65sTLRqD888JCtgOC1imjirbjwnrS7Vzwx4KayJfCbi5oiZyLjh5o/w6kq6qqo776lLj8KQEI+eC13VG/wkJOv8JGmuT/grrE6SVAlJGDwn5W08JG1p+Gds8Kl8JCgt/CfiZFcNOC2hyQn4LW28J2Vgm1SwqUKHEIaLz/gt5x70ajgp5dge3PwkJ2KJTFLS+qlrDcKDEIKclDIuvCRq5EiJAohQh866p63Le+/vfCfiKAne+K2vEgleyThvJs6IjTwlqmCCh5CHC97bzfwkbyPwqUldGLwkKGHwqU84r2Y8J6fpFwKNkI06qeQMiTvv73wkaCnJ2UiQlzwnZS9JfCeuYlASyV30agl4L2DOlBU8J2SrOOAqTxkP01iRAohQh9g8J2UiD0k4KSo8Jy8sSHwnp+uJSvwn6mzLC574LGdChBCDiFP8J28j/CQtKLwnp+rCj9CPWrwmLSGWCXRqO+/vXvigbo9Vy4/1bwmavCfoaZNyLo98J+CvvCfoqjwkYKmZS5k8JCkv+GglPCeuZFQP34KPEI6dOGKivCRjYjgr7AsYEd5w7TitqVnP+CuqvCvo7nwnqSuwqfit4Dwn5W0djp78J2hvGDwkaagJi/RqAoEQgIiYApHQkXwnoCpXPCeuKfwn6KV8JSQtjQm26bhpqLvv73wnoKPJ1xiJmbguqXhvZsqRvCdk5nwnou/4K6C8KuetybhrabDmi3vv4cKNEIyYe+/vdGo8J+VtMO0cNGoLu+shlXwnYSs44KsYXkjdDrgs64iMCvjhr8q8JarqTzigoEKCUIHLiLwn6qGVgooQiZc4oCI8J2akDxVNPCWvpfhs6NmffCei7/wm4WSw61M4KqCXMOGewoyQjDgrazhjKwkwqVtQDrwlqCb44KHZdGow57CpS4u6o2nYMi6XyTRqDbwkZmV8JCuqWAKJ0Il4Ka/QcO0Jycp44OvcPCQq7BS8J+hkOCriE3wn5W0Qeqfk++/vQpGQkQ94K2cevCRq7gmV8Kl4bOX4KC14aaHOWwnO/Cbsp3wkJa7biDwn5W0JvCQjocn8JChqcKv0ajwkZqCIirgsJck8K2frgoZQhfwk4CYJjwiLybwnaqe8JGRnVck8JGRoAoMQgrwkJ2i8JCpkiUxCjNCMXRz0ahgYPCRjLI68JatkfCRtpjitK068J2Tp8i6WGjvsa1U4KOO4YON8JGapkLguoQKBEICVT4KEUIPPuC2veK2ouC3lifwn5W0CglCByTvrKbgs6MKM0Ix8J65iX7Iukc68Jirt/CQhIDDtPCego8/8JGEiPCQp7jwn5W08J6lk/CSkr/IumVQTgoFQgNaYDwKCUIH0agg6qqJSQoVQhPguoRQKnHRqPCeuKdG8J+uqlJ7CgNCATsKS0JJZPCQgK3gpo/gsaov8Jq/u8ObP012VvCRjZAuwrc64KmR8Ja/sMO/4K6fJdGo8Ja9nuChuvCflbQ94LaB8Jq/sDrwkYqIKu+/vQoiQiBQ8JartTQ84bGGNtGoUCpDJ8i6wqUndj3wn5W0YD1cOgoTQhHwn5W0PD3wkYO1JyrwnoC+VgoQQg4iWCd74oOe4Let8J+rpAoXQhXwnZKy26w64LSfezrRqC8nUSTqo7cKN0I14Z2vXD0iMUfvrYA8ceCyl2U5WWDguqU98JCGnPCRtaMl4b2Z8Jaqtu+/vCZG8JChlOODgT0KGEIWLuCnhzYq4reDJ/CeuKfgsIHiv7gvKgoqQigv6qyrR0wg8Jq/vcKlJsKl8JGyoy/gprLwkbGE8J2VgCvhvZ3wkYyyCh1CG07IusKl0ag6SSo9dPCRnJ09P9GoZip1e++/mgoNQgvCpVzwkJKo8J2SnwoWQhTwnZS98JGWvMi6cPCbhLLRqOCsgwo3QjV9bz3wkY2e4o+EZSZdIj/vv73wnYeJ4aS58JGLoOGfsCRDX03iroDgq43iiId+JGDdsi1BJwonQiXIuvCQoIjRqG/wnrmCfeCvl+C2geqmnVXhqpQ8T2slP/CQrYJ7CgdCBeGotiV+CkFCPy858JCMsD1c77+S4byYb+C6sOqnksKl8JuxsFwlO1TRqOCzlXDhsYc/KiLCpeGkj9Go8JCGlvCflbTwnrSTIgobQhnwmLSI8JCApTrqn5HhjZPwkYqI4KuQ6qezCixCKiJ9NS/wk4OR4La98JCsg/CfiYLwn5W0QOC/mSRi77+m8J2Tvj06byI4fgolQiPwkbu1eTMlJ++5svCen7PgqZ4meyVQTeCgt8K44L+V8JCWlwoPQg1Z4KiK8JGMpibwkJK1CiZCJENcJ9GoJXPwnLyCJCfwn4iwwrbIumBdJmXwkKKrWUkvJ+GBsAoEQgJNPAofQh3wnrmJ8J2Vg1jqrK7gqYjvv71g4LOxTSTvv71QMgojQiF9YCJS4K6cLuC1hyThnKdp8JCgo/CcvKXwkYqQPSTjiIgKM0IxTvCRjLMv8JCKh182KlPCpVwl8JGMrHbitK0iNMKpOl3wkISCevCQjbDvv70q77+9JwoXQhVf6qmBe+C+vuCwj8KnbVc9L/CRkKsKGEIWPGDCpSfCpPCepZPwnrmJe3tg8JGHowoaQhguUOCts+GciyV+4bG1b/Cen7lc0ajhvrAKK0Ip4KmMLCQl8J28pvCRnJ4uYvCRnJ08fuCthzfwkYuP8JCnjVzgqIbgqKwKBkIE4KmaJAopQicq4K6fYOCxnUjIuu+/vX3gp6zhrbVcW/Cav73gtrpUPfCbsp7qrJEKFkIULvCflITgrpnwm4WV4bK3dMKlJ0sKN0I14KaIey/wnrikPuGmueGdpOqitfCRgJki6qOQIiDwpba3JzE8KkDvur1777+98JGNl/CeuIoKKkIoKibwkYyyVu+2tvCegJfCrPCeuIE9wqXgtongsYbwkKqKwqXwkbKtOgoDQgF7CjlCN8O44b6XZHvwn4GbTyXwnrmqcjrwkbWg8J2Uh3vRqDoqwqEiKi7wnrmv8J2Sq3bDjELgsqsmPCoKE0IRJNGod/CflbTDiOGhmy/hqrkKHEIaYD3wsZS48J+qlfCeuLnwkKexJnPCpScm0agKNEIyJPCQkqPgqZHqrKvwnrGy8JGKiPCQk7TvrITgq6nwkbSJJsKh6p+Ra++3j1LwkY2QP18KJkIkYOqpkHY58JCgt/CRo78qU3nCpfCehY4mXC7lhqDwnqWf4KaaCi5CLOC7hmMq8J+VtEvwnLydXPCRpIUm8JatvuCroickPC4mOmXIuibRqD3wnrinCiVCI+Cvgjzwn6GXNU3wn5+IPEpcXOCunGDgtr3RqFV78JCPiSAlCjRCMkxgM0B+MXsn8JCWtu+/veK0rfCRpIHgqLw84LGETVXvv71S8K+mhOGAqe+/vSHwkY2CCg5CDPCQlb48JjkuOu+tgQpAQj46d1zvv73CpeGggUbwn5W04K+X8J+VtPCQjpRS6q+P76S7OeC6gkTCueCqgj1y7Z67SCbwn6yCImDCpS4qLwoqQih+LjbgqqA+z5jwkbS64Lan77+9JmDwnZWGPmg6bWLwnpOaMTnwkIyECjhCNkhNUMO5U3sgwqt+aVzgsK/wkJaUOvCRtL09Nlzwn5u36qykQVwi4LeT0agkJ2DgrLcu77+aIgo9Qjs1wqU/bvCfn7Dvt4/wnYmB77mKIjrwkaS44YqK6qyF8J64pEfvv73wkbCNNWxd4LKQVyQuNytc8JGTmQovQi0i4Lq84LSDJOGaoSLwkamqdvCeuYvgraAqLz49KzrwnqK+wqVp8Jy8kvCRpqAKEgoEbmFtZRIKQgg84aSFfOGltApVCgluYW1lc3BhY2USSEJG8J65m2Am8JGLuT8qPeG+t+Cpm/Ctt7hh4by8UeCovHvgqKzwn4mh4bG5YCTwq7u9LlPwkLKUJvCRsqvgrbE/wrnwmKuJXAqYBLoBlAQKswMKB2NvbHVtbnMSpwOyAaMDCgdCBUZx4b+QCihCJvCflbRDOcKl8JCdlWzwkKm14LSL0ajhna4k8JaskuC6iUXwkb2CChpCGGZuYOqnqcKnLydxJio+4K6IbT9gLyZLYQofQh3wkIW1wqUvWT4kLibCpUtgdOGPrvCRtL3wnri5PwoTQhEqIuK2i8OAZT/wn5W08JGAjwo1QjPDhvCflbQqVjIlP1J9V9+b4aWJb+C3m/CQqYjwnrmXe+CxhPCdhqPCpcKkJVwk4bOyw7AKHEIa4b+kM8OHOsKlJy9gL/CQlog94KeIPWfRqD8KEUIPVvCeuIPIunxsYCZW4Ki4ChlCFy4qJuqfmPCQoLjhv5kmPXxSPvCeu7AwCiFCH+Cuo+CokPCQurDRqC1cOuCxi8KlQ8Kl2qnwn6G3Ik8KNkI0YHpDJybCpfCRpqPwkbKZTz/wn6CcL13groZi8JGImWB6X3Tgt5bwkaS94LC8J0bhv45yTQo+QjzgqLPgp5fvv47wkJS/PUPitq7vtqMqe35+e+G/gXvhjIvgrrLwnbyQ86CGkeGGgOKwvVs4eXjgrY0ncTYKSwoEbmFtZRJDQkHjgqXCpe+/ve+/vfCeub7wnrmi8JCsuci68JCep/CflbThna57JyHDhVUqJ2oqPO+/vWwk8JGNsUXvrIYnJsKlagoPCgluYW1lc3BhY2USAggECrsVugG3FQq4FAoHY29sdW1ucxKsFLIBqBQKDEIK8J64gfCfr4ZpYAotQisv8J65ksi6YO+rmHRZYO+/vSdX77+94YuA4b+e4oSO8J+tvyg94K6ePy4lCj9CPeGLkeK2ieConCjDpnvwnYCWPPCRrIDhnbDwnZ244Kiuw7t+8J+pq1BnPUsxwqVu0ahA8JGMkGg6IiZHyLoKMUIvSuCggsKl6q+2ezo977+9cfCfq5DwkZahdCZnP1VhfGrDoPCflbRL8J+Hru+/vSQKFEIS76qT8JC8n2hW8JGNs+C1jcKlCjZCNFw9OuGMkiYw4LeWPCZ+762DLvCQqIzwnZKrP+CokCXwkbG7XCUuPCp88J+VtHtrOvCQlZ8KHUIb8J64pDpzOiTvv70yOj/Ctidg8JCWl8i6dk0kCi1CK2Bj4r2y8JuxuvCdlKHwnZCnLzxF8J6LkSTitIzIuvCRso4x4b+j8J+mlyYKGkIYNjnwn5yX8J65qPCdqqdbLinwnZKiI8OzCjZCNC5o77+9WvCen64vXGTwlqqT4ruZXPCflbTCtXonJPCQlpwyeybjgZ1GIUFtJ+Cviy9kw7AKBUIDJiUnCiBCHm1rUT7hv6fIujrwm7KXRFlL8JGZl/CflbQvdeKAsgpCQkB7XCI9yLo0Oi/wn4Sn8J+VtMKoPE97w4Yq4aCuSfCWq7HIuirwkYWRSuGdhPCeuKHwlqmhMfCRtIgje/CflbQmCh1CG1zwkKO04Kyye1g24LKbwqVMP2AuW+Cun+CnswojQiFt4Kay8JCojPCdlYbIuuCsrMKkLiTgsI/vpbFe4K6eLnsKQUI/XMOZefCeu7DwnrmNPGQub1LIuiJVJTrgtZQmJsKl0ajgqLnwsZSs0ajwlq6C6qOQ4LGm4KysLWw66qiT4K6qCiJCIEXwkr+VUO+/vfCbhZU/KPCQgYTRqOKAg0ov6qmYedaOChBCDsi677+9V8KkPPCflbRrCk5CTPCRtIngtr3wnrqoIi588JGwv/OghrLgvIvgtLjhg4c68JG8skfqn5B18JG2kfCRsIw88JCOqsKl0ajRqCnwkYy3XPCegLHwkIC92KMKGkIYJMi66pKTJjNXeuGqv+GLgPCfn6LDkT9cCiRCIj/wnoCgPyomwqU9cPCYg6EsIybgrKpr8Jq/s1zRqOqqr3oKHkIcJPCflbQyL1LwkYyz8J6yhyXwnrmfMM6E6qygXAoCQgAKKEIm8J28p/CQrprgpp1BPSfhiZo8XOCuk8O2L+KHvdmhPz1v77+90agKGEIW8JCNpPCdkbNlayXDo+GLknzwkaSVKgoeQhzDvWIibPCQo6hM4Ked8JCegSI98JCWlCLRqHd7CitCKfCRiIEi8J+ruPCfq5UqIjxwRnvCpfCQv7bCpeCzoeCxr3Xgtr3wkYagCkFCPybgqKvgqr7wlquDKm7wkYy18JuxmikkPsKj8JGEjNGo8J2Egeqkm8i6KvCfiLAk6qeP8JGaq+KCvUvwkJKlLwozQjE/4LWK8J+VtHvwl76Ew5tlP1zCr+GiqDo6JfCQrZEqJ3M88J+Aji/wn5W0Z3XwlqmgCitCKT1Ke2vwkKCP8JuxsOCtlvCfoIjwkKiGKC/wkbC9e/CdlYZzPCc64Ky/ClJCUPCSkbN88J+gieC3qfCRnKtQJvCdhrVe77my8J2qnXsl6qCw8J6EslAy4L2YeU3vv73dqOCgvfCdvJLgq6Dvv73wkIK14LG/wqXwkbKvw59vChdCFTxD4Z+pe/CQoIjRqCLgqYJEWuCtiwoMQgpjOuCzo+GfpnpkCh9CHSslOPCQnrPgrJBxdy7grqk70ajCpcKwePCflbROCkBCPi5cPvCespkpJsOD4aSx8J+VtCrIujBGJk3wkayE4Y6N77+9PDxC8JGCjPCfr7ci8J65m+GJi20w8JCWsTBrChRCEtGo8JCjre+5myrqr7B44LK1aAohQh8m8JGTkGbwn5W0Jjwo4LOGUsOJ8J+JovCQqZHwnYuCCiRCIjXhrZchXCbgt54nUy5J4aSZS/CRtInXmC7wkK6pLlE6Ki4KMUIvV+GkkfCQoIQ64K6O8J+VtOCujvCWuYM6JSYk1Lzgs7LwmK6wOjxDL/CQlrw917MKCUIH4KmM8JinvApJQkc24LuO8JatmOCsgeC9ku++iy/RqOChgsKlMUBg0ajwkaSJJvCRpLDwnZWG6qyWwqXwkIGS8JCrr/CRiqfvsZIzJvCWvI7CpQowQi494LGawqXgp597ZmBQ77+U8JCUpWNuW2Dwn6m0efCWvoB78JCspe+/vVw51o9aCiJCIHbwnrih77eP8J+VtCrwnqG1be+/vfCfm6d8PFwmKikqChtCGfCRtYPwnrmHJUNPOvCeuZlbOOGnl+OCkyUKL0ItPfCdjLNqbCXIuiJBKjo84rakw4onYPCQoIjhraJge/CQrq9hL11L762D4rStCjVCM/CRtZDwnp+tICJaPDBrL1J5w5k5Iu+/vXspN1nCpU9B8J2EsyTwkY2XIPCRjbLwkYOCJAoxQi9MOy4uKsi677iV8J2Rq+C/hDzvrL7CpSo64bGPP2DgsrwzRfCdlYDgt4bgrJBgdAosQirgq7rvv5xr8JCWjOKtv/CfiZFgdPCflbQ98JCohjkiJG0nwqXwn5W0XlwKNkI0LlHhpKfCpW0l77+9LyfgorYqXFzgrZ3gtYsg4Y2tezxpZzrwkICITOC/gcOMSTrvv708KgoqQijwkaS88JGwgfCRrIY6IvCRpJYjI/CQkrI3OmA9IvCeuZTwkai9PFZkCj1COzfwnrm2L3vwn5+YZ+CotSZOLvCRoLQ977mr4b20e+GdgMOf6p+T4Ke54K+NYuGzhW0i4b2MJz/vv70sCgRCAik6CgtCCeCrkCftlo17IgoHQgXCpSrCpQoOQgw7P+CstvCfq5Ng0agKA0IBTQohQh9Bw67wn5eiWsOeJjooTlAvJeCtp2V78JOHgmvgrLhZCjVCM/CRkrvwkLS1KWhCJcKlduCwj/CSv5MkJifit4jguoTgrZbwkIyf8JuxtsOxPifRqEomVwoaQhjwkZqYM++/vfCQmrYrJyLCueC1h+G9m2cKJUIjMmZ74KqC8JGNl++/vcKyPC5bwqXCpfCRsrQmRzps8JGgp0EKCEIGcmRP4rOXCjNCMSLwnqWJ4b6+NvCfoa5IeyVf8JGNn2Dgsr064oKv77+9bipgJ+CzivCRio8mPfCRp6EKLkIsLtGoJTwk4Kqt8J6klvCRtKpg8KufuXXwkI6B4KOOKuK0kFnDneGhiPCfqbEKMEIuPz998JG2kVXwl7C/bDTgtbLhk69gKtGoYTrhspkqJ1x786CEo3U/aT/wn4mlXAolQiPwkaiEe+K2kvCdkqXgtoMq8J+VtOC1jPCRg4DwkYy3OWAuJgo0QjLwkIC84q6L4rqHZD/wkbWo8J2GvyDgvZbgrpXgqIrwkIez8JGMj8i6cMOnXOGLqeqfugpECgRuYW1lEjxCOi7qo5DwnZSKWWBkPMKl6qiXJeChsCEq8J2qnvCeuKHgvrLIuvCRk5nwkKqHJOC0kPCflbQlIvCWroEKNAoJbmFtZXNwYWNlEidCJfCav7JlOk3gtrld4LCOdeCnl0/gu4lLyLoqwqXgsY3CpeC0iDoK1gS6AdIECo0ECgdjb2x1bW5zEoEEsgH9AwocQhrwnqOM8Jatoci6XMOW8JGNpuGnleCrjO+/vQoQQg4iaTvwnZ61JuCxrsOULwo/Qj17TeG/nvCeubfgtr14SuGfp+GttOCzlj/wkKKsI/CflbQqUj0uJT3wkbS8KjPwnrmR8J+VtFzjhafwnrmfCiZCJCTwkZGWIuCtlvCdvKlgcOqslGMnJ0Xwn5W0JfCcvpXwn5W0PAoDQgE6CgVCAy05bgoWQhTRqMKxYCfwlr6FSlNe8J+VtCbIugoNQgt78J+VtOC2vT/DiwoHQgXwlqq4OAoZQhfCpPCegJg18JGFhCVE77mrOu+/veKCkQoJQgdT77+9MnQ7CgRCAiEnCixCKvCRk5FAw5IiXPCRmZJY8J+VtFzgt5/itK0+4aKQ8JCirVw/4LqlI++/vQpGQkQvwqXvqqPwkKmY8J2HqC/hjoTwnoCJQ/CeuZ/RqD9cRi8v8JatnfCWv6RM8J+JkcKoTi8i4b+m4K6/LvCRtpA676y0dAo4QjbhnbMmJS8+4bK+LuOHufCflbTwkISl4LaCaTFJWfCdkq9yXnsv4raHJuCvkFzCqMi64Kqq0agKAkIACkFCP++/vfCfrIbhv7Qu8J+VtMKl8JGllmHvv70/KXs26qKZ77+94raOP1Dwk5GKd8Kl8J+gmz/CpXMq0ag/0ah7JQoDQgEiCi8KBG5hbWUSJ0Il8Japg/CeuLTwn5u68J+VtCo/L+KwjT9TblrwkYOA4YqFJCFcPQoPCgluYW1lc3BhY2USAggECqgPugGkDwrdDgoHY29sdW1ucxLRDrIBzQ4KJ0Il8J64ufCQnrrit5jwkKKnNeGohidhJEM/wqTCsDBc8JCRiOCjlgoxQi/hspBjYuqVo1xFPTgt4LWI8J+VtF5c8JattX3vv70kyLrUuvCRu7Jab37Wj+CzrApBQj/wm4Wm8J2EhSTwnoCm8JChjWDdg0AvZVPwkoql8J+BjiQ08Ja5oiB78JCgllngsq0k4K6KUfCeuKR+PPCflbQKBEICeSoKJ0IlP/CegKN98J6frS0yKuG/mfCdkrtK4YCEwqXwqp6B8JCPiXh4YQorQilgJEEm8J+Jonvwn6aOXD8k8JuFpnbqoZZqLiPwn6uyJWfRqCZQ0ajCpQoiQiA88J2UiCrIunHwkIag4aeYwqs6YE1tOi/wn5W0fsKlbgomQiRPw5vwn5+IOCrwnriiJHPwkI2C8J6ApPCflbTiuZzwnriAJ14KREJCLjF6PMKy8J+VtMKl8JuFkT8nblvwnaSiaO+4hi/wkK6b8JCWuz1cXDwn77+te+C6hPCYtIXhvbLhg4VWw4rwkaS3ChJCEMK0KeCxljY94KuQyLohwqUKQUI/OvCRqZEt8J65myZgJfChsLV7Xio9wrkqJSTwkaO/Km3wkaKtfsKl4Z2o8Jy9hvCWv6Au766ZRTJg6pux4KupCgJCAAoWQhTwkbWEwqhwbfCflbR78JCmiGQnJAobQhk/b++/vfCRnKfvuIovVl/RqPCRsIAi77mdChtCGUbwkbaQ8J65nyXRqE/gtr3hqIDRqD9ZyLoKCUIH8J+CoC8lewoXQhXRqMO68J+VtGpc8JC5o8Ou8J6CjyQKCkIIJcK6w6Lgs40KAkIACkVCQyU4LvCSkrw64Y+G4bGd77+9OvCdkp/hqoPwn5W0dDfvqYxBJ+CriOCsrPCflbTwnp+uOvCegKpULj/DtybjgoThj70KQUI/IvCxvJh1P/Cen67wkJ654K+COlgm8J6lmWrwnrie4bGGOVx1S+qntfCbg5TgqpDwn4i64L+G4ra+J3TvqaBgCgpCCCt64LeWcSQ6CjpCOOCsj/CWrabvvK1DbPCflbQm8JGIvX068JCorvCdkqlxLHBlYiQm8J+VtHgqwqXhpLc0P/CRvLc3CjxCOiXgr5cv8J+qgDnqp6g8P+GMk2pK76yDPSImJeGzhvCfn7DwkYCP0ajwnZSYIPCQgq3Cpeqapu+5qicKAkIACjNCMcKlyLo94Ku6bMi6OiJ7ePCdgodcyLrRqOKBky7Drz8+4K6CKvCQjIvwkI6iwqclV3sKOEI2Pci68J2IiMi6PPCflbTwkYaT4Y6JwqVs3qMkOuCroXF1dd+m8J+VtEElwqXwn5uoYDFGPcOIChxCGuCwg+OIjeCmiTopw6Aq4KureuGtsE3wkKioChZCFCcu4raNw50mddGoMPCeupTwm7KFCh5CHO+/vfCrnrEn8J2SrsKsb2Ar8JCwo2Ahbj1KWT8KGUIX8J+rsEbqn7cq4L+YbT9977+94auGJT8KN0I1P+CymVsiJsKvMypG6q2w77+94oGDc+KBvfCav70l0ah7Iicq4b6kJPCRgYYi8JCmmyIvLzYKCkII8JuFlfCbsboKQUI/eDFWIV4uMC4kIO+slS7wkKqb0agk8JGisXLwkZ2DyLrwkIevazzIuvCWupfwkK2p44CNZ/CWq6TwkKC8YCZ8CjNCMeGuiT/wnp+j77+98J6BlFbwkZGD4LGB8J2UvOqsltGoLz9977+98J2UnjJg8JCkpi4KDkIM4KyyNO+/vUztnrtGCgZCBHzvv70KDEIK77mhbfCepYB2KQpDQkE54LOGLjnCsyolwqXCpci6w48q4bSj8J6EuMKl8J+VtPCQub3wn5W0RPCWuZbwnrmL8JCVtzok8J+qhn1TJTR3RQoxQi9bYCJ94KCY4LaCPyk9S27wnpOSJsi64oKn4ouFyLpg8JCOkfCbsILwkLqs8J+fsApDQkHDl/CWvZ7wnrmSOi/vv71l8JKRsSrwkY2wfX3wn5W0ZCVcNsOn8JKQvvCQqJfwnYafPeG9m+Gtn3Twn5W08J+GngpDQkE98J+VtGPvv70q4Kqr6qGW76yEbci6OtGoPSfgt5Yv8JGRniLiu5Lwn6uYZtGoypfgtp084aGNLvCeuodJ8Ja/sQoVQhPhiZAvIvOghb0/OfCRp6TgrZxVCi5CLGoqw77gtaIu4K+XXMKl4La94LCGYn13eT9T4KqBJU8k8JCmviXvv70q4b2dCjNCMfCfobxcSmDwnrqi4KmI8J+JoOqrtvCflbR7P3s88JGHrirwkbGD77+94bOGXMi6yLoKDEIK8JGagGRo4Yu5KgoyQjDgr4zhvYs98J2UjirhiYNcw54nbPCRvIAq4reAUtiNL23vv71cTPCQlp7wnZKiwqUKFEIS8JCgiCTIuu+5q+Cor0rwnp+pCiBCHiQi77+98JGxtS5g8Jy8t8O1Lm08JSfwkLObOmBuegoOQgx7QvCdgaDwnZi+a0AKHwoEbmFtZRIXQhVc4Ym28JuAkOGPuWAndynvv73RqCYKIQoJbmFtZXNwYWNlEhRCEvCfg6Z1cuOEhT974oaSwqVcPwrjHLoB3xwKphwKB2NvbHVtbnMSmhyyAZYcCi5CLPCeuaQ8TuK6mVzhp4Bc8JCEgHLwkbS64oCj0ahTYPCav7BmJ/CRsIPwn5W0Ch1CG+CorW/wkYOj762ELj/vv73DvuCxneCsgyXIugoGQgTRqDomCiFCH/CdiIs94ae/UfCen6ou4YuDKDLhg43CpT/wkb6w0agKJEIi4K+XPCda7Z63SOGxku+/vXs+8JCWm+qsql7gppXOrD8lYAoqQihc8JCOmGtpfeGOkVlfwr9gSCThmYjwnrmp3qnwlqmIXFUqw4Hwn5KFCg9CDUfwm7GF44W54YyTVUMKPEI6yLrwkKyAOPCfgrrgrpJLw4F7PHsmI+C5jEc88J+rgPCQrYrguoRR8J65l1Tvt4/wkYuxJ/CRjLfCpQoVQhM9wqU8JTHwkaSOPPCRiohg4YONCgdCBeqcqCVACipCKC5YT86M76abJVEiLu+tg2clLvCflbQ/8Ja9tGzRqC5teyZe8J+VtDoKF0IVwqXgt4rgqJMmJHtZPfCRjZBaKmhgCiRCItGo6qyOXPCbsoTwn5W08J+CsuG8t+qiny0/cSdgSPCdhr4KQkJAPe+/hD3wkYy24aqZIvCQoLzDsfCqvIfwnrKJaT09fuG9nfCeuLfwnZKiOkFK8JG1ocKlKsOq7Z66Z8i6w68lTgoVQhPwn5+hXCdf4bKrPPCfr7NgP3pcCilCJ8OB8JCgg++/vfCdlYZAUuC+t1MmJvCegIHwm4mVRjonw7Y64q22OgoSQhB74KCi77+94aWOXDzhoI8vChNCEfCRqpQoPCpU4ZuFw4fwnZKxCiZCJPCQgZJPyLone++/veGDh+Gwh2rwkaO/4LqIJC8vJiLwkL+IOQoUQhLVoWB+ZynwkIy58JCegeCouGAKQEI+8JORktGoQy55c/CehI4tX/CfrIE7LCDvv73DizJ0VvCRpZbgqI8q4KmR8Jq/vldo8J6BkSVaLiTvvZvgrIUKKUInJeK5k2s/77ai8JCNoTrwm4Wn4a+ncVtbLj/wnbyafF4/JzNzY2x5CjxCOuGdr/CRtb7gsYp74K2i0ahgJPCflbRq4LCGPWDgtrUlJfCegY468J+VtGTCpT/wkKmVOuCngy/groIKOEI24YqL8Ja/sfCfra3YllB3PCTgroLwkI2sJ/CQlrTwnoSjKkrwn4K1OlIvOGXvv70qLypKOyJZCihCJj3wnLyRSsKl4KuhTmHwkIab8J+VtPCRjIPwkJOzOvCRtLrgs55wCjtCOe+4lfCfn5Xvv6pvceGLiTJzWHMv8J+rl0jwn5W0w6V7ND3wkLOtyLrwnrqTQzfwlqqO4bKp4a25OwojQiE8eyzCvsOLImAvPfCfg7Mq8JGnis60WCrwkL2/4K6pT2AKQUI/WvCQtIZX4K2sXnHwnaqi8JGxgj/wkKmE86CFj/CeupPwkbWCIiLwl6araT/IuvCegKPwlq2l4bCFZkXwn5W0ChdCFeCsifCRvIjvv708Ku+quSQs8Ja/sQovQi0lP2lh4K2W8J6foT0lLzwnOeC3llLvv73qorPgrqNf8JGNlybIulrRqMi6PDoKDkIMeXfbrCXhnbLwkIGBCkhCRvCWook64K6x6qypPULgsaEkQ8Kl8JuFkOGKk3vCpU7wn6CE8J+CuDDwkL2F6qCz8JCNp/CRgJ4iYz064LqpLkrvv73irIAKC0IJQ+CmstGo4L68ChtCGfCRpJVc8JG2lCLwkYy/8J6koi95Rz1COmwKGEIWRFU94KGnfPCQlrt94KeIwrM9eyRnPwouQix777+977+9fG4iONGoUT97d++mgFEq8J65iTzwn5W08JCyktiHWi8u8J+hmQoKQggiW8i64K6ZYwonQiUiPC/gspbwkKGCV8KlJuKAlS/wn5W04Lqe8JCWjm5w8JGMtlk8CitCKWDgprcuPXvDhOGkhkBFL+C6iSA/MWMiPfCdqqHvv73CpTBNPCXwnaqjCjtCOXtCe/CeuLlcJ+C7hsO/PEwp6qyWYFwlJVwi8Jq/vvCdhJVH4Yq1RntF8J64gCXwnYaa4K2WIuK3gwobQhltey9OOs6MWfCegJjwn5W0Y/CeuYvgtbcwCjlCN+CmkELRqFxywqXDiCoqazwt8JCoheCmvyc/WUHhpbTIuj0p4aS68J65nSjwnZKrb/CeipQiw7AKIEIeeOCxoXs9J/CegJvIuuGdh+CpnFrhv7TRqFwkJMi6Ch1CG1TwsZyXPHjIun1gXGlRc/CQgpjemS4/8JGMtQomQiThi5Fk8J64tPCbspwmPXTwkZit8JCOsMi6UCQ80aguY/CRtpQKHEIaOizwkIupyLoqL/CRsrUiNPCQk55OKvCRsLMKP0I9TiQvMtGoZVzig65nP3A9wrTwnou/XHvwnrmf8JGiu/CRgr4/36XDhcO58J2SnlnCpfCQi7bwkJS0ReC6ggodQhvwnoqs4Ki+PC1gUS7wkbWl8J66kSjjh57DgS8KCUIHcj3wkYOZXAo3QjXwn6yK4YqbaMi6PzHvv63wn4C1R+Cqr3Lwn52KJjZyRS4vJPCQkrHwn6ug8J2drFzwn4K/ewofQh13bjpQNDU/4LCSZvCQlo3cueqmqmDwnoukJuGMgAotQivgq77hvYw/8J+VtFzRqPCRkp58JPCQvrJk358i4bC9J+G8nVjwkLqU6p+QCkBCPvCRm4HwnYG+w4UyyLpdL/CQk410XD1gXGp+4KuH77+9M/CRvIE5PD/wkI6cXPCWqabitb9R4oK48J2TqT1NCjNCMfCflbTwkaSV8J+IpDNKXXjgvaXwnoChc1zit4TwkIaFIj/hpqQu4Ki1LG7vv70nPmwKGEIW6qm7U+K3keCwsvCeuLZH4K6j4LuBWAoRQg99e1EwP+Cpnk4yV07gtY8KH0IdYDonaz09MFJN4Y2Oeu+/vcOZ4LK4XHHRqOGxsi4KT0JNPMKl8JCol/Cav7Hwr6KD77+94Kak8JCoovCdkrfvuaZg4Kic8J2qnz/gtoNgSS8kLfCQjZ/wqqGy0ah6J/CWv6LWjyrqrrLIuuCxvS4KDUIL77+9VMi6KzwiaWgKAkIACgxCCmsu8JGRnT/vv70KP0I94KS/JCfwkbKqJTRdR/CflbR3PyZ08JC9gPCQpL9g77+98JG2qci68J65t86MwqU/8J66uci64K+wJuG+nQokQiIuYCYvJCTwkIaRYMKpM3fwkIaR8J+VtOC4rS7IuirwkYOACgVCA1tcIgoWQhQ/wqUlXDrCpS7wn5W0L8i6PDrNvAoxQi/RqNGo8J+NiWbgt4ov8J+ttjzwnZSsP8i6RiReSu+/vc6VVD99Lzw9YXQnJirIugo9Qjtc8J65qNaIN1zwn5W0OF84e+Cok9Go8JGMs2fjgIt28J2UilzwkJK86qyLJS0qXNGoWOCpnnvqppNIPwo0QjLgvocvbyTDsSUnQ0TgoLkuey1O77+9zpgk8J65t0/hiYzvv71kJSbwn5W08JGNkMOwTAoDQgFTCg1CCyLwnrqi8JGNoGc8CgdCBWvwkL21ChxCGmDRqMOXIz8vJvCfm7bjh4g6JjNYP++/vX0iCjtCOSpC8JGygOCskPCRoIrwkKmQ4KiBwqXwn5W08KCVh9Go8JGshvCfgrbwkbKx44SL8J2nqiA/77+9LwoXQhUn4K+QPPCQlqvwnrmXXDQ6dO+/vSEKIUIfTio6PU488J+VtEbgprg8PcOf8J2mvvCst4Pwlq2oQwouQiw9LiXwn5W0JFl7OfCRqpxgSPCRjZ5tYnvwkpKkYHdzYFctKF8/JCZG8JCMiAoCQgAKRUJD8JCGoGDIuu+/vUp78J67scK2XPCQlppz77+98JG0uvCWrangroXwkKuA8JGNkOCpkSXDu+OIhGXgr40m4KyG8JK/nAoSQhAmOvCek57ilJfCpT9h4LCzCi9CLVxGfjvgtr1FJ07wn5W04byd77+9XvCRgaJN8JGSguGdomLhh5dMJ/CSkbMibQojQiHwnri7US5Ee3tmL27wkLyzJyXigqbhs5DwnY24ZvCfiKQKG0IZNfCflbRj8JGkgTpc8JGMgfCdkYhg1o8+NApCQkDwkY2XLuGJvSpg77iY8J+giXVB6qmRRu+/vSrvv73jh5/hoZZP6pOC8J+tuuCsh0figpTwobK5YPCQrLrCpW0uCjFCLyAi8JatkuCriPCfr7AvXmMl8JG1qCfgtZRdNjo68J6ApCLwnrmHay97aVk/4LOHCg1CC1nvv708XPCeuYJ1ChdCFfCQqYhz8JuCnNGo6qyE4oG3JeGKoAoVQhPwq7Cp8JGshuCho/CQjItFIjRwCjVCMy/gp4fwkYCaNjjgp4M8KnA68JCBmy7hrJ3wnZK7d2DIulo6cCzgro/wnZS7ffCdlJdFbQojQiHDjuGCkSLwnp+o4Z+38JCopCZ9W++/kirhirh4WvCQrbAKMUIv8JK+ldGo8KqgjCbDjmXgoaQ04Yyz4KeILS81Li9EL++/vfCflbQmLuCytvCeuacKB0IF4o2YZXwKKEImekU6cuCym3cmwqXgp4t64K2B4YyVwqXwmr+wTkA/eF3gq4skLj8KGkIY4ras6qmXImzwkJ2MWifiip3wnZGqyLpgCi1CK/CRpq/wkJaV77a+w5FrJmZ7Nj0o8J+hoPCQg4xtQSpgOvCRjYvhna7hg40KGUIX8JGllic/77+9Ii/gt5ZrwqUnc/CdiLkKSkJI4LSPOkbigoc8J+GPnOGxifCRv6Lvv7066qeSLtGoTmo977+98J+olS9F6peHPPCdlJklbPCRnIU18JCWlfCeuYfwn4mh4KiDCiMKBG5hbWUSG0IZw5Mq4Z2z8J2LhS5T8JCrm++5mCfgrKA3PAoPCgluYW1lc3BhY2USAggECrIbugGuGwqKGwoHY29sdW1ucxL+GrIB+hoKPEI64Lqv0ajhvJvwn4OF4K6uXPCeuIBZS/CfoITwn4e56qSSw6BgOvCdkLDDovCRtILgprLCoirwkIC8JwoKQgjhiqDwm4OULwoZQhcl77+9TCrhiLZ6JiRs4KCwSsi64KWcWwosQipN77+94aq/J+GugSYt8J+VtDzwkbCY77mCXkI9Ls6TIuCpi++/vfCeuIcKK0IpbTvRqOGls/Cek7J08J2SuyrwkayHYPCeu7BdLvCehLgrwqXgp4Lhpa0KCkII4ra74aGRwqUKO0I5yLrCpVzhj47wnriiwqUlPeCooHvwnoS2IvCfr4g9JSrtnrvhv73wlr+jJe+/vUvwnYSMJ/CRjJMiCjBCLn7gppThia4wYiUqLvCegKQ38Ky4gcKlNPCWrolOUNGoPSDCotGoPeC2gvCdlIoKR0JF4aGvcuCog+K2qmAuLzpldnTgob/vv71Jcjzgp6Hvv73wnrin4rWv8J2Sn+G+hMKl44OfwrTwkaCrwqXwnYun8JKRsMKlCjVCMyIr76yAXeGDh+CumT9aL0zCpWLhjbxPKiBc8JGnouG/szfhsIzjgIR4YD8kXOGypeCrrgo8Qjrgp6An8J+hsns64LCh762BP+Cun+CyuVk4cPCQhKjgp4cwLnAh4reSbPCQlrYrLy3hqqBZPS5+4Y2TCiZCJCg28J2UiCdg8JCtqSrwlJOUPfCdlYsu8J+VtNGo8J+CoSRzLQohQh9wLvCRiIbwl76zeTfwnZKOMvCeuKlfZvCflbTwn6mmChtCGeCmsu+/vdal4LOHJCs9KuC2tCV7JPCfr7IKIEIeLnkiSkrgr7FK8J+HtSU2PMOB8JGkhuCshSrwkbaUCj1CO0k8W0ngqLzwkJu56qC2OcKuIvCRtL89LuCnnSc/KtGo8J65iWB68JGNlz3hoqZY0ajgqp/vv73wn5W0CjFCL/CehL3wkY2jJzQ/PSJ3e+C1hvCflbTwkJa5KuCqs/CflbQmfvCQqZBe8J6LpCgiCgNCAS4KO0I5JOG9nfCYrLVJxJTwkbGw8J+DnG/wn6mhOvCflbThs5l3wqV6ey9u8JCkv++/vfCflbTRqEI84LufCiFCH++/vSp70ahk77+PJeqvt2Lwnaqc4Ymm8J+isPCei78KBEICTWEKCEIG8JCBk3VKCjlCN+Cgt/CdvJzRqDrgqLxBOeCtle2fgsKlP1okIvCetLLtn5BkdPCeiqfwkbWk4KaPYPCeuLVeWS8KBUIDwqUnCi5CLGDCvVxzJOG+m3rwq5+JIsKlPzAgLvCfiaA+JfCdppclOOG/kCLwnriu4aytChJCEGw8J/CSv4PRqD95J1w6XVsKP0I9e1868J65i/CRprLhjZEmwqXDqVkn4YmMdvCRhZhT4aSpPz3wm7KQ86CHqS4u5pGFL/CQqL/gpos/K++/vQoFQgPCpSoKFkIU8JGLsfCcvJjwnZWn4KaQ4b+80agKDEIK0ajhm68hYDxgLwouQixuPyLiroThv7PDtuqqoCp4LvCflbQmJWfwkIGQyLo84bKCfuG9m1wn4KeIUQojQiEvLeOAluOGmj9lRfCdlYZg8J2TgOChnvCRor7wkKCFL3QKF0IVL0gx8J6FgPCav7LwlqmQ0ajwkKC4Cj9CPXFMTvCflbTgsYfhg4fwnoCmTfCflbTgqo3wn5SN4aSRWXTCpSZIJOCmsvCRvIs6OOCxiMK04LGaKlzCpSQKFEIS8JCumz3RqO+/veqfkfCflbRLCj9CPeKttyc+Pe+/vSYiSMKl0ajgr7EmXFzwn4Op8JCWiOCzseCvrSciVvCWvp4nYHvCpTjwnLy6w7tC8JKTt10KLkIsVj1jLCritKfwn5W0Pe+sle+/pS8mwqXvv73qqbUnOmfigbFS8J65lCXgqLYKMkIwLtGoImbDvPCeupZGe0ou77+9LvCfr4Dgs6HqoYQva2jwnrm5ZfCdjKQu8KuhgFVcCilCJ+Coj2Qi8JGMnjolOnpK4K6Q0agnw4PgsYtM0aglyLpg4b+Ww4IqWwojQiEvYVx0U+OHmuCmg0J4OjPgp53gs4InOvCRpZjwnoWO0agKOEI28JuBl/CRo6AjTS/wn5+JZGM+L2XwkJKNKjgm8J64rCrgrrjwn5ucMfCfn7A80agi0ajwlq2SCgJCAAovQi3RqM6J8JCSuEvqoZ0u8JCAvH5p4KaPeT3hv7RE8JCTpmQnVXHwkJSZKvCQoaYKE0IR6qeY8JGMoMi6KlzwkI69wr4KB0IF8J+VtFwKOkI44bGC4amvJGBaRfCehYPwlrmBOOGykmDvt4N78JGbhfCflbThv5hcP8Os8J2SouqcscKl06g0wqUKFEIS4aqV8J+uqfCflbTvv71l766PCh5CHGnqrqB1PfCeo43wkbGZSELvv7174aK6LjE1Jm0KJEIiyLrwn5W08JGKiCole2Ay4LGYR++tgSXCpWEgJOGKui9cPAoCQgAKA0IBPQoDQgFqCidCJWLIunLgsI5NJkV98JOQlXsl6qOT6qC1Vm0v1ZIhfHvwkJaGIiYKMkIwOvCei7/vv73Dg+GltCIiXS/qp5c8LuCorSXCpXc68JC+hCprUeCvtCTCslvCs8KlCjZCNDEqIvCRp5RLeGA2UPCxqLl54recT/CeiqzqoY9B4Z2w8KqllTrgtasmTULwkbWoXPCWqYcKM0IxPfCRipTDq+K3kip1fi/gqa076qq3XMKl8JCBk8Kr4aCY4reA8JuJh0dDauCpkT4mJQoeQhwxWMi6wqUvY/Ceuaglw7En8J66g/Cfopxz77mgCiJCIOGehHvhiaPwkLCLyLrvv71iOic64L+TJlp7JiTCpUt6CgdCBe+/vUI/Ci9CLfCfoZDwnoWC4pGIeC9t4Z+V0ah+bHsuVGDwnriBROqbnERK4L67P++4hi8kZAoFQgNSPUgKCEIGOuCjk0ZgCk9CTVHwkYyDcvCWvIs94Ker0ahI76qF8J64gPCdlKZ48JGEp/CThq9j8KyVg+C6guKckvCQlrQu8JGIhVzgprnwkbuqPvCdkqVHLuCpmWczCgxCCuGlgG9c8JCgqCIKGkIYyLoqcyUu8J6ElCsi8JCkvy/vv73DriUnCjdCNcO3IfCRmprCvVoiPTxlZDwqL1pGYGnwkZGePPCQhIDwkKO04oCH77+9WPCflbR5J3I3XMOgCgNCAToKE0IRL3s80aha8Ja/pPCQgL/gtpUKR0JFYHfwkbWn4aKpyLrhpLbXtDDwnoSq4aWwLj3wkbSJbjNgPXvCpfCQgKTqmZbwkaSVwqXwnrmk8Jq/sGRgezrvrL7isaM/CjlCNy/RqOC6meG/mOCzqiZgOlHigrvgsIjwn6+54aacVsKlw5o40agm4ra54Ki8PTzwkbWH8Ja/sXEKM0IxJSovLi8gwr3gpoVg8JCAuSRcOz0lXPCav709w7ppdSbgqYDwm7KHSPCflbQ/JcKlUgoaQhgk4Ki84LuU4K6O4Z614KeC8J28qlwieHsKQkJA0ajwn5W08JGCs1nhrrjwnrqGLj3wnrqySvCQuaIidD8r86CEinTwkKKvbfCegKpgXiLgoqYi8JGcvyglOuCvlwo6QjhcYkEi4amJ4rauKvCQsKhf4LKs8JCVv+Cuni574ZKS8J2Tg/CeupdGV/CepZ9cYPCegKrhs4Q3OgoCQgAKPkI8LlZc7YehLuGlgMKxcPCWv6JC8JCzkGE/OuC6geGktj1C8J+fsOqfmEHgsJ0iJeGPuCZjO+C3gVFr4KCzCjFCL8i6SEDtnrnhpKEuJiYl77+9JyU78JGkhfCRjLLCpO+tg++/lvCbhLIl4Las6qOECglCB/CSk4rhiZ0KRUJDYCc644Cl8JCWqOCzhDLhj7zwkYyd4KizPfCbspFGPzzgr5d+KyXwn5W0JuKFkNGoU/CeuY7CpWLwkKGIwqUlL+qgswoMQgp1OnLwlquw4aWAChlCFzQlzonwk5GEInN377+9PSon77+94q24CgJCAAowQi5t8JGAs++tici6feqjliFf4amKa+CgsWZBIifwnoql8J64pPCdhIQvd/CRtpBsCjZCND3wlqGhNypz6qWEIj3wn5W08JCkgErYjic/4LGd4Y6/TPCflbR78J2TguKAoT094b2Nw6kKF0IV8J65kSR86qykPSJD0ag8w77wnZWACgpCCMi6fu+/vT1gCiVCI3rwnp+qJmrhjJLwkI2sNTnwkYyPQz8q1qjwkYqWwqXDi96OCiRCIklneOqspCLwn5+wLu+/vSLwkZye8JuCrsKw8J+VtPCRmaEKLEIqKj0lOC/CpX3gr4p9VuCrofCflbRrPCTwkbKaKlzhoIcnPC7qnZfwkYytChlCFyIl8JCmvSROKnzisKbwlqux8JC8gj06Ch1CG3vwlqWZ8J+ekvCWqpsg8J2SvkXhg4c8wqUqJwo0QjLwkY2iPPCQo7TgtoN68JGwh++/vfCflbTwkYiH8JCos9Go27kn8JCyn+Czi8Kr4Ki8cgoQQg4vc8Kh4Ki5QSZpJuCqiQoJQgch4K6T4q6SCghCBsK2POC0jgoTQhFCP1rwkbGQL2A/8JGBqOCtqgoFQgPZsnIKDgoEbmFtZRIGQgTgoKQlCg8KCW5hbWVzcGFjZRICCAQKpxe6AaMXCvsWCgdjb2x1bW5zEu8WsgHrFgoPQg3DrjTwnrinPlDwn5mcCi5CLPCRnLrhqJ7wkr+o6qWs8J+VtFwq76yVw53hqonwk5GOcyY54bCMVyZcWtGoCjFCL+Cos3siJmNzPNS20agzPOqop9Go8JCol00iP+GDjT5R8JCBiyfwsZOPfMi6Usi6ChpCGF4le0I/4KmH8JiypiJvVdaP8JuFlT0/bgouQizhiope4b2ReybhsLM9TSLCpShlOkTgp4hHOi9kTXwn8JGMsCLwkKS/8J2LjwoKQgjhsbVb8JatlgoeQhziuojwn5W08JColV/wn5W0w5JcZ1zvrKrCpWpoCitCKfCflbR4aV89w7Mq8J2UinngsZ3wn5W00ahnLzXRqCQmePCflbQ2JCV9CiZCJCclJS49ZCU88JC6seqdp/CslIdmZy/gs6gm8J+UnSbwn5W0KgoGQgTwn6KwCgRCAtGoChBCDiFj8JGNkMOY4reMaVxFCgdCBfCdqqUmCgZCBGDgqocKGUIX77+m8JCti/CQlrtc4K2ddu+sgfCQlrsKFUIT8JChieGfsOCnrtGoYC7wn6aWfgoMQgrCoCXwn5W0wqUkCgZCBNGoPS8KPEI6NeGvo/CRjbEoJ+KIuHRH8JCBlTzwkb+A4aSe8JGyo8OAJic/77+9PcO1Llx7KvCQhoMoJ1zCpT4hXAoUQhI84b6r8J+Djz17bu+/veCumi8KHkIcwqVDUUp78JCWhPCRkZ1vJSY4ajYv8JG2l3s6PQpCQkDIuiB7IfCRnITCrljwkY2N4b+z8JGojTdq8J64g1I88J+VtOG/uPCeubQyNHvqrIt64LeK4K+oXPCeuYvvv6tcCgdCBe+/vdGoCjRCMipg8JGMsj/wkJaSQVVoIjnwkIuH4KiC8JC7v8KlJGXwkbWVdeCxqSZb0ahgLFUi4LeuCjJCMEgqJWBg4LazMPCRmrjvuJfgs53wkYy5Um1j4Ki54KewRDBi8JGMssK88JGNrOGlngooQibgu4bDi+KCmVomNinCsjAqZC/gtZjwnoCpfu+7u/CflbQ98J2SuAoGQgQnPyU9ChVCEyrwnrmSJMKl4LadUPCeuZdaXC8KHEIaOiXIutGoIj0/JT8mOuCxmfCRsbxgJuC3kSkKCUIH8JGNjOCzpgpFQkPwn5u14b+k6qmY8JCwiSLIulHwnYuT4YuLYFDgq6E94K6DXuC1iPCeuZ/IuiUqbO+5s+GLhSUyVfCeuqVC8J2Sqy5QCilCJyfwnrmU8JCpg+GkteGxhOCtjFjIuuqjmHg0Z0fhpI7goaBg4ameMQoYQhY5fiTwmLSE77+9P+GzhVw94b+T4KqtCixCKicrR2QhJvCeuqbwkJaRYHtcVOCunuGmivCQrplZ8JG9hiThppTCpdeyaAoUQhInJMK+QCXwlqum4Ymb8JG0vCcKKUIn8JKIlXvwn5W0KOCmuNCTRi/wqoqX4r6jROGdkMKlQifgporwnZK9CipCKNGoyLpcw77jhr54e+C6neGJlD9c4aWyOu+/vfCRpqN5LVLvv717wrcKFEIS8JCMg2Al4ZSqcivqkr7wnrm2CidCJfCRnLbigpQ/PSUvJjHDuPCdkILit4U8Ty7wn5W0XEDqoJ57My4KKEImLHs3IcKldCTwnrinSfCQtIthwqXCpmTgrZxLMkdc4KuAwqXgqLwKFEISKvCQoLzwn5W08JGBnmrwnoC5CjxCOkXgoZ7gtaHqrbErL+CrvzjwkKmVNCrwkIem8J+hl3N7e/CQobjwnoWPaC8vaeC6gi7grogqY++/nHQKKkIo8J65jS4x8JCPjOO2kmo6IvCdjLlg4KyX4Yq5KHbRqCVtSu+ku8OSKgomQiTbufCQirgu8J64ofCflbRy4Le0USbvrYHwn5W08J2Sqy/gqLUKR0JFT/CflbRJODzwm4q+8J+vteK7lirwkYqNVER9YFrwkb6wU/CQoIjwmr+w44aZ6qqW4b+HPSrwkYS98J2lqmngrIPwkLqtChNCEe+/gsKlPS/hnqIvMMi64oCgChZCFC/wkLC+8JKDhTgk0agqwqvwn5W0CgVCAypwPAo5Qjc/JvCQqKDiuYjwnrqt4r+w8J2Urj3wkYKBJCHhiozhqoJg6quhaeCoueC2g+2fhHvwkYGu6qyMCixCKsKlRj868J+VtO+/vdiHw5rwnri7fWBTPUHwn6ul4byaJTxlOuCynzInewoFQgPguqMKCEIGJtyd762BChxCGvCfqbLwkYyzYD/wkKeXMvCflbQ8LiXCvcKsCixCKuCqvjo6yLrvv5x+8JGMhuCxij9+Pci6Kj1c4KegTyXCpci6S+qskuK0jQpFQkPCvFzwkbS6N+Gdjl4uYOCmvPCRpJbwkYWgevCQjK7goZ58P8OF8JCHlSrgrK7gsZ0y8JapheG9mzIqPD3iuobwlqmFCiRCIvCeo5bwnoCb8JuyhMO48J+vsi7wkbyP8JCpkCXwkKCFXl0KO0I50ahfI2vRqDXwkKCK4aSQ0ajIuivhv49CKeCmuWDwnriLQPCdm7178JaphW978JGllzhCVvCfm6RcCgpCCHPwkbS90agiCiJCIEPCpeGqiUQne/CeuKdj8JGEvT8iJybCpfCRg6PgqYdHCkNCQS7gs4jwkI6HLvCflbTRqPCRsq0/WCJH77+K8J+VtEjgoYnwn4e7XT3hiY1K8J2ItvCRtL/wnoWOP8KlNDotUGBGCilCJz094LCO77+90ajqqqLjgLbhvZtcUCbwkZaO8JuBhSrwnoS2duCouQoEQgLCpQosQirwn5W0T+K9m/Cfn6c9IuOIil0zYMK/JvCQgLx58J6jiNW18J65gvCeuYkKLEIqPOGOgsOA4YOHX3vguoInLGVLb2wufHBr6p2kb/CflbQ9R/CSlIHwkaWBChRCEifwnoWEyLovYO+/vT0v8JCNiApHQkVlVkPwnoWJJPCRtpfwkY2XPUHhvbLCpeK2vfCflbR7bVFH6q2k4Kew4LuIJDrhraku6qmQ6qGs0ajwkYuxWu+/vfCQnoUKCkIIXe+/vfCen7QKGEIW4aSy4Luf8JGTluG8tDrwmr+94LuGLgoSQhDwn5KeT8Kl8JGMkFN94Z2lCg1CC3rqqY3hv7Nxw6oqCiVCIz3wnLy98J+eoPCQhJM0evCeuILwkKGBOvCeuZRRPUMnLnw/CipCKPCeuKJp0ajwkY2fPWZv8J64u1xA4La9QSXwnZWOZMi64K2NIvCdjK0KIEIebiYn8JCkvy/vt49fw63wn5W04YONSuCzptyp4YyDCgJCAAoKQghRK/CQnrM6cgoVQhPvrYTDrfCflbQ/8J+grSYn44KWCjZCNHsoJHNuMXTwkY2i4aWALiDgqrngqZF6LvCQvoDgqY3it4PhvJrhoo9SJWBsJVzwlq2gMHYKPUI78J6AlCU6WDrwn6CLJ2U8e+CnnfCSkbJXQOK2vkTwlqu0XyLRqCdrdeGok/CQloVg4LiazLLikYU/wqAKI0IhKsOg8J+VtCQqIu+/vVzwkIeT4rWW8JGyqiJr3JJSScOmCihCJuK3k8K3e1x4J+CuqGo6dO+/riLwkKiNJMOX8JCWpTwiJ/CdlZc9ChJCEPCeuZ/gv4Mq8JCgvDTqm4MKKEImOj/RqCYn8J2qm3AkPfCflbTvubBNVDPqpJ9cyLrgu4JcKuC0jj8KBkIE4Yq5JAozQjE84bC8JC/CoGrwkIqYIU9I4Ki84ras4b6/4aC6XMKl8J65m++3tfCWrb7hp5XCpT97CjtCOVdbdOGgifCRi7df8J65sfCRo6Jg8JCpgUNcYTzitrtQPeCulHoo8J6fqfCQqaU8Q/CforHgrYQ9WgopQifwkYuM8JG1sT/hsL7wkKaEJCdgJGpTPTrigYo/P/CbhaXTn/CRsKYKEgoEbmFtZRIKQggvc+qopd2AIgoPCgluYW1lc3BhY2USAggECtoKugHWCgqRCgoHY29sdW1ucxKFCrIBgQoKO0I54LKn4LeW8JCDliYk4LeR8J+VtDXCquC0vV97SuqekdWW4LqCYCR5Vj3wn6GyaeGzny7CrPCQlo4iCi1CK1FSJHnwkaeLI8OPQjzwkK2APfCegYfhvZs/ZcKlXE06L2c/8JCGkXAiwqUKPEI6wqXljq4l4KuN4ae4Szrhp4hF8J+VtFY78J2MpfCeuqFI8JGcpTHgtr17Zls/wr0m4LGi4LSCOnt7agorQilPUGDCpdGo77+9aci6PdGo8J2Yp1Q84YyVIiU84Kqs4ZyQPfCQlqpXaAolQiNdJGLgsI7hvYx6K3t0Vz9i77+9Vzwi4Kal8J+VtMKl8J66jAoJQgfIuvCflbQvCkBCPvCeuYJAPOCziuGLi9GoKvCeuZ09J0vwkI+L8JGas8Kl8JCSjTxgY+GDje+/vXfwn5W08J+VtPCflbTwkYSLChdCFVxQIu+/vSpHXDrgqI8lJD868J2IpQozQjEyJC7wn5W0InslP2VcwqXwnYyGPSQk8J+rgPCfrpV0XG/wkZGeJVzvv73vv73qr7Y8CjJCMCovwqZn77+bU0fwkaO/JuGyluqSsWlSJuK2vilPJc6aw7XCpSB48JuFpHtl8J+rpAoxQi/qrJJCXci6yLrwkZmRc/CegIjvv73wnrmb8J6lll1m8JCSofCRg7N+IeC3hiZgSAoJQgfwn4CcJ0NFCgJCAAoFQgPirogKM0IxLifwkbWoMDol8J6FgirwnrmHOuqvs/CRm4kv77+9atGoL/CflbRALk3hoJgn8J6FgwoiQiAq8JC0sNex8JCireK0p/CcvJHwnoCmw6Uk4bGD8JCWlQoGQgTwn5W0CitCKfCbg4kl8J+qvcKu8JGEnyTwn5uiXGRm8J+VtOC7jXFb4K+2OiIqJD8lChZCFEjtn7rCpXrgq5BIP+Cph/Cfg4J4CiJCIPCeuYvwkYGTyLpx4LK2NWAvPTJb4aWA6qaDaDp74LOMCjBCLsi677+94LSMZ2fiurzwn5W0auCuvvCdk4IqJUQn4LeyJ2UkJsKlzb/wkJKlaCIKN0I14b2dez3gt4rwnrikdvCRpLjgqI8vWSV3yLrvrIUl4YmV8JCekfCQjooi8JC8ijZc8J+VtCYKDEIKL+Gnl+CsmmJiQQoFQgPhiacKL0It8JuxscKlJ/CflbTgs4bwlqmi8JuFp8Ks4LOVLWFFJnfgsZbwkaSGUFDDhiolChpCGGA8OiU/OvCeo4zRqCkudW17YEEqyLpgPgozQjHvu54nYNykV/CQhKg7LeCnnyfwm7KD4byc8J+mmSRcQPCeuqXRqO+/vV3gsI7wkpKTChJCECcgYDR8PS7wnbyq8JGkgVwKJ0Il8Jasnsi6KiVdVVg8MNGodOKAtiLwkK2twqXgpo/wn6uAJzfIugoCQgAKM0IxKk138JCMo3DwkbGQOuGLgDw/cSXDnOK2ti8lIsi6KPCRo78i4LKU0ahg4rec8JCkgwo5Qjd78JGNh2Dwq42i4Z2qP3nCpScuOuCyhCdtJSJ7JGbCpe+/vT0vct6l7Z+X8J+fpfOghr89PWBnCjBCLnPwrLqKKns7SnVy8JGNqe+tg3vCpSTwkbWoJicn4b+86qqxY/CflbTwn5W0ezYKDkIM0ahuazLwnoWA4KyICipCKFbwn6GWyLriv7rwkJG5RfCfg4tOJXlnOCfwkLqrRvCRk5nhppfqrIQKLwoEbmFtZRInQiVd8J64pFjhv5ku4rSGJu+/vcOoTuC6kCfCpfCdvKdxKuGisci6Cg8KCW5hbWVzcGFjZRICCAQKnQm6AZkJCqkICgdjb2x1bW5zEp0IsgGZCApFQkMk8J+iscKpP/CQqJfwkoiILvCRiql74KinQyQu4K2V8J+VtPCRhLzwm4WSe/CQgK3wm7KEfEZgN0Y/OsOEUXw24K6jCkVCQ++/veKDnUJcXDTwkKiWTuK6glDwnYSFJEV2e8Kl77+977mw6q2r4b+X8JCWp++/vfCrnqXDm3s8SOK1hPCRjbHWjyYKQEI+LuCqpe+/vUFE77+9P+CvhiYu7KWA76ypJlTIunQq8J65tuGeqOC4tfCegIzwsYGpdipvKsOT8J65pCR5eGAKB0IF77+VwqUKBkIE8JChvAojQiFzPPCQoLx+e+GggyZg8J+Cq/CQoLhc8JGAteCyj/CdlY4KBUID4KeLCiVCIz3wnrmfJuG9my9g8J+vs+Cvl/CRtb9c76y+RPCQpr44IsKrCgJCAAo4QjbwnqWfWuqntGjRqEUl8J6Fji4877+94LSG64eaTOCotmM9yLpaYMKlKvCQlqxKe+GDhybIuiUKDEIKKvCRgajguooncQoYQhYqwqo/LzrCpcKh8J65i828VSZy4K6qCj9CPeGKsuK2pfCWv6JI8J+er2hgOyLtn4Q877+9P+GZtWAq4oKjQibwlqmiKuK2tfCRkIQw4rStLuGdoG3DiiAKCEIG8JuFlS9OCiRCIntpPOGfqHtv8JCwjvCRjbTwkJKoKuCmmvCQpL86PPCehLIKGEIW4KmeKjngrIrwkaO/35k24YqyKDzIugoMQgrwn5W08JGFqdGoChJCEOC1lmoyZS/wkbSRN+G/vS8KJ0Il4Lya8JGNlyUjOvCRp5/vv706168mZlcve0Twnp+70ahz44O0Pwo6QjhcLnQi1LY9YMi6azLwn5W0dvCbsakm8J+VtMOH4LGI76ywcCdwJ/CflbTwkaWSZi96V1No8J65sgovQi1NwqXwn5W0fPCRtajgsL0vJUUm4KqzdEEi8J+VtFc88Jq/uFw877+9JcK8wqMKJ0Il8J+VtOqpmeGmtN6fw79a0ag/O2ZV8JG1l/CflbQvPDUzL2AqXAoMQgpgIjziuoDwm4WVCjRCMsKl8JCBilzCuPCdkJsr4bycUzAjYCDRqPCRqL528JGxueGovCQu8J+VtU/vqa0k4LyaCglCB8KlPPCav74KDUIL4Ky9JvCehKvDhD8KJ0IlJ++/vXMiZ1zvv73wnYSEw4XgspIi8J+VtPCflbQg4pCKbuCxlgofQh3hv5ZrPTBg8J65iTzRqD/gsIFuSjDwkaSd77ajJgo4QjbwkZqGe9Go77+bL2/al1wqYCYi4Ki277+9XNGobOKUiOKRguC3jyI/XGAyNcKlWyrvv5TvrYEKL0ItQWvwkaSa8JGNoeCwjvCeuLvwkbKU77+9UyJAIHzwkKmj8J65jVxiJi48Y9ejChUKBG5hbWUSDUILPE3Iuu+skybRqF8KVAoJbmFtZXNwYWNlEkdCRfCfgIR74LufLirwlquoXkjIuvCfq5bvqr9bJPCfn7DwnpOfVzHIuvCQrJnwn6KxZD8m4Kme4aW08JCameGKs1Dlh5UqWgrPHLoByxwK2xsKB2NvbHVtbnMSzxuyAcsbCi9CLW0w4LuG8J+VtDrwm7G0Ji5l8JCjrTzwkaakJXoo8JuxtXtw8JGdhi7DqCZgewowQi7jhq5Ra3sk8JCSgyU96qeV8J+rmXE6w48ubyci8J67sVtW4bOiP/CWvaYjJn46Cj1CO3B1dj484aeQJOGyvuGPvG3wkIO0P/CflbRSJSUuYCUv8JGMj+CnoOGklirgsb7iu5jwkLOnyLrwnLy0CgtCCW3RqCY88JCWlAoyQjAkMFvwkZK38JCwnmdvPTU6cOqvszInXOC/mS5B8JizguG9m/CRtLowPOC+m/CRvrAKKEIm4aWAPDYobPCeuZQwPWBqe8i6Ky84PeqlpdGoIsi68J64mvCRk5AKO0I54aSM8J6lkzrwn5W0YOGJmlnhnaAqIvCav7gv8JGkjOCnolLhpbDwkKO0e0YvPfCThrfgqavisr8vCilCJ3ngt4BWZOCunC7wnrik4raxb3o/8J6Al/CQppYmXCfwkbWF8JCEhwo+QjzQrmPDkeCukPCflbRcLiR48JGogCQk8LGijSJh8LG6i+K2q8i6Qzwmfn7gr5d9dMODbvCdqpwiPfCflbQKDkIMPyZi77+98J+roj0hCkhCRuG/ovCRiojhsarhpaUj8JGNlzIkfe+/vUzvv4XhvY3wkICQXOCkunnwn52Je8KoLsi6w5Eu8J6ApirwkIC88J67sfCRqp0KC0IJJPCRioglNWA1CgRCAi5PCjhCNvCflbRgJFTwkpKg8J64tPCfg5nDqDoqaEnhvo/wnL2SPXjwn5W08J+JhvCWqZEuLsO18JCAqgoGQgQuLyQ9ChFCD9Go4YmcI/Ceub7wn5W0LwoQQg7grYtgIi014b+t4YmYfgoHQgXgpo/Dsgo8QjrCpfCQnoM0fPCQtLIi8JCGmirqo5F744OeLCrvv71cXPCegKPhvZngsI/wkLmnXGXwn62dPfCRp6FeCg5CDFFnI2Tgt4on4KaqYgo+Qjzgs61ldCck8J+nvFwqPcKjWj8lY+GJmD3wn6u38JCkrnnwnZCROFpjZvCeuLDwq56Q6qaFyLogXCXvv70KPEI64aqqPUEmyLomeyYgJHpeyLrwk4eR8JGDs8K+0ajqnovOivCetLbwn4aKyLrwlqqK8J6yryU8JuCnnAoSQhDwn5W0buGztOGMifCRv5MkCjBCLvCQoq7CpXvwkJS64reKN1w8XPCQoY0qJjHhs4Et8JCnivCflbTwn6qtPDrhrYYKJ0IlRXfwn6u24LuGP/CRmaTRqDBX77+9e/CRsqzhiZo8Ij3hnI9cJAoaQhjgvIM/IvCfnIDwn5W08J+Cv2AgLvCRgqgKJEIiNCQ6KuK1lCp3SMK00ag/OiVfVO+ukuOHlz97J3t5JeGPuQobQhlgP3rwkIut8JOLumIu8JG8jsKlJS9AYHt4CgpCCCdB8J6friotCg9CDVwmyLrwn52E8JCBgUcKEUIP8JC0pSrqrK0l6p+Q4b2SChNCESXwn5W08J+VtCVPJiZg6qWgCjFCL++/vWrwkaOT8JChlD/wnZWCPyTCpXvVoHsrWfCdkp5KJ+ChouGeu/CQlrnhiZpwCgtCCfCRk5Dwn4CoewohQh/wlrmhJ/Cdk7fvv708eyYq4q258J65m+GlgPCQvZNgChRCEu+5lyrwkbyFPXdx6qyM8J2Lqgo6Qjjwn5W0TMKhYCLIuvCeuZnRqGBeLuCzlmsnQPCfopDgrJDwnriI8J+VtGdY8J65nyll8JG0uu+/vQoRQg8qOycmMu+/vfCQlrzCpT0KCkIIQS9gXeK2h3wKFUITYt2b8J+VtCpc4KilT++/rS4uUwo+QjzDr+C+iuqviPCRjIDvv4TwkbSD8JCNpuCvhuGJvfCeuqXRqHspUvCQq65L8J65nU/IuvCroIDvrLjgqZEKJEIi1q7itqVbZCrIuuCuo1s9fVwv4ralV/CQro08SPCRtZhmLAo6Qjjgq4VgyLrgq6HwkLyJwqVcS/CehY8vIiE+yLrgp4BLJiJfYOC2k/CdnYxu8J6KrXHgoYngqZkqbQooQiZYdPCQraHvv71iIuqjk/CeuqdkJncq8JGNhDrRqPCQpqkt4KiJIgoZQhckZzo08JG8h/CfqYI6OvCRsLrwkYuwSQo0QjJgOvCQooo60agp4oCF8JCMvOCvtUtZJURA8J2JguKquk974KuQIkQqLSppWOCsp8KlPQoOQgzDuPCRrIA/8JCoukEKKEImIm8mfe+4sPCQnrgi4K+G8J2Sn86HJO2esjVVZzrCpfCQtLHgu4kKI0Ih77+96pqmJeGKqiQhSypc8JCon8Kl8J+VtNGo4LWH4KGCCiRCIsOlZN+cTWvwn5yjPXvwkYqgZj9h4ae3MOGmp/CQs4Hhip0KDEIKKjoq4Kuqa3vCqQofQh3Iuj5AbeCmmmDCpeC1iPCRiojwn5W04K6Z8J6Fjwo1QjMzceCwiOqslT/wkKOkJmDwkZOT6qyk4a2e4K6PIsKl77+S4LuOJ++/vSZge+GPvMKlLmAKGEIWKnRUKtGoPSdw8J66je+lpeCzneG/pgoSQhAm4KaFKuCujyY1WO+5sTonCkVCQ18u4KejYOyZvTpmVzvvv70iJSI98J6ln++4t/CeupDwn5W08JGKjF4/4pGJaPCcvIMww7hc8J2Sv1fwnrqhIvCRhbMKD0INJVzCpeG9qTFX8JKUngopQifvt49VJHLgsIwnNOCuhzLjhIVg4YONR/Ceuag88J+VtFbwkIeiKDgKPEI6OMi6e2JjOj1V4byy8J+VtCU/8JCoqD9GLyXwkbCPZvCegIXqqYcn8JGWh++/veCsqjfgqZzwkaSWIgosQipgLyLwkaWTLjon8J66p9GoS++5sT9cesi64Z2MJ/CeuZ/gtI/gt7PIuiQKGEIW8JasvPCRmKrwkKGPXMOpLC57LloqWwoUQhLRqCLwkJ6A4KyLZvCflbQuyLoKKEIm0ahc4Ym4NSgnyLrhp5g8Wz8k8J+CjFEvLjczUvCRrIFfXPCRmogKJEIi0ahWLyc84K2MYOGqg+GznvCflbQq77+9KvCRtZDgrp4vIwomQiThg4dHSPCdkp/wnZWOYF4kL+K6lj/wkISB4ra6PeGgvEsvIj8KJ0Il4KqdLiXhpr4vXF/CpfCdlIldPfCQoJvwkaWB4aOlJC7wkJq8OgoPQg3hsqQ/KiQuZOC7jl1wCg1CCy9S6qqmyLrgroZ6CiNCIeC1rHXgs4pRVlzwnrmU77+9aTDIuiYnMHNee9GoLu+5qQoZQhfwlr6R8J+VtDzgrqMm4Kay4La9PO+slgpEQkI8cvCdk6/gpbFXw77wnrqa4LGdw5HwkbaBJfCfg4fDmVw1fOK/ueCgmSfvrL5VWi/gqZFS8JGSgDzwkZa4Ql7vuKMKGUIXdC4l8JGyoVzwkKSJXHlg4b2R8JGcsDoKLEIqSjR7UOCshiXhpbM6P/CRh6bwkJad8JCPkC4o4K+wXMOSczzwn6+3Lj1uCilCJz8mdik84oOk8J2Vg/CRtIZc2I0l8JCwu/Cfn7A28JCGkci677+9Jgo2QjQk4LuGJOCovio26qylNiJ28JGKiPCRtqg9XOGekfCeso/wkZuGfSdpJDTCruC1qfCeuY0mCjFCLyTgqY0/JPCRpZTwnqONdnVv8JCUgHfwn6qDajjwkKGTMErikYjwm4SyJ2EvJN2DCitCKV7hj6PCpuGvmuqsoybwnp+k8JCMvPCfobB8JOGxg1/IuvCQrLHCryZbCjJCMFRYePCav7jwr6iIay/wm7KI4Kqy4b+Y4Ka2KvCfqbpS26nwn5W0wrvRqDrwn6CSfQoEQgJ7MgojQiHCpSbCpSLqqpzDvfCRiIvwn6ujWCIx8JCGl9GowrMt0agKF0IV8JG1ofCflbQ6JCbwkZGZOiDwk5GPCilCJyYi4K6Cezss6qmEXDgmwqXwkJaRey/wnZWG4LeUOPCehYI8VsKlbgoRQg/IusKlKVHhrpA6bybgp5wKJUIj8JCkk++/vci68J66t/CRh5tg8JGGmWBg0ajIuuK6gfCRtpEKCEIGXPCQo7QiCj5CPDp58JGMrGYiYC7gtr3guqzgraHhnajIuuGnqSxK4KK+0agkJuCoqlnwnrmO8J2mqeCvl2BL4K21JzzCpQoRQg9577are8Kl8JCAhfCWq7AKMEIuP0HCpV/wkYy2bHzgsZ0keFwuLz064aSzIu+svl1r77+9e3w977+94Lql8K+hrQoXQhXIunV6cOC3ridcw5bvv71XUvCeuqcKDEIKLuCpkXphLkPCpQo+Qjxg8JC6l++wl8KmLvCRjbFbI+KAimo6YOqlp/CQlpTwnZSZ8J+VtPCRpIBpfeCxiFw7OuG9m1w9ffCRvrAKDEIK8JGMry86e2pkUAo4Qjbwn5W04YuDOtGoMiVfMD1cMic777+gK/CflbTRqHjgtZ82ZzTvv4MuOPCRiobjhYfwn6+yLzwKSkJI8J66ofCeuYvgsJjCpfCRjLLqp5QuL+Gftsi6XPCeuqnwlr+k0ajwn4Kl4Lq84Z+mP/CRl5nikYnwlr+j4rumXD3vv71g4LaBCiFCH3vhjLThv5dEPPCRiotB8JCVnXnwn4iBQXbRqPCflbQKO0I5PdaO8JGKgCEg4Yafw6jgoIMqb3LhnIYqaXzvv73wnrqo6qylZzFgQWAl4YS+Y/CdlYtq4aqU6p+RCjAKBG5hbWUSKEIm6qGQOu+svl0l8JCWr+Gfoncm8J+VtOK2o/CflbTwkYehOlwnyLoKOQoJbmFtZXNwYWNlEixCKj4nXC/wkIWQU2DwkIuz8JG0iOqonCjOjCIw4o2zJGDRqNGoJvCRjYwvOgqcBLoBmAQKrgMKB2NvbHVtbnMSogOyAZ4DCh9CHcOi4bKp8JCuqlwl8JGMlSrwn4CiUyQx0ahf77+9ChFCD2bitKfwnZKi8J2qq+CqsgoaQhgk77+cfXvwkYy50ajwnaqpQyfDvj0lIlkKBUIDL2BuCiRCIvCQnafVrOCskPCQhqDDj+CniFrtn4I2Lipb4LeW8JCgklwKMEIuQuG/pT0xw5VhZvCQjZgl44Wg8K2Xkk4kTCdO8J+VtDhr4aOn4reQ8J64u+CviAozQjFb8JORgVQiUHJdMvCbhLLwkJaQ4Kes4KqLIsOq4KiuR+K0rS9nPzDihoEmJD0k77mkCixCKirwp7CpVMKlKvCRjZBcw5h6XDR7L/CeuYvwn5W0wr4vJiVr4LCPJjdkOgoCQgAKHUIb8J2Vhicie8OUJOG9mXtl8J2ilfCflbTwkaeaCh5CHC/wnri7NGYlXSbqoLVP44a7eyvCsjzwn5u3wrMKA0IBJgodQhvkg4TCpUHikYd6L/CRtLpAYMO8P8i6JTgxPS4KG0IZ6qeQ8JG0vyJcI/CRtYBi4Laj77GC8JCThgoGQgTwn46MCikKBG5hbWUSIUIfLvCQtLnYiiZoYPCdk7E0yLov4KGIOvCfq5TDrCY6Zwo6CgluYW1lc3BhY2USLUIrIsKlP9Go6o+AS1jIui4mw5PwkpChP+GPuPCWq7VkKvCfrJQ/4ZutOuqgsgqtA7oBqQMK+QIKB2NvbHVtbnMS7QKyAekCCiRCIvCRjKNKImBmJz4iYkXwnZS74KqtOs2/4b+98JGwgkoldCcKM0IxJVsj76y4YMKl4LeSw6ElzaFxyLrwn5+wWe+/veCqvsKlfS994La98J65iSQk8JGNkApEQkLhioLwn5W0wqo84Ka98JGnnnE9YfCQoaDwkLOKJD1H8JGMgcKl8JarteCnh8OjLm42yLpzLvCeuYLgr4zCtOCss2YKNUIz8JG1gzTvv71qyLrivK1gdOGpjCJm8Japg9GoUTjqrq9uScOTIuGbnnXgrpDwkYqP77utCiJCIPCeuK3RqPCbsojUmzo/1qPCs/CQkr3wkZydw4x+NDlNCi5CLGU84b2BJuG/tmvguoFs77+MIjXwkK25XPCRmojCpe+/vfCRjL/qn5EuJ2RcCjZCNMi6JmBbTeCsufCRgbXwnp+uIvCflbTCpeC2geCsi17hs4bwnZK78JCunOC4oS7wkLOFXCIKA0IBIQoaCgRuYW1lEhJCEOGFkCTwkYak8J+ppCbhsr0KDwoJbmFtZXNwYWNlEgIIBAqqGboBphkK2xgKB2NvbHVtbnMSzxiyAcsYCjhCNl/wn6qHJeC9keCunmrwkJa84ZypXeK2hVzvv70/8JatndGoPfCRsIc8yLrvv73gq4fhvZnRqAoWQhTgu57wkKi6Iinvv73wkr6qLuChjAobQhlt77+9JcKsPDTwkaSAJz8/8JCoj+CqtlhGCj9CPfCQrq1ndiIn4Yq58JGNjfCWq7Ml8JCznuG/mjVgPzwv34BN8J+VtPCeuqLgro7wq5+Z76yX8J6AlDrRqCYKIkIgM++5q3nwnoC/QSLwkYy94reJ8J+DoOqTlErRqPCQhpkKGEIWfuCviPCRmIxz8J6iv+GqgeC0kO+/vQpOQkzwn5W04Zqke+GMvMi68JuFlTrhvLXRqDzwnriq4K6e77+9NSJ+0ajwkb+Q8JCTsD3wkKiSQCbwn6q18JGNqyrwkaS34LGpduGntyIjChhCFi0iLzrhr6Vh8J6fqzo2JSTwn5W0XDoKGUIX4YuFJEPwlqu06qmIe/CfoIXit5lxVCIKA0IBdQpBQj/wkI+D8JiQkyTCpfCRjKLwkJ6DYPCQp5/Co2Bc6q6Z8JCOrvCeo5M98JCypvCyh6duT/CroqDIuuCzgiTCsTwKSUJH8JGNkNGo8J+VtGHsrbt38JG1uVAuwqVNdvCeuqHCpeOEi++/veOHmuCsg/CShYNgdm3DgFxx4K2c8Ja9nfCQjoEk8J2MkSUKKUIn4LCr0ajNvC7wkYaqwqUq8JCFul/grYjwkJ6yWH7hqrU6YCbwkbaXCh9CHeC6pSQ0QvCdlKTgrKIw8JCVoV1yUCR5XyXwnrm+CilCJ0Il8J2ejz/grLLgp5/RqMOcw6E68JamhipN8JG1olnwkIydJOCnhwogQh594aad4LWGUsKlw5V0w6nCoyXDqj/Cvci68J+DgkQKBEICwqUKGkIYSHY1772oeybIuvCQqI174LqEXCThvZs8CilCJ0jIunHzoIaq8J65pG1MUih7JuGljifwkZmRSOC3j/CehYQr4LCbPQoKQgjwnoCK4b2LXgoLQgku8JGxtjzDoyAKGkIY4LuY1o3wlquDImDwlquX8K29iScj4rSnCitCKVxn4K6c17Dvv73CpW494KqR4aqZ8JGMgvCflbTRqOCtizwlQvCQq5Y8ChhCFkrvv70+PVXwkYWB1aPwlq2T6q2iUjYKUEJO8Ja5luG/jPCQubnwnoWOLnvIuvCRvIde77+NT2RU8J2LrvCdkp5V8JapmSU64aeQJ8ONR/CQkqLCpfCbsbPvv73CpvCQoL8i4amy4Kq/ChlCFyfwlquFX1xXyLrwn4OhYCJpLF3wn5W0ChdCFS/wkI+Sw6dGPOC3hvCTiLx74aeRewojQiHvv73Iusi6J8i6JybwkYy2Y17wlq2bw49Wwqo9Jci6JkcKEUIPP+G9lCrwn6C/Jizgq5BkCjtCOcKlJSrIunkzIuGmhu+/veGbpOG8sUpg8J6Cjz/guYIvI++/vfOghpLCsvCTkYBc8JiSu2BBIzliKgofQh1c0ajIusi6Kk0k4KuL44a18JGXgXIiRNGo4LKTJAoPQg0/PuCrvPCWv7DwkJOoCi5CLDfhqpg4ZeCruVx+4KeXPMKl0ajwsK2zX07wkJaDd8Kl8JGKkyrhqrZ6wqUgChxCGiUuXfCQuqskIPCQoIg68JG/qvCQqKpSL2JGCgxCCmIu8J+puGF4OlMKLEIq16Ar4ra257eW8Ja9pDtgw4XCpeC2pOChnirvt49g4LOzJOGJjOCosiciCjdCNTp+OiVELS/wn5W0KyTwkaSi0ag677+9QfCfq45Y4La7XCJg0ahqwqXhi4AkwqU76qy3SMi6CgZCBMOgJUMKIUIf0ag/Pz8m6paa4LGB8JuxumBwUj9+L0Il77+iJe+/vQoGQgThqoknCjpCOGhDPPCRnJTwkr60KvCTgp4i8J+hoyY6JcKlJs6McSYnJfCfnYcn8JGRnj096q2a8J+XhPCflbRpChNCESQw4L2s4reB4LudJT3wn5W0CjxCOvCfg6LqrJUkIuqsqeK2rPCRg7gu4bOE8J+qhTzgt5DwlqqaLzfwkY2XN+qupsOaQeCxrvCQlpXitroKGUIXPMKlUD09zpFL8J+ql9GoQOqWp0DgsLQKE0IR8J+vhSo9Vi46wqXIuiLMtSsKCEIGLiQ8eyUkCg5CDMi6bTxlUirRqOCxgAo7Qjkkw5DwkbS8IiJ68J65m/CesqXwnrmHyLp64bybw6bgq4kye1rwnaqeKi4n4rarPWJI8JGLsybigZIKBkIE8JuxtgoSQhDCpS9gJ++/vUJu8J2TiickCh5CHCfwn5W04b+Zfk96POOBoypW8J+VtMi6P28/LzoKEkIQ4LOd4K6PK+OAkkTXkzF7KgoCQgAKREJCIDom4aCH8J+VtHoqbycn8J+VtPCQlqDgq5AxUfCfqbYuwr9z8JCTku+/veK3lNGoJPCepZ8w4LmC8JG1h1zDhVxACjZCNCfwkIag4aCXzoxsOmtuOWMmL+CulMO74KCzdsKlRSTgqLwqJCcnLld74LuC4LOGUO+/vXsKIkIgwqVu4b+3w7/wnqWXcsKlIvCbsYJcbkY6Kj9qL/CbhLIKKkIowq4kP/CRiIlHP8Kl8JCki/CfqKPRqEYn8J+vsOC8oSJc8JC9tVwqTAo2QjQnOyUn8LCbvSxP8J6frSdJIj/gq65NIyTgropQ0ahcLi49yLpgWyLwkbGz8JCrgPCeuLs8Cj5CPDxcJyci8JG8jyE78JGZo+Chnu+/vcKldj7gtIjwnqWf8JGasHXCpeCmtyp3Ly/wkJyAeybwkZGgPCcmKAoaQhjgq7rgp5cuwqXwkL618J6ApOGgpOqfkVIKMUIvw7jgsYFd8J64sVdm8JCdofCRiLImPEtHJiHitpDvv73CpSRN4L+MOjU8c/CdlK4KB0IFfOC3mlAKDEIK4Y+54b+44bGDPgomQiQn8JCAgvCQrpxc4b+may7wnrix8J+VtCfgqYsm8JCgg0tTIj0KIUIf4baL4LOLPyIl8JCWhGBT8J+VtOG+iy5q8JGctu+suwo8QjrRqOCnl8i6KuC6gWDwn4OxJu+/vfCfm6nIuu+/vVw94YmRcPCSkpvwn6uOKiTDmCXwkI2RJsi6wqBvCh9CHTnwkJKp4LuedMi64LqEKComJybqrK1g0ag9L8OKCh5CHO+tgCR6VT8wZnrwkYyubXxK8J6lg+CzjeGoonQKEkIQLvCfgIfwlqmg8J+hlibCpAozQjF7PfCQkqnCpVPXk2nwkKaT8J+VtCYk4LqCIj8kPOCpjEDRqHtCJy8l4LufKiZv4KiCCh1CG9Go8JGkiS4wNuC7lnU68J+Fp+G/s/CQqL8nJgo2QjRO8J2DhuC4gi8n4KmHTvCQhIFVMyUoIvCdiLzwn6qE6p+Q8JGNl+GimXvwkayH4aS1w4kgCjFCLy7wnoCGTiXgqLYqwqVY0ah5JinwkLqxeSbgsqx2SvCfg4/gtYxJPVrvrIbwn5W0ChFCDynRqOCuiOCqkXtuP0V7TAouQizDn/CfgqPjgJ06LiRkJeGnlGLwkY2yJ9Go4Leb8J6EjWAq4ai2LkvgrIXCswo5Qjc977+976iYJS8mYPCQlq3wnrm08J+fqCFc8JuEsu+/vdaN4b+IZy/gt59c8J65iSfgrpA7KsKlChhCFmvRqDxwKsKlSuqnlD3wkpCeQ0vhsLAKDkIMKOCmtj1oeyMiLz9KCjlCN3LLkeCsiDTwkLqxZOCrkMOPLyom4KewJizgp51g8J65iybCpfCWrZw/8JCznkM9PSYjKlQ5PCQKGUIX8J2XrDfwnbyl8J2SkDoqcOCzsnHit5YKCEIG4r+1VD9BCh9CHfCRtpBK4razWVPvv70uRCQ/77my4K2ncvCRi4QqChxCGuCovzxjJ/CRu7cnbC5OIk5n8Ja/olzqn5dZCi5CLPCeo45w4YmdTfCQqoXCpTp08J65gu+/vU0mKsi64aSNSiZgw4rigpThvZluCgxCCvCfqqw6eirvrZ0KF0IVXConJsKlSlxjY0wldibgqLxgWci6Cj1CO8O2IvCfn7DwnoCU0agyflvIulzhvZt8SO+/vX7hnIXwkJ6n4Z2iUOCpnvCfoJPhs6vgqZ4mP8i6ZipgCgZCBMi6Jj8KJkIk4pGEePCflbTgsZ0h8JG2kN+m4Ki876iXfCUu8J64tfCQnY0lChwKBG5hbWUSFEIS8JC6rfCQoIhFcO+/vUBgzp5KCigKCW5hbWVzcGFjZRIbQhnRqF5i77+9ImJuJfCRnKbCry9twqXwn6KUCmy6AWkKHAoHY29sdW1ucxIRsgEOCgxCCnrwn4K+L14lw6QKOAoEbmFtZRIwQi48ZCY64aq7L+C4ieGLr/CflbRKOtGo6q2SeuCyj8OP8J+gv2Dwn5W0JfCRsoAyCg8KCW5hbWVzcGFjZRICCAQKpBe6AaAXCu4WCgdjb2x1bW5zEuIWsgHeFgo1QjPIulhKLvCQlJDtn6reli4t8JGEvlom6qexIvCeupPwkYu5cfCdkrXwkIqY8JGnodu0w7cKFEISYXnIumwn77+gKvCeuoMiNFtYChFCD0DhoJnjgLjvuasu8J+rgAoEQgJSJgoMQgrwnbyn8JGHq9GoCjdCNS/IuuCunPCQjJLgpq8vSMKu4aiaXOG/s9GoZGA8UM278JCWm+CslWDwkJaJzbs/KkzDqUlyCi1CK2Hwnrm0MCdv8J+VtMObKjp2KlRofTrIumI8yLo94Kqf8J+VtD17ZPCfn7AKB0IF4L+CV2IKIEIe8JCPkC7wkLGCPEdOIsK44K2NRvCfoZTwnrmRcWAuCgxCCvCeuZEm77uK0agKQkJASOqjlnLwkbuv44KZw7Ng77+9JvCQub7gtoxX4Ku/8J+CvFwq762ERMKl8JG0veGogEVvMkXDoHs68JKSr+qjmQowQi5c4LWP4rSn8J65vj03LOCgsS53OGAmRNGo8J2SsvCQq48n8J+VtOGJnD/wn5WPCgpCCD9Xb+CpnCd7ChZCFHvvv73grIMmamDCpfCflbQieMKnCjpCOE/hvZBF8JuFpVc8UiZ7wql677mjwqUq4LKLPe+svCrwnYWK4YCk8JGEovCflbRz4YOHw7Xwn5yuCixCKvCdjIDhpKc/16Ar77+9PeChpF7wkIqbN/Cfop1t4LOIcNaN8JC0s+CuigoEQgJdbAolQiPWjuCkrjsm8K+gmfCxkbMgTlDgtI9zfD/wkYyP77+9X+GwnAoJQgfigo3wkK6ECiZCJDpN4LGv8JGNlzXIuicnL1bwkYSpQHslPSXhj60x77+9OivDsAoaQhhc8J2SpmDRqOCyuO+/vWBgUUx777KMIj8KFEIS6qux8JCqhyUnN+GLhDLwkayGChZCFD0u8J65p+CpnHtvXC4/XPCfoZhVCjJCMPCdl6/wnrqnPuCsoc6bJUXCpfCflbROOD978J65pFx8MPCRiLDwn661PU5C8J6lkgoGQgTwkbSJCghCBvCeoKwnKgokQiJ4PzUq4Kej4KuQKmslXe+7jvCQipLitqThna/qn5Mu4LalCgpCCPCdka3wkKuzChlCFyLwkaeDKvCRhbXwn6Cd8JKBq3tg4Z2yChhCFiZ78JG0uvCfm7glP+K3i0zwnrmUXSYKA0IBeworQingrZ9i4YWaPz3hq4VB4ZyrInvIumB9einqrK0ufu+tsHBT4Ki4LmNYMwogQh7cmeCxhi498JCjtMKs6qeZ77+9wqU6WOGjhMOjw4EKBkIE4LOWaApIQkbwkaSSPfCQgqHvv73wnZKicuCyq/CQo69l8JCousKlJ3LwkayH77+saOGvgVfwkai6wqXvv70p4LuIbyrwkY2QUcO64YmRCgdCBSU+4L29CgdCBSQqdsK7CjJCMHR7LcKl8J6TtPCeuaTjgo1cO/CflbRrNOC2juqsheGjgzngtbzhvq/wn5W04b6vJwofQh3gsqDgs6NYfS7CpeGJmCJg0ajhr6Mn8J2qnnRhXgofQh1DPeCytvCdlL7vtrlg4aGxwqlTb1Lwn5W077mqMAopQicvemAk8Ji0h8OiXMOpQmDCqCJdYGvCpfCflbTwn5W0Ii8i8JCirjoKBUID4oGwCi1CK/CvpLdwXOCvl+GypvCWrKvwnrmXw4ZCIj8/RVPgoZB0X++/vUMmL/CRjIEKDEIK77+94Z2v8Ji0ggoKQghQb/CcvJA8YAodQhs9XSc7afCWo5xYdDxLJPCRjZDIuuK2svCeuZQKGUIXJD8i8JCiiyVYOFxQ0ajgvqDhpZ7CpSsKAkIACg5CDFoqL+K5m+GqsyhgPQoRQg/wn6yZ8JuEsvCfq4XgqIMKAkIACi9CLSLwlr+kL+ChlPCflbQkPGjwrJO7KvCQo6fqo5gq77+9KiLwqqyDJvCflbQlQgoaQhhb76y7ZPCeuZ8meuGPo/CRjIA977+9IkkKK0Ip8JCBgVdGwqUt4Ka2XGMk8JGypD/vubEnPiLwmr+zdPCRgo1j4bmIzbwKE0IR8JCwg/CflbRyyLohZiYkYCcKJEIiLvCQurHwlquJLydmLi9g77+94LqlIjl+8Ja6gUtG8JOKrAo1QjPgtYbgp4fwn6qH4bOV8JCetTzwn66p8JGCoWRY8J6AgfCRm4Nc8JG0iCrgr5d98J2qnSIKMUIvLjp3J++/qtq14LOHLT1FQSbtn4/wnoCg8JGDtjjjhKLwnZam4b2d4b2lNuGKjEIKRUJDbzo8wqVPJXvwnZCr4r+64K2M8JCWlD9gPOCwjsi68J65kVnwn6qV4L+JdDXjhK7wkKmAI/CRgr/wkLqK4aqnJWA/IAogQh7wn5W077+9ImLRqO+5hPCflbRgIvCdlIDwn4e0LmoKBkIEOC50MQoDQgEkChRCEic44reBYCXguY/gspklfsKlJAorQinwnqWYXDlA8J+uoyLvv73gsIvitK1a4K6eNPCQqbTwnp+uW0wi8JCGlgohQh9nL1txPTwqeyck8J+fp+GJjS8lwqXqpo/hv5vCuyoiCgdCBXN6J0EhCg5CDCXwqaGoe0V+Ii8uPwo6Qjjqq6skJCw98JCAh33goLfwkJKi8JCdkSXhkZ/wkICT4LGMJvCQi6c/wqPhs6Ij8J+VtC7wkISAfQooQiYq77uPXGDwkZK4dMKgdi7grZxc0ajvv70hw6rCpS4m8JGQlWDRqApCQkDvv4PDifCQsqnwm4CN4KC+Kj9gSsO+8J6jli7Iuu+/vW/gtI7wn4mQ4KqQYD1s8JGbgylMLyXIuu+/vfCeuYdFChVCE8Kl8JCTpfCeuLngr4oiJ/CRjIAKHUIb4K6S8JCpiDrCpeCxneG/tC3gq4kl4LCgZCRSCh1CG+Cyt8i6YCA60ajjgY3wkbaQVj3hv5d74KWeYAoLQgk6POCug/CrnqUKB0IFL/Cfnb4KNkI00ajwkZ2Dflwv8J+igGci17Rm8JGguGfwnqCmPzhLUC/wnZWDRT8lyLol4KavfH0vYOqcmwonQiVreCEqLO+/vWAqwqVhXT5oIPCQrbs98J64u/CQq6Dig5fwn5W0Cj1CO28mw7d68JCUpV/wn5W0XvCflbQ7Lu+/lXsuJOCouGB7PDvgprDqp73wl7+3Sj/gppB24K2dTX7wn4iyChJCEHFcJH3wkbS68J+VtC7gr4sKJkIkL+GDh1rgr5BU8J+VtDR+KV4v8JORiVzwnri5LypC8JGKqCY6Ci9CLfCRh6h38J6fqsKl8J64oipgWibwkYu5PzzwkYyGMeqqmsKlKvCflbRA4LWxPAoqQijgrprgrLXCpeC3nFtJ4LCPJ+CokOCmsuGKuiLDpvCWuYU/wqXwm4WSCklCRy9hIvCdqp/goajwk5GM4aqXSeKjmktJ6qyFZ33wkKS/8J65l/CWrZsnP1zvv73hqbg94LGK4q6BJDzwkKKsdfCfnZDwn5W0Ci1CK/CehLLgp5/Xom3horfDqMKl8JC6reK0rSomJOCtnWlg8J+VtPCQoLzIuicKF0IV8JCol8i6W+GbrvCQvohaJCQv4LuGCgxCCl4kL8Kl4LG8Kz0KPEI6SybwkKS/XDxiYHvgqqLhvr1XJvCfh7A9M8Kl8JCtnzc/8JCtqcO2SCYlyLpK8Ja+gOCutX4uO+CwgAoWQhQlOlzCpci6Ne+5hV0hXFZv8JGyrAotQivCt1zwnYuPITbgrZzit4A/KHIx6qOQa/CflbQp0ah7w4zhpbQqKvCeu7A6CgJCAAoFQgPgqLUKCkIIYO+/vcK7IjsKP0I9PfCQqI9g8J+CtibwkJWv8JGIkXvDgO+/vS9ybPCQgLEiOlzgtbrwkKmWw4gmyLrgtr13PSXwn5W08JCorgocCgRuYW1lEhRCEtGo4Kiz8JGTmT/wkbWlPyTDjgoPCgluYW1lc3BhY2USAggECoQdugGAHQr2GwoHY29sdW1ucxLqG7IB5hsKRkJEPPCRkpvwkbCAJuCos/CQnoMsMFxLKvCeuZJc4aCTJ+GLkPCbsp8nwqXDtcO08JGQqPCbhZE08Jijmy7wnYK18J2dkCcKCUIH44O4XOK1sAoaQhjwn6GYb1HwlquC8JGQnVngqKV7Ly5cOlQKBEICLycKL0ItXCLwnp+oU3zwkYOzXPCbsoHwn5W08JGNs8i64K624YmcJzzgspbgprJI77+9ChRCEip7XmfgraPqp5M48JGcjeCmhQoSQhBAeO2ft3vgqJDvv70477mDCjJCMEw8Q8KiPPCQuqt+77+977+96pSPImBGyLomJ/CeuLtGLyomZXs94KiB0ajgtIJkPQpJQkfwnqOP44exPC3wkKO1Lm3RqOG+uOG+uT7gqLzwkIqbOOK6vTRxSuChoic68JC0sOGfqOCwolFZ4Kuhd+CssirwnriC8J65tQojQiHwkJK7KeKBtPCQq7bvv73wkKyF4LuGSVPwnoqtIvCflbQKC0IJJ+CvgU/wkIC9CkBCPuCqlS1s8JCohTd78J+rpe+sgk7vv73wkYePeeC7hj0iaHA8XPCQrIrwn6mkyLrbtu+/vWDhs4fgqI/vv71+ChJCEEzbv++/vWPwm4SyIuCqsi8KI0IhRVwq8JGoqeG/uvCQja9vJsOcJiTwn6u3Pypy4LmYTy43CgdCBfCQpL9BCjtCOVdc8JCnnyBfJjbwn5W0yLrDrT3vv71fSPCRpZPwn5W0JOChsG1g8JOHmPCeuarwnrmb8J+VtOCvgAokQiLwnqWf8J+VtCfwnoCm8J64ufCbhZXwnp+q4LuOIjPwk4y+CipCKDwm8JGco+C4llJAWT0/PfCbsoEkMeCnjsKlOnQnWPCRpIXgv4TgrL4KDUILJSLqnpYp4K+3JSQKGUIXTSVg8JGRjPCRtpQqK1MuJi7wkJa1OicKCkIIJvCflbTvrLwKQkJA4Yq16qqj8J+gtkFP8J64iOqSmWQuw7rwn4O144CfdOGupk/qqKon4K2dWXvgrpxI4LeWbicpLvCdlLvvv70ubgouQixU1Yx58JGNofCRgafwnoWOOvCeuKTDmPCQm6TRqOC3tGrRqCbwkbSJ3IR4YwpEQkJ90ajvqLY/8JGiqdGo8JCEgD0kKvCWro/wkYOiPMOE8JCzrvCQs7IuJfCXnIthavCQlqs/8J6gsyXwkKCIQi7vv70KJUIj8JGAp1wg8JGcqmkl77+lJlzitZ/grZbOh+G/m1MiYPCQkbEKCUIHRGclYeGqhgo3QjVv6qy18JCuqeCmieGKtW7wkbWYP31fw5vwn4K04K2VUlM0Jk0vZSTgr4bqp74mJ+GmuM6GOwoMQgpg6qGzJeGIljonCjFCL/CQqIbgtpvitqpFTi7wnZWGPPCdkrnwlq2u8JGovXvjga898J+JkeC1i2DhsYJvChNCEVXvvL3wkYqV8J2Lre+/vcOTCitCKU178J65sEYnPfCRjLPwq5GNe3TvvrJ8OmPwnZSO8Jy9gzzwk4yE4Ke8CiNCIfCRg7nhrow/KFxu8Jq/un3gqJDRqC4o8J+VtCp6TeCqsgo3QjVCJVTgpqtMwqY9WCXgqoHwnZGCRu+/veG/hClcal7Iuirwnrmbe+CulH7vv70z4LKP4YupTwo2QjTwnrSdSV7gt7RUScKlXEwjJ/Ceuafwlq2f7Z+gaC7wkKGNJ2zgu4bgt5hN4KCE6q2y4aqTCj1CO/CQh7HwkbWBXEDDpUBEXjrwkIqF8JuFpPCfq6AkfnrIuj3vv73graHRqO+4uuG9jfCeuZIlIj3wn4CeCgdCBT3wnZKICj1CO2siJz/ita9gbSdGSfCdjbJm4b69YPCQqYNM8J+VtFPCpXdR8JGFlyVaNHvgvrJ54LKQ8JeelNGo4bGRCjFCL/CRjItoMUnwnrmU7JS08J+bvPCRrIN70ajwkbaY8J64t/CRnKbvv7068JG0lmAvCiZCJDov4KyQLeGfoSQpYMKl4reB4LeW8JGEqmTCpS9I4rqRcOCtnQojQiHwkKSa8JCTnuCqm15MJ/CeubrCpfCQpKvwkYK1Tm4ke3MKI0Ih4LOyKvCdjbU6bPCQnaFIXHzRqPCflbQ6YfCRmosuP0R0Cg5CDPCXgL8m8JG2kcKlUgoLQgkqRj3grqPgoaYKQUI/KuGftvCQq5rwkban8JC/hOCxgtGoOlLhn7NrNci6JmzwnqWf8J2VkGThoJctPOCulSfvv70/8JGNq1d04aWACjhCNmDwkbGqaSJN8JGArk/Cqi7RqFxBK/CfoqMzYD/wnqWQL3sp4L+Z8JCKribRqD098J2MriY9cAozQjFqPdGo8J+VtDrIuiLvv73gr4Y88J2VgPCflbTitrbwlqmkQ+OFqDskI1zRqD80yLoqCgVCA9GoXQoIQgZW77+9JlYKNkI0KtGo8JCdoOK2pdGoSnouK1wv8JOMhOGKhfCeuLQwL1HCoHvwkJSD4KeA8J+VtFwk4riHPgpFQkPvrYHhpZ3grK/wnruwXGcmPz5c8J6Ei0wtNfCQkqPIuuG+nuC6unHhgbUsJfCSkZAhTOCrkM2+8JCzgGDCpfCQoq5hChBCDjXwkYyQ4L+U6qitPXsiCipCKC9RInvgprJ74LCeJuGdslfvv73ivowuKj3wnrmRImLwkKur8JC6g2AKAkIACkZCRCrjg47wn4KpJ2BlJfCRgrhs77+9OdiG8JuEsuCumiZSLvCQoLzgrpLitKdx8J2btlPhn4/wn5u7SOGdsuqpg0jwn5W0CjVCM1jDsHTRqOC0kD8kJ1rIuntq6p+WMSYwWeGrjfCen67vv73vv706J/CdgbzwkK6c8JGEnQo+QjzhpYDCoC7wn5W04KmqPy/wlqybJfCQh7FnPPCSkJvgqLzwkYyw4LaNwrZJ8J6FjvCWv7FTInbwkJKlPC8KA0IBQApDQkE6KvCdvKk/8KuFgT9nwqp7JuGtmeGfiXFEJvCbspXwnqWTPTzwm4qKe1x88J6FidGo8JGqieC/klTgrZclTu+slApCQkB74ra7Ve+/vcKp8J65ovCehY43bfCRsql5w6fiurg9J8KlJ1/IuvCQpIXgoaQ88JGcoeCquTpcImbgq4si4KC4ChpCGPCSkbQvyLrwnrqRQ17WpUZ7IuCmsuC3mQolQiMiTOGaufCbspPwn4i3JmZANX0k8J6ApPCQnaIk4LGMyLo6ZQotQisnPTxhPPCRtYLvv4zvv73wm4O84K6f4LqlRPCQjrXIunzvv73qqYBHPz1lChNCEeqsplg/eOCytsOU4oKT77+9CjNCMfCQjZ/wlq2k4LGvP/CRtIHwm4WkXkQ/e0bwn66XwrLwn5W0fibgsa/wnriV8JCouXsKNUIz8JGAruK+pzrgu5dKazIlJfCQoLdcyLrIuvCQtIAx8Ja/ozpHPNeQ8JCdj+K2q++/vSsqCjBCLi3Dvy8m8J+VtPCflbQ94YuWLz3gtqhEYCRtJl3wnbyF4oKV8JapnPCWv6ThvYkKCEIGNlxPLtGoCgtCCXtc4aS4KuC3lgooQiZ8J0dEaj/groUv8JGBsS/wkKmHesi64KaKJk3vv70ycSDwn5W0KgogQh4u1pMnXPCdlJYk8J6ygi5K8J+Cuu+/vUpgacKlLmwKGUIXJD3DhFMmXC970ajDlvCfh7pE8J+VtGAKKEImR9GoROGdivCbiblvTiU98J67se+/vT/wnZWPwqZMePCRi5U9PToKKUInIu+ng/CflbTwnrmJwqXwkY2X4Kay8J65tuK6h/CeubfCpeGLkCIqCiFCH+G9nSfwkaShePCdvKrwkJaVIvCfgq0mLi43N/CQjrwKLEIqXCQ/6qyG0agvLuCqoGDDtio88JCkv/Ceubld77+9IuCwjuCop/CQnoNcCi1CK8Kj4oGw4aWx4La98J2VhibwkJ61JPCWrZx24aKe4L+H8JCugfCflbRQ0agKKkIo8JChiOKBsC/gt5Elw47wnrmdKvCeuKHvvZfgs5V68J6EkT8v8J2SvgoNQgtL77q74aq48J6khwoNQgsvVi5BIvCQoaZSRgpFQkPwkKiNwrnqoLlxMeC1ilLgs4vhorPvv73wkYen4KGQP+Gnp9Go8J2VgSTgtoE8XDp94K2MP3zqn5jwkaq98J+VtMKlCihCJuqjlFzwkKCIJS50Oy8n4oGwP/CeuZQqLi8+JvCcvpThvZ3gp5cgCjVCM/CRlpnwkY2B4K2ERDo98J+VtOGNgvCXqojgqYwm8JG0piN58J+VtO+/vUAvc+GjgGfCpQpGQkTguZRU8JGDuGImJ+CouDQnXHsl8J64geC6pci676Wv8J6TkDUqJOqfkCfwn5W08J64ufCegYxc4aWA8JGMp1cz4by9PwomQiTqqZHCpeG9nToub+GglfCRi7Two66F4KiP8JCjv2rvrYBPw7kKBEICZ3QKPUI78J6jkXzwlqyRPeC6hEnwkIusJzo9TPCRqKDhib9TO8Kl8J+VtE5e8J65n/CQi7AkYPCQpITwkI6YJj4KPUI78JG8tPCfg6tB4aWzYD94eeC1h/CdkqUnKiLvv70iYeqskci64aSqJSbwn5W08J+ioVwuPfCflbTjhYgKQ0JB8JGHhHt5ZPCRgaBgL0/wkbGR8J+VtDUlz5NxQ+K0p+GymdGo8J+Cq8Kx8J+VtOGMoPCfnJw6ZCzwkKmS8J6ApzIKH0IdK8KlJU084Yq5Ry4v8JGmvjrhqa5bJmXwkbGZOzoKOgoEbmFtZRIyQjDwkYO54LygJD8mwrrgoZ4kOi4k8JG+sD0s8JCWnDwm4La9Qzzhjpc68JG2oCo/MycKSQoJbmFtZXNwYWNlEjxCOvCRgZgkcMi6a2vDvSdeP/CflbQv8J65tvCeub5VIvCRtpU677ihS/CQo7VcwqU6OibwsaCg8JGkt0MKzxa6AcsWCpgWCgdjb2x1bW5zEowWsgGIFgoZQhc88JCnivCflbRi8JiAjS5Nalwk8JGTmQoGQgRh4K+ICilCJ/CRu6kiKi56LOKDoeGDh8KlyLp48JGwjW7wkISB4LWWJ1ol8JGdhgo3QjXwkbSPJDpcPPCRnJVsTPCRip00w6pnXeC1lCrivqTgp5/wn4KpLn5p4KeH8JGIimBc4LOWMAobQhldIfCQub0sJvCRkZ1fYOGdq++/vdiPIn4kCixCKjp3J/CShZp7XPCWuo7IuvCRhL3hoIZ7wrjRqMOP8J+AkiDgqLNd8JG8kAoNQgvwkaeabWVnJtGoUAozQjHCpTgkfeqUru+/vT9Ue/CRsaM8e/CflbQl77mBJuCpkSdAYPCeuYItYPCQrpFFPVR8CjpCOPCQoIjIul0vL+CmimDwkbWlISzCpcOyScKlwqXgr5BaLz9eXDEl4K+G76yD8JSSqNGo8JCeicOyCgtCCXMm8Ja/o9Gocgo8QjoiWW/DlvCWvZHCpeGlqGBpYFxCOio98J6FhPCRtYVo4K2A8J6lmVRgyLot8JGNq3sm8JCsvzUkw70mCiNCIWbwnLyF0ajwnrqF8J+VtDou8J64uX3CpfCyi7Yi4oKcPQoqQijwkLKU8JGGlPCRtIHDhUwl8JCekfCRo79RYuCrkFxKJfCQlpLwnrmyChJCEOCysljwlq2gJj8zXOqfkFUKA0IBSgozQjHgrpzwkYi58J6TtHt+bvCepZ8vwrjIuiHwkJahIfCRv6kmZS9Oe+Cth0zgu4YvYGAkCilCJ+CslSVG8J6EniUlKSbgpq7grpxU4rStyLom4aycbeCvkO+/vU0qbgo4QjZT4K6JwqRd4LCIP+GKiuOAi3sk8JG2kzw98J6fteCqrjA3L/CRjY3wnZOO77+98JCumfCQgIsKJEIi8J65lOCzpvCQlL/hhLgx4LCOYC/hnKI9O/CQi4DvrINNJgorQinwkKeDdfCRjLPwlr+wPS4/8J+IoC/CpV/itKfwlJKT8J65pGBc4LOxcwoLQgk/cMKlJy59LiUKL0It0ajwnrqabCoiwqUxJmo18J6ysfCdg7Mm4LaBPe+shiBZ8JGNsCXwn5W0Pci6ChNCETgg4YmM4Z2ySnMqPzxc4LuGChBCDjzwnoWF8J66sntB4b2dChxCGiQl4Y+48JGWluGDh/CRgLZ4cvCWvIrwn4aoCiNCIS7vv70i8JarsCRvUSQ68J65mdGow73wnrquw5dBPyzRqAodQhvgobvqrLwv4L+DXybwkKeiLntl4YuFSXzgsKUKEUIP8JGoquC/lCpJKjzvvoppCihCJsKkJfCWqaHwnrqB4YumeOCsj8i6JOCyjkDqraTwkKCI8J6fpTolCkBCPvCRpIk98J66hyVyJSco8JColeC2gsKlJOGLgO+4rXIvJ+C7nvCcvI8+PuCxu1tT4Kai4reefvCQrJfgvr5zChVCE24qe/CRgqoq4KeN4KWCJSrqpIUKHEIafXtgKsOaLWN78JuAil9yXC5GOuqsi/CQlJUKAkIACipCKMi64Z2y77W08J2Nruqnl0oow4TitJvCsPCYtIHwkZKI8J6Fj8KlZioKMEIuPy7vv71c6qemWOCuqSQi4buzcy7hi4A68Jq/seOAuy4kPGXwkaSWMT/wnqOLYAomQiQr77+9PPCeuIPwkIKpSlZK8Ja5juCsssKl4rWv0agn8J+isUMKEUIPPCfwn5W08JCwiPCdkJVgChhCFvCQkqQvedGoYOC6mT1j8J28l1/gtJUKDkIMwrR5YGc6IvCQjZB6CgNCASYKGkIY77+9euK0rULgt4oi8JCygVXwlq214LqlCgpCCPCflbTwkayDCjlCNz3wkoWi8J6fric94KmR8JC8iiJi4Z2McuKBvzp78J28glwuJfCdg64mIEvwkamXPWto77+9ZSoKK0IpOjzhp7DgqrPqo5LwkaCBMVXIum0oJfCRg7TwnrmkwqUu4KGUwqXgprcKJ0IlOtGowqXqp61sPFPCvT4lTvCQq4nwnZSPJFXwkbGbJzFUJMK4JwoqQigr8J+bt+GLjnHvv71leOCqt/CYrqpca/CRtIQl8J+rtPCav7NgJlt3CjZCNO+/veK7qyTwkaS4RzXgrYfgsZ1zbCRQJEbwnoSUTnh777yG8JCklz3hnqYqPCQ98J+VtCgKH0Id4KiyL3RH6qCOSCLwkL+IXOCkq/CflbTqk4Dhm5gKEEIO77+DKu+/vOCqt/CSkIwKJEIi4b+y8JCAofCeipXwn5W0TfCflbQ976qIJTAm77+9euC2kwoMQgrwn5W0VlrwkKaKCjNCMTY6fTEnwqXvv71Mw53wkKuc8J2Rp8OP8JaqgCZRe+GJkOqfkzUvPTXhi6kiTPCQrKAKHkIc8J+VtFknWTNjYO+/vcOJPzzDrsi6Lk3wkJ2hJQohQh89Q+CqgWnwn5W08JCiqPCfrqA9ZXs1YPCQiok9eHNgCg1CCzog8J+VtCcnRD0hCipCKOGLgGDwn5W0PU1FJC/Dhz0nwqVp1rLvrLjhpYDwkIC8Yci6JvCfgI4KL0Ite/Csra084rWU8JarsOCpnk3OjPCTi7knw7rwkLSULyrwkKCI4aSoJ0fwnou2CjFCL2Al4LCQb/CdhZAkIsKxw5cudF4kJDgl0agkL+K/k+CnvS86Q/CRq4giIvCQtJdVCitCKT3wkYyDOio6OnthSPCRg4Fz0ag/6qWTYCRg8J2IkFzgrqnqqYM977W6CjZCNOCyp9GoQvCQqZFuLu+/vXdzL/CRu6vitrgi8LCzsD/hjpd0JtepJ2NP8J+VtNGoLnvgrpMKKEImd/CRg7Rg8J+VtCgvNlzgroklXC7wkbCU8J64riZK8JORguqsqicKBEICJ3oKMUIv4Z+nXz3grLbwkYSUO1zwkJSG762D8JGmq/CRjafgs5488J65r+C7k+KAh/CRhJgKO0I5KWVgZPCbspA98J+VtGTwn6G44KmpJ/CWrokkIi5Q77+98JGIjGA/aEDvv73wn5W0Jtad4LOW77+9CiNCISUy8JODtPCav77gqIMuXGI+4Leswr09dF970ajhv7nIugozQjEq4bGH8JGNgvCfr7LwnZS94LOI4LGG0ajwkJOmJ1QiRvCflbTqn5jwlqy144ead8i6Cg1CC1068J+CvyYk6qyDCh5CHD3gp7LwnrKr76yWJsKlbGDDqvCdlJt74bK0XDoKPEI6JW3Dqi/wkKSlKvCQv6LRqC/wn6Gw8JGHgTPwnZWPPS7wnoCeLjkxw7x+KvCflbQkJSp+ezwjPOGLgAoiQiDwkJyAbci6yLovOipUKuqflz08SS/wnriC4YyS4b2NXgoaQhjRqPCQkrMv4Z2NaU/wkKGFL3RgLvCQnrcKDEIK4LK1TCR88J66sgo4QjbwkKC88J6KlC7vrL5zJCbwkKKryLrgrZbwnrmt8JGNjWDwkayA0ajwnbypXuK7r/CdkqsuPHsKDkIMLvCflbTRqC/wlJKCCkBCPjXIuuCokFxc8JG2lPCfqoM/Ksi6ZOCuj/CepZ9w8JCdgyY/4Zas8JCipzrwn5W0V/CfnK8m8J+VtPCen6siCiBCHvCeiqcn8J6AnfCen6FcKeCyj8KlUWAn8JatnXJJLwoJQgfwkaioKMKlChNCESLit5jwlquqwqUi8J+CuilJCgdCBT3wsY2WCj9CPfCrnqPvv71M8JuyhGouQvCflbRl4Ly1ffCfpIbgspjgqKvRqOCth8Kl77+91YLhvZ3wn66owqXwn5W0JGAKHQoEbmFtZRIVQhPwnrm+8J+VtDJtYG/hupnwn5W0Cg8KCW5hbWVzcGFjZRICCAQK6xK6AecSCrYSCgdjb2x1bW5zEqoSsgGmEgo5QjfwkaujPfCbsarCpTzwkIaTYCbwnoKPKvCQqJYlJeK0sT/wkYq34KuH8JC0tCbwkIC68JGZkk0mCjZCNCQnYPCQoIg6KnAv8JGnneGxhlwnYPCdjZVz77+98JuEsibgppDIuiTvrL4mXO+/vUfRqCUKOEI2J/CRpZcjIuG8pTrwm4WmXSLwnLySOsKr4Y6V4reC8JCKiVwvbmDwkbKIaiolP/CRsKHvv71cCghCBuCuqOqsgwohQh87P8i68JG9lfCQs5Xwnrqa4raCL0A4KUokPDvwmr+9Ci1CK+Cth3vwnqOS8JGMgu+5qD88P+Cmmeqoj/CQnaYv4Z+m8JGgk34uceCxnVQKCEIGXEHwkY2wCiJCIMOyNMi68J+qh/Cdkr91M+Gogj/wkaSO4aOB0ah7Mi4/CkRCQjDwn5W0VPCfm7Nw8J6Esn1P4YuQyLrwkJ6PYCIkL/Ceub7wkLC18JCpkyhL4reTSGs68JCkh/CQq7QsOj8n8JagowobQhkm8JK/ni4vNPCRpIlLMPCQq7HwlqmR4KmcCgxCCms8wqXgsIjvrJMKF0IV8Juwgj8977mqJtGo8J+VtPCRjah8CgNCASwKNUIzL07wnp+j8JGwtnQlLibwn5W0JuC6nkrwkZip8JKOjVFyLi7qrKI68J2Lru+tgSjDrnskChlCFyYqwqVjyLo6QSRZJtGoKuGftyd2JGknCkpCSCoiUvCQqYDwkYqfIvCQjpFS4K+IyLrwn4KiJy9ALirqoZ7wnrmJ8J2QoC9g8J6kh1zwnoChXO+/vfCQgLUn8J+AtD3wnZWPOgozQjE6yLp7PGovw6c64Kq2Lj1sZH3wn4mQdkMq8J28mSIlJGTitK0uXCI/Vkrwnrmk4Ki+ChxCGnsk4KuAJ28wR+C/mvCWrZ174reWJ/CrnrguCjRCMsOVP2DgsZbwkY2CwqU04K+6TvCSkbMuP/CepZ/wkbW6P+Ggp8O6S++5s/CWrZjwnrmqCgVCA+CqqgobQhld8JGapcKlIuKAgyxt8J+uviZA4Y6DyLpjCjlCNz3gso7wkKGqyLp1KvCWv6An8J6KrivwnoCDeEThlJgnJGrgrqThv4LwkaSJIvCRpIlfU2A6YGAKIUIf8J+bokJ7XOGmhfCtl6MvUvCQrotXw4MuQDwvceK0rQo4QjYhazxk8JGMsvCRjIPwkKmWeCYkKCtq8J+tiPCRspjwlr+xN+K2uCd7eyXhsJzgobg88JuImnAKMUIv8JCegFnCpcO78J2QteCsoULguopc8JGKoCBDIicuYvCWroNM4Ky98JC6sS5iJSAKKkIo4pGA77+V8Ja9j0l7YeCointVJvCQi6Uu44ew4LWP8JCPkeChqXkuRAoqQihwYCo6wqw/LyrRqOCmquCsqiYi8J+VtPCeuY/wkbKtPC97Ly/CoCRhCjBCLi7wnL2T8JG1lsi6L++2lPCRjIPCrs6M77+90ajqqYB78Juwh+C6hPCrn5bvv70KNEIy8J65gjrwkbak8JGdgUXCpeCrvci68JatoOCqj/CQgYx1cjpRYC5o4rWw76yVYGDDoycKH0IdfVZh77+9JPCWq7PIusOWPSfqnrE6JyrwkaSCNmUKCEIGIVw/Jz8lChhCFlzwnrmZdOC1ijZgyLoqIXMuP/CdvIQKH0IdcC81OTrwn5ucOzvXtG9C77mK0aVT8J+VtOCumS8KSEJG77+98J+VtCrwkJ2La++/vVFgZvCdkqLwmLSG4oKn4K+MKi/wnrmHe/CWqafgtr3wnaqcb/CQp67wn5W0KS5bcvCego8/cQo0QjLCpcK14KmZzbvwkZykYFt7LiLCpSTvv71BJsKlXy9qTlVaPO+/vSYle/CWvphhZ+CxjAovQi3qn5Mq0ahVw63hp7VHw4EzLid0QtGoJeCun1Anw5UqWe+qmeCmq1liJfCQqKsKKUIn4KOS4YmYRMKu0ajqp7XwkJaX8J65oUbCpSciTMKl6qax8J2IvFgkCh1CG/CRta5ZLdaNbOCokC/wkYO24aSrK23wkLSdPQpEQkJF4b+A4LWIRWBS8J2etvCfooTIusOFR/CRqLcmPX5c8J+VtD/wkYS7bHDwr6Ge8J6ko3o94KG377+94a++6quiLjoKMUIvyLrwkaS1X+qsqfCflbTwn5W08JC0lsKle9Gow47wkKOjP/CflbQlJjcifPCfqYUKG0IZMmjwnoCkJ8i68J+qgzxacc6Hb1zwkZi6KgodQhs66qeWPC57PGTwlr+x4LeK77+pJVNI8J2SriUKCkII8JCPkizgrbcKBUIDOl0+CitCKS7wnYiR4KqH8J+VtCc/4LSOJeCumvCflbQi8J6ApFZYVMOM8KifgdGoCh9CHci60ahIJiJww7hcKion4am8w67gp5fwkKiWTDwiCitCKTJn8JGHreGgjCIo8J+qhkBqw7I/YO+/jfCen70t6qeQw5fCpXvRqC8qCgdCBfCflbRvChZCFNiR4Kyzw4A9MCRabvCeuqXwkaSbCjBCLvCflpLIuvCbsbHqqYXwkJaUPfCQoZ55KvCQoLzwkKCIP1cvSy44J01ge2lacS8KH0IdKPCQlI3wkYua8J28qPCflbQ/8JGkjVxw8J+bnz8KLUIr4LKtYO+/vfCRsIbwqreX4K6c8J6Fg+CoteCxnTZ4Knvgs5YqJzxqJi9wJAoHQgU98J+rtgoPQg3wkLCsLiJ777+8OCpiCg9CDSZ74YuM8J65mfCQuawKGkIY86CErybwn6GT4aKpefCQoYou4L2U4LqBChtCGdGoJW/IuuCquWdlw7Jp8J+hqMO+8J64tjoKKUInMnV78JCplVXIui4/W21c4ouP0ajwn4aRIifhv7Jxeycv8JatnSUvCiNCIW3wnqS9J++/veCoo1wlPyjgqot4VCVc76mX77+P8J+DgwoLQgnwn6uw8JGStSYKFUIT8Ji0g8OG4a2E8J+VtPCRjZDehQoOQgw+QOGjlMKl8KatlyEKEkIQJOGbnybitL098JuynU49LQoCQgAKO0I5XPCRkZ88LyTDiSXqpaDhv7kiSUnwnrmf4bGG44C0JW98XOCnh2Dqq4HwnqOR4ae9UkZuU/CeuqEmCgRCAiQnChsKBG5hbWUSE0IR0ajgpqbhi4Ak4K+C8J+VtEsKDwoJbmFtZXNwYWNlEgIIBArTELoBzxAKgBAKB2NvbHVtbnMS9A+yAfAPChZCFPCQlqngqrVFavCfiaDvv70iIsi6CiRCInnIuifRqPCfoItmQi9naWgkJy9gPGptYMi66qeS77+9w5cKH0IdOuGlivCdlIhwU1xL4a2y8J+bqSJfNOCvkOCpjSoKDEIK8J2qr27wm7G6PwoOQgzvrIQv4YONJHfvr68KKUInb/CQoLcmL9GoP/CflbRY8J+Qp/CQv7F00ajwnZS4T9GocEFvIlxnCj1COyLvv5zhn7E9KifgsYciXsKlTSrijaDhnI/jiobDouKDkuGugfCtu5suJ0fgqY0pXO+oj++/vUXwnriiCjBCLnsnL+Gdgd6cZPCfhL4mWvCRtInwkY2QT1A94oCj4LuA8JGwgjZU8JGNnWvqq6kKK0Ip8JKJsi9qJPCdkpjwkamiKDwi8JCoq/CflbR88JCWkm7Ok3vwkY2qeD0KCUIHQD090ah7Ngo2QjRV76yT4LOHw7VcVOKPsS4vUzYxLDwuIeCoslzCq1t077+94K64LuqngOC6hPCRpIDvrJQ/ChRCEjsq8J+JhfCRiqjwn56+8JCgrwpFQkPhqaQu4LWN8JaqjibgsJpVU/Cbhafhg43vrJQqJuCtrfCQvYF78J64pFvCpcKl4aaC8JCssknRoOCsoibgsZhyayYkCgJCAAosQiol4b+Y4K2mXDpz0agv8JCkivCepZXwkbWW8J+gi/CQpL8gWeCrgXLDp1MKC0IJw7LwkYKe4b6kCiFCH+CxluCxilZFdk3grLPwkJOBPeCtnU7CpVku8Jq/uk0KJUIjVeCnn/CQnoJc8J2Lg/CvoqbwnZOBJPCRtIV18J66o2DOjCUKAkIACj1CO8OCRkgk0ag98J6KpuCyrmDCpSLwn6CR77+9fV0ne+Gyv+K0rfCbhJjDjTwnXOGClfCRpLcqIm0+wqUiCidCJeGLgC8qJUbwkYup4KerPSImL+GkgDTgrLjwkpGkKiJ04KmHwqUKGkIYPD0977mi762AJ/CRjZB88JCjvvCWq5paCilCJ/CeuIPIujki77+90ahAZnZ1Oj/DrDwqJOCovOGjmm/hqqHwkISNOgoxQi/gsq1b8J+pp9GoL1jIuj8uM2p78JG0s/CflbQnIvCRjZDgs5bwn5W04KqDRzJecQoxQi/hsZ978JCWlHAmOvCcvJIuwqVpbEzwnrmv8JCojSbvpKDqg7zwkYyQ17I8JzRkewoCQgAKFkIUMyJ3JSXhkajwkJapPmA7buKCrzwKNUIzez5V8J+VtEAlPeGyk+K0pzzhg4fwn5+k4YuAJybwkICK0ag7Xy/wn5W08J+rsy7CpcKuChRCEuCqvHnwnp+oZUbwkYuzKn5SXAowQi5744CVKnolyLpc4Kq1PMi6KkU/JDTvuahUaSfwkYGDPDrvtrzwkbS8ez8q6quiCh5CHHk9YHsmVSRI4LOM77+CUThcyLo/JG8u8J65lCkKBUIDP8OjChhCFuqsrfCRpZTCpfCbgKh2JPCRto5SPyYKLEIqeuCmhmDvv73Dgm8kYOK1mCI6YzlFYFzwnaqdYPCeuYJ5Pyc+ceqslcKlChZCFOCumvCRjKYs6q2XR8KlN2B4byx4CghCBiTCt1wkegoIQgbRqMOP0agKKEImPyXgq6rwm4CJKuK6jjR74rSnIHsnJj3hnoJcV/CRjZDRqPCRmYEKC0IJPe+/hmY6wqsjCitCKfCdh555b3ls4KaP4oC58JGyomDhiZhg8J65pCbwkY2gyLo9cTrvv71cCiBCHnBOXFY1KyDgtYYmKuK2s/Cdmqx48J65osOFWVk6SgoWQhTwnYyaUtGo8JCzhyc7yLrwnbyoVwo+QjzwnoCk77+9I+GCqkfguorwkIGLe/CQuqtGXCRKJz0/e0wi77+94aC4JvCRjKE9PPCRjZfwkIu2R+GovSkKN0I1ZilO8J66mfCQrq3qmoc6eyA8XHfWh+Css3szXOqfs8OsPC0m8JCOpfCWrI4n8Ja+j++/vS8KM0IxPeqcq9+hJuqpguCoj/CeuZThibTwkYqiLvCdlK3wkICabycnatGobOCqlTIq8JG+sAomQiQm8J+VtGrwn5W0XOGMszXwkKS/XCXvv708OmJNcFdCJPCeuLsKNkI0yLrwnrmbPCUvKz0w8JCgiDfwnoKPLvCRtag/JiVcYuC6mPCdk6XIuvCeuo8lwqXUn9q4dwoqQig9YPCrnaxG8JCUtUDwlqu0eNGoO8K/YVxYJSkiJSTRqMKl77+9KjkzCh1CG2IqPS5L8JG8k1w/L2d2WVw98J65kS/wn5+mLQoCQgAKIUIf8JCMnfCQiolN77mK8JG1kuCrkHbRqCY88JGKm1knYAoQQg4v4K+BZyfqnJ488JCqhAoGQgQ877+9ChRCEuCuv8i64Leu4ray8JG2p+KBuwo2QjTqn5h7SPCfpojgr5DgrLVTXSHCr/Cfn7DwkpCqMEwvU/CRtpXgpqzwkI2ZX3NMJO+/qydPCh9CHSor8J+VtGDwkYyGwqVcYeqpiD1s8JGNjci6PC8kCixCKuGkquCtnPCfqbYvLibwkY2D4b2dXPCfn6Dgp4jRqFYy8JCjtSfjhLhcNAo7QjnwkJW5T/Cen61tfTovPcOZwqUkwqUuwqxcO1VuTteE8JGwhCdO4KaZ8J+pvPCehIQmyLrwkJOjyLoKHkIcJ1dN8JCWlPCeubQv4aWhSy4kP1YqTDfIuuCxgwo5CgRuYW1lEjFCL1Vg6qaxQcKlTeCwkOCti1vqoKRvJfCTkY8i8J+VtOGKumEh8J+VtMKi8K+kvTs/Cg8KCW5hbWVzcGFjZRICCAQKqBe6AaQXCs4WCgdjb2x1bW5zEsIWsgG+FgoeQhxO4Ki58JCokCLwkJW38LC5qPCdqq7gq6HwkKeOCiRCIu+su/CdlJnwkK24NEt344GN8J+HrF1ge0YqKu+pk+GKu3YKLkIs4rqE8J+VtPCWv6Ai4LKtXTZZYC/wnrmnPDA8L/CWq7Dvv7094ZuCc1XvtrMKMEIuJzVgJ03jg5V7Pzwn0ajwkIuNQ34n8JCRlWQ4fO+/vUnwro6+fuCnteCojyXRqApBQj8/TeCqtfCehJXwn6CURe+/nH1n8J2Li9GoPOCghyIm8Ja/sOCuqWU9JiJG8JGZoSIvYHjwn5W08JCGgHbgqZEKQkJAJz4k8JCTkGvwkJOJ8J64uy5JaypiVj89Tsi68J2Sn/CQv6bwkYO3a/CfoIXwnrmibzZp4Z2g8JKNjci6IG7DlwpHQkXIujrwnL2x8JCZpvCRpZLvv73wnZWuL+GMlOCxnWvwrqyS8KuftifgoaXvrL5cKy8u4Y26Tj93aPCSkbLCpcKl8JGMgiYKFEISXCLwkbSDPy7soqRV7Z+zOMONCiNCIT96RfCdmJZv4Yma0ajgt5gmwqXCpdGo4rKfPO+/qnrCpQoQQg7qo45cJVxS8J28p+C5iwodQhs6yLrhsaJ7YSV+8JCGoNGo4LCo4aSLYPCRg7AKN0I1J++3j/CRhYQr8JGooPCQioLvv70vTO+/vfCdjbdaXPCav7rvuaTDreComdGozoREw7o/wqUKGEIWwqLRqPCRvI5VP/CQoLAn77+G8JK/kwoPQg1x4ZyJd1zgorvwnrmfCh1CGydgPVla77+9JPCdi4Q6XvCQvLBgQOqfuOGEuAo+Qjx7Omrwn6ulyLrwkaSTwqXgtoLDv/CRmoPgsIlN4KuHS9GoRSZo77+9YuODlPCehKDCoCdgJeCtgvCeu7EKOEI28JGNgjrwkJaUwqU6JvCeuqHwkLy63aYvckJxXu+snVHIutGoJlvwn5u2KuKOkiUqccK2IiZcChlCFyku8JuFlfCfgqBg8JGwpPCQlILwkKCACgJCAAo1QjNZyLp5M/CQgLxyZnhuRSLgvosvNvCeuqngqLZ7NCPvuJLwn5W0eS7hj7g/0ahC8J6jglwKJ0IlJlVC8J+doC7gv4bwnrmHJFPwn5W08J64oTwm0ajgrp8i77mMYAoFQgNLJy0KOUI3361v4K2sXPCdn4HwnLy9VHjwkbKrYH17c+OEiPCeuY3wkYmBXCd78J6jkCJ13ZHzoIS4PWIkeQoxQi/gtozvv712Om8q4LqlwqV+6qCPPXXhqpbgtrfCpfCRvI9gRToqLvCflbTRqOCumQopQic9JeOEp1zwn6uFLjjvrYRg8J6Lv+qelTAqZT9PNTwkPyo5IlXir7YKOEI24KmNd0BrOjo4eigvTMi6OMKl77+94LqBOvCforHwkJaveyRgb+C7gPCflbTwn5W0SFQ84pGGCgRCAiJACjdCNXvwnrmHejQ0IuC1lD09Yu+3jyYk6parOkzgv5rvv7018JG0vG8lamDwnqON8JCanHxxLichCgxCCiTgs6M94KuQPWYKIUIfQWVcPV094b2bP/CeuZku8JC0seC0hFw/8JGshWY6cwo2QjRr8J6yr2Dvv70l4Yq5JOK1rybwnoSJLvCfqbrvv717e3t88JC5plzwn66U8Ja/oeC6kyYkCjpCOMOa4LOzfvCbhZHhopBc8JuykPCbhZEn77+98JC+gMOE4K6S8J2SrHslOu+/vVzhvKk+fHLhna4qCiZCJEvwkI6/4Kej8JGNp0TRqEngtqvwnoCY8J65vD06Oj/Cq++umQo8QjrhiZjgqJDgurwn4LyLReGJmPCfq4Q6aX7hqpDwkKGBJPCRsLtcJzLhu4fwkZmmL+GwvC4v16/DoCU/CkhCRu+/vWzgqYzZqWnwnrKsIuC/g8OZPmPhirxcJS7wnrinXPCRhobwn5+hOMOO8JC8mfCQqJwn8J64guCsgfCeuZ90LtGoLmMKGUIXOkzqoKJ3J+C3imcuRiTwkY2IJCF7fjAKDUILP/CegJfDieGnuyYKQEI+U/CRtpDigoTCujzwn5W04K+Q8J65i2I7e++/rTzwkI+P8J6AqC7wkL+EXPCego8i0ajCpCoqXNGoO/CRmZUKMUIvwqXIuvCfgKXDqz/grofCpT978J+FiSJDJTXwkYOZ8J+VtMOr4ae/RTbvv70iw7QKDEIK4Ly5e+GlgOqpjQoqQihU4KqFTPCRjJgvItGo8JGmpsOZSPCRjI8v4ra9KvCflbRAaXzhpZVnChdCFSZJISrwn6mtc+qvt0NQfFwi8JCuqwoSQhDwlqyqWD0l8JGkifCQlrMlCjxCOj3vv73wnZSyPSjqrYDitKfwnrmXT0d+P3FtPDzwkaalNvCRjZcqL2Qn77ePckzIuu+/vSYh8JCuhHsKBUIDJSQkCkNCQeCohyd5KvCfnop8POGpifCdkqstZi5cfXPwkbSxyLpGPeqflvCRtZPwkI+PbFbwkZyeOuK3gPCflbQm8J+rpyciCiFCHy4kXOCokPCbhZDRqPCRpJM9w57wn5W08JG1vT8gXCQKM0Ix8J+CtTE94KGkwqXDhyI9YCLgs6Fg4rWN8JColj9cZVzwn5W08J64uyhdzbrhvZNbPQobQhkka2/wkb+J4KGe8JGyhcO4PeCst/CflbR9CiVCI++/vfCRqYbgt4I9YGDhrZzgp7zitrHgrZx58JG8jnRSaSUkCglCBz1U4La9a1UKPEI64KuQOifwn5W0w63IuuCqtuGJi/CflbTgoLLvqpHwkIupdT9s8LCRuOGhqvCQp5zhirLgqorVhUpcIwoDQgE6CjBCLnsiOi493LrgooLwkYynYPCRi6Twn4ml8Ja+ljw9PydnIio+POCgqeC0jic/KlwKGEIWUuGbnGFPcuC+t+CmoeCvhsKlPeCtogocQhptV+CsiSrgsKLguoTwn5W08JC+ulEw8JChlwoVQhPwn666OyXwkJ2j8JCAs0rwkKGPCihCJvCdi6Fc4K6kXMi6LmTwnZSq4rap8J+VtGM7aSJgLmDqn5HwkKitChBCDm/gt7Twn6GZ8J+VtCYqCkBCPj/wnrmdJeGlsuCxr+Cuvk/wnrm+8JGKheGNumA/JFk9e8Kl8J+VtFLwkJCi8J6Fh2DwkYaB8JGwnCfwmr+6CkFCPy7RqCZy44K88J2VguCxoS3wn5yQJD9z8JCdpPCQnaDRqCo9XSbwnriTRcO8cULwkJ6FwqXCumDwn4iU8JGklgoEQgI+ewo8QjpmV11gPSdEwqTDjMi676yFOirhi4DwkYiu77+9Ii9W8Ja/sfCvoKLwkZaU1o1wO+Ggle+/vfCdlY4yChpCGCbwkomB0agmYD8uwqXwkaqc8JG8m2lRPAo4QjbDm/CflbQq6pKfIkVf8JuynvCQoLgqRPCWqZJeWvCQhIHwkJa54r+0cPCQoLjwkbyYM0AoXCcKOEI24Lau77iHYFwnLfCflbQj4aqqL1nis7pg8JCSodGoJuCrv0098JCshk9j76yx8J64gDrwk5GSCgJCAAoQQg590ahA4a2x8J2SouCpkQoVQhMm4LOWPO+/vWBYceCsvmBLJjp7CgpCCPCfiKsueS8/CgZCBPCRpJUKHUIb4K6JLvCegIsr4LOI8J2Is/CeipHwn5W04KigCjBCLuCws+C6pfCeubrvv49k8JCOuXskRyc98J+trT3ho5tVJD3RqPCflbQ/77+9yLoKLUIr4ra5fXt+XOK6hfCfnLIuw6FkdCXCpWA8PXw84K2WJuCunsi68JGXl03CswodQhvwnYySTjHqrKjwn5W0Sl0ubmAv77+98JGsgk8KGwoEbmFtZRITQhHwkbG48JGcqSI98J+VtFXRqAo0CgluYW1lc3BhY2USJ0Il8J+SungtPfCQoqc9L14qTPCen7R+4LGW4LGa4Z2m4Kef8J64gAr/D7oB+w8Krg8KB2NvbHVtbnMSog+yAZ4PCj9CPTpGR+GhgXTvv73wkL+qI/CQlrfwn5W0duGglWp98J+rmsi676yBSi5cKu+/vSPhvZPqn5Pgv5DwlrySVmcKFEISRCJm4KKc77+94LeSL0F177+9Ci1CKzQqNO+/vWDikYhYJCkmWjpryLpKJijwnbym6qK56qyWd+CnuuG/hC48JWcKD0IN8JGXmjdpS3tU8JakuwpMQkrwkIC9L1Z6OiLwn5u4d/CQgLTwnZChw48n8J64tnQn8JCkv3DwkIWQ8JGxneC2k++5ln0lyLrwnrqjwqVpMPCRspjwn5W0U+Gfswo8QjrhjInwkJKgKPCRnKXwnaqfe+qgm3vwkZmS4Ki84YKn4LON77+94K+BXSXwkaWB4LuBJOC6oj3CsSU8CixCKuC2veCnnyJkL++/vXvwn4e2JT/wnZSHWCd8e0rzoISCPOK2ve+/vT9pWAoEQgJgPwoEQgIwJQoCQgAKCkIIZyJgKT1+Vi4KFkIU77+9JeCxi/CRv5Q9QCfwkZmTzowKAkIACi1CKyolSiMwPMK+d+GksPCQqLPwkbGody4nRPCRnKU6SHPgu4JCyLrwn5u5LlAKDEIKZSIkJuqsouCysQoMQgp7yLp6w5fwkYirChxCGvCRgLUlyLouaivwkpGuPWYqwqV4e2BiaC97CgJCAAocQhom8J+VtO+sgOCouOCrkD7wkJ6eXNGoPcK+YAodQhs+P+CunH7wnLygJuKDq2Av0ajCpeCspvCeuZcKKUInP1HwlquwWGBNM3vwkZiXdfCWrol24rCZdOChqOGkqM2/77+977+9ChJCEPCdgLjwkIS/XELwnri50agKHUIb8JGkt1w6L++/vT3RqFQ677+9c0zIuiXwnrqmCg1CC8KlLmom16/wnrmCCilCJ/CfgqHvrYDgr7osJOC3qMK1Lz138Jy+svCflbTCv/CQjZ14WOC3igo3QjXvv71QamBx8JC5sGgr4YuAJPCTgLXwkJan4KyL8J6Cj/CWvpjwkYyUwrtgctaN8JG0utGoWgoCQgAKEEIOyLrgs7PgrqTqnIPhvZsKK0Ip4LOe8Jq/vcKl8JGKiPCdlJnwn5W077+PX+CiiD1+8J65gvCQmqY90agKHEIaJSU6P/CQqoNc4b2fwqV7NPCdg44qX/CRiqYKP0I94LC9w5R74rSBJ+CskOGMkzxNT/CdkIXRqC/vv7024b+TJeC1uGbwkJ65REnwn5W08JG0vNGoJzA/LuCrpgo3QjUn8JCetO+/veKRhXbwkKiW8J28pT9YwrF3J+KAmD1VLiTvv71h8J6FgCJ48J64ge+/vXthJQoVQhPgq7808J2Vqj09YGvhi4Umw6dOCi1CK/CQqJPgt5N1JFxdwqXwn4ipWvCbspzCsXd877+9yLrwkYuRwqXCpfCQkJYKIUIf8JGKiF/grInwkaefbjdbXOG9oOCti0jgtbnwkYyBPwoJQgc68J64kdGoCixCKm3hnYlgTS86JvCQlog1N+CrvcKl6qin8JCumvCRjKbwlqmmT3wq77mwJQoPQg0lJMKmPPCflbTwn4ClCg9CDeGJu18i4Ka5NyovUXsKQUI/dSckKDfwlq2XKvCRmZVRe/CSkbQnXPCrnYvwkZal8JGcoVLgoZ7gs7MiLu+xhzbwkbGsR0Fg4bOX4L6sPCd7CjxCOuqfkDN28JGlguGqgfCflbTwkKC3PfCWvpsn4LSQLuCuhm4u8JGNiOCnjT3wkKifXvCflbRe8JCPj3cKMEIu8JGxsWjgqLw58J66idGo8J+VtHtN4bOGP+CrjWzwn4S3IeGmvibwkYqF4b+8fAo5QjfwkYK+Lz3horcqPHvvv73wn4WB4LWGJ/CRpJUm4L+X4K2IcmBrL2dWJirhi44y8J+VtPCQqLpvChlCFyTjgbPgsawlJCp2KSzwlqmUR9GoJigiCiRCIuGJuPCesp3grpwufj7gqZ4qJ+Cqg1ws8JCrikYuTfCav74KQUI/PfCeo41Ze8KlPTwl8J6AhETwnrSnLvCSkKw2JPCdlJIl4KGe8J65sT/wkKC80ah70ajgsLQ/UfCRgLLwkZmmChBCDiJ54a23LvCQnY/hiZheCihCJu+/vfCQi7Hvv70mPci68JKUsWpd8J+VtPCRpInqop7hp5AnbMKlCiBCHtGo4oC1VOCmsCJI6qy54LKkQjIl76yXXXzgsYJeIgo9QjvgqYDhiovwkIeSRz/hn7Xgu5/wn5W0OmjgrINr8JapkDXwkK6u8JatrfCbhZVe8JCBlS7wsaGt8JCgvAobQhnwn5W0MOC6uS0u8JGMsyLwnrmhIkPgvZ0xClBCTuGNsm/wpaSG77+98JGMgfCdlInhjofwkKuAJCLgrp4q4K2B8JCAvfCQlrwzOu+5tHsm6pym6qyl8J+qvfCdnK3CpVzwkKiG77+9J2A7LgoXQhXguqXwnZK1X2Ame20l4LalZuCnlz0KFEIS4YmNd+KAtT/wkaSBICLwkb6wCiNCIXvhvZs9W++8oPCQoLUzVOK6mFRByLpVU3pgP1w+8JCngQonQiXwkYymKnnhj7zwkJaOe+C6hEXwkYWs4K+Lw44kYEAlJ2bwnoCjCjcKBG5hbWUSL0It8J65sScw8JGmpPCeuaTqoLTwkISf4ZiG8J+enSbIujrwn5W0YHI1XOGkjsO2Cg8KCW5hbWVzcGFjZRICCAQK9BG6AfARCokRCgdjb2x1bW5zEv0QsgH5EAoJQgc68J2MrD1xCj1CO3Xhp4DwkZuD4K6GPPCRvYTwkKiF4K6eS3vwkYu24K+GLtGoc1xW8J66lS7DlOCug2QkMCbwnoWI4LCSCgZCBDxAJicKGEIW8J2SpSnwnZSKNX3Ct++/vUM28JCPlAoiQiDgqKsu8JCpkuK3huG9nSYmJS974L2gYC8icD8i4LS7TwoCQgAKFkIU4Kqi0ajgrYjCpeC6h9+/LiR20agKHUIbJOCrkMO14Kezey7WjeCtpyXwkKCr8JCNmSI8CgJCAAoWQhTwkKCF0ajwlq2FJuC0j8i68KqiqgouQixdLuC0hvCRsJPCpSc9IuK0hcK2J+GKjfCfq6Q/L1vRqPCRqJVgJWDwkbSyewowQi7hppLvv717UeCupDzvv6rRqPCRjZfwkaq88JGMtfCWvZUp8J+pqNel8JC/qTwlCj9CPWMh4KmeLeKAhn4n8Ki3ijwl4K6SbX5cwqXCpWIle/CfnKHvrYPgq7vit5HwkIaa8JCwsj9C4K+Q4aWAJToKMEIuPUHwnoKPLUw9OjVLXvCeuJrgrKg68J64iCJ7KPCRpJbhoI1g8J+sl/CQoLwlJwoPQg0we8Oh77CRQfCflbRgCgJCAAoFQgPgs7EKJEIiJO+/vfCQi7hg0ahhSFp+8J+BqcKlJvCepZ/gt4rwlq2SMwoeQhzgqZFgSU5Wwrh+8JGItkzwkIGN76y08J65sVVPCi9CLU3grII9PfCRpI9c8JGRnuGekOCugiPhpYDhg40lLzzwnrqRPXXqn5Z44b23Sgo3QjUlJuCunyd7Jybhioo9yLrgqLA8JeK7s++/vXvwnqOTJj3wkJaOL8Klb3xfyLph8JGWve+/vQorQinDleC3sk9TYCU88JCnhfCQrq498JaspTwi77+9WC4m0ajwq4CVLmZTKgoOQgzhi4pITFM98J+VtCoKHEIa4oGVKvCflbQm8J+VtMO98J6jjfCQgZA2PyIKBUIDP2ArCipCKGbwooeWQEtAWvCRiJXhnbPNvyol4KiIL2DwnoWJNzw/4K6+JkctLkMKAkIAChtCGeC3n8KgPEcl8JG9mOGdg/Cqqq8u8JGwh0UKC0IJ0ajwkKa+OCN7CiFCHyrit5tRPPCegI13Wj8lPGbwkaeR4Leq8J+ilfCflbQKFUITTeCxulfhv4QkYC4mNSUsJS4vKwomQiTwkK6tU+CxmEYv8JuygfCQpIww77+Se9GoIvCRvIPwn5uwfSYKDkIM4aSncMKlNMO3dSQmCgtCCfCRirDwkb2UJgoCQgAKJ0IleCfvv7zwnoS18JGIkMi68JuxuOCti1zwn5W0V3vwm4ecJHgzVwovQi1eIuCqsy7wkYu4POqfk3vIukPwpbiv8JGMsComLtGoJsKj8JCeie+/vfCbhacKNkI04Ka88JuxvPCRhLJi8JGKm/Ceiqt7JW3gqLkvJeCyoC/wkYO5Luqnp/CfgZZg8J+VtHAlVwoRQg8u4KyZeyTwkY2MXyRzPCQKHUIbXO+/vSwq4KmcJj7gr5dPVvCflbQkPSTovIQkCg5CDOC/hjpZ8J6ksy5qLwo7Qjk/6qCwOe+/ve+/vT/wnYuSJOC5m1wy4LKn4Z+yXCV24Yqu8JCgiMOkL/CRjZdF8JGnoO+qiz87PD8KJUIjKjw6YOGNoOCnteC4t1kiNfCbgZnwnZK/SlgkbPCflbQudi8KGUIXPeqmtOG9nX4v4KehXSLwnYuzL+CssycKNUIz4LGL6qyE4bOpX+KAm17hiZvhnp9cIvCeubvwnrqrKjpmw47wkauLJOCokCrwnZS9V8KlCjdCNfCflbQl77+9P+C7hmogOmDwn5W0YOqsoy7DiHsm4La3dPCfr7XwkZ2Ce0nIuizwmr+54K2fCjZCNPCQlY488J+VtOG/svCqnJ9oOvCdlLzwkaCY4YOHc/CRmafCpVguXT0/PHtVP157euG9nS4KNEIyPT/wkISMK+C8lDwueSclUPCRtbN8PO+/vSfIusKlKO+/vSojw7nwm4mRI/CeuZnhqaMKAkIACjhCNuKDqTVcJ+K3i+Cpm++/ilzgrIMq8J+rkSZIPO+/vS4yQC9lU+Csq+C3suC0t07RqMKl8J65mQoFQgPCpXMKPUI7SuqtqTfwnYOh6p6n4K6aYSrwkJSWLvCdvJdfPPCfgqzhnYgpc9GoIvCen6vguoLwn6+z8JGkifCfh68KHEIaMUjwn5W0Wl3gv4Xqr7lNXC/gtZTwlr+wdWUKNkI08J65vvCen7pLYkLwkoimfSok4oKBPD3RqPCeuZsv77+96pKpMj3wkKyQInjwn5W08JaqpgopQifwkIec8J64on3guobCqiZC4KeAyLrgrY1gI2skfvCfgLtO8JCUhi4KLUIr8J+VtCXwkKyG6q+3b2Dhi4ThjJPqrIzgr5fwkI6T8JGDlH54J/CegKo9JAofQh08Jsi6Iu+/vfCQv6Y6ezM/8JCehNGo8JGNg+GSpApOQkzDpPCRjaBw4buV8JGFg17CpTp9zbrhg4fwnrisM2DCp+KAheGugOOzrPCQqYDwkZK2P/CRp5xgfvCflbTwkpGM76ioWfCeiqrgrp5RChpCGCTwn5W0Ll/wkbujV+CqpPCQqZbwnri0dAo/Qj3wn6+04b288J6hgOK3neCss+C1jfCdja4877+94KiK76y+LiE9L/CRpJLwkIaRUMOcJEpJe04mVvCbsbRHCkhCRnB2LibwkY2pePCflbTwkKiTSfCRpqNo8JGqv+C3svCRpIk9Qy/wlq2l8JCgvMOG8JGBssi6JvCdkqI/XzzwnrieJPCQpL8KGkIY6q+46q6MT0LwnZKpJuqnty4kKlzhnII/ChdCFVxgyLrgooLgspBoez89LnkuL+GhjQpRCgRuYW1lEklCR+CzojI/8JGBmksqUiJtL/CSi7Zc8J+hrybwnrqjJPCQk7Q0wqXwn5W0PuGDjfCflbTgsZXhqojwnri177+9JFFj8JGAhMOlCg8KCW5hbWVzcGFjZRICCAQKtxG6AbMRCsAQCgdjb2x1bW5zErQQsgGwEAoKQghNJvCRsLliSgoCQgAKO0I5YD/wkIagM2HwkaSOJ+C1ivCWv7Fre++/vScu8Ja+hsOFXCRU4rSPNnEi6q6ZLSdG4oCK0ah94b+JCitCKeCoifCRsbguYG06NVzgv4Lihrbgu4YlPfCRjJAl8JORjvCQqIVKOiRcChhCFlHwkbSnVeG9m2AvIFpFKydWT+GwsGAKGUIXOlvwkYOBP/Cdk4InLuGds+Cshj/IukMKPUI78JC/sTpgeiVi8J66pzw/8J+CreK3ji1v76ymOuGyh3xl8JGDtduuJCrqkrsq4rWnXD1c8J+VtPCflbQKDEIKXPCRtIMvPequmAobQhl+J30iLuG9kvCegIzRqCI98JCMgyY76qC0CiJCIGbvv73IuvCQnrTgrYjwn5W0J/CflbTCuDrigJEkZzltChNCETjCpeqpkPCQlpLwnZSDYE0vChJCEHXwkYqa8JORh/CRpZJFYCoKGkIYIjYnPCfIulzRqEfgprLwkKSDQeCxnWk8ChpCGMKlP++/vUhu4rSPUlvgq7ovwqUoL2EuJwovQi064YmWJHcj4Z2jYntUP++/vSbhpYBR4LeQ4LGdUsKlL/CWqYkk6qyL4KiGeyUKLUIr77+9OuCjvNWhJ1F7PXg68JG1g/CRjL/wkaSRL+KRhsKl8JC8iO+oli4nPQoaQhhKPz8vLiU96qKa8J60vHtcWyritIfgrLMKMkIwPUfCviXgrZzwkKagIuGmsfCRjJ9g44iM8JGNsuGJimDwnoqnQ29m77+9PeCzlmo6CjlCNyrwkbS9OfCflbTgqL7wkJaU8J+NvC8qXCfwm4WV8J+VtPCQio888J2Uij/Iuj88cCpgIlE3YDMKF0IVXPCRjap78JCiqfCdlY9cMC/wkL2JCgZCBDQmNToKL0It4LWdUuOCvnfwkYu40ahx8JORk8Kl8JC8oD8/djwvTWw077+9OlF7O3l177mECglCBy8/yLpMJVwKDUIL8J65qSQl8JCgvD8KM0IxT/CQkqDwkYqf4Len77+9PPCQqJJiUz14yLrguInwnqWQWfCflbRB4bO377+98J2RswoPQg1F8J+hmPCRtLpcM2BzCjtCOfCQlbUnw5XIuvCfgqHwkbu38KWxhzwlZO+/vdGoLvCflbRp4Lql8J+VtNGo77+9JMi6TSY977+9Lgo1QjMuPXNo4Z2wyLpcMsKlPVhW77+9XS/RqNGoe+GJi1xDUV7wkKeoeSrwn4Ox8J67scOgbWAKFEIS6qeR8JGDgi/gqZ7DhS/wkbuhCjlCN3bwq6KNwqnCo3lRyLoq77+98JGIqVEu77+9L+Cph+GfuCbwn5W0XDV1L+qihuCst8i6I/CUk44KOkI4ZOCnlzIuL8i6yLrwl6OhyLo8PW8+yLrwlq2y6qmJ8J65qfCRh6VqwqXhiotcLj3Cpe+/ivCRjL0KF0IVwqHgvoPwn5W04omMOe+4lvCdk7pCCi5CLCU/JfCQlKJpyLpC8Jq/sTrvv4fgqrPwnrmUJVxlPFw/JTrhirnwkY2Bw5hbCgNCAUMKFEIS4amoVzbgq7s/aPCQuqzRn8OuCglCB+CvkFwmJjgKQkJA4K2Hw49cKuGJimTCoVN7aMOAXPCQnYnwn4y/Ye+/vSVOw47wkKSbSilK4aCY8JCVtU404L23yLrhsqA28JORigo8QjomIsOs8J+VtHo88J+JkU4l4K2E8JC/rzon4Kq+XG/CpS/wkYydUvCeuYfwkaeg4YqM8JG0unA/6qmyCjhCNvCcvL7CpeKCgmngtprDue+/vXw/PcOk8JGLsOGdpeK6nmDwkIGS8JG1p/CdvKfDllHwkaWRdwoYQhbgrprtn5zIutGoXMKj4aGq6q6/4auOCidCJSfwkYqcw60u4Ka54LqO8JuygeG/uOCjoUvwn4e+8J2ksPCeuKcKM0IxN+CouSrwkr+BPV0l4YqNZvCfoZcmJsi6InTgsIo8Wj1w8J+Rviok4LqHLi/wkaWQKgo2QjTgsZgne/CQsKbhnInwkYiDXWEq8JCWjSjwlq2qPy4l8J+VtFE88J+VtHTRqCVhXOC4ricmCi1CK8OSXTfwlqubM37wkYq877+9UuChovCRg7TwkKGt8JChjS8r8JGCpuGzoDoKAkIAChJCEDzwkY2gRETgq4Rwciziv7MKGEIW8J66qPCQhqDwnYWuJPCRtaAqPyojPAoHQgUm8JCnoQoXQhXiupXwm7G48LC0r+C1iO+spnl7P3sKG0IZPPCQsYcn77+977OPJiFyVSIq8JG0uuG8mAoLQgnwnrmC77KnwqwKM0IxYE9g8JCOq/CbhaZvP1kkJfCQp7HRqMOJ77+98JChlSRQ4b2VOjrwkJ2SKV4m776dIgowQi498JGcqS7RqPCRtLzjnZth4LGm8JCysfCRqbF08JCWheCvl++/vfCQhILwkIytCh5CHOqpjF068JGMsuCmsiI84aWobGDvuKQqJTDigb8KH0Id8JCyr8i6YPCflbQxZdulYNGoTmPhjJQ9ROqfkDoKBUID4Z+hCjJCMCNkdG7riLFEyLrguoEo8JCAmj1N6qeY8JGDtVDWjfCQrL7vrqPRqCbgrZwm4reedwofQh06X18q0ajgpp8/4K6v4Z2T8JCWleCmssKl4KuDJQoyQjDvvJrgoLzDuTx4J+Czh2ooWici8J+uvuCzsjx7P+GKtCZ28J+VtOCvgu+5iSp7KnwKMkIw8J+isOqZqFNQ8JG0hD97wqXfpuGKr13wkJ2Dclvgr4jiuYZn8J2AhcOg8J2UlH06CjYKBG5hbWUSLkIs4Ki5Q/CQlpA9KPCdhJVo8J+VtOGom/CjgKnRqPCRioBGR/CQqJYt8JCgiDEKNgoJbmFtZXNwYWNlEilCJ2Xvv73DrsOOKuCtn+Czij858J2ClnsiMX7dgkDwrZij8J+erVHIugrkDroB4A4KiA4KB2NvbHVtbnMS/A2yAfgNCh1CG+Cttypk8JSTrTouwrDhjLfgoLnwkb6wfXskbgocQhoiOlzwkZC8IVUievCWrbXgpobgrZ0m8J+VtAowQi7gt4ZaaiJPWiXwnrmUJfCQqJXgqq4m8JGmoCbjg4VpPyfwn6qIP+C4pXLRqCIkCjRCMkEiJ+GLjCoiePCfg6Ex4Zuc3I3wkY2LOCbgqbbvv71u8JuIv+GDhzA68JGxlSrRqDwqChlCF8Oezpdc8Jy8p1LwkYSJ8JCmpOGhskZHCgJCAAo+QjxN3KHOjPCQgIElJPCSkbTqoJPgp6LhgJ418JCUpGBccfCQoIjwkK6bJNGo4KmeJkts4raMIvCRi4HDiyAKOUI34KGeL1xeVCRpKnHzoIW18J+VtD3gp7Yn4aS68JGQrHfwkbWn77+9TkzwkKuze1Mu4Ke+4raIPQpPQk3wkKiFM+GKivCRtLzwkIGK4b2ZPzrwn6mo4b6me/CeuKfwkYyrwqV9w6jvv4t7IOCxjWPwkKC8e+C+hMi6SO+/vW3tn6PwnrmX8JCnrAovQi0l4aWwImolPOGJmHMgJ+2fgmR0KvCQra7igrV4fT/gqLzhv4Ii4K+C8JGghyoKAkIACiNCIfCbsbY8JErwkZyH0ajIunDqo4ThjKPwkL+hJeCqveCunAoIQgZg8J+ghC4KHEIaPznhpJnivKvwkLqsKDbwlryd77mwbPCflbQKPUI7YOCxo++/oXvRqPCQoIU9PeGlsC7IuiXikYXwm7KFJ/CRtIglNUMy8J+hkmrwm7KUK08kwqBYP3nqraMKF0IVe/CQqZDwkbKF0ahgXUAl8J2lhMKrCi1CK/CRqJ7DucK5Jkc/6p+YLfCRjI9ewq7hs4fCpXon6qyp772TJvCbsbxrYDoKJUIjOjfwkKekYOqev8O4PzrvuZIk8JGDguCrjCp7XSo/8JCGmzwKL0ItXCLgt6rvrYDwkKiG8J+VtD9WVOqak2zwkKS/w47wn5W0bOCzi+GLgD88Vip7CjdCNT8ja1ZrW9GoKCEi8J+bue+/veKBsDfwlrmhP/CRmaThi4U977+98JCAvTxu44Gd0ajwn6q/CiJCIErgu5/wnrqm8J2VhvCQgZ3vv4Pvv70qwqXgr5fwnZSaCidCJfCflbRPZPCQgIHitrtee/CXvrjCpSIt8JGDsyZoLOC9jFcuK2IKMkIwekDCq1Dgt5bIuiVBIljwk5GAPyY0PcKl4ZepL+CshvCQoqjwn5W0ZWzIuvCav746ChtCGfCek5/vuIIgXC4/PMKlXE1gVvCRu6wvWXQKCUIHNTrwkLKgKgouQiwiwqUiIypaJ/CwpLpRL/CQhpTIuntjJPCRvI9R8JuEstWvJ1bwkYeo8JCbvwoWQhRHTPCepZ4nwrZdc2NK4Ki2InwkLwoTQhE8W8Kuw53wkIC84b22yLo/NgoxQi9t8J65h3sqXyrgsIbRqDdZJSJgLiQ98J+VtHI88JK+lvCQtIFcXPCQpL/DoHrDmwozQjHwn6moJzpn8JamjvCeuKI68J+VtCMi8J2Su+CxiPCQlrxa4LCM8JG0hFzCp8ONM2srCjNCMUDwkK6vOCTgqYfgspInw7jCsPCRspJOIuC8qOqflz3vv7wk4LeAV+GfpSfwnZWGRFwKK0Ip8JGlmE7vv73wkK6p8JCBl1Dwn5W04K6edeC0jip8wqU/JFzgpKzvv70KQEI+XPCWv6MufiRw3ILCvSLwkYS/8JCEgPCfr7Mq8J+kjTx28JGKiPCfnZLwn4Cow4XgqLYvOsi6Kj0iPVRJbC8KLEIq8JaspCtx35slYPCQjrXCpS4/OmYuUeK0iPCdkrFo4b2baDpm4Lem4aKjChxCGvCRjYc64rWBe/CQlrngp5zwkKmmVO+tgyJ7CiNCIWslPPCWuoxgPfCRtIjwl7ypKvCbsoRPPV9uwqU7a+GJjQo6QjjwkISf8JCMgmDgqYzgtrB74aCD77+98J+Dgyp7PFw0eyQnwqlkwqXRqHFgdGbIuvCfgqfelWDDswoIQgbvv5Uu0agKEkIQ77+uJzU/4K21766D4rqNOwoWQhTwn5W04KGpfXPwn6mwVuCwqOCqnwoyQjA08J+VtDc8XErit7jRqMKlPOGaskw8L0RgTu+tgEMwRDNlJ3jwkL64XSbDsPCbsZQKDkIM4b+rKuqToScpyLoiCgtCCXXwkZiyaDolewoPQg3IujvhoJcgXPCfqqoqCi9CLVbhpLvRqEs/Pe+xpC7vuIAi4YmV4aeQWfCdgbU4OlXDkPCRjIvwn5W08J2NtQorQinCpjzitrjIunvDjSom4YyVJzxn4Z2wPC7vv63RqFLvrLIn8J+VtO+/vQoTQhHgu5zwnZWGdMO1wrg9cFzRqAoCQgAKFwoEbmFtZRIPQg3vv70iKci6XE5eyLpJCjoKCW5hbWVzcGFjZRItQisuJFTXmzxgXMSWWtGo8J6jjXnCpfCRvI1mJz3hv6PqrI5s8JCph1AvP9GoCvERugHtEQqWEQoHY29sdW1ucxKKEbIBhhEKL0It4b+ayLpz8J2IsuGMlFZ7OjjwkLSlPC8u8J65tfCRhaBaVCXwkaee4b+X6qevCgNCATwKGEIWUSbRqPCflbTgvLwo8J2Hmkvwn6mtSQoLQglj0agv8JCtnUUKEEIO4b+E8J+VtPCQlb/grYAKJ0IlQiJg4LemJCTigJXwlr+gXDxc8JarhyRmWvCQnYLwnZKiPO+/vQoUQhLhjKjwn5W0eyov8J+VtHtYPG4KMkIwLntD24Hwnrm7w65ewro04raNJjPwkaSWwqUv0ahG8J+VtPCQgpTCpTpHKCLhvqZvCjNCMUDIuvCflbRu8JCMsCdO4KmI8JGGsT0kIvCbsK4kP/CWrovwn5W0LuCsk2PvuavDq2AKG0IZKmAlP8KkJyk/KuCnozVNJMOZ8JCngTpgJAoGQgTwnZS8CjpCOGgvJuCnjcOEPCLii5jwkK6aSCfCpXszJiU98JKTuSfgrrDhsK1hPWzwkYyyPO+2p/CdlJrhqr0qCghCBjxg8J+cogodQhslLnt74LGA8JCekeqhll5Y8JCguOK9vu+1mi8KIEIeb2Hwn5u6QSYkJvCfkY5X8JGkvCp7eD8rOvCRvJJ6ChtCGS5PfD1m6pK56pKbXVpI8JG0jErwnrmkKm0KGUIX4LOVRjpv4b+JJ2M9XOCotU8gJGzIumYKPkI88KWpkfCQj5TwkYijXj0vXPCRsIEzJPCav7nir57wnZKsfvCQi6xcNOGwiCbwkLSR4ZipLzrwlqmjPXhmCiJCIDvhkLPgu5PwkJac8J6lnuK7n09rwqU6b/CflbTwkJKoCjpCOOGhsvCdlYbhi4DRqPCRvL/vv73Cqk/wn5W0UyHwn5W04LOWyLrwkbGDKlEwKiI2M3vwkYyyXCBrChZCFC46PyTwnrmfdS4iJvCfiKEqXcKlCjNCMTAnYGZQ4KGp77+9wqUucT3wnrmsZlQ9e0jwlr+jODrwkJOO4Lql8J+ukPCfqoVNOSQKLUIr8J2Fj+CrkDwkXiIsU/CcvYZf4Yma8JCpgvCQgL1g0ahdLj3wkbaR8JCeswosQipuJvCRo4TwnqWUYPClmYbihZ49e2DwkJ6AR+GTlF48cuGKivCflbQgXEUKRkJELvCdkp/hibV6e+GlsSvir5bRqDzwkLy1dOqpjChCJGAv4Y2e77mqL/CflbQ/8J6ApuGqoSQs4aqJ8J+VtPCRtIZkyLoKBUIDa2QnCg5CDD1ZdvCRpLhgw4xQPQoUQhLwnaOwwqXgr4gl4LCM4LmTNXsKF0IVYu+/veCyjsKle17RqPCWv6Qz4KayCg1CC/CeuZfguq7gu4YgCkJCQPCdqZfhqLLwn5W0J++/vUIm8JCBh/Cfq4Hgo4o94b2bOzY/4b+OLmAiQWQj8JKSkPCQvrkqJ/CQrodROuC3giUKTUJLXPCWrZXwlr6eYFbCpXvIuuCzh+GLgsOdKidc8Jy9gF/CpfCfpJTwnoSr8JG8kl8vP+KDqvCbsp3wkbaRWvCeu7HVk/Cfn7A14Ki1CgxCCsKl4Yq0QvCflbQKGEIW4YmTUkZuyLrwkKC3V+K6likuYsKlLgobQhkr4LavP/CfnpXwnZKeKj0uUkDDsuCtoD9+ChZCFOC9qzxWIS4mXFB1Jl3IuiYlJH5gCh5CHCYu8J+evjpH8JGDk/CQraPwnoS2aGDwkISBJCoKBkIEbjJ7PAoxQi8maDrwnZWGIfCRp5w9YPCWraHgrpQpaVzgppDwlquyw6An8J64u/CehJrCuT4vJQopQifwnYuu8J+VtPCQoLg/eHvwnrmUL0Lwn4WdcSbwnYy58Ja8jPCflbQKA0IBewo8QjpC8JCdoFJx4K6j4Ku/Oy8u8Jatl/CQrLlg4raK8J+FsSXwn6S88J6EuPCfoZBgw5zwkY2fWCLgrLAvChdCFWBc8J+VtPCegYHwkKiAYjVgYuK2rQoeQhwifeG/mSo24LC18J2SsSQnRE5vXiLwkK2i4KGeCjdCNfCRjYwnPPCQlIs6w7DDrvCRtpTwnoKPzb3hirMs6qyt8J+VtCRewq/hm4890ag6JPCbgaokChJCED1+0agmP8Kle+GglirgqLYKBkIE8J+VtAoJQgfwnrqEUGxtCiNCISTQiz0r8JG0iXzwnri04Y6iP+CunPCei7/wm4Sy8JGllgoIQgZl8J65ulYKNEIyPO+/vfCWvb/wnrm5S1k9auK/sSbwnZmwPFzvpbtg4reMJHc9wqU6JsKl8JCEgTZbcEEKAkIACiVCI0PwkY2Q8Ja/sPCRgZlc4Lql8J6freCuvz/horsqJSJ74K+NCjNCMeGJi/CQgIVgdjrhpLvRqMKs8JuFkUvwm7Kf0ag68JGygCw/77+94LqR4a6ZwqU+LVYKKUInJMK64Yq0P9GoNeKht+GfovCeuIBf6qCO4K+X8J2SrHrZtvCdkqw/CipCKD0uOsOhYHXwkJ6IJuCppuCpnvCflbThi47wn5W08J+hsjpzJPCfrL4KGUIXMWBcVSgvwqU/4oGwL+Ghr+C/jPCbhZIKA0IBLgoqQijvv73wkKi5KvCbgrM+YfCfq6c/0ahCPHXgqZltJ+Gool48VifWrCcqCilCJ/CegIrwnp+m8Jq/te+5sD1Lw5Y9762AKi5UYG06Kjo/77+9QeCnnQoeQhzvv5o8JHDwkJ6wKPCeuIM8J/CQrpnwnbymJCYzCi1CKyFNLnTqo7Ul4rasyLrwn5W04r+0XDc9L+CskMOXfeC3rSU8Km9STe2fpDoKDkIMVyY/fXvgqIHgt4F6CgNCASUKLUIrLuK0reGOluOCkcKl4reE8JC6p++tgEDqqbRu8J60iS/vro7wnL6C4LWHewoqQigxUkApL+C0kCXRqC3wn5W00ajwn5W08JGxu/CRgokx8JG2lXPvupIjCkEKBG5hbWUSOUI3WMi6aT0kzpPDsO+/vfCRu7jgvYBgI/CRjZfwkIagaeChnuGqg3ZFLSZcRCTwnZKOyLok8J2SqgoPCgluYW1lc3BhY2USAggECuQUugHgFAr5EwoHY29sdW1ucxLtE7IB6RMKDUILO8KlZcKl8J+drEEKNUIz8J+ip+GkqWBgIlp+8JGIguCzjCLgsYPwnYy5Kk0oJFxJaXQ8dFzCpdGo8JCmsvCflbRgCglCB2AnbvCRmpwKLUIrMOCqty9O25zwnrin8JCMgH5nZfCdlK4h77+9JuG7lOGmuyzWo3XwnoKPLgoQQg4icfCSvpHwnoGH0ajDugoLQglfPz3wkZyPZGYKPEI6YPCQgL3RqHPwkLC38JG2i+GzhCrCruG8m8i68J6Fjj8kyLoyfnslOvCqu4zgp45E8JCUo1vRqOCrvAoeQhwg0ajDly3DpPCeua89YPCQhpomcPCQqLHwkJW1Ch5CHOCth+Crh+G6leC1tOCml++/qHslMm9oJT97RiMKCUIH8JuAtEHDrAosQio/cnjwkbKn4L6IJ/CQk5zCpWzCpTzgrp7wn6uxKuC1pvCcvIBc77+9ZXsKGEIW8J2UnDpj4b2Z8J+VtPCegYXwn66aZQoTQhE/8J2CoWJwaD3hvZ1cezrCpQoMQgpc4amue2w6Py8kCipCKEMsJVzwmLKjJi868JCoqD9PaPCRsIMkPzolLGxi8J6KnzxHJ/CfnL4KD0IN8JCwsFgr8JCWuy4xewoCQgAKMkIw8JGklks6w7Ul8J2Rhlph8J+fsMKlUvCRsrDwkb+mcyvwn5uye2nwnrmZ8J+VtHt7ChRCEuKCriRwIci6UlV7PzB98JGbiAoWQhQ8J2BkJVTDkCHDgeKOrsOaPG5gewoYQhbwkKuwXHokc++/vfCRgZY9RvCeiqo9Cg1CCyQuNypcLvCflbRyChlCFzzwkaS/J0U9Wicv4YyUenzwlqy84KaFCjhCNicqwrEv4b+K8J+VtPCQoql7V/CdhI884YmYPErwn4iV8JC6seCupC46buCqg8i6JvCdhKPCpQooQibgoqPgsb3vv70uOvCQvbZF4oCTZlPgq407w60+4KyyMOqsoVdaXgo2QjQhyLrknJlgWFLwlquzOirqpqVtKNeh4LSOTWPDoeqsgkHqqYHwn4e8YOK2rnh4cfCflbQ9Cg9CDfCQlaI9JzzwkKCBKl0KKEIm4Ky1JfCQubIqw7ExJVx8U8KlYPCRtpjwnqCRYyrwkY2HOjMnKi8KBUIDPyd3Ci9CLUTIukrwkL2877+94KyyOj7wnrmpPOC1jeG+rvCYtIY/ISLwlqmo4Yq0yLomewoRQg/hjZd00ajwn5W0wqtFJiUKIEIeOvCeua00JT0k8JCVvVzwkYGh4LGZ8JCTi++slz1TChxCGvCdlIgu76iDdUZO8JG/gdyBLF7IuvCeuaFwChlCF/CQqIXwnZWGbXYqJ/CRjYfvv73hv4pECg9CDfCflbThpbImJzrgq6AKAkIACgtCCeGmhMKo77+9bwofQh1PYFwiJy7XtOGtmT9g8J+gvuG9qCU8LiZx4amtLgoHQgVEceCsggoGQgQmezNKCgJCAAovQi18UPCQp5o88J2VgzLwnYWqPicjezoh8J64pPCQsqEk8JGwvWZlPyo48JCpkHsKB0IFePCfn5kKTkJMP0Dhn7bwnqWfVm7vv43RqPCRmq/vrL7wkbuwJ3vwkI+QPeCzi/CQnoPwkbS18J+ps0jit4PgsZl2O9Go8JGjhvCdoprhvpDhoJVcJQoeQhwuL/CRsIgoWsOKKk/RqCpV1YoqKjR2OuG9r8i6CipCKPCdvKdHJ9GoK2drPSLwnqWfeiLhvpvCpfCRtaVo4aqnKibvuK/IuksKFUITNGDwkKeOffCYtIBm4aS54rSnJwo4QjZxyLrwkLmmKklA8JCeg/CfhqHCpfCQjbLgp5fwkL+n4KCjIj50LS5o8J2Sqe+/vfCRtpUlYD8KKEImLibwkKC8YFxn8J+VtFlpKfCRnLPqn5MhaD3wkKOpPVpAJ/CflbQKN0I18JCopzomPeCugjjIuuC6gfCdnInDp3Dwn4mRQEHCpS54PHvgs6HhnJ/wkZuCL/CQubDCsToKDEIK4YmdIj9TcURgPwo0QjLwn5W0XyrgsL8vNy/wkJ64Li0/KkVge0I90agmV+G+rllyIjnhhLTjhol38JG/gMOrNgogQh4i8K+nvOK0p27vpofihIHgrLhcYHvwkJGqUlPvv6QKKkIoUtGoXFbwnZOBJfCesojgsrjigpkme8Kl8J6Bl24uNjQ/8Jq/uXUzLwpIQkbwkKC38JCWlGDhvLzhvpzgqLjgqLbhioFz8J28qTzgr5fvt4/wkJ2j8JCzizw9OuOHvFw94oCeJ/CQrI/grY1gYPCdk4UvCiNCIS4lJfCRtYQnNOCtnVU94K6OOirwkaSBYCbit5N7JSBoKgo2QjTwkJ6z4KuE4Y6Y8J6Lv1lY8JatpTzOh2w/4LqBMvCflbTgqLJ58J66kWAn4LWNXlDwn4mQCjhCNmXhiZrhoJLgv4vwkJaQXyVGPUXCr3lSPWzwkLyB4YqzWjFcLy/wkbS8e+qsqPCfoJvgrIIkOgoCQgAKB0IFbzs8LyAKHkIcKuCulSfwn5W077+9ReGdqVxGOvCRipjwnoWFQApGQkQmTPCQlJw/JXw6N++/vSFR16/wrbuzUfCRioA077+90ag68J+qpHvwnaqlIvCRlobRqHvhja/wkYS48JCdiMOEwqXDgwooQibIusKlXyo94K+QdSXIui9g8JiulUHvv71BJCJiUFdGc23Du+CssgoWQhRJ8J2NpSrwn6qmw5DCpfCfnJ8jOQo2QjTwkZqA8J64gD88NOqnun7wkJKmUOCsuFAlYGPwsoiJLmHwnoKP8J2Sn+Cun+CsuFNxY3tgCidCJeCxme+sljw58JGMiCPhrp3vuLdJ4Ka9YT4l8J6Bnz/wnrmte24KNUIzwqXwlqmlNU7hrK7gvavvrLlBc/CSk73hvZQ/77W+VWEq4La9wqXwkbCEYCYmPPCRpqNSCjZCNCYk8JChjCLit4VgLyPwn5W0a+Gyv+GKgfCeuolM8J+Dn+K0rfCeua5Rwr1rwrAvIvCQnZUKDUILU0TRqOCnjfCflbQKFEISwqjig5jvv73vrYHgvqfwlqmFCgNCATgKB0IF8JCAilwKHEIa77+94L+T8JGysC/qp7zIuvCRgp/wn6KxXCQKIkIgc/CRjYxmJ1zitrp68J2qrOK1sMKlZ8KlJiY6NvCQraMKQEI+VMOZ77+9PC5y8JGMnitG4Z2v4Y+o8J+VtHThvJzCpVHDr3zDpzova/CQja/grpUiJPCQk7LwnZKv77+9cycKQUI/4KmLfNGoJPCQnrLwnZSN77my8J+VtDlTJsi64Z2KKe+/vSZc6qiT6qOVXT1lKuCyv/CfgrxLLuCuvvCeuY09ChpCGCIi8J+rslHwkayEWVw98JCVnEHwkYq9PwpHCgRuYW1lEj9CPSbgrZzvv71eOk88XG/CvHvwkKOk4K+XUD/RqHfwkKiB44eRJVc8K1fgqJY677OvJPCrm57CpeCrjfCdgawKGQoJbmFtZXNwYWNlEgxCClF736dg762ASSIKzgy6AcoMCp4MCgdjb2x1bW5zEpIMsgGODAosQirwkIyx44aJwqVjPC/wkbaQ8J+VtC8ucTciMCEuYtGobyIq8JC9uuCsj2kKBkIEOsKlYgoxQi/Do+G/jSLwnaidJilubeG1hWnRqCfwm4aULlzwkpGy8J64p8i6OmQu4Y6W8J2LiwoiQiDqobDtnr7wn62Z4rayXPCbhLI9PCTwkbaVwqXwkYiLVwo/Qj3vv73vv71xYeCuo8KxVvCSv6Fq8JuxsiQ8Rz3wkYer27zwkbGFJPCWv7EkxKzCpSU/QOCzlvCflbQv4KC0CjZCNH5hNmcmPSU/c8KlZvCflbRk8JGFnzrwnouN17Rc1pPCpfCfk57wnoKP4KuJP+CmvPCQtI8KKUIn8J+btmc/Ksi6cG3wn5W0772davCWvZDgsL3vqKFzKsKlJOC2u0V5CiRCIuCtlt6PJnbwkL62J1wgOiZYfeCwg+GslmU68JGNg1xzITwKJkIkPzx14KeIyLo64b67b28uPfCeuYLwn6ml8J66guCouPCQvZklCjNCMS/wnrmy0ag9w6cvNVwk8JCtgOC0nuC3muC2g8Oawrzhv4zwn5yj8J+pu1xY8Jarmy4KMUIvPeC6hHrqrp4ze2BqLDov8J2XpE8lyLp1XC8l8J65m8KlQVZSO/CdjbfDgfCfm50KPEI68JCtsvCav7Pwn6C+Js6E8JaquXPwkaufe+W1nF7grp8wIvCflbQnJDo/4LWiKnvRqOC7n+CnjO+/vQoSQhBY4oGR8JGklm/wkYere2FBCgtCCfCRi5Q84LuXLgo4QjY8b17vv71gw5sw4LSO4KOf4Z+iItGoOuG8o8Kl8J64pHPqqownwqXwkaWDKjVbPGvvv73CpS4KBEIC0agKJ0IlSk0377+i4KyG8JuFlS7wlq2BIvCbsbzwkbKhPOqvpTnwkIu4PQoOQgw9PfCfh7DjhZBAPCUKNEIy8J+CqWpg8J64m+GsnEzwkam3TvCei7/wn5W08JOHvC0swqtAe++/vSdGYFHOmcOfKmkKM0Ix8J6fqHvgopvwkIek4oSl8J+JoCTwkYyK1qDwnYySUvCQhZTgqbXRqO+6t8K64KqyPwoVQhNxL8OkeyA84Z2zXPCeuKQ8dMOzCiZCJMi6IiXCpS7wkLqxQydg4K+C4aC7KvCRio178J6Fjy5+J3tgJAoOQgzwnriKaz3gr4dGwqUKNUIz4Kej8JGKivCforBaT8i6wqXhvZfwnrKr8J+pkTzgq6jwnYyeYlUkaC3wl4auKiBcYDhVCjJCMPCRkaEnwqVjItGoZuCskFvwnoqQwqXwkYylPfCShpPwkbCCPfCRiqbIusKl4KyQKgoEQgLIugowQi7wlryAavCflbTit4pj4LKuT3tm4K+QOjo68JCnsXzgtr0qXMi6JuKRheGqhc6TCiBCHl4iw5ZgYNGoXTrwn6uQ8JGMs9evLFzqn5fvv73RqAoNQgvgs5XwkY2zctGoXAoPQg3guoElJfCdjbfwnqWSCgVCA+GiigoiQiAuPz578JCjvPCflbQvYeKAheCmuGFa8JORjip3Y+CvkAoxQi80wqUiYPCQoYE8MMi6V+CuhzsnyLol8Juyn/CRh6NgP+C/gMKlYPCQqJcu8JKJgwoyQjDgrLB64KyJLyQm8JCKnPCfl6XCpSLwnaG/aNibPe+/vUzwkICEbn3gsr3CvDrqn74KN0I1Q/CWq60mJCUq8JCWvDHwnoCk8J65ruCnlyXwkYyk4bK08JCdkMKlJfCdlY086pK70ajgrIoKLkIsP0Pqq5468J2qreG8ne+/vTzhv4NV77maTOGKs1Dmj6YnInvwkbWowqXgr4cKFEIS0IQ677+94b2Z4KCxJXXjhJc/CgZCBGInwqUKJEIiY++/veCmsm/wnrSdPyTwkbCAV8OpXOCmiybwkJ6F4KyrJwodQhsufCFOJPCTj4Lqm4zwnrmZ8J+GhfCfqqokXD8KSkJI8JCgqvCQjoTwkYqiPPCfqbciIuC8uPCen7bhnbNrJVwmKvCflbTNuvCRjKPDt3vwn5u30ahd8J+DmvCfm6w6PNGoNS7wkKO1CgRCAj4qChYKBG5hbWUSDkIMYNGoIi7gsL3wn6avCg8KCW5hbWVzcGFjZRICCAQK3hu6AdobCoobCgdjb2x1bW5zEv4asgH6Ggo4QjbwnouSJD7hrpE64LG+WeGLjvCRipY8JCQldfCRo788wqUnOnXigYMmRNGoJHZg6qCy0ajvv70KLkIsL2lvwqXwkZOVJfCQqLrwmIewS3tV8J64p+Copy5nYGA9IvCQpoM/8JCphmQKDUILcci6VuGpofCdqqMKOEI24q6Vayzwn4OGMm9Oe/CehLhW4LOy4YmMzbtp4rqEPyQgJOC6geG+sO+zrfCflbTwnrq54LaCCgtCCSHDtHUj8J2SqQovQi3RqPCdvJU8PcKlJvCWvKcmwqV7cOGfgDpBYEHwkYqIJsi6POG9leCoo0c9PUgKBEICJS4KSEJG8JCsokngu4Z1OsOfRfCflbRj76yy8JCegV/wkbK18J+VtOC3ljzDjl/wn6ukJWDwnoWGJsq74LCq4Z+zYS434Y6UXOC3hQoHQgU88JCigAokQiLgt58v8J+VtCIq4LOhVTpec/CRkJPgo7Twn5W04bOE2bs8CgxCCuCumeC1juqtuyoKEUIPKeCnl3vwn5W08JarniU/CidCJfCegKcuPD3wn5W08J+giOGpnVppJS5JPuGktiZU8LGRinvhnpYKFkIUJyZg8JG/pVzwmr++76Sk8J+VtFQKK0IpXMi6e3Ui8Jatn/CehYnwnp+k6qaX0ajwkJWIYiLwkbSDJmbCpe+/vSIKDkIML0TwkbS6OCbwkJ2QCj5CPG5vaiJf4Kme6pqkKVzCpT8kcGAicmgn8JCegvCek7fvv73igr17eO++ifCdjaXgs6LgqpDgt4ZJ8J+fqwofQh1c4Ka2YPCeuI/wkI+Tb+K2qeCxmTrgrp8v4KqrIwolQiPvv5zqkpx9XCoi8JGrnCFmKvCRjKw8OuCpnic6IuqsiuG/pgoFQgPCpSYKDkIM7Z+hwqVkO/CdlYx7CixCKnXgq6vwnrmCKiTisLwn8KqqqT3gq7tV4b2J8J+ckPCQppHIuuK3m+qmmAoLQgnRqDniirc2UUoKOUI38J6LuNGoP24i4LCOL/CRjLzvv73hpYAkKu+/re+/vfCfgbhbJzYvIkjhqKfvv73wkbyEe++/qQoJQgfgsZXwkKCICg9CDXgvXPCQlqPwkJ2FKHcKRkJE8JaqgTzwnoCj4rau77+9OsKz77+9aG/wn5W08JGnjvCQlbx98JC0uPCWrL/gt54/V+C0kD/RqHnhrIrwkZmY4KaqwqAKLUIr8JGjr/Cdqq3hvpZBT3sk0ag94Kay8JSRqG1J8J+FufCflbQu8J6An92DOwolQiPzoIeJ8J+isfCdkKZI8J64uSXgq5DwkK2uJyXwmr+98JuyngoeQhwnUTw98JCovzYk4Kya8JGSjvCQsqDwn5W0by54CgNCASkKC0IJ8JGnlXngs515CgtCCeqsrHsrOuCnjAosQiovSOCxjOCwi0Z48J2EkmPvuYou4ai1NDwn8JCglE86P096dCHwkY2LfmkKBkIE8J+VtAoxQi/CpVztn7JX8JGKjFI9OntHOvCeuZlcOPCRtIncteCvkDrDufCRtZXgrLnTjnMiZgo6QjgqL2Qv0agkSD0m4Kike1wn8JGMiy/hn5gl77+94b2bL/CdiL0/8J65lC5mOiZmcvCeuYfwkJaOKgodQhtK8J+ghvCvpa/hvbLwkZqD4La96qKVXS89P0AKEkIQRF/htJUq0ajwn4G38JGIiQo9QjvCpWA38J+qiD3DviovQ157JCJ06qyD8JOLqOCogdGo8JCGoEZRPO+/veOInlzgrppg4LCJ8Jy9sD4/PAoPQg1MLlzqoqk9OvCRmZUnCkBCPuCmvknwn6uD8JG2kCbvrK0xOuqosvCfm7c9PC4qevCflbR2LnRp8J+VtFwl8JGXicKsb+C+nEzwlquqJ1N1CiBCHvCflbTIuvCepZLwm4K44KuIRvCeuZRi4K6C8J6FjgoZQhcqJdGo4LenKeqsiVxeKiLvv6Q9cOCnjQo+Qjwm8J6fre+/hPCRtah7IipxXFU44KizWS/qq6Iu77OCROqpicKleyLwnZWAJ/CQlq/wkL+0JT3DtOGcrDEKLEIq8J2VjsKlI3Twnp+qNSXqlKXwnbyI8JGNlzzCpfCQioXIusOowqzwkKiWCjdCNWDgsq836qWqelsmPMK177+9KuCpi/CRpZLgra96PfCeuqdiw7bqr5o60ah6TPCQlrBN44aOCjpCOFxp4amoPcKlSzrwlJeWdSZGRfCflbTwkbWlTiRcXPCdlYbwnpOYYOC1jfCegJ3vv70n4aS1Jz8iCi9CLSVh8Jq/sick8JGLlFw88Jaqm03CpvCRjag14YujNvCQppB58JCuqnBrPCbCpQo2QjTgp4vwkaS4XPCQnrQs8JCRrlwu4raG35nCqMKlSsOaezDwn5up77+9w5kkKWAlZGBy77+9CixCKj/Dt/CQlbfwkYCT4bGI8J+IgOG9ouCtncKkKiQ1KuCtjNGo8JG8p0Y4TwpBQj/gs43wlqmVL86IOibihoMyPOCnl+Coq+GkqTzYiyLwnouu4K6UPcKl4b+D8JCWhy5B4YyV8J2VhiUl4aGGJiIKMUIv4LeC4KGEOtGoLiYl8JCWs++/vXtge+CvjH19MDsl4Kyt8J+VtO+/vSpcJvCRtLwKIEIeXPCrn58mQ0dB8JGbgSdhwqXwkaCGLmEuSvCRsaA6CiRCIi9cS0fDmnguNyxwXE7wnrmNLuC+iyc8fuOAnSTwlq23wqUKPkI8eFonZOG9nSQl4Lqd8J+Cty868JCGkXzwkb+E4KerLS464reY4K2HJGBKJ+GOhuChu+G/osOuRsOd4raTCgJCAAouQizwkYiP4KGeNMOSVvCso7xg4Z2HXOKtueCun/CTiagje2DwrK+8NV7wkLyzLwojQiHCpeGJi++slifwn5W0XDDwn5W0VsOp4K6j4LKqJfCegIQKREJC8J+VtPCRjYc8J2tw77+9JPCeurol4LGmXOKFteCrrOCotinhvZtcYHvihKvgsLzDq/CQgKt48J2Um+GylvCcvYR7CgdCBTzvrJN4CiVCI++/vcKl4LOVLm9OwrkmL/CRjYzgtL3vrLo4JU4nafCbhaQ8CiZCJFQl8JG2lELwnaCm77+9e++/vWDwnrq5XC4n8Ja/sOC3kuCpkQoxQi/wnaqcbTTgo7nwn5W0w7JrJfCegI/IulY9cD3IumYn4aqx4LOh0agn8J+VtMKlQApBQj8lJ0HWhOqhmmjwn5+pwqo/8JGgrsKy8JGlkOCsgSXwnoWHLyQ9Peqoj24q8J+WjfCen7jvv6U877mkOPCRtpYKMEIuR1pUJCZm4Y+8aCY/SyRd4ruGeybwkJWGKkhRIjrDr1pyR/CQoIhd4KGnPOGLgAooQibwlr6CJzwiJ+CwnfCfop3grqgy8JCVslvvv5s8IiQr8J64p1lQfgoEQgIiLwoHQgV9WjA+Ogo+Qjzqno498JCoqcKlZe+thCY9IvCeuqs9ZuC7n2DwkK2vYOC9n2pULGBi8J+VtOGpv1zgso9YwqVkXOGLsCoKG0IZ4L6M4LuDP/CflbQqZWl8aci6168l4aScdgo4QjZX0agi76y+T008RSIq8J65ieCyjl3wn6GR8JG1gj8lJzpE8JCEv+C7jeGkgyXIuuOEomAqwqUKKEImLsK/JOCwryrhnJXwn5W04YuWPMO8SCB3WOGXpS5H4aWYNfCeuKcKJEIiaeCmlMODL/CdhpvwkbSJLz176p+TUvCRo4om8J+VtO+/vQoqQijhoIEnPEcmLsi64KeIJkI0OsOJ4LOx4LOjOuKClDw54raTP+CjgD88CjhCNuCugsKle9S2b+C7ii/guonhjqIq8JGkt8i68JG0pyrhvZttPSo6PC/wnrmU4KunwqXwkKiGRwoTQhHwkZOS8JGNh/Ceuq89WnkscwoeQhw88JGEvfCav73qr5/Dq2DqrKU/4Ke+PD0v4KqwCiJCIEpb4Yq84a2Ge/CdjbTqrK3wn6qEciYqeyLvv7zwkYyCCjJCMHsq8J+dkuqsjF7wkYirLz1OdVzgqLLigZLRqC5z8JCKmPCQnqTqr7lnPeGqpicmYAoTQhFc77+9fvCRtZRGeyh78JatvgoHQgUmSuCujwodQhtpOci64YuA8J+VtDxXey8lwqVZ4KiH8JG0ki4KJkIkPT/DoCdlI9Go8J+VtDrgsqvgq6HCpSbwkIKRJzzIui5T4YiXCixCKuGKoMOcRDwyJOCrjOCtiPCWq6I84Kq/YMKlfSQ677+98J+vuVxq4aWqVwoFQgM9JHoKQ0JB77+976egRDpE8JCggsi68JGMs+Cqg/Ceub7tnrUtez0q8JGZpT09aPCQk47Uvn5STdGoZlwuI/CbhLLgtrPgvbwKDEIKO18kLi7wkKOnJQpRQk8pwq/qqZLwn5W0S+C6ru+/vT3wkLqx4Y2y77+9b+Cxq9Go26Bo8J+qp/CRvL4uJPCRtIQn8JCWkvCRpIPigJvwn6m2YPCWvIrqoLYk4KiyCjlCN/CWrZ9ILvCRo7/gp5cwQyTwn5W08J65kl7wn568LCooaCvRqPCeuLdcYD098J+VtEgv4KqRdm8KD0INOvCfiZE95JeAJXvCpQo6CgRuYW1lEjJCMPCRqKJ7PD/wkYy88Ja+mnEm8J6ln+Cpi/CRsLvvv71je3tDL3vwkZmp8Ja8kDwnJgoPCgluYW1lc3BhY2USAggECvUFugHxBQqhBQoHY29sdW1ucxKVBbIBkQUKAkIACi5CLEJuJ27wn6q/4LOxKuGdsnbvt4/wkYS2Oy97e+OIjFTgs6HIuifiuo3gsYImCjBCLvCRtpZ28JGklifwnYOoJW/grIJp4Ky2LiLhvL7hsYAkw5zIumjhsp3gsaHhnbAKLUIrTe+/vfCeuZdjJfCeuKI/P+Czs/CfiKbgspnwlquGJ+C5iWXwkJmWw7gqPAoHQgXvv709OAonQiUgw6I6YPCfiaLhkIhsPMKkLyQuUz3wn5W0wqXwkJ6EP/CQkYckChdCFe+soT7CrvCdi6NgJnfwkYKs8J+lsgosQirDvk7vrL5L8JCBhsKlbT8i8JGlkGAud/CWvLrgrZ3wkI6B4Ki2VvCQoI0KPUI7VSBT8J+VtMKlVS7RqOqdkjY68JCBke+/vXvRqPCRtIB7Ju+/vT7wkIecOiXtn4Av4Lyzey/grqPgu4IKM0IxUO+/vfCfobwuZu+shlYvJfCQlZMs8JCsgS4+P+G9ln7wkKmHyLrwkIaT8JC9sXdIPAoaQhjwlqm1OvCfoqc9Tzpc8JargeK/te+/vT0KG0IZXPCfoZI6P1g88JC8gizwnoCjfiUkL01+WAoYQhZycPCRjJAkw73vv7xUdXThn4nCpT86CjdCNT9m8J2dqvCRgq3wnrmwJSl3M86K4KmsQOGkpl9HYi/RqPCRhI53w7/wkKiXbfCQh5En4YmNCkNCQVs9YC7RqPCQrYPhrbbwkZmQwqUoP+KBtuCupC/gqbDwn5W04Zq/bj8/PMO/e++sk+C2geGJneCosz1M8JGNsD4vCh9CHdGoL++/vVI98JatkWUhPDzgqYg88KuegiLwkbyaChtCGS4q77+98JCClWZl4rikwqXwkpKU4YGPLioKEgoEbmFtZRIKQghZJfCQpIFnJQo3CgluYW1lc3BhY2USKkIoa3lr1o0lJXZ8PWDCpSngs4oq77+9ezfwn5W00ajwkLOA8JGCoEUkOgrrDLoB5wwKjwwKB2NvbHVtbnMSgwyyAf8LCjlCN2Yl4aiJ8JGGrzMvJXvwkICLOuKAnPCQjKLCpW/qpILCpfCflbThiZhtXNu58JGkqPCRk5jgrZwKGkIY4rqcSvCdkrUv77+9e/CstrTRqPCRnJ5JChNCEVxAIlbgp4xc8JC8s1XwnqWIChRCEuCqkS7wnp+jPCVgSTpy8J+qhQoCQgAKJUIjIsi6Z+C7lOG/m/CWrJTRqFzit5Xwkr+gSXp7XHI/PH13blUKNUIzL/CWv6ImReGqmPCflbREw4zgtrjgso594Lq98J2UklEkfvCflbTcpD7wn5W0dyQiJXsmChhCFmQueiPhnY4pcTzCpVku8J+qgz80wrgKC0IJ4YmdJvCeuLtwCi1CKz998J2SmPCeuqXgvofwkaKreOqgncO8aCLwnZK2JyvgppAmPDxjTvCQvIoKREJCIlpY4YyVwqw98JGcly4qJ+G8tVwqJktfdPCQoIjwnYyh8J+use+/vUxg4rODOsK08JCOjfCRlqQ9ZPCQo77wlquxCkJCQPCRtLo/JUzgs6Iie9GoKuCmiC3grYdx6pOkV0DwnZS98Jatlk3wn5+w8KywvD/vv70nKi7vv7188JGsg9GoJT0KMkIwc3nhi44+YEvCpS5lYi1XbyLgu4w9PSdc8Juxke+/vfCQo6fwnqGazozIujp1yLo6CgJCAAobQhk90ajhpbPwn6y18J+VtOC7hEdUWuCtnSouCgJCAAoiQiA3TPCRiojgrZck4KecYUA9ci7CuvCfn4vwkKi58JCtmwoyQjDwkIC877+9JT8kPTxgyLrDhCZ1JOGhs0HwkZmV4YmR77+98JGMgS8i4KqC8JC6sD8KLUIr8J65nTzIuuCvl20n3Lhc4YySyLrgtYYu4LeS4b+JKz1+W/CQqbBcJC5tcwoqQih1WPCbhaV1XD/DpFzwm4WV4aCA4b2dLz3hpYBc77+M6qyURmDwkJa7CihCJnLwkaS18J2VjSRKUOGku1w9yLo9bz094Kil8JC8gdGoPCrvv6YvChVCEyfgrp5cIj9Q77+9XFXCpSTgs54KKUInYDFp1ZThn5Pvv73vv717P/CdvJh9JuGjr3PDkeCrouCyg+C2mkclCidCJTZG8J2Bq+Cro8Kh8JGKpeCroSfvrqtRbDrwlqugSVzYiy/gt5QKNUIzK+CtqCZ7NvCQs6TwlqmzOO+/vfCWq6jwn4CWP+qvsk4nw789PDo83q0977+9SmDwm4WSCiNCIWLgu4Rgw7U/USdB8JCEgMKl6q+ZyLrRqCXgsYNl8J+psgoGQgTgr4ZCCipCKC0ke/Cdk4DCpSrhnKElPXtGPci6PfCRpZc0XOCxlSJ7ZSx58JGNp3YKLEIqek1J8J+VtOCqgyTqqoIow6NFRTwk8JGYqiUgL/Crnoxd8JC6q2Xwn5W0CkdCRfCRtYdcPCPwkbyN4a2d8J+VtOCmivCeuZ9eyLom8JCqhm3hvZtt8JCWlHc9KuqfkXfwnouxIj7qn4Ng77+9LeCxouC2tQoKQggs8J+HquCmuQogQh7wm4Wk8JC9t2DigK/DqFYl0ajDh/CdlYbCpcK9MCIKBEICyLoKIkIg76yU8JCArVwnImlC8J+JhPCRnJ178JCBhfCdlLvit5gKNkI0fuCqhcOd8JCkpS7wkoaswqVg77+T6p+WYeGgkMK14b2dfVzwkaeRJ/CfiYN78JCypeCuhQosQipmOMi66pSqR8KlOkUkw7ZBOjxF8J+VtEB8Lt6W8J2mnG1LJWcvyLo9JCoKDkIMTPCRh4nwkZmj0aguCjpCOCw84oW4cSTDnuCznSsgYNew8JGGiiTIuuGOkiLwnrmp8J2Su+CzgyrhvYhfXPOghpnRqGDgrZ8iCh1CG/CQkqjwnrmLKvCQlLbCpWhWc/CQvYJw4KaPIAoZQhc/yLrwnrm58JGyn2pc0ajwn5W04rSEXAo2QjQ/4b6hKnFc3YUkLuCxh1xZXNGowqUn8JGlgPCeuZsm8JGwgPCRsZzhpbImPyBc4ay+4b++CghCBi9c8JGDowoFQgPvt48KBEICQCoKJwoEbmFtZRIfQh1je3vhvbfwkoCSzowl8J+VtMi6OOG/gOK2oy99PwoqCgluYW1lc3BhY2USHUIbVi9qwqXvv71p4b+6I+Gpq2Al8J+qv1XwkbSDCtYHugHSBwrkBgoHY29sdW1ucxLYBrIB1AYKCUIH8J+VtD4/LwoVQhPwn4GQ4r+08JGMs3Yk4byvOCJRChpCGDZcL+GqotGoPWlG4K+BJk8mLlXDvsKlLwoEQgLIugomQiTgsaDgqLJrXDzhqoNc8JCKiOGhlsOiYEEl8JGyhyYqwq/vv6QKQ0JBSy7guoTwn5W0M8K2WCbcjDrdp/CRtIY8JFBo4KiC4LqC4LqB8J+fsFbvv73CpSTwn6qf8JCOjMKl4Z2uL+GckyYKN0I177+9Jj3wkKCAXCQ+76y8zozIui5M4L2C8J28piAnL19UXPCQlJpg0ajwkpCJ4YOH8JSYnSoKEUIP6qKN8JCVmXI8Li4qJDo/CjxCOjzqoLljPMi6Vi4q8J+prXLwm7KeZF/wkLOYZuC6tHJkPEbwnouA4Ke7VPCRjaxq8J+VtCfwkbCFJiEKMEIuKvCRlpnCqcKl8J64ufCRjYfIuuOHnz3gr5DgqZHgsI9uMjzvv7178Jy8ieqigAo/Qj0qVG/vv71X8JCgvFHwn528d/CflbQ8JTjguYHwkJKm0ahASfCegIXwkI2XJ++tg/CWqoM6zbp6Im/wkYy1CjxCOi/wkJaOWmLDmyPvv73gsapaIMOn0ajgrKvRqC484LGpw43gsILwn6CQ8JGSsHs/8JuFp/CRjZdcLzoKOkI4eirwkYqwL/CWor3gqrln4bO0XvCdhoTgqpUvwqw0Su+5suCwgtGoLjzIuuKBufCRlqjwkJ2je3gKKkIocPCwnZXgqZFqWe+/vS5bw6N7WG/wkaqCJj/wn6qI8J2SqScqwrQuLgoUQhJnLiJjcT9VPvCQoYXgsYDguZoKIkIgR0cvNDNzUeOHvCBzJjfitKdQ8J6kgdqZJzrwkaCEIDsKDUILcV0vwrThoJDgrpwKOUI3JDfhj7w+15JG05jgv5AmKirwkZaM8JCDl8KhJeC1q+CznjzRqOG8mSTivrjgrr84XEDwn4mjJwoxQi81LvCWq5vwkJaU4Kmb8JCMsvCRtIngpo8lXDjCunbhpIRR4LuK8JGMkC8kV+GLhAoQQg7qrIbgr4rDls6UWEXCpQolQiPwnrqj8JGAjvCfnYMuanvwkZGfVCdzZ2hcw718XCfDrTVEdwoOQgx777+94bOpJMKlwqUKVAoEbmFtZRJMQko8NUo94LKS8JGNiMKjX+qooyrwnrmJ8J67sOCmsvCQnq8t8JCum+GdsiFG4KGoKi9twqUiw4zwn4e16qmQ8J6ApD3wkKyg8J65hwoTCgluYW1lc3BhY2USBkIETl7CpQq3HLoBsxwKnBsKB2NvbHVtbnMSkBuyAYwbCjRCMvCflbThoKw44pGK0ahcJD8k4YyVLfCQoIV7YCXwnp+g8J6FiS/DufCdlIk+RW/gprJNCilCJ+C0iz/gqbXwkI22JEzhqLTgvKLgu4Qu4Ymb6qGk77+9yLrcryU8KgoCQgAKEkIQdeCzlS7hv4QvQy/vv70vLQoOQgxGdT178J65ifCQo7QKSkJI8JC6g3wv8J64ueGkjmssOk3wn5a5KvCrupY6e/CRvK5eaeqsheGPvPCflbTDiS808JCCm/CQurHwnaqf4Ki1LCfgu5zhvqYkChNCET9IPfCdjLPwkISC8J+JgFo6Ch9CHc6HP2Bc4oKWM+qsluqjlFzwnrmZLnDhio0k44aBCklCR/CRjYdq8JCKiVvwkKGRyLrwkYChQ+GKi2g68JGnmvCWvZY94LqEeT8i8J+guOC4rC4v8JCeh+KDnMOO8JGKiFxI0ajRqGAzCjNCMSUuPMKlM1Ths6nwn6CA8JCEsHMg77+94b6bfeCxlu+/vVM/Jci64YiYPSrgu4bgu4YKE0IRXFzCviLwkJisJyIiRCjgrKQKGUIX8J+Coj88S+Cun15w8JCohSJS4Z2lP2AKQUI/WWzwnZyg8JG0g1/gqqvgro7gs4jwkr68P13wkISV8J2SvXDwnriDJ/CflbQ1LtGo4LGdYPCThbHCpUbwn5W0CjVCMz0kWPCQrpvvv70zbjrwkYSMJ01xJOC7luKBsSpcPCdOJu+2mcKlez0kIsi677+96qyFRwopQifwnrmZ8J65svCQrprwkbCK8J65l/CeuKdc8JGEtifwk5GKWz0hYGoKKEIm77+94Z2z8J+VtMOJe3jwlrmNYeGlozp78J6ln/CWvZ/hvoFg0agKDEIKLlwv4K6aJsK/dQoOQgxSZPCQrqonKvCfm7wKI0IhIiTDs++/vci6yLrwn66s8J+fqsKh4bGjLjLwn5W04YuDCgRCAtGoCkZCRPCQrJ0kIvCRpZLvv71gTiQ6ez3wm4GPKibhvJ3vv5bwkKGUKlgl8J+Zr03wlr2+VPCRsYTgtbXwkZiYJ3vDiSjwn6GSChhCFjoifO+5tDvwkbS6fDrvuLB9RCngp5wKCUIHa8Kl8J+bqAorQinwkKC4LtGo77+9OiI7Ki5gbT7wn5W0XFwu6q2GPfCRiohdb9GoP+C2rwojQiHwlrmnYOG9mUzwm7KFJ/CRjZck4LCP0ajwn6yb8JGkkmsKBEICLDUKGEIW8JarieC7gUzgtpFB8JC9kCcy4rStOgozQjHwn5W035FmKMi6PiLwn6KnJOCtnS7wnrmd8JCukCbvsqc6LuGCoy89R/CQhbnwnrqhCj1COz7wnZem6qypJ/CRsZ8lNy468J+VtFzwkb+M8J+VtDxO8JGMt3VIS9+MwqXwkKiVWPCQipxc0ajwkIagCidCJfCQoLwnYGhYPGAvX+qlki40S13wn5W0Yyfwn5W0e/CeuahbTTUKBkIE4oCZLgo9QjsiOVvwnrin8J+ukSN7JCx3MeC3szo8J+CytyZwYTzRqHUm8JGXivCQgZTDrPCepZ7CpT1+4bKq8JCokwoiQiBeQOKFr+GwnfCbsbwqW+G+sjzvv5x8PfCRmrbwkZqvPAo4QjZc0ajgq4duSTw4TGJ74LqCLfCYqbBbPz/wkKmAyLrRqELwn5W08JarslVgdO+svvCQlo3RqDIKHUIbOmAl8JCetuCnouqWtDI/4Yqn0ajwkYOAU8KlChtCGWzqn7lcXuqlvCJhSeKugvCegKpZXiLhqoUKDkIM8JCplH57QO2fscKyCgNCASoKLEIq4LWe4LCAJc29RW9f8JGFn8KlZu+/ve+shD/hna/wn5W0PtGo8JCSpsKlCiJCIFzhhLHwkJ6s8JK+rVzwkYyIfFzwkL+j77+9QvCeuZk9CiBCHuCmii8kw7YlKyzDmsKlN2B4yLoq4KeL4KuE8J+VtAoIQgYkw6rvv70KPEI6aeCosOC1nmNv8J+bonvCpfCRjaN7L3smPOC+sz0i4reVInvgrapz4aGy8JGkifCWv6Lwr6ahKlcqMAo5QjfwkJaMIj8/RuCsrPCflbTDiDXRqDzvppdcPfCRjIjCpSYvJVw63LXwkLC7ZjolWHvhq4lg4LeWCiRCIu+/vWA88J+VtGg6yLo/4oK7WC/bun5L8Ja/sMKlaj0kdjAKGkIYYD8x8J65nypcIvCRpLvwn6uY4aeS6qWuCiRCIj3vt49r0agqe/CRgaXwnrKlyLrDle+/veC3hequr/CWq5AKN0I1YMOdSPCetITwn5W0X+Cnuy7wlq2x8J+VtOCymO+tgT4g4LKO8Ja+gSfgsZngso/wnYugWCUKQUI/cMi6yLrwkaCQLu+/vfCQh5rwmr+y77+UJiXwn4mBU+KBsGDIunskQe+tpj3wlqmeLPCSkofRqMOULi5GJjA/CgZCBOCotk0KL0Itwq88e+CohuCmsiYv77+94KOE8JG0vOCskDVB8JGpv0068JGIuzw/bsKlO0BpCkNCQXMk8J+Em3g88JCuqvCRnLXwkbuv8J+VtOGKjUEu8JGIvD0p77+94reGNjHtnrom8J65m8i6YFQ9afCRhL5c0ahEChdCFeCzjM28PeK0p+G9kOGMgvCdjbQidAopQic/KfCbsoE8VSYxe8KlOtGoPF3gt4rgsIEkPVpUyLpjJz/wsJqlPFEKE0IRIn7wkISAL/CeuaF98JG1omQKB0IFXOC2jHkKM0Ix8JGmofCbsoBcdPCQirbDpu+tg/CeuaTDmvCeuLkuPGTwlqmFPeCsmVhWI8Kl76y+LgoOQgzwkY2m8JuGil4mUn0KE0IRfS5gOu+/ovCQqYJL4KedwqUKPEI6YCk9MGDwkbS68J+bsHvwkJa48J+VtPCeuYIv8J65gj/RqD3CpeKCjsOL4rq5YDpgVD1X77+9PzzDtQoUQhLwnrmqLfCRiqhp762BJFzgs4YKTUJLbfCdoK7wkK6v8JC0tTxm8JCAgOqcqNGo8JORgcOX4K+o8J+Cu8i64oCIbCTcoWzhpYA1IuKEl8i64b6WLPCQpLDDu/CRpKjivb9LCg1CCyrjiJgqJvCfq5JJCh9CHeC8l2E66p+YaifDhDovJT89fD/RqE0/Li/wnoKPCj9CPWld8JGwhCQ9fD8mUGNTJfCRtKzgrIM24K+L4oKb0ajwkKCfwqXOjFPgqZvwkJa8P/CflbTwlr6Y8J+brHIKAkIACh1CG3NOwqtQ77+9wqU98JGwu+OGmkhp4K+Q8JC5tgoNQgtgJy8ieu+/veGmogo9Qjvhp7bwkYyqOj3hoI8vP/CRtpHqp5InWibhnKjgq7ovOOCtsvCflbThi5TgrZbgoYA84Ky18Jq/sFXCpQotQivwkKeFwqXcr/CQnrhk4KiY77+9e8i6Lz3wn66DIlbvv73gs5XhoJLvuJdkCjBCLjwm8JCprjoiL1/hpKc34KeH0ahU8JG1qOCnoCJ7JMOIJ/CbhZV7LyfDkVEkR3sKMkIwLvCQvJJceSp7L0Ym8JapqOGdjyJw8J2Rs1hYU+CthyU/UDInYHjgpp0lL+GJokNgCidCJfCfj6Je77+TYD0qfvCRmozgtYfIuj8kJfCdlL3wn5W04Km0wqUKEUIPLiXIuuK0rcKlJHBTZiJgCh9CHSRuYtaP8J6Lv/CRjYd+IntF77+94LuC4LevQTcmCh1CGyrgt4rgrJ3gqpfgqoXqp4XRqDrwkISAPV/IugoUQhLDk/CWvJLwrJG68JCBnPCdqpsKNEIyPeGDh8OSJ3vwn4e3wqXwkY2I8JGxhXHwnrii8JC/ouCorWXhv7jqn5HvrJfhvolaXFwKO0I5YOCxgcOAezrwnrmdWPCrnqDhvaA4fmJG4YmaUn7wn5W04KqzRTnhspkk8J6Bmj9g8JivpzzhorAiCgJCAAobQhnwkKGsKuK3msi68J+qrzwm6qC44LaBWDomCjBCLi/wkIag4a22KuCtgCcy8JGBsyfCpfCQhIHvrLlW8JG7q8Kl8J65mzIhImDgpoAKFkIU4b670ajwn6ukyLrDh2vwkauKwqUKLEIqMvCRjaom44e2QfCQrJRCIkBTLnAx8J65n/CSkbLwn5W04LeyUC7gupxdChdCFeCsieGmq/CWqad1cSfgt7Qk8JCcjAolQiNeX0A9J2vjgInRqPCWrbNg44CFevCeupTirbfRqMK3fiJ3egoxQi/grY1TTirwkKC44aWz8J+rheqlvGjgq5DRqOKCr3knPuChqT/wn5W08JCEgDM9ewoxQi84WzFD8JCplXgvyLo6Jci6XPCQi7rwnou/ZvCfm7YnbiI2YFzDmfCforDguJUiVAoDQgEhCkpCSGAyKdGo8JGZpPCflbTwkLKw8J+bqOK2vFTDq0Phqr0nL/CWupbvt4/wnrmHw5jIuvCQnrhg8JK+pibDgvCflbQ/KfCflbRBKwojQiFbw7J5PCoq4LmA4Kef8JCdoPCWrIzwkYGE4LeKw58me1oKLEIq8J2LivCQvINg8J+fsOGeiPCfq6Jg4Y2WPS9DXEQ98J2VgfCQqYQ+P9GoCi5CLEfIuvCflbQmYDLwkai24aWAPy578JCsuXEi8JCSse+/vTnigLhcPOG9mcOmCkkKBG5hbWUSQUI/4LmGKu+/pSQ/4KaQ8J+VtCTwkZChPF09LzDvuajgp4gq4KayJFzwm4KYdS7gq4fwn4KzSfCRpqY/4bGWJlxCCkcKCW5hbWVzcGFjZRI6QjgnK/CRhYVD77+NJD7hvoThir3Xr0HwkKi6yLrwkJq3O+GmhXsw4reL4rec8JKRtOCystGo8JCWvAq0FboBsBUK2BQKB2NvbHVtbnMSzBSyAcgUCjJCMDs98J65j33jgqvwnoqiUfCWvp8pfvCbhZVV4LGELkV7yLrjgKXwlr2c8J60puC6hAowQi5Z8J65vuCzoEMv8JCSpfCWv7Hhna7wkLSY8JG1kcKldPCfoIE+wqXwn5W0VcOhChBCDuC2vfCRpJ4qOEFdIsi6Ck1CS+CrkD3wnrSX8JCVsPCRnJJW8JGDoTzqn5ngtqfwkKCE4raq4K+r4LaBeVDwm7KGPC/wn5+i4LCI4Yuz0ajDvTfwkI+N8JCdotGofAo+QjzgvZXgs4ZgYPCRpJY8cPCehLc8JDzwn5W0ZT/gtLfhpKk/PNGo4KuvJPCRprrfqjtbJMi6JMi6PfCflbQKG0IZRHXwn6S/yLo6Oi89cEjgqJDgsJAk8JGYrAoPQg0qJuCur2Lgu5TwlqqTCgJCAAodQhtf4b++PiVc4KGp8J6Am3vRqPCdlaxLQXslUSUKHEIa8JCplPCTg7YlPPCen6PgoZ7enuC6sickPDoKG0IZWci64YON8JCjoic6OvCdh5HwkI6fbOqtsAovQi3RqO+5mSLigb89JT9cYFUh8J+VtPCRg5d7WT0u0ag88J2qqsi677+9fvCRpL4KPkI8MF9Ze3ktS+CnnSXIui46Ju+/vWdg4LGabvCRtIki4K+XJfCRioTwkY2Q6q6QJDzRqNGoe/CTgrvwnriACjZCNPCRmK3wnrmOfGBGXj0w77+9Oi4n8Japp+CovCR08JCAvXjwkYS54LmF66W8J/CegKPhg4cKJkIkLfCRsrPwnoSX8JGFl+qsqPCflbQkw7J68J2QrPCeubbjhKU6ChZCFCXDtu+3j/CRjazXl9WF8JC0s8i6Ci1CKyXgrLNc77+97Z+oKiHwkbS84rSF4LWH8JGNn9GoLmgmOirwn6Kx4pGJW0cKKUIn8JC5rntOXOGwgMKzJNGoJ/CQurAmwqUl77+9UTDhpLkn4aCm4KyQCiNCIfCRsYXitIfgrZU/8Ja/sO+/leCoq++spyI64K6pLirCqwo1QjMk8JCPiFgn4Lql1YTwkYiKNCdgRuGJkidi6qq66qiO4KGe8J+VtC9nL+GgrcOG4YmKe0EKDEIK4KiC8J65hydnPAobQhl7yLog0ahHYHfhoI/wnqWQci/RqPCRpIlgCgxCCi7RqOCumfCRiosKGEIWLmDRqC/RqPCfgIfgupDCpS7hj71SPQokQiJMXOCmrfCRnKk/JibwnYSHYFzIumBcU1thwqfqn5PwkYiECjZCNCbit5LgsYfgs6gi8JG8nfCQlrxERvCeuq1sKCYq8JCSpi5nbvCdlKwz4oCm8J64ty89WCcKMUIvYHfDhtGo4b+lP0zRqFEl8JGKtOGNvGDgt5bqrIt7J/CdvI468JG1qOK2seK2km4KIUIfYOGPu1wi8JCdpXo7ayJjbyo9PVzDrUxoLyovTDtcLQoXQhUm6qOW8JGkhUkgWSfhprZj8JGNnS8KJkIkasO18Jatt1zwkKCRL/CRtIHqqK7hiZBY4LOz6pmHPCIn6qykCh9CHXvwnqOVPOK6gWAqPNGo8J65p1xyR2Dvv6Q/VMKjCjdCNT/gu5/wkK2G8J+VtPCfn6hc44C977+q8JG8k/CRsbA/4Ym/JuC6gWEi8JGxoiRmNfCeubd+Cj5CPC9g8JCBgeC6hyTwn4SP8K2lrXEiLuC9ps6b8JCghWrvupfwkYWpRSgle+GatuCxgPCflbThvYsnUGA8SQoKQgh7JlXwnYyFfgo6Qjh9Lj8k8J+VtMOl4LaBw7ki8J66hD3DhjpCbeG+gvCQtLfwkbWnwqXhp58qP3nwlqyX8J+VtCswLwoMQgo/8J6lk+GcqS9bCgxCCuCssiIv4K2XWyoKC0IJ4Ki40ajgqrlLChFCD+GltC0lJyTwnYinwrF7LwoOQgxr4LOib3sk4YKna0kKEUIPw5Thor0w77+kIvCeopFxCjVCMyTvv5t9VfCQo7TCpVTwkK6r8J6Lmy1uVuG/tPCRgr974Zyy8J60sPCflbTwn5W08J64uQo3QjU8LypndsKlOj3wkKCEKXUlPDQ/4K2V8JG2lPCei79EJvCeub7wq5Ou0ajwn5W08J+VtOC3lgoOQgxkTCcnP/CflbR8SF4KJUIjez0ufPCRmaEvL2BaP3fivaY7b2Bc8J6LhFHwkYqCVeGmsSYKIEIeOTk9bT3wnZKUNsKlJybwn5y4ePCRsq3IujouP0xvCkdCRSR5X/CflbRC8J+kq+C8qSzgqYfwkb+fUDTwnrqYPcKlQPCQp5/hoJLwkYqITfCdqbHwkYqo0ah78JGnpHsk8J+qiH0qPQoQQg7wnZe1XOG+jyHigbd9awoMQgrwm4WnLm4q4ZyQCiZCJHsq4Ky5Kirwn5W08J65r3puJvCwmaTit4LRqCoiS/CQlrsmJAoLQgk576y48JCuqycKL0ItX/CRtYN0Ij8uZPCflbTwnrux8J6lmcOqPS8q8KugguGdsPCeuaFjKTrwnoCSCglCB2cqJPCdkp4KKkIobu+/veCniPCehY9CX/CRjaZV77+9L+KCkyUkQeCzjfCflbRXZkskPAoTQhEj4LOucnPwnouW8JK/luCsggoHQgXwnrm+LwpDQkEnyLrwkbCLZ0x7b0jwn5W04LONw7PwkJCkRu+/vcOLe2JJ4KyP8J64uSph8J2Fru+/vTPwnoGpPfCdhIw6WO+6hQopQics8J+uriZcNzMmWUvwkKmGLiok8JCWj8i6MPCfn7A94LOd8J+VtGUKA0IBOgoOQgzwnricXiXwn4OWzowKFkIU4a6D8KufkeGdr/CSkbInP/CwuoAKD0IN0ajwkaSD8J64p+GKigo/Qj3gpqzwkJOfMyrwkJ63VfCflbRP4LeT8J+VtGAk4LKP4KeNZF3gtZYnKu+tgNGocCVcPPCdlJngrLJdIkNVCipCKMKl4bKDL/CflbQnKuqsg/CflbQv4LuS8J6EnyLgrbNhJDTgs55VREsKN0I18JGMtvCego9gYOCpjDHwn6+58J65hyMu1o5z8JCGoPCSkbJYPOqhmCR3KjnCpvCfnJ0iPFUKAkIACiJCIPCRtoox4LeKPE7wkKySd2BgYOGJpuGdr/CRh6FM4YONCi9CLT86Wj9WYGBf4Zqg8J2UsPCQuqx+b3A88J+Equ+/vfCQlrjwkJ2PP/CbsoPDpQofQh3RqCQ6JWBgJOK6osKlOyJ68JC6nj0rJOCwgDZgewooQibwkKaR6q6jJDztn4F7KeGxvci68J6is8i6Jj3RqDxSVFrwnoCVLwoNQgsqcnt0X8Kl8J+ptgpBQj/Cu+GLgGfDk/CeurbRqO+suPCWvLXwn5W08JGZlz5g8J64pCDwnZKiYWnwkKO08JCLqy7CpTXCsmzwk5GSyLoKGEIW4ZunQFzwkKe58J64pPCdk7NT8J2Mjwo6QjjwkYuzK37wkK2JImDhi4AkPeGLgOK2pmDIuuC5hvCflbQ835Aj4Ki1XCXIuiTCpSLwlq6BJuCsgwoeCgRuYW1lEhZCFPCdkp/go6c/ZPCeuZtcLlTCpci6CjMKCW5hbWVzcGFjZRImQiQ/PfCeuZfqrKI/fUjwkbCVV+qfky3gs4I2SfCQvYUz8JGCviMKih+6AYYfCqoeCgdjb2x1bW5zEp4esgGaHgoaQhgqOSU68J2Fgzzwn5W0WDzwnp+t8JC9tyoKDUILO1dPOl/hjaZrLnUKCkII4Z2vNsO9L3EKFEISMS48UEck4Ki2OuGNmMKlfi89CjlCN8O48J+Dm+CsqyJcyLolMPCflbRu8J6TnMi6WtGo8JChjfCegIThpJB+PVxvScO7wrTDuzfRqCoKMUIvSCnCpTI68JCLodGoRTwkMvCQvrVqfFkuWyVOOu+kuyHCvyI/4b2TWSU/Y/CRkaEKGEIW8J66rz1RyLrDp1Mlayc04aKUXFJgPQozQjHCpfCflbQ8LiTwnrix4KuQUnBd8J+fqUHgqLjwnoKP8J65u0bgt5rzoIS2OiVgZVw/CkNCQfCdkqUu8J6LhuGnk8i68J+VtMOlLzdr4KyrO0BTIkXwn5W0ak18Q/CQqI5h4YuAwqXRqH7wnYyl8J+VtOejpmVSCipCKD974oGMPTzgsZUuIiEv8JG8gjbhvZ144KayZC978J+VtCIne/CRkpAKM0IxfFRV8J66tVAmRSLwsI+QWeGclOG/s3nwlJSlS+GJk/CQpL/hn6dPVvCdvKg/77+9ewoLQgnwnoWOLvCRjYcKQkJA6qGaafCflbTwlq218J+VtGPigoxw8JGFgu+/vWLgvrfgu4hMYuqinfCWo75pbfCbspEoafCehYk64reb8J2SuwolQiPgqIXwrJmPIGV7LiTCqX3vv73wkIGBJ+qqjnku4aGD8JCMkgo0QjIq4KyJ77mbRi/wkYywJDrCpUzguoJtbiYu8JGMj++4iGDCpVbwn4e58J6Ai8ONW+qZlQpGQkTvv73wkYqAzpHwnou/WD0tP/CSkbFyJntCWOK7lX7CpfCRvITwmr+4JvCfnJBYJeK2sOCqjPCflbRc8J+VtOCwmSrCpQouQixnWvCYtIXhv486bWti77i24YyvT2gm4KKKcybwnrikd+qSovCeiqnCvcK4JQpQQk7wn5W077+94Y6C6pOzYMKl8J6yh/CdkrtkXPCQjIDhraLhiY3wnZWGwqHwkKC8L+K1sPCRu6IhU/CQgIA0VOCsuPCQjazwkaqyPFzhsbIKHUIbMsKlWGlLyLpg8JCUhz01PUlXL+CusPCbsbg/CitCKeC4rMKlIyfgroY84KuJ76qo4oCi4KKG8KudvS5gPfCXk4PgrqritqR7CilCJ/Ccvp3wn6+E8JuykvCRvrDwkKC3Tlndu++6juC7g/CQgYhn8JasrgomQiTwkY2N8JChjS8v8JCWu/CQhqDgtoHwkJO08JiKi++/vfCdhKkKDUIL77+98JCBhPCRhJcKFkIU4Lep8JCLsuGlgDzwkJOC8JuynWAKPkI84KiyOiA2w5jwkL+JSGB3YCUlZyLwkaWYJvCdi4Xwn6GR4ryD6qG1LeCxqi/gtr3gp6zvrJQkJ3PgroJ2Ci5CLCd0J/CRmaXguqXwnYSUdvCRkJPgpooq8J+VtPCqp7dJa8KvRyTwkLyg4K+GCidCJVzgqoN08JCejO+yvGRYZuCtjMK38J6kgFwmYPCdmq09dvCQsosKNEIywqVcKmkiTvCRkZ9D6qCzOuCrjCbwkYqIyLrwkIuiPyfqm5XDmGXgqZ5a8JG0usi6J20KE0IRQfCXm64p8JG2l2974LWIw6MKI0Ih8JKNr27RqOu5tM6XKXLgrKvCpU7gqpBcUPCQvbPwnoWHCi9CLV7wkLKN8JGIsiotS+GJiy5ceyovXVvgqqTgo5/horbCpW40ePCRjLJUPeC7jAojQiHwsZ2WyLp74Lef8JC0t0BwPybwnrmXaeK3hSQnZVvRqCoKEEIO77+98JCtv1xdO+Cwjy8KQUI/6qyu4L+DyLpT4aOR8J+VtGDgqLx08JCgvCJ7R3QvOuC6hG5Xw6bgt5rwlqmO4pi3wqXgu4ZWJlzjgp7wnZqtCgJCAAoxQi8vWSVdwqYkUPCfgbNgPSnwnrmZ8J+qgNGo4Yyh77+LIkA9PUBQKipQYCskeyt7IwopQic/JeCukmh7IFzvv71T76y4YOCxrSozWeGKi+K/uFHwkIqr4aSSeyIKOkI4yLrwkYGrwqVX8JGMvfCQoa8zJ2DhiYzqn5PwkJ6AIlfvv71cZOGdhTwlXHoz4b+E0ajwkJyJXCQKLEIqOj3hvZVgXPCRjY1l77+9JntcZCohw7Dwnp+t4oCU8JC6q9GoQSxS4KuLChhCFvCfoIYxXDbwnri1L34qcSwi8JuBkD0KEkIQ6qewWe+/vXMn77+98J+DoQoLQgk6V/CRspXIujsKA0IBLgoCQgAKCkIIKjLwkICY0agKN0I14aqj8J6AqERa4LGqVzrgvp7wnrmZ4Y6IPW9QbNGo0ahJXCTwn5W08J65n/CeuZ0uNyLvv70KO0I5SDw8avCdlJdSwqUm8J66mO+/vXZQJeK3kHdP8J+um/CdlL4/LHvvv71uRUDwn5uq4LCsXGNO77myCipCKO+/vfCQpLfwnria8Jy8s+K3ijwu8JCHokvvv73hn7cm8JG1geCylT8KOEI28J65j/CRmrkvJiIm8JCYkitPKOCpkS/wnqKk4Ki44Ki8JvCWrZ7wn5W08JGBr/CWraA+LickCg1CC0nwnoCVPOqhlXsqChlCF3s38JGnoz3vuJNn4KqC8JCguDHwm7G3CjhCNuqlpeqmlCLRqGDwn6myL/CflbTwn5+oKuCpm/CQlIcnwqXYiuC3gj/gu4Z4RE5dXOGtk0RdKQojQiEkYOCxofCdmYYuIvCeuYI6JOG9mXIl4KmRJvCRp6MzyLoKEkIQOuCijPCbhLJcaiYu8J65iQovQi0nP+C+sS5v4rSnXT3vt4/goLnvv70qKG7jhIY/e0JT4Kay0agm8J+lv/CRsoMKCUIH0agk4YyQXwoTQhHwm7G7aFjwnoWB77+9w4nIugpEQkI8IvCRhYM98JuFpiAgfPCQvrAs8J64tfCRv4LIuirhjqvwn5W08JuxjCRgLidcYeCsjPCWrZ4+8JGEve+/vfCeuqwKN0I1auCnpvCflbQk8JC8tWDwn6qCJOCqkFJie/CQlpjhoInlqa/wn4OJ77+8O3hdeTFbLmBMPHsKIEIe8JGIvybwnrmi8JCtkvCeuqjCpSXhppw8dUNg4aa9ChVCE8OkJyLqrKUn8JG9liTwnrmJ1qEKBkIE8JGkjwo8QjrwnrqhyLrwnoqU8J+VtOCvl0nwrae+aiPiu4LwkaSJ8JG+sOCpnlVmN/CRjYMl8J+rjyQmL0jwkJa0CiZCJGvwkIqP8J2VhuCxnfCRjJTwq6CL4LWKJ3nRqCVQyLpHZOGJiwotQivgs4zgoLjwkZyWPPCQtLDvv71de+GlgMKlbiUlM3Ai8K2SsG/hqqtv0ag9CjRCMifgsr53JnE88JG9hPCfq7Y68JG7sfCRtYQuJTom4b684YuA4rWUJzTwn6qIw4rwn5WBCg5CDOC4hCZLfSJY8JGshgoEQgI9JQonQiVcK+GboCLvv70rPPCQurAwIjrgqZnCpVxN8J+VtPCQlrwxyLpNCjRCMvCflbTgrplQKjxa8J+VtMOgWjzgt5toYOqgme+/veKkjM298JGwkDNhJThG8JGrlCYwCixCKvCeo5Hgq4glJiXwn6mzP/CRvJddJuCsmCfRqGXwnZK7KWA8XD/hiYtLSwpEQkJc4Ky14b+48J65kuGJm3vwrYqDJ+C7nD3wn4mRb3tSw5TwkpG08J2qqeGTq2zwkL+E8JCehPCQgZJx77+98J+VtGAKCkII4YmYN2bhi4UKB0IFPyXgspAKA0IBLgo4QjbgoaDvv70lJMOuZjJMUCMlJ/Cen6MvNMKl8J67sSUu4LqQQCjIujslJuG1mMi60ajiu7PDtj0KKUInOvCRlog9UzxccPCRvrBI4KqBKz/DrS8uPColSj0l8JGDlPCQqL8uCixCKjpP0ajwkIq98J+VtPCRtpPvv70mJequmS7wkbuo8JCWs/CRkIYk77+9UAoxQi/wlquHPDPhpIsq4KeX0ajig5t9Pci64reA4KeXP0rgu4Zt8J+VtOCmrPCeoI0lewotQivwkJ6h8JCWpj3vv73coj/vv4TCvuCpjDwu4K6p8JGkvvCflbQkNy7huKgoCjtCOXnwkYOAUVPhvZN8e+qnnsKydCfvv70l4KKz77+8MT1gwqUmdfCbsp1jTuCtiHM1b27gsaIk8J+tnAoaQhjqr4c68J65i3ZG4raQyLpB4KSAbvCQoIgKK0IpJsK9PUnYlzwwQibvv73wkL2H8JG2ovCQrq8kP9Go8JC5tDrgp5zVoC8KLEIqNeGMoio8bHLwn5W0J+CosuqvssORZD0w8J6ApCTwkYOB77eP77+tyLpWCiBCHkbguojwnZqewqVXJvCflbTgrYzvv4pX8JGEkOCysAoqQig5NfCQq4fDl0snwqXhqqbwkKCA8J6fvPCfiYJj8J+VtCLksIkmUsOkChRCEidRJzzIuvCRgKUj8JGBr+qZowo+Qjwn8J+GhuG/tPCfqYpq4K6eYGU977+m8Jq/vSc94a+i0agl8JGMr9Go8Juyg3Mu4KGiSGzCpkF2IvCegYUKO0I5e9GoXOCyqMOS8J+VtCo94ZyrLyTwm7Kc4KGeLmFwLO+/mvCeuYdg77+9bCLhjK7wn5W077+94K6ZCjxCOi7wkY2hPC/RqC3vv71EeyXvv71C4K2We+CorCRgWWU5L+qskT/wkKGPL/CdjIDihrLwn6CvOsKlZy4KCkIINOG9nVzgt6YKLEIq8JaopPCRpJVhwqUkw5zgpp3wkZmgIvCWrZAu4rarTOChqeGtnyVcJTQhCipCKE8/P+CuglTCpTpgXPCSkbNg77e0WPCfr7bgrZcp8J64gzw9Jy8vwqwKGUIXe+GSneKCuzwmPO+/vS7RqEzvv5TIum0KLEIqaVJlPNy+8Jatne+so20iOnN3Lu+/ve+/vci677+9SDor8J+JgmJt4Ka3CgdCBSp16qmVCixCKu+/vfCQpJ/IuuODm/CsjYp78JGBl8KlLfCfqaDwn5W0yLrwkIaNIeCxmApFQkPRqO+/veCmsMi68Ku3heGfs/CflbQ9JvCQloPwn5W077+mwrc9LCd6yLoi15/wq52kXPCRgo/Dg8i6Ly7wnbynQjwmCg1CC/CQvJ3wnrm5XCUvCiAKBG5hbWUSGEIWYOCykCpze+GJlmdgKmbwnriAwqVVVQo1CgluYW1lc3BhY2USKEIm4oGwcyrwkJa7PS/wkbaUaiMiOyZaKu+/vS9gw54mw6dQ8JCAr2kKyQG6AcUBCpoBCgdjb2x1bW5zEo4BsgGKAQonQiUiLuCuo/CflbTwkKas8JCni+GlsuC6h+OIkjrCuMi6buK4s2M3CkJCQOG/vuCnnD8k8JCohmcudCQtafCflbQ8VOCpgfCWv6LwkIWKJVvwkKux86CFieGLheGXjS/hirMiL++5ssK0w74KG0IZ8J+VtO+/vfCdkqIvXl3vv71VPdKqTEDRqAoVCgRuYW1lEg1CC++5m+qbtibwkb6wCg8KCW5hbWVzcGFjZRICCAQKhQ66AYEOCskNCgdjb2x1bW5zEr0NsgG5DQoQQg494auIVNGoPeCpntGoPQoJQgfDiPCRnLc/ChVCE9Kx0agiOinhv4rwkJSjQifvtJoKBkIEYD86XAomQiRv77+9XC7gtrZ78JGpljrvvp7gorovbFvitKdw4KeL8J+ggE0KAkIACjxCOu+/ve+uu+CnnCUvaS7wn4ixwqU6YO+/vUl7YiPhm5/CpfCRpLvgs4DgqaYwUkd3MeGkmjrvv70mTCQKL0ItXGhHI3s18J2LqU1gJTrqqpbwkYyQ4Kau8J+CqfCRsbx8XPCcvInhsZjhv61VCjtCOVAnwqXwkY2y8JCwlznguIHCpfCflbThj71LXFTwlryrbci68JGkljx8MGt48J6AoOC0jnY0e+CsswozQjHgs7HgrYsiJHPwn6uyS/CQgZBxyLpBa8Oz0ajgqIbhvY0mZO+/vSfhvrpRPyUu4rSUCkJCQFHXoVjgsaY/JUB3yLrgqKsm8JCVme+/vWEq77iO8JuDkPCRg5pc4Ymc8JGRnjp66qGU4KaK4L6A8JuFti/qrJMKA0IBPQoPQg3wkLOl4aCycNGo4aKVCihCJkHwkY2X0ajDjUE98J64uci68J2im+Cojyfvv73fn1DIuj0u4oK1CjZCNGLitaHwkauPwrjbt82+8JGyrSrDsvCfiYXwkKC8QMKlQPCflbRBUyQkIlIkKOC1h/CQq5oKEkIQ8JGKi1U8P0PwkJ2E4b2uewo6QjjgqIXwkKGAWjt74LqzOk5uYeG9mS7wkKic4LOKyLpgwqXguoHgsJ1F8JCMmm5gY++/vUNI8JCUkgoqQijwn6ui4rStXUNRLzllwqVQ2IY88JGKmSc9XC8i4L2aYOGkuToiXGAuCklCR+GlgPCRpqct8J+VtOCrhyJcJPCRhZE48J+VtFTwkbS6On3wm7KBXPCRp54v4K6TL3Y88JGIkeGJjTbwkIaVPfCRioLwnqWXChxCGmBj44a74ZyjPDol8J6Cj2zwkI+BYO+/ksOcCjdCNXVW77+9P/CQnZXwnruxwqVSQEzvv70qZSdnKuC0j088e9Go8JuyguGns+ChjcKl8J+VtC8/CiNCITov8JGFlPCeuZ12Rl4l4LGVP2UvJkXhnYLgrYsnQj08YAozQjHgoLLIuiLvuavwkbS6Kz/gtbFNw5QmzpbgsYA6PeC8lXtQJvCYgKIqIi7wnZGmLMi6CiJCIEJpPzom77+98JCjteC0sdGoP8i64LOM8J+Al2Dwn5W0CgtCCfCWq4jCpSQ/PQoNQgvhrb0vUF3wkYi3Vgo4QjYu77+9Lzbvv63wkb+xci7wkpGQ8JCumfCQo7QnJfCQgYQi4Y2wLiJcc/CflbTwkZyHM08iXD0KC0IJ8J6AnDfwnrmkCg1CCz9GyLrwnYGdPWAgCgNCAWAKG0IZ8JG0tTMz772xMeqfkfCWrbNM4pGE8JGkggoCQgAKGEIWL/CQlrtSL+ChoELwnrKc4amx8J6ftwooQibwn5+B4LqCPSbgs57wkK2V8JCFrFRnICoqfEsuTm1Qwq4m8JGKiwpBQj/hi4nwkKC877+9deCqr8Ose++/vSonPfCRh6fgs4vwn6GYPeC2vVwkJ+qoseCqsEHhiZPwn5W04LSX4aqVXHUKKEIm4LOVOz9fInw2e/CQgKDvuKHwkKCIMsi6w6llP8KsTGnCpUjhrKgKCUIHWHsk8JarggoQQg57KnJhJeKBheGbi1ciUgoWQhRl77+9yLo4LDBoJXvwkJa0PeqbsQopQifwnruwOFxZ4pGBWPCflbThjZI88JuFlTph6qieIuOHviJg8JGylFoKIUIfKvCeuLvRqPCRpILiuorijIQj4LGa4K6SZzpc8JGMsgpEQkLwn5W0wqhgw4rwn5W077+98JG0vO+/vSdOSC7quJHgsYvgrrjRqDrwnriAMiDwkZqDP/CflbTRqPCfq7EkJnHCpTwKGEIWJyZ2wqVNw6fvv7098JariDw7XHt7JAo2QjRZ77+98J67sU0/4byb8JCAveCuguKClGjRqO+tgXtgJPCdkqZqInM8ImIq77+977+9eDojCgRCAlp7Ck1CS8KlU+K1sCLIuvCflbQo8Jq/vj3IuvCfqaFLYHvwnrmi8Juyllx68JGXiXTwk4eTL+Ctp/CQir4/8J+JguGLt/CWvprhg4fhnYd7PQo3QjXhlL7wkIGF8JG8qS3gq6gv6qKxYD9BcXvwkJ6zOnnwn6KWwqUnw7l7YFZOw6jwkaSg8J+VtAokQiIiXS5NNSzhqqXwkbakK/CRiohW8J65n++/vSFc4Yyc0aglCiIKBG5hbWUSGkIY8J65m3sv4K+G4L+FL/CRsq3hi4XwnoSwCg8KCW5hbWVzcGFjZRICCAQK0wK6Ac8CCt0BCgdjb2x1bW5zEtEBsgHNAQonQiXwnriiUjTwkI2rT+G9keqvsXvwn4mQ4bycWOK6uEHwkK2T4aqHCgZCBCIvPlwKHEIaPy4iw7AqK2pzQuGMlfCSi5NWezwqNOqrnigKCUIH4b2dQjHDmwoKQgjgv5Q8OmBLLwoRQg97N/CflbThqrLsm4RQOi8KHUIb8JatnF3wkaeNYcKm77+98J+VtCRM0ag9KlgqCgZCBPCRkZ0KC0IJLkZIYEg8PCRcCh5CHOOCunQgY2/gqK1gOjwyXMi6JfCflbQmQfCRg7AKLAoEbmFtZRIkQiJcfMOZ8JGHrCrgqLbwkYad8JCApj1ZXmDhg4080ajwkIyhCj8KCW5hbWVzcGFjZRIyQjAvJ1w/4Z2A77+9wrzhrasp8J+Sr+K3leqdsi7wnrmu8J+VtE458JGNiCjwnoCIQHsKgwO6Af8CCqkCCgdjb2x1bW5zEp0CsgGZAgofQh0m8J64u/CWvpd78J65kWfwkKaYJS7hpbHgtbo1JwoqQihcwqVIYCtX7Z+de/CQuqvCusKl8J2WiuC0gvCQlpXIuiVaalYv4KeECjZCNCpGU8KlSD/XpS4kQCQ8OfCQuqvwnrmC4La04LWGfFtgXO+/vVx6ZOCvkOCuj2ngu4bgs5UKPkI88JC6qOGoqmDwkbSF77+94KGw8JGNjXtpPD9ITDzqqZjwkK6uP+qfkTrwkZiH8JCnoMOSYOCzs9GodT8vCh1CG+GXnO+/vcO976q2PHbIuuqsrPCQrYdHQOCxpwoYQhY7JGEhYOC9kfCforHCpeCyq/CQloA9ChlCF++shvCQvY1Ce/CeuY1Xb1/vrJXwkKKGCkAKBG5hbWUSOEI28JuImDwq8JCohSZ7OuGLkvCbgbElIuGLgPCflbRNPSfwnri2eDzwkIyB8Jq/uuGpnjl4Ici6Cg8KCW5hbWVzcGFjZRICCAQKLAoKdXBkYXRlZF9hdBIeugEbChkKBm1pbGxpcxIPwgEMCgqQmHaBIDUIVkdM +CtUBCtIBugHOAQo1CgNrZXkSLroBKwoQCgpjbHVzdGVyX2lkEgIIBAoXCgRuYW1lEg9CDS4kMGAmPyfIujjirpUKKQoEa2luZBIhQh9DbHVzdGVySW50cm9zcGVjdGlvblNvdXJjZUluZGV4CmoKBXZhbHVlEmG6AV4KKwoJZ2xvYmFsX2lkEh66ARsKGQoFdmFsdWUSEMIBDQoLAVYZGCh4QDQIA5wKGwoIaW5kZXhfaWQSD8IBDAoKQkU1ggCJMiMxPAoSCgNvaWQSC8IBCAoGAoQSQ1ds +CikKJ7oBJAoVCgRraW5kEg1CC1R4bldhbFNoYXJkCgsKBXZhbHVlEgIIBA== +CpABCo0BugGJAQpMCgNrZXkSRboBQgpACgNrZXkSOUI38JGMv+CsszFP4aSiSci6SPCbhZUk4aeUfFA9e1JcwqUz8J+mmHtMLVNDXGXgsYPwmr+z4Ky1NwoQCgRraW5kEghCBkNvbmZpZwonCgV2YWx1ZRIeugEbChkKBXZhbHVlEhDCAQ0KCwESAFFnJiY4YUmM +CkIKQLoBPQoJCgNrZXkSAggECiMKBGtpbmQSG0IZU3RvcmFnZUNvbGxlY3Rpb25NZXRhZGF0YQoLCgV2YWx1ZRICCAQ= +CooBCocBugGDAQooCgNrZXkSIboBHgoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAoaCgRraW5kEhJCEFN5c3RlbVByaXZpbGVnZXMKOwoFdmFsdWUSMroBLwotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFxMWQygzJFhGmM +Ci8KLboBKgoJCgNrZXkSAggEChAKBGtpbmQSCEIGU2NoZW1hCgsKBXZhbHVlEgIIBA== +Ci0KK7oBKAoJCgNrZXkSAggECg4KBGtpbmQSBkIEUm9sZQoLCgV2YWx1ZRICCAQ= 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 +CjoKOLoBNQoJCgNrZXkSAggEChsKBGtpbmQSE0IRRGVmYXVsdFByaXZpbGVnZXMKCwoFdmFsdWUSAggE +CjEKL7oBLAoJCgNrZXkSAggEChIKBGtpbmQSCkIIUm9sZUF1dGgKCwoFdmFsdWUSAggE +CkIKQLoBPQoJCgNrZXkSAggECiMKBGtpbmQSG0IZU3RvcmFnZUNvbGxlY3Rpb25NZXRhZGF0YQoLCgV2YWx1ZRICCAQ= +Ck0KS7oBSAoUCgNrZXkSDboBCgoICgJpZBICCAQKIwoEa2luZBIbQhlTdG9yYWdlQ29sbGVjdGlvbk1ldGFkYXRhCgsKBXZhbHVlEgIIBA== +CjwKOroBNwoUCgNrZXkSDboBCgoICgJpZBICCAQKEgoEa2luZBIKQghSb2xlQXV0aAoLCgV2YWx1ZRICCAQ= +CmsKaboBZgpDCgNrZXkSPLoBOQo3CgJpZBIxugEuCiwKBXZhbHVlEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBMpSYcSF4UEdBnAoSCgRraW5kEgpCCFJvbGVBdXRoCgsKBXZhbHVlEgIIBA== +CrYBCrMBugGvAQqJAQoDa2V5EoEBugF+ChIKC29iamVjdF9uYW1lEgNCAWoKGgoLb2JqZWN0X3R5cGUSC8IBCAoGATAjKCmMCkwKC3NjaGVtYV9uYW1lEj1CO8KlPSduSz0k6p+TevCegKPit57hioc8KvCRtpbvubNFYdGo8JGmoiXqrKxz8JGNkDwnwqU85LCdXjgnChQKBGtpbmQSDEIKR2lkTWFwcGluZwoLCgV2YWx1ZRICCAQ= +CtcBCtQBugHQAQqjAQoDa2V5EpsBugGXAQofCgtkYXRhYmFzZV9pZBIQugENCgsKBXZhbHVlEgIIBAo4CgdncmFudGVlEi26ASoKKAoFdmFsdWUSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAWOUlXkYInNpVWwKGgoLb2JqZWN0X3R5cGUSC8IBCAoGAZk3M2QcCg0KB3JvbGVfaWQSAggECg8KCXNjaGVtYV9pZBICCAQKGwoEa2luZBITQhFEZWZhdWx0UHJpdmlsZWdlcwoLCgV2YWx1ZRICCAQ= +CmsKaboBZgoJCgNrZXkSAggEChsKBGtpbmQSE0IRRGVmYXVsdFByaXZpbGVnZXMKPAoFdmFsdWUSM7oBMAouCgpwcml2aWxlZ2VzEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKJoE4NXcROYdzbA== +CuIBCt8BugHbAQrEAQoDa2V5ErwBugG4AQq1AQoFZXZlbnQSqwG6AacBCqQBCgJWMRKdAboBmQEKDQoHZGV0YWlscxICCAQKGQoKZXZlbnRfdHlwZRILwgEICgYBEGAgIG0KFgoCaWQSEMIBDQoLAUl0CUIjGRBYI5wKGgoLb2JqZWN0X3R5cGUSC8IBCAoGAgMkAjFcCi0KC29jY3VycmVkX2F0Eh66ARsKGQoGbWlsbGlzEg/CAQwKCikSFCKVYYlEgmwKCgoEdXNlchICCAQKEgoEa2luZBIKQghBdWRpdExvZw== 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 +Cq4BCqsBugGnAQoiCgNrZXkSG7oBGAoWCgJpZBIQugENCgsKBXZhbHVlEgIIBAoYCgRraW5kEhBCDkNsdXN0ZXJSZXBsaWNhCmcKBXZhbHVlEl66AVsKEAoKY2x1c3Rlcl9pZBICCAQKDAoGY29uZmlnEgIIBAobCgRuYW1lEhNCEXjhvJvwnri7WSTwn6KweTo9ChwKCG93bmVyX2lkEhC6AQ0KCwoFdmFsdWUSAggE +ClwKWroBVwolChFkZXBsb3lfZ2VuZXJhdGlvbhIQwgENCgsBF1YWY0M3QYdgPAoYCgVlcG9jaBIPwgEMCgpJMElxiDlRKECNChQKBGtpbmQSDEIKRmVuY2VUb2tlbg== +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ2x1c3RlcgoLCgV2YWx1ZRICCAQ= +CjkKN7oBNAoVCgNrZXkSDroBCwoJCgNnaWQSAggECg4KBGtpbmQSBkIESXRlbQoLCgV2YWx1ZRICCAQ= +CiQKIroBHwoJCgNrZXkSAggEChIKBGtpbmQSCkIIQXVkaXRMb2c= +CnQKcroBbwoJCgNrZXkSAggEChEKBGtpbmQSCUIHU2V0dGluZwpPCgV2YWx1ZRJGugFDCkEKBXZhbHVlEjhCNmDwkbWE4bKy8JGlkN+2UT/hiYxg8JCnhuOEjC92Ji59O/CRqqHwkKyf77+977+9YT/gqrIiYQ== +CnAKbroBawoxCgNrZXkSKroBJwoQCgpjbHVzdGVyX2lkEgIIBAoTCgRuYW1lEgtCCfCRjKtKe2DDsgopCgRraW5kEiFCH0NsdXN0ZXJJbnRyb3NwZWN0aW9uU291cmNlSW5kZXgKCwoFdmFsdWUSAggE +CnMKcboBbgpMCgNrZXkSRboBQgoMCgZvYmplY3QSAggECjIKDXN1Yl9jb21wb25lbnQSIboBHgocCglDb2x1bW5Qb3MSD8IBDAoKV4OJQiQpNhBWfAoRCgRraW5kEglCB0NvbW1lbnQKCwoFdmFsdWUSAggE +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ2x1c3RlcgoLCgV2YWx1ZRICCAQ= +Cl0KW7oBWAoYCgNrZXkSEboBDgoMCgRuYW1lEgRCAjVeChEKBGtpbmQSCUIHSWRBbGxvYwopCgV2YWx1ZRIgugEdChsKB25leHRfaWQSEMIBDQoLAXYSWUEQdggnQhw= +CogBCoUBugGBAQotCgNrZXkSJroBIwoMCgZvYmplY3QSAggEChMKDXN1Yl9jb21wb25lbnQSAggEChEKBGtpbmQSCUIHQ29tbWVudAo9CgV2YWx1ZRI0ugExCi8KB2NvbW1lbnQSJEIiQfCRtKTCqu+/vXIlWfCRpInwkY2m4aWGVjJmJyfhsJkvUg== +CikKJ7oBJAoVCgRraW5kEg1CC1R4bldhbFNoYXJkCgsKBXZhbHVlEgIIBA== +CjwKOroBNwoJCgNrZXkSAggECh0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgoLCgV2YWx1ZRICCAQ= +CmcKZboBYgolChFkZXBsb3lfZ2VuZXJhdGlvbhIQwgENCgsBclCGeIJlcDaYfAojCgVlcG9jaBIawgEXCgoEBpZnYSKFMXc8EP///////////wEKFAoEa2luZBIMQgpGZW5jZVRva2Vu +CrkCCrYCugGyAgqpAQoDa2V5EqEBugGdAQonCgtvYmplY3RfbmFtZRIYQhbqpIPwnoCkwqzIuvCfiKNx4LWGeyp4ChoKC29iamVjdF90eXBlEgvCAQgKBgIIFwdWHQpWCgtzY2hlbWFfbmFtZRJHQkUk8J6LnN6B0ahD8J+VtCHwq52i8J65l+Cpm/CRvIUvKj/wn4io77+9LvCYtII28J+VtCbqn5Nqe2jhvZ1d8JCkg3AjwqUKFAoEa2luZBIMQgpHaWRNYXBwaW5nCm4KBXZhbHVlEmW6AWIKOAoLZmluZ2VycHJpbnQSKUInPHPwn5ep77+9bfCRjY0t8JGbhnAq8JG1o+ComFzvqbvCpUhL4oCGCg8KCWdsb2JhbF9pZBICCAQKFQoCaWQSD8IBDAoKeTFEeHNYVoAYnA== +CjkKN7oBNAoJCgNrZXkSAggEChoKBGtpbmQSEkIQU3lzdGVtUHJpdmlsZWdlcwoLCgV2YWx1ZRICCAQ= +ClsKWboBVgokChFkZXBsb3lfZ2VuZXJhdGlvbhIPwgEMCgpAYCkzCBYHVEFMChgKBWVwb2NoEg/CAQwKCldWCTSWNAN4eI0KFAoEa2luZBIMQgpGZW5jZVRva2Vu +CjwKOroBNwoJCgNrZXkSAggECh0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgoLCgV2YWx1ZRICCAQ= +CsUBCsIBugG+AQqYAQoDa2V5EpABugGMAQouCgtvYmplY3RfbmFtZRIfQh3gq7vvubBgIuCtrfCeuZJq8JCMkvCeiprwnrmfJAokCgtvYmplY3RfdHlwZRIVwgESCgUgY5mDfBD///////////8BCjQKC3NjaGVtYV9uYW1lEiVCI1Xhv7508J+VtPCflbTwlqibw5x4L0/wnZGb77+9JOGfoDo/ChQKBGtpbmQSDEIKR2lkTWFwcGluZwoLCgV2YWx1ZRICCAQ= +Cj4KPLoBOQoJCgNrZXkSAggEChEKBGtpbmQSCUIHU2V0dGluZwoZCgV2YWx1ZRIQugENCgsKBXZhbHVlEgJCAA== +Cl0KW7oBWAoqCgNrZXkSI7oBIAoeCgRuYW1lEhZCFDZk8J2RoyXwnrqwJcOG4rahPCYvCh0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgoLCgV2YWx1ZRICCAQ= +CswBCskBugHFAQqKAQoDa2V5EoIBugF/CjgKCmNsdXN0ZXJfaWQSKroBJwolCgV2YWx1ZRIcugEZChcKBFVzZXISD8IBDAoKRil1dBIoYTkUPApDCgRuYW1lEjtCOTxsW/CQnonIui4iIPCRi6rwkayEzb/wkIag8Kups2Bc8JCxhfOghpHvv709PGTau++4uci6yLpnegopCgRraW5kEiFCH0NsdXN0ZXJJbnRyb3NwZWN0aW9uU291cmNlSW5kZXgKCwoFdmFsdWUSAggE +Ci8KLboBKgoJCgNrZXkSAggEChAKBGtpbmQSCEIGU2NoZW1hCgsKBXZhbHVlEgIIBA== +CjkKN7oBNAoJCgNrZXkSAggEChoKBGtpbmQSEkIQU291cmNlUmVmZXJlbmNlcwoLCgV2YWx1ZRICCAQ= +CnQKcroBbwpOCgNrZXkSR7oBRApCCgNrZXkSO0I5VTppIT/wkJK7TDrwn4WJInvwkY2ma/CbhaYiYCJqaeG/mnBuRPCSkLjvu7E9w4biu57wnoCQWi8mChAKBGtpbmQSCEIGQ29uZmlnCgsKBXZhbHVlEgIIBA== +CosBCogBugGEAQoiCgNrZXkSG7oBGAoWCgJpZBIQugENCgsKBXZhbHVlEgIIBAojCgRraW5kEhtCGVN0b3JhZ2VDb2xsZWN0aW9uTWV0YWRhdGEKOQoFdmFsdWUSMLoBLQorCgVzaGFyZBIiQiDwn5W0XPCQoIsiPeC2jvCeuZ1gLuC7ny7gspA68J+rgw== +CvQJCvEJugHtCQoUCgNrZXkSDboBCgoICgJpZBICCAQKDgoEa2luZBIGQgRSb2xlCsQJCgV2YWx1ZRK6CboBtgkKEAoKYXR0cmlidXRlcxICCAQKxggKCm1lbWJlcnNoaXAStwi6AbMICrAICgNtYXASqAiyAaQICkm6AUYKNwoDa2V5EjC6AS0KKwoFdmFsdWUSIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCiGJd4KDGCZXJIwKCwoFdmFsdWUSAggECkO6AUAKMQoDa2V5Eiq6AScKJQoFdmFsdWUSHLoBGQoXCgRVc2VyEg/CAQwKCiUFCYh0QzSQUFwKCwoFdmFsdWUSAggECkS6AUEKMgoDa2V5Eiu6ASgKJgoFdmFsdWUSHboBGgoYCgRVc2VyEhDCAQ0KCwFIQoQFOXdZdUlsCgsKBXZhbHVlEgIIBApJugFGCjcKA2tleRIwugEtCisKBXZhbHVlEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgoziAEyWVAlaRlcCgsKBXZhbHVlEgIIBAobugEYCgkKA2tleRICCAQKCwoFdmFsdWUSAggECim6ASYKFwoDa2V5EhC6AQ0KCwoFdmFsdWUSAggECgsKBXZhbHVlEgIIBApSugFPChcKA2tleRIQugENCgsKBXZhbHVlEgIIBAo0CgV2YWx1ZRIrugEoCiYKBXZhbHVlEh26ARoKGAoEVXNlchIQwgENCgsBSJBlU2dwEBVxXAopugEmChcKA2tleRIQugENCgsKBXZhbHVlEgIIBAoLCgV2YWx1ZRICCAQKKboBJgoXCgNrZXkSELoBDQoLCgV2YWx1ZRICCAQKCwoFdmFsdWUSAggECkq6AUcKOAoDa2V5EjG6AS4KLAoFdmFsdWUSI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwEnITmGaJJllYMsCgsKBXZhbHVlEgIIBApUugFRCgkKA2tleRICCAQKRAoFdmFsdWUSO7oBOAo2CgV2YWx1ZRItugEqCigKClByZWRlZmluZWQSGsIBFwoKElZSRVJGdBgynBD///////////8BCkq6AUcKOAoDa2V5EjG6AS4KLAoFdmFsdWUSI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwE0JiJpKIN1EnM8CgsKBXZhbHVlEgIIBAp0ugFxCjgKA2tleRIxugEuCiwKBXZhbHVlEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBEIkWcEAllmYkXAo1CgV2YWx1ZRIsugEpCicKBXZhbHVlEh66ARsKGQoGU3lzdGVtEg/CAQwKChQ4UoExmDJzGBwKG7oBGAoJCgNrZXkSAggECgsKBXZhbHVlEgIIBAobugEYCgkKA2tleRICCAQKCwoFdmFsdWUSAggEChu6ARgKCQoDa2V5EgIIBAoLCgV2YWx1ZRICCAQKKboBJgoJCgNrZXkSAggEChkKBXZhbHVlEhC6AQ0KCwoFdmFsdWUSAggECim6ASYKCQoDa2V5EgIIBAoZCgV2YWx1ZRIQugENCgsKBXZhbHVlEgIIBAo5CgRuYW1lEjFCL/CQnoB6IuGKsi/CvU1uSkjwkaCQ44OQ6pyAKk7grpzwrI6T8JCEr96NMFDwkaSJChIKA29pZBILwgEICgYCIYlTBCwKCgoEdmFycxICCAQ= +ClYKVLoBUQowCgNrZXkSKboBJgokCgNrZXkSHUIb8JCzqeC5kPCQsJcqKj3gspA/6qmGN2Dhn7JQChAKBGtpbmQSCEIGQ29uZmlnCgsKBXZhbHVlEgIIBA== diff --git a/src/catalog/src/durable/upgrade/v73_to_v74.rs b/src/catalog/src/durable/upgrade/v73_to_v74.rs new file mode 100644 index 0000000000000..174a288972c53 --- /dev/null +++ b/src/catalog/src/durable/upgrade/v73_to_v74.rs @@ -0,0 +1,17 @@ +// 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 crate::durable::upgrade::MigrationAction; +use crate::durable::upgrade::{objects_v73 as v73, objects_v74 as v74}; + +pub fn upgrade( + _snapshot: Vec, +) -> Vec> { + Vec::new() +} diff --git a/src/catalog/src/memory/objects.rs b/src/catalog/src/memory/objects.rs index 88c2ff14eee8e..3e13fbb8017e0 100644 --- a/src/catalog/src/memory/objects.rs +++ b/src/catalog/src/memory/objects.rs @@ -292,6 +292,46 @@ impl UpdateFrom for Role { } } +#[derive(Debug, Serialize, Clone, PartialEq, Eq)] +pub struct RoleAuth { + pub role_id: RoleId, + pub password_hash: Option, + pub updated_at: u64, +} + +impl From for durable::RoleAuth { + fn from(role_auth: RoleAuth) -> durable::RoleAuth { + durable::RoleAuth { + role_id: role_auth.role_id, + password_hash: role_auth.password_hash, + updated_at: role_auth.updated_at, + } + } +} + +impl From for RoleAuth { + fn from( + durable::RoleAuth { + role_id, + password_hash, + updated_at, + }: durable::RoleAuth, + ) -> RoleAuth { + RoleAuth { + role_id, + password_hash, + updated_at, + } + } +} + +impl UpdateFrom for RoleAuth { + fn update_from(&mut self, from: durable::RoleAuth) { + self.role_id = from.role_id; + self.password_hash = from.password_hash; + } +} + #[derive(Debug, Serialize, Clone, PartialEq)] pub struct Cluster { pub name: String, @@ -3341,6 +3381,7 @@ pub struct StateUpdate { #[derive(Debug, Clone)] pub enum StateUpdateKind { Role(durable::objects::Role), + RoleAuth(durable::objects::RoleAuth), Database(durable::objects::Database), Schema(durable::objects::Schema), DefaultPrivilege(durable::objects::DefaultPrivilege), @@ -3418,6 +3459,7 @@ impl From for TemporaryItem { #[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq)] pub enum BootstrapStateUpdateKind { Role(durable::objects::Role), + RoleAuth(durable::objects::RoleAuth), Database(durable::objects::Database), Schema(durable::objects::Schema), DefaultPrivilege(durable::objects::DefaultPrivilege), @@ -3441,6 +3483,7 @@ impl From for StateUpdateKind { fn from(value: BootstrapStateUpdateKind) -> Self { match value { BootstrapStateUpdateKind::Role(kind) => StateUpdateKind::Role(kind), + BootstrapStateUpdateKind::RoleAuth(kind) => StateUpdateKind::RoleAuth(kind), BootstrapStateUpdateKind::Database(kind) => StateUpdateKind::Database(kind), BootstrapStateUpdateKind::Schema(kind) => StateUpdateKind::Schema(kind), BootstrapStateUpdateKind::DefaultPrivilege(kind) => { @@ -3483,6 +3526,7 @@ impl TryFrom for BootstrapStateUpdateKind { fn try_from(value: StateUpdateKind) -> Result { match value { StateUpdateKind::Role(kind) => Ok(BootstrapStateUpdateKind::Role(kind)), + StateUpdateKind::RoleAuth(kind) => Ok(BootstrapStateUpdateKind::RoleAuth(kind)), StateUpdateKind::Database(kind) => Ok(BootstrapStateUpdateKind::Database(kind)), StateUpdateKind::Schema(kind) => Ok(BootstrapStateUpdateKind::Schema(kind)), StateUpdateKind::DefaultPrivilege(kind) => { diff --git a/src/catalog/tests/debug.rs b/src/catalog/tests/debug.rs index 72ba0ff141ead..893dbae57e74c 100644 --- a/src/catalog/tests/debug.rs +++ b/src/catalog/tests/debug.rs @@ -92,6 +92,7 @@ impl Debug for StableTrace<'_> { items, network_policies, roles, + role_auth, schemas, settings, source_references, @@ -134,6 +135,7 @@ impl Debug for StableTrace<'_> { .field("items", items) .field("network_policies", network_policies) .field("roles", roles) + .field("role_auth", role_auth) .field("schemas", schemas) .field("settings", &settings) .field("source_references", source_references) diff --git a/src/catalog/tests/open.rs b/src/catalog/tests/open.rs index f53d10e99c213..14622211954c2 100644 --- a/src/catalog/tests/open.rs +++ b/src/catalog/tests/open.rs @@ -73,6 +73,7 @@ impl Debug for StableSnapshot<'_> { databases, schemas, roles, + role_auth, items, comments, clusters, @@ -100,6 +101,7 @@ impl Debug for StableSnapshot<'_> { .field("databases", databases) .field("schemas", schemas) .field("roles", roles) + .field("role_auth", role_auth) .field("items", items) .field("comments", comments) .field("clusters", clusters) diff --git a/src/catalog/tests/snapshots/debug__opened_trace.snap b/src/catalog/tests/snapshots/debug__opened_trace.snap index 1a85a78cb7811..c81d818c0d813 100644 --- a/src/catalog/tests/snapshots/debug__opened_trace.snap +++ b/src/catalog/tests/snapshots/debug__opened_trace.snap @@ -1258,6 +1258,8 @@ Trace { attributes: Some( RoleAttributes { inherit: true, + superuser: None, + login: None, }, ), membership: Some( @@ -1296,6 +1298,8 @@ Trace { attributes: Some( RoleAttributes { inherit: true, + superuser: None, + login: None, }, ), membership: Some( @@ -1334,6 +1338,8 @@ Trace { attributes: Some( RoleAttributes { inherit: true, + superuser: None, + login: None, }, ), membership: Some( @@ -1372,6 +1378,8 @@ Trace { attributes: Some( RoleAttributes { inherit: true, + superuser: None, + login: None, }, ), membership: Some( @@ -1410,6 +1418,8 @@ Trace { attributes: Some( RoleAttributes { inherit: true, + superuser: None, + login: None, }, ), membership: Some( @@ -1448,6 +1458,8 @@ Trace { attributes: Some( RoleAttributes { inherit: true, + superuser: None, + login: None, }, ), membership: Some( @@ -1470,6 +1482,9 @@ Trace { ), ], }, + role_auth: CollectionTrace { + values: [], + }, schemas: CollectionTrace { values: [ ( diff --git a/src/catalog/tests/snapshots/open__initial_snapshot.snap b/src/catalog/tests/snapshots/open__initial_snapshot.snap index 9a9fcef197164..82d9918d3e11f 100644 --- a/src/catalog/tests/snapshots/open__initial_snapshot.snap +++ b/src/catalog/tests/snapshots/open__initial_snapshot.snap @@ -939,6 +939,8 @@ Snapshot { attributes: Some( RoleAttributes { inherit: true, + superuser: None, + login: None, }, ), membership: Some( @@ -968,6 +970,8 @@ Snapshot { attributes: Some( RoleAttributes { inherit: true, + superuser: None, + login: None, }, ), membership: Some( @@ -997,6 +1001,8 @@ Snapshot { attributes: Some( RoleAttributes { inherit: true, + superuser: None, + login: None, }, ), membership: Some( @@ -1026,6 +1032,8 @@ Snapshot { attributes: Some( RoleAttributes { inherit: true, + superuser: None, + login: None, }, ), membership: Some( @@ -1055,6 +1063,8 @@ Snapshot { attributes: Some( RoleAttributes { inherit: true, + superuser: None, + login: None, }, ), membership: Some( @@ -1084,6 +1094,8 @@ Snapshot { attributes: Some( RoleAttributes { inherit: true, + superuser: None, + login: None, }, ), membership: Some( @@ -1099,6 +1111,7 @@ Snapshot { oid: 16664, }, }, + role_auth: {}, items: {}, comments: {}, clusters: { diff --git a/src/environmentd/src/environmentd/main.rs b/src/environmentd/src/environmentd/main.rs index bed793a24adb5..8323947d45aae 100644 --- a/src/environmentd/src/environmentd/main.rs +++ b/src/environmentd/src/environmentd/main.rs @@ -210,7 +210,14 @@ pub struct Args { /// Frontegg arguments. #[clap(flatten)] frontegg: FronteggCliArgs, - + // TODO(auth): we probably want to consolidate all these auth options + // into something cleaner. + /// Self hosted auth + #[clap(long, env = "ENABLE_SELF_HOSTED_AUTH")] + enable_self_hosted_auth: bool, + /// Self hosted auth over internal port + #[clap(long, env = "ENABLE_SELF_HOSTED_AUTH_INTERNAL")] + enable_self_hosted_auth_internal: bool, // === Orchestrator options. === /// The service orchestrator implementation to use. #[structopt(long, value_enum, env = "ORCHESTRATOR")] @@ -1103,6 +1110,8 @@ fn run(mut args: Args) -> Result<(), anyhow::Error> { egress_addresses: args.announce_egress_address, http_host_name: args.http_host_name, internal_console_redirect_url: args.internal_console_redirect_url, + self_hosted_auth: args.enable_self_hosted_auth, + self_hosted_auth_internal: args.enable_self_hosted_auth_internal, // Controller options. controller, secrets_controller, diff --git a/src/environmentd/src/http.rs b/src/environmentd/src/http.rs index b53f3d0f96eb7..c9555bbc3c9f2 100644 --- a/src/environmentd/src/http.rs +++ b/src/environmentd/src/http.rs @@ -558,6 +558,8 @@ impl AuthedClient { user: user.name, client_ip: Some(peer_addr), external_metadata_rx: user.external_metadata_rx, + //TODO(dov): Add support for internal user metadata when we support auth here + internal_user_metadata: None, helm_chart_version, }); let connection_guard = active_connection_counter.allocate_connection(session.user())?; diff --git a/src/environmentd/src/lib.rs b/src/environmentd/src/lib.rs index d84476db538d7..950306e7a1314 100644 --- a/src/environmentd/src/lib.rs +++ b/src/environmentd/src/lib.rs @@ -107,6 +107,10 @@ pub struct Config { /// The URL of the Materialize console to proxy from the /internal-console /// endpoint on the internal HTTP server. pub internal_console_redirect_url: Option, + /// Whether to enable self hosted auth + pub self_hosted_auth: bool, + /// Whether to enable self hosted auth on the internal pg port + pub self_hosted_auth_internal: bool, // === Controller options. === /// Storage and compute controller configuration. @@ -735,6 +739,7 @@ impl Listeners { tls: pgwire_tls.clone(), adapter_client: adapter_client.clone(), frontegg: config.frontegg.clone(), + use_self_hosted_auth: config.self_hosted_auth, metrics: metrics.clone(), internal: false, active_connection_counter: active_connection_counter.clone(), @@ -765,6 +770,7 @@ impl Listeners { }), adapter_client: adapter_client.clone(), frontegg: None, + use_self_hosted_auth: config.self_hosted_auth_internal, metrics: metrics.clone(), internal: true, active_connection_counter: active_connection_counter.clone(), diff --git a/src/environmentd/src/test_util.rs b/src/environmentd/src/test_util.rs index 83284c252d853..b2dcb7759a173 100644 --- a/src/environmentd/src/test_util.rs +++ b/src/environmentd/src/test_util.rs @@ -93,6 +93,8 @@ pub struct TestHarness { data_directory: Option, tls: Option, frontegg: Option, + self_hosted_auth: bool, + self_hosted_auth_internal: bool, unsafe_mode: bool, workers: usize, now: NowFn, @@ -128,6 +130,8 @@ impl Default for TestHarness { data_directory: None, tls: None, frontegg: None, + self_hosted_auth: false, + self_hosted_auth_internal: false, unsafe_mode: false, workers: 1, now: SYSTEM_TIME.clone(), @@ -247,6 +251,16 @@ impl TestHarness { self } + pub fn with_self_hosted_auth(mut self, self_hosted_auth: bool) -> Self { + self.self_hosted_auth = self_hosted_auth; + self + } + + pub fn with_self_hosted_auth_internal(mut self, self_hosted_auth_internal: bool) -> Self { + self.self_hosted_auth_internal = self_hosted_auth_internal; + self + } + pub fn with_now(mut self, now: NowFn) -> Self { self.now = now; self @@ -540,6 +554,8 @@ impl Listeners { cloud_resource_controller: None, tls: config.tls, frontegg: config.frontegg, + self_hosted_auth: config.self_hosted_auth, + self_hosted_auth_internal: config.self_hosted_auth_internal, unsafe_mode: config.unsafe_mode, all_features: false, metrics_registry: metrics_registry.clone(), diff --git a/src/environmentd/tests/auth.rs b/src/environmentd/tests/auth.rs index efb8f4af42873..1010efd1ba5b4 100644 --- a/src/environmentd/tests/auth.rs +++ b/src/environmentd/tests/auth.rs @@ -3103,3 +3103,235 @@ async fn test_transient_auth_failure_on_refresh() { assert_ok!(pg_client2.query_one("SELECT 1", &[]).await); assert_eq!(*frontegg_server.auth_requests.lock().unwrap(), 3); } + +#[mz_ore::test(tokio::test(flavor = "multi_thread", worker_threads = 1))] +#[cfg_attr(miri, ignore)] // unsupported operation: can't call foreign function `OPENSSL_init_ssl` on OS `linux` +async fn test_self_managed_auth() { + let metrics_registry = MetricsRegistry::new(); + + let server = test_util::TestHarness::default() + .with_system_parameter_default( + "log_filter".to_string(), + "mz_frontegg_auth=debug,info".to_string(), + ) + .with_system_parameter_default("enable_self_managed_auth".to_string(), "true".to_string()) + .with_self_hosted_auth(true) + .with_metrics_registry(metrics_registry) + .start() + .await; + + let pg_client = server.connect().no_tls().internal().await.unwrap(); + pg_client + .execute("CREATE ROLE foo WITH LOGIN PASSWORD 'bar'", &[]) + .await + .unwrap(); + + let external_client = server + .connect() + .no_tls() + .user("foo") + .password("bar") + .await + .unwrap(); + + assert_eq!( + external_client + .query_one("SELECT current_user", &[]) + .await + .unwrap() + .get::<_, String>(0), + "foo" + ); + + assert_eq!( + external_client + .query_one("SELECT mz_is_superuser()", &[]) + .await + .unwrap() + .get::<_, bool>(0), + false + ); +} + +#[mz_ore::test(tokio::test(flavor = "multi_thread", worker_threads = 1))] +#[cfg_attr(miri, ignore)] // unsupported operation: can't call foreign function `OPENSSL_init_ssl` on OS `linux` +async fn test_self_managed_auth_superuser() { + let metrics_registry = MetricsRegistry::new(); + + let server = test_util::TestHarness::default() + .with_system_parameter_default( + "log_filter".to_string(), + "mz_frontegg_auth=debug,info".to_string(), + ) + .with_system_parameter_default("enable_self_managed_auth".to_string(), "true".to_string()) + .with_self_hosted_auth(true) + .with_metrics_registry(metrics_registry) + .start() + .await; + + let pg_client = server.connect().no_tls().internal().await.unwrap(); + pg_client + .execute("CREATE ROLE foo WITH LOGIN SUPERUSER PASSWORD 'bar'", &[]) + .await + .unwrap(); + + let external_client = server + .connect() + .no_tls() + .user("foo") + .password("bar") + .await + .unwrap(); + + assert_eq!( + external_client + .query_one("SELECT current_user", &[]) + .await + .unwrap() + .get::<_, String>(0), + "foo" + ); + + assert_eq!( + external_client + .query_one("SELECT mz_is_superuser()", &[]) + .await + .unwrap() + .get::<_, bool>(0), + true + ); +} + +#[mz_ore::test(tokio::test(flavor = "multi_thread", worker_threads = 1))] +#[cfg_attr(miri, ignore)] // unsupported operation: can't call foreign function `OPENSSL_init_ssl` on OS `linux` +async fn test_self_managed_auth_alter_role() { + let metrics_registry = MetricsRegistry::new(); + + let server = test_util::TestHarness::default() + .with_system_parameter_default( + "log_filter".to_string(), + "mz_frontegg_auth=debug,info".to_string(), + ) + .with_system_parameter_default("enable_self_managed_auth".to_string(), "true".to_string()) + .with_self_hosted_auth(true) + .with_metrics_registry(metrics_registry) + .start() + .await; + + let pg_client = server.connect().no_tls().internal().await.unwrap(); + pg_client + .execute("CREATE ROLE foo WITH LOGIN PASSWORD 'bar'", &[]) + .await + .unwrap(); + + { + let external_client = server + .connect() + .no_tls() + .user("foo") + .password("bar") + .await + .unwrap(); + + assert_eq!( + external_client + .query_one("SELECT current_user", &[]) + .await + .unwrap() + .get::<_, String>(0), + "foo" + ); + + assert_eq!( + external_client + .query_one("SELECT mz_is_superuser()", &[]) + .await + .unwrap() + .get::<_, bool>(0), + false + ); + } + + pg_client + .execute("ALTER ROLE foo WITH SUPERUSER PASSWORD 'baz'", &[]) + .await + .unwrap(); + + { + let external_client = server + .connect() + .no_tls() + .user("foo") + .password("baz") + .await + .unwrap(); + + assert_eq!( + external_client + .query_one("SELECT current_user", &[]) + .await + .unwrap() + .get::<_, String>(0), + "foo" + ); + + assert_eq!( + external_client + .query_one("SELECT mz_is_superuser()", &[]) + .await + .unwrap() + .get::<_, bool>(0), + true + ); + } + + pg_client + .execute("ALTER ROLE foo WITH SUPERUSER PASSWORD NULL", &[]) + .await + .unwrap(); + + { + assert_err!(server.connect().no_tls().user("foo").password("baz").await); + } + + pg_client + .execute("ALTER ROLE foo WITH SUPERUSER PASSWORD 'baz'", &[]) + .await + .unwrap(); + + { + let external_client = server + .connect() + .no_tls() + .user("foo") + .password("baz") + .await + .unwrap(); + + assert_eq!( + external_client + .query_one("SELECT current_user", &[]) + .await + .unwrap() + .get::<_, String>(0), + "foo" + ); + + assert_eq!( + external_client + .query_one("SELECT mz_is_superuser()", &[]) + .await + .unwrap() + .get::<_, bool>(0), + true + ); + } + pg_client + .execute("ALTER ROLE foo WITH NOLOGIN", &[]) + .await + .unwrap(); + + { + assert_err!(server.connect().no_tls().user("foo").password("baz").await); + } +} diff --git a/src/pgwire/BUILD.bazel b/src/pgwire/BUILD.bazel index 2ed0a74a19dcc..b6a49fc3d5817 100644 --- a/src/pgwire/BUILD.bazel +++ b/src/pgwire/BUILD.bazel @@ -33,6 +33,7 @@ rust_library( deps = [ "//src/adapter:mz_adapter", "//src/adapter-types:mz_adapter_types", + "//src/auth:mz_auth", "//src/frontegg-auth:mz_frontegg_auth", "//src/ore:mz_ore", "//src/pgcopy:mz_pgcopy", @@ -74,6 +75,7 @@ rust_test( deps = [ "//src/adapter:mz_adapter", "//src/adapter-types:mz_adapter_types", + "//src/auth:mz_auth", "//src/frontegg-auth:mz_frontegg_auth", "//src/ore:mz_ore", "//src/pgcopy:mz_pgcopy", @@ -94,6 +96,7 @@ rust_doc_test( deps = [ "//src/adapter:mz_adapter", "//src/adapter-types:mz_adapter_types", + "//src/auth:mz_auth", "//src/frontegg-auth:mz_frontegg_auth", "//src/ore:mz_ore", "//src/pgcopy:mz_pgcopy", diff --git a/src/pgwire/Cargo.toml b/src/pgwire/Cargo.toml index cee8c3929915f..4a24535220d40 100644 --- a/src/pgwire/Cargo.toml +++ b/src/pgwire/Cargo.toml @@ -20,6 +20,7 @@ futures = "0.3.31" itertools = "0.12.1" mz-adapter = { path = "../adapter" } mz-adapter-types = { path = "../adapter-types" } +mz-auth = { path = "../auth" } mz-frontegg-auth = { path = "../frontegg-auth" } mz-ore = { path = "../ore", features = ["tracing"] } mz-pgcopy = { path = "../pgcopy" } diff --git a/src/pgwire/src/protocol.rs b/src/pgwire/src/protocol.rs index 0435cafe98c50..9dc91538f274c 100644 --- a/src/pgwire/src/protocol.rs +++ b/src/pgwire/src/protocol.rs @@ -26,6 +26,7 @@ use mz_adapter::{ AdapterError, AdapterNotice, ExecuteContextExtra, ExecuteResponse, PeekResponseUnary, RowsFuture, verify_datum_desc, }; +use mz_auth::password::Password; use mz_frontegg_auth::Authenticator as FronteggAuthentication; use mz_ore::cast::CastFrom; use mz_ore::netio::AsyncReady; @@ -35,6 +36,7 @@ use mz_pgcopy::{CopyCsvFormatParams, CopyFormatParams, CopyTextFormatParams}; use mz_pgwire_common::{ ConnectionCounter, ErrorResponse, Format, FrontendMessage, Severity, VERSION_3, VERSIONS, }; +use mz_repr::user::InternalUserMetadata; use mz_repr::{ CatalogItemId, ColumnIndex, Datum, RelationDesc, RelationType, RowArena, RowIterator, RowRef, ScalarType, @@ -95,6 +97,8 @@ pub struct RunParams<'a, A> { pub params: BTreeMap, /// Frontegg authentication. pub frontegg: Option<&'a FronteggAuthentication>, + /// Whether to use self hosted auth. + pub use_self_hosted_auth: bool, /// Whether this is an internal server that permits access to restricted /// system resources. pub internal: bool, @@ -123,6 +127,7 @@ pub async fn run<'a, A>( version, mut params, frontegg, + use_self_hosted_auth, internal, active_connection_counter, helm_chart_version, @@ -196,6 +201,7 @@ where user: auth_session.user().into(), client_ip: conn.peer_addr().clone(), external_metadata_rx: Some(auth_session.external_metadata_rx()), + internal_user_metadata: None, helm_chart_version, }); let expired = async move { auth_session.expired().await }; @@ -211,6 +217,47 @@ where .await; } } + } else if use_self_hosted_auth { + conn.send(BackendMessage::AuthenticationCleartextPassword) + .await?; + conn.flush().await?; + let password = match conn.recv().await? { + Some(FrontendMessage::Password { password }) => Password(password), + _ => { + return conn + .send(ErrorResponse::fatal( + SqlState::INVALID_AUTHORIZATION_SPECIFICATION, + "expected Password message", + )) + .await; + } + }; + let auth_response = match adapter_client.authenticate(&user, &password).await { + Ok(resp) => resp, + Err(err) => { + warn!(?err, "pgwire connection failed authentication"); + return conn + .send(ErrorResponse::fatal( + SqlState::INVALID_PASSWORD, + "invalid password", + )) + .await; + } + }; + let session = adapter_client.new_session(SessionConfig { + conn_id: conn.conn_id().clone(), + uuid: conn_uuid, + user, + client_ip: conn.peer_addr().clone(), + external_metadata_rx: None, + internal_user_metadata: Some(InternalUserMetadata { + superuser: auth_response.superuser, + }), + helm_chart_version, + }); + // No frontegg check, so auth session lasts indefinitely. + let auth_session = pending().right_future(); + (session, auth_session) } else { let session = adapter_client.new_session(SessionConfig { conn_id: conn.conn_id().clone(), @@ -218,6 +265,7 @@ where user, client_ip: conn.peer_addr().clone(), external_metadata_rx: None, + internal_user_metadata: None, helm_chart_version, }); // No frontegg check, so auth session lasts indefinitely. diff --git a/src/pgwire/src/server.rs b/src/pgwire/src/server.rs index 8f285aa954816..a67363161876f 100644 --- a/src/pgwire/src/server.rs +++ b/src/pgwire/src/server.rs @@ -48,6 +48,8 @@ pub struct Config { /// a valid Frontegg API token as a password to authenticate. Otherwise, /// password authentication is disabled. pub frontegg: Option, + /// Whether to use self-hosted authentication. + pub use_self_hosted_auth: bool, /// The registry entries that the pgwire server uses to report metrics. pub metrics: MetricsConfig, /// Whether this is an internal server that permits access to restricted @@ -68,6 +70,7 @@ pub struct Server { internal: bool, active_connection_counter: ConnectionCounter, helm_chart_version: Option, + use_self_hosted_auth: bool, } #[async_trait] @@ -89,6 +92,7 @@ impl Server { tls: config.tls, adapter_client: config.adapter_client, frontegg: config.frontegg, + use_self_hosted_auth: config.use_self_hosted_auth, metrics: Metrics::new(config.metrics, config.label), internal: config.internal, active_connection_counter: config.active_connection_counter, @@ -103,6 +107,7 @@ impl Server { ) -> impl Future> + 'static + Send { let adapter_client = self.adapter_client.clone(); let frontegg = self.frontegg.clone(); + let use_self_hosted_auth = self.use_self_hosted_auth; let tls = self.tls.clone(); let internal = self.internal; let metrics = self.metrics.clone(); @@ -176,6 +181,7 @@ impl Server { version, params, frontegg: frontegg.as_ref(), + use_self_hosted_auth, internal, active_connection_counter, helm_chart_version, diff --git a/src/repr/src/user.rs b/src/repr/src/user.rs index 403bca4949774..734b1419edc1a 100644 --- a/src/repr/src/user.rs +++ b/src/repr/src/user.rs @@ -18,3 +18,8 @@ pub struct ExternalUserMetadata { /// Indicates if the user is an admin in the external system. pub admin: bool, } + +#[derive(Debug, Clone, Serialize)] +pub struct InternalUserMetadata { + pub superuser: bool, +} diff --git a/src/sql-parser/src/ast/defs/statement.rs b/src/sql-parser/src/ast/defs/statement.rs index 476b206520073..675cde2ea955c 100644 --- a/src/sql-parser/src/ast/defs/statement.rs +++ b/src/sql-parser/src/ast/defs/statement.rs @@ -1904,6 +1904,8 @@ pub enum RoleAttribute { Inherit, /// The `NOINHERIT` option. NoInherit, + /// The `PASSWORD` option. + Password(Option), // The following are not supported, but included to give helpful error messages. Login, NoLogin, @@ -1932,6 +1934,7 @@ impl AstDisplay for RoleAttribute { RoleAttribute::NoCreateDB => f.write_str("NOCREATEDB"), RoleAttribute::CreateRole => f.write_str("CREATEROLE"), RoleAttribute::NoCreateRole => f.write_str("NOCREATEROLE"), + RoleAttribute::Password(_) => f.write_str("PASSWORD"), } } } diff --git a/src/sql-parser/src/parser.rs b/src/sql-parser/src/parser.rs index ae30d5a055bc9..47ee78e97c0a4 100644 --- a/src/sql-parser/src/parser.rs +++ b/src/sql-parser/src/parser.rs @@ -4141,11 +4141,11 @@ impl<'a> Parser<'a> { self.expect_keyword(ROLE)?; let name = self.parse_identifier()?; let _ = self.parse_keyword(WITH); - let options = self.parse_role_attributes(); + let options = self.parse_role_attributes()?; Ok(Statement::CreateRole(CreateRoleStatement { name, options })) } - fn parse_role_attributes(&mut self) -> Vec { + fn parse_role_attributes(&mut self) -> Result, ParserError> { let mut options = vec![]; loop { match self.parse_one_of_keywords(&[ @@ -4161,6 +4161,7 @@ impl<'a> Parser<'a> { NOCREATEDB, CREATEROLE, NOCREATEROLE, + PASSWORD, ]) { None => break, Some(SUPERUSER) => options.push(RoleAttribute::SuperUser), @@ -4175,10 +4176,18 @@ impl<'a> Parser<'a> { Some(NOCREATEDB) => options.push(RoleAttribute::NoCreateDB), Some(CREATEROLE) => options.push(RoleAttribute::CreateRole), Some(NOCREATEROLE) => options.push(RoleAttribute::NoCreateRole), + Some(PASSWORD) => { + if self.parse_keyword(NULL) { + options.push(RoleAttribute::Password(None)); + continue; + } + let password = self.parse_literal_string()?; + options.push(RoleAttribute::Password(Some(password))); + } Some(_) => unreachable!(), } } - options + Ok(options) } fn parse_create_secret(&mut self) -> Result, ParserError> { @@ -6115,7 +6124,7 @@ impl<'a> Parser<'a> { } Some(WITH) | None => { let _ = self.parse_keyword(WITH); - let attrs = self.parse_role_attributes(); + let attrs = self.parse_role_attributes()?; AlterRoleOption::Attributes(attrs) } Some(k) => unreachable!("unmatched keyword: {k}"), diff --git a/src/sql/BUILD.bazel b/src/sql/BUILD.bazel index d7c629fc3e3ae..2f62ed832f081 100644 --- a/src/sql/BUILD.bazel +++ b/src/sql/BUILD.bazel @@ -34,6 +34,7 @@ rust_library( "//src/adapter-types:mz_adapter_types", "//src/arrow-util:mz_arrow_util", "//src/audit-log:mz_audit_log", + "//src/auth:mz_auth", "//src/build-info:mz_build_info", "//src/ccsr:mz_ccsr", "//src/cloud-provider:mz_cloud_provider", @@ -98,6 +99,7 @@ rust_test( "//src/adapter-types:mz_adapter_types", "//src/arrow-util:mz_arrow_util", "//src/audit-log:mz_audit_log", + "//src/auth:mz_auth", "//src/build-info:mz_build_info", "//src/ccsr:mz_ccsr", "//src/cloud-provider:mz_cloud_provider", @@ -142,6 +144,7 @@ rust_doc_test( "//src/adapter-types:mz_adapter_types", "//src/arrow-util:mz_arrow_util", "//src/audit-log:mz_audit_log", + "//src/auth:mz_auth", "//src/build-info:mz_build_info", "//src/ccsr:mz_ccsr", "//src/cloud-provider:mz_cloud_provider", diff --git a/src/sql/Cargo.toml b/src/sql/Cargo.toml index 12e7380d16427..1a68a1026f310 100644 --- a/src/sql/Cargo.toml +++ b/src/sql/Cargo.toml @@ -35,6 +35,7 @@ mysql_async = { version = "0.35.1", default-features = false, features = [ mz-arrow-util = { path = "../arrow-util" } mz-adapter-types = { path = "../adapter-types" } mz-audit-log = { path = "../audit-log" } +mz-auth = { path = "../auth" } mz-build-info = { path = "../build-info" } mz-ccsr = { path = "../ccsr" } mz-cloud-provider = { path = "../cloud-provider", default-features = false } diff --git a/src/sql/src/catalog.rs b/src/sql/src/catalog.rs index acb083bd1ab78..67844de316a5c 100644 --- a/src/sql/src/catalog.rs +++ b/src/sql/src/catalog.rs @@ -21,6 +21,7 @@ use std::sync::LazyLock; use std::time::{Duration, Instant}; use chrono::{DateTime, Utc}; +use mz_auth::password::Password; use mz_build_info::BuildInfo; use mz_cloud_provider::{CloudProvider, InvalidCloudProviderError}; use mz_controller_types::{ClusterId, ReplicaId}; @@ -485,6 +486,12 @@ pub trait CatalogSchema { pub struct RoleAttributes { /// Indicates whether the role has inheritance of privileges. pub inherit: bool, + /// The raw password of the role. This is for self managed auth, not cloud. + pub password: Option, + /// Whether or not this user is a superuser. + pub superuser: Option, + /// Whether this role is login + pub login: Option, // Force use of constructor. _private: (), } @@ -494,11 +501,14 @@ impl RoleAttributes { pub const fn new() -> RoleAttributes { RoleAttributes { inherit: true, + password: None, + superuser: None, + login: None, _private: (), } } - /// Adds all attributes. + /// Adds all attributes except password. pub const fn with_all(mut self) -> RoleAttributes { self.inherit = true; self @@ -508,13 +518,40 @@ impl RoleAttributes { pub const fn is_inherit(&self) -> bool { self.inherit } + + /// Returns whether or not the role has a password. + pub const fn has_password(&self) -> bool { + self.password.is_some() + } + + /// Returns self without the password. + pub fn without_password(self) -> RoleAttributes { + RoleAttributes { + inherit: self.inherit, + password: None, + superuser: self.superuser, + login: self.login, + _private: (), + } + } } impl From for RoleAttributes { - fn from(PlannedRoleAttributes { inherit }: PlannedRoleAttributes) -> RoleAttributes { + fn from( + PlannedRoleAttributes { + inherit, + password, + superuser, + login, + .. + }: PlannedRoleAttributes, + ) -> RoleAttributes { let default_attributes = RoleAttributes::new(); RoleAttributes { inherit: inherit.unwrap_or(default_attributes.inherit), + password, + superuser, + login, _private: (), } } diff --git a/src/sql/src/plan/statement/ddl.rs b/src/sql/src/plan/statement/ddl.rs index 79ceabd206b2a..98d516372b8fc 100644 --- a/src/sql/src/plan/statement/ddl.rs +++ b/src/sql/src/plan/statement/ddl.rs @@ -20,6 +20,7 @@ use std::time::Duration; use itertools::{Either, Itertools}; use mz_adapter_types::compaction::{CompactionWindow, DEFAULT_LOGICAL_COMPACTION_WINDOW_DURATION}; use mz_adapter_types::dyncfgs::ENABLE_MULTI_REPLICA_SOURCES; +use mz_auth::password::Password; use mz_controller_types::{ClusterId, DEFAULT_REPLICA_LOGGING_INTERVAL, ReplicaId}; use mz_expr::{CollectionPlan, UnmaterializableFunc}; use mz_interchange::avro::{AvroSchemaGenerator, DocTarget}; @@ -4189,22 +4190,29 @@ pub enum PlannedAlterRoleOption { Variable(PlannedRoleVariable), } -#[derive(Debug)] +#[derive(Debug, Clone)] pub struct PlannedRoleAttributes { pub inherit: Option, + pub password: Option, + /// `nopassword` is set to true if the password is from the parser is None. + /// This is semantically different than not supplying a password at all, + /// to allow for unsetting a password. + pub nopassword: Option, + pub superuser: Option, + pub login: Option, } fn plan_role_attributes(options: Vec) -> Result { - let mut planned_attributes = PlannedRoleAttributes { inherit: None }; + let mut planned_attributes = PlannedRoleAttributes { + inherit: None, + password: None, + superuser: None, + login: None, + nopassword: None, + }; for option in options { match option { - RoleAttribute::Login | RoleAttribute::NoLogin => { - bail_never_supported!("LOGIN attribute", "sql/create-role/#details"); - } - RoleAttribute::SuperUser | RoleAttribute::NoSuperUser => { - bail_never_supported!("SUPERUSER attribute", "sql/create-role/#details"); - } RoleAttribute::Inherit | RoleAttribute::NoInherit if planned_attributes.inherit.is_some() => { @@ -4231,9 +4239,43 @@ fn plan_role_attributes(options: Vec) -> Result { + sql_bail!("conflicting or redundant options"); + } RoleAttribute::Inherit => planned_attributes.inherit = Some(true), RoleAttribute::NoInherit => planned_attributes.inherit = Some(false), + RoleAttribute::Password(password) => { + if let Some(password) = password { + planned_attributes.password = Some(password.into()); + } else { + planned_attributes.nopassword = Some(true); + } + } + RoleAttribute::SuperUser => { + if planned_attributes.superuser == Some(false) { + sql_bail!("conflicting or redundant options"); + } + planned_attributes.superuser = Some(true); + } + RoleAttribute::NoSuperUser => { + if planned_attributes.superuser == Some(true) { + sql_bail!("conflicting or redundant options"); + } + planned_attributes.superuser = Some(false); + } + RoleAttribute::Login => { + if planned_attributes.login == Some(false) { + sql_bail!("conflicting or redundant options"); + } + planned_attributes.login = Some(true); + } + RoleAttribute::NoLogin => { + if planned_attributes.login == Some(true) { + sql_bail!("conflicting or redundant options"); + } + planned_attributes.login = Some(false); + } } } if planned_attributes.inherit == Some(false) { diff --git a/src/sql/src/rbac.rs b/src/sql/src/rbac.rs index 25b86b71625db..4efe6fe519134 100644 --- a/src/sql/src/rbac.rs +++ b/src/sql/src/rbac.rs @@ -427,12 +427,21 @@ fn generate_rbac_requirements( } Plan::CreateRole(plan::CreateRolePlan { name: _, - attributes: _, - }) => RbacRequirements { - privileges: vec![(SystemObjectId::System, AclMode::CREATE_ROLE, role_id)], - item_usage: &CREATE_ITEM_USAGE, - ..Default::default() - }, + attributes, + }) => { + if attributes.superuser.unwrap_or(false) { + RbacRequirements { + superuser_action: Some("create superuser role".to_string()), + ..Default::default() + } + } else { + RbacRequirements { + privileges: vec![(SystemObjectId::System, AclMode::CREATE_ROLE, role_id)], + item_usage: &CREATE_ITEM_USAGE, + ..Default::default() + } + } + } Plan::CreateNetworkPolicy(plan::CreateNetworkPolicyPlan { .. }) => RbacRequirements { privileges: vec![( SystemObjectId::System, @@ -1165,6 +1174,30 @@ fn generate_rbac_requirements( name: _, option, }) => match option { + // Only superusers can alter the superuserness of a role. + plan::PlannedAlterRoleOption::Attributes(attributes) + if attributes.superuser.unwrap_or(false) => + { + RbacRequirements { + superuser_action: Some("alter superuser role".to_string()), + ..Default::default() + } + } + // Roles are allowed to change their own password. + plan::PlannedAlterRoleOption::Attributes(attributes) + if attributes.password.is_some() && role_id == *id => + { + RbacRequirements::default() + } + // But no one elses... + plan::PlannedAlterRoleOption::Attributes(attributes) + if attributes.password.is_some() => + { + RbacRequirements { + superuser_action: Some("alter password of role".to_string()), + ..Default::default() + } + } // Roles are allowed to change their own variables. plan::PlannedAlterRoleOption::Variable(_) if role_id == *id => { RbacRequirements::default() diff --git a/src/sql/src/session/user.rs b/src/sql/src/session/user.rs index d68d098fceddf..1ff00cca6376d 100644 --- a/src/sql/src/session/user.rs +++ b/src/sql/src/session/user.rs @@ -11,25 +11,28 @@ use std::collections::{BTreeMap, BTreeSet}; use std::sync::LazyLock; use mz_repr::role_id::RoleId; -use mz_repr::user::ExternalUserMetadata; +use mz_repr::user::{ExternalUserMetadata, InternalUserMetadata}; use serde::Serialize; pub const SYSTEM_USER_NAME: &str = "mz_system"; pub static SYSTEM_USER: LazyLock = LazyLock::new(|| User { name: SYSTEM_USER_NAME.into(), external_metadata: None, + internal_metadata: None, }); pub const SUPPORT_USER_NAME: &str = "mz_support"; pub static SUPPORT_USER: LazyLock = LazyLock::new(|| User { name: SUPPORT_USER_NAME.into(), external_metadata: None, + internal_metadata: None, }); pub const ANALYTICS_USER_NAME: &str = "mz_analytics"; pub static ANALYTICS_USER: LazyLock = LazyLock::new(|| User { name: ANALYTICS_USER_NAME.into(), external_metadata: None, + internal_metadata: None, }); pub static INTERNAL_USER_NAMES: LazyLock> = LazyLock::new(|| { @@ -54,6 +57,7 @@ pub static INTERNAL_USER_NAME_TO_DEFAULT_CLUSTER: LazyLock = LazyLock::new(|| User { name: "anonymous_http_user".into(), external_metadata: None, + internal_metadata: None, }); /// Identifies a user. @@ -63,6 +67,7 @@ pub struct User { pub name: String, /// Metadata about this user in an external system. pub external_metadata: Option, + pub internal_metadata: Option, } impl From<&User> for mz_pgwire_common::UserMetadata { @@ -95,6 +100,14 @@ impl User { .unwrap_or(false) } + pub fn is_internal_admin(&self) -> bool { + self.internal_metadata + .as_ref() + .map(|metadata| metadata.superuser) + .clone() + .unwrap_or(false) + } + /// Returns whether this user is a superuser. pub fn is_superuser(&self) -> bool { matches!(self.kind(), UserKind::Superuser) @@ -112,7 +125,7 @@ impl User { /// Returns the kind of user this is. pub fn kind(&self) -> UserKind { - if self.is_external_admin() || self.is_system_user() { + if self.is_external_admin() || self.is_system_user() || self.is_internal_admin() { UserKind::Superuser } else { UserKind::Regular diff --git a/src/sqllogictest/src/runner.rs b/src/sqllogictest/src/runner.rs index e2543e525b802..0a19f36a0a6c0 100644 --- a/src/sqllogictest/src/runner.rs +++ b/src/sqllogictest/src/runner.rs @@ -1072,6 +1072,8 @@ impl<'a> RunnerInner<'a> { cloud_resource_controller: None, tls: None, frontegg: None, + self_hosted_auth: false, + self_hosted_auth_internal: false, cors_allowed_origin: AllowOrigin::list([]), unsafe_mode: true, all_features: false, diff --git a/src/workspace-hack/Cargo.toml b/src/workspace-hack/Cargo.toml index 209a509f65442..98886a81d2d08 100644 --- a/src/workspace-hack/Cargo.toml +++ b/src/workspace-hack/Cargo.toml @@ -32,6 +32,8 @@ aws-smithy-runtime-api = { version = "1.7.4", features = ["client", "http-02x", aws-smithy-types = { version = "1.3.0", default-features = false, features = ["byte-stream-poll-next", "http-body-0-4-x", "http-body-1-x", "rt-tokio", "test-util"] } axum = { version = "0.7.5", features = ["ws"] } axum-core = { version = "0.4.5", default-features = false, features = ["tracing"] } +bit-set = { version = "0.8.0" } +bit-vec = { version = "0.8.0" } bitflags = { version = "2.4.1", default-features = false, features = ["std"] } bstr = { version = "1.10.0" } byteorder = { version = "1.5.0" } @@ -103,6 +105,7 @@ postgres = { git = "https://github.com/MaterializeInc/rust-postgres", default-fe postgres-types = { git = "https://github.com/MaterializeInc/rust-postgres", default-features = false, features = ["with-chrono-0_4", "with-serde_json-1", "with-uuid-1"] } predicates = { version = "3.1.3" } proc-macro2 = { version = "1.0.94", features = ["span-locations"] } +proptest = { version = "1.6.0" } prost = { version = "0.13.5", features = ["no-recursion-limit", "prost-derive"] } prost-reflect = { version = "0.14.7", default-features = false, features = ["serde"] } prost-types = { version = "0.13.5" } @@ -170,6 +173,8 @@ aws-smithy-runtime-api = { version = "1.7.4", features = ["client", "http-02x", aws-smithy-types = { version = "1.3.0", default-features = false, features = ["byte-stream-poll-next", "http-body-0-4-x", "http-body-1-x", "rt-tokio", "test-util"] } axum = { version = "0.7.5", features = ["ws"] } axum-core = { version = "0.4.5", default-features = false, features = ["tracing"] } +bit-set = { version = "0.8.0" } +bit-vec = { version = "0.8.0" } bitflags = { version = "2.4.1", default-features = false, features = ["std"] } bstr = { version = "1.10.0" } byteorder = { version = "1.5.0" } @@ -242,6 +247,7 @@ postgres = { git = "https://github.com/MaterializeInc/rust-postgres", default-fe postgres-types = { git = "https://github.com/MaterializeInc/rust-postgres", default-features = false, features = ["with-chrono-0_4", "with-serde_json-1", "with-uuid-1"] } predicates = { version = "3.1.3" } proc-macro2 = { version = "1.0.94", features = ["span-locations"] } +proptest = { version = "1.6.0" } proptest-derive = { version = "0.5.1", default-features = false, features = ["boxed_union"] } prost = { version = "0.13.5", features = ["no-recursion-limit", "prost-derive"] } prost-reflect = { version = "0.14.7", default-features = false, features = ["serde"] } diff --git a/test/sqllogictest/role.slt b/test/sqllogictest/role.slt index 72bedcf3ecb59..42d0855aa4cdf 100644 --- a/test/sqllogictest/role.slt +++ b/test/sqllogictest/role.slt @@ -47,11 +47,14 @@ COMPLETE 0 statement error non inherit roles not yet supported CREATE ROLE foo NOINHERIT -statement error LOGIN attribute is not supported, for more information consult the documentation at +statement error db error: ERROR: SUPERUSER, PASSWORD, and LOGIN attributes is not supported in this environment. For more information consult the documentation at https://materialize.com/docs/sql/create-role/#details CREATE ROLE foo LOGIN -statement error SUPERUSER attribute is not supported, for more information consult the documentation at +simple CREATE ROLE foo SUPERUSER +---- +db error: ERROR: permission denied to create superuser role +DETAIL: You must be a superuser to create superuser role statement error conflicting or redundant options CREATE ROLE foo INHERIT INHERIT diff --git a/test/sqllogictest/role_create.slt b/test/sqllogictest/role_create.slt index a85f575ccba6a..c6e6651805b03 100644 --- a/test/sqllogictest/role_create.slt +++ b/test/sqllogictest/role_create.slt @@ -63,7 +63,8 @@ COMPLETE 0 simple conn=regress_role_limited_admin,user=regress_role_limited_admin CREATE ROLE regress_nosuch_superuser SUPERUSER; ---- -db error: ERROR: SUPERUSER attribute is not supported, for more information consult the documentation at https://materialize.com/docs/sql/create-role/#details +db error: ERROR: permission denied to create superuser role +DETAIL: You must be a superuser to create superuser role simple conn=regress_role_limited_admin,user=regress_role_limited_admin CREATE ROLE regress_nosuch_createdb CREATEDB; @@ -141,12 +142,13 @@ DETAIL: Use system privileges instead. simple conn=regress_role_admin,user=regress_role_admin ALTER ROLE regress_createdb SUPERUSER; ---- -db error: ERROR: SUPERUSER attribute is not supported, for more information consult the documentation at https://materialize.com/docs/sql/create-role/#details +db error: ERROR: permission denied to alter superuser role +DETAIL: You must be a superuser to alter superuser role simple conn=regress_role_admin,user=regress_role_admin ALTER ROLE regress_createdb NOSUPERUSER; ---- -db error: ERROR: SUPERUSER attribute is not supported, for more information consult the documentation at https://materialize.com/docs/sql/create-role/#details +db error: ERROR: SUPERUSER, PASSWORD, and LOGIN attributes is not supported in this environment. For more information consult the documentation at https://materialize.com/docs/sql/create-role/#details simple conn=regress_role_admin,user=regress_role_admin CREATE ROLE regress_createrole; @@ -163,10 +165,15 @@ CREATE ROLE regress_connection_limit CONNECTION LIMIT 5; ---- db error: ERROR: Expected end of statement, found CONNECTION +# You might think to yourself "why is creating a role with PASSWORD NULL +# allowed? Especially when self hosted auth isn't enabled?" +# The answer is unsatisfying: it's a legacy behavior from Postgres. +# Creating a role with a null password is the same as not specifying a password at all. +# So, uh, sure... simple conn=regress_role_admin,user=regress_role_admin CREATE ROLE regress_password_null PASSWORD NULL; ---- -db error: ERROR: Expected end of statement, found PASSWORD +COMPLETE 0 simple conn=regress_role_admin,user=regress_role_admin CREATE ROLE regress_noiseword SYSID 12345; @@ -231,9 +238,62 @@ db error: ERROR: Expected end of statement, found identifier "noreplication" simple conn=regress_role_admin,user=regress_role_admin CREATE ROLE regress_noiseword LOGIN; ---- -db error: ERROR: LOGIN attribute is not supported, for more information consult the documentation at https://materialize.com/docs/sql/create-role/#details +db error: ERROR: SUPERUSER, PASSWORD, and LOGIN attributes is not supported in this environment. For more information consult the documentation at https://materialize.com/docs/sql/create-role/#details simple conn=regress_role_admin,user=regress_role_admin CREATE ROLE regress_noiseword NOLOGIN; ---- -db error: ERROR: LOGIN attribute is not supported, for more information consult the documentation at https://materialize.com/docs/sql/create-role/#details +db error: ERROR: SUPERUSER, PASSWORD, and LOGIN attributes is not supported in this environment. For more information consult the documentation at https://materialize.com/docs/sql/create-role/#details + +simple conn=mz_system,user=mz_system +ALTER SYSTEM SET enable_self_managed_auth = true +---- +COMPLETE 0 + +simple conn=regress_role_admin,user=regress_role_admin +CREATE ROLE password_role WITH PASSWORD 'password'; +---- +COMPLETE 0 + +simple conn=regress_role_admin,user=regress_role_admin +CREATE ROLE login_password_role WITH LOGIN PASSWORD 'password'; +---- +COMPLETE 0 + +simple conn=regress_role_admin,user=regress_role_admin +ALTER ROLE password_role WITH PASSWORD 'new_password'; +---- +db error: ERROR: permission denied to alter password of role +DETAIL: You must be a superuser to alter password of role + +simple conn=regress_role_admin,user=regress_role_admin +ALTER ROLE regress_role_admin WITH PASSWORD 'new_password'; +---- +COMPLETE 0 + +simple conn=regress_role_admin,user=regress_role_admin +ALTER ROLE password_role WITH PASSWORD NULL; +---- +COMPLETE 0 + +simple conn=regress_role_admin,user=regress_role_admin +ALTER ROLE password_role WITH PASSWORD 123; +---- +db error: ERROR: Expected literal string, found number "123" + +simple conn=regress_role_admin,user=regress_role_admin +CREATE ROLE superuser_login_password_role WITH SUPERUSER LOGIN PASSWORD 'password'; +---- +db error: ERROR: permission denied to create superuser role +DETAIL: You must be a superuser to create superuser role + +simple conn=regress_role_admin,user=regress_role_admin +ALTER ROLE password_role WITH SUPERUSER; +---- +db error: ERROR: permission denied to alter superuser role +DETAIL: You must be a superuser to alter superuser role + +simple conn=regress_role_admin,user=regress_role_admin +DROP ROLE password_role; +---- +COMPLETE 0