From c393b96da3aeacd9c4c250ae494ca4a3e3e57aef Mon Sep 17 00:00:00 2001 From: archipelago Date: Thu, 11 Jun 2026 00:24:32 -0400 Subject: [PATCH] backend: harden rootless app lifecycle orchestration --- .../src/api/handler/node_message.rs | 16 + core/archipelago/src/api/rpc/analytics.rs | 24 + core/archipelago/src/api/rpc/auth.rs | 10 +- core/archipelago/src/api/rpc/bitcoin_relay.rs | 900 ++++++++ core/archipelago/src/api/rpc/container.rs | 323 ++- core/archipelago/src/api/rpc/dispatcher.rs | 14 + core/archipelago/src/api/rpc/lnd/wallet.rs | 7 +- core/archipelago/src/api/rpc/mod.rs | 2 + .../archipelago/src/api/rpc/package/config.rs | 23 +- .../src/api/rpc/package/dependencies.rs | 9 - .../src/api/rpc/package/install.rs | 373 +++- .../src/api/rpc/package/runtime.rs | 759 ++++++- .../archipelago/src/api/rpc/package/stacks.rs | 1955 +++++++---------- .../archipelago/src/api/rpc/package/update.rs | 46 +- .../src/api/rpc/system/handlers.rs | 147 +- core/archipelago/src/api/rpc/system/mod.rs | 393 +++- core/archipelago/src/auth.rs | 38 +- core/archipelago/src/bitcoin_status.rs | 85 +- .../container/bitcoin_ui_nginx.conf.template | 10 + .../src/container/boot_reconciler.rs | 99 +- core/archipelago/src/container/companion.rs | 77 +- .../src/container/docker_packages.rs | 52 +- core/archipelago/src/container/filebrowser.rs | 86 +- .../src/container/image_versions.rs | 26 + core/archipelago/src/container/lnd.rs | 3 +- .../src/container/prod_orchestrator.rs | 1246 ++++++++++- core/archipelago/src/container/quadlet.rs | 289 ++- core/archipelago/src/crash_recovery.rs | 385 +++- core/archipelago/src/electrs_status.rs | 12 +- core/archipelago/src/health_monitor.rs | 160 +- core/archipelago/src/main.rs | 29 +- .../src/monitoring/notifications.rs | 76 +- core/archipelago/src/monitoring/telemetry.rs | 80 +- core/archipelago/src/server.rs | 198 +- core/container/src/lib.rs | 6 +- core/container/src/manifest.rs | 463 +++- core/container/src/podman_client.rs | 8 +- core/container/src/runtime.rs | 37 +- docker/bitcoin-ui/index.html | 309 ++- docker/fedimint-ui/Dockerfile | 16 + .../assets/img/app-icons/fedimint.jpg | Bin 0 -> 41944 bytes .../assets/img/app-icons/fedimint.png | Bin 0 -> 41944 bytes docker/fedimint-ui/assets/img/bg-network.jpg | Bin 0 -> 999074 bytes docker/fedimint-ui/index.html | 452 ++++ docker/fedimint-ui/nginx.conf | 30 + image-recipe/configs/archipelago.service | 1 + image-recipe/configs/nginx-archipelago.conf | 45 +- image-recipe/scripts/install-podman.sh | 13 + scripts/container-specs.sh | 12 +- scripts/deploy-config.example | 4 + scripts/deploy-tailscale.sh | 12 +- scripts/deploy-to-target.sh | 28 + scripts/first-boot-containers.sh | 26 +- scripts/fix-indeedhub-containers.sh | 3 +- scripts/reconcile-containers.sh | 54 +- tests/lifecycle/remote-lifecycle.sh | 66 +- 56 files changed, 7543 insertions(+), 1994 deletions(-) create mode 100644 core/archipelago/src/api/rpc/bitcoin_relay.rs create mode 100644 docker/fedimint-ui/Dockerfile create mode 100644 docker/fedimint-ui/assets/img/app-icons/fedimint.jpg create mode 100644 docker/fedimint-ui/assets/img/app-icons/fedimint.png create mode 100644 docker/fedimint-ui/assets/img/bg-network.jpg create mode 100644 docker/fedimint-ui/index.html create mode 100644 docker/fedimint-ui/nginx.conf diff --git a/core/archipelago/src/api/handler/node_message.rs b/core/archipelago/src/api/handler/node_message.rs index a1879ef1..d0d794d3 100644 --- a/core/archipelago/src/api/handler/node_message.rs +++ b/core/archipelago/src/api/handler/node_message.rs @@ -128,6 +128,22 @@ impl ApiHandler { hyper::Body::from(r#"{"ok":true,"handled":"connection_accepted"}"#), )); } + + if let Some(handled) = + crate::api::rpc::bitcoin_relay::record_incoming_relay_message( + std::path::Path::new("/var/lib/archipelago"), + from, + incoming.from_name.as_deref(), + &val, + ) + .await? + { + return Ok(build_response( + StatusCode::OK, + "application/json", + hyper::Body::from(format!(r#"{{"ok":true,"handled":"{}"}}"#, handled)), + )); + } } let safe_from = sanitize_log_string(from); diff --git a/core/archipelago/src/api/rpc/analytics.rs b/core/archipelago/src/api/rpc/analytics.rs index 8f261e86..817e9f41 100644 --- a/core/archipelago/src/api/rpc/analytics.rs +++ b/core/archipelago/src/api/rpc/analytics.rs @@ -189,6 +189,27 @@ impl RpcHandler { .map(|f| f as u64) .unwrap_or(0); + let latest = self.metrics_store.latest().await; + let (cpu_pct, mem_pct, disk_pct): (f64, f64, f64) = latest + .map(|s| { + let mem_total = s.system.mem_total_bytes as f64; + let disk_total = s.system.disk_total_bytes as f64; + ( + s.system.cpu_percent, + if mem_total > 0.0 { + (s.system.mem_used_bytes as f64 / mem_total) * 100.0 + } else { + 0.0 + }, + if disk_total > 0.0 { + (s.system.disk_used_bytes as f64 / disk_total) * 100.0 + } else { + 0.0 + }, + ) + }) + .unwrap_or((0.0, 0.0, 0.0)); + // Recent alerts from metrics store let recent_alerts: Vec = self .metrics_store @@ -210,6 +231,9 @@ impl RpcHandler { "uptime_secs": uptime_secs, "cpu_cores": cpu_cores, "ram_mb": total_ram_mb, + "cpu_pct": (cpu_pct * 10.0).round() / 10.0, + "mem_pct": (mem_pct * 10.0).round() / 10.0, + "disk_pct": (disk_pct * 10.0).round() / 10.0, "containers": containers, "container_count": data.package_data.len(), "running_count": data.package_data.values() diff --git a/core/archipelago/src/api/rpc/auth.rs b/core/archipelago/src/api/rpc/auth.rs index 5c433c95..d15685f4 100644 --- a/core/archipelago/src/api/rpc/auth.rs +++ b/core/archipelago/src/api/rpc/auth.rs @@ -79,7 +79,8 @@ impl RpcHandler { .and_then(|v| v.as_bool()) .unwrap_or(true); - self.auth_manager + let outcome = self + .auth_manager .change_password(current_password, new_password, also_change_ssh) .await?; @@ -88,7 +89,12 @@ impl RpcHandler { self.session_store.invalidate_all_except(token).await; } - Ok(serde_json::json!({ "success": true, "session_rotated": true })) + Ok(serde_json::json!({ + "success": true, + "session_rotated": true, + "ssh_updated": outcome.ssh_updated, + "ssh_error": outcome.ssh_error, + })) } pub(super) async fn handle_auth_is_setup(&self) -> Result { diff --git a/core/archipelago/src/api/rpc/bitcoin_relay.rs b/core/archipelago/src/api/rpc/bitcoin_relay.rs new file mode 100644 index 00000000..429489e7 --- /dev/null +++ b/core/archipelago/src/api/rpc/bitcoin_relay.rs @@ -0,0 +1,900 @@ +use super::RpcHandler; +use crate::container::docker_packages; +use crate::data_model::{Notification, NotificationLevel}; +use crate::{bitcoin_status, identity, peers}; +use anyhow::{Context, Result}; +use base64::{engine::general_purpose::STANDARD as BASE64, Engine as _}; +use hmac::{Hmac, Mac}; +use rand::RngCore; +use serde::{Deserialize, Serialize}; +use serde_json::json; +use sha2::Sha256; +use std::path::{Path, PathBuf}; +use tokio::fs; + +const RELAY_DIR: &str = "bitcoin-relay"; +const RELAY_STATE_FILE: &str = "state.json"; +const TXRELAY_USER: &str = "txrelay"; +const TXRELAY_PASSWORD_FILE: &str = "bitcoin-rpc-txrelay-password"; +const TXRELAY_RPCAUTH_FILE: &str = "bitcoin-rpc-txrelay-rpcauth"; +const TXRELAY_CLIENT_ENV_FILE: &str = "bitcoin-rpc-txrelay-client.env"; + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(default)] +struct BitcoinRelayState { + settings: BitcoinRelaySettings, + requests: Vec, + updated_at: Option, +} + +impl Default for BitcoinRelayState { + fn default() -> Self { + Self { + settings: BitcoinRelaySettings::default(), + requests: Vec::new(), + updated_at: None, + } + } +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(default)] +struct BitcoinRelaySettings { + enabled_for_peers: bool, + allow_peer_requests: bool, + allow_http: bool, + allow_https: bool, + allow_tor: bool, + selected_peer_pubkey: Option, + http_endpoint: Option, + https_endpoint: Option, + tor_endpoint: Option, +} + +impl Default for BitcoinRelaySettings { + fn default() -> Self { + Self { + enabled_for_peers: false, + allow_peer_requests: false, + allow_http: false, + allow_https: true, + allow_tor: false, + selected_peer_pubkey: None, + http_endpoint: None, + https_endpoint: None, + tor_endpoint: None, + } + } +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +struct BitcoinRelayRequest { + id: String, + direction: RelayRequestDirection, + status: RelayRequestStatus, + peer_pubkey: String, + peer_onion: String, + peer_name: Option, + message: Option, + approved_endpoint: Option, + credential_secret_path: Option, + created_at: String, + updated_at: String, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "lowercase")] +enum RelayRequestDirection { + Incoming, + Outbound, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "lowercase")] +enum RelayRequestStatus { + Pending, + Approved, + Rejected, +} + +#[derive(Debug, Serialize)] +struct TrustedRelayPeer { + pubkey: String, + onion: String, + name: Option, + relay_approved: bool, +} + +#[derive(Debug, Clone)] +struct TxRelayCredentials { + username: String, + password: String, +} + +impl RpcHandler { + pub(super) async fn handle_bitcoin_relay_status(&self) -> Result { + let mut state = load_relay_state(&self.config.data_dir).await?; + hydrate_tor_endpoint(&self.config.data_dir, &mut state).await; + let known_peers = peers::load_peers(&self.config.data_dir) + .await + .unwrap_or_default(); + let trusted_nodes = trusted_relay_peers(&known_peers, &state); + let local_node = local_sync_status().await; + let credential_status = txrelay_credential_status(&self.config.data_dir).await; + + Ok(json!({ + "settings": state.settings, + "trusted_nodes": trusted_nodes, + "requests": state.requests, + "local_node": local_node, + "credentials": credential_status, + })) + } + + pub(super) async fn handle_bitcoin_relay_update_settings( + &self, + params: Option, + ) -> Result { + let params = params.unwrap_or_default(); + let mut state = load_relay_state(&self.config.data_dir).await?; + let known_peers = peers::load_peers(&self.config.data_dir) + .await + .unwrap_or_default(); + + update_bool( + ¶ms, + "enabled_for_peers", + &mut state.settings.enabled_for_peers, + ); + update_bool( + ¶ms, + "allow_peer_requests", + &mut state.settings.allow_peer_requests, + ); + update_bool(¶ms, "allow_http", &mut state.settings.allow_http); + update_bool(¶ms, "allow_https", &mut state.settings.allow_https); + update_bool(¶ms, "allow_tor", &mut state.settings.allow_tor); + + update_endpoint(¶ms, "http_endpoint", &mut state.settings.http_endpoint)?; + update_endpoint( + ¶ms, + "https_endpoint", + &mut state.settings.https_endpoint, + )?; + update_endpoint(¶ms, "tor_endpoint", &mut state.settings.tor_endpoint)?; + + if state.settings.enabled_for_peers { + ensure_txrelay_credentials(&self.config.data_dir).await?; + } + + if params.get("selected_peer_pubkey").is_some() { + let selected = params + .get("selected_peer_pubkey") + .and_then(|v| v.as_str()) + .map(str::trim) + .filter(|s| !s.is_empty()); + if let Some(pubkey) = selected { + if !known_peers.iter().any(|p| p.pubkey == pubkey) { + anyhow::bail!("Selected relay peer is not in trusted nodes"); + } + state.settings.selected_peer_pubkey = Some(pubkey.to_string()); + } else { + state.settings.selected_peer_pubkey = None; + } + } + + state.updated_at = Some(now()); + save_relay_state(&self.config.data_dir, &state).await?; + self.notify( + "Bitcoin relay settings updated", + "Transaction relay sharing preferences were saved.", + ) + .await; + self.handle_bitcoin_relay_status().await + } + + pub(super) async fn handle_bitcoin_relay_request_peer( + &self, + params: Option, + ) -> Result { + let params = params.unwrap_or_default(); + let peer_pubkey = params + .get("peer_pubkey") + .and_then(|v| v.as_str()) + .ok_or_else(|| anyhow::anyhow!("Missing required parameter: peer_pubkey"))?; + let message = params + .get("message") + .and_then(|v| v.as_str()) + .map(sanitize_optional_text) + .transpose()?; + let peer = peers::load_peers(&self.config.data_dir) + .await + .unwrap_or_default() + .into_iter() + .find(|p| p.pubkey == peer_pubkey) + .ok_or_else(|| anyhow::anyhow!("Peer is not in trusted nodes"))?; + + let mut state = load_relay_state(&self.config.data_dir).await?; + let existing = state.requests.iter_mut().find(|r| { + r.direction == RelayRequestDirection::Outbound + && r.peer_pubkey == peer.pubkey + && r.status == RelayRequestStatus::Pending + }); + let request_id = if let Some(req) = existing { + req.message = message.clone(); + req.updated_at = now(); + req.id.clone() + } else { + let timestamp = now(); + let req = BitcoinRelayRequest { + id: uuid::Uuid::new_v4().to_string(), + direction: RelayRequestDirection::Outbound, + status: RelayRequestStatus::Pending, + peer_pubkey: peer.pubkey.clone(), + peer_onion: peer.onion.clone(), + peer_name: peer.name.clone(), + message: message.clone(), + approved_endpoint: None, + credential_secret_path: None, + created_at: timestamp.clone(), + updated_at: timestamp, + }; + let id = req.id.clone(); + state.requests.push(req); + id + }; + state.updated_at = Some(now()); + save_relay_state(&self.config.data_dir, &state).await?; + + if let Err(e) = self + .send_relay_peer_message( + &peer, + json!({ + "type": "bitcoin_relay_request", + "request_id": request_id, + "message": message, + }), + ) + .await + { + tracing::warn!(peer = %peer.onion, error = %e, "Failed to send Bitcoin relay request"); + } + + self.notify( + "Bitcoin relay request sent", + "A trusted peer was asked to approve transaction relay access.", + ) + .await; + Ok(json!({ "ok": true, "request_id": request_id })) + } + + pub(super) async fn handle_bitcoin_relay_approve_request( + &self, + params: Option, + ) -> Result { + self.update_relay_request_status(params, RelayRequestStatus::Approved) + .await + } + + pub(super) async fn handle_bitcoin_relay_reject_request( + &self, + params: Option, + ) -> Result { + self.update_relay_request_status(params, RelayRequestStatus::Rejected) + .await + } + + pub(super) async fn handle_bitcoin_relay_create_tor_service( + &self, + ) -> Result { + let params = json!({ + "name": "bitcoin-rpc", + "local_port": 80, + "remote_port": 80, + }); + let created = match self.handle_tor_create_service(Some(params)).await { + Ok(v) => v, + Err(e) if e.to_string().contains("already exists") => { + self.handle_tor_get_onion_address(Some(json!({ "name": "bitcoin-rpc" }))) + .await? + } + Err(e) => return Err(e), + }; + + let onion = created + .get("onion_address") + .and_then(|v| v.as_str()) + .map(|s| s.trim().to_string()) + .filter(|s| !s.is_empty()); + if let Some(onion) = onion { + let mut state = load_relay_state(&self.config.data_dir).await?; + state.settings.allow_tor = true; + state.settings.tor_endpoint = Some(format!("http://{onion}/")); + state.updated_at = Some(now()); + save_relay_state(&self.config.data_dir, &state).await?; + } + + self.notify( + "Bitcoin relay Tor service enabled", + "A Tor endpoint was created for Bitcoin transaction relay access.", + ) + .await; + Ok(created) + } + + async fn update_relay_request_status( + &self, + params: Option, + status: RelayRequestStatus, + ) -> Result { + let params = params.unwrap_or_default(); + let request_id = params + .get("id") + .or_else(|| params.get("request_id")) + .and_then(|v| v.as_str()) + .ok_or_else(|| anyhow::anyhow!("Missing required parameter: id"))?; + let mut state = load_relay_state(&self.config.data_dir).await?; + let serving_endpoint = if status == RelayRequestStatus::Approved { + preferred_endpoint(&state.settings) + } else { + None + }; + let request_direction = state + .requests + .iter() + .find(|r| r.id == request_id) + .ok_or_else(|| anyhow::anyhow!("Request not found: {}", request_id))? + .direction; + if status == RelayRequestStatus::Approved + && request_direction == RelayRequestDirection::Incoming + && serving_endpoint.is_none() + { + anyhow::bail!( + "Configure an HTTP, HTTPS, or Tor relay endpoint before approving access" + ); + } + let credentials = if status == RelayRequestStatus::Approved { + Some(ensure_txrelay_credentials(&self.config.data_dir).await?) + } else { + None + }; + let (peer_pubkey, peer_onion, peer_name, direction) = { + let req = state + .requests + .iter_mut() + .find(|r| r.id == request_id) + .ok_or_else(|| anyhow::anyhow!("Request not found: {}", request_id))?; + req.status = status; + req.updated_at = now(); + if let Some(endpoint) = &serving_endpoint { + req.approved_endpoint = Some(endpoint.clone()); + } + ( + req.peer_pubkey.clone(), + req.peer_onion.clone(), + req.peer_name.clone(), + req.direction, + ) + }; + let peer = peers::load_peers(&self.config.data_dir) + .await + .unwrap_or_default() + .into_iter() + .find(|p| p.pubkey == peer_pubkey); + let peer_name = peer_name.unwrap_or_else(|| peer_onion.clone()); + state.updated_at = Some(now()); + save_relay_state(&self.config.data_dir, &state).await?; + + if let Some(peer) = peer { + let message_type = match status { + RelayRequestStatus::Approved => "bitcoin_relay_approved", + RelayRequestStatus::Rejected => "bitcoin_relay_rejected", + RelayRequestStatus::Pending => "bitcoin_relay_pending", + }; + if let Err(e) = self + .send_relay_peer_message( + &peer, + relay_response_payload( + message_type, + request_id, + direction, + serving_endpoint.as_deref(), + credentials.as_ref(), + ), + ) + .await + { + tracing::warn!(peer = %peer.onion, error = %e, "Failed to send Bitcoin relay response"); + } + } + + let title = match status { + RelayRequestStatus::Approved => "Bitcoin relay request approved", + RelayRequestStatus::Rejected => "Bitcoin relay request rejected", + RelayRequestStatus::Pending => "Bitcoin relay request updated", + }; + self.notify( + title, + &format!("Relay access request for {peer_name} was updated."), + ) + .await; + Ok(json!({ "ok": true, "request_id": request_id })) + } + + async fn send_relay_peer_message( + &self, + peer: &peers::KnownPeer, + mut payload: serde_json::Value, + ) -> Result<()> { + let (data, _) = self.state_manager.get_snapshot().await; + let my_pubkey = data.server_info.pubkey.clone(); + let my_did = identity::did_key_from_pubkey_hex(&my_pubkey).ok(); + let my_onion = docker_packages::read_tor_address("archipelago") + .await + .unwrap_or_default(); + payload["from_did"] = my_did.map(serde_json::Value::String).unwrap_or_default(); + payload["from_pubkey"] = serde_json::Value::String(my_pubkey.clone()); + payload["from_onion"] = serde_json::Value::String(my_onion); + payload["from_name"] = data + .server_info + .name + .clone() + .map(serde_json::Value::String) + .unwrap_or_default(); + + let to_fips_npub = + crate::federation::fips_npub_for_onion(&self.config.data_dir, &peer.onion).await; + let identity_dir = self.config.data_dir.join("identity"); + let signing_key = crate::identity::NodeIdentity::load_or_create(&identity_dir) + .await + .ok(); + crate::node_message::send_to_peer( + &peer.onion, + to_fips_npub.as_deref(), + &my_pubkey, + &payload.to_string(), + signing_key.as_ref().map(|i| i.signing_key()), + Some(&peer.pubkey), + data.server_info.name.as_deref(), + ) + .await + } + + async fn notify(&self, title: &str, message: &str) { + let (mut data, _) = self.state_manager.get_snapshot().await; + data.notifications.push(Notification { + id: format!("bitcoin-relay-{}", uuid::Uuid::new_v4()), + level: NotificationLevel::Info, + title: title.to_string(), + message: message.to_string(), + timestamp: now(), + app_id: Some("bitcoin-knots".to_string()), + }); + let len = data.notifications.len(); + if len > 30 { + data.notifications.drain(0..len - 30); + } + self.state_manager.update_data(data).await; + } +} + +pub(crate) async fn record_incoming_relay_message( + data_dir: &Path, + from_pubkey: &str, + from_name: Option<&str>, + payload: &serde_json::Value, +) -> Result> { + let msg_type = payload.get("type").and_then(|v| v.as_str()).unwrap_or(""); + match msg_type { + "bitcoin_relay_request" => { + let from_onion = payload + .get("from_onion") + .and_then(|v| v.as_str()) + .unwrap_or_default() + .to_string(); + let message = payload + .get("message") + .and_then(|v| v.as_str()) + .map(sanitize_optional_text) + .transpose()?; + let remote_request_id = payload + .get("request_id") + .and_then(|v| v.as_str()) + .unwrap_or_default(); + let mut state = load_relay_state(data_dir).await?; + if !state.settings.allow_peer_requests { + return Ok(Some("bitcoin_relay_request_disabled")); + } + if !state.requests.iter().any(|r| { + r.direction == RelayRequestDirection::Incoming + && r.peer_pubkey == from_pubkey + && r.status == RelayRequestStatus::Pending + }) { + let timestamp = now(); + state.requests.push(BitcoinRelayRequest { + id: if remote_request_id.is_empty() { + uuid::Uuid::new_v4().to_string() + } else { + remote_request_id.to_string() + }, + direction: RelayRequestDirection::Incoming, + status: RelayRequestStatus::Pending, + peer_pubkey: from_pubkey.to_string(), + peer_onion: from_onion, + peer_name: from_name.map(String::from), + message, + approved_endpoint: None, + credential_secret_path: None, + created_at: timestamp.clone(), + updated_at: timestamp, + }); + state.updated_at = Some(now()); + save_relay_state(data_dir, &state).await?; + } + Ok(Some("bitcoin_relay_request")) + } + "bitcoin_relay_approved" | "bitcoin_relay_rejected" => { + let request_id = payload.get("request_id").and_then(|v| v.as_str()); + let mut state = load_relay_state(data_dir).await?; + let status = if msg_type == "bitcoin_relay_approved" { + RelayRequestStatus::Approved + } else { + RelayRequestStatus::Rejected + }; + let approved_access = if status == RelayRequestStatus::Approved { + save_peer_relay_access(data_dir, from_pubkey, payload).await? + } else { + None + }; + if let Some(req) = state.requests.iter_mut().find(|r| { + r.direction == RelayRequestDirection::Outbound + && r.peer_pubkey == from_pubkey + && request_id.map(|id| id == r.id).unwrap_or(true) + }) { + req.status = status; + req.updated_at = now(); + if let Some((endpoint, secret_path)) = approved_access { + req.approved_endpoint = Some(endpoint); + req.credential_secret_path = Some(secret_path); + } + state.updated_at = Some(now()); + save_relay_state(data_dir, &state).await?; + } + Ok(Some(if msg_type == "bitcoin_relay_approved" { + "bitcoin_relay_approved" + } else { + "bitcoin_relay_rejected" + })) + } + _ => Ok(None), + } +} + +fn trusted_relay_peers( + known_peers: &[peers::KnownPeer], + state: &BitcoinRelayState, +) -> Vec { + known_peers + .iter() + .map(|peer| TrustedRelayPeer { + pubkey: peer.pubkey.clone(), + onion: peer.onion.clone(), + name: peer.name.clone(), + relay_approved: state.requests.iter().any(|req| { + req.peer_pubkey == peer.pubkey && req.status == RelayRequestStatus::Approved + }), + }) + .collect() +} + +async fn txrelay_credential_status(data_dir: &Path) -> serde_json::Value { + let (password_path, rpcauth_path, client_env_path) = txrelay_secret_paths(data_dir); + let password_available = fs::metadata(&password_path).await.is_ok(); + let rpcauth_available = fs::metadata(&rpcauth_path).await.is_ok(); + let client_env_available = fs::metadata(&client_env_path).await.is_ok(); + json!({ + "username": TXRELAY_USER, + "available": password_available && rpcauth_available && client_env_available, + "password_available": password_available, + "rpcauth_available": rpcauth_available, + "client_env_available": client_env_available, + "client_env_path": client_env_path.display().to_string(), + "restart_hint": "If this was just generated, restart Bitcoin Core/Knots so bitcoind loads the txrelay rpcauth whitelist.", + }) +} + +async fn ensure_txrelay_credentials(data_dir: &Path) -> Result { + let (password_path, rpcauth_path, client_env_path) = txrelay_secret_paths(data_dir); + let password = match read_trimmed(&password_path).await { + Some(value) => value, + None => { + let generated = generate_random_password(); + write_secret_file(&password_path, &generated).await?; + generated + } + }; + let rpcauth = match read_trimmed(&rpcauth_path).await { + Some(value) => value, + None => { + let generated = generate_rpcauth(TXRELAY_USER, &password); + write_secret_file(&rpcauth_path, &generated).await?; + generated + } + }; + let client_env = format!( + "BITCOIN_RPC_TXRELAY_USER={}\nBITCOIN_RPC_TXRELAY_PASSWORD={}\nBITCOIN_RPC_TXRELAY_RPCAUTH={}\n", + TXRELAY_USER, password, rpcauth + ); + write_secret_file(&client_env_path, &client_env).await?; + + Ok(TxRelayCredentials { + username: TXRELAY_USER.to_string(), + password, + }) +} + +fn txrelay_secret_paths(data_dir: &Path) -> (PathBuf, PathBuf, PathBuf) { + let secrets_dir = data_dir.join("secrets"); + ( + secrets_dir.join(TXRELAY_PASSWORD_FILE), + secrets_dir.join(TXRELAY_RPCAUTH_FILE), + secrets_dir.join(TXRELAY_CLIENT_ENV_FILE), + ) +} + +async fn read_trimmed(path: &Path) -> Option { + fs::read_to_string(path) + .await + .ok() + .map(|s| s.trim().to_string()) + .filter(|s| !s.is_empty()) +} + +async fn write_secret_file(path: &Path, contents: &str) -> Result<()> { + if let Some(parent) = path.parent() { + fs::create_dir_all(parent).await?; + } + fs::write(path, contents).await?; + set_private_permissions(path).await; + Ok(()) +} + +async fn set_private_permissions(path: &Path) { + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + let _ = fs::set_permissions(path, std::fs::Permissions::from_mode(0o600)).await; + } +} + +fn generate_random_password() -> String { + let mut bytes = [0u8; 32]; + rand::rngs::OsRng.fill_bytes(&mut bytes); + BASE64.encode(bytes) +} + +fn generate_rpcauth(username: &str, password: &str) -> String { + let mut salt_bytes = [0u8; 16]; + rand::rngs::OsRng.fill_bytes(&mut salt_bytes); + let salt_hex = hex::encode(salt_bytes); + let mut mac = + Hmac::::new_from_slice(salt_hex.as_bytes()).expect("HMAC accepts any key length"); + mac.update(password.as_bytes()); + let hash_hex = hex::encode(mac.finalize().into_bytes()); + format!("{username}:{salt_hex}${hash_hex}") +} + +fn preferred_endpoint(settings: &BitcoinRelaySettings) -> Option { + if settings.allow_https { + if let Some(endpoint) = settings.https_endpoint.clone() { + return Some(endpoint); + } + } + if settings.allow_tor { + if let Some(endpoint) = settings.tor_endpoint.clone() { + return Some(endpoint); + } + } + if settings.allow_http { + if let Some(endpoint) = settings.http_endpoint.clone() { + return Some(endpoint); + } + } + settings + .https_endpoint + .clone() + .or_else(|| settings.tor_endpoint.clone()) + .or_else(|| settings.http_endpoint.clone()) +} + +fn relay_response_payload( + message_type: &str, + request_id: &str, + request_direction: RelayRequestDirection, + endpoint: Option<&str>, + credentials: Option<&TxRelayCredentials>, +) -> serde_json::Value { + let mut payload = json!({ + "type": message_type, + "request_id": request_id, + }); + if message_type == "bitcoin_relay_approved" + && request_direction == RelayRequestDirection::Incoming + { + if let (Some(endpoint), Some(credentials)) = (endpoint, credentials) { + payload["relay_access"] = json!({ + "endpoint": endpoint, + "username": &credentials.username, + "password": &credentials.password, + }); + } + } + payload +} + +async fn save_peer_relay_access( + data_dir: &Path, + from_pubkey: &str, + payload: &serde_json::Value, +) -> Result> { + let Some(access) = payload.get("relay_access") else { + return Ok(None); + }; + let endpoint = access + .get("endpoint") + .and_then(|v| v.as_str()) + .map(validate_endpoint) + .transpose()?; + let username = access.get("username").and_then(|v| v.as_str()); + let password = access.get("password").and_then(|v| v.as_str()); + let (Some(endpoint), Some(username), Some(password)) = (endpoint, username, password) else { + return Ok(None); + }; + validate_env_value(username)?; + validate_env_value(password)?; + + let secret_path = data_dir.join("secrets").join(format!( + "bitcoin-relay-peer-{}.env", + safe_pubkey_fragment(from_pubkey) + )); + let contents = format!( + "BITCOIN_RELAY_PEER_PUBKEY={}\nBITCOIN_RELAY_ENDPOINT={}\nBITCOIN_RELAY_USERNAME={}\nBITCOIN_RELAY_PASSWORD={}\n", + from_pubkey, endpoint, username, password + ); + write_secret_file(&secret_path, &contents).await?; + Ok(Some((endpoint, secret_path.display().to_string()))) +} + +fn validate_env_value(value: &str) -> Result<()> { + if value.is_empty() || value.len() > 1024 || value.contains('\n') || value.contains('\r') { + anyhow::bail!("Invalid relay credential value"); + } + Ok(()) +} + +fn safe_pubkey_fragment(pubkey: &str) -> String { + let fragment = pubkey + .chars() + .filter(|c| c.is_ascii_hexdigit()) + .take(24) + .collect::(); + if fragment.is_empty() { + "unknown".to_string() + } else { + fragment + } +} + +async fn hydrate_tor_endpoint(data_dir: &Path, state: &mut BitcoinRelayState) { + if state.settings.tor_endpoint.is_some() { + return; + } + if let Some(onion) = docker_packages::read_tor_address("bitcoin-rpc").await { + let onion = onion.trim().trim_end_matches('/').to_string(); + if !onion.is_empty() { + state.settings.tor_endpoint = Some(format!("http://{onion}/")); + let _ = save_relay_state(data_dir, state).await; + } + } +} + +async fn local_sync_status() -> serde_json::Value { + let status = bitcoin_status::get_bitcoin_status().await; + let blockchain = status.blockchain_info.as_ref(); + let blocks = blockchain + .and_then(|v| v.get("blocks")) + .and_then(|v| v.as_u64()) + .unwrap_or(0); + let headers = blockchain + .and_then(|v| v.get("headers")) + .and_then(|v| v.as_u64()) + .unwrap_or(0); + let initial_block_download = blockchain + .and_then(|v| v.get("initialblockdownload")) + .and_then(|v| v.as_bool()) + .unwrap_or(true); + let synced = + status.ok && headers > 0 && blocks >= headers.saturating_sub(1) && !initial_block_download; + + json!({ + "synced": synced, + "blocks": blocks, + "headers": headers, + "chain": blockchain + .and_then(|v| v.get("chain")) + .and_then(|v| v.as_str()) + .unwrap_or("unknown"), + "status_ok": status.ok, + "status_stale": status.stale, + "error": status.error, + }) +} + +async fn load_relay_state(data_dir: &Path) -> Result { + let path = state_path(data_dir); + if !path.exists() { + return Ok(BitcoinRelayState::default()); + } + let content = fs::read_to_string(&path) + .await + .with_context(|| format!("Failed to read {}", path.display()))?; + Ok(serde_json::from_str(&content).unwrap_or_default()) +} + +async fn save_relay_state(data_dir: &Path, state: &BitcoinRelayState) -> Result<()> { + let dir = data_dir.join(RELAY_DIR); + fs::create_dir_all(&dir).await?; + let content = serde_json::to_string_pretty(state)?; + fs::write(dir.join(RELAY_STATE_FILE), content).await?; + Ok(()) +} + +fn state_path(data_dir: &Path) -> PathBuf { + data_dir.join(RELAY_DIR).join(RELAY_STATE_FILE) +} + +fn update_bool(params: &serde_json::Value, key: &str, target: &mut bool) { + if let Some(value) = params.get(key).and_then(|v| v.as_bool()) { + *target = value; + } +} + +fn update_endpoint( + params: &serde_json::Value, + key: &str, + target: &mut Option, +) -> Result<()> { + if !params.get(key).is_some() { + return Ok(()); + } + let endpoint = params + .get(key) + .and_then(|v| v.as_str()) + .map(str::trim) + .filter(|s| !s.is_empty()); + *target = endpoint.map(validate_endpoint).transpose()?; + Ok(()) +} + +fn validate_endpoint(endpoint: &str) -> Result { + if endpoint.len() > 512 || endpoint.contains('\n') || endpoint.contains('\r') { + anyhow::bail!("Invalid endpoint"); + } + let lower = endpoint.to_ascii_lowercase(); + if !(lower.starts_with("http://") || lower.starts_with("https://")) { + anyhow::bail!("Endpoint must start with http:// or https://"); + } + Ok(endpoint.to_string()) +} + +fn sanitize_optional_text(value: &str) -> Result { + let value = value.trim(); + if value.len() > 500 || value.contains('\0') { + anyhow::bail!("Invalid message"); + } + Ok(value.to_string()) +} + +fn now() -> String { + chrono::Utc::now().to_rfc3339() +} diff --git a/core/archipelago/src/api/rpc/container.rs b/core/archipelago/src/api/rpc/container.rs index 7377bca2..9446bc00 100644 --- a/core/archipelago/src/api/rpc/container.rs +++ b/core/archipelago/src/api/rpc/container.rs @@ -4,8 +4,9 @@ use super::RpcHandler; use anyhow::{Context, Result}; use std::time::Duration; -const PODMAN_INSPECT_TIMEOUT: Duration = Duration::from_secs(10); -const PODMAN_PS_TIMEOUT: Duration = Duration::from_secs(10); +const PODMAN_INSPECT_TIMEOUT: Duration = Duration::from_secs(5); +const PODMAN_PS_TIMEOUT: Duration = Duration::from_secs(5); +const ORCHESTRATOR_HEALTH_TIMEOUT: Duration = Duration::from_secs(5); impl RpcHandler { pub(super) async fn handle_container_install( @@ -171,46 +172,69 @@ impl RpcHandler { // between "installed" and "not-installed" in the UI. let (data, _) = self.state_manager.get_snapshot().await; if data.server_info.status_info.containers_scanned && !data.package_data.is_empty() { - let containers: Vec = data - .package_data - .iter() - .map(|(id, pkg)| { - // Keep this mapping in sync with the UI's - // ContainerStatus.state union in - // neode-ui/src/api/container-client.ts. The UI maps - // transitional variants to single-button labels - // (Stopping… / Starting… / Restarting…). - let state = match &pkg.state { - crate::data_model::PackageState::Running => "running", - crate::data_model::PackageState::Stopped => "stopped", - crate::data_model::PackageState::Exited => "exited", - crate::data_model::PackageState::Starting => "starting", - crate::data_model::PackageState::Stopping => "stopping", - crate::data_model::PackageState::Restarting => "restarting", - crate::data_model::PackageState::Installing => "installing", - crate::data_model::PackageState::Installed => "installed", - crate::data_model::PackageState::Updating => "updating", - crate::data_model::PackageState::Removing => "removing", - crate::data_model::PackageState::CreatingBackup => "creating-backup", - crate::data_model::PackageState::RestoringBackup => "restoring-backup", - crate::data_model::PackageState::BackingUp => "backing-up", - }; - let lan = pkg - .installed - .as_ref() - .and_then(|i| i.interface_addresses.get("main")) - .and_then(|a| a.lan_address.as_deref()); - serde_json::json!({ - "id": id, - "name": id, - "state": state, - "image": "", - "created": "", - "ports": [], - "lan_address": lan, - }) - }) - .collect(); + let mut containers = Vec::with_capacity(data.package_data.len()); + for (id, pkg) in &data.package_data { + // Keep this mapping in sync with the UI's + // ContainerStatus.state union in + // neode-ui/src/api/container-client.ts. The UI maps + // transitional variants to single-button labels + // (Stopping… / Starting… / Restarting…). + let mut state = match &pkg.state { + crate::data_model::PackageState::Running => "running".to_string(), + crate::data_model::PackageState::Stopped => "stopped".to_string(), + crate::data_model::PackageState::Exited => "exited".to_string(), + crate::data_model::PackageState::Starting => "starting".to_string(), + crate::data_model::PackageState::Stopping => "stopping".to_string(), + crate::data_model::PackageState::Restarting => "restarting".to_string(), + crate::data_model::PackageState::Installing => "installing".to_string(), + crate::data_model::PackageState::Installed => "installed".to_string(), + crate::data_model::PackageState::Updating => "updating".to_string(), + crate::data_model::PackageState::Removing => "removing".to_string(), + crate::data_model::PackageState::CreatingBackup => { + "creating-backup".to_string() + } + crate::data_model::PackageState::RestoringBackup => { + "restoring-backup".to_string() + } + crate::data_model::PackageState::BackingUp => "backing-up".to_string(), + }; + + // Scanner backoff preserves cached package_data. Refresh stable + // states so callers do not see stale `running`/`exited` after + // health-monitor recovery or Quadlet --rm container removal. + if state == "running" && requires_launch_port_for_health(id) { + if !self.cached_reachable_health(id).await?.is_some() { + state = live_state_for_app(id) + .await + .unwrap_or("starting".to_string()); + } + } else if should_refresh_cached_state(&state) { + if launch_port_reachable(id).await { + state = "running".to_string(); + } else { + if let Some(live) = live_state_for_app(id).await { + state = live; + } else if quadlet_service_active(id).await { + state = "starting".to_string(); + } + } + } + + let lan = pkg + .installed + .as_ref() + .and_then(|i| i.interface_addresses.get("main")) + .and_then(|a| a.lan_address.as_deref()); + containers.push(serde_json::json!({ + "id": id, + "name": id, + "state": state, + "image": "", + "created": "", + "ports": [], + "lan_address": lan, + })); + } return Ok(serde_json::json!(containers)); } @@ -383,15 +407,33 @@ impl RpcHandler { // If app_id is provided, get health for that app. if let Some(params) = params { if let Some(app_id) = params.get("app_id").and_then(|v| v.as_str()) { + if let Some(health) = self.cached_reachable_health(app_id).await? { + return Ok(serde_json::json!({ app_id: health })); + } + + if let Some(health) = self.cached_state_health(app_id).await { + return Ok(serde_json::json!({ app_id: health })); + } + + if requires_launch_port_for_health(app_id) { + return Ok(serde_json::json!({ app_id: "starting" })); + } + if let Some(health) = self.stack_health(app_id).await? { return Ok(serde_json::json!({ app_id: health })); } let mut last_err: Option = None; for candidate in status_app_id_candidates(app_id) { - match orchestrator.health(&candidate).await { - Ok(health) => return Ok(serde_json::json!({ app_id: health })), - Err(e) => last_err = Some(e), + match tokio::time::timeout( + ORCHESTRATOR_HEALTH_TIMEOUT, + orchestrator.health(&candidate), + ) + .await + { + Ok(Ok(health)) => return Ok(serde_json::json!({ app_id: health })), + Ok(Err(e)) => last_err = Some(e), + Err(_) => {} } } for name in status_container_name_candidates(app_id) { @@ -424,14 +466,19 @@ impl RpcHandler { .and_then(|s| s.strip_suffix("-dev")) .or_else(|| container.name.strip_prefix("archy-")) .unwrap_or(container.name.as_str()); - match orchestrator.health(app_id_candidate).await { - Ok(health) => { + match tokio::time::timeout( + ORCHESTRATOR_HEALTH_TIMEOUT, + orchestrator.health(app_id_candidate), + ) + .await + { + Ok(Ok(health)) => { health_map.insert( app_id_candidate.to_string(), serde_json::Value::String(health), ); } - Err(_) => { + Ok(Err(_)) | Err(_) => { health_map.insert( app_id_candidate.to_string(), serde_json::Value::String("unknown".to_string()), @@ -443,6 +490,65 @@ impl RpcHandler { Ok(serde_json::Value::Object(health_map)) } + async fn cached_state_health(&self, app_id: &str) -> Option<&'static str> { + let (data, _) = self.state_manager.get_snapshot().await; + let Some(pkg) = data.package_data.get(app_id) else { + if data.server_info.status_info.containers_scanned { + return Some("stopped"); + } + return None; + }; + match pkg.state { + crate::data_model::PackageState::Running => None, + crate::data_model::PackageState::Installing + | crate::data_model::PackageState::Installed + | crate::data_model::PackageState::Starting => Some("starting"), + crate::data_model::PackageState::Stopping + | crate::data_model::PackageState::Stopped + | crate::data_model::PackageState::Exited => Some("stopped"), + crate::data_model::PackageState::Removing => Some("removing"), + crate::data_model::PackageState::Restarting + | crate::data_model::PackageState::Updating + | crate::data_model::PackageState::CreatingBackup + | crate::data_model::PackageState::RestoringBackup + | crate::data_model::PackageState::BackingUp => Some("starting"), + } + } + + async fn cached_reachable_health(&self, app_id: &str) -> Result> { + let (data, _) = self.state_manager.get_snapshot().await; + let pkg = data.package_data.get(app_id); + if matches!( + pkg.map(|pkg| &pkg.state), + Some(crate::data_model::PackageState::Removing) + ) { + return Ok(None); + } + + let url = pkg + .and_then(|pkg| pkg.installed.as_ref()) + .and_then(|i| i.interface_addresses.get("main")) + .and_then(|a| a.lan_address.as_deref()) + .map(ToOwned::to_owned) + .or_else(|| health_probe_url_for_app(app_id)); + + let Some(url) = url else { + return Ok(None); + }; + if url.starts_with("http://") || url.starts_with("https://") { + return Ok(http_launch_url_reachable(&url) + .await + .then(|| "healthy".to_string())); + } + + let Some(port) = port_from_url(&url) else { + return Ok(None); + }; + Ok(launch_port_reachable_by_port(port) + .await + .then(|| "healthy".to_string())) + } + async fn stack_health(&self, app_id: &str) -> Result> { let Some(members) = stack_health_members(app_id) else { return Ok(None); @@ -469,8 +575,14 @@ impl RpcHandler { } if saw_unknown { + if let Some(health) = self.cached_reachable_health(app_id).await? { + return Ok(Some(health)); + } Ok(Some("unknown".to_string())) } else if saw_starting { + if let Some(health) = self.cached_reachable_health(app_id).await? { + return Ok(Some(health)); + } Ok(Some("starting".to_string())) } else { Ok(Some("healthy".to_string())) @@ -482,7 +594,9 @@ async fn member_health( orchestrator: &dyn crate::container::traits::ContainerOrchestrator, app_id: &str, ) -> Result { - if let Ok(health) = orchestrator.health(app_id).await { + if let Ok(Ok(health)) = + tokio::time::timeout(ORCHESTRATOR_HEALTH_TIMEOUT, orchestrator.health(app_id)).await + { return Ok(health); } for name in status_container_name_candidates(app_id) { @@ -508,10 +622,8 @@ fn stack_health_members(app_id: &str) -> Option<&'static [&'static str]> { "indeedhub-minio", "indeedhub-relay", "indeedhub-api", - "indeedhub-ffmpeg", "indeedhub", ]), - "fedimint" => Some(&["fedimint"]), _ => None, } } @@ -583,6 +695,115 @@ fn status_container_name_candidates(app_id: &str) -> Vec { out } +fn should_refresh_cached_state(state: &str) -> bool { + matches!(state, "exited" | "stopped" | "stopping") +} + +async fn live_state_for_app(app_id: &str) -> Option { + for name in status_container_name_candidates(app_id) { + if let Some(live) = inspect_container_state_value(&name).await { + if let Some(live_state) = live.get("state").and_then(|v| v.as_str()) { + return Some(live_state.to_string()); + } + } + } + None +} + +async fn quadlet_service_active(app_id: &str) -> bool { + for name in status_container_name_candidates(app_id) { + let service = format!("{name}.service"); + let mut cmd = tokio::process::Command::new("systemctl"); + cmd.args(["--user", "is-active", "--quiet", &service]); + cmd.kill_on_drop(true); + if matches!( + tokio::time::timeout(Duration::from_secs(2), cmd.status()).await, + Ok(Ok(status)) if status.success() + ) { + return true; + } + } + false +} + +fn health_probe_url_for_app(app_id: &str) -> Option { + let port = match app_id { + "bitcoin-ui" => 8334, + "botfights" => 9100, + "btcpay-server" | "btcpay" | "btcpayserver" => 23000, + "dwn" => 3100, + "electrumx" | "electrs" | "mempool-electrs" | "electrs-ui" => 50002, + "fedimint" | "fedimintd" => 8175, + "filebrowser" => 8083, + "gitea" => 3001, + "grafana" => 3000, + "homeassistant" | "home-assistant" => 8123, + "immich" | "immich_server" => 2283, + "indeedhub" => 7778, + "jellyfin" => 8096, + "lnd" | "lnd-ui" => 18083, + "mempool" | "mempool-web" => 4080, + "nginx-proxy-manager" => 8081, + "ollama" => 11434, + "photoprism" => 2342, + "portainer" => 9000, + "searxng" => 8888, + "tailscale" => 8240, + "uptime-kuma" => 3002, + "vaultwarden" => 8082, + _ => return None, + }; + Some(format!("http://localhost:{port}")) +} + +fn requires_launch_port_for_health(app_id: &str) -> bool { + matches!(app_id, "fedimint" | "fedimintd" | "fedimint-gateway") +} + +async fn launch_port_reachable(app_id: &str) -> bool { + let Some(port) = health_probe_url_for_app(app_id).and_then(|url| port_from_url(&url)) else { + return false; + }; + launch_port_reachable_by_port(port).await +} + +async fn launch_port_reachable_by_port(port: u16) -> bool { + matches!( + tokio::time::timeout( + Duration::from_secs(2), + tokio::net::TcpStream::connect(("127.0.0.1", port)), + ) + .await, + Ok(Ok(_)) + ) +} + +async fn http_launch_url_reachable(url: &str) -> bool { + let Ok(client) = reqwest::Client::builder() + .timeout(Duration::from_secs(2)) + .redirect(reqwest::redirect::Policy::none()) + .build() + else { + return false; + }; + match client.get(url).send().await { + Ok(response) => { + let status = response.status(); + status.is_success() || status.is_redirection() + } + Err(_) => false, + } +} + +fn port_from_url(url: &str) -> Option { + let after_colon = url.rsplit_once(':')?.1; + let port = after_colon + .chars() + .take_while(|c| c.is_ascii_digit()) + .collect::(); + port.parse::().ok() +} + async fn inspect_container_state_value(name: &str) -> Option { if let Some(v) = ps_container_state_value(name).await { return Some(v); diff --git a/core/archipelago/src/api/rpc/dispatcher.rs b/core/archipelago/src/api/rpc/dispatcher.rs index 367b584a..1e3b624d 100644 --- a/core/archipelago/src/api/rpc/dispatcher.rs +++ b/core/archipelago/src/api/rpc/dispatcher.rs @@ -98,6 +98,20 @@ impl RpcHandler { // Bitcoin & Lightning deep data "bitcoin.getinfo" => self.handle_bitcoin_getinfo().await, + "bitcoin.relay-status" => self.handle_bitcoin_relay_status().await, + "bitcoin.relay-update-settings" => { + self.handle_bitcoin_relay_update_settings(params).await + } + "bitcoin.relay-request-peer" => self.handle_bitcoin_relay_request_peer(params).await, + "bitcoin.relay-approve-request" => { + self.handle_bitcoin_relay_approve_request(params).await + } + "bitcoin.relay-reject-request" => { + self.handle_bitcoin_relay_reject_request(params).await + } + "bitcoin.relay-create-tor-service" => { + self.handle_bitcoin_relay_create_tor_service().await + } "bitcoin.init-wallet-from-seed" => { self.handle_bitcoin_init_wallet_from_seed(params).await } diff --git a/core/archipelago/src/api/rpc/lnd/wallet.rs b/core/archipelago/src/api/rpc/lnd/wallet.rs index 72f6ad72..dc560930 100644 --- a/core/archipelago/src/api/rpc/lnd/wallet.rs +++ b/core/archipelago/src/api/rpc/lnd/wallet.rs @@ -23,10 +23,15 @@ impl RpcHandler { .await .context("Failed to parse newaddress response")?; + if let Some(error) = body.get("error").and_then(|v| v.as_str()) { + anyhow::bail!("LND could not generate an address: {}", error); + } + let address = body .get("address") .and_then(|v| v.as_str()) - .unwrap_or("") + .filter(|addr| !addr.trim().is_empty()) + .ok_or_else(|| anyhow::anyhow!("LND did not return a Bitcoin address. The wallet may still be locked, uninitialized, or waiting for Bitcoin to sync."))? .to_string(); Ok(serde_json::json!({ "address": address })) diff --git a/core/archipelago/src/api/rpc/mod.rs b/core/archipelago/src/api/rpc/mod.rs index fc50efc5..ee0439c5 100644 --- a/core/archipelago/src/api/rpc/mod.rs +++ b/core/archipelago/src/api/rpc/mod.rs @@ -2,6 +2,7 @@ mod analytics; mod auth; mod backup_rpc; mod bitcoin; +pub(crate) mod bitcoin_relay; mod container; mod content; mod credentials; @@ -302,6 +303,7 @@ impl RpcHandler { | "system.stats" | "tor.status" | "tor.onion-addresses" + | "bitcoin.relay-status" | "federation.list-nodes" | "system.get-settings" | "system.get-node-key" diff --git a/core/archipelago/src/api/rpc/package/config.rs b/core/archipelago/src/api/rpc/package/config.rs index e1092f59..9aaab545 100644 --- a/core/archipelago/src/api/rpc/package/config.rs +++ b/core/archipelago/src/api/rpc/package/config.rs @@ -3,7 +3,7 @@ use crate::port_allocator::PortAllocator; use anyhow::{Context, Result}; use std::time::Duration; -const PODMAN_LIST_TIMEOUT: Duration = Duration::from_secs(15); +const PODMAN_LIST_TIMEOUT: Duration = Duration::from_secs(60); fn is_platform_managed_app(app_id: &str) -> bool { matches!( @@ -31,7 +31,6 @@ fn is_platform_managed_app(app_id: &str) -> bool { | "fedimint" | "fedimint-gateway" | "indeedhub" - | "saleor" | "immich" ) } @@ -501,15 +500,6 @@ pub(super) fn all_container_names(package_id: &str) -> Vec { "netbird-dashboard".into(), "netbird-server".into(), ], - "saleor" => vec![ - "saleor-db".into(), - "saleor-cache".into(), - "saleor-api".into(), - "saleor-worker".into(), - "saleor-jaeger".into(), - "saleor-mailpit".into(), - "saleor".into(), - ], "nostr-vpn" => vec![ "nostr-vpn".into(), "archy-nostr-vpn".into(), @@ -599,7 +589,6 @@ pub(super) fn get_data_dirs_for_app(package_id: &str) -> Vec { format!("{}/penpot-postgres", base), ], "netbird" => vec![format!("{}/netbird", base)], - "saleor" => vec![format!("{}/saleor", base), format!("{}/saleor-db", base)], _ => vec![format!("{}/{}", base, package_id)], } } @@ -977,6 +966,7 @@ pub(super) async fn get_app_config( vec![ "/var/lib/archipelago/portainer:/data".to_string(), "/run/user/1000/podman/podman.sock:/var/run/docker.sock".to_string(), + "/var/lib/archipelago/portainer/compose:/data/compose".to_string(), ], vec![], None, @@ -1006,7 +996,7 @@ pub(super) async fn get_app_config( Some(vec![ "sh".to_string(), "-c".to_string(), - "tailscaled --tun=userspace-networking & sleep 2; tailscale web --listen 0.0.0.0:8240 & wait".to_string(), + "tailscaled --tun=userspace-networking & for i in $(seq 1 30); do [ -S /var/run/tailscale/tailscaled.sock ] && break; sleep 1; done; tailscale web --listen 0.0.0.0:8240 & wait".to_string(), ]), ), "fedimint" => ( @@ -1079,13 +1069,6 @@ pub(super) async fn get_app_config( None, None, ), - "saleor" => ( - vec!["9010:80".to_string(), "8000:8000".to_string()], - vec!["/var/lib/archipelago/saleor:/app/media".to_string()], - vec![], - None, - None, - ), "nostr-rs-relay" => ( vec!["18081:8080".to_string()], vec!["/var/lib/archipelago/nostr-rs-relay:/usr/src/app/db".to_string()], diff --git a/core/archipelago/src/api/rpc/package/dependencies.rs b/core/archipelago/src/api/rpc/package/dependencies.rs index 9a03de87..8e2e7af2 100644 --- a/core/archipelago/src/api/rpc/package/dependencies.rs +++ b/core/archipelago/src/api/rpc/package/dependencies.rs @@ -289,15 +289,6 @@ pub(super) fn startup_order(package_id: &str) -> &'static [&'static str] { &["archy-btcpay-db", "archy-nbxplorer", "btcpay-server"] } "netbird" => &["netbird-server", "netbird-dashboard", "netbird"], - "saleor" => &[ - "saleor-db", - "saleor-cache", - "saleor-jaeger", - "saleor-mailpit", - "saleor-api", - "saleor-worker", - "saleor", - ], "penpot" | "penpot-frontend" => &[ "penpot-postgres", "penpot-valkey", diff --git a/core/archipelago/src/api/rpc/package/install.rs b/core/archipelago/src/api/rpc/package/install.rs index 18658a6f..6fbdabb5 100644 --- a/core/archipelago/src/api/rpc/package/install.rs +++ b/core/archipelago/src/api/rpc/package/install.rs @@ -13,11 +13,12 @@ use crate::api::rpc::RpcHandler; use crate::data_model::InstallPhase; use crate::update::host_sudo; use anyhow::{Context, Result}; -use tokio::io::{AsyncBufReadExt, BufReader}; +use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader}; use tokio::time::{timeout, Duration}; use tracing::{debug, info, warn}; const INSTALL_LOG: &str = "/var/log/archipelago/container-installs.log"; +const IMAGE_INSPECT_TIMEOUT: Duration = Duration::from_secs(10); /// Append a timestamped line to the persistent install log. pub(in crate::api::rpc) async fn install_log(msg: &str) { @@ -34,6 +35,36 @@ pub(in crate::api::rpc) async fn install_log(msg: &str) { } } +async fn local_podman_image_exists(image: &str) -> Result { + let mut cmd = tokio::process::Command::new("podman"); + cmd.args(["image", "inspect", image]); + cmd.kill_on_drop(true); + let output = timeout(IMAGE_INSPECT_TIMEOUT, cmd.output()) + .await + .with_context(|| { + format!( + "podman image inspect {} timed out after {}s", + image, + IMAGE_INSPECT_TIMEOUT.as_secs() + ) + })? + .with_context(|| format!("Failed to execute podman image inspect {}", image))?; + match output.status.code() { + Some(0) => Ok(true), + Some(1) => Ok(false), + Some(code) => Err(anyhow::anyhow!( + "podman image inspect {} exited with {}: {}", + image, + code, + String::from_utf8_lossy(&output.stderr).trim() + )), + None => Err(anyhow::anyhow!( + "podman image inspect {} terminated by signal", + image + )), + } +} + pub(super) async fn patch_indeedhub_nostr_provider() { tokio::time::sleep(std::time::Duration::from_secs(5)).await; @@ -244,10 +275,6 @@ impl RpcHandler { if package_id == "netbird" { return self.install_netbird_stack().await; } - if package_id == "saleor" { - return self.install_saleor_stack().await; - } - // Dependency checks. Prefer the scanner's cached package state so a // congested Podman API does not turn an already-running dependency into // a false install failure. Fall back to a bounded direct Podman probe @@ -447,6 +474,7 @@ impl RpcHandler { Ok(container_name) => { self.set_install_phase(package_id, InstallPhase::WaitingHealthy) .await; + ensure_host_port_listener(package_id, &container_name, &[]).await?; crate::api::rpc::package::runtime::reconcile_companions_for(package_id) .await; install_log(&format!( @@ -652,10 +680,6 @@ impl RpcHandler { self.write_lnd_conf(&rpc_user, &rpc_pass).await?; } - if package_id == "portainer" { - ensure_user_podman_socket().await?; - } - // Pre-install: SearXNG settings.yml (required or container exits immediately) if package_id == "searxng" { let searx_dir = "/var/lib/archipelago/searxng"; @@ -748,16 +772,10 @@ impl RpcHandler { .await; debug!("Running container with args: {:?}", run_args); - // Build command with optional custom command/args - let mut cmd = tokio::process::Command::new("podman"); - cmd.args(&run_args); - if let Some(custom_cmd) = custom_command { - cmd.arg(custom_cmd); - } else if let Some(args) = custom_args { - cmd.args(args); - } - - let mut run_output = cmd.output().await.context("Failed to run container")?; + let command_tail = install_command_tail(custom_command.as_deref(), custom_args.as_ref()); + let mut run_output = podman_run_for_install(package_id, &run_args, &command_tail) + .await + .context("Failed to run container")?; if !run_output.status.success() { let stderr = String::from_utf8_lossy(&run_output.stderr).to_string(); @@ -766,7 +784,9 @@ impl RpcHandler { .args(["rm", "-f", container_name]) .output() .await; - run_output = cmd.output().await.context("Failed to rerun container")?; + run_output = podman_run_for_install(package_id, &run_args, &command_tail) + .await + .context("Failed to rerun container")?; } } @@ -922,12 +942,7 @@ impl RpcHandler { let is_local_image = docker_image.starts_with("localhost/"); let has_local_fallback = if !is_local_image { let local_tag = format!("localhost/{}:latest", package_id); - let check = tokio::process::Command::new("podman") - .args(["images", "-q", &local_tag]) - .output() - .await - .ok(); - check.is_some_and(|o| !String::from_utf8_lossy(&o.stdout).trim().is_empty()) + local_podman_image_exists(&local_tag).await.unwrap_or(false) } else { false }; @@ -942,14 +957,9 @@ impl RpcHandler { ); } else { // Local image — verify it exists - let images_output = tokio::process::Command::new("podman") - .args(["images", "-q", docker_image]) - .output() + if !local_podman_image_exists(docker_image) .await - .context("Failed to check local image")?; - if String::from_utf8_lossy(&images_output.stdout) - .trim() - .is_empty() + .context("Failed to check local image")? { return Err(anyhow::anyhow!( "Local image {} not found. Build the image first \ @@ -1139,12 +1149,10 @@ impl RpcHandler { } // Verify image exists locally after pull. - let verify = tokio::process::Command::new("podman") - .args(["images", "-q", docker_image]) - .output() + if !local_podman_image_exists(docker_image) .await - .context("Failed to verify pulled image")?; - if String::from_utf8_lossy(&verify.stdout).trim().is_empty() { + .context("Failed to verify pulled image")? + { return Err(anyhow::anyhow!( "Image {} not found locally after pull", docker_image @@ -1278,11 +1286,13 @@ impl RpcHandler { // set `prune=N` in bitcoin.conf themselves after install. let bitcoin_conf = format!( "\ -# rpcauth: salted hash only — no plaintext password in config or CLI\n\ +# rpcauth: salted hash only - no plaintext password in config or CLI\n\ {}\n\ server=1\n\ rpcallowip=0.0.0.0/0\n\ listen=1\n\ +rpcthreads=16\n\ +rpcworkqueue=256\n\ printtoconsole=1\n", rpcauth_line ); @@ -1871,29 +1881,34 @@ autopilot.active=false\n", .unwrap_or_default(); super::validation::validate_app_id(app_id)?; - match app_id { - "saleor" => { - let password = - tokio::fs::read_to_string("/var/lib/archipelago/secrets/saleor-admin-password") - .await - .unwrap_or_default() - .trim() - .to_string(); - if password.is_empty() { - return Ok(serde_json::json!({ "credentials": [] })); - } - - Ok(serde_json::json!({ - "title": "Saleor admin login", - "description": "Saleor opens to its own dashboard login. Use this generated admin account to sign in.", - "credentials": [ - { "label": "Email", "value": "admin@example.com", "sensitive": false }, - { "label": "Password", "value": password, "sensitive": true } - ] - })) - } - _ => Ok(serde_json::json!({ "credentials": [] })), + if app_id == "filebrowser" { + let password = + tokio::fs::read_to_string("/var/lib/archipelago/secrets/filebrowser/password") + .await + .map(|p| p.trim().to_string()) + .unwrap_or_else(|_| "admin".to_string()); + return Ok(serde_json::json!({ + "title": "File Browser credentials", + "description": "Use these credentials when File Browser asks you to sign in.", + "credentials": [ + { "label": "Username", "value": "admin" }, + { "label": "Password", "value": password, "sensitive": true } + ] + })); } + + if app_id == "photoprism" { + return Ok(serde_json::json!({ + "title": "PhotoPrism credentials", + "description": "Use these credentials when PhotoPrism asks you to sign in.", + "credentials": [ + { "label": "Username", "value": "admin" }, + { "label": "Password", "value": "archipelago", "sensitive": true } + ] + })); + } + + Ok(serde_json::json!({ "credentials": [] })) } } @@ -1914,10 +1929,128 @@ async fn cleanup_stale_package_ports(package_id: &str) { cleanup_stale_pasta_port("8444").await; } "nextcloud" => cleanup_stale_pasta_port("8085").await, + "portainer" => cleanup_stale_pasta_port("9000").await, _ => {} } } +fn install_command_tail( + custom_cmd: Option<&str>, + custom_args: Option<&Vec>, +) -> Vec { + if let Some(cmd) = custom_cmd { + vec![cmd.to_string()] + } else if let Some(args) = custom_args { + args.clone() + } else { + Vec::new() + } +} + +async fn podman_run_for_install( + package_id: &str, + run_args: &[&str], + command_tail: &[String], +) -> Result { + if should_scope_podman_run(package_id) { + match podman_create_then_scoped_start(package_id, run_args, command_tail).await { + Ok(output) => return Ok(output), + Err(err) => { + tracing::warn!(package_id, error = %err, "scoped podman create/start failed; falling back to direct podman run"); + } + } + } + + let mut cmd = tokio::process::Command::new("podman"); + cmd.args(run_args); + cmd.args(command_tail); + cmd.output().await.context("Failed to run podman") +} + +async fn podman_create_then_scoped_start( + package_id: &str, + run_args: &[&str], + command_tail: &[String], +) -> Result { + let container_name = run_args + .windows(2) + .find_map(|pair| (pair[0] == "--name").then_some(pair[1])) + .unwrap_or(package_id); + let mut create_args = Vec::with_capacity(run_args.len() + command_tail.len()); + for (idx, arg) in run_args.iter().enumerate() { + if idx == 0 && *arg == "run" { + create_args.push("create".to_string()); + } else if *arg != "-d" { + create_args.push((*arg).to_string()); + } + } + create_args.extend(command_tail.iter().cloned()); + + let mut create = tokio::process::Command::new("podman"); + create.args(&create_args); + let create_output = create + .output() + .await + .context("Failed to run podman create")?; + if !create_output.status.success() { + return Ok(create_output); + } + + let mut scoped_start = tokio::process::Command::new("systemd-run"); + scoped_start.args([ + "--user", + "--scope", + "--quiet", + "--collect", + "podman", + "start", + container_name, + ]); + match scoped_start.output().await { + Ok(output) if output.status.success() => Ok(create_output), + Ok(output) => { + tracing::warn!( + package_id, + container = container_name, + stderr = %String::from_utf8_lossy(&output.stderr).trim(), + "scoped podman start after create failed; trying direct podman start" + ); + let mut direct_start = tokio::process::Command::new("podman"); + direct_start.args(["start", container_name]); + let direct_output = direct_start + .output() + .await + .context("Failed to run fallback podman start")?; + if direct_output.status.success() { + Ok(create_output) + } else { + Ok(direct_output) + } + } + Err(err) => Err(err).context("Failed to run scoped podman start"), + } +} + +fn should_scope_podman_run(package_id: &str) -> bool { + matches!( + package_id, + "botfights" + | "filebrowser" + | "gitea" + | "grafana" + | "homeassistant" + | "home-assistant" + | "jellyfin" + | "nginx-proxy-manager" + | "nostr-rs-relay" + | "photoprism" + | "portainer" + | "searxng" + | "uptime-kuma" + | "vaultwarden" + ) +} + async fn cleanup_start_conflict(package_id: &str, stderr: &str) -> bool { if stderr.contains("name is already in use") || stderr.contains("name \"") { return true; @@ -1968,6 +2101,12 @@ async fn cleanup_start_conflict(package_id: &str, stderr: &str) -> bool { cleanup_stale_pasta_port("8085").await; true } + "portainer" + if stderr.contains("pasta failed") || stderr.contains("address already in use") => + { + cleanup_stale_pasta_port("9000").await; + true + } _ => false, } } @@ -2026,7 +2165,7 @@ async fn ensure_host_port_listener( return Ok(()); }; - if wait_for_host_port(port, 10).await { + if wait_for_host_port(package_id, port, 10).await { return Ok(()); } @@ -2052,7 +2191,7 @@ async fn ensure_host_port_listener( )); } - if wait_for_host_port(port, 60).await { + if wait_for_host_port(package_id, port, 60).await { install_log(&format!( "INSTALL REPAIR OK: {} — host port {} is listening after restart", package_id, port @@ -2084,31 +2223,6 @@ fn published_host_port(container_name: &str) -> Option { }) } -async fn ensure_user_podman_socket() -> Result<()> { - let socket_path = "/run/user/1000/podman/podman.sock"; - if tokio::fs::try_exists(socket_path).await.unwrap_or(false) { - return Ok(()); - } - - let status = tokio::process::Command::new("systemctl") - .args(["--user", "restart", "podman.socket"]) - .status() - .await - .context("spawn systemctl --user restart podman.socket")?; - if !status.success() { - anyhow::bail!("systemctl --user restart podman.socket exited {status}"); - } - - for _ in 0..20 { - if tokio::fs::try_exists(socket_path).await.unwrap_or(false) { - return Ok(()); - } - tokio::time::sleep(Duration::from_millis(250)).await; - } - - anyhow::bail!("podman socket {socket_path} did not appear after restart") -} - fn required_host_port(package_id: &str) -> Option { match package_id { "grafana" => Some(3000), @@ -2118,17 +2232,21 @@ fn required_host_port(package_id: &str) -> Option { "gitea" => Some(3001), "nextcloud" => Some(8085), "nginx-proxy-manager" => Some(8081), + "portainer" => Some(9000), _ => None, } } -async fn wait_for_host_port(port: u16, timeout_secs: u64) -> bool { +async fn wait_for_host_port(package_id: &str, port: u16, timeout_secs: u64) -> bool { let deadline = std::time::Instant::now() + std::time::Duration::from_secs(timeout_secs); loop { - if tokio::net::TcpStream::connect(("127.0.0.1", port)) - .await - .is_ok() - { + let ready = match package_id { + "uptime-kuma" => http_host_port_ready(port, "/").await, + _ => tokio::net::TcpStream::connect(("127.0.0.1", port)) + .await + .is_ok(), + }; + if ready { return true; } @@ -2140,6 +2258,36 @@ async fn wait_for_host_port(port: u16, timeout_secs: u64) -> bool { } } +async fn http_host_port_ready(port: u16, path: &str) -> bool { + let Ok(Ok(mut stream)) = tokio::time::timeout( + Duration::from_secs(3), + tokio::net::TcpStream::connect(("127.0.0.1", port)), + ) + .await + else { + return false; + }; + + let request = format!("GET {path} HTTP/1.1\r\nHost: 127.0.0.1\r\nConnection: close\r\n\r\n"); + if stream.write_all(request.as_bytes()).await.is_err() { + return false; + } + + let mut buf = [0u8; 128]; + let Ok(Ok(n)) = tokio::time::timeout(Duration::from_secs(3), stream.read(&mut buf)).await + else { + return false; + }; + if n == 0 { + return false; + } + let head = String::from_utf8_lossy(&buf[..n]); + head.starts_with("HTTP/1.1 2") + || head.starts_with("HTTP/1.1 3") + || head.starts_with("HTTP/1.0 2") + || head.starts_with("HTTP/1.0 3") +} + /// Resolve the host gateway IP for --add-host flag. /// Resolve the default gateway IP from the routing table for --add-host flag. /// Explicit IP avoids issues with "host-gateway" in rootless Podman. @@ -2235,6 +2383,18 @@ set -eu conf=/var/lib/archipelago/bitcoin/bitcoin.conf [ -f "$conf" ] || exit 0 changed=0 +tmp=$(mktemp) +awk -F= ' + /^(server|txindex|rpcbind|rpcallowip|rpcport|listen|bind|dbcache|rpcthreads|rpcworkqueue)=/ { + if (seen[$1]++) next + } + { print } +' "$conf" > "$tmp" +if ! cmp -s "$conf" "$tmp"; then + cat "$tmp" > "$conf" + changed=1 +fi +rm -f "$tmp" ensure_line() { line="$1" key="${line%%=*}" @@ -2246,6 +2406,8 @@ ensure_line() { ensure_line server=1 ensure_line rpcallowip=0.0.0.0/0 ensure_line listen=1 +ensure_line rpcthreads=16 +ensure_line rpcworkqueue=256 [ "$changed" -eq 0 ] && exit 0 exit 2 "#; @@ -2272,6 +2434,7 @@ fn should_try_orchestrator_install(package_id: &str, orchestrator_available: boo fn orchestrator_install_app_id(package_id: &str) -> &str { match package_id { "electrs" | "mempool-electrs" => "electrumx", + "home-assistant" => "homeassistant", _ => package_id, } } @@ -2299,6 +2462,16 @@ fn uses_orchestrator_install_flow(package_id: &str) -> bool { | "archy-btcpay-db" | "archy-nbxplorer" | "btcpay-server" + | "homeassistant" + | "home-assistant" + | "nextcloud" + | "vaultwarden" + | "jellyfin" + | "photoprism" + | "uptime-kuma" + | "gitea" + | "portainer" + | "meshtastic" ) } @@ -2336,6 +2509,16 @@ mod tests { "archy-btcpay-db", "archy-nbxplorer", "btcpay-server", + "homeassistant", + "home-assistant", + "nextcloud", + "vaultwarden", + "jellyfin", + "photoprism", + "uptime-kuma", + "gitea", + "portainer", + "meshtastic", ] { assert!(uses_orchestrator_install_flow(app)); assert!(should_try_orchestrator_install(app, true)); @@ -2364,6 +2547,10 @@ mod tests { assert_eq!(orchestrator_install_app_id("bitcoin-core"), "bitcoin-core"); assert_eq!(orchestrator_install_app_id("electrs"), "electrumx"); assert_eq!(orchestrator_install_app_id("mempool-electrs"), "electrumx"); + assert_eq!( + orchestrator_install_app_id("home-assistant"), + "homeassistant" + ); assert_eq!(orchestrator_install_app_id("lnd"), "lnd"); } diff --git a/core/archipelago/src/api/rpc/package/runtime.rs b/core/archipelago/src/api/rpc/package/runtime.rs index 1d06ddf1..3f2b1d54 100644 --- a/core/archipelago/src/api/rpc/package/runtime.rs +++ b/core/archipelago/src/api/rpc/package/runtime.rs @@ -2,15 +2,18 @@ use super::config::{ get_app_capabilities, get_containers_for_app, get_data_dirs_for_app, get_health_check_args, get_memory_limit, is_valid_docker_image, }; -use super::dependencies::ordered_containers_for_start; +use super::dependencies::{ordered_containers_for_start, startup_order}; use super::install::install_log; use super::validation::validate_app_id; use crate::api::rpc::RpcHandler; use crate::data_model::PackageState; use anyhow::{Context, Result}; +use archipelago_container::AppManifest; +use std::path::Path; use std::process::Output; use std::sync::Arc; use std::time::Duration; +use tokio::io::{AsyncReadExt, AsyncWriteExt}; use tracing::warn; const PODMAN_CONTROL_TIMEOUT: Duration = Duration::from_secs(30); @@ -53,7 +56,11 @@ impl RpcHandler { .ok_or_else(|| anyhow::anyhow!("Missing package id"))?; validate_app_id(package_id)?; - let to_start = ordered_containers_for_start(package_id).await?; + let to_start = if self.orchestrator.is_some() && uses_single_orchestrator_app(package_id) { + vec![orchestrator_app_id(package_id).to_string()] + } else { + ordered_containers_for_start(package_id).await? + }; if to_start.is_empty() { tracing::warn!("package.start {}: no containers found", package_id); return Err(anyhow::anyhow!("No containers found for {}", package_id)); @@ -124,7 +131,16 @@ impl RpcHandler { .ok_or_else(|| anyhow::anyhow!("Missing package id"))?; validate_app_id(package_id)?; - let containers = get_containers_for_app(package_id).await?; + let single_orchestrator_app = + self.orchestrator.is_some() && uses_single_orchestrator_app(package_id); + let mut containers = if single_orchestrator_app { + vec![orchestrator_app_id(package_id).to_string()] + } else { + get_containers_for_app(package_id).await? + }; + if !single_orchestrator_app { + containers.reverse(); + } if containers.is_empty() { tracing::warn!("package.stop {}: no containers found", package_id); return Err(anyhow::anyhow!("No containers found for {}", package_id)); @@ -190,7 +206,13 @@ impl RpcHandler { .ok_or_else(|| anyhow::anyhow!("Missing package id"))?; validate_app_id(package_id)?; - let containers = get_containers_for_app(package_id).await?; + let single_orchestrator_app = + self.orchestrator.is_some() && uses_single_orchestrator_app(package_id); + let containers = if single_orchestrator_app { + vec![orchestrator_app_id(package_id).to_string()] + } else { + get_containers_for_app(package_id).await? + }; if containers.is_empty() { tracing::warn!("package.restart {}: no containers found", package_id); return Err(anyhow::anyhow!("No containers found for {}", package_id)); @@ -206,7 +228,11 @@ impl RpcHandler { let package_id_owned = package_id.to_string(); let companion_app_id = package_id_owned.clone(); - let to_restart = ordered_containers_for_start(package_id).await?; + let to_restart = if single_orchestrator_app { + vec![orchestrator_app_id(package_id).to_string()] + } else { + ordered_containers_for_start(package_id).await? + }; let state_manager = Arc::clone(&self.state_manager); let orchestrator = self.orchestrator.clone(); let pre_state = @@ -323,7 +349,9 @@ impl RpcHandler { match rm_out { Ok(o) if o.status.success() => removed += 1, Ok(o) => { - // If normal rm fails (e.g., still running), force as fallback + // If normal rm fails (e.g., still running/stopping/removing), + // force with targeted cleanup fallbacks. This is deliberately + // container-scoped; never prune the store during uninstall. let stderr = String::from_utf8_lossy(&o.stderr); tracing::warn!( "Uninstall {}: rm {} failed ({}), trying force", @@ -331,28 +359,36 @@ impl RpcHandler { name, stderr.trim() ); - let force_rm = podman_control(&["rm", "-f", name]).await; - match force_rm { - Ok(o2) if o2.status.success() => removed += 1, - _ => { - let msg = format!("Failed to remove {}: {}", name, stderr.trim()); + match force_remove_runtime_container(name).await { + Ok(()) => removed += 1, + Err(e) => { + let msg = + format!("Failed to remove {}: {}; {}", name, stderr.trim(), e); tracing::error!("Uninstall {}: {}", package_id, msg); errors.push(msg); } } } - Err(e) => { - let msg = format!("Failed to remove {}: {}", name, e); - tracing::error!("Uninstall {}: {}", package_id, msg); - errors.push(msg); - } + Err(e) => match force_remove_runtime_container(name).await { + Ok(()) => removed += 1, + Err(force_err) => { + let msg = format!("Failed to remove {}: {}; {}", name, e, force_err); + tracing::error!("Uninstall {}: {}", package_id, msg); + errors.push(msg); + } + }, } } self.set_uninstall_stage(package_id, "Cleaning up volumes") .await; - // Clean up dangling volumes associated with removed containers - let _ = podman_control(&["volume", "prune", "-f"]).await; + // Avoid global Podman volume prune on production nodes: store-wide + // Podman cleanup commands can block app health under load. App data is + // removed explicitly below when preserve_data=false. + tracing::info!( + package_id = %package_id, + "Skipping global podman volume prune during uninstall" + ); // Clean up app-specific networks (only if no other containers use them) let app_networks: Vec<&str> = match package_id { @@ -600,9 +636,25 @@ async fn do_package_start(to_start: &[String]) -> Result<()> { if i > 0 { tokio::time::sleep(std::time::Duration::from_secs(2)).await; } + if let Err(e) = ensure_startable_container_state(name).await { + tracing::error!(container = %name, error = %e, "container is not startable"); + errors.push(format!("{}: {}", name, e)); + continue; + } + match inspect_runtime_container_state(name).await { + Ok(Some(state)) if state == "running" => { + tracing::debug!(container = %name, "container already running during package start"); + continue; + } + Ok(_) => {} + Err(e) => { + tracing::warn!(container = %name, error = %e, "failed to re-inspect before package start") + } + } repair_before_package_start(name).await; + wait_before_package_start(name).await; tracing::info!("Starting container: {}", name); - let out = podman_control(&["start", name]) + let out = podman_start_container(name) .await .context(format!("Failed to exec podman start {}", name))?; if !out.status.success() { @@ -669,6 +721,7 @@ async fn do_orchestrator_package_start( tokio::time::sleep(std::time::Duration::from_secs(2)).await; } repair_before_package_start(name).await; + wait_before_package_start(name).await; match orchestrator.start(name).await { Ok(()) => wait_after_orchestrator_start(name).await, Err(e) if is_unknown_app_id_error(&e) => { @@ -681,10 +734,13 @@ async fn do_orchestrator_package_start( } } } - if errors.is_empty() { - Ok(()) - } else { + if !errors.is_empty() { Err(anyhow::anyhow!("Start failed: {}", errors.join("; "))) + } else { + for name in to_start { + ensure_runtime_host_port_listener(name).await?; + } + Ok(()) } } @@ -703,6 +759,137 @@ async fn podman_control(args: &[&str]) -> Result { podman_with_timeout(args, podman_control_timeout(args)).await } +async fn force_remove_runtime_container(container_name: &str) -> Result<()> { + for args in [ + vec!["rm", "-f", container_name], + vec!["rm", "-f", "--time", "0", container_name], + ] { + let output = podman_control(&args).await?; + if output.status.success() + || is_missing_container_error(&String::from_utf8_lossy(&output.stderr)) + { + return Ok(()); + } + } + + let _ = podman_control(&["container", "cleanup", container_name]).await; + let output = podman_control(&["rm", "-f", container_name]).await?; + if output.status.success() + || is_missing_container_error(&String::from_utf8_lossy(&output.stderr)) + { + return Ok(()); + } + + Err(anyhow::anyhow!( + "force remove failed: {}", + String::from_utf8_lossy(&output.stderr).trim() + )) +} + +async fn force_stop_runtime_container(container_name: &str) -> Result<()> { + for args in [ + vec!["stop", "-t", "0", container_name], + vec!["kill", container_name], + ] { + let output = podman_control(&args).await?; + if output.status.success() + || is_missing_container_error(&String::from_utf8_lossy(&output.stderr)) + { + return Ok(()); + } + } + + for _ in 0..15 { + match inspect_runtime_container_state(container_name).await? { + None => return Ok(()), + Some(state) if matches!(state.as_str(), "exited" | "stopped" | "configured") => { + return Ok(()) + } + Some(_) => tokio::time::sleep(Duration::from_secs(2)).await, + } + } + + Err(anyhow::anyhow!( + "container did not reach stopped state after force stop" + )) +} + +async fn ensure_startable_container_state(container_name: &str) -> Result<()> { + let Some(state) = inspect_runtime_container_state(container_name).await? else { + return Ok(()); + }; + + match state.as_str() { + "configured" | "created" | "exited" | "stopped" | "running" | "paused" => Ok(()), + "removing" => { + wait_for_container_absent_or_startable(container_name, Duration::from_secs(60)).await + } + other => Err(anyhow::anyhow!( + "container is in unsupported state before start: {}", + other + )), + } +} + +async fn wait_for_container_absent_or_startable( + container_name: &str, + timeout: Duration, +) -> Result<()> { + let deadline = std::time::Instant::now() + timeout; + loop { + match inspect_runtime_container_state(container_name).await? { + None => return Ok(()), + Some(state) + if matches!( + state.as_str(), + "configured" | "created" | "exited" | "stopped" | "running" | "paused" + ) => + { + return Ok(()) + } + Some(state) if state == "removing" && std::time::Instant::now() < deadline => { + tokio::time::sleep(Duration::from_secs(2)).await; + } + Some(state) if state == "removing" => { + force_remove_runtime_container(container_name).await?; + return Ok(()); + } + Some(state) => { + return Err(anyhow::anyhow!( + "container is in unsupported state before start: {}", + state + )) + } + } + } +} + +async fn inspect_runtime_container_state(container_name: &str) -> Result> { + let output = podman_with_timeout( + &["inspect", container_name, "--format", "{{.State.Status}}"], + Duration::from_secs(10), + ) + .await?; + if output.status.success() { + return Ok(Some( + String::from_utf8_lossy(&output.stdout).trim().to_string(), + )); + } + let stderr = String::from_utf8_lossy(&output.stderr); + if is_missing_container_error(&stderr) { + Ok(None) + } else { + Err(anyhow::anyhow!("inspect failed: {}", stderr.trim())) + } +} + +fn is_missing_container_error(stderr: &str) -> bool { + stderr.contains("no such container") + || stderr.contains("no container with name") + || stderr.contains("does not exist") + || stderr.contains("not found") +} + fn podman_control_timeout(args: &[&str]) -> Duration { args.windows(2) .find_map(|pair| { @@ -714,6 +901,13 @@ fn podman_control_timeout(args: &[&str]) -> Duration { .unwrap_or(PODMAN_CONTROL_TIMEOUT) } +fn podman_start_timeout(container_name: &str) -> Duration { + match container_name { + "immich_server" | "netbird-server" => Duration::from_secs(120), + _ => PODMAN_CONTROL_TIMEOUT, + } +} + async fn podman_with_timeout(args: &[&str], timeout: Duration) -> Result { let mut cmd = tokio::process::Command::new("podman"); cmd.args(args); @@ -732,12 +926,48 @@ async fn command_with_timeout( .with_context(|| format!("Failed to exec {}", description)) } +async fn podman_start_container(container_name: &str) -> Result { + if !runtime_host_ports(container_name).is_empty() { + let mut cmd = tokio::process::Command::new("systemd-run"); + cmd.args([ + "--user", + "--scope", + "--quiet", + "--collect", + "podman", + "start", + ]) + .arg(container_name); + let scoped = command_with_timeout( + cmd, + podman_start_timeout(container_name), + &format!("systemd-run --user --scope podman start {container_name}"), + ) + .await; + if scoped.as_ref().is_ok_and(|out| out.status.success()) { + return scoped; + } + if let Err(err) = &scoped { + tracing::warn!( + container = %container_name, + error = %err, + "scoped podman start failed; falling back to direct podman start" + ); + } + } + podman_with_timeout( + &["start", container_name], + podman_start_timeout(container_name), + ) + .await +} + async fn do_orchestrator_package_stop( orchestrator: &dyn crate::container::traits::ContainerOrchestrator, containers: &[String], ) -> Result<()> { let mut errors = Vec::new(); - for name in containers.iter().rev() { + for name in containers { match orchestrator.stop(name).await { Ok(()) => {} Err(e) if is_unknown_app_id_error(&e) => { @@ -758,6 +988,44 @@ async fn do_orchestrator_package_stop( } } +fn orchestrator_app_id(package_id: &str) -> &str { + match package_id { + "electrs" | "mempool-electrs" => "electrumx", + "home-assistant" => "homeassistant", + _ => package_id, + } +} + +fn uses_single_orchestrator_app(package_id: &str) -> bool { + startup_order(package_id).is_empty() + && matches!( + package_id, + "bitcoin-ui" + | "electrs-ui" + | "lnd-ui" + | "bitcoin-core" + | "bitcoin-knots" + | "lnd" + | "fedimint" + | "fedimint-gateway" + | "filebrowser" + | "electrumx" + | "electrs" + | "mempool-electrs" + | "homeassistant" + | "home-assistant" + | "nextcloud" + | "vaultwarden" + | "jellyfin" + | "photoprism" + | "uptime-kuma" + | "gitea" + | "portainer" + | "meshtastic" + | "botfights" + ) +} + async fn do_orchestrator_package_restart( orchestrator: &dyn crate::container::traits::ContainerOrchestrator, to_restart: &[String], @@ -770,22 +1038,72 @@ async fn do_orchestrator_package_restart( async fn do_package_stop(containers: &[String]) -> Result<()> { let mut errors = Vec::new(); for name in containers { + match inspect_runtime_container_state(name).await { + Ok(None) => { + tracing::debug!(container = %name, "container already absent during stop"); + continue; + } + Ok(Some(state)) if matches!(state.as_str(), "exited" | "stopped" | "configured") => { + tracing::debug!(container = %name, state = %state, "container already stopped"); + continue; + } + Ok(Some(_)) => {} + Err(e) => { + tracing::warn!(container = %name, error = %e, "failed to inspect before stop") + } + } tracing::info!( "Stopping container: {} (timeout: {}s)", name, stop_timeout_secs(name) ); - let out = podman_control(&["stop", "-t", stop_timeout_secs(name), name]) - .await - .context(format!("Failed to exec podman stop {}", name))?; + let out = match podman_control(&["stop", "-t", stop_timeout_secs(name), name]).await { + Ok(out) => out, + Err(e) => { + tracing::warn!( + container = %name, + error = %e, + "podman stop errored, trying force stop" + ); + match force_stop_runtime_container(name).await { + Ok(()) => { + tracing::info!(container = %name, "force stop after stop error succeeded"); + continue; + } + Err(force_err) => { + tracing::error!( + "Failed to stop {}: {}; force stop failed: {}", + name, + e, + force_err + ); + errors.push(format!("{}: {}; force stop failed: {}", name, e, force_err)); + continue; + } + } + } + }; if !out.status.success() { let stderr = String::from_utf8_lossy(&out.stderr).trim().to_string(); if is_missing_companion_ok(name, &stderr) { tracing::debug!(container = %name, "companion already absent during stop"); continue; } - tracing::error!("Failed to stop {}: {}", name, stderr); - errors.push(format!("{}: {}", name, stderr)); + tracing::warn!("Failed to stop {}: {}, trying force stop", name, stderr); + match force_stop_runtime_container(name).await { + Ok(()) => { + tracing::info!(container = %name, "force stop after stop failure succeeded") + } + Err(e) => { + tracing::error!( + "Failed to stop {}: {}; force stop failed: {}", + name, + stderr, + e + ); + errors.push(format!("{}: {}; force stop failed: {}", name, stderr, e)); + } + } } } if !errors.is_empty() { @@ -801,6 +1119,7 @@ async fn do_package_restart(containers: &[String]) -> Result<()> { for name in containers { tracing::info!("Restarting container: {}", name); repair_before_package_start(name).await; + wait_before_package_start(name).await; let out = podman_control(&["restart", "-t", stop_timeout_secs(name), name]) .await .context(format!("Failed to exec podman restart {}", name))?; @@ -818,7 +1137,8 @@ async fn do_package_restart(containers: &[String]) -> Result<()> { ); // Fallback: stop then start let _ = podman_control(&["stop", "-t", stop_timeout_secs(name), name]).await; - let start_out = podman_control(&["start", name]) + wait_before_package_start(name).await; + let start_out = podman_start_container(name) .await .context(format!("Failed to exec podman start {}", name))?; if !start_out.status.success() { @@ -855,22 +1175,158 @@ fn is_unknown_app_id_error(err: &anyhow::Error) -> bool { async fn repair_before_package_start(container_name: &str) { match container_name { "btcpay-server" | "archy-nbxplorer" => repair_btcpay_dirs().await, - "indeedhub-postgres" | "indeedhub-redis" | "indeedhub-minio" | "indeedhub-relay" - | "indeedhub-api" | "indeedhub-ffmpeg" | "indeedhub" => repair_indeedhub_network().await, + "indeedhub" => repair_indeedhub_network().await, + "immich_server" => repair_immich_dirs().await, + "netbird" => repair_netbird_network().await, "grafana" => { repair_grafana_dirs().await; - cleanup_stale_pasta_port("3000").await; } - "vaultwarden" => cleanup_stale_pasta_port("8082").await, - "homeassistant" | "home-assistant" => cleanup_stale_pasta_port("8123").await, "nextcloud" => { repair_nextcloud_dirs().await; - cleanup_stale_pasta_port("8085").await; } "nginx-proxy-manager" => repair_nginx_proxy_manager_container().await, - "gitea" => cleanup_gitea_stale_ports().await, _ => {} } + cleanup_runtime_host_ports(container_name).await; +} + +async fn wait_before_package_start(container_name: &str) { + match container_name { + "indeedhub" => wait_for_indeedhub_dependency_dns().await, + "immich_server" => wait_for_immich_dependencies().await, + "netbird" => wait_for_netbird_dependency_dns().await, + _ => {} + } +} + +async fn wait_for_indeedhub_dependency_dns() { + for _ in 0..30 { + if indeedhub_frontend_dependencies_running().await { + super::stacks::repair_indeedhub_network_aliases().await; + break; + } + tokio::time::sleep(std::time::Duration::from_secs(2)).await; + } + + for _ in 0..30 { + let ready = podman_with_timeout( + &["exec", "indeedhub-minio", "getent", "hosts", "minio"], + Duration::from_secs(5), + ) + .await + .map(|out| out.status.success()) + .unwrap_or(false); + if ready { + return; + } + tokio::time::sleep(std::time::Duration::from_secs(2)).await; + } +} + +async fn indeedhub_frontend_dependencies_running() -> bool { + for container in ["indeedhub-minio", "indeedhub-redis", "indeedhub-api"] { + if !container_is_running(container).await { + return false; + } + } + true +} + +async fn container_is_running(container: &str) -> bool { + let Ok(output) = podman_with_timeout( + &["inspect", container, "--format", "{{.State.Status}}"], + Duration::from_secs(5), + ) + .await + else { + return false; + }; + + output.status.success() && String::from_utf8_lossy(&output.stdout).trim() == "running" +} + +async fn wait_for_netbird_dependency_dns() { + for _ in 0..30 { + if container_is_running("netbird-server").await + && container_is_running("netbird-dashboard").await + { + super::stacks::repair_netbird_network_aliases().await; + tokio::time::sleep(std::time::Duration::from_secs(2)).await; + return; + } + tokio::time::sleep(std::time::Duration::from_secs(2)).await; + } +} + +async fn wait_for_immich_dependencies() { + for _ in 0..60 { + if immich_postgres_ready().await && immich_redis_ready().await { + return; + } + tokio::time::sleep(std::time::Duration::from_secs(2)).await; + } +} + +async fn immich_postgres_ready() -> bool { + if container_health_is_healthy("immich_postgres").await { + return true; + } + + let Ok(output) = podman_with_timeout( + &[ + "exec", + "immich_postgres", + "pg_isready", + "-U", + "postgres", + "-d", + "immich", + ], + Duration::from_secs(5), + ) + .await + else { + return false; + }; + output.status.success() +} + +async fn immich_redis_ready() -> bool { + if container_health_is_healthy("immich_redis").await { + return true; + } + + let Ok(output) = podman_with_timeout( + &["exec", "immich_redis", "valkey-cli", "ping"], + Duration::from_secs(5), + ) + .await + else { + return false; + }; + output.status.success() && String::from_utf8_lossy(&output.stdout).contains("PONG") +} + +async fn container_health_is_healthy(container: &str) -> bool { + let Ok(output) = podman_with_timeout( + &[ + "inspect", + container, + "--format", + "{{if .State.Health}}{{.State.Health.Status}}{{else}}none{{end}}", + ], + Duration::from_secs(5), + ) + .await + else { + return false; + }; + + output.status.success() && String::from_utf8_lossy(&output.stdout).trim() == "healthy" +} + +async fn repair_netbird_network() { + super::stacks::repair_netbird_network_aliases().await; } async fn repair_nginx_proxy_manager_container() { @@ -1009,11 +1465,11 @@ async fn recreate_nginx_proxy_manager_container() -> Result<()> { } async fn ensure_runtime_host_port_listener(container_name: &str) -> Result<()> { - let Some(port) = runtime_required_host_port(container_name) else { + let Some(port) = runtime_host_ports(container_name).into_iter().next() else { return Ok(()); }; - if wait_for_runtime_host_port(port, 10).await { + if wait_for_runtime_host_port(container_name, port, 10).await { return Ok(()); } @@ -1035,7 +1491,7 @@ async fn ensure_runtime_host_port_listener(container_name: &str) -> Result<()> { )); } - if wait_for_runtime_host_port(port, 60).await { + if wait_for_runtime_host_port(container_name, port, 60).await { install_log(&format!( "START REPAIR OK: {} — host port {} is listening after restart", container_name, port @@ -1051,27 +1507,99 @@ async fn ensure_runtime_host_port_listener(container_name: &str) -> Result<()> { )) } -fn runtime_required_host_port(container_name: &str) -> Option { - match container_name { - "grafana" => Some(3000), - "homeassistant" | "home-assistant" => Some(8123), - "searxng" => Some(8888), - "uptime-kuma" => Some(3002), - "vaultwarden" => Some(8082), - "gitea" => Some(3001), - "nextcloud" => Some(8085), - "nginx-proxy-manager" => Some(8081), - _ => None, +fn runtime_host_ports(container_name: &str) -> Vec { + let manifest_ports = manifest_host_ports(container_name); + if !manifest_ports.is_empty() { + return with_legacy_extra_ports(container_name, manifest_ports); + } + + let ports = match container_name { + "grafana" => vec![3000], + "homeassistant" | "home-assistant" => vec![8123], + "jellyfin" => vec![8096], + "searxng" => vec![8888], + "uptime-kuma" => vec![3002], + "vaultwarden" => vec![8082], + "gitea" => vec![3001, 2222, 3000], + "nextcloud" => vec![8085], + "nginx-proxy-manager" => vec![8081, 8084, 8444], + _ => Vec::new(), + }; + ports +} + +fn with_legacy_extra_ports(container_name: &str, mut ports: Vec) -> Vec { + if container_name == "gitea" && !ports.contains(&3000) { + ports.push(3000); + } + if container_name == "nginx-proxy-manager" { + for port in [8084, 8444] { + if !ports.contains(&port) { + ports.push(port); + } + } + } + ports +} + +fn manifest_host_ports(container_name: &str) -> Vec { + for apps_dir in manifest_apps_dirs() { + let Ok(entries) = std::fs::read_dir(apps_dir) else { + continue; + }; + for entry in entries.flatten() { + let path = entry.path().join("manifest.yml"); + let Ok(contents) = std::fs::read_to_string(&path) else { + continue; + }; + let Ok(manifest) = AppManifest::parse(&contents) else { + continue; + }; + if manifest_container_name(&manifest) == container_name { + return manifest.app.ports.iter().map(|p| p.host).collect(); + } + } + } + Vec::new() +} + +fn manifest_apps_dirs() -> Vec { + let mut dirs = Vec::new(); + if let Ok(manifest_dir) = std::env::var("CARGO_MANIFEST_DIR") { + dirs.push(Path::new(&manifest_dir).join("../../apps")); + } + dirs.extend([ + Path::new("apps").to_path_buf(), + Path::new("/opt/archipelago/apps").to_path_buf(), + Path::new("/opt/archipelago/web-ui/archipelago-runtime/apps").to_path_buf(), + ]); + dirs +} + +fn manifest_container_name(manifest: &AppManifest) -> String { + if let Some(v) = manifest.app.extensions.get("container_name") { + if let Some(s) = v.as_str() { + if !s.is_empty() { + return s.to_string(); + } + } + } + match manifest.app.id.as_str() { + "bitcoin-ui" | "electrs-ui" | "lnd-ui" => format!("archy-{}", manifest.app.id), + id => id.to_string(), } } -async fn wait_for_runtime_host_port(port: u16, timeout_secs: u64) -> bool { +async fn wait_for_runtime_host_port(container_name: &str, port: u16, timeout_secs: u64) -> bool { let deadline = std::time::Instant::now() + std::time::Duration::from_secs(timeout_secs); loop { - if tokio::net::TcpStream::connect(("127.0.0.1", port)) - .await - .is_ok() - { + let ready = match container_name { + "uptime-kuma" => http_host_port_ready(port, "/").await, + _ => tokio::net::TcpStream::connect(("127.0.0.1", port)) + .await + .is_ok(), + }; + if ready { return true; } @@ -1083,6 +1611,37 @@ async fn wait_for_runtime_host_port(port: u16, timeout_secs: u64) -> bool { } } +async fn http_host_port_ready(port: u16, path: &str) -> bool { + let Ok(Ok(mut stream)) = tokio::time::timeout( + std::time::Duration::from_secs(3), + tokio::net::TcpStream::connect(("127.0.0.1", port)), + ) + .await + else { + return false; + }; + + let request = format!("GET {path} HTTP/1.1\r\nHost: 127.0.0.1\r\nConnection: close\r\n\r\n"); + if stream.write_all(request.as_bytes()).await.is_err() { + return false; + } + + let mut buf = [0u8; 128]; + let Ok(Ok(n)) = + tokio::time::timeout(std::time::Duration::from_secs(3), stream.read(&mut buf)).await + else { + return false; + }; + if n == 0 { + return false; + } + let head = String::from_utf8_lossy(&buf[..n]); + head.starts_with("HTTP/1.1 2") + || head.starts_with("HTTP/1.1 3") + || head.starts_with("HTTP/1.0 2") + || head.starts_with("HTTP/1.0 3") +} + async fn repair_btcpay_dirs() { let _ = tokio::process::Command::new("sudo") .args([ @@ -1157,6 +1716,27 @@ async fn repair_nextcloud_dirs() { } } +async fn repair_immich_dirs() { + let _ = tokio::process::Command::new("sudo") + .args(["mkdir", "-p", "/var/lib/archipelago/immich"]) + .output() + .await; + let podman_chown = podman_control(&[ + "unshare", + "chown", + "-R", + "0:0", + "/var/lib/archipelago/immich", + ]) + .await; + if !podman_chown.as_ref().is_ok_and(|o| o.status.success()) { + let _ = tokio::process::Command::new("sudo") + .args(["chown", "-R", "1000:1000", "/var/lib/archipelago/immich"]) + .output() + .await; + } +} + async fn repair_btcpay_database_password() { let Ok(db_pass) = tokio::fs::read_to_string("/var/lib/archipelago/secrets/btcpay-db-password").await @@ -1205,25 +1785,28 @@ async fn cleanup_start_conflict(container_name: &str, stderr: &str) { return; } - if container_name == "gitea" { - cleanup_gitea_stale_ports().await; + let ports = runtime_host_ports(container_name); + if !ports.is_empty() { + cleanup_ports(&ports).await; return; } +} - match container_name { - "grafana" => cleanup_stale_pasta_port("3000").await, - "homeassistant" | "home-assistant" => cleanup_stale_pasta_port("8123").await, - "vaultwarden" => cleanup_stale_pasta_port("8082").await, - "nextcloud" => cleanup_stale_pasta_port("8085").await, - "nginx-proxy-manager" => cleanup_nginx_proxy_manager_ports().await, - _ => {} +async fn cleanup_runtime_host_ports(container_name: &str) { + let ports = runtime_host_ports(container_name); + if !ports.is_empty() { + cleanup_ports(&ports).await; } } async fn cleanup_nginx_proxy_manager_ports() { - cleanup_stale_pasta_port("8081").await; - cleanup_stale_pasta_port("8084").await; - cleanup_stale_pasta_port("8444").await; + cleanup_ports(&[8081, 8084, 8444]).await; +} + +async fn cleanup_ports(ports: &[u16]) { + for port in ports { + cleanup_stale_pasta_port(&port.to_string()).await; + } } async fn cleanup_stale_pasta_port(port: &str) { @@ -1249,31 +1832,6 @@ async fn cleanup_stale_pasta_port(port: &str) { tokio::time::sleep(std::time::Duration::from_secs(1)).await; } -async fn cleanup_gitea_stale_ports() { - for port in ["3001", "2222", "3000"] { - let kill_listener = format!( - "ss -ltnp 'sport = :{}' 2>/dev/null | sed -n 's/.*pid=\\([0-9]*\\).*/\\1/p' | xargs -r kill 2>/dev/null || true", - port - ); - let _ = tokio::process::Command::new("sh") - .args(["-c", &kill_listener]) - .output() - .await; - - let pattern = format!("pasta.*{}", port); - let _ = tokio::process::Command::new("pkill") - .args(["-f", &pattern]) - .output() - .await; - let pattern = format!("rootlessport.*{}", port); - let _ = tokio::process::Command::new("pkill") - .args(["-f", &pattern]) - .output() - .await; - } - tokio::time::sleep(std::time::Duration::from_secs(1)).await; -} - pub(super) fn is_missing_companion_ok(name: &str, stderr: &str) -> bool { matches!( name, @@ -1352,3 +1910,20 @@ pub(super) fn orchestrator_uninstall_app_ids(package_id: &str) -> Vec { _ => vec![package_id.to_string()], } } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn runtime_host_ports_are_manifest_derived_for_public_apps() { + assert_eq!(runtime_host_ports("photoprism"), vec![2342]); + assert_eq!(runtime_host_ports("jellyfin"), vec![8096]); + assert_eq!(runtime_host_ports("uptime-kuma"), vec![3002]); + } + + #[test] + fn runtime_host_ports_preserve_legacy_extra_ports() { + assert_eq!(runtime_host_ports("gitea"), vec![3001, 2222, 3000]); + } +} diff --git a/core/archipelago/src/api/rpc/package/stacks.rs b/core/archipelago/src/api/rpc/package/stacks.rs index 77211240..b1e434a8 100644 --- a/core/archipelago/src/api/rpc/package/stacks.rs +++ b/core/archipelago/src/api/rpc/package/stacks.rs @@ -7,10 +7,134 @@ use crate::api::rpc::RpcHandler; use crate::data_model::InstallPhase; use anyhow::{Context, Result}; use base64::Engine; +use std::process::Output; +use std::time::Duration; use tracing::info; use super::install::{install_log, patch_indeedhub_nostr_provider}; +const PODMAN_STACK_PROBE_TIMEOUT: Duration = Duration::from_secs(10); +const PODMAN_STACK_LOG_TIMEOUT: Duration = Duration::from_secs(15); +const PODMAN_STACK_PULL_TIMEOUT: Duration = Duration::from_secs(600); +const PODMAN_STACK_REMOVE_TIMEOUT: Duration = Duration::from_secs(90); + +async fn podman_stack_output(args: &[&str], timeout: Duration) -> Result { + let mut cmd = tokio::process::Command::new("podman"); + cmd.args(args); + cmd.kill_on_drop(true); + tokio::time::timeout(timeout, cmd.output()) + .await + .with_context(|| { + format!( + "podman {} timed out after {}s", + args.join(" "), + timeout.as_secs() + ) + })? + .with_context(|| format!("failed to run podman {}", args.join(" "))) +} + +async fn podman_stack_status(args: &[&str], timeout: Duration) -> Result { + let mut cmd = tokio::process::Command::new("podman"); + cmd.args(args); + cmd.kill_on_drop(true); + tokio::time::timeout(timeout, cmd.status()) + .await + .with_context(|| { + format!( + "podman {} timed out after {}s", + args.join(" "), + timeout.as_secs() + ) + })? + .with_context(|| format!("failed to run podman {}", args.join(" "))) +} + +async fn force_remove_stack_container(container_name: &str) -> Result<()> { + for args in [ + vec!["rm", "-f", container_name], + vec!["rm", "-f", "--time", "0", container_name], + ] { + let output = podman_stack_output(&args, PODMAN_STACK_REMOVE_TIMEOUT).await?; + if output.status.success() + || is_missing_container_error(&String::from_utf8_lossy(&output.stderr)) + { + return wait_for_stack_container_absent(container_name, Duration::from_secs(90)).await; + } + } + + let _ = podman_stack_output( + &["container", "cleanup", container_name], + PODMAN_STACK_PROBE_TIMEOUT, + ) + .await; + let output = + podman_stack_output(&["rm", "-f", container_name], PODMAN_STACK_REMOVE_TIMEOUT).await?; + if output.status.success() + || is_missing_container_error(&String::from_utf8_lossy(&output.stderr)) + { + return wait_for_stack_container_absent(container_name, Duration::from_secs(90)).await; + } + + Err(anyhow::anyhow!( + "force remove {} failed: {}", + container_name, + String::from_utf8_lossy(&output.stderr).trim() + )) +} + +async fn wait_for_stack_container_absent(container_name: &str, timeout: Duration) -> Result<()> { + let deadline = std::time::Instant::now() + timeout; + loop { + let output = match podman_stack_output( + &["ps", "-a", "--format", "{{.Names}}"], + PODMAN_STACK_REMOVE_TIMEOUT, + ) + .await + { + Ok(output) => output, + Err(e) if std::time::Instant::now() < deadline => { + tracing::warn!( + container = %container_name, + error = %e, + "inspect during stack removal wait failed; retrying" + ); + tokio::time::sleep(Duration::from_secs(2)).await; + continue; + } + Err(e) => return Err(e), + }; + if output.status.success() + && !String::from_utf8_lossy(&output.stdout) + .lines() + .any(|line| line.trim() == container_name) + { + return Ok(()); + } + + if std::time::Instant::now() >= deadline { + let state = format!( + "stdout={} stderr={}", + String::from_utf8_lossy(&output.stdout).trim(), + String::from_utf8_lossy(&output.stderr).trim() + ); + return Err(anyhow::anyhow!( + "container {} still exists after removal attempt: {}", + container_name, + state + )); + } + tokio::time::sleep(Duration::from_secs(2)).await; + } +} + +fn is_missing_container_error(stderr: &str) -> bool { + stderr.contains("no such container") + || stderr.contains("no container with name") + || stderr.contains("does not exist") + || stderr.contains("not found") +} + /// Adopt an existing container stack: start all named containers and return success. /// Returns `Ok(Some(json))` if the primary container was found (adopted), /// or `Ok(None)` if it was not found (proceed with fresh install). @@ -19,11 +143,12 @@ async fn adopt_stack_if_exists( stack_name: &str, all_containers: &[&str], ) -> Result> { - let check = tokio::process::Command::new("podman") - .args(["ps", "-a", "--format", "{{.Names}}"]) - .output() - .await - .context("Failed to list containers")?; + let check = podman_stack_output( + &["ps", "-a", "--format", "{{.Names}}"], + PODMAN_STACK_PROBE_TIMEOUT, + ) + .await + .context("Failed to list containers")?; let stdout = String::from_utf8_lossy(&check.stdout); let names: Vec<&str> = stdout.lines().map(|l| l.trim()).collect(); @@ -45,10 +170,9 @@ async fn adopt_stack_if_exists( for container in all_containers { if names.iter().any(|n| n == container) { - let _ = tokio::process::Command::new("podman") - .args(["start", container]) - .output() - .await; + let _ = + podman_stack_output(["start", container].as_slice(), PODMAN_STACK_PROBE_TIMEOUT) + .await; } } let existing: Vec<&str> = all_containers @@ -76,10 +200,6 @@ async fn adopt_stack_if_exists( async fn repair_stack_before_adopt(stack_name: &str) { match stack_name { - "saleor" => { - repair_saleor_network_aliases().await; - let _ = start_saleor_storefront_containers().await; - } "btcpay" | "btcpay-server" => { let _ = tokio::process::Command::new("sudo") .args([ @@ -102,16 +222,17 @@ async fn repair_stack_before_adopt(stack_name: &str) { } } "indeedhub" => repair_indeedhub_network_aliases().await, - "netbird" => repair_netbird_unified_origin().await, + "netbird" => repair_netbird_network_aliases().await, _ => {} } } pub(in crate::api::rpc::package) async fn repair_indeedhub_network_aliases() { - let _ = tokio::process::Command::new("podman") - .args(["network", "create", "indeedhub-net"]) - .output() - .await; + let _ = podman_stack_output( + &["network", "create", "indeedhub-net"], + PODMAN_STACK_PROBE_TIMEOUT, + ) + .await; for (container, alias) in [ ("indeedhub-postgres", "postgres"), @@ -121,210 +242,117 @@ pub(in crate::api::rpc::package) async fn repair_indeedhub_network_aliases() { ("indeedhub-api", "api"), ("indeedhub", "indeedhub"), ] { - let exists = tokio::process::Command::new("podman") - .args(["container", "exists", container]) - .status() - .await - .map(|s| s.success()) - .unwrap_or(false); + let exists = podman_stack_status( + &["container", "exists", container], + PODMAN_STACK_PROBE_TIMEOUT, + ) + .await + .map(|s| s.success()) + .unwrap_or(false); if !exists { continue; } + if indeedhub_alias_present(container, alias).await { + continue; + } - let _ = tokio::process::Command::new("podman") - .args(["network", "disconnect", "-f", "indeedhub-net", container]) - .output() - .await; - let _ = tokio::process::Command::new("podman") - .args([ + let _ = podman_stack_output( + &["network", "disconnect", "-f", "indeedhub-net", container], + PODMAN_STACK_PROBE_TIMEOUT, + ) + .await; + let _ = podman_stack_output( + &[ "network", "connect", "--alias", alias, "indeedhub-net", container, - ]) - .output() - .await; + ], + PODMAN_STACK_PROBE_TIMEOUT, + ) + .await; } } -async fn repair_netbird_unified_origin() { - let host_ip = detect_netbird_public_host_ip() - .await - .unwrap_or_else(|| "127.0.0.1".to_string()); - let _ = write_netbird_config_files(&host_ip).await; - - for container in ["netbird", "netbird-dashboard"] { - let _ = tokio::process::Command::new("podman") - .args(["rm", "-f", container]) - .output() - .await; - } - - let _ = tokio::process::Command::new("podman") - .args(["network", "create", "netbird-net"]) - .output() - .await; - - let _ = pull_image_with_retry(NETBIRD_DASHBOARD_IMAGE).await; - let _ = pull_image_with_retry(NETBIRD_PROXY_IMAGE).await; - - let _ = tokio::process::Command::new("podman") - .args([ - "network", - "disconnect", - "-f", - "netbird-net", - "netbird-server", - ]) - .output() - .await; - let _ = tokio::process::Command::new("podman") - .args([ - "network", - "connect", - "--alias", - "netbird-server", - "netbird-net", - "netbird-server", - ]) - .output() - .await; - let _ = tokio::process::Command::new("podman") - .args(["restart", "netbird-server"]) - .output() - .await; - - tokio::time::sleep(std::time::Duration::from_secs(2)).await; - - let _ = tokio::process::Command::new("podman") - .args([ - "run", - "-d", - "--name", - "netbird-dashboard", - "--network", - "netbird-net", - "--restart=unless-stopped", - "--env-file", - "/var/lib/archipelago/netbird/dashboard.env", - NETBIRD_DASHBOARD_IMAGE, - ]) - .output() - .await; - - let _ = tokio::process::Command::new("podman") - .args([ - "run", - "-d", - "--name", - "netbird", - "--network", - "netbird-net", - "--restart=unless-stopped", - "-p", - "8087:80", - "-v", - "/var/lib/archipelago/netbird/nginx.conf:/etc/nginx/conf.d/default.conf:ro", - NETBIRD_PROXY_IMAGE, - ]) - .output() - .await; +async fn indeedhub_alias_present(container: &str, alias: &str) -> bool { + network_alias_present("indeedhub-net", container, alias).await } -async fn repair_saleor_network_aliases() { - let _ = tokio::process::Command::new("podman") - .args(["network", "create", "saleor-net"]) - .output() - .await; +async fn network_alias_present(network_name: &str, container: &str, alias: &str) -> bool { + let output = match podman_stack_output( + &[ + "inspect", + container, + "--format", + "{{json .NetworkSettings.Networks}}", + ], + PODMAN_STACK_PROBE_TIMEOUT, + ) + .await + { + Ok(output) if output.status.success() => output, + _ => return false, + }; + + let Ok(networks) = serde_json::from_slice::(&output.stdout) else { + return false; + }; + networks + .get(network_name) + .and_then(|network| network.get("Aliases")) + .and_then(|aliases| aliases.as_array()) + .map(|aliases| aliases.iter().any(|value| value.as_str() == Some(alias))) + .unwrap_or(false) +} + +pub(in crate::api::rpc::package) async fn repair_netbird_network_aliases() { + let _ = podman_stack_output( + &["network", "create", "netbird-net"], + PODMAN_STACK_PROBE_TIMEOUT, + ) + .await; for (container, alias) in [ - ("saleor-db", "db"), - ("saleor-cache", "cache"), - ("saleor-jaeger", "jaeger"), - ("saleor-mailpit", "mailpit"), - ("saleor-api", "api"), - ("saleor-worker", "worker"), - ("saleor", "saleor"), - ("saleor-storefront", "storefront"), - ("saleor-storefront-app", "storefront-app"), + ("netbird-server", "netbird-server"), + ("netbird-dashboard", "netbird-dashboard"), + ("netbird", "netbird"), ] { - let exists = tokio::process::Command::new("podman") - .args(["container", "exists", container]) - .status() - .await - .map(|s| s.success()) - .unwrap_or(false); + let exists = podman_stack_status( + &["container", "exists", container], + PODMAN_STACK_PROBE_TIMEOUT, + ) + .await + .map(|s| s.success()) + .unwrap_or(false); if !exists { continue; } + if network_alias_present("netbird-net", container, alias).await { + continue; + } - let _ = tokio::process::Command::new("podman") - .args(["network", "disconnect", "-f", "saleor-net", container]) - .output() - .await; - let _ = tokio::process::Command::new("podman") - .args([ + let _ = podman_stack_output( + &["network", "disconnect", "-f", "netbird-net", container], + PODMAN_STACK_PROBE_TIMEOUT, + ) + .await; + let _ = podman_stack_output( + &[ "network", "connect", "--alias", alias, - "saleor-net", + "netbird-net", container, - ]) - .output() - .await; + ], + PODMAN_STACK_PROBE_TIMEOUT, + ) + .await; } } -async fn start_saleor_storefront_containers() -> Result<()> { - let names = podman_container_names().await?; - - if !names.iter().any(|name| name == "saleor-storefront-app") { - pull_image_with_retry(SALEOR_STOREFRONT_IMAGE).await?; - let mut storefront_cmd = saleor_storefront_app_command(); - run_required_stack_command("saleor", "create storefront app", &mut storefront_cmd).await?; - } else { - let _ = tokio::process::Command::new("podman") - .args(["start", "saleor-storefront-app"]) - .output() - .await; - } - - write_saleor_storefront_proxy_config().await?; - if !names.iter().any(|name| name == "saleor-storefront") { - let mut proxy_cmd = saleor_storefront_proxy_command(); - run_required_stack_command("saleor", "create storefront proxy", &mut proxy_cmd).await?; - } else { - let _ = tokio::process::Command::new("podman") - .args(["start", "saleor-storefront"]) - .output() - .await; - } - - wait_for_stack_containers( - "saleor", - &["saleor-storefront-app", "saleor-storefront"], - 60, - ) - .await -} - -async fn podman_container_names() -> Result> { - let output = tokio::process::Command::new("podman") - .args(["ps", "-a", "--format", "{{.Names}}"]) - .output() - .await - .context("Failed to list containers")?; - Ok(String::from_utf8_lossy(&output.stdout) - .lines() - .map(str::trim) - .filter(|name| !name.is_empty()) - .map(ToOwned::to_owned) - .collect()) -} - async fn run_required_stack_command( stack_name: &str, label: &str, @@ -345,6 +373,62 @@ async fn run_required_stack_command( Err(anyhow::anyhow!("{} {}", stack_name, msg.trim())) } +async fn run_required_scoped_podman_stack_command( + stack_name: &str, + label: &str, + args: Vec, +) -> Result<()> { + run_required_scoped_podman_stack_command_with_env(stack_name, label, args, &[]).await +} + +async fn run_required_scoped_podman_stack_command_with_env( + stack_name: &str, + label: &str, + args: Vec, + env: &[String], +) -> Result<()> { + let mut cmd = tokio::process::Command::new("systemd-run"); + cmd.args(["--user", "--scope", "--quiet", "--collect"]); + for item in env { + cmd.arg(format!("--setenv={item}")); + } + cmd.arg("podman"); + cmd.args(&args); + let output = cmd + .output() + .await + .with_context(|| format!("{}: failed to run scoped {}", stack_name, label))?; + if output.status.success() { + return Ok(()); + } + + let stdout = String::from_utf8_lossy(&output.stdout); + let stderr = String::from_utf8_lossy(&output.stderr); + if matches!(args.first().map(String::as_str), Some("run" | "create")) { + let msg = format!("{} scoped creation failed: {}{}", label, stdout, stderr); + install_log(&format!("INSTALL FAIL: {} - {}", stack_name, msg.trim())).await; + return Err(anyhow::anyhow!("{} {}", stack_name, msg.trim())); + } + + install_log(&format!( + "INSTALL WARN: {} - scoped {} failed: {}{}; trying direct podman", + stack_name, label, stdout, stderr + )) + .await; + + let refs = args.iter().map(String::as_str).collect::>(); + let direct = podman_stack_output(&refs, PODMAN_STACK_PULL_TIMEOUT).await?; + if direct.status.success() { + return Ok(()); + } + + let stdout = String::from_utf8_lossy(&direct.stdout); + let stderr = String::from_utf8_lossy(&direct.stderr); + let msg = format!("{} failed: {}{}", label, stdout, stderr); + install_log(&format!("INSTALL FAIL: {} - {}", stack_name, msg.trim())).await; + Err(anyhow::anyhow!("{} {}", stack_name, msg.trim())) +} + async fn wait_for_stack_containers( stack_name: &str, containers: &[&str], @@ -354,10 +438,11 @@ async fn wait_for_stack_containers( loop { let mut pending = Vec::new(); for container in containers { - let status = tokio::process::Command::new("podman") - .args(["inspect", container, "--format", "{{.State.Status}}"]) - .output() - .await; + let status = podman_stack_output( + &["inspect", container, "--format", "{{.State.Status}}"], + PODMAN_STACK_PROBE_TIMEOUT, + ) + .await; match status { Ok(output) if output.status.success() => { let state = String::from_utf8_lossy(&output.stdout).trim().to_string(); @@ -413,17 +498,82 @@ async fn wait_for_stack_containers( } } +async fn wait_for_stack_container_health( + stack_name: &str, + container: &str, + timeout_secs: u64, +) -> Result<()> { + let deadline = std::time::Instant::now() + std::time::Duration::from_secs(timeout_secs); + loop { + let status = podman_stack_output( + &[ + "inspect", + container, + "--format", + "{{if .State.Health}}{{.State.Health.Status}}{{else}}none{{end}}", + ], + PODMAN_STACK_PROBE_TIMEOUT, + ) + .await; + match status { + Ok(output) if output.status.success() => { + let health = String::from_utf8_lossy(&output.stdout).trim().to_string(); + if health == "healthy" { + return Ok(()); + } + if health == "unhealthy" { + let logs = stack_container_logs(container, 80).await; + install_log(&format!( + "INSTALL UNHEALTHY: {} - container {} unhealthy. Logs:\n{}", + stack_name, + container, + logs.chars().take(1000).collect::() + )) + .await; + } + } + Ok(output) => { + install_log(&format!( + "INSTALL HEALTH WAIT: {} - {} inspect failed: {}", + stack_name, + container, + String::from_utf8_lossy(&output.stderr).trim() + )) + .await; + } + Err(e) => { + install_log(&format!( + "INSTALL HEALTH WAIT: {} - {} inspect error: {}", + stack_name, container, e + )) + .await; + } + } + + if std::time::Instant::now() >= deadline { + return Err(anyhow::anyhow!( + "{} container {} did not become healthy within {}s", + stack_name, + container, + timeout_secs + )); + } + tokio::time::sleep(std::time::Duration::from_secs(3)).await; + } +} + async fn stack_container_logs(container: &str, lines: u32) -> String { - tokio::process::Command::new("podman") - .args(["logs", "--tail", &lines.to_string(), container]) - .output() - .await - .map(|o| { - let stdout = String::from_utf8_lossy(&o.stdout); - let stderr = String::from_utf8_lossy(&o.stderr); - format!("{}{}", stdout, stderr) - }) - .unwrap_or_default() + podman_stack_output( + &["logs", "--tail", &lines.to_string(), container], + PODMAN_STACK_LOG_TIMEOUT, + ) + .await + .map(|o| { + let stdout = String::from_utf8_lossy(&o.stdout); + let stderr = String::from_utf8_lossy(&o.stderr); + format!("{}{}", stdout, stderr) + }) + .unwrap_or_default() } async fn install_stack_via_orchestrator( @@ -495,20 +645,10 @@ const REGISTRY: &str = "146.59.87.168:3000/lfg2025"; const NETBIRD_DASHBOARD_IMAGE: &str = "docker.io/netbirdio/dashboard:v2.38.0"; const NETBIRD_SERVER_IMAGE: &str = "docker.io/netbirdio/netbird-server:0.71.2"; const NETBIRD_PROXY_IMAGE: &str = "docker.io/library/nginx:1.27-alpine"; -const SALEOR_API_IMAGE: &str = "ghcr.io/saleor/saleor:3.23"; -const SALEOR_DASHBOARD_IMAGE: &str = "ghcr.io/saleor/saleor-dashboard:3.23"; -const SALEOR_STOREFRONT_IMAGE: &str = "146.59.87.168:3000/lfg2025/saleor-storefront:6eb0b97"; -const SALEOR_POSTGRES_IMAGE: &str = "docker.io/library/postgres:15-alpine"; -const SALEOR_VALKEY_IMAGE: &str = "docker.io/valkey/valkey:8.1-alpine"; -const SALEOR_JAEGER_IMAGE: &str = "docker.io/jaegertracing/jaeger:latest"; -const SALEOR_MAILPIT_IMAGE: &str = "docker.io/axllent/mailpit:latest"; /// Pull an image with retry and exponential backoff (3 attempts). async fn pull_image_with_retry(image: &str) -> Result<()> { - let exists = tokio::process::Command::new("podman") - .args(["image", "exists", image]) - .status() - .await; + let exists = podman_stack_status(&["image", "exists", image], PODMAN_STACK_PROBE_TIMEOUT).await; if matches!(exists, Ok(status) if status.success()) { return Ok(()); } @@ -522,10 +662,16 @@ async fn pull_image_with_retry(image: &str) -> Result<()> { if archipelago_container::image_uses_insecure_registry(image) { cmd.arg("--tls-verify=false"); } - let output = cmd - .arg(image) - .output() + cmd.arg(image); + cmd.kill_on_drop(true); + let output = tokio::time::timeout(PODMAN_STACK_PULL_TIMEOUT, cmd.output()) .await + .with_context(|| { + format!( + "podman pull {image} timed out after {}s", + PODMAN_STACK_PULL_TIMEOUT.as_secs() + ) + })? .context("Failed to execute podman pull")?; if output.status.success() { @@ -557,75 +703,6 @@ async fn pull_image_with_retry(image: &str) -> Result<()> { unreachable!() } -fn saleor_storefront_app_command() -> tokio::process::Command { - let mut cmd = tokio::process::Command::new("podman"); - cmd.args([ - "run", - "-d", - "--name", - "saleor-storefront-app", - "--network", - "saleor-net", - "--network-alias", - "storefront-app", - "--restart=unless-stopped", - "--cap-drop=ALL", - "--cap-add=CHOWN", - "--cap-add=DAC_OVERRIDE", - "--cap-add=FOWNER", - "--cap-add=SETGID", - "--cap-add=SETUID", - "--security-opt=no-new-privileges:true", - "--memory=512m", - "--pids-limit=2048", - "-e", - "NEXT_PUBLIC_SALEOR_API_URL=http://api:8000/graphql/", - "-e", - "NEXT_PUBLIC_SALEOR_MEDIA_URL=http://api:8000/", - "-e", - "NEXT_PUBLIC_STOREFRONT_URL=http://localhost:9011", - "-e", - "NEXT_PUBLIC_DEFAULT_CHANNEL=default-channel", - "-e", - "HOSTNAME=0.0.0.0", - "-e", - "PORT=3000", - SALEOR_STOREFRONT_IMAGE, - ]); - cmd -} - -fn saleor_storefront_proxy_command() -> tokio::process::Command { - let mut cmd = tokio::process::Command::new("podman"); - cmd.args([ - "run", - "-d", - "--name", - "saleor-storefront", - "--network", - "saleor-net", - "--network-alias", - "storefront", - "--restart=unless-stopped", - "--cap-drop=ALL", - "--cap-add=CHOWN", - "--cap-add=DAC_OVERRIDE", - "--cap-add=FOWNER", - "--cap-add=NET_BIND_SERVICE", - "--cap-add=SETGID", - "--cap-add=SETUID", - "--security-opt=no-new-privileges:true", - "--memory=128m", - "--pids-limit=1024", - "-p", - "9011:80", - "-v", - "/var/lib/archipelago/saleor-storefront/nginx.conf:/etc/nginx/conf.d/default.conf:ro", - NETBIRD_PROXY_IMAGE, - ]); - cmd -} - impl RpcHandler { /// Install Immich stack (postgres + redis + server). pub(super) async fn install_immich_stack(&self) -> Result { @@ -640,21 +717,16 @@ impl RpcHandler { } // Clean up stale "immich" container (old naming) before fresh install - let check = tokio::process::Command::new("podman") - .args(["ps", "-a", "--format", "{{.Names}}"]) - .output() - .await - .context("Failed to list containers")?; + let check = podman_stack_output( + &["ps", "-a", "--format", "{{.Names}}"], + PODMAN_STACK_PROBE_TIMEOUT, + ) + .await + .context("Failed to list containers")?; let stdout = String::from_utf8_lossy(&check.stdout); if stdout.contains("immich\n") || stdout.lines().any(|l| l.trim() == "immich") { - let _ = tokio::process::Command::new("podman") - .args(["stop", "immich"]) - .output() - .await; - let _ = tokio::process::Command::new("podman") - .args(["rm", "-f", "immich"]) - .output() - .await; + let _ = podman_stack_output(&["stop", "immich"], PODMAN_STACK_PROBE_TIMEOUT).await; + let _ = force_remove_stack_container("immich").await; } let images = [ @@ -694,123 +766,129 @@ impl RpcHandler { ]) .output() .await; - let _ = tokio::process::Command::new("podman") - .args(["network", "create", "immich-net"]) - .output() - .await; + let _ = podman_stack_output( + &["network", "create", "immich-net"], + PODMAN_STACK_PROBE_TIMEOUT, + ) + .await; let db_pass = super::config::read_or_generate_secret("immich-db-password").await; - let _ = tokio::process::Command::new("podman") - .args([ - "run", - "-d", - "--name", - "immich_postgres", - "--restart", - "unless-stopped", - "--network", - "immich-net", - "--network-alias", - "immich_postgres", - "--cap-drop=ALL", - "--cap-add=CHOWN", - "--cap-add=DAC_OVERRIDE", - "--cap-add=FOWNER", - "--cap-add=SETGID", - "--cap-add=SETUID", - "--security-opt=no-new-privileges:true", - "--memory=2g", - "--pids-limit=4096", - "--health-cmd=pg_isready -U postgres || exit 1", - "--health-interval=30s", - "--health-retries=3", - "-v", - "/var/lib/archipelago/immich-db:/var/lib/postgresql/data", - "-e", - &format!("POSTGRES_PASSWORD={}", db_pass), - "-e", - "POSTGRES_USER=postgres", - "-e", - "POSTGRES_DB=immich", - "146.59.87.168:3000/lfg2025/immich-postgres:14-vectorchord0.4.3-pgvectors0.2.0", - ]) - .output() - .await; + let mut postgres_cmd = tokio::process::Command::new("podman"); + postgres_cmd.args([ + "run", + "-d", + "--name", + "immich_postgres", + "--restart", + "unless-stopped", + "--network", + "immich-net", + "--network-alias", + "immich_postgres", + "--cap-drop=ALL", + "--cap-add=CHOWN", + "--cap-add=DAC_OVERRIDE", + "--cap-add=FOWNER", + "--cap-add=SETGID", + "--cap-add=SETUID", + "--security-opt=no-new-privileges:true", + "--memory=2g", + "--pids-limit=4096", + "--health-cmd=pg_isready -U postgres || exit 1", + "--health-interval=30s", + "--health-retries=3", + "-v", + "/var/lib/archipelago/immich-db:/var/lib/postgresql/data", + "-e", + &format!("POSTGRES_PASSWORD={}", db_pass), + "-e", + "POSTGRES_USER=postgres", + "-e", + "POSTGRES_DB=immich", + "146.59.87.168:3000/lfg2025/immich-postgres:14-vectorchord0.4.3-pgvectors0.2.0", + ]); + run_required_stack_command("immich", "create postgres", &mut postgres_cmd).await?; tokio::time::sleep(std::time::Duration::from_secs(5)).await; - let _ = tokio::process::Command::new("podman") - .args([ - "run", - "-d", - "--name", - "immich_redis", - "--restart", - "unless-stopped", - "--network", - "immich-net", - "--network-alias", - "immich_redis", - "--cap-drop=ALL", - "--cap-add=SETGID", - "--cap-add=SETUID", - "--security-opt=no-new-privileges:true", - "--memory=128m", - "--pids-limit=2048", - "--health-cmd=valkey-cli ping || exit 1", - "--health-interval=30s", - "--health-retries=3", - "146.59.87.168:3000/lfg2025/valkey:7-alpine", - ]) - .output() - .await; + let mut redis_cmd = tokio::process::Command::new("podman"); + redis_cmd.args([ + "run", + "-d", + "--name", + "immich_redis", + "--restart", + "unless-stopped", + "--network", + "immich-net", + "--network-alias", + "immich_redis", + "--cap-drop=ALL", + "--cap-add=SETGID", + "--cap-add=SETUID", + "--security-opt=no-new-privileges:true", + "--memory=128m", + "--pids-limit=2048", + "--health-cmd=valkey-cli ping || exit 1", + "--health-interval=30s", + "--health-retries=3", + "146.59.87.168:3000/lfg2025/valkey:7-alpine", + ]); + run_required_stack_command("immich", "create redis", &mut redis_cmd).await?; tokio::time::sleep(std::time::Duration::from_secs(2)).await; - let run = tokio::process::Command::new("podman") - .args([ - "run", - "-d", - "--name", - "immich_server", - "--restart", - "unless-stopped", - "--network", - "immich-net", - "--network-alias", - "immich_server", - "--cap-drop=ALL", - "--security-opt=no-new-privileges:true", - "--memory=2g", - "--pids-limit=4096", - "-p", - "2283:2283", - "-v", - "/var/lib/archipelago/immich:/usr/src/app/upload", - "-e", - "DB_HOSTNAME=immich_postgres", - "-e", - "DB_USERNAME=postgres", - "-e", - &format!("DB_PASSWORD={}", db_pass), - "-e", - "DB_DATABASE_NAME=immich", - "-e", - "REDIS_HOSTNAME=immich_redis", - "-e", - "UPLOAD_LOCATION=/usr/src/app/upload", - "146.59.87.168:3000/lfg2025/immich-server:release", - ]) - .output() - .await - .context("Failed to start immich_server")?; - - if !run.status.success() { - let stderr = String::from_utf8_lossy(&run.stderr); - return Err(anyhow::anyhow!("Failed to start Immich server: {}", stderr)); - } + run_required_scoped_podman_stack_command( + "immich", + "create server", + vec![ + "run".to_string(), + "-d".to_string(), + "--name".to_string(), + "immich_server".to_string(), + "--restart".to_string(), + "unless-stopped".to_string(), + "--network".to_string(), + "immich-net".to_string(), + "--network-alias".to_string(), + "immich_server".to_string(), + "--cap-drop=ALL".to_string(), + "--security-opt=no-new-privileges:true".to_string(), + "--memory=2g".to_string(), + "--pids-limit=4096".to_string(), + "--health-cmd=curl -sf http://localhost:2283/api/server/ping || exit 1".to_string(), + "--health-interval=30s".to_string(), + "--health-retries=20".to_string(), + "--health-start-period=180s".to_string(), + "-p".to_string(), + "2283:2283".to_string(), + "-v".to_string(), + "/var/lib/archipelago/immich:/usr/src/app/upload".to_string(), + "-e".to_string(), + "DB_HOSTNAME=immich_postgres".to_string(), + "-e".to_string(), + "DB_USERNAME=postgres".to_string(), + "-e".to_string(), + format!("DB_PASSWORD={}", db_pass), + "-e".to_string(), + "DB_DATABASE_NAME=immich".to_string(), + "-e".to_string(), + "REDIS_HOSTNAME=immich_redis".to_string(), + "-e".to_string(), + "UPLOAD_LOCATION=/usr/src/app/upload".to_string(), + "146.59.87.168:3000/lfg2025/immich-server:release".to_string(), + ], + ) + .await?; self.set_install_phase("immich", InstallPhase::WaitingHealthy) .await; + wait_for_stack_containers( + "immich", + &["immich_postgres", "immich_redis", "immich_server"], + 120, + ) + .await?; + wait_for_stack_container_health("immich", "immich_server", 360).await?; self.set_install_phase("immich", InstallPhase::PostInstall) .await; self.set_install_phase("immich", InstallPhase::Done).await; @@ -896,10 +974,11 @@ impl RpcHandler { } // Ensure archy-net exists - let _ = tokio::process::Command::new("podman") - .args(["network", "create", "archy-net"]) - .output() - .await; + let _ = podman_stack_output( + &["network", "create", "archy-net"], + PODMAN_STACK_PROBE_TIMEOUT, + ) + .await; // 1. PostgreSQL let _ = tokio::process::Command::new("podman") @@ -1119,10 +1198,11 @@ impl RpcHandler { } // Ensure archy-net exists - let _ = tokio::process::Command::new("podman") - .args(["network", "create", "archy-net"]) - .output() - .await; + let _ = podman_stack_output( + &["network", "create", "archy-net"], + PODMAN_STACK_PROBE_TIMEOUT, + ) + .await; // 1. MariaDB let _ = tokio::process::Command::new("podman") @@ -1336,15 +1416,15 @@ impl RpcHandler { "indeedhub-build_api_1", "indeedhub-build_ffmpeg-worker_1", ] { - let _ = tokio::process::Command::new("podman") - .args(["rm", "-f", name]) - .status() - .await; + force_remove_stack_container(name) + .await + .with_context(|| format!("Failed to clear stale IndeedHub container {}", name))?; } - let _ = tokio::process::Command::new("podman") - .args(["network", "rm", "-f", "indeedhub-net"]) - .status() - .await; + let _ = podman_stack_status( + &["network", "rm", "-f", "indeedhub-net"], + PODMAN_STACK_PROBE_TIMEOUT, + ) + .await; // Phase: CreatingContainer — pulls done, network rebuilt, now spinning // up the 7 stack containers. Bar advances from PullingImage band into @@ -1353,10 +1433,11 @@ impl RpcHandler { .await; // Create indeedhub-net - let _ = tokio::process::Command::new("podman") - .args(["network", "create", "indeedhub-net"]) - .status() - .await; + let _ = podman_stack_status( + &["network", "create", "indeedhub-net"], + PODMAN_STACK_PROBE_TIMEOUT, + ) + .await; // Generate secrets let db_pass = super::config::read_or_generate_secret("indeedhub-db-password").await; @@ -1364,231 +1445,247 @@ impl RpcHandler { let minio_user = "indeeadmin"; let minio_pass = super::config::read_or_generate_secret("indeedhub-minio-password").await; + let tmp_env = [format!("TMPDIR={user_tmp}")]; + // 1. Postgres - let mut postgres_cmd = tokio::process::Command::new("podman"); - postgres_cmd - .args([ - "run", - "-d", - "--name", - "indeedhub-postgres", - "--network", - "indeedhub-net", - "--network-alias", - "postgres", - "--restart", - "unless-stopped", - "-e", - "POSTGRES_DB=indeedhub", - "-e", - "POSTGRES_USER=indeedhub", - "-e", - &format!("POSTGRES_PASSWORD={}", db_pass), - "-v", - "indeedhub-postgres-data:/var/lib/postgresql/data", - &format!("{}/postgres:16.13-alpine", registry), - ]) - .env("TMPDIR", &user_tmp); - run_required_stack_command("indeedhub", "create postgres", &mut postgres_cmd).await?; + run_required_scoped_podman_stack_command_with_env( + "indeedhub", + "create postgres", + vec![ + "run".to_string(), + "-d".to_string(), + "--name".to_string(), + "indeedhub-postgres".to_string(), + "--network".to_string(), + "indeedhub-net".to_string(), + "--network-alias".to_string(), + "postgres".to_string(), + "--restart".to_string(), + "unless-stopped".to_string(), + "-e".to_string(), + "POSTGRES_DB=indeedhub".to_string(), + "-e".to_string(), + "POSTGRES_USER=indeedhub".to_string(), + "-e".to_string(), + format!("POSTGRES_PASSWORD={db_pass}"), + "-v".to_string(), + "indeedhub-postgres-data:/var/lib/postgresql/data".to_string(), + format!("{registry}/postgres:16.13-alpine"), + ], + &tmp_env, + ) + .await?; // 2. Redis - let mut redis_cmd = tokio::process::Command::new("podman"); - redis_cmd - .args([ - "run", - "-d", - "--name", - "indeedhub-redis", - "--network", - "indeedhub-net", - "--network-alias", - "redis", - "--restart", - "unless-stopped", - "-v", - "indeedhub-redis-data:/data", - &format!("{}/redis:7.4.8-alpine", registry), - ]) - .env("TMPDIR", &user_tmp); - run_required_stack_command("indeedhub", "create redis", &mut redis_cmd).await?; + run_required_scoped_podman_stack_command_with_env( + "indeedhub", + "create redis", + vec![ + "run".to_string(), + "-d".to_string(), + "--name".to_string(), + "indeedhub-redis".to_string(), + "--network".to_string(), + "indeedhub-net".to_string(), + "--network-alias".to_string(), + "redis".to_string(), + "--restart".to_string(), + "unless-stopped".to_string(), + "-v".to_string(), + "indeedhub-redis-data:/data".to_string(), + format!("{registry}/redis:7.4.8-alpine"), + ], + &tmp_env, + ) + .await?; // 3. MinIO - let mut minio_cmd = tokio::process::Command::new("podman"); - minio_cmd - .args([ - "run", - "-d", - "--name", - "indeedhub-minio", - "--network", - "indeedhub-net", - "--network-alias", - "minio", - "--restart", - "unless-stopped", - "-e", - &format!("MINIO_ROOT_USER={}", minio_user), - "-e", - &format!("MINIO_ROOT_PASSWORD={}", minio_pass), - "-v", - "indeedhub-minio-data:/data", - &format!("{}/minio:RELEASE.2024-11-07T00-52-20Z", registry), - "server", - "/data", - ]) - .env("TMPDIR", &user_tmp); - run_required_stack_command("indeedhub", "create minio", &mut minio_cmd).await?; + run_required_scoped_podman_stack_command_with_env( + "indeedhub", + "create minio", + vec![ + "run".to_string(), + "-d".to_string(), + "--name".to_string(), + "indeedhub-minio".to_string(), + "--network".to_string(), + "indeedhub-net".to_string(), + "--network-alias".to_string(), + "minio".to_string(), + "--restart".to_string(), + "unless-stopped".to_string(), + "-e".to_string(), + format!("MINIO_ROOT_USER={minio_user}"), + "-e".to_string(), + format!("MINIO_ROOT_PASSWORD={minio_pass}"), + "-v".to_string(), + "indeedhub-minio-data:/data".to_string(), + format!("{registry}/minio:RELEASE.2024-11-07T00-52-20Z"), + "server".to_string(), + "/data".to_string(), + ], + &tmp_env, + ) + .await?; // 4. Nostr relay - let mut relay_cmd = tokio::process::Command::new("podman"); - relay_cmd - .args([ - "run", - "-d", - "--name", - "indeedhub-relay", - "--network", - "indeedhub-net", - "--network-alias", - "relay", - "--restart", - "unless-stopped", - "-v", - "indeedhub-relay-data:/usr/src/app/db", - &format!("{}/nostr-rs-relay:0.9.0", registry), - ]) - .env("TMPDIR", &user_tmp); - run_required_stack_command("indeedhub", "create relay", &mut relay_cmd).await?; + run_required_scoped_podman_stack_command_with_env( + "indeedhub", + "create relay", + vec![ + "run".to_string(), + "-d".to_string(), + "--name".to_string(), + "indeedhub-relay".to_string(), + "--network".to_string(), + "indeedhub-net".to_string(), + "--network-alias".to_string(), + "relay".to_string(), + "--restart".to_string(), + "unless-stopped".to_string(), + "-v".to_string(), + "indeedhub-relay-data:/usr/src/app/db".to_string(), + format!("{registry}/nostr-rs-relay:0.9.0"), + ], + &tmp_env, + ) + .await?; // 5. API - let mut api_cmd = tokio::process::Command::new("podman"); - api_cmd - .args([ - "run", - "-d", - "--name", - "indeedhub-api", - "--network", - "indeedhub-net", - "--network-alias", - "api", - "--restart", - "unless-stopped", - "-e", - "PORT=4000", - "-e", - "DATABASE_HOST=postgres", - "-e", - "DATABASE_PORT=5432", - "-e", - "DATABASE_USER=indeedhub", - "-e", - &format!("DATABASE_PASSWORD={}", db_pass), - "-e", - "DATABASE_NAME=indeedhub", - "-e", - "QUEUE_HOST=redis", - "-e", - "QUEUE_PORT=6379", - "-e", - "S3_ENDPOINT=http://minio:9000", - "-e", - "AWS_REGION=us-east-1", - "-e", - &format!("AWS_ACCESS_KEY={}", minio_user), - "-e", - &format!("AWS_SECRET_KEY={}", minio_pass), - "-e", - "S3_PUBLIC_BUCKET_NAME=indeedhub-public", - "-e", - "S3_PRIVATE_BUCKET_NAME=indeedhub-private", - "-e", - "S3_PUBLIC_BUCKET_URL=/storage", - "-e", - &format!("NOSTR_JWT_SECRET={}", jwt_secret), - "-e", - "NOSTR_JWT_EXPIRES_IN=7d", - "-e", - "AES_MASTER_SECRET=0123456789abcdef0123456789abcdef", - "-e", - "ENVIRONMENT=production", - &format!("{}/indeedhub-api:1.0.0", registry), - ]) - .env("TMPDIR", &user_tmp); - run_required_stack_command("indeedhub", "create api", &mut api_cmd).await?; + run_required_scoped_podman_stack_command_with_env( + "indeedhub", + "create api", + vec![ + "run".to_string(), + "-d".to_string(), + "--name".to_string(), + "indeedhub-api".to_string(), + "--network".to_string(), + "indeedhub-net".to_string(), + "--network-alias".to_string(), + "api".to_string(), + "--restart".to_string(), + "unless-stopped".to_string(), + "-e".to_string(), + "PORT=4000".to_string(), + "-e".to_string(), + "DATABASE_HOST=postgres".to_string(), + "-e".to_string(), + "DATABASE_PORT=5432".to_string(), + "-e".to_string(), + "DATABASE_USER=indeedhub".to_string(), + "-e".to_string(), + format!("DATABASE_PASSWORD={db_pass}"), + "-e".to_string(), + "DATABASE_NAME=indeedhub".to_string(), + "-e".to_string(), + "QUEUE_HOST=redis".to_string(), + "-e".to_string(), + "QUEUE_PORT=6379".to_string(), + "-e".to_string(), + "S3_ENDPOINT=http://minio:9000".to_string(), + "-e".to_string(), + "AWS_REGION=us-east-1".to_string(), + "-e".to_string(), + format!("AWS_ACCESS_KEY={minio_user}"), + "-e".to_string(), + format!("AWS_SECRET_KEY={minio_pass}"), + "-e".to_string(), + "S3_PUBLIC_BUCKET_NAME=indeedhub-public".to_string(), + "-e".to_string(), + "S3_PRIVATE_BUCKET_NAME=indeedhub-private".to_string(), + "-e".to_string(), + "S3_PUBLIC_BUCKET_URL=/storage".to_string(), + "-e".to_string(), + format!("NOSTR_JWT_SECRET={jwt_secret}"), + "-e".to_string(), + "NOSTR_JWT_EXPIRES_IN=7d".to_string(), + "-e".to_string(), + "AES_MASTER_SECRET=0123456789abcdef0123456789abcdef".to_string(), + "-e".to_string(), + "ENVIRONMENT=production".to_string(), + format!("{registry}/indeedhub-api:1.0.0"), + ], + &tmp_env, + ) + .await?; // 6. FFmpeg worker - let mut ffmpeg_cmd = tokio::process::Command::new("podman"); - ffmpeg_cmd - .args([ - "run", - "-d", - "--name", - "indeedhub-ffmpeg", - "--network", - "indeedhub-net", - "--restart", - "unless-stopped", - "-e", - "DATABASE_HOST=postgres", - "-e", - "DATABASE_PORT=5432", - "-e", - "DATABASE_USER=indeedhub", - "-e", - &format!("DATABASE_PASSWORD={}", db_pass), - "-e", - "DATABASE_NAME=indeedhub", - "-e", - "QUEUE_HOST=redis", - "-e", - "QUEUE_PORT=6379", - "-e", - "S3_ENDPOINT=http://minio:9000", - "-e", - &format!("AWS_ACCESS_KEY={}", minio_user), - "-e", - &format!("AWS_SECRET_KEY={}", minio_pass), - "-e", - "AWS_REGION=us-east-1", - "-e", - "S3_PUBLIC_BUCKET_NAME=indeedhub-public", - "-e", - "S3_PRIVATE_BUCKET_NAME=indeedhub-private", - "-e", - "ENVIRONMENT=production", - "-e", - "AES_MASTER_SECRET=0123456789abcdef0123456789abcdef", - &format!("{}/indeedhub-ffmpeg:1.0.0", registry), - ]) - .env("TMPDIR", &user_tmp); - run_required_stack_command("indeedhub", "create ffmpeg worker", &mut ffmpeg_cmd).await?; + run_required_scoped_podman_stack_command_with_env( + "indeedhub", + "create ffmpeg worker", + vec![ + "run".to_string(), + "-d".to_string(), + "--name".to_string(), + "indeedhub-ffmpeg".to_string(), + "--network".to_string(), + "indeedhub-net".to_string(), + "--restart".to_string(), + "unless-stopped".to_string(), + "-e".to_string(), + "DATABASE_HOST=postgres".to_string(), + "-e".to_string(), + "DATABASE_PORT=5432".to_string(), + "-e".to_string(), + "DATABASE_USER=indeedhub".to_string(), + "-e".to_string(), + format!("DATABASE_PASSWORD={db_pass}"), + "-e".to_string(), + "DATABASE_NAME=indeedhub".to_string(), + "-e".to_string(), + "QUEUE_HOST=redis".to_string(), + "-e".to_string(), + "QUEUE_PORT=6379".to_string(), + "-e".to_string(), + "S3_ENDPOINT=http://minio:9000".to_string(), + "-e".to_string(), + format!("AWS_ACCESS_KEY={minio_user}"), + "-e".to_string(), + format!("AWS_SECRET_KEY={minio_pass}"), + "-e".to_string(), + "AWS_REGION=us-east-1".to_string(), + "-e".to_string(), + "S3_PUBLIC_BUCKET_NAME=indeedhub-public".to_string(), + "-e".to_string(), + "S3_PRIVATE_BUCKET_NAME=indeedhub-private".to_string(), + "-e".to_string(), + "ENVIRONMENT=production".to_string(), + "-e".to_string(), + "AES_MASTER_SECRET=0123456789abcdef0123456789abcdef".to_string(), + format!("{registry}/indeedhub-ffmpeg:1.0.0"), + ], + &tmp_env, + ) + .await?; // Wait for backend services to start tokio::time::sleep(std::time::Duration::from_secs(5)).await; // 7. Frontend (nginx) - let mut frontend_cmd = tokio::process::Command::new("podman"); - frontend_cmd - .args([ - "run", - "-d", - "--name", - "indeedhub", - "--network", - "indeedhub-net", - "--restart", - "unless-stopped", - "--tmpfs", - "/run:rw,nosuid,nodev,size=16m", - "--tmpfs", - "/var/cache/nginx:rw,nosuid,nodev,size=32m", - "-p", - "7778:7777", - &format!("{}/indeedhub:1.0.0", registry), - ]) - .env("TMPDIR", &user_tmp); - run_required_stack_command("indeedhub", "create frontend", &mut frontend_cmd).await?; + run_required_scoped_podman_stack_command_with_env( + "indeedhub", + "create frontend", + vec![ + "run".to_string(), + "-d".to_string(), + "--name".to_string(), + "indeedhub".to_string(), + "--network".to_string(), + "indeedhub-net".to_string(), + "--restart".to_string(), + "unless-stopped".to_string(), + "--tmpfs".to_string(), + "/run:rw,nosuid,nodev,size=16m".to_string(), + "--tmpfs".to_string(), + "/var/cache/nginx:rw,nosuid,nodev,size=32m".to_string(), + "-p".to_string(), + "7778:7777".to_string(), + format!("{}/indeedhub:1.0.0", registry), + ], + &tmp_env, + ) + .await?; wait_for_stack_containers( "indeedhub", @@ -1661,15 +1758,13 @@ impl RpcHandler { self.set_install_progress("netbird", 3, 3).await; for name in ["netbird", "netbird-dashboard", "netbird-server"] { - let _ = tokio::process::Command::new("podman") - .args(["rm", "-f", name]) - .status() - .await; + let _ = podman_stack_status(&["rm", "-f", name], PODMAN_STACK_PROBE_TIMEOUT).await; } - let _ = tokio::process::Command::new("podman") - .args(["network", "rm", "-f", "netbird-net"]) - .status() - .await; + let _ = podman_stack_status( + &["network", "rm", "-f", "netbird-net"], + PODMAN_STACK_PROBE_TIMEOUT, + ) + .await; self.set_install_phase("netbird", InstallPhase::CreatingContainer) .await; @@ -1683,10 +1778,11 @@ impl RpcHandler { .unwrap_or_else(|| self.config.host_ip.clone()); write_netbird_config_files(&host_ip).await?; - let _ = tokio::process::Command::new("podman") - .args(["network", "create", "netbird-net"]) - .status() - .await; + let _ = podman_stack_status( + &["network", "create", "netbird-net"], + PODMAN_STACK_PROBE_TIMEOUT, + ) + .await; let mut server_cmd = tokio::process::Command::new("podman"); server_cmd.args([ @@ -1771,500 +1867,6 @@ impl RpcHandler { "message": "NetBird self-hosted stack installed", })) } - - /// Install Saleor stack (PostgreSQL + Valkey + API + worker + dashboard + Jaeger + Mailpit). - pub(super) async fn install_saleor_stack(&self) -> Result { - if let Some(adopted) = adopt_stack_if_exists( - "saleor", - "saleor", - &[ - "saleor-db", - "saleor-cache", - "saleor-jaeger", - "saleor-mailpit", - "saleor-api", - "saleor-worker", - "saleor", - "saleor-storefront", - "saleor-storefront-app", - ], - ) - .await? - { - return Ok(adopted); - } - - install_log("INSTALL START: saleor stack (postgres + valkey + api + worker + dashboard + storefront)") - .await; - info!("Installing Saleor stack"); - - let images = [ - SALEOR_POSTGRES_IMAGE, - SALEOR_VALKEY_IMAGE, - SALEOR_API_IMAGE, - SALEOR_DASHBOARD_IMAGE, - SALEOR_STOREFRONT_IMAGE, - SALEOR_JAEGER_IMAGE, - SALEOR_MAILPIT_IMAGE, - ]; - self.set_install_phase("saleor", InstallPhase::PullingImage) - .await; - let n_images = images.len() as u64; - for (i, image) in images.iter().enumerate() { - self.set_install_progress("saleor", i as u64, n_images) - .await; - pull_image_with_retry(image) - .await - .with_context(|| format!("Failed to pull Saleor image: {}", image))?; - } - self.set_install_progress("saleor", n_images, n_images) - .await; - - for name in [ - "saleor", - "saleor-api", - "saleor-worker", - "saleor-storefront", - "saleor-storefront-app", - "saleor-db", - "saleor-cache", - "saleor-jaeger", - "saleor-mailpit", - ] { - let _ = tokio::process::Command::new("podman") - .args(["rm", "-f", name]) - .status() - .await; - } - let _ = tokio::process::Command::new("podman") - .args(["network", "rm", "-f", "saleor-net"]) - .status() - .await; - - self.set_install_phase("saleor", InstallPhase::CreatingContainer) - .await; - - let _ = tokio::process::Command::new("sudo") - .args([ - "mkdir", - "-p", - "/var/lib/archipelago/saleor", - "/var/lib/archipelago/saleor-db", - "/var/lib/archipelago/saleor-cache", - "/var/lib/archipelago/saleor-storefront", - ]) - .output() - .await; - let user = std::env::var("USER").unwrap_or_else(|_| "archipelago".to_string()); - for dir in [ - "/var/lib/archipelago/saleor", - "/var/lib/archipelago/saleor-db", - "/var/lib/archipelago/saleor-cache", - "/var/lib/archipelago/saleor-storefront", - ] { - let _ = tokio::process::Command::new("sudo") - .args(["chown", "-R", &format!("{}:{}", user, user), dir]) - .output() - .await; - } - - let _ = tokio::process::Command::new("podman") - .args(["network", "create", "saleor-net"]) - .status() - .await; - - let db_pass = super::config::read_or_generate_secret("saleor-db-password").await; - let secret_key = super::config::read_or_generate_secret("saleor-secret-key").await; - let admin_pass = super::config::read_or_generate_secret("saleor-admin-password").await; - let host_ip = &self.config.host_ip; - let dashboard_origin = format!("http://{}:9010", host_ip); - let dashboard_url = format!("{}/", dashboard_origin); - let api_url = format!("http://{}:8000/graphql/", host_ip); - let storefront_origin = format!("http://{}:9011", host_ip); - let allowed_hosts = format!("localhost,127.0.0.1,api,saleor-api,{}", host_ip); - let allowed_client_hosts = format!( - "{},{},http://localhost:9010,http://127.0.0.1:9010,http://localhost:9011,http://127.0.0.1:9011", - dashboard_origin, storefront_origin - ); - let database_url = format!("postgres://saleor:{}@db/saleor", db_pass); - - let mut db_cmd = tokio::process::Command::new("podman"); - db_cmd.args([ - "run", - "-d", - "--name", - "saleor-db", - "--network", - "saleor-net", - "--network-alias", - "db", - "--restart=unless-stopped", - "--cap-drop=ALL", - "--cap-add=CHOWN", - "--cap-add=DAC_OVERRIDE", - "--cap-add=FOWNER", - "--cap-add=SETGID", - "--cap-add=SETUID", - "--security-opt=no-new-privileges:true", - "--memory=512m", - "--pids-limit=4096", - "--health-cmd=pg_isready -U saleor || exit 1", - "--health-interval=30s", - "--health-retries=3", - "-v", - "/var/lib/archipelago/saleor-db:/var/lib/postgresql/data", - "-e", - "POSTGRES_USER=saleor", - "-e", - &format!("POSTGRES_PASSWORD={}", db_pass), - "-e", - "POSTGRES_DB=saleor", - SALEOR_POSTGRES_IMAGE, - ]); - run_required_stack_command("saleor", "create postgres", &mut db_cmd).await?; - - let mut cache_cmd = tokio::process::Command::new("podman"); - cache_cmd.args([ - "run", - "-d", - "--name", - "saleor-cache", - "--network", - "saleor-net", - "--network-alias", - "cache", - "--restart=unless-stopped", - "--cap-drop=ALL", - "--cap-add=SETGID", - "--cap-add=SETUID", - "--security-opt=no-new-privileges:true", - "--memory=128m", - "--pids-limit=2048", - "--health-cmd=valkey-cli ping || exit 1", - "--health-interval=30s", - "--health-retries=3", - SALEOR_VALKEY_IMAGE, - ]); - run_required_stack_command("saleor", "create cache", &mut cache_cmd).await?; - - let mut jaeger_cmd = tokio::process::Command::new("podman"); - jaeger_cmd.args([ - "run", - "-d", - "--name", - "saleor-jaeger", - "--network", - "saleor-net", - "--network-alias", - "jaeger", - "--restart=unless-stopped", - "--cap-drop=ALL", - "--security-opt=no-new-privileges:true", - "--memory=512m", - "--pids-limit=4096", - "-p", - "16686:16686", - "-p", - "4317:4317", - "-p", - "4318:4318", - "--tmpfs", - "/tmp:rw,nosuid,nodev,size=128m", - SALEOR_JAEGER_IMAGE, - ]); - run_required_stack_command("saleor", "create jaeger", &mut jaeger_cmd).await?; - - let mut mailpit_cmd = tokio::process::Command::new("podman"); - mailpit_cmd.args([ - "run", - "-d", - "--name", - "saleor-mailpit", - "--network", - "saleor-net", - "--network-alias", - "mailpit", - "--restart=unless-stopped", - "--cap-drop=ALL", - "--security-opt=no-new-privileges:true", - "--memory=128m", - "--pids-limit=2048", - "-p", - "1025:1025", - "-p", - "8025:8025", - SALEOR_MAILPIT_IMAGE, - ]); - run_required_stack_command("saleor", "create mailpit", &mut mailpit_cmd).await?; - - tokio::time::sleep(std::time::Duration::from_secs(8)).await; - - let saleor_env = vec![ - "-e".to_string(), - "CACHE_URL=redis://cache:6379/0".to_string(), - "-e".to_string(), - "CELERY_BROKER_URL=redis://cache:6379/1".to_string(), - "-e".to_string(), - format!("DATABASE_URL={}", database_url), - "-e".to_string(), - "DEFAULT_CHANNEL_SLUG=default-channel".to_string(), - "-e".to_string(), - "DEFAULT_FROM_EMAIL=noreply@example.com".to_string(), - "-e".to_string(), - "EMAIL_URL=smtp://mailpit:1025".to_string(), - "-e".to_string(), - format!("SECRET_KEY={}", secret_key), - "-e".to_string(), - "OTEL_SERVICE_NAME=saleor".to_string(), - "-e".to_string(), - "OTEL_TRACES_EXPORTER=otlp".to_string(), - "-e".to_string(), - "OTEL_EXPORTER_OTLP_ENDPOINT=http://jaeger:4317".to_string(), - "-e".to_string(), - "HTTP_IP_FILTER_ALLOW_LOOPBACK_IPS=True".to_string(), - "-e".to_string(), - "HTTP_IP_FILTER_ENABLED=False".to_string(), - "-e".to_string(), - format!("DASHBOARD_URL={}", dashboard_url), - "-e".to_string(), - format!("ALLOWED_CLIENT_HOSTS={}", allowed_client_hosts), - "-e".to_string(), - format!("ALLOWED_GRAPHQL_ORIGINS={}", allowed_client_hosts), - "-e".to_string(), - format!("ALLOWED_HOSTS={}", allowed_hosts), - ]; - - let mut migrate_cmd = tokio::process::Command::new("podman"); - migrate_cmd.args([ - "run", - "--rm", - "--network", - "saleor-net", - "-v", - "/var/lib/archipelago/saleor:/app/media", - ]); - migrate_cmd.args(&saleor_env); - migrate_cmd.args([SALEOR_API_IMAGE, "python3", "manage.py", "migrate"]); - run_required_stack_command("saleor", "run migrations", &mut migrate_cmd).await?; - - let mut populate_cmd = tokio::process::Command::new("podman"); - populate_cmd.args([ - "run", - "--rm", - "--network", - "saleor-net", - "-v", - "/var/lib/archipelago/saleor:/app/media", - ]); - populate_cmd.args(&saleor_env); - populate_cmd.args([ - SALEOR_API_IMAGE, - "python3", - "manage.py", - "populatedb", - "--createsuperuser", - ]); - let populate = populate_cmd.output().await; - if let Ok(output) = populate { - if !output.status.success() { - install_log(&format!( - "INSTALL WARN: saleor - populate sample data skipped: {}{}", - String::from_utf8_lossy(&output.stdout), - String::from_utf8_lossy(&output.stderr) - )) - .await; - } - } - - let admin_script = format!( - r#"from django.contrib.auth import get_user_model -User = get_user_model() -user, _ = User.objects.get_or_create(email="admin@example.com", defaults={{"is_staff": True, "is_superuser": True}}) -user.is_staff = True -user.is_superuser = True -user.set_password({:?}) -user.save() -"#, - admin_pass - ); - let mut admin_cmd = tokio::process::Command::new("podman"); - admin_cmd.args([ - "run", - "--rm", - "--network", - "saleor-net", - "-v", - "/var/lib/archipelago/saleor:/app/media", - ]); - admin_cmd.args(&saleor_env); - admin_cmd.args([ - SALEOR_API_IMAGE, - "python3", - "manage.py", - "shell", - "-c", - &admin_script, - ]); - run_required_stack_command("saleor", "create or update admin user", &mut admin_cmd).await?; - install_log("INSTALL INFO: saleor admin email admin@example.com; password stored in /var/lib/archipelago/secrets/saleor-admin-password").await; - - let mut api_cmd = tokio::process::Command::new("podman"); - api_cmd.args([ - "run", - "-d", - "--name", - "saleor-api", - "--network", - "saleor-net", - "--network-alias", - "api", - "--restart=unless-stopped", - "--cap-drop=ALL", - "--cap-add=CHOWN", - "--cap-add=DAC_OVERRIDE", - "--cap-add=FOWNER", - "--cap-add=SETGID", - "--cap-add=SETUID", - "--security-opt=no-new-privileges:true", - "--memory=1g", - "--pids-limit=4096", - "-p", - "8000:8000", - "-v", - "/var/lib/archipelago/saleor:/app/media", - ]); - api_cmd.args(&saleor_env); - api_cmd.arg(SALEOR_API_IMAGE); - run_required_stack_command("saleor", "create api", &mut api_cmd).await?; - - let mut worker_cmd = tokio::process::Command::new("podman"); - worker_cmd.args([ - "run", - "-d", - "--name", - "saleor-worker", - "--network", - "saleor-net", - "--restart=unless-stopped", - "--cap-drop=ALL", - "--cap-add=CHOWN", - "--cap-add=DAC_OVERRIDE", - "--cap-add=FOWNER", - "--cap-add=SETGID", - "--cap-add=SETUID", - "--security-opt=no-new-privileges:true", - "--memory=1g", - "--pids-limit=4096", - "-v", - "/var/lib/archipelago/saleor:/app/media", - ]); - worker_cmd.args(&saleor_env); - worker_cmd.args([ - SALEOR_API_IMAGE, - "celery", - "-A", - "saleor", - "--app=saleor.celeryconf:app", - "worker", - "--loglevel=info", - "-B", - ]); - run_required_stack_command("saleor", "create worker", &mut worker_cmd).await?; - - self.set_install_phase("saleor", InstallPhase::StartingContainer) - .await; - tokio::time::sleep(std::time::Duration::from_secs(5)).await; - - let mut dashboard_cmd = tokio::process::Command::new("podman"); - dashboard_cmd.args([ - "run", - "-d", - "--name", - "saleor", - "--network", - "saleor-net", - "--restart=unless-stopped", - "--cap-drop=ALL", - "--cap-add=CHOWN", - "--cap-add=DAC_OVERRIDE", - "--cap-add=FOWNER", - "--cap-add=NET_BIND_SERVICE", - "--cap-add=SETGID", - "--cap-add=SETUID", - "--security-opt=no-new-privileges:true", - "--memory=256m", - "--pids-limit=2048", - "-p", - "9010:80", - "-e", - &format!("API_URL={}", api_url), - "-e", - "APP_MOUNT_URI=/", - SALEOR_DASHBOARD_IMAGE, - ]); - run_required_stack_command("saleor", "create dashboard", &mut dashboard_cmd).await?; - - let mut storefront_cmd = saleor_storefront_app_command(); - run_required_stack_command("saleor", "create storefront app", &mut storefront_cmd).await?; - - write_saleor_storefront_proxy_config().await?; - let mut storefront_proxy_cmd = saleor_storefront_proxy_command(); - run_required_stack_command( - "saleor", - "create storefront proxy", - &mut storefront_proxy_cmd, - ) - .await?; - - wait_for_stack_containers( - "saleor", - &[ - "saleor-db", - "saleor-cache", - "saleor-jaeger", - "saleor-mailpit", - "saleor-api", - "saleor-worker", - "saleor", - "saleor-storefront", - "saleor-storefront-app", - ], - 120, - ) - .await?; - tokio::time::sleep(std::time::Duration::from_secs(5)).await; - wait_for_stack_containers( - "saleor", - &[ - "saleor-db", - "saleor-cache", - "saleor-jaeger", - "saleor-mailpit", - "saleor-api", - "saleor-worker", - "saleor", - "saleor-storefront", - "saleor-storefront-app", - ], - 30, - ) - .await?; - - self.set_install_phase("saleor", InstallPhase::WaitingHealthy) - .await; - self.set_install_phase("saleor", InstallPhase::PostInstall) - .await; - self.set_install_phase("saleor", InstallPhase::Done).await; - self.clear_install_progress("saleor").await; - - install_log("INSTALL OK: saleor stack").await; - info!("Saleor stack installed"); - Ok(serde_json::json!({ - "success": true, - "package_id": "saleor", - "message": "Saleor stack installed (9 containers)", - })) - } } async fn read_or_generate_b64_secret(name: &str) -> String { @@ -2283,71 +1885,6 @@ async fn read_or_generate_b64_secret(name: &str) -> String { secret } -async fn write_saleor_storefront_proxy_config() -> Result<()> { - tokio::fs::create_dir_all("/var/lib/archipelago/saleor-storefront") - .await - .context("Failed to create Saleor storefront config directory")?; - - let nginx_conf = r#"map $http_x_forwarded_proto $saleor_storefront_proto { - default $http_x_forwarded_proto; - "" $scheme; -} - -server { - listen 80; - server_name _; - resolver 10.89.4.1 valid=10s ipv6=off; - - proxy_http_version 1.1; - proxy_set_header Host $host; - proxy_set_header X-Real-IP $remote_addr; - proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; - proxy_set_header X-Forwarded-Host $host; - proxy_set_header X-Forwarded-Proto $scheme; - - location ^~ /graphql/ { - set $saleor_api http://api:8000/graphql/; - proxy_pass $saleor_api; - proxy_set_header Host api; - proxy_set_header Origin ""; - } - - location ^~ /thumbnail/ { - set $saleor_media http://api:8000$request_uri; - proxy_pass $saleor_media; - proxy_set_header Host api; - proxy_set_header Origin ""; - } - - location ^~ /media/ { - set $saleor_media http://api:8000$request_uri; - proxy_pass $saleor_media; - proxy_set_header Host api; - proxy_set_header Origin ""; - } - - location / { - set $saleor_storefront_app http://storefront-app:3000; - proxy_pass $saleor_storefront_app; - proxy_set_header Upgrade $http_upgrade; - proxy_set_header Connection "upgrade"; - proxy_set_header Accept-Encoding ""; - sub_filter_once off; - sub_filter_types text/html application/javascript text/javascript; - sub_filter 'http://api:8000/graphql/' '$saleor_storefront_proto://$host/graphql/'; - } -} -"#; - - tokio::fs::write( - "/var/lib/archipelago/saleor-storefront/nginx.conf", - nginx_conf, - ) - .await - .context("Failed to write Saleor storefront nginx.conf")?; - Ok(()) -} - async fn write_netbird_config_files(host_ip: &str) -> Result<()> { let public_origin = format!("http://{}:8087", host_ip); let server_origin = format!("http://{}:8086", host_ip); diff --git a/core/archipelago/src/api/rpc/package/update.rs b/core/archipelago/src/api/rpc/package/update.rs index 90541499..f48044a6 100644 --- a/core/archipelago/src/api/rpc/package/update.rs +++ b/core/archipelago/src/api/rpc/package/update.rs @@ -16,6 +16,8 @@ use anyhow::{Context, Result}; use tokio::io::{AsyncBufReadExt, BufReader}; use tracing::{error, info, warn}; +const PODMAN_UPDATE_PULL_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(600); + impl RpcHandler { /// Update a package to the version pinned in image-versions.sh. /// This is a manual operation — the user clicks "Update" in the UI. @@ -327,6 +329,7 @@ impl RpcHandler { if archipelago_container::image_uses_insecure_registry(image) { cmd.arg("--tls-verify=false"); } + cmd.kill_on_drop(true); let mut child = cmd .arg(image) .stdout(std::process::Stdio::piped()) @@ -334,23 +337,38 @@ impl RpcHandler { .spawn() .context("Failed to start image pull")?; - if let Some(stderr) = child.stderr.take() { + let progress_task = if let Some(stderr) = child.stderr.take() { let reader = BufReader::new(stderr); let mut lines = reader.lines(); let pkg_id = package_id.to_string(); let state_mgr = self.state_manager.clone(); - while let Ok(Some(line)) = lines.next_line().await { - if let Some((downloaded, total)) = parse_pull_progress(&line) { - Self::update_install_progress(&state_mgr, &pkg_id, downloaded, total).await; + Some(tokio::spawn(async move { + while let Ok(Some(line)) = lines.next_line().await { + if let Some((downloaded, total)) = parse_pull_progress(&line) { + Self::update_install_progress(&state_mgr, &pkg_id, downloaded, total).await; + } } - } - } + })) + } else { + None + }; - let status = child - .wait() - .await - .context("Failed to wait for image pull")?; + let status = match tokio::time::timeout(PODMAN_UPDATE_PULL_TIMEOUT, child.wait()).await { + Ok(result) => result.context("Failed to wait for image pull")?, + Err(_) => { + let _ = child.kill().await; + return Err(anyhow::anyhow!( + "podman pull {} timed out after {}s", + image, + PODMAN_UPDATE_PULL_TIMEOUT.as_secs() + )); + } + }; + + if let Some(task) = progress_task { + let _ = task.await; + } if !status.success() { return Err(anyhow::anyhow!("podman pull {} failed", image)); } @@ -430,7 +448,6 @@ fn should_try_orchestrator_update(package_id: &str, orchestrator_available: bool fn orchestrator_update_app_id(package_id: &str) -> &str { match package_id { - "bitcoin-knots" => "bitcoin-core", "electrs" | "mempool-electrs" => "electrumx", _ => package_id, } @@ -459,8 +476,8 @@ fn candidate_app_ids_for_container(container_name: &str) -> Vec { match container_name { "bitcoin-knots" | "bitcoin-core" => { - push("bitcoin-core"); push("bitcoin-knots"); + push("bitcoin-core"); } "archy-bitcoin-ui" => push("bitcoin-ui"), "archy-lnd-ui" => push("lnd-ui"), @@ -525,7 +542,7 @@ mod tests { fn container_name_candidates_cover_common_aliases() { assert_eq!( candidate_app_ids_for_container("bitcoin-knots"), - vec!["bitcoin-core", "bitcoin-knots"] + vec!["bitcoin-knots", "bitcoin-core"] ); assert_eq!( candidate_app_ids_for_container("archy-bitcoin-ui"), @@ -543,7 +560,8 @@ mod tests { #[test] fn update_aliases_map_to_manifest_app_ids() { - assert_eq!(orchestrator_update_app_id("bitcoin-knots"), "bitcoin-core"); + assert_eq!(orchestrator_update_app_id("bitcoin-knots"), "bitcoin-knots"); + assert_eq!(orchestrator_update_app_id("bitcoin-core"), "bitcoin-core"); assert_eq!(orchestrator_update_app_id("electrs"), "electrumx"); assert_eq!(orchestrator_update_app_id("mempool-electrs"), "electrumx"); assert_eq!(orchestrator_update_app_id("fedimint"), "fedimint"); diff --git a/core/archipelago/src/api/rpc/system/handlers.rs b/core/archipelago/src/api/rpc/system/handlers.rs index 281839a2..573f4600 100644 --- a/core/archipelago/src/api/rpc/system/handlers.rs +++ b/core/archipelago/src/api/rpc/system/handlers.rs @@ -1,7 +1,7 @@ use super::*; use crate::api::rpc::RpcHandler; use anyhow::{Context, Result}; -use tracing::{debug, info}; +use tracing::{debug, info, warn}; impl RpcHandler { /// server.set-name — Rename the server (persisted to data_dir/server-name) @@ -32,6 +32,21 @@ impl RpcHandler { data.server_info.name = Some(name.clone()); self.state_manager.update_data(data).await; + let hostname = hostname_from_server_name(&name); + let hostname_result = set_system_hostname(&hostname).await; + let (hostname_updated, hostname_error) = match hostname_result { + Ok(()) => (true, None), + Err(e) => { + warn!( + name = %name, + hostname = %hostname, + "Server name persisted but OS hostname update failed: {}", + e + ); + (false, Some(e.to_string())) + } + }; + info!("Server name updated to: {}", name); // Push the new name to federation peers in background @@ -43,7 +58,12 @@ impl RpcHandler { } }); - Ok(serde_json::json!({ "name": name })) + Ok(serde_json::json!({ + "name": name, + "hostname": hostname, + "hostname_updated": hostname_updated, + "hostname_error": hostname_error, + })) } /// system.stats — CPU usage, RAM used/total, disk used/total, uptime, load average @@ -155,21 +175,7 @@ impl RpcHandler { let mut freed_bytes: u64 = 0; let mut actions: Vec = Vec::new(); - // 1. Prune dangling container images - match prune_container_images().await { - Ok(bytes) => { - if bytes > 0 { - freed_bytes += bytes; - actions.push(format!( - "Pruned dangling images: {} freed", - format_bytes(bytes) - )); - } - } - Err(e) => actions.push(format!("Image prune failed: {}", e)), - } - - // 2. Clean old log files (> 30 days) + // 1. Clean old log files (> 30 days) match clean_old_logs(30).await { Ok(bytes) => { if bytes > 0 { @@ -180,7 +186,20 @@ impl RpcHandler { Err(e) => actions.push(format!("Log cleanup failed: {}", e)), } - // 3. Remove stale temp files + match vacuum_journal_logs("200M").await { + Ok(bytes) => { + if bytes > 0 { + freed_bytes += bytes; + actions.push(format!( + "Vacuumed journal logs: {} freed", + format_bytes(bytes) + )); + } + } + Err(e) => actions.push(format!("Journal cleanup failed: {}", e)), + } + + // 2. Remove stale temp files match clean_temp_files().await { Ok(bytes) => { if bytes > 0 { @@ -191,17 +210,53 @@ impl RpcHandler { Err(e) => actions.push(format!("Temp cleanup failed: {}", e)), } - // 4. Prune container build cache - match prune_build_cache().await { + // 3. Keep only the most recent backend deploy backups. These are useful + // for rollback, but a long-lived alpha node can accumulate gigabytes of + // old binaries under /usr/local/bin. + match clean_backend_backups(3).await { Ok(bytes) => { if bytes > 0 { freed_bytes += bytes; - actions.push(format!("Pruned build cache: {} freed", format_bytes(bytes))); + actions.push(format!( + "Removed old backend backups: {} freed", + format_bytes(bytes) + )); } } - Err(e) => actions.push(format!("Build cache prune failed: {}", e)), + Err(e) => actions.push(format!("Backend backup cleanup failed: {}", e)), } + match clean_legacy_backend_backups(3).await { + Ok(bytes) => { + if bytes > 0 { + freed_bytes += bytes; + actions.push(format!( + "Removed old legacy backend backups: {} freed", + format_bytes(bytes) + )); + } + } + Err(e) => actions.push(format!("Legacy backend backup cleanup failed: {}", e)), + } + + match clean_web_ui_backups(3).await { + Ok(bytes) => { + if bytes > 0 { + freed_bytes += bytes; + actions.push(format!( + "Removed old web UI backups: {} freed", + format_bytes(bytes) + )); + } + } + Err(e) => actions.push(format!("Web UI backup cleanup failed: {}", e)), + } + + actions.push( + "Skipped Podman image/volume prune: Podman store commands can block app health on busy nodes" + .to_string(), + ); + tracing::info!( "Disk cleanup complete: {} freed ({} actions)", format_bytes(freed_bytes), @@ -216,6 +271,54 @@ impl RpcHandler { } } +pub(super) fn hostname_from_server_name(name: &str) -> String { + let mut hostname = String::with_capacity(name.len()); + let mut previous_dash = false; + + for c in name.trim().chars().flat_map(char::to_lowercase) { + let valid = c.is_ascii_lowercase() || c.is_ascii_digit(); + if valid { + hostname.push(c); + previous_dash = false; + } else if !previous_dash { + hostname.push('-'); + previous_dash = true; + } + if hostname.len() >= 63 { + break; + } + } + + let hostname = hostname.trim_matches('-').to_string(); + if hostname.is_empty() { + "archipelago".to_string() + } else { + hostname + } +} + +async fn set_system_hostname(hostname: &str) -> Result<()> { + let output = tokio::process::Command::new("/usr/bin/sudo") + .args(["-n", "/usr/bin/hostnamectl", "set-hostname", hostname]) + .output() + .await + .context("Failed to run hostnamectl")?; + + if !output.status.success() { + let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string(); + anyhow::bail!( + "{}", + if stderr.is_empty() { + "hostnamectl failed".to_string() + } else { + stderr + } + ); + } + + Ok(()) +} + impl RpcHandler { /// system.factory-reset — Wipe all user data, remove containers, and restart. /// Only preserves the data_dir itself (recreated empty on restart). diff --git a/core/archipelago/src/api/rpc/system/mod.rs b/core/archipelago/src/api/rpc/system/mod.rs index 86f5a324..a9cd7d3d 100644 --- a/core/archipelago/src/api/rpc/system/mod.rs +++ b/core/archipelago/src/api/rpc/system/mod.rs @@ -1,6 +1,9 @@ mod handlers; +use crate::update::host_sudo; use anyhow::{Context, Result}; +use std::path::{Path, PathBuf}; +use std::time::SystemTime; use tracing::{debug, info}; /// Push the server name to all federation peers by syncing state. @@ -301,53 +304,12 @@ pub(super) async fn detect_usb_hardware_wallets() -> Result Result { - let output = tokio::process::Command::new("podman") - .args(["image", "prune", "-f"]) - .output() - .await - .context("Failed to run podman image prune")?; - - if !output.status.success() { - anyhow::bail!( - "podman image prune failed: {}", - String::from_utf8_lossy(&output.stderr) - ); - } - - // Podman outputs image IDs, estimate ~100MB per pruned image - let stdout = String::from_utf8_lossy(&output.stdout); - let pruned_count = stdout.lines().filter(|l| !l.trim().is_empty()).count(); - Ok(pruned_count as u64 * 100_000_000) // rough estimate -} - -/// Prune container build cache via `podman system prune -f`. -pub(super) async fn prune_build_cache() -> Result { - // Just prune volumes and build cache (not containers or images — those are handled above) - let output = tokio::process::Command::new("podman") - .args(["volume", "prune", "-f"]) - .output() - .await - .context("Failed to run podman volume prune")?; - - if !output.status.success() { - anyhow::bail!( - "podman volume prune failed: {}", - String::from_utf8_lossy(&output.stderr) - ); - } - - let stdout = String::from_utf8_lossy(&output.stdout); - let pruned_count = stdout.lines().filter(|l| !l.trim().is_empty()).count(); - Ok(pruned_count as u64 * 10_000_000) // rough estimate per volume -} - /// Clean log files older than `max_age_days` from common log directories. pub(super) async fn clean_old_logs(max_age_days: u64) -> Result { - let output = tokio::process::Command::new("sudo") + let output = tokio::process::Command::new("timeout") .args([ + "60s", + "sudo", "find", "/var/log", "-type", @@ -366,8 +328,10 @@ pub(super) async fn clean_old_logs(max_age_days: u64) -> Result { let stdout = String::from_utf8_lossy(&output.stdout); let deleted_count = stdout.lines().filter(|l| !l.trim().is_empty()).count(); // Also clean rotated/compressed logs - let _ = tokio::process::Command::new("sudo") + let _ = tokio::process::Command::new("timeout") .args([ + "60s", + "sudo", "find", "/var/log", "-type", @@ -384,14 +348,81 @@ pub(super) async fn clean_old_logs(max_age_days: u64) -> Result { Ok(deleted_count as u64 * 500_000) // rough estimate per log file } +/// Vacuum systemd journals to a bounded size. Returns measured bytes freed. +pub(super) async fn vacuum_journal_logs(max_size: &str) -> Result { + let before = journal_disk_usage().await.unwrap_or(0); + let output = tokio::process::Command::new("timeout") + .args(["60s", "sudo", "journalctl", "--vacuum-size", max_size]) + .output() + .await + .context("Failed to run journal vacuum")?; + + if !output.status.success() { + anyhow::bail!( + "journal vacuum failed: {}", + String::from_utf8_lossy(&output.stderr) + ); + } + + let after = journal_disk_usage().await.unwrap_or(before); + Ok(before.saturating_sub(after)) +} + +async fn journal_disk_usage() -> Result { + let output = tokio::process::Command::new("sudo") + .args(["-n", "journalctl", "--disk-usage"]) + .output() + .await + .context("Failed to read journal disk usage")?; + + if !output.status.success() { + anyhow::bail!( + "journalctl --disk-usage failed: {}", + String::from_utf8_lossy(&output.stderr) + ); + } + + parse_journal_disk_usage(&String::from_utf8_lossy(&output.stdout)) + .ok_or_else(|| anyhow::anyhow!("could not parse journal disk usage")) +} + +fn parse_journal_disk_usage(output: &str) -> Option { + let mut parts = output.split_whitespace(); + while let Some(part) = parts.next() { + let (number, inline_unit) = split_number_unit(part); + let Ok(value) = number.parse::() else { + continue; + }; + let unit = inline_unit.unwrap_or_else(|| parts.next().unwrap_or_default()); + let multiplier = match unit { + "B" | "bytes" => 1.0, + "K" | "KB" | "KiB" => 1024.0, + "M" | "MB" | "MiB" => 1024.0 * 1024.0, + "G" | "GB" | "GiB" => 1024.0 * 1024.0 * 1024.0, + _ => continue, + }; + return Some((value * multiplier) as u64); + } + None +} + +fn split_number_unit(value: &str) -> (&str, Option<&str>) { + let split_at = value + .char_indices() + .find_map(|(idx, ch)| (!ch.is_ascii_digit() && ch != '.').then_some(idx)) + .unwrap_or(value.len()); + let (number, unit) = value.split_at(split_at); + (number, (!unit.is_empty()).then_some(unit)) +} + /// Remove stale temp files from /tmp and /var/tmp. pub(super) async fn clean_temp_files() -> Result { let mut freed = 0u64; for dir in &["/tmp", "/var/tmp"] { - let output = tokio::process::Command::new("sudo") + let output = tokio::process::Command::new("timeout") .args([ - "find", dir, "-type", "f", "-mtime", "+7", "-delete", "-print", + "45s", "sudo", "find", dir, "-type", "f", "-mtime", "+7", "-delete", "-print", ]) .output() .await; @@ -406,6 +437,177 @@ pub(super) async fn clean_temp_files() -> Result { Ok(freed) } +/// Keep the newest timestamped backend backups and remove older ones. +pub(super) async fn clean_backend_backups(keep: usize) -> Result { + clean_backend_backups_in(Path::new("/usr/local/bin"), keep).await +} + +/// Keep the newest legacy backend backups and remove older alpha-era deploy artifacts. +pub(super) async fn clean_legacy_backend_backups(keep: usize) -> Result { + clean_named_backups_in( + Path::new("/usr/local/bin"), + keep, + |name| name.starts_with("archipelago.bak") || name.starts_with("archipelago.before-"), + false, + ) + .await +} + +/// Keep the newest web UI rollback backups and remove older copies. +pub(super) async fn clean_web_ui_backups(keep: usize) -> Result { + clean_named_backups_in( + Path::new("/opt/archipelago"), + keep, + |name| name.starts_with("web-ui.bak") || name == "web-ui.old", + true, + ) + .await +} + +async fn clean_backend_backups_in(dir: &Path, keep: usize) -> Result { + let mut backups = backend_backup_candidates(dir).await?; + remove_old_backups(&mut backups, keep, false).await +} + +async fn clean_named_backups_in( + dir: &Path, + keep: usize, + matches_name: impl Fn(&str) -> bool, + allow_dirs: bool, +) -> Result { + let mut backups = named_backup_candidates(dir, matches_name, allow_dirs).await?; + remove_old_backups(&mut backups, keep, allow_dirs).await +} + +async fn remove_old_backups( + backups: &mut Vec, + keep: usize, + allow_dirs: bool, +) -> Result { + backups.sort_by(|a, b| { + b.modified + .cmp(&a.modified) + .then_with(|| b.name.cmp(&a.name)) + }); + + let mut freed = 0u64; + for backup in backups.iter().skip(keep) { + let remove_result = if backup.is_dir && allow_dirs { + tokio::fs::remove_dir_all(&backup.path).await + } else { + tokio::fs::remove_file(&backup.path).await + }; + match remove_result { + Ok(()) => freed += backup.size, + Err(_) => { + remove_path_with_sudo(&backup.path, backup.is_dir && allow_dirs).await?; + freed += backup.size; + } + } + } + Ok(freed) +} + +async fn remove_path_with_sudo(path: &Path, recursive: bool) -> Result<()> { + let path = path.to_string_lossy(); + let args = if recursive { + vec!["rm", "-rf", path.as_ref()] + } else { + vec!["rm", "-f", path.as_ref()] + }; + let status = host_sudo(&args) + .await + .with_context(|| format!("removing {path} via sudo"))?; + if !status.success() { + anyhow::bail!( + "sudo rm {} {path} exited with {status}", + if recursive { "-rf" } else { "-f" } + ); + } + Ok(()) +} + +#[derive(Debug)] +struct BackupArtifact { + path: PathBuf, + name: String, + modified: SystemTime, + size: u64, + is_dir: bool, +} + +async fn backend_backup_candidates(dir: &Path) -> Result> { + named_backup_candidates( + dir, + |name| { + name.strip_prefix("archipelago.backup-") + .is_some_and(|suffix| !suffix.is_empty() && !suffix.contains('/')) + }, + false, + ) + .await +} + +async fn named_backup_candidates( + dir: &Path, + matches_name: impl Fn(&str) -> bool, + allow_dirs: bool, +) -> Result> { + let mut backups = Vec::new(); + let mut entries = match tokio::fs::read_dir(dir).await { + Ok(entries) => entries, + Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(backups), + Err(e) => return Err(e).with_context(|| format!("reading {}", dir.display())), + }; + + while let Some(entry) = entries.next_entry().await? { + let file_name = entry.file_name(); + let name = file_name.to_string_lossy(); + if !matches_name(&name) { + continue; + } + + let meta = entry.metadata().await?; + if !meta.is_file() && !(allow_dirs && meta.is_dir()) { + continue; + } + + backups.push(BackupArtifact { + path: entry.path(), + name: name.to_string(), + modified: meta.modified().unwrap_or(SystemTime::UNIX_EPOCH), + size: path_size(&entry.path(), &meta).await.unwrap_or(meta.len()), + is_dir: meta.is_dir(), + }); + } + Ok(backups) +} + +async fn path_size(path: &Path, meta: &std::fs::Metadata) -> Result { + if meta.is_file() { + return Ok(meta.len()); + } + if !meta.is_dir() { + return Ok(0); + } + + let output = tokio::process::Command::new("du") + .args(["-sb", &path.to_string_lossy()]) + .output() + .await + .with_context(|| format!("du -sb {}", path.display()))?; + if !output.status.success() { + anyhow::bail!("du -sb {} failed", path.display()); + } + let stdout = String::from_utf8_lossy(&output.stdout); + stdout + .split_whitespace() + .next() + .ok_or_else(|| anyhow::anyhow!("du output missing size for {}", path.display()))? + .parse::() + .with_context(|| format!("parse du size for {}", path.display())) +} + pub(super) fn format_bytes(bytes: u64) -> String { const KB: u64 = 1024; const MB: u64 = KB * 1024; @@ -422,6 +624,103 @@ pub(super) fn format_bytes(bytes: u64) -> String { } } +#[cfg(test)] +mod tests { + use super::*; + + #[tokio::test] + async fn backend_backup_cleanup_keeps_newest_files() { + let dir = tempfile::tempdir().unwrap(); + for name in [ + "archipelago.backup-20260501", + "archipelago.backup-20260502", + "archipelago.backup-20260503", + "archipelago.backup-20260504", + "archipelago.backup-20260505", + "archipelago.bak", + "archipelago", + ] { + tokio::fs::write(dir.path().join(name), b"12345") + .await + .unwrap(); + } + + let freed = clean_backend_backups_in(dir.path(), 3).await.unwrap(); + + assert_eq!(freed, 10); + assert!(!dir.path().join("archipelago.backup-20260501").exists()); + assert!(!dir.path().join("archipelago.backup-20260502").exists()); + assert!(dir.path().join("archipelago.backup-20260503").exists()); + assert!(dir.path().join("archipelago.backup-20260504").exists()); + assert!(dir.path().join("archipelago.backup-20260505").exists()); + assert!(dir.path().join("archipelago.bak").exists()); + assert!(dir.path().join("archipelago").exists()); + } + + #[tokio::test] + async fn legacy_backend_backup_cleanup_keeps_newest_matching_files() { + let dir = tempfile::tempdir().unwrap(); + for name in [ + "archipelago.bak-1", + "archipelago.bak-2", + "archipelago.before-3", + "archipelago.backup-keep-separate", + "archipelago", + ] { + tokio::fs::write(dir.path().join(name), b"12345") + .await + .unwrap(); + } + + let freed = clean_named_backups_in( + dir.path(), + 1, + |name| name.starts_with("archipelago.bak") || name.starts_with("archipelago.before-"), + false, + ) + .await + .unwrap(); + + assert_eq!(freed, 10); + assert_eq!( + [ + "archipelago.bak-1", + "archipelago.bak-2", + "archipelago.before-3" + ] + .into_iter() + .filter(|name| dir.path().join(name).exists()) + .count(), + 1 + ); + assert!(dir.path().join("archipelago.backup-keep-separate").exists()); + assert!(dir.path().join("archipelago").exists()); + } + + #[test] + fn hostname_from_server_name_derives_linux_safe_hostname() { + assert_eq!( + handlers::hostname_from_server_name("My Archipelago Node"), + "my-archipelago-node" + ); + assert_eq!( + handlers::hostname_from_server_name("Kitchen_Node!! 01"), + "kitchen-node-01" + ); + assert_eq!(handlers::hostname_from_server_name("!!!"), "archipelago"); + } + + #[test] + fn parses_journal_disk_usage() { + assert_eq!( + parse_journal_disk_usage( + "Archived and active journals take up 463.9M in the file system." + ), + Some(486_434_406) + ); + } +} + /// Read temperatures from /sys/class/thermal/thermal_zone*/temp. pub(super) async fn read_temperatures() -> Result> { let mut temps = Vec::new(); diff --git a/core/archipelago/src/auth.rs b/core/archipelago/src/auth.rs index 12f71f9a..ce7f51cc 100644 --- a/core/archipelago/src/auth.rs +++ b/core/archipelago/src/auth.rs @@ -86,6 +86,11 @@ pub struct AuthManager { data_dir: PathBuf, } +pub struct ChangePasswordOutcome { + pub ssh_updated: bool, + pub ssh_error: Option, +} + impl AuthManager { pub fn new(data_dir: PathBuf) -> Self { Self { data_dir } @@ -288,7 +293,7 @@ impl AuthManager { current_password: &str, new_password: &str, also_change_ssh: bool, - ) -> Result<()> { + ) -> Result { if !self.verify_password(current_password).await? { anyhow::bail!("Current password is incorrect"); } @@ -314,11 +319,21 @@ impl AuthManager { let content = serde_json::to_string_pretty(&user)?; fs::write(&user_file, content).await?; + let mut outcome = ChangePasswordOutcome { + ssh_updated: false, + ssh_error: None, + }; if also_change_ssh { - change_ssh_password(new_password).await?; + match change_ssh_password(new_password).await { + Ok(()) => outcome.ssh_updated = true, + Err(e) => { + tracing::warn!("Web password changed but SSH password update failed: {}", e); + outcome.ssh_error = Some(e.to_string()); + } + } } - Ok(()) + Ok(outcome) } } @@ -485,6 +500,23 @@ mod tests { assert!(validate_password_strength("MyP@ssw0rd!123").is_ok()); } + #[tokio::test] + async fn test_change_password_updates_web_password_without_ssh() { + let dir = tempfile::tempdir().unwrap(); + let auth = AuthManager::new(dir.path().to_path_buf()); + auth.setup_user("password123").await.unwrap(); + + let outcome = auth + .change_password("password123", "MyP@ssw0rd!123", false) + .await + .unwrap(); + + assert!(!outcome.ssh_updated); + assert!(outcome.ssh_error.is_none()); + assert!(auth.verify_password("MyP@ssw0rd!123").await.unwrap()); + assert!(!auth.verify_password("password123").await.unwrap()); + } + #[test] fn test_validate_password_strength_too_short() { assert!(validate_password_strength("Ab1!").is_err()); diff --git a/core/archipelago/src/bitcoin_status.rs b/core/archipelago/src/bitcoin_status.rs index c0e16107..1a67cdad 100644 --- a/core/archipelago/src/bitcoin_status.rs +++ b/core/archipelago/src/bitcoin_status.rs @@ -13,7 +13,8 @@ use std::time::{Duration, SystemTime, UNIX_EPOCH}; use tokio::sync::RwLock; use tracing::{debug, warn}; -const CACHE_REFRESH_SECS: u64 = 5; +const CACHE_REFRESH_SECS: u64 = 10; +const CACHE_ERROR_BACKOFF_SECS: u64 = 15; #[derive(Debug, Clone, Serialize)] pub struct BitcoinNodeStatus { @@ -65,6 +66,36 @@ fn transient_error(err_msg: &str) -> bool { || lower.contains("broken pipe") || lower.contains("eof") || lower.contains("500 internal server error") + || lower.contains("503 service unavailable") + || lower.contains("work queue depth exceeded") + || lower.contains("decode bitcoin rpc json") + || lower.contains("error decoding response body") + || lower.contains("expected value at line 1 column 1") +} + +fn friendly_transient_error(has_cached_state: bool, err_msg: &str) -> String { + let detail = err_msg + .lines() + .next() + .unwrap_or(err_msg) + .trim() + .trim_end_matches('.'); + let lower = detail.to_lowercase(); + let state = if lower.contains("verifying blocks") { + "verifying blocks after restart" + } else if lower.contains("connection refused") || lower.contains("tcp connect error") { + "waiting for the Bitcoin RPC listener" + } else if lower.contains("timed out") || lower.contains("timeout") { + "busy and not answering RPC before the timeout" + } else { + "starting or busy syncing" + }; + + if has_cached_state { + format!("Bitcoin node is {state}; showing last known state and retrying. Detail: {detail}") + } else { + format!("Bitcoin node is {state}; retrying automatically. Detail: {detail}") + } } pub fn spawn_status_cache() { @@ -72,6 +103,7 @@ pub fn spawn_status_cache() { loop { let fresh = fetch_bitcoin_status().await; let mut cached = cache().write().await; + let mut sleep_secs = CACHE_REFRESH_SECS; match fresh { Ok(mut status) => { status.ok = true; @@ -80,33 +112,31 @@ pub fn spawn_status_cache() { *cached = status; } Err(e) => { - let err_msg = e.to_string(); + let err_msg = format!("{e:#}"); if transient_error(&err_msg) { debug!("Bitcoin status: transient RPC failure: {}", err_msg); } else { warn!("Bitcoin status: RPC failure: {}", err_msg); } + sleep_secs = CACHE_ERROR_BACKOFF_SECS; if cached.blockchain_info.is_some() { cached.ok = false; cached.stale = true; - cached.error = Some(format!( - "Bitcoin node is reconnecting; showing last known state: {}", - err_msg - )); + cached.error = Some(friendly_transient_error(true, &err_msg)); } else { *cached = BitcoinNodeStatus { ok: false, stale: false, updated_at_ms: now_ms(), - error: Some(format!("Connecting to Bitcoin node: {}", err_msg)), + error: Some(friendly_transient_error(false, &err_msg)), ..BitcoinNodeStatus::default() }; } } } drop(cached); - tokio::time::sleep(Duration::from_secs(CACHE_REFRESH_SECS)).await; + tokio::time::sleep(Duration::from_secs(sleep_secs)).await; } }); } @@ -117,7 +147,7 @@ pub async fn get_bitcoin_status() -> BitcoinNodeStatus { async fn fetch_bitcoin_status() -> Result { let client = reqwest::Client::builder() - .timeout(Duration::from_secs(8)) + .timeout(Duration::from_secs(20)) .build() .context("build Bitcoin status HTTP client")?; @@ -183,3 +213,40 @@ async fn bitcoin_rpc_call( .cloned() .context("missing Bitcoin RPC result") } + +#[cfg(test)] +mod tests { + use super::friendly_transient_error; + + #[test] + fn explains_verifying_blocks_without_generic_timeout_copy() { + let msg = friendly_transient_error( + false, + r#"getblockchaininfo: Bitcoin RPC returned 500 Internal Server Error: {"error":{"code":-28,"message":"Verifying blocks..."}}"#, + ); + + assert!(msg.contains("verifying blocks after restart")); + assert!(msg.contains("retrying automatically")); + } + + #[test] + fn explains_missing_rpc_listener() { + let msg = friendly_transient_error( + true, + "getblockchaininfo: tcp connect error: Connection refused (os error 111)", + ); + + assert!(msg.contains("waiting for the Bitcoin RPC listener")); + assert!(msg.contains("showing last known state")); + } + + #[test] + fn explains_rpc_timeout() { + let msg = friendly_transient_error( + false, + "getblockchaininfo: Bitcoin RPC request failed: operation timed out", + ); + + assert!(msg.contains("busy and not answering RPC before the timeout")); + } +} diff --git a/core/archipelago/src/container/bitcoin_ui_nginx.conf.template b/core/archipelago/src/container/bitcoin_ui_nginx.conf.template index 7ab57dd8..43ad2ee6 100644 --- a/core/archipelago/src/container/bitcoin_ui_nginx.conf.template +++ b/core/archipelago/src/container/bitcoin_ui_nginx.conf.template @@ -23,5 +23,15 @@ server { proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; add_header Cache-Control "no-store"; } + location /rpc/v1 { + proxy_pass http://127.0.0.1:5678/rpc/v1; + proxy_http_version 1.1; + proxy_set_header Host $host; + proxy_set_header Cookie $http_cookie; + proxy_set_header X-CSRF-Token $http_x_csrf_token; + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + add_header Cache-Control "no-store"; + } location / { try_files $uri $uri/ /index.html; } } diff --git a/core/archipelago/src/container/boot_reconciler.rs b/core/archipelago/src/container/boot_reconciler.rs index 264a86d0..d52bd3ed 100644 --- a/core/archipelago/src/container/boot_reconciler.rs +++ b/core/archipelago/src/container/boot_reconciler.rs @@ -34,6 +34,7 @@ pub struct BootReconciler { /// `systemctl --user` and `podman`, which both block real time /// and would race the paused-clock test fixtures. companion_stage: bool, + wait_for_recovery: bool, } impl BootReconciler { @@ -47,6 +48,7 @@ impl BootReconciler { interval, shutdown, companion_stage: true, + wait_for_recovery: true, } } @@ -56,6 +58,7 @@ impl BootReconciler { #[cfg(test)] pub fn without_companion_stage(mut self) -> Self { self.companion_stage = false; + self.wait_for_recovery = false; self } @@ -78,6 +81,21 @@ impl BootReconciler { /// by the orchestrator, and companion failures are logged but never /// propagated. pub async fn run_forever(self) { + let wait_start = Instant::now(); + while self.wait_for_recovery && !crate::crash_recovery::is_recovery_complete() { + if wait_start.elapsed() > Duration::from_secs(1800) { + tracing::warn!("boot reconciler: boot recovery did not complete within 30 minutes, starting anyway"); + break; + } + tokio::select! { + _ = time::sleep(Duration::from_secs(5)) => {} + _ = self.shutdown.notified() => { + tracing::info!("boot reconciler: shutdown requested before recovery completed"); + return; + } + } + } + // Initial pass: no delay. self.tick().await; @@ -244,58 +262,65 @@ mod tests { ProdContainerOrchestrator::with_runtime(rt, PathBuf::from("/nonexistent-for-tests")); let tmp = tempfile::tempdir().unwrap().keep(); orch.set_data_dir(tmp); + orch.set_disk_gb_for_test(2_000); let orch = Arc::new(orch); orch.insert_manifest_for_test( - pull_manifest("bitcoin-knots", "docker.io/bitcoin/knots:28"), - PathBuf::from("/tmp/bk"), + pull_manifest("test-app", "docker.io/example/test-app:1"), + PathBuf::from("/tmp/test-app"), ) .await; orch } - #[tokio::test(start_paused = true)] + async fn wait_for_status_calls(rt: &CountingRuntime, expected: u32) -> u32 { + for _ in 0..100 { + let count = rt.status_call_count(); + if count >= expected { + return count; + } + tokio::task::yield_now().await; + tokio::time::sleep(Duration::from_millis(1)).await; + } + rt.status_call_count() + } + + #[tokio::test] async fn initial_pass_fires_immediately() { - let rt = Arc::new(CountingRuntime::new_with(&["bitcoin-knots"])); + let rt = Arc::new(CountingRuntime::new_with(&["test-app"])); let orch = orch_with_one_running_manifest(rt.clone()).await; let shutdown = Arc::new(Notify::new()); let reconciler = - BootReconciler::new(orch.clone(), Duration::from_secs(30), shutdown.clone()) + BootReconciler::new(orch.clone(), Duration::from_millis(50), shutdown.clone()) .without_companion_stage(); let handle = tokio::spawn(reconciler.run_forever()); - // Yield so the spawned task gets CPU to run its initial reconcile. - tokio::task::yield_now().await; - tokio::task::yield_now().await; - // We expect exactly one reconcile pass to have run by now (the initial), // NOT a second one (the 30s sleep hasn't elapsed in paused time). - assert_eq!(rt.status_call_count(), 1, "initial pass should fire once"); + assert_eq!( + wait_for_status_calls(&rt, 1).await, + 1, + "initial pass should fire once" + ); shutdown.notify_one(); - // Under paused clock the select! is blocked on sleep_until; the notify - // will unblock it. Advance wall-clock a hair so the notify gets polled. tokio::task::yield_now().await; let _ = tokio::time::timeout(Duration::from_secs(1), handle).await; } - #[tokio::test(start_paused = true)] + #[tokio::test] async fn second_pass_fires_after_interval() { - let rt = Arc::new(CountingRuntime::new_with(&["bitcoin-knots"])); + let rt = Arc::new(CountingRuntime::new_with(&["test-app"])); let orch = orch_with_one_running_manifest(rt.clone()).await; let shutdown = Arc::new(Notify::new()); let reconciler = - BootReconciler::new(orch.clone(), Duration::from_secs(30), shutdown.clone()) + BootReconciler::new(orch.clone(), Duration::from_millis(10), shutdown.clone()) .without_companion_stage(); let handle = tokio::spawn(reconciler.run_forever()); - tokio::task::yield_now().await; - tokio::task::yield_now().await; - assert_eq!(rt.status_call_count(), 1); + assert_eq!(wait_for_status_calls(&rt, 1).await, 1); - // Fast-forward past one interval; the sleep_until should fire. - tokio::time::advance(Duration::from_secs(31)).await; - tokio::task::yield_now().await; - tokio::task::yield_now().await; + tokio::time::sleep(Duration::from_millis(20)).await; + wait_for_status_calls(&rt, 2).await; assert_eq!( rt.status_call_count(), @@ -308,27 +333,23 @@ mod tests { let _ = tokio::time::timeout(Duration::from_secs(1), handle).await; } - #[tokio::test(start_paused = true)] + #[tokio::test] async fn shutdown_terminates_loop() { - let rt = Arc::new(CountingRuntime::new_with(&["bitcoin-knots"])); + let rt = Arc::new(CountingRuntime::new_with(&["test-app"])); let orch = orch_with_one_running_manifest(rt.clone()).await; let shutdown = Arc::new(Notify::new()); let reconciler = - BootReconciler::new(orch.clone(), Duration::from_secs(30), shutdown.clone()) + BootReconciler::new(orch.clone(), Duration::from_millis(50), shutdown.clone()) .without_companion_stage(); let handle = tokio::spawn(reconciler.run_forever()); - tokio::task::yield_now().await; - tokio::task::yield_now().await; + wait_for_status_calls(&rt, 1).await; shutdown.notify_one(); - // The select! should wake on Notified and return. Use a real timeout - // with advancing the paused clock to make sure the task exits. - tokio::time::advance(Duration::from_millis(10)).await; let result = tokio::time::timeout(Duration::from_secs(5), handle).await; assert!(result.is_ok(), "reconciler did not exit after shutdown"); } - #[tokio::test(start_paused = true)] + #[tokio::test] async fn failure_in_one_pass_does_not_stop_loop() { // Manifest references a container the runtime does not have AND // cannot create (no install path — install_fresh will also fail to @@ -344,26 +365,23 @@ mod tests { ); let tmp = tempfile::tempdir().unwrap().keep(); orch.set_data_dir(tmp); + orch.set_disk_gb_for_test(2_000); let orch = Arc::new(orch); orch.insert_manifest_for_test( - pull_manifest("bitcoin-knots", "docker.io/bitcoin/knots:28"), - PathBuf::from("/tmp/bk"), + pull_manifest("test-app", "docker.io/example/test-app:1"), + PathBuf::from("/tmp/test-app"), ) .await; let shutdown = Arc::new(Notify::new()); let reconciler = - BootReconciler::new(orch.clone(), Duration::from_secs(30), shutdown.clone()) + BootReconciler::new(orch.clone(), Duration::from_millis(10), shutdown.clone()) .without_companion_stage(); let handle = tokio::spawn(reconciler.run_forever()); - tokio::task::yield_now().await; - tokio::task::yield_now().await; - let first = rt.status_call_count(); + let first = wait_for_status_calls(&rt, 1).await; assert!(first >= 1, "initial pass should have touched the runtime"); - // Advance one interval — second pass should fire regardless of what - // the first pass did. - tokio::time::advance(Duration::from_secs(31)).await; + tokio::time::sleep(Duration::from_millis(20)).await; tokio::task::yield_now().await; tokio::task::yield_now().await; let second = rt.status_call_count(); @@ -373,7 +391,6 @@ mod tests { ); shutdown.notify_one(); - tokio::time::advance(Duration::from_millis(10)).await; let _ = tokio::time::timeout(Duration::from_secs(5), handle).await; } } diff --git a/core/archipelago/src/container/companion.rs b/core/archipelago/src/container/companion.rs index 5cca19e0..144505ca 100644 --- a/core/archipelago/src/container/companion.rs +++ b/core/archipelago/src/container/companion.rs @@ -9,6 +9,7 @@ //! | bitcoin-core | archy-bitcoin-ui | RPC viewer | //! | lnd | archy-lnd-ui | wallet/channel UI | //! | electrumx | archy-electrs-ui | indexer status UI | +//! | fedimint | archy-fedimint-ui | wait/proxy Guardian UI | //! //! Lifecycle: `install` writes a Quadlet `.container` unit to //! `~/.config/containers/systemd/`, daemon-reloads, then starts the @@ -22,6 +23,7 @@ use anyhow::{Context, Result}; use std::path::PathBuf; +use std::time::Duration; use tokio::fs; use tokio::process::Command; use tracing::{info, warn}; @@ -30,6 +32,9 @@ use crate::container::quadlet::{self, BindMount, NetworkMode, QuadletUnit}; use archipelago_container::image_uses_insecure_registry; const COMPANION_REGISTRY: &str = "146.59.87.168:3000/lfg2025"; +const COMPANION_IMAGE_CHECK_TIMEOUT: Duration = Duration::from_secs(15); +const COMPANION_BUILD_TIMEOUT: Duration = Duration::from_secs(900); +const COMPANION_PULL_TIMEOUT: Duration = Duration::from_secs(300); /// Static description of one companion. The full list per backend /// app_id lives in `companions_for`. @@ -65,6 +70,7 @@ pub fn companions_for(package_id: &str) -> &'static [CompanionSpec] { "bitcoin" | "bitcoin-core" | "bitcoin-knots" => BITCOIN_UI, "lnd" => LND_UI, "electrumx" | "electrs" | "mempool-electrs" => ELECTRS_UI, + "fedimint" | "fedimintd" => FEDIMINT_UI, _ => &[], } } @@ -114,6 +120,20 @@ const ELECTRS_UI: &[CompanionSpec] = &[CompanionSpec { host_network: true, }]; +const FEDIMINT_UI: &[CompanionSpec] = &[CompanionSpec { + name: "archy-fedimint-ui", + image_base: "fedimint-ui", + build_dir_candidates: &[ + "/opt/archipelago/docker/fedimint-ui", + "/home/archipelago/archy/docker/fedimint-ui", + "/home/archipelago/Projects/archy/docker/fedimint-ui", + ], + pre_start: None, + bind_mounts: &[], + ports: &[], + host_network: true, +}]; + fn render_bitcoin_ui() -> futures_util::future::BoxFuture<'static, Result<()>> { Box::pin(async { let paths = crate::container::bitcoin_ui::RenderPaths::default(); @@ -201,11 +221,12 @@ async fn ensure_image_present(spec: &CompanionSpec) -> Result { return Ok(local_image); } info!(companion = spec.name, "building locally from {dir}"); - let out = Command::new("podman") - .args(["build", "-t", &local_image, dir]) - .output() - .await - .context("spawn podman build")?; + let out = command_output_with_timeout( + Command::new("podman").args(["build", "-t", &local_image, dir]), + COMPANION_BUILD_TIMEOUT, + "podman build companion image", + ) + .await?; if out.status.success() { return Ok(local_image); } @@ -226,7 +247,12 @@ async fn ensure_image_present(spec: &CompanionSpec) -> Result { cmd.arg("--tls-verify=false"); } cmd.arg(®istry_image); - let out = cmd.output().await.context("spawn podman pull")?; + let out = command_output_with_timeout( + &mut cmd, + COMPANION_PULL_TIMEOUT, + "podman pull companion image", + ) + .await?; if !out.status.success() { anyhow::bail!( "no local Dockerfile and registry pull failed for {}: {}", @@ -238,11 +264,31 @@ async fn ensure_image_present(spec: &CompanionSpec) -> Result { } async fn image_exists(image: &str) -> bool { - Command::new("podman") - .args(["image", "exists", image]) - .status() + let mut cmd = Command::new("podman"); + cmd.args(["image", "inspect", image]); + match tokio::time::timeout(COMPANION_IMAGE_CHECK_TIMEOUT, cmd.status()).await { + Ok(Ok(status)) => status.success(), + Ok(Err(err)) => { + warn!(image = %image, error = %err, "companion image existence check failed"); + false + } + Err(_) => { + warn!(image = %image, "companion image existence check timed out"); + false + } + } +} + +async fn command_output_with_timeout( + cmd: &mut Command, + timeout: Duration, + description: &str, +) -> Result { + cmd.kill_on_drop(true); + tokio::time::timeout(timeout, cmd.output()) .await - .is_ok_and(|status| status.success()) + .with_context(|| format!("{description} timed out after {}s", timeout.as_secs()))? + .with_context(|| format!("spawn {description}")) } fn build_unit(spec: &CompanionSpec, image: &str) -> QuadletUnit { @@ -368,6 +414,8 @@ mod tests { assert_eq!(companions_for("electrumx").len(), 1); assert_eq!(companions_for("electrs").len(), 1); assert_eq!(companions_for("mempool-electrs").len(), 1); + assert_eq!(companions_for("fedimint").len(), 1); + assert_eq!(companions_for("fedimintd").len(), 1); assert_eq!(companions_for("nextcloud").len(), 0); assert_eq!(companions_for("not-a-real-app").len(), 0); } @@ -398,4 +446,13 @@ mod tests { assert!(matches!(u.network, NetworkMode::Bridge(ref n) if n == "bridge")); assert_eq!(u.ports, vec![(18083, 80, "tcp".into())]); } + + #[test] + fn fedimint_ui_uses_host_network_for_public_guardian_port() { + let spec = &FEDIMINT_UI[0]; + let u = build_unit(spec, "localhost/fedimint-ui:latest"); + assert_eq!(u.name, "archy-fedimint-ui"); + assert!(matches!(u.network, NetworkMode::Host)); + assert!(u.ports.is_empty()); + } } diff --git a/core/archipelago/src/container/docker_packages.rs b/core/archipelago/src/container/docker_packages.rs index 1c161c98..97dfbe03 100644 --- a/core/archipelago/src/container/docker_packages.rs +++ b/core/archipelago/src/container/docker_packages.rs @@ -26,13 +26,7 @@ impl DockerPackageScanner { /// Scan Docker containers and convert to package data pub async fn scan_containers(&self) -> Result> { - let containers = match self.runtime.list_containers().await { - Ok(c) => c, - Err(e) => { - debug!("Failed to list containers: {}", e); - return Ok(HashMap::new()); - } - }; + let containers = self.runtime.list_containers().await?; debug!("Found {} containers", containers.len()); @@ -63,14 +57,6 @@ impl DockerPackageScanner { "indeedhub-build_ffmpeg-worker_1", "netbird-server", "netbird-dashboard", - "saleor-api", - "saleor-worker", - "saleor-db", - "saleor-cache", - "saleor-jaeger", - "saleor-mailpit", - "saleor-storefront", - "saleor-storefront-app", "buildx_buildkit_default", ]; @@ -298,7 +284,6 @@ fn get_app_tier(app_id: &str) -> &'static str { "uptime-kuma" => "recommended", "grafana" => "recommended", "searxng" => "recommended", - "saleor" => "recommended", "tailscale" | "netbird" => "recommended", "portainer" => "recommended", // Optional: everything else @@ -519,13 +504,6 @@ fn get_app_metadata(app_id: &str) -> AppMetadata { repo: "https://github.com/netbirdio/netbird".to_string(), tier: "", }, - "saleor" => AppMetadata { - title: "Saleor".to_string(), - description: "Composable commerce platform with storefront, dashboard, and GraphQL API. The customer storefront opens on port 9011; admin dashboard is on 9010 with admin@example.com credentials stored on the node.".to_string(), - icon: "/assets/img/app-icons/saleor.svg".to_string(), - repo: "https://github.com/saleor/saleor".to_string(), - tier: "", - }, "gitea" => AppMetadata { title: "Gitea".to_string(), description: "Self-hosted Git service with repository and package hosting".to_string(), @@ -732,20 +710,25 @@ async fn reachable_lan_address(app_id: &str, candidate: Option) -> Optio let Some(port) = url.rsplit(':').next().and_then(|p| p.parse::().ok()) else { return None; }; - match tokio::time::timeout( - std::time::Duration::from_secs(2), - tokio::net::TcpStream::connect(("127.0.0.1", port)), - ) - .await - { - Ok(Ok(_)) => Some(url), - _ => { - debug!(app_id = %app_id, port, "suppressing unreachable launch URL"); - None - } + if launch_port_reachable(port).await { + Some(url) + } else { + debug!(app_id = %app_id, port, "suppressing unreachable launch URL"); + None } } +async fn launch_port_reachable(port: u16) -> bool { + matches!( + tokio::time::timeout( + std::time::Duration::from_secs(2), + tokio::net::TcpStream::connect(("127.0.0.1", port)), + ) + .await, + Ok(Ok(_)) + ) +} + fn requires_reachable_launch(app_id: &str) -> bool { matches!( app_id, @@ -766,7 +749,6 @@ fn requires_reachable_launch(app_id: &str) -> bool { | "tailscale" | "immich" | "searxng" - | "saleor" ) } diff --git a/core/archipelago/src/container/filebrowser.rs b/core/archipelago/src/container/filebrowser.rs index 8501699d..e51b11fe 100644 --- a/core/archipelago/src/container/filebrowser.rs +++ b/core/archipelago/src/container/filebrowser.rs @@ -8,6 +8,8 @@ use anyhow::{Context, Result}; use std::path::PathBuf; use tokio::fs; +use crate::update::host_sudo; + pub const DEFAULT_SRV_ROOT: &str = "/var/lib/archipelago/filebrowser"; pub const DEFAULT_DATA_DIR: &str = "/var/lib/archipelago/filebrowser-data"; pub const DEFAULT_CONFIG_PATH: &str = "/var/lib/archipelago/filebrowser-data/.filebrowser.json"; @@ -39,17 +41,11 @@ pub enum EnsureOutcome { } pub async fn ensure_config(paths: &EnsurePaths) -> Result { - fs::create_dir_all(&paths.srv_root) - .await - .with_context(|| format!("creating {}", paths.srv_root.display()))?; - fs::create_dir_all(&paths.data_dir) - .await - .with_context(|| format!("creating {}", paths.data_dir.display()))?; + create_dir_all_or_sudo(&paths.srv_root).await?; + create_dir_all_or_sudo(&paths.data_dir).await?; for d in ["Documents", "Photos", "Music", "Downloads", "Builds"] { - fs::create_dir_all(paths.srv_root.join(d)) - .await - .with_context(|| format!("creating {}/{}", paths.srv_root.display(), d))?; + create_dir_all_or_sudo(&paths.srv_root.join(d)).await?; } if paths.config_path.exists() { @@ -60,27 +56,67 @@ pub async fn ensure_config(paths: &EnsurePaths) -> Result { .config_path .parent() .ok_or_else(|| anyhow::anyhow!("config_path has no parent directory"))?; - fs::create_dir_all(parent) - .await - .with_context(|| format!("creating {}", parent.display()))?; + create_dir_all_or_sudo(parent).await?; - let tmp = paths.config_path.with_extension("tmp"); - fs::write(&tmp, DEFAULT_CONFIG_JSON) - .await - .with_context(|| format!("writing tmp {}", tmp.display()))?; - fs::rename(&tmp, &paths.config_path) - .await - .with_context(|| { - format!( - "renaming {} -> {}", - tmp.display(), - paths.config_path.display() - ) - })?; + write_config_atomically(paths).await?; Ok(EnsureOutcome::Written) } +async fn create_dir_all_or_sudo(path: &std::path::Path) -> Result<()> { + match fs::create_dir_all(path).await { + Ok(()) => Ok(()), + Err(e) if e.kind() == std::io::ErrorKind::PermissionDenied => { + let path = path.to_string_lossy(); + let status = host_sudo(&["mkdir", "-p", &path]) + .await + .with_context(|| format!("creating {path} via sudo"))?; + if !status.success() { + anyhow::bail!("mkdir -p {path} via sudo exited with {status}"); + } + Ok(()) + } + Err(e) => Err(e).with_context(|| format!("creating {}", path.display())), + } +} + +async fn write_config_atomically(paths: &EnsurePaths) -> Result<()> { + let tmp = paths.config_path.with_extension("tmp"); + match fs::write(&tmp, DEFAULT_CONFIG_JSON).await { + Ok(()) => { + fs::rename(&tmp, &paths.config_path) + .await + .with_context(|| { + format!( + "renaming {} -> {}", + tmp.display(), + paths.config_path.display() + ) + })?; + Ok(()) + } + Err(e) if e.kind() == std::io::ErrorKind::PermissionDenied => { + let script = format!( + "set -eu\ncat > '{}' <<'FILEBROWSERCONF'\n{}FILEBROWSERCONF\n", + shell_quote(&paths.config_path.to_string_lossy()), + DEFAULT_CONFIG_JSON + ); + let status = host_sudo(&["sh", "-lc", &script]) + .await + .context("writing .filebrowser.json via sudo")?; + if !status.success() { + anyhow::bail!("writing .filebrowser.json via sudo exited with {status}"); + } + Ok(()) + } + Err(e) => Err(e).with_context(|| format!("writing tmp {}", tmp.display())), + } +} + +fn shell_quote(s: &str) -> String { + s.replace('\'', "'\\''") +} + #[cfg(test)] mod tests { use super::*; diff --git a/core/archipelago/src/container/image_versions.rs b/core/archipelago/src/container/image_versions.rs index 7fd7828a..5d68f967 100644 --- a/core/archipelago/src/container/image_versions.rs +++ b/core/archipelago/src/container/image_versions.rs @@ -219,6 +219,10 @@ pub fn pinned_image_for_app(app_id: &str) -> Option { /// explicit versions we should advertise to users as available updates. pub fn available_update_for_app(app_id: &str, running_image: &str) -> Option { let pinned = pinned_image_for_app(app_id)?; + available_update_for_images(&pinned, running_image) +} + +fn available_update_for_images(pinned: &str, running_image: &str) -> Option { let pinned_version = extract_version_from_image(&pinned); if is_floating_tag(&pinned_version) { return None; @@ -378,6 +382,28 @@ mod tests { assert!(!is_floating_tag("v0.18.4-beta")); } + #[test] + fn available_update_ignores_registry_only_changes() { + assert_eq!( + available_update_for_images( + "146.59.87.168:3000/lfg2025/nextcloud:29", + "git.tx1138.com/lfg2025/nextcloud:29", + ), + None + ); + } + + #[test] + fn available_update_returns_pinned_version_for_same_repo_newer_tag() { + assert_eq!( + available_update_for_images( + "146.59.87.168:3000/lfg2025/nextcloud:29", + "146.59.87.168:3000/lfg2025/nextcloud:28", + ), + Some("29".to_string()) + ); + } + #[test] fn test_parse_image_versions() { let content = r#" diff --git a/core/archipelago/src/container/lnd.rs b/core/archipelago/src/container/lnd.rs index 22420099..98f84cb3 100644 --- a/core/archipelago/src/container/lnd.rs +++ b/core/archipelago/src/container/lnd.rs @@ -76,7 +76,7 @@ pub async fn ensure_wallet_initialized() -> Result<()> { let admin_macaroon = "/var/lib/archipelago/lnd/data/chain/bitcoin/mainnet/admin.macaroon"; let wallet_db = "/var/lib/archipelago/lnd/data/chain/bitcoin/mainnet/wallet.db"; if file_exists_as_root(wallet_db).await { - if file_exists_as_root(admin_macaroon).await && lnd_getinfo_ready(admin_macaroon).await { + if file_exists_as_root(admin_macaroon).await { return Ok(()); } unlock_existing_wallet().await?; @@ -305,6 +305,7 @@ async fn decode_lnd_unlocker_response Deserialize<'de>>( anyhow::bail!("LND REST {path} returned {status}: {text}") } +#[allow(dead_code)] async fn lnd_getinfo_ready(admin_macaroon: &str) -> bool { let Ok(macaroon) = read_file_as_root(admin_macaroon).await else { return false; diff --git a/core/archipelago/src/container/prod_orchestrator.rs b/core/archipelago/src/container/prod_orchestrator.rs index 3f109333..cf9cc70a 100644 --- a/core/archipelago/src/container/prod_orchestrator.rs +++ b/core/archipelago/src/container/prod_orchestrator.rs @@ -26,13 +26,15 @@ use anyhow::{Context, Result}; use archipelago_container::{ AppManifest, ContainerRuntime as ContainerRuntimeTrait, ContainerState, ContainerStatus, - HostFacts, ManifestError, ResolvedSource, SecretsProvider, + Dependency, GeneratedFile, HostFacts, ManifestError, ResolvedSource, SecretsProvider, }; use async_trait::async_trait; use std::collections::{HashMap, HashSet}; +use std::os::unix::fs::FileTypeExt; use std::path::{Path, PathBuf}; use std::process::Command; use std::sync::Arc; +use tokio::io::{AsyncReadExt, AsyncWriteExt}; use tokio::sync::{Mutex, RwLock}; use crate::config::{Config, ContainerRuntime as ConfigContainerRuntime}; @@ -48,6 +50,15 @@ use crate::update::host_sudo; /// so the rule is visible in one place and unit-testable. const UI_APP_IDS: &[&str] = &["bitcoin-ui", "electrs-ui", "lnd-ui"]; const ARCHIVAL_BITCOIN_DISK_GB: u64 = 1000; +const INDEEDHUB_BACKEND_CONTAINERS: &[&str] = &[ + "indeedhub-postgres", + "indeedhub-redis", + "indeedhub-minio", + "indeedhub-relay", + "indeedhub-api", + "indeedhub-ffmpeg", +]; +const INDEEDHUB_FRONTEND_READY_TIMEOUT_SECS: u64 = 90; fn is_required_baseline_app(app_id: &str) -> bool { matches!( @@ -75,6 +86,67 @@ fn is_restart_sensitive_app(app_id: &str) -> bool { ) } +fn is_builtin_network_mode(network: &str) -> bool { + matches!( + network, + "host" | "bridge" | "none" | "slirp4netns" | "pasta" + ) +} + +fn uses_pasta_network(manifest: &AppManifest) -> bool { + manifest.app.container.network.as_deref() == Some("pasta") +} + +fn dependency_manifests_required_by_active_apps<'a>( + manifests: impl Iterator, + user_stopped: &HashSet, +) -> HashSet { + let mut required = HashSet::new(); + for manifest in manifests { + let app_id = manifest.app.id.as_str(); + if user_stopped.contains(app_id) || user_stopped.contains(&compute_container_name(manifest)) + { + continue; + } + for app_id in manifest_dependency_app_ids(manifest) { + required.insert(app_id); + } + } + required +} + +fn manifest_dependency_app_ids(manifest: &AppManifest) -> Vec { + manifest + .app + .dependencies + .iter() + .filter_map(|dep| match dep { + Dependency::App { app_id, .. } => Some(app_id.clone()), + Dependency::Simple(app_id) => Some(app_id.clone()), + Dependency::Storage { .. } => None, + }) + .collect() +} + +fn host_port_wait_timeout_secs(manifest: &AppManifest) -> u64 { + if manifest.app.id == "uptime-kuma" { + return 420; + } + if uses_pasta_network(manifest) { + 120 + } else { + 60 + } +} + +fn host_port_repair_probe_timeout_secs(_manifest: &AppManifest) -> u64 { + 5 +} + +fn is_podman_socket_bind_source(source: &str) -> bool { + source.ends_with("/podman.sock") +} + fn requires_archival_bitcoin(app_id: &str) -> bool { matches!( app_id, @@ -163,9 +235,57 @@ async fn wait_for_host_port(port: u16, timeout_secs: u64) -> bool { } } +async fn wait_for_http_host_port(port: u16, path: &str, timeout_secs: u64) -> bool { + let deadline = std::time::Instant::now() + std::time::Duration::from_secs(timeout_secs); + loop { + if http_host_port_ready(port, path).await { + return true; + } + if std::time::Instant::now() >= deadline { + return false; + } + tokio::time::sleep(std::time::Duration::from_secs(1)).await; + } +} + +async fn http_host_port_ready(port: u16, path: &str) -> bool { + let Ok(Ok(mut stream)) = tokio::time::timeout( + std::time::Duration::from_secs(3), + tokio::net::TcpStream::connect(("127.0.0.1", port)), + ) + .await + else { + return false; + }; + + let request = format!("GET {path} HTTP/1.1\r\nHost: 127.0.0.1\r\nConnection: close\r\n\r\n"); + if stream.write_all(request.as_bytes()).await.is_err() { + return false; + } + + let mut buf = [0u8; 128]; + let Ok(Ok(n)) = + tokio::time::timeout(std::time::Duration::from_secs(3), stream.read(&mut buf)).await + else { + return false; + }; + if n == 0 { + return false; + } + let head = String::from_utf8_lossy(&buf[..n]); + head.starts_with("HTTP/1.1 2") + || head.starts_with("HTTP/1.1 3") + || head.starts_with("HTTP/1.0 2") + || head.starts_with("HTTP/1.0 3") +} + async fn wait_for_manifest_host_ports(manifest: &AppManifest, timeout_secs: u64) -> Result<()> { for port in manifest.app.ports.iter().map(|p| p.host) { - if !wait_for_host_port(port, timeout_secs).await { + let ready = match manifest.app.id.as_str() { + "uptime-kuma" => wait_for_http_host_port(port, "/", timeout_secs).await, + _ => wait_for_host_port(port, timeout_secs).await, + }; + if !ready { return Err(anyhow::anyhow!( "{} host port {} did not become reachable within {}s", manifest.app.id, @@ -177,6 +297,245 @@ async fn wait_for_manifest_host_ports(manifest: &AppManifest, timeout_secs: u64) Ok(()) } +async fn ensure_user_podman_socket() -> Result<()> { + let socket_path = "/run/user/1000/podman/podman.sock"; + if podman_socket_accepts_connections(socket_path).await { + return Ok(()); + } + + let _ = tokio::process::Command::new("systemctl") + .args([ + "--user", + "stop", + "podman-archy-api.service", + "podman.socket", + "podman.service", + ]) + .status() + .await; + + remove_stale_podman_socket_path(socket_path).await; + + let _ = tokio::process::Command::new("systemctl") + .args([ + "--user", + "reset-failed", + "podman-archy-api.service", + "podman.socket", + "podman.service", + ]) + .status() + .await; + + let service_status = tokio::process::Command::new("systemd-run") + .args([ + "--user", + "--unit", + "podman-archy-api", + "--collect", + "podman", + "system", + "service", + "--time=0", + "unix:///run/user/1000/podman/podman.sock", + ]) + .status() + .await + .context("spawn systemd-run podman-archy-api")?; + if !service_status.success() { + tracing::warn!(?service_status, "podman-archy-api service start failed"); + } + + for _ in 0..20 { + if podman_socket_accepts_connections(socket_path).await { + return Ok(()); + } + tokio::time::sleep(std::time::Duration::from_millis(250)).await; + } + + for args in [ + ["--user", "reset-failed", "podman.socket", "podman.service"].as_slice(), + ["--user", "start", "podman.socket"].as_slice(), + ] { + let status = tokio::process::Command::new("systemctl") + .args(args) + .status() + .await + .with_context(|| format!("spawn systemctl {}", args.join(" ")))?; + if !status.success() { + tracing::warn!(?status, command = %args.join(" "), "systemctl podman socket repair step failed"); + } + } + + for _ in 0..20 { + if podman_socket_accepts_connections(socket_path).await { + return Ok(()); + } + tokio::time::sleep(std::time::Duration::from_millis(250)).await; + } + + Err(anyhow::anyhow!( + "podman socket {socket_path} did not appear after restart" + )) +} + +async fn podman_socket_accepts_connections(socket_path: &str) -> bool { + if !tokio::fs::try_exists(socket_path).await.unwrap_or(false) { + return false; + } + matches!( + tokio::time::timeout( + std::time::Duration::from_secs(2), + tokio::net::UnixStream::connect(socket_path), + ) + .await, + Ok(Ok(_)) + ) +} + +async fn remove_stale_podman_socket_path(socket_path: &str) { + if podman_socket_accepts_connections(socket_path).await { + return; + } + let Ok(metadata) = tokio::fs::symlink_metadata(socket_path).await else { + return; + }; + let file_type = metadata.file_type(); + if file_type.is_socket() { + let _ = tokio::fs::remove_file(socket_path).await; + } else if file_type.is_dir() { + let _ = tokio::fs::remove_dir_all(socket_path).await; + } else { + let _ = tokio::fs::remove_file(socket_path).await; + } +} + +async fn wait_for_container_stable_running( + runtime: &dyn ContainerRuntimeTrait, + name: &str, + stable_secs: u64, + timeout_secs: u64, +) -> Result<()> { + let deadline = std::time::Instant::now() + std::time::Duration::from_secs(timeout_secs); + let mut running_since: Option = None; + let mut last_state: String; + + loop { + match runtime.get_container_status(name).await { + Ok(status) if matches!(status.state, ContainerState::Running) => { + let since = *running_since.get_or_insert_with(std::time::Instant::now); + if since.elapsed() >= std::time::Duration::from_secs(stable_secs) { + return Ok(()); + } + last_state = "running".to_string(); + } + Ok(status) => { + running_since = None; + last_state = format!("{:?}", status.state); + } + Err(err) => { + running_since = None; + last_state = err.to_string(); + } + } + + if std::time::Instant::now() >= deadline { + return Err(anyhow::anyhow!( + "{} did not remain running for {}s within {}s (last={})", + name, + stable_secs, + timeout_secs, + last_state + )); + } + + tokio::time::sleep(std::time::Duration::from_secs(1)).await; + } +} + +async fn repair_manifest_host_ports_after_stability( + runtime: &dyn ContainerRuntimeTrait, + manifest: &AppManifest, + name: &str, +) -> Result<()> { + tokio::time::sleep(std::time::Duration::from_secs(5)).await; + if wait_for_manifest_host_ports(manifest, 5).await.is_ok() { + return Ok(()); + } + + tracing::warn!( + app_id = %manifest.app.id, + container = %name, + "host listener disappeared after startup; restarting container" + ); + if uses_pasta_network(manifest) { + podman_user_scope(&["restart", name]) + .await + .with_context(|| format!("podman restart {name}"))?; + } else if let Err(err) = quadlet::restart_service(&format!("{name}.service")).await { + tracing::warn!( + app_id = %manifest.app.id, + container = %name, + error = %err, + "quadlet restart failed during host listener repair; falling back to podman restart" + ); + let _ = runtime.stop_container(name).await; + runtime + .start_container(name) + .await + .with_context(|| format!("restart container {name}"))?; + } + + wait_for_manifest_host_ports(manifest, host_port_wait_timeout_secs(manifest)).await?; + wait_for_container_stable_running(runtime, name, 15, 90).await +} + +async fn podman_user_scope(args: &[&str]) -> Result<()> { + let output = tokio::process::Command::new("systemd-run") + .args(["--user", "--scope", "--quiet", "--collect", "podman"]) + .args(args) + .output() + .await + .with_context(|| format!("systemd-run --user --scope podman {}", args.join(" ")))?; + if output.status.success() { + return Ok(()); + } + + Err(anyhow::anyhow!( + "systemd-run --user --scope podman {} failed: {}", + args.join(" "), + String::from_utf8_lossy(&output.stderr).trim() + )) +} + +async fn start_container_scoped_if_pasta( + runtime: &dyn ContainerRuntimeTrait, + manifest: &AppManifest, + name: &str, +) -> Result<()> { + if uses_pasta_network(manifest) { + // Rootless pasta/conmon inherit the cgroup of the process that starts + // them. Starting through archipelago.service lets backend restarts kill + // app networking; a transient user scope keeps app daemons independent. + podman_user_scope(&["start", name]).await + } else { + runtime.start_container(name).await + } +} + +async fn restart_container_scoped_if_pasta( + runtime: &dyn ContainerRuntimeTrait, + manifest: &AppManifest, + name: &str, +) -> Result<()> { + if uses_pasta_network(manifest) { + podman_user_scope(&["restart", name]).await + } else { + let _ = runtime.stop_container(name).await; + runtime.start_container(name).await + } +} + async fn patch_indeedhub_nostr_provider() { let _ = tokio::process::Command::new("podman") .args([ @@ -633,13 +992,18 @@ impl ProdContainerOrchestrator { let user_stopped = crate::crash_recovery::load_user_stopped(&self.data_dir).await; let manifests: Vec = { let state = self.state.read().await; + let dependency_required = dependency_manifests_required_by_active_apps( + state.manifests.values().map(|lm| &lm.manifest), + &user_stopped, + ); state .manifests .iter() .filter(|(app_id, _)| !state.disabled.contains(*app_id)) .filter(|(app_id, lm)| { - !user_stopped.contains(*app_id) - && !user_stopped.contains(&compute_container_name(&lm.manifest)) + dependency_required.contains(*app_id) + || (!user_stopped.contains(*app_id) + && !user_stopped.contains(&compute_container_name(&lm.manifest))) }) .map(|(_, lm)| lm.clone()) .collect() @@ -700,11 +1064,12 @@ impl ProdContainerOrchestrator { // after proving the container exists. Boot reconciliation must // not create every catalog app just because a Quadlet unit is // absent. - if self.use_quadlet_backends { + if self.use_quadlet_backends && !uses_pasta_network(&resolved_manifest) { if let Some(action) = self.migrate_to_quadlet_if_needed(lm, &name).await? { return Ok(action); } self.sync_quadlet_unit(lm, &name).await?; + self.sync_dependency_quadlet_units(lm).await?; } match status.state { ContainerState::Running => { @@ -713,15 +1078,19 @@ impl ProdContainerOrchestrator { // password rotated (or template changed via OTA). If // anything was rewritten, restart the container so nginx // picks up the new config. - if let Some(HookOutcome::Rewritten) = - self.run_pre_start_hooks(&app_id).await? + let app_hook = self.run_pre_start_hooks(&app_id).await?; + let file_hook = self.ensure_manifest_files(&resolved_manifest).await?; + if app_hook == Some(HookOutcome::Rewritten) + || file_hook == HookOutcome::Rewritten { tracing::info!(app_id = %app_id, "config rewritten while running — restarting"); - let _ = self.runtime.stop_container(&name).await; - self.runtime - .start_container(&name) - .await - .with_context(|| format!("reconcile restart {name}"))?; + restart_container_scoped_if_pasta( + self.runtime.as_ref(), + &resolved_manifest, + &name, + ) + .await + .with_context(|| format!("reconcile restart {name}"))?; self.run_post_start_hooks(&app_id).await?; return Ok(ReconcileAction::Started); } @@ -744,6 +1113,39 @@ impl ProdContainerOrchestrator { return Ok(ReconcileAction::Installed); } self.run_post_start_hooks(&app_id).await?; + if !resolved_manifest.app.ports.is_empty() { + if let Err(err) = wait_for_manifest_host_ports( + &resolved_manifest, + host_port_repair_probe_timeout_secs(&resolved_manifest), + ) + .await + { + tracing::warn!(app_id = %app_id, container = %name, mode = ?mode, error = %err, "host listener missing for running container; repairing"); + repair_manifest_host_ports_after_stability( + self.runtime.as_ref(), + &resolved_manifest, + &name, + ) + .await?; + return Ok(ReconcileAction::Started); + } + } + if uses_pasta_network(&resolved_manifest) { + if let Err(err) = wait_for_container_stable_running( + self.runtime.as_ref(), + &name, + 15, + 90, + ) + .await + { + tracing::warn!(app_id = %app_id, container = %name, mode = ?mode, error = %err, "pasta container not stable after install; recreating via direct runtime"); + let _ = self.runtime.stop_container(&name).await; + let _ = self.runtime.remove_container(&name).await; + self.install_fresh(lm).await?; + return Ok(ReconcileAction::Installed); + } + } Ok(ReconcileAction::NoOp) } ContainerState::Stopped | ContainerState::Exited => { @@ -758,7 +1160,13 @@ impl ProdContainerOrchestrator { self.install_fresh(lm).await?; return Ok(ReconcileAction::Installed); } - if let Err(e) = self.runtime.start_container(&name).await { + if let Err(e) = start_container_scoped_if_pasta( + self.runtime.as_ref(), + &resolved_manifest, + &name, + ) + .await + { tracing::warn!( app_id = %app_id, container = %name, @@ -771,7 +1179,15 @@ impl ProdContainerOrchestrator { return Ok(ReconcileAction::Installed); } self.run_post_start_hooks(&app_id).await?; - wait_for_manifest_host_ports(&resolved_manifest, 60).await?; + wait_for_manifest_host_ports( + &resolved_manifest, + host_port_wait_timeout_secs(&resolved_manifest), + ) + .await?; + if uses_pasta_network(&resolved_manifest) { + wait_for_container_stable_running(self.runtime.as_ref(), &name, 15, 90) + .await?; + } Ok(ReconcileAction::Started) } ContainerState::Stopping => { @@ -793,7 +1209,13 @@ impl ProdContainerOrchestrator { self.install_fresh(lm).await?; return Ok(ReconcileAction::Installed); } - if let Err(e) = self.runtime.start_container(&name).await { + if let Err(e) = start_container_scoped_if_pasta( + self.runtime.as_ref(), + &resolved_manifest, + &name, + ) + .await + { tracing::warn!( app_id = %app_id, container = %name, @@ -806,7 +1228,15 @@ impl ProdContainerOrchestrator { return Ok(ReconcileAction::Installed); } self.run_post_start_hooks(&app_id).await?; - wait_for_manifest_host_ports(&resolved_manifest, 60).await?; + wait_for_manifest_host_ports( + &resolved_manifest, + host_port_wait_timeout_secs(&resolved_manifest), + ) + .await?; + if uses_pasta_network(&resolved_manifest) { + wait_for_container_stable_running(self.runtime.as_ref(), &name, 15, 90) + .await?; + } Ok(ReconcileAction::Started) } ContainerState::Paused => Ok(ReconcileAction::Left("paused".to_string())), @@ -819,16 +1249,28 @@ impl ProdContainerOrchestrator { // lost the container record after a crash/reboot. Sync the unit // bytes first (clears stale Notify=healthy/nc probes), then ask // user systemd to start the generated service. - if self.use_quadlet_backends && self.quadlet_unit_exists(&name).await? { + if self.use_quadlet_backends + && !uses_pasta_network(&resolved_manifest) + && self.quadlet_unit_exists(&name).await? + { self.prepare_for_start(&resolved_manifest).await?; self.sync_quadlet_unit(lm, &name).await?; + self.ensure_resolved_source_available(lm).await?; quadlet::enable_now(&format!("{name}.service")) .await .with_context(|| { format!("start existing quadlet service {name}.service") })?; self.run_post_start_hooks(&app_id).await?; - wait_for_manifest_host_ports(&resolved_manifest, 60).await?; + wait_for_manifest_host_ports( + &resolved_manifest, + host_port_wait_timeout_secs(&resolved_manifest), + ) + .await?; + if uses_pasta_network(&resolved_manifest) { + wait_for_container_stable_running(self.runtime.as_ref(), &name, 15, 90) + .await?; + } return Ok(ReconcileAction::Started); } @@ -886,11 +1328,17 @@ impl ProdContainerOrchestrator { .to_string_lossy() .into_owned(); } - let already = self - .runtime - .image_exists(&bcfg.tag) - .await - .with_context(|| format!("image_exists {}", bcfg.tag))?; + let already = match self.runtime.image_exists(&bcfg.tag).await { + Ok(exists) => exists, + Err(err) => { + tracing::warn!( + image = %bcfg.tag, + error = %err, + "build image existence check failed; rebuilding image" + ); + false + } + }; if !already { self.runtime .build_image(&bcfg) @@ -909,26 +1357,61 @@ impl ProdContainerOrchestrator { self.prepare_for_start(&resolved_manifest).await?; self.ensure_container_network(&resolved_manifest).await?; - if self.use_quadlet_backends { + if self.use_quadlet_backends && !uses_pasta_network(&resolved_manifest) { // Phase 3.2 path: declarative .container unit + systemctl. // Containers parented under user.slice instead of // archipelago.service's cgroup → no FM3 cascade SIGKILL on // archipelago restart. self.install_via_quadlet(&resolved_manifest, &name).await?; } else { + self.remove_quadlet_unit_if_present(&name).await?; + ensure_user_podman_socket().await?; // Legacy path. Production until tests/lifecycle/run-20x.sh // goes green against the Quadlet path. self.runtime .create_container(&resolved_manifest, &name, 0) .await .with_context(|| format!("create_container {name}"))?; - self.runtime - .start_container(&name) + start_container_scoped_if_pasta(self.runtime.as_ref(), &resolved_manifest, &name) .await .with_context(|| format!("start_container {name}"))?; } self.run_post_start_hooks(&lm.manifest.app.id).await?; - wait_for_manifest_host_ports(&resolved_manifest, 60).await?; + if uses_pasta_network(&resolved_manifest) { + if let Err(err) = wait_for_manifest_host_ports( + &resolved_manifest, + host_port_wait_timeout_secs(&resolved_manifest), + ) + .await + { + tracing::warn!( + app_id = %resolved_manifest.app.id, + container = %name, + error = %err, + "pasta host listener missing after fresh start; trying restart repair" + ); + repair_manifest_host_ports_after_stability( + self.runtime.as_ref(), + &resolved_manifest, + &name, + ) + .await?; + return Ok(()); + } + wait_for_container_stable_running(self.runtime.as_ref(), &name, 15, 90).await?; + repair_manifest_host_ports_after_stability( + self.runtime.as_ref(), + &resolved_manifest, + &name, + ) + .await?; + } else { + wait_for_manifest_host_ports( + &resolved_manifest, + host_port_wait_timeout_secs(&resolved_manifest), + ) + .await?; + } Ok(()) } @@ -947,7 +1430,9 @@ impl ProdContainerOrchestrator { async fn prepare_for_start(&self, manifest: &AppManifest) -> Result<()> { self.run_pre_start_hooks(&manifest.app.id).await?; + self.ensure_bind_mount_sockets(manifest).await?; self.ensure_bind_mount_dirs(manifest).await?; + self.ensure_manifest_files(manifest).await?; self.apply_data_uid(manifest).await?; self.run_post_data_uid_hooks(&manifest.app.id).await?; Ok(()) @@ -1075,6 +1560,19 @@ impl ProdContainerOrchestrator { .with_context(|| format!("check existing quadlet unit {}", unit_path.display())) } + async fn remove_quadlet_unit_if_present(&self, name: &str) -> Result<()> { + let unit_dir = quadlet::unit_dir() + .await + .context("locate user quadlet unit dir for removal")?; + let unit_path = unit_dir.join(format!("{name}.container")); + if tokio::fs::try_exists(&unit_path).await.unwrap_or(false) { + quadlet::disable_remove(name, &unit_dir) + .await + .with_context(|| format!("remove stale quadlet unit for {name}"))?; + } + Ok(()) + } + /// Drift-sync an existing Quadlet unit file's bytes against what the /// current renderer produces. No-op when the flag is off, when the /// app is a companion (companion.rs owns those units), or when no @@ -1138,6 +1636,7 @@ impl ProdContainerOrchestrator { || restart_for_exec_change || restart_for_health_change) { + self.ensure_resolved_source_available(lm).await?; let service = unit.service_name(); let reason = if restart_required { "stale health gate" @@ -1164,6 +1663,101 @@ impl ProdContainerOrchestrator { Ok(()) } + async fn sync_dependency_quadlet_units(&self, lm: &LoadedManifest) -> Result<()> { + let dependency_ids = manifest_dependency_app_ids(&lm.manifest); + if dependency_ids.is_empty() { + return Ok(()); + } + + let dependencies: Vec = { + let state = self.state.read().await; + dependency_ids + .iter() + .filter_map(|app_id| state.manifests.get(app_id).cloned()) + .collect() + }; + + for dep in dependencies { + let mut resolved = dep.manifest.clone(); + self.resolve_dynamic_env(&mut resolved)?; + let name = compute_container_name(&dep.manifest); + if self.runtime.get_container_status(&name).await.is_err() { + continue; + } + if self.use_quadlet_backends && !uses_pasta_network(&resolved) { + self.sync_quadlet_unit(&dep, &name).await?; + } + } + + Ok(()) + } + + async fn ensure_resolved_source_available(&self, lm: &LoadedManifest) -> Result<()> { + let resolved = lm.manifest.app.container.resolve().ok_or_else(|| { + anyhow::anyhow!( + "manifest for {} has invalid container source (neither image nor build)", + lm.manifest.app.id + ) + })?; + + match resolved { + ResolvedSource::Pull { + image, + image_signature, + .. + } => { + let exists = match self.runtime.image_exists(&image).await { + Ok(exists) => exists, + Err(err) => { + tracing::warn!( + image = %image, + error = %err, + "image existence check failed; pulling image instead" + ); + false + } + }; + if !exists { + self.runtime + .pull_image(&image, image_signature.as_deref()) + .await + .with_context(|| format!("pulling {image}"))?; + } + } + ResolvedSource::Build(mut bcfg) => { + let ctx_path = Path::new(&bcfg.context); + if !ctx_path.is_absolute() { + bcfg.context = lm + .manifest_dir + .join(ctx_path) + .to_string_lossy() + .into_owned(); + } + if !self + .runtime + .image_exists(&bcfg.tag) + .await + .map_err(|err| { + tracing::warn!( + image = %bcfg.tag, + error = %err, + "build image existence check failed; rebuilding image" + ); + err + }) + .unwrap_or(false) + { + self.runtime + .build_image(&bcfg) + .await + .with_context(|| format!("build_image {}", bcfg.tag))?; + } + } + } + + Ok(()) + } + /// Phase 3.2 install path. Renders the manifest as a Quadlet unit, /// writes it atomically into ~/.config/containers/systemd/, asks /// systemd to reload, and starts the generated service. Errors at @@ -1189,7 +1783,7 @@ impl ProdContainerOrchestrator { let Some(network) = manifest.app.container.network.as_deref() else { return Ok(()); }; - if network.is_empty() || matches!(network, "host" | "bridge" | "none" | "slirp4netns") { + if network.is_empty() || is_builtin_network_mode(network) { return Ok(()); } @@ -1329,7 +1923,6 @@ impl ProdContainerOrchestrator { "chown {db_dir} failed with status {status}" )); } - self.repair_btcpay_database_password().await?; Ok(()) } @@ -1359,83 +1952,34 @@ impl ProdContainerOrchestrator { Ok(()) } - async fn repair_btcpay_database_password(&self) -> Result<()> { - let secret_path = self.secrets_dir.join("btcpay-db-password"); - let Ok(db_pass) = tokio::fs::read_to_string(&secret_path).await else { - return Ok(()); - }; - let db_pass = db_pass.trim(); - if db_pass.is_empty() { - return Ok(()); - } - - if self - .runtime - .get_container_status("archy-btcpay-db") - .await - .is_err() - { - return Ok(()); - } - let _ = self.runtime.start_container("archy-btcpay-db").await; - tokio::time::sleep(std::time::Duration::from_secs(2)).await; - - let escaped = db_pass.replace('\'', "''"); - let sql = format!("ALTER USER btcpay WITH PASSWORD '{}';", escaped); - let output = tokio::process::Command::new("podman") - .args([ - "exec", - "archy-btcpay-db", - "psql", - "-U", - "btcpay", - "-d", - "btcpay", - "-c", - &sql, - ]) - .output() - .await - .context("btcpay db password repair: exec psql")?; - if !output.status.success() { - let stderr = String::from_utf8_lossy(&output.stderr); - tracing::warn!(error = %stderr.trim(), "btcpay db password repair failed"); - } - let _ = tokio::process::Command::new("podman") - .args([ - "exec", - "archy-btcpay-db", - "createdb", - "-U", - "btcpay", - "nbxplorer", - ]) - .output() - .await; - Ok(()) - } - async fn start_indeedhub_backends(&self) -> Result<()> { let _ = tokio::process::Command::new("podman") .args(["network", "create", "indeedhub-net"]) .output() .await; - for name in [ - "indeedhub-postgres", - "indeedhub-redis", - "indeedhub-minio", - "indeedhub-relay", - "indeedhub-api", - "indeedhub-ffmpeg", - ] { - let exists = self.runtime.get_container_status(name).await.is_ok(); - if exists { - let _ = self.runtime.start_container(name).await; + for name in INDEEDHUB_BACKEND_CONTAINERS { + let status = match self.runtime.get_container_status(name).await { + Ok(status) => status, + Err(_) => continue, + }; + if !matches!(status.state, ContainerState::Running) { + if let Err(err) = podman_user_scope(&["start", name]).await { + tracing::warn!( + container = %name, + error = %err, + "IndeedHub scoped backend start failed; falling back to runtime start" + ); + self.runtime + .start_container(name) + .await + .with_context(|| format!("start IndeedHub backend {name}"))?; + } tokio::time::sleep(std::time::Duration::from_secs(2)).await; } } self.repair_indeedhub_network_aliases().await; + self.wait_for_indeedhub_dependencies_ready(120).await?; Ok(()) } @@ -1461,10 +2005,16 @@ impl ProdContainerOrchestrator { | ContainerState::Exited | ContainerState::Created | ContainerState::Stopping => { - self.runtime - .start_container("indeedhub") - .await - .context("start IndeedHub frontend during reconcile")?; + if let Err(err) = podman_user_scope(&["start", "indeedhub"]).await { + tracing::warn!( + error = %err, + "IndeedHub scoped frontend start failed; falling back to runtime start" + ); + self.runtime + .start_container("indeedhub") + .await + .context("start IndeedHub frontend during reconcile")?; + } started = true; } ContainerState::Paused => return Ok(ReconcileAction::Left("paused".to_string())), @@ -1475,17 +2025,45 @@ impl ProdContainerOrchestrator { self.repair_indeedhub_network_aliases().await; patch_indeedhub_nostr_provider().await; - if !wait_for_host_port(7778, 10).await { + let frontend_stable = wait_for_container_stable_running( + self.runtime.as_ref(), + "indeedhub", + 5, + INDEEDHUB_FRONTEND_READY_TIMEOUT_SECS, + ) + .await; + if frontend_stable.is_err() || !wait_for_host_port(7778, 10).await { tracing::warn!( - "IndeedHub frontend running but host port 7778 is not listening; restarting" + error = ?frontend_stable.err(), + "IndeedHub frontend did not stay reachable after reconcile; restarting" ); let _ = self.runtime.stop_container("indeedhub").await; - self.runtime - .start_container("indeedhub") - .await - .context("restart IndeedHub frontend after missing host port")?; + if let Err(err) = podman_user_scope(&["start", "indeedhub"]).await { + tracing::warn!( + error = %err, + "IndeedHub scoped frontend restart failed; falling back to runtime start" + ); + self.runtime + .start_container("indeedhub") + .await + .context("restart IndeedHub frontend after failed readiness")?; + } + started = true; tokio::time::sleep(std::time::Duration::from_secs(5)).await; patch_indeedhub_nostr_provider().await; + wait_for_container_stable_running( + self.runtime.as_ref(), + "indeedhub", + 5, + INDEEDHUB_FRONTEND_READY_TIMEOUT_SECS, + ) + .await + .context("IndeedHub frontend did not remain running after restart")?; + if !wait_for_host_port(7778, 30).await { + return Err(anyhow::anyhow!( + "IndeedHub frontend did not expose host port 7778 after restart" + )); + } } if started { @@ -1495,6 +2073,85 @@ impl ProdContainerOrchestrator { } } + async fn wait_for_indeedhub_dependencies_ready(&self, timeout_secs: u64) -> Result<()> { + let deadline = std::time::Instant::now() + std::time::Duration::from_secs(timeout_secs); + let mut last = String::from("not checked"); + loop { + let mut all_running = true; + for name in INDEEDHUB_BACKEND_CONTAINERS { + match self.runtime.get_container_status(name).await { + Ok(status) if matches!(status.state, ContainerState::Running) => {} + Ok(status) => { + all_running = false; + last = format!("{name} state {:?}", status.state); + break; + } + Err(err) => { + all_running = false; + last = format!("{name} status error: {err}"); + break; + } + } + } + + if all_running && self.indeedhub_api_dependency_dns_ready().await { + return Ok(()); + } + if all_running { + last = "indeedhub-api dependency DNS not ready".to_string(); + } + + if std::time::Instant::now() >= deadline { + return Err(anyhow::anyhow!( + "IndeedHub dependencies were not ready within {}s ({})", + timeout_secs, + last + )); + } + tokio::time::sleep(std::time::Duration::from_secs(2)).await; + } + } + + async fn indeedhub_api_dependency_dns_ready(&self) -> bool { + let aliases_ready = self.indeedhub_required_aliases_present().await; + if cfg!(test) { + return true; + } + + for host in ["postgres", "redis", "minio", "relay"] { + let Ok(Ok(output)) = tokio::time::timeout( + std::time::Duration::from_secs(5), + tokio::process::Command::new("podman") + .args(["exec", "indeedhub-api", "getent", "hosts", host]) + .output(), + ) + .await + else { + return aliases_ready; + }; + if !output.status.success() { + return aliases_ready; + } + } + true + } + + async fn indeedhub_required_aliases_present(&self) -> bool { + for (container, alias) in [ + ("indeedhub-postgres", "postgres"), + ("indeedhub-redis", "redis"), + ("indeedhub-minio", "minio"), + ("indeedhub-relay", "relay"), + ("indeedhub-api", "api"), + ("indeedhub", "indeedhub"), + ] { + if !self.indeedhub_alias_present(container, alias).await { + return false; + } + } + true + } + async fn repair_indeedhub_network_aliases(&self) { for (container, alias) in [ ("indeedhub-postgres", "postgres"), @@ -1513,6 +2170,9 @@ impl ProdContainerOrchestrator { if !exists { continue; } + if self.indeedhub_alias_present(container, alias).await { + continue; + } let _ = tokio::process::Command::new("podman") .args(["network", "disconnect", "-f", "indeedhub-net", container]) @@ -1532,6 +2192,32 @@ impl ProdContainerOrchestrator { } } + async fn indeedhub_alias_present(&self, container: &str, alias: &str) -> bool { + let output = match tokio::process::Command::new("podman") + .args([ + "inspect", + container, + "--format", + "{{json .NetworkSettings.Networks}}", + ]) + .output() + .await + { + Ok(output) if output.status.success() => output, + _ => return false, + }; + + let Ok(networks) = serde_json::from_slice::(&output.stdout) else { + return false; + }; + networks + .get("indeedhub-net") + .and_then(|network| network.get("Aliases")) + .and_then(|aliases| aliases.as_array()) + .map(|aliases| aliases.iter().any(|value| value.as_str() == Some(alias))) + .unwrap_or(false) + } + async fn cleanup_stale_grafana_port(&self) { let _ = tokio::process::Command::new("pkill") .args(["-f", "pasta.*3001"]) @@ -1635,6 +2321,10 @@ impl ProdContainerOrchestrator { ) })?; env.extend(secrets); + if manifest.app.id == "fedimint" || manifest.app.id == "fedimintd" { + env.retain(|entry| !entry.starts_with("FM_BITCOIND_URL=")); + env.push("FM_BITCOIND_URL=http://bitcoin-knots:8332".to_string()); + } Self::expand_env_placeholders(&mut env); manifest.app.environment = env; Ok(()) @@ -1762,6 +2452,9 @@ impl ProdContainerOrchestrator { if volume.volume_type == "tmpfs" || volume.source.is_empty() { continue; } + if is_podman_socket_bind_source(&volume.source) { + continue; + } let mkdir_status = host_sudo(&["mkdir", "-p", &volume.source]) .await @@ -1789,6 +2482,15 @@ impl ProdContainerOrchestrator { if !Path::new(&volume.source).is_absolute() { continue; } + if is_podman_socket_bind_source(&volume.source) { + ensure_user_podman_socket().await.with_context(|| { + format!( + "ensure podman socket for {} bind mount {}", + manifest.app.id, volume.source + ) + })?; + continue; + } // File mounts are rendered by app-specific hooks; everything else // must exist before the Podman API accepts the bind mount. @@ -1809,6 +2511,113 @@ impl ProdContainerOrchestrator { } Ok(()) } + + async fn ensure_bind_mount_sockets(&self, manifest: &AppManifest) -> Result<()> { + for volume in &manifest.app.volumes { + if volume.volume_type == "tmpfs" || volume.source.is_empty() { + continue; + } + if is_podman_socket_bind_source(&volume.source) { + ensure_user_podman_socket().await.with_context(|| { + format!( + "ensure podman socket for {} bind mount {}", + manifest.app.id, volume.source + ) + })?; + } + } + Ok(()) + } + + async fn ensure_manifest_files(&self, manifest: &AppManifest) -> Result { + let mut outcome = HookOutcome::Unchanged; + for file in &manifest.app.files { + if ensure_generated_file(file) + .await + .with_context(|| format!("ensure manifest file {}", file.path))? + == HookOutcome::Rewritten + { + outcome = HookOutcome::Rewritten; + } + } + Ok(outcome) + } +} + +async fn ensure_generated_file(file: &GeneratedFile) -> Result { + let path = Path::new(&file.path); + if let Ok(existing) = tokio::fs::read_to_string(path).await { + if existing == file.content || !file.overwrite { + return Ok(HookOutcome::Unchanged); + } + } else if path.exists() && !file.overwrite { + return Ok(HookOutcome::Unchanged); + } + + let parent = path + .parent() + .ok_or_else(|| anyhow::anyhow!("generated file path has no parent: {}", file.path))?; + create_dir_all_or_sudo(parent).await?; + write_generated_file_atomically(path, &file.content).await?; + Ok(HookOutcome::Rewritten) +} + +async fn create_dir_all_or_sudo(path: &Path) -> Result<()> { + match tokio::fs::create_dir_all(path).await { + Ok(()) => Ok(()), + Err(e) if e.kind() == std::io::ErrorKind::PermissionDenied => { + let path = path.to_string_lossy(); + let status = host_sudo(&["mkdir", "-p", &path]) + .await + .with_context(|| format!("creating {path} via sudo"))?; + if !status.success() { + anyhow::bail!("mkdir -p {path} via sudo exited with {status}"); + } + Ok(()) + } + Err(e) => Err(e).with_context(|| format!("creating {}", path.display())), + } +} + +async fn write_generated_file_atomically(path: &Path, content: &str) -> Result<()> { + let file_name = path.file_name().and_then(|s| s.to_str()).ok_or_else(|| { + anyhow::anyhow!("generated file path has no filename: {}", path.display()) + })?; + let tmp = path.with_file_name(format!(".{file_name}.archy-tmp")); + match tokio::fs::write(&tmp, content).await { + Ok(()) => { + tokio::fs::rename(&tmp, path).await.with_context(|| { + format!( + "renaming generated file {} -> {}", + tmp.display(), + path.display() + ) + })?; + Ok(()) + } + Err(e) if e.kind() == std::io::ErrorKind::PermissionDenied => { + let script = format!( + "set -eu\ncat > '{}' <<'ARCHYGENERATEDFILE'\n{}ARCHYGENERATEDFILE\n", + shell_quote(&path.to_string_lossy()), + content + ); + let status = host_sudo(&["sh", "-lc", &script]) + .await + .with_context(|| format!("writing generated file {} via sudo", path.display()))?; + if !status.success() { + anyhow::bail!( + "writing generated file {} via sudo exited with {status}", + path.display() + ); + } + Ok(()) + } + Err(e) => Err(e).with_context(|| format!("writing tmp {}", tmp.display())), + } +} + +fn shell_quote(s: &str) -> String { + s.replace('\'', "'\\''") } /// Result of a pre-start hook pass. See `run_pre_start_hooks` docs. @@ -1912,10 +2721,31 @@ impl ContainerOrchestrator for ProdContainerOrchestrator { if let Err(err) = quadlet::stop_service(&format!("{name}.service")).await { tracing::debug!(container = %name, error = %err, "quadlet stop skipped/failed"); } - self.runtime - .stop_container(&name) - .await - .with_context(|| format!("stop_container {name}")) + match self.runtime.stop_container(&name).await { + Ok(()) => Ok(()), + Err(err) => { + let stuck_stopping = self + .runtime + .get_container_status(&name) + .await + .map(|status| matches!(status.state, ContainerState::Stopping)) + .unwrap_or(false); + if stuck_stopping { + tracing::warn!( + app_id = %app_id, + container = %name, + error = %err, + "container stop timed out and left a stuck Stopping record; force-removing record" + ); + self.runtime + .remove_container(&name) + .await + .with_context(|| format!("force remove stuck stopping container {name}"))?; + return Ok(()); + } + Err(err).with_context(|| format!("stop_container {name}")) + } + } } async fn restart(&self, app_id: &str) -> Result<()> { @@ -1923,11 +2753,11 @@ impl ContainerOrchestrator for ProdContainerOrchestrator { let lock = self.app_lock(app_id).await; let _guard = lock.lock().await; let name = compute_container_name(&lm.manifest); + let mut resolved_manifest = lm.manifest.clone(); + self.resolve_dynamic_env(&mut resolved_manifest)?; let service = format!("{name}.service"); if self.quadlet_unit_exists(&name).await? { - let mut resolved_manifest = lm.manifest.clone(); - self.resolve_dynamic_env(&mut resolved_manifest)?; self.prepare_for_start(&resolved_manifest).await?; self.sync_quadlet_unit(&lm, &name).await?; if let Err(err) = quadlet::restart_service(&service).await { @@ -1937,17 +2767,36 @@ impl ContainerOrchestrator for ProdContainerOrchestrator { .with_context(|| format!("restart start quadlet service {service}"))?; } self.run_post_start_hooks(app_id).await?; - wait_for_manifest_host_ports(&resolved_manifest, 60).await?; + wait_for_manifest_host_ports( + &resolved_manifest, + host_port_wait_timeout_secs(&resolved_manifest), + ) + .await?; return Ok(()); } - // Best-effort stop (ignored if already stopped), then start. - let _ = self.runtime.stop_container(&name).await; - self.prepare_for_start(&lm.manifest).await?; - self.runtime - .start_container(&name) + // Best-effort restart. Pasta containers need a real restart in the + // user scope; stop+start can devolve into a no-op if stop times out. + self.prepare_for_start(&resolved_manifest).await?; + restart_container_scoped_if_pasta(self.runtime.as_ref(), &resolved_manifest, &name) .await - .with_context(|| format!("restart start_container {name}")) + .with_context(|| format!("restart container {name}"))?; + self.run_post_start_hooks(app_id).await?; + wait_for_manifest_host_ports( + &resolved_manifest, + host_port_wait_timeout_secs(&resolved_manifest), + ) + .await?; + if uses_pasta_network(&resolved_manifest) { + wait_for_container_stable_running(self.runtime.as_ref(), &name, 15, 90).await?; + repair_manifest_host_ports_after_stability( + self.runtime.as_ref(), + &resolved_manifest, + &name, + ) + .await?; + } + Ok(()) } /// Remove the container. `preserve_data=true` is honored by NOT touching volumes @@ -2079,6 +2928,8 @@ mod tests { created_env: StdMutex>>, /// If set, the next `build_image` call fails with this message. fail_build: StdMutex>, + /// If set, `image_exists` fails for this image reference. + fail_image_exists: StdMutex>, /// If set, `start_container` for this container fails with this message. fail_start: StdMutex>, } @@ -2201,6 +3052,9 @@ mod tests { } async fn image_exists(&self, image_ref: &str) -> Result { self.record(format!("image_exists:{image_ref}")); + if let Some(msg) = self.fail_image_exists.lock().unwrap().get(image_ref) { + return Err(anyhow::anyhow!(msg.clone())); + } Ok(self .images .lock() @@ -2236,6 +3090,34 @@ mod tests { AppManifest::parse(&yaml).unwrap() } + #[test] + fn active_manifest_dependencies_override_stale_user_stopped_entries() { + let parent = AppManifest::parse( + r#" +app: + id: btcpay-server + name: btcpay-server + version: 1.0.0 + container: + image: btcpay:latest + dependencies: + - app_id: archy-nbxplorer + version: ">=1" +"#, + ) + .unwrap(); + let child = pull_manifest("archy-nbxplorer", "nbxplorer:latest"); + let mut user_stopped = HashSet::new(); + user_stopped.insert("archy-nbxplorer".to_string()); + + let required = dependency_manifests_required_by_active_apps( + [&parent, &child].into_iter(), + &user_stopped, + ); + + assert!(required.contains("archy-nbxplorer")); + } + fn manifest_with_container_name(id: &str, image: &str, name: &str) -> AppManifest { let yaml = format!( "app:\n id: {id}\n name: {id}\n version: 1.0.0\n container_name: {name}\n container:\n image: {image}\n" @@ -2307,6 +3189,24 @@ mod tests { AppManifest::parse(&yaml).unwrap() } + fn pull_manifest_with_generated_file(id: &str, image: &str, source: &str) -> AppManifest { + let yaml = format!( + "app:\n id: {id}\n name: {id}\n version: 1.0.0\n container:\n image: {image}\n volumes:\n - type: bind\n source: {source}\n target: /data\n files:\n - path: {source}/config.yaml\n content: |\n key: value\n" + ); + AppManifest::parse(&yaml).unwrap() + } + + fn pull_manifest_with_generated_file_overwrite( + id: &str, + image: &str, + source: &str, + ) -> AppManifest { + let yaml = format!( + "app:\n id: {id}\n name: {id}\n version: 1.0.0\n container:\n image: {image}\n volumes:\n - type: bind\n source: {source}\n target: /data\n files:\n - path: {source}/config.yaml\n overwrite: true\n content: |\n key: new\n" + ); + AppManifest::parse(&yaml).unwrap() + } + fn pull_manifest_filebrowser() -> AppManifest { let yaml = r#" app: @@ -2428,6 +3328,37 @@ app: .any(|c| c == "start_container:archy-bitcoin-ui")); } + #[tokio::test] + async fn install_fresh_builds_when_image_exists_check_fails() { + let rt = Arc::new(MockRuntime::default()); + rt.fail_image_exists.lock().unwrap().insert( + "archy-bitcoin-ui:local".to_string(), + "podman image inspect timed out".to_string(), + ); + let orch = orch_with(rt.clone()).await; + orch.insert_manifest_for_test( + build_manifest( + "bitcoin-ui", + "/opt/archy/docker/bitcoin-ui", + "archy-bitcoin-ui:local", + ), + PathBuf::from("/opt/archy/apps/bitcoin-ui"), + ) + .await; + + orch.install("bitcoin-ui").await.unwrap(); + let calls = rt.calls(); + assert!(calls + .iter() + .any(|c| c == "image_exists:archy-bitcoin-ui:local")); + assert!(calls + .iter() + .any(|c| c.starts_with("build_image:archy-bitcoin-ui:local:"))); + assert!(calls + .iter() + .any(|c| c == "create_container:archy-bitcoin-ui:offset=0")); + } + #[tokio::test] async fn install_bitcoin_ui_renders_nginx_conf_via_hook() { // End-to-end: install("bitcoin-ui") must invoke the pre-start @@ -2583,6 +3514,83 @@ app: .any(|c| c == "create_container:electrumx:offset=0")); } + #[tokio::test] + async fn install_writes_manifest_generated_files_before_create() { + let rt = Arc::new(MockRuntime::default()); + let orch = orch_with(rt.clone()).await; + + let data_dir = tempfile::tempdir().unwrap(); + orch.insert_manifest_for_test( + pull_manifest_with_generated_file( + "meshtastic", + "docker.io/meshtastic/meshtasticd:daily-alpine", + data_dir.path().to_string_lossy().as_ref(), + ), + PathBuf::from("/tmp/meshtastic"), + ) + .await; + + orch.install("meshtastic").await.unwrap(); + + let config_path = data_dir.path().join("config.yaml"); + let config = std::fs::read_to_string(config_path).unwrap(); + assert_eq!(config, "key: value\n"); + let calls = rt.calls(); + assert!(calls + .iter() + .any(|c| c == "create_container:meshtastic:offset=0")); + } + + #[tokio::test] + async fn manifest_generated_files_do_not_overwrite_by_default() { + let rt = Arc::new(MockRuntime::default()); + let orch = orch_with(rt.clone()).await; + + let data_dir = tempfile::tempdir().unwrap(); + let config_path = data_dir.path().join("config.yaml"); + std::fs::write(&config_path, "key: operator\n").unwrap(); + + orch.insert_manifest_for_test( + pull_manifest_with_generated_file( + "meshtastic", + "docker.io/meshtastic/meshtasticd:daily-alpine", + data_dir.path().to_string_lossy().as_ref(), + ), + PathBuf::from("/tmp/meshtastic"), + ) + .await; + + orch.install("meshtastic").await.unwrap(); + + let config = std::fs::read_to_string(config_path).unwrap(); + assert_eq!(config, "key: operator\n"); + } + + #[tokio::test] + async fn manifest_generated_files_can_overwrite_when_declared() { + let rt = Arc::new(MockRuntime::default()); + let orch = orch_with(rt.clone()).await; + + let data_dir = tempfile::tempdir().unwrap(); + let config_path = data_dir.path().join("config.yaml"); + std::fs::write(&config_path, "key: old\n").unwrap(); + + orch.insert_manifest_for_test( + pull_manifest_with_generated_file_overwrite( + "meshtastic", + "docker.io/meshtastic/meshtasticd:daily-alpine", + data_dir.path().to_string_lossy().as_ref(), + ), + PathBuf::from("/tmp/meshtastic"), + ) + .await; + + orch.install("meshtastic").await.unwrap(); + + let config = std::fs::read_to_string(config_path).unwrap(); + assert_eq!(config, "key: new\n"); + } + #[tokio::test] async fn reconcile_noop_when_already_running() { let rt = Arc::new(MockRuntime::default()); diff --git a/core/archipelago/src/container/quadlet.rs b/core/archipelago/src/container/quadlet.rs index c142b6da..f0927472 100644 --- a/core/archipelago/src/container/quadlet.rs +++ b/core/archipelago/src/container/quadlet.rs @@ -34,9 +34,13 @@ use anyhow::{anyhow, Context, Result}; use archipelago_container::AppManifest; use std::fmt::Write as _; use std::path::{Path, PathBuf}; +use std::time::Duration; use tokio::fs; use tokio::process::Command; +const QUADLET_START_TIMEOUT: Duration = Duration::from_secs(90); +const QUADLET_STOP_TIMEOUT: Duration = Duration::from_secs(45); + /// Default rootless quadlet directory. Resolved per-user at runtime via /// `unit_dir()`. Tests pass an explicit dir. pub const DEFAULT_REL_UNIT_DIR: &str = ".config/containers/systemd"; @@ -61,6 +65,12 @@ pub enum NetworkMode { /// attached to it. The network must already exist (orchestrator's /// `ensure_container_network` handles that on every reconcile tick). Bridge(String), + /// Rootless slirp4netns networking. Podman rejects network aliases with + /// this mode, so render only Network=slirp4netns. + Slirp4netns, + /// Rootless pasta networking. This is more reliable than slirp4netns for + /// host port forwarding on long-running web apps. + Pasta, } /// systemd Restart= policy for the generated `.service` unit. Companions @@ -181,6 +191,12 @@ impl QuadletUnit { NetworkMode::Host => { let _ = writeln!(s, "Network=host"); } + NetworkMode::Slirp4netns => { + let _ = writeln!(s, "Network=slirp4netns"); + } + NetworkMode::Pasta => { + let _ = writeln!(s, "Network=pasta"); + } NetworkMode::Bridge(net) => { let _ = writeln!(s, "Network={net}"); for alias in &self.network_aliases { @@ -261,6 +277,13 @@ impl QuadletUnit { } let _ = writeln!(s); let _ = writeln!(s, "[Service]"); + // Dependency-gated apps may legitimately keep their container entrypoint + // in a wait loop before the actual daemon binds ports. Fedimint waits + // for Bitcoin IBD to finish before execing fedimintd; systemd's default + // start timeout otherwise kills the generated podman run job and leaves + // the unit stuck in deactivating. Health/status remains app-level state, + // not a systemd start gate. + let _ = writeln!(s, "TimeoutStartSec=0"); // Restart policy + 10s backoff. RestartSec keeps a crash-loop // from saturating the journal. Companions: Always. Backends: // OnFailure (clean stops stay stopped). @@ -334,6 +357,8 @@ impl QuadletUnit { // either form. other if !other.is_empty() && other != "isolated" => NetworkMode::Bridge(other.into()), _ => match app.container.network.as_deref() { + Some("slirp4netns") => NetworkMode::Slirp4netns, + Some("pasta") => NetworkMode::Pasta, Some(n) if !n.is_empty() && n != "host" => NetworkMode::Bridge(n.into()), _ => NetworkMode::Default, }, @@ -382,7 +407,7 @@ impl QuadletUnit { entrypoint: app.container.entrypoint.clone(), command: app.container.custom_args.clone(), read_only_root: app.security.readonly_root, - no_new_privileges: true, + no_new_privileges: app.security.no_new_privileges, cpu_quota: app.resources.cpu_limit, restart_policy: RestartPolicy::OnFailure, } @@ -436,13 +461,14 @@ fn translate_health_check(hc: &archipelago_container::HealthCheck) -> Option/dev/null 2>&1; then wget -q -T 5 -O /dev/null {0}; elif command -v curl >/dev/null 2>&1; then curl -fsS -m 5 {0}; else exit 0; fi", - final_url + "if command -v wget >/dev/null 2>&1; then wget -q -T {1} -O /dev/null {0}; elif command -v curl >/dev/null 2>&1; then curl -fsS -m {1} {0}; else exit 0; fi", + final_url, helper_timeout ) } "cmd" => hc.endpoint.as_deref()?.to_string(), @@ -456,6 +482,29 @@ fn translate_health_check(hc: &archipelago_container::HealthCheck) -> Option u64 { + let trimmed = raw.trim(); + if trimmed.is_empty() { + return 5; + } + + let (number, multiplier) = match trimmed.chars().last() { + Some('s') | Some('S') => (&trimmed[..trimmed.len() - 1], 1), + Some('m') | Some('M') => (&trimmed[..trimmed.len() - 1], 60), + Some('h') | Some('H') => (&trimmed[..trimmed.len() - 1], 3600), + Some(c) if c.is_ascii_digit() => (trimmed, 1), + _ => return 5, + }; + + number + .trim() + .parse::() + .ok() + .and_then(|n| n.checked_mul(multiplier)) + .filter(|n| *n > 0) + .unwrap_or(5) +} + /// Parse the manifest's memory_limit string into MiB. Recognises the /// forms our manifests actually use: "", "m"/"M", "g"/"G". /// Returns None for anything else; the caller treats None as unlimited. @@ -532,12 +581,21 @@ pub async fn enable_now(service: &str) -> Result<()> { // .service file lives under /run, not /etc — `enable` would refuse // ("transient or generated"). The unit's `[Install] WantedBy` is // honoured at daemon-reload, so we just start it. - let status = Command::new("systemctl") - .args(["--user", "start", service]) - .status() + let status = systemctl_user_status(&["start", service], QUADLET_START_TIMEOUT) .await - .with_context(|| format!("spawn systemctl --user start {service}"))?; + .with_context(|| format!("systemctl --user start {service}"))?; if !status.success() { + if wait_not_deactivating(service, Duration::from_secs(30)).await { + let retry = systemctl_user_status(&["start", service], QUADLET_START_TIMEOUT) + .await + .with_context(|| format!("retry systemctl --user start {service}"))?; + if retry.success() { + return Ok(()); + } + return Err(anyhow!( + "systemctl --user start {service} exited {status}; retry exited {retry}" + )); + } return Err(anyhow!("systemctl --user start {service} exited {status}")); } Ok(()) @@ -545,32 +603,112 @@ pub async fn enable_now(service: &str) -> Result<()> { /// Restart a generated Quadlet service after rewriting a known-bad unit. pub async fn restart_service(service: &str) -> Result<()> { - let status = Command::new("systemctl") - .args(["--user", "restart", service]) - .status() - .await - .with_context(|| format!("spawn systemctl --user restart {service}"))?; - if !status.success() { + // `systemctl restart` hides the stop phase. On rootless Podman nodes a + // generated unit can sit in deactivating while `podman rm -f` hangs, which + // makes RPC/UI state look frozen. Split restart into bounded stop + start + // so stop timeouts can be recovered with an app-scoped kill/reset. + if let Err(err) = stop_service(service).await { + tracing::warn!( + service = %service, + error = %err, + "quadlet stop failed during restart; waiting for unit to settle before start" + ); + } + if !wait_not_deactivating(service, Duration::from_secs(120)).await { return Err(anyhow!( - "systemctl --user restart {service} exited {status}" + "systemctl --user restart {service} could not leave deactivating state" )); } - Ok(()) + enable_now(service).await } /// Stop a generated Quadlet service without removing its unit file. pub async fn stop_service(service: &str) -> Result<()> { - let status = Command::new("systemctl") - .args(["--user", "stop", service]) - .status() - .await - .with_context(|| format!("spawn systemctl --user stop {service}"))?; - if !status.success() { - return Err(anyhow!("systemctl --user stop {service} exited {status}")); + match systemctl_user_status(&["stop", service], QUADLET_STOP_TIMEOUT).await { + Ok(status) if status.success() => Ok(()), + Ok(status) => Err(anyhow!("systemctl --user stop {service} exited {status}")), + Err(err) => { + tracing::warn!( + service = %service, + error = %err, + "quadlet stop timed out/failed; killing app-scoped unit" + ); + kill_and_reset_service(service).await?; + if !wait_not_deactivating(service, Duration::from_secs(60)).await { + return Err(anyhow!( + "systemctl --user stop {service} remained deactivating after app-scoped kill" + )); + } + Ok(()) + } } +} + +async fn systemctl_user_status( + args: &[&str], + timeout: Duration, +) -> Result { + let mut cmd = Command::new("systemctl"); + cmd.arg("--user").args(args); + cmd.kill_on_drop(true); + tokio::time::timeout(timeout, cmd.status()) + .await + .with_context(|| { + format!( + "systemctl --user {} timed out after {}s", + args.join(" "), + timeout.as_secs() + ) + })? + .with_context(|| format!("spawn systemctl --user {}", args.join(" "))) +} + +async fn kill_and_reset_service(service: &str) -> Result<()> { + let _ = systemctl_user_status( + &["kill", "--kill-whom=all", "-s", "SIGKILL", service], + Duration::from_secs(15), + ) + .await; + tokio::time::sleep(Duration::from_secs(2)).await; + let _ = systemctl_user_status(&["reset-failed", service], Duration::from_secs(15)).await; Ok(()) } +async fn wait_not_deactivating(service: &str, timeout: Duration) -> bool { + let deadline = tokio::time::Instant::now() + timeout; + loop { + let Ok(status) = + systemctl_user_output(&["is-active", service], Duration::from_secs(5)).await + else { + return true; + }; + let state = String::from_utf8_lossy(&status.stdout).trim().to_string(); + if state != "deactivating" && state != "activating" { + return true; + } + if tokio::time::Instant::now() >= deadline { + return false; + } + tokio::time::sleep(Duration::from_secs(2)).await; + } +} + +async fn systemctl_user_output(args: &[&str], timeout: Duration) -> Result { + let mut cmd = Command::new("systemctl"); + cmd.arg("--user").args(args); + cmd.kill_on_drop(true); + tokio::time::timeout(timeout, cmd.output()) + .await + .with_context(|| { + format!( + "systemctl --user {} timed out after {}s", + args.join(" "), + timeout.as_secs() + ) + })? + .with_context(|| format!("spawn systemctl --user {}", args.join(" "))) +} + pub fn contains_stale_health_gate(unit_body: &str) -> bool { unit_body.contains("Notify=healthy") || unit_body.contains("TimeoutStartSec=600") @@ -579,6 +717,12 @@ pub fn contains_stale_health_gate(unit_body: &str) -> bool { pub fn health_cmd_changed(old_body: &str, new_body: &str) -> bool { directive_values(old_body, "HealthCmd=") != directive_values(new_body, "HealthCmd=") + || directive_values(old_body, "HealthInterval=") + != directive_values(new_body, "HealthInterval=") + || directive_values(old_body, "HealthTimeout=") + != directive_values(new_body, "HealthTimeout=") + || directive_values(old_body, "HealthRetries=") + != directive_values(new_body, "HealthRetries=") } pub fn publish_ports_changed(old_body: &str, new_body: &str) -> bool { @@ -588,9 +732,11 @@ pub fn publish_ports_changed(old_body: &str, new_body: &str) -> bool { } pub fn network_aliases_changed(old_body: &str, new_body: &str) -> bool { + let old_network = directive_values(old_body, "Network="); + let new_network = directive_values(new_body, "Network="); let old_aliases = directive_values(old_body, "NetworkAlias="); let new_aliases = directive_values(new_body, "NetworkAlias="); - old_aliases != new_aliases + old_network != new_network || old_aliases != new_aliases } pub fn exec_changed(old_body: &str, new_body: &str) -> bool { @@ -620,9 +766,11 @@ pub async fn disable_remove(unit_name: &str, dir: &Path) -> Result<()> { .await; let path = dir.join(format!("{unit_name}.container")); if fs::try_exists(&path).await.unwrap_or(false) { - fs::remove_file(&path) - .await - .with_context(|| format!("remove {}", path.display()))?; + match fs::remove_file(&path).await { + Ok(()) => {} + Err(err) if err.kind() == std::io::ErrorKind::NotFound => {} + Err(err) => return Err(err).with_context(|| format!("remove {}", path.display())), + } } daemon_reload_user().await.ok(); // Defensive: kill the actual container too, in case quadlet left it. @@ -957,6 +1105,48 @@ app: assert!(!s.contains("Network=host")); } + #[test] + fn from_manifest_slirp4netns_omits_network_alias() { + let yaml = r#" +app: + id: vaultwarden + name: Vaultwarden + version: 1.0.0 + container: + image: registry/vaultwarden:1 + network: slirp4netns + security: + network_policy: isolated +"#; + let m = AppManifest::parse(yaml).expect("manifest must parse"); + let s = QuadletUnit::from_manifest(&m, "vaultwarden").render(); + + assert!(s.contains("Network=slirp4netns")); + assert!(!s.contains("NetworkAlias=")); + assert!(!s.contains("--network-alias")); + } + + #[test] + fn from_manifest_pasta_omits_network_alias() { + let yaml = r#" +app: + id: nextcloud + name: Nextcloud + version: 1.0.0 + container: + image: registry/nextcloud:1 + network: pasta + security: + network_policy: isolated +"#; + let m = AppManifest::parse(yaml).expect("manifest must parse"); + let s = QuadletUnit::from_manifest(&m, "nextcloud").render(); + + assert!(s.contains("Network=pasta")); + assert!(!s.contains("NetworkAlias=")); + assert!(!s.contains("--network-alias")); + } + #[test] fn from_manifest_preserves_grafana_data_uid_and_volume_shape() { let yaml = r#" @@ -1056,18 +1246,20 @@ app: assert!(s.contains("HealthRetries=3")); assert!(!s.contains("Notify=healthy")); assert!(!s.contains("TimeoutStartSec=600")); + assert!(s.contains("TimeoutStartSec=0")); } #[test] fn render_skips_health_directives_when_absent() { - // No health spec → no Notify=healthy, no HealthCmd, no TimeoutStartSec - // override. Companions rely on this so their rendered bytes stay - // unchanged. + // No health spec → no Notify=healthy and no HealthCmd. TimeoutStartSec=0 + // is a service-level baseline so dependency-waiting apps are not killed + // by systemd before their app daemon binds. let s = sample_unit().render(); assert!(!s.contains("HealthCmd=")); assert!(!s.contains("Notify=healthy")); assert!(!s.contains("HealthRetries=")); - assert!(!s.contains("TimeoutStartSec=")); + assert!(s.contains("TimeoutStartSec=0")); + assert!(!s.contains("TimeoutStartSec=600")); } #[test] @@ -1094,7 +1286,7 @@ app: let h = translate_health_check(&http).expect("http must translate"); assert_eq!( h.cmd, - "if command -v wget >/dev/null 2>&1; then wget -q -T 5 -O /dev/null http://localhost:8080/health; elif command -v curl >/dev/null 2>&1; then curl -fsS -m 5 http://localhost:8080/health; else exit 0; fi" + "if command -v wget >/dev/null 2>&1; then wget -q -T 3 -O /dev/null http://localhost:8080/health; elif command -v curl >/dev/null 2>&1; then curl -fsS -m 3 http://localhost:8080/health; else exit 0; fi" ); let cmdck = HealthCheck { @@ -1163,6 +1355,25 @@ app: assert!(h.cmd.contains("https://example.local/health")); } + #[test] + fn translate_health_check_http_uses_manifest_timeout_for_helpers() { + use archipelago_container::HealthCheck; + let http = HealthCheck { + check_type: "http".into(), + endpoint: Some("localhost:3000".into()), + path: Some("/api/health".into()), + interval: "30s".into(), + timeout: "30s".into(), + retries: 5, + }; + + let h = translate_health_check(&http).expect("http must translate"); + assert!(h.cmd.contains("wget -q -T 30 "), "got: {}", h.cmd); + assert!(h.cmd.contains("curl -fsS -m 30 "), "got: {}", h.cmd); + assert_eq!(h.timeout, "30s"); + assert_eq!(h.retries, 5); + } + #[test] fn from_manifest_picks_up_health_check() { let yaml = r#" @@ -1201,6 +1412,14 @@ app: assert!(!network_aliases_changed(new, new)); } + #[test] + fn network_aliases_changed_detects_network_mode_drift() { + let old = "[Container]\nNetwork=slirp4netns\n"; + let new = "[Container]\n"; + assert!(network_aliases_changed(old, new)); + assert!(!network_aliases_changed(new, new)); + } + #[test] fn shell_join_escapes_dollars_for_container_runtime_expansion() { let rendered = shell_join(&["sh".into(), "-lc".into(), "echo ${BITCOIN_RPC_PASS}".into()]); @@ -1223,6 +1442,14 @@ app: assert!(!health_cmd_changed(new, new)); } + #[test] + fn health_cmd_changed_detects_probe_timing_drift() { + let old = "[Container]\nHealthCmd=curl -fsS http://localhost:8080/\nHealthTimeout=5s\nHealthRetries=3\n"; + let new = "[Container]\nHealthCmd=curl -fsS http://localhost:8080/\nHealthTimeout=30s\nHealthRetries=5\n"; + assert!(health_cmd_changed(old, new)); + assert!(!health_cmd_changed(new, new)); + } + #[test] fn from_manifest_renders_to_a_systemd_unit() { // End-to-end: parse a real-shape manifest, build the unit, render diff --git a/core/archipelago/src/crash_recovery.rs b/core/archipelago/src/crash_recovery.rs index fd74f26a..56f3f391 100644 --- a/core/archipelago/src/crash_recovery.rs +++ b/core/archipelago/src/crash_recovery.rs @@ -334,6 +334,103 @@ fn is_process_running(pid: u32) -> bool { /// The crash recovery (PID-based) handles dirty shutdowns; this handles clean ones. /// Skips containers that the user intentionally stopped via the UI. pub async fn start_stopped_containers(data_dir: &Path) -> RecoveryReport { + start_stopped_containers_for(data_dir, false).await +} + +/// Start stopped multi-container stack members after the backend is already +/// ready. These can take minutes after a reboot, so they must not block +/// systemd readiness. +pub async fn start_stopped_stack_containers(data_dir: &Path) -> RecoveryReport { + start_stopped_app_stacks(data_dir).await +} + +async fn start_stopped_app_stacks(data_dir: &Path) -> RecoveryReport { + let user_stopped = load_user_stopped(data_dir).await; + let mut report = RecoveryReport { + total: 0, + recovered: 0, + failed: Vec::new(), + }; + + for stack in stack_recovery_specs() { + if !stack_has_any_container(stack).await { + continue; + } + + info!( + "Recovering stopped {} stack containers after boot", + stack.name + ); + repair_stack_network_aliases(stack).await; + + for container in stack.containers { + if user_stopped.contains(*container) { + info!("Skipping user-stopped container: {}", container); + continue; + } + + match container_state(container).await { + Some(state) if state == "running" => continue, + Some(_) => {} + None => continue, + } + + repair_stack_network_aliases(stack).await; + wait_before_stack_container_recovery(stack, container).await; + + report.total += 1; + if start_existing_container(container).await { + report.recovered += 1; + } else { + report.failed.push((*container).to_string()); + } + } + } + + report +} + +async fn wait_before_stack_container_recovery(stack: &StackRecoverySpec, container: &str) { + if stack.name != "indeedhub" || container != "indeedhub" { + return; + } + + for _ in 0..60 { + if indeedhub_recovery_dependencies_running().await { + repair_stack_network_aliases(stack).await; + break; + } + tokio::time::sleep(Duration::from_secs(2)).await; + } + + for _ in 0..60 { + let ready = podman_output( + &["exec", "indeedhub-api", "getent", "hosts", "minio"], + Duration::from_secs(5), + ) + .await + .map(|output| output.status.success()) + .unwrap_or(false); + if ready { + return; + } + tokio::time::sleep(Duration::from_secs(2)).await; + } +} + +async fn indeedhub_recovery_dependencies_running() -> bool { + for name in ["indeedhub-redis", "indeedhub-minio", "indeedhub-api"] { + if container_state(name).await.as_deref() != Some("running") { + return false; + } + } + true +} + +async fn start_stopped_containers_for( + data_dir: &Path, + include_stack_members: bool, +) -> RecoveryReport { let mut cmd = tokio::process::Command::new("podman"); cmd.args([ "ps", @@ -400,7 +497,7 @@ pub async fn start_stopped_containers(data_dir: &Path) -> RecoveryReport { let names: Vec = names .into_iter() - .filter(|n| should_auto_start_stopped_container(n)) + .filter(|n| should_auto_start_stopped_container(n, include_stack_members)) .collect(); if names.is_empty() { @@ -429,11 +526,276 @@ pub async fn start_stopped_containers(data_dir: &Path) -> RecoveryReport { recover_containers(&records).await } -fn should_auto_start_stopped_container(name: &str) -> bool { +fn should_auto_start_stopped_container(name: &str, include_stack_members: bool) -> bool { // Keep generic boot recovery narrow. The Rust manifest reconciler owns // managed app stacks; starting every exited Podman container here races // it and resurrects legacy/orphan helper containers. - matches!(name, "filebrowser" | "nostr-rs-relay") + if matches!(name, "filebrowser" | "nostr-rs-relay") { + return true; + } + include_stack_members + && matches!( + name, + "immich_postgres" + | "immich_redis" + | "immich_server" + | "indeedhub-postgres" + | "indeedhub-redis" + | "indeedhub-minio" + | "indeedhub-relay" + | "indeedhub-api" + | "indeedhub-ffmpeg" + | "indeedhub" + | "netbird-server" + | "netbird-dashboard" + | "netbird" + | "saleor-db" + | "saleor-cache" + | "saleor-jaeger" + | "saleor-mailpit" + | "saleor-api" + | "saleor-worker" + | "saleor" + | "saleor-storefront" + | "saleor-storefront-app" + ) +} + +struct StackRecoverySpec { + name: &'static str, + network: &'static str, + aliases: &'static [(&'static str, &'static str)], + containers: &'static [&'static str], +} + +fn stack_recovery_specs() -> &'static [StackRecoverySpec] { + &[ + StackRecoverySpec { + name: "immich", + network: "immich-net", + aliases: &[ + ("immich_postgres", "immich_postgres"), + ("immich_redis", "immich_redis"), + ("immich_server", "immich_server"), + ], + containers: &["immich_postgres", "immich_redis", "immich_server"], + }, + StackRecoverySpec { + name: "indeedhub", + network: "indeedhub-net", + aliases: &[ + ("indeedhub-postgres", "postgres"), + ("indeedhub-redis", "redis"), + ("indeedhub-minio", "minio"), + ("indeedhub-relay", "relay"), + ("indeedhub-api", "api"), + ("indeedhub", "indeedhub"), + ], + containers: &[ + "indeedhub-postgres", + "indeedhub-redis", + "indeedhub-minio", + "indeedhub-relay", + "indeedhub-api", + "indeedhub-ffmpeg", + "indeedhub", + ], + }, + StackRecoverySpec { + name: "netbird", + network: "netbird-net", + aliases: &[ + ("netbird-server", "netbird-server"), + ("netbird-dashboard", "netbird-dashboard"), + ("netbird", "netbird"), + ], + containers: &["netbird-server", "netbird-dashboard", "netbird"], + }, + StackRecoverySpec { + name: "saleor", + network: "saleor-net", + aliases: &[ + ("saleor-db", "db"), + ("saleor-cache", "cache"), + ("saleor-jaeger", "jaeger"), + ("saleor-mailpit", "mailpit"), + ("saleor-api", "api"), + ("saleor-worker", "worker"), + ("saleor", "saleor"), + ("saleor-storefront", "storefront"), + ("saleor-storefront-app", "storefront-app"), + ], + containers: &[ + "saleor-db", + "saleor-cache", + "saleor-jaeger", + "saleor-mailpit", + "saleor-api", + "saleor-worker", + "saleor", + "saleor-storefront", + "saleor-storefront-app", + ], + }, + ] +} + +async fn stack_has_any_container(stack: &StackRecoverySpec) -> bool { + for container in stack.containers { + if container_state(container).await.is_some() { + return true; + } + } + false +} + +async fn repair_stack_network_aliases(stack: &StackRecoverySpec) { + let _ = podman_status( + &["network", "create", stack.network], + Duration::from_secs(15), + ) + .await; + + for (container, alias) in stack.aliases { + if container_state(container).await.is_none() { + continue; + } + if network_alias_present(stack.network, container, alias).await { + continue; + } + + let _ = podman_status( + &["network", "disconnect", "-f", stack.network, container], + Duration::from_secs(15), + ) + .await; + let _ = podman_status( + &[ + "network", + "connect", + "--alias", + alias, + stack.network, + container, + ], + Duration::from_secs(15), + ) + .await; + } +} + +async fn network_alias_present(network_name: &str, container: &str, alias: &str) -> bool { + let output = match podman_output( + &[ + "inspect", + container, + "--format", + "{{json .NetworkSettings.Networks}}", + ], + Duration::from_secs(10), + ) + .await + { + Ok(output) if output.status.success() => output, + _ => return false, + }; + + let Ok(networks) = serde_json::from_slice::(&output.stdout) else { + return false; + }; + networks + .get(network_name) + .and_then(|network| network.get("Aliases")) + .and_then(|aliases| aliases.as_array()) + .map(|aliases| aliases.iter().any(|value| value.as_str() == Some(alias))) + .unwrap_or(false) +} + +async fn container_state(container: &str) -> Option { + let output = podman_output( + &["inspect", container, "--format", "{{.State.Status}}"], + Duration::from_secs(10), + ) + .await + .ok()?; + output + .status + .success() + .then(|| String::from_utf8_lossy(&output.stdout).trim().to_string()) +} + +async fn start_existing_container(container: &str) -> bool { + info!("Recovering stack container: {}", container); + let timeout = match container { + "immich_server" | "netbird-server" => Duration::from_secs(120), + _ => Duration::from_secs(90), + }; + if container_state(container).await.as_deref() == Some("initialized") { + cleanup_container_runtime_state(container).await; + } + match podman_output(&["start", container], timeout).await { + Ok(output) if output.status.success() => { + tokio::time::sleep(Duration::from_secs(3)).await; + if container_state(container).await.as_deref() == Some("exited") { + warn!("Stack container {} exited shortly after start", container); + false + } else { + info!("Successfully recovered stack container: {}", container); + true + } + } + Ok(output) => { + let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string(); + if stderr.contains("exec.fifo") || stderr.contains("failed to start container") { + cleanup_container_runtime_state(container).await; + if let Ok(retry) = podman_output(&["start", container], timeout).await { + if retry.status.success() { + info!( + "Successfully recovered stack container after cleanup: {}", + container + ); + return true; + } + warn!( + "Failed to recover stack container {} after cleanup: {}", + container, + String::from_utf8_lossy(&retry.stderr).trim() + ); + return false; + } + } + warn!( + "Failed to recover stack container {}: {}", + container, stderr + ); + false + } + Err(e) => { + warn!("Failed to recover stack container {}: {}", container, e); + false + } + } +} + +async fn cleanup_container_runtime_state(container: &str) { + let _ = podman_output( + &["container", "cleanup", container], + Duration::from_secs(30), + ) + .await; +} + +async fn podman_status(args: &[&str], timeout: Duration) -> Option { + podman_output(args, timeout) + .await + .ok() + .map(|output| output.status) +} + +async fn podman_output(args: &[&str], timeout: Duration) -> Result { + let mut cmd = tokio::process::Command::new("podman"); + cmd.args(args); + command_with_timeout(cmd, timeout, &format!("podman {}", args.join(" "))).await } /// Simple tier ordering for boot recovery (mirrors health_monitor tiers). @@ -620,10 +982,17 @@ mod tests { #[test] fn generic_boot_recovery_skips_manifest_owned_and_legacy_stacks() { - assert!(should_auto_start_stopped_container("filebrowser")); - assert!(should_auto_start_stopped_container("nostr-rs-relay")); - assert!(!should_auto_start_stopped_container("bitcoin-knots")); - assert!(!should_auto_start_stopped_container("lnd")); - assert!(!should_auto_start_stopped_container("indeedhub-postgres")); + assert!(should_auto_start_stopped_container("filebrowser", false)); + assert!(should_auto_start_stopped_container("nostr-rs-relay", false)); + assert!(!should_auto_start_stopped_container("bitcoin-knots", false)); + assert!(!should_auto_start_stopped_container("lnd", false)); + assert!(!should_auto_start_stopped_container( + "indeedhub-postgres", + false + )); + assert!(should_auto_start_stopped_container( + "indeedhub-postgres", + true + )); } } diff --git a/core/archipelago/src/electrs_status.rs b/core/archipelago/src/electrs_status.rs index c046637c..f84b4693 100644 --- a/core/archipelago/src/electrs_status.rs +++ b/core/archipelago/src/electrs_status.rs @@ -17,7 +17,8 @@ const ELECTRUMX_DATA_DIR: &str = "/var/lib/archipelago/electrumx"; const ESTIMATED_FULL_INDEX_BYTES: f64 = 130_000_000_000.0; /// Refresh interval for status cache -const CACHE_REFRESH_SECS: u64 = 15; +const CACHE_REFRESH_SECS: u64 = 30; +const CACHE_ERROR_BACKOFF_SECS: u64 = 60; /// Build Bitcoin RPC Basic auth header using shared credentials. async fn bitcoin_rpc_auth() -> String { @@ -70,6 +71,11 @@ pub fn spawn_status_cache() { tokio::spawn(async { loop { let mut fresh = fetch_electrs_sync_status().await; + let sleep_secs = if fresh.status == "waiting" && fresh.bitcoin_height == 0 { + CACHE_ERROR_BACKOFF_SECS + } else { + CACHE_REFRESH_SECS + }; let mut cached = cache().write().await; if fresh.indexed_height == 0 && cached.indexed_height > 0 @@ -92,7 +98,7 @@ pub fn spawn_status_cache() { } *cached = fresh; drop(cached); - tokio::time::sleep(Duration::from_secs(CACHE_REFRESH_SECS)).await; + tokio::time::sleep(Duration::from_secs(sleep_secs)).await; } }); } @@ -146,6 +152,8 @@ fn is_transient_error(err_msg: &str) -> bool { || lower.contains("broken pipe") || lower.contains("eof") || lower.contains("connection") + || lower.contains("503 service unavailable") + || lower.contains("work queue depth exceeded") } /// Fetch ElectrumX indexed height via Electrum protocol (TCP JSON-RPC). diff --git a/core/archipelago/src/health_monitor.rs b/core/archipelago/src/health_monitor.rs index c37fc3ff..5bbeeb3a 100644 --- a/core/archipelago/src/health_monitor.rs +++ b/core/archipelago/src/health_monitor.rs @@ -217,6 +217,7 @@ struct ContainerHealth { app_id: String, state: String, podman_health: Option, + host_port_ready: Option, healthy: bool, } @@ -427,42 +428,92 @@ async fn check_containers() -> Vec { // nbxplorer, mempool-api) and UI containers need auto-restart too. // Only skip ephemeral containers (build infrastructure, init one-shots). - containers - .iter() - .filter_map(|c| { - let name = c.get("Names").and_then(|v| { - if let Some(arr) = v.as_array() { - arr.first().and_then(|n| n.as_str()).map(|s| s.to_string()) - } else { - v.as_str().map(|s| s.to_string()) - } - })?; - - // Skip podman-compose infrastructure and one-shot init containers - if name.starts_with("indeedhub-build_") || name.contains("-init") { - return None; + let mut out = Vec::new(); + for c in &containers { + let name = c.get("Names").and_then(|v| { + if let Some(arr) = v.as_array() { + arr.first().and_then(|n| n.as_str()).map(|s| s.to_string()) + } else { + v.as_str().map(|s| s.to_string()) } + }); + let Some(name) = name else { + continue; + }; - let app_id = name.strip_prefix("archy-").unwrap_or(&name).to_string(); + // Skip podman-compose infrastructure and one-shot init containers + if name.starts_with("indeedhub-build_") || name.contains("-init") { + continue; + } - let state = c - .get("State") + let app_id = name.strip_prefix("archy-").unwrap_or(&name).to_string(); + + let state = c + .get("State") + .and_then(|v| v.as_str()) + .unwrap_or("unknown") + .to_lowercase(); + + let podman_health = parse_podman_health(c, &state); + let host_ports = host_tcp_ports_from_container(c); + let host_port_ready = if host_ports.is_empty() { + None + } else { + Some(host_ports_ready(&host_ports).await) + }; + let healthy = state == "running" + && podman_health.as_deref() != Some("unhealthy") + && host_port_ready != Some(false); + + out.push(ContainerHealth { + name, + app_id, + state, + podman_health, + host_port_ready, + healthy, + }); + } + out +} + +fn host_tcp_ports_from_container(c: &serde_json::Value) -> Vec { + let Some(ports) = c.get("Ports").and_then(|v| v.as_array()) else { + return Vec::new(); + }; + + let mut out: Vec = ports + .iter() + .filter(|p| { + p.get("protocol") .and_then(|v| v.as_str()) - .unwrap_or("unknown") - .to_lowercase(); - - let podman_health = parse_podman_health(c, &state); - let healthy = state == "running" && podman_health.as_deref() != Some("unhealthy"); - - Some(ContainerHealth { - name, - app_id, - state, - podman_health, - healthy, - }) + .unwrap_or("tcp") + .eq_ignore_ascii_case("tcp") }) - .collect() + .filter_map(|p| { + p.get("host_port") + .and_then(|v| v.as_u64()) + .and_then(|port| u16::try_from(port).ok()) + }) + .collect(); + out.sort_unstable(); + out.dedup(); + out +} + +async fn host_ports_ready(ports: &[u16]) -> bool { + for port in ports { + let ready = tokio::time::timeout( + std::time::Duration::from_secs(2), + tokio::net::TcpStream::connect(("127.0.0.1", *port)), + ) + .await + .is_ok_and(|r| r.is_ok()); + if !ready { + return false; + } + } + true } fn live_container_ids(containers: &[serde_json::Value]) -> HashSet { @@ -640,33 +691,41 @@ fn parse_health_from_status(status: &str) -> Option { (start < end).then(|| status[start + 1..end].to_string()) } -/// Try to restart a container. -async fn restart_container(name: &str) -> bool { - info!("Auto-restarting unhealthy container: {}", name); +/// Try to recover a container. Running containers need a real restart so +/// rootless network helpers such as pasta are recreated; `podman start` is a +/// no-op for a running container with a missing host listener. +async fn restart_container(name: &str, state: &str) -> bool { + let action = if state == "running" { + "restart" + } else { + "start" + }; + info!("Auto-{}ing unhealthy container: {}", action, name); let result = tokio::time::timeout( std::time::Duration::from_secs(120), - tokio::process::Command::new("podman") - .args(["start", name]) + tokio::process::Command::new("systemd-run") + .args(["--user", "--scope", "--quiet", "--collect", "podman"]) + .args([action, name]) .output(), ) .await; match result { Ok(Ok(output)) if output.status.success() => { - info!("Successfully restarted container: {}", name); + info!("Successfully recovered container: {}", name); true } Ok(Ok(output)) => { let stderr = String::from_utf8_lossy(&output.stderr); - warn!("Failed to restart container {}: {}", name, stderr.trim()); + warn!("Failed to {} container {}: {}", action, name, stderr.trim()); false } Ok(Err(e)) => { - warn!("Failed to execute podman start for {}: {}", name, e); + warn!("Failed to execute podman {} for {}: {}", action, name, e); false } Err(_) => { - warn!("Timeout starting container {} (120s)", name); + warn!("Timeout {}ing container {} (120s)", action, name); false } } @@ -684,9 +743,10 @@ pub fn spawn_health_monitor(state: Arc, data_dir: PathBuf) { if crate::crash_recovery::is_recovery_complete() { break; } - // Safety timeout: start anyway after 5 minutes even if recovery hangs - if wait_start.elapsed().as_secs() > 300 { - warn!("Health monitor: boot recovery did not complete within 5 minutes, starting anyway"); + // Safety timeout: start anyway after 30 minutes even if recovery hangs. + // Stack recovery can take many minutes on low-resource nodes after reboot. + if wait_start.elapsed().as_secs() > 1800 { + warn!("Health monitor: boot recovery did not complete within 30 minutes, starting anyway"); break; } tokio::time::sleep(std::time::Duration::from_secs(5)).await; @@ -827,6 +887,7 @@ pub fn spawn_health_monitor(state: Arc, data_dir: PathBuf) { } // Handle exited, stopped, created, and Podman-unhealthy running containers. if container.podman_health.as_deref() == Some("unhealthy") + || container.host_port_ready == Some(false) || container.state == "exited" || container.state == "stopped" || container.state == "created" @@ -932,7 +993,7 @@ pub fn spawn_health_monitor(state: Arc, data_dir: PathBuf) { .unwrap_or(&90) ); - let restarted = restart_container(&container.name).await; + let restarted = restart_container(&container.name, &container.state).await; if !restarted || attempt >= MAX_RESTART_ATTEMPTS { let notification = Notification { @@ -1088,6 +1149,7 @@ mod tests { app_id: "bitcoin-knots".to_string(), state: "running".to_string(), podman_health: Some("healthy".to_string()), + host_port_ready: None, healthy: true, }; assert!(health.healthy); @@ -1103,6 +1165,7 @@ mod tests { app_id: "mempool-web".to_string(), state: "exited".to_string(), podman_health: None, + host_port_ready: None, healthy: false, }; assert!(!health.healthy); @@ -1193,6 +1256,7 @@ mod tests { app_id: "indeedhub-postgres".into(), state: "running".into(), podman_health: None, + host_port_ready: None, healthy: true, }, ContainerHealth { @@ -1200,6 +1264,7 @@ mod tests { app_id: "indeedhub-redis".into(), state: "running".into(), podman_health: None, + host_port_ready: None, healthy: true, }, ContainerHealth { @@ -1207,6 +1272,7 @@ mod tests { app_id: "indeedhub-api".into(), state: "exited".into(), podman_health: None, + host_port_ready: None, healthy: false, }, ]; @@ -1217,6 +1283,7 @@ mod tests { app_id: "indeedhub-redis".into(), state: "running".into(), podman_health: None, + host_port_ready: None, healthy: true, }]; assert!(!deps_are_running("indeedhub-api", &partial)); @@ -1229,6 +1296,7 @@ mod tests { app_id: "bitcoin-core".into(), state: "running".into(), podman_health: None, + host_port_ready: None, healthy: true, }]; assert!(deps_are_running("lnd", &core)); @@ -1238,6 +1306,7 @@ mod tests { app_id: "bitcoin-knots".into(), state: "running".into(), podman_health: None, + host_port_ready: None, healthy: true, }]; assert!(deps_are_running("fedimint", &knots)); @@ -1247,6 +1316,7 @@ mod tests { app_id: "bitcoin-core".into(), state: "stopped".into(), podman_health: None, + host_port_ready: None, healthy: false, }]; assert!(!deps_are_running("electrumx", &stopped)); @@ -1259,6 +1329,7 @@ mod tests { app_id: "bitcoin-core".into(), state: "running".into(), podman_health: None, + host_port_ready: None, healthy: true, }]; @@ -1274,6 +1345,7 @@ mod tests { app_id: "bitcoin-core".into(), state: "stopped".into(), podman_health: None, + host_port_ready: None, healthy: false, }]; diff --git a/core/archipelago/src/main.rs b/core/archipelago/src/main.rs index d534f936..93e24bdd 100644 --- a/core/archipelago/src/main.rs +++ b/core/archipelago/src/main.rs @@ -20,6 +20,7 @@ use anyhow::{Context, Result}; use std::net::SocketAddr; use std::sync::Arc; +use std::time::Duration; use tokio::signal; use tokio::sync::Notify; use tracing::info; @@ -168,8 +169,6 @@ async fn main() -> Result<()> { boot_report.recovered, boot_report.total, boot_report.failed ); } - crash_recovery::mark_recovery_complete(); - // Construct the container orchestrator once. In prod mode we load the // on-disk app manifests, do an initial adoption pass, and spawn the // BootReconciler loop (Step 5/6 of the rust-orchestrator migration). @@ -195,17 +194,20 @@ async fn main() -> Result<()> { } // Adoption pass: link existing podman containers back to their // manifests so the reconciler doesn't recreate them. - match prod.adopt_existing().await { - Ok(report) => { + match tokio::time::timeout(Duration::from_secs(35), prod.adopt_existing()).await { + Ok(Ok(report)) => { info!( "🔗 Adopted {} existing container(s): {:?}", report.adopted.len(), report.adopted ); } - Err(e) => { + Ok(Err(e)) => { tracing::warn!(error = %e, "prod orchestrator: adopt_existing failed (non-fatal)"); } + Err(_) => { + tracing::warn!("prod orchestrator: adopt_existing timed out after 35s (non-fatal)") + } } // Spawn the boot reconciler loop. Runs an initial reconcile // immediately, then re-checks every RECONCILER_DEFAULT_INTERVAL @@ -272,6 +274,23 @@ async fn main() -> Result<()> { // Spawn periodic container snapshot (for crash recovery) crash_recovery::spawn_snapshot_task(config.data_dir.clone()); + // Recover stopped multi-container stack members after the backend is up. + // This can take minutes on busy nodes after a reboot, so keep it out of + // the synchronous systemd startup path. + { + let data_dir = config.data_dir.clone(); + tokio::spawn(async move { + let report = crash_recovery::start_stopped_stack_containers(&data_dir).await; + if report.total > 0 { + info!( + "🔄 Stack boot recovery: {}/{} containers started (failed: {:?})", + report.recovered, report.total, report.failed + ); + } + crash_recovery::mark_recovery_complete(); + }); + } + // Spawn disk space monitor (warns at 85%, auto-cleans at 90%) disk_monitor::spawn_disk_monitor(config.data_dir.clone()); diff --git a/core/archipelago/src/monitoring/notifications.rs b/core/archipelago/src/monitoring/notifications.rs index 45cccac1..6fdf478b 100644 --- a/core/archipelago/src/monitoring/notifications.rs +++ b/core/archipelago/src/monitoring/notifications.rs @@ -1,15 +1,20 @@ use crate::monitoring::types::{AlertRuleKind, FiredAlert}; use crate::webhooks::{self, WebhookEvent, WebhookPayload}; +use chrono::Utc; +use std::collections::HashSet; use std::path::Path; use std::sync::Arc; use tracing::info; +const NOTIFICATION_MAX_AGE_SECS: i64 = 30 * 60; + /// Push fired alerts as notifications to the state manager (broadcast via WebSocket). pub(crate) async fn push_alert_notifications( state_mgr: &Arc, alerts: &[FiredAlert], ) { let (mut data, _rev) = state_mgr.get_snapshot().await; + prune_stale_alert_notifications(&mut data.notifications, alerts); for alert in alerts { let level = match alert.kind { AlertRuleKind::DiskUsage | AlertRuleKind::RamUsage => { @@ -27,7 +32,7 @@ pub(crate) async fn push_alert_notifications( level, title: format!("{:?} Alert", alert.kind), message: alert.message.clone(), - timestamp: chrono::Utc::now().to_rfc3339(), + timestamp: Utc::now().to_rfc3339(), app_id: None, }; data.notifications.push(notification); @@ -40,6 +45,30 @@ pub(crate) async fn push_alert_notifications( info!("Fired {} alert(s)", alerts.len()); } +fn prune_stale_alert_notifications( + notifications: &mut Vec, + alerts: &[FiredAlert], +) { + let now = Utc::now(); + let active_ids: HashSet<&str> = alerts.iter().map(|alert| alert.id.as_str()).collect(); + notifications.retain(|notification| { + if active_ids.contains(notification.id.as_str()) { + return false; + } + if notification.app_id.is_some() || notification.id.starts_with("health-") { + return true; + } + match chrono::DateTime::parse_from_rfc3339(¬ification.timestamp) { + Ok(ts) => { + now.signed_duration_since(ts.with_timezone(&Utc)) + .num_seconds() + <= NOTIFICATION_MAX_AGE_SECS + } + Err(_) => false, + } + }); +} + /// Deliver webhook notifications for alerts that map to webhook events. pub(crate) async fn deliver_alert_webhooks(data_dir: &Path, alerts: &[FiredAlert]) { for alert in alerts { @@ -53,7 +82,7 @@ pub(crate) async fn deliver_alert_webhooks(data_dir: &Path, alerts: &[FiredAlert event, title: format!("{:?} Alert", alert.kind), message: alert.message.clone(), - timestamp: chrono::Utc::now().to_rfc3339(), + timestamp: Utc::now().to_rfc3339(), node_id: String::new(), details: Some(serde_json::json!({ "value": alert.value, @@ -64,3 +93,46 @@ pub(crate) async fn deliver_alert_webhooks(data_dir: &Path, alerts: &[FiredAlert } } } + +#[cfg(test)] +mod tests { + use super::*; + use crate::data_model::{Notification, NotificationLevel}; + + fn notification(id: &str, timestamp: String, app_id: Option<&str>) -> Notification { + Notification { + id: id.to_string(), + level: NotificationLevel::Warning, + title: "DiskUsage Alert".to_string(), + message: "Disk warning".to_string(), + timestamp, + app_id: app_id.map(str::to_string), + } + } + + #[test] + fn prune_stale_alert_notifications_removes_duplicate_and_old_generic_alerts() { + let active_alert = FiredAlert { + id: "alert-active".to_string(), + kind: AlertRuleKind::DiskUsage, + message: "Disk warning".to_string(), + value: 90.0, + threshold: 85.0, + timestamp: Utc::now().timestamp(), + acknowledged: false, + }; + let old_timestamp = (Utc::now() - chrono::Duration::minutes(45)).to_rfc3339(); + let fresh_timestamp = (Utc::now() - chrono::Duration::minutes(5)).to_rfc3339(); + let mut notifications = vec![ + notification("alert-active", fresh_timestamp.clone(), None), + notification("alert-old", old_timestamp, None), + notification("alert-fresh", fresh_timestamp.clone(), None), + notification("health-indeedhub-1", fresh_timestamp, Some("indeedhub")), + ]; + + prune_stale_alert_notifications(&mut notifications, &[active_alert]); + + let ids: Vec<&str> = notifications.iter().map(|n| n.id.as_str()).collect(); + assert_eq!(ids, vec!["alert-fresh", "health-indeedhub-1"]); + } +} diff --git a/core/archipelago/src/monitoring/telemetry.rs b/core/archipelago/src/monitoring/telemetry.rs index 0b1c4482..2cc1a6ce 100644 --- a/core/archipelago/src/monitoring/telemetry.rs +++ b/core/archipelago/src/monitoring/telemetry.rs @@ -71,30 +71,49 @@ async fn build_telemetry_report( data_dir: &std::path::Path, ) -> anyhow::Result { // Anonymous node ID — truncated SHA-256 hash of pubkey - let (node_id, version, container_count, running_count, peer_count) = if let Some(ref sm) = state - { - let (data, _) = sm.get_snapshot().await; - let id = { - use sha2::{Digest, Sha256}; - let mut h = Sha256::new(); - h.update(data.server_info.pubkey.as_bytes()); - hex::encode(h.finalize())[..16].to_string() + let (node_id, version, container_count, running_count, peer_count, containers) = + if let Some(ref sm) = state { + let (data, _) = sm.get_snapshot().await; + let id = { + use sha2::{Digest, Sha256}; + let mut h = Sha256::new(); + h.update(data.server_info.pubkey.as_bytes()); + hex::encode(h.finalize())[..16].to_string() + }; + let containers: Vec = data + .package_data + .iter() + .map(|(id, pkg)| { + serde_json::json!({ + "id": id, + "state": format!("{:?}", pkg.state), + "version": pkg.manifest.version, + }) + }) + .collect(); + let running = data + .package_data + .values() + .filter(|p| matches!(p.state, crate::data_model::PackageState::Running)) + .count(); + ( + id, + data.server_info.version.clone(), + data.package_data.len(), + running, + data.peer_health.len(), + containers, + ) + } else { + ( + "unknown".to_string(), + "unknown".to_string(), + 0, + 0, + 0, + Vec::new(), + ) }; - let running = data - .package_data - .values() - .filter(|p| matches!(p.state, crate::data_model::PackageState::Running)) - .count(); - ( - id, - data.server_info.version.clone(), - data.package_data.len(), - running, - data.peer_health.len(), - ) - } else { - ("unknown".to_string(), "unknown".to_string(), 0, 0, 0) - }; // System info let cpu_cores = std::thread::available_parallelism() @@ -153,6 +172,7 @@ async fn build_telemetry_report( "cpu_pct": (cpu_pct * 10.0).round() / 10.0, "mem_pct": (mem_pct * 10.0).round() / 10.0, "disk_pct": (disk_pct * 10.0).round() / 10.0, + "containers": containers, "container_count": container_count, "running_count": running_count, "federation_peers": peer_count, @@ -166,16 +186,28 @@ async fn post_telemetry_report(url: &str, report: &serde_json::Value) -> anyhow: let client = reqwest::Client::builder() .timeout(std::time::Duration::from_secs(10)) .build()?; + let payload = serde_json::json!({ + "method": "telemetry.ingest", + "params": report, + }); let response = client .post(url) .header("Content-Type", "application/json") .header("User-Agent", "Archipelago-Telemetry/1.0") - .json(report) + .json(&payload) .send() .await?; if !response.status().is_success() { anyhow::bail!("Collector returned {}", response.status()); } + let status = response.status(); + let body: serde_json::Value = response.json().await.unwrap_or_default(); + if let Some(error) = body.get("error") { + anyhow::bail!("Collector RPC error: {}", error); + } + if body.get("result").is_none() { + anyhow::bail!("Collector returned {} without RPC result", status); + } Ok(()) } diff --git a/core/archipelago/src/server.rs b/core/archipelago/src/server.rs index 30eaa3d2..dc1cafbc 100644 --- a/core/archipelago/src/server.rs +++ b/core/archipelago/src/server.rs @@ -17,6 +17,7 @@ use std::collections::HashMap; use std::net::SocketAddr; use std::sync::Arc; use std::time::{Duration, Instant}; +use tokio::io::{AsyncReadExt, AsyncWriteExt}; use tokio::net::TcpListener; use tracing::{debug, error, info, warn}; @@ -331,6 +332,7 @@ impl Server { // lifecycle op, and to break out if the spawned task dies // without ever writing a final state. let mut transitional_since: HashMap = HashMap::new(); + let mut scan_backoff_until: Option = None; if let Err(e) = scan_and_update_packages( &scanner, &state, @@ -342,6 +344,10 @@ impl Server { .await { error!("Failed to scan containers: {}", e); + if is_podman_scan_timeout(&e) { + scan_backoff_until = Some(Instant::now() + Duration::from_secs(30)); + warn!("Podman container scan timed out; backing off scans for 30s"); + } } // Bump the scan-completion counter so any caller waiting on a // kicked scan (install/update success path) can proceed. @@ -364,8 +370,16 @@ impl Server { debug!("Scan kicked by install/update success — running immediately"); } } + if let Some(until) = scan_backoff_until { + if Instant::now() < until { + debug!("Skipping container scan — Podman scan backoff active"); + scan_tick.send_modify(|n| *n = n.wrapping_add(1)); + continue; + } + } if scanning.load(std::sync::atomic::Ordering::Relaxed) { debug!("Skipping container scan — previous scan still in progress"); + scan_tick.send_modify(|n| *n = n.wrapping_add(1)); continue; } scanning.store(true, std::sync::atomic::Ordering::Relaxed); @@ -380,6 +394,12 @@ impl Server { .await { error!("Failed to update containers: {}", e); + if is_podman_scan_timeout(&e) { + scan_backoff_until = Some(Instant::now() + Duration::from_secs(30)); + warn!("Podman container scan timed out; backing off scans for 30s"); + } + } else { + scan_backoff_until = None; } scan_tick.send_modify(|n| *n = n.wrapping_add(1)); scanning.store(false, std::sync::atomic::Ordering::Relaxed); @@ -847,10 +867,10 @@ const TRANSITIONAL_STUCK_TIMEOUT: Duration = Duration::from_secs(120); const INSTALLING_STUCK_TIMEOUT: Duration = Duration::from_secs(20 * 60); fn transitional_stuck_timeout(state: &crate::data_model::PackageState) -> Duration { - if *state == crate::data_model::PackageState::Installing { - INSTALLING_STUCK_TIMEOUT - } else { - TRANSITIONAL_STUCK_TIMEOUT + use crate::data_model::PackageState::*; + match state { + Installing | Starting | Restarting => INSTALLING_STUCK_TIMEOUT, + _ => TRANSITIONAL_STUCK_TIMEOUT, } } @@ -874,6 +894,18 @@ fn is_transitional(state: &crate::data_model::PackageState) -> bool { ) } +fn absent_transitional_replacement( + state: &crate::data_model::PackageState, +) -> Option { + match state { + // A stop operation is complete once the container record disappears. + // Do not leave the app card wedged in "Stopping..." just because the + // background task died or the backend restarted before it wrote back. + crate::data_model::PackageState::Stopping => Some(crate::data_model::PackageState::Stopped), + _ => None, + } +} + /// Merge a fresh scan entry `fresh` into `existing` while preserving /// `existing.state` (which is transitional — the RPC spawn task owns it). /// Non-state observability fields are taken from `fresh` so the UI still @@ -881,8 +913,17 @@ fn is_transitional(state: &crate::data_model::PackageState) -> bool { fn merge_preserving_transitional( existing: &crate::data_model::PackageDataEntry, fresh: &crate::data_model::PackageDataEntry, + user_stop_requested: bool, ) -> crate::data_model::PackageDataEntry { let state = match (&existing.state, &fresh.state) { + // A user-initiated stop must keep showing Stopping while podman still + // reports Running. Repair/restart transitions do not have a user-stop + // marker, so a fresh Running scan means the app recovered. + (crate::data_model::PackageState::Stopping, crate::data_model::PackageState::Running) + if !user_stop_requested => + { + fresh.state.clone() + } // Removing with a live running container is stale: uninstall either // failed or Archipelago restarted before the spawned task could revert // state. Let the scanner recover the UI immediately instead of @@ -909,6 +950,11 @@ fn merge_preserving_transitional( } } +fn is_podman_scan_timeout(error: &anyhow::Error) -> bool { + let msg = format!("{:#}", error); + msg.contains("podman ps") && msg.contains("timed out") +} + async fn scan_and_update_packages( scanner: &DockerPackageScanner, state: &StateManager, @@ -925,6 +971,7 @@ async fn scan_and_update_packages( pkg.exit_code = None; } } + normalize_reachable_package_health(&mut packages).await; let (current_data, _) = state.get_snapshot().await; let tor_addr = docker_packages::read_tor_address("archipelago").await; @@ -992,7 +1039,11 @@ async fn scan_and_update_packages( // observability fields (health, exit_code, lan_address // via installed) from the fresh scan so the UI still // sees live readings. - let merged_entry = merge_preserving_transitional(existing_entry, pkg); + let merged_entry = merge_preserving_transitional( + existing_entry, + pkg, + user_stopped.contains(id), + ); if existing.cloned() != Some(merged_entry.clone()) { merged.insert(id.clone(), merged_entry); changed = true; @@ -1029,6 +1080,19 @@ async fn scan_and_update_packages( // owner (spawn_task) is responsible for clearing state, not us. if let Some(entry) = merged.get(&id) { if is_transitional(&entry.state) { + if let Some(replacement) = absent_transitional_replacement(&entry.state) { + let mut updated = entry.clone(); + updated.state = replacement; + updated.health = None; + updated.exit_code = None; + updated.install_progress = None; + updated.uninstall_stage = None; + merged.insert(id.clone(), updated); + transitional_since.remove(&id); + absence_tracker.remove(&id); + changed = true; + continue; + } let entered = *transitional_since.entry(id.clone()).or_insert(now); let timeout = transitional_stuck_timeout(&entry.state); if now.duration_since(entered) > timeout { @@ -1088,6 +1152,99 @@ async fn scan_and_update_packages( Ok(()) } +async fn normalize_reachable_package_health( + packages: &mut HashMap, +) { + for (id, pkg) in packages.iter_mut() { + if pkg.state != crate::data_model::PackageState::Running { + continue; + } + if !matches!(pkg.health.as_deref(), Some("starting" | "unhealthy" | "1")) { + continue; + } + let Some(port) = pkg + .installed + .as_ref() + .and_then(|i| i.interface_addresses.get("main")) + .and_then(|a| a.lan_address.as_deref()) + .and_then(port_from_url) + .or_else(|| fallback_package_port(id)) + else { + continue; + }; + if frontend_port_http_ready(port).await { + debug!(app_id = %id, port, "normalizing reachable package health to healthy"); + pkg.health = Some("healthy".to_string()); + ensure_main_lan_address(pkg, port); + } + } +} + +async fn frontend_port_http_ready(port: u16) -> bool { + let Ok(Ok(mut stream)) = tokio::time::timeout( + Duration::from_secs(2), + tokio::net::TcpStream::connect(("127.0.0.1", port)), + ) + .await + else { + return false; + }; + + let request = b"GET / HTTP/1.1\r\nHost: 127.0.0.1\r\nConnection: close\r\n\r\n"; + if stream.write_all(request).await.is_err() { + return false; + } + + let mut buf = [0u8; 64]; + let Ok(Ok(n)) = tokio::time::timeout(Duration::from_secs(2), stream.read(&mut buf)).await + else { + return false; + }; + if n == 0 { + return false; + } + + let head = String::from_utf8_lossy(&buf[..n]); + head.starts_with("HTTP/1.1 2") + || head.starts_with("HTTP/1.1 3") + || head.starts_with("HTTP/1.0 2") + || head.starts_with("HTTP/1.0 3") +} + +fn ensure_main_lan_address(pkg: &mut crate::data_model::PackageDataEntry, port: u16) { + let Some(installed) = pkg.installed.as_mut() else { + return; + }; + let main = installed + .interface_addresses + .entry("main".to_string()) + .or_insert_with(|| crate::data_model::InterfaceAddress { + tor_address: String::new(), + lan_address: None, + }); + if main.lan_address.is_none() { + main.lan_address = Some(format!("http://localhost:{port}")); + } +} + +fn fallback_package_port(app_id: &str) -> Option { + match app_id { + "fedimint" | "fedimintd" => Some(8175), + "filebrowser" => Some(8083), + "indeedhub" => Some(7778), + "nginx-proxy-manager" => Some(8081), + "nostr-rs-relay" => Some(18081), + _ => None, + } +} + +fn port_from_url(url: &str) -> Option { + let after_scheme = url.split_once("://").map(|(_, rest)| rest).unwrap_or(url); + let host_port = after_scheme.split('/').next().unwrap_or(after_scheme); + let port = host_port.rsplit_once(':')?.1; + port.parse::().ok() +} + /// Register Archipelago DWN protocols on startup. async fn register_dwn_protocols(data_dir: &std::path::Path) -> Result<()> { use crate::network::dwn_store::{DwnStore, ProtocolDefinition}; @@ -1211,10 +1368,19 @@ mod merge_tests { // not clobber the transitional state owned by the RPC spawn task. let existing = make_entry(PackageState::Stopping, Some("healthy")); let fresh = make_entry(PackageState::Running, Some("starting")); - let merged = merge_preserving_transitional(&existing, &fresh); + let merged = merge_preserving_transitional(&existing, &fresh, true); assert_eq!(merged.state, PackageState::Stopping); } + #[test] + fn non_user_stopping_recovers_when_container_is_running() { + let existing = make_entry(PackageState::Stopping, Some("unknown")); + let fresh = make_entry(PackageState::Running, Some("healthy")); + let merged = merge_preserving_transitional(&existing, &fresh, false); + assert_eq!(merged.state, PackageState::Running); + assert_eq!(merged.health.as_deref(), Some("healthy")); + } + #[test] fn merges_fresh_observability_fields() { // Non-state observability fields (health, exit_code, installed) @@ -1224,7 +1390,7 @@ mod merge_tests { existing.exit_code = None; let mut fresh = make_entry(PackageState::Running, Some("unhealthy")); fresh.exit_code = Some(0); - let merged = merge_preserving_transitional(&existing, &fresh); + let merged = merge_preserving_transitional(&existing, &fresh, true); assert_eq!(merged.state, PackageState::Stopping); assert_eq!(merged.health.as_deref(), Some("unhealthy")); assert_eq!(merged.exit_code, Some(0)); @@ -1234,7 +1400,7 @@ mod merge_tests { fn stale_removing_recovers_when_container_is_running() { let existing = make_entry(PackageState::Removing, Some("unknown")); let fresh = make_entry(PackageState::Running, Some("healthy")); - let merged = merge_preserving_transitional(&existing, &fresh); + let merged = merge_preserving_transitional(&existing, &fresh, false); assert_eq!(merged.state, PackageState::Running); assert_eq!(merged.health.as_deref(), Some("healthy")); } @@ -1272,4 +1438,20 @@ mod merge_tests { TRANSITIONAL_STUCK_TIMEOUT ); } + + #[test] + fn absent_stopping_transitions_to_stopped() { + assert_eq!( + absent_transitional_replacement(&PackageState::Stopping), + Some(PackageState::Stopped) + ); + } + + #[test] + fn absent_installing_still_waits_for_owner() { + assert_eq!( + absent_transitional_replacement(&PackageState::Installing), + None + ); + } } diff --git a/core/container/src/lib.rs b/core/container/src/lib.rs index 5f828aa5..e9f1ceb7 100644 --- a/core/container/src/lib.rs +++ b/core/container/src/lib.rs @@ -8,9 +8,9 @@ pub mod runtime; pub use bitcoin_simulator::{BitcoinSimulationMode, BitcoinSimulator}; pub use health_monitor::HealthMonitor; pub use manifest::{ - AppManifest, BuildConfig, ContainerConfig, Dependency, DerivedEnv, HealthCheck, HostFacts, - ManifestError, ResolvedSource, ResourceLimits, SecretEnv, SecretsProvider, SecurityPolicy, - Volume, + AppManifest, BuildConfig, ContainerConfig, Dependency, DerivedEnv, GeneratedFile, HealthCheck, + HostFacts, ManifestError, ResolvedSource, ResourceLimits, SecretEnv, SecretsProvider, + SecurityPolicy, Volume, }; pub use podman_client::{ image_uses_insecure_registry, ContainerState, ContainerStatus, PodmanClient, diff --git a/core/container/src/manifest.rs b/core/container/src/manifest.rs index 123bc82e..62c22b9b 100644 --- a/core/container/src/manifest.rs +++ b/core/container/src/manifest.rs @@ -1,5 +1,5 @@ use serde::{Deserialize, Serialize}; -use std::collections::HashMap; +use std::collections::{HashMap, HashSet}; use thiserror::Error; #[derive(Debug, Error)] @@ -42,6 +42,9 @@ pub struct AppDefinition { #[serde(default)] pub volumes: Vec, + #[serde(default)] + pub files: Vec, + #[serde(default)] pub environment: Vec, @@ -216,6 +219,8 @@ pub struct SecurityPolicy { pub capabilities: Vec, #[serde(default = "default_true")] pub readonly_root: bool, + #[serde(default = "default_true")] + pub no_new_privileges: bool, #[serde(default = "default_network_policy")] pub network_policy: String, #[serde(default)] @@ -263,6 +268,14 @@ pub struct Volume { pub tmpfs_options: Option, } +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +pub struct GeneratedFile { + pub path: String, + pub content: String, + #[serde(default)] + pub overwrite: bool, +} + #[derive(Debug, Clone, Serialize, Deserialize)] pub struct HealthCheck { #[serde(rename = "type")] @@ -302,8 +315,16 @@ impl AppManifest { } pub fn validate(&self) -> Result<(), ManifestError> { - if self.app.id.is_empty() { - return Err(ManifestError::Invalid("app.id cannot be empty".to_string())); + if !is_valid_app_id(&self.app.id) { + return Err(ManifestError::Invalid( + "app.id must be lowercase ASCII letters, digits, or single hyphens".to_string(), + )); + } + + if self.app.name.trim().is_empty() { + return Err(ManifestError::Invalid( + "app.name cannot be empty".to_string(), + )); } // Exactly one of container.image or container.build must be set. We can't @@ -355,6 +376,11 @@ impl AppManifest { "container.network cannot be empty (omit the field to use default)".to_string(), )); } + if is_dangerous_network_mode(n) { + return Err(ManifestError::Invalid(format!( + "container.network '{n}' is not allowed in app manifests" + ))); + } } // custom_args: no empty strings (would inject literal "" into @@ -447,6 +473,11 @@ impl AppManifest { } } + validate_security(&self.app.security)?; + validate_ports(&self.app.ports)?; + validate_environment(&self.app.environment)?; + validate_devices(&self.app.devices)?; + // Volume tmpfs_options: only meaningful for type: tmpfs. for (i, v) in self.app.volumes.iter().enumerate() { if v.volume_type == "tmpfs" { @@ -466,6 +497,11 @@ impl AppManifest { v.volume_type ))); } else { + if v.volume_type != "bind" && v.volume_type != "volume" { + return Err(ManifestError::Invalid(format!( + "volumes[{i}].type must be bind, volume, or tmpfs" + ))); + } if v.source.is_empty() { return Err(ManifestError::Invalid(format!( "volumes[{i}] ({}) must set source", @@ -478,6 +514,45 @@ impl AppManifest { v.volume_type ))); } + if v.volume_type == "bind" { + validate_bind_source(i, &v.source)?; + } else if !is_valid_named_volume(&v.source) { + return Err(ManifestError::Invalid(format!( + "volumes[{i}].source must be a safe named volume" + ))); + } + validate_container_path(i, &v.target)?; + validate_volume_options(i, &v.options)?; + } + } + + for (i, f) in self.app.files.iter().enumerate() { + if f.path.is_empty() { + return Err(ManifestError::Invalid(format!( + "files[{i}].path cannot be empty" + ))); + } + if !std::path::Path::new(&f.path).is_absolute() { + return Err(ManifestError::Invalid(format!( + "files[{i}].path must be absolute" + ))); + } + if f.content.is_empty() { + return Err(ManifestError::Invalid(format!( + "files[{i}].content cannot be empty" + ))); + } + let file_path = std::path::Path::new(&f.path); + let under_bind_mount = self + .app + .volumes + .iter() + .filter(|v| v.volume_type != "tmpfs" && !v.source.is_empty()) + .any(|v| file_path.starts_with(std::path::Path::new(&v.source))); + if !under_bind_mount { + return Err(ManifestError::Invalid(format!( + "files[{i}].path must live under a bind-mounted volume source" + ))); } } @@ -485,6 +560,195 @@ impl AppManifest { } } +fn is_valid_app_id(id: &str) -> bool { + if id.is_empty() || id.starts_with('-') || id.ends_with('-') || id.contains("--") { + return false; + } + id.chars() + .all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '-') +} + +fn is_dangerous_network_mode(mode: &str) -> bool { + mode.starts_with("container:") || mode.starts_with("ns:") +} + +fn validate_security(policy: &SecurityPolicy) -> Result<(), ManifestError> { + let allowed_network_policies = ["isolated", "bridge", "host"]; + if !policy.network_policy.is_empty() + && !allowed_network_policies.contains(&policy.network_policy.as_str()) + { + return Err(ManifestError::Invalid(format!( + "security.network_policy must be one of {}", + allowed_network_policies.join(", ") + ))); + } + + let allowed_caps = [ + "CHOWN", + "DAC_OVERRIDE", + "FOWNER", + "NET_ADMIN", + "NET_BIND_SERVICE", + "NET_RAW", + "SETGID", + "SETUID", + "SYS_ADMIN", + ]; + let mut seen = HashSet::new(); + for cap in &policy.capabilities { + if !allowed_caps.contains(&cap.as_str()) { + return Err(ManifestError::Invalid(format!( + "security.capabilities contains unsupported capability '{cap}'" + ))); + } + if !seen.insert(cap.as_str()) { + return Err(ManifestError::Invalid(format!( + "security.capabilities contains duplicate capability '{cap}'" + ))); + } + } + Ok(()) +} + +fn validate_ports(ports: &[PortMapping]) -> Result<(), ManifestError> { + let mut seen_host = HashSet::new(); + for (i, port) in ports.iter().enumerate() { + if port.host == 0 || port.container == 0 { + return Err(ManifestError::Invalid(format!( + "ports[{i}].host and ports[{i}].container must be non-zero" + ))); + } + let protocol = if port.protocol.is_empty() { + "tcp" + } else { + port.protocol.as_str() + }; + if protocol != "tcp" && protocol != "udp" { + return Err(ManifestError::Invalid(format!( + "ports[{i}].protocol must be tcp or udp" + ))); + } + if !seen_host.insert((port.host, protocol.to_string())) { + return Err(ManifestError::Invalid(format!( + "ports contains duplicate host binding {}/{}", + port.host, protocol + ))); + } + } + Ok(()) +} + +fn validate_environment(env: &[String]) -> Result<(), ManifestError> { + let mut seen = HashSet::new(); + for (i, entry) in env.iter().enumerate() { + let Some((key, _)) = entry.split_once('=') else { + return Err(ManifestError::Invalid(format!( + "environment[{i}] must be KEY=VALUE" + ))); + }; + if !is_valid_env_key(key) { + return Err(ManifestError::Invalid(format!( + "environment[{i}] has invalid key '{key}'" + ))); + } + if !seen.insert(key) { + return Err(ManifestError::Invalid(format!( + "environment contains duplicate key '{key}'" + ))); + } + } + Ok(()) +} + +fn is_valid_env_key(key: &str) -> bool { + let mut chars = key.chars(); + match chars.next() { + Some(c) if c.is_ascii_alphabetic() || c == '_' => {} + _ => return false, + } + chars.all(|c| c.is_ascii_alphanumeric() || c == '_') +} + +fn validate_devices(devices: &[String]) -> Result<(), ManifestError> { + let mut seen = HashSet::new(); + for (i, device) in devices.iter().enumerate() { + if !device.starts_with("/dev/") || device.contains("..") { + return Err(ManifestError::Invalid(format!( + "devices[{i}] must be an absolute /dev path" + ))); + } + if !seen.insert(device.as_str()) { + return Err(ManifestError::Invalid(format!( + "devices contains duplicate entry '{device}'" + ))); + } + } + Ok(()) +} + +fn validate_bind_source(index: usize, source: &str) -> Result<(), ManifestError> { + let path = std::path::Path::new(source); + if !path.is_absolute() { + if is_valid_named_volume(source) { + return Ok(()); + } + return Err(ManifestError::Invalid(format!( + "volumes[{index}].source must be absolute for host bind mounts or a safe named volume" + ))); + } + if source.contains("..") { + return Err(ManifestError::Invalid(format!( + "volumes[{index}].source must not contain '..'" + ))); + } + if source.starts_with("/var/lib/archipelago/") || is_reviewed_host_bind_exception(source) { + return Ok(()); + } + Err(ManifestError::Invalid(format!( + "volumes[{index}].source must be under /var/lib/archipelago or a reviewed host-bind exception" + ))) +} + +fn is_reviewed_host_bind_exception(source: &str) -> bool { + source == "/run/user/1000/podman/podman.sock" || source == "/var/run/dbus" +} + +fn is_valid_named_volume(source: &str) -> bool { + if source.is_empty() || source.contains('/') || source.contains("..") { + return false; + } + source + .chars() + .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_' || c == '.') +} + +fn validate_container_path(index: usize, target: &str) -> Result<(), ManifestError> { + if !std::path::Path::new(target).is_absolute() || target.contains("..") { + return Err(ManifestError::Invalid(format!( + "volumes[{index}].target must be an absolute container path without '..'" + ))); + } + Ok(()) +} + +fn validate_volume_options(index: usize, options: &[String]) -> Result<(), ManifestError> { + let allowed = ["rw", "ro", "z", "Z", "shared", "rshared", "slave", "rslave"]; + let mut seen = HashSet::new(); + for option in options { + if !allowed.contains(&option.as_str()) { + return Err(ManifestError::Invalid(format!( + "volumes[{index}].options contains unsupported option '{option}'" + ))); + } + if !seen.insert(option.as_str()) { + return Err(ManifestError::Invalid(format!( + "volumes[{index}].options contains duplicate option '{option}'" + ))); + } + } + Ok(()) +} + /// Host facts available to `derived_env` templates at apply time. /// /// Mirrors the values `scripts/container-specs.sh:detect_environment()` @@ -864,6 +1128,38 @@ app: ); } + #[test] + fn generated_files_must_live_under_bind_mounts() { + let yaml = r#" +app: + id: test-app + name: Test App + version: 1.0.0 + container: + image: test/image:latest + volumes: + - type: bind + source: /var/lib/archipelago/test-app + target: /data + files: + - path: /var/lib/archipelago/test-app/config.yaml + content: | + key: value +"#; + let manifest = AppManifest::parse(yaml).unwrap(); + assert_eq!(manifest.app.files.len(), 1); + + let bad = yaml.replace( + "/var/lib/archipelago/test-app/config.yaml", + "/etc/test-app/config.yaml", + ); + let err = AppManifest::parse(&bad).unwrap_err(); + assert!( + format!("{err}").contains("bind-mounted volume source"), + "unexpected error: {err}" + ); + } + #[test] fn empty_custom_arg_is_rejected() { let yaml = r#" @@ -1089,6 +1385,157 @@ app: } } + #[test] + fn unsafe_manifest_values_are_rejected() { + let cases = [ + ( + "bad app id", + r#" +app: + id: Bad_App + name: Bad + version: 1.0.0 + container: + image: test/image:latest +"#, + "app.id", + ), + ( + "unsupported capability", + r#" +app: + id: bad-cap + name: Bad + version: 1.0.0 + container: + image: test/image:latest + security: + capabilities: [SYS_MODULE] +"#, + "unsupported capability", + ), + ( + "docker socket bind", + r#" +app: + id: bad-bind + name: Bad + version: 1.0.0 + container: + image: test/image:latest + volumes: + - type: bind + source: /var/run/docker.sock + target: /var/run/docker.sock +"#, + "reviewed host-bind exception", + ), + ( + "path-like relative bind source", + r#" +app: + id: bad-bind + name: Bad + version: 1.0.0 + container: + image: test/image:latest + volumes: + - type: bind + source: data/cache + target: /data +"#, + "absolute for host bind mounts", + ), + ( + "bad environment key", + r#" +app: + id: bad-env + name: Bad + version: 1.0.0 + container: + image: test/image:latest + environment: + - 1BAD=value +"#, + "invalid key", + ), + ( + "duplicate host port", + r#" +app: + id: bad-port + name: Bad + version: 1.0.0 + container: + image: test/image:latest + ports: + - { host: 8080, container: 80, protocol: tcp } + - { host: 8080, container: 81, protocol: tcp } +"#, + "duplicate host binding", + ), + ( + "bad device", + r#" +app: + id: bad-device + name: Bad + version: 1.0.0 + container: + image: test/image:latest + devices: + - /tmp/fake-device +"#, + "absolute /dev path", + ), + ( + "container network namespace", + r#" +app: + id: bad-network + name: Bad + version: 1.0.0 + container: + image: test/image:latest + network: container:host +"#, + "not allowed", + ), + ]; + + for (name, yaml, expected) in cases { + let err = AppManifest::parse(yaml).unwrap_err(); + let msg = format!("{err}"); + assert!( + msg.contains(expected), + "case {name} expected '{expected}', got: {msg}" + ); + } + } + + #[test] + fn reviewed_host_bind_exceptions_parse() { + let yaml = r#" +app: + id: reviewed-binds + name: Reviewed Binds + version: 1.0.0 + container: + image: test/image:latest + volumes: + - type: bind + source: /run/user/1000/podman/podman.sock + target: /var/run/docker.sock + options: [rw] + - type: bind + source: /var/run/dbus + target: /var/run/dbus + options: [ro] +"#; + AppManifest::parse(yaml).unwrap(); + } + #[test] fn parse_every_real_manifest() { let app_manifests = list_repo_manifests(); @@ -1099,7 +1546,6 @@ app: let mut failures: Vec = Vec::new(); let mut modern_count = 0usize; - let mut legacy_count = 0usize; for path in app_manifests { let content = fs::read_to_string(&path).expect("read manifest"); let parsed_yaml: serde_yaml::Value = match serde_yaml::from_str(&content) { @@ -1121,15 +1567,14 @@ app: failures.push(format!("{}: {err}", path.display())); } } else { - legacy_count += 1; + failures.push(format!( + "{}: expected modern app-schema manifest", + path.display() + )); } } assert!(modern_count > 0, "no modern app-schema manifests found"); - assert!( - legacy_count > 0, - "expected at least one legacy manifest shape" - ); assert!( failures.is_empty(), diff --git a/core/container/src/podman_client.rs b/core/container/src/podman_client.rs index 3111a4db..7ce04a40 100644 --- a/core/container/src/podman_client.rs +++ b/core/container/src/podman_client.rs @@ -56,9 +56,9 @@ pub enum ContainerState { impl From<&str> for ContainerState { fn from(s: &str) -> Self { match s.to_lowercase().as_str() { - "created" => ContainerState::Created, + "created" | "initialized" => ContainerState::Created, "running" => ContainerState::Running, - "stopping" => ContainerState::Stopping, + "stopping" | "removing" => ContainerState::Stopping, "stopped" => ContainerState::Stopped, "exited" => ContainerState::Exited, "paused" => ContainerState::Paused, @@ -129,7 +129,6 @@ impl PodmanClient { "filebrowser" => "http://localhost:8083", "nginx-proxy-manager" => "http://localhost:8081", "portainer" => "http://localhost:9000", - "saleor" => "http://localhost:9011", "uptime-kuma" => "http://localhost:3002", "fedimint" | "fedimintd" => "http://localhost:8175", "fedimint-gateway" => "http://localhost:8176", @@ -390,7 +389,7 @@ impl PodmanClient { "cap_add": cap_add, "cap_drop": cap_drop, "read_only_filesystem": manifest.app.security.readonly_root, - "no_new_privileges": true, + "no_new_privileges": manifest.app.security.no_new_privileges, "restart_policy": "unless-stopped", "restart_tries": 5, "netns": { @@ -635,6 +634,7 @@ fn podman_network_settings( Some("bridge") => ("bridge", None), Some("none") => ("none", None), Some("slirp4netns") => ("slirp4netns", None), + Some("pasta") => ("pasta", None), Some("private") => ("private", None), Some(custom) => ("bridge", Some(custom.to_string())), None if network_policy == "host" => ("host", None), diff --git a/core/container/src/runtime.rs b/core/container/src/runtime.rs index 0c6b9c1f..e92626ea 100644 --- a/core/container/src/runtime.rs +++ b/core/container/src/runtime.rs @@ -7,6 +7,7 @@ use std::time::Duration; use tokio::process::Command as TokioCommand; const PODMAN_CLI_DEFAULT_TIMEOUT: Duration = Duration::from_secs(30); +const PODMAN_CLI_IMAGE_CHECK_TIMEOUT: Duration = Duration::from_secs(10); const PODMAN_CLI_BUILD_TIMEOUT: Duration = Duration::from_secs(900); #[async_trait] @@ -150,7 +151,25 @@ impl ContainerRuntime for PodmanRuntime { if is_missing_container_error(&stderr) { return Ok(()); } - Err(api_err.context(format!("podman rm fallback failed: {}", stderr.trim()))) + let zero_timeout = self.podman_cli(&["rm", "-f", "--time", "0", name]).await?; + if zero_timeout.status.success() { + return Ok(()); + } + + let _ = self.podman_cli(&["container", "cleanup", name]).await; + let cleanup_rm = self.podman_cli(&["rm", "-f", name]).await?; + if cleanup_rm.status.success() { + return Ok(()); + } + let cleanup_stderr = String::from_utf8_lossy(&cleanup_rm.stderr); + if is_missing_container_error(&cleanup_stderr) { + return Ok(()); + } + Err(api_err.context(format!( + "podman rm fallback failed: {}; cleanup rm failed: {}", + stderr.trim(), + cleanup_stderr.trim() + ))) } } } @@ -196,20 +215,26 @@ impl ContainerRuntime for PodmanRuntime { } async fn image_exists(&self, image_ref: &str) -> Result { - // `podman image exists` returns 0 if present, 1 if absent. Any other - // exit code is an environment failure we should surface. - let output = self.podman_cli(&["image", "exists", image_ref]).await?; + // Avoid `podman image exists`: on production nodes with a stressed + // rootless store it can hang even when targeted at one image. A bounded + // inspect is the local-storage probe the trait contract describes. + let output = self + .podman_cli_timeout( + &["image", "inspect", image_ref], + PODMAN_CLI_IMAGE_CHECK_TIMEOUT, + ) + .await?; match output.status.code() { Some(0) => Ok(true), Some(1) => Ok(false), Some(code) => { let stderr = String::from_utf8_lossy(&output.stderr); Err(anyhow::anyhow!( - "podman image exists {image_ref} exited with {code}: {stderr}" + "podman image inspect {image_ref} exited with {code}: {stderr}" )) } None => Err(anyhow::anyhow!( - "podman image exists {image_ref} terminated by signal" + "podman image inspect {image_ref} terminated by signal" )), } } diff --git a/docker/bitcoin-ui/index.html b/docker/bitcoin-ui/index.html index 415fdf85..d24dc0fd 100644 --- a/docker/bitcoin-ui/index.html +++ b/docker/bitcoin-ui/index.html @@ -18,6 +18,7 @@ body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', sans-serif; min-height: 100vh; + background: #000; color: white; overflow-x: hidden; } @@ -555,6 +556,87 @@ + +
+
+
+

Transaction Relay Sharing

+

Trusted peer access for broadcasting transactions through this node

+
+
+ Local node + Checking... +
+
+ +
+
+
HTTPS Endpoint
+
Not configured
+
+
+
HTTP Endpoint
+
Not configured
+
+
+
Tor Endpoint
+
Not configured
+
+
+ +
+
+
+ + + +
+ +
+ + +
+
+ + +
+ +
+ +
+
+ + +
+ +
+
+ Restricted RPC user + txrelay +
+
Credential status unavailable
+
+
+
Relay Requests
+
+
No relay requests
+
+
+
+
+
+
@@ -608,6 +690,7 @@ // RPC Configuration - Use local Nginx proxy within container const RPC_ENDPOINT = 'bitcoin-rpc/'; const STATUS_ENDPOINT = 'bitcoin-status'; + const ARCHY_RPC_ENDPOINT = 'rpc/v1'; console.log('[Bitcoin UI] RPC Endpoint:', RPC_ENDPOINT); // Make RPC call to Bitcoin node via local proxy @@ -654,6 +737,220 @@ return response.json(); } + function cookieValue(name) { + return document.cookie + .split('; ') + .find(row => row.startsWith(`${name}=`)) + ?.split('=') + .slice(1) + .join('=') || ''; + } + + async function callArchyRPC(method, params = {}) { + const headers = { 'Content-Type': 'application/json' }; + const csrf = cookieValue('csrf'); + if (csrf) headers['X-CSRF-Token'] = decodeURIComponent(csrf); + const response = await fetch(ARCHY_RPC_ENDPOINT, { + method: 'POST', + headers, + credentials: 'include', + cache: 'no-store', + body: JSON.stringify({ method, params }) + }); + const body = await response.json().catch(() => ({})); + if (!response.ok || body.error) { + throw new Error(body.error?.message || `Archipelago RPC ${response.status}`); + } + return body.result; + } + + function escapeHtml(value) { + return String(value ?? '').replace(/[&<>"']/g, char => ({ + '&': '&', + '<': '<', + '>': '>', + '"': '"', + "'": ''' + }[char])); + } + + function setText(id, value, fallback = 'Not configured') { + const el = document.getElementById(id); + if (el) el.textContent = value || fallback; + } + + function renderRelayRequests(requests = []) { + const list = document.getElementById('relayRequestsList'); + if (!list) return; + if (!requests.length) { + list.innerHTML = '
No relay requests
'; + return; + } + list.innerHTML = requests.map(req => { + const name = escapeHtml(req.peer_name || req.peer_onion || req.peer_pubkey); + const message = req.message ? `
${escapeHtml(req.message)}
` : ''; + const endpoint = req.approved_endpoint ? `
${escapeHtml(req.approved_endpoint)}
` : ''; + const statusClass = req.status === 'approved' + ? 'text-green-300' + : req.status === 'rejected' + ? 'text-red-300' + : 'text-yellow-300'; + const actions = req.direction === 'incoming' && req.status === 'pending' + ? `
+ + +
` + : ''; + return `
+
+
${name}
+
${escapeHtml(req.direction)} · ${escapeHtml(req.status)}
+
+ ${message} + ${endpoint} + ${actions} +
`; + }).join(''); + } + + function renderRelayPeers(peers = [], selectedPeer = '', localSynced = true) { + const select = document.getElementById('relayPeerSelect'); + const button = document.getElementById('relayRequestButton'); + if (!select) return; + if (!localSynced) { + select.innerHTML = ''; + select.disabled = true; + if (button) button.disabled = true; + return; + } + if (!peers.length) { + select.innerHTML = ''; + select.disabled = true; + if (button) button.disabled = true; + return; + } + select.disabled = false; + if (button) button.disabled = false; + select.innerHTML = '' + peers.map(peer => { + const label = escapeHtml(peer.name || peer.onion || peer.pubkey.slice(0, 16)); + const approved = peer.relay_approved ? ' · approved' : ''; + const selected = peer.pubkey === selectedPeer ? ' selected' : ''; + return ``; + }).join(''); + } + + async function loadRelayAccess() { + const statusEl = document.getElementById('relayStatusMessage'); + try { + const relay = await callArchyRPC('bitcoin.relay-status'); + const settings = relay.settings || {}; + const local = relay.local_node || {}; + setText('relayHttpsEndpoint', settings.https_endpoint); + setText('relayHttpEndpoint', settings.http_endpoint); + setText('relayTorEndpoint', settings.tor_endpoint); + const syncEl = document.getElementById('relaySyncStatus'); + if (syncEl) { + syncEl.textContent = local.synced ? 'Synchronized' : 'Not synchronized'; + syncEl.className = local.synced ? 'ml-2 font-medium text-green-300' : 'ml-2 font-medium text-yellow-300'; + } + const enabled = document.getElementById('relayEnabledToggle'); + const requests = document.getElementById('relayRequestsToggle'); + const tor = document.getElementById('relayTorToggle'); + if (enabled) enabled.checked = !!settings.enabled_for_peers; + if (requests) requests.checked = !!settings.allow_peer_requests; + if (tor) tor.checked = !!settings.allow_tor; + const httpsInput = document.getElementById('relayHttpsInput'); + const httpInput = document.getElementById('relayHttpInput'); + const torInput = document.getElementById('relayTorInput'); + if (httpsInput && document.activeElement !== httpsInput) httpsInput.value = settings.https_endpoint || ''; + if (httpInput && document.activeElement !== httpInput) httpInput.value = settings.http_endpoint || ''; + if (torInput && document.activeElement !== torInput) torInput.value = settings.tor_endpoint || ''; + renderRelayPeers(relay.trusted_nodes || [], settings.selected_peer_pubkey || '', !!local.synced); + renderRelayRequests(relay.requests || []); + setText('relayCredentialUser', relay.credentials?.username || 'txrelay', 'txrelay'); + setText( + 'relayCredentialStatus', + relay.credentials?.available ? `Credential file ready: ${relay.credentials.client_env_path}. ${relay.credentials.restart_hint || ''}` : 'Restricted relay credential will be generated when peer sharing is enabled', + 'Credential status unavailable' + ); + if (statusEl) statusEl.textContent = ''; + } catch (error) { + console.warn('[Bitcoin UI] relay status failed', error); + if (statusEl) statusEl.textContent = `Relay controls unavailable: ${error.message}`; + } + } + + async function saveRelaySettings() { + const statusEl = document.getElementById('relayStatusMessage'); + const payload = { + enabled_for_peers: !!document.getElementById('relayEnabledToggle')?.checked, + allow_peer_requests: !!document.getElementById('relayRequestsToggle')?.checked, + allow_tor: !!document.getElementById('relayTorToggle')?.checked, + allow_https: !!document.getElementById('relayHttpsInput')?.value.trim(), + allow_http: !!document.getElementById('relayHttpInput')?.value.trim(), + selected_peer_pubkey: document.getElementById('relayPeerSelect')?.value || '', + https_endpoint: document.getElementById('relayHttpsInput')?.value.trim() || '', + http_endpoint: document.getElementById('relayHttpInput')?.value.trim() || '', + tor_endpoint: document.getElementById('relayTorInput')?.value.trim() || '' + }; + try { + await callArchyRPC('bitcoin.relay-update-settings', payload); + if (statusEl) statusEl.textContent = 'Relay settings saved.'; + await loadRelayAccess(); + } catch (error) { + if (statusEl) statusEl.textContent = `Save failed: ${error.message}`; + } + } + + async function requestPeerRelay() { + const statusEl = document.getElementById('relayStatusMessage'); + const peer = document.getElementById('relayPeerSelect')?.value; + if (!peer) { + if (statusEl) statusEl.textContent = 'Choose a trusted node first.'; + return; + } + try { + await callArchyRPC('bitcoin.relay-request-peer', { + peer_pubkey: peer, + message: document.getElementById('relayRequestMessage')?.value || '' + }); + if (statusEl) statusEl.textContent = 'Relay access request sent.'; + await loadRelayAccess(); + } catch (error) { + if (statusEl) statusEl.textContent = `Request failed: ${error.message}`; + } + } + + async function approveRelayRequest(id) { + await updateRelayRequest('bitcoin.relay-approve-request', id); + } + + async function rejectRelayRequest(id) { + await updateRelayRequest('bitcoin.relay-reject-request', id); + } + + async function updateRelayRequest(method, id) { + const statusEl = document.getElementById('relayStatusMessage'); + try { + await callArchyRPC(method, { id }); + if (statusEl) statusEl.textContent = 'Relay request updated.'; + await loadRelayAccess(); + } catch (error) { + if (statusEl) statusEl.textContent = `Update failed: ${error.message}`; + } + } + + async function createRelayTorService() { + const statusEl = document.getElementById('relayStatusMessage'); + try { + await callArchyRPC('bitcoin.relay-create-tor-service'); + if (statusEl) statusEl.textContent = 'Tor service requested.'; + await loadRelayAccess(); + } catch (error) { + if (statusEl) statusEl.textContent = `Tor setup failed: ${error.message}`; + } + } + // Implementation branding — detected from getnetworkinfo.subversion. // Bitcoin Knots identifies as "/Satoshi:/Knots:/", Bitcoin Core as "/Satoshi:/". let brandingApplied = false; @@ -720,11 +1017,11 @@ syncStatusText.textContent = status.error || 'Bitcoin node is reconnecting... showing last known values'; syncStatusText.className = 'text-yellow-300 text-sm font-medium'; } else if (consecutiveRpcFailures < 6) { - syncStatusText.textContent = status.error || 'Connecting to Bitcoin node...'; + syncStatusText.textContent = status.error || 'Bitcoin node is starting or busy syncing...'; syncStatusText.className = 'text-yellow-300 text-sm font-medium'; } else { - syncStatusText.textContent = status.error || 'Bitcoin node is not responding yet'; - syncStatusText.className = 'text-red-400 text-sm font-medium'; + syncStatusText.textContent = status.error || 'Bitcoin node is still syncing; retrying automatically...'; + syncStatusText.className = 'text-yellow-300 text-sm font-medium'; } } if (syncIcon) { @@ -910,8 +1207,8 @@ if (syncStatusText) { const hasRecentData = lastSuccessfulUpdateAt > 0 && Date.now() - lastSuccessfulUpdateAt < 120000; syncStatusText.textContent = hasRecentData - ? 'Bitcoin status bridge is reconnecting... keeping last known values' - : 'Connecting to Bitcoin status bridge...'; + ? 'Bitcoin status bridge is retrying... keeping last known values' + : 'Bitcoin status bridge is starting...'; syncStatusText.className = 'text-yellow-300 text-sm font-medium'; } } @@ -920,10 +1217,12 @@ // Initial update console.log('[Bitcoin UI] Starting initial blockchain info update...'); updateBlockchainInfo(); + loadRelayAccess(); // Update every 5 seconds console.log('[Bitcoin UI] Setting up 5-second update interval'); setInterval(updateBlockchainInfo, 5000); + setInterval(loadRelayAccess, 15000); function copyRPCInfo() { const info = `RPC Host: ${window.location.hostname}:8332\nRPC User: archipelago\nRPC Password: archipelago123\nRPC Endpoint: ${RPC_ENDPOINT}`; diff --git a/docker/fedimint-ui/Dockerfile b/docker/fedimint-ui/Dockerfile new file mode 100644 index 00000000..7cb19290 --- /dev/null +++ b/docker/fedimint-ui/Dockerfile @@ -0,0 +1,16 @@ +FROM git.tx1138.com/lfg2025/nginx:1.27.4-alpine + +COPY index.html /usr/share/nginx/html/index.html +COPY nginx.conf /etc/nginx/conf.d/default.conf +COPY assets/img/bg-network.jpg /usr/share/nginx/html/assets/img/bg-network.jpg +COPY assets/img/app-icons/fedimint.png /usr/share/nginx/html/assets/img/app-icons/fedimint.png +COPY assets/img/app-icons/fedimint.jpg /usr/share/nginx/html/assets/img/app-icons/fedimint.jpg + +RUN sed -i 's/^user nginx;/user root;/' /etc/nginx/nginx.conf && \ + mkdir -p /var/cache/nginx/client_temp /var/cache/nginx/proxy_temp \ + /var/cache/nginx/fastcgi_temp /var/cache/nginx/uwsgi_temp \ + /var/cache/nginx/scgi_temp + +EXPOSE 8175 +ENTRYPOINT [] +CMD ["nginx", "-g", "daemon off;"] diff --git a/docker/fedimint-ui/assets/img/app-icons/fedimint.jpg b/docker/fedimint-ui/assets/img/app-icons/fedimint.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4a759c5501a48a0fe42c3c4992759a4c73cd8265 GIT binary patch literal 41944 zcmeEuc|4SD+yB^wNFfPRD9a>-C^D5B*+Wd(rbxCV*~Ls`OPC~-EJgNZ>^ozhO31!% zGugKp#u#Sto9^d%?`L`6=l3k1_j&(#KKH3}T-VjiHP>;T=W!h0<9i&ZgVBRI9-5Y) z^8*0D&=4R4007tltPDp1O!OlL`VW9X2*C2|F#uq}aPqffTL!5=zK0P2U_ADx_eVGb znE&{G`aOSbH~x73hu>_k001`n6=wMh3i5Fbe>i4fWCDEnuj>l(@*f!faL0oK0N?}T zf8CME`UBISjz6*f@mqiWlHXr`AA#RT;P(;ueFT0Vf!{~q_YwGg1b!cZ-$&s05%_%s zejkC~N8oRdz`+C{6u|InV`QL*;f#!oOw3I5#>~q6v$3+V{@U37*w}w03$C06EDL-J3|JYgkbr@6aJSN z^yg$|VP#`K#KCz4z{tSF#K_FV!oo}^9vFgtQVGnwEJsf(Tw^_Ea*s{SgYQCc+(< z>!mIHrhPaGMY|^GHT1H9vqKfLJ%bLGvY3tn3)ib+gZUMP{$I|}3 z!vjYrXBST|Zy#Sj|A6PAVc`*xFQQ(@zez|;diyRpBlA;Mc1~_yepz`%WmR=eZCz_y zdq*ew^Ovvv1A{}uBco&Ea~SN8`Gv)$6*p4wT(*7Pi19>Ti|O@t-veP^v#|Ax>!^lOY`W5Sxi$|pT==N$S+rA-EQ%V zcytG)8MgQpTAN!IU6(`ciCTy&=NMU+YH$v~j*y0F^KNN9x63Dse4Z11@M+Cel&2klgku}N7*r`%p%RCG7nk_yRT zi#CPKz~rduUNLvC3@4Ct2#ih2c*l?(=ph##hrpa48mR@_g%c49emnsg4No(NKE}it z#$Jw+LNags=ALg}@X*x)7##(G1ISlYGX+wUjmf(QfRS9O4=gi}4gf1a-?=C~sSk{F z$nw9{dH!#p0w1HcjteO^N}e8eE~bd!^=rs?HT*a;O}#@KfJ|-Vf_1X zEFlw8;isRe3JN0oRTWQ#Sz%TSvdWeMhdq;@z*gS%a58=wh(eI%<@7eRLgG>@P-Cmq zajJ<^VBu=^W9V3JK=rb*&6VRHsh~PqkNYO<&1MN|7p3PGFZ6ltaENGjJXr&5xp4p} zpCHd<0ms(BF9{h$;Ba8<@ip;@tzsY=$m4|)bmnpN$^6FjBk)OfBZ{ots55U6Z|K$- z<2lmSS|}_d%O-pui&Fze19{cia{VODU0pxPd`by`q>QYf(a5lF%nU~Z(M4mxE%Dlb z#!ME>(vT~0tKvdTVGeTuWR7C^CP?QWBv{mCB=DI)l>)B)8(}Eh{{e0) zcYHJg(S3yK=&&eWog03sQHhy2d0X34s>sP~F;CFfN3lTThMrB_emxl+sPVE*gRwmA zcI#A6a26#1(opQRLx6YzS`{2Y|6ECer$z>%JVzb-_S&Y0dkHFRpf3rcd6) z>UwpUL}PJTv>xatEMe+Q)ewUY|EVf>y_JPa)2C+P5^zX zY;>G_3EsGGLQO$UQ$bB+P=IMr9GQbqkxx3~Bqq5+*r=iuymfUOG9C=9?@u zMS6bQsMx&3b>aLq-d!*^}gUZ=kU9Gs>s` zOUV&64@$ugKQx=r=y~4;pDQ$A$5+AF8#~|&6Ga!JKzL2Uvy3Pyz`v<89sK)IM>j04blCs)XFsQ-3;%Gn$&XEVMp4Fndmdp9H_rsj#JLM*C5x^h248a#~R)L>c zq!VFlckQYOPcQ60lms@TzE;K?Nf0_g`zQ1#5g$o`cmX$I(=o9pJVrx7=S(j3F5A2b z@JvxqC3Zmdj~?NoCAhsa=DqKs`$*g-N|mpOTSpk;PCUDlxn{Vk%e#XT?}-WV0cQd4 z8lefr+iRi+fUMI4UzR*b=GFp|pD|i>NUaW2GBd1l2|U(KUmzc7J*u6X{hyG9d!kQ< z8I2U8NLIx4{yrG+j)I!cw;L1yvX5ADFPek0egFswoqP`jIDbB_wg6g=#x!W0O(@%M zia@nh?v<8AfluUSL{WsPp>%%^_;>Y#e?Nd8{_dVVQ2E}f>yhXQfvfPT^*hQEUIXPd zUZqr3S}*KO68ZqZ;nnE!V3K?>{jNgPuBsR26H_N>3rIWEhp(G3tb0E<68XqSVsz`; z4nO(MVFVz!1GXCX0BF@RkQe0k0LGSnPx5)^tkX2Y{!9;<{mU119z08Tk=hC`TJkB`{(2ZQ}52wZTX+6d+*u;ZFgCR z=m~#H_@GhpIDHJ8z1d&zhtCp>fBj!`c=^n5{FXFi$-h0>pGo2|2v<+zV8U~)rm4BJ zO`tZ;ApoMB@SOr85}SnZG7dv=yEo_;A*LQmv95WG)QxOyf#Y-H-{S*w>?Nd?h9Lo33A@j1=JS5v)JG-md>n#rpxpuLyKt0ZTbwbhACwmFdd@JSbd}(1>)Kb^8Q)ExBQnH zd73@B>W>BIFWa4d(1cABatV%^$x?S-UbU&e!w{{qtWN|IQF?1l5$Wq2j}HK2`29X= zI@yFBDlOVBKUYdJHAr`PYCPP<9=q*B#W%)9dfbVV)a)~)4ybzQzGJ^Gsept$X#v*%-x+>S@G)t!g6T>b`-)QML<56i}L$@?n|4!s^iVid1vhbN) z{bxJy;9rdR*3-ZhI>ZeNNxge^&Wq=NABnJxczUd%dW*s*KSJa28W@=e?0EI}V}ex4+# z{1D=P?B7v%&MK9Wa?!9m-#Q6R06lY>YVae9&X|*&=hPb zPPur#STvB}@Zd4FY*ORA`rF8}i0SkQFb*<$zOa9!!_vSfwn2@lfv1fVYLr9aXPP}% zP>Y01p-CfKKg1W(x{`O7@ID$RD|!<;NI`FglT;+-veATc%mIKTgKAAZI|XcAs@~du z<54{zJWD1bLttVDfRORMd#H}aX>_}ds*q=kbG`aP^ImPv}WW3m}qw6c)`Y{Jp9r4YDp};D3Eg7 z!9n$2lpE|lDQ8wPc;|&g{MW7MR38E`EHD9U{Os~(#8|Nxln}{wZ4%P+z#16SI(^gn zyN$`p+_s)~AR^tVpgJIEDztMN&-JJ=GJo18un>dUyI&X}qgxQyr^SEfpV4OE!9P!K z+>{3O(S-bNkg9F1q>n2gEmvFa&c7%SlAn4vl%Lo3cA0h}P`VBu*5BntyTx&Bd1MbV z6Tlsuvs9JmXfMdXs%ZF~;3^{e{q|V#_ZljwqNIYWr4-um;|@3QeCF4L`N=(XpG$+j zac4fAtlB8fF{rjqwgQ>fus6c9yf1r~=Ux(Awr$xSQaHYJ@heN~h*@^?CtgC{+WL)& z4sT1hdcdT8mcFm5%(svkW6xNSBl+y`)>x7IO?9{7ilX()9vyDumd8SL_z&CMNei-U zs0Y4>S2(V{boA$%mcku%gE!n|y0o)zzYI;V3`^Ze@*^I{zx@$Cn}^M!ujS>^?uYl@ z`H7*#QICwr8Y?*4@I0+IdCF=hWW)%PSup30KovnP4Bf&hf8U=L!su6qwS%=`_e_ku zr8-XLW{)iRfHi-M?*Atu{^pHkdc^McOC-c&rTD zKoqrr^c459b%smnhF34oM227|=Uq=5bZc+ezDk=h%b3$;1CCg6*6XZ?G5XME-3|_B3{gfrFNk@m@2vSx!87VP`;Ue zMu5oBcZb}8>0=~0v^ zM{4$Kl$Z;;Px1qup$h*y&hs}~?q8tK__%N&g3c^5>~x>HB>&7C=5oN3fRQ#BYbn|N zMbV|^7i|Q>IyC>XQMyP%icjKdm=*_HKkCLTSCe9bf&P>e;@Cyx7k=)A)P(p;#dX6| zVoZ!5OUfA(`s<1`KIcwa5s*Wc8fv^|cHKp&sp52ls)@w>VGH|H3@H#ujwP3H(S3jK ze8Rc0ap0Q~s1SE%Rc4=jcMee%n1;~7HM(04n zo?qUZLjQzSCtWv(8bC;CpyMn^PSDSe{L7#{_v=X0h+AZonL@Wtsp4cfAk*OYTrJK2hw8+2Y5&xQ3q@U|YoBrJ- z9@CqnS8XfF4hI0{C6as{4B>%ivW#$bVXzdAecMYK!GgmJ!#^U&Z^u{nywXYW>V}&i z02l%}ra4LanIykl(O)#@3A2!i$3~3&rACFc7Tl!!Te7fNMrsO5JQr0m$;Y%hUhCS$ zB^wabUE0YpqWIJS{k3v`c~4!^zH4LsvnqPdx?{fli4UgnBJFe9P}h{D+e%G#z^#=u zS8pfwdDo<-vRO(E@Svl=RukSIac=FkBXY;e8Y>ubKkz7v=HR!2WZsVK~SBb);!Q+ajc6Ja`is!qMv7*(C$lbrM`ws4|jbp1dU=(*c15o({aW$_Fb|by2TFYtQ)ZLdIuRuSn#)NNkKFIr91qStt_k7%F8>9RT8JUQl89eV!N~gSWI>gLB4I ziz_dB+*T|Xmg+k1ITCdM&_}%hvcZ6Xru|ko@M-T36CQEQ4SIpYV0^Ga6z&)BAyN}4 z{b-;_nw8CU>$0)V_a>#A>1~3=*67ehqaFE;)zS?dI$F@$CT~HW=w3%M{^1g}Uyj{f z^T4BtzJou?@SSfk%98f&T<@;+MPBuQN;{sgn2oK(S2`KJsg*pb1Ve{*_H}5E-}{jz z8gs-%i$89pEvZtzwkRp2Oq@FbpmV<#?o(-tNXd zAATKr4UL74CBBd(hCg?GlKIHa7R&(sgp(M^fecdO+pD|Gc<2aL^F@6H&`Zu`!M*4r zUHO+ss%)R*icR-FW5bYrCVNF3iRw+n?rXDjCtA6aro-5%u{Gc;NCCyySFwdzTcC^d ziqY?&mQ@>UbJpEc<=mP4%SprUYfY?Ehw={q>_t4HI4A8g5@;?F~*akn;MAFCIT2SN31p4wO*^m8y z5z?Qbrhh)|ADmf?yFwjK$Ef+cSvj9$*oUlNjB;~d>tC5%1ZTm7EDea;MeRCVp}f!{ zR5>(uonkUOx+d{((h6`GhG@PNdRnH&|Iv=lSNs{U=fwGl0pc*)?r?)$y_J<&!so)L zPaj_&ad2nnQh?^BGg#(jWsNiPbS>K$7SXY;V1At!2Lu1mSo2%U&s(m8bO&5=iXnN0 z(DkUn9Hbw(F1S;iZdf&XDBHiX;P!B76<8YltT?%Utfay2Ls^x~#~|0-imGveQuX{D zow13Fx9E1IsHkT$u5~ASeB!a-Ff>*jl0o8Z-cOI*d8b|(KJ^W@8O!2uNvh@ZoavK1 zA&;pgxCR_&4i_%Y!(USuLd!Z=h8zIAd?_SK!PbLDC>GJ)NO#fgjXE85@81bQ#t#u# z8!}KFJs#GbiIzFxFKdEh&If%Z_RMD=?($?ovm}*?f`MmbcyDI$#gU4^iXB*)y3yoVQ~RrE#>6O4 z20H!mrz_G<8Ev(TO_xZ}S!CqCL7mRa3etJ(o4ZL@Z^M*HW@I|BXyMTiC5@{gk5WVv zuUw$aR~dedUyn_oa+z4GuGPiL2v?dA?nv@2oVfL-B*C)UC}M9U5Jrt`Ql|h07oN9U zD(woy9ebbq>g}`j*B36W6Oga&+!4%-=567pC8w#ATxXFlk|9L7m-d+3z_M99>EW#_*+MQR8&MS|S`PLle@%){;)Xxffg{g(>zuH1#=b&0C{rV8-=?K1 z@G~ukd2B+UYTqImM+uCm7#Ujd0buqGN(5d>utJ0f%=Zjc{UWe3-GHB9iXw9#?$l0{ z?oS%;1E%`LCG|8hD(7wTe5Qugm$5A@uUmJlM*`)+SpnwlmjpXJeXBa2LRPE6yfJ27 za&8IiHx;bufDIG^8hVr=Gsals`reeqRRm#?vTonIQRGjq?3lJJvF7av$m-5LThmqG zp7?Ibw8*|2DQiRn%V0O$URd+mruw?49rp0G7!@osw&Ujk*FR@-=5L>F_9tXI;)+X?`qotY*2vW%V-J`!f7{>Wqu}QvEj~!E=-a>Hj{YhK z&&Tl3r-meA8>?rN+ILBAn9%x~F3Ya4SKQM(7?Z(-zR>nA9!uqqb&3Vr{CAhTo#0v; zT!Rk-jX!l1IylAa7it;~*7%WB z+@fsAJ@+8ynYvFmZ2pboXrQ;K!zVKEwc`nIYl-CK-2lb9fsbFr`G+kvQ#1Kfv#x4u zUjY@DJqxVmUrPts+HekA>fnl z*=<)Z3hBt8N-V0PmlqT|3@RTI5EN_ivF{6lb99=TOm3f@@X?MIz)M(7aO7UlU1EW; z!dndCu1rPpB&}Kf=2MV~CtbbY-W?u@z05&$pYWt{oXI5F>(`RJaT#~_p93@oPCki9 z@8YNItt3x>EM7Uf5|9#pC+pIKvnVx8tQZ~4IJB)!rRU*P4(XcTrrdXP4+j@0D$wU} zQ6UB~(i$c8iQx}0dtTdT^!eFmC-p9meDLF$Gj5lA5ikh@;w+MPM~=cde2|lm?wU zp|i$oI%F`c*YcKtE$jF7*Yj+fl4GyCSG$8;U6~(ii$}6>j&gC3qpL&j0pYx$CiLv2 zF;+mF*U!P@CIW`?z$4c7$Q*$z)KsO40g6cWnJ#VCG56!&?jiKZNBfzBnH2z0&rj+A zIQq7hwpQ0lNC95=zA(QAAMbeJ7k#TSTjr4|Fv?P@C>HdS_@a;0Ulc-cgF2zyl;e2T zF0x9eWuOX?bgD3t$C6@7EricTfe+Cn4^i}SHCGaI&fgB1sqZD%U~$N4nb(&wop+ru zr@Kr<7j)b2gx`UT-;=4F|9${amm5D$WTAdUIR@$J^Bi$LI*sN%09ZW=&1Mq`fOPUO zY5S5%&!K#k2Y}~k8l`wt!~>_S%Evd%q7j<5`W7HPWk)?1 zFM?A~k)U~K-k_zjJ=uVo-gKVy6bo%rljB?3$c9V9`d?DGbd0y7cC2#kC$=G5R^&6V zVVDdxjbg*#pXMfNAsToB8yg`yL{*~*lGbP8u^K`Vmbjv?O5cLhjx;A60Kj_Gm#2F_ z#)RZtkrCe;h$LB7K`hOp8YRnbtZo#+0#z)ra&Gc(kvHqBCE0*k9@Rc5Nxl7-X+@XSL_SQB#f7E__)izi(Xs49l5S3m>aC#`wW zMILpjX`c;39r+nXf-Ce~J!q@Rz@TRP61!Aq_tqaw2W9(p^!m0z_{rPog#UCabskm(P*t$HiUiCRyx zIRLP*lH3X`KZ#z@mEEY{yL*@RplJywhX#k+DpZ9p448$;Qg4-fCHo-fUBvPyUUbS# z9v`r@F6yX{t1eMRmbBnIW#0I^bby;lDelboT%lvSor}bi&KLw61%+3t21n+&%NATL(e3~n2_P&vZEvlbR&^o!3q$JyWqs44a8YYp!#uC`i zj2G{E3`UPE&b>SIMOpauX#)(60GG$s4N2qzxUX*hvyyvG^{0M zw}_7d_8|m+oFwrwNt&!Ws^yMb)rlH6V4SA~mTX*L1+Ba-k9FO+FwGkZ_K$q+Uag6H zB!Q1V{-WW+(i2S-l*IN0#c%+yhdzfhDmf8QT+S9-7Xa$Z_spcx1pq~;4Ld1MUOKD9 z18Q&d<}^P$NCKwtveTlYH?89R{aYqlE@NL)L!zYe1%E>tIweQ}{O&q04my|kQ6LU$ z2pj*pU@^|y1MUG`x)tr~b1^f#$ilkfqwkpbxKp9cv34QjNCIic?WjXd)f)$i>+E7x z`2&VFCsZpl>3JVBdSLwa!i?4%2A-9&V>sPgvObP-b1GK1WsN;6oM8WPZTr8?!0$C6Zdskgvb1?q9V(=Vp^l$zFpICg*l+(=A3Qn zJ2LvPA6hF*Q#mGmTefKx*df{*pk7C1r+z}szJ~)*jz!n~=lgRS`t8(h3h$p)yXy%B zOj>n0D_Zqro#19yx97)?rkrs(`lEnTk@yXz+-jdEGkQ77WJ`)p#eMS)qkBLB&=5?3 z@|g4j_uTxs87_?SD)QuGga-$#1}T$Kk!eX^%!Xr`mn-rHpXZoLXYOv#Mo{=&+aMNk z&QQKNPN~+tSLlj#G+2*3(lS#i*~$|sgZSj4@Jks_Qup1WbOXrNY2cTcESuPUKgf~K zUkJ)OWAGDpOX$~?*@)0il7EtU(iI+$y@znS5!*{R>xhf{S()$&1GpY$2QEsw@O3OF z-K^54k?q|9U>G@nwhIG}UU$>V9Xz}DbVE5V&#$_@uH9CP`s4MfHN$`{EY0dkKXl~t zwlv8nes>jBPdh~A@FNq)NOH6Im-Wxpn4+~l)1dt*rKU@?DWTqIPA3}A%P(b%CCmh5 zuSP(8vg@fwmD_s}$L&2-Oak+W8aWKDH3qVEqow{uE<)`Ko93^2)u_uSH-+dmOBOR> zCgu|mhLavp#Y?*yiNoKEX9C_Exi=aXb~8pvW&aU_{asR-?O&|E@L9<2yUKA$MB4XQ z$Hgds30lwQXXZzwHh0pPZ~RY%VaP`CY+8Exg9NgEVBkRD35@J&_Kme_R*e%L18i6J zC;PM^>8F$Yfdcx?KCGZUTL}A%lT9w%Q ziq~a30l@E&7UMC^*^%Zc84!?dsp@-|AfQLw2P+JFV^kB@X5Dz zmJRPER0)F0sg@-qY>_7!RB{re7HKW!)_fSpHz-`l(SjA?o9V~wIdDJ?7ioV zp9{Q_O{tGxzs)Hve0OAyr=2Gj%&#Hks?)BaG+d0#k%(LPe1jQV=~w1>>1?t8GcRS_ z+ixShQRzybV7qaTvuzS}k`5c%csnkoul3UJEAultp3-K|9Nh4Bm4Ezw@>{3+Q>o=- z8XfaE7?VJ|Ej-b9&ADEIy5#^YK>ZcK6h1AvybNs*MS%knrx!3i4mA}%QNLWWFbm_B!CpiXX%3mpnzL zK0TK{cV8Zy;H6;`#Nk94>OfDuE??8p;xj+`=lQgIei5zHB6y#)amN=$;tkcOLS9SV zd%lBQJOI!*Qt9OJI7!(7=V?Lez-=1qA2#~_g8AYSKNQLK-Kzus3umyd5`R?#`XE@hYXcj>s!ltTRRP zt9D$o8RGSr+;}|Xjs&242oldUKUkuL+8=uq+DHv+YbP6 z_W+s{y(;1{sk(C?8b0_)W#kY5xVcLKQF*}jGi>x~Dn}?M>CSP-v4?#g10~3^*)=&0 zF>i1J@C9k)?NfD@b7DS=@VFg*dJS?8uxswOBoF`AE?RD!PP@1_i=1`S>D>I~cVoS4ZhQ>hdBHw|xc&KY(;FW&Hv(dV4 zPM;z-F;8A=c#H)ptU^P9N1HBCbV>CA<4FkbJDWf3jC;_i13-Smt860|ztvffy)<#& z^UnJ7->F!!IfHr-;=Dj|-RfWr%p}<8oH1MF#i;Gflj-^@L5!)jc@^gDrnW?qr2Nl}MK#xTVO=%wF!)h(rQ^Ot)5870&O^svb+riY+cmDCB1>;u zX;b>vdY@zDxXS{^w-Yq<5bNSpbuZvi=QN1{u_1zgM%tk_7b;9aIQZ1E)m%B04sQs01QOJ-PM%9`#U{ib!5x((*^d$&4um!rtv z%3nOL$@)5Tj;{Zkkrc)5CtW?!f7E}d))QMkyiYLpu(G%N;i@@V^VdYGVpIO4ZS3g0Vsr~^#)br^_=r>+{t+N#+1Ld_e7z$^)8HNu8QFAKY1g5Tk zS{vZBk;R3bVap>DgCrSlKo9iq)oCVMSz-8@x>i>#s%u| zT0`JUqg6?-``4z}###Z3CsQS#UvOe`ruZor>AbVOhRl@TDzRp0?cCyw{iCR;E3U1* zuXyYXiJdNlIf>hj?7ERpK=rPTjM0 z6Q&AV(e!|~;Q(N^6kkGLEI;cn6#iQ&liWKG;C}dot`?`^&D&INI(<0%DZN5vZ6{BY z?{Z@|F_E3;;r-5A5JDyS44f|1A&O&FbzhU%Wk2{WncQ2iG;aj(%&kJ(8=?I>`cxs> z6&=G@XbHztv7qU$nh5@|3ioc&ZzK(I+_p@2{F}KhvpVp=`x_&L%H0~W#s+Z?Ar4&8 zIj5dm$&4Yp!K5?39ry4+;tkxI%80D;`ll1G)EvX<`NsquXyNQCIY1#lp%{Usj4+(z zKA(Nms-<%GC_PEo@Bh=7vd!sGjvLRt!27OIvsUX2t{S`LvOQt@g(;b)$ok~kI&>+4 z{3P&l1?dI(5-D+f364%o^>`d{qD@MWfZT3rs;n&=l&owpKL5)Tj(tyP5Lb_#0%A5kncv|8?VSc)Q;#>Xe?5sl-2vMH*) zkpV-fhz8z#*W=bYEQLLAW@VZOv;vGMhMlI^3^!;#nSMZyU}y?Q)uBkz#_jPqB++Jw zV!Ysgn^pY)(2$Ml-L|OLr&_G+D}<#%UhzCo-kTA!i%*d!jsg2M*yg8u4@Y+D23kbz zogkQK1)d;(r!Qshk-w&L{_;GFNs{jrxWJvHvWxMhNCfb_pd9zwBMW=5vymst(X*ia zJ4nni8hbfjhjs)$4jXAzYbZtP73_@jxVx{eLnl_c>MLQjZG!2p&rN7HJU@T}7d8tP zht4Lv>4$$9m&#~*MQQ(O0p|mKGqf-!=*ofP0Xe_ zu9b7t7%w7zz|>8y{xE^QOCR_XUijDd(f{)WBY%5eJCVL6tXT!jOOsui7OpZRFB%{* zpbpSZ1dV+i*CQuN8x@l6=-*3}=6fG|1x_`eNHQh9eXCiE^$<{8dG|n^_vw=knhtRr zht)6bYhcM--Vb;ft9GLVJS$e8yV78y!>rGx>GFYt?E}BvWoq4#`545U%n;aLdiTB; zog}gQX_gU-T{O;Ky#5-P_4wSgKh}0v{qIU66Yh== z`|6k|PVoI5k{UD?e_nDNyO`6KGYNMfIVJ@`#4?i06F<`P10k@GpZETIJ;;nKNE)E= z@2-R95CR19xgR@d6Z+h1g2VSm@!()3B(M7vvCAu-4oVhWv!OQ5b&W;T_YYr7^M$BE z_C;y!KwdZ4X7U-)q%vO}4iw?1j_jr1rF;B+ zUdqbPhvKJvp}UvnbWZFr0mbcyHja3&de-&%Y7GVTd4wpf9?=HcaoA25s=G0cd9-dpz7IfdI5?rQ4X2!(*mntP~H*(nW|-h;pNPak?BZD!S- zwFS1OTXgC}n&!Qqc>K7k_>);B=ek9@|hHV{;sjrR?yjZ=}c08MbA3u_0QytTwO_RaH zaxiyjJ3C!nq+=aV44UctoaA`H&XTJVh9Iy3f%lE|hDH&0qodMF?Ps0Z4glUktd0v1ycHrz^ zgK0yLzJ4I|LYHm3&5JXSHuu5(c<)%`^s+HMyaF-$`w z4#7w_sSot$ctZ&JCzse?FF~GvJ^}kjC-U;Y<#NXY)p1|&h?t5^uCOWMmtXw$NA_iC zUz(0U8E8Gz{J65>-m)?68VU=X6N)q1j2N+1rxvJ73+pauxjsGi6}7gAoTHnD>uQ`* zN~=i!00cxeHT!v z`LqG}Y#sEl@k_YF=LXFjt@rQMK6h1<0TBFsR#p(6b~bYjziqPvE@_bdrcwTC0I~HH zB|#TFaBu(S&w%RB`t847QGf58=O0cdy#$!WS!z}(B#(Tr5YcQ;4so`$bWb)4L1{K| z!9G`AJ3ZL&@P(KhrR)H(dH~od82$RhT3f^IX6#F(X2i+2rmg7Y%spVbB{(!tzj%^e zsa_|2@I%iP&=Q=J_8H7iF{@sSlej~p!aDp^<`zQ(&oEk%0tT%zxBxI0qU_~i)g~`< zvl$mm(<*24ts?T?NKNl?SY#qDL6cDvu&^#)QPQ2iRM~yT*w8`QdvELILX%NSN4;%Ek3Os4% z!=4X?s6a>9qMKL)FOt$7&ZI|qEzLX9)VaZWlv-*AYBt$-+%1JBLAoPul$S`pki7ub z+Y{~zEmbm0xR}Kk#0}{r1?-p$btTZ)u(JGlg-hdzh@BH&sTOC${cab4xOk(wkZ}o@ zw6?z7N%u;2S^c@BS^uz{_4048^D&Tj=oFX;=~kc_zReQP@=e2TbRx6$#tO{+E2`9z z!c5n(qk#%ZS4rpSo8eBK()c8F1}k_9yB`4AoPwd+RNd`EqMG*8J86;+fR;Tg2LNB= zpZme~k8PJ^L`g9=(n~ZQDiaq^Y`v1GJC#lE0C0&X7Iv|g6pz=jz@^~mpV7Y;@Q?J5qJEB13u8oe13_RG-_7TrX&dm_S3utN zKzs5jCyV39+#4#nC3>@sKs&amw{oOYDjm@E&=Cp)jEpKTN=VdrH&stJY{r#jZOtem zNyf8UAK0GqG>K}g-fmizR7VJ)=SXZ@@GW$Yr4$%XcB3dEFz~fajELB63-hXqWNcce zvV{FA-TtY`YWH9|X|Aqe6QyH1vmVgpN^H;tL-&@tswj3&Z^v`@pT-447yZeOBpw?7 z$og@N9ET(A%Hku1==;eOa*Wi>*w7yEJB@uIZ9|gne4=Zg`#w;X4vlbZgj0Xg+@O18 z4ceD!Flnkle0<_<#oDuh3-j6mj&aK!UiV58JdXazDDJU-a3NM8zQ9sfA`r=v)xEe; zI1rec*y!0xH|b|cjo)uCZwjgI*`WEUOcY6KFpW3xa{s-{>-jS?NDUWC4doKD!0x-! z6@k_(8lA&uVim&nw1Rq=g6CCdj;Z;JZ%@J_`O<4c!$y4IYE@vI(E%V9QkC%|DD~QU z^2a<{Gf+sWz~1A@@GSQja>-&v6+?~!5Q{l)?XAur80Uvq{0B+BqQvS+xT38r351+AZbcf9w*x!(G3bRWseDr?&`+QLbjhGmoG(&t=N~^Lb zTa$yr(}77xg4vm>w7hr7Y1|>1+I&gBz}X&j?=_U~LY5S*lZZy91L?Dl(9+mo;+cifpmhhwbF2tQ2&Q5XGZ1p^3(ZJS&6&h*p49#y|Ln z==k@Q=`LfF8r48ABMrP+;qOLty4cTic`n@Sl%xAY4;w)PrBZ%#!AHGdrEd8>n1Ek{ zW`!N<6D$+n!UcaYBYJx!34UDp+L_{ad7mCk23PwTyoQ@Vhr%9%4>yVUxz729uB)Gz zQ@dYXR(ds(|LUdYUh!(Ct>S&ugRf_8MPQT-&2+?sxva)~EGUDBEVlLCMzvECP3o7==i5&y2i>Bop}xy*N0w!%f?Uh@N{ zJ&0T0ML~uRSa;i=vhW$HFX-Kf?Hpdbh;@HOMrvMBQry=SO)gZ-sPnl&JuhOXwv+04Du9HTN=R0yV z)fRV|kXvh}jPqg2&bN1P_|gU2^SGu2OsX`Y$Wk6(BOcd}l7y*I_y*M(@-AlPXf2H0 z&=sT!QG*82Ul04`w96fC!8EekoV}?cuco_3CwI4;?B$8`yLCXbH}*LZc@E`Z{-t76 zXVZxqTvhGG_mAbxBZcj=p74{*T`pv)7`b#i!D6%n34?v~y6?i5f5~9|Wp)bu4<)%m zm1{>yOqvIP(1;G=<@+z{B;$OE7?ce~A*Ut7Sz!M@XNC3$k5yeF-#+I6SK<}D|DXmXZ?pS{IEK_kfMmsig>AXhs)SqCQ+PR*=nZud^iOP zq8H@q@t;~Av{WQh>DDWdHf}3IEz}UW{n;_p)dw%r%|Xc@6^nFBqciymY_*s!Q9 zH324bhm>=pR$+NljGC|h$V_kr@Oc$F?Yp*)pJ)RDX(vbhX4*VIW%!v)GJQ=HVPDgN zA=~x_J#GzMLInXo)5LHFThRukd`TM*2wPiM#_9V8a=~)Ht{|khtNYVO#3Uz)*lU$< zV%ZD$OrP?fB!J(5N$2SG_u1sOfo}3uieiPy{jG9a^wI4mqZA%%SOR6D>sX6)xJhMF z2#?DFz_9l?$zBs59-$G8;q+ZY5n%dHLQ9zEMAWb?^K|w+lL3(U-0Z}1Hi-?F4 zsuZb-f`Wh$5fKF?(gdW0UZeyJ5a~!U(t9V6Py;F6?U^}uelv5e*`0^J{>kb&mSrUmytpQTQ-8NwF1E zXl@&SXB_GDwtzhM`KR59=VkgHtEu<-8EgWJ+qeM0*SymeX$j#9KF*4s!t9W~s2{;}j`U(zIcabbHB3R;~Br?<5FM32WYRjfAV(O*nzL z&g&@2cvy;;>3ty}WdCI-ht4};#ykjCYu5K&QRs652E~Fr_j7^=0hACl9MxgBGWHH2 z-@p7+asRZGnBaZTTp8lf#gtpopq#x}44NVZj80CAi>fnZZPQfRK^>l=;@)fLE>bQ4 za!R9jLtX^4J*h(V7k3)e-XgB))K#7nPAE{NGOgR`wrIj5`fOq~2}^V1uMpw;(zjn$ zYU{7$`)NeKp8+gzoiBS?>CGUkt8Z(Cq!w)VrGJ5!)l!>lcDGle>LNQ+Km_gWHdgD>b1;31Hm z-~YuQ{Pn;t@{gq^b+YL%^?ZpJkwskVF4UD?zp2uxOhhoEJrQ=B%u2$K8eq@ES99UD z`MvpwsfH_NG7(+tI{F&XzRB9W#xHI?&<2}F z6(@gd!LBUhEx_!5(0iOiN@ZZcXm3(SuEgiO+G*rz7|FuqM6Vg8>b6_+$b!^D6fGOm zgQlFsN5)o>tK81GQ;#G-EC6L9+E>gc?`kbK%W8D5t&+HH@uT2Szz|7q1ApJ`f9(w` z1fDa{(3~|rxlUq$!qEghWjHZ%uAjZ=vt<_(*9A0=pF%f_GCUgR^d!MaoyF@Z^fsG- ztel0lNP0_Wv8#^rqZD2q%;CCKNF3u$od8)iev-~U)F><)Y9;S@{SZb1egM_;k)2@+ z8AqW>m*-;r5&LMyHGb@nFQa>1_g!uBE>7aZK*W@c6J?ZaE z&T-+F+;J7t;Q2+cOrL`#C$F`b+9f+%l{nI0^^||^)(uK}!1!A~RjOh_ zQz_-s=MRCXb}yJ5bQ=R?CB*3wH7e9=G|7(|PBmVX@QzE*jPy>Wvp(D%XJ-f^B!YFw zTsSU)5elU7nHKM0m91K{E3iKTlW;*aZCV{kw;L z&#F?U0&MjKhuhCG1rj!O0bm;jJo;Y7>Gfz~hWvGjVdXHm$B~_@%rl-|En7{&96*aa zpal{R10jwK1)n3k9@jc^Ye_;jGCaXkzYR9%{J2K@z5mto6(mNSaFd5?D)%)vLGk|W zV5R2(mDR%92f|8*#?X@(ZS}Qot17)MBIZN-Ebs$IWTfkv-|^*DyIk>9Hh=WF1Mygl zYi@tt?Nd?Gxe`F!Mw$uJ>H*ws#Qro!8ohNIp8JviFs#Nv) z?1-nPGxHiIaZ+|g(Ax9`2#6svZz2y=ieE1{>8NB5Sa*;_b4}1x$o)xB8dWzUNJ+woZF+o^NO4PdOpr=Ec^$+K`Kmng{J#6^* zLG2$=Nqv~!!{AxMpC^}PJTA|OfP-dWS-Y+a_oB6e!}nsv-z6E}?U|GaKmQXAyb(Q) zeR`98_(5Fjz;netz!%?{xYoH)Y*Mo*wlk?&8v4D1*E^By%cZFgbUiIky*Hb%^NT+g zGq8o}bq%(2<2qlgeg%;*`b|`c25#S&6R{y-&K7&cQ!JgMt=|HSE3;><=!E+(rPz+u z;0%$qfT{kMu zEMS(LH>YE7c|Q+K@<@a|oRpy&R&7JxlPd3APGwgd0CNK?;=^A8I(q;-&kYynCLhE^ zmYy8sNItPHA?H;P7PW>mY%`EJ(&HA=MN%{V>P|1^XAwd?>cT`COK<| zwgMfdh1J3D z8s{=M>C{QlBY|g`i-pmL-7l+Up4ORud4KUNZv&6C5dT&aqQR(C=A3DAH{&#Z9DZZT z=&|ozIay#Cck%jxa=2TB4XUl6>j0aL6$uzC-zGB101c>w8o0jl2u@?V=T8Uk z9{G^?RW&dshMP%-sF2Q# z;~z0tXzINT5XE#<&9USu_>}w^;Vpy3pIX3Seb>l@CBFGjFZhn+#nB#G)*AM`m|dC4 z5#uwrezgKz0VP&19S8t2!*zrxx96G|3LlM)MJ~#&;Kjg&l_?@t;*);taiQ&IOnYE0 zQZ)W420Q3XY*`C~nI`wKIhp-5G#)2)eUG4wzIm*6Zb$pNhLwzcPgV=aqJee>s@{Gy zJZf8~cRr4Ur}2et&5{*}F!HH6)8Z=MZdruEQ8tcQj7T{UoS#{YN#}RHFZDbyzOScZ zH;D!pu(w$J*gJwA6uNB|(Wcmqb4W-_cuMckoAghu+f=PW8BhLVla8aJ7|}?e*7fk| zj;j-qlmKO9)&(#`O4O?xx}Gi;l1k;F-K(OUB-?Wo&Nu*UM%`x5J@LC<_5dVsWaP#? zO6j^V>t8KvHC&z{m*)$U*sbidyWjv1@5`81vQDxramLJ(;FcyI!H+nxPx21x;@IhR zDdo=V?I+c${nR_oo4wWhVSjf7Q0q;;(7Y<^iPg`8X=Om^l&g1Qj~`IS`UZXMX&}MG zr_I(ft+ll}WFe)4)iDVhf1n1sKO5Ux1GUTctS2xBZR@(G1qu4U*~&1K&`H3#NU=f* zDqmfGHt_xLL#1mLlHEr`bKT4w53&RgQP28^n@Hep4<7#36-R;2k=**1AtG8%Qc=Oz zx*K;whh*4Xw=trzSdPizp`~vNhHhfq+f{Bl*3y978YWTu_tFl`e^BapV=P=pBfcSU zvg725(M$W7%K{SkfhyN7E=!=Im{+DR!Qh_q7UWaiu|h)WH;k*TMqDSjr*t`o1&C7N zK+(IH2l6cUm{lr#I+b79`Y<)@l@RY1TK&(=NGOqZOI? zU4=`DPk%sRQw`{=h1d)QZTQE+!~;xX@OiFR1*mgHi7ey=yZon3R!ka`HIp4wl*@8n z2DK*ea)98I;fbMmZ|UkVvPs!b}ITwyEBsD279wI_>&b zol}&>xhCt9B1^}aX0z7Zp}ikHQ0P+qD2DPGn&%6A+DR&SQA z>u=rsN#fYc;thZ%Kq$@jeJgYBc-g1$n27T~<$J!Khi^>xmqK372!w-+SL82rfbR9KM|0Q;O!krm44+-M3-(LwVW~^LJIyxzkivcr0KrGdosj9HQZul(Z4pXEy)PIs z_L8@d8$77FQ&Ef<$OMj|{+;RFBXk0YG_fj*-g%;ZeuCz)hGHDk0f@opq#5_-G4s6) zQSB-8?oW^zjJFRKhbPtLrkWRwRANkIdAVpIP!`p4L(XwqJF^tRh$Nn-p znX(OSj;mzxtbH-*_}Ss%%GlEjFSS{b7nXpN5+gV4n7*Uv^lx!32LPX)yBVA`6PPIN ze8L=66<@*Pei^4OiLlCF@Ekq!R!WRh^nT=y3j3+I8m%UBJWJDoFd9z~V?XsSiMQby z&4}Ee;V}s&7N_EOA0N3D5{Qh0Ri=;TSPwR2)tA4F;yEqIbifPBUjoY+Cn@60V`PFP zc3|3_UPA9>tZFXwFIUTdE(4;^*C*bkMV)k2%ur)a+F##+@cR)q`Of5K#*SzMvCAt2 z&$wM#P;C-^TF4eNW`yH?@|fK;Z%g0L<|Pz=^JqA(dCj>QM1m?%q)n4aHlLu7eYE|m zM85@bFiMUw?e;Ki0fskWV1jZ-4Uvf1>rR@lUrj%Uf1sq36`CN2X?KIBJOpf8e0}|9 zN{+U0d_(Zp<6*IL>Tik?0!CBxx9+o%-pa-^3oF@E4a-I7*<(cWFZPC;KM?<(UtaoV zuhqP^%`*9}o<%Go>OtkI$@epCXp-cnmg}k4qP|S)q-6DGA_{CrqO)=M)|7MnG>?VA zOh$Bwc-H&R4oN&h*ZrHpTW7Xx>9rdJrAuZ%1sf!{ywy2(a_)%F2BufdIdauiUTV6l zwKDzDaiN;q-1gM;%`Ee{2$cqxi^L|Y60+*+Nllf$(zaJK;iivm%A6LVchX(fVefLa zQIY8;S+`^T7LqEH37Syt+_XOVi`cAY?etc_C zIMq{W;&HXKsN$4qpbvk3k9HE@mZ9MN;irTqm^k9(x1sBha6n_JwSLt}i_55*jNFPW zjuk3ZI8e94SgO=k{szSbhNr5gD^*q=e;aG4veU)qp5CRkXOU6sWrDvdlm3Egk*ZJU_ppc^dZ_gmU7|4Lsp;_ay*65l+^Xa*Mn!YJT{LR;p$mXM77K+2I-5GFdm1-QQqd3$tOW5jaB zm5SD)_xlDJ(Y&!`j9Y-~q;($y#J!!eqHEMO8@ya5!j3jfVyi$DDK_FrDx)9G$%DV1 z+)Cc}CQANB*T{u>FfoZP@pwJ!dI%s(@3<4zWV$bf>(IKaD8yHepgW65GuKl~s~e^n z{NsrK`uVSn4c)!JAT)OAJOv&~^d-{!Xs?1Lp1jL87kkR5Pzn3|vtQ(0J9@I^Jp1xm z*C5vv>~S44O}S6Yck=Fe4*$35C^cspbv%%M+7B2Ik3k$BQg)^(x{I3 z4kQajcFs%<*0qzeXnewg8yn(^#qh|p_?3?!5~g(!JlNp1@617`{qrBiO(i56EEBbI za(6)Gmgw>`56U>4KCYF|l`jLC)26QwxY?e;diV1y;BUgTyHF=;7Rbo77C!Qw$(~G) z!*L3H(y!VDO>qrrbnY6umFC{P=}4bc)SrP#QK(aiF*Ki1lbNX};r{j-gxKO0pbl|j ziV`6b)#F{fj56Mz;6PfNedH?%0E?y;dS|v-*CG*Vfr%G1VR!OIDgqW%0w`))vNcv0U z9ghQyFK7-~Ew^`_#YUub6Tu}B#d)O6?hVl>1}Abn30A@N1acb`RsL0&xS#{7t=xC# z4XqlDnS%|(Lbbf!QK)Cb8dF4GJD0z`us2Js%Mn&Et)A9A(VN&<0g0hd!xpEl27=TW zGfM&kemi2Bd=I9t5Nd*dH!k-Vk5I~p&7s&(ROxidq3j1QrQYquCIT$+2pXS3G4fLw z#V&C9F^8?OyT8zQss}EP2n#|sT*Z12HMjgoyfhtBNT&+XQr)pt^t6qq^71|;=o2=o zi-!_#MMhMIOuD&SCIu~6J3Ff%PtL(So(x{O21s&eSLUT7t9N$& z)C0_3d-ght_|3#`e1AYb#Vj1VA?^H1OJ`NJH!-)5fwMoo~sKKRoo zgU+8C#2bAu^FUcM8(`(cVEbHD(R&!+(W=6PmzwGsnz38sVBVo#pzL)Jo3><)30JwJ z(!uHI;p;w>9_KFu?`|s*uGILD2|=f>(~RS~J4ja>2-ezYN4kcbim{xYN>%SI-t&v> zA2*KlZ@LmD?$dYxaT@+q8k|&%{e%)3b|uI@SGy@6fEJL@@%@vS6?!SoT(};3LI{_iQDNqdP4nTfDKl#q2u{f(A(;|>mp>5L~H2K_in z{}iX8A4vC1SJ7X)H7m73{y0qZv-qj9@O;JljSoLfj4_5TkBEf0j74n= z*YK+K$ZcQn;D*S50qPOM-p+CCHy)v+;OA37p0?|6U@A^7ieod~J3~`l%^0EJ5K3Y; zO`rU@w@Z6z`Y7ZWXM?^2(OyAeq{%Ysyo}`yJywLVW!{ID&h$P;EzTkJJa?9fO#hMrif5P4`kyM5Y`y$g>jo(=d}p{cfj=)dGR(F4ToFN8U4|Q(F5B!HHIAPH3X0W z3q1olf2$U7W8T*tOG6Q5VKn;9VC|RRnYy)friiN)|1-qnKq-XWHl2R@fBqci$(?kn z@z4FkkF+7@g+X3h+cYhat>@pFQeRRTj3hIPzZ6jdIQIA|ovuRW=ac=*a86Au1Bul3 zzjm+ix9-s-lG&g>Biwk5x(lC_k!JJ&q?N9(Qn&#RI`dygABOm4^!k7IW0deHNNEvr zee-4UfeOaM)NPQ*{~YZel=OXm3L)g_^)GMggik5 z|KcH0I>Pav5K@Gdx#Cx$Tw zEK*P{6Ob(Up_-!J{bMcsvtNI5A@wg9?w2I_uPp}u^xf5ppH&)u10Vhq(*1Ya{jntP zFC+i`_w+I*Y4H~c8(sBX13=L*o+BgTY{W8IRaqAIlQJ6VLVr&=3Ha8dfI{F9pp|mB zZiRUExH;;j85ZLTtxfctRTgj-wAKj(ok=F^aqP*Mxjz8vst8AjQE*M$a!&8QnVil= zCAw>DFf29>VwTTQ^=xhA@LMcx)#YG7S0xLFVfJ?!)C@X!YE0?rK51q9d?$}A;0_Wr z@0K2C-yIC*GP!#N=Cwmd^5$l_YRdt|b{R?eKbZt6WtBmz>I*xAfz8+ zLg)iWqgJ-K1N_;#QlO|yK)BrLjY?D#wNtBTr7Na`GNw@9(u+L}FdY>c`zcCfkx4dj z;hx!KHGCUEg($HlM9=7=we>nKzzDIg$5AYIEcZKRET|SXhcU_Ce6#ER8Z=Vzg!7v% zwExPu^~s=q9U|9b%p^i0W#gn|P1n>_z(^IZHe*=o34ycG8t2~}9_pzPUp1>Pe1Y>7 z(z93819*J>8y=i4N>5a@bvRztLu8{<%GL-?kO9qcLKFO?Yt6YVIc$=lf(wgV%7`{N zk-xrYW)_&V_RV`^JOMMVcHjWa8YFHJyouX-44knmypF#FZBKDh7?PXXc_g=8zw!A; z8b7C>rk&@H*fr6#d6+*N8C86Sg&QVkHCm{n{vWue!Y{W0VP@9eeY`h)S6svM#M9q zNf+)_lPbcZw^IwdBgutO)#kAk9McAWn58i6qVg_zNq^kdS;?r2jkJZ|O7#-NAC{ zHk2S-p(@>gIE*u>0$#KG_JN|zwaq7v#-U@ zeZ@)@n|aYOXWeIuvic5}T813V`Et4dQ_=_3_6p`|Wdm7f`35}fxM6EAub$<8wfHUA z)w;HF@EiY58`T=oA}&ICn`P@?fs>Zq{Hb~NqV3AA52n^#A#|(Y_9E@@xKEzfD;c$q z@-Y^GWLD*eZyF!Uq;hB}6bw!S|H$|CX*(BQz9LcQBJutX!ZM85OWNCO3AhB0BPOyx zT@v9*QyA?+x`u$s{V&o5heB(FX`1S-GBcD2y{xuw`l=KjFBB1ThdvV3XRaF{_2ECo z2gpB|$@vX$>~E`QzTM$5qDE%T^&x5_!#|6)<2a8K7>q806{2xNCS3JX&1b@t?e->n z#l8j15nZ&RR?T{cI#Hf{ccSZn%|f}>#drK-8c~~Yn~5S_2~hE_~7T6obaLrr4d!*o2BD5H@u?OPuE_utPu|7 zG+~pR|F&9?bkL~P23&aHUO^9d=PJF10SI48Qn~`%G7H=an36pOg*?u|`h*w3N0>7a zTF3^g8nIi!{0>us%|nsS29aW)Pzy;r?s9DtFxIZGA|P13RgS~@ajp_Mu7+0WG^{Wr z$@G0Yu3jF3SGd<9C z?8=sJcPmI1Y<}3&7IMTrA<{dT=9M%zS9fJ#$f`m(G*-3OIF(?=>60j6Dj?qf(A)2t zrEc>(_Hj7}!+`j0mmOEXPca{bEABt4(6T((^i5PaRVPg#2Al6)q4A`diSDxF)4iOj zH{&5}Wlf1b`|*psBd5HBKfXvCywgqjGTujmHHr|AA{NU7Z(`G=`u4adP`0Ta{!VVb z)gb|Wvhg$bG>O3WOpRW3yvZEGt!KP+Rv&rsq}nyONsI%8FYHmsrQe+Je|cm7$8C2r^2SOp(J5p4sC6U2w15okPvcX3x7#dT$-{jNfkxZwKY)58LzJoT! zUMZF1BHB6x5BUzt4fY)d;CjSa zcqGn-oH%EK=jUAy1lH+>uHN&%ky!boF^~WAn(Dv5=fCt6941_j@|%Bp(AnHXQ%QL% zYr-rNJ0VGmd7mz_!peky&l*UtU8z@wy%_`Q#2WRZ0nGmBCQu7~ZGeeN7+wgrVIjl1 z1H>UquLLcY;L7W^2%c+8bxx`Cg^O%QfXV~k!&5Vuli^EQ{8fB(HO%!~aocS1RQ?_H z9r#U-9s?10+szvL%`!K?>K9S*DVZYTIh<*fY0DRZ(MZ3VNsdx*(_Q?%Qc(rYz)R3} zNO;+?zWtrL0Wa=@tqbjC`bxcx9&c%jbCAAuxzK?4S}2Nk@yy^sbm&yD-Ts$1+0Ir1 zWxLS%7=Q!yeo&h@PBh#E>uPNGhc*t>O zOdKc~bga#I8Aszn-vO$-Zqe`jmXizaM(_jKTv80}+?UPkBDc)#8kdnHDs%l>CZ%EY z!LN@^jp7n-J6k8cRlo4Dh<=S?+!RMi$8FUeEx&QI>TIhv7!ZIc;8F*4%N#+`+!V~j zNZteul-8FA?12IBc&V;u4$WA0$#TrbM)gcaf`D z`O4Zfc)(JU0Blzx=K0P?K%mjD05QAs>K<5llE`L_tE|4_pU?U6np{zLErUyCCxUv_ zzsh%vPe1GBupGmMn%pdYtn`bPws*Gu+Z^Heg+c5Qn%m^bA8gIdmKHgAHl2QwsPAj4 zs0J=12W0kag7?EB@?-~KF?P7OQh(cr{97XTciOQ1c>!z<ZieBjn0%Ndx@b+ zOdl$o0VyIQqWMQkL-l0#Hz6)T-_dl)D>>tC7Vi1BJCZRAgLSyal_;u?J3o45V0P9D zXZr%6YAqdvoZtU+#e@ZVFsip9jw_iRg>0q zj`^$iQsU+pg6pT;;5YaE~Ff7fYX!^!u9YoyMIl|2NhQ7l+gx#~Wk`?$DUmzqD; zlD&9E==ihg_-jif+R*8o*n%aCp|oXG@7gkp;tLCD{`s^hawq9`T#mCr0u3HfiGVzS zmZL|0^Ywfjm#U(t5PVyrfuUJJj(x~klvQ|VT5QjJ2zaL-lcmEPjOecuaQU*Z8}_<% z$KXK52LG0=L?h@*?lK%Qg00_qLp>gQqW>-?08}pbp`7)0TMoegQ6ObChOptSuLa^G zGI$#6c{{yQ`mrisr&*%tvHVA^*?mSMK6M?GLGlz~RWtBxLU{q3`=&Uou8uGbe^qJf zAwRXu5ipABjGCoa9)};Eq!r)Dcj)r0vAk5lQJ%e!sW&^)wBu;yJvtYvmUqzXYDHlM ze26e0?5mTo#@2+5y@5LsmiqaY#Hu1--;|X*3Ms<&J*Bk*-hB->j#~$3H_+c9j<@C7 zo(RjT{3(5od6SW__VC1({y>`4>2{Y{!3cXy+h^(<9brC)7QP=u zqV_ZYIWGEB_sdm19TRk|dxf<#Sy>O)Jz4jTbcQH){C%4lUj;K0BydMOYIBXYE)Z6n zE+=3bp&cwMlWRaf+s#m;C||F%F_2d+5_KPkW;RTY9N4U>utf&m0#Q{E8XF6SFuMzl zGNcIE`S*;~?zP2fpP7=1&-A!D@^*M>^;IvG&FVmw1e+aRdz%7ApZLM>=GhI=Ga1!ons{8&CX4q9TC&Hq8m*0l1)^YHEOKL z`9S?a9f65Ow|fcZcuz|C1*y64%{S=%1W@Y=#5(@S0xkOy@RP!HBq{0j1P+}@%_D4@ z-Vb57DHpct3X}Tfw9L8JnHDuCv0C#OxNKLEzt~AL(=NyGI-B#DMik+oz*JUPjo#&< zwwbwton44Ms8NFyA!l?FTfLz*_v|Y6BXJF4 zQ-*xP;O-^T7CeZZ8mzt^be1>JCzR-|7*fIm#R1LJIkcnxkPAO3$be3(e7etq)lGju zQbBF)N@$eEof*D&frJCN}ArWx{m;C}&^rxVBk literal 0 HcmV?d00001 diff --git a/docker/fedimint-ui/assets/img/app-icons/fedimint.png b/docker/fedimint-ui/assets/img/app-icons/fedimint.png new file mode 100644 index 0000000000000000000000000000000000000000..4a759c5501a48a0fe42c3c4992759a4c73cd8265 GIT binary patch literal 41944 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 literal 0 HcmV?d00001 diff --git a/docker/fedimint-ui/assets/img/bg-network.jpg b/docker/fedimint-ui/assets/img/bg-network.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f474fa1f400351dfaa9cf03a0240f76adf901db0 GIT binary patch literal 999074 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

-{_VJ?Rv^uC`t|cKrR7 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 z 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

yF@#4|1UCdPs-Sd;o|vqtpzzIpMR%|!&30$lyh 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ˬ~VKxxoqAO z7&=vFZ^UrV`*b0FBsqJgcZ`)Z+$$A!xyLn4GN`H_$-58lw@}agZreSrw$L zJ?1H`Uclfg31yrM9twqkF&e2U&Z#MFW28&%Vo5WOiN8d*-aqh(*EnxGX!A6%kzym$ z*>h<2#wVbs)nNFTKBar?B^CO)}1xpyNPwC?@TGf4pCvLsTQ#ZuJ9(t*|?hLs3s_XkG z;Raren?7y6ksL0qQ2tNI>QWJzB2i4LVw7H`naz(Q?|%FA#qw<``}JH%ZCKfO(LXDY zL*eH|3}k%v5v8;n(HgkrHbNof%B>eNGG`+YSJ`Xo8~BB(-bPSXuS@Dd=7C%6uQn-{LpBroM9la?6I*8 zJ)0yUf(CvgF^1<|a)=kDGwRyA*AOgfPa&!kt=IvS>3)?ZPG+OJ*b4*z7?bEyR5J$Y zEz}YD&Mn+C6}h3H#x_1?CW*^rcm_|7rjrI-NuuNZ5gf(wHuacuniH`tKnO>o6-F#O zK9rhTYP%0bH`C!vgUcP#QyKadj8hxIh2h*$YNID`dT_;1U{*OS#%aHlk+koDjrR^K z1P0A+Sj^;V9WnM%-D}~frcN^nhzSZ_szg@r8S^GKELQCfHM<3>U#22`rRbm*Qed?4 zoCH?=U;ch#l;9UOIYSG{-;;U$i^IsV#n2Gp=q0iLfm*2kJDAF|eV>rL$^g%yWX+#^BowL^%XZ;TVK$m(TRO z@pPUPh4is{6odO>lQBSz4oSl$v_`#bno=B|v5^!0L6s(VF%aV*0;(yKJvhEB;O*V#-ri@D_Hjta^Xp zc?vlfBBo7D{KI<^W(tOXYpQP>HuYW*eU4N_ zCk@G^mzo**vaN~PAVxqhQKB%uF0Vzu%13(PGHsD4t_T4SymeaGjo^@N;$M{zEXN=h zLl-i4)a}hEi=(n97rqhFs-0qi`nl|D;qyUNAh_7>NW`-NKFU41pWYm|GUO@R1Wsxk1f6(qM>+I6@L#?C`6e@qyvWi)60xmYQrQwVNM?kTK%)RYlCT&}VTfieU9wJ)((GV+K7N}yKo zHlopYGg>{wl$nPZg~cr3e@pz1or0?AbX0wYb@=KlF zwkza5sJd}#j7t8QQ51YJVYV)$WiTKcsT65;z%)9-ek$iW2aTMwg>L-9iU+A5)i27p zZ(cRGPvOh+SAIzQ7GC&?F^s59&TxqA&z^IBx_9eU_T3K3balJX?8IdiON?WgXY+1Gv!51j zlkIr?8WZ&zLP7o?M#Wm!2EeOsV_mLZbA$O1Bf$NUIC#&qkE2PNe{!DX@14H@a&G4p zLIPrguitDX4UchW`JEsY9tpHw4ez~uZ4wg^YxO-|@KvbOmKL)Eh(ijqRBkNG$mBMK zEI!uXvrY6#d#6o_Nhl5eQu4C2{mF!qWw#&E`va!zij;} z&M#b~dyJeH=*YG8b&z6qgl^yC3hT0@yG)%_CKba4RnX`2EKj`9 zrDf{OxJqd0Zu|vAfZ{*%?0(AqSOK~-Z~zh0UHyYTMOPe` zNX4{%enBkPm(tB{XJCI!P@WjA^d5%!6kTt{4Z(oK&&1e;qi4}VY{Hv`4Y=KvQ#7c& z-+OE6Uy$C7;K{*AM_qQ37s@mk4P(!_C|(A9_QV(9k#ILpN-*J6l-X$a-9w|FTk-`T4w@ zk|GBCkqakGu?$+Lga+gEB|89J+`wCvuK~}-W;KB%m58XqrbGecz0l7W*M=E~lKnoC zM2xpLg;+%kPu#v^PFEXiFdRhuP8DlcP8AfTSxqa(w6Q2or(ZRI#B2f~_TiiO>uea& zM((%A@VFXU#8Hg=7^(Cue zC2yKo!KeXryB)%wKJmj0!(J9#&0q;qcIV|m!9)2wqek||yBjygJc+v?yM+Va&$(QM zd8f&d6vUSMHx&!Bz7%776L#@ehvvi|ccbmJ`>Ah1i_ul+UX^*)Hix8PgBvJyc%t@7 zsfq^>>sY1oE(%CFKm&lywtNlb``4Oi;j!H9Wt-W?W25h>HFwX|MDaP0Hvd+~_g6Y2 zLyLQ{RPLr-;Oqso`TRV&-+nXOe z+@D|Q;XuJtS4STwYfIblHV6D*%bOg&tQvW989?GO7D4lD_!RQ_kIxU|Yo0A6P*+re z|Gaml0&uYhnhV0shdC*lhTf+2(U`Yi>!Pt&^GxTW+n6$i9xFgn&M?ajl`ip(zjG&) zMhm!_+hf>vo+bD?L;X)`HWtCYj2FbJ8@v|8T4}<%9tu>!mTArHN(V!? zBB*y~>l@S8_7R&-al6^XWCo32o%0jRzhX0`l?)@WxAk4l0XlZ0onb~OL)`Nmui6arK{9KE!6%949>5{Pkngt!Ll?^ccnLFToSD z7vzs@y&n%_3Kp#E(FvsCv!`?LoA--*Ft!1!yLhXgvlm<)*Z_cKyQ%nYL?|$7*nzT@ zr$gJjXTp5|t45wFJaRPSnAkh*O<-*P2f7YA{fslY={RwP z&Rqsp#6Y-tjWHWY5&rjx>osn%#sF@$1el-PZ2;vFpb8K_c)NJZ8Mqw}7|P1W$vTM9 zHjjRLKev#IsMi2S*5LK<>VJZ33 z_jo^W!NpEH#MijthZ+GZTZubteTN6$Ux5V|X@@#jzQ|qb z&Rq!psX3nse3Z4zj=_u{tffzuGoDk0gW*2x?H$#o>(W#AxbUkc5CHy}Z8<}UM*f%c zYJL3+D>Hj&n5t?g2?Rh{_2bVL3u8JXmB1Tl``F-^eVzXaC5X*~w(v6^!E5p}mM0MP6G z0>*0>&Xoy|0pP2TALk#JDlUg--;2@=I?x{(1DXm<^d{ex0y> z<)0OPj-gZKQ&(W@_LE@I53mp>l{SA5SI7*=44&zH`qi~ zaro%xI=0X&OF0QGk)M(_d9Z}S;mVgkD!#LrH*`QZD4DelLg*ljeniTzsdo=el<7Lh zUoE2GA0R_O0osP_j7PwT)~mpaj|6IWY7fw!Fof~Qyiz%S<5alo^Tb2Vhw27@w=h1_YZqXkH>WEeDZ}OpWS+UOfTKe_ zv)AxVxDTAx$og+{H3#Ms@cE|!^lv8?7E_>ZU!dEEiB5i}cx5V<{P({j1nIyQ#JHA@ zVoR-O6sbG@36rHll15?lpTHVAKKd^C2L(WpQyhiJ#-yJmD|Ooy6E5##H^;-+= zzP5{NiuHQA!?Cv0s?v=R1l7t#!rMd^c){Ykn=x(ujuS2b74fQrG#CTGlK$Jd6K-(j zc1-16`Z>R_9Vt(H*04wGu zdx*L!0QNiJKW@Yj)8k5z#k@RAGj z4gv$8rT-4G#~>sWJV^~$tdoZ32N?f!s$H0DaVT_bvU#@hQc)NFs?6h~Z7* zzg13O0d%%GPc-*ts=x7YZyHnMviT*h1`8RB~U+))63d-`T4PY2)q2 zZhpgNMaBY0qp^7g9`M+^i%KYvT_>-YYPOT~cVd}<;qNRw7Pt>wOYwM}5xSh&A3D!3 z&O?25Bik4jPY&aaZ#O&`smuMFWb=dcAf#*k)0O56^>+KkKO5cZ(|KnEl8Bb%S3=?> z8!+Vmn3a_;H7L7ZtsUJ-$K!gNuk`|LCW8s24gxX42YlA&a;T3}z5op+PyM4w^p_7E-2|yi*i`W0i^M zhwMr1PzoGotnt!Wqlvzx)}6_pyPCSdeM<3-DBv?SeTZ46V^~azwQ}++N$(GVt18q9 zreb8}^*)FH59EDs9c~L091QVn>=3Qd*z}F=&2L_Dy7W$6R*k~bMuSM_vZvA0J$lh! zhXGa+1QrqTeb3G2%hCS>RU0t|UUZ&dKsjvz?)%_m7~topOS!@6VVd3Ph!bLpy|Y1r zSErt&LYG-UP8S&aYo);rLpLqXGvFj`0>cIXxBO`odLzxSf%xa`0Pw*XgK#_iSA=sI;G`R3m{9 zZn*s{SfKe7gy#s&Cw~rR8;&ppzjf5~f@93j`aJ*b(K<+LW;ZSEnUWZG1G~Q14gsb= zkJqW45{_ABE8%&-;lSfvmhQx$chrXGORcn=Q=|&p<=)p!-1E^H?M^K$1%`?Qha1;v}tn zOhD88HEzuh=hS97r9;#*TPUO2f?-qN_wNvER5*nm{<^r(Y5(u^hLV5##*Z?5Cr%)Yu0QMo9ViA-qwsDH9$}?9 zx0eHjiR^fGoMYyyU%=E1zEl53^T;WG&&RrKtD|Pna6MuINqe$BwBx`yRX2sHesxf- zes)Np&^n>=Q0f#8On%A~_jrF!T~S|%39Y^r*>(EF)`hA36YN&ypvs*wP^Ii6_Sy@= zIoA?pReBdu%1pNpReHJ^8#^oeYu^~en2kCg=nIasWqyx@5;FOW=V$uB~Z^#2&wSSV!^4k*PVv&_A>j2# z&Qq-*U$TOnFqUV&^!OV-e z!U->+q4 zlgb*<-h>s3PJj_^QAdCILPjzoJa^GsWOxKo#8G&seqa&&NnZaLXT!6|U;~BxGpBEV z3T4S8)t5y zpud9SBFT3XpMLJh%(&_Cu6utY2_m;(@eN~<=k>7NEzm`|0rd+4X_Wbf>`4+enu%Yg zkc<(;4NP3A)7+8ULJf(C8BRr?WE=02N1i7d#CG(_Kq&=rVIj_vf;z6Yfpdlqq)}NI zEr{ULztA&p40^s23rh(>4`wd_15Rsi?v>)k-y)nxo;?8tZ78?5POOOUwZ0)rABrTTU1sl+70zoi#9?0PggPwrgDISGn8BwSEj{)?t+e#j+9QTMTl zYYf@9pY9nRQ|+-dh*{G5jc=%X(zh)1S?6PmQ(IVSOXf;?Hgm?})ainU7AImU(B!3qBz+uuW}m^5@_*?M|%FrHla%*C+nMv8UK$cJxK< zQS$v-L2R2qzSiB<=;WzUdDOEyT`iIY)i+hCUDq%08k}w{_w$ivQD}y(?u<^dE9>}K zkGC?1$4nAY>pzjH71)d&ndJp^QAcUPxBzdGWf24H6;$1)@ml!N4wuUzFl>0$f zb9$urpp6LB#<1zrk(CoHkIy0NLr0_VXP+fac<4Cdm7k89irRKTZN9wR_Rx&*Ov$l4 z6P~orT1W`D2CbB4fgGs1+)zWGnt;309Sf$!!r(@5nvHqP7pDrv=#sCkKLIon9O)aSQ2lurv>exV8n*uH?)T!rjrV@*6=-+s*S%Mw&#Ai7kxrwP zS|A08f(B)0HD*C%7CGZ68EZ`5tyfCTE4l~A8Z5w7IYsAddrGbSnD8(lIyHXrwO-L+ zVN}@@xzKc)x9Rk7B344Q^1wa)^yXwF2L?mJFUH6g4po1d)p93^{AdaIY{XEJ+jK%H z-#n_DGrJs+8$$dg<1;(n1pzum<}bM#pD1xlZIx&-=S(y&2j1HG`hi>bfujNwT3IHo z`Q1Zxxr}Os=D0sNNJH+Y+6-nrM|oAANJaxz?!T`%*ro!-s*Yle{Lihm zgZM8p%dM04QOX>({LvAlop%+pn`ToVnh_KQntTJ1j2n28WwH6rrgL#fPEg{8k7H~O z9L^6s=qz|Ycd8FEWu_tX%jMu6xkM0*7$@?rPal^4+tg^|_2T44Z3IXQ#3d1h)|s+y z^Uo-O+4{pnEsa|jO$%)J_VyROk|rh|C{n&F`P`<+r2uXmoYb~?5uo(2TW_xX`-Y(} zvG2=jYR96uqIEE3ooA(NUwYs3zyq!@1=*=P2^1gv6jRk5h`z2V^Sy6!Z4pw;GdkJq zmVb^Nujs?mal`gd&ui9^rtzYe$^`p4+^o#DS*UvGl8E*vr++`|9*&Z1)ia0x#gCS3 zxi22{U2>U81)O}q?|h!Moy;`}TP#aDf3`|s4=Xk}Hkhu&JxMdzS}(s&{XE{bK@w8d zJ=_@@Z*da2!Mj{w6mIlhOv>c2X{U%0xCmUTW2si!f)qH*Pafmobq4 zKal3mx!vEP3ik`&-FbOd4TwHPETiaVoGjra4iQJekw(f|gFgK;A_^h@9Ph(#)UgD3 z`|gvGgF8=jx9SEA)|fZFM)P&|a5hv4woA`I+a1-eyROfM%NxrcxJV*C90`_s=;ZWB zV7`S|Bn)9RezhGyDMG(y!EW@yZIIh|57k}`10(p`r}4y0A}I_Qa*bb;l4>3jcf|B} zNQdZC;^M)(VKsX4OU3hH5fk5Ce*1}ZaS1!vT&vJU6c=v0${VQimqTDnEt@v^m{=*> z`5ldJ!!>2gmfQ1e!D#`{as}HHy2dcVGGhmd{Ea~|VBQ?CqmCJKNF!W0w`L%|dB3z? z4%-DFtI~i>(fs!>@6W9Q4W@Nz7=33@<`7|sW;=)6&DOsz3&RT}Cb?@gocbH~FwYoJ zPXQJUfDhD^h%S=_FT#R? zA^0!BMQE(X{OycAMlSV!oP)vt1t2!>*OZ!&iWHo|2G)ISImP&Qe%VJ)5{ES$OO}-e zhw9Gre?j~wlS>`1Frf=O5bpQVRc)p_m4?~bQLPo6MBndifzAO5FIx|rY^ys+_8^$_ zpSRj~CfusvErCs70+=th%1Y%et;o5_ohX>s#i@zH?;dZCWK7IFon=CJL{A}hnZ{jwi@xVbz9uX#&<2E3 zY1qe%^553BE1Gk}8N|@qH0aFIizD!4#SwV=JdbBmCORb^C|S#GYs37lG10Cg(w^xM zC6HrgAWqH2P@c_gT)NoXY53LKg7;3pB4dyX47gS8kwqeoHuZ0*;!Sfut5g3QI!Na_nL4%=8Z&Fj(%aTX~}0 zn%tw!dyLAR7_ToDfYJ@w4Y2bX8-;@{nkL@>&Ym#`h5&Q6!3Xh1%ndxX2DZvBRO273 zdx3`M8i1*81g4EhSP6MH+iJOW1!9*;0xr*+EV=Cxamg&c3PzsA5)95={@l{@dz_cP zku2D}k$__6=wbiYzp_WG2?-rTBA~EoA0*RV4JFJ$3LKNVkC||awk!TZJGFGXIEn=# zBIwJ_VsL-QD2AMYM09W$zj}~t+$D3MI5f;tMi`g2Yq)~dELuIfU{vqxx%EtUKf z1}L#$jvCqQMy^^DPNj@#BM)0nxgzT_4ZTOcgMz{&D65n8x8LYSw1}1z*Fxo8n&sm_ z%fIwVSuZ!n8kq^rNg_HRfX3DzllA2R0s3K^?oHe?vW95mrKF>jrB{f^xiO(m3)G^% z{dH--m#(b0S|95W$IRWsxfGxlmno+GkIn;-1bTs&Id45gV5@z78w|`cSJqT+x7ukP z^VAo~aW4L%3|NHcj{4PC{R0Osm7WrIqW4ax7Zw6K{lt(_(_dPov7On=RCUh%aXGoE zDIX{(NJHHs!>`Jloxh>&C@^9ZQ%n2>w&2mC)N$`C#vd37gvr7@c&`7qtc)iZF(;qI ziq8$P!REJ7AWlG(mw6lD^Fcela%3(X7K>ol*bL67Gd7fEl^4`)^nKdaDn2ZXPTf<0 zJX6rpcH=hc`H6nl1Szj~M&4UIj{~2XCGLfZOZP_r(g5<^MiLFO#v^wut(R$cp%(aH zMB$ExwFa!G*tcq?aPs_+Lije|S@IMQgof0Qv!xCR8AwKyB6i1>XY4@eUw=XBYK+v; z5=8)JtP4mcg65uV2!xJSo*s)!Vc2X}4j6FFsRQd%8W^jo_UI@z7pzi-0q8_(u3v4~{A21y2Hp}okK_z8^x^&= zQfcZk9I|^}*9Jf-x-zV4uTL#hyEtuHTHAMzn_IOQMs0WL{dOudfNX2?vS>|m5SRFx(bO?)Uud3KJ(0q7HaN& zM=kuK-5c`EkOG9YB75NDgqtQ1A@@j_!*DAYB!}nF16x;^y^wOy(kY7JblFXFaTrR+ zT4k9TIV)8lR<^^oHL?c-eBS23 zXTT)FXnssh!&{y5;(-?3N`?A|*d$feFOBiCLBR}=nqrF?AVgYqCm!?8Ff^-ozth}X zalH|KQf=%nMS?DV`lQvuk*(sAPDQFI1Z-%{K`sv!5e(ArNHh~zFw@Ph~!kvuPhI| z@+QAs^TqcEb&!M<-c_P6T`4r#xLA6PoV_Q}^N6qn(w_$XS^v0Q9sZBeUwW7CMi-}v z&a|~!d6K1&zacYk|B>-TV!{jr7JAEPly8kM;WzCPVHD3uxIaZ=jNq(b{+00(4CvB_2!{ci2+ z*9I#x>d};_cab=OqtrAKr{wL^Xh>OGaKFPj5Y)LYT{>D zm%>7=SM(Pz{ho}qJzm?LrcU$=)MjP=g204QJmqgdD$`k{$6eby6@LYeq-HP@s(_CV z(vL5K&M45k)2l~T3G+pc=&Y3$pUSK)G9eV91f>$<@4 z;3P3~k42(nfR#m(tdXZR4pMQws!;dWr8BZOMNV`YtH2}@{zhzp(2gNz-xucxijgJ? zde-{PVhWndI}TbvVXJXMeKE;$Fgs1~fqdbpccM(ec7@~wy4IwS21c7j@|paKT%3hp zh0>`;G41poqN?HWHfTrPEqK)%|1H`7W1zWBta@tfL2W7^r(ng$zEmfIDid~UvYzv~ zWESt!-h+oBscpL2zLMuV#cGN;^EO*OmGZ(c5e`a0Fuf;MT-mBIPVPK zl-s`&;aNN7iT_ZoHgakx=SI0u_lF&mp{FVE1le+Grrh^7h8()LbD) zZR{^547ho&9e*Z}SSF_jPlD37%@IRo`eLCgPDg?Y&-;0vTkV<>7b3lrv^r_;{Y!6Q zq;H|wA+=}3K=Lwvh!m}U&7t9*L(?Ao&Ubd>Ja3>vgL_NfA5WxkV0-q#@XQ%!SBZ_~3-3cAoj^8x_vq zhjt{AogQ4Mb2H!f=!EI&aWTZc<55kba_Rlzg*umTdetUmR zSw=(&Zqw>R=(AYFmfn5qHX9)x1p5sV5AeJEV;zr^H^&9&9NxG38A`SaZ-c?5(zFnD-+4 zTl=#V#_<=z5s5_qKRi-LN}%&p)VL0vQ?x+%i-TwDI5ZHBw*2#RA36}d;2wwjUb1!O z=@sikO=PdZ$UtN%Avc%N+b8MQgPLc0%(zIAik0I)YjgNd_Ljw{KD!9nkDmY7!cQ+v zFUOnP&_)aEa^$mWKAXg2lV>{3?>14j=m?CCj^R4imL;?EpwJ8uBeDANZwqe!9z9fNeJb@Y(m)p384Q$(LShqD<-{I{drKFFjkjYWW854U4jVC`yh#d0$`+8~ z$;q|fR3K@A*68ru^OyO0kI#e*gPWA$*@2jFCr)1HwH z^LdP+)lKJVUp>Edj$!tAI|KNWh1hjE|Am=H!>6H)E*De;q5-Yq!niHWoIW!-Y8k4lGJ&m6is+6G*hVc}9a? z+>|d&73&l0YCd|{-LPQCkb2du9^C|1OqgeZ74s?T3hI!Rd6TzhV!OzZ&2^O`gK6Ifm?nrZW${d7sf`;bnE-_pD?;*Mpmp685$ z;pG}3Wpx$b3J32|cps`vr345fv_af@^7Z1)^QRVnPP5 zPy4J>9LR?zXdvXk(u_B9dzkUWCfKPu<$1QzwT+Q-$VV}T`ZJlL4hwdb37@m)>0DhH zA6Io;(c6{}8s<@*W55jf3o`+n(~+0Q=bE=@*a0(5L_3p0_1ebd=n1aU$m+^K+;>zz zJYVIUJyq@t1q*L!yJ)Y}duk$^M#v)hsNAh=@vTG39N*yQkpMLN2;7|Asiax zKTIRrV9p5pRpySVVew7D?~R2vmxeS#!Z*P`v6Lzlg(}oD-rcJCl#bfnq>p0IJ#hvVQBzcfuXK{a~SWsXmpO`fagOG?QU)U71Em&aRuMVmX$*Fn`qKF zK!T~ka|P(YueI|7v!} zmj=O66tUw(gCvm{$72}fe(;g;f6c*6dPV(Fy+oZkFc##w(n>G5nw+Pz;BuTF+QpO^E%hJj*jEyxk5)kpDycN6U_-i zE&AdS%@IP>al>ye&$OSMGcvaS1#=#MTcDk?T%etpi{HzgmfIkBPnLH=s5=3Lui2sI zR9KZRj`}Z%$d0ng+`Tif=~{GC44jKl+e z?nFWY;kecmGS=vN<6ZzAoRjGfSm9wlk0SNU1&&z`2>ITMjmz-I09?fWu%pyJu;2@3k*_@ zBqTS8f@T2HGX2C6He|*Cpf&ZNyCXkhV0hxc;|ZtG2q&C8+Qd->k0==byJ^~$rx)_{mIfu zS;67jSourD3~t2&6Va=lU#5urk7+Dnt@l| zjPR?W6W677ydLP4Kh^no{H%sKi+`=jHWqtNj_`wtf@mtU34^%UIem@1|? z%;{djb8Yy~tB06HOnu2`7P}V1A%aGNCnh-u zb%oP)zI#XSjr@7+j!6(Cs3S+BC`>&ptAA$KY{EuWSmJZ!7mf8X8{GlMws04-9w>`dxdn>cto z(9a$3yhg)R=RE9P4)!jlYd9BlF2euE??nPSj2}fOwI$@t3qGUwOijnarTP0t0cWN! z6CVtD}as)rzq$U|QM_VLExyLCoJ4)|ydbY;h^{GZ_1z>u*|=45aR?bPdb zd9QLI$^K%}C&_d6Crd zJmBxo;UiJ*cT%_D0??&>DJ}(dMdVVPT{wV01486;B=5pqBkZCPd4fE*Yk_A62zm*# zSSE2^0nMwaJHrH?j(#G*WE6~jFe(o4eSy`gT~c$_TU~|M7Ef$jU>E$6JrYIq@-hr{ zEVa6EzOh=j??|jP zS&etaJ3^$6Tk$cHdVN9}ITu?3JfP~De?otKFb!Z&MMslpo?BN2emX!`8;$K^D<1{P zC@IncT+gV{B|dhjtOJG8Wu~R$`3whP*(bh{pz&nN++eM4U9d#3Mb+}9GaFR#oe0OI z$KU31ChNscK#UEsF+ftf~U#e6He^~&hN`NEDDxNEO!Y?nbEV3H_+ zO|Z`PgRQl@|M9N3yCr#e_U}K9&Y! zF)4HUz(mV|0#B>REE`Gm+E}_pvNYoqj60K@-*=gS-uJ6ibTk18z0@7tLaIkfS{ zX7-qXn_^RJCL#wGx(B4(=eJX;flKLCdX6L-5EI{8Ut?0Bz>XstNyc@uGPMZP47Q4C zLK%SB}qa4vUmx;wMi(Q>Ko@}B6NBZ5x>=WM!q1j$d373ZvK z0Zklru7nkLnB8=?8>M)KymaXZ4+a)S^k9WVG%vqG&?3$-u4u0MJ*67Z+CDOW^mZT` z0g#d5(h3kWYSXs)lx<@IKoNL_l1QX$@=O8e0=)B%iOt(vmWn9yqxA>Ejsla53S1Ww zn|DJkqWpy_K3%He;&_W(Z16_Gb*t@A1ynRrMAXxEH-U4RX=)YRx;-cFvtgR)Z2`;;gwjt2v5i0vveBP02 z;oY^BZRgc?S&*^!fv9N|0ytV9oABgz-mBr>VlJcDD#P_~jc}bi@WN-yKG!3&=^5^r z9SdYeUBk)54%9vuY~iX5J6+-S4%icgid ztl;rf(D|@KaJ{iS#0C1aQ1A8iuV374K0wfawl-3`pil_38IFBB@TK9E&Ym**&$xth z@{_4I{hqOd<&RqRbhySThAcdPEJU~{4}P&<1^HOFVAz#-bm5(=4vg;=OlKUM7~R~W zuHsm?_c&Av(#@~eVdOh6AdKMDtuLs)`kbB(mVn$;V>NFA65{;!fR`GZC(ceZ9FL-0 zm=`cb^Y&$5Do@p`&S71{1w2w*Esxo2d;yr%X>u|FWUh*@%1{P(2+*r$+SaE0Ri-1T zO?2IKLQ?_26rQuPvbSuky!LPiaIL(;Nzd-1xu}(9p)YvGmZ$_SAioIjEqkSt^5YFD ziW8)+USKtLMf~I)FSXCVZxkgbcG8?cLG;zFUq!c7^_t836b^+$47b!Q?oYh|CcnCL zPuKryKU>Gtm+>fy4bL@ymN0NgFi68V69i`dp!)}NO;ouSsB82lTz4@a7p1Hk&?uYA zW^`sgSON?gWrPXugAy)F{}9W*HV1} zEVhgyl)uTihcK-2k=q00rxu#Ant$*5={(PALqEY&^%9p|)Nt})I0FS_#s+mY+qKz? zvdW3h6M~R_8z)Y3UQGz-aBGfdZxQT~t351bl)80i%>>7HV7^c)|PEG+;|! z|InUIi6RC5`&An|&L<0YEITT0;M3>0poX2%=N+0R!6@O`br5Wr(&W+^hfYFv9s!bc z#0NG;Mg)7$TTj2@VXXB*Yy;VU{=~!|z%%f>#F6!@S4MaiT4l(9YmN$Yz>b603T=qC z^d>h*;Q7Mx$AMZ@(r!oymbFzX{Nsj&EwI_q;H!#2ts_|$7C{p#qc zJ4p&zXulBA>Bv%?ef6!P^WMkFhi6iRFXIJL7+NXj-Bj>cnzoB0S)h{V zW@Ap{x(?=kODri*T%=aUcLY@!A>Q=j{7sLM7=%sCNx$ucDu zFQ;j|vo5)H>hpe47je&ZIXm>xrK4Z6+_)8`WTLWVqN@3WE)1{=GR&K(%X0_rYZ*Ff z{l0Jb#U|#(t)nk$Uq1tjS~JFKqGfu7f3ddp=Wj;fxJ;aAq;!sgX zp^jn3+@qC02R#-|)&2yh>WMcHl*!O#&$(`05uHyI+4yBT?yY68xc^v)$2Z@!Z-Vzq z_S4%bWAtaZDO>1dZ@cF8=JI}75^Kr!*M9n4?6WD8pF41Ep(B5>UFzHLem9F|{cBQP ziDui86ya`?6AU|#D!ijNR}z;p*N>@ti#wtVtvfW-Ax{nY8V`Hv>20NZ^1wvG>GMQ` zuKHwS6RW<&yk1AgPd!SL6vvri69rR!b=eG8Yz-;qF4P1n&*vT71;ZJ{JO?3~qDi0L zK<B^Wkq=8juYO)pD&L`iB^h?<_JAm`;54x zaDN1kMg(d^qn4hySx-tNhdy8Ls@Zw?0_MP{phiG}SF<0t>TDFx zff&g7h&%CF%Ke&p^zk^yxv;WHQUM>9x(?qp=eMlCSnTj2=^7tM&zDi%Sx1Zb`7`YW@((>oDDAtLjMr+dd15>CUCjMYvEczVlPbO&vw+wA3klX}o< zn0-K@>6$Rifps9I*lGRcNIhcpcg3<}((;(i^Glw*Hox?(KMBf)MJu<39&H%xk;IRs z48F6tWjQ@JuC4mDXgxm9FK(p*;i*M|=2ShEzJEUtx6s?($pr&x9wq(~ZbmJ|#b@92 z);{O+t)CYn`jcHa+4}X}86`Qw)A%H3=uDvJkqt}|a_WPm*X74)l*#c_8XztO7)1JK zWUWds^Y|w`9UYw|Ei)4dmzhlCx6G%vkA8jArvQ#@lA_2UGqjf8{;W;wE~nm;!c_Cy z7Oxqt>!VI^HMWK2W5nI)@S^Nt|CQ%wu1>sF=j25sM;?Fm+v=grx4-<1iDODL8wZdX zZYPxIELWVcRbxN$JQUj>=6^eW=N$2z^T8W0V>?75r_zzeH6xo{W6GXakGv7t7S0L( z>c9uixCsV-q!_Ro?e*8fhd)^Tsmpyc_w#<+nRhRWO|4SRTs*!XT|#IwBuIXxj{kwo z)-=)!4b$$H8!OZ%`PWpf_nuIDeym6InC#J}K-uPRZXX`>pZ*S;iyA3)dU2&K@T|PV zi`n3(vKMV;#XZr{)j4(^W?zqSr?WM!icLNxhV48g35{LDs0MH7YPD3LtbneI;8PhQu$8`PT+HPT9A! zL(B5Fl#2L>ztx8>Nj#sfJDV~aOP>|d>hD#5e91ZoS^PKfPEP+DiS=ThZ+`>B@~w_$ zfk}A&Vd2{7o+qnU!VCp=V`AC_?bCYggiRvE*WO=|m3759(yd42E;;=uE%uPRx9;+Q zu=NY|Quln_+Faox=o3v<&|`E{@Tb50Vo!?@NwLja{8s3Tn6>2ob*q!FZdkO@z}4HK zjJFKKS9FQKL(K)kiG-Ec$xk6?12)gFs#NGE@PtVIQcV1sypAp0z+bb2sT%y7c$rMjZguX=7ZO@+Ir*9MQ z1##H>@$Vxh0$gqH^DkVH=Tue?g}#R197iHNWO^}2wfKhEcuKLnasLmwDy z+Va6Z(lB`jJ@Y=ugm#?(QrM)fHuIiSD!3XY>>h}?*W;L3w+vcwJfyRX_(bEpUNXCE z0MROVd6ml2@_@cr{t!U6uaKDXl-#*>F49q!ST{j`OPTl&B&$YpI-X#YK1xdkg!X_K zv!`y#&gWytyHAwmNaIV-L??st4E{_!>pVyl85dXAFv$OuAWcQU0#cGZsax zswVNliyppfuPEX!3yA?i`!cV72e{fgT?|VecMVJJciCa7?@OC_hBqMIYG_J0?JiNk zaOCv|ps8*}0-d2v5C{jL`P6EI5JAP*M>@Zie(UudL?q5)^6U+;gcfO+MVFk}@60q` z%{z9&FJ(n;rdQjB#f1I5#to7d<6^b@`MA7&77x$<#=Ux^WNoU;H@6LTYklW=oRdS& zVXas?TsO!2d&Kq*?+I9?Rn7)OhIE^J8w1ypc8guB8L_T}MK5 zb?R!A@O;#t4T(o*J^F?nmRcS}X7Y#JMIi4l%-)oc5ezH-*=4yv(Pr11OC;=TDsw-q z6`caqN@R=`^*j7Kxuf5tf!r7T=+;@EOJl!7Ra4I=-o@ygJb_I*AX=kd^tP_{yNJFmQ?&^{rLDkQLCm)o*Z}p>`SE{6}lnAtc&zCbhj) zD&alL^*TmEzz|za`t|DfyJOnNQl54@CAYzFht)?`%k(~NzX*1_LagB4Q-2;O>{z{V zZbQ74E2(|pqb&>MS9(Gjmj6KVmp19e4hp{!b+#W6>+Q?9G<;giQk^MV`lVsBF?=~H z21-ZdNDtz(3QAx%nAM$&p_r3cuV&8ZEhEp}$oGOu z-g#YgstdHL5OOy&=$;MA-^|&=-Q%4~q@!SSvD&<_wr%5n;!*#3) zUkw^C(#-es<8{uf!0J)7kt>=mU`&DT?xS0YWqD0C`ETlXopaGfuNlPFhI&M%i+GhX z=byVN$HGH0LTPB@YxoY#Gg``hm{3864Q;eQu%3+7z` zD1HEYK&&=OjXaM6C1LT1JU~jNX8y#^8`&ZbW+SQiJKc|%C2s~Pia>TNXoKWuzgF~o zp`I5fr(P%E#k8I9c@VNeXo~y~bfz3mmBmh1!+duGaxibr>qTY@=wjgtssefNLM1WS z9*eEN1mHWJ-o-7&-Cxh=qblU?(YHvaMxqUZIg-uIj@S-GWiJK#{$v4}y)iMVV600C&Nn~7NXP?4C1*H>Ai5ic2B!9P zG+=WmIpH)>wm|**s`Q_qj^-YZXvF#i3gm1M9h&Pd23@P?idsajM^k_R%zK7Fy^iff zErx{P*EoU=JxqtbVLpheafI%j&Q9i7uB!QgLvy^1k*4PS(V$(wg*eB^h(B~JblFG8 zhad1$>CU`T2X3Y@ARq?0#N+9vkZx~L;sAbQ5p5L0$}uBH*goMG@WgfsBXZ6W(v40h zOsoM&0X4ZP4ciE{t$nwUQ`Pb|hCde5WCWHo_%iVc0_B|-%C`!BYbK-9p5fV@y4Sfl z8xE0=)i8XuG?euC}!d7}5SBbTXIOGYpr@ z@K3XG)zY!BxXn2KEaDEOhlDVZ4UbrkXhiQ0GuCR3q2VUv%j8f1ItjwSZwD&%cKkT8 zZxCr*00NJYEAbx^nGf8QOO2+7Um}*cYB=dCI0K?*#KVim=4#`o4d0ArTA4w^qD97TaL zcY(Rj9}VvSZJ`YbDFWVont$o6g}0jKvoN}FhdOd!BjqWdCj-$lx-b3J0gV3#B2@?O zd^hi4^WWp1!a_r_hRS!6^uQy7+4SYvO*)&5Zq0hQ!y~pX00yy`1jt|__FS-IHK?;i zO9H@e0g8E9uz9WZ_jSwm!U5% z=c8+j-2}{A_XRUcdizf!UL@~#kKW#MzWBPkykE2^x^;^VGJp3~`dmj)q84T$W&+gN ze^FO^!2G7>MJS#tA!J`ckEP5mU?+v1=tFfb?f8|ZB+mMdn&$Tg9^GCxU)KZq(YZpg zD|b}hJMa={qOU2w8D`|KT!XpF(&DsZKn_pelxjG{PD-YB<1|`1BbtU2pX;Zx*+NhvRlm9~rj?Am%hQT$V;U9ha%P_yWWnu;Ys$^Mr*ezT+W%6SqU-~hufK#vN zjcrPa*rf@jrG?v0uSHqQLNt7GM&ry6qQVv~G(^ z+$e*#*gE6EPf+y1(rjx`;&6B~1(C;$t32`G*#waMax>VsC|n>nM(%#x?ZZa8YHRE! z*st=d>5oQqD^jzQuiZWwPUfl)J=Gnn8f;;|f=!N8{dF7nwJsuF=H9KNUqAI9=;V&D z8|K$D(f7;}?ohd#^0+ShUTJw?zRit+_RA1GIN;uj3P?gWKj;8-O|c&s&gb862$#AV z9ZQwrUmqW6108JjyWrsU?n6|6?qPLg`;B%Tk!3+(tzVBz)jpp=RRRSYN?SY;lem1gA zT=}nB$l6%smpgW+1D3mnYv;q&UF!o13&Q&%Oh)HbU?E(rBAti+A{pYb9Y)>?P!G5& ztDSFrNLn?-TfILFJK#v(=C{J15KN@}T~+b>RfI@$QKs~?EDXHunlJX#y?>*#kER+P zGP^}z&C#L`JoHg@;B_nmt4ARcfQ|iQ+~Lu$iqVuNWmX4rU-ojqqVj<%u8w8lKo6LY zf`BoQ4V>xl@II(dx2J`f;A4D&3JWz$3+VNfF_zKlg)DR| zKuV{>8##g($Yb6%e&_wDHFca^(}9*}>T27JUw2=!n)r(l;~0i|D>H|vzBP+o2VW@n zY1GaG29XHPWTuC(>;$-ZM>n%wA>nX`H^jJY_w7L+|B1*Vz7rN$<^+pAU>t?!IA9(lsgGs_hfji;{`K9(GJ&9W33 z;?Dq}3^JE{zytKCw?*O=pBl}xzWKgI(ymxHUEo9C^eRci=+zySb(@80c9mhK1 zn7ZmX)C-XaleHD8yc(2U>Z9>HK{KxB>guXpd4#9VsIgmowp9ZNLEx%`KHij!`c#(M zGl~%s2vF=Sc=}888k=LU72j(@*6I*kq8M}y>fVOA|HyNNegCE$w{vguz_H{HQ8H;V z*~zDuyE8kq`7ie$%BvY03;WTR(5|cD-N#9^jUanaay`*hC*IL3 z(V}zgo|-;MWtpoB5r`Mix;GH3zm#IQrj6zPo}572`SR!*QWY#TSBIICxO?pqF+}L3 zv9Wy9?sw9fCX|rw3$W~%+vec}YTwj!J_Vt5?{s8$?}a6FH7OOgNUqtJ|B z55Y{41TPzr6I2obfmog!NdXu~C#7PHlI0h>=MzGwva}EyQ0*oE<72r(%?s#Jy%f zD1c@(W1Lwn8i0^ z2oO#6dREc#yk29YFBwLuGK9!IEbAKzyNzLUD#P-7(v#%D_=pTf2~cCh1bW7+;RkQ< zBY|eC7Fr&Na^?Me7G%iyqRcKIXU4q=A!N(~8`n3>39ebfbbs{>^Lkf@IyzS)ec{^Z zAENI)m;&eiAykp-Pt>9+kYC7be|Te59B5{H%4#{CkeU}@PD9zUNq(E^Y>o4%^}I(- z$5+H1_62s>-?TE`iNiy~jRA8YEA!*Rcs`@ zWl~p*e=Ua?PqOBZ$M-!-kmhY41u6M{H=b-IrwhP~9^XtmanbC{If9|sBZRbnvl;mf z6fKV(EGO`ZTF>2r@E%AK=tVWtiSPSlhD`O!k?~J{|K=k(c#U~SEJI9>-qiEG@gvp9 z^37!XStww%W^Z&zy*Z@`9JE;s*v59KrPE#6+T<9C1J^&r-2Qs5^bj&SrvJChZdY;= z4+V-Q0{pn35`?y}EOVexA0nDDm}*{5i?BBe30E;Mep#acbj}7e*&#pLYbtNF2%{L& zM5D$I8Plujb`~EL$HsI-=#c%=wyIG6|3Epnc}ClI5V!}dlACE4P0!Y>qa*@=SV

    p)lY-a@oc0IfxXndt9RUjtnm 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�xQzix77vGM{{qunHwHe9wzdctVjiBNr2rDcpu0Bz1z{W*hk^ zeD6M_?xh100kvQfQ32u~t+G;&k9_b_wlDi*1YID8Q7q3)l7pd#g-T{@MY9_uO*oS8HV*FN&2p@wU(edP%LEj@V&!`=&nlS@TK ztcq;^GBW&VjJpM*iBtWn(mB%=N#l*0D_^MGV-hZjFTf)!yB0qenuDcRBDW~kiW5UcFHo;+V?L$Jn$~5~RHy(6) zuHdG*eVDK)v9Z!TN5N^}WzwJ#_EMm=*jx56lRQJx~_7VKyt#b4L2C}r!PNdLmT01HQ+aA^L`_4~Y$0o(>92aZ8^sc38g8{4 zb!((p%{cONLzXL-GbhXDT=s5<_j&E;S!eDu>A}34Afw);??GUoheo%Mdmt%GM?Sc| zI8{>44wb6&ZYnl=w@g#jDCHx6vYeulY+udwM7_9%Nq0%e&idd!r97jA=>V! zaz0Tp5s(s;2|NSI+Bv6Agn-mzh7nQZoK`pQ(DxCK>7mv-#*m(fJD#4)rwX7ta`eyf z?mgc<5Qn10SlvY1HvX(AAl@8`Dy&pofo3J4u13FWDiOa*AKWVNk8&p1PJu@zF~>8OpF@J|%(m;BGI|*j+GoKraNlE~IPwim zcxd;-pw636dhcNw(Al{{h7ExD_Vukd-IB(9$jh;01mp`h5v)9ntci+xH)DW*D)= z1a%hk@`BF~UKkZudiA{ki>|Kqa8-7)Oq@HL1UrgMnb5!802Y)TlT`g!g)ip({fc*R zJRN_Y=i{jax9zDggM2*jVYd@0VHO*S>0s#;PnOL9gg47)AN+)T^!wQ2ouIFRS_fBL ztYw*%zLH{>_Dy8261aDdB0FEWJ^SrevCbq-+B-McXk-q%paF$J zL95)QT)IB>?4_;=Iq<=7IJ2BaHxRfq1lBJWuH_ zN+=kHDr|^eTlmXCP>o#zA))nkr$rzn0jzqhe6Z1flwF3Y;MG`bvs65%V0@LsU&LQrt=ms`4CEMG zSPKZ2UNI=r@>tR}=q>thWT9^?!n<>xT@?)I&+QxGntdNO-XRstq6W2%gV%yW+Tmky zvio#K&E#^CYpgOX?e4;p(E67f0f$PuI!dT~^H594#d|u?0tGJu#ncC{DXC^6kVvS5 zpU=8FU8N z1ZR?_KNMSd9YTpyTSeDiY4G%VPl7&r`{d`q*zK{Fgd{=7o|h2;!;Qa>&HN8?XxWkh zcnPvo8|$>(sj0f5kQlzhmdu^8_$4{^^Hg#yZk5WokLo8uiTg}OQMiRU`fhF^t5R!R zZi1lE65rc14rH)xmnHi0hr(Jbgec+-rbRa3u z9U-f90s=yGP-&mq`h*pOlf38A2LUWE^{NL1Rs08+@P{W}{14(}{taKZ9>5mhPTFi^ zBqv+k6E@Wt!*b<6tAB3$|1IW|sn@pw8=jn5)NYrqecrx$Y?c>+{&tN42 zg5T3uW1bk6KPdq%Acyg#rswqd*X3B0cm{aRSo{*xccI|^+bOELD|E9a)s^iOZT(P$ zHBM=h9<}%3PqkyQ;;gf}+Plgw2y8Ws-uits|DznO?WlP5f|Zo*4eDf(;pFH9SwSYh zL#0M^hrOb_(?cxTL=6tHB*&qXoenOn8dM?(yag};pB zowCeNi^>T~(KmH~gM_~(-#))Tz@t?}T-kn|vP#JJqGnSTuY{@^v7ockTGCbts?pwG zSZ-&D(og54ju$s1R3XuW0=#V1Egu_TBnnp4+F*FNEAq|yYuca?yxcv|r)1CO!(wv8 z1Bvc$8}jT0qMtYykbxR&o+J74MoQ@^c`6vV#U|ziy^?WXSa?bh_Xw5o{6UTm?iuHG z93Sed93^ag!tPxl%zk=2np*>Q@7sJB5qoj7Ygb7W?)LC=fp;-y3icXOU}qT}3Z`z* z4;obTx;mAVPL%O);ey>I z`ET<%efr1v3%YsN^faY}5XVgS^ad3-@qEQ=DY7!dZ!FHv&ll6?=SiC|I>NG}rZm6h zr?E8ar3zAf7k=Lz(kb%&qr<}61MDes9fdmF^daq2b9S}TfBu30o-f%{MBa$Xcnd3+ zqx8`JuF_Ub_!jgqHpfC#31oVNOV9_n*ybJvps5(VCURZ{Ts9h=I*81Sdi+pX*-WXsrPebmVtIbK49~ ziaKjvnY-?P^J{6YzbyAAk)7L^44%;|Ur=XsUCw_fY} zQ7PeiXK+3}C7(#W7o9TwP`bckEW*fg8P{J>VQEDGn4T@cYP90^4SG{`7RnaSP2vmm z+&AusDDlzr*9v);5a4ydKjUoD*>U%8;QNIwN<+DGr4`?mo;l|X?eDiX(OtWwRsqkw z5lLqWrMYx}wX4w^P}g=~BcyaVU%J}`u7q;y;)t46JBDMBvqcXSgJrqnN7vy2;rkrZ2<=-dIS|qadE?=*|$G4f zGS4Zn=)IbyYr8*2+r02fFOb`?jhOh`Oe%H|rVM(k!2po}F6db8$+w<=w@OeJ!I`;y zMdSZTb-;W6y=M#b;%m(hIK!dtDA;$G|!s*ejxi|Lh;NP-2sLSg6 ze9z2ghwemt0R*zLWs_ra#4UzeRQzj0AtR*VM))4g`+1h68x zeXQ}E_5`ygQNbt{Oa<>Ijl>6>mF?;Cpdk;ieLwY-jYcXj9FoEbssHAB@2JmuksjtR8PP6JIx@+&+c<^a`;izdLUqt#Bwe&(uX&(vkyK z@iYr}3L%F=JC^s{1Hc2Lz`8%GJ%D0YK}>D^2K0x6)`ND6p@X1o_Maf-bYKH`CkKHl$&FL&})Eb4u;X@{~2h- zW)DK=_-Ty2L7eLPk#$X#aaQNZR(TRrr5!pA~6g)9vj|@ z8_vp%4r=Y{zedD>Er)4;C(rg3dX6}Uozs4FMTNl3&G!#Y0A`4M1wS}~LW8XZwH_L= zquR&!;go)@aOHMBsD&5!fCX=zuNc9x$Q{bT$Va&@deA;R1`?J4EoX)w+Up3hH6wN? zJ8h*#SYMBuxyS(pFs4=@#YU<{cOw3vMBgG?4Jx-p(~sxup;*+rx@HX| zsT`2k0RKiVk79cyJ3zUw4*VeZ=x&>W*RQ5X+Zs}wUx{fYQbP0g_5!W1Gl=Rlu)=id$^@$=A z_H_XI2PjDwet(|9#Fi{{o8`?n2H%hQ!GP;-PZ&PtJ52^R7N*kOw zoYqwI7fuFR%czxB{=~uDv(k6PXgsA8kQCoWs>8{#ojEgg*qI~MC~F|s2|zEElSU;o z^!ofM*x*+=Vk+x^^D~(-4hHh5Q@7u7yo5lP2-^Qb4!)Y)(R8)-+5OL4j(La%pr>#x zABN`?Y8=&jU=)sv-h$@Ip2a|rlL!raIVCVY4qeuCq0%_kK6d7je z66;;e^pFDiKqCR&U{qFcR#d(Qj+gO%7p@B=7DtgMo5iN<@!<#H7F``i@ExGRSr@(? z{U!n0s=6OY%k4={?Rz}Xwx-W!-039C(^6)?K(C)+Q)Omq3XC*6yvAJ3M?4;D3!G!nL;eyofI{ zi?e@?=nvIg)JhM-2C}7pDDsz!lt5?BW`yp3?o?3@=X(qGxZ!|n3xF-2j!=QoL zw&8-;o$;zmKs6@2xozWd?Lr>nKUFALPi$6id9A1f2f!tdZvy}JXO61)E_x-%0om^l z)X(MQR^ZQ0n zQ>m>cl8)GCk>3QzR-Mc}M%H0~By4^Q0AWZDIE;LE6} zqX#MPY~&h5H=ALKb0G660E8Vt{7U)_st(q{K&5K?JV+gEwWE)tF8^y}d(VeDm>v1n z4sLevmmTVjTcrIF^Ljc841+2G%k6Ki{sDjik}G_7jO`?H4KX!^P4diI-8=erleq$! z_JaAdB1JF_nAKK9U(a5=6OTkd2%8dw8Sr-QJ2V9jsXSu8`JUuF?I&2S^f^Z)EJ2N@ zmOl;uFAuA$n)R(njDzoocTmTBVaxh19-s17ZT{qUW*DyOqQX6YG*yLZT8FxEp;(&sbVm2)!6nLF`L`k4#tLcrT?z4T8py+y~^K1qkyYzbpEu8yZe;#mStdX3RZef)8@eH1#I9D~GZv zRmca}Z&38oJb<(S{;iIq6lV#w6|kq}{xb|H%4xw;e9T^`dpGuDgzf8i6BOP}-2IAi;A@OJep0ZIw8a?{v~X75@uuCN>k=CC z=Z#n}1( zGQw09iiW@P2=pR>tP9W61i-JaAk-~b5qzI0rBn10UfPPcIQ)ib4o7-Y_9{R7s#NBL7UIWUwT1Qv}| zmdd(}n6CL?>)wssY*wbN#4U_3tP_IL)h#u`l-;Y`fz7lrZlOmE+fMpmTQYPc)!nv- z^9==wzCej|1Ef=tVSz_7p$&3`{Z%tHp@y^3iZ=7!yPfV*fT8^P0XTRaq6Xv*Adn!a zn`4mz2~hM=T0aH3ptx;1^fuTcVs$ba!A$o`{tAkDeQF!$nW+?ro_&A%&<{$(VJ9G7 zYfzv~<_qkQakO0=n-n!OOSgUF*ZT+pGxijX7abjM((2m$6-}XC9D)kXlTg`!81fN? zRnDknNZ+~0wz{t7*D3GK3+9gtoUS|lLXwFa`Ria9V&{NECFO1dGqiUm_0;3DVEF!=m{OICU0&z|7+!Eog#U?1@U zr77D?Jtq$n1ymE|#L4`tA?--2ULDW{V}Y=G<&}nx0*RhEN3OZ&XC+TM2uU}5&7V0H z016{BTLO`|O`_#7YcMr>)9^=UKS9n5Hw5FSXsi0$6T#N0E-@AI?7cYVjRSq*E0Tz1 z)S>D6pqWl!kROgsg}JWx;1PnrTnSDO!+CZ%G>~ty59|sCTbCG~dbePMI`RzEa4HgV zz;wVKV8`zV&(cXhLPqR7(lAKryp-uVB!eo~%~$iaDR)OMV$erhsk$g)fY>JRf*C`u z06SA*y^wL{Z&y2vz58nCLV`lbX(ffMe7%W%mW$Z%Y+lk_i_7nh80}{f1m!H>jlrAK z{G%N2o}F+sZi96x&L3pCwB_cQUVJl&g!P0|MwMEU1yp#TPX#b&#yF9`#=dv{`rVj3 z-q<9kIwg7Zo!4;0e(W7}CCGvAZqX9o_i(?-eWjC#Zg?4Vsjb6H-n`{^q;}+S8QAXg z-A)Cj)jeZml#nRNjp)0HO#|;%)VOy^G!81j>b(*eA4YI9tIyV+i+L562{}?*KO`wb za|nW9sDz|wbnYmB3px?PzCei`D46!OpM&r1qRO{$_GMDi`Y-V8!KaQ|hioFhI`Qkw zp$Y*&r8`!Upd$;{-lYxF;K|SL`uR}Z-j`={@2e>_T%T-kxnCMWmJrK9; zuuQ2zIqGD2yZ9;o`QUm`7Y-rIubwyE9$-yAD^X5q>J{X#{aormfN+{ z2C9=fx3UvYEKL#JQHj{JU2roNm-k9QwqpSnRixmSPwgo@f0l(03AY+OoGL#G`=ykg zDu&UF|Aq7xJqQt3rs{`02Zg1=xW&tluiGJhyT;mt&|iH`G7Ke0ifB;R7W4cmV5-I){o~77sz08e+_DrD-mcQyoh*L@OwPj<8)Ba)Tx)+V& z)Jz|f|P*+$uCdHk(P^J4hdLP15>uItO9{13&_UZxmpFO$CL z+x$p*;H=nNf}Ea`?6WuJj-%cPb@xNb<_noU98J)4zy4+WvQMN&g59u2Op<-2f5H`J zr*yl9;r$8R;@LJ{h(Gi=8-Ww@{EFnKnD!xFC&5~TnZ?W4T>0=oZ&AK+*Yhxx*N^Uu zFi8Bp;3q;F-Pez^A?7%5&k8p@wUwbt*GxNbJN>)snrw8e_=b_uqil5Bb;aKe0?X>} z)n|Bpl`{fu3|-e+ujxR}?u9V|j67>9E#6Fycn9_y(N`(|{nA%1J!o)wb>U*&M-)>^4qEX#IgXn5@V|3Ltw zX5?ebQeMh;m3i+@1@g`D-V&B z$@sfk<@YB}EyjFjtN$Yv+a7K3<+5pAA&;6AaXj6NT%)Gh&7bil6BKgfe2Kuopb!>F zQoS7y)}PQDh7BL`p=idBY#hr(C(i8-R?^zF3aT$|AXxb%9tD#GInRb>zK874Rh3!~MwqV6Lzq-L6};hH z8z3W(ZCUo1+DRlG2zU#7hANu`G>yO?-mFkAsOX8O#%^OrARB6I0j&Sn$7#FyGZ>D{ zbgw}$({?Drud5iO4nc!C;0Ng#ufc_J+OIgSV-?>pyf(ZJZ0;gzYOzn21SF5yVhv=J{HgYI>TJ4P}}kC zY`y+R6$>Ve4ZGIruTimSv9+cUkC|E6-7a5Qxg4668=cJ5eQEgIMbAm*;ODk|>oMhxu}i{b5Nik-KNZU0v4d zAN9YCCbgM}CWWi~PX~UdF2ySN-T+x&ooLg0cL)y=O|i|+xSc{!b~yCXXx;I*Wz zO%-oRHTk94@f*t3C}m;DgwI$kdKKSt6MdinHkuzJ~+`PLdOPzh++LVo1siZ(fuAzlg z|1zh{;>7(X-=N#%u1kM^J1}Abcx8A$(LTaI{HbvSMnIQ zb#Iirl_VlP(5~sv?jN2ah@Wl!99xIO;e^^`G15roSXN^)N_ZvEDo86(kM+r@ou6Y? z?O-c3#V~uG6XLZ>vHX1gFzd_H?WHIkTy^XY?r!by3#wPfe@bS%(*J|#uq#w(^k81y z5npe_;@pzsMy9%*#RT~(^ISQ~#QAzmeiwb6(lT!o?y4~)IEzT|9qy=m{h za8Z^kMv7bUo5?L<5_5btR^dbT!R^>W@l>BI$CRBbTPc!?^$a^9N8tR_enI`(SbsJ) z{*2kV_~Nn)0`}O|RbW|`7X55qe!=WcBg>>xTha$0}qoAiaJDPa@XUNR*8+r7j~ZlIPx(H|58fcU(+6 zdEe&ytG?dX_Z7?eLRi}6V}|Nw@l~DXXbneOerhi2<)1T+xD)73(U!+wpV<#YvgJ*?OQaW;Ygo!crIWPSYfe~=BVQU~?xmj`5Zp^uMhCw?+0 zHd?ia?OO$i$DXU>2k*>2opC>bPeG=r@+4z8wjJu=DyOL(_r-^@CKCOhxup81T^1j% zL^|CQQ}%*lL&<=F=Wm4T?@NiYRFpPhe^N(u?P~b+wAO?uP5bts_eNq*=(LopPbc?y zj!`#qhm?8N3$=lLs?gW!a1~uGsz8PQBV3oGqd|Po=ciQHCv|C8>Rv;pT6Aw=FP7^O zvkUE-nnn#};v6EU=Yxuk@PdrAPJerBL`BOe5jL!6E|uU>+PChf3tK%(l#klK+U}!HWML8 zOPi!ysr99G0vl3 zxVw#ir(a$exu09b$)j(X5uFebIeYiNHGXqm@uQE&7ptYwX%{^br}c@;vGb0N4ckv8 zXpL@sb^5%0rV>-Z<4A=cni=53BWMxK;!?&VT%^@zHniZx~OgtA}#+vF&fc-VX`IY8OI- zJSMtUF@Z)MaOrCQ%f?$XRfKHY8?YTdPi(T*&j;!dof1SSk{)!zCZRdLu~j_pV`?Ff zN?WG_35p9o8T9aR<;jP42Bh6u-9t(IuXm_joNxZ-p}GG+`|Gj?vuUL_PyW%A?w2-w z)8FSJRUP}Dl+6s>r~W^zx+kcHnerHhHTl3e@Y~zZZD`)diCte6>IeC?7@=`WQYLX! zqccN3N0Zl2X7}HP;F=((9WR}GH65|77{>!GBMvCco4lNTd%*9-RqBuGY89*Kh}pX0 z;C@Dgyevg8ZtNM?Ycjss+{yOm-ZRR!jnjm95Sz&GFR?cs`3=*$1A)i-|GxcO#EKyZ zCGG$fIl`cE=yk%+3#`QvLJt3fc-i{XpcT~2SD8FH-~dRc75Dhz!3>}7a3&5##w`Iz zPg=@b5eZM~IBww~G&7t=fPuo=@Nzw6&z^=S;b1t|0rmw#nZlEdwkwn3Yfc47()HGb z;Zh;ZxdWzn?8HuCX{4(C-vE$D?gdXa1C@I@1vmmN^`E+)Wzn4n-DbiutUox5@53Xm zv1_w$?*sAsFG%qIR`QV@HVC83holE5Ef6s@Ds7i8qFfK9Z&HZ)sIWnJfjskJ$YpJg z8|zbwXd;ogYMi_1N&pAaknCbXY(^spt9v3WArW}wMY4*|^SyQ}Y!FBLdoa?arfI)Q z*#XyFRaDd=dxyeUuLHWWn>Is9Iq9mGL8{n0kBriPEg<^!K>rJ3esiz@(TQRc-d(SJ z9qRB(S9QW^3X7nXnl4YRs^{*A4L5|un@W%BiJh|Uk}N89JgW^9Ik*PJHXf5#`o z_@XQVnP?O<<6YJshdQBih^#$!ZQlQ?KX^{X{g6Sn36bLIt$5>^2FpeOb_7Rdlef`* zeB}@9S0w4l)~V-8#%U#ePBj8+@#oYL8lef{y|z3H{hxHUhbb%PsJEIc&3Af;!$9BvKFIT(8W*IYGqf0 zP&+J(OOra$wGf;Q(v+TAomC!Ieg}epgIlJ9Go1hZ1M{;Kf~qbw*4l0SAbQ({Br;gE zI@IevvTK&u?)D_6`SN}H0To_eFmO?)g}avgye+L)%5&RYA;OV!!fR=gr+2=$@UvWN{adlu=m_g1`?A20toF$S z%^vXqsUr=Lf7-~@6-GvrvOqejrKohl%|q1ScB$|}zS0vX6KbRgMmao6jQS4ZVb+i6QZgnYI z)X9s`ZKMnZiOMU~-I16M2s{EFK6N?Hdf;;q+#HgO4l=I3Br?jM*txLM;``@|%c(1G z+|t4h*r3B7rSZ?%-o*kDi8IM{tA5apvKP$B+-Dw+W!K$awfNE2-?OD)rJQd2l#5)? zJ$VY%dn5%Ezu{g4lKMSApljfoZ@vFKfTZDRj3$#(77;|XE?b#srb+y#L`9VoNI{@4 zxaig_+PutW@Tn=M-zZ6xbp>luaJs(#wEYH2Ir-x^YcDUcZuNWpVY2UWioEcVzyNpQ zFMU)oA!3x_N;udadBm)=F^Rq{d-EygN?6!`^)mHVsrKT&u&k3UydQ$y0I7T!0!)IZ<7 zm_qjUFPeO8t~A}G4`_zy>is~10|*vG#LWN9pzo%~5jIp_c53G6bjhTP#~I40Jb@?eGD_+OJ< z(e*&H&Ut&@cLHunzJpJIkv{stPndHZE8*(pL>lH$G^=UEHC2yD6==93oHBduHTjun zwVaR+}st*Fj z%{DIXYqasT0&tCo^2Icv5l5^ncjS@LGInnmBetKH98=d) z{f^&jvm&$ZAi9=Smh}Aj**Tzox^dkeMpHs6C;yW5HLL#X@!)n< z&lV!_(1|x43_9|M^N$+YHy^hX{xZPQs&tC+KZu3#tu&gvpnmj9;NQv1Zy38zNmeR- z(UP(vAi_towc2Xazb59*S!3FPR z_O6PyvE_vk-`l%Fp_9d{DCc+gN3v~H|A_%KSdUx2>Zk5XK2`V%6+O-fvfJS<8I|q< zP(Ll{`N?Ikepy=}W&@<73#K-39`va}$x(coiCmx#8Wa@WS*bSWW#lRixAr0@?J$Sg;&nu}T(u2LL8QV-CC;iRfeBF$RC}?kT`swU- zE4akphHLlz?U&dk#Z5rZcaJpug;Uc8Hx5tTr$>0(-A`8Svhn8w=xRf_V;$*CIEJm2 zQI=MEgOqOHtH=FIvP0POhmZBxcbSyUZyzIltF{7x3nKYb`L?~%0RzQo9WIm*-DaH! zh1SBu?Ois10u4^GNETRWdEz@<^dI7pnUD)TA58_IuDO9+Wt-;(s0#$rfw6CweyDrXTXLq-N3Ga>Nad|zU|X?y&GyFKOR>{PjFZ~4Ua(#3^>o$<{OSjY$Si1jv;9;`C2nQG2#JQ{rAAo9<>1`@*W}C9cA3 zn7JT?_kfhO`jFL+P-mv^k(nMy23P-LkygsvWySk`W1|H95{&`(+zo(8r$@-e$E9y$ zrAE+zDlSZ}9c((O0~EKxrH3=Ekz_ug&wn0jAZ<*XbGL^5Fuu(KwPf}`bMy})YAB+mQ!ruS@`F6+4=goOF%8c6!=U4qT zQw5n@_kxoj_gU6AWuODD2nE>S?HZAPqb+K$$LX_y>FWNu0L`zkmj< z`b>mDzruxHclnT=)+}1NAO~y!C+4G6aywnv>Y4Qr@zUqIvjDhB|5b8x@kF~=#4svA6E`<6 zs8*B1_I{P;t$O%$T`Zzb)ln>dSFJpJ~rEPn#$`-(gl$p#i06cD%-qhD;{_8yt zsc(Y~mfxjO2@6JfuY~O!PJPCz{lM5mS23Hka+ge*n>X37_1^WY(`T_=N3hAO9ao=N`}W`~Uw*wUVp@MK-G_g<_QEFeBxZoDUu3G$j&-946+F zl-5R$6-Ewo$T2x2ImH}$n@o{2qgl?3nDO~teSiOUt6Sss+I2k-kH`HX{(ASG&AKwM z4Wld-dV%={B%Hdk9c&|3;1@QI{C!Sk?D1zm&I~BSsTckSX;Q~k0Y+!s6kwv4@$MDS zC91brF0$a~ZQ%LdVA6iPsp>i9mMfI~MfEQiAc;73Mc#D84W-q>#*e>R}Ci+b+~z58jikP zL}+5>SN)2~N7K8pVEkd^jRYcSt22|KNIQ!)z%l}etFtms`bV3?nOaTp=};ghV2qo> z*>ITGqEy=1BD(Y%AN9~*027w{bp(FLN;B2w{p@%(>65(ET}Vc#*M7SZL1hv{E*+wAQ=d8tEEOW z;8x+GW&~=3NW{x(#L~tRNl4)&Jk)`Tj25lc8%e{SPdwe2j_(_+ni`EkHSloQ#bZ0Z zUiH==r!Y7i^SLclqXdg;RBD@#q|v%V#U$YA>VRqtg3FJc7_4w*@`Mr|0TG|)7aAYr zA&Fq=J*m6(kyM?YC#Rzj+Pnj>sf7V5i6k6O3Q=cq%=2W$S-rTW{6$nMzHj+={(Y3o7dxuM%*b5@gsT)*ABUs&J?+an|LVzE6~y`& zX!Luc1icaJ1Ol@x71`$K4NRe;F!tb5hAx4ECy#cAoZZ8cs^I|qBAq*tu0g>66YObP zj2(>Z##5Wpo?KC>_NSY6)u!!z;Z_tE52x+xn>y|{1XjNyNXU`1dYdw(ZMusg&Jw!5~!h~iEA<4<32Vca>#6diq<98?CI=0Gv} zG_4X)&w7eg3U|55$8wm|=1hzIm;QU$b0E`@Lzk{HU6ywhZ#o0gV+X5%kl5(?Ju~%9 zBDEuDMHJFfiXk?itdX-yNT*#_$H#Pk`%-oL*#`<0sW`=yN<;Arle{gi(>~w^pYjW9 zI@;=GGg-$&p~$de!gAxy*YD6czRU{H8Q-geACXQTN}^L=WD*Id_e^U=B1^cxv#p#1 zExA%u(>9wY>Y8#@Y)ZV>#ky88ds^8bTK$#>;jJc3-yxKxrwIkh zHw)t`wNjmPN&ZMTHLD4yO8G*qlAIE;Ps zl~UI%PDTn?3DO4Tli2lB)~5D8ferK`KeLGE%`Xc7d)My?Y4b{!0;b4G^TA&BBB&gD zV*MHr`z1J>R%Krx^qA574g*EPKS5urIei?sz@&h!fdwun1DvUe`U-Oz_#H2+(LL69 ztg4S1K=5-%)}oqCb0|8p)9={n7a}FOe_W1iT7TXrW0W-o7U2b(wOb<*HFpNd`aZ-o zKi-K18IW8SS1}{LapSzXi*Up0*qDfXB0^=AW5=BwHl+2me#~F)0cz>}*x@Ii$K1LaX)N#ee(;S`-TmR@b9@rnS#z-(pGDECN;E-!u$kN2FQh^utT ztZMj|!u=ZQNCyI4N&jz_AT)0P&5)H!UD~j{U$$@1KSJ@%jggCY1@y4~W;m%@+wGnD z?hOwNPm0G0Q7>Z(lt92(ekB%m{;s^+1MvwU4eAOONXJwIDj>hCf~-f>43+xfmMKlH zW<~zfqk&lGTODmir?nX-sW1}&NZ`1^&F(1N`z$vk);5odqgNr;3v!QGh}AyMNaZ%t zy_V&3s>+6RlF1oJJY^xomrJ|j_FYx@T2*8$iZhLxJ$tsWzav-5L~}`Bjdr6l)4wwF z>$RuOK7m4YVGGk}b{*mL*QXZ^eu&}Bp6wWeWca}!&5V-eB@I7riq0>?BeKL>FYUHa zr_jki3g*RBOCYW^Fq>O0cK^bit<+G8vzo5KNZ8eM-KG{9DF<>F*8k;AS&E*OB||e< zd0e2+#>XQawySvoMGwDA(68SsVASl-#iPf6!>#xEj93W@sJVD6A3&!hWQ49`$5OO4-XI zE%^D<*JA_4w{*K_iH>mVWc5w{&wG^sY8^UA)=QQ99MMm1DIHSo&@IdpE3>-8H` znRjySR`86Cv0zaB$;I7kY{ar<0Jb|X0=AD1xahr$dOj!~fxRKbP6X`1r*ekFDz{W6 zgT3pG9~a0GQG%W`qX1VPdPn|%ar2Zcm^(hYr>3&9$wrci$=nk4;=}p#<14oZ_8uA; zXbcc|YTY&)oR0w69E07q)FDo?D*FM693I}KZ`_x87G!p`Vqg6a^3poZ#`u4bk6b>c z8rhR5**rY0rm#RS)(~$!F)-ZxpvrRmz^IZ;G$eh{3wkR6E7~6 zR=oyxGkC_%Q1Ll%Sjvk=wu$qIra!YDxY|eJrPBM6_8%X5qj}y$x%lI_#a1FCNBWU? zf2UmMATkm}yaxvULqy0ueeKmL#UmV1427aA0CqfsiSUrE)pj(WgDcO+{? zE;h6rZxF*^N|Uf_FBo8KEBF8vUB8*etX7`!qmaMRybxK zGgwr{637XE=m4_3wp2HR-&o((1X~SW^YpIs<|`5~!Q-uf0@xOc;AmC}V(OxoSxlY{ zV?WQAqt`NU^!{eOi7F4)yqeQ-;hR<@VC(S&=0?)0BCEQ&YY>0_C!4pwCg&X-{)Bv~ z&#_s)sec*d0f37q@hMl1ny?53D7KMNu)UO1*&t%UJ@T{gu84OiwWQ~rQ+PEjbSTsz z>d5IS%#$;8_#-Y01j<`!KmPhq{5XC#uoViW&DbmrF7ltA?Wm=cHPWlPLy)_uUt8z3RD^n#-mvrE?@2qcY$64 z?mi^PVn;|w{*507m6B8cpd_QsCCh~dvoz^dPTvqPqN?E=reWiQ%N!f?Fu_WFPi#|W zkw}d1z16y=@`7}j$F@C-cCkdb{BVsPstYw(V%mo1igkbpYCpOip03N`A_@szlZyKz zrUX67D2c!Qa#Q6U**KT3MrZw-6l|%zuc}Uho@K%V{+;W5IZHI< zcb7L-GgLpGC-gMv_-k$1#4#5lwJ0bd|JR=i4F5{+yM(*1};QFW_`lDI$M_HO*JE_+fSbxGx{bm>C)?5^Mgt&K&dNrj2l zq#^|6e|;OUPB=L3&2|$OO*N_CgrenF_79^vMFtI|DrTDwyFubeE~@%FVO~AyEuy3i zcNBjghl$Ye)v39W()nb3H!*sCjV{jN=WYGmy)}3_Oj*m5mJ3vl?>*_AwM3n;8&clt z&eUo)^&(nYa}vg^uRK#)>{=>4*|nX9`I6!7uC`~m+C^BHz!Db=Qg#_#h->4r1VZi4 zmbGzY4r8 z29-)-h%U*zhYYvszy)X3h5d7!h6+WE=NJ&j$HT-VXx&XIi^q-C*rso$fF)ycI;5j$ z%4O*9T|P>9R;VSD3*bC98Gmk8hosX_z-)an`LjPF^2$m^$tg zz(%jpnK^pLO_lUY`oetsO1I(8i7~&g+L1++FsMIZbqxtb7=TzG;;qleqdm>936jox zA6+!3=A3NygiGPWW4D4AQCxNoJo8(O8Y^`SFqgsn6P!`r!-K^H?;yV1Z1*7d>ORsd ztMo8e>?QX+oTHwEA-d59Y1+J;uw&|R1Nz+86`0|+ItA*W$LaV|L!R!*l+uj83`S3?hbTc$48;o~RmhD$8Zx8OfvbsgG+wSQf)Iy3_pRA!pB*Td>UR=fWoZTNhW_4JLy%E$P7*2-}{PH}fT27UINulD54NRTf{=K@cc~Zk@FH^9nH1cPKZ;ku{6;+xxOpv$f%3q@uI`W7VsG3%N zN0|Ccb>0Zm?DpHQG4rwxr*EL?$zfU+=-~#C8z8oe*?j8bm(KW$4G)W>y_+bBd)o#A zXULHf?=Sk+${9>np~biB6AkMwQua}r1-MTi289;l z$}{GjJF+H)_6{=C)F$#a&Yjo#UK4t~<9(FL2#CEOz*7Jr=;yPslcMO2%feDVYHApD z)MSYi%-XfLGX0CK!kp#$B+6u4j(=p8v}Dk6 z5!6UoXMswPTR8Poew2nczG5YEmD6G=Wx1U3lK)UmQwkNgHKIQ8wl?pC)$->x#u5mnv)3_hz*_GGFA$ zMrqg;LV_USv1gKa@-3&Q{_@8g<&W_jA#5RB5zGr?c7Hapxf6m0C}Jpth!`^#d1lz?{)}OdF|3Afvtv=TYj0k+pK?E zOkP=rP#%cL^dh?eeWp37apf9IMa2~P}V zw#__!j<~)w(eDu5HLuh5e$HaA^N;sM*>_&T%lBtIMJgom^AVQaJR5~d|78ESIURQ{ z*p|P4F0E0Otg%a>dJxdA+kd~#cb_{_|9ePrz_G&6{EFl86^9O2Gc=gM$#;9J+i-sm zOx+8NLA_ub(XW$Kf3Q-6|IQhRNIGqpD2pyFb2sbo=_*D)ZQ(Df&YJ|tp>8}4YUDp^Y_x zI&m}J3I+02W-K?ngd@~;OWbyo0I^6tSp##4f*@&v4>r{2g;Gng-*{FZ46+~GCguqR zo$x_Vt5TR$d`x*WdlkYH_9oIdtkL+i=6rxcS=SdA2bS+!Z*@F_8iA+o^GYhky;b=G zMnd8pT_++jHOI{^*0*_Bg;inPR%B&PnR5JccQ# z^6k^rXF>15MKZ-s+^H)g_k)dM6flaQ=cx3dkOx-Zj+MHi0r?$F;}-)N|AL&fdZ+t* zh4CEbVt&i}NTH(;E-`w+luQ#s@nFEFJd+4}Xr_%-F%P)ug=}rp_ho%~wJ$&>ahXK85;ZVClu1v|7 ztdWWYabi)AVlOBkKOPC@;GHoOwi=Zz;F6Ny@Q6kuA09l577B(tiu?~kGY)nB%x@OS zk<1NNJC9;grC;_-JSai0Ki< zg?gV$Bv@EBIgzdBlchNP;b$7!`GkAk#ObP6&;ibebTpF2F&CgLW3C3cc2*ms+gMZ5 zF-^S+xbQ3A&wp=_E@2|a?SCSbEZq;=xOPn_=UcqUzdkG;`NoGuZrDZ;O(NpswnM<; z)=!+vUE5J7FJ%!sO9D-J|J=F-F&(UEt}(yJDLg#lar30W@3^$OY8HPHoj+oN=7myO z<^zSg&;>Qw-yo|mb0(Z;efeu;L&yi7Ev22I8eCkEW1@a^pA^+$YCELBCH~wrHdmjE z?8wlLKvg?ZO*DwnITvXL|1v|iu%GYc+V;N3nb$uY1j>;5!>ZuXxK;amjhe&Lp zwxFdg_sci^l!M9%9&XqCHd=$X?LgyVeI%u-1C79%c9N{2HERFqeqNz21O5b;kDMpo3ok+!7h!u60UCoaze6L{7s7^QYq%P z9nODlRLC$8at=yJrXYVyUgI2@q>Sc)(NTIiE>nEr9|c7#Q6y&C4es))%%xIeb=z9v z+^bBJDX4TV#z*eZkPi$ar+R!xRw@8G-qPDEZc^(~%NyH-uQICE?`4fvWwvu7nP4KO zY2i6VP?Dn49D1^ZL+w<11Rx|5Sl*^ZJ;1&0y_*;t`8RwPhN&e{R$6Yn{JxG<%-c>u zYRfD7u)@F=ZtF7j_W|EtA_&HoKg+y+-_QJOwO3hD8AT@@6G&eND{Z56)<4y%wHLzH ztqb~FeOsT`n>!`$Na^IGSAca=vYO^YlhmdgRm>hy)<+}0q|Dto zeRYljdfY{xC4WuR6BWj$cmJlA(Y-*{E6>VQ1-}&}U|NCghPNi~*@Rp+XgmS-9m$vx8wu_gnQzoT~O%IBxI*%i;@_|-q2>%Q9Se;MXAK4;Urw7j~;-{sokyH;DM$2u!Ktqlno zY^pm-{&BDW!|hgfK5lgT&A|oEob9I*ca(jGYYBMr$L96=U{iNdmdmC6T^cEL-}L4j zf88*wfSv6Nfz3N_SW|Za+bd0lya!G+YWkP})7@2MefX8(sd0#I z>`BHX#0DZl=;P})*-8FCdrppqlzz}Q#@3LW&DO2GMz%&o4A=u7B!tj6#d_gqhLl6? zvCsbg=VLdUW-#3EnB-V~U=r$7b9r^9t-;I7XlMD{!ROD^AWmyssn?92j2p`_e_}G9 z%gV)|WgLBAPTIOt5icZUqnzT~H4j#UsFY)`KRx4?>~?qX_`EeWV`u0Jjfd+g9l7Yr zXxlP4E*znxb!$PkR<#sE$JSbGse5ctkUI8PGhcIq>#MMBl&N`ril=R;avkAdm$ynx z&(iLaJeBLdVm&Y9<7#I+M%A-paKA4OsYG=;Mcbp^{AW>CQRb$jcX}b}<30`3{kQ(u zD(}2|AWOqCB*r(rqHf7CZe1`T&=Je`a5twg_U#(7!ng+zk4aHGVs^P0E6 zg7%p%?~WK0sTiM{xQ3DQJwZ|$mKf~S>x}C{kp$PnIk#Hn)7n!n;^VEP^%DGVzqxd@ z?AqkbP(ed^*jQ@@q)l+_V7X*>k|$F?#sXTU!i9^WVptjHO~ zSq=4gD-Va{e2oU!Qe*3SnU$*>^VbfbT zC{ivyJ*9zF%`a$A?!w7rs5$@AfV457;^M52W@*g!xJ$c+o;;#^o;_r>bEUTUvZ8nc zH_yN3I~04jt+Ial!M>U4xmyDxzg_e#NSR+OBn*xhxA+iT9mO6K*y?`&?Y`w*v8@IVvv)#7^whT#MGhv>t%a|< zpS#4&!UVdXG}Nrqg4Rh`?60|;?$G&pB|=q@^hoBQt=IX(CY8a35uKvfl24c#hyNw; zgqE(>-8dQVdCSl$Pp-uZnOrSd%`c>Ni-2a^6(c3znD~O($p^Hp;sFM)F|ti5hTvr@scLpjFY1b}t#h-$PN}-U1s? z2d}2`7hJV9wspj&Lbz zuKek)hdo2(ey0yJkjst4gSMJYFn9=f8YN}r-A7J@lqmnXV%V;s&Ed>&f#@sUK2R2@ zOXio%f{Fl!kob0MfjG4-p10*VaUypzy=T|_VMbm9@5;o7hlK6)$Mw@50;d7KJjCbM~!L_&BeRt zcWb59)zv57sbUr#-Qj^Ou6cAkQ&qGGW-&`P>&I{Pezi!h^=e?{L=}ns z=l2DdStIGY5xM^F9=8S?7WtIk(*5*~pjHtzDDzE*Lhpg^U#z^fz6_%nG$)&=0l^Q_ zQyL-F(u;ItVvv|q071W2kEZa@{^yx%*?IxHPMHt{W`GJEZgcg=+kr|+D2GXcc@S*A zCEsip%mV-m>@CAnWb<-+{bf4QlbAzDke@i=`OtjA*}MAYXuSS9e9@jB2`+aqzrvh3 zjuR_eyKQ6nL2e}NOA0bk^_<*qw;fN0t4I{DP)y)Nomfm%i7bvDXp~%Gy(Jt=!&Cz$ z{M2<2$ShJ%De_+%P<|g=d^5;SE|P>F1vNJFBHZ8qU~Qp@*($>>I8=JE7&~|CR^AM* zn{0S9=fBLBF#ITun-4j@G_y`L1tbPQ7s$Ov9aapD>?Komm;+hy*DAd)U!5X{-eti> zM(x3r?1Ou-k?O^u{Z@6qPUEL(CkWmkz|N%16QT%rWm0HUx25&H_b6nL!YKe^+-4 zDbN!YYwDpadg!#sPWuzS_HDH6{%7>G2g{15?a*mzAmeTLMygwe|MDTImNq&?tuL}04;s`CpnF~-esUgWm8sq-e|*- zz-jgIf%vJ+gg;gJXVN0b&7j!c@a?D_@_Zj;M3YzF;}9UhS^{7Z;ocI)^8c+-3U8kp*ju7Y(!Kv~F=tL#^d_T(U(^JGT_kn;qeZ(VIR#XQCySyv>7z-+ zF82>%LCCF8>Pv!^%A;@-Mx$|#4v!2_Td{-IbM&dtbTb>jKaX!wunlwjd4j4wa0 z==#O7;$ubGUXA$HzKy3SO0(3cj*U!&#G=(K@1Y>YgLu9@>qo01`_J3f#~?Y1(pUn z-qNkJPsbj~hBK-JfuPPNuE^TWS8Y76Gt)*=mGU=J%bc^Zji^7Lc-L?fBtTK@x$EIXrKi50MV z5?#iBV0!o4tvBRoTiJM@EHAjXekOLDKckTSq6-TH(b00Wo!_c4(P(g;gj&D*K=U00 zGPeikZ4vts7dq5pJIcbD60+UE?-yn2d%-`pz)^K~H*E7btc}`}n-s`;ncdLFFwwvb za(ZeWydDU;rMJ*Pcj_nj6&GAcyZO+CEPVCu(&`8528FH27p8j7LV&*U|JS4$rAw_k$mlT*yq+3(1FLCy?B#7D zg*&GWn8%#K(|K`W@DM0#B;Lz`=9MA!Lv;vzK>B+3QCTGW-+vq>C_Tv7;DxAL%SRJ_KmpUk`MUiGF&_G|#qJczp zZQ(}x_{`jTsOYTY(iYUTQ*?m?yrfx3<_w3Q|Lopy|NivRWYZkkBvd0%G;LX*;a9I^ zZ>OjC-aio~Dm4VoshAok#b4~h!izBD$p{o#eQBT|J$jJ83uB!+XHo++pyn3WRopGS zUnLL_zv8Ecs@FJGYWpcG1Lfz6jgQL64xi8-W@_fGBGA~Vn=$u3Kk1A+?B@;hR$<&aoR+VaE~=R`F9&0(#zx|@twMHn)<^~P7%@)Eh2-J*wIW{5z3-4^@L$TPL%@VlHd z|GE1>13dzu0GI-Dp{X68Bnw3ov3@(+vNlAbm#{|cTe3PGvFI&*sbTq{EE};S(JyRL z^XvTgPYS>l4_)DailmQcF7s`6&xSq%+dgL{ zqHmh3zX1S2!wjNVCx@HKj0w1+SNQRTBw5{`Pawvb$mVew%X}dDdBT>8t^%AGx+OtltexzP3GaWZL=CP#_TF>NJ z8GqecFzpNn68CKHf8XL@3!E&{o@yrlJ?0v&Em>vARkOF5323`3E&5>kpmnw%)Stuo z9ba2++|;ooqxtnTL_sB11Y|S_m6~{G11M(Dobj(Yiqk))Db(fet)ni8YT5ML7pU`- zgx@&>P|Z;4mKP|TF1dlf!P5Fsg6eG39Tg2dM6~{k12;fM#>l$|m(Mz7cJO8Y zJ|~a1E^AbkBt3qeoB~R@RAsVbs~BuNeY^ zg6PRLOu+|*%ZSnhQryZz85dmns@flAJo$&cLA>VyJ`m0axKne7$XRf%*nh|HUN(%& zzV50d^HX&j!^b{fJGoWJ)%XL)~g^zQ5l9>Z@Vqf5nRw#7cju&;z4EL|JBvi%KO z&FKm$Y%9ew*dPvg?)-v+%*y-RKnH{^29`IETDQGMQPzykoUcER!J43^L72s{70R)Z ztLOgvLX{8(3Gi`U`^dXZD-99V@1H-mo!Bdd{<+Y(zZzxmgHZlgPz@rL!kN4AtbFL& zt4pXZX&FX%iG>jEr;t#%%J3C#u-`l{^=OePxVMd)d_LM9ra6k3KJRToS(Hb zaXUMXJQ~W{DeRiz)%12NnP#N3B+DV1Z1@+u;TU&*+VU<;iUL=;*xc4CF@ML(Yu-}n&z-xZ5%ljD62@8FeHmB^%?i(NhNxYGsl%0HJUN6 znd-`V_S?~5ZjS!9uHK=kFv0*rfZ40_TyxH1bD>kKzu(COOgc&dd2RZSPd1txM)Rz4 zHS}>m^c-DNBw^{ah;ORzMyUQkX5%Ca&Hu1^VK=9b1YRRqo~6sXzLcZ?hVTG@N4c0x z_QA#ief5v){q`bCXihhg*CHV?2FswAATaegSK~gtJ?FV|DU1kFp#tV#c8nb|Idg8- zTf>$55sy<2*dICt2>CmD`&MM>EHj26o;bETc|`Jw@>6tO}ME$PI_j zP)cODKucv_o4Xq}rY6XJZ!MlxeB)O+>ry9W%F6Yr+HOPuY#ZRHf~_*ksHU874&BI& zt%fwi+Nbb@zFd<~|Gb&yNm6x6#J0b*UDJF1+0ejnF{T9M6wpP(@eA9&p!{2o|7Nq7t_cHj5^jD2 zeH@e=0^owJ~sK(Rrx_|v$Nkf7&VL@=MsS0_b?$)(vEupwVMm=M`ELPs%}KXBd( zg-)9!^pN*3s#dT)VG6s)^$3n3N~qD1Y*=FhAIZtB?UKbj{G}+H=xfK6hAW6Cx{1^r z%Rqb^gEa?k%{vMx$`luAnscU+MQI*+qy1O;*l8#<21E%OQ`mFsHl0@`U%pp{qCpQy z-2P}4Y$&j?oA19spZS@kQ>{!{+=4D6qs~Av`VKR|?^Aigsj*9Yf%4e0>0mo(aX@o> zGGF?V&%0th^(9KTRmyBI09%*ZO1rV4i*xJXID29#KK?|GbZGDq>oTUq8aOZEKc-z8cX|teoGGBzDgW^)fL@GoZz_X>&WZ;n4|X;_ z5$bMz_xo0sA*`#{`yVpo8s{8L z=L3zC?8v!w*VVN-lS5Mx?46-0=zmR;wP!yf+O!#f?PDho=zu>+SJ9WzE4=>b(pZg^ zSyq%_6|)=PZB6+Y$pB>cX$_EK{DYx?T2zDzVlKKca%0XzfCtV%(u`IL#!m((sGJ?> z%&eAaqgR1w__nn|4MElK^O#TJgFU539{Ui8x|C_TZvo$`hug*5cs_*9H!HNLF;Uo@0f#o393-d~58i~+n~mN$t-SelKbX$JeXXg`T9OI1HJZQ7xP!6u!R znF`gefqL3{pIe9o(NWU5!~0I#2t0HC1r{Q~1XiS8^K#+4zbqkx!FBeVoN!W}M)h12 z57|LYtKKk^SDoFTEkeMz&0THjxGg!Xd%%e8KL2<*BnX1zn8tNOv+uAf2F0TQLZk)D>0>wUp|$sc8yqU04xgu@~yy4 zwqYe#@KvxGA0OE+J6h$bFNW4xu7n~3{BLs@rnjCvl*V75_7Qc(OA_t;I3^9BpI^Gx znRiBQGXw5R9p9|WhY(j?ccyEL|+?mXwLfK)vM{L>U8L(z- zKZr&Bi4g-Q{K!LU&eycmG{H6I|9Zu9kTffxW8Jhi zM`vIANXO<$aJVgdOqw$HK81SDa^b6V2>^yav-0V{W&~H}Oe-o9@PTH``9q5B;e%*I zEuJn~8!#0il4AGt9viKRZ-Jcs_&nKnVOnjT*v8=)uAQO0E_-{HE>+Di`O=iE;ozcB z7)eqd4_P9IRve8z_+0hSCFH`v!M>_YQMdk!^Ot7#QIoXwf=|%xdnHflth7gxUbZt< z=L}-XAJ-FQAs>_wKuh;0-)hhQAVCs|f{+?Z{?>NI``X=g?V$zI@xG;TL{=|m?8+@4mJC+c%9)X@d8;J%X>T!$=DQZX7+jokw zU&J$ppE#6~J(nz+L>T<1UX+LE8k{^rG5X0DCd5KiIu{O3{vy%)h8Mn}zRPq-@ z;K?WsT`>H=3$r4pemzVw=EuFP-i&nXSk}Y*50Z2D`ooL$3M!Gke%sVZnl-mmWEy21lz*o6?Tu@4TCQUu~M;C%PbKP5E!Y+O++ZK2|lPjLCf` zEOwWZG`N1SWv|dy^s{oa-4gyR?0GbUCb4b3Bhh*$U36@fr3R9reA=Hz^~2>NncsuJ z#KxR>SYReL*pCx$ybBfvy;E3$Yy+whIqgA;<{@83y*PIw6Ta28^%O{+Tdqg!?V4+z zQUkwN+H$tp`nHEca56da%WgvOX6TOMCs)1VvYcw6@)5yPK6_iWQYJq5z{LM@$kmAI zi5!d90_9?4bud7Hhax+|kGWJ+2wJN{1%@7DG|Y|Nka)1YanlJ_rz($0*X}-USo0#< z&T+QEi5wY$DLiua-OD6{p{eAZ<>6H&`%DvQ7 z?2$S*aTUbmy9m484ZN-I_~5ZiPp?llm2?1R9>ey?jYWOjFZxs^?!qs# zC|hdcdMr8IV6~ypX4xpdZpgRsV`GwYN5uI(qnn@is-gxX(g;G|t={~RH6eY(Ur09m zvH#om!PaHtsK4(mPHZIju6XJ>#Zzj@KSX){nHTO!4BWMnb{&vd`crM5LYL^8P^EU1 z{SQ*%9P;z;{rFu8pV2x~Y|VSRuT^ofo<1V#zD94}ojGZ60`-h^+xgDh!@wM|0wrTQ~J%D+unGgOGeZLyPOZOp@;XusV9 z5hkk`@orT6TpgMzs`}M*X#Dhw^bP*c1jU2{CiZuo_a2Yc_0)}k3dZPdsu;3AAMBF; z_Uzj0ec|kfC@s`+N3+UVB^g_3u@xEfQ}6VJqrC5ir^`+U95E)PcLbTKTSWv(shXaR zykgts21~FOg>;ukmL)USOVw>`G?Gqg+~#f8>vm_=m6Lxv`N|wnF!yu&Ai&>E~$+PtN3^X3O~C=FvLJp-@UIgc=JACRr>tt>C3 zSh|&~R&rsr(&nhbZPPQe2rat}gFnqkzZ1~j#RtJgpMM~ZNit7o!d{7|6opIK$sIFj z`05eW-abZBMC`I`v0B)A{QRlyllW_iCHg$nD_H!0uPzw;4-#(nvIY{&-dM7>dm1m# zlm?3q*`-#w;ObxAt*S45{$%HVo5Ory3Rbz(s*_ltBSufuxj#hbQsPRWM(^{#JSB;E zL(pg*p7FC{B4sk2O0yFg@|LGQwHi4I6|p6Rp_cO-vBgkkPlY)Thh$bUN!=5#{r+6= zUn>zUn{(VPfKh+Mq9li@6PUD*XWIm!n|117Pzs9RvI{d6dd-IfcDl-W?)qf1l6tyfi(>7co~zLdVt6fUSef7Y zOmkjp-Az0($9&W0nC{utuw{Cup8ZE|)*vneSc8}(Z>-4IU|ZbR>ehBCE9L3lw83sh z%#VkC!Qr#0872*p|J!f>E9heo#LA^}%!fMbp400$kR2bcfiN_1m!+Qll+LAFRGbN& zkNGZXZoi+k$O1_L?4=gBrm?)cYGe3ysn^BV?bu)y1LB$Ly;QaAVo`wpXCt;4)AxKd z;y>iYTtDT3W-ak3VGWibusw1t8y=SmObX-s$V3|RO^N(Q(uBb}3me@{a4yjIBOC^e z+Zz9Rkol9Geg0Z8MMi#wzPD}rYAU)FG7KdjLLp<13YJ?GZuvXHw`f#N<3B%`vig#pE{e&8-V!DKkA`anwWY!JOskW z3jAwgiVScc?Z(A)4{i}f5|e}PA3S zga|~_?YbS)lZu|yHlkd+-nrHwu#s8eSPF~OVHxmXp_#z@=M;jL=vIWRj0jIgQ`Sdel)lZ<^6=c`u0_TJd!v+Ci@>Oh^qM3(yBnw^?+U3 zKpl|*m}u|6#!y~s4`848QddaMug-kM1sDT78jC;iTKaC(qYH1#(Ky*Xv~!zBM_Avy z=%h_ctFYQy7682&{kNj@nGj0tO26AM^MAu#=h8}>=e=cp0dbGm5S*9Sw1)L1-}HL+ zn-|~awnH?mgq!onh`gENB*c}mug)8>%luGex0Tmv4K9P`Xu6VjjjWFE$CXq5pv+Yq zeSGO$EQPQ@I>_qyAUn)(27!Qkc$SxdM4=e-2SHck@^I_KA{9(sz41R{#Wnc6N3wrN zy&`Y{Y7OHlM4dTu`VXj6DtGPgmizUgwVCxtQlsn`@wnq%P$psvt9Z*At=7PQst*2j z0i0hSjZ8+eX&#k$RSEvDIm}y=fVdk-!^#oI!>HtsZIbNnm-YK z$hD-eN^qIJA=;#;&RRm$)w#VbYlJIuvxf+Rb3BT>wi>0rq)KNUI18h@xp0v>ASEUk z^J(|#_7E_{F!+BQoqIgf-yg@v%1WX{k)fh6m0Op&%t*NfMZ8JplH)XNVc1)dodDi0AN@91g ziRU-9M99=kFjA>MrU~RSes+2;|G4MZr_9Gc+qmhv+^q1r+ zwfB8-**wP3-;_f!NhX~?fBkmxKKm;czNO0M3EkSKv*Rk9BlB(hY~T)ul!AUo>ghO5aU<+Wk2%OP!qws9yw zLYwX=a!H<&S`R0tB3oD;CQ&6Wu3gJx?Q-49ezNaMbP;6|J<>7P3LvGBL0iPO23dnj zD73DgL90Fa{FF!1bw&e|$dIM_TVA+TVp{&V>4N^wm}}a%8(!bRIK3aoos!m`3uRxF z!W|zA2>7hG-}iaWn=y-{qvy&@Eym%<3yd$4ahLue1@L=@F5|un zr}lQYi@qVcKh1!W1~=>>*OJSYg5CTcbI3hrZx5WSUDp1ZDsH;>5(Ow~ZCn!;O1Hf| zf@)l=7<NAH-Um~BqywKpSoSWzEFZFn5>Ji=h-prmnF1<8ACN87}tAr4NffV`eiW=T7Jk-%9HX4-?&{YEWG(q&tqA zT6CFs=wEU2vHppMdi#@~R5gEtl=%x<#p)28;G2xf_Ui z`7voye|lHzz5=1qaBQ1xu~EF_zGrqesR25&%D=hi4~%MVA14C17(M*sudS))#RB!q zPk&}NNF{cT7i@{gIcq9wAf9+qA`TNOzLKm3Lq^rwf93EPSe#D17epWGFstr|JXt+{ zGxwOFm*!smdG_ns)0$ys|9bY8Vnrxxli zJ>%tFd9oFj7U+oIE>?hOfcCWwQifFMFVK5>)R-GOH5K_y z#mmRHh_-;Lw3fRPXannM<;#P|QN!n}o9m=aQNSo_=}9s&XIU(jg8douTkF#2bKf*Y z(BbVrb*V}Q&bM-!BArTa2A8GXKGVgN`o^ODlT>L=&U~$p$$9_dsrrf4N9Ft2W0gAv zSb>4#GncJM4h0n1=m$5HAi&d(i{+JtC0m$p?~ljFlKi$}t&^FJ{eO!d`8-7o;yyF; znf!lnsh$k%9Fk%b{#PJOK7Z)qGsT+}`994kaU_uRsGT<_9_U?VJdkZ+v%cJ-UbrP6 zEgtJ_H=LUovpNT|grm1wEqsxzh~mZKwdOhHZNIkaUUH0>!V=ut>n!h?UG7w7)h$w* zY5be38O`lp;+e+^|MVQ}Mt1?)8r7$E>)RTRjKXUg{k3`8RWphcOs-MFemxqcZYr0F zlxd+Dgpk5g?HSLQ8 zIjW1Bi1Jft>bK{W9~N7fb%W0N`*)u|8*pA~;^~Rkhi=Vq!=aV5Jb~j^b@oLG8xzi} zdRfU6j#E49ry~D@fRV0$PU=3gpJDctytBPI zl&=NHWY9{KD*b}iB`lw49LR&tLc}CmK*~fo%I5`DYJQ{nsp5h{dmWiv>!5KcR~xpz zNbkq4lsUL$<=#KPM@GLW*vI0!znb#PjBX|lFetn^uO4w~E=i#^Ab&c|)_LFJ8ifxM zvKo#NmN~-NH@aI4zbi07c_dx5Kdbb&w<~^sjZ0VIw}D$7S9QlUw}BLThQg5EHQeq_ zk;veG?f#O&%NLUr!-I$bWWlKVQC;!6@SUzl=A0tn?DCxYYrTD55QieFO7+yo`6*k8 z21#2&81$e2v~;p^vnn!>XmsKWi9ZFCBvNT7Qt%-FvE2&>BEy!~9nU2H{JO_}*XHxU z!xl0ARMtpnakm=aOhgUc*;KnfCE?GymX_C05mEE07Pi}DDuI(Q!Y1jPjUolwsyuL4Ae+&i(nm^`f-Z6Z%E`!b&WUjm4vgv&Q@g^%|_7&#IfR(0Zg}M}z1+ z)xiTo*teL)zoXeTS~JT6GjPakAiEZPzbx;t@HVUB&wmi%RzL1vHvJ#1J`lSEqKl%U z)%t9V=>(=gTF9`u(t2Wo%P&WqSZNq~SRUf3jcpY)7o851r9eTbPmvBPDVEAlCN#rx zbF+bva^%5@yDOGoP}@HxknjFeX69z8dVCF6WL7cA(&xiGtzky7eOvV-criwfdKSqt z#VJB6G!BQ4-aJ#dEP@o|jtCry%2eoq7)O<7lsYuX#l=#^Bi~jRKm0%X2yAKgbqU;1 z3Wr~g4*zHM{>85^THdzykCMtS&zh#%A!lwTfyy3Wou~eTWZ8;EIX+x!r~RK*;PR#j z(_i%P=hAw>0Mr z%9LTV3s_gX-p)~=`JLz|K+wS(3Poa!MD)SH!2rwKAECR6WDhUBR#4(vZ@p&`_0#@J zJY~y9G-Q=g$8uBIAj1TZsm>Q_*`OYwC026KTmS{70y|FGb}eSwm&{$7>a zVwe&>n0qpltL~hdVkqGvy`lu@B45%`%7?`9JW2Gp>}Kqyqm!w_mP#{v}5Qt=6Dvw71I8_u;@mFd$3+z;MJ-aFHMxJ4EY zEKOog?^kr$7k+!nJk*aBTc&aCRGIjHLk~7Zx=7UtDzn0#Btz+nMfMJzI{yyd18>ca zrkj}g>0xjX)Gg5Uh(YmU(?*HAjb}n3|3V)ivaZ?uYED^oZUUAg%Yn)=0GWS;1LZ#t z=$?w+3XT5<@Klw_H>P+9K$Ahk$cO>vsNagQv;@#+Q6gBnFiM$8b&e4$8Yktw?sVL($qpy!{s|L-rW8gxSiXE@xpOY%`k7C^Wf6^i z=0Xk%m)`6GVi8C6lrw!pZD(Ij;r!BF9(FSy;5;6#1!}{#?R5B7dGK_`|X! zoTCnmUe_IqVEWlWWrQ1+VqCRh)`8-{*>)kLdb}g5_}AWn3&IA@ySOI36QWX`Uq<{% z2I8>ZjL|%(43v%^kIlMq^Vs94s-}!tZ=ujw=Tgv?yfms!T~Wtb~MA@9Yf~wQ4dsIBf$IdJao7Cq#r5e^bIiUSDF7~*qn9Qu@m&A z1Sb{>6h4b$Xtp0n8M4!or z&VE?uqa}dIEuvO+(kbc$)}TD?=2g=~ljZbmNFeh@MqNZb@0InKn73l(x>MO_h(=1oD|@dTyw{u6 zC!sKoCIh{bnywarT2TE8$n`(6{SAFfAphhUd``KKolCH?cs+~GDX|P*!8ED7MA9Gf zpFP{&C$0|!#StZm*uR7sz>2zdfgSfA5?>2Yn$s)+_H5+IGS$mLN&&ik`cT>;&-o2J z+VI?$h96DRj;CI})g5B+4YM@az-$aK64yRfU8+7@kEANS2lXUC+&MTZ3Dv`+#IWnZ zuN}?%48AHox%gB$l_->sl>d+j5GM<>raD~=w2h!4FCNFJ1HG4(GLiYW0BXDfI%m(F z`|H$w48Dx)ERb&uWdo||{`*~5=|G5G*3Mc}lX%`sfyrN$q1vz<#3RF4SM4vxZvSH2 z?Pu-+bSlf6up+TuTAm>>jQ`%@vf%GD@HE?p&*{b5w2!{C)n*C@27%S17(ldk%C3Ni z%(j0Mov-+<&P;y~{r`fAFQ;h>1uubELxgB5j;3yr0B_samwc&M5|HyW&#BEwkjY#? z%e9LKe6iT&xqO)4+HU8X@l=b@jEW{^}})gBavMYD(9_u+*lT6BVVrDfM%lf?Oz^GyT+#S zaMNZ51+he1JA|#MWI%4h5&IoY-s`eYmrlyqe&q?Jqsg{o_?$P%%_U~q)Wcm)OJiyE z353k8C@e3zbfX*p^!)gk?&h=esLM1fRd2y=RtPL2W4w=zj97#4e7v`0G%e5K)shEhxn0|%bq z`55V6z2XhN)Mw=E^P|_~5xq<7z5uOBU}*Vba+JRiwaOOQEWLW0$)2Y#to#Ld!#CLF z0JJMGuPr^1R#UWG-luxgdMdI1s=XM1< zCY5MaJnZv|Pyf8s$%I%`ETx{2Y--rfipP_Zq<51smRVzof2d>z9@U&BJNKGSZvGKv zZ<9~;-91mwxbO?uzZr8VlzJ50@9eX#Rz51$Fv`)}aAN&{5NEYC$_ta*PWI)6m9g<3 zCke8f(TJBgpGF)Nwc)Q60G zfu;~PVMY&YF;Ak=6o@fWk#SKNgXK*%Z3z|FN3A}?1cPYREeDZ&uqS{^RSN73ZtZhg z>6731CMDYr0PH_8D;?VyiS9bZ6|O%KW7R zNM-WN?MOHVx&VShfr;g{ow%9eFlrO@tmlVf-C^}`iCzMkWnaNqk0o%yhnRY>1vA@1 zb#2dM1Ha(9yu>tVDat{Y$515L_FobqRCd=+- z>O=xrh5@?Q?ts+Xfu2Jxvew1ba-MjcrysYj!3S`d51iePgWuy=nXu=pP{X#%wM zq|K6=cpDR{m;?k1PwQcHE(2VK+{_8E6Oxzm6tZQ2wTZt~cwZe^k=E~-Aixp?b&>x5 z?Sx^T9g`nVTl%7HwnkN$q|!jnirwm}Ae-VtFo;d6;;Tii@|&}?B)x}$Y=I8G7b(fD zQhJ}qdeFKZVHqsTidjOQMv<705Gt2qX-oIN3zkYCIe9?^YDPut5l(?p1#CtS_}Y_& z+glkl?pi^$JeS3R(pgr3mKlo(!wUZYI%c-D3rJ*}*j&=?9;Z5r$}A` zB>}Qft!|i1_Ko(r*1li})bBpH8lJ>miQ;eu%N%~Ok0?Qr6_B1ECSpi46y2dD-i3f_Y#GwTnib+GjqIBeO7!tk&Zh<);r!UR$;)R087zSSf?8843(vRIJ? z1F_kG%xE(Pd*x@XnVguW42$rz0@nZYo;DJU5aU@L8nRTkL9ksFENwz$=KtD#y)|-E zUaNIVV!1zxRs})IzrhouVJx%t81&Ox{Ym+aU}{|vbRT?*H?^DJfkJOc>4#*-9^;@zOGLnTk0}2m9H6( z08KBh-90EcoAerrD;~v;NW}J#Hr{UZOsWc1MK=cJ>f3oeP=zbnHY_;nBIPMX$Hdcx zPw~mOpSUPoMRkIs#(w?>@!yN_w7MYb4+Q;?wx7ocf&mWG^H|n}kn5iNwwQ0@8jYH_ za%7|~9d`huJa+180@y(Pq>V{H5SVpDAkx2Nk-60?p?UlT;i@jMeZgpF$6Yia2mRJy62M(RxaBfl^JS)cNP z;-W$+11~!b?Q`Q4fXuo>5BZrGzl4igL6x1ak#Cw2!tEK^DywMRLM{&6F1rIKq72qb zs#K+L>Gfr)no}abOOaHYSzGDeElRU9*CT@!jXA4%SAvgcnQY`Wy%Rq#dB(dx@jbA)}=SmLw&36m&C+`T3q!)^K(*5(oDB^p7zGAF_+5vA4{|yaZpuM z65d9+E1nx?mp!!w5q77c4`#f+iBO)o`>A5jM_|{F_OY4RzAwh?vsS7Es+xb|t<1`p zRMt`PZxr=TiI0&RF%Dm*#9m!}s-&OPODh)9vwg7bQYWx+ZrSR>_$cA0Wee>oC#_jq z90*;_+kNUxlBbahu0%Pba~nX_a=#g{QvlNjCa)FWO8IcMiIUU!PCP>NgPzd3!#qy1 z$ofCX^lZ&`#!)j_sg@T<9~fUO^f*JD5sUs&-XX4pkn>xCx$7!>|HASgcAUvGa8Fl) z&2GJl4vyV>i?u6^KAXR+>o^}zgg#&pEVozTicEzw{{*fxkbSxaQ8A9&T@sbGT1V>* zVsxS4EwT&9mrgjWg9I(~uK3+;-1Xp;QY+}%)>Vk>jYf6xpirL(_YvVe7 z+DMlD?;U9>4zjJY9~VK-rY$#B$@KI2)8n>%dJNJ6Kr$ANAka-lpn5`&%;^ znnG)kyBET{nP|5qWO22|@}7RYCQ=3D)0A4yav{Pd@hwxpr&ViOfQqxr;i{-4r+2OH z?v^*^usBjPE~yPLB@}X%Y}%OZt^t#sXImS$B0ZMaGBPuZ1nWUa^>2*_E((p>MyN(_ za?!1JJMn5<~Mzke(^O5QlVm6kOY4e3NbeQhc0<~LO)h0PTZHDL0nTVzkK3JaY- z89g3jaW=L*Qd|Cxx%z`)nn)LSjv{&8j(cbMZXQONkw@>Q)Lxj4?@}qNz~)BDQ%2+H zXC(72CNANTeb#bhYh)o3DbQInR*8=X&6!Pv!*5$fWq2G!=8rf^%VH^u849_mtsN_2 z(-zmT%@M8XW|LWIGAXkv^}_UPs@YWG0$R)=+jpws_uY?_MI>Jp7Am`ibTOzCNd;qU z5%&;o=n5N;KCaf1OJv4VxoBGLK|nan_G^b|fc~1JqISCY01A0vnNBCnT46dJg6C5W z{ad_g^yE;c-RCf|0Hlfx6tCwVTGBQJT_O^N28nR{hufEG5^$ADEUM2LW!Y|7=oW8$ z63VO>R5@pmqmeVrKdJgbOYvOKg7Hr4SV=t%Mw%eJ=%@p}5XxQ5PA$R&wMNWQe^HXE&_zT}>k`*@h#n=2ShH_tznZ`WAofqm-^ z;G<5vlvITjAI!k-9EEVUfCcSc-A)CAV!6zjUD8pw1(CnL%-ZW3J19nl8+V%p@52w< z)Wp*^(@68?<#KY_BG2i#F@KAJw#LC*{4YVwYb77*OTgPlo6du z(Z4TerWS>_{bt3}M+=T>Yr=YIqS*8(EN!XmvDUfIzK#w0sca>DxC~#*Ml$_7R5>H} zJ8MuZj0J*pJb#_9Wu)FKAbS5qvWBa+gu(aUtxLBSV483-PIvw`2Dyi@T7SGzuoh>J z(BpHXqhpKE*rNeDiLiJIL;{q9LV0V67Y$mFy4E{stj})^lM!Um~ zn2*NE-_L!`a%NW^jLO%x@DjcEJ$&SknU&ONa^p}WB!c-mFzpZb;{w9G$18-Pyt28i z{D=7rVm7((el@JOjT_MgP05=II+rr-_}aRn?N7Hj-Rqu`N@o0FQ?0kSNnQMnty%z`Hs0z9YNxJ(Y~yeFb@EW^rp}Ue_Un#JkB~?n2{ct zuZN8W*jy;nTfXWP`~H!iKcI(VPeiMaLjqvVDMGewL3PMILxQPuw=LvzpSoj~ma7Z!riE!CHM= znXGMkx_2~X+GvZVE#}c>JiO+CqAJXQhmn@2xq{XKCUMmc7}M1}Q-m3hph73&gZlX+ zx_zU+if8f&Dl*eYO@8^YoDw5)1p{Uu#>&N()zTadYGFdM(%+H4!e!*=-O(}sx(cK9 za#snHy@yLJ{)9>#Q;2we^$u|xO%Qpi-_S)NB`ukKtitY>LHb8eLXKm*JJa7v-F*tA z3}g)@J^k*T^U&?q{@ouXXiF?wo$QY~_xh!eA@lcy_&`9c$JA~IRU0uDc#~ANBG;xu z+4O~q!HlsVtN7z{Bm1Bc{&)X_Fn(0LZr8>GYRf#;{?cVIFq$kWEyyyZ{ceg0*;BAL z_-jYck^9Z3ZF&iAJ}=FfG!Z+m{bF}G=$%fw0KDP{#~*$`HPNPY$MgJ14Of<}aSq@B!J%oytG4B0quagFv=6=kcAIr1}EWRdY_V=JVJUbis>ZJqqaf|(+ zdmVExZ}9$Y1Xt_#wes~v2gd)$Ld4<9-_uUdpPThXMNH4@IghYBbG#VjC1xENVyk@q zZ4G|n8EXE-&c`57Mc_soeS47fW|_^6)@LkKDmZMu_!+!ft4H5gUl=bl!Qy~FF z4i`5ld*`iGlwQ+@`8`w2G70jQD!H}`Iw=DHde<_myQ6BH4Bm6~>rlFP@t5f^5LUaX zXRkw8itR&;t$xm(1R(l$o>N56azC~cB5?dOfKBh`9z8=meCuG?27^4^`mcg0-b)2A zfrC7U2==5Rm=`aaQ-+r}!9^lETbfS=dg>5kHT;m92*Z(0t@T)h1ZYJhO>+tb#07w@ z8N6uJ@K>PF89x%6`*H9YG=T>|`~x@v8W6;3XOpJc6F6pEbUf(VrJTmwxCF!=1pr1B z;{@tDION;-n4HbSfs;5NHl_9ndORpJW^SNo)=&Bu$_1XDs~vrG`p^0@>r_KTAE_@S}szKiAJkEz|&7!^-=ocL$87Wr+zf;zm+ zy&|*&l8z!TLg)$cshX#wBe9nAsMb#}l(!Z5OEMIXL)tKS4heIoBed9IYFX7lVlB4& z)vKP>hxglLAD3Q~^D}f{=u!>_APYS2ZS&$Lr=B9ORq0`^cQIjVgsd1&Jq)Gu25x`< z0JcFVt*!UqU%@PN^}f~vd3_keo$3VlB#I0PRF>M9vmgy2Aq{lbAC~ka`I&b@dnivh zqiR?7ZH*0SnJ4LL>$|7=_`1E_U$RdwKtIl)3Vqc6U8&q-wk_TW2ne~_O;JCH)hSJX z=82E)9nm6Q&jjH`9Tq$D14QphX?$Te%D3{JUIDoQTji~>K#1k1KY06 z>FF1vvXP75FN$m7ALD~AR~{({^7p?Uq2B9trU|LlNjfCv)#T0=stb$^;yk>B;D1pH z>Dz~Q#-+5rK&Kd7q3;#@cnjGXMx2s}^pQLi{@!_{uwQJOlJK5%cx@Y`RVEq`UKFx_ zN5(rHN*sR|aYz-TbLT&Z`BP5Z=&*l|JVQ zZLSpbE{~!39+Py!2_WOZy&D?zV@OXSJd z`=%z6jK0p<12Jv`FV7#?=YF9PIfJ%R{PS*G@ebrr9s6M}DdgciU1jvKxeMpY(Zl5* z+u?^_cx2{J$X?Xi!j|hpA0O1&r6r<#8pZ|dFejez==AG!V350|+I3tYD!a%y4b z@1V&rS+<+W+Li%%jIG8yTX=#TwU}<1X;V#^MFnkf5%Ga04Cm#*K9u^UOVep}yM6Q2 zC>Cd!@%Z>ygW#7kR@8mpf27P1uRBOm@6iL!G%{EeW!u#oM+X!y5DQMrNA5LP<`mv` zKl{K;8E>(ixIQF9>7?d=bJN%UG^3M>1_3_~pPaBb(Rb5TRt^@j8 z>}TJNy@M#K6TJiYh&|-u(=y!OcWbF=g01DZQ`6t+VV`XdUUVl0BU>l~kIip=y^2fM zFBH2n^b!^@t9VbVrB~d{gJo0yuya-t)uVh+*3N2oznJ!NXSCYhAqhu<{$ot9%Mua< zh1Bk%pEbYKqpqsHCe(!rr=okM0=se}F`rL6wTwll#o@|Dw9s;znk@<<0lEwWyYArM ziybF+-GCgDNulXm$lMsS_!R-3wI2h@L0>K0ZF(Lr3kmuSYgN)4AMbVLD)q34|3QLd z5xO!T3a#d3a-BIUceXYr&KA$2xe+!O9tctBiOB- zBmDfJNgdNRZfy3_GEG)+raWtebX&6Cz5IKOU5stl?^6%^CNqN>xPgPCX}IS>)!{U`TYlLXOEEOG(XVz12TQ1Bm7j!o*Z8gqB3jHIa%_rx{Vp|oHxU7Ex%KT=kHEEzBS3cOxv(xZZ z)!)vq1QrWi9?Q!54BI_4^aCBGVweq$#dE%1nTLhapEdje3f%*SNil2glA7NWDL z^Os)`taWJobP!Tn+O4DUnFwZ``VNEbr`{r-oYIPXz4K6!b3z74x(j0(IGkHlaZUOU z0_p*Dk?GR|i#X5)tgAicJZ9{go7KHv+j_t(xOzACXTtGgEjw@lC_MqmvO&5f1Tlp? zfQyPD8FQT=DunjemUxF5uU%+`73l!m+a{5+nY6(VA+oqXuFiEF{$@G)7N~G&;8x8$ zQr~9ejQIPCw}=y?4T+B0+x#;C2#e)>M%!{gw>mK4?%*nWq~<`v&8^vzKt2y$$XnAU9a|}r9J|9|y!I+x-v7RATUwz!zyb`<^BfM>Qt1_0N_`Hr52LWqk=>IWNz+$L=I|C{%icQ6$wIc9{%vs+x3aDAK2 zP>Jt%zD7Vj#)~r2h$IiTc|^BC2B3et-~B*=73*?}Kspv25{NZciV_DVl7GXS2F3zP zZ;>~^hU8|$;Sw`jkLY95HqqjlofS!cTiHOfu|gIBQ|gByFcuK@6}e1BqyP1Byj9EP zHD5G@$mPaTZ5BGt|MURwDRsFl&l{gP%LKJEpXa=#w3C-RWNwH&6BOW_JvmA>p}=T-Eog8UoEGM%$VDVDH|I0!r71*o4edVQYueToO@ zWeem{2x3i!Af}n&de?J?>SvETgzAfN^Iw2+d0}K>3HcAryXhmIWiSwyDBlbsO`Hxa zvq2PTtR?-s%u!?YbQp}}PoCx|W*Il;OilwC?AFs^LLhOe_{~2=MvIu!0=a+slaooW zI|fA6FB5z`?!v*|1jGQ~Pu3Y58lWsj>xVM(Eg!@d=z=J?a;?hZ>oakBQy3ap`;vn8P+gz#A6T|`&!0M-LY4?kKGv%i zI^~WrT<0TMIEO6>-RP$r#yr<9v5N``?fds>C0gudFnBC3OhqwC-Z1BOvFNBmwAq)x z!izWtek>Hq!Uw2X3w1{A9^Bxp{K$vp_nFH#%;|^C8~X$>oAJLK+TZ7T+KbI*@v2jp+>hgk8&OAm(+N zEw`n_r>)j(cUJlvCERqkKq$#Ii`tZ~{dT$P)?uc4dc@j_Vt&PqSqF4kq(Abz#Vo^bq`YE>uj@bKldQOYZ^$!#DEy zFB3MhvSbUq0t?wK7t8yE7r4jj$ZG+JEB&{AIgQ3YO54#OyEL4~88Z_kaCr{lj|fjJ z)yCJV%;&#mXRN2{{dgoUp`2EqdKJfp?@3!9GzLn)w6F19AkGW_GVXNn5wEE1Y|`_S zEy@b`!Y~eJ>f2v=p7ZJA@na1p%6>iJ?)Bq!Wtsm$e0NjUlH_*=|9ODz3g}H`tzC}N z-Z+@oQUE3_J1OwkTy$3{ z%(eOHFrCjShOaT}xcpl^QMsfUnsid-^dGbaScA}fK`v0p-dtl(g09%Sz~MtZXrfGJ zX;%Fq0iY9zLCe8UCM`)#Q0OQ$h-g|k?G9$iY)mtl`|cCBZBN6+0JbK(L%*L;91C`S zWXW)Gbdp=~E#Qt^U|;;=`RHrHaS1Y~DBVB-6$$8bFXh9*&xuAMrEfXB#{rJkq97)V zf({wulvacVY5djYIulO}9Q340aB8gvL<}hy-vY#$@efC*6+8f|p$>xPE$v z>D8EXv!u}NV01ngYx(_MMot5@x)VvECA9FI4Ml8v*BJo8-}bsy2f8_t&BiVBM3=Qr zNIglaOXxsasO>A_Dl_s~q%$Dt*k}89?BBn1{*UsMj68HmH5){5Z8qXNzLf@84nwi$)vF2DFetvD zSw>L%b1;8|lYcGbWVjNIb!qt9OU)YuvePO&Cg;ITCI5CcUJQoR%d^KNBR%2)Y6*my zS=y72?I@LTNcqSh;nfbS-0YiZ9wsdh)V_Z0`9|)=&s4&P_0Yc;E+4G36*KXRU~`zX zTJ_Xla!7?-u;V#jw@iQXLg_i+4_^BoP?OaL*0DPO_N7-hXs^FNt8>qd3x?_P8!>t1 zt~Z8SXa0kL`oy)&;DusnIAam4^9a>WY|MPse4xeg>p?<;1-^c#rh@3gFRAD$(3ISC z^x^yrjKz5W7 z|2rG6p1)qV>$eP}(j^Xf#+r))9Xrnu8^ZK&PBEPf=t_^^DFt8>4dsf43)UE$v28`U z<5Q{S!Z3fbA2GQ6dC1E#D}xCoR||MBMPX{1=#zC#?JGil zLE;1XuU`Aor6D6Xk2%d~?n$F@jJ^@0Zgw-A=Xm+}js@US zo!wMd{rY5l=XE=|k@u^6B`sY{Ki0#=$6?d)l*pfdI1PE-5WSftB!k7;RKKi@U9*7E z`Mja@AEC1FP*Be3IbTQAs-ZZ#J{~M5r&>~4ms|vrYfhb>gf8*RubzJ^RwE0O?6g<- zlG{$0X022Ze5$rKA0PM8sX5%I2?4q80>{F|0b+z*)!b|V`J}FXq0*~s%5tfgStTXH zGQUjqZuw2egWNN~xB)=KWkKh4JTmV#xv#R>G*XwN&0F~wS5aErd*~vs5=-;BTtud8 zCvJF0PI4rcpS1L9EwiC}E-Ff44BH?4>dE_~7Otmbld9iS^Je;yl3a>q^^5rHZ1#&{dK*nR4Zt|gpGCFpe4I*0VoVVAY5`c(G(V& zKd)9-qgUE_x-oX<8sVmGd?)N*0%Z*%ryC)GLbp#Ymp;GnI9F#KqXYsn5=KidAnKKX z9w?99fid0Ln3J8{ZI(%Wwh+3?;sc4*nu^~dF9!YE?S)um6o(H~X0OOcx5Gd>3U8jZ zFmJMqYjdf*_Rs>TxMa9yvzw}txtkyFuayJ_rJ@!)fvV^bc|-rfPL7~?pmF@2VI;!; z(i10!I|Y;_RXm_z(8{tg76h>`n}i*}vT1dBRGYR!xi@KXXln{kHC}qJrI(*l_Eb&( zJm|jn4~5;$X$qnI+Nz`;EX!Kw7-mi$F`dD{L3%8(2&2hlUdMMU9C#F5V%CmZ2-@0a zfQ()s_3CEvK(+fW^R)vpvDQdw8ULpXn}%7kn0cySbaNl7w6VU0p#*xTAlbeo{ny^@ zOc*?J6TsDNCA9#NoozJ+vo?&2TqLwTw~^s-crl6(^mq5EV{ zRIsMzc``v#D#6YF3es?bG!tnj(JqfDQAa&*ZnZ-dNZm40~QxIqWjCx{n zIe{Xt7o6ulwGI zO5%lq_kOdq@E@c3ADx)aje&BCHyD%fSdyjZo~3z?d^2_W0-NAZQB1rQ#W0+#P67pLYkEd zoB=%R)|pL=1qv(qjDkK?5W&CsZvd1#NQ{vO{&62$+CR0~t%t7T^_*2`ozx#bkHGw8 zR&*NBiWJj2(L(&vD1c*IkS~ESWGMd2lv(SUn2*imX)72w7q9e7{Nrqg)j3S5ZO!ry8(;!VU%lEL1C zCn`)b32oWpDk{MHePVo_`3|kvzEGSFaO1`okn9%DDo?`4$cDMg%xaCpro2{7J*E2} zM3)~+_9+Qhw6XF3_WbHC>M)BA>X%=h!P5WaHeCPMD1~dehNM^3Si> zc5t#bShSuPr<2@10s9_8Y=!z$M_{emHHS`>*V+uvyZH_t%I-t5IPib}09A)yATusO8h zTQ>b7(81V2Ps?yFTCD!a?K(U8JBWU z&hgLELG01mhN*z45UL=7GEl5-H$vVg50u4oV32Q10T!Q)D6G*&o)>2-DAh0rS!7TV z6%B!ldRmDfTi~mTQ%JHH4{U17>lby1OkE}!KG=3xK8UNhOnYuxb*3T!UC9NKNe}UG zxL7bNp2nhmdpS~u?4pw8n?-9LM&?fBPR3DuI zt@SCP-grJU7t1LOtkghJ9*0SRVb+4}6VX@9-%lse!(3qP#L zSLyG`@cXe5v<5>8=6)Myu6O=a@7>b(HPO$ejw|(DXo*1$r9z>3QtJ;*{a^T`Hb>FY z(c(FXNJ8G)!{7R=3)s~AQPIHAW^0z-6IvmJ4#R8JFGR?K)y%H@xXowdws+f!#Hilg&c7qY5CcL`CD zb1;wiIf&Ff9g)AMW!y(724Kamhz~v*2e}da8Jn_k25-Tl&9a=>ed|LBZ>pAcQXwrn zI$^#%$FOVFE~h7MxPBxdn0P$}J;#*OKQ9w5ma5HZtr@>QR9l_-QSR9j?zmi-Q0OA* z2Vj@vh_HycFkMi*+^MGH9G(Xz9F0nhnQD)!^V_L^0rJNrfuxZjSnD4==X+b_HsSeU z+}X!Ve_gTof!%-Yrq9&G!N!p-%v%OxSX%8V`-Y6ooOTlL*R87t;>3*&no=ICpS@u* ziit{ecZU5bnOfL3&r1HBt#$m%vhZgi_F$~#FzHB}xX#nN@K~A@l5MNo)1&j%+W@=S zI+}P-Tl?KY9yUIq@m`>fF^7|nvC;Tw?keG1%Hi45OFSVv>zYv@o7K{Ei{CNOV1X~< zQROY5I1WFe6gjg z?BM0y2G?`WPnAoy@SDR7aN=s0jtEhAu9>;GFIa1$MfX}&Gv&Iv4!Cb3ZtXhuDt!K< zF=;K7w>(q=cIh`~uYGO~Iq&TcMF{bQ_|+Hi7=??w9HIwx{UmJDk&Fs0iz7eJ{H?9W zc4{rfiD2>BC5NXtD>IS1ZSLGp^Su)+a_ZQ_#l&AlW-@;hT8d9Zp(ElCDMVM}vt{PO zrHmS{epYth`3XZ9&tj0}Z;suq|Dj$l`3f@Ii1TKRW`Edr8Z#qwX>)A${p$ZnI`?>{ z+y9SGQ!B|*+)Xwkx^w6*hYoX?QMY4qK6H>|N_7i!HrYt3TWfPZ6s8>JP@xnmnUpz{ z$rL%{Fq*|2=P+jX@ACcqyT^ll_W69S>v|tv@8`=jCxm8exuCCb=-7CW0YxrfIQptE zVH3h^Vej#6Dj~VIgMzl`8~Hq*cY5+cpO&U(>~MH81%r$jc52(N;g_@_W0Q^DcHqa| zfZS4>3k}-w)#x`ysDd0>5^^uRV^fkxkOm$F;ZugAT@qu>$aceCN(7q7ed zWnAO9IVzHyj}h+6fth%Vdzlb9Lz5t22FOU$mJ|Hw&>h(Iew_%nwV+zLjBolVXDc3r zITE?JqD=@o)91!*D&Xml;g5XYEynz|W+L%9aqHR^C)#!bF7I|eIQbZe8He7dZ)eT$ z?=D%5v!Fo9uCz@(?>4sr8^xbYbY}D$qOcgDxa`A+k=KTrLE$-L$^8iKZ0Q+`&$kH_ zUx=xepP`Q@mYmm+Gg?wvB#oMcsXllL^FEfqLK0jPUr=-# z1wa=Cn=k%^x+69J9Oi9=X9Rw9z4xdwAQt~C;Ai}hX(q~zX3A2JQb>SEX^1HSe5ib{Q>*5;wK1wIEF8!1!>^X`=^ zD9eVO{A~p?f;%>U@GJ*?e&>BB$-^^+w#%xu|OV`(L zsl}<|X?8?i)SD1{`C{A4R`{Wnx4VJd&gZ#@rOD!$|e*X*Hx;2t7XO0ns^w>sX@_-wfdM3qva^WGcr%% zZDwxjHBd~m^)r91q3d35Ot}ZgGi$Xs1xd9+cxW}8EzA8kf5(PX>HZA9M)Kx z(-yZ2;Z_Lbd_&L;1h3+xu<+U+SGT=u-S@D+HSLb_Ynn#gB~F`N;Eztc%Hq{`kZk$9 zS<5`~LhstGurjtqwhrvpbZr2Lcq+KrM z9kHNYmD$bs>1!-yc8nXiCHZUgA4NOHY=S=g9J%?^3)TOg(7c72=cOMbHTvqt;^`CC zHwRC2oPFj~BNIRMu@v&4Y*4SZY&!5=KX!A-oz+XhZ{mJvyh}N2KH1#0p3F~sEc-DkZjzHl z?lQ8p)P-`jEnib${-IOkroP<qrfz&woX6PXC=Wf|iMp1I2j5as5MZ`+AW2kBi*! zwa33q4l$erpaf>4f`L(SDqOMfSLvq!zrD1Pb9+e4-*1yj(Nn9T!+6F@;!XGE1IjMA zyQufMpsjE=9^!k$-#3|w^j-}G^@0j3;vV_+pYav%ap_SnKe|mkkM7nz6LDp{&8SsH zL&aO&M0QP*t8*4jjh0-%v4^$a1-v}0Lp5y1v0oj@aH$5t33>7E_1WvVtApPey^dZV zv@9m{m-^XCUI;nZgi*Bnrg2Z%8(o(2Fz$TIQ0 z#`@9SyRcyL+O4?U>D;1$cxo2Y0m>^4+V7|h4&yyyT+w-IN4Mtbg5JCa0L(2*VOG8t zBD}cs!2O4Gl+>3qq}_SZe|1rpIf&; zMSgR_BAeqm^7IP(A*w!E`$PKmw58tPA1_U~uOzp$UO$Pa*1rwLHgs%u)!X?taW)1R z*`1AW=^{Eve+GPN|Qel%U1NUxGVjcAD_*djVS}>ILx*khu zb?!8mQ;ZpQfAFO$@$~!u6&-WY+_B`Z_UXD~VnU&}$#X@u#hq4t29E=#p2C1=vuPiB&1?+0_ z-64Z46b8)CG;2jNT|gCz4K()8tlS=>bMxSt>bUXkJZ`)Fo4TF_@+LmEBLpHL1kUGPqTOp$RM>b}=BIyxPFF-SjbL zWgW*rU+khR0jo-vrJOMSJa1N90_98sP22a!+ipo;%h1}t^WW_c1Swm3+f$iS`8hG# z2ghC0n}fqwqXBxN@?GHt%dP#tn&T_l>!B)`-x&UKgbV@8!V>YguC(*S)FbK1=T2pf z&Uf7WaCXo29jsKqablt(`ObG#Y%x2!j*Xv@U#khY4Q<4TwKAPp1ciT8tv*)1$e1|x zCU0valBkmI9Kqr2_B{W1`)+*u;r=UGphCJ=XR@Fvy?P%R}K$baVkfC|MS4oP+a(maw6G3$W}7%?qx1L zR(AN(zzuHV2Wi=TvkG|W3huhjwl+z;```X$t#vPgkA(#r#2Sj~ugRQONA-HD-2H-L zm&ZujD7h02|4zPaa;g=i(B!VHXV>cXbWk=A(jTEU(KF6BM5kg|`OurH6k4X_Ea6n8;7nV}vAA1vgt)w~ z0DbqHWJ$-hq`i84yV`~It^)l|BR&rUU)K`62>dHf^^WMZmfPC9_&Z)ZJlb+HM0nMz z{~)ftjp(LvDlxP~Nv(;IcKcf*4Q=o z`OE75Z-;P$I$xvKYSD)uD>}Om4Bz`^HQ1NfR{!RZvCl*3^oMCgTl@lf4|-5Vm>RRg zQ2mC}lfV?a_ORnQqJ9;rzI^YS1^KuH%*FoQbX_rX)|}UWbxARIuWq`Z%9Y^TC6t|d zY)jQ}#pfx#_e0k_{XV;A-`gbZu56X|JTbVJg}JPe%C;@~^T3Hmoer;cOj{aRCqAO{ znPA}*?s@$&DMCszy#<1L>)z96vTt4}G#3?>hlR?=ZuVy@W+N9y@9aa|Z@z5ga zFNJFd*|PT+&Nc2UFjVv0W%NX<5lyVN_p;noWO0LBTO6eQ`U4#`Aff7V3uDkzeR-5HS7zr;i}gtOy*uWJ4}Tt*6976aQhEtJo*IU zWRi9BbX3uoLmwU({na-!Z9p2l&V{PfuDuH%zLH*{cA&k{II^V`oo8`D(u2Mlb>4wf zBME05qrBD52C2H4$fI2YSi_PO|b<4NP=UvBJD$xAp-v$r^O#pA`3H!o`XpLIZX z$+IfZ6$(Q&Csxq!Fe-On+55hV&MNrl{9k3(%`LmtsoXj)44rUx%{^Nu@PcWdewR9T z9d&P@whyYwrRG(0eCM4P#IpZEYM6$~vD~$$o_xObVIPF-M=m7*J0~HW`!~e*#MAKb zk3shB#vZ?WCx2Qfu&jMkal6-k?kJEo!sn z%%cn$B7VJ~zmL9N6i9FQO%m}%?g`x$#Fi^R=B3TY&wPS!pO4QQx>vSkC*_ahCex}) zmz?5aLlPk2rEj;pTv}SYnXsTspcXE(igbVfQ3x#G09e(DgHF)?Q!iUxWNG>jEo7Z( zbv@aq&urmw+w*}K2D+(d7ru_07~wNsY*`c3s(RrhJFPu*J2i~|&JasoQwmAZVo zQwn6q0D;}3=>7LC+(8=^<(#P3wZjClw6MVc@&d1E=xK&HOh^fpq+OsbhpVn#cpr2j zl67-kYtkeb-==SEX(O**$3(7oMzTg6?kGq0=)ZcGypWa}@WGZl-T&e^%F?=g=$|uw zX+I7gd(oPz_Ik*-5VB>kY%M#+%Aq;aK<=D-*ME@w$qU9G`~KCz7kafRDLv_j>Q_>B zd^)4)vV2!qGCg&4P;2*^)#K#{5Z#deZc!^ z0K{>#E4|IT#H}^rqKKIEpeZ>$sijW%E3f!e2A_N}o4)knZBR*JQmvebM;#zlkC@yY ze_(pkK>tCRqN`v!=I)4l8-gFle&Aq`P@0FpYfnFT=TvJ zn)9bo=l8PmF-62d4OIcM*zfHy?Pg@Romo-aEUe<}l=8rvzNO zt^eYqYrE9EC6~JjlW%XnU!J3L7_F;8(H(t4{rEwH`VF;Tr?Mod&Z`y@(xZ5+{m$hr z(Rb3FE-|l&Ja7@3_IvtLoOK>1asA2)H0wCL2YHI=CqK?+Sna43H=4^TaEsjK2b82` z7}3X=iEID*$Hi42i^6?~{#N`lyT9lgl+fW2A1+%P(S+gPNwx{pEBc*nViwkNl z2QU!#j4Pz?^dDE6Q;P>amA7Ad-V_pW<6X=0!GJZ5ds{9gS8~@MCpT{n5C7w7>cIAp zzuG=bnKW;{BY!exS>{AigzQ|k@7@JPqZD&gq1E;LHi%k__UB;4wEui`_f%NaE=?Yt z`1hlo7>eLR9EAO17HjNQEb#sJc4@OGC$m+B84MXN5vrr^N~`4f!~sXa=Q{2A-;Va` zf9-giXReMsfZJC*a6=oo6iDT152&bpdy>we?+$Q$d>*eYfaPy8$iPN1N_(r)y#CF- zd++}9IN~I|76vW;1t>NHkH#Nb%+xi|M?8@a%l;vpDymNY^sC^Q#=l8_oCePDMa;1< zb;QhtlJKl;w&@Fo{XI%kgk(3R^7%)Y8uUMk(^Htaq-dh^@ii+7FK#88U?X8y9*LzE zFray_UKsZ8p~CF%iWdb|KPQ5W{VG<-wgJPs4yFy6ueC5rY-~^rh&jsTKU*t{NOXsB zOJH%|1VS6Wz>Zhr>8C=sg@ei!@F6MkNkuiRf{qK3rgZkW=q{18)sF)%N(yxL6As=q)%Q7Y&Mwq76*P-o0Sit7x zx-WdG`Pd=~rzeteWIbMmOR7v8+6sofr8vkq(4x5RRfh~yr_x8_Y+J6M_O~+<*Na$O z)_lI7`s}1*d~Xm&h|Ua18)i`mIkFMr2AMBR{sZUB0$M=Bx!@c;FoATKE8b)TF36td zjyQ4j40c6AH~x11=`RclNO-WnuQ7HdQx0Lb!0>#~g?Z-o za(mFA=FoidmmH*-2y-Y6sd_Kg~I1QtzY3k zZ;bEM*Q4Sfc&Z+49#^cL+=2mP7!HyeTQ>~?AJ|3;`3^D9?zHd)y?&^---GU|zvwM{ zg?-ZCEKfBe0aeCz;~;yh2GK7Ht-`+kDyyUeGdROf-MFR;R?xkck-r@XOv%MD#~^!4 zY$ju#n@FyxoxpI5x1#g&#e*yAB>Yxyx0je(r;5)ZfD@cubYxf#fMWoch=UN9 z4z>W}Vk8`ZQeHt#6bEagLs#(|F*H78A{q{|KNPUh>3C28g}&FvmRhT;HyBF1x@7}9 zLs9SJ#fij4z`X+UG`)efbz}4bwR>2P=9GAP;-Af>`r$`4z4ZDSBb@mX58Aj(F=1nj z{Mo7p-EpbpN4X4)m^wXg3^D)%+Jc1q(bb|BCf>*bdJgdlAKpR=`fowjVJZVeSF0iM z=tGAQFcYGnc?GA+<}d==#X6U_tLKG1+R2@!kaJ{C0|v^q^Zc4!m9TMGoscbB*U7(Y zU3E+M@R@2%k%%UXhi-)3Z-lJ8NLeRG||EJW$8lY!q6uRm0;S}r~?c?5=!&h!; zM9S~+mY@od(O~`Aa(S;^+LloDkd1_-vNs*e#ot#-NIyE=Hoo%*>r%664%yt{!be{M zn6EFqh57cbqX4G~GVXOP)Q>ko?_*^_pT$;~@y0?${bt$x+MSO#U#4~#lMqYXSNfK+ zr&NHk8KYQ_n!`nN0A%EETqbTz=DY4GmyEFUo*-F%OBD-&y6^FCf;l&JQqT((^oX3A zqf9}V=S9Y~Q3v(n`Z;l(B#7J86>C!qRxy##DJ2jVgYxKfQw?GfI{z#E9<&E=xM=g6 z&Bj760?@^{z+TgBe^JugI)qrCNCcry!jT&P8YCF;Nwzbke>4t-&Q5~6iIl@g+={5A zOXIzMCV(5636w*bWSoO19#p!|xZRv%IpWfd6HL6lmzG*V`kwzNwS4w{4oL7c4PjNy zMr&l?`P2dHB=5h-P}B`5m|Z9E&Gv=&#oVo7bVlP9w-5Wxt%fS08sOLeVI%*kZ*gOj za*5v2azE3phpgh7*0(mQM*FGLnvU*==S6zACjT2|Rj`fc{GsZJn{Vi!1kN9UV|Ml zyAAm#ND7u;zo2^t)t8pvF+GoBddFJ%hoUoZ+6tGXCR4zBa$s`R$-BWk*8v?>ryjRT z3@_CXaYY!PO}yDlwPC9&X|eLRPD-suLFwObACRY6c#~(6E$#;IY4ulWh)~6M0*PbW z6Rh3JV4l!Qbt!Xdewp8sitT*8w=Xp;AO zlM=$IufZ5D17NDd#P3hI z;}BENXtIT(F0_>2gQfwYT2^^7EpSfdKZxW_^?i0AlhEyMkV}2&`bbTN#9#FTyU5-u zdDSt(0Ni0#VDl0IMcp0Kb1AeN(j5*5&O^c74++LsyHe7V)}PpI=87q#TV*!eG|-HT z3w(D@FfzD-agkGWM(=52Fx@RiRKhGKJ=l8GTXG{Mu+~1NA zLJ(^M{&`+Q94)wQ)!1!``1yegD! z7GsYEt^tW<`|}JMb&`OTkHYquSb57(QgEzs<5J^qIRieXC^7X*oIp_iS0 zem}-=S14$&tA43zY-OKAH722Ob}k>|k<_8C%Fl(N%X}b}O2B+}P@(e}Xos%HBeqoS z=6L?Bjj=tVoX~6(24aiRrw4ahz7r1<1f8V|3M-PuBKl<{nKK{iH~&-2WTVey`lWPc>Wjt9XiQ88z$h74b_mo5zjwp(&;b+ z=#gcVF%ULw$OACk#NQ0(h6CDuMK)aU<_;Qarm?nV3s0Q-3=kYISCy(Cq9QfYdtG~yS3J=I7uj2t_^kzZahMFi& zBvZ~)+-&8P%<{S&9Z?wdGDm2d4HSBIlC%PgCq?dm?f!$cA#kV7m%RJLM#@T1&4{GF$P8{;d)43`5bOqziA{{bf3aRpK`+ z6NS&LF3CojGbMOH?|gc_@jx4uVlt3MI zs;|;miqbugGJ!+tWG4v2;MYG#ZS$vj#cxC;k^ag*tsYT7bE}UYwR2o@6ApvU5?67j zEAj?HW$1xxqO(GPAyaY^yMFDL_dEImu;!GwbxnM^N?%{HO0L7>Bf) z^p+0e7#yJDDH_;i^))y&iK5*$MFDZII$(x9IF6a@B_FP+zrsII$3eP2c_z=^)e^#K zaA5Jf%50!kqVQF?9Z4~iz+471x_R1GO=Edho&-*fkndWAS8}HGWK%XWfY33ZK3sH8 zm;sxnLr+(6WM%ZKZ!~-%&SC5BV(c3^D~4!7hlKBNeYJPXfS<|_e$UW?xD>d5L+94D zwh23c9am*BuZKR)@+!doPR{9_aon&MtMLyN2y7+{r?wCQ>-W){u;GZM^%$*$TIM8x zC4zv$Df`bDnAgxn21=7{KGeB5Nh97h#9}bq-vkZ=QMiMJ&g4m=T?el18jB%NYo~BV z0oKSIIFK(ZeCKXY zt?5q|1DY6EgVLk3RzrkEg9Aav6jByC0SbmcYSDKcNI)0rg+UUi^&17}b5EqXN<0S8 z#VFJvHr6mv#zJkd{_ZcMbu!~fydi=m9SV$I4qbyIlW^ zQRIw-K&NE|O_5^dBe*bdn09L-@zgBtLg54!JgOg7Tu1-ILIk_h+3$bTJ#t1)Gn54z zHUb-j!wF**NhT=6mg>ZU?HO?#^+htk+>^Zey z8>~N~*j6g2JPH>q=dM%}B9{+PYMX%wY?2y3U#gHyyCl9_x)Fht ztjg0pLnKSlT@?^~XABYDR0KKaBHGBM7_tObAWQTuOub+D|9-Ef=3^un2pPc0yxYM2 zT|CT8v!MwZtSj?%Ecoyu-!Yz}(j;EuTUs&DJkgpAW2Zy-RzLdyHL z2lqKlShOk^V-y`KF4?{t3jET>OM-T7ZTSW6K~h7z|4!aDdISH=e+)xIMB9$J;tS z!>$-|JE`j>7t`JL$P{daC|jxIkP|$l!vUE-di;Cq1pt57;-Dh!3a$B%Q}_aUNj5gCJ%$-++Rq$<5a$XEl$W83;s)rv=G;s>4Lo=#zo12qw zW!_J!0SE^>Nr+;<=lZ~Ly@{%&ziqO|l)fH-ld1OZ6?0XXJK-*rVUlTgJSA8TvKqEA z=a3la#3D}$N0Vu7krhVv5Wc#+JQ9el z$9yVYb=drbx5>c{7#i|4Xg9rOzsUw*n?t~8fMZ9MM@k)LvZqrnO9jjuZ1c_^-qUQb z9E*kDbR(c=Ujt9)W`krtC;wSV-vQc}dpB?MVj;spnC1bXfzqqX8TZM4aF$ppMd5jDnd)7oW0lHL>@S^CEGLTJJfkwB zkouN&AVcSsH54IWL4Rg>Tym2#zv3-rlFXqO=~^@HD9^Es-}qH{4ZgH#fI<{8i%JN| zg*VPxsur6SYX0u8-5CsCL)-9fsJEJROUqyJ84wcM>9oU$@yQGflWP(T6jRQ_;*uXD zt~XbZasxtc9!~qDT3g)OQ&1`}!K)YViKnLJ%SBM_EnTQ))3r#~Mh&|g{(ry%ezmG& ztA218uhe+sXD6_F0<*6s*2xtbrC41o6DgHH=wKmyDnI__R zMyWtV)=r*N$a3Uf<%MtK9;k6BI@WJ|_Ew6Noluac>H0xw+uHgTd;3V(P@<94kz)_; zjTvhU-H~w!Y)-K*v__<>2TVuf+MJE~h+)qsLNkU#B%1nTbySL8v6xcKXUvZGY@mmssrOCB&8=s*oYmmsc~W`)ihlSrd+2qK!$&K?RQIcPIN8yd!?Za zMEQ;1+$TTVSY1a5XnTi7EFoQw;;ma!OhhA@RVRTtOmF$ksD;DI?()Kske~VHYvWgj zH`QD7b7XSoRmSFFDNzTyaO1-A^E;RInQFI$swIHX%D3%3zx?@SIAZvd+vU?QgB5PJ zFB3_MBq90nIq>=N^8N2c{_UA3@^HaT2$3%qG`AtNFG-ryO_k96a@#F~waCIO_Sc3F zS@)~HeRHB(8q39Z(#8|fX1x#X{(1+xc!$j3uov_Xg>gz@Tdl%;q39Vr@S(c=AHlK*kTHDHz;nk~fTmH{`m}NA>bJ9(KI05zAu`j> zV>idQDA_}nt~cOc`KDsfn6+Mk8vo(>SN#EwIYCIB=ur%qgDKMLz34QVr z$<>FIGb>cm#_oq?jaV2Oet2%ay|p9iQ{Ydt18!$cy<9EN*`))2hB!%x4TD+w2M6?sOReUy(J#M>ZFBs+J0{_mzd%aF7Er;jJsT!m76 zYm8~1iMw=7)2W!Nq7j#f&jz$Xt+jV@?_zYyEVdmqyV-z|4m)66cc5-xo&U`&;l0oa zTxfdEX!-*!+o=?58=bMTTiZ+kL5)K4>OOc)%OYT_$iY9PI+Po$Exw=P;FOnxr(VyZ z-2GG0J=kWFQoa+`Q*`>iU0Knf0z{gwC1ZxFn${)mt$5|AC>14&4IFM1f)G2w>&CG3 z{Eu|0&DQKeL$Q%0-G-21rW^qYZNYWDyi$UcKK*g#it;JHcuxNus>)twe%B+?4VKR0 z(u9RBqfIskS}UB=)uT0`N`|u4QR&Q!petG``{FkA^-=iOyTxYha+X0MoW5ecW+gY} z5X%#>Axy!o=rG`fw*B<0qV^I`fvT_fu>lZfe$z_PJ!YL)W~eGBw-uwrLhurce3Z7; z{5!volHW0HhG7|7jr3&&#cuZLCr8x2hS_gLv`E~1H64{+TkjrMGQ4O{l<%S0maBQl zIO!Uif^3ERUh4=ZBSRn)JI?$uAJ;4FklM~vNt+8EOZV{jD@i6NgyIK<&}<9FjP)#j z(X_)AfPrZg3Dc`%ui55f|saAehyE>|n-Lbo=0_J_(2_$9V?Fb1Uuii3vg z`cJc3jLpBayH1~@7K#Rx2uDj^X1=_Z*Bzn0P=fMs!!St!RsT*inq_6xciH_ zHW<5~6zK2t`KU^>R*O1CZmTru3`%P z_*k1}D?3VxwzWp0{$a(0aM%SJ=E4L-uJ#FOk)WK7sBkVU;+lrc` zYk~^jc8}0kJd_o)!a7VRl+=|*>tEV06ja?Y><}HhWuso|#AHIGdJjWF6&tVZwXXc` zb#(AhZ+3UfW0b4!CZi-9rtJF_#UB2-2lYeQ(!uK0CdZoQ7m+k4aqX9|&bx1|;r!oZIeJ%Yd0zbd@&xXg3VqDO)=D~S_6HMqKD5P> zyrlS&NQoO_k~zbf>{nQvG9H$TAz$pOwv;6+trF$_gG|lhS_&#Va|GmN_^TZGDzp78n;1d9pp4v?aMeY;e%cf$;9Us8c1rLm$lirbXHMMq^ zY6Fy2dI7qGU8mGCNlmBk8n1t|v?y*^UG&i`Jb`Gf^}hLbXDEMJF&aPr^w03l-oENY zC2J2=zj-iaMY?GFitJsr?=)Jw047>ql%#LI(-r1Z1JwgBe<0gIxE4kKW<@ zIKGJFHq!G<)7_nj#^3(Hd3KvLUB5aJ5@cMU$i}e7X%{b!dwh7%_{N*ZsCPYMo0>!I zWvvjHqlLSYf~>|lHT=G}zba<)PHzjg(7y9@chvPg;5%}@4ZHQ|Gz#co-ZO5Yb6q=< zr?pWa1@)hzsIZ`(Z)mFomge)b{x=FAk(`gkiQj}TDP-zr*d6AB1gFUFel7@rp3OMD zbU=(d01D~7Rf*dtmU)}wgV!7@^~;9B2(zvQhA81|`MDouAq&TZr=za?2^n>;}=i~fOe zHWnmwi|`_?u1mJ>c5E%yiT$Czs2Jsmk8A|%o#fRde0tG9TAmF?VQ?cZ&l>rlugCWa z^E8fD?`z`XQOZYqGz4sa;0{B2QY??I7gtS_^UDaQYkl$97#Lmz{5+;YkoY{+HzO{c$;X210D?y5Ev0 z_dXtF#lPsJgx+iv?t3#?LS`UCi$TIAX>j;Jr*0YH@FgIBzkxOAM}zX?w@+@Lqbz|p z&mCh@_PXY(1jV)uhcU)*83uh60w`^dMet9{d?4EqW#s|Lq2Mvg+lauK(6ev0HwuOo z;~0ofs!C!&NdrOZy5{yB%O*4@wrHscR73~Drf@9`sb)e>7z7>&1Sv(zA5WjJM{JQ!<9GW7slU%z6!=4&i|a3jL5Lk2vwH9?yCpyc+@gMS zrRw-+yi3hEav_exLDLk!To@P}Oy8%wyTlcDC?=S|S&3vSGGa#Ro>e!MoD2&&=;bBx zM)X?hvc6zggN8_zZ*3xf_;kmf3ZMs%6PBj+f6WfwUwLG_dCIul$Nt3bIL>qq&EXv0 zbU@lI*dSNpr^;ir)91AvgtVWedAlH^&B}MMcW@sH{AwMaUrxO`MxniZ8y9<$82WVj zbkeqB&mCoYRDCXPxho}xU)8GRD2jT%r zRdm;bY_M*6e9?!fKfR;pF*q-D+=&qtX-m1bVRr2$&-q$`eLAQ2=*|N)%MnE5cTrxL+a_dwnsM7l^@cP zajnD9-sor-{C=hqi!HasTB&jAK)v;GwFP&#pURlEctoSJC0sr6!C6>lOJ5u`Y{KA{ zkxK3xw_Poc2A3K!QkL7;b1L=ZqJ4LIl_NICLK@c22ti}avX_Y})OD^Kus60Vgf*0AfMCkVB*wp-rvofFTl)08&yL2SuC-1NEwgEz#4)B+6SoYm9@?fBqpRo|wp6AQ`onz}UbXbkv)fRFoa4Z3!t$}28s+Zh5Xoz2 zQWmVjR^iFv%h>xr{W6|tNb2o3~h)Wmam~l5dX3Hp@4gsT78y)7_8L(iiMf zET3icAG|jp_xU4NNq97B=HNS4|Fy$kjs#fs4df<1va_=toBr+K*%dP7sYyOQtlKsn zu3zwEhvZzPt0+2S|0(Y!nQN_4YT@&@GMz0y{)Cuj{YZfb%O(kd^2Rre^g^Zo)yo;T zqr9DkU8;E)n7wGR*kK$;{9k>q($6N~JKIPmQ`W4{9dU(R9v;!02y%m;^ z5ICGF=^pLs>pUFvKy_w7x|Q!%PzS^a!wChu{dc@LOFgmEb(b<)3rVn#u5HynwY{=& zZTa|)$>!tm_P&Sd|Ax98tQP!&j(wV^toPrtg!^w6I0s}W&cq>OVP9kg?60)?D@xwm z#&65))!#N~lp{dK{X#Bq`m&n;M9jyI$&Pvv@rJ>s)uN`~v(x`nztEJreHAPCg_-OJ z@BB}*@&%J9>6qRhum-olUpl&vu3U*Mh;vQpKdH-9kKLrnpLuvf@Y$~4##w5&bu9*U zyaH!_`gGPilVe9S=J!3mo7DulSu$lrOeFU)5!(s$B_C4O>fXmPpRzSHsf8mq8`B-% zk)sT8wkZ}TEL&7v*aMUb<(M3F+bfrFy-@GmA6$tw;U}`ZrY>N6w1P-U&W;C zgO4a^u?h zeK+ZL5li`gv;~0`mW@ESe4SZ0=79-;_*ZID6Xd2!_KK5W0N{C_fpPPq!(>|-WI-~& z88(W`FY;>Q_e`Ef8Ig0~4n>$SP;!cU%Q7RoAK>S2GLPRcwWLrB?2jgM50eB+8*@b%ov3ESW)m+b!alp!E3arb#aw^?~CP@pHlxp{3w*Q zbxjB_&``h*WXwz4Wcv<%d>hN_XMoUadpM}MgH|D?B$|-38eYUIT>^a_Pw+`PvSg@F zFCvEo`WNdLN30zJjOVp-d!QBOAZ%WBfBozl9&bW8^K<+7)kZ&8-@d_~9X$#c{!DuQ zxznRz3=0H!E$S7RVFIuT`*eiVFam4^8N2%#hLSYd0Lu{YOlaRT)nnmad9|Qv#%izK zgvB<<1o|Vv{KUAhOds8UP1$yljb^-pc5|T{rZn^qkJ>i9CCwmZgR%UO)>bw`IuzSr zZmtem8sVng$*v@xNf$(QLER4KzC((1tfGbkz$M(76>F^m(`zW$?Op?m0DQ6-Oz5OpGLqo+)p@1 zTb-7%dv%_uw?eUcK!kC_-m7eZ)2^hhG-+H}6j(6I+ zcEaqVAA|TC^h{qg`X}7|QbRBagUqqjEBKxrpYdWLdu4AGB7zc2+zhQK0XZe(D5i|m z^+$d38Kd_d5wE_8!j5`~45erbYzBG!bo8P;p&j_m%aVjzU= zuVG*v73-w%kcZI@6{2-*6CQY2wc-Y&0P^}7z-opQfl^N-1n)os1alZ9s0%pGs;k|A zfKMfWT_!JG7kZT`Sc&P3X;^nVaYZd&PJatd-#|pRg(MdwzdVnTGulZ}E^etVSeXj05$`4aSk8aft zAI_*(^3!%m!9N8NLEhqzRr+Hy4&;=-$z7#1Ud*D%8ADi0pgJ@6QKDvd<)UCeq}hOMk1LqRX$i?V)dXSWNJ zjhSRl!4^l0DZ>v2XuwEI^vSIL<;q5{(S?Piai~KH2CiNo=z+69{aSAf7kU#teO*XC(k*c$;6#=7gU9I!kF00&RG!I*yxt$!*ceY?0Ii6+}t z?HvQGZF{YY=5u@8}pT&h{?(5_5SS z`$p#8>nL%9x~JqzeFyt$!E8z<+Yv6hxF9SoNcComW?YYhN{A5Ml+V~E2OLWAAcsHK zmhg>AjHG&mSQMhY^j5(Bfjg(zYQn|wz~-Wzk8b#%JDzR!#U6}ca%l0B_r%#V{4;re z!NZptCotkVN!t4$D2%fTXH=Fk$8PXh0k}6fds6zgfCyp;AR&HnbO?#K_m7VsZX_9a z)~ax6Yz8R7T=&)>LD5|gPlq<6a{PcokPu$>jgCyNA?PlM7{^Skh1Wdy9`G&4c7{w0Gqjq{=!^ve~XV%5cYlE z&sf(h?noZsP7+*;FzrJl%D30zq{Gxlttr~f;fx8MGm;MkHyWzv>Sa^Uh;P(T^*6gEi5~xx3 zW4GtPl^4jj&2b_EJjS+bp5`is|b=2?L^ zNlHunJYx7WDSbp6WRnn(ynwc6UFXjGKij&Ke_yJ+`6b$KUW=|R|B6VU_t5Nf%hI|= zu;6aKh+Drl&m+JlNVz)4&K?iRi9qRfq8;Wpd#Pj^bhDK2EfK2S?p?Su8VN)sxOLa~ zwT8R%Xs#3841?w&qv6+$gr+&5I)S4zY?l@MY01HFk>_z4R-$EY(ceTa&2Fhc%?vXf z0%jl0w6zd&aB!@Pb*}zB{>*8A>AvF|l)UmHBg+oLGzQ=nHQMt!yOB8M+#iI&SoM1y%7Ht{3tT9h%VUZMDILp^@#mC^gEd_I~&=P!pV_3?}qN!t$!Sx?`I=uy+?%zr`jh%&kbR!zw>nDEm)R=6V>QqcNKF-g;FI zXY}Qn{XI;{z&0M1up;D%MpN^}TP30KH8n!s;!@!l+!M}El+OOs9Ecr2wYg%xc-vO> zV$86R$C%I}7{kA!Hn5%DGU^U~b za@pmEQGh=WQSrdqANj zFaTR>l@BOGODf%Wtl4sz^FbMMb(1W!u`C_!N&*CE&Yr%pXo;?lvASV(j>n*#AA zZ@$=%x{g~q=OR(3wfB{rSPKJzl>zvdi_YONz!CO0`77K0OE-_933%v`nPGVxC)r8X&Qk|(v;4dmAKwTtw8%9!tEi*#R*LQ zNe9(s7Q>+}%Yjs1-*7H!@{X4#f)Lse0O^!jti+Szaf*arkZ zOQpO~1?rQX1lqjjK?s;zt??&c9JfO?$ofsLEETQ->(sJ;(aCwela%N+XENNAAifjL zF<=8-byE$|F&b_^WEbATH*1B#P=;9CVTM8h1L-%5q_xL61x%9}Jz)DD#9-t2Q!q}w z9-M7vEKzAHwy=HH!bV}ZKu?-32armW0yC~@K6+e&)s**pZ8%|C3&@|a00X*x&Z~RyJYiam0n2>k!%}j;tQWJf`g5-tN7IK=yX7>3#eSd$s^#{H7+VgN79@qVGUp1Vu8U?nd_4z{}l?(w2@I33S zLa-7uaXoK1;L3`^6b|7xMUb0A*<9D7H0633|EHna0gQh_ZfNCT3cOcbM zVqamihhI9(6?z|~I_ihACa67Cexm(WX>olhp45P;5IB_nuJxh2?8gV7S3J5XpD)LH zlXomaAYAUk{Hnx_vw8K`0v0s>J3M5jRDlZij&?0x^E+(#$OE7eP zV27|)-n__E_#qcHlS9G>XbEtR6?fdK58m4^anLa(1`grl$HLoaGelAnBS10RQ^sqp zmNBaK@b*N5so8H#?eDZFwq7K}1dBT;<>r?6_Pmt(53+kJsVU-*tgx{7iz8HRtGpgN zHq|+0*)s-V&l&{ZOc6~+qgmxjy)yKMLN?w`&oz21wKg)ZMTvx|9e0$q7kMR%yC^B6 zC|HTqwrjE;&%W@}v;$oh7{EGtuTV46heGVv2T(QOR^^hswBJa=z{f$n+a=((q}SX` z(vJ%{dP(O#RA^jcjkm+l`oUb+$pD?(TV!C$`C7s?r~g52rio@cC`q|0s0V0}G&`G~ z-}CV56;!8&%faz!2=|Yk3S*L2S!v6mdg&|k0Iw@*gn;XOR&E`T`b1#UXu2gBpPQAU8s1cwoRSv zhiEw2{N&0uTa{;5Qb?Mx%|6JhS@$w3>aAph)npBKEU;l^GJ*)_J1sRk#fB-FhN^#v1guTE zMuyfkotCvH@Zn@?*@UwOS)e<*KG_<=g9NkZ-ntVO990x^ROIIqib-Hzi9|FL!2;%gZSwvj&$y^^9|1wxQB($|mNt%%V48)$Yo`(9*W3blR&`cFdKLUFwl8C0=`m{lp9xv!DN zexoci^C#L_DoIvOe-0nJzJyA^$QDFF z+1@~TZ5h~{WD325OaWm;y<;(5@^i(?eXOi25s0~6;Kp$P0HV86`k(}EfwBJntkaNa ze(hS@k-G!tNEJ0x%+`~>y*p#K?{q&58MUC~jwAQ1N<`%F&mFX$wCM*6*B-sL2c3$?lW|DXX_+(6^nz#lFF(^S*yz|3Nd9Ynr5} zA$8~uMW_fwX7wg*c5tTxF7X=K4`;vQ&)H_9TEzhueZSkm41EWcR|oGtC@_Tcqr^tx zaJAP37w#=U3TR<<$Wh469V`EGj~YWNyEc2dnK;}9GWB(52>merm-6kPF2 z;p`*gsJV+gEe zUo`K>YAqn+`%fVz@`tATIpO?GVBV8 z!7C`fbM6b}p$wmlOEzS4d9MfhH{CRycGMsGQg5LbuW1PD(rk{66$JlI9`2Ana8Szh zIvp6oH}I7*@shzMo`n@pRC+z{JU>X}_=8;1run?}+~$-I$zO_2^Ck?z`Nd)N+%HDA z@6>_!HzVhC6rtVT9MI=io4%FqbmLuJZ_wT?y&wj<#*EhDUKo}G@_F4dTicKMrdx{> z|FzfD(jD_HU=U6PcOdtN{QiBrzi@H##gy|`E-zd?*;mUCO-Us$MG2PPJars2|EAtn zJwIb#9rP!#IAA+Rt?5@61pT}2aIk2zvt0eAXgl;QFb)s;dZDH^{N2_dr1zaKzGC`I z?UPZq;J|wRws2^cH|%^~@8uhrdo?yrn|iLhNk`?Xz1gJIDeY-Q*Saj8a1*&_xZ}xS zo0Z1dCZlG)Q$PR$BA6ejJ*P_9TUq-|+i*~rCs|VSIM#C9R4Ox|nWIm1DKqh#L#bK& zZ+<7GUK12T{{ab_1k-yi=ioj^@yOa|@N?3o)^DoNz>k0c5#ZLft!s^Cs?p;S1l!J@ z%JT|3V>lqBM+KR|CWhpMs;!X{+?&wJ%jF`70 z2*+rCXT>P)Wjaa*~j*Il_|pYA{12r{vX)~?D(&m#|#aHpb)+^bpxzN2MN`gZEP~3FI`fT%RnTzjRe9{aU{Hjy*iOfXd^Tz#5hSvbYUSz)M*O9M z53wvP)pFpa!2L7{4A zo9d19PD6z^q^(m+D>LhAf}vTvrZ5_RcA!8B@je{PM;7BcL?%LUgY?h3zIg5Lc^7(C zx7Soe6>K{o#2K8^m9>V^SP!rIHZl;jp(ehc_x;zQJ`IO-SGC1Zoe=*d=z1}U0Pg*>@zsXK$CS%;IXPX0 zsf!BN^^VXUR{ox5ViyKwTLd8gN%e!{=tgwR>SzQ$!sV91%bUj|Q;P5Om7&Icc%{CV zTw<4X*$P=(g=qSgi0@kEZz>jQi{IuU9{DTj-E3~_g5~28%(8{N{;965ND_bPq*n*9 zf~m0ujNJqL`EDE^C8}90{T0-;yd@x4tQRfB3BedeoW2*$4zmvgx2_`R17*S!Awh%OGGDf@)ZUFZ~-olwHnaBj*M7?}XZ- z@Fi@z#+9`LI~%YFLtQ8sp!%E1p=k9^t%AhLDK=)qu=<@2Mp$>F~mD z$HMrBd+eGe$!gZ4nee7Dr}1|$PIk7It8193xS@;|dYiE16PYuEcZs|ON7x^xaEWoT z>wDyt{1M}$pR0x{vOZWp7`hw#K=v7tguv`Lq`Q7oTXwYk(by;D1$`C8t@N`>zVqLg z*~(~zkFU4BbO{LDL~^+f>(E2Gc$8hZdHk0ZZfwx%k)E-^je|-1)@FdOhJ71IkzR-J+9;vEYG;(LNJj8|P(uzoC0BjAkX^2nRBAGFxu7|+p2Y6`k>)4LWR>4f ziLD9FjukQeCk9d>|AXw(0lhj7Xntl!)+rX~kAnHQd^1^L!7%aJbqND|5=>1~*X!h| zBc}?O`GI0B*yrpesh2JanW3uP(I-Z2e#+Gy%v5FP>!}D;EudvY8O@8Y`-!7Aa71GYy0RBk*sb=w(4ejbI1&w|owJyo>M6N$Kh~6GGEvdh4d2!!4nsXvsjzs}cnj%CNz?%X z!mYVOMw_RV<;|IMYnjxJtn&CpO?P9Cjy^|*AB9oXYVjN<8|t#ZioD33vaMq#vr!ai(R*s!wU1_J~apqn!YtLN}vD z-p0aUU5iyCwXf~O9kBqa#t<7a&cSw;&kW>4Ieo=i^-xN~JEnhhmKrLpP^Dxgs1gFk z-pyeK8NZXs|K?Lk`=AC4(*GcN5bhIAxeJL(k^quC8Wl}_Y~H@Oi}V~B^f(8QNs2W; z#gcS|Idweli@T4Lju45`qHB7ZTf5L0ErzegvFlbXcZ%&OFf>$WCKEm+lKPs{sqDL; zO<7&xaLFZFVLM@p0Xj%PGPHDTdfY0}oRW;D>qZ-AwT~b9eQrdh2Kqar zq?s=RI<#t5aD}$15tPI*$y4)Yl}RTAS!UgAeR?wt$4(H#)9mAH3qTI-KOOe%O^0Hg z;iIQ|2i;|>CCkx}wfW2PoO}Kyw@Z&5Le(co?>Vjq3rpV*xgzEDBswOv?5x6`o;!XT z*>5W!TJ{Y-a})nmqA;Aj+i*xq8#*=Vd&qs8pTCtxq4KRu0#H~B@4R{X0ccx&h)E?= zcBMRV$*fbFB0A3~S(G=r4SikqA|_ZI8BB}b<%1Nb zu@=1;_i!fHc_z41T_rC`554(j;gh0{dMDFen>^#w`R|DHNh4>xrVmop_1k&j-l6vo z*VaCE-SNvVGx;C#Xl2|-ghdMMO_5D0rUuTVVHlXami< zX(u*IFU}TBB-aSn)k{xVwtaL;#XovF`qYaU1|m=%MYzNSID17d)eg2GRR^qEW@f=u zXi@EVhyHCdGvscEFi_eDz84t45~@KuMuc$L!)Nnlzv$SP-GaFkZ6~>e;Hq%csd7_S8eX;SetM3Pb9S zau`^f$69*^Lw*C*0ft-@ck&&MkneOqxa6#&yQOhVN%ug?r%gc37 z(q$tH|Z?XsIM)P{)Bb92Un>8FMQPDIe@9kT+^JB^rG`tQUx- z@`VK|aEUoM_7m7%Uo39d4c%pOR&kRCX+7as5D0CwGM!~Qy|~~$U~-K>h+`|NSrR#Y z2&QA(g}M%6tZLkhC_GmQ8cPPVIjWL&;p2p3pnjZaN$@m?@e!WWo~Gx7)tzIBB|PONl$?n zknU*W5uE_VCG`)60l9433J{L%&y@$-`##X1!2sPTItmTGUr$_5GHL59({{yhdG<3F zimBkSWx=qyUq-?0pITzQ)i;_UUM%V&@3R{CMww0gnXh_K88#mt&jmU7pHohB;>PF2 z+>mHW1Z@@8V3i)y2Smsv>$grTg*)CzR~r7f$gs_GOFDwAX!clSj4>yicO_BS+}={P zKkI)9&nDcX-0zUR;MrAw%|EIdofW&(=T)s66)vi5yQBZnYRnl>>wyUq!LkS{&JPDE z*oI?Q6sLdRGt#B9i5W(f=l7gkc)^0xN|Cy2-0#7wqUon>m@-VEi9_;zEi07_TL4@j z_{V&!CnZlgeQ;fl;3`?iaCijDLs8wsOCKx_d4-oHqp6=#m~o0cLS&}0~D>F z)3wR1HQZG@vk4LO7YXZ*?a~6r#U4xp7)r<|f>t{*Drk09eR>8YdD`tf|v^TMB<`(ZcQV3~mi>6fNkOn(^lmP7SHYoeGh@kd+I z(C3fH61#puM(PJSV1H2CEHS15aF#FMI^_p<3e)!%qfk4i2GT2b^%ZR*A|<16%}BOv z3+QoB+}TZM?7cn5XNC-BO-ND*e;ZY@+^6g|-N?GXx`H*%LJ3kl;CO3w^zB7@5b&8h z;Yq}{*FWxL`~nR$an*%AU&pWW)`rE=STKH1D^zOgj*jxZptO_S9oGlCn3y7sjLqa{ zP^uRRQ&-UU&7d`wQ&wgRKnHm$%XD452H_brPn(A1ZT69cCL5%Adq!!oXu$eMCVSgH z`K`ceJYN^+l3uk4UYunBbastR78g%2$`r89RKz1CBO*33qj)qnf;9oOXpRIVXM%~& z7UK>!A>q$CTtl}E09A{ojxokQU$l8uCl`3!1~$dy5}oZn?V`kIh6tjmJ;jVZ$xyI` z@s$s5cayBkzChS$rpz=3qt>h->Ia5)Co|tkDd~$b{YznW?7SPME%%LNx-d;lsT2O& z+_Iv~P|r}Dq-W5qVR5q>2vEbQB@h&JgmvKcW*n1?st}0rgLuVV1*xQZ0vNse#o$k? zomGMe$XtHZH~W~tt!ygjB#P2T(ZD-Lz5-l5#r?gz87T4uDIS~)4rFIOLBOdp)SU;G ze!rH1Ow+sp$KZkLdv9^qy>>mx_!;2WW78E5tS#(BC{fuWkLDu;#T6iK&oOU*V9N*d zM$u9V8Ox%0E-#P41?@UsHV@Eb{HN?Lo&gPb>c=#AxF{`yhlFDRZW;|g>mLQTg3C8q zrpl9jZ^)BZCG8L#)FXz;R_|zrdco`-DiN^=kP&qo&n0?g(Ux~^7g7X>bqkZKA1M7g!y?>3 z-W9qn(63+`3h#xXIN&x=D`#77J zfy1cCsXoG?F0x@OP)RZgoeQ*k?P3JM54^f+)@e5Maoy|)_d-|k)vD{|IjVYRWt%MB zwVK&NP}RB=Vb;uq0-G)Y-q}Jayh{#7$)R#>_7JP3%`N3#B?2fTkWxB-#n=u=SFGsB zGJ%Pwv>(&aCj4Eee$}f4Es$TmEj3(Zd&chhqc+=N zP7SamK{}ckjHK#I&Xdr~!Y0ccOuM9wRu?XIsUW98Yl&a09}Po2=aoGD&qh}%oy}Dv zKcBp%eIQ>>?yW8YAPWTN59a!OkBEY?xHeCxBK|RvUP4jT**xwlkRB+PFPDDN_|NVK z#q?SRtDt0G`R_h zr&bOr>-;@62ZyvkX;r7yaFt?|4anY4&iuE{=CK6{gydT;~!-P_2Fg`0C$eC|J+d$w(HdVXDw0`!Dw(H zpQFQ&4;QS#(M1Qw6DpXiUcDd*`(Z_4)Sya1X_AtTxE;I1hUUp~O7VDbkVHhO?9%ju z>*5h}C~MGI2ByHeA`ekf(YDPSR55@r3ftL~*tFs+TN!*5O05?~gy!zx@+I*ouAM(W z23SUcze??SS<3_a0xZMan_sNIf>Rc=0b)z2qes;WfTd@Vc;s?39XBIf%7GYrwQY)=jY)LG+1_=Jb)pua32imG4ZoEulsA2MBwlCm{+n zC`L`r;&NI#@9e)12vHN^B78SyCWexG#ZVYN-PSxm)c%llZ6x*T*@SfVGwJ|nG!uG ze-9IffkEN*QwqMpYa_q0j0Neg@Mz=cA4-18cisid{vLtg1;HiX(dlBhBU=|hk0U4= z>3uZt;h(+R#Mf8p6X%Wh`P*rczu2FiZQeg;H6C(T;+Gv~HkfX3`Hk?aUKw8?AY}fC z2JHNVCLWM3VAIcKB2!qIQQDWqy_mLh8(!3Qc_OMcE?yLspdBMlNEA5Cq5W}uF+&7T zAqycZPf$Cq)y9_Jq8v@=(*2eRWhxRV1g4Z^n8$gnt>1U5%~s^H49E?#Y+$lV*=(x6 zkr{!(M~38T;c>IQ!X!jllQrR3M{?*OLxuN)$8my*Wc&Bt|oj0_Xq+-HSymHcU?v1Ul4hI>9bg)o!Qt__xcSsj!VK)0aWIk zjQnvlATt^(yN9#q*xiobSN=aDOK}}R@YCYWI>7ruwj#J*aHhUiVaR6^a}LJkf%3ex zLImh#EO}MQB`TBF4XDqMEHU9JBcvvS=7z^LOHtgs7m^~9?=CH!7;dG4O!GHIu9|>i zaL*?1$(J@35E3kP*<^yvNS=!%dIN1oZSBcDj}{PYMGY4ZeClWOqs^vlm=iof1l|dt zk1&|VENz<=#%+-dPne(uZwJN&(G(F+xUk{7df@;QjDt6@ZmsIz(KXx7Kpc3fnX&!xUc;5=8#rz`MPr*Iq1zhVG|}6 zU8lWEoxB1`1W8Y4zfI|WACBpCX$xJ^ziH<$NMF9<7)ws$@sufz@p)RVCilM-i352) zuX!}U3{@h2sNE@~h4XJd(+4uAx2|d(FPtPRY|12ropD^VS0{u-h4s zncG1#(^^~ynnt6mT%v}|W@n{%k|^DH4`lZT1$bx?ai{i@Fu~N0BNvO-889YMgmb34 zP9Hd5TI`xM+@83iXq&|blRP~%*=ka!#B`KN_i$e~ow3foKRPaK4$#!%{#E;QKl;fUu^~llClUt6P zna23p>0IWJ#I@oXFjCq(_1#XXT@#a=IP>!0(2dOF+}O5&9-NBP4FPS%cj*#NNKs zc0M6d7-99_zqZ|~%=MsIE>F5RT3a=MR+nmFcgzujl^MLOo-%Wgy+ivQKg{a`ib-W#%;Wr zyYcoY;-6VkN%<^UM$fxT44U8`#Oiq|wL>m_U{*%9-`{67vQbE?%2HexdZB)?scxWV zHg&#a)F7(aq-Xnn3T|chJMaHNE-T=OHLO{(r`q^~c$Q%L+@^mSeqG`&WDiX*sUwHA zbO;$42sg>=2X0>ZXq{K_xDP@h{FEdBurKlT=&7)+2-pD1GVPS}2hd_}z$VH7E@{$> zxvTVUFPR9kk?Rc)hcS!R04 z+cquGg5to`=>H(qk60&K8Hz#iz5c%5FH*GC#S{##(qOMz74G@S2VFEleDsk3jtdh8 zi9-DOtB*@fb~Ii}#?JsPE5rB0OQ+eR6?+|8dX-Bd17HbH z2IWm9_3Z8L3VV0RDB1GK@u>GPx;VzFlf$UG_HNA&!Xnet$K;#xT#dLSWM%+nA1WK9 zu}S7D_aU+A*O)tEQ@GvhzJeRq&rB=zA1q0D+_|SSAQ2NjMcEQG|FPwpe6&Z}W`<#V zW-`J}?EIhOLn?4%#;MC*n>X9pA|Wv6=KM2a=~8$`Ed4H#q|2Ery{p&vH*Vt0-%UlM zUZLnoT{5HOOw-g(IJI7(=@Xb(sIqF7utkN*3PdNx)Sjr<(WT9Yj)z~DL9!QrXQVjF zy?ShRei0(XIivhMzCt16`;l{?7%}cd8r|{$Yx0r&zMee4YlL(&B^`8VlXBxe_uQ8SNj^6_^1=4Kj^)SX z;lDn=)gr0Jc#k5Q%kB2%OMn+EEc7U!E_NpcxMdwF$HPf;vfJ=v%g9zGi3ta==| z&-mu4Ezb@@tLCIgU|971P5=&}?M_ekzVnJ;;|kX!EET%dLq8-NTpPusmg~m516mqA zl2a=0Fb(37p?~rx^70q~l5TT6Ue zVw~qub{DGEVsNSLN=+5g*Y)1g@S64-?9O{~q3j)%V%(&jqwaqk&XqcvwTBv?4p!5J zKo4UTs+i_hCtAKk+qsL8zgpwOb1OOJhhiuH1EZ*)0&2EI8GhRc5 zdl64a$7P*jTw}~(0rIy7B43vl1TDm5uFs}JI8Qmflqz;=ThB=UohNR0_r44p)s%CU zyyNEOKg=Cy_%?PdOlen3m>>jYblHAIBk0mVU~bHQMZjzaBRpF$SC5#240oe8eDfgo zFa-3q+=AaE4~%N#Qn}qeph~}lb30y|!rR%RbAq^i@CQKO+V=TvmP zQb6_A#vrcrEd1Xvi~!UQ_D43K#+KFaXD$o>F6;Yy^Y5mdS=l@f>S18Y*ue{`&!$xX z?uj$?XiOW24@|Gu{d_T*-XXxgoji8&Fj2=;ZBc|r^n$3tJ7HwPs0+JMwEuSIqM;VK z87GqNzj;clXdBZV2yq4*)nD#<;N)!DY2R`QdXrrMtlT19KK=akJ+)5oQ%=k@Q|dtFS;X|93w>N>l>B{( zQ>DD@oQ*VvFq8)6HL+qBO=4q#ghLDnk#a*BHU#GC&+WTha&&)5#Q)mRUUPqNv zea%b2U6Nep`}xJd@7-jD9KB^9r3LOf7+8Yo@5GG&!F|;oUqRrj)0(mID`}Eq3_I9_D=eOZ0RFw; z+l-c8a`i1QfrnF}k8@mhxb)lRe{LJ!jEjLO{5YUFgq3*JbhC{K@iAzfdQq{N`eE~E zCLytV(b?hYvoqhyiXNT#Bq6h3pAA#^SY~>KICCW#)8I-H{TjwO&AC8zPAr`R#ZxdM zdXjzavMd8_y-C?)uL#F5nphw?yKEpkaEd_#j(VbW z!pK~YAM&L;%j8%+rsm1jS`1r`<5?Y)Dt89FvIEbL7FQrgkArqG zN2-Oc4IX=;l>SPETQOnkd_@lEnygTK&G zl86ShX#}mO)=e1}@`|g4V7IiX@Cd)|=7`IxQR& zXX$XtO!mty-*=0HRfl~XV$bOM&*_IkROH*NvtO;uR*`;PU@Rpc2BPnCIV=)efMXaX z_0_-AI-T)o!ABp&M*7b3i8R6-2$FiMB>vjlC^KylDppU-3*%!V$Q)AtioWAA(K8yA z3}wwNzfrIWpVZrksDfz^7B`B+>$(y&`<;abp96C+?*+J(Mk;4hiq|M890{CDs2)J8 zw@BOE%;0a3v=zFm%*|8L%7c8cxLvGoc&W7NIOuSRUJL7LMTH{?v#W>&@muC9t~IDM zxDA?t8XKWitH*sH+wMSxyt(atk&6$me!6hZ2Ws9?clh9RPIp8o%_4_;yF#_RTIadZ z7sL4xTGi#Z>l5h}_Az!y9Q`gB7VIg`Ah+3Q%3+^S=QdS@T#ND!F+*7OgDHV5$#*$7 z#===MiR%>}9(m^PO`q!b968z|hFeP)tuB}BAPW^EmS;r-i6`j3gO5l>@zfPjV$Zvf zL$nXUQSQi+g=4kj`_6tVJ#?*>HIorV+4bpG%k`_So&kL_U+qDiP2pAEz~BetZ?B#F zj}M%H+YHGM1*+#hw9UA5quD%)DXiq4+4lYi3_TFP00E*$beVH|UXB6&#Fb;Ac4i5G z@$%JKK?Lu&Zq`q2${(IrEa+)8aHL2*?ni>r=r@Oht)j&p&dt_sRjmqDwJz<^84sE1 zX+XGq`||eWm?GxK%(Mya=zo8#f`1VbLQ8Qe#NS23t9Q2)*T3FX8PNZL)O+2PQ=1}V z&6EYvKLs zA0N~F-F8Pv_SzPO`{`}XeWAMj%!}M=-&jj(IuuGw4hXD*$L9Rq7r508S#r=R9o+){nI?Z1N!E!V{wt=$4^m3k^QZZBOU(%+q{NKX88nv_7A zowc#;WDUIW4Hca@XEn1h_}L#b%nK}f_BaQW3mdvmnA{Fn{DWe1FPb>cV>1*#RIxbE zwyef8lV?W~);qSoAC*LMO1Fd>=TfE@4&8ete^h`xT<8;&|5fI_TIAQyVRE_6rrT5B zTSK&a^Ur$i`|#xCjaOlTrw`;p&8_knNRs(5ULWJX4 zG`YK@*E6K;-F5Cn@~@^%A9)6U{2w_Z^7B?so=XU4w|HkR#Ec3*P4#)saKwIcck?xJ|~@+iq9-0{FqI z?RcQ7_txi;>FP3UB^{H>;~b@Y-+fQ!B`OvT)k;qjLK?ZE%X&XUD|`b9J>VerKmPfN zvDl$aZ_EBM9O@f+>Z@K9U5BB^x;oBR*2mOS?-?5D@NL=#4@SdIn#}B8I71RAFw2Yv z(wGNC^WKq^QNa?@vq#lp;HL*JxH>~Alysw$QL|!vii{0DwapZX7dC$Xd}?9vU2}r@ zxvrk^8ba;9fVB^7rMaS}n^|W25X@J=t=gPrHL-9ZW(mfcLv;ZM<_Qm6s898!kQd*K zKQ0`JFw4wy&EB7})AWZ9B+g>FuypTF@d%5y+SK-r6Kac!R|9GZ&nCm0ixeU`+y1mU zg=&Nfo2Dt5-?2AR{X4!i9h=MCaM^`vPe0oI()IZPJ$dGl13@*VutNd5!3D3MNIlG; zUw)hT$9t`?UMc@>8&o0Vv+_XxSY*HKI$2+Glt782#h#R_cCNnQtzmkKwsy&gJp#q3 zs9Ii5*(7IwM@hH(kJ(^(j8r;5P>Fy?n|G>pZ zFNe!BrrQXJ{E5b4Cvy8abK|iSX zZs}-0iI_}wHWCoA5{HLL8FW~;AT$?tL#9o(3q+brf6^0YJg%+m7G@a#XKb}!uU1y! zaXUL@uhzwiFm zfm3l>N20xBG%r|XRF@7dPM^gj%6eGI#+dJQO7g7rCYFbZ@nw}JIFvdrT}6}r_Rhfq z>)mn&o}-yFTVgOUzXo;d3++f-#l>+2*WmLBCR<#f#P+)FlDlHtl%%~}dS04-zxdOk z7gbC8eXgRdZV{$l2d=~jNT%d+f$b%EHER9WJCe%7AD{h7$$AwX#0(UJz8aNuq->L# z)+il|*?*zymlh=kUXKTE_vei(l{-mJH!tm~{y8;L+rHTc-Hdeh*6Y<;|ENuVhB~$q ztAk|E&p2PvxLjC8VT{2+tvl7T@jobu(Fq`%WVz50etf1Fg`il-pAT%I}d(r{w% zt2|y&McS;vB=oPp%;lR3_ZbNv_8cAlT`4Ap_gmkjq!|jQXbrJa4|%-V~yQS zj@Lh_^z4SuFMRojy3Omh&wtgFULLDWRbO}`4TaVOP(vM39Rf2{zpx%6ZKA7}UhJz$qM-iHxT$`bN zcsyc}SHjZyuRQDBDuKG#6WhBm1wu}#3}6Fc>4rx{di8g&4 zSC?m;_bSV6mEgIyG*4^AU^8+V*7E?p2^iK%T0)8LzjUaJLe$|Ee9!+@0muhZo6|z|iCEruNjM5i$L!e-QWs>m~Xk-ne z+hKo$qJU4o8FF;!XP-H36tXcXn5be^deKr`#vz7+>`%w3hRK)UMwzGXvz*4D9Z5!CSMKnqm!(kW}{sdOZ6lYJk}i@K-{0_E!wD z=Gf#CZJIpDCzyPx)-J7f1`7#K`;7ZU3LOv7A_XmBbn%YSZV2~UC~Z^~JD^VqLx{>5 zV^(np7?zAA0EN0F(mNFN#;#_S1A-0K_G1jLmo`NtVDl`fS6XI(!AP{4)%krAjnqUi ztHI?J8n!D<3FkrT5yKOLz6*)Ub%Zi$9)GaRp45{`s6i|kJO`gRI6r-yMw17imEh5E zE(>JSONBZN8h9BJ<~ZUc=q-(bB#m12H0PMa9P^TeppG2+0y-5|{i_Gfu&DVv%0 z>K*ZzJhrS?`h57lO}2iCBV?M<#oKy#xNZah4Hv!59|JS;p!JjQb4&J8Kqm`|RH&6z z;?39#vtI`=NCq^n?VWzbZqt3kopr0R4=j{h(l$Pu+HSWEx=Og zn3CcW9gvrLQ_ufWZ28cLa3tvh*TsbM&0XTU^MGB(;QxO8b?*yLU6PPYyTSmb?Y2ll zIBu2AXStNg1Gd%0fNAs$Z~g3v>-1z?JV}oS#P%}Ge0(r)auFusgyG1LF1?80JookW zM4&3lO28Siw=YnlU^PaLudueZewf-(i3jj3-PlzY9fM|+-3Ak5Pqc5Rl!vp)omILz zxe52_qoF$bD7R42g&cXr*hs?}v&Ak0cPyNdxBDzBrD^k{Be&FcWQ(#0M#7>Vc8x!c z&qG~ot*CQ#>3As?)B?PsW_t4p5+n4_l8o(t@gYmV^t1Q^*YSI@mwZzj$`));b4{!y zxFlwrqgnnFv%5hDGzGLJUljMgO8oboxIS{51U9YydEe8zmv1z)cGQ$z0pKD+N186j zFRICnKrOk-?=iQ0hYV%_-ig|mBimqrt5O<)V+owsluka1+C|F*18|vy6bE>1fzr4b zNbrBIyxGpgXp79aZYN9(#jcc+tTjmIw$x>N>ZSDlH# z(+b!UougwBV5#;N*M0q=e%sJY2gUliQM{n>KUj44u;&M9;Vj$NoFPCqK2P;vnf=@qCR+*aO)~LI&DT$JJG5&Y!Pk{vNDq;-OQ)vpe?jN9F zL7^P^PMd|a8w^>XxoaGWDgEsAITck;rO|o;j=o?8N6L%{2G&*Pwu-nx7GUoY9fMLx zcw8pV$s1q*kWpyhN$bbIBp-l}g3Kg63YhtaV=M?0&%3?IOxkc5hNu4{^@X+vU$Uup|kP-kE1IOWcvUA(_|%CDm58Xl#mLgIc9XY61gjK zjg(w-<%p4_#76GI^l{9QJ2z3Xp+ZLP&}fz;cQ&){@8$PTf5htj-s}B-y`Im<^KsC2 z?mtI1+!#N%u+Cgr&~A%e*$JP)cI3${A;6fuoGTa3tD9q+L0PO#My=tic`SHOvVzS* zF&aX_z_=x}jy1|!+m@pc;eGM6Cn`_$*o>9@zpPD^Ik!kNOUY7lWzXoLj^}SJN*Ub- zQj@}Ut+S^+KdmVq=>VqvU9Y<#V>Bpw4av^J$oXWqpJ>mz-MdIPG+wa7` zjK0jNG~K0FXHXr0JUs1?iet6@(GdLPpJeqcAu?pv-*fA5W4vgP%=UK@z7-r!rCtkB zV*w9Oqy*lkiffd26$zkc4VeAbX9sI5VS3H+FO*C3&nV1zTf2oLa21Gxy^e?4kk7*x zx<8ed9*&HA3vzf&v=!v6LPgwO+f>y(COPn7&-Bf5_K^}?2u+n;P` zJ`Il(uN@aGIpplQC~O%}=FX_CcCc-#)bG146!Vqu_%M7QaEOM!{Z%Ynw3RC>{s8P3?;+qa4@kfy_#4_wDi_h`h%g-tN2GER26IT;HvZ1Ib7|=Mcl? zSy%ievvRlPvTz3j#x#7g%QPQNru}~{V^oUZ_MPIJdC^lbQcP6ptLhy%bx=NBq;9-p zd^Xo_j^mUkmR?gH7q4V7)>u&+-^|F~f=m(`R+}}c|5f?4 zwIevlZ3w-8un>6CjgI6VL<*%}!a<&oO){SBeh+w}(rt~@+bpBSdf&+o8HeVtJ|W1V;>dC;Lc$Yre6 zV}hJn9-&KbbR)mXKd(@F(b2^>lb*R|pYR>Iez2T-sMk+Cgt3w<&&=%$+l96N_kd4E z!9#w}qF`25*7)gh-o+MqW%JZ^2bXxwD+|J+xfWh2D(?>jQGX8QRw`D%(mUHBjZ5B3 zQa&lm7dW}B-*+{}s9Cdq4?jcWX!d&HGpif99>e<^9E2QlA9Fa{@)n_!%zy4Tvb4NR z=!ZR-WyV-@K##Qm<}DmTIJeMuEEH30=BY_eoq$oc{!4u_#1P}vaV#{V!_H&#&Mx}S z5>l}}?3+hXHe$*JvdZ@54<=e za7+(ayil5cKE1K98334;|9xT6B-;RQQNaxmV~8ORVQCwpspp{i0X*B#hkLJyUrWXh z;mK_hjrjIUWsoqC5Fh1AlO(@z1pDW&47d)Rg6hiw7$M0h zq>q@nxu^nWM}h)|O55n21Vr>kVLwBH_hAS~wb8(fai?buMRP2Qf)m!k*1`w$r6>Bb zv?7-Q7cM6YYqGknbW=cVj>ZI;tvz}A!bgc=%^lLL$6qBe1 zijQ?O;lLiR)lu%U(Pgkua4@T!;0OOlR#H01o8!7^Zp_gmH+KkP$51UhqVv%;REgw0 zz6BDmmOm`nHX$}49*ZJ)wsggl=YTNF%~Rt@Bt*~1b?N_`H}Mblo5I-Tk&?!&VJ=1w z)KOV*2udfGC(Y`68TE2^Wr#ml>)$595b6NG*%Y?xKfB;ZYurZH?83vlFz5{wg=Mij zPi?EoN3X?1$Gi-=OrxWi9Ki@UP#%KDXT9AN}KGxk(vo!!jbC?OYl< zuVa7Y%FaS;{E8TgC;#%=1=Oe*{)d|3-OfP;$GPughj&5$Jn78_3J3&;NN$0i+@%+~21(SV$65^mIc zh@|Nz0p&lO6E~xQ;39&$fq|E%Y&FYu7V{Lroxx{)j>vZ4{z(>P0K(3g;`H6ON>UPl; z)IXcuKF!$4E953^>7~3epKi*R$(7t19TuJRBS)7BIsVuInXx5F=*WZdf*g4virNkY@Iz8(H)ewS4Ynv&q_n4A@J;iJsRn^pZTCAfY@YLrigfIfM)4b zeOILR>)x8et)~3h6}S}RE%On@Fd{QHs(vI0cANy2&Qi*1vgkVM`W1l2C?y1E^*ys% zx;1K8+g3oKRT>!}IbJEpIT$nlNbVqac($#|AuPF<^>KyDNH{osuAC9CWg7+447SF0 zDAXQ2&+vqRr!^yHw07Ty&2WO@AtB01fagHwNQMmr5mBu}r~1?={BlDD`x2?T?TWOP zzS5DZ+#3k0xR++x)s9K;V2hgB|E_<6(2`FnWzB{PprOrrN5`-6yUuLYGvtVwa@X#( zB{sS|hJ<@-pX-o)OVtRr7+;;x`Vh(e^`EC+sSeL{TmIhGkZd9C&$T^!T>z2qmi71F zlfqi_mUp$cJ6PT5^)|~wy+tWT?yD^FdJhQyGrJ>2QK*CDPG;Q_4kwkU8U$<*kY&FJCb%P&zxi(O`NZu3c|1Q$ zueMEH=M266aS>jd`L&Il6TzWBd3rs`wDy2xhJQ3hUSIF;27Jo9g^e)RXP>RZF8>7` zq0s}GqY8EoH{Ro(sN=`_|Jg6IT*!ZK{0{<_z2L73lQ?l6>Bk_uy`ICmREdG@etR$Y z;|Zmna@C5o?S8w*a&EAY!%J$P#f}4CqItpBN?St}Q8jS8iYxZin$W&npv2;zfeleGX*@eV-I{mj(pR$aBc`h*7Z6yUixqP;ytAFzc`i z-&Q;SniZSpX|fdSAe`)sz-isB^7|^U8@v|3%)6#6MfG@D`)Kj}9;!*|!V@|E*&|Zf z+ys8j^{H|_cc(nknQmQyzo#ME3nmE=xx1izEDY#$$bev8=~^lh-n+NU3n|5;?Kv@%x33d=qck)oFGOGQ5xe7v9YFrx}?KKC^v1 zgz|qOi`+2p)_@1sPQOo?0uB@2EvkX0E%9MZPMNzK#faAOjcF0F-f!zV5HMo0s*CT5 zx*=2kr)XPwX28tcKNCs~`oeho^&?Jd^AKb(zTJ*E{_~=}ij>D5V&H7x_~=?;_EY(w zdjA_wRlmA4?{n1*)v!EWsn(}*`QUJ?la8l4j^d6CLzEyKlD<^>J05#gQc-z%UG_H* zWjx?Efs!4&JC7EGY;97t*}4MoDbx8?GmXI3=LaI1hhJcV5RfoYL%DtF#013;G_le2 zOQkA%&5B=z>B58%p^F+qR@)^p?4w5va~3q~;^mxrJgwX+6(z4}?jEKc$Sbe&Icr9j>fcR=QdOjgbrzr#Jb@PvRTevnD@v5Jm%P##r zVwucusMT95?lc10^L-gA1;zqefB8{{)i^KJiK-;oj@P$d`bH#Muk()F3>K-qcxSU^ z_~eU-G2-R2uO^Gp9{+<}`qn5dCaSs?exz<#`Q5~QzRPt|^3+y_Pzm5E_tn0j{`}fw z{$|Uv?KH4u7AF!03cADY?Te(spnV^*w|2d-!FL;UNHRyuY7N<63~G-2l&Rb@TqOSZ zeVTc;-oA;i)B8N)m2QZz!k^uw2drM6L?9P4*VEpQuhi?Ct_!qaCfeM3S6);Kv=e25JDLDt06aH^E;Fs-gc6YiADDeJ5x>R+Cds5cM_U_DTWAME zbBn}U``thZuk8wCwwTPs0{7Xb0KN|Qg~{NMggKCY_s8_J?rW_O(THSM=h)Np$HtH5 z|DI-0ym&RIQ+gDVC%3W23Z)?qtqzY6C}yw4y-w8?Ff^c7pCmr|jZ3*9igFcw`{}|- z{3h_twzO@{onFHXzLR zP;wiDXV=oz#J%BSIxM*X-LtgR{L;y#bBAU(E$>x*T9X5C6|l|W1V;Zgz-Itva+sRX zAPL_jfbCdt=9YeE)|;;`{BGh^;X3m$!eZac%+Fy^Z0cI)J84kCA1skiXDeB_?Aau^X zOoHGz)d}^f9>!f~u=^dEXD+%7(ZvlBV+u9f!YI@@X9*$(T=d`6&I3 z_zN75Y4OkNj5Yj0h8-qk;IkRz47#TVYm7Z-Sp7V41)Hx2q+{%Kr;~v7Kk1MhEAkNU zpNMGXLYUl`LQL+DKVq%Z3}|gFD%p?cs7M2u#v`vkN(6K$f5;3aP_W5fLVmvnenek1 z%1>hC^iQ{;R=*imiVS8DOv;))RZ|aTe&^OPBI&~=P%zkTLh`+9!asIXmDq&nU1hX0Zr%bKA>h~> zu&qlQzatwU@VIofw>dm6vx$%}$l|gp@5oFjKQ7^QqL?Eo3I#nsp@T>q5zmdDvbO9c z!h!CWXUV8Fdo%Q}{()s&>1$=-RB3M{ZfM6~?L?7*i{_0d^~_j525@dJ&f^coZ$l{f zhzX?Ytimmvn_~Ba8Nb~30czgI&g_CSwh1Pm-YIr#B#>6QEqQLXHhSl~!o~Z;B*{~( zTW04{+65U%5%7c**JQlC?G{w+XfC)Gd~Dxokb9`f0X-KsS-(^pF|QG-Afs|t19CbD#ZFi zOPBtZ;kZ{r7R%Z#-?ti$O*eViQpOIddY13)?=7y4iHJ z+!-5@gQuwjaiW%b4gwHVxag^nLkl-|6=8+R(I9%~SHAesSH4+rI+|NSqg;GRq&Ump zzHjv01QWsg@F{Pl1C>I6cdQqrFlV4#X4&dCtopjRGk`7xy9{#j_v`npSUShYI_Qbf zwz&neH7hxm9QZUg^R0jHrCwV-g5vu(k4El%p!<8g*L;Lk=2GOfnRMh} zQInDayDP^hg+}Q%uMM+siaf!{${>Mndf;vXRm(D;hU#~pd2k!MQt?~Q(8I`(R4{B~ zb8+CjKmOU^ms5#rO2c2B$W)xUXVLdl-QTc2!5 zLVX};60&YsKJ45(1-v2t2ibP(TbD1!JWW1!F5RmlqSVAyHTl=ehe0L7r6qRy;r?fS zx;xqsr$y-1evf|rLi~E&ZSwQe8w8~I_i5Yk^G)Zy_h6%3Y{$ASXpJ+@c5ssYYH0W3 z_+5;(94koDQr(lIMCJYsb>S8hx_vQ^XimEA1;7SiO<4ZbtS{mpbnGni*oDi&0jd!G&8Wt_T(QXTk9`XybCOjwEO!}qR^YSQPGqi%~p zgeB?%>n$fUjzX6x)oH8BM^4I+8ay_c(mWfhu?o9ehGvUX$k@|oA02_pp02d%7{Z`u z0}DR?ZIEqI56mC#WfTJ=IGYk@D}L zwuZ;gCBFLj2ThPtcY00jC{@(iL zcQJoW*--wpy%zT3L>GJ7!k8RbwOhU=t^Mw+E^$2pHIHgYo7ZBg>99=(QtugS)DwPq zC{twMYMjWb;Pk~h=_gwA#29?*pWPl`HuO@&_`}>je_hPk!uV({-TdOM-w8#}Lqz4o z?;;}=+E%XD=?m;(O2ER@#8?J@#zeZk_ecT`@ez?P4c9wL83a}APXo=lH zYOYD6?oi(tU1h&*3|}9qG7(s3FTpzNRIM{&L*;`INePLw;@Pv>GO@zLv^xn-PI>!I zoS0m>ts}N?d(4$%m2}6?XZRxh=Vh6dM^UR{^O!SeQj zcW&BdKDQ$#@iv262t9w*UqKLdbh@(2Ga=nemENU$H2u8XhUxRiYn$o6svTwGuj9`U zAqe{ur`b^0gGBMY-9dnd1hk1L%1X)9wTlJyBSTAD#cB&p^=GB!Px0p)8;HkbWq4ae z&Rzpy%(QG2B`+BJ(mh5`v`gH=aupA4 zu-44!n!lep(6N+DWW+`;Obo(C;+kKeY#()_WrEGA<8Ax_AU{CVv#;-A;g5Z2?y!x< zl_@RDKQx(xka?A?aEtJ5=^Jk>`b#c+IoT*h!W7X%Dmo_2@|c``)$YLtE$O-Kxg#j7v99bv4!BZPt+0JdG4?>JKQl zxnpa8{UGwEvL~Nun@5B4{=D)oz+503+Ll^ZOmr2zr?hZ)k%s=w4j#g^GgLaA7vn%2 zsY2AFvmyfCT6W_KIiYg)H;Etp_if=Zc~1b%}4cPM`yO>>Z=!bMGwKf@>oTJnv1 z=N=l|Q*pYd7do2fnQrmN{=RwmvP~I+@g>Fhe-J&cLR8`E#ce;WXT~uUfrdOz)}vD| zcCYPi*ucru9C`KICTb}DeSO>>>aPIy{qX&{iSg)ncU3+mKHSeAe`BlQmq(dA`>C>+ zFT(kgq?+cF+z7iE#kOlF>qo1)YF_dSg-u<`*S33;tcSoV-lus5)fCC z&3_kKGq&Fi{3twq#boY^kbq$3oew-(5)0rVRZ2w7O8u0tZ=GM_>#y;j?nFshO*QLX zockbI8Ew)h{X(RvKKEhxDbp-#S9#xF;94m9drGoT?OWrwSC4D&%N{rm@fc~R+U)Nz zO?ZE7k*heZm-kMD`|ebt&)?NO-Rk9nSRs60#b=#{vtiKzg5H!^3&ot4scPcuYs%y+ z^d%OzIS|Bq_J{|uV&Qg~>XtlJ5H|vb*4NIsL_-sJ5}*Vv?#VM7Q5pF>_4nN#r{q+q zCdz)5Wqp;+qSa0lS}k|w8KCT!SP`S6eHkhwa4>6HRZ)%>b{gg~-rC#MKMa-ptkk@z!4CL&Z7&{H9o%soCprArPN5c3x{`LBgjV z!B`S~>!|d)Pt9l88+9(@RaZUse2+PK#&)1^g!ru1;!r|;IL@qCmF$|aKUWJ%4^nW{e`{dA%NTk8Bw!B2Os|faf9Re^i}CEs z+y{y_lv579amKN4|54x3qhpSPl2JYEu7abx1RGUmze-|RnVWdR1j8~l!Vr0y&ek{c zQf{m%{g6`1O50ZB0pl@haE7x#%4F~_cst8~#2t)fz=+rsm;}r)`U|VaWR4ORC5|mg?xTR}vanImN zha`~OM^EV(W#EWmnHB*X8!YRuYHD^#-#~MNH374Z8q0*QOJz9h7Z{R|vE|Bsl)JY# zD;>pLV_9?GHm-nC^B@=)KOoiCde$+yoO?Bvv0Cpe_Qg*7af8F^G|d*&B$l`LpzJ7X z>%}%02nR=`akosX_+4utJ!~#PTCe(Oxtu#2_?r=We#A9pVb6qc9!(3&ceetAw@uV6 z_Ri%GbzA}mz1XE&3D^e5(U^GoYM7uF+-fdrj$lliHWf0Ue ztw}(*WhT! z6$>{CODjzFQQ1aI0IJrL^Ge-Vdph@bJ-fT~niJAt6*RbDJ;QkxV18LxWrJuB{tatQO zZq$a}KW(1MA(_LbbUG*4Pc&H;G*{%+MDv4s&@v;Q=xxq4klV5DzLzVQC7nBJ`Stmd zQY;wGwg}>IL_pr10+iE?P<8m~w*1*4AkxcT<5|vrUb=UFxnD?l2n1J&iU;gZ7;^>Y z(OIpBdT~H72(D9*M6vs@xxnH0-oYwpv( zr)C*kr51ULcVT{qI0u$Dngzc6iD*>nis-qNke$A%J5|Xo-QG(Y7+7%Daz}PWw$27Z zx9Y*?2HdZKZ>M@c>PrV~bZL!S6!e`^9xzl`n^`xBr*ZiK6E}95tdqb-fv`z&rOt(g ztY|JTY2pk~sRKoq*#4&F6q@vMG$fYw7wA6K$Nvn#XKe`4*^~hTvJk*Z?s_W=NSeu5 zsjTzZvuar8+)Wh+=SNTyu%@{qot~pL4beg3xeWxeXYx@sXhF|gX0I?rGoaX$ZxZy9 zEj^xYkVwtY#itAkokh>PQGN9Ck(<&^+Gul9t1GzJku(IfMGQjz0;qy?isAdtdc(D` zJ^zD9uN6FXqfKu$HVVU8n*j^gs(bHVJZ9=$uSM=IH~`#OFZGf?YDDN?eU{^y>wi8gkxg#P~-pJZN;HXtA$o=DvP$~ z59q=r8m*Md3_9D=?@Ao{I2d=)^5aU2^uI(Mh*OyvKJa;(* za3GBbq?{llFlabnzn9Nq;lZA}CK+PP>}{-}X~tCGI<4jKyStsb24dKJCBSf%n~Ze@ zk!6xUBZy$Fsvw%!}7xtFzu1 zY>(S(m02|oPxQ=B;jgo)T*e#^*r~jn2Pdai^5HWQSK!P4e>__4S}Rj^=LDNJ+}IDE zC6MEL7{}crkeO!uAVqG=EQ*=0#Jd=+tPv#f9J~-}6w)gDdo3{o$1yK|u)6DcxZh4| zOeK@RM7GQr3R-@<0r^s`7AEUf{Tp4Vr3OL1{OA&j0j9^-sC*zYte?TgAz0fZ(@Bc~ zpE47Ux^Kaa{6HwG;gJk$2@UwHyh9E~rRV>1A8p^+I$iRTtlPmhq%4H$#0hXPq8_O} zUi(0e1yq&1meqFEhc{Zh@k3!`V+F)O%;R@I{A_GH#p*i2ZGzs`tMC1SqT?Q!WM7bI zIg6f!1Gf|D{jDepfQ97iat}Zx8bZLbWLWwCX}ohP%}wF;>b2IQqtg)Jr33EA$mP*Y zpd{HYohF$qk)Mh? zw#>`eD8{C>rK1>e{8E8cYu5&teYM{>@@99_GyR4It>(R`DcX4DPJJ4 z6nPJ0{a&sF?scXsFRJ-Y&)t$f>V7UI;Ct4D{oJ5r+e#}Mpx55wIPr~NE{u^z4DaO5{VfMB8-xcx!Q8l zj*`0yn2zMj!C`4@s3;X_`Wk}wEH+$)R;EJ~2yN-e-X#q8#7dJ^H_c>VFzHeDR?N{& zy>cig#4i`P;IC~ks!z|2a{MKS+LcJ=G>T+)05%GX3Fh$&YmvKhpfg;o5jdS`qtLAL zz_|=*T7K&aT?_-80eOMxG=g24L^GNzrwlVz>sH#{jhau41dsQCelZ^{du|O-0b}k3 zZ(~vPzF1=2!YizB8dvFN&jr=x3-pE}Il;Z1)A10~*jK)-lF5p>rPS1``nTLWHJ(k| zq36PP>v)_ad+h#rGyi_V^3V|^fa3>JPc`N{%iEq-8q)=4Kr;uXx0f*I_1rpdI9>Nr zMy32Z{omD?s}5uTg&z9riWaYvc$j6Goy9puO?o{vSH(&g3WWnN$?Fld@%10YS{Y~- zciA?np_!2~@?AGJ>~f5bt+2Q4nwqSPU(qSfy;tMYb$5Rhj4J0u$sgdxXgg^mdRmbE zO_yh1TG(4Xx<>u0NcvVA0Ecr~Dhl(x*tmIrF=0XG(TgZk{ z>k5UcIreHe+F4vD7iL_~=p((;D{p?OXj15g9Z4*%fAUSo^0-ATh0@3&jz`^mz4~wd z*EOG@pIcu9;I@_m=M$P94h0#hN&HYQj#xxfLJm1|j`Lhv9iH8{$oe?R z=N&qfLH6p(xkdh4C2-HEV$0Ac#2bY&maoXX`A)A(%!%MXGYL^?mAXVnMH&D2@k!#- z@4cCZaxXhYYV`lacIoWvzQsVA{YEJ^eYpDM`ZGN1;7THZ( zPwY@fJ!ZMFti`e2%t~)-$%YxAo%~BDVw5k0F_<-QPxP7dNf$@y1<3n^nydbAY2y#yXGqk0A`qL5^5Yk-Z@l>r&x}V%Y7L_JT2fJ6+4a|+nMO%__K%#< z){%|NbGqVR72noG2sPsh*O*`tn+HOa?D zMz!{6>uQ%`JZl=r)wa*XX7XQb(rnAYi5oUyYNns^=SC^vxs4V*9OnNq&)BvM-*0VI z@q;;7)>7LnhV-X-KD>BQ+zQ!Ir1Wav=WHQ-t5awp;r*Fy%o|DVZ^7z^1tv_kFyztA375=__fI)~BkTOgZfV3{}Kp7dx4+^q98!Ed?HX zABx4L+-gILqDN)C632Z6_$0Y_n~hZO>v&(e$dIIVEz`k=47bi~KgFf{t3TEV} zI62QtG1hA4S1^H8dpLT9IpoX6n>s^a6wfE&ZBKF~$53A=E5JcBT_PG~vc$+kt}%Nh z!&;alZ-{u{fJsH?GQ?H!11*lFPH%!Ydz zLc&5Aq-G+vW5Kv%GD{ElBZsRl*%ltc=!;zn>Y?WYx{_oPpL#80lOtFT$4-&&P_mdy ztXj4ZFu9}f6Ql>lF6!ezZk&}dAfvN3tu!kfI3XlYU}oq(txTfWcNJ?o_E6L~0UVGU z|AIPmZKw@{Mo8dEOB?xs)VZsqbDvN|LIO=&{$MU1RDXHCw}xJ_vIsq%r@2@l4B{5z zNpq}itt3gco#Kr(5-$iZ`$l4MIOZRvfwV;3^)Z+n{*Iyo>xRDYQ&yTGxHaZTzO|G; zv(`2^>tCSKI6Stz366HaE|8Lb=ZiuY~(jRY3SP@V+o}a+z_N8!c7hh00AuU+F>F zk$DZdWwF7_tZLzt41Qt&5 zqKn>ta|Hc&C)xat_re^DMMDb4*=#ih6Eg@I<`J-1M$CT(0?Hc1-F$W3>cX4rTvj@R z>Lsn8g5J zTyav^L=VWDI*ry823fO4Z;o6F`M1UZUA_T16_(Xjis#l9MDoRrM*~}abDHtbXgUxw z9A3OZ`rjbiesO!D@O!An_6ZL5{QsfG97j7q_LX>$--j)zR1<~7g8 zS*TADNEpbh8qzmrM5Z!_FI=_oQ<-fr4tDtMf#QQP0gO$bAgnE(6>CoZi^H`3(dXTj z>!{cJI197?*9hc-qP->GsDAe;aM$D(wFyRiDW=I7Ys|3N4^eX&&i zk=E5-KWYfx$ep+RCV9m$)^93&gP}DLx<|%HbG7D@XF`k4reMP5C+X(@Xr4nHj>Qpf z|?W#obDoWZ|*b>b#FQfZovg2FQ zXuJRnCaCTj>mA(p?v;E*WI6G$2UO;XhQD-Q-p7^lt;)j-CnH*+;oczu1*-Ahmt(Uc zp8d=Yn2g| z-s-Z-pS_5UlD#igQ%`+=Z;%1z1Mk`17JggRxxwjQoUKUmgSWu`aS(38cG$Dc8!{AhbjnC<#S^(IP>`>j?* zb&V&*5lG=-3gwV44YF69Vq9n{)mHkw@50|v$2E%6^;(fHqTgnU53Xo$e0Sy5muhhQ z-i;CkCm+euOZ9YUZhiH?Ih#*}U7s&cMA9SYZuflIg>L=VLooC?tjcRV3cMvqRrGB) zAslHv8G&l7n*<(>Edafv%fC8s1@sFFol|Z=SDB|BcQcin3ixe#1h(FXdBIw0U6>JR47bx z8(6>YNQSSNthQf_{=(*LpB8z?5E-8)e7W6{srK$)BimD~ce0>^p@C;5PQJ6Ki8c|^q;4$Jte{%F_F-X7cSyjO-I8=r=THN4WQr-_EiYz=q! z29Aw~{{hEn?#%<2>yZa@_}50MSmFLc$<1My*l5OSiSznYJ~3eP)TdODk%wo7MDx`= zgNk)(2%AvwPg+HW0`eSd@0+CZpF`q=VEKCH3uXnKlLXLpn$U@m_G_nfOk*EU3jGiA z0c0yY#3^JH!e&}&9h8aPArUmU%2G?j+mCDk-zZe$BKn)&`DZdO@oho)tl;e*tc)$c zx3Na0q<<@mt-?u_SlWjOlyl#e`k+libC3qk5hY&E;0nBY{>@p#$@`E4o#PSiYFx z@OE6s^f>nTsrTUn^$z-Ddh`fDCMjNSpP914M178&(G2}g z)o@rV`X1zQqF}eV8*S?=Q-+z%i1{8HRPk)&@*<%u` zM*ewBly+~Dqu3v@XS#YzA(Pu0mep1sJ@qf-lBd1ZeRf-?u^+bF`=NWr8%^EA;8<2& z913k%tiG(2IEY#(v};4PSuQMvIbCv84tt`MK=XX^j=JC;cS!HI;)gvh5)ivfuC?Ec zYM&ojxdefyL_FxF%0tSSz#K-R{u#H)3n zONz0wN_7XCq9_N8yS~)#5!WBh2tKPqHq`B({;$(BU!QrfKq!x#J@x#BuCVIAg&S8~ zUGc|0KVD_h>Roh6u8)tXbx0+9X7Y(T;am$;3@(%wEh6O;rRRO$OKO={=zZ(`U3~qa zjKPdFq*B+3_%PsJjCUGVN%5nsc!=;*!SDZ+u3tY`l=9}=O*>2CP{HHBY?+m3K@P!u ztVH{p!*=Z<9{a~oJ{AYhjU&b|M|ui>tju@IO>TP|@Sl-Pg}Sr9?rr%ZKF77|OSO8yIflfx(w_ch==;5kcX#bZmn!rI3R{PS=WHk{Cb65SrjE!4dnR%o~wdTb6 zGb+1HBRcHJ(Ezh9Ft`M4?N+c1qo9{~@+zBbP-PWB z8YZi21$S4;JM)|MBIWVu9T9%iRa^gUY)@HraCvUvMI{N?p>7~d=3(=sya8_w@S^4{ z+`W}1z;BX`laCM@saj7O`r(*?n)ZZKSk5-qZlW)CrsZslJCH1{+KapelAM2N@dJZgBYbl?v!VOsL8Py|&s# z^TYo8{$|~7lzaaB(A~Xl;IW7km|imEHscq-8ts?yvO~AuKB^c|2MCDZetJ^&rQ${@ z>8s~Lu3UZR2~2Zp?O>Z(3aWwJn)MyAyy=|Pf4J5jBOCzHIhMEgP6qRF{CG*Tx~9od zFEeCKUbnl*qI;@s42Jv`fE7k)l&Kn8=7{M^?AlHq&z=0}GR>`RY;v%uTzgJi-W}5b z-7&aA!B{Y8G3U6&I*v(eA3st73Vm+1-Q}}3Fjb~ZZH8D*X-yD3hrwf2mRYhtv_I5S zGVD)1TDT<;&!Wwcx~l$q3=Dds&j0Nx#Tthe{anHKn6P-h1{s7Xmm75k1`-z?k0p&s z(k`t+pD2N^Ty8m^mkEqAs@;0rNF5Bxv9PdYQ{2e;P;6d^W6%81>O#1EEXeScIMcHE8ZMeQ&V^AR^!7Y519&HnxP4km!~ zSv@mmIg2Rz&Qs&`ekRHCYtVn=&$DDS;fX-4=1NI5&Qzle@+ws>eW%&( zD7YkT?fFBO{1&7^slaRP@G48JA_wKg01`l@q4|4D1%)9(OKdiUz zXvZCY?&)k=mykFi>ZxIWq%APv3Z^Y=N$W(*p5cH!YD0ywPn06>Iy^r$fNG2A4QS0j zJKY#tz^)Pyz?@=aYkf!#Yd=~4^36O^y?f#_)P#6A3wN08>JmGC+DI&eR(IxFRkP1$ zAS-mL@lag1&TLldepXa)qtSbHs&1hV?B1G;{3 z$6>yR?sf@`!0xLLZhN}_CSO$^85=GBo7kO#s~=q?hVQmOo;U}QABfAAJPiY38#zFr zYOo1Fh=)!_nI2;AJHNUYfHqL9rl|CG(3oE5;+GDw_Mm5!{9AXf`)};m)o2V{ymK-E z*^-uN`f;Q&0x}(cK4AS@h)^~*DK^YpQ?0c}ytP!%^84<=(Non`(SDVu=4J3cUt_a9 zY$sFvG35g4)|mVDW~{DmT6)@airiJrq_{WxV#9M}7`=iUjUGpJZBE3;eRZG>y93^One$ z@mXXh$Ml%$Sf1%6hdP-n?yZ-OiZCM7&*@rHO;8BGcPut zcUp@lJr&xNTIOCnK~q+ymJ-#VUv)Jg0aPu*Vuv;?Ho{W0%geOBA)L^Y=WCHLZn*!}Evi^^dEkaN ztR?vIq$aM=IYGi3J%)zPV)F#+WHuO3$#Ja7ioB5@w<_jWa{8aX--cA-xA_l#{3t&h z`%NayOxoxxckj^}Jkdnw=lcug4u_-|2M^VjDrYm6xN7tAHMtW_wdPsQFvL6^<|b@p~zKsn0=;2kgk9_ zuWr=*(~EP#D}6*%-+8|48Z;@vkv>U2~7jn;o@68P}1rGO+rrMx-g*bZ{I2n)Ux*T z>nB}s|NiZ|$cv4{3_lDoLE;P?CHEvBtt5VY)X z9zox+_AA&_9ePaZ(h>3aonvyRSmP?(8VGSWDm-$0iwk%P71>|M9auhuVry3ShTfdaYA>QAoAJV)hCU^vJ#r>gAyLO_1n zq5QxNE)0pwzF4oAtyzi*2>=;q+$htB5BP>V7Y3I=-qqdnWnmPVrHv3V(h&g*f1rj3 zS0j4NrYWvcX*GZWbPo!4Xo+0GCMDJol!s?qRgSj1)g$=VQFJJAh#Nf6WPR%CJCuf! zZc1ERDF(u8uKNgzr+2Tl@E_OKXrS_HcW>@v&ZsSbqK(m)`CI0X4$Y)39yYVBAR1Fp z9U=keGbomR^DsdA|42Ibc&6L`kB^m=WGQOy#wtptVia?j(ZMNMP8}VaQgT`jIbbG)wi;q`vLs+d)t`~~s) zGn!dO-hTmEYX)@e&z@fllg$|QSFPR^DlR@WxBn8B^$`SwYA?CjYf)G2)k{4L&ELOt zbeXFDaodMLOd}<7@N03o+RiIveFK-KXEjZk9suIWwG$iH%nI0h50JM36bQctR=N06 z+#u@R$LW&b8G?3kVJJ6cfi(;VzZgfmB&tat`mP$kR{Aa!M;UU(+zATW0kBa(5nIg9 ztdqe%0vF8jMz=~A8MU%s|9uPN( zi=PD6^xHAfuXd$+(gCqbT=ZI1C(`+G{Gc!8UJ;AYR9kp4O|RpFmi6=FmLMbqcctJd zvl7o-c23L%5-tXF9*~u8HN>wS+J(2N4@|zDdR5t+MPh$bvE-jR=UN^EP!}4L37jo7 z!Z-0E_<~c}s?jkLyader%m{Jy-hKd0Iy5IemZ5vHn~G5nB_|pf{~Xe0UT65E~-J|yqn7)xciE@4RiTA?|(#+hJaRd zLUSN~Yi$(J_l<5_C7s5T7WjN>Bw5Kgc*-=>2o3_rq8xvUDIU)fg%)A749Wl?3kVE> zs&9xhd2!QoAKg-ijhIGW>}{j@epF}CDdJ72Z#v9kb!OG2r)f3(!njc8Ds-!9=)7_Sl7xIs3+{AQ9*i%f>J)E)y z92wl!a>DnNk^Q^xr90Q3dDnA|C8jBPns}FeYz|p##Mt$cH_I%}eJS&B{&8pIqH&ut ze^OBTJ3zkQ#l~x0{_l2|%{83_&XGDfg%kf+Bq%9v&ITIJvK`x=zCRJE!e+h?9J4f7 zNZfH!HNbP^;>UaW;TPM{wT^`c!Xy|$Y5K=z{q*^bhhFPY6Qh?}buKP&^MXG-o2N&V z9EhR7|CSvJPmFk?;kBZ=fc$r(MfZc>*XxH!>M8q?o0%vAQ>6}{=NOeTX0;9p5W~Q2 zu@(Kg+Qhqm?SXgieimmIR4qr&lmc9ryvwrsiJdjyem~Uw_dm#n+lOate>y356j9TZ z`TRz%=u+v)XV+xSodAwk3OgLsI0NCI&6h?F`mv=^74WD``bT}M_(o$gA!N(HrXhW$$ zyNI`$m_oU2}dNE?$;X}$&1z=P&LNRQSNg_pv3Sk*jg z^sJ-&cj@ZZ4KP|JaGrKMqjAb!@IBJ+hUx8?3B94U3QKn?A54DY0nzO=Y!rV0wOV17 zJJc_P&z2qRDHq75b$mp$Ud%_k{tFtj_5d)G#0AnpCTI&HLkoGn4c>@Eh+OcvvD_NO z3-}>|@z&k`&0>1cE>pV5wu<6gj>a)@$;CvA5&UaD5C=k*$ za!<0L!1z-sj65Uy!vTxnUdd9q zQp=BvG?;(d{Ucl*V>*Fg4qPMyyrk$s%ic88icF<e`5C1 zy=mn({sL;m-f^eq>hIf!Xy;`^OA^wiIXMTu*)#28Um~N7$(eVLSDA^USJp(!EkR`% zQ!uHSL428C^8Q!`w+qZZT8YVz@?SLs2N*AjY0OWpn~17eLm&()MlX&d{yqj0a8W%yFE81bOlLp&OagpV0erSCvXb-8T1%Ihm-!bc0CkWl~Y^AK}be3>Z zu(axY;7-aPaVs zt4A#4V#HngtqFq`s;(IxG2(-^^Usg{CisozTYld8yhFEHx%I0(h({WwU(n6dP?B2? zw=M19cHfb~?2+@;!t^IohY!i7WRbox+~U$KAd^k8T@gSWH)28J01Yd*O0{|NBuk|l z^adB4@1OIB0O0iWDbsksvMmSbavnuh;9MztoLbgAXIo6%T*~yO`$I$SycE&ew zpqM$?z0|nq;?3YB*!39>%VXH6j_55kR#mweJb^C;EtF>ts_u-+4YM63UbB$fSiMEgg@SGirYaN1mFNwAMuC7tg;+mBs-U)^r4>an!-M-9zj-J#Hz0jXTIG2PPt zAhXXeX7b=$a6&sPHD=qA*Bwy zCi1>lN&S_N_tXr{Stz|!Yn=F;saEv49}>^`^dF>kGubx*8g^aOXAJ(Ez$?>IuXDm{9KTMT@(xQoZIxc)+vsu{A z8+yXI59CMBof%h9`*!$$JrM44$3EKF-%gKq>c|J{nDW$emT`>VppidJtxI$%{_X3q zi@tkr-q6_=n}vDLQjw4x4&@?GynE=Sy>HI?^00@;)GiMqC)Vn#R?S5@E7y0ow>7x- zz329z@+>BvI=vwzmYVOkFoVn{_p4>ac9&7Ev*&(a87Q(ip5l)lr2ml#n*P%QJ#(7& z;zEV^jCazD@bE;yApiufdSLX~ z&6RtOJxZ;*JRyTQ%_=;%C*1L39#3s^VAk~_>WIUsHnUMLVj0P*IP6Orqq9>m1qZeq_cOs8()88$B^TR}yJbArDRm4z`^c-A1z< zBZSWoKCAm%+Wj*U-9F8(@cK7>u*PL{0d+{n^pVMI+oYBEuG?cexMLm*T=m5z<|ibT z^Rw~6ZbOuyn?fkDdgzeTk*{p%aEj$xS5IkHqCS-ST;cB+Lxt`hR&6*0Ooj+sU9A$n zyn9hH7e_UQ*DjM)dukqp_0yj88>?Vr}Au-ZG#*U%SO&I zE3RKyj?g}MAw0A;`n&`7b|JfzBhk9L;+=CRZGB&FMel(p>Uy2gMHw~h&lSj}J}Y7z`*I7LT9L>c`xB6T@Rzy5&Ws!&X;CFooW(?u9r2NzYJR%8fjoGg5s zW2hJD8)|Lb!m-2olm5M!*q)mr_-fs8rxg^lVg6U;-uNsTi~zx!D>{X$vKI!fzx3i1a;nFQ^DxaTHO{PirtMXAPEiO-VJ3L10!Ori^G< zE;zAXn`X7n9cpw=g|QkIizj@n&{P39JKmm@`mo7MvtaUL0YtPBR>T-SKba~Clk6Y5i&*@_QUrrK9A<#0J)liSK~`@$uCv*R z;#J~1(LI;j)FVPfLEv0%o&)D&7N0{)^Vz{tAvLmIqE>T`n?JeMD#daUw475Ok5rZT z6q(K#5k-;CS(r&i+bq8&L``al0Yzw3btgB7e)fT}Hh?`kt(g(b=O~K{W42*BBjpEu zkh9Aa?J{3Ro>emkhgo(yCxSN*RiWIw%dZq1OP(I8Le2_)B}!PzFuE-biwxAPi&qIB zhJz)`d0hzJt(n94n$(_F!v$*9wNUJ?2L%9Ed>r*(m+)l3=ey8)vrf`-1iXV8|Kjp| zbRSj}$rXAyR~&n(iN-9o4eJLI>NjFVvZXESC!Uj(BQwZ#1!kf3x~4o2{J$?1MgKn2QZ3G6 z{d{pj@|$(KxS#n67cMRWB=GLy`ct^*ohOC z%tOEX;yr!6vxikJj8>h4JUmQicbYewhA%WiRZ}g!H2s~<-1&35Iq=|Jt?~XCSiO%M z)S5##&Sw3kWc42Ie*zmVc+aO9DX<6~N$O)`=P)&@Cro1lSp-5yaa+s{Is3hw)-QL2 z=8)uh1%6C)Bn_QGV%21>TmM$*m0UrJX$mCp&!(!0+v85l&c>!x?HXOw5ab`;c~Y*( ze{i40muM`@4h-kT#axvmx5GQ8q@%O7Z|M)j0;iB6_2JgxTpRmGN>D>z`Jt(=Iq;N< zZwDoVwc(^`4t?zW`+4=df4A!)ScZ)nlao#>vc}5Z8|*CMw9znqrzcjfQ7 z%?**zEDUWR!ED>Qf*+0eQw+`42&r$(V+5h|Im5k9+~itgg6$%=tUDQIOrk%22&xu0 zg{nVOHyryX$<(cuaH8|5M2aoQML)jMFFwAd&L$&<-^J*DPQC1iI^=9bqSDQ?G&dYF zb+7AFH6|hyKNy``oU+qzbqNOZ#7}B4j>Ii)(DrQ}8C*#KnbA=^sB87xJQ{%?9EZ1o zxxpho02yc*1K|a$At1E9D#docqZI6k(myRw;VDRl$XnFY{fxdh3DQ}OZx*8gc(fNt z<*u+o)=UTvNYK|HEia)EDyeZ5?(0w)Tc4+pD2bE)8;HMOXPOEL#7n&Y7Frye?f0IK zxYCuoC;OGx>3sc0PqDiQ-22DYO-T*wn{%vWbpsK1P&cVD_IKM;v;N(pX2ONy zZEoTAwNEkoB|d^*545tIZrU*HCpqgVHd*$o@t0t(uXrk^%c$<+=wtbTIxzQ3y*E5e zKVE{1=Tq_t;tJC@yP{-gDP{kv3{nn=WPRwV#4i!SE3w_r|CI!z{xE$hclXHes8@=* zVQRis;WlHHksq~zOX#{oyjajCBu!b`uO8919bH^no$EH(^dBTDm@PnLr<{6-aixo{ z8LZxQ1{5vVU8qCd0|i{QWVTOL%-8@mhitw*80*Nk`Y$w> z*(_ZIz3el)D$n*MQ%*;}wPu&9?j0Tl|HdgDOqSN|Pl7`UQ#p2> z*rtpCW#!IrE|dw}4{YQF;~RHn$y*Tq&MZzDIp5#qQL`(*F?$AOuud>xnky(6l>b%o z`uCWAO0Q6f| z9&ChNYiyMX;?SC@p#|M0xmXMIj^F)_{aJUs!JwQ|UopM?m-^ssNN;cj)pUp z3;T4!xY{++$DKmlE>_PZuPTL{-}L6rdgN#nG7Enw&HlD9IU^-8+8aQW3nF)H zy(xzxwc23Rhm(85kim^D)=19t10Cm((+A|gRFjd&tlYoP%r@?4d8h04zm0aK;nA6D zmj6L4(E4MIOQRku8A!TK=r{8qEg#f1bk;dz#B@rUOPph42Q{W~aLD9W)ra(lm`_!& ztY$kDo_XE1e7J9$t~A8O4`w3WA+=a~eJX|3aAi2m?R_-N#56*U8iOR`S{nXL2DVm*ZQH?d!j08~M7zeZ~mNeyZ%7WT23w%cROy z`F1m2f8am%`r&buR1Hu0IIJWzGx1Ph*i`i0>ePSG&3elhec1M*c%R?%D&6~A?K=** zY_;NwLP}On_8l5IKRtBI8_b$3u-t1w%olc|WNMr3Geh<3UJ8}%XLSQ4zr;C8Z7Y2U zhz#1S%%-bC#o{;NwF`Nfbq{*r(h->>$|vyJB(YhBwwqQ$y{!I?`+{)tP5Yiiqqdow zT+l8}NX5cTi1>JSrVvpC4ILoDkX#f;kZ(H64hWb7hShVp1n+O}j=63=I7y8R0$r7w zg3CedGQ1s7Nuw|i3&kRG15YtgQ%n5%%*(|qgzXttW2t17_)2_4%bhFkx;DqY9p)0sQh7^3cRSua z5^juW%9yA%cVV|{P$`75)v$a4a+dnfldjm?+jj#m8oGOGtm&+W)G;CwPR^|VBW&?@ z>HiGJ4#2Ycz!AmfzEk40$($Eg*&9#IP3WJ06$V^ODx5yj;{ON2+hn>kgSd;_5YHTQ zo(qJ({0{;c7z@C?=YfgQa*cILc)UP@nHJ;+2w1~mD?oUXaHom@&=qU_tYewg%HXoq zhm}@r>*Up3Rl+sEo4cYQOfW~;H@iw^bQj06D}%&rWCX<~3=6#-d8^h8wSO{$}%mM^|q-d^$*GI+f^+FpmNZ=Qo7Y9 z$b_zA?^)0?;CjW*BYl19!^*vT=hDonssv0UHxJFN+B9wq3b&dTn68jXmkU`v4(gWs zl_P>#!s!;Zj8)a1E~6qUgKrf{?`P`IHmfJ~qm5DCWOh;it>tz^7>Rv${@X>U^fXEmr_EOORJ1C5w5=O6Af0?=Wegy#i2Ho1%z z)9m*hWJ5vbbg1|6jp3W%4&q17M+zr_FV1pL!7?OT7}B2K;Knq-(0$%`4&6%(j|my92|x;3z~zCNxvVLnWCgJ&xe{00AG( zU2COv*In(hWV01nZyq65T^po?PF`6ci@Y)n|HvO&$RGAb6_%#0qwR2R|2OMha2u8{ za*D;~oX*mV5g~&oS4j@STfu7wm(`o`J3X$au)R3R0Ca}Hbxw!}f)}v_{lyJf#ekkc z7Frtnt7xlkvF$x>KCpa-=N<3+0}23uZ;C;I=FmU)xN9>LCBop+JES)6*+}>}p$b$1 zV2DK)Dw+x4Fig;Bddxuzpk)>Ik3#rEB8I=QgX&`>IkT>=&;l2QFM)WGRqAg)hTt*a zsc|AzF$j|M%+?56Lp*4EIYtIzSc2zTo7&nykmIq|>)8SV)}njoZ-+m<$))QOFf|Zw zM)wOa-qEmP0CYg7hP6i|`<3EoFz~`o_83@Q_~GO{aLx}xX*_WOzb4AWcc+vCNR-HN z6Fguco^umATX1?hQyodXf|uEs1sQDeM zv;3behGge6+|hJUM6LI7h0Yi2wKf?D8e1tpl|21M&#BiW zlEzq!8{19bZ5|SW&6C#&cR%kxom!Mf-1}|2!zhLA7PUl1b(FOY8537NQ==${(l&pP z-gNEZnEHLanAI)>VAdR9M8(&vGP>V7p1Mk^uD1CUus$hy>0;n?e?UM0&mm{PQn*S(oT zp97<$4pMyZ|6&f`O?|9z;V|*CXG~xNulp$wZ#cz+!p^*8y#W*fayRe+PW!HYvH1PN zaL{DvZA~Lrd4S2VV{|0m@ic=Xfx@80ja9(ye&z|52XN;=*ShqcGi4LDsO#(vxRfKrK;VoP#MRPSUufCEIE;uKO-{SfY&XApZNm?&Xh}pY8*$YuwAsRA z9E(f*r&nXDaHh?}8YP>X!tp0%WyV32x-VSZuq6N}?Xs}kN_2-saU%jGN$e2^KPcUo zf)-Nk^nP4TOI`|-EB9PTsTJRWcq>*P&aGO=)+a54rUrPm2NtL90xx$2>@P4GiphZI z8&McGCwMt5aJBHAS+M2B=hER2hLd(KHuSy1+xan8%V~7#!0ymz^u0 zA%PXC_sT8#H4XVikuzOGiybiLe0eUW8Og;-8f3q2$2@(t+nfEe=+mewW|>$f1c=Xb z=Pw;=TKggwZ&V!mRQjAe`LP85Vdboik8$qfm44l4pDa~i0x_=GZhLZ^(+Wu#Dt_yv z<##=E#dup))!4F>$T@b81+IZTKiP8G;Tm7@x}C1O0zP98{Qya@>OyLqZn?}RUrvd< z0W+uJB1qqa&YSuZS*o!pJ5ZLUUQy?*eS37-$xSi8T|Ui{YVKUCcM6$x*YgOOW>>nu4{ATj(}ayj8?gau1oN5Q81%1$%KF)iv} z8PjM$6H!kx@s_U*x+pUeG#@O+OaqDe1EWvW4a4vcmnzOZz7~Atuk}IYI7ehOSc-wE zz;~)V7nRLI(QUe}K9-4)z<{HPqe(8Ep|%DXs@(?FU(pV*&;g)W({mP=P2h;p z?)$ko*vQGM7?Z4H`^ZYxTlz+l>0n-2B%s9M z!A*6Bf>#sI6Xbz14q76Tgk`m}BGfO7pGB*kGBPY3fT^I#lqO$K?PvBL`? z0MXAvyyBzZ`K<)7i1dIa^|}@2Zz7l*drgW62`Xq{_)u3WA>CztbnONZwB6B6j6Z+ zu3Um|$^=_qE!p|g_r7PlsPZs>d{W*IEUQZR=SP-ISm&B@PCRQj4JyQ18fwm`wkWM# zM}X2QnjR97!Eo?f3VfasFo!OV$pYswFFYd{4LWl-{ce!0#!GOm&=yD#*MjJ1qJSV| zuZ{Q2x^`JUG|28I_=FmHc-a5*x~=e^bPa@x=vS4$ptqtbvCH2xkvAmP6UjcQ$T`)j z9jf?pzEIgl>$umwMrB-G9ViktJ`Fbkff`=4a6Oy108V*wHSK&|Bzzt~nfIS6?_nyv z+JiRz<2IDUnlIM*ehS+mZ{%%4vBT#PnEl~P5c~;c+zP$pZD{auh3r;i_+LN*WF@q| zJ#}=GV=XkjXm&9r^nUbV&HnX+PUL+>>^#?_E7E_I8(GjQdro#~j(Xcq5}lJD)gW5fpsD)em9JJDjRjNJwQSCDGaf|}#dx_VvBdHN|0cc5%*AbB+hsOL zO}qA6uWPs^!}gU6W*;>|jh*rM{?D(ybB#DyMaa7!_7@sQ&ab;N{m+vK)$5DlpL{2G zD$(QAGCYEo&n(3Y#*%jOTZd~e96-`O*AD%7TW#`h*t-HH`z^ey$jIKb6Hd-%(gk3< zj+y4WR8xNj#oi$X%o)ABg_jLcvUyPVHk>*D^>YC#*9&@JdS8&{b5vpJ-`iubnMNrmz(rVXn0tQSJ`TfzuC16Q zm%{thvbds^NXK-0S~vh(AG%&MqCz)9^bO^7rLTok)4;Ls`(H5XaEvc_(Z@5cGWY}w z0C+&>u8%KYEkNXN7!$!Z;<7ETV~TB~l-m16@d42g2LyZsc7^wVjint+r5u0%z!4@IaR5bVl>s z2;L6H9L3vQe(z;`5fsTJSm=D&#Y!9z%%;r8xK6~So5WM!lwMVaVfhZ~@4)ug+e2Y=ys8@I;u-EB7(L@@ zOz$v_hTjTC-92Gzbkgy{xpwR4iF+U3M6lP98N7wUXI;nVpFXCw-EVXMrB(*s)Jf+R z9R5;#%AZgHNLLrmFrL(H000R>cYQ>@=KCM<3*%8y$oeCDvNUf|Gf$q3$ualaKBOJ< zCTN*g;#EqmUF;azKP6)v10sy%QW*nnJg9#5O0-nZwY_Xlue> z1qiqAAF?vMv*KfcKQOa0@dR;4Y`UtA>n4w3X-lvsf-`rF;jIHAT5#6?LDG&>-Zi-4 z*@e=nBoG|+S1pr|*0{+3B%K77TLN*kk^;!T5zOZSdPUmnM4~gvoDEW^=V=tSo#xwA z{&(wy!xKGUHyzUk%3TBtCGmNH^-4)~=o9;VJoo92XAm`*1p`Yjdi>eFV_T2o?*Iqn z(hJMgEs;+$!)__&PvZ_;;V;&jrJJ`S;kLbti3S0(&^bL$g-Mc*j1J~}x1n36D47wk zS{H8TSge)Rao0%a)roIumL2%!GJbdAn;K|k_%wh7$`)6rWHC5QPTeu}SY`mhHMk@WzUYM7NUW`TgTss@F_f{pyE_VgQ=>?aBSD&pxSi=$r)xE%cqH za))LYSfGC0vge0IpwXHh_aY5rrQ~?9pQ8#kBv0X);7``dJScL7vM~9LihDg4sjA3Z zxZGKFussrh2Os(dvAEp@hx6_MT*b>NvItQz9}f$ z(j}5|DD~y>6pX{qa~nRVOkq_Y7m2wIU~25+Y%Wm2G70%uF?tYp;EmzeJ#$NGU5AO3 zk8KE+TP%M$_>a9%1EB`kpUiK07h+Df?I-|eSl0Em`yxyF&x{_sTJQ(#IHf+-X(x|; zX&NirTC->&``y^1%5DJV-dv%3ar<$$8&0AXK4#W$&a!9a?53nSJs|Dkj>D?dVAxfF%zCBUm^5ywyy{wPeY<>EK3vRJ!Tu_qR%sB4 zSFwDz2i~7-HsWM~Rjo0=p<2J;slY**l|U%DfT5CBp;c?WQ`_$}OS_C!(+mpQtFIK( zEHyw9itM{0X6YQ&*1Y~c6u}MPK)@u}%qWNfaI?0_@e>q@+hZPM%$`S!xQRe;3s~S# zB149WSu*%$TG|etgi?xDw%#-@ZyW{x4d^YOsKHC%q1r!z6)b`h1Daraliw9$0^n=s zRAmSz#L1!lvN@(V;})1!$AKVr(#g9XI}Ez${@50600YRhtk|XLc5zc>AIF8Yvq(Mp znARRE1I9uE7Tc<|@8AyW>v4&1`fSa;kC`rgOqx(@8?gFO^S%>T9JxG8)5)a##9v56 z2+_G?9}Nfq?B+54zP9iC*(Yag+5h-wWbdl7IDwG0n34}u#^2Rg41M}0`}I8;Ek)+?BjepRmhQf9&pYdgFRsm3sS( zu^0qbHLcbCy!G|a#qNuTm6M~*%w3r~Eh33Ca}l#{FJ$)GXFe~6+ex9Ahd(B-CI%AD z?+G!!H>?^d;K9_Mj1`*W?7y7c(wkxumM{Gl3?~=gHfwjxP=z1sM@BdX?tmKNBD^a> zARZCYnN@{p@vWgAU7R@j3?s!2o{pI-U=y?Q%l!nJ{@#6l+^Tr(J{@p+snsLn0)IG@zV3|TTbY7N@6-Bvdmn6Ye7U!)c)7>eu$3 zg&IkaqF;YeM81@FE^WjqvvIaFj87%z83(G`Ru(A6yqwX}V6%5AG_o#j$lhv2_eYKH zmnE*-YTjz-GG{K4(ab%N7uXP4*a#7MN3TDrp5mW;Z^J(0$BO9EpbSr-Ofns3nYZZq z#``E~_*@QeZ`H-n;IM2(`6eUuR#ZTH^7{eo%!Xk)Q*o)XI?+0Phh4nf(=Z$sYqH34 zaXNRiv*n8ausp66Hdpvh_&ML3ml_U9@zd663fdejBDzjJ`kI(4JB3M}%gPpc#;XoT zIGK3E23A&4UCss1Wwc+vOq3EW3RWNv)QogeR`1R==!&uD2RhK09w8qhh}M9B>HcCKSo&s4J^- z`+@!+UH<#R?cY~TSWzVpln^>&w}+#?Vqw$_Qi5!E^RG%;XjRc=M9??YJF>UfUjE8C(a*gyi!(g7V*fM=RQuYGY&@56<;dwM zqX%#f5C-E4`;BVK;F2m0wd?_r^IbGx_IE50MUZy(WV2bKwH8(%9`cP zH%&cOL!!EqigNu9)j2^IRI217MZqQ4ar@@Zjp{Xh3Aa%{8*=m3mOh0d>gDKGdBfHX z#oM3Aw`;pU!otx8sKum8}z3IQ+?}`3tt(en>R@>?1cRHgK z(hfB_lWqX4AwS=AY-T-l{9Jhdp+23kr=oDX^xiiKm;1i&-nEMu#?K(q`OZ_Z{r!!v zUUbZ+@4a2+umK;;oiCB<18hF*Fqtvpdd5&YC*#{5?7q13$hMCwbrZ9>quT9VWd##5 zTE{;W{#Hn-akdB_afAXT&g}t+6(}W%G1iP`{5L_4mcNF73`l-iZe+%LhZ$35l~BO9 zr@xEk;L|Yzro5#J>m^rp=MY0>(lF;dTYpC3>VOl}-L4yf zctQX(A|rx~Bul4ohETk@=X$tbt4rpSQ+h*Ri%dKW?3xF@zCL8mtqRCDf;T#Q+gXE` z#AuN#{`H!4P*0~6tH!J}3SD@v63;37_A~$LU!Ztej&$<0M(rQh+IQ|t|2RxI-JJv{ zvVQB}Z60>u;>S25vTCn(${cmEQ5-b0|7F5J&>Edzyr|no(BYz~Cbp+;Io(iY|!t->HGGH18MDhDF6p^H5a%T0f7`m-| zwHV81L7X!Gl0Yk-?yPRb)~+-rO6g+N5+G{)$n~0A+HYL%$jK4L+YS$}I6crj;lx8ju&mQ~Q%T{N z^PVe+iH$!Xhygv;&&866e_vJ=t#5vo_0IdZ$oom0t|F#s_RXs#m{hIQBx~8ZHd`a9 zgZd)Rg0uAY=7JdG?BsWT%W!a~QPjxv1?vmPPmCu^xvY1$(*wMOmXq+EbPg_0Bt3F2RvbqRkLaY7?R8u!3!e+Sk^fa}>#&x7FVupYj zGdJ6cp_i2%Zc}`2mNik*&P!`kSs~^q?St|Ea1?hDFQfJ(VfWcdUN-O&zEnfEq;Nh1 z&Cab{12XCJ=~Tbd??U`x^ z=vHQR(W#^|+M@vX@%1Os#@k%h8$95xeE1K-oj~tTwX*jzc1nZ90LgBd(&1bQ+I*Gr zwM18HrSB#FzG>Zxys>?cY5PXUZ3ZwIQ&J4;;WSH0o%nCGVWT~ZP>13qq#xgSW%}ihI$T+5Hdf(<88RM3kJOzd9F)?`<%HtO!>tWV)3V zxl}nuad7cg(lt-Ia8zPi%(pa)Oln?zdx#)cC)p@q3-V*;cJZ5*8dqW~tapg|-ZC=a zJ)&;yj@+t_y2e#0{?};5o2w9wIK(j*<<_LTCLhf{nv$Z5eQ~$cH2PEoO}lTVShs6S>MyrE%&6z9`NJr zoi9laA9QE1quIlh*ZoIc*t#{{?Hr*^zF$%uaFo-!yUSO|`R&#aIag?gH@GCtLmPtz z(th{H7Js;IvUGQ!(mT0~4JH+mHuXK3jnU+hX~(0ZqqL*kIOr?wojzAfKBS9nI&8E% z6g@mQh<&gReO^ObgEFK#cZmLJLbHxtHOmcje;CVxVGWTH-0s562R7Y-7F|}uhe8Y0 z5D3)B1sNSH+v%OPQq%w>%BRR4s&rcEXjwfzxS8JZbbQ0}uV2#7HQLX6&|rgVs?WV+ zS`Igs-rU?#*7&~N&_wRn%MROZCe&5X81tKtIv9 zXfF?{Jk?+ALVu`UBxvl9VdWcxO1jRzUFNsE3Zf6jGlVEpl!i*+Wq{W9zpd9OA5oas03v%yTs0zZl^-G(&${ z{Bn}N6F%RvmnqkbA3&g-RSH(j7cHW?hP@lU755tI?Auv`M74uTxoIy2La+ydQohBCi>A&8;2y?X{$y4+X|`gyRAP6rrR=)- zr?ltXK{IF-Iji@wQf^1qO~}U#@0i!9LD<^9fmqT@;T%2Jq>{hRC8am)KZtzh>mRS5 zeS}12@DMI?9wd=G#^LZM`fu$GHm`2Ko735;VkA#Wu2>4DLvq65fQ!KIE9#7{?_w=?cS52;Wm#q#3-o= zQJ=W$Z~7?*e!q;A6~JZH9RN9KyEWBjWFY+YbaKW_+ofzJmaRf9zQyhMgAeyU_0Qi9 z-7R~Ri(LPQ>Swa_tIo7_Mu>m?btH$@(LF*mM+gZ|Ro&%?CyWC(LFY9QY=msyK)Bt& z)Fjrq_c= z#SVmqQp zH6Fg!K!7TC9mYw+c!dl_JrtB0I*0IXmXCu>XA>b^%V8r^JGm>;*;9>@L0Svq#hRZ= zXrN!Wn%c<3+X!+tw47HxVQuG7L;U380iS1$bX|IOtsgXP$hXMhFnXh-z7D7>eiT2U zQc3+)LXj+qxy`UQGvT2^j`1@D>^3Ne7a=+$&V0~+)zLn;rEEY%d7$OO$M``)RKWMS z(=t|_zZ~$@yl`OnysOIz-g+Vxv$#tDxX1m9gBe`JIteDrG(&b`w0p6jiDv9UV%d7* zq9t0!Q@)C?3b-8A$7}D+JItHWH`t=f&V{vyiTgDwv8x{7?X`i;DkOJ#XASWdN_JFU zo@mIPvRufwymsL8t0UvaS$!pv7k)vHJ%49D*lphBow6W7k5YcBfiBl1+5JKi|8?oP zzc4c#0Dr8Wuux=COK~#T&mI#;DVvPdZ1V6l{e6y9IGD_w7bt0Js07i+(Gb!ER!mxU zj9I-UfM$co1N*|ouFq*N))Y9R8gZ;qEzujrAi-%uGe%XIv3(vZ5m7!) zr^3JN(WLk{qqqt0qS3=75g7qO?}>yoRJ;k$L{qeVs^jTQ6u=KFwY%}iN*^kjRRIA( zbaSAAi4MdwyL0H@z<1)Ki;4M0N%*{Qy-?Exs@+Ye$f~s63D@@A%js;|BD0BQeB--1 ziP2rc4;nZrbv-rg`?+0bPcuR+KfMdaC;Au=JT?lZSz}oh4wkKYZBTj}0EiUb>N-7U ziRz8Y^uCxWqPX62APNV;0_bYP{N*a1O96?%kn#k~O@NX89 z-Fi_S-&v}U`1EGldOH*pIvz#Y%|G|KE}3(}^8YwG_duq<|Bp|rR+6PCGN$+>m&(#* zE;CAQ$^BMIL@DJmw_LK3q@*pkLKrb~Dc9UWZZVfarUU#0S$EU;@bLxpV!Iesd!kqA3K_=gn-VIm)Lnm3?OvKl(@Y$89w|33{6;0 zX;R}qqMm&QM?J${;ATJClgeP zJXc>D?DRUVAX=Bk@3<%$-7j*h?B~BPnkT-*&r;5wI8OAMXNdK9wmt0FzxbV-gb>R3 z@xyfyoMxVqMVVUAhI0^l67Mu}EBjY*d1jH;%U>5H5&QIZn24RFfh)BNbLr}v^0!Y8(gvJQWA7W=zOCq1`_=if;;GO$60Bx3*k`@xME0rU(mbUJ zEyOhLfZ4fiFtf2@4i{&7H}d49W12Iu4xrR^v6>UXPbiZi_Z6eC>ZBm!okvkTMWp4m zjB6*8d?)a}WnOKt#R5?nSbHky-9(K*SLexkjbO<@k@!RATQ%uQgDbtOIWks6IW{Da z`~BvAiUd+`!pAEutuE#3n7(!m1d-mdqKr*0X!T`|0NkbUz~`vmeFob~=4oR!g&!>p^w z&;LQtL)E-`^xsM&;d+>a&?|QtLv}Z|eZ6>pk&9i?i;Jv0w~dg4e*F&uUoWwxXsit! zo3ClpcfIM8@b6SW%c@CQ^yz;)s zrKi-0naN1#d&U0$CJql}UQ_*iE%-4Z~2Qw+;j+-5eQvxetVah?)Flj4G>y3 zkIR2>(Hu_vthwfNXqTwgQF4$E^b<1_T0Wn$Vd#e@fC?xV}MUC{3QCsM-^k= zuWB&aG*=#5!ssz0O@L(bQvEtJ8NC82o(CLbjs+e8TtANe2eY@A^@D7cb64G7Mo9r0 z6u4DZZ4Il3P%Qoqy%U{fj5JpeWLELH`L(OO5CVBwr9V5$Gqini3B7vguKJCWj%jd0 z3wa6KnT~0_X;)bAg(NflC$Y~V?k=hPuO{Xs~FAm$(?8h zP>N012p`lLtp{riluIHbAmIb!I+HR5Q+LoH6-7_0w6C4cnTrD-*5T<<;Vbb)gLGmT z;gok5*#C%N6aj0uZo?Wj7rt~xd2%_dp@UCQwxs?@HLD*`-JKQpiWmlN7EzFdJ^K1J zx%G}}I6{nG1^zAkHtK$2G>9mq<@Ymvwe>H3ek9tT=vYV4V`(Lz`J$5sI7G)`kca$T z$Q}|!ug+f{usr%oZT|Jn1Zeozpk8HE11%EnGUEL%&}QP_{8^Z`CBrk>wF=HK7!Eev zd4GHU?D->iCueCeu;3YWJ>&Q!B+bXr+iP@e!jY?fN~KK$c>Xm?PM3ga!y&*()R-Bq~a>^Fc2{MS!RvYmIus)lKX1|rR9ynDs`RW5@B)OJ@y8L=x{ z^pn&+>AN^H<&)ne4v(aHBF_n7O>ulp{I++O@3|qB7tuW)Kjg%!aimNcd@^gGLEKO| zYBv!AvJ~cM@$gxh?RlF&Pv?}Us`=LWrQw}^Z{!IhR-whYAUiH1eG@?m{5Cep^r3fd zkB{zl(raf>+2b}X2iNZQ1!1S|XgQc23PiQx+JODWVBX6_iB8N#^?d&Kl814FTeUx&}o3D^4 z9?#u^IKgbe(`=n|-~a-o!xXd(kbDE7u|ZG=$mOu24V@J))Z&jQLbp83`U%2jTcYy( zxm`JXdJu$DD}0rFE&1m~jWt_8+_Pa_3fjkjhbC-Eqay)H*}u=vx+btpR8#i1lI}lH zLQsT(FBZsMsIIIn7eKyE@=?8MEcbW)CxXdC4Vs+U#G5m!s+f$F_4 zZTPmdB#zYk^J)#|8S?c`jkQLg^eV0yLPZQR2B^yts1}>ol)4+oRUSOOc~#P;1NnOa z7^!%4iToDF-#`gu3LlIV<^uEyhc*${_b$dJQdJ^|8IEq8r-NNz`(lIl3~7_|?orR0 z`_ef1o$WW&l3&y~?Si-u0RIt>-rwK}{C_zV({)}BJQ-(LmDAX@heMFfhF9QN>yRnF zKeCm&GH711^_n(6&Ylp%2OB%73k<843p{nuJzId-P@W*^#sUO^So=p>`B^r~P{ce% z7p0xsUH`r1<<|*#wC~q9GBo-BK}vyKZuWw7B`V4*P>?Mv$QjVQ2@-uX2$iNokK?*l zaga$NNorz=CtRCa{`N&(9+}4XcC~xqXj6a@+FW_GMy8?X8yI}pE5t+TvT1nea^dB` z??-5kICAmopE{Eb>FKyt2gh&MQ|kA=EzJ5TG@OxM?%;cwu83{~vy{~Q|7hT{!YJn_ zXotbTg?E^(RxPnTXk%_*$Yi?gHn?_8g5JWW{eU>I)xy4GjX?)rkFYLJlm@P*&iYf% zq(ifJzN*hlDsBYv5<~6CL+Z_&z>Lsd<3JIdO0AlhQ@PfkQ&cc0&mD++ktI=R*gLh+ z(Q!QYrpWao+yH5XO??sYRyuksc?R1gCM8FISA;h&ZQX{+EW01u!ZGOe#y_9&wjUPB zH$={|Gg__k5kXK$Aa6FcKZ~&X^0Ck!zSbr=v#7x%u9sjI3A7fLSGF0wlnq>9oDFik zS(Y02T1#j(=H%|-Qs#fe1s#z7IeDD;M$+R1g5753jf$e@cca&1kg!EoFPw@@zy9WO zxy$l}aFXT5DqE1m_U+EQwA_jmlRezpsoi%k7;)w0`zpU@*==Kg8prnz>LiU0U)Q_6 zOY9^nHe)j4^1bbLCE?jbIC6o(5wf`Pjg%PBhJ96xJQSO8(nHMdIXlJcs=1K)kj=w4 zQ`4#g5I50`hBsA|+Z}!hoX(2LU71HP!3WAn8hhGUD2rD=V?R9i221Fj=OcYd|~+C3-NQ#C{UHd?p=p>)Y$Pky=!v%qKP=M$UNf z)L|1Pqa*%YTvNABn!TC=Pm>!8oG5KK6q|Mcdk$hYGP79ov(WL)ytT!vU5WpL1bxf* zd|aF&*{v1gIy;Q*e23Cx$c2Xh^b@%|U7{DdeH>rU#UqyHuiaDid-Nfa9*ZYD4dSUZ zr4?BB8FAaKDE1Co!TWyc7ihO3z4G~fA%I64)G3{~)#aYsgin7PUl z70>PampYJqR}v`3LOw2u87&q}9Gl8*lLoQkl%T2-r7xEP0cOyVJa(a9%VQ%;V)a%T zANAk+(+V%-;fZ)d-ezFYzk5h`zn(QKTblWm(3}?9wkL^Qgwdg)9fBSk=^Lwtjj1Zd;vAl z2WwwA9U+Rr3JrZG@6|hD{*>k_y{5{NDzLCS-kw+QmhQUHW<}g zP~~Cj3X-5`nUDdhWQNGh)je@!)3_#xh(P@7=ISa~Eg%ajWR`kNLxII?j5`$(;!IHP zp9qOYh&Yp-)K_ybc=BYZg`w2u*iF+AnY!-HATYdFd4 zXsj6qORlg#v5LTBnc{!7C&NO46IQ=20PfMKnF5Dm6O<9BGod;nU9Ma`6|Jb7g}VAln0>@gcTY_VXA;-wdDvhBF%Y z9*z`^HF*Vh3=HAA%$Qcz89y+s!6JXLiKb@)zSjgzLJR{3-=QR9nCcNG@@zw%NYG|v zG-sp#wIhK|^op5cIGVA{K>mEE*x;4M3rMtrcM;HY{4`)YECxeJ&YW0T~h+Qui>EPG1NLgbwv zgfJSci~ws42s8tD(G&wiAkM9tu?vV{f zm3X|gZ?FI{YYc9+)gs(lp4NAS^P}-=aD*a-3ZyTCJXBSJFIH_1)gH-PIAnSJk)28|3-yW8C)< zuM~o2aR@Jl#pAF3RzTj3-@W}((xaaSko~pc9SeqNUZIP&=D!`hD*4XMv!!pD8VV}T zMf)TaBVV=p_;_UXO;x3$@Ynjb39Ngj>SAgk%zHy$)mpr?{QuO9T)UQ?bp?|m!Z43# zHI(P<_N*1-Q=SD#P8(fJ$iQ1Rwi>vWZ`voV4Ng6QTxnK~SHzA;+rB0G=yof~oj&vS zgZqWv(p?vm$&!u7Be(Nm@(mIp44WT!Qm>vYmM8a!fQaNhiC>})Upk^-Nwu{AKbe#cxf9L8bsl`oz&l1p0< z5#qE9{(TJwdjKXb?LAPTvcQPgb((C2e5v+j50g5<{Y(v?9JgX;_-|{@8rSxb`edcA z0R}(K!wT!H%hs>Z*(}x-j*ohWjDZ#&EM#XI?+n|G2$XPf_CDX9Vyd|DqDa`;J&T6s z&FtH`OHQVG8vZRF&1Pi$R?^XZ3lY8?NxQw?3O&&!jx&j!i*G(RB|lOl?c*byKfcuK z7i+D5K-@qQ53Q7RJI+X(h*p$2xAZg9-MXraKh_mlK}0X$>q0|r6{UEdzouZfd`Z>$ z`OR;8|GLYGi&DGLnCG&OQ%g^W#Th+?ZBPG=p5=hZqrCbw-7nwFCF1-8X`+!uHdRLu zDRcj#8T}%Qk0i}qHnUSf?#Sx?O%ED5HSY_*zB%Ei@xC%qbau&CaNnLNZ5__YRM& z3CJIgjgT@0i2@k9O$%&&#h9D-MT8@nNTk3;!-~eObH`I zp;esO7@sZm47S+A_qa~_r!agXKbf_)GV*@A11s(OYz97E6EC6Dt?9-UhzGlaJBzlZ zZ?W6+%6U;0?;(8SsYfJR@po&K#3XT%BjpR;Zp><}fJf znc@*fG#S*uQZ7UjB)35Mx&rbD;k!N1>PA5ZnHd8!6~zL>;qc5IG7U$-Bjp89JC3Gs z!h5urXzYKjXD-dNvC$7m%gP+f@K9Ic6E=evbI-D!vB(+>q#^s>9Cv&#uamBYmyKM` zN`Sml2dl6dzk%9jp2wQYJqthjihS;;+&IS-2if$JL1*ip&QO)bM9;<)M+`{P=&^P! zUtoK?v9f@sl%;SfXsuCulXzOEfujG;>b4^u`%;U@hoc*T?1Um0$!id?fH`ADHABR> zHsWY#JG;l+rAIu5g=?F0Q4T7M3CGl) zBs51ZleYYo`5|xJJAol(7;2bhxo;;yHeCxSyasok2eO<9P9XPIV!%8x9W+M8|7dhf zV`(E`QA^3a^5e5B506K|h26CLB8f0-;s(MB8LtR=1@l31;Pek>`HwN0TLnzojg2LH zMYHl?mkVR{uhdqD)KDZ^U-8gJm8BSUi2ZKa$VTziBvH3*L3CtcyQ~35MdBGHR6cv= z$B6>1aqJs5)tNjs`f6L9$+@^6VQ^FH&yHc(*I3~h4U05jUL!t-tHOkXonNYR81@b5 z|7HTyy#~sWK|ZN5DSZ2X07Wr(SBwuhob@;$Nv`X9v8yb=3pPyE9Ytqx;&BrvC z5oW~+|CXaPbg0@FwdLPAwA{R$W5B)M3^ilK#gV7XoR^-MJ~lcMKDg^wW79em>C`{FL+g$dvQf?4vUaS(@n*`- zJ;$9P5Z46yz-%hcX+}If=WB;l`^cok$p{OPaBQ?pG<4QNvJ$mJb{~qT_133-b}*wN z@DD;nKTAO&E}}}FzK13`|IJpo%!nl{ukHfdyK+#vN@OXnTOEv9FW2CzF2G`pCgTrX zKs>hDe;|^EDQDSP8DBpoEAgl#IjCuev1B9iWY{vwwpmH?wi*N3+&Q>PGmV@z*vFra zS5-MsbIywq)yVNh(M$k-5pw*Cv)26hlN%|Dl2ar)$9jF?=20u$$MB-z3kAhj3fU0R znu5*?a#Ml44@9#GdM@_Ogt__e#a$x`QbP4GrxaRoh>_>PcMr@eY9X`zrE?M0jbTx^^mZUP(Kd6x-E!@B5vKM{euo?OsE?c&~D-J02(eP z`LU=&2JJJBh?bh?_FZ&6Ci%qg``ZjcUHUht8b}j_^)`wD4YvesfC`($TZ0L|$mnqb z3`V)}Nit@vNc#sCC9`va9~xM=V0bGN=*EIWmlVy{mA{NFH*&+ba#VrDAztaD$nP|P zmbIzQb-!LbIUs1>P%l6^SDkcsgTW7$V? zo_W4j!>zx87B3<28HrWU1Lm|qS@Os`RhVc!8NH?efE1rzJ}~O)+FLJgR^Jd{k#!^# z+2~s3RX1rfr*>Ula5Wb$^KKqs5N%vE1nUokwi*G}BT1!)e&5D*_W^FAJf_T}Kl@;% z{9dV(n4nve{~zSi14x^T^rzK8KclP?;7v)Qjv@zgFC7(uh`UDg zA{RtkBCYgZ$H6_nfc@#d>-4a$68}3-jvLYbq0dg^cP|^OdgXBN?Qrk4*UGu5 zi8mO-MbU8A`qLUNN7U?vYML0*=9QXZ%6G#ZSANhD+~cbf1*cscEeUGrBquO5M?B!ak1ks8^<#M5zPSo zAe4=qqk2@P70g>k&JLv0#;_E-SY(&@?7B4dnydbSuq9Sq7^=pcO0jDi(nV`Igz5O%Q6MD? zm}-GI*6hcXY5P+N_$rBH$+8k)-kKu-= z_i7GI;X`);hTOL7YN@K&%?5Msr1E{2mD0}G2mgb7PYlc4gc`E3-6lDDEAr4h@YYl9~LquZc6 zn9a@;m#}N<)_!G}H#AzYqx{pCPMhS;IQBRL*)Lq1GxwF__3?;-oh{Mqg6n<6IDCP; z7W(%CM7tRp*1T;&!&w41Z3D+Ezkk&s$!U^~mYg<(#s;zrElU+pG)cc2!>$tN@c<^N z*wk)M`MJPp2NK3Q7)t&#VqelcDXZls${s9%y{26BJZic>`|ji_=Xp0oM$0N9vg)oz z2NQzG>p_TwgxW;sai>zKG4xsfSn$`iS_3CMCd!bmGYn2(9%oguXp`m+N=8{O=EoZt}g7Qdh zmP+l7Ns|@Q20bt2N=%PoGl}X=xn>8WvR1d%C_>954z^6{+JlUkIxt%97EUAsRgC>Q zj$Xyi%XzQ_dUF|=`zGp%H)2uZjI;T~?_h{VkE9PJxL7Vn&@*{D=^I?TcLg<4P?>rS zFr5|{-DZ%?S9&}axIaE>Q^G&zG1s)vwo(d9++{2@btu{_>X4`qnkzKCTqt&}jZ`gy za9yEMOY+?kx}?DB+U)y+KNJ;%!-sntn`KvRab2?TOi3`aRvK}oa=7r$0)E+9t(#Cz zp!kI5D+Gf0xxS%i%F*k<49P%3Y3RG#6E{~-l$bLuo=6Q7HSv*)tfADt@M_s)K7e}Y zyZ>$C`mF-PI*EJ6@){<4<3AdWyiy-X3%h4Gs?dIEcmXQ})&;04N^4*?ZGtECAesMz zyjRwk{CH-~CuGn&@rf^NiiW92&0jtLTGsvBA=$C^pS|E_XBplE{mwNBit;j5C0o^C zfBIctqd!B(URItS=i=tuU=zH2Nd&?dQ&SYP{KM@ALkjHL0=Pp-vgZS23r|pI-`D%4 zpkR9Ak=>4osm`@&ThR*7uWYQ4uJuT5j%>Pb+3c(qeDMTbot5`07nZbqDm)cD4O$>%uLdTS z&{;Wu>SOYm+QR#9<abfvBo*%$+-7gj6A4O*-xzzP~V>kKdDhFvTa zel-<>-;wJVxdA%1D;u^CHTVR|+2keQ|L_RRycQ*LTy809#VTe1o{OM}-1qJdZ2|y} zJnW$hWb;M7a^boAy_7u}W=D(VD7A3VIDLV2B+-j>5<&Zv40uCIr`5wj+k4BNLff7q zIk@P4j^-vJI^qN2!oi%si2*D%CE2;6L6Y3SIRL6SCCPxYR=GdhnGX_xVG^i7NBpVo z*puUGr~x8IS&Zi0!?~5Q3*oxmul;X=F6Gv3V7tT_$J@$zPi%S1_j{Dc?fq@2mr)nE zN_Efb&~^?5aMXn7-w(e&rbtBRq7+=Ks@U_b#|$sV0cnzTXsGOtv(g8Y--ssDrsxz{ zuPgmbz2;+xAThlmP9iIb=3a~h;-;VCU^L#dD&C#UkYZ*c%_+x%7!90htjXJhlv~a} zl#Ky{W2?F=G7ParYs@=zr@GrJFK8Wl=ms1L>g)4p-dhqI&?VR3MbjbEIeyk&OvN<9 zMZsC7iFU2*Z;h3s@XcWaXA*yXpqr>^phUzqeIRVk8WV_NC<#)mUto;xq!`DU(ex+VgS#oe@3qL1_pl)KpfY}P9NiY^w3r1(}Md*Z!%@;F_%54b&Q8QhZE zt=ik%`$kJb_~x6aGb?KkTc=N3AnYz4vI-Sr({3)c8hE9IfLq}w?-RK%<;>8tJ^b!6f!D8v@H^Z56)$6kp5f%AqtPvvW(SLnX<=hrN2B^ki* zvq=tn4hzIe1wH9wOdt`Ekkk&nRr&I)Ys!!H_l|*$v`Xv|l1Fqfj7|p452l2aYY(<( z3m7H_s6sa<8YO&k-L3Lnzc$j$wwBsvEk4fHPOYwOaR({ZsZOY2u*Lb#&81x%1d~~( zm#T+7m~l7NrXJ3GB?I#zo*u;Gb09o1|f)Lv4>(e?yJd=DFtr}UnRcrIEItydnl}-j?<0({ht-8$m>rJV2t@hvsEhSxedZHMMsjfV&FwZ1jm1 zwGrAYb@Dqwz-Q#PDV2}DuIiU|4W06B~$`DzTG9Wd(SeV9ZYi*qaxZBs~Dq&hvo&Lco`+_7V?(>?m+fj z9C+^6-M%u5Z%*-*w~a81O+$N;Su{yrkQC@g=FEo&v!-E4`tk?Y?Zj(I3+F44200&xV)fTAggR|X+Ia6O=P>Z4)R#*Ny-KwUprZi|6cCnEZM+3_Npq3KZ zv?pJCV?FH?^mdaH%cM?&f|wVj)gy!=hKTsHSiFLh{lE6PV$6NOEmU;M9hQxWzJ{}p zlwICt2%sK4ls(5zYmA2iY}Mx^YpPjGabNfszUF{+<_FhqB5K8P(0Df_p@&Idoi)-V zZNQz#T~t5^D%9O*CN~Ns++M*HWe6?o;$!}t+g+}#d^=mEmC7@SFdVH4NjdV!*&hTe zmaUU@HCVs_irrRyg?Vsakm(XX5GwbryYrJLMN(7C^}lAUyYJ=YDFj%kDPutzhMnvmg!mWv?#VSz z4hdWXcj2{)iR!C6N0X7g_AhSk(e!TTB6LnCIplObl3?dORMmaWUCRl!Qy*r5_`2GV zbms~#&5s38OgBF$+fXo?J3LCLGuK1oYIipR!2~|(#$QF%;F&8Hr{Q?=A8ZRncUf?C zKK4%iHHWih+M1lG*SV=+pK<#C8^$dA{i`q&`^BTw!i)=PJn7@6C9I`rp zy}#?-_twkjaf36APgl2ogUPk=Yl*9Yp_|r`1H(h5a)}YNURT*mwfuZ~lC1FcDU6C6W38^QwO&kHl|c=U@vxNZ)gs5HA>Dp7?-fq} zj*G5)NVPe6aln%>%d46vx`A^=`^r0P_Y%0mQV_ zoniTt0RRys9Rv`U_P!@@Hva2vN;ujCUuj&ZaSKTm&7L<<2O+EBR9~6zSxYHW7cjaq z31I^X6m=dXp147f1CygozO{chXbHiKH<;;=!M-gYJ$tFr)T28o z^R?V!{TaNV_bCfdKW+e!r*-QjUAqbg@pD>-tjDoc^bJ~P%+9x|(3{6^RcLE_xgSgY zFL(n2EC!%syg!AU9G@T>)v5Z=yE|TbKuS;R4GHZJo{WeX1BRN&Xp{9UJ%vZt&~fS+6sq%U4oBytuDGYTP|!Cn_`d#y+SzqgNnJB zkEQtAU(+_QI3Zo^I-KT1=<&!pmZGh@x4IiGqk)DJM{ZS7UuK`p)+oH4oNCss8TkSaKaDq_#t9xVjG44)^zs^W2$9WM zmb-VFSAn)%JRSpP;y!*HTX~JWuYgNp9scYu5%s%&@?&G2o^~1Kg9ir=`LQ3FMN%W+LAF@>$Wu~ zqE@kUQVD0=b2Y$e0`yD9F>{0{n%9t7>;FDEq37_#{x{TDM}z%_JfnE3e37%NslrkpulOLm1aFPzWfUN%2Xzez^1s4}&3~STtx%tw{H- zAtP;qBLPdN+-e&U+@y0s)>iM`0VYQtOG{_u-LqC}@TVUd&1Sv%YU5G+ON%H-Y_R7yeP;QSODJHS&q1h(&B#S}D-H9#jen0TXkm{8X(4&ucf zc~gRmY>;Ig&A3k55+CJ%X26!)46w?kjO~-LZvH$h*5ie=;;kFwvcCz%bk;xPTJV-0 zCdEaPz5WLQ?yWhp_0bXsOFt#`)=i3LqyVS-iu0^C*d%HiG`2PIXnqjQJhK%B1#D+7 zP?%)qrksT8kcqH~VLC;PI6Bs~$_=Du{8|G=!~l{sWl1(SBb-{+v^{of{B_Iq2zrAT zjP8w$LY4P2BO-c0IU8^wewPUv`;lB450_0UiT5!)l9d^D8Yv$#&1nAg)_(eNXLs59%5z!k99 zCduU&vlK|t0g*9>87rtq(*O!l5&t=xRP5ax*@z_q`EN4UN-|WeO??&|gCBj7u`fp$ zq?=tlCBjLaWCq7NL-&T?!TT>%jbI7_rz z>>NjL6^*?%$q0Z6rQXCD^Rz<E+7ga)R~EaM}L z$R=1Xp$kxS;T~^F|82omXMf)FxIRcixB>?U;ZwsdadA?%|5?3OuOnH@Rt*! z)U_i=2q2Z?_Rn4Vs#PyHGV=S|9>e=GBbN_6u`>JJa86@SLPQ6Qs&_4+Eny_A!1Uwv zxx$98wz|R)2IM$IRM`#-$ikqRWU4R;teKbcEn<}V6G~0yhvpoIos6rWK7%J2X-y8r zA5nQ$x${BB+scGq`?LI~Cp|sm7*UUE(Q9>=r`jC~JwRU_a5oz+9FA7de=Jo%$$}A3K&TLi8F};an}ePo7{u-AL$}UnlTa!BkSO!@3kQ~$rd8@RWXBOiklV*y9eQW# zxxF&(Onl3k2U&*{!wvHwdw=m%4n@aAo^?pk_@Ekmt(AEs&d6b4&tKyTgJt!Sm8QJK zgSt`>3;aJuul@T`*5LQxyPDOuXv>-ztFiW!Nwoz&NI@Xd)GuY{SU{7J_hO49y*(uAg@Yj)oG zATZGD1yx#LQG6I|Zq#4kST_8nZr9}Vn-Sr{t{IWkYyG9=eO{ASt=iOb8i$43xBa^# zveP6jS$tJ2JDTt$V-5ctvOA{|(~;Gk4-Pe2 z=+U;rIn$9{ zEkKG6$&Fp>;jD>2S)#E_FP7o9q$}jUH}Xa3+1@}PVv8bTG1Hd<1i`XD3}53z2dX@eYb z7DP~P!NQg2O^%?|WrD}*7*1n9T+m&AfF=_e>?k9yh4gCQQK7T1_( zj-3F|uD;^LEtvbw5cfo|_@m@-FJ%$|6!uQl_QJT0d_+uEDE!%}iH{W-f3U}Xq!r{? z>iWqSwnOCtw_VtlFyJx%@Izmu_tt{+tmVgTC_yl=__%5o|9bA{+2BC^o7zuO#4O6) zJ=9N=O!sH98(BXKjrYkh=v=X(q7XNK+O$%&42Qu1-5%wiZ4XbU4*IQPGy~bZyn`Dv zA%s7fQ&<1e1O+nx&v92eee+#T94Po)*f%l- zbC)_P1RY@I8{%@a7mtnRunYA?oPmb*6h#fxU^-88TOBEKx1WE#>lR>j;gs*8h4Bz} zv2tDS+23Y>@0-@!*!|S@H_El7^v{0+RiWm`qPSG{4G-ydLa1y0+uhxNEmfP3*JVCY zYuwR|;-P2mcb(mPW|!N`iu>28ABC*Ye^a_>X%UB$lyy728cux(uC9DreqHu8{8CWG z`u>)@=~M;0?R(#w-{giB;%jM#ph#8S$GD91ZUGW!oKE_G8Pa*8?NoNja(r205=pb}=)%Myt_-r6 zL0_a`-=P0wA3FGC#H93x9~`c$e%)hQa!_K9m!eYk_#I09+0Z(9G+x?S>+(U# zCbpx*KSzGg%gK1fsu?i7lf2Ppp&6jTzW=SB)Ka?>qJr%@2e$sE|gnJ@h z(r`Uqp@=XQbi3rgp$4p^^fRexzu6d(sIr#F8yFiQkcY8ZS5zC0g9ZY-kr8Wm(TicS zO=B)|S%WbpXJMZYE%vPLsamGWd(PGPWTG4yX_E)&xqDTrwTRmuf0@_4Q1ovhmH`Qz zH!}Pmo%89|-Y-R&o~lNOmD4{5t6kS&3?wiO!N@3?ofO9`8fjU{9H+R8G3;)X-e`O1|%@&MFPBV4IGv!l*{B z^=Fr^h0gVHhIg$W=wVVlrGx{^@_Mw3)L_6+MCig!-HD6gftBAs&PyUs{eiPCBph@+ zXV#}qOy3+QbrxgFXwX;nxGLz_fJ`IHj5xaACSa%PQ|3Q6#8VgkPgY-HTwM2i3!0>N zQiR5E=eR42mc_Dv0&}_0q#x-#Vl+XVs71gj4#!LLlk7#hQ`%rSj=zM~HZ@UQ*k5fX zj6W)>+`r53wEWGJ?v1-8r581{!G=VGx)qP=)hlCud%{3G#8n=Hxp#VAU3@b6t0_dX zLmpa*73#H}e5PL$V6Vd~f;3uu4!4vD+h;u3RZVnw>uf&i<(;xyn%G^9277Z?%e<7o zFLqa78ZQcBRfYQ){;Vj%{T*)J7N4^DO9tY7)x%PS+a+yqe*s2e3z46a6sqn(Xb6krI1NSZII@o1W!(9W?@nSxHdE(H7VE?4v( zUpR-^tz1(R$F~LoTQ-W6bZ_I_Po{p;a$IvtcXLT-k@Pw zGk~o5K|^|qV}v}}oM9F38?24MMf^;!f9SK#H`u7LJM0s#L-uhvXJ3S*#kbc6ZDZBu zoj#aG`DzJNR3sv?Gd|e)i^TZ0FYY?Ol{)>7Y~OLJO6y06Xp?S_OK*Qkrb-gqKnf=J zDZ{YB#_~kmB{|O`4WY7@84PT@u+5dX@``Df$PX4^#RD8`5wnEjGBTAo za{CrlM#nsPX)sK=ovkdVW0fSBNuZZ;@lc9smNBEBv3q%SdN<8UFvztsT-L88dF^5@ zz`wd{+hqFvtMxLRpjT=MS;d(W^1v<#<{Rs<4(f6nON$b_df&C~B9 zgovv)AVD5RngR2qr;dR#=g%JyPikQ5}jEFau4KV>-fJtK=IuQS&D{&Hu_0RI|c+T1AXHDf)0KBGRAe=i1x)Ej_= zeFr_?vw5<&#zVk9(R{0ZgCEHZaB`>>Zt-P ztJs6A8eK`)Oi&L6C5nB>&lJUcw(w~G6n`=XJ)+mt7Tktz)MCwR zWAx5A`SiZRxT>HI4KGaeMVsFEm^sLQ^4f%fbKots%O8?KY6y`u6xL-UseNVHZnmVq zHxmtCX*r7x(}(h>O^xo%K9w#(ag=Q&Tdojw{%v<#YT&KqQ%1~9-KVu0nvA;!Vi>%ttV5$obX&Ysg!Q!L)`Ak8QtfYRQ zd`WZMGOv0ZkL7!K``Wd1wpI*Gc}B}AznbBV00Hx^>@0K`y(cOP8;c=K2w6R?Z0zq|aoSEB8 zJ}wNmIOk)ChWKxFlf&izlNQuoAdeU^U{Z{~dv2l@QUh^*rOW#y#L|`j?s+!Fe`CB(|Fy&9vqyQ)r~bJKA3$lCX_uDY zlal`Iv?Jhu5WnMXr*zf^P74}Q|yJ9T`iB_#+lqE+7t`HI_vCwDZ4$o zKRFEb^M@X+rDLrs>dOyY;Ml~yvkNPjuRP=2y3>{kI^hZ)*_Vc&dQbxUo@)`d}(z(Yo-Tr@k zQmupNKvA11N+>m?Im{diNtSauIG0Ema+nwqC2h#5!pLC`A(c}qrx+=d5g9p*W>`)m zo7w%le1Cu4k4Jaz`{Q%CuIv4JzuwPRgD_Vx?HmdTpl{SMKd;=fYs2*?(R*s{GPk{a z)P#nbM_hN`F;TH)7xvkPQVhfoiJ$Oia2H z9f-8((&v;r1G5&&*K3Xrx1liwhQD-07z-ezuDV7vK`dNbf{w^izAysFIu;t-I`NV} z6SC@=vN{o24H9fS+j;FE8o~hhHgh?|PbiM?yjdu-!go@Lx3jYE9wgUS-ad`i5|o^^ zYGLq!??!4z>@KR=`%h3TNa)z*KO3kNaQmB1{RMxM5S_Z4jmcrQ^=10!U{ zkD%Ct=>V=FfPy~Xho5TKKbFDvcIL3UvJ$YW=P-_7{yiM+%*L1M+!<-3_v+nsDZ?Mv+?M~F*dvb zb`d|&KPoCyBKGUQ75`K_rB_&J*A59{5|NE1YQ}7;rJxOs0&N|n-w!~_kEag=oC<7p zt%K*k_Iw-tfB?LHXq6+={e-!F&xmA@=Ylb-R!zx72x|<$7UR52IOMS*9hhBCnW|5< zl3dtRNu%Cg%tWLErQWg)Xcl(^dquOeBZK%7F2eJ7N&w8FbFmmT2YP7AzeCvTS>k36 zwhEt?1Gc|*JvnVc`TbuaY;TZZ&k?%DUGW zsTlsPrdL*?agBnqITtdu7<9eS1u19woKsG>Pen;hBA z7=gJJ8e=TTse#l37I?I{*5q=LKy`|?`83V!)?X1=pzg{>Km>}S>u<6c1j8*;SNp=h zKnUhx1V@!>4LZmve00a);sX@38uPz4vTTch%OUqV&jL(3eEzNz5Tr)y<~)|=B7ujQV9WYiq9^Ubb$16t=& zu;SMD)~2VVJwxU|alwm_Qt{k|tC}~~aRx4{_>S=+rBh*U*ja(~(?0b*p-p@OQm6s) zli>|O#GbQr+%DJrhMj=-+j9OrX>wiVgBsTDTgp-R!F{)blQ#w|F zgs>Vo{tOcZp0IW>Cb3LRMo!KjAJ|TDUvtZ0MO|KCcY{@LMxxOsM{G14M7gyWw#BhT z6Ug&`lxrfhBK!GwiWo~iK?wH@Y4r%WxnFKHkf}$W_`zpVc<5qWyl)L}r7))Z(_8I> z>fLzPmu*{h$X|&Ob6D_&mbEE8y6!Iikqg2mt1h(brF0E}v0Ap7gb$|R;+gnLISdil zfEsOP)`1U$T(MZvLKzc+)&5N!m=(puSqdXE%C(;u_2jCkfg43SA(2~B?@rfMCDN%CWYZDpR>+|^cB6g z1tW3ls~bYta|UAF8)vs85lZMUFlvW+pk}zT%Ydn(O!*+qT4YLg;c7l3`Gm)mv4E(k zXm;x{HEj=3&_J57J>z!#^WE5l{Y(miCfFh;gAkT$3vCt)fEa%DwzMcZZX5|D|D4h* zmp)atVaz3_lngV$SQ42gbtLIW=Y2vE@KPT4oARH${qOAz6)%T? zhba^(7QX%D! ziX799R38Ww-uRqq81{hD`6P0yL@dY|WM z6z^ux+5Kb+TsgPS^4XLG_Mbk7lp`oT;xKqiO_qhOUjex7Igo&~fx#2n{u0}jSNzB3 zd-%-x+m6YuUsBPlf>q8;eEGE+5RaEw1n5+wL2a1z8_JqK02eLClDi2M<15J0b;~LuNqFvY|l#S`idM1E8+&TSx|tY%pFHCtco$HR`;#+*`e^kqQS5 zX13j{XTH1@0gA)7b8V1eg8?(&o@|6Pi^5|rlzU}_mBLeSnPuwkNT^w9)y;Hk0JQqP&$Vl-?9X^OO`>A`ub>f%a5^;4sPa2 zj^Yzym0~6d5}opki566|xBSf%06S#6x4 zeh2+$*@+XrgCk~jXHOqro7I;Gsjhf#Bh~C{W7}W9upSHMfZqwJaGgLw!yaC5`~Xlz z2XouynwuuS}spbf&7ce&>#(-3yiz)6x zftQDD#tgKaH9FXHq84sqNi$$y4wNUx_;1zX_xLa?s)1LKMxldQ(T{eOPZN&XUKpx= zDj-d=TeT+KqR3u_W%S;A#oMJ>QAD&cX2UpC8Ms{6FJ?3`DHa{wwN*zXn%MiWmNi4A zbVsDLbb&fBGXh>|?0=RJHU-Wf*J{jhoEyl;tgktXhG2t;6h(1HxNNJ~riqOOxKO!P zv1Am0icoAug`|@F7Hl;Zj3@eN?~uBBD_N_Nw$Z;V{rPW`hJ4}|;MTjLB73$`8ASDk zLvxDXafM`h!UEqu>6(PhZCY_Nvq0+mUgppNH&Qxxj@%+8D@X_g&Fz_>m6Dg0U>};9 z1Gq*pazBNR>3Zan*0IkT{_|Yhb$`8D>S~14m0I)#`5HL*+>qo1KA4RJ4eeaZ%u!Yn zy#Wix8UvM%XP@`J`24WjkAJwv&9WJQDI(`f;c_^De&!PmGK@iEBk4jHCcRgJ&ThT^ zGj{jOI*PczcK>;g<0$YFuS2V~3Ce$*aS49vY|t(>>wnlgN|4}UEc7_{yIimtYp)AS z;=6x`$iKWD5%lBaTWwN$RM+p3^hq0L(C9yK{R9%*YCX?qD~>J$ECiYTT}Q1{e}o}y zPu)B-m$Tm+BC`${R^xfe-%O`FqlkH=3C!pb%9>R*8V#DWThuvnBAG!#2Vq3kL+=th zEn!7m)rZ{|oFB!!%RD~4HIyyHm~}1snWEZ&1;&i=JGp$Mt%@?7176A~U z&Ju+LF*~VBjj{hAkg2@5V!apAUXpIQAh{2a1n|$yNSam?D6g2H&8yED0sHq;-O7_O*OT$M87_F-W@6Uc zHB(g@b@_q(!1B*8GCvMKE_;&$SpQ@)eW~Q18Xp0^aYE-*_P zM;H8gmnZI(e&&nKMBdkUVv82v4Ko3ZXqLnXGMx3uyK%Jc#$YB(Ez1xkIACcxG z3^-1g%rs3}TorL2J$80%yq|LyqiI}end0Ol0uO1PzdDV_<=F2(5yTcVBgaE)I2e~yC4rf6@Mg2w#y>xPSn|;_YzJYp|pPcavUf@mEx`HVzobz}4(<@d5s5 z26svc9bT;C(NNPJ$evb8K4pO?5rC6H$>h2R*b}=z*ZBhRD>xO8D&KqxK4t!zO?A?1 z=YgaLUpB+TL14p;@~m4YPX4R;uHqlYWb~ISe@=I<{vmTn_Krkn6fnTO=&n!6Hy4=$ zL>ua&)MALhqdL8kQpq>Il=}J%rp#`&?A5GI_S_wK8P$9Voap++2Qw4e*f|#1?XY{7gYqoGSIG_u#8EVq34h_o3*K`DtKhmC6-+a^z`aAZ-e_ zu95+=;lS~G19=u3WKQa&V1*4*w8xF?zgZcuAC7c9{PfN90Dy}4_g(j_%N&=p9`gDM z3tD55C%dtOK6JQ%1sB7PBF#8qbk$AztlQ2HwsvT{EdpE1i0MP#3U_5R0w!YH&Y^RKj#WMEgNnwdKU$PP^qyCiscPyTCSx3Kz_~6x(-Kxgn7=XMfyBH$9vavr>xFyvc?a*q>Mw!c1hI)%|XcHLa z`N{#}jXf*RjdxvAGHuu-B?$LIe$|7e(oWr3g7wX?pI4W;uy(HqBsk}PW135jrYX52MS2?Ulvfr%@{B$25U9>Tz?DDdRCZMiuuGk}-@ zE@S0SY1%|23OK+(VD^?@vHGL;z?D+D#V3<5J~piAUh~JC>g=hPKW})}BUI&u&}kYVjctdV)}P8L*;=n!sxY22b>PA3)qoaIpvg$h%>%Ujp-)(WLu05bcsu%L{>j0-lQAS}qgQ zPpL6Wj$P_rS29tMVD(GZ3IJqIl$eqOTx_erNTC7w(Y=R5Yv`p{|C51v%(rRpxUAmD zm8MN7>BD2SHv4THqzbkusA_SVs5wHX3D->U4#FZNBZI)-9$jD%dq2HJ2`T~ov}h;P zw-I1TgChuCdY^^8wX{ysQX|I%a0kVkgmXqAkEK{qNvVJ`zzxa}IBqOp>G!8_JPAue|rm zP!(Zrq{JQ{odDvmb+lfp=+uRJF#cn^2g4c}OnfE;at!-Y2Z&T`ey+JGOaf$XWT!NT zD{Ti(sU=3FQcMCK?;#jZZEm(81P$wi>&+KZEYQ?R`FQUH&E5Dtjg8BQtG6NoGTpM( z$-Fy?1h&=hyo-i+Tfjn-59%wR)`l><5lehavJ*&Jn$eHj;C{}4Wp8INI47uL!1ic+ z8lcz+%02-A1A#~{*mSgmoebTWwb8Z4rz*@xK{m5Qv?ZFKld+woPEvEi5>1u~jA*~2 zZ^_8-Ft_rVj29HZLv;CE%JD%66SstNgsOf*&MF1;5>&}wpVzZ!mH$Dy(|gjQ7mtBO zG`zO(8ACuse>x67?WqPtkmXVZqRFo$)Ub;Lg^TGH&6izZy9Rx0fl zGu?wm@x4SFq;sw@UL@-OdnI{AoE*-8H0D(!dGDxUB42~X!hp}kXcR3c2F8Wu;qq7Cfe#T5Z$Z7(2 z2vZ<;0L7*=7CEh^p9g645s)_WIGhIu3W=3RfA;SYi{5St*=WJSs!b!H$0Fk3%C%ZL z_@I9qW>qsk7bK?Uh0%Dp#o3wyV z0^j{Paf}3&qTw!)j=?sLKX`p*nCA15Fk-~$Nj!^)V|MdxAixeQSzp-?bK}va9=C)8 z;G|iIOBC4x9maiqh!aG;RD11Cl9ubv2##gCSGIrf0-a(#VDokcZ>|};;KO{bnHj2Z zpOj_-;)$*3804t%gpAU-54+7<5`FN#= zTsRu6iNutldA(?`scejERVe&0l1cN}W2|+8dYj7QzK&hcd~ z8<_0CGPCSrirwGFT*djkumrHGG1EZ&lLyTI)34U>88eROtq#Dff6eZoC~ z-h8>06MXfCgPqnyog+u=eD%7~U2j-|Gpy%E2tz-r2X*sKoVPzTEr(V2%#)8xNVt{9 z=n=Z#ezQzSnO1KU=zRjE5WFFWFG1-kVgK`+w(|`26c*G{JKG?m90eTdYneY5_OsJA z_sNf6Pv!f`U{r9dp9cc$Xl0ut&5%3v6=fjvP{3kMnYafIU6QdHLEyNq*k7#;4n)Q4 z3qpLLbWl-&Hn_Jw!^O7JztKr*Qkq+6aw#QPYr&AOV zyjx}o)hH(7R8{!dkoiybRf96G^l!YCYTvOPHFR39id8XAlAvkq@%(U)ap@N2>tgcJ zzGA3fu@ZZ+v$Bb{VgCMeuA@`e6*)avc9n!VV6rLIqoxSYmUa=w{;<)4`? zM5kT!#7B3?Yk#eZ^WAgYnYC?4=nVIuVwjcurUHb|j>K?KqrZ?;`u^)}X@BwN7mp_o zI>oAKuzt!~CPcOJZv59Sz%hyf4U$ZF<9WgZa>u!@~km zC3`O(UK00{_}xVPy2{+yBrVBGfE8KiYGpA(~hud zX;%QFD@0%vZ$s+C#6=n*3yTZUv?>ikNWfo{Z(v?=xkzMU5exGu1Xz+$LXtt3zG5zd zm2`%6dzin+Uux^t3$m1&0!xe^=_P79ydf1r_^+4u+1U8j?&?jMqD%LGp|QUA zt%J^)e$Bc3E&S08(E`Wj7(s&X4{uv$b78oiyl`4_-qSC8$-#=ECB9)P)ZD$Q(%M#3N_xZ9-BltX%WFfGeD?Sy zw)T0=`F@5i4gMh^99{C_>zuBSKro8y#=D_;uX%O0PqkF%y0Z$uJ(7eDL9ANHsZpb{ z`U=eWqDiU!TiXT(61-1lA{CZ|Av0D+WbS=F>8F#h%GURzKF^pLsT1`2W%o~{(dWzc zwr~6($`T4^uVU!n*v7ydcbarbXm^50Zlz+>pt*CFBS zA#y4IL0m;>KT1uXw>z5Di;}*+n`{iGUUqMSBAP!p2w&SJ!ckNT>|d)#M~iF*k0!dF zBG9%D+o6;6u42f!-XA6w49%g|To34>JXKhGtu}o>k0v8c!(5Gei|X2r;(|$zenH92 zdp34skO1J#n80PLw}o#pJjvT5@&~C%Ir@Zv!}?ahb!#L4-LrgD=YyJnR0#MPS zzTItm(pUAl@;lp<%tEgXxkUR%nEPA!*UCdHEOu!gIohNvTN2|@F|4s#Nz)exl0Rka z;`_f!^_W0WPE7?C9|-?C5&ru@jD$;#!$9VL5J~dd(aWR$CZCbtZ(nD2I*w>$I^!v0 zHaKD?P%j9}B}eQ02F&*);@!Dyfkuhe98Y5LxKG)#?}Q%N%n!aG1Q|lIeMk3GsM#iK zrx&8Y39`Q@Z?Mz5jPcFeU(GKk++d}+T-*nl7#yk#4heRj`$Q}g&9a)VWUk0D=S$s9 z-0kh0#@LD4ZpGYEt5coZy!XmmG|YX{4`@Uau6sx`iOQYa7@V*i$>rq>N-VuEVwX#~ zXguJSwHM{VM21AN8+YY3EEbm`St4Dh3Fpu3cwpq>10awY1A!ltHa$gg)p;31?xt%xQ-ixXB(pa zQ1mmcxAryuWm%L+yTUvscWVVhbfPt?KN^GrFyr$Z?qx{ufNu7-qQLQqi0c>@twj^V z2MbDa>(mE=jS~VG6*ZWLc6ErUDXmGJH5J6nASEJd`_W1UIvp-9;g~9(BNp_v1>)+`eA`1059gm+(ln{jugbd* z9fYn2fY7;IAZVC%=4n>dS&A{&#ZN4&3duuIes4#@n`ww_R<<@V;^Zs%zZxw6&-+KW z)I*JYP*Z4y>p{yUc(uEK(}di|Q(G}y<*tH>?Hu{g#S{s}Juv2$y2=P>O7 zLdnT`$)Iy3rH`ZE?07=N3PIcYCE-;l;F>c)kjb1_kr4ythk>3-eJ3%;<@_4LO z$3EoxAIPxaTEsM$IoWpn>h{uShEMBK_MZL`HLZ52cQ*=3uToyDGe|UWMZp4FAR$dm zP_n_AFMpe^e{*(|Y1fagzUyN1D1P6UOKVS%$21gCVrqG);bWSA6-Ov=rP9Eosg-d% zEJN~dvoo6t>qFAMPj|WlJ^`L<*7_wm`uAeFVf!BICGE*Bc&IZ zz?;>#>sHyO92nRmy~#;O5|L`qhF^#puu`TH#$x;KZ7-J{I#Yjc>RX0#K|Xx5>1RiM zD+^OzPD-D#gw5Vjfm%xmWYw{>l-?brIjYK8scT>Etxb z>H7_V{s(e96gPdkmvhH7?`fox^gxW5*s0F8{~#~ZI#@Z490x*Y>;ABe+rMK9Kgh-U zNgt3Egrml*g?;=N~^_T<)qX zaiAI%uVFIsbP+CmiKTw2o%#z4H7NLppmiPFBGo;OyvoKIAAZp#{O>?)V&6hAKq}Sxn43-SloIqY0e7-_T_t6R0 zAtc#2^ar8ZF>y|lLMiCW8HN-?O!lR0xOsSX0)senGJ1wHO%MkmVEIkydcU}{V2T}8 z9)|E`Tfb)cBAmegn0=)e$bCw5BQ>F0&QYfc4A$af5Xj#s*~f7IYXGDmP+StU3sz#M z{0Jw4z#uVJ>L;?{FJCqU{0n>ST&uLA>9iwHZ{B)jC$s$*sWTyn&ELU5oZ|g&PUYdY z(F&(&41XB|O~9>V){U0S&6cm%nD`u!I7rwDLxH{+VVNzC1eNhLd+=qpI`}7;q|5ID z4Pv-Ts(kI8)8K)KgS%L$;s)?Ogq8xWxEw(PeJ<{(+&dWPP&wuCR~{R=#eWu;vdvG>(b*gGycb4{FsTOw7mAw)cc2}T>sUUb&cjqZ1Ek>NBVgcaXH}1fIeX)^xdW$@3Ayn+ZCv&FR8x&Q35eS3 zBhpvx9{#XLfuP%Ri2RK012JYz4Ug@}_4mjC_A4p|T3dfCxES;P^*u8I%BAS$X3!$~~g zY>-Mves~xOkW?$hTCA$`2@6Ce1A&h4Ig?wI`ux4dNfn74&<7A!UA3dZJh-6OLzBwN z1Q(4~KA-qtE1~O7a-eS|+v>~W-|LF+QydwfGeNTh4lsIgk_r_g`@j`xeoJmZ?U_r_Sv8_uP3l4 zl;EHZEtqC2g2zF=N{dxL@C`3MQn3owtVCi~Esf%fU247m{i>JsKkUbrKEGEf{Jqa; zl){KO#DvwQ<5xh(36btg@hUvZ><$Y@Z(!Ssjy(et%Osx>ice~p?wN^lmum;}w*C-H zhB<@P7xS~^eVih~afJ1z0OZ0XtP^DWuF1>SU|TAFeolTU3r!$R3W zQHDKIgBTku`YXJFDa4os{T1O%V+u`pQjFPsCJB{`kAs5^s9fNWG7}kIR~LqqxYW-R z)~~Rs-8LlyybEBpcn2(y{w?|M&&Ika=EuR@*u?jAFz*d;QPxj(We9I*MriQc@)=BV?aaEla>1x#K6|V7a={24TH$LJQ{(g!lhY^-?&ReQTA(3@ZFeI9A=v)# zi*g5hXIwWC1K=?5+Ld*TGA&_Ah!d2A53pD9;C)1^5X%&PO^=niU_LMA?dXQv{5@1w_atq2`LB8JwJr6k@B2EhhWD8E)S6Hc$wtxiK+e_VC7l4eXb#*|m}!6YDM|L8 zj}AIEyp9F`R15;)McI*LM)kUWR~ep@naApRioJ;byYcHl7V4 zej+i6`2f;&&=C09)Z5S`L|g$B6AXY(rMr?xeWjr_l~f8`#a~BfkL-A4nl;hiI9y+V zB;l84+=}V!fZ^tes?vLw%P2u&D4Vv?2;mmAfl-?qC0E#96B(((1(2#4B8WxOivE;d zzn#`oc_(;rsd03P4qbpPT<<)a7j{7-=wd9+>ufZ(ePR)xy+M~@k-gASv*<8zp9&m5 zRjwWDzHtaAl+_#sF;PW04k?#9$>lhfX|>_3VyU#g0&VrcX%!7slSx2{V2BRj5iV3S zm(d7>#jgT1KSE}X-3YTwQ~Lu0mT#!j(z?>vyTu6tseAktNIMf*N3kzHtEsbW3&a0o zpMTiZp`I;*j)WE=zNQx|Y{EuBgg2C7qv9woE0JL4s7^`&{RctO8?C+jh5tb!!tSwG zBOEiWgwNSrp-n4hX!M^TBIP+;s}1VAsPrTwLr;4h2UP3gk6pjm8{3GjD6S4Smmr4l z1%N#DUNOSq1dxJh=l|f={1=Nu`_gBK+6$|Aaa8`Pb~fNaHeiKS2DM2w^jz8BF<_@w z_Vi9j5Jm=qP|?e#k8M+Gj?v)!2vk8==nNMIXavf;O?-4#m;f5DWH5w}AXt#sz3OF_ z)HaSxz+lJ5B7TEU39PIbvq$?PLAn(q-tnUdl_HAhdFu(c`NJvpQ5^IOAm;T;m5OD8 z&yq6P=BKjxw6xFX0Vdm?Gtnk08;3~m|6PmJ(8>!8%Mf#m>2;(U9_9IA-(Xn8%-&n( z^C+;*vW zJ2x%)4KK-ZiNsk^0Rgcz_-WfH-Q<~WYb(HfeKT?fZ@3D33MEx{SHp^0*Vqn%azM~c zF%p`sO~5Si?H*P&U4~#sn+GGjk8m+h>6oO0`4@g$Ne18zw%L!U$Ksnq>*GHb}A z#s`E{Ds|$gwi<`9SM49n)2G6Zv|3+#nLjE5=$Nm69rMYcVtuiTn1eZsrWWgs?i+n; zOmo@bdqXs5Y2PX{nl1GATzC3a`c|)!gHY}!3@!*wc-(>mJBDO`M>7ztX%)R0ci+XN zjwu~rAEB%yLpMUc$OZRWc72x|_s1TXo$Qpqck{86N@RHK)&L3K&!pkgzM*iBT4}jr38JmJ0FLuqf9-8`k^ko|6_za`A3yqFjwcSnvbIld2 zKi6lKe@sTq%P=X@v{ebOKLse)kA4L4Jn+fSj=Gn4kutx%no@P}w!twN3^bC%EsQx@ z@4=v0t`Z4mm;FQ53H!hjTZ$`!0g&XxN(HVH5Ks>~_K}`y7J=nok6R&U+QFLV0|!JQ zFUq8wpiEI`P11Y`OYzN;LzBh**Y+ILSnt`62-|DALN(xy;x0R{_aLbVEM<|huhyfc z5Tg&3?21dkEpK!zTk)0gX6-z!j*j6tYtTK0u3AS#W5|n=4Nf^=G2DU7-b&976A?6| zS|&DsBG4$y1)`Kfd;}VEm}6zK)6}BtcLPhHa&@Pa(OMUdY&|5gwESARFX61tn*oQu zi0Kno*xeb)b~>4)H5Rz}M%Q-T-8zT7d`b%*$z7Q}9j>CjNlg3$HW+}*b%dH)j>Q$Z(vz@&Q>glSGFW$QPs0E&oSb8gy% ziTJhRsT}+QNPQZ)+Tt0irA0GZ4HIHgPaNAcm&H|4`<{Ay?f73{OXwO}!-Eq7+xAy2 zvjQAV1>Ag(jraqQ^PsyT`yWJr^-*EF?35oZv8_L$B1On$3i(jbS1k3bAofMj2zm~p#NhF-20TGgqw{??){RfFvmOsMX%mgX-H5S^IVn?nW zwxuqqXqs}`@DW)hr6@Om3u$D=o7{65K}|SIbbK;SbJk3_4uLzQE$e<1za$ z0jHVrepA3T-i;3|3}~V$jN(aj$vN-QK;Zsln?l@(Xz10ctFV(pdv=Z;w>PI4h;l^XnQRy9!w6Z5D5$$cRqAJ025frpc%zbqDjNCgoyA}t`xbb ztyEfcHA3GHe@aF$b6->K{&ea&Kexqry{;?qdw&F;4w)8*G_fj{bC?Z2TLFqKW&IOU zC|ctZkBrU^imHKXHPI01J}N_cCMmac=0n>ca)I2@Fe^6&)levSqSv{_F(xw80sS?i z9=WhmsLk|adAH_tYI8ESnTPXRt8ZS9KY%;UDj&W30I;J&49P;R| z;c+Wciwf-WJf?a>PY;BA$#z&BRHp+iYnkIvp=t_vFOvQD!8XtT0AQ~1MWzZO{Tm30 zO#9Nf7USc*Ss!idAjHQ??v&Ov1{v?~CLQb#}X{sWV6aDmh)pW!FQgs`qS%K<~;shhcFAwpwxLzzIysQi|VvA z0rTl2RdA8ssbi3nXrzg|4zFvgDr915+U!0g$ux`sOSPzP`S1cS@?ORWTaK&cg^ZBO*bT z92*Y85)bPFLGSA`#fCo-&!@xe{o{3IY~0?_KxQ+~$|I)>HJZj5%U-WuzUa01C+0j4>6>$OafFQ%A@Ti1~QbS6r~Z{W;qFY0L1 z=FWj~hJ8Ld0>f@y(E!8|A*=Ry}g! zc)I93S{zeMA%4zW;U@v?a=ZbZjGfX;5pQa5hlPo(uJCtU4-%l5AmH;4F>d3Pw_?^* z>#SKxdn7R7YvCcFX0bv7EXf1aExGILZjC8vNIzjnNx&9)XI3`8VKS6XU+W0 zK7L3L+wdEK1r?fMo%m>W3_ozmo$5GJVD@WAP$uF7GU|Z|BJ#{Zh=RYQ(q8T4ts*;u zeGWyUj*`aW$?xNQ@5N!enIsVJt?0rgffCp3x*K4l_|6wD5w+LAkXoT>7I^7VGV7ia z@KE3>8@m8Dkrg;Fu$qPw07pwQG9rYPQ$&699|Tycvg!fW=2XOR9Phi_0W=hhJ@t^V z=7iae6gQ9)L+;8KRY-;A8q~nso8;x?K+s*cDEL)ofgfpx#3uE``fOjORdic#6a*Hp zvYOj3N`lAY;~J`O(r77DlrNc|2jZJD-65usWP1;S%7 zv_emPm+j7SKhut?PM^H!s6~VbBHbd43|Xx$r{475nUKlW-mUDBgN+ zm`4ou&#Ts?*51~mJ!SM3Yjx>XwK-Adxn%@pgL;MI7SfeFN|&}wtaq!oh1sXxQ8Q2(iIM*n z&k9agi13+LKt6p7z4sKlAimYC*Hu~D)BlA_v2mW~i>1}?$)M2^G;g2=(|eBA6V{)BXIB7Xdzu2_9g;qsF4Ppb?c zeblH(!d)h@x$Nr56P=X$2a+S(RNiM64{dAjI3Yc;7~{5zbG%le<#{Y@PfN3QEBxw> znSvt;US;wv@7wot4on(Pi$W$6^$kV00&>TNv!uXBzXwrrsVxte4m!wxg(Vs=I0>xm zf$~FFeolNa^1ZvIDrK*R{|UR29YvxOn=aKcqL-AkhC8@L)Hq+{9hjGU8t3dQy@AQb zVLGm*d~2}Mgqswu^i2M?K+mtg=@UW7kd@dXYGOlm&A+=m6WMz09nd(0=o3^{^qp9#|4*BtDQjb>hc&LMAufeTGu3UNdT=KT*kj4tF+M1=4 z4ikNHsdt-smS(Mg+!Z+6f+TO`Os2d6*<|RIiZE^3^A`?Gn}poOjHeIOGUB|LJ0m~w z6w3l$Uox%FI<;$S8D)9##Eka%oxK+h{d%-5{Q>c?^MM_BM@p>I!nOzo>xv8AM`kRLaN8z(YA0wkxWXEfH##pGd z)MQPpLw;C$?!_yV#97lwTc;IELk=V?V8*8Te*JUeczvH);uSnDd&JDL?D*~K?PJU{ zKo=AXOOLC#daY9Q&Z*+|U7`|kwbLEXF-^<(#&#|Pv$n+k{3qcXMVjQN?x1`t7GHe~sS-Zb~K1_M3OPDiF$?PI$XJ)>~{l zR>@o_e793`PSssO=_!~lWx_X=q;_cy8puhQO?uEh?+;af)aaWUAq_|;LZYWE!xaiEab+gs?i@z`WEuMXe$=I)UOr_njHVq=4BN9cA zy7H{+pZ!VoMQSGed(%{%R=ezpEv2@rTD~H~J znI|4TN%|F=3!;{eJadnNZrO2sk)i9HlwDW;Qn+`f^HR}^ij^2O%4P;9Ra#JQG5Ta0 zyCuZ&&iCF&y^*JRH(r}cH=%VV79L1=yB0h?k~CcIo~lmHIPOFE5GqYwEX%XQ{ZN;& zivDRjHCyGGTX*)9BuT9ztw;HsgvABdZT33$e`FL?w}cs|-hV;NlA7J}vCe<%iru}H zyA7>GtmrdG1m$z``I^CGRMhWxQi*ap2b90d=xAo6ptugb2lbE6yey3+GFtdPFU(-P z_H)j&I=|$1RjxeyL7Xju;ckR@eSG=u$-WENF*~%vhQuikK*i1gdDhrn1$VOaj2JFN z=ilZW)Dqk0@Bbr zeU8(fcP(!cd%_x>ZVi|_7dL6$ovn4kWjg<aad|Kcqg7N3VIe@TjJWb^C~fp*Gvw!MXq z*nFjZlc{3pfjf}Xn#!AywVYdB$nST7N%@S2$~El0QV9*^=NA&XEa)*v-X}>Pd7PoP zN22lyxnSzSxO`}!s_dl0-Ma(1=WIu%_H4!?P1bbx-buE!e({Vn9@ut0Wk|9?^yPw6 z>}>2qsjhTbzzM6l? z30*N2XUqG2*{aic=$eOs+ay|9?)8SGSy|a{oHz0QW}tV?1Ht)S1+Oj?9ob?pKBpxe zSN^@MHXuRbMCMX!Xd9*Q8eg-L=YT zf(0J=(EeU!s^_AEMvH%N`7gb1mT#l~*dkP<8LMynaf{GJ9#hsPe^Qe|4ie~lPKhto%q6LY4K<%rOZU~r&TDm zbNdt{YELE$A{)9^HxV^hHKu7-b9zXP@!Ob3I5ze;sk-iROw+$BM1xTeDMN?v{Buh( zN3QJq8k4%D_t(^r>8rb}b>@`5d0~fFyX^j;!;f`V_8veSZ~h7^p%N;(H^&XfkBSzuq)#S{o{~Pj5Ut zT(nL3(DwtgA7I)EH+>X7yZE>}IG!6UQhO$}BT4T=SUqlS!<{`u(SH zXv@LP{Z^j#v|TeA3T;1hVC~6wld&)1&>`t&($%q#wqyV1mwRzHvz2y#IBiqP8ugB#Z0uUmx$C=)R?=rJd)G}`aL}%5tgv>e=ymq|su)gVcWbyoR*oG71gWnU2eT?L^?w}t=ZagZ!KocE>S&0b?cBD;*>sWhTVFrT}v*= z4$MJV_q_KniEMD*2GZcdJZ5Ze8OomX`L>P{PHG-clx;W#1IZwuwa|CDVe_8#9xYA+ z7xDGAY#nAIXoY>bc0zzG@T5Te8!WildnMl-A&bIeZ`}lm`pZELq zdOfc-DNJkfWNgla(D1Vz2A{jD)QY|Jmqo^ilCe_A1TA0JNF5bYyM{yFv>G7Jw&;}k z>UNz!-)7@1HSm<&j7t=5!R+v|gDdROA=XW7*c_Geje^8cR;~_YK$fTXxKaLW*j!DR zRiD}uuMOx7->@P%P%O!^faa^b)C!;<2EhY_qvfdPXfb2J)EJ|D6VM7>kQJlz8`Ue^ zWh(5(-+mm)uRG&`zD;N=YISUB{gnZFeX$G22deWFr*!@*SI-FKB_^Ob*0Y=aL#mR& zJ6iz1Fyb+n%eFngX!!~8I0UIbz7Za7X9n5zE}%;LFVO_JYrPA9S(0@55o8MD|8eNO z$uEb){~*sVa}aJo0&IH(vaNBk1t`n}xdl|~4|>ET+MwXywwdn#np4LQYa=p>p_>a4 z_*|i*dxC3z)WGt}-vnZfvtthpXW5YVV!h=Aq8#{K_2I=CA)I z@jx=M<>UJ~ft?0J7`plV`4d{eG^4_{t27(BQ|=$cZLl258-G{cJf@f}e~)uyBnS7S zB5HFe2T#`+5^JjToPWwlimCbsF^MV3_Gqdu z`lFlX$M}!r=hgjG|4Kk#9)3i=D?Wd}95z8<$=NC5*9>Jbz93(8;0tbu$=`hSA# z<^(RfpJJI=2)dAYwpb{bp&#TaHN-v`mRbqDQ;qr zzMu2FPU4m`1jLynV{Y+t`h@qo1l8pR1OmCm2HS;0eW9uT)u^!hG2k(jm8dhZw+KN^ zSbn_OGl7kNkX5K5C>F(osmo6`6h;FzL0DtMpEj%f9sJW6z5aiYXFW7&Y1D8FcBk@* zwD^%{a=Zt&;c_Rk-A@ER*KQH_K<awKk!WSi_*o;0F9mtgnvjVWhOPg#UOD_Y}UE&Cr5vfY1;PEPsXWeQo@3U5&6S}vtw!VqVDmpFURy(&n%>?$jXw@vRWIm z%$TSgyR&2o|6tZ19`(;ysQ~JvcM#`Hs$9tSkA5lQLVMFowXcWG-3`NCJf753q5eS2 zMb+85XM*?;=a{8D`O;>m>v2fzA^*So$Is9@SYFTRBZyRNV9#E?r?NNwQk`0ag<^#S z$f^+JTXeyN`wL262Gcq$k1tb&)re3y6oE3bx=*+lQ*ZwivT?!XM z*6c}a_l;M#Jn&kcJ8;{Gx@!t(As>;jR#DAvfUXlsu7t?VJ`Zd#BTmAHFYH;Jin$_!< zH=hfoUJ$yu@B>vpv*@0_OchW6{!ZCUEqKuFokCI)FspF59|Jfv*v{O=UH6On5aGeo zCcx(X*>LWJXe4FRcYC;`_0XcY6Ze4L#isw;idnHj&S7)0hqyW0C-Y zLeK7XO(PRo4X#7vp<9(AFdf0g5MRuY8#cWxgsXqJ1Lr$tBj4H3Vedx@V;yG);+doC zH*kE*`T)D^fDgn&Ezg`JrY)eBeYsbO91|<_GMu^acOB-{yt_Zrnbl<%KNRq4tRN<4 zDvYZkRdT|+jtLPPB}1CGje!)WRWK*UT|TbJUb9iz*R-Q1GFKW&SHDj)c0OpoP+Ce)&wj{75sIV~0{!*9G6Z zEpyb5cZI|JmK)YV6qHz{;(-YLgCA0SpAOw) ztyviWa@xRu#;rgGvL^Dp`aNd%LG-sXs3Q}x(uNbkV7D$VG+i!zYE$9)WeiZ|1Yss`&!)b0ff#VT9dR5tBFQP=nn(y8uya&cLf;6s30p%gp@ zLN3-vb1(k{ne#xgdhYCK2Tvu{u4Z&8NZhDO2rzX==Qouy_wCq$=7S@o#AcSmE4)}O zv>wRE|8k_e9sORjV<e^CZ*!~i(Z zCHE{;H)eCGbX-f?i6}LYagW>F4o9z0U4j70kS&xBZ1i~Xoxj`V{Q;8K{hw@5L8BrH zfL?%lHQF7kB4YQ)Q3)JNNx=KcOW(w5%j(8?&HgiVjctFmROP>YALDjkIy$YV1ut6u zzDJ0XR<_0_INZNeP3)(e^*{YsyB_)i;DBEs%QCVKEbAV^2)Tdj z|8%^?|4TJo_s5#89PQS}O2pqei*67qvxs=4wi+qeouxPrtp2JqnSVrC4GvFmx zDH9QS4ItdYIrk^MN}iINs&Jc1z^Q*dlJZDN3_3Cq2xpsV{3Q+t@FmI{v0aNaHeY-m z$cF(T4695K0E{^SKAvj!(or50(LjY4PpTkKvELu1MN&HEma|eQDXhW4DvMq;VQGfV zw=6L~1aWcGuV#UznTu;LG%35V^N8cl^!KVdV`7*`N_qMrfCzKvw!&SA9$6=1`w@B? zrUsRIt1#oFNQtY0`3Wf1n}vGhDS`+O1ngw6E7%i)8~K#>3?kSRkzS#*-uXw0tz=2_ z{C81+*FwL+X?D6Dty`_%|9`uEb5&8i^Wrz}!Y|C{`~K@M`VH%-l>Q(%C^$L?K$TP8 z!ZslQkLDHbi?H;gp*Fp~->o3qqzAfHEX;$9Sq6_e@al_JK$qJVy*S-AfQ%K>&xor$ z0%Yf0T0@sZ(vuFGyyxPJ+?g2SX!}dX=BQB{mbB`c_7MhOX3das*2Ir50XI<$t24CN z+=*%Y%UxeI4MAO3hk-3`$<|OoNoE)d%zjf`++-t-P`?afwj{7|U6JA=0@&sYG>k48 z!s#1H5p29JCfv$g!YDlv{WPHQ3~FfsFzrlMA7Z&t3MARtQ!17eJO&5B)0M#fG{%58 zmLF0))U6{Qm;U}7L@HWdHh|lr6Bd};Z}N?fo*@D_{mQn(f|>syvVetWf*qDegt^!$ zzxsKw?s#^v$I=Wrd_PzioK7rYZ*5*rSy07q8U$0DcbNvqV&k0fOGQ5WYSBGcgH27x zJ>($A`>52dw=Hn_xu^H*kKBhr{~+VxOMLrd2fjBJ9TXtzy7=SPfRakeUAYbiHd@r; zk2Ak9}ay`dHc<`8jic^$2 zLQ7{N?)u|T`gIqd(@=5yGZ6tY15^&K1uB&7uYgkQVk$3Mm)(P=R}aSwHZ1bVy`62+ z#?5NPp>5b!iLOsN)h%kAuApTmMC5$tBkSh~A0BRyx6vmfQepqi^s> zRLC;mb!9R$GoP6Qf+P*jWyfpK@R7sy+chv1L$C$h`9vN3(mYqZF(oN|4hOOW2jl%R z6@hU)hukX@9=SziAh6_#ABXX|+Y~x24Y|vl#_?or#4=Nlp}`>IL7FXDjc#cDIXT6n1umx9Uy9xGrY>0f?857+2%VdTJU065PL_X z>XB;zr@0~5SQ>CxQLL(MIq)g9)j%3!&F*yn$Uao3SPO6ks~x2yFbp_5j=Dg?3mazeNbsi|yX^N!z5 zA7aqsj}wE9SdxWqq{$$+Ktedqb@?jm0!*Xdq*Q({gpL7K;j!W7fjK z-&CHP{?zI8j_Ee7y5wf2*PDx%TXEEm$ecqnv73IMUrT%+5I}Reow|7PgYvKS09yvu zO5YSSqG^+>ktnmjm*5LW$!9A(l}qnw9$%P~q!2G&B%}%)Ivtgss8ase98OP^cCmTuuyE;t7Iv&v_Bl zvC4f9EYui;APyg2Ch^<#wwdtCn~+yQ@2(tlR8e?8D?j#z%^2mWB&Xf28BsMxV?sDU z_>glk2}I^D@KfW8uGD;KrJTGA#WF{Uy=|%E5<2Aes~Q!U&pIioA-*5**9hpIWKcVR zB38p;#f=aN2hx&50tY$rb3nPlrco{*>)4*Oc*EJ^vTPZCFp1_Ed%O$C^xJFxUBuT-l& z=*DG1aCl$}jo?UsZMuQZmRzAqBjd(TTfaUAZ+SeIcpwFklhHDx7AZ_P1`qQqvq;VL z&ax$g7+p)t1r?pt8n>)c6qJ67-27t9w66p8Vi^leA2rXv_lN#!q+$747Zjo;A&Ue& z#g8HJ{OT%bE=S{7&7s`eH6K06%kujVD%s{VjO}|@`($P{=r2FAx@hm)obc*a9uR6& zT1_>AffIn?ficXtwHDxh#19%&Rw|Nl!dbvx++Tbt4P0jwG1aKP_|m&*E^`5%t2e&} zC=;9Z`@`l}VcuYodrd#IaWF}B@U?vTgq)!b7(a8lpg#rHZ|sjvRn#uA{&j0wCW}ps z0koCr5(^&_fwhed6h7=_K#L`^!MV(f0CR3y1dbg_9V><$68H@A=$oEmr-a9FCVMSH zw`Zf8R<$%na6mpy<$&QQ5BV)slnd$Lt#7}t+$6n{ISyu0Yr zC%WO%Smd_4d&Fj~w*6BFtfMXr&|QlUn%^F+(@mTF3_3HtuyC96|79inyX@~0oT0BR z6)ucul(T@%PM*o+SuJl;`aFAD1F)2A-=Adu7ROgKJS>>f@zH2MW7xR^HU?#0X2XZ> z1xkUnUX%-a5v>Q_mAGG{YYyT?mCMATd!0J?lb?&AkJA|sV_&!w*x)iwXPqjmb_oP8 z-EhO_ikG!~Kw)09e`ef;w@@3Tu1zTyfsGF=t}B0!v=JbK?ZcnC1+5HIJ$kWr=EU(>q!P=cVZWPN!cC+dVg5rulf$@x_ zfaZ+FQ`X-B;niaWfCuF7&dfhMr4+a=_%EQoO-UaUWrC*?nSy|og43glZEE`0A%J@K zQjIqgBFaa_Uh4qN>WSzz``d;HlwVVN7;Yp_!^bjta!4JP7lyZ-D-|iIxlO{0Fh#Ds zz4pm2oQYzQhxqpPqw*;J$2gD~{Zf$_g-^$Eo8c_V;u@)BZ(fpZ>13C|&@w+Gl04e} zx>iIBMVr&_iG4uo;7Xwwxo0h9n$`qX9i|mU3;U%S;=r&y5M`l!Y=y(u3zQkMIzO|; zLnLPu>a75}&-zm7e-gzAa$DTWRK z``m+QNL=)J_9}iI*!C#vH_)Td`Xj)<2dTE|5)3SzH+@s$%@cvmKR84Y-_uX7v8};S z1kS@uiJGV^(fayr4k`fWJ%k+)Fn}yREUWvKZorhr-z98_%$Jfmo;EYs6$YB|E<{=HLnI*@p9-={$bQtV|4>42+^u zMs%Y8l4y*DoKufCu@J0tQ?3>Q9OhHHwjh=Rn+w4;&J1Qwh&+p-nhUN5^PT36Aya5z ztVJ_(Ui?c0jh6U`T8n$b1DqKqkz} zTV(K7*cKSDLOW(mO}v>^Gv>likbuZos178Mi`_Z;F^nn(vhWC-GRgn@%c|WdJQ_HP zIoWC~05_1TJWPWKJ`#8!QJtx4<1cA`9VFoTVCV{VFmTLe27Lls3aDnX4#oq?*+CM}v#)CgwYI#UW&Ps0nD5_-Az-BOTV* zn^1>i^BP+7#6fdj0Iui1FRAOxEfMv=l8h2((Z8}>5KM?fbp`X(&JzMapme>8fEdir z+(W-dVCWub*n2fQqn6pAQae?)2KalqF7n8L3&3o4RzD>-1RR~ZOP#Yc*kAW+4fk|2jL$bV z&T81-zZ&jYX!^v*KlrNnwNeq^MfFRCD@yMK(@|z)FCScZ=*{7Fis=%f{DE1)qRRNq zZ?`cpH&|@k;fYFJ>CwF-(^-V+81I{IJAJc^F1%4YHan=g{}EzNyY!}hd-N}|jJ89d zx2DO;B5<0GQXA?;C8Nh!(d372xw2!tA;cc-DHHr0$H~{iV)kzWy7}?}tqVtb&NRQ^ zm;*N^D5$G#&ntiZ2RY>xEn)Xx%Z_DB>n=nP+pdRoXK$kRmKArNuJyv0+Jp-cZw^NW78Djo?rJ{ zY;>9F0e$ddwTeu{iUJ3;bhW&qyO^-GV+n+uI@fb4EZ?*7s_;GPxp5=%zg-|>BHvH( z4;{SoOI0dGQ)}{#T1+C)sWhKT#A+}Y3y3g>Z$t0X1P1zB<2U5@)~1QXH-vu`shjU2 zYV`at%Am<^Z|v-XU=x|ZCVuy&cWwP&HALeF88PG{VzwX=Z2fXcIcKjX^zA*z6G|6o z9P>9|GuTPZK+oHll>>LsYmn6U_nfsceqvF`v3uz8WGC8BM%0;iPC1dabF| zVm8br2zk-w`9$5H>BnYq!q(gJ=|Rv$fsGo3nDVoQFDC^bh%csd3k3H{J^pp~(<8eB zt*wo|*+ZhX)z986r9Twjma3p7>mm3a{~?4I>-DqpMS4e&59^bHM@PIaK?mXD9(5_H z-^D}!MX|b&3GAKkv`JYXZ{E@9)a!|}3(H4`C!@qUjZ@k}^Urj<-tCm{;?C^yxrKaR z5OH^I`&#a!odPcE(7(br2}z6Y5+cytfY+56lvSwD?_~4pCR2CEjgw-kt*_OEXQ2?{ z=X}q%Dnl*HD<>gOwC~O;=pmF-;R?aKW0wj}*etK=Ew<%b*c(16mG>0b%}_un=1*fY z{Jy5!S7~!RFV9}7m_PVQPkqFokL}ms?r2-rUOMz-o2I1f*qDFlH}`AP8pF=geg2EO ze@82P$AxL_s+y&$JJ1M+>%T}T1O%6c|1;nH3i$-8&8C<`fLj|X^=2o>?WRyh_mOAD zuAeP!MtJEiZfn6seTUZXnEJAm=iSnD|k+%{6nwzNI--o zT`?m(e}pTMobnerA157xcpwqNA!^gi1Q0IwhgcA|zOB}(o!$ZneN3%1Q)7wE`7(nyF1=x<;3rrurw3?iA8L;jO8eSCj!GKn%JL>SG&^D{Q^M|Fp zkHADUl3EN`5M$wvr6B?5J-e@B90o=fS`f$d?_Zkm8OPLKy$#*o)*+@7-!fNU_J}+4 zsOQAx>}0jJTMCJ0v%ALL>=E^c%0;zIa|aWg&s8jBJzqcmwRx}YN_v@-5R_!pwOnSo z+e~F7`FdQ&{?8&>bngoKN7{DHg_NEd zN9}91Ib3mI=754p!pEN4?9RP}f)rziX&q#}O6^fGV@!D1m`$kHw`V}=oj#U>{&+nu z>HY_bkvi{-Vg&RR1&cJ=tA+A&Y2Q7^M2-84D zx7v9T$?~r@T$$@#rkFQh6tVW}Kem&f=1gBP$4(ts?k1eNw%9r!Yz z^lI$+LB~~M?{%g7irbG=C**i(z8${a7IEsf(0*mt)9T94%w%dqI(N)+i!?$QW^q?* zdVOY(D_(fCkR4L>#NqUmWS|#JYDEh2qn;P$zH#d5Gw&cl{2j#ib3A8VRWMo?F&L7b zf|)(A6!O9js07|5E=Z1>+zas)3EM|eq6zs7CaU6$5-x1ii#&bQ?fio>5$vGldG8K# z^UY_Ar~;K3UP9| z{(id5Pc{(Bs&o_nW}8rsUbVx?oVeOtu_#+b^q(+RLp-{a&e{hxiWSTgZZR$0cN{r# zC@ubn3hLxBHJZ*&+sVBjilbej!*8TzfzA7uZRurFG9N3Y&xyy|n7RhZ7Hk*4pW_k} z?Ubrom{U_4Z1ZIUeODp0B_V6{Qb)-9A3xf3heM5by@<9djUUIV-L>~O*~RHp*>B4D z)|qWUcP{^ZKF267|oXy*`Zk=gJZrK3J>NumYz87 zGk#g-=D8tTOsLf*QofZba{gM^GqYi$_PNoXZ++S7Q;su>5V;|<6ThV|X(2%ZlVjTI ze?JCBtv)1(UR(~neD5qlOTOw)o9v+p#qFk|y2*n9m-@16QaLAYxjc@qFc36oKr57X z4YG~~Cw(qxL#o8|1WD8$+BW-1jG^-G;Rlnb8sl3nx^C?F1+~-i+Se5;VyVhjlW9xk zMf%0ANhh;D3*SmnmVb$lO`IEv@qo8BA6$8Ivhu0!?UNIgDSO_UEZ_YJSAg)m z+YpI5qPNODYCRPxfel9&&E86O_-e1IW+L#yE*QF(aZN(W&4u0oS-JSOcQ>MrZHu+S z_fPO@Bs!_bOMTiTeKfKEeylb9MnZ>|F?jhUG*v<|hGJnvrq01-9=Z~?TUQH$vGWSz z9x;HXc_CBKfUBPS5Bwl@w&)oLGM*FIgrB;eCG$3|q%q?q0drIXbPL}nYnG7^c zGzs5}UyB$@a7JghgD1j^Y1gJy8(0@#T7lv)m9oM6Ldolkr%-ej#Qrmj4gjo0lA)OCet~_Bg z7tw7|d}%zrs`4BI%>lzQ2HUnP=TyF4EF_SIK!l0)q~pn;3C8APrN$_R(;BmuW==Pa zP8zWXs|;6NA3TCY2(k`J3}*j6w-Mm*vim#6^@oJr~e|7Q@w0obg1%WbZ{&9&&5kB41roP{rTnf$W(_K z$#Oawst>w$0*qQ|BFoYS^X)QUl^Yz5Z#5Id{h91R;ELQ>++vee-J-KBPed2HztSQk z_t*Q@UJEAp2I(_HN`*iT9^rD-Fx} z;$1J#iWbM~aGaesoBC~;*BU8xnPmoQpGi03Z?`&P^w0f+eD~nZpEYs=rF4uGCW=++ zWj3YB`m@B>njtM?yq=8(tTN}h5@F0gCv+>u2EGZM>VJ8T6WTr1#(=}0rMz#M5xg}2r^6O zgbv3ka29WNDU^<1a$bjh+>M5%?C*+g38m|W2d>-iIfvdH4ELq!EljD=5Uv#T=J+$6 zLjZup%YZ|-7h8h~<)2#bZpVh8X|44Q?CfqOi7p(7H|4W)1~=Y9Si2chF@yD(9mcTg zEs0_YM%9!%OdFqHY0-&LHj_SyRa^2#t?n?%J$m_YWcz%Ksbi4`R+X z8R-yB=!f|0MjREWmR1e(@hj8j>Ds*&j2c4Bw}c<%Db-72XZK;90CZkrYq~?+LovWT z{07eatcdzsCO@>w0%}&FbaNjQp7fp!H3;BMi%abWcsQl(ZO?)LXq(m1OA@Bfq@XWV zShZD#TOJU`b$Jje4EoQ=sF?$*KBA7t=@+AvP1*=Fc@z?1iVbeuQ;C@33%>eOPRX&Y zdj2rW9{XOwThNZEfI+FD?M4TAqsp;Od!x`}Ws`KaE%UI`SScEs+*`g5d^hG*6AvuL z2u+$u*U)4GnIQVe^BLut22r#XN9*J1*iFDJ0O~a=vm_eh?Xt4(q~(oOd(0DKE5oMc zOANjFFS0A3>$X2kM}+OAqlZQ)-DRyWV&gV7Xb61A_H}#v4JH-vDW*IIY9<0{H_GSt zQ_f=7p}(#qiJpDv;(}r*4pd}zoI9eiB0R&Vhkbu2h%ggIozx2}N7x(KBC=P~nfaW* z+!emPF|f!&*Vkib5=&$#sKrXqwsJiF#HWG2i$_L8-k-EX6~p2ue7)7O{`gk9R@4Li!xfaRv> zdb~G&I(_3Fmo?AJpVogI=(ghcP%KF_sS$N_ru(JhXzNTg11K`7W$Q)ci8IaJSUHbRuZT1cMCGdZ^ zr1%G|+AWY0rM8yyNocCHOqQ3wHl{X^Pl>%lQzq6C@ttU%3et$F4k&MJz(c2A}Twq0UL*XGV9p>HpUH9H5re3AFAjWel zA_(!_O!IaR@vPw^^g8g`vFuJ7w*0CKNGRyyx3o+SUl8n7=8JIfNdSkPe(%5p)hXF)Xq=4R&d0-Iv_BsJ;?wDU0CLM4%W=j;B@D?JeeID z)rxsIl9!k+KONQ~NHRNiS{Ej&D}$cla0?{fs4>_Kl93gUwwaZfEw~^EI6tIcW@1o5 z_)Ic^+0VaJJai%<>oPUK5QT&yXgk*T-4FC~c30 z3T8{jCtSD`Hun<_aNmaZVufr${q#r^DzKX_NG9Sp@xa0A)p)2H^slC;RYF038yicmrPXJ4smleCPwK96f_>KuLT&ji_XC4%IBAy^++nwK5QfKt3n=*Q!Q95x|~+!*M!82M6HuwNGx$PpLOxpD~*SXwSr-KOfbC%!`G3> zYE;KRNSOtV$>CC!U2vTkoq6_Xnc36_(+O+88+IODFyD*@7{AgiCmQ6gq#NuaSx!MM zD6!iu4f)}CeI3VBxd9*2LrtF3kYL^n&MpzFmtfEUvLWNC1Jp)j2&!uXcB8v`^2D{h z>@$eL)c1h#1t!!wF!Qb33_eh3OCCZkZr(-9o zLpb0e2^L*tbUOD?WMt}&&-m0!f-=CO*Xb48cG5&Bf3ZBt*bY$2!2gW>QN~KBhcJP| zAD8_q!A%f=U4T$`M+?pa;OmT2K;(CFE<7CGZ-QHC*kT*_IxPRN!&qRg1E~ z=tKgavD%}I^55e#qpq6X^OPRoJ%aI)e@957y;Um4q+jo1^_4lDPz};F64D(%igpQ zW&++IHWnf}r$(8MsAlq%fa}w$=)D3-WOy)phA%$&R$TtBX&?6S7L-@Gt_ZH#((Az~ zG!L5wyg5n;{=!V&GW)uZ7s)+BX5T}bT2vLmEs4W75pOVep9i#UjE;@F0GF3=>dkBf z;0DqqTL1ewZDt*hoYGv-S!NF+%T3QDh6nu}tOC@&TCDU(7nl*RAeRoAUt)syr#Y}C zMsJOI=-oL|S{aoE9v_-YY)r({8-M`ccDS)kR)7|XrJLJ+d5yoGfu$m2?eeE?in@Nx z&D3#OxXq@my0Mq?zhr|%Q7&`c`ZuWzs@GIg7n$P^HH!{+=6l_>bC zcoCQ!yGn=!}zon4RkUpEF`bXPnix%yD+M7=qD)!*iEOZqn$c_SL)1P=v1BN$Ts!roHr5h* zEs~rnD6>NsM**&xXnVEQ;exXja0I}t>URk4xL3HuilvSTTdJ~RCuyAKrdOTnf0btdX8WaeR!h2~FF3bgXvvK1FaN2)wgU-EBE(vZVU{%bGzfS5y1hqgX23`+e*Z)iqS1r*D3#ZRx=I@pd;30GA^1>Is_RgGYvuzeHh_Uiu+6VwmKjKyFml_ z$H)S#*w*uv-;uCfEn2fC$JtU{|b_Vq5_050t%=Wc@8Xc6E@9nvb%6265+u>k<3ywcgzN|qG{Y_ zwF4%Z>+X08;P;&bdmlRAa0&+O1V4UkXwR{oA!BOz4J?ThN6PcRAHi|BAR2q!dKTOC zW>y!xae|nLxL*UwIDmpNX8=pM#Oj?^@`n!!E7!3P7yIVM)71t`x3tGg0ah`s%K%Y5 zLI$pzgnRlUy(LNXuisBj3AfU!nSxaDF_ZVY%sdzh>}FT8p=hUcatwFf<_~-r6cMOR z-(J1Py$)`?PMyV30Pp7kV@L31)-_9<7QFt;{I*ZPo?&Snh?~iF&hLVIY=+eVW~o2Q z67Qk`bd^eNU|F+BO>3|wwuv^s!2)c^>xJEFDNlB}gaN{wMO&vvA8A5AL-}y$j_)K8 zEY}q&AuEOE&H#gxO6&CNIa4E}EP3#aR~_P_*YIYvgwQ2Hz>&G4rr8VpXiqlv#V?fK zd8KL6b2H(yqs|2n8_bR!z{_Ybnm4_k;ti^3y>Lg(Bl1+#rW?f%+~{jWx0MLMUW!zi zP#GJU+LYW)Oh^GSnU==33T|$0ymfBz$wLlCv9lpEWAgyM{!uFwF~cBM14z!E++O~5 zCsuBd2QtlQm4Tr4B}AlGzNhWDk;+Kvy?vYfd)rU?iQuyP;bHS&*%m85YDyGl6SD^a zQ_gHUC)M5niCepYvpaAU@#iLxfXXoQpcW%9%3O(>mX}S88k=t>IwUB0xo=liYu#FJ z;9jvUc8tBp0Yk#F7 z6#l|J%mr1pYTqSdLQIFvft)R~4upGggf^fAY^uce~i-I5dI)!gE6=5B}iel z83U|X88t>1o{Uimh&PH*j{v9g5{b5um$b#`OGYq95w=_8KGK3xp6j>y@7*NGJcDudPnNeq^zpSs7I4%~1Tij?aB$;710kA2y6mbwR01t8PliIaX7 zp1%SX-QMG9Wo+P!_+2MbLY>p8t^r7Sv=^KNwL%dtyDMxwhYsi4!v{=IkM%@t-})PC z#B^fnXEaOwq%L0;3FDw;Hn-mA?7?)gl+6aM72uLdVjFP(f}r0?(;}zGL>#coBBBd4 z=p&FwqlNJY!rM)p=kn#)XbwBShrc{)@v-ms>v1sUg1)q?pqGZutjGhc&Q+( zymHqEPl3TcKkfA}P&s<7J2h_;9{+{omD9@5>(m&SgXlN3M`_cf*1;x-O+DJSW}rPLy2MjfxN}i# zc!4#@{nTsWMJt(9TC8Xh zGe_f!gDz#U@0EYcF9t{%#DX{L7Fv)hNZ!(sO#e4NaSd1;(Vd(6N)*jW7O*R}t(^ig zWJ**Xg*`aPsF##H8oVAB4(p8WxvN9kBHuL2Eir-d8z7tH@FHqKxdY@^hh_yqo;8TM zzOWhz;*3Xn?$J<;Dw!0479AWvU@-o<&6%(O@(a3CFzc0Piw02_Z)njfFVAE3L;W3KU@R@9c3n1-b z>dQ@Y9&O+@bzr$zPYjwv<5Jy5c^kIxm!R^%UOA)Ow05^(1B+uZNJP^&6vD%7t7krm zh9D!;#gqbMhf`_3Q3Avf@RW_-9&*X_;4(@1`6MKMeJEn9H7@|F>j{J}Hg1M(pW_X5 za=_lo-1f+4ltns_J%F_aJ=8mRhe88+Tx018?D_K^|>l z&#GPME5!=1`KN~KL>C!l_ah|^LuSCX)Hq{|MlcztvI&A5!e&Swu^$u@e!Gk#@~D>H+78{O$#Zve>vDn62jvgfP0+{VRIl?CVZ! zLP`Ub-;Y-X8=sA~<(!aQjq%l9rpb%{X3o*4j<#)rOE7a!pcw-4R*4o7=7%>=<`wie z!kMJ`Y#9m_*&wo0PNfmk$Tu2!P1sLj5J$@-TuK8-krZb`i`3Uey@G6vAWg4=2}McBN}MLl;JwQ zb7!JNIS|Bjr;7^?mH`{D0<|bH4boihC-C4_ffVR-YE(iP@Q(wHXzw+P@m&|RE(iOi z>zsWn7kFz|?RLlHRD_Q#3z~a-`z8icez|JhXj&kdV~if!JE-&xr{3H-~9_dmprFGpFXxC6Z}*0xZHU=<;f@a_uM-$R@Ol~e);b8f<;bA;yF(Z z72%&TNs}>eLW^r;HvFX-xjrHPeaq}E8{QRqQEB1j$Qiyf{2%0!fPZyMm`nVm#C7vy zH(pTwz@{)NpPv(H-_LX^JwMlBf?)eTK>I?@7=WKWZ?0+=}+x2h_*giN;~ zjWM~7mmA2@J+Jr(np6d+F-YDx1KI(Fm=@z92xKzS`PZ5WGGeNIF)1n_q0SAX1N6(b zm?z8h>j8tOT@RZlAKI6_8e&a~tmZJ-rbgN>uo1AEio(opPa0g03ZhXL0Gq$N>E^Kq zBg=SY^rX|(3-=V;@4vOTH+Md1{Xk4)OlHTO(;VT10Y`$KjrXmS^*NY!pLTV(-^1j) zs+MLSukOnuGz!QjZd;;NnY-X?yz1%*qy?S#a=LU|L9S}v8Hu=^?jLQw|%I0Wl-|1U+_`qmg zcvz8qaZ$16eTe(syidD~6m%`LSdo#gI!CqPzAuVf9vBlYA}i`E+7@cF{4a+N{&oof zrOv13Fxawv?9%KjJle-`f=CmXD1Mf7*ZkKTjW-XN(7Z za?uauRGOqw>7_#wa*(weH*R4=zs}hY33WfLil5u8Bs~1@yu8m>_teH$iZq+-s>*;m zl`BY<10~^}e3K{V#S_&oTYa&cRc>X}&ut=2))j#f}~^gJmYl-0`jD*zK_o zHMO;#)b};#FFyoEZ96|nS5VMO{|K8zs}KC%RO;&x(EG*nYeNzIZpf{H z<-ysiy`MZ$(3=m1b2!?Nj-$cyo9RcH3ls1DLAHCnnK^%I;p*`Z`n}ulbNw}94;i*} zX}Maap~pXLntb`8X{~-){rYgh!14bQRTc(y$f`g`#4S^v7b_1fy<&pDTeSxijZdt0 zxik#B)gH0J*XjScW7bLV@%b)p?-=>C>yODJJwvx+N$mG;2ZoQZ?)2wgIC@1BI-w+m zmHic>t;a3JTg3x~FpIT{XtYu_ovxjIL{CAYEd5=bccMp?2S_pi3fp)>jogju==cvJ~O8Z-m9> zfB@TI9c?ca&L-Y@B8U+pc;U^XtD9%I%87dYUtM+YNx_XT{q)Zyl)3l=uVZZgfcoHo zQQ^QYmKA*1NMh`X*nByBa%YQxRnu`s{AA_dz1OB4j-KB2q$)WjK}O-}tx(v$$trhT zHJ5XFz#+DDq}cHaCZ%NM@liKfDJC=t8&_hXgeJa8w<1nwD|WoF6*7c6;RfVVf^P4o|}h z-JVZ%^xzy6ecYO=o)+9GP^ePbXY9b5U3{zJ`pb)?5>F~}gNmHjBP4fMnCT7PFZK*QdXU8+>+7- zd|SsF4nNg2aiDjaC~9keyG13{soS1ZNGfM}{g0z_k7xRQ|M;|OC0Pe*vYDcsN)CN8 zhZ!B5lCzGIOeqO-ju;6gZH}d4$YBo2p`0oiVx&x_$eCg0e3--5w(sxm_ivA!-n-xT zecjjfdOcrR36S8;6`D>&i{+WCaB1Srww-k)-+jzL0Uds3P|oLa-nDO1$q%<#Vb2~N zI^69kXZByo$sPGe#Y+Y>=g${57Dd!JNpsrh9#g@!{NtyO7n$}bTKIF5v9PxE{82|Qh>vSDX7(mW}u3gR*7kf27!S`#YSQ)04)?GF>heD%LRZaBP z=7ee~)xWu62c}m{>c7|@a<=?S)_hZAC!JaDG^e8+IqW0REr}lA!pWU;6 zoUrKly>4+XKseOmoYA9%zB1#Z7oPex`1NHbH_XqX{v+Yg={tcN7hnss4h@_bRipoY zUYj2N!?(DrQ#FY}3cg%DDsYijq-SKm?~d52s(?{COq_0|THHIE*V)~;#*&JKfXt7s znsY?d_SYig_fqOM_pfWnh9osR5V|3f7we@zh*Z0ND=43Ph!^iNDMz(`+OWp#Y&p5q z+Kj%G=l!^}=t5oX`QOmZNt;NuBS4pLrm)m}-}Koke9rp4@Yzj@)b*k0Tf5|R9#AKS z`psNycE8We&xn2U=g_7;#Ie~?6P|*l#G9>lUpyPW>3(~DW8D*AZQf*h=yUfA{zuE=;`Kqjj=qccn4USbTpvyFjk;JVFo|%!cwE&c~y{ zI}kB2g&S#eV)r?$Pgt!l&o?od_T z@%VM>vUWO4rg0^a6A7TTcDqg`88;T9PNTnv4L2rJ6k7=mSdEjUOmgMr!v%_sE6-Vw zr3PDyP9U2*_V)RMg#DEIFjJYgtI)~AF`Xrq6=ou&1Pf7IAuU_34&g+$_z4UGO632< zcd2~b@0+Hp#qtWfRE-!ba9N`0B8ln0LFM_*&4gFIFn~dbZ|52~UO%pw%8L<#w-{9DmBn9>50@QLS8_@VV>>)+4md%H*2)lv!beW#N2!u()))QTc zDWyZO$WJ}w6+Tn!C#ph4G#jx*H)iBrdvx#GV8m03=2vGbT2%A~CJ(n|)MJ|OeAW8u zkBJZ2{kL2s?W392Rclv^3;0qq*Oe3ZAia#|*Yb0N%X;Y1p`}%8XAH~VYRX|O=Q<7~ z%E<)A^qN@dxIkcKa~DfbotV}QEJMhEr~wnrIK>!UpNfh4M;d4il)ew~z}cr>_6INf zifxW+Za?@01gbN&OqmI+(OUkcYdhMMK@lM+t`A|cb7iLIFnQ&5e zdfs0x2QH9cBBk0_cr7>3Al!g(ep{~Orlk8U@%yZ);5W3FW=)TRS$}8Iq+Z>bxQvK_ zESCp#s`Y9F^QRfZ2_)G9-j~GXwE2#$8h|%;JKUk<#=x8X>s}DHD^Tv#TiATAg312H zBVF_Q8&HOhbnAIra$Sp|Z!i>4uLcS=WOuC%HSy$l1qx_AHu<$6#IY@QK1Nr6+<^Eo zqo&~3$#44%iw0N`hD)4C`|iqe8?iDr1sn1A36M{iqlaxppq1K5{+*ob#>O3Y9`@A> zA!iWCb7(@Gb{PR{Cx+SCV7WBJwy6QT5<>ypd_{0m8PDr4?;LdW?q?o7?{B88y zmbmGyokLMP6>64@QwVEW^KYDSqt4HIF51(fHAj<7wC3NA>WWNI=GnllCu0&F!WR&_ zZa~Kh?D=QVKE#Sl{!wNQ%ri`n4k8+f(a=Ls$cjLT%;R;6wa+vWa9`ik_xi?Ttn@iy$UEe!|uP`&0=B|{-Up*5NQQS-TTYkk}t6;MPC9}B| zFz;CL9V!HL)p;x_)f#ksUCS(qwE-S}PnKgeD*7zu6eIZ>_0Dr=SU^dyfW zR%dY~cl*`xk8~CzTX6kejTI~>HTasTby3{!M?O&qv^s7f9}E>oRAO}09rjj+#HWWZ zaEm@h{10ME7P9^ac{APn%(wpdBFPHF+qNpbvk!jgASuXw0?lOzxFzVu@1XKZ+Lyv8 zKezelj}JaY5H@H<^py;uhhq%JPOOh_!ew02j3&FBb>I9xk~zPu$0zW*bogUSsftDX zbl*YDDoA!ET|M9@HHrS%&zS@(>zx_Q+v5RxCXJPag$Ylbp0hKnS8*QIOCqup=FC0C z(pj=$vFMq7FKmTLPWaOGtEJa@cO6fTd9Lz_A5(q&2lVa{g@ukwq6B?G6Hh*yyIF5R zWO#UW25{+cVk_o&q?&8Cf}y&@O&IY`LeN5)&vQ{+POTZ zZ>6D3RxWBElqzo;-+G$U16!1ajCi4>&8IYbFvao^sFsYv(;bu=F+IN(`1R*m<-DUU z_OUnP^Nr@qv*@yBTy*OBR$`jZyH>4^thpJ%)hApU#|HAPWO6*(T)J$~X#2qEL;i#O zyweeGQ!?eHB(Phnl+HZSWhdN5X4u*EW zE~NTki42xd_029Ed`a}>mpZWT<@t3Sn+oZ6mwI>EQLdidznTZwF&o5mTet#}+icbg zH5B5mjNL1|w02|Lw~TLAxuGn6cqQU6LVAR3rP-qIND7hskJQGuo-Xz}6{qxiM zK>Pl**bSq3D_sE&9@65ytZCou^EXhlafvQh%MTPe!mNM?67=0_G`a^*j4}LVuKYK5 zqVfO+XI;91UWv0*o)$xJLZ8Cwz8mN&2^~%Rm+*Upa z2H`G#{iN=i28>s_UkiaFye%)W$v4XdPn8=8m)eE#9{pRpE(jLri{HX)Y)3aG#s}mo zkb?VpLM#S=G~^$A^Xm=~mP2uL~V9*j{ zSfA!tvL0H^;ooz*2ou}=J`rHW{(by5l%`%gFMS_tOESnEGoPWrJSDfUaV#{- zeTxIK(YlC*=JPTwR+`--{`@f2!R?fQDfdHG^?C|{2sS7ugnM%pz717yK8=MVz zBN$-`FbGtvweg0-@r7nT<^}hgmz@=jBKz_f+0CXaDh=P}P;dnL^!biXtq}gj({b*| zTR*e6G@K?y^)GVADp@rWdf`w3pWxIhKQ1|J>G=0PAwC2TI1Zn`Uy%9ld*a*(p~5<` zZs+Gkgx~OT0W=k3z^Y~ntT|>$QFJhuBmq0C^JR!G3Qql(s`>f0T~H-CC&MkZO}*r~ z|3IA)%>Y#VxQ=phv$~6j*$|KtRZ`%k*^}v|Nkd!sN6N~~YKn*wqJTdZpQqlLe86ZT zEP`X_4$XeIR;l?$xzn%>t9B#T1`A(a5HQA7-{xzDJB|d>1T|~4xoa9&uzGapQ!rM2PB4xh%f#tF1;6@6EivRLxV*bX7lZTZCVp(0eJSiq$`JNoZ zM>iFKFS3|#{6o2=XBSt#Zyq)(h(5!J1h5${F8YLUNC0mKWR8{`zkVLkdZnwbz!o9NjL=_d69vCZ%O$Jk_{#RA%W3?>f`A)L zW^72Z_tI{<)k{I4c*3c40xw{_#NJdfTfGU~_F}?fd1HB2FmEttl2nz~mEq8@TUl@T zQ=t*sz3_=-p~p?HnC>^f^O}itAcg}L^Zd)P$k4HZ`KACF4&y!iildil6)uw{A~?NE zaxX+Wkd7iiiUz!4!GOp-CO}yRm0j6aFN+$533p*UC+SrHK;)K`*tyuhCccuj_PSQ z?*5QCatT3OWh0qlzF$Y4%P>lzu;pAO$U|Me7?TI`6{XvB2%K54HTxK*3=Wd9F?!+1 zaEF&u*iZtgUQ}A5?Sl%Dq?htmIaZDAyRO%G?I*2EZ*cR=vD(jiF`~-_eyttwQfH#j zp=)4ow>wCmx}P`ujZZiJ(-d+KL08P|0Sb!qG#ahLD#XQ|N#)U{Ub4MR^g~%BVd3XM zbS6*a=#;O1ClcKlZii6-F-vGF$DG_mZWk!8v8s9F#6%1IkO07*Yqs5H{UAKEGsFf~ zMHF6-9X$u8GYoF-np~!+)b^Cr+gNufSY$#KDu!MSMoY=(C=fc5K%T;IY?C<)q>PUt zqSR~#fhQZ~h8J)J%4p}DVS%a^eG2zNZh&xpaIQrgfEm!ynob|y>Vt`K$G^3sGIsq1 zxt&j-d*s!lV?h|MP$dXl@TQ4|nOBa+?8;fBb+a9X1puR&jEd^r6 zBRMVuv(Ust&E;Na4RJNJj~eFY#{7zcET zlmWlaAQrR=K0_-^@ztKj(x(k8b^eRrY)hAmV*bq`cTu4*$}n>|zjTm+#S&FhT;$T| zWhi~|wpO4+;2boLPsc;Zc{+itbQT3$r`hY^;=h?)HbZA}jAvqIdPBmYag0>2dvnKR z_dLsz@J9i*VXr-6C2_-Ey92)2$JCk$64YOA_G7LV*=Pr(zQwTQQe}6OUo7#7>2^yD zYnn?qnAm-LrDOi7-HCNH#06iPCH){@J$nZ!1Wp%#DU0JNGgJtCg+9u$D;!3=8hEn1 z#c}LlcjQ#7*;rQE>wqJcN3!K)W@)t4Rom8{?6!4H6wI-d$ZPQqD#-rrBKEvsqOMRa!ullkctyCj#LhR56 z?|y#Jz9%Cnu2~$COvQb-=3A)Vd@3E^NYCQw8d7TMC(2e2cx-XK)7;D`tOQ|YbO@lh zflm*b`4#Lz7MAOD=ivwdPA+Hzx2>K9=AtNdigGRX_>CEo@MGv&9ttyyqxLL{QfOhJ zfqXn?IL zJqSDm#IdtzYf(MNv5By}1meD%n216s&`W`rB;=@FpkfCMf!d%=Y11uyzz$U3B=wz~ zh1CzkezY6MV;DTH)WJG)eL~^}O8}JQPV)+0TEssKAbiXo=G|VWUkamc*dL+!F|dG* z)fy7wa1W^MFjE+i!I+1e(v!=yUYRq~ZDfNCtmC{nBhNEKv4T}3NK8|yr;b3Tu=TBl znoMsPv=iUY3wKCEX&8ZXafZ;Wb;d>u!dhOXFH5^>U>KMN0j@*O!AW9mgaveD`VMiu z*ciAsgS^7ASFi{?R!BpxwSaKw4TpvXAXg_^rJg3JiGryyZG84BW^T@@Bb8x?$o*iF z)QV$(YJ!xiWl116ae9{DW-Ad(0i$V)RS5%IFLVOBi%AOV(y9tRgRA$+{1=m?*$M?2 z#2x`%3y&k?BSp|< zoWXnj#Vdop^6%Kg%bhG`a+^Kc^0V7a==LPd{_6Z-{sp(P&#*n*DY$`9Z7};ns&%A* z{QRp;sp-bk$rC$=*#c~N+_oDO;OSc|?9wV98R;%~I*lL56!B#u|{fSOK4aqfxam{P7060EQp9g z|1oRt6#yR{%`h2?eSZ$Vtu#13+mdL#j1i?Y5~JS(PXu!@&wUVRde`}G{-OXmUtmNj z(-qVU9dnQ0vs6_c9z;!P50kAY;xy94;a4q1^s%l`uFyVXp% zTJh#5-$@cdoprn`C6Nah#XRX9I27=t09DB2YE)Pa;Eavn#8Y>q>J{lJ>b@>xQ8~8h z0W*n!J2W?ER-3T@Nl=kXxoxUty82{`R5A_5>`Mss30)f@8~0V)p2Nr3dD{+b(j(BV z>P7E{QU+WC202mmWp*Dqdm19BZ%i(Iu*a`st0uV4NPSPsl^_O7YUzd7gFT#x{sEc| zn~CXNZteyl5)wpp!<3g0d?yy51?Cr@Y3v8E7n(5v)3S?nYvTsFbi4QmpOflBh-6-~{!8EN^sueq@)2+Q!5^ot zFIO-02=d&8kSLgma$u>ppi597Qg_sVFti|9K7`D9Ym9_P2ABb4b zGSdFefg{?b_23!}G>OA9bIe0;k9syi3&4i*F70PxKe$T?KH5!Q-OdcGiyM)Q@Z*b8 z?y=<334qmCXtA{M7vA_fvH@C6T!|Nd&=UTg4CM>}rF(y#31Myn7&|edRFyTBArQ@D z3aoW!^$7jTthkz&4(8kZz~3f9D ze0^y>Ye7&*MT`*QSv((XG%nsppD@!o78S`|>(He&A9|}nB5+zjn}C~xYbNQD+o{Wd zkF(S&%6u_;Za6+bfD<~z-l&<@W>{Di(-@^lJMK(x5Xd78Q#tuR$Z<|HNWw~{nCI_K z(2>&%g_oF<=bzPu;L+9|Mq&m8<_wVa??ad}S93~PoP~2h0nUPg9)SA{=wFi?P|1Lt2J-76$KE!Qzdj8fMEE73>Cjxq)M_T?>FVo0L3 zCE;9T`aNi3gb}#Jgx%h;eHe9L^Ypg~pq zEil0_^Ltm}I36rfoP{aU3wSPjs#KCLa2Wu0ydo&nq;q=urRKqzxCGh^1vBwnI_vUt z9TLtGoYQ^e8}TA%3PoW538*4fH9OHO44zQsv3n;T95f_I{?gnAaFR7-87;&w*U65A(r{>XrOM8W^@ddglEga3>$1r0 zmOooiz2oUCpC-f2Mub1BceGgD9oWQPEb3WXb~2v4qIm2+Y~i3*RJ9N6Z<@hFBa|*( zn&BMxs`l5Z_c5^@dx|zmoT>2fBRgj;`3>ve$TN?zHxSa_F$&TwuFZ8*56 zD3>&gYTEs2Hza;kcf6v^5w&D{ZA07k-1C^OhCRIx&t0`x7UYKg4wP|?fTwKXybdjohs*cxB@8xKxXIm#|6naQ zt1tZ8B#}`NI^s2b_mp?+G4cD)SA^w1dt5blO=@=IU=pGC6a&^;%T_!%(69Daw7;Lx zI_ezWRQ}}bEyzP-m<$6|-d|dGH3qd*_cig5YK>w-?>N^c>mkYk$mP^NZWQEowGn zMko6^pSa3DXKVCfyS1Fm=$^YYs&^__G@L2=YL;76d?p8TJhJtN*3j_Zv$9q(T`KC5 zr<{~;r#GC31Ih?s`Pq!_2#VY-Nag2ejS^U25)s~nt#mjQHj_EufCg48q zmw&Hg!aLGJ2rOHiZa`Xlklan+$)-n|G=thR~m z`VZFJ$U3xLcH+2b{ACjmO6zj2yxOA};uEc52|rwWBa`Ra3@iMb6&iBkLqUVp4;jZ2 zbt^Zp>kl6~opZ;~)uJrz(3w;@MB3vC^R1VikgEs7Z$#0rObT$`2N(GR7Kz7F-+C^b zm`Ue(Ttd9qNJ+AqWFbaa(oBz{Zo?DO+J*Bud8uBM;Y7=c_i*((ka+dlyj z>w0_T&e|*gO*<5qT{mZBRCtVfYqPOJtXe|Pn_oB16;eM}#_X4H@$^hWbU$=(pLC@~ zrnKYr&)!qBk7MGu4f$5i5oZ?vYx$HHR(9v-z>_2R@<27c7mAR`6uiOjm9s}Zd^KS0 zbBQf#lZA(Os2x@Ec!Rt3(kD&+SB^IB~fk2!1cZ7rQ%<^K2A7=bSGL3guyLHgCz!M3(tmDj5P}$QBLi~ zrzLH~ITAkIy~lsJt+iDB!*8YIge}cKH3uFHxsg?tdnFamN=Q+B#9&d^7Gf&zD0P=! z!FwyJ+sZlgZqKX4BI7Mw2NJl~043+qlCK=D)`6zW9Vn9Q0n-a`>v>vV)y@k$Cy zrMjJH6Y%mrT~%h+UcGBJcJrdoRoD;v5AX$$H(Yt|@w0R1NZVypRc*=50SC6 z9@?sqzpd}$F!vq&7W?hK*sT2Q+&>+CGY7V$?1sItsZI4UczMRq>5`{t+I~`+#;cHe z&^zKqf0@DrSi?0Wy=gY(RV6J&)4Z3ES~ zCky?y=T8mxp4+utJ-bUg3*zed^tNYYR5vSbu=wpRKdUD3%haX8AT7nq z6Sgg#_eXlR7*a-@$jT;5wWs%u*bRQNx>`Rulg(9 zKD%QdY~9oai);M6Jh{?*U_O2!_w7GOM?%PA>Vqzx@{HIK9d#btb?tez* ze@JHJH;sSpy=A%m;NfuZRqxKd-No=5&ZxYN%!@w-lW~(KLvIztjm{=dG`LKM+hD{@ zLNEOKALQ|W$L?B_WNQU~j-<&~#-S?ibr@f?`?IsNSXq87_G#YXw*dzlyR8S^t2j$W zAGJ=B@7V{pim=>8falN7pLenC$S^FVp(`fYG0=5LX_g z&?cSwIZ)(4$p4j^*)jOgxNjC?M3+|&)j%=>cG}5)Y9J8UPGiSvlO`rrHJ7)z%f|eo z!{qn!yl#J-sC&A@{Fup`1IHc?{k=_6!VFHN%67|1%{3W9xbFh)_D%(vo6(Xlc3&77 zpgxxyxGy{MWS@o@<5bqeUZijgb0X2>)DTXqpWkSfFbZK|y{?su9BK_T*}b0PZ6t(s~h8w*s9UsQuygd_yA zTtBo%Jv@nNw+^_}_G)zgvCa$iE(=4~<(+s#NeU zTt@Um%Zd257ph>E7pahMLX7?-hrLtHkN%yfHgMhIaL{3LdvqH++C~cQqM=e8aJahj z=}|37zfOOQ+JY#=-gq+@Y>qDpJ7Hd_aA*w@>9QNlbg(M9dzXa^H<($ByiG^H4$(1C zC2yE6LWyeW@V8bM!C-W6=`&(M%cfKdB_t=EVw}|Pk8s!C==fw45~!e4{JuvJxBH~J z#KV#SvF;=@-5C;2eABb+AZWTWj39#*Vx+eT`(6yty&yM8TKeva|Jj@Y4g({{O zt>U6>Pf8~lo{XT@$iqK|NVu1+N?(peu&HA(SEI3as1B_iyR>uy4T5mW^sI)lV#}bL zi6@IUH5eh-)m3-2693o9Tf*DykY*rO=Qx?)a(F2>+AwOAfgl78_ag7gjtJ^Tq%P9+ zjk0vya^PF{8Q#j!$G10pw>ob5au#GhOdByuyGo7*C)|&sY=dU8(N?g^i*#G2e#qbd zu8u@C!CxQ~=RMw>Q`nwnJW_Q@f|Blo)wi8cd*|RwuSeZSVb%)M2=r@T$)7`1a{Jzz z3>+VH-l`WL3Q`Om-Ohh&Z`zX`)4Mbs4mh*ox0MLqXLV_;H$u&>TpFXDoEAwkqFV(n z#fzWq`#IkSvh=K>Pz8`pc>3gKA1eC3>8X$;j1nm&Z~L=ORLyC+_1N|f%!qjMT@_wn zIlA%lO}{C<$T-LAsh!IY>gpHer$f2pq7+4F*%wzXGRX&fz_`CZ&gG!E_GlFz;@>K+ z=f75X^ zA}0EYb0SzqhF_v#j(+nY2x+k8VuG5tjEi5q+ryA_xin5+_T$}q0>M=|%kk3F#ArvG zwq?l>e8qg8eo6v-a3p|>Gw#a=CaoZjv<`AF-Fv*{spR;*6&=jqsQwKpE9!#@z@Zr7H`%BhS;Tm!jf9G~sN$S}5@5J%1IFPJD3E zu=239)6OV^h^{a_69U7+$k0a-H@LjgW?S=4j6)(C*pDN1oGbnZnZq^aOe08Hd*hG8 zfX{#J_pM@A3eG=xb~yH1PW~Ns41lJLt`~lXG2$h78L;94a5F#Mpfp&o{$+65;_zdM zFZwm>m_KvPyVY%trfjh=Bb@33yyX8N3nU+X`P|1owKBZD)W5|SUAN_-Yab9YhWQ8n z2Z`3ZzWPMe1>`%`c`4|FF}Qlbm@YY5Ka-*^iI@8yq(zh_efZd8!ryB2Y_;g2M}W-% zP5S1*|3UKKyd)2{;{JFGVMF=GE2h0(P^$0*jAygO&3S+Ix6Ist6GoawaM=XVut)7K z9YBs3!L51j_NQAd{fE&a2IsuI=i4X&wy3Fa+xAgVRhD{qyd$h`dMk}^7E>~;8E5fr z5>B3xiZ2y2S=88u4w_Q=Dz~3`M{p`?!=WfMs56S3ZBOpXB%R&`{|5KcNHyQ>`{LdP za-4(>Mq#&@wY^9{k4j)`Hc^VBS7|t_sOmhkZ#uX)F{|S)M2kH;QXh`eyNOr29f3m0 zdi`P|z)3aRLfNgl<8byBLZODb?kIu0zUA5pcl)gP&k6U(S7}HWe$ZOcvV?FxVx7Iw zBUmf$_Y)ERbwPs932Ix+$K~|VURb@~&$Z4YXA3N-#yzE;7R2Xw!dsWd%UXov5M!3N zOv6}ZQjed!!i0@cEBh#$>d{x(<#j93SmN~;Pm1Ascp86w?7c((e*q3wS{RG;lekzW zI@o`%>%+Y2^6y#L&__KlGJ7jAC3jsS=}5)4(i*J>BWX_L+-2yz$Pn6_Gy z6MNThyQ}LOreXi)L>g^8ot(0U3{REKHtUXxu_07Lpk;9HmFAE`cXC`zpd@yGwdE>n z@$KCo$9mtZz@Yh)w;BKv19zp`IM?FcYfL^lT>>IG*o0|YNN&I|oMBP}&v~^iIxhHp zKLHjO^WojSK!r~Uy>`W<$0ph!tp#}?s_n@68oMG@8&{$gQxWgG!!N)x)pPQ&q9EqKR_tIdoF)- zJNid_s;B#wh;~wM0qAC#%YDx%!`%LHS)N_7$fo`sdbuW4tupP~L7>^we*s-dpvn$C zGPZm1K@T#J_gJo5`TNe6tztC#W+X5BIBTPe(Dm(b0Og0GVdoBb>~-k@Mo`sc6Avoa8UXUPD{fd=wxORp+TkO`nRA zs9i-7Uw|#)rQE{N?1|L%Fvyn2Y<`GCoZ&pC&s3or80?m|T+|giCovHwUWS0Msz=VB zk7<2qa#9WBrk2z@n?sO8`NbF*_~T+|BYA(byFuWl*Rc}MnhK11=Nh-t zjl1QBD8Jk%Mq@jo#J^dY^3C;rDKuSZ^xn2HxI(hMjxaPK&Yk-vxG zUB`cdrpI%|o}iwv;>@44_+CY*Z~X1WK53vUR9ZwGEda56%fAgOlspSY2>l8(r-qHg zl5RJt|2|~u{MBoG%aq}Q^=Qjke?7;<=O!fIPp6i*^`72hyDW*@WIV4XDK)5k?Q1$~ z^SBrjwqXPS@Rb1}W)6@eVl;Lw0@1cPin;hB!0w^9J?X>S4|>^kX`j-Qf_C|YdpqH4 z=vI}1+B9et3(|iH%zWKVg90+S5^0}1Do=DK+7H-i*xM!{me^I+QzPw1SMz6Pm;X|e0 z@63wI#KA{-NXzTmS||NmTTFRtoLBFWp??WeSi?+9@sFKHbE7dcz2Hcg@d4wXd+-#& zNTw0YGaMT%P^08)`er!z_H?{Bg_w&|xhaF8KM3WcMU{?T=CqP(vWGNsiQI|@R?Poi zE8c|v%UM{Rc?!S&vWjt4`jJhX?G>pd5wYVAEs!H9+*k$8K-{<2o$!^uy2A=||5+Vx zBFF?7O99SRec;N>r6WYw|1HE9C_eai;5JpB++T4>f(CsbypqCvk*Bx=( zafU=xAC5*if9BH00hCBpmRy$}@8TXgSKULMh`SXiDFSMS_J8fp0?u+!;oAZW|I5=zR6qA3a11odwsj8(<|2k{R<`o8zIW$kFu_t{Et z`gSGb^DC)u1%2A_tDI&XCH*w~-z-r&F&c-Mg8ksb{~3rmwj)P+Y%>d58LI#iR&jL2 zDP)^osUoYVn#HjGze^(1 zN{x(R3lIkc7XLIq>`ns+f#$o`V1E_P&|gj+8G~P6nX`i>l%6Jgypp}fKHflInMdZuM|QV_vG`fZ+aVdh(ej=)rr8k4!*dn(&XhqMSo~DD6w9(v5=cW z!4R~u>QbC%+aH}RL(=EwB-cc|9w$2nx5|jjEZ>iPH0U{1qv+i|Tj8$f9U+QS>~AVQsQ_RtzP&k{IS>Y*aCxRRa_R7Y z@84>XHV|KK*u`%O*!4$I)+ZQf^?*^Ib6LA$B@zr%I2Q+!FEjIDAi=A@G8AK`$awwT zL-+KlV-Nta9G`*U+;%{P;_f(YEOPvYy(V_W_s6t~gy zVc0vptog+dWJsV?jmxPT{0BG52nm07o;s$jO@=nF7sSo`ZWl2i$>RXAee{u^q`DfA z;sMNOSu85GHdm2#Up8{wMFIqNHYV*oa|xOc$9^R8KiOm7cjHT|L5;?-(=@CFZzj1E z7i|K1{eNKnf{_b9pS0=bWz}M9_+doV+hAcxf|#cv7y_L@-yHrDTs#)}>!M7HPcnXR zxmc#)uRk?vTF;M!doj_K#b~Eff%*c-pv~!4xPwB>M42kuV@P_>In- zIM1Dj$;kY>OmAoFE`R_F0>@J6i?{HzOjf7RJ|}PvbCqHobr0 z7GPib+D-A_;Ct+qb!Uh_U<$$hZJk-H>Tz7tE3aU>C($x+t;np=4rvC)Pk{dc#7pDL zV4$r{3XiIk5$a-EFf$9B^L)9eQXpn&eEV$-xtjrA?GSA)i=qh*C2p=^PH8o&zC%S) z3&eSN`pua^QL<F~%lDsd(O zCvcdq68HKc>aBm<(YT(2TK+P@gvoKN=rX|d zRQgc1*V7GrcZeilfywiXTTHD0H-o6!!I51ypN;#oc@cu#Sp%l$uRFs4?Pw`7BmhNb z)?>wTHIGxj;9gi^q*Ncv$z9Oifb!&UFTo|*mK0@x2Pau^T;+It&_DPJFzf7gdscT& zj5cMZ=U?LRvt4!XtYe?W`)ApB89%ixXKlOR%R%S>GT^?c1{HMa+J)OCCFqm4b)WQa zHQ7AT8wd&e(c7O8^6J-;!_t3sC9f<_I-OBJvQ2h!!1_6SG4t5PptBA59-!9K{-D0B zxm+#jYP4T1YCRa?1!$fPSE_YBR_UwQ+Pt6P?JePU_77a?OZIxN`Vy-1z4g(TUo^#- z!$DHGlbZ34k8cJfm>Eugp!$ckk&_z+8J=9^1=lC|71{Q~hk`DMnLfAJ6Ug1{jw1P} z2IoB87We(Mmhyn+hx_h6Fv<^7RMxxT%LlseJw5ipssc58DH|t`9+W|htODHM!<%kj z$xo8(Yy*V@b54sIzWSSLig)cf89sZm6Ho)g&%jFUTj{469+%D-m^6j^nC%pHiL-DR zn7(iAnoM!Ut)SZll4}m~*&}<*z9oEx4it|2G0UU}HvEWd#;GrMU>gF^vu{)-VJKhh z-Pojl*Qk9O^`GTa)gemM^E9z!nnKs7(DPT#V}=@=*}FZf9_{z{-Deu)Zr6)&7|>N% z`p^HK%+Q$&=bN5y>+OJ1(OnrISU#gbF~bjWlvzEd)nyVhIbz|s!?nkAv{p6yvgFTX zlJ($%lapS_c=djrQUz0kpG9hCQ!e$)?Oyyu_#m-st6spnk7k5K|GSLHw6Hvsd z(6~ZuNI14gb4Cy`$LV^JH7A7sKcmG}X%3J|fZ+wJ5)>c+!WEP1_h*+Aa#irFvc+NYca0U~5K1*P{KtiJ}BcLN#N>-mDO!v9pQl!&jB$ z!uBOE$@L1o|7xI%KH;8pIlyA&k;Wr*=jc}d zpSiv?bY=Yt+T?xeV*lyVLGMHN-FDV#_6ybp#mbz+q^SuT?d7QMPf1Ii=R{zO+Vi*Db4Y@?=t$3`AoTUD=1`wh#)}fGj<09Kom9rx0p%&PN$TFr zG9Cs~K&;U@Rv1^G`c8ii-~gS54i|vX=|9@ZDPAyFV|ul7Mu_M{7J)>`A|930lW>iU zUyAGmA#edyG3H|KAKS;n*2}mK4}I|mD z>dB`=1|+>eF8wTs(^RUqY7%fcW`6O$TXB}5;Zh*$H7tZ^dGQox3j>$Q0~FvFhM53O zRNtWtL}&s&3t$3)^JQi#hyT;3jIrk6KSu{U`jrBYE03-?XA%l5S^HS>$*IFFP=B7e z!jx{w&X@Yu*gD|n$?Phudg--%0>ETjr;7TWBBPNKlGwu9%eUP)gB0SvQmjy*IeF&~ zLHT0MG!HUv0UDmXQ zvaaqz)Eo(?>cM)mXu2XOil@7{Pi$U8eFWkRTe=taK8t+asxeuCf&rZxOGy=)Kfn=Z zTAWqXy~KiKdOH!-Rg4vVws#mt;jBfK$J+-8J;*TPb7eL9X!YV$*tGh+y9aA9|AY8J z*uYNoAk>bn3lS7ySd@D5?}X9EJJvtSY4YqIfB^(;TtW=U5#7XfQJS9sfX#V$^gJ{^ zLKDyc`P})4^fj9NNO*nTiPVlu_{aztdNkf%>o(%v-~NZ_mtmn1KwIw)+ZjoR_&0Ev zq?B|?L^$k3283Qe+AmnkKOd#r((93__)Z)!j-1+x84q2bYZli7JW-qjxF_Daa=Bt+X4TVIlX#8uH)FioZ|#y zx#W>&fZR9>3e`Eor63`G4tmWnEFv2jHl?vSVK0h=x{8GM}1OV=OoQ@Rz z18NtA<61d_ayrL69{d^gz|&@YQZ_zZMhF8GS$(vq+M7Chj@-n|$1%8h2pG8?O&wQ} zN*EvjF&W=3k~3Ug-5F{h@sAJv8)&X(&0wSu{HBC1*~o5oxmx^_1)n$`tD_nM-DMbT=!ZAGTLiZ+NTKR!<%_d)ol=MW) z#CU7l7SqmfTNao^7T>OH z{w#S^fDynr=GC2eTr3bTzCakPkf&5M^b$d#e393zwxtyud)KXSO_eCU6*AQYmtkHF zGM>BQLztV6BH{Ts3p+iLVXC}bCg}YXC3`b@;zlN>tK2p4>~j#T;XHFPST1Lkp$f=w zIj-2gAsig^5qhZi{w>Y_N1CnL(~UPk6HLW0otPe&4-F)7hX7vLg6O@-50}Ej(CpF; zn?pxk!ln1NAzi$0T2|z1lde72fQ|jaL!n?~q1pH5xpcDp=R(j+AHM73tJ%=7Su#~! zD1KpDxt9=w2vq*OD$hda6Re?_x#s`l=*r`n{{Q$`SxKa*`L>ywa&;J$Ic9XYlDTzA zYD9g7xlPQGlx9N|g^^>9TwSPy#6(~7HAN^in$hH#W14+`Z@>R~M4$Ef?EQJaU$5uu zd7M&ideFMIcQQ5Hvnx|0P(!B<@#85(7c-a>&}a8;(;N#0ZlnU}Ult@WFZb;?rsO4v zwNfodR%4Eg*o}<$ftMN2o3^Hnbj{~)s+Cv*N-_&I22?d-Ex`VkWZWWwT0qv!0GR~d zG1H8kP}Z0vCIjTQgVMaB8qf+c05mAkgeQQ;vG@>)gzyOriVWdDjt2JwXs{!b3-vF`qOVeT9!I_&Yiu>8hLu7YZtNi?nr!; zoKrs(`JCQg969WvU;ivm^JrG(la#OrzFVw5$SFKb&7KJgrn*I43*I=a=stvK+Z(TI z-fTh@u>DAn26KH0V|rytx%fK;f8Q}N58X66Y`(r)BDV~^i^<km;V$3U-@WZ|jT^n+6)NRPWq*%o`&nqhR=->m zY*KQ_86g;YQ`+2IZPND=UpLG)>6SQu+Be_oC8z1q9hC^L`YW^He7Z6Jvgkhj6!ROg z=*>!8*{9wuCuxJ|*uvez@{~JsoNCpqrx&LAi!Y2ysx>?F<2U_qIiZGZm$Fq;xndEV z{6YTRmBbX%bl)QP{@O+hukDKHP|t$9Eof>?Zbh<-&*8hdbH$s)vhSPHzv|2fa}0M| zRyPp>uKUshTpjWvcm)EWLoap;XkRp5)>2E{92-T<%aXWU0(GIvB#?l(S`=n_y)UoX zAV7UXHom6VJP+9WevGPhSWZ?|9wX>krD&Hcbk*kq=|Pr|JIkyPw0Mw2UcrmgtFqF( z@WP09QJY~oY|{0>of;ZslK9{V3=OM-*+iEVkNsi5|0$d5u|AfGuHDp?RiVL!ihl+0qioNn)=`Y#8`TKN*YIWgM*uqNEnPl@Uzsl~V zO)lsMH}yjxnsUcO+CQW7l_z(pqI)WTMr{3cso@4S{PKz5`57$oja#?w@DblJ=%HCd zSGANzENsJSIAT)l%&gpjz-q&?pZ>P$INVU<#`Mx|OM!f&RB30Z=C5<;luyB?{B!%#8bsM5 zM~kr7$VDu$yRe0I)++>{g$GJWUC z{!I^jzu8+rZ&NRu@1t3mK~tCvAJ^&^w5pLky@kKN^-3D$tPZt)wJtFyDlJ^X`UZB+ zTflZpX%o;7Cci>vjab*1ijf;%7(TBLYfeA+wlWc>PWxmGiS)nck@92Lzav&JZtwA> zE$_)}IUBpB-a2hQw-E|;-(UIULTe)e;H}Y?tGylHGb@HHD zWCk3F*Yx!-A@0S%;u$&}cZTIW)5Gq!xm{A8dX40;uKn%pPt3Bd)jCxERW3{~{b`kQ z_%D-G4As@5?8oMvBJ~$|ujuCix=f4uVD;p8{%5y-a;D{O`dQYU_ec?b#(nXkw-|ca z|I354vj>G5o8FzMMa0$Dcn0P_5Z!erCV2Q%4m3Zohx2IP#w{O2WP2tng-q5e9T+-G zM2J7AVyjLiK5C79CTd$g7FK>^I?+6xU>7cr9W?rU7ytZi*-5#}zFd*%IRl%aB#ob% zON=}sXlhLto2oLsKYFHtkg@|(9JVYcGH$M92 zalz0Z{Z96r>q))Ds~Xt=KUJAB^=5sWb{_+}iK~I(Ihx%U%|>?&!4aU%Eow-%noass z`QkT(5?af0XS7N`82sB;a;;#&86mnZakciyhU7@g;L#_vjQ83rgRA*j}u2ENS$!JH{3kp5KnKF(!v@JRu^@zzqF$AIE9crDoWfNmJCV2Op) z#c3W$O3zVDg%SKgkg}adsneA40t-yt%;fxh>b`?=%@Ir>&Ct~NAk68RuthPp4O;}ei|jGHjR;Uqu8 zF?r3V1vFhuY#{diAI`R?&E5~gei#G-rhfu0qIkP_h#|LaH86OHDo2(*`^*rrYXdM9 zXLZWR|6WL@sIhiP?ZmpIRUrT+vJvf;NANq%)eA*Sxfz?iuhUMyU(EPy6M{`+^jzb7*)Q zOk+bhYb-Ap`=d0z{KmJ3?GTSmDx->^8CrBKU;7{@<6;qrx&I=LgQSl+>hd&3(7<&q ztANn0oNb3iTF!FSLa@TJc}<5GfJye?J2{#o29uaq8INNNY3acX5AERh&!uu8 z!w{JX9nR1rn)&UMI2p75An)ka+*5H18_Aj6NgQ-;<-WNB)q3HEqjJ*ma?A=bIY?8D zGGsy-fpYlPi8}REEo=*N-Xc21{Ze;f)0@2od+3~nOpBnKF@ef8_ zy#7!;7NwoQi4&I9y6v%zrNV;9WI0Nr4O+I?TvP+Afk@HW$q~D)M-e+{#uF5_lKAEn zv*Z`Cw)L~R^=1#7JXYPG_jwJ&@a;w6sz0mtddrxhAyR_$VN|h3THQvwu~eYtSSrkL z@49@sh22&A&fgL`vl@eNPG)FV0|+XdlWcYWr^AeCy`eOd8e6V_IHbVrT6MkiQM9c? zFN~HmZxmDrP>c&NH{4_nD6;b5WmaAO)49V@QdCc;crYa3{Z#t3uhuO4w)~?=Ma^ID*qd`@7Z-IinD&WrhuMiI zH%LaOC4U@@e(ZwME=(`qpC)8Lb=8R4#tNdz@0kbwz9I+E(fM`a()+{R3Dy6AWvMC2 z=)s4HNw?QS6ZuZ1qWf#V*UD^9MYKzYNx6Xsa`Xs#9Q9j+Q0Sx>1K2^KF^nMQok0AE z17JouS;6}}tW;ZPhqZ6K)quC-aGQ(oS_D$QPA{^B6|xLXH6kb=u9l&Xb!1`*_HVhI zE|g86S(v<$<}aA+^}u@V=0NE`^4l}^AEPyCGh&j8FH&b5w*bCIm+Ei`QxDmz`qqH3 zvI$&DM~eL&L1{iEm-7y`+?2(Y&P;A_FX$$OjCIzIQP z|M|01tq=&-zA=`yw!ldqIJK!9(~L9)xewvTeU z_$JjuisYm`lJeKC-MPxn(A*6sp#i;R?k#VnMyh&c;AG;gpg;M|zk2%1loG9UPpuYN zLJ4MdbYTcte*PdLu{#fG4fiA^q<&EF2y88Fv%hbr)BQbsM~^&--!f%HcDvs3Nw?Y4 zKs5;|`7QcUYGQV?o(o5H@p~I4tdS0--G5y)3LG#yJ1+wUn06xsn|~h3P@iS)X@tSK zNZ7c}zvmSPJOgE-H?!xTc0Jxy1mXTo1g7FD;%J>m5iu-hon@?nozzfngT@5JE68k; zvgUFL^_E)3#ZC_;PmT9Je&R)bML^e~(Qzx`9{%^@X?>QT;k4|9&Y) z?C(!P12hz&yBN=UJ=i}il1bi$9y>KYsCz*gfoncbKv=wSj$Sibef#Ey0u{V6;A z>i4AH=Oo`={R>JQQ`@e7NXTfY$G4cwBdu$0ly7tj_xdFrugK{P$l3|nbFgh-0BX`- z{pTN>!L#9gcMiFwrRo`xwM?!)8n4O8Cq1H>ZQd9a*UXnx z0?}Pw<~{}6O}Dun)Np9ZV@e66O+_#MtwnK~O+M7n-#|4G3lM`VGu<1!0)rP010OLQ z#-5s>y<^$XB+#Z_`S?MTJKdz)-|&yzpvW+qS#vXYIyq7O#uK$+Wr$d$fq>WncUmuZ zw%U{l3p=Xt);Ri%sXD}KE(b!+$yvxtfcB>N@AJC%>SKrFrqNj}7gjU%cj@`l-GWptA2PL*g;g?pUT)m$EUrt zI~PJ4x{v4OVpw2{`66+79&lBVM5I~3F0ofX-}<0gNtMT!2^ayrMKo{hmVOB3@Weki z6K}fnW-CxdV?nFVPnkODk)EYga$xkEU=GvtYk7(+q@yc7C`w_0mRS;aVJoevUpT3C z|GhflVZ0F~?^NWA>2m{1Ci}utm}@FY_|a0KSY3WGP=R)V5;WIfMgq+8aE9l$o`!#xxq~X z-xhQ1qGEQd<6Rj;*+AIXir3Pz#JLc+Yr+I%1YW8hbCl|dN``>>{H2AFq1nm?+9j`! zX4byI29`q(w;x>F(utNI{1Fvi9S~p>^SS*O2vGonXJL^xL50->iKz!U4cj1RGgW|b zMpC7f(yVp2g%T|r^{_WpQ)5pcWYRbW^*~#E?9D9dC)`9DMhNclp=AlqI+qtV44v4b zHJL{6-~8ai?ai{#}u@Tzi##j}J z8O84Nr;4^pm7zuJga1NQVCh+iPz`7us77p;ka>!C&o--==0G`>2D(8V41EueL5gXK%*zg zfgt@N@#3Qot^40Mz}dhR47kHYmxrb#X{e}&z30*Wh+^%$y~c${6VrRGc!T>5ks>y8 z90Tkg4!)lG$fJT~aJ@f$Tl03Zyb%u}{PV4Wi!4X&i)%LuRn2M^KL^fDSNxyS!f#nm zxop#(hfPx0!hf)8LKI+FFHY=QEGkC0&~aGStP2U5-4P!W(IBSB(Jp z3J%9b2T(mOf^ubamIPinS>Fvb<52Jid~agu;OQ$TGvewHlsxT0+b&Kupj6-q#ZE4! zx176nqx{xJ7C2vObFq#8@IR*yygp=;7rBHprr;-p6?>;l6*v$HgL%~a;5a2!E-EI0 z9?;WQ$s9f;qZ>>O0VuU}y^meWudkEGi$kg&B&LOI-qJ&Aku-G|yUOE1=qhjash{qR zTgn2En#GcS+Ny=1f&>ByD)E%OU00EI+y`d^rT^R*lPCmPH9m;NOHblgjtS32Ct~kAyoS^q8@Xs9A z@2tYf;19$=7YoL}=WBQv#T(Ofa@)RtM3x8EV4xa3F=tD2;^sk+#brr!S@Ij;V8@}- z3TFi?OOFVA#S zCr&IH3Ir=$W!tkIyM4qP7MC{UeY+#v@Flf!C)LNg@G!Fsx*lujWdLpBOM+KjGs2$f zZ=L3Y5yG1^@t+u%3S1L7J6E++le-8$NiA=p5|Q6iM;h?TmrL1?sDT zBkBOeNXX{I!UCprD(4O4JhcPm>&_ifd*~ELNNSv57VC48aOOkNTN2BAvgBbQ_{z z#~fbf0Y%_oWO2ZYs>sl1+Phl@7TQw^5mZI+4vYz`j`K`Zn+RPrqbqNwTdzecCObpJ z)e=>Zw=n|XbXB~>*jGE!3Z?2o#R@y2-p5=CDuIRe*m^=|Z~7Ui z2u=-mb}9d4CpikR0ZDd;j3nzQf09jgx}Nbo_@il~Rxlery%M?#Y<14Q^Z9$bS2%AT z_vY$-G&PnY1z?8Kc@oVMRf3h|4Rhjn=y}$PlNzWb4BNrj@isYB_1%a~K)@wQ-Is^R zhqT}xsr8%9-)J&NB})NeK#?KqlTl2hY&*hXT{okx=1v6aHCNu?y6HgtHhF1 zP4Lg$irf~aj!W?5_S0ek^|h~Pb#*($H?@E6+4pr)as9mF^I5_ZqB^8Ft-tWOlb2x#is zn1|1*T1agev^YitcCfwm&&&YlaaH=NJjfu ztA0moP)WNNsRP75vOF?Vs8yOLb3b@x4o}>V9QX39BHzppZ@60s~ z9o}#1OSOa}1n%+;2q$qr;o#@kZWWhE1jvp-1{%pZ+tfR!sJmQ&xl5&za#AU(-?Vm5 zpaKugya}cns0=n8hD5m>RNSc{*Ew>?;d89&RSN@o=S2}Ye(P~{tu#g6#QXWL&Id3f zf$dnhz`7x_Q}CxbV^qj9N$8(hLTc|1NW0SvZ((&7z5BxQ2a>1a(+8!A*L*Vs$2UXa zk_)jKLe;)hKZiGl4s2}qh9qVaoQwEDy~(eESVDoLiHa)Y0dV84z-z=#8OU_V+3B+` z1=ys|7^x4N#O|WlK0qT55lq&&tjivm0ig%iGIlK}eD9=s?=e&Ly76)~M6y#%c6;P) z_8yTa8=SW}1;k>h^Jwp12?g$a)~|^TX*2il=YGYu##;Z5ZG{DK-|3K@#vi7oSOvGU z0;Yw(@U64OTtik&YjO*4Y46d4lm0#P_YnJ9xI(s1 z;PZS_kBMQ^8`ZtQg5 zLJw)3$Y?Xj!zE(*Jz;!43p5W?#T&qm1Kvecu|b_Voe+?puS#hZ{mgB3jpeIT;9M?numS?uJyGud-Xj3LaI2}h_1Me4VS~wcxJoA@8mJzM>ZGnc1 z1sAfp2U4qZn+|O>Ruh8OYfciOeDYqqsVAJr0i&NwM0P+czhw!Pxt|Oy2Iufyy>T2S z2x4A50vXHGAEJ=~X%%K7IkyTziw_WyO^g%CsnBlIoM_ls+ukp?K1$dtM3XRKSvU|? z+Tj(2reoK*;pQG$YLTX9|h;?OTsJ)j|cGh61)v`=|2cUlAZtL*=-dMeDO(h z3jyGr_pj5fI<8mjJds1J_JEBI(V3vCv<;#F{_O8_$-rr|sh8>04r?M1x*K@b`tNAy zjDDIQaj2gO2WS$uVy;tmln3X6lZ1XVxGlI~j=^H~L~9F!Z>&YE8IeG^$~#3Iy|Cry zv9PqO6SB2KBURX6FmsU$nmSJA!4V|E`BM+f7gUF1ZW2w0B`)Viy(jhX@0kjYT@Nhk zUz>avAJb9=Az)|F93U7JCue=Iz^(jDJuIwRRFCLRLzPNg_R<%ID&Z`f7+vtt?M}VV z`b0Uru!d_WNyYGmtInecK;RWE{zz$R1=QPOpHDY_bsQIe6)r9F#CUCT6=W48FiPj` zqT4F;$lkRYRO;wp;eflNsLiaa8_x#wZEZfN?19rPpiNZTBLc}Wmo6;;Y3264l?P=_ zSe>xvs@RFO*LB;P4r662X;oY{(#VR)OrHSvr9rbwBToioX-Jrz4; zwi*MtfBBc=IM_vSk>cwnxFo*wAexr@CK?3FU38u*?EG-~QE!`_1?~=lx5}}IKsGA) zNivN;M8&ML8_qw`qUA@C7J(bHjljuvexHqX3QQCo4U+weZH$9gfD7yym+=^s-Dmad zq#ofK#%X_wR$HxZ*euBF8=J(-#`H$udCDMTB?&Yb*dmox;+JPXjT$rW-132oZ?E?$ zHrLKH9fosX>94xP;vb5Ze%w|84xH{WsNzFGxym=IMIxt6v!IByc6_DBd<*IUo(;-(xE21e zoy=C*C!5ELGXHgo8=}1>n#4TGs515mP~ks{Y4^bN_{^_G8##r6C(7msE05?-yc&PA ztL~F=H2#FJNT|Z^`SWKxo~;y1%Mb5>#N<#`7pw&!eY~HRnbw&3;x7oU26z(XgE7XcVbzT} ziio%-+dzuEI9l7i_t23G+8eN34j5)tgXKq<7YWw@16I4kW&Kl&kIZ7I(O_b8Zei(| z^Y-EDx*-rM9>+32qcbg-F$NyIPr*r_UH1;Jupl9wv9f!3rD`MtK{?b42$Wi~pc-WW zj*7eQ9E&oKXT03shOA$&OXQ85ob*FvH%2V62m!XCC5mi6z&`x^5UC*IuSLIc2G&xb zdVT-OmYd^e*^Y}?!yCD)g5bI}J@8~k8?j*f!5_zW6gLA-iE1ujBm_JAbRLlhCQSrF z@55`8ra6K5R(fyomJaq9LsAdwSH~M*doumMd0+!`j{;Vbg#e@hNmmINZl=tu;y@sN>Eov;uEQ1#C&o75c~@zQb;w{9gW7-+@T z0|*!2WiZx%Xe$Hu9Y77DGdbuZ^(;`yiIX>>E&+DY7&x(tq!YTaKxl4%Ou;h zL`%RFsz#?A9uV`!V;D!a>TeYIr<3DkXzGQ=YKG$qX76_ z5>~nX2l?RP9!&AR@VLzLewX*2jCQ-@&o#Eb5W?Wyuwrk+cG>x(OqeQN76yT9wDCMO={%>jCy#!P1@%;X)R75wG&9*a#4I)}UcX{uCkG%}^nqkjE~_-dc8wY{q6+ijdN z*=4xsdRmndG*%ZD^Z|nH#_8O?ggTcP=h1oMKt+1#6y)Qmba4CkD3bG0yvjf)d;IuE z(qC-3@GZuk>i25K!phYCgKUO#zc(s8bxd9+7+$Wh9<;QqoIdYaN4lZ)=z>aqR@Uca ze`_Vd0<0^&h|6$r`#HBS`5~=SSlxwSeAdW9DIjp#gctSE|1a@=_!`m_O$ahU~u>E^E#3U3yZ9=&f*p?7Re)!qCp zj)nt?I`{oYGH!k#n&!v>25hpA+6-C^ktd^v*A5eJeHT|_5!ItM9>R|s(ii|mM;KER zR$b49KEKEiyj*sU!w9=eh5N5dAm;CQhjy-4FA z0m}{OlQQZMw0eJC4BIc{N7`c$Hb28KAL8_8C89SRh9b!0ynYU<_x?mP7fR=dqsvT} z>|*B7h7dX08kTM2;+~_~9?62LOpQbQm~HE>WKr)wJEzDniNw4`*-ygr)psk~x&mmx$rNv5P=zW!y1KF*>UP{Ps0 zSOk?(Z%m}bh!@4R_P+*;XgO3ax-JG=e0jLPq4C;)hwV+)V|A^`9L94f`T4N z@u~vnDZ_kjXPT$~zUN-g9~p<~8>CL1Hkc7NKoQ%`yE#2Khn*buE*VNI@p#jnv5k?e zYX6K0*$WdJ#;jRedZOH{t1k=>emfG>7VJ+yw0-xh5#6&HTf0{vGr;sZisb%9Huj%o zXF2(Xk8F=9hrfL{r!07HhkfKy!+@3%E;ymQiE7Fp4Er-GOP^S>ryv|fN!o4`kPtX` z3wS~TE8+u#jw{mKv^Od&;hI*x`grE=X48gWumBq$_$ah}vqI*> z?<|VRd;}t{e_^RKshk!?V=$T5-Q{;R!P%GmLIq}9=2H#P%&s9+5<;OEQRcoRCP%G0 zdZD_oI;)ASBCBnBZ6rwf@DWW6TS4x z<>VW`>~xR)af-1wb=?EPgY?sl8In31uXID>ul5f__p~5V^-`(83^Y;GQAQeXlG3C( zPU0A{=1U*gw^;NjEI*uJspgty2nSlM0Acp2^JTjzMS);2&d=C5=|S!7QGdDe`XN5e zvJrh!`qxD!R2}dO?($%KyDb_gH+apx@Y>!aP|au`hC*8@Pwg!)nHh)V`~25C+bl!& zobfPHc#W6G*mt}wgWLB5Ow`#?TfE=Pe0XO7Bj z(7e1{%Ywt(VPk|Xe`=Um6M22HCG$GOI9`5>L5;9nJvKL2G)bP{%$xm@I^m|mO_h({ zW#Z-2bUnhI@vzLyf|N5JM;OXE{0EDocNmeSY+AP^yr9(|$M21QG%BsXHnNtL9PWH2 zDv3+~UA!Fv%ykqBW_&j&=2q7xEl0yz=d^LXbiLAP zF`IDRmvCj9UN-)lq}p0rJnu6reo*W(_!h7|m@!pa7j@4n=FF`gL~iW6C5On1&0{>| z6TC*t@OtAu`OWSj5*ICc?eF&A!}EGj{OY(~OJQ!06hWm+;edQH}2I z#c38LjkSPwZLw_Xt%4a0mHp(sdSV3hoif3XMCZF&VB5|8xC0?bY^jp63hWiGzNI4h zG?D7b9jczMyaE`0s{IHE82x~3u>RzfU7Aw-L=>0+z6HrHD={uA?!=KH4iaxvvB}HV z>sy@)jGqh2$x55IYa`}EK&N%q)cyjpk2ot7YXfZ1Y;p@_1TU$z^xWg3n%lsxIdaR} zYPubNQuz@6u%s3gR)u{4&W&}{j9VEdhXT!2`7s1{1h6Qey-$IlbYZ#N01TqAOMiY8 z`Lex@A;{AJaj|2xy1?Zj$OV4i)vAtNS9rA1RWU1WCD`Q-PnAor!eRMmpFdH*4$`;5 zIT}TBxG`K{M|vLM5utoJLPbDhSmMWQ&0`tA@+eY_pV$5DS;j?&Gv4SvpFaqgvmPvA`OWAPJ((OR_!Z);2VP2U0tqMz3Tn~dld;70jzlo0OM zCZX)}Iv&ai&`Xkw?)p8wH^2O+0(ccU|9iMoUf1NqDn(hl1k1_?e4A4?_ih2AjY1FZ z$gKg3MunR7r_~HajY$N1A%S={gmS*7us}>&b-k-{4C98wB_W^H^9d}Gh62gb%;J8eMn&J(cK-eyiuI38DGQeDpuQ4@slY_y`2( z|0u=##dLF4Kd_K-KF96H;YdTpdrZPcxiyGT)xM2)!-=_1{dRus4hM#Y6|Pg9HS%O;A~Y!7Y!q@?RGQasjMm#TlMa_ zJWTef`BB(x`fUy9F&6l)aIYLmBjL4FU+J3$+^X8+mF^xv+@jK<&OU@hW zY)dc2{0Hf*hF~PoxUy=N2&XSDoiGo(+9gk3R59ca!Rp1>r}u_{#iHJ#ID>~OfiZ1H zOk$vQHR7rLR0F7LPRzv$74xG+-;ag#sEb_R_6sFT4pd!yHEPV+=hcIKch8+wcA@g1 z8+9LrAkEi^b)}Qs>)O?U0%+e|guKPH|N~i&8I;@b9u~kJxp(vlIVnzy%pjX`X{;+aTxi$ z$5D@m#vi&+LQ05>iaTgn9@8hmqG=gF3eHV5U(CM9 z%5zAd?8GpxXKvFL!W~&u%I1$qnjySAc~9e(V=Egk#G0#&%8$>9TyrcFw+=z`a^#lF zF;J=xus#1o9uI?xT-pE)DULNpH_y{4fgR|YduQm;)jw$*UI}MB0nWwTmv>$Cn&swUC`lEA^U}yb^UrNdIZpS5-yRO$P)(1yg2E*QqVO>D*8lToiwEJUW3kVWu3e8t!HC>)PSKWWR?rshmbko3VpKE@J$yo=Bian0~ zGW9oF68|6VP8}CO#wkfF{p6=~ovGiomi`KMcraw-)m``Jfcg5CRoBi7is{W#-A2SA zA#ZZy**`}#9>Ae>s!gMivWSjCmxmv7B;PHfE%X5(jKh^3gHmTBSRzSiPc%)&sRk1H zTezmb$W1OdT5wC;C=bKiB_To(U;5@89wZ&~Q_82tGmedb7x#jAl>;LL1W4*ooiD=T zWh|R)bG#S}D=rpPsyr5f%KrsspqGlt+scAjxw{oXw1bcb9@iqp<|gUkYM=~xRf=!t z{B53wU4jc%DQOpW_G~S;;?lld^&q0>D*hoeCMb9Wz9F3dkNt=6tv_p6c3B8ucLNt+^P<)fn3P$8NH!tT17{p2 zuE0kA)u~e!jEh}I&$*M>rDBA96cOx|D84<~(?=|6;wc*hNw1A+*F2T5Z#JE$9t!UmEZ!!7Fs;Urq<&cA%x?&hjrfmVfzq zw1)r7dsCg~4Srp^LfQ0yeEXw4XUZ}2R0RF4Ir81ChHtkFjR^Lmw8e}@l9m)GP z*Jk@*mn^Od8(|p1g^U}ZFdYc#TZi;M(D*s&L572a9Z1xJrlIwm^qqh zU?FpPqNPc4NCjNeLQv1o%h|EWvSoB|iqh%_NHm-=@s-ZrnW-}aY=r!~CZ@T&klXz$ zXb9U?||Ak+|AbH~oswg(XUnZrWs}^smD^(X#kf=2-HpgIxD?sh0MUtgvZn zh=7pxs+5Op+H+svJh-6oQ$1V~Y7-Q-f zt}w58?zLxv__acBWt*nI5s9XsCt<8zkLk6lzP!`hk579ij@IIDNcU21<}bo%2`_!0 zovb2_;H02n@Pz0+((J>mQm|vquZEROcl~*pto)e>W@PED1z^51g5n6vLl{?Fd<%&|US;D!n1pG% ze=F)sL3${C!!~&E{WuQCWD#HN^EeTZy$DNyxb^(!>)|XuD}W_lyT)n#$iH&k?UoDY z=wH8^>gt%UaOGB2Cro$GO~C>@aTM8!N24>mIu5dlFsW^IRVWky`vZycq{$Wsllq^e zpb4XFSCxrtK(uu~aZ)crHA|`QxyMPSFPeUde{Sz|0BIGlfIb69u+z-6dMqGSt>N=@ z(s~{Z5gV>(HE!8qHW^IMAV-gY)XCm5+xKTXj~!PWx-U__a{6UNY@i_`L!#H>jdQM!?TYRq!cI`U-uXh)1ilYBPjgl;}{2{TVz69Z; zF}oH`VcXQ198^lg!~_2yzKcy5bQU^0sl(r+{`ue8mt`LfcD_RMsPnLZ^|`CRk-UDp zK`6^6%rs{WGd&41IPzN2U`AHqPfYCHK^v()*qb3Ah5~}xE+GiVdEkBM=4UDcw zNeUbxMpDgSrw`-CO%L}2UvecBhc!y3SC}RhJA-2p>_(V2iMO#rNy2Q| zT`oxUnG-I-OYJDAfP54??)<5&zPnrG84oD`r<&pk>%15z11Po|pAWJ`Ty|@5O@xRw zuvpnPU-i2)Hi^J&d1#(>Bzu}>G>cg?%_>AH0E!&06f|EK`Y1+MU6n%JM}?BBsYGbM zFN!J54}L!r~POQTq!3EcmXVy*~Jt^N16^hkmf<=c3uu33B^Fcz5FG?Dlig(G|ga6Xmxs_&n!5oPrM;nETwf=wv$69eyepy(Egd(YxL=^g)cW{yKvLsoneZ$`z(SyP4I*(xq z!0F4eAij}etB|j(Yo0g4?5E{YQp--Boid{ASzT-crp)(r%F`*`#+1dW_os%1g6STi z*feu*+Y4e35mygg1q6d$c6qq4Dn2j#GZ=HI~f2G1KTM#O;U1CDbO zrzq0z^>2p${tHupCyN=)c zV#4s-N!-wug^74@B6dqiu;+F$ZRIjm z7F9ox-Hsaij7(I$|2hHKH12M;8Zjd*YbG~3ce2tQYfPRi2m-8E~MuK$NK8|z3C%?^hr~R?xB(`I;jMlHG zPv2vx-nV6fb5h-gzT|E2o_z|DlTFR{t}#R=sfe{xU+r~G%PPCk0MVvG6dWWS+{(SR z$8DrHcd42ghmB>#^@SDrU0#ltf@Sf$!W%x^1Y!T9A3@FAi>Z33Q$h z?k9E2=<{h>7QGhR0_$0h*kxcr@_CbmYqP9nXO%QfzPZ41OKJpIIwc)e7Ut9n-bA~p zyB86{#dk?Fz5je{7qHO#%r}JD8@kUqM(x7c`3uVKd?mOw4-dpKuF@DIe&A1Nk;2Y&L6?HvQta`S;k*8a<_Cr^n zt>?9F?xjVdJcdDLCj5QE5CRzLVk8!L8zYo|F37O#DGILN!fpc3e=*9D$Zr8}(W=8x zej&|xZarZ4{$&dVCQgQ|Fky+rJ@3|Mi3FC@!%@*%SgvUym2$vo|NEs5SX=@hFj2n> zMz8?L0;9Z`gk+d4v>Uq`vZh%dlr9hS{7p8LDqYiD91hcFfnhP%&4qBWO!QDbr`efgAWNs9bHqV0W5g8&bS(dAM3X>XMzlgd?lwN$Shu#^YwN z;HS|WU10sGcvaAvn5eFS(Bc>@GqBbtVNzjYAljJI40cQt;PWi|Rkf84x_V$^HiL#W zafVDn*7VzUp0c>HJp@SyN+UpxEhXLWXM!@JgjWiq66sxay=n9qJcwRfD)arK2Ps5^ z3ls^rd~f35#44&?oBk!HD0eWgk{IlSara!r_4eRe?k&G z#OSR1X_%qhw#irmM#77LUn$$y$_F>G=I6NHW#)awXL^=&GtZp8qqzhI&#O*L;zk9+ z!kUp&Gj#pueMxw_Nb(}5$}#@#ZUoA26&Oh~nq4eR-({5{mIQ0yh=k#}bS8f6qVtn< ztWNh#Ydk1FOE8kXm8Voq0ox^@+1Xme1!9dkr{7zCkAT#`(NKJ`?GSlyX}gZ=nHTbS zHZT@d%4YS8*No>@oK3IdJ6PtDnE1y(gA*9@g!RJsY}EeH*Z)phvFaAU$^fu{E&V27 zSEy#n2MgC%QjBwhfF%U|oz2(dEd0wi8iN1?QUIxusA64e)Z7}3)8`Z}K~U)Zz@ZgU z_X8`YG*h(m97Somym(4Aa0S+!XXRsoIZt;)DHmsY4_IuKyZGbTjYRb?EN4TnmwO^$ z{y4By!5QT2i>qhx!P0X18{}D|2(7bAMZOt%mZ&w7Bqr+#JZXo~fM%C7@lGIxU1?R3 z2<;((%e{7K-36Up7q{S3PC6g<0H7B*+N+8$WR0y>YaGYDO~pe_C(`^XF*KtvGt?e-LjJXnI|Yec3%=-Ggx7+@T>92l+0qZ)ODu ztxCa1*gE~x`1(Y*ksdI4YCjI>5f;nsa{9agOXMTi6$`eusg25ybcFo>ItGAwgy!4& zG^>&NhiU;g%3BiP$EBBnH(%$JOn0QSLr<_Gl{*5?`qlDU1b5O9JaMozGQ<-Rpxr~+ zTwWg%u7vPcqTFni>Bn9)+@{X000>#5?g*g5fb2W*KUit0HM9R9X#VNCeg?SlesOt~ zH{3KqX$J>*n2O8230)j|XI>c%q=CjXNy;AwT$V(+nUsfEh8iKyseT{fS}2^)vgE)8 z!gb_ig9)ie0T83k1|yTR<%e%JzK#l8(@Kmk@BY3Xk9j`BvfBuhu%aIiamh;t+IIk3 zA^QrT#^imzMntZA9IaJQ!@$CcrB8^b4PAeQoY?eW;_v|?4!>qOJ@_O|7x)Pi0Lbu# zKS@|bCH)5}bw12S@qmNQOK0_t3hVRjQ6=OUM&@xM8r-@-6s_ar$rgcJGm-P*ZCJ69 zB(Jfe{3uz~efG6`_aN+lBz+4!)BFEFR#tK>Cr(qlD4lXSmF1ion$ZPGn|n7QtCWQ0 zl1q#nDQ9hjQY}+rD7TVJB`al0nXICwsL?Dfx4CT1zWE!H|xb|hKV1HQi^ zbu$kLVP3I95%w1l?QJ4>BC>R%ZY^4+R~E6sW$KUuJ}dZtRbifJ2gO>k8wJ#H2X6X4fVR3_b{$i4HPv*f9{Si|)K$Fy>4G zHyY7+*|Q}6v;YWkPT^`g%*z48=&A!EeYDzm)Gk`8{+hMUK12+bv-6}ScCnJVO`T^c zfXxJN4ey}gokOsgp;tU2?R+vDWh$VoS^SDULk*7umsnBtxoRTTh8^BavGdZF$)Bj+ z-f4h$3KhysgLraH?T@8fU3^un=6!4v#1Oe+&o*IF_hvsm-6zH1i;sb(W6u3BwUbdm?5B5C<(Wj)Mt$8tAYdIL=5*yCNG|FrfYA?pV@IA zZ&Xva*51Z)+%v~{WTzZo^^V>V({Ycf2Dn^|GXkaFxo$`JA1d`LbavfA$7jpzFoY***&p0 z%!dDHXu8zxe*D;`+QiJ;hfa%WPSq#GwO}E#W?uH2dk6N%6T8AboS6D~!7Q)RTc|bv z%DC=(U)x0&8swSM@bGn4Ls<5)^(}-wo)iz}=pAKHytLrmmiWCNox6IQXkK5-+vu*e$}N<{~nsyc5z!f{?bWt{tD@@qQ`bY(YNVXyCL+{bDsP^+b4(P z7l)*EJe6n=oJgemjg4Ab^zK6Bio{b$*{+aZWgLaAI-{B|_~LO^5OQ>V!|gBrv=rMX z9S#8mR-U#5-TzBJ2JD##k4M~3-vX>Jb4zc|2*(h-SYIPnZ?G|S9(w4xHFkuV^k!#H ztybhl)dZg`>MAt(-YZv4V`$yD+^E_FR-CLe2}%>~6=CYeX$XO=m$|n|B9=FpsHO!* z{O{0`b0qloQ69>Bg2oQR#Hc)UBqovwg%I$j%q>5(+hh}lg3+-VuSn48PYS}uz{NG( zbs!-rNmHvIFw+r9Qbp~^X3+(KZl@@Zn5hN5DDPe1Z6&RD{}QLl)UqZbaaW|kQllV= zGPV=bAeSqrnc=Nl$xwD~W${X!Cb3B~>QZgH$lm_MS&Jb=q6boq!I3EYH zMjeq({59#D;cywG^wZ4jPol6H4gzi{CHbdq$A*PZ1W*KYSm-XaVxAI!@vI3(FUZ`J zPZT^RWdDqRa_dE_lUc0JM8^WSTsFTwap6NihE@nt@zL}GAlPL; z*CNMjm9y+lKklnaIDYXI0r?psD-uz{ZrQG1k5Z76xS2xa3F$EbW{NN1NuIAGpG$F6 zRucqRvZ2gTGHRMQS8;nuS$5;e0lg?uSE_EOE-E4y!{w_yjIcbQ6geViye`_B6-ovr zEPLSme!c3dK*F<0HsU+l!uk3cz-~oJe?l~RlBgz;EZu`9#47w~iM(}#3wl~eVv$JZ z+G*?|m#Uh-3;Ux5Cy|)w*7;ias&F7)dl0f`Vr~)m**P;Ib;(WlT(C>om$8ft47kOW zq-GhQ>gN=Txr%{lSx;i3hfc$M6+O#mNe>H>z;zFlQ+k=>&Q#Dc<&m?^*70vW&_7+o z(vsA#ym{D{yh6gVMg}^$Zyj6t&05PLGx8RlFPZ1PP&T(h6EmVBqCIu_-G&Z5)w0Cx zPlFET*A4cgF2e!onC|MtHs$87(~TeLq4VWl=7#3MH;?j7^#=^>wbQ_bbIYyYFZ9e8 zuF@YT)l8y!*!&Q%HMHb$Qd{2$q`txHwv1Iek6fWnQxX!SNOsKgo%h|wGon+j7nYC7 z?k9pKpz`%#opJK_l&w)0VV9DUe)~K8BL@HQ&DoKbVRqN8+xY*9M!)(0R*u}-ng}&m z^yICfmNlsbA7mUFd0*{tUls`M#=a?$nKBjU#t82`(sxfQsLc_`|?vijER_1 z*>lUvUW|^Bq}g^&@oGJNCWk347)mbH&V6g}cENd<_Wx;V z;Y+?}l^kH%b9qh_-!?t_^~uf8Lbo(_zzghg|CnKt^ZbE?NEhkMRLT4=agtQ!z`Kjc z*R`~&ae>na7!^xdjrew~Ly^%BtGq3$7`$k*>oHg7~sk%C1d@*JslDk?|P`%O&P-b&a*^? z8U7r;t2hSnZBilY^xm_CFDX^O);C;+%1-S+OpORk*wz}yZ<7hO{&2{hY<B|y@jWSh<+(BTX_~?)X#SJU1{q^Wavo7JELQ3*Ks$T@LVmX6;=2XAQ(SQGme7Un zG-Zw$M&yxBQYIrX0y>A?S*OL$z%|&A0PjxOVY9!}rWq*SOUu7P3YF|t$$K?<2UXHe zgwnLMX7)z`eTH4-{>$&Lq5X?f(}@}we0H+k@JEqH(OSO@%&=!I`jdZz{DN8CmRn|L zaedS;Qz{?kh15@M_h|KYJJU_z_&(YIM!^-E*G;uOS>9YVv+T6vt+4`rno7cY+l8!I zl+<<(Js$$og~ql4-Zf(3tU8n(ZfwM)VWNixPKw*wagIdjF+%?#L}PCMs*}u6HL2eH zA#3XKGc%f8Q{{g47qV(TWl8m;Y+4i7P^*~2T>4CC&Qb278EtLtmXg}f6V zwf?6S#`y7WhhG0}0FNE=4rz;7Q7I1h^$cu=$T#2i)7Viy%$|1urbI`B>4{GPw=H%+ zL|HI~1Z`Db}bJcaDBt#WdK7NE1As%Z2C>q>v3z{!viXR>**}p$)#a|LLx#aD%*Po2LC$y-6h$T&z}-_ z*m(}wwDn`S-vB(&t0-uu6cxC1b3>CyDC$ExpyA0}hq;x3-W(M3%9Y)KPkW$s?(jR5=|1E%cTwGtd0cGp*}Y~2o|pjfxl=WU^>l#V1Jt2JR4E$6ua76 zB*sEKy-L)o!%P5W{W6$PzAwfCp+gn@we0uju(p$P^GlLN2Ajd7iZHP}X=jXlmLN)X zmtf#>1o-$F4iZH!(><;6aRzo0@GIv|N`W-0DA}~;n0(g4=p13Vhq3+{7)T4**llsIeYG(M%-DjNS*yzNAu`yMozLS7${@Na7pbfzS`Q_llU>oJN|{fg}dSiUuLWy!$KK+8q966kH$P zv|#FQ@5@_Po>=|ax6NCmg=jrixNFOW zO`8t+)YV^GvBi*OmpDt%Y>%GW_$N7Tm=o;@cE!Fk&yJ>c5L5|(28CANZG99{-z-u_ z`TNpsE)Hgr)T{S9b8^4C4Lo^?Vu;vPQU&i;`Rm#g8xgMx-&OYLniz}<@S}#X>q~%S z#a0f>0~pnv)0ZsD_L6?{#P!B#n!vu)tJVrMmSlrIUT7I+!1~h}B$fm-jlfZzJ9qj^ z!y6E3Kde|j(j}sFH}3;yuLZq~om9X%(G3H>)&D+Y;K-^z;dq5_e)PPtx&Nw3vaINc z{hdSaAj;+9YW3{|8_wY)QNiY--1WG#2RO(7;zep{b7+XduMbMQvutEDQ6M5Kj(QN( z`_lzj55>_#H#~WH|I$rAcl278k5dQiqdc$doW5kW`pll>BOCX=|BTqoSv|mv9vrau zbO{?P==Ck&9XD87EvSh5c3;x)tvmCWY-)J<9_okW@uC9_fqmE~uIQJQPH1H2lg z)`wM86`^;QK07Zyi>wdqdZfya_h#kt)GQnWbZB2> za$npi%~Z3MH&~F65LMeudw4q2Wl27D_6r1od3=_=A2`GVzIQ zSl}i-cnwRj83AwBp7d#y6C4=*yZ;HL=*ypeHFnJl`PcbL!w(lnyATAA(dkRW?GEv$ z_l}9+p0uqfbGe$nyAp*(ZL#;Gm2@w!c}LF{gkM1m6gm$^C$IU1aQ|y5bsG+z&*olZ zCQ;$^Al`nl?wutPiBr>>WnJYKXlaS9q<(WGcp=;VW8R_b*rrJ_m?0hW-QD}h{_fqs zbj=z`_kLRF-*DDa+xgP2e`*d4?9Mz_Uj=&xkUPrp`4s8#iuRjpXNw^Kg*z(qP-cw( zv{RJNLjF}Bb?{?WJ!GJ8ORV;E9WXfNcX%KP2zbyy^M@+7QxEDH=4W{NH_(D8g;b%;6KkI3s zCJXsO9=MTBYJ86|F3nM+_gY3a3Qa+d_E2%V<~8>+6wb}-_l--bHS(^~x+A$s=&FN4 zr9zWOJMD_PB#6T&VxRn=k_Y^b1~&)--hS#!k2-npMo*o84ZwlqbjPmLtT+UuR~6

    0)}}i)93Hp^(!GEuwi{bVr1M=?<{bw-SyM5alni$4<9CLC$=o#|Z}?W!o*jBeNEfDy$DyyTO*8%5E-*)J-|<$1!&A;EJeUDA#kcrnr=koz zvMuak`NK>KUYqP9p8V9%bRCM(ce|f@yi`=i zKHzEdHucYg*-M(RPr8nio4+6p8SHGc9NS2ncHBP<+daVx#+zX4v z{ZK?a(EUeMUBe&Q&sc1wMBA|hWdZ@@G3H^kzmc>P;Y)4u(!HAg4zWTaVCKlguBMA^ zk)2$!*fZ^w2_I?OFH^;vzze~cdmdHhD1xSW;tv{N3x#OAD~Fd5iSTQ6VI4pkpjHHC z;}X9==}YRsecq`&VBlv2%{k@tz_5WaTZ~t#zj;ELi%51a> zB_DBq%5W+na|dSQeABNSVjytj61jrn@lOSa6$RWO)v3Rhe))HyKJC607KNJNk(wW4 z^OHOn$(%5!0ax;Ey3m&93XjKW2)D_Oe-ZQW?4vK;>l`s1&9Fa~fP&s&dzh)Fm$|{w254>hY7kd67 zcz$pzLZP9cZ4-NH2%tPQR({VjOR60v71$&!V66c>IULJ68~pHh3k>~*3>#1{xTI|} zGU(!q-H?^!q3((AY!nyB7M~xo7*&F`#j~(zDWb?ryK#x!D{w)g9VT)hj$>urFwwkwd*dQg>)41F7Q+4GsEA z=a*2Q34s0XZ3O`t9KlrHAKh{qr}_3Dybs5Z_q`#2WKYqv#9ltLkVfKSmLyinzo%hh z`lH%t>^CJ}?#%7#3RMwn6urr*yPPTqRMzJSMRPS68d-cdX3Ur_Ck@Sq3l;WY5lkAm}X(ALxdMXgOUE%1f-y zd{2ewP_xpve;_lNe?^od-{JNdoP}|8t+~iR0taLD}HN29Yp~Me#tr- z$)*0rV6j2GlfL+6Wq)izL5@SqgJY^bfZ_7mUj|*yIBb+8EZqC`$GzUPNYZY=2SzpQ zl!W#fhT$uj1$|t5>Sx;hSsdIVpMpp?}WL-`wx85x?+GBr&k(RFB*J zi>+*y7F8(swRxA(m(&es#Vh!s7+aCirNx5~Ve3A)s|&ys5{GzqHY(#@Ey#&cZVmB^xH0TEyX6xU%ns*U$#_HI;BP+VlPD z^oOl@B9M1$6&{=!xOQN*N}|M`_p@TdOYuGR@(C&(B7Q$N7Si9tOT9Wt5>v`)DJQI8_uz)62cr%VvMGhZ&gr$NQ~fMhe_wi8Eavx9fa1v+ za>Z>%;?5f+PS}8GuT0z;ftQH^e(n7qUF1={FjU45umR!*Nzu_G0+;$P1*JCEsz06t zYY6)Dopb>6kU=zGuus)BI3vQu%qXuAm;>ViI>@|Kdv_g49!XZ#X#dE56(+e9U)E`t zB~~2I|F7c;3UZg=FZyA;gD2ozG^8f$+!0RTQf8?NFXw)W(h4f_ea(68_GCRGzE;M^ zE?VCt6jY5fUSSe29&B35)QC*Tg}LB8#$r&P7-MTZ{#raWIJPy8yOGWU%we^0A&TUN z8WKB*x=A~aG08c3wll2>cW~e`__W+~Dx%5>!E3@rJtDa_VO6P47n}2q1Yoq1(9LN}!R24Coy?u$Mu2%qySFcYr;4pko&sU{ z?Vki$Ez)ql8@Z6QF~|yVJtg^DVKYr404EjSt)xPNBI9N*TT~{((5~RoGGXOzR(dx; zpZ9mxltR6_$`xf~2PvLmgkQN2YK4_txN6dhrldquyZ{)l?lO{ynNuujV8)`)gQ3ErgM7fQ=5hEC{&3|#MS*{^-IGhF&i=^@{MsENL+#-N}BMxwjlh=mlApX zg@s4a#X+4+4~|Q+dR5%2f_&NPcFSk44>~VqB5@--k6v|XjFCO2g*%^mAN`ORIAn8W z5g#G_5=)Tr$oa8-|Ge@jCKvjj{Cs|CI407$ynhqI8;fNnr?*k)lYHGpqPNw@*xqHS zy`5Sy%P+oJ99G1;L>NgG;)8Hs3ab68*oTncwlsTGBy+x%9^ZG)h=pXc{Iah#m~2`b zE+g7*T~Xirpn7S>&tHC%_pTWXZM+uKQ1;Jt|K$gllUv#l5QM{i^K?Ay)vtA9zrR3^ zYsLf{mn?eTNWEBX_WXcTZKYp&uEQ3*sqWu*2G1GCE*T7&U4A2~cKS5`?yvg8IjheU zd=a1cf&VurIO4&>#b>KmEV-dK2r|#AA@W?41axv$oztq&kb`2>q14_#e#ftPPifgC zKr}iwEg}rWiZBaMe?C7kpz?Lz(0*=T-t*_@G}~8a{kJ9Fw!!Sh4xce?b1Sj0@r3g3 z+V0aa=`Ch|zSezgZ@7AQ#h#P*f*J{}j+)e&gywTgd zWL?1y<;$p~)aF+mfBv=M>(|=urKo+W`<`@bY`^3`wk0qsvSuszM3dNO^2w{V7Oty% z#GCoBqxMelkz+%7f+~&uxi7Nspq8ZOY03Ki?ghU8bw2Vyd5}~)=K3s>fU~^uHm>}H zSNa*(-n$vULe7%%b`x8g`CDpi?4sCmo{%3#_10>6h0R^Z*fGiI5|ytvT1F4SMI2-D`Bz^!pdoOWM#mAlJxq8`V z)uPrpMJB)2Xw^pB_1^rtGFZc&WMy)B*Jy|E?LiL*+lE^FtK>8abk0oKK~mJBjX)z>unZ=x9&Eh zZd+_&{AKr<8OA~U-CZ+zo#oFJM? zIwBt1meHq?ecW%&LW8V_YFgHV%$dK_%byv4%W6BKG1pe$1Pc&XPz|^5lpo6Lx`+~9i1Emf37u6 zFF&}$TiYp0aLN`vaw7CI z2IJ_H^5Z3XdpKLl9v)B{+7Z5Wo$XE%e7>>!?1qvpxc9ypCx^&OUPWbkqA}X0q^+bh z6Zdr*3`8B4s_ZIk>`sW;VZJjAX@qsc(C5xQ;BJb@nYyes73p|E%gNQ_=pNI@M%4JuJuZ_!R^3`Sr$rI-9(nW@E!CKfqb|4ceR$&g5>k}OG1f{q2fMrw zR5v5*KT{!9e@NfrrK6-fO00Y;@ibd~=Lj}f0^P8w2L<1%Uwi5In@YR6L#}(4@e4MYi8uuJcrD;=ERpqzyCKhW*L}lZLRmWxbOFN+aYQ5LJ|?}3UB%s=8x@@Krk}3u z&`6!HHj9F9Z91qT-PRFp6jnCpa_|2)aBRfTcx-Sgiig`qp2%}do0OW@HX)6Wa_@b1 z6Te6$IG1d_BD1qWnZw*L{M5|$t439Z5k|t~szE7l2!K^RAsIIa!YUrdH_IYKbLkDI zaLdm{twl=;uY3=BXJKxI6c~C{T;{f2n|S_L-4oP%D{<%J#UJ($wmOaBGwAXVj0%7E ziqGvI`ue6$C2m%Ax_|G#hP)bC(zongBkhZL7uv!3K;LWR`iQQ8^Q)ANCP9_Gvp|=R z4oM*Ep)}&Wmzu5Lny2jYy8dmkNWjfMeD&n*MOPD!ak7E@C>3n~bnWSW`)eD#53M_9 zmVAl6fZe}>clu0F7(ze3_6dG{lDpgf1eUDWefPTVMCC-Y_62`DzztdSB_-#Pd)E!# z8fnh1YDAeS%X~tP{r;HtzmJc)$0nI2AeFt)*fV8AOUmO_KtL*V3<~3~0xK5)U>zLu z-yu*PH)WMSm`;zL$Dw;_tzyMHl5&KpL=Aog97LuI|3QUfggA0*29_Y9!(bohf*y8& zv(c4p0jf9|Osn8HzhG4f))?-9zOMqFn?zYF=f`PWiVPIm}tb$9?z#Er6J5f>1;>WfB4lAP6Kx% zu9u}PR#1;WZfx#}9`6P-+Rgk(1QE=vrmsD>hO8KM0(X#lubyN?%mZ$io4At1oGLJf zMkIOSdqIPium(AyR||rV1T+K(HszM#nzJFs7S6xziEBuroOxi_vH)Bx*B`2wBz9vp2*GHNowv-%~LVXGeeL(m6o_*Yg=x?BXvclHMN!6{t_pGh=PF5+@M#@R+MT}( zGpJ24l5I!Uq6A17oAmf@nn4iM4RhPG05Y=OuysQosKX`$${UzyCXoP~BYNd=HP z=)x5s`QK3^2fpzD&ztY_)|uT;b8zKP6=bNLK$(CW1QCg;)3K<1`{u73M&k>?naL#b z$l(Px@g`asB>0Ba2{$jRcf-XM-kV;hK)@f2|GmyfF{QkpCjK$Mf9neB6JW)bY!*c_ z>#aW;#gpZ~Q@}6?015iRc6b42ideKalmXs6pFco!FU)u0mTzx3-cK4#@P1x9Ef@ht`w$p){7TjUm|p8 zC~4RCp^5P|*3bTKn;@5*CO|B2c>P4dBs|+Zu;1P0)(}&~U+);*l(rI-G(KoF^1OI$ zLCjyLw>kx?D{;_c!M+5~b8W@C9vt^O(TI-ozApODNEq%L@Sr$3TPo#Ay(<+5{`^+-sK*Le?QiT@!q#4dJ_2FkgzK96t~ zNFW9(0yjAkg@xHVA#WVS!M|XM+}w%?Y6Zv(FrHlL4kO7t+03s;o5L#x_SLGa)vP5= zbJcMaaN9oG`JuMfHfDNUMZ_QM$p1~bZ>0Wvk;g3dx*+DUH@6biCxy!v8a;1pfBh}q za#l^c64iSqzMldilJc42NTRm$~iAPg3&zg=i3+b_yofccr%Vz|Hk^**!=se^Bd3A%|JizQR5jGGe+|H9Kc56 zm_z<=njFTvac+I>4>zh=TK_|&^Dr9zx)b;t#EZX&iO0?jPd2}#C=#+T(T{=3xcfxZ z7KFvB8(Cs7(-eP}rYB1T-O}-f)4%P9n{Nkmq>`1Uk5`^gl1;D1;s49^pk6RY2o2u$ zv~ZYon=ADD{&DM_kNPp9%Ft+0>2SQ+qtvg20_i{cb&y54t-y5l7SPlb%*U28m9^hr z{$C3^J`NqL3QPS}+%h!i9KO&uZR3iFB2CiUX#?2}|0|etGUZEjt&i2%YcGZn9Mqw{ zu1}R;Y_)UqFGQP1J{UI|rW{m6Z^&JCtLf7Xk#PpEL^R@KFbFJS8IJts$=!=us~S-W z5%D&jTfVg5YPD$T0k0yKm<83|3LTV0Idd1qQ6b6)RCy20Qnttgtb;nvDZW4a06I$~ zu9&V%Q&<>!BCH}#2SoHqrQNsV|OBrW6pr+Os^vSWp8 zSPD}A`Bv%GYE>)d9iDof(`}bLcY1m1ko9k4i3>GH#L%;UQ<@*qhgS%h@UUI67px=` z!7uVTcN?&`hPwRXwbmBI&c6Tb^DJ)JG37rX7wZ&z=<>7b z@D?W5jZgqVIa|?I$o34|NPc} z)IldIT^*a7+}&r;=imzQ;y@{Z;g#1*DT7!AvvU{3c{d8LvP7CM(nIAmM%C%mbqT>k zJpTsl?}$?{P-O0q#C~bguZjr*Jh`%JYT5;Cm6Gs1Bbi?U6aR|MGs9$XWMe4y4I?}^ zkY&x}3B_#tS{1(i=Km1owZu|bj$Me6R-_d1K4iyH;p=`I+O{_tvyoQ3gg!9G(0(HT zAw`7oNOKzxOX<<0K?IP18oOBvk~+DS?OEE8nBIwz zjo8C-T#U8H-QJ#!3eN%2K{C#TgbS0wc|X2~*#tth(Mf2kPM1j(-nLOm46a_Cc$gr} z2d1#z;Eb4o3hQ{cY1){S0$QK|mO&3iPHAvN3xF5MR#i3F09i=!_rI(2K5iD#)g%{x z5kf(cz}~$WoOc;;Yb9+x$5#1e7xL;jDXua9SXfB&B*lhfHw#fj5yDxKWar%0#fW=0B0 z?z=hVpmb6lVUe4O(UMNBEg`Del$)U&soW(Yhw08_PLzA2SuA%mHrvkc^8NkSBkbn= ze!pI?>$;wINC~qRtplz5>~Tx!n1<3`ma!$e{ox>Q*UXZaOgafBx#77Fbl)CYnxu>Z z=+x_XW<@3Y#Kf zP_D)=J=P!y7i%bo`FFOo+in>2vFrG3b0YZ1^ocKz_t-W^>**E6&6aqg}A@`KGtlT-VbER-_Rs=ojOolaP&MmUU(YG zw4k|9wScuuc%h4gB?-6`O|)S&pSG}xmdlijgWD`4B78FoGI03d4zz)Xo~oqd(%>;7 zRFxoPp2T-#Lz$BW=K6UkM5Is&l(jurAVz?<1Px+4di?VutoG8A60?gf>j4ym(Y6DT zESxTQk2c=H%wFWSxw+%(-YKJI4b|pn^H5mi{CSDAo!&W%923kRFuQi6rJFTTb1Tmbwq5g-YGwHlupUL*2?Q^)=7ttyk-}nnJ zS4omtljCN?=O;Rq3AU4@BK{1&(jRuf=hdx4E({J)Z5t)aHzuTtStIRi)c;v}kq2E} zw3o+#rGI0c{`ZqZ+mrjD)c|{Mv?WBL%#Nvwhfm1Iy44fBa*Jq{1x-1eaJnaJ1^lou zvL9zkQd?sa|0t6*K@=D}f&xkO?mig!UMz?!-u~UwG`gihY?p}t%wK=E5}S78WmJo3 zTD6oo@FTy{xX^x-3sHKEoER_M?BQk;% zxls_S>yJk!GeWSmTA9pHRaA8@&A={71wLiH=&(f02wcxr=^e~ zy9V&4EnpiqzLe~_NP9W52W*e)z^%bVrvGMNZYs&XmaMgpNlgS49~Pib$fQi5kl%Bu zc+@06vis^puENZT3l7vUBaL}@S`t&SB=Bt)3^@lu>u!w1)(`T2uVmC z^wAKYF?mGP>Yg^R`>5jL}kPJ%=f?f?_md|Wt zO)2ApXYwi%P~ced^)!!3p9E7Qgv!))&8o$iCu3z_~iX@Fug7anv9b zXR4GvU%`eCGo#dG{`KSglT&BVEnniBBEW7YdRsY?!Fj@RA6Y4vZ6cgXjmPD zf|GB|Ok&(MY+6dpu_x4?8OzUEn?wJ8cVY@WFU!D1VL%El1Y=+B^@1k~90W~UCaD7i z4{mP#P;FpHusET%Gw7t@n}Og;K;}tim)JR~v*QU>&88d9W5o#M8@{k$w=2$h7Z9G^ z7rVBDAOCLhc|>1(E*6FCH14m|@9Rqio~>l>O`DwyYsCzV(_6PCg(jv7PFK)vpju%6SufZFxPJ70Q}vaw{uWFzNmgGBfYc37_Rgebc5 z-Trd>&tjk|aLn$`fEUIT#1_R0%Nl)GCHy^i(Z$-ZUVDZ$vcFeo!k_?JE8(7DSr1Iw zK>9+9kIw999OwsFZk@OIn~Kkc-mpe>n^Xe%pT<2l*UtGaCm1fOsYo7t*2vx zC$KDul+P>p8GXEYkd2g)2RYpK^k`}X#<49(!#Y!qEp8fN7y@}<@IXQCy}cz zT5-h^xGChrT^6hVyD+vPgO@~7}C zh)o+kdrf$T_Bl53UV37raq_Hk4tCFy+olk7?xAX@^E>Yq&G4;73Un9YvYDgNtTIZ4 zDnA)zw*7C1j}20yh$r@W7g3Go~Y zvS7MEzzYvEL;0J5B4c{7d&r|p+v3%pVfGmr&RT}ryl^KK?dd%$ zO>VY5o=$`+0G<}R1HZ3$&;KskB;$wWSdcT_Fu~n*A}9r-iZFG&09ui(;718FJ_=S7 z%r}Vg9VvS{xMj@I$aksuUqsTpFTrkm$Q>F%sG5etn7TwkHetQLq18bXRmm_0j! ztgNS*>)0t}6J5cTgDwFUI`Lq7L%Dj&*bYoLA-fs*WL9JckGplQ(+ndR&b?V2oLkVz zT!fero*RVC@%@9MrOe(Uc;;v}2$};;;Q5JZLy>?XB-PikL5xkTf^V{(*+{w!B?IdW zB9=5Y0d7~7b^3XXm}atP>0&%p&k6YeElpM2XjBi!AC>B>^;yKB1%TJx$IhFvI5od+d7MOdLAwpg3`G z>usZ&sWgFM>1kki^fz)xq>j1^2M-+5J6Dsm?r5R2i*{5i@iA4FkRRv4CWZgGts(LW`cm-Y2*iXx`Saw}np>$f zIb&Gihgq35SXi_Ai@~lpzdl{|C&Ae8e(ScbgwOmBbJQh>mXg)>tEU2Zr?M)dD-V6z zapr$RiHDC_uV35X?;P{9XGW5J=I3`)YxY;AygMyGthu`XOwnVbdV&=;%usvW+Nr*1 zaQ<2R>a70|E4xm(zVaQpb!`Nv>u(X5J8)L+@JsEQ!Wus1-{TnpohOW_h_XtZ8|wU zzn}hc!8Kj6>af9k=jfYX4YYUkn}6Nma_w>SPLJH7Cle~C9YyWE-TUI?UWNOo*QSZA ziRz)9Z)(vFK&N1%&f5Dcsh1+s=j6$O7+%gr)eT*i(lr|oOBFjESyksJKG=N^=U73 z1p)K9KTStoSD43%wHY+?8|%ns+M;44tA+!Uos!MVIXMmzW~5-=ujKGZceHLj-$O?S zmIY;cQQWFJDeQibc;W5OcD-ht6(^wv59$B8(f8&cbM*#Rq(qRo=OFrXVCd3TPhmI9Exzc0p)FG< znhlXtN>=!p6hF}nE_M#iB)@07GyfJ{uy+`>D!=SGqWX6Dk2cNNh9raP*J-M6OV=pF zkf)62tHFdCI15D4eClyTsz;2}6PzABVtF%ZwfV5!7BKR}rs^Hs_u|-<~6V`(q;M zs9nYPyoH*Q4%fQirEOOl8Wd$5qKt2_>`hSqa0s&0EB;`0((_Y?zHT}6s(%nw*hhO^ z^xXPnkh6}>GA{Lsjj67M~)>?pT4 zH18eHv**6$?XJFl&UxxJCL4115-vNN?uuS!d{~j4H!NHJ$E#P_vZ5?>4YTd`Xrt_p zJVHR`#?L!%(BB$;aWpTneuKPP9XhGX3ky8f`XAyh5z?2(&)j@(Jo|ivit3y4Q}o+(yg_LLZ+p)iOcO{w-9tM|Ef(- z(bF~NImFrD{#x?Ms`|i+m?~!i?K?LEd)_+8v(~>Ef!<4qZFW3&i1ftsw>y#AHO>Z| z)?XfKjao9I9=VE4?;oZ854Awvmd?I`(RYkmHtPLas z#SW%QT*fyzyY<%`d5qG(t^GZrYZKp{fzECv z=Au#*$hZ^0eB{@W(|C{1A$fwTFBD`(e)Btvvuq2R>b{zOvD?vzZ>Wuq zu!(xD`~{3HgF>_~kJQm|^%JrJqlFs5uH4Hqv7KBd(y#7W6SjJDmoYL^CNKsl>&$_n>Sf6mkJ?0fMZ|*9SuZx8*>fNzdKgb<9u}kOA}IUo z&9!e2oY47ml>B)%cZH#kPDF$sJH4CdDDgbmvt;=(Oz2XGO3}Z{upZ-NuVo~EqlSFq z}jX^=i$uMYb&H&#W``Pxfd+{(*-Jac{5y+8cQjE*&|aq0gL5&fhbGy8z~QA6@92=uzTOL}50 zBL&r|z6cUHZgk8xtXMCP4c_KcGg^mCzNhW~{muk7T<@}1tTD6S6qr)ACt7L(9IKA) zHMy}G--A>fY^Rr7s(a3FU`%3+4AQBV_L|$x-|4x{7NnF_NAx&yvvq$|o$s-5QD`#P zF-qUBF~(x?Jak>u>OJkrbLP1sWd?FZXd=6%dyW*c``o{3Sq zUy~m)GrqW5+>1}Iit!FCZ?gQ|}y zgpoZnGBE=xWaI{^OeSK`*uH2|-3|R7xm?ORHXpe^7@`+Qb%Na7U1bC?nCfoNK58UM z<79&ar3Wo@OPpLV*a;)Srrp~jNJ%PwUB{h0nBMMEAvl4b@rvX_k33cMte@~2Z2>*D zd4$~nC$)6eDBl({2BRIoxvi2rqP|(!#wYH|sT`4X^A;mt&)__vf9f0q5rpqb;Mm#$ zDp0$B3pDu()#;1dJi*;vRn*``M%P_;%$;_5Y{l(l_CyuQzuQH@5eK8(_T1qqDJ11B zbduKL2Ja{S@O9hxF@xYN&SqvC*mChf$b^@&mktsh#p?pzm<92?of-I}NOU31W#)iB3S32qsXk z?|6a3SGN%V?+(+5b1zw?GY_sbR6$Xk;)7h2g{*(Ho6-S;#K#*fagl5^<^Lj0^&V4a z+6ZHZJdIhJO6VqXV;7hrSwqv0OEwjmfOEb=FV+a;UQ+%N&gwK_<^N4PNx?)co?B>k z_{6aU;+U$eEpf@C(1V1n*kI6>_>CkB2GvV#L%g|fAFX%2@Ypj{gG*$4Ct325>;x2a zj}I-hMHTUw5qDrxsm!_#t?M3xPe*>V@wJQl0O&hrzlFw(X$*PG>CkH)Wq2RUoOD#t zitf31)<+(^aG$z_s9uV94D^&}Vhe(*G4RcmYDt|qS0+8^zMQz7Ei1+sr8a?&>OGOd^-;-!u&xjU3Y_dWqb@FSj)`Cr`dz49xipHWCMD9(@;+ zjOw9FA*5j8UIL)cqrylmJd`zws}r=}_(6ebtObF5_hjKhJdKkPCDX7I{Sejg9Z07H zJi@yo_%d!D5Wcv*Cy9)XkIqGf*a3L1Ddia!iWw}S5Z|A&4t_^Gl`o%@^9?^Bv_+~Z zwfVNV1`r!5RK*Dhc&Xx?c$%Z@J*%D>W-m=C>v!xlMA~;fK)~EudWZG5K zTAKay^T<&k@1vo4X9!bs2SB}&jQ)lZcMBKCdrUM&@%29Bx`7X>55}86vS0TGo+y(S zYpLoAoWO#plNZAMzkB~kH!FrvU{MB%kb9i>HsE_-aZ}*xf?5eim3Ce~<2bRZn)CPK z)+SiC-v+Sv6C0#NDX#ByDJ_Il1Csz7@zuZKWCKVmeT+LZP8=%VjnQzP=PIYkNJeyF zJeD$#nNbyg{%!?ku#3(GDDgtSc!q~$#6wB8Wqx1=01Q|`UML3_@u>OZ{b?H=!0Y;A z7RbSEqEw(nUmYr+6cd~F3 zMmre1gasn0a|DU1#=umy=vi7aJj{@a$IP==MXOA!#`pK9eyI$gqg_a&KWQWq2-+z+yBBW+4QC>%+3dcG~nIdN4JHcUm6 zA9K*NnNlVOaF0C0W9H*w~Cff z4{DwaCnAlN2lTUWaO^TD8f^Q^Mnfz`CNhLU!I1pyv+nDsn%AV)1i=^OBu!nI{kavTwI)#lYA`Z)Ve=pCGs4D>{>z`Tg3K z)l3rgJRvoF@}c6-H$8g+7nqf)Qha`IwoL0L3^OxV?d9YsshuS3FW0&znocIR+unNh zabx?-8?|Z;ufX9%Z-+7n%xND?b3-ZI*PJyQzJH-i%Tzj+$xT#mp5b_`Z>gDTcTJA# z+RP2XI6#!HhPi|$ch`kkOWaZ4FD>*$i@SBw%34gA3l2zD7)Tz>8N#wn9~xw1;40#l zFYQQ-RZ1GcNY(-%VmRH$QD zDKdeuv-?YSf(<`QEQEI`$e%Yx6LZKmq&idg{fK1LRi+?lamEwQAk<}*kZ{P~{*w*WXU7Yl;I z_4Q$v(qzGtroC0sFfO@4Dk-uS71E0MVP@Yx8y9*8dQgSfFmLxj|8k$27>DhMFfwW61OMg8d8mhaD=S(hau;FL6r>rAgOw!7o40}piRQr z-<`~#*3SbIA#&;{u@F+lTf~4KxOBvekkj=lGjt=LsCIz^JR_0J3VeNA;M*b?RNM*3 z9uvNbL&0ylA0%{lN@TL3Ec;$7VWA}mw%x~?6H|rA{(`OE%-cZUkThu>)6n4}!JHg9 ziW0uUwBG?^$C+*bHP`2KgV6mKgf|~~TFRQt4MrdV&2O_oSj`giII0LsINz{dOBk3? z*{n)}agV{X(WIglJf{le+PpKQXTn+K2`>bN)1zFDd8hPl-2u~h^(i?5Jul)F+Cqe7 z*~EO?l6Z#b746n3L&5-6Gal;1GNbx=)RTG`LgaS)F8_c^Y`NjFY-%NfhkE>PD&DU8w(Jw7$g=P0peslbS%CKprU`s2pk9wbt6UR#1Qg=6F0fwxs#^4)3XD2nJQD>S5ZKC0kHl@bpO zxklz8Arm!ErTPrd(3$YGFGSyOc<)-uSRvS@H7sKLJ%Cu+W{9h3-G30@li(mynK={r zi8-hMPRGMj`KKEq9Q;9>W5}<>YA%)!rRfeN;(KAbmUD%X48)Iu)305iAqS)KO>dgo z-Ie~8D?c$t^KO*V0N?qy{08)8nphEYX;6MH=B`jlQAR(~%|B?u4TpsJK+B_;vz{*+ zhx}^WMN>1uq$!zrOn|(aKd}7!w>(^eg?+7Oq50^BN!nHjYDx zv=ma0p;K0irU=u#B0#zZ1tKVOs*wL*hQE)k#ZIsU>w-G9-`!uXyr(>;@WXm*sCrHp zBQ;d6=i7WD;T`vQ|DZcLkUuqtAJ+Kop+;^4q*)fK)+sk>Z+Ar&RywOyPROqiy8szaFEs0n`>OGETzhA-ktN zhiNISIBhANrzmLVU0shY4Bp0&IN??YTmO`xeJBlg+d@`oZ18X&kv=D;z)MUg#1duna0o+&v4_%4^H{ z?yx)B_YWUW7fwQryqG#Zq~6Y$eh0ZSIN_#Y3+ zz7}??KWY-`U+%bw0d+j^o~=8hA;Oy^<-v%2mMoqw-lghiRnFDH?An1ya0FJrxWG2O z#o4hL74De}W?KF+A{oCl7ly`qH@1K`4m%#I#;JWt38^CuY8#)gX1?nhCc5D>rMh{z z*mD=Ql3NSw!5o`4Gip{43m-gZG52WoI{c1>WL4_?lv`e!fVY_7{+L_&by4W#ts%Tk z!9j``ps_tn?-C-ChnyVB{{ezpz*4@}N-3-u&}swx)2G^P30j>jn&btcbH$_|ZIQWS zJ;zgU^$_%V^;%Yo6&{@Hy|`~VdEqlkpJ&PZ%J5ueq5<0Tgn!VjhxQX2^G=Ra(HRBL zrb}tL20!n^WHBfbzk5AC#b>{i%8wB;nnteP#h8 z%xXT8*D)Y|%8J#f^y{fazeciVCOmxW=Z5YaVgvq4 zZqLBX%qQxPKXg00jiQP4*=n#-F7-K)h|h*Q!S39U)~^NmUxdZu(oqvQxc^Oli?m)Y zQur0!v0gX8YFb)>-3R%h88SsG{Y%g$LiwUT^0VVS%ssF55 zv`taxXn+xpDpIac2@HZ(u;l`Yf{GbAa0odAWpnsUliRXpQZ;A`Z4)!UdYF_gTggOx zcP6{jj+_=LLts6C1s2dO7CF8rBkK*76nN!PORxJMus2T7wg54P#n;EUL$JU*;ILfQ zX6CTIMk<1#MBnL|JEmYw{r2>l!>`Ac&$9f^E3{3<5B`i;pU`)3Cwut2@ z95n-bgSr-gtq*V63Tww6C_A|~wB(By0N+R`AOuPv%gel`!ZiRCC$P2-?Am$qfO*kB ze`kM(kUm=Ji1+vf2(z%E&6d=IY7s z@#p!K-WvT?=YrI!1P@XThJ1R8U^@Ts9N_`a1v92gW=hYAhQPHp|_4>eBo)OJX_+0;G1FnVz zN$fr)F@l+*X=^EfmIgZ}i9qvohX>{#KMytf&WhA8`uybYM1y7Ie;lmA|AY8ItHDqk z1HOH)^ZwMv#z^O>v=sM0&wk)JZ=2Um_54PvJEBDbUtb7|B=YS3bf$_r!PfD>PuL_P zxzrzh`;j%%Wltg5zOHmWO|xff=Z4@het}il+Msw$coRqG7UHNB*06<@-^n*IcpYj`kW2}Ifda(_8W|eCS!^Ov zWo9K&Mt~^k`>wz3Bl(I3wW;9%dVZJ+d5b^EB{FQJf|lmC25{~wX*VmkWVa>2)DYM+ zVD=BNx##foHeb-B18d4VjY-~moP;Xhf9*w?*#_EdGCx!qRWzgSgY%*B4lPu== z=?+ohC{`)2Zs0olQWhNgw}#nI8UkU9_3Fs0vp(l98bM^==xM-$rfM!6u@(rJ^IBv90d3Fm7t3!Z#u|&?B|K zi#u(KX_JfSv$INH5M;+9;q)J)`fk{Xt{PyqBtRzPc?jLn#HxxhbHp$ ztBH0pzL+&7&zDRj&ugMM?0A5Py1d(h)0#2DewC?Kf7ZQm`)qlkT*B$=7c0HF{2usl z>B4&=n5-%wtyK!?Ah3fJ;TtC>SYWHpI&O-;#_y!NqL{HQQo7o4J%d>#vX)5qasvQG zXD8~@I4G3TOKTisUoBdau>$flWOB%7#}maBw%#&vk1Q7@W+srgPV%UU@N5Z_A^4Q* z&b$P<%Y(C64Y zl2C;kdUuyJd8F4+Z^!!Hk(<$Cwg272;)=fVAUJrHV%k7ybzXboviw>Y(*({N3NT+qR^Q zoV4Ws`u5k3c&nKVLSub5Ge5b>?<1&#n3WahZv1oHWPI)rdUxaXVzCRpKbtXA4nnQW z2XW9y{9AJWz0bcX{dX%G=W2qH4A=LrU(mYRIgQ2)J->lRiS(lW*Ea7CXEm-G`z7RB zlmbX*&(B_{4!*hlI%Dj8X#co)WUJ8|Bs06zDouV9;2=_#9W{s(IsfT$UVO}jp`+b@ zZ@KNY{^e66-93ZO9=d$*-~VuS5Fw{+6f1Y3)_e~l?Zz7HIV-3b?7XzOA=yD^Wy4S9s?&B)tA1?xqPr%G4x`5}8?L06 zp<`C0h%VOJ)3>*;w46KiRNe1=F|pd<;Kt#t`mw*>eXJ*K0JFhkJ}yZy+m8tik*uug z20{udMQms&!pnN|2vIvwwEeGAQIe~O=an0Rbko<02rtDm(*4&nhAU$~ zE{XLp9y-9^3_KF$QTE~nLbHW)UFloB!#SBTe5;%O&a@d-31$tH-`kt$8B6Qeg5hYd z;K zW&29s(dW0WNw$_@y%U^o-TC>Mek@_Fo)INoSQ!}p`kDC9ny1b-3F8{)f|(A}pYCrt zN{CT%`qgLtY_#5WB4u@{c@o|hhOuT950@Qo^S_+_@u*!?%MS`)yOh3rPn>e9jEG{^ zKYmy8A}1OK&HGjAZ!0@erObfZ57n?B4s%<$bo@g+_K|D4LW) zeDL;YQNSf}X$1(@o6W~>#Z|8Q-iJUVEkl#;B{eS*>)cc5?4UQa*g6>7r}ErtV%FI= z9=cevM0w!>i$}7$dOL>A%Eqo>WziLs_IpMx{xQhYbHrh^t*;32l&Ry`VB7GMDx5qCM;WSaDH;x+Q>Q;1ejkf zuf{F^dvElf;}Pu~+sJjQO}o4Ag*Gp-w@j08tmyQs0?FnO^7QA_N(}c*Cm{w7dP^Yo zEq1xuTWwZIo0g&F z=BrYd-nEnqJ_y@pzh?dTM5|>m!TEcwr(5ja^bu_~r9s4e$zGxGQTSVl&WOnW>;D_Y9va=#%POPYMx{w`etQ{uSbMasoeYf?y>tJmdRL{yx^dC48Z9G|c>FwNF zd_De9&$N|8k{Gp?=#)O4l-CtSPA%X0ep9Bv1C^NYw}E+~&Kl$Sr>(2aQ9Nt#F)6WR zr(jx^`dy@X*hV%XtSRiIy^;(=h>b3HUtxHqdw6MVH)FP5d+R%Xt@Fn>=HCwtV1rK+ z=0`>4M-KP>cCNT%(xKJ<6643Z1n{mWkObZ#)S(Z1uhwo6iCXnH+17@HIy zCE0y;lR059O#iHJidQ_cUv>3C-uCC4_Jzl+NH@CebfHJ94Tg_Q_VL^LU7O_RBls85 z=txQL{?jh2EVjiliP{6^e^x{xsAyYCv+13-z0->8>1$h~#oxcT*hY5vP1k<(A3N!^ zvfyp_wM}(dUb!0`f%K>tJ#*gFp>pbGXS;?`0`Rnic`>)?!(zKrOV?7!h zVO=~@*=p^+q<>32YO{_Ol2>%UvFktKy($XRN~n@aoX2GoeBSiXeQ~%@sA8)0d^_=V zos)bwW%}1p*EL{~Ch+8mG!*X;h6o!EyilH7V34IUK3bIQj#^1k6>qa*_OYS3O3KH| zMqLO(9?tBQ1`=qq^R*=N!Q^52*K}s;6GFfuF_9;cA-g3mNQHF3ClJ^97;xk{;JAifR9;H9k zp|L~f)KDD$wu!LO_~p<9zz5&6^+E_wA=*x*%wvxirB#9E0?o-OE+8f5eDmm%t0*o) z*?`Xy9DPld946_*K5~dBL@l&Al3vq3ynbAD%L)fCveYL*mS-IBDBU>kp+$vs%9*;wJd z?VP#GDdPWxZHa{T$GVsMIQ<1~d8`Yx)Y)PLf+YmjYROgSu-!*VHVO81?GN5)+0i8u zm}Im+hn|+4q8-w`h!eCKWz#4a;rR9cuU47(Tj`TXp|HDBvftFQUS2f3mHpO| z&6dG0$cufJgW2eTX*$p2^P(VUwm6zGCGF-d8nkCvU&%xvv6Rjkjo)Oph(opmG{1~b z5GQ+x$feR+lXfY*gl<2i`X)(Ua<+0|Aqvox6I;0?*gaqha9k4JH&B z+3?7~+}&ry>FYL5|Eaee2Th=wTJqMhUL+ek%Dk<;71a&Nqfh(R*E*_d&3|3&vSVLGUfTP4j~0{fb^VxEIuTJqkXL1-hI96L>-L5eJh}g-n@X zW;DsTYxt)nhLYTLQpETXPj>)*}{a9+n%J4#moTb+szyDdKF3` zq>M^DaWr*6o=R=1C7RUaxKt{dOr`VZ7yqzKW#%%dCU2c-vP4VwcB^cn2!jeAQ1F8o zL(i6$+McZg+Gs#r(XaY4I6MHV^&$o!YI8dRP&k+vV<1*w@gKV^8{~%YUql|P1&;ZR zzqMrWXQ~AsmIqf2d8Lc&aKqdvKAflC#xwjuz*O5aD6GlC1pAjTlOVSzQRX4DB6qW0 zw5pgotknj*WWz$`mUyjspGop(EQNXcN;LKSFr}wmu1E$^XQI9!Jb;t&sy~X=dILSo zJO@lix=Nl;?yC=n*j1N+9!?j3lw=ChNh7KIQgN>J95^R?MG9f+G=@17E@r;Ur-D3% z=LC;I?q*vU4(kPeBgOm1L7+yn3)nXhB@Gi0W)CsBeO-3v1z6UIb0jzmaQffg?XKn< z5yaDZ)}#bwFu>m%Cp_PcjT0pvEiJ92I^={`M8dpOSg>Vp0I!P)!LmCx2p}b6PT7&f zWCy<@g9fI^O2}$Y>Kcx26QaPrky)iO?d^nlYYC!<)u?C> ztH(wmAFVdHW?OB@59sI0n%0Iw_9P6|9_RM9T1hntbsiZyMyTXAWiS*{O{* zwJENB^Q|}5Ybz-A156ddCaT%2plWS0IK1C8w)@v}Cyxg&!S;=r0*yEjJV^vTn`F0VY=0(4#U!_ql^v}%%f(napU`@} z*XkkydsZ}R1LFJJ{3?9MWjgsC;3N5C-LTc+%*bk*J2fV+vb6LVfcs9XxjaLa>6n@* zQKR%ZV%2^mIch*{lj!fYL@r{5H@5jKoB%1W%Iu}as2&^u+T!WJvl)Rjc;KJn6p38% zqb(GM1{=A*m4;7Bgct@L%ZoMuCZuQ`_n(9{TO$LH0PAKOnY77@w1AIA8o`1nz)J1# zv4YZ1nXenwbxxi7(ck-1X>MT-l1zNYD^5>HnQFfUuD(UYv=k_Ym|eIR8p5NUBdfKU>4r_b z@MpZPa(H+WOag)T64lZmsN>b{e1*11KpEjPwtDE;&akFUfBFyc4<>g&4SssvmEonG z1XTh@PFr!i(DZMo`$|ibW!Y ztUyGRvWjz&OcIKOKuY#@ZwM(`+`|T)6Feep<1rrg7g@)tV6i80-^CD*kjKS$h-1vp zqn1tUhL>x=jG_q-ia&U)hyz|r)L`u^9&-uj(Q@bVF2>_?o{;rO)iR?ouyUV_a1`NU zC2y2e%-dukGZ$1`WW5mW6EQf_i{K?WT-q^(QVv`b5f7I@%rj;rv-sqKJ=KR0?1K|5~Q1{5dzy%B|PK0cL8mqwK1RAVz{F2bA+^~+v z{>LcJ6dAclwvl6t=5WP4H?P~k0Z>hO{*We=No59hU#IR{6QLG*kw~9@P}DO(QCst; z#mWPFd?9{LF;wcTCE+i2QvR6*_r48Cp1WUXFR>tzc_U3n|K?c1_$-jh+>Q_z%cZKC ze}}JYDW3QxfWp?(^X*Hwe~rs#iPV*CA1`}aECK2RiE^c6gKc=Hqn%N)~MZKyGCG=c4;U`osIC zb-~Zh*#b=5n{M`@1slqUch7M@L8@ zO#oj0Y;@f)jdR+nE71wx2-o9?>Fw$(9;8?eS53WMOCph~Ao3uoU;{W%lC#Kz?*Ab| zN`sY{Db?70)8V^o`gzDog7}I4`zWKah5~^Rh{cbbew@v|`HP3k`t-Wlyz+I6FmFL9 zGrAd^pq0g7ej1oM=phBqd)U|jW=$j)9NBgpasz;3)Xqpqs1s}lK98_lR#1;rDHHXV z?G7W>gC!1Bjam5AX=Sp)cS;}upHPiH{jm$qQb}`k8##Bq*(KK=2$LQ*KIh@Q3!c{O z%3+|nse}8j#;gXll$Zr0-}ULpNzfa+W#QqZmO-BT|A(sK_q{3c+w4HJmdFikPY;K2 zeZgMVh|(7bED-ljnJ0{VfKz1>h;dCunvC}%ZupE!l6D`*0u%x!DldbHzy~X8wc>m9 zL?LLG%`nrNY|RPQ>)V@SoSMPghAdM0Y69qh50Pq9oY)|eUIuUK>j)Vyi)(hI8Y>?? z+>=X52EpR6Z{>0h40{1~T7FpK1RHz1ID^vA-TpSh$;~?SkRm$f-;2B%taf$<9PD z42F%)@WEc=og14>Iy+flQgbK5Lf4KutE$T+n!)+%{mrb;*IbMv^X8}8nI|r8AC^0z zWH17DDp{o<=_?+zM?I+Z>=o~{eL4SY#&>H6yiMzv{yMnn05K2S>h@}vx5IUmx_4#wxyZJnuq`0Ekd zHI3-Dq)A9q;fj62Z~$%0%=^V#*U!R}8u&JyO{FMF=MAHm%T`}S9ovS)sHFu4$iAgZ=$Gp8;gT-iGk@cLuEv|OI+r&p1 z-til3fxhk-;W0>kC{As0fo57O${s?6A;XoO5U;{|=p5%Tj1KviqSN zPlby1OM$Y@1HlJpr*h@XXlwkoqgfaJ<@0!9fXJu6_f6~OPD-WfO{AC=paPsU*wNYQ zV&5+YNbhZIY~GRB>USsp=uJx#ESAu3i{HjAUNwcRSUWV&TGDf}d?mnZ3fAgFo$9jZ?o$O2pHri*8qmp^s|6L!FFUOy2;CR}q-|3ka9VkEq@k?M@$f zTDEZzto{XwKxMvC#2)mF1S_bNr>-r^D1xR`Q@(4jF_XxjKeYQa=e)byXXHxIM_Pk# zy!y!pf#UkolDBk8uU&fmzlY^I`Xi8z!(1Un#Oj!*k$Dcqjg7CcGBA@V0A zppj>0{6lB)C_*L~*lM<<1zF%f7zAWPj!;My z_Iy1-I4yCvGi{|p6uN54%>fmLk}#pyF$K^UfB#Mz>#m>)@Xw`Pin0bNP-)#*ugGXkRi5#hBvCh>(Kg|s1!ENN;_4yl=c#OTLNNi-sf^NMgdQr-d$tY4|z@zpjoGDLztfSkFLNuM19 z;?wJ-gaz8xPwBQUBoYAm{li|CJ?H0Sh!CZ>BEjm*U4B6AGq7#flp{gIF^>k!aMu%! zN<`qm(1cX1CBQWaX^cZve`UqqhXfNP_lRI|ITN=KBZ$0<|9h4C6m_L6uyxdO534~;I$N~ zz|-TjRVO)jac1Ss7I#_;5ME0b507cH_!#6Od&(`G2do?graf!yA{ch5K_-nDmybiC zt|k_YFKZ=V0#0Y0d3eQMh$o}>B`4FNZAo;}M@&3+QOG3qQcr)h3otY7>)z&JDg7N$ z#i&0G1qvL=^q1XlS0iH_`-;b?v%J)Y!!N2&<)xW_ZFg z%g;k1@0{o+-8EnA#Nr6+29zE`jC=Ce>!25(!bLA#4phzPTDi60{Y#0zd%pi6=*N`)X+^PqjKJWZZ~rvAbNpAWMd_vI?bSaQa_q#fvCX;$U;j6lu;)a@&w`NHlm7V! zD=F_k8?K2C`;iSvzngX(JFkEI)2T0n^}FuxaCSLpO>6|S@H5i|0iJuIx}bb}eJMC> zKe^N@Hi%4ac}MV@)Y0G!xMeg8#3#O#KG9de+-{pczU>uY<2$4n1p%y zVV8U5hsBNlSF!h+-9=YD&7^vBI;qnev8okS7#c-{t?9U}t6 za}S2Q7Lap!;pK1=Lg3|DiKW@Bpnznl$672SXiA)Z(IR&9Lzxt2Ic*}_{APBv1r#0AMjFGcK8k>(8rZGMvp8cXI&DxHmaXRyL|&b4)!z%J;( zwV;?_YjYcAaGM4iX=GQ`yk4F)fryJkogx(M*{WC1s*#zDkT8_)|5wtv$1~l(e|$`> z1Zaz(&qhy_nj$kdgDXW_?{GQP(5h0l;4+@Fm`Uz;y1!z|#2KWpcJ zE0r!D8c##LlW|zf4*J2X}wzq|jA;j1~Q|F1LV@sKmH?#Tik|RzKUW)es*=i5(%!t_XB3f zi#PFtsQAQU<%6p`_fF^OJsn{(hFrSc z7zDbUZO_!^{mh;g7baw3_r;pc)r&HxCPpNw05R~RL{c-?VD#s~jK)2+Mky|?k*6D& z5ihV*_MAe5!eaP%_mwI_$~z&FbGjbKGoKa?=}ZwyWbxcQoA3EOUfsR4_AyNegqj^J zzi;W*c&Zf_?t1}*N#U*6xgu(=maw9(TkNIS8tbpJJPef$nun%f?^0M+LsR8MLF zW7&#p$ItgJ?YOxYK}S8_#XNavPr>;)?bZktGMdag;&VA;*^?E=GRArt$y4z*b^9K~ zwqZiY1T=k%@13>PI23M;#UHq>9oxgUyN14Bfhb94XTO}pNJKV&<8Q`_pQGGFP)APe znRY-_trPlnMEa@soYRKVkInJUy+v8hG&V*|-hU(Bb|EM0$BBL;vQcPJZzA+uasuw0 zx%aEU$S#MY!5{zdcG^{Hhqsde$hfEbv^VZ`Z7TQF&q85Ghuu{=;hV z?VZTy4pT=3`+G0ja_Sitpugp#0&F6;*Z*;T$^B^h z+^yU%i#VS}dPql+^}1~{_xGGPGu)&jN^ws|l?Sd`nXh+RJlFY`nx7~|U|zf@td{1xLfH@J zqnWgrkI%HZ}d!Yw@IW3Vt_gL8Z z&O}W6&y@4VPLYDQ9(GF+a}e84V7__dXD;<*-rv9yeDJp)ct-eaO`+T7{32PUk0 zC$W3|yms;7k9KB1|BINkQ>qFjXY(^U2(%JV3oG^>-B7&9IC^E;RetQYB@o&j^n;wW zXU#^>?3&k>Yq-CmcNmOv-S&>@sbdlH3-L2^w%Il`Y>wb)6MlfbYT~+F~a(yCx0tMIpo3UyFAjSv1a7XD)#(t;psfy?%aG%C=42^e4?d;-u|nnWQ~+afI`)r8#}Z}(gm-g&YT*(9 zR*4`iE11IP$A!Ysv1BD3et11uIu&rqDN+NGYlZsG=<_T}pO1pglL~+<Fep3v{Q9S)L&=$s>@Irw{9Fo(M*~WHn zv`-BiM3-;eq>K%EFK8r$g=*ymCpVhIrGVR?6BPd(;{4F%a(3X^Yd7{{%*3+>5l=RH zTo-R6`ZZ^fh#7}=90#_%w?VU8I#0t{PL2zXn*9j}${xk8DS0`6juM_?XD(F- z2C4M+Mlg*;xln&01+ zxp}u>ZX#~1J5&a}g+V{wsCX*C4d)#9HG?h&Bf&%}BD$&{8x1}0=3|l4a#y%%GJn3*2MW$?DCu^QpHm_cPuqjScvlmZ(pm=(K3v2w0V-Fz@57y_w?`5h!TrE<&V1q`)n z5@3eAs#rPTP*}^kp#hcg&6F~Vca$#B@YS<&M`&P2NmY5#EJ zrLy;A)eo;_E&%=$Aaf$kbRH^jEcb|sfOAv{)L*Gl4a` zm?lA_uL(d}S=>jJ1;E~EKrIR%A(S;;@aTss=Lz#`CUi;q8#U9i2&tcr?1e-JkC8Mo zJ>6$q9pP0f=$2T5@MeFc1UWn4H@0?YC&Hjwe-#Qpg_#|49DlZ0l4Wk*Z0#PQy499Lgcz!2*(GWjp4B^B=59)-fK+@q1>h&aJc^w=TxJ)?A*v=~i!pqE z`Xn;&e5zFd28E%w_08)bb(ux!TDvvO26_?!$D9HK6yPeW_>0tBQMMsieY`R)((K)x z;7{JK+_H}r|D2zsq4K;O#b&C8nBwi*BUMsYUQ^Q2gki@4G}(Jn0plNg7mk~}9g@_n z2s}_s7r5jZ*Bl$om^n>8TqQ0$9lh$6gDgjmV+ke%p}Dn0g6^SrhrKIRjH<+ER`-{c zi`B|4sV!0T;4L9l0hOq_Dh6%d-(-QI2@>E}AtKyI9{+FV_o8@_c)Q)eY z8rCJ`7(RMmdUmZp^*38zCNmTXF&}z9pSf-gjzlvJZ@h`~hko*Mh!TaTsK8|d#ALv! z8Zd8MMs68FmO7t=0*W09Ul{*h$A>)c%4}c~?r7JAU=Ir`K>^FrT z^N_0{vjKqkka>L=e6bCk-ZTb*5$&@SokF4A_W;O zICrRDM#X)8PaN@oa!8k)_f&Ye3~gsg`*bGRD(nm@SOQ0_3piMmP#@A9WGCsdHcRI%=~SAlmHt01_cx1lPyO z@ZGh34^q}e;!y@yAXkdrQn@FkV^TFBde;At=Y(Rk5y0%xGhiAe;OeCP2Ubxx4XuXF z>!3{Q?0?39ilxr(vn;0!BvO$+*oA@3Ixxxo|DAFyL&u~oDdG2_zQ8FA)8X5J|Ah@Y zaM~TA$f1IMtAHlK3JIxFINp}=Ki2!%x?ixCp zB7-5B;Qjio3tjynJcjZDK4zH9g}YE)Gz@MZj5eZ1Y>kOZDI`)xnD9kLNx*JN$ov7T zl^h;StA`I&AtlvG)et262WC-{&I2y=q~dlayw=F@YcGU_0Hffvsx*dn!(CA1A@@hz zoVM4`Qz&NtoQdLmf7yWyXgW-2233KoSlY~7M0#q z3owP=_jGtZ&)3!wGy~%H$E$5oEL|mRGwQ(PaJR+?uC9F2g!&}@p@zkkrHa0FJl`Gz zL9b+CfKNw1HdN3r?tAT-wsQc50c&Q`ZWWS4o;m!{^YR^RNZhE-<7-@0VHWVMpLfkL z%jXW=B8yeshTcdvHWWj0Qq4GjN{zCouQ{VssGH*0XpjvuBa6$y7?MNfi(+T2Ya$Vl zWzuP`;fufNPVq601ubNmdzMLh&rv)3um#j!A?7<8iO*IH*sO?mmM3eNlY>oZ zbP7F+6tEB#ta|}5P(pcAcB~LJ zz`9;J71Z&q58~7@LtxvT3JmQUaQaDxML!Xs^LICPkO>Hlz_?jkMk7LkPh*nWe~BB+ zAmrNOnutm+2;w5;1!ix$bLnI$&AR%H9CVk#GNj4S?v!&v_+HTAx>{#;9KM4YDQ?Q^ zaAq{ixn-2M*WqqRswMj*WNrS<)7%yI_p&fh!6`W8^^V$8H(!_$(!^Mn=BeK^GZF*J z84YMu(l*eDVBKh!nG9`?8f=UN#foBg_d*QUjaOC|u6t}wbAV@h5Mn6~v615N#snY$ zWud^&z~G6SK@T$52eC2=#M5519*#4+JD!B<+wuCSH^99VL)O)R221 zOh3+<328*LjC4zr51o#du(goi6&U39gM)M819ST3z5UK7J2J>Qj$gwK*hd#X)*8-qK_z>*yE}nENQ=Iu3dTyKDn~T zvuaTbR7ry_@Sf{9bkc0YXoFk{gKu>}G`dfW9GT36I~)&c;0fQQ1fF+1Q4DcQF3}30 zIb|kSTDFr|PN*Upv^Vsf>WPW(AgBZ0 z|H+P82bqSowsGkyZQXhYt(fY)f!BA^lGQGG08y} zZ)FgzoehW^DVkD%sH|XpPe&tiI)NZiD|SIett&Y(TQv~8^bGX8=R0tLoxj^`LM6vB z{AN|ky-e=m)_j8-{Unwl+*z>>8Bi>wBGQ(y;h!Vg&B45G&A$*w2%imI zhM$_80N{KhGDT2H%W{hPK9@{@r?Ai0$T$uy1@FY(GkN3KW7^tLrJv=o$fm;Hrmd8o z4;BYEaZB3%<~<}@T&V7_dsJ@Y^;5*)sNT5XdXQ$E-r*Zm?PO##o>*DrR^s*nwUS_ z+*d8@T;fxcbn(rjN3wfasiJ@4Z(Eg+`|p~I>_kI3d*8R!Ho6{KeBd?G(fG?g>x;xS zW0$P>9J@y$-<}PdOg$0rc~br8?7uJQOHO+@cwX$hcB1{siYV?=_iez2dV7Dk>C}Sr z#c7-FZhiw1nf{XOr&<9gPO#QdcO9Qb!=nB+Io9+{vi_f<#^ zBtAJY&*i&be0n~wtW1TwYmu|Nir^<4el!DV_8x~Km!E|*w{KU~Qi-BjrFsWfF=1wf!Bq0^oX_OMy zPcCbWQxz_Dx#OW7C%m4qK4{R#7;cRx^4G3T7((F~LV4jlQ>(52(g=1tNK;Z8#E+&7 zW0R%fUoA!zd-=!Bywl8>ddfuG8piI$lZ_F!UF8JZA{Zo#F>S8H$c;QZXQBC~h?kHM zzKHYDI?Mj8w94ANJZwDz5;yT#%e<7&Lj0PC2F^NVbxH+Z4>wvluGGI5Jr}S5_&n1k zB^RBWyF=^V^I5qzl-~|555sSYZz5VeNN%tWDBt1{_NXn{3;|PmrNeH8==?NQFadHqMB*@ zFJf&|#qak*@7xit+V;5Of}2GSTC6#Grz-oM8F{mHVw8pQF8OI&HyP`ZOYoGC^ zeoNH4M@CQ_26c{7@Vx`t^a-3$p87G2`iI@~FteAYIFEN}WH+FPeQNW& z)@Nv+JXA}&3zgjT&%nPU-N4^zuPg|@SocYABk|jBB!s*${*pEODDju1TmMC@CrYP@ z)77u3)VK#-lOKdv7VX(Y^t)QuDI7redp}7ZUfE86Pp|vpa=z;jTJ$iVEq+{y+IB_I z!pWX6{ln+zgL3IAAVJ|(>YGu=&hFT7?mt^Q>2@mMp*;&Os)t zRHlsmF$863Q3FDSzfjU1vf3TJB^CipAI;re>x_oLpsap*-<>&)J|8sS{&?o*-)BJZ z@c8mz!`x3|7dc#`h&&_YwWyXum3^f~I4xZ8Vx^|Dd;y|3Y#&Mfg9Ek*VVh< z=ZW2ZIPIy4GdOkW@WMHyScCg;th)I9@-l8;LHJl_HRUPUg3TQNaH?u~v)!}+%Tc>r z@DQl(No>PcwsY&)dXLWGQZQd1-MD_loTD6OWh#V z=^-Ss3SNeGx0Tf*$3xb^-t<~)y~EEgv0|I2EvIH|BxVr{Z7P1eh}Mhk+d}S9_-8LC z+g*;G?Y!pB{|%jenPH|k*EG%ISm}0LgWk3>hHat&TpuYLjE+jEWGkbbU^|Ma+CM|e+ z>+VH8&mnqEJZj4DL+hg(&cvt}nTr`85tG6O%2@u`l)Z8XzR;Da!h}VYeAswgdM#?x zf(o^-@eL$ye3waMe(IvU&Pqbf`P{SHSP?{J+pRa{->xkVEZ&Q0kY-W+Q4#;_lI-8) z)g(IT*j8f{T3H4)icJ>nPFBM4>`=ZN8qceL9hAGn;_|@_4V%l50(0XkNXm^29$1N>t{z#VF+ulR=wp9cGU(+DmJ|oF9X#;v_LH>+C@X1 zT!lJrFq(s|PS?6Nf7^+q_WDyIF<5SblYgNkebGFOIrSR=C8AY)&v~!+i*^ytvYDG} zw@+t_$FjC!ib+08a8>f(oF=^S^t>E-5hPx# literal 0 HcmV?d00001 diff --git a/docker/fedimint-ui/index.html b/docker/fedimint-ui/index.html new file mode 100644 index 00000000..44f85d9f --- /dev/null +++ b/docker/fedimint-ui/index.html @@ -0,0 +1,452 @@ + + + + + + + + + + Fedimint Guardian - Archipelago + + + +

    +
    +
    +
    + +
    +
    +
    +
    + Fedimint Guardian +
    +
    +

    Fedimint Guardian

    +

    Guardian is installed and will open here automatically when Bitcoin Knots finishes initial block download.

    +
    +
    +
    +
    +
    +
    +
    +

    Status

    +

    Waiting for Bitcoin sync

    +
    +
    +
    +
    + +
    +
    +

    Waiting for Bitcoin sync

    +

    Fedimint needs a synced Bitcoin RPC before federation setup can start safely.

    +

    This page refreshes every 30 seconds and switches to the Guardian UI as soon as the backend is ready.

    + +
    + +
    +

    Readiness check

    +

    Checking bitcoind readiness...

    +
    +
    + + +
    + + +
    +
    + + diff --git a/docker/fedimint-ui/nginx.conf b/docker/fedimint-ui/nginx.conf new file mode 100644 index 00000000..8f78cfe0 --- /dev/null +++ b/docker/fedimint-ui/nginx.conf @@ -0,0 +1,30 @@ +server { + listen 8175; + server_name _; + + proxy_intercept_errors on; + error_page 500 502 503 504 = @wait_page; + + location /assets/ { + root /usr/share/nginx/html; + add_header Cache-Control "public, max-age=3600" always; + try_files $uri =404; + } + + location / { + proxy_pass http://127.0.0.1:8177; + proxy_http_version 1.1; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Forwarded-Proto $scheme; + proxy_set_header Upgrade $http_upgrade; + proxy_set_header Connection "upgrade"; + } + + location @wait_page { + root /usr/share/nginx/html; + add_header Cache-Control "no-store" always; + try_files /index.html =503; + } +} diff --git a/image-recipe/configs/archipelago.service b/image-recipe/configs/archipelago.service index 8c3bc16d..0cddae7c 100644 --- a/image-recipe/configs/archipelago.service +++ b/image-recipe/configs/archipelago.service @@ -8,6 +8,7 @@ Type=notify User=archipelago Environment="ARCHIPELAGO_BIND=127.0.0.1:5678" Environment="ARCHIPELAGO_USE_QUADLET_BACKENDS=true" +EnvironmentFile=-/var/lib/archipelago/telemetry.env # DEV_MODE disabled in production — enabled via override.conf on dev servers Environment="XDG_RUNTIME_DIR=/run/user/1000" # + prefix runs these as root (needed for chown/mkdir outside ReadWritePaths) diff --git a/image-recipe/configs/nginx-archipelago.conf b/image-recipe/configs/nginx-archipelago.conf index 933ba3a7..bbc3c583 100644 --- a/image-recipe/configs/nginx-archipelago.conf +++ b/image-recipe/configs/nginx-archipelago.conf @@ -148,6 +148,34 @@ server { error_page 504 = @backend_timeout; } + # JSON-RPC endpoint. Browser GETs are navigational mistakes, so send them + # back to the dashboard while keeping RPC POSTs proxied to the backend. + location = /rpc/v1 { + if ($request_method = GET) { + return 303 /; + } + if ($request_method = HEAD) { + return 303 /; + } + + limit_req zone=rpc burst=40 nodelay; + limit_req_status 429; + proxy_pass http://127.0.0.1:5678; + proxy_http_version 1.1; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + + # Limit request body to 1MB for RPC calls + client_max_body_size 1m; + + # Increase timeout for long-running operations (e.g., Docker image pulls) + proxy_connect_timeout 600s; + proxy_send_timeout 600s; + proxy_read_timeout 600s; + error_page 502 503 = @backend_unavailable; + error_page 504 = @backend_timeout; + } + # Proxy API requests to backend location /rpc/ { limit_req zone=rpc burst=40 nodelay; @@ -896,23 +924,6 @@ server { } } -# Compatibility proxy for cached PWA bundles that still launch Nginx Proxy -# Manager on :81. Rootless Podman cannot bind host ports below 1024, so the -# container admin UI runs on :8081 and host nginx owns the old :81 entrypoint. -server { - listen 81; - server_name _; - - location / { - proxy_pass http://127.0.0.1:8081/; - proxy_http_version 1.1; - proxy_set_header Host $host; - proxy_set_header X-Real-IP $remote_addr; - proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; - proxy_set_header X-Forwarded-Proto $scheme; - } -} - # HTTPS - required for PWA install (Add to Home Screen) from dev servers server { listen 443 ssl default_server; diff --git a/image-recipe/scripts/install-podman.sh b/image-recipe/scripts/install-podman.sh index d630ad10..0977bd8e 100755 --- a/image-recipe/scripts/install-podman.sh +++ b/image-recipe/scripts/install-podman.sh @@ -6,6 +6,19 @@ set -e echo "🐳 Configuring Podman for rootless operation..." +if ! command -v catatonit >/dev/null 2>&1; then + if command -v apt-get >/dev/null 2>&1; then + apt-get update || true + apt-get install -y catatonit || true + elif command -v dnf >/dev/null 2>&1; then + dnf install -y catatonit || true + elif command -v apk >/dev/null 2>&1; then + apk add catatonit || true + fi +fi + +command -v catatonit >/dev/null 2>&1 || echo "WARNING: catatonit not installed; Podman init-enabled containers may fail" + # Ensure archipelago user exists if ! id "archipelago" &>/dev/null; then echo "Creating archipelago user..." diff --git a/scripts/container-specs.sh b/scripts/container-specs.sh index 52220725..2264e56b 100755 --- a/scripts/container-specs.sh +++ b/scripts/container-specs.sh @@ -177,11 +177,16 @@ load_spec_bitcoin-knots() { SPEC_DATA_UID="100101:100101" local btc_dbcache=4096 [ "${LOW_MEM:-false}" = "true" ] && btc_dbcache=2048 + local btc_rpc_headroom="-rpcthreads=16 -rpcworkqueue=256" + local btc_txrelay_flags="-rpcwhitelistdefault=0" + if [ -f "$SECRETS_DIR/bitcoin-rpc-txrelay-rpcauth" ]; then + btc_txrelay_flags="$btc_txrelay_flags -rpcauth=$(cat "$SECRETS_DIR/bitcoin-rpc-txrelay-rpcauth") -rpcwhitelist=txrelay:sendrawtransaction,testmempoolaccept,getmempoolinfo,getrawmempool,getmempoolentry,getnetworkinfo,getblockchaininfo,getblockcount,getblockhash,getblockheader,getrawtransaction,decoderawtransaction,decodescript,estimatesmartfee" + fi # Dynamic: prune on small disk if [ "${DISK_GB:-0}" -lt 1000 ]; then - SPEC_CUSTOM_ARGS="-server=1 -prune=550 -rpcallowip=0.0.0.0/0 -rpcbind=0.0.0.0:8332 -listen=1 -bind=0.0.0.0:8333 -dbcache=${btc_dbcache} -par=0 -maxconnections=125" + SPEC_CUSTOM_ARGS="-server=1 -prune=550 -rpcallowip=0.0.0.0/0 -rpcbind=0.0.0.0:8332 -listen=1 -bind=0.0.0.0:8333 -dbcache=${btc_dbcache} -par=0 -maxconnections=125 ${btc_rpc_headroom} ${btc_txrelay_flags}" else - SPEC_CUSTOM_ARGS="-server=1 -txindex=1 -rpcallowip=0.0.0.0/0 -rpcbind=0.0.0.0:8332 -listen=1 -bind=0.0.0.0:8333 -dbcache=4096 -par=0 -maxconnections=125" + SPEC_CUSTOM_ARGS="-server=1 -txindex=1 -rpcallowip=0.0.0.0/0 -rpcbind=0.0.0.0:8332 -listen=1 -bind=0.0.0.0:8333 -dbcache=4096 -par=0 -maxconnections=125 ${btc_rpc_headroom} ${btc_txrelay_flags}" fi } @@ -518,11 +523,12 @@ load_spec_portainer() { SPEC_NAME="portainer" SPEC_IMAGE="${PORTAINER_IMAGE}" SPEC_PORTS="9000:9000" - SPEC_VOLUMES="/var/lib/archipelago/portainer:/data /run/user/1000/podman/podman.sock:/var/run/docker.sock" + SPEC_VOLUMES="/var/lib/archipelago/portainer:/data /run/user/1000/podman/podman.sock:/var/run/docker.sock /var/lib/archipelago/portainer/compose:/data/compose" SPEC_MEMORY="$(mem_limit portainer)" SPEC_HEALTH_CMD="curl -sf http://localhost:9000/ || exit 1" SPEC_TIER="3" SPEC_DATA_DIR="/var/lib/archipelago/portainer" + SPEC_DATA_UID="1000:1000" SPEC_OPTIONAL="true" } diff --git a/scripts/deploy-config.example b/scripts/deploy-config.example index 9f3eecfc..c752d8c2 100644 --- a/scripts/deploy-config.example +++ b/scripts/deploy-config.example @@ -5,3 +5,7 @@ # Edit deploy-config.sh and set ARCHIPELAGO_PASSWORD # export ARCHIPELAGO_PASSWORD='your_password_here' + +# Optional: central beta telemetry collector RPC endpoint. +# The reporter sends telemetry.ingest JSON-RPC requests here when users opt in. +# export TELEMETRY_COLLECTOR_URL='https://YOUR-COLLECTOR-HOST/rpc/v1' diff --git a/scripts/deploy-tailscale.sh b/scripts/deploy-tailscale.sh index e5b8e54d..e81fe4c2 100755 --- a/scripts/deploy-tailscale.sh +++ b/scripts/deploy-tailscale.sh @@ -17,6 +17,7 @@ set -eo pipefail SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" PROJECT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)" TARGET_DIR="/home/archipelago/archy" +PODMAN_IMAGE_CHECK_TIMEOUT="${PODMAN_IMAGE_CHECK_TIMEOUT:-10}" # Load deploy config defaults (IP addresses etc.) [ -f "$SCRIPT_DIR/deploy-config-defaults.sh" ] && . "$SCRIPT_DIR/deploy-config-defaults.sh" @@ -186,7 +187,7 @@ deploy_node() { # Transfer custom UI images (individual tarballs — never combined) echo " Transferring custom UI images..." for ui_img in bitcoin-ui lnd-ui electrs-ui; do - HAS_IMG=$(ssh $SSH_OPTS "$BUILD_SOURCE" "podman images --format '{{.Repository}}:{{.Tag}}' 2>/dev/null | grep -q '${ui_img}:' && echo yes || echo no" 2>/dev/null) + HAS_IMG=$(ssh $SSH_OPTS "$BUILD_SOURCE" "timeout --kill-after=2s ${PODMAN_IMAGE_CHECK_TIMEOUT}s podman image exists 'localhost/${ui_img}:local' 2>/dev/null && echo yes || echo no" 2>/dev/null) if [ "$HAS_IMG" = "yes" ]; then echo " $ui_img..." if ssh $SSH_OPTS "$BUILD_SOURCE" "podman save 'localhost/${ui_img}:local' 2>/dev/null" > "/tmp/${ui_img}.tar" 2>/dev/null && [ -s "/tmp/${ui_img}.tar" ]; then @@ -926,12 +927,19 @@ LNDCONF if \$DOCKER ps -a --format '{{.Names}}' 2>/dev/null | grep -qx portainer; then \$DOCKER start portainer 2>/dev/null || true else - sudo mkdir -p /var/lib/archipelago/portainer + sudo mkdir -p /var/lib/archipelago/portainer/compose + sudo chown -R archipelago:archipelago /var/lib/archipelago/portainer 2>/dev/null || true + if [ ! -e /data ]; then + sudo ln -s /var/lib/archipelago/portainer /data 2>/dev/null || true + elif [ -d /data ] && [ ! -L /data ] && [ ! -e /data/compose ]; then + sudo ln -s /var/lib/archipelago/portainer/compose /data/compose 2>/dev/null || true + fi \$DOCKER run -d --name portainer --restart unless-stopped \ --health-cmd 'curl -sf http://localhost:9000/' --health-interval=30s --health-timeout=5s --health-retries=3 \ --cap-drop ALL --cap-add CHOWN --cap-add SETUID --cap-add SETGID --cap-add DAC_OVERRIDE \ --security-opt no-new-privileges:true \ -p 9000:9000 -v /var/lib/archipelago/portainer:/data \ + -v /var/lib/archipelago/portainer/compose:/data/compose \ -v /run/user/1000/podman/podman.sock:/var/run/docker.sock \ $PORTAINER_IMAGE fi diff --git a/scripts/deploy-to-target.sh b/scripts/deploy-to-target.sh index f6ea1ed4..a98b02bf 100755 --- a/scripts/deploy-to-target.sh +++ b/scripts/deploy-to-target.sh @@ -421,6 +421,20 @@ deploy_secondary() { rm -f /tmp/archipelago.service ' 2>/dev/null || true fi + if [ -n "${TELEMETRY_COLLECTOR_URL:-}" ]; then + echo " Syncing telemetry collector config to .$SEC_LABEL..." + TMP_TELEMETRY_ENV="$(mktemp)" + printf 'TELEMETRY_COLLECTOR_URL=%s\n' "$TELEMETRY_COLLECTOR_URL" > "$TMP_TELEMETRY_ENV" + scp $SSH_OPTS "$TMP_TELEMETRY_ENV" "$SEC_TARGET:/tmp/telemetry.env" 2>/dev/null || true + rm -f "$TMP_TELEMETRY_ENV" + ssh $SSH_OPTS "$SEC_TARGET" ' + sudo mkdir -p /var/lib/archipelago + sudo cp /tmp/telemetry.env /var/lib/archipelago/telemetry.env + sudo chown archipelago:archipelago /var/lib/archipelago/telemetry.env + sudo chmod 600 /var/lib/archipelago/telemetry.env + rm -f /tmp/telemetry.env + ' 2>/dev/null || true + fi # Deploy udev rule for mesh radio UDEV_RULE="$PROJECT_DIR/image-recipe/configs/99-mesh-radio.rules" @@ -682,6 +696,20 @@ if [ "$LIVE" = true ]; then rm -f /tmp/archipelago.service ' 2>/dev/null || true fi + if [ -n "${TELEMETRY_COLLECTOR_URL:-}" ]; then + progress "Syncing telemetry collector config" + TMP_TELEMETRY_ENV="$(mktemp)" + printf 'TELEMETRY_COLLECTOR_URL=%s\n' "$TELEMETRY_COLLECTOR_URL" > "$TMP_TELEMETRY_ENV" + scp $SSH_OPTS "$TMP_TELEMETRY_ENV" "$TARGET_HOST:/tmp/telemetry.env" 2>/dev/null || true + rm -f "$TMP_TELEMETRY_ENV" + ssh $SSH_OPTS "$TARGET_HOST" ' + sudo mkdir -p /var/lib/archipelago + sudo cp /tmp/telemetry.env /var/lib/archipelago/telemetry.env + sudo chown archipelago:archipelago /var/lib/archipelago/telemetry.env + sudo chmod 600 /var/lib/archipelago/telemetry.env + rm -f /tmp/telemetry.env + ' 2>/dev/null || true + fi # Deploy udev rule for mesh radio stable naming (/dev/mesh-radio) UDEV_RULE="$PROJECT_DIR/image-recipe/configs/99-mesh-radio.rules" diff --git a/scripts/first-boot-containers.sh b/scripts/first-boot-containers.sh index 72b6901d..c702822a 100755 --- a/scripts/first-boot-containers.sh +++ b/scripts/first-boot-containers.sh @@ -431,6 +431,17 @@ fi # Rootless podman prerequisites (run as root, configures for archipelago user) log "Setting up rootless podman prerequisites..." +if ! command -v catatonit >/dev/null 2>&1; then + log "Installing catatonit for Podman init support..." + if command -v apt-get >/dev/null 2>&1; then + apt-get update >>"$LOG" 2>&1 || true + apt-get install -y catatonit >>"$LOG" 2>&1 || true + elif command -v dnf >/dev/null 2>&1; then + dnf install -y catatonit >>"$LOG" 2>&1 || true + elif command -v apk >/dev/null 2>&1; then + apk add catatonit >>"$LOG" 2>&1 || true + fi +fi # Allow binding to ports >= 80 (rootless default is 1024) if ! grep -q "unprivileged_port_start=80" /etc/sysctl.d/99-rootless-podman.conf 2>/dev/null; then echo "net.ipv4.ip_unprivileged_port_start=80" > /etc/sysctl.d/99-rootless-podman.conf @@ -612,7 +623,7 @@ if ! $DOCKER ps --format '{{.Names}}' 2>/dev/null | grep -qE 'bitcoin-knots|arch -v /var/lib/archipelago/bitcoin:/home/bitcoin/.bitcoin \ "${BITCOIN_KNOTS_IMAGE}" \ $BTC_EXTRA_ARGS \ - -printtoconsole=1 -dbcache=$BTC_DBCACHE -par=0 -maxconnections=125 2>>"$LOG"; then + -printtoconsole=1 -dbcache=$BTC_DBCACHE -par=0 -maxconnections=125 -rpcthreads=16 -rpcworkqueue=256 2>>"$LOG"; then log "Bitcoin Knots started" else log "Bitcoin Knots failed (may already exist)" @@ -1202,7 +1213,13 @@ fi track_container "nginx-proxy-manager" if ! $DOCKER ps --format '{{.Names}}' 2>/dev/null | grep -q portainer; then log "Creating Portainer..." - mkdir -p /var/lib/archipelago/portainer + mkdir -p /var/lib/archipelago/portainer/compose + chown -R archipelago:archipelago /var/lib/archipelago/portainer 2>/dev/null || true + if [ ! -e /data ]; then + ln -s /var/lib/archipelago/portainer /data 2>/dev/null || true + elif [ -d /data ] && [ ! -L /data ] && [ ! -e /data/compose ]; then + ln -s /var/lib/archipelago/portainer/compose /data/compose 2>/dev/null || true + fi $DOCKER run -d --name portainer --restart unless-stopped \ --health-cmd="curl -sf http://localhost:9000/ || exit 1" --health-interval=120s --health-timeout=5s --health-retries=3 \ --memory=$(mem_limit portainer) \ @@ -1210,7 +1227,8 @@ if ! $DOCKER ps --format '{{.Names}}' 2>/dev/null | grep -q portainer; then --security-opt no-new-privileges:true \ -p 9000:9000 \ -v /var/lib/archipelago/portainer:/data \ - -v /var/run/podman/podman.sock:/var/run/docker.sock \ + -v /var/lib/archipelago/portainer/compose:/data/compose \ + -v /run/user/$(id -u archipelago)/podman/podman.sock:/var/run/docker.sock \ "$PORTAINER_IMAGE" 2>>"$LOG" || true fi track_container "portainer" @@ -1232,7 +1250,7 @@ if ! $DOCKER ps --format '{{.Names}}' 2>/dev/null | grep -q tailscale; then -v /var/lib/archipelago/tailscale:/var/lib/tailscale \ -e TS_STATE_DIR=/var/lib/tailscale \ "$TAILSCALE_IMAGE" \ - sh -c 'tailscaled --tun=userspace-networking & sleep 2; tailscale web --listen 0.0.0.0:8240 & wait' 2>>"$LOG" || true + sh -c 'tailscaled --tun=userspace-networking & for i in $(seq 1 30); do [ -S /var/run/tailscale/tailscaled.sock ] && break; sleep 1; done; tailscale web --listen 0.0.0.0:8240 & wait' 2>>"$LOG" || true fi track_container "tailscale" diff --git a/scripts/fix-indeedhub-containers.sh b/scripts/fix-indeedhub-containers.sh index c3416cec..8a873a18 100755 --- a/scripts/fix-indeedhub-containers.sh +++ b/scripts/fix-indeedhub-containers.sh @@ -10,6 +10,7 @@ SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" # This script: stops broken containers, removes them, recreates with correct images. echo "=== IndeedHub Container Fix Script ===" +PODMAN_IMAGE_CHECK_TIMEOUT="${PODMAN_IMAGE_CHECK_TIMEOUT:-10}" # Detect node IP (Tailscale or LAN) NODE_IP=$(hostname -I | awk '{for(i=1;i<=NF;i++) if($i ~ /^100\./) print $i}') @@ -29,7 +30,7 @@ fi # Verify correct images are available echo "Verifying images..." for img in "${INDEEDHUB_REDIS_IMAGE}" "${MINIO_IMAGE}" "${INDEEDHUB_POSTGRES_IMAGE}" "${NOSTR_RS_RELAY_IMAGE}" "${SEARXNG_IMAGE}" "localhost/indeedhub:local" "localhost/indeedhub-build_api:local" "localhost/indeedhub-build_ffmpeg-worker:local"; do - if ! podman image exists "$img" 2>/dev/null; then + if ! timeout --kill-after=2s "${PODMAN_IMAGE_CHECK_TIMEOUT}s" podman image exists "$img" 2>/dev/null; then echo "ERROR: Missing image $img" exit 1 fi diff --git a/scripts/reconcile-containers.sh b/scripts/reconcile-containers.sh index 73a58f68..8b9b2c34 100755 --- a/scripts/reconcile-containers.sh +++ b/scripts/reconcile-containers.sh @@ -98,6 +98,11 @@ alloc_port() { # Run as archipelago user — podman sees rootless containers directly. # Use sudo only for chown/mkdir operations. PODMAN="podman" +PODMAN_IMAGE_CHECK_TIMEOUT="${PODMAN_IMAGE_CHECK_TIMEOUT:-10}" + +podman_bounded() { + timeout --kill-after=2s "${PODMAN_IMAGE_CHECK_TIMEOUT}s" "$PODMAN" "$@" +} # ── Pre-flight ─────────────────────────────────────────────────────── header "╔══════════════════════════════════════════════════╗" @@ -152,7 +157,7 @@ container_image_id() { } spec_image_id() { - $PODMAN image inspect "$SPEC_IMAGE" --format '{{.Id}}' 2>/dev/null + podman_bounded image inspect "$SPEC_IMAGE" --format '{{.Id}}' 2>/dev/null } container_network() { @@ -218,6 +223,39 @@ prepare_bind_source() { esac } +ensure_catatonit() { + command -v catatonit >/dev/null 2>&1 && return 0 + $CHECK_ONLY && { info "catatonit missing (would install)"; return 0; } + + if command -v apt-get >/dev/null 2>&1; then + sudo apt-get update >/dev/null 2>&1 || true + sudo apt-get install -y catatonit >/dev/null 2>&1 || true + elif command -v dnf >/dev/null 2>&1; then + sudo dnf install -y catatonit >/dev/null 2>&1 || true + elif command -v apk >/dev/null 2>&1; then + sudo apk add catatonit >/dev/null 2>&1 || true + fi + + command -v catatonit >/dev/null 2>&1 || { fail "catatonit missing; Portainer compose builds may fail"; return 1; } +} + +ensure_portainer_host_paths() { + ensure_catatonit + if $CHECK_ONLY; then + [ -d /var/lib/archipelago/portainer/compose ] || info "Portainer compose dir missing (would create)" + [ -e /data ] || info "/data host path missing (would link to /var/lib/archipelago/portainer)" + return 0 + fi + + sudo mkdir -p /var/lib/archipelago/portainer/compose 2>/dev/null || true + sudo chown -R 1000:1000 /var/lib/archipelago/portainer 2>/dev/null || true + if [ ! -e /data ]; then + sudo ln -s /var/lib/archipelago/portainer /data 2>/dev/null || true + elif [ -d /data ] && [ ! -L /data ] && [ ! -e /data/compose ]; then + sudo ln -s /var/lib/archipelago/portainer/compose /data/compose 2>/dev/null || true + fi +} + container_has_mount() { local name="$1" source="$2" target="$3" $PODMAN inspect "$name" --format '{{range .Mounts}}{{println .Source "|" .Destination}}{{end}}' 2>/dev/null \ @@ -250,13 +288,7 @@ container_env_val() { URL_ENV_SUFFIXES="_URL _HOST _ENDPOINT" image_exists() { - # Note: `grep -q` closes stdin after first match → SIGPIPE (exit 141) on podman. - # With `set -o pipefail` active in the parent script, that propagates as failure - # and spuriously skips local-image containers. Use a full scan + explicit match - # check to keep the exit code stable regardless of pipefail. - local images - images=$($PODMAN images --format '{{.Repository}}:{{.Tag}}' 2>/dev/null) - echo "$images" | grep -qF "$1" + podman_bounded image exists "$1" >/dev/null 2>&1 } resolve_spec_image() { @@ -280,7 +312,7 @@ resolve_spec_image() { fi done - repo=$($PODMAN images --format '{{.Repository}}:{{.Tag}}' 2>/dev/null \ + repo=$(podman_bounded images --format '{{.Repository}}:{{.Tag}}' 2>/dev/null \ | grep -E "/${image_name}:${image_tag}$" \ | head -1 || true) if [ -n "$repo" ]; then @@ -377,6 +409,8 @@ reconcile() { return fi + [ "$name" = "portainer" ] && ensure_portainer_host_paths + # Filter by tier [ -n "$FILTER_TIER" ] && [ "$SPEC_TIER" != "$FILTER_TIER" ] && return @@ -701,7 +735,7 @@ BTCEOF # bitcoin_rw.conf, so clean both files. for conf in "$BITCOIN_CONF" "/var/lib/archipelago/bitcoin/bitcoin_rw.conf"; do if [ -f "$conf" ]; then - sudo sed -i '/^server=/d; /^txindex=/d; /^rpcbind=/d; /^rpcallowip=/d; /^rpcport=/d; /^listen=/d; /^bind=/d; /^dbcache=/d' "$conf" 2>/dev/null + sudo sed -i '/^server=/d; /^txindex=/d; /^rpcbind=/d; /^rpcallowip=/d; /^rpcport=/d; /^listen=/d; /^bind=/d; /^dbcache=/d; /^rpcthreads=/d; /^rpcworkqueue=/d' "$conf" 2>/dev/null fi done sudo chown -R 100101:100101 /var/lib/archipelago/bitcoin 2>/dev/null diff --git a/tests/lifecycle/remote-lifecycle.sh b/tests/lifecycle/remote-lifecycle.sh index ea4eefc9..b700c107 100755 --- a/tests/lifecycle/remote-lifecycle.sh +++ b/tests/lifecycle/remote-lifecycle.sh @@ -158,6 +158,7 @@ image_for() { dwn) echo "146.59.87.168:3000/lfg2025/dwn-server:main" ;; botfights) echo "146.59.87.168:3000/lfg2025/botfights:1.1.0" ;; gitea) echo "docker.io/gitea/gitea:1.23" ;; + meshtastic) echo "docker.io/meshtastic/meshtasticd:daily-alpine" ;; *) return 1 ;; esac } @@ -219,6 +220,8 @@ rpc_call() { payload=$(jq -nc --arg m "$method" --argjson p "$params" --argjson id "$id" '{jsonrpc:"2.0",method:$m,params:$p,id:$id}') fi curl -sk -X POST "${BASE_URL}/rpc/v1" \ + --connect-timeout 8 \ + -m "${ARCHY_RPC_TIMEOUT:-60}" \ -H 'Content-Type: application/json' \ -H "Cookie: session=${SESSION}; csrf_token=${CSRF}" \ -H "X-CSRF-Token: ${CSRF}" \ @@ -244,9 +247,16 @@ container_state() { } container_health() { - local app="$1" - rpc_result container-health "$(jq -nc --arg app "$app" '{app_id:$app}')" \ - | jq -r --arg app "$app" '.[$app] // "unknown" | ascii_downcase' + local app="$1" health + health=$( + ARCHY_RPC_TIMEOUT="${ARCHY_HEALTH_RPC_TIMEOUT:-20}" \ + rpc_result container-health "$(jq -nc --arg app "$app" '{app_id:$app}')" \ + | jq -r --arg app "$app" '.[$app] // "unknown" | ascii_downcase' + ) || health=unknown + if [[ "$app" == "indeedhub" && "$health" != "healthy" ]] && probe_launch "$app" >/dev/null 2>&1; then + health=healthy + fi + printf '%s\n' "$health" } assert_container_healthy() { @@ -277,6 +287,10 @@ observe_stable() { while (( $(date +%s) < deadline )); do state=$(container_state "$app" 2>/dev/null || echo unknown) if [[ "$state" != "running" ]]; then + if [[ "$app" == "indeedhub" ]] && probe_launch "$app" >/dev/null 2>&1; then + sleep 5 + continue + fi echo "stability failed: $app left running state (last=$state)" >&2 return 1 fi @@ -292,7 +306,9 @@ wait_state() { while (( $(date +%s) < deadline )); do state=$(container_state "$app" 2>/dev/null || echo unknown) if [[ "$target" == "absent" && "$state" == "absent" ]]; then return 0; fi + if [[ "$target" == "stopped" && "$state" == "absent" ]]; then return 0; fi if [[ "$target" != "absent" && "$state" == "$target" ]]; then return 0; fi + if [[ "$app" == "indeedhub" && "$target" == "running" ]] && probe_launch "$app" >/dev/null 2>&1; then return 0; fi sleep 5 done echo "$app did not reach $target within ${timeout}s (last=$state)" >&2 @@ -346,6 +362,8 @@ probe_launch() { case "$app" in lnd) probe_lnd_wallet_connect "$body" || { rm -f "$body"; return 1; } ;; electrumx|electrs|mempool-electrs) probe_electrum_wallet_connect "$body" || { rm -f "$body"; return 1; } ;; + indeedhub) probe_indeedhub_nostr_signer "$body" || { rm -f "$body"; return 1; } ;; + tailscale) probe_tailscale_login_ui "$body" || { rm -f "$body"; return 1; } ;; esac rm -f "$body" } @@ -362,6 +380,7 @@ wait_launch() { assert_launch_metadata() { local app="$1" timeout="${2:-$ARCHY_TIMEOUT}" deadline lan + launch_url_for "$app" >/dev/null 2>&1 || return 0 deadline=$(( $(date +%s) + timeout )) while (( $(date +%s) < deadline )); do lan=$(rpc_result container-list | jq -r --arg app "$app" ' @@ -436,6 +455,47 @@ probe_electrum_wallet_connect() { } } +probe_indeedhub_nostr_signer() { + local body="$1" provider pubkey signed now + require_body "$body" '/nostr-provider.js' 'IndeedHub Nostr provider injection' || return 1 + provider=$(curl -skL --connect-timeout 8 -m 20 "http://${ARCHY_HOST}:7778/nostr-provider.js" || true) + if [[ -z "$provider" ]]; then + echo "indeedhub nostr-provider.js unavailable" >&2 + return 1 + fi + printf '%s' "$provider" | grep -Eq 'window\.nostr|nostr' || { + echo "indeedhub nostr-provider.js does not look like a Nostr signer bridge" >&2 + return 1 + } + + pubkey=$(rpc_result node.nostr-pubkey | jq -r '.nostr_pubkey // empty') + if ! [[ "$pubkey" =~ ^[0-9a-fA-F]{64}$ ]]; then + echo "indeedhub Nostr signer pubkey unavailable: $pubkey" >&2 + return 1 + fi + + now=$(date +%s) + signed=$(rpc_result node.nostr-sign "$(jq -nc --argjson created_at "$now" '{event:{kind:1,created_at:$created_at,tags:[],content:"archy lifecycle indeedhub signer probe"}}')") + printf '%s' "$signed" | jq -e --arg pubkey "$pubkey" ' + .pubkey == $pubkey and + (.id | type == "string" and test("^[0-9a-f]{64}$")) and + (.sig | type == "string" and test("^[0-9a-f]{128}$")) and + .content == "archy lifecycle indeedhub signer probe" + ' >/dev/null || { + echo "indeedhub Nostr signer did not return a valid signed event: $signed" >&2 + return 1 + } +} + +probe_tailscale_login_ui() { + local body="$1" + if grep -Eiq 'tailscale|login|log in|sign in|authenticate|authorize|auth key|connect' "$body"; then + return 0 + fi + echo "tailscale launch did not present login/auth UI content" >&2 + return 1 +} + install_app() { local app="$1" app_json image params app_json=$(catalog_app_json "$app" || true)

    uqn2ZG+2P=mi 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%0D@~SNV8b1^^U1Y2W83D*`k?ZP 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