From ce31915e301825bc6769396bba4aa7bcf0ec7c2b Mon Sep 17 00:00:00 2001 From: John Reed <87283488+JohnReedV@users.noreply.github.com> Date: Wed, 31 Jul 2024 09:55:10 -0700 Subject: [PATCH 1/9] add delegate id --- docs/delegate-info.json | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/docs/delegate-info.json b/docs/delegate-info.json index bda41b48e..46355da3d 100644 --- a/docs/delegate-info.json +++ b/docs/delegate-info.json @@ -390,5 +390,12 @@ "url": "https://cortex.foundation/", "description": "Cortex Foundation is committed to advancing the integration of decentralized AI. Our validator is designed for transparency, reliability, and community engagement.", "signature": "7a6274ff6b0f7ddca97e37ef4a9b90781012ff3cf7baa3159f6feaafc43c557975aad324ea608d6b8abeb21f8f3ca2595e54b81a7564574d0242b803d969618a" + }, + { + "address":"5F27Eqz2PhyMtGMEce898x31DokNqRVxkm5AhDDe6rDGNvoY", + "name": "Love", + "url": "https://love.cosimo.fund", + "description": "Love validator exists to accelerate open source AI and be good stewards of the Bittensorr network", + "signature": "c221a3de3be031c149a7be912b3b75e0355605f041dc975153302b23b4d93e45e9cc7453532491e92076ccd333a4c1f95f4a2229aae8f4fcfb88e5dec3f14c87" } ] \ No newline at end of file From ad827b4620a3e8736b7437dba31a08df690bddcb Mon Sep 17 00:00:00 2001 From: John Reed <87283488+JohnReedV@users.noreply.github.com> Date: Wed, 31 Jul 2024 19:04:45 -0700 Subject: [PATCH 2/9] add swap & tests --- pallets/subtensor/src/macros/errors.rs | 4 + pallets/subtensor/src/swap/swap_coldkey.rs | 15 +- pallets/subtensor/src/utils/identity.rs | 28 ++++ pallets/subtensor/tests/serving.rs | 180 ++++++++++++++++++++- 4 files changed, 221 insertions(+), 6 deletions(-) diff --git a/pallets/subtensor/src/macros/errors.rs b/pallets/subtensor/src/macros/errors.rs index 07710dc5f..d3e228ec5 100644 --- a/pallets/subtensor/src/macros/errors.rs +++ b/pallets/subtensor/src/macros/errors.rs @@ -170,5 +170,9 @@ mod errors { TxRateLimitExceeded, /// Invalid identity. InvalidIdentity, + /// The old coldkey does not have an identity. + OldColdkeyNotFound, + /// The new coldkey already has an identity. + NewColdkeyInUse, } } diff --git a/pallets/subtensor/src/swap/swap_coldkey.rs b/pallets/subtensor/src/swap/swap_coldkey.rs index bd8a11fa1..082114d94 100644 --- a/pallets/subtensor/src/swap/swap_coldkey.rs +++ b/pallets/subtensor/src/swap/swap_coldkey.rs @@ -64,23 +64,28 @@ impl Pallet { Self::remove_balance_from_coldkey_account(&old_coldkey, swap_cost)?; Self::burn_tokens(actual_burn_amount); - // 7. Update the weight for the balance operations + // 7. Swap identity if the old coldkey has one. + if Identities::::contains_key(&old_coldkey) { + Self::swap_delegate_identity_coldkey(&old_coldkey, new_coldkey)?; + } + + // 8. Update the weight for the balance operations weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1)); - // 8. Perform the actual coldkey swap + // 9. Perform the actual coldkey swap let _ = Self::perform_swap_coldkey(&old_coldkey, new_coldkey, &mut weight); - // 9. Update the last transaction block for the new coldkey + // 10. Update the last transaction block for the new coldkey Self::set_last_tx_block(new_coldkey, Self::get_current_block_as_u64()); weight.saturating_accrue(T::DbWeight::get().writes(1)); - // 10. Emit the ColdkeySwapped event + // 11. Emit the ColdkeySwapped event Self::deposit_event(Event::ColdkeySwapped { old_coldkey: old_coldkey.clone(), new_coldkey: new_coldkey.clone(), }); - // 11. Return the result with the updated weight + // 12. Return the result with the updated weight Ok(Some(weight).into()) } diff --git a/pallets/subtensor/src/utils/identity.rs b/pallets/subtensor/src/utils/identity.rs index 1c9c3c25d..11d3677d1 100644 --- a/pallets/subtensor/src/utils/identity.rs +++ b/pallets/subtensor/src/utils/identity.rs @@ -106,4 +106,32 @@ impl Pallet { && identity.description.len() <= 1024 && identity.additional.len() <= 1024 } + + /// Swaps the hotkey of a delegate identity from an old account ID to a new account ID. + /// + /// # Parameters + /// - `old_hotkey`: A reference to the current account ID (old hotkey) of the delegate identity. + /// - `new_hotkey`: A reference to the new account ID (new hotkey) to be assigned to the delegate identity. + /// + /// # Returns + /// - `Result<(), SwapError>`: Returns `Ok(())` if the swap is successful. Returns `Err(SwapError)` otherwise. + pub fn swap_delegate_identity_coldkey( + old_coldkey: &T::AccountId, + new_coldkey: &T::AccountId, + ) -> DispatchResult { + // Attempt to remove the identity associated with the old hotkey. + let identity: ChainIdentity = + Identities::::take(old_coldkey).ok_or(Error::::OldColdkeyNotFound)?; + + // Ensure the new hotkey is not already in use. + if Identities::::contains_key(new_coldkey) { + // Reinsert the identity back with the old hotkey to maintain consistency. + Identities::::insert(old_coldkey, identity); + return Err(Error::::NewColdkeyInUse.into()); + } + + // Insert the identity with the new hotkey. + Identities::::insert(new_coldkey, identity); + Ok(()) + } } diff --git a/pallets/subtensor/tests/serving.rs b/pallets/subtensor/tests/serving.rs index b0eada8e6..564db2238 100644 --- a/pallets/subtensor/tests/serving.rs +++ b/pallets/subtensor/tests/serving.rs @@ -1,7 +1,7 @@ use crate::mock::*; mod mock; -use frame_support::assert_noop; use frame_support::pallet_prelude::Weight; +use frame_support::{assert_err, assert_noop}; use frame_support::{ assert_ok, dispatch::{DispatchClass, DispatchInfo, GetDispatchInfo, Pays}, @@ -827,3 +827,181 @@ fn test_migrate_set_hotkey_identities() { ); }); } + +#[test] +fn test_swap_delegate_identity_coldkey_successful() { + new_test_ext(1).execute_with(|| { + let old_coldkey = U256::from(1); + let new_coldkey = U256::from(2); + + let name = b"Second Coolest Identity".to_vec(); + let old_identity = ChainIdentity { + name: name.clone(), + url: vec![], + image: vec![], + discord: vec![], + description: vec![], + additional: vec![], + }; + + // Set identity for the old coldkey + Identities::::insert(old_coldkey, old_identity.clone()); + + // Swap the coldkey + assert_ok!(SubtensorModule::swap_delegate_identity_coldkey( + &old_coldkey, + &new_coldkey + )); + assert!(Identities::::get(new_coldkey).is_some()); + assert!(Identities::::get(old_coldkey).is_none()); + + // Verify the identity information is correctly swapped + let identity: ChainIdentity = + Identities::::get(new_coldkey).expect("Expected an Identity"); + assert_eq!(identity.name, name); + }); +} + +#[test] +fn test_swap_delegate_identity_coldkey_new_coldkey_already_exists() { + new_test_ext(1).execute_with(|| { + let old_coldkey = U256::from(1); + let new_coldkey = U256::from(2); + + let old_identity = ChainIdentity { + name: b"Old Identity".to_vec(), + url: vec![], + image: vec![], + discord: vec![], + description: vec![], + additional: vec![], + }; + let new_identity = ChainIdentity { + name: b"New Identity".to_vec(), + url: vec![], + image: vec![], + discord: vec![], + description: vec![], + additional: vec![], + }; + + // Add identity for old coldkey and new coldkey + Identities::::insert(old_coldkey, old_identity.clone()); + Identities::::insert(new_coldkey, new_identity.clone()); + + // Attempt to swap coldkey to one that is already in use + assert_err!( + SubtensorModule::swap_delegate_identity_coldkey(&old_coldkey, &new_coldkey), + Error::::NewColdkeyInUse + ); + + // Verify both identities remain unchanged + let stored_old_identity: ChainIdentity = + Identities::::get(old_coldkey).expect("Expected an Identity"); + assert_eq!(stored_old_identity.name, old_identity.name); + + let stored_new_identity: ChainIdentity = + Identities::::get(new_coldkey).expect("Expected an Identity"); + assert_eq!(stored_new_identity.name, new_identity.name); + }); +} + +#[test] +fn test_swap_delegate_identity_coldkey_old_coldkey_does_not_exist() { + new_test_ext(1).execute_with(|| { + let old_coldkey = U256::from(1); + let new_coldkey = U256::from(2); + + // Ensure old coldkey does not exist + assert!(Identities::::get(old_coldkey).is_none()); + + assert_err!( + SubtensorModule::swap_delegate_identity_coldkey(&old_coldkey, &new_coldkey), + Error::::OldColdkeyNotFound + ); + assert!(Identities::::get(new_coldkey).is_none()); + }); +} + +#[test] +fn test_coldkey_swap_delegate_identity_updated() { + new_test_ext(1).execute_with(|| { + let old_coldkey = U256::from(1); + let new_coldkey = U256::from(2); + + let netuid = 1; + let burn_cost = 10; + let tempo = 1; + + SubtensorModule::set_burn(netuid, burn_cost); + add_network(netuid, tempo, 0); + + SubtensorModule::add_balance_to_coldkey_account(&old_coldkey, 100_000_000_000); + + assert_ok!(SubtensorModule::burned_register( + <::RuntimeOrigin>::signed(old_coldkey), + netuid, + old_coldkey + )); + + let name: Vec = b"The Third Coolest Identity".to_vec(); + let identity: ChainIdentity = ChainIdentity { + name: name.clone(), + url: vec![], + image: vec![], + discord: vec![], + description: vec![], + additional: vec![], + }; + + Identities::::insert(old_coldkey, identity.clone()); + + assert_ok!(SubtensorModule::do_swap_coldkey( + <::RuntimeOrigin>::signed(old_coldkey), + &new_coldkey + )); + + assert!(Identities::::get(old_coldkey).is_none()); + assert!(Identities::::get(new_coldkey).is_some()); + assert_eq!( + Identities::::get(new_coldkey).expect("Expected an Identity"), + identity + ); + }); +} + +#[test] +fn test_coldkey_swap_no_identity_no_changes() { + new_test_ext(1).execute_with(|| { + let old_coldkey = U256::from(1); + let new_coldkey = U256::from(2); + + let netuid = 1; + let burn_cost = 10; + let tempo = 1; + + SubtensorModule::set_burn(netuid, burn_cost); + add_network(netuid, tempo, 0); + + SubtensorModule::add_balance_to_coldkey_account(&old_coldkey, 100_000_000_000); + + assert_ok!(SubtensorModule::burned_register( + <::RuntimeOrigin>::signed(old_coldkey), + netuid, + old_coldkey + )); + + // Ensure the old coldkey does not have an identity before the swap + assert!(Identities::::get(old_coldkey).is_none()); + + // Perform the coldkey swap + assert_ok!(SubtensorModule::do_swap_coldkey( + <::RuntimeOrigin>::signed(old_coldkey), + &new_coldkey, + )); + + // Ensure no identities have been changed + assert!(Identities::::get(old_coldkey).is_none()); + assert!(Identities::::get(new_coldkey).is_none()); + }); +} From 9d13693b5537eb11fefd23b1a961e1e49ed4c9bc Mon Sep 17 00:00:00 2001 From: John Reed <87283488+JohnReedV@users.noreply.github.com> Date: Wed, 31 Jul 2024 20:09:54 -0700 Subject: [PATCH 3/9] expand check --- pallets/subtensor/src/swap/swap_coldkey.rs | 14 ++++--- pallets/subtensor/tests/serving.rs | 47 ++++++++++++++++++++++ 2 files changed, 55 insertions(+), 6 deletions(-) diff --git a/pallets/subtensor/src/swap/swap_coldkey.rs b/pallets/subtensor/src/swap/swap_coldkey.rs index 082114d94..ca57cf994 100644 --- a/pallets/subtensor/src/swap/swap_coldkey.rs +++ b/pallets/subtensor/src/swap/swap_coldkey.rs @@ -59,16 +59,18 @@ impl Pallet { Error::::NotEnoughBalanceToPaySwapColdKey ); - // 6. Remove and burn the swap cost from the old coldkey's account + // 6. Swap identity if the old coldkey has one. + if Identities::::contains_key(&old_coldkey) + && !Identities::::contains_key(new_coldkey) + { + Self::swap_delegate_identity_coldkey(&old_coldkey, new_coldkey)?; + } + + // 7. Remove and burn the swap cost from the old coldkey's account let actual_burn_amount = Self::remove_balance_from_coldkey_account(&old_coldkey, swap_cost)?; Self::burn_tokens(actual_burn_amount); - // 7. Swap identity if the old coldkey has one. - if Identities::::contains_key(&old_coldkey) { - Self::swap_delegate_identity_coldkey(&old_coldkey, new_coldkey)?; - } - // 8. Update the weight for the balance operations weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1)); diff --git a/pallets/subtensor/tests/serving.rs b/pallets/subtensor/tests/serving.rs index 564db2238..914a891de 100644 --- a/pallets/subtensor/tests/serving.rs +++ b/pallets/subtensor/tests/serving.rs @@ -1005,3 +1005,50 @@ fn test_coldkey_swap_no_identity_no_changes() { assert!(Identities::::get(new_coldkey).is_none()); }); } + +#[test] +fn test_coldkey_swap_no_identity_no_changes_newcoldkey_exists() { + new_test_ext(1).execute_with(|| { + let old_coldkey_2 = U256::from(3); + let new_coldkey_2 = U256::from(4); + + let netuid = 1; + let burn_cost = 10; + let tempo = 1; + + SubtensorModule::set_burn(netuid, burn_cost); + add_network(netuid, tempo, 0); + SubtensorModule::add_balance_to_coldkey_account(&old_coldkey_2, 100_000_000_000); + + assert_ok!(SubtensorModule::burned_register( + <::RuntimeOrigin>::signed(old_coldkey_2), + netuid, + old_coldkey_2 + )); + + let name: Vec = b"The Coolest Identity".to_vec(); + let identity: ChainIdentity = ChainIdentity { + name: name.clone(), + url: vec![], + image: vec![], + discord: vec![], + description: vec![], + additional: vec![], + }; + + Identities::::insert(new_coldkey_2, identity.clone()); + // Ensure the new coldkey does have an identity before the swap + assert!(Identities::::get(new_coldkey_2).is_some()); + assert!(Identities::::get(old_coldkey_2).is_none()); + + // Perform the coldkey swap + assert_ok!(SubtensorModule::do_swap_coldkey( + <::RuntimeOrigin>::signed(old_coldkey_2), + &new_coldkey_2, + )); + + // Ensure no identities have been changed + assert!(Identities::::get(old_coldkey_2).is_none()); + assert!(Identities::::get(new_coldkey_2).is_some()); + }); +} From 3ce54bd44045c1307762f8140ca61f47d40c69e4 Mon Sep 17 00:00:00 2001 From: John Reed <87283488+JohnReedV@users.noreply.github.com> Date: Wed, 31 Jul 2024 20:15:20 -0700 Subject: [PATCH 4/9] fix doc comment --- pallets/subtensor/src/utils/identity.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pallets/subtensor/src/utils/identity.rs b/pallets/subtensor/src/utils/identity.rs index 11d3677d1..8cf7b4ef0 100644 --- a/pallets/subtensor/src/utils/identity.rs +++ b/pallets/subtensor/src/utils/identity.rs @@ -114,7 +114,7 @@ impl Pallet { /// - `new_hotkey`: A reference to the new account ID (new hotkey) to be assigned to the delegate identity. /// /// # Returns - /// - `Result<(), SwapError>`: Returns `Ok(())` if the swap is successful. Returns `Err(SwapError)` otherwise. + /// - `DispatchResult`: Returns `Ok(())` if the swap is successful. Returns an error variant of `DispatchResult` otherwise. pub fn swap_delegate_identity_coldkey( old_coldkey: &T::AccountId, new_coldkey: &T::AccountId, From 28a00fefefd285f3c8bb5d6d993f71bf4954da2e Mon Sep 17 00:00:00 2001 From: John Reed <87283488+JohnReedV@users.noreply.github.com> Date: Thu, 1 Aug 2024 10:11:34 -0700 Subject: [PATCH 5/9] remove swap_id_coldkey fn --- pallets/subtensor/src/macros/errors.rs | 4 - pallets/subtensor/src/swap/swap_coldkey.rs | 14 ++- pallets/subtensor/src/utils/identity.rs | 28 ------ pallets/subtensor/tests/serving.rs | 100 +-------------------- 4 files changed, 10 insertions(+), 136 deletions(-) diff --git a/pallets/subtensor/src/macros/errors.rs b/pallets/subtensor/src/macros/errors.rs index d3e228ec5..07710dc5f 100644 --- a/pallets/subtensor/src/macros/errors.rs +++ b/pallets/subtensor/src/macros/errors.rs @@ -170,9 +170,5 @@ mod errors { TxRateLimitExceeded, /// Invalid identity. InvalidIdentity, - /// The old coldkey does not have an identity. - OldColdkeyNotFound, - /// The new coldkey already has an identity. - NewColdkeyInUse, } } diff --git a/pallets/subtensor/src/swap/swap_coldkey.rs b/pallets/subtensor/src/swap/swap_coldkey.rs index ca57cf994..b3fadfa70 100644 --- a/pallets/subtensor/src/swap/swap_coldkey.rs +++ b/pallets/subtensor/src/swap/swap_coldkey.rs @@ -51,7 +51,12 @@ impl Pallet { Error::::ColdKeyAlreadyAssociated ); - // 5. Calculate the swap cost and ensure sufficient balance + // 5. Swap the identity if the old coldkey has one + if let Some(identity) = Identities::::take(&old_coldkey) { + Identities::::insert(new_coldkey, identity); + } + + // 6. Calculate the swap cost and ensure sufficient balance let swap_cost = Self::get_key_swap_cost(); log::debug!("Coldkey swap cost: {:?}", swap_cost); ensure!( @@ -59,13 +64,6 @@ impl Pallet { Error::::NotEnoughBalanceToPaySwapColdKey ); - // 6. Swap identity if the old coldkey has one. - if Identities::::contains_key(&old_coldkey) - && !Identities::::contains_key(new_coldkey) - { - Self::swap_delegate_identity_coldkey(&old_coldkey, new_coldkey)?; - } - // 7. Remove and burn the swap cost from the old coldkey's account let actual_burn_amount = Self::remove_balance_from_coldkey_account(&old_coldkey, swap_cost)?; diff --git a/pallets/subtensor/src/utils/identity.rs b/pallets/subtensor/src/utils/identity.rs index 8cf7b4ef0..1c9c3c25d 100644 --- a/pallets/subtensor/src/utils/identity.rs +++ b/pallets/subtensor/src/utils/identity.rs @@ -106,32 +106,4 @@ impl Pallet { && identity.description.len() <= 1024 && identity.additional.len() <= 1024 } - - /// Swaps the hotkey of a delegate identity from an old account ID to a new account ID. - /// - /// # Parameters - /// - `old_hotkey`: A reference to the current account ID (old hotkey) of the delegate identity. - /// - `new_hotkey`: A reference to the new account ID (new hotkey) to be assigned to the delegate identity. - /// - /// # Returns - /// - `DispatchResult`: Returns `Ok(())` if the swap is successful. Returns an error variant of `DispatchResult` otherwise. - pub fn swap_delegate_identity_coldkey( - old_coldkey: &T::AccountId, - new_coldkey: &T::AccountId, - ) -> DispatchResult { - // Attempt to remove the identity associated with the old hotkey. - let identity: ChainIdentity = - Identities::::take(old_coldkey).ok_or(Error::::OldColdkeyNotFound)?; - - // Ensure the new hotkey is not already in use. - if Identities::::contains_key(new_coldkey) { - // Reinsert the identity back with the old hotkey to maintain consistency. - Identities::::insert(old_coldkey, identity); - return Err(Error::::NewColdkeyInUse.into()); - } - - // Insert the identity with the new hotkey. - Identities::::insert(new_coldkey, identity); - Ok(()) - } } diff --git a/pallets/subtensor/tests/serving.rs b/pallets/subtensor/tests/serving.rs index 914a891de..8dd371acb 100644 --- a/pallets/subtensor/tests/serving.rs +++ b/pallets/subtensor/tests/serving.rs @@ -1,7 +1,7 @@ use crate::mock::*; mod mock; +use frame_support::assert_noop; use frame_support::pallet_prelude::Weight; -use frame_support::{assert_err, assert_noop}; use frame_support::{ assert_ok, dispatch::{DispatchClass, DispatchInfo, GetDispatchInfo, Pays}, @@ -828,101 +828,6 @@ fn test_migrate_set_hotkey_identities() { }); } -#[test] -fn test_swap_delegate_identity_coldkey_successful() { - new_test_ext(1).execute_with(|| { - let old_coldkey = U256::from(1); - let new_coldkey = U256::from(2); - - let name = b"Second Coolest Identity".to_vec(); - let old_identity = ChainIdentity { - name: name.clone(), - url: vec![], - image: vec![], - discord: vec![], - description: vec![], - additional: vec![], - }; - - // Set identity for the old coldkey - Identities::::insert(old_coldkey, old_identity.clone()); - - // Swap the coldkey - assert_ok!(SubtensorModule::swap_delegate_identity_coldkey( - &old_coldkey, - &new_coldkey - )); - assert!(Identities::::get(new_coldkey).is_some()); - assert!(Identities::::get(old_coldkey).is_none()); - - // Verify the identity information is correctly swapped - let identity: ChainIdentity = - Identities::::get(new_coldkey).expect("Expected an Identity"); - assert_eq!(identity.name, name); - }); -} - -#[test] -fn test_swap_delegate_identity_coldkey_new_coldkey_already_exists() { - new_test_ext(1).execute_with(|| { - let old_coldkey = U256::from(1); - let new_coldkey = U256::from(2); - - let old_identity = ChainIdentity { - name: b"Old Identity".to_vec(), - url: vec![], - image: vec![], - discord: vec![], - description: vec![], - additional: vec![], - }; - let new_identity = ChainIdentity { - name: b"New Identity".to_vec(), - url: vec![], - image: vec![], - discord: vec![], - description: vec![], - additional: vec![], - }; - - // Add identity for old coldkey and new coldkey - Identities::::insert(old_coldkey, old_identity.clone()); - Identities::::insert(new_coldkey, new_identity.clone()); - - // Attempt to swap coldkey to one that is already in use - assert_err!( - SubtensorModule::swap_delegate_identity_coldkey(&old_coldkey, &new_coldkey), - Error::::NewColdkeyInUse - ); - - // Verify both identities remain unchanged - let stored_old_identity: ChainIdentity = - Identities::::get(old_coldkey).expect("Expected an Identity"); - assert_eq!(stored_old_identity.name, old_identity.name); - - let stored_new_identity: ChainIdentity = - Identities::::get(new_coldkey).expect("Expected an Identity"); - assert_eq!(stored_new_identity.name, new_identity.name); - }); -} - -#[test] -fn test_swap_delegate_identity_coldkey_old_coldkey_does_not_exist() { - new_test_ext(1).execute_with(|| { - let old_coldkey = U256::from(1); - let new_coldkey = U256::from(2); - - // Ensure old coldkey does not exist - assert!(Identities::::get(old_coldkey).is_none()); - - assert_err!( - SubtensorModule::swap_delegate_identity_coldkey(&old_coldkey, &new_coldkey), - Error::::OldColdkeyNotFound - ); - assert!(Identities::::get(new_coldkey).is_none()); - }); -} - #[test] fn test_coldkey_swap_delegate_identity_updated() { new_test_ext(1).execute_with(|| { @@ -956,6 +861,9 @@ fn test_coldkey_swap_delegate_identity_updated() { Identities::::insert(old_coldkey, identity.clone()); + assert!(Identities::::get(old_coldkey).is_some()); + assert!(Identities::::get(new_coldkey).is_none()); + assert_ok!(SubtensorModule::do_swap_coldkey( <::RuntimeOrigin>::signed(old_coldkey), &new_coldkey From 7058b51beb737d92b73ee8289f9f6bd71a85d371 Mon Sep 17 00:00:00 2001 From: John Reed <87283488+JohnReedV@users.noreply.github.com> Date: Fri, 2 Aug 2024 07:59:35 -0700 Subject: [PATCH 6/9] update & move tests --- pallets/subtensor/tests/serving.rs | 133 -------------------- pallets/subtensor/tests/swap_coldkey.rs | 157 ++++++++++++++++++++++++ 2 files changed, 157 insertions(+), 133 deletions(-) diff --git a/pallets/subtensor/tests/serving.rs b/pallets/subtensor/tests/serving.rs index 8dd371acb..b0eada8e6 100644 --- a/pallets/subtensor/tests/serving.rs +++ b/pallets/subtensor/tests/serving.rs @@ -827,136 +827,3 @@ fn test_migrate_set_hotkey_identities() { ); }); } - -#[test] -fn test_coldkey_swap_delegate_identity_updated() { - new_test_ext(1).execute_with(|| { - let old_coldkey = U256::from(1); - let new_coldkey = U256::from(2); - - let netuid = 1; - let burn_cost = 10; - let tempo = 1; - - SubtensorModule::set_burn(netuid, burn_cost); - add_network(netuid, tempo, 0); - - SubtensorModule::add_balance_to_coldkey_account(&old_coldkey, 100_000_000_000); - - assert_ok!(SubtensorModule::burned_register( - <::RuntimeOrigin>::signed(old_coldkey), - netuid, - old_coldkey - )); - - let name: Vec = b"The Third Coolest Identity".to_vec(); - let identity: ChainIdentity = ChainIdentity { - name: name.clone(), - url: vec![], - image: vec![], - discord: vec![], - description: vec![], - additional: vec![], - }; - - Identities::::insert(old_coldkey, identity.clone()); - - assert!(Identities::::get(old_coldkey).is_some()); - assert!(Identities::::get(new_coldkey).is_none()); - - assert_ok!(SubtensorModule::do_swap_coldkey( - <::RuntimeOrigin>::signed(old_coldkey), - &new_coldkey - )); - - assert!(Identities::::get(old_coldkey).is_none()); - assert!(Identities::::get(new_coldkey).is_some()); - assert_eq!( - Identities::::get(new_coldkey).expect("Expected an Identity"), - identity - ); - }); -} - -#[test] -fn test_coldkey_swap_no_identity_no_changes() { - new_test_ext(1).execute_with(|| { - let old_coldkey = U256::from(1); - let new_coldkey = U256::from(2); - - let netuid = 1; - let burn_cost = 10; - let tempo = 1; - - SubtensorModule::set_burn(netuid, burn_cost); - add_network(netuid, tempo, 0); - - SubtensorModule::add_balance_to_coldkey_account(&old_coldkey, 100_000_000_000); - - assert_ok!(SubtensorModule::burned_register( - <::RuntimeOrigin>::signed(old_coldkey), - netuid, - old_coldkey - )); - - // Ensure the old coldkey does not have an identity before the swap - assert!(Identities::::get(old_coldkey).is_none()); - - // Perform the coldkey swap - assert_ok!(SubtensorModule::do_swap_coldkey( - <::RuntimeOrigin>::signed(old_coldkey), - &new_coldkey, - )); - - // Ensure no identities have been changed - assert!(Identities::::get(old_coldkey).is_none()); - assert!(Identities::::get(new_coldkey).is_none()); - }); -} - -#[test] -fn test_coldkey_swap_no_identity_no_changes_newcoldkey_exists() { - new_test_ext(1).execute_with(|| { - let old_coldkey_2 = U256::from(3); - let new_coldkey_2 = U256::from(4); - - let netuid = 1; - let burn_cost = 10; - let tempo = 1; - - SubtensorModule::set_burn(netuid, burn_cost); - add_network(netuid, tempo, 0); - SubtensorModule::add_balance_to_coldkey_account(&old_coldkey_2, 100_000_000_000); - - assert_ok!(SubtensorModule::burned_register( - <::RuntimeOrigin>::signed(old_coldkey_2), - netuid, - old_coldkey_2 - )); - - let name: Vec = b"The Coolest Identity".to_vec(); - let identity: ChainIdentity = ChainIdentity { - name: name.clone(), - url: vec![], - image: vec![], - discord: vec![], - description: vec![], - additional: vec![], - }; - - Identities::::insert(new_coldkey_2, identity.clone()); - // Ensure the new coldkey does have an identity before the swap - assert!(Identities::::get(new_coldkey_2).is_some()); - assert!(Identities::::get(old_coldkey_2).is_none()); - - // Perform the coldkey swap - assert_ok!(SubtensorModule::do_swap_coldkey( - <::RuntimeOrigin>::signed(old_coldkey_2), - &new_coldkey_2, - )); - - // Ensure no identities have been changed - assert!(Identities::::get(old_coldkey_2).is_none()); - assert!(Identities::::get(new_coldkey_2).is_some()); - }); -} diff --git a/pallets/subtensor/tests/swap_coldkey.rs b/pallets/subtensor/tests/swap_coldkey.rs index 9203e2b3f..a4fddfe90 100644 --- a/pallets/subtensor/tests/swap_coldkey.rs +++ b/pallets/subtensor/tests/swap_coldkey.rs @@ -523,6 +523,22 @@ fn test_do_swap_coldkey_success() { stake_amount2 )); + // Insert an Identity + let name: Vec = b"The fourth Coolest Identity".to_vec(); + let identity: ChainIdentity = ChainIdentity { + name: name.clone(), + url: vec![], + image: vec![], + discord: vec![], + description: vec![], + additional: vec![], + }; + + Identities::::insert(old_coldkey, identity.clone()); + + assert!(Identities::::get(old_coldkey).is_some()); + assert!(Identities::::get(new_coldkey).is_none()); + // Log state after adding stake log::info!( "Total stake after adding: {}", @@ -594,6 +610,14 @@ fn test_do_swap_coldkey_success() { "Total stake changed unexpectedly" ); + // Verify identities were swapped + assert!(Identities::::get(old_coldkey).is_none()); + assert!(Identities::::get(new_coldkey).is_some()); + assert_eq!( + Identities::::get(new_coldkey).expect("Expected an Identity"), + identity + ); + // Verify event emission System::assert_last_event( Event::ColdkeySwapped { @@ -1286,3 +1310,136 @@ fn test_coldkey_delegations() { assert_eq!(Stake::::get(delegate, coldkey), 0); }); } + +#[test] +fn test_coldkey_swap_delegate_identity_updated() { + new_test_ext(1).execute_with(|| { + let old_coldkey = U256::from(1); + let new_coldkey = U256::from(2); + + let netuid = 1; + let burn_cost = 10; + let tempo = 1; + + SubtensorModule::set_burn(netuid, burn_cost); + add_network(netuid, tempo, 0); + + SubtensorModule::add_balance_to_coldkey_account(&old_coldkey, 100_000_000_000); + + assert_ok!(SubtensorModule::burned_register( + <::RuntimeOrigin>::signed(old_coldkey), + netuid, + old_coldkey + )); + + let name: Vec = b"The Third Coolest Identity".to_vec(); + let identity: ChainIdentity = ChainIdentity { + name: name.clone(), + url: vec![], + image: vec![], + discord: vec![], + description: vec![], + additional: vec![], + }; + + Identities::::insert(old_coldkey, identity.clone()); + + assert!(Identities::::get(old_coldkey).is_some()); + assert!(Identities::::get(new_coldkey).is_none()); + + assert_ok!(SubtensorModule::do_swap_coldkey( + <::RuntimeOrigin>::signed(old_coldkey), + &new_coldkey + )); + + assert!(Identities::::get(old_coldkey).is_none()); + assert!(Identities::::get(new_coldkey).is_some()); + assert_eq!( + Identities::::get(new_coldkey).expect("Expected an Identity"), + identity + ); + }); +} + +#[test] +fn test_coldkey_swap_no_identity_no_changes() { + new_test_ext(1).execute_with(|| { + let old_coldkey = U256::from(1); + let new_coldkey = U256::from(2); + + let netuid = 1; + let burn_cost = 10; + let tempo = 1; + + SubtensorModule::set_burn(netuid, burn_cost); + add_network(netuid, tempo, 0); + + SubtensorModule::add_balance_to_coldkey_account(&old_coldkey, 100_000_000_000); + + assert_ok!(SubtensorModule::burned_register( + <::RuntimeOrigin>::signed(old_coldkey), + netuid, + old_coldkey + )); + + // Ensure the old coldkey does not have an identity before the swap + assert!(Identities::::get(old_coldkey).is_none()); + + // Perform the coldkey swap + assert_ok!(SubtensorModule::do_swap_coldkey( + <::RuntimeOrigin>::signed(old_coldkey), + &new_coldkey, + )); + + // Ensure no identities have been changed + assert!(Identities::::get(old_coldkey).is_none()); + assert!(Identities::::get(new_coldkey).is_none()); + }); +} + +#[test] +fn test_coldkey_swap_no_identity_no_changes_newcoldkey_exists() { + new_test_ext(1).execute_with(|| { + let old_coldkey_2 = U256::from(3); + let new_coldkey_2 = U256::from(4); + + let netuid = 1; + let burn_cost = 10; + let tempo = 1; + + SubtensorModule::set_burn(netuid, burn_cost); + add_network(netuid, tempo, 0); + SubtensorModule::add_balance_to_coldkey_account(&old_coldkey_2, 100_000_000_000); + + assert_ok!(SubtensorModule::burned_register( + <::RuntimeOrigin>::signed(old_coldkey_2), + netuid, + old_coldkey_2 + )); + + let name: Vec = b"The Coolest Identity".to_vec(); + let identity: ChainIdentity = ChainIdentity { + name: name.clone(), + url: vec![], + image: vec![], + discord: vec![], + description: vec![], + additional: vec![], + }; + + Identities::::insert(new_coldkey_2, identity.clone()); + // Ensure the new coldkey does have an identity before the swap + assert!(Identities::::get(new_coldkey_2).is_some()); + assert!(Identities::::get(old_coldkey_2).is_none()); + + // Perform the coldkey swap + assert_ok!(SubtensorModule::do_swap_coldkey( + <::RuntimeOrigin>::signed(old_coldkey_2), + &new_coldkey_2, + )); + + // Ensure no identities have been changed + assert!(Identities::::get(old_coldkey_2).is_none()); + assert!(Identities::::get(new_coldkey_2).is_some()); + }); +} From 2fc87ca7b8eed5f2ae2a72ee924bd30632b43339 Mon Sep 17 00:00:00 2001 From: John Reed <87283488+JohnReedV@users.noreply.github.com> Date: Fri, 2 Aug 2024 12:18:33 -0700 Subject: [PATCH 7/9] add swap_coldkey benchmark --- pallets/subtensor/src/benchmarks.rs | 57 ++++++++++++++++++++++ pallets/subtensor/src/macros/dispatches.rs | 7 +-- 2 files changed, 61 insertions(+), 3 deletions(-) diff --git a/pallets/subtensor/src/benchmarks.rs b/pallets/subtensor/src/benchmarks.rs index 03e087a92..e30cf9027 100644 --- a/pallets/subtensor/src/benchmarks.rs +++ b/pallets/subtensor/src/benchmarks.rs @@ -429,4 +429,61 @@ reveal_weights { }: reveal_weights(RawOrigin::Signed(hotkey.clone()), netuid, uids, weight_values, salt, version_key) + swap_coldkey { + // Set up initial state + let old_coldkey: T::AccountId = account("old_coldkey", 0, 0); + let new_coldkey: T::AccountId = account("new_coldkey", 0, 0); + let hotkey1: T::AccountId = account("hotkey1", 0, 0); + let netuid = 1u16; + let stake_amount1 = 1000u64; + let stake_amount2 = 2000u64; + let swap_cost = Subtensor::::get_key_swap_cost(); + let free_balance_old = 12345u64 + swap_cost; + let tempo: u16 = 1; + + // Setup initial state + Subtensor::::init_new_network(netuid, tempo); + Subtensor::::set_network_registration_allowed(netuid, true); + Subtensor::::set_network_pow_registration_allowed(netuid, true); + + let block_number: u64 = Subtensor::::get_current_block_as_u64(); + let (nonce, work): (u64, Vec) = Subtensor::::create_work_for_block_number( + netuid, + block_number, + 3, + &hotkey1, + ); + + let _ = Subtensor::::register( + ::RuntimeOrigin::from(RawOrigin::Signed(old_coldkey.clone())), + netuid, + block_number, + nonce, + work.clone(), + hotkey1.clone(), + old_coldkey.clone(), + ); + + // Add balance to old coldkey + Subtensor::::add_balance_to_coldkey_account( + &old_coldkey, + stake_amount1 + stake_amount2 + free_balance_old, + ); + + // Insert an Identity + let name: Vec = b"The fourth Coolest Identity".to_vec(); + let identity: ChainIdentity = ChainIdentity { + name: name.clone(), + url: vec![], + image: vec![], + discord: vec![], + description: vec![], + additional: vec![], + }; + + Identities::::insert(&old_coldkey, identity); + + // Benchmark setup complete, now execute the extrinsic +}: swap_coldkey(RawOrigin::Signed(old_coldkey.clone()), new_coldkey.clone()) + } diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs index 00865f8db..8057e9dd4 100644 --- a/pallets/subtensor/src/macros/dispatches.rs +++ b/pallets/subtensor/src/macros/dispatches.rs @@ -668,9 +668,10 @@ mod dispatches { /// /// Weight is calculated based on the number of database reads and writes. #[pallet::call_index(71)] - #[pallet::weight((Weight::from_parts(1_940_000_000, 0) - .saturating_add(T::DbWeight::get().reads(272)) - .saturating_add(T::DbWeight::get().writes(527)), DispatchClass::Operational, Pays::No))] + #[pallet::weight((Weight::from_parts(127_713_000, 0) + .saturating_add(Weight::from_parts(0, 11645)) + .saturating_add(T::DbWeight::get().reads(18)) + .saturating_add(T::DbWeight::get().writes(12)), DispatchClass::Operational, Pays::No))] pub fn swap_coldkey( origin: OriginFor, new_coldkey: T::AccountId, From dcb198f3b154b770cc605897b182ddeaf45408ac Mon Sep 17 00:00:00 2001 From: unconst Date: Sat, 3 Aug 2024 16:51:59 -0500 Subject: [PATCH 8/9] initial --- lock.ipynb | 412 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 412 insertions(+) create mode 100644 lock.ipynb diff --git a/lock.ipynb b/lock.ipynb new file mode 100644 index 000000000..cb7425f1f --- /dev/null +++ b/lock.ipynb @@ -0,0 +1,412 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import math\n", + "\n", + "def calculate_conviction(lock_amount: int, end_day: int, current_day: int, interval: int) -> int:\n", + " lock_duration = max(end_day - current_day, 0)\n", + " time_factor = -lock_duration / interval \n", + " exp_term = 1 - math.exp(time_factor)\n", + " conviction_score = lock_amount * exp_term\n", + " return int(conviction_score)\n", + "\n", + "\n", + "def calculate_max_allowed_unstakable(alpha_locked: int, end_day: int, current_day: int, interval: int) -> int:\n", + " return alpha_locked - calculate_conviction(alpha_locked, end_day=end_day, current_day = current_day, interval=interval)\n", + " \n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Define intervals from 10 days to 3 years\n", + "intervals = [10, 30, 90, 180, 365, 365*2, 365*3]\n", + "\n", + "# Generate data for 3 years (assuming 1 block per day for simplicity)\n", + "days = range(0, 365)\n", + "\n", + "# Create the plot\n", + "plt.figure(figsize=(12, 6))\n", + "\n", + "for interval in intervals:\n", + " unstakable_amounts = [calculate_max_allowed_unstakable(1000, 365, day, interval=interval) for day in days]\n", + " plt.plot(days, unstakable_amounts, label=f'{interval} days')\n", + "\n", + "plt.title('Max Allowed Unstakable Amount Over 3 Years')\n", + "plt.xlabel('Days')\n", + "plt.ylabel('Max Allowed Unstakable Amount')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import math\n", + "\n", + "def calculate_conviction(lock_amount: int, end_day: int, current_day: int, interval: int) -> int:\n", + " lock_duration = max(end_day - current_day, 0)\n", + " time_factor = -lock_duration / interval \n", + " exp_term = 1 - math.exp(time_factor)\n", + " conviction_score = lock_amount * exp_term\n", + " return int(conviction_score)\n", + "\n", + "# Calculate conviction for 1000 over a range of durations from 10 days to a year\n", + "lock_amount = 1000\n", + "interval = 180\n", + "duration = 365\n", + "\n", + "plt.figure(figsize=(12, 6))\n", + "\n", + "unlockable = [0]\n", + "days = range(0, duration + 1) # +1 to include the last day\n", + "locked_amount = []\n", + "convictions = []\n", + "unlockable = [0]\n", + "for day in days:\n", + " current_locked = lock_amount + (7200 * 0.18 * day) - unlockable[day-1] * 0\n", + " locked_amount.append(current_locked)\n", + " conviction = calculate_conviction(current_locked, duration, day, interval=interval)\n", + " convictions.append(conviction)\n", + " unlockable.append(current_locked - conviction)\n", + "\n", + "plt.plot(days, convictions, label=f'Conviction ({duration} days)')\n", + "plt.plot(days, locked_amount, label=f'Locked Amount ({duration} days)')\n", + "plt.plot(days, unlockable[:-1], label=f'Unlockable ({duration} days)', linestyle='--')\n", + "\n", + "plt.title('Conviction Score for Various Lock Durations')\n", + "plt.xlabel('Days')\n", + "plt.ylabel('Conviction Score')\n", + "plt.grid(True)\n", + "plt.legend()\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Lion's Share Distribution:\n", + "Participant_0's lock: 6974, share: 0.0072\n", + "Participant_1's lock: 9165, share: 0.8613\n", + "Participant_2's lock: 8303, share: 0.1312\n", + "Participant_3's lock: 5278, share: 0.0002\n", + "Participant_4's lock: 2642, share: 0.0000\n", + "Participant_5's lock: 4272, share: 0.0000\n", + "Participant_6's lock: 4160, share: 0.0000\n", + "Participant_7's lock: 2101, share: 0.0000\n", + "Participant_8's lock: 3090, share: 0.0000\n", + "Participant_9's lock: 4980, share: 0.0001\n", + "\n", + "Lion's Share Skew Factors:\n", + "Participant_0's skew factor: 0.0528\n", + "Participant_1's skew factor: 4.7893\n", + "Participant_2's skew factor: 0.8054\n", + "Participant_3's skew factor: 0.0017\n", + "Participant_4's skew factor: 0.0000\n", + "Participant_5's skew factor: 0.0002\n", + "Participant_6's skew factor: 0.0002\n", + "Participant_7's skew factor: 0.0000\n", + "Participant_8's skew factor: 0.0000\n", + "Participant_9's skew factor: 0.0010\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "def calculate_conviction(lock_amount: int, end_day: int, current_day: int, interval: int) -> int:\n", + " lock_duration = max(end_day - current_day, 0)\n", + " time_factor = -lock_duration / interval \n", + " exp_term = 1 - math.exp(time_factor)\n", + " conviction_score = lock_amount * exp_term\n", + " return int(conviction_score)\n", + "\n", + "\n", + "import random\n", + "\n", + "interval = 365\n", + "duration = 365\n", + "N = 10 # Number of participants\n", + "temperature = 5 # Adjust this value to control the steepness of the sigmoid\n", + "\n", + "# Generate random lock amounts for N participants\n", + "participants = [f\"Participant_{i}\" for i in range(N)]\n", + "locks = [random.randint(10, 10000) for _ in range(N)]\n", + "\n", + "# Calculate convictions\n", + "convictions = [calculate_conviction(lock, duration, 0, interval) for lock in locks]\n", + "\n", + "# Calculate mean conviction\n", + "mean_conviction = sum(convictions) / len(convictions)\n", + "\n", + "# Calculate powered convictions using sigmoid function\n", + "powered_convictions = [1 / (1 + math.exp(-(conv - mean_conviction) / temperature)) for conv in convictions]\n", + "\n", + "# Calculate total powered conviction\n", + "total_powered = sum(powered_convictions)\n", + "\n", + "# Calculate shares\n", + "shares = [powered / total_powered for powered in powered_convictions]\n", + "\n", + "# # Print results\n", + "# for i, (participant, lock, share) in enumerate(zip(participants, locks, shares)):\n", + "# print(f\"{participant}'s lock: {lock}, share: {share:.4f}\")\n", + "\n", + "# # Calculate and print skew factors\n", + "# base_ratio = locks[0] / sum(locks)\n", + "# for i, (participant, lock, share) in enumerate(zip(participants, locks, shares)):\n", + "# skew_factor = (share / base_ratio) / (lock / locks[0])\n", + "# print(f\"{participant}'s skew factor: {skew_factor:.4f}\")\n", + "\n", + "\n", + "import numpy as np\n", + "\n", + "# Function to calculate the \"lion's share\" distribution\n", + "def calculate_lions_share(convictions, sharpness=20):\n", + " # Normalize convictions\n", + " normalized_convictions = np.array(convictions) / np.max(convictions)\n", + " \n", + " # Apply exponential function to create a sharp drop-off\n", + " powered_convictions = np.exp(sharpness * (normalized_convictions - 1))\n", + " \n", + " # Calculate shares\n", + " total_powered = np.sum(powered_convictions)\n", + " shares = powered_convictions / total_powered\n", + " \n", + " return shares\n", + "\n", + "# Calculate convictions\n", + "convictions = [calculate_conviction(lock, duration, 0, interval) for lock in locks]\n", + "\n", + "# Calculate shares using the lion's share distribution\n", + "lions_shares = calculate_lions_share(convictions)\n", + "\n", + "# Print results\n", + "print(\"\\nLion's Share Distribution:\")\n", + "for i, (participant, lock, share) in enumerate(zip(participants, locks, lions_shares)):\n", + " print(f\"{participant}'s lock: {lock}, share: {share:.4f}\")\n", + "\n", + "# Calculate and print skew factors for lion's share\n", + "base_ratio = locks[0] / sum(locks)\n", + "print(\"\\nLion's Share Skew Factors:\")\n", + "for i, (participant, lock, share) in enumerate(zip(participants, locks, lions_shares)):\n", + " skew_factor = (share / base_ratio) / (lock / locks[0])\n", + " print(f\"{participant}'s skew factor: {skew_factor:.4f}\")\n", + "\n", + "# Visualize the difference between sigmoid and lion's share distributions\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.figure(figsize=(12, 6))\n", + "plt.plot(range(N), sorted(shares, reverse=True), 'b-', label='Sigmoid Distribution')\n", + "plt.plot(range(N), sorted(lions_shares, reverse=True), 'r-', label=\"Lion's Share Distribution\")\n", + "plt.xlabel('Participant Rank')\n", + "plt.ylabel('Share')\n", + "plt.title('Comparison of Sigmoid and Lion\\'s Share Distributions')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Lion's Share Distribution:\n", + "Participant_0's lock: 3916, share: 0.0015\n", + "Participant_1's lock: 440, share: 0.0000\n", + "Participant_2's lock: 8807, share: 0.3472\n", + "Participant_3's lock: 8077, share: 0.1545\n", + "Participant_4's lock: 6539, share: 0.0281\n", + "Participant_5's lock: 6470, share: 0.0260\n", + "Participant_6's lock: 148, share: 0.0000\n", + "Participant_7's lock: 701, share: 0.0000\n", + "Participant_8's lock: 2765, share: 0.0004\n", + "Participant_9's lock: 9026, share: 0.4422\n", + "\n", + "Lion's Share Skew Factors:\n", + "Participant_0's skew factor: 0.0184\n", + "Participant_1's skew factor: 0.0035\n", + "Participant_2's skew factor: 1.8483\n", + "Participant_3's skew factor: 0.8967\n", + "Participant_4's skew factor: 0.2016\n", + "Participant_5's skew factor: 0.1886\n", + "Participant_6's skew factor: 0.0075\n", + "Participant_7's skew factor: 0.0029\n", + "Participant_8's skew factor: 0.0073\n", + "Participant_9's skew factor: 2.2970\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "\n", + "# Function to calculate the \"lion's share\" distribution\n", + "def calculate_lions_share(convictions, sharpness=10):\n", + " # Normalize convictions\n", + " normalized_convictions = np.array(convictions) / np.max(convictions)\n", + " \n", + " # Apply exponential function to create a sharp drop-off\n", + " powered_convictions = np.exp(sharpness * (normalized_convictions - 1))\n", + " \n", + " # Calculate shares\n", + " total_powered = np.sum(powered_convictions)\n", + " shares = powered_convictions / total_powered\n", + " \n", + " return shares\n", + "\n", + "# Calculate convictions\n", + "convictions = [calculate_conviction(lock, duration, 0, interval) for lock in locks]\n", + "\n", + "# Calculate shares using the lion's share distribution\n", + "lions_shares = calculate_lions_share(convictions)\n", + "\n", + "# Print results\n", + "print(\"\\nLion's Share Distribution:\")\n", + "for i, (participant, lock, share) in enumerate(zip(participants, locks, lions_shares)):\n", + " print(f\"{participant}'s lock: {lock}, share: {share:.4f}\")\n", + "\n", + "# Calculate and print skew factors for lion's share\n", + "base_ratio = locks[0] / sum(locks)\n", + "print(\"\\nLion's Share Skew Factors:\")\n", + "for i, (participant, lock, share) in enumerate(zip(participants, locks, lions_shares)):\n", + " skew_factor = (share / base_ratio) / (lock / locks[0])\n", + " print(f\"{participant}'s skew factor: {skew_factor:.4f}\")\n", + "\n", + "# Visualize the difference between sigmoid and lion's share distributions\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.figure(figsize=(12, 6))\n", + "plt.plot(range(N), sorted(shares, reverse=True), 'b-', label='Sigmoid Distribution')\n", + "plt.plot(range(N), sorted(lions_shares, reverse=True), 'r-', label=\"Lion's Share Distribution\")\n", + "plt.xlabel('Participant Rank')\n", + "plt.ylabel('Share')\n", + "plt.title('Comparison of Sigmoid and Lion\\'s Share Distributions')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "770" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import math\n", + "\n", + "def calculate_conviction(lock_amount: int, end_day: int, current_day: int, interval: int) -> int:\n", + " lock_duration = max(end_day - current_day, 0)\n", + " time_factor = -lock_duration / interval \n", + " exp_term = 1 - math.exp(time_factor)\n", + " conviction_score = lock_amount * exp_term\n", + " return int(conviction_score)\n", + "\n", + "\n", + "lock = 1000\n", + "calculate_conviction(lock, 365, 100, 180)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 7a77dfd7f3d6028e6c22491b9cb467f9dd6ad551 Mon Sep 17 00:00:00 2001 From: unconst Date: Sat, 3 Aug 2024 16:52:24 -0500 Subject: [PATCH 9/9] initia; --- .gitignore | 2 + lock.ipynb | 412 ----------------------------------------------------- 2 files changed, 2 insertions(+), 412 deletions(-) delete mode 100644 lock.ipynb diff --git a/.gitignore b/.gitignore index f394de80c..5921b6b93 100644 --- a/.gitignore +++ b/.gitignore @@ -6,6 +6,8 @@ **/*.lock +*.ipynb + # Generated by code coverage *.profraw *.profdata diff --git a/lock.ipynb b/lock.ipynb deleted file mode 100644 index cb7425f1f..000000000 --- a/lock.ipynb +++ /dev/null @@ -1,412 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import math\n", - "\n", - "def calculate_conviction(lock_amount: int, end_day: int, current_day: int, interval: int) -> int:\n", - " lock_duration = max(end_day - current_day, 0)\n", - " time_factor = -lock_duration / interval \n", - " exp_term = 1 - math.exp(time_factor)\n", - " conviction_score = lock_amount * exp_term\n", - " return int(conviction_score)\n", - "\n", - "\n", - "def calculate_max_allowed_unstakable(alpha_locked: int, end_day: int, current_day: int, interval: int) -> int:\n", - " return alpha_locked - calculate_conviction(alpha_locked, end_day=end_day, current_day = current_day, interval=interval)\n", - " \n", - "\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Define intervals from 10 days to 3 years\n", - "intervals = [10, 30, 90, 180, 365, 365*2, 365*3]\n", - "\n", - "# Generate data for 3 years (assuming 1 block per day for simplicity)\n", - "days = range(0, 365)\n", - "\n", - "# Create the plot\n", - "plt.figure(figsize=(12, 6))\n", - "\n", - "for interval in intervals:\n", - " unstakable_amounts = [calculate_max_allowed_unstakable(1000, 365, day, interval=interval) for day in days]\n", - " plt.plot(days, unstakable_amounts, label=f'{interval} days')\n", - "\n", - "plt.title('Max Allowed Unstakable Amount Over 3 Years')\n", - "plt.xlabel('Days')\n", - "plt.ylabel('Max Allowed Unstakable Amount')\n", - "plt.legend()\n", - "plt.grid(True)\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 84, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABAcAAAIjCAYAAAB/KXJYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3QUVR/G8e+m94QWSCAkNIHQewm9d1BQmgpSVHpv4ougIl3pqEhVUbAXOkiT3qX33msSEkjbef9YshJDSSCwITyfc3KOe+fuzG93NpF59s69JsMwDERERERERETkhWVn6wJERERERERExLYUDoiIiIiIiIi84BQOiIiIiIiIiLzgFA6IiIiIiIiIvOAUDoiIiIiIiIi84BQOiIiIiIiIiLzgFA6IiIiIiIiIvOAUDoiIiIiIiIi84BQOiIiIiIiIiLzgFA6IiIhNzZ49G5PJxMmTJ1NkfydPnsRkMjF79uwU2d+LLDY2lv79+xMQEICdnR1NmjSxdUkppm3btgQFBdm6jFRh9erVmEwmfvzxR1uX8kzFv+7Vq1fbuhQRkVRB4YCISBp37Ngx3nnnHXLmzImLiwteXl6EhIQwYcIEbt++bevyHtu8efMYP368rctI5I8//qBy5cr4+vri5uZGzpw5ee2111iyZImtS0u2mTNnMmbMGJo1a8acOXPo1avXUznO5cuXcXBw4PXXX39gn/DwcFxdXXnllVeeSg2pSXxgtm3bNluX8kjxYVz8j6OjIxkzZqR8+fK89957nD592tYlMnXqVIWFIiJJ4GDrAkRE5OlZuHAhr776Ks7Ozrz55psULFiQ6Oho/v77b/r168e+ffv48ssvbVrjG2+8QYsWLXB2dk7W8+bNm8fevXvp2bNngvbAwEBu376No6NjClaZNGPHjqVfv35UrlyZQYMG4ebmxtGjR1mxYgXff/89derUeeY1PYm//vqLrFmz8tlnnz3V4/j6+lKzZk1+++03IiMjcXNzS9Tn559/5s6dOw8NEJJj+vTpmM3mFNmXQMuWLalXrx5ms5kbN26wdetWxo8fz4QJE5gxYwYtWrSwWW1Tp04lY8aMtG3bNkF7pUqVuH37Nk5OTrYpTEQklVE4ICKSRp04cYIWLVoQGBjIX3/9hZ+fn3Vbly5dOHr0KAsXLrRhhRb29vbY29un2P5MJhMuLi4ptr+kio2N5aOPPqJmzZosW7Ys0fbLly8/s1rMZjPR0dFP/D5cvnwZHx+flCmKh9fVunVrlixZwu+//37fC8l58+bh7e1N/fr1n6iGiIgI3N3dbRIepWXFixdPFNycOnWKWrVq0aZNG/Lnz0+RIkWe+DiGYXDnzh1cXV2feF92dnY2+VshIpJa6bYCEZE0avTo0dy6dYsZM2YkCAbi5c6dmx49elgfx1/c5sqVC2dnZ4KCgnjvvfeIiopK8LygoCAaNGjA33//TenSpXFxcSFnzpzMnTvX2mfbtm2YTCbmzJmT6LhLly7FZDLx559/Ag+ec2Dx4sVUrlwZT09PvLy8KFWqFPPmzQOgSpUqLFy4kFOnTlmHM8ffP/6gOQf++usvKlasiLu7Oz4+PjRu3JgDBw4k6DN06FBMJhNHjx6lbdu2+Pj44O3tzVtvvUVkZORD3++rV68SFhZGSEjIfbf7+vomeHznzh2GDh3KSy+9hIuLC35+frzyyiscO3bM2iciIoI+ffoQEBCAs7MzefPmZezYsRiGkWBfJpOJrl278u2331KgQAGcnZ2ttzGcO3eOdu3akTlzZpydnSlQoAAzZ8586GuJfw9XrVrFvn37rO9x/L3ZKVHXf7388su4u7tbz/G9Ll++zMqVK2nWrBnOzs6sW7eOV199lezZs+Ps7ExAQAC9evVKdJtM27Zt8fDw4NixY9SrVw9PT09at25t3fbfOQeS8roeNqeFyWRi6NCh1sfh4eH07NmToKAgnJ2drSMkduzY8aC3Pll27txJ3bp18fLywsPDg+rVq7Np06ZE/W7evEmvXr2sdWTLlo0333yTq1evPnDfUVFRNGjQAG9vbzZs2PBY9QUGBjJ79myio6MZPXq0tT3+9+y/7ve3IP7vzdKlSylZsiSurq588cUXAMyaNYtq1arh6+uLs7MzwcHBTJs2LcE+g4KC2LdvH2vWrLF+jqtUqQI8eM6BH374gRIlSuDq6krGjBl5/fXXOXfuXII+8Z+tc+fO0aRJEzw8PMiUKRN9+/YlLi4uQd/vv/+eEiVKWP+WFSpUiAkTJiT37RQReeo0ckBEJI36448/yJkzJ+XLl09S/w4dOjBnzhyaNWtGnz592Lx5MyNGjODAgQP88ssvCfoePXqUZs2a0b59e9q0acPMmTNp27YtJUqUoECBApQsWZKcOXOyYMEC2rRpk+C58+fPJ126dNSuXfuBtcyePZt27dpRoEABBg0ahI+PDzt37mTJkiW0atWKwYMHExoaytmzZ61D3j08PB64vxUrVlC3bl1y5szJ0KFDuX37NpMmTSIkJIQdO3Ykukh87bXXyJEjByNGjGDHjh189dVX+Pr6MmrUqAcew9fXF1dXV/744w+6detG+vTpH9g3Li6OBg0asHLlSlq0aEGPHj0IDw9n+fLl7N27l1y5cmEYBo0aNWLVqlW0b9+eokWLsnTpUvr168e5c+cSDfX/66+/WLBgAV27diVjxowEBQVx6dIlypYta71Iz5QpE4sXL6Z9+/aEhYUluiUjXqZMmfj6668ZPnw4t27dYsSIEQDkz58/Req6H3d3dxo3bsyPP/7I9evXE7x/8+fPJy4uznph/8MPPxAZGUmnTp3IkCEDW7ZsYdKkSZw9e5YffvghwX5jY2OpXbs2FSpUYOzYsfe9ZQFI9utKinfffZcff/yRrl27EhwczLVr1/j77785cOAAxYsXT/b+7rVv3z4qVqyIl5cX/fv3x9HRkS+++IIqVaqwZs0aypQpA8CtW7eoWLEiBw4coF27dhQvXpyrV6/y+++/c/bsWTJmzJho37dv36Zx48Zs27aNFStWUKpUqceus1y5cuTKlYvly5c/9j4OHTpEy5Yteeedd+jYsSN58+YFYNq0aRQoUIBGjRrh4ODAH3/8QefOnTGbzXTp0gWA8ePH061bNzw8PBg8eDAAmTNnfuCxZs+ezVtvvUWpUqUYMWIEly5dYsKECaxfv56dO3cmGEkTFxdH7dq1KVOmDGPHjmXFihWMGzeOXLly0alTJwCWL19Oy5YtqV69uvXvx4EDB1i/fn2CcFZEJFUwREQkzQkNDTUAo3Hjxknqv2vXLgMwOnTokKC9b9++BmD89ddf1rbAwEADMNauXWttu3z5suHs7Gz06dPH2jZo0CDD0dHRuH79urUtKirK8PHxMdq1a2dtmzVrlgEYJ06cMAzDMG7evGl4enoaZcqUMW7fvp2gHrPZbP3v+vXrG4GBgYley4kTJwzAmDVrlrWtaNGihq+vr3Ht2jVr2+7duw07OzvjzTfftLZ98MEHBpCgPsMwjJdfftnIkCFDomP915AhQwzAcHd3N+rWrWsMHz7c2L59e6J+M2fONADj008/TbQt/jX++uuvBmB8/PHHCbY3a9bMMJlMxtGjR61tgGFnZ2fs27cvQd/27dsbfn5+xtWrVxO0t2jRwvD29jYiIyMf+noqV65sFChQIEFbStT1IAsXLjQA44svvkjQXrZsWSNr1qxGXFycYRjGfeseMWKEYTKZjFOnTlnb2rRpYwDGwIEDE/Vv06ZNgs9PUl/X/T5f977eDz74wPrY29vb6NKlyyNf93/F/05s3br1gX2aNGliODk5GceOHbO2nT9/3vD09DQqVapkbYv/TP7888+J9hH/WVu1apUBGD/88IMRHh5uVK5c2ciYMaOxc+fOR9Ya/36MGTPmgX0aN25sAEZoaKhhGP/+nj3odcf/LTCMf//eLFmyJFH/+30OateubeTMmTNBW4ECBYzKlSsn6hv/uletWmUYhmFER0cbvr6+RsGCBRP87fnzzz8NwBgyZIi1Lf6z9eGHHybYZ7FixYwSJUpYH/fo0cPw8vIyYmNjEx1fRCS10W0FIiJpUFhYGACenp5J6r9o0SIAevfunaC9T58+AInmJggODqZixYrWx5kyZSJv3rwcP37c2ta8eXNiYmL4+eefrW3Lli3j5s2bNG/e/IG1LF++nPDwcAYOHJjofuD7DUV+lAsXLrBr1y7atm2b4NvowoULU7NmTetrv9e7776b4HHFihW5du2a9X19kGHDhjFv3jyKFSvG0qVLGTx4MCVKlKB48eIJbmH46aefyJgxI926dUu0j/jXuGjRIuzt7enevXuC7X369MEwDBYvXpygvXLlygQHB1sfG4bBTz/9RMOGDTEMg6tXr1p/ateuTWho6GMNb3/Suh6mVq1aZMqUKcGtBSdOnGDTpk20bNkSOzvLP1vuvd88IiKCq1evUr58eQzDYOfOnYn2G/8tbkq+rqTw8fFh8+bNnD9/PtnPfZi4uDiWLVtGkyZNyJkzp7Xdz8+PVq1a8ffff1s/qz/99BNFihTh5ZdfTrSf//4+hYaGUqtWLQ4ePMjq1aspWrRoitQbP6onPDz8sZ6fI0eO+440uvdzEBoaytWrV6lcuTLHjx8nNDQ02cfZtm0bly9fpnPnzgn+9tSvX598+fLdd46W+/2tuPfvoI+PDxEREU80ckJE5FlROCAikgZ5eXkBSf/H+KlTp7CzsyN37twJ2rNkyYKPjw+nTp1K0J49e/ZE+0iXLh03btywPi5SpAj58uVj/vz51rb58+eTMWNGqlWr9sBa4u+5L1iwYJJqf5T42uOHIt8rf/78XL16lYiIiATt/3196dKlA0jw+h6kZcuWrFu3jhs3brBs2TJatWrFzp07adiwIXfu3AEsrzFv3rw4ODz47r5Tp07h7++fKODJnz9/gtcVL0eOHAkeX7lyhZs3b/Lll1+SKVOmBD9vvfUW8HiTJD5pXQ/j4OBA8+bNWbdunfUe7/igIP6WAoDTp09bw574e70rV64MkOii0MHBgWzZsqX460qK0aNHs3fvXgICAihdujRDhw5NcOH4uK5cuUJkZOQDP9Nms5kzZ84Als9aUn+XevbsydatW1mxYgUFChR44jrj3bp1C0h6WPlfD/oMrV+/nho1aljnEcmUKRPvvfcekPhzkBQP+1uRL1++RJ8BFxcXMmXKlKDtv38HO3fuzEsvvUTdunXJli0b7dq1ey6XNRWRF4PCARGRNMjLywt/f3/27t2brOcl9Zv5B60uYPxnQrrmzZuzatUqrl69SlRUFL///jtNmzZ96EVxapDU1/cwXl5e1KxZk2+//ZY2bdpw7NgxNm/enFIlJvLf2dvjl+l7/fXXWb58+X1/HjR54tOs61Fef/11zGYz3333HQDfffcdwcHB1m+x4+LiqFmzJgsXLmTAgAH8+uuvLF++3DpB4H+XJ3R2draOOEgJD/od+e8kdGCZu+L48eNMmjQJf39/xowZQ4ECBR5rFMKz0LhxYwzDYOTIkSm6zOPevXvx9fW1hpbJeQ/h/p+hY8eOUb16da5evcqnn37KwoULWb58Ob169QISfw6ehqSssuLr68uuXbv4/fffrXNa1K1bN9FcLCIiqYHCARGRNKpBgwYcO3aMjRs3PrJvYGAgZrOZI0eOJGi/dOkSN2/eJDAw8LFqaN68ObGxsfz0008sXryYsLCwR653nitXLoBHBhtJDTLiaz906FCibQcPHiRjxoy4u7snaV+Pq2TJkoDlFgewvMZDhw4RExPzwOcEBgZy/vz5RKM/Dh48aN3+MJkyZcLT05O4uDhq1Khx35//rqCQFE9a16OUKVOGXLlyMW/ePHbv3s2+ffsSjBrYs2cPhw8fZty4cQwYMIDGjRtTo0YN/P39n+i4SX1d8aNIbt68maDfg0YW+Pn50blzZ3799VdOnDhBhgwZGD58+BPVmilTJtzc3B74mbazsyMgIACwfNaSGhI2adKEmTNnMm/ePOuEfk9q48aNHDt2jFq1alnbkvse3s8ff/xhDRzfeecd6tWrR40aNe4bJKTE34pDhw499mfbycmJhg0bMnXqVI4dO8Y777zD3LlzOXr06GPtT0TkaVE4ICKSRvXv3x93d3c6dOjApUuXEm0/duyYdTmtevXqAZaZve/16aefAjz22vL58+enUKFCzJ8/n/nz5+Pn50elSpUe+pxatWrh6enJiBEjrMPw4937zb27u3uShg77+flRtGhR5syZk+BiZO/evSxbtsz62p9UZGTkA4OY+G+K44crN23alKtXrzJ58uREfeNfY7169YiLi0vU57PPPsNkMlG3bt2H1mNvb0/Tpk356aef7ntxeOXKlUe/qPt40rqSonXr1uzcuZMPPvgAk8lEq1atrNviv62997NgGMYTLw2X1Nfl5eVFxowZWbt2bYJ+U6dOTfA4Li4u0efT19cXf3//RMuDJpe9vT21atXit99+S7Ds36VLl5g3bx4VKlSwfkvftGlTdu/enWjFEbj/SJg333yTiRMn8vnnnzNgwIAnqvPUqVO0bdsWJycn+vXrZ22PDwDvfQ8jIiLuu/Tpg9zvcxAaGsqsWbMS9XV3d08URNxPyZIl8fX15fPPP09wjhYvXsyBAwce6+/gtWvXEjy2s7OjcOHCAE/8ORARSWmpe1yniIg8tvhvX5s3b07+/Pl58803KViwINHR0WzYsIEffviBtm3bApb5Adq0acOXX37JzZs3qVy5Mlu2bGHOnDk0adKEqlWrPnYdzZs3Z8iQIbi4uNC+fftHDvH28vLis88+o0OHDpQqVYpWrVqRLl06du/eTWRkpPUCokSJEsyfP5/evXtTqlQpPDw8aNiw4X33OWbMGOrWrUu5cuVo3769dSlDb2/vBOvSP4nIyEjKly9P2bJlqVOnDgEBAdy8eZNff/2VdevW0aRJE4oVKwZYLsDmzp1L79692bJlCxUrViQiIoIVK1bQuXNnGjduTMOGDalatSqDBw/m5MmTFClShGXLlvHbb7/Rs2dP6wXWw4wcOZJVq1ZRpkwZOnbsSHBwMNevX2fHjh2sWLGC69evJ/t1pkRdj/L666/z4Ycf8ttvvxESEpJg+cN8+fKRK1cu+vbty7lz5/Dy8uKnn35K0nwQD5Oc19WhQwdGjhxJhw4dKFmyJGvXruXw4cMJ9hceHk62bNlo1qwZRYoUwcPDgxUrVrB161bGjRuXpJpmzpx53/vTe/Towccff8zy5cupUKECnTt3xsHBgS+++IKoqChGjx5t7duvXz9+/PFHXn31Vdq1a0eJEiW4fv06v//+O59//jlFihRJtP+uXbsSFhbG4MGD8fb2tt7H/zA7duzgm2++wWw2c/PmTbZu3cpPP/2EyWTi66+/tl4QgyUAzJ49O+3bt6dfv37Y29szc+ZMMmXKxOnTp5P03tSqVcv6jfw777zDrVu3mD59Or6+vtYROvFKlCjBtGnT+Pjjj8mdOze+vr73nffE0dGRUaNG8dZbb1G5cmVatmxpXcowKCjIestCcnTo0IHr169TrVo1smXLxqlTp5g0aRJFixa1zmchIpJq2GCFBBEReYYOHz5sdOzY0QgKCjKcnJwMT09PIyQkxJg0aZJx584da7+YmBhj2LBhRo4cOQxHR0cjICDAGDRoUII+hmFZWqx+/fqJjlO5cuX7Lhd25MgRAzAA4++//060/X7LlxmGYfz+++9G+fLlDVdXV8PLy8soXbq08d1331m337p1y2jVqpXh4+NjANZl6R601NyKFSuMkJAQ6/4aNmxo7N+/P0Gf+CXWrly5kqQa7xUTE2NMnz7daNKkiREYGGg4Ozsbbm5uRrFixYwxY8YYUVFRCfpHRkYagwcPtr7fWbJkMZo1a5Zgabrw8HCjV69ehr+/v+Ho6GjkyZPHGDNmTIIlHQ3DsoTeg5bMu3TpktGlSxcjICDAepzq1asbX3755QNfS7z7LWWYUnU9SqlSpQzAmDp1aqJt+/fvN2rUqGF4eHgYGTNmNDp27Gjs3r070Xlv06aN4e7uft/9/3cpw+S8rsjISKN9+/aGt7e34enpabz22mvG5cuXEyxlGBUVZfTr188oUqSI4enpabi7uxtFihS57+v5r/jP24N+zpw5YxiGYezYscOoXbu24eHhYbi5uRlVq1Y1NmzYkGh/165dM7p27WpkzZrVcHJyMrJly2a0adPGusTlvUsZ3qt///4GYEyePPmBtcb/vsX/ODg4GOnTpzfKlCljDBo0KMHSkvfavn27UaZMGcPJycnInj278emnnz5wKcP7/b0xDMvfiMKFCxsuLi5GUFCQMWrUKOsyoffu4+LFi0b9+vUNT09PA7D+nfrvUobx5s+fbxQrVsxwdnY20qdPb7Ru3do4e/Zsgj4P+mz9d5nGH3/80ahVq5bh6+trfa3vvPOOceHChQe+pyIitmIyjGTMriQiIiIiIiIiaY7mHBARERERERF5wSkcEBEREREREXnBKRwQERERERERecEpHBARERERERF5wSkcEBEREREREXnBKRwQERERERERecE52LqAF4nZbOb8+fN4enpiMplsXY6IiIiIiIikcYZhEB4ejr+/P3Z2Dx4foHDgGTp//jwBAQG2LkNEREREREReMGfOnCFbtmwP3K5w4Bny9PQELCfFy8vLxtU8WExMDMuWLaNWrVo4Ojrauhx5QjqfaYvOZ9qi85l26FymLTqfaYvOZ9qi85l8YWFhBAQEWK9HH0ThwDMUfyuBl5dXqg8H3Nzc8PLy0i9cGqDzmbbofKYtOp9ph85l2qLzmbbofKYtOp+P71G3tmtCQhEREREREZEXnMIBERERERERkRecwgERERERERGRF5zmHEhlDMMgNjaWuLg4m9UQExODg4MDd+7csWkdkjJ0PlOWvb09Dg4OWo5URERERNIUhQOpSHR0NBcuXCAyMtKmdRiGQZYsWThz5owugNIAnc+U5+bmhp+fH05OTrYuRUREREQkRSgcSCXMZjMnTpzA3t4ef39/nJycbHYhZzabuXXrFh4eHtjZ6c6T553OZ8oxDIPo6GiuXLnCiRMnyJMnj95TEREREUkTFA6kEtHR0ZjNZgICAnBzc7NpLWazmejoaFxcXHThkwbofKYsV1dXHB0dOXXqlPV9FRERERF53ulKIZXRxZtI6qffUxERERFJa/QvXBEREREREZEXnMIBERERERERkRecwgFJM4YOHUrRokVtvo+kWrlyJfnz50+1ywtWqVKFnj17PrPjlS1blp9++umZHU9ERERERP6lcECe2MWLF+nWrRs5c+bE2dmZgIAAGjZsyMqVK59pHX379k3WMU0mE7/++usT7eNJ9O/fn/fffx97e3sA/v77b0JCQsiQIQOurq7ky5ePzz77LNHzzp07x+uvv27tV6hQIbZt22bd3rZtW0wmk/XH3t6eZs2aPZPX9CTef/99Bg4ciNlstnUpIiIiIiIvHK1WIE/k5MmThISE4OPjw5gxYyhUqBAxMTEsXbqULl26cPDgwWdWi4eHBx4eHjbfR1L8/fffHDt2jKZNm1rb3N3d6dq1K4ULF8bd3Z2///6bd955B3d3d95++20Abty4QUhICFWrVmXx4sVkypSJI0eOkC5dugT7r1OnDrNmzQL+Xa0gtatbty4dOnRg8eLF1K9f39bliIiIiIi8UDRyIJUyDIPI6Fib/BiGkeQ6O3fujMlkYsuWLTRt2pSXXnqJAgUK0Lt3bzZt2mTtd/r0aRo3boyHhwdeXl689tprXLp0ybo9fjj/119/TVBQEN7e3rRo0YLw8HAAvvzyS/z9/RN9q9y4cWPatWuXYB/3mjlzJgUKFMDZ2Rk/Pz+6du0KQFBQEAAvv/wyJpPJ+vi/+zCbzXz44Ydky5YNZ2dnihYtypIlS6zbT548iclk4ueff6Zq1aq4ublRpEgRNm7c+ND37fvvv6dmzZoJlsErVqwYLVu2pECBAgQFBfH6669Tu3Zt1q1bZ+0zatQoAgICmDVrFqVLlyZHjhzUqlWLXLlyJdi/s7MzWbJksf74+Pg8tJ6IiAjefPNNPDw88PPzY9y4cYn6fP3115QsWRJPT0+yZMlCq1atuHz5MmD5vObOnZuxY8cmeM6uXbswmUwcPXoUwzAYOnQo2bNnx9nZGX9/f7p3727ta29vT7169fj+++8fWquIiIiIiKQ8jRxIpW7HxBE8ZKlNjr13aM0k9bt+/TpLlixh+PDhuLu7J9oef0FqNputwcCaNWuIjY2lS5cuNG/enNWrV1v7Hzt2jF9//ZU///yTGzdu8NprrzFy5EiGDx/Oq6++Srdu3Vi1ahXVq1dPcPxFixbdt75p06bRu3dvRo4cSd26dQkNDWX9+vUAbN26FV9fX2bNmkWdOnWsQ/v/a8KECYwbN44vvviCYsWKMXPmTBo1asS+ffvIkyePtd/gwYMZO3YsefLkYfDgwbRs2ZKjR4/i4HD/X7F169bRqlWrh76/O3fuZMOGDXz88cfWtt9//53atWvz6quvsmbNGrJmzUrnzp3p2LFjgueuXr0aX19f0qVLR9WqVenfvz9eXl4PPFa/fv1Ys2YNv/32G76+vrz33nvs2LEjQVASExPDRx99RN68ebl8+TK9e/embdu2LFq0CJPJRLt27Zg1axZ9+/a1PmfWrFlUqlSJ3Llz8+OPP/LZZ5/x/fffU6BAAS5evMju3bsT1FG6dGlGjhz50PdFRERERERSnsIBeWzx3wbny5fvof1WrlzJnj17OHHiBAEBAQDMnTuXAgUKsHXrVkqVKgVYQoTZs2fj6ekJwBtvvMHKlSsZPnw46dKlo27dusybN88aDvz4449kzJiRqlWr3ve4H3/8MX369KFHjx7WtvhjZcqUCbAEGFmyZHlg7WPHjmXAgAG0aNECsHxzv2rVKsaPH8+UKVOs/fr27WsdCj9s2DAKFCjA0aNHH/jenDp1Cn9///tuy5YtG1euXCE2NpahQ4fSoUMH67bjx49bQ4/33nuPrVu30r17d5ycnGjTpg1guaXglVdeIUeOHBw7dszab9OmTdjZJR4sdOvWLWbMmME333xjfW/nzJlDtmzZEvSLH6EBkDNnTiZOnEipUqW4desWHh4etG3bliFDhrBlyxZKly5NTEwM8+bNs44mOH36NFmyZKFGjRo4OjqSPXt2SpcuneAY/v7+nDlzBrPZfN9aRURERETk6VA4kEq5Otqz/8PaNjm2s72J8DuP7pfU2w8OHDhAQECANRgACA4OxsfHhwMHDlgv2IOCgqzBAICfn5912DpA69at6dixI1OnTsXZ2Zlvv/2WFi1a3Pci8vLly5w/f956sfs4wsLCOH/+PCEhIQnaQ0JCEn3jXbhw4QR1x9fwoHDg9u3bCW4puNe6deu4desWmzZtYuDAgeTOnZuWLVsClgClZMmSfPLJJ4DlVoS9e/fy+eefW8OB+CADoFChQhQsWJA8efKwevVqatZMPCrk2LFjREdHU6ZMGWtb+vTpyZs3b4J+27dvZ+jQoezevZsbN25Yb/E4ffo0wcHB+Pv7U79+fWbOnEnp0qX5448/iIqK4tVXXwXg1VdfZfz48eTMmZM6depQr149GjZsmGB0haurK2azmaioKFxdXe/7/oiIiIiI2FxcDPwzH/yKQpaCtq4mReiruVTKZDLh5uRgkx+TyZSkGvPkyYPJZEqxSQcdHR0TvQf3zjHQsGFDDMNg4cKFnDlzhnXr1tG6dev77utZX1jeW3v8+/ewWfczZszIjRs37rstR44cFCpUiI4dO9KrVy+GDh1q3ebn50dwcHCC/vnz5+f06dMPPFbOnDnJkCEDR48eTcpLua+IiAhq166Nl5cX3377LVu3buWXX34BSDDZYYcOHfj++++5ffs2s2bNonnz5ri5uQEQEBDAoUOHmDp1Kq6urnTu3JlKlSoRExNjff7169dxd3dXMCAiIiIiqVNcDOyYC5NLwm9dYPUIW1eUYhQOyGNLnz49tWvXZsqUKURERCTafvPmTcBy8XrmzBnOnDlj3bZ//35u3ryZ6EL3YVxcXHjllVf49ttv+e6778ibNy/Fixe/b19PT0+CgoIeuiyho6MjcXFxD9zu5eWFv7+/dZ6CeOvXr09W3fdTrFgx9u/f/8h+8d+ixwsJCeHQoUMJ+hw+fJjAwMAH7uPs2bNcv37dOqLhv3LlyoWjoyObN2+2tt24cYPDhw9bHx88eJBr164xcuRIKlasSL58+RKM6ohXr1493N3dmTZtGkuWLElwKwJYQpuGDRsyceJEVq9ezcaNG9mzZ491+969eylWrNgDX4uIiIiIiE3ERsP22TCpOPzeDW6cBPdMkL0sJGNC99RMtxXIE5kyZQohISGULl2aDz/8kMKFCxMbG8vy5cuZNm0aBw4coEaNGhQqVIjWrVszfvx4YmNj6dy5M5UrV6ZkyZLJOl7r1q1p0KAB+/bt4/XXX39o36FDh/Luu+/i6+tL3bp1CQ8PZ/369XTr1g3AGh6EhITg7OycaDlAsEzU98EHH5ArVy6KFi3KrFmz2LVrF99++22y6v6v2rVrM2fOnARtU6ZMIXv27NZbEdauXcvYsWMTzOjfq1cvypcvzyeffMJrr73Gli1b+PLLL/nyyy8By/wBw4YNo2nTpmTJkoVjx47Rv39/cubMSe3a979NxcPDg/bt29OvXz8yZMiAr68vgwcPTnC7Rvbs2XFycmLSpEm8++677N27l48++ijRvuzt7Wnbti2DBg0iT548lCtXzrpt9uzZxMXFUaZMGdzc3Pjmm29wdXVNEGysW7eOWrVqPcY7KiIiIiLyFMRGwa5vYd2nEHr3y053XwjpASXbgZObbetLQRo5IE8kZ86c7Nixg6pVq9KnTx8KFixIzZo1WblyJdOmTQMsw+x/++030qVLR6VKlahRowY5c+Zk/vz5yT5etWrVSJ8+PYcOHXrkbP9t2rRh/PjxTJ06lQIFCtCgQQOOHDli3T5u3DiWL19OQEDAA7+t7t69O71796ZPnz4UKlSIJUuW8PvvvydYqeBxtG7dmn379iUYBWA2mxk0aBBFixalZMmSTJkyhVGjRvHhhx9a+5QqVYpffvmF7777joIFC/LRRx8xfvx46+0V9vb2/PPPPzRq1IiXXnqJ9u3bU7x4cRYtWoSzs/MD6xkzZgwVK1akYcOG1KhRgwoVKlCiRAnr9kyZMjF79mx++OEHgoODGTlyZKJlC+O1b9+e6Oho3nrrrQTtPj4+TJ8+nZCQEAoXLsyKFSv4448/yJAhAwDnzp1jw4YNiZ4nIiIiIvLMxUbBlukwsTj82csSDHhkgTojocduzhZqQmTS7sZ+bpiM5CxqL08kLCwMb29vQkNDEy0rd+fOHU6cOEGOHDkeOFHds2I2mwkLC8PLy0szxj9F/fr1IywsjC+++OKpHudZn89169ZRvXp1zpw5Q+bMmZP8vAEDBnDjxg3rKIjUzJa/rzExMSxatIh69eolmqdDnj86n2mHzmXaovOZtuh8pi1P/XzG3LHMKfD3ZxB+3tLm6QcVekHxN8HRMjdW79W9OXj9IJ9V+Yy86fM+ZIe297Dr0HvptgIRGxk8eDBTp05NM8v2RUVFceXKFYYOHcqrr76arGAAwNfXl969ez+l6kREREREHiLmNmyfA+vHQ/gFS5tXVksoUOwNcEz4hdDwCsP58p8vyeia8dnX+pQoHBCxER8fH9577z1bl5FivvvuO9q3b0/RokWZO3dusp/fp0+fp1CViIiIiMhDxNyGbbMsocCtS5Y2r2xQ8W4o4HD/W3NdHVzpUbzHs6vzGVA4ICIpom3btrRt29bWZYiIiIiIPFp0xN1QYAJE3F2Fyzs7VOwNRVvdNxSIiovij2N/8HLul7G3s3/GBT99CgdERERERETkxRAdAVu/gg2TIOKKpc0nO1TsC0VagoPTA586acck5uyfw4bzG/i0yqfPqOBnR+GAiIiIiIiIpG1Rt2DrdEsoEHnN0pYu6G4o0ALsHz654baL25i733LrbKNcjZ5ysbahcEBERERERETSpqhw2PIlbJgMt69b2tLlgEr9oPBrjwwFACJiInh//fsYGLyc+2WqBFR5ujXbiMIBERERERERSVvuhMGWL2DjFLh9w9KWPpclFCj0Ktgn/VJ4zNYxnLt1Dn93f/qX6v+UCrY9hQMiIiIiIiKSNtwJhc13Q4E7Ny1tGfJA5f5Q4JVkhQIAa8+u5acjPwHwcYWP8XDySOGCUw+FAyIiIiIiIvJ8u30TNk2z/ESFWtoy5r0bCrwMj7G6QIw5huGbhgPwRvAblMpSKgULTn3sbF2AyIOcPHkSk8nErl27UnS/JpOJX3/9NUX3+Tw7dOgQWbJkITw83Nal3Ffbtm1p0qTJMzteixYtGDdu3DM7noiIiIg8gcjr8NdwGF8I1oy0BAOZ8kGzmdB5IxRq9ljBAICjnSMTq02kVmAtuhfrnsKFpz4KB+SJPOsLt2dp48aN2NvbU79+fVuXkmxVqlShZ8+eSeo7aNAgunXrhqenJ2AJC6pWrUrmzJlxcXEhZ86cvP/++8TExCR43s2bN+nSpQt+fn44Ozvz0ksvsWjRIuv2oUOHYjKZEvzky5cvxV7j0/L+++8zfPhwQkNDbV2KiIiIiDxI5HVY+RGMLwxrR0NUGPgGw6uzodNGKNj0sUOBe+VNn5dxVcbh4uDy5DWncrqtQOQBZsyYQbdu3ZgxYwbnz5/H39/f1iWluNOnT/Pnn38yadIka5ujoyNvvvkmxYsXx8fHh927d9OxY0fMZjOffPIJANHR0dSsWRNfX19+/PFHsmbNyqlTp/Dx8Umw/wIFCrBixQrrYweH1P8np2DBguTKlYtvvvmGLl262LocEREREblX5DXyn/8BhymdIDrC0pa5oOX2gXwNwe7Jv/++HHmZK7evUCBDgSfe1/NEIwdSK8OwfNht8WMYKfYy1qxZQ+nSpXF2dsbPz4+BAwcSGxtr3W42mxk9ejS5c+fG2dmZ7NmzM3z48PvuKy4ujnbt2pEvXz5Onz4NwG+//Ubx4sWt33APGzYswf6PHDlCpUqVcHFxITg4mOXLlyep7lu3bjF//nw6depE/fr1mT17doLtq1evxmQysXTpUooVK4arqyvVqlXj8uXLLF68mPz58+Pl5UWrVq2IjIy0Pi8qKoru3bvj6+uLi4sLFSpUYOvWrdbts2fPTnSB/euvv2IymayPhw4dStGiRfn6668JCgrC29ubFi1aWG8LaNu2LWvWrGHChAmYTCbs7e2t79d/LViwgCJFipA1a1ZrW86cOXnrrbcoUqQIgYGBNGrUiNatW7Nu3Tprn5kzZ3L9+nV+/fVXQkJCCAoKonLlyhQpUiTB/h0cHMiSJYv1J2PGjA993+Pi4ujduzc+Pj5kyJCB/v37Y/zn87hkyRIqVKhg7dOgQQOOHTtm3V6tWjW6du2a4DlXrlzBycmJlStXAjB16lTy5MmDi4sLmTNnplmzZgn6N2zYkO+///6htYqIiIjIMxRxFZZ/gMPk4rx06Q9M0RGQpRA0/wbeWQfBjVMkGDAMgw82fMDrC1/nlyO/pEDhz4/U/zXeiyomEj6x0TfVA8+myG7OnTtHvXr1aNu2LXPnzuXgwYN07NgRFxcXhg4dCliGtE+fPp3PPvuMChUqcOHCBQ4ePJhoX1FRUbRs2ZKTJ0+ybt06MmXKxLp163jzzTeZOHEiFStW5NixY7z99tsAfPDBB5jNZl555RUyZ87M5s2bCQ0NTfJQ+wULFpAvXz7y5s3L66+/Ts+ePRk0aFCCi3SwXKhPnjwZNzc3XnvtNV577TWcnZ2ZN28et27d4uWXX2bSpEkMGDAAgP79+/PTTz8xZ84cAgMDGT16NLVr1+bo0aOkT58+ye/tsWPH+PXXX/nzzz+5ceMGr732GiNHjmT48OFMmDCBw4cPU7BgQT788EPMZjPOzs733c+6desoWbLkQ4919OhRlixZwiuvvGJt+/333ylXrhxdunTht99+I1OmTLRq1YoBAwZgb//v8K0jR47g7++Pi4sL5cqVY8SIEWTPnv2Bxxo3bhyzZ89m5syZ5M+fn3HjxvHLL79QrVo1a5+IiAh69+5N4cKFuXXrFkOGDOHll19m165d2NnZ0aFDB7p27cq4ceOsr/ubb74ha9asVKtWjW3bttG9e3e+/vprypcvz/Xr1xMEHwClS5dm+PDhREVFPfC9ExEREZFn4NYV2DARtn4FMZGYgJuuQXg0+AiH4Ibwn3+fP6kfj/zI3+f+xsnOicKZCqfovlM7jRyQp2bq1KkEBAQwefJk8uXLR5MmTRg2bBjjxo3DbDYTHh7OhAkTGD16NG3atCFXrlxUqFCBDh06JNjPrVu3qF+/PleuXGHVqlVkypQJgGHDhjFw4EDatGlDzpw5qVmzJh999BFffPEFACtWrODgwYPMnTuXIkWKUKlSJeuw+EeZMWMGr7/+OgB16tQhNDSUNWvWJOr38ccfExISQrFixWjfvj1r1qxh2rRpFCtWjIoVK9KsWTNWrVoFWC5qp02bxpgxY6hbty7BwcFMnz4dV1dXZsyYkaz31mw2M3v2bAoWLEjFihV54403rN+Ke3t74+TkhJubm/Ub+3sv2O916tSpB94uUb58eVxcXMiTJw8VK1bkww8/tG47fvw4P/74I3FxcSxatIj//e9/jBs3jo8//tjap0yZMsyePZslS5Ywbdo0Tpw4QcWKFR868eH48eMZNGgQr7zyCvnz5+fzzz/H29s7QZ+mTZvyyiuvkDt3booWLcrMmTPZs2cP+/fvB7CGGL/99pv1ObNnz6Zt27aYTCZOnz6Nu7s7DRo0IDAwkGLFitG9e8IJZvz9/YmOjubixYsPrFVEREREnqLwS7B0sGWiwQ0TLV+e+hcj9rVvWZN3GMZLdVM8GDgTdoYxW8cA0L14d3L55ErR/ad2GjmQWjm6wXvnbXNsexe48+Qz1x84cIBy5col+LY9JCSEW7ducfbsWS5evEhUVBTVq1d/6H5atmxJtmzZ+Ouvv3B1dbW27969m/Xr1ye4DSEuLo47d+4QGRnJgQMHCAgISHDxW65cuUfWfejQIbZs2cIvv1iGETk4ONC8eXNmzJhBlSpVEvQtXPjfNDFz5sy4ubmRM2fOBG1btmwBLN/2x8TEEBISYt3u6OhI6dKlOXDgwCPruldQUJB1AkEAPz8/Ll++nKx9ANy+fRsXl/tPrjJ//nzCw8PZvXs3/fr1Y+zYsfTv3x+whBO+vr58+eWX2NvbU6JECc6dO8eYMWP44IMPAKhbt651X4ULF6ZMmTIEBgayYMEC2rdvn+h4oaGhXLhwgTJlyljbHBwcKFmyZIJbC44cOcKQIUPYvHkzV69exWw2A5b5EwoWLIiLiwtvvPEGM2fO5LXXXmPHjh3s3buX33//HYCaNWsSGBhIzpw5qVOnDnXq1OHll1/Gzc3Neoz4z9m9t4SIiIiIyDMQfhHWT4BtMyH2jqUtawmoPBDy1MSIjYUjix6+j8cQZ47j/fXvczv2NiUzl+SN4DdS/BipncKB1MpkAid32xz77sXW03bvhf7D1KtXj2+++YaNGzcmGF5+69Ythg0blmC4e7wHXfAmxYwZM4iNjU0QKhiGgbOzM5MnT07wTbajo6P1v00mU4LH8W3mZLyfdnZ2ie6x/+8qAf897uMcJ17GjBm5cePGfbcFBAQAEBwcTFxcHG+//TZ9+vTB3t4ePz8/HB0dE4xIyJ8/PxcvXiQ6OhonJ6dE+/Px8eGll17i6NGjya7zXg0bNiQwMJDp06fj7++P2WymYMGCREdHW/t06NCBokWLcvbsWWbNmkW1atUIDAwEwNPTkx07drB69WqWLVvGkCFDGDp0KFu3brXO93D9+nUA6ygVEREREXnKwi7A+vGwffa/oUC2UpZQIHf1FB8l8F8z985kx+UduDm48VHIR9iZXrxB9i/eK5ZnJn/+/GzcuDHBxe769evx9PQkW7Zs5MmTB1dXV+tw+Afp1KkTI0eOpFGjRgmG9hcvXpxDhw6RO3fuRD92dnbkz5+fM2fOcOHCBetzNm3a9NBjxcbGMnfuXMaNG8euXbusP7t378bf35/vvvvuMd8NyJUrF05OTqxfv97aFhMTw9atWwkODgYsF6Ph4eFERERY++zatSvZx3JyciIuLu6R/YoVK2Ydjv8wZrOZmJgYawAREhLC0aNHEwQShw8fxs/P777BAFjCnGPHjuHn53ff7d7e3vj5+bF582ZrW2xsLNu3b7c+vnbtGocOHeL999+nevXq5M+f/77hRqFChShZsiTTp09n3rx5tGvXLsF2BwcHatSowejRo/nnn384efIkf/31l3X73r17yZYt2yMnUBQRERGRJxR6Dhb1gwlFYPPnlmAgoAy8/jO0Xw55ajz1YOD4zeNM3TUVgPfKvEc2z2xP9XiplUYOyBMLDQ1NdAGbIUMGOnfuzPjx4+nWrRtdu3bl0KFDfPDBB/Tu3Rs7OztcXFwYMGAA/fv3x8nJiZCQEK5cucK+ffsSDTvv1q0bcXFxNGjQgMWLF1OhQgWGDBlCgwYNyJ49O82aNcPOzo7du3ezd+9ePv74Y2rUqMFLL71EmzZtGDNmDGFhYQwePPihryV+gr/27dvf9173GTNm8O677z7W++Tu7k6nTp3o168f6dOnJ3v27IwePZrIyEjr6y1Tpgxubm689957dO/enc2bNydaKSEpgoKC2Lx5MydPnsTNze2BSwjWrl2bDh06EBcXZx0F8O233+Lo6EihQoVwdnZm27ZtDBo0iObNm1tHLHTq1InJkyfTo0cPunXrxpEjR/jkk08S3Lvft29f67f858+f54MPPsDe3p6WLVs+sO4ePXowcuRI8uTJQ758+fj000+5efOmdXu6dOnIkCEDX375JX5+fpw+fZqBAwfed1/xExO6u7vz8ssvW9v//PNPjh8/TqVKlUiXLh2LFi3CbDaTN29ea59169ZRq1atR7/RIiIiIvJ4Qs/C35/BjrkQd3cEaPbyUGUA5Kj81AOBewV5B9G3VF/2Xd1Ho1yNntlxUxuFA/LEVq9eTbFixRK0tW/fnq+++opFixbRr18/ihQpQvr06Wnfvj3vv/++td///vc/HBwcGDJkCOfPn8fPz++BF989e/bEbDZTr149lixZQu3atfnzzz/58MMPGTVqFI6OjuTLl886oaGdnR2//PIL7du3p3Tp0gQFBTFx4kTq1KnzwNcyY8YMatSokSgYAEs4EP9N8+MaOXIkZrOZN954g/DwcEqWLMnSpUtJly4dAOnTp+ebb76hX79+TJ8+nerVqzN06FDrKgxJ1bdvX9q0aUNwcDC3b99m9+7diZZIBMu8AA4ODqxYsYLatWsDlm/VR40axeHDhzEMg8DAQLp27UqvXr2szwsICGDp0qX06tWLwoULkzVrVnr06GFdlQHg7NmztGzZkmvXrpEpUyYqVKjApk2bHjpUv0+fPly4cIE2bdpgZ2dHu3btePnllwkNDQUs5/T777+ne/fuFCxYkLx58zJx4sREc0GAZa6Knj170rJlywS3mfj4+PDzzz8zdOhQ7ty5Q548efjuu+8oUMCyju2dO3f49ddfWbJkSbLecxERERFJgpun74YCX4P57u2zgRUsoUBQxWcaCsSzM9nROn9rDMNItDrZi8Rk/PcGZ3lqwsLC8Pb2JjQ0FC8vrwTb7ty5w4kTJ8iRI8cT3S+fEsxmM2FhYXh5eWGXAmuFim096nxOmTKF33//naVLl9qguqfn5MmT5MqVi61bt1K8ePEkP2/atGn88ssvLFu27IF9bPn7GhMTw6JFi6hXr16iuSfk+aPzmXboXKYtOp9pi85nKnHjFKwbB7vm/RsKBFWEKgMhqEKSd5OS53PftX3k8MqBm6Pbozs/xx52HXovjRwQecG988473Lx5k/Dw8AQrIDyvYmJiuHbtGu+//z5ly5ZNVjAAlskeJ02a9JSqExEREXnBXD9hCQV2fwfmWEtbjsqWUCCwvM3Kunr7Kp2Wd8LDyYMvanxBgFeAzWpJLRQOiLzgHBwcHjkXw/Nk/fr1VK1alZdeeokff/wx2c+Pvy1FRERERJ7A9eOw9m4oYNydKDtnVUsokL2sTUszDIMh64dwI+oGmdwykdk9s03rSS0UDohImlKlSpVEy0GKiIiIyDNy7RisHQv/zP83FMhV3RIKBJS2bW13zT80n3Xn1uFk58TIiiNxsr//alsvGoUDIiIiIiIi8mSuHrGEAnsWgHF3ues8taDyAMhW0ra13eP4zeOM3TYWgF4lepEnXR4bV5R6KBwQERERERGRx3PlMKwdDXt/+jcUeKkOVO4PWUvYtrb/iImLYeC6gUTFRVHevzyt8reydUmpisIBERERERERSZ7LB++GAj8Dd2/pzFvPEgr4F3voU23lqz1fceD6AXycffg45GPsTFqZ7V4KB0RERERERCRpLu23hAL7fsUaCuRrYAkF/IrYsrJHejXvq+y5uoemeZqSyS2TrctJdRQOiIiIiIiIyMNd3GsJBfb/9m9b/oaWOQWyFLJdXcmQ0TUjU6pPwWQy2bqUVEnhgIiIiIiIiNzfhX9gzSg4+OfdBhMEN7aMFMhcwKalJYVhGOy4vIMSmS3zHygYeDDdZCGpRlBQEOPHj081+5s9ezY+Pj4P7TN06FCKFi362MeId+3aNXx9fTl58uQT7+tpSKnXmVQDBw6kW7duz+x4IiIiIvIfF3bDd63gi4p3gwETFHgFOm+E1+Y8F8EAwM9HfqbtkrYM2zhMy10/gsIBeSJVqlShZ8+eidqTcmEt/xo+fDiNGzcmKCgIsIQFderUwd/fH2dnZwICAujatSthYWEJnhcVFcXgwYMJDAzE2dmZoKAgZs6cad0+e/Zs7O3tSZcuHfb29phMJlxcXJ7lS3ssffv2Zc6cORw/ftzWpYiIiIi8WM7vhHkt4ItKcGghYIKCzaDzJnh1Fvjmt3WFSXbs5jFGbhkJQHbP7Bo18Ai6rUDExiIjI5kxYwZLly61ttnZ2dG4cWM+/vhjMmXKxNGjR+nSpQvXr19n3rx51n6vvfYaly5dYsaMGeTOnZsLFy5gNpsT7N/Ly4stW7bg6emJnZ3dc/FHMWPGjNSuXZtp06YxZswYW5cjIiIikvad2w6rR8GRu/8mNdlZQoFK/SDTS7at7TFExUXRb20/7sTdobx/edoUaGPrklI9jRxI5SJjIh/4ExUXleS+d2LvJKnv09K2bVuaNGnC2LFj8fPzI0OGDHTp0oWYmJgHPuf06dM0btwYDw8PvLy8rBfC9/rjjz8oVaoULi4uZMyYkZdffvmB+/vqq6/w8fFh5cqVAHz66acUKlQId3d3AgIC6Ny5M7du3Ur0vF9//ZU8efLg4uJC7dq1OXPmzENf61dffUX+/PlxcXEhX758TJ069aH9Fy1ahLOzM2XLlrW2pUuXjk6dOlGyZEkCAwOpXr06nTt3Zt26ddY+S5YsYc2aNSxatIgaNWoQFBREuXLlCAkJSbB/k8lE5syZyZIlC1myZCFz5swPrQdg5MiRZM6cGU9PT9q3b8+dOwk/P1u3bqVmzZpkzJgRb29vKleuzI4dO6zb27VrR4MGDRI8JyYmBl9fX2bMmAHAjz/+SKFChXB1dSVDhgzUqFGDiIgIa/+GDRvy/fffP7JWEREREXkCZ7fBN81gejVLMGCyg8ItoMtWaDr9uQwGAMZtG8eRG0dI75Ke4RWGa9nCJNDIgVSuzLwyD9xWMWtFptb498KzyoIq3I69fd++JTOXZFadWdbHdX6qw42oG4n67Wmz5wmqfbhVq1bh5+fHqlWrOHr0KM2bN6do0aJ07NgxUV+z2WwNBtasWUNsbCxdunShefPmrF69GoCFCxfy8ssvM3jwYObOnUt0dDSLFi2677FHjx7N6NGjWbZsGaVLlwYs385PnDiRHDlycPz4cTp37kz//v0TXMxHRkYyfPhw5s6di5OTE507d6ZFixasX7/+vsf59ttvGTJkCJMnT6ZYsWLs3LmTjh074u7uTps2908r161bR4kSJR763p0/f56ff/6ZypUrW9t+//13SpYsyejRo/n6669xd3enUaNGfPTRR7i6ulr73bp1i0KFLDPIFi9enE8++YQCBR58j9iCBQsYOnQoU6ZMoUKFCnz99ddMnDiRnDlzWvuEh4fTpk0bJk2ahGEYjBs3jnr16nHkyBE8PT3p0KEDlSpV4sKFC/j5+QHw559/EhkZSfPmzblw4QItW7Zk9OjRvPzyy4SHh7Nu3boE94GVLl2as2fPcvLkSevtFiIiIiKSQk5vhjUj4dhflscmeyjSAir2gQy5bFvbE1p1ehXfHfwOgOEVhpPRNaONK3o+KByQZyZdunRMnjwZe3t78uXLR/369Vm5cuV9w4GVK1eyZ88eTpw4QUBAAABz586lQIECbN26lVKlSjF8+HBatGjBsGHDrM8rUiTx2qoDBgzg66+/Zs2aNQkuiu+dKyEoKIiPP/6Yd999N0E4EBMTw+TJkylTxhLSzJkzh/z587NlyxZryHCvDz74gHHjxvHKK68AkCNHDvbv388XX3zxwHDg1KlT+Pv733dby5Yt+e2337h9+zYNGzbkq6++sm47fvw4f//9Ny4uLvzyyy9cvXqVzp07c+3aNWbNsgRBefPm5auvviJXrlzExsby6aefUr58efbt20e2bNnue8zx48fTvn172rdvD8DHH3/MihUrEoweqFatWoLnfPnll/j4+LBmzRoaNGhA+fLlyZs3L19//TX9+/cHYNasWbz66qt4eHhw+PBhYmNjeeWVVwgMDASwBhjx4t+TU6dOKRwQERERSSmnNlpCgeOrLY9N9lC0pSUUSJ/zoU99HkTERPDBhg8AaBPchgpZK9i4oueHwoFUbnOrzQ/cZm9nn+Dx6tdWP7Dvf4fRLGm65InqehwFChTA3v7fmv38/Niz5/4jFQ4cOEBAQIA1GAAIDg7Gx8eHAwcOUKpUKXbt2nXfYOFe48aNIyIigm3btiX45htgxYoVjBgxgoMHDxIWFkZsbCx37twhMjISNzc3ABwcHChVqpT1Ofny5bPW8N9wICIigmPHjtG+ffsEdcXGxuLt7f3AGm/fvv3ASQI/++wzPvjgAw4fPsygQYPo3bu3Nbwwm82YTCa+/fZb6/4//fRTmjVrxtSpU3F1daVcuXKUKVOGsLAwvLy8qFChAvnz5+eLL77go48+uu8xDxw4wLvvvpugrVy5cqxatcr6+NKlS7z//vusXr2ay5cvExcXR2RkJKdPn7b26dChA19++SX9+/fn0qVLLF68mL/+siTTRYoUoXr16hQqVIjatWtTq1YtmjVrRrp06azPjx/9EBn59G53EREREXlhnFxvCQVOrLU8tnOAoq0soUC6IJuWlpLcHd0ZXmE48w7Oo0fxHrYu57micCCVc3N0s3nfh/Hy8iI0NDRR+82bNxNdEDs6OiZ4bDKZEk2elxz3Dp1/kIoVK7Jw4UIWLFjAwIEDre0nT56kQYMGdOrUieHDh5M+fXr+/vtv2rdvT3R0tDUcSI74+QqmT59uHWkQ795Q5L8yZszIjRuJb/EArPME5MuXj/Tp01OxYkX+97//4efnh5+fH1mzZk3wPufPnx/DMDh79ix58uRJtD9HR0eKFSvG0aNHk/367tWmTRuuXbvGhAkTrCsllCtXjujoaGufN998k4EDB7Jx40Y2bNhAjhw5qFixImB5P5YvX86GDRtYtmwZkyZNYvDgwWzevJkcOXIAcP36dQAyZcr0RLWKiIiIvNBOrIM1o+Dk3bmr7ByhWGuo0BvSBdq2tqekYraKVMxW0dZlPHc0K4M8kbx58yaYiC7ejh07eOmlx5+8JH/+/Jw5cybB5H/79+/n5s2bBAcHA1C4cGHr5IIPUrp0aRYvXswnn3zC2LFjre3bt2/HbDYzbtw4ypYty0svvcT58+cTPT82NpZt27ZZHx86dIibN2+SP3/iJVwyZ86Mv78/x48fJ3fu3Al+4i9476dYsWLs37//oa8DsAYpUVGWiShDQkI4f/58gkkUDx8+jJ2d3QNvGYiLi2PPnj3WeQDuJ3/+/GzenHDEyqZNmxI8Xr9+Pd27d6devXoUKFAAZ2dnrl69mqBPhgwZaNKkCbNmzWL27Nm89dZbCbabTCZCQkIYNmwYO3fuxMnJiV9++cW6fe/evTg6Oj50fgQRERERuQ/DgONrYFY9mNPAEgzYO0HJ9tB9JzSckOaCgf3X9nPu1jlbl/Fc08gBeSKdOnVi8uTJdO/enQ4dOuDs7MzChQv57rvv+OOPPx57vzVq1KBQoUK0bt2a8ePHExsbS+fOnalcuTIlS5YELPf3V69enVy5ctGiRQtiY2NZtGgRAwYMSLCv8uXLs2jRIurWrYuDgwM9e/Ykd+7cxMTEMGnSJBo2bMj69ev5/PPPE9Xh6OhIt27dmDhxIg4ODnTt2pWyZcved74BgGHDhtG9e3e8vb2pU6cOUVFRbNu2jRs3btC7d+/7Pqd27doMGjSIGzduWIfVL1q0iEuXLlGqVCk8PDzYt28f/fr1IyQkxHr/fatWrfjoo4946623GDZsGFevXqVfv360a9fOOqriww8/pHTp0mTJkoXY2FjGjRvHqVOn6NChwwPf+x49etC2bVtKlixJSEgI3377Lfv27UtwW0aePHn4+uuvKVmyJGFhYfTr1+++Izk6dOhAgwYNiIuLSzDnwubNm1m5ciW1atXC19eXzZs3c+XKlQShy7p166hYsWKSRoiIiIiICHdDgdWWkQKnN1ra7J2geBuo0BO87/8F0vMuLDqMnqt6civ6FlNrTKWob1Fbl/Rc0sgBeSI5c+Zk7dq1HDx4kBo1alCmTBkWLFjADz/8QJ06dR57vyaTid9++4106dJRqVIlatSoQc6cOZk/f761T5UqVfjhhx/4/fffKVq0KNWqVWPLli333V+FChVYuHAh77//PpMmTaJIkSJ8+umnjBo1ioIFC/Ltt98yYsSIRM9zc3NjwIABtGrVipCQEDw8PBLU8F8dOnTgq6++YtasWRQqVIjKlSsze/bsh44cKFSoEMWLF2fBggXWNldXV6ZPn26dI6BXr140atSIP//809rHw8OD5cuXc/PmTUqWLEnr1q1p2LAhEydOtPa5ceMG77zzDmXKlKFBgwaEhYWxYcMG6+iL+2nevDn/+9//6N+/PyVKlODUqVN06tQpQZ8ZM2Zw48YNihcvzhtvvEH37t3x9fVNtK8aNWrg5+dH7dq1E0y66OXlxdq1a6lXrx4vvfQS77//PuPGjaNu3brWPt9///0j55QQERERESyhwNEVMLM2fN3EEgzYO0Ppd6DHbqg/Ns0GA4ZhMHTDUC5EXMDHxYfcPrltXdJzy2Tcu3aYPFVhYWF4e3sTGhqKl5dXgm137tzhxIkT5MiR44GT0z0rZrPZOoGdnZ3yo2dh4cKF9OvXj71796b4e27L83nr1i2yZs3KrFmzrCs4JMXixYvp06cP//zzDw4OqW+Aky1/X2NiYli0aBH16tVLNI+HPH90PtMOncu0ReczbUnT5zM+FFg9Es7dvRXWwQVKvAUhPcDrwbeSPq/+ez5/OPwDH278EAeTA1/X+5qCGQvausRU52HXofdKff/qFnkB1a9fnyNHjnDu3LkEKzQ8r8xmM1evXmXcuHH4+PjQqFGjZD0/IiKCWbNmpcpgQERERMTmDAOOLLPcPnBuu6XNwRVKtoOQ7uCZxbb1PSOHrh9i5OaRAHQv3l3BwBPSv7xFUomePXvauoQUc/r0aXLkyEG2bNmYPXt2si/ymzVr9pQqExEREXmOGQYcXmIJBc7vtLQ5ut0NBXqAR+LbPNOqiJgI+q7pS7Q5mopZK9KmQJtHP0keSuGAiKS4oKAgdMeSiIiISAoxDDi0yBIKXNhtaXN0h9IdoFw38Hjxln6ee2AuJ8NOktktM8MrDMfOpNuhn5TCARERERERkdTIbIaDf8Ka0XBpj6XNyQNKd4RyXcE9o23rs6F2BdoRERtBnRx1SOeSztblpAkKB1IZfdsqkvrp91RERESeKrMZDvwOa8fApb2WNidPKPM2lO0C7hlsW18q4GzvzKAyg2xdRpqicCCViJ85NTIyUuu6i6RykZGRAGlvxmMRERGxLbMZ9v9qCQUu77e0OXtBmXegbGdwS2/T8mwtMiaSBQcX4G1427qUNEnhQCphb2+Pj48Ply9fBsDNzQ2TyWSTWsxmM9HR0dy5c0dLGaYBOp8pxzAMIiMjuXz5Mj4+Ptjb29u6JBEREUkLzHGw7xdLKHDloKXN2RvKvgtlO4Grhs0bhsFHmz7iz+N/UsSxCA1oYOuS0hyFA6lIliyWJUfiAwJbMQyD27dv4+rqarOAQlKOzmfK8/Hxsf6+ioiIiDw2cxzs/RnWjoarhy1tLt6WUQJl3gVXH5uWl5r8cvQX/jz+J/Yme0o5l7J1OWmSwoFUxGQy4efnh6+vLzExMTarIyYmhrVr11KpUiUNm04DdD5TlqOjo0YMiIiIyJOJi4W9P1lGClw7Ymlz8bFMMljmbUtAIFaHbxzmk82fANC5cGcyn8ps44rSJoUDqZC9vb1NLz7s7e2JjY3FxcVFF5NpgM6niIiISCoRFwt7FsDasXD9mKXNNZ0lFCj9Nrh42ba+VCgyJpI+q/sQFRdFSNYQ2gS3YcmpJbYuK01SOCAiIiIiIvI0xcXAP/MtocCNE5Y21/RQvptlWUJnT9vWl0rFzzNwMuwkvm6+fFLhE+xMmkPraVE4ICIiIiIi8jTExcDu72DdOLhx0tLmltESCpTqAM4eNi0vtTsTfoYVp1Zgb7JndKXRpHdJb9Pbr9M6hQMiIiIiIiIpKTYads+zhAI3T1va3DNB+e5Qqj04udu2vudEdq/szKs/jz1X91Aicwlbl5PmKRwQERERERFJCbFRsOtbWPcphJ6xtHlkhpAeUOItcHKzbX3PoTzp8pAnXR5bl/FCUDggIiIiIiLyJGKjYMdc+Hs8hJ21tHlkgQo9oURbcHS1YXHPF7Nh5uNNH9MoVyOK+ha1dTkvlFQzm8PIkSMxmUz07NnT2nbnzh26dOlChgwZ8PDwoGnTply6dCnB806fPk39+vVxc3PD19eXfv36ERsbm6DP6tWrKV68OM7OzuTOnZvZs2cnOv6UKVMICgrCxcWFMmXKsGXLlgTbk1KLiIiIiIi8QGLuwOYvYUJRWNTXEgx4+kHd0dBjF5TtpGAgmWbtncUPh3/gneXvcPPOTVuX80JJFeHA1q1b+eKLLyhcuHCC9l69evHHH3/www8/sGbNGs6fP88rr7xi3R4XF0f9+vWJjo5mw4YNzJkzh9mzZzNkyBBrnxMnTlC/fn2qVq3Krl276NmzJx06dGDp0qXWPvPnz6d379588MEH7NixgyJFilC7dm0uX76c5FpEREREROQFEXMbNn0OE4vC4n4Qfh68skK9sdB9F5R5R6HAY9hyYQsTd04EoG+pvvi4+Ni2oBeMzcOBW7du0bp1a6ZPn066dOms7aGhocyYMYNPP/2UatWqUaJECWbNmsWGDRvYtGkTAMuWLWP//v188803FC1alLp16/LRRx8xZcoUoqOjAfj888/JkSMH48aNI3/+/HTt2pVmzZrx2WefWY/16aef0rFjR9566y2Cg4P5/PPPcXNzY+bMmUmuRURERERE0riY27BxKkwoAksGQPgF8MoG9cdB952WZQkdXWxd5XPpcuRl+q3th9kw0yhXI5rlaWbrkl44Np9zoEuXLtSvX58aNWrw8ccfW9u3b99OTEwMNWrUsLbly5eP7Nmzs3HjRsqWLcvGjRspVKgQmTNntvapXbs2nTp1Yt++fRQrVoyNGzcm2Ed8n/jbF6Kjo9m+fTuDBg2ybrezs6NGjRps3LgxybXcT1RUFFFRUdbHYWFhAMTExKTqJTjia0vNNUrS6XymLTqfaYvOZ9qhc5m26HymLSlyPqMjsNs5B7uNkzFFWEYXG94BxJXviVG4BTg4gwHoM/NYYswx9Fndh+t3rpPHJw8DSgxIdKu4ta9+P5Mtqe+VTcOB77//nh07drB169ZE2y5evIiTkxM+Pj4J2jNnzszFixetfe4NBuK3x297WJ+wsDBu377NjRs3iIuLu2+fgwcPJrmW+xkxYgTDhg1L1L5s2TLc3FL/TKXLly+3dQmSgnQ+0xadz7RF5zPt0LlMW3Q+05bHOZ/2cVHkuLqCXJcX4xhr+aIvwikjhzM34kz6ChgXHeDiypQu9YWz+PZidkXtwhln6sfVZ9WyVY98jn4/ky4yMjJJ/WwWDpw5c4YePXqwfPlyXFzS5tCbQYMG0bt3b+vjsLAwAgICqFWrFl5eXjas7OFiYmJYvnw5NWvWxNHR0dblyBPS+UxbdD7TFp3PtEPnMm3R+UxbHut8Rt/CbttM7DZPwRR5DQDDJ4i4kF44FXqNgvaOFHyKNb9I4sxxrF6/Gs7AJxU/oWpA1Yf21+9n8sWPYH8Um4UD27dv5/LlyxQvXtzaFhcXx9q1a5k8eTJLly4lOjqamzdvJvjG/tKlS2TJkgWALFmyJFpVIH4FgXv7/HdVgUuXLuHl5YWrqyv29vbY29vft8+9+3hULffj7OyMs7NzonZHR8fn4oP8vNQpSaPzmbbofKYtOp9ph85l2qLzmbYk6XxGhcOWL2HDZLh93dKWLgdU6oep8Gs42OvzkNIcceTTqp+y/dJ2SmYpmfTn6fczyZL6PtlsQsLq1auzZ88edu3aZf0pWbIkrVu3tv63o6MjK1f+O0zn0KFDnD59mnLlygFQrlw59uzZk2BVgeXLl+Pl5UVwcLC1z737iO8Tvw8nJydKlCiRoI/ZbGblypXWPiVKlHhkLSIiIiIi8py6EwZrx8D4QrDyQ0swkD4XNPkcum6DYq1BwUCKiomLwTAMAEwmU7KCAXk6bDZywNPTk4IFEw7GcXd3J0OGDNb29u3b07t3b9KnT4+XlxfdunWjXLly1gkAa9WqRXBwMG+88QajR4/m4sWLvP/++3Tp0sX6jf27777L5MmT6d+/P+3ateOvv/5iwYIFLFy40Hrc3r1706ZNG0qWLEnp0qUZP348ERERvPXWWwB4e3s/shYREREREXnO3AmFzV/Axilw56alLUMeqNwfCrwC9jafvz1NMgyD/234H7HmWIaVH4a7o7utSxJSwWoFD/PZZ59hZ2dH06ZNiYqKonbt2kydOtW63d7enj///JNOnTpRrlw53N3dadOmDR9++KG1T44cOVi4cCG9evViwoQJZMuWja+++oratWtb+zRv3pwrV64wZMgQLl68SNGiRVmyZEmCSQofVYuIiIiIiDwnbt+ETdMsP1GhlraMee+GAi+Dnb1Ny0vr5h2cx8LjC7E32fN6/tcp6lvU1iUJqSwcWL16dYLHLi4uTJkyhSlTpjzwOYGBgSxatOih+61SpQo7d+58aJ+uXbvStWvXB25PSi0iIiIiIpKKRV63BAKbP4eou5O0ZcoPlftBcBOFAs/A1otbGbN1DAC9S/RWMJCKpKpwQEREREREJKU5xoZjt/oT2DodosMtjb7BlpEC+RuDnc2mYnuhXIy4SN81fYkz4qiXox5vBL9h65LkHgoHREREREQkbYq4ht36idTa9zn25juWtswFLaFAvoYKBZ6hqLgoeq/uzfU718mbLi9Dyw/FZDLZuiy5h8IBERERERFJWyKuwoZJsGU69jERABiZC2GqMgDy1lcoYAOjtoxiz9U9eDt7M77qeFwdXG1dkvyHwgEREREREUkbbl2BDRNh61cQEwmAkaUwW9yqUbzFYBydnGxc4IurQc4GrDm7ho9CPiKbZzZblyP3oXBARERERESeb+GX7oYCMyD2tqXNvxhUHkhsjmpcXLwYNITdpopnLs7Clxfi4uBi61LkARQOiIiIiIjI8yn8IqyfANtmQuzdOQWyloDKAyFPTUsgEBNj2xpfYFcir3Az6iZ50uUBUDCQyikcEBERERGR50vYBVg/HrbP/jcUyFbKEgrkrq5RAqlATFwMvVf35tCNQ4yrPI6K2SrauiR5BIUDIiIiIiLyfAg9dzcUmANxUZa2gLJQZQDkrKpQIBUZtXUUu67swtPRk+xe2W1djiSBwgEREREREUndQs/C35/BjrkQF21py17eEgrkqKxQIJX55cgvzD80HxMmRlYaSaBXoK1LkiRQOCAiIiIiIqnTzdN3Q4GvwXx37oDACpZQIKiiQoFUaM+VPXy06SMAOhftTKVslWxckSSVwgEREREREUldbpyCdeNg17x/Q4GgilBlIARVsG1t8kCXIy/TY1UPYswxVA2oytuF37Z1SZIMCgdERERERCR1uH7CEgrs/g7MsZa2HJUtoUBgedvWJo80Z98crty+Qm6f3IyoOAI7k52tS5JkUDggIiIiIiK2df04rL0bChhxlracVS2hQPaytq1NkqxXiV442zvzcu6XcXd0t3U5kkwKB0RERERExDauHYO1Y+Gf+f+GArmqW0KBgNK2rU2SzcHOge7Fu9u6DHlMCgdEREREROTZunrEEgrsWQCG2dKWpxZUHgDZStq2NkmWtWfXsvbsWgaUGoCjvaOty5EnoHBARERERESejSuHYe1o2PvTv6HAS3Wgcn/IWsK2tUmyHQ89zoC1A7gVc4tsHtloW7CtrUuSJ6BwQEREREREnq7LB++GAj8DhqUtbz1LKOBfzKalyeMJjQql+1/duRVzi+K+xWmdv7WtS5InpHBARERERESejkv7LaHAvl+xhgL5GlhCAb8itqxMnkCsOZYBawdwKuwUfu5+fFrlU91SkAYoHBARERERkZR1ca8lFNj/279t+RtZQoEshWxXl6SIz7Z/xvrz63F1cGVitYlkcM1g65IkBSgcEBERERGRlHHhH1gzCg7+ebfBBMGNLaFA5gI2LU1Sxm9Hf2Pu/rkAfBTyEfnS57NxRZJSFA6IiIiIiMiTubAbVo+CQwvvNpigwMuWUMA3v01Lk5SVziUdHo4evB78OrWDatu6HElBCgdEREREROTxnN9pCQUOL77bYIKCTaFSP/DVN8ppUaVslfip0U9kcc9i61IkhSkcEBERERGR5Dm33RIKHFlqeWyyg4LNLKFAppdsW5ukuFvRt7hx5wYBXgEA+Hv427gieRoUDoiIiIiISNKc3QarR8LR5ZbHJjso3Bwq9oWMuW1bmzwVseZY+q3tx56re5hQdQIlMpewdUnylCgcEBERERGRhzu9GdaMhGN/WR6b7KFIC6jYBzLksm1t8lSN2zaOv8/9jbO9M872zrYuR54ihQMiIiIiInJ/pzZaQoHjqy2PTfZQtKUlFEif06alydM3/+B8vjnwDQDDKwynYMaCNq5IniaFAyIiIiIiktDJ9ZZQ4MRay2M7ByjayhIKpAuyaWnybGw4v4ERW0YA0K1YN61M8AJQOCAiIiIiIhYn1sGaUXByneWxnSMUaw0VekO6QNvWJs/M8ZvH6bu6L3FGHA1zNqRjoY62LkmeAYUDIiIiIiIvMsOwjBBYMwpOrbe02TtBsTegQi/wCbBtffLMff7P54THhFPMtxhDyw/FZDLZuiR5BhQOiIiIiIi8iAzDMpfAmlFweqOlzd4JireBCj3BO5stqxMb+ijkIzK5ZqJ9ofY42TvZuhx5RhQOiIiIiIi8SAwDjq2ENaPhzGZLm70zlGhrCQW8tIb9i87Z3pl+pfrZugx5xhQOiIiIiIi8CAwDjq6A1SPh3DZLm4MLlHgLQnqAl59t6xOb+mrPV0TERNCtWDfsTHa2LkdsQOGAiIiIiEhaZhhwZJnl9oFz2y1tDq5Qsh2EdAfPLLatT2xu8YnFTNgxAYBivsWolK2SjSsSW1A4ICIiIiKSFhkGHF5iCQXO77S0ObrdDQV6gIevbeuTVGHHpR0M/nswAK/nf13BwAtM4YCIiIiISFpiGHBokSUUuLDb0uboDqU7QLlu4JHJtvVJqnEi9ATdV3UnxhxD9ezV6Vuyr61LEhtSOCAiIiIikhaYzXDwT8tEg5f2WNqcPKB0RyjXFdwz2rY+SVWu3b5G5xWdCY0KpXDGwoyoOAJ7O3tblyU2pHBAREREROR5ZjbDgd9h7Ri4tNfS5uQJZd62hAJu6W1bn6Q6ceY4eqzqwdlbZ8nmkY2J1Sbi6uBq67LExhQOiIiIiIg8j8xm2P+rJRS4vN/S5uwFZd6Bsp0VCsgD2dvZ0zJfS87fOs/UGlPJ4JrB1iVJKqBwQERERETkeWKOg32/WEKBKwctbc7eUPZdKNsJXNPZtj55LtTPWZ9q2atpxIBYKRwQEREREXkemONg78+wdjRcPWxpc/G2jBIo8y64+ti0PEn9Fh1fRMksJfF1s6xUoWBA7qVwQEREREQkNYuLhb0/WUYKXDtiaXPxscwnUOZtS0Ag8gh/nf6LgesGktk9M9/X/163EkgiCgdERERERFKjuFjYswDWjoXrxyxtruksoUDpt8HFy7b1yXNjz5U9DFg7AAODClkrkN5F81FIYgoHRERERERSk7gY+Ge+JRS4ccLS5poeynezLEvo7Gnb+uS5cibsDF3/6sqduDtUyFqBwWUGYzKZbF2WpEIKB0REREREUoO4GNj9HawbBzdOWtrcMlpCgVIdwNnDpuXJ8+fa7Wu8s+Idrt+5Tr70+RhbeSwOdroElPvTJ0NERERExJZio2H3PEsocPO0pc09E5TvDqXag5O7beuT51JkTCRdVnbhTPgZsnpkZVqNabg76rMkD6ZwQERERETEFmKjYNe3sO5TCD1jafPIDCE9oMRb4ORm2/rkuRYRE0FUXBTpnNPxeY3Pyeia0dYlSSqncEBERERE5FmKjYIdc+Hv8RB21tLmkQUq9IQSbcFRy8vJk8vklonZdWZzMeIiQd5Bti5HngMKB0REREREnoWYO3dDgc8g/LylzdMPKvSC4m8qFJAUcfjGYV5K9xIA3s7eeDtrqUtJGoUDIiIiIiJPU8xt2D4H1o+H8AuWNq+sllCg2Bvg6GLT8iTtmHdgHiO3jKR/qf68Hvy6rcuR54zCARERERGRpyHmNmybZQkFbl2ytHllg4p3QwEHZ5uWJ2nLspPLGLllJAYGkbGRti5HnkMKB0REREREUlJ0xN1QYAJEXLa0eWeHir2haCuFApLitl7cysB1AzEwaJ63OR0LdbR1SfIcUjggIiIiIpISoiNg61ewYRJEXLG0+WSHin2hSEtwcLJtfZImHb5xmB5/9SDGHEON7DUYVHoQJpPJ1mXJc0jhgIiIiIjIk4i6BVunW0KByGuWtnRBd0OBFmDvaNPyJO26cOsCnZZ3IjwmnOK+xRlRcQT2dva2LkueUwoHREREREQeR1Q4bPkSNkyG29ctbelyQKV+UPg1hQLy1C07tYzLty+T2yc3E6tNxMVBk1vK41M4ICIiIiKSHHfCYMsXsHEK3L5hacuQ2xIKFGwG9vontjwbbQq0wcXehcoBlbVkoTwx/eUSEREREUmKO6Gw+W4ocOempS1DHqjcHwo2BQ3nlmcgKi4KAGd7y8SWzfM1t2U5koYoHBAREREReZjbN2HTNMtPVKilLWNeSyhQ4GWFAvLMxJpj6bemH+HR4UyqNgkPJw9blyRpiMIBEREREZH7uX0D1k2HzZ9DVJilLVN+qNwPgpsoFJBnymyYGbphKKvOrMLJzomjN49S1LeorcuSNEThgIiIiIjIvSKvk+/8jzhM7gzRtyxtvsGWkQL5G4OdnW3rkxeOYRiM2zaO3479hr3JnjGVxygYkBSncEBEREREBCDiGmycjMOWL8gbHWFpy1zQEgrka6hQQGxmxt4ZzN0/F4Bh5YdRLXs1G1ckaZHCARERERF5sUVchQ2TYMt0iInABNx0zY5H/Y9xCFYoILa14NACJuyYAEDfkn1pnLuxjSuStErhgIiIiIi8mG5dgQ0TYetXEBNpafMrQmyFvqw5YqZe3noKBsSmwqPDmbxzMgAdC3WkTYE2Nq5I0jKFAyIiIiLyYgm/dDcUmAGxty1t/sWg8kB4qTZGbCwcXWTbGkUATydPZtaeyaITi+hWrJuty5E0TuGAiIiIiLwYwi/C+gmwbSbE3rG0ZS1hCQXy1ASTybb1idwVHReNk70TALnT5aZ7uu42rkheBBonJSIiIiJpW9gFWDwAJhSBTVMtwUC2UtD6J+iwEl6qpWBAUo19V/dR9+e6bL241dalyAtGIwdEREREJG0KPQfrx8P2ORAXZWkLKAtVBkDOqgoEJNU5fOMw76x4h9CoUGbtnUWpLKVsXZK8QBQOiIiIiEjaEnoW/v4MdsyFuGhLW/byllAgR2WFApIqnQw9ydvL3iY0KpTCGQszpvIYW5ckLxiFAyIiIiKSNtw8fTcU+BrMMZa2wAqWUCCookIBSbXO3zpPx+UduXbnGnnT5WVqjam4O7rbuix5wSgcEBEREZHn241TsG4c7Jr3bygQVBGqDISgCratTeQRrkReocOyDlyMuEgO7xx8UfMLvJ29bV2WvIAUDoiIiIjI8+n6CUsosPs7MMda2nJUtoQCgeVtW5tIEs3YO4Mz4WfI6pGV6TWnk8E1g61LkheUwgEREREReb5cPw5r74YCRpylLWdVSyiQvaxtaxNJpj4l+hBnjqNNgTZkds9s63LkBaZwQERERESeD9eOwdqx8M/8f0OB3DWg8gAIKG3b2kSSISouCic7J0wmE472jgwuO9jWJYkoHBARERGRVO7qEUsosGcBGGZLW55allAgW0nb1iaSTHdi79D1r67k8MrBoDKDsDPZ2bokEUDhgIiIiIikVlcOw9rRsPenf0OBl+pA5f6QtYRtaxN5DFFxUfRY1YPNFzaz58oeXg9+nUCvQFuXJQIoHBARERGR1ObywbuhwM+AYWnLW88SCvgXs2lpIo8rOi6aXqt6seH8BlwdXJlWY5qCAUlVFA6IiIiISOpwab8lFNj3K9ZQIF8DSyjgV8SWlYk8kZi4GPqs6cO6c+twsXdhSvUpFM9c3NZliSSgcEBEREREbOviXksosP+3f9vyN7KEAlkK2a4ukRQQY46h39p+rD6zGmd7ZyZVn0SpLKVsXZZIIgoHRERERMQ2LvwDa0bBwT/vNpgguLElFMhcwKaliaSUf678w+ozq3G0c2RC1QmU9dNym5I62XRqzGnTplG4cGG8vLzw8vKiXLlyLF682Lr9zp07dOnShQwZMuDh4UHTpk25dOlSgn2cPn2a+vXr4+bmhq+vL/369SM2NjZBn9WrV1O8eHGcnZ3JnTs3s2fPTlTLlClTCAoKwsXFhTJlyrBly5YE25NSi4iIiIgkwYXd8F0r+KLi3WDABAVegc4b4bU5CgYkTSmRuQSjK41mfNXxhGQNsXU5Ig9k03AgW7ZsjBw5ku3bt7Nt2zaqVatG48aN2bdvHwC9evXijz/+4IcffmDNmjWcP3+eV155xfr8uLg46tevT3R0NBs2bGDOnDnMnj2bIUOGWPucOHGC+vXrU7VqVXbt2kXPnj3p0KEDS5cutfaZP38+vXv35oMPPmDHjh0UKVKE2rVrc/nyZWufR9UiIiIiIo9wfifMawFfVIJDCwETFGwGnTfBq7PAN7+tKxRJEXHmOG7cuWF9XCuoFpWyVbJhRSKPZtPbCho2bJjg8fDhw5k2bRqbNm0iW7ZszJgxg3nz5lGtWjUAZs2aRf78+dm0aRNly5Zl2bJl7N+/nxUrVpA5c2aKFi3KRx99xIABAxg6dChOTk58/vnn5MiRg3HjxgGQP39+/v77bz777DNq164NwKeffkrHjh156623APj8889ZuHAhM2fOZODAgYSGhj6yFhERERF5gHPbYfUoOHL3yxmTnSUUqNQPMr1k29pEUpjZMDN041C2X9rOjFoz8PPws3VJIkmSauYciIuL44cffiAiIoJy5cqxfft2YmJiqFGjhrVPvnz5yJ49Oxs3bqRs2bJs3LiRQoUKkTlzZmuf2rVr06lTJ/bt20exYsXYuHFjgn3E9+nZsycA0dHRbN++nUGDBlm329nZUaNGDTZu3AiQpFruJyoqiqioKOvjsLAwAGJiYoiJiXnMd+rpi68tNdcoSafzmbbofKYtOp9ph87l/ZnObcdu3Rjsjq0AwDDZYRR8lbiQXpAht6VTKnzPdD7Tlmd5Ps2GmU+2fsKvR3/FzmTH3it7yeic8akf90Wi38/kS+p79VjhwNdff83nn3/OiRMn2LhxI4GBgYwfP54cOXLQuHHjZO1rz549lCtXjjt37uDh4cEvv/xCcHAwu3btwsnJCR8fnwT9M2fOzMWLFwG4ePFigmAgfnv8tof1CQsL4/bt29y4cYO4uLj79jl48KB1H4+q5X5GjBjBsGHDErUvW7YMNze3Bz4vtVi+fLmtS5AUpPOZtuh8pi06n2mHzqVFultHyHfxF3zD9wJgxo6z6UM4nKUREQ6ZYfNh4LBti0wCnc+05WmfT7Nh5vfbv7MtehsmTDR1bUrkP5Es+mfRUz3ui0q/n0kXGRmZpH7JDgemTZvGkCFD6NmzJ8OHDycuLg4AHx8fxo8fn+xwIG/evOzatYvQ0FB+/PFH2rRpw5o1a5JbVqo0aNAgevfubX0cFhZGQEAAtWrVwsvLy4aVPVxMTAzLly+nZs2aODo62roceUI6n2mLzmfaovOZduhcWpjObLKMFDhh+becYeeAUag5cSE98UuXg+dlcLXOZ9ryLM6n2TDz8ZaP2XZsG3YmO4aVHUb9HPWfyrFedPr9TL74EeyPkuxwYNKkSUyfPp0mTZowcuRIa3vJkiXp27dvcneHk5MTuXNbhpWVKFGCrVu3MmHCBJo3b050dDQ3b95M8I39pUuXyJIlCwBZsmRJtKpA/AoC9/b576oCly5dwsvLC1dXV+zt7bG3t79vn3v38aha7sfZ2RlnZ+dE7Y6Ojs/FB/l5qVOSRuczbdH5TFt0PtOOF/ZcnlwPa0bCibWWx3YOULQVpop9MKULsu0M2E/ghT2fadTTOp9x5jiGbRjGb8d+w85kxycVPqF+TgUDT5t+P5Muqe9Tsv9WnzhxgmLFiiVqd3Z2JiIiIrm7S8RsNhMVFUWJEiVwdHRk5cqV1m2HDh3i9OnTlCtXDoBy5cqxZ8+eBKsKLF++HC8vL4KDg6197t1HfJ/4fTg5OVGiRIkEfcxmMytXrrT2SUotIiIiIi+cE+tgdgOYXc8SDNg5Qom20G0HNJoE6YJsXaHIU3cr5hb/XP0He5M9oyqOUjAgz61kjxzIkSMHu3btIjAwMEH7kiVLyJ8/ecvPDBo0iLp165I9e3bCw8OZN28eq1evZunSpXh7e9O+fXt69+5N+vTp8fLyolu3bpQrV846AWCtWrUIDg7mjTfeYPTo0Vy8eJH333+fLl26WL+xf/fdd5k8eTL9+/enXbt2/PXXXyxYsICFCxda6+jduzdt2rShZMmSlC5dmvHjxxMREWFdvSAptYiIiIi8EAzDEgSsGQWn1lva7J2g2BtQoRf4BNi2PpFnzNvZmxm1ZrD/2n4qB1S2dTkijy3Z4UDv3r3p0qULd+7cwTAMtmzZwnfffceIESP46quvkrWvy5cv8+abb3LhwgW8vb0pXLgwS5cupWbNmgB89tln2NnZ0bRpU6KioqhduzZTp061Pt/e3p4///yTTp06Ua5cOdzd3WnTpg0ffvihtU+OHDlYuHAhvXr1YsKECWTLlo2vvvrKuowhQPPmzbly5QpDhgzh4sWLFC1alCVLliSYpPBRtYiIiIikaYYBx1dbQoHTlhWdsHeC4m2gQk/wzmbL6kSeqVhzLDsv76RUllIAZHLLRGU3BQPyfEt2ONChQwdcXV15//33iYyMpFWrVvj7+zNhwgRatGiRrH3NmDHjodtdXFyYMmUKU6ZMeWCfwMBAFi16+AygVapUYefOnQ/t07VrV7p27fpEtYiIiIikOYYBx1bCmtFwZrOlzd7ZcvtAhZ7g5W/L6kSeuRhzDIPWDWLZyWUMrzCchrka2rokkRSRrHAgNjaWefPmUbt2bVq3bk1kZCS3bt3C19f3adUnIiIiIrZgGHB0BaweCee2WdocXKDEWxDSA7yel7UHRFJOjDmGAWsHsPzUchzsHPBw9LB1SSIpJlnhgIODA++++y4HDhwAwM3NDTc3t6dSmIiIiIjYgGHAkWWW2wfObbe0ObhCqfZQvht4PnilJpG0LCYuhn5r+7Hy9Eoc7Rz5rMpnmmNA0pRk31ZQunRpdu7cmWhCQhERERF5jhkGHF5iCQXO370d09HtbijQHTw0UlReXFFxUfRe3Zu1Z9fiZOfEZ1U/o1K2SrYuSyRFJTsc6Ny5M3369OHs2bOUKFECd3f3BNsLFy6cYsWJiIiIyFNmGHBokSUUuLDb0uboDqU7QLlu4JHJtvWJ2FhMXAxdVnZh84XNONs7M6HqBEKyhti6LJEUl+xwIH7Swe7du1vbTCYThmFgMpmIi4tLuepERERE5Okwm+Hgn5aJBi/tsbQ5eUDpjlCuK7hntG19IqmEg50D+dLlY8+VPUyuPtm6QoFIWpPscODEiRNPow4REREReRbMZjjwO6wdA5f2WtqcPKHM25ZQwC29besTSWVMJhN9Svahed7mBHgF2Lockacm2eGA5hoQEREReQ6ZzbD/V0socHm/pc3ZC8q8A2U7KxQQucfV21f58p8v6VOyD872zphMJgUDkuYlOxwAOHbsGOPHj7euWhAcHEyPHj3IlStXihYnIiIiIk/IHAf7frGEAlcOWtqcvaFsJyj7Lrims219IqnMxYiLdFzWkZNhJ4mKi2JY+WG2LknkmUh2OLB06VIaNWpE0aJFCQmxTMSxfv16ChQowB9//EHNmjVTvEgRERERSSZzHOz9GdaOhquHLW0u3pZRAmXeBVcfm5YnkhqdDT9Lh2UdOHfrHFncs9CuYDtblyTyzCQ7HBg4cCC9evVi5MiRidoHDBigcEBERETEluJiYe9PlpEC145Y2lx8LPMJlHnbEhCISCInQ0/SYVkHLkVeIsAzgK9qfYW/h7+tyxJ5ZpIdDhw4cIAFCxYkam/Xrh3jx49PiZpEREREJLniYmHPAlg7Fq4fs7S5prOEAqXfBhcv29YnkooduXGEjss6cu3ONXJ652R6ren4uvnauiyRZyrZ4UCmTJnYtWsXefLkSdC+a9cufH31CyQiIiLyTMXFwD/zLaHAjburSrmmh/LdLMsSOnvatj6RVC7WHEuPVT24ducaedPl5ctaX5LeRRN0yosn2eFAx44defvttzl+/Djly5cHLHMOjBo1it69e6d4gSIiIiJyH3ExsPs7WDcObpy0tLlltIQCpTqAs4dNyxN5XjjYOfBJhU+YvGsy4yqPw9tZt97IiynZ4cD//vc/PD09GTduHIMGDQLA39+foUOH0r179xQvUERERETuERsNu+dZQoGbpy1t7pmgfHco1R6c3G1bn8hzIiw6DC8ny+02RX2LMr3mdEwmk42rErGdZIcDJpOJXr160atXL8LDwwHw9NRwNREREZGnKjYKdn0L6z6F0DOWNo/MENIDSrwFTm62rU/kOfLLkV8Yu20sX9X6ivwZ8gMoGJAXXrLDgRMnThAbG0uePHkShAJHjhzB0dGRoKCglKxPRERE5MUWGwU75sLf4yHsrKXNIwtU6Akl2oKjqw2LE3n+zNk3h7HbxgKw+MRiazgg8qKzS+4T2rZty4YNGxK1b968mbZt26ZETSIiIiIScwc2fwkTisKivpZgwNMP6o6GHrugbCcFAyLJYBgGE3dMtAYDbxV8i14letm4KpHUI9kjB3bu3ElISEii9rJly9K1a9cUKUpERETkhRVzG7bPgfXjIfyCpc0rK1ToBcXeAEcXm5Yn8jwyG2ZGbB3Bj0d/BKBn8Z60L9TexlWJpC6PNedA/FwD9woNDSUuLi5FihIRERF54cTchm2zLKHArUuWNq9sULE3FHsdHJxtWp7I8yomLoYfIn9gz9E9mDDxv3L/49WXXrV1WSKpTrLDgUqVKjFixAi+++477O3tAYiLi2PEiBFUqFAhxQsUERERSdOiI+6GAhMg4rKlzTu7JRQo2hocnGxbn0gacNu4jYOdAyMqjKBOjjq2LkckVUp2ODBq1CgqVapE3rx5qVixIgDr1q0jLCyMv/76K8ULFBEREUmToiNg61ewYRJEXLG0+WSHin2hSEuFAiIpxNHekVburcheKjtlspaxdTkiqVayJyQMDg7mn3/+4bXXXuPy5cuEh4fz5ptvcvDgQQoWLPg0ahQRERFJO6Juwd+fwfhCsHyIJRhIFwSNJkO3HVCijYIBkSd07tY5pv8zHcMwAHAyOVHct7iNqxJJ3ZI9cgDA39+fTz75JKVrEREREUm7osJhy5ewYTLcvm5pS5cDKvWDwq+BvaNt6xNJIw5dP0SnFZ24cvsKbo5uvJb7NVuXJPJcSHI4cPXqVSIiIggMDLS27du3j7FjxxIREUGTJk1o1arVUylSRERE5Ll1Jwy2fAEbp8DtG5a2DLktoUDBZmD/WN/ViMh9bL24le5/dedWzC1y++SmRvYati5J5LmR5P8bdevWDX9/f8aNGwfA5cuXqVixIv7+/uTKlYu2bdsSFxfHG2+88dSKFREREXlu3AmFzXdDgTs3LW0Z8kDl/lCwKdjZ27Q8kbRm2cllDFw3kBhzDMV9izOx2kS8nb2JiYmxdWkiz4UkhwObNm1i9uzZ1sdz584lffr07Nq1CwcHB8aOHcuUKVMUDoiIiMiL7fZN2DTN8hMVamnLmNcSChR4WaGAyFPw/cHv+WTzJxgYVM9enZEVR+Li4GLrskSeK0kOBy5evEhQUJD18V9//cUrr7yCg4NlF40aNWLEiBEpXqCIiIjI88Ax9hZ2a0bA1ukQFWZpzJQfKveD4CYKBUSekhOhJxixZQQGBq++9CqDywzGXr9vIsmW5HDAy8uLmzdvWucc2LJlC+3bt7duN5lMREVFpXyFIiIiIqlZ5HXs1k+i5r6p2JvvWNp8gy0jBfI3BrtkLw4lIsmQwzsHQ8oO4XLkZd4t8i4mk8nWJYk8l5IcDpQtW5aJEycyffp0fv75Z8LDw6lWrZp1++HDhwkICHgqRYqIiIikOhHXYONk2PIl9tG3sAcM3wKYqgyAfA0VCog8RZExkYRGheLn4QdA05ea2rgikedfksOBjz76iOrVq/PNN98QGxvLe++9R7p06azbv//+eypXrvxUihQRERFJNSKuwoZJsGU6xEQAYGQuxBa3ahRvORhHJ2cbFyiStl2JvEKXlV2IjI3k67pfk84l3aOfJCKPlORwoHDhwhw4cID169eTJUsWypQpk2B7ixYtCA4OTvECRURERFKFW1dgw0TY+hXERFra/IpA5YHE5qzBxcWLwaTRAiJP07Gbx+i0ohMXIi6Q3iU9lyIvKRwQSSHJWlg3Y8aMNG7c+L7b6tevnyIFiYiIiKQq4ZfuhgIzIPa2pc2/GFQeCC/VBpMJtFSayFO39eJWevzVg/CYcAK9AplWfRoBXrqtWSSlJCscEBEREXlhhF+E9RNg20yIvTvRYNYSllAgT01LKCAiz8Sfx//kf+v/R6w5lmK+xZhYdSI+Lj62LkskTVE4ICIiInKvsAuwfjxsn/1vKJCtlCUUyF1doYDIM/bb0d94f/37ANQKrMUnFT/B2V5ze4ikNIUDIiIiIgCh5+6GAnMg7u7yzAFlocoAyFlVoYCIjVTIWoGsHlmpGViTXiV6Yae5PUSeCoUDIiIi8mILPQt/fwY75kJctKUte3lLKJCjskIBERuIiYvB0d4RgAyuGVjQcAFeTl42rkokbXuscMBsNnP06FEuX76M2WxOsK1SpUopUpiIiIjIU3Xz9N1Q4Gsw351QMLCCJRQIqqhQQMRGLkZcpOvKrrTO35qX87wMoGBA5BlIdjiwadMmWrVqxalTpzAMI8E2k8lEXFxcihUnIiIikuJunIJ142DXvH9DgaCKUGUgBFWwbW0iL7i9V/fS7a9uXL19lam7p1I3R11cHFxsXZbICyHZ4cC7775LyZIlWbhwIX5+fpiUqouIiMjz4PoJSyiw+zswx1raclS2hAKB5W1bm4iw/NRy3lv3Hnfi7pAnXR4mV5usYEDkGUp2OHDkyBF+/PFHcufO/TTqEREREUlZ14/D2ruhgHF3hGPOqpZQIHtZ29YmIhiGwYy9M5iwYwJgmYBwTKUxeDh52LgykRdLssOBMmXKcPToUYUDIiIikrpdOwZrx8I/8/8NBXLXgMoDIKC0bWsTEcASDAzZMIRfj/4KQKt8rehXqh8Odpo3XeRZS/ZvXbdu3ejTpw8XL16kUKFCODo6JtheuHDhFCtOREREJNmuHrGEAnsWgHF34uQ8tSyhQLaStq1NRBIwmUz4e/hjZ7JjYOmBtMzX0tYlibywkh0ONG3aFIB27dpZ20wmE4ZhaEJCERERsZ0rh2HtaNj707+hwEt1oHJ/yFrCtrWJyAO9W/hdqgZUJV/6fLYuReSFluxw4MSJE0+jDhEREZHHc/ng3VDgZ+DuSkp561lCAf9iNi1NRBLbcmEL0/dMZ0LVCbg5umEymRQMiKQCyQ4HAgMDn0YdIiIiIslzab8lFNj3K9ZQIF8DSyjgV8SWlYnIfRiGwfxD8xm5ZSRxRhxf7fmK7sW727osEbnrsWb6OHbsGOPHj+fAgQMABAcH06NHD3LlypWixYmIiIgkcnGvJRTY/9u/bfkbWUKBLIVsV5eIPFBMXAwjtozgh8M/AFAvRz3eLvy2jasSkXslOxxYunQpjRo1omjRooSEhACwfv16ChQowB9//EHNmjVTvEgRERERLvwDa0bBwT/vNpgguLElFMhcwKaliciDXb9znV6rerHj8g5MmOhRvAftCrbDZDLZujQRuUeyw4GBAwfSq1cvRo4cmah9wIABCgdEREQkZV3YDatHwaGFdxtMUOBlSyjgm9+mpYnIwx29cZQuK7twPuI87o7ujKo4isoBlW1dlojcR7LDgQMHDrBgwYJE7e3atWP8+PEpUZOIiIgInN9pCQUOL77bYIKCTaFSP/DV5GUizwN3R3fuxN0hu2d2JlWbRE6fnLYuSUQeINnhQKZMmdi1axd58uRJ0L5r1y58fX1TrDARERF5QZ3bbgkFjiy1PDbZQcFmllAg00u2rU1EksXPw48van6Bn7sf3s7eti5HRB4i2eFAx44defvttzl+/Djly5cHLHMOjBo1it69e6d4gSIiIvKCOLsNVo+Eo8stj012ULg5VOwLGXPbtjYRSZLImEj+t/5/1MtRj+qB1QG0TKHIcyLZ4cD//vc/PD09GTduHIMGDQLA39+foUOH0r27liIRERGRZDq9GdaMhGN/WR6b7KFIC6jYBzJoJSSR58W5W+fo/ld3Dt84zOaLmynrXxZ3R3dblyUiSZTscMBkMtGrVy969epFeHg4AJ6enilemIiIiKRxpzZaQoHjqy2P7Rz+DQXS675kkefJ9kvb6bWqFzeibpDeJT3jq45XMCDynEl2OHAvhQIiIiKSbCfXW0KBE2stj+0coGgrSyiQLsimpYlI8hiGwfxD8xm1ZRSxRiz50+dnYrWJZHHPYuvSRCSZkhQOFC9enJUrV5IuXTqKFSv20DVJd+zYkWLFiYiISBpyYh2sGQUn11ke2zlCsdehQi9IF2jb2kQk2cyGmSHrh/Dbsd8AqBNUhw9DPsTVwdXGlYnI40hSONC4cWOcnZ2t//2wcEBERETEyjAsIwTWjIJT6y1t9k5Q7A1LKOATYNv6ROSx2Zns8HTyxM5kR6/ivWhToI2uE0SeY0kKBz744APrfw8dOvRp1SIiIiJphWFY5hJYMwpOb7S02TtB8TZQoSd4Z7NldSLyBOLMcdjb2QPQu2Rv6uaoS+FMhW1clYg8KbvkPiFnzpxcu3YtUfvNmzfJmVOTB4mIiLzQDAOOroCZteHrJpZgwN4ZSr8DPXZD/bEKBkSeU4ZhMGvvLDou70iMOQYARztHBQMiaUSyJyQ8efIkcXFxidqjoqI4e/ZsihQlIiIiz5n4UGD1SDi3zdLm4AIl3oKQHuDlZ9v6ROSJRMZE8r/1/2PZqWUALD25lAY5G9i4KhFJSUkOB37//Xfrfy9duhRvb2/r47i4OFauXEmOHDlStjoRERFJ3QwDjiyz3D5wbrulzcEVSrWH8t3AUzOWizzvToWdosdfPTgWegwHkwMDSg+gfo76ti5LRFJYksOBJk2aAGAymWjTpk2CbY6OjgQFBTFu3LgULU5ERERSKcOAw0ssocD5nZY2R7e7oUB38PC1bX0ikiJWn1nNe+veIzwmnEyumfi0yqcU9S1q67JE5ClIcjhgNpsByJEjB1u3biVjxoxPrSgRERFJpQwDDi2yhAIXdlvaHN35P3v3HR9Vlf9//DUzmfTeK0mAAKH33rvYexcbrq5Yd227q67rd3+2tYu6u9a1i11EpCgd6b2XQCC99zLJ3N8fFwYjKKAhk/J+Ph55JHPunclncnInue859xwG3ghDbgP/CPfWJyKN5v3t7/PYqscA6BPZh6dHPU2Er45xkdbqlOccSEtLOx11iIiISHPmdMKOWbDoScjZbLZ5+sPAaTBkOvjpTQOR1mZI7BD87H6c3/F87u53N3ab3d0lichpdMrhwO23307Hjh25/fbbG7S/9NJL7Nmzh+eee66xahMRERF3czph+1ew+CnI2WK2eQbAoJvMUMA31L31iUijyq7IJtrPnCskOSiZr877ikhfXSYk0hac8lKGn376KcOGDTumfejQoXzyySeNUpSIiIi4mdMJWz6DV4fBzKlmMOAVCCPvgTs3wbiHFAyItCJOw8l/N/2XKZ9NYXX2ale7ggGRtuOURw4UFBQ0WKngiMDAQPLz8xulKBEREXETZz1s/dwcKZC3w2zzCoLBt8Dgm8EnxL31iUijK64u5i9L/8KSjCUALD60mAHRA9xclYg0tVMOBzp27MicOXOYPn16g/Zvv/2W9u3bN1phIiIi0oSc9eZIgcVPQv4us807CAbfCoP+AD7Bbi1PRE6PzXmb+dOiP5FVkYWXzYu/Dvor56ec7+6yRMQNTjkcuPvuu5k+fTp5eXmMHTsWgAULFvD0009rvgEREZGWpr4OtnxqjhQo2G22eQeb8wkMuskMCESk1TEMgw92fMBTa56izllHQkACz4x+hi6hXdxdmoi4ySmHA9dffz01NTX885//5NFHHwUgKSmJV155hWuuuabRCxQREZHToL4ONn8Mi/8FhXvNNp8QMxQYeBN4B7q3PhE5rZZnLnctUzi+3Xj+MewfBHgGuLkqEXGnUw4HAG655RZuueUW8vLy8PHxwd/fv7HrEhERkdOh3gGbPjJDgaLDyxP7hMLQ28xlCb10ciDSFgyNHco5Hc6hc0hnru56NRaLxd0liYib/aZw4IiIiIjGqkNEREROp3oHbPwAljwNRfvNNt9wMxQYcCN4KegXac0Mw+CLPV8wtt1YgryCsFgs/N+w/1MoICIuJxUO9O3blwULFhASEkKfPn1+9UVk3bp1jVaciIiI/E51tbDxfTMUKE432/wiYNgd0P968PRzb30ictqV1JTw9+V/Z376fBYdWsSzo5/FYrEoGBCRBk4qHDj33HPx8vJyfa0XEhERkWaurgY2vAdLnoGSg2abf5QZCvS7Djx93VufiDSJDbkbuHfxvWRVZOFh9aBfVD93lyQizdRJhQMPP/yw6+u///3vp6sWERER+b3qamDd/2Dpc1B6yGzzj4bhd0K/a8Hu48biRKSpOA0nb2x5g5fWv0S9UU9CQAJPjXqKbmHd3F2aiDRTpzznwI033shVV13F6NGjT0M5IiIi8ps4qg+HAs9CWabZFhADw++CvtcoFBBpQwqqCrh/yf38mPUjAFOSp/Dg4Afx99TcIiLyy045HMjLy2Py5MlERERw2WWXcdVVV9GrV6/TUZuIiIiciKMK1r4Ny56DsiyzLTDODAX6XA12b7eWJyJNz8Pqwf7S/fh4+PDAwAc4r+N5uixYRE7olMOBL7/8kqKiImbOnMn777/PM888Q5cuXbjyyiu54oorSEpKOg1lioiISAOOKljzphkKlOeYbYHxMOJu6HMVeHi5tTwRaVp1zjpsFhsWi4UgryCeHf0svh6+tA9u7+7SRKSFsP6WO4WEhHDTTTexcOFCDhw4wLXXXss777xDx44dG7s+ERER+anaClj+EjzXE757wAwGgtrBWc/B7ethwA0KBkTamIzyDKbOmcrnez53tXUP765gQEROyW8KB45wOBysWbOGlStXsn//fqKiok7p/o899hgDBgwgICCAyMhIzjvvPHbu3Nlgn+rqam699VbCwsLw9/fnwgsvJCcnp8E+6enpnHnmmfj6+hIZGck999xDXV1dg30WLlxI37598fLyomPHjrz11lvH1DNjxgySkpLw9vZm0KBBrFq16pRrEREROS1qK2DZ8/B8L5j7V6jIheB2cPYLcNta6H8deHi6u0oRaUKGYfD13q+56KuL2JS3iRnrZ1BTX+PuskSkhfpN4cAPP/zAtGnTiIqK4tprryUwMJBZs2Zx6NChU3qcRYsWceutt/Ljjz8yb948HA4HEydOpKKiwrXPXXfdxddff83MmTNZtGgRmZmZXHDBBa7t9fX1nHnmmdTW1rJ8+XLefvtt3nrrLR566CHXPmlpaZx55pmMGTOGDRs2cOedd3LjjTfy3Xffufb56KOPuPvuu3n44YdZt24dvXr1YtKkSeTm5p50LSIiIo2uptycZPC5HjDvIajIg5AkOOcluG0d9JuqUECkDSqtLeW+xffxl6V/odxRTq+IXvxvyv/wsmnkkIj8Nqc850BcXByFhYVMnjyZ//znP5x99tl4ef22F6E5c+Y0uP3WW28RGRnJ2rVrGTlyJCUlJbz++uu8//77jB07FoA333yT1NRUfvzxRwYPHszcuXPZtm0b8+fPJyoqit69e/Poo49y33338fe//x1PT09effVVkpOTefrppwFITU1l6dKlPPvss0yaNAmAZ555hmnTpnHdddcB8Oqrr/LNN9/wxhtvcP/9959ULSIiIo2mpgxW/ce8hKCq0GwLSYaR90DPS8Bmd299IuI2q7NX89elfyWrIgubxcbNvW7mxh434mE95X/tRURcTvkV5O9//zsXX3wxwcHBjV5MSUkJAKGhoQCsXbsWh8PB+PHjXft06dKFdu3asWLFCgYPHsyKFSvo0aNHg0saJk2axC233MLWrVvp06cPK1asaPAYR/a58847AaitrWXt2rU88MADru1Wq5Xx48ezYsWKk67l52pqaqipOTq0q7S0FDAvx3A4HL/pZ9QUjtTWnGuUk6f+bF3Un63Lcfuzpgzr6v9iXfUKlqoiAIzQDtQP/xNGtwvA6gFOwKnfgeZEx2br0pz7M7sim5vm3kSdUUe8fzz/HPpPeoT3wKg3cNQ3v3qbg+bcn3Lq1J+n7mR/VqccDkybNu2UizkZTqeTO++8k2HDhtG9e3cAsrOz8fT0PCaIiIqKIjs727XPz+c6OHL7RPuUlpZSVVVFUVER9fX1x91nx44dJ13Lzz322GM88sgjx7TPnTsXX1/fX/pRNBvz5s1zdwnSiNSfrYv6s3WZN28eHvWVtM+bS4fc77DVm5fXlXnFsCv6XA6FDIaDVjg4182Vyono2Gxdmmt/DvMcRrlRzhTbFA6uOshBDrq7pBahufan/Dbqz5NXWVl5UvudcjhQUVHB448/zoIFC8jNzcXpdDbYvm/fvlN9SABuvfVWtmzZwtKlS3/T/ZujBx54gLvvvtt1u7S0lISEBCZOnEhgYKAbK/t1DoeDefPmMWHCBOx2DVtt6dSfrYv6s3VxOBz88O0XTAzYg8fa/2KpMUeYGeGdqB/+J7xTz6On1UZPN9cpJ6Zjs3VpTv1pGAaf7vmUfpH9SA5KBuAM4wwsFotb62pJmlN/yu+n/jx1R0awn8gphwM33ngjixYt4uqrryYmJqZRXpimT5/OrFmzWLx4MfHx8a726OhoamtrKS4ubvCOfU5ODtHR0a59fr6qwJEVBH66z89XFcjJySEwMBAfHx9sNhs2m+24+/z0MU5Uy895eXkddz4Gu93eIn6RW0qdcnLUn62L+rMVqCzEuvwlJm59GbuzymyLSIVR92Dpeh4eVpt765PfRMdm6+Lu/iyoKuDh5Q+z6NAiUkNTeW/Ke9g138hv5u7+lMal/jx5J/tzOuVw4Ntvv+Wbb75h2LBhp1zUzxmGwW233cbnn3/OwoULSU5ObrC9X79+2O12FixYwIUXXgjAzp07SU9PZ8iQIQAMGTKEf/7zn+Tm5hIZGQmYQ0wCAwPp2rWra5/Zs2c3eOx58+a5HsPT05N+/fqxYMECzjvvPMC8zGHBggVMnz79pGsRERE5ocpCWDEDVv4bW20ZNsCISMUy+j5IPResv2uVYRFpJRYfWsyDyx6ksLoQu9XO2R3OxqbQUEROo1MOB0JCQlwTBv5et956K++//z5ffvklAQEBrmv3g4KC8PHxISgoiBtuuIG7776b0NBQAgMDue222xgyZIhrAsCJEyfStWtXrr76ap588kmys7P529/+xq233up61/7mm2/mpZde4t577+X666/n+++/5+OPP+abb75x1XL33XczdepU+vfvz8CBA3nuueeoqKhwrV5wMrWIiIj8oooCWPGSuQJBbTkARmQ3VvuNpc/lD2L31PJjIgIVjgqeXvM0M3fNBKBjcEceH/E4nUM7u7kyEWntTjkcePTRR3nooYd4++23f/ekeq+88goAo0ePbtD+5ptvcu211wLw7LPPYrVaufDCC6mpqWHSpEm8/PLLrn1tNhuzZs3illtuYciQIfj5+TF16lT+8Y9/uPZJTk7mm2++4a677uL5558nPj6e1157zbWMIcCll15KXl4eDz30ENnZ2fTu3Zs5c+Y0mKTwRLWIiIgcoyIflr8Iq/4LDnOiQaJ7wKj7qeswgaxv59DHotECIgIZ5Rnc8N0NZJRnAHBV6lXc2e9OvGwKD0Xk9DvlcODpp59m7969REVFkZSUdMz1C+vWrTvpxzIM44T7eHt7M2PGDGbMmPGL+yQmJh5z2cDPjR49mvXr1//qPtOnT3ddRvBbaxEREQGgPA+WvwCrXwPH4VmCY3rBqPuh8xlgsYCWYRKRn4jyjSLMOwzDMHh02KMMjBno7pJEpA055XDgyDX5IiIichxlOYdDgdeh7vBEg7F9zFCg0yQzFBAROWxbwTY6BnfE0+aJh9WDf436FwGeAfh7+ru7NBFpY045HHj44YdPRx0iIiItW1k2LHse1rwBddVmW1w/MxRImaBQQEQacNQ7eHXTq7y++XWu6XYNd/czl7+O8Y9xc2Ui0ladcjhwxNq1a9m+fTsA3bp1o0+fPo1WlIiISItRmgXLnoO1bx0NBeIHwuj7oMM4hQIicoydhTv569K/srNoJwC5lbkYhtEoS4SLiPxWpxwO5Obmctlll7Fw4UKCg4MBKC4uZsyYMXz44YdEREQ0do0iIiLNT0nG4VDgbaivMdsSBpuhQPsxCgVE5Bh1zjre2voWMzbMoM5ZR7BXMH8b/DcmJU068Z1FRE6zUw4HbrvtNsrKyti6dSupqakAbNu2jalTp3L77bfzwQcfNHqRIiIizUbJIVj6LKz7H9TXmm3thpqhQPIohQIiclwHyw5y/+L72ZS/CYDRCaN5eMjDhPuEu7kyERHTKYcDc+bMYf78+a5gAKBr167MmDGDiRMnNmpxIiIizUZx+uFQ4B1wHl5lIHG4GQokjVAoICK/ysPiwd6Svfjb/Xlg0AOc3f5sXUYgIs3KKYcDTqfzmOULAex2O06ns1GKEhERaTaKDsCSp2HD+0dDgaQRMPp+SBru3tpEpFnLrcwl0jcSMCcafHLkk3QK6US0X7SbKxMROZb1VO8wduxY7rjjDjIzM11tGRkZ3HXXXYwbN65RixMREXGbwjT4cjq82BfWvW0GA8mj4Lpv4dpZCgZE5Bc56h28suEVJn06ieWZy13tI+NHKhgQkWbrlEcOvPTSS5xzzjkkJSWRkJAAwMGDB+nevTvvvvtuoxcoIiLSpAr3weKnYeMHYNSbbe3HmCMF2g12b20i0uxtzd/Kg8sfZHfRbgAWHlzI0Nih7i1KROQknHI4kJCQwLp165g/fz47duwAIDU1lfHjxzd6cSIiIk2mYC8s/hds+uhoKNBxPIy6DxIGurc2EWn2quuqeXnjy7y99W2chpNQ71AeGPQAkxK1EoGItAynHA4AWCwWJkyYwIQJExq7HhERkaaVv9sMBTZ/DMbhuXNSJpqhQHx/99YmIi3ChtwN/G3Z3zhQegCAKclTuH/g/YR4h7i5MhGRk3fScw58//33dO3aldLS0mO2lZSU0K1bN5YsWdKoxYmIiJw2ebvg0xthxkDY9KEZDHSaDNO+hytnKhgQkZOWW5nLgdIDRPpE8uLYF3li5BMKBkSkxTnpkQPPPfcc06ZNIzAw8JhtQUFB/OEPf+CZZ55hxIgRjVqgiIhIo8rdAYufhC2fAYbZ1nkKjLoXYvu4tTQRaTnyq/IJ9wkHYGLSRP5W/TfOaH8GgZ7H/q8sItISnPTIgY0bNzJ58uRf3D5x4kTWrl3bKEWJiIg0upxtMPNaeHkwbPkUMKDLWfCHxXD5BwoGROSk5Fflc+/iezn/y/Mpqi5ytV/a5VIFAyLSop30yIGcnBzsdvsvP5CHB3l5eY1SlIiISKPJ3mKOFNj25dG21HPMkQLRPdxXl4i0KE7Dyee7P+fptU9TVluG1WJlReYKprSf4u7SREQaxUmHA3FxcWzZsoWOHTsed/umTZuIiYlptMJERER+l6xNsOgJ2DHrcIMFup5rhgJR3dxamoi0LPuK9/HIikdYl7sOgNTQVB4e+jDdwvRaIiKtx0mHA1OmTOHBBx9k8uTJeHt7N9hWVVXFww8/zFlnndXoBYqIiJySrI2w8AnY+c3hBgt0O98MBSJT3VqaiLQshmHwyoZX+M/m/1DnrMPHw4fpvadzReoVeFh/06JfIiLN1km/qv3tb3/js88+o1OnTkyfPp3OnTsDsGPHDmbMmEF9fT1//etfT1uhIiIivypzvRkK7Pr2cIMFul8II++ByC5uLU1EWiaLxUJeVR51zjpGxY/iL4P+Qqx/rLvLEhE5LU46HIiKimL58uXccsstPPDAAxiGOcOzxWJh0qRJzJgxg6ioqNNWqIiIyHFlrDVDgd3fmbctVuhxMYz4M0R0cm9tItLiFFcXU15T7rp9Z787GRo7lHHtxmGxWNxYmYjI6XVK46ESExOZPXs2RUVF7NmzB8MwSElJISRE67iKiEgTO7QGFj4Oe+aZty1W6HmpGQqEH39+HBGRX2IYBrP2zeKp1U/RKaQTZxnm5bKBnoGMTxzv5upERE6/33SxVEhICAMGDGjsWkRERE4sfSUsehz2fm/ettig12Uw4k8Q1sG9tYlIi7SnaA//XPlP1uSsAaCgqoBKo9LNVYmINC3NpCIiIi3DgRVmKLBvoXnb6nE0FAht79bSRKRlqnBU8MqGV3hv+3vUGXV427z5Q68/cEXKFcz7bp67yxMRaVIKB0REpHnbv8wMBdIWm7etHtD7CjMUCElya2ki0nLtK97HtLnTyK3KBWBswljuG3gfsf6xOBwON1cnItL0FA6IiEjzlLYEFj0B+5eYt6126HMVDL8LQhLdW5uItHgJAQn4efoRb4vngUEPMDJ+pLtLEhFxK4UDIiLSfBiGOUJg0RNwYJnZZvOEPleboUBwgnvrE5EWq9JRycxdM7ki9QrsVjt2m52Xxr5EpG8k3h7e7i5PRMTtFA6IiIj7GYY5l8CiJyB9hdlm84S+U2H4nRAU787qRKQFMwyD7w9+zxOrniCrIgvDMLi2+7UAtAts597iRESaEYUDIiLiPoYBexfAoifh4EqzzeYF/a41Q4HAWHdWJyItXHppOo+vepwlGeblSbF+sSQHJbu5KhGR5knhgIiIND3DgD3zYeHjkGEuHYaHN/S7DobdAYEx7q1PRFq0CkcF/9n0H97Z9g4OpwO71c613a5lWs9p+Hj4uLs8EZFmSeGAiIg0HcOA3XPNywcy1pptHj4w4AYYehsERLu3PpFmqq7eSZWjnqraeioPf1TX1VNb58RRb37U1hmurx31TmrrDRx1TmrrnTjqnNQbBoYBBoBhYJifMDBwGke/NncAm9WCh9WCzWrFw2b5ye2ftFstWK0WPD2seHtY8fG04W234e1hw8fTipeH7SdtVjxs1ib5ef1jxT+YnTYbgGGxw7h/4P0kBSU1yfcWEWmpFA6IiMjpZxiwa44ZCmSuN9vsvodDgdvBP9K99YmcBoZhUOWop7SqjtJqB2XVDtfXpdV1rttlP7ldWVNPpaOOytqjQUBVbT219U53P51GYbdZ8Lbb8PfyIMDbgwBv+88+exB4+GtzHztBPnZC/TwJ9fMk2MeO1Wo57mM7DSdWixk+3NTzJnYU7uDufnczMn4kFsvx7yMiIkcpHBARkdPHMGDnbDMUyNpottn9YOCNMOQ28I9wb30ip6Cmrp788lqKKmoprKilqPLw54pa8sur2bbXygfZqymuqnNtd9QbjVqD1QK+nh6H34234mmzYrdZ8fQ4/Nlmxe5hxdNmwX54m7ndgtViwWIBC0c+g+W4beb3qndCvdNJndOg3mn87LMTR715+8hIhWqHk2pH/eEPc6RDtaOemrqjwYaj3sBRX0dZdR1ZJb/t+Yf4ehJyOCwI8/PEx6eCffUz8ff05eKk24kI8CI6MIp3J88kwNuzUX7uIiJtgcIBERFpfE4n7JhlTjSYs9ls8/SHgdPMUMAvzL31iRxmGAbFlQ7yymvIK6sht6yavLIjX9c0+LqkynGCR7NCQdExrTarhUBvDwJ97A3eGTc/2wn0OfrOub+XeeLvY7fh62l++Hh64Gs3h+d7eVhb3LvgTqdBTd3h4KDOHA1RXm0GBOU1R0ZNmCMnGn6uo6ymjpLDIUxpdR1OAwoqaimoqAVLHZ6hS/EM+x6LrRaj0sqyT3ph1AW5vneAlwdRQd5EBXoRFehNVKA30YFHb0cHeRMZ4I3tF0YjiIi0JQoHRESk8TidsP0rWPwU5Gwx2zwDYNBNMGQ6+Ia6tz5pU46c+GeWVJFdUk1mSTVZxVVklVSTWVxFdmk1WSXV1Nad/JB9u81CqJ8nIb7mO9chfp6E+noS5G0ja/9uhg3oTUSgj2t7kI8dX09bizuhb0xWq8UMPDxtv+txHPVOiipqKaioYWH6Qj7cN4PC2iwAQmwdSeQKHO3iyS2rIaekmoraespq6ijLLWdPbvkvPq7dZiE22IeEEF/iQ3yID/EhOtCLg6WQU1pNbIjHL17KICLSmigcEBGR38/phG1fmKFA7jazzSsQBv0BBv9RoYCcFnX1TrJKqjlYWEl6YSUZxVVkFleTXVpFVnE1mSVVVDtO7sQ/2NdOZIAXEQFeRPh7ERnoTYS/edvVHuBFkI/9uCf6DoeD2bN3MaVnDHa7vbGfqgB2m5V6axHPbfk7yzOXAxDhE8Fd/e7izPZnuuYbOKK8po7skmpyS6vJLq0mp7SGnNJqco7cLqkmp6wGR73BgYJKDhRU/uw7evD81sV42qy0C/MlKcyP5HBfksL9SD78ERXgreBARFoNhQMiIvLbOeth6+dmKJC3w2zzCoLBt8Dgm8EnxL31SYtmGAZFlQ7SCytdAcDBwkoOFplfZxZXU+888TX9YX6exAR7ExPkQ2yQNzHBPsQEmbdjgryJDPTCy+P3vastTcPHw4fN+ZuxW+1M7TaVG3vciJ/d77j7+nt50DHSn46R/r/4eHX1TnLKajhUWMmhoioOFh3+XFjB7sxCimst1NY72fMLow+87dbDoYEfHSL8SYnyJyUygPYRfnjb9TslIi2LwgERETl1znrY8hksfhLyd5lt3kEw+FZztIBPsFvLk5bDMAzyymrYl1/BvrwK0vLL2V9wOAQorKSitv5X7+/pYSU+xId2ob7EBfsQ+5MT/9hg8xpznaS1XFV1VczdP5dzOpyDxWIh2DuYx4Y/Rvug9iQEJvzux/ewWYkL9iEu2IdBP2k3R4LMZsKkyRRU1pOWX8H+ggrzc775+WCROTJlR3YZO7LLGjyu1QLtQn1JiQogJdKfTlEBrqBCv48i0lwpHBARkZNXXwdbPjVHChTsNtu8g835BAbdZAYEIsdRWu1g/+EAYN/hk6u0/HLS8ipOGABEBXrRLtSXhBBfEkJ9za8Pf44M8NKw7lbIaTiZtW8WL6x7gZzKHIK9ghmVMArA9bkp2G1WEkK9SAj1ZSQNV1dx1Ds5VFRl/l7nVxweXVDGrpxySqoc7C+oZH9BJfO25bjuY7VAhwh/usYG0jUmkK6xgaTGBBLu79Vkz0lE5JcoHBARkROrr4PNH8Pif0HhXrPNJ8QMBQbeBN6B7q1PmgXDMMgsqWZXThl7csxh2GmHT5zyy2t+8X5WC8SH+NI+whyenRTm5woA4kN89E5rG7M6ezVPrX6K7YXbAYj1i22WEzrabVbX3ANjftJuGAZ55TXszilnd04Zu3LL2ZNTzq7cMoorHezOLWd3bjlfbsh03Scq0IvUGDMw6BYbRM/4IOJDfJrl8xaR1kvhgIiI/LJ6B2z6yAwFitLMNp9QGHqbuSyhV4B76xO3cDoNMoqr2JNbzq6cMtfJzp6csl8dBRAR4EVyuB/tfzKhW/sIPxJCfXXNv5BWksYza59h4cGFAPjb/bmxx41c1fUqvGwt5511i8VCZIC5ROKwjuGudsMwyC2rYVtmKduySl2f9xdUHJ4sMY+FO/Nc+4f6edIzPoie8cH0TjA/a4SBiJxOCgdERORY9Q7Y+AEseRqK9pttvuFmKDDgRvD65Qm+pPU4MhJgZ3Ypu3LKzXdCc8vYk1tO5S+EAB5WC+0j/EiJDKBDpD8dIo4GAQHemsVfjs8wDP606E/sLtqNzWLjok4X8cfefyTUu/WsdGKxWIgKNOfBGNMl0tVeUVPHjuwyV2CwNbOE7VmlFFbUsnBnw8AgLtiHXoeDgr7tQugZH6SRNSLSaBQOiIjIUXW1sPF9MxQoTjfb/CJg2B3Q/3rwPP6s4NLyVTvq2ZldxvasUteJyo6sUkqr6467v91moX24Px2j/OkUGUBKlD+dovxJDPPDbrMe9z4iP1XpqMTD6oGnzROLxcLtfW7nk12fcHe/u2kf3N7d5TUZPy8P+iWG0C/x6OouNXX1bM8qY9OhYjYcLGbToRL25pWTUVxFRnEVszdnA+Zx2CMuiP5JofRLDKF/YghhGl0gIr+RwgEREYG6GtjwHix5BkoOmm3+UWYo0O868PR1b33SaAzDIKukukEIsD2rlP35FRxvVcAjIwE6RQWQEhlApyh/UqICSAzzVQggv4nD6eCzXZ/x6qZXubbbtUztNhWA0QmjGZ0w2r3FNRNeHjZ6JwTTOyGYa4aYbWXVDjZnlLDpUAkb0otZc6CI/PIa1qUXsy692HXf5HA/V1AwMDmU5HA/zV0gIidF4YCISFtWVwPr/gdLn4PSQ2abfzQMvxP6XQt2HzcWJ79XvdMgLb+czRklbMkoZUtGCTuyyyipchx3/1A/T1JjAkiNNmdQ7xJjLr+m+QCkMTgNJ3P3z+XF9S+SXmaOTPpu/3dc0/UanbyehABvO0M7hDO0gzmPgWEYpBdWsmZ/EWsOFLH2QCG7csoPrwRSwSdrzdf0qEAvBrcPY0j7MIZ0CKNdqK9+3iJyXAoHRETaIkf14VDgWSg7PGN2QAwMvwv6TgW7t3vrk1NWV+9kb14FWzJKDocBJWzLKj3u3AAeVgsdIvzpEhNAaowZBKRGBxAR4KWTBjktVmSu4Ll1z7GtYBsAod6h/KHnH7i408X6nfuNLBYLiWF+JIb5cWG/eACKK2tZl15kBgb7i9hwsJic0hq+3JDpWh0hLtjHDAs6mB9xwQqBRcSkcEBEpC1xVMHat2HZc1CWZbYFxpmhQJ+rFQq0EHX1TnbnlrtCgCNBQLXDecy+PnYbXWMD6REXRLdYc111jQaQpvTKhld4eePLAPh6+HJt92uZ2nUqvnZdrtTYgn09GdslirFdogBzLpF1B4pYsa+AFXsL2HCwmIziKj5dd4hP15kjCxLDfBmREs7IlAiGdgzH30unByJtlY5+EZG2wFEFa940Q4HyHLMtMB5G3A19rgIPTWDVXBmGwcHCKtYfLGLjwRI2HCxia2YpNXXHBgF+nja6xQbRPS6I7nFmINA+wh+bVe/MStMyDMM1ImB84nhe3/I6F3W6iGk9phHmE+bm6toOb7uNoR3DGXp4ScXK2jrW7D8aFmzOKOFAQSUHCtJ598d0PKwW+iaGMKpTBCNTIugWG4hVrx8ibYbCARGR1qy24nAo8DxU5JptQe3MUKD3leDh6d765BhFFbVsOFTMxoPmLOUbDxZTVHnsHAEBXh50OxwAdD/8kRzmp3/kxa2yK7L5z6b/YLPY+OvgvwKQEpLC/IvmE+wd7N7iBF9PD0Z2imBkpwjAnOTwx32FLN6Vx+LdeRwoqGRVWiGr0gp56rudhPl5MjwlnFGdIhjVKUIrIYi0cgoHRERao9oKWP0aLH8RKg6vkR3cDkb8GXpdrlCgmahx1JNWBm+tOMDmjDI2HirmQEHlMft52qykxgbSJyGYXglB9IoPJklBgDQj+VX5vLb5NT7e+TEOpwObxcYNPW4g2i8aQMFAMxXgbWdC1ygmdDUvQzhQUMHiXXks2pXPir35FFTUuuYrsFqgb7sQxqVGMT41ko6R/povQqSVUTggItKa1JTD6v+aoUBlgdkWknQ4FLgMbHa3ltfW5ZZWH55V3PzYmlmCo94DtuxssF/7cD96JwTT6/BHakyA5giQZqm4upg3tr7Bhzs+pKquCoB+Uf24rc9trmBAWo7EMD+uHuLH1UOSqK1zsi69iMW78li4M49tWaWsOWCujPDEnB0khvkyrosZFAxIDtXSpiKtgMIBEZHWoKYMVv0Hlr8EVYVmW2h7GHkP9LhYoYAb1DsNdmSXsu5AkSsQOFRUdcx+/h4GAzpE0LddqBkGxAcT5Kv+kubvx6wfufOHO6lwVADQM7wn0/tMZ3DMYL2j3Ap4elgZ3D6Mwe3DuHdyFzKKq/h+ew7zt+eyYm8BBwoqeWNZGm8sSyPA24NRnSKY1C2asV0i8dOkhiItko5cEZGWrLoUVv0bVsyAqiKzLayjGQp0vwhseplvKqXVDtanF7P2QBHrDhSxPr2Iip8tI2i1QOfoQPolBtM/MZQesf5sXrGQM8/si92uQEBaltTQVKxY6RLahem9pzMyfqRCgVYsLtiHq4ckcfWQJCpq6liyO5/523P4YUcuBRW1zNqUxaxNWXh5WBnZKYIpPaIZlxpFoLde20RaCv3XKCLSElWXwvLXzVCguthsC0uBUfdC9wvBqiHop5NhGBwqqmL1/kLWHA4DduaUYRgN9/P38qBPu2D6JYbQLzGE3gnBBPzkH2WHw8EWnUtJC1BdV83HOz9mfe56nhn9DBaLhSCvIN49812SApOwWjSkvC3x8/JgcvdoJnePpt5psOFgMfO25TBnSxb7CyqZty2HedtysNssDO8Yzhk9YpjYNYpgX813I9KcKRwQEWlJqkvonPUZHi9Nh5pSsy28sxkKdDtfocBpYhgG+/IrXLN4r9xXQGZJ9TH7tQv1dQUB/RJD6BQVoGUEpUWrrqvmk12f8MaWN8irMic3XZm9ksExgwFoH9TeneVJM2CzWlyvefdN7syO7DK+3ZzF7C3Z7Mkt54edefywM4+/WC0M6RDGlB4xnNE9WkGBSDOkcEBEpCWoLIQfX8Fj5St0qSkz2yJSYdQ90PU8hQKNzOk02JVbxsp9h8OAtELyy2sa7ONhtdA9LogBSeY/xX0TQ4gM8HZTxSKNq6quipk7Z/Lm1jfJr8oHIMYvhpt73Uy/qH5urk6aK4vFQmpMIKkxgdw9sTO7c8r4dks2327JZntWKUt257Nkdz4PfbmF0Z0jObd3LONTo/C262+YSHOgcEBEpDmrLDQvHVj5b6gtwwKUesfjO+URPLpfAFYN5W0MdfVOtmWVsiqtkB/3FbJ6fyElVY4G+3h6WOmdEMzg5FAGJofRNzEYX0/9GZXWZ3/Jfq6dcy0F1eaKJ7F+sdzY80bO7XAunja92ysnLyUqgJSoAG4fl0JafgWzN2fx9cZMdmSXuS498PO0Mal7NOf2jmNYhzA8tOqBiNvovxoRkeaoogBWvGSuQFBbbrZF9aBu+J/4YS9MST1LwcDvUFfvZFNGCSv2FrAqrZC1B4oor6lrsI+P3Ub/pBAGJoUyqH0YPeOD9O6WtFqGYbgmE0wISCDQKxBvD2+m9ZjGOR3Owa4VT+R3Sg7349YxHbl1TEd2Zpfx5YYMvtyQSUZxFZ+ty+CzdRmE+3tyVs9YzukdS5+EYE1wKdLEFA6IiDQnFfmw/EVY9V84vDwY0T1g1P3QeQpGfT3sm+3eGlsgp9Nge3YpK/YWsPxwIPDzMCDA24MBSaEMSg5lYHIo3eOCtG63tHoVjgo+2PEBc9Lm8N6Z7+Fl88JmtTFj7Ayi/aOxWxUKSOPrHB3AvZO7cM+kzqxLL+LLDZnM2pRFfnktby3fz1vL99Mhwo+L+iVwQd84ogJ1yZZIU1A4ICLSHJTnwfIXYPVr4Kg022J6HQ4FzoAj757U1//yY4jLkQkEl+8tYMXefFbsLaCosuFlAkE+dga3D2VQchgDk0NJjQnU5IHSZpTXlvPBjg94e9vblNSUAPDNvm+4IOUCABICE9xZnrQRFouFfomh9EsM5cGzurJ0Tz5frs/gu6057M2r4Ik5O3jqux2M6hTBxf0TGJcaiZeHRnCJnC4KB0RE3Kks53Ao8DrUVZltsX3MUKDTpKOhgJxQRnEVy/fku0YHZJc2XE3A19PGwORQhnYIY2iHcIUB0iYVVhfy7rZ3+XDHh5Q5zMlNkwKTuKnnTZyRfIabq5O2zG6zMqZzJGM6R1JeU8c3mzKZueYQaw4UuVY8CPa1c17vOC7qF0/3uCB3lyzS6igcEBFxh7JsWPY8rHkD6g6fxMb1M0OBlAkKBU5CfnmNKwhYsTef/QWVDbZ72qz0Swwxw4COYfSMD9ZlAtKm5VflM+WzKVQdDiLbB7VnWs9pnJF0BjateCLNiL+XB5cOaMelA9qxL6+cT9Ye4rN1GWSXVrsuO0iNCeTygQmc1yeOQG9d/iLSGBQOiIg0pdIsWPYcrH3raCgQPxBG3wcdxikU+BXVjnrWHig6vBRWHlszSxtst1kt9IwPco0M6JcYogkEpc0rqi4ixDsEgHCfcAZGDyS/Kp9pPaYxpt0YrBYFZtK8tY/w597JXfjTxM4s2Z3HzLWHmLc1h+1ZpTz05VYem72Dc3vHcuWgRHrEazSByO+hcEBEpCmUZBwOBd6G+hqzLWGwGQq0H6NQ4DgMw2B3bjmLd+WxZHc+K9MKqHY4G+zTJTqAYR3DGdYxjAFJoQTo3SMRALYXbOe1za+x6NAiZp0/i2i/aAAeH/E4fnY/zQIvLY7NamF050hGd46kuLKWz9dn8P7KdHbnlvPh6oN8uPogveKDuHJQImf1itFSsyK/gY4aEZHTqeQQLH0W1v0P6mvNtnZDzVAgeZRCgZ/JL69h2Z58Fu/KZ+mePHJKaxpsjwzwYkRKBCM7hTO0QzgRAV5uqlSkeVqbs5bXNr/G0oylrralGUu5qNNFAPh7+rurNJFGE+zryXXDkrl2aBKr9xfx3soDfLs5m42HSth4aBOPfrONC/vGc8WgdnSKCnB3uSIthsIBEZHToTj9cCjwDjgPz5KfONwMBZJGKBQ47ESXCnjbrQxMDmNkSjgjUiLoFOWvdzxFfsZpOFl0cBFvbX2LdbnrALBarExOmswNPW6gU0gnN1cocnpYLBYGHl5+9qGzavhk7SHeX5XOgYJK19wEA5NDmTo4Aafh7mpFmj+FAyIijanoACx5Gja8fzQUSBoBo++HpOHura2ZSMuvYOHOXBbuzDvupQJdYwIZ0SmckSkRmjdA5CSU1ZZx35L7qKqrwm61c17H87iu23VajlDalDB/L/4wqgPTRrRn2d583vsxnXnbc1iVVsiqtEJCvWzkBO/n8kFJBPnoEjSR41E4ICLSGArTzFBg4wfgrDPbkkeZoUDiUPfW5mbVjnpW7Ctg0c48Fu7MPWZVAV0qIHJqSmpKWJC+gPM7no/FYiHIK4hrul5DrbOWq1KvItI30t0liriN1WphREoEI1IiyCqp4p0VB/hgVTqFlQ4en7OLF77fy4V947l2WBIdInSZjchPKRwQEfk9CvfB4sOhgFFvtnUYC6Pug3aD3VubG+3Pr+CHw6MDftxXQE3d0dEBdpuFAUmhjO4cwchOEXSOCtClAiInIbM8k3e2vcOnuz+lqq6KpMAk+kb1BWB6n+lurk6k+YkJ8uHeyV24ZWQS/3x3LuvKg9iVW847Px7gnR8PMKpTBNcNS2JkSgRWq/4OiSgcEBH5LQr2wuJ/waaPjoYCHceboUDCQPfW5gYnGh0QG+TNqM6RjOkcwdCO4fh76c+PyMnaXrCdN7e+ydz9c6k//HrTKaST62sR+XXedhtDogz+ce0Q1qSX8say/SzYkcOiXXks2pVHx0h/bhrRnnP7xOLloUvZpO3Sf2ciIqcif7cZCmz+GIzD74anTDRDgfj+7q2tiR0oqOCHHbks3JXHir3Hjg7on2iODhjTJZKUSE0kKHKqCqsLuXfxvazMWulqGxwzmOu6XceQ2CE6pkROkcViYWjHcIZ2DOdAQQVvLd/PzDWH2JNbzr2fbuLpeTu5YXgylw9sp6VxpU1SOCAicjLydsHiJ2HLp0dDgU6TYdS9ENfPvbU1kbp6J2sPFLFgRy7zt+ewL6+iwfaYIG9Gd45gdOdIhml0gMhvYhiG66Q/yDOIjLIMbBYbk5ImcW23a0kNS3VzhSKtQ2KYHw+f3Y27J3Tig1XpvL40jZzSGv7f7B28+P0erhqcyHVDk4gM9HZ3qSJNRv+5iYj8mtwdh0OBz4DD6yB1nmKGArF93FpaUyipcrBoVx4LtuewcGceJVUO1zYPq4X+SSGM7hzJmM6RWmZQ5HfIrsjmgx0fsPDgQmaePRNPmyc2q41Hhz1KrH8ssf6x7i5RpFUK8LZz08gOTB2axJcbMvn3or3szavglYV7eX1JGhf2i2PaiPa01+SF0gYoHBAROZ6cbWYosPULXKFAl7PMUCCmlzsrO+3S8itYsD2H+dtzWL2/iPqfLA4d7GtnTOdIxqVGMrJTBIEadinyu2zK28S7295l7oGj8wksSF/AGclnANA/um1driTiLl4eNi7pn8BFfeNZsCOXVxftZe2BIj5YdZAPVx9kUtdopo/tSPe4IHeXKnLaKBwQEfmp7C1mKLDty6NtqeeYoUB0D/fVdRrV1TtZc6CIBdtzWLAj95jLBTpG+jMuNZLxqVH0bReCTTM6i/wudc465qfP551t77Apb5OrfUD0AK5KvYpR8aPcWJ1I22a1WpjQNYoJXaNYs7+QVxftZf72XOZszWbO1mzGdYnk9nEp9EoIdnepIo1O4YCICEDWJlj0BOyYdbjBAl3PNUOBqG5uLe10KKl0sHBXLt/vyD3u5QKD2ocyrksU41IjSQzzc2OlIq1PWkka9yy6BwC71c6U5Clc1fUquoR2cXNlIvJT/ZNCeS0plN05Zby8cC9fbshgwY5cFuzIZXTnCG4bm0K/xBB3lynSaBQOiEjblrURFj4BO7853GCBbueboUBk65r4K72gkrnbso97uUCI63KBKEZ0CtflAiKNaGvBVrYXbOeiThcBkBKSwpTkKSQGJnJJ50sI9wl3c4Ui8mtSogJ49tLe3Da2IzN+2MsXGzJYuDOPhTvzGJESzu3jUhiQFOruMkV+N4UDItI2Za43Q4Fd3x5usED3C2HkPRDZOt69MwyDrZmlzN2Ww9yt2ezILmuwPSXSn3Gp5ugAXS4g0rhq62v5bv93fLjzQzblbcLD6sHohNGuIOCJkU+4uUIROVXtI/x5+pJe3D6uIy//sJdP1x1iye58luzOZ0j7MG4fl8KQDmHuLlPkN1M4ICJtS8ZaMxTY/Z1522KFHhfDiD9DRCf31tYI6uqdrN5fxNxt2czdmkNGcZVrm81qYWBSKBO6RjE+NYp2Yb5urFSkdcqqyOLzfZ/z2e7PKKwuBMDD6sHExInU1te6uToRaQyJYX48cVFPpo/tyMsL9/LJ2oOs2FfAin0FDGkfxp8nddblBtIiWd35zRcvXszZZ59NbGwsFouFL774osF2wzB46KGHiImJwcfHh/Hjx7N79+4G+xQWFnLllVcSGBhIcHAwN9xwA+Xl5Q322bRpEyNGjMDb25uEhASefPLJY2qZOXMmXbp0wdvbmx49ejB79uxTrkVEmrFDa+Ddi+C/Y81gwGKFXpfDravhgv+06GCgqraeuVuz+fPMjQz453wu/++PvLlsPxnFVXjbrUzsGsXTF/dizV/H88FNg7l+eLKCAZHTYGvtVs7+6mxe2/wahdWFRPpGMr33dOZdNI8nRj6h5QhFWpmEUF8eu6AHC+8Zw9WDE/G0WVmxr4ALX1nOjW+vZntWqbtLFDklbh05UFFRQa9evbj++uu54IILjtn+5JNP8sILL/D222+TnJzMgw8+yKRJk9i2bRve3t4AXHnllWRlZTFv3jwcDgfXXXcdN910E++//z4ApaWlTJw4kfHjx/Pqq6+yefNmrr/+eoKDg7npppsAWL58OZdffjmPPfYYZ511Fu+//z7nnXce69ato3v37iddi4g0Q+krYdHjsPd787bFBr0ugxF/grAO7q3tdyiqrGXJnhy+25rN4t15VDucrm3BvnbGp0YxsWsUI1Ii8PG0ubFSkdarvLac/Kp8koKSAEj2SMZutdMroheXd7mc0Qmj8bBqkKZIaxcX7MOj53Xn5tEdeGH+bmauPcj87ebEhWf3jOWuCZ1IDtfkvtL8ufUv1hlnnMEZZ5xx3G2GYfDcc8/xt7/9jXPPPReA//3vf0RFRfHFF19w2WWXsX37dubMmcPq1avp399cB/jFF19kypQp/Otf/yI2Npb33nuP2tpa3njjDTw9PenWrRsbNmzgmWeecYUDzz//PJMnT+aee8yZgx999FHmzZvHSy+9xKuvvnpStYhIM3NghRkK7Fto3rZ6HA0FQtu7tbTfKqO4im83ZfDRVit3r1zUYELBuGAfJnaLYmLXaAYkheBhc+vAMJFWbWfhTmbumsnXe7+mc2hn/nfG/wDwtfry9TlfExMY4+YKRcQd4oJ9eOKintw0qj3PztvFrE1ZfLUxk282Z3FJ/3huG5tCbLCPu8sU+UXNNs5OS0sjOzub8ePHu9qCgoIYNGgQK1as4LLLLmPFihUEBwe7ggGA8ePHY7VaWblyJeeffz4rVqxg5MiReHp6uvaZNGkSTzzxBEVFRYSEhLBixQruvvvuBt9/0qRJrsscTqaW46mpqaGmpsZ1u7TUHFrkcDhwOBzHvU9zcKS25lyjnLy21p+W9OVYlzyFdf8SAAyrB0bPy6gfdhcEJ5o7taCfxb68CuZszWHu9hy2Zh6ZUNAKGHSJ8md8aiQTukaSGh2AxWJOKGg463E4691Ws5y8tnZ8tmRVdVV8d+A7PtvzGVsKtrjai6uLKawoxNtijiIM8ghSf7YCOjZbl6buz3bBXjx7cQ+mDU/k2fl7WLgrnw9WHeTTdRlcMSCem0cmE+bv1SS1tEY6Pk/dyf6smm04kJ2dDUBUVFSD9qioKNe27OxsIiMjG2z38PAgNDS0wT7JycnHPMaRbSEhIWRnZ5/w+5yoluN57LHHeOSRR45pnzt3Lr6+zf9633nz5rm7BGlErb0/w8q20zn7CyLKtwPgtNg4EDqS3VFnUWWJgOVbga3uLfIkGAZkVcLGQisbCixkVx1dQcCCQfsA6BHqpEeoQbh3MdQUs3/9Lva7rWJpDK39+Gzpfqz5kXlV86jBDPxt2Ei1pzLAcwDtLe1ZMn+Ja1/1Zeui/mxd3NGf54dB7+4wK93GnlInb61I54NVB5gQ52RUtIGu/PvtdHyevMrKypPar9mGA63BAw880GBEQmlpKQkJCUycOJHAwEA3VvbrHA4H8+bNY8KECdjtWuu8pWvV/WkYWA4sMUcKpK8wm2yeOHtdiXPoHcQHxRPv5hJPhmEYbMsqY87WHL7bmkNawdEXcLvNwpD2oUzqGsW4LhEEellbb3+2Qa36+GzBKh2VOHHib/cHwJ5uZ9bSWST4J3BBxws4u/3ZhHo3XNNcfdm6qD9bl+bQn380DJbtLeTpebvZklnKrHQba4q9uHt8Cuf2isGq5YRPWnPoz5bmyAj2E2m24UB0dDQAOTk5xMQcvXYvJyeH3r17u/bJzc1tcL+6ujoKCwtd94+OjiYnJ6fBPkdun2ifn24/US3H4+XlhZfXsUOG7HZ7i/hFbil1yslpVf1pGOZcAouegMOhADZP6DsVy/A7sQXF09yDeKfTYMOhYuZsyWb25iwOFR1dctDTw8rIlAjO6B7N+NQognyP9tuRYWGtqj9F/dlMbC/YzsxdM/lm3zfc2ONGpvWcBsCEpAmE+YYxIHoAVsuvz+ehvmxd1J+ti7v7c0xqNKM6R/H1pkyenLOTjOIq7v1sC2//mM5fp6QytGO422pridzdny3Jyf6cmm04kJycTHR0NAsWLHCdgJeWlrJy5UpuueUWAIYMGUJxcTFr166lX79+AHz//fc4nU4GDRrk2uevf/0rDofD9UOZN28enTt3JiQkxLXPggULuPPOO13ff968eQwZMuSkaxGRJmAYsHcBLHoSDq4022xe0O9aGH4nBDbvZcLqnQZrDxQxe3MW323NJquk2rXN225lTOdIzugRw9gukfh7NduXZ5FWpdJRyey02Xyy6xO2Fhy99GhV9ipXOGC32RkUM8hdJYpIK2K1Wji3dxyTukXz1vL9zPh+D1szS7nitZWM7RLJA2d0ISUqwN1lShvl1v8+y8vL2bNnj+t2WloaGzZsIDQ0lHbt2nHnnXfyf//3f6SkpLiWD4yNjeW8884DIDU1lcmTJzNt2jReffVVHA4H06dP57LLLiM21jxJuOKKK3jkkUe44YYbuO+++9iyZQvPP/88zz77rOv73nHHHYwaNYqnn36aM888kw8//JA1a9bwn//8BwCLxXLCWkTkNDIM2DMfFj4OGWvMNg9v6H89DL0dmvHM4HX1TlamFfLtlizmbMkhv/zoJKV+njbGpUZxRvdoRnWOwNdTgYBIU3ps5WN8vudzqurMkTseVg8mtJvARZ0uon90/xPcW0Tkt/O227h5VAcu6Z/ACwt28+6PB/h+Ry4Ld+Zy2cB23Dk+hcgALZcuTcut/4muWbOGMWPGuG4fuT5/6tSpvPXWW9x7771UVFRw0003UVxczPDhw5kzZw7e3kcPlPfee4/p06czbtw4rFYrF154IS+88IJre1BQEHPnzuXWW2+lX79+hIeH89BDD7mWMQQYOnQo77//Pn/729/4y1/+QkpKCl988QXdu3d37XMytYhIIzMM2D3XvHwgY63Z5uEDA24wQ4GAqF+/v5vU1TtZsa+AbzaZIwSKKo/OEBvo7cH4rlFM6R7D8JRwvO3N/QIIkdYjvyqfcJ+jw3bLHeVU1VWRGJjIRSkXcU7Hc46ZS0BE5HQK9fPk7+d045ohiTwxZwffbc3h/ZXpfLk+g9vHpXDdsGQ8PbQ8sTQNt4YDo0ePxjCMX9xusVj4xz/+wT/+8Y9f3Cc0NJT333//V79Pz549WbJkya/uc/HFF3PxxRf/rlpEpJEYBuyaY4YCmevNNrvv0VDAP/LX7+8G9U6DVWmFzNqUyZwt2RRU1Lq2hfp5MrFrFJO7RzO0Q7j+yIs0odr6Wr4/+D1f7PmCFZkr+PDMD0kNSwXg+u7Xc2HKhfSJ7ONaClRExB3aR/jz76v7syqtkH9+s42Nh0p47NsdfLT6IA+e3ZUxnZvf/z7S+mgMq4g0H4YBO2eboUDWRrPN7gcDb4Qht4F/hHvr+xmn02BtehGzNmYye0s2eWVHLxkI9fNkcvdozuwRw6DkUDxsCgREmophGGwv3M4Xe77gm33fUFp7dJbm1dmrXeFAh+AO7ipRROS4BiaH8vkfh/HpukM8MWcn+/IruO7N1YzrEsmDZ3UlKdzP3SVKK6ZwQETcz+mEHbPMiQZzNpttnv4wcJoZCviFube+nzAMgw0Hi5m1KYvZm7MaTCoY6O3B5O7RnNUzlqEdwhQIiLhBZnkmt39/OzuLdrraonyjOKfDOZzX8TzaBbZzY3UiIidmtVq4uH8Ck7pH8+KC3by5bD8LduSyZHc+N4xIZvqYjvhp4mI5DfRbJSLu43TC9q9g8VOQs8Vs8wyAQTfBkOng2zyu/TUMgy0ZpczalMmsTVlkFB9ddjDAy4MJ3aI4u2cswzrqkgGRplZbX0t6aTodQzoCEOkbSUF1AZ5WT8a1G8d5Hc9jUMwgbFbN7yEiLUugt52/ntmVSwe045Gvt7Jkdz6vLNzLZ+sO8ZcpqZzTK1aXREmjUjggIk3P6YRtX5ihQO42s80rEAbdDINvaRahgGEY7MguY9amTL7ZlMX+gkrXNl9PG+NTozirZwwjO0VoUkGRJmYYButz1zNr3yy+2/8d3jZv5l40F5vVhofVg2dHP0tyUDJBXkHuLlVE5HfrGOnP/64fyPztuTw6axvphZXc8eEG3v3xAI+e150u0YHuLlFaCYUDItJ0nPWw9XMzFMjbYbZ5BZmBwOCbwSfEvfUBu3PK+HpTFt9symRvXoWr3dtuZVwXMxAY3TkSH08FAiJNbX/Jfr7e9zXf7PuGjPIMV7u3jzeZ5ZkkBCYA0Duyt5sqFBE5PSwWCxO6RjEiJZzXluxjxg97Wb2/iDNfWMqNw5O5Y3yKlkSW302/QSJy+jnrYctnsPhJyN9ltnkHweBbYdAfwCfYreWlF1Ty1cYMvt6Yxc6cMle7p4eV0Z0iOKtXLOO6ROr6PhE3emPLGzy79lnXbV8PXyYkTuCsDmcxIGqALhsQkTbB225j+tgULugbzz++3sacrdn8e/E+Zm3K4h/ndmNcavNc5llaBv2nKyKnT30dbPnUHClQsNts8w425xMYdJMZELhJXlkN32zK5MuNmaxPL3a1220WRqZEcFavGManRhHgbXdbjSJtVXVdNQsPLiQ5KJnOoZ0B6B/VH5vFxtDYoZzd4WxGJ4zGx8PHvYWKiLhJbLAPr17djwXbc3joy61kFFdxw9trmNQtir+f042YIL0+yqlTOCAija++DjZ/DIv/BYV7zTafEDMUGHgTeLvn2riyagffbc3hyw0ZLNuTj9Mw260WGNYxnLN7xTKpazRBvgoERJqaw+lgVdYqvk37lvnp86lwVHBhyoX8fejfAegR3oPvL/meUG/3z0kiItJcjEuNYkiHMJ5fsJvXl6Tx3dYclu7O564Jnbh2aJJWTpJTonBARBpPvQM2fWSGAkVpZptPKAy9zVyW0CugyUuqdtSzcGceX23MYP72XGrrnK5tvROCObd3LGf2jCEywLvJaxNp6wzDYE3OGuakzWHegXkU1RS5tsX5xzVYdtBisSgYEBE5Dl9PDx44I5Xz+8Tx18+3sPZAEf/3zXY+W5fB/7ugB70Tgt1dorQQCgdE5Perd8DGD2DJ01C032zzDYdht0P/G8DLv2nLcRr8uK+ALzdk8O2WbMqq61zbOkT4cV7vOM7uFUtSuF+T1iUix3p4+cMcLDsIQKh3KBMSJ3BG8hn0ieyD1aJ3vERETlaX6EBm/mEIH685yGPf7mBbVinnv7yMqUOSuGdSZ82dJCek3xAR+e3qamHj+2YoUJxutvlFwLA7oP/14Nl0J9+GYbDpUAlfbsjk602Z5JXVuLbFBHlzTq9YzukdS9eYQK0JLNLEDMNgV9Euvk37luWZy3l3yrt42jyxWCxc1Oki9pfsZ3LyZAZGD8TDqn9NRER+K6vVwmUD2zG+axT/b7Y5euCt5fuZvz2Hxy/oyfCUcHeXKM2Y/gKLyKmrq4EN78GSZ6DEfMcP/ygzFOh3HXj6Nlkpe3LL+WpjJl9tyGB/QaWrPdjXzpQeMZzbK5YBSaFYrQoERJpaWkkac9Lm8O3+b0krSXO1L8tYxph2YwC4vvv17ipPRKTVCvf34plLenNe7zge+Gwzh4qquOr1lVzaP4G/nJlKkI/mV5JjKRwQkZNXVwPr/gdLn4PSQ2abfzQMvxP6XQv2ppkZN7ukmq83ZvLFhgy2Zpa62r3tViZ0jebcXrGM7BSBp4eGJIu4w9qctTy28jF2Fu10tXlaPRkZP5LJyZMZHDvYjdWJiLQdIztFMPeukTw5ZwdvrzjAR2sOsnBXLv93Xg8mdNWyh9KQwgEROTFH9eFQ4FkoyzTbAmJg+F3QdyrYT/9kfhU1dczZks3n6zNYtjcf4/BKAzarhZEp4ZzbO44JXaN0PZ1IEztyyYDVYiUlJAWAYK9gdhbtxMPiweDYwUxJnsKYhDH4ezbt/CMiIgJ+Xh48cm53zuwZy32fbiItv4Jp/1vDOb1iefjsroT5e7m7RGkm9F+0iPwyRxWsfRuWPQdlWWZbYJwZCvS5+rSHAnX1TpbtLeDzdYf4bmsOVY5617b+iSGc2yeOKd2j9UdNpIkZhsG2wm3MPzCfeQfmcaD0AJOTJvPUqKcA6BDcgadGPcXg6MEEewe7t1gREQFgYHIo394xgmfn7+K/i/fx1cZMlu7J5+/ndOPsnjGak0kUDojIcTiqYM2bZihQnmO2BcbDiLuhz1XgcfpOxg3DYFtWKZ+vy+DLjQ0nFkwK8+X8PvGc3yeOdmFNN6+BiJg25W1i3oF5zDswj4zyDFe7p9UTm9XWYN/JSZObujwRETkBb7uNB85IZUr3GO79ZBM7c8q4/YP1zNqYyf+7oAfhesOlTVM4ICJH1VYcDgWeh4pcsy2onRkK9L4SPDxP27fOLqnmiw0ZfL4ug505Za72YF87Z/eM5fy+cfRJCFaqLdKEDMNocMz9c+U/2VawDQAfDx+Gxw1nYuJERsSPwM+upUFFRFqKXgnBfH3bcF5euIeXvt/D3G05rD1QxGMX9GBit2h3lyduonBARMxQYPVrsPxFqMgz24LbwYg/Q6/LT1soUO6aR+AQy/cWuOYR8LRZGZcayfl94hjdOVITC4o0oaq6KpZnLueH9B9YkbmCL877ggDPAADO6XAOiYGJTEycyLC4Yfh4NM0kpCIi0vg8PazcOb4TE7tGc/fHG9iRXcZN76zlon7xPHx2VwK8taJBW6NwQKQtqymH1f81Q4HKArMtJOlwKHAZ2Br/j8KReQQ+W3eIuT+bR2BAUgjn94nnzB4xBPnqD5JIUymsLmTRwUX8cNAMBKrrq13blmUuc10icGXqlVyZeqW7yhQRkdOga2wgX04fxjPzdvGfxfv4ZO0hVuwt4F8X92JIhzB3lydNSOGASFtUUwar/gPLX4KqQrMttD2MvAd6XNzoocCJ5hG4oG885/XWPAIi7jB3/1zuWXwPTsPpaovzj2NMwhjGthtLn8g+bqxORESagpeHORfBuC5R/GnmBg4WVnH5f3/khuHJ3DOpM95224kfRFo8hQMibUl1Kaz6N6yYAVVFZltYRzMU6H4R2Br3JSG31JxH4NO1mkdAxN2chpPtBdtZkL6ArmFdGZ84HoCeET1xGk5SQ1MZ024MYxPG0imkk45LEZE2yFzRYCT//GYbH6w6yOtL01i8K49nL+1N97ggd5cnp5nCAZE2wKO+EuuSf8GqV6G62GwMS4FR90L3C8HaeGlwTV09C7bn8snaQyzalUe905xIQPMIiDS9SkclK7JWsPjQYpYcWkJelTmnyPC44a5wINovmu8v/p4I3wh3lioiIs2Ev5cHj13Qkwldo7j3k83szi3nvBnLuGNcCn8c0xGbVeFxa6VwQKQ1qyrGuvwlJm6dga2+0mwL72yGAt3Ob7RQwDAMNh0q4ZO1h/hqYyYlVQ7Xtr7tgrmwXzxn9YjVPAIiTcRpOLn9+9tZnrkch/Po8fjTFQZ+SsGAiIj83NguUcy9K4S/fr6Zb7dk8/S8XSzZk89zl/YmNlgT0rZGCgdEWqPKQvjxFVj5KraaUmyAEdEFy6h7oet5jRYK5JZW8/n6DD5Ze4jdueWu9uhAby7oG8eF/eLpEOHfKN9LRI6vzlnHhtwN7CjcwVVdrwLAarFSVVeFw+kgzj+O0QmjGRk3kv7R/fG0nb4lSUVEpHUJ9fPk5Sv78sWGDB78Yiur0go54/klPHFhDyZ3j3F3edLIFA6ItCaVheZ8Aiv/DbXmNf5GRCpr/MbR+4qHsHt6/e5vUe04ctnAQRbtyuPwVQN4eViZ3D2aC/vGM6xjuIaciZxGxdXFLMlYwpJDS1iauZSyw8f75OTJhPuEA3BXv7vw9fAlOShZ8weIiMhvZrFYOL9PPH3bhXD7hxvYeLCYm99dxxWD2vHgmV3x8dRkha2FwgGR1qCiAFa8ZK5AUHv4HfyoHjDqXuo6TiLz2zn0tvz2a/wNw2DjoRI+WXuQrzdmNbhsoF9iCBf1i+fMnjEEaj1ckdNq/oH5vLn1Tbbkb2mwukCwVzDD44ZTXXd0CcLu4d3dUaKIiLRSiWF+fHLzEJ6Zt4tXF+3l/ZXprE4r5IXL+5AaE+ju8qQRKBwQackq8mH5i7Dqv+CoMNuie8Ko+6DzFLBaweH49cf4FTk/uWxgz08uG4gJ8ubCvvFc0DeO9rpsQOS0yK3MZVnGMgZEDyA+IB6AyrpKNuVtAqBTSCdGxo9kVPwoeoT3wNaIE4uKiIgcj91m5b7JXRjWIZy7Pt7A7txyzp2xjL+dmcrVgxM1Uq2FUzgg0hKV58HyF2D1a+A4PNFgTC8YdT90PgN+xwtztaOe+dtz+GTtIRb/5LIBb7uVyd2iuahfAkM6hOmyAZFGVltfy7rcdSzPWM7SzKXsLtoNwJ/6/Ylru18LmKsMPDL0EYbGDiXaL9qN1YqISFs2PCWcOXeM4J5PNvH9jlwe+nIri3fl8+RFPQn109w2LZXCAZGWpCzncCjwOtRVmW2xfcxQoNOk3xUKbMko4eM1B/lifQal1XWu9gFJIVzYN54pumxA5LQocZZw+8LbWZu7lqojxzVgwUL38O6E+oS62kK9Q7kg5QJ3lCkiItJAmL8Xr0/tz1vL9/PY7B3M357DGc8v5oXL+jCofZi7y5PfQOGASEtQlg3Lnoc1b8CRa4rj+pmhQMqE3xwKFFfW8sX6DD5ec4htWaWu9tggby7sF88FfeNJDvdrjGcgIkBpbSmrs1djGAbjE8cD4GvxZXXOamrqawj3CWdY7DCGxQ1jSMwQgr2D3VuwiIjIr7BYLFw3LJmByaHc/sF69uZVcMVrK/nzxM78YWR7rBpp2qIoHBBpzkqzYNlzsPato6FA/EAYfR90GPebQgGn02DZ3nw+XnOI77ZmU1tnTmrm6WFlUrdoLukfz7AO4XoxF2kENfU1rM9dz8qslazMWsnWgq04DScdgzu6wgG7xc4jgx+hY2hHOoV00vWaIiLS4nSLDeLr24bzt8+38Nn6DJ6Ys4M1+wt5+pJeBPvqMoOWQuGASHNUknE4FHgb6mvMtoTBZijQfsxvCgUyiqv4fEMan6w9REbx0aHLXWMCuXRAAuf2jtWLt0gj+uvSv/Ld/u+oOXIMH5YclEz/qP7UOY9evjMxcSJ2uy7bERGRlsvX04OnL+nFgORQHv5qKwt25HLmC0t5+cq+9EoIdnd5chIUDog0JyWHYOmzsO5/UF9rtrUbaoYCyaNOORSodtTz7aYsXtlmZfePSzAOTy4Y6O3BeX3iuKR/At3jghr5SYi0HYZhkFaaxsqslWzM28g/h/3TtWqABQs19TVE+kQyOHYwg2IGMSh6EFF+Ua77O+p/+2oiIiIizY3FYuHyge3oERfEre+v40BBJRe/uoK/naXVDFoChQMizUFx+uFQ4B1wHj5ZSBxuhgJJI045FNiaWcLHqw/yxYZMSqocgBWAYR3DuKR/ApO6ReNt17JnIr9FdkU2q7JXsTJrJT9m/UhuZa5r29Vdr6ZbWDcAbuhxA9f3uJ7kwGT9MyQiIm1K9zjzMoN7Zm7ku605PPTlVlbvL+KxC3rg76VT0OZKPSPiTkUHYMnTsOH9o6FA0ggYfT8kDT+lhyqpdPDlxgw+Wn2QrZlHJxeMCfKmZ0Al910ykvaRGiUgcqoMw3Cd3L+99W3+teZfDbZ7Wj3pE9mHQTGDCPM+OjtzclByk9YpIiLSnAR623n1qn68vjSNx7/dwdcbM9maWcIrV/ajc3SAu8uT41A4IOIOhWlmKLDxAzhy3XHyKDMUSBx60g/jdBqs2FfAR6sPMuenkwvarEzoFsUl/RMYlBjEd3O+JSHE93Q8E5FWxTAMMsozWJOzhjXZa1iTs4Z7+t/DuMRxAKSGpmK1WEkNTWVwjHmpQJ/IPnh7eLu5chERkebHYrFw44j29GkXzPT317Mvr4JzZyzl/53fgwv6xru7PPkZhQMiTalwHyw+HAoY9WZbh7Ew6j5oN/ikHyajuIpP1hxi5tqDHCo6Orlgl+gALumfwPl94gjxMycXdDh0TbPIrympKWFB+gJXGJBVkdVg+5qcNa5woE9UH5ZetpQAT73jISIicrL6JYbyze0juPOjDSzelcfdH29kc0YJf5mSit1mdXd5cpjCAZGmULAXFv8LNn10NBToON4MBRIGntRDOOqdLNiewwerDrJ4d55rcsEALw/O6R3LpQMS6BEXpGubRX6FYRgcKD1AnbOOjiEdASitKeXh5Q+79vGweNAtvBv9o/rTP7o/fSL7uLbZrXbsnlpVQERE5FSF+nny1rUDeG7Bbl5YsJs3l+1ne1YpL13Rl3B/L3eXJygcEDm98nebocDmj8Ewh/yTMtEMBeL7n9RDHCio4MPVB5m55hD55UeXRBvSPoxLBsQzuVsMPp6aXFDkeBz1DrYXbmd97nrXR2F1IWMTxvL82OcBiA+IZ2zCWDoEd6B/dH96R/TG167LcERERBqb1Wrh7gmd6BYbyN0fbeDHfYWc8+JS/n11f3rEa24sd1M4IHI65O2CxU/Clk+PhgKdJsOoeyGu3wnvXlNXz9ytOXy4Op1lewpc7eH+XlzcP55L+yeQFO53uqoXafEMw+CW+bewNmct1fXVDbZ5Wj0b3LZYLK6gQERERE6/Sd2i+XL6MG7631r25Vdw4avLeez8HlzYT/MQuJPCAZHGlLvjcCjwGXB43H/nKWYoENvnV+8KsCe3nA9XpfPZ+gwKK2oBcxXDkSkRXD4wgXGpUbouS+QnssqzWJe7jvW56ympKeGpUU8B5gl/haOC6vpqgryC6BPZhz6Rfegb2ZeuYV3xtHme4JFFRETkdOoYGcAX04dx14cbWLAjlz/NNOch+OuZmofAXRQOiDSGnG1mKLD1C1yhQJezzFAgptev3rXaUc/szVl8uOogq/YXutqjA725pH88lwxIIF4rDYgAsKdoD6tzVrsuEciuyHZts1qsPFT7kGuywHsH3Iuf3Y+koCSsFv2TISIi0twEetv57zX9eW7+Ll74fg9vLTfnIZhxpeYhcAeFAyK/R/YWMxTY9uXRttRzzFAgusev3nVHdikfrjrIZ+sOUVptLmdotcDYLpFcNqAdoztH4KHUVNqw3MpcNuVtYkzCGGxWc16NN7a8wdf7vnbtY7PY6BLaxRwVENUXu/XoZIE9In79GBQRERH3s1ot3D2xM93igrj7ow2sTDPnIXj16n70jA92d3ltisIBkd8iaxMsegJ2zDrcYIGu55qhQFS3X7xbZW0dszZm8cHqdNanF7va44J9uGxAAhf3TyA6SOulS9tTU1/D9oLtbMzbyKa8TWzK3+QaFfDpOZ/SKaQTAINiBlFYXUivyF70jexLj/AemjxQRESkFfj5PAQXv7qCpy/pxVk9Y91dWpuhcEDkVGRthIVPwM5vDjdYoNv5ZigQmfqLd9uSUcIHq9L5ckMm5TXmKAEPq4UJXaO4bGA7hncMx2bVEoTSNhiGgYHhGur/8c6PeWzVY9Q56xrsZ7VYSQlOoay2zNV2bsdzObfjuU1ar4iIiDSNI/MQ3PHBen7Ymcf099ezL6+C28Z21HLdTUDhgMjJyFxvhgK7vj3cYIHuF8LIeyCyy3HvUlbt4KuNmXywKp0tGaWu9qQwXy4d0I6L+sUTEaBrqaT1y6/KZ1vBNrbkb2FrwVa25G/h4SEPM7bdWADi/OOoc9YR6h1Kr4he9IzoSa+IXnQL66ZRASIiIm1MoLed16YO4P/N3s7rS9N4Zt4u9uaV88SFPfG2a/nu00nhgMivyVhrhgK7vzNvW6zQ42IY8WeI6HTcu2w6VMz7K81RAlWOegA8bVYmdY/m8gEJDG4fhlWjBKSV21u8l5fWv8SWgi0NJg08YlPeJlc40C+qH3MunEOsX6zeFRARERFsVgsPntWVjpH+PPjFFr7ckMmBgkr+c00/QrwVEJwuCgdEjufQGlj4OOyZZ962WKHnpWYoEN7xmN0ra+v4akMm761MZ3NGiau9Q4Qflw9sxwV94wn109Jp0rpUOCrYXrCdrQVb2Zq/lSGxQzg/5XwAPKwezE+fD4AFC8lByXQP707XsK50C+tGatjRy3C8PbyJ849zy3MQERGR5uvyge1IDPPllnfXseFgMee9tIx/X3Xi5cHlt1E4IPJT6Sth0eOw93vztsUGvS6DEX+CsA7H7L4ju5T3V6bz+boMyg7PJeBpszKlRzRXDEpkQFKI3gmVVqPSUcnnez5nW8E2tuZvZV/JPowjS3cCTpyucCAhIIF7+t9DalgqXcO64mf3c1fZIiIi0oIN7RDOF7cO44a3VrMvv4JL/7uKK5MtTHF3Ya2QwgERgAMrzFBg30LzttXjaCgQ2r7BrtWOer7dksV7P6az5kCRqz0pzJcrBrXjon4JGiUgLVpJTQk7C3eyvXA7gZ6BrhN+m9XGv1b/izrj6MSB0X7RdAvrRvfw7vSL6udqt1qsXNPtmiavXURERFqf5HA/Pv/jMG55by3L9xbw2k4roUv3c/NoTVTYmBQOSNu2f5kZCqQtNm9bPaD3lTDibghJarDrvrxy3l+ZzifrDlFc6QCOrjhw5aBEhnbQXALSMi0+tJitBVvZUbCDHYU7yKzIdG3rGtbVFQ542by4tMulBHoG0i2sG93CuxHuE+6uskVERKQNCfK18/b1A3nwi818uPoQT3y3i7SCSv7vvB54eljdXV6roHBA2qa0JbDoCdi/xLxttUOfq8xQILida7faOifztuXw3soDLN9b4GqPC/bh8oEJXNI/gchA76auXuSU1TvrOVB2gB0FOyh3lHNJ50tc2x5b+RiHyg812D/OP44uoV3oGdGzQfv9A+9vknpFREREfs5us/KPs1OpyTvAlwdsfLzmEJnF1bxyVV8CvO3uLq/FUzggbYdhmCMEFj0BB5aZbTZP6HM1DL8LghNcux4srOTD1el8tPoQ+eU1AFgsMLZzJFcObseoTpHYNEpAmrEjSwfuKtrFjsId7CraRVVdFQAB9gAu7nSxaxje+MTxFFQV0CW0C6lhqXQO7UygZ6A7yxcRERE5LovFwugYgykj+nDHR5tYuiefi19dwVvXDSQ6SG/a/R4KB6T1MwxzLoFFT0D6CrPN5gl9p8LwOyEoHoB6p8EPO3J5b+UBFu7Kwzg8z1pkgBeXDkjg0gEJxIdozXVpPuqcdaSXprOreBcHSw8yrec017YX1r/AsoxlDfb3tnnTKbQTqaGpVNdX4+PhA8Cf+v+pSesWERER+b1Gd4rgo5uGcN1bq9mRXcb5Ly/jresG0jk6wN2ltVgKB6T1MgzYuwAWPQkHV5ptNi/od60ZCgTGApBdUs1Hqw/y0ep0MkuqXXcfkRLOlYPaMS41CrtN1zGJ+23J38KqzFX8UPED7377LvtK9lHrrHVtv7DThYR6hwLQP6o/GJASkmKOCAhNJTEwEZtVawOLiIhI69AjPojP/ziUa99cxd68Ci56dTn/vrofQztoTqTfQuGAtD6GAXvmw8LHIWON2ebhDf2vh6G3Q2AMTqfB0l15vLfyAPO351LvNIcJhPjauaR/ApcPbEdSuJZek6ZX4ahgX/E+dhfvZnfRbqb3me5aBvCrvV/xwY4PzB0PL5Th4+FDSnAKKSEpOOodrse5sceN3NjjxqYuX0RERKRJJYT68uktQ7npf2tZtb+QqW+s4qmLenFenzh3l9biKByQ1sMwYPdc8/KBjLVmm4cPDLjBDAUCoiisqOXjRXt5f2U66YWVrrsOTArlysHtmNQtGm+73lmVprM+dz3zD8xnb8le9hXvI6siq8H2ycmT6RXRCzBHA+RV5OHMc3LmgDNJDU8lLiAOq0UjW0RERKTtCvb15H83DORPMzfyzaYs7vxoAxnFVfxxdActdXgKFA5Iy2cYsGuOGQpkrjfb7L6uUMDwi2DDwWLemb2BWZuzqK1zAhDg7cGFfeO5YlA7OkXp2iQ5PUpqSthXso+9xXtdH/cMuIeUkBTAnDjwf9v+1+A+4T7hdAjuQEpwSoOJAScmTWRM3Bhmz57NmIQx2O2alVdEREQEwNtu48XL+hAb5M1/l6Tx1Hc7ySiu4h/ndMNDlwifFIUD0nIZBuycbYYCWRvNNrsfDLwRhtxGlWcoX2/M5H8/LmVLRqnrbj3igrh6cCJn94rFx1OjBOT3MwwDA8P1Dv6PWT/y2ubX2Fu8l/yq/GP231m00xUO9Insw1WpV9EhuAMdgjvQPqg9QV5BTVq/iIiISGtgtVr465ldiQv24ZFZ23h/ZTo5JdW8eEUffD116nsi+glJy+N0wo5Z5kSDOZvNNk9/GDgNhtxGWpU37y08wMy16ympMq/B9vSwcnbPWK4ekkjvhGD31S4tWm19Leml6ewv3c/+0v2klaSZX5fs58EhDzI5abJrv5VZK133i/GLoX1wezoEmQFAn8g+rm1dw7rSNaxrkz8XERERkdbq2mHJRAf5cMeH61mwI5crX1vJm9cOINjX092lNWsKB6TlcDph+1ew+CnI2WK2eQbAoJuoH3Qr36fX8c5He1m8K891l4RQH64alMjF/RMI9dOLgZyYYRjkV+Wzv3Q/0X7RJAQkALA8Yzm3LLgFp+E87v3SStJcX3cP786jwx6lQ1AH2ge3d00oKCIiIiJNY3L3aN6fNojr31rD+vRiLvn3Cv53/SCig7zdXVqzpXBAmj+nE7Z9YYYCudvMNq9AGHQzBT1u4MMt5bz/0kYyiqsAsFjMdU+vGZLEyE4R2KyahESOr7S2lBWZKzhQesAcBVBijggod5QDcEffO1wz/kf7R+M0nPjb/UkKTCIpKKnB58TARNfjhnqHcl7H89zxlERERETksH6Jocy8eQhXv76SXTnlXPjKct69cRDJWpXsuBQOSPPlrIetn5uhQN4Os80rCGPwzWyMu4K31hUx+7n11Nab7+QG+9q5tH8CVw5KpF2YrxsLl+airLaM9LJ0DpYe5EDpAdLL0hkaO5Qz258JQE5FDn9e9Odj7me1WIn1i8VuPTrhX2JAIj9c8gNh3mGa9VZERESkhegUFcAnNw/l6tdXsr+gkoteWc7b1w+ke5zmePo5hQPS/DjrYctnsPhJyN9ltnkHUTvgFr72PpvX1xSx7butrt17xQdx9ZAkzuoZo2UI26CSmhIcTgfhPuEAZFdk8+dFfya9NJ2imqJj9rdb7a5wICEggV4RvUgMTCQ5KNkcCRCYRLvAdnjaGl6GYrPaXN9DRERERFqOhFBfZt48lGvfXMXWzFIu+8+P/Pea/gzpEObu0poVhQPSfNTXwZZPzZECBbvNNu9gCntN4781E3l3SRFl1QcA8PKwck6vWK4anEgvTTDY6jmcDjblbSKjPIODZQdJL003P5elU1JTwsWdLuahIQ8BEOgZyMa8ja77hnmH0S6wHe0C2tEusB29I3q7tnl7ePPulHeb+umIiIiISBOLCPDig5sGM+3tNaxMK2Tqm6t46fI+TOwW7e7Smg2FA+J+9XWw+WNY/C8o3AuA4RPC7g7X8lTRSOYtqgLMSQbbhfpy1eB2XNwvgRBNMNgqGIZBaW0ph8oPkVGWQUa5+ZEclMyVqVcC4Kh3cO2ca3/xMYpril1f+9p9eX7M88T6x5IQkKDJAEVEREQEgEBvO29fP5DbP1jP3G053PzuWp64sCcX909wd2nNgsIBcZ96B2z6yAwFisyZ3p3eofwYfQUPZQ5hzxoLUIXFAmM7R3LVkERGpURg1QSDLU51XTWZ5ZnUG/WkhKQA5nJ/V86+koyyDMocZcfcZ0jMEFc44Gv3pVtYN/w9/Yn3j6ddYDsSAxJJCEwg3j8eX3vDOSbGtht7+p+UiIiIiLQ43nYbL1/Zlwc+28zMtYe455NNFFc6mDayvbtLczuFA9L06h2w8QNY8jQU7QfA4R3GNwEX83DmIEqKvQAI8bVz6YB2XDmoHQmhmmCwJTAMg5m7ZpJZnklWRRaZ5ZkcKj9EflU+AENjh/LvCf8GwNPmSXZFtisYCPMOIy4gjnj/eOL840gNS23w2B+e9WHTPhkRERERaZU8bFaevKgnoX6e/HvxPv45eztFlbXcM6lzm554WuGANJ26Wtj4vhkKFKcDUO0Zyju283imaDhVxeaao70TgrlmSCJTemiCweYirzKPzArzhD+rPKvB58TARJ4e/TQAFouFF9e/2GCY/xH+dn+8bF4N2p4b8xzBXsHE+sfi4+HTFE9FRERERASLxcIDU1IJ8fPk8W938PLCvVQ56nnorK5tNiBQOCCnX10NbHgPljwDJQcBKLeH8YrjLF4vHU01Xnh5WLmkdyxXD06iR7yWFWlKlY5Ksiuzya4wPzLLM/Gz+3Fd9+tc+1zw1QXHPeEHqKmvaXD7rPZn4TScxPjFEOMfQ7x/PPEB8QR6Bh7zQtsvql+jPx8RERERkZN186gO+Ht58LcvtvDmsv1UO5z887zubfJSZoUDcvrU1cC6/8HS56D0EADFtjBeqJnCe9XjqMGT+BAfrhmSyCX9Ewj21QSDjenIRH8ZpRnscuwiICOAsUlHr8W/bs517Czcedzr/ZMCkxqEA/H+8fh4+LhO+GP8jn7EBcQ1uO99A+87fU9KRERERKSRXTU4ES8PK/d9uokPVqVTU1fPkxf2xMNmdXdpTUrhgDQ+R/XhUOBZKMsEIN8Syou1Z/Nh9Rhq8GR4x3CmDk1ibJdIbG0wlfu9nIaTouoiyh3lJAYmutofX/U4u4t2k1OZQ05FDtX11a5ti9cvbhAOlDvKXcGAv92fKN8o14n/Tx8T4P0z32+zw6tEREREpPW7uH8CXnYbd320gc/WZVBT5+S5S3tjb0MBgcIBaTyOKlj7Nix7DsqyAMgmjJcc5zCzfhQ2Tx8uGRDP1KGJdIwMcG+tzZTTcFLuKCfQM9DV9t7290grSSO/Kp+8qjzyKvPIr8rH4XSQFJjE1+d/7dp3Xc46thdub/CYwV7BeDu8SQlOadD+6LBH8bR6Eukbib+n/6/WpWBARERERFq7c3rF4uVhZfr76/hmUxY1DiczruyDl0fbmAdN4YD8fo4qWPMmxrLnsJTnAJBhhPFy3bnMrB9FbFgQ9w1J4qL+8QR6291crHsYhtHgBPvbtG/ZX7qf/Mp8cqtyXZ8LqwqJC4hj1vmzXPt+uefLY074ASxYcBrOBm039riRWmctUb5RRPtGE+Ebgc2wMXv2bKYMn9Jg3y6hXRr5WYqIiIiItGyTukXzn2v6c/M7a5m/PYcb317Df67uj49n6w8IFA7Ib1dbAWvexLnseawVuViAQ0Y4M+rO5ZP6UQzrHMO/hyYxKiWiVU7o8fMT/sWHFnOw7CAFVQUUVBeY7/Qffpff39Ofr877yrXvm1vePO4JP0BBVUGD2+d0OIfhccOJ9I0kwieCcN9wIn0iCfcNx25tGLZMTJp4zOM5HI7f8zRFRERERNqUMZ0jefPaAdzw9hqW7M7nurdW8frUAfh5te7T59b97OT0qK2A1a9Rt/QFPKrysQIHnRG8VH8ecz3GcN7gJOYOSSI53M/dlZ4yp+HEajl6XdEP6T+QXpZOQXWB66S/sKqQgqoCfO2+DYb0v7zhZbYWbD3u45Y7yhvcHtNuDF3DuhLhG0GEz+EP3wjCfcIJ8wlrsO9VXa9qxGcoIiIiIiInMrRjOO/cMJBr31zNj/sKufr1lbx1/cBWPRJa4YCcvJpynKv+S93S5/GsKcIDOOCM5KX689gUOpmrhnbgob7xzSpRcxpOKhwVBHgeneNgTtocDpYdpLC6kMLqQteJf2F1If52f7654BvXvv/Z9B+2FGw57mP7OHwa3B4cM5g4/zjCfMII8w4jzCeMSN9Iwn3CifCJaDDS4JZet5yGZysiIiIiIo2lf1Io7904iGveWMW69GKu/O9K3r1hEEG+rTMgaD5ncdJ81ZRRvexVWPES3o5iPIE0ZxQv1Z9Pecr5XD2sI092DGuSSeuq66opqi6iqr6K9kHtXe3vbHuHfSX7KK4uprC6kOKaYoqqiyipLSHaN5rvLvquwb6b8jcd9/Gr6qoa3B4SO4SEwATXyb7r8+Gvf3rCf2e/Oxv/CYuIiIiIiNv0Sgjmg2mDufr1lWzOKOHK13/k3RsGtcpl2BUOnKIZM2bw1FNPkZ2dTa9evXjxxRcZOHCgu8s6PWrKyJv7Mn7r/o1vfSkAe50xvGG9EP9Bl3HnkA4khPr+poc2DINyRzklNSWU1JZQUlOC03AyPG64a59n1jzDrqJdFNUUUVxdTFFNkevkPcYvhrkXzXXtO2f/HDblHf+Ev6imqMHtEfEj6BDcgWDvYEK9Qo856f/pCf/tfW//Tc9PRERERERah66xgbw/bTBX/PdHtmSUcuVrK3nvxtYXECgcOAUfffQRd999N6+++iqDBg3iueeeY9KkSezcuZPIyEh3l9do6iqKCdz3JTUb/kiEYV4rv9cZwyf+V5A46mr+1qddg9k6y2rLKK4pprSm1HWyX1xTTElNCV42L67rfp1r35vn38z2gu2U1JRQb9Q3+L7RftHMu2ie6/ba3LXHPeH3sHrgYW34q3tuh3MZHjecEK8Q10l/sHcwod6hBHkFNdj35l43//YfjoiIiIiItDmdowP44CYzINia2ToDAoUDp+CZZ55h2rRpXHedebL76quv8s033/DGG29w//33u7m6xlFWnI/zud7gW89sfxtplnh2BPbAL6E9vt7l7C97kk0rQ/h/I/6f6z5XfHMF+0v3H/fxov2iG4QDZbVlFFYXum5727wJ9Aok2CuYKN+oBve9rtt1lDvKCfEKIcQ7xPXZz+53zCUMl3S+5Pc/eRERERERkV/QKSrANYJga2YpV/zXDAhC/FpHQKBw4CTV1taydu1aHnjgAVeb1Wpl/PjxrFix4rj3qampoaamxnW7tNQcmu9wOJrt8nLefkGs8e7LEyFpZHgeOQHfCtlHZ+GP8o1qUH+gZyDeNm+CvIII9AwkyDPI9XW4T3iDff824G8ABHkGEeAZgLeHd4Pv/9N9R8WOOm6NdXV1v/dptilHfqbN9XdOTo36s3VRf7Ye6svWRf3Zuqg/Wxd392dyqDf/u64/V7+xhm1ZpVzzxkpm3jQIWzNeuv1kf1YWwzCM01xLq5CZmUlcXBzLly9nyJAhrvZ7772XRYsWsXLlymPu8/e//51HHnnkmPb3338fX9/fdq1+U6iorGCesYAKyvC2eOONN94Wb3wsPnhZvPCz+tHF3sW1f71Rj81i+5VHFBERERERaT2yK+Hl7TbOS3TSN7x5n1JXVlZyxRVXUFJSQmBg4C/up5EDp9EDDzzA3Xff7bpdWlpKQkICEydO/NVOcTeHw4HfPD8mTJiA3d46l+loSxwOB/PmzVN/thLqz9ZF/dl6qC9bF/Vn66L+bF2aU39eXlvfYC625urICPYTUThwksLDw7HZbOTk5DRoz8nJITo6+rj38fLywsvL65h2u93u9l/kk9FS6pSTo/5sXdSfrYv6s/VQX7Yu6s/WRf3ZujSH/nT39z9ZJ1un9TTX0Wp4enrSr18/FixY4GpzOp0sWLCgwWUGIiIiIiIiIi2NRg6cgrvvvpupU6fSv39/Bg4cyHPPPUdFRYVr9QIRERERERGRlkjhwCm49NJLycvL46GHHiI7O5vevXszZ84coqKiTnxnERERERERkWZK4cApmj59OtOnT3d3GSIiIiIiIiKNRnMOiIiIiIiIiLRxCgdERERERERE2jiFAyIiIiIiIiJtnMIBERERERERkTZO4YCIiIiIiIhIG6dwQERERERERKSNUzggIiIiIiIi0sYpHBARERERERFp4xQOiIiIiIiIiLRxCgdERERERERE2jiFAyIiIiIiIiJtnMIBERERERERkTZO4YCIiIiIiIhIG+fh7gLaEsMwACgtLXVzJb/O4XBQWVlJaWkpdrvd3eXI76T+bF3Un62L+rP1UF+2LurP1kX92bqoP0/dkfPPI+ejv0ThQBMqKysDICEhwc2ViIiIiIiISFtSVlZGUFDQL263GCeKD6TROJ1OMjMzCQgIwGKxuLucX1RaWkpCQgIHDx4kMDDQ3eXI76T+bF3Un62L+rP1UF+2LurP1kX92bqoP0+dYRiUlZURGxuL1frLMwto5EATslqtxMfHu7uMkxYYGKgDrhVRf7Yu6s/WRf3ZeqgvWxf1Z+ui/mxd1J+n5tdGDByhCQlFRERERERE2jiFAyIiIiIiIiJtnMIBOYaXlxcPP/wwXl5e7i5FGoH6s3VRf7Yu6s/WQ33Zuqg/Wxf1Z+ui/jx9NCGhiIiIiIiISBunkQMiIiIiIiIibZzCAREREREREZE2TuGAiIiIiIiISBuncEBERERERESkjVM4IMeYMWMGSUlJeHt7M2jQIFatWuXukuQE/v73v2OxWBp8dOnSxbW9urqaW2+9lbCwMPz9/bnwwgvJyclxY8XyU4sXL+bss88mNjYWi8XCF1980WC7YRg89NBDxMTE4OPjw/jx49m9e3eDfQoLC7nyyisJDAwkODiYG264gfLy8iZ8FnLEifrz2muvPeZ4nTx5coN91J/Nw2OPPcaAAQMICAggMjKS8847j507dzbY52ReX9PT0znzzDPx9fUlMjKSe+65h7q6uqZ8KsLJ9efo0aOPOT5vvvnmBvuoP5uHV155hZ49exIYGEhgYCBDhgzh22+/dW3XsdmynKg/dWw2DYUD0sBHH33E3XffzcMPP8y6devo1asXkyZNIjc3192lyQl069aNrKws18fSpUtd2+666y6+/vprZs6cyaJFi8jMzOSCCy5wY7XyUxUVFfTq1YsZM2Ycd/uTTz7JCy+8wKuvvsrKlSvx8/Nj0qRJVFdXu/a58sor2bp1K/PmzWPWrFksXryYm266qamegvzEifoTYPLkyQ2O1w8++KDBdvVn87Bo0SJuvfVWfvzxR+bNm4fD4WDixIlUVFS49jnR62t9fT1nnnkmtbW1LF++nLfffpu33nqLhx56yB1PqU07mf4EmDZtWoPj88knn3RtU382H/Hx8Tz++OOsXbuWNWvWMHbsWM4991y2bt0K6NhsaU7Un6Bjs0kYIj8xcOBA49Zbb3Xdrq+vN2JjY43HHnvMjVXJiTz88MNGr169jrutuLjYsNvtxsyZM11t27dvNwBjxYoVTVShnCzA+Pzzz123nU6nER0dbTz11FOutuLiYsPLy8v44IMPDMMwjG3bthmAsXr1atc+3377rWGxWIyMjIwmq12O9fP+NAzDmDp1qnHuuef+4n3Un81Xbm6uARiLFi0yDOPkXl9nz55tWK1WIzs727XPK6+8YgQGBho1NTVN+wSkgZ/3p2EYxqhRo4w77rjjF++j/mzeQkJCjNdee03HZitxpD8NQ8dmU9HIAXGpra1l7dq1jB8/3tVmtVoZP348K1ascGNlcjJ2795NbGws7du358orryQ9PR2AtWvX4nA4GvRrly5daNeunfq1BUhLSyM7O7tB/wUFBTFo0CBX/61YsYLg4GD69+/v2mf8+PFYrVZWrlzZ5DXLiS1cuJDIyEg6d+7MLbfcQkFBgWub+rP5KikpASA0NBQ4udfXFStW0KNHD6Kiolz7TJo0idLS0gbviEnT+3l/HvHee+8RHh5O9+7deeCBB6isrHRtU382T/X19Xz44YdUVFQwZMgQHZst3M/78wgdm6efh7sLkOYjPz+f+vr6BgcVQFRUFDt27HBTVXIyBg0axFtvvUXnzp3JysrikUceYcSIEWzZsoXs7Gw8PT0JDg5ucJ+oqCiys7PdU7CctCN9dLzj8si27OxsIiMjG2z38PAgNDRUfdwMTZ48mQsuuIDk5GT27t3LX/7yF8444wxWrFiBzWZTfzZTTqeTO++8k2HDhtG9e3eAk3p9zc7OPu7xe2SbuMfx+hPgiiuuIDExkdjYWDZt2sR9993Hzp07+eyzzwD1Z3OzefNmhgwZQnV1Nf7+/nz++ed07dqVDRs26NhsgX6pP0HHZlNROCDSCpxxxhmur3v27MmgQYNITEzk448/xsfHx42VicjPXXbZZa6ve/ToQc+ePenQoQMLFy5k3LhxbqxMfs2tt97Kli1bGsznIi3XL/XnT+f26NGjBzExMYwbN469e/fSoUOHpi5TTqBz585s2LCBkpISPvnkE6ZOncqiRYvcXZb8Rr/Un127dtWx2UR0WYG4hIeHY7PZjpnJNScnh+joaDdVJb9FcHAwnTp1Ys+ePURHR1NbW0txcXGDfdSvLcORPvq14zI6OvqYSUPr6uooLCxUH7cA7du3Jzw8nD179gDqz+Zo+vTpzJo1ix9++IH4+HhX+8m8vkZHRx/3+D2yTZreL/Xn8QwaNAigwfGp/mw+PD096dixI/369eOxxx6jV69ePP/88zo2W6hf6s/j0bF5eigcEBdPT0/69evHggULXG1Op5MFCxY0uN5Hmr/y8nL27t1LTEwM/fr1w263N+jXnTt3kp6ern5tAZKTk4mOjm7Qf6WlpaxcudLVf0OGDKG4uJi1a9e69vn+++9xOp2uP57SfB06dIiCggJiYmIA9WdzYhgG06dP5/PPP+f7778nOTm5wfaTeX0dMmQImzdvbhD4zJs3j8DAQNdwWWkaJ+rP49mwYQNAg+NT/dl8OZ1OampqdGy2Ekf683h0bJ4m7p4RUZqXDz/80PDy8jLeeustY9u2bcZNN91kBAcHN5j5U5qfP/3pT8bChQuNtLQ0Y9myZcb48eON8PBwIzc31zAMw7j55puNdu3aGd9//72xZs0aY8iQIcaQIUPcXLUcUVZWZqxfv95Yv369ARjPPPOMsX79euPAgQOGYRjG448/bgQHBxtffvmlsWnTJuPcc881kpOTjaqqKtdjTJ482ejTp4+xcuVKY+nSpUZKSopx+eWXu+sptWm/1p9lZWXGn//8Z2PFihVGWlqaMX/+fKNv375GSkqKUV1d7XoM9WfzcMsttxhBQUHGwoULjaysLNdHZWWla58Tvb7W1dUZ3bt3NyZOnGhs2LDBmDNnjhEREWE88MAD7nhKbdqJ+nPPnj3GP/7xD2PNmjVGWlqa8eWXXxrt27c3Ro4c6XoM9Wfzcf/99xuLFi0y0tLSjE2bNhn333+/YbFYjLlz5xqGoWOzpfm1/tSx2XQUDsgxXnzxRaNdu3aGp6enMXDgQOPHH390d0lyApdeeqkRExNjeHp6GnFxccall15q7Nmzx7W9qqrK+OMf/2iEhIQYvr6+xvnnn29kZWW5sWL5qR9++MEAjvmYOnWqYRjmcoYPPvigERUVZXh5eRnjxo0zdu7c2eAxCgoKjMsvv9zw9/c3AgMDjeuuu84oKytzw7ORX+vPyspKY+LEiUZERIRht9uNxMREY9q0accEsOrP5uF4/QgYb775pmufk3l93b9/v3HGGWcYPj4+Rnh4uPGnP/3JcDgcTfxs5ET9mZ6ebowcOdIIDQ01vLy8jI4dOxr33HOPUVJS0uBx1J/Nw/XXX28kJiYanp6eRkREhDFu3DhXMGAYOjZbml/rTx2bTcdiGIbRdOMURERERERERKS50ZwDIiIiIiIiIm2cwgERERERERGRNk7hgIiIiIiIiEgbp3BAREREREREpI1TOCAiIiIiIiLSxikcEBEREREREWnjFA6IiIiIiIiItHEKB0RERERERETaOIUDIiIiIiIiIm2cwgERERFpEtdeey0WiwWLxYLdbicqKooJEybwxhtv4HQ63V2eiIhIm6ZwQERERJrM5MmTycrKYv/+/Xz77beMGTOGO+64g7POOou6ujp3lyciItJmKRwQERGRJuPl5UV0dDRxcXH07duXv/zlL3z55Zd8++23vPXWWwA888wz9OjRAz8/PxISEvjjH/9IeXk5ABUVFQQGBvLJJ580eNwvvvgCPz8/ysrKqK2tZfr06cTExODt7U1iYiKPPfZYUz9VERGRFkXhgIiIiLjV2LFj6dWrF5999hkAVquVF154ga1bt/L222/z/fffc++99wLg5+fHZZddxptvvtngMd58800uuugiAgICeOGFF/jqq6/4+OOP2blzJ++99x5JSUlN/bRERERaFA93FyAiIiLSpUsXNm3aBMCdd97pak9KSuL//u//uPnmm3n55ZcBuPHGGxk6dChZWVnExMSQm5vL7NmzmT9/PgDp6emkpKQwfPhwLBYLiYmJTf58REREWhqNHBARERG3MwwDi8UCwPz58xk3bhxxcXEEBARw9dVXU1BQQGVlJQADBw6kW7duvP322wC8++67JCYmMnLkSMCc+HDDhg107tyZ22+/nblz57rnSYmIiLQgCgdERETE7bZv305ycjL79+/nrLPOomfPnnz66aesXbuWGTNmAFBbW+va/8Ybb3TNUfDmm29y3XXXucKFvn37kpaWxqOPPkpVVRWXXHIJF110UZM/JxERkZZE4YCIiIi41ffff8/mzZu58MILWbt2LU6nk6effprBgwfTqVMnMjMzj7nPVVddxYEDB3jhhRfYtm0bU6dObbA9MDCQSy+9lP/+97989NFHfPrppxQWFjbVUxIREWlxNOeAiIiINJmamhqys7Opr68nJyeHOXPm8Nhjj3HWWWdxzTXXsGXLFhwOBy+++CJnn302y5Yt49VXXz3mcUJCQrjgggu45557mDhxIvHx8a5tzzzzDDExMfTp0wer1crMmTOJjo4mODi4CZ+piIhIy6KRAyIiItJk5syZQ0xMDElJSUyePJkffviBF154gS+//BKbzUavXr145plneOKJJ+jevTvvvffeLy5DeMMNN1BbW8v111/foD0gIIAnn3yS/v37M2DAAPbv38/s2bOxWvVvj4iI4kX0zgAAALZJREFUyC+xGIZhuLsIERERkVP1zjvvcNddd5GZmYmnp6e7yxEREWnRdFmBiIiItCiVlZVkZWXx+OOP84c//EHBgIiISCPQ+DoRERFpUZ588km6dOlCdHQ0DzzwgLvLERERaRV0WYGIiIiIiIhIG6eRAyIiIiIiIiJtnMIBEfn/7diBAAAAAIAgf+tBLowAAIA5OQAAAABzcgAAAADm5AAAAADMyQEAAACYkwMAAAAwJwcAAABgLkrZF520n7l4AAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import math\n", - "\n", - "def calculate_conviction(lock_amount: int, end_day: int, current_day: int, interval: int) -> int:\n", - " lock_duration = max(end_day - current_day, 0)\n", - " time_factor = -lock_duration / interval \n", - " exp_term = 1 - math.exp(time_factor)\n", - " conviction_score = lock_amount * exp_term\n", - " return int(conviction_score)\n", - "\n", - "# Calculate conviction for 1000 over a range of durations from 10 days to a year\n", - "lock_amount = 1000\n", - "interval = 180\n", - "duration = 365\n", - "\n", - "plt.figure(figsize=(12, 6))\n", - "\n", - "unlockable = [0]\n", - "days = range(0, duration + 1) # +1 to include the last day\n", - "locked_amount = []\n", - "convictions = []\n", - "unlockable = [0]\n", - "for day in days:\n", - " current_locked = lock_amount + (7200 * 0.18 * day) - unlockable[day-1] * 0\n", - " locked_amount.append(current_locked)\n", - " conviction = calculate_conviction(current_locked, duration, day, interval=interval)\n", - " convictions.append(conviction)\n", - " unlockable.append(current_locked - conviction)\n", - "\n", - "plt.plot(days, convictions, label=f'Conviction ({duration} days)')\n", - "plt.plot(days, locked_amount, label=f'Locked Amount ({duration} days)')\n", - "plt.plot(days, unlockable[:-1], label=f'Unlockable ({duration} days)', linestyle='--')\n", - "\n", - "plt.title('Conviction Score for Various Lock Durations')\n", - "plt.xlabel('Days')\n", - "plt.ylabel('Conviction Score')\n", - "plt.grid(True)\n", - "plt.legend()\n", - "plt.show()\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 124, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Lion's Share Distribution:\n", - "Participant_0's lock: 6974, share: 0.0072\n", - "Participant_1's lock: 9165, share: 0.8613\n", - "Participant_2's lock: 8303, share: 0.1312\n", - "Participant_3's lock: 5278, share: 0.0002\n", - "Participant_4's lock: 2642, share: 0.0000\n", - "Participant_5's lock: 4272, share: 0.0000\n", - "Participant_6's lock: 4160, share: 0.0000\n", - "Participant_7's lock: 2101, share: 0.0000\n", - "Participant_8's lock: 3090, share: 0.0000\n", - "Participant_9's lock: 4980, share: 0.0001\n", - "\n", - "Lion's Share Skew Factors:\n", - "Participant_0's skew factor: 0.0528\n", - "Participant_1's skew factor: 4.7893\n", - "Participant_2's skew factor: 0.8054\n", - "Participant_3's skew factor: 0.0017\n", - "Participant_4's skew factor: 0.0000\n", - "Participant_5's skew factor: 0.0002\n", - "Participant_6's skew factor: 0.0002\n", - "Participant_7's skew factor: 0.0000\n", - "Participant_8's skew factor: 0.0000\n", - "Participant_9's skew factor: 0.0010\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "\n", - "def calculate_conviction(lock_amount: int, end_day: int, current_day: int, interval: int) -> int:\n", - " lock_duration = max(end_day - current_day, 0)\n", - " time_factor = -lock_duration / interval \n", - " exp_term = 1 - math.exp(time_factor)\n", - " conviction_score = lock_amount * exp_term\n", - " return int(conviction_score)\n", - "\n", - "\n", - "import random\n", - "\n", - "interval = 365\n", - "duration = 365\n", - "N = 10 # Number of participants\n", - "temperature = 5 # Adjust this value to control the steepness of the sigmoid\n", - "\n", - "# Generate random lock amounts for N participants\n", - "participants = [f\"Participant_{i}\" for i in range(N)]\n", - "locks = [random.randint(10, 10000) for _ in range(N)]\n", - "\n", - "# Calculate convictions\n", - "convictions = [calculate_conviction(lock, duration, 0, interval) for lock in locks]\n", - "\n", - "# Calculate mean conviction\n", - "mean_conviction = sum(convictions) / len(convictions)\n", - "\n", - "# Calculate powered convictions using sigmoid function\n", - "powered_convictions = [1 / (1 + math.exp(-(conv - mean_conviction) / temperature)) for conv in convictions]\n", - "\n", - "# Calculate total powered conviction\n", - "total_powered = sum(powered_convictions)\n", - "\n", - "# Calculate shares\n", - "shares = [powered / total_powered for powered in powered_convictions]\n", - "\n", - "# # Print results\n", - "# for i, (participant, lock, share) in enumerate(zip(participants, locks, shares)):\n", - "# print(f\"{participant}'s lock: {lock}, share: {share:.4f}\")\n", - "\n", - "# # Calculate and print skew factors\n", - "# base_ratio = locks[0] / sum(locks)\n", - "# for i, (participant, lock, share) in enumerate(zip(participants, locks, shares)):\n", - "# skew_factor = (share / base_ratio) / (lock / locks[0])\n", - "# print(f\"{participant}'s skew factor: {skew_factor:.4f}\")\n", - "\n", - "\n", - "import numpy as np\n", - "\n", - "# Function to calculate the \"lion's share\" distribution\n", - "def calculate_lions_share(convictions, sharpness=20):\n", - " # Normalize convictions\n", - " normalized_convictions = np.array(convictions) / np.max(convictions)\n", - " \n", - " # Apply exponential function to create a sharp drop-off\n", - " powered_convictions = np.exp(sharpness * (normalized_convictions - 1))\n", - " \n", - " # Calculate shares\n", - " total_powered = np.sum(powered_convictions)\n", - " shares = powered_convictions / total_powered\n", - " \n", - " return shares\n", - "\n", - "# Calculate convictions\n", - "convictions = [calculate_conviction(lock, duration, 0, interval) for lock in locks]\n", - "\n", - "# Calculate shares using the lion's share distribution\n", - "lions_shares = calculate_lions_share(convictions)\n", - "\n", - "# Print results\n", - "print(\"\\nLion's Share Distribution:\")\n", - "for i, (participant, lock, share) in enumerate(zip(participants, locks, lions_shares)):\n", - " print(f\"{participant}'s lock: {lock}, share: {share:.4f}\")\n", - "\n", - "# Calculate and print skew factors for lion's share\n", - "base_ratio = locks[0] / sum(locks)\n", - "print(\"\\nLion's Share Skew Factors:\")\n", - "for i, (participant, lock, share) in enumerate(zip(participants, locks, lions_shares)):\n", - " skew_factor = (share / base_ratio) / (lock / locks[0])\n", - " print(f\"{participant}'s skew factor: {skew_factor:.4f}\")\n", - "\n", - "# Visualize the difference between sigmoid and lion's share distributions\n", - "import matplotlib.pyplot as plt\n", - "\n", - "plt.figure(figsize=(12, 6))\n", - "plt.plot(range(N), sorted(shares, reverse=True), 'b-', label='Sigmoid Distribution')\n", - "plt.plot(range(N), sorted(lions_shares, reverse=True), 'r-', label=\"Lion's Share Distribution\")\n", - "plt.xlabel('Participant Rank')\n", - "plt.ylabel('Share')\n", - "plt.title('Comparison of Sigmoid and Lion\\'s Share Distributions')\n", - "plt.legend()\n", - "plt.grid(True)\n", - "plt.show()\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 121, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Lion's Share Distribution:\n", - "Participant_0's lock: 3916, share: 0.0015\n", - "Participant_1's lock: 440, share: 0.0000\n", - "Participant_2's lock: 8807, share: 0.3472\n", - "Participant_3's lock: 8077, share: 0.1545\n", - "Participant_4's lock: 6539, share: 0.0281\n", - "Participant_5's lock: 6470, share: 0.0260\n", - "Participant_6's lock: 148, share: 0.0000\n", - "Participant_7's lock: 701, share: 0.0000\n", - "Participant_8's lock: 2765, share: 0.0004\n", - "Participant_9's lock: 9026, share: 0.4422\n", - "\n", - "Lion's Share Skew Factors:\n", - "Participant_0's skew factor: 0.0184\n", - "Participant_1's skew factor: 0.0035\n", - "Participant_2's skew factor: 1.8483\n", - "Participant_3's skew factor: 0.8967\n", - "Participant_4's skew factor: 0.2016\n", - "Participant_5's skew factor: 0.1886\n", - "Participant_6's skew factor: 0.0075\n", - "Participant_7's skew factor: 0.0029\n", - "Participant_8's skew factor: 0.0073\n", - "Participant_9's skew factor: 2.2970\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+kAAAIjCAYAAAB/OVoZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAACLFUlEQVR4nOzdd3gU1dvG8XvTE0LoJCBgKCIgVUCKhSK9KAoIgjQFqSKGjrSAGkBQkA4iRUX4UURReokgIiCIFRCpilQFQk2d9495sxCSQBKSzG72+7muvTI7Oztz7+Zs4Nkzc47NMAxDAAAAAADAcm5WBwAAAAAAACaKdAAAAAAAHARFOgAAAAAADoIiHQAAAAAAB0GRDgAAAACAg6BIBwAAAADAQVCkAwAAAADgICjSAQAAAABwEBTpAAAAAAA4CIp0AHByNptNo0ePtjrGffv4449VqlQpeXp6KmfOnOmyT2d4b0aPHi2bzZaibR3t9XTu3FnBwcHpsq/UvA/OJDw8XDabTcuXL7c6SoZIzzZwL8HBwercubP9/oIFC2Sz2fTDDz9kyvFr166t2rVrZ8qxALg2inQATu/IkSPq3r27ihUrJh8fHwUEBOjxxx/XlClTdOPGDavjIQUOHjyozp07q3jx4po7d67mzJlz1+2//fZbNW7cWA888IB8fHxUpEgRNW/eXIsXL86kxEiN2rVrq2zZslbHsBfMx48fT5f9rV69WrVq1VL+/Pnl5+enYsWK6YUXXtC6devSZf+ZLf6Lkvibn5+f/bM1f/58RUZGpstxfv/9d40ePTrdfg/pyZGzAXAdHlYHAID78fXXX6t169by9vZWx44dVbZsWUVFRenbb7/VwIED9dtvv92z4HN2N27ckIeHc/85Dw8PV1xcnKZMmaISJUrcddtly5apTZs2qlixol5//XXlypVLx44d07Zt2zR37ly1a9fOvq0zvDfDhw/XkCFDrI5hOWd7HyZOnKiBAweqVq1aGjp0qPz8/PTnn39q06ZNWrJkiRo1amR1xDSbOXOm/P39FRkZqVOnTmn9+vV6+eWXNXnyZH311VcqXLiwfdu5c+cqLi4uVfv//fffFRoaqtq1a6eqF/7QoUNyc8vY/qW7ZduwYUOGHhsA4jn2/1wA4C6OHTumtm3b6sEHH9SWLVtUoEAB+2O9e/fWn3/+qa+//trChBknLi5OUVFR8vHxkY+Pj9Vx7tu5c+ckKUWnuY8ePVplypTR999/Ly8vryT3E88Z3hsPDw+H/yIhMzjT+xATE6OxY8eqfv36SRZud7bDzHDt2jVly5YtXfbVqlUr5c2b135/5MiR+vTTT9WxY0e1bt1a33//vf0xT0/PdDlmcgzD0M2bN+Xr6ytvb+8MPda93Pn3BgAyCqe7A3BaEyZM0NWrVzVv3rwEBXq8EiVK6PXXX7ffj/+PdfHixeXt7a3g4GANGzYs0SmcwcHBatasmcLDw1WlShX5+vqqXLlyCg8PlyStXLlS5cqVk4+PjypXrqwff/wxwfM7d+4sf39/HT16VA0bNlS2bNlUsGBBjRkzRoZhJNh24sSJqlmzpvLkySNfX19Vrlw5yWtXbTab+vTpo08//VSPPPKIvL297afU3nmd8pUrV9SvXz8FBwfL29tb+fPnV/369bVv374E+1y2bJkqV64sX19f5c2bVy+99JJOnTqV5Gs5deqUWrRoIX9/f+XLl08DBgxQbGxsMr+ZhGbMmGHPXLBgQfXu3VuXLl1K8H6PGjVKkpQvX757Xnd95MgRVa1aNcn/MOfPnz/B/aT2Ff979fHxUfHixTV79uwkr4eOf8+XLVumMmXKyNfXVzVq1NAvv/wiSZo9e7ZKlCghHx8f1a5dO8nTY1PyHid17MjISL3xxhvKly+fsmfPrmeeeUZ///13su/J7aKiojRy5EhVrlxZOXLkULZs2fTkk09q69atCbY7fvy4bDabJk6cqDlz5tg/F1WrVtWePXsS7XfVqlUqW7asfHx8VLZsWX3++ecpypNSSb0Pqf3Mfvvtt3rsscfk4+OjYsWKadGiRfc87uHDh9WyZUsFBQXJx8dHhQoVUtu2bXX58uVkn3PhwgVFRETo8ccfT/LxO9uhZH6x9vbbb6tQoULy8fHR008/rT///DPBNtu3b1fr1q1VpEgReXt7q3DhwnrjjTcSXbYT/7k8cuSImjRpouzZs6t9+/b240yePFmPPPKIfHx8FBgYqO7du+vixYv3fC/upn379uratat27dqljRs3JshyZ4/zkiVLVLlyZWXPnl0BAQEqV66cpkyZIsm8jrx169aSpDp16thPrY//+xr/u1y/fr397+/s2bPtj91+TXq869evq3v37sqTJ48CAgLUsWPHRK83ub8rt+/zXtmSuib93LlzeuWVVxQYGCgfHx9VqFBBCxcuTLBNaj5rZ86cUZcuXVSoUCF5e3urQIECevbZZzn9HnAxzvGVNQAkYfXq1SpWrJhq1qyZou27du2qhQsXqlWrVurfv7927dqlsLAwHThwIFHB8eeff6pdu3bq3r27XnrpJU2cOFHNmzfXrFmzNGzYMPXq1UuSFBYWphdeeCHRaZixsbFq1KiRqlevrgkTJmjdunUaNWqUYmJiNGbMGPt2U6ZM0TPPPKP27dsrKipKS5YsUevWrfXVV1+padOmCTJt2bJF//vf/9SnTx/lzZs32dNEe/TooeXLl6tPnz4qU6aM/v33X3377bc6cOCAHn30UUnmf0a7dOmiqlWrKiwsTGfPntWUKVO0Y8cO/fjjjwl6tGNjY9WwYUNVq1ZNEydO1KZNmzRp0iQVL15cPXv2vOt7Pnr0aIWGhqpevXrq2bOnDh06pJkzZ2rPnj3asWOHPD09NXnyZC1atEiff/65/TTb8uXLJ7vPBx98UJs3b9bff/+tQoUK3fX4d/rxxx/VqFEjFShQQKGhoYqNjdWYMWOUL1++JLffvn27vvzyS/Xu3VuS+ftu1qyZBg0apBkzZqhXr166ePGiJkyYoJdffllbtmyxPzc17/Gdunbtqk8++UTt2rVTzZo1tWXLlkTtITkRERH68MMP9eKLL6pbt266cuWK5s2bp4YNG2r37t2qWLFigu0XL16sK1euqHv37rLZbJowYYKef/55HT161N5LumHDBrVs2VJlypRRWFiY/v33X3shkZFS+5lt1aqVXnnlFXXq1EkfffSROnfurMqVK+uRRx5Jcv9RUVFq2LChIiMj9dprrykoKEinTp3SV199pUuXLilHjhxJPi9//vzy9fXV6tWr9dprryl37tz3fC3jxo2Tm5ubBgwYoMuXL2vChAlq3769du3aZd9m2bJlun79unr27Kk8efJo9+7dmjp1qv7++28tW7Yswf5iYmLUsGFDPfHEE5o4caL8/PwkSd27d7e3vb59++rYsWOaNm2afvzxR/tnLq06dOigOXPmaMOGDapfv36S22zcuFEvvviinn76aY0fP16SdODAAe3YsUOvv/66nnrqKfXt21cffPCBhg0bptKlS0uS/adkntb+4osvqnv37urWrZsefvjhu+bq06ePcubMqdGjR9v/xpw4ccI+BkFKpSTb7W7cuKHatWvrzz//VJ8+fVS0aFEtW7ZMnTt31qVLlxJ8SSyl7LPWsmVL/fbbb3rttdcUHBysc+fOaePGjTp58mSmDdAHwAEYAOCELl++bEgynn322RRtv3//fkOS0bVr1wTrBwwYYEgytmzZYl/34IMPGpKM7777zr5u/fr1hiTD19fXOHHihH397NmzDUnG1q1b7es6depkSDJee+01+7q4uDijadOmhpeXl3H+/Hn7+uvXryfIExUVZZQtW9aoW7dugvWSDDc3N+O3335L9NokGaNGjbLfz5Ejh9G7d+9k34uoqCgjf/78RtmyZY0bN27Y13/11VeGJGPkyJGJXsuYMWMS7KNSpUpG5cqVkz2GYRjGuXPnDC8vL6NBgwZGbGysff20adMMScZHH31kXzdq1ChDUoL3Jjnz5s0zJBleXl5GnTp1jBEjRhjbt29PcIx4d743zZs3N/z8/IxTp07Z1x0+fNjw8PAw7vwnUZLh7e1tHDt2zL4u/vcdFBRkRERE2NcPHTrUkGTfNjXvcfxrjxffVnv16pUgT7t27RK9nqTExMQYkZGRCdZdvHjRCAwMNF5++WX7umPHjhmSjDx58hj//fefff0XX3xhSDJWr15tX1exYkWjQIECxqVLl+zrNmzYYEgyHnzwwbvmMQzDqFWrlvHII4/cdZvk3ofUfGa3bdtmX3fu3DnD29vb6N+/f7LH/PHHHw1JxrJly+75Gu40cuRIQ5KRLVs2o3Hjxsbbb79t7N27N9F2W7duNSQZpUuXTvB7mTJliiHJ+OWXX+zr7vx7YBiGERYWZthstgR/d+I/l0OGDEmw7fbt2w1Jxqeffppg/bp165Jcf6d7fQ4vXrxoSDKee+65BFlubwOvv/66ERAQYMTExCR7nGXLliX6uxkv/ne5bt26JB/r1KmT/f78+fMNSUblypWNqKgo+/oJEyYYkowvvvjCvi65z86d+7xbtlq1ahm1atWy3588ebIhyfjkk0/s66KioowaNWoY/v7+9r8RKf2sxb+/7777bqJjA3AtnO4OwClFRERIkrJnz56i7desWSNJCgkJSbC+f//+kpTo2vUyZcqoRo0a9vvVqlWTJNWtW1dFihRJtP7o0aOJjtmnTx/7cvyp01FRUdq0aZN9va+vr3354sWLunz5sp588slEp6ZLUq1atVSmTJl7vFLzuu5du3bpn3/+SfLxH374QefOnVOvXr0SXLPdtGlTlSpVKsnr+Hv06JHg/pNPPpnka77dpk2bFBUVpX79+iU4y6Bbt24KCAhI83gBL7/8statW6fatWvr22+/1dixY/Xkk0/qoYce0nfffZfs82JjY7Vp0ya1aNFCBQsWtK8vUaKEGjdunORznn766QS9V/G/75YtWyZoe3e2g7S8x/Hi22rfvn0TrO/Xr1+yz7mdu7u7/VKAuLg4/ffff4qJiVGVKlWSbFdt2rRRrly57PeffPLJBK/l9OnT2r9/vzp16pSgZ7l+/fopao9plZbPbHx2ybx04uGHH75rO41/PevXr9f169dTlS80NFSLFy9WpUqVtH79er355puqXLmyHn30UR04cCDR9l26dElwicad77OU8O/BtWvXdOHCBdWsWVOGYSS6rEZSojNZli1bphw5cqh+/fq6cOGC/Va5cmX5+/snuuQhtfz9/SWZl9QkJ2fOnLp27VqCU+JTq2jRomrYsGGKt3/11VcTnCHQs2dPeXh42NtQRlmzZo2CgoL04osv2td5enqqb9++unr1qr755psE29/rs+br6ysvLy+Fh4ff9+UJAJwbRToApxQQECDp7v9ZvN2JEyfk5uaWaOTwoKAg5cyZUydOnEiw/vZCXLr1n/nbRzW+ff2d/6Fyc3NTsWLFEqwrWbKkJCW4tvCrr75S9erV5ePjo9y5cytfvnyaOXNmktfDFi1a9F4vU5J5rf6vv/6qwoUL67HHHtPo0aMTFALxrzWpU0hLlSqV6L3w8fFJdDp4rly57vmfyOSO4+XlpWLFiiU6Tmo0bNhQ69ev16VLl7Rt2zb17t1bJ06cULNmzZIdtOvcuXO6ceNGkqPHJzeifFrbQWrf49vFt9XixYsnWH+vU35vt3DhQpUvX14+Pj7KkyeP8uXLp6+//jrJdnXna4wvIu58LQ899FCi56YmU2rd72dWunc7LVq0qEJCQvThhx8qb968atiwoaZPn37X69Fv9+KLL2r79u26ePGiNmzYoHbt2unHH39U8+bNdfPmzbvmu/N9lqSTJ0+qc+fOyp07t338h1q1aklSokweHh6JLjc4fPiwLl++rPz58ytfvnwJblevXr3vAe2uXr0q6e5fjvbq1UslS5ZU48aNVahQIfuXaqmR0r918e5sm/7+/ipQoECGX8d94sQJPfTQQ4lGnI8/Pf5ebfTONuDt7a3x48dr7dq1CgwM1FNPPaUJEybozJkzGfUSADgoinQATikgIEAFCxbUr7/+mqrnpfT6RHd391StN+4YEC4ltm/frmeeeUY+Pj6aMWOG1qxZo40bN6pdu3ZJ7u/2Xra7eeGFF3T06FFNnTpVBQsW1LvvvqtHHnlEa9euTXVGKfnX7Aj8/Pz05JNPatq0aRo+fLguXryY5teZlMxoB+ntk08+sc85P2/ePK1bt04bN25U3bp1k5wqy5Ffi3T/n9l7vY5Jkybp559/1rBhw3Tjxg317dtXjzzySIoH6pPMv0f169fXp59+qk6dOunIkSMJrjVPSb7Y2FjVr19fX3/9tQYPHqxVq1Zp48aNWrBggSQl+t15e3snKg7j4uKUP39+bdy4Mcnb7eNhpEX839u7TZOYP39+7d+/X19++aWeeeYZbd26VY0bN1anTp1SfJyU/q1LDykdADM9pKSN9uvXT3/88YfCwsLk4+OjESNGqHTp0kmeSQEg66JIB+C0mjVrpiNHjmjnzp333PbBBx9UXFycDh8+nGD92bNndenSJT344IPpmi0uLi7RabZ//PGHJNlPn16xYoV8fHzscxA3btxY9erVS5fjFyhQQL169dKqVat07Ngx5cmTR2+//bYk2V/roUOHEj3v0KFD6fZeJHecqKgoHTt2LN3f8ypVqkgyT89OSv78+eXj45NoRG1JSa67H/fzHse31SNHjiR6XkosX75cxYoV08qVK9WhQwc1bNhQ9erVS9Szm1LxWe/87KQmU1qPm1mf2XLlymn48OHatm2btm/frlOnTmnWrFlp2te92mFyfvnlF/3xxx+aNGmSBg8erGeffVb16tVLcGnGvRQvXlz//vuvHn/8cdWrVy/RrUKFCqnKdKePP/5Yku55KrqXl5eaN2+uGTNm6MiRI+revbsWLVpk/5ylZjC3lLizjVy9elWnT59OcKlKrly5EswqIZl/i+78PaUm24MPPqjDhw8n+gLl4MGD9sfTonjx4urfv782bNigX3/9VVFRUZo0aVKa9gXAOVGkA3BagwYNUrZs2dS1a1edPXs20eNHjhyxT/vTpEkTSdLkyZMTbPPee+9JUopHzk6NadOm2ZcNw9C0adPk6empp59+WpLZq2Kz2RL05Bw/flyrVq1K8zFjY2MTnRabP39+FSxY0D5tVZUqVZQ/f37NmjUrwVRWa9eu1YEDB9LtvahXr568vLz0wQcfJOgpmjdvni5fvpzm42zevDnJ9fHXnyZ3Cra7u7vq1aunVatWJbhe/88//0zX3nfp/t7j+OvjP/jggwTr72y7yYnvrbv9Pd+1a1eKvsxKSoECBVSxYkUtXLgwQdvauHGjfv/99zTtMyUy4zMbERGhmJiYBOvKlSsnNze3RNO83e769evJvp/xbSm1lwIk9XszDMP+NywlXnjhBcXGxmrs2LGJHouJiUlUpKbG4sWL9eGHH6pGjRr2v2FJ+ffffxPcd3Nzs8/WEP+exs/nfj95bjdnzhxFR0fb78+cOVMxMTEJxpooXry4tm3bluh5d/akpyZbkyZNdObMGS1dutS+LiYmRlOnTpW/v7/9UoWUun79eqIv04oXL67s2bPftT0CyHqYgg2A0ypevLgWL16sNm3aqHTp0urYsaPKli2rqKgofffdd/apcCSpQoUK6tSpk+bMmaNLly6pVq1a2r17txYuXKgWLVqoTp066ZrNx8dH69atU6dOnVStWjWtXbtWX3/9tYYNG2a/vrtp06Z677331KhRI7Vr107nzp3T9OnTVaJECf38889pOu6VK1dUqFAhtWrVShUqVJC/v782bdqkPXv22HtiPD09NX78eHXp0kW1atXSiy++aJ8eLDg4WG+88Ua6vAf58uXT0KFDFRoaqkaNGumZZ57RoUOHNGPGDFWtWlUvvfRSmvb77LPPqmjRomrevLmKFy+ua9euadOmTVq9erWqVq2q5s2bJ/vc0aNHa8OGDXr88cfVs2dPxcbGatq0aSpbtqz279+fxlea2P28xxUrVtSLL76oGTNm6PLly6pZs6Y2b96c4t7+Zs2aaeXKlXruuefUtGlTHTt2TLNmzVKZMmXs1xSnVlhYmJo2baonnnhCL7/8sv777z9NnTpVjzzySIr3ef78eb311luJ1hctWtQ+x/ftMuMzu2XLFvXp00etW7dWyZIlFRMTo48//lju7u5q2bJlss+7fv26atasqerVq6tRo0YqXLiwLl26pFWrVmn79u1q0aKFKlWqlKospUqVUvHixTVgwACdOnVKAQEBWrFiRaoGEKtVq5a6d++usLAw7d+/Xw0aNJCnp6cOHz6sZcuWacqUKWrVqtU997N8+XL5+/srKipKp06d0vr167Vjxw5VqFAh0VRwd+ratav+++8/1a1bV4UKFdKJEyc0depUVaxY0X6tdsWKFeXu7q7x48fr8uXL8vb2Vt26dZOcXz4loqKi9PTTT9unw5wxY4aeeOIJPfPMMwly9ejRQy1btlT9+vX1008/af369cqbN2+CfaUm26uvvqrZs2erc+fO2rt3r4KDg7V8+XLt2LFDkydPTvHApvH++OMP++soU6aMPDw89Pnnn+vs2bNq27Ztmt4bAE7KkjHlASAd/fHHH0a3bt2M4OBgw8vLy8iePbvx+OOPG1OnTjVu3rxp3y46OtoIDQ01ihYtanh6ehqFCxc2hg4dmmAbwzCn5GnatGmi40hKNLVZ/NQ6t0+Z06lTJyNbtmzGkSNHjAYNGhh+fn5GYGCgMWrUqETThM2bN8946KGHDG9vb6NUqVLG/PnzE01Fldyxb38sfmqhyMhIY+DAgUaFChWM7NmzG9myZTMqVKhgzJgxI9Hzli5dalSqVMnw9vY2cufObbRv3974+++/E2wT/1rulFTG5EybNs0oVaqU4enpaQQGBho9e/Y0Ll68mOT+UjIF22effWa0bdvWKF68uOHr62v4+PgYZcqUMd58880E06IZRtLTLm3evNmoVKmS4eXlZRQvXtz48MMPjf79+xs+Pj6JnpuS37dh3Jpm686pvFLyHif1Xt64ccPo27evkSdPHiNbtmxG8+bNjb/++itFU7DFxcUZ77zzjvHggw8a3t7eRqVKlYyvvvoq0VRZyb2W+Nd+53FWrFhhlC5d2vD29jbKlCljrFy5MtE+k1OrVi1DUpK3p59+Otn34X4/s3dOmXWno0ePGi+//LJRvHhxw8fHx8idO7dRp04dY9OmTXd9PdHR0cbcuXONFi1a2N9nPz8/o1KlSsa7776bYKq15NpG/Ps/f/58+7rff//dqFevnuHv72/kzZvX6Natm/HTTz8l2i65z2W8OXPmGJUrVzZ8fX2N7NmzG+XKlTMGDRpk/PPPP3d9XfG/g/ibj4+PUahQIaNZs2bGRx99lOh9j89yextYvny50aBBAyN//vyGl5eXUaRIEaN79+7G6dOnEzxv7ty5RrFixQx3d/cEU54l97uMfyypKdi++eYb49VXXzVy5cpl+Pv7G+3btzf+/fffBM+NjY01Bg8ebOTNm9fw8/MzGjZsaPz555+J9nm3bEm1p7NnzxpdunQx8ubNa3h5eRnlypVL8LsyjJR/1i5cuGD07t3bKFWqlJEtWzYjR44cRrVq1Yz//e9/Sb4fALIum2E4yMgwAJBFdO7cWcuXL09zryUyX4sWLfTbb78led01AABAZuKadACAS7lx40aC+4cPH9aaNWtUu3ZtawIBAADchmvSAQAupVixYurcubN9rvaZM2fKy8tLgwYNsjoaAAAARToAwLU0atRIn332mc6cOSNvb2/VqFFD77zzjh566CGrowEAAIhr0gEAAAAAcBBckw4AAAAAgIOgSAcAAAAAwEG43DXpcXFx+ueff5Q9e3bZbDar4wAAAAAAsjjDMHTlyhUVLFhQbm537yt3uSL9n3/+UeHCha2OAQAAAABwMX/99ZcKFSp0121crkjPnj27JPPNCQgIsDjN3UVHR2vDhg1q0KCBPD09rY4DZBjaOlwJ7R2uhPYOV0J7x91ERESocOHC9nr0blyuSI8/xT0gIMApinQ/Pz8FBATwQUeWRluHK6G9w5XQ3uFKaO9IiZRccs3AcQAAAAAAOAiKdAAAAAAAHARFOgAAAAAADsLlrkkHAAAAXI1hGIqJiVFsbKzVUbKs6OhoeXh46ObNm7zPLsrT01Pu7u73vR+KdAAAACALi4qK0unTp3X9+nWro2RphmEoKChIf/31V4oGB0PWY7PZVKhQIfn7+9/XfijSAQAAgCwqLi5Ox44dk7u7uwoWLCgvLy8KyAwSFxenq1evyt/fX25uXFXsagzD0Pnz5/X333/roYceuq8edYp0AAAAIIuKiopSXFycChcuLD8/P6vjZGlxcXGKioqSj48PRbqLypcvn44fP67o6Oj7KtJpPQAAAEAWR9EIZLz0OkuFTysAAAAAAA6CIh0AAAAAAAdBkQ4AAADAKdlsNq1atcrqGAoPD5e7u7suX76c7DYLFixQzpw50+V46bmv2x0/flw2m0379++XZL4um82mS5cuZfixcAtFOgAAAACHc/78efXs2VNFihSRt7e3goKC1LBhQ+3YscO+zenTp9W4cWMLU5pq1qypU6dOKSAg4L72Y7PZ7Lds2bLpoYceUufOnbV3794E27Vp00Z//PFHivaZmoK+cOHCOn36tMqWLZva6HfVuXNntWjRIlOOlRVQpAMAAABwOC1bttSPP/6ohQsX6o8//tCXX36p2rVr699//7VvExQUJG9vbwtTmry8vBQUFJQuA4fNnz9fp0+f1m+//abp06fr6tWrqlatmhYtWmTfxtfXV/nz57/vY90uKipK7u7uCgoKkodHxk8ClpnHcjYU6QAAAIALMQzp2jVrboaRsoyXLl3S9u3bNX78eNWpU0cPPvigHnvsMQ0dOlTPPPOMfbs7T3f/7rvvVLFiRfn4+KhKlSpatWpVkqdvr1+/XpUqVZKvr6/q1q2rc+fOae3atSpdurQCAgLUrl07Xb9+3b7fyMhI9e3bV/nz55ePj4+eeOIJ7dmzx/54Uqe7L1iwQEWKFJGfn5+ee+65BF8u3E3OnDkVFBSk4OBgNWjQQMuXL1f79u3Vp08fXbx40b7v23vHf/rpJ9WpU0fZs2dXQECAKleurB9++EHh4eHq0qWLLl++bO+hHz16tCQpODhYY8eOVceOHRUQEKBXX3012VPQd+zYofLly8vHx0fVq1fXr7/+an9s9OjRqlixYoLtJ0+erODgYPvjCxcu1BdffGHPEB4enuSxvvnmGz322GPy9vZWgQIFNGTIEMXExNgfr127tvr27atBgwYpd+7cCgoKsr+erIQiHQAAAHAh169L/v7W3G6re+/K399f/v7+WrVqlSIjI1P0nIiICDVv3lzlypXTvn37NHbsWA0ePDjJbUePHq1p06bpu+++019//aUXXnhBkydP1uLFi/X1119rw4YNmjp1qn37QYMGacWKFVq4cKH27dunEiVKqGHDhvrvv/+S3P+uXbv0yiuvqE+fPtq/f7/q1Kmjt956K2UvPglvvPGGrly5oo0bNyb5ePv27VWoUCHt2bNHe/fu1ZAhQ+Tp6amaNWtq8uTJCggI0OnTp3X69GkNGDDA/ryJEyeqQoUK+vHHHzVixIhkjz9w4EBNmjRJe/bsUb58+dS8eXNFR0enKPuAAQP0wgsvqFGjRvYMNWvWTLTdqVOn1KRJE1WtWlU//fSTZs6cqXnz5iV63xYuXKhs2bJp165dmjBhgsaMGZPs++KsOLcAAAAAgEPx8PDQggUL1K1bN82aNUuPPvqoatWqpbZt26p8+fJJPmfx4sWy2WyaO3eufHx8VKZMGZ06dUrdunVLtO1bb72lxx9/XJL0yiuvaOjQoTpy5IiKFSsmSWrVqpW2bt2qwYMH69q1a5o5c6YWLFhgv/597ty52rhxo+bNm6eBAwcm2v+UKVPUqFEjDRo0SJJUsmRJfffdd1q3bl2a3o9SpUpJMgdbS8rJkyc1cOBA+3YPPfSQ/bEcOXLIZrMpKCgo0fPq1q2r/v372+8nt/9Ro0apfv36kswiuVChQvr888/1wgsv3DO7v7+/fH19FRkZmWSGeDNmzFDhwoU1bdo02Ww2lSpVSv/8848GDx6skSNHys3N7F8uX768Ro0aZX+d06ZN0+bNm+35sgJ60h1VVJTcxoyR+82bVicBAABAFuLnJ129as3Nzy/lOVu2bKl//vlHX375pRo1aqTw8HA9+uijWrBgQZLbHzp0yH5KdrzHHnssyW1vL/QDAwPl5+dnL9Dj1507d06SdOTIEUVHR9uLekny9PTUY489pgMHDiS5/wMHDqhatWoJ1tWoUePuL/gujP+/TiC5a95DQkLUtWtX1atXT+PGjdORI0dStN8qVaqkaLvbs+fOnVsPP/xwsq89rQ4cOKAaNWokeI2PP/64rl69qr///tu+7s4vaQoUKGD/XWUVFOmOqnt3ub/1lmqEhkp3mcoBAAAASA2bTcqWzZpbasdV8/HxUf369TVixAh999136ty5s70X9X54enre9n7YEtyPXxcXF3ffx0kv8QVx0aJFk3x89OjR+u2339S0aVNt2bJFZcqU0eeff37P/WbLlu2+s7m5udm/RIiX0lPh08LRf1fpgSLdUfXsKSNnTuU5cEDujRpJyVzvAgAAALiKMmXK6Nq1a0k+9vDDD+uXX35JcA377YO7pVXx4sXl5eWVYOq36Oho7dmzR2XKlEnyOaVLl9auXbsSrPv+++/TnCH+uvJ69eolu03JkiX1xhtvaMOGDXr++ec1f/58SebI87GxsWk+tpQw+8WLF/XHH3+odOnSkqR8+fLpzJkzCQr1OweeS0mG0qVLa+fOnQn2s2PHDmXPnl2FChW6r/zOhiLdUT32mGI2bFBkQIDc9u6V6tSRsthpHAAAAEBS/v33X9WtW1effPKJfv75Zx07dkzLli3ThAkT9Oyzzyb5nHbt2ikuLk6vvvqqDhw4oPXr12vixImSkj9NPCWyZcumnj17auDAgVq3bp1+//13devWTdevX9crr7yS5HP69u2rdevWaeLEiTp8+LCmTZuW4uvRL126pDNnzujEiRPauHGjWrVqpcWLF2vmzJlJznd+48YN9enTR+Hh4Tpx4oR27NihPXv22Ivo4OBgXb16VZs3b9aFCxcSjFqfUmPGjNHmzZv166+/qnPnzsqbN6993vPatWvr/PnzmjBhgo4cOaLp06dr7dq1CZ4fHBysn3/+WYcOHdKFCxeS7Gnv1auX/vrrL7322ms6ePCgvvjiC40aNUohISH269FdhWu9WmdTsaJ2vP22jAIFpJ9/lmrVkk6dsjoVAAAAkKH8/f1VrVo1vf/++3rqqadUtmxZjRgxQt26ddO0adOSfE5AQIBWr16t/fv3q2LFinrzzTc1cuRISUpwnXpajBs3Ti1btlSHDh306KOP6s8//9T69euVK1euJLevXr265s6dqylTpqhChQrasGGDhg8fnqJjdenSRQUKFFCpUqXUs2dP+fv7a/fu3WrXrl2S27u7u+vff/9Vx44dVbJkSb3wwgtq3LixQkNDJUk1a9ZUjx491KZNG+XLl08TJkxI0+t//fXXVblyZZ05c0arV6+Wl5eXJLMHfMaMGZo+fboqVKig3bt3JxhBXpK6deumhx9+WFWqVFG+fPkSnJUQ74EHHtCaNWu0e/duVahQQT169NArr7yS4vctK7EZd15AkMVFREQoR44cunz5sgICAqyOc1fR0dFas2aNmpQsKc9GjaSTJ6VixaTNm6X/n3cQyArsbb1Jk0TXGQFZDe0droT2br2bN2/q2LFjKlq06H0Xqs7o008/tc8T7uvrm6HHiouLU0REhAICAlyu5xemu33eUlOH0nqcQYkS0rZtUvHi0tGj0lNPSYcPW50KAAAAcCiLFi3St99+q2PHjmnVqlUaPHiwXnjhhQwv0IH0RJHuLB580CzUS5WS/vrLLNR/+83qVAAAAIDDOHPmjF566SWVLl1ab7zxhlq3bq05c+ZYHQtIFQ+rAyAVChaUvvlGatBA+uknqXZtacMGqVIlq5MBAAAAlhs0aJAGDRpkdQzgvtCT7mzy55e2bJGqVpUuXJDq1pXumN4BAAAAAOCcKNKdUe7c0qZN0hNPSJcuSfXqmafCAwAAAACcGkW6swoIkNatk55+Wrp6VWrUyDz1HQAAAADgtCjSnVm2bNJXX0lNm0o3bkjNm0urV1udCgAAAACQRhTpzs7HR1q5UmrZUoqKkp5/Xvrf/6xOBQAAAABIA4r0rMDLS1qyRGrfXoqJkV58UVq0yOpUAAAAAIBUokjPKjw8pIULpa5dpbg4qVMnafZsq1MBAAAAGcJms2nVqlVWx0iV2rVrq1+/flbHSLXw8HDZbDZdunQp3fd9++/x+PHjstls2r9/f7of585jOTKK9KzE3V2aM0fq29e836OHNHmypZEAAACAtOjcubNatGiR7OOnT59W48aN0/WYtWvX1oIFC9L03NjYWL3//vsqU6aMfH19lTt3blWrVk0ffvhhumZMT8HBwbLZbLLZbPL19VVwcLBeeOEFbdmyJcF2NWvW1OnTp5UjR4577jO1BX1G/B5Hjx6tihUrZsqxMgJFelZjs5mF+ZAh5v033pDeftvSSAAAAEB6CwoKkre3t9Ux7MaMGaOZM2cqNDRUv//+u7Zu3apXX301Q3qfbxcbG6u4uLg0P3/MmDE6ffq0Dh06pEWLFilnzpyqV6+e3r6thvDy8lJQUJBsNlt6RJYkRUVFScrc36OjtZnkUKRnRTab9M470pgx5v3hw6U335QMw9pcAAAAsJ5hSNeuWXNLx/+P3nnq8i+//KK6devK19dXefLk0auvvqqrV6/aH4/vmZ84caIKFCigPHnyqHfv3oqOjk7mbTI0evRoFSlSRN7e3ipYsKD6xp+xmoTVq1frlVdeUevWrVW0aFFVqFBBr7zyigYMGJBgu7i4OA0aNEi5c+dWUFCQRo8eneDx9957T+XKlVO2bNlUuHBh9erVK8HrWLBggXLmzKkvv/xSZcqUkbe3t06ePKnIyEgNGDBADzzwgLJly6Zq1aopPDz8nu9j9uzZFRQUpCJFiuipp57SnDlzNGLECI0cOVKHDh2SlLh3/MSJE2revLly5cqlbNmy6ZFHHtGaNWt0/Phx1alTR5KUK1cu2Ww2de7cWZJ5lkKfPn3Ur18/5c2bVw0bNpSU9CnoBw8eVM2aNeXj46OyZcvqm2++SfT6b7dq1Sr7FwgLFixQaGiofvrpJ/tZAvFnR2R0m0kvFOlZlc0mjRghTZxo3n/nHSkkhEIdAADA1V2/Lvn7W3O7fj1DXtK1a9fUsGFD5cqVS3v27NGyZcu0adMm9enTJ8F2W7du1ZEjR7R161YtXLhQCxYsSPb09hUrVuj999/X7NmzdfjwYa1atUrlypVLNkNgYKC2bdum8+fP3zXrwoULlS1bNu3atUsTJkzQmDFjtHHjRvvjbm5u+uCDD/Tbb79p4cKF2rJliwYNGpRgH9evX9f48eP14Ycf6rffflP+/PnVp08f7dy5U0uWLNHPP/+s1q1bq1GjRjp8+PA93r3EXn/9dRmGoS+++CLJx3v37q3IyEht27ZNv/zyi8aPHy9/f38VLlxYK1askCQdOnRIp0+f1pQpUxK8di8vL+3YsUOzZs1K9vgDBw5U//799eOPP6pGjRpq3ry5/v333xRlb9Omjfr3769HHnlEp0+f1unTp9WmTZtE22VEm0kvHhm6d1ivf3/J11fq3ds8Df7GDWnGDMmN72cAAACQNSxevFg3b97UokWLlC1bNknStGnT1Lx5c40fP16BgYGSzN7dadOmyd3dXaVKlVLTpk21efNmdevWTZIS9DyfPHlSQUFBqlevnjw9PVWkSBE99thjyWaYNGmSWrVqpYIFC+qRRx5RzZo19eyzzya6Brp8+fIaNWqUJOmhhx7StGnTtHnzZtWvX1+SEgwsFxwcrLfeeks9evTQjBkz7Oujo6M1Y8YMVahQwZ51/vz5OnnypAoWLChJGjBggNatW6f58+frnXfeSdX7mTt3buXPn1/Hjx9P8vGTJ0+qZcuW9i8tihUrluC5kpQ/f/5EPd4PPfSQJkyYcM/j9+nTRy1btpQkzZw5U+vWrdO8efMSfVmRFF9fX/n7+8vDw0NBQUHJbpdebSYjUKS7gl69zEK9a1dzxPcbN6R588wR4QEAAOBa/Pyk207pzfRjZ4ADBw6oQoUK9mJLkh5//HHFxcXp0KFD9oLrkUcekbu7u32bAgUK6Jdffklyn61bt9bkyZNVrFgxNWrUSE2aNFHz5s3lkcz/ocuUKaPvvvtOhw8f1s6dO7Vt2zY1b95cnTt3TjB4XPny5RM8r0CBAjp37pz9/qZNmxQWFqaDBw8qIiJCMTExunnzpq5fvy6//3//vLy8Euznl19+UWxsrEqWLJlg35GRkcqTJ89d37vkGIaR7DXoffv2Vc+ePbVhwwbVq1dPLVu2TPS6klK5cuUUHbtGjRr2ZQ8PD1WpUkUHDhxIWfAUyog2k17oTnUVXbpIn35qjgC/aJHUrp2UwddSAAAAwAHZbFK2bNbc0nHgsbTw9PRMcN9msyU76FrhwoV16NAhzZgxQ76+vurVq5eeeuqpu16P7ObmpqpVq6pfv35auXKlFixYoHnz5unYsWMpynD8+HE1a9ZM5cuX14oVK7R3715Nnz5d0q2B1iSzt/j2Avrq1atyd3fX3r17tX//fvvtwIEDCU43T6l///1X58+fV9GiRZN8vGvXrjp69Kg6dOigX375RVWqVNHUqVPvud/bC+K0cnNzk3HHJbwZeY14atpMeqFIdyVt20rLl0teXtKyZVLLltLNm1anAgAAAO5L6dKl9dNPP+natWv2dTt27JCbm5sefvjhNO/X19dXzZs31wcffKDw8HDt3LkzVb2oZcqUkaQEue5m7969iouL06RJk1S9enWVLFlS//zzzz2fV6lSJcXGxurcuXMqUaJEgtvdTvlOzpQpU+Tm5nbXKfAKFy6sHj16aOXKlerfv7/mzp0ryezll8xR59Pq+++/ty/HxMRo7969Kl26tCQpX758unLlSoL39M551b28vO55/IxqM+mBIt3VtGghffGF5OMjrV4tPfNMhg3gAQAAANyPy5cvJ+gZ3r9/v/76669E27Vv314+Pj7q1KmTfv31V23dulWvvfaaOnToYD9tObXie8F//fVXHT16VJ988ol8fX314IMPJrl969atNWPGDO3atUsnTpxQeHi4evfurZIlS6pUqVIpOmaJEiUUHR2tqVOn6ujRo/r444/vOsBavJIlS6p9+/bq2LGjVq5cqWPHjmn37t0KCwvT119/fdfnXrlyRWfOnNFff/2lbdu26dVXX9Vbb72lt99+WyVKlEjyOf369dP69et17Ngx7du3T1u3brUX0Q8++KBsNpu++uornT9/PsFo6Sk1ffp0ff755zp48KB69+6tixcv6uWXX5YkVatWTX5+fho2bJiOHDmixYsXJxrILTg4WMeOHdP+/ft14cIFRUZGJjpGRrSZ9EKR7ooaNZLWrjVPOdq4UWrcWLpyxepUAAAAQALh4eGqVKlSgltoaGii7fz8/LR+/Xr9999/qlq1qlq1aqWnn35a06ZNS/Oxc+bMqblz5+rxxx9X+fLltWnTJq1evTrZa7wbNGigdevW6dlnn1XJkiXVqVMnlSpVShs2bEj2OvY7VahQQe+9957Gjx+vsmXL6tNPP1VYWFiKnjt//nx17NhR/fv318MPP6wWLVpoz549KlKkyF2fN3LkSBUoUEAlSpRQhw4ddPnyZW3evFmDBw9O9jmxsbHq3bu3SpcurUaNGqlkyZL2ge0eeOABhYaGasiQIQoMDEw0WnpKjBs3TuPGjVOFChX07bff6ssvv1TevHklmQPTffLJJ1qzZo3KlSunzz77LNE0di1btlSjRo1Up04d5cuXT5999lmiY2REm0kvNuPOE/qzuIiICOXIkUOXL19WQECA1XHuKjo6WmvWrFGTJk0SXQuRLnbuNAv2iAipWjWzcM+VK/2PA9xDhrd1wIHQ3uFKaO/Wu3nzpo4dO6aiRYvKx8fH6jhZWlxcnCIiIhQQECA3ZlJySXf7vKWmDqX1uLIaNaQtW6TcuaVdu6S6daV7zOsIAAAAAMg4FOmurnJl6ZtvpMBAaf9+qXZt6fRpq1MBAAAAgEuiSIdUtqxZqD/wgPT779JTT0knT1qdCgAAAABcDkU6TA8/LG3fLgUHS3/+aRbqR45YnQoAAAAAXApFOm4pWtQs1EuWlE6cMAv1gwetTgUAAID75GJjRQOWSK/PGUU6EipUSNq2zTwF/p9/zEL9p5+sTgUAAIA0iB9V//r16xYnAbK+qKgoSZK7u/t97SdlE/bBtQQGSuHhUoMG0r59Up060vr1UtWqVicDAABAKri7uytnzpw6d+6cJHNuaJvNZnGqrCkuLk5RUVG6efMmU7C5oLi4OJ0/f15+fn7y8Li/MpsiHUnLk0favFlq0sScT/3pp6U1a6QnnrA6GQAAAFIhKChIkuyFOjKGYRi6ceOGfH19+SLERbm5ualIkSL3/funSEfycuaUNmyQmjc3e9YbNpS+/NIs2AEAAOAUbDabChQooPz58ys6OtrqOFlWdHS0tm3bpqeeesp+mQFci5eXV7qcRUGRjrvz9zd70J9/Xlq3TmraVFq50uxhBwAAgNNwd3e/72tlkTx3d3fFxMTIx8eHIh33hYslcG++vtKqVVKLFlJkpPlzxQqLQwEAAABA1uMQRfr06dMVHBwsHx8fVatWTbt3707R85YsWSKbzaYWLVpkbEBI3t7S//4ntW0rRUdLbdpIn35qdSoAAAAAyFIsL9KXLl2qkJAQjRo1Svv27VOFChXUsGHDew5scfz4cQ0YMEBPPvlkJiWFPD2lTz6RunSRYmOlDh2kDz+0OhUAAAAAZBmWF+nvvfeeunXrpi5duqhMmTKaNWuW/Pz89NFHHyX7nNjYWLVv316hoaEqVqxYJqaF3N3NwrxXL8kwpG7dpKlTrU4FAAAAAFmCpQPHRUVFae/evRo6dKh9nZubm+rVq6edO3cm+7wxY8Yof/78euWVV7R9+/a7HiMyMlKRkZH2+xEREZLM0RcdfXTL+HwOmfP99+Xm4yP3996T+vZV7JUrihs40OpUcFIO3daBdEZ7hyuhvcOV0N5xN6lpF5YW6RcuXFBsbKwCAwMTrA8MDNTBgweTfM63336refPmaf/+/Sk6RlhYmEJDQxOt37Bhg/z8/FKd2QobN260OkLSnnxSD586pVJLl8r9zTd1+OefdahtW4l5IZFGDtvWgQxAe4crob3DldDekZTr16+neFunmoLtypUr6tChg+bOnau8efOm6DlDhw5VSEiI/X5ERIQKFy6sBg0aKCAgIKOipovo6Ght3LhR9evXd9xpHJo2VWz58nJ/802VWrpUDz3wgOLCwijUkSpO0daBdEJ7hyuhvcOV0N5xN/FndKeEpUV63rx55e7urrNnzyZYf/bsWQUFBSXa/siRIzp+/LiaN29uXxcXFydJ8vDw0KFDh1S8ePEEz/H29pa3t3eifXl6ejrNh8fhsw4bJmXPLvXtK/f33pP7zZvmdepulg95ACfj8G0dSEe0d7gS2jtcCe0dSUlNm7C0ivLy8lLlypW1efNm+7q4uDht3rxZNWrUSLR9qVKl9Msvv2j//v322zPPPKM6depo//79Kly4cGbGx+1ee02aO9fsQZ8xQ+ra1RwBHgAAAACQYpaf7h4SEqJOnTqpSpUqeuyxxzR58mRdu3ZNXbp0kSR17NhRDzzwgMLCwuTj46OyZcsmeH7OnDklKdF6WKBrV8nXV+rUSZo/X7pxQ1q0yJy6DQAAAABwT5YX6W3atNH58+c1cuRInTlzRhUrVtS6devsg8mdPHlSbpw27Tzat5d8fKQXX5SWLJFu3jR/JnHJAQAAAAAgIcuLdEnq06eP+vTpk+Rj4eHhd33uggUL0j8Q7k/LltLnn5s/V62SWrSQVq40e9kBAAAAAMmiixoZo2lT6euvJT8/ad068/7Vq1anAgAAAACHRpGOjPP009L69ebI71u3Sg0aSJcvW50KAAAAABwWRToy1hNPSJs3S7lySTt3moX7v/9anQoAAAAAHBJFOjJe1apmT3q+fNLevVLt2tLZs1anAgAAAACHQ5GOzFGhgvTNN1LBgtKvv0pPPSX9/bfVqQAAAADAoVCkI/OULi1t2yYVKSL98YdZqB87ZnUqAAAAAHAYFOnIXMWLS9u3SyVKmAX6U0+ZBTsAAAAAgCIdFihSxOxRL1PGPOX9qafMU+ABAAAAwMVRpMMaBQpI4eFSxYrmIHK1a0v79lkcCgAAAACsRZEO6+TLJ23ZIj32mDktW9265jRtAAAAAOCiKNJhrVy5pI0bpSeflC5flurXN3vYAQAAAMAFUaTDegEB0rp1ZoF+7ZrUuLG0fr3VqQAAAAAg01GkwzH4+Ulffik1by7dvCk984z0xRdWpwIAAACATEWRDsfh4yMtXy61bi1FRUktW0pLl1qdCgAAAAAyDUU6HIuXl7R4sdShgxQbK7VrJy1YYHUqAAAAAMgUFOlwPB4eZmHevbsUFyd16SLNmGF1KgAAAADIcBTpcExubtLMmVK/fub93r2lSZMsjQQAAAAAGY0iHY7LZpPee08aNsy8P2CANHasZBjW5gIAAACADEKRDsdms0lvvy299ZZ5f+RIs2inUAcAAACQBVGkwzm8+abZqy5J48aZp8FTqAMAAADIYijS4TzeeMO8Tl2SPvjAHFguNtbaTAAAAACQjijS4Vx69DBHfndzk+bOlTp3lmJirE4FAAAAAOmCIh3Op1Mn6bPPzKnaPvlEattWioqyOhUAAAAA3DeKdDinF16QVqyQvLzMn88/L928aXUqAAAAALgvFOlwXs88I61eLfn6Sl9/LTVvLl27ZnUqAAAAAEgzinQ4twYNpLVrJX9/adMmqVEjKSLC6lQAAAAAkCYU6XB+tWpJGzdKOXJI334r1asn/fef1akAAAAAINUo0pE1VK8ubdki5ckj7dkj1akjnTtndSoAAAAASBWKdGQdjz4qffONFBgo/fyz2cP+zz9WpwIAAACAFKNIR9byyCPStm1SoULSwYPSU09JJ05YnQoAAAAAUoQiHVlPyZLS9u1S0aLSkSPSk09Kf/5pdSoAAAAAuCeKdGRNwcFmof7ww9Jff5k96r//bnUqAAAAALgrinRkXQ88YF6jXq6cdPq0eY36/v1WpwIAAACAZFGkI2sLDJS2bpWqVJEuXDBHfd+92+pUAAAAAJAkinRkfXnySJs2STVrSpcumfOob99udSoAAAAASIQiHa4hRw5p/Xqpbl3pyhWpYUOzcAcAAAAAB0KRDtfh7y999ZXUuLF044bUrJl5HwAAAAAcBEU6XIuvr/T559Jzz0mRkebPZcusTgUAAAAAkijS4Yq8vaX//U9q106KiZHatpU+/tjqVAAAAABAkQ4X5eEhLVokvfKKFBcndeokzZljdSoAAAAALo4iHa7L3d0szPv0kQxD6t5dmjLF6lQAAAAAXBhFOlybm5v0wQfSoEHm/X79pLAwSyMBAAAAcF0U6YDNJo0bJ40ebd4fNkz68ENLIwEAAABwTRTpgGQW6qNGmTdJGjFCun7d2kwAAAAAXA5FOnC7YcOk4GDpzBlp5kyr0wAAAABwMRTpwO28vKSRI83lceOkK1eszQMAAADApVCkA3fq0EF66CHpwgVp6lSr0wAAAABwIRTpwJ08PG5dm/7uu9KlS5bGAQAAAOA6KNKBpLRtK5UpYxbo779vdRoAAAAALoIiHUiKu7sUGmouv/++9O+/1uYBAAAA4BIo0oHkPP+8VLGiOXjcxIlWpwEAAADgAijSgeS4uUljxpjLH3wgnT1rbR4AAAAAWR5FOnA3zZpJjz0mXb8ujR9vdRoAAAAAWRxFOnA3Nps0dqy5PGOGdOqUtXkAAAAAZGkU6cC91K8vPfGEFBkpvfOO1WkAAAAAZGEU6cC93N6bPneudOKEtXkAAAAAZFkU6UBK1K4tPf20FB19q2AHAAAAgHRGkQ6kVHxxvmCB9OeflkYBAAAAkDVRpAMpVaOG1KSJFBsrhYZanQYAAABAFkSRDqRG/Lzpn34qHThgbRYAAAAAWQ5FOpAalStLLVpIhiGNHm11GgAAAABZDEU6kFpjxpgjvv/vf9JPP1mdBgAAAEAWQpEOpFa5ctILL5jLo0ZZmwUAAABAlkKRDqTF6NGSm5v0xRfSnj1WpwEAAACQRVCkA2lRqpT00kvm8siR1mYBAAAAkGVQpANpNXKk5O4urVsn7dhhdRoAAAAAWQBFOpBWxYtLL79sLo8YYW0WAAAAAFkCRTpwP4YPl7y8pK1bzRsAAAAA3AeKdOB+FCkidetmLo8YYc6fDgAAAABpRJEO3K9hwyQfH/O69PXrrU4DAAAAwIlRpAP3q2BBqVcvc5nedAAAAAD3gSIdSA+DB0vZskk//CB9+aXVaQAAAAA4KYp0ID3kzy/17WsujxwpxcVZmwcAAACAU6JIB9LLgAFSQID088/SihVWpwEAAADghCjSgfSSO7cUEmIujxolxcZamwcAAACA06FIB9JTv35SrlzSgQPSZ59ZnQYAAACAk6FIB9JTjhzSoEHm8ujRUnS0pXEAAAAAOBeKdCC99ekj5csnHTkiLVpkdRoAAAAAToQiHUhv/v7SkCHm8pgxUmSktXkAAAAAOA2KdCAj9OwpFSggnTwpzZtndRoAAAAAToIiHcgIvr7Sm2+ay2+/Ld24YW0eAAAAAE6BIh3IKF27SoULS//8I82aZXUaAAAAAE6AIh3IKN7e0siR5vK4cdK1a9bmAQAAAODwKNKBjNSpk1SsmHTunDRtmtVpAAAAADg4hyjSp0+fruDgYPn4+KhatWravXt3stuuXLlSVapUUc6cOZUtWzZVrFhRH3/8cSamBVLB09OcL12SJkyQIiIsjQMAAADAsVlepC9dulQhISEaNWqU9u3bpwoVKqhhw4Y6d+5cktvnzp1bb775pnbu3Kmff/5ZXbp0UZcuXbR+/fpMTg6kULt2UqlS0n//SZMnW50GAAAAgAOzvEh/77331K1bN3Xp0kVlypTRrFmz5Ofnp48++ijJ7WvXrq3nnntOpUuXVvHixfX666+rfPny+vbbbzM5OZBC7u63etMnTTKLdQAAAABIgoeVB4+KitLevXs1dOhQ+zo3NzfVq1dPO3fuvOfzDcPQli1bdOjQIY0fPz7JbSIjIxUZGWm/H/H/pxtHR0crOjr6Pl9BxorP5+g5kQItWsijbFnZfv1VsRMmKG7sWKsTORTaOlwJ7R2uhPYOV0J7x92kpl1YWqRfuHBBsbGxCgwMTLA+MDBQBw8eTPZ5ly9f1gMPPKDIyEi5u7trxowZql+/fpLbhoWFKTQ0NNH6DRs2yM/P7/5eQCbZuHGj1RGQDoKaNVO1X3+VMWWKNpUpo6gcOayO5HBo63AltHe4Eto7XAntHUm5fv16ire1tEhPq+zZs2v//v26evWqNm/erJCQEBUrVky1a9dOtO3QoUMVEhJivx8REaHChQurQYMGCggIyMTUqRcdHa2NGzeqfv368vT0tDoO7lfjxorbsEEe+/apwf79ikvm7A9XRFuHK6G9w5XQ3uFKaO+4m4hUDCBtaZGeN29eubu76+zZswnWnz17VkFBQck+z83NTSVKlJAkVaxYUQcOHFBYWFiSRbq3t7e8vb0Trff09HSaD48zZcU9vPWW1KSJ3GfOlPvAgVKBAlYncii0dbgS2jtcCe0droT2jqSkpk1YOnCcl5eXKleurM2bN9vXxcXFafPmzapRo0aK9xMXF5fgunPAYTVqJNWoId28KYWFWZ0GAAAAgIOxfHT3kJAQzZ07VwsXLtSBAwfUs2dPXbt2TV26dJEkdezYMcHAcmFhYdq4caOOHj2qAwcOaNKkSfr444/10ksvWfUSgJSz2czedEmaPVs6edLaPAAAAAAciuXXpLdp00bnz5/XyJEjdebMGVWsWFHr1q2zDyZ38uRJubnd+i7h2rVr6tWrl/7++2/5+vqqVKlS+uSTT9SmTRurXgKQOnXrSrVrS+Hh0ttvm8U6AAAAAMgBinRJ6tOnj/r06ZPkY+Hh4Qnuv/XWW3orvicScFZjx0pPPil99JE0eLBUrJjViQAAAAA4AMtPdwdc0hNPSA0bSjEx0pgxVqcBAAAA4CAo0gGrxBfnH38sHTpkbRYAAAAADoEiHbDKY49JzzwjxcVJo0dbnQYAAACAA6BIB6wU35u+dKn0yy/WZgEAAABgOYp0wEoVKkitWkmGIY0aZXUaAAAAABajSAesFhpqzp/++efSvn1WpwEAAABgIYp0wGplykjt2pnLI0damwUAAACApSjSAUcwapTk7i59/bW0c6fVaQAAAABYhCIdcAQPPSR16mQu05sOAAAAuCyKdMBRjBgheXpKmzZJ33xjdRoAAAAAFqBIBxxFcLDUtau5PGKEOeI7AAAAAJdCkQ44kjfflLy9pe3bzR51AAAAAC6FIh1wJA88IPXoYS4PH05vOgAAAOBiKNIBRzNkiOTnJ+3ebY72DgAAAMBlUKQDjiYoSOrTx1weOVKKi7M2DwAAAIBMQ5EOOKJBg6Ts2aUff5Q+/9zqNAAAAAAyCUU64Ijy5JH69TOXR42SYmMtjQMAAAAgc1CkA44qJETKmVP67Tdp6VKr0wAAAADIBBTpgKPKmVMaMMBcHj1aiomxMg0AAACATECRDjiyvn3NU98PH5Y++cTqNAAAAAAyGEU64MiyZzenZJOk0FApKsraPAAAAAAyFEU64Oh69TKnZTt+XJo/3+o0AAAAADIQRTrg6Pz8pKFDzeWxY6WbN63NAwAAACDDUKQDzuDVV6VChaRTp6Q5c6xOAwAAACCDUKQDzsDHRxo+3Fx+5x3p+nVr8wAAAADIEBTpgLPo0kUKDpbOnpWmT7c6DQAAAIAMQJEOOAsvL2nUKHN5/HjpyhVr8wAAAABIdxTpgDN56SWpZEnp33+lDz6wOg0AAACAdEaRDjgTDw9p9GhzeeJE6dIlK9MAAAAASGcU6YCzadNGeuQRs0B/7z2r0wAAAABIRxTpgLNxc5NCQ83l99+XLlywNg8AAACAdEORDjij556TKlWSrl6V3n3X6jQAAAAA0glFOuCM3NykMWPM5alTpTNnrM0DAAAAIF1QpAPOqmlTqVo16cYNadw4q9MAAAAASAcU6YCzstmksWPN5VmzpL//tjYPAAAAgPtGkQ44s3r1pCeflCIjpbfftjoNAAAAgPtEkQ44M5tNeustc3nePOn4cUvjAAAAALg/FOmAs3vqKbNHPTr61unvAAAAAJwSRTqQFcQX5wsXSocPW5sFAAAAQJpRpANZQfXq5mjvsbFSaKjVaQAAAACkEUU6kFXEz5u+eLH022/WZgEAAACQJhTpQFbx6KPS889LhiGNHm11GgAAAABpQJEOZCWhoeaI78uXS/v3W50GAAAAQCpRpANZSdmyUps25vLIkdZmAQAAAJBqFOlAVjN6tOTmJq1eLe3ebXUaAAAAAKlAkQ5kNQ8/LHXoYC7Tmw4AAAA4FYp0ICsaOVLy8JDWr5e+/dbqNAAAAABSiCIdyIqKFZNeftlcHj7cHPEdAAAAgMOjSAeyquHDJS8v6ZtvpC1brE4DAAAAIAUo0oGsqnBhqXt3c3nECHrTAQAAACeQ5iI9JiZGmzZt0uzZs3XlyhVJ0j///KOrV6+mWzgA92noUMnHR9q5U1q3zuo0AAAAAO4hTUX6iRMnVK5cOT377LPq3bu3zp8/L0kaP368BgwYkK4BAdyHAgWk3r3NZXrTAQAAAIeXpiL99ddfV5UqVXTx4kX5+vra1z/33HPavHlzuoUDkA4GD5ayZZP27pW++MLqNAAAAADuIk1F+vbt2zV8+HB5eXklWB8cHKxTp06lSzAA6SRfPun1183lESOkuDhr8wAAAABIVpqK9Li4OMXGxiZa//fffyt79uz3HQpAOhswQMqRQ/r1V2nZMqvTAAAAAEhGmor0Bg0aaPLkyfb7NptNV69e1ahRo9SkSZP0ygYgveTKJYWEmMujRkkxMdbmAQAAAJCkNBXpEydO1I4dO1SmTBndvHlT7dq1s5/qPn78+PTOCCA99Osn5c4tHTokLV5sdRoAAAAASUhTkV64cGH99NNPevPNN/XGG2+oUqVKGjdunH788Uflz58/vTMCSA8BAdKgQeZyaKgUHW1tHgAAAACJeKT2CdHR0SpVqpS++uortW/fXu3bt8+IXAAyQp8+0nvvSUePSgsWSN26WZ0IAAAAwG1S3ZPu6empmzdvZkQWABktWzZp6FBzeexYKTLS2jwAAAAAEkjT6e69e/fW+PHjFcPgU4Dz6dFDKlhQ+usv6cMPrU4DAAAA4DapPt1dkvbs2aPNmzdrw4YNKleunLJly5bg8ZUrV6ZLOAAZwMdHevNNqXdv6e23pZdflnx9rU4FAAAAQGks0nPmzKmWLVumdxYAmeWVV6QJE6QTJ6SZM29NzwYAAADAUmkq0ufPn5/eOQBkJm9vacQIqWtXadw46dVXJX9/q1MBAAAALi9N16QDyAI6dpSKF5fOn5emTrU6DQAAAAClsSddkpYvX67//e9/OnnypKKiohI8tm/fvvsOBiCDeXpKo0dLHTpI774r9eol5chhdSoAAADApaWpJ/2DDz5Qly5dFBgYqB9//FGPPfaY8uTJo6NHj6px48bpnRFARnnxRal0aeniRen9961OAwAAALi8NBXpM2bM0Jw5czR16lR5eXlp0KBB2rhxo/r27avLly+nd0YAGcXdXQoNNZfff1/67z9r8wAAAAAuLk1F+smTJ1WzZk1Jkq+vr65cuSJJ6tChgz777LP0Swcg47VsKZUvL0VESBMnWp0GAAAAcGlpKtKDgoL03//3uBUpUkTff/+9JOnYsWMyDCP90gHIeG5u0pgx5vKUKdK5c9bmAQAAAFxYmor0unXr6ssvv5QkdenSRW+88Ybq16+vNm3a6LnnnkvXgAAywTPPSFWqSNevS+PHW50GAAAAcFlpGt19zpw5iouLkyT17t1befLk0XfffadnnnlG3bt3T9eAADKBzSaNHSs1bizNmCH17y8VLGh1KgAAAMDlpKlId3Nzk5vbrU74tm3bqm3btukWCoAFGjaUHn9c2rFDeucdado0qxMBAAAALifN86RfunRJu3fv1rlz5+y96vE6dux438EAZLL43vS6daU5c6SBA6UHH7Q6FQAAAOBS0lSkr169Wu3bt9fVq1cVEBAgm81mf8xms1GkA86qTh3ztnWr9NZb0ty5VicCAAAAXEqaBo7r37+/Xn75ZV29elWXLl3SxYsX7bf/mGcZcG5jx5o/58+X/vzT2iwAAACAi0lTkX7q1Cn17dtXfn5+6Z0HgNUef1xq1EiKjb01NRsAAACATJGmIr1hw4b64Ycf0jsLAEcRX5x/+ql08KC1WQAAAAAXkuJr0uPnRZekpk2bauDAgfr9999Vrlw5eXp6Jtj2mWeeSb+EADJf1arSs89KX3whjR4tLVlidSIAAADAJaS4SG/RokWidWOSOBXWZrMpNjb2vkIBcABjxphF+tKl0rBhUvnyVicCAAAAsrwUn+4eFxeXohsFOpBFlC8vvfCCuTxqlLVZAAAAABeRqmvSd+7cqa+++irBukWLFqlo0aLKnz+/Xn31VUVGRqZrQAAWGj1acnOTVq2S9u61Og0AAACQ5aWqSA8NDdVvv/1mv//LL7/olVdeUb169TRkyBCtXr1aYWFh6R4SgEVKl5batTOXR4ywNgsAAADgAlJVpP/00096+umn7feXLFmiatWqae7cuQoJCdEHH3yg//3vf+keEoCFRo2S3N2ltWul776zOg0AAACQpaWqSL948aICAwPt97/55hs1btzYfr9q1ar666+/Uh1i+vTpCg4Olo+Pj6pVq6bdu3cnu+3cuXP15JNPKleuXMqVK5fq1at31+0B3KcSJaTOnc1letMBAACADJWqIj0wMFDHjh2TJEVFRWnfvn2qXr26/fErV64kmo7tXpYuXaqQkBCNGjVK+/btU4UKFdSwYUOdO3cuye3Dw8P14osvauvWrdq5c6cKFy6sBg0a6NSpU6k6LoBUGDFC8vSUtmyRwsOtTgMAAABkWSmegk2SmjRpoiFDhmj8+PFatWqV/Pz89OSTT9of//nnn1W8ePFUBXjvvffUrVs3denSRZI0a9Ysff311/roo480ZMiQRNt/+umnCe5/+OGHWrFihTZv3qyOHTum6tiO7PBh6fffbfrhh0BJNnmk6jcFpLcH9UiDbgr+eob+6z1CO8dvk2y2dNt7TAxtHa4jJsamQ4dyqUkTq5MAAABHlKr/Do8dO1bPP/+8atWqJX9/fy1cuFBeXl72xz/66CM1aNAgxfuLiorS3r17NXToUPs6Nzc31atXTzt37kzRPq5fv67o6Gjlzp07yccjIyMTjDgfEREhSYqOjlZ0dHSKs2a2Tz5x05gxHpKq33NbIDMU1DAd0Tzl/v1bfdB8gzaoYTrunbYOV+Ih6SkVLBipNm0c998hID3E/1/Lkf/PBaQX2jvuJjXtIlVFet68ebVt2zZdvnxZ/v7+cnd3T/D4smXL5O/vn+L9XbhwQbGxsQmuc5fM0+oPHjyYon0MHjxYBQsWVL169ZJ8PCwsTKGhoYnWb9iwQX5+finOmtn+/beIHnoo2OoYwG389Nn5l9Xl0ky96z1MxwpXTdfedMBVXLvmqX/+8dfQoVHy89uiO/4pBbKkjRs3Wh0ByDS0dyTl+vXrKd42TSeW5siRI8n1yfVmZ5Rx48ZpyZIlCg8Pl4+PT5LbDB06VCEhIfb7ERER9uvYAwICMitqqjVpYn7bsnHjRtWvXz/V1/oDGeLcmzJKLlT56/v0+/hwGc2bp8tuaetwJRcuROuhh6L099/ZdfNmU7VubVgdCcgw/H2HK6G9427iz+hOCUuv/sybN6/c3d119uzZBOvPnj2roKCguz534sSJGjdunDZt2qTy5csnu523t7e8vb0Trff09HSaD48zZUUW98AD0muvSePHy2PMGKlFC8ktVeNP3hVtHa4gb16pefMjWrKklN55x0Nt26brxwhwSPx9hyuhvSMpqWkTlv63wMvLS5UrV9bmzZvt6+Li4rR582bVqFEj2edNmDBBY8eO1bp161SlSpXMiAog3sCBUvbs0k8/SStXWp0GcErNmh1VQICh336TPv/c6jQAAMCRWP7dfUhIiObOnauFCxfqwIED6tmzp65du2Yf7b1jx44JBpYbP368RowYoY8++kjBwcE6c+aMzpw5o6tXr1r1EgDXkieP9MYb5vLIkVJsrLV5ACfk7x+tPn3iJEljxkhxcRYHAgAADsPyIr1NmzaaOHGiRo4cqYoVK2r//v1at26dfTC5kydP6vTp0/btZ86cqaioKLVq1UoFChSw3yZOnGjVSwBczxtvSLlySQcOSEuWWJ0GcEp9+8Ype3bp55+lL76wOg0AAHAUlhfpktSnTx+dOHFCkZGR2rVrl6pVq2Z/LDw8XAsWLLDfP378uAzDSHQbPXp05gcHXFXOnNKAAeby6NFSTIyVaQCnlDu3OcSDZPamG4wfBwAA5CBFOgAn1LevOQLWn39KixZZnQZwSiEhUrZs0v790urVVqcBAACOgCIdQNr4+0tDhpjLY8ZIUVHW5gGcUJ48Up8+5jK96QAAQKJIB3A/evaUgoKkEyekefOsTgM4pf79JT8/ae9eac0aq9MAAACrUaQDSDs/P+nNN83lt9+Wbt60Ng/ghPLlk3r1MpfpTQcAABTpAO5Pt25S4cLSqVPS7NlWpwGc0oABkq+vtHu3tH691WkAAICVKNIB3B9vb2n4cHP5nXeka9eszQM4ocBA8+oRSQoNpTcdAABXRpEO4P516SIVKyadOydNn251GsApDRwo+fhI338vbdpkdRoAAGAVinQA98/TUxo50lweP16KiLA2D+CEgoKk7t3NZXrTAQBwXRTpANJH+/bSww9L//0nTZlidRrAKQ0aZF5BsmOHtHWr1WkAAIAVKNIBpA8PD2n0aHN50iTp4kVL4wDOqGBBcyxGyexNBwAArociHUD6eeEFqWxZ6fJls1AHkGqDB0teXtK2bVJ4uNVpAABAZqNIB5B+3NzMiZ4l85T38+etzQM4oUKFpFdeMZfjP04AAMB1UKQDSF8tWkiPPipdvSpNmGB1GsApDRlijse4dau0fbvVaQAAQGaiSAeQvmy2W91/06dLZ85YmwdwQkWKmDMbSvSmAwDgaijSAaS/Jk2k6tWlGzeksDCr0wBOaehQczzGTZuk776zOg0AAMgsFOkA0p/NJo0day7PmiX99Ze1eQAnFBwsde5sLjPSOwAAroMiHUDGePppqVYtKSpKevttq9MATmnoUMndXdqwQfr+e6vTAACAzECRDiBj3N6bPm+edPSotXkAJ1SsmNSxo7nMtekAALgGinQAGefJJ6X69aWYmFsFO4BUGTbM7E1fu1bas8fqNAAAIKNRpAPIWPHF+aJF0h9/WJsFcEIlSkjt25vL9KYDAJD1UaQDyFjVqknNmklxcdLo0VanAZzSm29Kbm7SV19J+/ZZnQYAAGQkinQAGS+++2/JEunXX63NAjihkiWlF180l+lNBwAga6NIB5DxKlWSWraUDIPedCCNhg83x2P84gtp/36r0wAAgIxCkQ4gc4SGmhXGihXSjz9anQZwOqVKSW3amMuMwwgAQNZFkQ4gczzyyK3zdUeOtDYL4KTie9NXrpR+/tnqNAAAICNQpAPIPKNG3Rr96vvvrU4DOJ1HHpFatTKX33rL2iwAACBjUKQDyDwlS0odO5rL9KYDaTJihPlz+XLpt9+szQIAANIfRTqAzDVypOThIW3cKG3bZnUawOmUK3drHEauTQcAIOuhSAeQuYoWlV55xVweMcKsNACkSnxv+v/+Jx04YG0WAACQvijSAWS+4cMlb2+zJ33zZqvTAE6nQgWpRQvzOy6uTQcAIGuhSAeQ+QoVkrp3N5eHD6c3HUiD+N70JUukQ4eszQIAANIPRToAawwdKvn6Srt2ybZ2rdVpAKfz6KNS8+ZSXJz09ttWpwEAAOmFIh2ANYKCpD59JEnuo0fTmw6kQfwkCZ9+Kv35p7VZAABA+qBIB2CdQYMkf3/Z9u9XAeZNB1KtShWpSRN60wEAyEoo0gFYJ29eqV8/SVKpzz6TYmOtzQM4ofje9I8/lo4csTYLAAC4fxTpAKwVEiIjRw4FnDwp28KFVqcBnE61alLDhuZ3XGFhVqcBAAD3iyIdgLVy5VLc4MGSJPd+/aT9+y2NAzijUaPMnwsXSsePWxoFAADcJ4p0AJaLCwnR2Ucfle3mTallS+niRasjAU6lRg2pXj0pJobedAAAnB1FOgDrublp7xtvyAgOlo4elV56yRwJC0CKxfemz58vnTxpbRYAAJB2FOkAHEJ09uyKWbpU8vGR1qyR3nrL6kiAU3niCaluXSk6mt50AACcGUU6AMdRqZI0a5a5PHq0tHatpXEAZxM/0vu8edJff1mbBQAApA1FOgDH0qmT1KOHZBhSu3bm6e8AUqRWLfMWHS2NH291GgAAkBYU6QAcz+TJ5rxSly6ZA8ldv251IsBpxPemz50rnTplbRYAAJB6FOkAHI+3t7R8uZQvnzklW8+eZs86gHuqU8e8Pj0qSpowweo0AAAgtSjSATimQoWkJUskNzdp0SJp9myrEwFOwWa7NdL7nDnS6dPW5gEAAKlDkQ7AcdWte2uY6r59pe+/tzYP4CSeftqcO/3mTendd61OAwAAUoMiHYBjGzhQev55cySsVq2kc+esTgQ4vNt702fNks6etTYPAABIOYp0AI7NZpPmz5dKlTJHwWrbVoqJsToV4PAaNJAee0y6cUOaONHqNAAAIKUo0gE4voAAaeVKyd9f2rpVGjbM6kSAw7u9N33GDE5CAQDAWVCkA3AOpUtLH31kLr/7rrRihbV5ACfQuLFUpYo5i+F771mdBgAApARFOgDn0bq11L+/udy5s3TwoKVxAEdns92aN33aNOnCBWvzAACAe6NIB+Bcxo2TateWrl6VnntOunLF6kSAQ2vWTKpUSbp2jd50AACcAUU6AOfi4WHOn16woNmT/vLLkmFYnQpwWLf3pk+dKv33n7V5AADA3VGkA3A+gYHS8uWSp6f5k+5B4K6efVaqUME8AeX9961OAwAA7oYiHYBzqlFDmjzZXB48WAoPtzIN4NBsNmnECHP5gw+kixetzQMAAJJHkQ7AefXsKXXoIMXGSi+8IP39t9WJAIf13HNS2bJSRIQ0ZYrVaQAAQHIo0gE4L5tNmjXLPI/3/Hlz9PfISKtTAQ7Jze3WtemTJ0uXLlmZBgAAJIciHYBz8/Mz50zPmVP6/nspJMTqRIDDatlSKlNGunzZHEQOAAA4Hop0AM6veHHpk0/M5RkzpEWLrM0DOCg3t1vXpr//vnnqOwAAcCwU6QCyhqZNpVGjzOXu3aX9+y2NAziq1q2lUqXMweOmTbM6DQAAuBNFOoCsY+RIqXFj6eZN6fnnGcIaSIK7uzR8uLk8aZJ05Yq1eQAAQEIU6QCyDjc387T3okWlY8ekl16S4uKsTgU4nLZtpZIlpf/+k6ZPtzoNAAC4HUU6gKwld25zIDkfH2nNGmnsWKsTAQ7H3V16801zedIk6epVa/MAAIBbKNIBZD2VKplTs0lSaKhZrANIoF07c8zFCxekmTOtTgMAAOJRpAPImjp1knr0kAxDat9eOnrU6kSAQ/HwuNWb/u670vXr1uYBAAAminQAWdfkyVK1atKlS+YE0VQhQAIvvWQO4XD+/K2TTwAAgLUo0gFkXd7e0vLlUr585pRsPXuaPesAJEmenrd60ydMkG7csDYPAACgSAeQ1RUqJC1dao78vmgR3YXAHTp0kB58UDp7Vpozx+o0AACAIh1A1lenjjRunLn8+uvS999bmwdwIF5e0rBh5vL48dLNm9bmAQDA1VGkA3ANAwaY16VHR0utWknnzlmdCHAYnTtLhQtLp09LH35odRoAAFwbRToA12CzSfPnS6VKSadOSW3aSDExVqcCHIKXlzR0qLk8bpwUGWltHgAAXBlFOgDXkT27tHKl5O8vhYffOscXgF5+WXrgAfM7rI8+sjoNAACuiyIdgGspXfpWBfLuu9KKFdbmARyEt7c0ZIi5HBZGbzoAAFahSAfgelq3Nq9Rl8yLcQ8csDQO4Ci6dpUKFJD++ktasMDqNAAAuCaKdACuKSxMql1bunpVev556coVqxMBlvPxkQYPNpffeUeKirI2DwAArogiHYBr8vCQliwxL8I9eNC8INcwrE4FWO7VV6XAQOnkSWnRIqvTAADgeijSAbiuwEBp2TLJ01NavlyaNMnqRIDlfH2lQYPM5XfeMWctBAAAmYciHYBrq1FDmjzZXB48WNq61dI4gCPo0UPKn186dkz65BOr0wAA4Foo0gGgZ0+pY0cpLs6cP/3vv61OBFjKz08aONBcfvttKSbG2jwAALgSinQAsNmkmTOlChWk8+fN0d+ZfwourmdPKW9e6cgRafFiq9MAAOA6KNIBQDK7DleskHLmlL7/XgoJsToRYKls2W7NVPjWW/SmAwCQWSjSASBe8eLSp5+ayzNmMLQ1XF6vXlLu3NLhw9LSpVanAQDANVCkA8DtmjSRRo0yl7t3l/bvtzQOYKXs2aX+/c3lsWOl2Fhr8wAA4Aoo0gHgTiNHSo0bSzdvSs8/L128aHUiwDJ9+ki5ckmHDpkzFgIAgIxleZE+ffp0BQcHy8fHR9WqVdPu3buT3fa3335Ty5YtFRwcLJvNpsnx0yYBQHpyczPnnSpa1JyD6qWXzJHfARcUECC98Ya5PHYsHwUAADKapUX60qVLFRISolGjRmnfvn2qUKGCGjZsqHPnziW5/fXr11WsWDGNGzdOQUFBmZwWgEvJndscSM7HR1qzxqxOABfVt6+UI4f0++/S8uVWpwEAIGuztEh/77331K1bN3Xp0kVlypTRrFmz5Ofnp48++ijJ7atWrap3331Xbdu2lbe3dyanBeByKlWSZs82l0NDzWIdcEE5ckj9+pnL9KYDAJCxPKw6cFRUlPbu3auhQ4fa17m5ualevXrauXNnuh0nMjJSkbfNdxwRESFJio6OVnR0dLodJyPE53P0nMD9cui2/uKLcvvuO7nPni2jfXvFfP+9VKyY1angxBy6vd9Fr17S++976NdfbVq2LEbPP29YHQlOwFnbO5AWtHfcTWrahWVF+oULFxQbG6vAwMAE6wMDA3Xw4MF0O05YWJhCQ0MTrd+wYYP8/PzS7TgZaePGjVZHADKFo7Z1t3r19PjWrcr9xx+63qiRto8fr1jO5sF9ctT2fjcNG5bSsmUPa8iQa/LyCpeb5SPbwFk4Y3sH0or2jqRcv349xdtaVqRnlqFDhyokJMR+PyIiQoULF1aDBg0UEBBgYbJ7i46O1saNG1W/fn15enpaHQfIME7R1itXllGtmnIcP64mq1crdt48yWazOhWckFO092RUry6tW2fo+PEcio1tqmbN6E3H3TlzewdSi/aOu4k/ozslLCvS8+bNK3d3d509ezbB+rNnz6broHDe3t5JXr/u6enpNB8eZ8oK3A+HbutFi0pLl0r16sntk0/kVrOm1LOn1angxBy6vScjMFB67TXpnXekd97xUMuWfFeFlHHG9g6kFe0dSUlNm7DsRDUvLy9VrlxZmzdvtq+Li4vT5s2bVaNGDatiAUDy6tSRxo0zl19/Xfr+e2vzABZ44w0pWzbpxx+lr76yOg0AAFmPpVeThYSEaO7cuVq4cKEOHDignj176tq1a+rSpYskqWPHjgkGlouKitL+/fu1f/9+RUVF6dSpU9q/f7/+/PNPq14CAFczYIDUsqUUHS21aiXdcTYQkNXlzSv16WMuh4ZKBme8AwCQriwt0tu0aaOJEydq5MiRqlixovbv369169bZB5M7efKkTp8+bd/+n3/+UaVKlVSpUiWdPn1aEydOVKVKldS1a1erXgIAV2OzSfPnS6VKSadOSW3bSjExVqcCMlX//pKfn7R3r7R2rdVpAADIWiwfl7VPnz46ceKEIiMjtWvXLlWrVs3+WHh4uBYsWGC/HxwcLMMwEt3Cw8MzPzgA15U9u7RypeTvL4WHS8OGWZ0IyFT58plTskn0pgMAkN4sL9IBwCmVLm32qEvSu+9Ky5dbmwfIZAMGSL6+0u7d0vr1VqcBACDroEgHgLRq1cqsVCSpSxfpwAFr8wCZKDBQ6tHDXKY3HQCA9EORDgD3IyxMql1bunpVev556coVqxMBmWbgQMnHx5zoYNMmq9MAAJA1UKQDwP3w8JCWLJEeeEA6eNDsUadLES6iQAHp1VfNZXrTAQBIHxTpAHC/AgPNa9I9PaUVK6RJk6xOBGSawYMlb29pxw5p61ar0wAA4Pwo0gEgPVSvLk2ZYi4PHky1ApdRsKAUPxPqmDHWZgEAICugSAeA9NKjh9SxoxQXJ7VpI/39t9WJgEwxZIjk5SV98415AwAAaUeRDgDpxWaTZs6UKlSQzp83R3+PjLQ6FZDhChWSXnnFXA4NtTYLAADOjiIdANKTn5+0cqWUM6e0a5cUEmJ1IiBTDBliDsuwdau0fbvVaQAAcF4U6QCQ3ooVkz791FyeMUNatMjaPEAmKFLEnNxA4tp0AADuB0U6AGSEJk2kUaPM5e7dpf37LY0DZIahQ81ZCTdtkr77zuo0AAA4J4p0AMgoI0eaxfrNm9Lzz0v//Wd1IiBDBQdLnTqZy/SmAwCQNhTpAJBR3Nykjz+WihaVjh2TXnrJHPkdyMKGDZPc3aX1681hGQAAQOpQpANARsqd2xxIzsdHWrtWGjvW6kRAhipWTOrQwVymNx0AgNSjSAeAjFaxojR7trkcGiqtWWNpHCCjvfmmeSLJmjXSnj1WpwEAwLlQpANAZujYUerZUzIMqX176ehRqxMBGaZECbOZS5w8AgBAalGkA0BmmTxZql5dunTJHEju+nWrEwEZZvhwszd99Wpp3z6r0wAA4Dwo0gEgs3h5ScuWSfnyST/9dKtnHciCSpaUXnzRXObadAAAUo4iHQAyU6FC0tKlZhfjokXSrFlWJwIyzJtvSjab9MUX0v79VqcBAMA5UKQDQGarU0caP95cfv116fvvrc0DZJDSpaU2bcxlrk0HACBlKNIBwAr9+0utWknR0ebPs2etTgRkiOHDzd70lSulX36xOg0AAI6PIh0ArGCzSR99JJUqJZ06JbVtK8XEWJ0KSHePPGJ+DyXRmw4AQEpQpAOAVbJnN7sX/f2l8HBp6FCrEwEZYsQI8+fy5dJvv1mbBQAAR0eRDgBWKl1amj/fXJ440axigCymXDlz1kHDkN56y+o0AAA4Nop0ALBaq1bSwIHmcpcu0oED1uYBMkB8b/rSpTRxAADuhiIdABzBO+9ItWtLV6+aXY5XrlidCEhXFStKzz5r9qa//bbVaQAAcFwU6QDgCDw8zC7GBx6QDh40e9QNw+pUQLoaOdL8+dln0h9/WJsFAABHRZEOAI4if37zmnRPT2nFCmnSJKsTAenq0UelZs2kuDh60wEASA5FOgA4kurVpSlTzOXBg6WtW63NA6SzUaPMn59+Kv35p7VZAABwRBTpAOBoevSQOnY0uxvbtJH+/tvqREC6qVJFatJEio2lNx0AgKRQpAOAo7HZpFmzzJG2zp83R3+PjLQ6FZBu4q9N//hj6ehRa7MAAOBoKNIBwBH5+prXpefKJe3aJb3xhtWJgHRTrZrUsKHZm/7OO1anAQDAsVCkA4CjKlbMvHDXZpNmzpQWLrQ6EZBu4nvTFy6Ujh+3NAoAAA6FIh0AHFnjxrdG2urRQ9q/39I4QHqpWVOqV0+KiZHCwqxOAwCA46BIBwBHN2KEOdLWzZvS889L//1ndSIgXcR//zR/vnTypLVZAABwFBTpAODo3NykTz4xT38/dkx66SVz5HfAyT3xhFSnjhQdLY0bZ3UaAAAcA0U6ADiDXLnMgeR8fKS1a6UxY6xOBKSL+N70efOYbRAAAIkiHQCcR8WK0uzZ5nJoqPT115bGAdJDrVrSU09JUVHS+PFWpwEAwHoU6QDgTDp2lHr1MpdfeolJppElxPemz50r/fOPtVkAALAaRToAOJv335eqV5cuXTIHkrt+3epEwH2pU0d6/HEpMlKaMMHqNAAAWIsiHQCcjZeXtGyZlD+/9NNP5tRshmF1KiDNbLZbvemzZ0unT1ubBwAAK1GkA4AzKlRIWrpUcneXPv5YmjXL6kTAfalXT6pRw5xp8N13rU4DAIB1KNIBwFnVrn1r3qrXX5d27rQ0DnA/bDZp5EhzedYs6exZa/MAAGAVinQAcGb9+0utWpkTTbdqRWUDp9awofTYY9KNG9LEiVanAQDAGhTpAODMbDbpo4+kUqXMYbHbtpViYqxOBaTJ7b3pM2ZI589bmwcAACtQpAOAs8ueXfr8c8nfXwoPl4YOtToRkGZNmkhVqpiTFkyaZHUaAAAyH0U6AGQFpUpJCxaYyxMnSsuXWxoHSKvbe9OnTZMuXLA2DwAAmY0iHQCyipYtpYEDzeUuXaQDB6zNA6RRs2ZSpUrStWvS++9bnQYAgMxFkQ4AWck770h16khXr0rPPSdFRFidCEi123vTp06V/vvP2jwAAGQminQAyEo8PKQlS6QHHpAOHZJeflkyDKtTAan2zDNS+fLSlSvS5MlWpwEAIPNQpANAVpM/v3lNuqentGIFc1nBKbm53epNnzJFunjR2jwAAGQWinQAyIqqV5c++MBcHjJE2rLF2jxAGjz3nFS2rHnVRnxzBgAgq6NIB4Csqnt3qVMnKS7OnD/977+tTgSkipubNGKEuTx5snT5sqVxAADIFBTpAJBV2WzSzJlSxYrS+fNSq1ZSZKTVqYBUadVKKlNGunSJ3nQAgGugSAeArMzX17wuPVcuadcu6Y03rE4EpIqbmzR8uLn8/vtMWAAAyPoo0gEgqytWTPr001s96wsXWp0ISJUXXpAeftgcPG7aNKvTAACQsSjSAcAVNG4sjRplLvfoIf34o7V5gFRwd7/Vmz5pkjktGwAAWRVFOgC4ihEjpCZNpJs3pZYtpf/+szoRkGJt20oPPWQ22xkzrE4DAEDGoUgHAFfh5iZ98ol5+vuxY9JLL5kjvwNOwMPjVm/6xInS1avW5gEAIKNQpAOAK8mVyxxIzsdHWrtWCg2VDMPqVECKtGsnFS8uXbggzZpldRoAADKGh9UBAACZrGJFafZscw71MWPMm4eH5OkpeXkl/GnVupRu7+lpXrAMl+DhIb35pvTyy9K770q9ekl+flanAgAgfVGkA4Ar6thROnhQGj/ePOU9Jsa83bhhdbLUc3NzrC8Y7vWlg80mW3S01e+a03rpJWnsWPOKjdmzmVUQAJD1UKQDgKt65x1p6FCzMI+OlqKiEv5My7r02s/d1t15en5cnBQZad6cgKekZm5uUpUqUu3a5u3xx6WAAIuTOQdPT2nYMKlbN2nCBHOyAl9fq1MBAJB+KNIBwJVlz27enElsrPVfFKT1OTExkiS3uDhp927zNmGCeTZA5cpSrVrm7cknpRw5LH6jHVfHjtJbb0knTkhz5kivv251IgAA0g9FOgDAubi7m12nzth9Ghen6Bs3tPXTT1XXw0MeO3ZI4eHS0aPSnj3mbeJEs2ivWNHsZY8v2nPlsji84/DyMk8C6dHDvGKje3dzLEQAALICRncHACCzuLlJXl66ERgoo0MHad486cgR6eRJ6eOPpa5dzcnA4+Kkffuk996Tnn1WypNHqlRJ6tdP+vxz6d9/rX4lluvcWSpcWDp9WvrwQ6vTAACQfijSAQCwWuHC5ohoc+dKf/whnTolLV4svfqq9PDD5nX4+/dLU6ZIzz8v5c0rlS8v9e1rTql3/rzVryDTeXtLQ4aYy+PGOc2QBAAA3BNFOgAAjqZgQenFF83hyw8elP75R1qyROrZUypd2tzml1+kqVOlVq2k/PmlsmWl3r2lZcuks2etzZ9JXnlFeuAB8zuNjz6yOg0AAOmDIh0AAEdXoIDUpo00Y4b0++9mEb5smVmUly1rbvPbb+bjL7wgBQVJZcqYRf2SJeY54VnQ7b3pYWHmGH0AADg7inQAAJxN/vxmD/q0aWaP+vnz5mnvffuap8FL0oED0qxZZo98wYLmafPdu5un0Z86ZW3+dNS1q/kdxl9/SQsWWJ0GAID7R5EOAICzy5vXvFZ9yhTpp5+kCxfMAeb69TMHnLPZzGvd58yR2reXChUyB6jr2lX65BOzwnVSPj7S4MHm8jvv0JsOAHB+FOkAAGQ1efJILVpI779vjhL/77/Sl19KISHmfOxubtKff5qjy3foIBUpIhUrJr38srRwoXT8uNWvIFVefVUKDDTnTf/4Y6vTAABwfyjSAQDI6nLlkpo3lyZNkn74QfrvP+mrr6SBA6WqVc25548dk+bPN+c2K1pUCg6WOnUy1x09ao4w76B8faVBg8zlt9+WoqOtzQMAwP2gSAcAwNXkyCE1bSpNmCDt3i1dvCitXWueN169uuThYXZLL1pk9q4XL272tnfoYE5K/uefDle0d+8u5ctnftfw6adWpwEAIO0o0gEAcHXZs0uNGpkTju/caRbt69dLw4ZJNWtKnp7S33+b169362Zez16okHl9+5w50qFDlhft2bKZJwZI0ltvSTExlsYBACDNPKwOAAAAHIy/v9SggXmTpOvXzeI9PFz65htp1y5z7vbFi82bZE77VquWeatdWypVyhywLhP17GmeHHDkiBmrY8dMPTwAAOmCIh0AANydn5/09NPmTZJu3JC+//5W0f7999KZM9LSpeZNMqeJiy/aa9Uy5213y9gT+Pz9pf79paFDzd709u3Ny+0BAHAmFOkAACB1fH2lOnXMmyTdvGn2rn/zjXn77jvp3Dlp2TLzJpnTxD31lNnLXquWVLZshhTtvXtL774rHT4sLVliFuoAADgTinQAAHB/fHxu9ZhLUmSktGfPrZ72774z525fudK8SVLu3GbRHn96fPny6VK0Z89uzjQ3fLjZm962Lb3pAADnwsBxAAAgfXl7S088YVbKGzeaA9Ht2CG98455nXu2bOY0cKtWSW+8IVWqZM7t/swz0nvvSXv3SrGxaT78a6+Zs84dPHirIx8AAGdBkQ4AADKWl5c5SvzQoeao8RcvmgPRjRsnNW5sXkx+6ZK0erV5UXmVKmZPe7Nm5rnre/akarj2gACz9peksWOluLiMeVkAAGQEinQAAJC5PD3N+dgHD5bWrDGL9t27zYK8aVOzyo6IkL7+Who0SHrsMbNob9JEGj/eHKguOvquh3jtNXM6+N9/l1asyKTXBQBAOqBIBwAA1vLwkKpWlQYMkL76yjwV/ocfpEmTzFPgc+aUrlyR1q6VhgyRatQwz2dv2FAKCzOveY+KSrDLnDmlfv3M5TFj6E0HADgPBo4DAACOxd1dqlzZvIWEmNen//KLOQhdeLi0bZtZyG/YYN4kc5q4mjVvDURXtapef91b778v/fqrefn7889b+JoAAEghh+hJnz59uoKDg+Xj46Nq1app9+7dd91+2bJlKlWqlHx8fFSuXDmtWbMmk5ICAIBM5+4uVawovf669Pnn0vnz0k8/SR98YFbeefNK169LmzZJI0ZITz4p5cypXC3ramXFMXpK32jc6Jv0pgMAnILlPelLly5VSEiIZs2apWrVqmny5Mlq2LChDh06pPz58yfa/rvvvtOLL76osLAwNWvWTIsXL1aLFi20b98+lS1b1oJXAAAAMpWbmzllW/ny5sXncXHSgQO3pnwLDzcL+a1b9bS26mlJN3/xVkTJssoZ6G0W/Xfe3NySXp+Sx+/nuRm575Q+NwPmqwcApJ3NMAzDygDVqlVT1apVNW3aNElSXFycChcurNdee01DhgxJtH2bNm107do1ffXVV/Z11atXV8WKFTVr1qx7Hi8iIkI5cuTQ5cuXFRAQkH4vJANER0drzZo1atKkiTw9Pa2OA2QY2jpcCe09ExiGOf/a/xfsEV99o4BrZ6xO5dDi3Nxl3HaTm1uC+4luNrc7tr/98VuPxdncFHHlmrLnCJDN5ibZbDJsNkm29Fn+//u3L6f7MZJYls0mI7nlzD7evZadlRNmj42N1fHjxxVctKjc3N0tSmHx+2bh7+3Rt1vKw9dx/11NTR1qaU96VFSU9u7dq6FDh9rXubm5qV69etq5c2eSz9m5c6dCQkISrGvYsKFWrVqV5PaRkZGKjIy034+IiJBk/icp+h4jw1otPp+j5wTuF20droT2nklKlDBvr7yia+cN1SpxVIVv/CEPxchNcXJXbJK3uz12r8cdbb+3Hrv3ef5ucbFSXNrnpr+bwAzZK+CYqlsdwIVdfOM/+Qf5Wx0jWan5d9/SIv3ChQuKjY1VYGDCP9+BgYE6ePBgks85c+ZMktufOZP0N+RhYWEKDQ1NtH7Dhg3y8/NLY/LMtXHjRqsjAJmCtg5XQnvPXLW7F9KGDTVlGM7XO3ffDMNesLsZ/1/AG3FyU9xt981i3n5fcXIz7nyOuY0t0fo77stI8Bw3xckm88RNm2HI7OO9dZOMu6xX0uvT8px0OMat9Url9ob+v88/4fo7npN4ve5re6u46rEls407K6vfu/t16pst8shu+dXcybp+/XqKt3XcV5FOhg4dmqDnPSIiQoULF1aDBg2c4nT3jRs3qn79+pwSiSyNtg5XQnu3RpMm0oQJVqdwPbR3uBLau7UqWx3gHuLP6E4JS4v0vHnzyt3dXWfPnk2w/uzZswoKCkryOUFBQana3tvbW97e3onWe3p6Os2Hx5myAveDtg5XQnuHK6G9w5XQ3pGU1LQJS4fz9PLyUuXKlbV582b7uri4OG3evFk1atRI8jk1atRIsL1knjKY3PYAAAAAADgLy093DwkJUadOnVSlShU99thjmjx5sq5du6YuXbpIkjp27KgHHnhAYWFhkqTXX39dtWrV0qRJk9S0aVMtWbJEP/zwg+bMmWPlywAAAAAA4L5ZXqS3adNG58+f18iRI3XmzBlVrFhR69atsw8Od/LkSbndNn9nzZo1tXjxYg0fPlzDhg3TQw89pFWrVjFHOgAAAADA6VlepEtSnz591KdPnyQfCw8PT7SudevWat26dQanAgAAAAAgc1l6TToAAAAAALiFIh0AAAAAAAdBkQ4AAAAAgIOgSAcAAAAAwEFQpAMAAAAA4CAo0gEAAAAAcBAU6QAAAAAAOAiKdAAAAAAAHARFOgAAAAAADoIiHQAAAAAAB0GRDgAAAACAg6BIBwAAAADAQVCkAwAAAADgIDysDpDZDMOQJEVERFic5N6io6N1/fp1RUREyNPT0+o4QIahrcOV0N7hSmjvcCW0d9xNfP0ZX4/ejcsV6VeuXJEkFS5c2OIkAAAAAABXcuXKFeXIkeOu29iMlJTyWUhcXJz++ecfZc+eXTabzeo4dxUREaHChQvrr7/+UkBAgNVxgAxDW4crob3DldDe4Upo77gbwzB05coVFSxYUG5ud7/q3OV60t3c3FSoUCGrY6RKQEAAH3S4BNo6XAntHa6E9g5XQntHcu7Vgx6PgeMAAAAAAHAQFOkAAAAAADgIinQH5u3trVGjRsnb29vqKECGoq3DldDe4Upo73AltHekF5cbOA4AAAAAAEdFTzoAAAAAAA6CIh0AAAAAAAdBkQ4AAAAAgIOgSAcAAAAAwEFQpDuo6dOnKzg4WD4+PqpWrZp2795tdSQg3YWFhalq1arKnj278ufPrxYtWujQoUNWxwIyxbhx42Sz2dSvXz+rowAZ4tSpU3rppZeUJ08e+fr6qly5cvrhhx+sjgWku9jYWI0YMUJFixaVr6+vihcvrrFjx4rxuZFWFOkOaOnSpQoJCdGoUaO0b98+VahQQQ0bNtS5c+esjgakq2+++Ua9e/fW999/r40bNyo6OloNGjTQtWvXrI4GZKg9e/Zo9uzZKl++vNVRgAxx8eJFPf744/L09NTatWv1+++/a9KkScqVK5fV0YB0N378eM2cOVPTpk3TgQMHNH78eE2YMEFTp061OhqcFFOwOaBq1aqpatWqmjZtmiQpLi5OhQsX1muvvaYhQ4ZYnA7IOOfPn1f+/Pn1zTff6KmnnrI6DpAhrl69qkcffVQzZszQW2+9pYoVK2ry5MlWxwLS1ZAhQ7Rjxw5t377d6ihAhmvWrJkCAwM1b948+7qWLVvK19dXn3zyiYXJ4KzoSXcwUVFR2rt3r+rVq2df5+bmpnr16mnnzp0WJgMy3uXLlyVJuXPntjgJkHF69+6tpk2bJvg7D2Q1X375papUqaLWrVsrf/78qlSpkubOnWt1LCBD1KxZU5s3b9Yff/whSfrpp5/07bffqnHjxhYng7PysDoAErpw4YJiY2MVGBiYYH1gYKAOHjxoUSog48XFxalfv356/PHHVbZsWavjABliyZIl2rdvn/bs2WN1FCBDHT16VDNnzlRISIiGDRumPXv2qG/fvvLy8lKnTp2sjgekqyFDhigiIkKlSpWSu7u7YmNj9fbbb6t9+/ZWR4OTokgH/q+9+4+pqn78OP68Xrl25ZeFbECC4DAKECkJgzKx3GLTtlZLzLZCGKRAQ5mVLmmaKWqCiOKcsZQRajjnZMZCuWou+qGwrkHLH2Wmq5RJLZJfXu/l+8dn3MVH8wMG3qvf12PjD855n/d5HcY/r/s+51xxC9nZ2TQ3N/P555+7OorIkLhw4QK5ubkcPHiQe+65x9VxRIaUw+EgLi6OVatWAfDwww/T3NzMli1bVNLlrlNVVUVlZSU7duwgKioKq9XKggULCAoK0v+73BKVdDczevRojEYjly5d6rP90qVLBAQEuCiVyNDKyclh//79HD16lDFjxrg6jsiQaGxspKWlhUceecS5zW63c/ToUTZt2kR3dzdGo9GFCUUGT2BgIJGRkX22PfTQQ+zZs8dFiUSGzhtvvMHixYuZPXs2ABMmTODnn3+moKBAJV1uiZ5JdzMmk4lJkyZhsVic2xwOBxaLhYSEBBcmExl8PT095OTksHfvXg4dOkRYWJirI4kMmaeffpqmpiasVqvzJy4ujpdffhmr1aqCLneVxx9//Lqv1Dx9+jRjx451USKRodPR0cGwYX1rldFoxOFwuCiR3Om0ku6G8vLyePXVV4mLiyM+Pp7i4mLa29uZO3euq6OJDKrs7Gx27NjBvn378Pb25uLFiwD4+vpiNptdnE5kcHl7e1/3vgVPT0/8/Pz0Hga56yxcuJDExERWrVrFrFmzOHbsGFu3bmXr1q2ujiYy6J599llWrlxJSEgIUVFRfPPNNxQVFZGWlubqaHKH0lewualNmzbx/vvvc/HiRWJjYykpKWHy5MmujiUyqAwGww23b9u2jdTU1NsbRsQFkpKS9BVsctfav38/S5Ys4cyZM4SFhZGXl0dGRoarY4kMur/++ov8/Hz27t1LS0sLQUFBvPTSS7zzzjuYTCZXx5M7kEq6iIiIiIiIiJvQM+kiIiIiIiIibkIlXURERERERMRNqKSLiIiIiIiIuAmVdBERERERERE3oZIuIiIiIiIi4iZU0kVERERERETchEq6iIiIiIiIiJtQSRcRERERERFxEyrpIiIid6hz585hMBiwWq39Gp+amspzzz03pJnuFKGhoRQXF7s6hoiIyHVU0kVERAZRamoqBoMBg8GAyWQiPDycd999l2vXrv3ref+7YAcHB/Pbb78RHR3drzk2bNjA9u3b/1WOW7Fs2TJiY2P7Na73b2c0GgkODiYzM5Pff/996EOKiIi4ieGuDiAiInK3SU5OZtu2bXR3d1NTU0N2djYeHh4sWbJkwHPZ7XYMBsMN9xmNRgICAvo9l6+v74DPf7tFRUVRV1eH3W7n+++/Jy0tjT///JOPP/7Y1dFERERuC62ki4iIDLIRI0YQEBDA2LFjmT9/PtOnT6e6uhqAoqIiJkyYgKenJ8HBwWRlZXHlyhXnsdu3b2fUqFFUV1cTGRnJiBEjSEtLo7y8nH379jlXmo8cOXLD292/++47Zs6ciY+PD97e3kyZMoUff/wRuH41PikpiZycHHJycvD19WX06NHk5+fT09PjHFNRUUFcXBze3t4EBAQwZ84cWlpanPuPHDmCwWDAYrEQFxfHyJEjSUxM5NSpU87rWb58OSdOnHBmv9lq/vDhwwkICOD+++9n+vTpvPjiixw8eNC53263k56eTlhYGGazmYiICDZs2NBnjt7rXLduHYGBgfj5+ZGdnY3NZvvH85aVlTFq1CgsFss/jhEREbkdtJIuIiIyxMxmM62trQAMGzaMkpISwsLCOHv2LFlZWbz55pts3rzZOb6jo4M1a9ZQVlaGn58fgYGBdHZ20tbWxrZt2wC47777+PXXX/uc55dffuHJJ58kKSmJQ4cO4ePjQ319/U1vtS8vLyc9PZ1jx47R0NBAZmYmISEhZGRkAGCz2VixYgURERG0tLSQl5dHamoqNTU1feZ5++23KSwsxN/fn3nz5pGWlkZ9fT0pKSk0Nzfz6aefUldXB/R/Rf/cuXPU1tZiMpmc2xwOB2PGjGH37t34+fnxxRdfkJmZSWBgILNmzXKOO3z4MIGBgRw+fJgffviBlJQUYmNjndf1d2vXrmXt2rUcOHCA+Pj4fmUTEREZKirpIiIiQ6SnpweLxUJtbS2vv/46AAsWLHDuDw0N5b333mPevHl9SrrNZmPz5s1MnDjRuc1sNtPd3X3T29tLS0vx9fVl165deHh4APDAAw/cNGNwcDDr16/HYDAQERFBU1MT69evd5bZtLQ059hx48ZRUlLCo48+ypUrV/Dy8nLuW7lyJVOnTgVg8eLFzJgxg66uLsxmM15eXs4V8v+lqakJLy8v7HY7XV1dwH/uPujl4eHB8uXLnb+HhYXx5ZdfUlVV1aek33vvvWzatAmj0ciDDz7IjBkzsFgs15X0t956i4qKCj777DOioqL+Zz4REZGhppIuIiIyyPbv34+Xlxc2mw2Hw8GcOXNYtmwZAHV1dRQUFHDy5Ena2tq4du0aXV1ddHR0MHLkSABMJhMxMTEDPq/VamXKlCnOgt4fjz32WJ9n3hMSEigsLMRut2M0GmlsbGTZsmWcOHGCP/74A4fDAcD58+eJjIx0Hvf3vIGBgQC0tLQQEhIyoGuIiIigurqarq4uPvroI6xWq/MDjl6lpaV8+OGHnD9/ns7OTq5evXrdi+mioqIwGo19MjU1NfUZU1hYSHt7Ow0NDYwbN25AOUVERIaKnkkXEREZZNOmTcNqtXLmzBk6OzspLy/H09OTc+fOMXPmTGJiYtizZw+NjY2UlpYCcPXqVefxZrP5H18WdzNms3nQrgGgvb2dZ555Bh8fHyorKzl+/Dh79+4F+uYF+nww0Ju9t9APRO8b8aOjo1m9ejVGo7HPyvmuXbtYtGgR6enpHDhwAKvVyty5c2+apzfTf+eZMmUKdrudqqqqAecUEREZKlpJFxERGWSenp6Eh4dft72xsRGHw0FhYSHDhv3nc/L+FkSTyYTdbr/pmJiYGMrLy7HZbP1eTf/666/7/P7VV18xfvx4jEYjJ0+epLW1ldWrVxMcHAxAQ0NDv+YdaPZ/snTpUp566inmz59PUFAQ9fX1JCYmkpWV5RzT+2K8gYqPjycnJ4fk5GSGDx/OokWLbmkeERGRwaSVdBERkdskPDwcm83Gxo0bOXv2LBUVFWzZsqVfx4aGhvLtt99y6tQpLl++fMM3lefk5NDW1sbs2bNpaGjgzJkzVFRUON+0fiPnz58nLy+PU6dOsXPnTjZu3Ehubi4AISEhmEwmZ97q6mpWrFgx4OsODQ3lp59+wmq1cvnyZbq7u/t9bEJCAjExMaxatQqA8ePH09DQQG1tLadPnyY/P5/jx48POFOvxMREampqWL58OcXFxbc8j4iIyGBRSRcREblNJk6cSFFREWvWrCE6OprKykoKCgr6dWxGRgYRERHExcXh7+9PfX39dWP8/Pw4dOgQV65cYerUqUyaNIkPPvjgpqvqr7zyCp2dncTHx5OdnU1ubi6ZmZkA+Pv7s337dnbv3k1kZCSrV69m3bp1A77uF154geTkZKZNm4a/vz87d+4c0PELFy6krKyMCxcu8Nprr/H888+TkpLC5MmTaW1t7bOqfiueeOIJPvnkE5YuXcrGjRv/1VwiIiL/lqHn71+GKiIiIv9vJCUlERsbqxVkERERN6KVdBERERERERE3oZIuIiIiIiIi4iZ0u7uIiIiIiIiIm9BKuoiIiIiIiIibUEkXERERERERcRMq6SIiIiIiIiJuQiVdRERERERExE2opIuIiIiIiIi4CZV0ERERERERETehki4iIiIiIiLiJlTSRURERERERNzE/wEKZS753fQQVAAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import numpy as np\n", - "\n", - "# Function to calculate the \"lion's share\" distribution\n", - "def calculate_lions_share(convictions, sharpness=10):\n", - " # Normalize convictions\n", - " normalized_convictions = np.array(convictions) / np.max(convictions)\n", - " \n", - " # Apply exponential function to create a sharp drop-off\n", - " powered_convictions = np.exp(sharpness * (normalized_convictions - 1))\n", - " \n", - " # Calculate shares\n", - " total_powered = np.sum(powered_convictions)\n", - " shares = powered_convictions / total_powered\n", - " \n", - " return shares\n", - "\n", - "# Calculate convictions\n", - "convictions = [calculate_conviction(lock, duration, 0, interval) for lock in locks]\n", - "\n", - "# Calculate shares using the lion's share distribution\n", - "lions_shares = calculate_lions_share(convictions)\n", - "\n", - "# Print results\n", - "print(\"\\nLion's Share Distribution:\")\n", - "for i, (participant, lock, share) in enumerate(zip(participants, locks, lions_shares)):\n", - " print(f\"{participant}'s lock: {lock}, share: {share:.4f}\")\n", - "\n", - "# Calculate and print skew factors for lion's share\n", - "base_ratio = locks[0] / sum(locks)\n", - "print(\"\\nLion's Share Skew Factors:\")\n", - "for i, (participant, lock, share) in enumerate(zip(participants, locks, lions_shares)):\n", - " skew_factor = (share / base_ratio) / (lock / locks[0])\n", - " print(f\"{participant}'s skew factor: {skew_factor:.4f}\")\n", - "\n", - "# Visualize the difference between sigmoid and lion's share distributions\n", - "import matplotlib.pyplot as plt\n", - "\n", - "plt.figure(figsize=(12, 6))\n", - "plt.plot(range(N), sorted(shares, reverse=True), 'b-', label='Sigmoid Distribution')\n", - "plt.plot(range(N), sorted(lions_shares, reverse=True), 'r-', label=\"Lion's Share Distribution\")\n", - "plt.xlabel('Participant Rank')\n", - "plt.ylabel('Share')\n", - "plt.title('Comparison of Sigmoid and Lion\\'s Share Distributions')\n", - "plt.legend()\n", - "plt.grid(True)\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "770" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import math\n", - "\n", - "def calculate_conviction(lock_amount: int, end_day: int, current_day: int, interval: int) -> int:\n", - " lock_duration = max(end_day - current_day, 0)\n", - " time_factor = -lock_duration / interval \n", - " exp_term = 1 - math.exp(time_factor)\n", - " conviction_score = lock_amount * exp_term\n", - " return int(conviction_score)\n", - "\n", - "\n", - "lock = 1000\n", - "calculate_conviction(lock, 365, 100, 180)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -}