From 301336fc8639f25f7edd6043ba988b7cbf8ecd5d Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Wed, 2 Aug 2023 16:01:55 -0400
Subject: [PATCH 01/37] trying out new storage interface

---
 examples/basic_test.rs      |  40 +++--
 examples/basic_test_copy.rs | 348 ++++++++++++++++++++++++++++++++++++
 src/applicationlayer.rs     |  11 +-
 src/ratchet_state.rs        | 106 ++++-------
 src/zeta.rs                 | 143 ++++++++-------
 5 files changed, 488 insertions(+), 160 deletions(-)
 create mode 100644 examples/basic_test_copy.rs

diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index 6d98679..b24402c 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -20,7 +20,6 @@ use rand_core::OsRng;
 use rand_core::RngCore;
 use sha2::Sha512;
 
-use zssp_proto::crypto::secure_eq;
 use zssp_proto::ratchet_state::RatchetState;
 use zssp_proto::{Session, Settings, RATCHET_SIZE};
 
@@ -29,7 +28,7 @@ const TEST_MTU: usize = 1500;
 struct TestApplication {
     time: Instant,
     name: &'static str,
-    ratchets: Mutex<[RatchetState; 2]>,
+    ratchets: Mutex<(RatchetState, Option<RatchetState>)>,
 }
 
 #[allow(unused)]
@@ -66,17 +65,18 @@ impl zssp_proto::ApplicationLayer for &TestApplication {
         (Some((true, ())), true)
     }
 
-    fn restore_by_fingerprint(&self, ratchet_fingerprint: &[u8; RATCHET_SIZE]) -> Result<RatchetState, Self::DiskError> {
+    fn restore_by_fingerprint(&self, ratchet_fingerprint: &[u8; RATCHET_SIZE]) -> Result<Option<RatchetState>, Self::DiskError> {
         let ratchets = self.ratchets.lock().unwrap();
-        for rs in ratchets.iter() {
-            if rs.nonempty().map_or(false, |rs| secure_eq(&rs.fingerprint, ratchet_fingerprint)) {
-                return Ok(rs.clone());
-            }
+        if ratchets.0.fingerprint_eq(ratchet_fingerprint) {
+            return Ok(Some(ratchets.0.clone()));
         }
-        Ok(RatchetState::Null)
+        if ratchets.1.as_ref().map_or(false, |rs| rs.fingerprint_eq(ratchet_fingerprint)) {
+            return Ok(ratchets.1.clone());
+        }
+        Ok(None)
     }
 
-    fn restore_by_identity(&self, remote_static_key: &Self::PublicKey, application_data: &Self::Data) -> Result<[RatchetState; 2], Self::DiskError> {
+    fn restore_by_identity(&self, remote_static_key: &Self::PublicKey, application_data: &Self::Data) -> Result<(RatchetState, Option<RatchetState>), Self::DiskError> {
         Ok(self.ratchets.lock().unwrap().clone())
     }
 
@@ -84,15 +84,17 @@ impl zssp_proto::ApplicationLayer for &TestApplication {
         &self,
         remote_static_key: &Self::PublicKey,
         application_data: &Self::Data,
-        pre_ratchet_states: [&RatchetState; 2],
-        new_ratchet_states: [&RatchetState; 2],
+        state1: &RatchetState,
+        state2: Option<&RatchetState>,
+        state_added: Option<&RatchetState>,
+        state_deleted1: Option<&RatchetState>,
+        state_deleted2: Option<&RatchetState>,
     ) -> Result<(), Self::DiskError> {
         let mut ratchets = self.ratchets.lock().unwrap();
-        ratchets[0] = new_ratchet_states[0].clone();
-        ratchets[1] = new_ratchet_states[1].clone();
-        let chain_len = new_ratchet_states[0].chain_len();
-        if chain_len > pre_ratchet_states[0].chain_len() {
-            println!("[{}] new ratchet #{}", self.name, chain_len);
+        ratchets.0 = state1.clone();
+        ratchets.1 = state2.cloned();
+        if let Some(rs) = state_added {
+            println!("[{}] new ratchet #{}", self.name, rs.chain_len);
         }
         Ok(())
     }
@@ -283,19 +285,19 @@ fn bob_main(
 fn core(time: u64, packet_success_rate: u32) {
     let run = &AtomicBool::new(true);
 
-    let shared_ratchet_states = RatchetState::new_from_otp::<Sha512>(b"password1");
+    let shared_ratchet_state = RatchetState::new_from_otp::<Sha512>(b"password1");
     let alice_keypair = EphemeralSecret::random(&mut OsRng);
     let alice_app = TestApplication {
         time: Instant::now(),
         name: "alice",
-        ratchets: Mutex::new(shared_ratchet_states.clone()),
+        ratchets: Mutex::new((shared_ratchet_state.clone(), None)),
     };
     let bob_keypair = EphemeralSecret::random(&mut OsRng);
     let bob_pubkey = bob_keypair.public_key();
     let bob_app = TestApplication {
         time: Instant::now(),
         name: "bob",
-        ratchets: Mutex::new(shared_ratchet_states),
+        ratchets: Mutex::new((shared_ratchet_state, None)),
     };
 
     let (alice_out, bob_in) = mpsc::sync_channel::<Vec<u8>>(256);
diff --git a/examples/basic_test_copy.rs b/examples/basic_test_copy.rs
new file mode 100644
index 0000000..4199295
--- /dev/null
+++ b/examples/basic_test_copy.rs
@@ -0,0 +1,348 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * (c) ZeroTier, Inc.
+ * https://www.zerotier.com/
+ */
+
+use std::collections::HashMap;
+use std::iter::ExactSizeIterator;
+use std::str::FromStr;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{mpsc, Arc, Mutex};
+use std::thread;
+use std::time::{Duration, Instant};
+
+use aes::Aes256;
+use aes_gcm::Aes256Gcm;
+use p384::{ecdh::EphemeralSecret, PublicKey};
+use rand_core::OsRng;
+use rand_core::RngCore;
+use sha2::Sha512;
+
+use zssp_proto::ratchet_state::RatchetState;
+use zssp_proto::{Session, Settings, RATCHET_SIZE};
+
+const TEST_MTU: usize = 1500;
+
+struct TestApplication {
+    time: Instant,
+    name: &'static str,
+    ratchets: Mutex<Ratchets>,
+}
+
+struct Ratchets {
+    rf_map: HashMap<[u8; RATCHET_SIZE], RatchetState>,
+    peer_map: HashMap<u128, (RatchetState, Option<RatchetState>)>,
+}
+
+#[allow(unused)]
+impl zssp_proto::ApplicationLayer for &TestApplication {
+    const SETTINGS: Settings = Settings {
+        initial_offer_timeout: Settings::INITIAL_OFFER_TIMEOUT_MS,
+        rekey_timeout: 60 * 1000,
+        rekey_after_time: 3000,
+        rekey_time_max_jitter: 1000,
+        rekey_after_key_uses: Settings::REKEY_AFTER_KEY_USES,
+        resend_time: 250,
+        fragment_assembly_timeout: Settings::FRAGMENT_ASSEMBLY_TIMEOUT_MS,
+    };
+    type Rng = OsRng;
+    type Prp = Aes256;
+    type Aead = Aes256Gcm;
+    type Hash = Sha512;
+    type PublicKey = PublicKey;
+    type KeyPair = EphemeralSecret;
+    type Kem = [u8; pqc_kyber::KYBER_SECRETKEYBYTES];
+
+    type DiskError = ();
+    type Data = u128;
+
+    fn hello_requires_recognized_ratchet(&self) -> bool {
+        true
+    }
+
+    fn initiator_disallows_downgrade(&self, session: &Arc<Session<Self>>) -> bool {
+        true
+    }
+
+    fn check_accept_session(&self, remote_static_key: &Self::PublicKey, identity: &[u8]) -> (Option<(bool, Self::Data)>, bool) {
+        (Some((true, 0)), true)
+    }
+
+    fn restore_by_fingerprint(&self, ratchet_fingerprint: &[u8; RATCHET_SIZE]) -> Result<Option<RatchetState>, Self::DiskError> {
+        let ratchets = self.ratchets.lock().unwrap();
+        Ok(ratchets.rf_map.get(ratchet_fingerprint).cloned())
+    }
+
+    fn restore_by_identity(&self, remote_static_key: &Self::PublicKey, application_data: &Self::Data) -> Result<(RatchetState, Option<RatchetState>), Self::DiskError> {
+        let ratchets = self.ratchets.lock().unwrap();
+        Ok(ratchets.peer_map.get(application_data).cloned())
+    }
+
+    fn save_ratchet_state(
+        &self,
+        remote_static_key: &Self::PublicKey,
+        application_data: &Self::Data,
+        state1: &RatchetState,
+        state2: Option<&RatchetState>,
+        state_added: Option<&RatchetState>,
+        state_deleted1: Option<&RatchetState>,
+        state_deleted2: Option<&RatchetState>,
+    ) -> Result<(), Self::DiskError> {
+        let mut ratchets = self.ratchets.lock().unwrap();
+        ratchets.0 = state1.clone();
+        ratchets.1 = state2.cloned();
+        if let Some(rs) = state_added {
+            println!("[{}] new ratchet #{}", self.name, rs.chain_len);
+        }
+        Ok(())
+    }
+
+    fn time(&self) -> i64 {
+        self.time.elapsed().as_millis() as i64
+    }
+
+    fn event_log(&self, event: zssp_proto::LogEvent<Self>) {
+        println!(">[{}] {:?}", self.name, event);
+    }
+}
+
+fn alice_main(
+    run: &AtomicBool,
+    packet_success_rate: u32,
+    alice_app: &TestApplication,
+    alice_out: mpsc::SyncSender<Vec<u8>>,
+    alice_in: mpsc::Receiver<Vec<u8>>,
+    recursive_out: mpsc::SyncSender<Vec<u8>>,
+    alice_keypair: EphemeralSecret,
+    bob_pubkey: PublicKey,
+) {
+    let startup_time = std::time::Instant::now();
+    let context = zssp_proto::Context::<&TestApplication>::new(alice_keypair, OsRng);
+    let mut next_service = startup_time.elapsed().as_millis() as i64 + 500;
+    let test_data = [1u8; TEST_MTU * 10];
+    let mut up = false;
+    let mut alice_session = None;
+
+    while run.load(Ordering::Relaxed) {
+        if alice_session.is_none() {
+            up = false;
+            alice_session = Some(
+                context
+                    .open(alice_app, |b| alice_out.send(b).is_ok(), TEST_MTU, bob_pubkey.clone(), (), Vec::new())
+                    .unwrap(),
+            );
+            println!("[alice] opening session");
+        }
+        let current_time = startup_time.elapsed().as_millis() as i64;
+        loop {
+            let pkt = alice_in.try_recv();
+            if let Ok(pkt) = pkt {
+                if OsRng.next_u32() <= packet_success_rate {
+                    use zssp_proto::result::ReceiveError::*;
+                    use zssp_proto::result::ReceiveOk::*;
+                    use zssp_proto::result::SessionEvent::*;
+                    match context.receive(
+                        alice_app,
+                        |b| alice_out.send(b).is_ok(),
+                        TEST_MTU,
+                        |_| Some((|b| alice_out.send(b).is_ok(), TEST_MTU)),
+                        &0,
+                        pkt,
+                    ) {
+                        Ok(Unassociated) => {
+                            //println!("[alice] ok");
+                        }
+                        Ok(Session(_, event)) => match event {
+                            Established => {
+                                up = true;
+                            }
+                            Data(data) => {
+                                assert!(!data.is_empty());
+                                //println!("[alice] received {}", data.len());
+                            }
+                            NewSession => panic!(),
+                            Rejected => panic!(),
+                            Control => (),
+                        },
+                        Err(e) => {
+                            println!("[alice] ERROR {:?}", e);
+                            if let ByzantineFault { unnatural, .. } = e {
+                                assert!(!unnatural)
+                            }
+                        }
+                    }
+                } else if OsRng.next_u32() | 1 > 0 {
+                    let _ = recursive_out.send(pkt);
+                }
+            } else {
+                break;
+            }
+        }
+
+        if up {
+            context
+                .send(
+                    alice_session.as_ref().unwrap(),
+                    |b| alice_out.send(b).is_ok(),
+                    TEST_MTU,
+                    test_data[..1400 + ((OsRng.next_u64() as usize) % (test_data.len() - 1400))].to_vec(),
+                )
+                .unwrap();
+        } else {
+            thread::sleep(Duration::from_millis(10));
+        }
+        // TODO: we need to more comprehensively test if re-opening the session works
+        if OsRng.next_u32() <= ((u32::MAX as f64) * 0.0000025) as u32 {
+            alice_session = None;
+        }
+
+        if current_time >= next_service {
+            next_service = current_time + context.service(alice_app, |_| Some((|b| alice_out.send(b).is_ok(), TEST_MTU)));
+        }
+    }
+}
+
+fn bob_main(
+    run: &AtomicBool,
+    packet_success_rate: u32,
+    bob_app: &TestApplication,
+    bob_out: mpsc::SyncSender<Vec<u8>>,
+    bob_in: mpsc::Receiver<Vec<u8>>,
+    recursive_out: mpsc::SyncSender<Vec<u8>>,
+    bob_keypair: EphemeralSecret,
+) {
+    let startup_time = std::time::Instant::now();
+    let context = zssp_proto::Context::<&TestApplication>::new(bob_keypair, OsRng);
+    let mut last_speed_metric = startup_time.elapsed().as_millis() as i64;
+    let mut next_service = last_speed_metric + 500;
+    let mut transferred = 0u64;
+
+    let mut bob_session = None;
+
+    while run.load(Ordering::Relaxed) {
+        let pkt = bob_in.recv_timeout(Duration::from_millis(100));
+        let current_time = startup_time.elapsed().as_millis() as i64;
+
+        if let Ok(pkt) = pkt {
+            if OsRng.next_u32() <= packet_success_rate {
+                use zssp_proto::result::ReceiveError::*;
+                use zssp_proto::result::ReceiveOk::*;
+                use zssp_proto::result::SessionEvent::*;
+                match context.receive(
+                    bob_app,
+                    |b| bob_out.send(b).is_ok(),
+                    TEST_MTU,
+                    |_| Some((|b| bob_out.send(b).is_ok(), TEST_MTU)),
+                    &0,
+                    pkt,
+                ) {
+                    Ok(Unassociated) => {}
+                    Ok(Session(s, event)) => match event {
+                        NewSession => {
+                            println!("[bob] new session, took {}s", current_time as f32 / 1000.0);
+                            let _ = bob_session.replace(s);
+                        }
+                        Data(data) => {
+                            assert!(!data.is_empty());
+                            //println!("[bob] received {}", data.len());
+                            transferred += data.len() as u64 * 2; // *2 because we are also sending this many bytes back
+                            context.send(&s, |b| bob_out.send(b).is_ok(), TEST_MTU, data).unwrap();
+                        }
+                        Established => panic!(),
+                        Rejected => panic!(),
+                        Control => (),
+                    },
+                    Err(e) => {
+                        println!("[bob] ERROR {:?}", e);
+                        if let ByzantineFault { unnatural, .. } = e {
+                            assert!(!unnatural)
+                        }
+                    }
+                }
+            } else if OsRng.next_u32() | 1 > 0 {
+                let _ = recursive_out.try_send(pkt);
+            }
+        }
+
+        let speed_metric_elapsed = current_time - last_speed_metric;
+        if speed_metric_elapsed >= 10000 {
+            last_speed_metric = current_time;
+            println!(
+                "[bob] throughput: {} MiB/sec (combined input and output)",
+                ((transferred as f64) / 1048576.0) / ((speed_metric_elapsed as f64) / 1000.0)
+            );
+            transferred = 0;
+        }
+
+        if current_time >= next_service {
+            next_service = current_time + context.service(bob_app, |_| Some((|b| bob_out.send(b).is_ok(), TEST_MTU)));
+        }
+    }
+}
+
+fn core(time: u64, packet_success_rate: u32) {
+    let run = &AtomicBool::new(true);
+
+    let shared_ratchet_state = RatchetState::new_from_otp::<Sha512>(b"password1");
+    let alice_keypair = EphemeralSecret::random(&mut OsRng);
+    let alice_app = TestApplication {
+        time: Instant::now(),
+        name: "alice",
+        ratchets: Mutex::new((shared_ratchet_state.clone(), None)),
+    };
+    let bob_keypair = EphemeralSecret::random(&mut OsRng);
+    let bob_pubkey = bob_keypair.public_key();
+    let bob_app = TestApplication {
+        time: Instant::now(),
+        name: "bob",
+        ratchets: Mutex::new((shared_ratchet_state, None)),
+    };
+
+    let (alice_out, bob_in) = mpsc::sync_channel::<Vec<u8>>(256);
+    let (bob_out, alice_in) = mpsc::sync_channel::<Vec<u8>>(256);
+
+    thread::scope(|ts| {
+        {
+            let alice_out = alice_out.clone();
+            let bob_out = bob_out.clone();
+            ts.spawn(move || {
+                alice_main(
+                    run,
+                    packet_success_rate,
+                    &alice_app,
+                    alice_out,
+                    alice_in,
+                    bob_out,
+                    alice_keypair,
+                    bob_pubkey,
+                )
+            });
+        }
+        ts.spawn(move || bob_main(run, packet_success_rate, &bob_app, bob_out, bob_in, alice_out, bob_keypair));
+
+        thread::sleep(Duration::from_secs(time));
+
+        run.store(false, Ordering::SeqCst);
+        println!("finished");
+    });
+}
+
+fn main() {
+    let args = std::env::args();
+    let packet_success_rate = if args.len() <= 1 {
+        let default_success_rate = 1.0;
+        ((u32::MAX as f64) * default_success_rate) as u32
+    } else {
+        ((u32::MAX as f64) * f64::from_str(args.last().unwrap().as_str()).unwrap()) as u32
+    };
+
+    core(60 * 60, packet_success_rate)
+}
+
+#[test]
+fn test_main() {
+    core(2, u32::MAX / 2)
+}
diff --git a/src/applicationlayer.rs b/src/applicationlayer.rs
index 3ea8922..2d0d78a 100644
--- a/src/applicationlayer.rs
+++ b/src/applicationlayer.rs
@@ -161,11 +161,11 @@ pub trait ApplicationLayer: Sized {
     /// If `RatchetAction::DowngradeRatchet` is returned we will attempt to convince Alice to downgrade
     /// to the empty ratchet key, restarting the ratchet chain.
     /// If `RatchetAction::FailAuthentication` is returned Alice's connection will be silently dropped.
-    fn restore_by_fingerprint(&self, ratchet_fingerprint: &[u8; RATCHET_SIZE]) -> Result<RatchetState, Self::DiskError>;
+    fn restore_by_fingerprint(&self, ratchet_fingerprint: &[u8; RATCHET_SIZE]) -> Result<Option<RatchetState>, Self::DiskError>;
     /// Lookup a specific ratchet state based on the identity of the peer being communicated with.
     /// This function will be called whenever Alice attempts to open a session, or Bob attempts
     /// to verify Alice's identity.
-    fn restore_by_identity(&self, remote_static_key: &Self::PublicKey, application_data: &Self::Data) -> Result<[RatchetState; 2], Self::DiskError>;
+    fn restore_by_identity(&self, remote_static_key: &Self::PublicKey, application_data: &Self::Data) -> Result<(RatchetState, Option<RatchetState>), Self::DiskError>;
     /// Atomically save the given `new_ratchet_states` to persistent storage.
     /// `pre_ratchet_states` contains what should be the previous contents of persistent storage.
     ///
@@ -186,8 +186,11 @@ pub trait ApplicationLayer: Sized {
         &self,
         remote_static_key: &Self::PublicKey,
         application_data: &Self::Data,
-        pre_ratchet_states: [&RatchetState; 2],
-        new_ratchet_states: [&RatchetState; 2],
+        state1: &RatchetState,
+        state2: Option<&RatchetState>,
+        state_added: Option<&RatchetState>,
+        state_deleted1: Option<&RatchetState>,
+        state_deleted2: Option<&RatchetState>,
     ) -> Result<(), Self::DiskError>;
 
     /// Receives a stream of events that occur during an execution of ZSSP.
diff --git a/src/ratchet_state.rs b/src/ratchet_state.rs
index 615a60f..8c26086 100644
--- a/src/ratchet_state.rs
+++ b/src/ratchet_state.rs
@@ -1,30 +1,34 @@
+use zeroize::Zeroizing;
+
 use crate::crypto::{secure_eq, HashSha512};
 use crate::proto::*;
-use std::ops::Deref;
-
-#[derive(Clone, PartialEq, Eq)]
-pub enum RatchetState {
-    Null,
-    Empty,
-    NonEmpty(NonEmptyRatchetState),
+/// A ratchet key and fingerprint,
+/// along with the length of the ratchet chain the keys were derived from.
+#[derive(Clone, Eq)]
+pub struct RatchetState {
+    pub key: Zeroizing<[u8; RATCHET_SIZE]>,
+    pub fingerprint: Option<Zeroizing<[u8; RATCHET_SIZE]>>,
+    pub chain_len: u64,
+}
+impl PartialEq for RatchetState {
+    fn eq(&self, other: &Self) -> bool {
+        secure_eq(&self.key, &other.key) & (self.chain_len == other.chain_len) &
+        match (self.fingerprint.as_ref(), other.fingerprint.as_ref()) {
+            (Some(rf1), Some(rf2)) => secure_eq(rf1, rf2),
+            (None, None) => true,
+            _ => false,
+        }
+    }
 }
-use zeroize::Zeroizing;
-use RatchetState::*;
 impl RatchetState {
-    /// Helper function to create a new nonempty ratchet state from a raw ratchet key, fingerprint,
-    /// and the ratchet chain's current length.
-    pub fn new_nonempty(key: Zeroizing<[u8; RATCHET_SIZE]>, fingerprint: Zeroizing<[u8; RATCHET_SIZE]>, chain_len: u64) -> Self {
-        NonEmpty(NonEmptyRatchetState { key, fingerprint, chain_len })
+    pub fn new(key: Zeroizing<[u8; RATCHET_SIZE]>, fingerprint: Zeroizing<[u8; RATCHET_SIZE]>, chain_len: u64) -> Self {
+        RatchetState { key, fingerprint: Some(fingerprint), chain_len }
     }
-    /// Creates the set of two ratchet states that ZSSP initializes a key exchange with when
-    /// communicating to a brand new peer.
-    pub fn new_initial_states() -> [RatchetState; 2] {
-        [RatchetState::Empty, RatchetState::Null]
+    pub fn empty() -> Self {
+        RatchetState { key: Zeroizing::new([0u8; RATCHET_SIZE]), fingerprint: None, chain_len: 0 }
     }
-    /// Creates a set of two ratchet states that ZSSP can initialize a key exchange with when
-    /// communicating to a brand new peer.
-    /// The peer must know the one-time-password and initialize their key exchange with it as well.
-    pub fn new_from_otp<Hmac: HashSha512>(otp: &[u8]) -> [RatchetState; 2] {
+
+    pub fn new_from_otp<Hmac: HashSha512>(otp: &[u8]) -> RatchetState {
         let mut buffer = Vec::new();
         buffer.push(1);
         buffer.extend(LABEL_OTP_TO_RATCHET);
@@ -33,60 +37,16 @@ impl RatchetState {
         let r1 = Hmac::hmac(otp, &buffer);
         buffer[0] = 2;
         let r2 = Hmac::hmac(otp, &buffer);
-        [
-            Self::new_nonempty(
-                Zeroizing::new(r1[..RATCHET_SIZE].try_into().unwrap()),
-                Zeroizing::new(r2[..RATCHET_SIZE].try_into().unwrap()),
-                1,
-            ),
-            RatchetState::Null,
-        ]
+        Self::new(
+            Zeroizing::new(r1[..RATCHET_SIZE].try_into().unwrap()),
+            Zeroizing::new(r2[..RATCHET_SIZE].try_into().unwrap()),
+            1,
+        )
     }
-    /// Returns true if this ratchet state is the null ratchet state.
-    pub fn is_null(&self) -> bool {
-        matches!(self, Null)
-    }
-    /// Returns true if this ratchet state is the empty ratchet state. The empty ratchet state has
-    /// a key of all zeros and the empty string as the ratchet fingerprint.
     pub fn is_empty(&self) -> bool {
-        matches!(self, Empty)
+        self.fingerprint.is_none()
     }
-    /// Retrieve a nonempty ratchet state if it exists.
-    pub fn nonempty(&self) -> Option<&NonEmptyRatchetState> {
-        match self {
-            NonEmpty(rs) => Some(rs),
-            _ => None,
-        }
-    }
-    /// Retrieve the ratchet chain length, or 0 if this ratchet state is null or empty.
-    pub fn chain_len(&self) -> u64 {
-        self.nonempty().map_or(0, |rs| rs.chain_len)
-    }
-    /// Retrieve the ratchet fingerprint if it exists.
-    pub fn fingerprint(&self) -> Option<&[u8; RATCHET_SIZE]> {
-        self.nonempty().map(|rs| rs.fingerprint.deref())
-    }
-    /// Retrieve the ratchet key if it exists.
-    /// This function will return a key of all zeros if this ratchet state is the empty ratchet state.
-    pub fn key(&self) -> Option<&[u8; RATCHET_SIZE]> {
-        const ZERO_KEY: [u8; RATCHET_SIZE] = [0u8; RATCHET_SIZE];
-        match self {
-            Null => None,
-            Empty => Some(&ZERO_KEY),
-            NonEmpty(rs) => Some(&rs.key),
-        }
-    }
-}
-/// A ratchet key and fingerprint,
-/// along with the length of the ratchet chain the keys were derived from.
-#[derive(Clone, Eq)]
-pub struct NonEmptyRatchetState {
-    pub key: Zeroizing<[u8; RATCHET_SIZE]>,
-    pub fingerprint: Zeroizing<[u8; RATCHET_SIZE]>,
-    pub chain_len: u64,
-}
-impl PartialEq for NonEmptyRatchetState {
-    fn eq(&self, other: &Self) -> bool {
-        secure_eq(&self.key, &other.key) && secure_eq(&self.fingerprint, &other.fingerprint) && self.chain_len == other.chain_len
+    pub fn fingerprint_eq(&self, rf: &[u8; RATCHET_SIZE]) -> bool {
+        self.fingerprint.as_ref().map_or(false, |rf0| secure_eq(rf0, rf))
     }
 }
diff --git a/src/zeta.rs b/src/zeta.rs
index 74026cd..0537945 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -50,7 +50,8 @@ pub(crate) struct Zeta<App: ApplicationLayer> {
 
     key_index: bool,
     keys: [DuplexKey; 2],
-    ratchet_states: [RatchetState; 2],
+    ratchet_state1: RatchetState,
+    ratchet_state2: Option<RatchetState>,
     pub hk_send: Zeroizing<[u8; AES_256_KEY_SIZE]>,
 
     resend_timer: i64,
@@ -66,7 +67,6 @@ pub(crate) struct Zeta<App: ApplicationLayer> {
 pub struct Session<App: ApplicationLayer>(pub(crate) Mutex<Zeta<App>>);
 
 pub(crate) struct StateB2<App: ApplicationLayer> {
-    /// Can never be Null.
     ratchet_state: RatchetState,
     kid_send: NonZeroU32,
     pub kid_recv: NonZeroU32,
@@ -207,7 +207,8 @@ fn create_a1_state<App: ApplicationLayer>(
     rng: &Mutex<App::Rng>,
     s_remote: &App::PublicKey,
     kid_recv: NonZeroU32,
-    ratchet_states: &[RatchetState; 2],
+    ratchet_state1: &RatchetState,
+    ratchet_state2: Option<&RatchetState>,
     identity: Vec<u8>,
 ) -> Option<StateA1<App>> {
     //    <- s
@@ -231,10 +232,11 @@ fn create_a1_state<App: ApplicationLayer>(
     noise.encrypt_and_hash_in_place(to_nonce(PACKET_TYPE_HANDSHAKE_HELLO, 0), i, &mut x1);
     // Process message pattern 1 payload.
     let i = x1.len();
-    for r in ratchet_states {
-        if let Some(rf) = r.fingerprint() {
-            x1.extend(rf);
-        }
+    if let Some(rf) = ratchet_state1.fingerprint.as_ref() {
+        x1.extend(rf.as_ref());
+    }
+    if let Some(Some(rf)) = ratchet_state2.map(|rs| rs.fingerprint.as_ref()) {
+        x1.extend(rf.as_ref());
     }
     noise.encrypt_and_hash_in_place(to_nonce(PACKET_TYPE_HANDSHAKE_HELLO, 1), i, &mut x1);
 
@@ -257,14 +259,14 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
     identity: Vec<u8>,
     send: impl FnOnce(&Packet),
 ) -> Result<Arc<Session<App>>, OpenError<App::DiskError>> {
-    let ratchet_states = app
+    let (ratchet_state1, ratchet_state2) = app
         .restore_by_identity(&s_remote, &application_data)
         .map_err(|e| OpenError::RatchetIoError(e))?;
 
     let mut session_map = ctx.session_map.lock().unwrap();
     let kid_recv = gen_kid(session_map.deref(), ctx.rng.lock().unwrap().deref_mut());
 
-    let a1 = create_a1_state(&ctx.rng, &s_remote, kid_recv, &ratchet_states, identity).ok_or(OpenError::InvalidPublicKey)?;
+    let a1 = create_a1_state(&ctx.rng, &s_remote, kid_recv, &ratchet_state1, ratchet_state2.as_ref(), identity).ok_or(OpenError::InvalidPublicKey)?;
     let packet = a1.packet.clone();
 
     let (hk_recv, hk_send) = a1.noise.get_ask(LABEL_HEADER_KEY);
@@ -281,7 +283,8 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
         defrag: DefragBuffer::new(Some(hk_recv)),
         key_index: true,
         keys: [DuplexKey::default(), DuplexKey::default()],
-        ratchet_states,
+        ratchet_state1,
+        ratchet_state2,
         hk_send,
         resend_timer: current_time + App::SETTINGS.resend_time as i64,
         timeout_timer: current_time + App::SETTINGS.initial_offer_timeout as i64,
@@ -355,24 +358,26 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
         return Err(byzantine_fault!(FailedAuth, true));
     }
 
-    let mut ratchet_state = RatchetState::Null;
+    let mut ratchet_state = None;
     while i + RATCHET_SIZE <= j {
         match app.restore_by_fingerprint((&x1[i..i + RATCHET_SIZE]).try_into().unwrap()) {
-            Ok(RatchetState::Null) | Ok(RatchetState::Empty) => {}
-            Ok(rs) => {
-                ratchet_state = rs;
+            Ok(None) => {}
+            Ok(Some(rs)) => {
+                ratchet_state = Some(rs);
                 break;
             }
             Err(e) => return Err(ReceiveError::RatchetIoError(e)),
         }
         i += RATCHET_SIZE;
     }
-    if ratchet_state.is_null() {
+    let ratchet_state = if let Some(rs) = ratchet_state {
+        rs
+    } else {
         if app.hello_requires_recognized_ratchet() {
             return Err(byzantine_fault!(FailedAuth, true));
         }
-        ratchet_state = RatchetState::Empty;
-    }
+        RatchetState::empty()
+    };
     let (hk_send, hk_recv) = noise.get_ask(LABEL_HEADER_KEY);
 
     let mut x2 = Vec::new();
@@ -390,7 +395,7 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     noise.mix_key(ekem1_secret.as_ref());
     drop(ekem1_secret);
     // Process message pattern 2 psk2 token.
-    noise.mix_key_and_hash(ratchet_state.key().unwrap());
+    noise.mix_key_and_hash(ratchet_state.key.as_ref());
     // Process message pattern 2 payload.
     let session_map = ctx.session_map.lock().unwrap();
     let kid_recv = gen_kid(session_map.deref(), ctx.rng.lock().unwrap().deref_mut());
@@ -490,19 +495,15 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
                 NonZeroU32::new(u32::from_be_bytes(payload)).map(|kid2| (kid2, noise))
             };
             // Check first key.
-            let mut ratchet_i = 0;
-            let mut result = None;
-            let mut chain_len = 0;
-            if let Some(key) = zeta.ratchet_states[0].key() {
-                chain_len = zeta.ratchet_states[0].chain_len();
-                result = test_ratchet_key(key);
-            }
+            let mut ratchet_i = 1;
+            let mut chain_len = zeta.ratchet_state1.chain_len;
+            let mut result = test_ratchet_key(zeta.ratchet_state1.key.as_ref());
             // Check second key.
             if result.is_none() {
-                ratchet_i = 1;
-                if let Some(key) = zeta.ratchet_states[1].key() {
-                    chain_len = zeta.ratchet_states[1].chain_len();
-                    result = test_ratchet_key(key);
+                ratchet_i = 2;
+                if let Some(rs) = zeta.ratchet_state2.as_ref() {
+                    chain_len = rs.chain_len;
+                    result = test_ratchet_key(rs.key.as_ref());
                 }
             }
             // Check zero key.
@@ -529,14 +530,21 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
             noise.encrypt_and_hash_in_place(to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 0), i, &mut x3);
 
             let (rk, rf) = noise.get_ask(LABEL_RATCHET_STATE);
-            let new_ratchet_state = RatchetState::new_nonempty(rk, rf, chain_len + 1);
+            let new_ratchet_state = RatchetState::new(rk, rf, chain_len + 1);
 
-            let ratchet_to_preserve = &zeta.ratchet_states[ratchet_i];
+            let (ratchet_to_preserve, ratchet_to_delete) = if ratchet_i == 1 {
+                (Some(&zeta.ratchet_state1), zeta.ratchet_state2.as_ref())
+            } else {
+                (zeta.ratchet_state2.as_ref(), Some(&zeta.ratchet_state1))
+            };
             let result = app.save_ratchet_state(
                 &zeta.s_remote,
                 &zeta.application_data,
-                [&zeta.ratchet_states[0], &zeta.ratchet_states[1]],
-                [&new_ratchet_state, ratchet_to_preserve],
+                &new_ratchet_state,
+                ratchet_to_preserve,
+                Some(&new_ratchet_state),
+                ratchet_to_delete,
+                None,
             );
             if let Err(e) = result {
                 return Err(ReceiveError::RatchetIoError(e));
@@ -552,8 +560,8 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
             zeta.key_mut(true).send.nk = Some(nk_send);
             zeta.key_mut(true).recv.kek = Some(kek_recv);
             zeta.key_mut(true).recv.nk = Some(nk_recv);
-            zeta.ratchet_states[1] = zeta.ratchet_states[ratchet_i].clone();
-            zeta.ratchet_states[0] = new_ratchet_state;
+            zeta.ratchet_state2 = Some(zeta.ratchet_state1.clone());
+            zeta.ratchet_state1 = new_ratchet_state;
             let current_time = app.time();
             zeta.key_creation_counter = zeta.send_counter;
             zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
@@ -630,15 +638,9 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
     if let Some((responder_disallows_downgrade, application_data)) = responder_disallows_downgrade {
         let result = app.restore_by_identity(&s_remote, &application_data);
         match result {
-            Ok(true_ratchet_states) => {
-                let mut has_match = false;
-                for rs in &true_ratchet_states {
-                    if !rs.is_null() {
-                        has_match |= &zeta.ratchet_state == rs;
-                    }
-                }
-                if !has_match {
-                    if !responder_disallows_downgrade && zeta.ratchet_state.is_empty() {
+            Ok((ratchet_state1, ratchet_state2)) => {
+                if (&zeta.ratchet_state != &ratchet_state1) & (Some(&zeta.ratchet_state) != ratchet_state2.as_ref()) {
+                    if !responder_disallows_downgrade && zeta.ratchet_state.fingerprint.is_none() {
                         // TODO: add some kind of warning callback or signal.
                     } else {
                         if !responder_silently_rejects {
@@ -650,12 +652,15 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
 
                 let (rk, rf) = noise.get_ask(LABEL_RATCHET_STATE);
                 // We must make sure the ratchet key is saved before we transition.
-                let new_ratchet_state = RatchetState::new_nonempty(rk, rf, zeta.ratchet_state.chain_len() + 1);
+                let new_ratchet_state = RatchetState{ key: rk, fingerprint: Some(rf), chain_len: zeta.ratchet_state.chain_len + 1,};
                 let result = app.save_ratchet_state(
                     &s_remote,
                     &application_data,
-                    [&true_ratchet_states[0], &true_ratchet_states[1]],
-                    [&new_ratchet_state, &RatchetState::Null],
+                    &new_ratchet_state,
+                    None,
+                    Some(&new_ratchet_state),
+                    Some(&ratchet_state1),
+                    ratchet_state2.as_ref(),
                 );
                 if let Err(e) = result {
                     return Err(ReceiveError::RatchetIoError(e));
@@ -690,7 +695,8 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                     key_creation_counter: INIT_COUNTER + 1,
                     key_index: false,
                     keys: [keys, DuplexKey::default()],
-                    ratchet_states: [new_ratchet_state, RatchetState::Null],
+                    ratchet_state1: new_ratchet_state,
+                    ratchet_state2: None,
                     hk_send: zeta.hk_send.clone(),
                     resend_timer: current_time + App::SETTINGS.resend_time as i64,
                     timeout_timer: current_time + App::SETTINGS.rekey_timeout as i64,
@@ -750,19 +756,22 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
     let just_establised = is_other && matches!(&zeta.beta, ZsspAutomata::A3 { .. });
     if is_other {
         if let ZsspAutomata::A3 { .. } | ZsspAutomata::R2 { .. } = &zeta.beta {
-            if !zeta.ratchet_states[1].is_null() {
+            if zeta.ratchet_state2.is_some() {
                 let result = app.save_ratchet_state(
                     &zeta.s_remote,
                     &zeta.application_data,
-                    [&zeta.ratchet_states[0], &zeta.ratchet_states[1]],
-                    [&zeta.ratchet_states[0], &RatchetState::Null],
+                    &zeta.ratchet_state1,
+                    None,
+                    None,
+                    zeta.ratchet_state2.as_ref(),
+                    None,
                 );
                 if let Err(e) = result {
                     return Err(ReceiveError::RatchetIoError(e));
                 }
             }
 
-            zeta.ratchet_states[1] = RatchetState::Null;
+            zeta.ratchet_state2 = None;
             zeta.key_index ^= true;
             zeta.timeout_timer = app.time()
                 + App::SETTINGS
@@ -928,7 +937,7 @@ fn timeout_trans<App: ApplicationLayer>(
             }
             let new_kid_recv = remap(session, &zeta, &ctx.rng, &ctx.session_map);
 
-            if let Some(a1) = create_a1_state(&ctx.rng, &zeta.s_remote, new_kid_recv, &zeta.ratchet_states, identity.clone()) {
+            if let Some(a1) = create_a1_state(&ctx.rng, &zeta.s_remote, new_kid_recv, &zeta.ratchet_state1, zeta.ratchet_state2.as_ref(), identity.clone()) {
                 let (hk_recv, hk_send) = a1.noise.get_ask(LABEL_HEADER_KEY);
                 let packet = a1.packet.clone();
 
@@ -958,7 +967,7 @@ fn timeout_trans<App: ApplicationLayer>(
             noise.mix_hash(&ctx.s_secret.public_key_bytes());
             noise.mix_hash(&zeta.s_remote.to_bytes());
             // Process message pattern 1 psk0 token.
-            noise.mix_key_and_hash(zeta.ratchet_states[0].key().unwrap());
+            noise.mix_key_and_hash(zeta.ratchet_state1.key.as_ref());
             // Process message pattern 1 e token.
             let e_secret = noise.write_e(&ctx.rng, &mut k1);
             // Process message pattern 1 es token.
@@ -1056,7 +1065,7 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
         noise.mix_hash(&zeta.s_remote.to_bytes());
         noise.mix_hash(&s_secret.public_key_bytes());
         // Process message pattern 1 psk0 token.
-        noise.mix_key_and_hash(zeta.ratchet_states[0].key().unwrap());
+        noise.mix_key_and_hash(zeta.ratchet_state1.key.as_ref());
         // Process message pattern 1 e token.
         let e_remote = noise.read_e(&mut i, &k1).ok_or(byzantine_fault!(FailedAuth, true))?;
         // Process message pattern 1 es token.
@@ -1086,12 +1095,15 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
         noise.encrypt_and_hash_in_place(to_nonce(PACKET_TYPE_REKEY_COMPLETE, 0), i, &mut k2);
 
         let (rk, rf) = noise.get_ask(LABEL_RATCHET_STATE);
-        let new_ratchet_state = RatchetState::new_nonempty(rk, rf, zeta.ratchet_states[0].chain_len() + 1);
+        let new_ratchet_state = RatchetState::new(rk, rf, zeta.ratchet_state1.chain_len + 1);
         let result = app.save_ratchet_state(
             &zeta.s_remote,
             &zeta.application_data,
-            [&zeta.ratchet_states[0], &zeta.ratchet_states[1]],
-            [&new_ratchet_state, &zeta.ratchet_states[0]],
+            &new_ratchet_state,
+            Some(&zeta.ratchet_state1),
+            Some(&new_ratchet_state),
+            zeta.ratchet_state2.as_ref(),
+            None,
         );
         if let Err(e) = result {
             return Err(ReceiveError::RatchetIoError(e));
@@ -1105,8 +1117,8 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
         zeta.key_mut(true).recv.kid = Some(new_kid_recv);
         zeta.key_mut(true).recv.kek = Some(kek_recv);
         zeta.key_mut(true).recv.nk = Some(nk_recv);
-        zeta.ratchet_states[1] = zeta.ratchet_states[0].clone();
-        zeta.ratchet_states[0] = new_ratchet_state;
+        zeta.ratchet_state2 = Some(zeta.ratchet_state1.clone());
+        zeta.ratchet_state1 = new_ratchet_state;
         let current_time = app.time();
         zeta.key_creation_counter = zeta.send_counter;
         zeta.timeout_timer = current_time + App::SETTINGS.rekey_timeout as i64;
@@ -1179,12 +1191,15 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
             let kid_send = NonZeroU32::new(u32::from_be_bytes(k2[i..j].try_into().unwrap())).ok_or(byzantine_fault!(InvalidPacket, true))?;
 
             let (rk, rf) = noise.get_ask(LABEL_RATCHET_STATE);
-            let new_ratchet_state = RatchetState::new_nonempty(rk, rf, zeta.ratchet_states[0].chain_len() + 1);
+            let new_ratchet_state = RatchetState::new(rk, rf, zeta.ratchet_state1.chain_len + 1);
             let result = app.save_ratchet_state(
                 &zeta.s_remote,
                 &zeta.application_data,
-                [&zeta.ratchet_states[0], &zeta.ratchet_states[1]],
-                [&new_ratchet_state, &RatchetState::Null],
+                &new_ratchet_state,
+                None,
+                Some(&new_ratchet_state),
+                Some(&zeta.ratchet_state1),
+                zeta.ratchet_state2.as_ref(),
             );
             if let Err(e) = result {
                 return Err(ReceiveError::RatchetIoError(e));
@@ -1197,7 +1212,7 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
             zeta.key_mut(true).send.nk = Some(nk_send);
             zeta.key_mut(true).recv.kek = Some(kek_recv);
             zeta.key_mut(true).recv.nk = Some(nk_recv);
-            zeta.ratchet_states[0] = new_ratchet_state;
+            zeta.ratchet_state1 = new_ratchet_state;
             zeta.key_index ^= true;
             let current_time = app.time();
             zeta.key_creation_counter = zeta.send_counter;

From 56ee4002a46b708b87e15a744e4758334d80c6ff Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Wed, 2 Aug 2023 16:42:35 -0400
Subject: [PATCH 02/37] fixed error

---
 examples/basic_test_copy.rs | 29 ++++++++++++++++++++++-------
 1 file changed, 22 insertions(+), 7 deletions(-)

diff --git a/examples/basic_test_copy.rs b/examples/basic_test_copy.rs
index 4199295..943303b 100644
--- a/examples/basic_test_copy.rs
+++ b/examples/basic_test_copy.rs
@@ -8,6 +8,7 @@
 
 use std::collections::HashMap;
 use std::iter::ExactSizeIterator;
+use std::ops::Deref;
 use std::str::FromStr;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{mpsc, Arc, Mutex};
@@ -36,6 +37,14 @@ struct Ratchets {
     rf_map: HashMap<[u8; RATCHET_SIZE], RatchetState>,
     peer_map: HashMap<u128, (RatchetState, Option<RatchetState>)>,
 }
+impl Ratchets {
+    fn new() -> Self {
+        Self {
+            rf_map: HashMap::new(),
+            peer_map: HashMap::new(),
+        }
+    }
+}
 
 #[allow(unused)]
 impl zssp_proto::ApplicationLayer for &TestApplication {
@@ -78,7 +87,7 @@ impl zssp_proto::ApplicationLayer for &TestApplication {
 
     fn restore_by_identity(&self, remote_static_key: &Self::PublicKey, application_data: &Self::Data) -> Result<(RatchetState, Option<RatchetState>), Self::DiskError> {
         let ratchets = self.ratchets.lock().unwrap();
-        Ok(ratchets.peer_map.get(application_data).cloned())
+        Ok(ratchets.peer_map.get(application_data).cloned().unwrap_or_else(|| (RatchetState::empty(), None)))
     }
 
     fn save_ratchet_state(
@@ -92,11 +101,18 @@ impl zssp_proto::ApplicationLayer for &TestApplication {
         state_deleted2: Option<&RatchetState>,
     ) -> Result<(), Self::DiskError> {
         let mut ratchets = self.ratchets.lock().unwrap();
-        ratchets.0 = state1.clone();
-        ratchets.1 = state2.cloned();
+        ratchets.peer_map.insert(*application_data, (state1.clone(), state2.cloned()));
+        // TODO: change the API to get rid of unwrap.
         if let Some(rs) = state_added {
+            ratchets.rf_map.insert(*rs.fingerprint.as_ref().unwrap().deref(), rs.clone());
             println!("[{}] new ratchet #{}", self.name, rs.chain_len);
         }
+        if let Some(rs) = state_deleted1 {
+            ratchets.rf_map.remove(rs.fingerprint.as_ref().unwrap().deref());
+        }
+        if let Some(rs) = state_deleted2 {
+            ratchets.rf_map.remove(rs.fingerprint.as_ref().unwrap().deref());
+        }
         Ok(())
     }
 
@@ -131,7 +147,7 @@ fn alice_main(
             up = false;
             alice_session = Some(
                 context
-                    .open(alice_app, |b| alice_out.send(b).is_ok(), TEST_MTU, bob_pubkey.clone(), (), Vec::new())
+                    .open(alice_app, |b| alice_out.send(b).is_ok(), TEST_MTU, bob_pubkey.clone(), 0, Vec::new())
                     .unwrap(),
             );
             println!("[alice] opening session");
@@ -286,19 +302,18 @@ fn bob_main(
 fn core(time: u64, packet_success_rate: u32) {
     let run = &AtomicBool::new(true);
 
-    let shared_ratchet_state = RatchetState::new_from_otp::<Sha512>(b"password1");
     let alice_keypair = EphemeralSecret::random(&mut OsRng);
     let alice_app = TestApplication {
         time: Instant::now(),
         name: "alice",
-        ratchets: Mutex::new((shared_ratchet_state.clone(), None)),
+        ratchets: Mutex::new(Ratchets::new()),
     };
     let bob_keypair = EphemeralSecret::random(&mut OsRng);
     let bob_pubkey = bob_keypair.public_key();
     let bob_app = TestApplication {
         time: Instant::now(),
         name: "bob",
-        ratchets: Mutex::new((shared_ratchet_state, None)),
+        ratchets: Mutex::new(Ratchets::new()),
     };
 
     let (alice_out, bob_in) = mpsc::sync_channel::<Vec<u8>>(256);

From e8a85d484bd6b22ee9c982f6e057aa014e8a5134 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Thu, 3 Aug 2023 11:24:27 -0400
Subject: [PATCH 03/37] finished new api

---
 examples/basic_test.rs      |  53 ++++--
 examples/basic_test_copy.rs | 363 ------------------------------------
 src/applicationlayer.rs     |  15 +-
 src/ratchet_state.rs        |  21 ++-
 src/zeta.rs                 |   8 +-
 5 files changed, 69 insertions(+), 391 deletions(-)
 delete mode 100644 examples/basic_test_copy.rs

diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index b24402c..8a031a1 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -6,6 +6,7 @@
  * https://www.zerotier.com/
  */
 
+use std::collections::HashMap;
 use std::iter::ExactSizeIterator;
 use std::str::FromStr;
 use std::sync::atomic::{AtomicBool, Ordering};
@@ -28,7 +29,20 @@ const TEST_MTU: usize = 1500;
 struct TestApplication {
     time: Instant,
     name: &'static str,
-    ratchets: Mutex<(RatchetState, Option<RatchetState>)>,
+    ratchets: Mutex<Ratchets>,
+}
+
+struct Ratchets {
+    rf_map: HashMap<[u8; RATCHET_SIZE], RatchetState>,
+    peer_map: HashMap<u128, (RatchetState, Option<RatchetState>)>,
+}
+impl Ratchets {
+    fn new() -> Self {
+        Self {
+            rf_map: HashMap::new(),
+            peer_map: HashMap::new(),
+        }
+    }
 }
 
 #[allow(unused)]
@@ -51,10 +65,10 @@ impl zssp_proto::ApplicationLayer for &TestApplication {
     type Kem = [u8; pqc_kyber::KYBER_SECRETKEYBYTES];
 
     type DiskError = ();
-    type Data = ();
+    type Data = u128;
 
     fn hello_requires_recognized_ratchet(&self) -> bool {
-        true
+        false
     }
 
     fn initiator_disallows_downgrade(&self, session: &Arc<Session<Self>>) -> bool {
@@ -62,22 +76,17 @@ impl zssp_proto::ApplicationLayer for &TestApplication {
     }
 
     fn check_accept_session(&self, remote_static_key: &Self::PublicKey, identity: &[u8]) -> (Option<(bool, Self::Data)>, bool) {
-        (Some((true, ())), true)
+        (Some((true, 1)), true)
     }
 
     fn restore_by_fingerprint(&self, ratchet_fingerprint: &[u8; RATCHET_SIZE]) -> Result<Option<RatchetState>, Self::DiskError> {
         let ratchets = self.ratchets.lock().unwrap();
-        if ratchets.0.fingerprint_eq(ratchet_fingerprint) {
-            return Ok(Some(ratchets.0.clone()));
-        }
-        if ratchets.1.as_ref().map_or(false, |rs| rs.fingerprint_eq(ratchet_fingerprint)) {
-            return Ok(ratchets.1.clone());
-        }
-        Ok(None)
+        Ok(ratchets.rf_map.get(ratchet_fingerprint).cloned())
     }
 
     fn restore_by_identity(&self, remote_static_key: &Self::PublicKey, application_data: &Self::Data) -> Result<(RatchetState, Option<RatchetState>), Self::DiskError> {
-        Ok(self.ratchets.lock().unwrap().clone())
+        let ratchets = self.ratchets.lock().unwrap();
+        Ok(ratchets.peer_map.get(application_data).cloned().unwrap_or_else(|| RatchetState::new_initial_states()))
     }
 
     fn save_ratchet_state(
@@ -91,11 +100,18 @@ impl zssp_proto::ApplicationLayer for &TestApplication {
         state_deleted2: Option<&RatchetState>,
     ) -> Result<(), Self::DiskError> {
         let mut ratchets = self.ratchets.lock().unwrap();
-        ratchets.0 = state1.clone();
-        ratchets.1 = state2.cloned();
+        ratchets.peer_map.insert(*application_data, (state1.clone(), state2.cloned()));
+
         if let Some(rs) = state_added {
+            ratchets.rf_map.insert(*rs.fingerprint().unwrap(), rs.clone());
             println!("[{}] new ratchet #{}", self.name, rs.chain_len);
         }
+        if let Some(Some(rf)) = state_deleted1.map(|rs| rs.fingerprint()) {
+            ratchets.rf_map.remove(rf);
+        }
+        if let Some(Some(rf)) = state_deleted1.map(|rs| rs.fingerprint()) {
+            ratchets.rf_map.remove(rf);
+        }
         Ok(())
     }
 
@@ -130,7 +146,7 @@ fn alice_main(
             up = false;
             alice_session = Some(
                 context
-                    .open(alice_app, |b| alice_out.send(b).is_ok(), TEST_MTU, bob_pubkey.clone(), (), Vec::new())
+                    .open(alice_app, |b| alice_out.send(b).is_ok(), TEST_MTU, bob_pubkey.clone(), 0, Vec::new())
                     .unwrap(),
             );
             println!("[alice] opening session");
@@ -194,7 +210,7 @@ fn alice_main(
             thread::sleep(Duration::from_millis(10));
         }
         // TODO: we need to more comprehensively test if re-opening the session works
-        if OsRng.next_u32() <= ((u32::MAX as f64) * 0.0000025) as u32 {
+        if OsRng.next_u32() <= ((u32::MAX as f64) * 0.000005) as u32 {
             alice_session = None;
         }
 
@@ -285,19 +301,18 @@ fn bob_main(
 fn core(time: u64, packet_success_rate: u32) {
     let run = &AtomicBool::new(true);
 
-    let shared_ratchet_state = RatchetState::new_from_otp::<Sha512>(b"password1");
     let alice_keypair = EphemeralSecret::random(&mut OsRng);
     let alice_app = TestApplication {
         time: Instant::now(),
         name: "alice",
-        ratchets: Mutex::new((shared_ratchet_state.clone(), None)),
+        ratchets: Mutex::new(Ratchets::new()),
     };
     let bob_keypair = EphemeralSecret::random(&mut OsRng);
     let bob_pubkey = bob_keypair.public_key();
     let bob_app = TestApplication {
         time: Instant::now(),
         name: "bob",
-        ratchets: Mutex::new((shared_ratchet_state, None)),
+        ratchets: Mutex::new(Ratchets::new()),
     };
 
     let (alice_out, bob_in) = mpsc::sync_channel::<Vec<u8>>(256);
diff --git a/examples/basic_test_copy.rs b/examples/basic_test_copy.rs
deleted file mode 100644
index 943303b..0000000
--- a/examples/basic_test_copy.rs
+++ /dev/null
@@ -1,363 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- *
- * (c) ZeroTier, Inc.
- * https://www.zerotier.com/
- */
-
-use std::collections::HashMap;
-use std::iter::ExactSizeIterator;
-use std::ops::Deref;
-use std::str::FromStr;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{mpsc, Arc, Mutex};
-use std::thread;
-use std::time::{Duration, Instant};
-
-use aes::Aes256;
-use aes_gcm::Aes256Gcm;
-use p384::{ecdh::EphemeralSecret, PublicKey};
-use rand_core::OsRng;
-use rand_core::RngCore;
-use sha2::Sha512;
-
-use zssp_proto::ratchet_state::RatchetState;
-use zssp_proto::{Session, Settings, RATCHET_SIZE};
-
-const TEST_MTU: usize = 1500;
-
-struct TestApplication {
-    time: Instant,
-    name: &'static str,
-    ratchets: Mutex<Ratchets>,
-}
-
-struct Ratchets {
-    rf_map: HashMap<[u8; RATCHET_SIZE], RatchetState>,
-    peer_map: HashMap<u128, (RatchetState, Option<RatchetState>)>,
-}
-impl Ratchets {
-    fn new() -> Self {
-        Self {
-            rf_map: HashMap::new(),
-            peer_map: HashMap::new(),
-        }
-    }
-}
-
-#[allow(unused)]
-impl zssp_proto::ApplicationLayer for &TestApplication {
-    const SETTINGS: Settings = Settings {
-        initial_offer_timeout: Settings::INITIAL_OFFER_TIMEOUT_MS,
-        rekey_timeout: 60 * 1000,
-        rekey_after_time: 3000,
-        rekey_time_max_jitter: 1000,
-        rekey_after_key_uses: Settings::REKEY_AFTER_KEY_USES,
-        resend_time: 250,
-        fragment_assembly_timeout: Settings::FRAGMENT_ASSEMBLY_TIMEOUT_MS,
-    };
-    type Rng = OsRng;
-    type Prp = Aes256;
-    type Aead = Aes256Gcm;
-    type Hash = Sha512;
-    type PublicKey = PublicKey;
-    type KeyPair = EphemeralSecret;
-    type Kem = [u8; pqc_kyber::KYBER_SECRETKEYBYTES];
-
-    type DiskError = ();
-    type Data = u128;
-
-    fn hello_requires_recognized_ratchet(&self) -> bool {
-        true
-    }
-
-    fn initiator_disallows_downgrade(&self, session: &Arc<Session<Self>>) -> bool {
-        true
-    }
-
-    fn check_accept_session(&self, remote_static_key: &Self::PublicKey, identity: &[u8]) -> (Option<(bool, Self::Data)>, bool) {
-        (Some((true, 0)), true)
-    }
-
-    fn restore_by_fingerprint(&self, ratchet_fingerprint: &[u8; RATCHET_SIZE]) -> Result<Option<RatchetState>, Self::DiskError> {
-        let ratchets = self.ratchets.lock().unwrap();
-        Ok(ratchets.rf_map.get(ratchet_fingerprint).cloned())
-    }
-
-    fn restore_by_identity(&self, remote_static_key: &Self::PublicKey, application_data: &Self::Data) -> Result<(RatchetState, Option<RatchetState>), Self::DiskError> {
-        let ratchets = self.ratchets.lock().unwrap();
-        Ok(ratchets.peer_map.get(application_data).cloned().unwrap_or_else(|| (RatchetState::empty(), None)))
-    }
-
-    fn save_ratchet_state(
-        &self,
-        remote_static_key: &Self::PublicKey,
-        application_data: &Self::Data,
-        state1: &RatchetState,
-        state2: Option<&RatchetState>,
-        state_added: Option<&RatchetState>,
-        state_deleted1: Option<&RatchetState>,
-        state_deleted2: Option<&RatchetState>,
-    ) -> Result<(), Self::DiskError> {
-        let mut ratchets = self.ratchets.lock().unwrap();
-        ratchets.peer_map.insert(*application_data, (state1.clone(), state2.cloned()));
-        // TODO: change the API to get rid of unwrap.
-        if let Some(rs) = state_added {
-            ratchets.rf_map.insert(*rs.fingerprint.as_ref().unwrap().deref(), rs.clone());
-            println!("[{}] new ratchet #{}", self.name, rs.chain_len);
-        }
-        if let Some(rs) = state_deleted1 {
-            ratchets.rf_map.remove(rs.fingerprint.as_ref().unwrap().deref());
-        }
-        if let Some(rs) = state_deleted2 {
-            ratchets.rf_map.remove(rs.fingerprint.as_ref().unwrap().deref());
-        }
-        Ok(())
-    }
-
-    fn time(&self) -> i64 {
-        self.time.elapsed().as_millis() as i64
-    }
-
-    fn event_log(&self, event: zssp_proto::LogEvent<Self>) {
-        println!(">[{}] {:?}", self.name, event);
-    }
-}
-
-fn alice_main(
-    run: &AtomicBool,
-    packet_success_rate: u32,
-    alice_app: &TestApplication,
-    alice_out: mpsc::SyncSender<Vec<u8>>,
-    alice_in: mpsc::Receiver<Vec<u8>>,
-    recursive_out: mpsc::SyncSender<Vec<u8>>,
-    alice_keypair: EphemeralSecret,
-    bob_pubkey: PublicKey,
-) {
-    let startup_time = std::time::Instant::now();
-    let context = zssp_proto::Context::<&TestApplication>::new(alice_keypair, OsRng);
-    let mut next_service = startup_time.elapsed().as_millis() as i64 + 500;
-    let test_data = [1u8; TEST_MTU * 10];
-    let mut up = false;
-    let mut alice_session = None;
-
-    while run.load(Ordering::Relaxed) {
-        if alice_session.is_none() {
-            up = false;
-            alice_session = Some(
-                context
-                    .open(alice_app, |b| alice_out.send(b).is_ok(), TEST_MTU, bob_pubkey.clone(), 0, Vec::new())
-                    .unwrap(),
-            );
-            println!("[alice] opening session");
-        }
-        let current_time = startup_time.elapsed().as_millis() as i64;
-        loop {
-            let pkt = alice_in.try_recv();
-            if let Ok(pkt) = pkt {
-                if OsRng.next_u32() <= packet_success_rate {
-                    use zssp_proto::result::ReceiveError::*;
-                    use zssp_proto::result::ReceiveOk::*;
-                    use zssp_proto::result::SessionEvent::*;
-                    match context.receive(
-                        alice_app,
-                        |b| alice_out.send(b).is_ok(),
-                        TEST_MTU,
-                        |_| Some((|b| alice_out.send(b).is_ok(), TEST_MTU)),
-                        &0,
-                        pkt,
-                    ) {
-                        Ok(Unassociated) => {
-                            //println!("[alice] ok");
-                        }
-                        Ok(Session(_, event)) => match event {
-                            Established => {
-                                up = true;
-                            }
-                            Data(data) => {
-                                assert!(!data.is_empty());
-                                //println!("[alice] received {}", data.len());
-                            }
-                            NewSession => panic!(),
-                            Rejected => panic!(),
-                            Control => (),
-                        },
-                        Err(e) => {
-                            println!("[alice] ERROR {:?}", e);
-                            if let ByzantineFault { unnatural, .. } = e {
-                                assert!(!unnatural)
-                            }
-                        }
-                    }
-                } else if OsRng.next_u32() | 1 > 0 {
-                    let _ = recursive_out.send(pkt);
-                }
-            } else {
-                break;
-            }
-        }
-
-        if up {
-            context
-                .send(
-                    alice_session.as_ref().unwrap(),
-                    |b| alice_out.send(b).is_ok(),
-                    TEST_MTU,
-                    test_data[..1400 + ((OsRng.next_u64() as usize) % (test_data.len() - 1400))].to_vec(),
-                )
-                .unwrap();
-        } else {
-            thread::sleep(Duration::from_millis(10));
-        }
-        // TODO: we need to more comprehensively test if re-opening the session works
-        if OsRng.next_u32() <= ((u32::MAX as f64) * 0.0000025) as u32 {
-            alice_session = None;
-        }
-
-        if current_time >= next_service {
-            next_service = current_time + context.service(alice_app, |_| Some((|b| alice_out.send(b).is_ok(), TEST_MTU)));
-        }
-    }
-}
-
-fn bob_main(
-    run: &AtomicBool,
-    packet_success_rate: u32,
-    bob_app: &TestApplication,
-    bob_out: mpsc::SyncSender<Vec<u8>>,
-    bob_in: mpsc::Receiver<Vec<u8>>,
-    recursive_out: mpsc::SyncSender<Vec<u8>>,
-    bob_keypair: EphemeralSecret,
-) {
-    let startup_time = std::time::Instant::now();
-    let context = zssp_proto::Context::<&TestApplication>::new(bob_keypair, OsRng);
-    let mut last_speed_metric = startup_time.elapsed().as_millis() as i64;
-    let mut next_service = last_speed_metric + 500;
-    let mut transferred = 0u64;
-
-    let mut bob_session = None;
-
-    while run.load(Ordering::Relaxed) {
-        let pkt = bob_in.recv_timeout(Duration::from_millis(100));
-        let current_time = startup_time.elapsed().as_millis() as i64;
-
-        if let Ok(pkt) = pkt {
-            if OsRng.next_u32() <= packet_success_rate {
-                use zssp_proto::result::ReceiveError::*;
-                use zssp_proto::result::ReceiveOk::*;
-                use zssp_proto::result::SessionEvent::*;
-                match context.receive(
-                    bob_app,
-                    |b| bob_out.send(b).is_ok(),
-                    TEST_MTU,
-                    |_| Some((|b| bob_out.send(b).is_ok(), TEST_MTU)),
-                    &0,
-                    pkt,
-                ) {
-                    Ok(Unassociated) => {}
-                    Ok(Session(s, event)) => match event {
-                        NewSession => {
-                            println!("[bob] new session, took {}s", current_time as f32 / 1000.0);
-                            let _ = bob_session.replace(s);
-                        }
-                        Data(data) => {
-                            assert!(!data.is_empty());
-                            //println!("[bob] received {}", data.len());
-                            transferred += data.len() as u64 * 2; // *2 because we are also sending this many bytes back
-                            context.send(&s, |b| bob_out.send(b).is_ok(), TEST_MTU, data).unwrap();
-                        }
-                        Established => panic!(),
-                        Rejected => panic!(),
-                        Control => (),
-                    },
-                    Err(e) => {
-                        println!("[bob] ERROR {:?}", e);
-                        if let ByzantineFault { unnatural, .. } = e {
-                            assert!(!unnatural)
-                        }
-                    }
-                }
-            } else if OsRng.next_u32() | 1 > 0 {
-                let _ = recursive_out.try_send(pkt);
-            }
-        }
-
-        let speed_metric_elapsed = current_time - last_speed_metric;
-        if speed_metric_elapsed >= 10000 {
-            last_speed_metric = current_time;
-            println!(
-                "[bob] throughput: {} MiB/sec (combined input and output)",
-                ((transferred as f64) / 1048576.0) / ((speed_metric_elapsed as f64) / 1000.0)
-            );
-            transferred = 0;
-        }
-
-        if current_time >= next_service {
-            next_service = current_time + context.service(bob_app, |_| Some((|b| bob_out.send(b).is_ok(), TEST_MTU)));
-        }
-    }
-}
-
-fn core(time: u64, packet_success_rate: u32) {
-    let run = &AtomicBool::new(true);
-
-    let alice_keypair = EphemeralSecret::random(&mut OsRng);
-    let alice_app = TestApplication {
-        time: Instant::now(),
-        name: "alice",
-        ratchets: Mutex::new(Ratchets::new()),
-    };
-    let bob_keypair = EphemeralSecret::random(&mut OsRng);
-    let bob_pubkey = bob_keypair.public_key();
-    let bob_app = TestApplication {
-        time: Instant::now(),
-        name: "bob",
-        ratchets: Mutex::new(Ratchets::new()),
-    };
-
-    let (alice_out, bob_in) = mpsc::sync_channel::<Vec<u8>>(256);
-    let (bob_out, alice_in) = mpsc::sync_channel::<Vec<u8>>(256);
-
-    thread::scope(|ts| {
-        {
-            let alice_out = alice_out.clone();
-            let bob_out = bob_out.clone();
-            ts.spawn(move || {
-                alice_main(
-                    run,
-                    packet_success_rate,
-                    &alice_app,
-                    alice_out,
-                    alice_in,
-                    bob_out,
-                    alice_keypair,
-                    bob_pubkey,
-                )
-            });
-        }
-        ts.spawn(move || bob_main(run, packet_success_rate, &bob_app, bob_out, bob_in, alice_out, bob_keypair));
-
-        thread::sleep(Duration::from_secs(time));
-
-        run.store(false, Ordering::SeqCst);
-        println!("finished");
-    });
-}
-
-fn main() {
-    let args = std::env::args();
-    let packet_success_rate = if args.len() <= 1 {
-        let default_success_rate = 1.0;
-        ((u32::MAX as f64) * default_success_rate) as u32
-    } else {
-        ((u32::MAX as f64) * f64::from_str(args.last().unwrap().as_str()).unwrap()) as u32
-    };
-
-    core(60 * 60, packet_success_rate)
-}
-
-#[test]
-fn test_main() {
-    core(2, u32::MAX / 2)
-}
diff --git a/src/applicationlayer.rs b/src/applicationlayer.rs
index 2d0d78a..86f7245 100644
--- a/src/applicationlayer.rs
+++ b/src/applicationlayer.rs
@@ -166,8 +166,15 @@ pub trait ApplicationLayer: Sized {
     /// This function will be called whenever Alice attempts to open a session, or Bob attempts
     /// to verify Alice's identity.
     fn restore_by_identity(&self, remote_static_key: &Self::PublicKey, application_data: &Self::Data) -> Result<(RatchetState, Option<RatchetState>), Self::DiskError>;
-    /// Atomically save the given `new_ratchet_states` to persistent storage.
-    /// `pre_ratchet_states` contains what should be the previous contents of persistent storage.
+    /// Atomically save `current_state1` and `current_state2` so that them and only them can be
+    /// restored with `restore_by_identity` and `restore_by_fingerprint` through a system restart.
+    /// Theses should overwrite the previous ratchet states 1 and 2 saved to storage.
+    ///
+    /// `state_added` will be equal to the brand new ratchet state that was added in this update,
+    /// or `None` if there is not a new ratchet state this update. `state_deleted1` and
+    /// `state_deleted2` will be equal to any ratchet states that are to be deleted and overwritten
+    /// as a result of this update, or `None` if there is not one to be deleted.
+    /// `state_added` will always have a non-empty (`Some()`) ratchet fingerprint.
     ///
     /// If this returns `Err(IoError)`, the packet which triggered this function to be called will be
     /// dropped, and no session state will be mutated, preserving synchronization. The remote peer
@@ -186,8 +193,8 @@ pub trait ApplicationLayer: Sized {
         &self,
         remote_static_key: &Self::PublicKey,
         application_data: &Self::Data,
-        state1: &RatchetState,
-        state2: Option<&RatchetState>,
+        current_state1: &RatchetState,
+        current_state2: Option<&RatchetState>,
         state_added: Option<&RatchetState>,
         state_deleted1: Option<&RatchetState>,
         state_deleted2: Option<&RatchetState>,
diff --git a/src/ratchet_state.rs b/src/ratchet_state.rs
index 8c26086..ef73229 100644
--- a/src/ratchet_state.rs
+++ b/src/ratchet_state.rs
@@ -24,10 +24,12 @@ impl RatchetState {
     pub fn new(key: Zeroizing<[u8; RATCHET_SIZE]>, fingerprint: Zeroizing<[u8; RATCHET_SIZE]>, chain_len: u64) -> Self {
         RatchetState { key, fingerprint: Some(fingerprint), chain_len }
     }
+    pub fn new_raw(key: [u8; RATCHET_SIZE], fingerprint: [u8; RATCHET_SIZE], chain_len: u64) -> Self {
+        RatchetState { key: Zeroizing::new(key), fingerprint: Some(Zeroizing::new(fingerprint)), chain_len }
+    }
     pub fn empty() -> Self {
         RatchetState { key: Zeroizing::new([0u8; RATCHET_SIZE]), fingerprint: None, chain_len: 0 }
     }
-
     pub fn new_from_otp<Hmac: HashSha512>(otp: &[u8]) -> RatchetState {
         let mut buffer = Vec::new();
         buffer.push(1);
@@ -43,10 +45,27 @@ impl RatchetState {
             1,
         )
     }
+
+    pub fn new_initial_states() -> (RatchetState, Option<RatchetState>) {
+        (
+            RatchetState::empty(),
+            None
+        )
+    }
+    pub fn new_otp_states<Hmac: HashSha512>(otp: &[u8]) -> (RatchetState, Option<RatchetState>) {
+        (
+            RatchetState::new_from_otp::<Hmac>(otp),
+            None
+        )
+    }
+
     pub fn is_empty(&self) -> bool {
         self.fingerprint.is_none()
     }
     pub fn fingerprint_eq(&self, rf: &[u8; RATCHET_SIZE]) -> bool {
         self.fingerprint.as_ref().map_or(false, |rf0| secure_eq(rf0, rf))
     }
+    pub fn fingerprint(&self) -> Option<&[u8; RATCHET_SIZE]> {
+        self.fingerprint.as_deref()
+    }
 }
diff --git a/src/zeta.rs b/src/zeta.rs
index 0537945..c6d6019 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -232,10 +232,10 @@ fn create_a1_state<App: ApplicationLayer>(
     noise.encrypt_and_hash_in_place(to_nonce(PACKET_TYPE_HANDSHAKE_HELLO, 0), i, &mut x1);
     // Process message pattern 1 payload.
     let i = x1.len();
-    if let Some(rf) = ratchet_state1.fingerprint.as_ref() {
+    if let Some(rf) = ratchet_state1.fingerprint() {
         x1.extend(rf.as_ref());
     }
-    if let Some(Some(rf)) = ratchet_state2.map(|rs| rs.fingerprint.as_ref()) {
+    if let Some(Some(rf)) = ratchet_state2.map(|rs| rs.fingerprint()) {
         x1.extend(rf.as_ref());
     }
     noise.encrypt_and_hash_in_place(to_nonce(PACKET_TYPE_HANDSHAKE_HELLO, 1), i, &mut x1);
@@ -640,7 +640,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
         match result {
             Ok((ratchet_state1, ratchet_state2)) => {
                 if (&zeta.ratchet_state != &ratchet_state1) & (Some(&zeta.ratchet_state) != ratchet_state2.as_ref()) {
-                    if !responder_disallows_downgrade && zeta.ratchet_state.fingerprint.is_none() {
+                    if !responder_disallows_downgrade && zeta.ratchet_state.fingerprint().is_none() {
                         // TODO: add some kind of warning callback or signal.
                     } else {
                         if !responder_silently_rejects {
@@ -652,7 +652,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
 
                 let (rk, rf) = noise.get_ask(LABEL_RATCHET_STATE);
                 // We must make sure the ratchet key is saved before we transition.
-                let new_ratchet_state = RatchetState{ key: rk, fingerprint: Some(rf), chain_len: zeta.ratchet_state.chain_len + 1,};
+                let new_ratchet_state = RatchetState::new(rk, rf, zeta.ratchet_state.chain_len + 1);
                 let result = app.save_ratchet_state(
                     &s_remote,
                     &application_data,

From 5c92d541470b7c709c9aa5506da0b8e3f24d5367 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Thu, 3 Aug 2023 11:26:08 -0400
Subject: [PATCH 04/37] added docs

---
 src/applicationlayer.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/applicationlayer.rs b/src/applicationlayer.rs
index 86f7245..133297a 100644
--- a/src/applicationlayer.rs
+++ b/src/applicationlayer.rs
@@ -174,7 +174,8 @@ pub trait ApplicationLayer: Sized {
     /// or `None` if there is not a new ratchet state this update. `state_deleted1` and
     /// `state_deleted2` will be equal to any ratchet states that are to be deleted and overwritten
     /// as a result of this update, or `None` if there is not one to be deleted.
-    /// `state_added` will always have a non-empty (`Some()`) ratchet fingerprint.
+    /// `state_added` will always have a non-empty (`Some()`) ratchet fingerprint, and it will
+    /// always be equal to `current_state1`.
     ///
     /// If this returns `Err(IoError)`, the packet which triggered this function to be called will be
     /// dropped, and no session state will be mutated, preserving synchronization. The remote peer

From 14db9cd756829011ac290f8cbd1e6564b5e97704 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Thu, 3 Aug 2023 12:33:24 -0400
Subject: [PATCH 05/37] added docs

---
 src/applicationlayer.rs | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/applicationlayer.rs b/src/applicationlayer.rs
index 133297a..a9dae59 100644
--- a/src/applicationlayer.rs
+++ b/src/applicationlayer.rs
@@ -162,9 +162,17 @@ pub trait ApplicationLayer: Sized {
     /// to the empty ratchet key, restarting the ratchet chain.
     /// If `RatchetAction::FailAuthentication` is returned Alice's connection will be silently dropped.
     fn restore_by_fingerprint(&self, ratchet_fingerprint: &[u8; RATCHET_SIZE]) -> Result<Option<RatchetState>, Self::DiskError>;
-    /// Lookup a specific ratchet state based on the identity of the peer being communicated with.
+    /// Lookup the specific ratchet states based on the identity of the peer being communicated with.
     /// This function will be called whenever Alice attempts to open a session, or Bob attempts
     /// to verify Alice's identity.
+    ///
+    /// If the peer's ratchet states could not be could, this function should return either
+    /// `RatchetState::new_initial_states()`, or `RatchetState::new_otp_states(...)` if a one time
+    /// password has been shared with this peer.
+    ///
+    /// This function is not responsible for deciding whether or not to connect to this remote peer.
+    /// Filtering peers should be done by the caller to `Context::open` as well as by the
+    /// function `ApplicationLayer::check_accept_session`.
     fn restore_by_identity(&self, remote_static_key: &Self::PublicKey, application_data: &Self::Data) -> Result<(RatchetState, Option<RatchetState>), Self::DiskError>;
     /// Atomically save `current_state1` and `current_state2` so that them and only them can be
     /// restored with `restore_by_identity` and `restore_by_fingerprint` through a system restart.

From fc1e86778ce49ce651e52d1c3eef4129f919cedb Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Thu, 3 Aug 2023 12:46:23 -0400
Subject: [PATCH 06/37] improved docs

---
 src/applicationlayer.rs | 9 ++++++---
 src/zeta.rs             | 4 ++--
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/src/applicationlayer.rs b/src/applicationlayer.rs
index a9dae59..2e1e113 100644
--- a/src/applicationlayer.rs
+++ b/src/applicationlayer.rs
@@ -166,9 +166,12 @@ pub trait ApplicationLayer: Sized {
     /// This function will be called whenever Alice attempts to open a session, or Bob attempts
     /// to verify Alice's identity.
     ///
-    /// If the peer's ratchet states could not be could, this function should return either
-    /// `RatchetState::new_initial_states()`, or `RatchetState::new_otp_states(...)` if a one time
-    /// password has been shared with this peer.
+    /// If the peer's ratchet states could not be could, this function should return
+    /// `RatchetState::new_initial_states()`.
+    ///
+    /// If a one-time-password has been pre-shared with this peer, `RatchetState::new_otp_states(...)`
+    /// should be pre-saved to the storage backend as if it is a normal ratchet state.
+    /// This is to ensure it can both be restored and eventually deleted when it is used.
     ///
     /// This function is not responsible for deciding whether or not to connect to this remote peer.
     /// Filtering peers should be done by the caller to `Context::open` as well as by the
diff --git a/src/zeta.rs b/src/zeta.rs
index c6d6019..3542103 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -524,7 +524,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
             noise.encrypt_and_hash_in_place(to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 1), i, &mut x3);
             // Process message pattern 3 se token.
             noise.mix_dh(&ctx.s_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
-            // Process message pattern 3 payload token.
+            // Process message pattern 3 payload.
             let i = x3.len();
             x3.extend(identity);
             noise.encrypt_and_hash_in_place(to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 0), i, &mut x3);
@@ -980,7 +980,7 @@ fn timeout_trans<App: ApplicationLayer>(
                 zeta.expire();
                 return;
             }
-            // Process message pattern 1 payload token.
+            // Process message pattern 1 payload.
             let i = k1.len();
             k1.extend(&new_kid_recv.get().to_be_bytes());
             noise.encrypt_and_hash_in_place(to_nonce(PACKET_TYPE_REKEY_INIT, 0), i, &mut k1);

From 76eb9636ea261fa5b6092e409a03467a1e5aaf93 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Thu, 3 Aug 2023 12:53:16 -0400
Subject: [PATCH 07/37] realized vec is zeroizing

---
 src/symmetric_state.rs | 20 ++++++--------------
 1 file changed, 6 insertions(+), 14 deletions(-)

diff --git a/src/symmetric_state.rs b/src/symmetric_state.rs
index 946e53a..3c49ca6 100644
--- a/src/symmetric_state.rs
+++ b/src/symmetric_state.rs
@@ -25,13 +25,6 @@ impl<App: ApplicationLayer> Clone for SymmetricState<App> {
     }
 }
 
-const KBKDF_LABEL_START: usize = 1;
-const KBKDF_LABEL_END: usize = KBKDF_LABEL_START + 4;
-const KBKDF_CONTEXT_START: usize = KBKDF_LABEL_END + 1;
-const KBKDF_LENGTH_START: usize = KBKDF_CONTEXT_START + HASHLEN;
-const KBKDF_INPUT_SIZE: usize = KBKDF_LENGTH_START + 2;
-const HASHLEN_BITS: usize = HASHLEN * 8;
-
 impl<App: ApplicationLayer> SymmetricState<App> {
     /// HMAC-SHA512 key derivation based on KBKDF Counter Mode:
     /// https://csrc.nist.gov/publications/detail/sp/800-108/rev-1/final.
@@ -53,13 +46,12 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         output2: Option<&mut [u8; HASHLEN]>,
         output3: Option<&mut [u8; HASHLEN]>,
     ) {
-        let mut buffer = Zeroizing::new([0u8; KBKDF_INPUT_SIZE]);
-        let buffer: &mut [u8] = buffer.as_mut();
-        buffer[0] = 1;
-        buffer[KBKDF_LABEL_START..KBKDF_LABEL_END].copy_from_slice(label);
-        buffer[KBKDF_LABEL_END] = 0x00;
-        buffer[KBKDF_CONTEXT_START..KBKDF_LENGTH_START].copy_from_slice(self.ck.as_ref());
-        buffer[KBKDF_LENGTH_START..].copy_from_slice(&(num_outputs * HASHLEN_BITS as u16).to_be_bytes());
+        let mut buffer = Zeroizing::new(Vec::new());
+        buffer.push(1);
+        buffer.extend(label);
+        buffer.push(0x00);
+        buffer.extend(self.ck.as_ref());
+        buffer.extend(&(num_outputs * 8 * HASHLEN as u16).to_be_bytes());
 
         debug_assert!(num_outputs >= 1);
         *output1 = App::Hash::hmac(input_key_material, &buffer);

From 5070a638ed215ebf60aef38aa67ccf812ab4e239 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Thu, 3 Aug 2023 12:59:01 -0400
Subject: [PATCH 08/37] cargo fmt

---
 examples/basic_test.rs  | 17 +++++++++++------
 src/applicationlayer.rs |  6 +++++-
 src/ratchet_state.rs    | 35 +++++++++++++++++++----------------
 src/zeta.rs             |  9 ++++++++-
 4 files changed, 43 insertions(+), 24 deletions(-)

diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index 8a031a1..2c0ef5c 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -38,10 +38,7 @@ struct Ratchets {
 }
 impl Ratchets {
     fn new() -> Self {
-        Self {
-            rf_map: HashMap::new(),
-            peer_map: HashMap::new(),
-        }
+        Self { rf_map: HashMap::new(), peer_map: HashMap::new() }
     }
 }
 
@@ -84,9 +81,17 @@ impl zssp_proto::ApplicationLayer for &TestApplication {
         Ok(ratchets.rf_map.get(ratchet_fingerprint).cloned())
     }
 
-    fn restore_by_identity(&self, remote_static_key: &Self::PublicKey, application_data: &Self::Data) -> Result<(RatchetState, Option<RatchetState>), Self::DiskError> {
+    fn restore_by_identity(
+        &self,
+        remote_static_key: &Self::PublicKey,
+        application_data: &Self::Data,
+    ) -> Result<(RatchetState, Option<RatchetState>), Self::DiskError> {
         let ratchets = self.ratchets.lock().unwrap();
-        Ok(ratchets.peer_map.get(application_data).cloned().unwrap_or_else(|| RatchetState::new_initial_states()))
+        Ok(ratchets
+            .peer_map
+            .get(application_data)
+            .cloned()
+            .unwrap_or_else(|| RatchetState::new_initial_states()))
     }
 
     fn save_ratchet_state(
diff --git a/src/applicationlayer.rs b/src/applicationlayer.rs
index 2e1e113..2f8501d 100644
--- a/src/applicationlayer.rs
+++ b/src/applicationlayer.rs
@@ -176,7 +176,11 @@ pub trait ApplicationLayer: Sized {
     /// This function is not responsible for deciding whether or not to connect to this remote peer.
     /// Filtering peers should be done by the caller to `Context::open` as well as by the
     /// function `ApplicationLayer::check_accept_session`.
-    fn restore_by_identity(&self, remote_static_key: &Self::PublicKey, application_data: &Self::Data) -> Result<(RatchetState, Option<RatchetState>), Self::DiskError>;
+    fn restore_by_identity(
+        &self,
+        remote_static_key: &Self::PublicKey,
+        application_data: &Self::Data,
+    ) -> Result<(RatchetState, Option<RatchetState>), Self::DiskError>;
     /// Atomically save `current_state1` and `current_state2` so that them and only them can be
     /// restored with `restore_by_identity` and `restore_by_fingerprint` through a system restart.
     /// Theses should overwrite the previous ratchet states 1 and 2 saved to storage.
diff --git a/src/ratchet_state.rs b/src/ratchet_state.rs
index ef73229..22302ed 100644
--- a/src/ratchet_state.rs
+++ b/src/ratchet_state.rs
@@ -12,12 +12,13 @@ pub struct RatchetState {
 }
 impl PartialEq for RatchetState {
     fn eq(&self, other: &Self) -> bool {
-        secure_eq(&self.key, &other.key) & (self.chain_len == other.chain_len) &
-        match (self.fingerprint.as_ref(), other.fingerprint.as_ref()) {
-            (Some(rf1), Some(rf2)) => secure_eq(rf1, rf2),
-            (None, None) => true,
-            _ => false,
-        }
+        secure_eq(&self.key, &other.key)
+            & (self.chain_len == other.chain_len)
+            & match (self.fingerprint.as_ref(), other.fingerprint.as_ref()) {
+                (Some(rf1), Some(rf2)) => secure_eq(rf1, rf2),
+                (None, None) => true,
+                _ => false,
+            }
     }
 }
 impl RatchetState {
@@ -25,10 +26,18 @@ impl RatchetState {
         RatchetState { key, fingerprint: Some(fingerprint), chain_len }
     }
     pub fn new_raw(key: [u8; RATCHET_SIZE], fingerprint: [u8; RATCHET_SIZE], chain_len: u64) -> Self {
-        RatchetState { key: Zeroizing::new(key), fingerprint: Some(Zeroizing::new(fingerprint)), chain_len }
+        RatchetState {
+            key: Zeroizing::new(key),
+            fingerprint: Some(Zeroizing::new(fingerprint)),
+            chain_len,
+        }
     }
     pub fn empty() -> Self {
-        RatchetState { key: Zeroizing::new([0u8; RATCHET_SIZE]), fingerprint: None, chain_len: 0 }
+        RatchetState {
+            key: Zeroizing::new([0u8; RATCHET_SIZE]),
+            fingerprint: None,
+            chain_len: 0,
+        }
     }
     pub fn new_from_otp<Hmac: HashSha512>(otp: &[u8]) -> RatchetState {
         let mut buffer = Vec::new();
@@ -47,16 +56,10 @@ impl RatchetState {
     }
 
     pub fn new_initial_states() -> (RatchetState, Option<RatchetState>) {
-        (
-            RatchetState::empty(),
-            None
-        )
+        (RatchetState::empty(), None)
     }
     pub fn new_otp_states<Hmac: HashSha512>(otp: &[u8]) -> (RatchetState, Option<RatchetState>) {
-        (
-            RatchetState::new_from_otp::<Hmac>(otp),
-            None
-        )
+        (RatchetState::new_from_otp::<Hmac>(otp), None)
     }
 
     pub fn is_empty(&self) -> bool {
diff --git a/src/zeta.rs b/src/zeta.rs
index 3542103..94bc566 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -937,7 +937,14 @@ fn timeout_trans<App: ApplicationLayer>(
             }
             let new_kid_recv = remap(session, &zeta, &ctx.rng, &ctx.session_map);
 
-            if let Some(a1) = create_a1_state(&ctx.rng, &zeta.s_remote, new_kid_recv, &zeta.ratchet_state1, zeta.ratchet_state2.as_ref(), identity.clone()) {
+            if let Some(a1) = create_a1_state(
+                &ctx.rng,
+                &zeta.s_remote,
+                new_kid_recv,
+                &zeta.ratchet_state1,
+                zeta.ratchet_state2.as_ref(),
+                identity.clone(),
+            ) {
                 let (hk_recv, hk_send) = a1.noise.get_ask(LABEL_HEADER_KEY);
                 let packet = a1.packet.clone();
 

From 988ba4723b09f44ff76187cd7782c4472819e514 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Thu, 3 Aug 2023 14:10:36 -0400
Subject: [PATCH 09/37] fixed accidental secret leaking

---
 examples/basic_test.rs       | 3 ++-
 src/crypto_impl/kyber1024.rs | 7 ++++---
 src/ratchet_state.rs         | 2 +-
 3 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index 2c0ef5c..89b8624 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -21,6 +21,7 @@ use rand_core::OsRng;
 use rand_core::RngCore;
 use sha2::Sha512;
 
+use zeroize::Zeroizing;
 use zssp_proto::ratchet_state::RatchetState;
 use zssp_proto::{Session, Settings, RATCHET_SIZE};
 
@@ -59,7 +60,7 @@ impl zssp_proto::ApplicationLayer for &TestApplication {
     type Hash = Sha512;
     type PublicKey = PublicKey;
     type KeyPair = EphemeralSecret;
-    type Kem = [u8; pqc_kyber::KYBER_SECRETKEYBYTES];
+    type Kem = Zeroizing<[u8; pqc_kyber::KYBER_SECRETKEYBYTES]>;
 
     type DiskError = ();
     type Data = u128;
diff --git a/src/crypto_impl/kyber1024.rs b/src/crypto_impl/kyber1024.rs
index a17ba38..8cd11e2 100644
--- a/src/crypto_impl/kyber1024.rs
+++ b/src/crypto_impl/kyber1024.rs
@@ -1,11 +1,12 @@
 use rand_core::{CryptoRng, RngCore};
+use zeroize::Zeroizing;
 
 use crate::crypto::*;
 
-impl<Rng: RngCore + CryptoRng> PrivateKeyKyber1024<Rng> for [u8; pqc_kyber::KYBER_SECRETKEYBYTES] {
+impl<Rng: RngCore + CryptoRng> PrivateKeyKyber1024<Rng> for Zeroizing<[u8; pqc_kyber::KYBER_SECRETKEYBYTES]> {
     fn generate(rng: &mut Rng) -> (Self, [u8; KYBER_PUBLIC_KEY_SIZE]) {
         let keypair = pqc_kyber::keypair(rng);
-        (keypair.secret, keypair.public)
+        (Zeroizing::new(keypair.secret), keypair.public)
     }
 
     fn encapsulate(rng: &mut Rng, public_key: &[u8; KYBER_PUBLIC_KEY_SIZE]) -> Option<([u8; KYBER_CIPHERTEXT_SIZE], [u8; KYBER_PLAINTEXT_SIZE])> {
@@ -13,6 +14,6 @@ impl<Rng: RngCore + CryptoRng> PrivateKeyKyber1024<Rng> for [u8; pqc_kyber::KYBE
     }
 
     fn decapsulate(&self, ciphertext: &[u8; KYBER_CIPHERTEXT_SIZE]) -> Option<[u8; KYBER_PLAINTEXT_SIZE]> {
-        pqc_kyber::decapsulate(ciphertext, self).ok()
+        pqc_kyber::decapsulate(ciphertext, self.as_ref()).ok()
     }
 }
diff --git a/src/ratchet_state.rs b/src/ratchet_state.rs
index 22302ed..829b6f3 100644
--- a/src/ratchet_state.rs
+++ b/src/ratchet_state.rs
@@ -43,7 +43,7 @@ impl RatchetState {
         let mut buffer = Vec::new();
         buffer.push(1);
         buffer.extend(LABEL_OTP_TO_RATCHET);
-        buffer.push(0);
+        buffer.push(0x00);
         buffer.extend((2u16 * 512u16).to_be_bytes());
         let r1 = Hmac::hmac(otp, &buffer);
         buffer[0] = 2;

From c6726babdf59fa8566cdeb4b748195f6bc1490b6 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Thu, 3 Aug 2023 14:12:59 -0400
Subject: [PATCH 10/37] added typedef

---
 examples/basic_test.rs       | 3 ++-
 src/crypto_impl/kyber1024.rs | 4 +++-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index 89b8624..32cf16b 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -22,6 +22,7 @@ use rand_core::RngCore;
 use sha2::Sha512;
 
 use zeroize::Zeroizing;
+use zssp_proto::crypto_impl::kyber1024::PqcKyberSecretKey;
 use zssp_proto::ratchet_state::RatchetState;
 use zssp_proto::{Session, Settings, RATCHET_SIZE};
 
@@ -60,7 +61,7 @@ impl zssp_proto::ApplicationLayer for &TestApplication {
     type Hash = Sha512;
     type PublicKey = PublicKey;
     type KeyPair = EphemeralSecret;
-    type Kem = Zeroizing<[u8; pqc_kyber::KYBER_SECRETKEYBYTES]>;
+    type Kem = PqcKyberSecretKey;
 
     type DiskError = ();
     type Data = u128;
diff --git a/src/crypto_impl/kyber1024.rs b/src/crypto_impl/kyber1024.rs
index 8cd11e2..7e6ce5d 100644
--- a/src/crypto_impl/kyber1024.rs
+++ b/src/crypto_impl/kyber1024.rs
@@ -3,7 +3,9 @@ use zeroize::Zeroizing;
 
 use crate::crypto::*;
 
-impl<Rng: RngCore + CryptoRng> PrivateKeyKyber1024<Rng> for Zeroizing<[u8; pqc_kyber::KYBER_SECRETKEYBYTES]> {
+pub type PqcKyberSecretKey = Zeroizing<[u8; pqc_kyber::KYBER_SECRETKEYBYTES]>;
+
+impl<Rng: RngCore + CryptoRng> PrivateKeyKyber1024<Rng> for PqcKyberSecretKey {
     fn generate(rng: &mut Rng) -> (Self, [u8; KYBER_PUBLIC_KEY_SIZE]) {
         let keypair = pqc_kyber::keypair(rng);
         (Zeroizing::new(keypair.secret), keypair.public)

From cf1804e65a0a17c02e3cd1671b3e63b8e45f66d6 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Thu, 3 Aug 2023 15:07:58 -0400
Subject: [PATCH 11/37] added a lot of docs

---
 examples/basic_test.rs       |  5 ++---
 src/applicationlayer.rs      | 41 ++++++++++++++++++++++++++++++------
 src/crypto/aes.rs            | 17 ++++++++++++---
 src/crypto/kyber1024.rs      | 24 +++++++++++++++++++--
 src/crypto/p384.rs           | 21 ++++++++++--------
 src/crypto/sha512.rs         | 14 ++++++------
 src/crypto_impl/kyber1024.rs |  2 ++
 src/crypto_impl/mod.rs       | 10 +++++----
 src/lib.rs                   | 21 +++++++++++++++---
 9 files changed, 118 insertions(+), 37 deletions(-)

diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index 32cf16b..31512ed 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -21,9 +21,8 @@ use rand_core::OsRng;
 use rand_core::RngCore;
 use sha2::Sha512;
 
-use zeroize::Zeroizing;
-use zssp_proto::crypto_impl::kyber1024::PqcKyberSecretKey;
-use zssp_proto::ratchet_state::RatchetState;
+use zssp_proto::crypto_impl::PqcKyberSecretKey;
+use zssp_proto::RatchetState;
 use zssp_proto::{Session, Settings, RATCHET_SIZE};
 
 const TEST_MTU: usize = 1500;
diff --git a/src/applicationlayer.rs b/src/applicationlayer.rs
index 2f8501d..7912450 100644
--- a/src/applicationlayer.rs
+++ b/src/applicationlayer.rs
@@ -92,22 +92,49 @@ pub trait ApplicationLayer: Sized {
     /// the protocol will tend to default to the smaller constants.
     const SETTINGS: Settings = Settings::new_ms();
 
+    /// The random number generator that ZSSP should use.
+    ///
+    /// FIPS compliance requires use of a FIPS certified implementation.
     type Rng: CryptoRng + RngCore;
-
+    /// The implementation of AES-256 that ZSSP should use.
+    /// We provide an optional implementation for this trait using the `aes` crate.
+    ///
+    /// FIPS compliance requires use of a FIPS certified implementation.
     type Prp: PrpAes256;
-
+    /// The implementation of AES-GCM-256 that ZSSP should use.
+    /// The efficiency and security of ZSSP is very closely tied to the efficiency and security of
+    /// this implementation.
+    /// We provide an optional implementation for this trait using the `aes-gcm` crate.
+    ///
+    /// FIPS compliance requires a FIPS certified implementation.
     type Aead: AeadAesGcm;
-
+    /// The implementation of SHA-512 that ZSSP should use.
+    /// We provide an optional implementation for this trait using the `sha2` crate.
+    ///
+    /// FIPS compliance requires use of a FIPS certified implementation.
     type Hash: HashSha512;
-
+    /// The implementation of P-384 public keys that ZSSP should use.
+    /// We provide an optional implementation for this trait using the `p384` crate.
+    ///
+    /// FIPS compliance requires a FIPS certified implementation.
     type PublicKey: PublicKeyP384;
+    /// The implementation of P-384 private keys that ZSSP should use.
+    /// We provide an optional implementation for this trait using the `p384` crate.
+    ///
+    /// FIPS compliance requires use of a FIPS certified implementation.
     type KeyPair: KeyPairP384<Self::Rng, PublicKey = Self::PublicKey>;
+    /// The implementation of Kyber1024 that ZSSP should use.
+    /// We provide an optional implementation for this trait using the `pqc_kyber` crate.
+    ///
+    /// No implementation of Kyber1024 can be FIPS certified, but this is not required
+    /// for ZSSP to achieve FIPS compliance.
     type Kem: PrivateKeyKyber1024<Self::Rng>;
 
+    /// A user-defined error returned when the `ApplicationLayer` fails to access persistent storage
+    /// for a peer's ratchet states.
     type DiskError: std::fmt::Debug;
 
-    /// Type for arbitrary opaque object for use by the application that is attached to
-    /// each session.
+    /// An arbitrary opaque object for use by the application that is attached to each session.
     type Data;
 
     /// Should return the current time in milliseconds. Does not have to be monotonic, nor synced
@@ -220,5 +247,5 @@ pub trait ApplicationLayer: Sized {
     /// These are provided for debugging, logging or metrics purposes, and must be used for
     /// nothing else. Do not base protocol-level decisions upon the events passed to this function.
     #[cfg(feature = "logging")]
-    fn event_log(&self, event: LogEvent<Self>);
+    fn event_log(&self, event: LogEvent<'_, Self>);
 }
diff --git a/src/crypto/aes.rs b/src/crypto/aes.rs
index 5e8f41a..d5f1d56 100644
--- a/src/crypto/aes.rs
+++ b/src/crypto/aes.rs
@@ -1,24 +1,35 @@
+/// The size of an AES block, which is 16 bytes, or 128 bits.
 pub const AES_256_BLOCK_SIZE: usize = 16;
+/// The size of an AES-256 key, which is 32 bytes, or 256 bits.
 pub const AES_256_KEY_SIZE: usize = 32;
+/// The size of an AES-GCM authentication tag, which is 16 bytes, or 128 bits.
+/// Some implementations of AES-GCM allow use of smaller tags, but ZSSP will only accept 16 byte tags.
 pub const AES_GCM_TAG_SIZE: usize = 16;
+/// The size of an AES-GCM IV, or nonce, which is 12 bytes, or 96 bits.
 pub const AES_GCM_IV_SIZE: usize = 12;
 
 /// A trait for encrypting individual blocks of plaintext using AES-256.
 /// It is used for header authentication, for which we have a standard model proof that our
 /// algorithm is secure.
 pub trait PrpAes256 {
-    /// Decrypt the given `block` of plaintext directly using the AES block cipher
+    /// Encrypt the given `block` of plaintext directly using the AES block cipher
     /// (i.e. AES-256 in zero-padding ECB mode).
-    /// The ciphertext should be written directly back out to `block`.
+    /// The ciphertext should be written directly back to `block`.
     fn encrypt_in_place(key: &[u8; AES_256_KEY_SIZE], block: &mut [u8; AES_256_BLOCK_SIZE]);
     /// Decrypt the given `block` of ciphertext directly using the AES 256 block cipher
     /// (i.e. AES-256 in zero-padding ECB mode).
-    /// The plaintext should be written directly back out to `block`.
+    /// The plaintext should be written directly back to `block`.
     fn decrypt_in_place(key: &[u8; AES_256_KEY_SIZE], block: &mut [u8; AES_256_BLOCK_SIZE]);
 }
 
+/// A trait accessing AES-GCM-256 encryption and decryption as a set of pure-functions.
+/// These should be trivial to implement for most implementations of AES-GCM.
 pub trait AeadAesGcm {
+    /// Encrypt the given `buffer` of plaintext using AES-GCM-256, with the given `key`, `iv` and `aad`.
+    /// The ciphertext should be written directly back to `buffer`, and the GCM tag should be returned.
     fn encrypt_in_place(key: &[u8; AES_256_KEY_SIZE], iv: [u8; AES_GCM_IV_SIZE], aad: Option<&[u8]>, buffer: &mut [u8]) -> [u8; AES_GCM_TAG_SIZE];
+    /// Decrypt the given `buffer` of ciphertext using AES-GCM-256, with the given `key`, `iv` and `aad`.
+    /// The ciphertext should be written directly back to `buffer`, and the GCM tag should be returned.
     fn decrypt_in_place(
         key: &[u8; AES_256_KEY_SIZE],
         iv: [u8; AES_GCM_IV_SIZE],
diff --git a/src/crypto/kyber1024.rs b/src/crypto/kyber1024.rs
index 1d6bc82..a844ff9 100644
--- a/src/crypto/kyber1024.rs
+++ b/src/crypto/kyber1024.rs
@@ -1,14 +1,34 @@
 use rand_core::{CryptoRng, RngCore};
 
+/// The size of a Kyber1024 public key, which is 1568 bytes.
 pub const KYBER_PUBLIC_KEY_SIZE: usize = 1568;
+/// The size of a Kyber1024 KEM ciphertext, which is 1568 bytes.
 pub const KYBER_CIPHERTEXT_SIZE: usize = 1568;
+/// The size of a Kyber1024 KEM plaintext, which is 32 bytes.
 pub const KYBER_PLAINTEXT_SIZE: usize = 32;
 
 /// Instances must securely delete the private key when dropped.
 pub trait PrivateKeyKyber1024<Rng: RngCore + CryptoRng>: Sized + Send + Sync {
+    /// Generate a Kyber1024 private key and public key pair, and return the raw bytes of the public
+    /// key.
+    /// The private key will be temporarily held in memory but the public key will be immediately
+    /// sent to the remote peer.
+    ///
+    /// This function may use the provided RNG or its own, so long as the output is cryptographically random.
     fn generate(rng: &mut Rng) -> (Self, [u8; KYBER_PUBLIC_KEY_SIZE]);
-
+    /// Generate a Kyber1024 key encapsulation based on the given public key, and return the
+    /// raw bytes of the generated ciphertext and plaintext. The ciphertext is immediately sent to
+    /// the remote peer and the plaintext is immediately hashed, both are quickly deleted.
+    ///
+    /// This function may use the provided RNG or its own, so long as the output is cryptographically random.
+    ///
+    /// This must return `None` if the given public_key is invalid in any way according to the
+    /// Kyber1024 spec.
     fn encapsulate(rng: &mut Rng, public_key: &[u8; KYBER_PUBLIC_KEY_SIZE]) -> Option<([u8; KYBER_CIPHERTEXT_SIZE], [u8; KYBER_PLAINTEXT_SIZE])>;
-
+    /// Decapsulate a Kyber1024 ciphertext received from the remote peer, retreiving
+    /// the raw bytes of the original plaintext. This plaintext is immediately hashed and deleted.
+    ///
+    /// This must return `None` if the given ciphertext is invalid in any way according to the
+    /// Kyber1024 spec.
     fn decapsulate(&self, ciphertext: &[u8; KYBER_CIPHERTEXT_SIZE]) -> Option<[u8; KYBER_PLAINTEXT_SIZE]>;
 }
diff --git a/src/crypto/p384.rs b/src/crypto/p384.rs
index c7ed465..161f5ee 100644
--- a/src/crypto/p384.rs
+++ b/src/crypto/p384.rs
@@ -1,19 +1,21 @@
 use rand_core::{CryptoRng, RngCore};
 
+/// The size in bytes of a P-384 public key when in compressed SEC1-encoded format.
 pub const P384_PUBLIC_KEY_SIZE: usize = 49;
+/// The size in bytes of the raw output of ECDH between a P-384 public and private key.
 pub const P384_ECDH_SHARED_SECRET_SIZE: usize = 48;
 
 /// A NIST P-384 ECDH/ECDSA public key.
 pub trait PublicKeyP384: Sized + Send + Sync {
-    /// Create a p384 public key from raw bytes.
+    /// Create a P-384 public key from raw bytes.
     ///
-    /// **CRITICAL**: This function must return `None` if the input `raw_key` is not on the P384 curve,
-    /// or if it breaks the P384 standard in any other way.
+    /// **CRITICAL**: This function must return `None` if the input `raw_key` is not on the P-384
+    /// curve, or if it breaks the P-384 spec in any other way.
     fn from_bytes(raw_key: &[u8; P384_PUBLIC_KEY_SIZE]) -> Option<Self>;
 
     /// Get the raw bytes that uniquely define the public key.
     ///
-    /// This must output the compressed 49 byte NIST encoding of P384 public keys.
+    /// This must output the compressed SEC1 NIST encoding of P-384 public keys.
     fn to_bytes(&self) -> [u8; P384_PUBLIC_KEY_SIZE];
 }
 
@@ -21,22 +23,23 @@ pub trait PublicKeyP384: Sized + Send + Sync {
 ///
 /// Instances must securely delete the private key when dropped.
 pub trait KeyPairP384<Rng: RngCore + CryptoRng> {
+    /// The `PublicKeyP384` implementation which matches this `KeyPairP384` implementation.
     type PublicKey: PublicKeyP384;
-    /// Randomly generate a new p384 keypair.
-    /// This function may use the provided RNG or it's own,
-    /// so long as the produced keys are cryptographically random.
+    /// Randomly generate a new P-384 keypair.
+    /// 
+    /// This function may use the provided RNG or its own, so long as the output is cryptographically random.
     fn generate(rng: &mut Rng) -> Self;
 
     /// Get the raw bytes that uniquely define the public key.
     ///
-    /// This must output the compressed 49 byte NIST encoding of P384 public keys.
+    /// This must output the compressed SEC1 NIST encoding of P-384 public keys.
     fn public_key_bytes(&self) -> [u8; P384_PUBLIC_KEY_SIZE];
 
     /// Perform ECDH key agreement, writing the raw (un-hashed!) ECDH secret to `output`.
     ///
     /// **CRITICAL**: This function must return `None` if key agreement between this private key and
     /// the input `public_key` key would result in an invalid, non-standard or predictable ECDH secret.
-    /// Please refer to the NIST spec for P384 ECDH key agreement, or better yet use a peer reviewed
+    /// Please refer to the NIST spec for P-384 ECDH key agreement, or better yet use a peer reviewed
     /// library that has already implemented this correctly.
     fn agree(&self, public_key: &Self::PublicKey) -> Option<[u8; P384_ECDH_SHARED_SECRET_SIZE]>;
 }
diff --git a/src/crypto/sha512.rs b/src/crypto/sha512.rs
index 0ff187e..2eb32a2 100644
--- a/src/crypto/sha512.rs
+++ b/src/crypto/sha512.rs
@@ -1,15 +1,17 @@
+/// The size of a SHA-512 hash, which of course is 64 bytes, or 512 bits.
 pub const SHA512_HASH_SIZE: usize = 64;
 
-/// Opaque SHA-512 implementation.
-/// Does not need to be threadsafe.
+/// A SHA-512 and HMAC-SHA-512 implementation.
 pub trait HashSha512 {
-    /// Allocate memory on the stack or heap for Sha512.
-    /// An instance of Sha512 will only ever be held on the stack.
+    /// Create a new instance of SHA-512 for streaming data to.
     fn new() -> Self;
-
+    /// Update the instance of SHA-512 with input `data`.
+    /// This must update the state of SHA-512 as if `data` was appended to the previous input.
     fn update(&mut self, data: &[u8]);
-    /// Finish hashing the input and write the final hash to output.
+    /// Finish streaming input and output the final hash.
     fn finish(self) -> [u8; SHA512_HASH_SIZE];
 
+    /// Produce a HMAC-SHA-512 hash based on the given `key` and `data`.
+    /// This is a pure function and does not need to support streaming.
     fn hmac(key: &[u8], data: &[u8]) -> [u8; SHA512_HASH_SIZE];
 }
diff --git a/src/crypto_impl/kyber1024.rs b/src/crypto_impl/kyber1024.rs
index 7e6ce5d..4c5ed15 100644
--- a/src/crypto_impl/kyber1024.rs
+++ b/src/crypto_impl/kyber1024.rs
@@ -3,6 +3,8 @@ use zeroize::Zeroizing;
 
 use crate::crypto::*;
 
+/// A wrapper for a buffer the size of a pqc_kyber secret key.
+/// The crate `pqc_kyber` is low level and operates directly on buffers of bytes.
 pub type PqcKyberSecretKey = Zeroizing<[u8; pqc_kyber::KYBER_SECRETKEYBYTES]>;
 
 impl<Rng: RngCore + CryptoRng> PrivateKeyKyber1024<Rng> for PqcKyberSecretKey {
diff --git a/src/crypto_impl/mod.rs b/src/crypto_impl/mod.rs
index 0a9dd5a..1f9d7ef 100644
--- a/src/crypto_impl/mod.rs
+++ b/src/crypto_impl/mod.rs
@@ -1,11 +1,11 @@
 #[cfg(feature = "aes-gcm")]
-pub mod aes_impl;
+mod aes_impl;
 #[cfg(feature = "pqc_kyber")]
-pub mod kyber1024;
+mod kyber1024;
 #[cfg(feature = "p384")]
-pub mod p384_impl;
+mod p384_impl;
 #[cfg(feature = "sha2")]
-pub mod sha512;
+mod sha512;
 
 #[cfg(feature = "aes")]
 pub use aes;
@@ -17,5 +17,7 @@ pub use hmac;
 pub use p384;
 #[cfg(feature = "pqc_kyber")]
 pub use pqc_kyber;
+#[cfg(feature = "pqc_kyber")]
+pub use kyber1024::PqcKyberSecretKey;
 #[cfg(feature = "sha2")]
 pub use sha2;
diff --git a/src/lib.rs b/src/lib.rs
index bc794bd..d3b627f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -5,7 +5,7 @@
 * (c) ZeroTier, Inc.
 * https://www.zerotier.com/
 */
-//#![warn(missing_docs, rust_2018_idioms)]
+#![warn(missing_docs, rust_2018_idioms)]
 //! TODO: docs
 
 mod applicationlayer;
@@ -17,13 +17,28 @@ mod log_event;
 mod proto;
 mod symmetric_state;
 mod zeta;
+mod ratchet_state;
 
-#[macro_use]
 pub mod result;
+/// A collection of implementation-independent traits for the various specific cryptographic
+/// algorithms ZSSP depends on.
+/// Each trait is hyper-specific about the semantics of the algorithms and the lengths of its inputs
+/// and outputs as a forced sanity-check for anyone trying to use their own implementations.
+///
+/// The `crypto_impl` module contains implementations of these traits in terms of popular Rust
+/// implementations of these algorithms.
 pub mod crypto;
+/// A module containing implementations of the ZSSP `crypto` traits in terms of popular Rust crates.
+/// Some of these crates are not thoroughly audited, so use at your own risk.
+///
+/// Note that none of these crates are FIPS certified, meaning a build of ZSSP using them will not
+/// be FIPS compliant. However lack of FIPS compliance by no means implies lack of security or lack
+/// of confidence.
+///
+/// This module contains the trait implementations as well as re-exports of those crates.
 pub mod crypto_impl;
-pub mod ratchet_state;
 
+pub use ratchet_state::RatchetState;
 pub use applicationlayer::{ApplicationLayer, Settings};
 pub use context::Context;
 #[cfg(feature = "logging")]

From 2c33e447bd079c764088b47e36a1375226f532dc Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Thu, 3 Aug 2023 15:19:32 -0400
Subject: [PATCH 12/37] improved dependency handling

---
 Cargo.lock              | 77 -----------------------------------------
 Cargo.toml              | 17 +++++----
 src/crypto/kyber1024.rs | 12 +++----
 src/crypto/p384.rs      |  2 +-
 src/crypto_impl/mod.rs  |  4 +--
 src/lib.rs              | 18 +++++-----
 6 files changed, 29 insertions(+), 101 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f9170ea..c58728d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -43,12 +43,6 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
 
-[[package]]
-name = "base64ct"
-version = "1.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
-
 [[package]]
 name = "block-buffer"
 version = "0.10.4"
@@ -108,7 +102,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
 dependencies = [
  "generic-array",
- "rand_core",
  "typenum",
 ]
 
@@ -128,7 +121,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c7ed52955ce76b1554f509074bb357d3fb8ac9b51288a65a3fd480d1dfba946"
 dependencies = [
  "const-oid",
- "pem-rfc7468",
  "zeroize",
 ]
 
@@ -139,25 +131,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
 dependencies = [
  "block-buffer",
- "const-oid",
  "crypto-common",
  "subtle",
 ]
 
-[[package]]
-name = "ecdsa"
-version = "0.16.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4b1e0c257a9e9f25f90ff76d7a68360ed497ee519c8e428d1825ef0000799d4"
-dependencies = [
- "der",
- "digest",
- "elliptic-curve",
- "rfc6979",
- "signature",
- "spki",
-]
-
 [[package]]
 name = "elliptic-curve"
 version = "0.13.5"
@@ -171,8 +148,6 @@ dependencies = [
  "generic-array",
  "group",
  "hkdf",
- "pem-rfc7468",
- "pkcs8",
  "rand_core",
  "sec1",
  "subtle",
@@ -277,29 +252,8 @@ version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "70786f51bcc69f6a4c0360e063a4cac5419ef7c5cd5b3c99ad70f3be5ba79209"
 dependencies = [
- "ecdsa",
  "elliptic-curve",
  "primeorder",
- "sha2",
-]
-
-[[package]]
-name = "pem-rfc7468"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412"
-dependencies = [
- "base64ct",
-]
-
-[[package]]
-name = "pkcs8"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
-dependencies = [
- "der",
- "spki",
 ]
 
 [[package]]
@@ -341,16 +295,6 @@ dependencies = [
  "getrandom",
 ]
 
-[[package]]
-name = "rfc6979"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
-dependencies = [
- "hmac",
- "subtle",
-]
-
 [[package]]
 name = "sec1"
 version = "0.7.3"
@@ -360,7 +304,6 @@ dependencies = [
  "base16ct",
  "der",
  "generic-array",
- "pkcs8",
  "subtle",
  "zeroize",
 ]
@@ -376,26 +319,6 @@ dependencies = [
  "digest",
 ]
 
-[[package]]
-name = "signature"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e1788eed21689f9cf370582dfc467ef36ed9c707f073528ddafa8d83e3b8500"
-dependencies = [
- "digest",
- "rand_core",
-]
-
-[[package]]
-name = "spki"
-version = "0.7.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d1e996ef02c474957d681f1b05213dfb0abab947b446a62d37770b23500184a"
-dependencies = [
- "base64ct",
- "der",
-]
-
 [[package]]
 name = "subtle"
 version = "2.5.0"
diff --git a/Cargo.toml b/Cargo.toml
index cd08fbc..4dbe805 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -11,15 +11,15 @@ path = "src/lib.rs"
 doc = true
 
 [dependencies]
-rand_core = "0.6.4"
-zeroize = { version = "1.6.0", default-features = false}
+rand_core = { version = "0.6.4" }
+zeroize = { version = "1.6.0" }
 
 pqc_kyber = { version = "0.6.0", default-features = false, features = ["kyber1024", "std"], optional = true }
-aes-gcm = { version = "0.10.2", optional = true}
-aes = { version = "0.8.3", optional = true}
-p384 = { version = "0.13.0", optional = true}
-sha2 = { version = "0.10.7", optional = true}
-hmac = { version = "0.12.1", optional = true}
+aes-gcm = { version = "0.10.2", default-features = false, features = ["aes"], optional = true }
+aes = { version = "0.8.3", default-features = false, optional = true }
+p384 = { version = "0.13.0", default-features = false, features = ["ecdh"], optional = true }
+sha2 = { version = "0.10.7", default-features = false, optional = true }
+hmac = { version = "0.12.1", default-features = false, optional = true }
 
 [features]
 default = ["debug", "aes-gcm", "p384", "sha2", "hmac", "pqc_kyber"]
@@ -29,3 +29,6 @@ sha2 = ["dep:sha2"]
 hmac = ["dep:hmac", "sha2"]
 logging = []
 debug = ["logging"]
+
+[dev-dependencies]
+rand_core = { version = "0.6.4", features = ["getrandom"] }
diff --git a/src/crypto/kyber1024.rs b/src/crypto/kyber1024.rs
index a844ff9..185ab6b 100644
--- a/src/crypto/kyber1024.rs
+++ b/src/crypto/kyber1024.rs
@@ -16,19 +16,19 @@ pub trait PrivateKeyKyber1024<Rng: RngCore + CryptoRng>: Sized + Send + Sync {
     ///
     /// This function may use the provided RNG or its own, so long as the output is cryptographically random.
     fn generate(rng: &mut Rng) -> (Self, [u8; KYBER_PUBLIC_KEY_SIZE]);
-    /// Generate a Kyber1024 key encapsulation based on the given public key, and return the
+    /// Generate a Kyber1024 key encapsulation based on the given `public_key`, and return the
     /// raw bytes of the generated ciphertext and plaintext. The ciphertext is immediately sent to
     /// the remote peer and the plaintext is immediately hashed, both are quickly deleted.
     ///
     /// This function may use the provided RNG or its own, so long as the output is cryptographically random.
     ///
-    /// This must return `None` if the given public_key is invalid in any way according to the
-    /// Kyber1024 spec.
+    /// **CRITICAL**: This must return `None` if the given `public_key` is invalid in any way
+    /// according to the Kyber1024 spec.
     fn encapsulate(rng: &mut Rng, public_key: &[u8; KYBER_PUBLIC_KEY_SIZE]) -> Option<([u8; KYBER_CIPHERTEXT_SIZE], [u8; KYBER_PLAINTEXT_SIZE])>;
-    /// Decapsulate a Kyber1024 ciphertext received from the remote peer, retreiving
+    /// Decapsulate a Kyber1024 `ciphertext` received from the remote peer, retreiving
     /// the raw bytes of the original plaintext. This plaintext is immediately hashed and deleted.
     ///
-    /// This must return `None` if the given ciphertext is invalid in any way according to the
-    /// Kyber1024 spec.
+    /// **CRITICAL**: This must return `None` if the given `ciphertext` is invalid in any way
+    /// according to the Kyber1024 spec.
     fn decapsulate(&self, ciphertext: &[u8; KYBER_CIPHERTEXT_SIZE]) -> Option<[u8; KYBER_PLAINTEXT_SIZE]>;
 }
diff --git a/src/crypto/p384.rs b/src/crypto/p384.rs
index 161f5ee..6d13387 100644
--- a/src/crypto/p384.rs
+++ b/src/crypto/p384.rs
@@ -26,7 +26,7 @@ pub trait KeyPairP384<Rng: RngCore + CryptoRng> {
     /// The `PublicKeyP384` implementation which matches this `KeyPairP384` implementation.
     type PublicKey: PublicKeyP384;
     /// Randomly generate a new P-384 keypair.
-    /// 
+    ///
     /// This function may use the provided RNG or its own, so long as the output is cryptographically random.
     fn generate(rng: &mut Rng) -> Self;
 
diff --git a/src/crypto_impl/mod.rs b/src/crypto_impl/mod.rs
index 1f9d7ef..a08b8ef 100644
--- a/src/crypto_impl/mod.rs
+++ b/src/crypto_impl/mod.rs
@@ -13,11 +13,11 @@ pub use aes;
 pub use aes_gcm;
 #[cfg(feature = "hmac")]
 pub use hmac;
+#[cfg(feature = "pqc_kyber")]
+pub use kyber1024::PqcKyberSecretKey;
 #[cfg(feature = "p384")]
 pub use p384;
 #[cfg(feature = "pqc_kyber")]
 pub use pqc_kyber;
-#[cfg(feature = "pqc_kyber")]
-pub use kyber1024::PqcKyberSecretKey;
 #[cfg(feature = "sha2")]
 pub use sha2;
diff --git a/src/lib.rs b/src/lib.rs
index d3b627f..8892f1c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -5,7 +5,7 @@
 * (c) ZeroTier, Inc.
 * https://www.zerotier.com/
 */
-#![warn(missing_docs, rust_2018_idioms)]
+//#![warn(missing_docs, rust_2018_idioms)]
 //! TODO: docs
 
 mod applicationlayer;
@@ -15,21 +15,22 @@ mod fragmentation;
 #[cfg(feature = "logging")]
 mod log_event;
 mod proto;
+mod ratchet_state;
 mod symmetric_state;
 mod zeta;
-mod ratchet_state;
 
-pub mod result;
 /// A collection of implementation-independent traits for the various specific cryptographic
 /// algorithms ZSSP depends on.
-/// Each trait is hyper-specific about the semantics of the algorithms and the lengths of its inputs
-/// and outputs as a forced sanity-check for anyone trying to use their own implementations.
+///
+/// Each trait is hyper-specific about the semantics of the algorithms and the lengths of their
+/// inputs and outputs.
+/// This is to enforced a basic sanity-check upon anyone trying to use their own implementations.
 ///
 /// The `crypto_impl` module contains implementations of these traits in terms of popular Rust
 /// implementations of these algorithms.
 pub mod crypto;
-/// A module containing implementations of the ZSSP `crypto` traits in terms of popular Rust crates.
-/// Some of these crates are not thoroughly audited, so use at your own risk.
+/// A module containing optional implementations of the ZSSP `crypto` traits in terms of popular
+/// Rust crates. Some of these crates are not thoroughly audited, so use at your own risk.
 ///
 /// Note that none of these crates are FIPS certified, meaning a build of ZSSP using them will not
 /// be FIPS compliant. However lack of FIPS compliance by no means implies lack of security or lack
@@ -37,11 +38,12 @@ pub mod crypto;
 ///
 /// This module contains the trait implementations as well as re-exports of those crates.
 pub mod crypto_impl;
+pub mod result;
 
-pub use ratchet_state::RatchetState;
 pub use applicationlayer::{ApplicationLayer, Settings};
 pub use context::Context;
 #[cfg(feature = "logging")]
 pub use log_event::LogEvent;
 pub use proto::{MIN_TRANSPORT_MTU, RATCHET_SIZE};
+pub use ratchet_state::RatchetState;
 pub use zeta::Session;

From 6cb72db9344f9b0f8f89d43fbc2fc9b8b2e313a4 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Thu, 3 Aug 2023 15:20:48 -0400
Subject: [PATCH 13/37] removed unused default

---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index 4dbe805..e41d91d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -22,7 +22,7 @@ sha2 = { version = "0.10.7", default-features = false, optional = true }
 hmac = { version = "0.12.1", default-features = false, optional = true }
 
 [features]
-default = ["debug", "aes-gcm", "p384", "sha2", "hmac", "pqc_kyber"]
+default = ["debug", "aes-gcm", "p384", "hmac", "pqc_kyber"]
 aes = ["dep:aes"]
 aes-gcm = ["dep:aes-gcm", "aes"]
 sha2 = ["dep:sha2"]

From c8b088f4c7b31485528ae82048a55768be910b70 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Thu, 3 Aug 2023 15:35:48 -0400
Subject: [PATCH 14/37] changed error name

---
 examples/basic_test.rs  |  8 ++++----
 src/applicationlayer.rs |  8 ++++----
 src/context.rs          |  4 ++--
 src/fragmentation.rs    |  4 ++--
 src/zeta.rs             | 20 ++++++++++----------
 5 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index 31512ed..76ce3ca 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -62,7 +62,7 @@ impl zssp_proto::ApplicationLayer for &TestApplication {
     type KeyPair = EphemeralSecret;
     type Kem = PqcKyberSecretKey;
 
-    type DiskError = ();
+    type StorageError = ();
     type Data = u128;
 
     fn hello_requires_recognized_ratchet(&self) -> bool {
@@ -77,7 +77,7 @@ impl zssp_proto::ApplicationLayer for &TestApplication {
         (Some((true, 1)), true)
     }
 
-    fn restore_by_fingerprint(&self, ratchet_fingerprint: &[u8; RATCHET_SIZE]) -> Result<Option<RatchetState>, Self::DiskError> {
+    fn restore_by_fingerprint(&self, ratchet_fingerprint: &[u8; RATCHET_SIZE]) -> Result<Option<RatchetState>, Self::StorageError> {
         let ratchets = self.ratchets.lock().unwrap();
         Ok(ratchets.rf_map.get(ratchet_fingerprint).cloned())
     }
@@ -86,7 +86,7 @@ impl zssp_proto::ApplicationLayer for &TestApplication {
         &self,
         remote_static_key: &Self::PublicKey,
         application_data: &Self::Data,
-    ) -> Result<(RatchetState, Option<RatchetState>), Self::DiskError> {
+    ) -> Result<(RatchetState, Option<RatchetState>), Self::StorageError> {
         let ratchets = self.ratchets.lock().unwrap();
         Ok(ratchets
             .peer_map
@@ -104,7 +104,7 @@ impl zssp_proto::ApplicationLayer for &TestApplication {
         state_added: Option<&RatchetState>,
         state_deleted1: Option<&RatchetState>,
         state_deleted2: Option<&RatchetState>,
-    ) -> Result<(), Self::DiskError> {
+    ) -> Result<(), Self::StorageError> {
         let mut ratchets = self.ratchets.lock().unwrap();
         ratchets.peer_map.insert(*application_data, (state1.clone(), state2.cloned()));
 
diff --git a/src/applicationlayer.rs b/src/applicationlayer.rs
index 7912450..6c00d67 100644
--- a/src/applicationlayer.rs
+++ b/src/applicationlayer.rs
@@ -132,7 +132,7 @@ pub trait ApplicationLayer: Sized {
 
     /// A user-defined error returned when the `ApplicationLayer` fails to access persistent storage
     /// for a peer's ratchet states.
-    type DiskError: std::fmt::Debug;
+    type StorageError: std::fmt::Debug;
 
     /// An arbitrary opaque object for use by the application that is attached to each session.
     type Data;
@@ -188,7 +188,7 @@ pub trait ApplicationLayer: Sized {
     /// If `RatchetAction::DowngradeRatchet` is returned we will attempt to convince Alice to downgrade
     /// to the empty ratchet key, restarting the ratchet chain.
     /// If `RatchetAction::FailAuthentication` is returned Alice's connection will be silently dropped.
-    fn restore_by_fingerprint(&self, ratchet_fingerprint: &[u8; RATCHET_SIZE]) -> Result<Option<RatchetState>, Self::DiskError>;
+    fn restore_by_fingerprint(&self, ratchet_fingerprint: &[u8; RATCHET_SIZE]) -> Result<Option<RatchetState>, Self::StorageError>;
     /// Lookup the specific ratchet states based on the identity of the peer being communicated with.
     /// This function will be called whenever Alice attempts to open a session, or Bob attempts
     /// to verify Alice's identity.
@@ -207,7 +207,7 @@ pub trait ApplicationLayer: Sized {
         &self,
         remote_static_key: &Self::PublicKey,
         application_data: &Self::Data,
-    ) -> Result<(RatchetState, Option<RatchetState>), Self::DiskError>;
+    ) -> Result<(RatchetState, Option<RatchetState>), Self::StorageError>;
     /// Atomically save `current_state1` and `current_state2` so that them and only them can be
     /// restored with `restore_by_identity` and `restore_by_fingerprint` through a system restart.
     /// Theses should overwrite the previous ratchet states 1 and 2 saved to storage.
@@ -241,7 +241,7 @@ pub trait ApplicationLayer: Sized {
         state_added: Option<&RatchetState>,
         state_deleted1: Option<&RatchetState>,
         state_deleted2: Option<&RatchetState>,
-    ) -> Result<(), Self::DiskError>;
+    ) -> Result<(), Self::StorageError>;
 
     /// Receives a stream of events that occur during an execution of ZSSP.
     /// These are provided for debugging, logging or metrics purposes, and must be used for
diff --git a/src/context.rs b/src/context.rs
index ab8a010..182ef30 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -102,7 +102,7 @@ impl<App: ApplicationLayer> Context<App> {
         static_remote_key: App::PublicKey,
         application_data: App::Data,
         identity: Vec<u8>,
-    ) -> Result<Arc<Session<App>>, OpenError<App::DiskError>> {
+    ) -> Result<Arc<Session<App>>, OpenError<App::StorageError>> {
         mtu = mtu.max(MIN_TRANSPORT_MTU);
         let ctx = &self.0;
 
@@ -136,7 +136,7 @@ impl<App: ApplicationLayer> Context<App> {
         send_to: impl FnOnce(&Arc<Session<App>>) -> Option<(SendFn, usize)>,
         remote_address: &impl Hash,
         raw_fragment: Vec<u8>,
-    ) -> Result<ReceiveOk<App>, ReceiveError<App::DiskError>> {
+    ) -> Result<ReceiveOk<App>, ReceiveError<App::StorageError>> {
         use crate::result::FaultType::*;
         send_unassociated_mtu = send_unassociated_mtu.max(MIN_TRANSPORT_MTU);
         let ctx = &self.0;
diff --git a/src/fragmentation.rs b/src/fragmentation.rs
index 64d3e7c..96ed746 100644
--- a/src/fragmentation.rs
+++ b/src/fragmentation.rs
@@ -76,8 +76,8 @@ impl DefragBuffer {
         &self,
         mut raw_fragment: Vec<u8>,
         current_time: i64,
-        vrfy: impl FnOnce(&[u8; PACKET_NONCE_SIZE], usize, usize) -> Result<(), ReceiveError<App::DiskError>>,
-    ) -> Result<Option<([u8; PACKET_NONCE_SIZE], Vec<u8>)>, ReceiveError<App::DiskError>> {
+        vrfy: impl FnOnce(&[u8; PACKET_NONCE_SIZE], usize, usize) -> Result<(), ReceiveError<App::StorageError>>,
+    ) -> Result<Option<([u8; PACKET_NONCE_SIZE], Vec<u8>)>, ReceiveError<App::StorageError>> {
         use crate::result::FaultType::*;
         if raw_fragment.len() < HEADER_AUTH_END {
             return Err(byzantine_fault!(InvalidPacket, true));
diff --git a/src/zeta.rs b/src/zeta.rs
index 94bc566..748099b 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -258,7 +258,7 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
     application_data: App::Data,
     identity: Vec<u8>,
     send: impl FnOnce(&Packet),
-) -> Result<Arc<Session<App>>, OpenError<App::DiskError>> {
+) -> Result<Arc<Session<App>>, OpenError<App::StorageError>> {
     let (ratchet_state1, ratchet_state2) = app
         .restore_by_identity(&s_remote, &application_data)
         .map_err(|e| OpenError::RatchetIoError(e))?;
@@ -316,7 +316,7 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     n: [u8; AES_GCM_IV_SIZE],
     mut x1: Vec<u8>,
     send: impl FnOnce(&Packet, &[u8; AES_256_KEY_SIZE]),
-) -> Result<(), ReceiveError<App::DiskError>> {
+) -> Result<(), ReceiveError<App::StorageError>> {
     use FaultType::*;
     //    <- s
     //    ...
@@ -436,7 +436,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
     n: [u8; AES_GCM_IV_SIZE],
     mut x2: Vec<u8>,
     send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
-) -> Result<(), ReceiveError<App::DiskError>> {
+) -> Result<(), ReceiveError<App::StorageError>> {
     use FaultType::*;
     //    <- e, ee, ekem1, psk
     //    -> s, se
@@ -588,7 +588,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
     kid: NonZeroU32,
     mut x3: Vec<u8>,
     send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
-) -> Result<Arc<Session<App>>, ReceiveError<App::DiskError>> {
+) -> Result<Arc<Session<App>>, ReceiveError<App::StorageError>> {
     use FaultType::*;
     //    -> s, se
     if x3.len() < HANDSHAKE_COMPLETION_MIN_SIZE {
@@ -727,7 +727,7 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
     n: [u8; AES_GCM_IV_SIZE],
     c1: Vec<u8>,
     send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
-) -> Result<bool, ReceiveError<App::DiskError>> {
+) -> Result<bool, ReceiveError<App::StorageError>> {
     use FaultType::*;
 
     if c1.len() != KEY_CONFIRMATION_SIZE {
@@ -800,7 +800,7 @@ pub(crate) fn received_c2_trans<App: ApplicationLayer>(
     kid: NonZeroU32,
     n: [u8; AES_GCM_IV_SIZE],
     c2: Vec<u8>,
-) -> Result<(), ReceiveError<App::DiskError>> {
+) -> Result<(), ReceiveError<App::StorageError>> {
     use FaultType::*;
 
     if c2.len() != ACKNOWLEDGEMENT_SIZE {
@@ -837,7 +837,7 @@ pub(crate) fn received_d_trans<App: ApplicationLayer>(
     kid: NonZeroU32,
     n: [u8; AES_GCM_IV_SIZE],
     d: Vec<u8>,
-) -> Result<(), ReceiveError<App::DiskError>> {
+) -> Result<(), ReceiveError<App::StorageError>> {
     use FaultType::*;
 
     if d.len() != SESSION_REJECTED_SIZE {
@@ -1030,7 +1030,7 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
     n: [u8; AES_GCM_IV_SIZE],
     mut k1: Vec<u8>,
     send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
-) -> Result<(), ReceiveError<App::DiskError>> {
+) -> Result<(), ReceiveError<App::StorageError>> {
     use FaultType::*;
     //    -> s
     //    <- s
@@ -1153,7 +1153,7 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
     n: [u8; AES_GCM_IV_SIZE],
     mut k2: Vec<u8>,
     send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
-) -> Result<(), ReceiveError<App::DiskError>> {
+) -> Result<(), ReceiveError<App::StorageError>> {
     use FaultType::*;
     //    <- e, ee, se
     if k2.len() != REKEY_SIZE {
@@ -1284,7 +1284,7 @@ pub(crate) fn received_payload_in_place<App: ApplicationLayer>(
     kid: NonZeroU32,
     n: [u8; AES_GCM_IV_SIZE],
     payload: &mut Vec<u8>,
-) -> Result<(), ReceiveError<App::DiskError>> {
+) -> Result<(), ReceiveError<App::StorageError>> {
     use FaultType::*;
 
     if payload.len() < AES_GCM_TAG_SIZE {

From b1e39a42a5f46b7c11bbc9167fb5d2308e7c3657 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Fri, 4 Aug 2023 01:40:20 -0400
Subject: [PATCH 15/37] refactored

---
 README.md               |  37 -----------------
 comparison.md           |  37 +++++++++++++++++
 examples/basic_test.rs  |  36 ++++++++---------
 src/applicationlayer.rs |  26 +++++++-----
 src/context.rs          |   7 ++--
 src/lib.rs              |   2 +-
 src/symmetric_state.rs  |   2 +-
 src/zeta.rs             |  85 +++++++++++++++++++++++-----------------
 whitepaper.pdf          | Bin 0 -> 420496 bytes
 9 files changed, 124 insertions(+), 108 deletions(-)
 create mode 100644 comparison.md
 create mode 100644 whitepaper.pdf

diff --git a/README.md b/README.md
index 95f2984..f043379 100644
--- a/README.md
+++ b/README.md
@@ -21,40 +21,3 @@ Further information can be found in the ZSSP whitepaper (pending official releas
  - **KBKDF**: Key mixing, sub-key derivation
  - **AES-256**: 128-bit PRP for AES-256-GCM and for authenticated encryption of header to harden fragmentation against DOS (see section on header protection)
  - **AES-256-GCM**: Authenticated encryption
-
-## Security Properties
-
-| | Persistent ZSSP | Opportunistic ZSSP| WireGuard | ZeroTier Legacy Transport |
-| --- | --- | --- | --- | --- |
-|**Construction**|Noise\_XKhfs+psk2|Noise\_XKhfs+psk2|Noise\_IKpsk2|Static Diffie-Helman|
-|**Perfect Forward Secrecy**|Yes|Yes|Yes|No|
-|**Forward Secret Identity Hiding**|Yes|Yes|No|No|
-|**Quantum Forward Secret**|Yes|Yes|No|No|
-|**Ratcheted Forward Secrecy**|Yes|Yes|No|No|
-|**Silence is a Virtue**|Yes|No|Yes|No|
-|**Key-Compromise Impersonation**|Resistant|Resistant|Resistant|Vulnerable|
-|**Compromise-and-Impersonate**|Resistant|Detectable|Vulnerable|Vulnerable|
-|**Single Key-Compromise MitM**|Resistant|Resistant|Resistant|Vulnerable|
-|**Double Key-Compromise MitM**|Resistant|Detectable|Vulnerable|Vulnerable|
-|**DOS Mitigation**|Yes|Yes|Yes|No|
-|**Supports Fragmentation**|Yes|Yes|No|Yes|
-|**FIPS Compliant**|Yes|Yes|No|No|
-|**Small Code Footprint**|Yes|Yes|Yes|No|
-|**RTT**|2|2|1|1|
-
-### Definitions
-
-* **Construction**: The mathematical construction the protocol is based upon.
-* **Perfect Forward Secrecy**: An attacker with the static private keys of both party cannot decrypt recordings of messages sent between those parties.
-* **Forward Secret Identity Hiding**: An attacker with the static private key of one or more parties cannot determine the identity of everyone they have previously communicated with.
-* **Quantum Forward Secret**: A quantum computer powerful enough to break Elliptic-curve cryptography is not sufficient in order to decrypt recordings of messages sent between parties.
-* **Ratcheted Forward Secrecy**: In order to break forward secrecy an attacker must record and break every single key exchange two parties perform, in order, starting from the first time they began communicating. Improves secrecy under weak or compromised RNG.
-* **Silence is a Virtue**: A server running the protocol can be configured in such a way that it will not respond to an unauthenticated, anonymous or replayed message.
-* **Key-Compromise Impersonation**: The attacker has a memory image of a single party, and attempts to create a brand new session with that party, pretending to be someone else.
-* **Compromise-and-Impersonate**: The attacker has a memory image of a single party, and attempts to impersonate them on a brand new session with the other party.
-* **Single Key-Compromise MitM**: The attacker has a memory image of a single party, and attempts to become a Man-in-the-Middle between them and any other party.
-* **Double Key-Compromise MitM**: The attacker has a memory image of both parties, and attempts to become a Man-in-the-Middle between them.
-* **Supports Fragmentation**: Transmission data can be fragmented into smaller units to support jumbo-sized data or MTU discovery.
-* **FIPS Compliant**: The protocol uses FIPS approved cryptographic algorithms.
-* **Small Code Footprint**: The Codebase implementing the protocol can be easily audited by anyone on the internet.
-* **RTT**: "Round-Trip-Time" - How many round trips from initiator to responder it takes to establish a session.
diff --git a/comparison.md b/comparison.md
new file mode 100644
index 0000000..abcdd50
--- /dev/null
+++ b/comparison.md
@@ -0,0 +1,37 @@
+
+## Security Properties
+
+| | Persistent ZSSP | Opportunistic ZSSP| WireGuard | ZeroTier Legacy Transport |
+| --- | --- | --- | --- | --- |
+|**Construction**|Noise\_XKhfs+psk2|Noise\_XKhfs+psk2|Noise\_IKpsk2|Static Diffie-Helman|
+|**Perfect Forward Secrecy**|Yes|Yes|Yes|No|
+|**Forward Secret Identity Hiding**|Yes|Yes|No|No|
+|**Quantum Forward Secret**|Yes|Yes|No|No|
+|**Ratcheted Forward Secrecy**|Yes|Yes|No|No|
+|**Silence is a Virtue**|Yes|No|Yes|No|
+|**Key-Compromise Impersonation**|Resistant|Resistant|Resistant|Vulnerable|
+|**Compromise-and-Impersonate**|Resistant|Detectable|Vulnerable|Vulnerable|
+|**Single Key-Compromise MitM**|Resistant|Resistant|Resistant|Vulnerable|
+|**Double Key-Compromise MitM**|Resistant|Detectable|Vulnerable|Vulnerable|
+|**DOS Mitigation**|Yes|Yes|Yes|No|
+|**Supports Fragmentation**|Yes|Yes|No|Yes|
+|**FIPS Compliant**|Yes|Yes|No|No|
+|**Small Code Footprint**|Yes|Yes|Yes|No|
+|**RTT**|2|2|1|1|
+
+### Definitions
+
+* **Construction**: The mathematical construction the protocol is based upon.
+* **Perfect Forward Secrecy**: An attacker with the static private keys of both party cannot decrypt recordings of messages sent between those parties.
+* **Forward Secret Identity Hiding**: An attacker with the static private key of one or more parties cannot determine the identity of everyone they have previously communicated with.
+* **Quantum Forward Secret**: A quantum computer powerful enough to break Elliptic-curve cryptography is not sufficient in order to decrypt recordings of messages sent between parties.
+* **Ratcheted Forward Secrecy**: In order to break forward secrecy an attacker must record and break every single key exchange two parties perform, in order, starting from the first time they began communicating. Improves secrecy under weak or compromised RNG.
+* **Silence is a Virtue**: A server running the protocol can be configured in such a way that it will not respond to an unauthenticated, anonymous or replayed message.
+* **Key-Compromise Impersonation**: The attacker has a memory image of a single party, and attempts to create a brand new session with that party, pretending to be someone else.
+* **Compromise-and-Impersonate**: The attacker has a memory image of a single party, and attempts to impersonate them on a brand new session with the other party.
+* **Single Key-Compromise MitM**: The attacker has a memory image of a single party, and attempts to become a Man-in-the-Middle between them and any other party.
+* **Double Key-Compromise MitM**: The attacker has a memory image of both parties, and attempts to become a Man-in-the-Middle between them.
+* **Supports Fragmentation**: Transmission data can be fragmented into smaller units to support jumbo-sized data or MTU discovery.
+* **FIPS Compliant**: The protocol uses FIPS approved cryptographic algorithms.
+* **Small Code Footprint**: The Codebase implementing the protocol can be easily audited by anyone on the internet.
+* **RTT**: "Round-Trip-Time" - How many round trips from initiator to responder it takes to establish a session.
diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index 76ce3ca..8aaafeb 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -22,7 +22,7 @@ use rand_core::RngCore;
 use sha2::Sha512;
 
 use zssp_proto::crypto_impl::PqcKyberSecretKey;
-use zssp_proto::RatchetState;
+use zssp_proto::{RatchetState, RatchetUpdate};
 use zssp_proto::{Session, Settings, RATCHET_SIZE};
 
 const TEST_MTU: usize = 1500;
@@ -62,8 +62,8 @@ impl zssp_proto::ApplicationLayer for &TestApplication {
     type KeyPair = EphemeralSecret;
     type Kem = PqcKyberSecretKey;
 
-    type StorageError = ();
-    type Data = u128;
+    type StorageError = std::convert::Infallible;
+    type SessionData = u128;
 
     fn hello_requires_recognized_ratchet(&self) -> bool {
         false
@@ -73,7 +73,7 @@ impl zssp_proto::ApplicationLayer for &TestApplication {
         true
     }
 
-    fn check_accept_session(&self, remote_static_key: &Self::PublicKey, identity: &[u8]) -> (Option<(bool, Self::Data)>, bool) {
+    fn check_accept_session(&self, remote_static_key: &Self::PublicKey, identity: &[u8]) -> (Option<(bool, Self::SessionData)>, bool) {
         (Some((true, 1)), true)
     }
 
@@ -85,12 +85,12 @@ impl zssp_proto::ApplicationLayer for &TestApplication {
     fn restore_by_identity(
         &self,
         remote_static_key: &Self::PublicKey,
-        application_data: &Self::Data,
+        session_data: &Self::SessionData,
     ) -> Result<(RatchetState, Option<RatchetState>), Self::StorageError> {
         let ratchets = self.ratchets.lock().unwrap();
         Ok(ratchets
             .peer_map
-            .get(application_data)
+            .get(session_data)
             .cloned()
             .unwrap_or_else(|| RatchetState::new_initial_states()))
     }
@@ -98,24 +98,24 @@ impl zssp_proto::ApplicationLayer for &TestApplication {
     fn save_ratchet_state(
         &self,
         remote_static_key: &Self::PublicKey,
-        application_data: &Self::Data,
-        state1: &RatchetState,
-        state2: Option<&RatchetState>,
-        state_added: Option<&RatchetState>,
-        state_deleted1: Option<&RatchetState>,
-        state_deleted2: Option<&RatchetState>,
+        session_data: &Self::SessionData,
+        update_data: RatchetUpdate<'_>,
     ) -> Result<(), Self::StorageError> {
         let mut ratchets = self.ratchets.lock().unwrap();
-        ratchets.peer_map.insert(*application_data, (state1.clone(), state2.cloned()));
+        ratchets
+            .peer_map
+            .insert(*session_data, (update_data.state1.clone(), update_data.state2.cloned()));
 
-        if let Some(rs) = state_added {
-            ratchets.rf_map.insert(*rs.fingerprint().unwrap(), rs.clone());
-            println!("[{}] new ratchet #{}", self.name, rs.chain_len);
+        if update_data.state1_was_just_added {
+            ratchets
+                .rf_map
+                .insert(*update_data.state1.fingerprint().unwrap(), update_data.state1.clone());
+            println!("[{}] new ratchet #{}", self.name, update_data.state1.chain_len);
         }
-        if let Some(Some(rf)) = state_deleted1.map(|rs| rs.fingerprint()) {
+        if let Some(Some(rf)) = update_data.state_deleted1.map(|rs| rs.fingerprint()) {
             ratchets.rf_map.remove(rf);
         }
-        if let Some(Some(rf)) = state_deleted1.map(|rs| rs.fingerprint()) {
+        if let Some(Some(rf)) = update_data.state_deleted2.map(|rs| rs.fingerprint()) {
             ratchets.rf_map.remove(rf);
         }
         Ok(())
diff --git a/src/applicationlayer.rs b/src/applicationlayer.rs
index 6c00d67..8476414 100644
--- a/src/applicationlayer.rs
+++ b/src/applicationlayer.rs
@@ -132,10 +132,10 @@ pub trait ApplicationLayer: Sized {
 
     /// A user-defined error returned when the `ApplicationLayer` fails to access persistent storage
     /// for a peer's ratchet states.
-    type StorageError: std::fmt::Debug;
+    type StorageError: std::error::Error;
 
     /// An arbitrary opaque object for use by the application that is attached to each session.
-    type Data;
+    type SessionData;
 
     /// Should return the current time in milliseconds. Does not have to be monotonic, nor synced
     /// with remote peers (although both of these properties would help reliability slightly).
@@ -174,7 +174,7 @@ pub trait ApplicationLayer: Sized {
     /// must verify this identity is associated with the remote peer's static key.
     /// To prevent desync, if this function returns (Some(_), _), no other open session with the
     /// same remote peer must exist. Drop or call expire on any pre-existing sessions before returning.
-    fn check_accept_session(&self, remote_static_key: &Self::PublicKey, identity: &[u8]) -> (Option<(bool, Self::Data)>, bool);
+    fn check_accept_session(&self, remote_static_key: &Self::PublicKey, identity: &[u8]) -> (Option<(bool, Self::SessionData)>, bool);
 
     /// Lookup a specific ratchet state based on its ratchet fingerprint.
     /// This function will be called whenever Alice attempts to connect to us with a non-empty
@@ -206,7 +206,7 @@ pub trait ApplicationLayer: Sized {
     fn restore_by_identity(
         &self,
         remote_static_key: &Self::PublicKey,
-        application_data: &Self::Data,
+        session_data: &Self::SessionData,
     ) -> Result<(RatchetState, Option<RatchetState>), Self::StorageError>;
     /// Atomically save `current_state1` and `current_state2` so that them and only them can be
     /// restored with `restore_by_identity` and `restore_by_fingerprint` through a system restart.
@@ -235,12 +235,8 @@ pub trait ApplicationLayer: Sized {
     fn save_ratchet_state(
         &self,
         remote_static_key: &Self::PublicKey,
-        application_data: &Self::Data,
-        current_state1: &RatchetState,
-        current_state2: Option<&RatchetState>,
-        state_added: Option<&RatchetState>,
-        state_deleted1: Option<&RatchetState>,
-        state_deleted2: Option<&RatchetState>,
+        session_data: &Self::SessionData,
+        update_data: RatchetUpdate<'_>,
     ) -> Result<(), Self::StorageError>;
 
     /// Receives a stream of events that occur during an execution of ZSSP.
@@ -249,3 +245,13 @@ pub trait ApplicationLayer: Sized {
     #[cfg(feature = "logging")]
     fn event_log(&self, event: LogEvent<'_, Self>);
 }
+
+pub trait CryptoLayer {}
+
+pub struct RatchetUpdate<'a> {
+    pub state1: &'a RatchetState,
+    pub state2: Option<&'a RatchetState>,
+    pub state1_was_just_added: bool,
+    pub state_deleted1: Option<&'a RatchetState>,
+    pub state_deleted2: Option<&'a RatchetState>,
+}
diff --git a/src/context.rs b/src/context.rs
index 182ef30..f4ff1cd 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -59,7 +59,6 @@ fn to_packet_nonce(n: &[u8; AES_GCM_IV_SIZE]) -> &[u8; PACKET_NONCE_SIZE] {
     (&n[n.len() - PACKET_NONCE_SIZE..]).try_into().unwrap()
 }
 
-#[allow(unused)]
 impl<App: ApplicationLayer> Context<App> {
     /// Create a new session context.
     pub fn new(static_secret_key: App::KeyPair, mut rng: App::Rng) -> Self {
@@ -90,7 +89,7 @@ impl<App: ApplicationLayer> Context<App> {
     ///   contacted
     /// * `mtu` - MTU for initial packets
     /// * `static_remote_key` - Remote side's static public NIST P-384 key
-    /// * `application_data` - Arbitrary data meaningful to the application to include with session
+    /// * `session_data` - Arbitrary data meaningful to the application to include with session
     ///   object
     /// * `identity` - Payload to be sent to Bob that contains the information necessary
     ///   for the upper protocol to authenticate and approve of Alice's identity
@@ -100,7 +99,7 @@ impl<App: ApplicationLayer> Context<App> {
         send: impl FnMut(Vec<u8>) -> bool,
         mut mtu: usize,
         static_remote_key: App::PublicKey,
-        application_data: App::Data,
+        session_data: App::SessionData,
         identity: Vec<u8>,
     ) -> Result<Arc<Session<App>>, OpenError<App::StorageError>> {
         mtu = mtu.max(MIN_TRANSPORT_MTU);
@@ -111,7 +110,7 @@ impl<App: ApplicationLayer> Context<App> {
             app,
             &ctx,
             static_remote_key,
-            application_data,
+            session_data,
             identity,
             |Packet(kid, nonce, payload): &Packet| {
                 // Process fragmentation layer.
diff --git a/src/lib.rs b/src/lib.rs
index 8892f1c..680a598 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -40,7 +40,7 @@ pub mod crypto;
 pub mod crypto_impl;
 pub mod result;
 
-pub use applicationlayer::{ApplicationLayer, Settings};
+pub use applicationlayer::{ApplicationLayer, RatchetUpdate, Settings};
 pub use context::Context;
 #[cfg(feature = "logging")]
 pub use log_event::LogEvent;
diff --git a/src/symmetric_state.rs b/src/symmetric_state.rs
index 3c49ca6..516c3bf 100644
--- a/src/symmetric_state.rs
+++ b/src/symmetric_state.rs
@@ -12,7 +12,7 @@ pub struct SymmetricState<App: ApplicationLayer> {
     h: [u8; HASHLEN],
     /// If anyone knows a better way to get rid of the "parameter `App` is never used" error please
     /// let me know.
-    _app: PhantomData<fn() -> App::Data>,
+    _app: PhantomData<fn() -> App::SessionData>,
 }
 impl<App: ApplicationLayer> Clone for SymmetricState<App> {
     fn clone(&self) -> Self {
diff --git a/src/zeta.rs b/src/zeta.rs
index 748099b..b33bf53 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -5,6 +5,7 @@ use std::ops::{Deref, DerefMut};
 use std::sync::{Arc, Mutex, Weak};
 use zeroize::Zeroizing;
 
+use crate::applicationlayer::RatchetUpdate;
 use crate::challenge::{gen_null_response, respond_to_challenge_in_place};
 use crate::context::{log, ContextInner, SessionMap};
 use crate::crypto::*;
@@ -40,7 +41,7 @@ pub(crate) fn from_nonce(n: &[u8]) -> (u8, u64) {
 pub(crate) struct Zeta<App: ApplicationLayer> {
     ctx: Weak<ContextInner<App>>,
     /// An arbitrary application defined object associated with each session.
-    pub application_data: App::Data,
+    pub session_data: App::SessionData,
     /// Is true if the local peer acted as Bob, the responder in the initial key exchange.
     pub was_bob: bool,
 
@@ -255,12 +256,12 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
     app: App,
     ctx: &Arc<ContextInner<App>>,
     s_remote: App::PublicKey,
-    application_data: App::Data,
+    session_data: App::SessionData,
     identity: Vec<u8>,
     send: impl FnOnce(&Packet),
 ) -> Result<Arc<Session<App>>, OpenError<App::StorageError>> {
     let (ratchet_state1, ratchet_state2) = app
-        .restore_by_identity(&s_remote, &application_data)
+        .restore_by_identity(&s_remote, &session_data)
         .map_err(|e| OpenError::RatchetIoError(e))?;
 
     let mut session_map = ctx.session_map.lock().unwrap();
@@ -274,7 +275,7 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
     let current_time = app.time();
     let mut zeta = Zeta {
         ctx: Arc::downgrade(ctx),
-        application_data,
+        session_data,
         was_bob: false,
         s_remote,
         send_counter: INIT_COUNTER,
@@ -539,12 +540,14 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
             };
             let result = app.save_ratchet_state(
                 &zeta.s_remote,
-                &zeta.application_data,
-                &new_ratchet_state,
-                ratchet_to_preserve,
-                Some(&new_ratchet_state),
-                ratchet_to_delete,
-                None,
+                &zeta.session_data,
+                RatchetUpdate {
+                    state1: &new_ratchet_state,
+                    state2: ratchet_to_preserve,
+                    state1_was_just_added: true,
+                    state_deleted1: ratchet_to_delete,
+                    state_deleted2: None,
+                },
             );
             if let Err(e) = result {
                 return Err(ReceiveError::RatchetIoError(e));
@@ -635,8 +638,8 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
         // handshake is being dropped, so nonce reuse can't happen.
         Packet(zeta.kid_send.get(), n, d)
     };
-    if let Some((responder_disallows_downgrade, application_data)) = responder_disallows_downgrade {
-        let result = app.restore_by_identity(&s_remote, &application_data);
+    if let Some((responder_disallows_downgrade, session_data)) = responder_disallows_downgrade {
+        let result = app.restore_by_identity(&s_remote, &session_data);
         match result {
             Ok((ratchet_state1, ratchet_state2)) => {
                 if (&zeta.ratchet_state != &ratchet_state1) & (Some(&zeta.ratchet_state) != ratchet_state2.as_ref()) {
@@ -655,12 +658,14 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                 let new_ratchet_state = RatchetState::new(rk, rf, zeta.ratchet_state.chain_len + 1);
                 let result = app.save_ratchet_state(
                     &s_remote,
-                    &application_data,
-                    &new_ratchet_state,
-                    None,
-                    Some(&new_ratchet_state),
-                    Some(&ratchet_state1),
-                    ratchet_state2.as_ref(),
+                    &session_data,
+                    RatchetUpdate {
+                        state1: &new_ratchet_state,
+                        state2: None,
+                        state1_was_just_added: true,
+                        state_deleted1: Some(&ratchet_state1),
+                        state_deleted2: ratchet_state2.as_ref(),
+                    },
                 );
                 if let Err(e) = result {
                     return Err(ReceiveError::RatchetIoError(e));
@@ -688,7 +693,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                 };
                 let session = Arc::new(Session(Mutex::new(Zeta {
                     ctx: Arc::downgrade(ctx),
-                    application_data,
+                    session_data,
                     was_bob: true,
                     s_remote,
                     send_counter: INIT_COUNTER + 1,
@@ -759,12 +764,14 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
             if zeta.ratchet_state2.is_some() {
                 let result = app.save_ratchet_state(
                     &zeta.s_remote,
-                    &zeta.application_data,
-                    &zeta.ratchet_state1,
-                    None,
-                    None,
-                    zeta.ratchet_state2.as_ref(),
-                    None,
+                    &zeta.session_data,
+                    RatchetUpdate {
+                        state1: &zeta.ratchet_state1,
+                        state2: None,
+                        state1_was_just_added: false,
+                        state_deleted1: zeta.ratchet_state2.as_ref(),
+                        state_deleted2: None,
+                    },
                 );
                 if let Err(e) = result {
                     return Err(ReceiveError::RatchetIoError(e));
@@ -1105,12 +1112,14 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
         let new_ratchet_state = RatchetState::new(rk, rf, zeta.ratchet_state1.chain_len + 1);
         let result = app.save_ratchet_state(
             &zeta.s_remote,
-            &zeta.application_data,
-            &new_ratchet_state,
-            Some(&zeta.ratchet_state1),
-            Some(&new_ratchet_state),
-            zeta.ratchet_state2.as_ref(),
-            None,
+            &zeta.session_data,
+            RatchetUpdate {
+                state1: &new_ratchet_state,
+                state2: Some(&zeta.ratchet_state1),
+                state1_was_just_added: true,
+                state_deleted1: zeta.ratchet_state2.as_ref(),
+                state_deleted2: None,
+            },
         );
         if let Err(e) = result {
             return Err(ReceiveError::RatchetIoError(e));
@@ -1201,12 +1210,14 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
             let new_ratchet_state = RatchetState::new(rk, rf, zeta.ratchet_state1.chain_len + 1);
             let result = app.save_ratchet_state(
                 &zeta.s_remote,
-                &zeta.application_data,
-                &new_ratchet_state,
-                None,
-                Some(&new_ratchet_state),
-                Some(&zeta.ratchet_state1),
-                zeta.ratchet_state2.as_ref(),
+                &zeta.session_data,
+                RatchetUpdate {
+                    state1: &new_ratchet_state,
+                    state2: None,
+                    state1_was_just_added: true,
+                    state_deleted1: Some(&zeta.ratchet_state1),
+                    state_deleted2: zeta.ratchet_state2.as_ref(),
+                },
             );
             if let Err(e) = result {
                 return Err(ReceiveError::RatchetIoError(e));
diff --git a/whitepaper.pdf b/whitepaper.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..c9231b70d133b24a21c573fde1826e1a3e17e6c6
GIT binary patch
literal 420496
zcmY!laB<T$)HCH$y>R8|4K5P}1BLvgEG`=xF8z?of>Z_l2>+z4)Z`K_{ovB160nF{
zeo-!$zLQgag+jD}f`Nje0T{<}>4Rjzx(vDWeG^NHGAk6K4Hdv@Kx8bJeo$(0erZv1
zYO#W;f`LL1m%dMGUV2G}f}yDb6maRgW#*Km7Afev<s_D*x}+xOr=)V(*>M$@6s0ES
za#h^A%zrLG<J<!#2KK*<AGlKUQlK)ac_|>Lo72q;7PRt$CEdJW2#Oq<M1vtH;z992
z`=n%OM5~A}q+en(q*-b*0>v?XV!{X%=`=}BM#gl@6GosykT#w$qn{^0DVHXmFf;-g
z4NFhZ^4r+Rz!*}16E45kO5L1v+wI-m_=WDPk}j(3u6&v+bNt+z$5)PAnigF6$6=yw
zr>V%w4<90a{yKVf(u#%scT0C>-C(-tz}!3gTiWfJ=G9-1wC}%nW<G1(gSI*&Zl||y
zjs~Z{`~RzZbS&=8QsYXUWA=seiJ4JZ+#l|+WFEe6{Iyke|BeO!Yra0Yc{<`e)7xX7
zZ_bC!c3&PLy7~LL?(OFK;h*_e*V}%4a>0K6zLIzMAI?Ae=h|~~*(?2b5Ad7HUGWdP
z?mszFMD@d!nhW;6x7T=GJ|}*Pd(P66?bmLUUZ3iF_o4p%o!PVN_I;R}wvR(eJzq=Y
z-A!-Nb2ayU4;wh}ohqJqUCHB)%Ga3(XD`$H%+qneEXMqA@E<{IbJuO@AJ%5}R|nre
z&v;AW?o7WJea^-SMN`+$xNvrZ?5=s`8Vdz08Xq;cd^~e~-6cWUl!wa~t`4<{esRF}
z;iJwbex@IeFYa6`erjFIz3ISaiBED*Qj8ksEzOf+6%6_qur*I9{8!#Q4ffK>Kl~!k
zH@9dW5Y`Z|Dfl&a;$s!@5~1^7mA06!{#eP;m9jSbk_nT;=N|@QX<PgEzpL=RFQBw`
zbtiN4r&w9-(=YY)zx<2Qd;j32{nO_3nsfWxdsHR9@!T+Z%gnTCTf&iZPb%&nzEd96
zJUjTUjK{5Iuf;1j+iy9$?~O;y9`(0vEAoumI&PMy`0TiT`P}K-yH#`ili9zAE&Y%l
za6he7{YrEr<6pU}-O?XaM4Ob;ZKq64;E9dQZ)JEfS8Ts&#WKOhmNioyW|#SCeVDsf
zv2gacdG}LF4|4B_ykZb#rF7dl^>1f*<cu}S8*L|=r&O9R5EKa0Oh3E(m+b$V@NLho
z9#|DRt5UHhGVk@8M_;Qs#pX#f-4(N)Gd(}vR`K%Q9#w`PAAD~&oy`4}ef!GdTs=-6
zxoKIp(|+Aux8}sJgO+wrm#ymA8_ALyntw}b%Xh)XWyu-lPkt1uTQJ$K>^!3@^7Taj
z{r|PUF9#n~|9dd${I@`fJ$ifA&U&~ye)>0u)a%@h>^*vqmhH)VdSj~Qk!s5yI?Ime
z@OTH9CJ1R=;<FN4f31XTays)YIj2|4riE^Ps4k(gKg93z^yk_(hB6Bh0>VQ3FZ?{a
zY~?C8|KASZ+81m}o6{rzf@Nxf^#UQiHUEzPRQj^W{kzac?ZsRN-hYprJ6p3_?iG`A
z$O4=6@VxRpt7h@MS8ouw!pp99*p7Rl$O^-2%od*I8NOjB>UM;7>bEII@}(QS2=~?f
zV&G!)`)%3Iq@LFnjk8zfUY_<hFa8;i#g?c0Y$UH=o+u*Jx@q6}6Sv-puYGwyZbH(T
zs*W{0LggVMn|ZcmY<?RzC9QwuBY`vP6(0y%C@)oByg8KV<Vg)r4G{r-GuQaf&VNtv
zzvP*iDz;g$K_bIn^+mQH=aG5okAnCkZ%?g0bJ+Q~B1;~Z%-hd=`)<wLc(naV_LCCn
z-5I`fxuxU|_lT%}=rgx(;HpY){Io{l?#I`4(>Z;r=c(tPzI7t|wPOBGu?EpJ%MBm0
zG>*8M9Do0<<Kyo9ZMkJP8V}Z7+j`us<)qN0bzG4rqg)ftzL?MP=s@0&<96C9Qy)&P
zo6}xkm^yW>He)xlp|0B1j>jj@uamqLvthN7d8xX6z>2G%#e23M)4B6`m)3hrK3U0$
zO00VKO#UA*G(NUV`r6cvn$rLKjl`#1VvUhaid}p%W6HMD-i?x7a~Z{ozBe>od^+dx
z8BYI4iy!bmNqNm!G%vy<SG@IZzul47GFO`XE>3G;ndtT>cxCZAo0PpXrdWr5Xq>{O
zWvlBa@3HjwHf}%dQbxV^JM<a~ruvHoZhJNP*Ho2u9mkXGOcJWwu4w-5W2|&G?fWJY
zZSm+zlkrnd26bsRo4!vB8<saeO}!ax$iZ|mb!XFp|GT0ZcK6ksk6ft2Tde;2NI`^w
zucdF%)MB+9jz=?k+xOY2hv|#@2OiLTy(=+4<*feo$o4{M#o0OWPC3gHPJ}&3zO<m}
z<Ysrq386jH`%YV$#EQ=Mon9uKeMslK!!Dss>CUa?&n_=Kb!wI}>mHHaZRV-As#)1u
z)rAQyIls+pnH{>qCQqMmrL?ZmtGp+=>`_#h$d;!YHTs#>OMJAxz<$)-AZnY_TMs@a
z&R>(f+<#0opL223p7aJ0l_?n~@_JV0zT0)@zPWB>>5DrF9~N#stJ`sg|HQ0GmoBs(
zOk;Upxp~^%l<y6irxq+a#3878sZjIm#S(#kbE+gl(yKdVpRC_le)Ee%_iUG}E}1IE
zFL&$XOYTjSewnZ=fj>n!XUhHh4{5A>T2_~fmK^7A*)?DDdN}8rRX2sIiu0E1-(;(M
zb&NCclk(1u_Hpmc?((<4vzw71%bxe<_x;vVnO&WJ$M?JsSyW$98#DXbcc#BH_FpQ9
zd%wG5-64h_{WtIb*;DiN@@&p+on;Fr|CfuIe8YFLcCUW@PR_p$iz;e5-|h~$bldO8
zan9Y58ocR;=83-0`s%vdQ`o%ka^!?%>)5XRcjmg!tbOz*{{$|b>-KT}rk`gCxHJ_m
zS(v5acXW59@6xSZle@PtJ38*sw@g1Ea${$3-4u=M-A<=3M18!vlIgA6%75~HrCcnU
z>|#Bamo*=2P<DM)a{TYTFS<)P4lK`{V0o%W(PeFKtc>@P-A}XET^E@aEjzI(^e`*?
zT2+Sj8Cz#X30TZ3iQP7Jy39KN8-ib!*||AcD9ERHB{w!@Op1zK!0e~3)6t}_;nSMl
z%9tEB!^+(+!s&aMT-7C>1P9@dAGau`?Ax-)O{)9MLeZ_Raxb(cUiYdScBvb#Xk+d;
z)hjkV_QNw)Ienw<c%QAy=S);v@?Ly@$F9tMNvG5N{xkgYiWKte7hShi$|dj7@v!9Q
z2a1+Ph&p}!u6p#)O#iN<g8Z6hw$Vvh+6EPzF%p~BE&1iN@tv#x(?s`H-96Kd7(=9Y
z)XnG%{jIh7!0CB^ukZx9KUTAEyEW%|OI!UV+k?XIJH@6idw=|KTZ?1-#hfp>vskNn
z_ncUjBVz47>uO#_(Z^4}HYC~qTkI*<R2I4Y@zt~y#hUH=>i$)%O1P?3nzy98Rr})|
ziBrE<3p{vjwR*v&#Y}%U9=RaA;){s0qNV@QNRA`FRMu@ddwru}sq%XfspFa7x?(tX
zTK4Qun3h;$c3R+UP*qus_@%>#s@$i3+@))n;+TF?_*R747KVn3YqS2GxM4GC!7mdV
zU&q4CUfJr)vmDvhROa7WGbu}_BUXR!rj!W*U6w+VyEfd_lvCRl|L4?JwfjcyJ$k=%
zc08M+!#BUO+GhLvlG7}Cd^c3DB}82ix}>A^^~BPQ{IlneUzv4FNMdX13?n`Brt|OK
z_VqSo?BL<<*s}0L^4}wi<}aVWK3j3a36?ppv-Dl|M=y9RSfZlReC#vF^xM@hQhpxp
znQ~jsPqMXz*Z;#h=~MSkWN*&ha3Wov<v{aW^*x35jVk6nhl;)Z*(ToGnYKTxd!3)`
z62^H_>sp1lN=iSp3p2km`WiXCLG?S+>KGrfT^supB^N)tAo{4*ctWh|?)8}tB~IK9
zd)SYq+vU0!`F(zLPvHJrqb2FZVoocrGRz5{?a`jiD>dC(_4iBbfHgVGL#IBQ!j}Ap
z%O$ueB5mu&w@k^Bk;!TqPkDbl43_jN{>{B%UH<GU?aO(uE*yM$x_(DM(DYO8w$FKN
z&$?OvJloW^aIPok-g#!6L6uJPvOXIsFI14q5b^PP*K<luw(!8khn1T;&)OI`F7~Z?
zUREz9;9c3caMoJC#mR#8H}ub12fVppeQ}bRd*a1K>&4Dq2y|ZmQ^3ZtRetuu=lav6
z*ozjV|2TZDdA9KhzT@lW{E11nF0p>FbB6ZZ{TYu8IBuPG*{9%iZu-efrz=;<1_wwi
zefMqKvdCRKq|eW+IOQ^}`##T7{<urMkJ`5`nmy0{C#Q-2%cDQ09($Zpe#nr6`ANs)
zf5O2ncTcK&rksjjlkhyqXT{_B5hoIbo(J)je+;o(lArt|Vmq(zyN99aRc#Z)84rZ0
zx&Kz#&;R%1)z8xmtv@bZscmtVA^Ak43Tw78)6HG`-mrJ2ewg%*Yo7R|ImaI`EZ;fp
zVZT>tu<31O<pnE#xH=x2+wrR{H)6*<2PKx`l|REZW4xtGFRYz-{fJ4!iWL5E+0r;K
zw!QxzIJ7f~-F8djU3T%7S&B;HgqTmSUSx0k;`_Yll-d^t@36z&g?|oo?>i;WAa&MX
z=j~Som7P4tjBA<PPoJK5gsb4q^>wEg88}6}OM7(fNpRkw<A>7~&#!Yl&Yq|JDTn3e
z^B>BRPDXVhKmKzSII>NP>Fj8DoiaJ5_O>XW`l0)74;EFvJeKOUpvL^jf9pk4S0~^9
zcfWD<|1%%u-|W1<9dpdc&=fR;fZnIEG%_N#PxCa|yZE-7(7xZ{8;T-VdAS%EGq9Zq
z<15NJ9;bfuNYK@=+&RoHeJ(002N)7^-mbr2$15kIp_!e=@454ogbACi?cX1}*mGJp
z-;T8S{cC2^|HCt9WiD-wSZXZm?zre{&d%CzuQwlPGdq)36xoyi(RP;TMT1W*1|Ad5
z|J*N*ulUx@`2TtMdAs`5#WVYuW=EOs-nCQx=+&%mkN+Iq-5nmDZXf&iaioUR{ykM5
z@8loMpI=!~8>1k5c9Vj4Nz<nY+s#@$PRWr|_+KYgF1!5mS59JyS^o9B+dIzYdld0r
z{&ef1!rbYh+EebXTUWq!KH9J}eqGF2<M_Ql{~0A{@tvPJtGcZw^G;E`xbCJM!d|nd
zuig_k_w(CZ`wMEfT_}6!z+<XE^Ll&IQ?pOEgm#FWeq^uX!F9P)^@X^}<^Zh|k7kr}
z-)`1Cc0jv)_qJVYKg+(8_qbRSnY;bRqkV5un`YW~%{`>RmS?IpxBdOTIyRZj6D1oz
z2p3mBF%`X6t*_7+Dv}atGVRwZ9n;URas*$pu#{K6u9)-q=(&Spx;Cs6r(bQGzvcCw
zsg?<`+}A=sANt$oyhY2-VK>L=tlhUoDtDGF_^!eCT>iwWGjl>Oacr+ue$x1F!q-dQ
zK{*FS=6-*m{U$+!=`{1XmftZxxh03z8$CYDnS9q$jL%cs^!}FDiyq!wFn^iW%wO+M
zpMGEYWWLyj(CwwFn{p}{D<VD}zIOF?o9ETu=dXX<e0c4{!=tB9AH5!5TYav4`g(n_
zjhCJW*L~mXsXSw<6VDWFxjnW2z8ziNaQy$FwH9*givt_JPBHu68m9Ymn(m|0t|_YS
z8h&e2`t}?uKRa)JaD}<kn|mj>hgNp8sj+1*%v;?T()`mi^uPjPd7DJjTbW7~K@FN-
ze6smE5^*OFJqwup+$TqCU!H@QT;Q9-qAHU-QaTeIvWq3cOW#h@Wnk3!@F(HcCM{`)
z&RhP^M6(~dy-+r;3^yo{zb$nq*_c!AcTw<$DDy+jS9lNV{ZKJ4RsFW8<KLgqob)qp
z$_&iGxy>fNGgtDNESPoa;~(9(mydlGU&r=VrE1=G)=HxbadT4zIX0+p70NEO@|wk#
zpupI(b@AF(PHVfE)j=H54!suh{`*X1{=WKA?FybV?LX2_nI?8B3#4c$TyItv@;6B8
zZSAz+;n}yk%dJgr0)v{s#?`!0ZYv*pbNKJA__*g*x5b<5p^Ph>^sOuF4)@nD+_5A1
zQI`no?2~(=`1XE0wmK&<;nr^hKE)Rg7BMZWSok>Q-kTd8TeS4}vpO{%o7hY*=W4E1
zW)|X#tL62X`AOo{>gpB!t2~`<80PhC)vY@vBe|?_>aD-K^s~ONF!}l8=#InXhxTY5
z7gK0D9?r9PLU8_PxpvjPrzhXj*Q#52Yhjn=q~A{*J9pm7S5db<z`Bml=z!R#4Wem%
z(kCA-a@Lh#n-Y7^B*=WqiaFMix%c0F3u-TzbF#TCHvD(=%H$$V;ZIjr?RYM;Dfilh
zK2fa)GVZfJamM}C`>^s2)5%E|2Y5IbJyzb$o2;Lzmfv)*{jHI1`k{=C4ViM^ChjWo
zKA;uZ_L%u(N}5Wp!t3swHTfbI8#mQ4uCUzb9H^xrdb;_;l<zmrDBrX3bu#Tf+4Ipt
zp}=$IX1Rx{Ci$PF{j*sQ{^rSk{`TXnW!{yYA)*#P-kp7V^}duGv(@!Qc`66|&U5gJ
zh-UG<a^cLGQSF>CO(myn$G(5xnC}1SdcUsNPvXSZTbon-?n(Su^td!4{lklm3D<&`
z%6kQeN6R_(y=?7a67`v4*V&$<7w8lzU$j=8=abl-M3d*Gb$bhI&TH=HR#;GADg5oJ
z&xsoo(vmK9)ihR2<y}&)pECXa!;6lEd?F5CWvgB8icQ(E*x(bZ<1tB_*N^HCNgthW
z*7`bu_3zTua4nVl-SvyoI}hh2D5t*DZhNfvwfC@==qI(QVI1Ek)n9g8*0Wh*W5uTA
zCyyn~=BYZS`Fg1@QSfXi6i5~HulhVUCC2)}WY&r#nKQqBA4v*i2;CU}dbY7kbM~M6
zxoQ?!yvsNFZAyL<WdCsWs+@%}GZRvLCb*oOELm$D=&#b)w~KRze&j}3r3bu@!Yid^
z`PsFv9|-hOTRWreT*q}ikq>N6jqER`R~$WXeB!L+#>OcoJmOkD*=Me-4E)D)<m2QU
z4yiA1{E`)rPSucD@xtR*%@UR)?<#C&tlvFH`}`A=qXJK!2k>y_FAG?psk~EyW8a(u
zOI5<AMZ~#!^M{>U&Nk<9Kf}b0pYvB&8D;SO%-L|QcgM9}x2tB;1KK&>h#%uLuTj-(
zpYUGso~OpPY)5Aael3k;HqO*dU*7gzH@}+Z%)XO<!pwaOY8MtuuBcTkaK62Kxt&k0
z#kWM?_>_!CMRUcMKC$={@+tfKRp+Au>n6@~oyfc9sK1>3Kaq1`A9ze8B?>0-n-p6c
zHyXXTH2db$&GJvY&lb2&ZE5uF4AlAb_t87GL*7RnC#`J$Ahpq}$>8mx<r*7fcB)&v
z(KAr9ZhY|Lt~!&L@FaPim6s2sebk(0@?c>@=wa3E5er0qifnS#@;K<$pRs0h+0OfZ
z9P?Ehz0PX3oOk#f)!XuX(WaRWPLo+WjgmF4n9Z&KxHMrRXR}K0?j`3kpZ+X7-?yOc
z#ni$x)@#^qI=C%v7P<F(%G+Brf<!kdT`K&4LV>yQq2I;~F?Oy?FETD(t~`-mA@Dax
z>#L>(%WL)H&kAEYw=B$GqJF`3$-&}<hh`WZ2ww11!I1xoKr!d9pW4PuMjm||-`bjm
z1jk9F?475^tmidZA?TNil*eX;zN-<;{Vj9kT4h?JQZ_lP=GkAuK6BEE+UH@_R{wtV
zy9SvQ#Vrc{y5ZKB=L-&AnR@t4l-PG+)z*#Yw=k=1uU)j{y~HGm{-s8#3Xk3j*XUjP
zAQThIVQKVNrPuvI@evN^{|6o~S}a#?r)VekeS+DQA3KUzwi}%=Fq_@D!r*F6kQLv>
z6Pg=09e8DtqdArBmWq0$h|TE(FB7)BV9arC-;gSI=^jU(+GC%k2~4tcUH*t1@%s|-
z=l=9tE9!EdxRkw*uKXTpCKXa~R(x@>!3mQV6ORd*0y7IQ?7Pmszh1_}O<DiO($AOr
z&lw!h_j&8wK11h4;s@_@w=Q?AeEY%Y2Sd`TcHPX$3T(`h*^1>y=BIde9}oGEnJ{zK
z{mvQxCRatDT>gH=?-_dS*;94a{oVO{*N)g7MWIia>RNC7zIOHC;kK&*?h8{z1#DOS
z@1JI?k<mWwY3%BivFRZ#eY$V<|IvwykJ)F}bYj7kCFQ-zsu4^P6C7d=aXPQ`*J_)j
z(c#Q-+M-dQVg-Y@v&Ys~BHqi`4yZ`${*3sUDyKEuE#Bx*zn#;uM3zkN@?(F0KIb$u
zWbv>GJv#G4hUj+-<q7IGYW-DKv)PS`nV#-A=a(=;gK>-hn<@G-(+U@#d9zf0X0FQL
zFX=MYzq&pbIJhgGxxSL6<j--oEp}oTp7HZ%FuVCIp6p`6kU#C1Kj%wfoma_KJ6?D;
zNBuW#{&m^+vg_9t`#+qAew{trGVNnd;+w;)f-;LfE}q}0yprww-zBGHdPKC6MD61E
zdmEp4ugfX<J~7B^?yarAcjfS%Yu>$Q#qw|6tT`4dgdPWY39s0mBwHQx`T14nR=37i
z{Eht4J^M;s|Ia^kYK~0%W%WlJ&gC%tvSZ~_)=pid{@{bAn5c}LZdH(sS-q!>U1O#V
zpa0Lp^BLOj`#uVd7T?YLH=+1G%gUzahl?ke?lN{~@M)C)&S!D+)|LxD3gsppa%`VG
zk#9M7=CKBYh0B(m-u?Dk;}7qBwXfgJdc4=SHd{FV_Wx^b9kzK5E<vHc<aDoZ`T2EO
z#x=ivF<WAn_x@?Q%5$V4I#cW8X7>HXOaGPY-ER={e9ow|`PA(@x0UsuhVNdL_wo5&
zjhX*9PYM5dJLyX4qr1@?GSsTiFKJf%x|i?epUTqS<{noTr^jA1l@F=BY&7t>{q)Mm
z)2FwcopJK$vITYl$!q^?oBw0offg(FIXdwtx_=wLnlR~GXNl9SI@{ORy?<`MEckkE
z$4!y9PxKeAUi9q#1ka_4VXEAVHyz~PWAv<S;WSMZz8G!82XiM}|8#7f-YHd<33tNG
z=h>8LDy)qOzBBFL*O(u>_hioxySc!YH*eO~FPB#2Jh0RHe5^%KTKKx|Q_0tJG%m+>
zTsk3su6)JMTiU%jVo~?)yyB0Pvi+In?Oq$Qa7)*Lsm;vutMrewFW#o7z;j3F-Gw_p
zj_qLXnm6U_zuFa(QWej?5YIL4E1O}?VVt6}N@!b$ulV%*+3&LdA6&P4*||$Qr$+ml
zG^#v~%bc5(&u`Y7;4M?;quhFXWkN$vg^St&Mm_x{wY_zHvSE>zwoa_#yE3cw&d$Z}
z`rd!Cy*hQt?9_Wz@8&u`=>2_S-=yi=mDqBBzxDnZY3O^b?z+tTDbvy%bj~_#zAEM}
z(6e9Ug`J19`!Vf*+ZgMd!WLAY=#ITDBa~2WvHV`p@&oB-(vRmpW)eKKQO-uXZL`=9
ziNeRx7sHHR*&JfuEpvgR`qI*aLd$!s=TE%!=4kcRKWu65%`Yn+tX;4#IVMv6E`!t0
zYn(3yIHta}nImI1`O2bQ_tIxHu1&kMJ(2xvo0jbbDgPT*`S%vxH0pE+;?y{_w;@S?
z(OU)4w72J0#0CVejy`SMAFQjG@{U9J)#+|=i$l)bzV}0Zc5$v-B37Gq_~H#!uZ{+1
zCV@FlXU(IcJPQwGHhV14?SFko+}rE0JM+@WhLzVt@2j0zwtA*@`IE=e|FrhhYp?3P
zukn+il=WqW%K0PP+C6f2-@msYPr||Aj_Kn?i?&PcasGYqnHXbQ#XaWDZ$DX0kesnL
zgM0qlZ?@MC-And}%wJ*|{qF~ZxJ3EujvD#mKdP*ZR$qH}f7{?U<5r=1^^&O>ft8I%
z=S(QGf2WWteuLTn`yO_gr=Q%;iRZ|q1W!Ac?y+R^E$8=atB&iW-A@*qB@@K6O)Kep
zd`g6`#ahw(`iy_fd>+{!k?^i{|G89zk)Kyr;GRzHVnr>jhjVf!`<*qc*!|u`W$CSV
z?`5UtdG61BaP|ERLzdmUcIFH146SL^%~`p+>)nU<{wI{~&hndPqrs7L=|3yux)3hk
ze@&h5x7}ggUo<;ykLZCvCr`+k$F4eF6>v4?;l49}-9k*?JM<cI9Nutqx1;|YeZMxt
z1qNQV_sfs+p8VldsLb!Z&uQHg#;^TPH#M!#PC96PrYpV6e#e6Sfk{(1vn7A*4-VY(
z_y<Ge`JEC?Qj1G}W^Iz&wX<Aq(hi{uQqyic7MA*Ic=Shk!!edXjruvu`TrZd-|umI
z4<nW?x*2GK9KDNfZeT`i7k#VL&AvOwKE}oyUg+M@(586PCiRJ9pK^4h#>S<rJV%TK
z^lt7x+~M3eYss3E*O#w*W-4>iP(WuxZ0wuGyH@R5Czt<y$LF&9_8%Ya-~PG0QGUn7
z`R|%EN**iR5IwFgKYvH(^opB)v;J=C{+towk&q!cZ}y{GAL^rO^QYfGf9?ObcPHn^
zsXo->xU1s(=kDFZtfJ*l--$opy<I>4?%h9C-?yvJ6Zm_5xBkVy!hdc~eEsb;3+qF@
z;>{Kv6X%(fZ8o^0y6<_FR$|dRzF%qbD)WlZtbV5EF-I;c*UD`h|DA6(r^^4`3!Cd>
zF>_l!qtDz$YbB>jOHRAb@XP#<`69h(SzGiZzh01Hi`%#R?Yzg6PMw?`G|gy}{Dkc>
z3>**MmTp(LUjF5IoOx;~^K2WX)#cUpOBTPcy?=I5N53EUN`vV6F0BsLSLJ^s-z(tW
zVpwp6Rqo9M^U(5?EBZ?Q=X)LG*jf)ixcz?q0k^sx6U-CpO7p)ZKC`sna-t|{%0HL?
zymR7R3;xZU{*FKNxXRp)Lt;y(Sbf?m^yt^C71tj(nmstey7pV~_3+ZOD;8$nuda&;
zsr0?`X<AKE;1b0Z9C~HX&e={}yfgXB%5&VYk2W&=-j!YwSFY>qyxh9Y%C22c>xQw8
zMC6m@fA+0fy>HWDk0}@a75u)d-S*2_@ASPoYbEb#v*%vjV)VpeiII2fig5D<VM{W*
zkM^9~z3rxzc{gjsl4-9M-7Hys-UK#(EVh<7wr$A|-sH$s2Jc@tLURwthM4_1$Hl?1
zGn7NG<fG-|cc1g_oX|^LelFErS?txzOFOqs`JeuT%~QYZ(<By|gIkyWJA6UJHlRD)
zuzSw?(*K)&f4J9e6T{mx$9%J9-GkkULd@?oZd&cXZpt4$W1d3UUyTim6LjOno*zC|
zw3=~)7~6rZtqT(iRz{XwIBEajYvM!Zud<6*KQlSOVHt4!d2OfxkI1G|SDYGGl<Ry`
zDLlof(>0@4;!Tzi$Lpk>{2TmN9Js|}o7+-gFSTcyprgq9_u4;yHGX+^r%_E!VUhK&
z#XlY<I!L>oNo)BVAnU)?E^FUwjT)C*y~TN5-!#k?Uc9Cu5X-;fgXCrr!9zhTj=HDb
zO{f=ebrUgi&wu&fFx{7_o?#8w<SCJ&O-B!8_v*?Txa7W;m?)mpEBG!|;Bw=%&2OvP
zdi2yLE&TsdjVbYJ^R$&EEk8r5Ss1RnD}<C+>{~cTi~CMUYuH;p=`P8gjhpUIU+!~#
z_hh#fI;DFnN@qSf7V69TFHOGcRN_&a`wfjZm2|!(PCW50y5@!g&zus8-(?&belm^E
zCh$Ji^>Zt~6*0MG#v)eb%Z&yHKbS9wU}Z}GcZ`pBVg25fcK2U>Hh%XpQSk3OmT%uB
zKPh~0zkNLTV&I2qHL@Su43533O<LLY$Ki{dm4^6T+w^m)`=k$E)Qj!DVQe^S??dZG
zFHa8LtQ}kC7VY0<S>~&tYrcPmg^SAN&dd;psq-BkEV*+gebK&*_aSeZ6#kVLw@*_o
zjr${cyT$g#RM{kvnoZYkrYzmOIIU*$Mwb_Dj+<PQi>4mSKD|WTYgSC?rF=7sjS5G<
zH%*wa(XqGa_}aLfHJiihUa6&Y37ZFdHN9j!%G0CD>ha{1(uF5~6Ik4`o7NuT<yf?L
z(KKnp3wJcPuDqeJF?Lzu*W~O6T(TEcmrJhRqqE+A{)zk-i^Pwp|H?|)`>w|3)x8DG
zyKZE!+wk;jz}Gk?{VOl@SEaKso&00JXkLZ6%Bxo2BI(!=dG<~dwc|VYbWUG5kwsmR
z<y+}lK|x8kKi6I+F}R&O$E+jpPm<?<oK8}z#l0BsZwVHUc|OU=7c~BO{Jru0S~Xoi
z?+LbVb|3xsLhb8u#-qHA4r`@1WjFrN%kjPEapcyld4<=S_Aty|lk|M+j%Xi|4NF(>
z%W6Njmrb7D^o;ZGDgW1Q`y%+~6&Ihax4-}C*0L&_9?7Qk!zCUYO_Xn(Tl{Omo%x27
zCNptpe%f_S^;LyL#B7-=v*1rTLQggxc6ZnzF8p1iKE;OZ){U~gnX}z>_i}AA^01k8
zd|^}Yo#utd7sxN4TY11savNVpZf$*r^+n@d4?eG`(A~y;xIXk?L}bMNMfMBgpDZl=
zekeq}$H{QIbjMVUDXSC~e`5NZ{9;dIgl7Gb4Dp)ZPc`Pnc03B0!CfnIclLCPclxqc
z6(993p83rff0FT+-^uv4K0O6N<<pZi%vapzVRb*&)nmBT?9iXcPn)>T-k9sZN1?lD
z*CgiHCEHcb?}?u|#c;V)zIc+V<nO<W{wgnfTpFC^8ONv;yfEph%?z>N*A@awk2U8r
zZ*Zt{%;+%Wl|C3@In7aG?#~DBz6okDtDXHZ@txAPv&>7DU9HvC7CfFH?kwD0wrN)z
z`;*?St9G~^ZWCYkd9jYdx81TS%8KSQTDRYu{^-_C)kl4EV$N=7OBAq?`M5tqezuH#
zkI^6d`-gM`f6i2uSTH9`o?*)Y*24;uTE&A^b-3fZRBxP1eYm;$fY>Jq?e-%ZU;CVC
zI2XnDqgIbyW#L6-M)8tUQPPKgYR!Ioamp-<b8A9RM;DYEL~&WFhNVt1OD=2kFcW3)
zQEa#py~E=8S6NM=uR$Lp+a7J|@i}bKe5#V+|L42A<qds{%oojM__Y0mbT_wuV(abY
z(jR-c?jDeDjW6AHZ1MG!;{ON38q*~0Zy%o`)OJLTXU@k~f#M?vC;fb1D|(K}Qs?81
zP28Q9fytNtPjPZHh-lC9NqJD5mm;&7PmwR_qEd5c!s0m*i*4d3Sx<PI$a+@hWOzyR
zpWw##t2Cn>|Lwi|B>qWNq|I~riNzCgXV!DN*IiKmr)V&_Fjaf4R@YsFTSfAoZaK!4
z=iLIo_e=@4bv3J;B(&~0lk<r;Cq-;5+(gxt|255+<9JWYkx{2aisy{b_N0k(PCpV#
z{wrktB<A3XSzdlopFXTgoa}rwX5AYukEyY<xCNI!;WThutG#!^4)@FldvZ>#W#MN2
z*jiDyLrKm)%=n|gV#SX|Q<tx^cvZUPoY8Hsj)~{l=T47e)A<q>xz{&`Nl)g;rY9#H
zUofz@R%;gfuUucuUp9LOyKsZ_^gqgVE+_l?B^8_x2(fj}UM4ATRp2~fp1jLBe`X0E
z)-0n1e|?mmU-e~cyYQ#&#GNTUEw%>>=9^pes+pBejr}2?G1K|O1ow_3ipTz%8wvjI
z*PRwExF|q2$|#v7kduFL<Fx2#*U4)pOq6He_Qpj+Np6BimA<CrMa7A>heJ+eZd}sb
z6(4nY!u4RKW@%HSty;M@=KpI}c<orSpkMO?)BIYqnywT4r%SXZX-&}m)z5L(KzhTA
zM;qA#pENB{?QU~Uvyl*=u$-$Q=eE3$wT)Z~pO)*Bk9+M8-sGP(--KuCF6BKBzni9B
zHK;P`ow(oZSi?jH3CC=~Uw>mbqA&Ja&j0o8;*;gfn;Cj6_NlIDxR<-+-O}R{IwykI
zC!L=8{>&up-4`Rg?G7pbv{=4*q9Ws7yRsg6<J=(SBUg4V{E`^Oc>nwq@y>L%nyU$O
zC2Ck$^({I#*ZjGbpWVnCul)X#rP8D(%Q}(5>OXIsjI0+f;MtpH7@zXu!iHML4_9By
z-`{ET$IpbJ<xXi>x}u4&;kBx;s0oeDE4rp=F<dsYxi{H?>*{-z^WqQwxUd&KTe1GL
zu{TeNtKXEF5vI|{_iLLT-qd+TIWqB`Z|JQpol`t{?!J*+ZmXMYwsN;Zzse@Ng_C7>
zDx7!Fp5*d*V}zCR%W|841x-wkPdc(qN=@jtT+;CQa6)~Z#G7tA#*%8W@0lAeeV>y(
z*Rp<hnc$<FoGD-bT;VOX%iT~_=qjRiaC?1ia(CzL(9P>@PA{9iep4OKP39b-pr5SL
zcA;9!lkT_}l|1t~?tJ{4rS=n#qYG?#U%b5W?Ds<6Pl8pPn?zKOuDg6~aVN*-r<0j-
z59x=0czOHVznMNJx31aF%B%MEIB~k{@`JP7QxlxjjyCmi%oP#X_05ji<I3Z2HyoQb
zt}@n5%v3uq*{d&+vY5-nxAdy)j{P4RJ6;?KJS?*3%sz8Vg&(Jqk1v`m9@XFUq;A@g
z+3T0Nr#;wpcye?VlX&wxS0(xA*cDH<b<Ghlb#)Z@@ukN3eDcagM%%Vza-Xa^T(f1)
z^iNYhZ%tZtLd^c$Q{&w~o=jU8Tl%ZkUBb7&;o?z!^Czsm`vXNM^L%>~D=E0yJm*c2
zjc51CUiKps=kI5*G?z5061&TA$ZMKa{O_MGTS@~b=hS%gE{l4-R9E2lI{W9Y@$;Yi
zNoFjYWSeB6%F+<`NzfqTrpaUJH!s3po?AFMZ|Bnk{0oKJ{Ht~13anq}YZpE>&N~-d
zRFs*+F#Yrr?RQdd799EUDewN-re_yI1^#&EtY%8+F>vub@h7bQz=MeSmJVKP>e(OY
zrp0qHuaCR5`*eY%(HWBu>ARLC*{EN8EMe!><=g3@({Fge=)OP`$5J^B=EHIKzRT!t
zs*-kePE!9IS=cSJQ+=b;9E*O-yFoDy^A>ap%uH#{Y{^})MdkRtTo=i_pU-l`oO5T)
z(!9X@>m{#~K)JHWjYaX7Ur5R4H6L)ZlDy{Ozs*QhVx4QM*~7M<pNi-CY<$@$_CvGT
zqSUzbWGr7$YeRASK_$C~RSS})Ua5cJZF!=q>_ua@`_E_m@p2DVZE3syQStlA^n<lp
ze>_iaO#W_vYs>GVGeQiXGgn9(EdG9V#{3O``x{ry-??P=vdNm;3+$%VF*?6#@?FLL
zF4(ML_NFS8Fk6Z4OYd8(xR@><F*2N+>7peyF>bH7du`6gyL{ZAz6dYLF!|kLbf+n6
z0{^)md2T;$YeavY?f=w(LEv<{{*g8DR%xG)&9a*MyjLgjspr=}YRj!+FP>lhXPVVa
zr=@?zPCK*So!tA_>s|b7q1F0{XY}-Yj%D;_&3mycxV}fKFeZJzP2q1Zq03I|lxyNS
zO?r;YFFVSYcjB1Zll%V_F2!a4QWSkKeaUAo-Fl|QHr@s)X9MSFc9^xvFG%9sEcQ?N
zfO-8N)(nXqFH`u!?N9#E|JeBO0G6(-Ir2JS*a}(;3j<=ivTLIv^Y6F`)qP(t@kCYR
zL1Kk`W#ox$>yKRbEG9Ov%zn}+wJmMOJjGPGur2%RUawyD%y7}0=?)DyVq<GVO7Gg<
zOWXg^%zn>@m;1MWG;fsOv2lKGlSR>Fg&S}D^zHT*1nYnO)LXahwB9qrup?(rFxi+N
zzV)R(sy2K2{d3pqOFuu_y*+aar;_>Ep!(wC?@vU`pFS&p{#Ac^e!kwnJwLB=`}6;O
z_RRbFznTAZp8fp(nw@Kr@4IK76CT)PZt$!<|MgHv-zE7otZ5eCb1$1;IWs4=xI};3
z#QB!fk7q4E?5ll0{OnqjUCzcb-dmiP=T$MzIxp_{YDQF5`=h35zkBL;alLoAAAQfG
zvFB?;y=(SIKG*!{XCHT7EfL*)cb%o6;PO?*OBvq1S;&1<<JZ0$iH-fcy54Wu!It#k
z+V{IQeN#0{&KU44PhNCc-eLB<&E`u_8~;6Vc5#N~-|O8vPa@?O%I$WG3f*hXr`lZn
zierOhROXlVYYk~U^A0S%qIov(SNichYesvSlGHS5skJvvb0e=-I~p8X^DWTLTFT<p
zzay)K+1hvA60N;@<(tSio}!k!c?<43JTL1Fc<OH-r*PkOMoU=H1)Wzyy$p+-i$sOB
z^Z7#6n?LbpnB6_f=xxK*@a`SsAHAr#cW25@{BAMdE&KFxGwaKxq4wwa=eDo1H<+BM
zb=sm~>C07n=WW<I`QZPU`1%92JDHa4?v`<#zI$C^Puzs=Jl~jiXP9S9J2C6aRNj?^
zb;b9~n5K6(%~@2w=&*S8;$)qgFLPV^tyBa5SKJrhUesvlcZm6W?#9<I`T8%3?wmE(
zA$7sA|8e|BMQl%59SI9$j{mYy{Db?o$L=!=+Als+k==RIQe5aE(-hvSLt;ui$~#q<
zN@|NuzJ7jHRBRyYH(UKO>(d7pmoLmZ>v{ej=a-O(yRQ7-=O1rb^<4C#`iVocIM<yr
zOXICA)|!!h+<o_<zZ-ANJh$l8uiEG<cWu{S-m-VWtFXCWUYy#$NRC&MZ_~1!#p|DO
z{gP&t`<}UU+oa}c-)s)(vZR)qxUTk{P@B>5Q)T5!ajW-PuDYkWr2b6WHBmqPcuVl*
zuT2*PC9lrgx;p-aD4Xkv&|-u4jz3S&7Te{SF2b~qslY(MvQ6g9te^=Ayl<CGvb*28
zX~A3Vw5{@;r!G9$Kf9}yq2kcCb@%<mV%@an9?>#Nnl-J%>Lkax(=$plOQu9E{&L>D
z$$jPNcL66_U;Xjh;KEcRy4J@vyY-Cm_Mdxt9=|bsdH&*^ua~m2lzWBmmdRNEZ)H2W
z<}&ZgpPp6`viH|nM%@=*z36z3=eLrncZJI5HaFQ#{A_zN@SUZ-S<=4BJy%5K(xUHf
z_g4NCa_=gW&+OdJ&9`5rykDOEYEe7G&wFQ7$|giy(~*2=JA0ck&-uCEUH7hir5k(n
zTW#pH4K;$5%k1~usE+^o{^e`?$WQX(w^dr3FWx<ICM!Ed>)ML2w?9%8BRmRt>=XPi
z@mMANd*yp~;<k?uYwz#WwaPX<u|{T!`{dxGG9MLEP9M3Ya!z4YzTgw4tVfp@?h3y!
zw`R9onb)oFxnF-aJ!y&LY=}#BXH(>4em?h{qHKg>p6R!nZGvmJCp+Kv>|ZL>doiYV
zwesUggB=#$BDXgmn7ofg<?;#M<Q&%vFEYcHx=r8Z&)PDPZ^u#tFE#l-=WEv{xlHB@
z7Pi_GyVaiktBApL&m(s_mHKsA>eK%;h=#p5!Tlxg>8u+K?(>A^a$IDH2xo}&5Lzn1
zY`y#RC8v*kpBh<$wPhCXzVdU$X&V`z)zUuNVq!-W4-^|_&${WsIQL3b{p*MF2hZ<)
zP&zqu$vxwVcPtLs9O#-XeAqO7XIr_+C0?J_N1|4>$I{+)Pbz-KutoF4LPKqS-lIiA
zF9g`wKT4RY@Vec8WtBTUBmSXBX4U4`;W?XTt)4GX?QS^xn&TDGy>YTm>aj&7bIKpc
zJ(}_+uRMP15)O{etj4=rIr=K}ZqJn{D@ouo@VW75kFS37(Zc%^vTa^0xo;}`<<1O`
zjEUDgKTnsByI^?Ob&*GdeQIP_$eH%FGjiumYW=c!+vT%v>u)RQSDA%vv|+gV%JawR
zI_+6=gmQe7c-Of9QLvk$lhFDgG+jF&C%bo1n>mY!r{;n?O}ovDcD@jtW#X2u8ZDc#
zdgt+Ly={G|v(isJfAux`?fO}j39WKJw#TyBv-~;CzxZZtE%ReXMICAWBG07;wkgM*
z9Bb;gi0OAtRCLNT*!7IdV1BD4$L1?McRT%@lJfqkx@)}JE2!~#YQVz+FUG=Kx=UnA
z^EPMww!ii$sc+ex;+VyJ$EI`K@;}$J*S^@MZqt@(hB=beT<rNb9g}QNmN&NeUY_ck
zygT!Ig_Y-}i%vZy+h1}81<t(LcmG8he|wgR*_L~E+|G7J?yoyHO_?RfG*I(gWQ<Vi
z1>P6yzH2lD<Sgmb;yp24xZEq`ro->PI~(RkpIDyU)e&CKyihLn){0LG3VdSfeVbgf
z8vZ$#Ug<o&id`Y+#YTRn98OK8BR_hVcDt;P(#_W436x-&d}HC^dDHeOD1UH2e>F5V
z|Cr1Swhh4t&Am=6{i!3#8Ps1ck~LdMgl)>-mvU>i&fSvEDqV7NiO&&DpJaocuFp#q
z#CT$tFj=%dS({*(E;;GKC5D}GFOGUO?OO4yBiJe=YNHlwSBLX))%I4Y8Ok>eTK%R;
z-(4T^?nUR*wDd1`Z(H0wv6n^T<VC~gD`z+P^hxd#x%R8hpw%+-O-$^`Gp@S)UsClf
z6K9^_Oq|mz+B^NyUY7ZNN0xV4rm>vLlkN>?P)c=A&ntXfW3tv{Q99$7SFiT{esOVb
zdgE1rgcIRG*Cn=heGmwAH=P#1Af7+fpZnG-;qz~IJxnQaT&rlfNAG%Gh!?MaR<q)C
zV_wUyY5HQZMaOf_t;ju`7Un8_V8NoBbKazQh-O<{+ptv7jr(ZU#G_Gb+CI8Vy4QVr
z_>1dhr?$raTNYxaA$mUqqe>6Syg3rtnSWV(w#AW&Yjx*jew6sLtV-CY-F{h)gvPg4
zmUEKfW(%6WeKP!`T<x(X<iW;k+DyBw?)5D7d%Z%W_Kx!75J7`)P8oAj9|x{t-FthR
z*3$f}KHpY{-M_gy!~0jQUi+R^u*P8Lw(_kJVb!v(Cz<3tmN?!hklDQ`S6)5-bj-t~
z<K|6^uTH%4ljU@vk6VpJ?oyLUnVBjlmQ7MtvsoEe@TzKgJfG^rrLVaP`yAGG2>;o>
z+SF<}6N|3*6_%aqk0d+-yzk%9ymEP>(#nlOKT_nMZxdARzSJ$jv?fQNUt?*b|NLLA
zHRle=Ge+Il-h2ABw&i@6y$mO%nfk6wvd(Dp6KMIfe&X4E%4PSyCI#hQ3}Et~@nGro
zMGH@6w|-liU|0O&$gFHb^*LP^7wWpT|LOa<mam?{b&r#7^5!l4v8xMO3QJ43oymE#
zeYO5H3)Yu;3CH)%sf=5r5)eD*jE7kCzbmsN>+H|mwRqw#Z~lGr&cue(mBpVQUH&pp
zq&-i-eYQgXU4u^_b-w(be{b0m$6b=<XEvW@UOdn2N!6jAsN-k9cF+H6n!PVqK)pr&
zQ&8QK{>Y@3uy1FL%s(~lPrZMqd}>qSZT>_t+q))ToUbdl|1i(-nz%%o<z~_K)8^Oh
z|9t*?YG2?pw!~lC-+0$4`%Hei@49{5vAP9@4!bN=Ss560k7wLp@4^|aGv(*Spon{i
z40v=mtrK?b(>MK={8D9m-qOjls`lTB3vre#ve(xtoM?9;iB)QPzFxeyx3B$bwNiF2
z(df*qm8SFeS~Ap6WMDMn4zu0nbpF|<v$_87_@j@;ttsQuy~o*m(r;mTUf-u9#p`BI
zHPmgN7tCX`OoDgzkHu>(nbOUo8W`C-t{eV5Z|Hq|k+bcyi)(%Au2uE<*>CF44xHf?
zH2csObFnMo>V9FyeUn-rzWB;sxG=+i&H<j+8xDQp3=TT=-{jijix2DWi!Hr4&m#0@
zZP@4MUj;pNWuJ3-&JkbsYVP5Sr3HV}MfRIm@8@ku%THgS=V@Ua|LTn_)6vE1?*+E>
z+Bzx9-^g?|mz{Ta)w_f(X|0EECUBMNpW{1WZN9^~T-R^w`?*ibZzuixG)2Kqo4vBa
ztLS&o%(Gohm)^I1TQ@=cs?4D<jtDu!;$E%EZ~mz2oSb&<>C&~kZnj^N;m=amd!EC&
zXohw04XKz#n(31~GkMm;d$0ChDd@3ApEGI2d+RsnMHRlR`fam&jzQGUIfWBvp6^lH
z$gx;G$x%UDOeR+4T=rEj9^IyZSKeo?ueE;{vV76ng3u>TA1)oU*Il5t+2s0lGm~>Q
zKV;aQ)2_dk>NsP4d*b<x8Q*vHeAuwI$2XIa<>!xS%bwjR;(P7$JF;$xqwEs7_4T`^
zO&7eEP$fCjpk>w7MV6Dh!s9r${?lSe{k?ErovK0o)psVRI}b(7lh2rP*?(Sm*slY+
znoOoUBp6N|3+ZhrNjkWE%33GawDkD%Uwd~?NVNRExK`l$^dzYp=B(b^<O?i=zOO3z
zwo&Ndh9$N(+J~&ydQaZb$C;YN&GviQ`<)&Kk2ZdsuCVxp-_d4|m#P7lr(!Km$!be~
zJs%=k_~6p!nvD??ZYMb|INCJ3d(M>Ax85(+kh^`T^35M7>DGT=T7Ev&I#jCqM?LZ4
z>?KzkD>a$A`ESmD9CpXsV)EY*U!NzowUfT9?3%as)$3LFV$L$WYvtM|cty5%>fQUr
zH7{k4yh-Gm>pEL^_ob-qU+1svkXrlSA?woTSLv^0LZ|*r7rkPCvncTFPp=u)`CTg+
zX7>FK-aJcxV%KZ;2-UBQ_Kz(Zc*LG&|Cc_^_3w;Y@a^v<x4R}^UTD5+g-y-!ZuOfX
zb<&O(HorLIKYjnd0G+<}YjZYC@L}5-+J4~ol&gII-Ul+|FbTbm<7}`#u)a!Tc76Hr
zcdc9Y%$zsTr8P=+XUvs_2J!W>Q?hi`H||eU;%IM>>AbMy?~5fnRv5flyV%C`uuI&c
zzBz2C7U{EGD&ARkRJS|$+mmpYic_Lr55Lwqpw+%W&*R7*RkIk?FMdHLZZ^NCdKmSG
z3D@882oBD=8DMuuC2wAkU4xE#SIqszF^7C>Y!hFs)mS6HL#}AQq}-GK*O8u9vKORe
zRveCVSiIo0=9V*aDx$W(D18<)L1n>BrLUh4C%g^kHHcN8wNJn5^@i%%@4EzEH2c~{
z?JC|c-={ZEXpOFs&dk~kV&y#Yy9^EErZB#-j7q-z|H4kyS5I8C1v?r--)%CI4iFQ4
z{C$C7kiPHEMW5v}{>guB6PL!)@wPBV+JFo1c$*Ww%zJNi<mB6CppN&2+g_o9&P)o9
z?`9WUy!N%+XdAqH>+C0u%1%PpZBiy}DmSaI`^`|1Ve#pNS4^<!j)QLBulKTD_$0o&
zb^nitkqrO;x^56?{BTGit|OpwqCmIr&o_UK{eR!`7c-0W@3!cx(mbUV{;=Bc9Pj`3
zo7eMxea-lnpEtkuuhZ(*fO&nT8+P2aTkyy%`p>36@7{hE-@f{O-v57Rw!75VSNFX$
z|M0wO-m>{>9xGfQsZQ*eFwf$X&{8q054Q1HYR{KXH{ZT`E6?PocDa_5i!ROheteJN
z(v@LO`qt~-d|P>Tsp#_a`}arw|L|5@Z%=e*MdrJm0grY()`~c^r*ZazRk_ddwzj1)
zx1MOvmyMoW=-gXev!GLIo!|+*i0+sJOj~*ib%RvqUEqG{>UczZ;=0=vCl83*GbHx^
zDy__n%HPV@8nG|pXi=njUT)><Y4f&ijlJ)_h-G<O<e?M7L3-C5AE+jt_`K9L+BrPl
zs;^M-eo@w^Jb&(wS3k}E)u;V(@&r5mPrYyRSNRs#zlhSSZ3&#ye9>lyulMb(*_T$?
zGW<`PvEuQr#?JvWQX>}FN~#yjO#U|`nV~Ph*W%mi_rHzz_}WNv9+3aasgrr)&U%CX
zKPgorYnEx~grB;UQh96UqkEe|+~VG}2Tv<orumtxYV9>ILGDj&o7ZOE-m}i3CaU|X
zt|!my*sOoI6;l$+wB%MRrJvg|Yu&LBhEo%2XP>?3Hz$0K+^mwz69YD+IPUUfoVP9h
z_{ynU|K`L>&igi@$syr{t@y+29bWajY_zi;a5xnBg=u|g3Yf6s(C0-#Mk#@<^981c
zUFyvG)*UCrKAHbl{T+7ZxR;7|6|y7bSV~sxQMR0s>s!Sv+Eae9dscS+SLV>CZ|~hm
z?0uMdVbh)F&XcQU7x}fE?*CoW>|6bAhoUv><<gbXjaO5SF4(pvTDzSu+Vf`iZI%fQ
zmo_SAFAQNQ*j&cIvyv%v7DuT<xRK1#kkh%hYL1#tc<gghyY-l%$wt<NonPM;Zf-oe
z?f9XsJFea<X74_gYcKqPC!}eKz$?~Z)c_s_n}vHVCWWn-$I`}nVCnYE?U5%FcAD>~
zk=3hTa#HcL*4j(5k+q#}zZYf*o-v#$H0$$ybMy6$wvBAg5fk42>+ljha#}aaGV6hg
zv9z<!+a0#LuOA0oJ6(19C0lD$xJJ>0H}7sNku?-MzUBC`#z4vLIj_I{36(pOc5%kC
zr$+fsYyY}<c5e<js58e>>3_!L)8-i^X(8Jj>l9Z_h(A@XvClojWn$4Z4yl-`j5BKa
zH{bo3czEY#l?x9qYUXaf?Nd;a+-0*@`;Eu$W6RFo&U>I?vL*KJfnN+oT_%h>U97f0
z&pdVIrkchDzn;Z9nZ>95D)sper_K`hY2aC;dQj%lHoe@l3q7nSlzXmH5<bnJBe|IA
z^qTu8zA;ZI*O>5hjd_5(7Q<Wyt;)3J?~Zye&Sk&BWE{-wqQalU8}VsQ$&Y!}0>2E3
zb1v`RGh@rb7spp`{T;J^X&?KMtj=>zYdrs6H{zSNV&<IN20rXPNvYgz=f1qvSTfC<
zqrgX0&F)f<hdY0#hx*9`W*^CA*47<wB|8OfUpnSDcV^k;Ct+oh*Bg&29lykV(lF;j
z;nO#_<>%?vEwnRFGoG-@#<bA2k#oz9jGscDtDhMp-c{)oyXDJjcA}H><i>lq!|!~$
zcr#XWuDXGQVfLp_LK8OZRiCRCy<<DGT#<x*&k@C%phpYddcA3#qI>DaqJQl?4A(f)
zTRQV+ZY;aSyLN8Y#p5TI=rOs*eQsgb-(I%)<@PB8Wu>bXCirJgonU!T^-7NKEm`TZ
zNiHTc6Vuo1<$e5d+3Ky!Lmru3zV7$_WdFD6>tBU-WX#xjC93k!dv>Ad19!iENIsYJ
zFugjhVB@xI<+zOF-0L12Gp$>#{66Q-{^H$>JCyW49qm+gbPru9e!%Nm*=yfexmml;
zoK(0puaDbXyJ#QFt|VK|*gTJC88<}|o@b~#7il~dT#=Vxc5uJZHub89i}@02q}OS@
zx_0B>7T=36mRUAMyRnO{DX3HbvT<6epS;oM#<>-}HW94nG#k6_eQu2jEuOw;U0I3T
zg;m@4TuHdde0A<yE*`CutSd9(osJw)d>?&z=l7KB_7)nw%Ni#4+`XH$eYfF4)9>DQ
zMO0j)7}rX!J{G-F)_A+|tZOBEFI|cVSaI@MTds2X+PN23XI#);_}f|h3FGw2(`yd0
zEfO~lK6<E5`KVB*{Vb)*kc~?E4QsCU&*x{qqGIs>z<aS7t?FX6e)}KYxZF7JqP|M|
zSML3Gm-KU1yp@vOF;SiOmQk2-RNcF2o~u1(ceV3rEfe08I>W2!U~jhjmEc>2vu5)7
zl%8&#GC6Knj85=zFO4^sAM%_t6<fLN(W3>sBsW?oPF2}w{C0veJG1e!Tk9rlJQvZw
z;>Y~VS6@Y*pJ|<UNXmv~JGb^r<M{M~h^YT^2Uj^o?Ftdh=`8rQ?T31~)Ga%iZmu&@
zuV-&M#qe@Z=Amg@UI!ieY;EN1!Nu`>zDC|{W(Ma~OPua~F}_qNy7R4&`okqsu?05-
zO<tBPcPN@wXT9mF@#%Y3uUTist@-%luJrkH^9o-tQqAW07j;iM-0Juv&GdxXO|gt~
zCw4t>DmQy6JLTltmTlpc-@Dj*{ci@GDY~&}@!5?ViZ4k@2c_M#bFXJ;@N;Q7XPxlB
z>DR|p_TC3AGHYfY?K`R@wAyQekyZ8_)^7C*r}<2)*{j_GgicQvHQ&%-U>+8#u}R%A
zc-gl1>lmM(lRNt(ddbn!$v3&V*Qm_4sJS7lYkJoz!pkJ^({z7%vjemG{MaTv?Ap4*
zdd}k0+*a(LzBTXFnf?1QW0hrzx8l`^?;AaKTcy3>>v*T)fBg6T4yGxJab1l^UM-$$
zwpJ%&<%CqrRRvK6GySt|VkgV5d23&|XRiLDWy@I)S}CisBwxJe<fNC}C}}+>U%XXH
zM`HJkfX{+cPFwK%e&m%|a`<G{m$@%ba!LQ-+N@^1cXJ>AOx~Q$tMrdaTdi9<|Jv6j
zo8|eQ?sc+^fAdp@>sjW-sz>WHZ6ETA{5-^L9Q?jf+t?x~?}mWW$$LgwdrO*M9X|M|
zatrsopK3o<J~psl@9>kJ$9{9+bAFq&L-(FOx%frSrsHB|;O<?g+t*H9XO;DC*3B(z
z_nzcjW`DA!Q~bAJ&eTJj&EId&ShqGHA>~7Onc&Ze_Vx)YS*H~xH5Om?>y+t}+`0Sf
z%QuBdRnuLBpQhfr@p|?o-(%{0^2_~M-v7S+&*9iS`QzN2|GKXk-uwFh)9n2x76?|n
zKB*E{vt-><r&AZYS>+hJkDlFZUOd@_(Uxt_OqN~kaVuKpHs2GKvj}R)nxXyW&E`YB
zj_W&rc&=ys_^EU=7wbB~SB-O9T3+sQVOsLy{L+j^Gdo?X_gzZvid(OC>xjP8fv@4V
zo8$#lwthL}@>fyB^TQ1%*&fYbKQF{v@a!s^r^G6v+W3Q~>zT^?>WzEE>=NG`)!J1g
zq`LP2|N2My3^JXy6Q*98*SE~*e$&b1(CS9F?Rjg$=N3Ngz1a|G!+fIqB=fOD8<|vE
z&oUf2y8CGJD*5LQN+KODKH?wsKN;OV{??KIvcB7LE+zk#Pfk|VAL4wT%cQhSpELh4
z=MLdp+)Aag??Rrq9$?aBtUt8rkezm4qMBsdwHFuOMm;ODthSPWZ&QET_>Pr)>yx8X
z?0v6<Gnb!f<y4sW?dRqX|0Z9nVY}DA?wQUW{bj{`GX(>Rb@v=RDfGyzqJ84>hG?N*
zM>nP(ovmD5e0O8YmU9pOa;AMv`n1mNd4-_A`Re$db8_Y47jHg(mt^%^@o~3yq57l?
z!XLNp;68Zp;LZhpH<KUTei)OpN!#qpY0f=jm6KC#BrD_l{Mz@Neo=B__ndQ;7k+%)
zdV*O!dX@IX<)XE$Vo!eVOFilvC$Y;)+Wy`0m_P1(|8`f(<cMD`F}-nYioI;k^vj)d
z+E0~pPoLdB?VHmHzZJh$)-kQpQ_GMOIQY|YUc)Mns#DX$cXe*4x^cmkrPys6xBaZ&
zU$;M=oyKtW^rhJOTS`r1Sk5TDPTFNB9oeX0=C`6gd;aSmX|FE-_?2|!Q23q?Q?C0j
z*~WhV=#_Ji-F{qe;_r*l+9g)AfHfi7RpZ6MZV4lX{JCK_XBCQD-<i8HU0k@t^wqJH
z_^w^2SGqnj`O}^BM&rbuxglp4pZo44>$~!ApWM9{=RRJZuzSXp$}Jr)qD~y#s4jBd
zNsq0a>3J7NRhjtOvUlG~&wabde0lMX-7{9LE;L{EH|S2SVODkacgZW?F6^FhtMZCR
zq3)Lt${)90XkPCT;PSBADYC65T>ibCe3f``sp*$vTjII)o?f~4+7n-k+Rl?8yH1?=
zTs-H|x_a$dy_2iIlnXmD{oXmR(ueC%YJrfOdt%${S*g>WP33NT@?_n~yLazTJHGw+
zB|Cw{il^7uEY}%0TyKlA<0z>4VZl08?QQe?=7Jd+`BB#ARX*ijdHUpI=dEumxu5?z
zb|XEK&weKN-9pDkP3<e|R@}a3SLyjfhP`0-2fNAN40{(JuyubHeD6_CMCq+>f){Gn
zlpI_?ckz$?4|kU8EL|U;VY^X!!wP|V@5h<XP5)^z{ZBdLIiuR>4@=UgTMWw{Kin!2
zw(B&f)}M0|_0DVS@g=H#DY(1CL+t=3Q`=){CceHSJZ=vkt`>a8@B1%Nl<A1oZ3`CO
zgidGGrppm5^+HcuWz8~Enad4co%|QT$n8*iH|6zC@t6s(Pd?7bboga`nZ4`V`|F$P
zRpjM7HP@VAT41BS*wna2Rwcpr@c9WBnI~%K{+eBRX8)NpCrfRv-FjVd>i;=TTj^#+
z<&!CTb#qJwZ)?tq?ap+tnxfe--H0{VasI~McgLM(JpYk%;==jbQ+poo;K^kcdw4q2
zIqb>D_!$=(6v`OQ9Gf0GE#8{!u(w%xTTlw8+q2slzc1f7*t7eq_n`;hRTO^&mA9?$
zPRZYKjj_uv;nuqKXFv7SKWa`fnDqRRLc-%R{l&~nG}rCmx0=DmW8Pc1zi-v1drvmh
zwVb|Zv15Knz=?bFJ9oY;wM>zVo9?`9J9os7xs#vI*<(MK;qih#S@**`b}ZW!o@3y6
zylJ*isC;?#xncn?p4t7L_isL1bb|lDcT<Vmc2y$J-9KE}tv2`Sx5ITQ)9$89xZhi_
zPF_<&Xa0&B`K=FmxT0V2w)(#Hd!%q|o3n3Dd(D-y6;Cy0O;XyU_Iu-pT#ro*icOat
zUUT@%PWjKQ>G<v;W``Sjo*R5HpuT@nR&Yr!m%bn9*g!6Qx6GpA5(Nu$1NcdRMy3Yl
z#Lk1ijlNxU+d`=JdiaCFXRU|+22J%^TU?lyRkm!?Hu*C3!lfCV(?YkoPWL!_q~3nH
zCYO+^*A(5{GV|A~W-y#|dtCC}k$Hi@VT;daI8L%0w_hn4+Plf8LT%?USA)zwi4{v*
zrubMbTf^zYwruHf=aXB6b}bk2I<au&HKwJ>w;bY%r?8nfWj+tcT4rl?vF&BR-3289
zVjOJ=Zi`H|rHibRyP;#um9XGY#^ISyH7@qIt_W<5?7ftk#_Q6YFwJFYs@N}^DHbn2
z-}^qtDfr~f!`ghd4N0t4p93`aB+L1xUf@xSWPQAXTl9f!zuuBWxmd{uyh2O4_cGL8
z(-K>7{*ju){Pw^m=Y{1Vf@ccf23%ZGQM8d!MnY?cJF6|H+>GYmGaB6IY}=;Jq984y
z$PyLlxBkK@#$^K2b~60uX56u7(#JF2e*O#*kzH~E(iy7ZRovE^Y4=#K3I`qJU`^Pd
zSMbAG;~Z0I#MA>z6XrD>JayQI^Y4e`30Ecx>SR;|H?SQn3d&B{^vQOiVl&^26+TZH
zGzEeq@>j^tDqwAybtYV((L$?WheAQjWZP*`QD3yQo?HBgi^vjK@{-dc@<6EyJ9DDe
zRRu*63w43?9bEs^N)L2$c}hB4>0D*X65)TiLjD6|o^t|gr9+Wq6;n*Z{tMcU(}b1<
zz7Go0@0+tqz|v80%B+-=QIVC6hm__nlR8<MG+CA3yDH@8txxw>hwuIO)7MJI-|fv+
z?Y64ekbXTmc_X#R|G9P3{m;u^ay<6y{U-Zk&2QcumJa#+yTm4OeudM&LsJ*e_ZB+8
z{BY90ny0*vE6S~A^PDQQTe&OpPRQRCZ@I*aF6_MN_m1JvP4x>?I9GM2{xzSnK7Mm^
z$;8Y*46)tca(4yPPCl>p#CeH@$>S5L>sGOJPk*o8Tr(rk`rwJfU&=jof4|>9?Pkge
zyV&LBuE$noe|_}zb=?2QCh~LARZG6v@3T&wZfo=B-{bwK&$qv@Qk#CQv{wIPdNxmm
z<p2NikN@vi{HOo;|A8N?_dd!$VU_pQ>xX#%BkOHiJ0dH&tfOwdaqbJ9!v3sHcGWzu
z&8DH%>1;D4&TaIH4M@>Xn{xRkx8c6xqz)IUKG{p$hH)Ji72K}!NIw-%l9?^hu47!b
z;#a(%otEIG6Bk^!F>|n&ZT#2%M~S`YoAbobZ7Pr4vpyY8f2#BEPI}2d<5;y4&6h??
zz5S*u#-^1>9@+l*N7<*x*ZiKOsf(BFT<GmK{d`QZR(<y?t)oZV4jfloVswpdW7&14
zlrqtcTV~cs{gylyb=5OUGlq4;mvg0WHVW<S|Ma@=W@Ej;ZtX{@GSa<a(evD|W{OB0
zyPdg5*Xm3@=P`Z3qmQ%t-_P2&qTuhw=~I_a)SSHhLaOMpTP>ABxiW6Cxf*88WpcT@
z`=_rt`Js?ySH_lSQ}y=0@;&gsBhO=Ya+X-2iOn{Z%ky;`b0sFb?zsHy?c;BWHy&Nu
zeB;Nq%(r4f>jLvX{#bLe%dxm%dNx<NRnXSn^XIk%9DOyN@96DI7mWTbu86!;ck$@0
zg8Uix9v<Y2x&3I<?S;`9yDI)<8^>f`-t?4X#^g=R3-4Js+B5#h<UT(wuRg;qP5X>g
zGWVhTv+pjews>nByU(m~c{WG+F0bty%f%;bT@#mQQ6hO<b;(lqT^F_l{PPWdn7bv%
zQd`&f`v&Lzw@jBzo2Om&>~-r(b;JDrS;@IKKdDXH{=(s!Q^(dLmf08o?{K`Z``HW4
zZNV4bbp5%sQ+(s`vofEzo!qs%;$&3Y$wu!*Qd@0hzGfOfTD*<r^PHm>FN>FN%l$F;
zNW%29IVPEpB)9Y&dRY7>=EQ%I`%87bPcJ$=Y1+cwAv;ps_B}kXb>m*uk9Ov9vMZv6
z4n>80wwS5+A;<1!`jR|`pDz2i7MHcny|rV>*?_I5*Og`e?SHB9I<ej6;IfrEFOJ7e
zdh_-CCZ+kl?2&<gJ>qPCnM(IvHvf73=ee_&^nW?VC52D*yEu(A)ZBKa&!<Udg<nqF
zm3rI1Iqw}leV^XpJyZ7RxyGK_6%s0G&vQmG{8#ng&o@IO@BXi~+4(l{wS{cj<*MMD
z|5yGm{-3+m@yYa*GYqrsJm*`9%I*&6+}`CWDRfxY_>@Xq#fiBaz6$UiOP%&%zwf8Q
ziM5q8o~7EIc)!X+j(rl7;T@rg$7Z>|t`+!eIWKK-q?N3kAkVi~B{!578R`kfy=h)1
z(XaMW@b99n{!P3-*0T%NzG(3kTJc4XGf{m?`yP$`JfEsrUe9Z46SSD!cl!9_#^8hM
zcPy95T&q83aMt$_Z}2^ps6XxzPb!6aQZIEL(Vp@|^~m|vM_T80tUJzsbUORfuYw0z
zaspLP2n+FlIw2tBnegm})xjl^hEjLr`THCTdZHg0GI=`O-uqF+e5H+?)WZ}f^*JhS
zAq7o-w^SMrdrJvUw!V1BE-v+QsLJZfzw`h9n(H|CaL3oMO();Hdsnnt=98IF-t?Z2
zb_Y4$2wi5%&fKuy+fQP`#oKK$kFDR?TunC8Je^~e_*t^S?pdvc{$-=&&np*Rw?7(U
z`u|nL+?Y>akGMVGH)Tcs3!SN}Oy^vhX}?q~-zHCN@<Qi=DUlt4vwzxL{j_pJ{lr?`
z>*|ZX?!0`Wcjx5~&(F;bx?Y@M+y1JG@9I~XReuAYyY-1GeLurC_d=tQW{8vfFPVAL
zo4cn6v7G%W___VSgbQVzE}dB&CCV$0y}lZ2XO(7jxqx}@4wvT%>mPmo*}>L+u}FN@
z?As5&8mb?e5aF%vCfptrJ@LjX4F&%>Z~Q)P4|jJ}X4!Q#;1G-Os^Dg$LZ^)lOO}0$
z-df|iF|I=A*wHFC<D~sP*CtFp!_?$v^kUNF0vYpP_oubZI+<q5Yii8DY3jw<Gt+g|
zHSf$g$}4-uq+M0xwYkug+Ha5Iu6LJ5>t9>D>a<m1WbqZ2r3W`oU6Wv<k^b!j*Js!8
zs5^2_^?`Sf9MtH1v4!DEr_-hD*VIdDWVjD}n{wgLxf&53uG!+RMS{gnuXTvnaBkDG
zs3~4|-%XtMp3%LNcUOsD$Zm1|u4L0!CaotDj`90PU6z@lB5S54QF7zRnR5OJ_Ub1~
zv%DtmnyqSnUHa#VU4K6XI{O*5)~xm2E~CrQJL$ffd~Wo6lOk{BTwC*t7P}{A%&E&;
zR9M<n=>At~LF>V5(!rL;=SizvoZ<N5&%T4jnfqVnZNK&Ha=pG_M9PJ*R`sszWgl;7
zl)p%u9`XE4olf3~i;v{08CaHh`z3^xX3uWOH(s5$d`n0|kA26{xZDjly3;rBn5SoJ
z-*YrOSg=U{p~*SbMNtYtzrJ5(n#z6Glvk&Y*MdvT|9-}XQ=AL*|Hg}-6mHzQ=?Rm-
z?eE)Ct4gP<Hh)Qcdg3V8**$mqxA9u)ux<67Vmh~I*6Sn6tS&qEGhFXl`W>_7XlQ|a
z2r_J{#@v|bHIjR!vWxF*`?$OQXsx#C;@uzq{&;aE@O9OlB@=IzM15yI)BMgtjZ^eV
zWZ0kQyY(kLkWF3wa>-&z*^Lo;4Ylu^9zNT^X<lC;c<_ILaPA|Gd#QmtJ2#h1KmKvq
zySP8UkFMkB-f-*0`7+BR-#N6G9>2nPD7JIU!~Z_DuTSLL{<?o}?~iB8Jj@GsX`fQM
zb?0vUn@4&3f2MzUb$q&cdHDZbzb|(OnEkzbclx)#;y;RKod5f;saJG%R`}DxzTaA(
zW2dIgR^lp84EnI`-qFAvH?EqS7rxr->~G+B!hY4peO;#?tZ?7E|JJfV$vZJqGZWrC
z4vk?sCA5JfuQa#x?~&&7JwJ9mU%0V4SJFg^ZSVG|+Jp;#LrWZUXRMssC}fl+Bl`9!
z^CP39N-qS8q}-0RZtqcE^lR^ai8&H{TYDG9PED<`_$wHHO-#(|lZM1Bxo<@oru_C7
zRL-_G{tJ1$%KfUmiL=|Bx+C>%ALZ9=+o7M^UfFZyeJ|^#yI0M)))g+}NRU->>=C?S
zpk;0Lw=w<Q+LtLa7w0^Wm00S)zS4bzg>PMMx4UY`a!3AbnE->i#~SA@?P)lo%(Hn9
zYlQ%(h*7R&RY<eX^{sMjY6i1p4fc05?M^m+Ab8m%VD7@tjH?)Dg&Fi0Xjxb!r#fD?
zjcEQ7Y2oyKUdWOZQAe)HT@M~yd4D(W$}Pi}p_g{3INm*aUu6Za-c?iPEHfsZ6+9nh
zCsbY1zO?SUl82ksi#X=}J$L6yUOe<+TaN2(j=INh!X@tIUVgRj+MYDy56eXO|6jZD
zQ6+eO<ulcOm*;ol<Y#Yty8K>GPsY~+U0J_uoiC^fx?Y?(KV|8?4;zftC-J;n6s|r&
z`rz?pX$r=|FYUH;aX#Q{DP!ka$oFgdX089CYpNE{-?o2#3MaRF;fGzt&&+4U_4YbW
z?p8_?_qjjO>u`nZQpQtSvX)od*$w>djLz8Ic=kAS+QHpUEwYy`A5bpVf3GLQ!l3q0
zz<Kc;+bM6H%K0C!>NGn&x#I@=<;;s|hD*I)S|4O``hHvM^_joAb25MbN;+K_srdS_
zR?4-<KPG+UP`##n@5Kk1*McY3oS*rXL%`kCKx>oSLa%!)+b?lFIx;(3X8M`xo5wcq
zDVK?v&iLsox7rr98TYRV<lU`2{p65F634Cl*&lV!*FBS;=(<TLTJY2+4PkZe0BbHg
z1^y2=O@(8-miX9Y9}w(h2^V0xEOuElLCIIl`_Yj}f0Q<MB(GDC7Wn@o?Cb4i_YbYx
zo<IBVzN_3{Zt87)=US)a8F{~RQ$nEH|HT^hy{>zWmVe*#{?VoVj6JTM{_}sf+eU5j
znVhirNX)#04&HsbnwGD!>gLr*KWH#XJXD<T`S7Mh--*2k*C!`CzT=JmdX&?JZTd%*
z*5vGu|HZXCJD*NWxVC4tLguok`|1-Sr8t(=8XItLGI+t$_}#;<yQ%)py?+OUMOqm@
zeY}#yb>LH@;allv`(LpN&a`B_F}a1YLM`!D;S{G=^YkoLg8GfEObm91sbAt~NSNib
z-}`5D+qJx3O4>`yf28|YUQe#ykhNZa#l;!txb{!G%D%)$Gnwbzy6NFPU$=8C+Z+*b
z`#!Hz(!>&`1D7{vE;acP8NE3=c)I<p$VWRS_kWtA_H&8T8Mzi7^*A1PRym2rbau5p
zi!HZSA6vA9vvKdnxmmZ><z%O3@V%P3{nkvjWl2RxBod}vh)QA1lw&_@>n||xO_ugb
z{ezhy*VT7FaC*0V+l=4Sl%8ziPzik}sq?eCF|^_7^0X(KC+~9S3$FftebK7i(|;ar
zV%c!Se_6~4!G-s{uO5GPpo)*<nMvN+zu#<MTfgIcQd9E!e9IZ0%qN9@$ze<Uto;rP
zY%0(8=Z~4%rg(Yfss*OOjV#IwyErBrHm&sLJ1xxo<kOVJdBqw*arcd<q<Y<YeXs1O
zY+t|Ex!4J(7+Z{UB0lFN|34~Lu_5Z<oY`rUe*6^fjhtq2u`F#u$^L6)A-?x_Ih5(8
z*+1FHTFn}izQ)^p=JFXUi<WqZ2Qqd<R9@F!btCKgpBvXdAHB1bsj_RHP?%bJ=i%-%
zYz3;DPu8yEVcO87e6LPoR_7Ee4W4q_BJShaOjXw;e-|p9ikZ`}y!w&+v+p)_`O>xL
z`xCr0Jhuc$NjLWUwsXx;3;l3;;-PRAIonfV*;CFWf7uXm*1u%(iXvAxHm_x&+B?qO
zT2yQ<lUn?5+co`+l`Z|J1^Sw{HTpa0=q<Jk*FRtUwJ2)^&y-iLKW+&p`yF$c#}g>(
zzs2|Z1jUO+zUrHQPtFb7uK48yztW-zUAEnR9N&8`#awIGK3CdTr!mKbdtZ5_@Dhvu
zNj;ubZzdg1TKnhP-^MqyPiJVJ{HkovahUb9us8E=i^DS;qm2EIvj4cg`Dpkp$$cr4
zSFSc*({_2b_K98oVznl>Y_t3W0}8x~#GOB7>Fzyo@p-Aj%0_k(>7u+l4}Z+LE+IUz
zdG7*Wkxbv1Zlkq(N_beL{3gwPWt#d-dFK|HxA_&Xe$Kh}<?Q)Q{&zl{(wy#d>hb0+
zD*Y|ltp&RAA>R#(=2~8t{@`iQmco4Lbhm!jaofd#?K<90T^8I`**blH*D%CCFJLZ6
z+dIJ^JAK~g%zMF;cJ$oJ_1WR|kz?+T)p|nZF_(;0H(#>Pir~{L^EuhSsrsG7(#f-T
z>MY!;I9cU1i*PQRDRXFxuX^e3=QsDtmD<*6ZkZr8nORRu|N5hitB$uNn`QbR?DC$w
zZ{NzPU*gr*H*rMm+#~ofgyYe}8}*!5H$VDWzG;@l?@4oP_tl&)*sNjWcHO8!@>2By
z6~Ds~k1U*iJ!ck7Su^cV@T<A^^h4V>%PrWjP{eG*`xgbDg{9Y>pL063IbmYaoF$q!
ztai?JT%W(lY>n9l_QDF|=AD^FmJyMXNhSWD{ykIEHmms{!JQWHdB=^ZsYi1>$~5<g
zIlerwwP51Mx2{5+y37yQ`j+XsEc>U`X}M#5=)(-_r+S4h`#-PaP!NAE(c-Uvd)c+_
zM`rx{OyB=x-0QR2-7)l!@%Jl<56oY$XT7pR&slG&!P4sqyvfE_A31p^u}{&K`Xsq+
zsZE7=+Qa$1ElX{F{FY{L`I95o^7%lPc<Hr8HmoNl%sNvI-EURIak1YEvZ!(Pj{SUq
z^-;th^JB64bB}fI-F8;yeRAJ-LwRm_v4z}>eU%IDt$4NJ>;5jmlWnu+-7tCkZO)@3
zwRSgTQr2H*+CN$EUQ_|&<jxXCr9jSkRclj&3>lJ6Ygld*lvy{$;QE#*<4-3`A5{LR
z$WaqkkouLJ?8kglt*14d)%+@BL0R<VDo&SKT;KoJ9%@=A`}mxR&yMU*{~vziHL&Dd
z8acaV;%67dWfftj?aDWQe+pycmb^Ug$aZF}oyHACPCN|9!`2jatYt{vmb5S>g^@$F
zr0hu6&!h=8O9CGExxbJpkf@rydDk?DV<Jlam%nAZ$9^#4wY5FSczu@8tdEVB&Hm+6
zmOKbHR^0gf&~sy3hY54$p15>Y#pc4zkBzrQJ{;J-@Q=++4b4)ipr{_<q|S(qX^LMR
zmpmyKpOq)M{ounbTIs1vt2&l<h`a0k?K;ez%O>!&`G@tX_XqUnS}g3EyWwGCnQx)V
z%;k>lZU?ov;x5XD=}hXs8=LM^zWQiQDHFrKlI+xt?0eWv1CExyuuA3%4yix3sMv7Y
z<08FF{_mcy+t5%RtvWd?Oi8X~V^&zv<e<cLs*Tn6J>1uOMI2tyW5e++FztqS_{T`U
z$fNU)KB{_rv-+2?yZa335OoJl!Os#QnF$jf$**n?woWqFoYJ!QQBvL0J#p*0wk!Nj
zn=vc$6dzN`)6me$JYltIdBSJ3r_XL&6|=2b@Bw?BOnH&DM@nJrw|0x8o@qXRrNsYM
z&$BwME%|z4P+-(m-Sc`3>f(9{N4NgwJE%RmtJ|nkcv4!0-St16n{}gh9?|2oh|$V>
zyz*Sk?udi;M88TH8Wb^~EtNiCx8uA=>N->Yp8MJ7mEN#x=KWPll#w{`txNSo=7;Q;
z8HzuRM2@`hVOH6;sd#qzubfwwTR8-+CkHRr7UenjY0^uts|VGeT_``=8>*)(pfSy}
z<Y$>jlA)7J>8UIJi9d_FW`%xnWuLohmfuvicj1Pn&!2OBDZU-%-Fd*G`mXt^*v+b^
zo^O1)@U459T&hdw#ntcgRX=MjPUTnBzU#|->Q#p6%{s|K<CP6ZqvWh_T?$olU3vTR
zygOf;w2C7R^iQgIyv|44pM7ylmU70E^8xBMb;TdUcPZ?hB^Gp|tWI#TXn1>KQKb9C
z`W4U06;3Yv+Y+qG`TqK<=ZjQ)_E_~lTF&9P#<?TlHH)&;R;fcr&YFjLOR}<QYC8uW
zu{f~#nSwr-w$slgN+Q?!_RpR4dz0w&hxO_#dX2k1L%!botj|%iSKa&QX@xr1l+O9C
zKD}3KKkM~;lKS)gQ!&?HPb;~<7k21v4tcmY{Lu0{rp;?sUtU~#KV?tU&GVn*-dy`2
z?xDx@?A>9OhK)-e9xP2Nn*Nz7XNtJ3dV{lPp1a|rHd(2CTC#mg8KNIm^v~^Iq;>9&
zF~hW*dHZ(so%x(8y!qFY*3)i#GEds?E7<P#XH86MXq9K!Ecb)5wO@{DtXlSKon)Vl
z++B6QhcTkl)@iMY360S0k~=hE(Y7zA&Rb}g1;*^kPN;7EZjh|o?*BsDApFp}sq0lk
z4qjIMbo#dWrpFiW{>ozWh-#cYy=&W))em<Tx3S+!&HQ<^#d3DAq|BZve<HF9Y9d;~
zS$??Bc;{f`x!BmRRZ;I_hn+;r{abdnJ<k%ZGK+W@iMH#%oy)#Mykp6$pRe5Z3K^Y0
zY^i!aa{u+3d7n2|@QWOs^8Jy1DBC+`#hQu-GMi1a&NF=BZF2l>ALygLy*Xfl|6-Pt
zAM{^vJuCElBi?Fp@SD5#`D<$VI-Xl5Ev`GDRlL!4&x}Xw_ZzIgmE8AzYuAb0FCy!L
zkGMuCEq!uF(`%ti(**CY$~+cNE~OW%r%tUXwmq}fw%pm~tElI%;N34ut|j}cU-jL$
zDcID<)`KnJ?X&v&jh&M-raxpq<he=P_-B^6{r{xz_8axrIb-SKT7vFCLOapM#K6>y
z*y)ensL1|1#{}!Hub*Llp6Qn1d*%F38~c=00`_!AOpsO3-Bi9zk<T)3Qq<b|+E=fh
zZJc8fk+3|nHZ=VD$Iyuf-|gTov){}0uzmw~d7y;sr42V+GmB0v$_Squ|M%ak3G9^t
z@18s_``Ph1BgE<K5y2+s#_YrYGrvY}|MNEI?|Zqp+Un`*yEQDIxXQhglZ!9-81TOC
z?*9*;XYX#GU2p&AZK#6J{~sUr|M;i=XXnJ%_wCa)yvm*~JhO=Br{*T-nJT+&c=#OW
z7+dq3yY6|Pm-pD@#(dxGbI<tC`XBa`dg~kV=D6{{|0TuT|F=HvdpEIut(4Xq+n0@;
z^FMmpfB*Aknc-BOrMG5D-!GlNqcF(g8@KO-+Sb{1FV;-((dKzooIZcz<Le$CYI615
zhn9r)&R(hS&1ag=Q0(|&_iY13$2)Bg7y1N?wS3@tyt!cg{!fh|)mMBJ#U6Zr{P%D5
z!Y_Zk{~XF+D{Xrs;~BS<`0D*L@}?~Gc4R!5tEGPGQ|<LIqp7KPdDSC3UDvN&vvf_*
z>MgQUlF#S!e10)&Q^Ks1w(3_Wi!?p`nVrk)&ADFVM9NBqyW4+tYR0bSH{b3#=iPhj
zcT&FtP0t#a@2+OEx^H~p$GpZ*DYM$5V_&PSc_*h~#4mnLTkl+~y}`*>UX%U!_5{4D
zIN$ocL^Wf^W`QrqUfTCs7@YjhW~!$7txNv-rsm_fzPwU0aW!Xjetog&$Kk&d<<(uA
z+IK2VJl7WIvq45)ylvx*2BjpXOPpaL6>9qOFXZ&^cv`Wa*O65)Sv8%R$KnsC`l%U9
zb=26ZAF|K9F`=VC==ix8KOJkcR!lYEcUWl^77{%>jMpgVjc@f6wa*;F4z)H<Bf~ad
zGS}RAe}bvJocJvM^KrRF=R-nY?kmrcePO{Zeg20}{>LKjlH8O%l_%X|EYia_C~s8p
zej$4%^2EDKT+a_Ln6A&O8MbTHJD<Fw9N(pE6BxR7@I2q_y5_>Gt<fG^eJ(!dzI$&o
zkAx1l;Ln_cD_734wz6#7_3rGn>2mIG6#8$)1%zKLo1k-!dslUF%J)u_X?y|lp{5It
zsvF8oTd(}7z0+Bc^+JS*gJkrEqjeu-^VViA-@NScCA&3j7xzi`FXvt6Fh~5;O6gag
z;?r7;ix0Oiz3+Bvvg5vuOFtZ+>3nXI<Dv8*l}HBHZkN{WEiLw2-d0U;3={hu@Asg*
zL(AyEvZ*%~&6>w~VCKd>T`MmJHu_4HueUg`<<9GV2B%G?=I0k2f3>4BDNXm@|Ha08
zpFL|YU%yfDlRMXH@om%2iE3(u{SiI7VE*|_r9sTw&m7R66*uppQ>pIaH!F6QOTAYW
z3{F_+_WID;H`_OGZJ)7QBCYPU>gJpFOk57eT!%HSI-WJeuiyP`wqufC@<AsRr8(2q
z3GY^|&{1}_iv6#YS6R%c?<2;1{b`bX!V<U04qMkv;^#E7bet2;<^_Jgqs(~r^T(%Z
ztp(R-xE@GaduPJYX<ys)V%ly>xwo9Nbi6J(UG|~G0go4I>p~bjOIj|l#$?2ZtTHV9
zx+&IlM?t@T?Rob#JomMPeuiyyT_liZGk@9h*G<b}^s6l@*mhiBP?`AqV%hUni6iye
zW#6|lRvx+4Rk(K1k+$FBn)hZ;D>W_LCa(XLvD(a~H|4O<lC)^k<g-<CI!uq}9Zl&{
z@F@M}W1Dl3Git-`{-uiQ_q39D9xmCv;9Js?1WuQbux;;3StByovdo+rnH)Pexh19C
z4~$_>T_=!#D{L1#=drstuH0eyaLXgW|HxcX<MOsElN%4zFEN<-{{Jn`KLYoT3htR!
z`;$q-$2w%ghvObMdP0QXpZa(sX-1(z!Qr$V^8lW-WB2Y%?hw9kP>iLrZQZ)3da4!7
ziVA!WX1DZ-Kb&*2*v9E_$Z288n@T60)l|%*YRevo%(s7dc(Z}=2bL}Sjxbuid2uyz
z$BgV3|6fXNir6H~l9V#*LQ(>U8)x{`CYJl#eDVXOc(+^INEc*z+Eip$axka(I=-99
zZCog}vqd@XuCl;712f%Eo!_HAcS>nmD{I}iFyhqZs@b5O{)x><J<0UD%|fw7J154v
zHhtN!amyc#8H$`S(Mh$Iz7b#6PhbnsNOEg**EM}9y{sWcIR1oBN_K7L6n7R?KFN|+
zCHtJ6d#$&8xVT7h{_>0yhU%q~lY(dVDooG4=c>>r+dR44eXIAjHRtzptPA`W{?p;i
z&X{Kp?&|D6oz{@ClQX$ZTPAqJPNu4DMGW&TW?bWO>zQozV>$bNZ??W<6%EEn?P=XA
zDjFBB8}$pWzV4qfu^~~S<x+miZSH3?C3ej9o-=8$#Wy`JQwAl816zJo8B{%P&YWU>
zM)s-T%cdh&*F8M9xX^)(y?~YJWfv#!Ep@xa8zwMp`(kk_Cc-Zzoqe(3NwvTxDc0lL
zZRUJ3N@P0PVba9!q5Ql}WOcoK@6?G+#S{F_JX_e^b^WoxJ)Rt1!PVB=LQ=WDn`+3#
zG5ly0yD{Ubec+}`k2LOHdDNk7P{#ei?b4K^2M^CIau&Eg@sxPNB>pwqCc22usGhXL
z^+><PFS&@tLHu7P32bn`ay(;xEz`$)3<V2!usPp7l;u79f9e~9Nr#!Atoq$8`NVNg
zhL_}Y<&}vSXP)(A<)6g%U<v>G86|;CFD95vs(CQa4&JEd{Nlz$p84m4<`!iboqqO?
z^C4Tx9|@yL8UMq?T4R<MuWeJ^9vS>-i^}9H%FHW!4xdcy=<4BExxn{8sw*FdE^qpt
zBT^QZ=A7T<w&SM7n%PqrR#v}zyTs&jpw7(qr+1w6;5pCX{d2GO{>;_;`FzCguszpf
zP@T9h$Ku)4wL)5H7taK2ezD3fN;R2H(oi$jVkuv7#Cu1Z-Mc4j@Y<38<ltIo(HS*y
zjWZwrNKKfh$~{MJh1j{uYoE6;g>2sBmh>vEkmH<-=o@D*(Tr}<qP%~9F0a13{t54U
z%S9W#d-y*tdZwFv!C3fRlDLiY)K%+v{lbG<Hr;(;^CjWz(*5ruR-Tyb$JDBJ^-@({
z_}s0JTZN~YeD+gb%5y|Z?{ezH8mrm%CR--1%9^$7lkY2)-n+*CU0-|tWxI8^JJLVl
ze(=0KPu~33dA;Oz!pzr?&fj^(&UYqr&$-TE&4)`P?)+>K<13ueI(^44n`aVJ4*G5V
zmQs1frO)%|kwc<C(zzvOo-_SZVH8x*x|Z>q);s&nidTPqE%l$||6<j1ceeDOGIO3X
zoh#x$_vygX(9e<)Hy>UT;yfpoEIyg-z}#PF_AyuW_7t64W*#E!Dztm*o$K70htCz>
z+cxV}Caa7%%if0pb1pq)&Fb2HVb1A`l^X-%Dq>bK3&gEpj`I%O^y}%mb3DB3>cxsy
zUU=|G$7G)0-Dh#<0w!!d8NfCD&f{7A-M&TpIjg(HFXROacI{LOC=vG6l0DKg&C=;o
zk?<y|>3+uE9#?F3t(dvVXvQQJ7GqDtL$-QFg<t2kvYq!{x1;EMT7b{&jsMn|-?Vsf
z=Ki!dZ81_!E#JSt=ezUhlhU>t9gUZ%?FZ~<zI>oj8n?_SM8uOfeU^SC=cFE;y;FAS
zb5H!R@HXfCR_R@>_e~rOriSPgEQn#-k`;UN`RNCz{qE;DF{XVr<E-grj@s;GZ?`Fv
zP5ViE%gJ5L&+lw_>Xd!@>Wl_kseeH`d8JF{b{{?ZZhemPR)=XBOzht;_urjWxnE%>
zU+|S>Okb4u&S&sBx02N@V$#xDx4+UFxdr;gkIuwq?{VM3rT3ZfcoL7XQBm8j7dNLr
zkuB?xE$d)ay|Bu5dPGtF>5o>SJ)eK>zHO1bl~GIPpt_%=dgRUpTJl?L(_Hz?edBnW
z+gAiBED}m?Qk-_0=R(;}u4$PQ4w(kOSn>0MuENSF@AF%fcxN)OmKtrm_@_+A=jd7A
z*%_y|u}qX)?K-t2Xx4PES>kG+8yrF(B>itQj8Zb2?q@c8PsQSCXOnJdRmP@l-^Olk
zv9tC?#1E(GclU{~eA}Q<B-C==RZ-CFxwrBRuK1v`Airo9eWu|1_m)~Rt+F_&^e2j8
zN567|LQy&AoiGm0bMCeQ243IapIGkr*qvj0p~k~$VNo?@0uR1(wkvT}DxQm<+*7Rj
z=cu`{<RjJksUAzSGTSoeUY#{N#f0}jb&;yW2C3DPLozkF>pH!;o1Fz_ZrduZ@l8j-
zI_<El5W}A9PxOo!Z|zwvqpF+c-r4<u!H~1>h`VB>O6AE-2iQ(LnkAEW_f6<uJzl$g
zzXj`@incwSy7uyfeIGtp-<~a!_xYefRnPbP^98h)&yfA#&dp$S@3VqMVb{-4uAOz8
z4@O8lZ9lQr=TFUlxu1z;Hx|1b72UV#&jh!RrTgCH6@4(;vE9mPmZ8VP((b(<xT-zt
zG#*tPd~o;o%md46RLg&!%8gNLSBT&H|L^B5OK;qt`S`@Q$ajZB&mH31>C*a;F^R{Z
zw^vb(bw<6F5cjn%S)Wes@0!dLB+k~QZrbtg()Z*u<pviDltMo37JOCmKJ4_#qJK?)
zmd;uJd#-F+W21O#`|4D)4>6xgy=Pd2^Y!t{cK8cazbif39?-@A=*zX*_t$E-GTI!T
zpZj68@R8UDFGH99KG|r^mooL^qg9vw^qBR`J2P`*Mars4Wo5_ysqqBXs>glL{Kwij
z_1MPAL65#P9#)bSd$08`Qp;%l^mli@{J3;vN9~>7pVQ?&?wh$+ZR4W}M~$C8nz?T2
z_BGY1Do45g>{*a*Vkj|<YeDofZnx%*!k<;^R)p*p-+06QcuTycn!J2lWAGzBE3rSX
z)=%eT3-Y|{D>LO_^a+Oie@zcOEn?oyx88Jm>4w@%e`fufDKEG!*0;`Dv*K~K<Ro3O
zRiY<E;-7_h+37P$Fiv_e{=T^LRUXT{Ul)UH8*efk;-3&0_2-Z8B>{!IiK&tIZtjz8
z=Q9fo`nOMh%IlxIS95Hu+U%q<i@&0AiDXh-c<(jQtupfp^jHPHY<z4K_|W%YwAJ}(
z$t_9u7S`~Ji0O-nddT11mUDKF$05DmDRL>=+x|PPn{<1^nk2z9cAp>rSv=?FJRVm;
z?mWi(@763|UuU&((oXw_dJlqpPE3C|_oHSocSO~Z?IMR?Y`FaD*~+>lv!34*eRy{^
zbHwir1&{CFdwNu8Zp#M|&eQf8rxy0^k?RrSV_H37%F%YEXcm=8#bM{NHnd(z@UHv(
zO{ZbW@)KU(dOtKaIfw01y)L6~|Ja7%MUis7qwJ+U{pWAROw#`1v@3o6*{7v<y5hgL
zI<(#WF)2tUU;p`pNhLp(^cXw6<ZZk@3-u>^pE?!BW_x$BM0wPN1LC_jmHPi=VigdJ
zjk%T|D6vM>biT8$`bz$y{*QXrQz~ONXe>5qGv)Wx^v=6mR^-7T>7T4{YFVm6zTl(>
zsSjl{yS>wcj;fabx!|kj#b>Gg_VM8_7ab-T^YGQ|m7guYA*rEvyV1dqhN5Q+ZO?UX
z);zN<=AZj4@8r!}4}D^FZMW%~J};+K&P4ZrV!=C^Jx4bEXSuKQzDS&P!9B+<%sn+7
zTyci+^{jv6|33d+g*i}QWB|I66m6iu*bH`OGH4Yg{u`6GN@eHYIredP9qay9rW&4|
z{CYPRX^7Y}UH8pCZX{%(C-AE8lHg9|tIGP@{?|U=S|h6(?bU3t>*<>}1<!3apSIY+
z`RKv#%`E?pISQ?CaWy;1l<GT0OLWcm^#8WqF>fB(OqhT5i{N#^X$u#AY_K>r!R(Lh
ziuE=>uXg+^pPqhyUx8YHTG34Jrqiz{$HwF}#UDzykK41u=KuMp_UDpre))X*_qV@n
z|31%%|MmA1+f>d^8vdbOzl*gBJcX88JzTqYMP6U~r<&9)yp#9OSsygHb$T@89l2TS
zEaO+|#F$&NZH?V%$9^FH&yASR?|*O4kDs4z)$`-y^4!SJD?V@O+rHgprOh4R-D}Ks
z`MDiG=^t*rE6lLWGosXHr~8YIZ*8))v(3-$EP8nSBAde}g~g&D=0=~cIUl!P*fh;o
z-D;1WN%cGhxr_^UKE;&JYw6|r`$RM_d)K;~_KqG>b$6z<Pul3Ewm0=kY@_v`8ofsj
z7xo=ke!ge#@wqz-f@8TC2(C$LW_q;N=i9RMMM)8%-05fI%zg^S>#RS;vm)EkWR1;R
zA;ou(3W7_Ho?UpuxI)j`!D7nmO}}J2r|UX%9hA*~UBhY;XrZUBYvgqMlhlPZf8_FK
zvh87=_HiD+w4%;zFBfS82jw|ubaEz4eSPTu0jIUThr4IBZaDDY@5$p{(@yrcGc4F=
zl~%hnKH|A;?y$P*?wi%W+UB!ulg(sKblv;V@otG+caGSJ5GKZRGavU@w4Gh%*X?}h
z%kNFv6<=2UIio$lS+h>*+BVl(<%)Y(*Udh>FI6BrVdBG2!qV#N+;dzfEsvj|;`cW$
zw<A8`(T#<b2VU>WiY<BCb})6XUCq9?tCq>F^>^Vr7p?l~angDI1$*m%?W*?=U$;9f
zE@*T8h35Mf4|}&;t&u6&dmvV^&$FgOGE19{WB;S)X591l)g52(>GHOQ15S4yeBNBY
zKecDk=d_kJ5fy(~wL}YV{Lp#z;zCT=lj|EEvAP{~F5Ikt^1-g81;47&mNwM-&Um5L
zbJwUs?I`DT&0^0fpDg|es4sI~RQY4$t8EgD0zSJBALLKaoBpGzyr*TKu>wQFGi!_E
zOgiO{dRbPVyE!#<Uhs^AOIiIle(hotyqDYExBOdZ_}zx9TmEp!ZO%{mxK(`8>(-V8
zA=^h?FN}r$%B~DKo|#}QT=<Ef;py*&4+=|P+iX5~oZ;Y~_r3+&P9=NvTwB4Q!<({l
z4c{alH!HR$KJJw{jZYTxoU8Jg>b9{pX1~1t_XBr14B01me%4&X-X|EYcdB>x<Tne2
zLspm+NvmhI-EL<5satq`I%|}>Ut@-l1|QEU)y@RBfAam;e<!GIt~0qJ;pckFQE{r8
zS&`5CEyq4Y$aV63xvTL%du{r)elFSTF2-CD!o0TyriC&4=P$Fl&2wcfQ-sX&Z;m$n
zbEL$V8ioX$omV~@B4#0~)9*5;Xo8!Zrbl+}q34q~v<Ax`*mQ4y6`%b{&d<h+f}gc+
zzk1+KPvvu^)ef#1$KFjmvs%ZfkA<_!<E!i$?rH8q&wjsPkFmQewmVkSXLj6kKP9;a
z4?h2R{Zol<^;+zSo1Yh{weqB7@OUUPxBQuy)NoXa>CLHSVr3KVD6$>=<iVY^Lz{Dg
z$A&3$o-pc96+ay`b8nuOXkzt)syrDpqm|6pHwwgFQ9iop@rf+nB*VxhIc4n;ET@$V
zl})ZpR99S3-kn^{vRd$b<@cOOF5_3mw-fZ()$X%=TEA?6`L}=>4q>%y55Jx3opCB?
zK?d{e7aoqxo;I}so;IEy3LPJ%qz<wu{_mO5uz-2NlM*)<<uld~)~ikDSj3X8<IlWL
zpr>F#xUrbGrq-;|vRe!cYZh+`WzuiD@LA<}Sm|kjbukRPbrXvYKd!yG?P#x0KqK#r
z|5>ZT9PIaZNqh^6d%B%*s*-eN>rxNRCt7V&+i$JD7FfG!N2yMJ*oCuJOVeG?&5=D@
zda1BqCpIu8alY}x^(W0Q`sfOWu8YuLt<vu^=g<F8%}oFM%e{<O82PzO75FPYORZ)3
ziT%m{WDf~Wy)v`1RH;SVQYxgKm%lpq5%biVW!KgCJZD=}Xy$*iPRzBssMex&>zvz!
z3a%+!!fV1~4p+_1S$aL_S@+4qP19<#>yl19i#yw&vFX`WW|Q@D3x6)>o>d;WNUh6%
zpWnxTY2Uj1(^~Bgr>#-un9}!Z!M(nK9S6)hr&loX{*<%Q^8b3l^Z%+IuI($<PCFjZ
zc>kSO)?>BP)wex1WZc|xyXkw&bL&n)V^633?}eAAKXs~|=3iPZ#a<%Mex~W!*E`Py
z-}0S({UQ9X`tLt~XVoWs3A3wOZDW}zn^=67*<(Z2{Vvsqc?G9b_8e?{zpm!?)H!q9
zF1&GBw<p<LGuz<$OZLKjDWCN&y=?iKtEkic&MPzUBM0a9_`=EiCO+Gg>mm^?=$L==
zghaml*Z%(3i=H`lr#q)KpL(GY7OZSDrQ(uDx@m@~@yj_~Os6_S{ug?l$z`ZLDdD-m
zO=v}&&w^)h$1M{NTAy<|QSwmmP0Aeoz-N!_@6XWx$#1|l_v2&d=c|t{$z0I)x9i5t
zXPX~zPMx)5LZ|=Y_RiWb7XF9g_&O|oXSEzx&zW`3pKtA&XNx5~=W;A~ocCkuhmOPH
zGpr`Q@Qw`OJQ-}ObS<X8<7Cy5iz_vQy3V9aesV0G@ON_ZBk_=``T&useT$Srxc4pF
z%3YT0C)_mmW$^E8cHeTYeap5!o^{R3H@kh-wGCQ=$MiCt_xGw!-@>hz`F!V@xmULQ
zl-JA*4pW`~{Yc-g+dNx5r^F?>OIq(yUa?_+&87SP7gSl!eNbp#G-aOurCgiW5>dx~
z?^yfmHn+=7uDu_p@?D($wU}X1M^E>)qZ_BDmXr!w%m1(3C(3C*@${6%Z<c?Uy?%BT
z>#xsU8fBYiroB89er5gg=t&LU$LB}SH@kg_{qo!|3rcMIKkbtem;HCPr+7_y>g_Ja
zU(;pN-D9>d|C{^sWm)*z)#utjn9k^%urn`3^1@`cnJT5%-QInDbtGW%DYi+rhgQ$m
z{gEvenQF`QYt_5o=T+i%G<5mbn9jVmuEi;ot8ZWSx(WwTCO)^TE5DWNT70nc-m%ZB
z)qKK72}8L(p_xDDwtte^9OwO%l}F>VdS}d{ht;ok#dJ?LnjT!76(KLaz*?)Zw_mVo
z+P1qYZZGV2-z%*z%BkNQaiP(X*KI=Dspko+{oe0oFyk)dn5CM~AW~<m_<mN>VTMyX
z!Y=cwIG^zEco()}<9*(xJc6_2Ooi$WFWK;8^7LPg`}aNJQ*TcDvovSlqubL&3vF{#
z#U?e$eLb?Ez`)e<Se4JpGIya95zp`M+YsP;sZQkOt>-McO0zx73<H^rJg0nZzjUrG
zfA=Eo${);cT%C2+yee|MXxPd>_oU@@|B4RJxaU8bthmipW9Ozn{2hM2^1!^;H@aRb
zt$5fOcCV}3()dv{>+JU{jd$@Y?aSU1{lqwkq5DIE$v(H^yUR}GemUwWXE*=Mo2Q(T
z!a^c<AI7e!jjDSPpT{m{FErzadfqjU0JDs`IZgu4s)btmcjeaX(Tdu{D<Ne6!TQ{C
zx37yD74LdV9d%@_*X)*l{N3NB%xR~!NNIHEjI<IKmNgqgO-r?d>wf2ay1}A*cP5kH
zDR%a&zjkN`1ZCDFEnj(O@ABn;wGTZ>GyOWzT6UJXf9yV&3yPm+T7C1FBhr?*)_}(#
zzw}Qei%)3v!*>@%Ys=VNc6I0F@g3FmniWuQzg?`WbJdQfBYR64cUj8)>YLCd_UG*c
z#&eR{p5KxezW%2zC}FzQ|H7hnyT;%BE(TMk&$lQnZZiws7+)bbXMIBAfp4#tBrTQv
z=hxH~eUsCs=1ci)i?o*qGopRo?Pc7gX&864#=|)O*JB$d^^Xt#I<I-udLUu3#rxZd
zAu(x3m&xATGC8g6%+YPTZmug+&3E~Bjc;N`2j`=ZE!zYlWllvG1#ztvnlQC#?X8&%
zf6Xm!2k!f(HPuaORZqT3>h>?8%rD=~QdjJot8(Ryipn?D@5W+FXE2)>cjx+LDWz|6
zTvqb2{qH<({l0|62{-?U9)DA+*W2?d{9L)&>a&-2T%XN<^#_+3EA!G%E4G$u{B}P6
zVfDY;(|Y(OYV@8e%-4<Il5#*>WovC{cy7C0>jLo*@6gzj{qrRMn@QVO7xJA{-y?Bj
zcEoJ9?BGZ{54O0S3i~uXCm+1!@smw||CcpWrP@Pt-B|x#wb=OW>aWt`HReYjoOGAh
zT<Rq)X<}E!f2pMALRtIcU9$t9=veeJEcOx6?L5%%h%J4WGfTj})LP$X+~<5Nqu1`f
z_){R#J>{j|>xTRKpFSLaf4(XHhg8tMuZIim4At^uBWyD!<QSE%uGf?6R@FQ8tL(wq
zL)#`>c(n^3*>Bj^w_L)^)Arcc`_u0&Qo4TmhxQD$l+Nx}W%fJoA1O}S{a(P6qpqCY
z(dxC-hO5jTbywxS8aZxvc>h+&b`Oj1{<hcbfhGNEzm8kaICnMK{O44Wt4)P-b3UbQ
zTz<7MKkjtnqOa=yb5ys?Q8mkrb~IG9kgdP^B)hik_)g8}8<V``gx>E7&-%c$+HbE=
z+K1WeEsn}5Mt?D!>zdVJaJ_rc`OWNc*>(=i-Yf@KUe@_3W&E32ME*g{`e~YJHy=Bn
z3ZGQNaNB=+?7>-YF3#RFIpyCAfe$^qLMwj=WH%rG@@LMY&Cy1ItoiSC3vT*`z7o50
zWxJRbfA`(DVf(&*={v}`yTD}W<DZVto3_ugDBAe9D9h~cu^(H6JG>`zDzCFntX{0Y
zWd4aMA)BnOUP#@&vbcEf#>wv+x#BmTs=HqEuXDor#l;KLwx96eNt?d9Q7~6bb<WXa
zk43%)l}~Uu`u14KounT@hhuMUN#QLL*8H=K&+EI+<lvJz{|ul1XL#W7!wgG*)6f9(
zm>eTROCw?@rmsfb&b#d<Q2RYxpjMML<o4e9pe?SK)O@8Eyg175ILqdQn6BVNm-Z#X
zEI)sqi_@5Fq&i70bb&#_+7mZ7Z?@jNIX$g)acIlpcs-6k#|1kz7J3NC1|FQa#AMgK
zxSAafT-rH{J{acLZT&k(q}(^o_JBup&X4+jyY&yAoBm0kE`EPsfXyNq&9xpSm7g8D
zPp5wI|MNNCKR)K%z1V+cjm?+N>-)d_tNtf+QtbS@TtRY@DJoOL>|K>zIVSZ~T#Z|@
zdbiEYvzEq&wMMhO4?dpWeRorY{=M@ny6$Sr?)Nd9edZj)gAm@nfW{RI7c@Fo%eq9U
zObqmi7VLFcnBga2e#d*FLg;mGW!^`o3-#lcpDvB65dE{f^K|Kjmt}>yrYxqVbEf=@
z41898{b`-s&E9&MUo(E_s@dqDN@h^2+vS<AvTxp5Pt&hTjaNCG)Bj!E{D$l7Gp|QK
zu3tLGns!_>>6YJQ1?86chf25YKKV(vB&}!Xxt_xH-L)HhyOK6~{kc5r(YM%nH9NdN
zr@Y)B8_8=gU-IA9yZgePv&P+gPS<a;naZsF#bST7bhl^kk|tTkb=sXDf9><P+r96>
z9Qk*5gBvt^yOuC{bEocoHNV^<>d@)?3H=6(7yJ8_NE^BwXtTKGQs2z{`)r{66fYj3
zLyn0JMa|1ji{&fum|eNI`d(7w&pK6+H7uQ{kIY)p5dLK0ITtOL4Sh?dbzGQi6`Ujx
z_&sWS!+{{l%yWE9j})}OF!Qi&UJzx=wAg5$G3(0r(P<n(0^E1F1Ycgaw0>mCE*+XF
zdDha%s%63~<$ZNew=w6vYqtNCGkNX1No;=_^Uri1;Bc<y%U<dF;lvWtAPz^Vb&0Qb
zFPWe0lN8KW&F*x2r(*$&5l>Ia6+^b<EpL1|5{|v|WvUitKdids`aKn=R}a-@q<l5_
z(lEm~>#JKrNEHX~#`h{L2iZ7t{mv|vew@*=z)OkKu*$%tTVCP=^I3*d3R<Oi`Dc}-
z%uwc;bDXPa<?%V(JlZae{iers#8;a=H|ChU?DI)Qb?2=?wmo%slKxJw=IS|DoXE90
znDd`3=gA2Pja#0X>!$Q27?^#`@smj}=3?Bw;$(z#>h{!GZ^fkZ_1tXdu2gb!-|}K!
za`^@U8INU8(%E13SR6L&i|#ozZRNT5e%-8DzW$Lt{;3;1!)6z#?69=<*nW~NdCQER
z%nykd*o}`&U3vSBf=8jjs!4tUs{$8J<?6C{c-Bx}JZiVDUF*gjfft(R$SyHn#drKg
z+HI%c6Yfo-KCV-BMR~1%w7;5Z+j6%4gAf1f-+$-b(@yAqvtPR6%;xvMmYA~W=qm<&
z+Gp9@+r%x-Wqvd1rqz*+=Q#>C7I*9v@klNX=z6G@woPR5ljb0vJ-@Uy^J3S{f7`WW
zt;%6t$MnNqMq5lT8pX&=OL1sSzd1Euq%ZSrL-9_g&I5%nSDSt~cQveJ?KY<T%X90e
zo2NaH+j)ws{OR=9PhK}X?DkuiEqqQao@eV(arNytL?Sf~d+?MkpFA}&=kJNqsP^v<
z#0~B$O=*wH(qACZ9@%2NIWmz;>PG5@`T07hv>U45ZJZvt|5ERzz9o+GE<JYni_TcO
z3H93?wcMr{I$w6lXA$|ni)CHTO*t|tqB@hlpWN2V%547lRmHM9&wb{myquv__PRf6
zm!U+pEsOiCj>60${t4%7DlOc)<ue%XaBs*taq!InVZNeN>Ar--87c<sR$AfPzDjoF
z^d`zXzOZTCF8H8i(VfHZ?s~q{IBb6}LpRQ*^<l0Di`H2MfeBqZ=IYFi_GFtRJms8p
z^SsR^_mY=ZvB+_qTrN4iviIPP*Niv$AE%@|c**vX&!*Y%788H*m)^!>bLJM=GY2=V
z&1O|KeXLa?qUk*`JGtt;HBZTd+JrTlZ7LfoXXNozDxI6?uClIrb;<6C{tqU{j?2B5
z*Og8)a4Uaw%0+j6mdd&;A12T9lTQeGPq5Zs{$xp~%yo~hG`Zs%y+4KPi)-c|e`&Gj
zm*(wzc|y^N*}jiNCM`+l6F-)^Hr4j#nj>`|n}27Q-d<%_+r`{_IJ)rnnt5Ue!>5Z~
z{e2_5G+v`cKe~Qj%aT=UaW|P}t&gvLEIt3)%F}PIg)$wV(D3%2!9;Jay}XB0_jo@r
z`hOz!82`E1P4~rupZhYIiKU#K;_YBL*WA#;&M@D)P^P0~KM&)|<FfPF7BQMHHdu91
zfO$^ve7;<PmevL8YL}UpeEuQRcd=|rqJ?N;qCr7nW>#K7#eUU?cLM$TdiUPn#J(|u
z&$3W(Tht=CZ+3aB8DHCQp7^*~r{cW`+wyNK8jB}tFtRNbt@JEQjjGEtWZcd(`?~Lk
zLba4VCoUhosy3z3>||c(I{)?txn1S$4AB>Yf_k_ZlMTL2e#qmw#;vU(Z^AnP1Bu1G
zj)&zKlYA^Tgec2b9dT6IVE_JcT#U4#mQX;e$q$$0C&sQ#a%t~3b{@a+_oG>M;iH2R
z$0K#yE!If1t8SY)<wyO7sFshCGv6})Wyw-gn5cX)hT*)*@93Ii(LaTlJ0Gl=<`;DK
zactPFHU`!^-w*$0_`RxR*U!}rEI$-XZT9Wbu5GVjd}H+eZNo(M?UhVC7k<_6EI4!1
zcKe@AYGKd1V<(2KXMHn$=U!XS^3?`8cFKjjqAcaoZ?D_<W$x<vQSUyoOt|0rwC3B%
z=tC7V^O!|?YQpPUZHkv(o9^@Z*}?nF7Z?J6e49EypOI00gMS#m;IyTu{uceaAtw1o
zw*8L&k8_9jRerr=e(l^7`R_B^j2r(l9G(1T-JbuG+MiVgnuSC!-M!%T^3q2SR=*b7
z70-Lyr#WPU$0T*{<F6iWxTD*A!q?R8#pbVd8~n;U<IQtr?&htzZN#1Z<nHaClXkbQ
zjJ$ULT7%wwlXV$4>e4>^3yz9Cvc_rC1jl8E{&=rn?7a2dgmxC?+iIpC4j0az$tLrF
zh4c5}BDIO9Pk)=Z<e&HZdd9|5yEJSK91F|_j<Kl`(VNTO#=I_myiM?bU484Xl~>Mi
zs@_Y;yL9HM+}ta^>eD~_SXb6O@Z56LMW|Lu^!nubeY+VvCYq>B-1h$AmdBFaOb3r9
z$?uP4@IE^Ew5QF_+rnJ`A9Kz%IMuNv?a&g1u8k*a{yzCDyeL^#UHHG@>$;=QbMzDS
zUGEAAH*b0Pf8MV(YWCR||Nr`PGCnTbFtI6P@yjQF9*K!R?>^ao@$~!o`|alctNHg`
zePjBst3M6*-9He2_w$wKnQSv>sHg<`DAv#NHCgIX_$s1$Zv4A#H%pGq?0O=8d8UAg
z)#<zqj_&$hXZ;ODZ)^5myDZszNvr*IQgbllu3fIvjXaaqHHvzFYkhx6y-Q`5w6)2?
z9HYf9Du+rJ?F*i5@7OYL%P$*OKc6o(cCG*S=W+en5trJ1I%jU~2XE1YV;PH*th&U_
z=1ecyT=1!C_S96qOB>?%ov%CjEL2X+?@VXdnzR?G2|5=#udRCbarffNeP>RcS-B`G
z&v^Z^)mJ!^xz0vDy``12bLXsc50teh{!2Ngsv4s;Lrt}FO5Z1=qx1GZv{z8)vDx)S
zJayN$aI0NRx{np4*bU1BZZEv`?wRNe?wRK%%}}g1e|JuQ_oeSMn;9nDHMyVA+!J*D
z-`nDxx`*vLv(9D28{8^;8+Grdq{!7vwO@r#ZCm=gZualWL|tLaxYW?L>)hrB=eVB=
zd}rMdIpy>f-=2~=oBpxP@4LOqQ^Ih;Y{?xv7j-Is&i=N#R!rvS-+NPeRYlggYWh{=
z*nT)Z|M5wtJSO=T^|Yeg-Rson1Z+4`v1!&G*7S0ROL9{r9WBzQiS*j`g}h8XQ6eOC
z`Ph!Su2dh<2-fEcz7u}>PMvzegZa&|t^(e?g{%vIY3w%f<e0oC(ZazcE5W&@K<R?)
zobXxECN4UR-@eFZ%xSuz(51DG^M@C|D{HsNq7_LD92q_5&gI=%n{QS*b$Po3Q-u+4
z##~m1(*g@#2YAc522Aydnk%ra<--P53xjKkuUt3oW4dnH60^Wa_jsY`p`aPF-xYk_
zE&Vt9_3IPY<PMoQ&B)c(i&<YUR{8R1b=kAL+}Dv$W_y>X_jilQW`s<A=f-ZTV`9Yl
zO>L_?+ta<=jRJR%F)BV^)LY@);3REe%y)v@Zg$1x6HJE;T)b|TMNH%=idYr!Mz}R*
z_Tqo17(^Q8Hmt6c3UclVdF6b$LtUnzXH~Syj=&bKVs<IUH6n%+la!V+9yd3&yU)VF
ze<d#^soH4O`_}V9>jK%{I(~NLn5Xz{HlIzm+s$KI(z#z(9Flj5WJ(f>xVv{sDZiAd
zG>=DPzYMo<gXJX^_hm)1jvdrExP|Gt_d5q=k;MnS5>`zzW?J}v#zV&^!ZA1I9lG#a
zLhgyEi_?lXJg<1xTdT1j4(_r$F(X89uF74*_tSbD<~`fA#o5wx?flEj%5M0%Y5a8T
zklC{BSfShH7f<B2$WE$kI&E&ipxgOTd-9TVCA=k{AHG>%D&3qgQ6}&ArjwIQJsaL_
zXt#Z2Yb_xDJA1aov}BP(^VH*y7aMeM-W)LPpKQ`%-rMG@m10ZWUP?ai(ehPbOq|eB
zP^@F!{&fNypUTu0<2w5<;zv}jOj^`aKjBS{#f`bg>I^>3IL+_-c#Cw;vclz8VkADi
zyzwRYv&E$uv%H1(`m7d-&M2`nRl2oo_NBEZ-MLSztbV`NX=FaRv0=lW`=5X4?OC&2
zD^ve<<By+4`gf=PUSjvPrA_T&Nqp=->F?A2{7c+@#jI@Q+v0>bH-7Y}$4-v;VR`)G
zQL*c1Dnj)qrYjUAJ-Qcm@ZBl>{oBvQt>4C~cV}U0+?qDkBTSQ&-D;iQh!#yX)4MAy
z=C8xBHRkE|l_7z<&R#Cpo<DK@rn9MAZQd9PnW#)*IIy$*bcB+QB3Ht@yq}X)tfqZm
zbn!#u?W*r5rng<Rn5CcCXFSV=!9<ah=>SVm+X}1Heasp2yk<#H^Y{K=@kQS3efxq!
z7R$Y=y{d&a^$R#HIGOn`%-5>-IQE?1hhdfaTNb4W77PnMvt8KA`lU?2)M_t>!DX@g
zJ<ey+o&3{`)VxmIa@omuv(P7EbLFP9>$XL{EMHsbZ2YY5v#4H<-<xe3f3|JgKR;~m
zJk2BRB~RBqKl&>xT+!jNIYS2f`N)?i^UI~hr9YhJPhWq>HST_CXT{XK)j5vKj8!YY
zNIebD`TnFZyp);cf6V(iH)PNCojJYbUa@1#zPxpnTTX6j%|3dfQTJs{+?!XDk9xZg
zwNEeE`l;|(>!VF)Y+oII@_FlBp{9SCPiL*0zO%Q}`+AOg`&);)tp(E+a_7vh&wCsl
z?mD;XmtgDU>WyBj_sA8@UEBSZ_f*q^nH?SfTCcO4O}Slt$s=##)Spk)K0h{{V=34X
z&Hth5x#t45zibj&X|J~(d1d$YOtJmq%3Uj;7w+AjuD|SbuGM+Hvej38b-ODcwqNyi
z`970j(ud!%yIFNEh}}F^`;}?SM!6<SPZ$5s|2dw!&XU;4p5O59LfwKZya(z96_gm?
zODW~Yu*;R#YWsa#d}Lv)d-c^<i<wG3tn#$_Ct`C;Y1Vg(ol~Ev`bxd%GuSn&mHWt&
zJw?Y|GrsNawborE$eG9H%wqDTMSxewZkF-l)TnQ3UM`AQd#7>cY5v0O%gakX+r)mA
z)ZYI>f3ww&_UGLqP8WL`ZC0>fnlI5??O*!rVz5Jj*oG-xsn*xnryS|Lxai&IP=|zB
z85biCZ`Rb~5}e|CL*v%$^&+z8b{Lf1o?y7>*S_=3&pVv@?XRe~v#wQfG;bDDlW&~z
zUsiy7Mi<j-*@BRTx6_%Jw_MzD^SWcM$L^K&e>4`^zbeel*id$%`SS7h?Z5cu_Sqeq
zIiGJHM`z+J=@OHBsy{#U9ckyOb}H|ZIA=FYzt-oj?7?mQ{CUYGixRd@so}GdWLNlg
zgY&gR{Um3e=)UWBZy(sP;nR_(<r~wFs{i4fWTg3T!mizu?Mpvj?DN~l^=wa+iR_6^
z*L3$!oM+}aJ3C!b?r^MO>1*xUtT2C?k|e(k{|n<}r~91q4_e86{dru$(xp6hKIgTK
zh7q!#+P}<Dd1JW!QJ13A2KUL!KmI@dtAEAh#Cv}7a@%h_KC0XH#lHUTNyS~iO*YnP
z6mdpd{*6%idvNnA<!k?IE#3zweF;0f<BPVM=cJlnU$W<X=5O4%`NO26Gg7`RyT<(L
zBV(YC(Ar7o4{Sdcxy~+WC$p(}+STs@t0p^tyX&TFW|}zv=&{=d$+oL@SzF#!KPCI(
zf8X`q@Vm@Q`F<@7V&|0E<j$O*W3fl}%=)wJwxK^NUZ@?se^frOc>Xb0HRC*%g?q~F
ze)7s~&yrf&-D>;zNO>a9S6B8MdEN{U4qX!t&3qa+Z+EHGX-99~zJ2^3ayYtY=kkly
zOl~{Ud*Ob=8Wr>QDJPOHERtM&^t%D~)k_W=Bv=nPy<Eq&!O36+lQWAi+v)?|TVp3P
z8g0GWJ8S15_9=x?*NtE7dLsC)Y<1X&Yy0w;<#$CUpFCt8er_|Dr`bdo)hzps58j9-
z#(epaJGa(aS|~y)=YCq2D0if^U{B)G9$lNm*}u7zKVLr3c4y!1tM7iAsD$^O&aynT
zEq&Iph^fjkp?m`QKQcGxOLuiIc*uCgppMC0Na%QP?vGW<GTE<}Z`af^e>nTs*5E&z
z^wkf1x7d6%I9w-qr?~U&^VOD(feEFY`xIyWekB$k79y{^WtI20&(*J1htw2$@5>Bb
z`z2fZ+fpN?sO90Q%U6f`Y**4;e=4W6aL2Ku;r|+b9_3JuxOO<}_g3-W7o87<Z%CWM
z>=4akF?)LdPNqe(9qe2WKfJg*_UV!t*XJ*tT(U1uYt!XjF=xDX7tBxSk36woq9^f(
z#Dh&a7RK9BjdY(Lt6qOB?ETemovwlVvtu_u*2~+UeImI<?y{+txq6Ee=eEeub^EF_
zvyZ84{+btE{@H5%v}^Yk{%qeI?*CU=`u=CD?Sej4{70*QGpQ`ua#mk|bFQz&-O!^}
zYd=+XO-)?4$M;tFPTdIaYo%%n!kW}_1SRjh4mDuwdMLBXTk!3N-Zx=?cZm4@-O=|<
zBBy(*w8D4&qql@qU)qRPO+S13s}N&q^c%hD>zF+ncRb7QzI1+P@M^v4t*@58j_p3h
zWfL7AI<M@Z)c3%2`>KMzqsxMg(@VdaL`><}Kkb3y>#Ccpp6;HvOUOQYea7$KvyRwm
zmAbsmx0F42_O4p}{?msZw0{fwe%>jwS)k>0*%pz5r#6Wx-4w`qRsK1=bl*|M=MPs&
zYqyKCw7KV`M#NjWSWWoJ;Pu(IVQ;0FUE3qW{joo<JNxYNmzFxh(y~mgN{r{;hKOs+
z4Q{;Ayr;%!v19&ISA&&)-}JltZoPlqfBER`(+V2u%f#7ZI{)ef%(^vYqg}bcq<c~K
zXPonn<T!HYZ${I%e4c%00=~~?i<y+5*^;#3*9(>X&!@3-{g{5UJVK-Y-Y*Nj-uqQ=
z&X|`TyL$R=Yiy?Jmk1e&kVzJTvVk}3=315tz5Dm3T2bw0b;MkIh4p5#PXF|~WxVb6
z@0!2<Qegete`>B6d!56P6;E2YAFlq@d$wAJVO89GJENzp|7NiDy-MOJx$!P++pbxg
ztV)}9e=cbjJlbv$A^6QXB3X?|>F}+_w@T4#4Xz{v?>cesy@R)eP0O15cM878?VA_m
zwfMOz!_Le@{NJ2b-gxvp`;4lu?&Mi7s@CURzu#ze@70IRXZ2z@P5*7{sJ_v8vq&uJ
z@yC{lGk7-&-}922;5_|SQo^QZoyt2*Hs>n-n6;>}{p0saAp?*9zr6Dg{(tr7WIdyi
z&BV`GI)p~%SUQ9jW~K^YKzN1KQ<?1IIc}eJ*RjfnhsGV+^Kjpto1Swl*6p&oxoX#H
zi=Pc;6OXi}KCN}R`1jZAdGi_@Q{{y=&e^2hC(*WS_wxI;2h=Y5PI0lHWB6mXi_W8-
z<6TPy!;P-Zao>FO=JCxpRMbu?mCq>i|7gdp`ZnNKr;4AT`Jdd4{<gm|8~$H?deeM;
zZ_kb%->is|%Dsn=KDGH}@blf>)7Pgz-yip{WSYgY{rhc>d}sahT(Mua-}pr8l%q4B
zN&QUDlsY}dy=`Lzx7(k+dimQ{KdRAcnX#nadcN06wdvdQ9z9Q*eECK0#|CE0pa1%A
zTKcPRudIFCaB9}NDW8?rXJl<#^Ze<um}{>q?q7;rm8@F2<ZWP7stdyp=ahwxf=b?@
zCGrnV{`?l$DJhmN8Lst9RBcj*+}w{Mf~s1x4(*!aAuOhQC^ApPhg&xE;?3VL-aL}9
zTK1Ubz-768WmV#e5BGf7bE)B>QO2X$yJx?yula2hcJb`3xo3;Yr#;xnn5f7yH=@uW
zL9g)t;~B?&ybSiQlt0tpF1p+*^p269OIC?WsLm8GpCgrPdK<G>D_QO4o3SlsUe)8(
z-}IKd3TL+&^(_@!aoBEtUC*1+FSl>yDJ3sUTo5d&t|`4Omj7wvnz#GboQh23<>7gq
z{5q6Z=fgZHmmd$qujC5-b;)Ai>~w+ELSfCE!yCHpH9vlvlo7FuBcg0|o>;Bmi+zrX
zZ}n##Qk>X7$;ablV&;UH8oS3yGZ`jd@UgqM$8Ue>@dFh}NqWa4XE1zHvrbEtTa}!+
zep>kMZ&#h<w(4&XNj=h6`!)0Ho74KgHZ<OBIN}yP!+CRd67w+~ADx+!*=Kd9HNTef
zKJ)Npu&|Ba7N)J1OfwgL;OjilwlHnlqTk0Ezu#z8^|LdHY+0!4^51pyS)tsZ9p_V+
zcybvTc#Qj4*F-g}Y-jN9)LX=OP(qe_N4{3WuDYZ(S8a|ZrLJ1&7qIe<aJK9e_D%CX
zB*&e<zWrzZj6d97KkUUqx7IZNW90B@IFMrK5}=Uz{!f3iz{Ead<)9Xi<aI3TBGbAS
z%=o_f7++P)mzpD<iv^EO&)ZhLqOm}wBT;9o*jYu(K2^7jUt3mGhz4{EGV&hVv7v6&
z)(b{6a&3yFE^Sd~zHt8G<XcCWHc$3B$a7iUYN=3R*5%0uau$BKSlax_;rE<Ru^abU
zw+odr9W6I}GG}JvrDrROPxTdll70TB@N%)A`m`{u_+7mGmyHyh6pvlX+9)&SQA84-
z|NN-gdT&K9WT{90Iw?G9DSNHh{wD#kNwb(2*JZ6^dF`vX-N&?DYu1^H1G=(P*l#_b
zc3)4tJhV~wqvdR#ovO{V`d7ODT6*K-X*uiK{acbUmws9*{eEAUW$)6I$KKD_&K_hd
zP%*sD_$`Cg^K#rHx6;XJ#??WWau&>AI$^4zxj?{z+EYP4uXvet27l;V>BkcBYoF7!
z2AQ5x$?X$W4=BHm7g7uFmf2f$LUo~~b9Ry3&$kWkO{a^>*7UsnaAAFtr^s5BeI>hP
zmmL*iO}H76#5k+DNXGY^;;n_()x4`cH|A~nGFe^4oBvnLzmBiz(;mjX;HVebP|*5&
zXP10|N5dzFE#2wnQ|ebwuh_A^>!<I=hBYVEO#O1cRi-VHdp@(~f-!R%Ta56MOI%O0
z4IbF8ek{{dSi&s3z;e&7jZgl(`t^nB`<CfO_iq2rT<%|Zk?n`&9Fd?FqcY~JHdmdE
zKX4WVSnOigbLPuxwBfNmc<Qh7g0oudbIWJ?O<V1FyoJf<^cm}C`^#e2HSc>~nAiE{
zz_#P!X%l|G=+v23RpT!6z*6Jv#wT-3eqU*lnz~L>b(d?Fb#2hpTTS+>k8?_@ds<z3
zEs`MoYr}QR8U9a8b-A76uCM!)z2R(sdq$e)AN41n*iI)__NhEOdULVZ607Rg?mFFD
zKJzENl6sK7(w(=&>qW)NL+<bVOKl{L@5J~>uq>?gpUQdSaK!h@@C*BTtM5Pbjm`7Q
z5Ilb~Wrw%Pt$kGw=e&RWU|;W*Iaz@_w|l=axTNpusnBSnx3A#yU1whTo>MxqzIq3W
zJti$aDL79y%Q5LlwwC9VcWTGVel0n2qshLz{?m<u)w~=={dbf&=2fK_UT2e^>+vA=
zP4z3s0J)44&bQZIJs1|)eqPDH_<ZAW*;un*|2&yEpL{fp_$Zep<GRE>IQyc^w5Jh8
zanow6a+#KTXKL-@+%nfrv2ojh^E(foiezJ(*?T9kwd?k~MKX7izB<e==?|5=napb;
zdn1K+$wyO(4|Y{T-aQ}RbF)_Pc@^tes-LynYS4NsTg`B<$St4w)10I~Jik-)lxfMz
zGbe1rS1zbpB!2PR`<+z_(r*?|b^jK_+{gYchIwTT?>3to-9;<Dt~_z-Q3+3AyT$?I
zEp8pXUWuO<xXh9Gmr}&%-|+0wgI7~FxfxfL>dtelI>EcnkNbYS?NisMXZA(ghj#eA
zSsfueh5c37n$+6OkA?P1|9amf^qTRxGxrrMF;6e<C(2p2?dlH39=e@dPfWP=IKKK-
zfU*taEX6FgE{!#5$7U@%Y@9Odoo=d0tn@)0j%%t7{Vqw?Eor-6`802EnRMcc-)&XS
zm#xkEQ6aK-9)8LFaP0H-lyz>7eGXF}S<lm{{&jjyr^ptE!?&5PrU;&r*tDy9rszVO
z3DF8~my7*m;|kSOJNo{)&1{j?>{feY^TM6qFK+AjwX%Df$QlivcQQ%)CkX9#e#9l;
z>FxRU$j6_3S9xz{r0+WF^la<#75CfaZ!pwv{k!{f?8N^b=~6XIH)lIP@KN$jsu4<C
zy8FaS;f0&@9yK~SG07`vhI{;(^x+6&tHnoe)n|$CPIKAoOgfnonp5<9uV9b)H*Hmk
zGt;!qqw+ubZmermubC8HzWt}@%gV>k-o)+tYt)&y<KDH+-*nbLH_>>zEM8Qhl;L&b
zSB`^g&YE*46(u;{stb6OAY&eWoA=?~@A+Mdy!&U&URu0AL+g^rny!5Xr=}P`IxBR2
zn%}3NGVE<EN$KlOt-7Odj(ygSxOHv!SdQxJKM{15P`F_e^+APu!pYFkb@`nIew$w>
z?cJ7pZ%R7bxmP=r+ZTi#P1;!~WA$A-tYqbi^wsUVeIMrSP-b4FuqD#EW#@7Cm>DPU
zp5jw8Uf>;ms%l$|Nl-E;Tk^vt&*rWEQee$2>iI)!UXQWn?nD26H)Kfc2-y5FT8TTV
zsns!HBX{HEJAPW)j23sVJw2Y=c-rvglDKQ1lY-YY+%MXzna=X4hqwLvQ?{54hx~{y
zDVp|+EHrvHE!)_4e)*)$C#5ysAN1=Aog04jaHSS|ylaRMldOG~xCBde_j&E?la@i1
z1;sDcg&Ax=+OTF}^7)G7=IW()D*C4ON1xrF-z~*#e&hV9pPtK-JMWvftUA56d~xBO
ziTjsMi&r!@I2jrEFV8p8FWhYV&gPx&M^5KH)jRX)?XCrhe&*%Lo?IK=oqM|VxapQ8
zKJRO4);m(fil>!Mvst2^m$dNbMTb?lw(qS~@D*Iy&A(&HCc7gW&n4ZPb^9cbe`}VL
zjKH4FEbmvIEV&i*#nszAnqi&e9dDLBpKY?#LwWb)U2`q<E%uAPl_|15=!xF{bkS9s
z5f4~TiHUvYy0Wiu^FqGTTbuF@tT^z$YvB$}iGJVPT>E8mT9-;zJlVWhI^zV>jDs4z
z(z0)>53XnH)J!e={Z7s><9?}F5VL-e*33PbDKAqa#J~HkFg>w&o~Q{gm&60UJI0=y
zl-(?*-g?(t5*m9U&3U8Ku9Y{EYcDxyEA>Upzf^Vnml5warx|na9zJoExx`3+)uCfq
zHap{V#VsaHW>r}=wYN`Wk&mC=MX~(zl6Tb|{h#`BDwdp3XBBZ$4>6Z~Y`dIAOo8`D
z;zxEB)<tP^i`Q2ety$LRb)3hO-RSC{gAd~-d7pB*!7pu9^=aMfRZCj6w@d7}6dSq5
zQ0ldVhe*s{!<lEizifYX@Onh$);*DVcU@o4v+!-dyCkErDs=Ygo@rk1p8fmzYmT8^
zrR3!=PuHry@87=Vdg}F=CD~2$@7MMJzA9OF)oy*4>0BLwy6D_fyH_oc41e&TlUv7N
z=I-o(vWgwcc2znq;SLvgpKwxP?GDH684cBKo3_m7T2mNu?&P-{DNospnOYJ&w(Cpt
za`H44-+yqRW6zoRLOEHlgDY>cMF`)ByuLw^Gv)YX-&rM>85Z(bHHoJbtj>*1UYMqT
ze%jX@?!cKATc;(pTs7)t`g!oC&|#yhWnv<G1g?o+Fj&SU#hC4M^kVCZca4Xx{@Pt=
zAI)&R;m58y;;Y+cr^fzRWu4}^eg?-B^*Nj#)$Ma%XvDGPFiyB^Qc+nK8}jaEYGt#R
zTD#Dt;|YzQR<5X&TI06yljJ4ABU3|Ut_n&xMeN{Q=P6O(lKhOT>xrnv{cWehP42qz
zPFU2t(!kt#;-dY*g8O2``KDKgubeUU2G`k)P0?kSWlA;pZry#e$RKVjr*!3~+Buo;
zW2}O<9p^|lv-2r_E6ums`)KmI>YvLmin$p~yKp|P;NUGk*A0HlnU;&JQ9Q*Q{aW>`
z={oQ4_Zp}EykhoUV4Zk#p<jC`qZ8Z8u)J9^Of&W`{A~99(anT+t*3PTf=iv`6%N}m
zgk`-|f3j@*sjp>izE{7B?PmGJn!#l>xs+96%J~&`u1hx>+2$^On4rwieOus0Y2cab
zEVFhmUVkpp<K&9?jEp;t7IF<+vSb==Ri+$|e6efKroMI)h1UBIigfvpgsPuCu!Xmy
z;EQd0Qq`wbD`Mm}ZlBUuZ4@REGG*KB-HbxnA+OwfyCRqIeO=sqHSNsVkEPz%G$i*P
zYMr>cCin4N-XJ}-yVG*bvZVZeJL^f8$LxL(QeMCJ>Fn!jDLGyCwaS_2?LS**?=P74
zCGV9%mixRwBWIPDe~&)5;5x=z&0H=1ZTI_&q81`Y)z);z-r445*gmCc?e$Li9r6nK
zZ`M1oIN1F;|3{DMRKpty<96Z8iCYaa40itgIqUq|>B?ujtZuBC5O-x=+?vfZ{#Ipf
zUp>!HUR3zf`&Uaf4;*=1x>(U^<^Fx=TjXchIhil6b(2%Ak1(xoJN@GPifP}Oi!KJV
zrJWZ(wNE-vA^4`lo7;;y;x^s>o_8Rft9?g#-}!^{-W286JlyBr=yW`D_xAc(Y(HO0
zt%;q!G1!TH<u8*!je-v?|5=;P?|yh-&DD3?w^WyJJmxZAd41!m!)m`Y7xn-0cA2kS
zRe9#!qvaR6Z4?vxJ7gwa`6g=ht5r3hWzB!?w*Tz8`TcfSdfLWVu3$4YFf;*ov=s>V
zw6Dh8&3|Gxseb<cMTP#h4ogJ$AFYj4srH<}y<vI^&znbPzb|B-&QtvRFngtO@*Vs7
zP@N#9t0A}Z_{HST9GG+>Xk*0J<c(dro1*UMuR8kuy~LljVmSvT^+i{U$D9l*-WT!y
z-rx7TFNG}I#9gm>$-U-$pl7+Zvt#JB6Vm_s?sOm6*YTsi`13pe`;t2!Y%<xJ*gbo<
zv1VSL`2U!H&-LT$%Rm2%H~;^2-6yB|>SE7#^B=}9sCo5kOGAuaPNwN~jrk9`4@azI
zRlc|{`@R41XSIr2`?l2A#e2l*=bP<&P+#|FTHZdpukCkN#n-mZW$06TbfQJC*U?bs
zaJ;sfZRnkKx--ohpZ)K6ZQfqzTpn9}yQHLg$6@X0b$dAE?fyK;oV6~Szq%^oFt5k0
z^-=K~xSsMy{G0LVmHFD|`=Zxwth@Yfw$WwrJeQNrQ{t<cHeOh2x~S}xwra+Pgr!?1
zt%z8*dDE0zdP<At+zW~9c2vHfay#ghO72IWXpM<|x1-+X8?O}&+IY!Jf;pjf^%d`3
z8k^2)X--b#bS?Y2-TC&;+f_gN<yWqF9bS9+>6C=ZlTR0X<d-ZgIa%<;ZsEt`!c9>L
z49+{M1B?H-?(GkV(wBbmBmefc+a}vrDsdfrGN<Fxp@L10$KpR7xbSN8Dwn-$EbDX?
z>U<ain|2FU{ah<Q`9w(|$I;WXK8h^A`<TzOt~&m}{lj82GIrXS@gHZi+^lNZ+;{4t
zXa?)m*USDgYtQ+%@KK}GufMkDr<X0?bZ=)j`|%x)hb8vq*sY!2K5xez**;5qMVH8{
zi%$z1>-Bd!d@j8FE3WF{oHv#`f0tdC@pIhsIP3maTLrEuOI`N<c^`ZG`$FdxNy|+n
zoK-g~g+{%<vqQkUVBM8~+sW7ESDNs%7c@A%Sdp%F+juG4i5{i0r*~x3wf0_M$XU8{
zcA>b#m%oPs59Mg*tQC_NkLWR7x>o1hxyi3T{yUj9gK?>l&=LLBNA;?%rSc|w@m+5z
zsEE+NCz>vDRC2OXrF6VhC;Kd$Lc#5&enscfZ(U&%4QTyWySd`~=HOETEF2a7k6g97
zXQj=%@zr=&{ClyLqHcVm<#wAc2-Pl>I>Zs^%E1xRctY`^{<%M$H-oi!a*r+ZxaN3e
zzH_=lgQjSC-K<@a2Ej!OrxdW>KDwL#%1h7tK}N3@YJ{$>J(<VIC?sxbXPABQ<<w(R
z|F?gzD3RllxnHHB>2$G7<*4_AFqX2y<kv^<K6>u@A}B{mf^C;j#^Nrw!>4nPOl7;s
zbJOD~^IivMl_##huWp=wOJk|G?h{v86;<KCe{Lmm`E9#$%79@N)7_0;#_7*CMmR~R
zS)8+a9Q$nPMjm&?k|Wo)UNT(y>_u^bo4jOiDzmcrr{j+rFIG&i%+xu2z4(vvMB`0I
z*X9TOYb;zd^|K-0o>fxo_m~I-$G0mOtWCWky;^n#JCEw+Im@|R^m)65=lE7E_4r&X
zwfoD=!ebU85{tjGWb~Zew8>(M+wYC5+9v8oCcWNh&>H1pbF21=)Kp%fB?-xQrfl^(
zcuZl>gr=nt^4!5YT#ppiGhd&>caCBDigdZc9_|w|N3#{#|J`-^S1DOE@5RzgFR`NJ
z=I0Z-e|@nunEp|C_l}Yc(Z`gZ{Ea%soF<ccZ*7W9z%l=)wo%8vr^ck*o5{3m-pjKp
zeIlQ&($yBQCKa8W$-3&u%)JWl{g`HRt`~`HeShWo*EGxUNe<Z`tSsM~JU&?zr~g<s
zeU8Vm`%nH{>ft~Ab9YbtoWg~iNA!N{8@Qj1f4%R*lfKig-$hplegE2&+N*gYDek$#
z;alh5>|eC!ctg@Fsa@N>ySD0Bu6CGbSRZKGp^!cQQOk0Rxl-QUGOLxY=gf*UOm;ZE
zW1XboTE!>R&S>2K^kGIyxN~OTO`pSd=e?#*m?_~Mw^&p$+w4<RLg)lP1Ctej=N45a
zRIYOPa*1_~iLQ60?=#oy%U5{MR~1>!`^#yunpW>=caw-fF3pO$2iRJkO%VOWc_<?F
zg8RlP5@%NRnrI$7c1R>S@Mpuu8E+XDxO7P5Y&@b|dgpm#p`W0gT=&lSW3m;t1)HBu
zJ<+^IG)2%~K|etCMD;<d#GXBx>qROThR>I*w%q-G(j!J?OM|lv`pp+*rlp^m+w8{Y
zT-<Q_kTLrc$qV@tjv8M~Td2Py;iJ|X&z!YYT-lAUxYo?|ogW-G`Q_#BTJ2jG>8-tD
z$`@Auc(NP!!rq9U^20$Q>o`K&bPtt&no<4z>^lF#FfGOy%OlNhdr#b&SZ6zZqUWBn
zDVN`?etov}wSN4ByuD^z9bwuh*YSwAsHn|~7D-Zz`4G~0f_Gwl3R_TYk?Q;oXZ1a5
z%qPpU-UR2oEZNEvvwuRK!O@o-d=7jMJyP;|_9*qHoV@>zX}zAPOM>Z&Z?~StMtg04
zbI8k4d;QE-Atf#oeFFpgcqYFH-)jxA`A+FUx3xOv_8wfhkSSw>*Th0opA-g8jqNjb
zM}BWU7Lb<p$A?i(FV*3%&~ml4Udl6~Ejc(Q+*$kowwLwa-K+I&>p$`~A7r>4wQGaF
z^YZnFn*)}n&0+|Ywq@q<7wwodUro5!pCh=sy3xH-c(QkxkuFc0@B?0*=>p&0X!s|a
zDxGt6-qv*Cb>%(l@6Tq>my%quFzLG9-s?XqJDirYDLbCi-CMoN;mMkx*K<^k%!{g=
zzrpM6+utIknx+;{j)$%_v`;hON&R8FuISbggW!-0;u<R|TLoCZ=V;bx?A$VCvBT1b
zA77+>5OQKrig?*(9_Re==IlSb%1(y^nzmmk-IRTI??!_s1wV!Mu6bnK@FAqJ!%oL~
z^VgQFr0hv$B4%b=8+6<jJzR36Gip}~!-Ygv28Ks`Ei%m!y__3_f922kG1F0W=A`S3
z+&UVPABsM8cTSk|`N_hHPs^${w{2S>9nz$`bKj+I?l;Ot7Y!!tnEUZjqn5zgs*jov
zP4*T}UA$-G($9uBPdjbW*HjAL;q+@(gO5W)i;Nyy%Dfj{4L)<$|500`wruIUCrX><
zY_|J+_4&H0d%@zy>#8*V7sYH{B+7g^F(GDlm7$x@l#4Sm&-ErO;&KspEAX-~-Mm`n
zsV~o5{=<5%iT*l)HI9i9Cl*Q8?JWA5?x)zx_G6mOuQQsn-PjjBcTcR*>+ZXCI^|;E
z{G{r~O7kA+UGAFxDl4w3s&vy1^WT*reLvRDig0RM{xO`Vm%H{?)Oy{H?lp>C8^6xE
zt+vX+#6Cv7<?{T;9#1?Tsr1d;m{54J#r00$_kbGDup{ePGL|%*Qki_c-dxGDFNBwI
z`K<prES)yJ#*g}Mo($hL<7p@VRHd+V`Q9CgR%IHI*N+r<@6b<8*v88Aa#@1J?Q0=B
zxSFa>EXw8ArEq7nZk)5qz^1|BUdX8zDMoEO_c~qI)m7Tik+(w4KtQ?q*V{wR!E$F5
z7q57__2!nXQzkpV3X(FL?pwXe;fq#{PsLJ(g?6s7T^|!8Pxh8f)^WKvp~(B8{lf>>
zBE03D40;(XW^Z3^ulXbU-Cc9(rmL#8I-gc`MteUhs(kb<<m3_C^bgC^-f^zaoa454
z*6f|ykzUUBUd|!sdD>5$YR$S(lxmo@Vb7X1O(J|XyVsen6MIx{9u#5FS;n~ipzFk4
zVWm>Dn>(|%=PmlEzD8-+LaG1TdhgXOzOcga=sR~_=Ihy;O`-*bS?}GvF|%}vgJ{RI
z=f6209(fb@DDXkbuJ$))G+rh-#Vnr2lP0v?gfFU@lc`<1MOf6Ndw(=zq3)dP^4#rP
zMIJDmTQbQgQr>@Bpjx+1qM>Tt=d*1bTrFh>Z4MtSe9N!)!*U+?v+M~)d8}uHSr>I5
z{1ZI+K+AO%uLXXtwO+{wCFch`nd3C^BiB*Z?FO$!om@XYtzf+%(!S7f;*vezE;Gk9
z-d~n~w{>%loa{U;fwTW>j1=e89d;7xXX0Ph{=fQr`He%-THmh;noD1PtAGEveA~`g
zi^J<yzDbLVe7I|G`^)yUyO*CiCr;laa<XjAQTy1BxwqH)$3EY7`_SWO4c3S4E;;Wn
z{QdGn*&Xe0{n__~FHf^;{QbRed1<|s+4dc&eqnjWGgtrI5&7_%X`p`i?cawtzBS+d
z^7Qg`ACLTPT=zP8^Q+pm&qMU(``EW@=ie=vd;4kF(%ZLZUEQ$I??mUG)UxE%%%wh+
zf1*BW?cRSj>~Pz&vs_jR*^R$Hr<}d}Z;$fSlK$BHZ)!ds489olvTX0IJo%NUN;zL|
z+vlDfTA%a&J$u>S%S==GXTMtUu3$;mOF1{4Vr$O)LhIDrpP$&wt$)Wh3bd?x>F1?y
z6n^?y@a=_}AOAhP@h<H6wUey<+VMTL&x&q7R6Bk6+n0H|oCy)nt9rukq<5I_H&U!_
z63)B4<k0W5`!eCT7tTDKe>?5Fyu#|lvY!j@uK#;FZ@s1I-MMAHclJfe`PCNg(B?aS
z``M3BCbs=f`)o^OJI<|*`=+3h)&H$TuFqEVve*gxTaOd>f4;4_(MdPjzajd_$IAN_
zM;zP3kGpFfn)j%5v(whg^MbS@FYb0+9nmuT+{T_Ym)^Z!DWUR(*YWwTtF@137e6Q{
z+P=H-#@qiTt<o>f9`wBYgssusw#O;&#wKR5+oB4s+WICj`Tu@hu4V{$IsZaL#p5q;
zUvQkSur6_~EOoe<dwJ{kYMG6O!M8eJN9NxC&8s;jhyMhRs^f;VTB~h)@6YOgf9L1I
zhI0pmC#nVXlzrcjTTpJWdb<6Wopp<g3!W`0W}e|Ty~N=wC)*6`wG51Y4Qf}`2c$U9
zI+}h<mix%=tIMyw)w6qR^YmQ-7lR{Hc^5-5+o$zko;>-G+CI7934@5u8ms#Yo?pyc
znRHj?Zzk&phuzZx)h!ksS{Ac}Nq6Dv6IM1%_co-@(A~di?w-4uUs?|F#(wE|&78Hd
zd`8jJlA8^)cAxE%;SgPzfADqTRpG@CbtUgfZQtrFX?gSb_pK_NPbPi2{&k-GOtD?h
z{}f#N{7=^KrFqBYj^)+sqspIm`&CPPz3nc<Id5U|ji2lRcUQW<;0n|2U;bB)Yl6n+
z*x8XC9and(wtW5d<8vR$j9LEo>M!_oR$t?HJQlmz?QNsl?L2qaa=-Se^G~q_hF|Gf
z^|+E_`WN@aj30Bo5A(7Je5?7r<MW%KM{1RmSC#NiVDEUXs<`*$7Tr}rvlIQRu78=?
zW>_6?n6JS6L8JQDdD2sP_}3KvJ2yf8;KUed`$@g>DG{9sD#?i-kC*K}>%sn#PtED^
zv7%Yh=Uqkih$LB<9x`uY77=)`!I8IdO}X=I?IYdA(rKK`a%oX>Ue9^JSJapGM#^`=
zR*k0(G4@w2${Q9hjm+izd(Uvk!K)W}cQrmUyUYK7`TH}GHcgw2|1}6d5<Iu+r1i@}
z$%^kRJulVc{h1Flr3a<m_2HV%w_#`Qi#m%;1sj>aYlAx$ACo;i@8EIXGf(O*wm*D%
z;;0?plD*HX8M=Gcd{ar@RXazL!?*3=x9KuGGk*u33EmRN@&4~DWv%T7qVfL<%(Z#u
zsw?J1c6y4Kw1p?=sVeth4Q#YGbUV2~d=Iay#mhyLKYdmdTl->DzTL0q6?_NT-nr#f
zOma@0^T62GF@P!IZH=%APs|w}m&5|*Q|}GT3IewVIW}#4ezjH4`N+FtrlpqU2Hgku
zT(Ns;xKwgM*?a!mFN*jgcHNyd{ru?_r>ks~PVlM-Y`$y1Lvr?})-#$`KfG7eJ^G-?
zYvOFvU)U=4Z-R10qD}r`dzqJJvo1f#e4l<_`J~Yi`v~z54N+geT033I?H01UocMI*
z@#a2`>1VDi{heiL7W6?^yGW<bC(*M;-~{XPpb6~?%NISL+cl?HOa9JD9ZTUuYeoJq
z+dQ!#dtL3T9F@O4#+f~-=dGCBd)OoPKJ!_USsXo`GqC2xVWTFlsFKTD>^>~wWMSLv
zz2TUrYKZ&_jx#TsH-0_%w0e3&gSCrJoyo5&e?CQN#MEb8KE2RjyQquZV-uC+`JF8P
zEcu*gZTY67aKfTVar%>khOA7sPWxWegxt4bWsQ9lbz6Jk1ZSp*<96R|bW1(sO<R@<
z2D)eaO>(Y!mlt8;@oVD)4;MefNqoJ{$1m?|ZK!eQe_)Z%Z@udNZyWwJJNy1BHa$aU
zHxun0qAkDMPKCH$54`KRh&j|?R}SBd4+owkEjE>ioH})7u>O1&_8IzjeIK8=mi*+$
zy`@Ln?|z%em0{Y-*TA%^g!jze`KRlq{NDKM<jy&~o+ky;N<X?xnOR%-dS>n3zlJs)
zXX_=;-;uKNeDo^v9lOc)b$={VX7+iqP2T)(``NNdpRfDdHw(?bePy-H_tUd>-7CDF
z%If*3*k-%fx3BYlKV_RO>%U{8uIFKaLhb%NSKqGfeip;Wd45NkS9j%?H*=)*CTp#m
zR_`CAAMWefET<f{XQ@x)qsl+ICm-DV*7=^Z+xf8NOs77+4!@pa$v%6b{JYx|_kOOK
zX}jlY+2o4SM=PE@xNvA<dEMO;`rnr8nmZ@X_<8Jm?22B$uvbt0S4=p0US#IPGp{f8
zsNb@!=RPVrfqkRab914o`yW_O-kf<c>!Z$_)rK?c;)?%7o((MG+?*I}^84$@kBvO5
zw4$ag_Sz&n<>IVI%C;u+4=LUJ8}W7;Z|vb^vvLgAANTq6{n_`KrJB|*FXMl%xt{2H
z@eF_N9YzPUkVmZFEbCY&e4o6oTd5$;RVLC{{<&DpVy}p-bLy7_OD(m0mhI$r%=l~B
zw92!1yIsv4`9CM_?r1QPyT7`7ae>6T^f`~jh2$G|y|cDY%AaR>>hr@*$)>z5nkNqN
z{+N6<z-!VaheK-(jAY(aIQhTbe>SbAD(C5c=93K7Vc3TGu<WofF*G+LdYDi8cHiS|
zUu*XtI^k_{pie8V#5qvJ^R~!s)>&rO4$W!57i@iLxN+MPuOhYE>)-DT6pxlWzwCDq
zOXMY$(u#_TckPqc$c3MLb$-3bpV@1!cxlTnUlsB4%CVW(R)2kXb$|TP%1P=^y=MLX
z>HnuMEb`SYg9%4i54F|1zxdAh=P%2@?fmQOKF8*T-#S(~arM>1-<Z1F&%RpzqTjye
z^WDRD_sjkJq$RlI|CbLk_v+jKA3Bx&mRsO-cxp_VmGho19lhLLr$U9))zY`z%bt2>
z!>_aDxBT`kl=HdpDF2mptjqj&?|L;CuUlVr{I0X9<ooFVKVC%r33S<Oe?Usqbh)+Y
z*F6V9-^N|bn?23?sz}l6RqIwh-d#Og_2TSV?ERs)e}B!4KPkTNxonNNU6gry^J?=v
z<qDHaOk8JI&R61n-kR*^IeE>ysa>Z{o;KHMd!OO*m^Pbf`jf(0X&ZF5Eqxjq6?XRJ
z)G0@^HhK7EZ#MZ9os(Nq(7uc}S+>7+$8L5ei+KA_KYqJJD%`B=KYp-L{r>xkmn)B*
zyj8y2VEgJ<zS~#ZDe=a#w`eyQ@LRXdbvu6TuTQYclQ=hbot!6iH$#`N`|jK8-sGHC
zIPI3D@2Y+4uW>w3e&evZ;pu6W_RxYF-PLkseU3^uqu-Uy-*r!R$Ntq%4ird<p1hTO
zTjuAVT>Y8@-mB(SU#+um)Dl=V&CdMd;?=R--*-LySnIsu+J}qFcOP<DpSa_U(xKYt
z3r;F8yHZkHx6RIdTFAw;ZBu)*7N&TMSUjHP$HB8E?8(LI)STx1^~YpA6%w|%|4Mj%
za{D{&9jkOapROvHa>6(|JhyJ2x3S=aeN|H)rk#Gf@Rx^8bFIF0zKwwg+a{&`o<arx
z4us_GI#+*#TS3h6PRDGq8;kg>`NQ?v`5r85KmX%H`>Jp50{*|QrLpiy?F_$OclV>i
z`^GiwS2znMYCLXDTXyi|0nHofK?+N1uNS;$j-66$`u~e*&^GZ^%%3muUb=Fu^xsCc
z(1c($h90>9mrovM%0&m)sOR*tRIBjnI9!TZ#Wh>4aN3Op!uQp!A}=tz&f)WJN%(H2
zo1A+7NLIp%>dBf3Pv=?7iAZ)=zJC#5aP6!5PTt5vxxu>)_^+@}T2?T@JUUY4!?m-S
z`zw3@CP`E~C0OVcJXy!0ll4Zqe5RzasPB*C?`tQ7#szU+@!A)kFt6eGqz@JQj&`38
z`M~=^?fBh!s;t$#+jqZ`_;Bp8=7lNN=Qo|>p7-I@(<xe<UDKXx<vm!$e@A(vl={CP
zf31Jo%CJRVdva)#!DTDE`|4uOM|w=>Gdw$Ix;y!@&9*9o4e!O?_=#zkM60Q}>VA;c
zI%Hw`fV-h|`%IxlN*harww71u&wlpczw@&h8H#E`w|ZY^?wI;;n-c4x`;+9>e4B3-
z(|AbRU}i|_7k`<0_Q&u4sog66k#+d*2Hx8XZKSTM@UgKfCT!0welU}dMR=J*Z>VX+
zhrSz(VJDuiOYJ&*qV(0Qh^eUy-tnIfv)$}-_ls3&ZqDbcDQB|<U+DC1H7s_Uw`u-H
zV@2b%Lv<e(m(C8}yOOQwfWRH0`sdm1(;qzDky9)><4!T}r)BO}r(R4At`>;B_DwX~
z<Il+`f#=zm-rq=$O74HkRo#5cG2P+WI}e2`3>nX(%<pd&yKz@@PV9n5qKVrlwThZ&
z$Q)&4xN&0M-hgGV_6uFu^w<9Wzn7&qmZY*Q(>ea{)D)eh2{&p~ayo=|OiO#8wCxd(
zko)Xe(f3ckV&nYgvg!yE^JeXbDMA{@=U)5!`$_b1`wu#6nD2btcdI(=Mf^vV-TPzN
z+oBsb7<x4sK9)cD_v4<2$JRINdN0dsmHi_A@}By=t@92lY~HmX;r^9`XzeYG3ko8Z
z-af*_dcwB#Ug4^BC%t_-Lhe+4deZE;-s<bwg|C>qELb%1QZ|Y1_`B}qlG8#HmBY_W
zD-qCI^P6FDSvGq~)>HLKoVT4-r!n4EUA{VB`VzC6YpJ)&$|%7_eJl32-C(e>mVWs4
zw$YC0V|;v#f0i6pQrKU3wXWgh<b?EZ1!+^d`<Bm(;M;Kf=ib%V{anJIUEd(2uvKQ_
zk|Ui4e>dm<o-7=5@5`pe3kt0CWG5v{D!0v;wz0?Bk<aEu+?^X~=bax)2e4O{OH^|7
zA2PP?@O9hx*wAim=M25zwr3v?Iv+01OJ)CQHYf3Mg8jwv$7`E%JH$)AOmf@(D0rzr
zG_RlNO-bAC*%vZGas;ovU7md3X4_T4O8+(dlUFzhoxJ`i>Ja;zT&<qe_5cyy=b7(Q
z7L`7@!>6WxV@vGeCXeR09I4xD*To-DtuSrjPiFoyv4ZRIr=)d9Yj_iNvjca^X8He3
zR$e@d)m)xMd~2%KG!}7wjjTrsLf&uUPFVA;yI6a;@3@Astzr1%h9kdOmaJ{q>?*`D
z|Lvi(vvm4P%?hU|F50^%q#)l&^xA@ehV5V0-u5s2w#oY_@7?pA89Lkhh1^6;b~2W0
z%`Lusue@>R_Cx=F|1D{FvP$^mBI*8g&52VlZ9H|JDYkUmv*o`{JQtN8oa_EI(c4yC
zlrKT%{H!-I0zG}Di}EIL^G!=hJiBhvk4Z;_7lz+iGkaU<+=|y<+ctBl?keo}<>rtP
zV>M*|b~^8f=>=`y2<A1FHeaU{YBXMypV8IA{<7kRAk)Uu*H7n}*_=FHKlO;_)Adnj
zHWz+pS5R5wvOK4*{r#O;vO>&OmybQ``F6yD;itT{QQOLhzeP@U|8zTSe(kE>>(U(4
zy!?C9jl3A)429nlo7(;!mp;)ht+3|_o0C9Kmj;J6(}M+DL^k)>CWMuF?P6^yopsE$
z(EFG|5@Y}M7us&AUdkr36gQ@`@!E6n+^ADAw3?d4eN^YmyBme!5_57VL_`@sw27;a
zT0i&poRb%9Iim7h&bctYa<x4CLF~~&#`#H2{C)Y_``_=-o_=5+Lz-JoL5!DhuHRaY
zcG2l8j^xaUp6?cM_FK-s^}X+x{C*tW*4*_o=hfTjy!4Znd@_d&mrp-<b61FePrI+;
z1FM2{DUaRNWA3C`G3!VQt^2Vx#d`Y8-7Jjy?s0}?7f;+e<nyI4Zd&p^@$!rdf1m3e
zKik24k;6^wJ#+Y>+Bs1te=N1Cn0#UKgL!<LiXWX5H}m@{xm)k0Npa$_XZz0U-1^in
z;9%j^q~Kh3+V9Ldq5B)>rKGt9tm9jF`&MON+We<Uj`wtmHm+D*vuwGZ{yL2VZhkH{
z(LDj(Dzev?oSfv?*BzK&yIF$gc8osT;h)9_Kjb$`ZvG=>@96K_6SXSh;orPY$8L+$
zm*U$W#Mo!AUM`{c?Bj!Jo4$BY{A#?>>~zZ6Q~!;3ZDQVSx3&A)l^YUHk7pm-a^lkl
zwUkfR)4IB5-?G(pU=QbC9r@{LKlgH`n&97yf@i*5`HYM8s_V>-Mz)k?nv6%*zC8NX
zCzR*^`O>i07R8plcMZ6o&AvRzRNtgQBTx3^9h)Gz=Sz3hE#a<Z)zJRLr&e}dFH6U-
zS}kkQhG}{GJRT|O?%#51*Tnss^#dZy)S~jm8JeOrx^Dlx78vz5grzi2r#nGz^~bdJ
zvMPHc<M!MTyJ>vV@{3<cf%N2*5^3j^-Fa&to(wFgyrX|KpX<iMG@F1Uo`x|cTi+e_
zONmQdo<EzvB}tKKLc*t<Esxgmvaeu0yx~+bm(U`Oz8>QpqSb0KkFpmQER=5BWcqn)
z1()RM<8$&n*UN-ByBKOMT&=$KRNutuKejr~+PNq<T~+JUqrOY~T@oi;+35G>_3Cqr
z58R$0%B<U^Q>pj*z=FbMU+!3YuK#(1o3XvqxZ2vo<mLg9gTYC2Gfh{PW>4yPJ*#?u
zWY9Y<krNNv{v}Q{@LDad@%_%N*Rv)FR^F=A`Kg#y5q~3YwZ@bUYYp{vt}oFKl)v0{
z$WkyVcE$PI-t`mr=Dk>ce&P2`uT$-urRy$E-rJI>YIbqPC+naItg)4Kig#A8w^Y^g
zOqzQ?<<4yN>UsH=JWqtCcqONvcTx=xK4<tO!GA^i`8^Yyg(oFx%$K?NUeQk2bX#7m
zX^lRs-@L;81+B|h$=@{z_2DdASU=Cl)Gh2#F8{5si+}H!a?R`UnmJ1t&rcESh@B-~
z%&yvf{=V+q%I}X&W3IkfCG$b*zJaFf84a<#m75xqXRn&R%HXG6(xF@PjvxDd(sHKP
z)hDy;MHg>a{Vlq2Kkw6=<IK)>^%{p)RUV4Ux+!Czb+%1aWZLu^&&leA>(2g<i;OF<
z)GPN^l-f9d`}DeX=YCyU8~4mp_xFj+b<3+4w%6~JK2as7{+#KXk^dJ}^*srt($87a
zlIDG0t!c3M>W0%I;%D=iZ)AxoolCKtIVbUL>ZZO|_EF7s3oeNr5Z`yb>dEhzA91fw
zD=|$C{Sj@e8_TpLSpBK6rv0OcaM?SOUlc+OtXEkF>KkOOzcb}x<Q&oMhkb2N?Gdl>
zobjc2y@`XhXnf0F{k`SBGml!WC@y$fQa4SSM_)qs+KdyOQk&|g1Rr-7{BmYOR?hdz
zNkvT}$ENRao@t|ZuzTjF_BF;Q=h(g|J)Cm)w@PHnl9W$(JU^a0W8U*>PJY3gO*eY_
z-Bx5RxZ09m5b>kUA&^gOevQEWg!gmu3v_0voKsttI!FCx<-V)BOK+LX=v}jCqMyFw
zj;_@2V)DEn4m11ar@m6&Ytwr1-DSp!Nx>K1h}X6o>0LRJF|%f4+_JN4II_;ZImwyx
zlvS`Uv%yHrXZBR~#A!mOKZ$Vs65aowldmE4^RBBrH#C%u(=IM3&M`~)|2wsG@v$3@
zUUFP}ruyDcR%zh13)MTbN95Mdb)SFe&6uWeW3!6()l0^8Q<y%^vAKSL(c(25|4IFq
zn=<y6f9aFh<!`-5O!B?dCASO8+;dYOzKpgDY1-@~caOJN;7CDH#iv`7k1zeiVf&rC
z<m0waQ|52{aBZqjzJKY8e8ZT7&mYK_|7m*uY3At<FSf{XHE2C#V2ctHd2wbBM@{~$
z+b^s`L_#(#nEK^ZnCho@zf6B`pY&diYa`2^$J-vY^|#x4{day{XZdcm)t-q5Cg$Ea
z7TV~_x_aS{vxnC1xZx-9s5?T1@$J=JOT`6GyC%F?@?rK)+250wtN+-1)V){Y^-Cq`
zIEB?4c1&Vo^}FP0W0%DIWy7MlWyz12x+nU4aeN;2<7?jzc11<o4O4d+m8mb`+<o%Q
zvGUi!*IB>pJ(KUR8yY3Xx4*FV=~5+euiT(%3m-{|d(U5+lzu*R<I|TFi(YzdV0S40
z)4}WBzKQGKjj(y~JDlg=<FNWt^fBDR$j&(ZwJ+P6XE&EEUBQz0Ia=N~rcvpMd1CN(
zyRC<<gJYE5Pdu~5hwbp}Huv+d{6Fa>EWD?tDD+f+X^+UieGS2ulOtXVX`Jm>a8hvX
zKV+sTDDrPXVnd2Xs;dgu$;C5s?yXUJ`8<!inJKGv-i39uqr6HCB-vbzUn~q;dFId0
z3)h)k&l%gvK3X3c-6EcHYL5EdHM5L3&V<W1y;M(kl?)6L7TCPse@9hnT!fABMU|*W
zin3n&EOv*q9{CvX_GsONx;N+j8u(W{%-bh#-fVo`dHwUd^Vm%F|9%urKPKK_+$-=X
z_(zP{oR43d8sr(zZ?%8de#^09-qY8StaU4yv`Wt^tpCEX`la*A`X9GttpCoI7Czhj
z%dk*0|5SR;a$#w0pQI&bY@79G9hvjL@Nzw)>B>BIECUp#Sa$rF8W<714ryyl^yE9+
zHr8EVf5W_Zby<eckye|PS5{s<Ta=<{IZew_RGt5h<U5_WGat@)5^?YIYk%`yjzTeK
zQe}6CY-Mo}$S~Qpe;>o*Ct0;qV`@JuweCL|TBRB!xY}gDkk_%Oj@3`U9X+p~G<n97
z9gmJ5TK}kg+w?82FQq0~9N+lxy~VFXy!&VL{Qva1d;NW>O4XE{qRDZ!`|6#JKEHaE
z|KjWS`S<Jg{rmoW{~nJSFU;rrU;JzT;rv&dZ#MojCWO1jWGtMxF6P)u!*Dg<M=HiH
zVPe%Lv41xNcna0lt=Rp#b%IqE|LiWW*sK4FbU&?lWUgxaZnb`l#hZ1PGb;CbEZ)}^
zwE6X;*R4LKU$*7#o@ak+?S=)5elJ_Qtv7q!&z*Kta(5n%{B`Q=W&0_AzMXd7`uSO1
z!^2(epVYm@`j5oRmfcO<xn|e9e;W>p#xb`0lx_96yd$9N8lOpw{-#9@ji>i5I(l=O
zP1fp7ho_qCSSB6Q*7YvoiA~lo_Fpf`g7vkvrrpSPeLDTDEPqtKnaPb^w?cK#IJ~t^
zkq}$;*LiEJxb&(^T5=OJqju>Y5dS?bQ~6jy_TEQTdv!8fJNH}3@mHz4ZfSja`<5T;
z*5BK1I%)d8ndK95b+_r>NJsq{JhQ^gZ#Xllhp}&8Z@RA7H~t&HXzitIcl|@M-o4zZ
z^Lx|l+iCv;^j98TymT#JZ0n+lGhcjdbbl#bw=3~?Rkk^E*WKjyGv15e`erP&E%Z_e
z-1$;U>*{UWw_)Ks%YS$%FIXM-?Mh2<KxS}$cAm|LcI$s<jDAkkl7ID&+5CI$P8Yks
zN1P)Sj|N5OW|=?FSu;y@cWl`2c@cbT!}|8UikZG^{o&s`k8>8MrS|`s9QkEsl-cgk
zo7ZL^e{JLJd6uQ9BKK$O?Nn}s+7**bR1GE57%B{eD?GOLgibuXr)=N<r+PQ1_Hj>s
zD(0BPAfcc=jWu{`(R$5uGj4cPn!bE8F^`ey<%#ycN?o3wR#_S=-Q8u@OjFtYA?f;?
zHMbl;PS0iy*kBow7pmGH{aHaFU0dt!MLnfx@yvM#tW1l;trZUiZqoUce${M#wszIb
zo_lf67cf1o>OPgWNbW~Qxv<s0wYdQqiFZ;rFI3Y$^5M>Q-gDo%Uuf`t{<VI7n|bZl
zBaUf1b{G6$$q_kYR>?Gbv&!OBwMnJw%ndL2a$TRMZLeIi{cPXt8B>>pN@l$5vkLLk
zS-JPM;Hr6D?H-|PwiZ45SnFWpvt~iFD8J`kmjIg-#dT_P-)uX0Mpd8v%BMDy`<vN$
zf-WVxv_-sGF;ACItnv5P7ZzKs_nH|jP}6JB@_*c?8(8JdliAR-bmqDVTfh2Vx4fWd
zURJ;1%!jF)*B-qzEmvy)in%fTE3REFU#A~wsNwTgScI+bgF={Bz{_cVzkjes>g2qT
zb+su8&zqZP81n3h*BhVye&4&HYr>iCaJ}68;cxY%>hnSOCj`|verEW}{^}F!>9dKO
z7j2(?Y?d0+O;#n%GOd@4EAq~MUeNQ^*8X>*!G=WL*CqzHwVq68YzW(T$Zkq?+I7{c
zm3=Q%&rMUBmOFdi>EMk%?DH8K<Pv7H9JJ%RbN5nmJA-3ntAUk%QesQ+p>Rh|U)L%|
zx9rF{2QxNI%Q-&d8gF3w%$$`mVPEwRv&(LsrnsrG`)5W}-^90pvTb|^rYE~h_Vroh
zZyMFH+~oy}n)m$URv&LiJde1zDJzB5g}v-W=gFI<FRqKVmEA7-k;bsYz3OW~l=CB*
zn2e2P%P*{Xd*{Wz<x*PPYTvEUp1eIfKyzQts;j$hRmuOz`SN@tchdbI6KCDow|Kh5
zgJQMr8%tg}xt$I+(rTS`=*8u?Y<K@^OEu~<bEQ5w$}#s`tczQdqd8;Zw<o_J{W@_c
z{o=MbdxQ85yH;mR{j-fd`pVVC><=y+cDiV|dZvh>#jZZd`Alan6m}K9lw8fJ<|@9=
z_hX}1N<&D{&w!=P0biwLN+R}L+oEEomFu5-y7#H)O(uo~6NPRq*zE9#>;27_k#bS1
z7P}s>ySAgurD|G*4a0szd6q}}`*-v(+uULKu_9?{n_ynEl4|b`hb2LZw)Y=%oH?c@
zxvX098}pRPf6MMFycb%&=d_SbNYbNq3)OE1pFXdcap+WYXqN4Zy}d09qZqHhH!J-f
zur?`(!H03l&QGETSXa;N2-{MBZ9Bum+;_h&-72X#dTnavfoX;X&Wp1i=jW(39NM<>
zGlzbkRsW)n&nkNhm}kCtqvC$`$ks_0t<xVk#!9Zu>rnaBzvf;3t556hHT>Lkkm0!Z
zg`+=No27%^scAT5=`H%2@Op#jUbRQteH<&&*Cn6q$@<n@BwLo3l%&{yE9^V_@!SHg
zG7(vW*sZ0{7MR@JzkAXmDVf?keN~$n&0c*o_YZi+%00!x;MzWASGGvSPSKk;a-Vco
z91`~aYvPjHy-haA@P%oC0n^fF2jrU13M4r1-Xz3)bm~zhosGp)#1`jnmR*(ldxyK`
z`a99yn{^NCZMa(B{rlz?J(=hGWP?&1>#S^lT$EW@$*1^*A#vf+ZQ5}xXX12^KZx4U
z)2dX$mtJa>F0tjt+iRQ~J2);ecR%=hrLtZ8_ola+y$tVb)ES~30{%^1vgvM==Y=VE
z8_G`UW=emUoFDt~&yBlj46DlSU(;duvhwc73+9XeykOj9kT33c=tf`Aj=pSeEuq$`
z-COP6t&5vB<J$pV<C7WNC$10LDR8&W*t;_D3Hw`-RSu2D5dpKFyj_xTJ>|vza!;wE
z9HxC;frUwDcFu8srdV6%cqCn1m6N?e;GB5m{i9YQPgXxsJ6CHL6f!Td;@k!W_own#
zjFbIRiVB=g@p8&)vR6L-FpK@<9B!4^fcAzLxfXkhr1=ijIZCAXE$!o7s@|f=wUN(>
z`_ks6ZcS!6|9-q(em=hN`nF#`1GWdhzmlTInA0))M$zwQmmkdzmtRq6GWpo&8yl>w
zP6jN@5vbebs#uo%euXc~wzwww1)m;ib(g-%2|97+Fx#>jKW2P6+^{pbTPIjp-RW1v
z&)oOl&Ni_X)L;3uEN)}zv#E7QcY7{4qp@4r@VM^U1Cp~Nre6#xKEm^`<mS4{+nHTw
z6HhZ;EO>LqV@_d`=HW9FTI0%e_tkOB@t<6^U`c0BH_IFa#-KUR_0m-t{DK!Qny&Cc
zvf;$8T)yVXrcb4mJmk_3#Q$E}JD)Y@o~@kRjSksGqPyJ`xAZQ3^LpN|mmWcPC*4?c
zyNLh(%^u@zOeb;=hRXZvEO<Nr{rwBm!;BtwE}L>tezo&1F+r`9i|ZFCeOQw+=Z$-_
zk78(fIYVgaP2;)K_MF>$XN~lYY3;e<PCn^(jIHDq7V8>n%~6qjeK)51r2UJS;*&`w
z_jkw~_sy8Iaq;cjp{;6(;fC`V#KQO4)&ITrWb<98r|BPSedq7a@K~}z)_;4%@&{j2
z`C|W1UGe1d?%S<itgm7O{~i!lGyHW+_ni09_kw;(#)qfBxNpEz{Z%fPi|Jeqhy1hC
zGuYp|?Vfkva`puO!=e|i=}5X&m;Zhln~>^se38d;ZSKhF7Uq|}{uE&9Q!&f3^787L
z`9Ms*GvVN4Sr!(4m68BSm9xjhD;9)qy*lwrV4h#ll%rbG8cH1VCo~*a&%0E$-TsT-
z{)tC^+SI<%x%}enO&{r2tp}S|GBW2DI16OF-f-gRT<@oipE*9qsLa+<nJx54S9FrE
zgZ|r-&wfvTAHV<TX1iiPqu|1o8HaQ_&BQy?<X%slr@V->_LJi8_A6{<0#gs#O!b+1
zUZuDr|Gx3vQ{Bh5d~4d6Z_oCGa~YHG%rC!!6Z8stk1X)JAG=y4K=^;y?1TjwlTVy{
z`LONj-mJ3Puh|ziGbihOwYZ?vs`2ZwV5dKKJbNGu+s30^p$s;s=bbq5pdz7_&u?m%
zM9IdpnW{II>du-e%_nj2`IJ>3rY^nb_~h9+wkoS_K@)AaEPk|`fBTPbS09BI&p2}D
zLz?%@qUvibSDlZ$cVA*`yJ{x*SN8CpO>1*izD`+xXoiLC=f&rRx%w9>>Fs%JZ*{-m
zx!De#ZkcVlJ%$CUHD0yC3i_?Jr?@J;`fO^#HcIfXmSK%eHg5`UHM+d<OwIN)N6$N@
zKQP|N!@?Q#K(PPUEAB^Agl4$BxZ@lmu{&n1j@`qJYS(6}Ml2C{I8jU4JE8yV#u8D9
z11i!PKPAcneP^9rsStDhf$j~Cv&S;`JeyXvpt$2a<D}fhttsYi&dzssmS}|;?Azv4
z8NqjNaeE4PqucEnHw!P;w`F{q^Wm4}bK?nW_5L2G&pAf@V|SiqJ^k3(qp^wnmm=eC
z1!Y-3IxF(vS^tUO*$Qz%8}$ygFMj5-;tcms{hEv_iSIvzO?RFAl48_jWn^#gU*gOU
ztqX5G)l-i5ic5cO|J!y~Sm3+EJIP{}m!5BhHu|vdmMMsj(U`H+Ak1iY`xoE0lVlkm
zI(FNy$W_?M_u^4p^m&8+cg`$c4F1>k_h=q{5fQUNS)O@GN~X>cgVR<sRA-(kI-F@g
z{W{a@S3wQ4K8v0Elyq9)0?QpGn>e4Y`zQ4$O`mz7SRp8eN$J`5uigI=1S(gx99gev
z|7yZ&S?{-rT62pZdp@$2?aj_Ja(}0mIU~d7Kj+zrjhgZ<r`@g@ylBXZ*vCIpk#kmH
z$D^NVC+69$dLch0<KS)W*zon`hgC)QooPCEqiy|a1-%8o3*Bdy@0$BqL+0Jb56fpP
zcPyXu*L2tWOF`^B`C8S1hvdX||2BSSHz7dkV|(`3bAg}g-$nJ#zEjJvL|$X+n`4W)
zWw$)|;Q1=Upkj{UrN?_j<Yvf~d4Ef5Zx)gKTe09ziq)JAI~;R^c0Ue_Id($NE#Qux
z<?fVED>;9<G*m3s`Y+P3TFGzu$N4@^Czx(2UCC#j_IPDOeB@h(*Ov~xTyS=?_1SN=
zk;3W8Rm!thESkUk+*G^jO2vNT#AW9yqu(C?&Ay}GGA`rxp?jCio*g@C6S3u_Tt!s*
zR_>iIE5*7EpMI8i5q$8j`QqG?-^Cx2I3@0t9J(IxfZ?|CJVEmpNjJ`X4qo(o9?Qoa
z9j!*<E$ngIUjAw6Z!~n6boX^Z!-ff5UtGoN)_jgF&`?#s649>2t>MpAH+4>iztBFm
z>HUW63+8YA(Z+9RAhWuvoImVmf%qdQq2_|KB2{X))AnQr{;gS{y|^oX-^va{K`*oJ
zH0PkYscK4#h2{#bGK?twsot^h@{4GeCBGBWe2*^MF=x*#P0jYBuQ{*zzi_y*Y*KTn
zpK?mj(V3I{A5@Bellx-%sOaI+zb|IVGVe)#_T&<`v2dJ_vHJQRvwtTKoynMU=4s<v
zw*AiY&b(msdsX13uenUl+ek(v_4($rzaCAI%P3o@@AK04-9H)Mm#HT&JpXp~?dyVV
zkzJ20)t=c(O})4`dc~R0dyPTb;hakwKK=?b<Ca@)`SOfv%SMAD3;#vYCU3%6J}N9J
zTPDA2@50F{Ryqc(vUMN6a$d+b_LjZxw@G=%{-xaB5wp^EiSFojH@?fokTvhjEa@3e
zmA^V32QT91y4sSoX7`$&y;_1Z^cw|K>}6G|q`#y%?Yq(E`sH&9U&iO}7eZKDn9^+K
zSN!vteCKk3wV|o8iYEV-iC?&dpEU=5n{wfko$a)qCV}wYmD?XEHg~12v;D=RtS9zu
z_NBieOg?HRFEgS`V|PCL-eLSh#&}D>%=w|eyuw~s$ogK?)IF_#!RYJpjG3{!=Px?A
zY}4bC)TBpS4EFJ+o7*_3JN%O{)MZwak$Ga6{_%1DL+|pN1}+yWJFmXb`RO?|buatX
zBeFav4gOt8`BF8_@qVI{EdSn|9E**`imh{G7HzUTwJ79?-fyM1YRhi9s#n<E3s1IN
z<C6W4W%DuT%SEz_Vl#4!Ez*A!eX%J@dsmduYLWVGlhV?~7k2LaY?B-F@_vHBp8QF3
zHkZB%idMhKeO`Y{snW!B|FG_o3Dd8?7rW1Muj@;&$T8!xJ;_EhB@|!gRXQfdlyALx
zrFs_w`_`umW%GO+KY!cBw(V8c$91=IUMBe&S=Kjj{b%dkp{IUKZN@=AN4_V2E_}Y(
zZS-@7-*K*0{f2?u53<%<NS5FKSr~uqn_qIA%;9Awmlu4gl1p31+$r6VFmdVS*}D7L
zI>HPM&g{PaXw!0azL~}jX0c~JAE}$5IJI1<X?4nUrQ@rmpYVO3y1nk1|BV+ao;q9R
zJeS)#eU9Jxb>cB!?nJ)}e#AGU??wct@y{#T9n2|DEB3ATOLaN;-Yl|1l;!7wdbOFI
z65cC!U-R<YCNnqZ8rz;Z)>+I-pIoFrT=Tpw^KJ8zQ!LHLmV8kP{u!99v0%l&j7DW4
zjhv8Y8oHbT`o}G1UeYv+mR0dMcC4a&w_I}?NB*=H69?wg?ee0gE=pNO9qnhkHT?^%
zvo?MgV?Ll^FzxbwUP)cUnZNJ$)-U7sJMd!4zm!rA*#o87!V2HcZ@bm%Gb2o)@Ni7e
z?#E5q>Jl~gIls3~UAS24UdogBlm~{d-^?j3+GY1AWbM({jTtvLp1u3&=qD9<)yu*!
z*e5R5JeT0$6unM=l4Gse&$Y`I+p>x73D{{q>+8GAi?ya^RiAz(q;gsO<XdC$LP_sO
zuUkEZs+-xbC)NJgQt(|R;q;rUR#{rVCv)p5c**TO;Vo9v<MOro-K>vnzm0VqRouV(
z9IaHEuUdKBZ0(K`-cK^_TwP*&Tv;}EC#StIn#;Ld!LVC!g1|2Rp4<MM`_3-pVq;10
zn5W8gyyL^sFKu-)0lNjb>ZOg(&vXpAcvbsDYS`x8(=HnqzHc|UJ?Wo4)1Ow6zXr9F
z-c&tGO}q48>cV!Zbr$E}1w4MAGD#$rLB(sAbBX2udgp)gcWRHzbEW2`6qgjGCgy@z
zpsUl2%&}ggW=!;<_GhD``|oTMt^2-S;>*&_4ef&Yi&|_%{2nh^aaqZCo5w^8{!cx7
zl-Ib;@{qcHJN|xgg~#2t;+tR9G<e<wsJP0_eSN(6MMmNF4zc_D9(*v5`q28IDRZ7q
zOPG#W(#Csxf4pTip4fS*^>?JN{6|}B@0-g$$qITG<o>W;v+vXC^=_~0OMgG=&hLrh
zIO>!1<I%Ujf}-1JAJsp-zP{q?*|%rcZ?CTxv|JQ_f8OHX@gL5gxA|Jlns`zvHB%>P
z$?1;Phl1Tp3RRxwE3aF%Nc+{Rw535?eI^{x-zS*$C2Y;i0K+%Q_ba7ezBqe$_w1=2
z(<%=uFMQxTQLnymzL+6zu=JAtS@t!*nc}?F;`wCvA99*gHv59aa-C<l-XBw2f0o00
z#>CF~KV$C+Dtaiao$a#tq|=5S^Zz{iY9Dt0+0@?=#<P}LJa+n38P6sb<kNZ5Y5nTb
zjD;PVnsQq&T>oixpe{n=YTA)Hzxyv;9Qf~wNgG8?$~dDS^<ww_gPr^)#_O-$+-Eyw
zrl?g8yVYbVG40I}g?!POw=&p|9LT=CM(dU=_k{JPmp`$%U!Ai!YmMC(-k_POlS5}$
zh1*@Y92@u4_u5lk+q5stR}Me7d9!&@C8w>GlxM}E!gb1Om*y?H<J&22=p7iSb2^z*
zuEF?1>8!2!3BLPu>{!H8Zk;%q@ol=fw%qIomo&SRjAMU&&^y3qaHVDWW7mnY?@rq-
zlK8o4=fl5p$xSLbMIV1p+I-(!k#*YS8XvER5&2g+rGK;CyHdp&^m3`=t`yafT&9p^
z8Pk7FOyc;IwbbEc1=By?J=3~=&hU8HDe|Kza?Q%OFTJlAE!m=$SeSC?+G@Y3_nfVh
zbqrrw?lWE^{7&2Wm&*5xGk@!@`n#|=_KWfMKa=N7^uA)Ybj^=90ktm*O!wJ5(vgte
z>bJpx!Fg-llCyW2=W=;+&Y08i{m5kBb8Gi-e~d6*{Bz^oNPdo8N0<05lN0FK$Qik?
zVVOYqtc84apIQtKi>!E(VWhPq=$2(^#uonFvG+_hJZn@u7cH(>(6@%^W~<M{;tS<^
z>qYwaop2Fsw0yOB3*Sf8`vK>7-C$PV{U_M{{MX;Y=WZALRq>KPr1n(Qvwy*nGqMfQ
z7lUFYn<uB2u>T6Y=pLWS^>J&^mSqMHdygk&aB>|gwb|M-kzXh?t5)Ejm3+$X59%}9
zxZk`#+&Z`AAKUWAeYg5nu1h$-K>NkwMHLn8H6hZEthIJN*uVIdMbw%;<*Cxr^AG;J
zcJ{E`t(N(PDl2Yt?kNA8V`fp5vNw(S%;eMSU*$<(D3tJ?*~G6j@tC-?{DVu3u3r`F
zxRxE{|L}ur_eCA43tyz3u2a(Yo~5roBgo(?_b2^ER$gPRuflOki%Jt%r>_mT$(QQs
zzo27*-BZQ#%XWF(PFpN^PH`9AUdR*JklMJb_wG%`X`8uAk6IP8D@VMo4V%(_EO(3L
z4!7{j`HA-xuIh8Y?`eEoFw5}enOQY2*d|(j&X}9eG{aw*wJw|G#GMT)o-a&~s!TZD
z8h7vB0Z-lq#jpADF1>iV`qR3+uDspZ%rVVV54fdFy5wbl(56DWP^!0AEB<-zY*UUm
zLYr%*M~2<KZ~FCM6U&TA+hf@>7TtX&y@fsCTfZLPL+P+>WlN>1?Jpf}<D2m_#eDOY
zxsjfGUsrA4?mlzZr!?0;%M&-O&|GQ%Jl0KDVMVd_yG>J{R+wBZ5~>JX$mcP6hwGy)
z^`f)x&Y1jR&eu6CyD!bskKbw%u;ae(y>+t>$?iAHTeGNnmF>q%AFrFf{doP{%z4{3
zx}W1eI?cz~=fs|EaSOgHUx;Gq-(<uVZr2s1#Px!$;p>j=D{`OhGc3NyFvoGyIls2o
zyD~prJDn38QvTxinFAJ8Z?;9cubsQ~^fg<{DPD21t@RA=^J8Z)=;~z(dCe6&dAnv?
z&Fgv6<_6Q*zb)hqtLr?p_hM6j)WYp;2X__4eJ=BMTo5k%Hque;ZAc7LOx)t$2@e-N
zylqz%b3JwD`nf(2ZffcB+@Jc@diC=Q?*CS39_aY=O|`fB_l*l8-+5JMUa<L|sP@8P
zV@RgYpAA#2`9FqzcoDPj$hJKz_HU2Bw#D`K)4h8=zi7*9#@YSQu&KA+pS0|Q=Z3n2
z&+cVTmvJ>K&y!9rkqZi)G1V{d|Hr(^H78%*Rh!)z5YUuiaqsohkR^NT9vxozb<@c?
zPmHB*I3?t4zgfFpzUb%Q{`_;EIY&d!1f<BE=l}IxWM=59-Fp}<+&(uQnmnmfZkoya
z{{b&!ci!gw=vzMf<oX*we*FEHsA9y~ev>W9YQfoOTb8Nw3C$B*Wca2y<wtDqyGxg5
zn_DZf%-wCfl;7mR!QD$Q2H(^>bFV|LS@zDu2YL+pmTCnLE1D`pXUQaJpE>yCN5-_%
zjtb1WY!<%VEGKz)yk%~i@YJ$O#5lOgj^%025*xJ_YYHw+@qBqy*xu2`KJWFi*{9hz
zPmwUvi8=D%V|-4<af6g24;rWNH~BT1acq+^+GD{O{ldTNd#m$}Hvd$y<ua8|_Alm`
z!E<EI3|G19bGP|6T-~_mlG*(Jd6UnTyPPXM_r3ORKyv#T+bL!(?@#{;cD!a%CHTmi
zF<^>U+}XI>(_0KbiaHtW6u#uSRLIFl&;IzcW-rsg*?%VcZ@d3=^26Z1=%u!4yU)Kr
zf7&~KN_bIN{h7yCp5HuS`Swr$*W;QUo1SlfX?RHP@t(`Fg|UoTt1o!XmYw@q<F96I
zoJgAa&e{F%=a<@e9%8A_6aASUyM-@0;=+4{a${?owh$N3X>PRz>zkA|CcNwqpYUAi
znc%&p*ZacP$Jf5qS$F8pS(%NepQ^o<IrKU*&*t>O)E&hepVnNDyTZ9{{@whX&pDIL
zr<*FwS`xQS{K2Mu3J*NRJ~cJ0zw=th<a&Q6-}?!?=a#)};h$^&+_yHm!f$W>rrmQ7
zx6Yhybz<|%!rX|G*u}>+^cj9k;Z(L~j@xrD|8wlUAIc9kCiX|J=$@f3`Z(yra_$NK
zQT3-~=gx1Mq2KiIYR0u-!~2I#XPjS>+$48shQ4P%rxpJRMVr~@4L4tQdKr6kMbf+T
zpQO%z(lD_(*ZyJWLmkg2{}WAb%~@*`7oHL@ee(-L;g>CU3bsldQR}S;Vk|6|+uoSu
zp_ltA*z@1du8Zx-Pd{}<2A*wn{cZH6vx3#>TiI^DXIqms`-|SCOFR|#RPUKIr@ue+
zVk<-I&9XC!p3AO&Hp-BTJHN^ObK$&Cb~Bdvv@xAGeY2B)1N)owH}!f3>aOuB_2SQ1
zirjCnx%({f-I0k~Q{`ir?>O$R;VItc_)MbIw%ldOjE*1a1<%FaD?YLAU!U{T@x=+%
zR36pT4aqAM4l#!^zZG2&*`{4_&dlfdammA9ES{S%&08o_nX@`}^~E*w&R&*P&v`dF
z=B4EV>0AB=%p4he<QWth<7OK08!cG-^84yvvZgtV$IM>I&gscz6q`5aR^n&-{1?|#
zXEKWHZmbU9T)14uN9(x2+M_0l|5oW-`#Jx1<-EnpAD+IyJtstR(!a|KFY}kqJpaAz
zgLme%2Aw1h>BDP}s?GU0sV2nx$X44GA=3_;Wm}|ha)_Jmlew^5GG_V_Y2^m{*>as$
z430ZF{?B{5*t*1`B&#)}c>2{dksecSS#Fy(Mb*s8PW11et@kb}R!li><ZQS4)|2^6
zcYKr8+8aV`q|4v8e|ji!=KZT}pWQ!weUTGy_v4qh>EDit+hy-oC#}=s&RToW-mgo2
z+m|I<HmN%<U8--JIK92P<?EXjQ!V=x+wX*j*nNJpYUfE7J|`Q`>b5ueCh?1wt&muK
zJa>9%_U%?%^>u<02eR7YHJ&pr@xNM7T{hL_<EP`ZGR_$nt^M+(?CkILd@a2k5>w)C
z2)=*)&3c<`#nfrj&b)ZuFmvjo?ajAORQi3$Td>P0=<}_LhS>s28!DblZ8OPeyQE<9
ze5vWgAE(t!-Zw^t7`C`g4US!3=$)T<<ZRiw!fDPbOy44%#iJjbEMEV%lPmW6lm~8;
z-MxG|CAueVd3P`N<!4iQ=ToeAycvbh#%@_Jv^wL|qzTnmbS{1j%$cK5aZ;$1N9UQK
zKktcc{T1$~zXYEMXKIxEdt(t#;u4X|3$E?>ULihlgR;-Y<@JB=UOMZ~z}bE&?2Bmm
zcSYs*xl_4YZoJU<xcxTg<F#Gv)=!MsE-ZVs<t*>+oy|FOcQ+)L8|^+KxJ~?nwp+Z;
zj^nGo&-ogVax7wj;i|Vqdnyh*{gnT8L96_l@NLCOMk%|b7u@CLyerL8*1JVmUh}Un
zr(fRcwhNXj!4K}P+1j8KxsH2RPph%rC0oG|m0y{RiUQA*8Owa#dYOImvXx7p&#T`4
z?%6jteI>OYZ{|Hs$lljvzGz-habo(6Ro!dCnzN<y6d%Ybizh6uioY%II@j#>PKisu
zgckY>@8Y*vceF})j`$zhv=1-$Tol_j?a8jSZ*&(YactN)>t5Q=llN9kusT|Co#~6!
zh1klu6B;f(jn=#B;Zdcsgr)Tf%M?DQU&6hSr<?vAo>#Z_Y-WApF}@%E%NXZd9@dt5
z`em-~KDLfFE1e&o?!Q$$Jgd9+ior=i$F|mTi8RIpE)J#swTl8HuRHDQm0lN<+<aHa
zVcP5`TO#^$Vw+xl-^zHTkGGWX>Gcz7o*%4k%xe3^vRc-rl--Ika^}6jwoUP~K4wh%
zW7V?NbZ*+?S88)MJv^-Vc-39Mso_@xSMfgXS2~}}cK-2Om8gGzo^5?>&S_u1X636s
zDc!hWw-~oTF2QSm{zb<fyqG-qcemSz=I<S!Lc`a;I#p_Jx%Bp}wQIiwrdyc(ejON=
zwjrecxvk&vPu;@Hbt<A)UtfAon_cfw)7x8FH>|Y1?E^0V{`+=gr{R&}WR4g$tv?SR
z#=f-idd^_5=cYB!bJ1nuOux=c#vkSUsbnzoC1;MJ%PA$k_GXqPGQUOk&-*XG<v(Md
zd)g~dw-c=cYGJ8hpaANM+SqXE`=sWjmt-iISQ?lUyCr6;_036l%qG46)y1{nr?f@N
zx#7Xqx*HR8BfpiL>AC(YHvfh(e~9SrZe_7ZwaBcK@%t+oZKPCtw``JKc*s>@V!7I;
z#b^Jj-P%*L=;8g0#pZ6(Q(x313#|@HHrxGp^8I-$bWSZwQntT-TCdK1wT|gp>5h=T
z>cjglzq_9I`}NI#_wU&K{9HcsuEgq1HkW7L-t8W6=bicfy!rpXyxDzwb^X16Pd!x}
z_V4&BaOXek|J_sNfB&^;IF`p1x<t+ON6EAmO7~NuR-0VoxmW)6@6Pq>);+ek_v(fH
zx^-)Px7{y$Yw+#)-H38s|I+e5)^ZtZ@7h&=eD&+;_WGw6mG;)f_TS0dT^9cLXZ!!a
zZtLCg4v{9!FRU(}I>uq%!23bi<Kpg)e}{R)%r|si%H*-Wc&OgRQ{?l?_3M4M)!N6s
z)IG3#JF`zF6T^hRvyV@{7A6^+b4e*Y&@bZG*ZCLI_$Svh&N|*Ohdrw5&I=BOuA&U{
z+2Ib84yaWw;c9r-e~)Eax|jOT#kM`?Li0AAztLP-?#IE*azSj{sgNbfZts8m3t`P*
z(C&@B;7~2~#GzTMr<(um@xu9HTHW0Y*X$l1i%;r5J>z`w)Fmgy57w*^p1Sm?(AVAX
z?(~JqAE@IwThaLU`q#guSKqx3axvZNC-HV$-bA(J()h39D<0*2DqJ;V1;aF7XN|w#
zFMf12+vy=5owA_kYx<i)&%;K0KS?qgZT57`R&AZ|%JReRZMkQ6U3yj(&2nN|)P+4S
z=j5zkmH5EFgpcdH&Xi9jQS!63V<om94BENw+^Nu6J6rYdJ=zxff8P0(j_ao{n7@<V
zYp&wiXYtvh(bkSxPE`^eGkzGC$sUe7^lne#NqgtJ_sol~ZOq=iG5dAwO%u5pvGG%P
zbo}1U$?5;mXA75GB=<IHov?{2i>C3Z7L_mD{<UF$T6FU*ccv-6f2+4X-?;Iy>BL>T
z*iLWy`%|m`qS=ER&Ua1jSn*HQu|FZ>5Gkbj^3qQy_g7A?^H@AK87`3%PWAX$;U(;v
zS<H4S=l82C)xn`3mp=9Cn7o)rFim3D>X+M$O+K2hDX$FT)4IL)utLV`BZ&s73w~wU
zeAj(%xBaEM#nScnuHCJC(D*cP!<V<AlX6Z!ixFhbJJ2C|K%4v1o>yVJ{bV{0Yv}w{
z*msCeFu<%J=WsToWB<o>izA*^{=3=H-Yoa(W59OCJa)EjhnF=oZWpI+oz9UccVo)M
z6AkYE;@kTg*C>cpJ0`!h<E-VWyB-`D{)zp=#s?d+CC^{C(mpWJWBQDLj2k5)(|CU9
zwm+;<`Pbg(adOesxyLU{PI$YkTrs7&d#d=i&l7sTUzn(%81>n|WzU2qN9;ERePA?R
zzkc0B-yO{kd?%!9W=pJ73(xsk{>g5kvz&Uz&fdvy&$q7<o$_>L*QT7#O+p`|7(Vsi
z?MT1LF=HNI8lV2Q-&xo9+xIg2Z}QcBb}w(^-K)!;ul8TvJyD#qDUt0;=kI`NdIAiO
z<rwd%UJw)y+dN^iSH*dG`H!bRD=a_5viwGqnEdM9#;bz%<ZRjVl+WHK#QIC;eT#iM
z?$?#-9A7Fw*yOp3f9aVmSEJ_?Ja(GBs&vin)mhWB5({D&PQTx^FKY9r*huc<)1QBQ
zAaZ+M$wJl*>s!S18U!@{ted)qdFjn5YhJy0F_lXzgeOkq?*Hkt#Xn?D<g)ddsAyYo
z;HR5Ki_h%O9}X2SJ=v<8#Ae&S=f-EJ4=mzbJB7FGEIA^gaj_{{L@MXc+STn{)93u+
z^KEmyeS;&KJ>=cI>jLjZFO~^RyLYwxeI?6E{_7h8o8%OEOaI=x$-m8OqH)`-8REbC
zdCtzMOq}<^<yhPA28p~2XD3X2>2rEYYwO{K&L{J}oy)VF*q*<t?D+N@n_1`Qp1(VD
zwsm@?VWzRW__XC~K5k6iK8;<5k?mcO1NY|r;kCz=mly3%pUp8hkS%hm<KmU?-2OG~
zcd27NrFvk-{qh}OnG2Vm;Qizymg}fc@z(afZ{CUI7r#q%*IxN#>M!GU=gHd~mMKAJ
zD`qy9$z^{jcj9VT=yzb&_3!LXXErKdotV+j{_bL`(AzJ}TXHfaAF;&>IQc8-Fz-Kn
z<LlJh2iL3q{oM9oy01Ied4HV?HZCmI@`X+;b2qffw5fP0?fAO#UT?`;mh)-z!&RRg
z{61sJ!)N~b^K<H!n%d1|%$3!xNhzAOUeSTUk(pJ(A!_IC(&NFw{Om$6uP9t`x!%LU
z&ip<0CeM!E&IdY|j#<Q<&i~41cmJxg)s7qSnKt`%J*`aCd{SF9>z}n~$~Z|~EZe-^
zsQv!(9Y%NUWU{XP+Vd>p)0Yh_8}i;?cvyFrWoO$?Q!(xC{f{l$H+;8~sx~c&yLqpB
zzWL6HtFtdI*)L{n%CpdMwbVw1Iq{ov%ylK!7rj5{?D_6op8SK1356eH(-*`U=w;M3
zs7^>TJFIXZueqE(wtay^i1VZA)gO&L_m#L8a0UxVtuXpv@F8(${k%0lxTNOXo1T1f
zZSc+M$Gc3l%Q}yIu)Zl~vvjhrZSt<muNzO~9nm<enDkn3$HPn03@%AsaIF4hHp%jI
zg7}`<t7Nm*w<dJFWj2x7I7fS;&viwY=eNV3{Iz>}GIOQ`8=vkp&0{QI9{$@?e7rjC
z)$517_NEJdFz!{&xiU9^A!6eR#RZPPx)R$i{@poi^}38`W-rT2Om8gv8b7XjZ+*?>
z<e5oIo4sC~+Wl3eq{}Mh%*mLqd6Rk^OU|8d-z7N1D{kxSst=2gZD2M(*k+d7A7&Ca
zD_KTi_Q9I&yVw2F6Vff1kGx#>?Vu{(q=w5mTbsEz_$0;rnGz}`e9DdOXVrtH8VNtR
z|6G`Eb8|v%lKz_KicdIVwyuAtRd(#M%DsIe-zMrl`8>6XW9Is;n>w7YDG8ia-RZ?W
zf4T+hqiHUU?$5+L&V=o<SUczU(S<9_3sM*xC(H~|TsUWI*VZ^$Pq(E}$6J&V%DR-M
z-|RSgFzUFL_NA+-k6&C${r`2nz@ZQ!b$KSc;LJDMC9K66=KRVMxESd!DxOj^cVm>w
z_5(LvO=c~X-hXDz(FI{88dm<r9iN{~e8KCfRB(%5$adeFTdUM<;yl(RzWP{Hlq)Eo
zu66!zrn$Y%{<_Gm4^7t2y|hJU;bazt7`>{;aX0UjEA+H0uP=PK>tR7{Ox>*xF7Z$n
z<>%Y}^*(;N;s77V&%h%4z%^ZWbW&Hd=e_@+G2#0Sk7W_bE}d>uuaqCz$gwU#U`g$9
z?ba&>M(uZgB*;zknYVZ0h9v#h?Ax0?f{fIe4)9-k9q_HKBSSIaX8R@n)>F#ocf8pl
zacymdxZj$>DpB@`>wDZ^_jedIoLiQ-ey%NNP+iIn&SJw!>piB;m>tkB|6=Wrj3p{P
zH$;CtU9nd(JK*8_lodI#UFRy24Ga7e;`KjCa#?m5iF`U4u-o|5wpZtzovms-t!$O&
z@}*ZjvI+dD@>l-B(~wA6uQfk!^A+_iwpP3-wb&;~U-9D1peOMM_86Zpw=GO>syyhH
zB=TUoT|&m|zY5#F@NAnBy6yJVLos*m?#|Pia<R8qH2vj&W>!w2a~F9Nb7ff;sLXVX
zNeJcgm}kK8OzY1lq2o+*A_G32)Vfr9Q+lV#iUgkp`_iX!vn5a5{LwRRqSKb5O^p$|
zIhW4pzF8mO@4jfk=LJpY9<9BW$U1jPS>GP{o8=O(66b8Xe=IM4VbY#243o~4|2)C$
zF{Qd&o9SUue{HPO591Sz#c3W}z0{rW?&rM2;*&S4+H8W#?<{GD2`B%|`uFbf?JrCU
zv%EPzSBFji)->x(Z`bnhj?1D|bDBI)iFg$mxU@UHJejCa%D4Pa(PyW^*WVtfgiD8}
zXz%-ca(-iY@QeNFxn7sjG@^}IHlDS*9y?{Gh?~?oFNfC;9Ww0>`^|6^zxp!&MabJa
zg`;!3HnSz~4pK|^O3w{Ua@n%|knKaRhs)Uh32)Lhoblsj;c5|v)6?e0?Mts+v*fBJ
z&x7BWU%YW&b~WnrRK2ag4lGg=4^b53dh+AYpA5(5=f(PmkFox|Ib)jL{1+d2-A>pZ
z|MSIjnbkXeAsLGVA-{OLV@tQWrA}V#t)X-LE+cad_q&hMTQV5yrE?t2Cf|Ck)4P4W
z!PF9$wLOj@!QXma6#D}ws;tuZ(!TU%@B{|u455DlHXGh7@azotpSDEp{px=#cGo1F
zCby<75kHmN+L5ETd-{}Mvz4~#YOjtSUg3ZL$ddNC*0T9Q0u>HQuWvF<5%%a4d%-BV
z@W<f>PnPFJ+djN@;7OWlI?v+2WRHQ7_4YMYT&Luc4=xZqVYe*CUX-`-cB-4}#P;8-
zFP!D#uzsU{*GKNN&%CC^tHb*%pTw>&>a%!o*QaRST(PTdQ{Qc2IJ&a@p5I$3<KJA~
z{d!0J&gc8hJamLvb^41MOR=87=(kU-%YwF6tF<5dBDFM9_Eg`72Ycr{y{q)1AZ0ag
z^^1>UkB>W_{Ko9IdmGoDypD&0snUr_g%TDoFTS78)-f&Z!k;Z4;x`K&xcmK+b&1xO
zfH|7Rnu~%zOtsil$7ok-^83K$w3GG%ZH%27LdjWw?dsp9T>3hvP~2c<*gI3!y7YDB
zPjX)UGC5^r`t(Iy>(fw`O_!y0D`Y0EoKhnoeCWxPZ4n<dcJn0kWq&-e@NKhjm%Yj7
zjfwAt)>sCWr5d$%Nd^V>Jm0Y4iO{6V`BP=P1Ne^IkZHN=ck0K+DQQ|W_XpqB`0|Wb
z>uxot`T70anNyio+dQ|+VVD!~bY}l@zj*d9;w@9<ZmqAY{QBznanVS#t`Nc7y(g8X
zHlO<Mz#F`##70!yPEU99L{{0<jMZBN3V;31eG$-X{aU|hMQ3PI*VBdD>-pzM7N31S
z-9or#8_$=ckIu}Wcen2M-|pM%oer%DwVP^C$9rj7THML?Ydwu5(;hS3uMqt4Yk8LV
zkF2HF&vUzXy!vofs^v)D{+Av+E1w+G&cF6yqrvY}S*?4Hn1pRRVgF9p=G6Vzg!s8y
zJMMYS5Zl){bq&X#h`6QBH$u&H%{IHve=GiE{uA*h^B;)+VO(KQuc0MpEwnneq2EZ9
zQAo`4%7rqimK3MAQ_iqTJ8b3oG_AY0{>6=;2gP}_)>oW3-WXCSTzHiC?36mkM@sf`
zD^qVb%31Dw^xz|_4^Pm{zrQ;cOi6b+HhCNC^u=1ymaiT%xV>Lny=Z~pn<+-MpHlN!
zrnhX`awfcs(d}|e*B0jd*O{9-3MyOPM9i|vRXEDhxq0H>jXBRVwPxH5_dR+{(rVJL
zrfU;L4sCp`ncA7kCa}h4am|fa4;tHVXu1f9)#>rD1p2PDm#ycxT96v?G;B_^h1a=7
zC3l*uQ}^_7^Z0&Jout9Kk^g6)z@+C@MQfT}^e&aW-T(Xhfman$bCWx#7ERhFR@E3)
zAETVkJDIJ%wpXUi;&q!Y$C($oXH;Z_A9+phJ9@5C<Ks-}*&=R--s_v|&ntQz8T?-B
z`^22TzTam_&k;F(&33<2$h$YIrU?s1{;258JsC3p)GqluYzf+OzjY2eEqH!E{#5*<
z=!;gho=h^{l8GuoToa3(pSA~@=xdaO=IwBJ=dJyR+o<H;mN`MwYxg<Iv6;MhJD)AC
zz-oWqi>YGb-nR<7eovnlyKd^tDOdLDc&1BP1X@KMS()G5pD+0%=(EDqD{ike{LEiJ
zd8BvLd2XRfSoE3&Rag0J%R72cxQj~~ggxCEcT_hisX<iae<ZIVE8kh}Z9k^^Z`yv9
z?+A~}ZozM58c**T+XzkGYbqP}*K^<Zin&XRU%EaB>U|f&GxulG3!eiTn<^8-w(Wht
zgvYYjHB9#Vx2q?%)?ToyFyQ{Np=7Cs#n%-w9AO?6UA`-~t6bOU6~0)s#n!igZ^8qW
zqdvJ>ACx;%#N{UjDBe5jWO+es>FSQA8Pj~5`kkKjzgwqpKtlejN30y*-}k-VT<<Cm
zoIiSdwzS-=2g}c>YV^f@`~0hzYYLCpwmoZqW^x|$i}2XeqWHn@-<zYGpUcSTO<1~d
z-Q3P)%HctaDx9<uR=mCUdXeNoQ%~C>@nt7#N>0swX_;BN;F7oZ)L$%u?mrg9+<F}x
zT(owz--k<Q7)?~S9(d<lvx@s#)x*g3>-w+C_IKZS*{V4?eb<e3XTPiw6Z7_ZziQrQ
zfx<VeWt&XjmavO#{#u%zsS-Hri$&e`HB)AZw!V+dPDptFee3F4eQ({iYYT+s4>l%O
zf07W0DQVyFfTL~WpUel#E>wgE>9M)rINi+lS#aCGUp(f2r&({UiQK+!m)7AbH62^8
z*wFJecmMol`n_<L4!g+Jlvtmif3_E!7wr|8ZX<M_>E?=#pFernny<!xSQ|5cnt=1u
zppP?lE0xAv(Y@dF`R3tm2Lj{|@+4Kw|6-)`;M28BjG=p1m!*d<|F~k^g{e-(C;uDh
z$LtOfm9<tWY@b|x!YsCarhT2r<h0h$IgheWZM0?d^yc6%d-mL?S<jkfbM})6YiGX;
z1?mEZ{^v8q|1VN9e7%3ghL9kRZAU~ea8AGMquUVp>2%lXTwU#c%L75-M;9N_35lEE
zS~kHwtVA=+Z=XK@htPMD*B>8^e08^S)s_W<cCu2zn|Q7M@ExD8^j5)Q<y_kn#>?B5
zo!?xVYU|^>ezQUB=?5ESmL92($PL&#xuxmK*|eKA?IL9p4y*ReJC)q48Pc+mZ(7)s
zPX|_C{wlBcU;bKpoHdrQH%oKOu{UEgL!ytPc^ezuFTEYK_(R~6%0j`z)|R@zCYTi7
zvC_Cz5y(>dX+cK1Zfg0`UKQ)OFXz7(<jM6}%(=aBlOq#z+*+5j?w{tofBf)a>dQB0
zd(Q2vJNBU7D%tp)Mc|opJ0`gl+eP2E|NT?a@XCdhus;#M_V0S1x-{im(6s!3q`R9R
z{^$3PpVl9LZQlQ*S2v%ZCvEw7l0^26H?N+p5evV*`TA%5{eS=by!xnpb-m4E*QNV+
zbzS{^|HFEnn_oBYZi+c4G$~_U>|dVwnOPjo&(cG8M@1OM|E-v=H?67L^8e=~P1U*o
zYqvirtMlUj{_<;C=_$LZpa1KunX~@gy=BM$eE;kFZ|&t}8XwO8{T5;Ka`*Jvvmeiw
z>)USgKV$3eJpDhPR7IBjysf|BN#W*QrJ@>*apH5`JDZNl#hm^;{eInF9;t(S_O+VV
zoshr%)l~G)ygC2%|Nr_P5*W_3>%x^?0bY(<3_r|W!+!r?>c*5?XYPx*e)XArgyVIW
zk?Vr*3oU|OA1(^Gs}gYRXWCj3hIHRqx=W|EIBrx;RtdEFZ}I-rk!_(9xRciEzW&a4
z>Q&{MNe}kA>X!bT`Z>x;QSnpMt0>*gRcrV%|2>)@Cokrm_w41bEw$SV^xw(dbzf#+
zJ;icf*z&hl^>d|veoWkIEAzSBXnNE9`S)|LXZ}08YG?eL`ZMu=HreKG+r4MfscX@B
zCKHu3XU|LYN_+Ntd;4Lhjg`BspXQ6~dmfj^RqxH*n<mqfobq#z|6TK<@N;XGMHdD%
z-mzN6ck1S!ysydk#LE@cA6@u=wRt~hV(=uDsiOa9O*hyQ#}u$t&%5T+{qXhwzIr}z
zY!XbYjO@{w*7oXWXyoay-x4Rw`Mvxd{BO5$!;_MK8=|a#KNYi*{mj4p_@BdPU+wT*
z|M|Po=N;m^|7!l<@~W|Y_tk9zlfExk`*8N(yS(>ye^Pf>Pu^c@wWjR&Tch`PjtCr-
zj@^Ct{Q+hp!K%&n4dQpKw{Ohax3`|5{pLKQ{O0r5fB$aZJ~QWF`%dPAyJt^5eERRE
zigQ(S<+{`7eEV6wbNM0Z_hMe*MeO_ImmmL{__~KHHptG%cF6@J*0{>8H^o@{`zu$6
zzyIuH{@eLy%X`hq*4GoRyS*~cudS%Dcza(ajDL2Ig3}Hyhrj&M%P$=Nqni=+^V72p
z`^(oq`O{tU{qn22-KX#WH+p}4_nPFp$5+0t{eJS*x{8acy^ms~q#s{DfAzxQ9g0FV
zzKpU{N*<qkE&t+;lwGr$kiwfc)7L!t>!Tr2wdC>hyKh8!iW<{7-W|Ji!+C*4Pl=bv
z`4h)?SZ$wi!6lpf{H4g9Yl^o={{35Zx`jj2J-I69D$kMwKW5b5Zul?m*5IgDThjb?
zIiu-?E{<bfUF(>YbT>13yQL^aOCLGNpts>*hCuinj)i~OYPX)QF<G9t$CIr|AWHLN
z?gGy)gB8i{lUX=aO}UnOI;p#)eOqUGlH2@K*xm@n{WoehCp?@M`64BBTaIv!q(`;;
z;U!aDW*VLoSL<yOte5&6;iMx`BgEaJBqp_1f#u?sj=Id2%EtzO0|lH^*3InyS#V?i
zx7UAT8<azwRSs`{G;LGHd_lFGtI5w#2y7GFFo%6l^xfrxNlIS~{Vg84GHcyPZL#F2
z)zMK6`TjQP<ikv+#qFv`;%81OFE2d0{NP#M0LC<rJ6tka2RQsw4R0q2Y9%D7HLTp)
zzq4nDGE>^qKG_*lt@{pdnP=U^!u>q4^o;oY{Z)b;bvxDeNVP?&`8-(u%;$n@z=crX
z%XZazHtDKC>YJk$&adNQc`KmQ$@RLdTGpXCa<Six_Tx>)o7mzkb8{4rJ?OJnXXD9G
zn5VI4LTBqN@nFw;=eT)JG>OTjw1{y`P}Sb0;2qY}{KYeoHE<21<wTK9@|sJYFYyhU
z5xLgqBq#r=$46!ttl%hHnd)I>B(j&oaL0M(nhkRdk_$KzMLkmlr*?5D9!sp+cPNC(
z*z|SszCWKTHFzhcJbcN(_%`*xcSrLDKGkeGo5Jp=*q53bemWwwPycVGi$P|1=TaSc
z*^rR9)R>Bww!9ABYc4&nyRW3m!55V2c{jpP*ReoAUG31135L3fFOm)|@92E<!Bwot
zRkHLbpRVMc=ZuDpFIPSja`)l6v7VzR#l`!WquCagRr)j7Ed#xt7-&|CSNJ&Xc*GH<
zG;hK*1&MBLM;;dTj$=U<$CBjFN3fj@dlj=N%0!~^v{0IP)bE%$H<b*76o;mU(^m{+
zI4_B)JyKi0y(>e2Elu*_b;D#qJEk;Ko$`b*Jwv|Dh99T4e0H<eH~#ol^P17ex3W*_
z#Z@H24|2A4Hcd1!vDABZVaxRgwl|CzpLxt&yKk|9yHog$MU_^EWO&X@vMfC#Q7mAf
z{j4M*?2Kf)WSXDs=S62G`uAJ5&t7>(GH0eiF^l&y-8csZuPJV`Iu83Qc6s)9UdWeu
zcGD#$`(1L~lNUE<|FL0nR!e@nqTo!Gr?+J9T+uk2WxJBoS^lp`S)I3fMvmf-_Sx;s
zH*3yxr|tSW!RPytHTRM&R;N!^H2!#SuUvp|LE5PaX^-x#egDjKyP%;Yd!?Q5@<Yvg
zmQ34I&vWiA%iJkff=w0kX5Wqt^A_-#diHRmv$#oUvfRBi?a$h`Pw||Xx#C@=1=Hl!
zl@({hHdg*fIMKim$Sc%s!k;dpbU$g`3>T3MnKb7{hRIs;!rJ?%ux)qEoLF(LV0T23
zrN8sLvv=lszq5WQ@qOF$()Tk&6n}V%Ub~Vj#+@zj$0fse!A`j+t<%J7I=S@qSL{2@
zEj!upsc!0w3=Y>zx4+EWntNZ=_IYx1Zt*%>B|(*i!N!tG-7YRk9cEAGm~0ZvQF#&h
zWAY8Q7X}|cn%iET`zqjFg3qg44x8__eVnxV+fsK4(*q|?N3AT}G&#Y=fk~O^(1vN&
zOO;YSRd2p_;N<!jwq6}&M~@jypTKZ)!?jei=|BG7^xlyBx^1<+OwN|(k1wMyv{@%5
zRBSSkYYJJ&<1hBib&hD2_{}+;Oi?MfY%h2$lV#rA^LCek_EL%Vn;mZ}w(*}myeH#S
zS8G{%6jPbZlud_t-sOGf^lTOjN*DIN9^B-AOP#kaD|7Mr)q9ur2B-Qhu5z7xc(0;Q
z__8ls-t4<z_E?+iIj_3U^xqqmrTqgPyw6>COrGO@V2#E7#>m1tnP)d&&FYr7J#+e<
zc=DRoFFfhBzAe)Z`sS2NS#JBdUi~kdwAulg=@SBZ+AZ_euCn=aTFE-Zy=h+RBo>XC
z>{Sy}${N3#%~6=@`AD`&ZhK&7>#B-pYdWH*CQY_v$u2zF!6yADac!pL{&&5p5-obd
zx8`kCl6?Dc2BYF6rWAS2)hfITcbWL5RBLl(ShieuOm?<lN;7RKPYClf<hv|?XsX(&
zr^&BoOh0?lNKW?9#Lb&7D(>mIz5V*jcUx>(#h2Y(wsBtN&4+AU#vN+H{6D!kA6m?n
z>MJh)<F{zeMR6u2w|kW?^*SjpI_hML9&!GC@}{LO_w5w6W4cz+uiosMzE1g%1g~EI
zhwIWdKUwM@8Ag<vR&bW4En0nb>IB6tyKJ7u=bK(r{J%sqKKN`b=aC0(?U^T+-P^A?
zqsegE;x#th9ZP3yo4cK%=Sa>SrUQvH@)C~aF&6w@`RS3;zUURd#TX<O@qC|n+V~ak
z{D)Ii=FCs+h*n`ZC=#j?xIRW_l7m63_1w4LOum`4J~2=c4V{z0byD?V+gEee*9NYx
z=MUZ$N)Th^pUTO%dBr~kn~i%++0rB#t{WyZ8Zf0j-6lI@>g~S6Hn+20zWepbVB_a&
z2N_*{Gk0Y0DO^#D-Og7qL7{Q8c<}dKEB(H6RkP22I>*dr;f3oK*Drl=IdrG3{GMe)
zQ{;tXhkGutF>hYtE1u>#d*Y0P+3YqxZ>B!X+>*I>I>UTZ<~+Zg)UySvSt62oN`%k(
z%HA<rbV|Z((l^=8%5ClKo^O*E>EG)9?E3q_!<p-h_a6*NDymaS>N&!`A^Tj{#?#BK
z4SOCsPgT15Rx((HMZPFHRHNoyqMfemBW978O|v8QPI5ON;=bH2mUbXb{AT**?l-EB
zn`12%9!t4N%+X}N{_QaDp^0;TTAX<B)=2J2YM$hUy?N6w%3lp-?P^&ZBiZ=CernV8
zUdiAOFaHI{*gaNUwBE%>xWG_#iOiNwHw&$O_jeSn@MZE^VsVk_d4q1aRrK-KyCjoT
z(ms?)@qac_Ut6;Ob*9}UiJR+;ci5bciVNxyh*=S|c$Z~zR!c*q-t_XsupH?g$py2Q
zBsk9zUJ=uDdDXewDsE2mHlAI2_4NdC*&p}YPCmQVtmk0%wdF)x!r3<yw3g|%=f3<I
zJJV>>Q+8)=E#B3V#%hVpip)Z6_EQf;dOm4#oRe;~{)xju9pUYzXCfYnF>aQ+W@Vr~
zU84Qwjph0exqJ83DrE{u?=?Dp#q!479kr4w3EoAEA0L}Dt@h8mNnLlUjAm|Y()8V?
z^HOqYt#bYTyY7egs-8)^Sm?2^xR^0LKyi-sCX3AnD(+UUKW1^_fvm0Ell*6W^QN_I
zd3D<H@5RlMe}ykyzPnuL)-K&-C+oYlr?hKqPIRx){=RMF&Lg{w9?9A_uN9i0#Krc^
z<0lVS?7WV1(q?W+Z0~=3G^n?p{%1?e)4jG={UX>L#FSasS6x|=cV>o^VnUd4Bj1^>
z>}JFBCy(izx!vP(^UryqhyRu(J?|A#Have>@=C=F@x4n|K8@(!#d3Ah^36SsiQd!C
zTzL0Q-X>a$Cpyf1N}XtSozBCaCB_Cv7Km)zWvDD=CS$Z9(JkHBScG@8iM8JK%J&Rh
z857Tca8Ulq!*ix6;q{?4HAymQ2J;^#+O5r%7fV%++F!#qf8O~5+sw7cPNY}3&75^!
z;+<}ym9(A4{EL51-)>y2K1J}<owa=eCgMLe(`MCMeEt8X`QIYU4yUn!8D@vm#KhQ=
z*u@@itz(NHn@xKESv#b%Gsg6hpo&Ms^jo`T-BFpj=JmR7X*F9{`hIJirqM0g8RBtD
z?)|@?Z}kIMc+cM0U3sTyDyPY8hsFCZHat3dS1In#2d{(wD;A1%dM)y~={o79hX16a
zzdpR$9zL<tH%8~l#!tI{$R=iHWwCcCcPAhI|M`Ws`JXJKf7{L1|9f1$SiG~Z$26;O
zbFI_SvuPhce|r1d{Qmuzzh9sAuTN6^wR`sYi+}4sJU4iLUSD|13s*tW%1O$$YLOD6
z?uA)1rX+^*g|9a8To{_D94UADYiQDR`Sn7Z*RZv{JyqAXHE;L2sNMM=n~y)f$|Wb-
zEX6XH@5ldX4`WNVUW(GKzw?Phb)k(>)o$72@9*+>9C+vTup{fF$=5$w(buYvt+xw(
zeK}w|Z+W((M&-F}(yMxB=RRJmFn7)6M^=t92Tn{43Y?gFMn+1vHSqncZL7@$J9%8b
z-ab*9ke+w>gb3Hozn|kDA7y)BAkc8;QR4<a?zzzw@5JTRic(@X?#n2e?B<$O`OW<I
z?rp2v?=p5=I2!cujdA8PE3bwdGwgTl-1Ksj_UwIXZ3eq$F31*sTKVcieP^hgM6kQr
zxpNkgXDl*p4tgqQZ#n#P{Q(~}qg@3Y_Z$8cF()szGLYYLCB=%h$++xi`+)_gT(max
zeeX?J(ru&VlT{hT8xynALwwdorx@ceRZU;Y9~7)<eE3zWRM~I(>vdY~tI{o2^Ep(9
z9O0_UdKvfevG~+i<yY(O*B$Lx5|tLB+r+E;_!@7=@;le-C$CKD*!QYBEct~^!wpZx
z@KZ+w*PIPLoqzlG^*6SQdQ8?hzdv&JyZxT1KYK1|Mb^dNpKCQ|@rmi3&vOzu435f(
z++HgYU}vTq^!q}w__H6gW~JTae;Tk}vc~4_yV%*`-#fg%TPdtnxjIp5X{oxzPnW33
zB?n$F3tU&^wu^t&V$aJ*vzosC>bh3`=GC@jua2!BWac*Nyua<<_FZA~uAPtlPVx(h
z>lZxZxHI9%f0x%9ev=v)P8eITE&KIGhtHki+Tni_e><1IVxK3w;lbsMcRy>(7i~Uq
zE9srzr9*Ys=GNR>+n|vXXYkS9?D*vm^W}JrPcE$#Nk4j8^?S<<N!8UMuAD!nO+B@U
z=dg0!&wa1h3)U%~R1ciRW;1c;i_TsBit7d4t-{mezm)LEzDx<Zk|(WjRK9ty$f<AJ
z-e~S?NH|#%`20vgfUucp>yCwT7o=_2Dz`*Pil!dO^FMrU^;cEn*thB*S1U3ywoeY3
z*phO@zcDpcu!UjU+MG>WmjAQsFPb}N`ubKg>!Xcd4)<()`gZqK{!rl=Mn@AYr>>lB
zctk>2)vVSsc@=}Rf~psHACJ)`!MW{G*S;&xb!7Dw7tVQDn(;!Z>+>D?UnSB(i&QqP
zn!)$0y72d}-T!wU$Xly4^+o!}>NF8;(dP@k983Ryyh@m3_kneL6mq>cdEPi$!WGlG
zHBRH(G%g{(&#p|uOZ6k(_2=tniceV6m9BSv@{dz0fjLEyYb&<SXUg6>p>XL!k>qzl
zXG{)v*oF1`Z+2f=6j8tJ1ka4@iFN0mFQ4djK5qWrJ;xP7T{Jgvw0ChQE)$-1ylAT1
z$(wiQ{>;_;^t;>X{C<Tm`o{YgbZpjYNPhYL-0xScF(2+8n8JO&t9kystuelS7r2}E
zKQD4_Tb8rL__xsVPtSIn=QFEKYv@!xdU-|7P1$-L9bSp_-t8u`x7IhrYb?wDtu{l!
zZ&7*1=0%GS^=<rpJ-)fnz*=3ZaKeN`YMbAl(Mu67TvAjYn^_TiEdE+?Q+Hij!Nt0Q
zpNq`2c-Og|{U))0vE8noSNDJY@PD~@*Mk06JAY;DEloXt>3F@B=eMFK=}RRi2rldV
zv^D?xM^?Sx#+`?5zjrPXi<n#8dF)M-6!ZJ#p7H-8TTjkAd2{`}njLlDLpu~im-^RS
zu*z7PHtprB^PM);%hc4*e^=MgnEX>HmVNU68+$ZZ;)}fYDd<_K#tS@}n)Wk7s#&~M
zg-dy}(f=SjwyfBct~RIVr;c9xq_?Jjqt~)uJM@1yZl5sCeERkfP1#ldiqoFvZteXP
ze3L(78&`!tH{YS#$?Yu(%GK+P>V(&<@I6&~{(I%KN#~=R>zFki8`UM&ei84k@vr$R
zeC@2Z{;q~z@h5A~ui0a>c5Spm(Cbz+sV(kb-mtAc+j(%;8;8(kvSBj>K6tMwDGo0^
zzV4aU!PfzDa)*zZ)_WE{G8NlryvpsNj;j5yqPtfu9`Dlo&coz>nAeW!z_n#hz4q4J
z-g3B)EBuCK!o*__&F@&5e$5Zhs$8|<S}Vi4iWyG>^5tcX#6Jixp2!;Rb?R48LHxp#
zN7J^QET8Inp?3Eg_BuO-34Mw|o9~3k=G^(%kaU<~&5TDsozfbgZcUK&vO6+iopk4U
z&0G7{=YJR7e=A5+@LuihdqvGzT|X{949I;|wBlReyp5|ii=K#JF*$9$aMi<i>zBtp
zlPL?;4K8?USa9dTb;XTmIQ913d$iK?4cmcd)>Z;Hne{g|b-HVnZoW6)Y=>V>{HMd0
zEm&+WS|rRkX&h&)v?g%Fl?-W@XG}(ZAEv*4-_kQ}es1%h1(~ZBXYZO`BoI=%cky1H
zdF$VJsXYGY<=0!n)V%ig?q&a^J4K&;z1Gm6p8aB@(CV*3q1oZ3M`lHrZ(xyc;4Aoe
zbuE*$Uz4o2sM@>Ndl@8~kMz&*iT&P@lsmg?A-{E{?M8_=O-BooV`fI4Qcrzc=y0c~
zl4&QGVYbXE-J2bYH)v^?@p9x#)y4B2{&Hkpvc}0t$C#&;NjsL#Ke6SR&07uQHE~J~
zTu;8_l_{NY&b{;Fc&#SS@w(nwvqesR`lhmCMLgq6`zzHpN0?btQoV}bPT_1+VXWC?
zdHVDu?Uf#{+7|ksi+Uh!_I%Fy^ac0d-|~xlXf@H>)H_dEBqw##uYiS4Gg;<Hcc;ET
zp^?fGug>Ve#PoHy^3&G~jxI7<;<HnR_rdfX4O?YY&fQeZ<F?c||4+qf;$*(lVr}dH
zZD0FxhR7`Y*m~U`zPDvB>|UP!a_PJ;Esho?Tiv4k9kQRVy4=$<;o4d2E21~UCpMkB
zz9;M0Y)y*^*G`no^O{~{qRk~7QRbN*GU3&o`QLo6PJJ|KtHpzoRq<xAMz5zV^LWks
zMfs=0w$jy4XI#&^KTqJpk$Dm^=9~GCo?SG5>C#k2zpV4j3|y}mEg3V`-#)xCn_o%u
z?R@qP%}i@zdtLTFOIEkkil46jPeZxLB8ctUo7Iap9^A?}!-Q*|ALCB<<vmxdsx4oA
za}elcye06){O`Iarp?b!`Y^6}R<5_>vcL%)xiqWIGkP~ZKFDFxFR^E{jLq~K9me>$
z&0Y@75<9pmeILGhX8JqNZvN2&?tH0ozb*y5cr97?=(BXj#2=bFHa$#`_<ZE9KeMw=
zXA}3V8#_|ZADZjC^_^V*;hApkvkuRz%6%AjJYVBtrvL8+JHLp!J<&;2d&%P)+0wqO
zKmS!)@a4|OE1xxIxo+3Eu}MJj<fp5;YR+GNGU)7lZ78b2<rgmKvygA%YX8@-PK5Oo
zTv3^oa{BKi`Q$GTw#Tyey#0A~!{mv-J}ET&9~F*B)_9OQ!S`;@#0QOw3^#S`wdvyF
zU%&MBiOG>~lA2ps`tDwMV6A&WA-rQ-*S6{d=T2CNr_A}}RBXd{{DyPaoK7X?2Xl5l
ztLjPkz3NSiinyyu{LI9__KF9K^rKG4@Cuvtc17Rj%k=9>^i%Gz^u52yFHAO<o2&C=
z%Je<X26dP6En6Lbs7yWjt|FR!;;Xdojcr$%7*)0FtL65|q>0q%3S0bB4c^UP(7^w_
zdwJaCMF+Il7gxQXY59QdtjzI@A1{@bwCzoOZNw<P_<?P;oXeVbu|}=2m!9*++DHfs
zF%<8U2{z-A`g~$;Y^P(0juV?(@j-QIW`%`qA6+L*XfA#z`|1Dubw6MJOk~?=I^$=m
zdV`0=%}eum86~>DiRw++G<(kDnx`s0Z<d~zxm!nETGpQbvB4a*&Si;@Bb@p+tm}XJ
z^K<5>{@P3D8){PfFUmg2W4Yhbc;J2rztB(HkIQ6sPRw82!uzYuoAcoOjKdbYPq!WM
z*I)g0VUUZU>d)eCzo1wTCh217l}G%%1)fGU8*Z*zBK7_K^@A@9n*T5DV)uI<YNK$g
zJhYzg_)nE2XX&B?+XPz^!&9dRRXQyUuZ_P~S+reo?~@0w_wU}<x1(_L<ej@-UEtH3
z==tfyxp&q+kKCoi^RgEt-3(;RaG&{qM>tDIJafm<9Uqk4xei2p>c3MdQ+`eJM&W&<
zDLKJM&#hxLTIv?KVjbV{#5v1S3$6xql#2xGJ>`9T)^@G(4(Z_H$r2UJv!!k_OWZo0
zynXfWex4O4mrIJC@MF;EIm~bUh_9IY-h}LB$EFD;1bc9sY?|(T<84K=u+?(6NfKvd
z3|O3xecKlm{?#^mO`uQgo+lDJ);r(gJ*T(nd2!=^zI(TVJGrJ7Jb%UOX0SKa@cgmH
z1s88NEI)Vh&oiF1o85L!*58-To%=WFd@bkA28*8Qf$~4EuBl_x_?x+x?eNWc->MG^
z>Q4Qu)f=?4^A2y+3yZ0to2yG1Gz;FFik)*Qf4zIz9q!hx7mm-=V0fYxud!*4s!#Ol
zTHZrbyR(*m)SDb~IB5B!lEv>P&Hfu8|El(;<<_{DCX)@8ADNzf;Y)WQgM_i_n+Z%w
z${XqrCd$PGwcT2q*=p3I&(v~)%ka}H%l|)ZpBq}NyHI(JJ;%Q|@<rF>15*y)dfNW&
zQ=X4be6;`4Ernq#-%jqDenrysSx(*26FuPzzn1hnRIB73JAcP-Z~K(`paX|YR=+(^
zznIPOm~W+g(^99@yPI}wUa4SN!16YwjzjKyY4s%4v)e+-CcScce(0Iq7Fk!{*;B$U
zxumJoimYaNFs1ba*ZP8Qf0m`3SmH5fUhlRkujfa--Y77~!9ZJj=M?p4Jh~S@6&|>~
zZr!$fPcAD7I-D$iB=FU-<H@P~4V!Kj3+BvvCcNOe$i4>;KfIjJ!|-5_^f5W{TMGoe
z@-mNf`dus&zI>YP%ECK8gbPh)DezjA%sqD6e(}{Xo~K;9g+&7OUF47LnXI;Clfkwn
zpWaTaTzKpHj$AFF8RvN!6(*$~n<-<UaOSZblLt%7p>2ZCFW+L^^FlrIP@AL5`x*NG
zj>SCczTsOtA<%qzpL3MXI_}0~p^1g-oLzofTI^Z$gfXtS{J8PW@N+BpcO+eF5t+la
z_LSJ=r4ibJH*Xc3jXs`Y(f>#F@3|&^={2g!i92#mYnX3zHE5i6bH}EPr+LPGcIWJ?
z*k2dvSeyPgUfIYSVR5!lO=G$4topkfv!5m`6N*kvpL*(UrNiS@5_zI-+0(Kf&bNz+
z=L@XAchSyAweDQQzY>n;|6OzTP5Hn4V7A@Al^JP!TISrDxG1<U%jet`p?ZIZiT601
z8J-5*e>>;+68&v^%BFh!n_1A9q_Hu}F=9{SA@RrloC_WcUA`Ex@#Q<+)hRDO++n<0
z`Jiz!pVUvC+^Ie1>OzkM+U;LZow$3Quxk23%W20~=dzyUuj;w;Q#L$~fuS<ZMWsxk
zMMltOWyD17@O=y&)qJ0p9sm8k-)@^sN)j*2wta6_ehB^*$-h{jc;B>*^Rhhsy*pHw
z^ti;Yx|Dm{)AiI-=Nkv)yDkJ?j$)8mXw>I;^V7a}ZNXnf%P({!<nI*^;j@=~ciS)d
z;=Qa#d1Ctaw=Ukj^4;E9N`eo9uKSraWWMuyzeCu{W3|nresPTsu0;MF>Xm2T2G?s@
zZuI@xqq^bC|NorEOlMY{l4GkpYads%i(P-#szn~_o|a2n%~n}@VWKcYO>E(<mXxU_
zb&HR;_@Dc7WA$T!r)|<PXAT?H98Q-By4x6@#AQ`{^ma^Fy0C!IKkbyKkAL_XGV%Rs
zT9vN$^!^UX^z$o9es@m${^!%Wr(9D?_9}Z6^JyOQ@L-gX-E<(>=zCXn2wy2%OM~Nu
zmgZ-3d}dV!EbVN+tWmT?bf+%&&w$OVq{_`Me$t<O?)sO>EbrGJsIxPjxb+jad+PIW
z-G7W1;_bw+jMEqzVvf@o8JQ5hDd%ofbpCBOvAXZ;6+Q)Vbu261pCcf`m!rONBe%&%
z=M9<i8J*K4PfpSbGQIQnb9I}umrRyM;KZl|aW<VUE92t4`{n0&Iv0DkEdDOe^6znn
z%aj0>j=mKSJc6Wp=jqk$ci_^_S@bITMg7*tUYc=npMJ5q-8#qnfBR<s*Du?9f8M_v
z`=?@Yg^OiS)WjF>65YFZ7k)9__p79`*!;)ach9+FG;3?O`@fHWuzp%j{l9&oodq#{
zDKW~fGi85%HJ9mqczwQOZEDDum{WGHF<C$6xXzb0{%+vw&L-)(bgR!r4~e!N>w0$0
z@fBOWrlLlQXXXOKt>6AuI9DcjJn2Ye?ViH?j&0V_)hYARUAN5$f3!;Roam&eYmfFP
zDKQrpE!lYE6vvwsiM$gAOGMYF)^V*_GU3rOu?k}ep_PyHr^<Az7<FZ8v-eF*ct1fQ
zuVu2D<J=u4fzBLXl$sSot?HyB=4!aKteajh9ucmnxMX|IiM<N0A;mZUJ7{d^xv%@~
z?$P8)ySqcJyf)jjg&co*<L=Hmsf)j~zk1I9GG|-C^wTLRN0%+ldH7ECbD{0oqG?O7
zE=cd#yIYG*rOxMW>Ab!Ja}AG7Ka#xKIAWp5k)DIBj%;VNLTkM~+swS-_~6&k=D$}y
z?iY)UyZfu?_bo=YP9xuNu?g=!UH;wuB3rX$vhTIkSqz^)uxc+j7*HTuKS%$%s{zLX
z-kWMd%8eErDpLy!AKZO-y(2)@v}Mzsms2b@A5hPB=qi2L{hP5UT4nO}53Zi-OCSAS
zQy^aXvRtD4zC@r+SlPPi-Y0Z8&Yh}_Unh2S(H`TdGhVY_voy%h-+c4T*{w6q$E_;J
zXcT$U%k4hZveTDg#$(APkyB;gUGmGbckljbBP;sOTeNz|FXPxyrmazx)5Kri@eAX8
z?iv&_IhDWBBOojA*f}At))i`J1NLl<x+u|{z9Zq|@pf6}V*i^d@9eG@A2^d_bpD@?
zAai+`XQ0z#!?iAo9W{2I;ip5x&IbINZWJ(e^R)Wsj|2FmmNe#_Pu_8HSE>bb^G08z
z=EpgFfu3tLPg(3?v|M{BU*J-XUE%iaa~9-WdS-c{#Pm+8$cYe1RwhroT%O|Zo7l^_
zH+?;Nw^A<P!1pS%viS6w$<w@Y9@^#RF~%>MW_e0vGjnX$!S$(KQ`e<#`y+9Gvux(^
zm|HhD6bt_U{q5G>lAaS4bJo9gU}fHXbk(k>heeh!Mt}X%`q*~I&p$KTy2M+P+_$+t
zy`q!0Y3|Vn!k=!fEZDy;C+7LdTC?mIIlRq#QXcSM$+Ortw^{e;9EF1!yVDcg-oKT6
zb-tk5L2-Vl>j%~M{|;YXn5sINgZr}1Q;P@Ty;~;S4w5aJ_GosJ)GIa%hh*kW`S+Q!
zISP(0TQ1>f&#;Q+HzSvv(i(sJ1!cDy@22iGd)nKb;eOBInD)vh?$x&3`#=8K-`gy{
zb73QsTL=GYh2Um}dn`F31zVjWa#@`2O0TQu`R2N9?%g9+PwIOYxbjvyKCFE!5jFMN
z4+VuY4mS-2OZElq|IXN`cxYQd!OHtF{RLb$>k`!x620!say8<-!Qa!*nfvUI&Pi>9
zZ1#lkuiYm1(|X1AIwu;=&Wa4l*&>|sK}d8#-<RL(W;Zq}O^@WeZsT|DX@%QkC27^t
zXt`P34o7y*SIWF8*7Qg(yv#i@{-2iY+PG;8<9do26y8hz*t=(?&t$X77c(|W?f%79
zwJWSG|CY~=uTQseE1qTGKlq%f>A}p+s|1r~Ssa~EJ;7j7SDq8ou89sxyes1k`3vQ9
z>_vXR{&3-$goa<+n{#Co>{;HVdlhN*>a*8*eNJLrTj?O#bz@pi_+>ryNe$wE&#F$C
z_GM4S{3n@HCw={QDPGEJ-klHL<$ubi+r407V&>gERkmq$E!Wqbi#!*qN8}fGR9)N8
zn=<SC3VYTYM_w)Fo8&3Yf1yM3K;v;8_74ix4;|<6^6%l7tBAMxa7^!yh0TP|OitgJ
zTK;G=DDIaRc=Df5P?zV+yIFkixsUv-ZM=T}>hGork{2w5?;hq`H6d^6wqg^`&}~aL
z+q`wwT*&tLecF`py*v7|I;yj)@6X+){*`Hucd(3y;_kDWj!v(XofWGcr)GQDy`8YC
zYFpX;>jHJxS4{iAaejRNWq}iti$d}h!>vOe>$TsDyW6t6bm`T1iN)Xb-Whh}KE1B8
zGynOqy>s(+=jE=gD*gHM+u_v{>{vFwt=n#OM~=07Y0|$)7Jlt#;-}3Y^1cr<j>?bW
zbLza|uu`nuZ*yU}VV=USm_y5&T_m;@`d-R;>#3U=WY9eKUd#r&v#sJDCcg1Zv;7?>
zn3*hMJGI0r_q!%b)1n~1r6FGnj{P)fa5yS3?N^Q5a#^|QiT&>#9~@u(@b}r1QLpE8
z2*01R!ua3;JFctIzrKBC%&R;Tw|MEjou`*sTU1;(`T13qgC&(;Lptbo?4IY!ohr+Z
z8(g{CuJ_$wNmVubw4;A2-Y;QnFHo6zf0NHb>4$~CgxIG07QfF}RZ^Of#;m!@$=JTt
zLh426gb$gwGv)U0{rCJsl^vI>q?YyK<5ybi_+r+*KRh*FSa_3x!-jcW&P-=z)7J`r
zX1?>xzJRAVy0&kETwu-alV&XDjU4w}Z#y<ua<W}NH6eM$oNo(1mCUkh4eH+7_mBVi
zwWnX7hALbUS<yEuStwg7$D$)_Ug<BL*107z>n6`VTzao`M_+T-jJb8HSKJ-#eV61<
ze|6RKt*X>Z--?cmjN)hi3`C@U#Z`&$^q)Lk(Cw&lB~dW&MUtkv`c?@8*5)T$gA@H`
z=^i^d_xt@G7NNRhEVC#5&s8b8<=S^Ebk0Iio;{L}w>H%pE?#hAo5JO<Ctj||y8Qmm
zgl|^nJk00qZaira%en6+pw8GYc_JaouXXE}s^8b@m=62B((&eMv$*ze(sBDUNwWN#
z`RsdIHgsRRtvUbl+1J8y?ime^4`L0j{?xm1@QYaEmuuDYxBq&1_iMu~ne#ID|2J68
zI4P^YrgZA2Z@-ybm}hcSzWL3RTKDs|sE<N+kL@?LCAZcJU5@*`|7ll6EM~jN&;oh>
zDx|U?RYBiBDJ!@nmrLJI!O*~fOW!TCsJKMI!orvfwwc+`(#%)^3_!9uC8<RU`ffRi
zC8;i{$@wX%Ty}O`&@Iswx2{Ir&XYbVSo=KuOY*m+H)E&oV>p(S|543>NhhrChKm7D
zlvE|B_7aDnj=$e6O{bJuItLm{UcUFlamK7?GvB>h6@2yT-7eK#50W&01dC@EgfyK#
zXc$>sHs`~dM<!u5i@lvHCY?TdYx3#?sfDJkk!x-q6<9M@k>eMaKnHir3ngvm0~$^L
zP86JK>icl!+JqRNi!418uC!!DUF=CRk=?X7qgh-yY7S>syc36nDqHqJc}M4_V-mOT
zE$Eb(p~S*0Tz73kx=VoP?Rmm1Ga5LYjveW^ka)1?;>^XT)E+#arD$N;mnG4-@Rk?{
zQ!S^|29LRdb_trxnj|k?Nhpmmuzd7t$E?Z^$G6T9nA@^<mcS&=H!R0m6a=C+IB6ud
zNm|@Iuj!m|kkx7H#t*`atDA}zUEteXGHKFTA!m_@`6A9CHI4=CY{pZ>md`lYv&G3E
zenIflj(Nc?3)BQy7PJ2fdia1#N+p{4#6n#&M**IB7v?twO}P-isHsnsX_n^W*SE41
z^;nG!cX<?;vy^t8wXt+;Q0%hpHl1*hkLj1s%3JOVNu4&z8B<oxioX!Fn)5+gg0O^>
z8KX+~F<}eE<6?7Sp7Hoztj;UdXHajQ%ynSrp?V3m@Y$Acy4ZxTOl_EH{6*i4v8k=q
z(6jA2cMj)52LWLgraSpzI;uCqFE;vFRewx+_U!)p{Ohy3cOMOXEW!9=^X&gyZoHj!
z_SD6HU(d^z*~h&R+kNclwnVe~opEpPbc^Tx6O!vPi0!WCRCj-NT>MCM-Je$7Lth@U
z7I*vf>vvchl>MLdk^4oGetf;{?EhOL<6}*%%Q>gkRlIz*eipy=_o}w}3x52$dVKe>
zlG^KM4BD@*i+sC{<5JfA^Uv(fZ-4#!Y}L(eD;MYfsxICeQ?vcw1HEQr|HBWa#wE`<
z%68wW*Y@4Q-|}~sK3x>HG5+62{~g@_PVQ@{UH$v^?d$4=93EY9hNqqHSiY@EST^sX
z|ID&grmN*5H-ECozQ*oevpZ_-#jB~aH~ETt-~9H5_wJ*#&)vVb@Ba2T|Mb=0H~;MZ
z`fS(DEzT|1Kkq;D-|GKAqiy=ju85`upHScQM!04R=j81<+A_9DQY-SKnd5f+?0+4e
z&0hXDv-*EoxBv9lQ`67K&n!H*j8mfj$~*0#m?M|3v1PO@s12Gt`|0lAzK_?7m9I4`
zS<(G*)hUaAr3KUGO!ALd(N+*BV)pp_vCDy1j+h?}yQID|_x_T{Ek+a1i7fF?kAArP
z;>}kb#+M?p7^>HVeH2X#T4k5uc_8Uwv83}niK;gnyV7~8cUhd7eI;C?ilcqi5%C|@
z9O8mqlH4!F6K`t#`f}pN!}|xlOsA$A%4}ZqCtSzcBu)0^5vxm`u`;g=^tGBTyfvGW
z9(P-O+;Tr);li@|ijA+VK1u!!>-!^iIb{D)n{)ZHcZ};^Kb+(iKZCtc>c;fte{LTR
z<&plczvp)M$L0rfUzMM7uT!7<s@&`GpL+*w-+s40#JsJLo7ruCR{Aq#>*6`PeodNF
z{PpY#u|Syw_MXt|UgkQ-Zai*#q<wXvQqV5fC6(U`b0w1;*}vN#ZhDvZ_6XZr;dPTW
z3+EJ7#+*{MTy&&aFMZJwJ7q5+`9<577I{^iXYxNK;?)x)uw(X&rAZDG6Xz^QIHUZF
z`_<WF&KBoxNU!93tfJu7cKm6;-fIv4X^6{LS3h4~V5k`4ejs9xta0tnwLeazzT+wF
zmRldcD!AF>`_233UVQVfs`#{=HQd1apID4w>T=n5qeTpn*Un|sh?dS-^<4O2>DD`@
zb~VMD_uSrh^WUxo{x^4g-<qf&BCGsYE7Eb{Jnm`CZDp<OTPy#6`}_5*<kgieypv@c
zn;(^l#I8PHHltHul_uY+%^BO?ulrZ(Ry*m|juVY#+nDwmCH8kM@9M9Nm~VY!(|q32
zl$lHZ8fo$*O;Y$>Bzvs&f$0eaKhsKU1Gz(-XG9)-kZF-f^KQ0io7v5GScmbsqeNDw
zzL5?0leqbIk8eI*BJ|`*-d#PNOP8m5oj!kjop8d>$&+&I?5s|iSe|?*x|zGZSS@r4
zS6TLC=TBu@1r}}R&FN#c@ju`C@^^p!?6W`loMtZY=<qAvCLC~VvBKO{sy{z{NxW8C
zyg5eqd-|roF%#YAB|rUV8TMuCCj~u0#ozV&7VUPv!S~nt&D&##-nZ16iTO=={I^ND
zDXV|)P0>g1pC`<(adkK@u4nS;(9_NXC!X5|pFMbc@2n=ym3u9=9Tr&b6W8h{yXu&o
zq<b7^;CrtZPj>q8PZx6Do;b&#U<!NT93ip8`db#iG1%b!+qtMbqrPhW&4nK%jVf&Q
zCcl1Sw9{tF(N_6+Mdy6<!V+7%gj#Jc375?km7Man>{c@SuNbZPwbO4uJ9{^6Z*=_H
z{PW=~U3WE4HhO9J39njyQR{EjX50B@It%P?-`)2^W<!3!*QS{Dn!neaUsw7+E^k)(
z_wKV_XCKWf{9U;F&Nt^heQSKP*UxjACivI6?*xB%cb;g8#KgN#pQUUq-QeKEW6HNu
zKI>1#S2M*cmuB{tx@_`}s-5ty!eN8Tk`zX>SM%1!&%3cdp=Y7DIQy<E50Za5wSIe<
za;Nlf=alMM9>J1Aj}4t)X|xqgk#qjB$9&_(Rc#qpwO>8U`mY{#>+Sk!T(6E8%KXgT
z{aao~-gFOU+rZe+0^690sS&v9S0JYDkM6&1CRR5;Uh&CNqX6SQT`A3WKIU`tth$qC
z^ITxaloyFM4m+M~IcZMWw)#4L{Y|Pfr#(G3^G#C2L>Jjf&p*vQ+&`tTMEv24c5bHs
zg)T~78bU6vAq7(cq|VCe*~KVys$QG8-)DFKviVaVeVb;^E1_v@_UC@DU2fa_ZO8t<
zd-mw()F*;ZJ+wR*&Ax4`oA>PE?jKKIpI$xtWWKq5T*CS<-_4z?{`1uLru_evxLoMr
zjc+M2%4dWxf4-Y<G3)ScdB@t7sbAWs)^=1Zda$eK-WE5x#93V?mpFZUQYX1N886vT
z;1;X*zRPI6IR9kL<rZnj_B{`uvVE5dld97Jm2HR5x@_Fx6CN7({OGCf)6*=%I}Yi@
z{R#J(bYO;z$pdT2MrP*5X+_p=mx?C@Hf>2cb*st3$3(Rw``r=`5BVd)vRhl?e3q$9
z{CN97$Ad#IrR_@`-&Q*}v8EWM@*Ka<W}?6)xYmEOiU@}U+vaau>JQH8Y>;@i`OKY9
z6%)hOtv!<#`LEC^bk5n>)8$8huivJB{j~da#n_+MH<vuk3u}G(wY_?U(RVqP*u(Y<
zows_te|y5s{X!JydOOFcikQEPD<brbxhHBK_T1x_F07S&ef_^%O9h3*_AK=bF8}?j
zz5B)8DS}e*z8-V#=XxbeOf!71BInb<u)*iZ`moo&vY&QNn7~rRZs^8T$DZO`Cd0km
zh3V2t)hXfUR$O@*mb#hu$ppi<7xyw;>HhNWb>~)<(%koshq|xtTY7bIT!pjw>#r$X
z^G<nv-=o*PYlE)wf!r9Ky$=Qau76fE?fZIo$<@8P3uhF3oEX4zP;~B(C)?flW>@Bh
zGYPWicAYJHCpUd(|3+c$nAd9})^3V?TkUYSVEzBeQ{xV3@b5jPwf<F3s@saW9-+%i
zpQU^f-Q)e&=BS^b{n2GQ*0%gSo_8i(lhvs!mG-Jt5?q?X!tsSeAYj@S#}8{cyShGx
z{heBDo-QFM@OH;;&p^e4*{7H83@)^qo%;IL)@$6{S{b^V`Dd?L#akit?6WY7kCH&Y
ztoHn;OY0|JGutk9)>?eWajqEUj-2HkM|8VaT<XxgR-ryWeYMqkdFQWuLNf1Jw9R{U
zC64t7Er?zAbaD2&S4Q!7cUCj3zxYPE$F}@l;+Zv@Y~SYyH=0{CNKfZDrOISu-noFG
z#f)=-#$F?_;zuD&GvD~nw=oOPivG33T|b6#ub5rtz9Qbxj}Ov!>z-mSPiM?*Ieok|
z_RiFoRTIz0OfH-#tI*E!yf>+J|GAtNuNBen{+?l!yRtjiC1*;ne8F|bdzaRj1hSj#
zzklW3v1>fX9E+#VxG+U;^&#(_aqkZP<aOEH{&ky(<8E&DSD&ZJG8*<YIIS^!8O*=z
zs>0Wdb&1m$cd9q+j`*#^vj63a3(XSV0%BG31xp07B@RwAz4QF@1unjuYdAgBLbg~m
z7FwKHa7Dp?f?(^^xuzzHAuKB4y-aliZPv{hTc6tP|1USgP2u3SHEC=yE)HKg3I(|s
z70z5$H9X;(a%IxS5EY+g+tyV-Tu`_`j>#ZZsag1RV`n@I)3X>k4TEZlSBxB+n7by&
z&feV}matTvBfrs@`-qE@PV|XIN)KF<EGjN>Tx<yUNzq;B@mN?+>i7@76#?FSMfM9!
zTua;=`m<ygUD#16xnz!PwbKWtX?jgBCRHe$cwtxk@%0peMUE_I#3B@qvcKkN-dY&$
z8S^y5-@_y)?u`TIa^Ade=}X)g7L>M0YKA%VR~27-8LP2tgR}CM*d^04pK6;HU%jrI
zS{nBD(+1`@EXr%QH|9qij<a$|IIvtQYle5jk(2ShCIx%$d|+ptQj`4Kn2VcF$E?m;
zOp5!!=}PnIG8@gk&*bh1&+n|7d6U&Jgu`NrNgYpi4a?z4bA3fGEM7FnS}##-$Dzs}
z%azvunf3kKtyuG^(;t1@e?Nvj!G|Scld8ef+7+)78w_sV_hr)xJ^o8`sfZj;V~MiG
z88#!U%=b+7M`hXt+$N^XWqnq$G^9beHfy1ckeZ>APuw%H4>L^f98tU!v_w{^S}Oa)
zbfM%R2BS$HA0rDYni}Kz+H+O+EAYLXe)u8h(?^|!6?eAy-^)97pv-v7vWDlPfyz7!
zg;vTfwR+yQY0ah$74B9)_ecBZNb}{HJ&@yQOsu}Aqcth;rc+||5ni4IdxhFf|B{je
z*D-A~=m|L#rTDFD+xHV6?%Y&1|9$And&Rq*f+lC@dW7vf9{N!8%%OQIwR2d^roQWO
z{AtWq@%X%i+s#vrixVrA{{E<5@-+YJE76y7AAe4%RpS+^o_up{Z`x{>)6S|tHXBz&
z%$UNalH4V9#;)@qcjJOjHy2twljW<=;hoI$a7p;WV>8bkn-Rx)$WdZZ$Xoq(F8Qvb
zPrpysXV&x*KC)8oqi=F~lVFT&$E$aHJu_rl8J_%}{r=y{1Lq8?9&BiOBOCU?xn1<3
z^W<v+{|=v0I+NwGXjj=p=CX<F63fn{nNQnt?8<^UIqy%HJ94l1nQ~)NmRXwnK@W*5
zy1u(kUlTO>B$)BVXhrpdTfIGPv2Xt?sm-1%DBU9~&$iTt&C5z|$`79fIXsJ<Pafl+
zUs5_L_l1V+E1mSU9TN<_FHK46Gk6<%?Dw0xic~K?`H)@bB`;6AA~7R&{~j*+ZVy%e
zpR;yzEb=L{lzsTT<LKto=GU*Ecj6K}Qs(j5U?%J3-RmW!*WYk(m6NSudgDJ?t}#mX
zj?KG?lN1<dZd)=>;md8N&u6NC#ebW{V(XX4zTl>$_BoE_?!mqjUgUl{R?}{gDPI3!
zJ7<#0oYS{2r#*Jw{PvtiH9N~QnJ+EOO_T3T;nAMQ&UmCl=CRt&=gTH;{<!dFn*sBo
z=&lcv4$kvLOrHE%@beFAYK5+#`!%7WNy=xFKK%+77hbk|)kfhE=?6iNrwcPCZg{%&
zX!hv`P7AkMoo+1cKdo?cxzSI{Wyc@;#W7vpZ|Kg#_-jprLf7(N8ouX02L9^Q_`0zF
z8q1r5$LmjCyU+bLar=L6)<p^;J@bBXvsPPOwDwTu5SA_M;`k{4TjSmNzwvWZ_xfRJ
z92ps7X&f0FnG)MLdJCFRIwn;2eZ9h;qKpN%-u*4=T2Sz6S4OOeMQ5Y%f|tzB7tNAg
zi&R&wyl8*_X6&R#LEfERQx|A9F$n4(zPt0h`Q~FMbDJj1`*Hl~7oHU0G*Q87VUx0F
z=A`}BKmW35uG!%EYQASh_Wt6KJF%ahF}mGa$NN7&Y`)29f2-H_`|W=I3i{Ymv}B9Y
z$**U{#IIj|a{bGrqd%X1y_tXAe(r-=FW;{(|M=Jb$Mt}3_4W5RxLB0M8?_3mAFKQM
zI^SaEq1*EtYEwf#-MhHYd&iXz*4}YtVRDMI{CJEed1=pF)TzQGSn;C8YW`ilX{n{(
z-{mMtc<-G0{<Zfh>-iq7Jgv4ef4|O5ducR#{i#(kXR@=dE_}uoxKQfT^%*BlOp?je
zF*9Lu7fbTczIVZ9J!gc{#6TbGzzGe#YAl6^ZAE)OHt#U;Y=1F(Gv`FDTG2>B6Ae?|
zX(@s4s=b?7p5z?r^_cH!vA|(vH0!>eH`;<5>+VKQblGOgk$v~>H~kyIpT7Kj)Vr5q
zvq)v&ze2ats5O69zgqV}Jb~TLUOCh3^LPHpyqE7}3!l!{&HM9Szq=^(hiH7P;{P|t
ze;(fT$tLs8)Lzdc1=@Ei=ZW)&wv-<exVlVHJA9f-<5bR?vkpZ~Jp%ty*{p*m-COf~
zXR%@V_YE--VgEIjAH8B<nfzY<?^bbPy=(mZ>B8EVHvL@_wL|@9(zOd|p|w-*Zr{~(
zd(A)Hxhvj%stJ2`w0_p}%Sm}JS8vMNzAQ6sYt-f~5#b*)efMb<6>KTtT|fOB_f-S#
zWdb+XUT5HQl^5n*Z>TINF66Q5R;$a4oqH1kJlmJ`wKke^vhAO8aFLB1-@!#@Qv14c
z_)dRRKXLJHkn*j&hV0rtGafw<Irr-y_qEaxwuNUSH~-u|(Nr{O&)0y0YQ@rDk9~dk
zcs(O!T=`C{IZ~opDV8W}(;{Iz>+5<4(WoD55=uYqn{)Qh)lC)APp0k_lfJ%9Kg^8n
zK&s-MIS;ZN3KSKd*6AEn?>Rl?%ANGjE7RACIp3J`P%g#n$GzJXr=|%+x7KGDPp^NS
zH$C#{r`xfCKYb2!um~<r-0|~6{g(M2>jnOQeU-Oyp6}nUv1!{sd0zdfcG>*(I=<a^
zPL}LjasO%ePnjvP=kot{e-B8`zO*WCx#-%B6J$0`*di9SGbQ8x4U>&p_oo_PXsAvo
zo^$)jx{j$&)J~t+*!Ftr<qHLOCgcfjYCEi>YW6C3qrnj?eu?1gOhv)nTR)jAh~GG?
z>aH&rkavWcDf@TFXU*B^Un<@|J}h~fOK>7%^kI%`AJ$4AX7FEq$a2ZkbNg?J1U%(h
zQTy!71J#l`#_31r^A`k%ZFcv6WcqL~Q=Icdt?BoiHQ82pg}hj}H7-EDH1C1(153pP
zJ0{uXrA#m?dwA@bIhP=-y1>h=WifC6=O1v|zstL&_2#i+F8<Jszl)@_EfVaUk2zS0
zD($N9%9-2hwn@u9jrr8QeZ4x2C;PVE<a7UNFw2A`z>D=*VFc%^gNqZE-g25+ec^z)
zppTlY-yNrv=xOg~);byJ_<Fo(6nEWMlcN}`V9Wk@OV5!fZCbo`Tl{l2gb4IR&eNY3
zEU$E7;*JGLx>{TN<6?PFUJgC%;uOy+)TX(Ahx|8dw%o}aAIcvXaxva&4cfG@s@Jkl
zg5eg&Rj1z7-KRS)9Jvu!?81J<>Ori@ZB4l;QHPXIXB?^I__eKBxTb%bU2)aFPp@8?
z91}S3)%U`c2ZsGoaT^6#1k4Udc5b-F-_4u7g|n;UYx7d|mc#=RduwL7pY7V6n!4Y0
zfApH?8|B)$3MMFU^BHlk?RS{5x-QX<?ay=ThxJ>;@3sEFdN0dr&i05I(^S;kUsP_G
zxkPG-tx6f6m*3wV9Hwny%yWBH_U@37F_>Vun@!4f+xM1zpADDQzTUrPF|U!{&D|^g
z)_>JoykfpWj@^~N+k`R{!gEYoX0Khec7p8GlX2Q29BDhJ>h2EZ?NDaqc<J~luBsw%
z&8nlDIx=S}9XrC&a`}?Z`*xY7;k(;EfB2*pX2}%)d9r%6$o&*;YpIP(FEM6Tm<UKQ
z&6#jgf1{y<v`CH9qlGsf9NxH5{`)pH)5LjOwO%oF&$zi_wpGc)<8|!2>@&>w6>m4p
zto3*BUvbGfOGze5Y|~QpZD%WU{B|ur)qC~wwY=)~O&1?MUv$3TKtlct_nQmn#gAJ|
zO0LPc{Uc@j0`|m38?L&g7<=9cT(hDz$xCj3)O(qWrdOj_(hf;~@3Yv-)@gTPdG+4y
zOB$!!c3+>yCu7m8bt7lNBR<ybrYSGJcKx?EHaa`)^Nm6_x2R3$cEzdReav2c-@2~g
z?HcR44VepP3LQMWQhif!MD^?T4u_(2{~WW=$J1I5?SIQ>d3Sc&Jj-Rr9RDvYT>oDq
zZMD)m`3}d!Ki!$TYnK21IPbTs!+f_{FZQOr+ujkPcz5$p*CWeKg|_eph4>2`(v%5g
zu~@)q%rN)Nxkwr3mfU59b-&uGi~W>4qPb@Oda?6VUUG)Suk^xz*H!=i{&dw@?(I?C
ze)c`z%*8htx5#_FU3HVoi@SZnElZA!<j7vRmn#=ejEif&82nv(_8-Blwl*!f+p&zt
zmTj88K3?o?!tU#5g*5F>efT0!Vp6lfWJy-hj8$(-OkUMYII`6u=4gaMa+She|CfrQ
zzn*NFd!mYc-E_U9)6LAY=cQ#&x03K(ZFGLt{``)RZUxy>6Qli;JWK9}+nT@FXfMyE
zp`14JRq%PEXm-1`%I}|BeM(YxIW@81+1nkT-$^Rff8sHmDN+5-uta13;<dZwudloC
zc#F1q``c~*^TQv#n9H{GXz2a?b}nuH1Fe65%l#9)qH*krX`zm3*WBFr9k(+~>lO)A
z-zsFZ{ITc3(dAb97Pkr=D<V>~x4oJ^In|_CYVkH*sadPD1Ff>^S2T5f`%qEY^Y-}M
zX)L#|U#b`XJKNeRSs?j)hhE>zg`J0D7=BE7aOaWdjG2tB&+;_8RqcY$=qS&)DI;jS
zx!xj8ti$lr`vYg*RLrmxYYX7-P)lx`{4vR%DOS4WH}gb)dwGH6XUva`XYdz9Fn4Ga
zB&pN~t=p`AT;Nlgrs~n@KMy>&m!A;-jQRhgp9kix{at_7T}Nh8`#;n9r-k<lnl6b-
zdUMiL@vFqdN&l|ZGoNKy!i=SrWsK!K4-;cELt<N5SEFC|-`OVk|K0wiiTW28#)U4?
z2+Rr)d2Z1c%Uo-5T`l7d|0lioep}17PTXQ?{r9=`VaZpecaB?5S2)VJ{A$OeWQ)(U
z+1)QbN)y!GSEux#ev1INX3C6?97SQ#WkGsjv(@cwI7^o-t~ogU=@+s4o7YbHyHZAx
z%lM7-KmNV?vENSz{y)EN-k*Q1VcaX7=4Ni(v1^}s_v){Yen0p*`?Pqt`2T&sK2PpY
z|9kc7#>)S)|6)%6{Q9M3Nz{|Xd8b64FMjIOt<jU@8(bN-e|N;Ol^k7frRq;S*rXNS
zma+Y4>y?B3;zryvF5Q*N`g%{uUPv@U>Bk1AOSv2OKHRog%}B%Qy5miu)bfoj&r5e6
zP5UE~_r_R`Eqz1m_U){tUqv!21BxD7tBBo+cHAOgcxc(f%G~a}`yy9!8rMd?m2Q5+
zeoVKO<Fkrl+6?}=H@BtsZti%zVBfLTk8Uy~UcVBXyL|5|ZKa2{aowv{6~3|FrMm6g
z`Opn(cYpfj#3KLlnxSO$ov3>^;@jqJTPB-Um_3~%<b|Mk`nHnWGhWwbUt1X45s<j<
zN{MOx=06*Ef4aAcwOvs2gOrAR=ig;VuRFSZ@o<}@GlgsE{j$%p+dITFXS}vJEOtTR
z;6<mY+F7E-t2@`Ut~?>W*lh>v_jch*4dsVz)o*3}mKGV!u}R-??2XjrS#bvn-cCE}
z#GbFba9fy3!!E`;ar0$Mt#`jI`0E|J?ar^=*Ikq(rR=?%udknfiC?07=B`&>L9<>x
zb`@iPcr@r}WkKob`~vOEH`YdTHFQTDy?l1}Zr6ho4ZrL%x)bd!645LxUH4Ay_UZHC
ztX>^c!V)}+8*eQ-^Z9q!gC)Wi)+d&|i<$rT&6~Hn9JvQ=*ZT%fYFpd+z)kD=iB#E=
zr>8!Nc=S16=vwxDV*E;};5Ci<S`Pb89`QUHBYC@OnP~LkQ>F~u0hwDJWW%H%H?7)K
z5nj8*`igK?Y@S(Ktk~SUlA;k$9Y6eCcs!8dL`Z7ll4O<(@Bho{UUO)_*=lvY+xm9a
z=73DL>scSqa?IrXyIJ$bGQ$^L3q)hX%u9pIw$JWP6<VqA@kGI@!xryKA95{SuE{XT
zs-^k&s>MauMV?rG{j&U!j#rzR=aZKze8zXPe=l|aTe8Arb-dBlZzp3GTur+2jN5=~
zCEva;B^<ZstjM{v_=8{E(w{rLBN`ZDy;457pJz#7Nz*Up{&~zePl{{Huf=k;7L!^f
za}KVUD8DViLiN${XaA-3|4%mg=oc;j_}b!}hB}4+U-b|C|F2Y+rZDT<rEL3qYhLLp
zRc_W?)5hS-e!bM0pZCSAhxf%?Kd?WX#2Pn~)1XB1u-~a?d<*R^KIm$=6lu^ryHnap
zMTTWP-}490v+K4R_EbDL*YSX@Q*w4;g_YUkZ6CSzs<(ekI6uA9<3PleJ9RzB3w9q|
z_x(bC_xe&77Uk{B;#te9J=+qaA3t4Z^jdmzqW6y}Hs=jCMqFEv?rnd+=5Gq$A^lU*
zo1_~Sojj7<+U|eTHfh1SGk5x5p7pXZ)$Vv`WBfePQhvo7ze?NHf~(W?zK9$>cviHE
z?@{4AS=Nt>6Xrd!Iuj%|CH(f?eZLQ<a2Y%HT{iIg^!wKO#m=|>?@L+I_#kn~TF)8J
zn4)flZ-{*vxK3ix47sd2b(_CBD^Ch7o0|GY>E|CqQ7;L<sO8-gk37%KyxOdLyV+t^
zgZn(s>ksVzfBZQ!QRusOd~IWx;ito)a$P<?G6x=ibL#z&wa4+WoA0(VO{GNhGNs?=
z&#wBp<8@8I>SM<LFLB>=nm0#(gMs+tpYLuLRX?66$Z0+8+nGB44@C|hPb{4l`EhqD
zDV}t9di3yNis7_&p`+UEtS3LG?yG!%yU<|W$`8B#{JPOs|4@=wiZ{=(`0s{`=O(S6
z`DA(GswWG+X*qG6ZnBpZI{I<9cdOoEok`lZ%`Xhje@&V2TU*@d%HH;%D%F6MjK&GG
z9_*06G=uXo<7vj2rzNwr-<v4Uy*odxtYB9BwcokVXRh*blJr0DrK8OM`Kn0<Ozvq$
z*B^UXfAxEI$>d|FQ`qs9e+3uxEfDBtx%>am48bmELH@LkGv`_?nHCq`4xCb~a8cA;
zF3j0^s!hlB>G834-#1#Z_EyfgYsKT4vVGFw2_n8cle%?2ab`S?;<?<ZbUq?egZ=*I
zk4~*UN!eE(9d^rQ5`EPWD6HNaWn`B1qPae8eddRm{kIL4cTO)@cGAmH@lwUBJ$1>y
z0#c1wG_q&?iRwGCe&0g%JyZTnH2<<<dQqR?Mfch%JLP9L#4TTNJ>6>4_uzezS;fs-
z?7KxyEAKq0VXtkj(PH!TSBLSWQct1zQ>8_izt<+PKAP|LS1kFMm9)_{C9Yk|{!Dyi
z5p!>X&qjXk=@T<^`}B^=+;y+oV%WR#$M;`N#dlr^#06YwjlKU#;_-qOwoRRuXE$nn
z{>I1ls7Kyu>paPycBl8Oyq(8U_Ulcmjo*@ky))JBEZo`Mlbdz+F|P{KhWPotH<Lxn
zz2^FV4U}b$NLd+lQ2X2>@#+Z0waa1(cl5o^_`Z6o;p=VZx90CP^kkYNl^UJ$<gARw
zMduqEuIut&5uN)n{m+!XLmHR*Cw&aoJTlkouJ_MGt{c;pyc*XtyUq3cc~I%<;^lMw
zQnKZqHAPSUZq_w5J?(>cN9V@qW1jEMsy9x`sMXS6=I0jq!0w=xd+$GP=d??y5k{6v
z)C?9*)IPH}{{yF-VdJIg3qFRr`nIbW-)UH}?o8?3hN$!MTsHFzeUm>j$la9TjNz8M
zH1Ge1f*G$AA}$zQH<^9t(5*G6w!U>!z0&JtX_*?V?XdOdvNO+S=LNjnbmF0eNv!Fz
ze2?Se9}Yk3>)EaS;?psn&eDpHqP>n)T>b5v*;=+N_FVG*VQb9^*@LH7>X$FsROiT2
zSEf71=#XH0?Z-L%HmmO&9*WsnGr3uO`o^N2mK7<*#T@HOt{h&@*u%4-U*hFuMMs%8
z+q0)HdlekH*qFU7&eq}m8xN-QKXa-C0`vE7n-%k+a-nUF&dD>EZeB3Fy*`Q4Yer3$
zP<B^va`Xg7Wya;AH?Hdl?JxV3ndQ37k%y(HQ*QReVy2nb*U!`6|Bm;#4m*3djdo6q
zPNR0D9k<AN$MgI>l`>NuyE*@-<os0Mah!i%rc;Yn(38OXuio4_#Cgr8zOuu3gW`NK
z|7_V)Ic0H`FK&eW;FEmD`1Q*jB@?@y9g1=vShfdu8^-O(H&)Qtzh89uXLf=0PdH8s
zaJ@Jl|E~G~uRjwbi+GvUxhY>8>ciL+`Gq-(9`Rfgv{sF?Z#X%Bn&XLc1rAkbD&BJn
zH{N}Gw#&vQo=Ll97R#KM3paZn5UExA_Wo|~lQ%8ftVFcj?p5|I@@4Cdu6GJra{04m
z>Ai{fJHI^l?D4N#$joMHpD@Ge&&(6bTX-gG{I&P7UY7pw*p=S7Ydwx_K5}sJ>gRiF
z0zP>jTx2gl<^MCGnv;*!f7JZuzB4WA@1*778@YrHL%Z$=seLft_<6EV!l#Ov4)6P%
z4OGrst*?pDG6=g+DEI$ONCJ<X;}qk~`;HnMaf>mW9ulM}9;o3Ee2~rQobONJ?T-t5
zS<N2Y%Ku>RzMt22gKJ3^$H5SJr>!O7Arj%irjn*xkIuIcX=&KjB%HBr8gr+O5=+3*
z-xsY-dNwUwv`i+J`EFcrpzHN=C+_TPSEQOY99xs~=j#;beE+{o=Jp@q+I-FD)l-pa
zb8mPQpE&0kXB4*MVy^t&x^q{HrLAq_r0?8*AuP2mHumNxwoca^GlMN(nvU!5%9E)w
zH+v;|(0iS^tJG6D>8$#4!;rscwJKD@vpvK&&YCOTyl$%It-NhFR;hc&%h=rtd$WSk
z`P9|MEtQu-A5Xoi@@{MQ5ACoQcfL+->MNZb!hC-B`Y4%KbrUNW>%PclNPMtw!$$q1
zJ0HF}Q5C=Q)zM{|$Jea<euww1ioh(p&)q?(uSG8}*zs;hiSaC{?{>|%`%jtb&Pj{7
zIy*MiYV)&0l3vFTH0R!}%#yesQXjBqwMO>O-{Jzb0?$<!ufCG_EXK@1c*cqeoC)?%
zC6ctvuX%o0q?H%N&-9RKlR+8B-}Tqy4{qz|Se5^webH%^>_p9c<%tgS{c8gyTJ$2i
zE-bFnv60|pb9sJ`YfEw0ExwYjy5c4FJ44?6iF?faRA%{UHpZ&tzXi`$6u(k-Tp6^s
zX}w2nUgq+E8KQH;7R>53>(BGrCstC~E*img-pk>kL%`HC&DK7rHY->>PMCegMfA?O
z)T0|-o&B=d=ule3b@S6w8}@u&>Fb$rUi5~S^#%X;qW2yfpOfL!Vm6l!xw=bn>Cv!|
z*ZGqdX;o}heY7sa%Ea!P+Z%12f^94Bvs}MkTFZNG%Pzy&s`t*{vH1URI@1{m(@)Fx
zD;GSO%-%09FQGrPZ+p+da={~8OM?^sK3TQmO`~|hiaQL))zvc{SW14(F}`Zp;+iFQ
z`vbe|wTKkK!tKZU%v#<{%1zmtdRsL5T<vk5#+ep}Di(e=2>n&#CS%Lp@#KllfzuU&
z$0pW%sCc#KV@~NZg|aI;d#+Way?ZV7<D*#2ul!S7=fzi~p48>q^=EU=uDw5d=DnR&
zv|H=orVGZaZKf@r=VM%_#?mlfCD^v+<k1;hZYsU_%enH?f~`x|?LP3n_(0dGCG5g~
zZZ>x=z5b<dLG*@-JE!F8Zn^)ywv$P!mvhoJlRw*ZuOBN-Icxhhk=Jb7?JxV}??q;}
z>VCUj79VBp$-m})BmbI3>%WCw{2?<vY5VFQDndJFKR3%<zvyK3w0-%$&FV)qfAr~B
z1{bxsrVA`)jC=Te>%sSZJmpa)KJO%3L!#vOpIH2+Y%h0i`oRUuIloLu*=W`EBU^cU
za`w9w-_}m@aXh;#Q?1VJc<qf}w+_n-*&2t&uj#%Yf75@R(XS_3%;rmDO`rDhcQqui
z3ao28cOd^|-YX}C)*p=y3%35Y(k`A~_jI0kgx2j^Z(TOeSF=leH=3D#k=cFk#bM(a
zqBHqlOkQ4Jp8d3{T7_YQ$Fj(uTY_13Efls5NS)HH!5e3|cW)}Y@#V+Nj=g?zbJ@Oa
zW=e8o@7{4#TH5vP_Ar&T+h_H5?XTpDe*8;ezTxH1liJVB^vy`N6VWzbo0NP<%c{!D
zVd31EHoNK9)_EnrZJN8{oLe^2rshA}ww!7|fAZyZjfZK6_h(hPWMA3f)*_TG{~{yk
zyCToqj-^ws*V?B#FL7*c*r!)GJJ(_g!=2c$b!z*zZBsq;p7q1h!iPKEcnTjaDt^{_
zuFdh&O9h$ms*j89SNUvyDY(h+_j#Gp^}4nZJd571UN2ZEbE;7E{>*FY-=gFNPjAl3
z`4V9E(fF<GnR=t7!#r6$4v(&J<*#ZtC~uhf`fu4&1DF0U+a9milX>xB>ycO0*QXs{
zu>Qgah6)}|zP<}}yyrC3f+jKlmdxD#UL@!CE`{Cw3!aPVW&dGVys2=`1f5SG#9m0d
zRZP=So8NM%n{}&Wv=hr}v4XpyN4wfpISTGs2i;ny89ulA=+z4uyQP*py*M3p%=L%m
zN&erPUhe;zQ5g`$FFNJU=4P3>X3PF}tzQvywkNagPLu9=$NZW5k3JAzKl@V7_4%Kr
zLpQ#D6>ITZ&*{9K!HLkObsjTRYJU6)>w0lxyU4fclP^wZi_8wT%+J`nc6anu^V^@)
z4|mQpcXdDWq^Wi16ZOg&J^t<WZP}a?E9RX$?UTUuKjUu7skbX<ahk3ZKNM}LKii>@
zrQ+u`wv;L2+LdoxG;KmopEQboelT-`_nwtiI}0Pt>*lhizx4`yWN_-aXqKtwoZqXa
zO=@w_cyZ~=opg~q*KW`EIh=1=rf>3&Rq&1a4)bM>|EJpfY|4+!ZF;_J(>ty|RcVQT
zW$$j#-1IoNYZBvP*ZiA)oNpUnnTp9bwr#PPaaf?wlYQSQkDIHGEj@Gi%-k4H%kxM7
z@!yY$w8Ap7VuEG<%GkizLIDg2FYb98^Sb!9nb7}t`<*81FMX~gqW`GSd~Tn#dFHFx
zyW<|^XWAPG<!+v)+CFLW$uINwA8l50Y!v!h^w{jNBsa^)2pzHgu?gZwnqM=@?Xgn)
zAkTlIL8vQe5u3?Vj{qx)yK`$S9EH5su>VV!u$xu2O=P=gTx!A+pW7ey=ha4-+UIQf
zfB5Oi?fR<n0ewp*r4&?dbvpXA;)9-Leet(XpT2BAJ>P$W`mf`sOH2Oq|64Wb?R|bz
z&z9uq$=p3Vt}T1E`~HUnp8R^YPfMpY`)_+AD-!s@T5?bBmOIHASqmnLh0K`fX*I#Z
z)g&}8Abs-d$Vi>McYf`2I$dUcto=Rdlbh&7rL`<2N!l^<w5CnDSrVtyb@Ph&^xj7?
zihh??{a8Pv!(+CL<{gd6k35`tG<WKJz9yc)+_)v>lu%oTAUjizcdVw=V)nv??7dF^
ztz?B1CwF^vA8=ZFNX>J~udvAmOhr~Hn*RH`0~|zzg2I(6g<pm*3i<HDW7b_Qmz_Cf
zvwe?md}k6ABAdbVLv7P#jqQE*j78r6R=;JtbhQ5Bn{WItf?qvpzgazf$H`}UfzKB2
z`BCAOI;lVQ+|4BtPw(r**H@f)&i#GEjL@0ew;f8qY`i8(bK)hY4keG}i{^b$R5qIV
z{PM=ko)s#^mia!VsjF@u7vH@5w`bn;6}qMKd(UKtr+vJ0P{K>MVhWpD?5DG<Cm-Cc
zxLBn!GRA(&&TJo+73?K8?KNGK51Ge3`#w2%QjOV#2A&BaHjU-xACx{X@k?L!+kai4
zfRCN-GxMGDm+I44MU*?=e|~i6uU>mi@K&Sh{U;WrM^92IV`Yf#^S^q?;EQAZ&X?U;
zx69sr($cF8vh+UJbf_)V^<~gz?eM+NbpD7<`#53t)O{yk*UXxJ^AI14+;ija_ck&Z
zx!t^?D)uwwQP9oWFuj<K1!*<6f0l&Q?Q1vG`=gM%)}P_ZzNNGGEVDY)Fe~ZU<kdn_
zv+nL}KYI4erY6Jtor|UK{kZn9HCtBbd+NW9Gi=Y?4OX4s#r!&|YC~AYf<%@TJX#Ua
zQw`T%Teazx`Kqlhrvxs>iSD0w&tB)B<b?}St9=yayb5iYyo38e9ykB81SS&(O;;yj
z4b2tlxq%<0s{-P>rv=_vJcC!GL4I{YzG#rjq#DoES6l`%TNa6~<offkddYl|r8%8X
zln-1Jd91N5DB?+i*qdc{X02HlDd%%3;4sg{0KW6Z+DV4r3KmqK{3Ee9!JT8%#Fz&O
z4sQ?dnGxsyY}TQYPSw@<jJn_F=IqPcG=I11;|ttk;jIo6$_p<ZJ*&3YxrvpdolEpU
zlp?DVOYVickJOo)D>XI#EBKw=;Uh6mt*+us_*KVHUC+HU4Eh8V1zI_eG4?YBnz=T*
zE|NOEe#Y@Nd<KjvuQkPOCUAEqt2OC2=gm#yJ=n$3Wx!mrP^vH@BU^yGW%kt>PYqVx
zRAjuMd}*7@LRE9#$1g(o+qxPLoDfUPXHwXB_0G0iE7PT#8?Rb=x-jLPTBdUS@{)q*
zCVTDV_nlfkv6a!{jAz5)xdluyiV2^#?6`E?%(TicByDN@pMW(7U2fcB^kES8j0)}4
zP0GwU@3yk*ny9DPoNLLq&dmQjf7gw}6W$!3d+kTNP{#qAC!zKtOFv!}YO*_(e26jV
z_MOO_xcwVXHl#X*ElYY_VVN+&EQ8~hpIqIJ!V(3Ay#|*xIhF}jH!|m(S|ECRlH!I&
zKHJJWx-seY^X9s{aEr+0n{BD=ua$PJdr(%quAt?qa{}wb#x9kO`x3G&3{NOsmvGtR
zx#dN!z(>7i4tL$nZo+b=c}cSadpZId4OZ6uzP;ke)yKC^UAe>k^7;&&hE9Xaj2FJQ
z$T8hGoXWl2ed120Sf%YkPsKO4zf@8?y<vXB?uRP=g3pY$Ecz8GYGS2yifQvB4(^iF
z?n&RaMO}~Jun73uZt`i{{jYC!oVfn3>WordTD@z{cjhJDa<d=w-Q~Z(=QrouQZ{R;
zOGYoZ%`v#U^}_3y8FL$gcG=8So%_iurzDlN%wwt7zV}h~zI8m3u3A@P&2G+m`(@X{
z_dA0tbri*>F5M`3ar;ewJF7+Sv-ic#+22#Tymx=fY~v@hS2QxdH;<5b_;2<E-Jb4u
zn$>0BzCC&r*^|;VW0CIf1QEqp#_liEw!BZ3(4Fb~d$G_P6GO3wzvjBNiZ(wul2R%j
zFv-?Y^Dgg{6)n508-l(ckX4(g|LRMMzt63_Y5naUOVm{+y0<KO`eNSCuYdFNt&Uu?
zWIej>WwKt$*2;y_&CItBTbbnkUeol+Y~Rh71`XC`)_ayqObfsL_1bBv*UK+D-OT7Z
zuXxi%ZmMsJ{^C-DE63CXZ#zGaZ;<vs#3Ljv=q7)Mr>a=Nc!mAj{scDGb()h7xnzlT
z{k>fyX)pNZw5XDj?X1@YYj3?UlF#7(?D%G{KL4JHk3R01SpD|+?Q`jREFA0JysqJU
zUBtROc4sb6*p<Yyj<&D6Ub)Q>y_{6pbAxNM(pLQi{xd|y{#-~5lWv;4?eLGSfp%5L
zSIP&?J+`=}!Ea6VvF?whe5p$>r)^g|)m|)q@bM%)5muqlIsHY2b`w4ye)HG-^z`qO
z&+EOsb6~=Tjfx*$J2_c+Z}OZPdi3y)<)`9#PIhxYDU)^yl)fq2aN}t&=jR7Ej<U?0
zV(?I3?eU?#f+xFgUfB|NFV$^^8O#5IS$fU&KH8ZoKiY%y9#6~Je)Ox!>>XQpWejcm
zq#n9IYwcWO_;X)F=d+o8&&_9c2RklzR@@=!Wjg8N8Y%CqXH{nFCr#AjJzga`KS`cT
zev8q$#y+hhPqV^y#dy>h#il>Kk?JsA?E;(H7WW!%cJCts1t)%pt>~GORG(DS-O*z6
zV*g^d%0EA*nLg2b9Q`BSYM-iYT}^l0njd17FMf#aDzD+5d~DYO_Ky6-Nzz{Bo%uIE
z_57J}Zo(JtqBfb&27c>``QJRh`h)4b_s?CQFRec}LH#k0<psf)_b-Sm@jd3YOxp5r
z-h?e_yZWU6?YhkABQxR1bWV@Gv5IS+C&t@{bJ*_Ce)4+dx9h=g^<Rbjj`*chwj$PL
zYR|QzP_>lhJ|Y);HJ+Q+HMK1=c`4qM&UZz%w&`KhyldhYodbpTdI{fOd^Pac_Kh0J
zHzE=z<gW}o^=)^v!x>rE+d|255#l#Xb<RjUF|v)A@v)3OusWyhSEcvA77e$u9~#Hf
z4fB|N4{nV2|2}>Hgzq7D<NJ*l9!ylVzLS{BWACtEXzOj;=cVeGO|E*Zt#es0{d0Fw
z*NhA7g>`{!(YhO7{bt&D&G5eXjHzGM+0JcteYWnGUJv^lxsqP5v~T-#o>-c<d;Wb`
zx90W%6}fk@7x#QApZ9ie_+tly=>_S+^@=-px!as`KWgzk_h$4B$JgDfZW`^Mt(z02
zzKnV1lTiMd`x#>IFWI`A%YIJ6*1PG)?tiE>I(_Why}~TMpN;$4T~jJKTO)Q&S^WD<
zSa+;^lgjF?-}YEdDNWxL`Ewrw-?V$mM)6agy|@woW^4FH`zkhvhu^2|x%T&d!{T*O
zXU~1L6Y@GB^j5!fZ;gt`@^9W;ckLz#EMb!OZ0??|E4Jb$-=s<}vD5m3GberHn)9BK
z)kw5ShJE&QnU73C-~YDVRTkU7M5F6~UI6=6Zl$!{E?pbsJQ!C`yzrKned$Dx{Zf3<
z5`3=;+79b~?A`fj?&lkBiI4v$`n*Zu7sxy0&L_;{9KjXV6Z7|(fbZ+v;sZg+UoT8^
zRrs>XRpHI`us7|_QWGU6WZR!>dVAgWLFS%qtiO5rB5RuuKmFOiGvPu{*z?<Z%TCKp
z-`i;BA3SZ(x2s(7*>kSTUvJ3yzjEHe3;a5FHtX+sX6Dw!qI~d%?y~(kGHk{%zy0<$
zZFlp|uYG&^TuiKRgW<{RuM3K^r%paxcl_{<+O3!R1)dAsW4Qm=T27|n^GO8<@k!dn
z9E;1k<2r&I-z;Rkr>3>=())*JT)tNK&tQ3AnY?y4>y8~=nx2opPdvWpkjq=s6+iUK
zZY9}$+_pt$U;pOK%LJ}{zB2n0zgh0SAHh9F|1H&pPfQV={PWbE^?AQFZ)`OA!u$7o
zqF{8%+MCmZwxsRP^;tDT_a>+6vtrh)XoZaoLWdaH>;!Ea)@mvKYv|rocK$#6OgDp6
zEZqfDQ_SUVCdLLt?*rT$9Xa{VHo>~<>t}2)SY0L|#InBK=0xEf3(atuRN?TO=a{D-
zIj8V!LbBYX>pwrg<W{lpJ{jgUHRvkejUCdpHFp~p9eybw`|pQV+y0A+b}J%UGh<{z
zRvq?P>0Dd+_3>(h{!c4xPMk0N-T8OL)MbmxS~PSDa(?XYt1CGyzxShkb;Z})`bD(?
zR%g0x>}+iIMjUl6{-O8d&)L`da_|0q{qQ_|qRuaVe)*{H_aDs9uKfM`G<VRifVR|S
zMlt>~TT`dVf3o0Otn&QnpS#<Ztv-7<@M&R!`=3z9qxS!|95%UswDIBj*9p6C#YJb{
zu{W$V`D%0HrJv}*&#@C(zB}lZ7~D#YkbKuA+Gxle{CZV#)%~sKFKzf&xUKo4m>_%p
z`%5M(qHce99^h;0S866~{@bprwA_e!9iO&Zp84GNI=i_OFCJKwEYqGk>(jL3|C)kR
zINzL*IqP3GC#T%0i*H$?occN$pJ?B0?~iTX+g9$r_R#}>+jAfI{?FK6uEl?*VfWeM
z8GRM(clDONS`zVb##+mpC*xLmrq$lP71bp!!xG73`^Z7f>~V<gwlbT~>GuA||GoSX
zQF``X-h^(?b<8(xWgeugp0?k-$LSFNmN)7D4jf!C;mt<=*Y|I}JhSxtFZUa@vzA8e
zdZ}aW7<KlwN7Kg`UZ>SRmcQo-XB1xYEUH&|<3@R@Wj?n5?Ud{tAC;9^^|MJYPYvk(
zV?DQUkItf49y#faMW-1Q*6=jQiEdgQS#8Wep;dO?$&&t1%{BeMKiylX`(9Y1^nU5G
zX$v#Iet0dx<QgS(O6c1rfBjeIH*nriS&{K>Wk!%#;wr8iR=GcaYjiFREn;|kb~01+
z(!^=atliGBT=_BD@pnHPoZi%Y{YANfu}9&Scf31mt{ixx<iG9AGhX%19E(O_qv_hR
ze)b{Fu2WrKaonlh*=wP7SmRg7?SPYS%|hZ>1lQ-MZQQE6{&=B8);Sfm9j*VE!m^cK
z9_*ddE4w4jR^>;+PY2Gbw5Fe(tSguva+s@0>+IcsH+c>Ncee;vYJ|$BbMHfC?tZy7
zD_O@<toG)@cYZ4Qt}-=w$5-Xvyz@YhOSI-({N2nIQpNj^m++SD)u^|<Y-%22?W6BB
zRg``G#rlfa{|T}!PaEc4xOZsEoC^(ple+W&{do03c5B_;c~u3x&$-L}%<eQeUfdv(
z`r+)%xjr%_cP6aWoc5sM(yJq>+C37U3o|S1ve)MsD9`wuWteIaaXv||IlISUl3CKf
zYJuK``)^#7i7!9<@pQMv%EUL;MmIczy7o373NQQhYF>B$optLDXc?wX+#|Fm{dUpH
z;yNd{qV!YqyH)N*Y0Fk#(-Qo>>6}(<kH-DA3!hx`{IFTF>Pw8(-On+1j&*(DZ;M%<
zai(OQTG+Isd>8z<Ub1i7yDm3*#`z7a)0bx+Hi%a@?|9?Ko@3FldYbN*NIs6`_i}6_
zZABY8`B%$k3uw>%CqLy~ujJ1?zt=77U3zj=rDe9<q`Jt@T?YD>`_0NvuG^{Y{dBhV
zl|3QWXPck?S@dja)#AzvuJ1GBrZhgA*%#e$%JI7E(*mu98&56uli4#Xy4CyZs)CtZ
zrQa@cwO{CGY>N`%>oVtJFL3(MQS^#UHQr-k>-xNa*DOL^<}WlpUYsaou*jygS*+PO
zNdAIVs95*4#+3J2vfCWj9=;#?`a}0tK5ssyX-oI3uBlvE?y<Hoc0u(9mmvE$8oQTf
znk|szkmg;yv`*8stVEl6eWl?7@#rfvPo@>F)E9L;ni#cY{t@Pdx6jw|f7u;7hcVIr
z+r`gsU(1?&x@Ge<NilL8>$^ER^WBb@UOyFS(bLxPsA<l}!^^a_oz`~yXY4l7P-QJv
zk<yUxs7(IHt5AB!G)jwmv&GMhXD?%S1c?1&(|hnGXUmuM22nST8AnOIIWg~|)*_c4
zv28O1EEXKeI-i%h(eH<M88>%|_J#x7n7m`{3y)tc*>u8-XL_IW)cX?aF7_z9G*_I`
z%wXSimGM+|=;ETyLB4mIYBxN%SiQ{lTu|ojLZhi){(ZOMs=Om3Z)#I&>l$pg$=7m@
zM~n+wsqgtDbECQ2+~R(59TU6$?c2GBZ0f64N_5D2Z<CPFU&Veey-?C-!)y)3uzdGB
zNh=+KYnDW5ah_gqc2bPPt4kB@HFqk!opy%Fz^ger$!)6P;>kk6{KsC(uJe9YDAU;H
z{~&nA59j0A3n$2No>(&1cay>jrMnR~l)lbotFsD@`7kpnt9h+1+XMl|T?h6q5SVkj
z^J#06E&pMrvW^So5+!q<HBRE55~0EHclW%Mdc#_$$4wKTemPyH`1)4lvooR7>=Gxq
z-Ry~--Fv3Xm?uMu<8tht$wz*wbv223U;g>(k8ypog`s$Y@;Y6Yua7q_SB~EO%rEi8
zevv2f6TE^L&er@_`den}HEH<_|KAzfqW|Z|cHQGYaMgP{Q+27H>!JLUcYj{`xv{Qo
zV?oo*0|wfaJ=Zf>Cii^SkJxeJa-@r(y}$7sfvlLa$wwAP87{Zx@d}->{HeO7;0Nid
zY6XF{Q!Y%ImXOM<SC^lfxmEVn&!+6y9w)g8rq_~WHijOxkGnQ;#aETZVV|_CT!qVK
zuj5nQ7_1R8Lu0G$vfQ=@D-H@R)KcHTe$FVVb9%SJPBrGW-tF5qZkqH>``Q$KhwizK
z(SgN&{3moA0wRK1a-MGSZq2lRza-ve>Qeqc7c`f8<>-b)MxNkYCYx|fcJ@o2b!=A*
z^*6Q5fAa3Z^`-A$JU+CK+pAYL+qh&?l*7h7(PmOoN^3WNY0tGO&OE#R<)Nj@3t5)$
zX14ZjZTjAM$=B+9{^qoaTuC<f7cuZ_R3}~5m}pXSf0mm<@AJAm>3fe_zFkW-OFW{}
z6Iv<kxFJNPWm?F_1daoL_DW=geT!(m_hN0SddQaJvkXqzNh)1`y54ZU{N(+A6qLeu
z?byht#s0eBe9q5r`t=iJo|xRIDw6cHpS<wm>|(}4#~d^I){C5tEZLZ@)z#@55P7#r
z&4PKuwA=rhGj&%ij4YO6eQxpR51Zb4`BlPa6|~D|URUB`T$t1PAZBeFuc~_F@;0N_
zGo#j={#MnnO0Vt0i<w4u=H%}z=$*l@D)}>Y$C2=8AJ)*%C1nB|)=50iQWaAw+~&4(
zLD|hUVcksXj<@?S^(>Fw>|A|tbF<I;hsush&lWqVxh$&q8Fc7k*@n%T$No6(j&WqX
zo2c1zIATRq*U^^+^Ot@)8M1h(bBv-)Z0rO64U23)ZDp<7w7fFAecx`0<rB8d(tpQg
z71oq^BreB(ZvMg>yJB}ebBaIQYO_P9QEd|MPxC@9-i0bE=Firu>NnZmo2wgLzHV~0
z$%+cagC-L@1kDtjw^|*Sj&nXL{pN4@nY|Che{$$dV7ZuZ;Ii@kx}`VIl`Y6Lttfu#
zxc@kN{`pA9JI7A%m}T#N=-RT?FQS$$_ckpHj(D9fXQ!=r``n)=WvPZgGG_F>($|eo
z3ux%NWL30rdfTLs#*=|rOD}P1tvTYI<=5nx^3X4!yzGzZT#x$P=?OVTLLp{JVbfmp
z{`k1LaJ!hEs<sxJErZRPh4++hvz|0-T`4frc9D)p%_-j9s%ANXyBQb%cjJi;_MJNA
zK-0Aiz0Y$^w6{w1-K>+l{d}**<Bf}&6IWc6d9KaW%dvy$SLOMe&W2$ODR&Y-`bKSe
zB#~d)R8W<t_`S_u;9k&*N>2lRjiwIs6sFD>^LCz|TzNeCM9QJM*mc*;$}eOaoV{b3
z?Ii4RHeo00^T4<}2b8{x+~~93cc9_X?CbG$ecFMZ4uPAJu4(R>vPjxr;lqlYrwbpg
z-1OF`!ZUOFMV6xMnf*`hirm{=^e=d#<UWIm5sSqpb5HU17ZAvpq8;G3Dnv;x&{JdK
zHJiOfD}Tg%SQK?>k#el^5$+Qe2bqpptV!uS7f~*8E6u<(e7o(vO+`1G%WpEhFVbK0
zFu%|z?|R4LBL|=8+oZme>B*e7EbQ9myED{s=0866&eh`R{AVYsERL6Lp0m*G-I}uA
zoz1ydU##S;xcc)5>rMIB>r7&g{;u1}X1P0h=F2^IcJ1QZ{z0f+)HfmG?OFW~6BoUf
zJ)-e?-$j`-)25u8@>(M)xNpl<FXhTDm(TDk@A!82*5RZ%&uo;}b{%`U<00G11Xe}S
zu6b`N5`~<nY}&)9=stZ$^-k_5if`pN{B*10I=P3NMW0Lmh*rS%gFA{v4zWc1VYsL$
z<8_*4U$?Hx+s!7gHNxB^Cb_a^wB)89Q7^IR^*JlX$0dIG#?M1f1=my-&+#dp7$);K
zkat7g^;vNTGKH&-=yWA|*B#R@SgB(W@lf?=OVCGt{b{HBZqLn}*<gJ*zU55XoIA&P
z|0D}uohjzIJn?r~+U1`3*+-ldXNKmm?lHN&a+NLbt20|-rZm_ndkdNQv%X@gnB^t0
zdlD<>!cS8&A5414)||R&>V+q=_wy3fnf63T{0L`}6LomRBqL<=@W}TQ#%fm$Q}XWw
zyc1eb@MHT8jgRk~7q2XTxw-BABHP}jyWihY4Oz(7aj9#&#QIs=CVYHVvQxc3VXEKd
znI7ub%KMlN?YV>`j&99&WN|M)tvCI7PW0Z+mC~+!O12(fmbkN3ylVfx=dz^5_5*s>
zaZkBB-%nhxayD;y!?FD5Vw(jyl042%a||u8jo$9Hi%mg!g4dRbUcAZvCl@#@ed*UA
zz$kTzF~h)Q%6d;r-ML9hJYS-xZT9SXn=>UirTTou6t1tw<Jnj9$9n6Y-#csXirqYu
zV`>-uPLDnIucxG$p-#-fIL(R0!EJ$exR}|Ku$BXNSQiF9VqKVWYvPe*wo#^fLJyc!
zCUpD@n)p`rVy^+$(a*mH^G(ivTBGe%cGNv+LB;ZEN4IARZaXis^uyB9vey+8o~+7g
ze|Khg>%nI^It!j0DU{swJbq`V^z!7rck+vUO?{c#Pllv+y*Jq-`ID`dchTR(^OGLk
zuKj*}!)19^(G5M1H><`UyZ`*penpQ(FO=Bd3o&?JZaydUmg%5}PSU+~YZd;<x@9^~
zOwe3!|8kvsp2mVVtO|MuIrRSS*~_B;<D$y7J;fI_zqD@Xzs`7z=U$8cwu?mtB5vWV
zK2m2@-kTPF+@z;J;f~I^o@akA9DJ#-aM#12q-AINpOr0p5}2AkzsqbY@?hmU)@>TH
z#cuuqL(8=0NmCy#s%AfwzsPjXrRuc}^EWXt%5(FlMs3`5?^LxsAM<OC9JQsPdh2$@
z&cAJZ@VCYf>%BMc3U1@w;I)N4Lz<geE$xF*+{)uOT-Nh*JniUYWAA!<u<`1rGg_q=
zCNsRL5aue*X0N-Z?z*?Mar=XNs&-%3akI*E>&3r&Fw1wE-w#gJUEX(gi|y4}c7ZYP
zedpxDUoYa~IUV;`D9CQQ>RTM*)8Q&ID|Uu<;1`?O&%7S8Bu{0#KWkzAhClOEdF$%g
zBpJV&{rPFy&f@8#c+fjo?qX@c!X&xRj+;zc_k3db68Q1Fu-hK-lZhd^!WSo<4L)iX
zH>>}=_$l>SoJVCnH8|&(oMt>0%B-pP=ziF*nCHi*8Cf0u^`=GpPeWU9rR8ezYp0?m
z^4F>y+!A%+#9xb^`R82@9&^^&9u;wTn&TBl?roFJFaP+c-mK+uboF$ziP^O(=O4d`
zyX)fpi}kcOo2b2%v7-;G+m4BGuit9vzR!I0+(z%+5uqECPnY#-Klc(}_s)vx|H|om
zT6~f%?Rx$*JWJU1<=j=x?{2cQJ3GBpqmJJ{nymZmm~<GEXr5-BL0m%|@4ZSRxdluU
zUc9q?;cd}#bhUkV%-?0L>ieQn6(fq<vwp4H=bg-VFrP*C;d!R*9DA1XX{>$k?jUaT
zYro)uI~z2(4#xcY_CM*5xO$YhI+pPfGc41oCI-etpOvsx`exsqV;^JV4Nr9MY?zj4
zK0EwgisdHJ0~?aoE<CWQu^_!FUE-s}#}iqP=ljQ=O>V1>*tX%om)O|Y*z)4$vvtBb
z`)ZdxFu$>)H|$n_$gYbMKPIm=zy0dw@$@<&6~}E89~Ip^QfhKK;OdUP1O9?$fBY`!
z%l<em`Dgw5d4Io#CYjy(;W=x?*{f$I#lm-=t$sgSK7P-xT|d6Ql0VPn`0IT*|HHrj
zKZ=dzwdLIdX8S%%-`FR(-z8sY=^u-bo?EMv?6-V-WaOjdzjA+UjGNWheR=ElzuKVx
zEl%#!rY&FZDg7$Ak-+ACaOYO8#A>Fkv3{{R*+TXn$7Y^qER(9P-21pUe#+5npZX?#
zU;MUDe0qaxaQW)pY`6TE$41YvI~$WH^)qnQog?=p{#;!+VX>(AsmWRO0zx8RS>N2b
zz3rU$yO+PpZhUiEd?P!rVDZ`16-M@KNzA&NH6F>XlYIM+AyvjOU`>wTGY^?pixwv@
zjh!=XSHkf{_sZ`mT$;0{@%6-+*Gg~BF@GqwAR+qyqe~gQ&s&q3Sf1YHoH5P1<c!LS
z?G_PExi=yir=Naz{Ew6Rz1W*itY7Zb{lzT6nJJ*-KcBhr&;{+!W%<!-q$B(yY7fZY
z{>{x<@Kn-2wQiQmfujeGXbGRoYLj}G^0do&MVqqzA0ZdVQyDRj=at*a?rE-bo!xw+
zRz}rLbz}ae3SsqQ;hZN=|Bi1y%g6Sxpl-&}+0nD21j8nFEr`pz*Ho~Mp|j!e)Sr(W
z5~?1p*060BWShTvp6QK0Oil`!603b>+U+`|gts+y+o;=hI4t-w=ZBWuO8y*Xov#mA
z1y0qs{P4H=EYDV;f6-S$@QHo%2P;Mi$pcJVr%E1nu{GQNT`+EKacxt~e~IJvee3!X
z_~+UlS#v-mQ>4C7p<noa`QeH)%ht{Ez2H_S@@nZ#la=45ux*|xVY+$hmH%v^7o3=j
z{^!T+VV2DeyqJ`{r9mxpxf$be?wRaT^La$Je^Nf@9kKViLf(=Cg-i06*xXq3^i}yb
z9qD@wUy2@WV9J(R>C^MCE6Lt4KE>*2n6MS+qUN>Brd^C{la8r;J%PDdM77G~z(n&B
zW{16xU8kPSeyLyeF6-^_g$zjr`RC@wvSu$?&a~U${{Ob+ceYfricPVeD0HLptww9F
zZosx1jDO4ToV$Lm*87R(>C>~9t<6Z2nlr;BW-jBz&-2`mMkPNtTfg&Cl+lK5KlIl+
zYAx|#J?&i=xKPn=V~T0w!Pj$Riav64tjzs?NO)$J<Q>DZ>pfM^Le?rM&E|JcQ(*se
z!_0&I#Z9xNXL2QS`eGcfZ*gL>u+*A%V0FQ%fNw`PZka!0+lAA7{1Y0lU6y=RSjY7F
zBGUt*cOr9gZZFJF>iHg(_W#c}-7_`C6Wg9hIq}bD(K5c|(CyhQzRqSLAHP81f;Syk
z_A+G37<{WZ6matB-IJ^4PWiem<#~H_z^gN{%RXH@>hy&3>bsRT8;|*={bCkLoOHx5
z`M-Bs%j_HHCm9@-T*+T&{pP`JAF}}MbL&6)&dE)i{D;3_MzO2>@w$XdzEc<uC1}b8
z^d>xIY<v*6dC8+Q;R{v@hAeXV%lI&CO%TJ0-muKVqipMc@Cv^UnY&;<$M?+&iN}LK
zhpCBpPrUKb;MbyT@dLF-rj{Qn=4ngdIdb~?<eCF_>eJ)bRxg(>@ORq$#qGIH=D8(P
z85jAQ`ENd{8R4{NmB!al8M_R>gBMmFSTi%2{fLG=$0B{cCv~&e98`1vWt_0a!o^`C
z57S-`ZF`pA|1u^>K4eRKC)WDw<;4T@y$&g~y)gLw$f3!X<Il=Rzu!MBKU^_MKjlEJ
zH?yZ=!#X#`exdc&&qS{!nLWJVysVWs{<N*km%~%oo+eptIq&)XkiyEm7q^}<?{c`}
zs>b;1zyh)3PD}XSy2>p2>||=YHfPo23%j@S{uJxDz&ri;L#Zp){eEVQ*SD4*-*<ES
z&yNm1&2A^-FaKXJ7_?&UN~YYa-;19w`0KUh#=eCyPAiUjwI<CtFk5?-@=yB<>GrY@
z*4XlI=x#nW$#3F!*I;Xf2Lh(fySFl}wsdXY#LRLeGcZp{<D-_ldJ&()qwo236}zSG
z_P1B}ISB16)qN*5&H9^xfML$H-Y?-B#MVo^-p<~=lQYlc?MWY#*X%+;K0YU2e7s_m
z@Z2|UO3Z2YLoFsBrg6A-_IJEvS3eV^{7Csy*c*xDP@bPV#A6ejs@GN?wv@eHQ5*f{
zdyUBB$g~v6Q#)TA2z0v7{<`n}2D?wvW+yC<M7zazeo$vRuH1OGW%bO@H@4hLG}*Od
z%g+t0a*FjY*ov)}Dtn)Q?0WpEVt)B1-@{J>n$zzv>XjAN1s?dHsMg!C=-l4pZGTm!
ziOFOyWBu-5H0|6|9oy-~uT(i3CoQ!o4f5HP>$2Ks^Qt{%_w>8Ux+^|&bX%Ugaov@F
z-&~W~*Y0({Kb6{?u5ajjwM1xYNqK1M!%y3Vyw<$p?kb5(oNJTeWw>ik@@t`@O84o#
zD=$R58%fwdnVeQq9kHX=Fl-^y(<z49zmoiW4l|xVbY1-e=Z-CRHy+4Hf7)}s@6U=E
ze2+8@OI}1exck3WnIs|F@$ue4zWaPf{BHb>lUa4(_!;l+Yb~qoo1(woyUbnBZB>`5
zyP7A}UQFZPAE6p|;S?D*=b6PDw{KnAec;%k^?Pi37dCHJ;MiTZP5YaOS7LWln#R*J
zo8CN~J%5Li)GQB2kDg5$5rr}xrbaDO)Z?uAf-O62zeq$s($3gX!L%y<U5<e9ROWsE
z6vRYJkMsWa<l|R&H{@4-e|O=64cZ<NSxgTNjkqq%@axm<`@Fy@Z&ypAqm7<!is;OA
zhDh_`34M(mYlK(dO-T``j`a9&ou$`f{odIN?{)E+XeFl~WXWJ}FFGEab5AtGWMkdi
zJ=Hl+c0apud#-fik`4DZoOHBU%%$XEys7YfldFMOukzEq&P^v;ZZFaa-^P}ecl*&S
zrsN#%!&&cDLiMadeoX6FGi`R9*jFjuQn5#?U9O&-_1e*jTXQ#aFvn}<tQ$9`ndR@a
z(#mNno4~1_<mh0ndC+#_RE0#=D!t~N2kgtW!`@9Vb+Pz#{qLrK&biNT&dI2nU8rSo
z$X0v#I|Iwhy5SvJJ=27|W-k4>*WHLIK;8BBl*3D|FdpLK2zgbw?O$C<_s%_$v$P(i
zPxu{rph{(x%S@-6w^k{>7kxFg!obznPyS0urTvzj(&=29B_Chi%5#l8e8BX?`P_|*
zH7eO=+qx``Wmx;<YTN2bq0QZIrkxI0IkC*sQRRT^?)Qow7T$r=*5-dsYFW0qLDoP*
zCVj8m{5v`4gYV6WFqoTq=($&f@q!o;i)mt}j9;zw-t2lbYtFhJV@nH<cP3>Uc3+8P
zblRPw(YW~kvm?Hp2ajdSb5*4^+qu~l#7taZzQ?JN@2awow)Ckf51abD_pRbQB%xFA
z{@~fuM=QBmy<bhXJo@j!v-A2h7EInfDac5C>-4S*oQ7{&F0?o`B)yt>gJpfngv8De
zqm#?eew*fz>N-92C;P{c60bY`M^%D7KFHb171af+N12qXC~cpqe5u1^k89-eNSEJN
z_Aa^=Gi9-~`_Jc6v3^>Q>~AZ~H9L_iX#Fu@W{9eZ%FKJaYV;2tn6V}LYG(iIP2~#8
zXBA@ZnoceK({g^@?wvL)#_rt~cB$*@rUrLRcHG9sZZKVT)x?YHiu2x1N=w$*_(V49
zV97bR<G~XbR~=uRdhz>H=3hJyXB)`fmp&B9;P;nz`keWytK}x?H@8;LY;ZmO#j1)?
z;L?3Lu1AxZ{iiQ3H<suOPPk%hZOvzS=gDd|CPV&RFV-mNdWuwqKiRaq_LkU|m%F-@
z85vKWdj61MOKizGUAM0q+ojTs-Q}-u3%Y4OC&<5d$<y8)e~kLMpM5b9?d_R7Lu<){
z6R%6RAM4b6mR{CS_-o~RzF6jCE3(yVe&6jr?U8vTs{OMxN2x+wz>2BWiype2W6e1%
zeZS!L)b;mIY`M#~xcb<}<c=vkyI9w+uoiKD_sHd<W(4Qk5`!kyF0;4nUKZMZr(e9(
zWJ^0EBz$8@3A3{Oq>Sy$ZnZFKI18V=>T*nVk<8E5ZyqZ(gl}^-J1yo=ew(*I^o@*z
ze{Q}z$4gBX&k3%{ac3)bZ?i1Q{T0L}rI*xk#`6(VtZ2cm_$!-UuVjm?eq*I@y?N?<
z!P6Rtj~G3f(8GAOui9hT)C<hken!77+`7b$&ze<J_G;0Td4+u(jT6qQ&t;r@sL94i
zX8P>5OF9mM3uZO^m^^cek*!6@nq~PKsR|$0CE9P0v^u$nVRea7K#1PKvdQIpy}xxg
zKDC&k%6VqXp7z#YzPuV~qv!l>n>%Lec2pi{x?rrxrk8#&TjQX?hj89y%KF{^BRQwt
zSbI3?oN?5HmCGLK$sV14-Ss^0zbhF}=X$!I>Mwax^fET?n>J^;?2noA_Ww9?Vo_7r
z`+)VIPjM}K;385Jf6G$&#`{I93gki$&Mlv`@j%OB`80LOlYVjrI~7D$9y_QL($e_i
z=+y_+)q87}9t}<CX6c)uS2bDoaZ$#O-8R*KRD1n8uUpG)oByWl!J3=Kex(KXoL5cx
zF2M55H(KCx=$??3mrFVv(sLV*+w=uKoV70Ln(>LVe+6Ut)=WNTlw~6oayRqL%W#Gj
zc8{<8UU|>*x1x5If%OwHsZTG;S)(@h-Cpx{fzmC$tYkmwS4a0fYnfg6&gA`Vt~wR=
z0Kcf*BL%J{=T$V#oaEN@oWF4;rRYf7H1)<~Mh}k5sfTs$U{SSK7kF3^vE<IX3B4C0
z6N6nneAbK4n6u~Mq)egWHc{_W%Zo(qmmKc)y<)Of>a+SrW6dOcYsXFTs>dhq;Fa|}
zo-67e^h)Qmo8#Qy2F%N!d=_1KB<AI#qijm|gzPsx_@T|pKJoq0t(IF(xs|E(m$_bS
zvHJ8lp#Glu5=WEoKF?NoeUiz#tgh80R=;m%hCSyZRo715m$SaEP=0jb=EE8D0w#EW
z*eRuP-&X0xh7z}`oK+uMzOa-Qlub4NIZNW>uS2!v1*>Krz7l?{M(*IGggjM2)qV5(
zw#V&WVDdqDs_oP4=%>rw{EsEDiY)lN<$Rg1$t*d;#|!36k!O4O=~z^?<>l@vXRqA+
zahLs$V!*`x`xM_YCHwt%{Q5>)BStw+U0vpwzPCx;vCC)YomDZqrgzDVZLj2o7uw>}
zSnUFSWwM7)K701{-CNhs&y=_Gjrm|&qojOX%Ia~tok@*6dvw0)5@W`kxh}6Qt-n|3
zt-JW;>d`Nu$EL}vpMClLa-v18{ogsaAI0ajSH=ZSv(xe4Q1K^9_SJK>;-kGnuU{Op
zn(G&5y}`}0&SLv?k%r%Qte)~8FUb-sWKU%&+dZww*kZ?@L%BV(PA;@j_%5qCtNeb>
z@^jZ69X?$ZEcbr&<hMA-ho?sIiv6X*RjjqLegO}D$Cl4{ZtoTlEzWxT+s{csQXV1?
za%Ue1FFd7k>EcU!jX&~Hs+rTV3<#KGTQFf_U<qDcO~m1eYo%`XJ=ylLcK@P8mJMt-
z0#zpM68e!?o6mH-uUv-t+poskmwdEWPrGGhV}0)Ya=oDA8D)PHcnp-f-Nn00#TOsG
zt7uj8Rj2JgWVM9n9Qlx>Lm?{<fBf_2dU~Q*YGC1n^Ivy$zs{Jpa9Lr4#+kzWANKF-
z-fr6;_vZi0vzzzV&79e6lsGN@<HKj)1jWpsK79V*^ZWRk%Hpr5&)Uy(ZTcc^{{Haq
z`yZaC<?WYu^O)%@D7Ml|aK4Z1CJQd*xrSQXW9v(ELxjFuUAi$`i(hWTe75QPq*p(V
zD1TebFvDg;?n&c#ldl_pRXpg^J-ttAfiU~StEJ17<enXjQVX^C^G=ITFZ}uk?hU!2
zpVs%xJ(JUaHe^?-ZvFA#(C;?u*WT;(Fi^<fV$pjpbj2bT4u^I|AH7)X5S!xCyvc2W
z@17kz_J_OK_VN?vFP{RQo_uK4cUZ}@;@-yDQ7R`R7^Sp?rB>*0@2hP5aDHAfe@5xj
zO%Jy3+MCSq=K%BezHLvJIzPSk%lFr-h^zY_p7Q#((f!Uh-Ns{$joWL>zwN%pC#Y7f
zVcx`j?BaShq3_K8d+bX;t={|R#DVD-KK{QRn8T30#Bqz=o<Fn9vi7CCx%2qn-78b>
z<nEp*o&O^*_2_K3sEWfsO53MuT4glKTcz;)oGAC}h=zEE3IFM<RzJ2>f8O}VPWDsE
z>}6T+wNxC$Sno4TZDiT>;`90awW=8vi+IipCNU|nm%L}~w@B!zl5|yiJHhG3HugkI
z<>#+7_?9*1NzbnMr1Rp~w0As;cXjLg@BTFEEs?yj_IC8c+BbKvKkkf9zkNsf--pi?
z3TvD71>Wjd=x*=+;N@{?)!n<x6PZ@o6g+2f*<!*FVj=hQ8v`H9UCRZn2d}Uk&N%+-
z#M__e76w0-T|R4PWZJz@qd*7awLAN3x>L?RSh9Rpey{s9nHKKZZhEO7qubWY?bEn&
zW_9k#h#i7L$vHWZN*6OflwOrfm6(xU`XYqyF3%3ZfZgls=Dw24T)kB>i9w)sR^7L0
zzu$SAU;UcD^Z2Ds-AmPqe*<z39hza<nZK^6_s_b?y!&{B)~=k~($B7NNvrZfDqGu(
zqQB8gvV$%h%y?CM*Tkl||InhA+WqT4{+@JV`kiey+NRg@JKk}|<({9@>+M%I<^C@F
zP+k9R)42_8G`6hz5<OY$uJw+~$|p9Q*mIZV#>5?yqFgO9U7lQtT&r~Bu7jnl_VH7P
z?v_~?HnenHt=$&zT`MSYj%Drt^|H+j*Nn9GJk8LGuB!YuH)YLxHo;@lb^nK5pU#)O
zNVVaV->>CS1|_RlZ(p^}|4=b&H?Py2bv=B_*L%tuPONC?)4D66{Os2qPuuc1M&12&
zg}of=8=WG=G%RzgJPs>eww!C$bx5S_QlgaldqppqrpE<)XP91l-c^!5txIBaSkwK5
z!pwZr?6oT!6aPJ%mwtF|c9*Y^o7VpWwyB-_mtW0q(mmYVzv5L)^HuRgV<Wrc>k3=4
z9dkE2x~nqUo$U|b$=Na`VZpA?l50)wJ4P`a{q$9q=c>iE96fXOi&{F1zA&?UDxaUE
z(^Hjby6`X;uhe15sfP`U-fv&6!kTOPGct_r+_c`m2V$S`2;MuIw|chcmjCB&wZvRB
zPz>MX9zK2c{razOJ{bF)Z7h7hOU~u(8SUh~pW+_cEKzk>@;3ToI>-KX<rdfPUGzHO
zeKmVinM#7|27#7&Z@C#B?lAI^;!^BRzRWU5(*4m-8-p!X>QUQDrE?>hrkB-qu-|xe
z^u<vw<3_a~5p^$KbLooeNBoLXe%Yz>Lue=G-^@D?mWON1zF(Lg#&uNZ9Z%!M=mO)@
zw%n>ws=?Y~CywZzN}K=M&^}Ge<d<_(YS*E&KU!p$MJ!HP5?JuK{#Q(|`o+UM3g1r7
zQC3@H`lj18=aE7G)pnLWA0`#AyZtNXf85Fb&vzerst4>_tDtay*{;=%8{cRYAJN(9
z%u;(HyqAYpc~!JnPHao(O^xfT8sl@<a_}2Yy%CVHIVQ5Fb&Wxvteiu5kF8<!yLX8q
z_k|{AR37=b?(UA~JhFP<YNp*k)3|@a-C1q2k4<NLIvj|eW^?M9{i*Ob(e^LT&VQJ7
z*=FJDqciwoWV^N`$=(Uo^@vfv@bJhv$vz9wX4@ihfgd-^?F;r-m2bM-(DJZxDSyY~
zH4GKYilx}(KRw`@_U`CC6^U45#nQlk1syWKY`0(if9G=D_2~s`Ux+q;|5~%{?y82x
zjGylaeqP};$CIUdGv}0=VDqmUiiUj~9>w~{tq6Ow`~4f0r1f&`t0oF2iayYMQh4Xg
zCk8=LY41gkELL|tzVWq)VOO~fqhRf&w?gx$MYz`N*Wiphe#_uo(t^b;%9~IB5Imo<
zV&>wSd5>y8G&+ks-l5NVuH(MTF)gEFm40WPeGFgu(o(KHJMsU~n>$7#d#|h#{9^ek
z@$%UT=0*BDChT1$`?vGW+Ruk}FQ}B;z-+wx9)r@Y13HBd)?c>Zi@T?na7RWf$ZLzN
zWJ1g<GreoePu<-fF^{WiYtF$yW2PA~s`^D7y9>l;t&U)1HMwNXKFvFQ`K1S@ced(O
zPqbj-xO2=?Q$jTCi^Z-FY8mYl!>60ZxK_=XHSysb!!C;thdGs6Z?3u3Qy|l~?lSN8
zO;e7WO?TW;X0v!AYyQ&iYd3a^S*#b!>C<c8ys+g+s%zJlBa2^2^mT<ts#r@XPf4A2
zIOs**o05Ykwf+?C(RVmm@*`11EZQh#nj(Ysd&URZ?;XEorV6Te6|_FqW4Kpk+QXc^
z>+PJlDQ9$l$7=~DhQ>|uTJZdUv(Dlvj4H2}O**bA_JJqw&KB0lBc99({}q-xNGMoJ
zq<-trUFrB|lY++KjSG+7=?@TL^K5$%U6!NFd3)9&BVl&?3z1o8lx<T#O>n=qC{yWs
zY?s=%mi62pcWrn&N#j`M%o`h2t&?RA-Lhufeb%vyBT|`9d+poT_p@$)V0l(>Mcwwm
zfvXSmQe(SP?yZe@5_NLv+CJf1tq1+9`XBFGc<fMfc;%M&2Uja`Rc-4qV2xEO>)3Ey
zO+PwVnEg)qGPQ3iCp#}|Z~MMx@87yNQV)2_7&BIf)y>LPH0i6Gw#1Q9?abTqLp%8H
zv>M$pW;D-PdG%P3_W!S$?nX^K)=gpz1t)Fg7bQN=@xGpPWkG0T)0G+8<)@e$x4wx#
zJ#Wqf=^ckxs%Je^PusYK_bJ=P^PGLE^R6x4=HaQlN7UqKnm|u+`T6qD!!AtQJwh~O
z?}YU_9Nnh*yvq5p#n;-Scg{6zk~*+Qr);6i;!hvt@|A^GZJYhhkLm4?>UoP@UR+GQ
ze5Lhq^WVr~o=xZ8zc<!?<LAZmC4%|JwWI#o>x0s7tz3~aRc+Y^_Ba1eD9f<Cw6qME
zs%Nm#=;%%kgVjkPKbm5U#MGU?+!nlR{8pJeAU1r?AGQZFyVA0xcOBYrx+s_bL{@C}
zBeS=2jTq*<@LLc#Dd3^Ril{%CVM{Nh`!#4L6@EFUz+bO0bEcGFft}fAk5iRLO(NYh
zUe0;iqG))5Va~0nh*{+hn@ZLO@Tc)5=PPQdYzZ!RY1sWCk8?HqcJ<}21lrF{JAXaA
zb#_tD=Nq+RdmYO-zb5itkGodT^vqEtMRn;MrB9-g8C{jfpQUELPnmu4=lMM0^?5GM
zhpxX1*%88YG3yoci^rE<<$K3ON~GR8tD<kq6}RoM$3KpL4RhpY>m566cDmrL!PMxC
zKZ5cze5||<hvYLoPt}u`;FxpHxKi*|g_Gi)okkZ*>IBZ*NDG{oV!ml_#QdEx4>-b@
z{F?1nYe!0L_VhR*WVHRm+uajyOh{Os)qbT=u>ItmEExyc_W_Zr3(e|;b~7cMIGKKM
zZ|vF?)8=q4@P4>_;jfHotoBB?t!yeLE?H*e=X)`b{og(7<>KAp-qS-SNfyq?Kgs&*
z=Z))0+f<z2Z~h&`vSX{Qc|>5rz5T_N|5FVkyabC4B~~-$?Vhx8T?+rVXB*ZT^xl>1
z_Eb8?nac1g&P(v{8l7!V1#X_aS5$i7sz$-t9kZD&th-N4b^0X9`#NT&*KD7iHDW#%
z;oIhVciw!}&RDkYU=(Lw#66Lx*FGoNv4nC97vAhut6x|X!peGd*AD%eT~!SG*Xit<
zWzRb`=Q6|kZ!Np#O}@gm^`{)K%B(9-xUR1GS@iZ&`-M$^c7FNhQGO_PTm4U~+~(S{
z8!^WinfS~^4V?UpbZ4p-7VJ+;4Z3;KXp-f8i8~?hCI`Iy;(RFWkk9WqmOoj$FWXEq
zIcea|dd>FQubKq4)u&bp7Dse9iu``TRkLo*irQ6a1!+Qm*sb(6wQ4qfTwPx~aV7JP
z+=X35HDw<^>t9^RVi6NEL-gjud1-U`)sFV$6jyAmIDatT?bBCb-l@$I;y;zo-+fXk
zaNN4(RLBg;`DecR8}y`nJ9f(UdV&V$8JC?*sn>4G&iigJmw41W_}I$)pI6z^mTchh
zxS8?hlQF+?>%lvsY=Tejl{2`72mPPCTzQ5j)BOWnd^w^o{youo&GpAD>Dr{rmu4~l
zIh#D|>)9oqGmfWK8%uHg**E)U-Opvye0a8pERphQ;uGFl*Ce!Pai3PtJFoR&OBZ_X
zajln~`J!{pj_ptLn&Lvf9PoM8^{VpF!<CVO2W!nW;*U?{d@Q2tCZzVmEwlCOO}TOd
zwqL4N|BMa#rb`^x`tPjq+$zM)w(;ZA-T#9P{++(3mzed(_3pc!F(pgR&fL6Q?N4nv
zyYY4V$Fed%=A|CGTYYlY8>2&RyBi`z7j|(gs_XwOlhVKZWBc1(qH+tmHkZ6#di8Qq
z`_q&ko%R~#{qn0Dmn_hicpfPs?fBK5$96@*G&`-OsRxxN9Y|^BS5DZpR6Xj+x@$7W
z7$-dUE;;djdx7*iq0>&AxIav_QvQ+g_i*Z)cLv1?`s!Tjk8_@K@$GR+nqyI%9lYWH
zxtzj!zCQ`qv_4cDZQj2!`O)lkyGr$sWL19O`bopN&ZS&=am=pck&A8kR!14UasTeX
z<NTyBU7GFcg1h>9%u<()*G;;A>&O)6Q_pk5Rm3lRjF?_zTVuXMJ?ut9*w^5zs~1`e
z7tN5h_4^w$_2i3%i<Dmq`8bA7+qLIv)1@1VUg>&Arsc{BzDd<i-p0N?Gb`u)w-lyF
zT0CLbuTS)nns;20<5g`OhiCk*5AhWxonKZS3)k3PDXqX8JK@{`b=LfbPxcocCJ8uM
zH}25zPcJrPv;MP-dp(E5)p)1c-v?%z%spFHTX6d4>q9XadGquXPyBtiSSfJL29<Tp
z=k8<*Y5$Dc@zX+L=YhQ0d(X_>edXZ(g%f?w7k_`oxsK7+DVXJX-+eEKj^F3?cWg`(
zY55_P!oQI5xcrw*su%4}9NPP%SNhEMvwL)HFPygg{@1|Z&BfnqPS~HFP@<Xl{Nse@
zovk+eJ1o}CjMsg0=ckq6l1pDEzENH=lP&M>mz(8x9=I>h+~pDLw0!*s#n6+ow^U0X
zO|%nQ6QaVg@Bh+U_p*$ZzfZZxzCk6jh*6?%*ZS2hw=!>>y|<G`N$t)|VV$eDr^eZ8
zv`F?m%sX`<-7wvC^%t|l%TzA5OP}!eslPabVXJuf<O$dLH?V4KS~-1-z@he8uNU-I
zyDXTpzKdg)-rpq_*}LbT{~d8isORyG^QHX!FRL_XD!mj|68N&6Ws!T=^*?MSbsLvX
zFPvvnTB0BBKl?<w+BCE1q=$BTYnwG18}{oLJ0EmhwS7)@5Qp-sbrUbBl!kg`B=r6Y
zy}QBpU}YZn>AU~0{Iv*`-<j)p{OWYKYe9Ee?l0HdIn#he{}Ri3E4i|r`OfdX@9x&W
zwQvpljvT#*OG46XE(uuk-Vzp`VX??Wr|$ZpmI>Db=iIm}ZuF!-ee>#7k7d>MIWP0X
zZo43I@>F=tZ|_7Q)%K%H{5J$lVKEeQFn0dNGjZZ`xqVz}p;wdsCJ3g_+pFGU8~y0B
z%$ehTvUZysXJ}h~KD_MAYG;|*+L^a+A9v)_2oGIh(RWBB=1}(BRyXk)j;VQj&-`aL
zDSzaNZ6wALbL)zcp&8L9HQ$Yl?7wqNu<m}mBMYNZcg3w*dBdIr-pFZx1gtMUJNb#(
z^vRnG5BaXk^r?0I-?N%u?(9p;Frg-ehy;%^^X}02@Y>L;-J9Ea((m6D_;FP7q{c!I
zfw_SPCoVCGw!QbKs#zrLM#{rYJ@Rj>^F+(H?~y;?5q<N6wO9PNN7IFW-oJCd=4a5y
z9?(h6H~;?f=>DzrJM-fs`EvdD`Stt$|6^lcx___z^6&Q_u8+6e|Iccbi$z&}QIp{0
zGy8sCK5wC&@U1!^UUI7Jom<Cyym_x%RU1#NY0b1UKH;IYHnl4)h(l%S2e-Rd`F*2H
zXCJ?<YMkY`!t}%G=~MjgA3PE8JN5f9^Rw0wr;jeu2oDW>_vdh8aM|olTls4)n$~T&
z_4eD+{b&ECmU@3pntZ)<XDx^E-$xrBg+^ZQ75_ZtaM9Ku(`%Q%`ST_J->0f-Z!!Ph
z=dxFSaEZ=hd35H>t8Gu;t-Sf}R7-4(!Ya1is}eY8Jj{PpbG_1ahO=sPk<)}HOy7DG
zl$n~|uc?x^;$}IXbaBnwP^Jx6SN#c=;BmVdojzroo2CKRUA?7863!)XhYIs{rgS9U
zTs=d*$6!OlSMIR0*SOw)%97sqX3fT5dsKU#yD}EM`DbvoB!Y>}JZxoi^X{+CuJ@ku
z=l+u@$(P<8ZLmKp%YIAVY=g=hA$hya<g^!QOfrjF9`Vy((AN22|4#nr*8eX|TfM33
z{W5OuNrv6#z7g9sxBtr%Fb}-UHGd_ibEv@Y^WygRvbOzDYBV*K(kx=kKKFuijeF^t
zM_>Ev6duURZF3Dczw+9agE=?Y*d-2239d^%Fh{)cuhYz<e~;~4!4x=oLFhe;>bs?t
z;p@JC6*rsqG3k2C%X9JOmH&UG{Cqn}=bC``?^}FQ8?xS?W#acpSi<qBq+q*J<3tCS
z?z+aSF4FnC{yx#V|Lgpgr^!Dv_J2Ot_^{*fIsbj{*zVouN@%O%zc{snZ=s;LGsAkJ
zTNy1^9aw`EYHW(xCY*m%86NdLY0B4KYiDoU(iX7sMreQN-0gL@1jUy+W~NS!+jqJ=
z^<n$_eS51PiZcanlb^S1)y+eGMSf!Iug8UoeH4pm{+Mt!Uig|rn?aCE3+toXn{IEv
zy@|uBY<AtFjc2w$yf)b^qjbfqTl~4R^^7jtzwz47_)qh@Mc~SbfjSRVs&^!7rPl~u
zowi}E9nX>X*7n?mm!?)ebZ4*H!f*RrzVpLn_SZ{9Emj80iuFnz&dIyKw9!uHhfa#Z
zu}4!6aL*G}P&>USp27P2!TZ(E+Gqd0eEG$+e@7<<T-d`RQEaIap2!gt;Bsb@h4HT(
zvG?mww&<EnVQi|n5xeS#_maapj7FUsET;Zn_VF<1r5cWB>zU?EeDQCV?oy|=voC6<
z79_I@np=E~K2xaV>b!K(jTpz2#~K&TUHqQDK&R7D>h%r9)umm^9EYCCIBTf5`>k(s
z{?%}=`Sja0@4uc)s(f=p%9ByDDCJ!8ykB!fJbJqKf73SUYmVv3d~x;e>~K!Q5T&dW
z9Geet-j=-7bv~#6TbHsM+wJ<Fs)~oQPN!=c3Nflq2`LujnlH5R^lQD;zO@D~kH|b?
z+}^hLXv_B92NYfS5?^=gZ8v+naf*ivOJ{7^jYAT}D;A0DW&50b;_(gU6Gu&#ri)Z9
zKB#DV_Ojmg?SEhGUuwkc8ZhUZcGiNMS-&5+{#%|iTfwADF>%?_)b#FECVej6$KwV2
z@;^npDcT<P?}}p3_WQAPhcv^9-#a$%sZsj3+`u`s&mi2`Olnf#q05c>6-T_hHU8F4
z+UsF<$*j%hUqs~Z+PzCO8`nPm)3PY|)ND<jOqZ;(Gm8y(`c{6idcg5)gYoAOI}MWw
zVP{@Ws8_KJbDOX7^}JiO>!jiXs{j2nUuW!RNhwbDv%C;oTyd-}c4ABOftEPI1Kwu^
z%#HJOCp~Qt{Bkp|=7{KFzdw>p;-?~tLLWF)_CGY^yOZnjY+uZb4|8fK9__BbQ9gZ@
zF5i;{Z23JFFH$C+kaW8h6RYC(-iXO9^YfkLMJb6V4VcrctvDXJ=yG_!Wp>Q5i7ZsL
zNzj~GEPwxM9=G??Nx!&ajIQS#O1-ChV1m8XhVp&ZjnnHspP&4A!jFvORi`30+H8IL
zd)3X|PsEaWJd_+ejW1{v^JTnXxXCfSUGr8vj}On&FCwcyr+dY$STS!(ZF*uNM?2fX
z(_ELosT@n(rYRiee4eYvJ*}=Ljy?0rjGM)$ouYc#b-pRSubz|p@Km%!QS>r(_wX`<
zIZX%eE-`IczAwG`_G4vT9kK7{Qf9op9jsrS@#6Q%<yP@iA4acpY<InCrg7!;jcNbi
zIh}r&+r2>Imb;m?k<I;8feoP_&);4Z7_EJwKj&&1tIwU)H}_>-TCI9ZU;%5brHRIm
zjV$jr&XW42Ini;Wi<H)*6VFyg$Gv;BV8hj-XE$o4#no4@=(YB%|NJ@2blU0o<wsm?
zuSsrL(0V~)UDK|~)BPQ}t9WiZL<f4ED!Db6QRVHtu5Q&|foB)+erWaje01h4;a4^D
zysj-j-Ik&{J42C2V@YOAiJbYViAIHs|JbB99cfYWa(?LUr!ZM>nV+W7`~7aN|7J{T
zQjuQ}yWB%s(zZr5RMnMxpO@Ez$Mu;Wo9>!dU3jSIk+5J^;DcR<)f?nJZYZBz-<_Nz
zAZpgfs4Y6<!G@Kuj4rANFlRsc@321hhw@&dFZ2G{h;)7R&D(sudb*R)Z-zIAcI>**
zbNRXX<7UGJH%$xuR=RP0KL6<K_3dn*nRN?heLRq_ab9*(*<-$d;HulR1+R(iQhw;4
zd%o0Z<77@=l|z0ZpPRQY<ueen{o(%gz0uR`oNK%`>pxn}t?rl@@McvHN2`RxKhB-)
z4F9t>-05nX^V@LdER7ctFX}f>^?GH#{vn4zE8DiJG~VY5U3X?U&g}0zY0-K`^4~-M
ztAB3qXYSc|SOiNe2IZnopVYkck_-hCV<Qq4n8xNm+4k{o-O)u3jFPt6OFTM58ts-`
zxA5&2xjwI%!Sk2G`%~Mhc3*P4bnN-J^X2<ite^V!$)sk+ZW+Gz!w(D6ES{`7d)F;@
zU(M2o`)|GQT{PL^YTe`|X6GiQY_{F=>tpDfDZxM8?52O#`lhVo?JCWn_02>2U;h<-
z=AWlI|Jujz|Mlk7P2Z&C=X3AH+@Duixc7FA{NJbX^W$UV|NQ=yzkZ6r-=klPYyJ!W
zV|wO&f4Zd48@2w=IwvRCPtTcituW1Gb6M!!xwk$&x}+tZ`T2PFX_M<0<4-4rZ{x|y
z`+565_qFoW+cDt_f4(|2dxh>hzSP=@KUV1fTD5ZL%iP;v&K^yDv?zCT`i1{Lie)qY
zF6gc8{(H*d{pz^_tLg%7O?&%ZBBu1u-qm$VC6bTWwEMZ){EsX5aCzu<$+Q%63ZJ_?
zMZHF3olS9S!mbGON+HqTwaqN@JF0GPxl`xxAoG6s@!FpYSH0iyvu#<}H}Mbu8=nUh
zpB9;~$>E%O`>6QzndcU-XZgCj{QbSS3hBMiw9YbGcLeC^m8$sYupX8T(7SPqQQl|a
zL`y@}gk>*(nObgn8pgpiukd2E)JH+>$dI=Z9o_w<%h(#W*_hOxJdhY<pgub)E;MIC
zXldX^*F`>&Z9m<E^H1MDsUdr~tM<A<%BDRx1g43f{@dEeBtBU*&2L%uuUUm!k`vfZ
zF8b8`<>t4ierZ?NaHievPzyiN8hUZzo9@_);xXAB+viM^UvXFbcXZ~2^(VCE7jyC+
ze_7|Cr@JC%Z}O8xv%j@D#mX!Rk?s4vYD(F>FuBt2XEXOF&)A@}_}bNe^_M#(>bJ=l
z-d=2>`upOdy^kO5-&eC$#M40N*bI-`GZk;w@CQi0J(YJmY?G?TBePxdX2K<}-)l2Y
zW;2-J$mV+Q>s!q=J-r@ZE*!Xh*yUr+nZ%s8jh^ohJZU_7+0xkhmhh4-n{pf8@oR-n
z>o#ApqQCYgqt9i7gxU2nXI7O(=G1OG86>JMDS7q%|Fve;87yZzecze$w^T7O&pWQ=
zxP8<8J<QzuoQ}+h(Efe0lVMkP>8tY@5tEzxJ?xv<c3YW#RJk?V!h16Bj#&|srw{E<
z4Zkp-+sJcMgnHWr;pBPJQWeH^6At`5;W_DW)Qg`dzP>CtELQ*UBacOTYJ<$eho@dA
zKDAwEBXv_;?0;%u<^xXE-)DBcG&z_1?PRCT&L3{IKL3k9N-uc$=X_kn<X;wowm+wG
z=Ns|<=x)7lrY={u@tuM<_r-Isc3tj^k1w8dX?^7T`I^t-eIGpa{a2W6E1op#$j+kK
zJ~wad&PhsSPk(e|`|Ope>V?{72NUP-O-YPT`=0uE#xuE+%k@P{`dt5~U#`%+5a0VW
z_<8c|o2|3Y6%|~TIGruNmvi6LM@2b{99Z|sWH~f4F`IW@W(YeSWhH7G@?ekRuT?v}
z>}D4HJ3hbOq*k=x_wPmgS5EGB&a6JhxRs&I)Z%&W#^-7>Il5YtSDb2j=(yhQ|0CIg
z(#~hUPn*a4hkV%j=JVtiPnj1z;At@V`o_|rv7VRtTk7?*bDLPSWf-IdF6OaM{9h%r
zsiep2xY_X)D!p4LD=+x9;7ZrK=nJkFCW&mnxp~$6ryGq|dr5mVJgS^plO^S^Rkx`2
zjqrCtlWQ`2dbi$P5_UXp(XM|VBi2b)N~?dfe7-NQm@Umd?%n=`efwE^mp^@1J16aB
zzH+%i)Pk?Z2Pap@@~>Ht@h0Tk%)NV7rd+-oQa(L(?`kg2r;1D1r7uq}PyKylR!ire
z9cs63-e_1Ju-{E$Kj*~dcOBR!UpVQ0;YVd!eB=5nN#CR`Zb}Fg&FW=;cIDv2H`^@U
zR-3d*rfHYBd=rS0TlII|M}F3u_k%ayw>Mg{rd#?{l*3M;8mr!=irftz52xt8WImv|
z<LTMk`7BQl*A~7y^2B-Xi{B4YXOtbkAA9q1r;S^F>Z1LQ^KT~T?b6-$cbB_D_~cs;
zvKDOddB>n(B6{MDzxWBSt^CDX=IDD~o^Uo%fjd!MHg!sq$dABXq3j2F53#5RZDha8
z&F8n4*W}mBhr31R<=uX!&~w`J@3u_-If+WsUN#%W&iwClXv4uYp<};d1Fy#JFPiZ0
zjaF&G=fJ<hAsPxfLS1`13fSHSslQaYm>we)8~eme<yViKQ0)zsPP>LhSI+ac9(tl8
zVdZJr$LP}D_mgFo=FCaU-tHD~=h^6aJKRFV`{+u=nw#Qp=eo##KI6ur7hx;Cu9W>k
z;k<69orh-_h|0um*>Sk`QOyM{hg)JoAEx;HotM3Mk;2tN{tF$uUoFo%zB@DZsEWU_
zoBR~REtPgB`I)3whRzY+v{U@6)11VFHCs|Ima3{sMFtCY%t@9%*TS@*G3d0b!O;yz
zixmEvs<CkLPmU_jEfkPjR=qsAr~0O8VnV-F=ZW@5&POxP9e#B$r+b%mNbGT|N21G?
zdU#n{cCBB(-%<U;tlKWn0<<#pe{L0JRp7tD`EJHnrbV)ARm-kloM2ii(JE#-ODuo>
zsSstc@@EHA)*M)?p?0Rlm(8Rw?#AXx>wM~_egAxNX5gnuOI!6{@JC7JUsLnxOc9^U
z_LiALbMJ+tI}6i0vNLZ*uw6WM=iJW-4Tg@}8Lt^0%-+A}sgo*ms43ga(CgFRER{TU
z(o^F@Si_;aHpyCS%|+7{63@)D_WI$d%24{~qs)uThFgxYGKN-#e|cILA7~|69safY
zrSjvY7IKWI40U+|Zl0cETwar;pfhv%5`M;sYdIK#wmxZmxL{fN(hZ;A)@~IqDePW7
zdxwSG_ktM5r;bXU)0$b*liRa?$7P+7owBP?absCRY`fBizq7m#=>O_-Q4};^7<u@Y
z*<XkItiKZG9Qe8TVBfZ>FHCR9?F{f(qoep`(%ds)UwUSLyx08mWti-_9UNiahoap7
zKjiHc_~%pR!@62pNhl*T@Ark@d^{2R#edjJ_<id%i-~ba3@^JHD_eE0y+O8BXy&p%
zYbTy``pqmYa^#M<?XM8UIL;ZOXBJ7gU1t_~ytOiZ@xuw+UCj}k>kg`Xn=ZuVuyx*y
zvIvD~rUzyx@ORa{*s)&W$b{QsJ6TRt7%t~NdG~ceY@tZQol`Bc%&vjPEPavRbykQ?
z$vdxe|CEoj-9EkTB?@ef+n4z2h;v95Wk0X}zgycx)vGvu>VYe}lq<DNG;)kXcX%^z
zxh=}QregMmb)k>vMx432zRK;TmQi=WqNAY?xA8EnnekS+`DUP5t^Yw$29G$e{vSe(
z8ntP&8FzCpyp=uc%hQ}|N-Gw85%|7II_rr4rmP6@D>r=S=v+&C{BW=2jV1Yk`&p_B
zb}%d6TjqP*`uN7z4qnUa3@^>fnC{GV`SiNtiIF>h2=|D(3NmJyPZg8o=dnDUbiCKa
zwY_kQxF{RP>*i<0%-2q{>m?*G&uU)O81a;AvzcyYlKzjcc?$wA-Br7~>cSpz^(%$7
zd#<*4{cL>nxZ30wkLCAWQBH1e)fm}?;!Hb*n$;{7513Cr(3e;m`7S{36knh8!8bbu
zXR<Ua6vc8lPBip8*&uxD*k5Hy;T(ytoYCjMoLq2!z12g_m<;c~DmFplt4@E&Klr*(
z_*8l7qWXG~%q>x>6~)t5D@5}|uH7_w>UmX<^O`QJqV)O%E7pB9U=^Ep+WCx|rNt4Q
z?Q@Q|7|p+NYt;mUx$n*gcjiiLUzr+kO;#^FHlbmP?R1s}J$4hj3wBDaZ#IxyB^z~3
zCHSx$yKC0_%w;S`Sx+C>uyENUwj(pom?<VrJi?gG@n~aE-3!O|mwP%aR2E$Cn9$Ye
zsPg6A4Xe%=0h_iNH!SY{TEQwHQKMS3QAxMpoUOyQUsg&dRp)8mo|LU|R%K6!$BU0g
zCUURYnRuWk$wN}_m*ek7mpJ1Zo4CZ>Q>v3^wuE;WY@g6^VVeECRokX~b2^c9NGv__
zgo#Jr&S|&hudrU*xwTb1f2x0fos^&7{N$&;XL9$P-JtSb{7Zqwnu`;ox2b1+d39US
z=(1VF^jyc;0w*`{I-A~`yKU(OvH4Rsd(C~}qOf>N&$)ZL{C9Z&-tc}_)bV18nUrbk
z%%99VCKi<*_YO!>aM|_J;n3y<N7$yH-u`O$)E^EfYApA?@G!End-U95zwM(bjkA~V
zY|_~lDOc2;A3ljI>gY8-i8-E*mlnORE93DtD*xu8@^O~B<wNeXA1sZnE^oYgI3j+1
z@#9MmHwCVE{4#omVmHtIPtF_PRvvB+x_*i4VMg$0S&lHz$K0HAGW~e#(`Pp~O;*{w
z(I`#unCFz!3z_2bnvJ|tWFD=_T%zmlHrwU>sk)rUJ`?AkyR_>@v_02frKL7p_kPFC
z(rHa#W$?dqJS}sLux(dH>c!-@mm5B$wX*cssm)P+@!Z{Je(cPjw_9$^N<3KhKT`6{
zQLFP}TxN?OCOu~p$`+Y)BehxQ-<CsqIqd6~|NJPbr1niOHse~2mRi`Y-jFF#;r0=a
z8<uRIkZ8aB=~;)>F{wAz>J%Tc2R$y%QtQ21aq!=imOI==-@KX1)(PI+;Boa+%Z<?g
zx{>*Ze->oSVlUeh&XcvEsC#eFXUnQta}J!C%-oamZi3Y@S)Yyk&!+6*H`BB{v0iJb
zu|eKHPgb+bC-1NCd5~=JSm)b~oE8~3kN5!d1Ck}Z&uu-=s(Q=!zCGGydeZ038G|bm
zb51I=r2V+N_O5yA#!bzWE>B`k4Ql$FsS@DB?s>;1mGM%%)*JQk*Z$duu6VxrYH+M9
z^zhk?)PD?uoJSr+m3;UdwIyp^^O`ep&0oaYKb9V~N#{QEL*s}4vi5h=Up>6DMD@!t
zZ-YZ^vwo)vtN)8kb=&@Dk(u%(m$_@VPM*P;U0k}&Y^jcgiOfyU_tG{z3UlPVoev9p
zt@P!)>}S6>?AP?Im+Y2LH8y9s^<qx<zNH<q>6UIs9XawunC|a*D9)F5dy#(jsj9^N
ztEMeb4c}1E?NBK9Be`SeqO+eg7T+!WCO*ID!)}4@%H@~i@^-5!>f5qP%sYOILn*Q<
zE9uFr{&~x$HRhFuUtL)F&gt4C(ZvUqo_^b@QMxN)%j(Sqc?M;siOdiBmPX69=<=~2
z-sf+S6mcSNn)0kOJ$acoJpG<)nkT1PtEr{0j7n}R*SF^Rz&m5&!#IZZpZJg0S|;zA
z{Y^?Q<>TEmHufK{Xg2O$`?cHr@;{r(r^~y!w|?Zj_*U8ZMTGfDjwt*1QxkkP*`@fd
zjsNQ3`LS@`j-Ac7_AM8<srtp~m6C7R;T0ymz2}#4zc1d`kd>08djIOF55c|*0uDV3
ze%!Q+Px-6j&oi?Ye6sMod&*dI_7kVVGp+_DPX&I?l7D}G`+U<bxjLU+pL&-Bru?2%
zQ`wUI>C>-M%ZffXI9Q}y5?l9SOEXKu@#YJ6@)Grfv$~~bJ-@f4-aoeO{%VGOW~Z0G
z==gYKb={tV1COWqhl@)$b?cb>&&k<xaK2nX%%)#LYRsG0oh{j!c<B0^hX+3Pxu4{I
zBVpiK>5%)(^?=@|LVhWYhrO-UKW)!#DV#Gw!ja{XXTPx=!_xaL3L@K{c9m6gFoo<h
zdz^PxS!JWy&7UIH7u{;UX9U~!yHDF_Jfm%q?AnVTj53OH&uO;L+-bS_a;}F&+x<l|
zJ~GAfT)dL_IrW3b0iJRd#qOrIJfF+|Yc_v9Iz#Tz5;lFKz%zeLRL*Jm-<!T&eV)=b
zv8!Lw)g;po8J~Oqso1mfbmz-P+x>1c6Q(xj+<jrQ;Ni0)Y_qdfcJ*w2HRY|;JRSp?
z&KSGevxdf=UixxfmjX|=-2dzFIVESs++CZZ@9bW4E3u*d_%g2|u@ANJ{NE!gY)j&K
zC)qu2PMjQa_sgu4t%j=#Dv!wf)P6kcYs)6fwRy&r1xut`XBHlmm(`e?{Dk-5L=KIQ
zr{ll=l^47GMik4CiKPkV#E*%wA<;{4d!=tqdJI~E>y-a6Bu(Vr@yE;dNL#PlH1|!2
z<x>@Y2|;B;?}=Re=l%BC)iy0S61h9Znnj9t!NnKSMLVqD9l9HT&-H`(9oO9!UEd=^
z-aXQ}`@C?E^_=^Ezu(=*(Y@i;$>)i8k5;x!4KfaO*r8vT`(yW-e+y3ASG@lJ^W)w5
zc49B}{Jy(Jy6iswTv|)+^<Des{D1%cJ$`(5zx@ASdLoPLZR&d8?LS!GRr&XCZquWZ
z@VBdN&P|-BbWb#J2mj<I&zbJl_iR-X<$Tmn_dY);bAH?I?$ZfL99y~*_H{QIo6UPC
z_ds94{h&f{^}o7z49nf;h_mgPGmCj$@uPP~c{U~eui5(YsKBH2Kgr9tYiKpS<X`OP
zaOL_ob5rJX&lah_e7{i8wee-jnu(&<m$z~=T(fn#xbKuv+VQJ5yHzZ{e7@BCa|Oe{
zJ6}0!6JMO>d?s*bi*ECuscv%Cf+zQ15|reO<dmIjbE7%8V$Z$%wkee|e>h~`@_oxH
zeE%VT&D<BJ7i~*z&c@H5crU>@xAxQ7D_?dv@pPa2&$al-U0a7ZDJ3m8zfyMNn|%Ki
z6-0{?Tk@=z-92Yx^3|Q&HnMq!)Z?FLEgs!!V3W4rdhP7v%)b{H?E8GvquACQWviIB
zEbv2x(dBC&u6as7iFb;AASgV?xbMh37Y^?!3=(tn#nWCZoN(^9V6go1R?hs#<>PB^
zeB?9Kl6fO8{(IA!iv2b62N@SzaNj$>C0&R$xVdJr^vS0F@=z&`&xJh;??(mSPJF@}
z#?|{=^LyvI|FW9XKFLY#ulds{U0_=?+t<CC@dYbm+7!t@H+NMq^shPoEr)gYWYcY~
ztZXhJY?qD(Nb)eR>Dg3mzkSn$7fj`9yI#agD=)8j$9}i`wb)scpXR!cB*g;{Y!_zr
z{VrcUV@Gb=@-(S4A5O*I-_`Rvvb|2?S+|dJqE^TZHxV;|jq<-<UMX>RTluy^Ldw$f
z?1sQ=Rc20;EPae)_}|L0w;g4e>7KMe<d5EOk)z$UN_NksC9ceiTs&h_BYVg4z$clW
z2e*kQ$ZBjps;tJ^kusB`$R|l?;h9M)3=DntMcIPti&jfZPl%jky5(ql^Ijjek|++*
zC_c8HO*(&V7&D`<-`@6p4f~poO1@=Db9T5MQ`K*Zx2yftsram-<zb+XtdZ1lbBW#)
zuMhWc@t2yj_T`JP!e>Xmu}sj_ziGIqa@yZLQ@PH!GWJAF7T5AP!ZSzl@Dc0(2Q1|y
z&U$sGu?DVQkUH5vWs;w$YPL{MC$HY2qvpx!8#F%eNoRF7_;e~aF<JGSkBd{8qYl%;
zj%HEreWKI*9MTws8(uG%)wk#F^^UkHLI=-G)%sDIXKgL9?ehkvnb8f>3nyg=Ht$vy
zFZrqvegDr7Pn8ol83m0B&NN?5cp&xs+~wAfN#~T6f0c{goxv{jFV1jxp^=SC5}QHX
z)wmGLl<&F5oDx}T=38s?4z9F$@*tzmP4>vvRd-g3edD@n-*En}*U3v7oX6Ul+r5$&
ztcsW!`=Tjtrw7}H4sVWqPleuH)fYLF!XPl!{_)IOKE0xEO==R0s+EEqqdWuxa?JYw
zu=G7$x>CJIVztX1pVoV?Yi4S0SP`VC%xRU~mbzoBuy%E8U1WJsZ)nzyiwB=vlat<%
z<R&ia`e3nI!P~zx*)6h?vKj8qR5J2+TlLx^`OdaGTjHA1U#WiatO)P9#Kt987PxEu
zrIK8px;G7nM0!r#*lx`2H*5M57Y^673mMEh6;C&Aj+|*P!{&J4!zm-Cld9)`&2RWH
zDZ^IwmPq80kcq4pbuQcd*m>~wAxVw86Q2tedHKI?u$ube@tw&@$0md%1V}7w?mQ6E
zFynsl2RA0}$FDSg8Q**(F=eY|(z1&Tk}nTlw?AMvvoVzUmW=5EmPuI*IUc1thP5(l
zTRDF1uxa10QTbUb-{~9O97iPHGrJzp<BC^(b3dQ+(Dp@nS;FGov#LIbIH~0+&%U&Q
zso%y>V(N*8yJ^LJ&ORdBetcqBxiXZIr~ks&L)+zePS{j9bU6qpO>$(KSG439bAjPs
z1&=i!#RZuTT>5(A?X=7dmDj$%_1GzK^h3(B5BnV7_B~*H$W*;^`mDcf_w!G<Fa5nL
z`^ys^Q=Z>n^_aPhO^&@ZVX!>Ru{ZXH`hzV~{S~}=&Sa%LRX;3fuXn|;Bj=69N#9j2
zF$!}s`GhxRJ>D`&bwTVeqfDd1sn;H5oHvtfYn^grX`tt$qX#c6yutB<`OL2AnzJU&
zc(_7)*O!#k%LxzEHaUMbUi2%Y?Xr(_oBO%XCo;t=%k+I14kUGUy!<=srwL=tg_+h|
zAzNNM_^5k7)@oR~dq(8(_n}wU8SZc>lzsFl?uq?`MYnxEB%Z#Jb!Rs7J>{c&a~@{@
zN-H^5eU0JVnhOhiUhufPIY@g5z5Wx@*4UG=jlrSM%^>8J-6Ng)1KD*>b7x4T*4WP1
zUE;|8&gkL##go+h<Tq;+E`L*F>|b|5ziHNIy_?aRM>~VOpIq9+ZMe%}vJYpvU=?S2
z+`De0_RxxN&wJ;XaDC5|)9lhw3twnxV^X(q^22N2zfF~v-&Zg%bJt>pMvaS&0jz0-
z`gwCNu6y}x-o*F6{qK8w&so2J=Zx5!;=X?!Bw0%y=(#Wc-JGhJsJW_kj#&1!zZc9s
z9OsB0wBL6>S()FiK&;@=Jn;~PYb<TkihMG@&rOxt5^Hke`N3yJa&IL68vWByl{Mg=
zQ=un(q&g_B^Ubu>RQW!uyfB?V9PENOWA<zcWe;56<S*kUbo29ph~sjTK5y63GH7pp
zVk8mjaMCm`AShnaS*G#nJeH4B(>J857Mu9GPZypl6&RlHdgbb>4-Im^{fv}m)GTmV
z{CJM)r#Vj!JeDZ<tn}V~&;Pc>zS|~}ENpxmbJQMfe95U`R&<Irms2*#PvW8Q(;sJ5
zjAy5C&2m@G-Z*KGB9H&G6Pr8sXTE!BT~f85tK)c6%aVmEN~{-u@a^DWQB1ycs#R*s
zONHL#^No30p|N*P)P#vCrJd!AxKVedcYf+6=~8azqtlJVr;AT#oxVa~$_Msqtao$M
zwHh7bUpn8Jo@R6M&%FJwT)CdR3UpQJNGtB1?YAvS;F!hQgnj=%bV~cLRaq;gd}IpS
z)$30-?VGk}y-AB4U%S-88+ALkoLzXZAW?ax`Mlrtw_omCuEe3bevZHEO<!HhOWfTS
zqO;p1KmVx~z3abXfz8+XpUw!pGhUE>z??bn-(UUr3FZQh|0S6e{y$5VzL_2t`>-V9
z2p`)kwl!@jdnH}=v_Jf6bn?!-hnJ+f3KzNVa(}n1$9QgAo!vYMvG)AuoGKBiq7jed
zgcdw6X1QC~u~5i6Z>1U2g*iW$hBGttY+EgR>(;ra6PErz<9ce6w?M<8-#V*KTyP7!
zTxGQ;NLX~^@jsi2DvaBwdqkd}aLZ`_HlqZsnF9MSX}HxTD!u>FYVbh3Hl6oYGVh<q
zUndGakSu=_C%dbs>HWEyLsGpanL@K)T$%c0UD*!3t$sZDDbAMCn^h{aA3eKiYSPEu
zDb@YphR(A!$pY+?T7P{?iapx&Z<SX6f=g#78f_CeWNmx8JSpVv%(pSOudM#TTK0O@
z|8pVIzRByh9}nvKd}5l&voul7X8kME%^&LMZu+Xh9Jpi7<hXVRt&HzJS=KW%a-aEV
z#%a8py|dQ5U^<h)Nkit&*bkzcIyTPScfxV;vfmZQw9Z92UI}LG3s+N!TK{cpe9w)3
zo$FT^qhxG##i#sS-w_=adQ#qW=_Pg9%W}UN=Nzc~JFS^f^`3XI_oR}k{S1G<?`rsQ
z?U-ujlY^5(a(@O{InRjy>h<I*_r4{(e+vz!3%h=9(7K%%<@z=7!`b}m7W?jxEzv$x
zqqA%lHXma+UNw>Ru>AfU&7SvsZ)0v>^%c8*X?pF~t<yJOu(>&7YgPM+$+yplhr4~9
zRv5NCr&Gdg?SG-^;)-+UW!=e9*y(=!*sYB$z9F5@w92~IUv&GNu9dcY(iO3XxjXl9
zh%<5PbQg&Jx?n6n%P-aXdKdS5?bosPvhC6Q`kTHLnl-xwT=V*QC+pFMr@~=|T>Dxa
z0}iaOkQ7?Q##beBJ>l`vgP*tG`6zc?Ve64ClS28ca?VW)-*s@;^d^JSDT_or1F~*5
z9$Juk-~5D^Ue44R;`e{-Sku`2%OO@n^3#J8zl}W(aU^_Bvpgw!@Nib>_G^d4&BQu8
zBa#lCDqq<-<<K<ChBnX6j-Eer94?8^dTkNDlI!ZN-M4-}o2B$!>G8asPL=<sykOWD
zvLm%k_qLGF*Xerg_hZa;7DO#?7WsN`-<+K4iNE}|YYD2(b}igex_@=t(q*L^HdiaJ
zPv5=HM|Vl}KZf3W244=}PCFNyCw95j<KFo+-DAxGOS}$hyKlO*#A8~4!}i~er~EE-
zu2YI;a1%LqfAhoH*3&Ne#AhbV(6XF$H?_`W`q4)_ez1yU%Dj#F&c8s`R8)MENAmi{
zkh*zu^iP^pomjMfw)J$qwwc^lB96OX{kltX<39^$Cl&tmAIy@EuFtggnfQmrO{-^N
znB4+J{-ufgZoRw4&2{JVqQrL`8{?<F%5dKLgtvC??&ozDQOk_i2|ca!(YOAzme=5q
zUePkf#y9VNU*wv!`osmEaQOw_U!L&f<K6b<9^cwq^E6E#-Pv$ym;QE^mQt_JSGJrz
zQdi-7^K0@!>7#u+w3uy`*q3uGoP1iLKO-QlIDBTm#4a9b=`Tw}c6>a=^I5psEwszq
z)?c&gabJjm)5E@Z3l}wiKa@6WZ{2~ToxiSFRH<uTOga4VTr^K$smJ8mv$PK$nUOGA
zZr!AUjT<s!bbXq3>mJCcIpV@PzffTEeW?{kT)6{Qv~Rxf#AJ%0;0>Q!lh)?FlWeRw
z|7CBbh?B<M`D-$MY;O4^9d={=mkE=0T=MbPZ`(S>-)!CFz?a)rOpE&U^qR)0Z;{Vl
zt(|MTEn4(?O}r}K%lJewuAqmCs=qg#xZ@<fI_3AO6?<Hj7Kna%-T#BLIU+5@`o<a$
zuYZ+~?N(_;SoRmq6?=8Bvwg<<<OQzN&Q0n)d%AX(+iv!J&9%W7rT^)sPs))OefmDp
z=cBd6<bQ0*r%dDjWS3pF6E)U*>@6@gOOP`=(`{A7zB4D+pWMUBYsa$Xn*QO&7M^Q0
zY1ajpKeW?&y!w#f?^Ww9ZUi4bs$bi4_}W@loy!jFnw>}6xVIKuDVtMs!O6CME?@HT
z|1bH!{$=r~`^l1^r!D*J;JwWUb5qRk&YRy+=$(+D{$-ogHi4b_RY7&X)_&0Zv)Sfu
zaUi?H?WvEwyf0)tpZ0noW96DQ!QZYqY392Qxj2<wEm`fGu_6EYQ$hA?_ir$C8)Tli
zX~@%~{x{R@Y0!FJ<LvX(Cm-Bi-KBNMIqBKG$jwi7IcYiaS_Ri8XC5>5zphz(oU>A@
zXU3lA?Z-}k{1RRv`RiJGxX0nSF^zH)e)P=zJbyyc#p<B2O@HsL%BeWNzq3QOeWnZF
zj>dhLpL_i?QuWj-eG&eXSB~#wY~Y#fT~FtJHLpt$6rUgwDR4KcPU1z~#2b-owZtXG
z>$!D}6^?LE*l;>wuVB-O@JZ6<db8v9UwpLS_t)4tCxhja9`#>ZvU2runY9X%(HBoG
z%Sw26>-^;Z&5Ri<{vX=LZTs@+{gOYInSDan?EN*DF-G&os`)#LAAdOPCGz!Ajm@)o
z=Eb`wHNIQDUvt8Ioi)ZKAybt2>NfE1PyQ+V<R#DSd)kMt>2tDI+8&y}$h>{0Y4bj}
z-W8W7Yi!+PVt@A2t1Bmp&mZLb!5sDSgnriB>7MuZ_=Sa8OE?<Eq#p_^|GRJNABMF>
z)(h5@x?9JvoqQd+A#=B}x|r-r<Ns`lo&}F~+-eVGl{2|Lz2JGty&b#$-RJqozxw}+
z7ntKECI%K*#!C#142a#bd{+AAq&wR{XPD(b3(L$9V$fgyX@gx#cu<#U_UboXZ`t4R
zl(${u(VQ&fIeWc-JcFZNn6`SI$I2{DlXZDt?n<c6KCE`L=C@Ak{*!8VSA-mmjLHj1
zdla+s?7Kg2zNZ&X6!F|T@qF3Mqo8xlE=M>BP2XYuXKwlZTW`1D`xk%D=Jy}hM6**z
zTqBpvp1qqr;?5g$d-wSN1%Dqsdv$&Gep_#rm-%^iZQt!5&Y!#UpIz?+quE;Pil!>t
zwcZlR6jI-n5OOarH&oK}tU+Av)@y<GAHp9Tj<uh2``v*9nJel&FV(c$3SW(_-6en9
zaNjMd<VEu9y<|;o3a^(Z@6KnNXCWJX^Y66sw^BEb`S85{m3O-*`Eu;R3s<hG$CXrX
zeEin0Y;KjD)isN+vi~xZ_8dDOpK?^q_p#P#5uup}R7DEoB$pZXU%hJP8!A?NeU9G_
z&xx+<*Of?Jwf^(_nb+zSGbR2#T6O7Sfc&`zfrjN(S-<=EBV$zNOq{k+PuuSCuOk`L
zHe_x;?j}@w^S)8aed7hM)!BNES7k_q89%vkr6ykWQS+3$pMTt5_?Fe~q}jd5g52sf
z{sYSwJA5o_4?MTY<Z+yXeh%+%aR>bmy4uAGJ4_~8H$}3pUAWR+Va~O^>Mb9HI&yYp
zs8xrTJB7$y6?bshv19e}wuMb0Y9f6+Z{Od^u>P>)uyOpulZVR>2{ZVHJ6N3G)8n+)
znj?(=?Cx#*dzM$n?aV)R_d?f;x2)GMFO<LavZBv9WbeDcC6iaYJ;u4Aj&HBc_U#VJ
z$<=k;zmu!=H@{Tc5a=IVT-PldD|ngX$AdBfEtlkCwOuNU1l7vf=4cf$*Vxxy(kc%v
zxF)gaecp@n2Bs$;$obv*@Rs3Qs%4kT*~k3%zO8)tZQsZ9iKYu1Z*!lRpT~B<>int~
zZ7#1ShZUUnv%h-y;Gt#7zQw(Vmo!Eyuq~R?cW90#kDRO63B~r+LBiq3bo8IMJy|h}
zb<-*NJ4T1TDYWuFDq!ce;;}x>tUcfC&BU^Uk2czt=&sV#5Ll~_*vh$}RM-Dp<bB3(
zU%#*4d2oBf+Nf=ehhO?}UF>nma}KHUSrsBz+j;F;h?-ROzj;+xv~#X1*B^bAQ0#uD
z;n>27saw}<`^1>5z2w4@*V;CUYcFW>{C!$5rO!vDyR+AO`|I|HpTyRcEvi0xo6Yu2
z$us3o`&56nimfUa+!pv%ci|LGJ2hwR>m@udUvBc){5sM8(+58OH|Nt^;;dG$HTWQ>
z)Ar^_8F!=Yq;LBk_m$30u(~)=@x(`t>#d;-Y&N0|rb*Wd9Aun3)-82yTpRE>MCdO^
z#<wSS+N{So_Ggwbo!q4Gujl*oVq@O7eY>x{ZV-2Go<8BA_KC&ej}9e>MOSBZ*xGJA
zYrV0X<EgcBswLMF`IMaFhgQq1U$ObUb*698k)3mIG2g3fNDE_i5X@Qg;)zCsbMLb#
zt3RC4jhD7F-Cpy_N&LqdIbUY!Sx4*s^*Ubve7WM<g-^b3BoDZWMJrsLFF0+1LdQ|P
zl#Tb|^8C+mDfhjfXT8@{w)*rNPWvSNCwk?kkG<TQdVP*1-HrFFzQ-}=QRm%Hi+9UL
z_o#LJ70uzb<`#PXi`P0T#>%iKbuar%HCE>fb6uxJ=IYE|^Nyc~)sMZx+H`SC&4K3H
z-RUuk_lm<8-<{j<e=|SWMW^+_!&&bf7SyD6%q!-QOBZqCmv~hCxjlb=Zr#0CI-PM_
z+D|KV2XE!L`A}nr#vGULyzG7HMawO=zr3+SQDV)vBLTZC8%h=#GncnN`|fRRqU>L#
zut_4`S>p3Au3TQ-2M2_tR!lun=g7eNJ+S+IOC*!(<D+x9Bh7>|UM0Aszp2_Aah`Fm
z`Hp>mFWG!q)YBu=wNU5qi35|f(#+bfaVP3+<z3pl)wy4~Zmyb-Kux-;=#N0DK9P*`
z;f%6n=fA&E^iXtrQsuQTPkptd=N-1Ws%8><MGk+TCvYdRYje89#qTrEYzcJR)%SG5
z+g$>MZ5M@a=Vwg)vs3lVGB-0OzLqJkG)`W=#qRwowOIR{yTeVk3w!_F`8Rt)Yh&P~
zb*A=jr|J1j7wMO2-NtjM_3z6oUK?6!%NAKIT{(9#Lk0hewnLk01gEK9wEtB$<(Yr|
zbNv?AYLAuoEZn#Fl^%O8WYcG3)iwWKAdlOUuy0O#gHuF*+no-{h|yu%`epaG@7)b$
ze~-4E+cd}c=BcH^pXK^rt=i6+wv=nqU7pF)xDBO$Ey?@fyTtqQB@NfLCxttA7N)RQ
z-bo3+`iF5Q%UO%hLS{D^zP{zVUB$4gC35YO;u<~6!iP_fSY0-}8rab>Kc(&7lfuv!
zLg`aBo|<s&#*HU7yicyB&JnA6?E7en)Px@k1+RUT{m8%(!Br-(e(kx{7T(=YRqLhd
zv>N7j`o{hIG10T&Devo^$(Nq?Nd3vYK4F2X>c@k8*TP;TuzhB7vpL%!XDGdIfkN4R
z(Thg+K3|{Z^6E#<)6d$gn>;PO*WJBrex6~o7?appC5<ae!4XZNF$Z+@^rn{{eeq)Z
zX^pk)k$Y$A3Yds1<?#gberS<gAl%Qm@?ycy)~Q?W*Kr$Yb{pru>1p|%WZC2<bt7c;
zjx$##SEuFqZ@JLgxzGLZ*Li1ItqOKTpX527=DYLhG{<%}<ER;@44XTpx@DHwen~xj
za@Pyx^D6~4HSgC)9%0k2w_~;uJf&^6?uO1mF2fF6W`>+8e++6{9qogTRd6Ujt>btx
z!^<Z|?5Da`{kOoU<}Z)U-m=5iWzw0QdR*R4qH`ZeWovQx^pu?}xbON%_s+)^(e2mf
z3z@dW)qk$~{We^`^2t+Ey}w@TdRA*hFTE5Y`tp)ttXp`<B8B}kv;%XFaT`8nC@?xF
z9LV1(Tl{kshl{7>YR<Is2YyGkO_%sq85+E<?4Vu7hwB|@t}twwb}RC1Y}t<@zNPu;
zM<Ru~6Q2G2cf;!8sU<5I<EKxSed)&FB&K;fLW0}+zPYDHxToqp*<)!wn|p*WM3p_C
zTdgwFzx1An)sdS%pZNZ~TgLrS^j4okhBedNsWKG_sk@B5ik%Eqe>v+&_H;|-KkC{%
zL2h618;>T%lB8g!@Xfkf9!x9VT=?OcA|%ju<mQ<mBmN&|@(l^qOA7v;Ji4xDj!RhI
zympVWL_xRapzl|rIGv@+Tt2xiSoEzgJ!oBXZ6~+l@rRf8sr<U7ro>R-<G*-@;`Mhs
zzJ>7fG++6B;^3EgjGHSQ+^-0T-DQ0{`C39p+Vqe2t^X_Oc|EoM&wg$0iUaBs-&cjl
zeloIKbei>ETyCxR$H~_g?(xlh9=_r4`s?fC6TK}NwOtN;<0<3h^?8<LKJ8LpdYcEs
zf+^jaQ{txeUOc1~nBc0YEccPG{O0LD?O)Yz-Z^HofiGFk&C`C;*ZF%l$WGEaw{4}J
z#+9VKg@Sy^nuj+pj?hiH=iKcr?_tEv-ns5TRP^Kr{ahXlQWbOaO6DwYnrFl)*wEnq
zoa=|_`E1sM&8~uL&NcdMJ2mIJib+oGu`~WU5hqKgGZ^o_yjS_my|x}tF%AV?J5Oe@
z)~H`9_uq$hsyx5;lsVyBHN)J$ay@6hiC>;wxHa#a=+#?00~=;oK2K}DdFtk3tq*I0
zBhQOnxNg+%J^8<3?bU-7OitU5UzvKC)9tAL=NDPNOo3_Jy0R@huFvs#S<<&)YgI<U
z)>*|lN2C7Fxm_Kn++P)S_E^E3Htve`j>kI7|5>cC%Q&X}?#x!MnnQmSJgq$LeZIQt
z=#jGX)x|&ObXZoN?1;G19}<?fXzPc_?0r7^ORryC_;OZb&L!u6%QD%f|5pDX{-*Hj
z5=%ZCq5R;v$8P>w8gbhD<LbsPqe&U*?|$#P8O!z|*P!J8m(?3|bsjq_ghqU*e0QO^
z@V?5sLV^31M-El>_sFPTP<|BXkn{cda>tui37s#`Uffr7s`%N7%bkJp4^B*TewHfG
zX{;w(@b$up)13#ojwkmERET(;+t=1}Bys&J*F9~<=LFVWW0#zB`umS<oDJ`PNT$Bj
z;+^`3EmG+S!@cyjH<nTk+U>?a|B6a|dd!sb>FB{bg-n-2`K#IbzfXEmGr{>?#k8Xz
zC&xu6cya|!Xi?$acj?*EwR;~3EDtGg{t}aW>89x=jn+jOXE(a@ZJTqGf3mxvY2UsA
zq2k6_ruE-+m!~&LGRy1b*xhJf`EAb(t@o=mqq`1lK2no!rJW|1r2gVR<GZ|;-Hn?K
zU-)nSc~f=s(O+@%L|9I|bXLqW*v!dmQp1)s|MCB(o=;NeIrm(v$UDxSfArAJK&G3<
znydQirWx7qXM3=@!Q^G6f>-xf;{)p>UK~Db=y+WA+L<f--Y<=cw^yX4EM(e{x@GGF
z4&`-T)z?(#JiP3FxKaE6i|FI8oYtjpZVa<A&2D<k`rxy;>rSJ_&^bHqTV2er-4*s^
zvB9UlO-6GnCDW&FyZ2zaig%oqT$ANK$H2%7ofodp2^D(2;s0?<c6LwRBuD32QwxK3
zy}CH-UTDq4kabxlXFJY(TK-A2zTk$ZOll3!;spZA?@r&I+~Bcd>i1;P=(Y=LdY`gR
zZi%0y;=I*s@%~5Z3$0TwdF?;7bXCMoofo&4aqoO)6Si{p=jjL3)Yw*Ms@Gh88+UDY
z!YNj{eKlF~<rl7>)f35nZusGZaE}RJ4$HxoS<Odh>TF&SaCCFa#9loW_M>gw6E-L}
za%+byOy{%VpPQ@o;fL!7t20WAdM_*0iZo7WWhl7(w(a-!&;6DrN3<hnu3as}XJ2>r
z<u^u`;s{G|3;CUS3zi1hO^REVcVLBe&K<`q0`qnEXKoZe^Q%4VHq(Z<P%YK#?sFCE
zGv`kat7=xeaJ_tuVUN%a-BR;|+f)<FTlZg-VEbe8Bi+2UVsY|QIlUZCXQk-F`zL*h
zpU-?~o_gV`xh(rQuS{2*bGAEjg0F}5#wqLU^^SSJb<y1(dZk9tdisMyds((}Put9U
z?d{&k6#m+CQrV}QOr{G|TeI4;PhNk>BF6dD=1|Uvx@P-m-$#pdu5WsIS!LM)eTDs;
z`_6@Qe&RmSAK@fBy_GX-ZT$*~jsG8BSnB(QzxK^Bulsily+Z<<68Wdxy=-yO@5cG~
znlr|S)hg#apH(#P(%&U%4;P549Lm%<drDDuea*_<bs6hLR$LDkx#)0)E%3d}l?Ny0
zznHt)V(!|%?t6<FmENW8n!t21a+Y{YN9D%#=IK6*98-^OHDZ79xx-<pBuB=|fAi;L
z|8$?bI>fF>c)3C9%M^>One`uBGkZ^koG4YSNOwIroq3(W<LPI#b=^O&GU}S0|N8c~
zD@DhqJSwwsm8<ptetV^@`KBCwzw|Zj*KRF;+8x){7-Y$wzVH>}rRO{%A9jC|`@oi`
zkaxDdY>v)eo>#LDue9B={YP86_KwO2x?kR1diyMXqJFM`+o^9Acl2epub6rH@zMVm
zSr$fpJ{&GpdvO0ehVG~rp%p)}epsq(40*8WI&;jF$J+bVW?gVzmCvxAxy-1)G<5Be
z!oaf^3k>JoW}3<+A<1F4%0A2W@VvEA5*J&4E!)qQ!g|`_^Su2k+dk~xqraouq`oPB
zLCDlNix>8-P3qr%JW38L;GSo-)?vQlFa5QXub%w1f59L2r^URnSOyx54KW8AjLl38
zi5+No8y($$XPao<_w_TFYG=6G^1NS?#Bx-uvzaCL)sb$o6>r%q!*;JubK5-4q)_bV
zXWKm<N~TlNuEoXA5@XX@>oT#u{rRW4rym^s%A~)q*5yI{9tCbM4Ivl(6%Rauc17gN
z@2zYR3A2d)aa!x&<(hQ&!s^qz*(EZK&Hvb++4pK$JnQHGPaj<r_ZN*1=$jIjQdn5(
zaP;WYM@K)so_}tB+?>6;e*6>s=2Bm5=>EO`!+L4UefuOmlw@w}?|h<h`PpId^&cJy
z#ntg&S?!~H@7BU-iG>e$McVMI*(Ih|O<d>`lxeo?1ye<v$mKl$=d)kO#%?pey;<~f
zjpvS=_r?7+`S&06@M2tjLtihCOXBp6O`6xzwKv_FKQT2|{^Qea8MFS}+MoY=Pu8~7
z%Tsor+N)Q$*ETwEtInD7Qcn52v$2751NY|0?_O%kH*MJr1)YrT-+u1f`;jG$yVGbl
zuQ3<rvBt?A>390S98NLtQJR)|H^l!BgBVYON8nZ7iq4H52Fz-KH<cn@s*2s{4?bwo
zw&l^?n9wApM84he-U7$Bh{x?qaR0E$Ed5Ph{jYC=JStj~>?=NH=}c%&xw)Aw^2C#f
z6%snO>LGVcHSLX(J+z)`{9m{0?)G>$lO9RMhb)^rgxOy=TsWk$pxBk;R7**6eOXNM
zLWc~O)B+b7^%gb}$BlVsw!3!ybW!qZs$@~)Y`o~fth*sv>G`>d%>rwi0>7CA-<By%
zQ|*y3+@JZ-E>7KStw5O7Et8Ci?^0qWM~E&FQ#^Y=<n{iibzxd!$Bqf4wHGbfy3xMC
z&gxOc5)m201-cR<95rH^{E9XKa+79sE2*Wbd};q<vShNMz5S(+E{pbETA*Rn-T!>O
z>+FEC2UhBTkJb5b$~daLW_@QWvmmaltjJ)+F{y3u`tMHN{cLvc?#j*juQp`}J#yUO
zFyot0{k*t&tL7cp^YdoJoky2uJ}rA5rg8h&`q<~MeG4aX2(Jrp%Q&+nx66a+Ugv%H
z;{AHpI-S*z%@Ig{?W(i&VVmO_!&sJPKf}wfpSbi~*m%OPt0$$SP_p>(``_PY^gd~@
zX?r{~CH{SLYE!_Sy??Ycl|EGNKQRBYP*e5KGpkRttoLBs*UuNilyu_KYS(mM;o#Jc
z$2ym$dy1>AWO|nJy)@DDx~kC(?$>_%;*t)n-c<U-#czT9O2NxIC8FnNCDn6U1;xJO
z5$=ew+x#jd|7`00XLW9i?j4;w`GA4j7h%3BJar7ctX=MTLX+<?Pum~yNy~k;v3bGe
zh&NmBG5;}s|NhS9+k4KvwY#;*?<50j^Qle2jc1c*OnH?0?payb^L5*8(=5|Dm9N?Q
zt>t!@z~}HGlWQ4MnA+h(1_>J<1u2|z)4S%eee>FL|L$Jfef_|<Kczc0XK#!7y?olH
zyU+OI)~-pEV_5zB&!wJq>%ONJ2Ve0GN<8pzV_f!rKY_Iq7brcMHuE~?vg23wR-e$X
zw-gpyv3>dDL^Ja~rHw|0a+<TFB`p?J<_lTLKd`+#o%3gOAY0b#nc6~kj=MZ}2sw0K
z_;jhX|IWhH(w)23<_ojQ>W38+xs*(4ieRvapXj6FFWI2PXt_XR@vnu9I~YSftCuC5
zt$VXSI7HF(z@_xB-B%_W9N~9SY%@Oe$T;aiq{b7)3}G{wO*4GYCY$Z#U^|;&_N{M*
zuix3vOBP47mt;?nVS3yXQL?&J<YGpBPJ^e)!G@_WcN&ZuRm3mLF#Js4P{|eLV6T?L
z+m|o5jg2`yA=@Taf6+ImI8_(XIjJ1sRdSzC{7jo9D;_rQu6NY>Nktl|BB`|rl5hAw
zoeXtiQ|w`Snaq(~8p8H8g6*+Q<F#8yL=O7=7e164uvO-^qv@vRsyRuV)7j2&JTNfM
z)cRmQ)BIun!A7x_FB7bp{r0%qDSRtQ4EcEch>B2-=X#Uyml;mqFDO0DIm2MJJ)ciU
z{`S_6wv4vdM^0Kv^||bp(mb~~<GYAP{Ztd7kgw5tvpEd5eyuBhKJSZ$#Jk`KK1&%l
zgBf+sksXK6F-~l<kC57-d_8qOTTI|Vwlyns!j{z4J$)9wIYO|YORC|MNElDR^vDZu
zChoGG<$d|u?pL?;Wf=cy2Az@KrL+D{$LiR(&y5-P{AEi>YcR|_Z+KwF>TP$#=7nB*
zQs^%DHE@MyZ_n!AN@uUVntT52A)$wcn^Qw$@=v|~^z|73&RgNxyDz#t(2KdZvN`%g
zDwk^Ffe(Lon*82s`FJ+pGbxUHYK`hS=M0WS@qE4CV0~2ZjwQ$agb&MgFM0b^c0CXD
zu|HVEB%P)y{--YB=Lwl>OmZ%tVzd<6?r%RdvFFLo27&8WvfNyG)_t7R!LnT><EnsM
z-KsSox`b1MtLJ2h-<-+*zv|zgnY(vue)8_v{q}VYKl2=4o$L1w%`mLo5H0a-cJ;6G
z#%HJ1?c4Ls{OPx{;B}|3MPys2UVgKEsbO~B#$6I;jM=7k=J-`l-X7RC>HCwJ?Q<K;
zRvu0}WNh=!sOw#=`Qv3Lr0aLz%gx`*${Jkx{8;0yCQFH)I6H}jyNb>87)@r|Jd!bE
zk*+@Ri#=W9-<-AeA5Q*ax4gM|`K8MiPC;tP>F0bDE@mF`<x*yxu{^|{#Y5@1gODxT
zq!We{mh?BO7_oWg9P!GE)O_?LSw=I3dCSVQ&pWx8ue`6YnSQRfPtEW7F5{VEfjp0n
z99gL(ReM^*<?x?G9W56{j~6YjOA`W9Pc0HMQDIuF6?`OT^0y1}YVrH$IvmIf37>js
zYVd<sK9YAVW@o>vTFmxcb9VN8_SB*upUuk+Pt~VsnRT9M<#u7?+2xxZGa+J|n8>r5
z+~SS75C1=z_h#<yAensi@^7;>XH4rgcpN%6KL2l;z#L`c18$#FTOKJb+RF4_{aJx=
z0-vlq>kQrV`z!f4qHdY)h&+6|`c5U^j?7Q<&&NEy|0nfif86oPjGT*`n2*=JxNRJ7
zX#9PtZdc+vnJA;8DN-M#W<Ry(oLqK&gWQ@A*WRC0{=94Vw|6H$OHbetFWf10PGhP*
zyJ5icq}7$_$1L3b{F^$Va_w@-7wO;fj{bSO=Ixi{`|HKNncO^naO1BjVyWLI^mJWl
z*9;Fl+a~hvsPD$r+y)L!Csk*z{pZ0auvPu%?vh4^z_aP0cb^nh)&EP~q<c{2#P4Ok
z_v8il1m8-DkxPx7WB!vlVzZ8SUiX2w32OFAmv)w0aeQlC+Vd^7$87qgBR`&9T55Ub
zZ|-LOHk0<+No&qU9=oA5OY*Y%gvZBpg}pb%9r%~1wqpIeAQP?C=YD)y@T)y#7uRva
zt*W22%N5tltW15px+z3<+RMW^?9T<Pm$I-f@-upJcA3$FESF4^)`e5fT%B})^YXkx
zv)+^wH^Wu$<lmM5*CSL~D*QC<xP)kkXL!ubNd-^Uw)y5C(4NiSR<YN<-+f)q+pHV^
zu3g=5n9r%;zupf%?_2%p`?oKQF=78)@VWNcgU(C4#JO*zz7z6KeaQ7VPK#k(W3c>F
z4flo(AEqYX{<-6})!r30AzwDWi&jutaic5n=(g1x-+jBfbnB{a9<$_EoFPhWn*$@=
z9<P*o#CdkYqs6AqUHrk_b9GBRkMakn6rOgOqV&7=>MG6He<!>67keaKW?u25<V>}I
zM0mTV)iIVcD&ivR-f*-i?%VV<pvP6e@Y>?pr%lQpEp7=+Xqflye8Dvyfp`Ngjk_xY
zGdG)`&!5y6p8Qeq(!ym%>l5N<eVlCiLvfFi{mmQxudZqou-;ko%)6rN_M_dIEP;>W
zRQJeVa+o~1IVkx3`yNB{fA7vn#3YyPojF${C-H*i8M}QPM=~$0OHZ%A?YLs&%kPyJ
zv!*2Gmgl~cwp)AsMzr{6t64|3wtbq}7r+%bSLPRknzfVb1;JY`z6<V{H}*Z|5p1oH
zY4*A$7Fl7jW1TT$dg}k(vwDLiE*Q*szR+KHqhhY$n?H3Q0*p@PZkFCAccW<C$=BB3
zPbg^>Ki<F>y6SSfqnOgvvs+39*rzg^Mp{-(nxX3SCvcn2B<tzA)<*qSITK~48v1nS
zD9m+B?T{$a*zo)7I;J=K<Cjkg7n*Zt!c41$Gc5SeC8Tnn^KrZX&^TiL3+JBn_Gj;E
zLq3{V&O9^kj^aiGsedQjGX6zeysomErNM2wJyYX!vF&fat^J+6Ia{jy`4(T@_1&vh
zeD=*0t_#t9A5^%6!C$rirL6Ru$>&oJ8ck(iyfyx+n%AA$cN`6mH!YR+e(h^1;;*>j
zqjG+c|Cij@KSA%l^{!riA~kjm_u{xy=C!By^(n1AR?Wa8;ncG!s!=jRppIk0{OMP%
z<~BIbIHNAX(>5c^@WrE`vVgkzuS{NCD4(8YqPptT(=Ro?D|vfM5{j=^Uf%xbd9Iek
zbhn~K`;PnHV>#iM#UvuXlXHT7gz$nt^}-LHUtrOYTf!bN?*j7)`91t!o4+%pE&s-_
z>3$^t0;x~oa+XW2LwE#!&XEc^QWK->Yu9|d*X@74?;iiY*g02bY1rMr=29tgHN|MQ
zGG7g!?2XLLZ%sDeEZb4>%HptX>9da^v+kCtZp-s9pZHp`>Ah@5VgIKT)>&E6i)AiK
z%~HEC>&5a#jk+m;t0u^CoQP;jDf=+_Y>SF()tpmaTHHF#op!F_KX1Ic#Q!%tWd6*y
z%_SS`1*9x8CvzH}<e&XVUgfyxqM1%g(x!Pk9TcxhW?M}+s#<eH@_&_g$wH>3az??y
z>+|pS_VzvKjV^w5edU{sH-2nucj@Tgy)*UZ*7)O3t^RbUER7Xrc)7XkaF?}RtON7L
zhrzb*p1ttVIeGGme{<tvXXXP({F~X`js6%(%$T+N?YB0bcX#~{yt-t5<fidS+x}Nf
zhxQ!{*OofJO8WjIcjL=823?cx8ma|(om+CuUbt;W@#Du!9$in`YyPm(h>h)d`HX6>
z?43W}Y>An(>ggjDUGar8TsZlUO;l6soOLsP@{Pnd3${P7*Om}jgrz5HYJjCDYG_7$
zPc-Ik@oh7q`tR`z-7D8Qb>=Uad#*P>sQgyDTCUCaf=oG)&TW-jRof>`^89`Nz8*te
zLyLx1;3bReFOP_L7Hr)8BXK{2$?Q8mn@;kli~LIywo05L=y|rq(@`XO^3lIHUmGtn
zo_o`C$C*dbf6i?cdbfOqT*?uJ+#k0C=7&B>*ZuW>m(}lILEW6fF4Dg0;n!{T)=ir%
zep!8gTuj{D{d<1B)ZzB2uQxsNUH?P;)lJp4cQ?4WKHDeaC6N8$u(<x_lR|O-Sng!6
zR?m;UT%D2lpvt`Ro|27|k@3bOTFU|q&Z;dib~1jIx@*Vo$mvJFefw8)jCFoc@2A?@
z%uUzKPYEeoetEQYf_{y3#mbJWcM_ymd8h?SD6RRzThD*irCY>f#zxQ87xQPHak9Rf
zb-eT9qF03zRgP$`m0}RAvP-_^bN%|iU3<^|?f-96|Bt8s<;z^V_-9M&t?oNEU$ty*
zJDRjl_uA?YdoHrw`}b0R`tvsb^3|=`*Pl=I^kWGXHJ-k(GdI)yutAeg*R`PZsaN(~
z^$}#7!Yn&$LX_~quPN6Sh2+@uw@!Y>`|spwU%BkZkA6RI;BuXyRI}D`H`nnlA??(o
zrQydon3|ZjW!3(d-mSU*zN$q^Lu&L^=VunDm(BiaTX1A$uC_$J{Hd>&moJ+iHH!bG
zzJ9_N>;E&QU21kzS1>pRZ2GnN?Je8LHShl{eqH*~o=Zz(-F?y3(*N_St?!p<*qsr-
z@$vn-kJs#@*M@iB*<Rdpc(M8OAg1$2jaK*>niv0?RlGNyvHVA}@%Jqs&+TgLh=1NK
z`+~8u;`#gqS^<kzy}bRa_($xWyOmDs7xb=Man5}9-M!N<T`UVS+k4~XvLDI;FAOgP
zGuV9Q^6+uvWplW~@ZZw#O+xjGq>DR})#Daz+NHGPS$X5+QisK<DyMxeto+1cGkZ??
zR~CP{XHWmw-DeW{)pO{^ftXbfw|g0AT|CnE{Yi~l%Z#|6=Ui;7=U5)t=aBt(<pRkw
za;AA&FVd{uoAEtz_!{ahl|S#p^vjYl(=Gojxa=C)vN5je*`Xr^_u4(uzj%Mi`}cgk
z{T$!89q(_m$>y!>m6<kq*W-gy;VkDIHB0zby>7M0$UVUwdVR^^z)KU(WUOzO59i<g
z)?AQ3cE>{PjT1k<|H>T47ZoXb_}RUFrhI;J*VC#}{)$2G*dDC@smSbi@TI{~zNmt$
zTOZ`wTV7`IUC-uKwSP8CU4mD^3<>q}$(p%kZ8>VjNh`a~-YMQ7#Cfzabptz3^Mb93
z4y$`t+zAUlH&gMlk@JU5n+|{2HLGE6<UGMB|3|+Ag#!6%B*eNymMk+jIq|0Brtd-V
z^j%ADH9wvl)Zcn;S7MLZ<@bM7C-k@^PBK|`!__eJr?Op|5bxs7qw<!~GV1?jmZr{_
z>{M2DGW_71%G~W~26ZPMAM-E2?R?GAVZyr5sxP~b`ONAu&^soz`A0OX@zo2-hd(Z1
zoDw9YS7QIjEXm84$=piW>!j5qKM56QmC1Tbc(%RIyd>p$PDmhE_)$yHy)7p*n)sCW
ze5{x%`clGdNig&C+b-^c6T70DB^w#pn6_V$w7t4{<C?2{C7IQMM*R_n#}cO8S@gwm
z)9aQuO0%AEt$DM?RO&{emp7Y{=2f|EB|S<Ft$dbNJtZ#%i@mn%?o{<Up}1Z5+pf1$
zKICy!AClh^E2FciZB4tEl4);EY|3sE6XV*;r4tV+Wt=`y=JqYzXTDxb#FU$|Z4+cz
z6)P|NERSg|^Qg)X|7fx{|MXc+qXfo#=f8c~a{TM5egUaKrpA-WJiS$l6C3`u$~<m(
z9OUq%!Cz4E<YT2Jiq;xEDkWPaOVadTon;VdoxxFXBU1F$|9~Gy3?hFYyeaY0TJYrR
zDwk)WNiVP17)&tW<XwNUc&=Z{>%RS;Lf&i1xP2CRHt#}N#8Iye$;UKRS13jusWVd9
zy*c1`!Opk&lA^1%md?#rI`O$KFp1}h;kK-VvI$!QPA2kviea4AQaEQ>om{)-k2O9s
zV$}}ZiHv_B;(XZYV8u46y&enOUa$%KPcoBRZ2hpt`-*7)ot0g8POVgy+1h_@`}NKj
zynFPY>s4K5Uu<q_RCSp>Ram`fufX1|TWsG{Mf0-9<ooEId;P+D&#PD8B7Z7P>}XmZ
z_=x#TP6~^g$|Cn$4X=-MSj-mTwA<%#sqoV-bA|RLyF7Sil+AnV^7+NZgtdRycU!0b
z(P+8kv-q|6xw|{{*$;ArUDEpcb5Y?G_gAl#pXw?8$(`{#e^Ii7diK$X2}h$9Dl{C@
zIK9M5LaU#}PkL>;jC1R%gUvITA0Lxk>>?e<E4Qy%&h&t{;Mrzx?|!wXE+_o0X8f7q
zbn`dgvf_K6uNs-Av59y8U**_+IAosTq6Wzi%@ag<*;Y?UURa@#@Ki(6DsJ)I%uaXP
zzA3jB*LkphI->RBi{W7(*6S>3dZOl6cNk4<Qam(Eam`W15bkQPh||G0Ry1!gW8QG>
zVA^}f2~86hG=KFy(O$D{o47-Qp9ah7m_?hfObmWEC45Eh&h580yYFVuNQsvam6DsZ
z{Q60b^JyjvckX?9B=k~tv|4p#;u^Ju9V}mqST!dYGz;^7vfX}k;o4;#>5Y%qI`~dt
zH;_8dd$TLw(ZW}eaYNaG{Krn4(soS9;e5U+_wd30DPCK1Ep7*UCI1bIl2VO09$aRi
zxy<oybzsotCjQm49@HI^cyQ0<QTc);1=7x|L%IDoF5Gx_)u-1fOEQcqeHLs;_ub(+
zL0jWs@Pu&2Nk@;DEL|R>w@5#Dr&`|5i+2yzu(;{1IBX`MsKYJ%{cUdCvuZ85n-6!1
z^?qYo5dY2cPhM!u`qLXMVw*O{-QQkRAO7xA;k$U%H^+|e66o|gx|_4wD2+AKNB8H^
zyz1HOe7wTXXKzzkD#Xcp`DocxiQ8MQMcFTiR1;x#VMuq+tFzkDnOIUJd42k=lTTN0
z9Z5ZOZQ;curlC7Z#5N~;pH-ZkY5I#rJJ5ISBcs683>uMJ=JkAjoGqHmdS;5g`{}fW
zDoYu;+=N@cf4!%_ZOOxBE0^Be7R-EW>&r7n+tdToEO}f%sya`c%h&bjbIT$LZdXID
zu15{hZ<c+XqPi&jVyD@wi&7JvdzoG*ue!5pa%kSw>D_B3lXHIY*WY{`W4P?Wd>++D
zPugDPPpM(yHhFxdo%4nC=3~FYRQoN~9#Cf7ny~uMGd<Ca<i9Ug%t=ZysN{HXM(AeB
zhu;i($3*UZz0V!dZ+7eT)h`O}$+vdRn)h_R^*+Oxrx8~dtUdMU_q8aAB^Pvr1<nR}
zupDK-8kH5rvuKNZc&25Z&LSu7|4m%F_rDk_G3M^z?n>=3FpKzpUSQINCA;-S4{<pq
zIz*;*Oe^VVDUq(*%qY~bE^)~_^+Zl~4tZUVUk?u5i?z7Y@bz`>tkh#){7rW(pB-I3
z>&4q+=7+3p+#ly1vNTAZWo-L7S1zh-dz4`^<Gzwt+vi<)$>!f>VEwmpukHuVy2pLD
zm&7Q)lUe2M%K!4H;NjV>j4z6}->h2nHBWMnX4t&RMf-Mf_Gerz-+AxuonO+z^VTK{
z{VU)-!<KAq{Zst))nyUSmfmhtuKYdWvQHXQ$=-vzW{F%5ogf~)aL<nO9!$;)q?S*g
zUAeR6e)+!>r;eGIxc8=PUG4s8qtwcVe|mS+%0C*kzAF#NU2y$abN$o>3pt*rWgMSh
zc3Q~xsB-Z2;_^dWH@>mIypw0Mqqynk<?Kn}$`?H}S3Udb8<!{L8mj7j=j8?45`kGe
z4@VX3Ew{}%B<tP6FiB8KUjEK@uQuhocG5ezoJ8uMB<9rf<Xm5VdV;Wx+q81F+<j~O
zoX?&vZ@gTvBsaKGIb+cr{db3+uP?8Rd?MX0+>)u9Q~19iJVd^&Im<Wy&et}D$cKOK
zp37&d5j~=C=U95pGxN_$TW=mazTBmD*X60RgqK^-Rt{5=Srq*~?5f?C4+msjZSuFR
zHg#X;u=CE((wLI%A^l|`|NTRsJ6CJY3NX0UA=Ta_-q7MA;uE{}+T8Q&Htd~aJB6Qf
zX==qTukhjroN`ZC?w(ySwe+Du*EW%bLXS00pIPp)<dJHZ#>8Jfi)Q5o@He06iLO|9
z#jb6|yeK6f>s98RM+47<>Ku`fT$bJ3z1YF`60`OTk5gPqq3Q|Gof&s~vc35+%lzBA
zsp7{r&&rzX5mRAQ*!jn;d}2)V{UymFjnjHJ9z3ft@7l##0h;Y*m)ktf-Z{u0DEsHf
zJ7c|R8>TE>E^vK=XNay<%_qlCEX8dcg4Z{)oqv3$h2?!iy6T7e`vPiu>383L{?9CU
z+@}_^r($eqiqumHsVqoU(DzTu3NFdz()Uv^G%(=Ocgrj)E>W<sFy+#Ro)2eaWM)q6
zoZ8u_`}xY-1?#TIA3Xl7^-)2ajF1J(&%)BE1*}a!<St3IANZ;%zF7R^gw!ve?th<s
z_0;mII`5;RZdVFSTRrzFU;F(UW9LblyB^HA!Kt@!S5kS`vIp(;D<AFKHRWU>j~;uB
z=5C!b`B+cE@WRlNLxww}KIEymD=s>CGw?}M{T0FV64BL*U4F22FV4|_Y?yg6<3V6&
zhJ&z{<?gO*-pWIBE(lZ$#r6bDni-R_ZTn5vz!zGNlGG-9W~gMRn5;6r;+mQ*Vsb^Q
zVy{4zpV_G+KaRIW7EJds=V=g*jK6UAm)F&{7Z#g49qewK8;fXg<|oMrHJ#MdQDc=A
zSKnxoZ#6OF&_U1SqdI;j5%Qe88{OO%M>Nlw(!o|WJ?g^VNzFTjq%JPiut|I|KjP!X
zn3$|(?vlL0&L92TxOzN&vW~T$oE-L={lAFu3@xc!8hs~^-0$H}U-e?=gwtu+$7Iqp
zTHFdPCz@(WNd#}TUsdZEbFRnj=xtVqgfn654D7;-q;g)ES{^O&ZD2JqsB2R@#n{I2
zN`(1{{n5<4d#n6J?>EcN4KuS5I?%z$u^>X}U<8~0X2FA3SkJ4osE8iS@w%*WP2sSL
zlv?sPv17_>uNm(Sn*5b#4qMHIHQ~w=lpV@aZ$y7c^9@m-VH19K8q?y?qX8^-LELAQ
z?;N-zHDTp4i3QQC6FHZy6jc*ET*+a^vvJzaE{91?9<%mT8qeHUD$cXC`S(fR`hVB=
z%c@09{>9{T_Pt$gmHp3OuiKw0En8dFy6ARM-mkxpE+<vi6<3-T?-Bd|v1sco-RFAi
z^8f#;{CfE3t0L3lD}M}U&eMIS{ry?*?0Jm&ErRAn=`$)<&6akUKEvF+S9-ho2JNL=
zDi1w7I-Bo9%lr8u7I&X<HgG<_V`IpE^%-09jDI^~V&<L?d&e|uzisj5^3CV9%k$gI
z>+hV&@sLj!<|*Ab>umV;XPdtLO8Is9O<CdgJ+tnbJ-PDd>-n4QuTQ@hn}4@8Qos56
z1CI9}XP#EQ*E(m-(|vQ#i@$iaXrcAx)aR4Wem?o-&pZ3o&;H3@|NP%?*?rw<@@c1+
zz5Y=5Yx~Rl%kRer6epjGNfepV)&F3@lB3}UT36qk?GHNm<|)h0eCgZscfaKCF6VBa
z`S0}l>+<iX8P}IqZr&AlruNq<p3S^0vK$g`ncAB83pRzbok{E|Szu!3ru05h<<ew>
zO{q5}+Rr+;^BEs_!n*lW`mDyjxz@%7C+hp>GG5y&8Bt!}GyRyUl+NUgbvnsaYbWt{
zn9n>B9ibMm_G4M!MfXXHezUjF{brIXaHfWJmw<7Ni<FXP#l{ztHo2=vF6!-D&O6B^
zUXYjDCxy{odcC5^B>i6tw5HFu)0=jE_5Hf<h0{-%b-XEF+$VEKqjP)1Ep_#*nA3ZU
z7Kr5+{@r<}NJBiYI{*031nHDDe|2`sCU4g$uA25{ap7g@ydb-iQ&Z>rwDy&zF1yz1
z&bue@f$6iurWM`|$(;Av);2yk{OeGhu;%ZENN3&$x)b{~E0-{xkUXlKT4S_WqAN8)
zU{aod(>ab`7vd}%yH>2Ldb&tty>;eM=OT?CHlqJNFOzTI`zCVo^(o(KG(T?Kr;=;o
zvvBXF6?UPM-B&i-EHh*2dAIlKRY^h3Yj(e$3pNKN%oku1772=8>@aO^Aj9(swO)4?
zcl5ltu3D*mc(TIwZA`LjnBzSRJSu0&Ju~!dt1NNXle!eh`D*p?_4<XW>W@@*q|II+
z`&zZq{?U_0LG{<`rZ2fs<v!bG*`>JX_a`5ktmjO-s4sDmt1mqI)CW!$32!&H)NT<5
z!|CjfMWuUZ{rqtD|GMd$`^%@F=2uRed?Hb|E;#M}8lNdIHb32QYTuL_%#n*enkZVV
zcAS~?jdhKaCF8rct&f<W+W9`}m=)q^^twZ!r}1sapGgnumqnbovi!u1J#9B+awZDy
zk<!`ewkZ0_w7`kGFHF!`xVm?utK1B=CwEO4WBBjCn|xYf{-Up`CzeM~l1o^Wtm*ch
zdE=*zB8zi_Ru`UO&{<gFc5Y(USIvf?fLc@TZ7nM1PsLrbq7}Oj6l*<Wyzf3u<)qCD
z8&CejQ}}plZt>QfuspEh)2kb|^|o4NzF2tl;$p?9?~1GZn_g@)JngV}`ntobb-M!A
z%Lq?$VVO4l{CEEISCqGYemOb#)4eAmmecG{RT(_HbAH3RsjK=8may8~Ub8{->J0Xy
z(+$P9aS17GvY5Rmw{PhVH-%@X-Jd$XdZXJn-Gt|=>`wPXcl%;iT@-&MD*VJqaW9*3
zsnC1AAKN#5=u?;J{;pMBvHoMkp6lBZ)|zC!itXBN*t~wv+rT1+nPIce2B{qUy79{I
z>#t|uj@L`yuADY=1#hmqf>K1+jb+>Xv!t&-S@^tp*P6Q7y3>qZ&csd$muvgfH)rh}
zF_BmLET`WsdTi#l`^;_5rE^u!OtzH#c}dSL*ZoIC&$iU0*y)|y-1qJas+KL~Z#vMI
zW!>7M!ag;V#rjs4f7elOi7gGD>T63%Vml{Pi5a-LMCh+Lrpcy!=tRru#q+-WW{N#u
zzccDz;pV8Gd5vx_RDCaS^u{fd|9&k;SxW7eU&o>bw(BAy*&Cx0c~3WFcO4PmcxIiO
zf`oO6@RG<mT^*5bYg{yTMD|^Ju~t<6@VB|Ui!PpPHYu%}FLV1>N6`A1Er~~OX}h;w
zNw-lbobiTl{lrr9i0#HV_|(gsN|*1ksFe?!@y){Un&TV|p)!lWTbG5(W-Qwobh>xr
z(_=S^lC!r?d}I~<xBHa4^QWb^7D_p=KMQxNu|Cjy{!Q@$<xPiTCPd!eY4k0{`j}#M
zP%UfKlYqT*tGgvNC(PY>+F<6#?P2mO^4IR09X@{r=cKiBUc?C}djD?MGD_Qf@YUwr
zeYqklyDlg?n@Sc7?@f!JXcpjUx7cIL+CMDz>KRjZe#;Chn>n*xR`K;IS-q;Vr*Bq7
zp1Y*2&Xu+-&QNc~!e3iA-(BXgeq*9VLHORoZ~E65-*|cW_gi6W^@{Uvj-H%u!T5Wl
zUBsoiduo+5-xThfl59CYYTa~`cem6IDC=csT-*0>#=Hrc=}W?={IXe;XY=U)r|iQY
zG22omX2wWuDQH{C*u;?N8v&k1-JN`Un;>Y^_oPpH#bsfanvaKl<#Xo0Efl)Gt~56-
z>v^MkpipvGh{vhv-v55SOFDSI`Q16cKbQK_R0?)7h;`rBD--{eetV{U_0NvO+wC74
zA7s63GmCR=gu;=Wt@U3{D~tVFD1ZLV`I<i+e|e@G`Cb*O5qo&!!`*(n{Py|$$Lgzo
zW_(l%F<uxU(OOfsbEoRjr&ZtX?XLL#<ml6z{?qT<ep-9sy#D)1zvq9*v|PS_{}-jg
zr?cm21?co`c>H_*pPN!~b?leg3oUk=t*L&{@xXk(E<3Y*Lh41Gv_b`@m<Wxu1;%2h
zI<9?Dxj!xR+M93b#czxIkMG!blzU-Yt;*+}ZIM3xr(>(k!i_#``m5;wJ+n|vX}#yH
zH98$}c^N$?<a-YOWni25R^k6KzpKxV8A|id{B(HQ$L965r$zW?sB}AB{q*Osq1Tx|
zGx*sas@z_-X2r+(Pe18y+w$F7u+FA?NqYFSkle-V`hTyvaVdDS_pEKD$D*IDv5=8&
z?`Zn1^WnY7B=2P@%O|f{#<>36vjuZRmbdB|FHnr;aCoS5?UvExTbEx2EcKndZsBSU
z$GCO{$1^VbYuO)7IDGcv;k7@1rXQD>m3fnQW08)l;YsV-`OPM`*mW0nxjc}abXC&h
zyP&I|^diyJjb5IwLL;yEmc~SKbc#789K5w)x0CU*XS=8Or@i-GFMjh|#7)i}QZrRM
z4#Ze99S|?v-ot&pk3;O+0VC_Ctfi4z4wbtspOsb0*R1PWvr$PUbm{}8{9U3m)=4rf
zb*P%0cX^fFa^0y3yfG(VPD}Hh_T*;%j@dzsr@a2~?zL=}TpFmsBoKeqH*%@zUbC!Y
z$CexO7CmwQ-JztQuka)|Oz!ocwihP_s|0E`g<jgSdF`piqFYu;a>#3DtNbwf`*lM4
z>NT0iBbqY~-0ljP;;YS+S2%TIYO|cX_LfiHnW@vb7Ho`b?&|4%XuL{Bvd(+;r#T+d
z75!=5xwrkRN}V#4HbrU$@E<EVwd>rvqSHGp&Dhj#xVc_o*fh&`Z^iq*gN|$oh6{s&
z{dEpn-hbM8JAV0P-jXAKPFURye_<ropEBc@`G;v%`_88wO~3U<H;}QDk$aiLo+2M{
zqxh5e=4<_L`B-AJulP`B(lZ$o*=?8Euko4n9c5^?zk2+~gr?2AYyX$Cq(3RV^>s<a
zZodf~A9uu0DA3hNT2($r*XZD9sWX!K4<sTEUR#;>M17j`IVQ2$!Q!r=4IP&0T46_y
zc4qTPS^P?8mP_99&iBcJxgMRJ);q&{wSz8if9D+WeO{1-SmQ>n_F{_%Ww%?3beNuT
zGYjM#C@+!~4m{{-RNxfPIO~t&g((8OpH8lvEtbvQbav%hhP^8~FJ#6oKb#k=!WGc>
z&nKtbp857G?+tf7e_i3sUF+Pmt&U;K*S{BzJ#epQ+!7o0<#5F!xBIO(J6!i%{@(mh
ztL5Os6I1`*KTx{qklebaFMA4gg_4ft*)QSFJ$5vrZNFu+pX#oeS2_ic)GC+kZ2Naf
z&`Pq&eoxm2{(b?=vJ{g;*BXCzc*fV5J=ytwv*t6S<6i{c9NWnJ>7nL{`KJu51phyp
zk-CK~+=0cI<)O;2`8^9-=k+b{TljE2L$0D+#yl;S<wAAqq_cykBs@q`RtqsH+Bj4D
zWphR_Z|$4yDIMC!Hyv-cog=On{3v1x$2(!2GOlH6fiDB}R=b9GB+i{|^6y!qVcS0+
zmUcrKu2=O3Gv~iBo&C6EGQ<C~8+Yn61}a3}kUV{L?$1eFHDWIO=cfDAnb^%t<mveK
z$jqgt^<~V8y|2xVHgD5Bdc!QWap9*)U)4_^+RJt6h?KNvsdK*XB&onjTzkLOp5pLN
zow}yz_P?hbn%bcy2|Pa5%Dxgtj~%pEuMx@i+N2rmw=IlM>!t(KUNtjef5yE!K8JXw
zDBXQ_Q|waE?>XvM&DQ#<oII-HDR)L{>t>~&r&J!Qo^q-(sC;{-l|Oi^aO3-{FJDEZ
z_UeWzuohK&J&V>&tIoM8#Q1TGb>rLEOa2~Hl6zfQa(F}f`j_b`Fy(pK+>{c_IT2cQ
zLikO-szpfZ<XNB2TY4?p8{3(mdCA`*`nK`rPgiz-nsM7QcW;keg8$^MXE_O)5d}LI
zPckuE`XJ0R<kgL7F6>)Xon@1_<u)hHo#n)}CDBylhkAs*VB6`fJY_rI<g7dRbFbl2
zgBsW9JD(D7>Kxh>nQ<yDP09M<vl-9-7Nq?TTiIBD_tZp@+{a-Dk2CIGU1tAaf<ftg
zkILs?GN$zHH~lLW(`9gkMd-}hZT=y57xGQp9M35FZ$cV({f#~6KHU-8c+C0i9-VDz
zyBFTg&&@a$ozPIZZCUxrtkAIRU<;$o)61vxY&@Ni?pv#{FV@uL=<d_9x~497gM2mD
zN(D`DF5UJbb(`{+Z#!b$H@}k&TxD{eL*v7tX)Cy@RD`b!D5$SqrmA}OMd}L%ryHvT
zXD7rwk=V3o*~K-<8D(EyNN8+gUfBA07vI`t6VEE8D=><(`yP}uJnejGqO)W~uE}BH
zdf#m`wy0Uo;`WT#b@+a_x%Z|AOERN0&vw6#jf#w8lH<GnS>mej)??D0(plfl(p5Jc
z4Q!UHxD#@+%zm2S>9s$+lb5xhob$TmM*BPKn6i>T4~l1o<$g6hpQ|bLDd|jwNQ+j%
z6G#0MmzvGEs;1{9Ol6(*;YmQ)_Cr5*KF|@GW3}(Oz3*LNm#6#6JFiQYY5RN(alIEE
z6gE|Kt;b>!2mVXjysZ)~59k=*OwdS3KX39ze1#{sL2b_SFKNMwnm3nUe<9#y<7{We
zta4&a>GXDkNnSrD6x^0pwmoNT*tFryajo*{D_dTylE`&<EPdIXKVkNJpC_j0JX+o~
z-Hg2~bD=a#f^on2hqY(6FZ;UquwM9%s09X}W5aH1UVrd*-OcCaxhnlh9g(T)Ijb)k
zuW5VrkBKKHHmW(k-skx~{);P84v7otZ@Zy#PuMP4@z}#zu8!S858Y0dd*<2%KB@M9
z@qCfarKHKvvhU38sFvRmVxJbe%T{gbO!<ngFW1|mZg26>uKwD7{>j2sN@t_bEwesx
z`js;8O_`5=EEPA*T`EFt${qx=2?e))`}HPiX9<IYLzZTHLz5?Cz(dR48jA?2|FVmU
z*-tz(>X39_EcNP-Kl^O?qskj><8;=oUw^Z7b;LHU@7>Nt9;>S^3iH1{8>=8xk$>lT
z?)CzK#_gR>+$`P9FOMC}7T)-0*21OkhpOj>REBN&_=VBg=~m<=Em{5xJD#R2cz@Tg
z?YP9V)gNOw=`)nM7biErEq@U;DQ&B9c&kH25nFmudCBf|fg2|+aW@d)Xg=^VT;((K
zUxxjQ_Ghdv74ZMV^<&5JXVr#3)@{z6_+(k;+ITjZO)DyTTndc4OLwjk|Ed_9D$R5M
z!#}Q!73;gUY}s-7>JdTiuP59d#Jt+u#rgH*<`chdxcd+0c6DY4=6Tf4HwkU4b6~ku
z9rmv4r#HuSjYIBULATwezB_w#MWxY&L&x}!_s2FZ+&jHu_brp2c^B08YOc6@?}urz
zf#QeD)sH(q`c8l0!1JN^rR1CsCS2DR|7H?pV!x66c5l_cKRfTvi7>WX>C`RpSbJ$w
z#67uBnKqw4X3kV<IQzuhrLvH1p-Ni&mg;G5)9MY{Gv>;EcR3VWxveJg-?|4MO0|*}
zt$&@ohAX<w=$0B+ouBXH9~%xbf3@bH%dR6Xwe45-+zky&_JySBD)wCzdLZrZd*H;P
z(7Y2)mX_ZiTsYg+mU?nkQU>de9jy%)p3AL25qjW?=kgQH4M&yatX<!_efTWHlvPr>
z@7p}JQ1L7;`vnhf9xrJTWHkJ#$I9c>up`gkCBdNH;$YjyZqKl@^-CJKe$~vscV_-|
z-=eAMU-Rxiy?tV@N&So)jhR<meuVpmKe@2y#H-M$W@QuPPrbdfVx#qU_LVu8o^Di>
zxOH}+=JwE{8>MEACEI-qB>YzWyRW@|+Vql1di)Zv1&?e#GVgQ#LFrWOPq)qV=H+ou
z*LnB8PwD>r*AF;78#Wx**znm>ctP8PNhKeyDmmV)uIdh6D6rf~$**<O{iDnO6zo~W
zJ6BM3we)Wfi)nLyRs~huoHk$VL`SW-_m@YWey=vIlL<XNEnjjK%m0?Ajd5C)?;px@
zik<!-a!z$e;n8NpbIrl+_H(Xn(BpmgXc6yKqu|*SZgJ*3F*$JT*yTB1ir@6@+P>*n
zzX|&N&vb9x@-i-;A0NK^&W@PvD6bsYxcI!{lsKE$|GSMOpO{@?FZ^^mef`VzaYlKk
z<u6qH{KcvFY9^zN&3pzMmGp@{#~Q+Ij2fOhA5i|N*l_(!|51StM!OU^IX=`?2z}r>
z7y0ihgZwJZ2M;q^csYDtF~4oiEN@`vQto2hQ>k*m+3C1?_&nu3|0m>4zIrz4=d}r0
zPX8CW*SA+n-j#oMOlZ-b%N@^u%s;^S$l3gn;AL+feji2CPi3CHQ-vfSA2naFCrViM
z`^tM)clff|I9M^tolt7BTT}b-)mxz(%pV!%9JndNemCwj$AY{5d~t#EnL7K<R_zz_
zsL1CQQ&F=u6WACp>)><i_MyXe4166ECol;#UMbDlB<m9p|Ac)b>(3dkt-HQ&IKF?`
zv5%ZS59B=<1eipw{`>58>ZR|odPWQV_1swcX%<G9{WK#JLo;H>wD(5d&b#d)RC_+0
zqcS4E;YL#YiM(H_4=suw6+WuaW#8PKvSGo>ZAW@tvMM&ZpFE!*D!y{IroVxM7~6?g
zt9PyTn{VaI-h5L*Vo&YChmt%$910FP<*_M+=m;fE(2M``vFW7)`^N>fKYzQ*Jg?GB
zU$sstf$e$Q^Rlx2v+v!X`Ty(N?u$Fam>144o5i2^e*T(AWmZ4l?A>W;yI=NS-S5-g
z3u3?g__nk3Kli^~^N!!E-)pdt&9GZp@ZqkKBT0wZXR+%{m^JO|%|H9LuQ-@KpWX4n
z-=H;N&hZlG`D!(j-<Jk9E@V1??TepSPt?AGmFM!>+^Y8b=6x*vRre@<-TRD^N~gU-
zQl({Oufol8y}X~MKHTNoekWV(TD(f>+@%+e+5XpC`DO}Re4qWE6q5%^_6NWAopav2
z*;ulDLoTOv!E7N$^9!~?_l{QBxOrDSK6bp3IsVmz!li6>&vp2mr2_e!--&A1MAfKR
z_Hb=AkJOJ%4NN^Nw7Mt!$(MOM`Zi2m6BqnkWq#1*(wVj@FK2PZHyKEne_@_nALBgn
zGT*l(<tYsdN~8<cP0jnd)-(FiJ#DRZVYz#Go|a2yZj*P3cVXagvF49lb1UGuyVG4A
zqk^3Qw|+AeCZz21F50ao?5r2!qIjH(=jZ8o!)tGMq<$*(h&UK@?d$SKv1W@uT~X`a
z=I&?ub&u>MvD2bIWS&Lrw^_KVvvgl+>DyPEYNBrLTC~xm{hQsi%_`^jsg{O42{q3R
z+MUqdpeg&l{a0^oL3XSNM}fn!$enRlkFIIitG>E&TF~3l&I?!WZSj1~b+LWw-xrSs
zW!4zHYbv+9a!Y&GrZR?&mA35%H|A_qvC>HtP4YZ)=y!-}Ik$JI^oNAz<|)#57V?I@
zWN4qtvG(L~|Lej|W!wAqzEvvdOX|~9Ei+s`^}AK%m7AM1bd`MD@3ot&U-^(}v~SlB
z^P9^<UD?gg&bc4I_3GI*b5q6F1*q(3Vm$t2_mxQ(vwU{!mRcNnWcSsStFiYsr^p#^
zeS2k{&b4FD>vWR!R2^>h|60~>IcNO_>6=r!_uVuVR=RV}Z#nC~2n&t$=5u>0yQj#%
z;rTMPXXdp{rL``?XI@u@&h2sQ@9$r;GH2f3lU+q-UfqB0O*8X<yFzPLXzM<ywO-t|
zS<la2lsP}o{)@B13BJ#})xRg)3@T1LG}qx>abu6^<d`?bjQqb&K43QZaL10X*24VW
z?Mt`jd{wj)(7AW%s=Ly;8ly^n=48JOp$+#}pIow5vokvOt!2ZHM^#R&>zH0m+9j7d
zx0Z89QNetpS4DvrZ(n3B+j}BA`q>HZh*gt*mp$53@h9CsMwP{E(nY^2fxR487}ovx
z&pfd}Ua7o0>DZ-d9SyD5%;u-=+?qPgxpt$>QqSCU*PU{A(^qGGk&(J%c`I-6Sz!-R
z&sn!t9ZJqzt{x(rA?D)4;-utm<H$F?r@L9_P^Ep*JyYW+Egsd=Q=52xcl3X`{cE+d
zzq3=~ZdawK6MFU6QYR_BTj?`}oo(q9Q_*D)y4n*tJXx#fUFg}aSL^V4_i6LzDWRHu
zvu-a{J$KFBBAT^La<irJa%aIx%Ux>u2K)<JcWU*;RJ~ZzJkf`9qx_*=5h5JdB4@up
zf9IpyqIPA!1@&CY6Os}a@F$r>Cho}H>HD+M`+L^xcgiRCyPx{9aJu(FpELCg`(EWA
zFi&bUyt{*MtC)DqW*txO<2gGXP3#bf_I*FUS;M@|@t>7jgqLf9Kq|NOy@!5Z9>1&I
z=5YS_!g90iE6ysU`7Lqc)ta_^WB)^iHfi-cIWF_N!#2j;s+lDqC(6I~_ac?Y+DU<h
zt`T=$UJMa1GYX%YyUf*7s3=P3w&pAw)yhkgTauStveh`i<|A<69nafG$LzLTEpcM(
zSn%V(&EF1tioA=2PAj;Em4=y{&Jz%>IBFZ}pA``v<fpB5DY3b1`5j%^c`^dF(fb$4
zDRERiR7*Lcw76dAj+2<%FM+(w&}BO3SIs)x)qZi+&gc})llugBy0$3rZ@F21`pPxW
zZ4#lY1+A{ChJJXnVhevRqlW0-Z!&St2bE-H4{Kj<EA-I+ZKC=6;jdfI{`*dwx!XnK
zz3;;rMGqNTMBmCfRZcf+XE9%XD7q>(Io*RLHS|f(stF<fCw;!}oSNn>_F8N8iWZ3j
z+r1ZO{FycNTP}0Pf=66OQv<i3S{JcLWlN`k-{XD${VyI&Xxw)@;8j-ZcP^jD8kd{G
z(ydo5VP?wgi^{m15Oed_MveVRjn*f%Z*gDa4E=bb(uI93(+!1tXYUK?-xqkVoyAbZ
zUbJIY0O!-N+aK<I&63mMhzPo{rFrk(ecQSvIm%>&S}P)>Cacz5y;f@6RO$PD5AW<7
zXOp=U*R2rluj=ngT4=P}X2Fj*uYjb_-WQxS8F_xjez;e2fcLlJ!QbC6G2Zv$DYt9i
z=V+U^=i)QRmyEh?{6507nU-+Ba<4h&*m9&M-p)E!X2yf{n>b@iOPBP?`uUhT$<FaD
z4f%6!Gt0_AjvWm8V*fJvQsQL=4>G-3yUM0Ca9*0U5TEm&PrA9WRx6orJ-xK<cMwCn
zK})r`q2h~U_r3Qdu-R*$)fStrzQ_9XtIFc%DH(AoqAj8xOg|PT$2#cQU)Z|te!bl0
z^*2x0`kD7BUb<`1)-^Y|FDt5JUeIwB-L9=!{+CWIo)osCL6+;*26<jR)oEY09>`=+
zP)JA!Sfl!2S9rvM_jw^_pZ;jBe_pZfRYbtd3)S2AX>Y!^OrQ0sa%|tNQ{R@|zc+mX
z<Mk^JPAomzC3*9wFle4HmvqT26mbhOTzu8PNib%~7Mlg^da{lWvRl^Ah&!fSG4bpQ
zRoAC3ww>}zQWie2mAIYoQK0Zideiltp9`aB+}N_^!R6-<mN`z&{Q5Y2MfwLZ>19i-
zu51dle-dLh|B|h`|J~>3H9j5N>HXF(Kk45K6Pc+6k;@-*{@d}}gNyms<;?<u-ACEv
zpTA?%>;1NF?xdoCQu|BAv5c`>B~K*#+Bfg#>2h3PUADcx!9;ytU6fqVABOax9q*l(
z9<n}^w6v~|Xoy>K&Cj|0!{UbrQ}Y(<T|6MDTypuvtE8gS7m_wqHU(~;^=bbpAE&l6
zF7EFwl^*$URUUBrb%VV!z`FQ*tW;U)%q#a_WO0}-*>K=rZpM`K=O+Tsnk=06-q<6t
z`(Cwxc~*I)!pd#0SnaEY9yq;SsB&cW+exz=DgrIv2A9}gbdB8S8~L`-YWKm?d0X#q
z_O=LHzpHvZ$2^amf{6i&uDTt!i&d^Zv=8~mE^;uX3$p=dYKS?|Zm3{nU<hBLV5DGZ
zYHV%^Td`oQU;tw(7@C<G8h~4Rprs8tC8<RU`ffRiC8;i{$@wX%Ty}O`#U(|liMd=A
zw|c*`2E^XJ#LD&f-MgGSckkYv`(RsPdAkFLUje7y!Mk^x*vqd!c*obT{C!^W{{QQ%
z)~{$X-R1uM&Be{tZ+TfeH%T>j%xvZixODK|)W+6{GsP8_DXcnsh$kT}EjcAEt#$E&
zfbB(FS^pj9b6?0=Qns;Z!}Gu5&SxYu-uy}wHZS|Dpk;A`IpuB+qfQQkm|vWjUR+ul
zgSN5p`T7pNb9)#HlgqV@8<><Gt{s$n!Q`&^?7@qtIjM;+e-)mqmt(xL%!ENqPEPNa
z{b5F>GKX~S;N<Ftrj4srFT8u~5}X{}Fspf`=!L7V>w^M5NAKEY^~uPvvZBI3>h?|p
zD~o83OBa}J*2L&Cu5u7xu-W<o&xiJuhD94?Kjdfj6o@dCdTUSLFO$XhY@OV(a}EdE
z4_-SZlJWkN;G?vBwi33QIeY<=C$ei;GQIt;bo#&R0`@<5Wf-`XPuE}mEBn`7N&B~b
zbFZ(j>>HWhw|m#T(PelRw#}ho(h{4+tCwrr9=LJu4gaEzYr7A-@7cI}<J7eqPqIHe
zf2o&ol9Cp~WB%6q*TsgV+lop`6H7L3`s=KGSw7S5mQG^6+Ovdo_ATY5jlUP$6>6t1
zc<FwB?~H%@Vx+6t`K#yuS18u5HvVj%GGnKuQRa<k%bkp=NB%#nnepJ?#z=-(Mwv5b
z&cw{Q!>~Y@;YDWF$uGwlU&Zwuu%D|_Kf~VS$4?6@3#K#nDGYztoN1J=e^3+CbGMNp
zJl%Z3{PX)||93x#h+s$yTegltctPt_+dK9*?aw%T-v8nFU+d^frjnWV$NE_h{5gKU
ze*PDGwKHc9-n;f%{@48QGb*c>tys3u<NNj}|E*kIWo;Pkcx2`<u!ZrZF>rIMTQ|IZ
zeDHn!XASA-zp=;nC#AkQE6ZS0KlS&;<^QL=`S+bC;Qw9)lZO9im%jL5xYL2*t9|pj
z<7W=${QB7a^#A7_|0O^D&p-A5#HasOFaB>=@-&aWZU6U5z2Lw4KgY_#w#C&O+o@eY
z`!$(cM8>Y{;J^PtTN~=vu3OQ(_U8YuCwEBIziH~&+xoWtcE(es%%_|t!P|;VxBkhF
z`L`+i&&G^xVc#55*~M4e$LTV#iKRXJ|M>R}z2MpX*V|7Y_xbmdsZQtoe>u&>{8tIz
zj!)ZIcW1-K&6_uh-#M;YufW&9fBLx9EJoY^bCMW@7w>I;?auMQd5-*nI|n7-^-Di}
z!eG$(C-E0|A@htQ|GRh0VDy>vU%`xF@)`RM;R7oF`5!SFX#N#1+{`p1<iDeQVb*_z
zGKR^&>^ry*EcqIL<a1-se@A&s-~Zhfc3Q@z8~$couGgtA=|1@;egf+OmOt(P1MkO+
zf8~F;Sm$&71NjrL<n3<DU-%o(`R{}E4$J@A|C*CN>i<}H<Wu~I#S_E+H_3m!^^d!*
zW8-i3x;N^V?Y%7QN^aNR`L_R$e3Z;T?wj^avj2|%4V?Yh{vH3yKKa>CKCDmMP$Tkv
z{iR5|uHv81_t*<uko~cq%kG7qy#AbeCcC14mv{AVO)c75!uD^qwLDXdt;|2s4+{^z
zjsM`h@Av)(?M(gkTmLD~zi$7vzF=?Txq8*#^B<a(7MK02IQswRub(si{C{9?@896y
zzd-ZOr9I7>_r+h|(tpc;Rq2Nu&+f-e#v;3;R+{kGd7qQb^Y^&mX%Z^wD1EM6$@B1D
zjn&pdSGFHIePq4eaow*M7Ov&g%00hNzpZdp@b27#?#U6%!mP)YO8>TOVBvXnsCwUe
zzkRdj=N^c5*qx$TH0REaiBmpbkhl4@#OC!c?{K&M=iaY+6Iyuc;QlFo#xB_|FKhK?
zEj?j+a?WAJ)}mB}mW8gnKe)`>yLYzZ>3J3E(|Q*-f41&S`~7h7=95yNEuQZUTX*i&
zrC#s8)y>Wvb=_uGt}m6VCg^nUeGnWYu~l)ygrlPWax;E<$N!l#M@?_#extt6(}ma?
zzc~EVEBW*;hyQX(dbIClPFDt1(L&iCe-77;Q!1TQZx(D!RBH@9@K{@NVbmV86_T;;
z{DI$3&U6!BoBzjLCT`k`zlGL|tQo(&J?B$@Zo0e1GNZ?unw2M1iYJtAN_ACT^U`o@
zj6LVo#OW`7G0ETk_dVv=p=!45g4Y4}ox-j6mfo|g@XyP6`Y~Pj>96LN&zG;u$8MZ<
zco*+giS08EPS$9fYm;a_dEJ`)9M0aD>G3a8BR0BD^gC^|vppr)e8zKwH!&P02ezn%
z&O5Wk--Bb>uht1^amLpE-mPIF=Pvl&@NZl-@zTW)zl;TYGW!_YCMUBvNzSh?o}c>B
zO6HSU=7XK09qKP$+*&GWz$<BfX3aa+Gn<zmFu8GW1OL(UiEnqE`usasD7%(l^ZNwz
zXB!=Y+g=uKx)a3t$8KKp)!esnmaf7@>)r=FUgGu3D$-QK>6;L@&1<zBud15XD-*c`
zrtRw}p62s>|MUrGSJ(bK*S_EK=!zHhF+wXWgWs|!>wBkLuqN9E@8^B~>)XlLJk9<c
z%qyO=O;)R4_(<gNdP#j{Bl)KCFDH`k@a69CbFEa-ymv&|b=l2tj{|SqRZF_Db!K4G
zf$O{1c&ne+nyc@<k<HPwZ${^D&goy6(zuqoM5WAJT^#2zVT+Eoz3}a?DwQ{y`^&P-
z&rD<9#~l|W6d3aQyRdhMl;Fu|`v^wu+{2u9SKiDJtP?R`UzYRwxps7~k<E)|`bL%J
zPP^n%6Dn>mUbbP1)o(Y~9l@$M=f1wmp_g{a;p8C^tu<*;)AuqTd3o~ut2CR<i;m4^
zov7icczT!N;$wwRPKs^S$<=>$;zAX>=Y=!v8)BBb99t#Kw&KeD_$M3J2A-^&c%yR7
z=4}(V-uz#5Pw9Ja&HNyD>#6O2J{RVH(Y&l@R8^n!K7ESUCx?8U|9c;;{&PU9DrIBT
z`@-C$%es+sS^57*ZrpR?&Mf_7J{>yOrcLSlyrgHtb*7y6v(G=))q4B**Ue0>cOo`c
zduN@>SGjg*+n(n|UaOLRbH&&$j;ft{LjT|%c8}ZHx_jqr+wtv;noa!MFSqseUiQzN
z)?NRiR_XbX%S(T+Q51AEyCAc4!s-&IUW>rf8viz_#&3=7T3qhETlLR_vu>dw9+oqY
zME-c%WST0fwWynEQlHh!XS;nD1nTzvI3^wZRv=;$uj#FVnlt9JLqv{ise~`KZg##n
z-+!US?PAlaOY{Hs+bxv7H}y}~`uf8ym2T!sU$}i+eoP^<ZE|URfuqwmZ`mh>v%cS$
zedo)~lMnxNg;~Bcn%A)EgDUU0#-P@R%abqIg<7P#%wkH_4Y$qW&f2v4+%e;pdB%wi
z`tFmQ0*%=-V+C^4MT^8Ap8O<OUwWltQiV^5Z0+nnTX&kqCfzydk?ww7|HAIaZyx#t
z`9Hf??QQg76R&yf!_@t2n^iCUOxTfVJkx?RDx#{P^!mJiar>>4`&XxP^Q3XUsoc}+
za$f!Ro>flvn*-d~7U=w`yZc~mM2=92!$O9_&O3Zz%@&Kc)=uSFDc)A5VRvX%#p3tO
zsnvNm&PPihWL|yd+r6d2A_6=m=U=Tzo-DRKPVvv7^}(heof&>@DLyMU-RJ$gCDUUC
zgO4<rxo9quY}vzD7kqnC<L6E{rF>Jvmukizq<+3g^6NPBB=Gvbyd>KVp?^K!&QXl+
zj{Go@Z+69Bf0NGw=e)O1xD)bxZIkrum`gV;bKMry8eVwI7*gA7vf^C9+S|RC4NGqZ
z9sV4eVE^er>7UC-zXd-~GL=viP*pm5Yuk-YihrN!Hhw!<>v~)0Md4GG{`p7aN^ISa
z+i1V7K04=w)QKx=qa*|K*2rxUo1wS1EVH@wNzb(Q%|*Whrp0}{|Cdkq$FbdyvL>Du
zZsE3C#PWRUYNpfGee>nddxyPwQ|T6YX`Y1B`|{#>hTbKCj}AJV_Wvzduk>bjRPn*X
z8@_6<sm!ewue-VUzR;ze8AA7}gN_D>Z57({&$jZ<<3A}!ZGD1^{QQqxT6Rov>qem>
zVbx~oCJ8Pb-ba7th^@+QFo+3c^FO+`qh0pQ?zgscY9HQvXKZv}-t4vjo6i}CUFr)o
zxqr?5U*pq!E9raL$HKY04tR8$s&0C^l_CA;?H1limF)kn>oWK4O55sRE&8T;;g`ys
zC5|id)CKN_l@wG<8>+T_XtnkFXvFei_is&})vf^>ycuT19$7ZY;N*w7T{p9{9&ce$
zw{CkACg#R{fM@eYv9|L|zsoc|t2!9Cv+K0jTnz`A&&7LW%QuQL?UvYCelI-y>+i5$
zh2!ZnGrs6Aoq5i8JI6eYX;Y`gsaTuM+JB`@Yo}A{1Nkeu?LAk8^9--a^tIdHukT#A
z&gFtp@x=+10v6ZnXL&jYewf?%M=o9M_k!;$Lqu2loYEH9*?G4|D%JVpZ9d1%{F>9=
zE{<byxSzISQnaw%TgEScoSwuuBs@C!Q*6P{+X@f*%C4XLJWZ-1-mgG)fw@7D@24Nr
zJ_m0xJl$eluqo9`y3o#d;gVg8?N%}6Zp@HA%XQ8$&DeBO+J&EcSQL-{|1Nd<Yx$3R
zt@-yC{`|>w=EZ8BG>iH-v(hhVms|IV|Bef}wPkhD_9D|e0-R9?+Z|g?uQ4#P#m2uf
zG7??>nWN?QD&32GM!l;_TveT|ufKe%nfBI%!{`?Oh1af)jc>O+xq9Rq-@NFYB8Dlq
z?`8Xb^1EwucixKY6GDo4?P9)dKk?$0PK>C=>uIllEY~kB6bul{U3f%HQ=0Gf>JAl=
z7O4t}yKkpGwD-CdwldwAam{viUGAHuv8D$rUB5J}{dIN=pQ_B=lN){%I@>Ok(7hi2
z$63**M)x8I?~>|OETU!Ed#B!fX)?83RpO<PVbwY3C>;)4<KT~co%U)M9ru(yJ3KwZ
z#a&tNi&g7%T|0R<-xFLn8CB-YnI^RVPQhmBGyc6f%H_VD>E=Qb`#%&Yz7a7g_x}~b
zBffO;)Rz;kNJ|-7=-<|>U2L0Q%*5+;{Nyj+4OezaOnlwNps3H5WypIxJ70-g`kTuA
zThG7n>K9(9yg%#kf`0ZrA%UTr{lqHwH*t6DtQ5_T_b%LI8rb_UQ{iOpiBda-nHj7~
zJhN*TSQfS4?+iH|8q%*HzT^jE(0^5X`AI9jiQSh;zj65V>2N9K>(5`TZnGELpL>19
z$JvKe6;rgBJkk|j%{+a|>GUJDO%Fq=?|=R=XTg(-lz6X}>OEdBHkcNDlh%@p_!FF}
zrmp5XEmOfF^5BAcXPp|aBl=5iJzNSDZj@BSXiWV$N$T|X)tm_$3G2g!?(tqcdZ0_>
z`3H?7tM4gKv)ib6Lq6=yBlkW3x4m-M6KHMwZ?$Qr!QD#%JLmYCEaGA>t2ox-Q?T;u
zdhyQn)74&?q@M^qVY%dD{A(6z8@}sz=D*%nb8@5P&3>Vb*7TT`um@}84ynmFzViLG
z{p*~>#g!9WPSxeT`e487^3*<u(39PN^Sq^&YpcaPWc%GV(dWYp(UUJU&Gwp1@Rhu>
zG;q$7?Mu`*cZ)ysnPd6Mq)9isv46tNy+?O%SJG=~4mV=zXkX^H|B&<BL?1iFCmq+q
zTn&<<Dqm@QYkX$7>dCz$F8{=K-rcU#sph9CZ}KYJ;`=d+n0dnQ^J=!N+&25r@uiN2
zS%=y8DfcUAWtBY33Vy(@eQ|g99f1|%YHPbJ4BWJ4mX)mP4U&De`;}?oyJ!1XH)Tbp
zU4D9Q9j9&Z1m>>F4z=Z1t>&GqjhrKK;dGlE^RFJO?=O!g81_93DeSzZKlK8ConGTd
zE5FmLcrNcq_{F`CVTF6aL;*+1dH*xo_$;a|AG}%fFh(%d=fdQC*-VLbC+u|&PtkP$
zm9VI%Pa|!L)0KA{CN^dZF=~6iwSN8cb@;8*b)82X+0~Wyt=q738|O0HD>K5*Dc?<E
zshslDSfu@#+#j{lmerv%CdHima3spHv24m|*LU5=I6mE2le77*hnG>>BhB`9mvHmD
zza*z_yqM0}>nOxD=U;r)k=GmbUdRc(zs~<O)LVVd+SDlSiyz`IhVDod^nd+BP{Sry
z)Bdse!L#>67R>qC9hJwO<8|$M?u1RRw!XOhpKr!W!7{cWapjv{?=F9HuX$7z*%cRO
zqSdgzFhqD!#<ov?MSs3{#l48TxIgvK|BmxZ6+X-`Jlp!#$R_iCgSbiOC5zBk2T$$m
z+az!)_gG4i+Pn4M!CyIY55`S7UG`y@nk(m_Co3fGcsI^**>NQN;=5TJ+Bs$&;+ATC
zTv5<c(DL!d>*otU$O=#8Ji`9%xJzY%o$+E%&r^M-o#*^|4C+%3$|YU6JA3=}J#Tf+
z{?^XaO?dh!Oi#QvNqtAP@8NTaR&ROII=3<$5z#r?uVzr3e&0HAviNlQt<V1bDSO)e
zMA<N>&-uM;y@8kKwfD@Ll_~25zoxF!uIrro`R(?+<psL+8-ML_-|fHSI@9k1vTnv*
z>Mgcu2fsV*<NdNO-`Draetq6!2a8x<+NT-_dD*R36KkkDzl_0m%CFA5U5R%+{W*);
zmO5Il3yV9|Q!}MaK6KiuFvGNqE4N?1^IK+O*&Z`i$MlnDCAu7qVnXyqzMp%??s?tb
zs%G-+sysC_tNEwP%Y9U?UXPqBA7OA|y|Y@7eE;O=pmMujrjkh+f-Y>YgQn`Y@>X$A
zi55}&9xHTxl}GoSorytVYnqK__#`b(owob$-=7=amzFN*JeJS4C+J(i!KRW~a~^m8
zzO>=;BA+v@p=%nu<MfQBEA_lN()Q%mG^wTQYxdO2KIF`t+RC%#`ogU`JC|}w2e(Ds
zHVOV&chP=NC+mcIj^rBAFSj4K+yB;nW}yDiN2%9zVbH@(hH4AWOI$o~@U`hJh2=T3
zCb8EltNsy7tKZP0w7z@({p8&d2i!CYWon+DjoJ}&bNYd2eA*4R@t@v4S=}wa_S@_8
zt~;GxFWQnF?EaVGze(P|yoYmd%nR9etmgH!*lTAlD0Ha=$mt#Z$X%5GKce~GJPrd#
z>!0&Kby?edk9&B$)OJU_e}V(UF>aFp;UiM|CXafYl0Peaws|`<^x2zL<!hEcHw?a|
ztGl?vKrY4QMBA!+KMbrE=b89L&$eq&|6;u)TEgtK?AFP>Uusj&_=bF(_^-lWLn?2^
z%*l2$Sh{{rxpy~0wDw<Q`@X=>Cq4dGelB5L-qWYXb93LOqC%m$Q_opi7XEpdd3oM%
z<yW!)Y;xxujF35YhWU}_%fn(WW|?a?I8K-#bTfbZ-Up{*_&<84?C;pO@{;N7temNW
zt5)YX2BlvVFyH5KLUP91fGg#b<Mys}H9GZmdRp+WBFomQGoE`N=`FKQotU51=CApz
zOmE-KTfW6s8(*EQ;l1J0nH9?_`PxcTfmhfpZSl+I(~az*Ppl?9U8USM<8IPJt($YF
zul~Ml>Vv~KD`X@OJDL_PC{T2g4-;Lq<iMeCuMYBQU%loPcp+xhH(_nbY8AQPQ!_7?
z1|<1;+ArB|QD3+B<oe@R%7u0Wt)JT-sdz;4y+Pr(V((KQa%~Nsr`~&~)c9fDvbQc5
zr?ph2X&V2G`C1uPv(DCgzM{yNf7?H8wdB3p`J21?h)ZOD%bK(UJM{dg-{rU4utE5F
zgi5->q>KkAZ*a!%U4HOO<cC#B1+Ox0C05QcogVg3FtX}yiOm(Bl1GO;?tVyEy<(Y2
z>49Ze^K<UrH*$?q`g7<kyY)+^t8>boLSM9tDXa*5((y_;NcDKe&iOM%W1m>&O?NoP
z|M*Gg`nyUJNe-6Jb$Ra2Kk(qmcbPhm5L5mqKTlt{a(d#1%=o_Qk_88wPprQ4e$mf6
z-<Ry_V-}YD_}+*8i$p?~%O=;L>J<(*L?*Ofti7I9eyxF3wa?sCZ^jF@J4HGx&&O>M
z^XYtEd-Qb7Q}-+emO5>o*w+hPF7FH1E#E1>VTZG}=)7CEm{Ssr_!MI%elWaSzIsJ*
z^oOIHmfhZSxFpLZ_F!(nm4+$I?vEGoa$K6MC|-MN%Brcke|cuVz8tr;>Syu#$)$(Q
zU$@7vT*ck{=ec#m>WkAXCDNBI+a&j<g!{$3Q2j%5OLx{(ow*Um&ckP#>0-1qCnYD=
ztEIJQ&R*%ubuBV6C$#PUm24JE66u(~Rr)rwl6OdZ3Co>BadBE%$Mcj|Jns~~buT}%
ztlc|j9=G|!up*U<qI!7~Cx1+vSnADm&LYY5meciZZx4Ddp2ZlI7MHCpv+2af(qMM8
z)yK~q59a@nwKjKJR(6r@{>7QI3>BF>nZ)OLeLOT-DrdIuwivw+tMAu1^jD_Vyz13p
z%<9W8-psLeLFLNAsq?Stb{$}?^m?a$oIzvtx#VXm2lxEso*_5;o5zvUH79gE8=Mm-
zs$1T8?<8ipSD>rVFTOuW;f7<@&cKXc`&Ry!Xnt$X`qC|0+b=XUd*%db$;Y<a63_2H
z77^O)`7QcU@?-xvOR3BU_FjxDG9?;%-Rp`A_BgJrH&=fuAlBJ(_V#X*!b28JSJijC
zzA|h1)sSCqO9CG5vhiPEmYB$qyyE_Z!!kmFl}8jz7ukM)5L@n`{#2TOa(14?`!)KC
zqT4qmzS%NKFj+7<h247j{RIj0|IcH3>=&yWcRHkgvrc|cn^b|s&V+5X`<6r<+^#fL
zPbEd?cW|(5<?FMjA0#Y&wD+Xa{d4u7cL%QJ%f52(TFQ)kl_yKi=L<$&77@ML&cvc#
zZTzbA$yA>8TUIZ#X8&lY{52?YW4^%Z>z5YZTXk%;d9!iLDgCYMe{y$faJxTLp2sYi
zbSO7Jkdv$L@t<Ay7tK^}>56Y`u1T<Z<!*leg_BoE>E|3donPu*i|!j5G%w#E+^guk
z%fox_1fDFPXZowG&8M{`WR}M<72Nlm^WJ}&UafXz<?H|xMbTu}sZ}O>Cboqy_0{WH
zy6VW%iL3lhTAsWa`}DSSz^W8q2k8g5QqPH`794qIJV&ZW^6903m+V>sEX+qA?R}6l
zIbp|&O>fQ!KhS(F>lX2AyH|ztw>9^cIeP_^-{r^_d|P#`p-Z@N!OhHsLpn7Kfft_(
zpE0(VeRU@?rzW*zTV8<U=MVP{+?JY`$(@gT(EW7l?ATwNb)U`{`0+(=;$Gg|ux0kr
z&%QC=?q|<RTC`}s_ml7QZI4I9@OYmpT=_M^y{x3J{FTAEHHSPo@2<~%TyMwpDAn!i
zZd0=&c_pRIxmIfX3l?`-UsUHQ39?(G_<ED3!kwI*4qtbkGhXOF<(tWB<qvP?AGJ4E
z>i(Fh_Nu%4`VPbOjgHTi&xo$r^Mb2_eP8dNfOAWy3STbh+J2JJljok|>;nR~wr8$v
zb6*nJu-B$`no@x3D!D6@997gp{~jp~T=MnWHY;AEViWs-TA8|e+YbAv+r*hK-?waq
zokmHsZ0LrfZ#Q@NZaZ`N^!`@q@)Kt_DxMeL7~1i8kJR_MG1HGd4ZYZ7KUrs4R?+8x
z#XgDCW>pJK)Hv(1$opx8RIWJJ(Wx7+&ncFFpJMlYIoq)pN{156-sY`)?svdt+oY>b
zYXT=5PoB5(u*(jq_ZpHdKb}`JChoMJ7<(;e%d$iFBilJdJ;Xk>Tq^VOUYWYoQq9B0
z;M7LTxfK`Ao<G93x7jne!1M6wc(thpYr@!4x_<B29AbK<Yww1L{<0Tu7JCW_X=vqN
zTd%~+zJF<O-omWU)@KEN*H+h-%7%%pweRqG-6d->>+!Eb_Fs$VKeUe6u`@|=G56j(
zK8z<1s;-|b{e2#@bM2=OFK#*g@R=eh|Ba99(WR;?;d4tbsdi0fnRn)=i1EtyU&3|z
zYC+<M1za?nb|x1!=-RL4KJ}s@r&i!yW_6s~a?5)%YgY<Snk4@(spJ27H<Q|3YRQ(V
z-g#B!#)X%>=4^RmzAog-hktpykJuVy>U@n|w<4pY{$7CA){CO|Vy5n4T6T5rKOWxd
zP(I%MGQBa;*Mfp7e{Av)_AIxq{qP|E`w^Y_Qd!e@H!g~wwCuyAb)O>6dEeRRWRzUd
zeZb=00z0vT8`R5|FSSd)&e5{Vr;)>O_wL6noa<UIRz*9PcD~uXP=!mBHB;r{ubC+<
zaymx;K1GQq7&NS(U~R(NC-t1eY`X3JH|L|;PE4%|Q~Y{u<vZK+O^;jd+z`sSwX&$Y
zWZCAwf#U4EVpa=OBh3D#@jrew<@guv%KR3=gGD<_w}@@fYUR<M#%|7eS64?wNGN2<
zx~1FCvNdw~UOo3na_wS`_L*DTWX_pSFv^biQCcKE+xJJ+*HgFN-Z?i#XMd2D$LzAT
zn>^kfsuB?pu@YwN`*J8<bN1WNN9q%cPZg{dP`IF_A#_%myXfJih?$eF98t5{V0=sW
zyIw+M;PD07QSs;PcTW4;(V%FX{ovPK^X#>z$7P&6YF2f9jlJwX=Z*BE>X64wp#}d$
zw4ckq-+U!KLi6gUi~DkHZ(aABD8J*PXIs`+#dg+7NB7q^dKGLpJFWIzZ|iDvMP0Kc
z<p-52Bwzh!J9*)2$Bt7Kzdk8{%jUN0n(_Xoj^*6EpI*Iz35zE43ro4&R{Xkb+6#+K
z+g)>R6(8K4mU2A#P{FlY{yRd6%_j5CyPW!E*ch_<iOZw&*`IF4pZojs_V@daR}z~7
z{cR<6GT*HTF>b$dRdxBPpt8*Fg-iA4@f^0i_1XCZ=f;Dll@fl(eX$g3U{_2$l92ve
zqx!uD>l~&HlcJU5Z?s)Fmd|l9H}HUjzwQUVbtSKC_j|J2P2YT=OK;mw4TA$t8M!R)
z?A8f?bXBX5;yANO`4^w_L_?9JuI2Ubot5)cRIdKC%lx!5teA)YS>G?I$;S^ox5>Lv
z{WM#(<X7%bo;%kswanOi@@c$!XzX)C3q^w+Nv=^U7bCR4vP^q?kx}sZE%h@^YG=ES
zYUm%|s`+Cw=Vskdj{xzM&ifZv8aB=P&bQKST6EmH>zn+ImMUIOIJnT0&+TjEQCr6Y
z%&iqSWFMI{>rCn1b8WZcorB+&FaNbYqO9~)VDJ;)AIil^4Guqa=UkG1sK$PDe+Ju@
zr^|i{-cYx#n?F~Je@94Hvhf1bRqhIR(;^l;DSN+-Gx~dElfCQyy$bVAnAyo)t10~v
zd3Bk$y6LqotsgFY+I#iHr>9<V*5B2inApxb=vl8U)@T})I(e4u=YHMo9<$i~ysG(W
z;yg)q8E*!AR(tzpQOh2$NUMsXX}9iAU~l%*ie3NgTclsY1=&majbafOB=#BzUNmg1
zIleTzciCnSn*_ndi?2?8Fn8kBH|PC+r&d2dzQx^tpJk;Kv$No&E{^vNUami1Z`i8l
z;_>W$c#(~bBKv8%X^k!S8)q!H^EX!3{W~cz^Qhd8TXzjkn?%Py+Ffw)=9&+Y^Ve7$
zc>l^><<PSui|SigkJO59@8*aU{ru(q*Ybeu?&5blUNuO&XP!K?^CR~rpTL9c6T;LM
z-(7!(d;6w;)0UPnEj9CrP?Y9O{Gh`y;mQHMHE!!$8bucCn|_`ua6wS?O2gcQo!oi%
z4qfV7m3LxU|Mm61W9{2*p1%@UWU){5ck-oDgNZ`x?|oI!iJTU9V0H6@47pcxPieT{
zxqe*q+_mFTiVqKFOZ;=`c=bInBQxP@v{mg?%Z{^7n+|1_GwSv|RujsRWP1ITfp^-S
z%q1zm9jkKRu%&btbn*qpa>hFIJZ@Ez);=j{=3#X8&nbzx-n;&@`Yzqt`(EYT!S%PD
zZ<{Q<v@mEc+rsar)0}LM9QyXx&u;dn-B*_u-Adu`R9sioBv*OO?#$;8OT!=k*&DLt
zLch>ox#{}*!#A?*JAOf9@>=V>T_>mVNtK2_v#8#_-+cMDL({sNkI#GJ@k_M+TT<2I
zEhU}eQ4+3?HmBru+(=(FdroDRcjwXVvwC}Xc$Qzv=vjYti)BJn<HD2+vnRfu?Zl@y
z&3uV>-TGq3W&7<9hqN_uik3wu)pC{ITcoblp(ydid)odj6~}({?w2*!pH-p1wZ%N=
zxl`7xGqQpHLQ02Or`Io!T>qQ%R95z-=1a4d`+53t97!!)oZYl@>bK1WA1%T-Z}ao=
zuXA*M_O+OKPe<R+O`N61+ulD9^;&$(U3Yr&Wy#k)eA1%TOskmPdrha@{2pRm;ifT9
zP+Rop(#twquAJbwVEn?Q-DiGxP5Jwd+`VP*W}nFmf5+pd-l;DlwQE|{i8|p^5!Ltn
zI<6OAo;%^>TfHit!%0=?0ggIp3woySmAS#!lT(}dVS{!JZ{-@ELYE73XGp%<uu`%}
zaGlzn2fMdj^}O~h?fLYUD}C9%g%bSz>)ItHO&{MWePp^W!}M%_=BF7Cg64Rnt<br}
z@v88QkDTy?ORJU3x|{k14Vkt~bDi*w?eV?i$)1}|f7`ieQQ-Aht@BcU6t0~qIUZ2|
z$EJ5$vHqLIeY-q6WB3<xmg)aoanAE)eRWgQoBD)m_H^#7<^I~IRxaqjY;<6L#Ib`%
z_ZrtV^s4MA*wt(r)O&gIg~c_hb31J|AB%}kiVrD$E@@L(@PEQNbN0=TkF3wXWfSv7
z_@Bb#zu&V`7X8);mHOhhD^=3V+xEUu;1Lb?h{@K;%<sC^toYY?R<x+}hwHAsc`AVc
zito!?&5GPU<lN$|QoJfDxzcw|aeLC86MvptazAF<xR*6A@pQ)Xx+S6$uktP|v1j?v
zb=d#sp3@IYcQ@?l`Juo4$jl89ac?rFX3yBslKtbF(_-u6XO(#Mo^kwnA%1hh9g_!Z
zcC0bKeEU|`m*jk_WUhs-CH_~}1f<mHd!0P_x6L?6IPSFF&gD-x85b#Sa2GfBJbk0e
zbY;|Q-7EH2*4=rR>(3^C#cQjIc}>ZVPWf$BYZ$Js{v-Xiq^2;*n*IE@EM}AEZVs}0
zr+#x<chU2768H2!>DN7N>{sj*>6#YODi|A|^5eJ2N9C+rUwV(Qte@~i=68J5#p_4!
zW@PZ0|Fe&?D{NV3aK~FEx^g|sWY5~yye45^{(khnkRCO2=~nNSB1XB@bITN`CTe|b
zS*EZ4)8%E1@xhZ9|8>jW$YtQ0@>iz)jLWq352Szoewe)DW%shLj6SLfOD=sC-gCg@
zi*988=_TJk8}!F;o<4tMOVYfq)rl6oOXR)d?<MDN@AGEQ2vJL%KXb0{k$8E|GY1X#
zEAw4^efW#~irKs@BJ*O-a@418&el8Rd-2{Emnv0RORmcJ7iz6Jtlu}?I$U+9OCa_d
zyQ+c3<|9VQo%^*X-!D8Z9@!RbIwfn}le{;|&Zb@qANVKjKgXZ<>{I1ZzBGopIctMl
z`1QX;FWX)E$=_sp)9x#G6Be(ti!!?P&ABG1XU~_jYx(pgq8E!*FmcbWd#u^<N^wfU
z#U+0KZf#6S+0Qdo^uqogshRH=$RC{HAEJ<L)8XFi82w_pu882)1Ld`<R+Xkkx_57Q
z{MdI~<xIy>g;np$c`Gs#_SFPN{`={cmL|K@e3s#|trC2W?pL2_7Ut~HVPZ7f7L)s&
z@g&1+R{52Yg4++Wh%Ve?f8fOPIfuDI7wn$*%<@$0oyz9@e@(U(&lX<7XP7EAo%@ev
zX=m1ak<b_0x+Zn~^f+{PgX8J1FJy1`IXHEmk+7F|@p@Ic{Iq^y(@$YGz1M|WYZrO_
zejp*$T~%?B^~2`Ai#)r{!i3(o9w^-7bj0X$dFHp9uS2{qPyBXa_eopjRgZ6|7>aE*
z(AZ$0T6EdK!si|Dg-(CrYswt^rRH(3{58!*_s_@va{?`$u20r%wPT(6#5&J*g`o9K
z{n(vxF`Nkog~_|UZag!(wWvzG^sj}%#UB^0F+aMz)VFF%<OC}nOVzR*X%@3+`R#jj
z{S$JmT&t31RO%fRUlw5Dxic|dJelK$-=B(*-jjXjeoZ^Py6}-y<-;<WshccoY@_84
zZD=lCGR?)zEJro!xaH;A561Cxxu39pD*NTacy^t5Xu+MMl5102gtsRAVGl7}>L1wq
z&*}UWr9_Km3!*lzT=^=aa6Jc~mQlg_u48xiNIbTg_M~o;pT_#N%R@D)Rg`Z2**$ZE
znq}T&(|w+aYZK=^iQCi9WajsLic&h)q3sdrpKE)v|E9_9@iR|MF8{**cMGe}9BUgV
z!Bg5y2Md^Po9M(a{8)4AebD-&IpH$1zt5bfviDEv7Y><z$G{ZzE2|#fKeYLnw0XEx
zk<>lbFCLZ(cT_Cwj$U0Y@G;`wm)-AlV~-e#8yxtOwq9h3^Wrxlx~Xk~OH6-#$rXvS
z(q6hE^WWs~hBsk)HoIr5XzqW{wEFMmiw{)`-4|wy&SKlMVY>8+)GzsaGP4Y8ekfPX
z`(UKPTwJPo#<cfvz^xKa=M=eZx9?w!mHxt9%R94l+v%>X0?F(LmOWRjqW|@9|2uba
zz1e%ETPEv+{4FQ1DcQUrZ8v+iK*56D9H-Zd9xD!*R3*0JiPx!>F1lCF7I2AdG&B{T
zsLXm*b$5r8(~~uKc0@McZ|eV~#Ax*Rsg_W+rROZQO|#yeIP9)9-{p<%zAJZMX7}x1
zUOVyrzRcKP>l*5%*NL4MQD)I$yS20UT=djGJhzo+^v>x!;j&YJlYQl{!kGm}+ht#5
zzrK{~bc5|=pJs*sneSCc5?lJVUDoZ3sGD+$>wap^mi7a`JJ}p{`K9MDh5ifX=rrE>
zuqXNH@+mi_D#^_}Yp~P!p30#v?pmhuPrD9t@ccirZr^(i(StQn>>ual%DgvJpZ)Vx
zDDNCre-7SlswttNyGs8kA1eKJefhu4?>U*vvKD^)(rwFUo!`YL{-8J3D6(t)d@r@H
z6(Q@4wWAp4F6NGz{<Y_5$?DL9A6{w{cm=p@sIrV%+h=?DgPrk_NRNA)Hw2gX&OQE2
zYuSTDLzifU8N6yKs~;UUs%D73|0Q-&(^psP_s>;$YxkB$Y-Q9cnP~IlMdHr)L0jg#
z&Irvu_fb^Q^y9)uYi-_dQfRK{i%gJ7oZY(7OYQD8zDu|24`;2vrgM-fcP>};wP=ft
zHQO()JH6ht@@l%D&JKY{ma~?zufIq1G^?#yUmxdbuKU>KgiOaz)@-dkGm|X>=Nu7E
z->`3`0n2LTv)q=!p<>>f_;1g@_B?0hm4fxf3W@=$Hmj~_=dAZC)_S*K^`V~0A#;zr
zSUz`ie`{RFteYjgQ}9#V`-WZrF9-Xvnrxoq7$0{pCm@0~y?V9C%nv)4pZM*)jU!T1
zGA?tawT08<{okLfN7SEs-Rvm&XgZH~u>2gJBl^MpY<pJ5UFKBEfAQ#o5m(CfS3w4K
zp*tRX*nGS^^X9KptC?;_++6>Z!Fs9_BljkcO}pYYhRO-Q+ZU30@nCi#-=m-3f0@>7
z4_X)X>5h|Z+N#$^=6PqeIX*Vd-*@kF&iBbT<XSgG?5>R6pKf>h$z{v9!u(fmldnyh
zIVGrI$F5hK7L+>5W)(g>ze1}agZsk~qpNGTiM598ZjQD4UFTW<AttId`+|sTtDMw|
zfaAVhCMWkfB)m*AX>wkBbIrUj{}Y|J+1&Rqu5{jizSBzEVN33g&nsPgnM#dxD*pQV
zYnnJ;kpEde{j~0j?q}0e6W@K&_s;81;*08z6908%M!NT(eY%IelZ!5IvRd=XsKaWd
zuFMx_HrI1z1uF3}e>SD8UUjqV`kI2)FM2I0R>uM?BewB39Ctd{b!6?ou!tKq&zG&#
zJskOT_P0(KlfsyuE)CDAyrq?MUhOK{!n(#V#q7YGCx!>5pTt_PWlIsbv*eape(oHW
z1f`AbK_R@NHLOnMci*nlz9*XKnxUe<+>keFmV82=T1=C3%uDIAbx!Xd$~hTV2dr{_
z!>e{;ovz2Tg8eU(<94jLQl{u-EKzxU&F+`$Irg0kYfat!UT#m(!qcreGtXI;Jlh-|
z61Mfr=a;Q_^Y33*y=!R^RBF}NwNuc)NK9nf_GF*T8rOM;?;qg1RPFP_`)trs)^i<f
z>MEK`%D?zNKl>o!Q=Ow_-S)L!{QH%I)+=6kJ8zjuyY~aPtm7GnUI!k3X0UaOy0Wg_
zRLlAHtuMFVD^;y%@sV(?c(%*Iw3094-QyQBUAwndY^wg|m0ouEV^`FryGN}XFET6*
zZ2uKfvXOt%XWL+bL-Uq@R6R5^<M4Bx$=k#V4!p=(>V3>6O*K-x_3D&&RUBTfcK27c
zUq3!aH}FL6FC*>!*8jG~pH3;b=C*J4rKMjzf@*Y@MNXZ=x6&x^&(_KgiJKu+vwtV`
zOj!InZ>{ZDwqWl0la^HNfA+VaGK1B1r^#0rl{qI^>gVg0mlyIVs1z?*?$nd>=)xl{
z|CyOhD_HdYblb4Iu+ClH(DP~UH=B1oj1DL3D-%jrES}nPuy(^e$+T1}DYx^{mo}$v
z`eGXJ)wpruXM;uQu^HK0DzC&wt+&aZCSG2uq!)X9*3Yz$r#3gRUf#?7dzRDBef181
z^S|Uhj=y>FsaN`?Ui*1dE~eMnOs&}L9xUrvdWh*zomb4c#BPh&X@cC=uE&2VRO_d6
zw=7?s$0)QW+-KIOvvGG$yS|&S@f#2G1V6?8X14F;Z;oI5dG+(9&Vqc&q{+)~X>YA6
zyEFCkN434l2`{IW#!O3$*gHMYoyCdOt^8VcNOntg!djPuccqFqPRsWxOX<6^W>eY0
z*C|4p-aT63aewcNujIHiZ$-yNYiozVxv~o#v_q$GtzWU0=V0vJ6U_oQH)`(<PyH;|
zZW?xZ<20?Xne~;;&UGhiX4<KoxVS4Y%;)q%pUS`gUR1m;o7QF{l9f{%pHL~WTvgX~
z_ImS9v3>JGj%ul8p7@w@+oQkazFy+voT3Zm%Xv>mDsB4kt4c_~cW-jwBca{qL0txU
zoWi#raP>xC*!1+u&b`~i?xZO1oH+Z15ohJb-wtOzB33s{bb04&vS6#9TI|_-6LLyh
zJ|u8$Vb47BYZH^?)xfpugfASPeDv8dBlgO#Q6Wh;jybL1DqHzug@2If;hGD(r{7ty
zc&^!XnHi6!Iej=$cRBw<>kFYNAFSgu>pLgib4;?0+qLYSf#m9qK75;2G8c1Snis}U
z;;^Fewx?a>vKznu73c*AxNBZn=>IvVQI7pb_4I8o7CJ2tkl9!mf9}k_a``t;cgLLQ
zi#uZE!1!NO#&E8%-JEAv?`8K&Y2})1^4ns1_QB3eJr{WGFLAg0YKm9zmA+)zcBa27
zWcu^V@77&DwD{t}{rdCvXSht+{^aH+?+No?CC!>C(-?3#=J(P`FL-s9<YiU<xn;g8
zqbVw9kMF{3&&2-7oXZQ{T&Q?F%h_7}sZ-U3CynNpIC^TQ27LXn{^+J_ca^M`94wr5
zQP4g|;rU*{^6KmN?oX<SIdE+X@1MRaA4}iv;F0$~UuWu;%-iE9tGjr9*pZ12Yc1t(
zgxqCaD|>9Jdy^{Ht<1<P`VChPH?2!N^EvL-zE9WMv(KkwyVn&xpR_z!?6AKChrrv0
zBQ7>;?0B+IJUH-qN73H1zuvABy|pJI=t2AaQ-)97gx@5mUzB^M_T86%*`ha>zL%x7
z79Pw$edmp1g<4JKubrw&e|Bj2eyP$uA11~6c8bK-^Q+@DWm}l;iOtbtSXggi5}sQ(
zr}h12$vELhuYak$*SGQCx$|G=GWipJQ9l<&JP3}Ay)JZiiJu)u(Witv@5RquT({-Z
z=VLMYTo2_AnWnFP6rg^NalPYCx#>60S7li_Zo0SH!#?tSWpnbSSx1+Ae)9a2Zq3Ux
z8@>3&e`vh7?QeN>_o2y#dEMtKH<Y<tSvBv*i+%NbmuO2H%WMtsVA}Ip{Ltd)G7p8f
zPhW9q>~9xr>2>_I|LIreqQ{qCrVIYoiP7wrtaPZ^r}f@Ar`%3Hi?jRG78$iE@1JiC
zzUUUnXKDL$L#)X+6<Kd3<GH;d{I>)CT@q(mR?4?tt#J3z*gUrT9PKOq_q5I9S>oRE
zjBVmA6Pq%XjRg_w1Do&9Qa;tu&!s-`{>&`~vGH-XCx7t>^IyGuT4`>+;MHulw{z3#
z<j*}QSGlSF#+l*D)&ogR4y*UO$NazZVcI97+j4E(8vHl!#w`#$sd6`3i9P*$%N4n0
zwypOLXl-$Sm*?lzY<yhmPtMar!fuv2MPHJiPkz_PZ^^5tb}%m9Z1X~|nzQ9kQfCxO
z+^c@R_4T32hxfWWItbi!=-C@(dQ-t)?)#UV)1SY{rA#>>HC=3awPmWJF`sx(=FN(=
zGxx<P&wI~Txi+=pp?SukmA59&RDY*u+cD|Ikpw<&quSL=C++=wzP)f#P2W1z!^^z5
z7B<Ll_q?AbA6XO=V9<NyLez9?*-1*?;(IzaIUNpNS7VxZd;a+eYG-1O#m+tHzLV2`
zX}!U@o$n8O&D(hWdp*-ht2;}tck7&r&#IXkF>~ri_l=)5&Umw{{=O=q|M0Q))pwmo
zBeDe8>?DtMv)EpZajUqtzWE{3hxo4*7fTMk@OfqM$ztb)HwpawcR7#dJ`ju1E?=)G
zC3|bRw+xr5ue4-e<AI31oJL1p%}qV}`TCWwCDVeH+CJa%zHa{WnCywKrqdHtbk$vg
zUf(QZ^Z#A>L|U`>_)^}URJpHuxfUMmDRJWej@>>t@nYQ!iI9WQ`O=xIY(p)T!xVmK
z#;kYd>Ab%CUR}HR-9FZ<&g+Cc7kxW^TqE<tlLrm<F-wvzHf6>aiOl=R_wkfp=`C^b
zty`Y7{EV7f+RkwLR2?I8TjZ((I+o^Y$9P`wgtR+#Pk+dKaBuXopgE;GTTegjk%`@F
z!5X~PKlN_ahwPWx384nv7PcAu`imSgxq|L66<sWhmOt+?EnH>(@)KS0D;-#3@{Hfb
zyc6GcCqO5uJ|^~(uB5T(^=(`q4hc<T|9;L_AWe$z#MwQwFW33COnW>1tZVG+)$y!8
zFTLd^PhH;5c6NEhZGH2fyVcbrT6R2{YI3M9aD7+Q=?y<6POsIu&^p)t#&fS(l~-@S
zZz<&};WFMRVABy37szB`>%#T!q_TOY{_-2Uw<@c)_2@9I-RR(c)}(UUPniyG>x{J>
zj?W&=-*#Vt<KV$H;kjbTza%v#NAb+qX=ufk-mofUeL-JrPsqZn9~U0x-P5==@#x>a
zwSQVBtV~TZskm=8DbvMzhh6B#p9^+O^D%sOE$e=0!Ge$)&k(I6H~0SyTH1Txa+%QP
ziBmtty_oQN`?n8W7Z0B6mb;|ZwrOJK(L16>TBi~$rpJjdKFQ6YtD{!E%J=*fZc*+~
z=I&aDC7W*+v;UHt{^XC>mg!TjDD3Jy`pI$6h8(_QLRWV$u8HDiID4idYiFl(;<l?(
zS7n^?*MG0`R%G^si>X1$vttvF#(c=tO|<24y=Zh~=LJ(Qy+a?5O;)<G>af%%rr&<5
zR)%ltH!Ex8R98PyKd8W!`#sBi@6FbiA~t6<cFW#h&dL5SSAx$YZ=aCx`dzgbz8`*N
zBOCU@<^44VVc-54rpD#^t9Pa>dd8Bya(B|4Z!GWK3^nu&U#;tvei9Mw8gl(sc3MY(
zhUcxcew{-Hv%a)Fw6R_mpEbp?nd8d5sb4D?{p<>7Ws79bC|n)s-!{jY>5vUaoc8|r
zn-V|ygsiyE|M<K<$3orjQ}-=mX#4oSG);1=^uIlC`;%V3@;tsV>4a&Y>F)!_pEFt%
z_`RFi`|f36@~e+)wf4ywwg0PotT2hA=fmf_0Rjuz*ySbaxP<=H6fC*FQgQtp^Z3Ud
zGSlWRE)|}?>Dv6QtjF0;+_$YL*rqGNFRT64f9v+0`ycLYvGlr`r{Tx)PG{jX^_7dS
zJ@@{*KzEXCug(VUhNC~umQApX`txqt<y~^uC0@x1dd9RZwfVBP^YzJFr&~Wy*f`%?
zKVY6VleUt5bht#}-UNoc>8a97uiH47y|}TG&0M(Pq3h|AgNv^Ixck1??B>BGk4knh
z@#TDpC>Q4FI?pt#EU%!pL|Si}dFRx)X-}UCZ%f}8pHa$h`ln#~zYlZyc>5-{UGcim
zcjd+7kI`O-R40jSk6W;0vgo1BMkcPOZYms_`su<+6Mo}DhS2ccw|4HBCc4itv^8OB
zy5^M<>tCXN?1mg?mHuw!oc!am-4#c<KVdy#3v1jz&V0D_uI{as2D+P6X59a^rR-(m
z)_Dp>ZsBaU?^@nfx|AO|zfH(ovFkkJkETTal`A_|rfIC4pIp-AEM!!1^Zc5FG0b`Q
zE&Bu)K6>GFxnTOtY@gE)jUVs(xF+S-7AO6x-_gcTO1jTS^hnxHyDs%x<;JCBS8I4V
zZ+*CMzSUG}ubS#c#%CWx&l#-GeWD<)Vb2wJWap+=ImgOwcQx4s99;J5*`|nhjS0KD
z->efgS+wq~)y#kbudoaD%}$|Hwgwz@mYcoE&O$P^dBgO|P2VQmdZekVKU*X~XFZQx
z`c4)78Hy50ljYs->938s;MDu&@`9q*3boB*KSC!5W@~pStmtI>{p^5z@V@2~x!w)=
zX>)ilYF*Gv^kH2XUZA<Ba&?Z>`XwS7O3R{~i`N_02`ufqW;8FMJMNxp`u6Q&zlyIt
zog46AwT^Ye4i%?!6Th}Bt$#Sx==f)gT@$^pElFVe8NuUj;-AwISa7`g*MoEVTeo_u
z#y#3{g-I;w%jN2QzeIjyemGUkc<-d^mrjF=n-?w@bBVl{wB^59p7h<gv=g<;Jzm!{
zm?S6L+}UQcZ-K*>E7hBtbX%9Dh~3^df47zHv6RT)-rue*Uu-V@D~LV(#KNbmRdkP@
ztJLVq?pCO+@m-}=>HD#?%7I<8{A`ezVBW&DbKGt*zwPx{@JU~1#mq%wchr1Sbu9W!
zV!!e|eSFEtYMtNq?NZyX+`P=`)A=A?+vN4+M?QUzwwK3qSZvzew{hw{wxkg20}Hla
zke+-sed4aIeInZ;zqxIFchgr=<we^kmJ0#-{Y8nP&Lzojn6AGopL6ImJA;eL0ydfH
z8#ZS@ezmcr^=4?1oLX5CV@2?ddu7bUpXP6qa=m1&VtxGM6#YA`-2J_6?!8HJY?m7M
z9GxMflYi>|W^PHjdFOWP3g+dWy!1>X_?d}+gYYVW$wi#Eqqf#eOWgUvtaT5E_pznv
zY13lGbM2!wDkl8mTsn92oSaE>^1?b!WVcpL?!Cqpv`Tu4Mg8`?nyLR&{cN`683Z*Q
zm#vFZQ*sM2OW$PN6YqWbr|&lD^@Wq3h_n7a+T87MY_jgcWs6Qce7y10joc8go=*x>
z%xV@!_AH8%`(AdQYt|%z7(4f6%#~cHxBm2J__QxP!0t;bv!?ZyV^;TA<1LiJKA)W>
z_>|YKSIpM=c4_3Sj+)?WYj@>cI^`7is!DLnf!O#jv1>w}n@!6;_Sf*mOSRV`mSU#s
zH?YemoUhK>wfoDt^)tPLSM7B*e%bg;n#bbVEY+;_nH8>qJ2@OO6^(X<C|qyb6M0`d
zM|<n!?DBl;NoBHmA}l2@ZH}C`Vf5PEyj5!H#bR}l;M6V$_J$K7vd8$YbtOtq^fXFc
zw=}clyQTI*$*b2RzPvD0lMvhfF>YnS@iXNsyH!7x=WVZg+9MtoebiJ}qoqZ$?~{te
zl6#K~cZ=^&58?g$@W}P_n!ri-zolrJ&Z`mCKB{JwzI9>swLK9o%a3Hf*ulIu_vGu1
z_rK3S8}PZ(spi<6U7oH@J=PtP>An*}_WP|?<K^5f%H&)3uVxz8KF`@dA5|RFSMf><
zT5I3YYFb#pu_ZHh*P18Go?5n4aQ<9#df7FzyKiqfuk#5Cayt9(wO#Y?;($w@({`0*
zo6ZW_XrZIL+{A-r>BG2`ALm;Xb6(A2u-I_%T(rQE?~6S42W6BMm~Jv<HjA5Yx+Yxu
z&^Oaka|@1=3zKEFMKzoM#D8pM(>D9%zhz1P{_>oAlP~X&Fcth+{cqB&hgK}&Ce63H
zr;0Dw+}SDi<-+3`_up<&T<c)7;?d-=L+M2ybtg>U{3As1vs$+58WD}Q`WmUUX%lo>
z{akm6oSa_0KvHCW{b}y1J&R)wl<e*Q<L9J%hWTLKhZC>fTrl*@a9?~;?c7yE26bJ@
z*Ha7`Hhn*#zJ96R;s+Mn0{ho%28b1!F&@*n{wve&{apviv+R#rLY6(>eeuGE-AQk*
z{!&<?5y4iWD=V?#+3W9R5@q&tXJ4|`O1~v@=E(7OfBUGVYt}ff&iNR^wC~r-K7pHd
z7EV657q>J?zL=Ewn@f=YW&N|KroAUZem?Y)XM3l!@6#gL>wWgAvtNA)ig2CvYL#7i
zz;oqQBClpAHJn(rlgsgcZpywF?`&^chwoUF8^|saS$-vKp-;k$d&lp;e7ky**)Nmy
z*>4wA_e@RhIB<2@0g=}gHk0ZOzTD~XNOfn*-`uSByPe;jiMe0%Vzqw%Bl=ZHK*h(<
zBYP5ZZG$dJ*BM#btN6Qwsn1(cHSNac`ht_f{}gS`?R|1qa9a3(mLIcMWC*H@_EuHq
z$TKuuE{NODS9v*}&Cv0frGYzFb=F)(#;3iyqVpRz9R5F>Pbbaq$eah4724H0GVc1O
z*6f(W@n_Ecx2G2--eU`&B;)=kb?*&vBkncdxBSwN+ou}Ox9}CG!OerGU(etD?tAY}
zjpSD+1D4*Iyt`aqcty+QZJPRe7jgtOw+FaCaov%>W&05!eQA$3vNhYDKFDc(9oF&e
zPn|En`rCz)6Py-rnAT;r?ySqdS3NB~1?#rVPg0i&E}I)*os{<M+>U^Cv#siDU1}cf
zTA2{{Wbyf3t(}+es%azz>^pWv^w`gp&t851`_1E}dH=tV(zp4OCAZIHs=c;nw#Flk
zlFdt#*GQ*q-_zx5X7_8tUhRi`SB`o3cO1ySyCz<7al+SxsiFIRa2w3p6j|6IEj2fy
zBBjcrHEL2iuUDzxU8zb5wx{QRHV4i*w#seMzapjGhyJzjJ>l%%5r6dmoPaZv)(brT
zvo`T=^C`C``FOpJ7v~l261RG-%05f{!$qwbVP?r)J1Uq<{`_Y@|Ht_jwxbnHG0w&U
z9j#yjKS04q!O+CS*bH`_0?N?}re<cABpj_EbL&z=_oH{~5;r_}_fEiM$8Cn@!v`L`
zdv{QgQ>-a^!-KqovCakM*9&g`_W1Vm{_0)ZS2X>+RlW9|DXZ?%RczfYtT%X6xXVgX
zA10)Vvv_EFzbYzVx^Z)7#Lb(Qff<>mxiN1Y|4&?eA*)$I&n&_HV10y#ql3fs@R=qT
zzFrNGe8Uk?u$jG}fYG9Y)$#|+&6|vK-n?P@Z^+`z!g$G{T$;PVNZWz&4M&mV!l_Kw
zm5w=U*2Knt{_|Y9;ocm^1Bwa<j{n(i?Qn>ZWuqax71NZ)b=MTyulGE2sBU1pafj{6
ztFQKoFIv~e#?EEAdBeuWCZdr~Z%snSR1Ie11BZ`Ym0G}8#OQd(QLJHq6x#|0S%?35
zy`rsR3o>&bf6{MdyK(6%GY2DM9P2l;XA17q!^O?rxdm80%#vN8xSplrJxkG_=^HQY
z=b6Fy-%f^sUHf?b;lH<kuXix(tG8x8d-foopM$%;w7Yi0(q3DR4{>3gSFc{4D#=i?
z<;Q7(jQ31+U)gst=e}u7ThCTMosZ>&*9yjl^|JqV+lv=>^iE#Qy}G;iZ@lfMzoO5+
z&PbKfU2=erPr*H0e9Hb;leaZCoQXewxBKn=>DkXYz7>4=$sc*kA}ZqF)wb5z!n3C>
z?%gcy5%=r9*?OfZ_D0$hv>V#z&YjyI&cIN_)?jmX?ahB)3tm2D`4xTg<Mba}+3n@k
zHwYj2w3T<l{9e@;U-`TGxi84F6twPW{8RI9<&Su$hYuJcZp_%tbjBgftWTqU(f%&S
zY5yNx|J{D0f{Euw{PBL~1OKj{ueX=n>o<e-#>IQD`+wdKKeJ4Ky~1j>(_h|C`@ee1
z6qahHnuv-W3_5dcWElAP^cWfB`K=GUuYbIPDfeG2`)~R9N_TGqhX?Ub_szRp?^X8y
zJI{sx)s7Mj|E0ZI|5)u*VE8-V(LCjOqIvz_qaXiQ-uYkl^S}Aide@)zvS0p3Ph2y5
z@8A1Xzv?Cb{D0BNXZ9`b|F(*`G3M8=>jtpxf7kT*zv)%RzuBd#2fvB^4_ANBRdbh>
z(_Q=bf4RlI-D`T)PdHsYcJ<D$_{X30cV3I{PRoDH5yZOt#-FcS7$Pig-2C7Fu5|aA
zw{i3Nr(d7>Cz`b?cHVzq&Bqyh+kRx9wy3ONbl_ll(R%2gmDd~_8wUBl>!n*5D*xFY
zWiShK-|%`h_k*pL_6@2MO`op!e)`04L*<{)-|h;=oJsW^{0G#&w*O$vxm54La6s*I
z{G(*{4JZF8`Z3(zZGVI{Ve)_H^*=@aU&v;AYX4=H<J0{|{!0aa<u7Eoapm8IY__i;
z!N>fC%r{K_do!&M{PO=ow%r5ys<#LK?EiB8<>tsg%<;xe{~Fh8>i+LufBQ&U=Hq|v
z=RZ%Edc*d!{qX9}tM(tZ>b$Oh@Y?dmALe-O&A-|A&1?B<|6yxDyZwoeQ7ayUm>=pV
z{=WL{tMqgESJzL?`L`lI|HjMGw+H^enDTh*mU@wMAERcSo_{QEs^0qii}GKyS+3i^
zy8dL{HGvEEevh_Vh4X)~mx-$`{>{Gc+p~ZCHEXXw<}cb;^<P=?d3MG6{U7U>-Mhof
zR9XA`f8F%B@JIH4zKip6JmEBQkDS9io4fT^9e3{D)zcKdCft-0p1JJqwUY@6A0u0~
z?6gf#SY{Mb%kz(Q=R^<LSI44mPFc8LEPheNH_Mz=&OI4^VcC^mYK=UD=HJP4jGUqH
zLjHe|M&NDtKA&TYH1|FJ{pQVT*%bEMEO!?=%zpjmSpULV{ngJeYCn&>9lpy($Zq@E
zZNW!Zcl-*mIx4hWG+QFX#Cdl5x6ElBTnDGN%5(}oKO<cH>{ptUditMMC&f<Aqwh8P
zR$p+h?=}8cckOrjPPOIU>V~`<?F22~n4UZFBwGIDUK7?smGd91=j3{57_WP>_qmko
zZG*;hcTA_qb{|@L`0?w*F2B_rgO<*iJ^3N$vn=T?lbnBlld^p4VzF~;jcf3E88uc7
zy{xyp&$HY!6g8GtR80C?w(j_<If657<=@<IiM!mbxaGa;o26$z>j^yn{+;uO|HZ4d
z6`TV8Q4dT`7n{EL#8|aRe*57Mcjx}@?LTd)RBN{5(iLm5t8*HZq!+RMd$3{I89^rl
z+kb0}Z^U<gPEzOcjS@2FT%2JY^x1piVd=+9-JgD5SlMx7(#8+x_F71txwU8Wvu)8Y
znp{^hW*FI>4hvX#S}-r-qv5Ps!OHt@DLmcqe)1B@z8fApjY<qGzDUQ18VdYS)zzBc
z_oTYzYUstaT00*^+)X(dqVj5=>(nJj+3$P)ywo{)L-{eeiKk{vO?|A8mH9Hb&p$QB
z>Llyjz%|Ok(`C8Vu<ZFf)%eLF$yrBEIlG5^U9?a@sp?VD)CY`z&Sz#wD_*&|sQ1^l
zSo3Q?oxl1>M(wv<6?e`&aNes7q3u;_W<1wRLn4-Pz1+H-$3L{J>_pM+UHgj@lMkHt
z=!m^BJ7H(ZRE_r4X7{Eo+IGA;GOI##{rS=vYZLpw&EVQG(fa83`z!Kz)WTNpaC{~)
z#pTW#??>s)%h{G57yCSGcSw3tPxqe=sr|tR%FE6z$k`~;Uzu&#r?>y1*8Q*hZ`Opr
zaFlqocdZ(Sv31K0r$)o=cBf_;b>_dj8RHf3z;8;Nm(zUF9_2OqGG}*BIJ$U;&E!yS
z+p|ypw&-4;cAW3*1xbdB+WviFbJib{Hag#~Ho-;z<m1WL=kZpx&A)x_YGvlBFmtE%
z|1~afuU|jk_uYeRKMua$6`nj&T+_@;IKmsbzL%fzvAkjDw)>=Nnz>5dwh*V&Z3lGE
z99+7MZSVWqkM2>wEURSZ$6oB@<ke=8_4?nOm)WkQvG?>QHI~1fYcIs8+qzgKKbW~=
zhP>62<IPp}dll0PGd@e?*~Pqn6yknOxc9PTp3zel(VwT5I^?dga%l1Ye`x)a$6kvB
zFE2FL=<$%gsPLKHh_lJr*4z5=`m^Uu->t7O>DIh;>6cDuX6)3N##Y{4nSNhGGt__H
zm;Us}^ll#a`Dgd!uN6H|pBj9Red15%&G$bQ)^px$?Y|p8^VJLI6tT=SDZQ)HR88(b
zeD!#hoSNK&?XR7;+8H(4yKTrncz<evi`O64Gq=|9=j{o6DdRBzrGU+8ZKD%QB+qUX
zn6ts~`25pbYNu6&JiB8g`>-)YOErc|Od$7aon%eK>J0g>@xOEDbsMkG>5ADS*6N+9
znV__)D&T3m%I~F5mN|*kC8{%<Z&hS2l<u_NId#r`X_m#UN0vC0@YMU~wEOm`>74p=
zZvUknIRa7MTTaPKr(d1V=+|K2tJltYUS&#VjT)2U+|TPwFDjl+dtUcOm|bLv+SVs8
zR{4kQf0L3DnqyNprQSJI{#K&CVB;-Dm9<r-Gec!g-u9U_rAYt7)z~9Z%PzZ2-*;cz
zFy^Tq^TfD@B^lE%G^P7l)Q3*rEwZnbeY(*@9^Y^+>4j0xdJp;5L{=+Ldw8g4VxF8_
zVDYWlyH34X?pl59y|MC=rmB>$I*U^LoNLTi-k&;4{xzG}7khq>pV#?r#NUsf?*4d7
zL`qSOq-Y9v6+=Xz(PQ2PTh{(K`ZRGxui;!pu7b?p47Y->K6>+<@2S>nX|oGI7ihF<
zBrMoFXXdr?Q|B%&7kL%LtitzDa6<W={M?%g!kfM2oxhw6-6*kRweIs7_pD#ea@qBZ
zx#AL!(3P*5Eo+OHhS?h3(l{r-GgP%8*k;XHE2evQi*KIz(aLsRIzh}zrt<!>Rgdpq
zoZxSNQ0l~!qTdhNzFJkT-u&{;`{WG@+gU`JeV;rme>GWl&17%KY2qbo?=zS4&e<&8
zJt4yWtmnqv6EmOQpCrF^ukPKrv}rS3z9lS7dbDn7q^`)^tY4E9onkqK!c(p^W=`!~
zRn%%MnG~4eE$LvYEU(?6vE#~i4-4&$eIDL_#3o<RezmeFX43vwTV_6B`u#O{@|>Ut
zkA6F4Upzf0v*6CvFNt{{)hGF_P-R_c%&O+hKE;sBi1m?s+#>nAWk+^=Ear1$3gOVo
zU<iJ>Qm=WN@qu}!>)ZQTmhIedB5UdH_-`D`w5EhS)L)``EF)gL^XC_3@1u3gR&(*4
zTF|v)Q3~(z-}<$)|6M6$RJ+mh(Cx|m*SxvsG(Nr;b<4H;S0Hz;Ab>&R8k5fLBIUgj
zrtcOS{>fXE^JGh<ZA0&cme(eH_Yd7|-MHuLRgd1OY2`OV`L4{}oTo8e@@LzfDfhPb
zb<SYz`8D5W=ARIUx@la~#D$+(>bJOGb@^PTxyt%maj=nZa2$tD?(#>!*W9q{<*F{)
zeY<F*=)cMLU)w4id;Uo2V|V_#-I|AI=Y_p2Ffv-V=jhxJ*I6M+dzx&YoC#wv4nMGc
z&6bt(^=#)a;f%hv>}vd?N!+_lFG@4HpUD<DZP7o;DWiGbo+Z3fUvDsFxu-j4<<YI@
z>Y5_rPKrv}OMd#`vLq;9Z`Wh#mY2QP4IjK0(#Xpck(zw<r?pvXn8xH6c1EA~>poy!
z^ga5*AHV-IyRzP#TGlMQ<$>uv!3!6?Lt08A&;5<{z1W@@m?EO(<G$;v(-u}ACaZ``
z=gXpeR5x;_GA4Gdt_!F#^!}i`e_>hE@<(q2dJYFH3b-o!?`dw^M^ktEJ2kJay;prP
zqj6e5rsKs=w(8H$pIXps%CPs8&)l#iQE%B7OL>JR2v<LBTNZciiRkLgbbp0gKHI;&
zz5CJR)~W+32HsqUYmYCE=Ji@GEj+Jw?$NJe<$wQ`zZWW2o!*hsWbMn!!tD5?=)2*h
z<s0Tk7|zw0x?3W(=2+U7EYXVDmxWbNdwbuM+@@rBg=xh^5rb<tIyeia7?rcuI)6HF
z^~Ejg8yk8Jr1#aBy3W-VKJ@o#!TSjgKNni`CWvWO$6ZrS_#kq`Sv<c)Fkt!pl~%uw
zWeQl;)$Mzzy~Hagz*JDes>O2I6rbZv-nZI~^7{H?r8XCxR(&46g41`8_w=n(ra!ph
zX`7+LHQ8XQwfpqblm5!;6_^&dep`3f`RCrWq^VoFosMmg$}GO?9NxjN^eH)D_Oq<&
z$D-*=%?g8-cAZ|o^2c%RGYw@?Cnu=BzR{g3wW;#iSMQ5+=5kE({;)6Um(bPS{*OZ?
zjA!g@c%M2ac~ZpDsKqrUT&7=mm+L-ZzByT3^qI`6Pxivs^CRCDUrk$(+n$n{Tig};
zI>5p&YR_4VcCG9ZrtqmVWkjT%Xa8c?nYl9T#*RPSRjXU%@-O}Pbo0k9Etj@~I=f$O
zX}oBi-ItldHHkOnQJ?h%{XIf&e&4+|x8l_%rmL2-iZkpwzx>QMK9^C~s>;T}7av(Z
z;m*Dob&dTu%HAo7Jzt<ZLGGg3sY3!;?fZ0GPv!FLGG|lnn3=_~PL@lnVa}D`?ow?A
z@0rY4Hl1FORNP+A_4=-q1>Z9BkQm-IhmOcAJ@j3_b^ZC)5AqjmN&<o#C#bm;q`f^6
zc=Eh%xUTc(OF~J-ZGqZ_UQMqrgxGqdzGCfKcRVvB%4vGb=lR|7N-J|pA4ZqNCd{9z
zsKU)|6k6&&KW*x~72h=aC3HJyY|>n~Rb|nnWAz6X7<LyvEXk|-v~=$0pvh%>7&P@4
zyDFKlWG|GTAJ`t$eus-Q`OK&Nn^pf$dc7icA={qdy{0;bCZ^H%=PcdX*s;a9r%QEH
zt?EwE4)JqrkG--IWo7g}g>HKGX-bZer&-Rb)67QM+^h{DF1M!an4N#pcBAE*vM#>U
zbB*5wxn4TdpA^aPOJ?oE!qBz$_a*0qrRAPvN}O$a=jd{-oNv-LWy|-hn6JAjE@4-@
z|KW`pv2}kwoi}S?z3YD0SNh`d`FaaE^5PjRXYcRueY9@PkCvx-`KO+qsdW?juXba8
zdi=i&&zbH#ydRx2J$v4zzHK=>gAU}Kjn1^!k(t;oW|nK!nJ#F((@ZF7r;UokgwK~3
zR5E{Y-5txm_^kPjofqd;r6k*iFRf;EJSmsbvd-%3mBM`ov%TJZotz%CR(Z-4De<pD
zr>pXfSa|QBn%nnTWyi#*WVOw+SLceHx@fSpwk-dcjFad>j%lge4ZK+<naB(7?|HH&
zs_3+2|CHOc3%=icD=8Y|=y+<)|Gim9n1V8543s@(&G=`D9$tU4Qfi~zuF}LqlBfAQ
z>Ry<yEI;}0&iaqNA1=#T8eiCY<22i@XEjAEpLTa{d*?K*`^QPH)dtH8OrPcM+jRd>
z(MN^wzAbkbY|WgL$amzd)0gWzFRb;Q%(Bw+x2K35SH!gxqsw>RMX6S+J?lGk(d7TZ
zTDkgZjmFxgmY)xc@qRV5djEIH`S-y~mT$V-dy36D@_Y7LW!a)DeGb2cMWXyGm{;$T
zT=Uo<I_|%djOG=|KccJn<$K<~S-Nj-RifGY3zPmXOPH~sH0Q$1segaW<K^;~)V{o0
zDS;zD?fU<q`#az6Na;M}W@oR{@hrRV%7!$v#pxcI^Did9%#%7S+Um<^vPFA)UD+(N
zD?JkrmxWCDW)gDg((mI>792SBI*d(QWA=St4e>2H23%2pcd|{pI%`*ran2f*#Akvm
zhK?Rl1ryI~zgDyS&#9kx9<!&MxL3{8G+TM=>uvjG72aLHxhnkQl^2WTizc37vel0=
z^UaIi$EW?Z=KWd6uUg#tzI-e9Nj*O}Cqz8`^G2JH$yVRBH~+ZUX<||Tc>e~@m3Nn~
zX?mJhd2Xi9p1jVjA-W9aa_nUq{>GA*4bv0me3-RC_w|nm{T{x#d>dVT(`0*Yyt|h5
z!}qUUSjPvqxh0(a^Kx%=#m(QW>Y^97_Urd^VV?@88MFk=-?S{TL-0%3#ejfcFJ05J
z|LinReZX94TasjdQ@Ty_Ea!ht*V+iqKkT7pKUxx4SVNiWs{-pAd$-%Ru6`FQeM~>Z
zL-E5~o?O9QHoKQ7UE81)e9%F3O>4gDmO_~i(#7vMWVFNHCGBp!vuA6K<NLfx9DJJf
z@z++z*p}aXmcQq@nttBl=p6IkKR5kds>yfD)c@O|*GbFEe*gOOcIEk{?Xwss*KIk}
zUi19DhL7*-M=O@k=IcANKWD0Js?O7kG6CIJpPpE~<$>0#F9xfA?B4t?<Pb+UcbuJO
zk}LNlsjqbtm*~7z4iV%IInZx+cj@fu341rb{vsGA`^HcF_Oe9d)AyH{hOg)5iZ9Pu
z+LFw3bI*xW!UqmN?q3!Wc(BCy;-8WUM=v(Gef-uUDEGzn=#Siqv-iCJTB~vSv`n?9
zt>`KRt&&Bo3)vn;x<;DkFP(P$Yqi$QpT`+Kb#Cr<7QERa_pq)j=8PxvDg*yA8;v(-
z)32P#u9ctvV8^`Gp<LGjl(r=Qd&szpt@g>Tb%DYPYp1gAs`qwSbo1G~Mdy5OE(}{&
z{)6?4Z`~RGss0atnxFa9z<HsQ_mf`F-i*VS^N#NNndVrbZX-N<Z_2wR_Ht{=Z|I)(
z)63e;^~YVdCPwzNn8zWOcXbgWiEAPpwwrBsRoJ4~d*OOfxRLKyzbKp3e|j$$H@p}2
zvec`x3%pc%<<5$7#Y=Vvgq))nx=9^((&?7BELps`%P1qW#P8(oi~}#t&9&8nZnRvG
zDHfBE@VB4WU}PkreJ4aVzLl4+?bP1~Kbd}Jh|e-EXMTIb;;HnTMK83vY!c44xT^#g
z=GCybd@-98pl$ueI<;2JYv#v%yLTd73m#lD>~6auKS}h3wRLy+Y#|rHhn`16<{Kn`
z5Yqn{mm&DR*7$*p#>bt%?KbUwT$~!@E%w*y&bRqdyjCyQ8;7NwGCwS2zi(~ul9bf)
zyXhMGK1Vj$?4CDw=M!(&j_vbH&IEnCaZU7J$1CfWdxg`#|INAD+%b9A)Aj}LKe%YW
z&$?&xefRHIha{~}?A%|YF~z55;o+-iDyLPuhD?<#-tIUpJ+t7#FNJAwGb)mgNwxTN
zZrC{aU1L*r#Dy&ZP5xR3<ENiYQC}Q8H!9EDY4`Q38c|hOnfC7O6RPa9Eoe48@mBoL
zrted4iY1m7xS768lyu4e^y9Vp)EBSju-!WCnWU|<qT5kO_wM#<izn{s<bHp<TwnfL
zTFEhs?4Icz?}Qc_?s>YZZ$5*W*3RJM)br=#rsb+h>4$VL>R%JK%v@#Co}%3v=bPIn
zt<0atrd#4K^!nqv$FoaP|18L|lWT8%+fY&v<@2rR&D*P91(ov!a}FF`=qR7knl0?P
zBh6_3m&E%2cLElwMua*We3MZAB`I|I@#Mc@%ap<l?)$McNN)A7n&+w(8FN|Vee{g3
zNssM!Pl-)k8IhFyJd(r1;^Vub7617h=02;6So5{qVw-cIeu5@X#+{ZedsbVPct&?c
zRbA4*rKg|TYW(YNs>=+0pPLQ&XAPKMd_23&q@q1OYroLBtukK@KL~Frw|A45W?1;b
z#O3|Y6{@|J=aY;Mec042E;GF_#&q+Ao!4EIE}!LBHP3D^ZS78s41c03cVc<=gzh#`
z=H4Cojf<U+-(I8;_(!9B?SZl`ugChXa{iIqA5QPyC&{sVO+>fW#TEJ$lfCcUYn?ZR
z<=bKDl~Y1bM~n7c>`?W{3)y<jK}F(rWKn+Axl39bR<=IVSB|n;``FZIpReU)`Inix
z{(Oapd6LfriNE_*y78hzsn!Xu>KFFYD%-zodt_L%F;3W$)vGhabwSv<_!dr!Yiwtd
zt7q`%FI?|j>G-nYui;-NL5;2d?Cf?p?+biz!_2jN)eHSSMsH?reE5ttWT9QSvHFww
z1$&lz8XNqSx)Xcx&uwKJuhR>>Zzg^J5wO<w^Y>M$u_BLL_O?GbKmW>MiTvJgQ)ahr
zl9aBTyl%c(&(z(^_sBifnYC`}iLMIG{TKHI#*{{RC!M=hQu0cvV)2vp%4eUv{&d*M
zy>I)c+2ZVrA|>S(>6!0Y6!Xyh)ji>TCu7$|ig7TCg$bEYRsJ=@W!9mmN_?75udG=2
z39Pm+Y1;Bg=gS8!i-`ZPTLK!}XFgATt?0<{G&o~B-)!fs@BMvsmr7=C4dc5W%w(hK
zRIV(tPU7iJW3}Xaw_86(zdm34c1o!f<ELz|S@-t~vDp_?v2Kn~eyB9<T*$_2hg_v*
zhVF81xpl2_(Yh?NS$l<rJZFEupI^Hszvw{LT#F~C3YVo<`Jd~Isu7i*Wm$i;U`B4s
zcZsJ>^TZBMW@PU@xgaG?e#+9EoP_@Wwgq3DBlrut7s&Q8EnINDKQ}#cx<KKH$M@<c
z_j(zvy2LLx)o!Wd;k%{kUl*N^h(5Hignx%`bY)h^)gy<JmI#@3n3vz0(6LVWLCV$S
zCkv+h{<d?^JBd{VMjsArIbhN5-~DcK$durgm<j*i?k!~yKYsATuP-;FOXGR8A{MTj
zE_>gz>$8%1S6up@0GGd9Qk+v4EYi$R>M*H$r1<vgqwalXJr})v5)0&5d-L>iXBG9N
z?of;tyV%ZkEb8lz1_LAW)6W!`DwSTpXb9N*_%e(A+4EE4Eu<two`*(WY<HRZQHD?5
zSYcklT9@b2rrW>AF0|W{?w+T1<Y9#0{j`TXCpHGWivC#1^~ZN7pQX#(I$36Z?HqaC
z1GAEu*=Od9_gu4@Ai~2|AO7Fu2Dga(iwbYu)A^e_b95%$RhT2gE&Ix_lOyR=vgW4z
zoXKZ4|CsT%uUc!DYGl)l6EC;?JJ!%O;lZR6WpX#-r+&=MlzEaQ{%Q7XS;p;7Iuf5(
z9V)4l`?HfF-N^G~g_y|HPT9U+b}31M5vB=SxfgHfTv4X^J}IHTRQ9E+yo~3=zb5-$
z-Q2w*>R;UagkV><{tIvKaq&Ao;#4d<YkIdMr%YV7FUJ4M-!DC0OIH5TPFfxC!d<nq
z;kTC3x8iOym(vgCuXS{p)^|V1(Bpl<i5nfN8C#e86@8tyPh+0{%roW{<zjp*7j@5I
z&iNW)f1>o~K~v{hEl=2HmxrjHj?8+pz(&h9mY=Ka{>wL)w#zw}g{>(IEM_`0XXc`>
z25z5vCUIrwn@V5mc`>Ct_M3d};uCG_>Q8Y@{QUX&N4v0n!spy3#)bcK6tni_kY6nt
z$?9S}G4)krR(Y8HB&n(^zbEo4Ph7-txL%a0cU5)zuipu2GbjCVnwMqAx^~+K5xwa_
ze_lRP+4@WR<-!#1cl)$8I{R0*d6aM4)Z$|v8@#A|a`p_~+0M#cmzDC_i{7xOnU|)v
za?Dtm)B2($D5^Jne@AWKLd`kP`n&I!g}Ish6Uy7X<ordwhX2L$UNX&)I;1S*>LO?Q
z?o{AKv;8H{kJ`-k%03?P?4MxBBe}31j^}&(zqd9WJiYvk(m(gZR?h;N>JB8X)BL#o
z+~QBwi(=1SEv|eKa{2ViJ8IHLSE_Wr&DJ$+_W!VdZ_-;`OGzKD<wh*)56M@ieA~Z$
z-rmp4kE%_1xXi<Hj>*#>bA?huA3bKwvEbUT!WqIGxBOAb+{#Br4@&A^d^hQEW>0ok
z&*I57-mxKdT}e-z-lijAUPm8n^ItHp=b5_Ygr$e}7H@7bk8PhA6I*4+*U7Wvdf=Xd
zeHD{A_e-_BmX20?7_%a+{l;AT%dK`VE|uMo4F8raGW*X)O{<S4M-spMZD5lue64qF
zBkvbSqh=3lE}ow4%!yM%>`SjQ+>%?qbdziPu4_iDzs!WDo_%5arAAZo(Ojip;z{>7
zG^Ea^?`XR*=gO<EwJNR4(%$XqD_6AllDK$BLHqu>toHkV-&ibIAb-KCO68qeQHjr8
z$s+N)>vJM!&)C<PGx3j<P|~3lQL6hdpOulU+9S3pth#;D_rf**tu90sMkOXxPPuZQ
ze|m<}N2N}l{f?`?|9$(r;_p;uZ_$7Jhpwhvi!AOJVp7*OnW*THA#65xqjeUyVBYd~
z%PT#np0{&Z@4VbTr(v3Ua)-pMoJR9+Jbl-0E_mxHXma+wIiJlGsdH~DqIJ#Ih&D{S
zpS$MT(+!b+g5qk?+84J*OwwFsIr%!%I`ee13hv(qyONls`0Zo`0vR)WCWe2JjFdGE
zZGG?}zDw+M{au}%dQwNWE9c(x6JED4)Z2zrra3}Wfm1>Lg8A)N-8Ry!U2O6(70T89
zIoE26?&u3PW~Ocxl*|m?tkL#tPej$ky7`}NCklSGYD;D}+TgQqlWDL04Xd+%EHBQn
zo3!_YkyIZ0vD(M)tRFnfIMI+LFSo8lASZQd$<xCh_Vk`+Q)k$Cxc*pW_luXm-d<Oq
ze6l%>oi`)1S>iF1h4}8SI<s>A@>Obw=RXyk(fjeo_Yc|E&$b<5t5r<o6}rtiOXtew
znfn)nA1qOnYhV5-RkE`A?a4*)7u;&=TMeEZo%CL4{WX<J?v(nyKFJyPzRr`L82rP)
z*Nk!Q+uw!)mD!ah#VkSx?B|Ip2_DPU{Jd$~;fH3<34hPd*|&>v*_L+86B%_}Jr#i_
z^2|rROw=>f`E=~mW`WrCrw;I*_`bS(-Xm`*sr=$?iyNo)9{+cY{r7>b4>Mot|1<2_
zGlR2Bzl1;bisHjM3Ac&M7uQ<%Y<1p#Mrmt(a!1Y<`?^;*PVcy4pYrHw;HybW0tW)!
z&o2JD(ZcfLIljc-*#<JcFN~b0<Zhhp-|Y}Kf8*vaM-S;u=SnhN`-D;P{Ni)9)z7qw
z!aq;Hsx)uKY+I4{E7w+@>npi8uhF>eWmDjm51oSAZUx03B{w|1xA>Z<;Qp5S)9tdy
zi}QOwUXcD7-gEzV<y@78tEEN5S6y_{o5<UqC8)UXNLp)rlI~)`?6q^}JiqC9?bT-6
zEZK_XbKbAa2wb1*T*GqY{WQM6Ay1#bY*Sw1cI#2z-pOC@U-_)aJ%66<g#L|RU;n?8
z_9Q>fcGLf@+;cD7Ey?%mJNNgX%+Uy+`&o<K7lzMf%Vj@4>zzzl+BE;TDF?5+g+J!_
z8s0Net6TWciVLTXSug5do>vjK<)P8cmm6847Ozpg^H2DG)Svm+vw0Tzoeek>mT6bu
zr~6CbaY6i#^(vEs<eM@s3fZNvj-9>G;;P`G4XH8jQ*PWfHB*zirNXFvu`WY#rs%Bf
zJNrExYCfxXetfLWw%k6)*1AdL;B)>%Yo80p9#g+GtFG<Wj4h>0<I5JsoOKhv^R)TB
ze9yg=Imw%A!!j0s$S<f`^K&cb>0jEP+IRIH=a;DEo-J<Ta^*N9=Qq1|87@=iFS!5U
zlu*+~=DQM0-MhoS7=C)@W;X5bG?%Z!+7lZ0uDm(Jw3E5_%a!B#e6@T(dVKfA+1qb=
zk#}3Pvo7w*C5|rrZ}l=J-s()%Dh&4u7yEwaIGMB5U9f^hrCcjp(kgC#qrc@FOXscS
zu@m<#xY0Q+_(a^nQj0CRvT^$EdnE2G$({erI`4y#*~N&T%irpX-rvj;pz5>ocChBI
z%@t0ioh(~6wN|gb;F|w0<VtAe?`bIq4=XhknqHbIbkytIEAcYx%=ag&gY{>z-8GX~
zdFK3<viH;budujWztkEhk?_>IT>ery%TtEe@pA&h9v{1P!|t9C|BhKQo8$Jc&vktr
zxWLo++fS<xstnvyOY={?_h!G=*2b~XCGeBvLtbVl$#A*(eCPCiF3x{g-O#;#h1|*7
zBcj>u+Kh8|29^BXbMyJ`&fu(#n%#b4EB3cdIA0rcLFP{1oQt--Q+6EfFibj^q$zKC
z@!c-{ix%$dEv~OkFJhX$_tcXGzMISL&ri{xyZ%qWv!bhpUOb|yy2<<VOSgF4TKO)d
z;<)hJc~3T8$=Nu)?9bXiMXcicn=9@qUHu@tX3t}x7i%LnWVrH29kNdL^SNnaDK;@X
zX5%#TiDh3{Yi<?ajZR_6w%_r_pUL?`hwMkG->chYxw$g4H!|i`eQV1&{Y<vjd4H*8
zL*r>XO@;aMgue8I`J4@Gu{#m^liPDQ<DAqpQo`E8slSqJkEd@ul)vyqc-Nizk+1V=
zUbBla%X814pd>k^t<LzF!Ycm7J<IeOGN&Xrop{aEC*qo`R$=F}?`n;B|G6Ez{&*Jm
zs9wK(b*)92^((=H_Z%I#K3(2qGErQzY-LaXo-5zq>ZJOIZ`QKk^6iL4jPGni#ToOX
z?HVTeo6d;e&%b(;{{m(;iMHvNVnQN47v+lxmg#Oe^6kzf!z&Nh#&XY15u5l}`i4kr
z8H?hTygxsmtXps;qO;|Q)sF41>W9B>>Jm6pQ6z9*Z|n2r28|D!qjXlzvb$pC>1gUE
zqG;n19rgB8sfeHOteplcN<UvY(PDd=UpY4B&rwbNrY=UkEmta~rF@l_?LA>9J^O>~
z525!vJv1gKcg=Wo?p`VD@770NTWu;+78Ep|>^6B=Zjv}Re%{_&K9@s(t+`&k)&I20
zvN!K7r&K-ru02=nXc|NDNvYzw7QZG1{dV5ChvU_1t)sGU^^1PSg`Qz!e(8Vv{=VM%
z^QW0;7H8d<ds}?@e;@lD9lO1jR9|z<DKBo?Ir-hgK*Rm=9(j@<wp2cgm7lc!?7pex
zDX#1r)Mj6Io3PUE?W8Y;mD+52$M}^SpQ*C*O`a|27qNWtRju1$ZhH9~$v@b{n$)`X
z-16`{{9qMFX~i7-1JzT19q0)W4vo1qFZlWc@ygK9gcm2cPIn|v-MiB#YDxd8gO6vr
zeqNj8f4O*hcKmy9n{yRu!cwWnb_<8UF48>Y8I$(Z`*WU(tyORP^JjfG6YgzoiqAh9
zaIs6k{{7eT@4mKAO@AI?zq#r@_hL1(@M|ouUUjY6t+4q~{@HtKhbvOFcuv1!4Sws-
z`upFakH<Uv<^_fyNxmMI-Lrn75uZ+9#K(kN7S;1JjIX~5>$@12d*SI%$9owLc5@6}
zzBBM<9<Ym-IF+h8^&bCz`;1?I+@b`$P3@{L$Y1eWcymF$Y29@1?wMyMU7C^_FZ`r-
zN7feqgHKcfU$0tqY|E1eHv3mB+94~~|64Be@VQq$WrxnCe6f<%eIqBxCEfbs^o*GX
zliFhU*lu;6v7qAD!efD6msQRgo@-Aq)wj96{@8`LMfs-HY`SWBWhoy!H6M5`nKoli
zXvwn3Po2>{);E?rw#taNR)w!#s8^*w<$f0b-#YCu)`rUdeQ|=qoIb}?!oviveAJtG
z=E3$7&g`_@M=#b%UeH+}FvFO`Q2EU3AG43wbM$53PmVp=_beqkshLx2r<l~SX0C0E
zKUV3yoS1&+-;+4e3!(=v)s(&7!NwY=BD0ZC{Iz&cg!^O8)cZyGJq%h$n2YTT-#u9T
zHQ%V*Ol^;S<g?{7tb{$n(@+0yl4_b#?%sTNvEaI(ioFU4Vxty35Bal3I`i<1viUcT
zIjd)Xs=eaS+#ji%z42e)+^^PBbD6693bOK&Zl)i$ySZ`qqR)q>&AM!0>bK#N*1QjA
zUwCa_n(AhJMZ9<hZ;ZHX+@8y3v-u7sojn)7>X6621!65{<ZCZHoGKK%ZL3pCrRa*&
z$II+CCH`@Fx98>OiRZpvVwo2axp&Ko?8LQOzrBnwzU3a;Y|<&HFPpuar6EJxMf-Am
z`QyG?`9BwAj!DZ+dAG+?+&-4?r|HFM3!hE69QJX+rfpM?em~Pt+T%Cz?(GF7UJT-Q
zCA$7Cc~vc<Chan}M(G)UmS1MC)c$Cp6LzWRjejam-L}<G^yrBN3k{}lvc9b1=TV4G
zh{{+~yJ^LlHRtPYce4oROn<F%R?ma`wprZ!pLbS=h~$=>@Y!c(aAApa&ymM+4Qbon
zPw^5ql<K}Y+osNZ;fGM^57x_gf4yo>t8ZUn$nKmOzf{?lDcS%2BFhzv`MCS6zuWk{
zR(^2tAM^a1c^a>i%j0_`IP(MAq)%<FdZ<~YH+R_&>4JrAb3Erhu?VVlxWrd6Wx-Zg
z$+AsfkIxQBOIyyjJ)mM*QRkD#JWW$or`+ln;VCOvC+0q<eCid2LmekS+MeQ=DOh&i
z*e{P;KjM$cNw%{`HFw`IzouO*AkQ;#`?9ZvIs3O~*gwnh`2L3d*2V~Rws_SDt&5L#
zfBEIE{(W*_&6>>%ANeb;iC>@4-B#CpqG*+#{n?{)AHF!evSd9+vapWU=9sH_Gk<DI
ztTx#_`+r)AQSHJ*&sun+!`)*`4<yd<_jigs-CH>|aZUaKtzW{gx!I?__?IvH=%rlV
zEa_UI*PL2{*Oxe12kmwI*%Y_R{HyTFUb~9UbfZo=gWly^GoHKOseB`*_^$Q7ti+vT
zYWIY4y~COPs{(3wGJlsU`I$7G<I~@qs*{E*Uhx)A_>&{*bmLXGa`*hjmeR*;FX}AU
z+}`3T(<nN>!PC;MY~}1@AB0WbOh0QfFERg_`KG@`CnklJWqg^S@%6}3hq-5pyAR#j
z#4;zsZG*vl>wQ*yy32p3?YYP+@ATH?h5v$OjoFV?=l)$$FVZ(}@xEJJxBQPeaQALl
zy^~RE=Vl+<@QQzGCxQjJmh|m^`6zYyqqQ}Qd8WD@^<R4BcG|nlf{CZYwev6eDXu8=
zD>|}_A#qx0>TBZ+#v7eMYj#S!@;vzS$ln8u+OIU_Z|Rtu+;!Q{uTallmb2k_Sd{st
zzqkG;6zbV)zFjR-r}0E#>#6!9KLfpQ_%Is3xYcD)mH$dx^|!Q9XxID=FVh=Bq906H
zQ6Dzx)o;d+@3}<|pTFd?SS8%xyv)uE`h4ae57o>_do$&{ylBg!_j3<USyycL=E4(W
zuc8lozASEE_;-0}^sNu?e$EoRWsr2d=&PQYqT3DeSJh?*e(v<&6~w6K_=LS_SMS^p
zm$v=N6mrUSc(tSbgM7cp71x?+1+HfjZv<SKvGEa;5|c+!TKFG{@c7C<{rYn}o9D$&
z(2H5=vzcSoTjnd<Rpm=Hx2%?RvN9HB-f^|}yT#_?3I-WfDdFCUcA~XyQ9(Q%0oNFn
z#X7u$@)dW>Nk8N2UV5={$HZT(D!Z%veiYgrJCnS>`h?Kh5H}xn*FD#MPT*YmbI;B7
z-I3YM{r6cb_`XD(`E9kPe9vR2Bc|r+YAo{v<d^^HQSgoamEp9Y@}@|Yo8R)28nXj~
z)UM9mP@-qd6%?VdVfT}OV#{~oD~0%UyS51xmRA<sseb(Rwh8}*Gcz9RMZI}bI>qGZ
zb<=IF^%q`6yUl7Z&?vd;y6WB4&kV<+>f08tbF!Qt;eB~piS%C;YwzdI@BSBhxmTnt
z@ckZadReWTpYiy4^No`;_5|f`c**u9@Y<wnDxsH>B&wN%T=yy-R$bm|U-!(Q+1}e~
zQ%jJKoNr2f|GLUuiJVuC?D=W(!=Q|-C?(CrBmH1kN6OXIyM7-`eSDNM-#@u>V%7<N
zc_a4!8b|w<Nk~?`cfa#?x#8A;B)@dVhjLfNP5<1RKl_?kqMBWdF2A^2f9AKzJEw;`
z_h+!DPjx;mbvRmiYsbVL_w_tog3X<uU;EH`>|?Uz-3-p9AOB42S`z;&^8SL^Ori|a
zUp?*Gn_I1>nRHpy$IA9~=<9?8QTMaGt1thXH^1q%&bqG$SYxhSO$q+X8~$@!rbS?J
z`OFPHVO=kOp6wF-$rcu{_ORM{C6jfEpC{c@`0snhi~0T&wzPc(UXGVH9sV=#LnYhy
z_eQcOc1^qV?n~?Q2}_=+FA>&dOLce3eiJG6xAtAh&wDdt_p<d}j{m$m{#O^rBH#C>
z=G$3(Kc98#es!3W{X~+!lgdXo-Os6EL0rG~JEnRyo_}#{pL@jycb33d&AA79rq&dn
z&7V8_n8CwTN$rn4YZlfv_DXKrzRB|GV=;HB6YmVGugln;Pf-ow2$>>1vE!}m#OMhg
z3EE$zAImI={`Mzx$<t*gl?|tgycNzq6?~fc%Dy)~2j98n_nl2I;dr{o+<DWtr3*V*
zKK3`aeTndzlY5j=sBwwUDen0bE#oe|@6lhgqvg<F-H!Rc<~82C-w<M_eR|T-jAt);
zv!AxN<?bl7xO~wo?2yQ}WWgHFH**W0yMDC)``BZ}=FLx+1&DqyTjKR=|GfPd@4q!X
z9_nTh>5_9{ho|)ZJ8w?SHeD|Buu%U<oY11_`)fZI%1(O5um16EoxtHsk0*0Js#E+W
zG+SqT%FL#enaA3me3$!_dggA@EZ4v}k}=xq`#Da$68PNm<Ko_vzvdp#?%ijxruX&i
zG`*F3%maVSF`Pf?gw>Dc1pz1igh?)6D#2d-VdqBKY@WTV78JZZaPrEYg^&L2@zm$r
z+NvF373sG5*74HXd7&b`k7s;Xe0-IhR(f8OOd{W^d`&e;<(HhZ{!O1Ud&XL|RgV@i
zKL4ZDJ9UfUtSg!+hmTKhznx$^=k4yM8?Fns`BoQBKV=}HZO-A(-xII<@J>fd+Horp
zA>GN+@gH_`GwQJ)x9*(ck{&W+O1NFu#*;G?c-sHmt+)^{cfXn&|2C!`t9sj_S!;au
z{P=m;vPOeRm`x)qHmO@WPxPGX)6@FbKi2AGvijL1Zkl(jBK%Hy`PnOd>Y}e-<vL1;
zoNZt7E9s3Z@0S2Z=Ly%o8Zfc8+47ildWLGR`u5vLa>w4y=gYD$n};M{eE*{EJ=?)o
zFJ(9DX%=Zr<(_>@F7DD3M!wsk?P~qXUu^FgY)keK*>vpN`m1L7tZct`Z8$8r`Yc;e
z>yM>6X~H^TYc}v#E4Mfqht%&(c1cU<_Vg6eNdF-#dF0(;{__$$PC0HdTKrknD%8uf
z`xIYG`z{{cGbc7Gn(v)%vD6^+diO+5qxnTq$16^%zWbr$`&D_JsMhI<`RlcNBlg#a
z@E-lG_3)7RSD(s{=|xl4F1+1uD${aNzB-`d(Yq7zi@)7nSa-0)=6u}V3m&t}^#b{7
zx<3gTNXQBP;EQ~=C^=c(tgkr7<I%6JK0F(fqJ(AIb~x4<_1Le@+9c{NelIlR{NGQ-
zif;p}AOB~VF`KLQ*VR7j@6km8E0+E#x!)G$HQ|4mjopQk69xO;-TC2Y8xd>A6kD^k
z;@=BLv$PMdHfGd%%svw`@zi1inX~<O*6mr9qgsDum4KPX#y$T7?^#KBz4^?P6R}z3
z+h*g_)*{ZQ{Pwi3`XgHrS$0bM)w+c%8e@*OuKen}eyjBQqpxb7xQR#9uRnBW_o1Cp
zIhL;{pL@_buTb-Z`|{$N!dY7Dex$P8_&K@!kiOi;>(4JSYQ5=N`6Q%4ZF`yYRI&9!
zpOjeso#t_^Wi)Q(%Ga6o@PP+g&YY@Jb+iBFzA{lurk>or^tEw{#+zH^C3h3v6<GfK
z?cpvxQA%G#P(t1;m7QJwsM;A*zUUM_FD8vii_5q!UN*S2VM=z}f{0_<?&93_XZbW2
zwk?0j_qHWXy`SZpP49ZHPxpVnUd8Qac;2j(f0eSdf$Kgq(Fbeu-yWCUxM-c@?Z&do
zl@9{)v%AGk&D3A=)?jDi<)-P97E3%NHnS;}OWVkADnHM9DyZu2DbL843%_r$6WC{K
z{Vwoi<^N~X&-O;f#;f_AE9<aXwRvyKRf$*XE8gdO=<RP=uXOilz{DpLo+-!2*4O_v
zf9-MOt@jk`qe1(gF4|w$z4E4j@t@AjypU6>b)RzAm$m+hYM+tXxv2JOY|5Y8(>`*W
zhnpR}Wx@TFXR%hQWc?#6^{+n{D;<^6kzEwxyJXRx6^GV$|GQ^sTcWS?_^ILDKd#TO
zov&?od1Sm+ZB^8PBNpFJeS2k@{qGFFso48(c8`rV?Y`;5?whZA%+OTmb*^&Fu@|L_
zm*?FM4_7<8cL%exsUqu(Z)ab=sOjjkaLL^lC8=q;`Avk}oaY-)Yr7w7`I7k7adG_=
zx5>;>63g1^GM3*xR;oPV$payOmERY`eHQZOuUxrKV{7S^Lvm_rA9hS#qkA`~uX1NW
zK!VlJqh0R7^#POO&b&I!*k6?MpQpv$Ui#KN?P<%lER*{cu<k_L>Zt)s6c6gJ;hL+n
zux^g`g?U?|pQg7RKRP+kwpHL+P`|<5*|$`!Lw?(=ma<ma$*;M?OtbKd#r55V79rcU
zb<&R9&^K>xc-^(@^_KShr5S0y9hn;oOx|sId3KVMgyD|G)u+#XUGmp++ftJV$2@CC
zr>ELIHS^DI68^Rz=Kfp1rT&GdUd`lLnyYw1P$*JVq3XD8TL-V--3X28|5tt9<EOTD
z%X#-dzZflh*H}H!i+h}_B=OlM#9(LeKC9DA4(WotcKqVDF(*D8JLa^RS;d`2C8b`(
z^vBkvQ(}Ib7C62rwz6`zI@|uvtlLT5;_d2{V)^{JZx%ljmoI#~t$gD0eK)`5S(W^(
ze3^Se<KP3X^&i@AeF^BglCo!B<D(tNwyRW&Z<r^!G*D&N^!)H`GRs9gHYqXd%(XNW
zm~mZJF+<!{U!uJ)=6LDm4xxMHd&`$pPLDXgZI+VqHk}rWix;|H3tXKOFZ9FcZ2OJ&
zrk+T<poKy)=Wk>kd-kM-*+j;d@5HW!I``zA0)AbSneX5iTxGy=gp)(!Yt=Ke#dG&9
z$@5qIo$%LJ>zTaiVfPQ;Jsz%Z^(eo+Fy*3++q#b&r9a=uR-8^fCjY_s)4te8U*}(l
z{^h$cYhv|!wk`TcZl8*m3_15@?e8>M&ayV!@2AdhUOat~y+TuU<F~n5$(3KEX20_I
zs_C}j^bHni-_FQad+T<ET|BosMBYAj|CPTl1ba2+7AtGMDE<}eej{FG$)Om=@4Foz
zwyfOtIpgmo1HX<Nd+fR=H;dk09$2{U$&7W&S3A2KO?~lGRzAb}!&xU=U)8B=KhM~_
zGjUS>`AlA|Y)LP_zW$R{=R)6J&_DWKN&5=>m(Mx7*3|U4cB{$UGW9(ZdD<@3j&ZY3
z*^J3oj+jhm{bDHbs&>oV#~k8o0vI23R_(Jmt)eW`w!NtInEQ!|Q&J3K-iyClcFthW
zg^Z<UQ;y#f{k$vre%gYQ*1~?=9MuAfUMBTE_l)*Vw%!$%CVby%R;tRJZ+VBGZCatB
zxKX)C^4{u9l{fD*ZcI(<s_E%_mw9!K^8C;pA*Dv$Pp<yk7Z=mKW$&FcX8YnNtyr)!
zNOnOGgTfNg8;7KyGE_}7348Fm<nsgh3uopZtZ7LXIef;dK)|E$jLz)c4pt^t?y<=^
zW{C*AiQ9H-Li*Cu-=AJOPLS-Jet=b{kTt^5*iMk;eEOCfPqI&E>3@r>x_R<#_r5tj
z=V!}DvdmXL>^fO*`oS-n{9XSJsJv9}J7~L*`-AwBu8p?aK6hx$yL|sFw;x02!_e=|
zl3%{`^j1{$-POvU%n@Y0J!7}a<9o*|PCfk2Z6fn0o6*HOSfTG7w{c+1^&7X3Jq>*L
zx4g5&+Ii9O#~H5bzIB-ir##Zbci7xE3Yp|Af8})SxtniqwETK{JM{21rM`PCGX7$P
z(}T=Uyt%X8SF&v3k;H%Z7_R({_B`maX?|u$b#=h!`Cbe5x32J*%|3m`i`juqbNX^v
z!(KdE&|78kyTIk!-?d-D%r9R#%;m$Nzt#I`;M<VCi>;abCm&szUY9Cz?826_o-9(q
zO~GqkiLSh^GwXJ#_WqrhZJ0dv<*k~*$2LFmEweDIo9NU2m!BsXcunKo^&qcYPHvYK
zTaQ~q=#|cm{4z)HsbqKZi0s+0P}pVOq9eQ?D}~oh-`zg3_?GLWtCNb_U)UXD@iw?|
z?`ehk^V~PT^bV+0*{srTk3A<496a-H>W<YGPx@_G9cm0_K3Uo6_~b>w$92W``Fm=Y
z>uxq(#8a#F;mghsJN-YgmYqNF={n!GU16`|X7O$`H*#S5eJ9PK#o&#=yv837cO0Mb
zICoFUggMtP&bFEr@^D-9@)ys0{2zul|KW5^OctHcI^~1(emQBMBVs?_-&Q>BxT^Je
zfSQDIE$hz%Y>lh<cBm-Dsj$>Hea>FD^ls1XeZ`Hv+zH+}t512)^L}3YqkLKJ-3edU
z|Fima|J*cjfA6rIXTEQX)SPAs)_hirKXrt~<0hMK`L(ad7izs0-g!i$Qgc=IuJ$+Y
zSyMePIzDXH{d;z^QI}A_=2J;0FV4&3n!M90{_|(|Ynua94_z@-KdhvG{C3p-DPmtb
zi<<w2x^pd#GmuQlQQc;;Zw1r(H<EMLy$uduXR}f?OX)6GX_Z;&YNG=#<xeI(J!tV<
z<aD^3{OR9zeTN)sCR(;hU&_60@@9Q)o3i~&`xRVbA74Mdc--L75BAu5tR6Y$E0zl1
zo_9-l`{Fr4kDX53wft<ISLgTiV@=WYw7uOAWNz6eoGTGonB%S}T7SXZ$lgoT^X2O~
zjUj%vzQ;Nvg5%f5E@yh!HPwFR!lynV=N@dTN?1EfQfA4v#jy{bKD&P9MY5+s-QGL@
z7JONIL2%P|;mh;lRhHgOdRJJWBV4yHrK5ggS$o=@%hM+I$IkiwdV}Nt){up%-{M>)
zO;;Vi;(PU6+6L>FpIkl`bVx4#SftduMeN)!me0?BRnKTqdiZqO^hZyY{wnHhT4$m<
zw^{n1ZqvK2SD!z!ohZ-nRc=f5dA7dN@k;KdD2-f8gGG-eXCAzL>)x(aTNGlhbmy>D
zNf|etPrYCD{;A3rAswgVytO@iH&-@t9DOYO{B+FTyQbOYP5WBz>(7a;l=l)o8@z4H
zg*Azn4?lW+C3L2sKcm_{S1t?pX~HE{!aS$=)sq$;4smA7&)V<qGXF~7f~c7iR=3M0
znmbB~RFv;}P%HRON__7231^S<t*CK!y);X#>u#m-j0Fd`UMyVqZCeL-&;i!@RSEyf
zKmKR`$y}g=ZMU|$f`LMQQWlqu4QxZUp@N}_g(-|@q+o7rVGQFTZ`QUjHa7$B)mGrr
zcgxHvNi9;)cgsmENp(q0&QD3@va{nVE-6Y)%;l=M)mz3IG9~u9nc`htTLlGMXD?4L
zFOTLRX5#|_#zzcHytqA<UsCi?=3P|c-P~dlq{VdUZ?D})yYs*QXV>1JwKeTs_WSJj
zo4;FLxBFhO$@Y?XK!d`Xg<2dIK@J`QDy#vQf-Z#%F)=zQ2s#RQ%$P9wGDBNQ)4#V0
zPfVJ2?K~_{u(Cd2%AExXD!0Bd^tc#r6)0$EYZrF#U{O%fQ!Vl5VqxNFc9>KzD3}-2
zz@8w&!*oH2B}3ssK)I8jYD@Qa=`-i#I^$lfcW2nn%kSV3^hxgj`+|lh<14&r%x%nD
z4tP|rFs^cy-XQECpUB*-wD<qirs!jGoh1{Qm~3rrSr49j*Ti9N9Vu7Wpw5%Yf1!Do
z^WA^|jtAkF8FDume_4Nzh0~Ie?VG`Odz)Vz(M!~C@Nzjw&q*)~*kNsTjG3=-7vqJ~
z%wMjWGFs^c{E$yMYtQkg!M>bbK}F+B`7Zm#^{Pz=>)D%ga|F)mCG0Tg$z$KpYU#*m
zr8TR`Ltn+7fv5eCQq$Z!f-fozxOj@0q8D@S&t_*15h-CzDCw>@dy)5;t=MrF_pZZp
z>P$KROl8}9{!~GS(4m`>T<*Js|E+q@c!oEt`Cdi-gZSsKIovA_)&6hWW?*sTTez|S
zzxV=0nP;yUL+d}NbLJ}j=|9WY#nREJ@~*R~g)tzU;mYY_azC;;ne)Y8<S)OVZ@i1U
zK3=?q`+(S8jw|wM+^+uxe(h=w3}Co)mig8D-~Pw<3oe`>z`(TGk!j7sG6Rc;^_v!-
z4Y+M@5XF>dpnpJEAga-c;lld!_x+z`Omq||P=EjbLj8QB3lV|tM~_T-zkc5TZ(3SP
zdl>dPEn;9yG!$^)D0wgUK<?MU|Mx598WZcUee4e?-J#3$LHqjps*BQJ!_Tg;Pd)JW
z`GgM)|K|EgH-_np9QZ50adzVo2eTLY3;%C^Qs4gP|CE2)r~m7H`>*GD^zg}-=8eDo
zkNtOMus%Fz&;KP0p1y8$>2DHavK9F7f0>l?e~AQL4VGsQ|J;u&Rgth2;wrFSzW=+>
zvvo|Lo1EkhPB8mcpYe=;_rvv-#Z3nn_6xk*5FgIt;K0H1OJBa~M2^hG>mAlnGwOF7
zc=w{y`Jdg<c!{ogE9<8(;MwlzP{%ue!wd_CH_zC<skzLzk?LI7+AuGO<I3ypTNoW2
zEtop_7#H0B%6>!X4oCgmO-oo9GX9?aBF))&gu&s4y~3^6U*tQcu?zg;*WhB<^_O{3
z^4<T8?-?89_CMUuwe4d;v2*#C=(HDk{|@b6&!=&PJImSPH)o=<?4tnLOGQyj54_Oa
zV5if(d3ITrl8!-4LSz4%FuCn9o)^xanNc0F$mq7}lB9<hR;_(eHEXLy?StP-+qPbd
z{u0p;ntHnLs@1#8XAPgFEPBr={9ApKTTjem5m&L5O55{#+|L9)$z>@L*qvAFXS9F!
z)w#x<^J1>#hrG*d*_KhCvASyVLeJAGnO|x{`ERD&P2ZqbR`EOU+p6N654X5CcZ9qR
zf5V?@H%CydB5acWcfK!YgG&szyR&93Xu9^@;?M+<Q<rLe_+36~^*;OTp})C1;C@`-
zuc*~QC+nL_rhf=t``d9R;~qC}w_5R_wAdn>g{Sn(x%d`(XEJZy{^;Q2CW%Bllcn3&
zlu8SWRaypXOx<Yujm_+>bEusC?K@xUj^6huonjj;#`<we#pZXKOIPjlnd2?~NI6yM
zRIjDOZG&oUuDJCZX1lNN)m_WBDSU++OWyN|VFy?a_SmS;6^h?_p!SUS>_tAYpP1H9
z=i=wv#$0hL^JDFS6|0wAoYiE`Gha5uZjH%`3c1U(yzgdcMNd-yn(y)bSsst*@vEt~
zP83{Dk^Xt6duz)H-Z}fHe7tJj@P=>hy_tP=Jje8<b<5V+)lIy*@seAeWRi32&%cER
zSJ%1STylo{`-)rt&Na_Bdeg6{xX&v1z~jG;dpw>igiI+BbWzkjJJ0E+(YI4GjSRM(
zX%}BSsr$0o|4;+xEf1K@b+V3&Ke_Fv?iads<BXurS_v(+AN_46_s>dh@5(La+I#84
zVY$5byb1l!HS?ZLN(nyvT>kc{%1pUQCokBqn)EDqZS<-?A@9EKx>%?8-`&W2XNutc
z%WN|lf1j_;N!k)FqR-0z^k-GBi-hT=8Oy5cN^&;quGiJo{TJdbt>pi$=SF*M*|ypr
ziJq=Dhw8H!^lHULU9#h4w2k)v$=Mq;<@>H_Ddmf1-VWRH$>mY#H2%MPy0?d2+J0t<
zGk^aok@*6j4jTN92;RI;e;Z@^$?eyB`mdF~{c<x@Hl)1TYv=c8C%@PIczI)YOy;f5
z`Y+ofXSmz=N1t5A*K99v?5;+e*&!EErFVC@jeG4&BGxBPv#{<8ntFqOhhO;J{F>_*
zb+le@P`nZnueWOz{}w~neIE10Pn~OcGB@ILGlxu{%k3_;^5>I|o24BRo4V&W>mkc@
zpHID8SGRt&DYbtcTdn<4qdg*fq0Zu*c@A+^il0xFcfN0V=$*bLXuCkmRIdrV6HfQL
zh%WK{uF34R?ppid+7mZ<v(Cm&P@7isdTw95oEpoq<=gT;in{DbulI{Ec;_n_8L<A!
zt^UP^W|^0=Z)s(nd^Gi%vRhMg!Mz%pSvSnK32lwD`@gBA`pu<JRhy>%y0|;oXF+J}
z{QKW^S2<6c%oXxV^;mC)vR%lP2`4*RkJ^Phy<c~Kx!#LNi*}>K+(DAR56%e<s5;Xv
zcfeb%YW)-k%TqDp{<^<1Pu@B|HTe8~wu6VJxQkQ=+q#@waWi76nR!y-u1S~0>RKX}
zbqUUquH*Q<toD$@-l}-z$v*;FCpLW87rQazgWBJw-#HhKE%o<#5x!^lZuR6!#;8S8
zCx6sP?cC^YJDY75o2%4!L+w2?ugtr$%`Dr}f+sTDZ63?6SOFIOldYSVO^_~XE5BU)
zEI#6>yXX4GkX;PtW`=X7bFX(vV}I1G?y)H3Y=5`z-9@i;ua`wUD$ANLv(Td>>Al?D
zDg1}_gnRP*oxy0>mD6>&eM(nB(XJaGtN+xwq-oj<Pj$=7bN?>jlU~2%!RyDz)b=r@
zymJ3{=XR=(K)u<*mj}cwC8kvy-EtK8rl))V$%FvSLeW-H8I7m|GuX_1k3@bwb|*AB
z;Ir&gyQ$MIN2Q!77usQ~oD*&*HmPngXS<18;hi?w>Gda)U;mEsu->p->)o^bT$4K|
zO7nKiy8iZ9Uff5`SwhPlvdbRa(3*2`lW`=QeD<HMCr_O_w|BbEj@+uHYyUa)240Mr
zzVw6LS`ks{E8M)TQ~6HGyKgSqQrI@@plz_L=f&Ccr<iNAC{7kBJEK=Q{ou-(@47DN
zR}~r-b3R(;_j_7uU`)PHj%@jfYqHL3wUo4+FUMcy>FxQpfAZ!}vpwdpuzBfD|DpJ1
z{pn?em$M#v#ob`sX0+l~>7EUHZ)|-T!&}Jm(PRG7&HFTKj>PWS=3VX(b!p;1iQ?U<
zl`U^~C<LllXCxJzyHnKekswgNdjG>OS52nQGmCt=xpw;dhe!83T5(=s^3B@vD{CkA
z3(NN3KNy&EbJhC8kJ;me<Lp8-E<V)Wu9YA*Vb7b}OI4JbO$)4FJe>0JQ@_m7%Xib)
z9(6fo%#-@Ca7)Mpu^pRl>~CDyvCJY!be<5?x9>fFx4dqQ-5zlF$3OG;FCxO3i*s&Y
z7de~B6I#i5X3no~Wm=W|t2u37NQKRu(Z0!&<8;#3`^LAP_n!<4D6D;cF!iZQps<{+
z&2_W;MS*{>)C638@aFuc>gA79wmdI5_TAEGy7IgoeP52HtC@fKcUt{MUHj@wYl~;(
z9L_&*Wi}Ikn6XQmXHSiuSoF0S+n&v9&+d8@d~OeaLZnUYu8C0x=C1o$(-pnyz{J?z
zcY*uTJ7*Z4YMHUG&9^pcj$_TNbytLc6yNE*cCL|+q3`i&4#O!*Z+EC>{rnaY`Lg<l
zZ}grm7jyUDYclrm+}!*q<ka%=3GMz-?{7~M*|RVERp6Eko3b<cs_Q!4JtqG5c$Mcl
z^{}qbS~IQBtGz6(wdOzNY!`X7=*`FS^z|DrPR*F8pI-isVQXo1c%{OZO*(ZR&dxhH
zBkmrSo_Xu>@@nl3iJHHh&dq7^?L8g1{La(Gm;Li9-+Ja+FFCRKjk-~?uXtjEUe+<y
z6aJ+^S~q8{+L&Q}t}(Uw@9Nk2?IAgT17)^Fe+is!di2mb!-aC<wexIamrvC_V=8CS
z^R{YY#UA0$0bLe_+OrmW#68;leD5vAa}qzgt}eZ|?Wx8=X8wKh*_+>p|J+i?VCgtn
z@mtLD-SO;_o0l=2*`IKM`7V>X|6!xEXB+iWeq^eIE#4~rS#L^MvsBHSf9@yMOZUtV
znmMD}>`Ic0Wv5<8@0##wn=Qm_&PN4teRQ*DeSOhaP)_sewdFf5O5U0-bxP)5+{+55
z@NkaPukMDhpVXi9+`|2n*A&+6d{MXJn7%J|-Lm5PagNGJQ*E!@BbRsG3;%I=`6|mV
zGbcC4X&je+Cu{%5Bge9RfgE?TeEjacRjZpX6ulB-d#c+bEw=6AjW2=1t;%;oX5X81
zWy9j0Gp!vCQJ&#poeLF?Z*ckK{Pgi>@vg&vmPkdL`RzKgGnKndQT3$R*>_&+y-!b#
zE?BamB7rN*<#$zue2kKX&gPj@Sn^iyD>)jodU4>M8wVvBwd>e7)j#VDRgK%aET&4)
zqtsdD_K6~MkDv!yd8rn!vfkbMQV@2~>(XV8(>WLZ?*8;Upu6{>>kktZ?UauXKcCpT
zqIrANtxTin>pe}=9<J?QF!k5jjcbFWl-zx*ZNGMCom_gn*y)g$Rn3=6@6F9`dp+JR
z`YbJHa(vXO%Tet=q`yQy4zAx7U1C}!xlUH^_uTmJ1*>0mT)146@FsbE$7QdLcKw!H
z-$;b&d3$Egy|cT}y)Nm&fosK?T_<iv^)FGMeB{8N<f$tzU7wL+tR{7{c2Rd;bB*lu
z;}Lx<+54EQug#d#edOu1_^IpWo!d}($Up7Gyta+eF`w^NzdrM1sn(iqj~In1N!@F%
zY`49%VXcYlR+hDUYj~g4os)}7NWHf4wm{h8bMl%(Mr-Yh4RR%-FI;??zQL~N{x6gK
z1BKrE?|zxxT&fUSFm08NTekg;MW<VHn)>9f?<(6}AMnVI_oJyz&pEwCQ&)d1eA%3I
z;N|rj+g<MUFrL|<D0^+4`KpTUBd0~O)_tC`B4y#zKQq$#Z_eDQch;Kw+g<gxq!n);
zZFik*wRHpcl;ZaF0<Y(XS?%-C(VQ{EzM}fC>kX;jnJ-;F{`@x6>GUmCckh|cCVy)`
zexTgU(sF7|u8v4%^1K%RTBGG|YReYy-q^L_rro7YK0&S1MIN6y5OMzO<`eBVR~qQV
z$!z|3X4%AZAyYZ0YwuPTIvko^p3!#aT#@^c=_!^v8{4y5FGg$of4;S6kwAj~RF4mp
z#;O-izWb?rL1d<>)Bjb@<wc=uqs&5meQP;Vm|8aWo{J1@VVzvNp+@A;oQ0ZSY>ggv
z%!zR~lR9<q_~o0qH<RYPbvB*$<J^l$^*7pOjIQKgK0PaKh3=y77W#hoz2m-IHCXm;
z?limd``^`1&wn|2b>GkQMX4LD6omN?zOy<qZ>C__+M`L=_XRwP>hJa2#@V9ra@qg3
zZ0~@rd)rdQrmAErpD0<s>(MmstSe%iQ$-eRVs9?nV=vr)-fLRmQ%)Q2bN5Xj&*zvP
z{#(;RTx|8(qxtEv%2!v`YI`;Q-=NUv6?lDhKkx1g@tJck%1l<jeJbu#MbnI=4-MZR
z9j*8!ThqV2;>UgSZJEI{rDHC&*&d4CA}Y(OeM@EC>v{LDzpD?hnPsk%Ilb?IvCllc
z?cAko<?KqgGz+vPX0Gg9H}wIJVfO5)Wm7KfT35Ht==kcw<sbM=Q=BJ0IMyx|`lQ;3
zci)AqLcXPo%W^+tSB8Hp6@B~DbMqG2-IHAIY@PDC_15OeALJC?tgM+MZD3%NxbnyE
zS*343zv};7WE+0Io9B3e@3DvX?;ZaneCoS&%GylT7nS?`7bYl`{%@GfyLEovnyiv3
zxyj-7-v8HpbN!GS_wJN9_t)Tk30t?9{Zjtn82s<9y_j?QuRW(ceT5fa%X@g?!_@lf
zrl5D9<Yed79yt8+%e)!CexIEFgXx+Fx9V5ceZ59Kvyc5{I8nXe{g3veuFjJ<iXU&t
zciN@gZ?t1-k(s}y;mwa`rS@HW8_VTOe0{D@>&dhVk9=C(Xr9I;%kk^-;j?Dl*DkOB
z!>#u^d;5tEW{K8u2j4xP;oG+3(lxfHR|AjSS}y%DX|v|WhwU}YNB4DZimH=1|A8+@
zqA%pz_wJt}r~jJW4&ErFG2`oN%lYRVBlyn==H7Nmx*u72Q@H5v@<89zbJn*E4AsJ&
z(p?TcKRVHeJ;W>bOXP(|yu0P|ra$A;i#7=4EAu<`?33-OOUDmI#70O9ew|yz#<}sf
zn|0fpjT<k`Q7>8-SkmJz{JQ0~g~@~^UvEuK-6=f#Y@7bNS62+ByKXg~IzMNU;gq-&
zOFEJdNk3Td@3TQyof30zMAx@>>&&(O{5yZ@8m~x<`|dRM^&)kC4@2~>y{J1V)EywY
z-7tK~EX&U7m%%qyM$AvujXbKgZT_3Gp!Bf0+T43GuIWftl}zl5uU%GgG}3-uyj4m?
z?);bH+j9@v?&G<5g4rvvK5d$PGq3slOn*DUa8|GFoXP8b{W<xiR(95Hp4}O<;pK#<
z-)3BW+>jQm);7InV%67&H;)GH^e`xnNw8%;HDBv-lR8($8=)&kk33An9)t<*6#qES
zNlk0H_Lt=QY`YhyMK1q+{Hpr%hi8IyUj0nD@^${x!&-Y6-dEDg=3XK^>y&rFM3+#`
zCX?nV$qWZy39g7cw5>zRc~eA~`cA8tihdIwJ^Q+A=cWZ|o`MzX{ToVH9n8vi{z(1)
z@AmKW--N2tmK~^x4at)~Q)^ogU+fuVJJU`lPj-r;6^~H8k+o_ee}LFh*EZp<=_NWf
z^UvheZ!PIKW>)d=rtRkZZpHhI%sf-?$IJ@0RsFL2`$Vp)X)3JjM-R0u+qKT|xvQy^
zXlb#s>Zh$jGrDA6E)2^T{qrm3%bDOE8(i;gIrpZ2v-$c}HuX%Z*_m$^&&$)OEXp;I
zU;Ey{!sEbW-~8QNk^2l&r&ig|d|Bb7Y_P|3LGYuQ^QE?A27NtyJ&%3r?4SzKwKuj#
z&pMxGDcxRjI9J<y>#;56*W9O?)!IbenR7<UrAoGIek0GV=;QB>|BhZ(biaM=Nw<$r
zgpLS*U*#pqGwb#5wpDZXss4G=`g_{b)jMheXM7KTGcSg%BR^KrllAxZHlusqMvKcI
z?2*0yZSu5B;cT%nI?JMYonqU#{#4yeOb_1@|6Xdw4Hmm)Zm9w}OwUq#tT%S;%Fj9w
zB3Np_E&NCAE)A7;4e?hWXUu)s^YS$7`paT}*KFMOI&bF2*FAk1cVF${nd&Wd;7adm
z6%nsp(G@c$nEz(zpSDin^R#0v$(@<5tJZ|yW1T0lFkg=Cho98h9g7Nj`kuYij{I1y
z*S7KPq4Fh5&noS^7oV%re_a0PD&stsC~>>&hgs7We$%gQbNv!r(D>+Gvq)?dx4^3-
zNq-OX@pmMtZH$_mb~3Z{-CB-kUeCL8T)&0BN?X5nWti8oUmUON+K%r!oNwqR=9Bzx
zrfKY+J+=XItJW4xjK1|t>uKP9^Z5P`{0raLynS@irqh`9_e#OA#BI;@UY@^}x^a(C
zx^dy>NtQBw>OD7{f@YU6&e<Wl=6?Ha=a)a%ioL&HS0<}`djF{<?_W>Ne5z*uS}<vv
zZDL8(sgp+CeL0Nr#hb53dCJVXF*zZB9-sBXKU2f9*lSNeiuUu2YTGQ=s4tiAI_<-c
zlY1mQGug{l#fSgw>Nk3$vBb}+uDDD>erDLEtCN$A?<$|rX6Oj{5zF0abbV&eR^5D&
z`4L<FJK0=wdg6TqWh)|MHzfP<NIlpS<?*=c#QK%qCT^ldi_SdzIPs9WPQTD}{*v=1
z>e-XG{azUNu`t%TZ}WLsXOHP8`9x>j<ofaC+~yze+5YrjeIu{lpO$&l=Hf@A-jAVM
zZ13jnm^*Pr%c7a<4I5@y$qGI3FYW7gx%*c4!R@V^gBLaN+7>$1YVC`gGR^M4=97>|
zkM)X^v;uN|f7Nn}u&lG%rN5u=w2G`?_1^lnM5XI(8QT2WfqSo(w^S?4{vOPutq}2M
z$(+0DAA6psT>5&p+kNQ{!M9etYO|vKF0p*y==3mi-mAwGt~_4Q(`~*w_2EzMAD`xW
z%8GqX-gVrR?-uJS%fD%!b!A)9T%VQKnZ5XS!%!`2#`VWCv+DQT)~%VfQ$H?Z`Q|dc
z3j5y~#&x<~#cPtvGi}&|YdmtSobN6z7pSY8?%b6$k?a1gnO}W>v)}3aE-ZL|f17yq
zq+T`wPebu#U#|G8JH3-(u}HKJb#yzi=k>Y8v34)#`B;B^FZcON&L*99)z7!u=X`sj
zdh^2@@!220ZQCDGTUpC_Yx?#hNxib%2HmS)3P?>XW2v3A?P=SGXDY%=cBf8TC^qZl
z11?1~&AIw~3M#)2wQgPiaIL4j6l>hxPFBfN#Tr?MSUA4*u*au~8=hHSQ#E@}NJzru
z+ddcdQapRjrC)}=kLe8lwsC{uwB45s?I&s1oqD_ama#bFw_QIbJ(PG=R;81j_*{~0
z>Xsv^DGe*SI|9YH*esqe+h}X}c*3JkuT78cKk)xWbH-xsWo(T;qDggJd@GVPJi;tL
z`OXU3ALi+P!pvm-+Q+lSEjUvQM4zz=i26jX^V*QJ<kD3Q*0`iO0ql?W+snv{X}?RY
z-;wttVc+@}Q$GGqsmuDp9MWphw^1<B+0$LiF_vBH^<BZK-;YGDcw)&Ke4u;rOf}nz
z8HaYf>Ak+dwdTC_$^xPE<ey)Jzg;xZdADO_Y{+Gw{Q;u=u?~mlwzGVfd3)Z{_P(`<
zm)zE!wi3VhNp;LG6jurVvGVi5yOK-K{w+Q5>7JnB_p^;x8Vf%+cm9~GySL#&j@d1d
zqelckNBkDpv8FC!UEvDO^_%nJyI%Udy!|F=D|=19pY#p+Z}my)%d*d&2@so~_D@Kt
z!20jirBZsYFER&lTxz}eenRTG?aQX7bH@i;2ELzS^;qG_*$=;7Wi-rmt3N#PRyiM=
z!s*4o=C{9LxEQ)4>F5l${@l;6J3T8WZ(Y9kp1xtw-0E|^eG=<mCQ28@%=}f@{^I((
z>ffy0XZI=mHF_2*HA_jX?g01J?@}S#H*e1nZDNg3f7Vs;$Cg>?q`kVq+rpWzrL5J@
zp6n|Te0G<SZE0#o_sWz1PCN+WGd^rKOX6k59hq6d{JWcbbf+8$%wT7=jcM<46sxP!
z4B^VXe&XMh6Kl3S53TS%eW7*#C3Wvr%a*2`W%|7Q!u~9?isLL^$sd9?&){Ct9eMk^
z$EB*x(x+|*`3haRf9cBP49_1S4m%c=OcOfea=dDZmC~XW6@MPq{67A``_j8Pm0K@H
z|J=JT`XFO$?U&qb&uVSLuQ;6)^wGWiTJQRutQ`3V-&t4RkKupt&?QSMDs}>2&FvM2
z!B4Np&RMW6%KCfEmKfWDoS<_K8dt9Tt4K;dQ&lbeUbA*i>HCs7sRc_lEnF8xY+L?Q
zYyX|c%Zu4cgI_gH2uXhN`hjf7!&i4~elK45TV3Zw!{$##7jI6uv{d<#*2c!R<Ts|T
zMf?w+(U#r%`@7xsPr`mG?Qt85`BSfGzu%d2;-uRlal4#yb0+DGli#^l?r9g9UEBJ4
z(FWZ&_nP<nO!1l_9G+IL>n-jaRdBujp1;?zN*#Txn0&eOjT<V@TZ=7oN;-9lW16^$
zH&1VWpHRTlsrxNY_7(Xlb>^lDd~IIU<Q$n07XE~P?{4S&W|M@jgsV*`RN?&1Rm1oG
zcbTdCqZucz1)cOi71U+*aLKZ4A%T6dclYi0^YL5UW&P^tm(r8*A%-*my>{5VK+8RJ
z*2W(}51N<91d2baHK{tEG-r*0as*HEE_FYvqr$gLJi>mTns2IW<#^=lvDF>P8!Ghd
z_`~hbU0HieDl`3X&%7tK&5{A_pRa7`o|E!JAce)mf0IY$pTo0%U0!#--^SxR2b=M0
zk*AM;NlgCJ<Fc30$oGNAu7Y#j+kdK*><rfD`~1+*{C(oq7-qrhos6~R*D5D(|M}#}
zY&F@RT6VoE{y`r0wdXf(5o3@Np3-^f!Q(?r&VOZ^eNEcFZ+6>nQMZsgede5i4U)^d
zizocpd1zH-1$*i2qlRaL<fm`{AQtFwTGqz($Dhx~y2`q1&Q0}8{Is(1)6usJ-l~NC
z4%o4_HQ^Dj-i8wMg88<Acf^m~Zq$8ydO_RTKF_3B^9@JOM;oe5m6&2OdHctW^Lv+_
zI^TWM>=Un}=&$%I&QaXzE7$cH{l9tAsVKI1(easAlHyL6pIYno<9Xd1sg>Wv_P#rt
z{*Y}#jrXSy-OPLz_oJ?5wY|^e)>BAmuf90N<q?mL?a{>ind~*5p7{?PKdpC_a+@BT
z&Xhj0W6{lhs|;eK*S1RaCI(CI+ID}gM_*9jlB?CW64$MM<{UDU`>k>zzhPb0*Sm3P
zS7*;IyC^?ze*Zq#-olj2tcg+KOJ#5FkbTeP@Zs`Lfj?cp*WOX>e0$tdU4PdUHv5#H
zHH)j>oO|!gSNu3BUbT)-#P#a6<YKoh#b3353~LYQJXb3Hv+wdcQSKP^YboWnw@T(M
zUa@8VjQ<|zZ&p=W2R?k*e8W_5qpDP7(lgn=Z8~RsUKg$XsiE`3;lsP))~Pv<9^~Br
zy<2+LLBVTx_{>h0?9~){(A&J}XOj`vCYGZQP99kMTe3gaaZ!lSzWCF-CYdv5+%8Jo
z_t<z3*VR<6#*LdV?MRBTJzm+6@?YrP;gY!xx0`n!w&2T}a$e|f53{5B7sV|mIbS7Q
z=BvMG<9=Ce!#=meH@9qOv4H%BaK*DOJG!-|TN$Ypc{Z;vYhaN&uNbmVeN)#uMaT7S
zQQNmpY4C5p**(`yrz;|;DbzG?@9Tv(qI-iM-`4Yd>9IID!O&;DT;`TQ3!|rh8<+1>
z^4Hd>7N75Y)=A~@=a^bX`?jb*CwH)%OW;z_P}`$<&zXPTv$r?)BwfiVkBO*@4G5P1
zzH`@Sb)B3Sr;A^kWwUcTB%IeR4GP~i*ORgR?cqt<=D%b@l_h^0wwiY8Pv7|O(2lPu
zGBIr-3O=hp`9IFj_dnURdRbdsw`!KC=F=DZzo%dRcyv<bZS!JTR)dnoYkRhR+7<24
zSie=*`XZxsVQk>pshPLlR<AkDxz0{vRmj@FupNeh;&UfYxVLosEak6P;-ViO{v&zq
zd)q$cRl6qepW|O}>C@IDMMnd9C65(%e$1RvI8EK6=;FG4$}=;jTFNrMNT1U%A%xXp
zx%P`GM|f>RCiw{eUU;la_rHpBHUo1}e`d|Joo5cksZZOu<k8of%15shOTzzNE*74a
z_1<L`!?C23m*rEgzbgFCd_LNG9k%rnme|)z7{XRa7%7;Um{`Dg$m=D{O^nTnUN5nQ
zHAEyz+>FO#dWnW%LkZvAxtH!5@-XulG9RAcynV?eFRmtqyI!8199&J8CJ9|q)aAJU
z;_JQdd*A<G|Ft&z+N_zI=cm8lJimBe?TtvDo}W|aJm?cBwct6)FCs9BZN-aKkqoU2
zPEJZpPELnf-n>x@Si=6~y@ld#NtTDqt%sNV?_Su{&@kb}3@wgMwO5A{8-DMTV_3k!
zprOY*WrCOx69+e^=U?9z<t2=(6zo?BJA^Y7$n!P-5ZJW(z+NW70P%2@s`>l>GwnEV
zhhf2#DJ=Kjmo!XLXJKS*PGE=?xFq_h^PV8jCkBbb2Lm{aKE$i;NQs^3p`YpKSYKby
zIAM7|gUmyv^Jm#Vv@69jx(Ud09O8e(@<UZ}0sE(xKNHm)PVgBNw*LCVDsg!3#D5Ab
zEDd}W4hIEh@LL@ff5zg-aA7xd&(;!#UvUCA;#21C=csA0Z)axUV)(E5UHx~sqQ;wY
zBMzRn>Z-<s#(){z2P9uHGQL>-nnQtkLJfn!nU~^%PaZP6KX3ly5Wqh{dDe&Br2-DI
zCj}UswErwV&)(BerC7^Svp{aY3D-ZZX1g@g8I!s0Toz_>{w475mA`0LL&L@AavDFL
z7u`)PsF!&4eyXv^vnPMN+a|A{zCe@b)m!e1L4OZBwsZU!E^bs{OmYf3B=qPJLx(wo
z5JQ>hpRJ9a3&fw8bNmr?%jR&bJh+$PT!!QXffdFqf1Nu%G5&O9@MzIjVflLh!2a+S
z2ZaNiTy9J<ih2PO59?PgJ}mHj|Fsvt-5r=2t~q7=W@L2QZ}<PtW>@PooP3`-{_y|(
zF3O#?YWB+4t3Ljl_=kVR8XkUz1wUF{8UGv#dgR2gV8sj#2PY>9flu$9*c4vOcl)Ou
z$^DFn-Q(|7{a*|Iy}S9opL54Q9}e>e_qTp|kn!4yA?APKuHFeV1SI~l{;B`=`~8&v
z_Ot)5`cz-~>wnpjcds9Qlz#rJ`@{c(j`ITg57_f;DXpFO!tg@t;&#Sw`$LLP#BW~B
zUD))i>Yx6qR+fdw9XX#p`gq>asrJf3MgetZ4WT!`rYHaFn*DE<DZd6!62te#e^s#z
ze;gDS{y%tunXSxyzk*#x^uIQR7e9Y~pO$4{aOdUq1)SZT%nlqZ8WRL+&%T%{!NBU`
zzeHH&!S;!aO-u$BLUWlMPIEI_92RWZ|1Km(Lg7URL!)Abl++Jd=0(20!ascfs_7j2
zukpx|f6|36|Cl@eYabQ<`|IyyrH}VHF1<GYpwF8S&%$JTW`Av)*pKhOzMpP<$IYZR
zXJ$)t>Y}?+i>%MRp7QS3=k>iOYSZG4>(89+pXFHc>z~5W(@)l&?T&Goqm|0{ZPMAb
zD+=dooHP3GlDpmP;nA&2rMJbi#ox3yl8Vk&pCh-l^7qD+=#?AiPi$zs?^0;{V|n?8
z$d=!0!_KVx{l<T9t*R$)m*)Au_cK^bzJ=HP6tLczwj)k^oo`9#$4>j3CMVSv<;>Z8
z!mz%nPgMNm`Hu6>g#rcDf1Z3Xc71qU`q}UP3Qp&;Nv>XjVcv%{#f2R|hpHX2yZhz)
zi?uH#^5+KBNIZ7X%ul(ye6G{f>3TNO>7Iq(c3lkEU}xItu<Q4;!mf)igryl8?zgXH
z&6>hK)wq1hLnq0@D)MI@{9u<d5<I`}w|L%t+m%5VOD`Qu-XVHAF*&m->GNu(k1{MJ
z4_0-0Zpm!X6BGRG))n!6`mrY-DxF`RU-l^e@k;cj)_S2k?GuEj_Qd>-{Z<rM(|df<
zj{b$NtJdjvJkC41w(08~TP52SpE&znR<^F6Uw=+|(vnRxZxoC7ojjs-d9|%p+|{h&
zrI-FKJ^ImYS?sZ^jhxMY7-puw+1620baaxc&z{*+oIWY>?m07S>4&>p1D?x&cU`<)
zb-8{(o#d-s$B#Zwd>$Xa=~-J??P1T`pU!_={maTguH2V5=ia`$&1+j59p6;mKlGQc
z(YlQ5>XEel5)-1fDp=MvzFYgXx_HO*<6W}X-|gf1s{a2(YUJnnzr>1DSe}~1J)CCQ
zka0)f<ew{Z@ae9X+Yj8-x7fPkc$slsNuUV(zMd8DpT`w^xLW15Zi;2wbEf-=$E_Pv
z*Dl?(G5%uVYl$n@I4&RAU!=47{=&^?+h%_3{co{2rQ=n}X1V3pawPIix-a?`7f;cV
zy~aPA&vjme=K7}vbMqahd(Zv+!&+(9T3!wluN~Eg&OhDomh=1M=}kSy;?@`Q8Sd6R
zIr-L#$9{7AuX9;l?x_qEuh8H9LyoC^$IEv;4GFakw>K>D(38A(a{AuXpDPr8TECvV
zed)O`$3Fe}k-q=8ZS<pkMuwHkP946nZmDq4jYnq#zHj~0oqS-*pPQPC^)o%5AC~I#
zeK|4LlK(d6vbpNX1uv)T&wjMc>&hkJ)eGZKm8}h)`eu{eKO5Cf`3>j9_Uv7jW}@@?
z-GvO}NVVoEU)NfM|L=BtyPHc(=kO;Zy>)lit9O_>to_XrWN=vg%;&qCCU$Lk&A#zx
z%#<^mHqZEYa%XvSW%5pEHJ*F>`WFj5s|b95WXjXGocp3uqAx0y=4RY{5glybni2cy
zxU_kavDg^_cjLoh`)fJerZ&xdJeT?JB-hp~z3T0`f4@8y;d?H;R>RIt;!^VETdN-)
z*)nm~XZbyEx(!$Cd^)wNr1$c(4OcnW-aGg#O0;f$yK}$flbEPKd(AvoCcl`t_0ZxC
z-3w<=c(dWWP*wbn-#;g+-%%}_niUmOR-C!(+IDfq`Bw3{vn{4a@4xqM*KfOwI^nM+
zeH@O<j5K2|r&hB3TXiYks3G`P{Lzr!(uaG#P5yT1z3rM?Dd&&6+)O=oZl`Y4{8dNx
zbZNA`+1l}K&*|-ME8ZVGR$}Gy@7>GRxa>2BSDq>ETJ`))`n{(IGLsv>Pd>V5rL5C?
zxt5c9^QYe2R`Wr7#mp~9He21+uC?-*6Mecy^Ll39v#iS5hhIpAo>h|hmbxyvxj33%
z@tj4({8uynT-kfXt}E}`(HmU<((ao2D&~Igwmy9N_ME$2AHN*fe&w{%S&d7~v2TC2
zKm4|Q`Zwcz6Nk@gv0mF{4BLg;TGyPK8n{~3RmE>|_S_wZzWZ;^3VW*0DC9Q(qkK<B
zxTlJ4vi&@-+75d&-`mMfYM<BTB`=?KJ?hKCPlEhx&S~QNwr8y9Ida)8wBg2DiDFir
z$D7OgG$)?<w6WDWd+ye|-KQ=yTl<Avn##ESX8W=WN~!x|7EG9`yZB`4r<N`QQ5QGA
zkDHG$y>VY_k!Vo+@FdG+nfX$cM=n2;pSZ{Q?VGLc-<F(GQO*^Lx#O~Nx*_A0TaWyW
z*6peO%~LNIP<6)p@-+b)`H~O!Wcly3i^<)5ZC~B1yV3J&X!z`<-fQ|!r+1%=Ec5W?
z*dKej{$N)0y`?MPoZX<7r`fAGAyPlEE7jL+l1E|L$Ig-;$F=%&|ApvX)lghGo&72M
zxp!JU6(QFITTLU28NYabo>RoQ(e_#5to!i-j?SF59;bygR@8_6JRYl}Zl8Tc|0R$4
z?Ny!qjnDe-_g{@%^!rb<t?pzwQ$dUW65g`S|GGkFZAg>Kur0s4eSZDzSuAERg_$)Y
zwml7x6+ZFnp9O!<lMUyCUhWUyFll}2YOB9La#LB;3$wl~p7=L7wAUi}j(OX6yVmN&
zduwNOygMX3eech*IPtFX1FLr3d}<WPuq0|xV}CODCoj3HE;^^rM?NceOS-%9#N)L;
zEp~;5*Z$Ic_O<!C?WJ>Driwk;Wm{~$#C2kfNa{k5I~N+3m`fjjP;`%r-S@-dP<yRw
zHuo+@>%7*}*4!>(d*VgPjl1S<QJy!HCKvrFi{Mm>-&lXK_G0(iDQb3-tJ}G{E05os
zmO0yJdDYDa3Y+!TZ@qhQ$G<mkXL)mb$4%@qEJ@z=-tbOk$$?h0gU#o{rSv|T7<6C!
zlCZDh)d9AU4(H3t&6^L;-1p_c&Y(ie@16I*Twm3ay?XxEJeR6dyxRhohOjd=u3w=3
zOsRG{OVWxTOUl1T7;2=x%kztjyBW63!X~wmi9ax$_iNb2(hau{x=Vy!OgmOnxAjr+
z-*{Fwhk4(d!f&ihdve^a_U=<N&fu57rkTDw_v_6>4&$p_dmJYoKT*=9pBiLS7y3<a
zcE);*ea=A*uWmP+&nU>;>iI-mZA#u2i`gYHWjVfmYyWR=ZJHb-y0ojw$Itw>($3S~
zxfd(uBp<UiU23;;(l5c6-*^3bykPtMinBUwYs2SRe>!Vi)s$8dCH&%2+tH<))(XAK
zY4^Hi{b+Ghw(N{HJFS3=DoTI(u9|oKUG6S$=uW=7<V<-3U#@kZ*5A4GeYN=RtN!;E
zOGtcEG7REMxP8p5s@c-?+q*{`#tJ54tsBofefSr7VZj>FW1Kdw3@<Gfytz~M{J@4(
z%`FKlw(scs8$30zW&`g=qmbF|{eKloW>4HAl={E(aN)88l8UD{bRFp0Q!f4_=Zit@
zgR}i@k%w6BENarzWKa~8E<UyTTJn(<?LW&beBEd76tF$#Kl8(`(@k!yXH#r%O<%FJ
z@$T2?b>-amvr^A*taO<D&74X4a%TF6_jeUE#8YQa__C8TfZHeF{^h&<Av+GWZnBr&
zd`W>hzDVhCyZn-@wa0oU?unSS$j>Wk^U>5fOIN>sxO-_`iCXOPNRzo{FB3f%&0Cr&
zv(241wc`5=KPU6OCCk{RK0WpE{EKbxrFv&L?v~&Wcorsc%;EJ_b6pm(HBX;hRNL%)
z<*faZxx3=7Zgz+&<yKl=mffE9w`7BF$GpqIDP=b&tZ%bl!Y^{<#vJQgMxW=k%w~^l
z+~3yKx*^BLaA9V4?v-q{1L5AQJ!UExeXjacP<`a{iy8G(6Mp`^d}ha!-K)1`75YB*
zyc)!>p7DyeH7sa`hSLw0?nvWTXP>*-%2;=Jb7{`$eWCifUFGH3Ng^wJOL9|u-d0~L
z*>w0<dB>fchsK6_JxB8ec2vvTf1JWHzr1vZ;FBFG0`4b7oGN!R&7H3CJ!Wl)VTU2#
z9Hpquw_5lj%CFz<teyYV`lIb9!x_5e&&qBF_jDh*bm2Om)kzhe_}KS(ss?)7tWQ|{
zoO0}Vj>*G61<RjCt-Y?c{n;{(uE^uBz8^CAy|?Gft$kY`F1+~MbY&)6InVOz8^!<K
zo$0*o{(^r~CVz=nm1tm_YybM@9J$w)XU+D%4_h&*qb6**%$(Y-Q@7gNNxZzj@X71n
zesZao)@Ny7EZb~b@nFlIX0QD#j{SGppVYVHpWM>du9Ck+tfUXRMwT4QKJ4!OC^c34
z=cd)`cWk{S|0Z#LS$g`fRll!#>|hhSeYbn%$Maup_v(s7U$rdSHcd#xrc!fqhsNP-
zhVGpY?>x_N`R{pjCHJ#Qlh=s^e^0+5JFl#n&Eax(o5-3yOIeP)PJD67_vto<H@5|h
z9tFEDn7DeM^tnnN-nuibXKy}EeCn{l{^etZSv8loJLfSNc@%$setuRk7yoZ_%~>2q
zzQ!M&SMD*hU*T$W=UzmupKicYIkN>*<2JL1l}?;{Cue!=-$i?_mL+b@z1+Ig=WK|i
z@-wNK{TZEmeb;|`lWDSbvTW-9de?lWYdl+iE>&L;!S>!|#*Dtuh4tMRt{vPr?^&y8
z1E2q;2F}ZA#ZPYhFO(~1ah@Ww`$}-pt;I3RGm<}UD6HyEX`OIG<=#}LxsInl{g!{r
zB-$wMEWPARL#|%<l+43(R|k49?@fQIH-FcH%de7;wG_IA`F2`!?aez<nWi{#dE}v%
z*K#eteC7ILUQL^HSn7$r*z0oF*DSw06^<?WA;G)t>87u|nIU~$EBKpLz0S;FI`&be
z`P?VZ5ATBKrssDb+06QUe`)HMufeafuQ^Pa=KW{`d!PG_6HD%XyT&nFrNe9Y(b@UN
z5$nqOZ%O_%RGMWbS}-f)>pAtacA33rSr})}XTR}OS|hj5=Z;QW*xLEx8PAO$|4_Qz
zlP_l(;i{V{VQDZkWmm_WjBg!!&;1Mg9Jlm($Y?!Ny7Rd*K1}a|zW#)XyIJ+Od!0Er
z{g&xho`SuaayBaa-y3yl|I*AUFMcWcs>$@F^fbADiueBf{d+UB@$6ycInl?x7oU+T
zczxNyYyU5Irl_CCWcTp1FFCQ|uA9&7k~tNRXJ4LMYixCI`aaIDCOWIi(_VePXmLfh
zQ0D19qfH`lb;|L=8gITh@cj<G!cn{X<=ZpPZ<J2F`}XDP_b{H55w3EPa;?v<mQI^|
zrJc#Tv2`2UI?XLrlNV1-b~wd<?_url*Bstn)AzPn-JPPgxN&_`=Ms@<+m_?s#F{TF
zuYS9JyWqY#Ufpr~1ibEjFPG8z_+)P~<Fos^CRRu0etUdAE_&k9i6yd^LMAzRe7dIb
zIPZh9u^(UklbKuQiSxgEcl-F!FS~B4ep=sO7<Jeyq4CPEu=7j4hOa*^>Jx0Fb?B7b
zJ~7Tof$j~{v`=g}?Ig!_Yx0v%`n{{fiVjIfNPG$BwG?iDRqEy^Dlfc$hFF3juf$)u
zD(R#rYUx_$L91Tvja&b>#;|wsf$*%)Le)2{%Uwdlsst~@%=Xx~=J5?pg-eAM!eYE}
zdygf~=iRV&PL)D)Z1COB&%{15=02Co*#2~5U_y@KN%7T@FFT*u^}B1X_kXLTmk{ij
zvP9=St6=yt&+{AA=DqJM`o8<sexJ)nFPBys`&`>KPpr(=a}TeGZKlwc9W@^=v4^;;
zAKBHuHe_e)Rht4PN1Mnz&(9t^m#!(deyF)9z^FcF-?>lG8cG3L7fm<DCvv~B3Z8KE
zlkzM{ACJ_|zq*=k_MK}!pXM*%JbE&w<NMp|Nfxa)Bh7T}H|@B^q#ltGRByNax7Fs_
zZtvx5S~)b-j2=G|7cY4;>qBQ^QgGJiR5#y4Ro`MeJ-t>7i=GaSIkWZ2u@Beyf7yDA
zUaHa2zg#yf=;(?&k7t%{z1Hy}^|*-dy$k)eb!U%73(c6Pdd^BKKjnzO-dVGZg@^B@
zMmog)DG2!57@TT4|0~nG&`@9BIaM1^Ub{T0qhk7Zu?HtE{#xhvQmAUj6^EE*yjl9Y
zemz)rc<NpMS1rPx&F1;1miUC;3dy=L|D@no=fB5R*YEjq+G75a%15`#%1*!BR`uHb
z>!FV0FYo?oQ_XrNyLeR=uVZqO9cvDg+KyEYM#>9c{A^iO_40J}XT?2%9P`d*eeT)N
zbSHSuhgPZJ<Lhjsqqi2>%kOz$$0}Q1;q2K}=X>&pX^DgFPe&(*X9m-sG%Gy##JV*&
z<UYS=y$w_2A8Yo$hifWJ-`x697O-)K-AcKs4~(Oa{k|WzF~hZc&xE|coVEQSMsoYR
zPj`68sMQ45rpGi(Zu*$uJ3;h7i|oN~bGs4(C$hS%JuUP4N9@|T7aMk|i@z40x6)}X
zZ^F%so1PRuFS|1{ETr>!z_(6@qYcgsf6MP>o;p#In6I6gvwiBX=d(SEV|SgiddoF)
z`=qV;^R=G}{(e(X5r6Z*-qW{(&fF>BVSIBzO7MG!Nl*2L$%}=p{8riRR53N1XXjLG
zZ2ail@+fb%wn?{39v;`W&p+9(-|E<@?($N`mb2=lx6Q)oiP@IU>yNYW$Vi=OZ98t!
z+Mm>VP5rrn+aJBZwk$b{opSze%7@D&^`A-pj?B{8yt%nZJ@Wqlo}l;=bE&#ZMuwY?
zh0lHbVBeW}KO#<F7c61jywhw}@8_k(i{cL`N=|b-r@3d%?Ts~gb3Q%Z<Z<E7p=P&w
z<EdMYZDS98_ie(4-S;f5jqm+y3@<o#YucQtb?+Fi+vOkiZ_o8*I%H-z>B5{nhRZBC
z)x-akN5oE^x-Bif!B_b4MeE8#N1rTS6{Gy@T5VH^2d`7H16#Q9Nxuu1o!%C|xpneM
zuiPgtLG5WSZa*K3%-wXv^|PkH%Bq<@zDw#iUO1$+V|8J3pyq15WWA#F3cq$4nTzY#
zCPl7Pp62Q!eLHco-N8CX3v<p##ThjnUmx)Pd>pY-X!hJ`_qa}dy<`12!arL0>7PSx
zKlT^rty(pCr^Ttt3;TCpNsmzfAkQ_)bL!Q5wRwr|7E)fnrYc_z`s`HD(71BaQ>%x+
z)~^3`d~Vm&xHF4y^Cn(9bNKHam#CBSQ-gnQoMIsp9B|6+F4Js_V(w>!wR<(r{%Li1
z7_h0YbMK~C{kFwSlf~os<G0^Qm{%v_Q-Aq)#0<f#^ZX%}Aun&f3=a4HBF!P0S;x&)
zJ!Q-HpqdLkNhz<VG^8!|R5~IPxw9;Gn$E+@8Y|(PRkJpHP<ixoc|gVr|EC}0ir+DN
zPI%kp{K7l)do}yd!nck5))f;A%_f>C*b3y#nd`93K{X;PDfY6P`_cEaueo(qzlodT
zaNzY^mL0lxZG&th7M@y?Zm^v1xw&lKdl$c+t<iJui}f9R!dhH@gy(j8fkDR0S$6|O
z8?%~j=X516{M`DapzDTru9Qy4rPv3TE-UZ4re5gV+4|8V_QK5L)k-|vA9(-IbK;+I
zZ*Eh`O@}|8?lYD!e?IFT*rCW)eQ<ZUxa(@Z%ZuMK|4rj!I@V_0&aQi=aEip!*OH~L
z9>_#azp?hWaQy1CF9e>iOrD<;dp>Qt_{45IHl_4}_D%D*ADyq;u_Wo!`p}X|bIgsn
zOa1td>UwmPy@+}JE?xg3bLEptr4Z9uM-Q2v)Uhkv^R@D8$GQKq=O0#<1xCI99XfM&
z^lH19t0!~VP8qLfTvt%5Qhn&}m2Y-Uc2@Tddx9^qGQM1W`0<(_`hkHe<}wqen#!xq
zkJ>tEd$!U7{+TxZ>v*>n{WYrax|{p)sGnho{?Y4`MOQIhbDb6te<Qx{+A7(p=FVsH
zcFn)HWAERXxZ6?F5<lp4dFmgqdOjti{tN3Hi=I0PSz;$nr1hD<3ZJ!FW#<LexF;f0
z{%OUhe-~J}@wrA?!PNKX)hFDadFt7vzG%tGCAO>dY%lLEf9>#P`4;`9n{Lij>Ts;r
z4c=j*!G7$L^OFZx-z7cb@47Z)@{V&erYjfT;kormQeO9^&dE(7YkcxJcdAZln6xYC
zp74J2DYkKHrzcI=bbHe#6NTxDn?+pHWw_4CUks0$yFFsfzAG2r+sV|)B(=p}Q*-Zo
z_)gt^mPWj#3$yUl#fjW{<$oosHcrs|b(iCM+`4a<Z?Q8SJM&WKvE;Ge;+;Rcrh27J
znXU3mTV3W`(fQB0_7Nv7GE`XoHGi++x6XHuFwff^kfn1q`)*>!nJZQ5=KCX5l4iaX
zU1eHvB_>?%!Od$6kNuHcp7?R@Es5~&*V7Lzbvej&|C`o^Wz)}XP+y~I9~Qbf^;q)6
z+H0q8nVX&co@1EgW%<fv`R_YnJc>fjOZNl?vA$e$#?(G(3BPIG(w$c3#dqaO*%L2+
zR66`gH>2;R??IKFT5NTR^FKBG^_jzzbtg^t^8d!>&1O%f&i<)cy)w>f$_r<~y%k;o
zhGFX$N&BrUaIV%&&*eWUeCuACxOsDr(I&A6k9PkMS-UB6m3hf!*9rHYOp-4>Yjw9t
zu~<)Lv(PQYuixMHmF%oJe%<_uuydK(iYM0Rg}wy8%*qMBq+pqD)v!Fs@KBJ^S;NZW
zY5g&I_7j)oS`==`3awW;;I+V|;YPZ~jfjfUx63Qs{_surzC7Ki%!WPwY}qc^Ime~`
z?OZ2czyEReD~|`ObZTB^ulT^<-K2W`dG3N42fcPLWQ|h(v~{mtb@<2LkI(h5&z}6Y
zSwP>d>Q~Ag&$4w|#cVx6Dh{SLD^%vG6gerb)z(ow{y@}w*JsVBsZ;W6SfZYuekk9S
z?X_>_o$|{wZdxu9Uw?n?%o!RVwr;2o+4VlK!u<Ol`&wqXMImlZUORJ?8=3Dtnl62&
z+b(leaHh7E-CTZ=p4ow3=MS&_a>w??$9vgv4BM}C*L`i-*1|2jy3Z?c)%uY66O*;?
zKHZ`AW1U!eS9jN)zfJ~)LS2z>mBVE(%FfC1-!7r&w|8OM?vMsmzLZ7hR%E`@<Nlt?
z_EG4$in{L6F!j};KLw&&Lj&y^pIg4vzwi6#-ABP~w|(Cf`0>AeC;1^Q&0x{H?p5Kn
z(=X4RmvuXLmip&h!w)9Pfv*KGRx(a=`I7$CpHbCr>dHOGm)xGFo%ctPrAzzg_PNU{
ztYW+Fd2TS=G^Ojo?VQir+QI=h*WE}J@ITc(%Rc*(Sx)Ud|GS43j`>PWId)qmerkMl
z&t(G<ACbj#C#rr)t$iNwX1AhWTeit@H(zU`lxw>Uof`h1JKa>&`rSJ5KYLkM&K4|_
zuttVhCSi>XERA5(u0{%mrk2L0Fs`uz{PJ-HLvteoVy_tQ`NkR$lYN<$OE{)!H^0=K
zyLa!(vXz(fuRD16?%lhp4h7}>Vs{h^ET2!E^Zob#Rn^(6(!OOy-u+wheRF${hvUq!
z3pdVPa5;1C+RSMa`x?0wbhNcko?u8wNLZGfkkF*69K5k$o7vBPnQ1;}k6b)?=-jl|
z@?wYj)Eu7k&*Zr9^Kihmb7BfllXw$S*bFum8g42!G+>w^Az|@9Ipg^WRsqIcQ4-84
zFByW$wyF7TNI6vYO|DNY?b$i`!hfGR78opIF(@k9botL)K7lQUg<A}mZZV}ao_nTd
zCNJ3AaE&3=TA5ooz5oBh1rH3%%eFmVw7k5ycro)Wi;FicXMGI3#BfJv&RIq;H9xh!
zb!x{N_It6NV9fRT7b_*JBk6GT&Y_p_T&dQ<>E;U-b3SlR$W2U1di~|$qonMdM;t#o
z_yVR)VLWkr_Kkn1Bc8>xnKabP^EFKD`?$a4|F?hLCk}nfPhT)`;@n=_3)c=Gy2g``
zm6*#kL45MU;<EB(j10NG|BYCptZ&x-V2*7RyXJ71zj=Q!JJS&sQN{!PT>oR|PoB8A
zb?;{3xszMJ#+zRH@A|p$%%W|_4wadisck#wx1s*2deXy;q%Vc<<i7mRTQ_y>+}Ufd
z*H2j4x_0Bs_*9AAH!iQf6=ktwhDX<*+s~X?e!HioJ>p47eUOm;EP-`~1%uC>-ZL-%
zb1it3nEz?}q>uU^-FfZezLkArxZH2#Q={YKYgd=BcTU4PHHLI|abfxO^;-YL4;mRU
z_2~A@VQf=N6Wg|-{)YV#wPpVg$^R|iQox>JT+<`3-0*Py`TF@K_G)KtoV#}GasSWz
zy34|^g-i<!Tk@~`<o{4E&YL@#_hihR$*{#|4G)7Gn;0L%@8iwq|9{e8(ET^}xP6Uk
zuJ2oh`iXz1zCZ5xS3UiDJwM~o{pKw~ANHpdmB}y8W?JyW_@x!k8Xh<K_@4jspa0FD
z{=Yu?pZMwjub2G4-*Y5p&D#Ihg8!U;@ZX((%f=1ger!K_{KYPd`ZbMf?jAR~@h?8O
zbaMUMb!$2|wsxQWf7Q#1+5Vd2g==q;mt;ytzL1Fcr@FmBXmf$NVc3QOGo%04Z~XCI
z_v`wh$mkohG;UZ%{wY0LQ(<WENB-{dX_Aq(G0J}On}6zyUU-@Obk6_0C-FC)B(MBu
z&L0@9Z2fruw*JnkybL8JEL8{UO#U-(WZENPf9=YRBY)q&WV>+r<}J(m9Sn9^-xz1y
zvOM(fYKB=D!`=t+i|Q5481`O}Kf<>_{9m&L!xyFhu5Wl4sy5npa60IJWUnpo`tK+|
z$Ef}S`|>yPUk+-1k3aJ9;K~o|hD<L+|1aq0@TwR1d|c{}qr8sPf7dzkf(`W-+RuI1
z-|?~e=!GLc<+J=4_Fk+P{Os<bT-^OX>DvA+^4HJH|K1<vmj8!+Q;mXf_VaqFnt~aB
z68{(&Z2Z6Dirufj$Db&3U#>sUpLFIQqkYVo|BUv0mmkT0SZuYr{y_hyHUGD~P_}%%
zf7$c?e~X!B+kZ$t`ttw86Y<9r|1ZDAulKv(b?fh7`OEGFzw2H8R|sCR{=;0i<kb)L
zU+z!+t~o5PS2_RVV)b+T9C^k$je7qB>P0^L|5#Z5*L}U+q|*QFe-?cI!E8Un_W$LR
z|8H_Ai@P81pZfE+*6)bv{~zp+_fu1Qr{=anySvQoj^nhij&u9BHtopU!amtXKzwDt
zl+TvQtyLG!IWOA$%lhM~$eF7zJx$VX?n$beW?SUM*MD=iw|U%e-j-fDo$p&(lHAi;
z+BSB-|33ej@E*Aj9pZw~j-RefZspkFCDZO8@<DlGRpO7{vu#sO3hdo~g<nT~$Hc``
zyEb~WmY*v9er;OXse}iGtLDDdvfM7&w@PNiy`<WcH@9|j-s!%?=|9n1ecH2^bxpnH
zs~vC2NlM4M%N=>&{YUGmR6&8K)T17qQ?^~|hnPYaZ=2WuVOH>?s#$%HQZ@Rt3bJfM
zHoDII6QN(8yRW`>mAA{p8>jQ~CS*t*t$6mcr9WqXpW2jHGolM568B7#_2Rf@bZGjA
z2TRN*q$yt9AGx(VUsY5}=j}!-dxOn?Un$L1T4`%4<Kn0+eg1dY&iZGUU9O3~&5~le
z^>3+}WM%vmDdowZjvO~JsGo7gD*Nv|rHZ(@p0ky&?g?&PUoqEs#oc)3nKLEtT~*o|
zCEB>}<#UdZiO=><S3e#7&$oQLz|U3AzDsgVyrw)aJG`sBD)HWDR^`9n-4<`zrIF}w
zK6`HUd#UfTu`>mwcPq`;I`1caE&jImiTjJ*>|kiQnW}Cp=y)-r<n6;Fq1n~ViRCO)
z7i>JHu(W8W==tsOhIKr*OPdT1@0wQETV?n4Pc7Fhz6s4+^S`ucggZPBoBh@>S^A`W
z6Z6yPg_ZjsW&2P3K0RrpV9JaiYmeO7bHlCG?A2A@x&0US^&jfoBb@WF$Ut@W4t@QG
zjCao6yWBqV+A;VRntZUZQ(F~W@OzuC`lO<DeC7YHKR*|AZ~cXmIjQ!>{`oV{78K?g
zRSI%!-TjsGKJWdvUoPsmez?N5eO^2Bv4ykNU+v_qPi%f?o}T(8pLu=%+bu`tJbA3q
zEW~|MuV?1E+jkZ{v0C*^<;Odhns<5&uWx$PW-?j8s^0XPVN_Nq`>d%-4&Mx<%C@I^
zO=aH8yX)*?Z=SyzzwekZ>-TIqDXAl@|Ju~yhOOM$guvjl8>dD$eLku9rzYUd{fu;f
zAMvjY2d2B$-cXFm7W3cwc(!u%(%En2YW`*jH_l?y3h;mbWQR&A_b#z>oTu`YGbNoA
zPu<@(XU6iRq%}pEUl#E^zN~M1{Pu#zg2xASemPC3R$n2Y@ml}z<nuk^SBzJmD4s8H
z{>toEGmpJ_YvdYdq<!e%uDd^v`Ak=lnzxm+G}Pt&Z=K6i-IQxyu8e>1?Yp5L!^@Q(
z(${2u&y#xn@!Qw!mXeV|E?NAq<9la!&icEvH}VsANS8o(#LkRw^I|W0^ejnUaZP;Z
zO55cZ7Md)|3b1*&mSIL~S8;TnbB#lLqVqQ9V;Lu(Z}ZGl`IJyM`DJUn#k~!}m$#+O
z^Y(suJ->KK*xGB~XQ%wyZnk8XN9LUBEzONP*=K|~%q+B@^L2U1R83a5^)J`2u*lf9
z^WlB5O-IA_@`UbEv+`ARE~|eUR@r*`%)CkMU%wsd%S<VJ*DIQDZ$HO8_v6QU*Vw!H
zAtz(ywpxc5dC$N7u!&doghA%+hNb)4IP>if9e;iJ(1(hjSGyhvPmz9Avt!jn`5S&`
z-qpW-AhRX+*PF}TMHZ7iBBc*8u3KZWeBzVF&O?)5UOAC6Q)T`2ox(TzT(14LbTeIT
zTXDNP-)@%O_D#!tZXC;d-H<qG%_a5ob-b5<ET3-4#vRY%#WH2yY>$si8#*7YH9Vwn
zgY&|nh+?<==mpC=<!}Al%xY{N_cwguLNmvj$<xJ~Cf?qCKEe1%=q0z~?Y}l`*j}^#
zethVgv<mK(9|EHH_uE&C{8~TZ#$u;Q%U1e5V(k9=`tRll(V1Ij?A)*^s=&R{<Y@XH
z3HkfIS5!7;AH1RQMK-ll{_x!9-oJmD%}+h`bDmMstJ7fpUB~?W9`PUcGMBAlY_DaV
z`MTnl%98L`drI@Bn;yO!FuNedpL<5;idk&RF_E<|PIX&!8)g@G+-#WJdxAr4*728i
z8xwL;ee5nZ@;v{QwN+xWY+yjP@E6sbz55<N<hdT^^fB>p{<Y^dc^_v>soU%pnsssO
z;Ro;5X~eFu`}aF(%M!^Wl5H6-BEIv&l)Ajy&fVcv<~TmBb!~HGSi$e28{c(8izn##
zXKs(?ef@q~Q-~y6+UA8_PfNcVh#a-wd3^shtwXDY*f?)X%l#F2P$wh6_Rz#qP5kn*
zj+V3aymei*TF>Sm=_+IC{4w>`&2{zBvOKLe*;@Q-_gV7p3ZE7H>eG=89|gp7UFG9_
z;|^DS|M@%TW$@)gMrW>D-O`oxHC<bD*jTJL=Pf7ObWU#`yNi{ptNvFh^)8H?dE?!)
z<9jArT%B_3caLpD&Wf*_yIAh6c>89y`>_R`uReVEy*hY<!jG!7mRJMhhfB8WDK2m`
z&;2iOee>JbZ84^mLVk;WG-)k%2<DKrRoD1_qUXu-$(n}eT`oP!tG}9Bl^J00S~b|L
zy!~xVjRgOVD)aff7&tk9v1x63ZhBZ{b<3>qvsV1p-(RMke)U=8dsEfZbs+|_{c2v(
zKL5VuY+cN-GA*Y`-6QKzV2pM`!8)_H=f7Gqv*y}+otm^#<!akDO*8!!I$Ug@WmF@d
zhenzPH91$7Znj}{>E~N37ARuo_-*AChBYjz^A<m<%@N+G^t!fjKG(E`J^Z%!RaT3h
zlDx*eeo^$kKhoB0ud^jM^};U+`R-d~*Ve;SA9MMH#IiXBUl(qA^S9~fQKmmy@j^_W
zK3s9WaqxMwcG@acZ=tV^IunKa7JFQJZTbFn&LXjm9cwpsc3d-`^Eh-SOJ1#gMDo!T
zP0vfuzCB?)8`zbq!y~QQu6(7PNi%m%Mf_z~6$8InPq?<V#ro79d){OjZ_W^NJX3O>
z5ig5<GEcpN$(^%{9{jm5t=-i1z`Qfdw`o4_i*ee(eKlgr=grD9;@)scH%4mpOpg#X
zId{YKqS*zd(n{l7SDzf+r*R~zGx@i(4$A@-6-L7?ed!P1*QxxvY1yO@=xxfeUgy{c
z>0_M^Q+KJD&b+^QjohnC_vZcEY+kK7{od-c=K@-%IUPHGFl*1%dD>@I@73xK+BdiT
z*4Mkf`P^sN_Qw|Af0HZA9BO}h)ynDVcP{^Rxw@p(&db|&-P%>@pUy<>=;GF5;%t2y
zm{y#Yvq|ob!3zT)`yPgqnd}p7j?OrEefgP7Ub|;rH+K|r4Jd2V4>C=%{jIo1SwJ$u
z{79F{BR%C$i`@-O7u|gSeL{@kzb!&04r-smm%ZHZTX8anYtez0+`PZ9lAg^vT2=D%
zicjPe;Xenw(n}t^GoJfctwdMiVDE}DN!^I2@273HZdrWb()xL^C)o}At_pOh-`>2$
z)#+)0(Sk368|`;SwHmx*=$`HU<lmzmH#bl2(aYi4<;NDE_&9&^p3Ap|HC`D+6m9d;
z=+kd~RexD2y0mOdD!+QP=-WH{N<4%^ZoA}h<h&B+s<VuFbv0}LYuCnQilIi08)u4N
zWLw?!u6Nsa+5Kzw@w7KziSQTrb2d@=#m=Jd#=>`YMEA|Eus<u#U8J^e%k8?=pY2%p
zibhB5kvM4Ym}j;8+wBL_%*`F7Ud`cM8D8)@vF^x$g#EWCb<6RI2)nFSJof*u@75VT
zuV(Uwr~h0Q`JzBQ(X=o9%@YU3t}Ak9Hl5mE{^LgO0m~V;7L{CHv@2j$jot32rE(XR
zMwyt@y)0RBb6%?Co5}pEFTdAOtYIoO{N^&jjbD3HF~bXq=8u~UB=7v5!xnaOa(MIY
zTBEPGch5hkeRPG{m0uGdMmtKlavobX-=IY6>rehYVS7Z^UNf%_V)!X4w1H*g#E>mE
zaXw17*jkFXi#Jb@Ty&|@`{e<p!?UI|p1IrgVtawqbo=KY{r`I2;*-~opDEcmf4|o6
zhsTdrvVYY&Gu>ZfZI;n3odgS>=a1xA=X^1czkBrl%STQN1pPNYk$1YZRq4EL_O~M!
zLatdaf0*gfDBft{mA&=6-?GkL*4EQjX8+v6ddf<#wAWo&DBK?X;9u<`^@VNX6HN|X
z<uhk~qPX8Qz+aWysO@?1LD}6U*Jk}@-nak#K8=|-BzGKpzr|WA`PS$8zGuU)r_9ph
z@L%M7ZL03JmCko=x1YHm;rNW*uaE1QkW%297pLAO>nkcBQdoF*{qa||YiC7H@L#q0
z-i%q_9vt1Rd-ZdQXz#DCx1PVm4D!BYPfon!WqHVMnfC{wD|?Py<kZ`teTKp5mHVOD
zp(*LNTXwAYY4cOizAC|B0Ym9-sp|@w+5Qd2lQgdSxjU#au9&oF^%I`*wih>pKeM*4
zdha;Zx+ScH?YV-*!FA3@3(6O_m+oJ-^!e6q&5g6yKk~VCx3O|T#_!$xiaF~-j}^Yz
z^1bJmP^5(OL6-LmGv+w>Rx90QoqTUwva?_~AL~Ar_@yT=t~zwY?XXSx*~6bs1jSA0
z@2z@f_%?L%o4yB2mQQY+ywE?V?8>S4jLX9qP5!bh_p7=v<&Eve4f7OSepX!k*Cq1$
z^9kQ#*+S;S{@)##`VM^&3+g)iI?y&W?TS?Umt#M7ckh)><apFoetq7FYu2aDQzm5m
zyE5nb*FwiXJEu8^?Fv#~mv>h%CXaL3s|V|<>R!(~R;6q*<*&Iw>!S8(CE*uMTZN<2
zkL92KV(~?}u+2u%lk@fdwQ(=__iR(>PZxS?q*ff*oK(lt{C2KrVaH^}_S^ntb@sA(
z6Zbxv<z2Py?_K|_C2#7xPJ4yO&A)qYg2=|*S^_>(?!4Kp&t&X==-}U*`tNsr{CkX3
z#@_w?l4;j{ei+%W`}mse|K*D>C#j2+Z`qgUw0!aUPE7};g=%x|{S?i6@T|jkM^EgX
zH__3rE|<sX9Z^?|^SfldV)eveol88c#J26&{XDSP{fPA<2MMRiUhftcviy(ys<<mC
z`9AwcbGD0D=6Xs@IONNC?C-Nh8Rgx#IJOqGpDz?%Ybx3q>e2np{w&v1yPcIU@^oLN
ztg|+>yfJ70$Mnm(;-2RA_lv9V-d(w6Ba1@omuFv&PdV{4{)}?2b6ND<JbtPC-QPWD
zb${w(nbsou^4M!DrjSR~wGVEeS7nZ?OEt(%2%mgFytQfh-nl%Php#L<pm#)i=bvvG
z!J)shw(^So{@A}HQ%7d|qvO}-O;C96$J_cdX6rh|uH^G)X9`Q}UtgEcTy!qPQaJpj
zn}>o@W~s2n$AVvX&V_xRy+txoUFS!Ns_I#Rq^17inK$Oko7Y`^T*D+h<@~}Ge1*UA
zqTJm!{!6mg+@$7s#)WU9SGGK(dhNq#>AW4~r+tpRR;pTDF=qyoZ=u$q!*>%Rtu3y7
z+Ot)u^23oQEp7Af@A;~9BSTDS-UnyDN|i$yGcx~etvxB&s+W@7U+ef|_Ph-N@BE$w
z>Po$DOMcVi_{lVC*;Z#!*2(YO{AbPK%$xQlP|2D3pJe^XHMYs04vWr-D|uzgBxSX!
zv1$D$YsK|nj#=-2ae1Lho*P>w^H<-B#>IS^!aOU#1&Qqay~wuM{KU(3%d+B@IxDyc
zi>`27r@Y{eqrf^X$EnE`DJS%%ox1nZ_@3~djEj4>hITG&SgZ8)EX($wm?^nsH5QYP
zhj{S1UGUn>?|6LTmyesa%<@w3WMx0+7g9E9uSWRx+Yw>kc-mG7a>Y2Eb9l<I{>k0K
ziq0z?2cLd-;q_Ae-hKAR<A@E8<r3E<cZGfq5_(Z4$oXdS9MQJGfW>O}_nGmmTy(x#
zajkfK_YRo@hHdU=ZI_r!-9NIU(&T>evgY_&_C4#hqqZeHn;4iM`a-t4PF(m}3<sao
zyplc<lYMWZ!zV>n-!odmTsyZ;twV$3^hS@@CiyY)pSmZ-Xx=<$ry@B2O~k~UCwGo<
zYdp8B_C6T6@4nZIhR05eeqK;Hw`<j>?hgUK`qkrKh^76}v+;kmqi6k{yEbC;<s9F6
zH!x&+hAY}mnzHx)#|{?H=LZrNPCxp6UG7W8lMhW34okK%w00D?xzByFK}vbU3Hzoe
zhBaQN&Sd^(**(2k)Xn$6S?>9adi$O|e}1y@$htQf{&GS7QhBA@|2rq}?^<bLDx~pR
z{@VPWPB){l{6~K$Rb@wP_MX7@{br=vl;mZ7im5ths<YlLiJsR`bUN`DgQw0(Nwr8j
z_AL$9_wHL!%b`>xTDLRee?iB0TgI2>rCw*(*gSXaSa6;tY#!g8zIHh!-u1idLgHJs
zT-<%$hsn*hDOs`f!YeuUdV~54=a~gN`Z6Y1*u2f(E~nI~Z5v?r>gX?(k8KkVd{4<Y
z_e$|>&ONe<kz3({w8fh%uHNcXmnQk2vC-0SsC%J!;VXA?xn6^ukded|^P7GD?2c8k
zv7eLGd-<%dimAD4?@y;Bum6D)pNn;0yy|&xziz<O;KQ@7GG%vdY`a{%>B#n74$0c3
z)!&%e`Ikn{6Ks+#x40L5%jdemhwzV@CiA1tZY%a*yyfTZS(;H^+!wT^w;t8)@|yYO
ziEZiT6Px_=`zG)CQrcnrq$f$sZqcsrxo0Y)RZpc<JlV8X?jq}~L#>?#ZT{73k6yfD
z(3JP$66*&3ScW~TcKFO-3fxv(lU;f|K+a>@cK4fxwKB0&H<;YlU%AfohyI@~xee29
zAH00C)w;8;wqWJGEnD4;JRUf1@6~#6!t(jNeTz?=STOVb4x{rHif=x<hCaFywfC{5
zQ($Sdpso6zwHHF32*-!s(6*@g>y+#nl)k;add=itmK+ynbG~lh6?JxLTvXTZqK}_6
zbr#>}<zHb?v3Ks`g3O*YVTph?i8axBS<>|uA6IPM-5Anma8AwciC~c6v5rLcxaAk7
z@vSknQT$zbYa?5q*xGOtiSQ=H&R?o~dM5HOVAXNvn=WGa>*SV;AB|1&F6g~kt0m1*
z&&HWhZV>3He?;S<p-$80?d9w8Z_Zg;8WuR+oa5l^y(tSPm#dfdm;djq`T90+v8eU-
zqB}j#Q8K>&=PYb|@p{qSwdotH9y~p=gY`Pck}CDDrWIW!&gti0FXGy9`@E5Qd%)CF
zd7l}~j$fUeJ(HzKuk>uk!E;+I4$O<JOq|?f7#~uhvBD&TZO;Mj&rRocZjupqk7GP0
zZv5f#Bi)S9f4-;wR;oI0nmIjm_X@H9SCsd0nElv$P%!>fh{Vr|8(o_OdCjlMe>w8l
z`d(P(QW3QqOTI+R4idfls9^1FP8Q|z+M5+To65^no_#acI-b&eoqc}B)FRCvT`Sb)
zC#HFycbge;_>6VG-mSf=FC$`q@ra0W$%!#*@UA-*BqHiQt6wv2p<IMe#KuWdU%Z&i
zo0%@8Y|nag=)=OuqbqrS)N6E}oOURm|Hpn^pBZm!tv9|mjlIjXm9?7rWtwc7i^)2j
zobKPMwiR8AbeUgYe8q5C<H~IxD}@iN);T?IXL$TAkuEd(7Adl~GGf!)rneKHxdtum
zH!=B@dr3K2^^48J$u67ry54@cd)CCtZF<v8f8Gk4cjEwCc(nbbnums(Co@<~CUS&p
zdZ-wA7)YvWh)4-!>pNewefa$a$Hsj=r;P36_8W3tH4cBFbeMIr-fruok=EU|F<Y73
z)kWoGcW7(ZZM(cf@%-KGY_XC@1=_e*9Z!21@9BL-m#IdrWXtNZr^SZu`G;;?z0vXD
zWaZ(1*OEQN4;x$UyWw@^#gcW*Wha$fGgqf6MqkL6i=XdT)Zefo``$K7&M7rLCo8wI
zq_PJ5^1t_N-9)7|Uyr=tI;Rr9&Y5r5?L#l^I-hsXbJq6uUD>bhJLU0-gWOHoZ_in<
z*}r`!SiAlA)vm%Yk2%6CK1S!1HGKOx%Se1qh`(^+@^iP9*cODC>2RF;b*@_{zwDFq
z4Y3msJws2Lq<%UUwu5h}wY<ZG%=+Xnu95CS4`Tf{n>;t@&eLY*d;eV`(pPQb@<%5d
zPYYiBEVZj+<+}?e&!$Xjn$PcLey=>Gye02Hv+%n3^I<nWf3@>a_YyM-OwekW)jpvw
zDYpFAHC=(5rZ0YH>9D@sT{)@!!mMvzjx{f*Z<+q?{u712Vf(rmzHMc)-;|}QWtaZ;
z^3L-+Sm(A!9}tqgkzW-N7t)^TEq7atamUo$dws_yPda!b-ong&ciV)9B8y&M9gPjS
z=lnMOX4IJz(KxNi>He-yYhUx*_y3voj%k;^CRgpEJ6x~2d><zsx?p%x=hz*y$164$
z$?7o`eYv7zc>9UaS7AG+ng3QT72@1?#re>-`iTx6q92ar>1kL>Scq@kbid4G#qHzf
zMYF4>F5uKSpn3D?^&itJUz|MFeo)@P<SOIzhi8N~#a@_{$LhL&?}xvM`rFU{TKmpi
zJ<iX)U1izw@A>l%1^Vq-^?r-u-rv`y)%{W=7?t)nUyaSX^fjMX<z7*u?ym^<fY_~X
zY*O`)?OwibzQeZ*g?l1n?&eC=eBF>cPyXDcr$&`MlFMIrS}W|@5Py2@6Mp|B4|l2d
zu-fC31*JMtH*FM5c=)<dZ}MDwDGPD2dOcR2FIh`}f4InAu)TNNm&n^+?H)EOOKNUN
zcPpzZnY2iq^Z6AHv2!=KMp`7zt~^`ltb0gC?Yws)r(@vudzJNx%kP~}k5~{b|9;`_
z%I3)6>0avRm#AEC{Pm>j<H;hC6R!kjD86)3zMH>g(*?oBS0wCMl4C#JEUlj|pz-2a
zOvm(n^CRBngzowJ*6&d8KlYPi|Cii1XXgCTcS}gw(5&3{S<vHNgFR<g#EF<)I%j8b
ztNiB-p%2NgmK)DMXSeuZSbm{uo2IY){KQugdsI5_b>5G-WU|w9$Ii7YcS)`1;JkDA
z2y@YTt)x3yAMB^S<h)z4uEmkzj8fVAg}3%_<+ofGYR}@EDU|af``5au6Gd1GzspSF
zU{Q0{h!^#rYZ}DRpk!5|`D$&|C$)QbYuXp-?_R80{?hX3;jk~UzeQDV2_DSeyXBBu
z%Pgh?hhyvQ*VIh-lv?$0mA68O(8*IvU)9z#<b{alxulBRyjohjP;}v|$3{y!1+1r^
zuA7x6f8SQicR$;%kH&_p1Zsmq#d_o(u)3yZJxrSPVvof1E2U4;{$0Ah*K6*tg0!r_
z8|;DMe}z|Ft0|gU%_=Y9Z2E9%VAP-7V2R5QBYh1#wjEcpY2Y#Xw(#_=`h`U-LYp@)
zy*;H{X@$~H#sI~vJy8J_UOCThvdcN7rd-%wX>7VX>CUwMnuleDC*LlaaeEW*xiyRQ
zrxw1uGI8%~<u%ONeYYQPsWLPE-O9N6RIbTe-6szO4jH#-yHzCLSd$j#qFZ*%-#M_=
zP|uO!rTRsaZGSDk&+V91zU*(vBU7naXW1S}JM(8u&Fh^n^gn&ZpS_RTug!S8KK}9d
zGSj}~$1k4k6f3K}V5y}L+xs|Ov}~nZ=q<az-Id!`&*Yc6XumPPtFL|kS*2g<qUWaB
zgv&d<4V{$`cc^eT|6&f!!+L=&UAjxOJ8!<4Jat}(>!cm=r4}#W7ap>%77DIi!mn-W
zGW+)d*GXme%Qie*Q+jsWqY|##mc}bd=^NS7z8p^eeX012N55g;tE*Qfj%giuDmb;c
z_lVuz&uh#rwoUxj8D25zHgiLXhE;DG+Z;9_S03xI-5Hl&I;WXi-gs!|_uMq#m4R_d
z^GwM-(+bPj-~R77tms~LJWlhj{wD|J9S%GdAHJq~r!Oj+ZRNK>@6gSppYt9h+&_|1
zEuSRJp&Rt-XTbK-sIPX3XC2@C=(1dG@wViY!;Jk?3SFiZ-!S(4lWcY{uQ;XDFWj!T
zRa-m9RkCxg`f;9+g{QN;o+vE88S;Q}=Zcd)rdtxO8YF&@-gY)_!nthznSY+y?#&DT
z#M9jIYPGH5iH;5ZXJR@Ibzl7(H_Q5$l*E^b6?Xz&X!v>F{5rKrf1>I8g|@;^4ty1K
z<#=H{TfDR(ntA`z(?U<S-+2`%H!<dAt<#!c@;4sv<RtIh_V!r(F%`qY4WS0ToZ%BJ
zBrWQ5xDL<S{a|5T^SR19|8ytWwA~V^F%VK)c;SljLR%gSXYb3A9<@h!WpACVG&mZc
zFuz#E`rfv!_tqun?+$t>qn7h(Yo7Hn$Jr(RSxoWY`L304<lNr<aL(z7JLyrotd?Bb
zpy$Gup0&QdJ=uP%t$bDA&!zFDN0u-i;=IFu_NM6d`7gFyV$<B~Gyg)Y|E^5EE1KTt
zA6PXX*!SgH)6uUB?@hTTSX6V)>(|wWhii8?Wc<^a=xm(vf$QHL=^#IoY602l-Ro`M
zc-`2i@NdcOEBwFCDclu`a$FK9y@x&YwN!79|LIQe#^tXRYF-*AmEQVY_J{XM){4Xz
zVJ)hEZI#8t7n&Y6Qkn2ZO0oE2TW9OC-5&in4VU@;4t%d^eg03`xlpUTDH2S79{m1o
zEv+FTx_;eOz6E<0p1D@JXl37_g=Uk*w%#kh{c@SJ_ASxrjDHWkle|88Rp<N-N4C4z
zl-&EEeKf1)$hSvAF0Vr!yZMb?@VHD3%Z_6e+8S$HxZ=-0X`cnJSs6uU9aGFJV!9C_
z`Se5Ru8lqsNg+#B*31s|;xLPQP$=M<|4@s0X5PM6(<7%WuVal_A6)Tu&#X$PP4l*K
zaDI#4)$A$XHUEmn&0SAVW|r1zHwV`xt)3{_-8-e}mBfy1UKxh34ZMmJBTkuG{yK1i
z%gcs=$zWmTww(`GRli^5wM}S!7)Mow%4=b-gr$?BWQ<Qc_0Qh6Hk-qqjU(bgZ1@(2
zDW2LNl@cF*GkG*YbX$V;PtkSpUUkd8zPGfnv>Sh!rMiN#Ptm^gN$bs8h3Wa{zAsvM
zKZ=R}xMB05qN#!sno4c6f`rnKZJL%}_@TAgdFk`8JAyJRk5oOdU&yvI*Whb5m!gvQ
z#60mw8u>Bxb}?+WrOzMnKhWx$xyn17EA{H}wL#B+RVDr46FGI@XvpuNwQ+81H!MwA
z{MuKq<h*w+Ujw`K&lWqykh)8&-Z%X^&06SwPcOPhi}CK4GZTW`O4<Vp*UkM`Z1Pp4
z%0(c6^L6p(%|-uvjBnl9Sn*MF#ifP?nOR5sT+~08WP8u_3Orl3O=R-{rcDXnKc-H5
z+qLO<&9cP$2#x+7`o|t;d|9BdCHV68=_1#5KeD#En}7bLKDWS;C3ZK@31)ge<qCf*
z^W^5N%F+qkXMJxLY487*Z{#bHAinN9cm9JzJ9pn$Q|o-}>FzzEwuzg)-mZ^Z?Nhh8
zE~@{*=5>0@E8izpOnKUNIB&~*GvVj*PnRn?`P&}+a5_}*b+BT_w9Wbx{)KIpjQV!!
zOW7?^sVLvmI}g}@`n6&OL;ls*A+M6m)f86DDElkBO(E`}k<`(UPw72Jrwi_Uyuf|0
z(ihjszw<JmpVCS^AE(!l^vLthN$+?y*4NWj{eC{q2wfqaS-q|&PHFCvwWXUQj&GWM
zKd|_V)bbwxL!VeQFMd1rIDeCO*o`UIS@&-Z*I3=yv+&}Hu;)H=KR^CaC+<|7wy4L#
z?6aI{{IR1#zt_9vDu}I3$ky4TWPfvt!fXA4ewRA_!%jJSVnXy}#V<On>8g<{Y2Mv_
ze%qy8f1bH-5EM{VKJ%BCSG)g1YR2R#pLp6X>i;g6v-i<jrGGQyY~n2I!zt#v>0+5r
z%(p1s%8UQGaMqIR_X6#{E!B^m7q@9!cE-%xnJqt57`c)&A1%(^w2DuyS2Cb_?F*ff
z8>jpZuFt+@!MX5*-}|!yF=^F1Kin+qY;jig`4n?axAD*XB?a8Sa;%N7P2`tI{V-Sk
z(5H)%#X>>en@-pLxyJr>_HjmD?H75UcN&H)_I!2k+rMS|j19NVtCO*<u<rOXq0ztT
zP%57o+aZN1i%wQZRjn@UtbcvXL+SIejxWzX-jd#yq-E;8Y1Z8rYp*GYbVchgT=FWz
zr!McN`-a)Z&1OcrLjP8Oo_kqK{6ogumV!gu(x<HI3;g*b(|2-sMQ26f+BaVlqEs~n
zBY(z;`R|E))qN$mX5kUx7n;rjGrc!&T5VV3IoDv-YcG@g0rg6sZY)c5s7=)4UluO@
zXm+N>vJ_1dlka!=kL{XyLVAt#%AJ2>zv$d8d3Payy745(bq2Hjr~G(w(mC+s-8J5~
zr#*cfv*4#(?V6cK+tgq47|GpKy5HgSD&X+Dcy{Z_k_CG;Hf`B;`Dje#?4u$wGOK0x
zm9#vaZ7gxoTz}7(9WQuxKk<Coy<@tq>bs*)t%TllnEZ@%@b*2k{YAuYg-Ek!{syn_
z>D@cyY96z4cdF)r({+9KJ$_B;`Ox}VCxZDcPw<)V!8w65-d<VM#B)>haMZH2{fDO&
z?YRA5z0Lafh2MU;Z4B?QyY^;HWdEN>Q?C{+y||~}dH<tF^>-I`{Rq&sT)aR+T&`5B
z>_pE-jnfWA)7roC1Z>MacOf_M+3J?`HEMsYwEg$o-l?Ky{`Qqu(9xG3Me8en@MX-r
z6}9>3^=|pjut&$`j=Ij^bIe(Ma*nnzSH_*jznmd|xMZbwt~1D=)^%Mfm;1<9_Qm_A
zb<Wx&d8lx;!TXy(4n<7bbN0bJi7#EZ`-`f%GwftvKCuruc+7T_{qIHj#jg(?dU<I3
z{WXcTk{Zra|MfbQ?uqTP448JWaF#*;+I^wF-?+@LU%2Gjy{MMdJRSKIj~!-bH8VbH
zstY`vWgWY?;@YBFUngCh+4ugNI?KnV2WPifi0|3@Wa@GKiEF})iYA2zWCbqiSv5!K
z`OCT9r?#0)tytTuWqmi%;LF3wj46AUw>`I#-?Y~}Yrk{QH=DKI*Oj;oR-R*bo^s@B
z-L_xr+YG<ha8%#;xoB>%_|fA$#b4YWOxU=7>c5X%+6(^X?R_A9RO`;#DW*##TOy0R
zp7M(Zi=7X6#l`cfM}O|J^)g>~$#O9&#a~drpmi@lZTIde>bZZ)enr}F`}Z4K^Q2py
zxTemvuE=4&ckS79or{+ar*34uYW=eEV%b%BOVeqVhWxc$DNm0q*lM+)Gt=*DROr*6
zH6np`3hVEP?T)FK^m_j!?&EVFNhSPSage1_GwVjZ{+b!N|2JAcD8DD@EX1+LaiXUG
zdw$`JAk*ACYt@@uW}e(1seNxj>#HxapTj0Ky*s+)(~roITN4hfm{ykl$Lq(ppNUct
z_1nHhJbBNuzi^Rc=5^7fm+}i6H|j|WZ!l&#9J__#Sf>>G+Y5)@u<FOlRc_3SnW6kZ
zG@I3^#yhXF+P6tzo$n7V4%tT<WpfRT1XK@SULB~|!Ja9Z9RKUnr_jGV`R{7>tCs&U
z{ZYi5?6IBg9m`7JN0-#DM|pjTl!`Dq)TAb#7|${(z&MpJpf>U6E046S`ohn$Nq<+T
zILOxR5IUT;c=b7!K%0|SXaCtUeX2{gbMc<#TwV*dr5Nip6?5HM;E<i1C}Yq$@5gF)
z?zcV?-n==f%8ZNcDxBNx4>u`1`7!U_Wah_wM)z~pXL~H#sH@gxJZY<oZ}3%yck5qg
zsZBj|Bb2*O)j8;LV9Vomzcg>g+wa}4E&u%f(<QeL&XAgrfBKeHr{wprs=mF_es^yE
zT6Ji3&GSOh!xH<#UzE-}5oOw_C7ko%?2&g4y4RMt-V2UjUiS9L!><!wSw!@`uQ0mI
zd-%(xjwx|QeST?&b~rX2)2KRf$~|(ccBaUg(oX?LW)wS`%r82<>cV$jdDiOSIeAHM
z3S`42@{(lVo~e#hyXu?3xh98u`hg9qfB$V*=d<vg^LqD_Jk2bVUoy?*v(ze8_q!IL
z{l|LeqT?ZMZ=(Cp6u0eJtZmg~U9*kDKP79<9o|1hKe;5gw#?dFw(P0fgCNI>ze~=)
zTsc|b#nd*gE~$FfQ2&&StT+6oKUXYdeW!Kf2Dj<`UeB60jGNzE?DJb}$jtXCv6y4m
z{7GMwd8eeWGoDyK_vjMkbZO204XYo1mi1P?s-jq0Xy|#NFXn2~qyGl~@BXu%H%Z>=
z&mxvPtr`VAA0scc)gBSMBr*Bvvsw{5oAvf7J6sjZw=$*QIkQ?_scdG-)h(|6yBF&g
zo?O;==D{uR(tXF+|93iG4=d}a`)%<=>BP~VBbSPsmZV3o*_tnBZusI%@Z)cdSFSFd
zx7lKWLGMOK?R{q-iYzO1NPHRg_>{&I2h|3@dE3ujYLArE;#+e4ineXmyW*GULVPy6
zJ3AXrEUe$z5*DW|#M)sZ`~RqoT<e2%|9M~J{b{)MNpQ0xLt6^tGynb@+-=uqpXt`g
zv2-*PiL<D^@$xs{=i6S_@{UbU?TXlV`fqtv@|EkmUx`h0_V^;T*tzGj@$v60!iO4+
zcLn_w-H^6v#paLmg@rD+tk7ZnF{`?@=n#MWj&(6lS!P|}%=r>%du*Re=iZjp`?tRE
z*S$GWF4T1IK2dGqZ)Z7wE6IPn`Af21-_~gYtFB4w^0@dlF||B1HpLta(lrmhFA&n%
zzxa?811EE#dC|#5lIcPd{_4!C>YdrX^y11LtM~8BRA79s%fsokfj!&wsMCbX&#oq{
zUTw=(9gkgeD>Gry$+(GJ%c}x^&hX^9YkFbI<SBgON6!S<X0X1{3RFDUe4ni?L1ba~
zQ=_P}{Tr`I7hivIp)u%SX2!xSldRRMpBEhyuu=Fob4UIPx0!S0?t3S#+&@j}#o3#+
zvX4BjSX9|CSgI*TU*0w8Wd4&?PHXROd357Q7~2}=H78~X|BKnUY*U@!`Ppo)uF`W2
zZeHMf9o(F_SC=oe_tR&s4br;&yy{%XpR&)F*v>k2i&~8*|Jya)b3?p#Da1`Yan3C^
z?OAKrLFWx~c5+s2P>f5cC>08MdSvZM-<z)b_0p`p0+I2Xoi}}4#$kHvjNDIstu6Yg
z_BW>Q$XNP)`lfYxQ}3>hF-t9+e=^`lkn<z6WkE%}-vWw@RP0}-ZBJb2tgM^G8Gr6h
zXX;+t9lBDU3vT2Dw1`}{c<pua(fZ~4Rl?HK9QSiIb!13s`ljyj?$(hrU{{lh3BKT8
zX7E;IOY7(7OySmitg)AthtL1LPWG?J;+h}lcJ8-uz5n>snu^K7BKIDDJ6~|;goE-5
z<9pATSU&&MC>1a~`sdz#PuHHR@J=_cqqi-0Ue=#fa44$0;%$5Qi`?{^3oXv(HZRC1
z59=tipICNvdEo4VR;N4c6O%YkFaGOucE9<I$2xkALJ1pI`zTJmpV_;yrm)9)!wOD=
zwcOGY8UF$eTwm;-cjCXWqtN@VKi{*A_uih|ZrI-(c<JD-wH2>wCjBX&!G3yvmTXk8
z{i&j!V|7gz^IQHpv9x}zIe3XxRx)7YJ)811s}BcW34O3T=F6-D&dWYsS3j+CW4lZH
z9*fOi+c%v}u&p}cIm773xsQ=Crg^uQ=e<51nvi^`Hf+s}>YbM+-!EF;@$T18-#N?l
z+pNOXY~|<w+B4Dj+vDGFcj+x(Y}jvZ;cc*|@zo^h9k*|vTDx5GsZ^}M3M<bW;umEb
zBO~v3dmg^D?%lf6ujbUWFa6x<tM0jX`6HjA8B8K_hv%vN_^`<_een<Fh<k<G-dud-
z;C<-b((C0lGpCf-8(mC{cx>(TLb5cRGk%{~mFN?*qg{WJ$~T`<oR%g2_^@^OgbT~~
z)P&~g1S=oR;x9Lxn_87yd^AYIrOZ~h%h34LNnyt?+z&%O1zkKWXe2l<;kWXw2|Tht
z5?>s>&K0G5?2(t_J*zEuPg-7GlEJmzT&k?(0_&7zd{c$W8SLIqO>kUhB4@h7Zt2W>
z(Ftu|yt#kqo6Z)QsrD>(_R6K4ch>&S-73BQ`H!bUCZCtun9W{k%+zpu`X%P`l2)$w
zkFVl8+&MMx*k7^8sH;KiRi@pIY<2ji(tG`R{<{dF$IlFWHvB8Pu{3FyPSIzlsUH76
z9JTNfnO(ghaA(Zn{U>IviHqmziE&Eht-4)jozPmLP_#|&vb<Jyns>br*Vnm{MNa;z
zC36^yc{ob9$z+}u)?1ys<>*zn|C#o+wJI{gJ&}w*j{G>9%xX5jUO+=F<o73r)YB*5
zXue1e_%e5<hlscIjP3Vp<(mGznjrGdv2f=7{C`*0`&7rIJWF2Xu=mx6&KZT-9{;+R
z&0+bvYnj8&%L`o=G{k;-dRDrA-?JYV4_=OYtnmKYikR7jrygi{pD#ZsnkK%V*V@A2
zj?fQ@4907*^|tfho#tnowtT&<wqljrtgaJn+)m2ZyLX-~ku&;r`2E-XxXz#NC%*K^
z2--Mpn~&e3`;RZ&*>^}aU|*yC7Ei%k83CQWGKPl@cDfWOuU#9R{c!fS37Web>$Ywc
zxos5IuJI%DkLgq<iOIXe@|<2g3%#GX;#6AchUH}i_a<ib8-EFwN<DNqdH)8RSD6Yc
zIcMoc%voL<U^$1)t2=eV+5^1*>#m=bir?Sgd&x-f)I`x0@2+KuOMcXF%$&5h?114@
zK8F(>7D@RxEtIq-P3!kN?Rl29DYh>7VORQvy9))iLvK$jTT}Y$*Gj!fpY~pDU%w{#
zz=o^^`ia6<81*Eht3_L%EI)hp`ihq34HM2<E$d)hT+XT{cw~lw$Kr2_!H!B(e9d;O
z^R*E(6Asp~@UFgM+U4pu&GGrqTN{q8OS^IHKv>?CINOJd*4uwR`Q~Qv_j3()%asCk
z=5&18w9)77bN?Tu$+{gJJiCG|TDBN=<XY-{@tyX{O?3&=mpP|`&hE4L`qAl%KrPE*
z>uGsM!nfa!U!=E6x1u2W@JrjdYu9YGpBsLKqauPqyWsL{%iB}({s;$Ys@<%b`Bhjm
zVba97x#<s+B-b!?uuMpP=P|XR_-`O9=bH1H-`!e2?rGJq<9Oj=6tzQq)rvh^cNuED
zQPF1P)BUyWY?4a%1Tz`t13XdBe``LP#p`v#p=amH_p(>Bz3n}6av!a6$rdTy)33!P
zQa9=Fv3l9N^^rS$R=<vV)OBvx&Jv}0v72vPTYXLEvCHQL%<FHx;W9cUJF#@W6W6o5
ztF!~VqIZORihZqg&S}Tgj^5G*iJYJM=V{$eyi&f;a9u;joO26jm#kjSweiQ7hL>Th
z<{WReU#fcN@sGKYHP>FB@bKMzMfRK1heL1E>TYcN7~Z&I(mvB9yJjt)dFMNQX6Gk~
z^;oU8e0(#z-IaZr$NioITA59StJurq?2gSo*&86p5VSXa@8e$Avw<>Ksx&8_c^vpq
zMqX2VT_1n#k9&tp53Ur8{Q9LkTj<5y@2#wxuC9JwSNd-;zvYS4`HVAeRc?F1>F?Hf
zwnoJFHbW0X%fFgX(d>hPUC&-?s25!34NSB6skC@w%b^oF50~BPJ(>35kVdwE_|?O#
zCf9RK4*SjD*BW~JNp6zZbOF<+#}9t=51O~_;O)b1!mYA#?nZ@qwT>GXN|d}>Cc6LZ
z@ywQeQ<8-HjWijHR#aZxsPWtL-pvoE-}iM&F-^Fev#~whWUZBQt=$6WJXw~AA8YR%
zH+=W^tKFJQ4`&Mhnp9SLV~O*c)EBmMUU;myx-?<=rKJ<R)od8*qBj_|WHR-9T<Dk(
z?X$w~ipFy9&(l9FxcuDVyX>0s8+KFLxsyt@4fh_Xt~>hiVrb?<(KV$)&uX`3u^6(6
zRKA~iWBK1*C7E}UxvL*8i%+usxwt%_@7e6XJzq~RdE0Z_e%=0(hCgE4%x;#fY7@A~
z#eMhpn=pm&)atLt^qMQrPW$$wxvg=}p^_l4JHF2ZuKgAdOZjqd7ys$hjTx(Eq;wo~
z{_-F)q|krQ>pPxx_wzP*mH3q3oU$v!{ODxC^7HSG^h-ORwl0n{(w-amp{1>>%PeJ0
zyTq45AwSl$I)X`gO<rN&g5G?q)6~}HiJtZQyynFlM=Kfs>Lo5Z7^D1EyJ%bDolA4X
zC4#SgUZFf;4r})kH)Z7rLnntN#Y=DhjQ+C5<c`YIRoRwX3PQ9Lb3cVEpSZ(&)7wup
ztIas1ojFnVUZ8E6-4#Baj}DWnm`@gI?dzOgX@7r%z=@r&JH?U(kKVEPGxw$8ryEjh
zzn*vMzIdVM{Y%|Ut+je(?}R34Dji{|koM24RN5Bq%i_<M_baWu=J8+G8|s{91#NTq
z)8j5>c7@rzkM;lDY;5o+Ea;BHdQPVJV~Z{^{9U<px0LKX^~l7(y1p&Kug+`B8FjpW
zZNt;PaeDq<S+9`fPfM5*ul-8(xG!OHyL&T-i#W@@i@{4=9z^`U<9KOFot9?ntSN>M
z^>37UUSB3C&pWqY(dhE`e||xMQ4<1Glji2V?)s;=)8@40=iVdTwYNOKYJ30q+^}@t
zLy^o%Z{g;rFBfNoUTeD_-CDK!_Kz0dPa!Qad8$SkIy18Gmc5nbJ{Y6j`B<yn+kHxS
zTpEkk=Y8*uRvnu6g}L0x!&0-jm?hhJg0Q9PE{-Xpibr1SHZacFCHQ=Eqf_(7-`&SV
z#Pu3>ZOts4`5^3LpZaB!xii`OQ$r3MR{7ePa%q->@YJ>4JI~(S?AmZDJnyS!uX1<n
zjd{$|IITCEeCY66^5D!f3F(N&XDo{E;~tAyPxloRelzjE%IV8hraNvryZ!sx=xy04
z@{xt<Zo0bHbTJXeKOW70YHyWTzHK_R%su<~?oFxE(!utR8?~d@4=SI3VZHm9xB2ed
zJJ0qNUro3DV{MzPt}54fFTVS@@V5PG*N>Ke-#>q`{ZFoqPK*oltu8jjzLSZR^lVkP
z;<pMBYD(C7&P!nG4GGU%Za-H_2R-~KyY*e6$T{vKdzh_KuPhbcIr+~I_nrqkmvtv}
zsq=44nWg+zXxHQm&)E|GJmH)A?!)H*L66lZPuVE9K9_LWuB}urY4X5l7H^&}>t;jq
zoEd++mLx4c9v94MJ84n1+q&c&#~6!bujbnQ?=mcJz1-`y>SFtwn}@9!XI?9AT%^q3
z;(Y3vi|x@S6{oY=>-DD8O_lt8W<spJT%h-%a~rojZdxR_kbQ}2tdf#5ciTpZNw3*D
zyN?##(K0W8tMe-{m!B)5uf_V+^9nhZP$hql58aEamd&zbF3x;^SZedHvh|fSvhyST
zzUyVEH_UB0y!@p6>VIW3FD!L7PWXFu_pXn^`~Ei;_|E)r>r?BlZQ-0tCZ{f*ADwR-
z`eNPbnaQjVE&7ul#rSOh|26G@#EHGe8tX*MR!H_<Fjl@fb7khq@{hdDVNE7WCq4-e
zy}9Y=1F^ZWYxmgZ^;kG+2;6)TyF*UP@w|9UWZa^f32X_=&+-QRy_~#J?x4j*xt_IG
zzXYfET}|4(s_Cry?$^^g^bVG&v`q9l>MXBnBAI^d*W<lBOb1L~e$C#hqMYmh&#1=5
zP&jVe+8duDR+)R0oKxJQlDvkQ!Kyg$-I;|7IUbG)6Mi}@);8_(Z(7P{cF<e?$F}5!
z*{xF&*l#bjf0z}1&iMVx$r0+}o{ybxX<xW!x8h6Q^W6PB3DOY<vX-)+%vM>tGHq{8
z@!2PHH<s}IyqT)zwP|*K*0DMFe2*wA2|1n@<!;U6+1@_khxXa8uJaD;l7IfF`hQB-
z(NC+kZ77|0xw7K<qi<?b0;-=fv=|oJJ@i=p;8El$quX4k<j+6jR=gqISW%mF_K5A2
z0v$)gNROEbM>`heuxFf1YMYWR5YM)+%f4Ku$|)-5XLh25hwYnJhC(OAT3%gzzwKa}
zyJ(fAqRQdtPnOJ-bPO;N-KM!UPHEPe`O$kl0`BnoDI5_FJ2CUulG9v|w?1IL<Z8Uc
z%+Wu^hv{W__2o3-Wjk*-+w7^kk*t%ZD=2+;&5Jy{62aT07GJ$f4GNjA7N<BBo@v_X
zZ-2BgeV;}Do?6c1?6nDR9K}l>*n3@*y*DkdkGp5C=liVZyF#8e@w(}L|57L*e{YI+
zi5lC)8A6Qy5f;C;O*TkUD7<KI`Z?h8><1qXcP5-zuuLJ}LL{J0Xy@4w1BIli8Uhk~
zcXv-)DLZlg3tP!1HTmb>1@||;_bp)G!^jn+<|@BEWZ~lZ;>HU5B-moU`gwSTMXXA6
z41MYKDz)b2>Fhr@*D$?*vw`b&V}9oL+@jdCw|}&}IVAY__BLgy@(1tkurysea>Agi
z=GWy3XXgvqUen38_}KVdQ18&Zot$|IvvfbHSS8Q5+xEKYHBVH@YKA+{8f5CVlo(4s
z_MMmEvo+Ch(F<(JF1KA7e^K{kWZ%c_H4P<4eJ>h6)=8Tb%f2Z4SMqc90t=g6HO86G
zI_?QP{$lnjP;#+shyQ&&-l@y$AFRE1<K*J&k7Sp*$7UuwK0mcXe%c|woKNC!*o?gE
zi!y%bE~sE<eS0t5Fw8Ply)~KL%rs*L!@rrn2Afk1mhH3spr}#U$g#KEe|A&h29xh<
zOb5G|lILu($yTmfd3?gbi|Om8tP(%Y`S`=-o!`%0*tRyJ>TY_Rt)yLRQWz(DYkb=E
zRjnJjr&tz0-}5t8%Z&YLF;BvTl}jd^vOGO=#&k1xgIL81nf6IXjxse}+_od@A|Lnt
zsdZUx*Uy_>N<U;3dimgozz?fDT>qANm%lo+$U)`Xq}aZHYuvW(IUL!1<;UyaC*Jt0
zRwQ-C9dfmM$u)QGiaYI7&);vh{ju}5m|oKR=XdJgYx*v)T;myhKK8v+Mo;_kGm3fJ
zyWe~ie|ueS^*f&{f9K?1Pl@}tOgZ++S^cd{`M*zpJM=u*Vv@v*G<lQH=~DM?d07RI
z>AmR=w&?j+weYa-Dvp0A_9^9u+={$qIkoAA(jvEwXZoD{E;pvGwYtKWx{q&dhP$c#
z{0VO-Yu$Nw`_qSyY+{B_)kO-dqMO_v|8)~H?)a^AVMWuQxVjvUWtrYTHD;`f+r#u=
zR=?ny?$2x1EVll5!tJJEtIx0JoAj#heDV5F5O~_<>G5kuD?iT*b@!j-(C!j^c5Pmx
z`=hd^PL^{~GH09C>s&fA-Q@2d5%0S>bp_RXi_hP!YTQ}%c4sEb+3-*HtL^jB7p3Ud
z$@Vz-|2qHU;e-t<7pJ*do;2fM>2-VeBxyE=6PuSL&FWTII(^pqS&b#C$~BwgnYX&~
z&(E$F4U@|kIP`wo;-a^zZ~R}@_)eX|{qS_qzSV1O9;;4&<R>;UYvQ*ghn=ZvGCKP+
z13CBl*K@WVa?QBx-DG)J+g+A<yB^oZJB>!$wwW1f-+N)le);I(p4OvB7CxT$wD+lQ
zB#+jNoPd_K%irJ2NI9I-_LFVet>1F-ug=a$ydflgbzx|7X}51wbMH?67G>u(uV1~K
zBHHw#RmVs!ztFUdy`;PLrsHdmxG8%de-A$P>uKVGjPj}Gdk)m<{KzP`+q0*o_1m8R
zlUB2w_E)?le^dTqTeX&|x6M_>>uYM+D^D-9m0$Ux;-;hhP1ik4Gc0Dx6gI9G)b2VM
zc<6EN(e8ua1t-eZ3&fsDsq{~HQutz1(mC6ONvd`7XEd7Kt{nS)F;7e=;?AW5x}|q+
z{BJ2>G;LbD>dUJSnY;9kEpO6j3U9ypbDP-w$9@tSZu9Q<h@HIoF5`>uvaHHGiVsuP
zeo=XqvOUD)Z`rRE$2QH|Q1Vg7)gVZ!%E|BF+wHxqMsY{a|5x9|==#rc@}eELzk0<c
z{CNEE%&oBXFP%82mhuVOi&($^xhwyorHREnjk3j8rmX7RWU=P@kC#6uUwQm(>am%g
zZ_d;O{%-Gjz?oyRcU#I-2U%{%?PV9w><h{6zVh&f)ZK@Q(>SiFmi;Q%4_Nf|*VU<i
zrGqYX^NE;0W-8oZ6JkHJGkfjK<(=UM5#j=KT(~k6C+(fOTWs#`#b1}C7`V24oE5Y6
z!KNK{)(;l@=$*ZMc-#Bj<u*$)culpp95?#gc+x5(|KS1oWqIB6r1vy%eq57gx+I(<
z+lt@)$f460V}3M7-+TY;-uBD8SdOIVKeVzgo>JN(lYaH;?d0FO#SIsg=Y8?@xo~)M
z+A<A&Q^!Bs=KF0(E4kRZ++^WgtqRRv-&c>BPi}S5d%5J8(}4{pFR%Y~>(&#RpHQ=+
zWqwGuT)Bir{NbY$vadLb{m|lgJZ(*=X{XS^omX>Q-#j_|`jSn8-rhKS&igj&=PsH*
zCEZ5xTmS#1O6}r2C%^gJs@^a;l|A;BijnbVpSg}xYXU=C!YfKycgsXMy^B4;dFuMB
z8;vjK2p?L0Ql|HCU53s74jrz_?VZb;&Odp-_5yG0Va6~o|8pGYV?Qu=l`ieWc4CJy
zmJ>S+O$^}Yau_L?85<j6JFvst$kKr5YZFRXL#Dj{rgv9UlY>Vg*15dg+~X7jbI$=D
zLlcfms+y__mlR~1rg$g|T~fRo>!tkXxW)57_0R8ZeHXj=n)&^Ezi<A&`}^+s&xRLY
zzbHO=>(H8mUIrR-x~EHPuuZsrB}9~kq4Cch2L*XP;mM3F?^yo5K9*?2w0oy>LcqrV
ztP{$an;&q@XX5BPka=hUgDJl{gT8%3xJOTT1P=$x2gb%l|CtWmIl{oD;NPL^Fj;y5
zTXWOh!WmBz_3ZKls@W|b&8XkY6p?#_Vb7vPhvw|R%(&@Xf_Voo2iFCbgR%$CbqMD=
z_%YPZ;AP?Y{?nZ^jFa8sj%!c*@zbZfrJuYx$6LI4deUQ-3daY047MArZ=4m*;r?N2
z;K2Qa=by2pIiK)>1B{RU9beDCxw*RW&H;v&!<<RXZM&3>Y!+-wFlTsF(6Db6o5O8Z
zp1;i3elR~^`LkD=LErrS{?mWY{tM+``a73r)5b>2-3<%u1XkD{;CsZvmZ6<laCq;-
zISc|<zKIJwdBW%Xq}j$%Kz)KK(}&%~0uG*G;tWnaKgw;&rOi9I@65d|`{+xy%e?qh
zf$eKJwoYxgv~FHlP(COAucpJD17;oB-yi<m9O<rchWpj`>l>OKa^KeRCcb`nD4C;m
zM^!_p=sza`y*dAXyg69Vpb+3PBc6qWVK>u(duDt#`%g*#*wIkWURl3WP?+V%&I2(F
zWgUtK7zL~i9`PSPFZ+a(?Z91|1B`Y5tv~p4w@(*O;NIBCyyoCH0gZF@tCa5~?6x;c
z`k5z?-ykV)&^C_Y!}a&~^Tjx-ZXR0TXZOGH|2_TwRZY_tF0?s5zw^KB<jKvI%zu8g
zGRD+2Ik3dCx-cH<nBGtyc9GHXUm4>c|5aL7_}Ct>{(C7_===ZGjnDdw5&yfIc|V*_
ziZWoyKFDzG|Aad-8XQ|3Z7TlnU-{4a>HlLN;zR$%tNef8HpOPnoVxbN`s4rm4Ngct
zdh%JkL18Vsj3R@tgcI9^|7}vu|2x8jbGSbi{CmGbOQuDjN#}~3W13zZW8Q)T^7cn!
zIUn(EyV`glSLR>9v;O-ZreB$(5U_#ojO?e^x0_BdG5yzWyD+_1`O)u(eGi__7dRoS
zX!hg1>Ay_}IV}Hf=67Aed*<8pcRyHK85GRTC-CznedX{LcyPR1V1@3D-{zYcZSDj}
z$V_B%I3vTbp?T-SKT*c|0TKru|2X~qxJy6-`>)%7jvJcE<>htQ)oo_JczFMt`%&!8
zdk>mfYz{V%{&*pM>%z6uuWq^$7bAUG=!N^s>Ha@<v~lZfd|=y^>>obq%jV6`uH4r=
zTlQHi(k}b@q~g6bn=Ss{&EMO%?w<RDIo*Dlx96R+N__QCrc&wV`$vL@MIN#*iFq7i
z8MQHKyPS&bEQv+_H!f}aX8X&h<)6;hSmTp%XO^gX9m+~v8zpZaIz1(Gg1wOGt@x|W
z=8@l}b2$DjNI4l<+Q%Q+ZQAd3x$5i!y^kNc)K9MN%GjB|pnl$t*~^rlwa!ZaaO~sb
z0*j4{D*h|8GM>>|{L`lC_MD{id$05VSu@o$<y%hmscAQY^s~46$zJpSuJht%?C$#}
zL1oEr#j`ZjZR_Vsn@><No)Yob_F~N{8>U?zug+TE(c_hMSu8KRTTnp#-W8Y1b+4Om
zf6Ub>bAIq*QSu?>?|X87eF=Co_u`==N^T(;88OKlwtbRa{aO4`#hIR6LjRgp{n`Bd
z$i>Wc4_{n-EcoE>+_hXf+jnm2G+myYeA4uBy6q&-pG?OUo_%KDt-qG}XIH%Fx461q
zz1Od*^k+YEJNvCN^2f7d^=FRWiHNxuU%iv*#cx@I_o1u1BfIw+EdAbPdgR9rhgtdi
zs&v(igo0Kct#=Z6TVp0*+qQqD@q}EZ-+m!i{|J~Gn7&MBdKz33a_sZNWzWrT{9LZT
zb7tY`U8@fMp7PRGDRv3J;pcjjO0lMp`d98#FIsl6RxDm*qI>m2fS`$ewrqC1zqVYD
zrRm|DfrYC+D|`zN3x9u5%j?&a7c(}y7Ph7x^Jyuvcyo&9&g7pdpPUPKL`go~;&16z
z{YvHI-|113|2CK|PdvFNAed_@&#Aj_#BUxxsQ)_7UVcIfpIq9L)SZ()z1b07mB}UA
z8h!c7<((o9MyzvJM5RdA?!PMbwo2rCN9d^zHF-1H+Nvla`;t6^9_PDS(<Q~Ny*1n%
z{)K)#(3zF8Yt??eIwxla_Tz^Ro_rAVM<#pXh3k5UOW$5<-}Gl$fEUaDhUq_Y{ntp|
zZV&sE#apHBbL-Vk`I+8VHnp_br>;6|qP8q;e^l4^?RP)?UT`u`SV*HSnpL}cQ$k7@
zudPIw%%3^?W=h#@NU5K~y~6a!((26M_pM9)%Gr99UOwfP*?)M?{`bNkUAvdwE7O$t
zbL7H`9j-ff)t>Ik&Dfi<c7|i&&TWQCBF-yqFP(DtmGk_k^U`yL(B+5y)_J`3TC-*2
zA0J{*P}(-%=Z2l3#5D2Xmj%KxCk>gDGvkwLmbNUMH_cCob?)hP0Y|-fCo<hK>lH2v
zbG3G8y?Q$Dp-PZZ!@l0u&ZgO)beFcRIU{DZ%2(w22W8#Dnm6k4jyD$Fx*HoMb*{Ck
zM@C)kan8)3IKQRleh+`!J8?_ztBXk5++Y1su9_$I)h6EZ4qN4@wY~Sgmi(P(5x-nZ
z<NB+=N3Z#9O4XRRN9z;szgIEOFL)dfQ}y^DD=Vdb-SctM_KMH`ua38Jek!(&y*{`7
zr?K2Iv2}N{98Y|6^>Itn_W1H;;)%beJ~yARiIv4qaInZZde9}iyft~po`5xvu4OKL
zufV!Gi*r-JC4ZYM8f*R@f4bRg`juDnW@!Fd{AtHSW5sf_i;2BY@|m>O^B=L8_%>_Z
zX_h*+bfXDv(>or7o?Q?%>E>JI(u8wso?n;Vy?jsQ!nr0}*8g6%dqv%L_KuQk8P`s$
z<ZH>5?ujn>q<Bc1L%HYk+7{!gIM&(h%l7(jm{TWTcj`>G%5@WyjkR6Pr+D6ek`Las
z=uVhrr;m30l9`K}XBdZxsPB)eTD4^XS9bL5Sr&Rhd{;izPP}3&*^@lW@?!bJD@r<V
zBF}yLWcf{huYhXRshMvD<P2t>uK3rt@%|5oAD{l@Z9ez;N!g6los|b`U+s-f_wauC
z#rFE$lT$;Jv_n_?X9(t9YHxb;{JJ-PG|Cc}O;^@i)HgBi-IcUWZ2s%EYH%MFpYdCk
zyYahHj*0YD)y;o?X#{e$Hr-g2YCLz#?!EfkuPf=y{-m*Km-DZx>Azc6Y>Y@{3F+i{
zSUKrMVQGt-;0BFv$4aVZPB<T!cIu&LgqlZswu391%(BoKQTHknlxIxuc~<0fZCCGu
z)1O)&wR1guCy*n4OL$7q;h*A;$Hb#Da`uJD?0!D^jHF8DME^CMTdZa;w$jn}j&9!6
z^l0*{s8^@hm&J&^uwE;<^EPkRp<m}egcwDtPkiEjuFY*@<${PAv%`4xbE3Lkx1~R>
z=3g3HncL1FwL|sR_gjDL|LoEzc@?@wrFQ?`dk;02-pamtTz-?cdV>Vtbz|8Cq1m=^
z>Q~mEJ;Qf&((SjtYwW%EY>7@X+|qiz-L~na{*IN)w1rbAeNXIe6RQp2ydYK>dEslI
zjMt5jml>U947n%n#QDx%y83m(e)%s)exG=zbX{|Eg06Q?|La5YoVWL=cD!2qzW;jc
zuX!4s*9#ZFx%5A^+|f2BgyV0p^LFPG4G*>XSs%4U*WEHs|G(1k>Fd&WAq5`klQK>&
z-Fm>=Y_-(-lG5W-p1+&)HCgV2Tj%B_pL9)yVwQ$wR%ZTj-ny`8dSv3!qo4k4y!lx7
zZu_t2n$k~#0#@}O>r7SmFn#H}wf{x<`pQ?Ux2=oX;UX8o+xwh%(e~F}PxFL*o<8~c
zRc6K|?HRI<%i@+^l{~v@E(iD5zVPNHQgu8_#ai#0?znl8hr!_mdo1$|PKkNdHmQf~
z<BHgmx2@Ia+%s#kfpV|T^1G7f*ELO8z2Io{kFFK&8)MEDu8A~s*2`#;Sy0rtXctrT
zzR!D)ob42SwNK;F7ojlaIh?=L<{Jh}1d8UVmVB~MyTY4&amwV9qLOn~FTbR(FYC+I
zvg@0kx~A!f<j<|!r^mc<Y`EO~S!Qm(U66K{@At@eA~$CnZGUt4eYIm_=f?KlYf{Er
z%F^zzX>D6vbKsTwy1E92&Uu=*8ESv#&syOY(c>w&<-6)ivyk&2bN9v--e7pJl-0fN
zhOpk1CyUOeMy+6FnaOsPb$XYx+4PBfs;}RYpW^&?_9IrF{WB!y>+QGQEEe?V+rHx-
z$_8x~45v0_`e}qZZGE|XTU_^^tF_I-N!82i)uL@=<QE-WdG2^u?DF^>n)lv(-&;6O
zE9W|Exz3`^zPsj6UBAm!^QoEThc_IL%hVEXRBG?s{A@x-uwdx=!`(CAXfp3p)N4K2
zm6>}yC2LNcz1Y2o3x3;<C^!Z@5A^xHMzl!o^W8@4kAbz$3+C)vnBTJ7f8EW7Msvk`
zHy%WrELpbe%@_B+wm0@O4cxL@HP*-HpPS(2W8cHa`%me$NzUCVDgr0u7bI&veyeqF
z+Kz?!W|HMP9=FX{&cC`6B7MH|?)-VL)IE)h4qSB5?RnVF|J_c~ecP&#jVJy4`WDsA
z|0=lDb>ggD3$`U1?`llbe{(8GNzwRNp6G=VAsLr{9jfgwn4**Bak$q9y}MB=aQsV9
z!o0Riw)c{{?p~<1E_qtllia3ZF>9NG!Hi9Zr&z!B)-MZk_^045P=4_COWWk^dLi#Z
z9^o(A{aYkY?V0B&5&vbzOO04X#kJp-6<F!X*p+6ka-Ui9c-p^RIr%f^c0bVD^y1ET
z<KvH>UOKp2{z2Zw63*iR6X$d*RkFVB@4d<>e|5IwQ(@PNw)ggXZzn{GEZiymplr>o
z`jg#RyW`JCmL3e$YJ7OS*~sdFe!xrn^-tb<A6Ox{Irh{m?#VGOqC4k3(e7<I#%WZ$
zLBfBVuJhgN2jn-u_#jy$;kx(KcCn4Qcf=2wD<{mKvB}BfwfMyuuja&`mRN7UOKGoE
ze#Hl!l@ZJPIrWVTO?9u%`c}#1Fr&Yu>YZzDOXe=)`UxDr_kKR5dVAxkw&ibg%75~$
z4a!gye5`F4dfQ0(v8IwC^Owb)6EE&vbm4eV$_=5F-|XtX&J*DcV{6yATT*`ane5ry
zqHb4z)Le?sh!E*>y#7Rc!55C3f7(smqB72Yxv}z=rN+-Q8&h9fEiOB1mcC{cn_E`@
zA?br$w&_p3Pha-m*E-v7*WO*-bN9Sjb+*GasB8X{T{c@@`I=2lS+Mp^@l_%ANjtvj
z?pZ5V?Q>4z{K7jn^R734(zx{Vjo^_ltL~e}#JcWz#}|I#(}4pIYSk{^o_U8q{#dWo
z*4*^_(UZy_Do$>&zr2X8vg5gY4Of519Gk<w*Z!Y+V7}*5poVhW%!iZRpG|qZt7*=;
z$#d2;>+YVZCaJ%tjbC$xwNL3YkN9tqcaJ~2dSin`eod>UR2;jENjP89j}>a0H{_+u
z@lCn3CNx!Uw@EFNT-@<T65qOy?0f8}?rq|KpQmQ_rAhOo9HMOFL$l7VJ?eYm-gARy
zxv+gltb%XcEI6_G>$^G6)gJN`t!(R^^|0oS;mc$B*LAn_iRvG{7$QGIto7VGtE6?a
z1g!myzX$wP>nf?rtxB3Tx2ND$9h=6~y@9V@|6+XYd^>ZgP|x<ehr)dyeq!8^y7it$
zf8Ez6+hb2YtxK7sCw1~lPMD2*X-ZsC!HmOl(q~`I>3=$Lbz$`Ljgjg$>6d;@yV@xG
z#V3Eu!OICJcN>Ph@qNCz;i~PY9~_}u&be$hsV&tzD^sy@;|%d$hramz55FDN&VKco
zEA^FQ<MWvG=M9_v-k2KpmfaG%e3zqjNmBVv)_=+uF26TA6dcy8GJoTqxxx|`RyKc~
z!8>omlg<5M(G8~3X2%`A-VVL-N3^6xxt1YHt3K;ykMQbs1^&M_?P;C-knQlUTDxaY
zrP@qh<hkuxKkv=PuWh$pT)M)z`P1|3pYjXJcurgpu08Zud<mz1$^OZc68<YVXuW#P
z^EBQ*Ja_IK?MYv&oEq-UEqd`i^+Trh#I&gbam%$mEpGJu%!(;hd$ggi_M(gbwT=QK
z&t50P{@;?Hw(EqQ7Cw4qZ?)5v_ZMzGeYCFNt$4oPs>3BOZ|(>Qt++5xl5gkEdkf`?
z#oerKoICf%SmdZt(%zMO?5Ejm;GO$&67TZ8IX^TLx24?DKM}e?$&LHZucM`wiRnvL
z_H2IjTA!2sNN4f&+m;+#Qh5VQg<4mH$VTq`b>K?&d+x4z=Yw)=l~0|VozCv3y{C5X
z%J?;x45j|h(@b^KezfHAv5D>H^$J9%&b)l?*7p~AHY>wewro5u5nON3W4rxQcG%U4
zb|z8zismJ%uJ?p&{+Z19)~j{w^Of}LTT`n%Kk6@MF?KS1xvQr8OP<q}4d%Bd9bFgh
zu!QA9Ty0e3${*9BcYb@zbldILteK5Lh5ue&TbK28-{IRI=iUy!F_r0T&h2O3>$%MD
z`uFLse;Ii3p35d4nfX?7ALmPpsv1Ped^6&EwQnC^TuOYS>C*~fzw;X&ia$t;S}Du9
zH~qJ#rur_^PQEJcblL99wfQSjnw+;<U#y4<7R#P?;6h>VE;U*G$v-V7zH<J}@x}e5
zmE`7@azBx_DX*8i{P7D(UHW9fvFKZSJ31e}l>fP)SK>nYs@t1timzzDUnXt)Sg+`@
zv#2bu<L9?etT~<SD%QW*o~M$_y}4t}yylO=yFNHPPi|({`_}z%iscTqoxUx_YrWeQ
zEEV6(JaKrweNk)7&7hZ^Ri){na<Vnurs<z_YHAa9fBy0_eCH{zdC&DveN1`eqq6%0
z`z{u~GQP;PpR*oa{P5g8c-e^_191kWOqSk*UzSQ$<=$d>`e1VOqTZcBoLp%$6f9E`
znANTeyzbevsXHojMW*o^%jPe|WhrXv8vbS9Up#scb<JJ-e2w;6-}X??$;F3!>|J8t
zYCPMKxw^c5V~zc%N*AZb{7*ZbHMc#z9P=oh--7eZgVj8K3BLC_?oFJjAm5c>a?EmN
z-_ddnmiFaqD!6u5-DtPDBpb&kci_g|j|SJ*emfy^?RnSwODmk#=oF?Z3Reb2bMC6@
z@fPgAxb<1u#q%{9`GwV6gG;Yo)qiH(eZRuXpyt~yM$M}ajPE}+6E~kf$!14|=eZD>
z?=!gd9{hUCx!0#8`A5~qyloGp9B1rfIbr<j)Q^+A%lB(+cNdHP_Fz`*l;+Px-~UK$
zUbSk1-)Cpj>^1Z5vQ3u~&-9yK*7SI5zs=R7p8fB)wzbQ=c1fCRc&L_BM|HN!ipnV_
z64y;De{NITu;7uJ>EcVPs!!#0dl!Db6;>nCbE#L}S|uX)ah&+27xORFdhnj~TpiOP
zlA$|gh1<eg3uoWl_+($rZ?5P!XI7k4b61aQ^I3PR@t<Aw(uj}mO3xpdkSa5=PHE*G
z-J1<|``JT(XXziUsCj2&fBY{0R^AhP&MtmZ+pL+kX~Lo@oBu2+h=07<$KvhV8-MOj
zm*c*5C^*jl$$4*U_QkusuDN_)`a*Sj+GN9*l2>;7PjhSMJ7c_Y&Qmt?pU<9o)TRjk
zRT6TYesZ<=H>atyCNlr#_hl9Rx%|y)=Xp^JSW5iZN-fx~)|&o5)5#_m@vZ3eLB-W`
zclXYc4_~``iKF^^)0BJ0>QUyse6!W;MfOz2cK^9-zba|5(#a`KVn*yc7~fj#e11xQ
zX%@r0J(i)$GB;~h_!n07o?q}QGc9;)_O?g!TIO5l|NT7SLQhl3e?#xXix)4sx5#Z>
z=ci|mpGvn~`m_16PEnj9)4tPv=ab?k^g8V<Ham8Oa)c&ao33TpUMn>xME#MkjP1SK
z&IkHk*KXu3ynMj8mpP?+_41?Vmq~9=uH7#4$mfyp?%3N0T8pgDZ8P1iZuwQc=TpSp
zjWK@%ex*FxlrObl#l7H^?D~#?q|VRR4;U9eIKPYgnE2_)Fh~2p!p*ijODA0C`1<L@
zbm>gfom(o7FouiWFMheNuyBTLZTj`xvo<^LJWo=e@NCiQ)F+7^5%d1MYD?{ytnNEI
z&qz#n{x=_;UF*aSSbli1;>4^{S5|i6=zE?Ed;cez-%Cwd8Z^oEbT!{5LBqQhuN|tZ
z4%+y3FT1r@c}v~uQ-W@{#DYH>KR<X<ciz`F)@^S?IF>qpT%@yrY4M$iTO6;OotB-r
zws?E>v*JtZ<=Ef<+HqTOcg&?P`%NMYydO;t+w~+~%S^56-?KTfl>yJKwkzfZZOE=<
z4W96R?b96@|4r6a?8*%&`7H2w_msKwStqgWJ^yC@zE*wlx({3v4)7d4c#KPg>+yx_
zfAa({?=6^}UpLEi=Qa-+-sRfYZ3MV@pFAtsb$FAvTiN3(RUYF5e14ow`ExrwPAqvf
zxBlF@^EVHQCNB7zvGnhxn6fxujqc|3CBJ>m&aCs9P|&BeDof2`kJq2>m|%||uG%ZD
zPCaT5|Ix6>ibu}Ivh{A*T$O(;Jh@UL_h)=s=jv*-V&W}ry;mKR-zB-%__9Col0VmI
zy5vl7ZM)U0^vS0-n0@?hGFe%5<>s{(i;k5=s~CUlXPKy?X%Vs0F;Q@7p~shaahnxt
zC$~jDT4~_BO?S~o5uvD6`i$EazHf0!>hQ=>t-Q>-(NKBnZLN*l5?bE|CB2L7IecSM
z^O8a#jk(=h&dfLUP5tJ);oIs;J+TYlIxl>_ckZydnUY_@l6|Z5HqU$B;~x3>!9n%s
zulVNJ#qUg*%756tReaIDs!Es8uTRX<?z<-4$&#56_hZfZ&C7Vb85c|sFL)v{vCi;H
zV~{KB0k++e6`PXP;`fNnoxdtW?+(AN-G)UuH<ND8_|P?p$JX#zNc|nfuR%{;?+1Oc
zIeG8)Op~LFpSTHZalgQ^l6C%Jw&gnYExs#Xsq3}RzV<QG<J0$}^VLrKJM*pC=`SR+
zQcgVW%aPRD8+T7~Cu+rPSoT*<rM$Z^-oK7HWwpf38FG((UtQffS8lJ(2iq6Q?MC)X
z>I!x;9zO8=(5wYl#T7MYUNYi-qPY0&{ivtn(oL1qr!U}TT{@|L%5-g)&&Tgfsx}D<
zjmf=J5Z2^#e#ugSh~!^FtqNx?edJ;<?Tq<q`S;3MVe>6VzaP7QjkARRs+#lDz-6Lp
z#mahy_xwK#-JZMjifB#Rlqs)&|MQx<<^^N^1kZW<ER71k_iX>LE_G|5V&THh?*$)L
zIhtCR&voycv+W@Nx{}Z-tM4+s;!MomaJH_{aL29gWj#p_YMk<#r<^8iz4Img>D`rc
zX7Ek>a3P>eZA<KvhNVp1DJsIM4_0RdePnj3{v*Fwcza(;(GfG-hhnQPw?0e{4^)Xg
zp8F*4mCdv0!wUbtX+QcjV{QMM-i?RPZ{1~B<Mwpf+g%(QPD>f@zKq$c!}Raqvdt2g
zWIn6jd+MH1d&y-F=eJV=$FlbwE&8zSV|Vi;g`dZN2^(-rGjFWeDdp<0IIVM%f4^#C
zh+^_KzKuVxwC&h^#7pNmlWF{ceZ2we))y?x-flX%Q&7(MzueIc?W;U~S}QyDs+G@3
zay^*h*z(|t_PpJ070<5mzbt<9r25{IYgG-RkIyEpT=M+egXLL#eMKA6cOJN%{8Q;O
z`?K1VED82wu0^*UuP?N}_4+#Zl{D@@oqa_sYcel+O1@FG;P_}};4Ja9GB&_NIpNNk
z%ef1f*H(qjJ<7AaDYI$Q`QUpNjQO+NRl2))H@uhr^KSL4$ik-W^B)-G`^zos=bL0N
z;rZ@l1SfxPc<WDVQ;q%!9ey?MRTfvax;~udmX~kDdFDabOi{mcMNXf$)@@kskSn?(
zyTNVNtc4d!&o0nk_G^x{c6G;by?d`7=55Nny)$Wkn##Ggo*prEX3^6pO8iWFJ#+It
zCsEm7t0JnO%)8iassDL<a1z79qoorTz1!XyTzkNTdAn9vCu1#B^Oe@kL9YMizSz!W
z&o9yPj`f=>C;MrsfbXU9*@1`tGsv*0KEO8PX{unLke`&rWn%-I)ihKvG&8n@@r)EK
zEezn-#-m(OU|?ZJ>=gyQ+gJnU+!WL8i7qIYDlg}M_wL}*#$!th)pxK9sqEOjo4uTu
zkF)VX-od96XYMpEe*ZswZ+Pt0+H2FkzTJENR=la{&Q)xiXS6Ps47hcX@ywZXhtwD*
z1O!cb%(`J?;ie563l#!`vzrc-9oT=y<H{`u@$d<Yn-A<~Qi*9;_8@%r63ri`ekU(7
zD!fl)Pk7F<;WNjE&s-ZeGFsfY@#DYnix)}^6HH3kBN?VdFnsFca|l<-;&fNn7oRZI
z^v74j|CUTI&b(xN^XJbVpZX=tN8U8*DHI2@H%!vJA(ip}mrHT5bwk@?OAd~2zx27R
z6tfL(cs5MEdiZej(JS|+9=&+ft7RVN14gE3<|~cs9K_2Pus$e1%#a#f{b2swjS7Lx
zCTktn)!#Ce(LE@)OwZxK>VteKd?f|7XA6oqFzjN8ljplIA(&-_1*7agp0Gd04V)jY
z=P<m{c~gJ+@6^AuIi7rQ-?Vb)&c%BtuWS}SagZy4a}zUD$P&@W1M?Ep8df$ReeV!#
z9e(_JO>lYegt;qkW*?BBI-6<9(JKtg*7N?mI&bw(?h~AEPCeq<^!u*T>-<^QHN7n(
zJS=YAW|lp$&SU@U$t*h=&c+{qcl6iuv$w1)sw{r|VbyWu6Pvbw_J)Guq^m^?mb)3B
zs{H4wG*$eYyqT$q@lH<7o;fu#3=51IUS#H-{WUx8@@dW=?UVm*|GAafUS8c@z2RxL
zu!H>s)em3UPaeN|MV5nM_YTItHUHlJ$Zt7vj&B3Q%x1<k2ki;Wm+arHPh0SG{*SMp
zVjbo&)NTuZyOH@uUHv~h$$h6zAG&z(-0S%t?B7ifjq(hPbZq;0zVH9H&Ti`}rkWWy
z8PCYv$zdofiz{Pz|N7wj{gENQj`g7jzxl74)4Wu<VeZ@WS@Fle%<sDUUx?vu{Aox2
zANfY9$HT8OF_!%AxYN)(`|O{u-GBc_zN%mH=fCD3^V9!*pZt%Wux0k#yYhLv?En0i
z-@elJ#JSh&8^SN{YK#|mIQg-ZSLUC22>Xxcm$Vpl9rC{Ye?66X_CCF)8O>K$&zO00
zXT*&i|F$&8EOngcz#S@Z<IXStlYcU=|Js{Xrog^n)ne@z-*-PX?e2YBU$g#qYToZ(
z{|aiaKAo=@eEoVV^Z&x${e~Y(=l<Kxr^#OI-hIFN_`$Qx2Bn3DU!AJ<{t7?B`ysJD
zHh_D<bNN$j8#Y;3G{pxqthfEms3RLYp)TH-U%nyq)ApDAM^1m!T3df%wg1ojBmcY3
z{ByhWhvC}wrQ6N_-ahniRb<$M{R-?2S3kv1kUqfmOZ*AzhFkx*_g%XApE<tu#H$bb
zKfIoP(LceNQ2I~&3DbsMf4KJ<?f%QXZ`#{`{7))Uzx@%fS$p#}|Bv`!)AHiNO4;A?
zr$1PI`v1T_F4tj!`URQH%7YhU42~?*Tk?3DThEE+%IYAFZzf;ErZ-n^I>5nbqhOl7
zXX1*9GdC^@P}_Uwyk2g~<+VERYG!|}{dg&T^}IC)yI;?m=~H#S>x@p~!>3Y3dMBT^
z%}8Qg%c>Nv9yupu!HrY~r>QDZf4LW}XuaCNW;#nhH}-zeBzE4iPLuUD8SO>ar_Y+i
z;~JAx_ja*wX~F878=jec7q!d%wygHg@A-yo6E#oG*A!{l^=^WY?W&9QJiUDD6TeLU
z;=+D%H+%m4z}7~?B`ocosyiR7-g^C0fc)m}yZrXazh<0F=sbPt_4!NcQ&n=7^S_We
z#L^Ppf9w5`cRQYPe`C8PGtD-wqn0~U;h|&kDT6?1`8#$i*YD+tn!I1BTJmT+U(@T3
z^^a_-XS-H~6e!+4=oXWEJ-(0Y!YviCYdgvl#CQDa+2QeQ?NLGZxQ!N3y<2SWc^R=p
zR<s=4T;^50#yjt0;QllAyUuI9j6VA&HZi2@>cidXzT7q!+3eZ=czkrfy<YY36{SXF
zq2y-^AD<CSs`T>m&SkABIJWV|+BJXvtlBX1)!CH%H|KOeXU|-(!_yons6FqR_R=kE
z9rJ$mrhoXOyMJP;oY9@zcM`(y)jFK){9>NDc=O)}zsmag9u_yv%efqvnd~zCeBH_u
z;@5XBoz#@`@7H_tV9l&8@++&kdy?+?Of_@66qc0dY@MF@Na393KcW8)vQf<Pj8@k-
z9=3cdk|L!OAo42Ql<mPe&c&`1!`glCq;CA!e5jV)>w8s6<;jq%+$<UUza`5)<XHRN
zO^r*ve6iQ;xr_5c3R0DqX!HL(Ve2r1dCS*AcmFHA6Lx<1lC<i{wMCNI8*2lvF_ye}
zbTR9dNuQ{$BBPjSDqH4z>Fc#B(J^}&C;Y6`xPSJuz{GmZ=rXP6u_YHoS)TWQRDR=N
ze`)s1ir^h~`*uHBFZaxM!Op<u{6mUM8msQjEK=WBn_}wssNqwk!m}7o9b38I*JLEy
z4m#aVpY-B{xLxC?e>;93ZHRkO!)$zNd(USlA-9I?;NJ_Eoo~*%Y8h;L`|6&Z<@NT)
zdn{&0ty*%YE8^()BeM@bmF~QC=vw$kyU*3DuS7mvb40vpyFIVL<25}D`jd|Y#Y`74
z`t!qDW`4NB^^-^Ut&1^dcsfb3VylAfj<ub~CARuZxy~u?bzZo|V{YxVZEWwE^t&E6
z^+irr?l3G&5OUgJuW4f=`{`?SubfWc8lJ4DcFIP}_-msCSG?ijJaPHBSZl?R6CY$Z
zii<>rC&fl?F#20i()B1~ZsQcS1&{6S8EkU<7!=s<mOpux_3CRI<$p(5J-_(Fa=Oe7
zDM{T3{{1RzyUr>{FK3a@*8lAHy*2)<?5RUPE2oD$?Vpluq3nHpg3@`NPFt<RF+UBx
z-gQo$^;4z0LiUj(%hr9SbJO1JTDe%)xnAidW7NhUV!Isklb&!_n$J@57GHIR?Sh5B
zQud9be}ejwS|{B;sn^4`HF>rAoS^3$`OW`)c$rnWK+AtNW4FQKj-PYaY)w3LH@GEe
z{!tO%-u9)Bf3H1O{`J_rOkb_a-uV1fnXQw}RycOo+*6CZ;pChsn;0Qw|Do+%&5N96
z5h7Q<Ce@YNKML5@I=3e4?cbjpHI6#g7S%mWcG<7A;pFEH)ph2-B^6b~W7~UHOm^P+
z{cKdX?K|!R>7Vz?wVyt?WAc_`)3Z(|rL35}$I|M`qgO(C#_Iwc`^@ZD6(`yJiQ`ep
z;FL*^ky*T6P2lr}TfFm*oyk6E@LJQ4jaj=@e`DeIg_qN(*&P17P1hhJerZ;6saY7`
z!misl)NT9M$-I-fbZ%j3`=?wbLznC`N5i$vih}C5&UJb`zfiOK$iwoS4^2B~*xIks
z__0ag+o{vb0{oYJ+;HPg%c-V>Q}fOhxxQKBmoaa;ZC00`veWaL!#h+<I$nHE3TonR
zey6XbCRTar&fj$#x_4L{QFaMf$mW%HTz{_iit~T#xkAIL{0e6FbXk7$eReCfygn#C
zs4e=;5#<}%Zzk6!9eKMjP0x$VJ9GcFb8|`^d-cv<P2A8>sKJ_kCOq$rz$5QlEt~!;
zH2S@_DXBabuPa#QuyU<W@r<;C8lhRQ8(e;b_=>8ppBOf4LC)OmA0v8=GB(<Lk<@xx
z6%pQ~IcX}F_Pm}qXT<gkS9ZnEs@^nzmPgL-)BO+LKfKGh=V-37{j*uwa|5>Df0j3;
zy*d7#!MUTN$6crWE{|XI&*YI)X8IxTxl1?}`jjf<zxfktvFxSJbydfs0jJwf{eDv9
zZFbG;M$hSH`BkwWwjK3<d2ycaiwRF0SQjwdS*FVt`pb2`(5cA<t5&J3PU$SRdX&N^
z_hN?SeuJXLRdvmuE**+36BRrh7oON?l%3TnqP{)g(972$0TC_dRPzJkcNm{=PT%*;
z{)n%*3a4(XOpvqF=M3JyfF;{jirw1KGH)xpu+dUIE}{9I?5nx@#ZLB|FYMe{d%WYx
zl<MirT3K!DwX0M%r!_w3+w1hb^+wJ)Rhtd(_8rs^)9(7eja6bziHp4B&p*ohgf^FF
zzkAfM@y@+c_XRoXEM0FmPZN_Xc^;r)=$)N3<^8G|fwP(OG*q@b|83t`cU>Uza_QcK
zEGqunY87W_wl>|o(5NiM%E7+I@bR;Y%V%Ahx??Tho`gyF(jGppt2TO?+Ur%(C?*@R
zaGzzPh6&^G-!5eq`&O_ny)uVgVC@h6bAECK)p=jSC(EDh-^R1ZO)Bk>Zb0Xb%Gs^e
z5-zQ8&u{bjQd2o2CBEG)ePX$^O^@oVM9wLXS<}kD{83)1%OJ4j(e;e$FA}wHOGdo;
z`o7Xne|6r^<5#oyb*0Ii-EF;l@4;`P*>O2v^Q43BO<Z&E*)c_<Lwc1v=1s`vZJTuR
z=bqh6G6&sXWdHbhPi1G7VJVk=vA`E0QJnyfqN_V!on@9idiQUk`ZAHkMLD}7UkIHN
zQ>_k^&Hdr?V25qy`H*{VJ1k3#ianVQ*R`Ecs*MQ~O<Z^K-k;iu-_B0Hb^ddLqd<z}
ziCHV}v&zo7xN(=>l9TTH?I*_YMb^I6nq)llN^$I?d_S4Jr6<0<%jn#6S4a2Py_MHm
z4|EwHX$!Gzonpojy&~Em(zrNvvwi1_TCvYPd4fMQ6C7vRsBPg+V)Ya$)bXF+oO7Xn
zV&qren}^r`RX!S8_fqzf;|pK!xA}$Utg$i8%HlB$cN^ZdNd5Ztve>OcJ8j0s)IS@a
zMzwkT=C$ADqI-p9$2!fu|M;WaHY+Q6^u%*L^<1hu>BI6ByI(Cn<$0`}wWa<0nk7>f
zZCA*;8+S!$?w00)xfvB-f6fgzydv||Z=Rg=*2#&Frdsg${(k(P!L~#oWoo~4qyN6G
z(@w9Med(iKYB`7e#VcFy%G*oC#vYmzs^}Eg|NGl?qxzDlPg5-GtXlQlyU(`p3oLED
z-@EPAx41)FS8IE6?YFf~ICWEP)|%xxn!oO7T~kqvojGky`h3x>FV9}&@^FV;ob=i$
z`p`;_iK;slKVDj7<96;%IA_Vs<x=K<w*9R%y|W`yzw<|*mhAP^JM%SaO=p`-EOjiJ
z<sxxOxbf5R*aI8Ax9p9OdS<0Cwd~v!UDG((r2kUy3ODVReQK(EzVg@X7ghUiFUb(O
z`BiV@1J!$9Y7R?XNMd1A58zKcTAWjpZQXRW`@p3SJTD!dh+Vpwaa-l1(u;lT#F>(h
z&);Tung7<4NuMQ`rT<Ur%S-RxTa!5T%>MHG)qZ!~&OE-h_SBSqp*1#9kLOf#SvN<?
z#5lC_{rr2m`VGI7mgHqEi%Rx<`;ans^KHVpm5CF6Y>@ZnpVEI={rleK{YI0*IJmw{
zPTx7V&fDnJ)81|S4&D3uak+}R=oDSXV1e6_f`0y0i|4##lK088bi5L4YWT6;K>ccd
zmR_&W-UVG-9;!w=rx(^6%{uh`hG3|Fq&)AeP}5SLKN+`o1hVsAV06|Nx_NKrM~8*M
zyRPM1#3yvd=6>e-CUgFw^pBIydDC4s+B&BNnJtyFH(M0`s@(Zou3B2`_7mL~{w(Ma
z;kR=?a^2wn9*I&{2dh`&2XrO3<m#`SdMD9#`+9)`>s<1!E4H;btgq^IID00m{UNtq
zORi_F+54IU+#a_sxR`DGw<#}{yHYN@dZN(1yBohXF43%US+wyQU%}VIA}r3y-lwls
z&bl?Ds70ne>hU`9hZ(2+jdvZXjO~v-dUoRy>m$!USqN^(Ke74rIfYjCsXTM#*JVpL
z{Yfl6!E~<WX6W<u!|ao5C7N$$+&cLD@5aY|pL}1o{hVoXI?C?jG}hBkFZ|n@WL4Gi
z>y-)D)*JFy(v0&zvd@te?hTn;d1Tr4J10*4`dfFPWd+xX3kMI}+7mx9b;5V!r3QiV
zGmX#Xu`KT6*>ch$MlfAOQRbJ%+Rqa`jjpUTzMB_lJl#G#afN<OJcq%&Q^8;50;IR!
zjcYG#n;pF9I@@Q)T|H%m{CNSdc;1LS+MK*ltNGxbDQ(g1m8mo4otl4Si)v`@frnYW
zNv0nqW}U7nUY0I6UtKWZ)RB)%#iE?I_nuvyaP{$p%a(Vh8nVA#vVVE@#EaW<Du2G~
z@p60;pR8LfWIO4~D^KfZGrmY!?NoAI=u)@n-43an-{PjaynNKiqyHnya8lKm$B(U7
z=(E|C=C)5d<EN$URA`*LaN+$wmzIfk#J63|*fN28TU&eK!-$E|&sq0!**&%YdY*xE
z?^4m=y({eF-X7DKcP}zjbA8G-@kh262Od2>AX2LJAU;^GWa|A`U5Rq;1lI+pB(7dM
zoR^i5@QJs)XWwF-T!GEY*4qjwtucx?(5-gE@WgV@7|&}3`Mc|usReliT6f%9!usY3
z`;|lXf<+&X2bG>X{^*2~N8g5*m64Y(_rBwr_nKR6`jTze&e)twd{brU`PX9qZ^QL}
z4Ge5`<OMpd3XKam>-R4`wC5PdqK(bWlba5F4Dl|Ve12hv%a5HqihTs@te=-U*}wa`
zeA|jW9&MY#y(AaEd?}P@JNKqYT`ud}@AhlY>XbEUD;FPl>B;FTEAnE^1A(xm3znQ>
zJ!9DaZEAeE#{og1I5%#IBw3^Xd*ahdY=WHy7oC1~Y_eJ9caOH!b8mgVcIZsy!IJ)C
z&TgrODNJg1!i!w>AKi`O|Iq!xWM}S#g4@~Q*Ne}0oc^=v@3|-$@$xgj1>R^rb8VCr
zOP}PM&&8p#ZU2h<MZ2}%c-(E?vVZdZ?QiaFHM_!PRqy1j;_7^ZQQc-$z~@&L>aojY
zZvVLcZC+O7OUv?>9QpUhj%R)mP&Z#Q|D{g?cjUSEO(9mt`dzt7MIVXyTWYYm{8+tG
z$=H)+-`r5He>@G|%rjJOD0vnx_PGAVLFjS!?Hfyze|WL!-s7IS)3ii$jlf(XnLrME
zr%xXZHx)dx-MU>;H*teZk?;KnGgAcK)J*x{_ho+PofhSuS-aOpJblypZK2e`OIe@m
zH9VPf&u=aW^lO>R=WBM6L->}uf?wvfyK9UNzMFUS42S=hX;bQtO*wJI^wjMwj+Hll
zD(=k;Ex-3@v3XVcb&i;V^sf=+QXHRumYP*&7+rmLecrrNM{jzl-3`8e+|!)>a7x`w
z7ZrEINWEEe^>eDemFccIm{btbbwl4a%rvOiac*N);kiAJHm0XavMvtStKpn!xzOJB
z!;hfSv^h*-J{Og@%=qiM@9OKz?-aTx25DWIdot_m)jPL;yzf!i+*IZC{9A^1wEl*q
zs}pCg&eM(3i(XOKsB`Y8L9$FHlU-4ir|~TT)4rrH<@c+D(yjXsz1bk{c!%3OP3=|Z
z%bbW9Yb7pI_g@Oj+Ft8F5fyD!|0y83x<lfG|EBqmk45QUW%=a3$z#LB?>EH!W~uJq
zoS&z~!E?Zv%l=ZVuB%MTi+c+ePcgqz^e-mKjG-|2hUnEVv-QM|HDv6aT6NjAU+`TH
zJI{@nsRp&4GB%5*AAh#Q#Wi30XU(I_lKWb}xxQR<B~>hOdCeWg6#lfR>F@Vy^akt<
z&tI{lCs*&yiUjRLGsJc%xE<Xu;PCbo;|!5Ehi^J$75_Vvdug-%@{+|ly+J0C*<p=3
zV%owxnYa`t`gGjfr_o>ZP}Y2^mj8o!54Yc(wc6tTu>cp=&w`?tFPvU0qq5I;&52G;
zmrcus^)5btRFub8Q0M;2Y}eUkS!aGF?)(u@(t1dD<yVU>D>plQ$n{}fP*qfyscx-h
zIq6VOyPxH|qvxGwvz7R6ar8Lra5lDY?)f8|_DT!H8ZDdqBBN3^>zq==1>@RFLSNf%
zeCadYb*r<g!u-HGmFKCV6A$(>#b@66)u%o+^Yz9K4WZfT52_c=>gats)ynOozSG%x
z!bk5uZhRzqg>8+cJWF`UCdL&>vnx1u&6|7algb`7zE^*Pw>2h+HSw$UeYHDv(BR8;
zmIKD-+H02C-ua<Yc*}QBwecr`s)bJ`6nxr#nCDN!@21pcA}S_n@2VAlWX%`IpRPZ@
ztoNhyi;T9lip;iZHxgUT)*QL!*QVtj_VZTn*2>9R1@4VJ>{G&@o3Bduo0@iJljku*
z$9dw(ys_tR)EpE{_nGpNP24E-vG<!h9uIG4ADVJz#qQ99wO?dT8~xqzTUUdP@6Dw5
zpYzpPdcyZ|DxaAhYySAKeQn*c<tOH7t`ZeFa&zA?uTM{F^n!U4H*)6O*qQj<vU194
zri7T|mVrX*3uksWgoKACd=Z&!*fZx<Lny0g!R|-%HuL81ov}krQA1L~D&(t$z-cq%
z%d6U$)z|MeTRY9f_0;;jm3d#aCmWVdu2H%9{h&qqBCgPP{tdSb=Re<bbX(-?_mY|C
ze_K2hQI5G{C)92iFg=Vpb=8lx3s@a}&c>*6B`a!(MW*V$ys~u3htDfJ{{8Fl&(1lO
z+10bAZ0!vDtH=7Z=I$=pC_eF(-(}l%X=*(se73*j&!4)Y!u#>^??3lH{k&Yeq@vFJ
z_mZidhwpxlY-B2$79I5Yrx53qNw3^qILW1{pG_%N3z1#Wy*}-w=Eu#CC$Bp&`!vt1
z^<|Co-EPf29yM)#dY??u#mN&o_;y9@^3`wA+4Z}3S>K$M4>&K}idw_@h5b=baHaiE
zr8~|KwjBw4{q(Iad!C3~m16uV8$Q;oWJljPmf2^gZI;(}mj3knseQ}gdF*>QAMZFe
zSKI%B$l+CI^xw>o+3T!!wyp4kSg221xG<-4-FLf3-EEitrEPzC@~!NBhK~%bxwEFW
zJc_ZobbTp%*QAw8=2TqLw9Yxz(`-{wcSq%;gX(O*y9@Lg+2?GYs%?7sdOKebOD?0@
ztoC)Pzj}Qmgtc#8KEhFY>gwyynhvvl#ZK-u^x2*?#au=!OL6itmYd;b&!kq0O;P17
z@B7tuT*NlLy{@y@u~t5TmCxB<vafKX^xhi*e7pbp1@ZSkoae2|J2TGMy6&Hc;Upo8
zuua#mK2ViwYPhgyrP8rmd^&#Zc8@Z*+}rhbYt4Lt%Ils#uGKBL$Gal_a=X+?xdV%$
zbGOQV{HBv$zWzv<Z&{e6_wL6YZ}(Xr3n{+R!(SA=a%s@L^PNXD6FBz%oiK6Y4gvlx
z>o;Cqn^^pRTD{`g2eU=LslLzZsyXs^<q4*H>4HitHk51dCoh}CxpKMp*52a6{Jql?
zF3o*zv26OgtmH|%p9lS@-IAYEZQ(Oxz5DD%ojWF$s+`y_tFN=JctL@9=kbRXE9|G)
zKmK~bCd4>2xL7_wKJd+6-Y}bq^Vj%pxbJ?^^YhOm<=36($N4T*?Rr|fEo1MB+l`Mt
zZ<Tx0yin`&#@y`aWg2c_ZqtsPEW9v9*fk+Te7TOyA8FpyDPg9j+uzJuUa;Bx)j5H6
z8!xX}Thb7{bYhU#4Dm8slU#eDmGghE+4)KOddzhFzT~%6^NPFWFFAP5-*|lTF743m
zz4G>lju{_&;v={xGt=|c%b7xN_xaqJx!lplUALIM=XRU9)pFL*<8MXM#5Z01e5U$^
zU83~P^l#fH76tmr2TnTP+nn*<?{<p%tY7C%m3}N~$Te28Qudy<G?Qtw%M-oI!sst=
zGS(FEhTi+#WAA*3H8N}c?3<US{nmH-x<bGvJbGgg-v^!NuNlIsRA(M*vn$;_gX7-!
z_N70)-}9B(sP4X{cY*z~xXsgLUthi0?-zDrUC2ka%Rh6kK2Yf@-nKisWXp#v)!Lg3
zDhG1YSG_5){ZsVa)ZQ)4Em%~~>Q7Zl%!g8)YhSdNzx;DZA~(Z*LBG(n^z9iQ2Y0Hz
zRr6Wr{%hKHw&T}TQ*K{;)ET{Jr^mbJKYvfGT<0O!m}Ajyrx}y>{~)8Y3Ab2E^WOFe
z_sUH;x0VNWn0qeXTX?J8;^+~{4{DWB((|9}@zpH77xdmtW#K1X4%@(wHZM5EzbmZi
zdq2bJ;n`aL0IkaFYDE_xD|u{~dibNw3dI$Z5|7`ppVf8k<-;4Bbay_MReITUdE@HP
zQjen7KaMWy+gvV}WPCoT``w~DcYWr?cs$zHz_O7gG)OEyX{FQd`~1>^Y>Q&w2DghC
zH;Fm!eW2KFCbw;i-nXoU$+a)TR1@X*Eco<Sp{8zCnEpKZIePLIF1zB}luplbbT6JU
z`LtEv%{$QzET{4U{PbpazC85d>-=e*35p@_x{mVKE<fC6RwSw9<M#F^w|ddsj#SNp
z#kN|SAB_+1KB}_rm*IZiUz=i%uy|Bxm+#CMIr~`hd(}lfkJ)km7~b}m92Q}nvnq0f
z!}3*8E7ltrd8V71CR^(k#BJMMyVIWSR{oFtI}etez0GfWMR{+(1n1mk!N+~vVt3^H
zFf$8|ytZ)aYL>Tc>*MP9-uRp;-ymfCG$Saq?qr_%&HqYoeqJ$YxF@oTW7gd4Z+uav
zT<28NnN=@e+VX7egZHV2?RU+*vhK-=usJdsvK_}Y{A3f4N~vx?b9Lj^&`ED%nUC+k
zovgRy(0*oJ`FC%Zc?UYAxN2ww)mVNxGOIy$jy<O!&(@PyBbF(4Bw1FTxh8eg^5gDm
z`wsaXDiQBig_n2!ZC-8Em$6T}&sBL@E|0d}Z{wQBYKh;fC%>MS{^KCC_Mzj?*|y5?
zh;I4ykXz(qM!w#w&INO;@7es?c<n?}?vsrhA3n_ec|z@%d8h%4?$PWmhi-mTQ)~2I
z{{7$kxG(Eol*zBR7Zb6Pl67nrKbAFX;m1?&!wt>P$6Q#)v3L31wauBXuP!Wf+t#@x
z)AG#1!1ohw-xuOguU)V=&m?NYZzWdCa*a8=FWjzOcBS#hCBxvEmrt&Gxg_JBk0itS
zZ8N-8w4ZEv7FU1s(_1%V@9T4J{{OIf`8{)Utuw-U!utxY`MWpG6*U*p|9#(KTI)uW
zmOCNrOal3)3!@*)C3~|N#c+JR8};tQ4C^J4v-X%x6*dl>ocB;t^wRIkujMan41A-O
z_(br)#SiSIE1A_MT9)n-Rr<EP$e!2AH)Td{n$&~p$XTs_dAA+<`un@nl(yX4cPlNn
zP3)U|f3M|vm&u>5zqvEdh4FFv-;9F_$J4I7xBby_t{_0~#N{2<lg?TQ$J}n%`R{1a
zjk)2^bu8_*#c!*5oMdj6Wy|mrY+d=~+*W3j|9Zi1d6(_%D!RW?+4R-yMb8|gu1h{Y
zl2pRpYkXhpO?<%F<^tat?rKwYuGKzef3nB@%ij6o&1<=&+;^uqE?KnM=0mHeo*rwb
z0+Y1Y-+%5hhXm*Dbi64u%k08}Nm~r3?^scGg<X}`QTh2r@11)#S~KpwbtHGc?&g4p
zdln138>eq|J##Gi!MtfUs}*nMntwhS^Fe&s0)ttV5~dpWuAHqr+1ML(?jYZb1F62e
z;eRLZihiADo-~hd&)EeZ46UY32)fJftQdAhRQ5zKPt+%qWlx>t{J*rFb~;%7;4P!D
zkddRsyC=>0-^2s<=Ipz^^xj*e^4Sk0_Mcm@$|kcg=?1UHmSFSkukJa&y(#-nadql<
z<~J5)>dV}ftzK#G*6PZczj?30o6~byGxjZ<*uH1atf^1dIPG}x?b@@)5_-WKTeJ43
zCKozB__V2g{{QdOr`Y}dIp-PQcaHUEGj6S`x-_@!smI-4wX^GN&&A%<y3y}2@x^;i
zE?Xl}af37S-IuGdA2qC+Bg_)~W%`C1wt|b1%h$(GQ@PK#=kkvED;ZvTMt@{l_HBx4
zj%ZGnYta#7uN7Y5VqF{O2c*0cowI7U)8Pq@dH4B$tPt3+;;+g5p6L(GesV-rN_BCU
zKUuCGYqVQ-TItdpUxC)`-{m({9Ee}f_0H+ZrM|u?VJW$fd=)DbZZE8P{n<atC-i*(
zsls&(Zy3b4g>7W(YJYL#ZM$~CX#)kln7q9K%kS{cnLo*OlW>>ho@)tngQm9~zcHO<
z`OzA2JB`=E(`8h?9=afUPfp^A^P}lc?NZtwiAOq0@!Q6{J;Zru*)zA!N6b2hx%d@a
zTuy(G-hNnhPngNBYfmqU_AEL4`IjUU^NEX(wp31^b!GLOlUo+L&Utz5^WDQwelo}f
zYP8PCuWG-xAz{MQ)3(n`en>R!ziroj`QF-N_oP!7os{BOZ{RXtx1IZXd~xriV<)F`
zc;9(YwB+i}?2T-a-gg@dR*C$wyK?38j2|XXXQZ(7v%ao)%6RpdxQ6HrhRZq3hpm_o
zcAnW3IHf)6)`gP9lXdygyh&S@ygh%&{b9F;(XPqUyXA_xDkTDPPED;pk(0(DRB+wr
z^!m@~d<T6wC#Gu@2Huo-C7%0ir|~-Hu=)?lJsp<buKs%65|P_lmUhn3NL+vP->j*>
z+1}MjJn5-2$@z8Ac%Pz!bM%&+>-X+N9~DubIw`D^Pg=xI=+?fx_yTRSbKf<te5h5`
za+=>ffAyT^FE4-G?&s?EeEs0#!8M;Qc`>hyJ7D4RsKzN(^WNv8otob}FG{<lXSXq4
zIV<G8=g;LUahls!^dBi(d3oVv!ChAGwZroRJnFYC-}$}&tmTh~x6EQMS-*d}eBDfw
zxlMA$a@SaRI?_&uTuWVVcGLTb)G?ugE#)k0f64suj7wYOb;}{j{>zg$HV@Bz-k0JM
z6<6IGX!TOhLT6h_Z*xA+$4A$9)wS-<oiHPH?NolhX~!ST4P3J|@kDe^fad1(<Ls9X
zCazCi`?I7hmNR=M(_Z=OM?P*3`1$4GN*1f_o0GX8|9qBKH`86%((1d?3Ptm>gC^ft
zr`(CQ=;%5(!?eDBw&&#iMcL=4yH+i84Gdb&kT13|c(-?Tu+@v1?FH;hqi3j@)o++_
zt+3ltHCIu;`RTr<hJ>h;Gja#+DQ#V67#hDu#K5!1F;_Lu<VGuV{GsV5nFG5G7ftV)
zk{hyfkK`MlKIiFWSAV!1t(&i*Fnw#{f}Q0`k1iFtN4%D45!$L^A;zcMvh<&<XER@2
zkHOs5M|K>UA}UkO4*axy8OxGuzO(npik&x~&G2#A_xo$t`djNeOT^uJldf&P<@c?4
z%RYUtw%(7trjsST1jRTjr~9cad}7@k(Dy2i_vI3<wpqEZe>Yaf%AA@TC#vdl?ex#8
z@U6CME?+p@UG8vAQq;It;?Kgs!;&f*oZfDGT(nL)UcV<AIiLSj&1^}P+nwE7ePzc^
z3$m@cyiM3``P?<~v6U0q9@d_l^=Cu3*=0@6te_Km3_7((-Q&4Cm-jwmet%c(gxii(
ziLjq`s?Izcj(6>Rwd&M-{R{<x3ATIQ*KIz#=rIfbKe>gI|0=8AnijT6{cW<utZ6C1
z8<(4e>df8v<<;*iofA&0ywlb#pR8!<b+$(*TTCg_r$t`lnx%tP=w}h;`Q?t)HU<Zd
zZCfJjZPYj~Z|<b(WAEq5-`_v~&5;dlzy5W9U4B8re&@$EcaKUR^!!{Cc}HG?Z5nUZ
zV(ypj?ziM7%-VZgx;?Sef0EAg$Zy;}zt0_tZrjIRU?elkHQ4jn-rK%gRWIKCV9@{e
z$~m3xNo!<&e9+AMWj^WfByT>hKT{7)+<xZlB5U4%FF4s_15JEO7ql;3l*S@7Z_E2`
zu73Gvy-l|_C;SZbYnx`#CpA-yD|6~(ZT9<17AHN|p2{vRCo$EJ`^gN|TBgJMvh#TZ
z=Pld&D~xxy*_tnwlP|0+xh!sW?QB7wt<|Y*;p|`S3QW>U*@Hfw)VTNcZ`_u`-`i)V
z{NfVW^NypuPTRLNN{DB6>Fwp&=Sn8qS&4D_xjdWg%d>T7$C8E5Sg)^rxY1d}XKP8x
zqEIgWsduHEYQN{*@p+S&|1Ns>n|FJcx%{~N>T}$L4IebmcbKruU(QqFwk7NRFSb)r
z{T&gReU|LiH&$M`a>Ce;|8vZ(YWbW~J|DB@PqOY4=6`H)eqr_eJ1S?+O(~6e^T~r#
zP>9)dZ)e;s&(c{}U)=E&$UEbD>FK`fPKVmsUTot|db1#)`_|FWSLc+2W%6e!HLq(q
za&N=t2ON(bUba5pmbpPXq%fhoD~;`$!TW83(vF<ZmPF^a`|kLkQTSnNNQ0EAoKgLR
z$uS92cLbG+PwQW~$71n%3kiPHgB!O>|7Cg>mODRR-Fhki^6Tn?C-0vs3R+TV`oQjw
zYN)O0^<TOl8C9NCtv)$XIP=vWo*9wp|B}njx=Zy-B$^*tXyeN()v|EX={i^auR&2~
zRwr*Mx^eNw)pvho>U*!4Oh0P0TO~%OL`Biu^wm}a`ECBZJfHSDzZVyMm!S4XyYj~K
z17EWY<Rz9mJ?wjZZI<N5a>kU7KOHZZ$XCsJU-?Vn`tu(%58t!hI{W^XQ`4u^*Jgj%
z(6T7Aw<JXR_N0or*Q6y3e_lKr^dp_CvfN`^e&e&*#!PX?I5Go7jl6opAG^Pd`R6*l
z`LK!e`Oo_9Y)|h;@Xsmmx~Nt$H9q0Z6@BL0Z;zf&3Ap;%p)B}c)T8OFU4mho`0sAM
zl({7*e!9q-%QbWRBlqhG-u-J+v;IMeMMj^$`*ww;Vg)=K-C{~JR<XWeXxL$&sA{g{
zq_KtL%>5^iycdV|9(%ZfQ>gv)R*771gA<eD8@D`?kNIwRq4tU-yIN~+_u*Ii$7C05
zU!(l-_7(5n^Au0cuvIKCa=p7=^_IG4%v$;AjF*>R@&4Mhfag?lNWs_p{t}tnKbzQy
zKYN&d=t{|&+P#yX<h|Lru8rUCQuH-j)*^wAuhT*#O;U_j`(85Mo*DXex$>mt4>uTW
z^7|y5VquWB_?-MZ#%Z&*_o|-pcM~-DUg4b(lo=^xc|mAJ-9js~jcz{-xqh0-*WBD2
z`)rSud*GWbJAUmbm7KTE=jF4{Nlw4yo_}mH5x771<qD(4fq&ej%}c+v-xB|_Na={X
z?LMckGlcD(S_{v!?w>S&Lm=CpmbB1FmETup+?`r_!Db!r$F;Yl4qIH{I~>fKK4FRa
zIj4I{9<@7{E3!}6_Fh8b!9`!aJKCY^ucj}3v&7xAwBFB`S6Xaq&9Y|?Ce$gpsU6|J
zU~MqXxjy+~;@R+eEl=qs|4k=FddDwPoVzSiVEtD`bK5`JF-|vqtRik(YI&p|yLa^T
z@w6qEg{u$c^IYt`AiuZ7Ikrc&-2I{T??urL$$HUFQ{q1HWW9_leDk02%^5vjY>QpZ
zu`G5qGB>qEEOs?AF*Y%VagkTM8kt&HKo0of(s#?uDM>9-(09v8EJ<}qP0mkA<+8Km
zDlREXP0Z!0xYe_rH6%3ph8~a7-MbrJPI{;J@?D-8uk_0)VN0A}@^QY@d-?9&J3r6P
z-L}tb+|PgipM1w!g8AC#Yc=<xiXB~-tvRNV#b?Co)g%)m5jivB2g4(-Rcmw@#Kg+f
z#Kg>4w6sdI#jPLMC$VVxE||R8^hD!(e&#~;1)bax->w~D%~{S+#BgHQEyjqOjB8?Q
z*4(Ml(P1zX6TA1{kj3&N<GoosB4;y;%wX80z`nqkX{yDEi<eK{x^#-Q=FEQ^ri`;M
z7}o6Bb0_~_5qrli=DBOm`p7VFsp*9|RDbA9Q!8UIoiNk%!qLz6iW#hHVq#=|&X{@k
z?%kO_Z|2T)@SEmTlF#t&nqC+~=mO&lCwVjYeoQrRxOhbFM|qkLM+ifycJ}lAPqP%b
z#mj}&6&Q3jY&K)IvS_xAkv-Gs$ME4HgQ;X?!zASk5A&0M?&rP7@NXq=!_>~N_Y3}4
z{O3w}`(gU#&Y6-Y?p-``@bayLLJ5hv>?|6dr;K-2?AXIN!(zsNBa@BAY>j_?@A#~F
z>*I5ft=`a_(W7e>gU<oZf0O5Jo;i8z;%?)~o44LwFEX>fl`%Z>(7_m)lzje@f<m_+
zN8hjADtv(_rp*7@e(UVl3`ON1{;@|ySkH+5<8|oH)rpaZ5B{2~9q{a}y;_3cq5PSu
z7g!IRJap*L+0%Rs`<NMQ&#akI-x~hCgyrATl)tKM=?`AN<tSo_Xqe3KD=M1dV7<Ve
zxxRNA7{t}X7p(t2zw5seOITRL&aE@K4~S%BzHRtmZ56?@<%e|h?Dr{e880L=o|n^Z
zczXT(et)(HAC1^8Z&dy>`@eesnf#@$OG82=|DF30KX-=23FZf9PaI@QNO_#XxZ$6a
zQQn8<_w|Q0W=H&Ye#{>)$<8g%@I8Oq1EatE$=mDM8otecx`6qQ`7|XCo2?EEZ{I6k
zPk)$V$oxO)Z@t{t{W1UktNjU|^8faP|M^an)|Hjjugv^^>3{tdwQtwT=KYswXuo!q
zbq@oV!UrjfKl#DB5AJ)fW-!@aw)Ox0C`obQ4@w<Y5x4$EyJe?)X7exDxoK<n%&Ye=
zf7%}N`1-V)k=6`T9nW3cAE(XWR*?N~I^UkCv~3T<+l?z!{s%E0oc;N}vZ~A(hiCi4
zdU_{wCp>zR@~D#`&q$(>X;0+A-5Gpeeq?trp7G&R5Z}PfFlV0r0j4J{A674pnZuBF
zF@Dj0LGgyjH|CGn47&fj**xI<-CMzUM(Dp%o*2XCC;3OX5~ls?y}@wi(tbhfhRA2;
zj~EP2|8q;wE7~tOqx(-j%d<rvq#Ji?fP}pME6Ev%Kdl$EShDGBzU+*dr}A0Smi>}$
zoVoJvIewlsx^I2!Rv!$xTCZFX(|eyIXYEhv#+6xr-4a&a+Ala`)w%s0;y$6@&6$4x
zwd)sulm1J(v2(W7%o#VC4o;uadOF|o_x?}&#oxxW{!rL_Ka_#pnE7U7`<r?d8JYbm
z-|AI<WdE9R_J8Y}2XoFimX)db)kic$GSsuPMl<{`*3g!o!B^qpJ7;a3_^0XTt;0Vg
z{pVv|xBF;5huMZ7%te2iuGJr5d3=Au<iFx2zt1*(o&KP_;9UGOh3od7&AdAQ8y@`F
zf3vXRcgE9~8LTBg4m0Weeq19~Fw3mop<sH>|Aq&r{>_xy@#b6o5;nb;?@!E02xtEg
z_J1M!bG~1`Y;Sme^-Im^d7N)*F+=&srm`RBSqe7%Q~sO(|K`DTOQyL8rhk%O7E^z6
zjpP2^XBhSR7SCP%Sw6i<^?hCWd+{PxtN&k{ewA;#QOD`1=TIEH`+q^=^B-$}#6Ldq
zwg1`vZ+rfG{Len~E1T`#3kB^Riu)yt{y8~px3@aRX;#j5f7*XF)^m4nzB{j&lFB;&
z|8Is5rbpf+J!ScmJni7t(n9vX4;lI%{$gj@e)BCqhuXV;$2*$#+Wu>J@L^uPL&45H
zb(5LhKQUSTt-Vqo_cU#t-vhH<e@bsQO@C4UA%4D}!vgjTJc)^7DaYh<f<^BXg)4f!
zIJd)C%ffZ*;;AmjU+jJG<?dHT)^FUgl~E67UG9A`z0q&WQ(ewm*%MtaslQ)*OzK9z
z??<h(_O)`oNulaxvjm?VFRVKLsn2C~b;rX_iL0(<we#-%%wW6WWa_l-WKinf;-`**
z=ML^Een0Kgig%iEQvVEgFWwY=PPP3<gw08bm4XZ90}Onp=FYNfcISJ1$b-kdzwlk7
zRc)<t>qN_MPFm8Z8y-~4oSgT5?e248rS^}v1}!@G>`tG5=lX7Up3+`J8^^c0+vY2D
zTR)GTvHy<s`->VA{AYFkQ7fD&*qb?Dck7)f(>n|It-h37v2bds^=od08EqTHi>>!<
zS|NA(L}v`=?mag(WG*kAbXUw{&;2aLZI_A`-%L!L?6Kv9b>v^B8E)4$T7AlY@!?<O
z=e*Q}4bwk<b56Q^*WvGju=e#~jRpM%6PH?R?`@eHcjJ>#yjG!7$;Q(sR+s56;1Rnu
z+jYCXP5%WoMW%a=;z|50Yi3vK=<Kq&5If<p%knvqcH)8imTrCCwf6Pp7sX}oB-kAF
z9b>xmm*sXoe_r_`?2XW|O!<t>!Kzkvsq5V?ulNwon7zEYYv%du-i0&niB(QIbv(D|
zT>O{7XT>KxO5dKD%G>giz3SGT&(DnJW=+d7IbQH=)r4I6cH_P`*V(>wv$mFezBl82
z{=J&tYH1y{443xU>zDG2N_X4}c+Pk3-<4Ib=HGm`W{Qrg)W27+-(K?(-=lf7bJq;%
znYFbhtETOGaQK?X@9Xa0&5s)8ugv%)E>iV`kHzknj>MV$XWt)M|3UoV&yv{p=fl3n
zzU&iY(&Wum?b6CE=j=N4;<v-zXGe`2B^J*570cIp-OA<qohK*6ZeBPdwsd>!$~s2(
za^{Bl#!8Z>^rp?q$vbWTG|P8_nbMn^N^25B565mvo4CTLbeH&!vOD&FqI#IVSzB{Y
zyYOP8iNg90wcJp<`HZhq&Fl`RUDl3$(rB{Fal@I&{aK=~qZFRZUQoB2Pvz;Y=!XHl
z&Obihbzi4HbFy5}O)b9K`y9cCK5SomdS#k@`h>H-3MV!@J_vi2x@5us8>hZ6R_@-w
zagndZ__jNLd-DyU84C}-THocjBj9LA+Vm4@+-Xl%yDWE%ua^^do#?8Y-W2y@ozQgI
z)(NGWZ42Igde+wYaFxpfjtesHrSk1(&73+<v1dP5x}KEF#5tQw)TclBBlEUyp_tdp
z;D164L4p!@rF~so<`~q)t55JdbSmfx^YlMT7itpf!-DJW=Wnx0DBU+pbWd2-1OD*n
z=)j3uHVyeYHAm+bv@~a!%wb*oed*V(<Ia%{&82NWye_1^@smmt6rDL=d*{Z3*FDco
z{o3$1y{pZFWlJfSU+)(0%&SMHyzf<)JNf2wwXu-a->v28|9<)U?w0YA$xEqP>9*a-
z*HSe7>eK!kdv~WjWYNh!a$iq0<-Mp;X@pnX;=6lxUi)Bo{?+|b#yHE=ebOF^>Bq(Q
zwEmj2&Tggh@hv*-<rWUtKeB~q1)RIB5)u>cqxIODiF4y~AziN-GH2WM%v7goo;_lu
zCz<NywR=80zbbFf#~rV$-d4C@J}|NI!)`k!i<+GeEwjwDPM=@)G)_K0wf*Dd`#YNM
zX;0Zu`nYoKu4Ag{wR4^=^3PoMzw6HB&Of=2TDRwJDe&E49sbU^Pg3^Yg&S|%{_RX%
z=B>H4;9}U7i0}RL`3zpUzq|jqJX&M(8PTstrGq}ZiBHW-JMQvn>kS)^@0Ir^o}BGJ
zEmyFq?_U1qEF<?X-JD$^|0*mLlRIBuILTIdH+bHi{`=p42A59X=F5|?JAX~y2FZr5
z-PagW-TV(3g*mTS_xonjx8;)zcGPTLqfzjg^I3uG-+3|H8{c-XW=QgUawx&3lHG5s
zclj%&V~baIed5tvzuW1av(3S}SvzuXJzOp}(_Q;$`>e?KxvD%2UP9Va_RPN7V{5jh
z^zHSsS9L|LkDY(#O{`iwlYePN<<f7bmxbtXdtUg$e@xST!`+)7vp=2@yB_<p?EcCr
zsy8<M^e}OKdF9BHndPiqg?^TX-A9dGim&Hge*5F}p7vXUnVPenZCxm<lKAMv!$XRb
z6q+jcgg$pHd?9=H)s8K<-J+ha_i>&7_eqTdSBKk-&B2{fFS5_OY`j0wcDv}e_#J=t
zr-n+^?Kdqvsn9AMm}Gk@&98mJ9)-U#$KQE6P27{(wrYWax!%>qzqc%6PmTX{>4~YB
z;!Aes{>1Q_|Gj&H!&dP8sEP~LiSq6_QSLuk@7dQ)QU52I{+s<~bHmjp<4~SCY;*p+
zKRan+ZNSm{Q!mf_w*U10c^|&-sQxQ@-XlLG+E_$(`}<ezUSXD-c6~a%H9Fv$EmOe<
z-#L#zD>+V>JU{f0v-2M9bFMxGEr!i=%^C0L20Se@JLYkOX?piuhbrHjM{*Bw$0xJg
zUZGUXvO4^`v^Hn$$Fg`8x5_O{&hu9;{?A_be(Iyd9}PjGWpiqMegFM@Gi~ApO_7uy
zBUQDfJ*BVBb!}|!r+GH@?Y3))NaK3Ny{>zL_d5F%p7&O!&;IArm3x(^W7FcTn{{4$
z#GB03>5Wm$zM((QbB5%l`xU#)9|j~IT`N(?|Kr&1pMJ*s7baN93p~%ssGjsVM{eq?
zhDV~e8QG&}?Vf(z+*@V-!`6I(*1EViEfUk_2g^KJ_G6oAjAPgA=|OJye$BLsE4eqR
z;PAn|)54z?>(p#n67+UygUp|E6F+&(3!1V*<KBYX?G^j4dhV8awfC0w+_^iYX0--#
ztUda1uEMKtGSe6=4;b5(acwr;^YzdY?LC=nj>|2W{NuMzUs3YUN6lKLN&WKDxM}W>
zpLKDsUXh(yXf<i^3yH~c?(1&Z%wG9Boz1wxJMi90r3nn@yI#C4xXP8pUuh(H^7q^P
zKRkE(epSAc`ypX9JBXuAdyY`5^6B3nZ%DYzbUWS48MJk~^mF!qTT~W#lzp8cynM~E
z(>CjT!q@REkLG^DAMW($dH$b0Y*}h61RTyj&5o1{_^ac2uJOg@zdt0R)=ZL1UViy^
zXEwv>^xrp5MDhEce|^jKOJ_+DGuQg>6`ibodDCT2ygVYGG&%oSHP_5JM=I<CldMf%
zbWHEsY*(^dWOjGJ9kEXiJ-4;$=I~8l-Ed~sqw~4;bNaS(PpDbY>NuxAU=P=Cu9N%s
zP0arnbLr=27Nd0{Zwq_(sroGVp8ak5TDda`XOc9Ye_OwYX=~8M6OV+BDb8ZI410Z_
zeb>qjp^w~EKRcefzuR2>Lh~Pu?&N)w{Womhen;!`xsP(M-K;*>wJb5br={v>R~B_;
z*Yn^%bL#KBw<*2*edoLomSajBnrA0OWUIE!>OCyG_{2Hx!s$h`d|&fyK2@u_<a<Qt
z^)IUB?J+O2)t)`*2ov9{(sq#Rb9nOkM;ueVeq3lg|4S?0ic|Gv_w=<_3-y$~^NKQ>
zKXcp3b<D9+{>q9gt3_u&*|GTaLy3^d>HS~ld<vHTUAnH?z`x`kV{Nq7^UevM4(C5F
zwbQcy;~+7$<;sK;miwyuEap$*&YJHywQs@7RiaH-LIovVr$$DUFFbX(&eJ3Ny7rRC
z@0R7&p4lW->fyfXi2a3yGvkb2t_gm>Yr(~`PqX8^)5;8relV$O&+l#KaG$Nv6tH!=
zsmZ*ifT-0TZ*<iocW*1n%b1<D>(<MHA9Bx+MC`M<&X9Lf#a~%^)5hb!4Mh&;e)g%$
z-I;0LuKbTZTWG2LvdMd2oL>1^e9gIgtG(Ipnri%dl6G*>ZO7-YivzT#t?VdY^IS(s
zX66oy%pK<IBxNQ~o1b_0qvT0F?sd$McCAeASh~4rlBMe7mVdrKUzBKV-P4eKJG+N1
z#M(z?{;}^XO>KVj`!L_-EaeefTpKs9HP3O0v|DIWTxzqtvHhO};j-Czjm?#%6<3RF
zzi;%GzN9j}hrM3yyqsd<OXYb>e=|wyFx`>;-lwvsuVeYFgTK2coC!a<^n01Y#+%KP
zDk?6ul$aY$`~CNq!O8QD9@^Rb%Uy-C)v6XYij|*|llgZ^G4h68`-Z4~(?8xpDw`uR
ztY$oUlVoopzD}<Ez1fnlCztPgdGO9gwH~$kGYYlteH63i+E{qntlKvBs+F<x+_tNc
zm;PydIuKUb{77j@__mYALi$hdToyRszRK%l_JLMc*<T6oBi+(tyXBvm6(n4)TpTK)
zcYm!`n#UTgw5020PXcqNm@c1uF8t`qfPjBhx!+4TU+eIQ8L!$YvUS>p^&iwX`^KH9
zI`3pQ^Zlxi&o3|DekID~-`}IRH*4MMonmk)o3(nyVLhYDrMe&L{u=vmTe*lUedfDy
ze~!?Fo;n$89rlt#irckp^LBP<IT@c)wpM9T=W>=_`$$5nRVOm(=+%Aa54`Ms)^DP=
zQo>$yitz6pRp(gWta}}yrrV$EAn<EX{`F;#Bz`wOi0->D68pP-*O%Y7{&+w0sEaVI
zky1H)EPG$>^y{0ZnkltM$lYJntdbGAgzcyM><!aH?(OZ;di6VJwcq86d5y>BD++w>
zyO3CS+w{OuzqmQ3al54tSUOGU_@Gy|?)Tl4x`q#BKX!<(-XY~|9k|XY`+Bv|g9F;8
z+XP*{<!|ET>TW(5|0Y9!S(fHQk68`OTGnU2^>xiDx-%il|A2w~u60X)hE6tk*>b7$
z?y;3ceAhjA?{Ay;ZtptzR)Yws2F^_jS?1~=Zx{HUa(RML!DTD!*5H{xib8&;{S<o2
zdtAjnnDwYwTPhF7->V4``HUjr!M-oTG!9p3$v;`!RVq==bbqy_ZS|}ICXp$nOS;mI
z{q(GecNdb}qc`io)y4yy{DKd^^hZa|UZCo*!@FD5$>%-SD)|cS+|P#Wxu+#>b6Q_W
zwq#74zA`wYux8sHo9Z)W8*?tMn?2uZ;T)%ge8Z)Wge08P4L9n(oSGGLKU{y#X4Pai
z#YJkqa}_=?-4!bTCH3MN!@*|B33`$qOZG2~j68F%I5kMi>)Fejn~s(n9&MPK=r-+j
zA>Ukq469`yY<_1p-#j$ER#)+B#*6IxVmm_unW|pO^|m&BW_e?>a@(|Hlixq~&8=<r
zE6-h`xaj{EnW<+z<Y$(=j@&Wn3-_G^9wI9**2Y@=|95=VMeqGLd~dRC&zZ7{p*fX{
z<rM3Uq${dYh1w4p&ZRUanC?-3^lb9Nu0HOGKZ5p@{1BNuNvhs$O-i8s<_-MpWeU0{
zq*!mA&X7>=_{G$v`gms{yKMe!)#Nhy-QjshQjhtX7?nl(*S(&aVr|-g^Lp^9xy{G#
z%`Z++IW_qli@U7vH(o*JXKVYW<SgvD{MtWwyUcsJ30{>kw$nA|>IsLf+qXk0;>WDL
zuah3U`B3BkZA+5D<bMto*Xw!~eOxB8>8fgX-t}4jzl>IgYA&hn+;)azg-C&e&dQs=
z{^ZH9xvw}<TEBO8V3&T$<3+c%HI!9Cqr&HFMLj-}yHB=>rSeYpX@UG&51mVsPsIn;
zZeG|IE3n?@cSh`vqjKJ6@A%payKH|<yHS<x7nNeEb|6XT#mQ}sQ(tO){dKbU*#7hL
zIGfX4a#w%O{rsV6?sH{LxpEsnzDei4uBj-^?EmYyHZgYR6z$~`L$uz+zGZrSef|o)
zGlG{p&cB{`c=mIS*D~|9BE4mudh7OyekyHAys=ed+mo$}RO&R|G@1xl2JbMRXFexq
z%B0;7pZ{T-{QO?|l|NO{$6nr@nW4D5HRHi7zFk|hJL{jHD!cyld*|lIo;<SZTbLhh
zziwW0abou~l?|(Y252`_1d5j|Q9kx)hIvHEY+tpbmCU|jvy=B!U1nXUUyxN@v8Sl;
z$H5nOUlqBk-I{Xy-8ANprCyFzv)9`k;=KQr^=Z|<X$yTTGB-Lto}#ZYEz^AU*RLCu
zGMD#!t=iqW((sz(<9lm_Pk#8j(q(%7mz?$0I_uSYx4zwU?OZ<N4Zj=gnQyApKXn~=
zUV73{^V^%E7j?c~>mMqKKh!L4dw#?}dGhC+p7noEBvw6LoS1QJ^4h~fk~`<VW0AdZ
zTur6L<7V9MYtuie9o!+Y&#YOrnpw%d_;6WG^&gvn^7C6>El8YPE@NlquDa3U!s3d>
zQ*Lv<7ORYHt(QE)A)a;Pv87^Z%9QyF-ktx;S*n(<!(y;bbIB_czY~_RnbHM%VtGZ<
zS?^4*)c<jjZ@2xu#Arw0ii|A5LmRGK+9frIQK`K@M&m+5{>NE6HrZ^EF}&H=Rk(KI
znOPoUFAiO)`w)|<p(k1Y)#3i9RrfzVYjuv8eRhFy+u{JLR2B8ocSc7yB>$OfBM>rm
z+LFSeuW~QV?Dg{IM8BA^&iuVr<Sj+D$DzTAD>cl2Hh#a&zl!Nhj-Ef4ZLR&gx#jzQ
z{onF*>cxM8=@X-;m@#hsY4q*OWX9r$tG68~bYzOMzx<Fb@^^)}<=!`wq|Cj3FXHpG
zl(}g4W#(BSBg3yxnqKVF5jwp6?uBi~(kyyhc@Dm2Ir>J{OK-cDDO0KJ7k?4&iqub?
z`Z9}ImscNJDUfVpetdiE_qs_tp3MsSv^ihmTfv---b?0vzQ#LKy6fK6lD%>}8n<-4
zaMazo|GKK?N3Oc)CrV96>bQ@1c%HozK0{n^(?a13n~d&-WpIjC%{(nxQMsQn#{OcB
zw)Nx5H?Az{ePtb}@J{4f|LxWH^l$C&&uIMqMN8BC-R4dD_9YTOL%Q#r6*-!*rYg*~
z>&e^Ze{u&euYFizBVx!XqEv5Gv-|u)tp{uC$`v+kd2MpN+w1)03L)QJT-EzE_p`e?
zi)j89U3tqOeq*oZuaiQd&D}XVI-4&fY`b(iQ)=VnXIT#F``R5{m3_Je?mml5b6?xI
zKlYcci24dq-+cY*m`U<)dzDHRd6$(2&Zt|u$gBO#(l1|5^cP+#ODx?dJhAem@g3Wv
z;w}-UZ~H{2c{K{{N?TpJHgZP8dl|9bN%^nWE}A~$+3KtD7bRCY`WsAYvDoq3Zm%QH
z)zF*?2js-t{{+@`uV|K7$;G?o>#I5YEYtI6UU6SByWFy}?%K@<CVj`I*5prlbx}}~
zW$DC+!hVZo!*72#jPPO!O&06*W(%BeVp);@)9uB?e22>~p08$HICK4;FGf21EP}WG
zdUEgcje_(yQr&TT#hKULo|GvTaG1MN@%pLk*5(o+!-Y008vCVwX7ax)Nqs(TMxyhL
z_sf1>JDaQVN&58kjm~Qm?tfK$wtTBa^8`t0*GB?R7A)DZc>4+O+K^-R`)=vh-C%qX
zS7rITh2__?veW0UtVnEo`uS(H$oU)FMM}Ch&38RNZ?)p4Qtn5`&%Fwref|7#`%}wa
z>W4p`FhwZ#(F|GrM?dZFE&g?YXXln%8~na3>w0Ht+nzXmtN#?+$NZ;vmF}CU{I#)V
z{~Auo--~ui2~TdD@MXp-p_s+n_h>D+xbUp|7psCo&l^1t+p_iw{d3t^8R^qI`TOD6
z0C&@rltQ-3>pA67Tc7Ux<#_tkwuPA!!}w*+2<3{}swy0kUG^kzKA*LYQl0h@0q==t
zR&Mb=t{t!NpV@R>u+sh&J9{h^8Wv|X=rb+mWteo@yZ*#Gq0%3kI=+3)4RtCGeS-CQ
zuG;ar?v^!6e6~b%sjZM+Uj37CdsR(Q#G{_vx|pb$yP3DodE$~Do!zj}tBAqbNwMsl
z!qWIRm($c#*;)>=N>6R@di?I$?^q4(!@QH$Ha~pKwf~M?*HOFt&+Gf%2_HNnaE<?3
z`w|6<xaB_tdGp!VE5_@YHfuYkE?z4<r@?>gs|GRAQunDfuAzIIHbkoi+?za2DBN&z
z<$E{HMvj~JVjk^Vq39_2Zk|li%}o`y_ES%P`jF#cZ2V=Nlyh?!`=&VNG&6>u94E^{
zqIwRMbg?#m*?Yxy5lelDp=bT4?4w6KPl~<yCV%_cg5A}t=WYKyZ^EOmm)>ac&9>$^
z{O@*tTi}{61xHp+eE7P`NO6sE?Y#Nx8`w?tvK{AZSV$b!JmqBWamv}eJN>9quixdA
z*^ilzeD4%i(&${0d#>o5e|CDCdS1YCvE2zm9EY!Ncgd0ZB+>geL}^OpmRlW(F2C<6
zy_y{NGVC&c{r|Y%Q*}2!64|__+&_l>#P6y{6AWUv|NP1Rv?)w?tF={bLT!VGOU`K_
zmad$?Thmu}#Pl&gpS|si&a2e*nGJUeg4I5~JzJY{@x-^T88aU5EM9UUaIvC3>m~Ik
z`md5-<{swUdgIqR&&|azB81hXbMCfeN&Q*>O0o9$on~P*t_u@_lXzb&=HGk6qU%gv
z{;wyN8u~Y;sc0welikUEMmk??UGe3GQ)-M~ML8s$JTysizt!yPyjj~eXZUEvKg_X>
zzJA}n(6V;DW{1rUr@cNBbAR`2jXb(;=C3B()t|L$PWvWJzy7A-cJf>GAE&?NoHypn
z<z4A^!hG>=xgWNVs>@%>eSNd(@K0ym57zDFm+zgd_0VfPcO*pY*TdI~Z~tui@c!D)
zm@k`ePJ5I)OW(|9jhgX_xj{>rt3)?eWNW>UYEXFFzSCD%>d^PAcMjb-UF3DPLFd5k
z*MdGmRYpP<TUKbLPTvy4-~8pJlK7f3rS@~?O2$cZL<JU`+?%nkEqi`U&7&MCk&@Hr
zEw=Jacm1-mZ&Osw>$AqwHpguaPg3@%ta(>(qLq8MPllc1H{mDd7N=`CmG?!-tv&wd
zCGTd7jn{g$nw}a?IP%Qr+`*D-e|7t2{J*s`cH;VOZ@ViB%OA!(d!^d%7%M+FZ;sA?
zhL`80ALp`jWqrME)h&5_yWR1bCch&8g<Wb|d1}co?w8edTc7X#5qO*V#rFPL-~5u7
zq%6Lu|KR)_|C&6r*dNXQS1-<uoblytO^89A(3<Lb7v|3wXba5JGh88gEcoj@hE}Jb
zdjdOG#ZC2$w9b;z7Cte*^2X+njb}f{y6*EVj!QGnUU1Q3o)}NI_f*NM!X3s}mKAAL
zr~ZDe+IFFr&GU#dm;BSX!}fW4M|TDVb!}r?cB8?|Z>mJp{pdXx+uAa&UpgN!VFzcr
z(EWP$C2H<oRdNCS&ktRdnC8Rbcarhy9hJRGmt-}Bxf5Rb&nuhNDy*r{r}3b2dxd8>
zyN_t5aLkNNzdJllZ+{M*nX|Nh%Kys`j`7Q}vTcizQ#n`QU%4zcMq$r_)ib7)YF6?8
z@7%qz`eE1E6Gz*o9||=R?I}ICU~%FV&9*t^FILta`^B)7Ykk=5v?ArC-)X8bwr0sK
zA2v_k^k_AQ__}9$a^}{%9!2`>cQgx`&iE(X_E~jdr$p?o_*W4ooBfVFjJ@!^DLil9
zk+tzlQtc1R7a!RDa=%dS!MFf7{i{yK?h|b*zwu3fvwhawnhw{JX*)Q%ZXVwE@Vhg|
z{yV%v?pYHbzjeE}^}VIqKbgmso{NOv{fX^0JoDhAbFk7y8~sDv9H(8K+c{?y&+Rc<
zcJ&3L@>=%I8Jp(!wDhwk^(%Nq9Q?feO)2-4fGKCVJ16Xl@LVl_WS+y?CWfs?x4&;$
znP!u(950d;ugj}1dN2C(JNsAmlP9#gWts$kIVfejY)44$<VBB!wtf4w{HdiQOPle*
zmyfQPIKS9fGUJ5YvngMdDsH%1>=0d9^F-Wt!@G{9E0(VblWx<Fna(Y1VVjiW5Z17^
zwzy&Ih8^DmxuQO(Z_Ut{C%I(W#k}WJ@=JVl|7dQV^wT_e3h&iR(`V10<NQSIeXK+C
zuYZi2ck%s^<rk4#X|!So&)fAOngSV2(hEdx74$hRUldW?mno#Kf370A<w*;((5_R-
z&#P}bRvR4BKhJBsa@!jhA<uIzeb4r_%qSIU+ShcB>$>u-EAK>>%zXabFYi&2o1w+d
z&W1<wmt?x#{u~zldFe*#mFGuxSLCthFMJbKe@E<+ji3sv-}{zBJM->l_jQLKiO%Jg
z>D98gS>UDEWhs`w?M%L<V`*IFi$mrgQ%V^Nf)-8r9cwb>a$1bt-2KI$?`4`jeYEh-
z{KEH@u4&w_7RFhY*m)h*58m^kt?OjO^rJqj%JZ+5CpKL3o~OR>Lfo7K!RH)$j$8?P
zm6QMXW%#+44^hQTt4tU+pI&pLK-};+@5U|jFLTGr6!~3HdOc;zd0|h<yv4n;H?vpX
z5)gI&!sZ^TuIc`0<E)y!NeBLAygX7Hu66v<wh0ljyA%!?l-%}Bb;#%Q-pu(fS^2&C
z=H=XV>(nO+S?}4LwCQTp{BEgS3&S%-bA(iyN-KKJroQUzb%=<YY?8e21ZQ)?QP234
zwEqqBI1bIpIx7>y#`^2ynTBN+9Z8$dFMK~yBw(VQLD}M($anI;cBoe89evc1W4lQw
zEB?3U%KR65rh6WG6zfs7;@`&`ZzjGq+i3rJfsmlJkQd*35372Ml9c%w?986EyC;8n
z_gKC8(4x$a>n&}W9~*alH#1N^p{H}dv+(JR8@9JQ=B52s72<HJ^h%7pyJZiv-1O&%
zJ9-j@=d2T~+5ORahd^mNQ_K0RnY>d<R|GuRJm-Z>`;1pnk-T|^Gc=#JRTl*(-SEHj
z>MYlEAL+yDKRes&18Png{=2y#>g|Vh3kBo_FI}1D*tOD>(`=)Lx}fJPMUjskPo9PL
z+`0O0`6{j8nL27GPu|{kUMu7(bF1~PeaG&Kdfo8u4((vF{k&mW&5>^>Zi}TRKF}8y
zp7W9;`&#P5$t<g;rX}}nIVv%&EqUAY_o54YFFubxX8S-RO7&}F>CZT~hMRl0pVH!u
zU*j(I`;YU2NuQ_n@7%+oF+)nFpm|F8niuJZ#6B=^o#U?DWM#CqTRdFa<obWdSCJS0
ztjhdntu|}9G0T0|sIx}7Sxno{zqXpAT$JnIx~G4|x&F@*W<8C%lFz+mp8lJt^IC9|
zxz`$oBZpRK`nVhxI(L4~n_a38bC%4T@+5KowX<J2WZR~%eDg}CF=VIz<5cBEPg39U
zopL%I_VngF54T-*L7OsO*|lsvt;Oo+o3+hm`YYBV{poX>8su)g=_qSrR^|x4FY!R2
zc4O?N@8NE9)=bHEnB%i@Q>64)?;X!lbk2P-xU%JDss8ROQk%Dan3nY^fN$=}6zTpJ
z#Z!CaKO2j5^iE7M+{hF2ty!b9*Z!}eYh;L^)P0`k@0Q1`KJf0l$vWGVi(4euyuKc%
zIyd;n+vx`?YMOa7_EcU{vWzNqHTBZcUT@vW6C<&^$UJ|RwF;NP2k*yK|GeHU6X@!Q
zP1m``)U2nO9Mxnfb7z0%KgNrVqJFg>mKn^jiJl^@`Mz1R>7f6PnfEU2tbY3HsWtcN
ziHkYiw=ely>v(^kC}Z)t*TxOvHQ$!VZ0vho`tHtl>m_AjW_d>+d8}WTI{mZp5wRjY
z&-;;6w#Q7k^(oNF(MkU5m-anJ)}7e>^5x0&Bb9&8DldBP^~dCXML=@SjkfULGv8~4
z|CRAP>V03U$^CZc>y0+tQxp^}>Nxfm`K{Vn9b6~s*?%xN-j8)^wr5U663;0!-OKfk
zQ73;tkY||x<;4#5giA(i-f!^O`fiQ_OXrPW-?}ot3Y5vQwtqjXJ9A$}>fOiU3w&2^
zuza{T=i<w=z3Jktkv1yM^E)5=>{-XSXJ_tR?fj`H1T$o~G+Td^)!t~UwJwqPbWhMc
z`1_qrZ9Vd(*Y_Uw)YMkn*tF(yR%*+#ierhk+$R!qJ*Kr>;oijkqaw=c)nOJ!$G-U|
z6hqk;EID2>;hR8`f&QOQMFAf-1gw5^Pr5qq!k(#@zBOJ+<oWeUZASLLSLx3_ez+d~
z%l7_>ECKnr+D&UyOPBM0U1pwMlc8HzG-=wF$WJ$)KX?@VM@+)BFi+7xsOgfJvhc}x
zMd@B)<9{y|*IOOmuO`_4e|5?Z$)A!ZeOQy?#iAmPv;S;4p;!F>tK-$+7l&O<BkP!s
z<@baX<tk<Dm?Dz9>lH`9dYf3i&U+mDP4_zLaxb>6`MT%U3Z?!z^A0EMI9qM(nE7L=
z+>x(K7hQevWXsRuq&($27ah;tJ~m}T!-=&=*Ph$^Y~CN6DHr?aC(K+hDbMxUY;o5^
zEYl-}_nhPDbmji4V7z+2>5=%QyZPq+e=yDDPJ-{YDwk<p(fgy)Lg$npy}4E3$sY@q
zqHCtYOgH_LGn_nczUDeC>Mvj5f11(Yz4O|O#(8R6%wzX-w|>v?UH)8#L)dIG|DB35
zdBIOrX%edrE2!RzXqwl!anqGohwt9VQ0O_3^X2rcS$c=0{<Ivsw8buT=P|E)GiM9d
zTJvhY3)lJRcIm~6*@yj_pXR7MUHGz<g>7c8@tReS3Vzf*(_1CX+N;q$ZE{~q_V3~+
zXXC2m8+xps7Al^7?i;i_-K{Uk^$Wie*JiEW>&oBmyM|rtd0bpRi^bnuCs*&@uDz3<
zJ-#8THnZoHr9nyE8^y8(X~%AIh**E&2wAgpX=0L|{8H7~J6G^s`|k8`<Bk4zz6TG)
z^Df*`zt4W*k*k6MI}_zaV$#aAf<;$tJ}+DxTkElY$p`zS2gyRuyUm<-shzd*oMXgW
z@pAFK+F9o+FCSY{b^URB{*w<!o9~_Q%6Y}wwB+~m!r=1HD|4rvko}lv^?b7k|D{JA
zN0z+IjqOw0QvLSzrb9QTPkSHD5z8tbzh^>*U(&X_`W8EP?ef%<n#IW1H045g;HyIW
zLpK$k$L<fT6IAq%3bQy;+Q9$IN%8z=W6k3`L<O&QozHpCy(@0#LY7sPo;i)l0nZ+u
zHe_3ED!E+g{UiZho)<<pcWL{Yna?<9lg>I**}b4mKybZOapdk9EAR9;{JMQDy_-Ye
zV%fZNjb@F-Q!?kykx1Q=q};A^`pn}}-;15+_vtV9y~=6B7j}qeg4LZJ9q#k87p}5Z
zb4iqYruv9a|CzPo-b3x`+c)iQ+pc%O)aBUuUG^R`&4f<c)fgH_FiE^WA}gHkm>nUo
zbk+X6FP_<RRSK^2sK?H(OxxplQ=QxHWut#uhM&LTt;SQ0_c$ibeU{Yua}}@lvN=Yk
z*F)wNNF@HRQt4vQJEHZdGNiu#r+fShOMZ>Yc%8g=$1jDM7b<TL=HV>pc;Da<mbB)`
zJB!61cWyE)tMUvsKje7z_qO89bI*PM-V+MB{p+Ch1Iu)8ae06J6_?N6e*NmeVHL->
zV%jsU!W=n+TFTolD4s0)A$9SB)yjv*cODGWKlSkGkuT5Bw>(q!47k5(f3K*p@y^%_
zfv2Nl4woO;HPL<V*}qTXw&k4uCtK+($o<ln`&_2#r7d4~O(_*W)PAc$a(>CCqnCXz
z%JVF__%mp2<#F@ZtPXh!TBeF=bA;CZzUZ{u&zxgct*P9<865J3CK_3d%E#PyNfx)?
zIe-2ClRMv?IIEszGaW7RP%E5vZ+dpW)0Ih!{sh@1KECAXKKH7yPvqj9wga{^6g?*#
zf1Nzv^7s4mNpHnEFS6twHCvVwwQA$;qt3k7<9k$(ue}xaXG_QlIj&i!ZZEE{IJG_g
zVBM9+HIXj^6ZC5rZ~rNGK)rmX!po49{JCp3<vTsLOuxMH<f?!z2??JpLUa7~2(RJ}
z(LV5RS=a9LlZB_tR$e%{Hv8r(U8ANafeRhqNh%-sETOyct*-l3qd5nk9BGqrJ9Xu{
zLe(awPzjqNW|`@Mn^rw?*zP87;l1(qzpJG|fuWvt^U_yuyrg?P;MLvMz&)R>3Keq;
z`X6)@FXb}%687elrnb{#-_?H48uqt*6nBec-<ETsHs@3k|CY)#T0d1f1HBvmoiRG~
zSk&o2rjhEm?*%EhIYRGrc>U{&n6CVN(OWJ4P}e`t%YCdoABM@VYvSTtTRrFb^*<LK
zJ<S?r8mwdAG}!Gslz)}!N37@D+n+8s$36YLCQws7pkeKqqg^+1PHFAuxM`I1=ghOK
zo_yQyh3J(3+-@x5f7EsttMI|~%)7KdsJ*Y+Y0A6r);Yxu&ILkKHb2PJSskJ@Rgk~v
z;>vcR>RX3e`o+)q{Fu1*tVhX%*qc1!tmoxcESskh{&YK^z`+h3KHas89M68xT$`*n
zXVWSl5!uDJC$oL<dlUJItE{puebKh}tO}ua@vD+djvc+``}^HV8J@s3OYQ`<*UBy7
zSZvvGq+s@?O@0dxh$pJPD>P8MQMh5<znyYSj+@tdO({@(6Wyj5+~P2)Tx0Kv^tqL9
ztoR<MMC|%|>7wxVl0I>se+<h`zgTawr0a#soAg&QF)DKJ4xN0o++Hy`yjN1#Fz%D^
z?nkYScC0u10`%W4{Mxsm%g5;3tGP?ku2n?N-+ihiz~;@|FWj{%Z|i!u*r;VzKkC`?
zF6_Px)2T;MleOwrmD?T3xo+dU{HJ36%nb_eiFZEPz3w@f@%T_^R%m$olLbCe3%9x)
z^7v*w{if$1pZj%Z*G<?lHAhVS@6UODJ70S%y)S$_J?+Bo-1up87)4)~e%{q&nZe8S
zyY}#8g*j`(tXBNwGHdOPt7#3Ei2T)|@1<6>+wW!Tk{|qgKYs80az{~3Bi!=N4}&m?
z%Da`1c9`C)nH0mRY_nT%>HWi^CeP<QzBlW`X^}}QjX#}hkDu7ZzS`G5>D<0Ibt`0~
z#qG6@&hpv5myg?U#`_wD<ucXlZ?t?|`JR1l|K^NOGfK7MolSacA~vh?cKUpNJyUJZ
zk9T?IMh{=cdP(~BG%wO%{v@|KJ)}ikZ>8KfHJ#Oo4!m95uga}X9_1^1&Nq2$Qk8e%
z%VuL2wd891%3>A?Cxx{<zY-o9&AEPke)%a?b4Jb1ol*L=eJ`@-+|t<a^kr5?XZ+Fo
zktwz}dY?%o+dp;j{klE1;hfg#3oh-=M`X9BpIsUj^K07srF$e>SASI4yI*TxK;+aX
zyM@=i2uuH*cS?1Zb<4N1BCQ(TbvqOq@?}i=YE-!73%_|D<=;~2b;xPY1*7Wy*Qbd6
ze6aXrp{do}rHYoRW^3mBo${#Tz?Fxe7lf)=#4yHtPFJjta0{6mm-6+%c`MD6m)oz-
zbA0hcwquTtgw%`sZogeSgC$pP>}=U&wC)3=vZ=$D6J^tss~>2$^omYxTykWC(;c$}
zr~2b7n4`E49%wox<sm)o*1uKjyk?m7WwyU@tlDz6rgyf?*~9xE{@rY%#BF!0OJ)0|
zRf-opj0~#sMFR6aZ9C`TymQ*dO{Z&)T7@p(|MCR$wPlRAAO0(NyRNAI<EDM=s}F82
z?NvR(p0Ojp?xdzj_s=R9&WZOu-qq@N6{<yN&3VleBI*3OJ@(kME#Lf0Pg!o`&5l1`
zEz{J#X`|7TOCCWrHe#>dJnT|iwEtPO8tZf6jXGX4xyw%`nMu7$X}P>gX+2BkMHeY$
zpRY*=0%Zy&?|=13H`-=4r|Z^NTdt&9xu2D3ba!i)Ry3)eEOnuG;mcIlxQD-6T}vel
zH($zgESD--EwFEv729l|E4Kyj%YTdd=VhV3(n);#uhQyo;ak=neeCbs)Dst7;%fb|
zb6&>W6F#3=_7*R>SaM0g%-^Ma9jiwCgX>eC#?E**f2-@`Z{czITP&Uy`4=_(x!3wN
z>6W1O6ZW_Fc=Oh@@VM-1$yyUGvA{T3YWwQDfBw`ciG;t`+_PRX_-<)M43E_(TeEkH
z5zeV!L*;z8n@HaeO7UbmSXpRP@ipXh$T6P%U#}(1;;P>GB<AnR7YfhY<kw`U$8^;l
z^V;5bzpk-khPz$vWa(5px5YlP8^he*1z%5?>=LY1wDFFga>mZjnNy#$p18B-$CNnB
zZ+~h<lzT6ENFB3Z|4%*HX0><nSD*HMQv{}e`TOGMysz4}67|cM3w1223yQpNH1BWr
zk4pvjP93k{on7U5jjOS)dZKHmosx~)uZ9^~JpBJ(oj#_YKTFs8<247CdmPVNg^&9;
z%5R+!o;Sa>^y|J$#g{*<kDvI<P5qN~E6;>2xA|W`wd0q2T(Rf0MXp51nVYt6q+SU8
zKhybR#j$%E{5?!mmL1%^^74iY!iyY#9}<h{ny6=Janp10^{wqyyL0Wgxy|$H+$@$O
zbY1%0l!)Neix1~Cn1@a{F1|{0s`=cjqHUk!qUYJE9e3OGHllx<a3JTlr?00iEjsl@
z&wSmi`ST|y*a{ZRkMO^i61!A--`rfEUvGOB-^sYlX|+A*-s!_HkF7ZJ+C%imyTfks
z+djFTzs-GpOA7BqwX?p_J(Vk-mx)MnyGZ_MmI`dtN!w`N|8^e3-Ga+^<`}qM<2Br$
zxT^5lY4KGJAr=hlFT}jLyVmX5jpqzX(=Y#dovFaVQa?HInAPHa(h}k`C(WL8d)7h2
zf|J{>?7aOg=u7c~uAhZ>86IzbvbmT=eE9?h&g%jWDuEBI9A>(3PV-yIek1W>U-&z|
zg(=qlC!ezR*Swcp{UT&d{>{0@`nG4}|JP|MYid-uR-`RzNmqOk!I#pU@aoc|O&4b$
z7CrykC`dAkr@Syz?YwQ(%ZC;+C9}R>{2I91>HwSaBo6f#!d|mpW^`|o`f^<Pr@>UM
z9s@R=?zhKI*6l4#vg`Z)V(HWSH|lQ8e|adsb;qV?<NSn~kKRdFoPTn61NW7KD(bUU
zW^|wAI+?!guJolEKZla<Z(VzB=B-cue9N@Qa>mx)mfsaJ<{LH{vYzyBnqIo?dWj6v
z;rB&v*UV3Fy>~!f@Y65VXL~do4q7dXubptxXo;(})(^L}cYXe+E7o$$KXeM-S<t5P
z?#E{TApK^qFULI1_X$ZIvoZZD++E}^&Fga8&eVRQ`nBb+m>MOe@3>Fixa-?a8P@sz
zS7+9B&bXd(t!}1i=v~Ko&zF7CU$L#{g8a(c5?p<6UL3mUR$>1uz4~(o%PiGD4%}0|
ziGQ+_5G%gr<r(~qZQX{sF#_2c=elhwPn=BR5y{j38Q#`C>DVpt`;jj*^3PT*SZy)Y
zKezPS?oZQ2I~d;E9P*Q5h~6#a%a)?k`NsG{?4#hL-})TZth%<nd&=dIN(Ld$iF+K4
z_nusuWR;|^y^=TRMpdM*(*7HZqn@tUSvE<*Uo>N3y6@uIb0pZzUpR@{3)Xe53@|zM
zx`$ci`#X_4A3E0c$=A)8_H63<qMSH&v9)G$0)=wZ1^lA^HFTaiJWcj$oj~NFhkS1|
zF1c65cV&MNm0;OE(?Z^^*KGai;!}OzKb$`m2yz|r(b%$QvqNlbNJ{+=p3PR;e75Jd
zM(b%$a-Xd(8CHMzY*UAw#y{iBs|tJU{h0gThRytV+{*1D%k-iudA@sd4(B@@pT@s|
zL+0=`!Q+>nK9!tg_vUWX*(Ny`HyiDwmnKiAvpE^m$h%G0!Nkv?te9uuwPu%Lzns+D
zz_TY*4nC4ywCcLxCXpF#J3FJk^BwuOH_<;pu`;8|Vq#Rs^Nr%+ja!UjLl5zP+oB><
z*Zb{HZcSWaNV-9i@ZF}8?w(W~mYagbQWvb<wF@4f{!vrrY`uH_DdD3{vr_a8?7S5-
z>n`jo{p%2+UR<ozZ@peE;_?!YDLbbN2b@pp(x0(7eg8@xr^kC&pJ`LKy!<L;PlaQ1
z-}g<b7wfr}yg1hSyXi`s?<~fpzFzn2Qa6gn1-0%uE*M;^7UT0fOZu^`r+A*%qub){
zk1gN6J$~e9gy3VbXU7!poGrMg?%p*!e1lk9#GX^mcVntoZ=Jcci&vl~PtW<(3B&a@
z`zu!m9h<Oh`N`t8T}IcZKWpFH?{ReZnz-8wUZpEeGnq2MaTQ<Uy3W=+g$LC%CGHh0
zzap1%b6)4&bZ?hXOTpc@S!=zW<L$#9WbZQES3g&5|D{iFq}Ld7E5sk|xU~0<#X99J
zm6MNr2u%L{?%bOH(QA5@s~Z>>-(S0{we`A%><4d$Y7L`YT@S~1GM89cgS6+Uns_`d
z(El7OkY|$msY`fT1INbe+EyZ5JEIRhpEP%3|J?1&P0xgn*cwc-^L_obpypLej!d&o
zO`f&LuUxs5h-I5DFzUz`)txX3zcuyEuDvSuyH1JL7jrxJ#4E+mcATO+L&q*at}x<|
z(4_R1^5xgcuE=j$yvlLb>EBZpe>r+&|A82%FgE{NQ+KM{{@h#gaKc0lPti{4i#Bi1
zZVHONv3JS7yVVnyc6|Ec7cK15A{xotx#94Gi`$m{bM&ua*4r+;iv8o2TeIaCO!(TI
z!I{5B+cJ4c+rHf&JNezTnuM*ZCixt?Dp)XG;)(DT*-xvAp8Pred*1Zk&_g>W3%9JQ
zdBwhhohh=`CZoLj2lu1-syy6No*cEP*m+mTiI1<=KKimCPwIm@_d8WgcRCcW&Ef6Z
z>7gR9R(>B_jeVo4vm&o@;*?jPAN~kictcF&@}n&}2^ss3Yj1kCX`hMFt)+F&KQ~C1
zvmPlu^R39`n&HWpxoZ|b6q;hOrA#lAtNjC0=84T=Pj}9GzrSVET`dcBy{(apeYbwO
zrOcaQtNif#i31xqAJkdo^XQ|2s!ws%#ua?e>hewqYWG&$oauCPzmTZwG5=pWVb=@J
zpPhAPDv!kO!kq@uH+}tev}CgOzWsbd<dcfUs>>H;Pa8itw#9N@#qscCtt#6rt1iCp
zU=m!hC+hYzzKe#w3y#b%H}Z}>t>hY)?&Yt#(c;v3^Ir!)PhKhT)u_bo*=)a4B{k>m
z9){RWIv35zQglw^+?(%Nn#W#vPIbDRf5~@-t_RP~z-Kq6*qmG^a8A+8qJCTT&QP1$
zyyp7DGINB^>WWzWIQ8&>Np*(Hv@Lc{A$^T=PyaqM|N4Xm$!XdgT^AljoBDC3NyS+9
zyfhB}(w?@t;E?sCyXv-&<mEV>woW~=XG;6oB~|OPJHIJ3E|g*V9v7Hr6MV!rrGBMD
z^=F2!d*=PzYm*)#cWcqvD^E;0Wjoup|D3t-?5cO$q|;AZAKbM{<o%be?96M}KY!VC
zK0chyqQ&Rq$?r~Ef&zAVJDpRJ{I}=T2kqE3#rcXi^5n$p_p%)q*IyU<n9XsniJs<7
zlf!m@Q>>e{4W$;m7MP}=w!MAp4uOCMWxpGT&aYV;`|#@4PU|_ZQ!?&UY4ArJJQn`c
zJznzd?TZ^D6o3DmG-=kXIVN}3x-PHEvNBNYstB9Eef2H&WCk0j<TvYjQVXND*BJ{O
zeZ=~BS8~&*uVF`A_Z5i=8aAFWls#Pdr1kp6+HFn^Mp0@Zz4JKBt}AQKH|UzMT<zE6
z53;J?!X@L*Sn+UZhKFyR{$`54>5Nyue!6T-HVv9no)Y<aP5Ug36?``hkH%}=)qk^9
zCse@e^NuHi9jn(kbf|2rx-ez6pz?*Y>nD^HCJAKhwa^xNG&^N#{Kd}I1`jgATlu!u
zbN*Q*@y;(>?9!`^KW;5@VL6?nxcmL@!yUhjeSU}Aa~ykL`E*V?i?2n&CwtM^Oa0F&
znu=|)nY2gk&zmXsAKsm~m%k>Q<3`v1J;^UkmzrNP_^q(qMNcY#M<+ky?BN=FHD5l_
z0~a1Rh%UUX#Q4vB<K-jCyqW5$%NO$-^Ec>SZ0mo`cGi2_--(A;obC>P;buAcMe38u
z#>cfps;5^v@~Us=u#L+Jzqhh4yyJ?k(7BwMx3+Gy-q>Ssv@G3AWJ{XX>qVB^x9df3
zUZ`<j?0d-y!v}{;x<6Pb=D5e*o6C6U-1b;DTa8UeRxxKBmi4+mk>UFWWn(>E`;Adk
zR=CS^<ed0ceR2B*DTk>`rVF0%t!d}Evgw`8zm1ty=Z^l1o%~(UXVND|xwK5(=C9pN
zt5Pp^#?~k<`t|*HjB0dKq0ADKxThY1`Fc+m8fPZWVXC{7ti~GLBf0ub_Olz;pY(G`
zi7c|SbbU0t|LC5FA13_x5a{ms@bo(M_Sw>9XE=n!R6+!=_Dh91P5pcAgI>=h#_hsW
z=BK+#uW@(2ub3M3!te6Kr*{jJ?N^E@I34Vnno^$n&Tzu3D=$9o;$Jm6=Ix?~;fE!!
zM5ek`E6f$Sd@t>AD=(kw-6|gI_`Lm3E-$mbzoYa_<w37CA7j=ZI9YqJZhC=K{9g;!
z+x~VdOy&2yKcU)dIDbyUoeMAQ{?16}dh|W(a<kzDUDb^Ti?Y)?8We24?>7xSdNP?w
zE$GYk`BFk_m0q3|FD;V)8tt=;RU-fL_V?Dm)(h#aloVPlQN*Uba$<BW_XXiDE0u~{
zPDh@7$<$ALo&3@3(8B^Lzl(e8nUC79`cdcEb0%}6=j&aoTe@pQ-Kvc^FHep5DWIS;
z>GHl~-=ZS5pPyPJ{WG>n_q%}J7vAH)H?s*n^0pIsl{9nJ^Yz<bm2$GpFnMgO7!Y<e
zVAqVg)-^?wS0%FUIFY|zWNWi=>W4LUEkCZ8t6r>~oAUkL+{aDnfvmrz?iZ%%#Lr%w
zbMRi@1)pO_YQr7AT|HY}eSdPYw8rnpUOU%5xpDmD>PceHXDwWvT(YbGcwh46%5%aW
zCqFtL>NjV@!+w<ux37m7G@9n;rt#d)$a)=EcxU(0^%}pOdF_=$s`v{2ZE<q`QT3<v
z2+u~Pw|}qkIo70cX%uKyeRw|8V!cw{`f`=n!gsG8h{qrFk7M1meC7NFH&)imeVj8(
zTd%&%_q+<vgIV+cs%)(dTa(RZ`{u<n)z6Ysg%5N@C~?$&dAsWL(gnpjy?STTCX~OK
zm!!pXQgF*g&Zu~QcFlVx_fxM19+~7C`j4Y}PVAcHuPQffV^Wb%I=F1(xmWrZ<lJ(0
zmmi$9e_ee5=cH85%)aw_)h{;HJhQzKer|Qj7fA*4=zXf!zsogU+S_lH;q&i}=9`P_
zthe8kJf+X|-$TIr#3G&OyS}gYo$xw7OZ19u{iga`jWy|pn-_%6+b{k#?ov~d-D0;h
zla@c4P^Uj@MW$*XL(r?VpJp+8mD(zNnyd<XD~f_oZi?GFx%-05EHSIKZ*B<uejt5H
zZgH#Dr9vkjo5yUtbwTqBa(UPypBi<yvgY0Nf6>rY^ZEArN6PP$wyQDkFY1*_IbSn#
zTGsQ+MiVrAH!a^|E*2d6dXdi4*`B8(*gN;>7Ej7QVO#LfOVy`AMQhbQmkEAm7SmRy
z)GtcXOLTs8L;O`_s)qHvKJAbr7ZjZz7z*s{-4Jl+a)i9-??MT`JC!=061NI!7Z>mF
z49JL^ye6T0-{B?gF-<plZckn*BECH1f8+E^ng9Lj`_&))sor^2eM<DqO}kF+*b#6f
z?E6`T!-AG}TjP$Uv;Nj<zBt9D>9^9Yhu_|A`MGoB8LjxdpQih>&rZ70afRvUOJnZ(
zNY7F!fzz_-@2wA7NUpiLzEoRG;9RD+=a!X^J^m<V>~LN6VVCQN*7Gf5i!50feeM~X
zowOI>d0Vw%Y0rYwP2Mkl>^)LE=bt}=p7O;zd7%t5?=_e2OJP{jWO1R%t9Mhp8q=Gy
zqwF@0znzw~^8{=@9&v-Y_|U>j_j3D|O*&X36S7}H&z?u<t9{J>w6G87=6qETjx}Dn
z|5mN{=CBzNod+d#*UBFb->0B(uE{M(B5_yGpXEElF6>(|rMG5H%<Utb{BI%_*#$_)
z#Ocfq-Yt2=-B-k3^2+B0#`h|wMCYy-&t!JUkr$Fq3{E?|x9mylgNOGt8Me4=eW7y4
zulq80$nx!SDha1-9@GX&c>C_qkX`9vEOIW`|FHGyS8e%%=a#44Vu=>$Tyb?1W6*?>
zSNCQ+EwfFMTxaz>cq%gs_mtYxZQ7ArUJ71Vqt*JmV1+_V!%drlHvMa*AKeAHl2kgR
z_RpF#=cv(FpSUw8XYVWfX!643hHK;h=kso`Pm}&7qE~*=jD3$`xs8@n+|{y+uCHG(
zHTpH}fBVQI;k@MZL(w*`BP*gK7UivON)WF$wN?=hJ3d#w+B%tswffwn&5TDoZrFsq
zdAu(?GJ49zHqMBJwa0j8h&X3<Ys^#9jQkmR?_z-KVb|taA7odTzPTB_Yx-N)pZ^M3
znw`tzzWsVWk9Tg$o;!E-l(kEmUl|Im&v#V*sd2=}WZh=tro%^t4#%vI*&kxyBfEJ+
zsq;%GkzbM_?rV0a{mfjoSZaClO;@wE?)JxAh1IUvhAfkMVk^rq^;xf=iMdL2+rH$>
z$}(39p4-gzy%yVf|IgC4)vrIqh<{w6nsH(AWzo3~-%q5jHC}dM@$U2s9+q*_g6-4Q
zmf5N|p7%6zd$T0NbKkA?Du+(I7vj5aF}ruZki?`0{YU=GOr|vC1r;q>r}xw~zCn1K
z#i81ByLGo-3*58(&CDBe^~WOHSI7K_k-f<Ce80revPnyix%%gvo!{Ik{rjb&+Zz7J
zH@h`wyIs8_8Ybe~`|#V}?+UV^u0Q)jr@A<tu3?#aURu;>`<$d@T_MwVMa&4^bys@U
zFUdK3PU<@v-B#b2vvlFN<1bnNFt$a;uVLX1oML7l)bYD4@+hZG$x`{Xi=K+K9aDN^
zZ2t7Oe^E%coLtlgYnJtAC-(9h?wxhSx7p>%`L2Qlzr3`Bn(J#suB`7onI`-*e?p%8
zxm|MwSf|d@?uu)Oa(Z$muk*>KIjUhDms4_^j4pRq*#2ueWU%?HUC6B%rYV0tFWI`P
zahMt{>)WvKlcnk=(_gFJ7dFW_bv_h6DtubGTB52tB>1<b>5uii>n49u=H*)TxNz%^
z<!dYs+n#8hx+v#Q#?p>ge`j9vcUqYCf0g#$%TLOtg#8V@oaj1n{r1IPZ?$|Y*!Fsz
zsOL?XcH*9;!;*`&$3zs(k9L20*7a)VmhQkUA*r!hPJsnmJioBq@D5+KZ(U)NUP$=j
z!Zii;Z-2bHFQV*pkoAmm^yaPlS8jj1R;u)<c#HEo<<=>J*#VnsE_0+5U*}=HSI{)a
z+;iot#D-t#KI$rWGRw=DPCoeaB;$bdqR-dX=&^jfd%A)t?}?(Vmu5inqqi+fV;6ou
zDcDglHP4p&yWJ%@kBp#=ZCTg+wr@DRG_v}sQ`(%*IX@5XV(-wCe0S);QMX5FitSze
z?6ur%Vz#kGg>BYHyjb0WYZ)G_VEGbd6LPiqMbfw9TLQ#{KYsE{J-e7cU*OlxlI#mR
z7w7ItekgcKvfCkD$m?kHPUn-WHs{WD53qZtudn&;!7qFB?Mx~gL~otAcc1wrgJt#Q
zjY)lK^4d%nOwM`;F6^GaGw9=^WSQ-2R%ZWeQ&ijPaQ3`YV36Ki#+i;{>1xkr@XIT`
z^!n-k*<(W{YqyN>eXi6$CR1mH7+*Gj@zp-FVTO3~sdu&}TnwwVp5~dI%K3bUHC$d|
z>04FlfSx!O-_QGQt@taoB}!)7MCME9-tw<|b1pXAQ0Ul+nzU(`|Fchuol{^U<l7l_
zB5Ci8%ex~#HSY2FkbN>Z@IiBu>P06Pj?GG!?@e069eU92>3J5JqemQi`~xq==^fqk
z<3!usO9y`V)V@2<_HARw=C5z})Xxo;J|)@b^2g2O%ae;+qv{_eE%)@k>tL)hVd3J!
zrSd6fk33lJ5;I?lVfPKi#vKRuaz($hFD(DQ;{Brj6A=$}9(1j<_$#0r`&1)&;pHp)
zSs44<Pv3}};yc;q#^<A2?g=|N4pyFX`<$_Iu^!)!<U?WKqO@+fG@HdA5=`8xeCW%r
zoF|31GWI<-ncYw{wY<1m-9o?CZg$*^w>B3X(k2!#-c!5P*!WXBd)@1Xg%c)!P^n)p
zx+P_E-18c>+$Gju3%9i_GJ3c0&zrfr&x%^pdlIJ@Zd-7!_+j47%d6iXZ<rloQt;)@
z0>%yE$Gue6$4+@^w>QTt(m?sbiAlBP8|SmdPw_ruBEPq(*zJMZyw~eY4ipDV_nHQt
zyJ_C~UE#^SsId57vGqy6jn3v8HE`{<i;`_?>!0&y>YuKDIhoGM=VyKCmHPI0SJL)L
zmyYJdcpZz<X{$B4X*^Tm@yTZw{lj;x7jWKqZ{c1;v$a=E_$4pqS+kX~TgzDbTRZj`
zU6;!+b6aB+t2F=f-$T8Utp97gG?x67j&itZapX<l;eW55Z(P}ZS5`uF-HnI}hA(*)
z_Wi5&erEUQkF<PKzH|M_Jrj@i7WgKc*tckuK7ISuNZD*hE3?V3;s#lzMM9ZO$M0C#
ziE9;ps_dxpZ@Z>bW4vY^b40@-wy;^3J&mPVw=9-BkY^jQC~WTinmmT1dh-Ntlo&|p
z%rv`mzeD}jolf<ok%@9sHIF7pie}zt3EXgBX?x(G)sAYJF0UpVGBa1{i(I>WU~lpT
z**V7>52-8>-ZE`>&O<Gq<u3blGdHB{-u80p2`O2%z)Q9@ZucK8Y?9daZ*8HBa6@3<
zjP*yBUO%|uiTo8SUFE}z@2GE94{CIE{FiLtagZrPWK~_q3Pt-9KHr$Gb(9}&Dg3;m
z{!8N2RR?P4W>^Q+Cf|;z-d~X#qc-zy*Lm9yM$R(}o;vP7;Xbv=FhFK??&>>wC%?!m
z7b`4NIPCn;>VLp5#YaIxbyI#@ZE5SBn|((6CeyUz&*!bXH#bV{?g{hx2OreV37NIr
z?Ekc5|4P(%Y&!O9_Nj#>w<phiCHpGpwc)nuQ47|lKHgCtu)kIGuzS_U=o1+Q>`G0E
zyNyfjvJP>X3ZIo|kIXwM{y<?mgW^`vit~#fnrfZoV$_<V@{Uh&x#!Nz>{)56H?@B@
z>|7@xr@+E=V%4nKXYUvGzfA6CFu7e8!EcbFc-Nt~xYxeQCRMGyN&3`-11Z;TpSl^`
zw(Qi#<_B><Kc~De-4fFyRQVxDYMP9wY^yKR4(b106NC2ob+c@qcWn9U9c{b(7JfLJ
z=`VjI%lGKoOLqfTY5UacmAh$_oGVysvEbk3yAD}7TQmEkZNhA4RoPGTyV~cV6A^E|
zDzpCcle~btXB?!v7-qlS^D!$WlWA^w<i5{NcV=8rU)^H4Kud*r<+a6f@+rr@l&+7k
zS-v7FL4)`7+n=h@6=q+1P0w|FmeZ4bvWZzN$KmAD%!TW#XVw>;mv9n(V<8!Ok8A$!
z?7hp@&uMAhAFqAqf|>?{X5IY##}fF|^zsA~-z_-Io02aYWb$}V>{qUGv*f%-27i;3
zTps>9s(vTmrrh(AZbQ)jg2d|)%P#yXJ-6)CXZFz5(}gUh)9$t9z4@j5BR+4k4XdHS
zcX@>^j$GG`npUgMm}{%S%%lHVLiSnTOrs0$zD8QEeR1aSRo(8;^j&Q~>wnyqxi>jI
z`o_hMvldGJ%~$!qe@wZzV`tcDgY*{_Jjc$o)a|V8Q9Hc&oy+r%X;*aqX2olBOVy+w
z{<mZ|7iWY{{N(?e9?w~Q>wt`zyMa8bk9%kQhqWt1^1m4`h&@o`lYE)2b4p8<(dUVL
zHIuT#@9<k}UbiA_c6o>E$r&dyjt7*lO3ARP3@F>!Wz6;RMNeLo=;i&#WbBT`-cSq?
z%PWfu2y@^4IPZpGRMaY|{JU$bvMXMkZ9IAX>wyWbhjtoYJQr-^G@bMEif_i7lvl-M
z$K06{`)s9~Mz+nf=8RC~!%{OBIU2Ms;8+p=FXoANc<ZedU%u~rSugUYIof%nX2|9@
zI?Gl_T<G*{&5z@~m33tPuX*8DY6|8rXIA|9d*fwA&W#UQ!Z?)9vpqZYq-y%D>q{Pq
zufKaU#p$@}L5`WZ4l~=P{JLR&Mv}oZQD^eHb6k;URhrJUxa{kFEB?1@PPdg(o*e7i
zhIM=QEPptWTS4(pz{QuxXP%!p<EZ2Lo#wMuCI4#N>DZS0puSS_@{Yh|oY7mo&qg~{
z9&|YVYQDd)0q2@8-5qQ4>xAa99{A8zlC)^<&B9Apzt|)z{+Yu2Y17(0aqDMKJX<WE
zZ1dLf*O{ijI`TK#=B4x}*&N_}by@QE#DJ1#&u?Cy_Oop210}QS*IVbFFSonYmbtxr
zNn&ByQ=LPV5!q9u?$z~dJ9_!ZeY;D?L;s~(x!P{ce5bT`%dVa2H(z`Unep?I!dZE-
zT=ONtPaDf4Sa0lWu|F8GUhI?l(Zqy_PH7u2spjptoBuBKP)Maolz155M$U}}u0MB4
z7o|zAa^{o{EuUo;*D3Q(#^_a)p6DOeRgLMM{V!v$vgn+5H%jK5CC^(sqdMl*CgJGA
ze<h`K?mA3KS<c0O$N%2?ZB{SXH@2ko9y$5)(%Szig?1)u{evV=d=uM|Clzk2CGu|h
zZi~e_=k~uc<}`Iqmi5rIcz;4Al!a^8gX)I5!u0Fw)mb$@S9lnF+BP#`c28WN*O5G}
z!g*h=2e>>nmp{Dp&BHGhD;#_n?wx<G?zGO-{{FRT-!$e;t~M{&vbFcu4raZ%KGnSu
zZ-P7Iv!;G}He>gRYjc<%o6gT{msP(yWow`LKKn}>Sx<5v?dWL>_cdE{X8tQz)w=Wd
zbJ~S9GoLB`uj+c%_D+pec&pFpowBR`m8{;fH$1YpgfG=`#*ybMtzQOzba?*G=l41u
z*N5|GeiTT)CY9x{&7k`5wrrin<xq}``}tYwPX!tV1Yb!!P@xjuZTmX;l?CU?(tk$w
z0>1-4)=bu7|Gig9>GfK%Rf=1`HO|Vv@;>?h3-2@Uwa$KxKdbcI=iS%5eFfU>l50G~
zP6uvzbw1ehsQH)n=BWFv)xP4s848a}r{8|1`Lgw4J?{#Oq(Az$lOI?(tz9LcEvdfv
z@P(6+Z&uVXZ%*AUWtbIs@KJ#F$zOBqKNagrw`{0CcgUyz*KT8RTd|AkA?H6Ng&Yy}
z-jlx2-`V2iSLO{5S*B0vxtf-4_q6Spf!7koe}CE*FPL`w$mchl8?&ylKbvqY=>Mnu
ztbHA+ZO1vfbpC$ldK+7s(;<}8X0GsIou~ZQTfaB%e5|-iF|>B+eO^t++$~cj8jYtX
zIiK9w5%0Im*zckJc9o5dW<BY~c?Wmu^-pz}S&*xxpBG$Zy01Ip>bAAM3t7Z3#&?Du
zY3z%)eq(9Be2Txr-_#X%KIAaEhDSc@-JRN`_VvA_*(Uv8%U?RQEV14g=G}8>_rChC
zzb{stJ|lEow|HSZ$Lb$-R})VQvh;NK{a*Pkd!LcCCu86%Wu}5zR|{@L{kqlQ^#A+M
zopMV5_pK3q<rigseBKTt9-~k(=JniR5uyxl_XlpVn{i3Ph-(E;==(tB2;V4E4yGUC
z@%wguZ)sY=-nzgl=xVruRbS1Kr^RUs8n&xK&u?lly4=P-amI0fzmPk#bE?axPro!{
z(TOeRAB%?Z_+1KQ47y-zdE9w-7O#%R)NszHXC+;4)o+QL60aAd?Rb3aPv_0ArZ(nR
zsunHW_UHiH-Bg!_k2W{kKJuBW7_;J!{B*^zZJ*^`le_QyaX$XUXJh2+B`&_n@3hM%
zO{|-=QeRB$;Zq*P%LWgk{)YHXy0h(hqUY<UTi#dfs^p42EV){{?*D;{$Im~F(X6TB
zYzeWsz4X{u_P;wPY<fNQ@2j2fH}Hj=@Awcod-df8X9=En&RSRQGny<tGwF*K)8+q1
z1pSiNmsP(O<=i#b^VFqS9f7GF>oc!Qe`7vWFS$PS+dG3zOuVfOd-SF)P?G51>%+5T
z_eX()6EEf8zxUl>A=hq0Zr}9%T(7LXmP`K<Rd3wZ`>Y_m;pu~~KfgSfbu26D)Y7QS
zN2l5Fer4CSI)2~xTZxu|$}ek+t|EQ5gPxn#@lU_v(_~i^^Ft(<Lzr>pp8L9N{F^`I
zDQ<PKe0?gf=ib+qUxnnSHZZ(VNLU&Bd(Q6amEWaZ&&97Y6wy1ZE@Ycm6n{G=#*nMG
zAfUPV8Hd2Nce`Y^@%Uaaeg1Ijs#;#g<6%ipk8GT3sP#$k^OKXIldktloqi`VU-!Wo
zhKNh6%P-qqb`7*L-SMd5fwsnpLot8&yN}O*$RG5&ZU#sGHSXFMi_5=Wc0bZoti`t^
zUFm)Qam~dSrZ=2m<oKw3l;@Fq)U~MNg@61TYhP+OylY(>EbSA&Nq2jl?4n0M^~87a
zD&E`rZ2LD`(HEY~9gWQHx<5K6IhM>1*wLl9Z~t|*=TQbJuU=TN_ojJlh{|MqYP?V6
z#Zy@xpKEnbg_m8}YSnazEk~>EzvXGq&q<vXOzKNCUgTWcSbt1&$xhylYE{h*N^DGK
zX)Zrgr%CzC@0-1}A$RSD6we2j8iaCGlIHA;I6r-9&~bTYqn~k)4qhvrd3Al{bz#Q3
zqr$VE{;WB4S(LS3nrWqrm+Xe_r@IS!w^~Z-f8A}oW)~;(tPtgxb=onni&lKFom&3z
z;WGVB>1pS`{Xd{r;(0`tYtB7w+32r_#Dh5^M731H+632W-nz}nuKxbe`Lw2Pj=j3w
z2e)dw&YHGV_h;9+C4n<TZ37uTc``_fFZogb{d2N-!jH4JKdgAepR_$y>@>^d{>@3%
z$_(%O=bd|OFK2Wo&F^{Plb2<=kA0>d`@Q{WW@JG8v@@?iXQ^g*UJ5Yx*=+oWpR-}x
z+E-s|q>WBEO*!ANVTQs_71IK}x$&Hz!_D#pSjApmU23^MWNuJZasAOC0m-|aJ{H`U
zR+ZVf*}U-bcs%2KZu3qZ_Vz!uF`{>Ga`CJRH$7anVBPi24J+?--hPx=^lpQ-o?ha_
z%b)a&<Ku3<n|Lr-wN-lG#M`ygxOd#?JGJK5d|QpAP3O$QbuY;G3$HM}TKhDlc;;T4
z8H)MW|4oqzdHQnO(jw<ubG+V1?M>gLDlui-mDPN2K4dY^-0l+W_{%%udWE0ym!)ko
zud6@%<*eH`@3s7lbqBnZ9ggfvmDlNdv2f+_8Gpo<EC~Lv(0S)~^~L{68de&IFN&#>
z^qG02PCzEfclH;p{fg^+4gT(W{`hdjG<FsLiqA9NK6xAeZ1U#X<t!g=%v#~PVfBFw
zzJ|}n?6%s$dOR_i-5bq2VrrLOTb<e-)+gwE>gjv2|I4lJZCzT;?V0`P*>f5BL-TCv
zSFZfNectiNON~Y^&)!tn@cq$Y{eZ7hQ*@3Bui4xXX28Vt;^}l1$5{*0`>WpE<39Rk
zx(ENo(8mvUzTnjfI6vn?s8DJ4J-Mo57uOc7JFw67cffp6zl!YZE&rEC>D69ZJ74>(
z-o~#RraN4GbR+tf&7SNHKVR~!PPVK*`R<HG%rYUDYnsRF#k>@Ky;wNZE>^{TTqAGS
z-kSNm_}BrinfkAG7hgZ}@{sy=mXoi{swBPVtalUmXR5Swb@ECpr5SYzdEe_Nx9obm
zUNYw5i?pf@M>qC;%~p7*vodgTUERfwq91W{wrJj*qt10L@y_w{^3q#*q8e3C-M=3$
zlg>SD)`5WL_I>qyTXeUtou+q@ciw{g{CDo9+*-~MHNCa%O{DhBzgK70Nxj^1MWlUg
zR#Gsl^~2thcRvE1ciL?zDOHQp)rhdYRj%8A_|VOBDNNIDON4whJ+y7E3ire0sx!A9
zZ@BlYuD`5bZnE{Z_fi~PUXqdLR(T$8+|A!yJIR$*_tSj7>(er(hi5LRyPO^W?5R+|
zlc}Glym)`Q$TeZn)h4y>tsQ9#U29^0pLf~kxB2Pa<}j%@HZcZopT2T>qPTy1Ou@T*
zOdO{^zQ3W8rh830``p&Jgg(!$8$<5@y&<Cb&ynH&k2u@rUd=YwZm|irk6ujv{mCuE
z>sU^Rw%(MfHIC6~`fIK|I?4Fy@lGSl6A^}{IqHi}h&+y1cl-6T8@B&;g&lM~<skF^
zklWoY;=O_%YhK-bywG+MH`D7&r+(IFXsx_l*MI4ed9um8-Bovr6x8lK_L6q|$d-Ig
zNd1dW-}C-s`;X@9Pwj7<@UpU1Z{5LbitoDXF8epnzT9v;>6Xx}_baEfpR#gx(h0ld
z`O9Zv|HVrZpH_;B^r}Xm&8j-=zFE#HV!vZ9+nFcZbtlZ5rg(xQ{f?HH(XA*i%MkBJ
zRR$aSkH;<7lBryG@+xDXq{BR!$VGpTPSf+tbqYW6ZPnzY7c0`vJ$CC9b~#?Z=LVmi
z;nZ(4mVMu2aM<GOs|g)`7nCo&wfXkx@Sdo6w}rNQ)9UZ$_P=7<CMR+KU)%X>PoEUA
zOurs>EA8vAPsU=bKhrby=dRt*>6|2$XvxJX*1pE-#BDpd!~E0Q`fsk%o*EUv+}WS!
z_HBif?WTWxz6QzDw?8sy`+n=ogu_AN*QWkm!&166;=@{#;P|Hr_y67h_@KzzXjbeO
zQ#-9)%Vo4pQ>MP^zIW_azy89|-R(bRcu#7aYMvS(@4ldaeU{bQC*Mw$*W8Z&+HO}>
zU8%I`X`q74^uCy7_uOvm*ry=He%&zCxjnA`SO0Ny{cMF}YhIquKl<qH_j?l!FRr|L
zR7CT6_x4Wni!0OBt$k(gKQQ7yyu2~Rk9SL5AyfH;rtcCv#a2kwt&yoTIO}C2y>3gl
z&_TEMa`P)G>+Viz&3#tVdcQ)4(_8HASJvjq^0&nLmoxCF>?m+$trsx6B)(_iM{$X-
zo8>t}`Gb>>6u7>Sv+X}MKc}^6*X!n#dUy5U#;&DPx1OqBb6LRUy!MY2{SS)or}_6!
zJWv&J^%J|5mi=i-RY{d6`)^#^wQ6xRbMSWe%x%tBP9GOp+@W~u*po}sjBOM5=Xr}>
zd(F<Ev7F`NDY?f}B2M?d)2(e?8~-q&Mr_^5@{cR6d#7)Co3ML9f4lFz?H7Io+4*bE
zJf&+Ye@S#kU?ks?&Z6y2rT*V8T&woIvrG7R=uM{CpWgqCo|U?7{}nz#H-(Sy+KR88
z7r$q>{CxTUGaDLCaeQ?6QNgq|!9F?Q=PM&W;gB^;qQB}My&T)WTHb(Xhs(KgmGt~j
zhP1n}$3%lSzJB&<s*+9H?EC$>Gq1kgr!sRtgM+D8Md1XQSt341(~1&zE!f?>xMJqK
z1^Z=9&6t%rT@CKK-Rh9jpHLCRZ+BJy)m)Pk^NqH|x5Vn}_8s1}k}qLH-?u3Y0hdFf
zGrhWalO}#!9w4S+uws98|IYC2b?OTkADZ5<RbONqohLTIeplv>_?72>Xw}_PZJqn~
zzg66Y##P@e?ZQ}fRC&E`{px;xK2m?nsU-pxdnV6mm)POHXR<lF&)P$geh>UKu71l{
z&KMXa7Ww^}5vMfk;$2JTpK{RX(pHmu^=B&c+-ilw<-E_h*aB~E;1-v@{a<EFnqOha
z3vFMYw<0SUUTteiyci>(ZQ}J*Yo~=%-)`g1fVr`WraamO%%O{tgSBh>|5snD|9?ZO
z{Bdx7;OUq3K1sq~z1M$lm_J{>{0MjH7M7S>3mhf+j5F?ZSea~Gc=jyc?a6bM!)`aR
z_Z)F@?+;Hn?>vjg$U`FKO3+5T6QNa`UVKkGp)1`G>MpzU`kN)~j9ah#RkXe(n10(S
z$1*ytu+U%KP<*-L>uteqU5t`UIiFW;xMO3`n6PYuq-sIWq$Xibo^z8P+{<)1kzZr8
z&Tv_H?DYo|)`jP~1;~G&sa3H_ZvLJ*Q%g@RPe?qf)5D>-^08Ntj>4LY7X{dCpXti9
ztTJSiX{r4ZynoIt#&Z@k>vI-I#_xWnvhJ$8$olMQH{5-Xp4jO8-bZ6PzixBh!Dq)N
z$o8fF5ONaIUCMtWS3jk-VZKsuPRa}3scafCo%&mt)K&JLaGlq@nmhcxJ5y$e4D-W@
zD`F1Z&6#HP_@}7N>B^NKLhP?Q=^hhzE!`FU${^))$!CwbYpnT9CUkd9j#%M0<*R<m
z_WxVg)Ss~`7CSU6CQe~r-MfiP6RLNnKDzF^$C~lT<l9NyySJRU+gFt1`G7Ma^p2o_
zYU;f8hc?`Jb^d_3*1V4wG>l&uS{=xq?z(pIw^GUb%t<egCFP{B)IP0i`J;Jw?&j=Y
z=|WepwtrOL6!2xDxmQd5s`k_+`p3K`8{K?#<!lwJ?djfo;zhz+tv_y&n{Ip2MR@bF
z=wxs6%^njNTfQxwa&p<lh3m^%mD+9ZcCTpPJlX8sahAmXO?&h7!Z}x6)7ljGByH|;
z-MfndWYR(%cfF2qQ2D!k{`K8y5&{wK>~qgPm2I1|?8>C)>R<LIWqq3%dNz5kM@<6T
z^cxR9Ulw8c8zbx&yt36n{=?ks@mV)MWF}vF=4VrQcK^|W{l5)@Y~<G8HCn|WI>~~i
z&U6164!_O_gIDjG^;XqJXDiH5cIMG_oF@D7NrH%{epRDwp2;LW>0q@l6IuUFn_bG$
zzyBkzomJ&Nx%dZMTQ=sz{<(1ZaO}b3%TkZco%4X(?9K{P?<RKk*u@tYbDY|t8T}z$
zqjY`3t}C@0!;@|<(@5pi<DGqGRgy#ZlTO9RRLSh*4>H!S$&a4QJU2CD#|*!d@|u&@
zNu~T2*|XvG_n$tk+r4KlIdoRhH}O-d@bYHOMGf^_MVIZ*-)pL8uHG>%HFY&Zoj;qY
z0!P@(yN`SCMCGiV$SwcYEc3-=U)jH37H#5;6%;a9%Jw!d`&o$LWxc%i)QL{vopH~X
zihFLU*p>caWm6WzJ?>vW4yhUB?g>0PH>`E`_C-t1dMVz$w0reE=S>^jpBoh?&2+Xf
zIB9I4;u2aGa(>gP-S=G0-$XvM4VHZAc&MXoW`;&*%hgl6=3Sf1?rBnE;gh+XrNDj@
zOCF=o-y>75X(<$ipFf$gid}%ixFK{(b5s1)Frf*3T528}%;t1#&fz-jXXG1h6FAjx
ziouq`&4*PyN<^-T-U$=iT=9+nEpJH+lXS&bgAkvO$ttO@?Z3@?ef@&*YSZ9@d6U@r
zmIQS?2%Y=O?X88G6YH;;$_r1gaPZ<uwRe>LaL;S$wTyV}b=x*g^$RSB{VBUE@~nfh
zsoQfkxy`5I_U|!&*Z#Hf^n2mlEh|ri9DH?R+R3L}tp}g&*{Zi-^BqQ}NuQY2HI~+S
ze~c<;f5N+Y#!N8-2K~x}9s6JX_^9rs>-_cYL(eIy`O<xVX7ySA)VyGJ(KIIN<IU?2
zGD03MSzzL|ke}yM<Ae8X-{*6$_VP<Tm*VUnvweO_WW-IWvYkJcsN}w!u{PUri;dFM
zMe}cNJ~`il>1e+550C1Z|K3X;=@5OpucxbWgTr~h4{tjDgl{|&vrCQPZ@RF@>_c--
zihjR8;nj<qciyf1s?M=7XyHCBfv-AE|1QRSTdnH6*=k9^=~z$c43W*tHUukXR|&tU
z)w{CtbJ7-r!Uy%P)8{OHv&3M*JORhroU)EGmi0|v|0$aCwesI}S+(ww%!iF?Nt5<W
z)6`dGKeu~IWO|>g{p2rq=lX2_wf&V#XwcC&W;WONKh<}zy)O0t)<LV?w;6uQZ#6Dm
z@wn^4E9Rrur)M2GeNC|-e2KqfO}fOd*u6PRnrf7@E<EsNFitwZeEGlV2jbVw=G+x`
zIB#_IR>sp)CY#$AT;+T3yWZz#Q_q!2st4Y4&wK55f9~|%mo6AgI-j`WSnthyFYU_N
zeN$63(vQ73Cs(N`tXHwVJ}cs`vTowRgNBQL-Zt1{_0!JO#Af?GY3t74d*nio35ist
za(p`1{(rt*$d@x7(=<X({Jq8BdH%q}ryT3P$Nf>5GUIp5fz}7xzdc$Ln!)CCCtU2}
z#{c5~l2drPxjTe~rl0$1+tIz#s!dAm+XU6?(*4t)2ko$Re;e8&z-As({zNYAfZC(}
z7Nw}Bv%fblFAa6NB(BkU_sbcX*+HBBI_B}j3LcKh5)xeUS=r;-;Ug0nHq~#;JoBKu
zEni(Ef7Tv><1*F7ZZ&BY6J8vd?<t+Z`BiSA)4rDXv#LXNgR*jGN<QB^XKLGT;ivz$
z)#Ww%X4aqo@IZ;->Z!Z^p0CcVJ0f-LZ<5=@*-K?6FF9k#yz>szi5v23LZ$6bU-B~f
z8}j%3jSppSQV!&)q^rbNbm=9ztx>m-%RR5>{>Rb(r1a@On;Cih<z$|}eRB8iZdJFN
z^DlpMjLI?Ee=_O$oVt~%O8ob%)5IUmXcAFrG*s~C{@C4qHBbK8&f_OyCzUaLD>^!P
zE#tCP6I?qzQ_C+I|7j|0U)Hq#%o}VMvRGodkj2o<!U%Q)i;;q*g`qi&hkPH4p@F4=
zi2?`^zK^AMJ8MA9O)<S5VU-=(kKesB;X8Pj$>f5AGOx+Ibq6`$2{f^mbFVw7xP#4K
zK_#NWp&}*i-I+VT|A)T6y7E==zNgvi^WUyYTX6BpLxw2p=qAxQ3*X7u%(=6OA<{Hg
zE{?(6TwdMWT;GbhS?|bQ!9UX_<~qvr6gOKqyZ%pA;AU>VGe4zB;k&xEX}X5P(ZhlV
z4zoWH6nQEr^z<3qhoa){KgTafs&P$Vu5?<%m^Ft%G+pBc?_9@gH;=NjZQNR1@AY}U
zKf`8G?gn=kmyW;u<qQ`%d72{{7ciJk*e!eGrRHMM6M_pK=dd#F{{1JMBdyT7yj(m`
zPfuT8-*3WX>E*^}!X~xKK42}}&YaPF_ke-_2Ga-ShZ#yI2>&>L&f=mZ!>%%c?e<Tt
z&Y8W7Q;?AOpi<Bh(YP?rUrsI{+kof86qyB!*Kl1ZV08X(6886UgY1XvHyJ7{D*y3)
zpZ@*5gTM><a|+tp>FVMFSJ;`hvfglzImp1v8tPY`UtY$*k@fesz>^ox{ygFT#NsI9
zIL)7}K7@}+gJCPfg5_-gv(BI8Vk;~xe_YaR@h@-U>+%`PgQvAeowl;JY+U#*@5TPt
zlba752=hPw?(o;=DY6UB#Rcr&-@wa~mHT-&XEwjMo~_1_tITV3zE3|nnd7hgOx+u@
z3J1=f)m1sf&#;^6z`d}tnEi)e|Ju>;Kj70JG5b=12hSh9VcJlc#U#V9k<otdg}-+k
z<|Q;(pJA4H@IC)%y>f}1T!ZP6Q?d!1+gcqi{_p&!!gl*l=lnMQ<_cz?9rJe_XMXVS
z@1MV4KXt}kI~U+Szy8es8T!*V&e^nW8Q1Okvj5jko>=&e?MLB<kIWVotQ8DOhYm3)
zGUhoPsCU1};`nb>({K6k)D^wP4o}V}&G&n0&szP@wEo%tvS!u~_cvadJKuww&EWsx
z!r(l{yw%I)=lxG#_W$9h|Lz~|2mZ^K`G3Dj#70K;e}M7-h5!GraP$*!pTD1Hp2h2j
z|Blp~K3}fe@NfM}#vkYBhB8Mx+syeFzWNPc)h%X)E7v~0Pj1<v>9FVEwOIn?+Pm#f
zep(*${`(|Lrv(YV>E<WiN3$L{c=+sJ`(4Y=ZYrwSWqD_w#LsrFKU*yR&kd5xdYbdM
z`fvp+3!{Pr&y(hJe_d4K7#SPn&tKMxYTo<*fk8vJ@T)ifo-kEp=`$oe=5hXS8|cW$
zApT+d3x1U&><@zev2!x+xbn|U$)Dp3zYt?V<lo*OKj&Y#toLv6|GV7NzwTGyZ{Yr;
z|6|IDZ}A^ia-G=!AXuxt{^0T$zyA*NmY=v#e{lJUbN`$Cmmc`XI$vq`Uv4g@9e4h>
z`IkH?+TPswU-Qk&89VRn{U`fwrAU9h!u!eX=k0U3nRnD2++ct9f3{AToWYIDN533@
zWOMe7{g3`=0iJJc(F@n>SVecX-ZpP3zk7x8<X($!%T=C9e&aQYwD=R2a96H8VnwFT
z)}0HZH)JQ=im*TTYn{#Ksb93dHs7EAP3_8xzL2%&=KuTt?BuP@zvsR<ZR~RRa{fLB
z>2{5a8Wtr>`Txkr{Qc@IBXIj+b%+F4tZmCilkSiCd)P$xO1EoWS5p%IzLhVFH9p}^
z__@L(uaC}bo1$wV68WrFWua@~^941>y1t*4u73EcN^X6^uZdBrGkI+vsLWe`<$T3#
z^M~ISzdvRj8@D|!s46H~$m@vqp3X=&`<aVNL?5Z{|8z<BhRZScMek0^F28Qm=YD42
z?^n0XH#{yjc5BNFObZgyb76WKUKlOwrRkSyqN(wx^8U5ZZF{DkZ@r~^_l9YZLcdg>
zQ!mpk38mk)<*dE?+*h1w;cZ(Jc&n@>v-ipc#zqaVA5Cs<YhFyMy*=@F#UtO#f~$K!
z@-{s)6V&0ZJoW9}1OIJ1dE*q1OYbsCetmE8Den8BHP08>_LoP>a_)<bdTPP{UB+iu
zr1ivE2bUX~n74b$TrFK9dLnVd#QjQHXBL0iA(pA`uGYQW`}A48oafosjz}2R-`wz@
zwOMufw-v=Fxc{nEz4)x>xHRsm@`i1@0xZP8^Ue~=N;;IQ?R4eb684FY&h)LgqZW6i
z&#UB+{<9O0xSL=7>puBiJYC=0V#iTS?cCCo4Te``;~z^u&sJGE@2t2g$AsCPCcFZF
zgmkMf9_)JaKa|nd<j=)?1-1=RqA@!)&hK-b_5bo#?#75sx98o~IsDtZs`=UleYL}l
zk1sEH+%ZFsL-W}TiIx2yXFQu)Eqy7^kZIzR<iDSGomLd}@93+Ot#NqN@#6NqvtAck
zO}F2DFeyG@!Vck6?s4lccQ$?5?Qw`By78gIkqcig8e4q1ZNOC|cr;-5gB=H6UhZZU
zE3}&%IqA9JHQP`QE#`vmBdbEzty#aWO5%ia+0nf-D!A@C>7BXq)W$pN(Wk;9OHuaO
zB@1Hj9ZQeDzeM2Yx#xeLoVi>%byb<?S)rY3cGsl7U;XS@d{1wN-yHXueur!B=RWp*
z{$Rx+{^<T)jdz2UPUrqMH7lQTV)pSXQx@gh&lk7I4BJ>?eD|%I(I>87kvnea+)6wy
z@PEd><Bq-U3br@umWQmKW%f42y|%pZ>)cgwUiQ0d`fgO~9T)g>wd)S+r?Nk+Y4Kv;
z3fnGJ?Vl2+rX0v;e`vwS2Tb0_)|=;~82Uvu`}|O9vOayvN#m%(!&<eSF)fi%S<de!
zy?>m0b9>JG<!jC3PRT46K4Uvw%5$SG^Up1F81I{%ne}#SSkwZQxK4po?gBaIOE(TZ
zy0==P`g&5=x2ZB~{O3!uX2|>9?t9bCa_yYVZh7lhcLjf43fY&^)#UkiO48Pa_jY~s
z|5agoI!32{<qh*Y%Ds0wJGo0waDK66n!oNC-_(p4Z@!#&tDYP;W#W$bwA^U*A|JMk
z0ao_~Q-WU|<?*ml_&w+7WR4iYU3>mrTNb<E`{K7U^9x&cuU;%;uQ^3?ZnE|AMUE2o
zxz}QU3cfgN73j3zd2^ok+Fp-EB5Ro4167yZUCv*=YP)QWlI!CiW^uVs@9M1A-FNJw
zl)7Wfy9EJSCu6&>mt+Zahgc`Ae6xA&p^{o}CdJMEe3m~&!?lv$ubH=a_4j>gdn@({
zt@pV2``g)XUG;va4l#soxi{N=^~qUlA1SZdSaiH~!Q7C8mb-HtQ-n?KO<ntJW|N9m
z*5h3Ny{F&!_r=co$D{L0IXA-ZzSXo<pEN#xP?6Z}@S^>FhhC@<+a06BXEnXmq=Gh0
zs1<4oJMri57U%BAtn9Nt9XC!f5^8-jwSL0FHUW3m{<KeN6KqYIIFjC-mN1YvUfTM@
zaEbgw4*So>%L7UZy$;l~`UFKkIe*h|=bqWOQ$PECo@2t(ku#ynv~l&06YbjWnzID6
zu1&fTV-i2%$f+CW{@+cN{C3j%U!6Nck4NZ?jI{Q-j}`vL9<NbKoF8@V;u)S)rG%}m
zheKU<C6{sk+0m&Md;jNa-K@mb^=qa_>F8YTa!B!>JfTuQ{*L1g;jLjhYlAXeI<>bh
znQHG`9oo4h_(AR08iP}h_Qe@L6xz+y`d{UBRYZ)1(!bpi0$=xe^N4xQ*v0p(hm$wi
z)TmDA=s$tl3IC7F`|)s0+I9CbU#a!^zC<~}QnyQ47jA_0Ycg}QX&U9|CZ6)vceRT?
z^&mbeR^r-HjojCLkI!XHPI<eBf5yrxYw>Woy-o9tQpMv9C-6$Xj5ExPKh`_p=J|u7
z7W$t8R)sn-ht#WXI#}y1diBTEGp30jovq#!>`SmqoG;K<(6e86;Yu%7S?w6M&sUFV
z)J_$AkvvyOQOdyb#I)HSk*`f(w*FWq;dRX4zy4#e;}zDUQ*AT9SA-uvVR3TqMi=qa
zM_FxFX<CQ9&u{t2ypUm@nqb9ot%SGTS7#+uWE~8;lm7Che(>*t8=Ky5do4Rz|12w~
z{)|hW`_Ft>8*Q=SRnj(t>mhs2$R7|Bxe)iv;AQf(^>&P_E_~S8sni_Vcy#`CZ#9F7
zz4f7er*@mJJb%p6H1cdn-Sa0gyQd!MdDTD9{`}M{uR4=*)cxf@uDki)=;Ax>vqxTa
z_LWS~UB9`|^g)DYHHUCXZ=qZ2*^<P^d$w&YH_>Yeyt#9-x}WFA&QH^Jt*?pyn5Ytd
zV$nyT{bft-4qL5#9r7S#_VG{3D{ly%W-D@juM?cL#D@K2@0H~@LX6tVvp=@8NOHgQ
zFRD}PO#bnpc3JVke}=K`9ID*Ax2%7B<*xVPhTUCCmPu<4^$OjK*Z8nj{#0;DpV-T}
z5erO}*X`rIcC51bz3kI`pJcO^zxTZ5wxk5xe=l7l`sm9H>GS9P&!t8#{#S9xWm;+P
zkEFHp^Y=@C|NXPD)?;eh-7Q=ND%!g@dS6<@<9}pxg5AmXsWMYNZ=T$nyU*=P)ZBME
z%3GdneP#2L(c|{+f(Erm_hv1NmS+A}>K9N_X8iiQ)07GGY$rB5CC#0sXqjEp{*-Z(
zi1)8u)_>nCPn??e?&TlGGNuPld{w_@+*lB_wMcWfoAxS&%VnA`&zY=CE>tc};j8+Q
zykyt0^hu#s`2sSxcC_XFGyYrK=l3j3YU;DF$KUPRqBHJ3HPO$moqlcUbc^UF?L1CH
zR=?y2%PfV0pN7n4Ig_aE_51kMb=wxEZjA}qaClR|9Oc_5qkP-0gx_l@zc#=6QuSVL
z@do~|_%@^C*2}uP-uJFCpK&<S^>hB5$7^*Lb$2&rmCu^?uyCTx1@n`E$G5)o(A0l9
z%R9MEHdpfavx841uikKfIgRPskIieOK4ma@o`3zd<n22Ta~a!e7ps$JBOm08d#JyN
zO)1{gzCYm62492iD^(ZNzKOc}XXSq_*TYLQYL49Xy0++X@<a7^b6O6zJ&;OlEO&Ew
zrnv0!lnlA4IXq%Mo1*?)|19)4K(lgsON;CT?YzP@nQz~wt4-s7_D6fld*(O^(W{$G
zqxHRJMdrTRFC=s9@icR}vUK@cg#+rTmFzp+SlAg&R!FaY&dsu5NB&90Lq<&dBlz16
z8}He^@b0B6wV&(-pP0z2T5}!z!g4A+TRkoJ!qhl{w!oz-4}AkSGT$xhogOm(^Z~!i
zk5gV9INVoVEGPIhO25~Ve?fNL1*vNf!mILoXKp$@&q}@a-=y4~synU2%6M;Y|I5|&
zy1nGg+S*0omp?zMmSMGie0;*y<f2zr!J8hwTJm-8%p|$cnY&hH+E`89%l6}0{$BC@
zZ2Ptc?h+6#7WQM}c(9B|IpjmZ<aiFr)u%2td0o=W<(pD@N^^<Wo4f2Yj<vY%obh<d
zXVGr1u)x3v$7Zu8yHD^~Y&5^SeWR#p$bof?<~#5GJpD~kUS-kjrYvjMs&BRIQ|@0@
z*ejdY_^?UzYBkT**apLwe>AG{^mUKsOn$iXk!6T0|Kqv>!F|zdXBHe}*IjOZSnTfH
zhadOJR@U0>N}t%X=>F_)a|7e#7Am-`I?C0~lKrubA-GI8S;gC9MdRV5lvcTw+oH}E
zbAL5{ny&Q!7>C>TgF7_ONI5#sa*VcG@wH@%=PL1caTOd>EbmmQDju#pIP;hL%*rDt
zv(w|&#D45O=Vj9JqN;1+^V%C6A%XX@JWtuCy|_F5s@j)pMZ4zriWlY?K4*Kw9=+W;
zSn;3Koc2#janr0gWb>SjR_yb%?!LL$*W~QYJ=^XJ+|#)y%rWh8&U)XdMNtQhR^C2;
zeG>19iVaN-TcQIFKk9sMbN0jBKY|yYOc0+^E44|+<<)^MSx&*EXvWT9X5;rKInz?!
zPgr*F_|=-93afVQ3oTDfn#1t5>9p%pmYp9zT-TgwXd8NS=@nZOMNgGvj@c&;Zqa9c
z5G}${)mAk*{7LD@O82>26dz^e|4yt?P<l5}-`OO@Y<`ei-vsOA(jrM-j=x_{ia*Q>
zxOPT<et1$Y|1{I$)D+2xh3z)?pL@oNX?*Y$%TsxN=uL#n#rHSX>h6xw%$B#{=RA8j
z(KMJtVezubhpwpDdt`7wbJ%Im?W0~S#j)l8H!Jg}Gn>>~{~0t`Jv+KR)lViQSZ(p6
z*AH8~A78k^^rzy~j2Eu|nQa8!uH1R2xW-p{hQK#J?+sz$3R|W!FVGTL+`7H~RH{(-
z1z*RcNm5d47QSWFQ{FfIPPojRV;Wyucdy=h{ZGK@y!--*PqRF#w;pp|aq{a=&*!~+
zCo5N_<e0@Xp8aJWBpBiKLwr*O$1TIY*5eBde480;BNvMX{aiaQ?%LjCJ0cPeL|K+e
zzw6zaQt?LP=H|jRonLN0zp_pCec;50vR~iLwe^-y;=WNJow-$_MwRX5>8}qS*dB@I
z3}x9WYP|0F>}%?aZ04GMm+F*Um&b0!E%lruZr|h!Q+PS{$D2Qom5(f_*r9YF{f|*k
zL!l1ax^R&wFGsylzx|!BpIzJZ^6@K=eQw=<J$-kTPMgfX?BdTS=Vwn?WuPp!e+G*x
z&okk@L0kO0ejOBgF=3kR#zn_iYC^Xy)7A98xN&KkSiyIrOHrZ67WdxNE-vX1{16z}
zD*8L;;a)$R?e+&JuKB*9*k9AdR_{mamR%)jcf^~{$eV3#u9n`OxMy~0{x8Mu4N40m
zpLno!CDpvYanti((8BQLhvcLD4>!MF?AFaH!(`v}@71}<pNkf*725nij@@O~YPZ>&
zE?hLrHFP?(>iL|{LHE__Cam=@yYc<tdagTP0v1`Pi5;62CZ5Gok(6JkDIA=5qf2&a
z(dwHMe(Em&6Y^lOi+3;o<&Qy4yI4+KEuO#VUhU2=J8v=H+{4MOcb@f==gD~Wf~?0P
zClU_kE52_}QHb_^{WE*c^vzpe2VOEin5G)GC}~pGiG`m0zU@q6!kMaXZd=E2-#?R(
z#1xdG^!W7s4XRs<u1*)}Ra}wyep}rWwcBYfyF7llo|~QApH`@^;p=5opYh4y#XSA5
zU(a8hn{n%Ec-ZZ=TNCeUaf-iDcbU7vYE7i6@c9#0#b$hY@?llt-SES4em(p4dOYX6
zs$bX5**WQ!Hecw(jhz}QXMa1b{42&N`e^%dm+MFJ+Yibx#(U&hi`;0{`!g@uF!5!v
z%XgK=FTBMEJo!%6o?)Drr`M&|7Uh<=BdxS{#nG9kok}LQ=FhpWziiH(jQle*jGeZ<
z5&6P@<Wc<5yVHYQu51qfrM69G>QoJG^E;o|RL<QwaHCXszS@M2_09J_tndj9+i*<(
z>erAJvr@M59oxMz>Smm$KD(9Wjf!cfx$=AZAGEvM)$1*Kouo52qfOe(uqQ$+jzh30
zbM2#CPwuNhYqLbMDjr|@y=Ur)s9zIYf2ZDGJon0~&fu1Ak-MGco^0mUldd;T*_{8l
z((m;z<EQ>|uZ+BI_^5yAy)V?!{)JbI^Kk|btN4MNZF9wA92xV>?Iu^=Tz)2-QOU+|
z`Q1BvtMjyHUToH|x0#U4r`O5<`i`5I$o$_fv-c@Zvkh<5PT@?v^QttcJ5j;?mhPMv
zj%UqWnZA8F>obRY=ZSsVI)S=}wL>RnKHs<N*xpkY`S$1*R*8skd#`Z&eC5xPru7lk
z`**MRJk)SE;qxTLz{9pG8XIftrysevjQd5yuazABML8Q4l9tc3THtDRt7g~M#P5PT
zA029F__$#X>&$m$S(-catn)sqM++MMjSzazc*JJ4liK;~!Y|J>JzDza;|Xu=ZHpgF
zxVfY6gIdb94Ighmn^kLC^zPfb6Y{R!%O)@0A26qV<#jzFy*XB2E^6QKF7@4|7vL2p
z=J+t($9Y4`)$iJCgN1Th=Ny0c>}>HHpM&|oO(Vnf(@uR#T=RK{^&d7tJ?}5A5+YS~
zQ)CKtpKe}gWcWn9p=pPQ(e<l`)+CioXg$`l|8-tZsany+XXixj8%jR<<G}v+T>3ih
z|CXk2cZczHTYP#Ob%x9EAoEu1{|lQKZy)&lK;Dg^-)nN!@#3`S>!!L-X%&dxq~l)s
zMtJ>|Yuol6E!g&8hr)F4*H_(~-J4u2o%yqx9@V(^lxca#nX(jo{rp!V?8Bu?XT@Bq
z&t8b$AzLv;k^kyJZ{w?KI!>BjPEMGA{~+JVm+og?@hfkizwf%}Lq*HWKDy0Ux2=iU
zcjc@6oUaegeY$HF(0$c%$_j5U*F6oB4(Cs3J!|>o&a*#KJ@ssH9qIO6@_#Cvd37Q~
zPDGbwJlbTk_m*wehmd<e3JuyWbTvjSY2DsgK9OBNeE)}^kCq?qjjq}_H^qCKt4k51
z#y+RbeU=yIIc`?llw0B>B)vEC;sHZn)08kSMQ#18^*?XFy`8<J_X*dreG%6E+7`$1
zv=nMoZ2e*~{xBVmZR(i1QcZ2GlJQ%$XBU>Ay4}9|*@?NrPd47OYuaKdV{xBDrE5nM
zkJ+s&dlNpHHC^4d!RxQT*TzWA@YPGsezfUY&1yeoPqMvaV!7;VGoN#zy$5%z7V_+P
zab#i0*OO*uBD=a4wJUXXR5Y&*h|4<v`{$`^%5J3|KQl^R=oHCq$bEe&@=o*xJ!Yp1
zZL*V!Wh)vjC;jdbNlfFFc3*O9-)14R9frqW>X>i)cAz&z?Y)M#q;K}eTX%yt?_~K_
zDfOmN>3sihzta+0CMUnHd1U%E#)_9?@m~(1EMX<awkc}aw`#1*9pcQs8obuuGT-K*
z2+PGM>w|pGS#0cH_N@2nRp+NCG|PYUuYBvl@!0Fn%8&c@T1*j{QGHbNz@Mb&eFbro
zcukFZdiP&`zPQBlp;}Sgp`J6x*Q>c*$&FpV{=&V$qKG?>k1ajA$M2urOrPMWV-MpC
zm#$sUChW3#+3~IY{{x?fGOKC7SkY&nn)YDJgFSZj@9xd+%5(fwYocNG|HUp%!Bd;_
z*$=e+I=8NI>*sCFFBfe0t7e%kRm!nHOv!W4ue~NV5m(*wHpo2Kvo`7TCb_TPV!vGO
zX@1?!b^T-C-kHaq{*JRLt=lK^#qjwiiymVab?MgJDG{>-cUzm?EGhVwnm=#p!7xGJ
zjla@Xp5{`_c%WV0<(o7;`4QWeV!7BjJ-N*%S-*OSsr}mfu1To8{-FyuyXT@5e!ZU^
z4=%gRb2PS8nz%tebkpQD_lj0Wte*B;|I=NY$+IFJul2Ht`Tg*XTD`K1Zr!Vk%#npo
z$sfLa3Qu~z_pkNN1g)xVbEbUCVN&p#?Bsu4sp@Cw;olasmR3E>H90dme0QDm{+65G
zN3Cb@{Lx~yUbjJW@npGMZGOdbocd=<c0@HBp7P(-ykf_yM_-TJ-*)lR*$2@aa>su$
zL`nYGo|YK8>YDUo{h;|v1B<*A-knjdkM}z9e24!|fmfD4*PU%wX1mfM`mCeZg=f=T
zuH?wzO6@jw3%Bz<XBPxbsf@7r(Q?DCPrIV%+Uok|=`z*{M`{eVobS{~JyNYJ)gB;k
zzVqJIhWd9#7B6nfNHwZHHh#wWapk33vs@g%->BJ}l&UwS(29ZQzhVUQD-)+j#kb4P
zFPL%ic^6Yo>n#7eMI0Y@)#kUpy!%Wfan8!!7ruY~aO~70<(mI@U$6hBcR47zqFf?)
zhs4yjkZ+~41MjYIIK})VWo_}^UEbRcIm{E^c!c+q;qD75(QJ_u&Cfhd+}SQ<&Ay?o
z`sT@-kLI6WSoP6o+KuqPY;}hs&L@?L@Vb~a<z%^7`(|W++%fS8kKcw+wRS<JQx2E6
z?@?KN?8Vhrm(5b;?7SMYkBL?G%)TM9v+{T8f$d_aKP1{{EcH4nx=~rR!_Clm#o1kj
zmPT75O>cMU?|UX{s$R>yD2hduYukp&=k`xkV|DuS#rRzCwugP|OZ3C{&ar1x_0<-g
z;(R~3bLr!mKf`D5dvR<{ZG67wjO8m2CF%$jO0Sgaf3>7nsm=9o*1hA>=|4jq8q^Q=
zS1Q(9XaD>6Er9#?7XPPC%VPr${<`ITZ{^h61s`vnt={qaS<A0w)mzHVv>a`>RXpK4
zbU?=W&q>egTB%Qyv_I|(&uDQ9%=);@_nKzG_hoSfLY3RE&1jD-S+I^{%iq#JpS(_a
zSe;RdQa`MgyF1CsXIFLDlpU(MLPc}tM>;KWYB%jnu+-GQJLUBBPfI*Rq@P<%D6WsX
zI&XJ>%!At>U;mL@{a&!D%_gq(ZvKvKzqc6_zF+Y8($*j1mIiL}F@|eQe!Uaz?hsI8
zQhsf^>ypF0H+etqIr=;8%0Ku<G<k`s?3!;XlNV*qKisi=|L1VK?As4gx$abYmau<!
z{w=_t5@s)87wjaL&1P7??ANb*D?fb<z4m(PyxlkKe(e>Nj`X?xVL{W>OY51vigs!r
z-?eC6-|OhK6Zyp-x;^h72v^-aKkl~OoJD82+Fw1NnQnE&q}y-Z^M(r!+EOZg-`4i>
zpY!3qu!4izCR?TaPNAX5n@P6%KlZhYHES(oc+1|aC$r=2=g-HoKG(%b##kJz5?Z$7
z>g(?||7Mj%UT_P1SferXFZ;ZtGlG9>uDE3u&Apww?};MU{$=uCJNcJ|Iw*xrNY-&V
z>{<D`VV<&&@3E!lqYl*{I8ttOL?G|oV!K`1E-jn3MAoZ$2UoA?TE_X9Ptoo1ZExKj
z(UPv3nZn=eUi|HUm7KHp<B95ShO@_AG)^nFu4Yy5{<lp3=IoCz6a_;jNh~c_ni#z3
zQs5+RCIL@1{q-!f-lU5>Y7x6xUYniyTjY!Bjcd)ubI<AD$vMfy+}?Yuv^Hw>G=u97
zef*nLoiDoYP^jatJwElJ{y)+7^*c3pro0LJEPMM++?8*9&B1wb{v40Co{`CasM*J}
z^5m7bcYjDt6DmKOwSjl*y+>1oEp@-0SX-&NcKZjNQm^Q%9QSi?&ouk~%m3Ykf?Muh
z`JLv|t{Qvl${s#ydY18Peb>>A=I_GT&i*l4c>c%JDYd1o70I06{(b7*^Z!G#L7VRG
zciSB1s_jmi+;nyGn^cvW`xPs9|9U>L%KCjo<CS%V%|<~k>2pdn<GAJ6)Z-Q|)Y<a=
zyYtQXi22VyU0>Pk%w=}=sMwq{W?LVHP2<+S7XEt1{kf^d7CUBiZb-WwpnOCn<PnFT
z=l2sAeRsCZUU=!+qW3Mktko2ozAr9{;9U{FdeZtmN?C`5{w-sCu%+a(q;T@_*K^A6
z3QA`v_N%Qf*ir71`H_{gMw~BT>BciREBww~d@<#%mrtj^ZIMdMp2F82pC+<q-01nC
zWc)-<MWROha^agh9h);8Oa*TzWMs02Bm@T<cmBV%HhN>s#CkuSJGBid%~9W`9=yw+
zU!twZb9Aj~xXX&QbJx0rn67=_6u0QYx5S@&)#CrT-e}tWNO$YWWtsMi%zu48zrf~Q
z*R&AxdQ~>{tw+kP&zrK9bzSgpu`ldZKa9Fp&&g@m*|*y3x_tOeyP}Up$LI8iomnUs
z7-PRWxG8AW`dQr0i&SO#-$`8FvwYhMebrxYO@l=&PR>tXDQI6U+<Cl@S#9YKsb+59
zGTl1+Ws4TfSZKH?YTd`s>wj*|4v_Gi|54A??(22OhetfWuFR5WtUV%{d$QYY3Cnfi
zMfsU|I}dBia`Kk$dbVi&{NwXKZJ(+rQ-8z2_D=$fj8egAg^yw<*Uf34ebjl!g>R+@
zV~zf5^yU|(E{py3PFCD~|FY<%cIk!%ks7u~jD-%*yz26xtj4e-)bj2M2i@4^tj2!K
z<(;a_T)e9nKUaNw_qwZQ_>{jBzi1ve-uvOT$79hihQHp-l;e|#v0P+4Nxpyjgq&B_
ze(NIF9A4jO{xdf4(_uwbiSxe~-7WE~-0|zz-i?=b&NStEysLt*t<@%fl9+wZ-ff|0
zJpQfRyFH}-qP2+Fym@;he@u-y{Cw)foLQfa`*<0<^IlryFV+@(w(Yj-lJ-9zRM$1C
zEO2spdH#xwi`A3$1?k~$a}^EFxpr2s_q?%zul>|i)roqFoI4+_y!rf%eoojA>uJv$
zFY53q=DoK%dnSFKW^dU)rntvnw>?h!x_j?TH>00Im3l8z?aX5m3fRsYD(TH$Zt!Sv
z(4wt&mQltD%1fiy{;*myy?C3`M<o-5mI{8?4AtqSiD@lKHWr$Jx4V6xJy`9?G55q2
z?b7hXZA*OK8KnJRa_7{FH|3exY|oZ>MLbw>+T>71A*b$6$yqlJZ(@rxx&A=;+sl^h
z##w^P58Zyxr}OuW@6ydh(T%S}bgGVNM<_k8<LYP0in}H~W$CTfi`^+<Yc79LEXjND
ztLf64nDyrz3gwRa|J*)j!|zB|k-eF#Q$Ic8J<d8s&v)m%#{xY8hKGB0U&v_TN@@0$
zuB+sfe4g`I==zGlncrufSpIwaPUHN=e6pM0)vRUYD@@#DCcisNI=E7L$Bk6>3)44o
ziCs+MQ-8ecjp=>SoE@9x&um&AJu8xvW8=DKa(3HTeR;F1vg^0%uA7%vxr6)e_F&sZ
zbDy8xW}vzC)?b6E&!<FB`So&RQNZc2l^a;n!;T+XkbCI=0-o7M^UGF#b+6p6a!O-Y
z#53c-^{<mw=X2b<7o?Fr@2&8f?>)EQO=@3u-6Y96c&ksv<An7=vBy?wZQSOj*gKnN
zX|h{P7L(!k!uYDrJ4^XDwi+tU54w^zM`}uG>?zOJ-^DFnZZNyt>m7Xg*%tfD52R;q
zmH)>7Ea2v&Qz42M&E^-0?3$@C?c7OE&DhIw_un-$n{C<~x!PH!FWaIypnPYHJF8dm
zN6)B@?I(AOKAO3Aw(c!E>%wm)n?+(&Ol`9pSLn`bt!VK)=~^}8i0h`^!FF$ErpW4?
zOUfyzx#?c%?5W1)cINFa6Jv?{v&(9ieEog!s8-eoxAW(F_mnKI5$*4HXm)d5b}Plz
z`bT>Gt*a;BGW_gW`D|nOjYW@M7kfPl6#SN!YRCCz(S`Vuq+=3mcDBW?xA?T|n*GfP
zk0-Okw^r<bHATBD;_!l;wJU$gxtv!}?>J^RMTJx2WV@6_=h=;Gytlm$3uqQOEEmac
z^N#(4xh0pO{<)sGK>1LXyqNum7KvF`tkuy=kQFcaB*Xvm>4zs~VZH9F7k%xBy2@$0
z@?Wg+wQB#WQ|sOBq%PinK6#z$>GPl34L+u+PT6gypdZFjtpBOYXk)vPX`ajTjXR#d
zO%*wp{x?wO;_>TVekZ=$=WbHo`gygOQa4{id`~_@e63nz<P+mp&%ZJzGd<yR4$Rs&
z<)ZM^pf4My*IwO`fBgN|KbDt8Z(Omjm-S66ddIo<D}VLs?j_PSp^J(RoZSDpK<&Pu
z>y?YWrN6(5i^ad6dOC1!<>rOYH!gG9EvG4Ua;N&y&AXa6?$-9YmgQ&vYe%-E@iW!L
zjdn}@rll>Ne`Kb8n@-e~{Yv)lJ$^Vf$m)NodUzzRNNd)LOIyOP^~?#rCHuoP)k6GO
zQPA(K!=1P1ReXO|>0te`X1iG-|A*z}?CZa7{<tP9bi0z1X>p3DC}Vw2$$iITI^Fk5
z|B5#jKVDf75g#&dqL{U1bFO!kxTosAMT;X97pbR3JlwkLpypl$i%V|No%=VPRAu^c
z@)(bV-ky&-@w!fIS1g5V1XMh|IC{DYer`MVe&wQ#ir2Ihr(E|}-FTHD&Q;bn<%V@(
z;g?-uw?98hc%3Nrth-{tl{@P;SEs3SWyi!?e(vemzxU9j`H{RS*Q=lS)JqCp`MNWl
z&*=O+*%f_`r$Z-HeEU!}H$i1ddRFBh_xlId%luMwpSR0+b$eu7*4?#_C9fX6q~cnb
zUjD~J--N|u*Ibj|>y;0$xck`UXiLJqJvMWiUT|+s_M9pA*5I{r{2fj1PqJt7Bewt5
zW-?KjwXf-#9PjjH2lV;3FztIB#j&94VI%Xu6*qD-x^E^Z#T0un-W6TN(3mm3Sm#4f
z=&QrrGi3wW{zRF?d^-_;A$|WbTaoEY`8k`bcYe0*dF1t=dAIiNfZ0ke*ZJ-?HA~M+
z+~T%hHCg-Sl?kVhh`fEzW4~_YhGOwo7n~nS?vJg=e7^bo#9t@W)|dswb-q)vIQn^_
z_Qow7zwbI%J*$f~zUq9qe{TMAm2LX(cU?4)f5rFoM7G4ft6@%#7pL9wdboYJbkT=N
zOBMeWzC7lZw5X0{qQk0^ZR`ctl&lvj*aSN*w>6%<=%G8W>X)8({<`lzGKlL{n62rW
zsOJ@^fAV-r{FLvn=O{+GT~lK<j9<Zh{KNg=UgI6yJ40sg-8M&|TDfuB!aO?>_9ynz
zjejGA<_0+J-m!$)UzGJ>faJtglOtR9{Z(<=Y~y~%aNqQQkETBHxO&j@<K|Uji^LbI
zoYD^BG0WfUy6WIh7jGt^T=^B7PH%FHKYB>lXQuFmlV$JSuCS|ACn~IPY4^@yQ!}zX
z;1#s8_ZQo?179{KpVK?}<ynXHgqs`Ar^YipvOHV!W2$}aq?h08H$A$Q`#~kLzqQ|J
zmhi{0$L2ft3T}I!^D19{SEj|9@FRI#&Q;c%?dBwJy1&B0;8j<m)9Tls6#v}X+}6}C
zCF#F!u3pNP<qvYbudeX%eHqK`a#YHGTh*T>^#{B}oZb}vEPNGV%;+%j4Qteqdo}#a
zP4@r)a$Te(es|vL1&`cwcUR^wW{z21Y%Q6yV3O-m^S1oL`FUqfin5(Kyq|x%zRb}R
zNB&EdH!QuXcU9ud;?Dv;I!Uc>SNu4`yWH<^L=WSBPiLMrR<W}rezEcQtlcSo#lVb-
zc>>p-8+KE|R2tpqW|hvZl~FJJyXS=4`NQp33|2PwS}dMEb>+&OfF~T+dzyLgZ_5x_
z*4?t=R3q0LW!oYvg+K}81zolJb%~4bJ-uMeKId)2yQaM|i}vQOZ!>$s^@laHGXJd6
zD>kS6kNG`a`xHLJ?RUub*#G)V@Vb;`-lcE%UF~vO=NzCq*G+d`$7Jh`|61Sd-eZs}
zl_s7sD``PZ!F{*e-zL5LAbN2|w)EVfl7*q1JQ;?HPU#x17Fv^Rk~%+Mvt~ZJ@0-Zt
z)TqmA-YaOv`;-|T5dU4Mxa@eiQoCyByu5>Kw!UfG|E`VS7nt04WS-2<m6=_xlI*3A
z@{E)gUA3uvu<^iBtGlyLYg~3&xkPi)$+PF~U5fa*K7Q5_rtnDDA54MbYXi>71jvTu
z39E`!&ErqmlPqxSB3FC-Z~MjP-b!Fu4{L0Qbv>+sC2R$(k%EP}sWFU)ydKul!oU!;
z8dgDpi1o1BSOey~6w>o)+O1~6GwlJ7*qys~W7#Am(hAD23vjGEc=v8>6WjC$LI;KK
z98%p~UG{y>|Mk1J?_2eA-}1L_-+h0%ZsFpfs|kXeTV^&dNemDdD+^PwcX0BYJC~h-
zrDzjVqfACg$*cr%ju-ldQgh8toRs8g{`CK}!y(R;XP;Cin-o`W3T|>_{IpJh!CJlH
zFR#5dzr6s*0|us_|B^Y1AF+GP+S#bf=(UESQbOcOkDEGU@rM$o=-WGNWI=0T_p&lK
z%<b=Q|H)t8FvIo)XHFs;tH#WoHyYl|_uFF7%wUormN23Fd41~w@hydgg%8q`i_6Q?
zO*faPwOU4U8yhg+IjCpGP&&c*#7W*1&L6P`4mZ!peMwJUlTpIpE4|_K{36~NQ@eN1
z6z2G#($Jvm5b#``KYWGi3C<5C77osSf(sroH2uq5^J6)q@q_jE7;Z$~{0~_SoA5&Z
zT$-4eK{dPa3U!Gr-VIF74h*81u3_T*;%N<%S3YfDD0xKk+mrlfX>4sXX4*^snYdHZ
zA<Bn0;akXq_@|c97LBqob0X&+oN!-t(_g;NS5h@sEM+-!PmZOu(Czo!`6@R!Q$AiP
z^WSEle~pi;xV`E>>zV@r-mCAsM(ncMkm-1^Z=HhW$^Aa_Tr&QjSmUV2kf$JU;_z`^
z21_OfIWe=G{fD!wtQ!6WZ2B)|ANt_+TZUqW2wPFcPpr|6^Wrk@olDD8Xy~4-ed7A>
z`(6LtGTyvl@ZQkMeLyCKw{6j1;lG|dn|=w~$L<rp!JNQQ^GME`;m7ZvzfZsDjGJbl
zapbf7XZv^4eI275!(yktJm2;IT4(oR8-{y2bLKFJ@#QHr^mj`iIDC}-!{7HBtI{6q
z-^B3mu@?K*CdMECe7>#p{_lC??fT!#|7V*?F#MPGmi*=tCD8CszE7HIXQP<E{hR;i
zef}SQ`oI6d{>6XpTm0M4>ABlUp?<~7{}=w(UrGCx(D6K;&3{g5Y2~B+LT@s;7W~g%
z#r&%{ZK}hxgz(@0ub$dD!}e^W#1*Me<<bYwT}t4euvF{D(L>MtH~rDP{>wH+z(8aP
zS25fFds+-)WeOkaOZ+FNCVt;yIcGj-DeM;$i~qGtM6NKU{j5G@vEx3&nK^UL*j#Mz
zcX{;S8C%6>``$&WCm!?jG2e(-XfRz}{6KK!J_hX>!nfW_*B<6g5dN+EOZX$x4VC|H
zHVzE4zufQm&bjhmvjs!WtN#jq46~2fcW@tA_S5`P^{31K**`Mg(D~=~#=j?x`7gI!
zD)T?_8ZY)w{3-QaEPusoKDGYkwwwFvi~bLhQ$OQB@HU)%8b5*kz_VZMf7a(k?Xa@6
zeLLCy$G<DD{y(svCeHDMag#%ITtg&B%Z+QTB{A1KChpq&#+U2trMEAa7;UJ~w=Ugv
zFG*3|FeIHV*CMt{wf4>7$h#94?H7n$So6UyBiDg1zk2<(y646DLhJ4JUhmuX<>k{0
zAqN{H{wi2%Np>%LAwHkoUH+|u^^a@mcR!WL%fwc04Eg+F{ayAHn^)|o?fTnw->j@%
zS+}^MF5c|0&}z|Si3l6_>Dlv4{at#W9CGSA)KUJb(YCzMvU|GmR}W43^DWP+B~C}a
zSiAq^$8Tx(ve!CIKD@Ji#<Ym}9Wwuz@@sxg-Tq^HO64Kf_mdW7%n`e0*tduMr_SQT
z9$Qo^wW=QPZK%t??b#Zaa`N!$vn#^o7Hl}TQ9qn<pNGcsxJ$A^yc!qdOPs!@*i^ON
zdUN$eLZ^ITr0%@OFXGF7$DH3SchX;c`F@t!><N9$yRStrzPGQyOVMHR^Xu2n>s3EL
z{pQuejUg9qmuAgXH<fsK<@{}pb?vL$x9(qPr9DYy^Q7;L>>oF0N%@O^i*kEET_o{x
zhVYd6vTu)6Y-Eb~=Gb)Iko(dsuiNFpw^~)bHl5#|Q6|3J_G_w@ux{OvfXr(z@|MQ@
zjJj?4DfQ$dLAj)TJ^Mebt4R?4+_yt)A73!P?Jh-+chy@L8}F|_DEi~=q>IV7)0QPS
zYwwvDbI$fAW3h>&LG+~ZhavsJvp>v^{`H~cYO@UM>)IE#Z!Sl*gw35esia=`^WS6t
z3TFF-`+VR}JNv8B>vN*W<<e_`zS=66%(w6OGHrWG(W{z*MNK@Z+~0rhpW%F>$|UJt
zJgbSp(}>x=>sH7I?-#e(I-T=G(g*d~cUK)(TlvCRu-W;T{FfEem?lea@`{xIHz(8L
z-z-C^m9PGUGTghjYuhg6;ujT1oxPOxbU*GnZr*?G*W4AMtBp!HwUckJ>EO6<YR&cO
zCmC0Bwk&>a@NVvsskgtamHoLO^r+i}?|UBq>i!zu<#+XPxWV(4FU0mAm>=jAx72OQ
z)DPL8Cv2`btoWt<(D#q`0*#cz7YCZ(aLPNab4cFsC&!1j_aFbbL{C_(TX3mIt>=lS
zS;w(^Wo8@;ix$@Y*!YCcE_TU;qdNOMo>#2ABb`^Kn3`ECBquxdxz7|+{hfVH{l-Th
zz0I7n<eJ-r9m)P}zLF3A`LTJQsuynF|2bN07C&cw|HoI|+?o2qmf!godxtSDDvvi~
z{-gc=B}?$5l2uEsdk;OyT6T`zGymQLKX-qt-NC-9r-UA^H29?1doI9!{n=9C<NZ5V
zNZk=i+o0vwCiOGQ@3?E%`YV$g>Pwx9Eri8Cq~@{;CC9{^JTk@Eq$d7N+pp=*1SQ37
zvX6g$=4-fk_9}zG6^4<|M4Szs&rBCNVRFl`PqsrrWZUWL)uHc|OX4PQ8+S^_6@UF?
zwa_W<mCCVO=boMa_?}0~z9!wvt?zW8%7QBWn`dTzbiQ)j)l6h!O52;s-GYs=>!)Ru
zne~e<Z(ca*i6PguDI!Y`E{+u_i`4D@x8!eQi_UJ1m0P+DtbWaWmc97av&WJNpKhG;
zQl9^d$?n*;lS%m{fA;i5Jb!8^R#sE@@c6eSLf?~QZO`uey70l=hGg+o^X-Z!n<@L8
z=s9zl-@E3<F0*-ep8gY?Q_{M_?4|pX*EZYEXvuAUcvgJ%%313Kb+u!;{$^!)?puGp
z<mnc!hmU0baCjRq3yDpt@|JH)yOr>EI^XKxC0@T9^E%5fY`VJer}Nwo1*iFrPv`B>
zDK-?<Zn=G9-8{v^lA`~T-@7x<&~!@ndXjabfA#MrZ&?i1T{*c^JS;_fpX9GS)=i3c
z6yo0of9Gd^WB81h^>qr9=rNVUCYMiLd>!tTV%Ix&ZPq#V`Agp1idFuo^X>e`Ct`nJ
zHU7W4B5A7Pxd86<rn-r$M^8ufYc6O05_ey2+DvULKHooWw>tFWszpr&wfffky>Ups
zysxdLd+YtZYZEpJ)?Hj%Qn&NXVpYkl^TO=p&sr27vDi^_%X;yv#QRfYAG>V)pQJsj
zyvw&dWbzMI|K(L37PGY(+kS7=bAK>({<#%pCAtfAZ~QprCbZ}O=7rm(r+BW^3`qK*
zJAZF?Qk}ccI`4%7@x6cD&&nREnozm>8|$ANG7+_}mlVF39{=yg54{?m`^smtgH#Sb
zdUh#ijc7^x$-i9{m3i+zNvUM(SIjGKyk@j%s$j6tm&W|*>F>j&oFXHOQd!MA1Jyb<
zDp%fCeR_TR*R#`K{Y`yl!x0*{RsJx0Yn{v$>05%gj>ztc7rA}>i%Xs&bL};=Y1`s^
zMNZlCE#%p=cduKQrr&ny^u0DaZ%@`)#6C@6ZDHptE>@r7s6RRNF^|_uXWww%xcJ@f
zZPVg@T*z~5c>nI|$xEMRr2LSwn{QYr>^GakZ*TSN&+iVm{(Jp?9mmG3-8-6pC-!r>
zczvBYE#uka%(;7Oww{lQx$kb3{p#-R6HoJh1>b0wid^@VGc2({@WI3Ix?LK(JG#Yw
zO}$?=^X;uw)|yNBtY;hRy8YWVFLY_Gv42p8SND0fH&;{6ZJzV@!>w<tWekOiRdg%(
zzxBS(t6ILkyEL_I&f*5gkmW}Iw{8mi>8COGK*p7uUQQaq0UliodnP)XrruPzAH{L$
zz>WnQ*~-g|-`tzHa{31&#zo7FpP&4}ki?L3ps?Zn4P%jqe|_pTPTiL*JM>2-M>MDJ
z+Mi3ejMDGr-V(Oz@jAbH-fS)Yz0vCgomX%iNwrGh7dU;q>c9tK=_2m7Wa&9UUYU$b
z1SKUmHwvyO)%fh6d%o*pLT8k=chi*5V!PW}d(C$}nfoTE>H1tb-|8E?`h{Lv>Utf2
zxU0+hitVALE3<cg$hq|3<3zO-)$%;yy)PAxHy!aiCCx4Iu&R8;+RE9#N`6my**>M{
zm1n&2qVg#_I28lsSZ$@&Pq(xw_T%sqk9XyF2)FnaW0fPwT(?RzTSrFL^v{CXHWSxR
zo$)&Ux90QJH-yDkCSC}w%w9ZU-^aJLoZ@>QG5joiRF_)9RmYcI$ZD#{Z@@k&X|=8B
zMYCY`NxPH3NxThx_VNAyHFIBml&xN?`Z4x}(}Rx7vy95t>Ym|q)LFE0tzmBwo5H6;
zuMcjrFS0irn`}7S`&s<n)El=R@M+0;SQS5?bM4QDrCX0GHuoF6wl`DyJ~im*M<;!Y
z%$-G7O+@}iF=SiGI!&5+EcnN<7H3b7_778=?AM-Oe)PJ|TjA5G#}5_Ee6`g;JTB%+
zu))-|%u1K@ip{m1W+&v9iFe*&yd|{Zy^T}siuiZJ<ue^uPy4HQJn!VxXr9}?dm8h+
zLT-FFu{7WMJ+nfm@>p+tWVM9VJ#NXU)oEfODrWybq*&w}QFO^oI?^Fv_+rz$Wxv1t
zD>f;8;(wq^-c2OsQ}NR2N_DSP{?9Gm==!`<<WgMMg$3%f_~-mv%w>2v?dlJ`#Vi{7
zcU#n=Z(KDOZOor~K5g|Be_c`i-<j?8?v5)=)h^C{lvv<!?agh2v)Xe%JUnu>Xt(^)
zyej2Y3lB<!UsmVqYFkpv^~ql8e$lg56UJ|cYK3K%p7h^d{D8q@QK@*v?*1C#%}bBC
z<jvoDD3tX>Q(qWoa9-WQ>P_#y+8v*{S?S`r`Ra~YH&gW8n)!K7MK8O(=)}d&@{R+a
z*{l{sp1a(&EO`IZbeWJ&=DO+ZYp3kV=X>=!^jwhg*4sMw`7fV!<ZRdy`>L`lC3jkn
zZn@^vyTSsyH@;aT5q`RnD?P$v;zQ=y!7eURTMUyFpBk}Ui4+!M+G6`}r>aM)UPt?v
z-YnzRiVRNUJHCmpXFW}~4GT8ceg0DH@uY_}MQ=GCX>6_xXUh@#7{0ASOKD4pq`{wK
zujE+V^Pk0M-<(iWa{kuzN%QY0-Ktobal87{8jG|=-{aQ2m|e{k!1&PSX<KR7#;egu
z8{41lC|tC@$ye{W_^xf1lUk0;H~EKuxOXKz^-bIqo8w>Q_?g<`wxmn$U8U~lcZKic
z>KSuhUfdj`8aB;0htHw(uurM*viYm7C@naBG+D{}&E40=5^v-l_fD%hzKQ*6()7$z
zfiC|AO-+Ne_WoL+v&sI?$E~d#J2`76AKWATthaUdvI8yC-?rqr2;Z0$_)PU_;fL;L
z`4?W8E#WALKAyQMc4=7iin?M2)k6ky7J|!r7wbNJk-OEox_Gnm<1E)(b28m*jut&_
z6gafy(7CW~i+hnysv@2KnF-&#e-$oNeRb%7^ke7G)2kQc?=n@LS7UB6^Zc^?H{F#c
zUJLcmZ18#2W$zKf@T)jt)ys!};=9+c+kdn*_2qH3-IsJeSlr*O@#VSk!Tu$8cnm${
z4L>Lc-BC^N)^mSYaivA&;?g>qlI^n<{ztX{T~xxXztO_xBGbZEn>b&}$hod@tVpn9
z_5JG_SFr0oM|^tBj25@uLH@b7kB0A?Ai5^MqvO*i7EKoA%S|dqT2V3ErcIUoI&F`<
z>d9|Bq1zAaJ^OUd?LV5Ud^MF%?X=MhKX19_^l3KjtFL!tEB2jK$(_P1Zm6!P^trgZ
zIQsnFMB`|Y+xr84M2EjU9KTR+X<J><-Svl-6d4Gfe7CjWGH-(0+z*?3S=QGt(2)_-
z>54dzuBIYy{A=OU$z^&vagsg7OB6-l>=RV^B02Hex5C)hKTI!t4nMF?C8=IdMeO7?
zlj|LSRHv<LPZPdX@muuCKJkY)7w<Fp@#(3?-c163j~IXV$=@OI?Pl?2rM-(1!b1yM
z<-gZWdSo3n|DN=@-EUL;7xsRhcy7m?pVj7nzXxf3@W`Dgzjph)lY+I!w{`ujTV{QB
zW9-pqC$6Vl-w;{Op|o^+$@)~0z|9=m({nfts%y91?Oxa@>BwOdeokkm+a!U^oVy|4
z4s$G-uGF8mWr~=HOi<VTUu6$3H=bMk(kd%;U9eDU=EmSZ77`MnHD4@W2?TF#H7zW8
zx2nq5?a|=_-X3*I{ZZP+EGw4C*7b|6v~qLo=yu+J<Hv+5?*}zLTaSI?N#3m<;rlU1
z=3-IcCeaDHL5VB6cFcP4@uy{@n3qA4vih2bYlURoxMHp`+CFIS-zHJ2%=D`9&SvAZ
zS)YGuxPJBBw&+oT$?b}3TaQhiaGSNH{a=qoe{XJoQEx<b`5VvMizm$u|99rIg;{U!
zh9iuL=by1D|IIeoqons)%`aG!?ORLih8aQfS#N_LC>+{5OEyoV&3=B;spG%(lk$sa
zxgOVhdRK1-<M&CnUyZk@eU@9BZ@TA3TUq8^_TVK+rx$U2*|tH!sKA;1dS#|&-EFgt
zS1!g2zuL8RwMY~1v#ncL^iGA`->~@ImS^sQyKC>t<UaFqS@x!AL0RYm_qJOV>`euF
zmp-0-`pL(?NOgsK3-hP4b;T{4Cw=rNS2NK&e`-hk^gVNIeA&O42Ba;`US7P;DLDOY
zmRj9{h}rXQTTPeuzx8I)CCybUcJ6Uj47={U-{&t+ZjOV(X{{S2s+-+{o*ISthb%g|
z{PXQ)KkX!XKmBod`b9${e$STp`AgpB?)vzlvY&C+OSTzKHLCxF$~GMq7WG-^8E7<R
zgP{9s3#C>=ljf4+bIvB{C7AvG)igt6S>JYUt2B9EfxFkv{P_6s_c=S>S%0kzj~-p+
zYqRKQZPfO;#~8DZt(z`$M|pNY(e8~iCx-_&YK9pdJv^KLY5t>=&lU)&GfUg*`~DJY
zpK;<<>$)q_@)O>2S{IoWzB(s#W3iayRMBUl2RHAt?7UF+a)X8C^LG71?(0OiHl%lb
zxOTyCE^BD#^z2i4(vhqJ;^)&J{c$;U{*lXD1<ebO1f648?|01K>7DMQC>MS;JYb8N
zzVrPzb9dN?Hs5WVe`zuI=e1TmwK2X;N{od^?q6d|RsVZ<N{8?kubH|M4Z8(>ESo3k
zw<(#Q>ny(fH!de^`Ckzp7XO+%pC_2)7K9XU*DCaQH%0IFouXhjXMK6?UsCtJ2hYE-
z(SmjA%fI|>i~s1YKJFlDHluc8^b^T#xhc-FQ~nFTs4jcB=I^P()XT-f=O)}d;n3Oh
z%2Vh3-VDK0io8;5UZ!1P;I;iXqsIP&W8<2)Q_9{bxa!s3J%8J#qr^frc>Xro|9@Gy
z{j0o_-m^3AUGwmH&ZFtem`VjD&t6~lEm}3tX-OJi=I-f-j|RQ?`XGuiRp8|AZTye6
z>~g>O{?9kT%nMV_d^B}B(zkxm($0#=_1BZ)Hb!@}Tuc!Na$VcSt$20bf2mt>W=b^?
zJkRA_r#x)EXXat0mM5=pSNrMX>1S8Uo|^sGXIZ#pcG?-Uq%XIl{{CT!y1sa?#=Dxc
zb!$AB4Vq48pKDO*ntF9(%sDr|l=QPbb*lWIPV7~l@>VI)ZOt3yt|X0&MfcAe23+Qx
zqWw~AbAG~V^WBeUO!g@-sAcIinD=Ez?T<4Ft6qI-o*n+WB=*mn)QGim*75db=l-mn
zZNII*zxHR<-Lr3}^giABqUxsV{i{pu6f*c?gPFdE9%-Kv^l!$7q<s^9G^@SeGB;x*
zp9*jF++X^djBa<XT;%r)$~#>xXtMoFinf`3kukeTwZbfmPrH0`Ycl6P`82Ukb9>Aq
zL3<f@ubDx%Z$GW=a1WDc?)$T8wd~3(adUQ9d}3R<?fZ^@4*Ms>f1Yz=y`Kc5!E)Ji
zEE}iE-ETho>vY=DMM|xF&kSa6YI;_@a8K6xRTZ|Og4ODI^$C})-Y6})y@hw@v;E60
z+2XU#eq5r?^8BI0lxNot_fAW_e{q{rn~Z99nb5`dO{x<(9VDY=^Ly_5JUQ+qbk`%u
z%vwW4U|EP^laln7TM1dF=a+g<I37Bo-_K6+gU$Y}8|${st*Vb&-uO~B<I21prj6;R
z%rB{w`K{FOit;;bC0W#wwC(=1>6wn9f7VDVeiw<@<}v-zLFxZS+EWibd}HU>`RfH^
zoU`2hi7%GdF7oruTBdRKOVA(vzXAH8OdE|vS~kqttGIX>8$<m30`7>zfkz~{>*oKu
zxcl9M8LrQng?+n4%q~scdr--Bjp407E=PFo*3MY4D{!Oe)HN?AZvGSUz2(S(RP$7E
zrtpW)<KM>?=P!8{qyJ=?<}|UexB#t|zfRVi*0X#x-1)QXEyXT{Gdw%yV-YS>{?q30
zvQM9ao8{#0B>xiUJ1?ZGH^r1;eO=pQ1?&Iv_1cqH2xP_0Vz1lCk|-{*z|*pJ>NZBv
zI_VWFC)94$*WD@7x^HGq)M}rdyvL=!Yh0ZCtLAHvJx{2`$q2@;HN_6f(TcqO0+KB;
z8;e9^qPDEv<8g1fiNYG;wQ29$E(hAIF7_6dnWD}-_rw9|&7s@vXDV;5{Q9wb(iX)#
z6_aks{9V9S=JuD<X0E}n%<~1CKA%hu;pQ*VyPMQvdTAf~zhCWd-&~)uV%t34^R;v4
zTCemwHl2Udl1rK_YImlmMXdRH?AWH-b^Eg}@0NP8vM=h>g`H-V6W4w45@(N}v|Pv2
zOL@%#Uppg<oF|o688$u7`niGqO+WX&^&YL)OLQj1opMR^%Q9qI65rk;!@^N~y?lS_
zWn<<|H8pXeGN&e#roZ_0#_UD#kLlU|*8eBJemH-9k;tiMbu3ny2}cWf_gr<DnYB|Q
zQrKu+=+ij`Yxt(9$wqe`4i?+BZ=>?}mnJexwmh;=xt$T=Wty~W#f-QQb@qDOx>rqU
zIcwwQv1YQxZD(KR<wk8qp8m6zwz5}W6xR_p%~i@hyE*&%4Vi};mzdmhLJIi~X*OD#
zt=lg2Jx5I|(NN=V@tf0OJ}>l4RqKSm&d~4JnsG(jA>waVCDYzgHT7AKa`vCOc|ZP5
zgv9le-(yoQy6=+z^0{(byK#Swg<sF1kEgh%&a;syuFQ{|+_UX%+~Xw;A7k@Y<vcLD
z>B8V1c4b|82$OJH$j(hatTf+#J!Po;&~fc^?}Q`bdVJQm7>|2RFPj*UHvN{Qyp^<T
z<CM(|>&`M?IUXFci8tOeX#LuwdT#3yZf|{VC;cky_>PsUBRxMGcX5@icij@9dFK_|
zqo>`iKPncfs-_j3&@0w^-LzD8(#E%ji{{n`wnVpH_{@Fy{4?*2B_;J4)!n+E!~UH6
zG$)Rs_5RP@I>+o3a!zjlJNtHGkLQAOx3?@)+GS8ArpGrY?Y{2m@3v8I*;Q=Wvfbxt
zy6t7#>!-42g$%P$NPtPU$l@fu#gi9Qv)Vo`*dgJx!7h5L#gpG$)*GZ!y_cp275cO+
z=vC@z<}dv0{wL)6)XV8V<IOiZwmi;1A8~Bf)T@)iy3g#ZY^nVh`oL%U=Jdr*6IIXM
zViMZ0b9YG5x7W8<)gMmSJt^c=zzUb?YyM4IaUjgs!fKU^iLq$u;oQx&hYB?9eJ0-x
zd2{_*`@wdn%-aW?VuaPAs+N2Ud)=h6b%Wk=Wx*70o#h>!EFZd+Y9AOzB-c4iczoG8
zdA(1($+77f&weUQz8Jnom@D-BRl$7^rfSSytFkXbv_`W?Qh4{7-Om?1<DGGI$wT?+
zc41pi37)Up+%A^HkQVdGw|mQy8&i#LR2pzk+Va=s{=qgeVdHSeH>+Nq6=K|ZMt9rI
zT7~NB<IFPqg^Skh5G;DM=iB7Wzh+Hm1o!xJx2Ko?+BVO<@rpsAnf=xL_nUqdJzG3|
z#uQ`A=|!4<-%RqfdQdmx<FY#w3{Uw8EY+TM*7Z+x@HTr_7u)ZjSG-$q-RPvYF4SVh
zxw4ierFpXywxuvBzmv5W&sRMj+cu-$YrA)!_0i;m_ih!xdMTvmpggZ#=yI>od5h&H
z@=<v^CEs^Rnl?AFyn6GBLuQAn=$apsst(Q7*OrX+Zt)0fykF~L<$C07V8-+hu|dXD
z3M-121;+1RUv2IGcjwn_etXUZWp9tX=8~*`Q%UZ9Tlcj}<%J)*_Z(Qcv8Q$Q!VAf~
zheKmde{o@5I``RO2j0jsohIAa4rOIBnG<WIg|@0^Ojr`LrQe*}wB93!S;OGO)%Y)`
z*F0Ou?Wpm2k-4O6?6Ks98m)5nb$3&iOxPQhwf8=o!uiae!@tes&wdWSXtw=Z@k*s%
zMJ=c1Uu4;TN`G_kpCzJ?b>F3ZZo8Gdh<(*wjo;Txj~En3vX|7=7CkGgy4Ub+!aeVm
zbB>3^yytsz@=}(ovuOL$R|`H`R=t}(qe*|SQ?Z-Qiw>2f!{=X3G++E&<?sILt3PEg
zCG}qwmJPk;d&qsB>S3kjf$Byf9iqCcR__n{cP7T+$?YTS@>xDj67)3ioNp$)+wRO2
zuQ`(!&N`Pr^Wpp88@&AMC)DXx{BB(I<Ez9LEmiTg`|s)|8m7hucc(?<h!vLh7#*%Z
z6yvh?1D}@RGS5FxH_xzB*`_CuuE-aD^t|trcSiy;?|hHQeE%dwC(lqf>q#?X*REr&
zh0`ZYVyS$_?H>EQZDa4}kBd&O^jT%~@!rhU`7gP3q^`5(o^vbNF=Z3W!nc8}D(&VS
z((5-I;jlVkb#=j1%jwVNOYdY$dClazQ%kMv)tc*99R9AGzwy^~`wdrS2^C)#sp&KM
zqEN;DFskv)PKh7td-K=(7qTY>L^`t?CobJTrB!HpU8~moa~~U@%V_6cUH8>=(Ztlg
z=~}<f&+YjA{`kFTOd<hJYp2v{-6)K(UUuHFrfZv7sNDY_d9RNqt-rtI-KW*9-7hvA
zs>+q}ip{oc;VCy$^wbXKp5^YkcCoCEj=g!<)u2GtPa(DWDR(BtPyX>*_Onm6kGzQd
z#-qE^_a6>2x)S(lwdy{jxF;vi>BLPmy~Ct3e|KBDaEpHRC-J1D4fF3dcQMY)d-^&t
zewEioW!GCz<MtSvZ%Dh^aWC!cWA5)vb-O(pPfU_amWa)A<+k!xzw!Oq5&r8BrMi!>
zO}?gS8}T<}w_jh!f}I^V79W?4Q+=zE*QX*7dgr%PxT@==mfQ&rC99iCYNlPR$X3jk
zpC%9;aQ39!o6PcwlRq<_cCL=w(s`g#F5Xw^#Lpk<o9Y}dtvc*9cSVd@@9Oe3<t-L}
z-WC3ieIoQ|YC+lKHJe+~GncqkJ<`9f@P8(Mda(T2J(pV2Gw&CF&#wI=QtTyrcj~6;
z8?MW_trZQNHRY$l5AFZo9-k37bj5vLik1#fO}A8r<%WZQ{zWwG(%ZFXw`!2}`h%ZN
zd#t=KcHc3&-B)$9&qFQVjZ)$AojEUdUpV|_Qh4R(<9VxvratnqS5$i*al>xwkN#DB
z>!a6*t&oUKY+5dPF!lWXYnEJn)^@=`>qHNSG=(!~&USzOLW=Ee#g+7VZ)a+)agBd?
zBacJ=O{UmQ+k(53x79ahuaqiGem_n8m71L)$Bbity7X-O=M>p$E!nJP*2Oz9+)Zc4
zrJ_KmCF_D-eRpFKjMMs|-|t*=eQuYy^Y-A#<*mNwvL4o^T)1;@s!NA!lI5HWi>=~k
zCG)@BG0*&4^V;s6_paPtnfvL=lfy@^?&N)Uec|iY0Grv<zKW+lKY6JCN7t1!)19)1
z8zN3wP2u3VFptYkqbYGlSae<PDv9rF@~=F7mOi6&R=j3#y2AW#VY?r`dMe5`cPZbM
zMXqnsCvvU5{B=Y3yf>>k7rv1X;>vBY)m|#mTNL10uWbBy$#Pv$>r~OS=FBOd*C`*B
zpUyUO-Gr8ugK06#7awwI&uag=cR^*;je}jQS)^6+wif4V?JASB<~;XhbD^NiGY!`E
zIqMuh`+VBevzlkqzWs{lUoVjVoIEA}`&X}=eY5B0Xe{g9ZWrS{xnauhC;m!bzkCvF
zZ&>>6z$&e~J5^RDevZ4(p*(4o)0zjS$4(hYEWSLu=lY{~>3fTJ*cw+|e)qd>Px`T`
zY?4QxOMF_iO4Rv9x<r<#&bOnYO4of)d|k~p>;2pH8H#&++1&-(m>%hF|GhghdEahz
z*E><m?wg;NEnd!k<l?1HjVl(Jk#YQHB6S~UN%`$yKDPfr(rq`--Qs(L(>Gb)IAG@;
zal+Sm+XDY<=@-23e)rp%d+2oS$9YX@iS272SEcVhHvd@nm7I0b`Wr--cL&{$yT12l
z-RV=3AKym&d9JM}Ho0tdO72^`sB1^{i#zV!)p_<Uq~NpM?30NTeSM9^k6F31+~eb6
z%M~{?{GEMwPV2XO>)vi^JFqu5bX&)i2lGT0F}U+`-#fe_Oyu(dr|5s2&m*PcnHTM0
zJpaCFYMg7-{hiB}UQj73l+<er+Iw6~;rOKO$G3B{%#mYc6Pj<gj$<p6MBS1%wOxVh
zqNHv;(%+IGRdG-C{`|6=3vWDc+bhC-N%ZcnQ{Id6GR1DEIaammwQnm<`FP{|TH84;
z|5p5qtgyF#ueFPzE2s49s*OC#H;=1j$<KGK|H;)pmo*}Gi(x{Iw|sJrQj<#k@oA^B
z)<`c+p4B+(_KZyyQ)MS#br*lZ=v2Qw<YtV7ns{wGXK7XDmY>3#cK=S3=UyF|v9dNf
zx%_b3`pUmQGmiD^EbYB0$~-5X@5-c^VXwlrO_j}A-WPND>T9Q`Z}-MZC^1f&w!7!Z
z!E%AFmS-yx%R@z`es7r=x+m<;`W^2s2cF-%JYd<X->;Vy{0J@3$!v9!^Rv#3+i<X9
zmcG%(Z?>HGs`n<nd7D+cfq!9&W!LnD{Eg-h98bJ>vw^4csc|L$oMW{ThEJZEs(E~x
zSwHQQo9Z0~J;73?o2;@r<|zfMislM9x=;T4HrC?oor!!uuWz2wytc|MnOoD!u-j)>
zPT{(VN1Up4_65gZc60IhTmCXR^Tavso6lL-m8`ucF8lPzgwK9Auf3G&IVAf^f3`JK
zotEg9gUjmHC;U0M`LXn&!skan?s76++m>ymF<HiXkw=!~9BI}M=cAu03BTOnnZg&*
zQo39wZf(8%f>+ym+o#oCx6}NwrbT53&#f!7^>3{-caeAVOTU)Yzbq!?!epPVF9J<M
zYyM_9|6J!$yXWl$pAGxNdot^;UDTH<-Xh*2z$s-stMbJ2=J&kYE0Ys#CQcNO_-U|c
z(Vh=QS}&(f``%pqM=Wclz@2Po{*w$F5AZJA`L~;SzVqVM%{>O5{kN(oFZ1av{V|dC
zeL$mTTz{Z%hk@L82f?~intN@tPsHkM6ZsUr%71pU;4KCA_mx){-YdAI6urd7>d;%>
z%W=UI-T9WVFQ52SsodUnx(C~ukTVu3N4C$fbvKu_pLA-`=YRY;b<#@M7O)vB7%1c?
zWpUZqz!s?)Di|7@!jEt?QZThNHGs(>FJLpXu&^Y00b3Yrh)C4-Wzo9?WgNV+UI?fx
zakg5*E|Jh7nb5}Osmk(FMDXRLDS1nRC%h9_;*u%Ba&N`=|L=GIug>1PJ#FpG;&0o(
z+f~p1Tbs@+y?LA5`Z>C1q}H%BD^;-mXqeP+eAX@{28DnQehv|pgyhTZ3UdzDuVKk)
zODMNsVVn9V|3`AU0Y~E|%?1Gtb6*LO1<xMx2naB7ba-)fcrrCII4T4@itjTh_iSJ~
zA)Lg0;R*AKg9{QY7;h)fSlw@Z<Q`+A)zf%yhUL8C4h~LEJ<rQ69L}-6;oHdQ$T&-(
zh4}_+=_1|}k_*^3H#P{`{r5Pi`Lw}dhu5di)s>YW8)F{S7?l5ZkFjCU=QzZ;fV-{v
zuI<5X4e@W8<~76|*f0H9If40wwZnt@GgSuGE#fC+c^o9?D4Hc`$cR2*+{(I}IUt?+
zONc2$)VhQh^69<yd^QdH*Rd%aQ2+40q~7(v7fa(mKDL`T4#dPb2FP<<kxO7NWMkek
z#pH*;Jq|erj;!CO1)uP=FMQ-UPocy3gw)dyy9)#yJpI@ioW6b!FE5ZT@6cvC$KG!7
z|J8*5;Zj#rwViV1568qD2w<7>AiS1KpnL=Gt82AC>ie&9a(!<4^*8di<AQBv`=d5|
zEqH3);B?34z$&i#$^||w^|#*~<Y?d!;1CfOXK%R6kdQCU{xAOI*V>qa`yCtO(?b3-
z)~z!LZ;)NZTEK9GujiNIhvsIRgA6UZ*)0yd-_QL2jvxmILyn>uM}z4NIVRN~*4C$Z
zw*B7h?t4%65w8L3q7HQihJU~QRHybmnx@P1>doivzu!Onl$|XpDPi~Q-`x-U6)P)e
zm>=j5XW)1sD#EyE2bTz2$3ij2|7RBQHvI`@{qQ~_bcHOB!pG$iS9JfbPB_1R+4-N-
z4R$d6Kl7EPElEe>z)$moXB(6pq_0dr@PGER{m%c)%l@DGR4?$y{&nD|g0g?TMgN-q
zvvU<STKxXgy7<SdMu)<9;kF=#FZQv$2kM`!;@s9+vEz^WsxF3wCJO9Z%l~~>b$Z|>
zkiTKA8B5~h5A9m@Z`k&;JmYC>+L~B!Vm&)+gOtDrdxI&fa^?i|v&kGieqTUBbymIH
zN{+3KH~$4qU(lh!@Z=reCq;)|iLJtnKR6epWN?4`cQ%2+US6clp_L)vEi1#Dgm*0a
zpK0naK5)17-rvLW-y`So!*_j?uD(CG*zfQ4f7{y*CggA6J$T3D%(KK9$)ypeU6;x<
zi@$%i;!FBA-^C_+ar-U5hw-Zz<{5>%rk&{eJu~K$gZRrwZA#BqzWK8^d;i{J{5u}{
zc3Pbc|7WlJxb(RBY|b?M!0&xe-=4hs#o*EXr&p)n{j|UAvpG-Mp&Xa|@Z{5Fp9R#f
zom;r$!>h1w>t1R`O4J$dUAZ|_ah2bX%_&Xh#}sbq>?oM@cJ9~Nno(jhEc(j#m_Nzi
zQ<=Oxeg4V&eRuB#cRyF-xX~|o>br5IXicf*)7>G<^f}%y*zKS0bh@L`%g*N9JN5l@
z7r7Zf4xh6BhV|>a8dK}vzm=VL#WgNyU+%%{q5^lPU-;D@I`43CE>rxb$&86IJbOjr
zg;saH*3`Wlxn+gcEZz7Zg;gzc4)om4E&KHOO4_c=XKFZ?NB*o{%A6}QBZsAMmu=z2
zKkJ$H9pCw3f5mL&?F^NnN+w$!cE65~dok(#-(%*76`aa{G3VM;?3=Qp`fOd<O`fvz
zVjFt@RvzBG?afrPopUa|bTyaW#IfIkKl|_Jj~}nDSpHt{-3<*MPfZuu<F}pme6)>F
z`m(9x-nzX>Vfz03!Bby$f3%$0yg}@WSEjy6dhC_?e%YFJZGj;n9s8sO17jckn)Ekx
z>CcZniSNU!3=1D=gdJM)ZMpKdTm84bXH2SJl+3H!UKG>4%S5GED|zC@=PUb9wX@&x
zWw_Vp-uo??`#Dd_-L)<E-$n&|39EcLA@J176K&}#-{$_A*|4{BdwA7B>lCMkIXVgK
zktUBXNNUep{pMhiN5GGZx8zUmGvBkhYNJKa{^REk-ghaBNf2|h_w2g-p`$nVe)7gg
zoAnO&ozUFN_%b_qQ_|VjulZZgaxQ%JyduB%#gXK@8z0Y$6o3BuldUA5fq<yeISEdW
z)KC@i`AY-BzSOH59{iM(f6JbsYSx4L2Wg?ccOTm5$KKLd?p$B?$t2I?pvAL;uZ~)5
zsw!LDaOP%efTqRy-9}}a`}7V^wlzMWQ#q$>SA>^Y$B~oGi!V<r)}1W$Nv=G9y}>l~
zEBUWKU(iwWpSiew?xqv7<yT$KG59^Lm;XRXQnLEtk2;yHd!<c^PcGDSU$e0NPZOtD
z@D6S-^=Y?eI$rm?dP%)2zWzy6^%UI|^RC!^d%~h{f2ncV^=n@97rzzwHvIwjYdP6%
z(|kOS?(3`K_*^8VeJ5xV>$<EWUeo=nwrvnfdcBm-bJMn}ru|;a<*(gSeCDxGrp9pT
z;>_w$b)!cGwZCS3FV=75eBU6F{AOj;vcx|=zE1x)E;L;8qTu4A+e>OWJI_b|<~kE{
zXXA?FJR8$qn=W*E9H=6ty!_7U9h>jS%y3?Ns=S5!-QH)qJ34hU^Ir<}D;7PRclqWU
zi`TJvOHb?Wvc17oal>@;CZBz4eyvDy{gY9BbjRnjb0fPOet&%?6o0mYU&gBawaxZV
z{A~LJd-#0a-!oKg$q_QE{;(u=QpEX*QoFuqniyP}<REfuUs~W<d)0||E|<T!wsrEt
zFPtY1&7Tlc-!CY5PO$!TP|*Kho?7g;7P<BOd&(quR9t7y{fe~6FCy`(drrM!7kV_M
z-r@Eqjc%9!2bY-!M5g`AG~V2ry6&~%AERBDuDDj#7HUk*ImG&AR>BSKCh3UTp5CAS
zb*M&{Jn;Ka=6mMcrL&UGX>H!xWpeBGJvk7UcfaBE$-|$RxLX7CtWIuIyCb&3zu093
zx8U-fujW}@mYAxxGWTA)y2o;-b<=Y<Nx!|?UREV)sI-3m!uy>zg4Q=`c5FV-y1v#<
zRM{ZtTGpyt(}Ldq^?7{jw9oumS#t47lJ4`re&(5^*75EguVMdMYmHX!y?U3$tLnD~
zx4zu<W77?{Mp^$Ssb?qJ_B!W%T2}PClIx}5X9ijJ&fAew?i>{6F~3vB$@(WyW5=r1
z56$LyTtB(Bd|h=)-u)W^a@u8~N$g+M)mz_RvRi-IOO^M%Z%nE7J3dCEKW&+Z9XFnS
ze6Z}!g70rz)h`C+sDIqLec!xFvD<dKtB*+=UlX5Z=y#~a%^>)_L9$Tb@h3h({@lwH
z<JxCz?4CHc^;2c3iTa}HtaA(OpG@RCx8U|$pZVQfSFX%qJ9qS8$;nUWIzFHN%5D5v
ztxLrtJh^6JtH_7fS>>l^>+u{u*Ke(GwPm8nFN?;yZPtA+A~}N<?$@Zanc7P?MYEpV
zm-Vb-gQ7)7+tw}5Z$-!-;*46v*K_d5zAa53<uYSrj;**i+0cq3^+TT3NgLhZ`Zxb>
zX}B8*{BB)awD|WgkAj+LoewuAod~%4^|bBrsho=cu15-UWnGP`UAJI?d4;nm|K}?q
z)i+$V<WF+%TWkLKLd+@_!PhQMF~z~_Cshg;*_yoQzOn5k=ToIa5%LqShAz14Fzw0r
zgs3Pk?+<mmEXsFvzbaj3QsEQq+r0i6_o`XXmzym5`9}R{<h~h+mlj?;o^;ZNcixlM
zb$oGwCY?bu;t$n)6koaGobeo0-xu%RPW>7*`?_UVjz-`s{kNIZkG_`Nuqs>WXnx(K
z6&!U|j&>ir_Ulx;u_@R6SI%Z!`)_LCVh@wdzy+Gcf|IQeJ)PvyyHhPmrRtwaRn(ha
zv(tW2&s%=KNdDjRz4yoxvzcs9{O6x}{K<B2LBi_YArk8C{R@J(P4K9bTHW_pXZP*B
z>n;YxI{g2!g8S|*`_&F^{nttg{?+X`ndvmEA~sd|*^@09SK64n<r^}bwC4R@YwG)G
z-Urj`=KQjy=1u9-r!niOi%aEfOqp|fYd}%y+*j96ZCE_NEJ(>cq2#cUw%gie=R4-`
zuJ!wN>XUf%`TQ7jAG>z{z^i)|%zC#tm}{3<ZrS6)ZoI~_cX?jWgvXB$-dnm(*Kqw(
z3zqid&$q-}G@QaSX&uMjXNq+v?EmLV_NMe)%~mXbe@=C2B<II>Uh@m`l~mi${p)D(
zzW?2Non2zN(auR$652X`x}UsWm;ch@SaG<1TIqhSAmzBTQ>RYPzyI(@h1T8tsh+31
zAH4S{sCklo>dn;jvuTnCrip|$-IEPFwy(qF{I|o?*FTh5cj1?2tL!hq$`av&x&lt?
zz9sCR?ftmIZ0gEA3lyI&6qRHzZ3!^HdPQW~tJsqUiT@Xt*_;dEkoi?|<Ld8ylcN^z
z>UOH<n6BRa(tTNBP>`XUX<GYcmxN0Pzg&MZbMC$+^YXKuZPe$rZkM<{`S{yqe-#~X
zS{gjM^s14+-|9hp<cV9_fAT)o8utjLm`apd+sdBWIM33>HbiFil11Kz3cWe=!<Tu#
zc`cY7b>AiWo$54UyJsOYpQYScv%c(?<lG+rjQtP1N}B~12`g&tsWyFnp($<QrOVl$
z`qtdD+S`-a$5FZPXv@5(4^!S-zFsNv@$a!sjy9nx$JIk~Tzohyer@c2^<dhyuMWnF
zzt46$hHc^ff5iM^qx?DcSLPe@e%q(pulzR8C`9k#&OJ|jCtKaW*FDu>-~NJDVat_C
zwxW~5yd=Chm+2;??p;yV-Iu~^bYSh?h|^_}Ka@J0e|0K<Dw4^3eCPSkzuU?ZlRB5V
z7+!yUF7r{!mEw{x=i_r1eENO=_o7ht$%dbp?S(&ZpXi-b7;97G`}6MFut^tN=Ugal
zJpb<GtB2LnFQ@%cFZh3W<I0oA-Y{*yrWqymWy<Dj{jWVk#hBw>FW&vi|MkmRqKr%O
z%bv;^7subsIbBiy!rP9Qv+ItS#FSH4UC*&jlNI2f_H>7cxVo1TZy3*Hja!qp&gT5$
zyW{(}Ge4(3&%bz9+QcHNx~AZ2j&beZ+__7IyMC3f-6xbQm;UtUz6<-e_q<p5C9Dx6
zKL4|on(M=^R_P~Zvw8)0XwOnJeYEX$=Dk<d>n}VL@tnBok;{b4pfus-n;bI5r)&=M
z-(7dzv*t}!qh`R(9bDd;a^m9i9vHf|J$$+Psh-CC_GQ9$6W{kuwpeZdkL5vzPsbc(
z(`UQ7PDD?=e8W?A!%CL!UuLZ#lcxFAB|kD=r6pVy5Tepz@%*=;v1s(Z>V-+}4}ULq
zRleYD>GE~ci!vUk!~K^-7rZ}K_LEiXc<6&Q)}q~!b-5eE)(RAb`b8REw5vF@KfzjQ
zabHK5OI`Shdes-#u0CJUuyMlmTb(zxf6jfPJh4pj$hk#no{YDbuL?fDsOrL+bJ}go
z9~<;oY){p_|IhEY;N>G{jT(Kw@8a8hcJ;-dVlsZGn!fD1slWYiukP27OGYnar1xpI
ze6}mEeivjm%UW%Pq;f@gLAm7Xhf2rKbY4wwT4K!jz9#pbiHSbPiFx*~=SMB7WbWOt
zfj8!<p|{0iv4qLB6P_;jXWr})c5^}IETe0uwocNmcy>u)%CrB6?=4ogc&)Wc@L|=h
zlusOIe&^K~vv_1WG~D%VyS{hc#&3yj6@iay>df759om$6IWL#Vk?&YvW&HE`hk8wP
z4;<ZjIo9orr0WNd=f9P-rLP1q&Hm=xcWLM9wC@pj{xm+#e78trTl;?de^#e2cGbw;
zeOCHqt9Hlw%$?rr``4;nI*_yK_{7Bl$6j&WU6<qdx54s6-1OxQ?JtTofB!t~@=2}T
zV)+v1_=~3Na+K~QtPyKV(A>ML!TsiE=I>wnxo5vKymj12ZQ0$b##}x*;|&#-37M7q
zlfM{WH<&u1^Wn=&uQewezhOR8PyJc=?q^4)yt;imeD%R@lUX-<&v<JGn=Z1j;Q97%
z5l@n*#xzaKDrV*F)p@(sR^&^T<=DHnX3P2iFJ0bX;QEZ=K<jaN&u8fca;IKOoPBV2
zmWsDmO~N(HHy751x#$?_2ro7GmbpC5Y~`e~7WT8-*7dDdJ6StP*V}Skf_R$5)w`NM
z4<)|UOFdlXJAKt+kGgH4tT9SYR!%(mYj&vQJ;&WVbALp0A6Uro*EQzy$6BHFl1w?)
zwL1?j731anWV>tj&ze0mJ6jJ0<c7Ufc^B$^;NTu(=H)BRZ%q(dcupu*js4_1O}R5a
zU7Zj6F}!T-iqqnK-cicGXja%HjT*+)&v%;t+f$#S!pM3nrl4?-+opnF%PmfA3f!Hq
zw_V)x<u&hU`6G9Os*9J;3)&rf>cz+Hj;SxsT&%FU&amly>9ZT23vADxiT<_d<4;z<
zSrrGLCLXh_`uel?dD0$Pzq5L#OK!Nl+Wy7Hsqws3&X&}3bA{Q&MehlI<&Y?zApC0Y
z{u^rZ>SjOQ9%T8bLO^lZ<SQ0WdDg0KeRpHinjkgTk{qkW-*4@DT(cy1$A?@c*5@fJ
zKLvfcyEJ6sqVSVBGjF$A|G4nNXI}L3y!7MmrfXN$o?(oa%xB*6OhWmUP+Qsa?_RY@
z9`l|bKWUq7KU;M#2d{-t?WO%LzJW4}SAP{!_UJ3Hy?%YwomCOcIlt<{gjQtE?fCd?
z8q4-j)0G>=e*Kj!JbCJl%l>bRkKAIG)7`b&U%T|ms#=+K$8Van&K1+#l+ZtS;lwYU
z+r0&>D&?#mcxrS1^?m<2DqQZiz!}%2*J~e2+`l%{##jB`HX)aSKR)MHY~QxSYki3B
zv$Z*uC%j9_@@lsnl9SL|Uv}+ZgRhO+o-B>5ygcXirn~BQWlyrbC8(d}_WYga<Yt=_
zH)o1ktTbshFgBG}zrDVscz4Fx-RA3cmP_ci?7X<taHV;~k>5T0PL+uNoXNA}%2e0u
zJhIN0tS+AH+H6xi+qW<wy*~ZN<E1l%cR2jhSbv!N*PM5Itz@s4hWosK_LwPIwIEBI
z*?x7`-<H2`LOuVrzdrE$vCiv*qH8O7l|O|VsQKvWl+Kr`mYL>M`ndH$@tp^M7rYGT
zH9S0z?bocuv+HKKRFuu<`xdgu@aesISC^HU)+9~W_$ekGcKxH(rvD3h^$xr5%1^vu
z?A-1gv|f6@h}>4?wfrR<kL33-zWAAVaJkRB>1UF5d|lqdV>c(sa+2VC(X2R^`t`3Q
z4(VNEe^M}iR{x%Z(ks8N`gH16MiFmqiMq2@ioNR-<v&j=n79RB7B4i4<5%x{bLGOc
z6y?sVfy*BWH0I=0s)(o``Jw#n&Wq`bTCQA`zA7)euv7A9Si-LJddnSNz5MBai!-LS
zQR2$N_x%qGUpakRw!FREZ1sN4jEuDPUyXJ<KC8WdyJ$Vzw*89?>&rz?T~fRAr|#e5
zc}pzk@BEji;k)O8=gRyUe;=LQ8qpZD^`Yggjq%fu{L6XnJm>xAnO5b8+9zkavHRZ&
ziCiKda#~;NaCgB?d6$zdGgQ~R?)yJ2=I_<~4evGYhYE|WbKJG%X?O0OlUWO2t?D)3
zc=kqMT=7K51H#AZPS?D>BHVK4nfC&Vxozo-oFd;IUL1b=$m?tGpZl=f|7GW46~Esw
z;dO*%-`T|(@h?jXH+j}B=5;D_E<MzGSGt#f{bH`}RbDe*CZF%t&yaq3GNjk()!*tI
zea*Y8_c;4Ia_YX-%*m>ePp`<{cwg|_rfe(o=OKTW)OMs*+W*sSIr&psJd@cs#`DIV
zz19EBL{AmFet-XB*5#by8;`ZqQ}1mNVpHihsXr^JH&6Ygoz~lqzne@h>^bba++*(y
z;XU)!icU<Mf5G6mzHQIC8-a}rd5&41tk@cJMM3;tbolujI{s`XsXuq@UA*G6@eixL
z`u}TGS0DHi7%u;4^`@7TCr^7^dVQg<qgm#g>8XAC-zKi){;q!Q;;+X!lE%S%K8kL)
zn-{$5ttY$Mx4j=~d}Z?V!&l9knCSiULD^%ufb!2V)=c8}A9lz7=jJ@;xaDxRd+17r
zyHfVPd)hC3+-K78TxC@r_j+>%sdem!MSa?MqYWn}*t{1#*xk78?&FKsn667sYMK=_
z^HHT=!Jk97W9Mi;&*|plyW#sTXVFEkSxeT1gvht-+jEEA=}E}+c00RP;Yb$U+wV(C
z#h<>dpEcS3*!yYLvBw!#X9Ul>a`paMskhS@WS(8CaIIcm9<p`m%k3|(#BA$bK55fq
zYcV(0sr=j5?fkUIzLzPW@bnVvGjktqvSQz4mdnYm^y>P{{cXQq@OLI=N4GBP-)K7F
z`&YGNY#WR<Eq-{uOgWM8=-IxN!moX{Urw2+`6<lwOz{NW7mhai`n^1blClqX`!6>R
zGh6PL*geJRyVb!j&#Y|h7EHR%oNT!^^@G{`)Zl3@KLU$?+0E+aycH-c>swZBzOJs~
zMsnZTe?`$P4}ZiSO)q@BMKgBsso(kL%UmShIi|*nwv=z*av;UC`f6rww`{Xyo#6HP
zg<8!*9L}#K^xn3VUGVX1+O=!_vb}W`j+Y`&ABnicxxW65plw>dh;Z${TPZVFK5klb
zG06Rg&D(YNoBuhn%}(*Tx6boH_{@&8wY!-mdnErq+`d!yqyKk<ta<H!DqMCn?|c2Q
zQCQw%)%3`PQupn@9@(igyIrUH7uUlDED=1{D_^D71u06mhyT?4v*YExz<XH?u`4V4
zQ#XCy;3;@r_46Z_W~IUnE?LgUr<GmawCQhRT!nU@Xx=yVT*m$W2SvV2x$x#hcyOfG
z=eldZ)*jX^v(Ue`KQ;fPtY)><SLyT@`Ug_C&sm{%SK(*aQuWY3RdQu({rUfBT7=K#
z>Ps!xG&lLU`ub#Bt0~8{Ip2Q@yc~Qy?LqupjxS8=eu_GW+SX6gcpOtSd!v=Dn((=+
z5zhNg&R_fPVn(-TP<-vDfS8Lb*&?Mr>CZB#zQm*Aq&@w-@I!vxcaw`l-`U+u5h$+z
zKS{=>F6+Uc*3UY-)=Tuy-se?X^!#Vbg-w$lPJigPuH$Hu$>g0nY!#C{Zun^Won!Hx
z{rIwqVtW#E>FP-yKl_SQSWo}4X?;~!?mF{iW}~?B)9q5v<{CFwrgSotZ9o1@rN$+=
zOngqIyuHRE-QzE}Ovn|o<+YA`qp<Hsk8$SKMM|~rxjvk%NYd}_|52D-_F`p?27lO(
zyebLinLjpc$w@qL<nD?9p&gmqf|l&dlVjg=DM+yXS76K>7TwVBqbX7EZckjjuw&C=
z)-~Dv3zGZP+vMch)pz7DEIrG=T&w*tf80lz%|(@mXFp?Jww7tNSzV6oj3oxio<D7`
zKjpK3uIl`_=40cccOO(@Qg!+txix8i^k^5U?)%8TRxRU%+50((lHPHJfiladyt#4I
z-u=i+r6;pry^TBeQp0ZMrujkd+Ehd=qqEh`JMOv7U%;ib#cR>K=a(*|&C6WBweRbl
z+1s=2z4<l2ncZ1&{6f&D&8d|JIzjI(q9w#H{aAWGXrlk&8!JM>Gk<>;epM1!^U36t
z$?cO%??gQ~puAJ`?v;BF{xem6%HND_g3T1$1e=+KA#6&`NWs$3*b>G=o?tUHFfuV#
z00E*-hzJqM5;phq)LE$@tF5|sw~0r&_jHpthlF;QG`C#R)b;Y>5b|m^;qdVGDEI6x
zse8Tm``+*S-v6&Z_kFHy`uCal&-_VyHgo24ozu#`vU!=(OGHB$I}4t-eQ0oP-1O>}
zlY_yGes-Q`tQ$7GICNKbVf`WovDy`@rDZw={!Wj(CYtrK@6Z#SyMbx1JXivb9v0+y
z$n3=8s_3*R!C-<okJ!(C#Y>?g8tE@Nw==H#%n&+(V}*2stJupokGZyQEp~VPd0y~D
z+F8Dqjt-8(zYqDQlr`--v{qNpq13zFdWEpoqOD7n1K2Zp+jsr`BhET|#@yYzH*0V_
zdHVEd^2;a3noG7$O?b{!b@1-nhFbyVD^{ytVf(Q=W<lFh;V=D%Dj0MeVy$=Fp1*-l
z=-Io}mt3ri7~FT5iacy9`rvTGA+~YF4F}m&(+9!n8jt*wx7zdWXsD0n6*$EFbM`y^
z_xD{2j>w;zcI}#ndb)QDzf2-`%R$+N2bObX*}S{=F2=#T<!rvQx4XH@sr#2M3%$$8
zY&H6!T<E=^X^Yqeq0syBS9eD4J~a34-HJO8`u1zH{9Wc4yUFH|o7l@IEUr6tGuAy<
zXD@G!TAX*6{fm3Ftbm7p%l-N35;BR*zhj$v+l@W=8OuL5Xr2C>+StVKKVe%y`2q$B
z9x)+C=7o9=E4FWyePO<HUBB@ce$^-DJ*VssoR@sb)3VU3f$czIz!m-j=g(de<|--w
z+Q9bXZ}i9eLJUldw+^hm+ZYxQZNc<`-<qrK(7!2xbIV(+nddhKHnTG})z|;Co4F|M
zG+SrEm!HS~^gnCjG1<CARMg_X#*h4|Jv^7BUmQQH&GO`#C<C*iKwR7cfmZ?_?(58&
z_F?}fhX0RO_cSOrD%GoX?^^m_<;~CV?>GNN@svHNFV0j56y|2#^w;=-S_0z+(^uS|
z{@XmO-|^?a@Av#^|4%pk&$r`}>+7q}xLLRQzkQUq`i{lt<EyUhsoJqPEnc?s7Q>PM
zv!opU$Ap)z;JtJBW&PGu@20Jgo#1xE>R)YVfjR3A^DAz`@A7iLKVR{u^Y!0219uCi
zRh=cx|LX!8?g$wCs4rQuc2k*ytyJEM%0JGmuDWOI+o!lkDCgGYi?44`xNzy})l2LR
zS%zLh48I%$vNM>!{!4CZRFGr2B>R-fWvVzsi()L}{@<DmESZPuo$EdJ8#CPeqq|7L
zvHsd`^F!<`2Oq59{4f2$mC=L$`hLbbk;QZSH_N^{_@iC4^{+Mui|7;iwG9GZPFH{N
zH**NI{F&Y}D_r5kPkGZ*w<W*ED9S9{P%rej{ZH$zf8qQ7tf-kQYkTLP>oI<ozms)e
zO>@W#IA5=--Ee95!f)^LC0*a-J?HuxesTrNoxKzO9}!?{s#&<Mp6UNpnQZ>>5Vv>r
zI{d4O|4;m1!M-pce}!p6l~Cs2C#`>%i_br=y)<*rj_d75jz?VMy>xTu-(|70ZS^_}
zf^KNvYth*?&ujUY(g|nQp4vRu<E+7*A8$=U9=DjQWtztRjGwKZ)xXZ1ahcnR{XF|`
zPh9tE+2O@cuT8!6VSnMr>-=R0avbtQ6HgX?6i~Z#M%niJtDrCIUg^!0<(M6F{niSB
zkfZzcejbxuEuJhCV{&d%_SdqeNrJcM&gPr`_~1hGk3UYnywUvTp*7o77e9vsc{=fp
z^FIpZ-#Oay{ttU>+;%gqG_7PWt22|?nHR6AGm2iRC36377q{4_<Gwar%0Hjoy5J+q
ztRDWM<w(tg&O`F5)rRu9H}vMe-S+7EcjX--%BRwU?&sbqm};kAeoWxTjXiAhQ@-1&
z-~2v%iFRec@6L^1f6blnrn2<dVbOyp6hxP~UwQOMy??SKU+m&^8%dQk36cJlL8s+g
z8#yGmaENwXS<SpVQ9->*sxPL(BwFmT@{ix&avHKGFsx*8EdOUZ&sS)AS7hc{Zz(OE
zb%zr#3v9M&c(2CF`qi9IYR_V+a~$luzb8w4^WVE|*7KM$!w-D25j!WDol$KzV$1uj
zwC1JcWPwS`Tb+g31U=tGdae|{$g?E(igU?~){2dMb5}|SYKm2FJeFE|a_)l16?55J
zeyo&fo}_7d<NVsch1Vus=iQY%QMdDVr@8Qz_|x{0TMxIsU6A)&cWTs;52wXzd;h%Q
z+Sw_-WZu_!|9JLHp%?Ghi%<4f-C}uIR_L|v8-6vu>pHiLvTr^0{(58Lj^DRU+1h`6
zGm_fy;@iz_zXHzM-JPNN=GdY9Y0u8E+k2ei_-*qf=ft69KOSu<@V}h0qNg;$PVNs&
zbmY-{vfiz|r@I$Ri6?EpX*fZ1R=)Pmw$pr?P9n*tX7UQ@m|Tx$Og_&T+@F5E)cD<v
z`|NfpVQG@PiX*F*t~?WRbnQQd%nI-Ow-Y;79Nt|Wp7rqak2lgmk6lF_cQ0t(G*z<D
z`sK`1M;9{Y1WpQD#<Jw<lJv(+k`lL)iVhd}%-P+3Z{lrVcE4A*ca<ltjZ}R6`nvC2
zc4y&uoAp~8U2@NB@2h)ro%82CwNzsj@fXQ2ZcS1O|98b=VZ^@vbc;m48uiZJqic3Z
z9$9@q%>Q8AeW$-=zoW~~OWl6-aNcD{WzjVgxt`x+j(TemXR!3BQ_9?Rvo0HQ{4MeA
zHt~CVHT;%<Q~XuUQmf_tJk6}~-1lVS{2vz1`nzKOmnrLh@i?6NeqXD~cuK{kckd*x
zX;ynDfB9>);#^((<!VdChqlVM1264THs}(aRa5ifgm(FvH||0QS#O4fADohIB>n88
zhP`-s9mkf(&!2BxRukhnq3p@4yjdx8Vy1FmS!%oW@xR+Qf}-wdy}L6fDJK8t-dcsv
zCu6E~DxKum<v)Ecs;ug`XrX?iKe+k%r)6p@qLVC?9&N1fD~RpibV@W=ogvLiK=1U6
zXFVJ%&phO9eDL#QY}e`d^EalyPxvsuM>@OaDeHpJIV;$TDp<|E?k$p^y#MyCbg#AN
zI1dYHF03o!S#fOAzT^L*F1K^UYbYh0TXXDWvs>c-vmyNNQ$zATwR^pHP(R3*V_0h(
z>h9B~82`6o{^n2RJ)c+)9qCeezEk>cc5G>^u94ukvo5peFSaVZq$}iereo#%xcEY`
z8EJ;mWzu%nrfl_}7kFf1TM?5>&y1C8)_G;^=kHyzL|#BJz5f2f&|4e+^6gf8_e4a0
z=lkLU@i+VK*?%}@()s?lZe3g40gg{v;aY6(uNx~JtqgwuCysHV|N3m^2j^U;9k&R#
zeBRg-AKhrY#O!Xx_p`p6-4<%rRqoP!Cb)TnVpP`Wg@=zgIbJh!&U?jt{pyK+XU*qA
z*-MY`{8_W3>+Ym=tZM(7W*&8s+?(|#V11v{sUthjl}P$sFPzEp`s~d$GW({#o!4+?
z%To8N@-7GK<U+C-ex2JRm{~O^@;8IMxE-^x<d*OK_s?y<J0VC)bivnKiU%gM#omhk
zXmxs0h8(}%g|uB9c?M;ddv;4|Wd|!gdf3_V>T2iuN0-ljHMX>U`NrC_&NNT-QM8|$
z;z32twQ}EO&x*V?sghi_Vd=WEX*V)13*F(^yK$BttGt@;<+>xAc7^cs*ZpZomfrr&
zFwHY@`-5FiZvEn06l%5n;CtV&R5s@DU^bOQ`oaH9lBTBz-M;PFJb%^2#KPuYp0nL1
zn-5OpUsLB8)O2%}?e2{^O8sK4p-;JX+&;7-?#Nk-!hJWTOYVQ3d3<r4%R52u7={af
zyYh6;Ue<b5;&=O&H^ccSMqZUc-|xCleZM^TRKMx_#or&h&tf}%XqUeE*X^g(CwYm#
zY5k&mR`>U<y152LzYX8^z75O~xmds+Z^tsHEALX2t?%sGZ<GK2+ZS{*eNJJfbC2ZD
zxyzoc+r7xx_I8e8yVP_g6Vp}av}RuFJ-J@yoBT1U_qPRowT|1UCG5MdWUBn?$YEi&
zBF|*a!ZMaqER7i)z6ti%Y(v((ygaKjWb<|Y_}i+-tEy&OC8}@>yvZ#x*!6Dy@@rd<
z*%%7i34GwV6JM`(>cC13X_cx!o{f_On^_Eu-2T?6-?6ycspWes)+_x+{r3`!+nLjX
z_iS?6-yOnvTfx0JrStuX|6Iz)Z)!51xe;<<QM&S$$lrTgSACzkFY%fqm;b`*;?_gg
zr!idbjGE83_`sY$Szb4Md_SLHIeqxvh2r?O$<w=Dc}F!qepEQ?FMHA9zKrbSS>H?N
zR`=|)SiNSRP=M=<X#I@6qIct6Hv9kD7_~>ks*qDg>+Gpcm7A~31qDP6uSm1ra!<@i
z*SlpjQ!YVb$CW*n2J7_wVsg2v?%wN{kUl-}XwB}@2Zv{fcJBUsa$e`=^rg$Mt0Z62
z&oubC)BjYOXV*&)<Byj=JH3k3uY94M9`ko~eE7cuT>rCEgOg|T&(1$!YI<TCuXL?w
z+RCE;%^AO*8FWe1^u0}bHO)tUz4IsONxxZE-8^!*zweV;$APEO)-}&(=*^4BwBdUC
ztfcMI%AH({%P%sq8QG;ts4yC`2|Z5Uv(G;`#%x1Z*Sy^!ZO@KhFi2yJzqd>4JL|Wz
zh6duEJ8~cByqWtX`95>Fl&5IC$u}|Xn0@z^R(=l7>zjROf`aUao!ccpaat-x+wPY>
zrEpgJo?5Zu&iVg$&JDDFRHwS&?zKJr+8e&TI@9WYPrk!}k7xNyF1to=DYr=85AEmV
z*>}u$+<Ys~P}A^O`ny+G+7uhD*LY@`9cyMhz9*4wztQ{8Z$5}0ZT<AdeC9@;B9Wd8
zp%cHK_Wdm{;T`sNuRxVxI)kN)zVZWwDZ-ayTEE<$9p|F=@b{`M6Xq>{awa){|D*-K
zJ=NUj>aNVJD}P|ubVl~iQmLtv7KnYlu}kIEl0Lq-DUA7jWrjBDw>l^Jutztonfp8U
zjL78rB$<PgpF3-x-=a9<wQ=P|O|jz*Qkt46Zv`IR>HGG<_<Y6oe^2%>rSBJ)e_2y@
zOKSHvMML4(+J~<5JQ`=~|Mx%aam?Q*O#4XOjI6rIYZ-}Lj#8-^8K=MP=r`Vf<Vl8W
zulg?YIhW!-T&lS~*OBGj=QmT^nBup5yS(Jb^cm%sC(8xtsa?5m#j|;;<{e8$fz^j(
zBCl_8%cv3WvDuc<X#b-mWtp9gl#jJkNwmPfp5vBVtmNHh%wqCiKmVVi`jrdrdgXUZ
z0{?Yq?tPT9jaRdN={in1X6ya#Q+QlX&t@t2ogQE4cad{xo$2xXOIC-!@?L${r6RMe
z<+NgI++M-&=TABsB!7ysz4HD{j$wj@-3rCac3&)Na<|=1h|)cBS|se6RNW882f8lX
z;+8A>-%|;gIscPMcGeSz_p4W^Y&z4rpzFwimLK0<AD;i3=cZnuM5~C%tnQ5XyGQ-x
zZY^AYt>g=jUUqS17>BFy>F9;6CHW>&+!H#3=X;c-#VvW5B2(tSPtp2(dex1T<)0m*
zcV&e)ZO>-37Ww|NWr?!k;?qphA6MM@c6q}GVg7bupSsTsZ8zuXEc?!q!73)TR&aVk
zZ_pfpNovJ6zw%!;O45F`ber`m|4xMk-lw0rSN9(}KKX`D$gk7;f;&I7e9w6PUHrF0
z!J9&^dMl+%S5}?V(MuFR{KQdJaZ2js#%5JH-#{(-w|k$oX(}qU?_HI~=9E?bBFFT8
zl<bskEwQ`j2fsPhlystc!`Z_4Y5yc*YhAo9{88dbx}BNLxaN1-*Uxcl-L>N0UhUe)
z8?^o4o{)K#YczN)emR_tC{w?YH9Mm-MZ>Of(%z1fkHu!~H{IW|`KaPF_eU*vWgVJp
z-Q@)&b-&%&v5U{?%flZwM?+Sa<%(|n`bjNy@l=mFE(V`Uj$2KbcXAOA_sYD$^?SB_
z^9nTUI<>3X(=u##GjEyv-dPMzIy)zQa&8hn?jhRlc5TKRRd3Ht(vrJBZ-2O%_5I<?
z)=QU*6y3W2Hf}|1qRX+C^Y`K_|Hla}IIy)=%QSlWhh57rPpob|I=f@bv4oS!pSz{p
zX6HruWwlI5J-2`%p?1ou?`D_0YFI1nq}=1;b7X(3UHT-p;o+*xCqdEf?zb2hSI)3K
zx}072%q5{M^{tN`H_888(Ppsm!rz~}CQ6A<{_|~ZddB}JzI!*M2yDF4aijltx!<Js
z{8sUM;$E)UFPUw6%YSi(@GOJN%<bR*glx~4Y4&8+J8RdZA7cBCDbKiSz^lD)?(Rcs
zldf8xDc&~gjePdoy~ZzPzjg0;vFypyCY@)mH?7K$KT);e(cOk8Ni($;>N<P=`y0;q
zMJrstZcR_2^8KK+Uv{!amwcz1-figr-k`TXC!R5M<(Vw5!&^7#R;RvvxU<gihW~}>
z_xIK}d_J^Dqvk!Q!>UsbW&8f0QJi$$BePS*(s5#?d+M&&DK?sKGkaUK(hU@Kmmhkg
zFIOXWb?4qayWg`JA8|3Z7vt%9FSw*4;&Rr+C$YX6$0v%a<-FS0oN{#!^Eq#s9eJ(u
z(w4n*J!%suu`qm&&aa<8mbLnQ3I6`OW_J7TCv6W8bJRaQufDAL=+Aq43w*se@_v*q
zmfjQ4eDjp0>5JLLb7#!E$~j}D{>QzO4xM}GdiC)<%M#_TA6@qZ*Dd;Y=a1f}^@_5)
zTKijP|C$qguafC*P?tl-L8aJ7H!hh+DD8OMub#TL$I(Kmb^An)u(bAfK^!leZfCqn
z3%aq%{I|&8+Vo9Pr#s!%s&jdi%XDAx9&gUHT9-28GylYviVC@7n_uZh%-b~o%;!AE
zU5O_Ii}IN5_KTOVJpDfV=<eI<d;KcilJ4xX-ZFh>@Jpo{g<R#S+@B3L)|J(rSDKyF
z*3x>djP=coms{>0POom)6}#M^x{vexw$C%v7uK!ZZ8D{?N7DMk$IY3qTjx4@sj}aG
z`epv+M+^R?S~@M6DlcWcdbVVH<(;Epq8hjIuBFWT(=hW;=hYj2$`a2x{X%tvw{BUq
zpeIGwxt#ySLD?&B1SPW-pM5n<U-I+!-G?TNGGC^BDO-BzTkYNFN8BAI>9uNgFP?C0
zN>TcQ9%D_x+BF_?t*1Y&etlC(e$LA9mBR9$(%$S1W4!*w=KK0(?5t)V*zZjLJclj4
zO!l|A?U$~#cTX;|+Ua=ruMtz;k1aJZE1l&<*Dg0ZmN{X*_1%*z59P5eale@HxK`6r
z+j6?@Q+c5;YK~Qg)BX5WQkU|t&60amDQ(y0z|IoR)pX2d%N4WY_m)vvS`jCX&UAag
zl42WUXy^Us$Unun8<tBxL|RO|-v7&yZ(Go@W$9~{%2h6^m6?$r8(;mVnE#P$=W_Au
z2D?t3Qn-_&p5YfSvrlr1thKybO;x<odu!#iubC^Z2>qYl|Gwl07w_|C{}ul&%J&`4
zKc4Q$^~aMl`gh_Z-X{48^4<0UGO>GRD`+im?&Y7Qt}5|%OEd4(dz(Lm7p*$4mAI?=
zZ6K3-(yhhn1vi=WWSZ+r&(>_?nR0T!;pc6BPn>@giv3<1&HLYrv0QAw-gchuaJAMo
zH^tY@nlRbsz?SR-m!-EJ*A8%c|Gr9o{+cyni%ctJXJ;SZ_cbOtV@1WZnyoIOO!6_0
z<1+Snok;w+g(E!VfpOiEUwPMFUu|&t|G6}|S8eaS%{%70`*gQN-JjK&svW#}N;D&H
zqqN5?<C+EaVqsUfHfyzrTzvdq_tP@Nq<p6*ca6?XoWC^9srRZaS16ajn|+rx%v8lK
z;yy{KJ&JjwGUtHq3-3kdSG+U3H~LOGw|Qm8<n68^vPT?r*KYbbp;g{Lr%YwTjl!Hs
zSLST5*T1>o*uEtv-Tr2#Yaf=1y0Yus8sRUtzU;~ApOyY?sF){Q)#(v5<*R<g{Hgy>
z7o2o$`Z^`5L2$0vwvcFzw#;Xqrc>3{$1=XyebA3%_e1~lH?OHEJKQ&YcF`m~`jT+V
ztJ$s-tF}HUyELPSZ&OgW+q(!3M}g<=XTB}oa)$X-(eHN?8zYx4j%RzPW|;mv-mOpM
zc8F7AU&!v)y4IH@-8Ur9Xj$4YM~Cxs^}#k#_uDPgW>1OY`^Oxh$DV2RR%`PwA>Yi0
zYcF^48vBI?8GdFi;1MfHz7%-kQqj9zHcb<H)9!ccA9~{6)|q&1RY`vKv*Ld~-HeyJ
z_J;gdIltlR1<5!M?P{C4YiCdA%uaLEkyC7SW53CJK}aga%k_X-akJ1bw~e2ZpQx6u
z@b;+8auzsjG%LMB?`+cTq-k#FKTO*{#nYJknfM%o6>EO3b5Yma{IGMw)-!>BlV`{~
zI+`g(cmJEb@tAnH&D&KKE@g=gWyMS>jPA##7d&=nYyEj*_Kf%I&8^LLb{;Qy`q^LR
zjd@%7vpE8MJ?k^}af{rX-&B#zWWOfL_4xb~)Ax(~6g_xl-Go;uCco>9FT^{a+o|I_
zJuLjfjHl19b_mTgJz2VackRiE`tjdpOHOWg=u4TTC9q@SHV2p4?;@W~x7l}&^TMRB
z{Qq8_oV3@)<ZA0{uFb2S|2SO}#;#*@CFqRmE3>V;&m79J&hxxDE1q`^ckeqs*UDfw
z(}@0<cgeixJ}#fHV(^@)>uaygYO8%3SCh;GUNAVX5Q+V0sruOaKKHk^o@;jel-+b~
z>i+3UCSUgYZz%iPnR)hi<0PTwGTuGQ3l|)`9N}3TvoFuihqtD6dh)@17q<(AMGWU9
zI3;Fh#mu#HxbL#$?UL`meS7bJT4@--eKh~pzRKIdQ@>TZOP_Y~4*j9reDdeRe?DFU
zJUQi)J_|~ygw?70O#40Qf_lj-ZU>b`_n&Nj_UP!kn26@cNPd@GMxzgho~Rm2c`nWA
zZn}C<-@R0~<bH%)+p&LB?>Ilb$+gAnVbu(EN6qhFE(o!m_6a+9`GKKi?BDPR5wG{@
zy&4v`=Y%qqFm%_>pED;qWW|p|UB7$c?nOM?DR?HmJmG4=iwwz?rl&Gy*>eXP9hg*k
zVQDJ&ZH6eBZ5P-s-O=y6UHi<|pj(pv(4h~7ajYs;&klTit!h-ea?gId8LuM0OS~*M
zd!04$RKlkZQi6};w<<l{_56rnz@wOJAA^)HuIDV9qbx6?$a?ui<R;ZqPZw_9koaaD
zXRSlzpM#?Hsek{8Y@MC0yq_Vohp&9OT%<f_>(1}lJxi^-8Clg99sPQZWxwK<3d6mv
zNqd>hUljAT2|jVZdhX&)r@R|~LS7y1bc<MWJowPz;|K5T>|Azzy35={OyyJ07l!TL
zbFRWvTrN)PrrWZ7!xNSMz6_5$Hb!mHTDGy4(@1%(;eFOk@ef6-CjFVw5c>Q_#Nnu|
z@7s@`eidwKci_d_D#_m2JA4?dD`uv0{GQRbyLg56of&rn{_;*s6L|Cf;`uB&dAF?d
zp<gci;P77lA=R!r!oi?KV@clu$9JBum+ZXbHRH0xi(?h*JlDNeef#C{yGeh(ewYz&
zckKI#bvd?i{3{frU(UCYH!<pq{H3UO|JNNQTUVaFIo$hiJkL{`xTk7$J%7miNebpM
zYDX`g>L|5R<ec(E`S=diJn?(h7GL!0tgkGnKUk?~mBW_$;m6Idb4(Y{+#vBX-)-l=
ztG9F6&WS~4yf&J=Cphxjho@oezgK;;_~1K-)4IC&yxq;0Q|30sTv~L+w2iBo>GqMU
z+a7lY*SDuF$eZ-)9-D?{LUFO&MvKPYe@=CIex|8kHCId*{}$rb)x{aS?wN^yvRX`S
z;Hu(DI`{e_3hJyUpAD-~FyhD!P<!p8sdwRtO;)P?x+^I<UqpW!9lh1I_r$H_MCHfZ
zzu#i;-}9jV&vXyj4g9?(>bES7nA38TqD-!q-@3AV?ynbyOMWaB{>$PlUo3itd+$ww
z(wUd7HaeuO-7v3<zjE{D%&l8X3Vkl^j<H*rm{DgC`eL<$TjbtZx`w9aA58b(5zSWl
zWF_T3YtGkCv&&cKY;{`hP+weG%XY#w*GB*6_4di?w@xKyPpJ8LD1Y;orRBEDvRn(D
z+C(B2d)wR={dChi@Ao^GXD??h;Za)asde-IiFvtVYtDJN8wGE>m74onZtCu%vP-Y;
zpLTcV{mP38)+{go{VX%SKe_P1@uIAqCLPg7J&vsTJk38=>h+a3W+z^rp1O<IM`PBa
ze1GfhXQOv?R_IE)H?BNvT~at>>Fn22Hy+ZC<YsB_s5vt+(CfU1clupJQ_Bf`+gX#t
zC*MDD_LuMk&4{q*VEu=e=D5H2*;)3aMf=|ex3e$(T(UR(Id$UB3Cmp>`X57|b1a@T
z_s{B!idLZ;@_F;@e_I^Pd@$?DgC9TU)T!z(>wC^S-{}(9%9k5W?jN645&E7hefIo@
zTYVe)uLWMSmWrQjeCYYrYZq7Lcs5R1H2;Ra<lMI#uUb_*Eqz)ge&GA5Yxn1U3(V%0
zYinSW3Ch`*H*M$V7mJmDdv6i$IR4D#y=~b0Kd&z8cwCQC{!lz|Tk0eS;RmWK^=kJW
zK5qPQqyCRQshrau|5?HL^}0yre}g}*MpsT{<}Z6w8L(Q_o$t%)^0+0oMNigb7R2#g
zsr|1tVgKKz=)aBH&vF}2vzPo6@0!m4VVy>T_$RMyfm2%#x6hV}-&dD^ujxA<OG=61
zed8vzb8|0M);-sIy4t$EZe~Q;+P|M%|380n_i~u8+LtD_sgrcqT?$+CUL?y*+I?wT
z@Ljd=xz9~Ey1xA4I^RoX{>iO%rU^PNPq}_*?7YP0JoWEEvnG4d?^`mLoYk0P9{a*W
zW9yf^-z(lqmv)I9VxKiT`|K_;`}jBQe`X09uWNbD{U~7T=`Z10nk<u>B&@c@via<P
z`~KUTX`9S8-QN?mv)V=PhYxp4aGAO6^ne?eD^><26(_7I>YQ^<=-Twkzg#-*{b5-v
zzUj(#uf1Bda8AIfMxH4lpU&88vVMBjyYj|mu^y>1-+%=Zmc9_SEWLBD$8PV8hnEyx
zHZ=VH`OvuH3gi7L-XByB?!L8dzRWeNolUnM1&XRvS9?5r_>EsL^tH$CJ`J5;<!4+9
zzjCL3Klf$vw@O}<IO%t5{wd60ZPw<G3w&qBQosM;(JgbYzFuW|&Nht8_?lp}{M&#k
zZ>jlb4_sNNe|nnWURgn&2Op+pT&#KWYIm4@uq3<P(s!HF&p%qADjR#*^m9Mwg-sO^
zdfa#7g#|)38vj2yUu9*Wb^I*_?K7QXCY_3|GpD}|NGzW5H?zW|{-?`k=lY7~-LFm`
z_xllk_so0|Mkbr!PL8hQoB1t|Uc6m7?X$Z;<ZIrv-XAene;OWH_A6(8_~IwGLSic3
zOS18CXKn7?yE9aZPr~T!ne2jh^2WByq&&J;it^YUl9{ic)zzKfA<uE<lJLi*$5E!C
z#_O)Hh!Z#X{PxZK15$@)#p*5=QqcC2xF|ER|6J>eka)#|yK+81V$0xu(G*;1Dr|Fr
z&9`+yulmNl`D-P2XC@W8^A+w6n(Oi2Ozw-E=-CdIOF6FnlX%qi1SH-H+bUJB|KhCV
zD|Gn9rmEiRkkaf<(E>r+a*GGWnJOLUv^Zqjv@XR5Zk)K}N%p#;da0j*yMND_x3l=&
z6O;76SDO?LuRc8C9!samA`_=f;ioF)|L(2(_TzD|)Af||%ePPe>+NQFEl2X%Z}}N3
zPARxdJu~;?yvuRt;^a%(o@;6I)E=2x`-tfXtKrR@)%UC9rEh3VmA_~a*{@w?#ZtE6
z5Nkx?Ql?+RE8<VdSr(Y*te&&y4dd@~vrUhtxK5kVC7dk7HI?b!ys4Ka^TzlrZJY7x
z;#;lXvua*m_vsUD<t@wEDB8;M=%K~*Q<LwVVl52X{l<%*J#~ve>ykp>Q&YNcB<x=C
zL^*vX_l1;eq4NStZZ17qbY)7%vfUF>S1wDHVvn}fRQ?{wYwH;;)BDI}v){Uddzrgk
z*`rtU*47{IoObci<SE_Pp8eK#ym*lJyHwG~qBC75LcW(;T=V~xZPoqbOLpPza><NE
zURNF|&0Sjf{p7RHDaWnc=BrH5(OSPQzpgUOK<ww+$Lmj5ua>_&{Y1iV!}A$Aaebk6
zb%AHA&#KK=Hz~T!y{4mj`QnS$X7p~(`8{!Wrs>ka`!eq5b9L64&VBk>c%RKF{k(pL
zz{lm~PP1<Re#|6h8l5V;LvDL(ujBN+UyEk&#7)|9lI@fJrR^vCV}E*lQ%K8XpV2Rz
zeA%cWzREuI$Aj0Y;`5F!>O6Yl9_PCEpZqzt`nKPzDY{r0{nq1S@ic|Gl7>xoj)6IC
z@9UN%gs04VTJ^GOiJtktkke=OA6v3HUnFxw(Ccrd#<x?_I!^w|ddc%Jd-17x()&LA
z6o2Q|d+7Fg#cT5A$_`b*kAEgTNOVg56MvGCk7M8SDI#K*xR=U(|Gw-}UG2mtf7ABn
z{I6MC{8umQ^1SFJ3H`q$<DyF9XPU}uKb_s4_K5ZU1knh~Wzu5RmnR+XJyIJzS5M+W
zV5--9hnMBX%5i4-6|LRBB3EkX9x>HT_<rQNMOekBYcto+adLJo2<BKHF=5rW_-y?{
z#qusuFND)d9<4jpB|Tf-!ETjMRmh!08$TWU&u_LAWuG&<vRGlE-NK@Ed25cvi7%7d
zezr8_#)9_`|8Km=v^nI+p{F@t_q|M3-%?Y4Xu({`&3}31)i!?9ZTR`RzspYC^IqE9
z7}X1l7ha!Ve?`ad-wxq~9$Pi{Z)XE?y!S7d`RV<O`hN+R*XzHUF4@*>vE-7eukPK0
z9%rsLzL>r2N-1Ao?>4dUZ7c>e&FWS<&pBCFe$({H#%oW?mZdiv9_L(bzOU=h+1Z`{
zRD^O@Nz|p6_Xyt7=rHX0via~7;mNn^q!QjaU2)$x-}~lnebEs1e~o_`>`$Co|9G;?
z!v7(LuJin7?C?4f{3ZPkuUy(}|8Sk{Z?$+o_hp}&y3q5|r-$1Pl?wTuGMBr;_iuf^
z?o81a3)>d|yUA{<+ducM*!GnM3bV{s*>5(9y?EwPe~Rm@U(Yz^9Spg1S>nL#be((m
zHh=H={#rCg^6blt*4K}9O7Z)?cpv|)CT_2BtnR`67Rhfa&zA9Cw70D1uYB^nHS%Xs
z>XxsfJD-|&Oe$|Z)$JyDTHCkH-(;7R_u`{D?x**%K0K89rK>b`lWHbk#(A#(`9C^u
zx0)~SpH@}u`t<V78xQU^zKQ(o81I!5H}j>@uiX1Dmh2I;`1@7s=TCoz**qD)v<$YG
zs#h&xT(wB=)h4m${G19w+EN?3v!|W7EGVhrkZqrEHRkQEf&=0|&+tAt_hXT{>*`A>
zaUw}<rS?ab3ZGoQYqqb*uH~P%C~2LTpR`cP)jz98b7ie{#Dz)PU*yisOpa_d)HMqe
za?A?dG?T6L-HNr9=cjYdIkq8Xi?n9UBD>$^fpSY{td(?(x+(ACwsVEdqgwM8!`C6~
zuil8v-(r?$BK=9-`?kRX!HnmVCa+vwF7v16$b)rfe|Y(rX@{@Vxv8#ZSGH@FGQ*|c
z|IGC2J}|R|?v;Ds^62z(Yo(aE7cMaDJFYL5kz2?v{(frt^@(+@my>TzS!`W&ebN)n
zy=yL2znc;h{^0kemUV(3YUQT;?_M%1w=Xg~|3}7aqr%)XspY*ky817c&%E<$mK5Kg
zi=V}_*KZSeURqe?_~1&aH2X=3|DX3=pP{bnx9;J)C+X`$BZIph?#VR^V4vT!nf1@~
zk~D5*#vl38QnTV8^>E#}-D`O`SK`cy1C7UTI+T~$X)eo|RV~o=Zu+VJXLMF%tv=Ng
z@<6Yh^U?W9^1*7~cIpJPM4q*^E!;L)u2y{du9;@jZ%;U`AZq(4^=QS!<PFTf4;}Qq
z?jo`0^CzxF5qm;IEB}1nEG8Zo_-@*Pb3d|gq<`b;>WE=V??1fuW>w9~@KcT50_Mjy
zl!c$V<2RG{^QN!wnePPumDab*na;YZ_L8Myr>d!Nw8IRy8A&^H+2?4Mw0!1^J$lQo
zS@QhWq6piN2&)Id4`1>g$jzS<^;D<#`nlg%y{0Wsn<-i*J~!UpCPCZa_?fHUq;eNM
zW8Un0=#T!<mp6njBulv*P+MK1emL@U>4Z3E8@5=%#&_J+lfw)zRd>92ug#Kf9=y)|
zQ>KAw+(ECmq8xJ+dRCmUVRJZQpLo;jzgIb5u+?7wuZNW$+2~J-=>NiM$NOHbzI<<*
zS@*3I7ymw~2ohU&HN0tS)`ndt4|?o1-dQfhdZzB}p98n{{QNXg`rm(M^QdPhuq{0_
z$F}s))W8I`*bsC%l_B=asmu+DKigvqYsi$>Qf5BO8yZS@@7}$uaaZ>&gYy{y=jIYG
z4i1lIlS>MUckkX+;PK+R6ePdvyJh<P&;PS)@6XzLuX5e)dDiQGFI;}@LfZ6gZ4peO
z3JDt4=Iqls9Ku4qB@P@tdivneqs@-~>zSLZnEp>ny6~DY_O64#h7<N*Hm!5uelgkS
z9Mi9qWn7HRQ|`zz-r2*D$0(TRD5$5$z%M@i!+svcbxI7D-24+v9i}obU}0pwYw#jf
z@!Y+23enatF6;icVw$mL2IHMWhnjNg?=W8Sa|oX>l~rOv7UNcCE8DvnsSi0Wv_&*F
z1ib&xbx<XZz16C_ps1><swl!@XQ4w(uIh}N4D%FL$U1PpU@Q5`5XD?KojYK20n<Ot
z9_D7b1<CA1zrEM+ZfvZI+QG!=&*VNqRN&3GClC0xvF&1-_l_+?dlkc#xs4C@_k{j4
zN?`tTSBk-${rmpIf8YMK7U1}E{N|xkT#ugQFn(ie%w;rFa941Mb!=sR#hS_-(Xh5&
zI?7^~<Geq*HaZS{V$=ND>V>v5Xn15Z>CAied$*OjcK8J2E4_z#pZwVEbnbrQyjeQ@
z+orWzSTY_AFz>nl^JHU8W0-&J_h)~M!`Kau2*3G#{U#gBwrxLSo3`#YUalwc<Pl%U
zl;5`>dA59%pQ$Ur_2BuVM?xac7#U(29Q3uV&)q**x@T@<{ggZVkNW@o{oBfU4x^dB
zD#Kq#vjfZRdE(8v`4t#mz2f`w{qOQe`vuv|%@0VWu(C!l<vJ$x{CBArV$S_{$bWJ<
zYb9gP&Uqcjc^~}x`}_OJC!NvP1U4-GUVr94&-CCpe`i;}*<bw+{tr8O!eI}?zBhXg
zF_g*G=`om#uV--h@bba``++7p4)y5=zskqEZs286_!GX#KlWGnA-Q`0`7hreO<?;|
zu48&aIJuEw*?)mQrsDR~uU>Bd{eR}O`j~(JZ~V1B^}qGO|JnUbyB9x}*S(zo^}l=e
zLzbd1|DyjN2`_&k{5@3BUz*`xd~of9_}8nrwy^EA{<}U*Fze$M=1U3D$Lq}npDbhe
z#1xg?upq3gKJcmj&Uf!wi&+{Qr3B0`yk}=UaPI8UulBo^uiaEsQDt&x-j5&dtTj=y
z{_hKt%VFL4Z*Q#4A0`Iw@Nn+@p5=n}iggY8-!Dr=G4K6nAaUR%W1GYL7zY2RKbdnB
z)=BJtu6cy{!IfXSznWWE8Rv-oce~@C^O)ry^Cw1&xBr;uTb$wi$zId-<PZOklsCWl
zH5eYW{A0F@ee#cAgXO`OAN)@$yWad|{};YC?A^L`{<HtJcl-DL5dZgi4MSs`gLco-
z%8scSD{6ByUYBk)nW=7_6I0VBx9or8%)8|$x1RkgZkA<K9Gdo_?e)@<PXXUQU(Kyt
z#=SCiRrUSmXH{1^^gU<kZm%m(<BSU4Al7r#^U%M}CgzvB?6^vb%4Ao@?ynZN->blW
zB<%;E>aQ5_a>bn9{vX%p?bYA=>es0-x5Lj9XYCGUIyIv__41pIyA0Piccs7lth4!9
zM`pl+HzFB273y&oo5iOaS6B-7hj?+Wk@(lXaZl?$x7jv@=EZi|Ppxe7=BkvaxE&Gc
z5U*Gq%(Ktve(;nIu^Ml#@ZaKlXC38QS+wCsQ25RH#Wl}Qu3*aC%WD4ZN=1*}*5db1
z)R>(lPyYH?J}JvfI)28^ODlv!w$9jlwEfx#D+bMd+i#y(vo-Ej>CGF<C+TzhU$<p?
z#<Fs9)`m@sZH`~#aj}~J@!3-mjmm!#+7@0v7Oe2e*k79Myr|y2WW7h#iH8pqt&LXY
zZ#xz*9G$a!QGUt9RrM?DzNcMniJEyVdqaAHVb-aue*-eN8Mp-{=0rYt;HKGqLY2#p
zY2$;CV<z>d*k%XzEVn&ql&C&2W;fH(b^~tDrp-4Kldms&`#NB^8*A_1%<_OoT81T;
z?@Q#*oThN~Mx{ApT3d2kXI05B!T7B60$(#;9##Ds@OkZRm3J0Xf6u<ks&dXlF;roy
z4*%->Lwm#x`DDHSE{uQpHfslSaai)!JL?ZOE==FE>GH+*i%WxVeK;BT#Kt|(@7pAc
z`(IW3UDc;O=T_Ra|N65^o9`Ks()?C6-_(k(OIKMg%JDVk*}Tx~)GUt4Pj2K(NNCu|
z?Y&U=>rddbdxhVxR;In{*t4#1#YCrq+?6|@?KI!~^OwlQS6kPbPH=HF+<GB&`ri1L
zXO(Y8ujjt4yssd&`7zg;iu>!9HhkK(ddZiRH5XzJ+U{zvy77{|RP*ZXO*JR4ODb#l
zq-g0cny_!$v89WDUU;r>cB0m5&AX~Izt?Ha_%{E#c*d_Av%PhC#a26hi*d-+S8G;_
zy0B+ysp-jDKVIed-!~jysdHy6oBsBoccJQJ*SV9`mI`kcWIm<q^<2Wn;+IGNRrZe4
zv-g)SJ3Be??~DB#WNs8y`yRLv9~`}8Y3{6O4~xZypDfQRIXz5TFEw@LU*9m@!oR9!
zx@E=bnHeu`b$^=LcVUyO<T6dyBDRo~d3WaAeY;Us>%Ydgwfsu^4DvHAcB!dP%wF<9
z<5=SVMKhCXsxM#v-M=?pW!v3%`x%4Ta({2DnXvL^nEm>~edYF<D(UUwc?IA7by(DD
z!oIl8E0~vAuy}FD=6`O6I~FWEX=$k(qvtlS**5pzV(!ytY)sC2mdrf=cW$ew;iT!=
ztfj}LW_6u0zIpCi`8$&vf;*0!D*9b0bzV_3cx{-uT@s&FpX|m-Dl?<iu58cF<klAI
zJ^T7LKl7B0-MkC8Eqwnu{m`4EswZ}4Gu_j+;{3nJY`<yJiOXjXt6nfWb48|+p)j#|
z>kDq#`|}I;>P%v|b3MhQOQvYfyJyVbuB`d}*(Zp@YF(-D&((HQJLSbYe3Z{_oIYvo
z*<S%coDWn|1eI^Ddt{iA7cQ+SRWEkg-)wr$g4aJeDx2TC>|K13-M+3sMP07QOs;$G
ztB)J395(MR{<w8}_RI}C)3&H|^gF!Wy?bI{bBb7B*R;*gE}p+uv-|Zag-waofj1hj
z?&O@1`So*z1m_x|zhVz}K9%yE;mR$w`cB5oSAQq1)HrN(<8D~~<`mukQh|4L+n26#
zcu<;q;CSti39E97rWnt@-MeMVwL5yt7y2r#y*|%N?uBsFx#?Gz8!R(_XwSf>G^29j
z#$6V_r!^dVb!)xS>*VOp%9Yd3&Hm)Q#$A6$f%b!?YuE6~J=koQy5hm@8JhF8&1Gcu
z?;Y1HJYaq7*f06=>dQLTp=Cj{FY1X`NBYHEeqJqUzagV?_tJgKtpzqdu~{{lNn)8N
zzxIEpL*KV*M&7FU?6{$*?G@Kwwp?$e$van1$rP;nBKeW~tlgIte!+}g&!!s*^Pbss
z#BAo@zQDQLd>>8zSzTcGy>u_*)7E$cwmF#}pB5kHdnC2*$a04ljtknKn8_*@ZOP*|
zt7409bd_?I;w|TlJ)VBq^#RX+`J2_2@$B19fBGIMe&_qeeYcgLudPadyvN9t_uRP(
zbx99lZI#%|!hG`Lm-nsv(~zDX7Qfbh_p43T*Y=)T62FVzt36-o>1oHZZu98;^S@kz
z&+W8NIl0Ytt5-zZroVU9ZGSUtyS+~QPVVgYKYq?iaXqm{@@H!2-oGu=*EIQ6=I^uf
z)!xotDdwCtNp9kl{XG|||2}%uAK$iM=ZQmR8QZp%YlOePy&{kMMfNEXKar0!{>2>=
zXTBoiwrN}TB};Sdry+~QJDw*Uk`ta%<P&_Y?2vHIlzhcg!8MZ`C&{uoTo&KV__1Zm
z-cR;cs*CQKFR*AdN$+r1*%T`0ZDg$RzRzG$+c~cZe`b6W2(DByJGmk<sk!Ndgy-Uy
z``w?fWVKa3G*4W`ea7DxI*r|5gYS#(Z<gMg%fT0XHayj{Woy);=leeNh;B^RQGL3|
z)5SdRiO|%a2i`sJi1;W~Qu&eBX`$_R<FjwP%HsZSc~Y|~RJKR_*1I=qM?7@YE1vDk
zna@1qi<DaQzNbOCA{%w9uatjj2@2eN?ws^Yk-5gQ7bO~$9qxV!Reayg%YN?4k*9lR
zSDp>+xD&Xj(o=kv`@3n;dW-glM(TEbVCR3y(6sNItg%69a-Wf8QGrmbMCps4duvZ?
zY1oRsIUnA3OQ550_r~jgayH-Ey;ZV4b=LQ`#>&Fk^%LD<uUp>DKe1BJf8{sLzs%Za
zzi-mMmUL*D@C&v1obST#FI*?Qmiz2afBE<JO0~PRGKw`bimvyZo7opx^mI%3OpDy!
z#Odqe)=!wiCF@@<xqrpJYuT@pZ*AVuu=uaalf5h5wT^x7ik!a4{bTr|fM(~v9yRZ0
zTzlI(|HaQ8{9LbB_grjnN;Z0&!(jTN%RMdRg8p>gi#l(aBmHs%l&+r@v2M@esW_?Z
z*vhNRoj<S4AT=o@`s)2pN3Y5xPQ2Bdb@S+%6|R-H-!^^PzTSev(cDAYHGNi4bO&$$
zB=ZV6shIWgtZTP7ao&F-TO9jj&&sFCcjm^uuDN+7vzam6<4iff(7%wp1ood-rukVN
zTy7Zr+Bo}&?aq{fJ+^gB9FMuy$bMQQ_ad-+>YpR08x4%IZ+>01s9&_vH}^WvZ-t)Q
z{Ohf)&aB<0R?*t+oSspe;4R>?;9}W7V>_dx4`;u2u2aiMF;7<e+L+-e^6~Pdooh7j
zNn~93b!ee*_uSaK*2kupPgZf)y&<A>|3+(Z^s1kCN^W|8Xfog7d#Ob|q-v9?Gt1SY
z9S4>Mm1zFHXZR=Gzx_DF)VLIvFMfY&Yfp-aIbPbnQT|Vvep=duqL)1L_2p$U^V#;s
zIB+oT$h^N#aq40HHBWdJhGxa|2EP4#D&=kR4JG}}*EpY?@ZNCxRe!O@2gTZL&u-p6
zGppNhUQeTL&nwSU^Pk=M6naQM!gu#f$Ms)6#;utdB=&E@;uTMnQ-9S}W>*CqNNkS#
z^EN7Q>E!1nA5RPDHR&-r=^j3lUcFwTC3mq?puN`}ox=VmjrK3AgQ`VTe+N7Ne#O>Z
zapKVK$^Ja9d()e86<f@`kH%-^MGL%H9M`bVbf!qyi~Ct&W!1AwIVNa4FZw>)Q*h5G
z)9+lrzS-P+y+-QrnQhm;mCjF6HhDEeYq8q9T$TO7`n7x${+#N6y<)OVr*T6#`;*6&
z9U_~GTi!gfpA)pAY-4rspAC`U8Rq-0)8MVCY*jrck*?6)VAE==7a~;5&}lev&Tejv
zZpK44!Ix*uiBRdOULVg@zka>lyG@Tah)i*h<8uD6K4X2w!oQO}_a)@{yga)khGE;Z
z)EVNtcB)!DFh1>>Qd%Ti_1OCkb5}?QPjT+KZjT&CrdKX+C;Yv+=wmx?@d;zkkcYER
ztw^%IpU<_C?~u_B39UO*!`Vge38?u#n$B4glgWKmZI9@d-yAuwyj-2?^0)P6Ce``K
zn4jnUvf{c^&djRlJ^SjX-rZnZb-(G*^YxCLM~);mSZot2R^^K~EK4%I#4h3WN9uZZ
zV6zMxug*SR+wwQ@hut=x7Zd;bOYrlB=)!r1cg}V*C%Z*1s;gvMn;W?$&`6Op*=e`L
zvyZW<Y&(mNa}_R&NSFG?D^=uuyX)mWojvkfZ(pwcV1K_XH_O2!HM}&TS1!JJ^PP3Y
zb&q#UdT{c5<J~~zoR2Zfd3EEm=IwkC%&!`!SNglyINL4p%g!jrB<?lW8JqgIJW~1;
zXy2l=LOV-Nl`UpgeCv+gp?WL^pSsHUW%hb|$eg@(E410D@xEumg9}p<?WK<?gdVT_
zlhmg^_m^1H>r~4x&T_A7tZbd<dTQpaeYr=>s^yoFWyyhahfYnBEh%GoAGu!F=3>I6
zb1I&<Z?x4oSclaW@v2*F6YA49Pd|RlZMG-Z{7YLx?Y0zTDD3+*IYR50mS)>3qZ}FI
zPX9};NzZk^D*6~S2Zm)oid^fl!}w|TGUMyht4zB*4$psEaonkEb-|9wXPu^Xd|qd$
z^vo*F={&pX;yXIFQ3eZACI;KC-CH7b@AxD3H}QY>xlTV_8nAZXq@Q0tq)ypX*fM!@
zbvmzDPmc9dllo?rm3O_D6fE}p7PF6A$Kvw#x)r+x#n;Z>lD~P&x59;?a?<ISUhg}!
za>LT)wl$U4baZ8QMyzu<{ivblVHLB_CDU_8>UF&hAGV%KR<3M*Zuha^!S83T7nw@t
zC%ustDE+P*^}4Mwe$VdO0GWpRKg`~X^MhV#URhlzaC}n2zU*6qik*)6`ve^BE|1(I
zUi>P!+D*gp?3`z*b7t<}ckKLzyFVR1&I;qYz39d_*+;Una{n#n%4VHtd0{g(c)_}G
z&CT&q@;<9i++>@3G$2vsr>I@sa%nToY7RD0?+@F**%fa4UQ%<yj@=-qJ;1wNxQPFx
zhpKF){5oD{<LKO3rE|CP{rq-wiQ#P1Q@elhx2>G<<W|e^XNP8<51#&->yALc{Ul5K
zxaiKWywi2OPWiH)oi{t=Zp^a77ZPP#UiKR?>#K5Rw`RP`Wb#^Y`Ov59w~m}?uDD!l
zWF4m@(7pDr!R+@Lq4`fGg3g{eA~$0Li@u!km7oxb{TI&9D7;_xLLo1di$l4}THD3^
z@0+PNYU(~!H3wef{@B|U#r?VDKL6g>CqKS^7caHfxVrONM&9brm(DLv^H{>Te)4ZG
z{{kkqYTL{5$G+{+uep*@G1*DzQ-m&0y~d>r3#8qrzS>s(Y44l34v$2s`?pT5i(aF&
z?}76MvCH|+OjoUEE46>V&-gYbZ{yyM8?$ZaPwfv|8#QPC9Pb4?^xEwoP1l_s5Sj8P
zrSnML!mmwNe^sl`PA__QAbfAq@;kqNn6FL06wJT*jQjPvF6(<UTN!&_rUbc2$ltg1
zx_o?DapT*@3_;$c!aYSPY8I(CQu2>#PVrAW-ScN=s)Iq)du?qM)i&mK-S0nZw>Plg
zcCCG48dRCArOTz{?_zT?@)^^jcq^_pX~)Nku`%y*X1HigTw%5HwQ^y5VYrCxl|H6(
z9l}1>-*1^B@ng}l?!?D}c11qnP7Z&&%d1a*@_p4HGG%d^+UfADL+-y>E4m6EKi_Dh
z=e+9UO_PaUE$6~hq)RK-F1Yw3Zz`+)L*_g+pWgxT`oX-KTe@52H(zGU-gZmpiTiq<
zpmjRC8+k4+-Qm%iUgnneN_7L1t?#WjwW=5I6;0ZtSaI*U9#i)zHpf|JOAjx8QLen|
zy!Vl;y4oGL4`0mKH1EyU+qLUN{O*a#@G~4N=$OJbeJPKkSBjwO3<jYaLSE;l_?|E7
z*z&z)w_Hcrqn!Sj7ZdvzdigE67&Vu1U$CRk<lAQ~4=r53F5X9N(fq{VGE2v+GXEb6
zS96H-go*kmX=l~RzWyR9Z1L+{eza5DRP8v?**3qvl;-dl?O!@)@yA_tmp@PQ`EARo
zI^(xy@SbZ~C!eKc#k=&sdRw?Gqhp=Z*C!W`J->8Rj8Qv7|8nGWj?{G7u4R|!*>9dK
zTg6@XSMJ|*vjFDpub)ZTSO_+DSq2;bc6ShYmsIPXez)Rxqx$pe`+uixZfe<mR;tOv
zHSQwkK8xFHi_N#qIvE=wQWzE<b^X-Dt;=q2z8lu=(RJ9sIQN>s`|Te(uev5K7uwgI
zq8?Jzsz0St@b`_AwI3u?58sn@-J}{3G<kZ`{!NA<6X#VGzZd$HJFnw)M(bfU+dlT1
zMApRW=*->6;-6Z%NZ%`Yxn2BK$kC(w`>dE|w`t6^{=Tova_ZXrmL0#7<N_av+GG^`
z7CyJQxkIvKgUl|wp!pUOjM47x2Nz_ln|;7|p#iu0bcQ#s$G@b#+HPSp`>Q%X=abr_
zZITr)e;m}!Tk&t@)lVB+w2DIY)we{>SbC*p(T|y_zr$}Bb=c~!v-e;AxpVtjt_v%E
zIXvFv8@6QX4BwDRMu9QRNf9CkHA5{oExT{BQuOwRu1*fquR_MF{Vy#_G<4fqUJ-WD
z=5+D<lKJi8XFB^9pFFapEI~VBp4ORARdtTJ>;j67yhV1)wSrWXJXbULB<l%9>}oc4
zQk1FITwk9lpC3Ev(6kAUct!8>@9pHhqowlEP}6<qW=$*Wb83%Wx#E<<qrz*88}%*2
z7YA?Bb^ga1R(Sj4)IviUvyJMW|8hPjXl#B{B_LiaQuR^zil0r<vG~_(WSc*&^xn44
z?7Az9vP59S4epHAq(!EWUn@s9OMG;_6#cjRo6T{(*UR|U{+ui1U2EX&xpdd-8%-Q)
z=GD2cy}O^AaIsBWyTV5P*A>x-qYSr2q&}Y0XDgY(`*4O%(^t8vh8hpKvZH#0mVa_f
z&R?peeErr{*G*aFG1)$k%UnacTkf8kXWR1BXQxN&rW30FjQ%8ivq^B{@w*u0^i3qA
zM&`PXX=IL*yicHsgooQ|ogdS*vdjKo|L&;!yTylH?j;YW1aoCa=G$B4Lb~%c3#IR@
z*emiZJG%PiRu#AP9Nv<=*&A2Ab-Mi0Vw+^voOw3=mNPCZEfXqr;_Z$|<y~H;dnm!Y
zX~(M-8}>7{e(Vx^e@#DAE^Mp7Yvx(&<qEi%UVIYoJZ5iE@ab53&y_1pPfuuU+r2;V
zrl9bVC%*$9&ef=&{9u0F>4WE&?D^WA;MOE+YSS`x{n2W_RV@j!mfCqiY42{_n6PT)
z*T1Y)maMyf%I5hLUHRQ|c_YiKLrG=(FLCSIhK4hiWLw4jzOmYW-c*N6bM!?wy8C>Q
zc_uU6e&d3<o)XWFEN^C<c=Nvg>&FN07+5p#-AK=3T`_g5qzCuD!dsOa*TwaI*dXHf
z=H}a#@6IhUE9ia8@H|y??$mE9rrY0Ejrq6gw(E*n=_?YLrhotP_{aJA+>FJN&*hyh
znzmdHj9~9vB2jQ_k#O91znLXzk+1Tf1lET{>zBkSZFph%%xg<$erZoU^Y$|dCr%%=
zTV3w<SMRk}QB<v4Blm3ED>Z#8^Y$}O|M2(d^@}=x&!=>>IPIIl>9=WDckiO!Sr^zh
zz14YqDr0f4kxk6+e_yKXon3tGRvnCuG-OhKaO9DpU<&&;Z#{uxwcWcjLf?Io&|G}H
zeQv~w(A`!&Ov!s!ycCOkFU<V-@7~#md!=OcnpDn86n8a!|F!Ds@m(JF{wA4$XN>ml
zIQrJ2BzEud9;5k}Zu}GEUAySx`-dKjSMjbWxGR&aUYWmz#pHqO;j2wX`zQaIQ+jvv
ztJ)oN?mRNismh(QH?zH=?V4=&^N7MQ4fSOC3WZebhHml4Yv0{;Q!dlGUU}c~!9_2>
zxp!sLG)xwqy_x&3z)*2#=CXGVuOdPpu1=|O>yYUcHLtzVp<I4mA$oH(d*rOVW9lZ`
zlFBdf9hB2izq8_tWXsk08Z#E$R9(vdqxZy7FDVX&_f|XfkKbz7Te;@*xzZnPPxE3X
zJ{A3@8Fj{7GvwMk3!}0*m%s3+xNfdr;5pa-zMK^Miak4X3jFs!&3JhxX`{-@PfPD|
z-qK17dpGT#k#&^73zd6^o_GnYIbi8<=5=-D^@yK)?-}|_araL6_FH?$jHj{O2PM|r
zc|PykmuRt<zPm(neuXTG^YM%hbNN%wXz%2t?Y&Eqb!*8l9Xln3`o-oQ;;$9TjQ3m3
z)ns4&q^Qk3F#IKlDEqX`J^9m0KPDWTx6dnSNlWDk?bhdI!q+b4u46xYyI*^P^}LV>
zJMGV#vM+NsMFjXOPRS`>v?|EX_(|{`HQg<1+9z4Lw5@Q92+B=-!Z6R)zHDP=_tXbU
z*SAktb}NMMpWE}B33;XtOLFbCddsA~eSW>p(CxPQJ@4liJXZWvJ>SxMsfc^^<yo%;
z%9)+m8GlNsti4lk^mo;lCY__L3wx?gzg?XdvDj&T+W|K>j++bjK7IYj#YFGpah8t}
zn|bp7ZrWZld+E_X>eXtSSt~mhN1vWKXQJ~iwZD@(7fxpr?+(rU`yx*<Q^D)cpDS9P
zLC&rF_|K)BJ#BxROW}DtqpZvhHub2TKQ<X?>K%DEgL~cdo&TCyKL+Q_QDR8m!GHYB
zxsURFKEKa&9PPC%6KZ3BUm{WeC^XJie$l%ABBxub-U6jl+9vI*_rEe%=i1cy{s&SI
z`_26%aBRsLYvYZ^-l7ZYKmBSC(6`OxJnVOm=Zb|)*=9e@UuH)O6b){78p-zB6&sxC
zig}XzL7CH5vQ?qp`M}PvGwe3o1utznIp@UsX-~7*oWzb^={UJX=`$Pu?c9IQ4U&8g
zcU@1ZsJwqKmNo7A8rP~FH4HP_wq_lj^eHYp{$}vE!;f#TJvXCYq^e}9>B@zzKig+~
zX>keT-1*|;ba9jTpwo<<D_r~v_wO=Nc&(*rAXM(F9ed=!z6sYp<xgaZi)p<U8m4hd
zxm0`cugM{cT-IC)s(xCfd$qjI_)ya_&PVl+jwq}bjAQm*YVmB(^>mX0|6L|0HBPuy
z+<e=%;mO1acN|=GP0bT$9@(Xo={#5X%bSTp_w!iN-yc6;ZF|hedcMx$httEZSI0NV
zZrXI?(4wx7Yffl<+_vPjuGfu+^Hmb$PDhGoHEP@HeDe74;^$>=Lm{z4rOuk?>)t&2
zbuuZovXyI@^SuCl0n@}B(eDw>l3dEU)AqS+krd8&Uzd@3QPeegx@P(er53p*OJ=_*
zF!`{haGCz*cSTzy-)-{0C%nzCH}jLl+tt@Y6+^hW_;qde?YW<1aj;uuWzr6<UD10i
zrw46)^)zR-qldH2jYofv99gof&r<usm8lXh@@osvE4NSf+qAr0f0fRj$*a<T3Qc;w
z!%H!%tWbTA!&T9Uax<NSjx*HuUe`K%?7!>n4Tp~G4OLn9R?#d*{mi+?H3olVzZxd(
zKfClO&+E-M5?r1)^GfEHN$>tB$-l@iX>z!_p3|+y(mU&J9qtk;zusTW#=TWG!#VAd
zRoAQ6%cne(Vmm2bu=Ne2^8&GyfW_~vc|~&XS}bW-dOBgLRs1Snmz>Ht{Yzo{r+I`G
z{8wmLz5J0&2H)=UHy$0CW}DG*ICFx6O^NGnqgU^kKP)L1x)(Abwf@qh%O|)eXHR@t
zH}ylczyE#7N=FUj!<vr@I$0tGrEkZWvv;oVHEy2yl-tOjr=~`KpQp^l2cA<pe%&mY
zfAZ(gvVCPc#cLZcE^V`1)MY2n=PtUk;LW|)`>ojRPfvTX`o<~#_f_SrM}v}*kEv8F
z{Ji?tznGLgd+N0>TF3P3S8nyXDruTlwad7qUrM;rlIvFO#18h*Z(qz3s?3i3X#77h
z^TXr`DV@?k!q&3+Ka5Z>mf=3%dX_8nbC~tCZ?8}6o^hr!biu+^h05Y-am^Q>F>Q!C
zU%BH>W^KT^wDfz@>X$NN9JI}jlpO5)p3c{8<b9c4d;aZrJy)4}1RqxTNLhGyeJ{41
zChnB@+xDW0Pr-^9p*&_cv!cDn-(=mK7<Vww?aua@>bKiVHasYM``z<o-j&dT^(?jL
z1Y07F)4Y3^<-Xn@KIi`RlRmHYd>i~fra320Hh8DM=Gk+xx18JNpLw#lyI$qu@gv+$
zzwBC!pWI{!jlE~Ed((=^tEcTd`{br#^3G$;H<xcZp8eKg_q&yKN94|bkAFRBtKP4h
zwkj_Lp0qB0QkN4RklMDz>B*rb-XR{wnMaSdl$JC+y<z^QOP{^2sAE=C5zkd!ft_D+
zIf_cU&av)I+uJp9)4{jCI#+jXS^kBSN3!Ui`75`1_hxfU{c*u=VZGOjyga=v2RZt8
zb$oiI=5yrMW7fTl3Mwn}{5ad5>Qv@g-h6w>`P~`^$=dAQ|5=y1r(Li;mHBu=w}5=`
zPo3=(uCAZBK_jE@%9)PRY>|(zgb%JQx_sl%w@oX=_UByxI(_%mL#H%!*|elweE&%t
z=6fFYi;4GX&$}pDmd05Ng1=mB=`8tHy=U3=OKSJ`R0Y0Hjp7Pm_7<_q{Ch&E=e?x{
z=d!tz4R7A>c{FMFm)O_S@<gWU@}8Qa@=~c|_7c-Qzh-<`v^Vjn?x|DXG-R~SKRK0c
z-68Xg<r1%qe$JI&3LlDZf6Li8$u9QEG(p{K@?x(#Z5TtEM4d_szC;W6oAbrxCkwZ%
zEfV3j^zez15LKJM=DXn0x{UlYQP(HPOs<;H<^F(wUVVGU-q(HyPOY`N?V|1ZCM*BJ
z#FncoD?hi&rRqK`&JStH`u%|6%jbgZf5!xW?%@}0-<Lkg>gUm^oAp2c-RkZ#_mT4x
z#bvj-L_e9G-S8riiQ#Cot<UE$5rwsiAyp5q2kifNt9I3ju)SFiua{n19^xD_?MQgY
zk~0NYi(hWMa<*(&{E{!%{lbLUX6T%KyV>sbPW8DG)AmIx#L0)h<_=hYX<emA&ao5e
ziQJ#78kjpK@;!|?(BB*``mU$b{kLn?Bf)*MQqS{vrC+Fiv@CY{*2A+pBQ9-@v%a}h
ztmJ~{yASofMi(aeyQX)fU-XP!z_L(|=cRl=@2z)po-2Qs=Dl@~qv{!(XQsy8wdTxB
z%R3edE4HMY+?szimG`CizWSu#=UIpDxNMwqX5WXY=QrKjY8d&O?~|4ccjoS^Mebkq
z`521VFAU@jleg1(q`@^KV*yL|jl=uj`%js-ewnh=S{~;3SFRi{H0OP)iTJmtaMLAy
z*U76yj|Ir}zl-0n@Y$tjn^v>rC9B_@k)1EQWRA-}CEI9;FMs_`MxHcUaVq_ozLKoF
zg3mJB+0!#p=bh7Cw5jOyU9;-Ey$QdTeGxd``Zp?i%GFFe?bi`+ZXeW8`Egc6$#m+m
zT{oup*cvWfqc>r~)_q!;kFR#VSUhFgGlm$JcM9J*-kJpb&yov%@IpXXy#D@?f6VIf
z@}H&|uzxfX(>&S7z<%QO<A_{`h<Ak#iob7MWw7gyl$pq*N&OpE%9+%2X7Tt}v{<U0
zlN8>?)LyhCKl;QY*4e(s6?;VE(sHYPcb?bX`|Ik1Pse93d(o!Jyz_;PU;E8deF^v3
z54)@TvzW}<WBhR^>*|lyk`w3E+Wr11#+PDn^{a5sEzSKq7g^eAi>#il+xqT~>-oLw
zkN#{}S-o8L_W|+OS5;X2?OJx^e$Cr&ePey6pXASG?cRmmt7-(o?kKKtm>3rr{dHdN
zlw0{*R=-c}&onsj^Yq(^&E0F37)!hfmVdOsbL0MS9oACboSHqxg)+5?!lxcyJ9t#<
z9M2k_RkF<)dw*m+>etIVek=0a%7roM*Yy1Nt^8;;VNPUgi3HpKsq6|Suj?hwNa*z*
zJ=-bbJ5OzEPts{U<Kn}~nRmEuZ@r$jZsEOO%g&by?U4D_`(?#+@pDzy?Gp;JKMJ3&
z_Dzb|SM0K?;bnoBYt0tX<a2BN8D8&Ndre2G^7z4XOW9KjS1{Ev%6flX&6#F#==Dx6
z|Jcn}U)?wz;<cRf%1*9H*D|AA&X_%1^y}M$YYXOXjyZp1rNvr?xmIO|bldxnn=Xx5
zqE{{alxbDApQRgL*nf7mX<NgwEjP1Nz;cz8xhc{~cNXSG@QbC8Pr9?TFtPxhbElv{
z#7TGCSp!6J#Laj-%Dp&s?rtdInsn*zUL9_otw%1Y@?L5xX>Jkn()MUpP}P*ZG?yu;
z?sc%;`QQJI@0(j6eph;~^wqxerRNX$tY3OsH<@{Jo5rD-2X|_0910ue>{_QMFTlXU
z^?{-B&y6!@sseThKgqW?+st_6E;CoL;D2%FbFxfL$~m7DESgsE6*I1=uwwkd!ccSQ
zQH|0g2ZaWC4w2upIf}*EPc-jYV8&1?*T8j#^-<$l9rog{rR}$F9u_S9_m4Ayc{B5m
zBS&0z{NrFhVc~pdVZsD%2U(Ww?H0;fO^$vHu@Vwojlch?v(8>(EAvk4-09bE-=1YI
z`u3o4=WWl8#f*Cv7F0Lz9bta-j&&pBA1TQNj74pKOr`kEj2+I)z52M^Sv-yVJKIiY
z299Q75uU=24lNbCZaCaw?0Cfxn`+vyO#8@F|4p~%v*;a&Z)bk+_~CE$yYUzI3pvLA
z<6vt%XpkO0p<DmTQN9H3(k2EI(W?~?><aW4P8@wEF8JgLqw|sGJq`it6HJ>vxW86t
zSkz<2&@$u0`kyuj-UWp3VDD$Y^74Amp8b~;`XUb=b>n;XhNrNxI^q8-f4NtDjLPTk
zPXE6CbZJRr<?bK<dvg}*nQhyDY{SQrr&r4xcU3w~dHVm6g3pcpxn%+t4jddTT}-SD
z0_F@y*mKVRUfnQnz4jA+_51q9No@}G;WM-kh#9h}2xM_P)+GL}ZrG#1uw%En%7y>;
z`~EBC*x5Dkitw;UIKNq-cVqu%<ud}e?F}FOySvbiAy^^l?+=Cp@$>8JW-6PVVSD!I
z$?w_!j*EVtm7%S9LZk4X=_h-?$jBM|2j)l5;6HFypM|BPvy;)K<p@LLf8WKdP5-VQ
z+wU|rHYbr`qy27InalTOtN(6g%Bg?ZEc@YpjFiEVM@|em`@i4e(O_Xw{`cXpeg1EG
z#sBr*|Flp4FFpT%yRxgl`f~d}IrT#S?CT~NUpe_*pDn4-_92Jhio*gy1wZ3gDL(Ok
zy2?3c!Mt<-Ux&6e3nWb_+*thUxxzxZt^oOtUNI5AZU2ko|805wKWLWl71l+ppBw&F
zMKj!~ad`0mhrlN$Yo&Yq{6~WRJ#13A^7;NGF1>^qXZ2@(<mO~{c=t{rK1U&G`j6HY
zhJQ62wznK={zW7+==XE;^l>mM9OGuWap=y*`nxMP2sDI0oBq;Yh3Uc6-@Pu3dp_--
zDA5r9P+o<J<%8Bgw;G0f%l8Y~H-x`57h?FJ_1~?dYSn(hMe}~ydx#vo^0&8zaSz*n
z1w$6$FVc!tjQ^W|2wZy5`iEQT)$M=WN|$c^<>q3lc>BMxsiW>qZR}e?{=4~XNqNif
z3oKN-S6?ak>uKv>Zl$iB|G1Sl?f%cL)YkByTWQ&cKfFH$SJwP*_`frF!}8tMk1~Hd
zmv?agm;V2;&q={fz~I{(6CNGGcLCD(s=kJ`-I`sUEKyszRafog4)Z9EbDy>zxF5%>
z{QBjN*=wfyiXKhab<M~1$&C^Q)8h}XcJxQ4`<)1y6=Wylxv<>#+l<`>4~|DJmu<Pm
z=9X%%HA!x>Tgj9)zRn4$U0J7QC0W!;D_&CF5V|+A==!sbsY=_}3)rT_30ztpc=&PZ
zr(53wl6qgx40|}g_bi8S$6a4zo3B&8y1x%dTF5zl)7ru*_BGdigpKU=^}ap-@^u;a
z9I=&U*EzynCk0IUwerGq-hDq@Jg3cBeCbK!5hd*s#qfzr1tvFpLkxaM*4D_IUx?cM
zJI31l?rX<0%st-|7PE&`v-PfQFUdMvI3r}yBLmm6_s6f<d}lduPVCC3eK+|zw`RIH
z3pL#}-m)flm+I4NM;OmPR@49eWBLUV-+->p#%<iuCnv6uk#^#_`h!28<B$4<LN<|g
zlft>CUt$hxkNCs!*Hy;j+HGn3{G7y~g{P-3Imv5XE^^suYFqoV`t^LX|GH?TXYW{g
zZj)}>4^KrkA3v52muF1r)hSus`=;@-Ml+L*@g4In<^~r1Ttm69u`biNIMOd%*>|MY
zMel#c?$|E{+ZSDM&oPQv_(A61fqMSi#ter;=d`^)EVSd}srNfCl&=!$o|C<_F}?7Q
z;Waz{`(`|EMC~`mR8M-?o+|#aK(pjp%}XBM6Ng%@(|Y$@SQWhYzy#KapB!1d@AmF7
zOMQ^@KH<J*ee~&?ja&(xV!4W(2fAj7UrCYGtBY;3pX|7`<BEY;=;Z@-9<}<%zUWrp
z&D(CUOmoQzzN&feAHDec$c6pP-K^&gv9Vj;T-M}JyJuKoCfO_YqDo`(sdG6;B`@($
zeDGP#;84!JqFbAN|K4DV3s@{K5Nv(nh<hyO<|TT^S>zpV#k{@TpLyoV6}zw28R!1J
zNxUz!?fcOJ{-<YhOSNO3)U9VYdcQ{d=fBur56*2lydtT^hwVB4b;V}MzQw!zR`>4`
z3}XEBp!RY5?&`RT!y4zW@36eRXaCuAxz*Pue!Vs068pNAjNL2d|MBp=>HkS2d#Zz0
zu0s}Q^<9y-3xeYIzpeN%>+w|IjvWiuEe>uzUJ;kDK_M*jxT)Ay?-!AO&Ie?zKmWN)
z$C{1%*di0YnJl$+_b%O!?k;a^bdNpA{rpV9r!A}@d#8MuQ2k7&vn0GOSJL@vf%!!4
z#7kA}HPNRmGk?nP^ld*>*BLwESn=~UhYK`)I;Xrk(Zl;n$dvu*Uhd-CtMnE*YIlD!
zDSW%h^OesuW~Y_Kymt#;u@p^tUivt#(!ZD2Xvev3ZWqTyACvQQ8n|y{DW@lwAN|K)
z6zAG`OLFF}!}7uT7i>5`NPMUY$!2ppxYuG?)y{jf>J#reWX@Qgw_tb8qta(dg}#D5
z8U5?)b++rDl-(RsxnPOr-N@Q2QO<1F9m}Wgk8iqrCMv>v*RFS3H$E**TJxsNzVbu!
zw=?IymHCHy`0g#fA6a}Z_w`l34LgcWR|{F`E}nSvs!hS!H_JY^8Y=W275`J}^ZQ}J
zf-|#Ty>M80FeXRK#NkxjBGsVJJ#!|Q80@nw`xtk3lm36}gA?Z$ESZ?}{mg`?>{BN_
zxNyMl<6N&t8p%~bTb3@qeRAsjsS~$NzrVBO^yHb+a$8F7bbp<{zh!1Xnck{bW=r>U
zWftfjUCQ-%uYl;)D>a&Wv9}IvOkXD7J3sS+h|uZRqNXpneJ;gpc>R0As|jtoGn0aU
zIpyp=9~-^!kK%<N(sH#kuiWYDX*&0Ib}7>q|8@OJ)9&dgTdv}H({z&acynLet4V7`
z_tsb#efm&3*Jo9#WTqMa-so4^?uB)0qu2254sX7mdu7dyunGL8k1Ox7_bttfmwnQ+
zR9IKaY+;D)`QDTu%L`(*pKfT%9!%<=bo!Z7&}UVykh>YdM(2*c;j8BgP4@Eq?z5z|
z?||-`efxzUem_}qd~#gz!|5VP*|#?895ed<EHG2Y;`;%wYA5cO34b>_T(w}``gev>
zrsgIFo5_u74=)71iR2eJe?2v2UslON8Poai1twqWT5#gT=FIhy%WH!5tyesn@pbC!
zbt)&O6pFgKHGIiB`t-r9FR!Zeln$J+d)KQkyUTFXyYr`G3*+1_Jn{T;@7WfO*E63S
z=hgH|*t}?N)|v0O6h%KV{A&;N)7ZT*<M;LeYt3Cv`9B_o-BgTrT(`x$H0b$~rFn1f
z7VSHc;rCT3vN^1-vUIPM%Ja?Q?vBr%+czn<pFhDo*K6NP)ypM&mgWc88F>fnxKVug
zUIhQ|7DrqDm<7{Q-90DvMyyk7{duAMXi-?vRfGNokKeqr_`cLILqgbT)0@`K&GK$h
zIv?inO<jJ3?X6HrtlEhOE)!L`Z=L5XF6-I<-|Et{rEa`SY}Z@twcj11B_Lg%xaN<;
z-(3Q&r&4@o?48iIq&+9dE^Jd*`n%(18=tS`OPq1+tcv=ZtGO*{RYnur^3OgGKA6Mh
z9Q<&dMwAdwhUlw*AM+L+zwA9}{z^gpN%0eR@~fPX;&Gm59lg_g?=L;C+y&NO-uPUJ
ze{ym5!~^VXzwbD+Mu<%hk5g=Yx7ft<cdO4L&UTSy`#hcGc18K~eEZeZJ;isfWeH#S
zw!=o#bI)W<+%H?=DSdRYZ0=Ea^~!+RC#3fuTRne5<!<8>SE7IKd{UrRCbd3!rKiY;
z8H=mmc3FSot?pWS?A!8xqP}75txL+HnR@5MemN7gc~QP*Ba`#h^}p0l@A_&rdG+4I
zX=`)D_61j6`=uPZ>$=1;|A-HTrwTUIDn3b#H#}1K(o|~myuis;w=aBqtN7<&Wb(SC
zMFID0Rjjfuuo>HREP3Vkz}cz%jmavmLzX+zrmps0DP;Hk^UB|Hb#8B7Sufj>QLH~n
zUNGN0!Tv@2*-Zu;SAKi8#bVCKmKV#|XEu9BOx<w(s-9<+Q?iGR;`ALW8v?{OEwN}k
z`)GF2!^|lvR~E6RsV=@z>H0v(c+-_f@u?4|<Xvy+U-hK*>;;*`Cn>)R7Q3ZQt8sDU
z*i~<~!TIOM*wc2~QYUiX`n~Y+o0eUFqn?>x_L$)Cl`(NvX9(lt9x44<&xOow<u~a|
zTAvga=85i=TI4s?N&C}O^&MQxm)`icR{!V8$iOP2*Sgx<nfO;osknrQZ0uG!v_HOz
z<Lq9g{m~n~6)|_8%en9@D`S6<*NtuKIWlVl#ko!v@^qhgc5CIFO%KX1eVyAN@`2~e
zlG1lm=05r|=gAlUJgL__{3oY#9MU_o{Qi2$hx^sI>++>j_dI@PuqZ%OqcJ!1vbMI9
zlmJ7tQpWN+<?}|p%!w|-m475(?zOrZkf3n$wpQ;&k%yBPIk>lPsJ^o8<j-lMT>gJU
z9W*jaf3W&0?-5x(Z}r;x33pyR6@NS3^;GfBFiXDPC;Z-9KE3|aaZamA{QjZ|X46mP
z#@p_`Yj>qdFaE+=W8Ej-uZotfbuPQxz+3fb0?z^kw~bc%uWx&8mY*B{A?N+=>9!Bg
zKiesl|J1>CXX!ytb-CKco5@@)?y<U}3H4{M-<*CT=M-B&oAz&=k1y|h^yBsu>@EKB
z=#}!F8x!Ogez_=@a_qUtj#|;fj9Leu{@}gn`>jZRqNntibA=B+?M$q?RKA((OW34m
z-{hxVv^FyccwM@Q!>dM}f5PF~3;Xzu)V9=ZI%{nZ$61{;vp)NL(zV)?TXNE8MCQ)y
z-tsO?LBlYsz+k$s;m<OkABWGMi3(lveJ``n`_>bSKS;J;_S`6IboAPe`#EzuY*%<a
zw%<GF#dom_YE`zq;f0~IW-HV$s*Y)QHw~F~e{O0n`!bD}fwJ#EsLO;tX|Y+fPC#bg
z%+~z3zl8YW*!5<<{Psi5lzG`ti<dK;9N*jsR+V~|{v}_#{#$17meVs@Zfu|CaqvQ*
z=ILgW*_Zjg2UReJL@fHQ`*e|@uhR)fnTdw6+ZNinEPX%u-Nz(zxvt9Ew3&B)UaUXz
zWsB~QWr^QrKZ=We=df$t%Y;2r4rSMWIyVK|x&C>#>dy67V#{<*{=8gmcrU*)OpHfm
zhuW4yX*!Bs-+fl^u}uknc`2l@-<Un|Wo&7hlBLG)G<B<O6U)!l<)2%-DrUWQ?3YR2
z>u$|dlZ=@ly^Y7tBXr4j)%vOGeh$_;J*_{=KeE~i-MkTJdc=6bqP=H)-gV6VB~+&0
zuydDG{iO`X{Q;Bb{5#X|>{*pefK{Bk*Y92Ll5KXqobFaAnfcUjM&+tgKbD7-zV2c8
zF>Tj0!Nak}zkR~zefaBqq4|TpIK!`))%m-gZ7pKcw_o~AJLgzp8>fWBTF-q8977ad
zRP=McNMg^s-15TjhwPzWfr*<!be6pNcYDdM71hf8hkh!&X4QCU%f387HSmJjVkQOc
z%lo8M6sGZcxlDYgp?kpc&2sl^k#}zTaxe1X_SW0LX1Vo!eT9SlBBfUmVXOYMo?JDb
zed?Z%8Yy!gz6`kIQ_!RNPltbR$fuQag4bouS`)c?0?XtRYfhe-Db0Fe!#alhE}N_-
zTuGWIFj?UJwSNmPOf+Ze>vUn_UbbhI)|pA`mk89)*iv{qEqWLCR4&huHIJ8BIdCoH
z;=C|Na${6vT8!aSlkINvZ*lxkx>~qJQgVGt>`r%f?u;{m=b}W;Xx+Wnr84n>vG2NX
z6T*%4m-_D%kH~-j%gwmnCT-Pr#w)r{9YT}jC7)Y;=snYXENt~0t5AP|!~Lyk^EHnO
zoRSnca$)}huenDaXYOIEtoi(J;R9tAS-v@SlE)V?OD&rsqWIvkwBYLb>pSccif!gG
zzx}r8@s5gL`wKQN<|uFXsd#_E<eB`&Mf($8f0A0%X4}A?Xs`Ky<N51}1%EbH)cI7l
zX|w+5%HXIunjBj-_j&n)w_Y;0n%Hjby?Hd!$!e-~k^M9uV}G&RM{KWg-8mN4ZKYF@
zz*?bSG4Z<f%=uN1PBp&2BQ5^q@M4Ecu?3my?20D8UaNa}W8cc8T7j>O&9<c`zS8C;
zChF-gwf4H^#8@qzF=@fs_$Ze4$O#6&XC=P9tF5&6?xwHHb@Pw#%LYx1NqZL^{KQH~
z<7!%y^3?^BrC&GRxqo_Ek!qE8Wz5U_qB$SZRpsZpdr$PWeYS^b8=pq@uUf~K&C<^U
zYkdP}IXyMhzo5QsQM7L6yRf{EKEb?|>Kj=~ETSi631?oMe=$3~tmfxdMUyR4zT7!-
z^3wd?Lm%FHN^H4Mz!6@x_2<OSk8Z~rnx?GzGiB$O1M?!vH2zPT6&t%NmC2Cv-l|}g
z+YK5^9se|n#IA`-+_U-1LPH0`$GzX)&b{JLl;ZbdAKTgF%Kv%O**Gng6p~+^nXoXV
zc9Ku2<ok9N@Awa)U!Ko%_cA!=+E;e}c*b`5)5Z&L-DDEkd&XH@hUpQ@T!!lJQ=RS?
z{Iy<i>`nNKO+ju7<xWMpo!2urBzpziET8-P&AgiT8+^259xdB(<+km~c4NNH?9VQW
zMx}3_Zo210&YLN#s%OvqyRIj8$=h@}Jwx?-r_LR@vrglyoKx+jkW|f{!nfbv1+KZJ
z9l~b1YRdDdSGW7Ow!U!6G1!@XY|q|XFY7(lyFcIxT>C=$mZ!{CdwJWv4`-RjK6*JT
zYvL{M^=CGo4t-W7x%|eF(}@Cy{)-m*t3OO=+G4X+ar?P9%9RUs?3`bf_OF~b?Un%h
zix;J9sxB=pPW{a@Y4xL(H`AK8=ik{}-t_D3m3tqrtPEmoT|Ddc-Sdw=ugmZWSx}~P
zEqUXDKigitw^48X?r$Bueey?keU_Pl87mWHnm?TK&5t@gjekm1q}puz!kVv-Qv%;M
zYssCNdHJI2!63s-u0JAy>}+RzUVhu)rf^`7=9-#KIcdsP?YDM3w{Y`G%&B@Gb9BSJ
z#mCNgM6PJxo%GjZcHHkhPlY~3?RWIk=<SwOuNOXUvdK$t)obO%HRfOW-?<!k8#G&o
z@%c(e>Haf!9yUE+=Ow@K$={6l+pe45ILFQ}(Q==atra~{VJ?>#_xlr1cg}daa~emZ
zz$cB?qgr(j8G_b-e&nP%cjJ`T3<p<o-6%Hrc$GJB$M?_+eUq&Fyz)XcUX`Bbn)xie
z@ZVOO%QD{=I5a*e+`c@U|F_zjl`A4WpURks++p*4bF@mtVw2R(xvy^~>DlghAszSN
z{Pi=TmriRZz1Egn_AEbM>|S2pxjO}qZbpT)?!0>8<Ga-3pKY?l{FbzF#w*J%e)ofK
zMpgg&ZAvqj2OFvEna=-CV)}ZYkCpox53)_FfAQgDT=7p6UW*Ac?NrlDwyOyr{`0wJ
zw_o$lJu6xlF7#3noB5R|dvf&b+E;0Hsg=u`_(Saee`=nxr`j_9liJ43UQ?_dOA396
z&5*hMbw-W;ceDHAMG4k#|HaLHcl4UbvDNdp1beN?(h^#A;~4+uAH|aUxP*PLHsrY7
zN@f3e_S*h6uXo3UF6=(H@t2mVtNG9MCvRVUcuii)`TI-{!_%odD*{#@DxPhrG-<)K
zsV6^A%(8mCdc~sC2fe>`sr=o^b;GE2kGo;y!ri7fs>4}SkMO3|ew2QA)^ox0Prqin
ztT_Js{EjHibNPW*vrg4rI?1)?>jDX-0EeAt-udmRP<U~ZM>143B+g4C{><)B;|EqB
z|9<$p`kFYSn)eoK{XXHDt?M=~zHVyb!TBU!{iO__?Jh}nJA?4l$Cp+1seF{-Ow3EN
zJjlW?wep^d&*iE-0pG-LJyW_K%~ji9Tl?paZ_1`N*Z)=ljWdlt&py<#@WA(|6)8(A
zCZ|~jEOx9ED*t(GieuQd$jDE7e%@dy-MaZ-)sA)E@rD`Cstrryo8~OeP2yawDlWyK
zHlbxxkjyI4744mmvie$`?Q=Tx_IJd&GpxJXr+J()_C$_6gZzH=kmq^Q6>@>wbkv?m
zMqjJFGNo;I;oX4GtYY`$_pZ#mA!xgJ_o`j`cdkCvofmsM?{Z9E@$1A#stOBVpDVKy
zF#SAZX>X_IX7Af-$KNhfS>7u+e^uGC2L-a<9_CgWRd;c9f8#N3otN74-~+>2zUE6@
zI}O*pj7a{nC9n0v-8rr`7dx-6i+NyYo;+80e(awB%c^;c58RF{)CruHJ<UD*sOvBG
ztVQnK)o;wXoLDbfMQ!^1Gh?>!^N#-;&TjU}2ugc9r{>SD)JIwAYrluDl+r2_Jy-0W
zz`*7FFQIUD+6%P|`_x~19~$>vObuI`vj4`<Tlb{Azuwz@v;5@c7xCrV{sv_yf5*+-
zeY?o><VUs(?`@WzU-#hC(YQ(cho=^MPx$rgX~%>|($QrVzY34-?z3Lu=kjG!!ckGy
z(?<^p+*&dD`R0&rqf0KIG_R$<*^<0V<<czcw9i((a)tc0CvX2SQ|UQ!%KZMJz^$Lc
zf-=&7^sacb{^Px>E%M8v%BQKGZaM$=%BpX+GBsyRPwdd)JUr{=pKDJ0uk8uF=~+Lm
z;CO;^T1i2j&N}^q<>z#MKK3$G?%MtLcGP{-a|KI0E86GnoVj)Ponu#Dy_(U_@Oj>q
z*3GAR&3B$L?sB)EAAJAoYKzbX6;s69H9zgWKH(h0g!0wDSQaGS%C)P@SZ*!y&(Gkp
z(PPg1f~1A^EB8izo4szqq0;v&7ghZ}t?v@rDC-#OJk@;fwEk~>(IxNCX1mDEEb%*+
z6Ccf^wfTYlTye$;z5?%DtgXzr=h?=mZc1CyS}w5atYww7aE|2H15*>HEbLFeBX^^B
z?uzd#Rr^ngepR};)wWmVE~A08;pEP9VV49>%3Z$DHv8de)n%GhLdxsUyBV5^tcti%
zB;oUN?)Q}BulKo^AF1^<uYFwm@hW@t-kjp=+0*={wP;Uoe6d+oa!K_Po5!A2mmc=A
zyuJDQ{M(t?yyYP~U-NZ}{$AZ=amubiUX1_G%I6E8uIN!Y7{BTGb>%tNls<NRjr)D#
zZQaV-x!(=H`9;<r?ND5$QMt-XdrGisyH51xg;t7Amv?GwC*8_f@LYaZL(2Cr_iS{X
zwwq|3>Nq)3#7E50=CJ+lcozMt-v2Cl8K?X1iQN6ar!q4>F>uEEL$8XRpL~uzc{m_p
zdUuz7YL<F+){=0~7~x%t?|M{fCV#F?{pD&L>Kv=JRH$xF)k5z@YdDwQk!fCjC8TMA
zo6)T`JnIvVg>)RTo^`DJSHmL5UFTPtG5o&1$B^&O`V*QHwqLT4&6C{pyU#o8T0ue&
zpHOqbR^>BYJ@Q*R-@kYsuKuy<k#<;LgLJvyy2*_-3IF>NOLxED&cAl*(UjdUYJUA(
zm1Q!o;lzb?<we_q4*UqW6T1Gkt(_rx+N0<V$(gM_Hadq3c|Pr1@3Km|bb0lG8*45d
zKDlxFS%uP9HZvx6T-EyiuYHB`eBJG_w%vZYS`o`PhxMt4be#MtadX+$U$XzNWj8K9
z|Mi(xVYauz8XcuO@3d?r-21gTmL4i}Uc0&@wEWk>PwDbXhxu7ft4H^J5WKO|PAmLC
za9)Z?_MancHTsP2Z!e$GdNOgv+L;Wtp*4L!&s=VLxOhTvq{PK3*=cvKe*2c?qm?ti
zE<K5@toxUdhJjhGYOuiC)c<j7Uml9>x|eaZDWN3q<n@98opb3M_Z$nJo?P<7P$)Gj
zklop2me<~dd97`S66e;gQHX0}QM|qInNxtAwPW<v?LU?kpI%yY`1#B)>=Mg%`<uMX
zT~-?W<=gWgVjujsJ(IiH^R;DT2k+%YQde^C?A^DAC*l&XZE}#!a`wY#rWY&AE$BYM
zb$9yeD3zs^=cl&Sn(V2OOZ!#UxSV^*W937~x7>aA`Ps@hi)Ou_Eok!h{IM;~oH>h6
zJFb!6bLRf{wQJ&|Jda(dosyBD>#ARM=3JQk0pTrt7vH4l)a<;O?!9h$k-m&$Q|aad
zzdFy~ub4fhcZdI#tU0^uKOHak*>@y#(z@SM&E_AT^!5BKf6YsGn^`vYbtGDey_I&m
zb36GmV@WP|a`;E}hv$nNth81X#<SJTox`A1)zIJTCdReGyS2aTw)Nj#S6wHsNL|@A
z)rsk*%bQex1HB8H?Qw=*uOE!>w@B!^(|_ubT8P<p)}H-8e;#!dQnq3`%<KGl67&Aj
z&DR${*4Y|&k9+R@`ni98P5S!oxpjfy#mQ%@eD57jx4QPVM^;$V^?1&1C!N5LO1V??
z4fb9#Fxq%{2cPL3zq|dbdp3NDyREb5s87|Q!02m>D|5w5_huZPDK&qsa7)<1%0E6q
zVJk$>i3F%PI!6C<J9D{YM@{ziHC+{(%rC7k6k@%dYT9lwp{o7OF3XuA@xknq6&hOA
ztS5Hv^WP(@n_S^oy?f`2rCHO?s)smr{#?hr`0BlW)}-%gC55wRgbIJ*{H8uP{C%1G
zKJ6(VX1L|XMf1!lk=Z#tzlQq;M^#iu$jQ3=*r(^_UMPRwl0En1i!Dp64b<aLc6{Ys
zc;G-q{3E6OR_2o)E6P^5cNk9f$jx~CcUhq4)R$B2Lq&hDN~((Hf2i=vjrIP<6~a~m
zPnj9x%tN0tF02+XtlbhIa^{-IuXm4FP2_cT?(I6AJ@LyEv);3bZ=aSQ4w<zxQJLH3
z<AGQ2lcQYq-<?;@yJK>aZ(f0b#v&Fy*A4qs-gSzVemoI=;Dv?G6dx}$Zf{SM+YMFA
z=ASF_z2s^B>K(`LyH|cc-^@Qh+UQK0UWU77dac<>elyOrX<Ew_u4QgI;<sk6`a^->
z{}+rZD)*JQU8-Eu{<mXRo6+GZRzKOeTOSx5Rk&7bIZ501#P_Uo>^pW9%k^}ofAU$e
zXzsEfT8VwXFMqP`K6_Q;;-%Gh9}2F_FWi;-`X;-Dt0%8Wk>+bR{YUj;`ei<IIci?I
z%J$BD{c&$ec}n3eWi6#Q^@%1yS7z)nE9K8t6R~?0`#NH&!ThgNPXwrS*6(ZUmAkg2
ztMpZa&A&AX?z*?vc3eBOssHL3)o<%2g;wkFUcKU_m7ngf{^s(WUY=F^6|0->?LK{F
zwwP^7>+_%crcN<*v`aBDVp`Fc+I;hRc>n%=9A^|v81rUtzOZ1gvPwYJ%-VZiTQ_g6
z+7!QY>jHgcZoZi|y9{%t<e%j_u&iT&dd)-meH&$XZdvxm1ZGypTz=oaZPqoGxie?+
z2exmh;1HkDKU@D|&AgXu6prsa&{jA%&FILb-A%u99iExabdcTF>~rUA@@BL5%6Ggw
zyN^#e@U%$bTA_L0>mwh<YiB;)HKUMIU23M;rZka7*P0ikCqAFa$19?^&2bqI<E_BI
zx25AU+_$TK>@`(1ohI2?vvp02=0+x$SL&W$?*}%?r8Ylm)s;IR9%*z=D&FJ6XQ6*7
zZ=YHDM2Vi*y+l_cfnVvlu$0rhYO#Y})2(;>E#B(%m(AsU{Ds-!B@^=x?e2XR7ilWK
zt?;I$Q(&C4O1%B0xrt`aMBiBjYs7GxOfdUuqc8CFZEcz1@(gYNB4<g~4;!9%{JHq+
zfc@X*NR54)nzI?$)C^_cvCh7F%OOR}lG$?Ngy&b3lkJQAm~O3l{MJV9)7icm$+M+(
zn)H6`+3oZ3DgT=S@4d4o-7(VW@49^J%Jp@zSFOIYSMy%{c5(93y?hO~9Tk6la4Fm`
zmMwg}>HCElw{){?isF~rUEDCM!DZ(1$$CdMP9;uDiu{#S_vrevp!d6OKi?|(?oyjb
z|FXvi{Wk|Bi0UWb2sM7UqNc3a>ZyVK=S#U9$LH<K|Kf9La@7A@Dq(xyEpq#E;r1@$
zT;{c3w@tm#zkI>3g)=^0R@$D=B%Y`K&%|)&Q#Z%Ad-iQtU#z{fIjg+rLjTbzAC`aE
z#l82=MXM8q=JuE4&ayt4!g1eYhhy~n_K*kLuGo0{?8&)#Qi1*d?J%{f$8+5Lvpnw^
z9Y{WR<a}lR#xrw@x1Z&fpLoFfzIff;ClY>T4CRgSeYeB!ayUGFHh;79$%va8j}^Wb
z#Lj0a;+QezsfbPB-0z>PS8D#(+-$YZ<;TpT&q}AF?oRpmq(npd#m`v}b7S<Pj?U_P
zcIT3=$)iTEXI|!_nTCSF+jp>u|EymAZK{Cf&*>2|7p08@Kl%5V=UA+L&lF#(E6Lii
zQsvXn=X_cp7F<nfn6I<6;VJJV-Zhy$PmkwCwx7JLdR-^ven<_|XN!)z;f}MdXL!i_
zh^SV%pLo8(Vg2MKZwt%cyZX&pxBq6d>xQZM)1ue)pFb3Lm!EHkvGCryrzr*}gpKBg
zyetqqwR55Jy5BiPx~7+zz8&6R{5dSE-%7Fdb-L*>&5Z?DwjSA7nDBD@zc+$M`O_^<
za9Mquw@LnU&dHN}?nT>gb#l)8xnaM@g&>BwI4L*psR6g2ZQl~UI{D7Cn^UhHxOb-J
z>Abtq3uacR2(>+5`Xo2}b?D-LLklyhU5Q^;n7;~I+jBrn)zD5?Nn`CJ&BoSWCh@cK
za%QZtt|?W1@%+2zrnU(y6*6Tsbygi+JX<!<oH_ZN(4p-4tLJo?&u|gGl-ZefEIw9k
z{?UhFe{{|z2W?7tw)0Eu5s~RB7s|}NgPZQ(T)*#l=kvU`f5Y5N1$=sCr*LGyxybLG
zzC1I;rR?7Xi}h#rb;#EK**W+3+sC&!g_d8`x2*egvokYlvElmi$UFBooVmtxu13{g
zv10v)Zvk_sy*ehSmhi)?V9MesHM5lhmu&n6J>v>gEEjxCaGm0yeI@ME?1yVYB4)66
zo5*D3wYW2UXw&OU@zh<>dMs+cy2z<r&(>c$d{_Qy#O5gF=pCz4^DkRSKY8PEJw&5s
zwqt4j)w35XqvK^h)djCUDR-PZ_Q$bpRi&28PepokzV+kDT>PhTZ(HWRd<nNH{%a4p
zty}0F`$Up=@?A||BSz7jb5$RAR|LL#y?0GWY)Qc@|I>?abXQE!Wh;Dh(&h4xmI+~k
z(_e5bmCUc<`lPdV-_kEXN=iz4FIr!(Ys-t}?0)L|Oy*-qc+ZCerE1TaeK_{KU%c&M
zWr|$mPH~Bq&lf)oN<QveSTfa*^|(vZ<+(p6C_en`qdDnR`}7}s?bRNCmaU94VV%jp
zE^79^nI|@=-aKQp*P#3Uv;zM*feDFTSN3`LoRi+-#%UbeJ=asSt94DS^WNWYO#ZNa
zuTlG5msdFdoAliK(^t;PTf`H$O!nmA73cmlZ<u5A70cQ-6GLok+f0lM5J#z*8JlBW
z+h%TTY)16jwsO{xDcRS}JT&fld~PT)pX60uZfwBJW5|5wf~u;<UEU_8UXQLzimJU0
zEhSn@Jv?g`&-*^-{ht5(ul-*inf>f$b$s>x>i55Q&D+{G)$@8oI3LgUW{ty%9&wI#
zjGhjTrw=@^Q&3PiqpqOPa{5#jhwCn<e?^ZsNjcjH23Yufs%I3jQB+VlwVcCgQ9)FJ
z#DaHExj49(o029qJ(|SC)G(o;;YfW$fxoAN;1ga}=BSzmD;YM&2b;7G-2H2_u+Puq
zisAoC7K=BQjE<a~h4b#eY?vc`L^zATi7`rHiSQBL(nYo>L=75lJ1ctZub=v0LYb4&
zUDcmIYinwLIOK8I?O488N1guxv#S;3F9DV#m!+B5>UeoFn(rvot35uP%E~i$L5F=E
z^A6@q>`you1Ng#M*s`=aq*fd}AmGnXYLT#D8Rv@~&I$DgX4Ny;9Ejh|$nulrzux!o
zZ|j``ZoE&Ku-Ep^Sy`6P&4*+d*;i<@TnN1O#QB#}C4&IZA8w8!*8_n+74ikHh^DkN
z{dp(DqH+2qqr#Pj`rh^p-&=Mm3)XO~c)ecmXZ=*i+(=Hgu!h|`9TPlQ-mU*9vT&Y2
z^_5$HfBe6*hMVUdGxv|v1r3J|@a=D7sNVTm`rrb&I04h6`xP|A-`U%_a|j8D3JC1b
zSKx54Vdz-DSNQ+>Pi=MYCfq-GKko{QBjdY*@&k;fEGitY7##mTU{i3oC&2LXB`YV_
zkNb`F(L0)&7$ma#S>7o01xUQJzZ#g=aadlu^yj>Q_ybN1M{OM)9$bI^UR_&c?}36D
ztMA)?xc~ihzEb)M#r5a@ra#)B{OMCcyh1~`kH`a2AyEbv)*~$pg@%p_FYc$7I9}L)
zOW=okIPWtCc9nl6-BFk8t-k&1W{|1xY!?1euA6JowN;?uvHYZHt`4pni}$ho-@o#o
z_0#{yKE#Lqi&y#ozHQ3hnArMu%ev$L`wdR;zIydtoWV6pU&V_ds$dFF!hc@V#y^5<
z#aMX07X5y|LQ1Gbs7dC`#jo#8odiz>#B)T5cWo*Eb$FV6-Qswy;?_e7y9!voT+e2G
zASxp8W4(k|)Hl5q;p|MVC+{nAcv=3p3*t=UXa7HG#)K6T44=NR{Cv1bPcpTWiLpsT
zw@Go|eovkcpASCp2;pjw(&s2>sDAWsSD+zhL;TC>ueYn}@qNhto9nqi=YqW$SLXli
zsu~&$9}d^e{{QOuz0;S4RZrgUaWwrc|9ksCMS=JZ+jq+|ckB&mDb95{9oZ|hmjC@R
zgKw9-ZcldEd@mzV<@TA)4C-fZ-_#P8`?T$W)~ba(cW-Vw{`hj^mYCn^%KN6x-MMi7
z<xuVk8D4v{Keg{^Wqy9&T2_%K!J_x^ii%^CO(!+0*j6b;bNg_A6Pf(-w8uxihihM*
z6%Wtt&@JxNZ;<}*sbz-dTro-Y>G!`q4eOB<KFw8h;mjn9c~>qgT|OOfHsi~yFdmbC
zA^TLP{koHXR>>~Apm3x8_uBln58IV`--RcI_McpF^6%A|pV}w=UZFXu=;~~NjGRx4
z)VWeSFFutuHk>ilcwX4AXEAOErj*R?efjmU;payj>#sSOw0$c`dq3&ymF3(AEoGzJ
zH!<!xb)?q%xz}IWWoO<8?aY(QSX8+xbZTd$QRoee*SAhjeEq##C;#~+bAA3}k$yd*
zt5t26yJ=s(u)bHttl;{oV4=4Y=jz5c3;DMQZ!zA=y8DTOmQYnkaQ(c3eZLMQAHQ34
zb|zQa$0mQdFSq57g`2tWu5J5byl-NjdU{5_O2Q|u2QCFHo$pI)%=gdQ^T4+|#K}S@
zPWg?{rbqkVetjXgY}bN%6;s`d3unJJ*9>@Gp%GcT+}CBhhLiGD&YU@W3br;*mD@4p
z@42i;N6&0(J{TzI`b*&V@{^Cex5=kH=f60U`-HyNktf$y>|49<m)G*F6I1km>8AQy
zYo5D&x$Rxf`LZVuzpd(=SMg=;F^A1uth?U6`khsJfBJ#w5BI!fE;h*RWZJ((PgsZX
z`h-7sYz2dSW_cNUH1B`Qz5bln+!JDor_5S6x$`ua=!9I1)cpI3Yq#aM@0a6VpL;sp
z@12tD+#=1-L8afWxx9JLnz21-@~W<B?=Pu~ebNa2zRSx{bov%i>C2No&0_6wSu<yn
zzL{&1=Bqs$mdspXk|_73vUa_&^u*4&4na*~J0(ue+VHpLcU;HEDUY&Vo0q&lnDOq9
z+m<?RzKOdYOgQ+u^Y;Sbmr9>rdUjr#bNuF<m$ml(Pi_jU-fhkETV3{af8S|I$-A=2
zmK<txKgVZ$w-E6?{jV(OT@6q8*FGQpFYAA1u$Hc|J(sIhdd=vDl;>j$>-10B&vUlM
z9NzOdZhrM2v)fG5yziIJ=geF3$mQ6qR3(?ME!nqjT@Bx>cAvX^PJgJ(g9n}RPo<4a
z@*<~OEc|wD$A|ge#%q??Ji4-Cu}pAPL{ayL1#dQWr9INHVlvNP`6f2$6WiOM(vz3c
zAFhdXdO9h`;Ptz(<{PX{kM?@|rn35_3r;CCv^(naGUU9@gwWjE7egN2X*8)hv20Bs
z!>1iJ6E{usTfuwo&~>Y*t#Ri*NcP?@sNcZ*F|Bd?S^u-n)(uameaaIJ^*L`d_udcj
zd5ab<b9<vU>9M)n*&@w|h^jXVM!%;ld~@BYV21J3ik+tp`@SwbbbiO5%Twm>=1H}a
zQtQn+`)T_5^HzK6cdwN>SZASIBE)MbytBh1tNGEZ0_)pW^{YPLJIX$H&hI02^{>yG
zIyJtOa5GwYDE|3OSChOwXTNLI%SIWUw0wWTWIw|~jphGm#w?!HGy8<G$lLYG4`$tq
z_^-Tq(!UdWIt$hv3!3sb#BtNF8|$x3x+8k*d71i>|7Xjq3X}f#OURtD&+hV3Tz9YX
zMUnmb=g(w)mxiPog<bn>{cPEZiw|xsT636xkATc0`(`y0He0b>bHgKhxH2r(NM=vk
z{M}dDWYx6RUXSN*WcKSNZ{6>3VSnI~yNum(niJp7n;n^HIw8+)YLiYD&*UAa`M6dm
zd9JjROWq`=7?VG@N!&Mc>)Si$s&>adQQ3R@MWWNq8H>vQ>g}i!G&{f8CSgU`Ea`0h
z8pE@fFY)kI{g~4K<dH@B+vIcmG;alVH*ZU@{C=EGnl0<D`^w`c+j$o0@GY%=+A6ZP
z+hgIWYZdE1$h%d4P@9!B`@>}})iejy`4^ABm@)C!9pg2L`|9f?wthdV*)+3jcV?2$
z!H(C9=Q%0Q>vs<;u9mp(p{%&}rr6c$U8h(+bsMu?TARM~)s0QZ6)cSm-`)(A`ccgN
zo}=dBu_$r%kIa`(CIqHM*Zh?cT%vOE?c3GQj9rxXR+l%PnYwp<^P9=)BERB9-sfC-
z+@=>FwdF!|%l*?zEtCCwLX%ecJWI2bTzc=XM_#h8>xIafKEWDqMSdt|FsuJr_jdBL
zYewm@zc}_f<aW-V$y}Q^BiiA8PM2xr14Y@Qe};FD%`jbhVzRY`{H2Mf*WSBQ=*9i6
z<=AJteJpR5n&!H7&fPv!e9y~r#<PoFl@~__rA_@4<jBs>c=W<ear?X4()*(ybL{>l
z_fS7~+p^HP7gB$ll%8vN#~b!XWAWtvL>IT$0!Nm${$J3#(!;j@tIiwYx+f8WLDT9B
z1y>)OmHXj9R79Uze9GzVYL35y#MbxOXGPdOs6ECRay5ZH=gY^-vu{Y2^?m-}yHB8V
z_W{Lcs^*M^w~Wm>+U$0ot~B4wC6^g(U%qGe_TPs4pG{f+$9o-f;W9rj{kf}HpSXD(
zTDx_ZPPwyO&Oupu*847(4-3Cba<~^3vY_VD#Y@IhdYuF7XXsi@aNP4qPEq1-;Hte&
zvU%(`cN;G*_}HsaKVS1(>&tt;b^m?5z1sD==<a8I<~vln-(PW`sJZ8SjU|^-R{mn4
z|1WNQw`#Rxd+rf-<j1_&+$k5-m3Hw(r$5;%uld(>lGK5yS4SB4E;Za4Tk(Zyo0@3P
z?^P|APTb6uY@e~>5u@Y7BWWsbZ-l+$q6LnB%sF3@b0O{7N974;qs6^hO+F^HwwwHP
zI`lqldHm<kYDQg~*f;DsP_}^ALs{?U{_2yPrg?l==$!Omod@ruh`+T~b9O#a?0vuD
zcPab9gy#oJzi(%M>ud7liQFoa^-{0Q)-8W0->ByiBAz36gKgV#>&I3LR;TlSnfWpJ
z*rKy8d{^^o_L*!8@t>Pyq5t--Nm$XMJ2LxACjCu%xp2~g7e>jm6+SYU>`T(|JNTtd
zBWqjdT9IvnwK}u)&;H!lwC>X*-jy#__V%qx<bJxq@rRPzwW~o!(fh93=JACob{Wjx
zV0>)vzjXfUj;AYkw+C%K!0h@iXj|cyT`VbA&Z|2o^Ow!Pwo4>Tr-JAC+p8}Y-F$ZZ
z?W0oF!%Mmh_GjIGcVFgO?llML9fdDF65fP+@BDT=TREA{MzQW%)Z<@D`TJglRo_q3
zI&p3Pm%m)68cXI|&M*wxlX0h#>y>bTy438Sf;U3a#l3XOUVKVTQskSzR=(roozy8&
z#@3S!*EbeCpL#!;QQkpLS!l^M@sy*bsw|qRJY4a2PyPHjMb|lS)>M7g=~J6MH*YNG
zW8SX2c!EQjj!AynflTu=%gm))mWM`t`twKg)|~8)*K2nj{>QL*)tjB)Hi|a;hShPM
z)>Gp-*Ly_g``+Wi`EyO?d-J*Ndf0b&*GJi^mmByyAHNk`x4L(p#I2{U`)6<)PLu0<
zDj})sz0z&}+OVQO4~%DD%t_X5vgGs-eDL#*v0y)ErpB`)`&P<rPO-mxbDh%LrO7qX
z?dA8LZ&jTW@jfiWI6eJwWYe@aL0bPqJ(wp37rs^CPpzGPGLY?lVAtzRBl+qX{y+Zo
z?Of$~vvCfK`0)j5>T46(swZ`9WVILBcH6tASf=dvho6@>Z@zJUVeIdgBbR(PN^UNT
z<g30|`DIJS%X2o8w@qyqZWFl}eE0es=A)M_7I8_-9bz=}KUR9^XSBpA6@#<0Llst<
zv|fw7G&%Y0wx+_ErR?h~)`jtFnK(`oN)onkd^Kgu{Euc4KUAjA{upH+uy>i|7KWQY
z4BWzP-|kL5t1o%?8|SQyotx+Ff5-gykWTjLGd~xq%l}E_+H<r{@UZd0cax1ImON8_
zuiyM;a{i6evI3j$=Pa4)vMu<*m+i}9Q@^G>JFrSs^d-ad)i-8j8D5g#y17jL{a&Yg
zFZaj9$Q^t6K=S8<I}K@8N^``F)277k^RCk0ZMxyDjQ2$6ZKW+=nU*h<cDU}fmaja}
zmwErzYKzIMHh;Qjo%nuV(TXd(9)%TjR`A@J7N7dK!usC9LeIR-i@oRX(R#73WzCzX
z3@WwJFN*Ya%C6e}zJ1PiLGJ;LDHo@oNKQNXBa=zs&ALZxudGyZ6|k)kwM(B`oAf2?
z^s#B1l9L`Lik#{F@yaK!cc16Ek|lQgo-i58Rjm6sN3Ex|QEU0>1-~lK$Sig_U-7kW
z+uh1l8^V7H&Pi0Bw!~$Uwdb^n=gj;qD^}jg&sgfDv7<q;;Z3OU*0U~|RY`NZkIbwq
zztvU7aV-30YENpdbpFkL9WC?rBN;yxFXy!se9w=+wf*Xhp1CF2FN?h9d>3oW=#{&F
zTFWcsD6e0S?{@1s9PFz-Bqq<#vJ&s_?cEvX8C|Q;k(`&d>g%!<Y=<pMDq23daBRPA
zT^ahQIcxUwBzL}<HbG^V4$nwej=Db2LsuqdZFkWAvaAf#9E~e|6W(@N-?H!QniH~}
ztHGS_an<HjgX^1eLMNU1-m%BjWkX~yON^~a*R#V*wj5@Z(h;hZzLMJ{e|^ugtjn@n
zFXf$@=X1<Qy5K<n=@nfecEx*gt1nGodHTM26u<F;=)GonLaz7AXE;rdNu6>tspRjy
zzdqa=OY&|k^IH7t%!?Vj<XmShJ$Utt#g^!$eBn6<!!O3HE=rj7ZMWLZjy+Mu-6^?E
z&H^bse=A)Mxzz4mx@)3(eO0^3+SCP?GemVZA5WA!<9cR#xp&J<Romj73I;MFuHTPr
zn_w29vvGS+c<7ARCHC6a{ClP?bN%hieUp!I9b@qGGyN{hqGyMjTH4=|XGw0=lVjq%
z=hkz&X<|#Wyjjba$Ste_DR)-NCij?#PZxW-y`$s#ndez~p<B79s>*+wCExAD^L<VC
zDa+7Ty-}KC2B|zV+t$s!;B||6Qc1?M*4+_r9`COVt@$2%X~J8%Z#i9dyoc?!uew%l
zam6U4pk%G?ezEWDF1_olsxI#8E)m)PB)Bu_iuDcM{_CMT@3WPCh%I05a$z-J?q|WB
zdP4sD*R3-Yx2UUF`bXB;lc((7+K20B`R;k{Iq9>q-}gZICs%gwJMQ;)-HF_#$t(SZ
z6VGiu#<~0XXWlZm!{+a1F1A=Xz1n`B_LXPTla9XJBU;z{pf<Vpvn%i4-8s^IU2ctO
z@lBH%wQapqPEP;wafT}MC!0AN<w_&7v%{Hct$Yrj+BcWmS*oUn?TKvP?ANEG{w)!c
z`&BCDYMg&_!Czthy8+w_TUSIWUScSX%H5l7w`cX;T84?6RbOn0Ed9ISr10A1oe#Iz
zJI~)~TCy(Bx2yV&QThwNvaZwBi@MtH{`jc0ZdP{%*Xeum@=MI;IIiq5e!0uz!Tf!>
z)w0*ucrVc2bH{SBYSyC4BgfjNyBAFRrgnYtx!)GcJAC3cb(nrmi+uIX=lzF<W%q8^
zsNb0@d28d(wM#>S9%fEn@a&Mef6@Y;88+_y9b$!@L5DIDjUFjVbhC#oaeC705mqJ^
z$@=hep2z>+U58lhbNF~B{h8@?L-t~H?AymDm3i#0lqz?<GT#>)Ul;TtO+wWAs=C|+
z{l@{}Da%jay>zo7i0#%L?b3IVmG6Y#uTYID-&c1&K2&ISHg`(zn@u(4TZDH$T{M4R
zW$xPIS5?}f6~deDXHDF2S83Ch*<ZIk-?z#C$3ZWXo^=ru-dU|-Rdel~pE)`E*PRa>
z(VKnyex4E9={l*dVy%>cW@q`Ool_Y$%=qB`V0)d^gLa2E2CYlnoo{mPcK^h^cwPMy
z8T)O;sY)0Asn|@Pxm}4juG8w~#gbQR43mn=7Ocp8EzJA1xbK4gg9T+1nyM|VWc+?J
zX3d*4&1~-0y~@8V1nzC;dn20nTEN|F+CA6!1$S3`&x|jK(=JqT&ChdNzP~(o)4J#W
zLOmkY*6-)LD1N%(a{25Vi`FC6R;*^adzS3YKWyV39m;#n{Q4D%qc`Jh4||-sFnh9V
zL8Kv5e3?wk89T?*WvaRbN;AL2#9U45`o&pXD`R%XYJMhn@)1i>b@pjmn`iCcxInn1
zW6KWjj@3a%Q+H`yj)__EsjIe`vr2Qx{`eZJ4!!Bplee#RzO`re%uTmzv(lHYIBfGP
zQpr8W=qMX^QNlgZJ^K|m3vP222-fmFc;sF{&pFGPcKJ!)9;M7WoUQGUzA7x`)T6J}
z`E8ajzZEonTEEuN{Q1+?!&;834A)BB3=(;EM01v-W#6{jE)k!tULJ9}&vy3Z(YYcM
zdI}G=%|3ssbLYohOMbgQnVOvOB&#JlV^365VcM*f>0j+#_VwH9%U_89TJr4DzaN(h
z^G{t~?jRd0k>9gx_LjJ(Y0qXqHEda6Q&~J$^4_<;lAM;t+rJ7p)~~d?SG4cwx0zqt
z4>pwtYwOQmHZ{{%yzleeqr2`f?Y*Cs;xWPh>)$C`SIO%t7V=fDaW=6QJREJX#`(pr
zt8*O}@=aVPogXaa^-9yGLM`iX&LdaPYt@ocieE!-rrt2KwXpwqbkB^s+Y#OC<#^}J
zG+BJy)-q9}U_tx-JN69^+;)8ZqY=RW&5GB5UEyL!Gv$5xIWHtu+rO@LRX@AuQzp|d
zTQ<|U$~83;gG(&U9Jf!to0ZgT$dfnMbwiVo`GF5XGfK}zE=^Bm@|fi4Jb(N9^McQh
z*4OR+dakqLpsVwf-)gUCYs{*gb863$^Zhkvn|ia@%IEZY&W=hkdsV&d^O+!<WgCK-
zk4&ohVr%zSEoA!Uz2{H$?T>DnvG$H-=#S2_yIXR0KYbt5WV|W1*5<yW$>V)9qoY1e
zeiq5l=Oo`Yvz+1kIri<!9ygM77BA%f$nYbx;h*A~7wM`m9%?T;d{dycVP$yg<m&0u
z7J8aEE)QDyFkk-jx%(52*F}V%yysW3M)FtN-UPWh|CM_GuPWTOzis)+U&6Dk&KB0o
z)U55VIDOHbUF4zv>lG$CUZKJI%d--NTFOs`t&r$=_~gizGfHpTYnS|5ls4Dke;#K?
ziEDud*X@=s8j(*|Z&+n|{H^b!8$Vp@W<MzKIV5D4$ST^Y!?oBs?rQ&{@5^;hPWurb
zW_z%$=#}P?MXy(RSG_k0)5tnCK}J>Kp2eQW6;&sEe|?#l^ndn`c6Z&teeSz8B{m<q
z5wqLAMYCh&^3o(8m77;1!X&pJt$r7^bK{GrHM6{yOe;M&VcqxX+n-OX`S@v7z?PtD
zrq2ppf8KG<=U5!O)QgjQ<21#!*?Qai?u)H0Iyx`=LFkm&MxA$FVek3nl1*K<R&O`f
zZ1O%C$t-q=m#tH68<%j=wkw+|jLt|Mw_O=_nalQ^X5L(%J;7SnE%!!vb=}!|h%shE
zmCm<E8-xz^JW9O%N!97>guMLCd4hHI+Szv>#y;TiUDrKNqI3TDmUADSw<tbudHnb4
z)|Z?+G~W7Wm0G`gkYxIN>U#Dk)4c9<NiJKfxq88Mr<GTpKiIH*mRj)k1jfs&e=wgY
z+W$*<{qlE;3oN!pe)+oO;b|F9+u+BQJ1Zxx44+VRYPZ|eMyJXe!5e;Dv6cNRTPjPx
zywy7GJ4w>V$yogL>)E$v+h6kIopADPz<jo8&fVrZm&2YtQLUQZW>E0*h2*IXpXEHi
zl-`+onEUbisTn&mgYu<v-Tv-e^79Sf@1!TK^Xpa`FV8u*wPaSS_n%+S=9+D7;<@H7
znfXxuR;v5oBj=NUyj!z&+v=C>23sA<ZAI4ox@i;}Iq&24Ee~zxG6t=yd0MppW~xll
zvHHS$K_A$ri{CM;S>pbvaDuKubxA?d{2;6PiVf3W=iJfz^Ji<-XU2<iV&C7czf~uv
z_UP94kG~BvH`i+{FwHwS)korV{WSSp!`t6-6Zj`_SiC!b?X}7hf#Nf9w#R$kOmA+L
z%0JzfH7mt&u?N?_&b?+EG;F@*FRd4Q`Q)a;-RcD^f62^Gjqyql$UoEnqB`e*<h$5q
zRuMC5?rawLd$xwP+%+z|?|jePV?UUUR+r|*J06=nTYc-=rEcu%%gk@GHnE;qwNOP-
zH&?A@=AX6Jl4;TDyEZdTdGd_=l~!2P`X6nxTsOasyuZ<P%glnae?77lf_wf;E%T`_
zeRKP2OWMz%7lG9sHj{U6X1vJ6U%ET8m08tQ<K4?RizAD<B3ECF5}u)`^@Szz=H(p5
zwc&f8Jy7L7xn25V3m4bBpQls5E!1{d(|7LS+toHNuD{QI9`!COHt+ci|1K+=zig7r
zA23afSa!uqoA>691FP@bZFnU;J#}@>^35l>+~3QFw;0Vg*j~1;=KD6QoqRJ=)?}0=
zH5hcBVcnY3$Z}_Hs9wb6O_Q884$FJZQ+)B7>DsTKlP>FTSlO9<<8`_#`!k`7M!9X;
zT-#LDPfUBkoOg2n?@7shH<nI5D4+RZ(--Y;Dz*(>)rm`g=9o`esPAsdGht<}ZE{TH
zvR?h2-z?&J>)dzMRp%TGxx#I?>BgLGdh@dX3EN)I*`ayFPUZEL|HqF$5U*eJZ&Tds
zrB^~PnHFX@IqBHctx{cle3J8(<mcK8RC%wtZ&a>hcgVkDX|}%Fo!hM1{n3os^_!LR
zx5Z6)-(*~Qie>q2uRrC>e*4GOL~jtZeD+|z@3my%lhJL0{O4tBqG}&I{ff)bIw`w`
zasA&54Q_{e6@z+ecWgU+H}Qpsr{~KDR`+XCzP(Cbf8XE}%lA|Xv+XY@yg9fst?un}
zC0=$P-{$j-`6803#npR*%A>`(>x0VA{?skLZBl!#Y}e1WtDhBDG5k*XKPxHXgyC1O
zt}m(bDJC&-v)3PTC{{C?mG`mx=&ttfkC}xEt(|g21)U@hC4auU^Zk^d&lA)y|7V`s
zss0k%{HQUu`B8IA<g-6aO|j08TACXWfA+@?(EO;lnU81rcIHdA3U_%gad|v8;5o~4
z=z>CTi8)7835SRB!X+i<O(pGHg6_ZgX#3pu{r~k}YqPJ-npyj{_HFh1>f^@QGbFdn
zFFYM}NJqiTKx2;diNoq_6RuaJaXexE@R9SwhmRkVjg4R5IwY&`|KP@%Ulq^kZ8KPL
zqdxM4wX;J3%QA*0WggRnfCIwe><j@63?f3zT-_f(GXD7a!{vW6N3j^QM#G&PT}COJ
z26Y3CBdoI{<(@rxnUkH%>^|r7{PhfG2G$H3T3Tnm&gPp?+G26L$uXdTjU$h_&}9w>
zn<c}%g9o+=?0CLEW`pOA0}uU@_Uw80?wyT-ySUtp&09sR#Sh#S%VVzKDr~ga?Wn`J
zKZq@(Nk*|g=<&fcwimZ<?E15`f^Bot?&dj)3@i^4xZ50J1w_JEs2-7Qu#o-W6Dqsl
zDNEzO)HVO6Gm1Yr|CFJ@=D_~De-r-~rEvfC1)cxlt}bxpvRD@HhE1gn3|ppLseB+;
zpvS<G_4BmAlLt)B9~|=(qS+^~9(qvzLZM;O8a{@W6CeER^b*pe)pv0BcdtFXUZ%2s
zr(?`!r7J;l&t7me9*W&ie{^}mYaT}BcXua$_b+_A(4c(9_j(oW=oL$^t~b$%om=sB
z!8ZL^#Z_GOIRXOT>}Qy=@CiH-78Md=VN%d%6yV>$`+hxhiS1m4{ZscRy72A0=Vzea
zAgaXMv3{*6%g4sIZ<&gk86KQlClLSsf7qYsLu^cp)3zm89AHYy<v#lFxHVH-#9vkA
zSMPIPGa5W|-Xbq>;QQ;Z-_3(v+9MAw;G6e<#(zD-^^MD>EnH{zeEyXGVW&<Wv|+e+
z=g%UByg)@e1_2HcCJt_Hrkek6-KA50tM~nXw90910>j1qhg|Pmu6HW?eVI9@o~=dp
zLw@`$1DEGc3_1Tzc5%*EkeB$#_NPAY`~4~Z_v`(C`t<*;7yqRvPFmf3IN$bmJllVH
z+Y=YB9sJzSx~MqzVTb002E{bSU;CGxSFG<{$9Ck>wW}ZNx2`G>NRmofc&(%F8Jpd+
zht+??^Ik7XdCj=-%C^?#+<&iT?Jw9H|M^)0cWcJsn4J1t36}2u_w^+mip;l_w{>tY
zGOb^&&>{Kj`_8TagEOD5Z}`Z~#prPEoPvLj%UZ!n3J0V+W_Wpb9Dkq2_TiI5VgU<l
z!-<RH39QA({)I*;Ix?((qyJ*NiVo9*tAE^uSU+U_)#d!aTp{=`@g1Ll_7D3N2jsu3
zFZ$2U_KB0RLf7Hke^!MTV&@bLp2U|Z%s(LiqyA?NL!7}8u|m#k|D75Bt^HxnTIjro
z<N5xu!}n)sD9LNHOPu)`Z|CCrf5HE<1N|Rz{$_VO&r#Hm73BT7o$29C#=w^P#T*wd
zioJUEsb7+*ptRw(m7>?@@_>HEJpmnG-@A8oGoLv6Y`zP_9>0zyiPJiGf4z1&z2DS{
zX@6)3Z;yn1c)R`dAL~~&$IhKAxaI!iPJ`e5f2!|0DaZ*Je7j@9qa&B|U2(_LRbJDM
z&8<%6sI6S8YjbXcwU59#qtDlFyU8j$SN>Ughx;_wsm74EHz!@#m?<yScX)Lo|K#(L
zjNY1BmIW$D-<j@Aes^b|{POv06~9a~$a*dK@X80%MT;wBt(wG-WgJ`6d474mQ;Rjr
zwtM-{?r+<fBiZ?mQHHTqyoE>8<U_{IH`{EdcsR2y6Rp_4kTa2I<L1IytJkf%cS6@|
zN$#1YG2S9q`Olj^p7G`1`uP1RUrUyA&3Ur2G>j{>Wm3SzD%->pavm?1Ds`W)y7Zvw
zh?07RV*DhT;~t?8Bu;H=`Q=pcvPx<F^W>WK4cT+IE~{baySDmZ)pe;E54NO~9lyl6
z_Gi_ycl>cSr;fE0NUvKJqGtKb%X>-pzb%Ws7~ALgnG{tqRQcXMwD%axniW4T1<0oE
zv*UUkI-%j_GmWQLyI=HFDD2PNw4~YN{r2)Ar(1kq{FuYeKhIa0#He!RjLNN5D`xSO
zX|H4M-%)Yye(CLLk~Tgq^K#AWGGD&0sO3qvTB0n?-(j3__Qva5z4-y6duFIydLAIs
z6u$cGfm>&9CT~tw|1<Ad%HquWoM18YNrH1_Q+uw8E1bBhI_qNSeJ8KWM~p<cCw`r;
za72Bhz0SgF`*=N*A7Mrt0*xY%%zuCN&<n#&P3P)#62D6I`5o_PPb(BVcYM#E8EILT
zxo&3qT_%z956B<CdF}ntyE&&N``Bf;{q>)oxcl<w%*i7AjZSXt+Sg}!-)gn>DZ>eC
zIgN`r{Ilf0M;q6hdtA@DBJ4c-TV~1r%~MS)PdhJt_nh^XVW;c<O%eLZ1&z*;wQCYK
z|G6%=slfKJ+=Qyrk;==8k1q)Qdy_wA!N;XP9)D#}-~86<tn%{Lm!=nSF(ffvyD1RZ
zxRr~yUMw)*<c>kDJ?oxg!6cgt8L<lgO{TD)Jhn=%`mSSC?mV0P^D{Iz88)qWwtUm&
zkFM%(!zVq<in^!1H|~M=l_m$(iP`44jYsqMuthn=+oUGGz1qJ1+cuy1`<DcAT*+|a
zH?G+eQzCWCV@kS&wdsuX1#2tT)Scd+cJ6*l@Wl|OV9#&I*n%p0f+v1^yJ_3@9YH^9
zS{}y6{;65_bHcmKwxmm*4;`z5->{szY3h9`YSv-rrPW2k_N7WwmYW^;{>AI2*nMto
zw;IcM>jx*}XEJedi&@<;XwJO5W?6#coG|4nky6#{{Mj}7vP&`#%6KRCw2P+I`JXoT
z^_F$M&Z(Z;-E`G!>#t+U5+Q|)?0jl=+*@Q*?^Tk{H@`w}-aWe?wrj74w!ID1oRhqv
zBZbNReeSgF=WqSo*{AQ3;Joq%qv_7KAxD_k&S6uomzlTVQ_Qv<i<3h4v?a#XXMW-H
z-?wwViHCgH<XsQ0&DlF&;cnpMF99~1tD}k%0=u+#q_17E=4{KxH}17XY)5ZgZf4K(
ze>ypx`@*IYk(>=HKd7gi*}19uB>N_gsJERb7wfK(*_INze#_Yauk1^ApBs5_>4yFe
z+4JV+f$2<+a@PyL2-Y(GKL6|MmeA}qd#<*5x5cb*F5qwH(T*<SulRn~?s%WXbF<j<
zm&{igXFomlX6b5{Ry84Soy^V0Y%0w+Ja{f<fAs3%kkc89!<Q)5hHX~gJL$y{Ls^|S
zZT8NJI~VYle2fiN^O$n-x{rW~wU`Ir^}8zsH)ip%22{Ti*~gc4DT#mGQSIl#^KQtb
zALBpB6?W|G|Ct}Iyp}!ra^=;&@2>-ml~`vVHSYXs^Zv`1(49{j?`GbgKfmhPrq~~A
zBcA%(P7hmsrux4Bp6Q0Hm%CNMoL9ESZ(<9~Ra)J8*Jj)GNlPqtXiuJbjafxR->RVY
zYMZ8;USQ6x#Xif5A8;q{b1|Kl?r?wqpPL3YyKNJheoJJS9lmlvXlr3rl9$S(2{OCy
zJ-Bp4NaoK>^SsilJ+{q`<%>_tx0H8n3aYa(kJ{`cci~r$VYp41_0MBhd0s|ZY+Lid
zbJv79Di@vRNtY<bmh)~_vfWm-q}4Fx&8C(kQ^adKZlAwyowH`SzgoIdtMMeW!(#G3
zx3Ta@l{J0SU31m1X7(q&qnC9!U92`Gmi-LeRXm5+A!}CT#WU*sG50mD&ySaX$D74I
zHD$)UTyOuvhl^z9L>wrV6}p_m(fa89)<bu!&U9ax|BmNc$1z*x84I)I4PIEpCe`*W
z-kDP*wkzkSPFz6pludW<ZGLCwt)JEZ+Ec_iZuz7KFID{3UNGOx=CNh56+>EYm#jUn
zneP8tnGcuh=$}0y^Md(j)Pr*yV&@vEh}Z^v2&tZ(xp|@In|-B|_O3T|`*`t9S)*!p
z<#RV{-tu7Ecj9#_akKImK7W_Ef4%svN#N#gksW=^ic{Upuf$fq`k|ye|J<`h2bq_b
zDjQs~obsu|r*vx5$+WFUH(&mh^KDCU&-9yfjJXq>&p&y$u%Fd(=7}3B&!n0Ix9jgn
z%`*7W@%3VUX2khTZmZn&y&jzJ`u&MhXX*Yh=?M!bZeW#UYb}Yrm2J1)_)p0K6YY(<
z&!Z=AN{-)rp>yM(FAceMSx0*6r_G$e@A~ao*?q$w%0X8Q4)!(oCkx~}I$d`%S!-@@
z+NQ1tG3U)y>^e7o&g1Xww}?Ob^!bHyRn2RS$!hjz7OG`@d2{wdSj>fq?+>Os2jqt+
zNG>eC^=Yeh-mLcMo>NZycC`MkXqT|Oxvca+Ok~#%|3J?<cG00ZuYG?7-=D5LrTesO
z3-i@A8S^Gr=~_OYA@32VZCtf^nw=bn=>-OnO<RM@)WX~40xLi2UAuC=vUhd46zgx3
zR&9mL-))|${n&VDdBuYedB@x@Z_*#H%z1z6b<vp(v-Gt?Hur9N?ddx|`XOKL)x%ob
zcOLWD#VDtDSgNu_@zz6`t@(-*Cf#saeaK9u{P)l6Q@(_2Ig}-yc@z<S?8U`%iyhSL
zcHP|FaBGuaZRYK=q(=qoFY8X6mpA_#ljiAaYyZ1FFB;BS)gHfh_KN7L>8{P!KK%{(
zxcsC0=J~UXC%EpFtGRQ5cXIrv$8VeVXZ5}J<E{;0S^U_-L$vo*q1?=%-ZQN?Ltn|R
zh@DVz<Eh!_gu;dVv4v3#tC!i=9Df^fwj?0H{*s}SD94U9*Ppc=Iv3>^6{+gR8$JD^
z;+@|P_q6}4ka^gk!RLC=edV<E`=1|93fklQ)O+cScL7s3>{%n}cG%+H!C4d4<Zih7
z6lKS;%kYTugdXs7N!oq&PU)KcZq})V3}-z)Fjp>9K6H<#{7vZNRj=FkTm3GoFMitL
z{)$2Bm~pDw-RFrqHG<za9{ID^uUU7k{MTKVmv_ID_*KWlGo3}m(O<54K}5){j|;!Q
zxo@8NxulqX0++r{W0qy*x75^T!Ls<jr#=~EE~tqUS$gXI%P_fpJoz1WnWx%ZznS=r
zYu<vIPYW}zDa^N8@6537)yeBuzxA=_J_@YZUifHn%`Syj_pZr}oPK^&y<}34KELXn
zndg2kN_g7gfJ6;HyNed9re+AZtDfE0c%$<6w2*x7Hi_dGCRxoDJr!UQxjci3TjQYL
zoXO{Azfr!Qt@G_-<xQ5?=d?`w?lLfM<(tC#w<>JC<>JeZk-I9(bY46>%Hel*N}jh+
zV0zV^re7b7{!QMyc(SZ9>+MI;j}Ijqig%iK_x_RPx$imsOWgl2CtbWMTmCr**jJp-
z^3hNFzO=02{nN8M`k&N>us!<j)4pI@f0_EPZQgA!zAOEbxc{}+g)hg-FIzpbex263
z^ONk#QvWo$e5!3cH1m1z4o-K?siiA7Z)vHsvEJi#)WoFLm${}=^TYB;?X!X!Ha%P3
z3B*WettzX@{l9&}*G%{2lMkz}Puyx0dUdrX<M(IBcW-)J$K<-&D#iM3(U)K8>u2=2
zihiDT^6?v$jmo}D8B=fP@3|`<GE10)D@II1Hp+j?b(=cn>HGH1+o>NN<F@D0uTO_h
zd}KIy_^H2la{p@sr5EwfkN3(k-Or8=^h=sLzsT4A^*KSS=<G^|-`6bnpRoA%I(@tN
z{etLMtJW{pJa_A_jo#Fm?}{^;xXautYKmvK6|zm1>e3W*zcr=p(&Pi7S0z6-PMRV*
zf31YZ1o<MKEz>?N_?)+Mae1q~XlB~vnX|jkd^p5xzU@>=)}|F!%hKv=)l(0AIBF>Q
zX>WYmjYgUOKW!iH*th4@x2w_<J*&G`{$LlH7alolUBv>Gp1VztuI0@;G*4M%M_R69
z_zdR%?1$W{BSSA=e<LCl&QkaF{3o;byur^FlwN7P_~OOOjlnucWzq~w_I_Mro*=2x
z6naW}TAQ7G=hKJp{#-e2_RH{9v(}^EcXtMzQ!%J(t>5eNPTN21c&&J6$=<mPf$D6Z
z&88^Lo%Zu{={2XbK2L8gp30sX^h4wBQRn$@e6l+iE@xs3@-N!E<hcmnA63)!P7|Va
z7gUs7yr-|J!*g?q#B&#mZOXTQwY}-KWnGuBS}@$Bo8kZEf~i~i_C&CLzq(BOa!vi6
zuvr$HY)@~$*TtFgmv!#McZ|g$+Am#fd{TaCN1I*wu!dW|TCKWT?eg*JsVN!96ILI)
zGk<D}{L_o`mY<lzGbfIF&rXlhsuv4_f0_lR8{5j9O<Fpm=lV;Lo$tQruFZRN+H9$z
zpvmXmnvsiI%3jEIo>MtiJ8yARk9qg>9Y;c{&8iw6pPaRE?S}^(m2cy&?S8*T=E-(_
z-an-i7pfO<&RVJQTR6_=rBI!_*0(o}f~z+#JJtMT>eW5k=iPI%r|QpmzSldGqgx`X
z<i+NSpAj+BY-gQYv+c<#i_^>JDEEs@@9%k-{P|i`)|QJ_?`PB*)lN`Z`cKSavg+P!
zO=X5ObrVsIrG5wR&s{XvDe2jT51|X+F7dmsc|vUZ_L}XJzAZR^bLG@kTpn5FvlqL#
z_}-9X<11X)tS+yyId0vl*-K2UH!cp{5WnDl>P-7H3a66S&r8bwH8V1xeeuGJJ+a}!
zJ>NGS?_IiY)Bm8lN@oY*m2r1ZEIk$*e*3ERygN&mRxWwvWo<oa@^4>P&vkJrSz9md
zyf@YCvHRAC7Xr?0npSw&tizzwBwjN56YH|Is=U5!Rcm)_wQYNmo@C}6`fi6tyZHO_
z{72(`Cg$dz>PuSHadlt)?xYn?>5M*WqW`YA^!n}#xhub~oGH+0=9<s_TX%BM$CR$F
zLw7puwr;u1+4ejlOL*lsq0N(?96!)^Pj2V+7vja@J5Ob8zGY^*-XyzM`eMlMv*m~X
zJT>euJ-K(<v9%kvZBS7QnzSg7X+pe>o6S_w#>@T@(RtzfjP`!0?P~QC=rDYr9`we4
z%c_(4`BT}gT6fwBid8&z-w|E?XxpaSb<dV>`*6qFJ2}bIp-Rncm&@ZLU)paJYZV45
zZEr7BY{}&32|Fs!a@yAC0GGazLg&+qae<=K&m~?s%g_Abfys^u?-$3tn7M90zt;pA
z<BlDNclrvf`7849{hRfS(?3mF!}BzPd&30x-0IY}>s;@bO)On^t~6oo{#SZF`z&3}
zEO*a2`*Lw8zr#)LQ&;^`1ltaC2I$31-FxKf8u|0{`&=(~oA20U{O(G}|CpL-b1pr+
zW>rvAtoMJF+pfQ!7u@f$sJbcI&eO76sarC|_?)Zh+|C3$tz-W>HyNJX+wfk`+MC@`
zZiD(VZR4dp&F{>eqT(xSlsEr<Sj}A5<Z`_7*J@@}(>YIFSb3j{&d+<%qMY?5hROJz
z|MV{vdAVQ8Rg+#kb2-U<Ps2KT{i}uLf?Rw?NB8;lCVgDlwKlu|K+V)Yp*u@z!&IzG
z#r3xf#U9R0o_V&9DNba|Hl72&?IyARt(%Z(m2+!tv(b+^MlRWA^Q_JY&R2gG>vPob
zTJU4Du8Sr!mbKhn?0d%g+JUv}#1dFf>iknLyx-1pTv1J`F8{#goTSYYZe+deo^Zib
zXz`chU$PRft-t8CYx`$wuWcM2DT_9hoSw`Oyk-Hn+cP=S`Qlbt`|f|*w`T4Rt(G*^
zw#UEcZTfM)th3|O9Y68fJDV1iO=d3srMa!x>+v^Ev9^sC9rGkjGQE49)}G%GGIiUL
zCDso-Hy6G*|7A<tLE9f?e?IjcW4(WBOUqKGH}n5*(LbS`=_+ZkB8B%?fk(K<JXeQn
ziVMTPB)Szly2z$wZhv6Ztnct6ip%`3An(`jQw%LuJ8n{)sj+-f!Pkw?tgO;@rB3N6
z-~Q5bO7dmtd)GrOZ0~b!wm)}df@nn0?m$<mMJ<b@m&M$%Eorx$IOpvW<0aZ<nfnF9
zCbb3jmE6n}?pQZ3#2~G1o8Oe~3SrYbw##cJiq-VemkF;9ouu($@myy<_XTPvM1KiR
zU6~lUmA(GE-SHT1*`n`BLcbHGE-!y7-nj41q7<t=v8>WkrUL(SUfw*vw|4jA(9#oM
zT7H|oUa?HDRqXiNi0#($<)_b-|5QD;t}Up_;v&cQhg)Qqh8|OnyqXx|U-aH<OUkF2
zrjJ6Ir<Z+r&|11V?}g*SV6`j0d&IJn=c-Hn@=Ezz)AarDoNue7|D1PSx+bW`TZ*A&
zad_<4bfyp2zovdayR&TR!q&NVJ+514r?(egzG1ny_E?JWD?u|$4a2r0DW-2W8#pFb
zZ+g1>i2Ip32`x@FkC>-&hwak!rs~PDvufQG^2&0_e!V_jo=5hE$U_rJ&fcIl1<NAc
z-kUa$>+)P=y8EsEv`pH%@YSaHO%=5lV~ZdA@}5{2qBG~Emv=#Awe5|)mupO7Ch9ji
z=6WjBlr&t-Nq*D*^|W>1zAWvda%P3<ZYOuwX@B7HU$%GC>4Q`L9Edv*#WL+$|NCnF
zj^BpebA&GKk)GZi+N$v+_)6Z>z{<O;?^#Srnxgy7es)UL`eI*uwe@w=%BAjmyqox}
z@9WyN6ZBkG7HWQG<i4kU>_O>Kmz4_x=2v|b&tSQ`Bk%f|aQ^4orM>(IF27jj-Y77I
z!|iE^ZPxA=PmR7LobO29G5h$G8LOB2+3Z|Bak=G7_E_&@M=q6%&554B)yX$qR?BwZ
zMy{Rn*KkVKOi<4W4_JKt(1KroZfQ+E8+GjNl~n=uwF?ecTz`KxP9)&valXBhjcXdB
zEyLcg3R`x&LN(Xcev`D`w(IA4?;cw^pSh+u-cwgDHbqG~y{fWL#m8`=W5ZMKZ^2C~
zr}?LTkKa(*exl;Ir`?Ady{mOH+w{H~?<+bToVNM*KF|E8>d)Tq7qJRGQho5A=5e8U
zMPi3k`FM2XHl97spW+qgFQ=MZ6#Z<G?v`Ea-p^7f<yn|xwCrc>rd@L1eorv;(B+8v
zeAO+uWZNF&*;VshPTEa9_xA1r(c2+QP5(}w{~@!`UAOW0^tZNW+7qqr&Pab(bZzm+
z)w<iy=h>&F8=aeCl@cWrU(snEx_o7o-%O2jHa~1ONWXg$le50@wnDSsWyZvxU&0hD
z&o10-FZ1tB(dO=%dJh_EXJ3Dr`TpvqJIjOIy#85*zcF$3XnG);em!QY_r!~w+NNrm
zrNI{~Z*AA@HkiwQCH;8ld6|ylH@oy13PY~MN#uoiw0Qqpy?#ce$CW)kCZ5I0P22OX
z>75iUH{5Ye;n$zXE|a8041~&p-ZiK{i2IxWGwJb_s^UM%y+O4HHq6xT>|uFpb$<4J
zw#>Wp`j6T_yYOjO-ZMt?dAAxTpW=zkn<k!~?(UKFy<GKsOXp-B&CA*P>-NdKFFMKP
z^gDF=RHaFko0sIXDPIcz;Nz%gvvt;<@=w9?fgc`<bZ^&EJk?Yqw@<)|JMhev^bj5U
zO{WaYnSPkfxxH_yt>&WekNx!m1#OEW6EErIew*>tAp7>BCGQ`fIPAYBDeJNRow)~;
zcd2M@<mu*q_I-!AR;Ed4xS;RFcx9)@{_kJx3Ep+`dF}g<Te7_mHY~|6^xl2wZ))!8
zkCs+9_wwczi){<)j&zIq>G~zVSy@PTw(itrw+<%cs2$s6A~Qc(Ncxw$Ro;xEHCNQ~
z1G3vZX0o?hU9;!N3Aal;K7n`3vL6Rl-Yyi1`}K0e3$B%_TkLO1?(*5NY~TD9Q~yO8
z>v=BoyO`~Lbmqz<lg=*x`KefzeOLGmr8{9Oc}2yOwRASmT$=N1ozAIhrwftScXZA5
z`zPctB&RizotMFN(v@F}WjS+}T#J|zXqoiWZtk59GwI7wl_D26{;i$GXD`|pF8yP{
zUsLa-zeSSOWix*(>{FON_gitWuj|Kkxn2T-CK+Lw+w?vM9o+6>7IUBP-hYi1ADX}S
zT`k?Z;&Z4}W~@s)>w&+bqIbE3ayPO*HpzKEl|f)?_0%Kbj^Y!J>re1`ws`jO)RL;i
zV4dbf=_jw==*7?IGy3mp_-5UaZJTU(7O{WnGL$`ga@~&OqW%npT@gzpFCRH$Y_|7G
zmWcRNp~w5~%l<idb=ymk{kravGnAtf^gh07lfEP_IC;X`h^Tqn9?Hu)-zd^uqAN5}
z%)H6{yOWyu<OXXu?P+{#RBtM*nf>8FW`OtNGmEyS|E%TRd*j&jB>BnWJjN_c=F-vP
zA`NRlO`397FK2P@LnE;%yKh{&w$JC^iL6cTX&K4+FK%xVzK~;iW!BRvg>gYTr6tWS
zUxg~GIbDxiJ?a)uR!+5@?Z@T1cG0i=#V75Th&hWXy%A>>U)#?SP#LD<5fxz@<nnqS
z@4M>fcCiJiDseN5#O`E%Q*y4f$<WJHJ?-T4|6zxJ(TsVjObgg<T;bm4(tITT9Ov65
zUVc{fRlNs`;=H|<dT`!Z9sN!?{e?}a?WU@wWt!VpJV`%0t-D9xsn<KH;OWZ#vQ5_N
zr|(AZIWj-3*)9D3j`zBUWpXC0JfHKV`l8g#)pwXX4{i<KAaF!CXLrtvx7#-BE#0%c
zocq&yR;gasqq`p6KUK>&>r2l9cQZ$~<EO$UJJ)PDdh(<C_J3}#-wP|o+AqD8(iP(Q
zKK{^)Ge0xq@=xF1_>W6m=JL-J<F0a{O<7xa{?a>8cg*0{OO72M1$BF`R_2s-{jW1#
z=DqXf=hBt^Tko63int0Mu1@^6He+tXwguB~DF0MrW_4cMTe{epCE!v~%+tev=ggm1
zqVdmBak}QrTY9#+6A!kq9Xj!i>x}E1&D*x}|9ry#&Gyy$tw%$7{7=M%tp6*be@rDW
z<@I61<7cNP#MQ49Yb-CB>0C2$>yb9$N1H8}I)(eYBkjxc-Bw#2yE22nioZ_lmGaG8
zmxeawRsX&Cm3r2w+I{|L)!&!BqqAuL_Vjh?bx%&+wB7huTHE_<Z}a5&UrKp0lb3wI
z<0DmCqW;qIJV*63zS3xi6D&OLh09DIM+oei^&**bUc-Icmnu)b-d+@;BigO^^@!!V
z;5m;~=iP37`u1$XdmWy{mi6`)^BYgUyM1DZOzOR+3Ng<2Cg;~GDpvV;tlqo#s-IJ@
z?kRhr#mDw}@p#>OEVV15IVMZ0_qp-p$J12ST?klp-Y&#kTr(t)$;|PdWJ2;Um5s-)
z9^X=_qi}tG@ZyO#?RM<EU2%T?{{<{jn(YPO=AA$4&vo_2j7K%KZ;N{?B|KK{liK{H
zAUGjaN`6{VsE69empPB8R<a1SU20xcCG%tU<@Bl3XYhKTcyVt1H8s_>A$D))wF_14
zY7~CH)A#Nn^=4nKXP1pxJc8PHSQJM2_Jw+!SlIvD%Fq4l&h7p!%?)+8?3`4T_XX!T
zpLqYcd~WCC8_riA8qb$dUm^E*PTHj%9Z~<+Rcu>O6+GM8t9+s7!TWAgn=U@f?sXB4
zJ#bOZO!<|gobAE==I!UZf1X&wz5esucXBCpPu!n}AA2{oXt|5_oXkGWtC5B`p530@
z*}lcX_knuQwb1DcrWCIfTU(=4Go!uco{G<sJ9k#-e>M~FzBg@7e2ehoyNQdsXFH0X
z;uID?xznQgPSSx*Y1)S;-|a6xyK3LoqGQQMsw;TfosAMsRL=kBvRpmNz|T$IF!$na
zi#5FsRaO5>-``!{c`nXu#cW%n14%VkzdC1GZ{)E}dC$9Da{srpTf~nG+B=1AYPxf!
z{9R3j|5ZD$rPn3IFL?8wv^mnZ>zrrt@e5Y-b1wOnlqP6judm$YaZ+`C*tsoxzj?e+
z>*MP7vtzQjm7dU;u05}9$ucwPrfW$#x|@%2ZB*Q}zdn5G8|SYM&v~WtGB5hBZ@#cZ
zKj_WoKdg^_8|nOJZTg;>J>}SErrFk?7YjeJ-)klFGsd=khSZmCKkm?r4J$vg`ATg$
zvrKkki_q13T^h{xU(`LOx{4*QTyt#MAI_v@-o1ZTa<}SB*G$**u;uLtu%7lYX0i7-
z*~+t=SH5k}7f))A-xP0j<7u$GiNMqV$y+L)ST@9+Y`*ud{q4ejKQ>qM_o6d;7cAJT
z&sg#MyKhms#9F7|_ODfIczRPOXivG~!aZSa*EX&K<DN_6yL`f0g*0DiUJCs3W7o@r
z8c)wAr{8Zo{cgpltCJ2zCTPznmAb|2YRy%?<XZaqSPq++nTJ|Vn4HcLJtOu;d^_8|
zOPqK1J^uNLVZk(k0_K`YTc^7$oqNemjiD;;e*fR5^iPtnvz_Zjo^RaKxbF0!bxrMO
z=f&%B39;Q}ej3c_ey!ai^4{GAAI&d$x?c1B>?2y<!TbA@)5o$c<}bat;wLE=$4ZOy
zt}~Z?zWn_AyJ9|XkE(97i9C^H)AH($esI*IybslJ#VXtf><-3%xG~Lkvh%YGD^@RY
zo_hYD*3w{&-;TvA^jB#daEsFaqTO|DdePLvO}^_iS*1n0RthB-#@#rlyx_vT#~k%}
zTwIoOq_<v(-ML`(+53_v6<NnuTz<W?Am`_f9cJA<mDK?|<{e)UvSM-9^Cw=i;Vqtr
zOrCvSt+<WJw|7PU#2Yi#y$KIW@!fsn{*U+wwr4Ld8n5F%Hg!h9@!Dmj6RMtOFI<`b
z)8ZxX>Gn1HIikh#JZ}5bmn?oM{rII+M!0Hi*?Fhc7Z&xzY`pd7NLt6Q#Va=0`$?3_
zs`Ia^%Bfv3A>hm=xnetA&E*>Mi&7RGj9&Qg%I|v<8I1hz)YpIDykZddxNA?a<EztO
zj2^j930f)o&t)4+yuRoxp;^{?4KX(w4n`fRy}wrMb!|uA*|{olE@GOd3olOZubRjD
z?cCu%_wQ}3+PFdFN#r)6vTtk~{+D!%{95AQ!Z|N0(7aRSQfK{_GBE+EcRRl=b-i{y
z&%f>Vn+5$ZoJ|eSI@}J{ioMLc=OwEH|4e4J;**}Qx698st*h!;G5ub?yZ)Nl`wLWj
zUp3EkulXh{7GqKIV}jZ}>HA5K-d>t@?p}}Agk|3(tbXqN@+`2{Q$l3h=2u>+GJ?B4
zC)xzpny-svj1jFoVg2@`Li;?q^9OER*Rk%k{PFebi`OM<4(9)6`#JfY?Pu=_g(ac~
ztyW!YeLJ7Izb9j-cZc3-w`Rqe2Imah5<mAVu>C*2m*>tZ*&PSu)%)LZZYj9qqP985
z&f|mjlQ-cUZtvOhjyIR8)F}6vbRITpFrE6A+h9Sv_HNN;)tx6}GBQmq@0oA&`WyYu
z-|%OQhVtgq5o#+>-aoUm@9^@7-s!p7ipxwz_*Pt>8uMtv@t&0$CBHYSKb<AG`ni1H
zyQm)@uHJcl$nD<OSBrk%+-wxFwMRz(Rgby8z0~w;O0A|Vu21-`ZBiR|?(B>^KZUAw
zpSygxnxVh>Youj+ON+@0gP+WNDGzmT-ucbAlwD9G{J2cTt(b%DO9S~$qAzTn8hHI&
z#gTd0i~n=noVK4`AZ(xTt=0CEZ3ACyTztiB!kf&bv!5yw-h{7vo?5p~^zg@+&r9-V
z6x)2%J!!%B!hOdX?SH;&PHoOgyPqEV&`ja~<}V-O%6Kn2e~bFJ@zyTKnsmMr#W`^d
zSD&+<Gx9YFp8Pl<<H3JM<*=ujm}|^TOp(`^g;W-#D(L$sWd)bya_Rdi7#bLWu8t}y
zE>W;Fgs(bNFf}(ZCid`+w=uu-Zy($A?`}P7z0J{9&v(_|7ip~fTrg>w?_G`D%WOwm
zbuMqqOZA-kM8&TD@6WU}&%ljO%lZ8pxsRNFTJ+7Zf9}sT&!bV{S6WL~1*nN!dnEN@
z75CZ~QrvF~zV0e8y?a|pqI<Qz(&bjCt6aS2#JnuGCeJ<Wp|$9!_$jsaeG5J+E@YkB
zF>%fD6<gJ$LPDI%=X2!>U0m=edrQl%3xR@#u`{AtWu-$BO>94HGf)%SsMm9KMMXQ;
zu>du(V^>2wS44#9?Aq-iTJn9C){Cc|H)b7bv3jdfklM7g&_P&9Oe{1pn<tGqY{APw
zg9q0fLmI;p4ul_wUvp9D;-rr52i(h*jtIp*G_buU!}VNbm%9zutc;|GLLd38*7NYr
z;L2ao)VcTa41-yR*gvdWAR~WZY10cET_49JyH`6FD`?0oda(Zd5fbdWkg0X0gRTot
zXKPgZA(eivFA0Vj0ZUFqEOxrpY?mFsK=RRjL)Q%|i6^ut@ZMlCa@X=!D3Q3K<||q-
z#o^2>rss;2Iu^Xi(7AZPD#v#((;1anva^#WZYfe(t`x~}&9Ojpf<e{{85dtuX6aR>
zy|bQ5Z9O<gWaZh!sVjb-Xj`$R&xKuWt9hAw$-0Ho%d;-o>0HoswQ4&jbK0n)S<3Ag
zgM@#gO}e32h#OPe1KDS735gGuuyKgUSZeq>>Si9#^lv-k?|Daa!nBLZ6WZop+)}!O
z*EXrQ)S_7~Q2Pw`w9qAAlf14l6|yj{_UI}yaF`m>WgTC?H+b*v8Ro8A&F7vAv%dP^
zPr=de_j{MuzX|bA>t3ApapAFfYwOp?g{@z;Twdh<n~?n37gzldh}CqP;1yvxGaxhL
z@zPx_Ob*+^YyOr7@^-yC`sVJM74t;@OZfSvb$@*IWlhM-)sJT9mwo6L`?Tgq!ousj
zDxyQ)*Z*D1k;AN-`|#z@luy6ItY&l^Gg@$W_KTPesl89XzU+GSGRG*I=h@-FU<pNg
ziFILTleny(-hMtmT%T?A!&RCh=5IoNZ+_V&dAprg<3;<+ZyQ-UOz$5^+EV_L?bMYU
zf<M`6douGCbT#zuACPY?W8h_eo9FR)oiwj>)m`>!`MVY-elg(K#aMmyV3L`X$pztx
zs%`Nh?`NG~y=d};75@?{F1>N!xEyL6t9$ZxKzY!IqOyGwrru>CcfQmXo5<PCtkt`r
zVw3xR$-*bi51DEoZp>PkoE?=E_UXYEu}=?*rnXLEp1%6@^*?vEpZ|RIc+LFvc29rT
z@RsJCzpfzltLf<PsO^Ef);#?G@P!wzdGZ{6-aWc|qF2t{cWF=marNij%Vc<;ul|@5
zrFDP%$97%y6`R`D8+lImns`$q<{@WxtXlo{v)?wfMm#+=iz#Kz!3E1SLZw=iEe>r8
z`yPKH)cEi_?yc84zN#K|k@a1<vGl>qf}`s^*R{O=y*Ih7a^<&u|7NAH_~y2xH!I-p
zmv5qf|2{6+I!pim?p4b+f7~=vKW+8R3^UF2ZsAN#|M2w5>)-A5S+SHypkv!Io*S<k
zm_GFLy*M`Q;?dpupD!=>f4cnRB1=noy}nZy->jL%|NLxH<XY+H?#I8!8<<6`oTI65
z`O?8lg65}Mv=f3jJqo|G>K|9XypZEdhFMhD=}KcM`F?ljMe&Q?{wcVm)3*9z=H^xJ
z_P=8(KEUR>M$=Ydy5GVp9Oq{C{=bpRd^ABmV24{n^ZC4^YlYrClY7R<E$1Kpw8A3l
z!>!V_HA}Zv%?M0+xaxs7Q~s@6Mprjw$bP9mrKS6Fmc!Iuj(26c-tpbWyH>mZu$Vbt
zUhnkFik({iY4X~u0=!KXk|q535}4<@?x{4b2<PMTa`+tk{JYq*LYKTf7FSkyF~8vc
zIQ?Dzah@Q_H%<k?hdqzaOEbB!(6j&K+48d|3rYfc`F3P#?m2sXkD$AnoNZT8!AB1f
zjT^3BF0UEn|8Gw|c4-r1nBXDK)UCT1w{7?pxbtRxse!=hMN*4O_GZhw^4m2rK1gll
zXzekc+G*TZ|NM~V@ejYsEKjrDHMKk~UgB0AcEPvA>gc3%l6gy-Z}1rW>n$<p=<s>!
zW|i<HA@5l@tAbgvvHXc1FE8f2Mc&K4Y`9+Ut+jpPhTLbRf8XR9yT4A)mwqY#^tju0
z^BL;uITEwZt-p1VX|B!=_N7IE@m^1pYVU{Wy_l0Uv*xU3%n8kyocG0A;>Fb`R>qup
z8>vyEr25@*YWK%kSKfZ}W9-=7#xqfJ8k@%jYp1AJbsfKJZu%UbFS)uW?eb%`MUtkX
zDVFg}yN_h;%W&A3v^-`m-}19Z-`%XJ+L9A?y1m-GHH7itWtRo|4lexm0&i`bo;^${
z3+fXS|9tgLis793aVD21f83JUaMaIYvO_@TggLPx#~=Uv#JJ$vix4d<;p7^QfNqrz
zp;GqqDe|nk*QS2s?~y%rv2&{49Pg!(?Y8X2g<owC9naV)u{Qbmp8jQhv#u7{IC2FB
z9$@2GC3g0BEUTgN(TWYV77k9UHJ65{TB^76ocpUQu|dR;V+C{Ljty<C3?B<#z6{h+
z4Kr;xo4kN$_JpWaF3&fs%HF!RkLTLI<vN!p-2HT#;my{l@=aS9mLF@~t^YY?kCm-`
z%Ki<7CQ9Z1e`o$VzT;8S`xhBL$vo=2o4Yq}PTMNcUlwmJ&i}op<DaUmh*atWM(5MF
z?{|xHr_Xp1%DYW{uhR>W$DH^6Og*z_k3~#Rf7$o+ZvVqaFTPtKsXOc9(ZgF0sXHE6
zeBk!AEj538e{486#nF*j>O|nmt!_QqbNTC2pG`RQ?&qHug?`Cvf>IYLyC!=to;mxM
zoq894tgYjx6?xNt<y;7S6@1_0@xuc(Z}XQmi@g@eTc*5GF?)aKIoIe{6`w24-I{do
z;2oFri2?Cbb89`>Vx09Y^OhLP9jog8_=;mj^8Za=GL)68rpPQ?@l5^r|Ia1sOKk35
z-pjN#f8WGs7Y)q&+x|XVUcE{+%r@%kq#$K}J>w6be?EG$;l~BTINNNyKKHY?#r^A+
ztJW2KStPz~Im3>HLI<>NnCy+yx6SFjEjVq%->leAr>ibh)V<na8}XpoXY%bzmX*~n
zRg;(HZMk1=SE0bzuN^SWgvDy&@)};|i@%>MEt2ZI#1NOfq@j}ON{?l%uD-*IuV!1D
zm^N5nVDM}YGIVW7{ajspX6|c-R}C*amo0eA@x|rJrOJ@d>&r^sio{gSo>5x$e~np|
zQEgnyD$fG3jJ{3Bg7UBQE?c>D`j%|>&o448k^_F)DNXElVqB)YEwJhQ;-5?3E!w@Q
zZg!BS@b0|ww>7I5eop;8`QM${{${)KwtX!v^i}sdl5_pIdXUBRRbhP{PY-q4pD}$F
zl(ETTf&A@hwrVNwmN0!0Tc9psFZ=9}MI&FrnG>Pi95VjPi%+<Bu@rOL*y(6a`j?y_
z>>F|@TR~Jq=sj;m`nLBuQr|T%{;m@KXyB`JVd6|z1w)<oNg-<v1a)`rVb_@%Kc(#6
z!2^G`%r2dHLD=bl*i!w8Elakk$e!PHENwBTu$+7R<em+RFIP)>e`?h+xo#^f6)ksv
z@$BWwK6O41!jn7dcCJj+Zocr_b&dD*Kb&0elkSDhxp}E?xls1EEw^>2t*HFX`c3+a
zUC>9q@V2=f%Wb&|C(O8E!Krldx|+!z#pwx(asKh_f!+zL7ZiJDOpBFNED^KYX)C*9
z?YjKG>b6Tv)=W51`cWdN>U`hU_^#UQZw6l;@!JH%S87dLRsHxvbj>I4luE;rd1oh_
zeYSB)p6uHD8xN~(pCh}pr+dY%tHmo%Ow67rQ@DBE*B_f~CIw$P92MueJ}=8~i`Dk5
zxc+A!b^FzI71vg;Te;Na%*;+T?TD?$1$T>gU)lLY!uj_l!II4>S&TPRPApv|JJWUl
z$=4@(tX?fS5u<ngx30;C(s{ftg;$z?hj05HvSR1iNxG+N-%Q)OY|8ULGsAt|GAbso
zozKA>^n6ki8~3|kK_MQ`F8mjs>Lqz|#neZ$WzOF)E1FzXwDaA%XM9OkMlC(N)`m>;
z487+ieL1$+GyKb{MAgb2r*;4GJ~R2gE99Hc+>7kqy{Dg8NEB$^zGiWh?@;Wo?meci
zGMge7FXR<Gy1;Q^*0%ViGlFj24$OA*Gd%BlCFpf<r1xU4lg8iNC-@%xx;kw8TmA3v
z!X}1uXDlkx)IB82YIpUMsAz8Zw2FlCSvR=Vf3-}$+w*wdO0~{P&UVxI4wX&jd>5ZP
zxC**WzCY2xUxepjO48CJi&8~n*rrWibLac3_@bvVt9>u}t~1Vx$qtVCZRM7CZEJ^K
z(fPh8jU0u0n%}=gn*Uv{q`k7(bN97Rb^&iVC)})!{H$mo7SB9ggrmtLbIU{1TQYoi
zt_3|?=zQYJwi4r$w#VK3_UsAU^8DgXky$B8=8LXeFPUZ+b}DsVqOIGOo-5asZI`@R
z@9p)h>0{3n9s6e%7rGBk3-_<k_;KK1e~Fy3v~=(%M_mQR*UAxWTwnIhzUvew+&1-{
z4I{IEeu(v+3lW72*2R@SzNCJ4?cVdpQ|B#dWfQAin_cT0oE`svUtDy{i?-jTTRzSC
z%Dj7Xhek^MLh&um?5X?K++CL9e>-W;?eg767sSNey>)JT-b=yt?|%!v^9nkvH&dfJ
zV7a`dX6=NINed_CJ9av3iuop{xq0GW$A3-SChBZF8mhNgj+)Ju2=TrmbU^iSMTTk6
zlW?h1%$;f<q=g=vS*>h;`q4>O*~~F?n!xt!ebWyls+<Z@b51$Dz&@tcQ2(KgChOK%
zz37+HViTw2c%>wK`6&PEvzd3_M)l*br7BwQ>`DGz9OozO#Lmb0QRUZ(=}Kivoss(U
zA}$CXF2A?*$xGXMW&JB(cx~NIO}P8%B;(xbL+@3^*wg>U+3dPzv+4PArjN?aCl1`#
zcdMJeYX257y<ZOB^$z^^o=|hOZn25VNlv!Cj~2-bO=#NsL+4zZg;4N@DMzk;NHo2v
znqE|sq3AF#iA6=1UHZ`ErRMkNtg>7dylhIagIA)d`Vp0zM`kH>I;^tPREYd8s{1rb
zE9}6|XNUQ9Ge!DOxMfG4H&e5d;*9KfE0FB*d0|t3!||WZwtrpB`&aYMR&<wm(O>`E
zDKM^~J|Wg9^+C%0!oJLxYua;q_F4Y<zkmO${&K_QtTK}pR_AW_Y`?2K_M#?xmY$jR
z=4ZQXWWU|?nMz&8%F)l3O#Hjy%mb0ztGRwAxR;jBo1gh(g2i;Br2i`)2A?Y1@;a<)
zwo(60?bLO4y<1ouHBFfl9^SOH+ivouS@oMxi(2bBmuc;4k_PLp%!yud&*Raao%Qn?
z6T31r&MQobS$3qeZ2eN(kFlq>>QA-vzvN_<ytlMG@?LE8e*Udp&s>~u7F88J{J7<n
z$+We{x9r{fT;pJ7lWJu_R(!tO1Mkw0*?&3iop<=0c;;8cqi%btdf89E7JtrPYw`HR
zkDdH0t|>Y#i@g3Tq_+H3RY%Kw+e4DU_BXx+KhTjAnmdP=Gg{|HjgShPMxSWOTg%h4
z{9CRlZG8N^a7pj)XBSm}p6*oafA2C!GGhDopAjpQznqTpXR(R6=C=OcWx4HnFGAKI
zKe4J{_7$f@3suucyImCbF26acYB}p%-wTBcF3nkJvt>$QQKsfAw|@_3KZ;%OBOvmT
zjiaO0kv<>kpMRzpFg?|KBfh}GE6U>8rSmTqP5Q1?v&D1cZDXrsrl$Fwce_r1%@Eoz
zF==y-*H+!jg_}I=TPCiWQj{?xwW0FYr5D9dbkg^WSaRfMPrt7s`RlF6vgOyN)#v$!
zczGu+IsVrwsxnV@?cq<|BD<G8N>@@`S<G4c@>}ucrYy;sHVc*n-rE1*CBsa=ExCG2
zTk9UYnEcX2B&YhBi#n@P9owm%GSmM#ldDci$7akrKk3EJ9(CK#H+ts3c-~i;qr6|8
z&EoT2-uk)Mk}EcE+qXFJMKI&t)h~}MSXX_{c1N#Yobr8T`H6C}Q*DfM%D$A&Klk;k
zapbxyJC`(XKeF&d<hjTnf4L8}KX;BidqAEs<a0OIG7~F<4Nt<kf4*Sf=GE6aKREi#
z-eTKN-7KM>H)_alIx#0kjqUPZv8rSS_SDFSefOWluKFIGl5)D8<FA#`S);rQPxf6p
zw=XQp>B7&yNw;JsXKK7$?!0;mKZDWJ_j~(wU*vw<oMsu-^L+J9r+az(CFeanxxLxE
zdH%gW*Dt@HzbD*O&ZkZN^dYXJ!vFlruK!F5pFBV8-lX<r_jl^Lf7!ame?g7aoc%e+
z)R$}jTKdJ$_40+yv9A2_YuhG&%*d}Y%H-m)k1$QQPgbz0oNs-wFsbMA!=|_i{}<m{
zJume4)zz<dziNM#Yr5iI=>CwySs}e?lW%UZS~aU{cj)n}A0__VnO*((rY3N1$nvW@
zW`(3*-7>3hxv%N!G>zw1_eA!jyI)-t6?Xbrvhmt!kI!FS6*X6H*0QMDS)tFb9)A^F
z8u)i}<e7a!`@SEK(48Y#&$;L0#ZzUL|GvGt{a60GYhP8j4DZQ_d~1EHWGt_}l(Mv2
zInQa@c}3q}tDcp9t^K;pYDL|dpufFKy*}COQ#oe8Nn!n@hf^>8j)~3bI(OH#WWUYN
z#Q%TS3*5bY@UpJiiX1b?Ur$n<OZ;jTtu~9r?sd&`{C*@YBtEA-$2Iub*P6-83&iKe
zz5BoC|KH*dUus@&yL2S@(-*%(7rX8Erk%Q0JMYyzLj}=$ho<n}o*BjC?)y1%9rvON
zBfFP(W!F`ir$1hN?{3yU&6W~zMV>m@8uK55PCx!#HB*$ht99*|^tYCsdH!!EN#0p;
zw=DR=v<hDF%lC!eZ&c)4eK_sty=Nsn{l#TwNBAtW)H0gy&(uHuq`9wpcgiK5>3c$V
z`5MWG*H8ND({?)emgeE&d&=`~9$wQXed)?8y-PJ;-<<Wgw@uC5rQMq8G;Qg|mlIQF
zzFNEK&*E8mM#bvoJOBSJ&yU-mkap<mw1u}89G1Uf%Vr#yo7(2{i1&)VmHK>-U!q4R
zS#9Prm)tjba`m^O_ecBl4}Q3v8-4KF+prb#OZJ^p{!#MSZNZBVO^*+6zuWeMG5S%$
zobsayHB60rR@benb5p2`|9h(O@dVo=@@KOy$*jL+^}AaysC;+2*-Res*c*Av+_xCc
zvOnK0+-376e-Gc&$)yrjduPm7is@hd|MjDbX$i~a-+cHJGx_F5PEW17X>;c2FWhf`
zezs~o@2}@SbFRwB`t69WR<`|_cUP}>_KJnKFHc__|MmRoACC7m6aIXAbM<y}{!P1W
z2iTKY?Jm@(e$sgMaGha)xB+Wp?4o0AR+-z6^gP|9*{=Oz^1k3T6?^~xdU~7rS$(&&
zf!jCtO$^`uG%vXQ@%^?B?|tU~|7FBs`(nW*jz8Rb8I|{sus!qZ`}3eZzV6pdnV-?y
zkAB@c@4yvv#&^HMR`uPsWi-32rd?k2c)!e_9p9S*-rv^sx}5716lLFawe9Vi1DUd0
zZ#uSTSeswk)t^0wy|UZY-uDI1pGk$Ytu6mQx0kQ^p5u_@6`f<fb>ICT#|0<f)mpY)
z)OAPjj88Im*4^mLbu%kAKmYad>F3q@2k#_o(B1M==1lOS6J=+wExmoaKz#klYO}{u
zPi>i5)+^>edR&(=@$Vh3hung9PFDWi^!?q}$@!5ih21PMs}s&IH{lm^<cW6uVDtN(
zZ%x|!CyVdx|M~EG`IA2O{ds5O6E@G;r{StDl6O{!=SLmK*=yHZRGicfA5Hq!`Ca#V
z%6&Pe_=01X7EYAe=YF=rXqjc-?p-zvPbCkwJU*GT?ZNSw$?fXhX&ej+0<8@DuADm-
zyrX^d=aX4B^J79TKXa+mJ+Z*y1Djz-pL>Zl`z6W#bB(oTTQBUqUe9>tb)7Kg__nEu
zDYiY-#^%UpOdA+kz)qYtR)9+=m|2<|5<AS@TgDzT`R+Dd4v+jxOHQ_nFfzB?TiX0Z
zYp<)2!W0&#7kfSPm3##SmXr%D3D;C|-PQ0#YXOs&`_7GXir>}WlYYE+qT!@BJD){W
zuig9nj}Tv2EOT6?#wSG|)=r1dTpt=$8C`Xmg9RCQ#2zs>vvyio@I1^&zY#y9<1j~C
zQM<C>r2pLuI+`3WNceCz9s96l0*Axh!;%65Oe`*{tVdK1CO8Q2O#2}&*g1)1io(1C
zjRi;9S11b_lq>PME?LdbmG{2kSkCA5>lvo&nky(MDzg2W%Xeb;fq;T&4yFrD3uF`Y
zX2|9$o@-#dB*y3b`_E#Q>06kk-fEpZ|NiOIqwIx+&z%>&d0*Jfpl@-D@k0B~!vXUQ
zG(Kb}I7mNY`fV&JFUX$of}#9>v$Vq73vmJ>JO>!g6+}xMlAZjpvEfhvLt60x2Vda}
zg{_MJCYb&ga5!*(Gb76nmVdGD^1rQjDmd~!rDLt`rK6%v9~zb4Fk0_0=D84f@riTw
zVn+rR#=ovD7Q2-Ve+u|>+>!hw;QZsRB}>4>>&yx>82|S@&+Bg5z3A@GI}gw8cYE?b
zl&$#GDUKCNmyWWwIqVkx`^ulQujyt|-`)2A=g(RxPKe{!zn|OMf+_2JHphx~?f=Xy
zcg`{|TlQsoQ)9=!=9`BvG;l;Xg@i<iH0)$F$d6|K7yp#EHYRa@Gt>TrGc1gC>pa2_
z@ENn{Fyyfxt`YdT)7d7GLFy?Z_lMv28|&9~u&^*_+!5ooX}Nh=(B=QizQ)9|`fD>z
zyC2-kSZv@{&BXBI`s@4mbqqf>DG8pl`@iu2zW9H?qjsIrN-O{G^XL7HCZ<c$AB061
zDpXrq85t833mtr%7&v~Ui^g*N$rpd{f5|GvHxn9;%uh31{$+ie?f-lB*W>dGnE$U?
z+Iyr!jIH3W`(v>L!4104d>{Oeez`yRUp~|S(5L^Ge*B;3arE%bpXD=Nm;d?C;T-ee
zoLxPq#M!C^hQF>mCB-!S$X{jnraygaLcosp)AjCGF9`JTKN0*Uq5GMO<8x!{{|5!-
zqC3oaR&l%Ew)zuzM*h!1{pFU21r1`CSpT`cm~}EM+y8K$Wc_IMGmj6;DxbcuC~?g8
z|DABj#O{`Vn`SQP&|q*}s9@)k&@+q0)rG;Hu}6NP!TbA8Y(IVqc$lcM9ylYxa6>WB
zW&b)+o)5bZ2+F<NAF!xCWZPGVg$8WDbs5fV`ychc%$VmH?`G9mbKP!vwOU_m+dePs
zv~ktPJf8UYsLXypqqn_6j>YGm{Ibk=WFIP99=xG3>`u+}b-x!rxp-rXz4H0#mj&~?
z*R7dwbjxqc44tR<Oj~R3iRYi+S9<esp5sKGZ;O*&Ud)~nKl$s7leuRK&%R$G;UDkT
zQOcbgnz!%I#drHs)i!ePU}!xqvL>_VMa9oI-|l8_T(;(o_6x^g?yeSTjn6#%&Rf|R
z+pjx%NZ3y#>hX*7HP_Av8?lRvv2FTQb-9)Avq{w|7j3z~i^0EFZBE-?eaGK_@|>mr
zZpn5BJ3finsABrkthVvA@;O%->5WIbJNN9H_M}d+zp6U-s6f)(0}I*u!+9#qzj)gp
zpSH>6g3@lDRn8A=p3I$-7;{5>W74&jwf86AnbM>2t<~a%t7x%wpn^PCAmiK920t$`
zt@)=_lzK4e^5rRexVqLC)}-#MoXK>RPq5qkxXLlpNhfSYEqg?Y-^j_nJ$o<n^=E^E
zkU8s|kCg7X)c9ggT;bmzUYXhlC%)TM;3yHY?T*Oy%FPq`UQV?-?P-1{@BEU>%dgGW
zO;fj0I`Vpo%*7XC!V*h<ZwYSs)z@vrnKh%fck53d=bin+Dvh7h*6g}pW%_V+&aI^%
z7C3)OVB99tEP8y!+sUU_K4bUiUG988`Sr9<ccV5uc>dAo#Nyc#S9829eY*MJ<;b-P
zg%$g<>pp&da=~oJf!%-Y{v~|iU6vD`l`p+8rhM)a6~EPcS4=)A&wGE#GW!>+C+2uX
zE#*7(X4X9y6Va=)mfn6R_-f~RU1_s>rL$)JPBcgkTN<8yGI^`R!nB;2$=l4sAI@2F
zUh(m+Z*SbXZ`dBHG`juz$<;U3JJODSth^sA{{H)>cuUI%0xmP}`edg01SF~axV2K)
zLGf(SMTW)KCn&On9F^H#v}s54#_xKs9Jl^nxl^?Dj%r$;YP$0GaHRlYo0f+a@72x=
ztGPtfMU<4xI`_lIcFyGa-a&VNDXE)8MlV(uQeHAUw|!ETLH?TM^9_C(P4n-uydIyU
z^zZb)?Yeyn7@4EmllRT@e$?hIud?vNLEZv4zZ(M8ocr8@d7tmJyY3%)PQR3ISMNH*
zu${Z^IxI;%e0+^VRQbCT<(Hh-uQH!qZ8M)cKi<QA%lG}8YNA|z>3sRj=)au(>5J0d
zZ62bp=3ja_srg<?+K+k3C(io@>ZevLv@L(L;C-I!qg?hbnZ=9yR?N!yaJsta@cC`~
zGao#wEvud7vnNf+>v?>9lZAa)TkL-M8~;A!n9Mk;+@bGsLe%=^79aKOr<HBzE^iG{
z^HVn0HL%!l$#|35t~Uz)t<#q`=4Zb-J}Du@xbo_^4HJ8M_wOj$e$;r=#((W>WjjA5
zU)*(m{jHg7N49q5bYyDh<Z!bVIlPfgJyxbTvE|>ltIy6}Vc(~ubN|w+TeD8Kt`Y0t
z{JZ7*_s{qLZTZwKvncS|-t$47=YK8xo};Ss-&yU&iro{JD0Y83B9X97a1z6(N2Swp
zL}rBw?7BSV{N%;iU*tRMd;Ag;%3gH5`gnVx1-q8o&h59B*-6h4&}<C3f0i%wL0CZX
zqqQuLw6ecVVE>UBIVsdcBR)-s`%PVT<Rc|PR>m(AUH(S<bzX6Ko%dU%sPer_zM0fy
z{f#*Z_31`=)88peOzkjd4rEt;zeYRN&bsu(RSE4|b-MSW4+<}M{Z^qoqH+Ppi)HsU
z%(~sam)Yf}Of5A1apc*1+1b*!SMslaFWmDh&grdlN=l3H<_r7M?kzY~TNeM%^kLwg
z#6OH@rTqUq_F8FnBYIVp5c8&;$;<TFHeH!z!g6KVyFiaNMU8E`YtKh6%?Xd)lJUrK
z`|}Gi?IlwmPM0#4yMBB95qYBr)sL%EX7Bmnu9Rla>S348X)r0wrloFo(S@+&*L_dB
zb;Lqy-^4}Q2ku+0uOzc?$Iq6Pck6_8bB^y`A{XqOaW|S-K7lD}Yn@Nqoppx0<Cp4K
zh-qD2zs~F33#Dt>ViVP-IxPBYviZ<Nqsl*DrYuYjzrAy7@)Y0Lx5nYS-#h)3m@wVp
zs#@QRms)>+<lWe~m8D(!+=@@ln{+iN%$8iFvD%`lX7AV9DRm3}X{heap7y0#(@p=9
zVOv$_EK6rOsk6FaY`yn3h8)UU^D}JAt^P=1{U47O9gF=q!+g?D_r*HmeIE;p%!E{C
zO>Jw@TJ`iCv$_2KQ?oamsdK9PIxSxO_o~d2trKR>&b=4VQe5OW?UiKmsZBypIO82Y
zJ&|Tzyx`S@q>impajMBbHXJTq^Gn20ZZ`YHIZd1IXm)RWFtMrAB*UVJ!zCtCFYI-7
z@9b(<dkz=hEj20Y7D>;}49}ZpDN*uSMCDa>RE)BSfyRYpN)sP5^&a&~@=Up1SgaS^
z!}$Ed&*#h6du^~hbMNnhi_e{{g^zLwT~T5@D{ys}mFS&xwI6mrG7Of_J#gwFubHY{
zpvu`tol`RYO`R~)cdgg7)=4>&W*#}&qO#}X!VMQXc(Y5*r9Ov${pY{9x0G{vb~AJP
z(dS&P8?%4iyjyZl+WPnv=e<X7KUVC2+FcrPQvAcI^5s8Q9AB_+UD>>O$HYSBReEh&
zv&rVnW$91Hp2q$=U-k8nU0kw#<`j+QZs~}lXKFXyn8LVf(R`C7W#P|WynnVrwr=q)
z&VNPgmj^wZFg5F0%hPpHrwlm{{>ZetHn~-`^6^)`r+!66T}FQw-+bLB;8<)s&-b`5
z)3f!mZw!vu-Ch1{kG^>KQMu_cxw9u-(GzM)^zY35(Y?F#@X2G5Q~AH<W;Dp&6zUHb
zcX_^P%ajXdvu7q$-#u{g98aI~>-n!L>zW0>x39Cx{;{E7<lZhLow|>F&c!PYk6o!R
zcqey5;p7!%4!=~}-APkL_0KJx?w8`2U_0-P__LR@|MamgUuyVeJNJYJ`@a8MD&)>;
zNO2}boA$h8JnCnB)$QXx|BalNLaXPkm7n$?L|V^CTwH1O|GOu&Ty&3_|FO~Kp1b|5
zydH<_nX3AuJ2wCL^Wcb9XVR?(&!W7#Z4CDmzqd_&vLtOv**DW`YdGeotw=t7=Ta{3
zTaCr1)Xz$vet++^ZC;VgrnvXU(u?ob{@-=mQQ?TQ)3h%ssv<T&GAkd|201Xs{rmpG
z`N7f?O1s=!r?0rK6LeuqQI1V+j!op&mrUCa>`IclInTMTe8t;4>&{=RS(o8{S)%@H
z;ZduyKitZNUiRHC_P?s;^GfELx6aQfS-UymdfL0>?lObD-*zwb+MT&-nTUV3|BhcX
zvn^J9{<v(f=h2T7w;cO;_L!{al9rPJ$EItW&EAkF+1Tfw9<t<&^zH<K%?m;uT6zC<
z&)T#nD{0zOzd12K8C!Rqk79L|K6|I=<U><~*%x=4zUpS&dh2ff>suPicg|`2+O1^d
zB;h8UtoKfD6;GLZ#_KFeITL+-%Z;xS&5w01+|?F4Z@=C1Eej%Fna!7(;U#IoW4&m9
z-SeWB;8&6_yngOV2)!cpP38NJeRF5Amij-wT=Ayu_<E-``SUKGw{12O5A1pWW5<pT
zmswY=Z|<JP!^xdqw@>273W=WT4Q_Uu4#^foB`xFLW4QKK&<e9xzh?aWwKq#4mHXhy
zEN+Dv^Dd`J&i=h1(6w>hjDl)Te+5NrW0Cxjch7wU&hC1DXRgkq3!Coz+<P;4&Ag`y
zTUC}z$XyJ*slXd}LA`68M!8{ylK4-@Nm9xumnXAG7j5{p_GJ40HHEKBPTu|&Ddl77
z+j;&o^X+S!pPX^H>~Gz~vFC6}M4?COobHC|1G85Z&pqq9M)qJ~?$5KD*M0}r`YyR9
z_260my`6LJT(Vi(I`{KOnQgw7I@>>VmdxP)+OzYSXxm52&b`|<^Zb=re>QSkM82}q
zamx?(+4lop$L**VP5Wi%Kf~nviM7H<?<{}5;QVxD_AaiZ7n{_Qid609IGtCyreM0b
z=VWZ#d_lJ6sUHJ=95<0o-}$C_O4$+Vv^_fyHFgS3cy8^%zJIgT?x@4%zG5uRR}TAd
z%<QXPYpi_z<-S#|p1oIUbKE{S_uak!*@7*+Q(A7rE_0!ZfRhGpJPEefYQOAxx_Qzh
z*Oflq{g?RHZrIHh;jZ{b_NR~E+~DU=7Onj)q&a2!hO5fF=k-JT%GsJeUw!9#=X3q$
z=jrL6JwAW9DYmF;@`pVej<wCWE_BZ0@IyYSw<q4LP1`ruBlpA?Tf>8f{U7(eJ=0=n
z9(Fg*C?|iWLo)LcV>8jqJRRAZt{N@T9sLSNwq%_=tbYDNevM5Cn|8#zbKl+Fr>_!P
zlI>bNU)4Zg(OG?OWm}`u;r8##Sk}&Gjg<R*u%Ij7PSG$-XHCP;_7B?IT+^N0yKbpO
zRagjT-L_WU_gW~$-(&TZWqGYzW^{Rc@>Q>7-7h0iaVY2B(xk(is~z?%w9#pgW_+Vv
zp27aDvEx*+@DFeQzEckTU+*m4ZuD@+*0!Tlf)9piEt%%8*!#9a>bzN>Ra@Zgh2_ku
zyZ=qM(4Ep^zD)Gb`j;D0HRMEDy?b)soOpR-lZ1tBS6HOK(9e~NPnPAc{<Q4W(ras1
znUp^{XZ*O#;%UaLZyicGo~^HTZtPd@Z!hKE`uEYd?)GbY-5I9yNSYpY(tGh?D%*U`
zZl}yix7Y4$nZM_mrjy}O*C~hi^V1J)e7XF-R-ElAkG#33>SqXBPCVgv!Ta}uXNSE^
z-hAaSOHFH<{m^eJ_p}$jCfnpMT3i*HaA?|9-#X=&SN>`InmEC|z$jB-?={8MzZC;_
zHUG|ve~|3|ad+X#+s+TN7hS6{RQtCqF}R6k$Aq5^a<Tnk;_}ZjGa~o?Dd7Cw6?o^=
zhZN<<EB^GxeK7uiZ(?kq*2$~uUr(R)e(J}KVb3&@Z+lF6%p)DU+Ifn0yR6IFWdc8E
zmc)M8y+_x&N`2m|=rz4vZ}pkp<;Cw>n=$$5nRwTnKQc)=6=Ek;ymq~1G?|^TynuWA
zwV-R+&bz87b@2asxp?n%nUA{mcTeoU``p6#P|m$;4}~JW%N@0e+5UTLzwEN(i-ME9
zJuB{oh~5A7>BFaAh40(;Y<H{|SLOc7opi-*+j{@mz0W#&k2=lx9(v_g!h){*JNzV7
z9dkPkGRtmGVQ)J3<<XlDdz<&Rt?`vSf5azb3#;*rSI?DNw)#9@E&lFR$@$xP3TEFI
zKUos7x3OsYhOhq3=38fqTm5~OVm{^h`j`F&x7jk>u4Z3#_A$R$`Bk#(e)sh&Zh9rv
zg=(BTBF~CxI6qs?wehYshtii@x9a|XyZj?{>EvhTr?V||3uKJaXS&W5e|!6Q)}DE>
zj~i!qNKa^4cRc3NHvK8i>%MM1Wm(eITl~TJs`333b^^DGS4<DfwO;=Ah->W>ZB@Tb
z`}ZV0joI}1#}S^}6Tfrq{d@Rd!1A>Z)2FUhzdqsG&UL1|FP4_=z3wiow??b;Z266|
zvFl5{^uJt}Fjos*7`{TSH8|>%aaQ@HyW4pVpY7jObL?H02=@gUe{G+md#^8$>6DFh
zpZR7E->fg;T3s!ylCD9MXQmu3=WZ9@8uhg)eMOwjs$=gIXKhgX^(IIDq1u9|E6N7n
z-eylOFHNYO6`!^!tN;D;zllm;*WB^4^o`2<G|%Z^NUx~3oWb1NrS20l;%6+DnBw_f
zdIQhI%olOB{}{`Ty*)U0a>54Lvp#{oWw!6DGtRv|$h}}!CU<+S`C_>rJI+p@5V**o
zfjxJs=WV_yGdus2f|ZWXmh6tva$lV<=j3?wTII#9G4l(}N?)FQojh;N<=~mGEQ@xg
zCnl|4cR}%c-r3s?Umo84aC-at7uz3AdCZ)A!{({oq<%dUgYwy-;%uR<Q@<H6|8`}4
zy5ON{9?#FFojGLBBF|%BzsLAOO{cXhXGF-{8|NoZn4{a`@U)(5Tizv+Clk3!W4Ke7
z&tTi}uufBH`bsxF^ZQ%Qq?_`d@m86TKIJ3pwjcTYuR40KuB<vLmZ7>Rz>2@()9k#x
zYi&+mTPxtb*Yd-omH(FrN2)eHcU!~%apB&UmU9=LHGi6N?~`n=Z$Lu#6%mdwt?WsY
zG<<H>n10LMb;vk<@rt*uUp7byKGc48@TU5MKzD7+^hcM3Z}Z62q}>gjH}k_p>0750
zr7TwJ>Web&TT%1vh8{EXtix+sSnhM*byzArcUoe~?3LD+pJxj8UDrtp)#AD>Wh}Y*
zl8&w3$wfW(mNS2<b!X?z(LIu3Xsx5TyL8FEEoG;YBCTJa^S|}vs+g(zoM%;r+wSjr
z>e+jJbx)CxqG{~SXIiuMUwsWtj*win<G0Gwt<yI9H?K}+`ncO#N7l7h@ZS7)uAK9J
zyx+OKCdFOj#ydsV*`gmzxu$Ph5XCtC>%$0}hc#cOhCEGYDej%q_2Yi`l{2lcJ6<O|
zs$K88bcyjRCZ6NhZdm(V=8}kI;o8%5abI0cZdRZC2~XV{Y_`sem^PQpJmlUX^Lu8e
zriHfe2LB^*m*wAV7g4${v-o$*SKEBM?$y;5ixz4a-!=SppeLei&)%!ooid(_?0hrr
z=Ud6uWj{4vdR6^vn_pUduVGD^cJ-Cy_pgo2f9>BO(pD3-KGt3;#BjB-U|hAl@&{gX
ztpLvc-%H=UIQAiKcKnw=E3&<Lf_oc}>!>E5dGmT*v%F8h$L6ztoGrXdmndmE*KcKw
z_?x<A(ZNO616z~r{8O6_Pxv+C0^c03J2zCWn4f)o_==;;oiq{O+RfokSGY^$0s}5b
zoh!OAM`-1*MN%_NP6giX-+gXV=Jqo)d0(H?j6Hefp7S|=doR9cQ*Nx7>Y^QSL+*sv
zgM;599(~9Pk6IV@I@MeJ`St84zji*)pWD96>AT*8g*U$PEb;xWWOnU{_JQ8{do;^t
zm#xZqA19oB<I}nLrH2jEj!Ztsm#7mLaKpsl_PzWM8Vfe8{;D3bN#V!5e-`bhFJ-oM
zpT2LMAivD-S&gfa!Z!W0#(YvC(~Ts{HeQs~cpW|OWbEopwn=ZdtDg~h_m^ca)AE}8
zzH_=)$5g~#t7p-+<(1kQ+q-11y2EA_(dTX}%Jy9>KN}>!HO9>U4eKrw$>T|1@4u;9
zRUhDI9>0sVQP5yY_!4i?(mWGSzuR-C>2uT>|JM4&`@A=G`^Qqr<Hx7WE0ns|ZxnFl
z^%19AS&>C$tL6)zf1C8`=^j_35Rq%qI^{d^^Ry*C1WlT8V~50ym#UGXcQQXk^UG9Q
z*-!BmbX(G0y07@(q|+5!y{q4yG!UQcws6C3kMtF#E8Av^EUanUAK@tSx!7}AiPWVh
z`(D<Z@JsAFX*U1OQ^mWkN7ARR-hT4_rhVMUS+5=N=iPBneVJ9S#MAnjB{TIlT+P?0
zS$=oLosho|<)(d_82aT2$AP^HQ)mAvnteryPdfbsi}|!FUIW4Y<f=7`U(IcGei|UC
zEtQ>9XJ)iW_rB%3xm%tW9Fu8y-0)`SM%$|XqBEzSiCxoPccrV-`g*M09KFZi@~4zM
zOtCogJhC!PE8tT7-6gzr54BJHw>%`bde@X-i~pXXLe4>zD?i^>T(#c#(5HY!>BhnV
zi&xg|`#U|__|H!MC-!$&uAS-i_g2OF=fNfiyF=ga-QCG`=ZEfYooIde;Hv7JEh?p3
zBR`c^=!9=;zxL>1{p-Gij<?$rj%QylQh(9#Zp!=<Vt2E{?<~(VG+TY4_}J0)XP21@
zTo%4rz4q%guC4t#|Fo_puf6!s>uh26%>wNw64E;seR{3VC8n}+@4oESo%xnqxB1QM
zI~!H|An8RMV`wqY`vr^DW;>kEVk`LQ_2_Dv{LvQaPqw~yV=XWJnzD6+aQufXWnB$Z
zg@w(*?-JjfewoQS)A`lm@~;=Se=p6hwBw(=Q?tN6u~jrLf8yz%pR=B-?-99kU+Yi7
z?AEuX{a;=#t__QvZtc1Gcn)(CTjr&sVHdrA%o1BZh2_Zc()4IPPNrp(+McF!e15;g
zeqYu0ne6k=rl>9|&C3?e`MvM8r<l)7-=}#tw<R~++oAt_lc9IZ?XO4Qy{?^^=DNWn
zQtDOR^tt`{w@sOkZV@W14h&twx^dB$IrHBw-f<-*XmdrSs#J!}e~FaMo+U?Xvu;^R
zJX0;dJuCg-q{+pFq01ue<4&#Expi*+`3QsKshgf={oHY7&(BToT!T^$p1RF3llyV-
z;{`i}cn_KHb&U&?TQHgDiBsVU)>E4CE32KZR$f)J*4bPAPVVPy2hRD|We=Tu^l$ZS
z-SxNhnos3DS?eB``eQR!#&N5o9A4hsCw=WoY%V2)vg^#`e6ww<Mozxc+NDlQ`J~T?
z{{B4ISc!l4?iJf3G8gA%?tZTuEFP%$uV-4^>ZKox4m@<azxU{)_#35esc%c~EDv!`
zcRtMUTYgGI@ma3ayp-aSqSVA(5Gy|^i_6r+0^5|GiHR|6lFmrM%*5Cf#zUU6GdD3Z
zCwj`R1a$22b+g!}OCDAly#^)iB_7RN4jAwl9N{^`Gxt)E&?VI%FHcX7ORAcRTps1y
zJ?a<FE4~N27xwkc^!VSme&4IUf4weZX6cv8CpizU38Y%^96fygv^rzJg)8QQtRFsd
ze){y0Q()sJDThG63HuY2!kjsnI9m^^{1bO%WMo`;VTKY%>$A*5i43LY>J0l88sc4=
z;zOGH`4tWvSN~@&*f)Veqv_5<GX~$d1}hmhN1=^c2V(aK1Xx##{F<>po>3;jk756g
z9WM^wf5>2&&cVdRc93C~!W7#hlC??_PgpLrH!l>Ja(#bLfyd3o0eV6X3)<V+^-oBi
z<aWPtvcQg|!XfY*gDr<pQ$hO;hB{N83rv>I|4NQ|AK^0C(603V!LNeoDeN4Kj0+gm
zH6)mv7b)LKFcV;5sI_p2_hnx2mZ|ZtV)h?J8<sz&(hT<c|LtG?>-sm9gX^~}4^#8Q
zb9xFh#6{BBH?&$gGTb^PwMWDMiZcU8+UIVLBBw(aKPr?9T;WXVRr|9}h9zLyW!8oZ
zy#KDs3H3DWS}<Xc$BN7A#TxftTCjW#%jUoaYis8O4V8=Qe~B#Q;E=E_(|<63c4^B&
z+XTCM$!!5Mdf%>B%efQN;GYl>Zr(BLQM`zW%NO}Gd`(OopF6udI64^>)-iOb-;n#E
zy|-~X_ml0D|BLs$J8=Fu>pP|muI7v%n{PQ?sCTjRm|)G);IzZ>PtCvWkMD~K+S?ys
z<8otMqgWOoaj|~W;>3=(^3t_GIaa72=;2>$TgPyJ{eAm<|BIhCH6EU`=b!Wc+WijB
zv7*V$q3`Tv|398Qy}g>Lrs78{qs^m3e;Dc*zc`2ZFg*DF-o#4bMSSXqzv^MUY254`
z|5u9HF59nN_TQU9re2p_{lWd6TOMRwbz+eDFSyfkzJa{N-v|HyPy6+L!vEQa>QjH#
zcmCPW9aL6a^y}@jA8-HL-%&_kG5LBt%a)A00WVlDv@E{P@a=wx@`?FNueRK9xI5?n
z?bU5e3&kDz(%Qw0`S%Ox&%Yoq(-qQI<&;yhKx4yS`ICPR&i@l-s;<Gah}qq#zBc+o
zU`@^cr_S%iZwUVV>#(Tw=WSNU_2>7W4{d6EXtw{Gk3$3tgOh?ooJ&oHB_{_rbIp&7
z+?mWD|Ex`6m>|yPzR;QBh1_3;Z3QeB*Jq0gvN1fZbKI{RSjZ6YTfUp0p``85oeBRL
z{xB@y{&nwx*^5^9^PIMS_uIbcW!$B(;DzQtr+=Y}H+UNzF4uE&#{Rqi?frQsmPee7
z!oGe74o*_!3sv;B*M9QCwjzw}<1?{Y^N-IgaphQiW8c0{8?PVm50@;Rx_y)8?%VSh
zeSVvJ<3x+T?e%x(75zVNJCnZo<SI)Io~7$lf7Z^s<Dc%HTPC0;Z87)mhKy66RX6Re
zh&^T<mS&OmrqfM$`ocwTo3fv-{uzGuglX_c-3H?YAJ{dEjcm2t^mbQrYoBVFnaX%I
zJ;_hXyU)P8)HtBpsHRnvwbyoPe%CVF&rwF*zOQG`e0lcGJ1;?-n!h_9&-I9uVAWl^
z-Kw~(-ico~v}ReAtWdLW+>iD{x0mery@mB$V$S9p=RzO<;o;HQICo3UxdtV+_BzW9
zmNX`(-+jLde3LJqXkdt5FY<ZmcJX`KVJ{Ef_T^|+$rTV=5iSySjPc$FtykUoak+LC
z>w-2LeK$Q>t5Lw6a%ht1%KMw^x7RP9>#Uf5&EiyP{MT*MzEwW?6BQjb$9u6!$%~h^
zcZ(8_3SQRyo7t<C6dyZL(xc>``0vG`#jLl)pFAlSeP=BzvA)hX-10`$;Tki=_nZpV
zo#!{CPHFtzC+nPfHplVur<l;s28;GPKhZUxk#w-?lxp?4E4#v88b^9Nh`o#3&-!Qg
zg`%^^0`6-+%9zUaw{qY6XV=9Jymz0^KlSCyxa^c)hZ}z+PGb7<fZs@P(Vo@TpRS#)
zx)?FlZnO5$Mz0y6+rMa9S7sl{EMPkEJFUU+huqipFM?XiK_&cI=9?PRk~5v|OLfca
zv9H>FuHV3RN!Vd;trc(iXPsL7?Ox6Eodv!fnR8DSFI@VoX^z^&UHSboAu8U>4ulH0
zS_wB4T7G2f3N@bi<-@Gn&4+Zq8a#H}){(4zzI%?+zI|1BZ+K2T+9W%x_06w7iM}1n
z*B7v*uU;<oT5in*^S9}*`i^$b3D1vOWUgbe^YF@FD}O!j)Yj;<3*9EVJNA?I!@W0l
zIJH-;S#>@2Ow#$wCvLsIVYx@ps79lH*9Z5APm30Z-!x72H4?4WxHIYRr@G|wmz~Gf
zFp7k0%~-H*a_5@`>4l8zm;L;;_3z=Gn=WigT>m5Qn)S8y=cR1K>gu+!v2(EqoLtD)
z@;Pi;>|FT_?-kY$&Z?xemN)tP*z>bq@sr)mvC{12j^~0O-bl|Xys)m>r8=!OSMj9O
zW5df+dzq%qE6aXh&}}XiUz4uO>H75GZTa~hpPwt;WIg}rJz4%&znmh@Ww=a<=4EGz
zvcHyDX`OrfxXSXsw)ecwO_p;%P`&1U=Z?3#Ppp2gIIk}1zIOGd?aSCE9ekITEtbf>
za8LX9jpx=Kw0QTRYT8ZqOmj)$>PasZjKmIp?pJr+XZXZPbKYn5V)@SeUxr<sT}~(N
z6^R^MvX8}<>HP~{pTjOOZ}u;ped$(JwfreJyLXHCyIOiypA$+f3R}&`?zT(r8}Ec|
zd+u-_?u?UFvAFZp_R)6R49mX)PLrlC@YD1+dv;JS<o~~!Z$wwlf23&8tJ`3)<a)?0
z169kF1%(?bJh%91I&eLDoc*m){!$^|i&&m3au;Lg=+@-N$q2ShpD{gZt(MLeOVuss
zd>K1FuADK$r?4@Lf$LAD<mJBNdaJ3+Uf-?a(OYxF|FYPl6N)cyR(v`rX}<0u_x0RB
zrt8NKoO>j3GWxg0%@moBHd7LlnuKO31qB_LaBfT4<m#L0;qt1hG74607fDn<rP0a0
zqc$=25pQJ9TFa78%0lyPIy!kiNh$RvmA}|kcz@nQZO-njGuArGqWkx4`ViZ6>Q-OQ
zhJ7h|kL9EPS*9P_w|<6yt^T~QvYL-&Yd=&UwX694+~7~Qv`YKr1$ik4jP|9^-MCgG
zCo4`h<Hx-P+)ovhTISc^ny|$y$LNw}_PVL%*UtFAD)Ic%m9omvO|aiPIqb@P1NoVg
zFKaNbs0sb3srGAb{DYi$wX^;CUFGxYZ=L+Pv8~%`>Hf&NYr%U=eFb)1ylJ%ItWBbh
z-l8LVTMtgza`T<ffnz(RSKsroTJhdd_lS-~$mYGly9|CbE=;l8UB!`}u*1qk=jevS
zVB5;0UlR-7Og6gQH$ieU&sTl<Qu)h5Zt2CDOFH&O^Q@ISy}0&>c<{tK-lc`Mrn&9!
zZ$~eT$xPj_;n9xiE+3U56-={D7Jtn4DgRM-v-w0dvrpuFGn=)$*EIRgvsKdhIfb|R
zcS?VMV7Y#?-(CHlg@scW_UT0KeIgoA6O&m});gVA+``Js`h<044vP_g*kx1p9@kS-
z*k+u36x!d)X?Eku!8`Vqk`w+^%g778&{F<#q_foL{)_V~UHebC-Z_*Rvh>ztp6?&4
zEH=eVt^5A_ZEw`aE1!<BwDoK>&v(Bb&$@Ko`{bUZY*J?ef~P1J7aV!}a2-!%XWIhy
zZgB-KjhENurtNsGB9#-S)RFy~S??HUTH|ZUg+e@kw@m%LRAk<-S?#S_f6cyB9(T;W
zBN#tBZ~vO@3m^ABbWX{Tx;J(Hrt4q--RV))tlG4zInl;tckkbOQBN!V6<j##-c@dT
zf9z9<nEI@}JVqZ?TxQ(ZtHSQ}heb?lf?VP~$Iy#Px|{N4Y#cTVEZ=ij${@8k-*)k?
zkeQV~F5Z!o-8cXKY>#l&SJus6JeS5@`<bY)xH9d<PV-GaKlbNUKCt$ao%PzS?ViIc
zA3l%skFOto&$cdzU2<}7piNzy&g-U9skooPWv%hYdOn}qVBZ(WdDe$VIV9}tqGjKv
z_5JDP`*p1Ir2%X15-X3>hebaxFwrPJy`if~`u_v52e;>(_|bUi#@*YNtuGmw6#8WT
z*g7|^RMTZjlsuZ;JKxOYZ{EwOMGGy2{;jdquW4Pkl=DkN{Ii~P%SeOkSNAQ^`E;l0
z@(eYLU+EjQCLZyQ;W;&NlKmmA7`e36wA<$-E2qoMQpwPsX8f>ZU!ri$%9Ya(ZvHso
z{n}5GJlzwugq!a^Y419IV%qII_Iaw|XL`RH1#dOX+vz@Y%bd>DXQu94QgbimIzy(f
z4CnO?d_}&GN+xg6-MMb(k<*5GZ>Mey74$3jT4I<S9BQ}Rziai@*=Hqf9<$x|Ytbs0
zQngTf%H<Rfw<pG*rx~976dZrp?z#Mr9oLq|{dvZ8sr=D3Z|_^NO^@v_Pqnd{w_~>!
zKmX*gtX<EOD*S&~uXb7*Smk~E`EB+kZ25_TrtUH8jxag(O673Y{meYn#@wJSrt>dv
zUyrD0jE~x?<Zj)|AD^_JHg%0F%v<iuIorQZq(@srTWn3s{X7=y#9wY1mBMM+J~_s&
zmIfa~%6%%foLG|?eK-Am*N*o^YIBRV+mbSO9y~q!=hX;3wT(XPhpp~>Y+uail6PTF
zdii_KN*&&~1L~`G=cRBdt-R(L%FF%z+Z?v2_f39=g@<G9F6>jzoaw*w=!uxGCZANc
z3RQ6C7ThVxt)En+ydlP5&hFs*mtIEQ_m=yp=k?S#V3yZr1I=|)Vh*3Y7QR(T_jzRf
z;#Er*Tz_`3T(Ii9<kO<l>%-?y3Yb1C{!p3}t3t||oc6u1p9n^8Js)X5+gVh4JyZW8
zzF+kzKYA1+!jk#kPw{n6<+AUd@OFO0@?dk%#*<HzPYdmNAoeZk@cPcU1A(Fs{~u^N
z{@}0GE14I%4{sd!{5VgQb8AP>T0w{0NQZa}>yRhPhkeaDlY<lfY<jfUd1C(h%S%@Z
zdi~k7!vF2;_@90{rXS|r7d&<7iPF=3X;*lsU%q?y$zt&X-{$)D<u1`*SG&qBcaMNc
z?51z3T@_}NyFa8(SM9rZ=d+D)*cvI_hyL9Um2M|byM4BGo9B(C4>^pZ#A`$Uy^p@*
z%&gqfcA{LhaqiEx%Tr%p*>ylqzr*`O1<QAd17E7=6!6T?yjyc&;|rThg6k)6U2fm+
zRiTum)p*0`9_!-WYR7+1*f8%{-RFjfzRSf5Bg>SI9^&w9f4sx#6;JTWU%bvwkLf-t
z<+X0BT<iE&`>bzq<Ev#lQHNZum(}I1WZCa`Q<eR`6Vu6~KDqC!dDfbW>A&5*OFVk<
zC9X&8touzjbu8&})%tz=WK>Y+UyJXSc7>b&KRaoqC9?m8^o^$TD)yVD>Uy>-u;&)9
zkWaoUYW&)&f6q!;5!H3QTW%YDkQD7J`&j?5BWU5AZxa0rEJQBo398sE(T&)?cXoo$
z?|*xroxF30HEz$OGP|@)g~&IvUqwIMe9`Lij!sp_z*RG@O?q>vC;prNy;_OIHzd`?
z@}^(jQ+L7eyX5P;>9sz!zrVF!*|Vx8sG&M!v39>w&WwX5{zXfxR+$yNd|t5enYhfd
z1IxmXO$%QVnx!1ddQ0ym>!Gzf7nrLgeu`dm_x_RlF;8sonxxKK`pZm}vtU10#Z=$6
z;E!(#rwFX=Gv4=A<63&wwU>wV<Zb-ioKk#GEy`|wb$XNVn-wu96WXW0Q!cmv`DR|;
z`JX=PKet#Ht<IYK?qS%OSV>;7doFTW{2nVf0^V1;o}RLMTG4}ZXWn&R=6v|D&#1`4
z?C~l2x$aR{4t{m3e{+U!2IF6CNf9QNw2sw$*Eg0&$a0!yH$SgU%8qT?pLi#gL-ViD
z2DLvNj{?QdDpVi4Q8LSL<=g0Z)t!IVSnk}ao^#K;vZ{J={r(v#@!UVA{=2a6!VSfY
z(<kpKPdw+axoqRQyG>n&+H21*dj8^qWYf}Lt4u|+Wran4y`6Y@^6$fEmff$CwRTFW
zSh4iw$M}`Civr@GUYz{+Qf0{TH`hMZ>@REIoWCpiknD3!6~p&`uZnhmZ%xg}@{ZZL
z<YFr0B9qTnd!k;chwc|LOq|}*wnh5uI;DrJZr$OGFAjRT`8029_1&4L?*-fHzE%}p
zbhw@IVz6w@JMXHJv@l*%pNrF%2glAaywfYR@45cHLlW~;7jvw7F>zzu;TwNk|K+*t
z`*m~YdEY9|1!2;Y?{PfklV=xI<yOABBI#nf%+IpA!dZ(aKfcmt6Z(Ef-MpJSg7`vb
z<+_zc@Jx28=~al$JH+5ub@4*UvB^H0rBy<lw3qnYJJ28&{3Wb;D^HhV{`MW!x4&Pp
zIedP<uBw_%e&4eT_hu&_?3>DM942lQVSG|!-}z&w1<qtV`g~Ya@Y#otcRLPUVP=Wu
zzWeCyq6_>|A9S|{{Zey1dnQ?7?Xq@De_O$4Z#YA4TE8p2y@!>9#qJ-cQT3~?OBeY1
z`X(-UlCE&WM|=9T2db$ysh96GCoVh|?KH2xm36;hZ%=05t|zv8gHIgkbbOmTQ?Tm$
zBHw3ck7spyuV>*kdZFg>*7k1Cr{3k=?>sLZj#{zo+U(}7*&kMyoH|@rWxe>7YS(ej
zAfM|?*yZEz=h(f}x$I`JZv6+BPk-)I_bQ!YE8o1YBCTbuy7sEY-g0-gD3wh87RPVi
z74X?dMdSZtmCHNK-Co>%@T!nohVSOKqu-;pyb9pz->~;|`NqWuzW-XSUVM7nj!2gF
zc+dM&gmWkVTz_o-hUWpl&Rti{<h;N9#%J|+tQ;4DRQK42)QY(sHLaYsTV%HrgUUDd
zdlBW{+nKpv%KS+Eqxn(ft((QK`S;(-Z_wD#^k%nm=gbw60qmE&7Dul4PxDh%RJ{Cn
z&)sL!ZE7W^YBjST>05gy=Ek9SOJ2L*WSJtb7Ok=6)92D%KC9)d<Dx1O{xdvgN*8-l
z{(8pw^J**84$l1GvuORxKCVYfv)-o8&vv@~?I-i;y_uD_Z=YYh#!uv2@w(flvbm*4
zGd-o({583e@~OGt@1pPXD%qkF%tGxquVXk`_p8lz(y{HiE7ocWhNcU?T`=#qnCBg(
zR~C;1=gXu?Y;j$wVOtnh($DgFOYGYHH@0VMESbFJ-R0{7KmG1+ZvMb89y^0o-&5Gr
zs*n5rQU|lE``4QmTu#Zo*maD>^61QGS$%S%KB3*GIJZiwyh_;>l9HCqx3_lD^{9z=
zI^{EV%Qo7dy*oqXzRcPEldfDkeD#H4h|rbyrPUW6uYSusXVI#K2Ip9l?3p97D$Tmv
zJ_hysF{EwwR4UtcV{d}p^X2m^l@{KZV=|$jwlSk3(5<=i@@pP*<NLR3Ecl+Cy}$I7
zklrSxC1+L@7+%^YKe0llsI05h=5~Afwi<PAl{r}tAKVFix@B@){^yy$EkD^Uf4FkZ
zr2UQ#xthmMem%IPkj1jvcgfU)m8Ty$#h;qJ=eKOj-lF~t$E3zzI=`~HZM^+I&9;i@
z+&0g7=Je?EpG%r}_XhcBYMwMJm?$j5nU_+<y>?<<cy;<@8Ihh9JNUQEZryZJFyQpp
z_X@XOmG7IVn7V!6jq8_M{C@kGPMN>rzTK)vKg0IsPJI!XxuPQSRNK_Fr<=;V8-H^Y
zl<eMIH1V9{Y<KS+UwFhXZwQK9TB-RuIq3Aa(!d~<@B@!ucAwi*@LBG7>b<VH!jo9t
zme)Mas{JrY|Ix43o57b3Ub)L1yY0gzjc1w{UdKHy3W<Dn@;I}x%dcd%z3IHuoVHGm
zty;Xj=9AFO_qA!FD)SdUTgv%uw(_r2%J+}U8eK4)UAFnlr$y3MrC)nA7aacYUC=yb
z*^A!?PHu=>KK-rr<HKA{CsKKq9BGK(cK^8FK}J7)iF@45NrnsExZYe!tv{&8EO^P>
z)wO(1T}t0wv4-nr2G0xjE5F)S(wnCIdc|e6t*0g4WJ%w=z`0&=Puc=?g>#9M%yrJ@
z2+uF~Sg@~lo&<;J((2vHXH>*IW;RZUf9GQ~ciN{_D>LtK_$y8K+_g=fh2@Q%UCiUE
zAIur?v1=c1xb<dpj;nahYS+MrHx5raH1F9Cxrm2K9D%H>QcsE2KWcfm-P&%)iu$70
zn%hDprT@IMJKnJPfxD#5g&o1cCV5(yznvF+`P{L;&`#(qV>zq*)l;?K)*cIbIL~xK
z|E&|3qVN8f@=;o0Td1&ICI0;tyGNV5N_P1hmK><p;);+edLzAbb5FZY|Az_pkGyQl
zoT~LYjiqkk(K8BFJ7@2aKg^o@ZpytChq?Z()7f@5bgH-Id9AgPZtr_UuVsaq%=j(h
zy~WQ|Lt=;FweIjk43&{=KC76It83{hZaC8#;AIrQ@(PR8(X>^(9y$AcWm>cEScQ7j
z7$nX2d!ktHQm}mW5j9@JKWD$E_xg*utv}dRuuiYWZ9(PoN^S43<r!xsg+5xURL`2e
zynaW?)0M%Y<)@b)HrjYcdSMBV)~W23ilu9G<)$v0c+UMEi!Qsb^WUYv)x{bM3cf8q
zs!$;?^JSv1@7eMjwfaZgZtuD)kW!?$e(#m4o~Od;f;%0`G8^ByZ+xkvX1i;})V+)2
zT%}nbU*uUN^>m$Y==+1)r~KUgnWeeX`^Q5@^=*Pv*I2#Um9q5mL7q<i8Pz_^4d>6F
zc;Vy4(#rbjo0nL#s0dfdB;NVy;-2E7_Fdt6TFu%^H8-8q<aI7y6j@(y;}@{1{piNR
z+J?=W1^0TN6YBnCJt0Xc=%_8biwNJt%BwR^-1wyS{`&+qnLSruNAl<{{ZnxMq3*(X
zLs9e0IetGIn}zb@5)w-<{_uZXbt`=7-?F6sPz~MkpQ~oh_dU?Rm%Fz~e`m|Qs%^%3
z<znj-w}lGl`Epsw*N9ZsayhKAeqzS6Y~9YC;-@V#B`QS>US#Y{Tf5@Su^pT;!g2fW
z>@A!)r}OhWm9W*@^iNE`7nU8me&10Klj0@iGjGn?nbqTcIM&<0cVg%{Dd%N(EEgWH
ze-rD~;%>0&hIXUt=8SOB(ig#rMK9DPN}TnI_i1l3-|SYi`gh@}ee3>q3Kw47zHasr
zr)4^u7acoiaO?SN%RORZ3HDlSaVdeGjF0ymby?PRruR+e)315^C;mEcsnhVuk82*E
zH2k*kUw<gJ=Jw>QE7jk7tFw)KpI&&Cy)bV5OQ9)x1^+%AyPUQCXyA*ZQrA+xsh3|r
zKCL@)ZF-Q+=hVx6U+o-MH&#w+w27X3qcuNw`6i99x(${Sr6Wzm9#rkW5HAp}pm6UM
z>u$RxrB^D?eK6Yp%9gpz;X&RLyQ}3J1KWi5Bt-uYzjx%<<Ffhdr}Fw|{^|K*JuhL(
zUYVr}PfRb{6+chtb7OYfs-qKrczUU_`8n=POJ3)a`LN~J3sFs%v@Fdk<DDOF@om25
z-fa=zIn6;%x9HT_;O`6DZeJ=n=le+gdSQ-l_O*EucQefnKY1u_?6Yoe$r3ewtNyP1
zV@IZ&E>R5mns}{+>&c2g6C+}h+&6#b6}!lx>RozoGV}Tu`rNIa9ET+rN#5yxk}np1
zY3o+iS4-E=y}s{Wz}jCO6*tza-nLu%anI52=N~7|-CJ(#{+g5j9;eaK6ERAzM!zTR
zShMrYA-DO9cRXU0EaI_xtygf=Y?jBSxSH>^Pd@%r(UCuru41eZ9{!6hF>6`LmRI~0
zPldgjO+<|@DBkZs9JJ9SYSGc4jJH!{|Eb6(iBDQ-<hk#$L+s-t$NoL8oLIu>$LrxS
zHQ?EWXHDkQc^!Ubtn9T*JND#>S82<xm+8Jund_DQp1AzPll%NTapNr!rzbbPao5!>
zOlJLl`_QdK$ER=Dd?(#yu@m~ZYS-zQzv7(6m1|V&&DNY|44z(F6Q9O^T8=gKj?P{8
z2<sd6znZ2-EMNS2)%V;Zrp~9&#!4^T;a8>I=gl`g^`ct8*t((`QO=1U-|Z29c#O$L
zq&qb<@}bhzUH%_>Ufx)Dy)5;z^2S#YM<?*|E!DMqxxmOw=+zqjqjhJFHJ#q8&-|Rp
z+{!%0S9e|i&az+YU&o&noAO8Gt>?0m?-O&bmd19kyCcQ7!DB~6VRYaYRaK+?C4X`h
zeBGV1b_DJ))eDro{pHz(OAA&VipyF3>fi5zw^g2nAzL=bP5W{=av48!B-2Tud&L#M
zect_Bf4?tWrFF*3s1r+rq;A~X?Q!mQhJ^mYEmqT`;u2?@Zg_fb0rTm)ol0?wto)MC
z?><)$7~;PsVaGkm8Ok4~O=XTf)pz0#|AR$2hd~prXj8AI23V$Ejf~9U`y-7M3@r^U
zjj+wV8X1@xn}R1_x%AyKb4pT+6!hJ45=&BDQj_yjQn~ExxS+OG-0Jzt8X%K(jkW91
zyLTq<-o1P0$8pW!@w<0IHWe2hyc1B_vD>?VUn-`l*s?fHE&bp3Rqu3H&5FByecJk!
zCqhhT962N7<8X=Z+d7||Gi&}ZaH{%RnuRfFYqJ|`Yg;pkPF*&2weAc1A{MRO37fm8
zHrxKU*HM|{=y1J!rpkq{cLPoylv8-0#+~q(VMF2P%^yE(-o$hxGV<rY<QEUl@K0db
z6+M%2$_&O&eBTtrS+qFW-SyM8xxKG{xB35*Yk}!f<_#Y|el+-ZT2>*Ay=a>e>n-Lf
z4eO>U?Ec=f%ptm=t$C&BiL0;coi1=i?b>DaY4e7PiV6efw=pwh=jgV)lwgz#TQ`lN
zbOQH@o3bfvKe~+^Bs185nVY7uXf-TbI`#B@E?)NHaQ+3x93S*HY&BxNxqHv<9XDq;
z&S89ilToUui$T<V!r%MHy6UA3nEu_BVURYyU4QuR?ceJi!oK}4Vw*L~>V_rL+r4Yv
z=rTMD+osUawMA+3>gC$X3>o>~rYl~!cJ$$0`4@a!HnGmyBmHM}iGo9v4=+Pa`j7lN
zy=CXZ`qt^4(F@yFUzqY!`%LxhrEkuv$h>*u@NJzQNBvdx%%?m?weNR}pWfe|o&5em
z;``6?DS4^+Y5&A|jm_P~bgQ-1%_q!xvOo8pD@T2bm_j&%xVE;ozO_EX6BdTbSy7w*
zOm(<?TJVd$>h1VP<$QH^eSCckpUb5b?6r$8{I+M27hhn_@!-`PwojjbE`L-n$RsU&
z;LNEjq6ti!Hf(bLA^bO%$LPQG{`2>5o)Z2r@oVkh8w_je|Ni|x`{3`knU*(hSN%2o
zf4w7eO6Za!Pq#?^^ZmKstFVyWzky$vUA&=lZnx-xW5>>MKB)Zv===V{kjAk8>mJMR
zEBf|~k73{b)3xs}*L#)y|IT;e-*1N(4F9FQZ$7Loc4W9^-@WeqsiRrH{vG`Gzw++?
zr=R}kpZ?$V>Hn@5|F<h;nn&NRf0_B;?8pC$%x~A^?ERPfao^6ob??I$Jo!+^{q6tt
z5cV(MUurd;S##&jzx83~M1R!rCVdloFMamNv6E*`{oH=%l<Tci!YRwLo@QnJ{C@3^
z?)6`<@8zt0<G6}XFRXsA!TY#1YyP``uS;2G_I`cG>EBuZyjiREFZ_R2J2n4R!nf-i
zHx?H%H=H}?px^R6a=)@(1OM&cp|cuo{%<|QAeL6me!X1$fVI1Q!_H>oL-EZ|pD}Id
z_^bL$x{x{I$bSVnhVCQsN4OIv{%QWfpcC}p)n*NY*h~8k*#k<y*$WvWp8QkrW9a@P
z|7Bk6L;kAs>wd8BO%MOod~dV%f5-PXL;rPG+~2(VpX2+RSN|{g{zj_)LUq|$`xmym
zuhk3QuNK*B|H9V#!~TxPw$>NUeXRZczv{@p?9Y0pKb!Am8~xRPRCRr()s21qU+snb
z&h1wzE304h&op0bbG?HZ1NRI6mhX9g_7>Lj+*>*Ge`CGkYWr{Xj_l^o>u2mQ-u{EV
zM*qMkf6Mnzboa{WI)3}Vp<;UEU*>(^4?L6qFn7{h`v=zXyX`;xeVX`Fxa;-ZtN&^n
z|1YdpfBr%J_wLPy|F5{ey8O@LI{s%r{&A<~a~u6XJb&`r`$5nDXL3KUUVP6z`RRw{
zQ}4V#bANv6^!mG3=gYk3{o!7H<KE3(e^&m8efjC%mw$o#+y72}^7mgvjIGSSg>~sK
zzVZLKC-c4jKzW_q{~1?yf46tqykGd^ui*c?SDT;s`ToZL;ycUo&b`lx{r{C~fBe7t
z5BuxF92NX0Xde2ssClKsiqhJQ-?eKc7P4PH?^)*e<lyQR(iU@VHEX^zZ%yDl*q+_j
z^g?yxyPtnwwCnZ=f4j6jO*&R4O!~0z{Vy4HbDkb6%P5{4>vlhrXW?;SaaZ$iwXN&)
zY?Jw_jk)K17W<mmFMZL{D#mU3>G|A|?nX^lbg%ATt#dvxb5@<9vZK#2x5JM<ekxLM
zY$@wVEe+|u-g)+H`KiENF`a(%)C9fdZI|%(Y%G4uvu=uUQ*`cfVL5qaYppvevfTBS
zZ=R|J7|dfk6ZrP4*F)RdWxV?``FR(a7D`?hSSWB}+U?o<Chfh|JvDfH#zfg$O)?(M
zQ*Qk7soTh^|LyAKmbBvm4g0(|eW|`u)Ri{ToL$_vGT*h8XW0Z3o236jd%m1mf1&Ex
z`WIaLx=NLeJKJXIY2GY;>DrS#bB6CKsq1$3H`06_9$(}<=kXeeqt+ee%vYQb6eT6D
zt-m3)mfe5nwM@}%-xr=z3YxgkE!J-0oB)<=aiO0@{&Raze~5gVxV+bX<Ce=Cw(upZ
zY?{+>b?!s{uQP3*S?O$w<^T4&$5r}d&8v8q7rkdzGAr%Wo@C9WXet*x)64tACtbc-
zN`GS3-`eI{`(b79sb%(O?xsn*pHgi3vF_RK1?MAXp5MFWolvi<#GY0&4yT$!pX=8B
zPW?J<X4dT5g_FODxvdE`&zmRE8u8G4>T{9oj8hV7Q8OQXUYXdl`}+TyU=^>p#jE%2
z*?;iwG^3plkF9E)^J!C@Dx0Ex^Ox1%Hbpg^;JoomQO5d4sH-Y_`Oav?ikCN*Y?OD~
zJG<Vo*7^pY=hZw%t^2vx&+oJ9;#6H26j7We+_QS;!>-t-2D22&NtR2VP2Ln=?O6Hw
z3D*+V776YC_|ume9d?$~K4trL?lAY(J6D6NJaiiCB>k8qOmui^!fc~Xom|WsTh3H9
zS7Q1N;m{S=Q-5bwc;5}zWo%M<#;Bm#|L%g0cuT+inxI|Z8{a4-O@C&Vb!u&CVV8$O
z-hbhbWo$i)hng0phL(PuJV(1vUdk|otxUXo*XM>npRF(DLjQhyG=0-_1%(OznbqaL
z9t0ec(e*kz`A&#|T4w6y_?w%wy1KsJsZe#=^y;~ov&)>zH=lOdPI6#6{dDfT?RPHe
zsBU<l;2~F)wlz%V`QBR>U;ci=Gi6H*x5mCRCtvM9|EOnrid|SjwV$q_=Et1@=DZ&t
zSOy-v$o)5C*FvwVpIuzf=SC=;SJZVYRr+;P%{*^f$?K|XJ*onW4k;Xew98&&M(vxt
z6%hgdH78{mpRDt0H)H8O?aP-wxvK2&8VA087h;xgySw#}!rOxkyFSlop8G}Y(34jy
zbl9V$Ss&f*X{%pwDmU`0`4i_?DUYWspVo~Pmo)s;7Q2f1O3T4clTVVTH=7;Yo?m#&
z#zx}mG?AT}A}udB%nA+;tX$_2&?WRhMeOG1`&X~VTYL)tJH_X3PxbmBVXpY5OR1-_
zzC`MzznRM`W-I+e<G|*%1#ABbEo0Y^-}mmTvJ!vk-I-H;v-71x%%_UhXo&7xpx^2F
zWX_ouiOnX@wkw2eKA~a5aA=oS{!+fr6SoJ6G<si(58|7;Jw5SFMdi!qj9x!O4sb2K
zP_yTRefsLo$~zlk&WS`n6*ACUR(oE9A^Xv@XOH@YFLJmPFH6YZ$I8s#?B1We!_4BX
zj6~`2l|1YFZ`wq@dS7`}%*f%A)4``-<>%kI-FK8}P2AmLw+YVdMY0?M@sCTkaz*IB
zJ=MO)=#KtYtCY#E@>8Z?s8ltQ=1MwrR;Ipow)vKTZC9V|x8a-W8dJSQ_ehn>+>Ogp
z{{5NIpt-TjTFIt5|Jk1Qdw&(r@1Cw)=``uUggH~bW$wMBz0qgMp0uwQmon+xaWxV-
zzjfB+mTr!)#uxwU{@pyeMPt9q?ib#lJMSM0*#GL)44Jd5cTIVE>$~C!b)iMu915z9
zj&EkNU%hReM6`P3tV1pjH8{Q<kDhWxZ^tiD!>O9Lmjry{a`07jy`;=@>A2aUjXcxy
zg4%0TDmJ|LpR_LA-~E6s>!SlF8%*l<r*7f16I+_f{Q0t(#NE{B&#Rf1xxe(huj+80
zonev0ZPB<Lw-UIrbh&?P>pL+2)_9yAebcZz@z$J~+bo3cxIf^iTDYg&xjV-wdr$N?
zxw3@2Tiiaca^^YBo*W^?ZKb#7;wR<0zqb;+udJ7!G&j}iL{QXThMH3DbG6eREW6p>
zdmvxz-qWkI`F;e)Yq;7=eo%TAUKeVgF=<!e-poB$Hs-uxkDm47gV_YP!_%Tqz5W!J
zYjG!h&KK3`6IOlwAbkJ4)C&!(RcULVEhyVl#{W3vak+HRk4F~^4=3mwzJGtObo+}}
z4AU+PoSDy-li>1=OYLg=(f<v{tFJBODEJw9zu3?;wE1y=w%N5_$xHJtypGUGvDac!
z_N?xlvO!(tj%<NRvbZG2zBhB1pZWTSQ?7Y|0B7pAS%p25=C=M3;Sqg(%Vxn7?Q%Iy
z(YaPvSDdtZzo|4bkHb7iY2{tZvS;S%I}9~V)i{Hma83_tefHD*<bqYJ^M6e}==4fv
zhw_d7v_mQKVd{_le%zX3xAN*?pJf{|^k<mngf|~v``u_ym;4&XgzGjh9t5|ah@Hp2
zUhw2ytF-RB(-NXCZJ);YOQLi^_HVw6oa^891aN0x+?wN6dP6*QMg6f|w?vF1vbck$
zNoGb((U_-Wx^u6?-5FJ%JLgE7ovXCHevvEW*~aT@=gQshG1k5N`*X-cK8Xc)*?eWJ
z!>0zUUiv5D?~R$3%F9wFB=1|WTmRCNOb4Odt5x&&)hDi3{Zk<~Wxt#0txrzYm)B}e
zYLK5~cd)0GCndNgDep^$)OMz}_S_R;p?l>1E}PJiYP3y2=|JmRv-suC7kpMtpTx;u
z(RF||_0&$!#8!(A58)_<bA?O4@AxoP{fPOZ39R>gPS+H?<6ahX<~IAB`n_RyUd!z`
z{_276rYH6r)wVUApY$iwOXOg-^O2hRwCbqK-LJA=clXU}2)TA3sBr%@MTg0Lr`KgE
zaO}_hU%f8xpWMN){qc_~H4D1;E2LVhbsw9ac~13)Hc$0LZka9CYLSzCxSZ-Ib<LTz
z;(3Ipv!>QLb+4W8)6YKl+Nl0FPV7aTs*JyX8k<8KV|`gpQbN1L_xo1!UlqwM6rLcS
zadyVfEvo1Ly{))*x?$#9#ys&Jwkh(?hpP%0mc>`~EWGmYl)s34%Ei5w78M$26U1xY
z%sI2MBRJlz|LLn$s~uh}<6G%5i+gWJnUGCbl!=1fdCq^rT6r;7`E+;RHxf$O{r%S0
zji*}jx1>IHjNE(1atm)?S7>9x>za<r?Y8fxbLQ_)tJ~G$FS1x`+igvGB@t0er{@W3
z(#Kr>Un>71eK>(tw`6DN`)ilhpRRt!fBUN*yG25*N$Sf>VRA-S-Yiyg{V}O&*T)sx
zFK?Q>f49Qj=g*tg3$&JAwm7{00|)!FmD^9o^4_uDYO&63&Znqq`{tZ&Uxa);Zpbs~
zMZHZ~t9<j%oVZ(BJs~#>Ypyr$+27^%$G*4s_LbFn_Y19TM5O1+xGeaqbW2d^S7)Cr
zcm3SBC-W@l3lz$Bm&F=x+G%yLdi~L_8?R>YJ(bv)-uCVV8;f#^`L4efQfK~uyL8A*
zzB}y_PoqxcneR=n&DC;c7<b+XJ^JhRmj#vQ?c!^7mqfpNH#vFn^r>wpc9>5W)>!Fy
z_{_^!yd}w^U)$D9(_Md7c6;m$y*CejopC)|S6Ml!|MI;x%Z*)s-deik*m|q0cK6oS
zU$cD~SabbY(ObQ&yGkZMx1}zbp(GXeW%r%M{*~KU)vowgo%IQ4SZA7O^6HFoRmT6C
zNw2H}R$kenZ~mY~^?%QcOGjE%92yy|jVIsDTzu$`OsuYjp2*tc5>j0<2mc9p3w~{9
z_71V=b$`RC6th%uFJD@n(T06nG+qZUalZUC_==gKmzUA1x02R&vC5_#p9QU35?30&
zDPMjx+wqzDk?GqnJoejE)$R7gLF%)e;BvP9Z64R<Be{N7ar>{^pTBZpx<Zj8tLA~Y
z7iD%eiC_MGGI$_sdsmd3cXxb@^HH~HK^$gNZin0!Sm*rih1pjgk8QgdS6OeKn)lAi
z-u`-0mzT>0C8;!X<=tkv`&UYD5^Hz&*VvIX=eJJD!l({&n~C~4)Be~^H`%X#`<BS3
zUO%1S-;E4APyer(>2jO(zu~I$`$O1luN|Fx#7d#o<m56Z(ThzP)1NY}cjQPD{QB$N
z=827B5}tX%{$1Y<GleESvs7MMc9Tbb*ViLASKWKIefAG?lSkVbeAdl9clMdk^$V?r
zrprIRy8QG@q@?uale^y<&p(t?abM``dwv1^t_K+%?K_&;BHjrlO>3XhykbjCWn9gn
zJ?cq&_V68Fk(2zrRb%VZ!xJY~N-fqp?2+_NN$Fzd$(^%vxdnEw<-BF4=d|senshMh
z1A#rt`@SBo{Uz%bVkf?NDes{xSMIqKZMYG+eXE95|1DXm{;;T|jn8kf^1Mzc?woRX
zQeCIV+wDf%&$r)HP%L(hzv9SnSo7{Q=BScw3#WXHEw220an_t_rDJjrCC^tbu-xTT
z&D`uAJ#R_5-tN;+8A@JeUp7>CJ|F0ip8mwYF46Ee!*O@tX-A)mW!>Gr<LAUhU-yKb
zwQvhOJHddlpX<o=`>CIQ#GlVPy|?}LbFXa$%lh^@a_@hra6MPZw{=guUS4B0|E6Qy
z$ENI9Sw83Qi~bcH!55<?Hk~$Vi_|e$S74QIrEk3WJp1H4mzXbV%o8?L)SN$Mtvq34
z@0HJ{b=qe|Zhk4q=IFNRf9S+6sI#yCzDifg&CN{DkCzneI%#v{Qk~!}p8g9NTAW>3
zXIR>gg_Yk}@oCoM@GV^3Au@5{t-Z{3Sxp<+wKmk;wtEru;*z`AJ(a$tKC|QHI)7~}
ziCVs5Vb7VX+PYgD#VtMDJ~oTXJh9$nGSMVIa5_`+l9;_K*e*6z?mp%}A$(RW)7+_B
zR;^e4c1M&wS4|_U#roEcxZ1`IYh|?-OxbOC^6A@OTnkgm=lwdH^<k^?zsvngt(t}T
zwRg`uY<G0yq&>THFDEU1HZw;0p-bdWEryg%?umiEb1z>0*v@S*&1sG4O>V85niii=
zs5CPu^Qe5<ko&=P-Fcpxpv#*j-pu;D;j!-F-$K3Og<5On4@-*~tbYD(;`+3MI&v*a
zEc!0nrEZ8?vh(g%uom}vqsWt7xqXAhp<Vh~``+9U<*qWVo;Txf&9$7q6N|sr6c(~+
zL~oawnS1>1<u$Vp{rS)v;c)fr&x`Zy3VDKF{uG>ZOH)N@?{3#=JC8Ik_!q^J_G16n
zA6(Vf{;>oF2S2g2JRXy`TZr9aUDH!ZAMu51Dtcx2PJjDb#U-%V>etmnFQpD=cHL86
zq%FE9_Vv3D+I!DWtJ5nlGWh0l_o2b0mhXz&o<;JVebu;kWBJpf&2~9@lWxaL%~(<C
zFpXdN+G7=arqIosj%WOzZLn^y!h4bZcfKd&7qI^hTkg;2E}q+$?sa<q;#b#Jut)u!
zlXl|=SCa3lOTJ|W@!w(!3r@Y^tzunpbK(nzSH(Z-%AVH9ez-g1;R(m{3&r`_e2(=W
zp1mnQOI2}~p0n5ILg$;mdG+rWBt@|NI;_s^_0TjuVoSot$<-eX@_W+?RzKdl#bEty
zfec;IioO40Bq!!rpP1=&bm8Xh&GOR?wyi2Nb$sD#@O<^tzD3`9;u!b3%;~le)>D13
z_z&~EQ#0>xD(rU>DQSEo($7&)I3aJH+!o*S-VG)5IvCIVI(GNtqQmmm8i#V5wI9y-
z-g8O%+x0lMXPeyg+n7#i#BGY|yrA=1<VlGNcm6tEgXd>blN(d-rUcInlbblt^5l;r
zc8te8;)Kj!dkCrRyLfqSMQBIH+1!^*rMoq4W|-M}o@}kYna`yzl@l%-|LsX*&HX*s
zOLxU`9h<cLj7s*xhb5`<hMT^e4cjcd)|&Z+h0XO9Z{jm@7!&5+VC2$L?KdrZ74hqJ
zQA}Uh4XuAMhc1gPk`LSYEl7eRt?Fl7SyY{g`o=yJGl!cWx)#~EU+Yn5y?fPYk;T%k
z-Y;rv9X;l`Y?CY0>Yl#)U~K98s-27cs--Q$w((6@nJj*EsZsZrKJ{}~&TL+Db6xG0
z*yZP}4k#Vy2>ITB{iA@o_72ZKe^c@ePMlUa{`BKPhikIMYxg-jbl1G#e(8H6tjEYM
z?!1(V+iTY6p=m#^SpBu~`M-8Tf7~~H-FFr2Y_6+1OBYVRRqeo68r}TcgJak1_}0nZ
zxdr8#i*Na@E$Qv3THYgTz`g5r-Px?}2kCts;*+j_?)2<<zGbJ_x<}6|WJ|W*Z(X$F
zVN|xyovRD3E`ECLJx`GZZ?on)@f53PKjfOz&z2>fdi=Jr>$dsswG;HKxaHGC!bA1C
zx$CP>hObh+C|J6>$$3+AAlECtt<je}4y>MV#mV>a;*_})_nAKExLMyalk@p|zmDgO
zbHr~giAcEh{<ihRIZGVtS2=7Dd2W|)uqDqnO7T<AOkp!Y&UMpQ`-E^lE^)ZE<7VJQ
z{k=b8E3SX25_mnw%wC;S@}#`o5$~kSzfS21H7=jYS9<Knim*Qq8RFJ`eW|g<G3FIV
z)V|5LcE+A(kxSna=9(OkaPPk7tn(!^9_`z4=!yyN|KCYf%V$0cSjhQ0;Z=lqRmrio
zrw#Y|yQ{tm==_|d*kJH?kB{Y|l0QcO*7Y~A@SX@e7jm7i;oOX^A_wR0pW(N6vVQ9H
zvfO@t(bH@6HvcwL6ysZ^&(A6?rD2oge_ipLYk+{q>So>9j3LV0&Q*1JHA>Y7&h<+>
zIk|<*64>oKUwp;Sy(S`0+mk+RJKcC^=J`YWr2e05?K>y1xrF!CxmW9SN|mj;d82C+
zUWz$bx0+9|im-JNnSY_kBkQ22Rq*-D)0d1FtmZpu@K!rLPw3U;bjwbasoynkG-y9r
zY@57He?6mTuZx~?-tHevJHByP?ky^qc(3O31&>*-MQ7Re7A`*V`BnOjH%eDOXmGl8
zUf4Egb+*+}R?U;5TkdVWS<J-S>uJEw6fQd1<44h7o(NyXX-}8WUhXjc;mpR{jd_<|
z>{h$ZCD{3hEwniE&ZONvhCfWx9%O2*Wx07tZO0PN^SUw@E7W>IW~v|DWO_C8^qKa{
zjrWRK=T3Low))JC-Yd;E)A-HSEt<RYObug9IKNy|Z5D%pi&`-635NUEza-d~sceuk
z*IoRh@baa9`?PAfw5%d-&dYA}`uDh))B0w~pJn+nlX9p2Y}s4pnXeJN#s9+RNp^p=
zOMf_4v>7K<TQa^lq_L^^_@%ka{%W6^bVEp7x?3P@iMyVsvH0$VzM2(Z=PNAB`eIOV
zbjRe$qF<)ya0b6!Qg_<o)w46t@4bB{#kocB%}&9`n|4SAmMd<%9{&10+w!Mr-06Eu
zAEm18oi)8$V3q{OZ>jyZ!l^y|9=l~u{K=aXGxPkno1f>MJDMq8(i5-nWIxA)Lvsra
zOjQbcUMj?P@4Nl8Eq85CNp{Yr#~y#!OfzIfi%u@we1B~p_g9sg&stNvlZ4Xxj28Jn
zPrmcb_p*$1O@i$My^d>QTI^;z=~|aeU1WayEO}Vru_rssU_HmTo6FvQ{AkQNEvSm~
z<f;YS4o6gLi;hpVbvv*?)wS<z!m*4S_0sHH8Rl~?+F0e}Qvb>L>3N%THx^Fw`aUr>
z_t4qjEP3~qPWa+IL1yyoEh`r3n<e^I|9T?+&}s73dvBHpiQL=r;m+rL_aaC2PPX+q
zJ0&K>U+CX0TN-sSd48+f`P*8udltWWwna^|?zfGCeyjC-p*P=VJvprLmi-*p5@XgK
zo>jgD%O76e`M4u>&NHuzvVx9gX)BuZ7wUW5<8_!&yY-XfUagq(KNPDhRvzT{z1<sm
zL3HV|hyPEAv{$^<I=tZhXI?>>J2$_qRSDUbvFcO$Ij>JK(xRDadT-5?cgn5c)Alh~
z-|ey4Zl3nS<ze|=9#*Z6diy5ypECIz!`Stp-PqJ`@$nz4yZ$_Q{36%l*Bfp=*16ql
z45S}>_2;guY>j!i_d|R9Jr?sb?upyy8cEB?@p)P7O0zdpF<h;Z^xRs@lx0GG<ZfXG
zeaVF%JL_M6S#M!<$~E_*AFCf*nQ-!|Q<@%itt$?%J=^nea`?AU^UO(qw>2)i^TGMr
z50B*<XYX3QmS{h}S1ViCt?%LV=N-j{-)?wbxjSjcqM&&`mz=jPpQG~oUeX84%-nr@
zQq&9$7oGX?!S(Rp5cbaXXCL0MdiK;wuVq2Mgxi`o?ai|;+FWM;{W(AS<jQrmM$^O}
z9AuQ3e&2T0;iA<W#3UA9Ti>*~?NIN>;xqQ^V&BOdC-HT!l~;OXJ>zkm{jO*7H*WFt
zG<imCNPd$0vdGfpg!TE%r&E4%wbrjQdzGzsyu)gFi1c>JQ$7XKtnt!e*H+Ao$_wJT
zT3J}v`$_7=$B5JFt^XeH`OUVG%U3zHbAfM0!Sf^L3j_Sl&3e3Q(yIBdtnGv}Cj})I
zelw2@?eSc^#Mq5VdD_&yuTwS|Jxhy{*;>rMB~Z1bMg3a_kJHCz3~Zhc+@A|>JJ0F(
zK*#>sgmX_sE6(I*hzc&Rme^7^aqBvnm{nqrm}<`-jr_yt60h(_{+V#!pXGnzcC9Yo
z>2SaKrekuDjEJ>&<4yI#fS<<=4un-R89u*Osi~&sAg93oy(_YnYhuDQV}k&#`IC*8
zWJMd_>yk8H)I4=s?b5K_j&>iIzVkIro^!mvFyo?Ef$sjri_bn+Inc>_d$MTYd-a!&
z`g28}EigZwuCb`ft3)Vj20PQuU)|{yx7J;swfXL+nWYa-?fP!1-CJ1qwd~^!@s_L=
z9@AFO46Rx9SN`|qH_nCje+1(CQ>WB^&wlj9_?OJvXY~;dXXYLdKIFJhgRS7*|ETqn
z`m?jSc|OD`-`+QWYOA%$s+srZ$^R)$+uF`p=dgR<vW&pX&7EuV(*vxmG-RzV+HSXB
z_02KsflB%NqirGQ8o6zle{y^Y2%P-+<)Jl(RemiSX0)pQn*MWnZ__WEN8G-9wR}!K
znRRY@&er)Kw|wE=oFL$<RWxmS-tv@R=cnYYxF2!8V1X1b>s=<b_f_9k8yBd!mvJBE
zHr(|`iAm~9MxUeXZleQRvRw?A-6gj7-gk@N$HNuYqRGxxvHHcy4O7=9T2E4!*7JHB
z|Ki5;r3bm*AAc}sGh;^Df*B8|%-LU6*!PtCg{;-%f{WTZN2jcM#L$vwAgOnNb)(eH
zO=^1!s}n?`8+1?SzLAjQ)$s0IzcFrW@b=}KqZi*5(VMxEwd?SPOg+1-hmZNPH?Vy^
zs1n&1eko?n<+-v)b)UZ}RQ=)od*O`BYifR08rQhV|Ct{nP&@b0@p~yp_jkN5V*P)H
zW9F_Lne)keR!&zH33-y)62{9napqg?yV<c{uRY}HtrC9rEz@zii~Xf#M`V8Nx+~qN
z{4TBa%&QDb=h&9@@(Yv}sZRBn?!55VoxeY0LO+-29n{_T{ibrv-M%0-_e+O2C-2W#
z8YZ$^)!Dq^|E%KmEWz(D%{M<ir=Z79psZ$=f#nI&yL?K<ccR4QrglfIH13P~pZ!om
zj%`(e()47T`^&3}OQMb$<$avL|I5Cz8NsKo2`u~?%9?zyXy=_@dDem)w!Ves-@Cc2
zL@nm@UgiFMamP6~(Y}U8(MI$Br=db(Qa+mOA0msnS3j-c*f_C}`@yQEIv&60+>Qyp
zGHZ(UmkE1TWXv~cFZduPdT(__$$>{7xr%S?&lSw|e6{BF(FnnvZsO(63vDAEmdLG-
zIdb)OT0zpznTx)tZQAX&Y{R9rcN``iccM(KMNS4i@VynXOsR9iQuoV(6ZAGn#z<8!
zO0|2xBk8iyR9nyMkyXl<j`_-YUwJn#V2%i<Ngf+_+Pcdx-}l(Q=$hBB=f|c#am$0_
zu`)MUIo|ycSgs(hyYFxM@p_kYX{DV-RsOwIu@3KQyI*PK8VU4&-uElV{^Y@#!SmcV
zC_F8i<eNG3#AiGCz-??dUHoqyH)9QZ&N=b2L*2y6>~~f5a*FvZzShEr)R(+iUwho+
zc<>oBlkJw3r@gL3b>@3N`0(!R#HAb6+uyCW>z3hVTzRF}t)-nu;HkO2h5f8ePZqWA
z<g=+PTeN4c!t(CJo9t(}t(dU-n0lR(L65+j{V6At=Qo*%TFY}UkXgr|l~sOd`=Ra4
zVZt>!*Y)aLGAb6#OP19<vLk!jNtwD8cjv~R_L?Z8bMF5v(I>{1C!gf*Ud{hiz|3KC
zsu2VCw5v%|KU!H_k^lO5O@Q!MX1VznE03MOX<IIE#!W7TkA3CBUvKWEUB2q-+ooiy
z6+M4f{%g6w&k08x_VL6e?M%M%d7IMIefNz{mznjO#L91Yy5!y~zpcyXW<L5>Dp1S3
zw$1g7(Cf;BIhLyf7dW%LJE!#c_LuLEpZYOR-fIzbG_`+^=Z}m3+-I;mRqUVobHO?}
ze?vZ}$H!t))O=nh_8)rEU=r6^ymaf|s`E|fc*Px@5@Wv4^L+I1_R4K}$<JcjKDf4&
znA~~setG2ajHhRwh{?|E-g$ec-s)rN5j&2o%nyx7o&Rg@+}CLu&Sm!|C8y~brrc&{
z*G+tL^^P?AuDvbom1)<`&v|g-`%6XJ1MSmKot9}zdC7gMw)Dm(>o@9$e>E&}I_VWq
zx>(Ynh<)P2HW9ORN75T-DDSRe-Z^j8r}?IH!k)g3ySw4KROr^JY>qoqw!hdpRVBW>
zV0oME)x8Hgt2s{AF4V|>`E+kfi1G|8yHEpOi%H57&-wQ4aQGOfJ-O2HNU>k|^?4@R
z>s!LF_y+ljp0}yaRlnU*a$>`cc1F`Jz10U}gl)pz&+`4zc&Vk@lrs6?{N^u3;<@uZ
zb-kAvT-&!%A(iW)pU}y!vq80&X7o3?et&<3XTsw*{D1#8uy5OK{Qb=3X%A!9OQfH6
z*{xMjb>yThgF4fxcY#g{tfA*yRXb8P|IWDDt$Sj|u}KGSzCKmLec$D)>iw|fEAq1U
za_T1g2$gy<n`valOi2r|5pwGA6xUyxQm(Z7_0;dJ_xw3delXZBH~G=_bst|DI!BAO
z<SccIKO$8nXyQ8e`h+7Tn+groa*lZ4a`sxFBcK|RSvT=lQK;$PpzSHw4^3UbIdk!o
z9f^V^QWj=Ej@nN5^bv7VQoT_-ckxn#zS3`U*X8C-$=~#kMOJE+ndE5~fwFsNLcC_H
z%@1s;RW-R({UW)xn5S|5j!RqZzCM}$^zF%u9NSb=<FaONGMc)|hcCtc>zpORbAQjw
z_?*1_SI7d^=evF{S>PqT=kFfYZw2dpx<d>_KKz`XlJ#|USGMxfD%rQjoB4lFQ9f-c
z_m@Fsqq=VMzkLjD#}~_q@OGUEUjM3liePWOoWerMheCTd_2vAY8aJu_fS(u7YlDT0
zwN6>B`jJ;%qp@moxKhv~p_!d$RgdMobpE?|J5$qs`ND$>ro1Q-%}$$l-}H|8vEzo<
z78X5r5SHp+duY{aOA*F5NpbGcTeG>MW*WL||C-I-ee-qEwD!plXDm*BCABy5%i9b5
zam-J)+dS7TnCBsrB!AL>KC?z!hWE>>yI3E$F5vsKu|w+JV;A?!tGQAx1R5?f%$j|J
z?Pb)8kPS)xMVlT3Ph7E6;c-?Y*W#rSf3IG?60wxm<#b-cW54647E6_-eLAMWty9Qz
zPj#CA;+2led|nDkofhDj{mL)#UCleu3#*FlU!R&gCA!5RbDx&`RKW|L1~+EyT)ghz
zzE*D6)R;4mUiVy?te}{Bykg=a<?Hti(w*}~?ynaNy72X<Qss_ITGL|pyPai<m}s0}
zIYY2D@R;F-&S@4&t5^L0x65y__!LdX=MA38xko<ydYo|ngzM>p!4WrZE^d1C!PqrQ
zZvOdQ6GVP4f0H^*ezSd|N&GwiZhkr6Cu+0v5_U~`;dY}_%DZT#pOee1E$Sju4)W_O
z&r=sm$f@Vtw9&gyE9vF8qBV>87T2C#Wu&@4;^tnC{FN+%?s@M1^QXMHA6F6BdVWVu
zpI-YKeY*s2*_?lI)gs?`ULI8v>M=A<nzTctv-|3lOv~~K6aAT`X9`@{`e2gnjc{M>
z#VLmbr!Lwqnmu1b&P(U-&qXQCInFwKhKgD}Eo}EHAAWARH94q|@wtDbC<`OkjMPfu
zck%8UC+$1Z7_jVV(aZS<-`+P$<YP{Bx%NesCGwV~(}wximY1tcOk%ibzU;tceYT%r
z+B4s}M?FfsQuHE<osEC<sfew?l3(M^Ds~vo{gAiq`-Aw;`_~oMNv(Udv*p;m(;+jh
z7C5hV&TISHo$c~n_T;&^(~J_27jp1l7f9Yz`(aCpc1gX@>UV#ZR`+aqT3U1EgylTt
zNplQ%)#hz_<8<bgPXGGQDAkf(P1W<;!oGwYnfOGwKCSHA3$EhY^JRK{g&v`QEF}MS
z{Cm0SXos+aW!;{wPqw))QLkBj>|ktr(i;2ld#CM`X0m%a@T3?B{Y$H{2@d)3HS4C5
z60=s`YRL~iJ>F;A(!=j;t=+49xvJZqf7+6DT;Y-o>}}`R9sX~-p4#RvcYj&ZqYj<s
z%DCelj#Jc2&vsqjc0{tG?C-{)%X4pB;XN!L?pc)mt2$+Fp~M-B*&@rC|LUJj6BIgH
zYT3gk!22Y5i`RD7hY{0QHvT!o*7E%AFF)>0IT6ooraWg^z1^h6lyP<M)ME>#*!?>#
z-E8q!=8oZRv8IL(6~C8GT-r9%sHikR)nsE(An!Tl=-n;akEPiY7sUkM-f}P6NcGnX
z;TyO6&u=Zb-mzr%#O~I#Uk)jvKjYKI&S+*W=sYkfN~!W&zwqby^pqGWEzYFV^;ywV
zPDdZ$d&c);D}R98>x{i$?LMn0Y+2o*$Y-|cnXv0+Rx^Ije?~_?-+p)O?$fZlfiro#
zW_QW1?7A?c-h*ed%9*UvV4;<d-(Ac2BX{*zTDQL4>8}NPd>Q&&r^U2&*7Ga97hRe1
z*YDfuJ<`6rT;`j2*;UNh)_%UJ%SKn)`_G4e-b))}T2&4|=4XocF4+HV*<0yVzT4e5
zxz1gqQfsN+Gii~)r~a))6<x6}W73v)Em)y&bltP;?kOF?JF1?^Y-#<Xwo&?{qW#jC
z?DwHufnAYp|2X<vYDJc=i8uOmZcEIpmi+7&f8`#^H|9UM^Z3-kdx_7r_LuOBpE)pV
z`=pH-I^ut>IR@^U)tvlI+uZ-rG*$h>56{12lF)p$sbz6O*8RHQtuiNd)>iu)u3T{M
z?aiZ|SwG(LNv%#hBdjR4{rv(4j@@~BGJ>A_Go}T3PCIw+s7A+ppF+XyznH4cBfPxx
z+p`WF6j)qSf8w691FN34!LI8)dFJi^m#j&>f52d!*emAyLJsG%Zv6|g-}7ewqvj(Y
zJMM3-^-f<?|DN@<jYoE~_q7F^w`{PVAUx~JlMQXFip`t%{*sAb^L;_!j>u_s+8R>~
z>%XK~9gqm0{wL98TF9)jhc9n@yY_CEbI!V#mDV{C+yA=l*0X<nS$azBfjfHXS;AB9
z9hfJy(&3zU+OjE+V((T-f38#7C3%B||NS@r{M&++nm1xXUMfA+zj;jlQSroilJBe9
zlIQeZx_7H&A8YqR)87|QA6WDI>KaboSpn<^vjSG8rX}kp>xQ$OdvoK!OBJ=b!Am}v
zN8j2XDHL!%z>~o?o#*t_(;6SnEu5)#aV?j^S`DF{OLHe}Ru%2+zqZvq)cf{bffOOj
ztUu4UPRhFB=X&pp^;PM33xA2PzpmQ-lDpW?V?ABzl7~*xG`n^EL6@iBpQSYI8@K1x
z_gpQzMGIJcS4`ZH`&({;hR{^DeaF03f0gOk)nM(axAVmue?{%9i;{mAXL&7Ev8>9G
zJUz*6feFj1ZIKTb-2E(j@btWW=WHVP++6hgZt1^&p0lQgpZBPm9_{X+605MI)Y3#Y
z+`rDG<o4^C-RCp*>}-7I&9){i;s3Eew^a{5{};;3DeqvpwEXau#?LFwm;Py9yP&!?
z_3fQ?<?}17AEnfos7*fme)(DdRa4I@RzLYy^Kwe+zKmC0c1&x(x-_w`zC7dDPH*<I
zS3&Hrr^uf>oXO~AbGrM-JEzS~?H@Ps@y<8$+pziY`QB|O#JzhCtaQ7e)fK-umy7$2
z&le`95U({)H%(u6rcPM(>;s2GSu#J{H16-ziJkRw<4eikH<pNQ?EHM4=g>#VmQ{!U
z*j=uiX8Y@%^uhQe$`)Tr9=7)@CJDXbp1CYbJ?f9m!41;<i?_xG?wwJh-*n3^BPb_A
zMoi;a<~1XB-wK7x#($VZUT~~e7UeFx8+vf1K;#+450AIqoA6s{r*}snPp-JiYL>7U
z>cJA)PunJW&35wqFL~Cqp8fhVS>}J`H5WWCYFb_H`?a2JzhS?%<|OgRFKd)`ZfNt(
z2@XpMm{K<T-rrOyC-==O<M)Z4_c+9qezR!V_U59iN1jg$?B$aw-mc-)>ht|-zlpn0
zLHMaZSA;+MIj=2Ex!$IDzlyiazN&VPY{Kt3i?@BcdAH$Cwd>bOo7a0xJ>X{kdP1M#
ztGcrVOG7u-w7+{1?(@!MF7K`N+2yt|8!q2a=hz}@bb5*6n`PEUUH$U&n`fjP6F#8w
zGo`)PQzA<LR`~q6>9a2FIz6E+U)Dc({~6KvUpr>jc7zD`NLDtSNmwpy<~&Cw=2$pu
zRk`S_-nfRJ+8fk@-)O0Ri(PSO<?gWB%^O3)8SOb0%KUWrB>%irFMlMVxNgdYa}ggB
zMJLWpR^IjX^Q^LCHPfdQWgL5(X^^w;cENL=%9YDM{J8TrN9x)=mxGgvD{XUC+jdV5
zkb0kGV&GgT5Pdfz-`m9U)8QWZNpgFpEO_$E;r$=(y)POnO6T5qFe!GW&&mwj?VMa+
z{x*lK<lA|OnSbgA=0D~kuOH05$G2)-{`sRF&jr<19zQwZkm^m&(wtLC%37y-0<5o_
z?%Hrf|5}Gq+Q!o}pPH<4XB0{8Iq7taw~*z?x17cNt!D)T&x<|Uc`3p_uI}GFkNh2e
zYI7ozyq4Hn-(7#>?RU2>{&b6F`6*xZreC(*FWYfPY|rOUb4+bYq`rvu&pu&mt9@WY
z*4IU0(OR}Y|F%npxpOA{Re!oC)J1^9r~TTQxmWh(C5o9lE2v#>^?4-U!L>X*f737X
z@(syr&)VtkoH$|GLGRTb>;C0wi!A<mW}UcR)u98=Cfar1-2B32=XL8K-~C(X-H1M>
z*m(X&+WATuX`hHr&Pd%whtJ%~DbKezm#Y`M@@Vr}r;m{<tCD5>TUe8f;wEUzoNK<^
z+@5l!Y3sCU?<Xlg3&~}3+*?|`Z{<^mmdlmv7M{Fu;o<}p@3V|OD>G(peWNJ)bCGhS
zQ<vfg<?FXuR~;*tPU{n@<m^|gb(+mmwP)V#o33;8q{=h(@_L?yO}s8;E6B}Jc~y7I
z?E7lb3c+vYvp0Qx(Q9Sh`y(`zd+E1T_6IoKr$^`fFwp*Sthh_pNHs}E<gKpv=GjHe
z()FQdE_qALXgGMNy6c72p3E&PlM<_zC9RCBNL{cx^XIX=lDqSoKD&#CaDB{_{CP4y
zvS-%Y;LsX3gPaX|KWc<nYDMO-xgL1qx5Vnj$?zpC$9Z{LFTCy(-nG!=zu&aF{zlK=
zvp1g5N{{XQv9y6_PPgauvnjDQOJBZTmi*_qwUd(2!pVgRsci0x9}BJAdGBV9>y(e{
zI!?2j_0-6={@gKLd#g<tNA6|YHJi^gWu#pE*C;!A-}Ch+owF=gZ2!)3*Q~Uu;o~aN
zR8{dw$MkO|{C+27a3*4subIcH2S;aT2FS8{DECYaU}SrGb8UdZgyL0BR$*$tgH_!8
zO26lQGM9IrYEz`U=T7m;2e%_+8=dm{))q7tMM*|X{&D|UGFz;EwKDJThf{42p3M;5
z6(<l@&(d(-Yg6{tV{4vgX2#A7p1C^pWZU$kp}&7B)ctuN^7*dK8m;-$-d(r5bt1ea
z?-Nh^MZdnPJL@-AI=by?Kh4$sebc{4^B}GtektFMzvxuzWLIaqsMoi7jo%`rr>C1-
zVp%SmRjx5Sa@ggYR#;lc{Mx7)zuW>(eSLi;TlQMvvvrrV7Dpx8opHChl(tUkM$T5Z
zhf*E=|B@!2{(PLh?ZmW<yHl_KEs3}Jw#uB>JMs6M9j5k~ElIjozt5!3D4e|bmY&JI
z5aH0dH!d;Q=U;oL%G&o&(J1sxQ^4I$%j<WJ9S-eV5o{>2=ekVoy>ovw9!)FQEj_oU
zYxx$r7;i;8A?d&GK6gw|Kfhsy&8lGE8_f&4-upZiH3`nUwzx>jMXNm2HUDRCLu~!d
zd!f5kj$Yk-$y-aRrb_3&cF)xFr=@r%B{X#{RBfDfSN%@Us{Z1uug;f7l;2K~%#l($
zAnrZ)dfy?TZ!hY;R4;L4E?5}a`dcK_@5|l^MTZ{moU3|2E3a>kK+RLDx8gtN%=GP4
z^A41Xe4}?dK9I%o#IEJM`#uZnGo@v&aF?mvG3RP>Tl~|I6?b$e<gHvQ-_ufG^n|4>
z@%<<F{(9S6D>kgXm(!lGeFIYx)7qaCD>g8^l6#b~j&q8Lkc7<%t>3<(nSL(&Ti^It
z`05;p&^+GPq0_v`^~^W(cM%IL&ip)B&Xknpu=x?cPw}pQvB%<P=jZPgo3{L{U)-D)
zue5Kxx4kP)^B)N;RZHFV;(^RG?)e;#B!0i^Gv?EgW0TJ*4-T!7NMuns(VtyqbkXXT
z%14{;SC>{s?ns_dI4@|!*Sy~!&c=A0U0p1=|A`rYaFCIV*{jWtOEpBAYJcqbTkIw<
z_wt9Hs@=O+zWdY5yel)|yy+e5u*tmZ?%VFUVR$=WzU>MP&ScBLZN>8%%hr`Ae)hT9
zb>w3Q=SR=zb+48yMaivbDZKcy=s>i_vgn!qzt*T2ZaIDYrnsWg%8&(G!Gd9XDzntB
zxnl!&6-==D;9zIav8cagX_eXM198Vzb!H?TdE<0NVtdSV!#=@)(AA%w{*3v!QTCjr
z-pjK$_ddI5qbhB<cf0n>Cr0u{9u_e!?o#66u|-E4V+&<pe*BZp*6w$1iQ((=g_{dz
zSN)zR@BL!0-mZee$<mcPHQ#x5AHJi0-P(7x_%e^|&W;zm+M_4w9e(?GlIG7&E76Ld
zRd3v`SImCJ_wr89JI}4zyI!~7ept{qhqbp?zfI=kN@aPAmqO_tKAbBq@7v+U^1<2G
z`qruE-Cu=!ris*;1v<Zf;2p)bO-uZM(=o9>LJRv1|885-tZ_ed!D|D7#!tUomOmB=
zdfRlVuCKY<Rqc0@)=nP2bDh!)m&vcqnyuE6*<~*G<8<7rEf*wsRV<#!>^T~e@=3|}
ze?-`&Z7c09IUPT?s&Xr@NKj^YyK3g<;@LUZzWZI|+pAW(e*dO}*Qcc4Nh<sC<eJy-
z&jpLUw;Vm?zvN(?;PT7eTtRGqw=A+XagyDtYkseDj&A0JWlh|Rr5x;MnDVN>SbQk<
z9cOCAS9K}I8C=R%o;FX~1d~Kx<<#=(>{}%@qa#?s{9fJVi<h~!tul2y_DL=wU`q4E
zhWG1abJ>*B3gp}ZE?jum+PBE}%9q_SQAdTtLf5{?-#t(6o3EPHl*oU&A0Np!?d4s5
z!_;-l#0|4oHl9k2wDMRd7|DI#wCi*!dz|p9iIuvcL2+Gc_v|=xdft!Do_O)3_zSZ`
z59`^>_Hf7-nFc)xNX>n=bW7T|6P5cexJ=vpAj;Nf28X5d(caUi;>%uk>hI~eZschc
zbA7ewrVn*_9bccYZrl;E^Kg4=^U4Fi!dR2`G(=DS`OV|5+is3WdNKLy^VO>+ALY1g
z^7Z}lMz6=|$2RCbzLr%tNis)kg2;~eO&gYE`294!Dl>KB{#$dqazi^K7v?SWe4y)d
zUFwjFUtJ*oPJ>rZu7$2z^Y>50rxka0u!SF<zUrOFZBhNy*FRPpgr1x0=GZh@WHI~6
z7bkW~UKZ5(<?L8{*h+HW(eHCjHb3k;JZ-JG<<!5*aT@7+oL?}=DpeMG9p|n4%_oxo
zGWhta4p+`U3wR{#pZ)WV+~&4E?#}dsY;NC5eoCrdJhHyviprTQr*=6#u2XPbvbk~1
zW&cFO$s#W*9$AabQ*{rwE|&f=Dbt|fkWK?z^VGsj(HK|D<TG(mZ!f$E{q&<lAwXuA
zq37iMkOtuieN1z-rsXWy6?yW0$p3Ae7Nx~?Yrn2+U70iMd{uw(l+6z6n<vMxIL{Eu
z)cLZzZhrE0xta+k{P(sT_F}m=DP@MaP1(<tw-z3mmYuRi(rnXonNOyjKP`%mthzYK
zW=mQ8)f49z`>)W6*rWHgljZx5Uvs^JGEJxMoP7I%D3?I6>)s8sTNnIU>w3ZbyvkFy
zqeoB3r_b{G$ecaX`u3Xc_I|53FRZ>--*>jJWqB!OE_%6E+_bUP`dL+DZ@$8^Ei>1a
z)vwsMI8K0HcTrid{fo8THH&0guY6wjf9AHUwtD|tpS<+l!V+lJdim(ZRUET#+_l}Y
zraXF6)U5cO>->|;XNR@hRUEyy<*N2uR_l_6)9ImSzaJEksodZ6qFp9c@>Q9Ghp$#o
zb?YtfnBWUrogc@tOV~O;47&2eT;cnI<NYgb689Vn+MxBR!fbuj4#%_yUKUfoUDnh4
z$yUp}zxaVw+m7`YK2KH>+<NNTyGG63dpazRM9F#i+|A+rZ<qg!|JlN*%}Z|o*m8MO
zu=*8Us~<97H{8DQMS4wY@ch=v37S>G)~fz(W@cIyOVywMy&&=b{N$;ZBVWJ#P*P!a
zc4bx5J;g6BKh0WHcb1oMUrCtk7QLwJC3lu7>#plN=U4cinsrHx$t$(KZh7jw@T9IY
zn>H8xVXAJL#?!Gc)jWUU`WYtvexFXioSAP|KWn;nJ%`@4!!ZsOZiYvdjyo}{Sgi6F
zJUCJP%nZNv(zl*`)vYz0)~C;}yP<5QtV_j)?tnnImr^suXI?&1Xuibg{r45qn3C&m
z-fX*bMBwMqg<n6M?#*}^x<K<Qd+^^UcXpHs?w4yeHOMG&Y+Wb+ckzb8)6ex9I+h)i
zb`ccl5uV8L_#gM7UrB48T^A0$|AguDq+JIi6CZ#1yf$?XN1~k4!9}N^KYbspSiL7C
zzB9T$(R|}B?+=<&?;6RqI~|i<(%8qEu)sg4qe)soY7>9rvoE^tS$}MftlG=_)T*%I
zTkWHXJpN3_(kvI%2_9@RzIeOG{G-T%#Dfmg&p7%o{SvB_cfam~yPI0Ditf(-%TKPK
z`X^W7m%Pf}^iETOn`G)sSHVL{?+zZ^|C0N>*NG$l-2#~sY>vv>mD#=PS$;ivh2p&F
zA_5j7S^H`y2<;6s$*6N;QMqWa`Z9-3^cl|8G2AxiKQD<5QK)&9a(=tqT^;3}J{R*H
zPJ2ZveJp3TpPwC4@IfZrQue`#BNLxYH!7;ywd06lPj;p<1H<zplF?6AwVqI!ADETI
zRN^Q1@%hBq-M=4Rp0n>`NmJOT$J$%v8csWzTz|E5qi3&O>?xk+$%Y>}Yd4s_yYwMx
z+SQnsS!Qx4IW@ALtm2rv=)#T7?a#~uK0NB5tJTuAfBX5;@cqTAa_&bi-buRnQpoU*
zx`VH5=ViIZM3b*;pZloxN`EM*clr@^|Hy=LsoRWtOCq-NA4)&Bi|^#q1%Lit>)&!S
z_c_Nh*Qb?h^?p9dX4~ps=3v1fB3l%juR8zdT@lY|KlkX)oKYSf&fxp$MeoAgi-K-^
zJ`tNdE}Z9h8F;hbOtN>j{Nv-dyW4Miq|Q>m>RVpkAC}krCuA9KOlR0_iCqR~GAlR6
z9g(`{eac&<;PcXF{~B*T|60jq>c#ly;ib>}wiqSve{R9DefI3&8W9}<jp;VB!Kra2
z{SuemKTF&4D$VZP@+Rq@Ok2Vvi8()>KM{3l=jC7Yv9|r}*>cXb*SkEkBe^$*{B8Ln
z+~WJs>wQGo<@?XCJ=*H^Q~VI;t%>trrUreuJwtU**Y_`}H_NpD*u87t9nCMP^eFz|
zWuI^NMNhGB>%A!1c+J%3o7j(rZq56_eTU|LwRXBSt8AT|w&JJL#)p%cPo4P2;#_pu
zuHEU|#GCcA4m@-@X4!qWGS}k8tZXUQ=D+`>4Ndm<Z(Mr2X!=hl^-tXvLMJ{m9q;GP
zx6oDJw)y>w$ER2G)J#9P_NJBEv}4bVmc4j(I7~R=ki@=%&l*!bda})z+&kqSeYd--
z=9l7whm#jg&6L}C&Ga+R;{Sy=8ubh}w|7Qwa=xSf&4`QfWXUCsGGi&XS<z2-ZL6%P
zs^~V>QP^2g{`7Wj`il!}LO)h)pY!aF_LBA;wOMH=<M{J`OihR`T34}R0+;Bo_6MI%
zZTV%l^t-(I>w|nn+@}~H9X;9Fo80&Ov;2;m$NT-C9%4N2@vZ5u*UL>hdm1*TsZ3Sa
zK3~M=*`%M^>g!wfOQ_jY&MRiI2=pn@TK!^y_0kzvzpwT5-+xPv=QgX<cb+?6dm>ub
z-hCct^mF?~u_Xtuz5cxGWyFrZTUOQWd1Bz{(tR>-R@9fZ`6rB@>TaDI@*`9r%Zc~p
zm)sT0wIj?P9c(;Ty6w^9N2@YCFU4Id?4Fk-x~;{ogzriB(Y^n9J_*g_^xEBc{XNUJ
zy_<JO%n~ZuF!76T-}@<FmU7(9Io+-r9-HmR!{K&qdBEnUXEr{~(Ybb1(jk27W|xFb
zyq~ykC;9Y7v7ZwyvAch_^tSVY9k*{jT=4Uj>Fjy?558f&WqfsJ#Nw+Lr*~hiV>FMr
z+sN5a+`skikC46ErzZW%-FL<H<b*#L){0zk=CKmqIQ!8~Hq)%B4-V(azdWDh=kiwe
zvt(-br#+uI#r1z}IT2_Rd;h&!^o2#{y$_U5s{FG3^qa3K?A{wi%@^{=-#mNDJxMCL
z=WV>epW2gmd}D*ZYcH6b`ugG?$$j6_cix|-HKD9{m)=c#q2GQCMqFtZeW%-8YJP20
z`sVkd1?d{%FHdWCKapNJ^BTtlPMrnKzYAAMY45A~W>XS9|I@RT8p@mx8@5f+<Sbpa
z=HEfxUl->exoPv?YH`7hYv$bNe$PDATIMABz$_x@yEWe~fy1wQuP}wR-aY!D@VE6^
zm$R<rYS#TOEbGoJI{lh!VqL@WN7CuPRPU7AoHqZX>MYP--t6J|$Sdr{0{^%yKIXLM
z*WI?6yvY{4NlDLS_2qvBZNI#vfBr*#9aZP!6+0xh)%;!d_VkCzH?O|g^Vzw^wWMW2
z+>YLk;+o&N1w2fL#Zr>go*uuN`rYu%D@C=bkI$4`>QDE%^V(wjkH2Q(-!zjS^U6+|
zu|;}je0aLs!k+KeY-R;AHS%8**HymVcJ<$Uh6Q}_AB(guwltkd%ibP*s@p^A#6%rO
zofU5jM3VP#GP}2zNga}pyI8rVe)620rt^)HW;pIr+VFyByM^ieWh(zQraoZ$QulqG
z#-)!pzemhHIOE>r$4rjCO!uqgH$Bs7Uu>N|#c9&f*ArAM9nOe_o@dgYk@vXSZ~Jty
zmX#_8=PY@*gdukF?z2X(A0;n;^J0C=-u3mb-485vZmCo<m=cuv!TfNfW#(6=%)g<w
zcCiL8Qj_yyew9|;vG^uZ?obvU)qLfv;?2rbt|^ywUf%9pX4Ti-D#|A8`!s3M?b&>5
zSWYwlyQ~>h@F*aD!Mw+3I}V1hO1|Vc`o*DP=h=)&+q*t{Z+e!<a_Q>Y?`s@W+a~R8
zS+!V%KhSRevS^FbkJj#<*L|n=TDSkVl#BDHn{}s5P0u)Zg)j8?7T#;Oe#^;4H~(AJ
zSd^8pm7DKEL(cpOS1r7^#8uk`ehsaRK3&PnCj3Wk|I|R4C!Y7O-I2a1_)___eAC+)
zCeCjkz8<dU5ZYZK(fi<eanoP_9rAzvSBTB7Wo4bADE#(g_v()gv47^S5mfH`{=3=R
zXa=X(BcW;EuAg?)x+eHjL3oL!n@8-O=UiPupEA!q`|c_5Zo}6-e(UO|s%+g|o6Oy}
z?bf_BK2gpWbz0MUwv-C4s}Txb_H2!R*y5Z+Mcz%PcO7#2)ZXQ@{6x`&D=%dK^u3l>
zH2-{~n6Gk8+}AA~&kfSbE<gWV_fE7bdFDPJ;kMp%4%c`!!IZPjWzKeURl9$0crf*(
z#y)Mk{;fhb4`y!B;|+YQpz7|DrB<=MW3hCG*mtXJUlDH4zd7Z<cb=K}@{+sSwZ;p4
zCneXWOwZl^X~DtQ_q&@s7*_o_w_;l7E$1sTGKSZFCBN-G$?=Y{BY2si)hfo<Zzb#b
zq)Q_jmR_&+4UrJE-JJUWa^|}l@s2-_Po@O(9-g4|V!uvKUg)d~nF_D=XHD9)$DIH1
zJ8tubCpX>@n6+@W`gY&fGv9dzz1ta9%lqij&C)`_%pGeCer(--Y{Q<_cOIlHcbm5P
zWZ0af!@o@eRd4Bgsowki?f0u)SGRe3zdgBA$d|joz^OY%aM|0mgO60glP?5+xwx)2
zsDAImOAlfTUi@q{uG{^wLo73$r@y)Dyye&GuW#&)Hs;Up=~}|@-1^J88Kn>G^gauO
zB-k=Z{jiB@|L}d=i6+gZNjised)r+9zSK5a&-e7-pIMEMwz(%9oW#MCuh@~rGrxIW
zQRKF52MhQv&N*VSEAz0Td9dNx*N60?50pi1mABKKmUe+Xd1tfs+uOC59-Ew)!*a0w
z!-h|8pN-GH{=@Eh=FGiGqWnAT{G+N~1QqLA{cc|tI`O<Ar(&wC(%f^s2OG}HdR}f#
zu4U@@njQbWVQ%4XIlVOndH-)+TOt0M%k1iD?ddz#X{KZu^lj8xckPPZmZ<)$Z`=1y
zy5x0F-F!pX{w>bY{@s(gcb2Ru+OyBo+C1W=w??qD{5mJGrplwDz8^c;KI>a@?k&D)
zA<FqVZ;ko>&?r8=zNO7vz7dSsuWz4zm13`~m}0Y*{j}iB34F2TdsMDH(cIKJv5!Oa
z=<!=~^?$#N=Twdp%xs#t-E=>*P_td%wO4_AXEpA9ooLEXqRII~taN*clTGKVMY}rQ
z-Fzc8L4R#5&zoAW_?45`1oPw6b<BR+CN8SpH}l|ypK=GTtxli1#;R&=nftH)*x$bw
z-B<jU9(O+X(z$y~m2=HzT`|9Ro=?(~>$9ToH<?#42Pa&UE<VCmJV{gIf{_2ugEn)2
zZE~MsthBuAlj_uO+0_~^_8)f8^-0*q{>dSB4cEO#n!l!OuCaf6F!|BvLoX(7i;>tl
z(Y0jume73)_m=z&?fqJMN;W$5*vx~f_r9O0S|w6-;s4g3+O}6Gyxnv6^1-Trr1e+Y
z#X62gH|)3HQY?LQ(dpF3%wZp=ax7^(yJ!+8=iNW$v$jq<cKYbF7tbTv(*CU7cf9QP
zn%!z^CRX;IDw;U|;SK(}dXeRscP7Q%z1;15H85PVI>>HP`R20HIYti{3&ZQBbJM&R
z?5@gt;wboSxn6#a-ZCAnR|_}DPhpw*{6hpUuZ{D*gbp_T2PYCakFEaGs=HS6j$*F=
zC5uDS?T6PSEU$chd2v<ZlYnD!!smJ?<z1g(a8k;y<=2Iip&uUlKa$#eXYQ@Ej-{8r
z`fTz%SCD#m(}TsVX|@q(qFQP<U8!0VaI$u)Yy!9N;#D>qTV(dEsg$~?xmwJ!R(3sG
zw#xin2H!J<FU_f6I!V;zc6sE1EMb8JWv!@)i_6@5*_{&peVD12B(1uh@smum@|0s8
zj}QD)%MLjypZomb`d+TMX{UB}pJZJSCUf)5y>qu7glSrAbdX9oc67P%rl?g%gJND+
zow3b)<$S5#=J)Azkr2~9&Rw(CXdSkVy8JEawELn*8LUV7o^CT=Wqx<jd>PYELf_6l
zQgYj!B$CW0eQ#>S*>>&XF2j}gvunhX{MTi%Ox)ya=xD#Lt)_jFuE1^&qc1J{1ZDI7
zJr$R=Y*@K4VI!-@u}3>z|5|qI>i6G=XRZv3c%Ne>{%O@E(|v5qiye*T6kf_{u6pNm
zGly%I&|lpO=lq(rPEPA`lAV5*e`VfswQHY&?~LOM+{A3>{Q9%z^|goZUq{ENEGhZ@
zlixa$Wn#?3*z?z86E|IUD-)WLoOE-Rz23L?>AB{mMqB+nL#MAz|NZjF9zU_&lm0EN
zwTS8XTNB><bNRKhTJ_r^eL;`Pw`HuUpIcE;nDZlg`!2t2n>)WVL~waV@8j|2l5co=
zdlJjabH9GDHvW-0e?!TQ=Ra42bdQ$vm20ZU*X_B-xa#`VtIFrv1K)^5mS5amG|$Ai
za_P_K4y{*T6&o#`QDtxVWbfkjlkbJ_Pj<F{c#yZl!SU?dYo+N`Oz#v=2s6q@HZ+?v
z?7wC>X_jO}$D%t)Ewi8f*100^VCr0(wOn%xuCY&E>B;UQqMY?3<Mf7KCG2T&>n%S#
zeX}dw@l@da=$LT5(ysQ&y~eXINgj8W=nCuzu3WLJ`s2SjjcpGnR9jkl8}v>)GVPw6
z?Ut3LYu;4ud0*>yGd3)`tE=|;#50fnCm-plN$LO5J6-)8!;{ts_Ey%9bDwKka~yvr
zm|(rXTx`asRMo#L+JA;;YIaTa4b+UB6f^z8Va8`Z!uEAfrf++7?zGfv<;RVDc7E)t
zElb>1J8~R55c94+N!2~`d#kYjZ`)l~HE$PkEwMWkIB)OrJ4+k5|NZOO7Vy8dz%P{9
zXN`{-(}h@zKfkxs$UJo8Zu)mJlH1<d<Ho(L<1)c%N(W@@j2{PTOIEz!GRaGk->c&F
ztSWc5U#(fG25awKKJ;x%qGbH6l}sj+KG>T-%ef(Kuw3BpiidNmgB}#Gb7y`UA;!d*
z`%|CUTHtO`+LuS%-s{{~+-l*v*7-{3+0o;Yw*oBY?g<n+I6YeHKa0wa;L|-*>iNqn
z+_HL4PyG4#<MTtyzq_un)o+<#`)6^nNXIj|wmId>H=I4bZ2I(9l}~!rWOk1us;5}{
z&t`Lr@7*xxNPt{ta=_MG9P$3on?%_k7`;9v8mY~FZ$jAN$3-927HI`7cW*DO_>q5U
zm#?*t<mP}Cy8`~Q|2@kQ&G+Tl)o7y{4`mVU<aJga4<<@|wsVNh&`FQJ&Od)=&6M^P
zM;bn7M5%<Y|MTU}MT@NCNB@4hDqhBEBeUDPHuKrTaK@HRw~bA^rR8TGzN;l$Jm2l8
zq%ZGDuF7q<0)^ZngcD<Oxc}dCE&18BAtu4J(j(?|4F4ygDR)W_%v?B)>&~Zpi>EB!
zKldzO(Xy$6%hlX|%<kA5qQJL~VTN8$#mali%OiXDKJkobY_911XZF-y`t{Uu&)&#9
zMg0fMs`yG`#SZgJf4Q|is{NSt*P<)$&rdVj_1kWiu#7@Z%WRdS?s_|_E2B<we+zi@
zM|$OS4*tl%JqP7iOBqQu%0%6|HSP0_MSJ?9rrrxk<lDseWA6SlXU+M}PLSAg<zd+O
z56*`?^5uTcGt92t+256rf24bgGt-B(un(K|FEcTW6lYGF%J}JiivHo8k|hg2Y?hhF
zvGl;bvX!fK{%5W@eK9QNbFRVH+?(&syxY8VuADt}NM1%i;(?h;xuTv#q_@u0!`&zU
znu>N8cXVmK_c|lIxrps}Q?%4SPU$WogD2OL6WNpbcSno<i)dRRrK{zAso>H=FT-cz
z(|y8z`kZQae_J88(6h#FgT<3Mp{<AOd8^*oPg`}it@Cg3xwypNj}{h9ictF&`GDiv
z-42mm_YK;c<Jx{t^^z()keMuVcFX&q4~zSrpSU&2xbLf#%G&D}buT|^vTIdt>fN60
zX|VFa$~}Az%hyP+=#+NZY_hiX`5fb{peNr}$g5^t&7AzVKseln;l?K231JgNnr?4S
zFH^aANW1QsoazGKX%RUS3SUi+SG?=<rQnm|M&}1hBd+kCt!Ly6xL4)lwbpCOs))s9
zTTC7w=-^rSSz_CIlf0CdD<|GPvq(?z`1{cMUzU4aR&Slj^GEr>IbKQWb%H5UQ?}hm
z{<lJB-}%VDZ9Xbiipg$iF6KA3n3?9NYb<%TVDD?Kv)kUQ7Q3xaypgeL@)k~aqiSP?
z;vcHke(R>YpYL*bHm!Qs-hJErw)`;pcdC+8bb(PqfzO|%?BW%l95uQ-nsoL>q?R9B
zIbVD$`*y+gM;>oF)7x_>nmM=MEKu*OA8S@l#~-)*f^StAuFgz6wY0RoQ!;e@2HUsW
z))ak`2+ayG_vF+oX<sy5cwzpVs|K^|#j90sowGl_vzR~cT&lL@Ufb`Xwek}_<;i{C
z-*B(k)%3Bi?at>1ejHtQM@3}sgjc-$@n8G(_WV*g%{JZd;y=N4Gjwj;sqHEecHM9#
zNTulrkHQxA^j&_FR^K`#D`y|&u<2W8*r%?ZliOeZNSbl;&-Dp=zDw0j61;X~qt@lH
zZJI@9-`w&KPcQy=PvOPZ>ytiP3GJJ9NYgvFGMhzH@@HhgWPWCk-8~E6{}lCIrTN8Z
zUut1lntJiEbu)@jZ!&lOHD}p84-T(@%9wwS=2|JKMh&tpU;ViHU;V7T7S7OQ@42S@
z)1mshKUq7~HdW8{UuHM++a{U2r_xR~^XAT#SgI#uXtr-VQ~We+=M@@ZIj_*r*aCh)
zp^<`_5#sbhl&j*5j4Z&X6)F%uuCTY9H6$eeyPijL%aWD?4b}FAOLi}jb}4FLWLqX-
zwRFkE33{RdPBNJSjuV1ZmQ2)hTpAcP;lITF?|<v>@6Eou`&?A<y}jQzf8YK6x83>3
z><Y_XpVrVhfqenKBA22gL|CS=Uior%%Tfk|2pJZ(?unm2%{sW};f4KqMRD93$GF>^
zPW{twkYeNdc<kpD#d{WW?6^2z{5ZfESm^L&*_stobR>8>8V?%%XIf;isln=q_%ogt
z%?z?4La$uUt!{H-Pe@pocW+1TzpX4k=KNp`l$6w5c>iSs7gJZGrQ?JKyCb)GyAHg4
z!P3aQOhaAbiuD6|)gMpp?%8{Blaf+hU7Z5QA?}t#JG4G=Gu9d8n;&3##d`FI)7-{*
zW@a`4mM`a16pG>woZ)@;^>}_)(Z_Gi2@4p`F}7PePK?{ZBfrF0g!zFPyU*6I49+GZ
zKiSuOXIEhPV=L_-qVnr~QT^t6(I&-ub>}&A0ys=qBpIA{G3gmth!|YC!d&^gnwwEz
z$!C29mUpd(o;uek8dw|=WdCv3lI22(A)CSu#{YfKpSCnE+`HEy&fv#-LD#ye2j^~L
zyA;XW>fkW(Ufh%Yzk=Hn7x?W+<`?)`yjjj;ioDT_^$(ext#<#BI&_m=H>t0s@|VNb
ztN)z}^gjLn5wq}KgNg*tG_lDn3+6Fgxqs64NqFUE29q!40biy|n>%_4NVT%X6gWFL
zC+G#->9#q+{fL`&kD=X#2@C$q{#fp+r^RJ)c+MV1_Z8Yap8w{*vM|5$w7++E4bK_*
z4Q!8hsB<;c+y0Nc`RK*d9;ZXh|Cs;R?pKQXB^9;(E9-xsKksL((mEy2AtW}LspY83
z!G;w#d@~)mwsZVUmsI9>lP~??|C21`*noyJ^YaRie_7vG`(LQx{d$WZjrG@z93Dn+
zv;O$!TqM0g<p$?><zN4OzuwpUZ{GHQ)u;bTKkLnxyku_w&-eLn-+%c;4kkAKAKV8f
zUOO(W&QL4j$9Cd>Ta?rPjxhOGJf9u^l!x4wZW3<dx+LnJmKew>5b>yA{@GH_&+S&y
z2lvdq^Dp38|NTGHuRJhNxx(?3_4n7@gQ<-N|BD`edHN*t_rD(wef(6;(KY$J{r9U5
zRtx9Uzx46>q{eVCL4onfj@ic|Cpk>e@SAWh;QxIeHWvqvDdu{t2hK_`?O0&&WdFKQ
zFByT0|DOIz_GDIK+rPFx=h2hqgAa~;o6Wt0?_cWwFf)-?{H03sXE|7&blrK~Wvfj1
z$_>9b*YkCG27IgOzOTOZ&ys_0e&4ik^8NQ@cSYeL_o?4DZf%+DdW(1Crf#?X+dT>V
zyIUX3VTnApa+jEr_;JyN4-}(XFZ1f#%5OBiyKS2_-y@Io@MCk;CYRU!KDGFdkJG&B
z)sKJ1Z+)`fJh6Y??za=}WZYnh-DfgmibGLoRMekOOIL(V{S&q(YwM{OH?ni(*5{vU
zj^<yNS!a9l<vZcYG4E!s6FAha`*g#)^}&luzkj|ix_N)eos^5E5=?HD_N5sye<vOi
z-*{h0^xX3oSMygb*!niow)N{aVg1R0;lGj&Y^*VVzG`b+8mld<Yh`f9dyZw6s?{q@
zvtFoXORtH~G&Y@j<iO_@apnON{wUpj+rHz2!JOXb6Pq4p*QhTnQF;&>^r*UvsrX`A
zocPTAzaFu@#m=SwCM8|(U2xO<n3i(ml%+{+*{l1i;<~&2zpr`rYV)uBqA0@-gZDS3
zydIs8vzIyQt@2d;(vB&P7O#E^e|RQiXKG;aXthej2gQ)iy41|Xe!dv?a`#EP<#)>+
zzpBKqHoP`XYMtDdJ@2O6ei`L*>s`%MoqIQnyL5WX``KG6t2Q{kniKxcP0Tc^Grj3y
ziGIXd%lynjZb_j|tHo}Xn{=OxRAmQkbmU*6wcko@=6(yFXOD$EuI)Y<kh>wdV$bTF
zbNVv74!mgZsm^!!w)t_KMSoe?;pe;+SNv{VO1YN3pvtTH`?1NIe+y=YT<H4c_Umm_
z;@`xN$0mE1J)HjgoBE-{Z{!xgHRR}#4&&Yysjxrmbb!gps>1J<({Dw$P79UyoRrRa
zN6KGiUao+A^(~iUEFNZeUfz?@_qe!RY56Ph89VH^hD`gqL;qUJn^oE0Ei(78T`&Eq
zkzug$%j~cD=Uq?oYzpeRyMcQ_gGv3wQy*r|F3Z%f;FM-F%E+y>-}G~uNoiPh-sF8P
zo;z*!)hoXGrDkuLkn(ij#7TE<-Zq)hux-jCU)zNX`wHzIzwulg5ccZG?r;0{HragF
zJF)9)sr<@s2a{)ezTTA@F2{PWb^4CL<Lmvhq)hW_MR%W&tX^5OKcLL7=IDXHDeL|#
z${f(%aQ|<l&!y|C-$QQ*Puh9krT*8qE30n>*PeN_=fSq4bDs%LwVc3t{nyeZMaIg{
zcAd)9C_nM^#IN_|$B#{6=VXyO7%Y7;zDl|>ntg&i6Z`TXWqs=eLJm!h=U$>Bn4Wrz
zbISKCZv>~8EY#4oE4(wKCTz>1l=s(et#)zwc(9f8uT$-crpQe%k0xd<Ub1)h^d}Qp
zJNr-7HBCLZeAWAqhlY#vaw55ZK72MS_Wc?e{&N@pe&Jl(-s>~9Fm7x5{rup0W(xZ&
zZV43^#+jXu`ll6<S$gGt<ngCzajWzVqa&Y8YPwo-_v*Yp<(XG)_q97t=a>`WWKmkh
z`Q&TYl;>eJfBU{R?|T|NV`@=ui~roWFJA2T`SIf7nT)Lq)m8L5a$D2YOK#2a4vS8D
ze&g)RBXeIj&weE$_*3ch4Rh7%n9KZg&d%#Llzp$p^M2V@n>D+O*Zr;d>Jzrz_xCQ<
zLwyP6K9^3#KT6%gbMd%Mg3>kj*=46VuO4`9c#K=U(x=Ml$^7f7+gC;<O<D7<l}oVm
zzV1V@q&dradN!T%FjR{=T=2tq#Yf+0+d~E)gS%rY-z#1TIU>93)E|W^#nU<x2UYf+
zyuE_=?VPi#6?GYX_vo#ExS*yoHl=Q9bHl4iX-)?w9TP1~_MLTM{kMqH#e3eU|L8Pg
z7IHf9s=f5G`Ba|J&-b|lg%@e$N*~mynxz$A@b&E^$;NpPc9*}m<DVDwzW%salA7QF
zH&c-vrnl8HqI}m_XB6Cy%YXBf`>Ql>b;g&-zMqwEyCUBoPx;pTe*3qjv-CX$?gYQv
z8UM$M=S+c-oXfV!tNeH}=gS5pRlM4F<dclk_5V{{u3w&|QRFv&!t-6Os+pNVeYbx!
zxo%V4cjnaQP!+Cib7p*5H~Y@3Ih7|<^6&Z<m59Z^+Lpe*Et+#_{p?xWck+EJJeT;2
zQPy>RI%~xgr;V)(|E8$!d4I}oX-^+>f1aVz|2+pfgU@;0nx}cBS@#Ez#>W#U>^JRJ
zRl3G>+}PS$BE!}!@YKym9b8lRmM!vJ{^aQ5q}p%i%#X(FHGbAJ-r*bYaM3|Sd0o@_
zWxsEpE&5osHg>YqhRuIIZC<yl<z3g&Bkg^&Ij>nAeJ`<oML?a(-1)|aUsP9Ww;Ma2
zd~4k?eMR|{xjh*z7qjZ_uGOvGH*I40>`7Z%7jdvfyHyA<dUSfN6)@&_|NO7xUh_NG
zr&OMrUmw2g|GL_l6ZULBlB3hh{$z=%qIOSG&m&op1q$yc=Is7_=)pyS*$Z3V<YhE0
z%yYD;R`?ncyXnVv+p`&>zsw~|oWr!O&J^wOH?~SiInv|l-(n~7BlN0kppMl`R=vKP
z(K36|f8Wx0%73GCuc^4ukvO+?66`g1#q3wjJkqyk(;TMrN-+j~bC=FL=04laJY00v
zRK0bbzUof(VX8~GZt$-?)O|m1L(GI<d^!s@A3wB}?OEmZgk9g9djj7F%h}J^aLp^}
z<B{w=N;~3ir7W-b_Ib@-)+KW<Ni0@czU6|z^BWiL?zCmtDqW$|u5RzY+e&ux?$uMj
zHb36X)BPcplXbe^GOM2A8EbxZq%JwVjOl~M_rM)uPdaz7eJpQHS?Yc;o6p&KS!?n3
zbfc46Pjl2ZIzLhPUf>kRC3<1jDNj3z2UnK`^~I*&ShBuA#K3ae>|HB&i+nySShC0N
z23xY(*M(=MdMxo@=*Rkgf`#zHd3_tNmREe;D}O4rb9%k+T~Frg0k`g}%uLp1%!{bK
zw776(V}!<5{vFe+T4EKa_P(;ctrxIk+1IlVu0H>nH-E*tGduTLXS5zLxb3K9ms&LU
zF(1Eh)0FcEPkWVKi#Rlm@n_k@C);-MPCby_(z<a@xn7c3y#8+mDWj)9Z9j_5dU5Y#
zND9mM5BEa7wy!#yr*gX>V0F>Q#|woy6w5U~{<*1WAvFEP<?qKh*R5WBW{qV+y~S3!
z6V`?5ix%$tRJrZ=_YHHWZfH)dyB?`)b?6%NlXnHv7v#7*tL?H6uWs->INx2n&YPuv
z-nqWW-$$RFes})M%B*GbA+NO$`Eze)&{p>5UD?0X_L;Qcw*F}ciq=S9WOms-A?;Dm
z)q-h4GY+0Uz1?S$TwCVEyF8I|uT2YFvuT~S`nnG*Z;Gq@^s(xgclz5Fxlb3Bi!8X-
z<`r69zG1PaBK=EMbgOGa?%Do5FU>mirk|2oIQ3HeKZ}Gpzn6WUmnV2Cf#HH?!owVM
z!K$}~hIfx1-*k@Kw7}|lJl7P?eOuj9*8VlCn`vvaC`Q8TiEPxDno@&v#h2B0=%&Qo
zUAFYq;e~G|{aGH}KB?l!lVg+e1&mwmrzOpJzj}|r?uH5XpYM9V>umhLE&EFCze#QX
zJ4tbEao8aX?j3Gl8Sm?AvVB^y{RwYdcmA7b4Q7|~%+q>9dmhcx+?2(_clv@^Lr=KK
zDGBDEb4|3x&Pe!tW7m;<RQ<S0K6SR{9Gw=)iOfbk&s3Z1-1Fl$=o(KjtV`^O4lBCv
ze3?HiI{ymmS)Ih=KRxCp?7!j`;J`WgOVsXP&hlHPa+XcxaXlx#!Ln^t>b*_RD*D&*
zI)$B|cJy6r(4$bEr@Zr5`Mm2|a-#LcvYoEmwbd_LYDVsij=8Wi@Nwqh=BOK?wa!UX
zznZSRwvO+A%HBy8k=uRkI%e#9s=257*xV9>McEZAra7+8)zr^AFpE8Zo1Aj<B&(uj
z6aH+7wea!ZGa<rdbwz)wUW2i=Qh#cc_S<({*Gg4C9OYUqt&_T<y8q$B4x#IFCElB|
zsZQsu-u3ZJ;qxu4cL$k&X0qN}ZWmHG?~l%2Ly_d-sW*e;Ju+;L>#EI9dQ!{yE%B8T
zsA5j#=iXy6f#0L_T#Sw1-$g&KEwhPw7k6=P9p9$gl1p?~`yV@GtX+H1PRSwd-%sf{
z-`rINO4(DzE}e|pzUFXJJ6rzDIrAz+UMDU5bn48!jFUalCe?S`Jly^{l$kUyzpAA;
zxuWIEt21Z5eK@yGKK%5pb(4-~c*$*3jdY1xa=%a_->pAjme<b~ueuM3UmsufX31A&
zd)zIfoKb2KUB|b2YN%g~;r@x6Duh1%`KtHm#-xUi7N6%%zMUs;dfe%E4WHtj>qZOA
z@2VXVILCNjt-0Yz+|D*#sa^Z_o+-L}&p|Wl<h{SWw@PpCemTGN=yrci$=v=GpBk3j
zUO4mI%&m*E^6h*(s@3|feC%apbVFoC3$vFlsQmOWFG6Rv&}Yr|<I5yd#p0G7-qLiT
zrt?NdbiSYdujeP{dCT`^*~~9aiA)a(+SSESczvqW_oG`b>(4nH{d-f_0>3lqy%!g3
zI_*_*L@9exbEUn}gBGrDD}K&>H{s2ym`wuPEX(JuI&$0R{-ixpI}9(si2Hfz-{jq^
zjV+(?-4!eJRf=a#tJ;^dN{eT@%m18*b#-&P=6QJg)*LLm@VrPP<?9vYYtuXqbN8mo
z7~51$G2YSVAd$ke|Lg2`LgF@p)2HnA{IKC(jc)(OGh4nzUU(`nd)I@*s<R(Y+vv2+
zJ-p|AAWOg^FDtH^qf$E0<5D$^3%=P4XI$NB=f6qWOX;%jPPWfN)%yaLo>O_TC3udb
ziHP)qny+EU)LE8w?TVagAN#51o{TlytfxQX8by!ZIq*B<xZUi{HXlPemHoXU=1)I6
zmo;zAwm0$>&pT~06DuB97OeYF=ss`JN~PVMY}cKCPL2DzSVEk~u=}%<d|6Ch+~EUt
zchdAbZL+MS|3B3Vwy{i|`_b$~o$hxR`_h-E9SgWyr_4NGE$)7LQ$_mnsh7InefV){
z?aUv(UW?TNe*NCKSiCqYtACfo!=o>Qj_J2PNT}_eVf@Krv0d3RZIhbGU!UJx{w41A
zoMNRP)2H87?)|#&yRfDIs{JfnQ?+t?I?^uxN!PnLd$OC*)$YZw-o1Vtd+w0-jR(x%
znsh^Uyy84*w&mk~?!x!|$6wFX>9W!7RV?>sJ$v=N%Ur*J1=gP@{S}|~cm7N@#Xl?9
z?`}U8w(h>D)bhgB>)n@@YqFVKyLr#DP4GpmVAPUKjr~5h4+K{(y6+hF*Kp754`*&X
zKDGCBdFq!<Rp+mTytB^<d1rm)qpbkbxhuD`-7DT4{~LeLoLA)K&m)ho&s{n(M9@Ef
zs|)M(L$7aI=$$&r6<g;0$m_?Pu*+$US9`a}nVV0yUSY6H(`(zOO%`(B{mVYqE_Siv
zJf3Yby<bnB^OCNHj92jl@8>IGpKSOX(ffLCQpCkmADxdj`9xit%6R$kd(lberzF_R
ziyQl_`kG?8V?IWvd|Tmu^?=;U)ra@(zP|ab<97cwd#c)w-P2rhMlDRF{igAWUsg`r
znkKo*n}sJSb4pJxsePAp??URk^>;a!OgG~x->%dZdfNK^29x{ew^r}IpXd8<14DB7
zTt8cvw`)9(x^J4jar)OKx+<S5_Fdj_$JptQ^NI=g1Nn@q9yk2VO6vWRog%N)Xt!`@
z;DYauUZ1iuw@jKh^KZg6-Ki%&>MTEdxP*Dicg+Cl_f9T~pQp;Q2;T^J<S_MQUESx4
zn`f`gN%q(}cU^0l+wZ<Fa*o@gT9qgNDi&f1K7H7A)~xrLi#|@i@O*0DjT09qw7)zN
zKI`JiTXD~`yQ1x;US-%P*QmYee9<9~-okSS$`>wRc_-VjUaR^lgMH*p=6S6;wduvK
z<|^NAKkmQJy7*6joQ&eh+0404T;Y?tdDhxrt-V}hZ}{)hr2Wo|9OE=~X8t@K^L_2X
z-4}nI$$a+I$?wkt|BX%jyRS-CJresiQ~r6Ik<PvoKh@;<q+i5-4KH8u+2mWXrgQqX
ztgtgCb3+O~zf{q@ufQSsD&R&~>hltd+mG*S)x9ke%+qLcviaKk+wZMhczE*^*`_+(
z8l$cm_v-EyoQ$){GSQ3CeScIT^gvdVkbA$T`PBmD$QdiA<|Gwr<Sc$N?KgY(lDu!n
zYfSI^bw8M8DAOb>Cbub_`B2bK-<SDvCnH7o>{VG*^+F+Bc=q**Hw_V5pF<N`7Zlsc
z?$f=xU`1=_X-S93pjq-OKi#?K<-r-N{z&b5`4Z#apqqAH7xrlJTFvv`qxWiw$l1Ba
zk4W0DUgZ$8_y6Yf%2U%`))={cvz<82<kJ?vyT-MZ%|Cqh&sdjqrXu+G#54o(?DT2o
zQT017-+g*ppyXcH^95VJw!PRUXP(d<eq{!`fB4E3f_5^!(i%DvmH&T6wfui9@3TE_
zGl!t<`yEo}<1Zc9{_n!A8%8m^*Z8sqst0lZR5V*QudQrHgBItTEx+w%JuEl)bZ_z$
zv-@+y|DKbG%~jR9?D@Cg&z0|br3D6$Zq}SV`I6oIdF|7mUCuKXAGUTlBGEeY*3{P<
z`!}6R6<+L}x+ut8s;MYUC?u-GS8&?a?8wAzlVUiZOYq)bc{So)u-&%I?R$^^j7@u6
zU@SHFHt$&@%eB`_9yx9HQw>S}ZgYPscN%+z$ZmuEv&A}YaOu`OJehfB!{fJ_vWZ_-
z-A(U*<dCkHknq>_mbHUMda(*q$i7;(=8~|URY#6%=JW(|iMjOHyLm}JPF~8~({Yby
z&bz?R3+x30cbI<vA!7gFUYqQ!e$S`NT*WRP_<H<Va?bL+r62aRe6Ls)zII9Q7m-yH
zFF1dm7L|AFu8f9X(Eh4L=Pq_!(@i{eh|A&et246$kA+S*IqmU_*K=E0+nS|%b9e20
zq@O<j?X?*}Y^}HVdBsaDD4kGweZi*l3zwhy)gx^pvDK3+GGFgh`6Hd9`N}nWxYx~i
za`w}7zf_$QY3}v*-j|=>vQjs=y72R!U%V6ZBB#z>f5!HY;n(MLs~g?EXo)UqxyT=0
zog@8<VJ6>EwHYgyPZAeBXm#B+;Owz&8=fjVzEk7PdZgU)Ri%28?9U$#Z#dpZZrRhB
zyOR64?o(a;x%|1zS+VW8GV3{2=biae^WgIjm*g|g9ja&ieSE}(xjpZT|EIYx)*jrF
zE^=|b#P3B`UI~+?Wd5%Dd(T)|sjbJkG;B+S_|EJk#?)s*ONtx5%(Xe67Z_P*(i!Q_
zrk*IeIQhpc<0-q2%!*<D9C?}d*AwsX(5Gu(zn=9<{;{T*vFs{di)kMnPKsx}y*WLN
z|Gmp(&9oaYC%x4#n<@6{*@aV+9Xz#`_bZ*AuP5yj_xi&7pe;TIZa*$<nbH?EugKj^
zBvX<7Q^xN*z5>?CIeFKsuYWPk{qW1U=lG9ZzAHaxm2*^xYL?x;pH}rY=7_nc;_;%n
z_ZlAwyk$9F{ciDm;m5OYi!)uz46Do7!eub;e$v%5i?&a<X$fe|diy4?^v9ny=W1h*
zAK!U3#6@wVhHs5awB60K6}qn%?^1hc^78?!ebqvZ4O|*BtEVk|=ae(uX2!LSm02@W
zY_D`JmoX7%Fv)ju&27>2y0-1E_{OG&)@uDk@An_Y|7`ep(7soqE7F?p!;am>f4<%R
z+P+IPx%#0*@G6(ib-$M_k)OqP@2uvHQ0Y$oihUf{Q{K+@TV@(yVfS%|*qyA)XCEr<
z*4z~E-SBqUhXq9yN-rGupHesa%agUxPA%>9my2b3c{YdbE;%P!O%&f|EEp(r>8Bj`
z(g>kTn(}RSKjhX<^JBmAM0&AGMz@{emf|hz7Q{RK+2!N^a++RF<h$Z4Ubm+>+8lS(
zDdkrwmRuJQu;Bg0icasPje0Lm&Rh2}<l2|F+RRbL)32y$f98GoxKHO6n}2HYi^cbg
z&dZ&hI^BQqve0`MX13q+Y&>?1=T!Q&_t&jIy){2{YOUpN1?APh<860@@*Y>1eKYLv
zU0>$>#NaLA&fVcP%{!HqLvK&=nek$tXLxx))Z7${=lhTRk6d^|CVWcW;oqJH{&}Bz
z+JkTOyofs7o+_G?k-6xX+p7f$+aJH~Uln(5?kU%ub590xOYW^Xqi&L7s8;(@`t&8w
zrAeNCY~3&BJW8D{7<wpa;p46Q78U;x65kbO*H^UqjrBokUY<pzx4n;kY@9RcL&@f1
z(OtXWU)#)NU8AR#zOZ`L&K3cyWBfaptKM2)9_Sr-!T5@`@3pOh-!>KZe)61uZ$pjy
zTA9++-Wk%@9(B9-UR$$i`|{SAYa>O(H=RB6Tw8skkJYu;&)a@%`D-v`tGD&0GjCfG
zH*RC`n(+ImP<_AK(}ujPn@qE(9(h{a+BKtR_qm^6YNbzXWwc&zS~REW?)5#zSL*gA
zr?{2boY?W-*P-ETV0y8=*q?7X@{%Qo-2X<b4T{)Mm$NIN;?b&t@WOK`Q_~$HHy6x)
zq&@ff_Q+msXItyG%tY7lHz~8+S=U=8e0qA4`FNAv?X&Oh{9-wGren(9@7Ih)EZlzC
zzEDqlc)8+gWXQAcC-$5@+;l71p)&A<dm@MZ@hS7-*EN`h3PcB(34b>|w)f@Ui8U>Z
zR?B|=b9t?ET<($g^2?&a+-GGngsqPD&%I>2EN%Y3+}y+04qdzP`NoRA^aT(2KX02q
zN$C2t&-wLze)sCqPX7J()VlHe*3*Gzj;^(lRa?@<V)AmbWQ`Of(yzXHu(jc}v(@zP
z8zya9ns%h5MUS&r!gkY~E}h*hYqR{C=N<W$-FrK<>ded8F*=t6nToY7&DOR0EP7ia
zoaldK@42)8*)MYc^u{)4X@X_W(#Y7*40frSk%FO_u`zrK6M53o(A?YrGHXeA(z53}
zYryR6>ug-gx*}c93o8oBw?BIK&Tj+L!Mh6`3d{B1fx*#O{_6dg{?`4sFFu!|c5>^V
zsP9qVCr=PKp?T?pbR$oLl7e=%6kAl4U&DeelZ2RU8|KaHoHlQs;ItN(lV|QR{gAiR
z>Eya_?Ho_a(VzU>j?oMD{oU>3asS`l0I3w#2?ZM%3=9}0A}l3uSiF46*z@I!%zs0c
zn?+15Uu4hrFkITgz&Szm0^c+jft0sN*=b2x|K~lok7s<+Cc?nR$7l9x|6RsE(;T9W
zoolrlw(Q%hdEt}o;)VNI9RyP{*tV4aoG<X?&a!XcuFWYa@$>WB@@rbz7KP}^`65>s
z)Qziy8<;NeWxVDvVfy1LsjxVo^N+b{RD@8&q?I%8?icA&NUm0|jaGONn~<2sv1L<r
zdEo{lrdv$+HZzMHUCOZOn#1aPN$<a>8>BwGf5sq@A^A`G-Tiy@tVWxE-HyC}K_De_
zZT{1wv{WVov&{@lDXvR0-p+lylJQrVTfO9~=o^jq{(hDHdRFHP?>*jsda?2fhxGX`
z)Pt^BD{I@9cI{i)ma;Ul`obl@LD#IcuI*uQoHortyW0B3{#U|An^~pyeZSlK?tc64
zyIfCFo_>>0$w^C1`6JG&%${wPs%<RIzF^0N{kivCH`J%7IaD)n+uGV%3oA2ZFf&+5
z&${$?s>8{nQa`p&dZ_==nw{S~dxGhKA9L9*96lrQ;~(SewB_$PSZ>_5Vz9mQZ{?48
zmeU6q42+DouuCxbo>`Od-=$uhx%YqT{qy&)osnGN`QNUNhvC=$xc`5b{k2PUQ_$v~
zZvU)a-f-@e9TPeh@m$@n`9EA!fuV?P$3+9?42hXD7<7Dc7{d6%8jk;Wn|Rs$ce&{Q
z4<g%**cdJTg}$kt{x5jL<NfLlf9}6_Wc+bI!f3(wovchJ{`c$@v*q6V@VE5g|IZWu
z-+uc4e$Ri=r~gaO{Lgn);u90Ae|_?Q>WBY}uWvWmT<~-I(cgEhZtQ>GVDh3?c+J1{
zE44nvcWd*S7!_~$vp=e^`tSGH2iuJ{{>WE8`^M$WoJO~zv~O+8>dznBf8<pC+nKF1
zMFaR!(!X6l%d{YI!Set1yS_g)`tz@@`o`Y=C-=1;{C@W*-z`zwdBVkb?_(zpab4KH
z^=f(J()#%-Zen5$(uaSWNioj-FPFq1yH@nXzq_m-&YfdU;Mvsr_q9i4Btyxc`p$o?
zHyBEq>IK*v{C@23=#_I&|HN*{@WSQ4f*Zr!8}dh376|`uzGv+5&vDKB;$Q50pHKeR
ze1oyX2y}zm&HqZ@zP~A|zff)0YX8D^{v-J#JPU$<HQ!5K^;f)bkNd?R&G$CH{_psH
z8XHLY;r~k0%I7Mcc=UI|Kjp-<f8I%%Kac-ke|fR-FZP=E0w4Ta%J2Q3HOHRqy-Lr2
zi9M4I%!>cCACJ$P(EQe3=AN(5KgRps27iMuRL}N}UE|vr2D(da=3nN0pa1^j|KWG)
zk^G0b8=uPmsB6CPm-FbScUfQUCj7s!|1$I6lmFiF{F47#{q<V?mG=kN+@Eg}Cg$+i
zUN#}^$M!4V>ZK0<xu^B|`)bB7%V(Z>e`c+&%$tAO302SY9y4rWmy-O`%yfA77x}+Q
z70dr0Z+)uIQu4>WKH}clxA*dI{!gn^&rDyKpZ=>~;QiJ=E8qP6w`jBZR@Q%yC*142
zY2Enm;Rm_H56_G2eg5ZnV^%uHroZXs_oCnb;Qw*YcDen8kG3m5+drrdn{MyAZ}%>y
z-2YQQ)vsf6X21PC?$-a>=>7MF{~xTkuW58hU!eHrk<5t+r|<7Mwg2h9Ci&Z)Y2`iX
zvr@uMCpI0+y}0e_LqSHXzC|`y%kO@hW}ml#J2N$U#-Fx)&i_Z>?%2p?wL#Nu-_MhO
zBh9@Mi?&OaB{J>Jw|PEe|1NQHwsyD9{PTa09*aHt+&V?MVmFKDvR-EErWmtVdxQH|
z6qn{-{N!=q&bmKwmaCsUf4)d_mci2i-T8kcC+ReAxw*b2;G4;g`5J-e<_f0g<t-01
zI(Gkq>Y^11wtk0Z6x}s3lQ=A&78~w8MdGcML8qbVzDG{?7WDW`+Qlhz#5>{4ZqX;L
z>pq`ZemVF;)7t(ok9PBK7yk3?$`m2@gA2BAh<zd;tN1Nr-LlVtuiKhE?}lF4yll-T
zJGUACy;9#iQBj(udwat5#hc9qIEuwnyi--)N-*j^eza}-&L0om{{C?L^rQUhj%BYW
zEc+<N^XA(0sa1`k3#U6s^P6O9%z175jqkh6=P6E)yte0k{wVx9^SN#M(QEsX9tN|s
zM7)@@L&Zhq%A6-wW|I!CnC%skraPmkFOAtiVyz$7S;sS~f=^SUW_Rxme|A4oS*r8R
zB>#1OeimEx#5O*ze5Avs@%6{Ew!r<S`=&T3sIUef-;ny`46m4HSkXP<kDfZxQ$PBe
zb<b(&_hNr{zx0(@s;#7=@XUZvTe;6y<ZG<?{uwNuD7NDL)qwd6x`cI#o5ggFE%MvG
z<?PzPtJ8}oOcuQ%&D__gYcp%LrH$JxNwt4FyMHEpdnaaB!mcIvarMft<&S?UNS?hE
zB2?1&{NTdVMHBVngj-ck9?E(<fAPdSU6+gY@yh0R2&(S1F?WrgrEGE6u=|#%%e+oy
zsmpVvxb>XRF+W`x+Bo&E-Kr%{vjQ)-CulCw*t*+yb4-hj#aa6&HgYz%7G1l&Tm5VP
zvoo2c@y8AsO>aB;Av=8Sw?id;?|#owVq3oS^>WR*y3%PEzh5~mbir-k+%*R--+H%b
znoE@Q?u*=|J2rn3eV;C~tT0pl;?(UkclG;Uxc6N9Lw$twnhA3nxA<(`aWzsgH1^{$
zj>xy=hgYAstKTT{@?ey$_A%epo*BpEX8B5`bcsy-BI3?}BK5Izc+%teiFK2vI&&<0
z$`#+sBPzYfh&y1l&+|_!y7u|I-!^_98opa_Ub)7x{GUfJ-Ot%8qp5Ij()O96Yd9S0
z_0FVho|ey>yv&?M+<Vr{RJ-yEHjU*$`EUFD{qFlF=Um(}e}<GySNt#0sL7|YtLBQ_
zNtm$fr`OI7ZpSyg*;l5o7Wd(q@SE|w@>BKY{6Y)!pSdc!RxI58=}Bb#!@?DYY*(BO
zR|Vwu{k6T+6X+CPr{?eJrFHs6Xt%g%S?sx$meJ}bH%i`*X8I-eiou9g?MKRm4MMUv
zT6_hjeLB^0BJpW#in8;Xy&rbG5BZyACjTd8n>ibE+V}NZg0iglDrRljvE}qS8|jkz
zjJY9A%L6#P*o2qwu07VLleTNmnI5)fW&0lKuH`bjo?3f-u_xOc=dSr*w@7<F54Tf1
zbZ+0P6klf7a(5j^rM5VmuxGhF(Q7vc6t`utPxRv{NId^tnce3eo8+TgjVlk%)#DAF
z^HACP!?EJXR&94h!`<%UmHw>9)YMhpUW@d<lP3OSQ^k{%yjH=@p@%vAj;`;j?m8f1
zRJL$?_e0M&YqO4h+}LN!zsGuFP=4c0rVAwz!B_G_=JMCg<y<aRDH$-oU;O@wM@rtz
z0tZs>s<{f)m%Ywkwu0}6&E5Xujcb-YI}!QmJWoLCsx$mM*YW-B@-uWf&i`lC@g<8}
z7-lOz=kV?d4cvIQGDK);?eYZ^f>dT`|8QJB=V@#6i&_7_tBL0CKVbOrpO^hn!T1u<
zbi18eH|0!I6mG0`Sf3#%qt=`Ir6VZJ;f~I(T{FM4yVNtjdY?Ig_4g8wxa6aUS~U5@
z&vw6(?r*J1zdu2}^vj0>StlNQEkC(HXR=(Oz4s(VuRPzwlWR{q_=(<|FnQs#DRu?i
zVJSkXAr23cub#T`V5#N&tB&E^%Ae!xc6=0aT)x%N_szeG<$ZGtf2KTK9Ut<*WRphl
zvK-r4>%*g}_D<C~8_2nJakpBcQR)Mi4O1D+FC|@nY`nxolsio83S;I2>k})poEN-J
zy*B;n6`94~%O(W>V6>W&v)w!Ya0vS<Za+^=r#&~k-l$(lTCOL(v()65(VunJ!ThOT
z%kplkU;JHGC+ZN^kS@EW&*9wXg%NWX7QWy1BYj!X?-WnQyPa<yyQ@YB*<KQsF|Yr$
ze$w7KTbk6<7EhA7`Sx7WUXvAl(TC0(pE<Wnr^0c!;LL8{^9N7bUb+7Ar(3j`P72#$
zw$)}=J|=D7!f<m&7xTA!z7mp>tF3$GE}rhcV8*w&;_Kh3#g{e;<X)ev=HG7YRx&|g
z%Y_B^=S{I)`%z=IZ*GV4TL+WZzaK_Lv|ZNX7g)4i<pyWvpPAD3*IMR&F<U36&mgI{
zx9kS9@JZRHMxv}dOC8d)H0S@x>|A))&{-<xZDr$qn@J8&4^O>cE;etm-6fH)YlMyW
zxGrDakXYW+v_6xuuj#2`k;C=eiTqQu6Wgnl>Y{}%Y+{i;x_(`4<lnpdTQW6o)PG!l
z>vf=NPh+20f0F&wsfVh6?_Biqt>BLRRa0LDPwSO>t6ksshr!n|TfZ+kOW5?kRExVO
z|IEzdS9e2R#{SE_AOFmIzmboAu>3!VBW%)1{pRg!YUip=uD)T}t!w)vbaCnZL$5D0
zS%0aTlcm(xJ0T=L+k40DQ~7(fw#;BuULKM2y|TU{u+uzz*RLzghMUZIlm5@|PVnTu
zlx+DX(Ng-MV6Bvgvg5-Cmh*Sqymt50(lys7?0z4j;SmsM#=nn$t-;Tq^Hnq(i{`Pe
zwVAR1YWAL+d?7nbZzq*#W$!8E5KldGwqshZm5X7qPVMar%!#+Q^j`Y;ET>9N$s+%#
zyT-o)f753N=IcLv8?bvpsf0j*nV6|S-Llf4r&YfuvMhSnaPWlagkS$+H(leMb@<2R
z&XdNbJB}`_Hq7MS_WepY%S*=EQ}M<}w%ZrpmhB9CwQueQ&G`~?RlQ}`9mSg`UUgo;
z8fAJy!B3^vutn|t^Oftqitcw3*V(sn%>hxhQx*<^g?n@rjW#Q`@90pP<X^UT-TK4g
zKMs_avItMx#h0ttkg~fZ`K~vQX<T6pYtgqqKVF&c`S~&Yww&3IFZGObAD3_Btx*2H
zU$C#Xleu2HCG7o=!m?Rb?H@k}Xr6ajaO@HDt0al`Pu(Xbx>)Kfb}idlcK!L%e&=h+
z%NBCaotZ3qkyV`Wl)#&Nk2f2xi~OCP8^pNh>b-seLy7ZqDkdq$q?-3fuF6+Y&f56T
zT)sn`$<mOA&2r85Y?qRrNvy{{JW~-laWK*}bBad2vG9^M-(4%3UrzMAzHfqao!;M&
zf7KpRTO<1BuQ+dUD!TK6g!+^Z%=#bn9){}9H;G!f)_uqSADhb<7f<;f=)f=Wntca%
zTrgMJrHT3_Ousyi)ouT1$RgqU#c}KNZysMS-Px-+A?wS7b!&NEA6auG{*~>#nvk8>
zCC`+f-F745dwj?38QP5xL`|<Y{B>Fxn{|Anjw<_4<^bjAuT;;svgfTWI9tH@bK9c}
zA2e)peX1)h4oe+PU#$K`z<$wc#ljVV>(cTqb9ts*J9w+xt%UW%x9dBeH}6m@^mr9<
zi1FT(EfVu@=Q20;eB9Xhyt3^3)YOX~ziho~th-Ll&>~{>K3@&zV++0(rPpjV)Y#&~
z#uRt1SAX`2-jBOIUVL+@xGVi)k4o?4@<O$L2fN-n_+Ed)^FZSUKmUOXyEI)7Exy1h
zv&8c3<9`2tw(6Vyt?4sg$7eaQhON#(aj!wzIn%b<)m7V0Yb@C&``h9J$0K$301d$z
zg5JHm?oY7)dB9jhPE)FO58LlutNm(zIrl3qU;QO*)AQFh&yOd3x%|x{<?Z?JTpG88
zl^&&f-Jg3t_>3>lrK3qbb{8iVA1ce6E4uvAg*HD2l?hKGZf_Bft#|&e^>bPAi&s8-
zpDYu$&03K=d(%-at=0T1a`&8+iqPID-W?bvSR*-~{m988-y1nUGd9}`EZ%8yg`1^u
zNzTK)cPo0VUwL($WKjCPS8j@VoeKXHMGlRA*ZyyAWj9}FHa##}*H(J=<WK*7I*aBl
zj^mEyed%yOFqz|BPoN<mSH*{I+ZyL;NB(Ab{%*%Ut$N?UOXknkhiuRnsMO(mZ6j3S
zHNAhSVUlC~ft%b{%wJzzD;1!A?Cw16%o>5{ck=d2Z}0c5JYhTk$gS@+C(lhUSl5?4
zUw%f|fyjGHj$SB|zEm7hd-;!0OK<$_df%cOC$30}eEieA);s&!wNvH}ZcO{Xy)aGr
zWAsurc*&P)&#TX0^-s^;^z1F?+KANG-qj(d7gjl}xyiZP>1E{97J;rszmNP_eUA5q
zQYUxm)b58O-)2qbYda^dp{&HI$yO2<@^ThqT*#q&BF%pUfBLb^*}Tmy`S7pKmpr#;
zUHf$Yj+)rK#B|O;omWpMJ+`sy+AV(TxZ8#rN6UM=F6eAdDwE#lZ>}BxtM7&0_E}DD
z`&K_#WA$d{n~J0RQd-Z<RjQm|7=6U|$h%LrQ?|c8)wSMyQ{u9o%R60P)fAL2G~6Wn
z_Z3fm&)ln4P5(O%scp2gEH8X-Z-2KieDRF19lp~VTi?EFyIGMFFxxu!N9?%=lhfz(
z-(b?I4NDFGUVCqa_P1?6N;Dho_e_d+?r;+PXi};-FaIEC?6XFOh;t{W@vkgU5~)rv
z4f?;?q-XM{*jJpzhYkhtm%eI?j9aklUX`+Hfn)SstuxP}thCxU*`3|Yx%+VG($4C$
zN8Ky^3!3y59RG$hl(kJLyZm9-Qs<}x60aw>zfoLfuy&H;TDDI)i_?uZ=>>1_Dm$y0
zrWV3$w)v1^B8y&?-&L2l7k{cTG1Vw)I4CK`Y@NL2ulM5JtJr=v|G(HWL*$IY{kR7b
zvnS?!U%yweUi#_;hQBMk&wQF1)KlVT%_EfIZsX;Y`A$${kIVGKKXr@wBn#K}ch>48
zF5A4i!z9Y^Ais4`1)Fia)ymVpDQi#M*w16fFEVwSU_t`td6o%<5BL2`aA0T2V_(8o
zIWaNrW%d_Foo|I)%e?b$%5iKy#<OSYvLBB)pKeT^yXN?r;C)BV%vxo5C$xCtT@jy}
zH5X5Ac6=hIZom6e)teN-w?E$Sr?_A0y&`}4XHV~X?&K*Bsex-;UbLkji(2?PW3|%m
zo_Vq#IBhOTXw}&t-hSdr{@oV6lRGU}JEeUpzrV#u`Tf$)2b#0?_!~-1G+ooa%VNut
zW$&Hy1xjy!k*$9;v*`|p-IhD$#_y~{RX^OFF~{RaZ}MJ+--b6AWbE9R(mk;wTGiZ3
zw`%G6#T6>dOy0X^8qF*S-6Q`pS$K`%{kr{LbFUv+bv5LW{#sj(qpwaoysf+Z-Em`X
z;=KNuPY>4^WNCZ7=($_2lkT{>%_7Sym9g%npi$U@Rpw778aG#L){YD7PC8!eJ8$NO
zEj%Cn;+_fV=}xzLb<t0>SU<Gq<*F4tYuE+u@@#S5{(Sy@{>Rszynh#7V)9*4Eb@)=
zosdL(m0V`FcU*dZMI!|-$TxjI*J!zX?pqe02lwW)T$$=KLCD@g*D<tefp)6qOZ7h1
zpKPfj{mv5go-++kp2(h8X&Zj}^3qNHsV9<_JecoX5Usz%{<hhd+3QdAXz3M9T|7lz
z&nI9`_zlxVNA7Q*@UwTLKw?9dokT<j+rulb7TliA|5LQR?yq+6y1d<~=KLym5AK@&
z=V<BH=8s>)%-*ohwCFk0{^ptPJ;xB~&x^WMxNa=`@c79~tyN!k>C{d6=Xr<o_M5fO
zoWg=Oc1Ae%S$f~@e|I-$Tc}3(B7T)Qjnjp;tuMWk{p6_HBCA+i)2s8Io-1k(u(~%X
zI@@@L#9ZlD{jcm>+LAfmODA<+tmu7x^MlZ|N!M*BNH4zHR_?&=_}l0F%9Q93FZ+gf
zIp*^u&wZCs%Dq?|;B44nVZwf6;^rd}o8S5`OV}V|^zFoq9T)8_YG%ux;raf?tz2c#
z+yq|JJFl%S+6i&<W%xas$$Fmo{9ikN!F!Fip}AYW7A6|*{OrE7D`%DQ{Z&r-8jm`7
zRlRbaEte0f*tc-vl4sHx+mug#DvSS8RC_X@fGZ~djksRw&!gTm*6n)z?yPCF+PNwz
zHo?_wj>}R-Y7~AJ<UT(r(e+a8y#K=%)xs41wc7;$9ql=(7{b`f>7;qIP4(0P+4G-&
z7|!}V;p56?-pdX5AGiCv35Bhja;rz@^*>=*A;}gw^?yIkxN5ujR{Mr9#tHwJ&RsS+
zps?VPbl|HU+XXXi#rZET-V@TJ7{_(^#nk@n@Q)|+b7oJP&v}EjE$XoD0rt%B2MP}6
z6^~zR-OT6Mw_(!Pe_eYPf04T5x<hyRC99VTi5+KmZjPwP+p3^kyFg`6U;2Nyz2>4k
zj83=NwlB?CoIInO)AsoGKT=LMZHM>Vk6L<QqtHhy3s>tWj*Nv%e_gmKdE9%7>jTGJ
zF}oh8&*kpiN#BDu?-s6-e*HNtqB4DhXY_?_Hx}0flulaw`e>ck`umm!86TT0oz^d?
zXNkxtn116(^cttIb?<BbvGT9$E-Dt0U1ra{=cchsRd~P$tKaF7Z+QQTEX+097JF*O
zqJ*1rEdJN0oEEq<`PrGvJ$&YjzH-cktlc4RW|<gmvN*dv{L9UVkHH3Q4$6x{L^%6`
zFR6UwI3e#cwc%sj<PTr1oKK}OrWCAdx}>kIv?|Pv@siwQu2+1XY(*2k?pxY-@^{;w
zU22!^N18a;E(qNsJEy59Yrp2>GYlU7JzwuHioKsUPduyNy?KT41S4;u?Y{f?vz$3L
zFTVEKNi9w1#Y^^+7hXm>KUIF$pDSx*G|N%U<`)0q370d!eaPKi%=v6>bLQ*YoAS=D
zx_jXFYO?_6EgWqu&5b7)-Tybm{^!bd;TzVgFVqg$*O)%bKDoHC;}oC!0aK4^%X|HI
z{cc{?Q>_iZRKIP0(gnHM>bjjX7raknnB*gPfAg%6Z|tTC)@Nruh%<66Ki9U?U31IL
z2cMMYi%+%{Q+n5^ZFjEm$n%gbRSTwXJ^O5m51Z2=lhW&^S*8AGm<vwT?LD^X$rSMk
zCpTCtda+M*2<9xdYCFWnFZj#Z%tw5#XjSg97tbvh7x%6{-1<5+`q16bzORgj_0FH;
z;^ci}b|z<E;P-^g2;PTf;!6zPmbNmfyPYW3_WdR1;9nUZ#b9$pos0i#zU0>R+N%BX
zr;Sf2Y*(@1J=;CwQ%$dAV(Ox7%b6^!$~#jgw#jhr+<Sq2)z3=Hid*SSUl%Xm&$nZt
zt(_OYIs5gyld3%4Mp`a;T3LHGHSS!%MVXrm7M;EJH?bhZA*ViC=463O^m9Xt>-Kju
zEq=zl+ZKH0?A%8cMcXfJ=(BrdRW5tt?~h86H%fI0kFIM;9PiM*a_f4O{Gkx$_}{yh
zEObelez<edPMxX34coH*Twk|y<;?v3VcTCSUY?l0=fl$?mPM~aH49By*nbB#rC#nA
zsoj&<_i{D=-t@1^2D568KeL*(piK0ycI2@~?=oy|)cvZP_0l<h$xEMwM=}J&b-D|Z
zB{Fy(@cYGFf3fynqu${yQ+t)f|9+7?ttHr6DlNZORcZF&oY|>&86sb}K3m5n-+#t)
z6}OyR&2*`yr{);E6Y#mZ@s?}VnFBWrml{52Y@bqP=D@Q{=Kz1^rgg3%m#_ag{(heR
z62sOa*>k+6OCD*&Po8|QuUP3!#R<W7VI%$+%UV-ghLcC!`|m%q^U1oN^0qtLV%p9V
zvHEt>t$x{$9Dm(XHs9%I^|ruwR+Hqjq9fDgR~^*cG=IU4rLKx+maUxbVNm}+>3W5q
zTaNeCr1^h@b{uzm=)W<~Q%Y&6m6AR4e%+&D&Vf<6MXzJu3mepnno5Pbdq`io_$iHt
z!%4`ma^amO*EI(w$nE<2H07}7e#7INd^}rPw3Sw<p8kEI@7R?WJ=dDguFd4OxU2cE
z;Fq!R=Nno@q3S2sWlk`5R(HI$cDA#{vh8xYLhMN`wMC%`x93%RPJOW>>S~^3o93;>
z+$Yn|2Uo|m{ZG9#Q-S~8_QE%oCtrsI`TwtN4Zg0#x97X(g~IOzreB?Q|G86^(VJE7
z=^^-|;MnmKNs1<Wj97SbejBhH+nm?&Y9fbl_7wgl_k{xH_=iMZu<-EV%FtDrd1OIO
zpq<;4GS!cZl1wY@e$QhvIkjTxtH$Wd>TLSnix|yIe~LVRVXWu*>QsCCW{m=7=5365
z)f03lakRadr}`zGDaoQ$>ELVCR4=)m7oS~dyP3(mKWRm6o$>XMbu5Yj(+^kp8r4QU
z+|$Eyc>0=4)&~R%dX;qF%zP;^A-I2Y!k?S`^IwUt`mpTLiHo(zt+qV7obcV(;m(mg
zAFn?SIc2`);wQGMf44Z}mEO2azwAF#fAZ_nkC!GcY22$P$oa<Vp<SvR%TNA4=PeB$
zWQ0gmSky#MuWq<*?J)Vqb0O||u6}Ld>#P#z>%RQ@?z(T~V)s-#^Vv`4eT<aT(3oak
ztL+f0I(1LAOzV^{m+r3rkj`g+iIYp;IxE<&@LYTKu^nOc(dtiGc!edHJ~CEq&WpRU
zbYXz$iH5ABD`HPKe7Y0Xy{Z3SXs4OQR|&KIx^9aC`qsD=znOEk)NxDj1<#q%2S0o;
zE(mzK>ZQgilaE`(v@A^vpE9ZaOMBgWxqONy#|4oKMJ(ct$8rRYfBw7u-IDvKH^z(F
z)^mJOJNstq)V;e>+1*>`?+;UGc;;Rl+O%m3i><|ms+QB*ypOgUNZK#g_W$S-%Wz7i
zZH~qTiz8F+i%8zFSAG3x$rayS@4uYoYukBmW?0PR>GIBtSTFN#O<F$ti)#)4+~m}#
zzw^F_-aM=F@q=DkzCb^hpp6N?|C<~W_Ni_<E9-d-`t>CCo|C%$%2I>lxbO3%Sn>T!
zUim5b>}Ws0m$W9gk?&WRem_s(pVTe<7hf@*e3ZFSLb1wu*8BEX?avj$yg0JIpY@wN
zIcw+n&6@iqn;2hTe&ct`J73}3()s;H`S1Ui@Eh=!8yn6j<y2R4<GEKfxi8V>@i~@b
zdFiV+tjK1Ly~}!F!LfZy(~7s%vMbj)%HEyr#(HPr+!cHi@5*?syLBKiPQRcpxA3pk
z#A$b~?#qmuv3kdUU!RMuUs^w}eVKdK`NnR6oV3jfr(PO2A6jlQMQC<0-yh%KW;TUa
zqH{m3?CJcdv|f07<o8+Y@1&pdzT9Jb>tgY(B?o)czN|H2HfP+!qLV4|&gt6G;I~pP
z7g%;n6nWlJt5AF!Go#b|TIj@?4i285%-^h;Y4UlZXvor&eRm%nY_W^X`@iyCmFXMD
zoxkpXmRlG*KP|2PKHFrzyN7Z!7Ie0*3FVseB5m%pu#H@=)Vt5@+jr(nu=e-AYKA`?
zTLZi}e+iy_9>-;LPeDBQt&I47A^TKE?~7FthmLQ~@_u=KT1(Z%nM-r0x@es`{&C^<
zti#^~kEeapEk3t+O>g&o*0{MGNz1;h^)FU<GC}iC#IB2*k5|q0C{CJNE>?B6KDl{m
z;0-Oq_B_?6+54@hOj2t2anwV-tnjK&aQ^P!pB}h)8?CB7SkzLkH}8h<E0YrD`%~WZ
zADCuuyx@J-+5Dqb9ZCI_nfvXX-sgF5_>!4>q%){cKrJ^b%<XCUhq7n|_b>m_<l@2<
zjlZhv-d$N&|F-gyMp90t%aUdRepY?SN&eaMfB8hrdv|r;z4r{;99#D6?mUyLxgk{8
z&FW%nsK?6MXql_|mHK^CnP$q&J1VZRu2bUL!(H;Rr!`iaf6)H&s@%3qbI<8O4l9)}
zLErcCwCTV8v(QgN!*$;7!^&H>O?_lDF{?c1;1@P)rp?bnBWG;5b}rb4$07OJ$|X~0
zZhAM<`bo;huJTI%?`^9l{7rv;>QT`Gk=5B@|4uJ$Ps=-F)*zfMcrEGMt)va!sY36|
z{_`dkaUR-!jmJ9UqK`xWk!AOfq|ejMmHhW!x<mI<_4y}K8SXI|U3J@f_iiki@O;`t
zt(C{$UYYXIqi&yZcEaxOmWBPg&FOm5`_?_=X8iq&MeKHwZqUDGfj#2aE$ycU?CUM=
zD&AA}{^z=957c+xiq)Cz%s-R;;U)<|?Y>LepT7ReNxoCcwe)n<fmvyRGi76C?Qe7m
zv)y&rx^-&j6Nh#C{)V`>-LZZtbW+R2{O0kmzEkzC#!c`E4;0<aZ<IPSV8W(?d(E$Z
zI33wuHL;=YSfon#C3S;B<+?S#Gr#=aci+udMm*hwRi!ES2M4dN@bYkhhj$zQ2Te$n
z>t4R}47;1n#ir7)!ne9k?cF++|GYkvTol{Re61JE8y8kSe|SrH<=RY#eW#A7-J9Z7
z?K^dg%eq-U;y*4;PZVF^er3+ra{18UoBX-f`p)Z(8nQ&=Jd>px*J;%sa4cT&@UYLX
zU3Dqm>*f?szxTDV`M{(+wqW(llmDK*(9SoLO0K)>=w!N)&$4~(Jf8k%NBPe8{4III
zUnu7L%Jzenu6tLfe^7Yr)$Td-&ZtD1?D6c^Qs-6b_6rx{P)QG6%9qH-Ui@*^=H)Wc
zN*Wh0lzP3K)yKc!L4Sns#tBhU<z0#FH)aW~6WY67v+?zh#%tS}?ysF_aPertO72si
zdsMr7P9GH7eP~l$DPLDsxX^vRXXmc=NG;#~NByqUoTv@rvNihqcq4^0<{X}Q=;ig7
zkuKFfPH|f%t`hMv(@<x-7j{c>{bPZWhYO<RY=!stzA9V%^F()_l%&Ai%<d$6nL8CL
zZe9DXWEJ&w)5Ym>4v}dWZ#Nfg-F@zQ&*yB`_I#UpSB1An@r!Hmd<rNOGuR;_-@oHm
z!E~Lvch&Lbx9b;Vc__b+RFv2uv^-?*@o+hTdA{u13})#6({g^7{p;tHq~4@|3!axh
z{G2A|Cb77m&ANCo!#Aq{=96}wUUziX-?n*^|39;+r{YelTlSP6dRmz(tHkfj(`Iw@
z<ZFF?oG-kiO-AYFrl8b@TMO9Tq@%WT)|_}gzgFs{Z}3Y_N9I$8VdAH>L$>aomAq@7
z+HS2QM{<SB+YVe^n|v*mhtbLKcWS_g_1okbwAmiVEV`a~DZq2(1nCo%{S)1_`hz}J
zUGCU(;$r)fB`?=kJ5Ks?wC=X^Z>K%a91RP9n<dA-I1+PQ@%QyV5wdA>7`oGb<QZ=k
zSiXhvu1D6z(3c)L8LRr%Op`pA)Dvtp$F5geH1BZE&Bxq9I~Kj2*|0LDx1Z&g|LT=<
zw6<scu30!qEhhEh-jED=p=IA5yKi}r`}13(L!I=Nu%lOnHuL-H@Rh}_FEc#Teu_)+
z%$X;RDxW4!48C2)Cm0^P;C|$RBdlUBS~?fw6#4QUCT30haiDSHj7yvIugT7PulV$Q
zSdpyq$$zQGf1NxV`Q>hW!{sMQ&cEXm6u<9tytDXWbMCh}$4Xhc(jqq~y#I4@^R_ql
zr-`;rv)CbfoN4E)8De6`?w8N3y1Y&9u;uSHa|~P(Or+Gm<|f?;Iowgty)64&9sh*u
z!JVFR&+mOq{N0qjBUN<bhgY%&9^!lFonz!?m;P~dT5Ik*#jE|*tFz`+ziGPuAWcY#
zAuKb|-&HlmH?8KS(vR?n-eWsmr%yiG_|q+rKk1Xprn}RZ7_ZZibndP?_Vvq3)<5T!
zwrM`$_^{PRu6*ZP$;Hi^{>?QrdzaF*{Zn7!--SZ)hn<VIh<>ZJJj8Q+u6v4;$-;*W
zC*FSYN?{kPbwAa4=)lCL+tHIMPdNM99IlhN{^Rr{-(UQUm;0L+I#0T+RCM^@%&!a1
zhHWc5<iDOxCSz0RgVc~k^ADOF>EC^k^SSoEC;#7F_U^hY?tfg_Ky-!*Cv$(t-4Az5
zK0Pzby4xrb6cH=U6DeK3Q+Vrg4?)4A`N?PRt~4*3r*dG&f{jOa#?HyVW7FU(_Dbrn
zj8DnE6Bna*6boN-QSW>^!)Wv3eH+6IEFPvV+4JVYUd2L}<}=&$Bk!^0H^!WJ+1wm2
z<q&@{rbG9|`Nr5+yCjmXy}OmayJx+fkh9zw^G`B!nNBU7l6Yj#H@U5rw*MJ_+BPK~
zUDc?3UEy~7gK1wAs?@?wuAZD1=doDdi2dcumR+Ju&$fCL_dGH2mW*s>@cC}U_;I1C
z^)cNDk1)pIn@4`DA4p(v(p}BPWbCeZOWD1WZS5MfitrCpmpiTe?R@;y^7+pev8~gH
znklFKrX{R%UF(@sJA|X!4u1J=dOPjRFWHHY4*m?d>iE^B!sj$IYwL<m7p^PQlEcM|
zW_(h+&HN&zs&jkkGcntsC!F2}1t&U8pWQ#_H0?60yPS?g$eL&K*9x6HedRTW{logd
zyyvPS{C8~Jo2wgX6uu+d<>?ERa@nqM-_8FXyxEw0MEb6lweTt~|5baxPvv^^()pAe
z*Nz|AtqcCSUXoqH(>?9HQ<B^Vopi~P$Ays}j1u2A_}gy3XSgYHubYQ*P<fl$8lUw%
zd<UN{3=Ne05P79w!u*7nS2l1KtzDFNyk&#Z>!5p~Cr{5yjk>(T;^XN}8ht673pa=#
zH$I<z=Hd3$EGNX7+Rl0`^gVlji3Dq*`|O2BzgMb#(5d`noSEp;bzUw!`L6u7J0jj*
zw>oa=l**^9F3zv*KBOKM-{INy-p)#t!#l7=QG1KMUUI*t_~O(2oB!Ur8FGO;<=jLG
zez*ASgoqWjw;L~2md$7AEwNgzY|tEEr~XIo`TCPjly26gv(KMj7ue<Z^V##@=hkO8
zSkC*(z5Vj+O>=jA&A!^**SGO#FMr7K^tsU&(kJQ2%U5R#{kptdKy-un(@?YPTG?Ap
zn(x_buDdAT&-O}o5zD3ddxQ30E<JqK^6<_V%SAsFENQHH|EFRqC%b#!LA!^`Jr+JV
zI#KfAkvUbe4s|Cp^erDbI{(%BapW0uBx7-5vZiz8?;Gb9t3Ku1k$BRv?CH^G4{kY!
zB#5!>mY=BmyD>OagZXLFlf`>u<<$x|<d`ZXY@5h>J>5VczJz<TzGK(Q66dc=cKULL
zOfgo}+M%3#SnRLslE9>-RqSb&zm@(yTcor~;kmX#{iR!dA&-xpa`|#r>e|6uYpyN2
z`{VPsx{0i5SMr06Z+>%_e5LRGo>{przm9DBp|nPFY4;Y<f4^^crv1(2o^<lQt(tM$
z1I=uX7Hxy(wJUBK2=57H2{?7BN<*PX#!bts&e_MMHujQ}jdEmCg&bGvAIBz+<#!BU
z+KY58JkT-s(~Sl*@5Ko`&HB3<CG^^Sq&sy*;|vxh)ob@2Z_z&!ZT;)&pQwnF+w|=<
z5<=4Sa~6m#Q9b<2b(2@@i<aKJ?>f`xie6ZLwY@TRS-`n{3Lh8t?AcxZ;YaxTuj-qA
z&5{+_S*5_Zi~G2&5Z_(t_N?s8ms3{$)mfzXg{9Y2{dCB`4dq9bdH+W(-l_aV?5sb>
z#lI&zev6APTbxz%MtogHdGDHyyRvduO#gh>ZKdpw3(jv??`^c4+U5DbW&QLGQbyMv
z?Q?qmpvG*;WzId(6HC0BC+W=L{`zL`^cg}Aw#Bb+EmjPAY+e1EWe1D?#tkk@9|br>
zHO9}AzI*-3j!eOVnv0J%>`^m5c2U}CL-Hgy=?#C^$UaGwo_Q!L-6Hu&+r(!_uD|@+
z$|B|daMFvFryk8cmHNQv-MhWYD!EJ|)0HH(XU=#O&u3%9B>p7ynuWqD`SQoYPV#Pt
zt@@i6xN{|OKMypsNj#GMG56t;H+O#>u3D9Sj(KwekCfc+oL>xe6?#eY*Q~j>XGP}T
zs85mW{NJsLp1)PlMYiFdZ@?<WPhLBOb5t9w-IsmrTQlElUeuzgI$p9V=93Ms-aXFb
ze9_gMM@Ut))A|hG;=ZHT)|||J^7Vq#_L}@X+|Q)Hzg<xgbuy?RanZYTtLIex>nMH4
z7x6@W{W@lMAxqcHI*-6#lk_!n!`8l<6Sl8<tM!u$+IB({j{2l*K6_@l`KKQ@Es9vr
z-c?`AUwZnuG0&X*@JZ6z58c0HCyCA7uhGd~u;Eg~YVEMO&Wc)pHlJ93^U(?AYp+!Q
zO#JNe?z{g<L*?t2e?&jld%94-Z+o$iXUaOUSL-4V^{q2nFeOd-`vo2z-x%}1f0Bbv
zgsnGR+cT}^*@>M3`?l<ykii)7GDxgXI=8!T?b+k<=B?L{PTL@|VVd5hWlax_#lCdP
zaqnmkldrLp`tt0b!`v6^`L2pB5#BXvhWK*R&g##<rh2O{5m}x%WAEY1(_FloCS6fK
z%)j@{y@qot;Yp2oUmN9a9-6;@)eAwpu!A30q;dR<GD!I%xOBIGgO{@T!HBs9_e)nt
z21{pH`Y`poh8ygt_<PGjgZ<mYw;6UlonNEPj;J0BI<9}IEBgPB1@q#oT37N5+eRh2
zbuYbq_hPHRjM6*S`CgfY*ZJ14e`n3OSb9GFR-1ou>y~$}JD4*CH+z1W)YQB!urX9=
z64!Avmc4q`3w>iOE|os`GW)~Y6>H2_yyjc8?ufhn^IgK%`M7OFy~TpspTDe3m#A|Q
zP@ca*;jm6!r^3yv*CtGy@}qIficed;CY9}s)VJz+J|k6W&bAumh7SfSB<f3CdrlwT
zuB>D1r?y;D{R<!0)6MOC-*+l5NuN+G!L{I2rjTT&-6xKv2TktU3O!VDcHVoPz4_?c
zfTF5AYlo}nIUgQ9cP-oR;3|!I%iXKAkG^8RZyD@8Q@wYQfHcc_4I#cn6`8=0qo3A3
z@~_R9_$~MO!MU9-O4*x_3-Wt;Dj)0Tj@r1Y=XkH!*U6nvQ}rbOyvlfBxhi+FaiDl{
z(2QxT{=WNLYSDd%IWvUK|BX)i4pr{QsYRQFug0wYX0qFFr~MoMXFoYL4xV2$f%WQg
zhm)a_Ei6*j>MXrVLLJ=ki+9ajy(#I@F1v*?n?k0vX>+X-yTx#sWfSYpj^Zixr&pbK
zx!J`krd{aPq7c`5S(>ZwXy8wet*1X43vT^!%JtE@$#bpVTV8+2mGvyVWS@fcnUiS`
z-LA51lc=wm@y)%yOM3gU(-p6j{@MoR#lNUvS-H&3Jkh?Y_DH76EjNi@o9`R{v-Eh;
zx=rM{^5c_d)>><bJh*!yev!<-g-w$h%RXzJci*&C`R<*MI_I4X!xyA)7CpuPHgx{#
z#|{@heOBF@;au;%danPu^KAzU&TY1Q!)RLb!BXc`y3r$+lGT3JofmfRoBOt?C_nnA
z_ncXq)JyI5=P$Xk>)llomSa02;usI<#e28yUGP&}%-Fw_$22`6|AIx%GU0tjSFKlx
zv~9ljbnV8)Wj9-HuV5)(did#lDTxKLT2FH8*zPPT>hpegp380Fi3<z27++Z170#?z
z_|))$54+LH#fvq45-z<ux2QfMa?d(;>;EBp!=E*_ue`ldL~VoS%5BAS7D`qK*3CNm
zESy<+ah1u8p920zc}1;yzBF3DFH$}vr@)tY)9>~&hh<(9|F31tti7)M<jSqQ`Ndq(
z6^vJZMrV};EEk_)J;{4b*5nmuqNXmMX)@*B;p2bTot=GZBKMXK;TUFNy*!H$@m!aG
zCf$pUZ8{<3ZTIWTJ9)MM+v>s+M}-6fV^5_i`;*s-O>zjAn)vFPm_~k%?HlI34e=)f
zRo^FXw~CZ^+r8G&puF+tZ~shzL$>UO!BQLcpPv?WMtRPChm#2fNm)7upSga#)c#T1
z7c$@M%ev3YU+(RY$vFA=Tan#2^`7|8?`|Y5vRysh>DbLBn|O=nG{-00XiCxA8oEL8
zg|B3Kv}~xX{fp8Wk(Tm73bR*M@S97CXIY=`cHdJ{FX!?q?M{oOt?UWmxpF;ox3wN<
zxPQOIdC~r|#6L4j(kF=NAE|BQJLo_6#BxL4+l49)pVEw8H*UITeyq#NbcK3ieX!#5
zpC7NKWOtmJ>+|R3t$Xa2Cl_YU%sQ8FQ$*WTO8jSplDhG+fY<JCUl}D9TwcFJqxGuU
zs*p`PA2TQ|lkxo)SnQ<7bi>8xbEQ<)UW3DNTXUH2+T3chWo&YPHTy$wqvy+S-sP`8
z_ioQwzD)DeAI(hptyM0uP3FE%{S!MK?B{hG-;mdizWedesa-{`D({|mPHnv~ae8c2
zPQissf)fHl3WX1G{C?QD-)H74z1{1|W!0B(Ub>zxwyQF-S0o~D-yLZmmCeGkXKS)9
zWlU?op#SIPPt#4>vnE-vPUkpQd^?9tcAxtTq0;j^3Z-9(-{WYpPWaR_?VXzS#_X?`
z%ct~KAD^QmpM9dVczWIkUJZj6=ckA!t^KpAI5g4S;K-AGi#s-7HhmhO7615{^yNB<
z-pluHs<ynJbw4sk@GHN=(WmtWMVaA6oYqQ4x_OB_;XfK9@24ibx%12~*kXtB{^+!c
z_j;z8<d$ET`5bBA&A_e8r^TxfD1NE*>b>o==e}lM`?pkspU02mIPbJ`I<8%_TWt0}
zoKiOPfa_I5rsY>A2qsNpp8h!|Eo*<r+sDUMqL_a)d;9L-GT8IiU}98@!L*pjPhBn_
zmD+5WZh5t>PrRyo`hwS`ipSSZU7EA3Oyh{>vv*?Awtwa?GF)`>df^=NNk#8F6QhJ#
z_UpE-2;a0gUOu}+W6e}0xhdWgYA?!aC2U=@;78u&J;A?1rm1Jhn=ko(`!73FUuEI;
zlck@3Jj|$cwahm->LS|oQ~4N&txNulpL3g!{R#QCs?=L!zq+)P?xc<-zw(Q`e6EHx
z-QPGN)Os<e|I?<cJrf!^H_ZQWcIB6Q@0iu^iY`f&E&TpFv`~7&Jo{Jb-E&WDpZ00X
zjsD>3t<UGKR`J;FxAd6s3l49_YgykV)*bw8#&pm_^N1{8^R5N6=A3qZ`>?+C*r7)r
z7UjVOVIqCn{YR}{c0HN(@!*_D&Xz+Pqt*Ewm;O(SObNgIb81);yRUt~=9R@uVt$84
zC+Uh`6*D!hSlqEhiGRukp~ctuU*2r~cCl0>cFQXvtAAR{OJ>gBxSK27Xz?eJPun&b
zh#Xhd3O#=^=(_-)kiy#aiF*rEV++i9bf<h!S>xuoI(X^hy0ew{M6Kt)ojdRCSECT?
zNH*hz)0gy|NdFX4f9y76$Qkx_j&+J#SAPA!!%26~j0pDi=l6VER%OPMClK)~bLQz4
zHhWh5Z!jrTk20Ck^>zy1-_pCg*Yk&&{_0!kyU4%QD`;+diJfK1;R(eKiN2CEPG6pD
zswfv}JLAFS#2bI7O#7-c(M{u)QPb^`(95=EE)#k;9(eX|%iavGWxi*E6Zaj7e7@K?
z>;8`bTle_Aq33$k%fc(tJG{;ZrA#`#f7w6dkN~kslKCBbif)Ido^pBC^poY0__f>|
z=f8PfE{EPd)8B8VS8mR1aB!hw&6i}c(EPZmXOzk;B@A`sF5bTC*HL8^@%7MC<*4Th
zMSkU%`z(}<c6}}6m~l<rchOld?(?<$O1ZZSVj0%_{I+r>_e%SaiH!^XU&x)Fc;x72
zg^RBQGP4~jIJooUHwf=g_^|!?_Qe~I%0<+)bstR0T0BL^$iDggL;rYbPOpnT&GDIP
zcTAEuhMr>Ls>}bpU|wFb+EIl#F8QxX{A+dGN|VyR#@t!kK4Fz|=FK+W%+7xG&O(QG
zoG$JHv-G#MZ96Jnqx#G`_|cC^zkZAVT(^f|PI7g~>+}3?<?Z}DpX#pa)@m_se377X
z+dx;T^wMU*Pu}kx{&mSHCq{1g*(}GK>;BK!wBqVvmQ9;jE?rW7b5dsaCqEYVYsX_c
z_)fi25$oUebK;bXKTg)Q`|j@AJ?nSx>Yk^$S^|zMBJxWM{uabmR3}FmDL?zDGkq`r
z*U8rdD;sxe9F%Qi4V$8%cw^%SwX6a$QLl&j>Ss+Ri|onTEIQLgEhWTr-CT{nIh&h$
zj4t0QF0)U$P|<7rEJ*&#n_X|6ioShZJL44lYpp{cR@v4&J<v2xle@d;P_up_`^S07
z*QK`X=1MmGCdMhN&31%q@wSU+O7$H17ruSVl)k&;km7Q=BW=?!C9K#Ia#gbHv+wmA
z4Ay(jYn)#$mtD3=%I89+-kfhoq*&WDDz)EbnB8=_s>J;I)c%M$H&=cBBzAuBq@bpb
z{-uUd6&X=?{M?loRz0}Yu~_O*$8XW+4LkDc`u_!_7@mG7@k6b?uyn=yzdGR(_xS=Z
zoiF#lV$b>0r1eIHcgw|zSE__JZu{!o^UmubZ|)1;(yM%$^K!PnoBeZ&$6ubH!>;vr
z)~<A1z5A8=z2;p?FZ$dY3V&~N7hCepb9+hQLc@>u1Wx_mlIgZV+t_J!LEsfZW}oK^
zc{XOWs3@-w`1yt5;ExSU{Y8=uC#*ksHcjiM*W|1@$}DBFMW#Zg!d?~;3-#{&Qc~KN
zuy&#3uLUxz^VLL)u59?ia)0|)bFNvtIrb}c>Th^$>~-~=H~XQc&odr&is{sR<iD=+
zwkh8KdHJpt*Sc5Fxv|!sr*?lyTZ`Wlr;4?AjwKXK)R;YMwx3G$in|+rd{|Jw`cv<r
zBksHtxepodc=69tYk&MzrDt+Gq*;7g>&_f^-TCN9?8{Y!%jC6~(>FQgYBW6Xc;3r7
zQTmqs<S^rcjCC8VCNTK-bZBgN7jaGO>&|I08{eLPC7`tUx#29A6{mj9>=N6ik@QiR
zGk7W2rpL>!vZYOUnOEAqFY8#k;m@*`W3ma$d)0b+%BJM1_O8ji>h?qXspS&a^<|d4
z#&&s=6K8)*VY0PocyS?JNokc{S3u7_bI!=QS@yqnfB5F)F!}$%P`5dK#%0~x+L<3^
zI|s*^E(`AaT=cDbPJrR=`!Wk=%9VSs+gEs8`>aEnmUHvEdy2Nkv&D7Jtvh&U8>6v`
z;O!5W3$$$CTIJ8a&*~;~EAiByL!n>qm<F%S+-sro%RK*|P37IRGtZqrwCcUudC=>T
z>F1mGm80zKPDst=JUoA*Le;@*7bi_QX3tvjZbwCpy^_Ym8GB?m|7)<87Mt=&@bGcL
zhK|(bGRgOM$2?C`E!3}nuOxAzH<YWjqg{a6ZR-V<N0N8`2JZIuyZ?Ue$<3#$woT-o
z_G1zM_6w_?Zqk1G$Y7yhg2pj6rSx+z6>2Q=7A;*I@~rP1ui&b~Qq$M!EWEd({JJDZ
zrjB8!i(T;bBCn4VSHG9vy-3Be?c7?{_5BKWTDI3&Z=Tqy^=*nsh{>J#jQsZ|iV7s9
z{W-aP;|9en1EZG@GtaDc)$N~`a@HW_z~#t}?ymuHPWRuPxV!7rg|bsSM2m~Qv?V^+
z+qP70W(?nl-lO*wHI_ICrr$pww7a=6k@N7rQl%W9ebT1i798-n*?8^5xq{<XD<nmn
zIp5rI`ab7M@$v)K=F-<MX}^mpUUaA6#o|VhRXjN+8dJV|YB}cJWWQfvt~&GdFP(#p
zmlmq>t9;Zt`QeVWRY(7`D;815Cz#FA_Y@H{Z1p%@Sn#IF%|q@m|D_eT6~C|CuCwm_
z*UzkmZ`YqIe46bZ#F3+s99R`Me`A!h_WQ5lf-R<;8M0for!39dQoa6erqG=m83!cu
zbSB6C?)>CxB$RMeq-K}*$C$!(4?DgZpIF4bcN^o5J!iEeAMNj(S^cV1z&>ePd|B;`
zpGSjDoj*42-FITw?RyNNr@mMnfBaxh+LztgKesL5dCrj5ch(?ZWs%qFf{0CFp3A;`
z(PVTx_Deb--Tv#dLmJ^ZnUfR^8?R_r1j}u`+bn&-X7%qIWm6)$9yz}1e)?tNpXW~Q
zJL5XPNv5cpTe*vi1SzaH-!J%Qu6o|b<l|?=^-n*2`N+SnY~NL(_)3o1XKyjJU$zqy
z<Yt>}8k-ci+%xfE;p@$DQNk`0`ObM|ecX_J^Y~1@j{Ohvwp^3A?xZ~9x8g#xdCNB#
zx;y?oVQ+2lY$DT&2RphfbzKj=%{=<q@j-~&)9$hhYKLQ=SQ_c)FOi=RmRT=Q$fz-K
zw!`(=n-^JKh^<}XvQ|P$>C?WpDDGqP=l=auc_Zi8obUkS7WQo&l?<01Z0oGg={y&E
zlV`jtZQpz~?Zqs?+XIbud7WFSYkn)uEA;a&mM(ks!>^5}hi$*D=yj&Jhl?v!H#p}-
z*}M}{&y$ww?s5Fc{c~NNX!kb*%MzI_pP8LFv|mL2FX8gL^_L@eTi^bv2kd92RG(UV
zq<{9_-?R6b#c%ua>7IYoMz8lPU-b8Cm2EXS{9I>=U}@6+3Et1vzg}k$!)2-Y=v%yw
z{HlN>td1d9HCo#rPx0~cdKeeQYLXM+usD3Lw%*COM~}`|gdWTHZg=JQd1dpF!q8l|
z!kneDFT$9Pq@7uv5OqFwN7*U0zT!h27tTyL74h%>1-+VTqj~w)b0;ve&QAVyPl}^?
zhd)R9>rU}KMJXM-%9+IY-mqj}ZSeSz-{d@@i=}zJUDe5%3;j;GJhNmz-FJyuXZg+P
z7i{=)b*%Q*1~WuE`fi)BXz8A{6V8XHyeQvz%2SGMQcOwT4&hf8Tt4<CGu4l-YqK`r
zym-s$%0Dr)qOb9t*!*5yQN-?(^`+Ph@v=2r9;AEe`L3C(+;;SWvsuZzQ1RMFGi~>^
z$F+9spLqP#ye}7fXS3c@m=eILa`?AM=;2!XWs{PnH8M5+Pis?@brpDcv)4YxVS;0`
zZPP@J>)M8VswMp07CDhB9g{EYGFs=Y{Ml-U>-Mdae2#7tcvWzFv2kUKZ0@<^Hx!<I
zzrlB-Wy;6E&<55M;kL`K=dD!YoAWEdOsqd|xnLku-nDFTk>u$Sdk^os&=fnrnXiBH
z$umJ~E<gIieq-K4kq)V)CbCU+oC^x9CPnCEooO&@eR9P9#A2%t4Yh8%Oa7gm+kT}o
zXM5;Z59Td1Bb%OGw)wQ+p|wl#6;A)u8Id_w*S_-VReX!S|4_t4lH-J`V$YPglb@K9
zE*A0Izpjs1^!VWE-qYgVZa?cfSA}Tpx-rRUr^&O=PM2@Ia$AwR|4jb3sk(cf%I%*K
zma_LA+g;%+E7MLpMa^=4zd5V*`I7R}^8(5{TdWpn#Dp{YC8en)?frCV(RvY+rf(@5
z85fpL(k)*&b3%6Tx4$I^rs<#9mNh3^DnqMqZ}wB=-HT^To&K$0&CaXm)<sR$;j(_%
zEOKjq1?Mpjy{)1i)g{eu6VLl@*%7@(f1>TwjlCb|X8bmKrNnTT)yN>~?J3*cyM(W)
zPvOnY=)V*H$AU}chtvV~=;-&NnwFo{?yY-$UV^1L>BAng`nmI_R4Ufkl_aJ1ep+&7
z(*L__1?T<WbIA7;!$C&Xo*lWWf`QH6hfhCRWqIH4`p&9ef#X$N4+NHOcIjNYa<b8V
zp|F6ZO?n)gKWBzI|NhT8kvZ?ryLsD!IMXuw6{8oLoGp@=a%scWU%DX`yA4ZKypC6F
z%u6lniEs@3|MuDHghxM?e(W%K<M380N~L}omndJK_`2V*m+!v#`$e#Kf7#PZ2WvS?
z*cYVcYet>TYK$mXEe;b;JJvUCf7Iu7H5`d2M9j7=<_+KIcQeD-fvNV`iaTvJD=yg`
z5DdNXU%{mC-gfQgT<i2joQ0;g*ETr)5o7I<JZ<p4%hdUDtW?JgyC(<w#qTe;bL8~K
z(>1^Jk6lUq`Q48HclWmm;alXNiez(G6+JgKieBHlP|0U*{K}m>W+{6rJXhM+(yhFH
zZAf_RadRW3oYj4b8^0JNEIl&$-K6-{k6Bc5l~YeY-MII}w}z+fCtswjKEeHIt4&ow
z`kOtqZ5oDCR%d*z7W~J1I>T@KE}b=xPycyaDxCkfV3z3WLyxO-l>#cyKD}z6Yg~UT
z-RkVy8`-xeY*e_DuV5?l;8CLSrIh54Z5a_iSPJX4{bwj`l~vm565#M!DdW6e_RfWt
zxes{+|CE&cFOFnrtLaJ6aBgL>_u0G5B%$@qm%VNZYYs08UZ#6NHTvWBq>1}^o{F73
zpT*^(eO7SxxmdO7*UduL>t8dgsyCW8+imZUfNK?UKH7(m_ioB$5SjSjv3YKnsgN~m
z$W`ad|BuLDEyygG>n!V-RI+cm_{v6|q`rc;yQVEZB<FJK)5N87ZFhY6?Uv-T<woAT
z?kKg0;*EQ=|1xDdJ*+J9V0k9<@MPrPz|*YJuVpT;^<}D=WaliU%y9REvggc)_OpYW
z&xywg=KCkAZFFv6TTq#BB|2#j-z%eODhG>PyV#dVu3wl{bne2^)LTm#cvdZ1ckjRQ
z@h2bND@V3_J?-CFKl_l@ud)KmVlQ^#@@bcL?JLu4)H4!0x?x52@wcr<u5_DJ>75sO
z{dBWSi^*RDbIIfRSzo<$U03AnpRsq({KPZP>RJWyFMrNREvpW{9MruaFuAjB#?{B?
z9vfZ$e<JXZ*52t?e@_2zcrU@<@$J=BI~w{<PqbB2-u%aA|B3a_x_UF63s<iB`FZWx
zgJKh6?q2?QEa_Ul>DumKKkh%xr3?;12EVc{bZ5AgoQiqQo^pYE53fU_X79oUyS{o`
zoNt@d-Yk=J;7Y@7sjnT6!{-XklQpVHnEG+k^Ym)w__{)!swtmRs@-@_t(eDujAP@h
z!#`NpmM&PZ{pHSCK7D7`FZ%mOq~PpR;o#M^Yx5?H=~Y;kA2!<mR%)|M&nxarotp}<
z9nxZk<&YLbV{<bueV^34^pXrC1w#{KV;B$lj20tfLrVoPAbdtkZwP0IaHLo+tLtMf
zE3K^C_f@%sCV44vu%xmJHsvsJX}AU{F7*uc&|>Vlq1)8wCUsQw=tV(R)|BuKN7-Cs
z0wo-#Z3`7)ycrYW5|g0CxV7}zoSBo0wZ7ilo&Wp)y+!A~e=ytj^s!=xaG&5YAFCA3
zH#_a@o-s7}ybw6DC}5?XhN6?(9g$V~N>dkFr2Q0c*elY=dFeTWuu5Nda>CRYmKkad
znQ13u(l{L(SRKXYH}1G1WO0CN3jdCh4P3_sBwMrky_J?`teBv1yQYqn&Bpn_mJJbZ
zmzOX{8!EY08nEp!P;@zx;x4DdbkBm{wc|v-mqY|7r&H3&gqHU9%ZVF%`n;XPB`!Hw
zcyTm}D>*OWYT>`a&0HSQ!;|l}JfN{(U@GtLy@iZ|eBOc%RxTR+2UAkoWF9LAIhe8E
z)5}ZP%5t#nVBTQ{DG5vI151qePmw+uChlbDYjo!E!z9ig*F_N;0t=K_)|3@378YdT
zJs=U!+u~|8=S;h(fmV~VM?+eXgvHG&rWr8>DYlaSU0xiLv29&fw2iK$o(L{G^5ff%
zh@OO&o<;M{Gfq{q`E)~B^04`C&clZdpLQrZ818e}%M!1bxaQym1ItH`444#Sr>x%>
z(87?z(R9XFp`nFQrAa+y#p&NJUIM-oR+deccF|Pb!NPGub%I7n!-RT~r95E@4HHgH
z)OZ@td_PJ=P548g9HY~O0FlKtYyEZ!9^Bv?w@;*(fl=V3ty;sC{rdTiDtmuesCE6}
zx_(Fh@Z{|D?EHL_Js+pfm@6yCIOSMQ!WpAP#%-F?Ga@4zR^)eA9C&d;;KFquai0d}
z?uU^loqyS^PkQo;*KJ86$G){s`zFtEZ8#X-#qN~T;chqMzxhQ|&HugkUupgCesrJz
ziHdlqNg}iFANxZaBt%{N7(7m$;+*s^W{wEsH`^=xlGAj=A1*HX_&rdZNi8*@yR~bd
zjIvg-ld`}*cCQaDQb|0!udh&5b22=_JbmG-d@h4DrwiqVLE(FRpOibheF_wI^0--Z
z`=a3Ehc#RGMdTPWcrPtbVO7dJlC-&Tk|)>1ewPdh9*Ghj^%EivdE%@rJEkn!7oc{8
zjVI)-wAsvM4T@K1+~4x><kFy^G%2|W#x>haXSq$_XmQV6akO&IjNYAwuJ1SHK5vmW
zzn?zSZ`Z}WyUXX?FLtkWU7fyV?^TC>&rPfDZCkR;)%3!O>j$l@LpGeOXWNqbcd~A$
z)@e!JpRUO)ioRQPr&gW5Uw-1wlQm-3A3Z8Ps3u`wa%{EJ`sjyy&91f?XC~&)l2_Sk
z8Lg{#=8e66&C<<JlGJM-z4%?IH8=9vGc{rN<1rh3cTLKio*W(fdG~3h$n9tUuKR0m
zwUt+8+TGNR^Y8vp?lt48on^6nZ|$TbTg_M29-SzD{Y=_!w(zE`SD&-{Hru^1?Rcl#
zbu&#sN&CBpgss8!WqY-)%-+wOe`;&SD}Os~h4A*-k-<@$R`I>HD~npX`DE(Zh4$yU
zB;4xW^}L;Wsb!A6&+qeblH%WfHQv{mJ<0pep3hGUSNs2q`et&pvRhV0si)?k+-ajr
zec2l6XKliCri&cdY4SL3`X<)hC7<HzWlXKy-?Lobml>X>95Q_YhmXa#6(4sNA6j=n
z=hcs2cV9F0K6+lTYntHkkn#uWk8D?`{QJBA&B^Z%djBPCHS>Pmtfd-xRHv73%fFk9
z-SYFFF5F>LqQUld){#GNv%Xn8FPXPZv~lVAWm7j!KVw;A8zypjMr}e?{M>i3hfi~B
zO~`RA{4?9=?v;?Ed)kV8-f!i-wsYYo-}m#6vM%b{BfolEUgg(@Vpi|Nakd8E*Z8E!
z@NDeyEsv_Zz2EVF`vU&dIotYPP5rh}*z8VQy3C#@@ii6u!W7=63U_94UfMFrGH++w
z?`Lr$Lb`0_e)Dd;4}Ej1e$(Ih+U+}3Cr@=bRsAh-{nGd6uZBwOO)3|tz3Dwu>-3d_
zhgOD5sofPS`SUku`tjq-E=@0%=}|W>F~63)+<8af%Eq~7YWYdoyF2cLy#CRdU%!aG
zTr+ucm;?Xa!|!&bPVvu_DBU}GmZYq|$<Mbcv(~3yw3_rPZ{N%XMo(<GcU~>rxjuhm
z^uyB{-<RCF6M6Ss=!-?_JEt-J40GFbU~gJt^6xq6@-_0)Y&W`Dx4+tPRn2efO0)WV
zugkX|zt*?QUgENR!@APFf?^+DpR;<fuwuH5(%hiX&0p`GU3Nse_sm(XyRXmJ`Uj<5
znJ>u3x-Q0?_gq5atwie!!RPNpyIH4;&zSw~1^b`03C3>^9M}7{#yOh(%?sY7R7cLU
zzqTYvJ->DLw!62`>ZV6FziWGMTXyd4^xw7j?0LEM@h3~KKJ9y)`Pp*+lJs+XXKdQ}
z!)9xB^wx>j?RCU*`OZjd-2HQI>Do7?C%za9#qycPi0waCb=#!=Fyq~d>y8EIgXbqD
z>3x}M7GJR>^?vZBjA^rX=`SpP)H?IjC-ZZHqR|sfbk`eduKgrmG&L}`(^uDU&YNoK
z{%au`EFKU4#FqY&wJk68t8_ExU9)y#-uavJ^PfvT%YFF0`l}ZE>!UKapR5$|fBn)v
z`uMqJ>C5g4%@WDIdw<hD)A|kdr@x%~@M-C_v%4JS{%qpvXa2@7^=^*G*|LaNJD%ri
zFMYG9W^Z-%oGX?ZlTKM~+HN}cTKS6S9dRyEC4ZKF;o1G#^X6%P(eB%)j=J(U-=20}
z+p_5D!f8fVC)JnQd9RGk%6uLmbY{0yxc!$;w*s%XM;;GW+j7psD*dYEU6=Hmleqm(
zElizSsK>ayTkWV%T=koKiyu606*WG+c6YOU{Oc>PV~p+J<?r4U9KD&XTY9$c7nQ<)
zmfA*7g#MoS{<U^l-<5AKHi!LO&%dYV_Rjx)Rq@B3E@XQ9YToq6JM{VQ=X<=Fv-{J>
zZ>+EX-u^7)XQpeiqu}AuL#q4wXYs$7>i2)kt`$H1Z_eB9vFO^SzpKU0`P~+rTl3z_
zXWGBr^N#LI%zq{4FTL6J-rJW6?dRI&tutQQwQak6l4j`L`AT*X>F;NU8%x$#m@oNW
zbdKo_=dMFFCvpM{WWEbu+9>qZ)4u$;#<sO_OYa2kNXqY8@a4vV#P2R^XRUpxpY>TR
zPO3im`;~;u;;;M<&#%t4UYDM5FR{vb$Mxk$rSIqeFgNU89*?aVW`U&{W^QB%Yj+tb
zn3$PkJt@!B$jk)X2qWTpuiT<^6Pc_lr4tmaE-vO-)GM&q<;n|H3BARxorcB|XLyW-
zFE0M>r{to3u~SIUbdk&Zy>4Fw_6o<Df8YB(_I}j;s(*7fpSOGcX7l{Rr<e9QK305p
zj$?v>hf4@s!iu~F+(M$FtQ}n)lRti1l^_^kBh(z$`bf}-L6}7*p`(DU;Rr+0qD2Zu
zaSdF@ZpwCV*?gRtC84R_p<$!2NS}-1Muy}b;bWqlo7qq7+_g(<*Q0se3G=l(V$3C#
z1Q_<%G9`4EI5C8L`Eqv40VxJX-VK5d%#Cgd3;h`WJ~#98kZ@q<bY4)%;n<+d#$E7B
zo$-J{hQ+6RUyF(MOc&O1==_VCp)1zR^kS9clq+8k2sF$(#oWQg(ACCVVzU1B#fmv+
zOr;qQFZy@yogKsf_$MrX^*8<0|FyoW^tZZ@B6A}{feH`*2FDwU7gPBEee>nc?Pj$3
z!`^0J{%?DUE=T!VeuaX!3l$jpHtbEaFE3(p4&-QP;9`6FN2dP(Q;A^#ix{uLfdva*
z)JF!0Tsryp|LNcHZDMj&Z<~c~y}M<3v0g#NPxfV7!)xV_*TZf*&0VMat9iD<zn|i<
zEHXc3zWUogy4C+$zBT!R-@E_TpQ?K8ndM(dy|lS#D*Ed^!@nt4FBtI1bZ%poc(i_R
zOVY#tjP<8}1w668{(1e3`t_U)zxKz7cO6%{%kXTGQvLk)7x&-aKk?~*#Hmvf=KhHn
zlrtMP?2zDKm^7h=V}jW9Pygzl9GaKBk;CL)|HJFM|IGexslsxImr;4P%;5tm%(9bK
zHFMWoDPrTw=j8noDb3m2$Z@P%di&YTiEF=oNcY|!@m*ofOnr?TzyIbu*`I$d`)%!$
zwqpt!VY{l8b~@=EkMO_uQRLRoDd*<>omv_tm$kL@@(fm1=KFW}ZXZ?m_x<&nxmxAk
zvi~}@k0z=6uV(Dpa&CR@K38LLYr~p`YXV!IEcdRg@@)K}7~*7{AU|bq>gOLRiIWUe
zj2~DZHPb(B{QC`){qv;)n{9V{7Zy#flr9m@d*OOY*uC_@DWlUx9y3bvUffglO_H0m
z{rkNu9i3+i_8$?NU;Kpc*7BE&K3?E)@@js@Wt|}RMPljC)OQI2vThL?pL>1@?63%T
zQQG#H<F{boWBnhoe;;VYT-um;u3qlMr=XVguaB*m$(A4HP<P7NcmAQ)qziw4T$!0F
z^v+n_Slx~<cKgO}iyluGs}1oAd3;K7W;M%~D}n1jRvuk8t?28Gd9$jQbJy}NS$f%M
zCySUWyWVlv$?|2V3V!~nQug|)v+(`QNzE6e&hfN)CD&V)*6PmHns?Ru)73LEoofry
zOfIfgJ6?W%y}Zt{#$Dfy^QE8sZM8n}MMjbFz<USIXFl!?o%eHgoYXq`U5k6Otoa^E
z39<Johu(#U7f5`Z6B%eKc7E2x$)?KEYk8h;&F`tV+^BnY!$elsLVJPY*B)sTczbPs
zcf1VRV;d_eRwyp2o}@QdDZYB0g+()`0M9dv%>IfBQK`qji)|%l9u?bsC)H@n=@%c&
zg6wpCCtaDdwo)Z$u?maFqav-KUmI7ZZuaK?bl}^v7@4o-YhDOEw33kTl+%cRxrTpk
zLc%uR&sI|1HvVrLw=8<m67cqrbU$OSt%LQ?9lzxS>m<rI+Z|ta)oI6-O?@)!59ekC
zU6So?l-#&{lY_Khz#`6;>)*RC-M0J2aB=STS<ge?s;YAu3K<`kNi2ChP5yXCdJF6K
zZzU%FKlk6_QMz{jgvdnxPnsKT)?Pj*a_HYV>C#8r|1EI{+i>@4ex&0*4r7a%p6p-l
zxpTc=u*oF;n!RQ|UtM(RX1#~4YYNu-h&}nZw|v{jSt>dutA$DeS4VR_iZKgpx}S7~
zsaEr7-#c?7Z-;p-R~bH(ueA$VW>IIV<2U2U&c@_^3EhxCISa~^8B{!v8`<dIPZRYz
z<r5{c?&}J+bvK?(+$@(fr>Hb;{*{2aDK-MTAN{=i)b{t<wr;&#DZ{J2zG?j0*%N>E
z=V~n4{ls>)SoC7!N&4o7tovFvKGV^dw={QKtzz2@sgE(|^yZywzcnS*)}^zhy6b$W
z@1(eCG72A9uelyI+Io>oaowdu<@(=@wU;iR?9n1CXZG#QZd>kpk+)ZU51M>)RDWPo
zrC;)4-KIIt>kiF5^f=&C`P7!Ym~#$k6X(8>`L}5ci<$i1$%<C3tyagy-<0Y;I8m1$
zncY8U+NwX#)*R(Oy&*p(Q0Cdm1G1B^louI4JY&Dg?4(fi;b7&XLYX&?-_Tky^SMNe
ze9Ni!9~D=A_J&MdzO>a>&g1Du%d{LJ4<o&)M|SQn_2Bpv9cwj@Lr!zGk%i~Ha}mMo
z8Y@4pWiQ%3Z=P?NdP&OPc@jHJcvk=JnYHToJXw{n;}1>m2V8vkv_xu;bym{n-yaii
zR&yzIy4?A(EpwIsA%hz`FJ|4e51YH~=a2G|M=CYP|14ZrE@;#<>EH#P>2ep`^?x~E
zi`%p<a_Z#gU!OXCUn_Hb;*Znom(P7OGx*+L%SA!fM^AovyX{wd){K+9uMHW5jW;~p
z5$_%Kvt*hVtCmfn_2G>k+Ztm&A7#D5_+|6byeXA8{ll{+wc3V8bpDHMYqp-O8C0GA
z*zf(i3CBDlXRpZr{cQbvzH}yk{^qG6S6KX-ZJ#eX{d51O>t;{2fBu-gxvcxj-@32O
z$C4D{cBmA+c$Vb9-YH@3yu2^E@%?!sy5|>*DqZdQ<Ju+L+qwC7Yfa|8PdhAMCiI2h
zx3^5Gu$r5=>vD{y{3?SY*6*jqKW}Q`n#ULNaLKNFU*f+^?PrnSe@SZ-kB+bU9g%9K
zu#|6a9Ob8(ggo};i42;#(#`7oWrg5VZ9y}auDQ+i`q9)YzaFmt_UpG?OePm^tIw-d
zzYn-gzI)Vk=STYwYuKOjcga~F|5~&9S$QXC*OHf-B^~p3?OgLSc~!=yx~06^_zw27
zmn)<^5Ba`ub)v!al^1pdosUphn9=;e=+Dk8+Kf*%bkx7Ld$lbNaC5f4?tb*ab@?W7
z?$%i=RP^J#B|>KGcz5D}^6sOdP3xn!uX_9Y*;eIq2bXNDkh?Im_se2&zn2nmb@Q2X
zoO%xa-FN5g9=H8oyf&WF>J{cIzN`t^)mC?;;ar$a>O-gZCZQj0&)(Rw({t9R3mZe4
z0;G6L*_D3#msV}t_GepQdUZ^n9b441Zk_JsF30BmTAX=J>vVC9o8AG@b-ezPOHY4)
zwA62p*rp@*=3MRNJZL7s*(!E>=VqO6Z?A<jGD#~gR#ugZXiZy`f9?KuO9O6A#n9r1
zTJIh9wb^CXKD;--#=Y#OJWD65?v)c&?|Gen%Il_B&T)A=t<=y@r(}iWs#TqvggFcH
zRePk5&ujCQzPoaR?1D1S4S!Nk?K`b@WQ*CZ4>zx{d`im+%bsf8E%8X~x%K6{Wv%~M
z;y&s|=B)A6Q&zj0vu0_W$hQp~$6YQNb9zVq|FqA4(bO+|5*epof6Do^<8P_uoTyn(
zeXTqL|CQ|hofb3YK-S?utmP-)lwUo%%_q^lhG~YbwRZEz+l5zh=YQV0$l>Plt=xV~
zO?WMSAHS*+B^c74oc{ivv99;hKdX9wgw4o1rDcE8d6~$f$*jUXf2N+#T@ZQIdYAa5
z;JD<<>kB(A)RkTY#k>qU&#vdXL4!}9xjs%OOU<uR^mo^fKK|&}Gnc>H_2Yc)^MCEE
z%`z2YH;ys(83bD2vMWp3`@qXP|Lmdb=4p1XE-0Sr-#V@MhiS&Eq8O%-3qLp9xxsog
zwK#9-&DRlIuAl9Au;#r;+niucxtvIToe4ePng52XDyrJQ{gm{l&*nt<o{5(y?b7*|
z++8gzQsnpIsqN`~pW?FpN=|5%geut{d*j)heDB<?SIVLbAMvz>DSxRp-_IIp{N2dM
z@lHkN+}pwY(?3cq+{~~om+A7QjJ@+amoH-Q`_<tyX~LGn7VVo_=IpuODZeVd<ddh%
z+mn(7OY{o@XX>Q;o|KyRGAd$)*RhDN0{N%ReT}~6{;zV@trc5SIN|HTQ<ryM|Mf1k
z?Ki{yTpob{uALnWChrchw6ob-3Pyj>W@s+YojG57;-;I6*6vwz?#sVhJ?pM#yw$vL
zz9KBQ?6}~;XLm1|o|=FE!;KX#dY`tP&vmx^e^$G8>$UsEGv^C3Dz9^xRO|Tl{qHM#
zXR#jODe0THUZlC*@X&Aegy5>(_7$Nw3sd`N8G0>0(Ga8Z@9aw5@}S=pe~%yInIoSW
z_KQvU+|j&+hkmF$WUnz+%Ib`^Eh$z~VH5K*y=bEoU)`VV5O`!VpSxi0yHJ~)IV<jd
z3IE*x(6x89Wwd1mpHiQN;`4hM!u^W_G%xH@kFscbc2Tp=$fP`PRmALHzItVM|4h1m
zdHx!qm-8<cFLx7Ux*lf!fJL0ie%;XvMpdj+Q+ey7-)_hbecAnT(VK57#`$l}?5vi1
zT3S!EnY8k~*ZlgmyB=;dns%wG<lx(ndYum=BR{E}IFMVX`Dbr<Uu0Q~!Gh%7n=i9H
zN=+{o-F4_h{0{cNnJ@F>9cvb?*Z=vV<nYV0=HD5nI<|BixVpILR_CA72O?Rw?0%>e
z<oo_vW{rrlV(~?X`iYqh3T`tk1J*2;IyL*``~5$AI#~UDK7?;#{LZxFsNY+^(y1H=
zPJDWqb6ot&o+DBpf5|<+Hp|ubLP~!3oCEKFawvNRZTtOgp2h4_-g#5qmvOz>K1ozv
zbN6eezwzg*7ku&#KFE~&_R-Ew#;iJds@^iQKfiG=VXS*{NPPE!+r8hu-28oWyLoKO
zlaJ+dt}#_U``-E3mR;uQl~O%-(~ysO{=UDw`b6jXXSRReYqB;t)UmeU$wULkiok{H
znm=zfCrw%L?q-9Xi`~|ZNq5b@7#!EqfBkC4k|{r57N}WlUR(M4Qp_IxWrwv*_qgy_
ztP}rzeA1m+t3DPlIlppi(60#ZJp%vNdG0?^f8^`Y>mDh07ggMQF#Dt5y4_N9rFV1Z
zs%_uHc`vLsGsBF%T2SEF*}h#;=K{}4oa4Oqx~it~$I+I(>N5}hvN2{`CtdU{HDjUm
z+K9@{#=oY%asAF^t2F2Jb;pGDdRgBmKYM>VDQe-$>+j;V`)?Vg-TkzEhN|%PY2TNZ
zJ@$-~zuDMr-g#*WQ<bRjVdI&FPZrcnZVh;!f9+4a?#cA$Q#<&lOE>eRhP!V#%zuBD
z+yu3NofEzERhDhl-)d~MsKDhof1yixsq{28tAwrZmiQ~1X!7oTX`8dX>4tQH`P8O}
zdd43yYwE;fy4D}by{diV_spW%J3r{gN`1PM5vas^KehM$#xL%_ejc%_xcM<;M#l0!
zg;(>$9?TXJRZ<RZ?On0-%Bz$$)AySG&a98oy06&3dDXPVSJZjA{=caZn|j)jpKoS=
zyXzJ4lefkBrDYvz^F!YsHF<YDJ@1QX>$aowP1i^2l(2r}o3K3RseI%1$yVz(=zD&j
z6~(eF-(pQ>XZ{@ZNlKr$m+`%upea_pGkwLsl&9As?$5trz5c?@U9Ly9OAoZq={Emz
zz1n88%z1qYwa~}?nQa&6-qm_kR%7sf?vxy^HT}z99-KP+GXK_HcQmr6`3W0t`u6Qh
zu(HgS?0a@LFI|rchdXLYSl3!vtLD__FW!2B`$X{G!>4CTp0+)we{=JdT(hZlLgF*m
zudJH)XV1rfJ|7=xFK3P|40q1I=07pX(kxZjCiHQ-!S**V*CtOi`rs?MV?*vc*MfI*
zPAW_Jw5{3jw%4fU?HgC#%WP#~=L4UAW)nG6Y@=hKyR*toTjv<l%uee>E`_T97FNEj
zA)mW0{j&D0kW25bn)Yqh{H+JRRPDR9PuHn}OaIXO9IJ^kCq?%kUKJ3=qNjWR0MFH@
zjI(EM?@Z&oS7M<3cSd*bFNP_s-%m`JRjN0!;Iv(C`*rPk_Ps~nP3_NTc&phPR_{_a
z-?w7#)wT<*4{Tlbe$ptKdSmIkt-QzdI{0Sh+iaT8xo62V_RQZKqjz+8XFY!Iap`)k
zmyK(i_7i=h*?aZYoc*iqHgAh)isgz4Y!jdCUwrLlZfvRPCml;Yquvz-sq<$Y*}LV#
zuM?k6PGWhbI%DtoWhY<M|Ngn0>t?gp-c!t4sWYECxV-t{k@jHniin$h>9=%F`+fX<
z;?d<(rx|uPerMKg{W@{W-(8Bb*DMWIztj%xdr^}6IVV*5V9{TPY%j6eZvC@fA4IO*
z-P={RPv`NSsxN|0lf5t31$Rt*_Ah?br9`8D=j_Vu?^Z`zI{sc;x$AFDpSrz;*7iur
zG@eN*-K^mnrypenaK)}zUuTtiNYS>#;OD{fnK$=5*tjuv!KT*%Gaj6D{c<{uNw<dM
z;#`qqW>Ttu>-Kj99oIagzHaNX`$d%*vQ-I_H<sx%zOOP}pCs|C;7!KGt$z)L*GDgV
zx%rFAK10z{tIky4IpmepIHQjL-j)4Fc#a+^UTyvERJ@I4jb+Ko)mj@QPR(t5Jok4*
zPmN7RmdNvSHhjOFp7T2L2s(sp*m7PgIlxGyFr?*ql@^Qh@=Xh+ZfQkqI)2l8%iI(f
zajE@!weMfJ*D(Iq+MKrZg$#4_@|yP(Y;H6eod0OpzjW2%%gpt&HdjPV=3gciaph4<
z@9!32>7$DdoivsD(>$&9?~Pl_?RN3=dsWu0c|W61(#HAf3DZ;VruFPC^$`YAB8jIq
z8SK3<L8<%Ohy1eheVQ9yeaV<%V!v|ks-%BW=6UjgK`Sid&u_7_`{R3iW!yd=jk5xG
z7f$6~d~NY$fv0=Cr`+)1;J>wM<<h>@Rf3a`T-oyRQ6s<0%q-#GKT19~h#cCyW8=LU
zm50u}QOmVmR${qm<>#N;(~2H<zKlMUv$6RjYq0UTmM?*?To$HRY6}~u#Z|<w7X6!%
zdF9@M(<v`grmQvovS{rrQ*)V&T;4@8{$00j?Y6d+KJjn%wd-!zE-Ti)+GcJ&ZQ53r
zw{kJs;!`d2l(GuFO+%(H`MO&2@yX|njr*S4pL}&y=7bW*QH^6cb9ml&wCOm`jJ@HK
zr!#fdr2RT+87~u?CM*kBx>i$e;R?6Z_BBg(y*RnsxL-VfWBn?Q*`^nbPGmZ;R9kyk
zqzI(T?pN(S^KHfC^*Q;RGGY5)KE87BR_Nh5_o^Q$r#C&G_U&TSgkSIO3n_b_{cw?c
zQTsWgG*RK&uhpRo1fn*3F1x#>qslehP->;GwYg_~+~)Z5&l_j=#vNuee9iQ!CHd$C
z+oxCmGd%jDn2Ti?)XV^57*xUB#83eO2v0NThWh3|G7#DGJiLN`>MiD@WgbkTPMba}
z7T(AWU3E21(eSRvgarai-tLd@k8hfu%fH~`=O2~F<j&mPKK-mq=-YEXhuqJ_o!z;&
zWa-Q$_qQ*9@J=uL^y!NxfBBQOf_pbVSO0ct>(gUj-q^*azh3rEUZ?Wzly>h_w`<o`
za__x97QBIfcfIj`wWo#O-9Mas7bO2{*UW+m_h0=>@Qgoa9G$Y=^_kdTle;_fW~-~o
zSw7!3!94VqT;gLHA9l?gtFGJEeXsIX-Qau0q!<}G{jWjM{ihe_v5V!~o!e`<Zg#D-
z&h(sLS?cF&zdtmwW4Zi%ol)%FJ)3_=XO?9ZTh8TUGm_vB(+-=t_ie`C|2O1#XV<;_
zc&hTZg{0cuhzaX9tv&N|i>~kX+<U$op41$j=DLx~C-|@V^b1{g>z1fZJN5hrSLhb5
zX+~Qjj%gHh=Q2)Sxa`m!u|tO*b#RHXpN@!_qY=KrB0_D3PmswYCR>rJ6-P_OS7(Pz
zIOFd6^nI>*#`A|vr!AzsPbMdLmTEjuOyspup2O_Eg_*sNbGO~$b9uTYUW&2)MuNwG
zB+U8sk?HZ7{@|X^^*@xC?^xTYK8IcKkq(Q^jmbU@s)Y;vE%;;3H_T<9Y1Q{x!8k*-
zgqN#bM`)Gy1Ix9gGS7R{`<%-s9PTc-=fd*8sYbNVe_qh>lby<qC);m_bM4A~F@4fH
zLuNmY!{r{fq85r@c@A>E>@oS`;>=Q@CRnIcuxQR7C+Cm}`d@l1KQ2@}xq`3G=?_n>
z(508}f(kEnehxYG+|6^owCJxpD`uYW?W)NOc~iVtXukB)nmmzISI2&-J=S&4J}>!n
z+h*k>GyhrlpLuqlue|iBcwWhi&r8zn{H;D!UfOtmvR}=-FL$1M>etNM@~QIDt>>Q0
z?fk7iS6<qAezIQ8yr6fVr*O?*9`eg(>E_pScgFAgz4USJA@8c%Z>PMk-xR-SyZzn5
z!@}X_&weS*za<>Dv%mV(@&9~1^SU4CJDgb+fi2e<4wGDSVl>x`<{GN!nyS22N!W6Y
z5tdwINJ3o`0;+2S_9E3ap)D!TogZyLs%unae!ahL>@30gm7z*<zvTWid(IqQ|NZTm
zD|hdmJ(R9#cjrRvuTy6?-QQjO;lqUTt52WY`gnEct*e(`eo(sid)=*Ffi`KgYc88T
zo~)jK>s7_dyGMS_Ot~9=*@*R>VE_Dg@7Gv`Ixl^aQ=i$FeEFQp2K(6`UqspqxAb@I
zUU6WH{W|$s>uLpGMS8ttc8yNI%Xu$_<5{?AlHE&dlia)Us-3nRJX6F<gL|*5|5@+1
zPj$kczjAKnx3;wFc?28&|ImK;M*ZSb%M<=xyS^^}mj1_z<!9&T>OcQ{v5`-)`D@gb
zcMrUO$?bXP=Xa*Q?yU67&%fWa97}gSwQ612;mYuxb=T{5DoicXy|gKYecjsk=aNp{
zkXOrkw6ch^eqrY|$5qb#r96x;H}W4yOwru%r7@y%js#DI%o0u+HOVKQteR{=XI_O}
zIXy$qXOXAF*Zk}8OHUQBW(sj->n0zV^{8MW4`=iN?nA5(I`SqoBp-@+US<5O$#1R6
zwJjat3nJ56CeFWnTD5`u2%Dv9(rf9NT31#&b!cCBIh(m==}P_uj;%-H8QkVtIrF``
zV)-KQN@TOCaF_G}?^CXPucliTtvJv6BHV&Sv@vaJ;vN^fm**!03%E0@{jFFZ_N8w@
ze7005pM~O{PZqoS448dPl^?jU?&ZGH?{$giPlS;CD|O4Gjq?TU+pRb=4@63MN-YR?
z`*^4K+0NM$p67|#lnZ~n<9nvqob&u$iFvyf4@+H0UJ-ue{7wF43HCE4{Y_B)eNgLL
z^VK)((wpSpH2qCb{?^=kliw`S{)X!BgX?baU)vzRCe{8%&)<aNZ_T<l__w9lr%d`g
zLGzpQvYY%jADM~&vHF<ZQp))H?Y6E}-uHj&wpt66^XJT6R=VA^^4+-!t@d};U-oNX
zzTM~t|J2XZ?6BnvW6XSEVhNpNCT5a(vTy!k1A(^pf4JT&230MX(O(nF(Rsx2RO0Pb
zond>`zNxr!u}Mxa`(I}(=W#WZ&#^!Kp5%V!$tTx;-#dTxFP6GLXKu1@Da}{;G5h}U
zW3zo+bboV|eCJx=(0lV+>)zQ>?-nLsKI`|U<fd)pN59kA>k~q3#nwIydX>+4@9;AA
zA74^g>z&`t|MltC)LYLr?55nk+9mgFChw;Cj?cROHDsQS+P~q$%;G%e=(T30t;t*B
z3?dQ_X1t5ZN@cTu)ADYQLDH%zcMFRABX53hJo-EOw&T{z&u@7Li`Cpnxjl3C=O0g4
z^W7RXzqb0;M{QnNd*3A7LAs|p@|eh+TzBjLuQxJ@+06O4&hm~_!bI!#C*Ie%ZavdD
zDD#zd&y>$SOI;^cF1T91bK#>Bxg|-7OOrC?ZO)~yOFDD3eC;1ADgEBq>rcz(M)Jvu
z7eDEE6#ZnzBkd<GGnCJF#J-*Lh4oX@Bg;>dEL`FQ^CuKPlBo23^X`^_`-!Fqh5Sz8
zCr$61=AV2ZZ+h}UeW%Tj<GUvv{D0^ZSN38Jmwd}>MRE^y4i)ZkvR5jR>ig^JQuszQ
zDQQl)%8?h5XI}X3wkuA$p6>c4tMHyi&$GkV3-aantGv5g>zR_@b60-*oIKqEMK9j(
ze{)~4t-f<!_umiy!<VBU{$*zIk!i=4d@yhQQ!ukMgS6m@Nj_-Bs=P`gm*P#%i55B0
zQ?s^)d-#|Oc?NK_|NH$_T6j&Et$^>m`)Bri<SzdHy43n&==SZxUr*eeZCgHl-<HX5
zzP}T>d-rK<WoC}GO?33lEE`+<jo0^SZ!b&uepBuKmaiWkoS41MCQi$GQ=OXR@4)Si
zO?Geo-TgOrif=Ht-Ocz{j{~*~^L?tem63gUy!e^JH_?<SUygr!zAJnFjEX07tP}2r
zMP5(nDK^>bm3TSu&ceLa|5mlXU8pBCDYVow=KhOFvv+nA_WZTs-*$6LyIz#u%`azV
z=e7TvY+~nfdHTLhwRh__{9b?Q&c$y<R<gP&26Ah|)@))Azj*flo@|}j|12K&e*Rav
z$>-AU54%pS+w}bMx-Ea#{oQbJ(r3|Vv7=g>a=*UyDVo2@zUR)B!k;qyOCL{V=6Phw
z=w{)tU{;6i1O|t$51MN18yFUFp0HrJBCwNPq~XxfpbCZ32A5qi0$D~39@E<xRxP{`
z)_8CylYw)UPwWq#LrEKwOD1|U$#P1pOjk+BD7n~eFy~l|Tg$^9CIkM%l1rq8+lpVw
zOlW_|la*q_Gu@NnmD!x#Uq4o*fBv}Zbp7ssuXw__mlU3uFln*&bh-J;-=>POeLQnK
z`^Y^eUS7S<q*cXp`-@(RwJw>(`jGXR*pcULN$+#}B7W^_@xE_<e5=QOb9dR7zr|X9
z@5@UPUv8(ymv!pKgso3X=QOV0BPsN2>PN#nVKcu^eRStB>!Yp5JN-*luFfy44}T#Y
ztgmWV9rHt?!bwK4VfhtrjSP>K(?c#ydp56mx7SL(^Nr`%moZ(x^ZKA|w&0&jMn9H@
ze(*lu6mP{>_fqA@(#sE~UpuHjmwkT^Pu)z{58A@!`(K=1q|f<3=gq>~mo)Ti-+$xO
z)s7O55Gc*g|NZ95+zGDsQ7w<39lh->_?Nx#ZSxUq8Nn2@95u5v9cmfj_~gG!?f6Qq
zA3oT3{qV)YI;%9k<ah%&&H9}Bb-TZHcDkS2$$Tw$YAJ7;h5O~zd}gv!WnXQ3wLa;F
z+$AMYPxkQF-g&8y^_WlIKL0skwr}-|MNcRB-oNv(@`b(ULuZrPm)f_lzh&S3f6<w_
zIr_^lUvy%9d@<{&R&@dE-8biVAKUcOpZT7~`}yjpRrYePU-d?-+U~8_?f19%rFAXi
zH>L)zQMw&=|D4Kq&EJPl_{vT{|1rQS&hmgloNz)5Gs~*Z8_b*xOE~5y6)|u#%xdUi
zcHo^@?ZBuJqtnVB#O|@=H0we&=7y3?js;R&xuOztv>A+-9KX_fUO|V=+D&|>%7uvy
z6RX^q+T6tVavaV)lj<UIPJ`jI!5qh3hKUx-&oNd?oLk^_>~O(MmIZl-cSg&vFE^84
zzx&Vj*Xz#}Y;}-o=h3v>RrK<sWm0@*qQLo@J#KGwFI;#qNn@GS^`9Ek^8!6qMGC|v
z<T=*lX?(l)tYhhW?;T%ii(|UK)D~ZvxG&#v$NSf6WreSjA1zqc!yD-xcU<zvso9DP
z<0a(}=T5DR*F0w%rw~^?=SPTp&|k^#<*oY+zXl0yKHl2jsD4C{slsb-OH<pFDo@tj
z%y*VMR!@2LLFUJwEcJr3d*$wI7CWe~+Z-Roy8nyLkEM?vO!sSwx8kkKl>Kw5^26y9
z52i=5>^Ca>+`Uid*Q5{UkBRMi+w<wt_q@3mRxL7ZWDVT@ZQEJDyPT0<7Moh=#qQZF
za<RVidD9DQ`2cf=fx-~X2g^tE!Dv1pDj)2A*z^foJ}}3u56q3BJ7|b$7-5cWV)i!$
z`2K!>{ZYB%<~If@`~LaqZw}u1TM_FYayR#^O3jluXXorHj-ToIt+<%y-MdfgtmJ*H
zZKQ)|SIx1t-FSW9>T78U-*0NgZ$0}V;pFOVx8`RXZ`!Ax`T63Oc}=x9{_g&1yOMA3
zgUN4q-sJZM)d%K>?-lKvown^*Ue+1ipQ*osFK_ktu_-#2yD;PR8tVgxHD|<?Y<RgM
z=lYh?dcninCWvvIe6>tUPx*VS?3=`dkH0>f%s9O2ZmHv}O)qE9wc-7{JotxzPyDZ2
zUwnTbe3w7v=FG1@EAB|INU({}i_9(Cw(#q}J(dz?f6qOb`srV#iO;T$3ZbFlvo9A0
z&#b##H$&lR&B;rfV%V0g{Xg3~<7k<Akg)gD;+j^iD7KY6y3-7~?j%JYNLjJcV0-I^
zEf$NKjyg(lcMCt|5@XM7I;rBUtarhAVS7|e`NmyttS4(iLjK<TBL3DUCPC6YS+kNy
zXC)u2jmnzF^cL<19c2#=7$#nSzG-tb_uL?l>yv$s7}`ms*X=oA@%=H+<45xUPH5(5
zKj3`s*kZxW$p1}6IKeaKh44A%>&6Ms9n<<A+nkVzVvTJ+q}bi^imSpeTlRS6<DHK$
z$clVWnqw|_aKA$Q(#MmRpDE;e<dN{{;kT(xdD6d@F3CRAD17LHY>+>zpNFk;fs>Uo
zukA%uCX2}(7J?Rmj&%zawN8px9h>vx!h|Ow?DmRveRiBLOUhSTygX8=^{{yHlJmV>
zwRu<0Ja==oGuQgIGqCe~Z;+jN*QP}a+++7x*S-6^r0cfL%1_Xd&GnU+K4lXc*#r%G
zey_aLdVaEA?L4D*pQmunU+(kECKYL9)4Hnm>#E}Wx7jb+ZUc>MUf=TUmz?}=Wzfjx
ziR1fud*V(#(Es>(MF6%ugSjkPVF>1#38Q&tG|$w)W&@~|XS64*h{Bd<EV0xxCI-a!
zJ22`Q9*la%#na-;{q^(ZAL`zgb9nsx<L4gR8N21z-=4Yd*50|T{d4x-Txk1!>D;CE
z<*^0j)3-kTnKJw1&0D9!F2DJ3B<}aNJGUm@T|PVK@|DNU%K5WCRjhk+<k!5EH|}=@
zSidEHfB)_K8k?_9XTLrFWpV9n5A*lEa{Yau@0t{wmIWu*oz%b0UwYfd@Z$-~^42{o
zFMVT?YfGrRc<|ZeP0n{i{<`wqZr<YH5q9-yh2+oopPukBi{;z5Uz}%lb|LSimb3To
zJTdq-KklKkK|QGBah84e{=jEx+n%qpjtV$fu_12rDY+Qu=YK29H|6}Bdr<r7-_4tS
zer<FJO^v>}@b=Vg_f6%^JS^fjFVVQxn7iu#Gm&*S<keOch3sotAK?C4VdBEWMr};x
zH$)SROd=w7IYn5=Bp!UI(Aj#}>vz*($3+Q2OD}YAzgW1iJubGqaF-fumZhfF|2Mz7
z%jDK2NVXpf`XsU8h?T|z#U$p6MhkYChkP;xJvYAZeDmgdlb`02_nm5wB<u|QGWRqU
zx;+*-_S61PXYieC4eEQ?1rJ4Xe0bm&#5nB)Ywe-x2WgBqswb>`Ucqm~yq0Ob<6%Ya
z)>7Vz&TQM`)sJUBe<1thfony+64QUCTG4s^^McNwoT$vWn1BCzk&4?3;=T49<JsWE
zv(Nd>%0}U&^8yx%^CmKas+s~d!6KyxE|$Moc>^2wEl58zkzXpLt@MHRlk^Mj3;pV+
z&sywf;jgP<9u<^V;<580_o?1K4RfnycQRaeUYu35*ic*Q%Zu*v^XE1Et@fXtte5vW
z<wx$ko*%Q+mG?h8*)m0a^8%Zh9iLK?PE8J+qP}^F%}mj!Co@h>Hk_h9IcT1bTcwfZ
z(~}}omQM+u7vxy!rTSDeHs<}A|DXQq%idF~a9_VZuJT>=cZFZaui2M;IC8aj@4n-)
zw-0Ll|H%LI%XY@a)0KX3?=D_Zj3v{UW1Dz3Afa&<0v`0-`&oNWyVqOA-drXX(XN!w
zicdG>UJY5jSM5Q`L?MS3@MM6nQRr3X7lw7lb>D2By}SOpEbUd^`?QCPMe^U>iERT<
z2H5S`eR}t+qN2Ay-o(6pmHG9LN?bc=GT=@+cru_Fc{0HLvJvYy!SC-ulL5RJVN(GC
z_h)~6p=rN{OI|46nMwHHj)!+j-cAna5Au@NxMlU)ub`pWV1JjuXU}U3GhaVk<?_Zc
ze8H9#v$OWpJ=|^eb9Td%x6dm}mitz}XfhG~Y`(ujuHFC2cY!nUZMS%Re=EM*&-I!6
zw)cH`*$x4ti1n^-`S#7T|Ni;ilOuoHFW;4TKYy>V)PB*-Rl9D@{T=(XE%x`rrjS!x
zJx&+N?%4Kkn^^F%e+GfV{!_gxTGgW1SMu3jGh|tE+>W7p;?e_`*pr?XCK)^^oS?R0
zM#=<r(IpZdhO46k^^<QIbgD64-G8@Ws@7rAC7v2<w)QY)cO7msQpsV|=MZmDzU9c&
z$C*6$^|=|`R$DJcTvm!}Oq(g_R_E95%^=>vTjX`*T71f?faP3@>l~KvmwBM=`<+25
z#N!WZ!j+ZAPZs#iZI*L2&)$&cRLET6x$}hMUn6(EyTy#ZM9mys7euB?=uh<jW&A|s
z$i)Uv`**8F=L&ww_Fa35QN1Nx&i%SrTEogTmN_dHY<Bp&Lgnm%e$|f)>m~)u{NVgp
zykhbMwl}R4moUCNrSWd}#XIG~MfcA({mxT*x4U!ad$ouAqz~7cr$jJU@!S>tSp2P7
z^9KL26#IyibsM_=CYb&{*!G5fcY^(mj=u@X-<o}I@Ryye+o1ie+4K#2_Dz1XWcwR)
z{w8pLYu3HVKQqNXrR(p6%x})yc6??1@ApSKG3G$R?z0PD8S&J)Jp6L_CUfxe%)7Y`
z-(vYAe>_N;+h$R-cgn%~0<Ven*m4EdiDhb3CAU|FtlsOCv}>Y5rxU0uxnIqxhg_BD
zBdU^H#nmspt-b5t?Sd@FIB9lRKU+K67rY!}`_pTDZ|v@-%w8rZCsTQO%5m>h^=sc%
zlJCDh7Mvho_CM|anNz{*(|&u`%DhTD*7z%o-`)LZ+O(ZQzhjbiJlOvBJZe?KcJ5$}
z$iZim*MO>$6)kTa!xdCkzbcY&{}DUyj^}|#Z;w}QSngY#(X5jAIo!Nb?iW8OSIqx?
z>RajObMNfAi-m7{UzgSGNU(`mADPO(ZvN-L*`TVVcenQAw~IIXJc^jGY}48|JHb`S
zd(^6AEzYVWBm!KO1VXEl<bw|t0u5FMWgKDsa^ZsW`gOZ4Vka|gog*@}zWncsx$W8!
z#};m!V#B7hl8>vx;|4>Vz&S?Hw6cuwF}ug-c8HaDDQ;As*^&I?fW_CxqCLj;eu;DH
zANkLDw2jTCQO<=UUGYG(wI^$YkoXtQF9*&t8B|TsEV|Hq#$ok>><a}aoC0H+<1R%#
zSzta-vHhI_yFSz2PL4m^pF$Pp+blhCvQwFHGXEXWVvGy=s<Fvz5rS;@6~A6Nz_~J=
zW6p$gCmQBu^f1ivbeY3p5$IRv2wIKtLbCW#GuzZa*&kg$B)<eM5q=+3e2Me<%GUF}
z)9lQxzU;inJzrY(=baZfp1Wz!mtI?&XOimLEN5Hg4qA=z`L@l=M`r$Q_n)2YSYK)M
zDSMvJi_a-ycK&LgDvdUtpB!lCpZ4-|N|>F$+ix4m$DdPz=BrQsX*2WA^OGWW{+iz_
zy;{!)Yt_!XboA@F57YbimsHGtAiCGC>gm$=cdI-6b?u;4$uUq>^5=oE-QVN`FLrYL
zV_f3AybfEY!8Wf<m3}@V(>N-Es*=a<1t|UeNO(X0DrP_bkI^!-uNKu+N&2<nYtJ5d
zw>flQ*6fD|Cxz#3wZER0QtN-|+1^ZB*54a`n}1FZlKpiwr8@7M^JPDa75Qg3Y@d>!
zHdA-wdDUlPf6V@_e0dA9f+=82={4De2O>WDN;gWTY|Xy4YrjTf^b4+*l+s|{=@Wmi
z<NKzvq2h0$)S1Mq?{+Ep-u!aaZ(iHK!!N5jmYuK7{k5z%{rmjZo1Nf(J}A?G`}y;~
z{>?5n$oU1%G><c8lq5UOTD8t>`Qv3qf0xyoJD&PEX=&<C9-rv{pcPDS^WZC(c!DIO
zbdp7O9NpG%G9WlHk2^85(1o?T*+fiC{gkK<-zApGo^5V13)-Fdx9)hCRNBim>F0_S
zzjnXWzg4;8fKeZ){S^@;%T?hK!F--W{D9!w1C7at)}2pH-!5jgbiz7Nrl~PF_ot$<
z@ZE9AV@K6T`}s)yeC?{*FQ9(@_Y1aLVf}n5Xg~kh@p_(~d8Z%9-`%^s16!WKGUseg
zQJ)32?r)pc)vWasX5^`O1PEap8@uZha`oLA@YvXww>!1Zs{Gw)%UWI@89lFmndH3Q
zl|H8DzWKk|nti%g@<#2hbJu)rZ6ZGH(&T@Bs%Oo6&s#NDdY6OhnY=pxQ_1(a?QYI}
zeK^2e7(8jH^YV6OTKAi6C+;kYU-tU-w#uYO6N~e>D}$H56*T*mP&M(;vc)@U?}prU
z<-hG13$AE(^xP@0-15Bf=<M@#2FFV`=Qo2UOWvf|m(2Hj>}*i`QtR?nP@iRL+H$k!
zmtQ6*G=EIknl$z1?Y?XOKYz=(@g=%H{M_&7Ck<X6Ybu$VoBHeWHj}&Cei|HvP8u5c
ze!U;#q+RxV;;aa*`H!_jE^0-bx{xHf_<-&<R-d+6T*c8G+}+Ar5i&Z-iG_<|4n9hl
znPB93v4i_dz>9@q*JIbL3v@J+7oA$a?XIgezj(y4ixFOO%-*Y<8TmQ0A4oowu~;N)
zQQ&jq>&`cCt~o6ix%5><xUh%+*h+bQgL8i@j#~V0w=e3tEmd)-Qb6&X(}8B&lPnQJ
z;=fuxANb01qjJK^#}@oX&0&t$7ZjXOTDXg8-sPy{h4(6+S(LC_?%{au>+(VWMEJuW
zPc%#C%&`!fQM03V>4MvBb($}wj32ZZ)U;m-ZWInWFED4qIS*(5l1_$mDoTDVep4pL
zXLN9VYMp1OZfBw*dG(-w$NYu<PF8ngwfw9K=Xw3Oqw%tMvD18M)6Y8tC!X)^s?7^|
zRJ?e~`QAlqG+qRXzwev>(`Mx#GyhdP&Q5-|z4Fqd?0H-M%u<*AW%F|8`N@4X^Ge=)
zULrhS-S&IsCGPp^Yis6h`Br&p<@w3yYUY)^`@DpE{_-imZI&K-t~u4t|K*#i^mo(W
z*S)Nm{b5qv{Jo#<lzww9Ils301*p%mbKi;O-&#W7J)ZaJ<9=pvpJjH*swvnq4VIbq
zA(&~-tM4wZm3WnQ=wR*o_U5NG=4W$y?_QY^{poZ`?Oij-fU;u#sx7vMoaKG=t!|Wr
zY+FBj)$Wc&YY*<0l+akd=@WnJ^?x(iQ1SUD|Fa!=-*Pv^Y<f9+?wj^^mo;lRmg&c)
z?%MS;;k)^%H)o#JSjqB)7|5*&TVqsx`$ARyJ<w9w^bcN@|82laWmj!l>r;Pg+Opeb
z@@f%9`;tyCieO!~@*ikGInN$Gpv>xxUeP3iE1Fat9lt5s5i&Z$K5Cj$g^hAtwpSkQ
z>b`2K<?(FsqEF|y?Z&@UcKY1AQ7@)A?V6XO)c5hA#n;EI$7aeemw5jFgS%g0G_$`2
zztWLNj*1QHGa0-eIn6JS+cA&Pn%}5Y=DB0q1+5oSB7Bi5A>jv#qh4E_lRhug{!XD?
z{NbKXj(@B_wPfboEbW^t?9McqfBSlolG~8h*&Knk_Y<nL3Y=a^HVI#n%zV+QCwO3{
z%aP6lokgFxc>^8yT`+!jq`ggLvDFXGkH%j-J(lnGKI*A{E|_z^v}$c$$cy5|X?EsX
zpLParJm2e8lQ-ql&cG?6thTQn-Ti1hUw!KRXP%<lD=+;q^N*@IJ9%3C=Oxbb)onjl
zUYdA*a$oJdl1HDHJh$_&diZ(C)bo?C+4)<2t-Lhz{N!`B^GY6mo>DY_dB_i&rI(&-
z&W(M4=I^Jw`m*`L_b$F(9X@aOIlGQ`8%z0R=k3^Kc>Vj2EAuv-s=ecE_b)f$OAt#v
zW0LgB<Jd9{mRWgA1Jb%Qx2**Bybj;c&hYY}sl7^&9uM=96lTjW%)TE!tm`}SgtH^n
zc^m)F@BN#zXXj3I?zvj9)7o05t$co+-MO0m^?k;lUAy8x?y&cdonv}`Tl=GT>+Y66
zkCpMipZq4dKGwEQ)P8yGcM1PT`zkZ!k3IZiscPSI_x8^I>udTaJJrY@o6}_X=%404
z>(^z+%T?3QKY#evq{q1P$?}I^rcJVo5$6=CZ)!68E4=*i2KoJ5UtPUsHhjHd{#*8#
zh1h3qQN#U{swI!r?fM{iJ|SE~_t!$}*nKay-&VEV@blx}imu)5A5-IXrYHT=)|K<W
zY+d*#=1jd$?VPrcp?Cg!>gw9g<8R;2A>|~tdg_bE-m7Lj`@iq5tKt8GW6|d>|5oJk
zz28+?`rA&9|F)jr?T@Bn-kRY_J8!P(viMfNHuHG&y!drHOHWPp{dKV_aBbJpOPXPA
z4Y!yy7(-ZY2sN-iV5r#7_<)h+-Xg{Y^Rg<t**CClP&~kR;R?gltx*yTR}L6GU<j~P
zS{9Weam66!aI^c$pqPc*r)cU;6E)I0cVR`MVoT^A)+0J?o3GsV_^@F?f;L+g!-d0o
z3_DC2*!|9Jba?S-!;1@H-nzmM7%S$hewlH{n17b)0>=%Jmm8`Uo}0yXg~KjeDnNP7
z=4FgurDmGu8iX&-pSA4pzIj<|*Db&Ecl%tuwhK`U`$AMA81z?a=4n1t4i}l;lCSY>
za{hs!sC(R!D&C6<OeXb3ZPQJ96tmWF*_{nuPdJ|iD7k-}7;z<VO;e_Tz6JZP?2~Z~
zhoTC5tfGp0_Rg}LlCogdTBo1feVX@+eSYe`XEopZtfFzod9TLV3-?`0Sf4oW<X+9R
zr6*O|woYO+oVkN5<ziRzD(5Ik=btu<S<DX`d!0)ETy-Yz$3G8=6C2)&K0FiISbuVs
z#FLOY>l0hM-mgEVBO1S3YL4#w>CFDGE!fOY*UG-S?Jav{%bn>yIXm;cKhFB3eJXve
z*O^Cp`<U3>qbiv{@9GZw(4V~4#A3&!_bhv!+z2oE8GF_$pe~{RVUNtmjnj&v`U>^(
z&KkxZ=RN))`2RCW{gr(81E&6cU;1so`OW|P&iwlx`fdOAoB!{n{{L<D+y2Cx{|h$#
zZ$9^rU+uU3l$-w*Q~tNB{oZd_Ic?dVvmV>$<eC24`B-z;Ug^7)vo1|`dM~<Hq(ZsP
z@ZP*FhyOLiesRx#`1Rw_>;1kT?bk)TlEap%u`DsLu(Tj)$a~Oa>hD?KYUJ+u9k!T!
zqE^Z;U-S9m)QJWk+0`;m+ZS5#{r<Q*Ab!ad&WQfn&G!@Ak`4EN5csUUd3xfT<=m1V
zd9qqBEt21L`Du6E?pPt_+4A@Mm+z>Si2ru9Nb}kLOOHO9>=izI{^+0MSB_^&#2@`D
zf9BGu$3F`yx)T&rHb!;Y?OW26`R)DfSdq{DY<rg4?3G`1;mg_?q1)d-{<z`oqb;)W
z$s4B>sZN`Hc2!66|Le2L_B{RhbXN58n43%F*NR_V6`?gZDV1Y|ZiA46YlALh1Os2g
zcWDMWhX=Y+46jyB+g`zt%^=Mr!{Eys5V^XQ(ScWonUCSBa?&c-Hb>sWrZyE*w2q2a
zdCz>56sfrQ5l^p_m{Y{jXooXN7T$Y%S@^lRwk0iKW3YY0)DX>F@ZgCIcZ(ihH(&17
zD@KfR4c{Z3`cK+^UJ%J7#WLHJcZK+?HJJ{*4>m7jG(BXMEfuhSV&rAEV$)yCGOgac
zUU}_R)v3Gnw_hf4tQCFb;o8LdVbZKe(~|6pTnjyav?ba7WYbytbngVmO)6aO$}d->
z-d0jOcU3C+6z^)6c?o=~MI!Q@uChn9X0Uy1DqgUA+8b7lHKNB?EH*uUWA#jDPqtMz
zwWjQUFyoW$@hSH|#T8u6?i26$xkhA%<ST97Z&J@@-kF^gHp?d|LR(T`a_4FXv9%V<
ztd>kQoO0gStH9W1@sb*|^~c||z3*>n<hdOucy5m9kLhbV9sQ2}lnPt%<6qX9ppRQu
zAH4ag((=QWzT|?<cdjqoxA%&p@9El;N2dMWCbC|0|Du{}tB&Zrd!$`Zuw<&a!TQ}9
ztp6>pc{Mj{|MWZH-B;^6{r=T8%um_BNt`<&D4(sl{OODjrpHTU&1IVX|ISX|v&5>#
zIrQ89>o@=3OZorX==c5boB!{n{jZ+>_x<ZP{}nd>Z$9;p-|Dyhj5q%S(*Czk_$xo_
z&HrOhB4>RvQ@&fY>*|l^eeEy4<&-?n^wQ_r8}=pWL9fKIis}n|znRM}%I|HtUM?PQ
zZ+7%Q|HYSX*s`>_f`LMQQWlqu4eSgog`rzdn^)WM=Pys3<N3snclq`ypD%9mnDK*I
zc+1oI7P9Sse}t~k4?4xN=J>vw?+p%boDpBq@pJ0U(+1xzxAs)9ZFS1L$ba|cC)fRV
z^*S5R_P;+Ke8;v&|98?(k<am&A1h|v>wNe;>0k1z$0j}NAN}J`%Y6E=#$u1_27yfx
zYhC2ygASVf{{B|4>!&;Oy`Xvb_yaS3g`HV-`}@a=8)b#J`qpoZ@Y*SK`fOV0k&XYe
zeXZ|(`crgvZScCBOa0fnvqE*I`fW5~xgzGkxj^Z_GzJ|8_5;6p8Tb`Gi19Lf4LKcc
z(_q@b%gEQTjBUl5tA`jCuuWrRZ+InWcvb1}g0_cJayDL5A93wn>QlIJ&4j?hHaA{w
z#Wjy~719jnEWPK})XvHpZ5Y7ZAXmnCU@fCXK~W#8lX$yp`?jd8nGE~~e(Nke{$yU|
z1sz7-rn9ryu5g!LGg;vFA@XvARN`Dy-WAtRtjTQNDOG#fME2X)knB?1r|<T^Eir7l
z##OpR=^#^ur*EORq5RH8J5*|%4d>S|PrLLf?u0_5Q0wA}C091(3JO2Z>NR}Y7OLcL
z&@N=z)qiABUy`U#bHzc+3$fncm_)91C11HXEBVdUGYeIiujYuJiZAf_IWPHCex?47
zm!`+LkJN;5-QoE<m93ihv(GzULv3F*!!=WRI!+!5Rp<_r36{NdO5)UWN!1;a^8$nH
zW?xS(JN(`KkV9MUdXDsSTz|Z;9Z^{RsD@WNq^909ZRL+!S0Cj3+#^#Fb=+`A<h$1a
z_v2nISoU;ZO48}t=&tKi;sfonLzBeHKZ;sdTskE^<9h6trh1v|r3VjAtx<oVdVJra
z)9<scHGX2Q=1G6j(Z6-d<)WVA!tB16R(Td|^M9G2ukbAW(YESM{rb)S_n!RsJ@woE
z^_%|hJ^Syw-tYU@Z~k{o`_Df0uYAe3dV`z)7oPdYulU>E<mUh0lbcPR=DO{ATC)1%
zd0GC8Z*RUhcX>*jNY&aGOAkmJ_I&)dK=vE^n??3joa^7~?W@b_`p+0p`_cznrpC6M
z!<4kf_ag(umK%AMMlHzpPQ)<JBIuTz51ZaLX4upj*PXAEdRMn6FMU_m_p)Vjmere`
ztKWGe<`X`jG<&>x>(sT&?mq0?`z?3pR^{FP<~NtEJkHL3&*bUHn46qmZBN|j-}O<z
zqW$jv+xItrGP%}t9yT}qW3OC4-<P*`#hzueQzE{c{^ktrvc@Wbx~z>oiZkL@Z20N&
zF2Fpr{^8+o2lNC$i^Jo>e(3tYvs+N{+p_1|mQ23f2`V}No|(08{O{7ofAG)J^*Qn8
z@^Ai4n|1rvyxs3I8rdEntU9YzT_8L6-}AdCH~ri$wSLC;^XH5@vmN)G+P2AgyLRsW
zY`dHZ1^d!G1J^L$4*CD~Xvju;p9?n}e+t=owS%UnyHi;>^$Zzjp9)BNDYUAf(1TN)
z-BTq-CfjF+g-6njp5Tlltwo%?wqIUVbv-sUjQG?U_%r=_{Ep(SO-6jZOP>fHne^#E
zgLW715$>+y4ri-IXPLmBT0Qk--49colKh1PT|YFJzPhd*kzP0Vkkx;7`^2u>G7ng?
z1i0QgHL&T0@@!Pm`5?TaaW?Cb6^_d~9C?kH*EP*^JgnM1<CD}Q)vHQuTR-v`eqpoB
z5M1HgvLJrKI;M|HG+llCBsdLU9w=VA;5ysCpi9PS0>bH>wojXOB+3Z0y>q@8DU~HU
zcj<z#i+3d-NXD&UEEg40WAT}B*_L7Z28F#Bj32eI=M}nD9ys1|eu2NwpO3w!>hlWD
zM^)HozWlpn>i5ZU74|PL{PuLe=Wq3`?$WK_o|D^6K3o)k+i`x+`I5TV#<6#Po%s+w
zU-IMCbho;%GXw9Xr#-Aqb9!$qTseQ{jo)W<_MSg;>i3z9_r}S4&ilNoO*49LJh^)Q
z%tOC*p59Ae`N7V6>G#N8JN8NXvCLsG*qm@E?s#J5yJ~aILY~JAEf>Shzgex^y{%d6
z&%=)S|AG^~g8Hs6&#Y&`mVL0U>>y#18oaV&;Iq%ioceYB$#>6KB;0@f@rA+tT;u7<
z=9X=$`*ZBC<bFPKMEUt0)lbX3ZVP8fH2rL4pY4B!uQd3pxKR%O74YWh$EmINKRwZ7
z?%F>8aEAZvXBXH!4?WAzE0*}}pYlWCO#Cm<blkyr`7?ITeY^8@pIC%}+?wlaHnCs7
zkXe6kuFmXw^$%Q?|KI3L-XV5mRgSiG$?i+vc0W7J#`!#Zn#fVB4ZdIR$N7l<KFrc9
zJ4OHD;*uSFLXx{8+$KB_65g<qM|GOsLN4+4DFuZSTn-)Gc&w$nS*7i)MXOtk#&qy>
z+;WRJ;bztO5>xBT{<d0&Yim5d5aA`~sH4fxvt!W>hdm1{+AWp{TO1KQdgFPK(KRN2
zO_gsdf`Kgd5zFiLHkCfRuDRxO{RiP?JI*rtEnr*tK#wKkLC{eF??X)XjZ!-z9eSiv
zx+JbB7(dW@A!!n`sY7$UVqB1JQh@Y%0q6V)&0>wWTsVHQzSI)%pA~fENy|im$$U29
zTvfRb^i^$>*$fM(T?p3ekUnOZ_`ptN?$U)}7bCf{MDNaJocHjkR6)36qSJvE%e%}4
z+}xMAZI%5h9*Ct+VXyJ|!Sn0L5&8QO#g90@uW9{0dD=bys7m{nt=}i}?VVrp<nNN?
z_v&l+&Nr#_V3x1F*!SbiZ=dJe?Jgf(d!A?i*O`LxwP{bn=Sx1VO%uD9uJ*;wc;fe&
zoqNxpx%B(Ynmy-xzS$Wc`+a7~y>zwDcE&ru&(z#=KImQTG_LoXL#pO4?S4J`q00eI
z24n7LuS=z-J>OT}EYxnm=O9sAn!LVvSGM(vL-Kq-UcP4u(|7$K-q5_x2utp<z_P@{
z%-o3hPGZQxyu}6rdq0cbb6)yw!Z9<(Nm^Yg(i4hqY|C18HBPu-mq(|g1K;1@UwfR>
zcE4i$BC&sF<zw|{?~cFDTlVT(Li$JL^!&06{o2&@XV3R_zkBy-+pallrRT3*n`=9l
z&;QNV{MB=1Z|=SMEc$v6|GYh=S6>F*?)+-&dAt9ZAnUIUzsrADhs`}6_~GWmOLLAL
zJ8LoF{_KxWJnzplmQRUq=9ye~vo0g*J2>;ObA`|T#*@r*@sC#PS@pu>$FBYj<+pCw
z<>3)#ezoH7q4Lsi-x*KtKA*Vd`C9937pu-b%l}s(@!S8(4}r7szixf&{hjbVe(BG}
zcbC5Q6H76W%QaiG%{~6&`Tu+Dqs{)89g}_zS{C(aJIAh7+qOAxU!SwTT;43Icwge{
zO?O<bUHv~-Rq=7boE0;de^T9(G&N_@RuQ?=B20IZ<r@w!;b~mTzvRFPE}kU^0uBVM
zj^@2zx@!K%mGNKG@5fL5SRwk`q;IZ@KjUeE_Fp!95zKKcF${iA?0goy60c*dlh-xP
za!T^;tzZ?}$tm%(a)v6i%&~wIoW@!8`Pq$Dt~`Z|Ry%td^;0CIO*$+-h&Kc-H#y-r
z*NEL#DQ3x`S&<#u2To7umbr4i_=(05))(SZrYZ{}C3>cx;Qz&2)OBEDLv!65ZO8pF
z9w(+=2rs&Stok@Jo1fT^iu}{{Kf2m~H%d-b*gr*Oe~3@rO4grCg+6&NeKP&j3H_xf
z^p`fb$rQ{m{80QUQ1r=St&{F&PrB=#aMwNQE<3ru%F*ssOU)I{pDT<%1?r!4->W3Q
zRY`uUn*3Hp`BFc-S4}lnRDWhz{LEnanW6GCBk9vooxHk-@@@4Ze;#h=&pW+%*O$Hb
zwRdbOh&`|<W6s{UTi3l+;Fgc+xXjkJe!9^w?)APc*oHbSu&mw~dI`SJ(mH0=<r_OB
z+22(g&$D^HJNa4i8}FXPQ~J00eP7Q5ZN&TS@G$H0yu>!eS@ESCelB@)W5=%jU5V@y
z#5h6g&DY2OSa<H9kwWEn%bst0N{^dGt-tx_tUO=x|4uIXML)gcZ|^IVfAg=~sD9J#
zlDj9HxQ;D8+jjNa3+`Vx=YLN>{p>z(#o|5nWz#(Wh&hH{y;k<(+tjz;-yL?#K4+d2
zJ8kxfUBC8kR!NcR6E^)Evacn4%_QF~(+(xibZV%6!(1?9isFVZjUp0}jg2A_ToPHO
zs~_(6`)X|Wb@jhDzgHW{txuYNY~$o7nhBDR0_GoQ%s$ZFz<t2;#R10UjLCDe)6awk
z1beJmDY)K2$(&Kyo_}*n!(j<7%S5-g?{jqnmUk%XIjB!J{Lspi+{`A({*TGv)f6_%
z6~WIIxVLnNL>O}yvQ|hIO>F*E*(cMwgW<2!;x-l&?&gm|KOOfw`UzSH6<p}ARedp?
zn{%hoFRypEE8bTeIB=3l{(bIG{`ijt_6CcEo=l(gWO~<0{jCc7L!9bXPWclg`E#kr
z&!r_7CNT3Ev(@?8t!k<XQT@5X^5+WHpDR><u1NkAsDHwJ?u33TRryjkyH~0|SA;)V
z9QI`KwI_?so-96h(mi%U|1K4IUUm6i1^HeTd0(G>Gmf6s|8w|5f0Mn;wu`ytA=CGL
z&t?r5TgM$C(z|*4+G|^7Qyw<IE{NLq;cJjvJtNok=3m%Kcx)>#V0V-dvBRPkWf5QF
zF|(E#T3tt$PdU6TG<fZ|SxuK+vltjHzuaGcpT{$7^(yuY$$!%RJiB@3Z2$AQ^RL{U
z{k6GTGw#iexoxL@-8^6W{_dS8v87hG%Br?(+xE4xv_{~(bNJggDtVi8_vOxhd2ZtN
z+^>bJ-p>4Ls=4*OZ}rjy`NH2>^}mBnWu{KKw7&0O#jCdu{1<;xEsC4{@^In)#hlyK
z_QeQ?Jen?hY+1H^%dT=3anMq}z8AS)#5UV)w9vLQ$+bPBbW~cU+N*ol%4I*h?_Iq(
zv*pR%=N2~~Z?i4ASEVbapI11i%|EE-x$eBSTYSF1_44+IypY%(e7`<oh2W*zIWD>U
z>o$CTR#?9!>0|6;@mH_Y^IMnYAJtmDZd>yH^=~%h-(S0ZT9NX#)SVx5qW^E-_NZt3
zVIN)x-lXr7E+yvYI<=p@w0FxD4wVFzE~bY<jJ*y{ntZz*9v19+<nWM5^VQNb1vglY
zSh)C7mb_l0&~>hBmHqF;YkH|IYnMLi5wLjji%sIwl5@ogx5Cr46W%FnHU^(ltvmKd
z#A3N$$fFIHdKN~ye$Y9^xnASlB^k2=T5WQo#%`Ba?I|)bc^#m<E^>KW+Sz#-8J9OW
zXS-TFws^WpTk3b#I!PsS26uL;Z>*Nj7u5w6$oz8d(q1JW^v=k+|Fr0F<%Ays1^Z9W
zF)ZYI=gK&}hq--m{h$60Vb>F;lWbe&yT#g?|EdyGOZZ<nwSY}6sea+%4a;ke^Tg|a
zNxl)>x!1So>$xS@xzkSQf4lqPr|N}Vu45lgY$)ga*7Y++_)4eqJ@H>j*CsFcU-6B@
zH2IqFg0wT`8cVH~Ea$l3Jx6GMRcHGB!ZgFo2r-d#`JdY#8v7L-<NW;c&E-n{43A*D
z@E^0!{W^GF`PA8i`jXRE|6IRtKg)m9v`eW)A<GjBoLkw%c{zL9mu;PX^IEy>rWXqr
zR>+<GQKhwa|GR}fn=tc-nIZDrS3psIN@;Rxk%C4+N?J&2gs!2UiGiMxi6)o6V`)i7
zevyWzen@6XPO65cesF10R%&vIhNixAQEFmIevyVxVn}L)LV0FMhC)VVL26M^YMQ3L
zcWPyMeo;!Xh9(z8VP<}wOJYf?f`*Hgk%5u1frWvwp|PQviK(uEiMoM-x+a&tZ+;3P
zB_TzL1qG=o3i@t|ImM}5`T-%X5qfT=IXOv*d3hiYgk)qED`XZcKs=(O5SCh0oSC1e
zV610oVrXh<WM*otYouoe^Pz$U$n8FvWvL2A21Z7j3fTpTB^kx3i3(*<jb?hrdM27&
zcHrX?K!cE`Cdk8)A(aKG3i|#@S-~Z_T>5?rmIk1csfvnA6f6vk;iHwt#^%sN6F{;#
zC8<RU`ffRiC8;i{$@wX%Ak&LWic%AExhih0jk;ZQ+d`=JdiV#!n`?RAZC|x=<yX_P
zB<sFZb-!iHf;RcwUUOoS+alwWb$`o*MR<i47+pH&th0%+WWL?qj2H>kQa5AO*kdbC
zPDz?M<-<CcG}h+$sfJn`4yO1x#V?IHwq?uAMK;M{2j$Zr$}g1^mYL#VJ0U84j%7u%
z(qpFs9E?Jlp=zyXcCej|ncXAJ9L4&jQ07ZRNPxtt9cNk68(4U_7dj+4D9x2Fa5P@1
znsH4__*m8pWuu1&jF?wUYI5S-ro!GT<94u{<*d<Ut~<$Gawb2Hv6PstYntGxezc)c
z(pA@qHQ!RIR4+JVF0-ZAq2>f3$wqdD^(HnUF_JP_tbY!hbJxnS-#WnfR40S&@GP%R
zm$X@i(;Jh{>YSZ(%EbJ`IV0VMN^V)z(gQYsoUBbUdpa8Hq@J+-l1yVyh?QQP7_e+D
zi^hfXh8&z<iWQD4ikvhvaN$x=G?v-mtiZ!=X_3#u(O94?Dz7m?vbCZyVDUxEh9sR`
z*}4Zd$jC8>Gpn2mWZ+mPdSIJZWQq6!=^BBVi<vkl%w)dB#uZZ%ddp(2Wv>g<%X3Y|
zT$kI7x}+LQPhIprqok$yZ<bL-&<TcTlBNO`ynhU{be*jl<F&pxT<*$Dnc{R}M$0`Z
z<+B@HgEuhxBr_afOVKpqH?w%klg#M9riw{=PBR;?B)7lV`~z%HW=sD0^|~SE-;C#y
zmUDbh|E;l%6Zu@UO(Nud`eOGCODkJ@i$8zf@4fs`o%Pen7j-i|?<ba*f3y89yJk<(
z43;3J#c%o<Z$|cg&g49EnenFd+5S(D{w-|j=wftKzVWTg@<LHepW4xi^eX$4j!aF7
zGwtgdcw{ELu9_mkGsUJy?C_p5aTAUw{n}FV@~ym>0naD#Wj~KT*na=tG;8^L`}gg$
zS#`(Ivpmj_^`C}{z~-}`>JP}Dm~K~JcEb9-@XY7kNoC!qKDpL;KkI&Em~WkBUijtB
z-GlEwvKM^$G~?oy<p$Alg{+>3cep&CXM6R<8MAp=yN_Lt-Q@o5B%`H@`;!@a6!TAV
zTB@cWIAFO`!MVtD-HCJ~rN!<Kk}PN4n<Q<d_V{LsS?m7(e&r(Xq99H6@+a#Q$~P}(
z-Koz1<l*r@it{Hm)u;-8@>rG<<x^~=Z2ZGo{qseo`F@{vU$WQLVx5=w>3Q%z9d3gS
z3f`M^_D!BNrT***;h%2*l<uG8|8&2`FuRqJ<F*3NdVl`7`1xUpFHV~0z0xSiz3zVS
z#(qiG%l7qsCnIl5@9Q*IKmNP@u<@5?oAg(zR4{8#Z#wE`Eo*T&;<RK<?wm%~wQqTH
zg|hBmxw(4M%hIWSg+{UAC%4$O?tA**Md+-$LH+-lSyO+$J$ocQ=pS!LqMfe#;-}1M
zR}U+le|@KF);*`D{`Bq|-&rSpnLht3DNoN|&(-65ob|a?j@pKptmpsU?^xrxu}SCF
zycfPUmV2!#i>v;=fB5jI=He~tCneV0T%VxM+Rc|ye#qwcWvz=}Zi?S}%yI2Yx_icp
z6K5}{Oq!k>FJ$^7!D`-JvCGvPLhsyl{5Y@gbLuziH$2(A^+)zKe_cL%Q<baYhwau;
z&u&bbXnuI}Ls7p?cVA~s+Pb1icY;4pQH0Jk)uz@{h6?J7pRrD<)yX^EuKMFyw&>0|
zvA*06oN_PbecH-*@%dx(_V@g@O7k3+?CwZdeW$rYRbb;;!P+~u<rRN91>W+0pQLhA
zPbJ;i<BZ7!l_x<go%wt(Uwk<H@Fk;zl}B6eWj&?TsE&D_O`jclJaYOneq>e{)$n)t
z^-u2j!PdDX*`=u1<@oRP@bGF;rKt=e>1MgbF3f!uJs!DzFFt&E^5*Spu8E!sT}IJ6
z<+_%52P`pX-%`Kj^RK_G47)sz>72^GdPuoxg6gCbIfmcA_v@d#A5tL{9PbjToBIAr
zx}m~u%LUup^ZWJAX*+awbZV^J`fBEnF4dqDxqL7F+&#XUf5sK@&N*U%ey0tZKP>fJ
zu)}1QZr9i2pTAqL-xv|U<i*A8&+OYL`2IWc&?q|ORWtu{_214dkA(^rm2BHnUUyUC
zyjbe5&%YNp&wa&U;p1x{slMfvYf6$!^puzV*3<LL?}v2cFa^xHux`6rm&66J&|kma
z++BY9^Q)dYOEkPPrI;33olulyzO~4s{GGzCiZ50+ing6S_ZB&ouM^mnamUI;ZO(hn
zqHP)%?l#x4_a{lO`P8Yo&9(L2oXXt|F5(je6`jovEKahC7J2b*<yLNwQpV1Erai}k
z@8tz9wm!a9PeJ&7^RH7|N(|l0x{YMzckf!TXiponABR`V=Y4%2UuA^cUFmKheD!xt
z$$b5XJZ9C07QbY;Ctgu;*!xA+kK2#L`osS5Ofj5)NAk1u?4F;GCK;}ms$2c$Z?d*@
zT~*qh-%R_@{Wr?*{=GNx*x$ZnZRwaRyF%8UzOv2cUC(dZRJA`YH%_&EP+#YBWk>7%
zZ|P1~cBTG(r!TW@^TKS|x~&J_i~qa+tAb;{!Nc&L`8Oxjnk~7Xb?D!v<Br$NmY)As
zYE@`;-El2v`Z~U}wLVukRbRPGs*}DD`0L%uIU>PVqJ5eEoC;t(VmV>$xg70PVanY_
zlOFS~&cEBZGNydZ-I!kM_$T*2?72KkxbDL$oyQ4V^9p=#ME={mX5S^1kdx`5IxA1{
z`#oN;`rzuh{=!<44+;`(Yu!ROZgC2|{KadF@0xP~365(v2E13a345NjV%@^q+iu47
zuDNofW%9O%w^o@dJ1>iE%DDX@Cvv}(aM3)M%LaKqLA~;tk0vflytF1cXzPp|);!j8
z>E+fro08WojNbk-Y~gmRhYRvvT+2FpVnW{J1<~du+1J*)wU($~G%3-Z9P-#*?L`>x
z-7ML=N>`GjN>)$E+dM7r>IL1~CEXXIXBGsQm3VJWOYzw5bwO8pm+I?qWv5+}Go*I4
zdanAYEL_svmbY<Qo|x68MbRxKtG9yq?=BtF`n#xf!@<)z5e0E?&L3Of_B11KUyJOd
z_=9mW(|<nJf1|p_PM49j^L*1(mftVJ<okrgyjZ+m>2g?V%5`r_-uCjlyZG$<2`d~}
zv@W*s<Syu}n*M;*!llhwgeyhif<{1WNbkYW<t8f4&7}*@E;_)%)Xud3c!lAtJLkn*
ze+C3<W$3WRxh^vPcFl}akYP);n?-Y2UscQ!IS=7Bx1@qNBf-u_2hF4&siPb74ydcX
zcFIrA`X2wh!8O;$h)Kp<wDaO^345#4%IT_Jq2XNXxZVfzSNz^|x0bi8cVX`vsVQz{
zx?ZK>uL7c$U)!PaIsQexMb2MM72e?7pRtDVb&^lLB_4j)%>2`!DJ8h`!pj2tI+p6y
znxba+eA2#i96jb6pTF<kJ;&RtoLX{=6IHXG6kh(6cx0pJwpns}^h8<JTDO?4IKO?p
zecmTlsUThF{(^7OKKpyb?H|N+PF~1cXr(>v=k$x8w0lfUE`BN4enf3r#w`7`r#UvW
z6ISMaHl43~TL1A)<u4US=AEwj!*cOg<A;d;<EH=SuX^#hKJt#gdxz_`yFXS(Jo)aw
z_^9rol9$W$l_h>9M=n^sx~P8kebLKI|JO5#Sv~X7IVQTqE^F(P9eoxzA3x_xPj`6|
zcH@j;fr*()z`O(9q5dm8`m}kkPL#MVEw?*RH)Nu?Y{Xl}*K-b-dLKVl`1F#Q(BoNK
zR()!e2v-x<KKS+I)y~@RJNCMt;*Tx<Sv(=^`GY0W3_6AyMN4ll<udZVedO1g&|SQ%
zzjU?dNnd;QOHV25@U86FO>4Wf-|m{hAjAJ>=Ij~LI%jpBx!3l+H%nX-d8@wXd)CWW
zCW&V%X9f0HKezuFu*aw8_sr%QR(qC}+U+{O`s6*a1h$RSSd!1@Y8({cko20cv*K>=
zTJyWgOZG8lhUrG1$gBMv<~<?A-I=rKWz^yV+huA~9z>l{3X)#!yWYeg=E@X~FNJr0
zY^`{-<N0GnZJF=JN=J?st~(JXKS$9^z3}7o^K+{b9?D$Ot+gl)b3N=`a6HL*pT(wR
z=Q4{;kDaEm>hbCEdhgA#TAIkI;C^X>%)t#Fp97jw_w7qss~Yhj`W%POTeBsy-(`=f
zBrd!dy4*zPz}cJ?@sESVjgkWdCbb7oY}@mICra08gI99g|I_bhZuL6kwCPZv;Fet%
z<qe{`R{!0Q)7_waRgh7AnKIMjb;?Zfu_X$eIqb5@9scILOSsbKUe>idHd*~iXozr8
z!`ciL@fGnmTV%c*cfY8&>D`3VbsR0rN)L$`NjXo>IB=syW<lh<3C(q@g^Mn{e<2mF
zm2y|{b<D+3#pQ-<v7vgagn2Cvhu>aPRAS62=08VW>t@r`{rm3K1=>B?+`2zU;M|(R
z<xb)y`8FTFKU=kJY1X=s*jXWaEd#!~IUJqSYA(3<_@Y~0dus!~Uh}+K9U1B`5<1;p
zRDS=Y<x~EhJ$fqct?OQcm9xy=e%HHNfA#zR`t+smubJjMU!UK<Wq;-QlGs%xvIV}r
z`M$4s+t=k=mc$+?ovSiyW9b+5FK?fFzgQOeDEQ936*31O7C+d()TX{KvX+%|-TqZM
z*VpXq+I`;t;S~3E(|&$dpIrXAW>>JP^pld}rQhvK6u!k^>)0Z%{|W*3&LV<R)423K
z^HNeP6rv3j%nZ$Ax%7iGt5QKsF8y$YXhQ{K1;bb_{h<8(5(P6u&|>N!kdCx`1xQaB
z#B))IwlQ)vHgR+^Fm`ixwXifdFf=lBc5*f_b+j-rHnT7`G`3S9tRxoREi^PWFo(=J
z5bhSLPV>$QcNIDI{7?LpOX6Q*Zv{m~-3y4)*!F+gG%+vDT+J`8+_{afoP<P#O$}9E
zc=gW8s8P}D$*){7VTOR%<6|9@cU(E<Ql=&qC?wC_WT>+2-23Fur_0aXseZTD`2HO0
zb36YmZP|Q*anpj!bF@o1pBtUK^CG4tIwa%S8{L&HJCAG$xnvo>K_rl)%i-gsohfVG
zf(><)|F|YvwM{kji4B|4nOMqmIbBq*_}r=K0hSA_9}4kCUMZTuU3H>#L0E&$hUqcZ
zTJj<djz#<nxf}&8T=LAbR3liAo!q*x%aL=2!glUZu2TmJi>w2mE?}CYaJ_34OXvfW
zonlwA0%RXfeo`iIts$!D^hs0Ub&RD?x=!S($8f(o`SSKQL9>R^Cv7KkRdZN;3r}u3
z`ed8HI(F$3rW0=a>=4XRTK@C4%Zf(bC%;a<6cWAb_Re4@Z%fs}w4%jNLgM5XufOs<
zJI*9=mZ$H=XK~$&u3j=KYpPAKf3Y><NMOk8i>%)SvXo4mTNiMJG}~-o>ke!13SbRu
z&I(}8YK+?>FT=o`z{1mLSA0}*=Q{=0@aCcg)j#iTVBXRYwqU&tkJ~}P0ui64#Nw~v
zA^APs<&0;K85;1W9h|aL*8kNm$$4tm&o)oiS<Ck9%-27frCd5QwoVcLCDKt{@GQ5L
za{}XO2I)h~&)QbSEzVJ#f7-aHLFQQ8ha92)pSAOLrrTXR`bP4+R>igJ$@%d)?~V%f
zZqlyN4E@4m){-t=vFEk+*}Y}{*EcfT?EC)7Ht&0pwcS^V8`o!6`(J+damV`QD^5K&
z-GA=R)?%q#rXN=xYwy2!=X$Wzfo*b&tIxc;DK&5Ew;Z*8L)&9tBrd;SvPZ5(-FDuW
zic60@`;~3jKIT3X`yX0a^XlWu<9&7fFW77sOs_Iwz2AOm&BOHm`F|Z79RC<tB)t13
zD=N$K%Fc9w(YBpkH`Lb(UAge#kH`V7I;&^fG|bu64s`6SP7mRFUAgA@#(DD0j~}qi
zFgd+*?d!AyA0x76d+EAd^`CzJl=F{M=Vwi|pAr1$xxbN?_gu5v8=i2mKA!vf?7O<9
z1(F`KO1EhFH1k9-7M=O!X1YP<$+72rFLwS6<n<DDF;xi_yUMz<D1gJuVcyLPyrG&*
z+6T1`ygN5-)>+ZaDS8u@a;LmxirnQeO>e?d_mtNMq85nl<hwF!?#pX?zb4oQY`(*B
zMd|8)sk7(KzutA$p|(g{_+rB%`IPeJ_J&=`ca?Sv=a^UjobzsJWy<Y?dYjANX<uiv
zdOUsqI{oMEv+r_Sow2JlI2xP4|AMVHLEeI)>TKSftEIm)jjDKc?>QQ9@HH;{(Nq4l
zhtq&ZjgeQ&I^kPx^QxW(<p&yHzqqPD+WY=>+?>yhc7Fw8Lh`s|m}h(yVxE3b^n>OP
zo|={2=?63o^2%O|+6L8MHk#mX(Y=Zx>WQU+|A|ShEDxqUEb%#*-KfQ=-X=5QQD4UG
z`=?A27Muwx-xuB??5uZSQKLKC9<dLh8f?FoFFE_~^kvzl4)x4;r?GP}l=19IIk23u
zn6*b_gX@LYkG3`}Wy<5SP)}$KNbkJ!TC4xClk$Oj#@DPlV%wO)>^J;syvlFO(A*N&
zAjy=*5%ssOLH7{Dh5bICoA{aRIGh`<@~<he;BjNjmfP|yd74J0*Lt(O&d&Es)O0=`
zV_oU#9kXA}G_}(;_jkdWNlW*8`9^Pg>b_Fa`&^xJ>77aD>P!40KCO3OlBOGaOT{#O
z<umam&vZrq_pF#at?C=+%HV0cEObh51(~1s(v7%PyKr*T<})b^H<x@p%ystCTYFDc
zoxhh>2YGtOznbh7`K$l_(o56+Juh6@lNx3tyIQ11ZsVut9g}_wK7A_~x>wM&S+LYy
zS!!N?#wS7P|9v-R^<}*4$f(s>^mcK_w`jrGaOH1y;v4Igk{+DxaPAgVHdpS8xn3;o
zDExvY)}dW?Zc(Yu<w*bi5`SaAHU4#A-@=^0kTJ3Jz*T$K;|CKBm`aK+2fpR7;5ydO
zx6A6bUz275k56>kpY|WixWn)MuQZrzh*_5vmn0UIR1~GAahVuem>U~&sj9mAyKw;k
D_+`j6

literal 0
HcmV?d00001


From f8487425c5718b34b04413c1b0c67cb31a1acb8e Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Fri, 4 Aug 2023 11:25:35 -0400
Subject: [PATCH 16/37] integrated suggestions

---
 examples/basic_test.rs  | 14 +++++++++-----
 src/applicationlayer.rs | 15 ++++++++++-----
 src/context.rs          |  2 +-
 src/fragmentation.rs    |  2 +-
 src/lib.rs              |  7 ++-----
 src/log_event.rs        |  3 ++-
 src/result.rs           |  3 ++-
 src/symmetric_state.rs  |  2 +-
 src/zeta.rs             |  9 ++++++---
 9 files changed, 34 insertions(+), 23 deletions(-)

diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index 8aaafeb..650721b 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -21,9 +21,9 @@ use rand_core::OsRng;
 use rand_core::RngCore;
 use sha2::Sha512;
 
+use zssp_proto::applicationlayer::{AcceptAction, ApplicationLayer, RatchetState, RatchetUpdate, Settings, RATCHET_SIZE};
 use zssp_proto::crypto_impl::PqcKyberSecretKey;
-use zssp_proto::{RatchetState, RatchetUpdate};
-use zssp_proto::{Session, Settings, RATCHET_SIZE};
+use zssp_proto::Session;
 
 const TEST_MTU: usize = 1500;
 
@@ -44,7 +44,7 @@ impl Ratchets {
 }
 
 #[allow(unused)]
-impl zssp_proto::ApplicationLayer for &TestApplication {
+impl ApplicationLayer for &TestApplication {
     const SETTINGS: Settings = Settings {
         initial_offer_timeout: Settings::INITIAL_OFFER_TIMEOUT_MS,
         rekey_timeout: 60 * 1000,
@@ -73,8 +73,12 @@ impl zssp_proto::ApplicationLayer for &TestApplication {
         true
     }
 
-    fn check_accept_session(&self, remote_static_key: &Self::PublicKey, identity: &[u8]) -> (Option<(bool, Self::SessionData)>, bool) {
-        (Some((true, 1)), true)
+    fn check_accept_session(&self, remote_static_key: &Self::PublicKey, identity: &[u8]) -> AcceptAction<Self> {
+        AcceptAction {
+            session_data: Some(1),
+            responder_disallows_downgrade: true,
+            responder_silently_rejects: false,
+        }
     }
 
     fn restore_by_fingerprint(&self, ratchet_fingerprint: &[u8; RATCHET_SIZE]) -> Result<Option<RatchetState>, Self::StorageError> {
diff --git a/src/applicationlayer.rs b/src/applicationlayer.rs
index 8476414..9856b4b 100644
--- a/src/applicationlayer.rs
+++ b/src/applicationlayer.rs
@@ -2,12 +2,13 @@ use rand_core::{CryptoRng, RngCore};
 use std::sync::Arc;
 
 use crate::crypto::{AeadAesGcm, HashSha512, KeyPairP384, PrivateKeyKyber1024, PrpAes256, PublicKeyP384};
-use crate::proto::RATCHET_SIZE;
-use crate::ratchet_state::RatchetState;
 #[cfg(feature = "logging")]
 use crate::LogEvent;
 use crate::Session;
 
+pub use crate::proto::RATCHET_SIZE;
+pub use crate::ratchet_state::RatchetState;
+
 /// A container for a vast majority of the dynamic settings within ZSSP, including all time-based settings.
 /// If the user wishes to measure time in units other than milliseconds for some reason, then they can
 /// create an adjusted version of this struct with those units, and use it instead of the default.
@@ -174,7 +175,7 @@ pub trait ApplicationLayer: Sized {
     /// must verify this identity is associated with the remote peer's static key.
     /// To prevent desync, if this function returns (Some(_), _), no other open session with the
     /// same remote peer must exist. Drop or call expire on any pre-existing sessions before returning.
-    fn check_accept_session(&self, remote_static_key: &Self::PublicKey, identity: &[u8]) -> (Option<(bool, Self::SessionData)>, bool);
+    fn check_accept_session(&self, remote_static_key: &Self::PublicKey, identity: &[u8]) -> AcceptAction<Self>;
 
     /// Lookup a specific ratchet state based on its ratchet fingerprint.
     /// This function will be called whenever Alice attempts to connect to us with a non-empty
@@ -246,8 +247,6 @@ pub trait ApplicationLayer: Sized {
     fn event_log(&self, event: LogEvent<'_, Self>);
 }
 
-pub trait CryptoLayer {}
-
 pub struct RatchetUpdate<'a> {
     pub state1: &'a RatchetState,
     pub state2: Option<&'a RatchetState>,
@@ -255,3 +254,9 @@ pub struct RatchetUpdate<'a> {
     pub state_deleted1: Option<&'a RatchetState>,
     pub state_deleted2: Option<&'a RatchetState>,
 }
+
+pub struct AcceptAction<App: ApplicationLayer> {
+    pub session_data: Option<App::SessionData>,
+    pub responder_disallows_downgrade: bool,
+    pub responder_silently_rejects: bool,
+}
diff --git a/src/context.rs b/src/context.rs
index f4ff1cd..5309902 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -5,12 +5,12 @@ use std::hash::Hash;
 use std::num::NonZeroU32;
 use std::sync::{Arc, Mutex, Weak};
 
+use crate::applicationlayer::ApplicationLayer;
 use crate::crypto::{AES_256_KEY_SIZE, AES_GCM_IV_SIZE};
 use crate::fragmentation::{send_with_fragmentation, DefragBuffer};
 use crate::proto::*;
 use crate::result::{byzantine_fault, ReceiveError, ReceiveOk, SendError, SessionEvent};
 use crate::zeta::*;
-use crate::ApplicationLayer;
 #[cfg(feature = "logging")]
 use crate::LogEvent::*;
 use crate::{challenge::ChallengeContext, result::OpenError};
diff --git a/src/fragmentation.rs b/src/fragmentation.rs
index 96ed746..409eff6 100644
--- a/src/fragmentation.rs
+++ b/src/fragmentation.rs
@@ -4,10 +4,10 @@ use std::sync::Mutex;
 
 use zeroize::Zeroizing;
 
+use crate::applicationlayer::ApplicationLayer;
 use crate::crypto::{PrpAes256, AES_256_KEY_SIZE};
 use crate::proto::*;
 use crate::result::{byzantine_fault, ReceiveError};
-use crate::ApplicationLayer;
 
 fn create_fragment_header(kid_send: u32, fragment_count: usize, fragment_no: usize, n: &[u8; PACKET_NONCE_SIZE]) -> [u8; HEADER_SIZE] {
     debug_assert!(fragment_count > 0);
diff --git a/src/lib.rs b/src/lib.rs
index 680a598..4a67dec 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -7,8 +7,6 @@
 */
 //#![warn(missing_docs, rust_2018_idioms)]
 //! TODO: docs
-
-mod applicationlayer;
 mod challenge;
 mod context;
 mod fragmentation;
@@ -19,6 +17,7 @@ mod ratchet_state;
 mod symmetric_state;
 mod zeta;
 
+pub mod applicationlayer;
 /// A collection of implementation-independent traits for the various specific cryptographic
 /// algorithms ZSSP depends on.
 ///
@@ -40,10 +39,8 @@ pub mod crypto;
 pub mod crypto_impl;
 pub mod result;
 
-pub use applicationlayer::{ApplicationLayer, RatchetUpdate, Settings};
 pub use context::Context;
 #[cfg(feature = "logging")]
 pub use log_event::LogEvent;
-pub use proto::{MIN_TRANSPORT_MTU, RATCHET_SIZE};
-pub use ratchet_state::RatchetState;
+pub use proto::MIN_TRANSPORT_MTU;
 pub use zeta::Session;
diff --git a/src/log_event.rs b/src/log_event.rs
index c95252f..b7b9428 100644
--- a/src/log_event.rs
+++ b/src/log_event.rs
@@ -1,6 +1,7 @@
 use std::sync::Arc;
 
-use crate::{ApplicationLayer, Session};
+use crate::applicationlayer::ApplicationLayer;
+use crate::Session;
 
 /// ZSSP events that might be interesting to log or aggregate into metrics.
 pub enum LogEvent<'a, App: ApplicationLayer> {
diff --git a/src/result.rs b/src/result.rs
index 9537b77..c9fd0d6 100644
--- a/src/result.rs
+++ b/src/result.rs
@@ -1,6 +1,7 @@
 use std::sync::Arc;
 
-use crate::{ApplicationLayer, Session};
+use crate::applicationlayer::ApplicationLayer;
+use crate::Session;
 
 /// An error that can occur when attempting to open a session.
 /// Depending on the error type trying again may not work.
diff --git a/src/symmetric_state.rs b/src/symmetric_state.rs
index 516c3bf..2d20cb7 100644
--- a/src/symmetric_state.rs
+++ b/src/symmetric_state.rs
@@ -2,9 +2,9 @@ use std::marker::PhantomData;
 
 use zeroize::Zeroizing;
 
+use crate::applicationlayer::ApplicationLayer;
 use crate::crypto::{AeadAesGcm, HashSha512, AES_256_KEY_SIZE, AES_GCM_IV_SIZE, AES_GCM_TAG_SIZE};
 use crate::proto::{HASHLEN, LABEL_KBKDF_CHAIN};
-use crate::ApplicationLayer;
 
 pub struct SymmetricState<App: ApplicationLayer> {
     k: Zeroizing<[u8; AES_256_KEY_SIZE]>,
diff --git a/src/zeta.rs b/src/zeta.rs
index b33bf53..8edee5b 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -5,6 +5,7 @@ use std::ops::{Deref, DerefMut};
 use std::sync::{Arc, Mutex, Weak};
 use zeroize::Zeroizing;
 
+use crate::applicationlayer::ApplicationLayer;
 use crate::applicationlayer::RatchetUpdate;
 use crate::challenge::{gen_null_response, respond_to_challenge_in_place};
 use crate::context::{log, ContextInner, SessionMap};
@@ -14,7 +15,6 @@ use crate::proto::*;
 use crate::ratchet_state::RatchetState;
 use crate::result::{byzantine_fault, FaultType, OpenError, ReceiveError, SendError};
 use crate::symmetric_state::SymmetricState;
-use crate::ApplicationLayer;
 #[cfg(feature = "logging")]
 use crate::LogEvent::*;
 
@@ -627,7 +627,10 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
     let (kek_send, kek_recv) = noise.get_ask(LABEL_KEX_KEY);
     let c = INIT_COUNTER;
 
-    let (responder_disallows_downgrade, responder_silently_rejects) = app.check_accept_session(&s_remote, &x3[identity_start..identity_end]);
+    let action = app.check_accept_session(&s_remote, &x3[identity_start..identity_end]);
+    let responder_disallows_downgrade = action.responder_disallows_downgrade;
+    let responder_silently_rejects = action.responder_silently_rejects;
+    let session_data = action.session_data;
     let create_reject = || {
         let mut d = Vec::<u8>::new();
         let n = to_nonce(PACKET_TYPE_SESSION_REJECTED, c);
@@ -638,7 +641,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
         // handshake is being dropped, so nonce reuse can't happen.
         Packet(zeta.kid_send.get(), n, d)
     };
-    if let Some((responder_disallows_downgrade, session_data)) = responder_disallows_downgrade {
+    if let Some(session_data) = session_data {
         let result = app.restore_by_identity(&s_remote, &session_data);
         match result {
             Ok((ratchet_state1, ratchet_state2)) => {

From f01e60bbc2ebfb1687a6e5302209edeaf4c0cb57 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Fri, 4 Aug 2023 18:40:23 -0400
Subject: [PATCH 17/37] added paper references

---
 README.md              |   2 +
 src/challenge.rs       |   4 +-
 src/context.rs         |   4 +-
 src/fragmentation.rs   |   3 ++
 src/proto.rs           |   2 +
 src/ratchet_state.rs   |   2 +
 src/symmetric_state.rs |   7 +++
 src/zeta.rs            | 100 +++++++++++++++++++++++++----------------
 8 files changed, 83 insertions(+), 41 deletions(-)

diff --git a/README.md b/README.md
index f043379..d164830 100644
--- a/README.md
+++ b/README.md
@@ -3,6 +3,8 @@ ZeroTier Secure Sessions Protocol
 
 ## Introduction
 
+An in-depth guide to the full protocol specification can be found in the [protocol whitepaper](./whitepaper.pdf) provided in this repo. This implementation references it heavily.
+
 ZeroTier Secure Socket Protocol (ZSSP) is a [Noise](http://noiseprotocol.org) protocol implementation using NIST/FIPS/CfSC compliant cryptographic primitives plus post-quantum forward secrecy via [Kyber1024](https://pq-crystals.org/kyber/). It also includes built-in support for fragmentation and defragmentation of large messages with strong resistance against denial of service attacks targeted against the fragmentation protocol.
 
 Specifically ZSSP implements the [Noise XK](http://noiseprotocol.org/noise.html#interactive-handshake-patterns-fundamental) interactive handshake pattern which provides strong forward secrecy not only for data but for the identities of the two participants in the session. The XK pattern was chosen instead of the more popular IK pattern used in popular Noise implementations like Wireguard due to ZeroTier identities being long lived and potentially tied to the real world identity of the user. As a result a Noise pattern providing identity forward secrecy was considered preferable as it offers some level of deniability for recorded traffic even after secret key compromise.
diff --git a/src/challenge.rs b/src/challenge.rs
index 5162656..26a695b 100644
--- a/src/challenge.rs
+++ b/src/challenge.rs
@@ -12,12 +12,13 @@ pub struct ChallengeContext {
     salt: [u8; SALT_SIZE],
 }
 
+/// Corresponds to Algorithm 11 found in Section 5.
 pub fn gen_null_response<Rng: RngCore + CryptoRng>(rng: &mut Rng) -> [u8; CHALLENGE_SIZE] {
     let mut response = [0u8; CHALLENGE_SIZE];
     response[POW_START..].copy_from_slice(&rng.next_u64().to_be_bytes());
     response
 }
-
+/// Corresponds to Algorithm 13 found in Section 5.
 pub fn respond_to_challenge_in_place<Rng: RngCore + CryptoRng, Hash: HashSha512>(
     rng: &mut Rng,
     challenge: &[u8; CHALLENGE_SIZE],
@@ -47,6 +48,7 @@ impl ChallengeContext {
             salt,
         }
     }
+    /// Corresponds to Algorithm 12 found in Section 5.
     pub fn process_hello<Hash: HashSha512>(
         &mut self,
         addr: &impl std::hash::Hash,
diff --git a/src/context.rs b/src/context.rs
index 5309902..6b80a09 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -50,11 +50,13 @@ pub(crate) struct ContextInner<App: ApplicationLayer> {
     challenge: Mutex<ChallengeContext>,
 }
 
+/// Corresponds to Figure 10 found in Section 4.3.
 fn to_aes_nonce(pn: &[u8; PACKET_NONCE_SIZE]) -> [u8; AES_GCM_IV_SIZE] {
     let mut an = [0u8; AES_GCM_IV_SIZE];
     an[2..].copy_from_slice(pn);
     an
 }
+/// Corresponds to Figure 14 found near Section 6.
 fn to_packet_nonce(n: &[u8; AES_GCM_IV_SIZE]) -> &[u8; PACKET_NONCE_SIZE] {
     (&n[n.len() - PACKET_NONCE_SIZE..]).try_into().unwrap()
 }
@@ -153,7 +155,7 @@ impl<App: ApplicationLayer> Context<App> {
                         log!(app, ReceivedRawFragment(p, c, frag_no, frag_count));
                     }
                     if p == PACKET_TYPE_HANDSHAKE_RESPONSE {
-                        if !matches!(&zeta.beta, ZsspAutomata::A1(_)) {
+                        if !matches!(&zeta.beta, ZetaAutomata::A1(_)) {
                             // A resent handshake response from Bob may have arrived out of order,
                             // after we already received one.
                             return Err(byzantine_fault!(OutOfSequence, false));
diff --git a/src/fragmentation.rs b/src/fragmentation.rs
index 409eff6..2e0db42 100644
--- a/src/fragmentation.rs
+++ b/src/fragmentation.rs
@@ -9,6 +9,7 @@ use crate::crypto::{PrpAes256, AES_256_KEY_SIZE};
 use crate::proto::*;
 use crate::result::{byzantine_fault, ReceiveError};
 
+/// Corresponds to Figure 13 found in Section 6.
 fn create_fragment_header(kid_send: u32, fragment_count: usize, fragment_no: usize, n: &[u8; PACKET_NONCE_SIZE]) -> [u8; HEADER_SIZE] {
     debug_assert!(fragment_count > 0);
     debug_assert!(fragment_count <= MAX_FRAGMENTS);
@@ -21,6 +22,7 @@ fn create_fragment_header(kid_send: u32, fragment_count: usize, fragment_no: usi
     header
 }
 
+/// Corresponds to the fragmentation algorithm described in Section 6.
 pub fn send_with_fragmentation<App: ApplicationLayer>(
     mut send: impl FnMut(Vec<u8>) -> bool,
     mtu: usize,
@@ -72,6 +74,7 @@ impl DefragBuffer {
         Self { fragment_map: Mutex::new(HashMap::new()), hk_recv }
     }
 
+    /// Corresponds to the authentication and defragmentation algorithm described in Section 6.1.
     pub fn received_fragment<App: ApplicationLayer>(
         &self,
         mut raw_fragment: Vec<u8>,
diff --git a/src/proto.rs b/src/proto.rs
index 0b7a5fc..e7fc4ed 100644
--- a/src/proto.rs
+++ b/src/proto.rs
@@ -3,6 +3,8 @@ use crate::crypto::{AES_GCM_TAG_SIZE, KYBER_CIPHERTEXT_SIZE, KYBER_PUBLIC_KEY_SI
 /* Common constants */
 
 /// Minimum physical MTU for ZSSP to function.
+/// If an MTU is passed to ZSSP that is lower than this, it will be ignored and instead this value
+/// will be used.
 pub const MIN_TRANSPORT_MTU: usize = 128;
 
 pub(crate) const KID_SIZE: usize = 4;
diff --git a/src/ratchet_state.rs b/src/ratchet_state.rs
index 829b6f3..ec5babe 100644
--- a/src/ratchet_state.rs
+++ b/src/ratchet_state.rs
@@ -4,6 +4,8 @@ use crate::crypto::{secure_eq, HashSha512};
 use crate::proto::*;
 /// A ratchet key and fingerprint,
 /// along with the length of the ratchet chain the keys were derived from.
+///
+/// Corresponds to the Ratchet Key and Ratchet Fingerprint described in Section 3.
 #[derive(Clone, Eq)]
 pub struct RatchetState {
     pub key: Zeroizing<[u8; RATCHET_SIZE]>,
diff --git a/src/symmetric_state.rs b/src/symmetric_state.rs
index 2d20cb7..bc4a965 100644
--- a/src/symmetric_state.rs
+++ b/src/symmetric_state.rs
@@ -37,6 +37,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     /// * L = `num_outputs*512u16`
     /// We have intentionally made every input small and fixed size to avoid unnecessary complexity
     /// and data representation ambiguity.
+    /// Corresponds to Noise `HKDF`.
     fn kbkdf(
         &self,
         input_key_material: &[u8],
@@ -69,6 +70,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         }
     }
 
+    /// Corresponds to Noise `Initialize` on a SymmetricState.
     pub fn initialize(h: [u8; HASHLEN]) -> Self {
         Self {
             k: Zeroizing::default(),
@@ -77,6 +79,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
             _app: PhantomData,
         }
     }
+    /// Corresponds to Noise `MixKey`.
     pub fn mix_key(&mut self, input_key_material: &[u8]) {
         let mut next_ck = [0u8; HASHLEN];
         let mut temp_k = [0u8; HASHLEN];
@@ -86,12 +89,14 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         *self.ck = next_ck;
         self.k.clone_from_slice(&temp_k[..AES_256_KEY_SIZE]);
     }
+    /// Corresponds to Noise `MixHash`.
     pub fn mix_hash(&mut self, data: &[u8]) {
         let mut hash = App::Hash::new();
         hash.update(&self.h);
         hash.update(data);
         self.h = hash.finish();
     }
+    /// Corresponds to Noise `MixKeyAndHash`.
     pub fn mix_key_and_hash(&mut self, input_key_material: &[u8]) {
         let mut next_ck = [0u8; HASHLEN];
         let mut temp_h = [0u8; HASHLEN];
@@ -110,6 +115,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         self.mix_hash(&temp_h);
         self.k.clone_from_slice(&temp_k[..AES_256_KEY_SIZE]);
     }
+    /// Corresponds to Noise `EncryptAndHash`.
     pub fn encrypt_and_hash_in_place(&mut self, iv: [u8; AES_GCM_IV_SIZE], plaintext_start: usize, buffer: &mut Vec<u8>) {
         let tag = App::Aead::encrypt_in_place(&self.k, iv, Some(&self.h), &mut buffer[plaintext_start..]);
         buffer.extend(&tag);
@@ -117,6 +123,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         hash.update(&buffer[plaintext_start..]);
         self.h = hash.finish();
     }
+    /// Corresponds to Noise `DecryptAndHash`.
     #[must_use]
     pub fn decrypt_and_hash_in_place(&mut self, iv: [u8; AES_GCM_IV_SIZE], buffer: &mut [u8], tag: [u8; AES_GCM_TAG_SIZE]) -> bool {
         let mut hash = App::Hash::new();
diff --git a/src/zeta.rs b/src/zeta.rs
index 8edee5b..18c5259 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -38,6 +38,7 @@ pub(crate) fn from_nonce(n: &[u8]) -> (u8, u64) {
     (n[c_start - 1], u64::from_be_bytes(n[c_start..].try_into().unwrap()))
 }
 
+/// Corresponds to the Zeta State Machine found in Section 4.1.
 pub(crate) struct Zeta<App: ApplicationLayer> {
     ctx: Weak<ContextInner<App>>,
     /// An arbitrary application defined object associated with each session.
@@ -57,7 +58,7 @@ pub(crate) struct Zeta<App: ApplicationLayer> {
 
     resend_timer: i64,
     timeout_timer: i64,
-    pub beta: ZsspAutomata<App>,
+    pub beta: ZetaAutomata<App>,
 
     pub counter_antireplay_window: [u64; COUNTER_WINDOW_MAX_OOO],
     pub defrag: DefragBuffer,
@@ -67,6 +68,7 @@ pub(crate) struct Zeta<App: ApplicationLayer> {
 /// A FIPS/NIST compliant variant of Noise_XK with hybrid Kyber1024 PQ data forward secrecy.
 pub struct Session<App: ApplicationLayer>(pub(crate) Mutex<Zeta<App>>);
 
+/// Corresponds to State B_2 of the Zeta State Machine found in Section 4.1 - Definition 3.
 pub(crate) struct StateB2<App: ApplicationLayer> {
     ratchet_state: RatchetState,
     kid_send: NonZeroU32,
@@ -90,9 +92,11 @@ pub(crate) struct Keys {
     kid: Option<NonZeroU32>,
 }
 
+/// Corresponds to the tuple of values the Transition Algorithms send to the remote peer in Section 4.3.
 #[derive(Clone)]
 pub(crate) struct Packet(pub u32, pub [u8; AES_GCM_IV_SIZE], pub Vec<u8>);
 
+/// Corresponds to State A_1 of the Zeta State Machine found in Section 4.1.
 #[derive(Clone)]
 pub(crate) struct StateA1<App: ApplicationLayer> {
     noise: SymmetricState<App>,
@@ -102,7 +106,8 @@ pub(crate) struct StateA1<App: ApplicationLayer> {
     packet: Packet,
 }
 
-pub(crate) enum ZsspAutomata<App: ApplicationLayer> {
+/// Corresponds to the ZKE Automata found in Section 4.1 - Definition 2.
+pub(crate) enum ZetaAutomata<App: ApplicationLayer> {
     Null,
     A1(StateA1<App>),
     A3 {
@@ -186,7 +191,7 @@ impl<App: ApplicationLayer> Zeta<App> {
     fn expire(&mut self) {
         self.resend_timer = i64::MAX;
         self.timeout_timer = i64::MAX;
-        self.beta = ZsspAutomata::Null;
+        self.beta = ZetaAutomata::Null;
         if let Some(ctx) = self.ctx.upgrade() {
             let mut session_map = ctx.session_map.lock().unwrap();
             let mut sessions = ctx.sessions.lock().unwrap();
@@ -252,6 +257,7 @@ fn create_a1_state<App: ApplicationLayer>(
         packet: Packet(0, to_nonce(PACKET_TYPE_HANDSHAKE_HELLO, c), x1),
     })
 }
+/// Corresponds to Transition Algorithm 1 found in Section 4.3.
 pub(crate) fn trans_to_a1<App: ApplicationLayer>(
     app: App,
     ctx: &Arc<ContextInner<App>>,
@@ -289,7 +295,7 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
         hk_send,
         resend_timer: current_time + App::SETTINGS.resend_time as i64,
         timeout_timer: current_time + App::SETTINGS.initial_offer_timeout as i64,
-        beta: ZsspAutomata::A1(a1),
+        beta: ZetaAutomata::A1(a1),
     };
     zeta.key_mut(true).recv.kid = Some(kid_recv);
 
@@ -301,8 +307,9 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
 
     Ok(session)
 }
+/// Corresponds to Algorithm 13 found in Section 5.
 pub(crate) fn respond_to_challenge<App: ApplicationLayer>(zeta: &mut Zeta<App>, rng: &Mutex<App::Rng>, challenge: &[u8; CHALLENGE_SIZE]) {
-    if let ZsspAutomata::A1(StateA1 { packet: Packet(_, _, x1), .. }) = &mut zeta.beta {
+    if let ZetaAutomata::A1(StateA1 { packet: Packet(_, _, x1), .. }) = &mut zeta.beta {
         let response_start = x1.len() - CHALLENGE_SIZE;
         respond_to_challenge_in_place::<App::Rng, App::Hash>(
             rng.lock().unwrap().deref_mut(),
@@ -311,6 +318,7 @@ pub(crate) fn respond_to_challenge<App: ApplicationLayer>(zeta: &mut Zeta<App>,
         );
     }
 }
+/// Corresponds to Transition Algorithm 2 found in Section 4.3.
 pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     app: &App,
     ctx: &ContextInner<App>,
@@ -428,6 +436,7 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     send(&Packet(kid_send.get(), to_nonce(PACKET_TYPE_HANDSHAKE_RESPONSE, c), x2), &hk_send);
     Ok(())
 }
+/// Corresponds to Transition Algorithm 3 found in Section 4.3.
 pub(crate) fn received_x2_trans<App: ApplicationLayer>(
     zeta: &mut Zeta<App>,
     session: &Arc<Session<App>>,
@@ -452,7 +461,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let result = (|| {
-        if let ZsspAutomata::A1(StateA1 { noise, e_secret, e1_secret, identity, .. }) = &zeta.beta {
+        if let ZetaAutomata::A1(StateA1 { noise, e_secret, e1_secret, identity, .. }) = &zeta.beta {
             let mut noise = noise.clone();
             let mut i = 0;
             // Process message pattern 2 e token.
@@ -570,7 +579,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
             zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
             zeta.timeout_timer = current_time + App::SETTINGS.initial_offer_timeout as i64;
             let packet = Packet(kid_send.get(), n, x3);
-            zeta.beta = ZsspAutomata::A3 { identity, packet: packet.clone() };
+            zeta.beta = ZetaAutomata::A3 { identity, packet: packet.clone() };
 
             Ok(packet)
         } else {
@@ -584,6 +593,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
     }
     result.map(|_| ())
 }
+/// Corresponds to Transition Algorithm 4 found in Section 4.3.
 pub(crate) fn received_x3_trans<App: ApplicationLayer>(
     zeta: StateB2<App>,
     app: &App,
@@ -708,7 +718,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                     hk_send: zeta.hk_send.clone(),
                     resend_timer: current_time + App::SETTINGS.resend_time as i64,
                     timeout_timer: current_time + App::SETTINGS.rekey_timeout as i64,
-                    beta: ZsspAutomata::S1,
+                    beta: ZetaAutomata::S1,
                     counter_antireplay_window: std::array::from_fn(|_| 0),
                     defrag: zeta.defrag,
                 })));
@@ -727,6 +737,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
         Err(byzantine_fault!(FailedAuth, true))
     }
 }
+/// Corresponds to Transition Algorithm 5 found in Section 4.3.
 pub(crate) fn received_c1_trans<App: ApplicationLayer>(
     zeta: &mut Zeta<App>,
     app: &App,
@@ -761,9 +772,9 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
         return Err(byzantine_fault!(ExpiredCounter, true));
     }
 
-    let just_establised = is_other && matches!(&zeta.beta, ZsspAutomata::A3 { .. });
+    let just_establised = is_other && matches!(&zeta.beta, ZetaAutomata::A3 { .. });
     if is_other {
-        if let ZsspAutomata::A3 { .. } | ZsspAutomata::R2 { .. } = &zeta.beta {
+        if let ZetaAutomata::A3 { .. } | ZetaAutomata::R2 { .. } = &zeta.beta {
             if zeta.ratchet_state2.is_some() {
                 let result = app.save_ratchet_state(
                     &zeta.s_remote,
@@ -788,7 +799,7 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
                     .rekey_after_time
                     .saturating_sub(rng.lock().unwrap().next_u64() % App::SETTINGS.rekey_time_max_jitter) as i64;
             zeta.resend_timer = i64::MAX;
-            zeta.beta = ZsspAutomata::S2;
+            zeta.beta = ZetaAutomata::S2;
         }
     }
     let mut c2 = Vec::new();
@@ -803,6 +814,8 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
     send(&Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, c2), Some(&zeta.hk_send));
     Ok(just_establised)
 }
+/// Corresponds to the trivial Transition Algorithm described for processing C_2 packets found in
+/// Section 4.3.
 pub(crate) fn received_c2_trans<App: ApplicationLayer>(
     zeta: &mut Zeta<App>,
     app: &App,
@@ -820,7 +833,7 @@ pub(crate) fn received_c2_trans<App: ApplicationLayer>(
         // Some acknowledgement may have arrived extremely delayed.
         return Err(byzantine_fault!(UnknownLocalKeyId, false));
     }
-    if !matches!(&zeta.beta, ZsspAutomata::S1) {
+    if !matches!(&zeta.beta, ZetaAutomata::S1) {
         // Some acknowledgement may have arrived extremely delayed.
         return Err(byzantine_fault!(OutOfSequence, false));
     }
@@ -839,9 +852,11 @@ pub(crate) fn received_c2_trans<App: ApplicationLayer>(
             .rekey_after_time
             .saturating_sub(rng.lock().unwrap().next_u64() % App::SETTINGS.rekey_time_max_jitter) as i64;
     zeta.resend_timer = i64::MAX;
-    zeta.beta = ZsspAutomata::S2;
+    zeta.beta = ZetaAutomata::S2;
     Ok(())
 }
+/// Corresponds to the trivial Transition Algorithm described for processing D packets found in
+/// Section 4.3.
 pub(crate) fn received_d_trans<App: ApplicationLayer>(
     zeta: &mut Zeta<App>,
     kid: NonZeroU32,
@@ -853,7 +868,7 @@ pub(crate) fn received_d_trans<App: ApplicationLayer>(
     if d.len() != SESSION_REJECTED_SIZE {
         return Err(byzantine_fault!(InvalidPacket, true));
     }
-    if Some(kid) != zeta.key_ref(true).recv.kid || !matches!(&zeta.beta, ZsspAutomata::A3 { .. }) {
+    if Some(kid) != zeta.key_ref(true).recv.kid || !matches!(&zeta.beta, ZetaAutomata::A3 { .. }) {
         return Err(byzantine_fault!(OutOfSequence, true));
     }
 
@@ -869,6 +884,7 @@ pub(crate) fn received_d_trans<App: ApplicationLayer>(
     zeta.expire();
     Ok(())
 }
+/// Corresponds to the timer rules of the Zeta State Machine found in Section 4.1 - Definition 3.
 pub(crate) fn service<App: ApplicationLayer>(
     zeta: &mut Zeta<App>,
     session: &Arc<Session<App>>,
@@ -880,28 +896,29 @@ pub(crate) fn service<App: ApplicationLayer>(
     if zeta.timeout_timer <= current_time {
         timeout_trans(zeta, session, app, ctx, current_time, send);
     } else if zeta.resend_timer <= current_time {
+        // Corresponds to the resend timer rules found in Section 4.1 - Definition 3.
         zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
 
         let (p, mut control_payload) = match &zeta.beta {
-            ZsspAutomata::Null => return,
-            ZsspAutomata::A1(StateA1 { packet, .. }) => {
+            ZetaAutomata::Null => return,
+            ZetaAutomata::A1(StateA1 { packet, .. }) => {
                 log!(app, ResentX1(session));
                 return send(packet, None);
             }
-            ZsspAutomata::A3 { packet, .. } => {
+            ZetaAutomata::A3 { packet, .. } => {
                 log!(app, ResentX3(session));
                 return send(packet, Some(&zeta.hk_send));
             }
-            ZsspAutomata::S1 => {
+            ZetaAutomata::S1 => {
                 log!(app, ResentKeyConfirm(session));
                 (PACKET_TYPE_KEY_CONFIRM, Vec::new())
             }
-            ZsspAutomata::S2 => return,
-            ZsspAutomata::R1 { k1, .. } => {
+            ZetaAutomata::S2 => return,
+            ZetaAutomata::R1 { k1, .. } => {
                 log!(app, ResentK1(session));
                 (PACKET_TYPE_REKEY_INIT, k1.clone())
             }
-            ZsspAutomata::R2 { k2, .. } => {
+            ZetaAutomata::R2 { k2, .. } => {
                 log!(app, ResentK2(session));
                 (PACKET_TYPE_REKEY_COMPLETE, k2.clone())
             }
@@ -928,7 +945,7 @@ fn remap<App: ApplicationLayer>(session: &Arc<Session<App>>, zeta: &Zeta<App>, r
     session_map.insert(new_kid_recv, weak);
     new_kid_recv
 }
-#[allow(unused)]
+/// Corresponds to the timeout timer Transition Algorithm described in Section 4.1 - Definition 3.
 fn timeout_trans<App: ApplicationLayer>(
     zeta: &mut Zeta<App>,
     session: &Arc<Session<App>>,
@@ -938,9 +955,9 @@ fn timeout_trans<App: ApplicationLayer>(
     send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
 ) {
     match &zeta.beta {
-        ZsspAutomata::Null => {}
-        ZsspAutomata::A1(StateA1 { identity, .. }) | ZsspAutomata::A3 { identity, .. } => {
-            if matches!(&zeta.beta, ZsspAutomata::A1(_)) {
+        ZetaAutomata::Null => {}
+        ZetaAutomata::A1(StateA1 { identity, .. }) | ZetaAutomata::A3 { identity, .. } => {
+            if matches!(&zeta.beta, ZetaAutomata::A1(_)) {
                 log!(app, TimeoutX1(session));
             } else {
                 log!(app, TimeoutX3(session));
@@ -963,7 +980,7 @@ fn timeout_trans<App: ApplicationLayer>(
                 zeta.key_mut(true).recv.kid = Some(new_kid_recv);
                 zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
                 zeta.timeout_timer = current_time + App::SETTINGS.initial_offer_timeout as i64;
-                zeta.beta = ZsspAutomata::A1(a1);
+                zeta.beta = ZetaAutomata::A1(a1);
                 zeta.defrag = DefragBuffer::new(Some(hk_recv));
 
                 send(&packet, None);
@@ -971,7 +988,8 @@ fn timeout_trans<App: ApplicationLayer>(
                 zeta.expire();
             }
         }
-        ZsspAutomata::S2 => {
+        ZetaAutomata::S2 => {
+            // Corresponds to Transition Algorithm 6 found in Section 4.3.
             log!(app, StartedRekeyingSentK1(session));
             let new_kid_recv = remap(session, &zeta, &ctx.rng, &ctx.session_map);
             //    -> s
@@ -1005,7 +1023,7 @@ fn timeout_trans<App: ApplicationLayer>(
             zeta.key_mut(true).recv.kid = Some(new_kid_recv);
             zeta.timeout_timer = current_time + App::SETTINGS.rekey_timeout as i64;
             zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
-            zeta.beta = ZsspAutomata::R1 { noise, e_secret, k1: k1.clone() };
+            zeta.beta = ZetaAutomata::R1 { noise, e_secret, k1: k1.clone() };
 
             let c = zeta.send_counter;
             zeta.send_counter += 1;
@@ -1015,20 +1033,21 @@ fn timeout_trans<App: ApplicationLayer>(
 
             send(&Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, k1), Some(&zeta.hk_send));
         }
-        ZsspAutomata::S1 { .. } => {
+        ZetaAutomata::S1 { .. } => {
             log!(app, TimeoutKeyConfirm(session));
             zeta.expire();
         }
-        ZsspAutomata::R1 { .. } => {
+        ZetaAutomata::R1 { .. } => {
             log!(app, TimeoutK1(session));
             zeta.expire();
         }
-        ZsspAutomata::R2 { .. } => {
+        ZetaAutomata::R2 { .. } => {
             log!(app, TimeoutK2(session));
             zeta.expire();
         }
     }
 }
+/// Corresponds to Transition Algorithm 7 found in Section 4.3.
 pub(crate) fn received_k1_trans<App: ApplicationLayer>(
     zeta: &mut Zeta<App>,
     session: &Arc<Session<App>>,
@@ -1055,8 +1074,8 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
         return Err(byzantine_fault!(UnknownLocalKeyId, false));
     }
     let should_rekey_as_bob = match &zeta.beta {
-        ZsspAutomata::S2 { .. } => true,
-        ZsspAutomata::R1 { .. } => zeta.was_bob,
+        ZetaAutomata::S2 { .. } => true,
+        ZetaAutomata::R1 { .. } => zeta.was_bob,
         _ => false,
     };
     if !should_rekey_as_bob {
@@ -1142,7 +1161,7 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
         zeta.key_creation_counter = zeta.send_counter;
         zeta.timeout_timer = current_time + App::SETTINGS.rekey_timeout as i64;
         zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
-        zeta.beta = ZsspAutomata::R2 { k2: k2.clone() };
+        zeta.beta = ZetaAutomata::R2 { k2: k2.clone() };
 
         let c = zeta.send_counter;
         zeta.send_counter += 1;
@@ -1158,6 +1177,7 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
     }
     result
 }
+/// Corresponds to Transition Algorithm 8 found in Section 4.3.
 pub(crate) fn received_k2_trans<App: ApplicationLayer>(
     zeta: &mut Zeta<App>,
     app: &App,
@@ -1175,7 +1195,7 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
         // Some rekey packet may have arrived extremely delayed.
         return Err(byzantine_fault!(UnknownLocalKeyId, false));
     }
-    if !matches!(&zeta.beta, ZsspAutomata::R1 { .. }) {
+    if !matches!(&zeta.beta, ZetaAutomata::R1 { .. }) {
         // Some rekey packet may have arrived extremely delayed.
         return Err(byzantine_fault!(OutOfSequence, false));
     }
@@ -1191,7 +1211,7 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
     }
     k2.truncate(i);
     let result = (|| {
-        if let ZsspAutomata::R1 { noise, e_secret, .. } = &zeta.beta {
+        if let ZetaAutomata::R1 { noise, e_secret, .. } = &zeta.beta {
             let mut noise = noise.clone();
             let mut i = 0;
             // Process message pattern 2 e token.
@@ -1239,7 +1259,7 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
             zeta.key_creation_counter = zeta.send_counter;
             zeta.timeout_timer = current_time + App::SETTINGS.rekey_timeout as i64;
             zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
-            zeta.beta = ZsspAutomata::S1;
+            zeta.beta = ZetaAutomata::S1;
 
             let mut c1 = Vec::new();
             let c = zeta.send_counter;
@@ -1259,6 +1279,7 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
     }
     result
 }
+/// Corresponds to Algorithm 9 found in Section 4.3.
 pub(crate) fn send_payload<App: ApplicationLayer>(
     zeta: &mut Zeta<App>,
     mut payload: Vec<u8>,
@@ -1266,12 +1287,12 @@ pub(crate) fn send_payload<App: ApplicationLayer>(
 ) -> Result<(), SendError> {
     use SendError::*;
 
-    if matches!(&zeta.beta, ZsspAutomata::Null) {
+    if matches!(&zeta.beta, ZetaAutomata::Null) {
         return Err(SessionExpired);
     }
     if !matches!(
         &zeta.beta,
-        ZsspAutomata::S1 | ZsspAutomata::S2 | ZsspAutomata::R1 { .. } | ZsspAutomata::R2 { .. }
+        ZetaAutomata::S1 | ZetaAutomata::S2 | ZetaAutomata::R1 { .. } | ZetaAutomata::R2 { .. }
     ) {
         return Err(SessionNotEstablished);
     }
@@ -1293,6 +1314,7 @@ pub(crate) fn send_payload<App: ApplicationLayer>(
     send(&Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, payload), Some(&zeta.hk_send));
     Ok(())
 }
+/// Corresponds to Algorithm 10 found in Section 4.3.
 pub(crate) fn received_payload_in_place<App: ApplicationLayer>(
     zeta: &mut Zeta<App>,
     kid: NonZeroU32,

From d8e417338c237e598ca5e88fca6d1c9d9ee03805 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Fri, 4 Aug 2023 18:41:15 -0400
Subject: [PATCH 18/37] added docs

---
 src/zeta.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/zeta.rs b/src/zeta.rs
index 18c5259..3b9aa39 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -25,6 +25,8 @@ use crate::LogEvent::*;
 /// it as effectively AAD. Other elements of the header are either not authenticated,
 /// like fragmentation info, or their authentication is implied via key exchange like
 /// the key id.
+///
+/// Corresponds to Figure 10 found in Section 4.3.
 pub(crate) fn to_nonce(packet_type: u8, counter: u64) -> [u8; AES_GCM_IV_SIZE] {
     let mut ret = [0u8; AES_GCM_IV_SIZE];
     ret[3] = packet_type;
@@ -32,6 +34,7 @@ pub(crate) fn to_nonce(packet_type: u8, counter: u64) -> [u8; AES_GCM_IV_SIZE] {
     ret[4..].copy_from_slice(&counter.to_be_bytes());
     ret
 }
+/// Corresponds to Figure 10 found in Section 4.3.
 pub(crate) fn from_nonce(n: &[u8]) -> (u8, u64) {
     assert!(n.len() >= PACKET_NONCE_SIZE);
     let c_start = n.len() - 8;

From 3717fdfd62a4dcb05e2821724875bc578070652c Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Fri, 4 Aug 2023 18:41:45 -0400
Subject: [PATCH 19/37] added docs

---
 src/zeta.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/zeta.rs b/src/zeta.rs
index 3b9aa39..19b655d 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -34,7 +34,7 @@ pub(crate) fn to_nonce(packet_type: u8, counter: u64) -> [u8; AES_GCM_IV_SIZE] {
     ret[4..].copy_from_slice(&counter.to_be_bytes());
     ret
 }
-/// Corresponds to Figure 10 found in Section 4.3.
+/// Corresponds to Figure 10 and Figure 14 found in Section 4.3.
 pub(crate) fn from_nonce(n: &[u8]) -> (u8, u64) {
     assert!(n.len() >= PACKET_NONCE_SIZE);
     let c_start = n.len() - 8;

From 778d9679e15ac62523ef7eb282783c8ec9bcc6ab Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Sun, 6 Aug 2023 17:06:24 -0400
Subject: [PATCH 20/37] fixed major handshake bug

---
 src/symmetric_state.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/symmetric_state.rs b/src/symmetric_state.rs
index bc4a965..878769c 100644
--- a/src/symmetric_state.rs
+++ b/src/symmetric_state.rs
@@ -119,14 +119,13 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     pub fn encrypt_and_hash_in_place(&mut self, iv: [u8; AES_GCM_IV_SIZE], plaintext_start: usize, buffer: &mut Vec<u8>) {
         let tag = App::Aead::encrypt_in_place(&self.k, iv, Some(&self.h), &mut buffer[plaintext_start..]);
         buffer.extend(&tag);
-        let mut hash = App::Hash::new();
-        hash.update(&buffer[plaintext_start..]);
-        self.h = hash.finish();
+        self.mix_hash(&buffer[plaintext_start..]);
     }
     /// Corresponds to Noise `DecryptAndHash`.
     #[must_use]
     pub fn decrypt_and_hash_in_place(&mut self, iv: [u8; AES_GCM_IV_SIZE], buffer: &mut [u8], tag: [u8; AES_GCM_TAG_SIZE]) -> bool {
         let mut hash = App::Hash::new();
+        hash.update(&self.h);
         hash.update(buffer);
         hash.update(&tag);
         let ret = App::Aead::decrypt_in_place(&self.k, iv, Some(&self.h), buffer, tag);

From 75bc95079ba1972738c28d00ec51e2c86bb6a548 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Mon, 7 Aug 2023 09:37:16 -0400
Subject: [PATCH 21/37] added missing constants

---
 src/challenge.rs       |  2 +-
 src/context.rs         |  6 +++---
 src/fragmentation.rs   |  2 +-
 src/proto.rs           | 33 +++++++++++++++++++++++++++++----
 src/result.rs          |  2 ++
 src/symmetric_state.rs |  6 +++---
 src/zeta.rs            |  2 +-
 7 files changed, 40 insertions(+), 13 deletions(-)

diff --git a/src/challenge.rs b/src/challenge.rs
index 26a695b..1a4b68b 100644
--- a/src/challenge.rs
+++ b/src/challenge.rs
@@ -8,7 +8,7 @@ use crate::proto::*;
 pub struct ChallengeContext {
     pub enabled: bool,
     counter: u64,
-    antireplay_window: [u64; COUNTER_WINDOW_MAX_OOO],
+    antireplay_window: [u64; CHALLENGE_COUNTER_WINDOW_MAX_OOO],
     salt: [u8; SALT_SIZE],
 }
 
diff --git a/src/context.rs b/src/context.rs
index 6b80a09..6e7cc98 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -83,9 +83,6 @@ impl<App: ApplicationLayer> Context<App> {
 
     /// Create a new session and send initial packet(s) to other side.
     ///
-    /// This will return SendError::DataTooLarge if the combined size of the metadata and the local
-    /// static public blob (as retrieved from the application layer) exceed MAX_INIT_PAYLOAD_SIZE.
-    ///
     /// * `app` - Application layer instance
     /// * `send` - Function to be called to send one or more initial packets to the remote being
     ///   contacted
@@ -105,6 +102,9 @@ impl<App: ApplicationLayer> Context<App> {
         identity: Vec<u8>,
     ) -> Result<Arc<Session<App>>, OpenError<App::StorageError>> {
         mtu = mtu.max(MIN_TRANSPORT_MTU);
+        if identity.len() > MAX_IDENTITY_BLOB_SIZE {
+            return Err(OpenError::IdentityTooLarge);
+        }
         let ctx = &self.0;
 
         // Process zeta layer.
diff --git a/src/fragmentation.rs b/src/fragmentation.rs
index 2e0db42..a0ceda1 100644
--- a/src/fragmentation.rs
+++ b/src/fragmentation.rs
@@ -82,7 +82,7 @@ impl DefragBuffer {
         vrfy: impl FnOnce(&[u8; PACKET_NONCE_SIZE], usize, usize) -> Result<(), ReceiveError<App::StorageError>>,
     ) -> Result<Option<([u8; PACKET_NONCE_SIZE], Vec<u8>)>, ReceiveError<App::StorageError>> {
         use crate::result::FaultType::*;
-        if raw_fragment.len() < HEADER_AUTH_END {
+        if raw_fragment.len() < MIN_PACKET_SIZE {
             return Err(byzantine_fault!(InvalidPacket, true));
         }
 
diff --git a/src/proto.rs b/src/proto.rs
index e7fc4ed..abd14d3 100644
--- a/src/proto.rs
+++ b/src/proto.rs
@@ -2,6 +2,8 @@ use crate::crypto::{AES_GCM_TAG_SIZE, KYBER_CIPHERTEXT_SIZE, KYBER_PUBLIC_KEY_SI
 
 /* Common constants */
 
+/// Minimum size of a valid physical ZSSP packet of any type. Anything smaller is discarded.
+pub const MIN_PACKET_SIZE: usize = HEADER_SIZE + AES_GCM_TAG_SIZE;
 /// Minimum physical MTU for ZSSP to function.
 /// If an MTU is passed to ZSSP that is lower than this, it will be ignored and instead this value
 /// will be used.
@@ -43,6 +45,8 @@ pub(crate) const PACKET_NONCE_START: usize = HEADER_SIZE - PACKET_NONCE_SIZE;
 pub(crate) const FRAGMENT_NO_IDX: usize = 4;
 pub(crate) const FRAGMENT_COUNT_IDX: usize = 5;
 
+/// Maximum number of fragments a single packet may be split into. If a packet cannot fit
+/// into this number of fragments it will be dropped.
 pub(crate) const MAX_FRAGMENTS: usize = 48;
 
 /* Key exchange constants */
@@ -66,9 +70,10 @@ pub(crate) const HASHLEN: usize = SHA512_HASH_SIZE;
 /// The size in bytes of both a ratchet key and a ratchet fingerprint.
 pub const RATCHET_SIZE: usize = 32;
 
-pub(crate) const PROTOCOL_NAME_NOISE_XK: [u8; HASHLEN] = *b"Noise_XKhfs+psk2_P384+Kyber1024_AESGCM_SHA512\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
-pub(crate) const PROTOCOL_NAME_NOISE_KK: [u8; HASHLEN] =
-    *b"Noise_KKpsk0_P384_AESGCM_SHA512\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
+/// Initial value of 'h'.
+pub(crate) const PROTOCOL_NAME_NOISE_XK: &[u8; HASHLEN] = b"Noise_XKhfs+psk2_P384+Kyber1024_AESGCM_SHA512\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
+/// Initial value of 'ck' for rekeying.
+pub(crate) const PROTOCOL_NAME_NOISE_KK: &[u8; HASHLEN] = b"Noise_KKpsk0_P384_AESGCM_SHA512\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
 
 pub(crate) const LABEL_OTP_TO_RATCHET: &[u8; 19] = b"ZSSP_OTP_TO_RATCHET";
 pub(crate) const LABEL_KBKDF_CHAIN: &[u8; 4] = b"ZSSP";
@@ -77,9 +82,20 @@ pub(crate) const LABEL_HEADER_KEY: &[u8; 4] = b"ASKH";
 pub(crate) const LABEL_KEX_KEY: &[u8; 4] = b"ASKK";
 
 pub(crate) const INIT_COUNTER: u64 = 0;
-pub(crate) const EXPIRE_AFTER_USES: u64 = 4294967295;
+pub(crate) const EXPIRE_AFTER_USES: u64 = 1<<32 - 1;
+/// Determines the number of counters a session will remember. If a counter arrives over
+/// this amount out of order relative to other received counters, it is likely to be
+/// rejected on the basis that the session can't remember if this counter was replayed.
+/// Increasing this value makes a session consume more memory.
 pub(crate) const COUNTER_WINDOW_MAX_OOO: usize = 64;
+/// Maximum number of counter steps that the counter is allowed to skip ahead.
+/// This cannot be changed away from 2^24 without changing the header nonce handling code.
 pub(crate) const COUNTER_WINDOW_MAX_SKIP_AHEAD: u64 = 1 << 24;
+/// Similar to `COUNTER_WINDOW_MAX_OOO`, except this governs the receive context challenge
+/// counter rather than the session counter.
+/// When Bob issues a challenge to Alice to mitigate DDOS, Bob will only accept Alice's
+/// response once, and then its attached counter is added to the window.
+pub(crate) const CHALLENGE_COUNTER_WINDOW_MAX_OOO: usize = 32;
 
 /* Packet constants */
 
@@ -101,9 +117,18 @@ pub(crate) const HANDSHAKE_HELLO_MAX_SIZE: usize = HANDSHAKE_HELLO_MIN_SIZE + RA
 pub(crate) const HANDSHAKE_RESPONSE_SIZE: usize = P384_PUBLIC_KEY_SIZE + KYBER_CIPHERTEXT_SIZE + AES_GCM_TAG_SIZE + KID_SIZE + AES_GCM_TAG_SIZE;
 
 pub(crate) const HANDSHAKE_COMPLETION_MIN_SIZE: usize = P384_PUBLIC_KEY_SIZE + AES_GCM_TAG_SIZE + 0 + AES_GCM_TAG_SIZE;
+pub(crate) const HANDSHAKE_COMPLETION_MAX_SIZE: usize = HANDSHAKE_COMPLETION_MIN_SIZE + MAX_IDENTITY_BLOB_SIZE;
 
 pub(crate) const KEY_CONFIRMATION_SIZE: usize = AES_GCM_TAG_SIZE;
 pub(crate) const ACKNOWLEDGEMENT_SIZE: usize = AES_GCM_TAG_SIZE;
 pub(crate) const SESSION_REJECTED_SIZE: usize = AES_GCM_TAG_SIZE;
 
 pub(crate) const REKEY_SIZE: usize = P384_PUBLIC_KEY_SIZE + KID_SIZE + AES_GCM_TAG_SIZE + AES_GCM_TAG_SIZE;
+
+/// The application has the ability to attach a data payload to Alice's handshake.
+/// It will be the first payload Bob receives from Alice.
+/// The application also must attach a static public identity to their handshake.
+/// The combined size of both in bytes must be at most this value.
+///
+/// If not ZSSP will return `OpenError::DataTooLarge` and refuse to create a session object.
+pub const MAX_IDENTITY_BLOB_SIZE: usize = 4096;
diff --git a/src/result.rs b/src/result.rs
index c9fd0d6..963017f 100644
--- a/src/result.rs
+++ b/src/result.rs
@@ -10,6 +10,8 @@ pub enum OpenError<IoError> {
     /// An invalid parameter was supplied to the function.
     InvalidPublicKey,
 
+    IdentityTooLarge,
+
     RatchetIoError(IoError),
 }
 
diff --git a/src/symmetric_state.rs b/src/symmetric_state.rs
index 878769c..702198a 100644
--- a/src/symmetric_state.rs
+++ b/src/symmetric_state.rs
@@ -71,11 +71,11 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     }
 
     /// Corresponds to Noise `Initialize` on a SymmetricState.
-    pub fn initialize(h: [u8; HASHLEN]) -> Self {
+    pub fn initialize(h: &[u8; HASHLEN]) -> Self {
         Self {
             k: Zeroizing::default(),
-            ck: Zeroizing::new(h),
-            h,
+            ck: Zeroizing::new(*h),
+            h: *h,
             _app: PhantomData,
         }
     }
diff --git a/src/zeta.rs b/src/zeta.rs
index 19b655d..7113133 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -607,7 +607,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
 ) -> Result<Arc<Session<App>>, ReceiveError<App::StorageError>> {
     use FaultType::*;
     //    -> s, se
-    if x3.len() < HANDSHAKE_COMPLETION_MIN_SIZE {
+    if !(HANDSHAKE_COMPLETION_MIN_SIZE..=HANDSHAKE_COMPLETION_MAX_SIZE).contains(&x3.len()) {
         return Err(byzantine_fault!(InvalidPacket, true));
     }
     if kid != zeta.kid_recv {

From 3395f7b7cf6992dbda9cca10ef4bb4b76a9639f5 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Mon, 7 Aug 2023 09:41:06 -0400
Subject: [PATCH 22/37] cargo fmt

---
 src/context.rs | 2 +-
 src/proto.rs   | 9 +++++----
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/context.rs b/src/context.rs
index 6e7cc98..2974c51 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -102,7 +102,7 @@ impl<App: ApplicationLayer> Context<App> {
         identity: Vec<u8>,
     ) -> Result<Arc<Session<App>>, OpenError<App::StorageError>> {
         mtu = mtu.max(MIN_TRANSPORT_MTU);
-        if identity.len() > MAX_IDENTITY_BLOB_SIZE {
+        if identity.len() > IDENTITY_MAX_SIZE {
             return Err(OpenError::IdentityTooLarge);
         }
         let ctx = &self.0;
diff --git a/src/proto.rs b/src/proto.rs
index abd14d3..d0ee289 100644
--- a/src/proto.rs
+++ b/src/proto.rs
@@ -73,7 +73,8 @@ pub const RATCHET_SIZE: usize = 32;
 /// Initial value of 'h'.
 pub(crate) const PROTOCOL_NAME_NOISE_XK: &[u8; HASHLEN] = b"Noise_XKhfs+psk2_P384+Kyber1024_AESGCM_SHA512\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
 /// Initial value of 'ck' for rekeying.
-pub(crate) const PROTOCOL_NAME_NOISE_KK: &[u8; HASHLEN] = b"Noise_KKpsk0_P384_AESGCM_SHA512\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
+pub(crate) const PROTOCOL_NAME_NOISE_KK: &[u8; HASHLEN] =
+    b"Noise_KKpsk0_P384_AESGCM_SHA512\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
 
 pub(crate) const LABEL_OTP_TO_RATCHET: &[u8; 19] = b"ZSSP_OTP_TO_RATCHET";
 pub(crate) const LABEL_KBKDF_CHAIN: &[u8; 4] = b"ZSSP";
@@ -82,7 +83,7 @@ pub(crate) const LABEL_HEADER_KEY: &[u8; 4] = b"ASKH";
 pub(crate) const LABEL_KEX_KEY: &[u8; 4] = b"ASKK";
 
 pub(crate) const INIT_COUNTER: u64 = 0;
-pub(crate) const EXPIRE_AFTER_USES: u64 = 1<<32 - 1;
+pub(crate) const EXPIRE_AFTER_USES: u64 = 1 << 32 - 1;
 /// Determines the number of counters a session will remember. If a counter arrives over
 /// this amount out of order relative to other received counters, it is likely to be
 /// rejected on the basis that the session can't remember if this counter was replayed.
@@ -117,7 +118,7 @@ pub(crate) const HANDSHAKE_HELLO_MAX_SIZE: usize = HANDSHAKE_HELLO_MIN_SIZE + RA
 pub(crate) const HANDSHAKE_RESPONSE_SIZE: usize = P384_PUBLIC_KEY_SIZE + KYBER_CIPHERTEXT_SIZE + AES_GCM_TAG_SIZE + KID_SIZE + AES_GCM_TAG_SIZE;
 
 pub(crate) const HANDSHAKE_COMPLETION_MIN_SIZE: usize = P384_PUBLIC_KEY_SIZE + AES_GCM_TAG_SIZE + 0 + AES_GCM_TAG_SIZE;
-pub(crate) const HANDSHAKE_COMPLETION_MAX_SIZE: usize = HANDSHAKE_COMPLETION_MIN_SIZE + MAX_IDENTITY_BLOB_SIZE;
+pub(crate) const HANDSHAKE_COMPLETION_MAX_SIZE: usize = HANDSHAKE_COMPLETION_MIN_SIZE + IDENTITY_MAX_SIZE;
 
 pub(crate) const KEY_CONFIRMATION_SIZE: usize = AES_GCM_TAG_SIZE;
 pub(crate) const ACKNOWLEDGEMENT_SIZE: usize = AES_GCM_TAG_SIZE;
@@ -131,4 +132,4 @@ pub(crate) const REKEY_SIZE: usize = P384_PUBLIC_KEY_SIZE + KID_SIZE + AES_GCM_T
 /// The combined size of both in bytes must be at most this value.
 ///
 /// If not ZSSP will return `OpenError::DataTooLarge` and refuse to create a session object.
-pub const MAX_IDENTITY_BLOB_SIZE: usize = 4096;
+pub const IDENTITY_MAX_SIZE: usize = 4096;

From 1cbc455876210134d2a8a69b6fc4c6a135ce645d Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Mon, 7 Aug 2023 15:08:29 -0400
Subject: [PATCH 23/37] cargo fmt

---
 examples/basic_test.rs       |  33 ++++-
 rustfmt.toml                 |   2 +-
 src/applicationlayer.rs      |   5 +-
 src/challenge.rs             |   5 +-
 src/context.rs               | 239 ++++++++++++++++++++++-------------
 src/crypto/aes.rs            |   7 +-
 src/crypto/kyber1024.rs      |   5 +-
 src/crypto_impl/aes_impl.rs  |   7 +-
 src/crypto_impl/kyber1024.rs |   5 +-
 src/crypto_impl/p384_impl.rs |   8 +-
 src/fragmentation.rs         |  19 ++-
 src/proto.rs                 |  13 +-
 src/symmetric_state.rs       |  23 +++-
 src/zeta.rs                  | 175 +++++++++++++++++++------
 14 files changed, 402 insertions(+), 144 deletions(-)

diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index 650721b..8770adb 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -21,7 +21,9 @@ use rand_core::OsRng;
 use rand_core::RngCore;
 use sha2::Sha512;
 
-use zssp_proto::applicationlayer::{AcceptAction, ApplicationLayer, RatchetState, RatchetUpdate, Settings, RATCHET_SIZE};
+use zssp_proto::applicationlayer::{
+    AcceptAction, ApplicationLayer, RatchetState, RatchetUpdate, Settings, RATCHET_SIZE,
+};
 use zssp_proto::crypto_impl::PqcKyberSecretKey;
 use zssp_proto::Session;
 
@@ -81,7 +83,10 @@ impl ApplicationLayer for &TestApplication {
         }
     }
 
-    fn restore_by_fingerprint(&self, ratchet_fingerprint: &[u8; RATCHET_SIZE]) -> Result<Option<RatchetState>, Self::StorageError> {
+    fn restore_by_fingerprint(
+        &self,
+        ratchet_fingerprint: &[u8; RATCHET_SIZE],
+    ) -> Result<Option<RatchetState>, Self::StorageError> {
         let ratchets = self.ratchets.lock().unwrap();
         Ok(ratchets.rf_map.get(ratchet_fingerprint).cloned())
     }
@@ -156,7 +161,14 @@ fn alice_main(
             up = false;
             alice_session = Some(
                 context
-                    .open(alice_app, |b| alice_out.send(b).is_ok(), TEST_MTU, bob_pubkey.clone(), 0, Vec::new())
+                    .open(
+                        alice_app,
+                        |b| alice_out.send(b).is_ok(),
+                        TEST_MTU,
+                        bob_pubkey.clone(),
+                        0,
+                        Vec::new(),
+                    )
                     .unwrap(),
             );
             println!("[alice] opening session");
@@ -225,7 +237,8 @@ fn alice_main(
         }
 
         if current_time >= next_service {
-            next_service = current_time + context.service(alice_app, |_| Some((|b| alice_out.send(b).is_ok(), TEST_MTU)));
+            next_service =
+                current_time + context.service(alice_app, |_| Some((|b| alice_out.send(b).is_ok(), TEST_MTU)));
         }
     }
 }
@@ -345,7 +358,17 @@ fn core(time: u64, packet_success_rate: u32) {
                 )
             });
         }
-        ts.spawn(move || bob_main(run, packet_success_rate, &bob_app, bob_out, bob_in, alice_out, bob_keypair));
+        ts.spawn(move || {
+            bob_main(
+                run,
+                packet_success_rate,
+                &bob_app,
+                bob_out,
+                bob_in,
+                alice_out,
+                bob_keypair,
+            )
+        });
 
         thread::sleep(Duration::from_secs(time));
 
diff --git a/rustfmt.toml b/rustfmt.toml
index 3a3929c..9c9fedd 100644
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -1,4 +1,4 @@
-max_width = 150
+max_width = 120
 edition = "2021"
 newline_style = "Unix"
 struct_lit_width = 60
diff --git a/src/applicationlayer.rs b/src/applicationlayer.rs
index 9856b4b..53090d5 100644
--- a/src/applicationlayer.rs
+++ b/src/applicationlayer.rs
@@ -189,7 +189,10 @@ pub trait ApplicationLayer: Sized {
     /// If `RatchetAction::DowngradeRatchet` is returned we will attempt to convince Alice to downgrade
     /// to the empty ratchet key, restarting the ratchet chain.
     /// If `RatchetAction::FailAuthentication` is returned Alice's connection will be silently dropped.
-    fn restore_by_fingerprint(&self, ratchet_fingerprint: &[u8; RATCHET_SIZE]) -> Result<Option<RatchetState>, Self::StorageError>;
+    fn restore_by_fingerprint(
+        &self,
+        ratchet_fingerprint: &[u8; RATCHET_SIZE],
+    ) -> Result<Option<RatchetState>, Self::StorageError>;
     /// Lookup the specific ratchet states based on the identity of the peer being communicated with.
     /// This function will be called whenever Alice attempts to open a session, or Bob attempts
     /// to verify Alice's identity.
diff --git a/src/challenge.rs b/src/challenge.rs
index 1a4b68b..5249a7d 100644
--- a/src/challenge.rs
+++ b/src/challenge.rs
@@ -58,7 +58,10 @@ impl ChallengeContext {
             return Ok(false);
         }
         let c = u64::from_be_bytes(response[..COUNTER_SIZE].try_into().unwrap());
-        if self.check_window(c) && secure_eq(&response[COUNTER_SIZE..POW_START], &self.create_mac::<Hash>(c, addr)) && verify_pow::<Hash>(response) {
+        if self.check_window(c)
+            && secure_eq(&response[COUNTER_SIZE..POW_START], &self.create_mac::<Hash>(c, addr))
+            && verify_pow::<Hash>(response)
+        {
             self.update_window(c);
             Ok(true)
         } else {
diff --git a/src/context.rs b/src/context.rs
index 2974c51..ca4b4a9 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -149,43 +149,53 @@ impl<App: ApplicationLayer> Context<App> {
             if let Some(Some(session)) = session {
                 // Process recv fragmentation layer.
                 let mut zeta = session.0.lock().unwrap();
-                let result = zeta.defrag.received_fragment::<App>(raw_fragment, app.time(), |n, frag_no, frag_count| {
-                    let (p, c) = from_nonce(n);
-                    if p != PACKET_TYPE_DATA {
-                        log!(app, ReceivedRawFragment(p, c, frag_no, frag_count));
-                    }
-                    if p == PACKET_TYPE_HANDSHAKE_RESPONSE {
-                        if !matches!(&zeta.beta, ZetaAutomata::A1(_)) {
-                            // A resent handshake response from Bob may have arrived out of order,
-                            // after we already received one.
-                            return Err(byzantine_fault!(OutOfSequence, false));
-                        }
-                        if c >= COUNTER_WINDOW_MAX_SKIP_AHEAD {
-                            return Err(byzantine_fault!(ExpiredCounter, true));
-                        }
-                        Ok(())
-                    } else if PACKET_TYPE_USES_COUNTER_RANGE.contains(&p) {
-                        if !zeta.check_counter_window(c) {
-                            // The counter window has finite memory and so will occasionally give
-                            // false positives on very out-of-order packets.
-                            return Err(byzantine_fault!(ExpiredCounter, false));
-                        }
-                        Ok(())
-                    } else if p == PACKET_TYPE_HANDSHAKE_COMPLETION {
-                        // The handshake completion packet could have been resent.
-                        return Err(byzantine_fault!(InvalidPacket, false));
-                    } else {
-                        return Err(byzantine_fault!(InvalidPacket, true));
-                    }
-                })?;
+                let result =
+                    zeta.defrag
+                        .received_fragment::<App>(raw_fragment, app.time(), |n, frag_no, frag_count| {
+                            let (p, c) = from_nonce(n);
+                            if p != PACKET_TYPE_DATA {
+                                log!(app, ReceivedRawFragment(p, c, frag_no, frag_count));
+                            }
+                            if p == PACKET_TYPE_HANDSHAKE_RESPONSE {
+                                if !matches!(&zeta.beta, ZetaAutomata::A1(_)) {
+                                    // A resent handshake response from Bob may have arrived out of order,
+                                    // after we already received one.
+                                    return Err(byzantine_fault!(OutOfSequence, false));
+                                }
+                                if c >= COUNTER_WINDOW_MAX_SKIP_AHEAD {
+                                    return Err(byzantine_fault!(ExpiredCounter, true));
+                                }
+                                Ok(())
+                            } else if PACKET_TYPE_USES_COUNTER_RANGE.contains(&p) {
+                                if !zeta.check_counter_window(c) {
+                                    // The counter window has finite memory and so will occasionally give
+                                    // false positives on very out-of-order packets.
+                                    return Err(byzantine_fault!(ExpiredCounter, false));
+                                }
+                                Ok(())
+                            } else if p == PACKET_TYPE_HANDSHAKE_COMPLETION {
+                                // The handshake completion packet could have been resent.
+                                return Err(byzantine_fault!(InvalidPacket, false));
+                            } else {
+                                return Err(byzantine_fault!(InvalidPacket, true));
+                            }
+                        })?;
                 if let Some((pn, mut assembled_packet)) = result {
                     // Process recv zeta layer.
-                    let send_associated = |Packet(kid, nonce, payload): &Packet, hk: Option<&[u8; AES_256_KEY_SIZE]>| {
-                        if let Some((send_fragment, mut mtu)) = send_to(&session) {
-                            mtu = mtu.max(MIN_TRANSPORT_MTU);
-                            send_with_fragmentation::<App>(send_fragment, mtu, *kid, to_packet_nonce(&nonce), payload, hk);
-                        }
-                    };
+                    let send_associated =
+                        |Packet(kid, nonce, payload): &Packet, hk: Option<&[u8; AES_256_KEY_SIZE]>| {
+                            if let Some((send_fragment, mut mtu)) = send_to(&session) {
+                                mtu = mtu.max(MIN_TRANSPORT_MTU);
+                                send_with_fragmentation::<App>(
+                                    send_fragment,
+                                    mtu,
+                                    *kid,
+                                    to_packet_nonce(&nonce),
+                                    payload,
+                                    hk,
+                                );
+                            }
+                        };
 
                     let (p, _) = from_nonce(&pn);
                     let ret = match p {
@@ -210,8 +220,15 @@ impl<App: ApplicationLayer> Context<App> {
                         }
                         PACKET_TYPE_KEY_CONFIRM => {
                             log!(app, ReceivedRawKeyConfirm);
-                            let result =
-                                received_c1_trans(&mut zeta, &app, &ctx.rng, kid_recv, to_aes_nonce(&pn), assembled_packet, send_associated)?;
+                            let result = received_c1_trans(
+                                &mut zeta,
+                                &app,
+                                &ctx.rng,
+                                kid_recv,
+                                to_aes_nonce(&pn),
+                                assembled_packet,
+                                send_associated,
+                            )?;
                             log!(app, KeyConfirmIsAuthSentAck(&session));
                             if result {
                                 SessionEvent::Established
@@ -221,7 +238,14 @@ impl<App: ApplicationLayer> Context<App> {
                         }
                         PACKET_TYPE_ACK => {
                             log!(app, ReceivedRawAck);
-                            received_c2_trans(&mut zeta, &app, &ctx.rng, kid_recv, to_aes_nonce(&pn), assembled_packet)?;
+                            received_c2_trans(
+                                &mut zeta,
+                                &app,
+                                &ctx.rng,
+                                kid_recv,
+                                to_aes_nonce(&pn),
+                                assembled_packet,
+                            )?;
                             log!(app, AckIsAuth(&session));
                             SessionEvent::Control
                         }
@@ -244,7 +268,14 @@ impl<App: ApplicationLayer> Context<App> {
                         }
                         PACKET_TYPE_REKEY_COMPLETE => {
                             log!(app, ReceivedRawK2);
-                            received_k2_trans(&mut zeta, &app, kid_recv, to_aes_nonce(&pn), assembled_packet, send_associated)?;
+                            received_k2_trans(
+                                &mut zeta,
+                                &app,
+                                kid_recv,
+                                to_aes_nonce(&pn),
+                                assembled_packet,
+                                send_associated,
+                            )?;
                             log!(app, K2IsAuthSentKeyConfirm(&session));
                             SessionEvent::Control
                         }
@@ -266,28 +297,37 @@ impl<App: ApplicationLayer> Context<App> {
                 if let Entry::Occupied(mut entry) = b2_map.entry(kid_recv) {
                     let zeta = entry.get_mut();
                     // Process recv fragmentation layer.
-                    let result = zeta.defrag.received_fragment::<App>(raw_fragment, app.time(), |n, frag_no, frag_count| {
-                        let (p, c) = from_nonce(n);
-                        log!(app, ReceivedRawFragment(p, c, frag_no, frag_count));
-                        if p == PACKET_TYPE_HANDSHAKE_COMPLETION && c == 0 {
-                            Ok(())
-                        } else {
-                            Err(byzantine_fault!(InvalidPacket, true))
-                        }
-                    })?;
+                    let result =
+                        zeta.defrag
+                            .received_fragment::<App>(raw_fragment, app.time(), |n, frag_no, frag_count| {
+                                let (p, c) = from_nonce(n);
+                                log!(app, ReceivedRawFragment(p, c, frag_no, frag_count));
+                                if p == PACKET_TYPE_HANDSHAKE_COMPLETION && c == 0 {
+                                    Ok(())
+                                } else {
+                                    Err(byzantine_fault!(InvalidPacket, true))
+                                }
+                            })?;
                     if let Some((_, assembled_packet)) = result {
                         log!(app, ReceivedRawX3);
                         let zeta = entry.remove();
-                        let session = received_x3_trans(zeta, &app, ctx, kid_recv, assembled_packet, |Packet(kid, nonce, payload), hk| {
-                            send_with_fragmentation::<App>(
-                                send_unassociated_reply,
-                                send_unassociated_mtu,
-                                *kid,
-                                to_packet_nonce(&nonce),
-                                payload,
-                                hk,
-                            );
-                        })?;
+                        let session = received_x3_trans(
+                            zeta,
+                            &app,
+                            ctx,
+                            kid_recv,
+                            assembled_packet,
+                            |Packet(kid, nonce, payload), hk| {
+                                send_with_fragmentation::<App>(
+                                    send_unassociated_reply,
+                                    send_unassociated_mtu,
+                                    *kid,
+                                    to_packet_nonce(&nonce),
+                                    payload,
+                                    hk,
+                                );
+                            },
+                        )?;
                         log!(app, X3IsAuthSentKeyConfirm(&session));
                         Ok(ReceiveOk::Session(session, SessionEvent::NewSession))
                     } else {
@@ -301,11 +341,10 @@ impl<App: ApplicationLayer> Context<App> {
             }
         } else {
             // Process recv fragmentation layer.
-            let result = ctx
-                .hello_defrag
-                .lock()
-                .unwrap()
-                .received_fragment::<App>(raw_fragment, app.time(), |n, frag_no, frag_count| {
+            let result = ctx.hello_defrag.lock().unwrap().received_fragment::<App>(
+                raw_fragment,
+                app.time(),
+                |n, frag_no, frag_count| {
                     let (p, c) = from_nonce(n);
                     log!(app, ReceivedRawFragment(p, c, frag_no, frag_count));
                     if p == PACKET_TYPE_HANDSHAKE_HELLO || p == PACKET_TYPE_CHALLENGE {
@@ -313,18 +352,18 @@ impl<App: ApplicationLayer> Context<App> {
                     } else {
                         Err(byzantine_fault!(InvalidPacket, true))
                     }
-                })?;
+                },
+            )?;
             if let Some((n, mut assembled_packet)) = result {
                 let (p, _) = from_nonce(&n);
                 if p == PACKET_TYPE_HANDSHAKE_HELLO {
                     log!(app, ReceivedRawX1);
                     // Process recv challenge layer.
                     let challenge_start = assembled_packet.len() - CHALLENGE_SIZE;
-                    let result = ctx
-                        .challenge
-                        .lock()
-                        .unwrap()
-                        .process_hello::<App::Hash>(remote_address, (&assembled_packet[challenge_start..]).try_into().unwrap());
+                    let result = ctx.challenge.lock().unwrap().process_hello::<App::Hash>(
+                        remote_address,
+                        (&assembled_packet[challenge_start..]).try_into().unwrap(),
+                    );
                     if let Err(challenge) = result {
                         log!(app, X1FailedChallengeSentNewChallenge);
                         let mut challenge_packet = Vec::new();
@@ -347,16 +386,22 @@ impl<App: ApplicationLayer> Context<App> {
                     assembled_packet.truncate(challenge_start);
 
                     // Process recv zeta layer.
-                    received_x1_trans(&app, &ctx, to_aes_nonce(&n), assembled_packet, |Packet(kid, nonce, payload), hk| {
-                        send_with_fragmentation::<App>(
-                            send_unassociated_reply,
-                            send_unassociated_mtu,
-                            *kid,
-                            to_packet_nonce(&nonce),
-                            payload,
-                            Some(hk),
-                        );
-                    })?;
+                    received_x1_trans(
+                        &app,
+                        &ctx,
+                        to_aes_nonce(&n),
+                        assembled_packet,
+                        |Packet(kid, nonce, payload), hk| {
+                            send_with_fragmentation::<App>(
+                                send_unassociated_reply,
+                                send_unassociated_mtu,
+                                *kid,
+                                to_packet_nonce(&nonce),
+                                payload,
+                                Some(hk),
+                            );
+                        },
+                    )?;
                     log!(app, X1IsAuthSentX2);
                     Ok(ReceiveOk::Unassociated)
                 } else if p == PACKET_TYPE_CHALLENGE {
@@ -365,10 +410,17 @@ impl<App: ApplicationLayer> Context<App> {
                     if assembled_packet.len() != KID_SIZE + CHALLENGE_SIZE {
                         return Err(byzantine_fault!(InvalidPacket, true));
                     }
-                    if let Some(kid_recv) = NonZeroU32::new(u32::from_be_bytes(assembled_packet[..KID_SIZE].try_into().unwrap())) {
-                        if let Some(Some(session)) = ctx.session_map.lock().unwrap().get(&kid_recv).map(|r| r.upgrade()) {
+                    if let Some(kid_recv) =
+                        NonZeroU32::new(u32::from_be_bytes(assembled_packet[..KID_SIZE].try_into().unwrap()))
+                    {
+                        if let Some(Some(session)) = ctx.session_map.lock().unwrap().get(&kid_recv).map(|r| r.upgrade())
+                        {
                             let mut zeta = session.0.lock().unwrap();
-                            respond_to_challenge(&mut zeta, &ctx.rng, &assembled_packet[KID_SIZE..].try_into().unwrap());
+                            respond_to_challenge(
+                                &mut zeta,
+                                &ctx.rng,
+                                &assembled_packet[KID_SIZE..].try_into().unwrap(),
+                            );
                             log!(app, ChallengeIsAuth(&session));
                             return Ok(ReceiveOk::Unassociated);
                         }
@@ -390,7 +442,13 @@ impl<App: ApplicationLayer> Context<App> {
     ///   slice of `data`
     /// * `mtu` - The MTU of the link, all packets passed to `send` will be at most `mtu` in length
     /// * `payload` - Data to send
-    pub fn send(&self, session: &Arc<Session<App>>, send: impl FnMut(Vec<u8>) -> bool, mut mtu: usize, payload: Vec<u8>) -> Result<(), SendError> {
+    pub fn send(
+        &self,
+        session: &Arc<Session<App>>,
+        send: impl FnMut(Vec<u8>) -> bool,
+        mut mtu: usize,
+        payload: Vec<u8>,
+    ) -> Result<(), SendError> {
         mtu = mtu.max(MIN_TRANSPORT_MTU);
         let mut zeta = session.0.lock().unwrap();
         send_payload(&mut zeta, payload, |Packet(kid, nonce, payload), hk| {
@@ -405,7 +463,11 @@ impl<App: ApplicationLayer> Context<App> {
     /// a problem.
     ///
     /// * `send_to` - Function to get a sender and an MTU to send something over an active session
-    pub fn service<SendFn: FnMut(Vec<u8>) -> bool>(&self, app: App, mut send_to: impl FnMut(&Arc<Session<App>>) -> Option<(SendFn, usize)>) -> i64 {
+    pub fn service<SendFn: FnMut(Vec<u8>) -> bool>(
+        &self,
+        app: App,
+        mut send_to: impl FnMut(&Arc<Session<App>>) -> Option<(SendFn, usize)>,
+    ) -> i64 {
         let ctx = &self.0;
         let sessions = ctx.sessions.lock().unwrap();
         let current_time = app.time();
@@ -422,7 +484,14 @@ impl<App: ApplicationLayer> Context<App> {
                     |Packet(kid, nonce, payload): &Packet, hk| {
                         if let Some((send_fragment, mut mtu)) = send_to(&session) {
                             mtu = mtu.max(MIN_TRANSPORT_MTU);
-                            send_with_fragmentation::<App>(send_fragment, mtu, *kid, to_packet_nonce(&nonce), payload, hk);
+                            send_with_fragmentation::<App>(
+                                send_fragment,
+                                mtu,
+                                *kid,
+                                to_packet_nonce(&nonce),
+                                payload,
+                                hk,
+                            );
                         }
                     },
                 );
diff --git a/src/crypto/aes.rs b/src/crypto/aes.rs
index d5f1d56..9a16d87 100644
--- a/src/crypto/aes.rs
+++ b/src/crypto/aes.rs
@@ -27,7 +27,12 @@ pub trait PrpAes256 {
 pub trait AeadAesGcm {
     /// Encrypt the given `buffer` of plaintext using AES-GCM-256, with the given `key`, `iv` and `aad`.
     /// The ciphertext should be written directly back to `buffer`, and the GCM tag should be returned.
-    fn encrypt_in_place(key: &[u8; AES_256_KEY_SIZE], iv: [u8; AES_GCM_IV_SIZE], aad: Option<&[u8]>, buffer: &mut [u8]) -> [u8; AES_GCM_TAG_SIZE];
+    fn encrypt_in_place(
+        key: &[u8; AES_256_KEY_SIZE],
+        iv: [u8; AES_GCM_IV_SIZE],
+        aad: Option<&[u8]>,
+        buffer: &mut [u8],
+    ) -> [u8; AES_GCM_TAG_SIZE];
     /// Decrypt the given `buffer` of ciphertext using AES-GCM-256, with the given `key`, `iv` and `aad`.
     /// The ciphertext should be written directly back to `buffer`, and the GCM tag should be returned.
     fn decrypt_in_place(
diff --git a/src/crypto/kyber1024.rs b/src/crypto/kyber1024.rs
index 185ab6b..9c5b5c5 100644
--- a/src/crypto/kyber1024.rs
+++ b/src/crypto/kyber1024.rs
@@ -24,7 +24,10 @@ pub trait PrivateKeyKyber1024<Rng: RngCore + CryptoRng>: Sized + Send + Sync {
     ///
     /// **CRITICAL**: This must return `None` if the given `public_key` is invalid in any way
     /// according to the Kyber1024 spec.
-    fn encapsulate(rng: &mut Rng, public_key: &[u8; KYBER_PUBLIC_KEY_SIZE]) -> Option<([u8; KYBER_CIPHERTEXT_SIZE], [u8; KYBER_PLAINTEXT_SIZE])>;
+    fn encapsulate(
+        rng: &mut Rng,
+        public_key: &[u8; KYBER_PUBLIC_KEY_SIZE],
+    ) -> Option<([u8; KYBER_CIPHERTEXT_SIZE], [u8; KYBER_PLAINTEXT_SIZE])>;
     /// Decapsulate a Kyber1024 `ciphertext` received from the remote peer, retreiving
     /// the raw bytes of the original plaintext. This plaintext is immediately hashed and deleted.
     ///
diff --git a/src/crypto_impl/aes_impl.rs b/src/crypto_impl/aes_impl.rs
index 9a2edab..c19b26d 100644
--- a/src/crypto_impl/aes_impl.rs
+++ b/src/crypto_impl/aes_impl.rs
@@ -18,7 +18,12 @@ impl PrpAes256 for Aes256 {
 }
 
 impl AeadAesGcm for Aes256Gcm {
-    fn encrypt_in_place(key: &[u8; AES_256_KEY_SIZE], iv: [u8; AES_GCM_IV_SIZE], aad: Option<&[u8]>, buffer: &mut [u8]) -> [u8; AES_GCM_TAG_SIZE] {
+    fn encrypt_in_place(
+        key: &[u8; AES_256_KEY_SIZE],
+        iv: [u8; AES_GCM_IV_SIZE],
+        aad: Option<&[u8]>,
+        buffer: &mut [u8],
+    ) -> [u8; AES_GCM_TAG_SIZE] {
         let key = Key::<Aes256Gcm>::from_slice(key);
         let mut cipher = Aes256Gcm::new(&key);
         cipher
diff --git a/src/crypto_impl/kyber1024.rs b/src/crypto_impl/kyber1024.rs
index 4c5ed15..9f56dc3 100644
--- a/src/crypto_impl/kyber1024.rs
+++ b/src/crypto_impl/kyber1024.rs
@@ -13,7 +13,10 @@ impl<Rng: RngCore + CryptoRng> PrivateKeyKyber1024<Rng> for PqcKyberSecretKey {
         (Zeroizing::new(keypair.secret), keypair.public)
     }
 
-    fn encapsulate(rng: &mut Rng, public_key: &[u8; KYBER_PUBLIC_KEY_SIZE]) -> Option<([u8; KYBER_CIPHERTEXT_SIZE], [u8; KYBER_PLAINTEXT_SIZE])> {
+    fn encapsulate(
+        rng: &mut Rng,
+        public_key: &[u8; KYBER_PUBLIC_KEY_SIZE],
+    ) -> Option<([u8; KYBER_CIPHERTEXT_SIZE], [u8; KYBER_PLAINTEXT_SIZE])> {
         pqc_kyber::encapsulate(public_key, rng).ok()
     }
 
diff --git a/src/crypto_impl/p384_impl.rs b/src/crypto_impl/p384_impl.rs
index ddf6e68..d20705a 100644
--- a/src/crypto_impl/p384_impl.rs
+++ b/src/crypto_impl/p384_impl.rs
@@ -26,6 +26,12 @@ impl<Rng: RngCore + CryptoRng> KeyPairP384<Rng> for EphemeralSecret {
     }
 
     fn agree(&self, public_key: &Self::PublicKey) -> Option<[u8; P384_ECDH_SHARED_SECRET_SIZE]> {
-        Some(self.diffie_hellman(public_key).raw_secret_bytes().as_slice().try_into().unwrap())
+        Some(
+            self.diffie_hellman(public_key)
+                .raw_secret_bytes()
+                .as_slice()
+                .try_into()
+                .unwrap(),
+        )
     }
 }
diff --git a/src/fragmentation.rs b/src/fragmentation.rs
index a0ceda1..902f836 100644
--- a/src/fragmentation.rs
+++ b/src/fragmentation.rs
@@ -10,7 +10,12 @@ use crate::proto::*;
 use crate::result::{byzantine_fault, ReceiveError};
 
 /// Corresponds to Figure 13 found in Section 6.
-fn create_fragment_header(kid_send: u32, fragment_count: usize, fragment_no: usize, n: &[u8; PACKET_NONCE_SIZE]) -> [u8; HEADER_SIZE] {
+fn create_fragment_header(
+    kid_send: u32,
+    fragment_count: usize,
+    fragment_no: usize,
+    n: &[u8; PACKET_NONCE_SIZE],
+) -> [u8; HEADER_SIZE] {
     debug_assert!(fragment_count > 0);
     debug_assert!(fragment_count <= MAX_FRAGMENTS);
     debug_assert!(fragment_no < MAX_FRAGMENTS);
@@ -47,7 +52,10 @@ pub fn send_with_fragmentation<App: ApplicationLayer>(
         fragment.extend(&packet[i..j]);
 
         if let Some(hk_send) = hk_send {
-            App::Prp::encrypt_in_place(hk_send, (&mut fragment[HEADER_AUTH_START..HEADER_AUTH_END]).try_into().unwrap());
+            App::Prp::encrypt_in_place(
+                hk_send,
+                (&mut fragment[HEADER_AUTH_START..HEADER_AUTH_END]).try_into().unwrap(),
+            );
         }
         if !send(fragment) {
             return false;
@@ -87,7 +95,12 @@ impl DefragBuffer {
         }
 
         if let Some(hk_recv) = self.hk_recv.as_ref() {
-            App::Prp::decrypt_in_place(hk_recv, (&mut raw_fragment[HEADER_AUTH_START..HEADER_AUTH_END]).try_into().unwrap())
+            App::Prp::decrypt_in_place(
+                hk_recv,
+                (&mut raw_fragment[HEADER_AUTH_START..HEADER_AUTH_END])
+                    .try_into()
+                    .unwrap(),
+            )
         }
 
         let fragment_no = raw_fragment[FRAGMENT_NO_IDX] as usize;
diff --git a/src/proto.rs b/src/proto.rs
index d0ee289..68594bb 100644
--- a/src/proto.rs
+++ b/src/proto.rs
@@ -1,4 +1,6 @@
-use crate::crypto::{AES_GCM_TAG_SIZE, KYBER_CIPHERTEXT_SIZE, KYBER_PUBLIC_KEY_SIZE, P384_PUBLIC_KEY_SIZE, SHA512_HASH_SIZE};
+use crate::crypto::{
+    AES_GCM_TAG_SIZE, KYBER_CIPHERTEXT_SIZE, KYBER_PUBLIC_KEY_SIZE, P384_PUBLIC_KEY_SIZE, SHA512_HASH_SIZE,
+};
 
 /* Common constants */
 
@@ -71,7 +73,8 @@ pub(crate) const HASHLEN: usize = SHA512_HASH_SIZE;
 pub const RATCHET_SIZE: usize = 32;
 
 /// Initial value of 'h'.
-pub(crate) const PROTOCOL_NAME_NOISE_XK: &[u8; HASHLEN] = b"Noise_XKhfs+psk2_P384+Kyber1024_AESGCM_SHA512\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
+pub(crate) const PROTOCOL_NAME_NOISE_XK: &[u8; HASHLEN] =
+    b"Noise_XKhfs+psk2_P384+Kyber1024_AESGCM_SHA512\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
 /// Initial value of 'ck' for rekeying.
 pub(crate) const PROTOCOL_NAME_NOISE_KK: &[u8; HASHLEN] =
     b"Noise_KKpsk0_P384_AESGCM_SHA512\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
@@ -112,10 +115,12 @@ pub(crate) const PACKET_TYPE_DATA: u8 = 8;
 pub(crate) const PACKET_TYPE_CHALLENGE: u8 = 9;
 pub(crate) const PACKET_TYPE_USES_COUNTER_RANGE: std::ops::Range<u8> = 3..9;
 
-pub(crate) const HANDSHAKE_HELLO_MIN_SIZE: usize = KID_SIZE + P384_PUBLIC_KEY_SIZE + KYBER_PUBLIC_KEY_SIZE + AES_GCM_TAG_SIZE + AES_GCM_TAG_SIZE;
+pub(crate) const HANDSHAKE_HELLO_MIN_SIZE: usize =
+    KID_SIZE + P384_PUBLIC_KEY_SIZE + KYBER_PUBLIC_KEY_SIZE + AES_GCM_TAG_SIZE + AES_GCM_TAG_SIZE;
 pub(crate) const HANDSHAKE_HELLO_MAX_SIZE: usize = HANDSHAKE_HELLO_MIN_SIZE + RATCHET_SIZE;
 
-pub(crate) const HANDSHAKE_RESPONSE_SIZE: usize = P384_PUBLIC_KEY_SIZE + KYBER_CIPHERTEXT_SIZE + AES_GCM_TAG_SIZE + KID_SIZE + AES_GCM_TAG_SIZE;
+pub(crate) const HANDSHAKE_RESPONSE_SIZE: usize =
+    P384_PUBLIC_KEY_SIZE + KYBER_CIPHERTEXT_SIZE + AES_GCM_TAG_SIZE + KID_SIZE + AES_GCM_TAG_SIZE;
 
 pub(crate) const HANDSHAKE_COMPLETION_MIN_SIZE: usize = P384_PUBLIC_KEY_SIZE + AES_GCM_TAG_SIZE + 0 + AES_GCM_TAG_SIZE;
 pub(crate) const HANDSHAKE_COMPLETION_MAX_SIZE: usize = HANDSHAKE_COMPLETION_MIN_SIZE + IDENTITY_MAX_SIZE;
diff --git a/src/symmetric_state.rs b/src/symmetric_state.rs
index 702198a..00b77cc 100644
--- a/src/symmetric_state.rs
+++ b/src/symmetric_state.rs
@@ -84,7 +84,14 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         let mut next_ck = [0u8; HASHLEN];
         let mut temp_k = [0u8; HASHLEN];
 
-        self.kbkdf(input_key_material, LABEL_KBKDF_CHAIN, 2, &mut next_ck, Some(&mut temp_k), None);
+        self.kbkdf(
+            input_key_material,
+            LABEL_KBKDF_CHAIN,
+            2,
+            &mut next_ck,
+            Some(&mut temp_k),
+            None,
+        );
 
         *self.ck = next_ck;
         self.k.clone_from_slice(&temp_k[..AES_256_KEY_SIZE]);
@@ -116,14 +123,24 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         self.k.clone_from_slice(&temp_k[..AES_256_KEY_SIZE]);
     }
     /// Corresponds to Noise `EncryptAndHash`.
-    pub fn encrypt_and_hash_in_place(&mut self, iv: [u8; AES_GCM_IV_SIZE], plaintext_start: usize, buffer: &mut Vec<u8>) {
+    pub fn encrypt_and_hash_in_place(
+        &mut self,
+        iv: [u8; AES_GCM_IV_SIZE],
+        plaintext_start: usize,
+        buffer: &mut Vec<u8>,
+    ) {
         let tag = App::Aead::encrypt_in_place(&self.k, iv, Some(&self.h), &mut buffer[plaintext_start..]);
         buffer.extend(&tag);
         self.mix_hash(&buffer[plaintext_start..]);
     }
     /// Corresponds to Noise `DecryptAndHash`.
     #[must_use]
-    pub fn decrypt_and_hash_in_place(&mut self, iv: [u8; AES_GCM_IV_SIZE], buffer: &mut [u8], tag: [u8; AES_GCM_TAG_SIZE]) -> bool {
+    pub fn decrypt_and_hash_in_place(
+        &mut self,
+        iv: [u8; AES_GCM_IV_SIZE],
+        buffer: &mut [u8],
+        tag: [u8; AES_GCM_TAG_SIZE],
+    ) -> bool {
         let mut hash = App::Hash::new();
         hash.update(&self.h);
         hash.update(buffer);
diff --git a/src/zeta.rs b/src/zeta.rs
index 7113133..e51f2f1 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -276,7 +276,15 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
     let mut session_map = ctx.session_map.lock().unwrap();
     let kid_recv = gen_kid(session_map.deref(), ctx.rng.lock().unwrap().deref_mut());
 
-    let a1 = create_a1_state(&ctx.rng, &s_remote, kid_recv, &ratchet_state1, ratchet_state2.as_ref(), identity).ok_or(OpenError::InvalidPublicKey)?;
+    let a1 = create_a1_state(
+        &ctx.rng,
+        &s_remote,
+        kid_recv,
+        &ratchet_state1,
+        ratchet_state2.as_ref(),
+        identity,
+    )
+    .ok_or(OpenError::InvalidPublicKey)?;
     let packet = a1.packet.clone();
 
     let (hk_recv, hk_send) = a1.noise.get_ask(LABEL_HEADER_KEY);
@@ -304,14 +312,21 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
 
     let session = Arc::new(Session(Mutex::new(zeta)));
     session_map.insert(kid_recv, Arc::downgrade(&session));
-    ctx.sessions.lock().unwrap().insert(Arc::as_ptr(&session), Arc::downgrade(&session));
+    ctx.sessions
+        .lock()
+        .unwrap()
+        .insert(Arc::as_ptr(&session), Arc::downgrade(&session));
 
     send(&packet);
 
     Ok(session)
 }
 /// Corresponds to Algorithm 13 found in Section 5.
-pub(crate) fn respond_to_challenge<App: ApplicationLayer>(zeta: &mut Zeta<App>, rng: &Mutex<App::Rng>, challenge: &[u8; CHALLENGE_SIZE]) {
+pub(crate) fn respond_to_challenge<App: ApplicationLayer>(
+    zeta: &mut Zeta<App>,
+    rng: &Mutex<App::Rng>,
+    challenge: &[u8; CHALLENGE_SIZE],
+) {
     if let ZetaAutomata::A1(StateA1 { packet: Packet(_, _, x1), .. }) = &mut zeta.beta {
         let response_start = x1.len() - CHALLENGE_SIZE;
         respond_to_challenge_in_place::<App::Rng, App::Hash>(
@@ -345,13 +360,16 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     // Noise process prologue.
     let j = i + KID_SIZE;
     noise.mix_hash(&x1[i..j]);
-    let kid_send = NonZeroU32::new(u32::from_be_bytes(x1[i..j].try_into().unwrap())).ok_or(byzantine_fault!(InvalidPacket, true))?;
+    let kid_send = NonZeroU32::new(u32::from_be_bytes(x1[i..j].try_into().unwrap()))
+        .ok_or(byzantine_fault!(InvalidPacket, true))?;
     noise.mix_hash(&ctx.s_secret.public_key_bytes());
     i = j;
     // Process message pattern 1 e token.
     let e_remote = noise.read_e(&mut i, &x1).ok_or(byzantine_fault!(FailedAuth, true))?;
     // Process message pattern 1 es token.
-    noise.mix_dh(&ctx.s_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+    noise
+        .mix_dh(&ctx.s_secret, &e_remote)
+        .ok_or(byzantine_fault!(FailedAuth, true))?;
     // Process message pattern 1 e1 token.
     let j = i + KYBER_PUBLIC_KEY_SIZE;
     let k = j + AES_GCM_TAG_SIZE;
@@ -396,12 +414,17 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     // Process message pattern 2 e token.
     let e_secret = noise.write_e(&ctx.rng, &mut x2);
     // Process message pattern 2 ee token.
-    noise.mix_dh(&e_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+    noise
+        .mix_dh(&e_secret, &e_remote)
+        .ok_or(byzantine_fault!(FailedAuth, true))?;
     // Process message pattern 2 ekem1 token.
     let i = x2.len();
-    let (ekem1, ekem1_secret) = App::Kem::encapsulate(ctx.rng.lock().unwrap().deref_mut(), (&x1[e1_start..e1_end]).try_into().unwrap())
-        .map(|(ct, secret)| (ct, Zeroizing::new(secret)))
-        .ok_or(byzantine_fault!(FailedAuth, true))?;
+    let (ekem1, ekem1_secret) = App::Kem::encapsulate(
+        ctx.rng.lock().unwrap().deref_mut(),
+        (&x1[e1_start..e1_end]).try_into().unwrap(),
+    )
+    .map(|(ct, secret)| (ct, Zeroizing::new(secret)))
+    .ok_or(byzantine_fault!(FailedAuth, true))?;
     x2.extend(ekem1);
     noise.encrypt_and_hash_in_place(to_nonce(PACKET_TYPE_HANDSHAKE_RESPONSE, 0), i, &mut x2);
     noise.mix_key(ekem1_secret.as_ref());
@@ -436,7 +459,10 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
         },
     );
 
-    send(&Packet(kid_send.get(), to_nonce(PACKET_TYPE_HANDSHAKE_RESPONSE, c), x2), &hk_send);
+    send(
+        &Packet(kid_send.get(), to_nonce(PACKET_TYPE_HANDSHAKE_RESPONSE, c), x2),
+        &hk_send,
+    );
     Ok(())
 }
 /// Corresponds to Transition Algorithm 3 found in Section 4.3.
@@ -470,7 +496,9 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
             // Process message pattern 2 e token.
             let e_remote = noise.read_e(&mut i, &x2).ok_or(byzantine_fault!(FailedAuth, true))?;
             // Process message pattern 2 ee token.
-            noise.mix_dh(e_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+            noise
+                .mix_dh(e_secret, &e_remote)
+                .ok_or(byzantine_fault!(FailedAuth, true))?;
             // Process message pattern 2 ekem1 token.
             let j = i + KYBER_CIPHERTEXT_SIZE;
             let k = j + AES_GCM_TAG_SIZE;
@@ -536,7 +564,9 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
             x3.extend(&ctx.s_secret.public_key_bytes());
             noise.encrypt_and_hash_in_place(to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 1), i, &mut x3);
             // Process message pattern 3 se token.
-            noise.mix_dh(&ctx.s_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+            noise
+                .mix_dh(&ctx.s_secret, &e_remote)
+                .ok_or(byzantine_fault!(FailedAuth, true))?;
             // Process message pattern 3 payload.
             let i = x3.len();
             x3.extend(identity);
@@ -623,10 +653,13 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
     if !noise.decrypt_and_hash_in_place(to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 1), &mut x3[i..j], tag) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
-    let s_remote = App::PublicKey::from_bytes((&x3[i..j]).try_into().unwrap()).ok_or(byzantine_fault!(FailedAuth, true))?;
+    let s_remote =
+        App::PublicKey::from_bytes((&x3[i..j]).try_into().unwrap()).ok_or(byzantine_fault!(FailedAuth, true))?;
     i = k;
     // Process message pattern 3 se token.
-    noise.mix_dh(&zeta.e_secret, &s_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+    noise
+        .mix_dh(&zeta.e_secret, &s_remote)
+        .ok_or(byzantine_fault!(FailedAuth, true))?;
     // Process message pattern 3 payload.
     let k = x3.len();
     let j = k - AES_GCM_TAG_SIZE;
@@ -726,7 +759,10 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                     defrag: zeta.defrag,
                 })));
                 entry.insert(Arc::downgrade(&session));
-                ctx.sessions.lock().unwrap().insert(Arc::as_ptr(&session), Arc::downgrade(&session));
+                ctx.sessions
+                    .lock()
+                    .unwrap()
+                    .insert(Arc::as_ptr(&session), Arc::downgrade(&session));
 
                 send(&Packet(zeta.kid_send.get(), n, c1), Some(&zeta.hk_send));
                 Ok(session)
@@ -765,7 +801,12 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
         return Err(byzantine_fault!(OutOfSequence, false));
     };
 
-    let specified_key = zeta.key_ref(is_other).recv.kek.as_ref().ok_or(byzantine_fault!(OutOfSequence, true))?;
+    let specified_key = zeta
+        .key_ref(is_other)
+        .recv
+        .kek
+        .as_ref()
+        .ok_or(byzantine_fault!(OutOfSequence, true))?;
     let tag = c1[..].try_into().unwrap();
     if !App::Aead::decrypt_in_place(specified_key, n, None, &mut [], tag) {
         return Err(byzantine_fault!(FailedAuth, true));
@@ -800,7 +841,8 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
             zeta.timeout_timer = app.time()
                 + App::SETTINGS
                     .rekey_after_time
-                    .saturating_sub(rng.lock().unwrap().next_u64() % App::SETTINGS.rekey_time_max_jitter) as i64;
+                    .saturating_sub(rng.lock().unwrap().next_u64() % App::SETTINGS.rekey_time_max_jitter)
+                    as i64;
             zeta.resend_timer = i64::MAX;
             zeta.beta = ZetaAutomata::S2;
         }
@@ -810,11 +852,19 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
     let c = zeta.send_counter;
     zeta.send_counter += 1;
     let n = to_nonce(PACKET_TYPE_ACK, c);
-    let latest_confirmed_key = zeta.key_ref(false).send.kek.as_ref().ok_or(byzantine_fault!(OutOfSequence, true))?;
+    let latest_confirmed_key = zeta
+        .key_ref(false)
+        .send
+        .kek
+        .as_ref()
+        .ok_or(byzantine_fault!(OutOfSequence, true))?;
     let tag = App::Aead::encrypt_in_place(latest_confirmed_key, n, None, &mut []);
     c2.extend(&tag);
 
-    send(&Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, c2), Some(&zeta.hk_send));
+    send(
+        &Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, c2),
+        Some(&zeta.hk_send),
+    );
     Ok(just_establised)
 }
 /// Corresponds to the trivial Transition Algorithm described for processing C_2 packets found in
@@ -929,7 +979,12 @@ pub(crate) fn service<App: ApplicationLayer>(
         let c = zeta.send_counter;
         zeta.send_counter += 1;
         let n = to_nonce(p, c);
-        let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.kek.as_ref().unwrap(), n, None, &mut control_payload);
+        let tag = App::Aead::encrypt_in_place(
+            zeta.key_ref(false).send.kek.as_ref().unwrap(),
+            n,
+            None,
+            &mut control_payload,
+        );
         control_payload.extend(&tag);
         send(
             &Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, control_payload),
@@ -937,7 +992,12 @@ pub(crate) fn service<App: ApplicationLayer>(
         );
     }
 }
-fn remap<App: ApplicationLayer>(session: &Arc<Session<App>>, zeta: &Zeta<App>, rng: &Mutex<App::Rng>, session_map: &SessionMap<App>) -> NonZeroU32 {
+fn remap<App: ApplicationLayer>(
+    session: &Arc<Session<App>>,
+    zeta: &Zeta<App>,
+    rng: &Mutex<App::Rng>,
+    session_map: &SessionMap<App>,
+) -> NonZeroU32 {
     let mut session_map = session_map.lock().unwrap();
     let weak = if let Some(Some(weak)) = zeta.key_ref(true).recv.kid.as_ref().map(|kid| session_map.remove(kid)) {
         weak
@@ -1034,7 +1094,10 @@ fn timeout_trans<App: ApplicationLayer>(
             let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.kek.as_ref().unwrap(), n, None, &mut k1);
             k1.extend(&tag);
 
-            send(&Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, k1), Some(&zeta.hk_send));
+            send(
+                &Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, k1),
+                Some(&zeta.hk_send),
+            );
         }
         ZetaAutomata::S1 { .. } => {
             log!(app, TimeoutKeyConfirm(session));
@@ -1088,7 +1151,13 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
 
     let i = k1.len() - AES_GCM_TAG_SIZE;
     let tag = k1[i..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(zeta.key_ref(false).recv.kek.as_ref().unwrap(), n, None, &mut k1[..i], tag) {
+    if !App::Aead::decrypt_in_place(
+        zeta.key_ref(false).recv.kek.as_ref().unwrap(),
+        n,
+        None,
+        &mut k1[..i],
+        tag,
+    ) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let (_, c) = from_nonce(&n);
@@ -1108,9 +1177,13 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
         // Process message pattern 1 e token.
         let e_remote = noise.read_e(&mut i, &k1).ok_or(byzantine_fault!(FailedAuth, true))?;
         // Process message pattern 1 es token.
-        noise.mix_dh(s_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+        noise
+            .mix_dh(s_secret, &e_remote)
+            .ok_or(byzantine_fault!(FailedAuth, true))?;
         // Process message pattern 1 ss token.
-        noise.mix_dh(s_secret, &zeta.s_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+        noise
+            .mix_dh(s_secret, &zeta.s_remote)
+            .ok_or(byzantine_fault!(FailedAuth, true))?;
         // Process message pattern 1 payload.
         let j = i + KID_SIZE;
         let k = j + AES_GCM_TAG_SIZE;
@@ -1118,15 +1191,20 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
         if !noise.decrypt_and_hash_in_place(to_nonce(PACKET_TYPE_REKEY_INIT, 0), &mut k1[i..j], tag) {
             return Err(byzantine_fault!(FailedAuth, true));
         }
-        let kid_send = NonZeroU32::new(u32::from_be_bytes(k1[i..j].try_into().unwrap())).ok_or(byzantine_fault!(FailedAuth, true))?;
+        let kid_send = NonZeroU32::new(u32::from_be_bytes(k1[i..j].try_into().unwrap()))
+            .ok_or(byzantine_fault!(FailedAuth, true))?;
 
         let mut k2 = Vec::new();
         // Process message pattern 2 e token.
         let e_secret = noise.write_e(rng, &mut k2);
         // Process message pattern 2 ee token.
-        noise.mix_dh(&e_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+        noise
+            .mix_dh(&e_secret, &e_remote)
+            .ok_or(byzantine_fault!(FailedAuth, true))?;
         // Process message pattern 2 se token.
-        noise.mix_dh(&s_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+        noise
+            .mix_dh(&s_secret, &e_remote)
+            .ok_or(byzantine_fault!(FailedAuth, true))?;
         // Process message pattern 2 payload.
         let i = k2.len();
         let new_kid_recv = remap(session, &zeta, rng, session_map);
@@ -1172,7 +1250,10 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
         let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.kek.as_ref().unwrap(), n, None, &mut k2);
         k2.extend(&tag);
 
-        send(&Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, k2), Some(&zeta.hk_send));
+        send(
+            &Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, k2),
+            Some(&zeta.hk_send),
+        );
         Ok(())
     })();
     if matches!(result, Err(ReceiveError::ByzantineFault { .. })) {
@@ -1205,7 +1286,13 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
 
     let i = k2.len() - AES_GCM_TAG_SIZE;
     let tag = k2[i..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(zeta.key_ref(false).recv.kek.as_ref().unwrap(), n, None, &mut k2[..i], tag) {
+    if !App::Aead::decrypt_in_place(
+        zeta.key_ref(false).recv.kek.as_ref().unwrap(),
+        n,
+        None,
+        &mut k2[..i],
+        tag,
+    ) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let (_, c) = from_nonce(&n);
@@ -1220,9 +1307,13 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
             // Process message pattern 2 e token.
             let e_remote = noise.read_e(&mut i, &k2).ok_or(byzantine_fault!(FailedAuth, true))?;
             // Process message pattern 2 ee token.
-            noise.mix_dh(e_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+            noise
+                .mix_dh(e_secret, &e_remote)
+                .ok_or(byzantine_fault!(FailedAuth, true))?;
             // Process message pattern 2 se token.
-            noise.mix_dh(e_secret, &zeta.s_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+            noise
+                .mix_dh(e_secret, &zeta.s_remote)
+                .ok_or(byzantine_fault!(FailedAuth, true))?;
             // Process message pattern 2 payload.
             let j = i + KID_SIZE;
             let k = j + AES_GCM_TAG_SIZE;
@@ -1230,7 +1321,8 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
             if !noise.decrypt_and_hash_in_place(to_nonce(PACKET_TYPE_REKEY_COMPLETE, 0), &mut k2[i..j], tag) {
                 return Err(byzantine_fault!(FailedAuth, true));
             }
-            let kid_send = NonZeroU32::new(u32::from_be_bytes(k2[i..j].try_into().unwrap())).ok_or(byzantine_fault!(InvalidPacket, true))?;
+            let kid_send = NonZeroU32::new(u32::from_be_bytes(k2[i..j].try_into().unwrap()))
+                .ok_or(byzantine_fault!(InvalidPacket, true))?;
 
             let (rk, rf) = noise.get_ask(LABEL_RATCHET_STATE);
             let new_ratchet_state = RatchetState::new(rk, rf, zeta.ratchet_state1.chain_len + 1);
@@ -1271,7 +1363,10 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
             let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.kek.as_ref().unwrap(), n, None, &mut []);
             c1.extend(&tag);
 
-            send(&Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, c1), Some(&zeta.hk_send));
+            send(
+                &Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, c1),
+                Some(&zeta.hk_send),
+            );
             Ok(())
         } else {
             unreachable!()
@@ -1314,7 +1409,10 @@ pub(crate) fn send_payload<App: ApplicationLayer>(
     let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.nk.as_ref().unwrap(), n, None, &mut payload);
     payload.extend(&tag);
 
-    send(&Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, payload), Some(&zeta.hk_send));
+    send(
+        &Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, payload),
+        Some(&zeta.hk_send),
+    );
     Ok(())
 }
 /// Corresponds to Algorithm 10 found in Section 4.3.
@@ -1340,7 +1438,12 @@ pub(crate) fn received_payload_in_place<App: ApplicationLayer>(
     };
 
     let i = payload.len() - AES_GCM_TAG_SIZE;
-    let specified_key = zeta.key_ref(is_other).recv.nk.as_ref().ok_or(byzantine_fault!(OutOfSequence, true))?;
+    let specified_key = zeta
+        .key_ref(is_other)
+        .recv
+        .nk
+        .as_ref()
+        .ok_or(byzantine_fault!(OutOfSequence, true))?;
     let tag = payload[i..].try_into().unwrap();
     if !App::Aead::decrypt_in_place(specified_key, n, None, &mut payload[..i], tag) {
         return Err(byzantine_fault!(FailedAuth, true));

From 0416cb9a0dd5311d16103fe9c76a784365630975 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Mon, 7 Aug 2023 15:33:27 -0400
Subject: [PATCH 24/37] updated docs

---
 src/applicationlayer.rs | 58 +++++++++++++++++++++++++----------------
 1 file changed, 36 insertions(+), 22 deletions(-)

diff --git a/src/applicationlayer.rs b/src/applicationlayer.rs
index 53090d5..31c4e12 100644
--- a/src/applicationlayer.rs
+++ b/src/applicationlayer.rs
@@ -173,22 +173,17 @@ pub trait ApplicationLayer: Sized {
     /// Function to accept sessions after final negotiation.
     /// The second argument is the identity that the remote peer sent us. The application
     /// must verify this identity is associated with the remote peer's static key.
-    /// To prevent desync, if this function returns (Some(_), _), no other open session with the
-    /// same remote peer must exist. Drop or call expire on any pre-existing sessions before returning.
+    /// To prevent desync, if this function specifies that we should connect, no other open session
+    /// with the same remote peer must exist. Drop or call expire on any pre-existing sessions
+    /// before returning.
     fn check_accept_session(&self, remote_static_key: &Self::PublicKey, identity: &[u8]) -> AcceptAction<Self>;
 
     /// Lookup a specific ratchet state based on its ratchet fingerprint.
     /// This function will be called whenever Alice attempts to connect to us with a non-empty
     /// ratchet fingerprint.
     ///
-    /// If the ratchet key was found, the function should return `RestoreAction::RestoreRatchet`. This will
-    /// cause us to connect to Alice using the returned ratchet number and ratchet key.
-    ///
-    /// If the ratchet key could not be found, the application may choose between returning
-    /// `RatchetAction::DowngradeRatchet` or `RatchetAction::FailAuthentication`.
-    /// If `RatchetAction::DowngradeRatchet` is returned we will attempt to convince Alice to downgrade
-    /// to the empty ratchet key, restarting the ratchet chain.
-    /// If `RatchetAction::FailAuthentication` is returned Alice's connection will be silently dropped.
+    /// If a ratchet state with a matching fingerprint could not be found, this function should
+    /// return `Ok(None)`.
     fn restore_by_fingerprint(
         &self,
         ratchet_fingerprint: &[u8; RATCHET_SIZE],
@@ -212,16 +207,9 @@ pub trait ApplicationLayer: Sized {
         remote_static_key: &Self::PublicKey,
         session_data: &Self::SessionData,
     ) -> Result<(RatchetState, Option<RatchetState>), Self::StorageError>;
-    /// Atomically save `current_state1` and `current_state2` so that them and only them can be
-    /// restored with `restore_by_identity` and `restore_by_fingerprint` through a system restart.
-    /// Theses should overwrite the previous ratchet states 1 and 2 saved to storage.
-    ///
-    /// `state_added` will be equal to the brand new ratchet state that was added in this update,
-    /// or `None` if there is not a new ratchet state this update. `state_deleted1` and
-    /// `state_deleted2` will be equal to any ratchet states that are to be deleted and overwritten
-    /// as a result of this update, or `None` if there is not one to be deleted.
-    /// `state_added` will always have a non-empty (`Some()`) ratchet fingerprint, and it will
-    /// always be equal to `current_state1`.
+    /// Atomically commit the update specified by `update_data` to storage, or return an error if
+    /// the update could not be made.
+    /// The implementor is free to choose how to apply these updates to storage.
     ///
     /// If this returns `Err(IoError)`, the packet which triggered this function to be called will be
     /// dropped, and no session state will be mutated, preserving synchronization. The remote peer
@@ -233,8 +221,7 @@ pub trait ApplicationLayer: Sized {
     /// fix is to reset both ratchet keys to empty.
     ///
     /// This function may also save state to volatile storage, in which case all peers which connect
-    /// to us will have to allow downgrade, i.e. `initiator_disallows_downgrade` returns false
-    /// and/or `check_accept_session` returns `(Some(true, _), _)`.
+    /// to us will have to allow downgrade across the board.
     /// Otherwise, when we restart, we will not be allowed to reconnect.
     fn save_ratchet_state(
         &self,
@@ -250,16 +237,43 @@ pub trait ApplicationLayer: Sized {
     fn event_log(&self, event: LogEvent<'_, Self>);
 }
 
+/// A set of references to ratchet states specifying how a remote peer's persistent
+/// storage should be updated.
+///
+/// There should be only up to two ratchet states saved to storage at a time per peer.
+/// Every time a new ratchet state is generated, a previous ratchet state will be deleted.
+///
+/// These are sensitive values should they ought to be securely stored.
 pub struct RatchetUpdate<'a> {
+    /// The ratchet key and fingerprint to store in the first slot.
     pub state1: &'a RatchetState,
+    /// The ratchet key and fingerprint to store in the second slot.
     pub state2: Option<&'a RatchetState>,
+    /// Whether `state1` is a brand new ratchet state, or if it was previously saved.
     pub state1_was_just_added: bool,
+    /// A previous ratchet key and fingerprint that now must be deleted from storage.
+    /// This will have been a previously given value of `state1` or `state2`.
     pub state_deleted1: Option<&'a RatchetState>,
+    /// A previous ratchet key and fingerprint that now must be deleted from storage.
+    /// It is extremely rare that this field is occupied.
     pub state_deleted2: Option<&'a RatchetState>,
 }
 
+/// A collection of fields specifying how to complete the key exchange with a specific remote peer,
+/// used by Bob, the responder, at the very last stage of the key exchange.
+///
+/// Corresponds to the *Accept* callback of Transition Algorithm 4.
 pub struct AcceptAction<App: ApplicationLayer> {
+    /// The data object to be attached to the session if we successfully connect.
+    /// If this field is None then we will not connect to this remote peer.
     pub session_data: Option<App::SessionData>,
+    /// Whether or not we will accept a connection with the remote peer when they do not have a
+    /// ratchet key that we think they should have.
     pub responder_disallows_downgrade: bool,
+    /// Whether or not to send an explicit rejection packet to the remote peer if we do not create
+    /// a session with them.
+    ///
+    /// This field will not be used if `session_data` is `Some` and the remote peer passes all other
+    /// authentication checks.
     pub responder_silently_rejects: bool,
 }

From d20d71ecb029b56be990748d9c856d764c956646 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 8 Aug 2023 09:31:55 -0400
Subject: [PATCH 25/37] reorganized

---
 examples/basic_test.rs                      |  28 ++--
 src/{applicationlayer.rs => application.rs} |  26 +--
 src/context.rs                              |   2 +-
 src/fragmentation.rs                        |   2 +-
 src/lib.rs                                  |   8 +-
 src/log_event.rs                            |   2 +-
 src/proto.rs                                |   4 +-
 src/ratchet_state.rs                        | 118 +++++++++++--
 src/result.rs                               |  13 +-
 src/symmetric_state.rs                      |   2 +-
 src/zeta.rs                                 | 175 ++++++++++----------
 11 files changed, 223 insertions(+), 157 deletions(-)
 rename src/{applicationlayer.rs => application.rs} (91%)

diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index 8770adb..4301add 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -21,8 +21,8 @@ use rand_core::OsRng;
 use rand_core::RngCore;
 use sha2::Sha512;
 
-use zssp_proto::applicationlayer::{
-    AcceptAction, ApplicationLayer, RatchetState, RatchetUpdate, Settings, RATCHET_SIZE,
+use zssp_proto::application::{
+    AcceptAction, ApplicationLayer, RatchetState, RatchetStates, RatchetUpdate, Settings, RATCHET_SIZE,
 };
 use zssp_proto::crypto_impl::PqcKyberSecretKey;
 use zssp_proto::Session;
@@ -37,7 +37,7 @@ struct TestApplication {
 
 struct Ratchets {
     rf_map: HashMap<[u8; RATCHET_SIZE], RatchetState>,
-    peer_map: HashMap<u128, (RatchetState, Option<RatchetState>)>,
+    peer_map: HashMap<u128, RatchetStates>,
 }
 impl Ratchets {
     fn new() -> Self {
@@ -95,13 +95,9 @@ impl ApplicationLayer for &TestApplication {
         &self,
         remote_static_key: &Self::PublicKey,
         session_data: &Self::SessionData,
-    ) -> Result<(RatchetState, Option<RatchetState>), Self::StorageError> {
+    ) -> Result<Option<RatchetStates>, Self::StorageError> {
         let ratchets = self.ratchets.lock().unwrap();
-        Ok(ratchets
-            .peer_map
-            .get(session_data)
-            .cloned()
-            .unwrap_or_else(|| RatchetState::new_initial_states()))
+        Ok(ratchets.peer_map.get(session_data).cloned())
     }
 
     fn save_ratchet_state(
@@ -111,20 +107,16 @@ impl ApplicationLayer for &TestApplication {
         update_data: RatchetUpdate<'_>,
     ) -> Result<(), Self::StorageError> {
         let mut ratchets = self.ratchets.lock().unwrap();
-        ratchets
-            .peer_map
-            .insert(*session_data, (update_data.state1.clone(), update_data.state2.cloned()));
+        ratchets.peer_map.insert(*session_data, update_data.to_states());
 
-        if update_data.state1_was_just_added {
-            ratchets
-                .rf_map
-                .insert(*update_data.state1.fingerprint().unwrap(), update_data.state1.clone());
+        if let Some(rf) = update_data.added_fingerprint() {
+            ratchets.rf_map.insert(*rf, update_data.state1.clone());
             println!("[{}] new ratchet #{}", self.name, update_data.state1.chain_len);
         }
-        if let Some(Some(rf)) = update_data.state_deleted1.map(|rs| rs.fingerprint()) {
+        if let Some(rf) = update_data.deleted_fingerprint1() {
             ratchets.rf_map.remove(rf);
         }
-        if let Some(Some(rf)) = update_data.state_deleted2.map(|rs| rs.fingerprint()) {
+        if let Some(rf) = update_data.deleted_fingerprint2() {
             ratchets.rf_map.remove(rf);
         }
         Ok(())
diff --git a/src/applicationlayer.rs b/src/application.rs
similarity index 91%
rename from src/applicationlayer.rs
rename to src/application.rs
index 31c4e12..776c7ac 100644
--- a/src/applicationlayer.rs
+++ b/src/application.rs
@@ -7,7 +7,7 @@ use crate::LogEvent;
 use crate::Session;
 
 pub use crate::proto::RATCHET_SIZE;
-pub use crate::ratchet_state::RatchetState;
+pub use crate::ratchet_state::*;
 
 /// A container for a vast majority of the dynamic settings within ZSSP, including all time-based settings.
 /// If the user wishes to measure time in units other than milliseconds for some reason, then they can
@@ -206,7 +206,7 @@ pub trait ApplicationLayer: Sized {
         &self,
         remote_static_key: &Self::PublicKey,
         session_data: &Self::SessionData,
-    ) -> Result<(RatchetState, Option<RatchetState>), Self::StorageError>;
+    ) -> Result<Option<RatchetStates>, Self::StorageError>;
     /// Atomically commit the update specified by `update_data` to storage, or return an error if
     /// the update could not be made.
     /// The implementor is free to choose how to apply these updates to storage.
@@ -237,28 +237,6 @@ pub trait ApplicationLayer: Sized {
     fn event_log(&self, event: LogEvent<'_, Self>);
 }
 
-/// A set of references to ratchet states specifying how a remote peer's persistent
-/// storage should be updated.
-///
-/// There should be only up to two ratchet states saved to storage at a time per peer.
-/// Every time a new ratchet state is generated, a previous ratchet state will be deleted.
-///
-/// These are sensitive values should they ought to be securely stored.
-pub struct RatchetUpdate<'a> {
-    /// The ratchet key and fingerprint to store in the first slot.
-    pub state1: &'a RatchetState,
-    /// The ratchet key and fingerprint to store in the second slot.
-    pub state2: Option<&'a RatchetState>,
-    /// Whether `state1` is a brand new ratchet state, or if it was previously saved.
-    pub state1_was_just_added: bool,
-    /// A previous ratchet key and fingerprint that now must be deleted from storage.
-    /// This will have been a previously given value of `state1` or `state2`.
-    pub state_deleted1: Option<&'a RatchetState>,
-    /// A previous ratchet key and fingerprint that now must be deleted from storage.
-    /// It is extremely rare that this field is occupied.
-    pub state_deleted2: Option<&'a RatchetState>,
-}
-
 /// A collection of fields specifying how to complete the key exchange with a specific remote peer,
 /// used by Bob, the responder, at the very last stage of the key exchange.
 ///
diff --git a/src/context.rs b/src/context.rs
index ca4b4a9..3e5e088 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -5,7 +5,7 @@ use std::hash::Hash;
 use std::num::NonZeroU32;
 use std::sync::{Arc, Mutex, Weak};
 
-use crate::applicationlayer::ApplicationLayer;
+use crate::application::ApplicationLayer;
 use crate::crypto::{AES_256_KEY_SIZE, AES_GCM_IV_SIZE};
 use crate::fragmentation::{send_with_fragmentation, DefragBuffer};
 use crate::proto::*;
diff --git a/src/fragmentation.rs b/src/fragmentation.rs
index 902f836..6af8f45 100644
--- a/src/fragmentation.rs
+++ b/src/fragmentation.rs
@@ -4,7 +4,7 @@ use std::sync::Mutex;
 
 use zeroize::Zeroizing;
 
-use crate::applicationlayer::ApplicationLayer;
+use crate::application::ApplicationLayer;
 use crate::crypto::{PrpAes256, AES_256_KEY_SIZE};
 use crate::proto::*;
 use crate::result::{byzantine_fault, ReceiveError};
diff --git a/src/lib.rs b/src/lib.rs
index 4a67dec..f871edf 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -5,7 +5,7 @@
 * (c) ZeroTier, Inc.
 * https://www.zerotier.com/
 */
-//#![warn(missing_docs, rust_2018_idioms)]
+#![warn(missing_docs, rust_2018_idioms)]
 //! TODO: docs
 mod challenge;
 mod context;
@@ -17,7 +17,10 @@ mod ratchet_state;
 mod symmetric_state;
 mod zeta;
 
-pub mod applicationlayer;
+/// An abstraction over OS and use-case specific resources and queries.
+/// This allows this library to be platform independent, but a user of this library must implement
+/// the `ApplicationLayer` trait.
+pub mod application;
 /// A collection of implementation-independent traits for the various specific cryptographic
 /// algorithms ZSSP depends on.
 ///
@@ -37,6 +40,7 @@ pub mod crypto;
 ///
 /// This module contains the trait implementations as well as re-exports of those crates.
 pub mod crypto_impl;
+/// The collection of major return types of this library.
 pub mod result;
 
 pub use context::Context;
diff --git a/src/log_event.rs b/src/log_event.rs
index b7b9428..69b4826 100644
--- a/src/log_event.rs
+++ b/src/log_event.rs
@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use crate::applicationlayer::ApplicationLayer;
+use crate::application::ApplicationLayer;
 use crate::Session;
 
 /// ZSSP events that might be interesting to log or aggregate into metrics.
diff --git a/src/proto.rs b/src/proto.rs
index 68594bb..cd0b520 100644
--- a/src/proto.rs
+++ b/src/proto.rs
@@ -85,8 +85,8 @@ pub(crate) const LABEL_RATCHET_STATE: &[u8; 4] = b"ASKR";
 pub(crate) const LABEL_HEADER_KEY: &[u8; 4] = b"ASKH";
 pub(crate) const LABEL_KEX_KEY: &[u8; 4] = b"ASKK";
 
-pub(crate) const INIT_COUNTER: u64 = 0;
-pub(crate) const EXPIRE_AFTER_USES: u64 = 1 << 32 - 1;
+//pub(crate) const EXPIRE_AFTER_USES: u64 = (1 << 32) - 1;
+pub(crate) const HARD_EXPIRATION: u64 = u64::MAX;
 /// Determines the number of counters a session will remember. If a counter arrives over
 /// this amount out of order relative to other received counters, it is likely to be
 /// rejected on the basis that the session can't remember if this counter was replayed.
diff --git a/src/ratchet_state.rs b/src/ratchet_state.rs
index ec5babe..c4ede59 100644
--- a/src/ratchet_state.rs
+++ b/src/ratchet_state.rs
@@ -5,6 +5,10 @@ use crate::proto::*;
 /// A ratchet key and fingerprint,
 /// along with the length of the ratchet chain the keys were derived from.
 ///
+/// Implements constant time equality.
+/// The hash implementation only uses the ratchet fingerprint.
+/// Any operation involving the ratchet key must take constant time.
+///
 /// Corresponds to the Ratchet Key and Ratchet Fingerprint described in Section 3.
 #[derive(Clone, Eq)]
 pub struct RatchetState {
@@ -14,13 +18,19 @@ pub struct RatchetState {
 }
 impl PartialEq for RatchetState {
     fn eq(&self, other: &Self) -> bool {
-        secure_eq(&self.key, &other.key)
-            & (self.chain_len == other.chain_len)
-            & match (self.fingerprint.as_ref(), other.fingerprint.as_ref()) {
-                (Some(rf1), Some(rf2)) => secure_eq(rf1, rf2),
-                (None, None) => true,
-                _ => false,
-            }
+        let ret = match (self.fingerprint.as_ref(), other.fingerprint.as_ref()) {
+            (Some(rf1), Some(rf2)) => secure_eq(rf1, rf2),
+            (None, None) => true,
+            _ => false,
+        };
+        ret & secure_eq(&self.key, &other.key) & (self.chain_len == other.chain_len)
+    }
+}
+impl std::hash::Hash for RatchetState {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        if let Some(rf) = &self.fingerprint {
+            state.write_u64(u64::from_ne_bytes(rf[..8].try_into().unwrap()))
+        }
     }
 }
 impl RatchetState {
@@ -46,7 +56,7 @@ impl RatchetState {
         buffer.push(1);
         buffer.extend(LABEL_OTP_TO_RATCHET);
         buffer.push(0x00);
-        buffer.extend((2u16 * 512u16).to_be_bytes());
+        buffer.extend((1024u16).to_be_bytes());
         let r1 = Hmac::hmac(otp, &buffer);
         buffer[0] = 2;
         let r2 = Hmac::hmac(otp, &buffer);
@@ -56,14 +66,6 @@ impl RatchetState {
             1,
         )
     }
-
-    pub fn new_initial_states() -> (RatchetState, Option<RatchetState>) {
-        (RatchetState::empty(), None)
-    }
-    pub fn new_otp_states<Hmac: HashSha512>(otp: &[u8]) -> (RatchetState, Option<RatchetState>) {
-        (RatchetState::new_from_otp::<Hmac>(otp), None)
-    }
-
     pub fn is_empty(&self) -> bool {
         self.fingerprint.is_none()
     }
@@ -74,3 +76,87 @@ impl RatchetState {
         self.fingerprint.as_deref()
     }
 }
+impl Default for RatchetState {
+    fn default() -> Self {
+        Self::empty()
+    }
+}
+
+/// A pair of ratchet states.
+/// It is expected that an instance of this object will be saved to a storage device per-peer,
+/// and be restore-able via the `ApplicationLayer` trait.
+///
+/// This corresponds to the possible values of abstract variables `rf` and `rk` found in Section 4.3.
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct RatchetStates {
+    pub state1: RatchetState,
+    pub state2: Option<RatchetState>,
+}
+impl RatchetStates {
+    pub fn new(state1: RatchetState, state2: Option<RatchetState>) -> Self {
+        Self { state1, state2 }
+    }
+    pub fn new_initial_states() -> Self {
+        Self { state1: RatchetState::empty(), state2: None }
+    }
+    pub fn new_otp_states<Hmac: HashSha512>(otp: &[u8]) -> Self {
+        Self {
+            state1: RatchetState::new_from_otp::<Hmac>(otp),
+            state2: None,
+        }
+    }
+}
+impl Default for RatchetStates {
+    fn default() -> Self {
+        Self::new_initial_states()
+    }
+}
+
+/// A set of references to ratchet states specifying how a remote peer's persistent
+/// storage should be updated.
+///
+/// There should be only up to two ratchet states saved to storage at a time per peer.
+/// Every time a new ratchet state is generated, a previous ratchet state will be deleted.
+///
+/// These are sensitive values should they ought to be securely stored.
+#[derive(Clone)]
+pub struct RatchetUpdate<'a> {
+    /// The ratchet key and fingerprint to store in the first slot.
+    pub state1: &'a RatchetState,
+    /// The ratchet key and fingerprint to store in the second slot.
+    pub state2: Option<&'a RatchetState>,
+    /// Whether `state1` is a brand new ratchet state, or if it was previously saved.
+    pub state1_was_just_added: bool,
+    /// A previous ratchet key and fingerprint that now must be deleted from storage.
+    /// This will have been a previously given value of `state1` or `state2`.
+    pub deleted_state1: Option<&'a RatchetState>,
+    /// A previous ratchet key and fingerprint that now must be deleted from storage.
+    /// It is extremely rare that this field is occupied.
+    pub deleted_state2: Option<&'a RatchetState>,
+}
+impl<'a> RatchetUpdate<'a> {
+    pub fn to_states(&self) -> RatchetStates {
+        RatchetStates::new(self.state1.clone(), self.state2.cloned())
+    }
+    pub fn added_fingerprint(&self) -> Option<&[u8; RATCHET_SIZE]> {
+        if self.state1_was_just_added {
+            self.state1.fingerprint()
+        } else {
+            None
+        }
+    }
+    pub fn deleted_fingerprint1(&self) -> Option<&[u8; RATCHET_SIZE]> {
+        if let Some(rs) = &self.deleted_state1 {
+            rs.fingerprint()
+        } else {
+            None
+        }
+    }
+    pub fn deleted_fingerprint2(&self) -> Option<&[u8; RATCHET_SIZE]> {
+        if let Some(rs) = &self.deleted_state2 {
+            rs.fingerprint()
+        } else {
+            None
+        }
+    }
+}
diff --git a/src/result.rs b/src/result.rs
index 963017f..ec194cb 100644
--- a/src/result.rs
+++ b/src/result.rs
@@ -1,18 +1,19 @@
 use std::sync::Arc;
 
-use crate::applicationlayer::ApplicationLayer;
+use crate::application::ApplicationLayer;
 use crate::Session;
 
 /// An error that can occur when attempting to open a session.
 /// Depending on the error type trying again may not work.
 #[derive(Debug, PartialEq, Eq, Clone, Hash)]
-pub enum OpenError<IoError> {
+pub enum OpenError<StorageError> {
     /// An invalid parameter was supplied to the function.
     InvalidPublicKey,
-
+    /// The given identity slice is too large to be fragmented. It must at most than 4096 bytes.
     IdentityTooLarge,
 
-    RatchetIoError(IoError),
+    /// Looking up the ratchet state of the specified peer failed.
+    StorageError(StorageError),
 }
 
 /// An error that can occur when attempting to send data over a session.
@@ -62,7 +63,7 @@ pub enum FaultType {
 
 /// An error that occurred during the receipt of a given packet.
 #[derive(Debug, PartialEq, Eq, Clone, Hash)]
-pub enum ReceiveError<IoError> {
+pub enum ReceiveError<StorageError> {
     /// A type of fault that can occur because a remote peer sent us a bad packet.
     /// Such packets will be ignored by ZSSP but a user of ZSSP might want to log
     /// them for debugging or tracing.
@@ -104,7 +105,7 @@ pub enum ReceiveError<IoError> {
 
     /// One of the ratchet saving or lookup functions returned an error, so the packet had to be
     /// dropped.
-    RatchetIoError(IoError),
+    StorageError(StorageError),
 }
 
 macro_rules! byzantine_fault {
diff --git a/src/symmetric_state.rs b/src/symmetric_state.rs
index 00b77cc..7c276d5 100644
--- a/src/symmetric_state.rs
+++ b/src/symmetric_state.rs
@@ -2,7 +2,7 @@ use std::marker::PhantomData;
 
 use zeroize::Zeroizing;
 
-use crate::applicationlayer::ApplicationLayer;
+use crate::application::ApplicationLayer;
 use crate::crypto::{AeadAesGcm, HashSha512, AES_256_KEY_SIZE, AES_GCM_IV_SIZE, AES_GCM_TAG_SIZE};
 use crate::proto::{HASHLEN, LABEL_KBKDF_CHAIN};
 
diff --git a/src/zeta.rs b/src/zeta.rs
index e51f2f1..c005334 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -5,14 +5,14 @@ use std::ops::{Deref, DerefMut};
 use std::sync::{Arc, Mutex, Weak};
 use zeroize::Zeroizing;
 
-use crate::applicationlayer::ApplicationLayer;
-use crate::applicationlayer::RatchetUpdate;
+use crate::application::ApplicationLayer;
+use crate::application::RatchetUpdate;
 use crate::challenge::{gen_null_response, respond_to_challenge_in_place};
 use crate::context::{log, ContextInner, SessionMap};
 use crate::crypto::*;
 use crate::fragmentation::DefragBuffer;
 use crate::proto::*;
-use crate::ratchet_state::RatchetState;
+use crate::ratchet_state::{RatchetState, RatchetStates};
 use crate::result::{byzantine_fault, FaultType, OpenError, ReceiveError, SendError};
 use crate::symmetric_state::SymmetricState;
 #[cfg(feature = "logging")]
@@ -210,6 +210,19 @@ impl<App: ApplicationLayer> Zeta<App> {
     pub(crate) fn next_timer(&self) -> i64 {
         self.timeout_timer.min(self.resend_timer)
     }
+    fn get_counter(&mut self) -> Option<(u64, bool)> {
+        let c = self.send_counter;
+        if c >= HARD_EXPIRATION {
+            return None;
+        }
+        self.send_counter += 1;
+        Some((
+            c,
+            c >= self
+                .key_creation_counter
+                .saturating_add(App::SETTINGS.rekey_after_key_uses),
+        ))
+    }
 }
 
 fn create_a1_state<App: ApplicationLayer>(
@@ -269,22 +282,16 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
     identity: Vec<u8>,
     send: impl FnOnce(&Packet),
 ) -> Result<Arc<Session<App>>, OpenError<App::StorageError>> {
-    let (ratchet_state1, ratchet_state2) = app
+    let ratchet_states = app
         .restore_by_identity(&s_remote, &session_data)
-        .map_err(|e| OpenError::RatchetIoError(e))?;
+        .map_err(|e| OpenError::StorageError(e))?;
+    let RatchetStates { state1, state2 } = ratchet_states.unwrap_or_default();
 
     let mut session_map = ctx.session_map.lock().unwrap();
     let kid_recv = gen_kid(session_map.deref(), ctx.rng.lock().unwrap().deref_mut());
 
-    let a1 = create_a1_state(
-        &ctx.rng,
-        &s_remote,
-        kid_recv,
-        &ratchet_state1,
-        ratchet_state2.as_ref(),
-        identity,
-    )
-    .ok_or(OpenError::InvalidPublicKey)?;
+    let a1 = create_a1_state(&ctx.rng, &s_remote, kid_recv, &state1, state2.as_ref(), identity)
+        .ok_or(OpenError::InvalidPublicKey)?;
     let packet = a1.packet.clone();
 
     let (hk_recv, hk_send) = a1.noise.get_ask(LABEL_HEADER_KEY);
@@ -295,14 +302,14 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
         session_data,
         was_bob: false,
         s_remote,
-        send_counter: INIT_COUNTER,
+        send_counter: 0,
         key_creation_counter: 0,
         counter_antireplay_window: std::array::from_fn(|_| 0),
         defrag: DefragBuffer::new(Some(hk_recv)),
         key_index: true,
         keys: [DuplexKey::default(), DuplexKey::default()],
-        ratchet_state1,
-        ratchet_state2,
+        ratchet_state1: state1,
+        ratchet_state2: state2,
         hk_send,
         resend_timer: current_time + App::SETTINGS.resend_time as i64,
         timeout_timer: current_time + App::SETTINGS.initial_offer_timeout as i64,
@@ -390,13 +397,14 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
 
     let mut ratchet_state = None;
     while i + RATCHET_SIZE <= j {
-        match app.restore_by_fingerprint((&x1[i..i + RATCHET_SIZE]).try_into().unwrap()) {
+        let rf = (&x1[i..i + RATCHET_SIZE]).try_into().unwrap();
+        match app.restore_by_fingerprint(rf) {
             Ok(None) => {}
             Ok(Some(rs)) => {
                 ratchet_state = Some(rs);
                 break;
             }
-            Err(e) => return Err(ReceiveError::RatchetIoError(e)),
+            Err(e) => return Err(ReceiveError::StorageError(e)),
         }
         i += RATCHET_SIZE;
     }
@@ -587,12 +595,12 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
                     state1: &new_ratchet_state,
                     state2: ratchet_to_preserve,
                     state1_was_just_added: true,
-                    state_deleted1: ratchet_to_delete,
-                    state_deleted2: None,
+                    deleted_state1: ratchet_to_delete,
+                    deleted_state2: None,
                 },
             );
             if let Err(e) = result {
-                return Err(ReceiveError::RatchetIoError(e));
+                return Err(ReceiveError::StorageError(e));
             }
 
             let (kek_recv, kek_send) = noise.get_ask(LABEL_KEX_KEY);
@@ -671,7 +679,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
     let identity_end = j;
 
     let (kek_send, kek_recv) = noise.get_ask(LABEL_KEX_KEY);
-    let c = INIT_COUNTER;
+    let c = 0;
 
     let action = app.check_accept_session(&s_remote, &x3[identity_start..identity_end]);
     let responder_disallows_downgrade = action.responder_disallows_downgrade;
@@ -690,8 +698,9 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
     if let Some(session_data) = session_data {
         let result = app.restore_by_identity(&s_remote, &session_data);
         match result {
-            Ok((ratchet_state1, ratchet_state2)) => {
-                if (&zeta.ratchet_state != &ratchet_state1) & (Some(&zeta.ratchet_state) != ratchet_state2.as_ref()) {
+            Ok(rss) => {
+                let RatchetStates { state1, state2 } = rss.unwrap_or_default();
+                if (&zeta.ratchet_state != &state1) & (Some(&zeta.ratchet_state) != state2.as_ref()) {
                     if !responder_disallows_downgrade && zeta.ratchet_state.fingerprint().is_none() {
                         // TODO: add some kind of warning callback or signal.
                     } else {
@@ -712,12 +721,12 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                         state1: &new_ratchet_state,
                         state2: None,
                         state1_was_just_added: true,
-                        state_deleted1: Some(&ratchet_state1),
-                        state_deleted2: ratchet_state2.as_ref(),
+                        deleted_state1: Some(&state1),
+                        deleted_state2: state2.as_ref(),
                     },
                 );
                 if let Err(e) = result {
-                    return Err(ReceiveError::RatchetIoError(e));
+                    return Err(ReceiveError::StorageError(e));
                 }
 
                 let mut c1 = Vec::new();
@@ -745,8 +754,8 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                     session_data,
                     was_bob: true,
                     s_remote,
-                    send_counter: INIT_COUNTER + 1,
-                    key_creation_counter: INIT_COUNTER + 1,
+                    send_counter: 1,
+                    key_creation_counter: 1,
                     key_index: false,
                     keys: [keys, DuplexKey::default()],
                     ratchet_state1: new_ratchet_state,
@@ -767,7 +776,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                 send(&Packet(zeta.kid_send.get(), n, c1), Some(&zeta.hk_send));
                 Ok(session)
             }
-            Err(e) => Err(ReceiveError::RatchetIoError(e)),
+            Err(e) => Err(ReceiveError::StorageError(e)),
         }
     } else {
         if !responder_silently_rejects {
@@ -827,12 +836,12 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
                         state1: &zeta.ratchet_state1,
                         state2: None,
                         state1_was_just_added: false,
-                        state_deleted1: zeta.ratchet_state2.as_ref(),
-                        state_deleted2: None,
+                        deleted_state1: zeta.ratchet_state2.as_ref(),
+                        deleted_state2: None,
                     },
                 );
                 if let Err(e) = result {
-                    return Err(ReceiveError::RatchetIoError(e));
+                    return Err(ReceiveError::StorageError(e));
                 }
             }
 
@@ -849,8 +858,7 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
     }
     let mut c2 = Vec::new();
 
-    let c = zeta.send_counter;
-    zeta.send_counter += 1;
+    let (c, _) = zeta.get_counter().ok_or(byzantine_fault!(ExpiredCounter, true))?;
     let n = to_nonce(PACKET_TYPE_ACK, c);
     let latest_confirmed_key = zeta
         .key_ref(false)
@@ -976,20 +984,20 @@ pub(crate) fn service<App: ApplicationLayer>(
                 (PACKET_TYPE_REKEY_COMPLETE, k2.clone())
             }
         };
-        let c = zeta.send_counter;
-        zeta.send_counter += 1;
-        let n = to_nonce(p, c);
-        let tag = App::Aead::encrypt_in_place(
-            zeta.key_ref(false).send.kek.as_ref().unwrap(),
-            n,
-            None,
-            &mut control_payload,
-        );
-        control_payload.extend(&tag);
-        send(
-            &Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, control_payload),
-            Some(&zeta.hk_send),
-        );
+        if let Some((c, _)) = zeta.get_counter() {
+            let n = to_nonce(p, c);
+            let tag = App::Aead::encrypt_in_place(
+                zeta.key_ref(false).send.kek.as_ref().unwrap(),
+                n,
+                None,
+                &mut control_payload,
+            );
+            control_payload.extend(&tag);
+            send(
+                &Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, control_payload),
+                Some(&zeta.hk_send),
+            );
+        }
     }
 }
 fn remap<App: ApplicationLayer>(
@@ -1088,16 +1096,16 @@ fn timeout_trans<App: ApplicationLayer>(
             zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
             zeta.beta = ZetaAutomata::R1 { noise, e_secret, k1: k1.clone() };
 
-            let c = zeta.send_counter;
-            zeta.send_counter += 1;
-            let n = to_nonce(PACKET_TYPE_REKEY_INIT, c);
-            let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.kek.as_ref().unwrap(), n, None, &mut k1);
-            k1.extend(&tag);
+            if let Some((c, _)) = zeta.get_counter() {
+                let n = to_nonce(PACKET_TYPE_REKEY_INIT, c);
+                let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.kek.as_ref().unwrap(), n, None, &mut k1);
+                k1.extend(&tag);
 
-            send(
-                &Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, k1),
-                Some(&zeta.hk_send),
-            );
+                send(
+                    &Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, k1),
+                    Some(&zeta.hk_send),
+                );
+            };
         }
         ZetaAutomata::S1 { .. } => {
             log!(app, TimeoutKeyConfirm(session));
@@ -1220,12 +1228,12 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
                 state1: &new_ratchet_state,
                 state2: Some(&zeta.ratchet_state1),
                 state1_was_just_added: true,
-                state_deleted1: zeta.ratchet_state2.as_ref(),
-                state_deleted2: None,
+                deleted_state1: zeta.ratchet_state2.as_ref(),
+                deleted_state2: None,
             },
         );
         if let Err(e) = result {
-            return Err(ReceiveError::RatchetIoError(e));
+            return Err(ReceiveError::StorageError(e));
         }
         let (kek_send, kek_recv) = noise.get_ask(LABEL_KEX_KEY);
         let (nk_send, nk_recv) = noise.split();
@@ -1244,8 +1252,7 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
         zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
         zeta.beta = ZetaAutomata::R2 { k2: k2.clone() };
 
-        let c = zeta.send_counter;
-        zeta.send_counter += 1;
+        let (c, _) = zeta.get_counter().ok_or(byzantine_fault!(ExpiredCounter, true))?;
         let n = to_nonce(PACKET_TYPE_REKEY_COMPLETE, c);
         let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.kek.as_ref().unwrap(), n, None, &mut k2);
         k2.extend(&tag);
@@ -1333,12 +1340,12 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
                     state1: &new_ratchet_state,
                     state2: None,
                     state1_was_just_added: true,
-                    state_deleted1: Some(&zeta.ratchet_state1),
-                    state_deleted2: zeta.ratchet_state2.as_ref(),
+                    deleted_state1: Some(&zeta.ratchet_state1),
+                    deleted_state2: zeta.ratchet_state2.as_ref(),
                 },
             );
             if let Err(e) = result {
-                return Err(ReceiveError::RatchetIoError(e));
+                return Err(ReceiveError::StorageError(e));
             }
             let (kek_recv, kek_send) = noise.get_ask(LABEL_KEX_KEY);
             let (nk_recv, nk_send) = noise.split();
@@ -1357,8 +1364,7 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
             zeta.beta = ZetaAutomata::S1;
 
             let mut c1 = Vec::new();
-            let c = zeta.send_counter;
-            zeta.send_counter += 1;
+            let (c, _) = zeta.get_counter().ok_or(byzantine_fault!(ExpiredCounter, true))?;
             let n = to_nonce(PACKET_TYPE_KEY_CONFIRM, c);
             let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.kek.as_ref().unwrap(), n, None, &mut []);
             c1.extend(&tag);
@@ -1394,26 +1400,25 @@ pub(crate) fn send_payload<App: ApplicationLayer>(
     ) {
         return Err(SessionNotEstablished);
     }
-    let c = zeta.send_counter;
-    zeta.send_counter += 1;
-    if c >= zeta.key_creation_counter + App::SETTINGS.rekey_after_key_uses {
-        if c >= zeta.key_creation_counter + EXPIRE_AFTER_USES {
-            zeta.expire();
-        } else {
+    if let Some((c, should_rekey)) = zeta.get_counter() {
+        if should_rekey {
             // Cause timeout to occur next service interval.
             zeta.timeout_timer = i64::MIN;
         }
+
+        let n = to_nonce(PACKET_TYPE_DATA, c);
+        let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.nk.as_ref().unwrap(), n, None, &mut payload);
+        payload.extend(&tag);
+
+        send(
+            &Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, payload),
+            Some(&zeta.hk_send),
+        );
+        Ok(())
+    } else {
+        zeta.expire();
+        Err(SessionExpired)
     }
-
-    let n = to_nonce(PACKET_TYPE_DATA, c);
-    let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.nk.as_ref().unwrap(), n, None, &mut payload);
-    payload.extend(&tag);
-
-    send(
-        &Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, payload),
-        Some(&zeta.hk_send),
-    );
-    Ok(())
 }
 /// Corresponds to Algorithm 10 found in Section 4.3.
 pub(crate) fn received_payload_in_place<App: ApplicationLayer>(

From a5851e93957bb34091226ffd18808a7d64a1ed2e Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 8 Aug 2023 09:32:06 -0400
Subject: [PATCH 26/37] standardized names

---
 src/application.rs           |  14 ++--
 src/challenge.rs             |  14 ++--
 src/context.rs               |   8 +-
 src/crypto/aes.rs            |  12 +--
 src/crypto/kyber1024.rs      |   2 +-
 src/crypto/p384.rs           |   6 +-
 src/crypto/sha512.rs         |   2 +-
 src/crypto_impl/aes_impl.rs  |  19 +++--
 src/crypto_impl/kyber1024.rs |   2 +-
 src/crypto_impl/p384_impl.rs |   4 +-
 src/crypto_impl/sha512.rs    |   2 +-
 src/fragmentation.rs         |   2 +-
 src/ratchet_state.rs         |   6 +-
 src/symmetric_state.rs       |  10 +--
 src/zeta.rs                  | 140 ++++++++++++++---------------------
 15 files changed, 110 insertions(+), 133 deletions(-)

diff --git a/src/application.rs b/src/application.rs
index 776c7ac..5e97ba0 100644
--- a/src/application.rs
+++ b/src/application.rs
@@ -1,7 +1,7 @@
 use rand_core::{CryptoRng, RngCore};
 use std::sync::Arc;
 
-use crate::crypto::{AeadAesGcm, HashSha512, KeyPairP384, PrivateKeyKyber1024, PrpAes256, PublicKeyP384};
+use crate::crypto::{Aes256Prp, AesGcmAead, Kyber1024PrivateKey, P384KeyPair, P384PublicKey, Sha512Hash};
 #[cfg(feature = "logging")]
 use crate::LogEvent;
 use crate::Session;
@@ -101,35 +101,35 @@ pub trait ApplicationLayer: Sized {
     /// We provide an optional implementation for this trait using the `aes` crate.
     ///
     /// FIPS compliance requires use of a FIPS certified implementation.
-    type Prp: PrpAes256;
+    type Prp: Aes256Prp;
     /// The implementation of AES-GCM-256 that ZSSP should use.
     /// The efficiency and security of ZSSP is very closely tied to the efficiency and security of
     /// this implementation.
     /// We provide an optional implementation for this trait using the `aes-gcm` crate.
     ///
     /// FIPS compliance requires a FIPS certified implementation.
-    type Aead: AeadAesGcm;
+    type Aead: AesGcmAead;
     /// The implementation of SHA-512 that ZSSP should use.
     /// We provide an optional implementation for this trait using the `sha2` crate.
     ///
     /// FIPS compliance requires use of a FIPS certified implementation.
-    type Hash: HashSha512;
+    type Hash: Sha512Hash;
     /// The implementation of P-384 public keys that ZSSP should use.
     /// We provide an optional implementation for this trait using the `p384` crate.
     ///
     /// FIPS compliance requires a FIPS certified implementation.
-    type PublicKey: PublicKeyP384;
+    type PublicKey: P384PublicKey;
     /// The implementation of P-384 private keys that ZSSP should use.
     /// We provide an optional implementation for this trait using the `p384` crate.
     ///
     /// FIPS compliance requires use of a FIPS certified implementation.
-    type KeyPair: KeyPairP384<Self::Rng, PublicKey = Self::PublicKey>;
+    type KeyPair: P384KeyPair<Self::Rng, PublicKey = Self::PublicKey>;
     /// The implementation of Kyber1024 that ZSSP should use.
     /// We provide an optional implementation for this trait using the `pqc_kyber` crate.
     ///
     /// No implementation of Kyber1024 can be FIPS certified, but this is not required
     /// for ZSSP to achieve FIPS compliance.
-    type Kem: PrivateKeyKyber1024<Self::Rng>;
+    type Kem: Kyber1024PrivateKey<Self::Rng>;
 
     /// A user-defined error returned when the `ApplicationLayer` fails to access persistent storage
     /// for a peer's ratchet states.
diff --git a/src/challenge.rs b/src/challenge.rs
index 5249a7d..fa8ccd2 100644
--- a/src/challenge.rs
+++ b/src/challenge.rs
@@ -2,7 +2,7 @@ use std::hash::Hasher;
 
 use rand_core::{CryptoRng, RngCore};
 
-use crate::crypto::{secure_eq, HashSha512};
+use crate::crypto::{secure_eq, Sha512Hash};
 use crate::proto::*;
 
 pub struct ChallengeContext {
@@ -19,7 +19,7 @@ pub fn gen_null_response<Rng: RngCore + CryptoRng>(rng: &mut Rng) -> [u8; CHALLE
     response
 }
 /// Corresponds to Algorithm 13 found in Section 5.
-pub fn respond_to_challenge_in_place<Rng: RngCore + CryptoRng, Hash: HashSha512>(
+pub fn respond_to_challenge_in_place<Rng: RngCore + CryptoRng, Hash: Sha512Hash>(
     rng: &mut Rng,
     challenge: &[u8; CHALLENGE_SIZE],
     pre_response: &mut [u8; CHALLENGE_SIZE],
@@ -49,7 +49,7 @@ impl ChallengeContext {
         }
     }
     /// Corresponds to Algorithm 12 found in Section 5.
-    pub fn process_hello<Hash: HashSha512>(
+    pub fn process_hello<Hash: Sha512Hash>(
         &mut self,
         addr: &impl std::hash::Hash,
         response: &[u8; CHALLENGE_SIZE],
@@ -74,7 +74,7 @@ impl ChallengeContext {
             Err(challenge)
         }
     }
-    fn create_mac<Hash: HashSha512>(&self, c: u64, addr: &impl std::hash::Hash) -> [u8; MAC_SIZE] {
+    fn create_mac<Hash: Sha512Hash>(&self, c: u64, addr: &impl std::hash::Hash) -> [u8; MAC_SIZE] {
         let mut h = Hash::new();
         let mut hasher = ShaHasher(&mut h);
         hasher.write(&c.to_be_bytes());
@@ -100,8 +100,8 @@ impl ChallengeContext {
 }
 
 /// Trick rust into letting us use a hasher that returns more than 64 bits.
-struct ShaHasher<'a, ShaImpl: HashSha512>(&'a mut ShaImpl);
-impl<'a, ShaImpl: HashSha512> Hasher for ShaHasher<'a, ShaImpl> {
+struct ShaHasher<'a, ShaImpl: Sha512Hash>(&'a mut ShaImpl);
+impl<'a, ShaImpl: Sha512Hash> Hasher for ShaHasher<'a, ShaImpl> {
     fn finish(&self) -> u64 {
         unimplemented!()
     }
@@ -112,7 +112,7 @@ impl<'a, ShaImpl: HashSha512> Hasher for ShaHasher<'a, ShaImpl> {
 
 /// Check if the proof of work attached to the first message contains the correct number of leading
 /// zeros.
-fn verify_pow<Hash: HashSha512>(response: &[u8]) -> bool {
+fn verify_pow<Hash: Sha512Hash>(response: &[u8]) -> bool {
     if DIFFICULTY == 0 {
         return true;
     }
diff --git a/src/context.rs b/src/context.rs
index 3e5e088..49c3829 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -6,7 +6,7 @@ use std::num::NonZeroU32;
 use std::sync::{Arc, Mutex, Weak};
 
 use crate::application::ApplicationLayer;
-use crate::crypto::{AES_256_KEY_SIZE, AES_GCM_IV_SIZE};
+use crate::crypto::{AES_256_KEY_SIZE, AES_GCM_NONCE_SIZE};
 use crate::fragmentation::{send_with_fragmentation, DefragBuffer};
 use crate::proto::*;
 use crate::result::{byzantine_fault, ReceiveError, ReceiveOk, SendError, SessionEvent};
@@ -51,13 +51,13 @@ pub(crate) struct ContextInner<App: ApplicationLayer> {
 }
 
 /// Corresponds to Figure 10 found in Section 4.3.
-fn to_aes_nonce(pn: &[u8; PACKET_NONCE_SIZE]) -> [u8; AES_GCM_IV_SIZE] {
-    let mut an = [0u8; AES_GCM_IV_SIZE];
+fn to_aes_nonce(pn: &[u8; PACKET_NONCE_SIZE]) -> [u8; AES_GCM_NONCE_SIZE] {
+    let mut an = [0u8; AES_GCM_NONCE_SIZE];
     an[2..].copy_from_slice(pn);
     an
 }
 /// Corresponds to Figure 14 found near Section 6.
-fn to_packet_nonce(n: &[u8; AES_GCM_IV_SIZE]) -> &[u8; PACKET_NONCE_SIZE] {
+fn to_packet_nonce(n: &[u8; AES_GCM_NONCE_SIZE]) -> &[u8; PACKET_NONCE_SIZE] {
     (&n[n.len() - PACKET_NONCE_SIZE..]).try_into().unwrap()
 }
 
diff --git a/src/crypto/aes.rs b/src/crypto/aes.rs
index 9a16d87..f7881c0 100644
--- a/src/crypto/aes.rs
+++ b/src/crypto/aes.rs
@@ -6,12 +6,12 @@ pub const AES_256_KEY_SIZE: usize = 32;
 /// Some implementations of AES-GCM allow use of smaller tags, but ZSSP will only accept 16 byte tags.
 pub const AES_GCM_TAG_SIZE: usize = 16;
 /// The size of an AES-GCM IV, or nonce, which is 12 bytes, or 96 bits.
-pub const AES_GCM_IV_SIZE: usize = 12;
+pub const AES_GCM_NONCE_SIZE: usize = 12;
 
 /// A trait for encrypting individual blocks of plaintext using AES-256.
 /// It is used for header authentication, for which we have a standard model proof that our
 /// algorithm is secure.
-pub trait PrpAes256 {
+pub trait Aes256Prp {
     /// Encrypt the given `block` of plaintext directly using the AES block cipher
     /// (i.e. AES-256 in zero-padding ECB mode).
     /// The ciphertext should be written directly back to `block`.
@@ -24,12 +24,12 @@ pub trait PrpAes256 {
 
 /// A trait accessing AES-GCM-256 encryption and decryption as a set of pure-functions.
 /// These should be trivial to implement for most implementations of AES-GCM.
-pub trait AeadAesGcm {
+pub trait AesGcmAead {
     /// Encrypt the given `buffer` of plaintext using AES-GCM-256, with the given `key`, `iv` and `aad`.
     /// The ciphertext should be written directly back to `buffer`, and the GCM tag should be returned.
     fn encrypt_in_place(
         key: &[u8; AES_256_KEY_SIZE],
-        iv: [u8; AES_GCM_IV_SIZE],
+        nonce: &[u8; AES_GCM_NONCE_SIZE],
         aad: Option<&[u8]>,
         buffer: &mut [u8],
     ) -> [u8; AES_GCM_TAG_SIZE];
@@ -37,9 +37,9 @@ pub trait AeadAesGcm {
     /// The ciphertext should be written directly back to `buffer`, and the GCM tag should be returned.
     fn decrypt_in_place(
         key: &[u8; AES_256_KEY_SIZE],
-        iv: [u8; AES_GCM_IV_SIZE],
+        nonce: &[u8; AES_GCM_NONCE_SIZE],
         aad: Option<&[u8]>,
         buffer: &mut [u8],
-        tag: [u8; AES_GCM_TAG_SIZE],
+        tag: &[u8; AES_GCM_TAG_SIZE],
     ) -> bool;
 }
diff --git a/src/crypto/kyber1024.rs b/src/crypto/kyber1024.rs
index 9c5b5c5..0cc898a 100644
--- a/src/crypto/kyber1024.rs
+++ b/src/crypto/kyber1024.rs
@@ -8,7 +8,7 @@ pub const KYBER_CIPHERTEXT_SIZE: usize = 1568;
 pub const KYBER_PLAINTEXT_SIZE: usize = 32;
 
 /// Instances must securely delete the private key when dropped.
-pub trait PrivateKeyKyber1024<Rng: RngCore + CryptoRng>: Sized + Send + Sync {
+pub trait Kyber1024PrivateKey<Rng: RngCore + CryptoRng>: Sized + Send + Sync {
     /// Generate a Kyber1024 private key and public key pair, and return the raw bytes of the public
     /// key.
     /// The private key will be temporarily held in memory but the public key will be immediately
diff --git a/src/crypto/p384.rs b/src/crypto/p384.rs
index 6d13387..84acf23 100644
--- a/src/crypto/p384.rs
+++ b/src/crypto/p384.rs
@@ -6,7 +6,7 @@ pub const P384_PUBLIC_KEY_SIZE: usize = 49;
 pub const P384_ECDH_SHARED_SECRET_SIZE: usize = 48;
 
 /// A NIST P-384 ECDH/ECDSA public key.
-pub trait PublicKeyP384: Sized + Send + Sync {
+pub trait P384PublicKey: Sized + Send + Sync {
     /// Create a P-384 public key from raw bytes.
     ///
     /// **CRITICAL**: This function must return `None` if the input `raw_key` is not on the P-384
@@ -22,9 +22,9 @@ pub trait PublicKeyP384: Sized + Send + Sync {
 /// A NIST P-384 ECDH/ECDSA public/private key pair.
 ///
 /// Instances must securely delete the private key when dropped.
-pub trait KeyPairP384<Rng: RngCore + CryptoRng> {
+pub trait P384KeyPair<Rng: RngCore + CryptoRng> {
     /// The `PublicKeyP384` implementation which matches this `KeyPairP384` implementation.
-    type PublicKey: PublicKeyP384;
+    type PublicKey: P384PublicKey;
     /// Randomly generate a new P-384 keypair.
     ///
     /// This function may use the provided RNG or its own, so long as the output is cryptographically random.
diff --git a/src/crypto/sha512.rs b/src/crypto/sha512.rs
index 2eb32a2..b1468ca 100644
--- a/src/crypto/sha512.rs
+++ b/src/crypto/sha512.rs
@@ -2,7 +2,7 @@
 pub const SHA512_HASH_SIZE: usize = 64;
 
 /// A SHA-512 and HMAC-SHA-512 implementation.
-pub trait HashSha512 {
+pub trait Sha512Hash {
     /// Create a new instance of SHA-512 for streaming data to.
     fn new() -> Self;
     /// Update the instance of SHA-512 with input `data`.
diff --git a/src/crypto_impl/aes_impl.rs b/src/crypto_impl/aes_impl.rs
index c19b26d..037430a 100644
--- a/src/crypto_impl/aes_impl.rs
+++ b/src/crypto_impl/aes_impl.rs
@@ -5,7 +5,7 @@ use aes_gcm::{Aes256Gcm, Key, Nonce, Tag};
 
 use crate::crypto::*;
 
-impl PrpAes256 for Aes256 {
+impl Aes256Prp for Aes256 {
     fn encrypt_in_place(key: &[u8; AES_256_KEY_SIZE], block: &mut [u8; AES_256_BLOCK_SIZE]) {
         let cipher = Aes256::new(GenericArray::from_slice(key));
         cipher.encrypt_block(GenericArray::from_mut_slice(block));
@@ -17,17 +17,17 @@ impl PrpAes256 for Aes256 {
     }
 }
 
-impl AeadAesGcm for Aes256Gcm {
+impl AesGcmAead for Aes256Gcm {
     fn encrypt_in_place(
         key: &[u8; AES_256_KEY_SIZE],
-        iv: [u8; AES_GCM_IV_SIZE],
+        iv: &[u8; AES_GCM_NONCE_SIZE],
         aad: Option<&[u8]>,
         buffer: &mut [u8],
     ) -> [u8; AES_GCM_TAG_SIZE] {
         let key = Key::<Aes256Gcm>::from_slice(key);
         let mut cipher = Aes256Gcm::new(&key);
         cipher
-            .encrypt_in_place_detached(&Nonce::from(iv), aad.unwrap_or(&[]), buffer)
+            .encrypt_in_place_detached(&Nonce::from_slice(iv), aad.unwrap_or(&[]), buffer)
             .unwrap()
             .try_into()
             .unwrap()
@@ -35,15 +35,20 @@ impl AeadAesGcm for Aes256Gcm {
 
     fn decrypt_in_place(
         key: &[u8; AES_256_KEY_SIZE],
-        iv: [u8; AES_GCM_IV_SIZE],
+        iv: &[u8; AES_GCM_NONCE_SIZE],
         aad: Option<&[u8]>,
         buffer: &mut [u8],
-        tag: [u8; AES_GCM_TAG_SIZE],
+        tag: &[u8; AES_GCM_TAG_SIZE],
     ) -> bool {
         let key = Key::<Aes256Gcm>::from_slice(key);
         let mut cipher = Aes256Gcm::new(&key);
         cipher
-            .decrypt_in_place_detached(&Nonce::from(iv), aad.unwrap_or(&[]), buffer, &Tag::from(tag))
+            .decrypt_in_place_detached(
+                &Nonce::from_slice(iv),
+                aad.unwrap_or(&[]),
+                buffer,
+                &Tag::from_slice(tag),
+            )
             .is_ok()
     }
 }
diff --git a/src/crypto_impl/kyber1024.rs b/src/crypto_impl/kyber1024.rs
index 9f56dc3..f5a518b 100644
--- a/src/crypto_impl/kyber1024.rs
+++ b/src/crypto_impl/kyber1024.rs
@@ -7,7 +7,7 @@ use crate::crypto::*;
 /// The crate `pqc_kyber` is low level and operates directly on buffers of bytes.
 pub type PqcKyberSecretKey = Zeroizing<[u8; pqc_kyber::KYBER_SECRETKEYBYTES]>;
 
-impl<Rng: RngCore + CryptoRng> PrivateKeyKyber1024<Rng> for PqcKyberSecretKey {
+impl<Rng: RngCore + CryptoRng> Kyber1024PrivateKey<Rng> for PqcKyberSecretKey {
     fn generate(rng: &mut Rng) -> (Self, [u8; KYBER_PUBLIC_KEY_SIZE]) {
         let keypair = pqc_kyber::keypair(rng);
         (Zeroizing::new(keypair.secret), keypair.public)
diff --git a/src/crypto_impl/p384_impl.rs b/src/crypto_impl/p384_impl.rs
index d20705a..2898bc6 100644
--- a/src/crypto_impl/p384_impl.rs
+++ b/src/crypto_impl/p384_impl.rs
@@ -3,7 +3,7 @@ use rand_core::{CryptoRng, RngCore};
 
 use crate::crypto::*;
 
-impl PublicKeyP384 for PublicKey {
+impl P384PublicKey for PublicKey {
     fn from_bytes(raw_key: &[u8; P384_PUBLIC_KEY_SIZE]) -> Option<Self> {
         PublicKey::from_sec1_bytes(raw_key).ok()
     }
@@ -14,7 +14,7 @@ impl PublicKeyP384 for PublicKey {
     }
 }
 
-impl<Rng: RngCore + CryptoRng> KeyPairP384<Rng> for EphemeralSecret {
+impl<Rng: RngCore + CryptoRng> P384KeyPair<Rng> for EphemeralSecret {
     type PublicKey = PublicKey;
 
     fn generate(rng: &mut Rng) -> Self {
diff --git a/src/crypto_impl/sha512.rs b/src/crypto_impl/sha512.rs
index 11e531c..87c66d5 100644
--- a/src/crypto_impl/sha512.rs
+++ b/src/crypto_impl/sha512.rs
@@ -3,7 +3,7 @@ use sha2::{Digest, Sha512};
 
 use crate::crypto::*;
 
-impl HashSha512 for Sha512 {
+impl Sha512Hash for Sha512 {
     fn new() -> Self {
         Digest::new()
     }
diff --git a/src/fragmentation.rs b/src/fragmentation.rs
index 6af8f45..43c1cb6 100644
--- a/src/fragmentation.rs
+++ b/src/fragmentation.rs
@@ -5,7 +5,7 @@ use std::sync::Mutex;
 use zeroize::Zeroizing;
 
 use crate::application::ApplicationLayer;
-use crate::crypto::{PrpAes256, AES_256_KEY_SIZE};
+use crate::crypto::{Aes256Prp, AES_256_KEY_SIZE};
 use crate::proto::*;
 use crate::result::{byzantine_fault, ReceiveError};
 
diff --git a/src/ratchet_state.rs b/src/ratchet_state.rs
index c4ede59..75de1ee 100644
--- a/src/ratchet_state.rs
+++ b/src/ratchet_state.rs
@@ -1,6 +1,6 @@
 use zeroize::Zeroizing;
 
-use crate::crypto::{secure_eq, HashSha512};
+use crate::crypto::{secure_eq, Sha512Hash};
 use crate::proto::*;
 /// A ratchet key and fingerprint,
 /// along with the length of the ratchet chain the keys were derived from.
@@ -51,7 +51,7 @@ impl RatchetState {
             chain_len: 0,
         }
     }
-    pub fn new_from_otp<Hmac: HashSha512>(otp: &[u8]) -> RatchetState {
+    pub fn new_from_otp<Hmac: Sha512Hash>(otp: &[u8]) -> RatchetState {
         let mut buffer = Vec::new();
         buffer.push(1);
         buffer.extend(LABEL_OTP_TO_RATCHET);
@@ -99,7 +99,7 @@ impl RatchetStates {
     pub fn new_initial_states() -> Self {
         Self { state1: RatchetState::empty(), state2: None }
     }
-    pub fn new_otp_states<Hmac: HashSha512>(otp: &[u8]) -> Self {
+    pub fn new_otp_states<Hmac: Sha512Hash>(otp: &[u8]) -> Self {
         Self {
             state1: RatchetState::new_from_otp::<Hmac>(otp),
             state2: None,
diff --git a/src/symmetric_state.rs b/src/symmetric_state.rs
index 7c276d5..deaab6e 100644
--- a/src/symmetric_state.rs
+++ b/src/symmetric_state.rs
@@ -3,7 +3,7 @@ use std::marker::PhantomData;
 use zeroize::Zeroizing;
 
 use crate::application::ApplicationLayer;
-use crate::crypto::{AeadAesGcm, HashSha512, AES_256_KEY_SIZE, AES_GCM_IV_SIZE, AES_GCM_TAG_SIZE};
+use crate::crypto::{AesGcmAead, Sha512Hash, AES_256_KEY_SIZE, AES_GCM_NONCE_SIZE, AES_GCM_TAG_SIZE};
 use crate::proto::{HASHLEN, LABEL_KBKDF_CHAIN};
 
 pub struct SymmetricState<App: ApplicationLayer> {
@@ -125,11 +125,11 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     /// Corresponds to Noise `EncryptAndHash`.
     pub fn encrypt_and_hash_in_place(
         &mut self,
-        iv: [u8; AES_GCM_IV_SIZE],
+        iv: [u8; AES_GCM_NONCE_SIZE],
         plaintext_start: usize,
         buffer: &mut Vec<u8>,
     ) {
-        let tag = App::Aead::encrypt_in_place(&self.k, iv, Some(&self.h), &mut buffer[plaintext_start..]);
+        let tag = App::Aead::encrypt_in_place(&self.k, &iv, Some(&self.h), &mut buffer[plaintext_start..]);
         buffer.extend(&tag);
         self.mix_hash(&buffer[plaintext_start..]);
     }
@@ -137,7 +137,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     #[must_use]
     pub fn decrypt_and_hash_in_place(
         &mut self,
-        iv: [u8; AES_GCM_IV_SIZE],
+        iv: [u8; AES_GCM_NONCE_SIZE],
         buffer: &mut [u8],
         tag: [u8; AES_GCM_TAG_SIZE],
     ) -> bool {
@@ -145,7 +145,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         hash.update(&self.h);
         hash.update(buffer);
         hash.update(&tag);
-        let ret = App::Aead::decrypt_in_place(&self.k, iv, Some(&self.h), buffer, tag);
+        let ret = App::Aead::decrypt_in_place(&self.k, &iv, Some(&self.h), buffer, &tag);
         self.h = hash.finish();
         ret
     }
diff --git a/src/zeta.rs b/src/zeta.rs
index c005334..1601b70 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -27,8 +27,8 @@ use crate::LogEvent::*;
 /// the key id.
 ///
 /// Corresponds to Figure 10 found in Section 4.3.
-pub(crate) fn to_nonce(packet_type: u8, counter: u64) -> [u8; AES_GCM_IV_SIZE] {
-    let mut ret = [0u8; AES_GCM_IV_SIZE];
+pub(crate) fn to_nonce(packet_type: u8, counter: u64) -> [u8; AES_GCM_NONCE_SIZE] {
+    let mut ret = [0u8; AES_GCM_NONCE_SIZE];
     ret[3] = packet_type;
     // Noise requires a big endian counter at the end of the Nonce
     ret[4..].copy_from_slice(&counter.to_be_bytes());
@@ -97,7 +97,7 @@ pub(crate) struct Keys {
 
 /// Corresponds to the tuple of values the Transition Algorithms send to the remote peer in Section 4.3.
 #[derive(Clone)]
-pub(crate) struct Packet(pub u32, pub [u8; AES_GCM_IV_SIZE], pub Vec<u8>);
+pub(crate) struct Packet(pub u32, pub [u8; AES_GCM_NONCE_SIZE], pub Vec<u8>);
 
 /// Corresponds to State A_1 of the Zeta State Machine found in Section 4.1.
 #[derive(Clone)]
@@ -347,7 +347,7 @@ pub(crate) fn respond_to_challenge<App: ApplicationLayer>(
 pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     app: &App,
     ctx: &ContextInner<App>,
-    n: [u8; AES_GCM_IV_SIZE],
+    n: [u8; AES_GCM_NONCE_SIZE],
     mut x1: Vec<u8>,
     send: impl FnOnce(&Packet, &[u8; AES_256_KEY_SIZE]),
 ) -> Result<(), ReceiveError<App::StorageError>> {
@@ -359,7 +359,7 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     if !(HANDSHAKE_HELLO_MIN_SIZE..=HANDSHAKE_HELLO_MAX_SIZE).contains(&x1.len()) {
         return Err(byzantine_fault!(InvalidPacket, true));
     }
-    if &n[AES_GCM_IV_SIZE - 8..] != &x1[x1.len() - 8..] {
+    if &n[AES_GCM_NONCE_SIZE - 8..] != &x1[x1.len() - 8..] {
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let mut noise = SymmetricState::<App>::initialize(PROTOCOL_NAME_NOISE_XK);
@@ -480,7 +480,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
     app: &App,
     ctx: &Arc<ContextInner<App>>,
     kid: NonZeroU32,
-    n: [u8; AES_GCM_IV_SIZE],
+    n: [u8; AES_GCM_NONCE_SIZE],
     mut x2: Vec<u8>,
     send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
 ) -> Result<(), ReceiveError<App::StorageError>> {
@@ -494,7 +494,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
         return Err(byzantine_fault!(UnknownLocalKeyId, true));
     }
     let (_, c) = from_nonce(&n);
-    if c >= COUNTER_WINDOW_MAX_SKIP_AHEAD || &n[AES_GCM_IV_SIZE - 3..] != &x2[x2.len() - 3..] {
+    if c >= COUNTER_WINDOW_MAX_SKIP_AHEAD || &n[AES_GCM_NONCE_SIZE - 3..] != &x2[x2.len() - 3..] {
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let result = (|| {
@@ -634,6 +634,27 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
     }
     result.map(|_| ())
 }
+fn send_control<App: ApplicationLayer>(
+    zeta: &mut Zeta<App>,
+    packet_type: u8,
+    mut payload: Vec<u8>,
+    send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
+) -> bool {
+    if let Some((c, _)) = zeta.get_counter() {
+        if let (Some(kek), Some(kid)) = (zeta.key_ref(false).send.kek.as_ref(), zeta.key_ref(false).send.kid) {
+            let nonce = to_nonce(packet_type, c);
+            let tag = App::Aead::encrypt_in_place(kek, &nonce, None, &mut payload[HEADER_SIZE..]);
+            payload.extend(tag);
+
+            send(&Packet(kid.get(), nonce, payload), Some(&zeta.hk_send));
+            true
+        } else {
+            false
+        }
+    } else {
+        false
+    }
+}
 /// Corresponds to Transition Algorithm 4 found in Section 4.3.
 pub(crate) fn received_x3_trans<App: ApplicationLayer>(
     zeta: StateB2<App>,
@@ -688,7 +709,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
     let create_reject = || {
         let mut d = Vec::<u8>::new();
         let n = to_nonce(PACKET_TYPE_SESSION_REJECTED, c);
-        let tag = App::Aead::encrypt_in_place(&kek_send, n, None, &mut []);
+        let tag = App::Aead::encrypt_in_place(&kek_send, &n, None, &mut []);
         d.extend(&tag);
         // We just used a counter with this key, but we are not storing
         // the fact we used it in memory. This is currently ok because the
@@ -731,7 +752,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
 
                 let mut c1 = Vec::new();
                 let n = to_nonce(PACKET_TYPE_KEY_CONFIRM, c);
-                let tag = App::Aead::encrypt_in_place(&kek_send, n, None, &mut []);
+                let tag = App::Aead::encrypt_in_place(&kek_send, &n, None, &mut []);
                 c1.extend(&tag);
 
                 let (nk1, nk2) = noise.split();
@@ -791,7 +812,7 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
     app: &App,
     rng: &Mutex<App::Rng>,
     kid: NonZeroU32,
-    n: [u8; AES_GCM_IV_SIZE],
+    n: [u8; AES_GCM_NONCE_SIZE],
     c1: Vec<u8>,
     send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
 ) -> Result<bool, ReceiveError<App::StorageError>> {
@@ -817,7 +838,7 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
         .as_ref()
         .ok_or(byzantine_fault!(OutOfSequence, true))?;
     let tag = c1[..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(specified_key, n, None, &mut [], tag) {
+    if !App::Aead::decrypt_in_place(specified_key, &n, None, &mut [], tag) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let (_, c) = from_nonce(&n);
@@ -856,23 +877,11 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
             zeta.beta = ZetaAutomata::S2;
         }
     }
-    let mut c2 = Vec::new();
+    let c2 = Vec::new();
+    if !send_control(zeta, PACKET_TYPE_ACK, c2, send) {
+        return Err(byzantine_fault!(OutOfSequence, true));
+    }
 
-    let (c, _) = zeta.get_counter().ok_or(byzantine_fault!(ExpiredCounter, true))?;
-    let n = to_nonce(PACKET_TYPE_ACK, c);
-    let latest_confirmed_key = zeta
-        .key_ref(false)
-        .send
-        .kek
-        .as_ref()
-        .ok_or(byzantine_fault!(OutOfSequence, true))?;
-    let tag = App::Aead::encrypt_in_place(latest_confirmed_key, n, None, &mut []);
-    c2.extend(&tag);
-
-    send(
-        &Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, c2),
-        Some(&zeta.hk_send),
-    );
     Ok(just_establised)
 }
 /// Corresponds to the trivial Transition Algorithm described for processing C_2 packets found in
@@ -882,7 +891,7 @@ pub(crate) fn received_c2_trans<App: ApplicationLayer>(
     app: &App,
     rng: &Mutex<App::Rng>,
     kid: NonZeroU32,
-    n: [u8; AES_GCM_IV_SIZE],
+    n: [u8; AES_GCM_NONCE_SIZE],
     c2: Vec<u8>,
 ) -> Result<(), ReceiveError<App::StorageError>> {
     use FaultType::*;
@@ -900,7 +909,7 @@ pub(crate) fn received_c2_trans<App: ApplicationLayer>(
     }
 
     let tag = c2[..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(zeta.key_ref(false).recv.kek.as_ref().unwrap(), n, None, &mut [], tag) {
+    if !App::Aead::decrypt_in_place(zeta.key_ref(false).recv.kek.as_ref().unwrap(), &n, None, &mut [], tag) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let (_, c) = from_nonce(&n);
@@ -921,7 +930,7 @@ pub(crate) fn received_c2_trans<App: ApplicationLayer>(
 pub(crate) fn received_d_trans<App: ApplicationLayer>(
     zeta: &mut Zeta<App>,
     kid: NonZeroU32,
-    n: [u8; AES_GCM_IV_SIZE],
+    n: [u8; AES_GCM_NONCE_SIZE],
     d: Vec<u8>,
 ) -> Result<(), ReceiveError<App::StorageError>> {
     use FaultType::*;
@@ -934,7 +943,7 @@ pub(crate) fn received_d_trans<App: ApplicationLayer>(
     }
 
     let tag = d[..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(zeta.key_ref(true).recv.kek.as_ref().unwrap(), n, None, &mut [], tag) {
+    if !App::Aead::decrypt_in_place(zeta.key_ref(true).recv.kek.as_ref().unwrap(), &n, None, &mut [], tag) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let (_, c) = from_nonce(&n);
@@ -960,7 +969,7 @@ pub(crate) fn service<App: ApplicationLayer>(
         // Corresponds to the resend timer rules found in Section 4.1 - Definition 3.
         zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
 
-        let (p, mut control_payload) = match &zeta.beta {
+        let (p, control_payload) = match &zeta.beta {
             ZetaAutomata::Null => return,
             ZetaAutomata::A1(StateA1 { packet, .. }) => {
                 log!(app, ResentX1(session));
@@ -984,20 +993,8 @@ pub(crate) fn service<App: ApplicationLayer>(
                 (PACKET_TYPE_REKEY_COMPLETE, k2.clone())
             }
         };
-        if let Some((c, _)) = zeta.get_counter() {
-            let n = to_nonce(p, c);
-            let tag = App::Aead::encrypt_in_place(
-                zeta.key_ref(false).send.kek.as_ref().unwrap(),
-                n,
-                None,
-                &mut control_payload,
-            );
-            control_payload.extend(&tag);
-            send(
-                &Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, control_payload),
-                Some(&zeta.hk_send),
-            );
-        }
+
+        send_control(zeta, p, control_payload, send);
     }
 }
 fn remap<App: ApplicationLayer>(
@@ -1096,16 +1093,7 @@ fn timeout_trans<App: ApplicationLayer>(
             zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
             zeta.beta = ZetaAutomata::R1 { noise, e_secret, k1: k1.clone() };
 
-            if let Some((c, _)) = zeta.get_counter() {
-                let n = to_nonce(PACKET_TYPE_REKEY_INIT, c);
-                let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.kek.as_ref().unwrap(), n, None, &mut k1);
-                k1.extend(&tag);
-
-                send(
-                    &Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, k1),
-                    Some(&zeta.hk_send),
-                );
-            };
+            send_control(zeta, PACKET_TYPE_REKEY_INIT, k1, send);
         }
         ZetaAutomata::S1 { .. } => {
             log!(app, TimeoutKeyConfirm(session));
@@ -1130,7 +1118,7 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
     session_map: &SessionMap<App>,
     s_secret: &App::KeyPair,
     kid: NonZeroU32,
-    n: [u8; AES_GCM_IV_SIZE],
+    n: [u8; AES_GCM_NONCE_SIZE],
     mut k1: Vec<u8>,
     send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
 ) -> Result<(), ReceiveError<App::StorageError>> {
@@ -1161,10 +1149,10 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
     let tag = k1[i..].try_into().unwrap();
     if !App::Aead::decrypt_in_place(
         zeta.key_ref(false).recv.kek.as_ref().unwrap(),
-        n,
+        &n,
         None,
         &mut k1[..i],
-        tag,
+        &tag,
     ) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
@@ -1252,15 +1240,7 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
         zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
         zeta.beta = ZetaAutomata::R2 { k2: k2.clone() };
 
-        let (c, _) = zeta.get_counter().ok_or(byzantine_fault!(ExpiredCounter, true))?;
-        let n = to_nonce(PACKET_TYPE_REKEY_COMPLETE, c);
-        let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.kek.as_ref().unwrap(), n, None, &mut k2);
-        k2.extend(&tag);
-
-        send(
-            &Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, k2),
-            Some(&zeta.hk_send),
-        );
+        send_control(zeta, PACKET_TYPE_REKEY_COMPLETE, k2, send);
         Ok(())
     })();
     if matches!(result, Err(ReceiveError::ByzantineFault { .. })) {
@@ -1273,7 +1253,7 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
     zeta: &mut Zeta<App>,
     app: &App,
     kid: NonZeroU32,
-    n: [u8; AES_GCM_IV_SIZE],
+    n: [u8; AES_GCM_NONCE_SIZE],
     mut k2: Vec<u8>,
     send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
 ) -> Result<(), ReceiveError<App::StorageError>> {
@@ -1295,10 +1275,10 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
     let tag = k2[i..].try_into().unwrap();
     if !App::Aead::decrypt_in_place(
         zeta.key_ref(false).recv.kek.as_ref().unwrap(),
-        n,
+        &n,
         None,
         &mut k2[..i],
-        tag,
+        &tag,
     ) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
@@ -1363,16 +1343,8 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
             zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
             zeta.beta = ZetaAutomata::S1;
 
-            let mut c1 = Vec::new();
-            let (c, _) = zeta.get_counter().ok_or(byzantine_fault!(ExpiredCounter, true))?;
-            let n = to_nonce(PACKET_TYPE_KEY_CONFIRM, c);
-            let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.kek.as_ref().unwrap(), n, None, &mut []);
-            c1.extend(&tag);
-
-            send(
-                &Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, c1),
-                Some(&zeta.hk_send),
-            );
+            let c1 = Vec::new();
+            send_control(zeta, PACKET_TYPE_KEY_CONFIRM, c1, send);
             Ok(())
         } else {
             unreachable!()
@@ -1407,7 +1379,7 @@ pub(crate) fn send_payload<App: ApplicationLayer>(
         }
 
         let n = to_nonce(PACKET_TYPE_DATA, c);
-        let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.nk.as_ref().unwrap(), n, None, &mut payload);
+        let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.nk.as_ref().unwrap(), &n, None, &mut payload);
         payload.extend(&tag);
 
         send(
@@ -1424,7 +1396,7 @@ pub(crate) fn send_payload<App: ApplicationLayer>(
 pub(crate) fn received_payload_in_place<App: ApplicationLayer>(
     zeta: &mut Zeta<App>,
     kid: NonZeroU32,
-    n: [u8; AES_GCM_IV_SIZE],
+    n: [u8; AES_GCM_NONCE_SIZE],
     payload: &mut Vec<u8>,
 ) -> Result<(), ReceiveError<App::StorageError>> {
     use FaultType::*;
@@ -1450,7 +1422,7 @@ pub(crate) fn received_payload_in_place<App: ApplicationLayer>(
         .as_ref()
         .ok_or(byzantine_fault!(OutOfSequence, true))?;
     let tag = payload[i..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(specified_key, n, None, &mut payload[..i], tag) {
+    if !App::Aead::decrypt_in_place(specified_key, &n, None, &mut payload[..i], &tag) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let (_, c) = from_nonce(&n);

From 3176d7594824517b702ebd0f063edab3ba36e5c9 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 8 Aug 2023 09:45:40 -0400
Subject: [PATCH 27/37] replaced mutex with refcell

---
 examples/basic_test.rs |  6 +--
 src/context.rs         | 64 ++++++++++++++++----------------
 src/fragmentation.rs   | 10 ++---
 src/zeta.rs            | 84 +++++++++++++++++++-----------------------
 4 files changed, 77 insertions(+), 87 deletions(-)

diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index 4301add..40997e1 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -142,7 +142,7 @@ fn alice_main(
     bob_pubkey: PublicKey,
 ) {
     let startup_time = std::time::Instant::now();
-    let context = zssp_proto::Context::<&TestApplication>::new(alice_keypair, OsRng);
+    let mut context = zssp_proto::Context::<&TestApplication>::new(alice_keypair, OsRng);
     let mut next_service = startup_time.elapsed().as_millis() as i64 + 500;
     let test_data = [1u8; TEST_MTU * 10];
     let mut up = false;
@@ -245,7 +245,7 @@ fn bob_main(
     bob_keypair: EphemeralSecret,
 ) {
     let startup_time = std::time::Instant::now();
-    let context = zssp_proto::Context::<&TestApplication>::new(bob_keypair, OsRng);
+    let mut context = zssp_proto::Context::<&TestApplication>::new(bob_keypair, OsRng);
     let mut last_speed_metric = startup_time.elapsed().as_millis() as i64;
     let mut next_service = last_speed_metric + 500;
     let mut transferred = 0u64;
@@ -372,7 +372,7 @@ fn core(time: u64, packet_success_rate: u32) {
 fn main() {
     let args = std::env::args();
     let packet_success_rate = if args.len() <= 1 {
-        let default_success_rate = 1.0;
+        let default_success_rate = 0.5;
         ((u32::MAX as f64) * default_success_rate) as u32
     } else {
         ((u32::MAX as f64) * f64::from_str(args.last().unwrap().as_str()).unwrap()) as u32
diff --git a/src/context.rs b/src/context.rs
index 49c3829..fb9ff36 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -1,9 +1,10 @@
 use rand_core::RngCore;
+use std::cell::RefCell;
 use std::collections::hash_map::Entry;
 use std::collections::HashMap;
 use std::hash::Hash;
 use std::num::NonZeroU32;
-use std::sync::{Arc, Mutex, Weak};
+use std::sync::{Arc, Weak};
 
 use crate::application::ApplicationLayer;
 use crate::crypto::{AES_256_KEY_SIZE, AES_GCM_NONCE_SIZE};
@@ -37,17 +38,17 @@ impl<App: ApplicationLayer> Clone for Context<App> {
     }
 }
 
-pub(crate) type SessionMap<App> = Mutex<HashMap<NonZeroU32, Weak<Session<App>>>>;
+pub(crate) type SessionMap<App> = RefCell<HashMap<NonZeroU32, Weak<Session<App>>>>;
 
 pub(crate) struct ContextInner<App: ApplicationLayer> {
-    pub(crate) rng: Mutex<App::Rng>,
+    pub(crate) rng: RefCell<App::Rng>,
     pub(crate) s_secret: App::KeyPair,
     pub(crate) session_map: SessionMap<App>,
-    pub(crate) sessions: Mutex<HashMap<*const Session<App>, Weak<Session<App>>>>,
-    pub(crate) b2_map: Mutex<HashMap<NonZeroU32, StateB2<App>>>,
+    pub(crate) sessions: RefCell<HashMap<*const Session<App>, Weak<Session<App>>>>,
+    pub(crate) b2_map: RefCell<HashMap<NonZeroU32, StateB2<App>>>,
 
-    hello_defrag: Mutex<DefragBuffer>,
-    challenge: Mutex<ChallengeContext>,
+    hello_defrag: RefCell<DefragBuffer>,
+    challenge: RefCell<ChallengeContext>,
 }
 
 /// Corresponds to Figure 10 found in Section 4.3.
@@ -66,19 +67,19 @@ impl<App: ApplicationLayer> Context<App> {
     pub fn new(static_secret_key: App::KeyPair, mut rng: App::Rng) -> Self {
         let challenge = ChallengeContext::new(&mut rng);
         Self(Arc::new(ContextInner {
-            rng: Mutex::new(rng),
+            rng: RefCell::new(rng),
             s_secret: static_secret_key,
-            session_map: Mutex::new(HashMap::new()),
-            b2_map: Mutex::new(HashMap::new()),
-            hello_defrag: Mutex::new(DefragBuffer::new(None)),
-            challenge: Mutex::new(challenge),
-            sessions: Mutex::new(HashMap::new()),
+            session_map: RefCell::new(HashMap::new()),
+            b2_map: RefCell::new(HashMap::new()),
+            hello_defrag: RefCell::new(DefragBuffer::new(None)),
+            challenge: RefCell::new(challenge),
+            sessions: RefCell::new(HashMap::new()),
         }))
     }
     /// Enable the ZeroTier Challenge Protocol, to protect this machine from CPU exhaustion DDOS
     /// attacks.
-    pub fn enable_challenge(&self, enabled: bool) {
-        self.0.challenge.lock().unwrap().enabled = enabled;
+    pub fn enable_challenge(&mut self, enabled: bool) {
+        self.0.challenge.borrow_mut().enabled = enabled;
     }
 
     /// Create a new session and send initial packet(s) to other side.
@@ -93,7 +94,7 @@ impl<App: ApplicationLayer> Context<App> {
     /// * `identity` - Payload to be sent to Bob that contains the information necessary
     ///   for the upper protocol to authenticate and approve of Alice's identity
     pub fn open(
-        &self,
+        &mut self,
         app: App,
         send: impl FnMut(Vec<u8>) -> bool,
         mut mtu: usize,
@@ -130,7 +131,7 @@ impl<App: ApplicationLayer> Context<App> {
     /// * `remote_address` - Whatever the remote address is, as long as you can Hash it
     /// * `raw_fragment` - Buffer containing incoming wire packet
     pub fn receive<'a, SendFn: FnMut(Vec<u8>) -> bool>(
-        &self,
+        &mut self,
         app: App,
         send_unassociated_reply: impl FnMut(Vec<u8>) -> bool,
         mut send_unassociated_mtu: usize,
@@ -145,10 +146,10 @@ impl<App: ApplicationLayer> Context<App> {
         // Multiplex session.
         let kid_recv = u32::from_be_bytes(raw_fragment[..KID_SIZE].try_into().unwrap());
         if let Some(kid_recv) = NonZeroU32::new(kid_recv) {
-            let session = ctx.session_map.lock().unwrap().get(&kid_recv).map(|r| r.upgrade());
+            let session = ctx.session_map.borrow_mut().get(&kid_recv).map(|r| r.upgrade());
             if let Some(Some(session)) = session {
                 // Process recv fragmentation layer.
-                let mut zeta = session.0.lock().unwrap();
+                let mut zeta = session.0.borrow_mut();
                 let result =
                     zeta.defrag
                         .received_fragment::<App>(raw_fragment, app.time(), |n, frag_no, frag_count| {
@@ -293,7 +294,7 @@ impl<App: ApplicationLayer> Context<App> {
                     Ok(ReceiveOk::Unassociated)
                 }
             } else {
-                let mut b2_map = ctx.b2_map.lock().unwrap();
+                let mut b2_map = ctx.b2_map.borrow_mut();
                 if let Entry::Occupied(mut entry) = b2_map.entry(kid_recv) {
                     let zeta = entry.get_mut();
                     // Process recv fragmentation layer.
@@ -341,7 +342,7 @@ impl<App: ApplicationLayer> Context<App> {
             }
         } else {
             // Process recv fragmentation layer.
-            let result = ctx.hello_defrag.lock().unwrap().received_fragment::<App>(
+            let result = ctx.hello_defrag.borrow_mut().received_fragment::<App>(
                 raw_fragment,
                 app.time(),
                 |n, frag_no, frag_count| {
@@ -360,7 +361,7 @@ impl<App: ApplicationLayer> Context<App> {
                     log!(app, ReceivedRawX1);
                     // Process recv challenge layer.
                     let challenge_start = assembled_packet.len() - CHALLENGE_SIZE;
-                    let result = ctx.challenge.lock().unwrap().process_hello::<App::Hash>(
+                    let result = ctx.challenge.borrow_mut().process_hello::<App::Hash>(
                         remote_address,
                         (&assembled_packet[challenge_start..]).try_into().unwrap(),
                     );
@@ -369,7 +370,7 @@ impl<App: ApplicationLayer> Context<App> {
                         let mut challenge_packet = Vec::new();
                         challenge_packet.extend(&assembled_packet[..KID_SIZE]);
                         challenge_packet.extend(&challenge);
-                        let nonce = to_nonce(PACKET_TYPE_CHALLENGE, ctx.rng.lock().unwrap().next_u64());
+                        let nonce = to_nonce(PACKET_TYPE_CHALLENGE, ctx.rng.borrow_mut().next_u64());
                         send_with_fragmentation::<App>(
                             send_unassociated_reply,
                             send_unassociated_mtu,
@@ -413,9 +414,8 @@ impl<App: ApplicationLayer> Context<App> {
                     if let Some(kid_recv) =
                         NonZeroU32::new(u32::from_be_bytes(assembled_packet[..KID_SIZE].try_into().unwrap()))
                     {
-                        if let Some(Some(session)) = ctx.session_map.lock().unwrap().get(&kid_recv).map(|r| r.upgrade())
-                        {
-                            let mut zeta = session.0.lock().unwrap();
+                        if let Some(Some(session)) = ctx.session_map.borrow_mut().get(&kid_recv).map(|r| r.upgrade()) {
+                            let mut zeta = session.0.borrow_mut();
                             respond_to_challenge(
                                 &mut zeta,
                                 &ctx.rng,
@@ -443,14 +443,14 @@ impl<App: ApplicationLayer> Context<App> {
     /// * `mtu` - The MTU of the link, all packets passed to `send` will be at most `mtu` in length
     /// * `payload` - Data to send
     pub fn send(
-        &self,
+        &mut self,
         session: &Arc<Session<App>>,
         send: impl FnMut(Vec<u8>) -> bool,
         mut mtu: usize,
         payload: Vec<u8>,
     ) -> Result<(), SendError> {
         mtu = mtu.max(MIN_TRANSPORT_MTU);
-        let mut zeta = session.0.lock().unwrap();
+        let mut zeta = session.0.borrow_mut();
         send_payload(&mut zeta, payload, |Packet(kid, nonce, payload), hk| {
             send_with_fragmentation::<App>(send, mtu, *kid, to_packet_nonce(nonce), &payload, hk);
         })
@@ -464,17 +464,17 @@ impl<App: ApplicationLayer> Context<App> {
     ///
     /// * `send_to` - Function to get a sender and an MTU to send something over an active session
     pub fn service<SendFn: FnMut(Vec<u8>) -> bool>(
-        &self,
+        &mut self,
         app: App,
         mut send_to: impl FnMut(&Arc<Session<App>>) -> Option<(SendFn, usize)>,
     ) -> i64 {
         let ctx = &self.0;
-        let sessions = ctx.sessions.lock().unwrap();
+        let sessions = ctx.sessions.borrow_mut();
         let current_time = app.time();
         let mut next_timer = i64::MAX;
         for (_, session) in sessions.iter() {
             if let Some(session) = session.upgrade() {
-                let mut zeta = session.0.lock().unwrap();
+                let mut zeta = session.0.borrow_mut();
                 service(
                     &mut zeta,
                     &session,
@@ -499,7 +499,7 @@ impl<App: ApplicationLayer> Context<App> {
                 zeta.defrag.service::<App>(current_time);
             }
         }
-        ctx.hello_defrag.lock().unwrap().service::<App>(current_time);
+        ctx.hello_defrag.borrow_mut().service::<App>(current_time);
         (App::SETTINGS.resend_time as i64).min(next_timer - current_time)
     }
 }
diff --git a/src/fragmentation.rs b/src/fragmentation.rs
index 43c1cb6..55b425f 100644
--- a/src/fragmentation.rs
+++ b/src/fragmentation.rs
@@ -1,6 +1,6 @@
+use std::cell::RefCell;
 use std::collections::hash_map::Entry;
 use std::collections::HashMap;
-use std::sync::Mutex;
 
 use zeroize::Zeroizing;
 
@@ -66,7 +66,7 @@ pub fn send_with_fragmentation<App: ApplicationLayer>(
 }
 
 pub struct DefragBuffer {
-    fragment_map: Mutex<HashMap<[u8; PACKET_NONCE_SIZE], Buffer>>,
+    fragment_map: RefCell<HashMap<[u8; PACKET_NONCE_SIZE], Buffer>>,
     hk_recv: Option<Zeroizing<[u8; AES_256_KEY_SIZE]>>,
 }
 
@@ -79,7 +79,7 @@ struct Buffer {
 
 impl DefragBuffer {
     pub fn new(hk_recv: Option<Zeroizing<[u8; AES_256_KEY_SIZE]>>) -> Self {
-        Self { fragment_map: Mutex::new(HashMap::new()), hk_recv }
+        Self { fragment_map: RefCell::new(HashMap::new()), hk_recv }
     }
 
     /// Corresponds to the authentication and defragmentation algorithm described in Section 6.1.
@@ -116,7 +116,7 @@ impl DefragBuffer {
         }
 
         let expiration_time = current_time + App::SETTINGS.fragment_assembly_timeout as i64;
-        let mut map = self.fragment_map.lock().unwrap();
+        let mut map = self.fragment_map.borrow_mut();
         match map.entry(n) {
             Entry::Occupied(mut entry) => {
                 let buffer = entry.get_mut();
@@ -158,7 +158,7 @@ impl DefragBuffer {
     }
 
     pub fn service<App: ApplicationLayer>(&self, current_time: i64) {
-        let mut map = self.fragment_map.lock().unwrap();
+        let mut map = self.fragment_map.borrow_mut();
         map.retain(|_, buffer| buffer.expiration_time < current_time);
     }
 }
diff --git a/src/zeta.rs b/src/zeta.rs
index 1601b70..ca69176 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -1,8 +1,9 @@
 use rand_core::RngCore;
+use std::cell::RefCell;
 use std::collections::HashMap;
 use std::num::NonZeroU32;
 use std::ops::{Deref, DerefMut};
-use std::sync::{Arc, Mutex, Weak};
+use std::sync::{Arc, Weak};
 use zeroize::Zeroizing;
 
 use crate::application::ApplicationLayer;
@@ -69,7 +70,7 @@ pub(crate) struct Zeta<App: ApplicationLayer> {
 /// ZeroTier Secure Session Protocol (ZSSP) Session.
 ///
 /// A FIPS/NIST compliant variant of Noise_XK with hybrid Kyber1024 PQ data forward secrecy.
-pub struct Session<App: ApplicationLayer>(pub(crate) Mutex<Zeta<App>>);
+pub struct Session<App: ApplicationLayer>(pub(crate) RefCell<Zeta<App>>);
 
 /// Corresponds to State B_2 of the Zeta State Machine found in Section 4.1 - Definition 3.
 pub(crate) struct StateB2<App: ApplicationLayer> {
@@ -130,8 +131,8 @@ pub(crate) enum ZetaAutomata<App: ApplicationLayer> {
 }
 
 impl<App: ApplicationLayer> SymmetricState<App> {
-    fn write_e(&mut self, rng: &Mutex<App::Rng>, packet: &mut Vec<u8>) -> App::KeyPair {
-        let e_secret = App::KeyPair::generate(rng.lock().unwrap().deref_mut());
+    fn write_e(&mut self, rng: &RefCell<App::Rng>, packet: &mut Vec<u8>) -> App::KeyPair {
+        let e_secret = App::KeyPair::generate(rng.borrow_mut().deref_mut());
         let pub_key = e_secret.public_key_bytes();
         packet.extend(&pub_key);
         self.mix_hash(&pub_key);
@@ -196,8 +197,8 @@ impl<App: ApplicationLayer> Zeta<App> {
         self.timeout_timer = i64::MAX;
         self.beta = ZetaAutomata::Null;
         if let Some(ctx) = self.ctx.upgrade() {
-            let mut session_map = ctx.session_map.lock().unwrap();
-            let mut sessions = ctx.sessions.lock().unwrap();
+            let mut session_map = ctx.session_map.borrow_mut();
+            let mut sessions = ctx.sessions.borrow_mut();
             for key in &self.keys {
                 if let Some(kid_recv) = key.recv.kid {
                     if let Some(weak) = session_map.remove(&kid_recv) {
@@ -226,7 +227,7 @@ impl<App: ApplicationLayer> Zeta<App> {
 }
 
 fn create_a1_state<App: ApplicationLayer>(
-    rng: &Mutex<App::Rng>,
+    rng: &RefCell<App::Rng>,
     s_remote: &App::PublicKey,
     kid_recv: NonZeroU32,
     ratchet_state1: &RatchetState,
@@ -249,7 +250,7 @@ fn create_a1_state<App: ApplicationLayer>(
     noise.mix_dh(&e_secret, s_remote)?;
     // Process message pattern 1 e1 token.
     let i = x1.len();
-    let (e1_secret, e1_public) = App::Kem::generate(rng.lock().unwrap().deref_mut());
+    let (e1_secret, e1_public) = App::Kem::generate(rng.borrow_mut().deref_mut());
     x1.extend(&e1_public);
     noise.encrypt_and_hash_in_place(to_nonce(PACKET_TYPE_HANDSHAKE_HELLO, 0), i, &mut x1);
     // Process message pattern 1 payload.
@@ -264,7 +265,7 @@ fn create_a1_state<App: ApplicationLayer>(
 
     let c = u64::from_be_bytes(x1[x1.len() - 8..].try_into().unwrap());
 
-    x1.extend(&gen_null_response(rng.lock().unwrap().deref_mut()));
+    x1.extend(&gen_null_response(rng.borrow_mut().deref_mut()));
     Some(StateA1 {
         noise,
         e_secret,
@@ -287,8 +288,8 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
         .map_err(|e| OpenError::StorageError(e))?;
     let RatchetStates { state1, state2 } = ratchet_states.unwrap_or_default();
 
-    let mut session_map = ctx.session_map.lock().unwrap();
-    let kid_recv = gen_kid(session_map.deref(), ctx.rng.lock().unwrap().deref_mut());
+    let mut session_map = ctx.session_map.borrow_mut();
+    let kid_recv = gen_kid(session_map.deref(), ctx.rng.borrow_mut().deref_mut());
 
     let a1 = create_a1_state(&ctx.rng, &s_remote, kid_recv, &state1, state2.as_ref(), identity)
         .ok_or(OpenError::InvalidPublicKey)?;
@@ -317,11 +318,10 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
     };
     zeta.key_mut(true).recv.kid = Some(kid_recv);
 
-    let session = Arc::new(Session(Mutex::new(zeta)));
+    let session = Arc::new(Session(RefCell::new(zeta)));
     session_map.insert(kid_recv, Arc::downgrade(&session));
     ctx.sessions
-        .lock()
-        .unwrap()
+        .borrow_mut()
         .insert(Arc::as_ptr(&session), Arc::downgrade(&session));
 
     send(&packet);
@@ -331,13 +331,13 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
 /// Corresponds to Algorithm 13 found in Section 5.
 pub(crate) fn respond_to_challenge<App: ApplicationLayer>(
     zeta: &mut Zeta<App>,
-    rng: &Mutex<App::Rng>,
+    rng: &RefCell<App::Rng>,
     challenge: &[u8; CHALLENGE_SIZE],
 ) {
     if let ZetaAutomata::A1(StateA1 { packet: Packet(_, _, x1), .. }) = &mut zeta.beta {
         let response_start = x1.len() - CHALLENGE_SIZE;
         respond_to_challenge_in_place::<App::Rng, App::Hash>(
-            rng.lock().unwrap().deref_mut(),
+            rng.borrow_mut().deref_mut(),
             challenge,
             (&mut x1[response_start..]).try_into().unwrap(),
         );
@@ -428,7 +428,7 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     // Process message pattern 2 ekem1 token.
     let i = x2.len();
     let (ekem1, ekem1_secret) = App::Kem::encapsulate(
-        ctx.rng.lock().unwrap().deref_mut(),
+        ctx.rng.borrow_mut().deref_mut(),
         (&x1[e1_start..e1_end]).try_into().unwrap(),
     )
     .map(|(ct, secret)| (ct, Zeroizing::new(secret)))
@@ -440,8 +440,8 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     // Process message pattern 2 psk2 token.
     noise.mix_key_and_hash(ratchet_state.key.as_ref());
     // Process message pattern 2 payload.
-    let session_map = ctx.session_map.lock().unwrap();
-    let kid_recv = gen_kid(session_map.deref(), ctx.rng.lock().unwrap().deref_mut());
+    let session_map = ctx.session_map.borrow_mut();
+    let kid_recv = gen_kid(session_map.deref(), ctx.rng.borrow_mut().deref_mut());
 
     let i = x2.len();
     x2.extend(kid_recv.get().to_be_bytes());
@@ -454,7 +454,7 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     c[7] = x2[i - 1];
     let c = u64::from_be_bytes(c);
 
-    ctx.b2_map.lock().unwrap().insert(
+    ctx.b2_map.borrow_mut().insert(
         kid_recv,
         StateB2 {
             ratchet_state,
@@ -643,7 +643,7 @@ fn send_control<App: ApplicationLayer>(
     if let Some((c, _)) = zeta.get_counter() {
         if let (Some(kek), Some(kid)) = (zeta.key_ref(false).send.kek.as_ref(), zeta.key_ref(false).send.kid) {
             let nonce = to_nonce(packet_type, c);
-            let tag = App::Aead::encrypt_in_place(kek, &nonce, None, &mut payload[HEADER_SIZE..]);
+            let tag = App::Aead::encrypt_in_place(kek, &nonce, None, &mut payload);
             payload.extend(tag);
 
             send(&Packet(kid.get(), nonce, payload), Some(&zeta.hk_send));
@@ -762,7 +762,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                 };
                 let current_time = app.time();
 
-                let mut session_map = ctx.session_map.lock().unwrap();
+                let mut session_map = ctx.session_map.borrow_mut();
                 use std::collections::hash_map::Entry::*;
                 let entry = match session_map.entry(zeta.kid_recv) {
                     // We could have issued the kid that we initially offered Alice to someone else
@@ -770,7 +770,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                     Occupied(_) => return Err(byzantine_fault!(OutOfSequence, false)),
                     Vacant(entry) => entry,
                 };
-                let session = Arc::new(Session(Mutex::new(Zeta {
+                let session = Arc::new(Session(RefCell::new(Zeta {
                     ctx: Arc::downgrade(ctx),
                     session_data,
                     was_bob: true,
@@ -790,8 +790,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                 })));
                 entry.insert(Arc::downgrade(&session));
                 ctx.sessions
-                    .lock()
-                    .unwrap()
+                    .borrow_mut()
                     .insert(Arc::as_ptr(&session), Arc::downgrade(&session));
 
                 send(&Packet(zeta.kid_send.get(), n, c1), Some(&zeta.hk_send));
@@ -810,7 +809,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
 pub(crate) fn received_c1_trans<App: ApplicationLayer>(
     zeta: &mut Zeta<App>,
     app: &App,
-    rng: &Mutex<App::Rng>,
+    rng: &RefCell<App::Rng>,
     kid: NonZeroU32,
     n: [u8; AES_GCM_NONCE_SIZE],
     c1: Vec<u8>,
@@ -868,11 +867,8 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
 
             zeta.ratchet_state2 = None;
             zeta.key_index ^= true;
-            zeta.timeout_timer = app.time()
-                + App::SETTINGS
-                    .rekey_after_time
-                    .saturating_sub(rng.lock().unwrap().next_u64() % App::SETTINGS.rekey_time_max_jitter)
-                    as i64;
+            let r = rng.borrow_mut().next_u64() % App::SETTINGS.rekey_time_max_jitter;
+            zeta.timeout_timer = app.time() + App::SETTINGS.rekey_after_time.saturating_sub(r) as i64;
             zeta.resend_timer = i64::MAX;
             zeta.beta = ZetaAutomata::S2;
         }
@@ -889,7 +885,7 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
 pub(crate) fn received_c2_trans<App: ApplicationLayer>(
     zeta: &mut Zeta<App>,
     app: &App,
-    rng: &Mutex<App::Rng>,
+    rng: &RefCell<App::Rng>,
     kid: NonZeroU32,
     n: [u8; AES_GCM_NONCE_SIZE],
     c2: Vec<u8>,
@@ -917,10 +913,8 @@ pub(crate) fn received_c2_trans<App: ApplicationLayer>(
         return Err(byzantine_fault!(ExpiredCounter, true));
     }
 
-    zeta.timeout_timer = app.time()
-        + App::SETTINGS
-            .rekey_after_time
-            .saturating_sub(rng.lock().unwrap().next_u64() % App::SETTINGS.rekey_time_max_jitter) as i64;
+    let r = rng.borrow_mut().next_u64() % App::SETTINGS.rekey_time_max_jitter;
+    zeta.timeout_timer = app.time() + App::SETTINGS.rekey_after_time.saturating_sub(r) as i64;
     zeta.resend_timer = i64::MAX;
     zeta.beta = ZetaAutomata::S2;
     Ok(())
@@ -1000,16 +994,16 @@ pub(crate) fn service<App: ApplicationLayer>(
 fn remap<App: ApplicationLayer>(
     session: &Arc<Session<App>>,
     zeta: &Zeta<App>,
-    rng: &Mutex<App::Rng>,
+    rng: &RefCell<App::Rng>,
     session_map: &SessionMap<App>,
 ) -> NonZeroU32 {
-    let mut session_map = session_map.lock().unwrap();
+    let mut session_map = session_map.borrow_mut();
     let weak = if let Some(Some(weak)) = zeta.key_ref(true).recv.kid.as_ref().map(|kid| session_map.remove(kid)) {
         weak
     } else {
         Arc::downgrade(&session)
     };
-    let new_kid_recv = gen_kid(session_map.deref(), rng.lock().unwrap().deref_mut());
+    let new_kid_recv = gen_kid(session_map.deref(), rng.borrow_mut().deref_mut());
     session_map.insert(new_kid_recv, weak);
     new_kid_recv
 }
@@ -1114,7 +1108,7 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
     zeta: &mut Zeta<App>,
     session: &Arc<Session<App>>,
     app: &App,
-    rng: &Mutex<App::Rng>,
+    rng: &RefCell<App::Rng>,
     session_map: &SessionMap<App>,
     s_secret: &App::KeyPair,
     kid: NonZeroU32,
@@ -1415,12 +1409,8 @@ pub(crate) fn received_payload_in_place<App: ApplicationLayer>(
     };
 
     let i = payload.len() - AES_GCM_TAG_SIZE;
-    let specified_key = zeta
-        .key_ref(is_other)
-        .recv
-        .nk
-        .as_ref()
-        .ok_or(byzantine_fault!(OutOfSequence, true))?;
+    let specified_key = zeta.key_ref(is_other).recv.nk.as_ref();
+    let specified_key = specified_key.ok_or(byzantine_fault!(OutOfSequence, true))?;
     let tag = payload[i..].try_into().unwrap();
     if !App::Aead::decrypt_in_place(specified_key, &n, None, &mut payload[..i], &tag) {
         return Err(byzantine_fault!(FailedAuth, true));
@@ -1441,7 +1431,7 @@ impl<App: ApplicationLayer> Session<App> {
     /// receive or send data or control packets. It is recommended to simply `drop` the session
     /// instead, but this can provide some reassurance in complex shared ownership situations.
     pub fn expire(&mut self) {
-        self.0.lock().unwrap().expire();
+        self.0.borrow_mut().expire();
     }
 }
 

From f21498a047527340d205ce1e93fc8da8ad16adf7 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 8 Aug 2023 09:49:16 -0400
Subject: [PATCH 28/37] fixed imports

---
 examples/basic_test.rs | 2 +-
 src/context.rs         | 4 ++--
 src/crypto/mod.rs      | 1 +
 src/proto.rs           | 4 +---
 src/ratchet_state.rs   | 2 +-
 src/symmetric_state.rs | 4 ++--
 src/zeta.rs            | 7 +++----
 7 files changed, 11 insertions(+), 13 deletions(-)

diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index 40997e1..3a52a65 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -372,7 +372,7 @@ fn core(time: u64, packet_success_rate: u32) {
 fn main() {
     let args = std::env::args();
     let packet_success_rate = if args.len() <= 1 {
-        let default_success_rate = 0.5;
+        let default_success_rate = 1.0;
         ((u32::MAX as f64) * default_success_rate) as u32
     } else {
         ((u32::MAX as f64) * f64::from_str(args.last().unwrap().as_str()).unwrap()) as u32
diff --git a/src/context.rs b/src/context.rs
index fb9ff36..b9b3953 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -7,14 +7,14 @@ use std::num::NonZeroU32;
 use std::sync::{Arc, Weak};
 
 use crate::application::ApplicationLayer;
+use crate::challenge::ChallengeContext;
 use crate::crypto::{AES_256_KEY_SIZE, AES_GCM_NONCE_SIZE};
 use crate::fragmentation::{send_with_fragmentation, DefragBuffer};
 use crate::proto::*;
-use crate::result::{byzantine_fault, ReceiveError, ReceiveOk, SendError, SessionEvent};
+use crate::result::{byzantine_fault, OpenError, ReceiveError, ReceiveOk, SendError, SessionEvent};
 use crate::zeta::*;
 #[cfg(feature = "logging")]
 use crate::LogEvent::*;
-use crate::{challenge::ChallengeContext, result::OpenError};
 
 /// Macro to turn off logging at compile time.
 macro_rules! log {
diff --git a/src/crypto/mod.rs b/src/crypto/mod.rs
index 00ca2aa..16279f0 100644
--- a/src/crypto/mod.rs
+++ b/src/crypto/mod.rs
@@ -13,6 +13,7 @@ pub use kyber1024::*;
 // We re-export our dependencies so it is less of a headache for the implementor to use the same
 // exact version of them.
 pub use rand_core;
+pub use zeroize;
 
 /// Constant time byte slice equality.
 pub fn secure_eq<A: AsRef<[u8]> + ?Sized, B: AsRef<[u8]> + ?Sized>(a: &A, b: &B) -> bool {
diff --git a/src/proto.rs b/src/proto.rs
index cd0b520..a31a402 100644
--- a/src/proto.rs
+++ b/src/proto.rs
@@ -1,6 +1,4 @@
-use crate::crypto::{
-    AES_GCM_TAG_SIZE, KYBER_CIPHERTEXT_SIZE, KYBER_PUBLIC_KEY_SIZE, P384_PUBLIC_KEY_SIZE, SHA512_HASH_SIZE,
-};
+use crate::crypto::*;
 
 /* Common constants */
 
diff --git a/src/ratchet_state.rs b/src/ratchet_state.rs
index 75de1ee..7538aa7 100644
--- a/src/ratchet_state.rs
+++ b/src/ratchet_state.rs
@@ -1,6 +1,6 @@
 use zeroize::Zeroizing;
 
-use crate::crypto::{secure_eq, Sha512Hash};
+use crate::crypto::*;
 use crate::proto::*;
 /// A ratchet key and fingerprint,
 /// along with the length of the ratchet chain the keys were derived from.
diff --git a/src/symmetric_state.rs b/src/symmetric_state.rs
index deaab6e..5388e8a 100644
--- a/src/symmetric_state.rs
+++ b/src/symmetric_state.rs
@@ -3,8 +3,8 @@ use std::marker::PhantomData;
 use zeroize::Zeroizing;
 
 use crate::application::ApplicationLayer;
-use crate::crypto::{AesGcmAead, Sha512Hash, AES_256_KEY_SIZE, AES_GCM_NONCE_SIZE, AES_GCM_TAG_SIZE};
-use crate::proto::{HASHLEN, LABEL_KBKDF_CHAIN};
+use crate::crypto::*;
+use crate::proto::*;
 
 pub struct SymmetricState<App: ApplicationLayer> {
     k: Zeroizing<[u8; AES_256_KEY_SIZE]>,
diff --git a/src/zeta.rs b/src/zeta.rs
index ca69176..2c71257 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -1,19 +1,18 @@
-use rand_core::RngCore;
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::num::NonZeroU32;
 use std::ops::{Deref, DerefMut};
 use std::sync::{Arc, Weak};
+
+use rand_core::RngCore;
 use zeroize::Zeroizing;
 
-use crate::application::ApplicationLayer;
-use crate::application::RatchetUpdate;
+use crate::application::{ApplicationLayer, RatchetState, RatchetStates, RatchetUpdate};
 use crate::challenge::{gen_null_response, respond_to_challenge_in_place};
 use crate::context::{log, ContextInner, SessionMap};
 use crate::crypto::*;
 use crate::fragmentation::DefragBuffer;
 use crate::proto::*;
-use crate::ratchet_state::{RatchetState, RatchetStates};
 use crate::result::{byzantine_fault, FaultType, OpenError, ReceiveError, SendError};
 use crate::symmetric_state::SymmetricState;
 #[cfg(feature = "logging")]

From 3e6a341491597eb8d277f7a23bb143ac3772710a Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 8 Aug 2023 11:03:00 -0400
Subject: [PATCH 29/37] improved dependencies

---
 examples/basic_test.rs       | 31 +++++++++++++++----------------
 src/application.rs           |  2 +-
 src/crypto_impl/aes_impl.rs  |  8 ++++++--
 src/crypto_impl/kyber1024.rs |  5 ++---
 src/crypto_impl/mod.rs       | 10 ++++++++--
 src/crypto_impl/p384_impl.rs |  8 ++++++--
 src/crypto_impl/sha512.rs    |  4 +++-
 7 files changed, 41 insertions(+), 27 deletions(-)

diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index 3a52a65..623ee3c 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -14,17 +14,16 @@ use std::sync::{mpsc, Arc, Mutex};
 use std::thread;
 use std::time::{Duration, Instant};
 
-use aes::Aes256;
-use aes_gcm::Aes256Gcm;
-use p384::{ecdh::EphemeralSecret, PublicKey};
 use rand_core::OsRng;
 use rand_core::RngCore;
-use sha2::Sha512;
 
 use zssp_proto::application::{
     AcceptAction, ApplicationLayer, RatchetState, RatchetStates, RatchetUpdate, Settings, RATCHET_SIZE,
 };
-use zssp_proto::crypto_impl::PqcKyberSecretKey;
+use zssp_proto::crypto::P384KeyPair;
+use zssp_proto::crypto_impl::{
+    Aes256Crate, AesGcmCrate, RustKyber1024PrivateKey, P384CrateKeyPair, P384CratePublicKey, Sha512Crate,
+};
 use zssp_proto::Session;
 
 const TEST_MTU: usize = 1500;
@@ -57,12 +56,12 @@ impl ApplicationLayer for &TestApplication {
         fragment_assembly_timeout: Settings::FRAGMENT_ASSEMBLY_TIMEOUT_MS,
     };
     type Rng = OsRng;
-    type Prp = Aes256;
-    type Aead = Aes256Gcm;
-    type Hash = Sha512;
-    type PublicKey = PublicKey;
-    type KeyPair = EphemeralSecret;
-    type Kem = PqcKyberSecretKey;
+    type Prp = Aes256Crate;
+    type Aead = AesGcmCrate;
+    type Hash = Sha512Crate;
+    type PublicKey = P384CratePublicKey;
+    type KeyPair = P384CrateKeyPair;
+    type Kem = RustKyber1024PrivateKey;
 
     type StorageError = std::convert::Infallible;
     type SessionData = u128;
@@ -138,8 +137,8 @@ fn alice_main(
     alice_out: mpsc::SyncSender<Vec<u8>>,
     alice_in: mpsc::Receiver<Vec<u8>>,
     recursive_out: mpsc::SyncSender<Vec<u8>>,
-    alice_keypair: EphemeralSecret,
-    bob_pubkey: PublicKey,
+    alice_keypair: P384CrateKeyPair,
+    bob_pubkey: P384CratePublicKey,
 ) {
     let startup_time = std::time::Instant::now();
     let mut context = zssp_proto::Context::<&TestApplication>::new(alice_keypair, OsRng);
@@ -242,7 +241,7 @@ fn bob_main(
     bob_out: mpsc::SyncSender<Vec<u8>>,
     bob_in: mpsc::Receiver<Vec<u8>>,
     recursive_out: mpsc::SyncSender<Vec<u8>>,
-    bob_keypair: EphemeralSecret,
+    bob_keypair: P384CrateKeyPair,
 ) {
     let startup_time = std::time::Instant::now();
     let mut context = zssp_proto::Context::<&TestApplication>::new(bob_keypair, OsRng);
@@ -316,13 +315,13 @@ fn bob_main(
 fn core(time: u64, packet_success_rate: u32) {
     let run = &AtomicBool::new(true);
 
-    let alice_keypair = EphemeralSecret::random(&mut OsRng);
+    let alice_keypair = P384CrateKeyPair::generate(&mut OsRng);
     let alice_app = TestApplication {
         time: Instant::now(),
         name: "alice",
         ratchets: Mutex::new(Ratchets::new()),
     };
-    let bob_keypair = EphemeralSecret::random(&mut OsRng);
+    let bob_keypair = P384CrateKeyPair::generate(&mut OsRng);
     let bob_pubkey = bob_keypair.public_key();
     let bob_app = TestApplication {
         time: Instant::now(),
diff --git a/src/application.rs b/src/application.rs
index 5e97ba0..7a50314 100644
--- a/src/application.rs
+++ b/src/application.rs
@@ -109,7 +109,7 @@ pub trait ApplicationLayer: Sized {
     ///
     /// FIPS compliance requires a FIPS certified implementation.
     type Aead: AesGcmAead;
-    /// The implementation of SHA-512 that ZSSP should use.
+    /// The implementation of SHA-512 and HMAC-SHA-512 that ZSSP should use.
     /// We provide an optional implementation for this trait using the `sha2` crate.
     ///
     /// FIPS compliance requires use of a FIPS certified implementation.
diff --git a/src/crypto_impl/aes_impl.rs b/src/crypto_impl/aes_impl.rs
index 037430a..5160ef4 100644
--- a/src/crypto_impl/aes_impl.rs
+++ b/src/crypto_impl/aes_impl.rs
@@ -5,7 +5,9 @@ use aes_gcm::{Aes256Gcm, Key, Nonce, Tag};
 
 use crate::crypto::*;
 
-impl Aes256Prp for Aes256 {
+/// The version and type of the aes crate that the `Aes256Prp` trait is implemented for.
+pub type Aes256Crate = Aes256;
+impl Aes256Prp for Aes256Crate {
     fn encrypt_in_place(key: &[u8; AES_256_KEY_SIZE], block: &mut [u8; AES_256_BLOCK_SIZE]) {
         let cipher = Aes256::new(GenericArray::from_slice(key));
         cipher.encrypt_block(GenericArray::from_mut_slice(block));
@@ -17,7 +19,9 @@ impl Aes256Prp for Aes256 {
     }
 }
 
-impl AesGcmAead for Aes256Gcm {
+/// The version and type of the aes-gcm crate that the `Aes256Gcm` trait is implemented for.
+pub type AesGcmCrate = Aes256Gcm;
+impl AesGcmAead for AesGcmCrate {
     fn encrypt_in_place(
         key: &[u8; AES_256_KEY_SIZE],
         iv: &[u8; AES_GCM_NONCE_SIZE],
diff --git a/src/crypto_impl/kyber1024.rs b/src/crypto_impl/kyber1024.rs
index f5a518b..57cd5e7 100644
--- a/src/crypto_impl/kyber1024.rs
+++ b/src/crypto_impl/kyber1024.rs
@@ -5,9 +5,8 @@ use crate::crypto::*;
 
 /// A wrapper for a buffer the size of a pqc_kyber secret key.
 /// The crate `pqc_kyber` is low level and operates directly on buffers of bytes.
-pub type PqcKyberSecretKey = Zeroizing<[u8; pqc_kyber::KYBER_SECRETKEYBYTES]>;
-
-impl<Rng: RngCore + CryptoRng> Kyber1024PrivateKey<Rng> for PqcKyberSecretKey {
+pub type RustKyber1024PrivateKey = Zeroizing<[u8; pqc_kyber::KYBER_SECRETKEYBYTES]>;
+impl<Rng: RngCore + CryptoRng> Kyber1024PrivateKey<Rng> for RustKyber1024PrivateKey {
     fn generate(rng: &mut Rng) -> (Self, [u8; KYBER_PUBLIC_KEY_SIZE]) {
         let keypair = pqc_kyber::keypair(rng);
         (Zeroizing::new(keypair.secret), keypair.public)
diff --git a/src/crypto_impl/mod.rs b/src/crypto_impl/mod.rs
index a08b8ef..ccbe469 100644
--- a/src/crypto_impl/mod.rs
+++ b/src/crypto_impl/mod.rs
@@ -1,11 +1,19 @@
 #[cfg(feature = "aes-gcm")]
 mod aes_impl;
+#[cfg(feature = "aes-gcm")]
+pub use aes_impl::*;
 #[cfg(feature = "pqc_kyber")]
 mod kyber1024;
+#[cfg(feature = "pqc_kyber")]
+pub use kyber1024::*;
 #[cfg(feature = "p384")]
 mod p384_impl;
+#[cfg(feature = "p384")]
+pub use p384_impl::*;
 #[cfg(feature = "sha2")]
 mod sha512;
+#[cfg(feature = "sha2")]
+pub use sha512::*;
 
 #[cfg(feature = "aes")]
 pub use aes;
@@ -13,8 +21,6 @@ pub use aes;
 pub use aes_gcm;
 #[cfg(feature = "hmac")]
 pub use hmac;
-#[cfg(feature = "pqc_kyber")]
-pub use kyber1024::PqcKyberSecretKey;
 #[cfg(feature = "p384")]
 pub use p384;
 #[cfg(feature = "pqc_kyber")]
diff --git a/src/crypto_impl/p384_impl.rs b/src/crypto_impl/p384_impl.rs
index 2898bc6..66cd470 100644
--- a/src/crypto_impl/p384_impl.rs
+++ b/src/crypto_impl/p384_impl.rs
@@ -3,7 +3,9 @@ use rand_core::{CryptoRng, RngCore};
 
 use crate::crypto::*;
 
-impl P384PublicKey for PublicKey {
+/// The version and type of the p384 crate that the `P384PublicKey` trait is implemented for.
+pub type P384CratePublicKey = PublicKey;
+impl P384PublicKey for P384CratePublicKey {
     fn from_bytes(raw_key: &[u8; P384_PUBLIC_KEY_SIZE]) -> Option<Self> {
         PublicKey::from_sec1_bytes(raw_key).ok()
     }
@@ -14,7 +16,9 @@ impl P384PublicKey for PublicKey {
     }
 }
 
-impl<Rng: RngCore + CryptoRng> P384KeyPair<Rng> for EphemeralSecret {
+/// The version and type of the p384 crate that the `P384KeyPair` trait is implemented for.
+pub type P384CrateKeyPair = EphemeralSecret;
+impl<Rng: RngCore + CryptoRng> P384KeyPair<Rng> for P384CrateKeyPair {
     type PublicKey = PublicKey;
 
     fn generate(rng: &mut Rng) -> Self {
diff --git a/src/crypto_impl/sha512.rs b/src/crypto_impl/sha512.rs
index 87c66d5..1d2996c 100644
--- a/src/crypto_impl/sha512.rs
+++ b/src/crypto_impl/sha512.rs
@@ -3,7 +3,9 @@ use sha2::{Digest, Sha512};
 
 use crate::crypto::*;
 
-impl Sha512Hash for Sha512 {
+/// The version and type of the sha2 crate that the `Sha512Hash` trait is implemented for.
+pub type Sha512Crate = Sha512;
+impl Sha512Hash for Sha512Crate {
     fn new() -> Self {
         Digest::new()
     }

From 7b45033cd5287ec235456e6afaf4bed3ff470cb4 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 8 Aug 2023 13:00:04 -0400
Subject: [PATCH 30/37] fixed size bug

---
 src/proto.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/proto.rs b/src/proto.rs
index a31a402..6a08419 100644
--- a/src/proto.rs
+++ b/src/proto.rs
@@ -115,7 +115,7 @@ pub(crate) const PACKET_TYPE_USES_COUNTER_RANGE: std::ops::Range<u8> = 3..9;
 
 pub(crate) const HANDSHAKE_HELLO_MIN_SIZE: usize =
     KID_SIZE + P384_PUBLIC_KEY_SIZE + KYBER_PUBLIC_KEY_SIZE + AES_GCM_TAG_SIZE + AES_GCM_TAG_SIZE;
-pub(crate) const HANDSHAKE_HELLO_MAX_SIZE: usize = HANDSHAKE_HELLO_MIN_SIZE + RATCHET_SIZE;
+pub(crate) const HANDSHAKE_HELLO_MAX_SIZE: usize = HANDSHAKE_HELLO_MIN_SIZE + RATCHET_SIZE + RATCHET_SIZE;
 
 pub(crate) const HANDSHAKE_RESPONSE_SIZE: usize =
     P384_PUBLIC_KEY_SIZE + KYBER_CIPHERTEXT_SIZE + AES_GCM_TAG_SIZE + KID_SIZE + AES_GCM_TAG_SIZE;

From c500fee8d5a82197ac26e3ead63ef733f03ad6be Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 8 Aug 2023 16:34:37 -0400
Subject: [PATCH 31/37] added warning enum

---
 examples/basic_test.rs |  8 +++-----
 src/context.rs         | 16 ++++++++++++----
 src/result.rs          | 16 ++++++++++++++++
 src/zeta.rs            | 14 +++++++++-----
 4 files changed, 40 insertions(+), 14 deletions(-)

diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index 623ee3c..ad81be8 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -191,9 +191,8 @@ fn alice_main(
                                 assert!(!data.is_empty());
                                 //println!("[alice] received {}", data.len());
                             }
-                            NewSession => panic!(),
-                            Rejected => panic!(),
                             Control => (),
+                            _ => panic!(),
                         },
                         Err(e) => {
                             println!("[alice] ERROR {:?}", e);
@@ -270,7 +269,7 @@ fn bob_main(
                 ) {
                     Ok(Unassociated) => {}
                     Ok(Session(s, event)) => match event {
-                        NewSession => {
+                        NewSession | NewDowngradedSession => {
                             println!("[bob] new session, took {}s", current_time as f32 / 1000.0);
                             let _ = bob_session.replace(s);
                         }
@@ -280,9 +279,8 @@ fn bob_main(
                             transferred += data.len() as u64 * 2; // *2 because we are also sending this many bytes back
                             context.send(&s, |b| bob_out.send(b).is_ok(), TEST_MTU, data).unwrap();
                         }
-                        Established => panic!(),
-                        Rejected => panic!(),
                         Control => (),
+                        _ => panic!(),
                     },
                     Err(e) => {
                         println!("[bob] ERROR {:?}", e);
diff --git a/src/context.rs b/src/context.rs
index b9b3953..5e01784 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -206,7 +206,7 @@ impl<App: ApplicationLayer> Context<App> {
                         }
                         PACKET_TYPE_HANDSHAKE_RESPONSE => {
                             log!(app, ReceivedRawX2);
-                            received_x2_trans(
+                            let should_warn_missing_ratchet = received_x2_trans(
                                 &mut zeta,
                                 &session,
                                 &app,
@@ -217,7 +217,11 @@ impl<App: ApplicationLayer> Context<App> {
                                 send_associated,
                             )?;
                             log!(app, X2IsAuthSentX3(&session));
-                            SessionEvent::Control
+                            if should_warn_missing_ratchet {
+                                SessionEvent::DowngradedRatchetKey
+                            } else {
+                                SessionEvent::Control
+                            }
                         }
                         PACKET_TYPE_KEY_CONFIRM => {
                             log!(app, ReceivedRawKeyConfirm);
@@ -312,7 +316,7 @@ impl<App: ApplicationLayer> Context<App> {
                     if let Some((_, assembled_packet)) = result {
                         log!(app, ReceivedRawX3);
                         let zeta = entry.remove();
-                        let session = received_x3_trans(
+                        let (session, should_warn_missing_ratchet) = received_x3_trans(
                             zeta,
                             &app,
                             ctx,
@@ -330,7 +334,11 @@ impl<App: ApplicationLayer> Context<App> {
                             },
                         )?;
                         log!(app, X3IsAuthSentKeyConfirm(&session));
-                        Ok(ReceiveOk::Session(session, SessionEvent::NewSession))
+                        Ok(ReceiveOk::Session(session, if should_warn_missing_ratchet {
+                            SessionEvent::NewDowngradedSession
+                        } else {
+                            SessionEvent::NewSession
+                        }))
                     } else {
                         Ok(ReceiveOk::Unassociated)
                     }
diff --git a/src/result.rs b/src/result.rs
index ec194cb..68f7884 100644
--- a/src/result.rs
+++ b/src/result.rs
@@ -142,6 +142,16 @@ pub enum SessionEvent {
     /// If the session Arc returned is dropped, the session with this peer will be immediately
     /// terminated. Save the session Arc to some long lived datastructure to keep it alive.
     NewSession,
+    /// The received packet was valid, and it contained the necessary keys to fully establish a new
+    /// session with Alice, the handshake initiator.
+    ///
+    /// However we had to downgrade our ratchet chain with this peer to a known state,
+    /// meaning either Alice corrupted their ratchet key storage, or someone is impersonating Alice.
+    /// The application should attempt to warn the user of this fact.
+    ///
+    /// If the session Arc returned is dropped, the session with this peer will be immediately
+    /// terminated. Save the session Arc to some long lived datastructure to keep it alive.
+    NewDowngradedSession,
     /// When Alice calls `Context::open`, a session will be created, but Bob will not yet have
     /// received this session. They will have to successfully complete a handshake first.
     ///
@@ -162,4 +172,10 @@ pub enum SessionEvent {
     Data(Vec<u8>),
     /// The received packet was some authentic protocol control packet. No action needs to be taken.
     Control,
+    /// In the process of establishing a session with Bob, the responder,
+    /// we had to downgrade our ratchet chain with this peer to a known state.
+    /// This means either Bob corrupted their ratchet key storage, or someone is impersonating Alice.
+    /// The application should attempt to warn the user of this fact.
+    DowngradedRatchetKey,
+
 }
diff --git a/src/zeta.rs b/src/zeta.rs
index 2c71257..19d3d96 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -482,7 +482,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
     n: [u8; AES_GCM_NONCE_SIZE],
     mut x2: Vec<u8>,
     send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
-) -> Result<(), ReceiveError<App::StorageError>> {
+) -> Result<bool, ReceiveError<App::StorageError>> {
     use FaultType::*;
     //    <- e, ee, ekem1, psk
     //    -> s, se
@@ -496,6 +496,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
     if c >= COUNTER_WINDOW_MAX_SKIP_AHEAD || &n[AES_GCM_NONCE_SIZE - 3..] != &x2[x2.len() - 3..] {
         return Err(byzantine_fault!(FailedAuth, true));
     }
+    let mut should_warn_missing_ratchet = false;
     let result = (|| {
         if let ZetaAutomata::A1(StateA1 { noise, e_secret, e1_secret, identity, .. }) = &zeta.beta {
             let mut noise = noise.clone();
@@ -560,6 +561,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
                 result = test_ratchet_key(&[0u8; RATCHET_SIZE]);
                 if result.is_some() {
                     // TODO: add some kind of warning callback or signal.
+                    should_warn_missing_ratchet = true;
                 }
             }
 
@@ -631,7 +633,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
         Ok(packet) => send(packet, Some(&zeta.hk_send)),
         _ => {}
     }
-    result.map(|_| ())
+    result.map(|_| should_warn_missing_ratchet)
 }
 fn send_control<App: ApplicationLayer>(
     zeta: &mut Zeta<App>,
@@ -662,7 +664,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
     kid: NonZeroU32,
     mut x3: Vec<u8>,
     send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
-) -> Result<Arc<Session<App>>, ReceiveError<App::StorageError>> {
+) -> Result<(Arc<Session<App>>, bool), ReceiveError<App::StorageError>> {
     use FaultType::*;
     //    -> s, se
     if !(HANDSHAKE_COMPLETION_MIN_SIZE..=HANDSHAKE_COMPLETION_MAX_SIZE).contains(&x3.len()) {
@@ -720,9 +722,11 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
         match result {
             Ok(rss) => {
                 let RatchetStates { state1, state2 } = rss.unwrap_or_default();
+                let mut should_warn_missing_ratchet = false;
+
                 if (&zeta.ratchet_state != &state1) & (Some(&zeta.ratchet_state) != state2.as_ref()) {
                     if !responder_disallows_downgrade && zeta.ratchet_state.fingerprint().is_none() {
-                        // TODO: add some kind of warning callback or signal.
+                        should_warn_missing_ratchet = true;
                     } else {
                         if !responder_silently_rejects {
                             send(&create_reject(), Some(&zeta.hk_send))
@@ -793,7 +797,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                     .insert(Arc::as_ptr(&session), Arc::downgrade(&session));
 
                 send(&Packet(zeta.kid_send.get(), n, c1), Some(&zeta.hk_send));
-                Ok(session)
+                Ok((session, should_warn_missing_ratchet))
             }
             Err(e) => Err(ReceiveError::StorageError(e)),
         }

From c964b0e1f59a4d9e53a04b9e678294c3fcc9a32d Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 8 Aug 2023 16:44:05 -0400
Subject: [PATCH 32/37] removed old comment

---
 src/zeta.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/zeta.rs b/src/zeta.rs
index 19d3d96..cc4f10b 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -560,7 +560,6 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
                 chain_len = 0;
                 result = test_ratchet_key(&[0u8; RATCHET_SIZE]);
                 if result.is_some() {
-                    // TODO: add some kind of warning callback or signal.
                     should_warn_missing_ratchet = true;
                 }
             }

From 8aad3746ed2fad37ca82c6a50c6d4c2859eb1466 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 8 Aug 2023 17:40:59 -0400
Subject: [PATCH 33/37] added docs

---
 examples/basic_test.rs |  2 +-
 src/ratchet_state.rs   | 76 +++++++++++++++++++++++++++++++++++++++---
 src/zeta.rs            | 20 +++++------
 3 files changed, 83 insertions(+), 15 deletions(-)

diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index ad81be8..7513eef 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -110,7 +110,7 @@ impl ApplicationLayer for &TestApplication {
 
         if let Some(rf) = update_data.added_fingerprint() {
             ratchets.rf_map.insert(*rf, update_data.state1.clone());
-            println!("[{}] new ratchet #{}", self.name, update_data.state1.chain_len);
+            println!("[{}] new ratchet #{}", self.name, update_data.state1.chain_len());
         }
         if let Some(rf) = update_data.deleted_fingerprint1() {
             ratchets.rf_map.remove(rf);
diff --git a/src/ratchet_state.rs b/src/ratchet_state.rs
index 7538aa7..b6bf51b 100644
--- a/src/ratchet_state.rs
+++ b/src/ratchet_state.rs
@@ -12,9 +12,9 @@ use crate::proto::*;
 /// Corresponds to the Ratchet Key and Ratchet Fingerprint described in Section 3.
 #[derive(Clone, Eq)]
 pub struct RatchetState {
-    pub key: Zeroizing<[u8; RATCHET_SIZE]>,
-    pub fingerprint: Option<Zeroizing<[u8; RATCHET_SIZE]>>,
-    pub chain_len: u64,
+    key: Zeroizing<[u8; RATCHET_SIZE]>,
+    fingerprint: Option<Zeroizing<[u8; RATCHET_SIZE]>>,
+    chain_len: u64,
 }
 impl PartialEq for RatchetState {
     fn eq(&self, other: &Self) -> bool {
@@ -34,9 +34,14 @@ impl std::hash::Hash for RatchetState {
     }
 }
 impl RatchetState {
+    /// Creates a new ratchet state from the given ratchet key, ratchet fingerprint and chain length.
     pub fn new(key: Zeroizing<[u8; RATCHET_SIZE]>, fingerprint: Zeroizing<[u8; RATCHET_SIZE]>, chain_len: u64) -> Self {
         RatchetState { key, fingerprint: Some(fingerprint), chain_len }
     }
+    /// Creates a new ratchet state from the given ratchet key, ratchet fingerprint and chain length.
+    ///
+    /// The caller should make sure any copies of these values are deleted from memory once they are
+    /// no longer needed.
     pub fn new_raw(key: [u8; RATCHET_SIZE], fingerprint: [u8; RATCHET_SIZE], chain_len: u64) -> Self {
         RatchetState {
             key: Zeroizing::new(key),
@@ -44,6 +49,28 @@ impl RatchetState {
             chain_len,
         }
     }
+    /// The ratchet key for this ratchet state. This is directly mixed into the master secret of a
+    /// session and so is very sensitive. All operations upon a ratchet key must be implemented
+    /// in constant time. The user should prefer to do nothing with the ratchet key besides copying
+    /// it to or from a storage device.
+    ///
+    /// If `fingerprint` returns `None` then this is the "empty" ratchet state and the key will be
+    /// all zeros.
+    pub fn key(&self) -> &[u8; RATCHET_SIZE] {
+        &self.key
+    }
+    /// Ratchet keys and fingerprints are "chained together", where each set is derived from the
+    /// previous set.
+    ///
+    /// This function outputs the total length of that chain, as in the total number of previous
+    /// ratchet states that this ratchet state was derived from.
+    pub fn chain_len(&self) -> u64 {
+        self.chain_len
+    }
+    /// Creates a new "empty" ratchet state, where the ratchet fingerprint is the
+    /// empty string, the ratchet key is all zeros, and the chain length is 0.
+    ///
+    /// This value is the default value of `RatchetState`.
     pub fn empty() -> Self {
         RatchetState {
             key: Zeroizing::new([0u8; RATCHET_SIZE]),
@@ -51,6 +78,9 @@ impl RatchetState {
             chain_len: 0,
         }
     }
+    /// Creates a new ratchet state derived from a one-time-password. If both sides of a session use
+    /// the same one-time-password then they can use this ratchet state to connect with each other
+    /// for the first time.
     pub fn new_from_otp<Hmac: Sha512Hash>(otp: &[u8]) -> RatchetState {
         let mut buffer = Vec::new();
         buffer.push(1);
@@ -66,12 +96,25 @@ impl RatchetState {
             1,
         )
     }
+    /// Returns true if this is the "empty" ratchet state, where the ratchet fingerprint is the
+    /// empty string, the ratchet key is all zeros, and the chain length is 0.
     pub fn is_empty(&self) -> bool {
         self.fingerprint.is_none()
     }
+    /// Checks if the fingerprint of this ratchet state equals the fingerprint contained in argument
+    /// `rf`. Uses constant time equality.
     pub fn fingerprint_eq(&self, rf: &[u8; RATCHET_SIZE]) -> bool {
         self.fingerprint.as_ref().map_or(false, |rf0| secure_eq(rf0, rf))
     }
+    /// The ratchet fingerprint for this ratchet state.
+    ///
+    /// If this returns `None` then the ratchet fingerprint is the empty string.
+    /// This is the "empty" ratchet state and the key will be all zeros.
+    ///
+    /// The ratchet fingerprint value is sensitive and should be hidden,
+    /// but the security of ZSSP can survive having this value leaked.
+    /// Operations on a ratchet fingerprint should be implemented in constant time,
+    /// but it is ok if they are not.
     pub fn fingerprint(&self) -> Option<&[u8; RATCHET_SIZE]> {
         self.fingerprint.as_deref()
     }
@@ -82,23 +125,38 @@ impl Default for RatchetState {
     }
 }
 
-/// A pair of ratchet states.
+/// An ordered pair of two ratchet states.
 /// It is expected that an instance of this object will be saved to a storage device per-peer,
 /// and be restore-able via the `ApplicationLayer` trait.
 ///
 /// This corresponds to the possible values of abstract variables `rf` and `rk` found in Section 4.3.
 #[derive(Clone, PartialEq, Eq, Hash)]
 pub struct RatchetStates {
+    /// The first ratchet state from the pair.
     pub state1: RatchetState,
+    /// The second ratchet state from the pair. It can, and usually will be `None`.
     pub state2: Option<RatchetState>,
 }
 impl RatchetStates {
+    /// Creates a new pair of ratchet states. The order of the arguments matters, and it should be
+    /// the same order that was originally given by an instance of the `RatchetUpdate` struct.
     pub fn new(state1: RatchetState, state2: Option<RatchetState>) -> Self {
         Self { state1, state2 }
     }
+    /// Creates a new initial pair of ratchet states, where the first ratchet state is the empty
+    /// ratchet state and the second is `None`.
+    ///
+    /// This value is the default value of `RatchetStates`.
     pub fn new_initial_states() -> Self {
         Self { state1: RatchetState::empty(), state2: None }
     }
+    /// Creates a new initial pair of ratchet states from a one-time password.
+    /// The first ratchet state will be derived from this password, while the second will be `None`.
+    ///
+    /// If both sides of a session use the same one-time-password then they can use this pair to
+    /// connect with each other for the first time. This pair can be generated with this function,
+    /// saved to persistent storage, and eventually restored by the `ApplicationLayer` when we
+    /// attempt to form a session with the correct peer.
     pub fn new_otp_states<Hmac: Sha512Hash>(otp: &[u8]) -> Self {
         Self {
             state1: RatchetState::new_from_otp::<Hmac>(otp),
@@ -135,9 +193,12 @@ pub struct RatchetUpdate<'a> {
     pub deleted_state2: Option<&'a RatchetState>,
 }
 impl<'a> RatchetUpdate<'a> {
+    /// Clones the `state1` and `state2` pair of ratchet states out of this struct and into a
+    /// `RatchetStates` instance.
     pub fn to_states(&self) -> RatchetStates {
         RatchetStates::new(self.state1.clone(), self.state2.cloned())
     }
+    /// Returns the new ratchet fingerprint that was added during this update, if any.
     pub fn added_fingerprint(&self) -> Option<&[u8; RATCHET_SIZE]> {
         if self.state1_was_just_added {
             self.state1.fingerprint()
@@ -145,6 +206,7 @@ impl<'a> RatchetUpdate<'a> {
             None
         }
     }
+    /// Returns the first ratchet fingerprint that was deleted during this update, if any.
     pub fn deleted_fingerprint1(&self) -> Option<&[u8; RATCHET_SIZE]> {
         if let Some(rs) = &self.deleted_state1 {
             rs.fingerprint()
@@ -152,6 +214,12 @@ impl<'a> RatchetUpdate<'a> {
             None
         }
     }
+    /// Returns the second fingerprint that was deleted during this update, if there was more than
+    /// one ratchet state deleted during this update.
+    ///
+    /// It is extremely rare that this function ever returns `Some`, but it is possible.
+    /// Users should explicitly test that their implementation is able to correctly delete more than
+    /// 1 ratchet state at a time, because it is unlikely to occur under normal conditions.
     pub fn deleted_fingerprint2(&self) -> Option<&[u8; RATCHET_SIZE]> {
         if let Some(rs) = &self.deleted_state2 {
             rs.fingerprint()
diff --git a/src/zeta.rs b/src/zeta.rs
index cc4f10b..f986b6e 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -437,7 +437,7 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     noise.mix_key(ekem1_secret.as_ref());
     drop(ekem1_secret);
     // Process message pattern 2 psk2 token.
-    noise.mix_key_and_hash(ratchet_state.key.as_ref());
+    noise.mix_key_and_hash(ratchet_state.key());
     // Process message pattern 2 payload.
     let session_map = ctx.session_map.borrow_mut();
     let kid_recv = gen_kid(session_map.deref(), ctx.rng.borrow_mut().deref_mut());
@@ -545,14 +545,14 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
             };
             // Check first key.
             let mut ratchet_i = 1;
-            let mut chain_len = zeta.ratchet_state1.chain_len;
-            let mut result = test_ratchet_key(zeta.ratchet_state1.key.as_ref());
+            let mut chain_len = zeta.ratchet_state1.chain_len();
+            let mut result = test_ratchet_key(zeta.ratchet_state1.key());
             // Check second key.
             if result.is_none() {
                 ratchet_i = 2;
                 if let Some(rs) = zeta.ratchet_state2.as_ref() {
-                    chain_len = rs.chain_len;
-                    result = test_ratchet_key(rs.key.as_ref());
+                    chain_len = rs.chain_len();
+                    result = test_ratchet_key(rs.key());
                 }
             }
             // Check zero key.
@@ -736,7 +736,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
 
                 let (rk, rf) = noise.get_ask(LABEL_RATCHET_STATE);
                 // We must make sure the ratchet key is saved before we transition.
-                let new_ratchet_state = RatchetState::new(rk, rf, zeta.ratchet_state.chain_len + 1);
+                let new_ratchet_state = RatchetState::new(rk, rf, zeta.ratchet_state.chain_len() + 1);
                 let result = app.save_ratchet_state(
                     &s_remote,
                     &session_data,
@@ -1066,7 +1066,7 @@ fn timeout_trans<App: ApplicationLayer>(
             noise.mix_hash(&ctx.s_secret.public_key_bytes());
             noise.mix_hash(&zeta.s_remote.to_bytes());
             // Process message pattern 1 psk0 token.
-            noise.mix_key_and_hash(zeta.ratchet_state1.key.as_ref());
+            noise.mix_key_and_hash(zeta.ratchet_state1.key());
             // Process message pattern 1 e token.
             let e_secret = noise.write_e(&ctx.rng, &mut k1);
             // Process message pattern 1 es token.
@@ -1165,7 +1165,7 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
         noise.mix_hash(&zeta.s_remote.to_bytes());
         noise.mix_hash(&s_secret.public_key_bytes());
         // Process message pattern 1 psk0 token.
-        noise.mix_key_and_hash(zeta.ratchet_state1.key.as_ref());
+        noise.mix_key_and_hash(zeta.ratchet_state1.key());
         // Process message pattern 1 e token.
         let e_remote = noise.read_e(&mut i, &k1).ok_or(byzantine_fault!(FailedAuth, true))?;
         // Process message pattern 1 es token.
@@ -1204,7 +1204,7 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
         noise.encrypt_and_hash_in_place(to_nonce(PACKET_TYPE_REKEY_COMPLETE, 0), i, &mut k2);
 
         let (rk, rf) = noise.get_ask(LABEL_RATCHET_STATE);
-        let new_ratchet_state = RatchetState::new(rk, rf, zeta.ratchet_state1.chain_len + 1);
+        let new_ratchet_state = RatchetState::new(rk, rf, zeta.ratchet_state1.chain_len() + 1);
         let result = app.save_ratchet_state(
             &zeta.s_remote,
             &zeta.session_data,
@@ -1308,7 +1308,7 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
                 .ok_or(byzantine_fault!(InvalidPacket, true))?;
 
             let (rk, rf) = noise.get_ask(LABEL_RATCHET_STATE);
-            let new_ratchet_state = RatchetState::new(rk, rf, zeta.ratchet_state1.chain_len + 1);
+            let new_ratchet_state = RatchetState::new(rk, rf, zeta.ratchet_state1.chain_len() + 1);
             let result = app.save_ratchet_state(
                 &zeta.s_remote,
                 &zeta.session_data,

From 755860ff995cb01fee044592ce597178911294d0 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 8 Aug 2023 17:53:59 -0400
Subject: [PATCH 34/37] removed unused error

---
 src/result.rs | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/result.rs b/src/result.rs
index 68f7884..88db809 100644
--- a/src/result.rs
+++ b/src/result.rs
@@ -20,9 +20,6 @@ pub enum OpenError<StorageError> {
 /// Depending on the error type trying again may not work.
 #[derive(Debug, PartialEq, Eq, Clone, Hash)]
 pub enum SendError {
-    /// An invalid parameter was supplied to the function.
-    InvalidParameter,
-
     /// The session has been marked as expired and refuses to send data.
     /// Several components of ZSSP can cause this to occur, but the most likely situation to be seen
     /// in practice is where rekeying repeatedly fails due to exceedingly bad network conditions.

From fa309c0e97eb4434e4c50e7f583f55c97b8d9357 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Wed, 9 Aug 2023 09:04:18 -0400
Subject: [PATCH 35/37] added docs

---
 src/context.rs   |  7 +++--
 src/lib.rs       | 27 +++++++++++++++-
 src/log_event.rs |  1 +
 src/result.rs    |  1 -
 src/zeta.rs      | 81 ++++++++++++++++++++++++------------------------
 5 files changed, 72 insertions(+), 45 deletions(-)

diff --git a/src/context.rs b/src/context.rs
index 5e01784..ea98d20 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -443,7 +443,9 @@ impl<App: ApplicationLayer> Context<App> {
         }
     }
 
-    /// Send data over the session.
+    /// Send data as fragments over the session to the remote peer.
+    ///
+    /// The session used here must have been created from this instance of a ZSSP context.
     ///
     /// * `session` - The session to send to
     /// * `send` - Function to call to send physical packet(s); the buffer passed to `send` is a
@@ -457,6 +459,7 @@ impl<App: ApplicationLayer> Context<App> {
         mut mtu: usize,
         payload: Vec<u8>,
     ) -> Result<(), SendError> {
+        debug_assert_eq!(session.0.borrow().ctx.as_ptr(), Arc::as_ptr(&self.0));
         mtu = mtu.max(MIN_TRANSPORT_MTU);
         let mut zeta = session.0.borrow_mut();
         send_payload(&mut zeta, payload, |Packet(kid, nonce, payload), hk| {
@@ -468,7 +471,7 @@ impl<App: ApplicationLayer> Context<App> {
     ///
     /// This returns the number of milliseconds until it should be called again. The caller should
     /// try to satisfy this but small variations in timing of up to a few seconds are not
-    /// a problem.
+    /// a problem. It is completely fine to call this function more often than the returned interval.
     ///
     /// * `send_to` - Function to get a sender and an MTU to send something over an active session
     pub fn service<SendFn: FnMut(Vec<u8>) -> bool>(
diff --git a/src/lib.rs b/src/lib.rs
index f871edf..9519d31 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -5,8 +5,33 @@
 * (c) ZeroTier, Inc.
 * https://www.zerotier.com/
 */
+//! ZeroTier Secure Sessions Protocol
+//! ======
+//!
+//! ## Introduction
+//!
+//! An in-depth guide to the full protocol specification can be found in the [protocol whitepaper](./whitepaper.pdf) provided in this repo. This implementation references it heavily.
+//!
+//! ZeroTier Secure Socket Protocol (ZSSP) is a [Noise](http://noiseprotocol.org) protocol implementation using NIST/FIPS/CfSC compliant cryptographic primitives plus post-quantum forward secrecy via [Kyber1024](https://pq-crystals.org/kyber/). It also includes built-in support for fragmentation and defragmentation of large messages with strong resistance against denial of service attacks targeted against the fragmentation protocol.
+//!
+//! Specifically ZSSP implements the [Noise XK](http://noiseprotocol.org/noise.html#interactive-handshake-patterns-fundamental) interactive handshake pattern which provides strong forward secrecy not only for data but for the identities of the two participants in the session. The XK pattern was chosen instead of the more popular IK pattern used in popular Noise implementations like Wireguard due to ZeroTier identities being long lived and potentially tied to the real world identity of the user. As a result a Noise pattern providing identity forward secrecy was considered preferable as it offers some level of deniability for recorded traffic even after secret key compromise.
+//!
+//! Hybrid post-quantum forward secrecy using Kyber1024 is performed alongside Noise with the result being mixed in alongside an optional pre-shared key at the end of session negotiation.
+//!
+//! ZSSP is designed for use in ZeroTier but is payload-agnostic and could easily be adapted for use in other projects.
+//!
+//! Further information can be found in the ZSSP whitepaper [protocol whitepaper](./whitepaper.pdf).
+//!
+//! ## Cryptographic Primitives Used
+//!
+//!  - **NIST P-384 ECDH**: Elliptic curve key exchange during initial handshake and for periodic re-keying during the session
+//!  - **Kyber1024**: Quantum attack resistant lattice-based key exchange during initial handshake
+//!  - **SHA-512**: Used to construct KBKDF, also used in a proof of work and IP ownership DOS mitigation scheme
+//!  - **KBKDF**: Key mixing, sub-key derivation
+//!  - **AES-256**: 128-bit PRP for AES-256-GCM and for authenticated encryption of header to harden fragmentation against DOS (see section on header protection)
+//!  - **AES-256-GCM**: Authenticated encryption
 #![warn(missing_docs, rust_2018_idioms)]
-//! TODO: docs
+
 mod challenge;
 mod context;
 mod fragmentation;
diff --git a/src/log_event.rs b/src/log_event.rs
index 69b4826..3cb3948 100644
--- a/src/log_event.rs
+++ b/src/log_event.rs
@@ -4,6 +4,7 @@ use crate::application::ApplicationLayer;
 use crate::Session;
 
 /// ZSSP events that might be interesting to log or aggregate into metrics.
+#[allow(missing_docs)]
 pub enum LogEvent<'a, App: ApplicationLayer> {
     ResentX1(&'a Arc<Session<App>>),
     TimeoutX1(&'a Arc<Session<App>>),
diff --git a/src/result.rs b/src/result.rs
index 88db809..a3abb60 100644
--- a/src/result.rs
+++ b/src/result.rs
@@ -174,5 +174,4 @@ pub enum SessionEvent {
     /// This means either Bob corrupted their ratchet key storage, or someone is impersonating Alice.
     /// The application should attempt to warn the user of this fact.
     DowngradedRatchetKey,
-
 }
diff --git a/src/zeta.rs b/src/zeta.rs
index f986b6e..47836fc 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -18,32 +18,9 @@ use crate::symmetric_state::SymmetricState;
 #[cfg(feature = "logging")]
 use crate::LogEvent::*;
 
-/// Create a 96-bit AES-GCM nonce.
-///
-/// The primary information that we want to be contained here is the counter and the
-/// packet type. The former makes this unique and the latter's inclusion authenticates
-/// it as effectively AAD. Other elements of the header are either not authenticated,
-/// like fragmentation info, or their authentication is implied via key exchange like
-/// the key id.
-///
-/// Corresponds to Figure 10 found in Section 4.3.
-pub(crate) fn to_nonce(packet_type: u8, counter: u64) -> [u8; AES_GCM_NONCE_SIZE] {
-    let mut ret = [0u8; AES_GCM_NONCE_SIZE];
-    ret[3] = packet_type;
-    // Noise requires a big endian counter at the end of the Nonce
-    ret[4..].copy_from_slice(&counter.to_be_bytes());
-    ret
-}
-/// Corresponds to Figure 10 and Figure 14 found in Section 4.3.
-pub(crate) fn from_nonce(n: &[u8]) -> (u8, u64) {
-    assert!(n.len() >= PACKET_NONCE_SIZE);
-    let c_start = n.len() - 8;
-    (n[c_start - 1], u64::from_be_bytes(n[c_start..].try_into().unwrap()))
-}
-
 /// Corresponds to the Zeta State Machine found in Section 4.1.
 pub(crate) struct Zeta<App: ApplicationLayer> {
-    ctx: Weak<ContextInner<App>>,
+    pub ctx: Weak<ContextInner<App>>,
     /// An arbitrary application defined object associated with each session.
     pub session_data: App::SessionData,
     /// Is true if the local peer acted as Bob, the responder in the initial key exchange.
@@ -156,6 +133,28 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     }
 }
 
+/// Create a 96-bit AES-GCM nonce.
+///
+/// The primary information that we want to be contained here is the counter and the
+/// packet type. The former makes this unique and the latter's inclusion authenticates
+/// it as effectively AAD. Other elements of the header are either not authenticated,
+/// like fragmentation info, or their authentication is implied via key exchange like
+/// the key id.
+///
+/// Corresponds to Figure 10 found in Section 4.3.
+pub(crate) fn to_nonce(packet_type: u8, counter: u64) -> [u8; AES_GCM_NONCE_SIZE] {
+    let mut ret = [0u8; AES_GCM_NONCE_SIZE];
+    ret[3] = packet_type;
+    // Noise requires a big endian counter at the end of the Nonce
+    ret[4..].copy_from_slice(&counter.to_be_bytes());
+    ret
+}
+/// Corresponds to Figure 10 and Figure 14 found in Section 4.3.
+pub(crate) fn from_nonce(n: &[u8]) -> (u8, u64) {
+    assert!(n.len() >= PACKET_NONCE_SIZE);
+    let c_start = n.len() - 8;
+    (n[c_start - 1], u64::from_be_bytes(n[c_start..].try_into().unwrap()))
+}
 /// Generate a random local key id that is currently unused.
 fn gen_kid<T>(session_map: &HashMap<NonZeroU32, T>, rng: &mut impl RngCore) -> NonZeroU32 {
     loop {
@@ -166,6 +165,22 @@ fn gen_kid<T>(session_map: &HashMap<NonZeroU32, T>, rng: &mut impl RngCore) -> N
         }
     }
 }
+fn remap<App: ApplicationLayer>(
+    session: &Arc<Session<App>>,
+    zeta: &Zeta<App>,
+    rng: &RefCell<App::Rng>,
+    session_map: &SessionMap<App>,
+) -> NonZeroU32 {
+    let mut session_map = session_map.borrow_mut();
+    let weak = if let Some(Some(weak)) = zeta.key_ref(true).recv.kid.as_ref().map(|kid| session_map.remove(kid)) {
+        weak
+    } else {
+        Arc::downgrade(&session)
+    };
+    let new_kid_recv = gen_kid(session_map.deref(), rng.borrow_mut().deref_mut());
+    session_map.insert(new_kid_recv, weak);
+    new_kid_recv
+}
 
 impl<App: ApplicationLayer> Zeta<App> {
     pub(crate) fn check_counter_window(&self, c: u64) -> bool {
@@ -447,7 +462,7 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     noise.encrypt_and_hash_in_place(to_nonce(PACKET_TYPE_HANDSHAKE_RESPONSE, 0), i, &mut x2);
 
     let i = x2.len();
-    let mut c = 0u64.to_be_bytes();
+    let mut c = [0u8; 8];
     c[5] = x2[i - 3];
     c[6] = x2[i - 2];
     c[7] = x2[i - 1];
@@ -993,22 +1008,6 @@ pub(crate) fn service<App: ApplicationLayer>(
         send_control(zeta, p, control_payload, send);
     }
 }
-fn remap<App: ApplicationLayer>(
-    session: &Arc<Session<App>>,
-    zeta: &Zeta<App>,
-    rng: &RefCell<App::Rng>,
-    session_map: &SessionMap<App>,
-) -> NonZeroU32 {
-    let mut session_map = session_map.borrow_mut();
-    let weak = if let Some(Some(weak)) = zeta.key_ref(true).recv.kid.as_ref().map(|kid| session_map.remove(kid)) {
-        weak
-    } else {
-        Arc::downgrade(&session)
-    };
-    let new_kid_recv = gen_kid(session_map.deref(), rng.borrow_mut().deref_mut());
-    session_map.insert(new_kid_recv, weak);
-    new_kid_recv
-}
 /// Corresponds to the timeout timer Transition Algorithm described in Section 4.1 - Definition 3.
 fn timeout_trans<App: ApplicationLayer>(
     zeta: &mut Zeta<App>,

From 1e87d1ba756561a28010fad757d54749f987194d Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Wed, 9 Aug 2023 09:51:52 -0400
Subject: [PATCH 36/37] stable version

---
 src/application.rs | 16 ++++++++--------
 src/context.rs     | 22 +++++++++++-----------
 src/zeta.rs        | 25 ++++++++++++++-----------
 3 files changed, 33 insertions(+), 30 deletions(-)

diff --git a/src/application.rs b/src/application.rs
index 7a50314..03f814c 100644
--- a/src/application.rs
+++ b/src/application.rs
@@ -142,7 +142,7 @@ pub trait ApplicationLayer: Sized {
     /// with remote peers (although both of these properties would help reliability slightly).
     /// Used to determine if any current handshakes should be resent or timed-out, or if a session
     /// should rekey.
-    fn time(&self) -> i64;
+    fn time(&mut self) -> i64;
 
     /// This function will be called whenever Alice's initial Hello packet contains the empty ratchet
     /// fingerprint. Brand new peers will always connect to Bob with the empty ratchet, but from
@@ -153,7 +153,7 @@ pub trait ApplicationLayer: Sized {
     /// If this function is configured to always return true, it means peers will not be able to
     /// connect to us unless they had a prior-established ratchet key with us. This is the best way
     /// for the paranoid to enforce a manual allow-list.
-    fn hello_requires_recognized_ratchet(&self) -> bool;
+    fn hello_requires_recognized_ratchet(&mut self) -> bool;
     /// This function is called if we, as Alice, attempted to open a session with Bob using a
     /// non-empty ratchet key, but Bob does not have this ratchet key and wants to downgrade
     /// to the zero ratchet key.
@@ -169,14 +169,14 @@ pub trait ApplicationLayer: Sized {
     /// least one party is misconfigured and got their ratchet keys corrupted or lost, or Bob has
     /// been compromised and is being impersonated. An attacker must at least have Bob's private
     /// static key to be able to ask Alice to downgrade.
-    fn initiator_disallows_downgrade(&self, session: &Arc<Session<Self>>) -> bool;
+    fn initiator_disallows_downgrade(&mut self, session: &Arc<Session<Self>>) -> bool;
     /// Function to accept sessions after final negotiation.
     /// The second argument is the identity that the remote peer sent us. The application
     /// must verify this identity is associated with the remote peer's static key.
     /// To prevent desync, if this function specifies that we should connect, no other open session
     /// with the same remote peer must exist. Drop or call expire on any pre-existing sessions
     /// before returning.
-    fn check_accept_session(&self, remote_static_key: &Self::PublicKey, identity: &[u8]) -> AcceptAction<Self>;
+    fn check_accept_session(&mut self, remote_static_key: &Self::PublicKey, identity: &[u8]) -> AcceptAction<Self>;
 
     /// Lookup a specific ratchet state based on its ratchet fingerprint.
     /// This function will be called whenever Alice attempts to connect to us with a non-empty
@@ -185,7 +185,7 @@ pub trait ApplicationLayer: Sized {
     /// If a ratchet state with a matching fingerprint could not be found, this function should
     /// return `Ok(None)`.
     fn restore_by_fingerprint(
-        &self,
+        &mut self,
         ratchet_fingerprint: &[u8; RATCHET_SIZE],
     ) -> Result<Option<RatchetState>, Self::StorageError>;
     /// Lookup the specific ratchet states based on the identity of the peer being communicated with.
@@ -203,7 +203,7 @@ pub trait ApplicationLayer: Sized {
     /// Filtering peers should be done by the caller to `Context::open` as well as by the
     /// function `ApplicationLayer::check_accept_session`.
     fn restore_by_identity(
-        &self,
+        &mut self,
         remote_static_key: &Self::PublicKey,
         session_data: &Self::SessionData,
     ) -> Result<Option<RatchetStates>, Self::StorageError>;
@@ -224,7 +224,7 @@ pub trait ApplicationLayer: Sized {
     /// to us will have to allow downgrade across the board.
     /// Otherwise, when we restart, we will not be allowed to reconnect.
     fn save_ratchet_state(
-        &self,
+        &mut self,
         remote_static_key: &Self::PublicKey,
         session_data: &Self::SessionData,
         update_data: RatchetUpdate<'_>,
@@ -234,7 +234,7 @@ pub trait ApplicationLayer: Sized {
     /// These are provided for debugging, logging or metrics purposes, and must be used for
     /// nothing else. Do not base protocol-level decisions upon the events passed to this function.
     #[cfg(feature = "logging")]
-    fn event_log(&self, event: LogEvent<'_, Self>);
+    fn event_log(&mut self, event: LogEvent<'_, Self>);
 }
 
 /// A collection of fields specifying how to complete the key exchange with a specific remote peer,
diff --git a/src/context.rs b/src/context.rs
index ea98d20..837b856 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -130,9 +130,9 @@ impl<App: ApplicationLayer> Context<App> {
     /// * `send_to` - Function to get senders for existing sessions, permitting MTU and path lookup
     /// * `remote_address` - Whatever the remote address is, as long as you can Hash it
     /// * `raw_fragment` - Buffer containing incoming wire packet
-    pub fn receive<'a, SendFn: FnMut(Vec<u8>) -> bool>(
+    pub fn receive<SendFn: FnMut(Vec<u8>) -> bool>(
         &mut self,
-        app: App,
+        mut app: App,
         send_unassociated_reply: impl FnMut(Vec<u8>) -> bool,
         mut send_unassociated_mtu: usize,
         send_to: impl FnOnce(&Arc<Session<App>>) -> Option<(SendFn, usize)>,
@@ -209,7 +209,7 @@ impl<App: ApplicationLayer> Context<App> {
                             let should_warn_missing_ratchet = received_x2_trans(
                                 &mut zeta,
                                 &session,
-                                &app,
+                                &mut app,
                                 &ctx,
                                 kid_recv,
                                 to_aes_nonce(&pn),
@@ -227,7 +227,7 @@ impl<App: ApplicationLayer> Context<App> {
                             log!(app, ReceivedRawKeyConfirm);
                             let result = received_c1_trans(
                                 &mut zeta,
-                                &app,
+                                &mut app,
                                 &ctx.rng,
                                 kid_recv,
                                 to_aes_nonce(&pn),
@@ -245,7 +245,7 @@ impl<App: ApplicationLayer> Context<App> {
                             log!(app, ReceivedRawAck);
                             received_c2_trans(
                                 &mut zeta,
-                                &app,
+                                &mut app,
                                 &ctx.rng,
                                 kid_recv,
                                 to_aes_nonce(&pn),
@@ -259,7 +259,7 @@ impl<App: ApplicationLayer> Context<App> {
                             received_k1_trans(
                                 &mut zeta,
                                 &session,
-                                &app,
+                                &mut app,
                                 &ctx.rng,
                                 &ctx.session_map,
                                 &ctx.s_secret,
@@ -275,7 +275,7 @@ impl<App: ApplicationLayer> Context<App> {
                             log!(app, ReceivedRawK2);
                             received_k2_trans(
                                 &mut zeta,
-                                &app,
+                                &mut app,
                                 kid_recv,
                                 to_aes_nonce(&pn),
                                 assembled_packet,
@@ -318,7 +318,7 @@ impl<App: ApplicationLayer> Context<App> {
                         let zeta = entry.remove();
                         let (session, should_warn_missing_ratchet) = received_x3_trans(
                             zeta,
-                            &app,
+                            &mut app,
                             ctx,
                             kid_recv,
                             assembled_packet,
@@ -396,7 +396,7 @@ impl<App: ApplicationLayer> Context<App> {
 
                     // Process recv zeta layer.
                     received_x1_trans(
-                        &app,
+                        &mut app,
                         &ctx,
                         to_aes_nonce(&n),
                         assembled_packet,
@@ -476,7 +476,7 @@ impl<App: ApplicationLayer> Context<App> {
     /// * `send_to` - Function to get a sender and an MTU to send something over an active session
     pub fn service<SendFn: FnMut(Vec<u8>) -> bool>(
         &mut self,
-        app: App,
+        mut app: App,
         mut send_to: impl FnMut(&Arc<Session<App>>) -> Option<(SendFn, usize)>,
     ) -> i64 {
         let ctx = &self.0;
@@ -490,7 +490,7 @@ impl<App: ApplicationLayer> Context<App> {
                     &mut zeta,
                     &session,
                     ctx,
-                    &app,
+                    &mut app,
                     current_time,
                     |Packet(kid, nonce, payload): &Packet, hk| {
                         if let Some((send_fragment, mut mtu)) = send_to(&session) {
diff --git a/src/zeta.rs b/src/zeta.rs
index 47836fc..abad602 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -290,7 +290,7 @@ fn create_a1_state<App: ApplicationLayer>(
 }
 /// Corresponds to Transition Algorithm 1 found in Section 4.3.
 pub(crate) fn trans_to_a1<App: ApplicationLayer>(
-    app: App,
+    mut app: App,
     ctx: &Arc<ContextInner<App>>,
     s_remote: App::PublicKey,
     session_data: App::SessionData,
@@ -359,7 +359,7 @@ pub(crate) fn respond_to_challenge<App: ApplicationLayer>(
 }
 /// Corresponds to Transition Algorithm 2 found in Section 4.3.
 pub(crate) fn received_x1_trans<App: ApplicationLayer>(
-    app: &App,
+    app: &mut App,
     ctx: &ContextInner<App>,
     n: [u8; AES_GCM_NONCE_SIZE],
     mut x1: Vec<u8>,
@@ -491,7 +491,7 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
 pub(crate) fn received_x2_trans<App: ApplicationLayer>(
     zeta: &mut Zeta<App>,
     session: &Arc<Session<App>>,
-    app: &App,
+    app: &mut App,
     ctx: &Arc<ContextInner<App>>,
     kid: NonZeroU32,
     n: [u8; AES_GCM_NONCE_SIZE],
@@ -643,7 +643,10 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
         }
     })();
     match &result {
-        Err(ReceiveError::ByzantineFault { .. }) => timeout_trans(zeta, session, app, ctx, app.time(), send),
+        Err(ReceiveError::ByzantineFault { .. }) => {
+            let current_time = app.time();
+            timeout_trans(zeta, session, app, ctx, current_time, send);
+        }
         Ok(packet) => send(packet, Some(&zeta.hk_send)),
         _ => {}
     }
@@ -673,7 +676,7 @@ fn send_control<App: ApplicationLayer>(
 /// Corresponds to Transition Algorithm 4 found in Section 4.3.
 pub(crate) fn received_x3_trans<App: ApplicationLayer>(
     zeta: StateB2<App>,
-    app: &App,
+    app: &mut App,
     ctx: &Arc<ContextInner<App>>,
     kid: NonZeroU32,
     mut x3: Vec<u8>,
@@ -825,7 +828,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
 /// Corresponds to Transition Algorithm 5 found in Section 4.3.
 pub(crate) fn received_c1_trans<App: ApplicationLayer>(
     zeta: &mut Zeta<App>,
-    app: &App,
+    app: &mut App,
     rng: &RefCell<App::Rng>,
     kid: NonZeroU32,
     n: [u8; AES_GCM_NONCE_SIZE],
@@ -901,7 +904,7 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
 /// Section 4.3.
 pub(crate) fn received_c2_trans<App: ApplicationLayer>(
     zeta: &mut Zeta<App>,
-    app: &App,
+    app: &mut App,
     rng: &RefCell<App::Rng>,
     kid: NonZeroU32,
     n: [u8; AES_GCM_NONCE_SIZE],
@@ -970,7 +973,7 @@ pub(crate) fn service<App: ApplicationLayer>(
     zeta: &mut Zeta<App>,
     session: &Arc<Session<App>>,
     ctx: &Arc<ContextInner<App>>,
-    app: &App,
+    app: &mut App,
     current_time: i64,
     send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
 ) {
@@ -1012,7 +1015,7 @@ pub(crate) fn service<App: ApplicationLayer>(
 fn timeout_trans<App: ApplicationLayer>(
     zeta: &mut Zeta<App>,
     session: &Arc<Session<App>>,
-    app: &App,
+    app: &mut App,
     ctx: &Arc<ContextInner<App>>,
     current_time: i64,
     send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
@@ -1108,7 +1111,7 @@ fn timeout_trans<App: ApplicationLayer>(
 pub(crate) fn received_k1_trans<App: ApplicationLayer>(
     zeta: &mut Zeta<App>,
     session: &Arc<Session<App>>,
-    app: &App,
+    app: &mut App,
     rng: &RefCell<App::Rng>,
     session_map: &SessionMap<App>,
     s_secret: &App::KeyPair,
@@ -1246,7 +1249,7 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
 /// Corresponds to Transition Algorithm 8 found in Section 4.3.
 pub(crate) fn received_k2_trans<App: ApplicationLayer>(
     zeta: &mut Zeta<App>,
-    app: &App,
+    app: &mut App,
     kid: NonZeroU32,
     n: [u8; AES_GCM_NONCE_SIZE],
     mut k2: Vec<u8>,

From 6b1fa53e1c22fa6501ee20d5f3db2d10a826e359 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Wed, 9 Aug 2023 10:45:56 -0400
Subject: [PATCH 37/37] added the ability to mutate app

---
 examples/basic_test.rs |  88 ++++++++--------
 src/application.rs     |  39 ++++---
 src/context.rs         |  78 +++++++-------
 src/crypto_impl/mod.rs |  35 +++++++
 src/fragmentation.rs   |  12 +--
 src/log_event.rs       |  44 ++++----
 src/result.rs          |   6 +-
 src/symmetric_state.rs |  28 ++---
 src/zeta.rs            | 228 ++++++++++++++++++++---------------------
 9 files changed, 300 insertions(+), 258 deletions(-)

diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index 7513eef..87335a1 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -7,10 +7,11 @@
  */
 
 use std::collections::HashMap;
+use std::convert::Infallible;
 use std::iter::ExactSizeIterator;
 use std::str::FromStr;
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{mpsc, Arc, Mutex};
+use std::sync::{mpsc, Arc};
 use std::thread;
 use std::time::{Duration, Instant};
 
@@ -18,7 +19,7 @@ use rand_core::OsRng;
 use rand_core::RngCore;
 
 use zssp_proto::application::{
-    AcceptAction, ApplicationLayer, RatchetState, RatchetStates, RatchetUpdate, Settings, RATCHET_SIZE,
+    AcceptAction, ApplicationLayer, RatchetState, RatchetStates, RatchetUpdate, Settings, RATCHET_SIZE, CryptoLayer,
 };
 use zssp_proto::crypto::P384KeyPair;
 use zssp_proto::crypto_impl::{
@@ -31,7 +32,7 @@ const TEST_MTU: usize = 1500;
 struct TestApplication {
     time: Instant,
     name: &'static str,
-    ratchets: Mutex<Ratchets>,
+    ratchets: Ratchets,
 }
 
 struct Ratchets {
@@ -44,8 +45,7 @@ impl Ratchets {
     }
 }
 
-#[allow(unused)]
-impl ApplicationLayer for &TestApplication {
+impl CryptoLayer for TestApplication {
     const SETTINGS: Settings = Settings {
         initial_offer_timeout: Settings::INITIAL_OFFER_TIMEOUT_MS,
         rekey_timeout: 60 * 1000,
@@ -63,18 +63,21 @@ impl ApplicationLayer for &TestApplication {
     type KeyPair = P384CrateKeyPair;
     type Kem = RustKyber1024PrivateKey;
 
-    type StorageError = std::convert::Infallible;
     type SessionData = u128;
-
-    fn hello_requires_recognized_ratchet(&self) -> bool {
+}
+#[allow(unused)]
+impl ApplicationLayer for &mut TestApplication {
+    type Crypto = TestApplication;
+    type StorageError = Infallible;
+    fn hello_requires_recognized_ratchet(&mut self) -> bool {
         false
     }
 
-    fn initiator_disallows_downgrade(&self, session: &Arc<Session<Self>>) -> bool {
+    fn initiator_disallows_downgrade(&mut self, session: &Arc<Session<TestApplication>>) -> bool {
         true
     }
 
-    fn check_accept_session(&self, remote_static_key: &Self::PublicKey, identity: &[u8]) -> AcceptAction<Self> {
+    fn check_accept_session(&mut self, remote_static_key: &P384CratePublicKey, identity: &[u8]) -> AcceptAction<TestApplication> {
         AcceptAction {
             session_data: Some(1),
             responder_disallows_downgrade: true,
@@ -83,49 +86,46 @@ impl ApplicationLayer for &TestApplication {
     }
 
     fn restore_by_fingerprint(
-        &self,
+        &mut self,
         ratchet_fingerprint: &[u8; RATCHET_SIZE],
-    ) -> Result<Option<RatchetState>, Self::StorageError> {
-        let ratchets = self.ratchets.lock().unwrap();
-        Ok(ratchets.rf_map.get(ratchet_fingerprint).cloned())
+    ) -> Result<Option<RatchetState>, Infallible> {
+        Ok(self.ratchets.rf_map.get(ratchet_fingerprint).cloned())
     }
 
     fn restore_by_identity(
-        &self,
-        remote_static_key: &Self::PublicKey,
-        session_data: &Self::SessionData,
-    ) -> Result<Option<RatchetStates>, Self::StorageError> {
-        let ratchets = self.ratchets.lock().unwrap();
-        Ok(ratchets.peer_map.get(session_data).cloned())
+        &mut self,
+        remote_static_key: &P384CratePublicKey,
+        session_data: &u128,
+    ) -> Result<Option<RatchetStates>, Infallible> {
+        Ok(self.ratchets.peer_map.get(session_data).cloned())
     }
 
     fn save_ratchet_state(
-        &self,
-        remote_static_key: &Self::PublicKey,
-        session_data: &Self::SessionData,
+        &mut self,
+        remote_static_key: &P384CratePublicKey,
+        session_data: &u128,
         update_data: RatchetUpdate<'_>,
-    ) -> Result<(), Self::StorageError> {
-        let mut ratchets = self.ratchets.lock().unwrap();
-        ratchets.peer_map.insert(*session_data, update_data.to_states());
+    ) -> Result<(), Infallible> {
+        self.ratchets.peer_map.insert(*session_data, update_data.to_states());
 
         if let Some(rf) = update_data.added_fingerprint() {
-            ratchets.rf_map.insert(*rf, update_data.state1.clone());
+            self.ratchets.rf_map.insert(*rf, update_data.state1.clone());
             println!("[{}] new ratchet #{}", self.name, update_data.state1.chain_len());
         }
         if let Some(rf) = update_data.deleted_fingerprint1() {
-            ratchets.rf_map.remove(rf);
+            self.ratchets.rf_map.remove(rf);
         }
         if let Some(rf) = update_data.deleted_fingerprint2() {
-            ratchets.rf_map.remove(rf);
+            self.ratchets.rf_map.remove(rf);
         }
         Ok(())
     }
 
-    fn time(&self) -> i64 {
+    fn time(&mut self) -> i64 {
         self.time.elapsed().as_millis() as i64
     }
 
-    fn event_log(&self, event: zssp_proto::LogEvent<Self>) {
+    fn event_log(&mut self, event: zssp_proto::LogEvent<TestApplication>) {
         println!(">[{}] {:?}", self.name, event);
     }
 }
@@ -133,7 +133,7 @@ impl ApplicationLayer for &TestApplication {
 fn alice_main(
     run: &AtomicBool,
     packet_success_rate: u32,
-    alice_app: &TestApplication,
+    mut alice_app: TestApplication,
     alice_out: mpsc::SyncSender<Vec<u8>>,
     alice_in: mpsc::Receiver<Vec<u8>>,
     recursive_out: mpsc::SyncSender<Vec<u8>>,
@@ -141,7 +141,7 @@ fn alice_main(
     bob_pubkey: P384CratePublicKey,
 ) {
     let startup_time = std::time::Instant::now();
-    let mut context = zssp_proto::Context::<&TestApplication>::new(alice_keypair, OsRng);
+    let mut context = zssp_proto::Context::<TestApplication>::new(alice_keypair, OsRng);
     let mut next_service = startup_time.elapsed().as_millis() as i64 + 500;
     let test_data = [1u8; TEST_MTU * 10];
     let mut up = false;
@@ -153,7 +153,7 @@ fn alice_main(
             alice_session = Some(
                 context
                     .open(
-                        alice_app,
+                        &mut alice_app,
                         |b| alice_out.send(b).is_ok(),
                         TEST_MTU,
                         bob_pubkey.clone(),
@@ -173,7 +173,7 @@ fn alice_main(
                     use zssp_proto::result::ReceiveOk::*;
                     use zssp_proto::result::SessionEvent::*;
                     match context.receive(
-                        alice_app,
+                        &mut alice_app,
                         |b| alice_out.send(b).is_ok(),
                         TEST_MTU,
                         |_| Some((|b| alice_out.send(b).is_ok(), TEST_MTU)),
@@ -228,7 +228,7 @@ fn alice_main(
 
         if current_time >= next_service {
             next_service =
-                current_time + context.service(alice_app, |_| Some((|b| alice_out.send(b).is_ok(), TEST_MTU)));
+                current_time + context.service(&mut alice_app, |_| Some((|b| alice_out.send(b).is_ok(), TEST_MTU)));
         }
     }
 }
@@ -236,14 +236,14 @@ fn alice_main(
 fn bob_main(
     run: &AtomicBool,
     packet_success_rate: u32,
-    bob_app: &TestApplication,
+    mut bob_app: TestApplication,
     bob_out: mpsc::SyncSender<Vec<u8>>,
     bob_in: mpsc::Receiver<Vec<u8>>,
     recursive_out: mpsc::SyncSender<Vec<u8>>,
     bob_keypair: P384CrateKeyPair,
 ) {
     let startup_time = std::time::Instant::now();
-    let mut context = zssp_proto::Context::<&TestApplication>::new(bob_keypair, OsRng);
+    let mut context = zssp_proto::Context::<TestApplication>::new(bob_keypair, OsRng);
     let mut last_speed_metric = startup_time.elapsed().as_millis() as i64;
     let mut next_service = last_speed_metric + 500;
     let mut transferred = 0u64;
@@ -260,7 +260,7 @@ fn bob_main(
                 use zssp_proto::result::ReceiveOk::*;
                 use zssp_proto::result::SessionEvent::*;
                 match context.receive(
-                    bob_app,
+                    &mut bob_app,
                     |b| bob_out.send(b).is_ok(),
                     TEST_MTU,
                     |_| Some((|b| bob_out.send(b).is_ok(), TEST_MTU)),
@@ -305,7 +305,7 @@ fn bob_main(
         }
 
         if current_time >= next_service {
-            next_service = current_time + context.service(bob_app, |_| Some((|b| bob_out.send(b).is_ok(), TEST_MTU)));
+            next_service = current_time + context.service(&mut bob_app, |_| Some((|b| bob_out.send(b).is_ok(), TEST_MTU)));
         }
     }
 }
@@ -317,14 +317,14 @@ fn core(time: u64, packet_success_rate: u32) {
     let alice_app = TestApplication {
         time: Instant::now(),
         name: "alice",
-        ratchets: Mutex::new(Ratchets::new()),
+        ratchets: Ratchets::new(),
     };
     let bob_keypair = P384CrateKeyPair::generate(&mut OsRng);
     let bob_pubkey = bob_keypair.public_key();
     let bob_app = TestApplication {
         time: Instant::now(),
         name: "bob",
-        ratchets: Mutex::new(Ratchets::new()),
+        ratchets: Ratchets::new(),
     };
 
     let (alice_out, bob_in) = mpsc::sync_channel::<Vec<u8>>(256);
@@ -338,7 +338,7 @@ fn core(time: u64, packet_success_rate: u32) {
                 alice_main(
                     run,
                     packet_success_rate,
-                    &alice_app,
+                    alice_app,
                     alice_out,
                     alice_in,
                     bob_out,
@@ -351,7 +351,7 @@ fn core(time: u64, packet_success_rate: u32) {
             bob_main(
                 run,
                 packet_success_rate,
-                &bob_app,
+                bob_app,
                 bob_out,
                 bob_in,
                 alice_out,
diff --git a/src/application.rs b/src/application.rs
index 03f814c..ba1f018 100644
--- a/src/application.rs
+++ b/src/application.rs
@@ -83,11 +83,11 @@ impl Default for Settings {
     }
 }
 
-/// Trait to implement to integrate the session into an application.
+/// Trait to implement to integrate ZSSP into an application.
 ///
-/// Templating the session on this trait lets the code here be almost entirely transport, OS,
-/// and use case independent.
-pub trait ApplicationLayer: Sized {
+/// This is a container trait for all of the cryptographic algorithms ZSSP will use, and all of the
+/// generic types that ZSSP will attach to sessions.
+pub trait CryptoLayer: Sized {
     /// These are constants that can be redefined from their defaults to change rekey
     /// and negotiation timeout behavior. If two sides of a ZSSP session have different constants,
     /// the protocol will tend to default to the smaller constants.
@@ -131,13 +131,20 @@ pub trait ApplicationLayer: Sized {
     /// for ZSSP to achieve FIPS compliance.
     type Kem: Kyber1024PrivateKey<Self::Rng>;
 
+    /// An arbitrary opaque object for use by the application that is attached to each session.
+    type SessionData;
+}
+/// Trait to implement to integrate ZSSP into an application.
+///
+/// Templating ZSSP on this trait lets the code here be almost entirely transport, OS,
+/// and use case independent.
+pub trait ApplicationLayer: Sized {
+    /// Specifies which concrete set of cryptography types will be used by this application.
+    type Crypto: CryptoLayer;
     /// A user-defined error returned when the `ApplicationLayer` fails to access persistent storage
     /// for a peer's ratchet states.
     type StorageError: std::error::Error;
 
-    /// An arbitrary opaque object for use by the application that is attached to each session.
-    type SessionData;
-
     /// Should return the current time in milliseconds. Does not have to be monotonic, nor synced
     /// with remote peers (although both of these properties would help reliability slightly).
     /// Used to determine if any current handshakes should be resent or timed-out, or if a session
@@ -169,14 +176,14 @@ pub trait ApplicationLayer: Sized {
     /// least one party is misconfigured and got their ratchet keys corrupted or lost, or Bob has
     /// been compromised and is being impersonated. An attacker must at least have Bob's private
     /// static key to be able to ask Alice to downgrade.
-    fn initiator_disallows_downgrade(&mut self, session: &Arc<Session<Self>>) -> bool;
+    fn initiator_disallows_downgrade(&mut self, session: &Arc<Session<Self::Crypto>>) -> bool;
     /// Function to accept sessions after final negotiation.
     /// The second argument is the identity that the remote peer sent us. The application
     /// must verify this identity is associated with the remote peer's static key.
     /// To prevent desync, if this function specifies that we should connect, no other open session
     /// with the same remote peer must exist. Drop or call expire on any pre-existing sessions
     /// before returning.
-    fn check_accept_session(&mut self, remote_static_key: &Self::PublicKey, identity: &[u8]) -> AcceptAction<Self>;
+    fn check_accept_session(&mut self, remote_static_key: &<Self::Crypto as CryptoLayer>::PublicKey, identity: &[u8]) -> AcceptAction<Self::Crypto>;
 
     /// Lookup a specific ratchet state based on its ratchet fingerprint.
     /// This function will be called whenever Alice attempts to connect to us with a non-empty
@@ -204,8 +211,8 @@ pub trait ApplicationLayer: Sized {
     /// function `ApplicationLayer::check_accept_session`.
     fn restore_by_identity(
         &mut self,
-        remote_static_key: &Self::PublicKey,
-        session_data: &Self::SessionData,
+        remote_static_key: &<Self::Crypto as CryptoLayer>::PublicKey,
+        session_data: &<Self::Crypto as CryptoLayer>::SessionData,
     ) -> Result<Option<RatchetStates>, Self::StorageError>;
     /// Atomically commit the update specified by `update_data` to storage, or return an error if
     /// the update could not be made.
@@ -225,8 +232,8 @@ pub trait ApplicationLayer: Sized {
     /// Otherwise, when we restart, we will not be allowed to reconnect.
     fn save_ratchet_state(
         &mut self,
-        remote_static_key: &Self::PublicKey,
-        session_data: &Self::SessionData,
+        remote_static_key: &<Self::Crypto as CryptoLayer>::PublicKey,
+        session_data: &<Self::Crypto as CryptoLayer>::SessionData,
         update_data: RatchetUpdate<'_>,
     ) -> Result<(), Self::StorageError>;
 
@@ -234,17 +241,17 @@ pub trait ApplicationLayer: Sized {
     /// These are provided for debugging, logging or metrics purposes, and must be used for
     /// nothing else. Do not base protocol-level decisions upon the events passed to this function.
     #[cfg(feature = "logging")]
-    fn event_log(&mut self, event: LogEvent<'_, Self>);
+    fn event_log(&mut self, event: LogEvent<'_, Self::Crypto>);
 }
 
 /// A collection of fields specifying how to complete the key exchange with a specific remote peer,
 /// used by Bob, the responder, at the very last stage of the key exchange.
 ///
 /// Corresponds to the *Accept* callback of Transition Algorithm 4.
-pub struct AcceptAction<App: ApplicationLayer> {
+pub struct AcceptAction<Crypto: CryptoLayer> {
     /// The data object to be attached to the session if we successfully connect.
     /// If this field is None then we will not connect to this remote peer.
-    pub session_data: Option<App::SessionData>,
+    pub session_data: Option<Crypto::SessionData>,
     /// Whether or not we will accept a connection with the remote peer when they do not have a
     /// ratchet key that we think they should have.
     pub responder_disallows_downgrade: bool,
diff --git a/src/context.rs b/src/context.rs
index 837b856..b5855d6 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -6,7 +6,7 @@ use std::hash::Hash;
 use std::num::NonZeroU32;
 use std::sync::{Arc, Weak};
 
-use crate::application::ApplicationLayer;
+use crate::application::{ApplicationLayer, CryptoLayer};
 use crate::challenge::ChallengeContext;
 use crate::crypto::{AES_256_KEY_SIZE, AES_GCM_NONCE_SIZE};
 use crate::fragmentation::{send_with_fragmentation, DefragBuffer};
@@ -31,21 +31,21 @@ pub(crate) use log;
 /// defragment incoming packets that are not yet associated with a session.
 ///
 /// Internally this is just a clonable Arc, so it can be safely shared with multiple threads.
-pub struct Context<App: ApplicationLayer>(Arc<ContextInner<App>>);
-impl<App: ApplicationLayer> Clone for Context<App> {
+pub struct Context<Crypto: CryptoLayer>(Arc<ContextInner<Crypto>>);
+impl<Crypto: CryptoLayer> Clone for Context<Crypto> {
     fn clone(&self) -> Self {
         Self(self.0.clone())
     }
 }
 
-pub(crate) type SessionMap<App> = RefCell<HashMap<NonZeroU32, Weak<Session<App>>>>;
+pub(crate) type SessionMap<Crypto> = RefCell<HashMap<NonZeroU32, Weak<Session<Crypto>>>>;
 
-pub(crate) struct ContextInner<App: ApplicationLayer> {
-    pub(crate) rng: RefCell<App::Rng>,
-    pub(crate) s_secret: App::KeyPair,
-    pub(crate) session_map: SessionMap<App>,
-    pub(crate) sessions: RefCell<HashMap<*const Session<App>, Weak<Session<App>>>>,
-    pub(crate) b2_map: RefCell<HashMap<NonZeroU32, StateB2<App>>>,
+pub(crate) struct ContextInner<Crypto: CryptoLayer> {
+    pub(crate) rng: RefCell<Crypto::Rng>,
+    pub(crate) s_secret: Crypto::KeyPair,
+    pub(crate) session_map: SessionMap<Crypto>,
+    pub(crate) sessions: RefCell<HashMap<*const Session<Crypto>, Weak<Session<Crypto>>>>,
+    pub(crate) b2_map: RefCell<HashMap<NonZeroU32, StateB2<Crypto>>>,
 
     hello_defrag: RefCell<DefragBuffer>,
     challenge: RefCell<ChallengeContext>,
@@ -62,9 +62,9 @@ fn to_packet_nonce(n: &[u8; AES_GCM_NONCE_SIZE]) -> &[u8; PACKET_NONCE_SIZE] {
     (&n[n.len() - PACKET_NONCE_SIZE..]).try_into().unwrap()
 }
 
-impl<App: ApplicationLayer> Context<App> {
+impl<Crypto: CryptoLayer> Context<Crypto> {
     /// Create a new session context.
-    pub fn new(static_secret_key: App::KeyPair, mut rng: App::Rng) -> Self {
+    pub fn new(static_secret_key: Crypto::KeyPair, mut rng: Crypto::Rng) -> Self {
         let challenge = ChallengeContext::new(&mut rng);
         Self(Arc::new(ContextInner {
             rng: RefCell::new(rng),
@@ -93,15 +93,15 @@ impl<App: ApplicationLayer> Context<App> {
     ///   object
     /// * `identity` - Payload to be sent to Bob that contains the information necessary
     ///   for the upper protocol to authenticate and approve of Alice's identity
-    pub fn open(
+    pub fn open<App: ApplicationLayer>(
         &mut self,
         app: App,
         send: impl FnMut(Vec<u8>) -> bool,
         mut mtu: usize,
-        static_remote_key: App::PublicKey,
-        session_data: App::SessionData,
+        static_remote_key: Crypto::PublicKey,
+        session_data: Crypto::SessionData,
         identity: Vec<u8>,
-    ) -> Result<Arc<Session<App>>, OpenError<App::StorageError>> {
+    ) -> Result<Arc<Session<Crypto>>, OpenError<App::StorageError>> where App: ApplicationLayer<Crypto = Crypto>{
         mtu = mtu.max(MIN_TRANSPORT_MTU);
         if identity.len() > IDENTITY_MAX_SIZE {
             return Err(OpenError::IdentityTooLarge);
@@ -111,13 +111,13 @@ impl<App: ApplicationLayer> Context<App> {
         // Process zeta layer.
         trans_to_a1(
             app,
-            &ctx,
+            ctx,
             static_remote_key,
             session_data,
             identity,
             |Packet(kid, nonce, payload): &Packet| {
                 // Process fragmentation layer.
-                send_with_fragmentation::<App>(send, mtu, *kid, to_packet_nonce(&nonce), payload, None);
+                send_with_fragmentation::<Crypto>(send, mtu, *kid, to_packet_nonce(&nonce), payload, None);
             },
         )
     }
@@ -130,15 +130,15 @@ impl<App: ApplicationLayer> Context<App> {
     /// * `send_to` - Function to get senders for existing sessions, permitting MTU and path lookup
     /// * `remote_address` - Whatever the remote address is, as long as you can Hash it
     /// * `raw_fragment` - Buffer containing incoming wire packet
-    pub fn receive<SendFn: FnMut(Vec<u8>) -> bool>(
+    pub fn receive<App, SendFn: FnMut(Vec<u8>) -> bool>(
         &mut self,
         mut app: App,
         send_unassociated_reply: impl FnMut(Vec<u8>) -> bool,
         mut send_unassociated_mtu: usize,
-        send_to: impl FnOnce(&Arc<Session<App>>) -> Option<(SendFn, usize)>,
+        send_to: impl FnOnce(&Arc<Session<Crypto>>) -> Option<(SendFn, usize)>,
         remote_address: &impl Hash,
         raw_fragment: Vec<u8>,
-    ) -> Result<ReceiveOk<App>, ReceiveError<App::StorageError>> {
+    ) -> Result<ReceiveOk<Crypto>, ReceiveError<App::StorageError>> where App: ApplicationLayer<Crypto = Crypto> {
         use crate::result::FaultType::*;
         send_unassociated_mtu = send_unassociated_mtu.max(MIN_TRANSPORT_MTU);
         let ctx = &self.0;
@@ -187,7 +187,7 @@ impl<App: ApplicationLayer> Context<App> {
                         |Packet(kid, nonce, payload): &Packet, hk: Option<&[u8; AES_256_KEY_SIZE]>| {
                             if let Some((send_fragment, mut mtu)) = send_to(&session) {
                                 mtu = mtu.max(MIN_TRANSPORT_MTU);
-                                send_with_fragmentation::<App>(
+                                send_with_fragmentation::<Crypto>(
                                     send_fragment,
                                     mtu,
                                     *kid,
@@ -201,7 +201,7 @@ impl<App: ApplicationLayer> Context<App> {
                     let (p, _) = from_nonce(&pn);
                     let ret = match p {
                         PACKET_TYPE_DATA => {
-                            received_payload_in_place(&mut zeta, kid_recv, to_aes_nonce(&pn), &mut assembled_packet)?;
+                            received_payload_in_place::<App>(&mut zeta, kid_recv, to_aes_nonce(&pn), &mut assembled_packet)?;
                             SessionEvent::Data(assembled_packet)
                         }
                         PACKET_TYPE_HANDSHAKE_RESPONSE => {
@@ -286,7 +286,7 @@ impl<App: ApplicationLayer> Context<App> {
                         }
                         PACKET_TYPE_SESSION_REJECTED => {
                             log!(app, ReceivedRawD);
-                            received_d_trans(&mut zeta, kid_recv, to_aes_nonce(&pn), assembled_packet)?;
+                            received_d_trans::<App>(&mut zeta, kid_recv, to_aes_nonce(&pn), assembled_packet)?;
                             log!(app, DIsAuthClosedSession(&session));
                             SessionEvent::Rejected
                         }
@@ -323,7 +323,7 @@ impl<App: ApplicationLayer> Context<App> {
                             kid_recv,
                             assembled_packet,
                             |Packet(kid, nonce, payload), hk| {
-                                send_with_fragmentation::<App>(
+                                send_with_fragmentation::<Crypto>(
                                     send_unassociated_reply,
                                     send_unassociated_mtu,
                                     *kid,
@@ -369,7 +369,7 @@ impl<App: ApplicationLayer> Context<App> {
                     log!(app, ReceivedRawX1);
                     // Process recv challenge layer.
                     let challenge_start = assembled_packet.len() - CHALLENGE_SIZE;
-                    let result = ctx.challenge.borrow_mut().process_hello::<App::Hash>(
+                    let result = ctx.challenge.borrow_mut().process_hello::<Crypto::Hash>(
                         remote_address,
                         (&assembled_packet[challenge_start..]).try_into().unwrap(),
                     );
@@ -379,7 +379,7 @@ impl<App: ApplicationLayer> Context<App> {
                         challenge_packet.extend(&assembled_packet[..KID_SIZE]);
                         challenge_packet.extend(&challenge);
                         let nonce = to_nonce(PACKET_TYPE_CHALLENGE, ctx.rng.borrow_mut().next_u64());
-                        send_with_fragmentation::<App>(
+                        send_with_fragmentation::<Crypto>(
                             send_unassociated_reply,
                             send_unassociated_mtu,
                             0,
@@ -401,7 +401,7 @@ impl<App: ApplicationLayer> Context<App> {
                         to_aes_nonce(&n),
                         assembled_packet,
                         |Packet(kid, nonce, payload), hk| {
-                            send_with_fragmentation::<App>(
+                            send_with_fragmentation::<Crypto>(
                                 send_unassociated_reply,
                                 send_unassociated_mtu,
                                 *kid,
@@ -424,7 +424,7 @@ impl<App: ApplicationLayer> Context<App> {
                     {
                         if let Some(Some(session)) = ctx.session_map.borrow_mut().get(&kid_recv).map(|r| r.upgrade()) {
                             let mut zeta = session.0.borrow_mut();
-                            respond_to_challenge(
+                            respond_to_challenge::<App>(
                                 &mut zeta,
                                 &ctx.rng,
                                 &assembled_packet[KID_SIZE..].try_into().unwrap(),
@@ -454,7 +454,7 @@ impl<App: ApplicationLayer> Context<App> {
     /// * `payload` - Data to send
     pub fn send(
         &mut self,
-        session: &Arc<Session<App>>,
+        session: &Arc<Session<Crypto>>,
         send: impl FnMut(Vec<u8>) -> bool,
         mut mtu: usize,
         payload: Vec<u8>,
@@ -462,8 +462,8 @@ impl<App: ApplicationLayer> Context<App> {
         debug_assert_eq!(session.0.borrow().ctx.as_ptr(), Arc::as_ptr(&self.0));
         mtu = mtu.max(MIN_TRANSPORT_MTU);
         let mut zeta = session.0.borrow_mut();
-        send_payload(&mut zeta, payload, |Packet(kid, nonce, payload), hk| {
-            send_with_fragmentation::<App>(send, mtu, *kid, to_packet_nonce(nonce), &payload, hk);
+        send_payload::<Crypto>(&mut zeta, payload, |Packet(kid, nonce, payload), hk| {
+            send_with_fragmentation::<Crypto>(send, mtu, *kid, to_packet_nonce(nonce), &payload, hk);
         })
     }
 
@@ -474,11 +474,11 @@ impl<App: ApplicationLayer> Context<App> {
     /// a problem. It is completely fine to call this function more often than the returned interval.
     ///
     /// * `send_to` - Function to get a sender and an MTU to send something over an active session
-    pub fn service<SendFn: FnMut(Vec<u8>) -> bool>(
+    pub fn service<App, SendFn: FnMut(Vec<u8>) -> bool>(
         &mut self,
         mut app: App,
-        mut send_to: impl FnMut(&Arc<Session<App>>) -> Option<(SendFn, usize)>,
-    ) -> i64 {
+        mut send_to: impl FnMut(&Arc<Session<Crypto>>) -> Option<(SendFn, usize)>,
+    ) -> i64 where App: ApplicationLayer<Crypto = Crypto> {
         let ctx = &self.0;
         let sessions = ctx.sessions.borrow_mut();
         let current_time = app.time();
@@ -495,7 +495,7 @@ impl<App: ApplicationLayer> Context<App> {
                     |Packet(kid, nonce, payload): &Packet, hk| {
                         if let Some((send_fragment, mut mtu)) = send_to(&session) {
                             mtu = mtu.max(MIN_TRANSPORT_MTU);
-                            send_with_fragmentation::<App>(
+                            send_with_fragmentation::<Crypto>(
                                 send_fragment,
                                 mtu,
                                 *kid,
@@ -507,10 +507,10 @@ impl<App: ApplicationLayer> Context<App> {
                     },
                 );
                 next_timer = next_timer.min(zeta.next_timer());
-                zeta.defrag.service::<App>(current_time);
+                zeta.defrag.service(current_time);
             }
         }
-        ctx.hello_defrag.borrow_mut().service::<App>(current_time);
-        (App::SETTINGS.resend_time as i64).min(next_timer - current_time)
+        ctx.hello_defrag.borrow_mut().service(current_time);
+        (Crypto::SETTINGS.resend_time as i64).min(next_timer - current_time)
     }
 }
diff --git a/src/crypto_impl/mod.rs b/src/crypto_impl/mod.rs
index ccbe469..921af90 100644
--- a/src/crypto_impl/mod.rs
+++ b/src/crypto_impl/mod.rs
@@ -27,3 +27,38 @@ pub use p384;
 pub use pqc_kyber;
 #[cfg(feature = "sha2")]
 pub use sha2;
+
+/*
+TODO: wrangle the feature flags so we can provide the default set of crypto implementations below.
+use crate::application::{Settings, CryptoLayer};
+#[cfg(feature = "default")]
+pub trait CrateCryptoLayer {
+    /// These are constants that can be redefined from their defaults to change rekey
+    /// and negotiation timeout behavior. If two sides of a ZSSP session have different constants,
+    /// the protocol will tend to default to the smaller constants.
+    const SETTINGS: Settings = Settings::new_ms();
+
+    /// A user-defined error returned when the `ApplicationLayer` fails to access persistent storage
+    /// for a peer's ratchet states.
+    type StorageError: std::error::Error;
+
+    /// An arbitrary opaque object for use by the application that is attached to each session.
+    type SessionData;
+}
+
+use rand_core::OsRng;
+#[cfg(feature = "default")]
+impl<Crypto: CrateCryptoLayer> CryptoLayer for Crypto {
+    type Rng = OsRng;
+    type Prp = Aes256Crate;
+    type Aead = AesGcmCrate;
+    type Hash = Sha512Crate;
+    type PublicKey = P384CratePublicKey;
+    type KeyPair = P384CrateKeyPair;
+    type Kem = RustKyber1024PrivateKey;
+
+    type StorageError = Crypto::StorageError;
+
+    type SessionData = Crypto::SessionData;
+}
+ */
diff --git a/src/fragmentation.rs b/src/fragmentation.rs
index 55b425f..c028295 100644
--- a/src/fragmentation.rs
+++ b/src/fragmentation.rs
@@ -4,7 +4,7 @@ use std::collections::HashMap;
 
 use zeroize::Zeroizing;
 
-use crate::application::ApplicationLayer;
+use crate::application::{CryptoLayer, ApplicationLayer};
 use crate::crypto::{Aes256Prp, AES_256_KEY_SIZE};
 use crate::proto::*;
 use crate::result::{byzantine_fault, ReceiveError};
@@ -28,7 +28,7 @@ fn create_fragment_header(
 }
 
 /// Corresponds to the fragmentation algorithm described in Section 6.
-pub fn send_with_fragmentation<App: ApplicationLayer>(
+pub fn send_with_fragmentation<Crypto: CryptoLayer>(
     mut send: impl FnMut(Vec<u8>) -> bool,
     mtu: usize,
     identifier: u32,
@@ -52,7 +52,7 @@ pub fn send_with_fragmentation<App: ApplicationLayer>(
         fragment.extend(&packet[i..j]);
 
         if let Some(hk_send) = hk_send {
-            App::Prp::encrypt_in_place(
+            Crypto::Prp::encrypt_in_place(
                 hk_send,
                 (&mut fragment[HEADER_AUTH_START..HEADER_AUTH_END]).try_into().unwrap(),
             );
@@ -95,7 +95,7 @@ impl DefragBuffer {
         }
 
         if let Some(hk_recv) = self.hk_recv.as_ref() {
-            App::Prp::decrypt_in_place(
+            <App::Crypto as CryptoLayer>::Prp::decrypt_in_place(
                 hk_recv,
                 (&mut raw_fragment[HEADER_AUTH_START..HEADER_AUTH_END])
                     .try_into()
@@ -115,7 +115,7 @@ impl DefragBuffer {
             return Err(e);
         }
 
-        let expiration_time = current_time + App::SETTINGS.fragment_assembly_timeout as i64;
+        let expiration_time = current_time + App::Crypto::SETTINGS.fragment_assembly_timeout as i64;
         let mut map = self.fragment_map.borrow_mut();
         match map.entry(n) {
             Entry::Occupied(mut entry) => {
@@ -157,7 +157,7 @@ impl DefragBuffer {
         }
     }
 
-    pub fn service<App: ApplicationLayer>(&self, current_time: i64) {
+    pub fn service(&self, current_time: i64) {
         let mut map = self.fragment_map.borrow_mut();
         map.retain(|_, buffer| buffer.expiration_time < current_time);
     }
diff --git a/src/log_event.rs b/src/log_event.rs
index 3cb3948..ae01138 100644
--- a/src/log_event.rs
+++ b/src/log_event.rs
@@ -1,23 +1,23 @@
 use std::sync::Arc;
 
-use crate::application::ApplicationLayer;
+use crate::application::CryptoLayer;
 use crate::Session;
 
 /// ZSSP events that might be interesting to log or aggregate into metrics.
 #[allow(missing_docs)]
-pub enum LogEvent<'a, App: ApplicationLayer> {
-    ResentX1(&'a Arc<Session<App>>),
-    TimeoutX1(&'a Arc<Session<App>>),
+pub enum LogEvent<'a, Crypto: CryptoLayer> {
+    ResentX1(&'a Arc<Session<Crypto>>),
+    TimeoutX1(&'a Arc<Session<Crypto>>),
     TimeoutX2,
-    ResentX3(&'a Arc<Session<App>>),
-    TimeoutX3(&'a Arc<Session<App>>),
-    ResentKeyConfirm(&'a Arc<Session<App>>),
-    TimeoutKeyConfirm(&'a Arc<Session<App>>),
-    StartedRekeyingSentK1(&'a Arc<Session<App>>),
-    ResentK1(&'a Arc<Session<App>>),
-    TimeoutK1(&'a Arc<Session<App>>),
-    ResentK2(&'a Arc<Session<App>>),
-    TimeoutK2(&'a Arc<Session<App>>),
+    ResentX3(&'a Arc<Session<Crypto>>),
+    TimeoutX3(&'a Arc<Session<Crypto>>),
+    ResentKeyConfirm(&'a Arc<Session<Crypto>>),
+    TimeoutKeyConfirm(&'a Arc<Session<Crypto>>),
+    StartedRekeyingSentK1(&'a Arc<Session<Crypto>>),
+    ResentK1(&'a Arc<Session<Crypto>>),
+    TimeoutK1(&'a Arc<Session<Crypto>>),
+    ResentK2(&'a Arc<Session<Crypto>>),
+    TimeoutK2(&'a Arc<Session<Crypto>>),
     /// `(packet_type, packet_counter, fragment_no, fragment_count)`
     ReceivedRawFragment(u8, u64, usize, usize),
     ReceivedRawX1,
@@ -25,24 +25,24 @@ pub enum LogEvent<'a, App: ApplicationLayer> {
     X1SucceededChallenge,
     X1IsAuthSentX2,
     ReceivedRawChallenge,
-    ChallengeIsAuth(&'a Arc<Session<App>>),
+    ChallengeIsAuth(&'a Arc<Session<Crypto>>),
     ReceivedRawX2,
-    X2IsAuthSentX3(&'a Arc<Session<App>>),
+    X2IsAuthSentX3(&'a Arc<Session<Crypto>>),
     ReceivedRawX3,
-    X3IsAuthSentKeyConfirm(&'a Arc<Session<App>>),
+    X3IsAuthSentKeyConfirm(&'a Arc<Session<Crypto>>),
     ReceivedRawKeyConfirm,
-    KeyConfirmIsAuthSentAck(&'a Arc<Session<App>>),
+    KeyConfirmIsAuthSentAck(&'a Arc<Session<Crypto>>),
     ReceivedRawAck,
-    AckIsAuth(&'a Arc<Session<App>>),
+    AckIsAuth(&'a Arc<Session<Crypto>>),
     ReceivedRawK1,
-    K1IsAuthSentK2(&'a Arc<Session<App>>),
+    K1IsAuthSentK2(&'a Arc<Session<Crypto>>),
     ReceivedRawK2,
-    K2IsAuthSentKeyConfirm(&'a Arc<Session<App>>),
+    K2IsAuthSentKeyConfirm(&'a Arc<Session<Crypto>>),
     ReceivedRawD,
-    DIsAuthClosedSession(&'a Arc<Session<App>>),
+    DIsAuthClosedSession(&'a Arc<Session<Crypto>>),
 }
 
-impl<'a, App: ApplicationLayer> std::fmt::Debug for LogEvent<'a, App> {
+impl<'a, Crypto: CryptoLayer> std::fmt::Debug for LogEvent<'a, Crypto> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Self::ResentX1(_) => f.debug_tuple("ResentX1").finish(),
diff --git a/src/result.rs b/src/result.rs
index a3abb60..47da452 100644
--- a/src/result.rs
+++ b/src/result.rs
@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use crate::application::ApplicationLayer;
+use crate::application::CryptoLayer;
 use crate::Session;
 
 /// An error that can occur when attempting to open a session.
@@ -121,13 +121,13 @@ pub(crate) use byzantine_fault;
 
 /// Result generated by the context packet receive function, with possible payloads.
 #[derive(Clone)]
-pub enum ReceiveOk<App: ApplicationLayer> {
+pub enum ReceiveOk<Crypto: CryptoLayer> {
     /// Packet superficially appeared valid but is not associated with a session yet.
     /// This can occur because the packet was only a fragment of a larger packet,
     /// or if it was a control packet that does not go through full Noise authentication.
     Unassociated,
     /// Packet was authentic and belongs to this specific session.
-    Session(Arc<Session<App>>, SessionEvent),
+    Session(Arc<Session<Crypto>>, SessionEvent),
 }
 /// Something that can occur to an associated session when a packet is received successfully,
 /// including receiving a payload of decrypted, authenticated data.
diff --git a/src/symmetric_state.rs b/src/symmetric_state.rs
index 5388e8a..e061efb 100644
--- a/src/symmetric_state.rs
+++ b/src/symmetric_state.rs
@@ -2,19 +2,19 @@ use std::marker::PhantomData;
 
 use zeroize::Zeroizing;
 
-use crate::application::ApplicationLayer;
+use crate::application::CryptoLayer;
 use crate::crypto::*;
 use crate::proto::*;
 
-pub struct SymmetricState<App: ApplicationLayer> {
+pub struct SymmetricState<Crypto: CryptoLayer> {
     k: Zeroizing<[u8; AES_256_KEY_SIZE]>,
     ck: Zeroizing<[u8; HASHLEN]>,
     h: [u8; HASHLEN],
-    /// If anyone knows a better way to get rid of the "parameter `App` is never used" error please
-    /// let me know.
-    _app: PhantomData<fn() -> App::SessionData>,
+    /// If anyone knows a better way to get rid of the "parameter `Crypto` is never used" error
+    /// please let me know.
+    _app: PhantomData<fn() -> Crypto::SessionData>,
 }
-impl<App: ApplicationLayer> Clone for SymmetricState<App> {
+impl<Crypto: CryptoLayer> Clone for SymmetricState<Crypto> {
     fn clone(&self) -> Self {
         Self {
             k: self.k.clone(),
@@ -25,7 +25,7 @@ impl<App: ApplicationLayer> Clone for SymmetricState<App> {
     }
 }
 
-impl<App: ApplicationLayer> SymmetricState<App> {
+impl<Crypto: CryptoLayer> SymmetricState<Crypto> {
     /// HMAC-SHA512 key derivation based on KBKDF Counter Mode:
     /// https://csrc.nist.gov/publications/detail/sp/800-108/rev-1/final.
     /// Cryptographically this isn't meaningfully different from
@@ -55,18 +55,18 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         buffer.extend(&(num_outputs * 8 * HASHLEN as u16).to_be_bytes());
 
         debug_assert!(num_outputs >= 1);
-        *output1 = App::Hash::hmac(input_key_material, &buffer);
+        *output1 = Crypto::Hash::hmac(input_key_material, &buffer);
 
         if let Some(output2) = output2 {
             debug_assert!(num_outputs >= 2);
             buffer[0] = 2;
-            *output2 = App::Hash::hmac(input_key_material, &buffer);
+            *output2 = Crypto::Hash::hmac(input_key_material, &buffer);
         }
 
         if let Some(output3) = output3 {
             debug_assert!(num_outputs >= 3);
             buffer[0] = 3;
-            *output3 = App::Hash::hmac(input_key_material, &buffer);
+            *output3 = Crypto::Hash::hmac(input_key_material, &buffer);
         }
     }
 
@@ -98,7 +98,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     }
     /// Corresponds to Noise `MixHash`.
     pub fn mix_hash(&mut self, data: &[u8]) {
-        let mut hash = App::Hash::new();
+        let mut hash = Crypto::Hash::new();
         hash.update(&self.h);
         hash.update(data);
         self.h = hash.finish();
@@ -129,7 +129,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         plaintext_start: usize,
         buffer: &mut Vec<u8>,
     ) {
-        let tag = App::Aead::encrypt_in_place(&self.k, &iv, Some(&self.h), &mut buffer[plaintext_start..]);
+        let tag = Crypto::Aead::encrypt_in_place(&self.k, &iv, Some(&self.h), &mut buffer[plaintext_start..]);
         buffer.extend(&tag);
         self.mix_hash(&buffer[plaintext_start..]);
     }
@@ -141,11 +141,11 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         buffer: &mut [u8],
         tag: [u8; AES_GCM_TAG_SIZE],
     ) -> bool {
-        let mut hash = App::Hash::new();
+        let mut hash = Crypto::Hash::new();
         hash.update(&self.h);
         hash.update(buffer);
         hash.update(&tag);
-        let ret = App::Aead::decrypt_in_place(&self.k, &iv, Some(&self.h), buffer, &tag);
+        let ret = Crypto::Aead::decrypt_in_place(&self.k, &iv, Some(&self.h), buffer, &tag);
         self.h = hash.finish();
         ret
     }
diff --git a/src/zeta.rs b/src/zeta.rs
index abad602..7e8a25c 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -7,7 +7,7 @@ use std::sync::{Arc, Weak};
 use rand_core::RngCore;
 use zeroize::Zeroizing;
 
-use crate::application::{ApplicationLayer, RatchetState, RatchetStates, RatchetUpdate};
+use crate::application::{ApplicationLayer, RatchetState, RatchetStates, RatchetUpdate, CryptoLayer};
 use crate::challenge::{gen_null_response, respond_to_challenge_in_place};
 use crate::context::{log, ContextInner, SessionMap};
 use crate::crypto::*;
@@ -19,14 +19,14 @@ use crate::symmetric_state::SymmetricState;
 use crate::LogEvent::*;
 
 /// Corresponds to the Zeta State Machine found in Section 4.1.
-pub(crate) struct Zeta<App: ApplicationLayer> {
-    pub ctx: Weak<ContextInner<App>>,
+pub(crate) struct Zeta<Crypto: CryptoLayer> {
+    pub ctx: Weak<ContextInner<Crypto>>,
     /// An arbitrary application defined object associated with each session.
-    pub session_data: App::SessionData,
+    pub session_data: Crypto::SessionData,
     /// Is true if the local peer acted as Bob, the responder in the initial key exchange.
     pub was_bob: bool,
 
-    s_remote: App::PublicKey,
+    s_remote: Crypto::PublicKey,
     send_counter: u64,
     key_creation_counter: u64,
 
@@ -38,7 +38,7 @@ pub(crate) struct Zeta<App: ApplicationLayer> {
 
     resend_timer: i64,
     timeout_timer: i64,
-    pub beta: ZetaAutomata<App>,
+    pub beta: ZetaAutomata<Crypto>,
 
     pub counter_antireplay_window: [u64; COUNTER_WINDOW_MAX_OOO],
     pub defrag: DefragBuffer,
@@ -46,16 +46,16 @@ pub(crate) struct Zeta<App: ApplicationLayer> {
 /// ZeroTier Secure Session Protocol (ZSSP) Session.
 ///
 /// A FIPS/NIST compliant variant of Noise_XK with hybrid Kyber1024 PQ data forward secrecy.
-pub struct Session<App: ApplicationLayer>(pub(crate) RefCell<Zeta<App>>);
+pub struct Session<Crypto: CryptoLayer>(pub(crate) RefCell<Zeta<Crypto>>);
 
 /// Corresponds to State B_2 of the Zeta State Machine found in Section 4.1 - Definition 3.
-pub(crate) struct StateB2<App: ApplicationLayer> {
+pub(crate) struct StateB2<Crypto: CryptoLayer> {
     ratchet_state: RatchetState,
     kid_send: NonZeroU32,
     pub kid_recv: NonZeroU32,
     pub hk_send: Zeroizing<[u8; AES_256_KEY_SIZE]>,
-    e_secret: App::KeyPair,
-    noise: SymmetricState<App>,
+    e_secret: Crypto::KeyPair,
+    noise: SymmetricState<Crypto>,
     pub defrag: DefragBuffer,
 }
 
@@ -78,18 +78,18 @@ pub(crate) struct Packet(pub u32, pub [u8; AES_GCM_NONCE_SIZE], pub Vec<u8>);
 
 /// Corresponds to State A_1 of the Zeta State Machine found in Section 4.1.
 #[derive(Clone)]
-pub(crate) struct StateA1<App: ApplicationLayer> {
-    noise: SymmetricState<App>,
-    e_secret: App::KeyPair,
-    e1_secret: App::Kem,
+pub(crate) struct StateA1<Crypto: CryptoLayer> {
+    noise: SymmetricState<Crypto>,
+    e_secret: Crypto::KeyPair,
+    e1_secret: Crypto::Kem,
     identity: Vec<u8>,
     packet: Packet,
 }
 
 /// Corresponds to the ZKE Automata found in Section 4.1 - Definition 2.
-pub(crate) enum ZetaAutomata<App: ApplicationLayer> {
+pub(crate) enum ZetaAutomata<Crypto: CryptoLayer> {
     Null,
-    A1(StateA1<App>),
+    A1(StateA1<Crypto>),
     A3 {
         identity: Vec<u8>,
         packet: Packet,
@@ -97,8 +97,8 @@ pub(crate) enum ZetaAutomata<App: ApplicationLayer> {
     S1,
     S2,
     R1 {
-        noise: SymmetricState<App>,
-        e_secret: App::KeyPair,
+        noise: SymmetricState<Crypto>,
+        e_secret: Crypto::KeyPair,
         k1: Vec<u8>,
     },
     R2 {
@@ -106,24 +106,24 @@ pub(crate) enum ZetaAutomata<App: ApplicationLayer> {
     },
 }
 
-impl<App: ApplicationLayer> SymmetricState<App> {
-    fn write_e(&mut self, rng: &RefCell<App::Rng>, packet: &mut Vec<u8>) -> App::KeyPair {
-        let e_secret = App::KeyPair::generate(rng.borrow_mut().deref_mut());
+impl<Crypto: CryptoLayer> SymmetricState<Crypto> {
+    fn write_e(&mut self, rng: &RefCell<Crypto::Rng>, packet: &mut Vec<u8>) -> Crypto::KeyPair {
+        let e_secret = Crypto::KeyPair::generate(rng.borrow_mut().deref_mut());
         let pub_key = e_secret.public_key_bytes();
         packet.extend(&pub_key);
         self.mix_hash(&pub_key);
         self.mix_key(&pub_key);
         e_secret
     }
-    fn read_e(&mut self, i: &mut usize, packet: &Vec<u8>) -> Option<App::PublicKey> {
+    fn read_e(&mut self, i: &mut usize, packet: &Vec<u8>) -> Option<Crypto::PublicKey> {
         let j = *i + P384_PUBLIC_KEY_SIZE;
         let pub_key = &packet[*i..j];
         self.mix_hash(pub_key);
         self.mix_key(pub_key);
         *i = j;
-        App::PublicKey::from_bytes((pub_key).try_into().unwrap())
+        Crypto::PublicKey::from_bytes((pub_key).try_into().unwrap())
     }
-    fn mix_dh(&mut self, secret: &App::KeyPair, remote: &App::PublicKey) -> Option<()> {
+    fn mix_dh(&mut self, secret: &Crypto::KeyPair, remote: &Crypto::PublicKey) -> Option<()> {
         if let Some(ecdh) = secret.agree(&remote).map(Zeroizing::new) {
             self.mix_key(ecdh.as_ref());
             Some(())
@@ -165,11 +165,11 @@ fn gen_kid<T>(session_map: &HashMap<NonZeroU32, T>, rng: &mut impl RngCore) -> N
         }
     }
 }
-fn remap<App: ApplicationLayer>(
-    session: &Arc<Session<App>>,
-    zeta: &Zeta<App>,
-    rng: &RefCell<App::Rng>,
-    session_map: &SessionMap<App>,
+fn remap<Crypto: CryptoLayer>(
+    session: &Arc<Session<Crypto>>,
+    zeta: &Zeta<Crypto>,
+    rng: &RefCell<Crypto::Rng>,
+    session_map: &SessionMap<Crypto>,
 ) -> NonZeroU32 {
     let mut session_map = session_map.borrow_mut();
     let weak = if let Some(Some(weak)) = zeta.key_ref(true).recv.kid.as_ref().map(|kid| session_map.remove(kid)) {
@@ -182,7 +182,7 @@ fn remap<App: ApplicationLayer>(
     new_kid_recv
 }
 
-impl<App: ApplicationLayer> Zeta<App> {
+impl<Crypto: CryptoLayer> Zeta<Crypto> {
     pub(crate) fn check_counter_window(&self, c: u64) -> bool {
         let slot = &self.counter_antireplay_window[c as usize % self.counter_antireplay_window.len()];
         let adj_counter = c.saturating_add(1);
@@ -235,23 +235,23 @@ impl<App: ApplicationLayer> Zeta<App> {
             c,
             c >= self
                 .key_creation_counter
-                .saturating_add(App::SETTINGS.rekey_after_key_uses),
+                .saturating_add(Crypto::SETTINGS.rekey_after_key_uses),
         ))
     }
 }
 
 fn create_a1_state<App: ApplicationLayer>(
-    rng: &RefCell<App::Rng>,
-    s_remote: &App::PublicKey,
+    rng: &RefCell<<App::Crypto as CryptoLayer>::Rng>,
+    s_remote: &<App::Crypto as CryptoLayer>::PublicKey,
     kid_recv: NonZeroU32,
     ratchet_state1: &RatchetState,
     ratchet_state2: Option<&RatchetState>,
     identity: Vec<u8>,
-) -> Option<StateA1<App>> {
+) -> Option<StateA1<App::Crypto>> {
     //    <- s
     //    ...
     //    -> e, es, e1
-    let mut noise = SymmetricState::<App>::initialize(PROTOCOL_NAME_NOISE_XK);
+    let mut noise = SymmetricState::<App::Crypto>::initialize(PROTOCOL_NAME_NOISE_XK);
     let mut x1 = Vec::new();
     // Noise process prologue.
     let kid = kid_recv.get().to_be_bytes();
@@ -264,7 +264,7 @@ fn create_a1_state<App: ApplicationLayer>(
     noise.mix_dh(&e_secret, s_remote)?;
     // Process message pattern 1 e1 token.
     let i = x1.len();
-    let (e1_secret, e1_public) = App::Kem::generate(rng.borrow_mut().deref_mut());
+    let (e1_secret, e1_public) = <App::Crypto as CryptoLayer>::Kem::generate(rng.borrow_mut().deref_mut());
     x1.extend(&e1_public);
     noise.encrypt_and_hash_in_place(to_nonce(PACKET_TYPE_HANDSHAKE_HELLO, 0), i, &mut x1);
     // Process message pattern 1 payload.
@@ -291,12 +291,12 @@ fn create_a1_state<App: ApplicationLayer>(
 /// Corresponds to Transition Algorithm 1 found in Section 4.3.
 pub(crate) fn trans_to_a1<App: ApplicationLayer>(
     mut app: App,
-    ctx: &Arc<ContextInner<App>>,
-    s_remote: App::PublicKey,
-    session_data: App::SessionData,
+    ctx: &Arc<ContextInner<App::Crypto>>,
+    s_remote: <App::Crypto as CryptoLayer>::PublicKey,
+    session_data: <App::Crypto as CryptoLayer>::SessionData,
     identity: Vec<u8>,
     send: impl FnOnce(&Packet),
-) -> Result<Arc<Session<App>>, OpenError<App::StorageError>> {
+) -> Result<Arc<Session<App::Crypto>>, OpenError<App::StorageError>> {
     let ratchet_states = app
         .restore_by_identity(&s_remote, &session_data)
         .map_err(|e| OpenError::StorageError(e))?;
@@ -305,7 +305,7 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
     let mut session_map = ctx.session_map.borrow_mut();
     let kid_recv = gen_kid(session_map.deref(), ctx.rng.borrow_mut().deref_mut());
 
-    let a1 = create_a1_state(&ctx.rng, &s_remote, kid_recv, &state1, state2.as_ref(), identity)
+    let a1 = create_a1_state::<App>(&ctx.rng, &s_remote, kid_recv, &state1, state2.as_ref(), identity)
         .ok_or(OpenError::InvalidPublicKey)?;
     let packet = a1.packet.clone();
 
@@ -326,8 +326,8 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
         ratchet_state1: state1,
         ratchet_state2: state2,
         hk_send,
-        resend_timer: current_time + App::SETTINGS.resend_time as i64,
-        timeout_timer: current_time + App::SETTINGS.initial_offer_timeout as i64,
+        resend_timer: current_time + <App::Crypto as CryptoLayer>::SETTINGS.resend_time as i64,
+        timeout_timer: current_time + <App::Crypto as CryptoLayer>::SETTINGS.initial_offer_timeout as i64,
         beta: ZetaAutomata::A1(a1),
     };
     zeta.key_mut(true).recv.kid = Some(kid_recv);
@@ -344,13 +344,13 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
 }
 /// Corresponds to Algorithm 13 found in Section 5.
 pub(crate) fn respond_to_challenge<App: ApplicationLayer>(
-    zeta: &mut Zeta<App>,
-    rng: &RefCell<App::Rng>,
+    zeta: &mut Zeta<App::Crypto>,
+    rng: &RefCell<<App::Crypto as CryptoLayer>::Rng>,
     challenge: &[u8; CHALLENGE_SIZE],
 ) {
     if let ZetaAutomata::A1(StateA1 { packet: Packet(_, _, x1), .. }) = &mut zeta.beta {
         let response_start = x1.len() - CHALLENGE_SIZE;
-        respond_to_challenge_in_place::<App::Rng, App::Hash>(
+        respond_to_challenge_in_place::<<App::Crypto as CryptoLayer>::Rng, <App::Crypto as CryptoLayer>::Hash>(
             rng.borrow_mut().deref_mut(),
             challenge,
             (&mut x1[response_start..]).try_into().unwrap(),
@@ -360,7 +360,7 @@ pub(crate) fn respond_to_challenge<App: ApplicationLayer>(
 /// Corresponds to Transition Algorithm 2 found in Section 4.3.
 pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     app: &mut App,
-    ctx: &ContextInner<App>,
+    ctx: &ContextInner<App::Crypto>,
     n: [u8; AES_GCM_NONCE_SIZE],
     mut x1: Vec<u8>,
     send: impl FnOnce(&Packet, &[u8; AES_256_KEY_SIZE]),
@@ -376,7 +376,7 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     if &n[AES_GCM_NONCE_SIZE - 8..] != &x1[x1.len() - 8..] {
         return Err(byzantine_fault!(FailedAuth, true));
     }
-    let mut noise = SymmetricState::<App>::initialize(PROTOCOL_NAME_NOISE_XK);
+    let mut noise = SymmetricState::<App::Crypto>::initialize(PROTOCOL_NAME_NOISE_XK);
     let mut i = 0;
     // Noise process prologue.
     let j = i + KID_SIZE;
@@ -441,7 +441,7 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
         .ok_or(byzantine_fault!(FailedAuth, true))?;
     // Process message pattern 2 ekem1 token.
     let i = x2.len();
-    let (ekem1, ekem1_secret) = App::Kem::encapsulate(
+    let (ekem1, ekem1_secret) = <App::Crypto as CryptoLayer>::Kem::encapsulate(
         ctx.rng.borrow_mut().deref_mut(),
         (&x1[e1_start..e1_end]).try_into().unwrap(),
     )
@@ -489,10 +489,10 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
 }
 /// Corresponds to Transition Algorithm 3 found in Section 4.3.
 pub(crate) fn received_x2_trans<App: ApplicationLayer>(
-    zeta: &mut Zeta<App>,
-    session: &Arc<Session<App>>,
+    zeta: &mut Zeta<App::Crypto>,
+    session: &Arc<Session<App::Crypto>>,
     app: &mut App,
-    ctx: &Arc<ContextInner<App>>,
+    ctx: &Arc<ContextInner<App::Crypto>>,
     kid: NonZeroU32,
     n: [u8; AES_GCM_NONCE_SIZE],
     mut x2: Vec<u8>,
@@ -547,7 +547,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
             let payload: [u8; KID_SIZE] = x2[i..j].try_into().unwrap();
             let tag = x2[j..k].try_into().unwrap();
             // Check for which ratchet key Bob wants to use.
-            let test_ratchet_key = |ratchet_key| -> Option<(NonZeroU32, SymmetricState<App>)> {
+            let test_ratchet_key = |ratchet_key| -> Option<(NonZeroU32, SymmetricState<App::Crypto>)> {
                 let mut noise = noise.clone();
                 let mut payload = payload.clone();
                 // Process message pattern 2 psk token.
@@ -632,8 +632,8 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
             zeta.ratchet_state1 = new_ratchet_state;
             let current_time = app.time();
             zeta.key_creation_counter = zeta.send_counter;
-            zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
-            zeta.timeout_timer = current_time + App::SETTINGS.initial_offer_timeout as i64;
+            zeta.resend_timer = current_time + <App::Crypto as CryptoLayer>::SETTINGS.resend_time as i64;
+            zeta.timeout_timer = current_time + <App::Crypto as CryptoLayer>::SETTINGS.initial_offer_timeout as i64;
             let packet = Packet(kid_send.get(), n, x3);
             zeta.beta = ZetaAutomata::A3 { identity, packet: packet.clone() };
 
@@ -653,7 +653,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
     result.map(|_| should_warn_missing_ratchet)
 }
 fn send_control<App: ApplicationLayer>(
-    zeta: &mut Zeta<App>,
+    zeta: &mut Zeta<App::Crypto>,
     packet_type: u8,
     mut payload: Vec<u8>,
     send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
@@ -661,7 +661,7 @@ fn send_control<App: ApplicationLayer>(
     if let Some((c, _)) = zeta.get_counter() {
         if let (Some(kek), Some(kid)) = (zeta.key_ref(false).send.kek.as_ref(), zeta.key_ref(false).send.kid) {
             let nonce = to_nonce(packet_type, c);
-            let tag = App::Aead::encrypt_in_place(kek, &nonce, None, &mut payload);
+            let tag = <App::Crypto as CryptoLayer>::Aead::encrypt_in_place(kek, &nonce, None, &mut payload);
             payload.extend(tag);
 
             send(&Packet(kid.get(), nonce, payload), Some(&zeta.hk_send));
@@ -675,13 +675,13 @@ fn send_control<App: ApplicationLayer>(
 }
 /// Corresponds to Transition Algorithm 4 found in Section 4.3.
 pub(crate) fn received_x3_trans<App: ApplicationLayer>(
-    zeta: StateB2<App>,
+    zeta: StateB2<App::Crypto>,
     app: &mut App,
-    ctx: &Arc<ContextInner<App>>,
+    ctx: &Arc<ContextInner<App::Crypto>>,
     kid: NonZeroU32,
     mut x3: Vec<u8>,
     send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
-) -> Result<(Arc<Session<App>>, bool), ReceiveError<App::StorageError>> {
+) -> Result<(Arc<Session<App::Crypto>>, bool), ReceiveError<App::StorageError>> {
     use FaultType::*;
     //    -> s, se
     if !(HANDSHAKE_COMPLETION_MIN_SIZE..=HANDSHAKE_COMPLETION_MAX_SIZE).contains(&x3.len()) {
@@ -701,7 +701,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let s_remote =
-        App::PublicKey::from_bytes((&x3[i..j]).try_into().unwrap()).ok_or(byzantine_fault!(FailedAuth, true))?;
+        <App::Crypto as CryptoLayer>::PublicKey::from_bytes((&x3[i..j]).try_into().unwrap()).ok_or(byzantine_fault!(FailedAuth, true))?;
     i = k;
     // Process message pattern 3 se token.
     noise
@@ -727,7 +727,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
     let create_reject = || {
         let mut d = Vec::<u8>::new();
         let n = to_nonce(PACKET_TYPE_SESSION_REJECTED, c);
-        let tag = App::Aead::encrypt_in_place(&kek_send, &n, None, &mut []);
+        let tag = <App::Crypto as CryptoLayer>::Aead::encrypt_in_place(&kek_send, &n, None, &mut []);
         d.extend(&tag);
         // We just used a counter with this key, but we are not storing
         // the fact we used it in memory. This is currently ok because the
@@ -772,7 +772,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
 
                 let mut c1 = Vec::new();
                 let n = to_nonce(PACKET_TYPE_KEY_CONFIRM, c);
-                let tag = App::Aead::encrypt_in_place(&kek_send, &n, None, &mut []);
+                let tag = <App::Crypto as CryptoLayer>::Aead::encrypt_in_place(&kek_send, &n, None, &mut []);
                 c1.extend(&tag);
 
                 let (nk1, nk2) = noise.split();
@@ -802,8 +802,8 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                     ratchet_state1: new_ratchet_state,
                     ratchet_state2: None,
                     hk_send: zeta.hk_send.clone(),
-                    resend_timer: current_time + App::SETTINGS.resend_time as i64,
-                    timeout_timer: current_time + App::SETTINGS.rekey_timeout as i64,
+                    resend_timer: current_time + <App::Crypto as CryptoLayer>::SETTINGS.resend_time as i64,
+                    timeout_timer: current_time + <App::Crypto as CryptoLayer>::SETTINGS.rekey_timeout as i64,
                     beta: ZetaAutomata::S1,
                     counter_antireplay_window: std::array::from_fn(|_| 0),
                     defrag: zeta.defrag,
@@ -827,9 +827,9 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
 }
 /// Corresponds to Transition Algorithm 5 found in Section 4.3.
 pub(crate) fn received_c1_trans<App: ApplicationLayer>(
-    zeta: &mut Zeta<App>,
+    zeta: &mut Zeta<App::Crypto>,
     app: &mut App,
-    rng: &RefCell<App::Rng>,
+    rng: &RefCell<<App::Crypto as CryptoLayer>::Rng>,
     kid: NonZeroU32,
     n: [u8; AES_GCM_NONCE_SIZE],
     c1: Vec<u8>,
@@ -857,7 +857,7 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
         .as_ref()
         .ok_or(byzantine_fault!(OutOfSequence, true))?;
     let tag = c1[..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(specified_key, &n, None, &mut [], tag) {
+    if !<App::Crypto as CryptoLayer>::Aead::decrypt_in_place(specified_key, &n, None, &mut [], tag) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let (_, c) = from_nonce(&n);
@@ -887,14 +887,14 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
 
             zeta.ratchet_state2 = None;
             zeta.key_index ^= true;
-            let r = rng.borrow_mut().next_u64() % App::SETTINGS.rekey_time_max_jitter;
-            zeta.timeout_timer = app.time() + App::SETTINGS.rekey_after_time.saturating_sub(r) as i64;
+            let r = rng.borrow_mut().next_u64() % <App::Crypto as CryptoLayer>::SETTINGS.rekey_time_max_jitter;
+            zeta.timeout_timer = app.time() + <App::Crypto as CryptoLayer>::SETTINGS.rekey_after_time.saturating_sub(r) as i64;
             zeta.resend_timer = i64::MAX;
             zeta.beta = ZetaAutomata::S2;
         }
     }
     let c2 = Vec::new();
-    if !send_control(zeta, PACKET_TYPE_ACK, c2, send) {
+    if !send_control::<App>(zeta, PACKET_TYPE_ACK, c2, send) {
         return Err(byzantine_fault!(OutOfSequence, true));
     }
 
@@ -903,9 +903,9 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
 /// Corresponds to the trivial Transition Algorithm described for processing C_2 packets found in
 /// Section 4.3.
 pub(crate) fn received_c2_trans<App: ApplicationLayer>(
-    zeta: &mut Zeta<App>,
+    zeta: &mut Zeta<App::Crypto>,
     app: &mut App,
-    rng: &RefCell<App::Rng>,
+    rng: &RefCell<<App::Crypto as CryptoLayer>::Rng>,
     kid: NonZeroU32,
     n: [u8; AES_GCM_NONCE_SIZE],
     c2: Vec<u8>,
@@ -925,7 +925,7 @@ pub(crate) fn received_c2_trans<App: ApplicationLayer>(
     }
 
     let tag = c2[..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(zeta.key_ref(false).recv.kek.as_ref().unwrap(), &n, None, &mut [], tag) {
+    if !<App::Crypto as CryptoLayer>::Aead::decrypt_in_place(zeta.key_ref(false).recv.kek.as_ref().unwrap(), &n, None, &mut [], tag) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let (_, c) = from_nonce(&n);
@@ -933,8 +933,8 @@ pub(crate) fn received_c2_trans<App: ApplicationLayer>(
         return Err(byzantine_fault!(ExpiredCounter, true));
     }
 
-    let r = rng.borrow_mut().next_u64() % App::SETTINGS.rekey_time_max_jitter;
-    zeta.timeout_timer = app.time() + App::SETTINGS.rekey_after_time.saturating_sub(r) as i64;
+    let r = rng.borrow_mut().next_u64() % <App::Crypto as CryptoLayer>::SETTINGS.rekey_time_max_jitter;
+    zeta.timeout_timer = app.time() + <App::Crypto as CryptoLayer>::SETTINGS.rekey_after_time.saturating_sub(r) as i64;
     zeta.resend_timer = i64::MAX;
     zeta.beta = ZetaAutomata::S2;
     Ok(())
@@ -942,7 +942,7 @@ pub(crate) fn received_c2_trans<App: ApplicationLayer>(
 /// Corresponds to the trivial Transition Algorithm described for processing D packets found in
 /// Section 4.3.
 pub(crate) fn received_d_trans<App: ApplicationLayer>(
-    zeta: &mut Zeta<App>,
+    zeta: &mut Zeta<App::Crypto>,
     kid: NonZeroU32,
     n: [u8; AES_GCM_NONCE_SIZE],
     d: Vec<u8>,
@@ -957,7 +957,7 @@ pub(crate) fn received_d_trans<App: ApplicationLayer>(
     }
 
     let tag = d[..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(zeta.key_ref(true).recv.kek.as_ref().unwrap(), &n, None, &mut [], tag) {
+    if !<App::Crypto as CryptoLayer>::Aead::decrypt_in_place(zeta.key_ref(true).recv.kek.as_ref().unwrap(), &n, None, &mut [], tag) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let (_, c) = from_nonce(&n);
@@ -970,9 +970,9 @@ pub(crate) fn received_d_trans<App: ApplicationLayer>(
 }
 /// Corresponds to the timer rules of the Zeta State Machine found in Section 4.1 - Definition 3.
 pub(crate) fn service<App: ApplicationLayer>(
-    zeta: &mut Zeta<App>,
-    session: &Arc<Session<App>>,
-    ctx: &Arc<ContextInner<App>>,
+    zeta: &mut Zeta<App::Crypto>,
+    session: &Arc<Session<App::Crypto>>,
+    ctx: &Arc<ContextInner<App::Crypto>>,
     app: &mut App,
     current_time: i64,
     send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
@@ -981,7 +981,7 @@ pub(crate) fn service<App: ApplicationLayer>(
         timeout_trans(zeta, session, app, ctx, current_time, send);
     } else if zeta.resend_timer <= current_time {
         // Corresponds to the resend timer rules found in Section 4.1 - Definition 3.
-        zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
+        zeta.resend_timer = current_time + <App::Crypto as CryptoLayer>::SETTINGS.resend_time as i64;
 
         let (p, control_payload) = match &zeta.beta {
             ZetaAutomata::Null => return,
@@ -1008,15 +1008,15 @@ pub(crate) fn service<App: ApplicationLayer>(
             }
         };
 
-        send_control(zeta, p, control_payload, send);
+        send_control::<App>(zeta, p, control_payload, send);
     }
 }
 /// Corresponds to the timeout timer Transition Algorithm described in Section 4.1 - Definition 3.
 fn timeout_trans<App: ApplicationLayer>(
-    zeta: &mut Zeta<App>,
-    session: &Arc<Session<App>>,
+    zeta: &mut Zeta<App::Crypto>,
+    session: &Arc<Session<App::Crypto>>,
     app: &mut App,
-    ctx: &Arc<ContextInner<App>>,
+    ctx: &Arc<ContextInner<App::Crypto>>,
     current_time: i64,
     send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
 ) {
@@ -1030,7 +1030,7 @@ fn timeout_trans<App: ApplicationLayer>(
             }
             let new_kid_recv = remap(session, &zeta, &ctx.rng, &ctx.session_map);
 
-            if let Some(a1) = create_a1_state(
+            if let Some(a1) = create_a1_state::<App>(
                 &ctx.rng,
                 &zeta.s_remote,
                 new_kid_recv,
@@ -1044,8 +1044,8 @@ fn timeout_trans<App: ApplicationLayer>(
                 zeta.hk_send = hk_send;
                 *zeta.key_mut(true) = DuplexKey::default();
                 zeta.key_mut(true).recv.kid = Some(new_kid_recv);
-                zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
-                zeta.timeout_timer = current_time + App::SETTINGS.initial_offer_timeout as i64;
+                zeta.resend_timer = current_time + <App::Crypto as CryptoLayer>::SETTINGS.resend_time as i64;
+                zeta.timeout_timer = current_time + <App::Crypto as CryptoLayer>::SETTINGS.initial_offer_timeout as i64;
                 zeta.beta = ZetaAutomata::A1(a1);
                 zeta.defrag = DefragBuffer::new(Some(hk_recv));
 
@@ -1087,11 +1087,11 @@ fn timeout_trans<App: ApplicationLayer>(
             noise.encrypt_and_hash_in_place(to_nonce(PACKET_TYPE_REKEY_INIT, 0), i, &mut k1);
 
             zeta.key_mut(true).recv.kid = Some(new_kid_recv);
-            zeta.timeout_timer = current_time + App::SETTINGS.rekey_timeout as i64;
-            zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
+            zeta.timeout_timer = current_time + <App::Crypto as CryptoLayer>::SETTINGS.rekey_timeout as i64;
+            zeta.resend_timer = current_time + <App::Crypto as CryptoLayer>::SETTINGS.resend_time as i64;
             zeta.beta = ZetaAutomata::R1 { noise, e_secret, k1: k1.clone() };
 
-            send_control(zeta, PACKET_TYPE_REKEY_INIT, k1, send);
+            send_control::<App>(zeta, PACKET_TYPE_REKEY_INIT, k1, send);
         }
         ZetaAutomata::S1 { .. } => {
             log!(app, TimeoutKeyConfirm(session));
@@ -1109,12 +1109,12 @@ fn timeout_trans<App: ApplicationLayer>(
 }
 /// Corresponds to Transition Algorithm 7 found in Section 4.3.
 pub(crate) fn received_k1_trans<App: ApplicationLayer>(
-    zeta: &mut Zeta<App>,
-    session: &Arc<Session<App>>,
+    zeta: &mut Zeta<App::Crypto>,
+    session: &Arc<Session<App::Crypto>>,
     app: &mut App,
-    rng: &RefCell<App::Rng>,
-    session_map: &SessionMap<App>,
-    s_secret: &App::KeyPair,
+    rng: &RefCell<<App::Crypto as CryptoLayer>::Rng>,
+    session_map: &SessionMap<App::Crypto>,
+    s_secret: &<App::Crypto as CryptoLayer>::KeyPair,
     kid: NonZeroU32,
     n: [u8; AES_GCM_NONCE_SIZE],
     mut k1: Vec<u8>,
@@ -1145,7 +1145,7 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
 
     let i = k1.len() - AES_GCM_TAG_SIZE;
     let tag = k1[i..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(
+    if !<App::Crypto as CryptoLayer>::Aead::decrypt_in_place(
         zeta.key_ref(false).recv.kek.as_ref().unwrap(),
         &n,
         None,
@@ -1162,7 +1162,7 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
 
     let result = (|| {
         let mut i = 0;
-        let mut noise = SymmetricState::<App>::initialize(PROTOCOL_NAME_NOISE_KK);
+        let mut noise = SymmetricState::<App::Crypto>::initialize(PROTOCOL_NAME_NOISE_KK);
         // Noise process prologue.
         noise.mix_hash(&zeta.s_remote.to_bytes());
         noise.mix_hash(&s_secret.public_key_bytes());
@@ -1234,11 +1234,11 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
         zeta.ratchet_state1 = new_ratchet_state;
         let current_time = app.time();
         zeta.key_creation_counter = zeta.send_counter;
-        zeta.timeout_timer = current_time + App::SETTINGS.rekey_timeout as i64;
-        zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
+        zeta.timeout_timer = current_time + <App::Crypto as CryptoLayer>::SETTINGS.rekey_timeout as i64;
+        zeta.resend_timer = current_time + <App::Crypto as CryptoLayer>::SETTINGS.resend_time as i64;
         zeta.beta = ZetaAutomata::R2 { k2: k2.clone() };
 
-        send_control(zeta, PACKET_TYPE_REKEY_COMPLETE, k2, send);
+        send_control::<App>(zeta, PACKET_TYPE_REKEY_COMPLETE, k2, send);
         Ok(())
     })();
     if matches!(result, Err(ReceiveError::ByzantineFault { .. })) {
@@ -1248,7 +1248,7 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
 }
 /// Corresponds to Transition Algorithm 8 found in Section 4.3.
 pub(crate) fn received_k2_trans<App: ApplicationLayer>(
-    zeta: &mut Zeta<App>,
+    zeta: &mut Zeta<App::Crypto>,
     app: &mut App,
     kid: NonZeroU32,
     n: [u8; AES_GCM_NONCE_SIZE],
@@ -1271,7 +1271,7 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
 
     let i = k2.len() - AES_GCM_TAG_SIZE;
     let tag = k2[i..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(
+    if !<App::Crypto as CryptoLayer>::Aead::decrypt_in_place(
         zeta.key_ref(false).recv.kek.as_ref().unwrap(),
         &n,
         None,
@@ -1337,12 +1337,12 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
             zeta.key_index ^= true;
             let current_time = app.time();
             zeta.key_creation_counter = zeta.send_counter;
-            zeta.timeout_timer = current_time + App::SETTINGS.rekey_timeout as i64;
-            zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
+            zeta.timeout_timer = current_time + <App::Crypto as CryptoLayer>::SETTINGS.rekey_timeout as i64;
+            zeta.resend_timer = current_time + <App::Crypto as CryptoLayer>::SETTINGS.resend_time as i64;
             zeta.beta = ZetaAutomata::S1;
 
             let c1 = Vec::new();
-            send_control(zeta, PACKET_TYPE_KEY_CONFIRM, c1, send);
+            send_control::<App>(zeta, PACKET_TYPE_KEY_CONFIRM, c1, send);
             Ok(())
         } else {
             unreachable!()
@@ -1354,8 +1354,8 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
     result
 }
 /// Corresponds to Algorithm 9 found in Section 4.3.
-pub(crate) fn send_payload<App: ApplicationLayer>(
-    zeta: &mut Zeta<App>,
+pub(crate) fn send_payload<Crypto: CryptoLayer>(
+    zeta: &mut Zeta<Crypto>,
     mut payload: Vec<u8>,
     send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
 ) -> Result<(), SendError> {
@@ -1377,7 +1377,7 @@ pub(crate) fn send_payload<App: ApplicationLayer>(
         }
 
         let n = to_nonce(PACKET_TYPE_DATA, c);
-        let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.nk.as_ref().unwrap(), &n, None, &mut payload);
+        let tag = Crypto::Aead::encrypt_in_place(zeta.key_ref(false).send.nk.as_ref().unwrap(), &n, None, &mut payload);
         payload.extend(&tag);
 
         send(
@@ -1392,7 +1392,7 @@ pub(crate) fn send_payload<App: ApplicationLayer>(
 }
 /// Corresponds to Algorithm 10 found in Section 4.3.
 pub(crate) fn received_payload_in_place<App: ApplicationLayer>(
-    zeta: &mut Zeta<App>,
+    zeta: &mut Zeta<App::Crypto>,
     kid: NonZeroU32,
     n: [u8; AES_GCM_NONCE_SIZE],
     payload: &mut Vec<u8>,
@@ -1416,7 +1416,7 @@ pub(crate) fn received_payload_in_place<App: ApplicationLayer>(
     let specified_key = zeta.key_ref(is_other).recv.nk.as_ref();
     let specified_key = specified_key.ok_or(byzantine_fault!(OutOfSequence, true))?;
     let tag = payload[i..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(specified_key, &n, None, &mut payload[..i], &tag) {
+    if !<App::Crypto as CryptoLayer>::Aead::decrypt_in_place(specified_key, &n, None, &mut payload[..i], &tag) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let (_, c) = from_nonce(&n);
@@ -1430,7 +1430,7 @@ pub(crate) fn received_payload_in_place<App: ApplicationLayer>(
     Ok(())
 }
 
-impl<App: ApplicationLayer> Session<App> {
+impl<Crypto: CryptoLayer> Session<Crypto> {
     /// Mark a session as expired. This will make it impossible for this session to successfully
     /// receive or send data or control packets. It is recommended to simply `drop` the session
     /// instead, but this can provide some reassurance in complex shared ownership situations.
@@ -1439,7 +1439,7 @@ impl<App: ApplicationLayer> Session<App> {
     }
 }
 
-impl<App: ApplicationLayer> Drop for Session<App> {
+impl<Crypto: CryptoLayer> Drop for Session<Crypto> {
     fn drop(&mut self) {
         self.expire();
     }