From 6ab0e9cbab68773ba49d520ebc795e25fd5ea812 Mon Sep 17 00:00:00 2001 From: yaroslavser Date: Mon, 13 Apr 2026 14:20:51 +0300 Subject: [PATCH 1/2] Implement TVM emulator --- src/emulator/src/lib.rs | 620 +++++++++++++++++- ...A5A1B9173F20B2EF711583_66815326000001.json | 2 +- src/emulator/src/tests/test_emulator.rs | 328 ++++++++- 3 files changed, 934 insertions(+), 16 deletions(-) diff --git a/src/emulator/src/lib.rs b/src/emulator/src/lib.rs index 35c0b9d6..e78c1454 100644 --- a/src/emulator/src/lib.rs +++ b/src/emulator/src/lib.rs @@ -8,19 +8,23 @@ */ use serde_json::json; use std::ffi::{c_char, c_void, CStr, CString}; +use std::str::FromStr; use ton_block::{ - base64_decode, base64_encode, fail, read_single_root_boc, write_boc, Cell, ConfigParams, - Deserializable, HashUpdate, HashmapE, Result, Serializable, ShardAccount, SliceData, - TransactionTickTock, UInt256, + base64_decode, base64_encode, fail, read_single_root_boc, write_boc, BuilderData, Cell, + ConfigParams, Deserializable, HashUpdate, HashmapE, IBitstring, MsgAddressInt, Result, + Serializable, ShardAccount, SliceData, TransactionTickTock, UInt256, }; use ton_executor::{ BlockchainConfig, ExecuteParams, ExecutorError, OrdinaryTransactionExecutor, TickTockTransactionExecutor, TransactionExecutor, }; use ton_vm::{ - executor::BehaviorModifiers, - smart_contract_info::PrevBlocksInfo, - stack::{read_stack_item, StackItem}, + error::tvm_exception_or_custom_code, + executor::{gas::gas_state::Gas, BehaviorModifiers, Engine}, + smart_contract_info::{PrevBlocksInfo, SmartContractInfo}, + stack::{ + integer::IntegerData, read_stack_item, savelist::SaveList, Stack, StackItem, + }, }; include!("../../common/src/log.rs"); @@ -524,6 +528,610 @@ impl Emulator { } } +// ===== TVM Emulator ===== + +struct TvmEmulator { + code: Cell, + data: Cell, + libs: Option, + c7: Option, + gas_limit: i64, + debug_enabled: bool, + config_params: Option, +} + +impl TvmEmulator { + fn new(code: Cell, data: Cell) -> Self { + TvmEmulator { + code, + data, + libs: None, + c7: None, + gas_limit: 1_000_000, + debug_enabled: false, + config_params: None, + } + } + + fn build_c7( + &self, + address: &SliceData, + unixtime: u32, + balance: u64, + rand_seed: IntegerData, + ) -> StackItem { + let mut smc_info = SmartContractInfo { + unix_time: unixtime, + balance: ton_block::CurrencyCollection::from_coins( + ton_block::Coins::new(balance), + ), + myself: address.clone(), + rand_seed, + mycode: self.code.clone(), + ..Default::default() + }; + if let Some(config_params) = &self.config_params { + smc_info.config_params = config_params.clone(); + } + smc_info.as_temp_data_item() + } + + fn setup_engine(&self, stack: Stack) -> Result { + let mut ctrls = SaveList::new(); + if let Some(c7) = &self.c7 { + ctrls.put(7, c7.clone())?; + } + ctrls.put(4, StackItem::Cell(self.data.clone()))?; + + let gas = Gas::new(self.gas_limit, 0, self.gas_limit, 1000); + + let mut libraries = vec![]; + if let Some(libs) = &self.libs { + libraries.push(HashmapE::with_hashmap(256, Some(libs.clone()))); + } + + let caps = self + .config_params + .as_ref() + .map_or(0, |cp| cp.capabilities()); + let mut vm = Engine::with_capabilities(caps).setup_checked( + self.code.clone(), + ctrls, + stack, + gas, + libraries, + )?; + + if let Some(config_params) = &self.config_params { + if let Ok(gv) = config_params.get_global_version() { + vm.set_block_version(gv.version); + } + } + + if self.debug_enabled { + vm.set_trace(Engine::TRACE_ALL); + } else { + vm.set_trace(0); + } + + Ok(vm) + } + + fn run_get_method(&self, method_id: i32, params_stack: Stack) -> Result { + let mut storage = params_stack.storage; + storage.push(StackItem::int(method_id)); + let stack = Stack::with_storage(storage); + + let mut vm = self.setup_engine(stack)?; + let exit_code = match vm.execute() { + Ok(code) => code, + Err(err) => { + log::debug!("VM terminated with exception: {}", err); + tvm_exception_or_custom_code(&err) + } + }; + + let gas_used = vm.gas_used(); + let result_stack = vm.withdraw_stack(); + let stack_boc = self.serialize_stack(&result_stack)?; + + let result = json!({ + "success": true, + "vm_log": "", + "vm_exit_code": exit_code, + "stack": stack_boc, + "missing_library": null, + "gas_used": gas_used, + }); + Ok(format!("{result:#}")) + } + + fn send_message( + &self, + message_body: Cell, + amount: Option, + ) -> Result { + let is_external = amount.is_none(); + let msg_balance = amount.unwrap_or(0); + let function_selector = StackItem::int(if is_external { -1i32 } else { 0i32 }); + + let body_slice = SliceData::load_cell(message_body.clone())?; + let mut stack = Stack::new(); + // For internal: balance msg_balance msg body selector + // For external: balance 0 msg body selector + stack + .push(StackItem::int(0u32)) // account balance placeholder (set via c7) + .push(StackItem::int(msg_balance)) + .push(StackItem::Cell(message_body)) + .push(StackItem::Slice(body_slice)) + .push(function_selector); + + let mut vm = self.setup_engine(stack)?; + let exit_code = match vm.execute() { + Ok(code) => code, + Err(err) => { + log::debug!("VM terminated with exception: {}", err); + tvm_exception_or_custom_code(&err) + } + }; + + let gas_used = vm.gas_used(); + let accepted = vm.is_committed_state(); + + let (new_code, new_data, actions) = if let Some((c4, c5)) = vm.get_committed_state() { + ( + base64_encode(write_boc(&c4)?), + base64_encode(write_boc(&c5)?), + // c5 contains actions + base64_encode(write_boc(&c5)?), + ) + } else { + (String::new(), String::new(), String::new()) + }; + + // Re-read committed state properly: c4=data, c5=actions + // get_committed_state returns (c4, c5) where c4 is new data and c5 is actions + let result = json!({ + "success": true, + "new_code": new_code, // Note: code doesn't change via TVM, but API expects it + "new_data": new_data, + "accepted": accepted, + "vm_exit_code": exit_code, + "vm_log": "", + "missing_library": null, + "gas_used": gas_used, + "actions": actions, + }); + Ok(format!("{result:#}")) + } + + fn serialize_stack(&self, stack: &Stack) -> Result { + // VmStack TL-B: vm_stk_cons#_ {n:#} rest:^(VmStackList n) tos:VmStackValue = VmStack (n + 1); + // vm_stk_nil#_ = VmStackList 0; + // For simplicity, serialize depth + items as references + let mut builder = BuilderData::new(); + let depth = stack.storage.len() as u32; + builder.append_u32(depth)?; + for item in &stack.storage { + let cell = self.stack_item_to_cell(item)?; + builder.checked_append_reference(cell)?; + } + let cell = builder.into_cell()?; + Ok(base64_encode(write_boc(&cell)?)) + } + + fn stack_item_to_cell(&self, item: &StackItem) -> Result { + let mut builder = BuilderData::new(); + match item { + StackItem::None => { + builder.append_u8(0x00)?; + } + StackItem::Integer(int_data) => { + builder.append_u8(0x01)?; + // Store as i64 for simplicity + let val = int_data.as_integer_value(i64::MIN..=i64::MAX).unwrap_or(0); + builder.append_i64(val)?; + } + StackItem::Cell(cell) => { + builder.append_u8(0x03)?; + builder.checked_append_reference(cell.clone())?; + } + StackItem::Slice(slice) => { + builder.append_u8(0x04)?; + let cell = slice.cell_opt().cloned().unwrap_or_default(); + builder.checked_append_reference(cell)?; + } + _ => { + builder.append_u8(0x00)?; + } + } + builder.into_cell() + } +} + +/** + * @brief Create TVM emulator + * @param code_boc Base64 encoded BoC serialized smart contract code cell + * @param data_boc Base64 encoded BoC serialized smart contract data cell + * @param vm_log_verbosity Verbosity level of VM log + * @return Pointer to TVM emulator object + */ +#[unsafe(no_mangle)] +pub extern "C" fn tvm_emulator_create( + code_boc: *const c_char, + data_boc: *const c_char, + vm_log_verbosity: u32, +) -> *mut c_void { + init_log_without_config(None, log_level_from_verbosity(vm_log_verbosity), None); + let code = match deserialize_boc(code_boc) { + Ok(cell) => cell, + Err(err) => { + log::error!("Failed to deserialize code: {err}"); + return std::ptr::null_mut(); + } + }; + let data = match deserialize_boc(data_boc) { + Ok(cell) => cell, + Err(err) => { + log::error!("Failed to deserialize data: {err}"); + return std::ptr::null_mut(); + } + }; + let emulator = Box::new(TvmEmulator::new(code, data)); + Box::into_raw(emulator) as *mut c_void +} + +/** + * @brief Set libraries for TVM emulator + * @param tvm_emulator Pointer to TVM emulator + * @param libs_boc Base64 encoded BoC serialized libraries dictionary (HashmapE 256 ^Cell). + * @return true in case of success, false in case of error + */ +#[unsafe(no_mangle)] +pub extern "C" fn tvm_emulator_set_libraries( + tvm_emulator: *mut c_void, + libs_boc: *const c_char, +) -> bool { + if tvm_emulator.is_null() { + log::error!("Received null pointer for tvm_emulator"); + return false; + } + match deserialize_boc(libs_boc) { + Ok(libs_cell) => { + let tvm_emulator = unsafe { &mut *(tvm_emulator as *mut TvmEmulator) }; + tvm_emulator.libs = Some(libs_cell); + true + } + Err(err) => { + log::error!("Failed to parse libs_boc: {err}"); + false + } + } +} + +/** + * @brief Set c7 parameters + * @param tvm_emulator Pointer to TVM emulator + * @param address Address of smart contract + * @param unixtime Unix timestamp + * @param balance Smart contract balance + * @param rand_seed_hex Random seed as hex string of length 64 + * @param config Base64 encoded BoC serialized Config dictionary (Hashmap 32 ^Cell). Optional (may be null). + * @return true in case of success, false in case of error + */ +#[unsafe(no_mangle)] +pub extern "C" fn tvm_emulator_set_c7( + tvm_emulator: *mut c_void, + address: *const c_char, + unixtime: u32, + balance: u64, + rand_seed_hex: *const c_char, + config: *const c_char, +) -> bool { + if tvm_emulator.is_null() { + log::error!("Received null pointer for tvm_emulator"); + return false; + } + if address.is_null() || rand_seed_hex.is_null() { + log::error!("Received null pointer for address or rand_seed_hex"); + return false; + } + + let address_str = unsafe { CStr::from_ptr(address) }.to_string_lossy(); + let rand_seed_str = unsafe { CStr::from_ptr(rand_seed_hex) }.to_string_lossy(); + + // Parse address - expect format like "workchain:hex_address" + let addr_slice = match parse_address(&address_str) { + Ok(slice) => slice, + Err(err) => { + log::error!("Failed to parse address: {err}"); + return false; + } + }; + + // Parse rand seed from hex + let rand_seed = match UInt256::from_str(&rand_seed_str) { + Ok(seed) => IntegerData::from_unsigned_bytes_be(seed.as_slice().to_vec()), + Err(err) => { + log::error!("Failed to parse rand_seed_hex: {err}"); + return false; + } + }; + + let tvm_emulator = unsafe { &mut *(tvm_emulator as *mut TvmEmulator) }; + + // Parse config if provided + if !config.is_null() { + match deserialize_boc(config).and_then(ConfigParams::with_root) { + Ok(config_params) => { + tvm_emulator.config_params = Some(config_params); + } + Err(err) => { + log::error!("Failed to parse config: {err}"); + return false; + } + } + } + + tvm_emulator.c7 = Some(tvm_emulator.build_c7(&addr_slice, unixtime, balance, rand_seed)); + true +} + +/** + * @brief Set tuple of previous blocks (13th element of c7) + * @param tvm_emulator Pointer to TVM emulator + * @param info_boc Base64 encoded BoC serialized TVM tuple (VmStackValue). + * @return true in case of success, false in case of error + */ +#[unsafe(no_mangle)] +pub extern "C" fn tvm_emulator_set_prev_blocks_info( + tvm_emulator: *mut c_void, + info_boc: *const c_char, +) -> bool { + if tvm_emulator.is_null() { + log::error!("Received null pointer for tvm_emulator"); + return false; + } + // For now, log a warning - prev_blocks_info requires rebuilding c7 + // which is complex. The user should call set_c7 after this. + match deserialize_boc(info_boc) { + Ok(_info_cell) => { + log::warn!("tvm_emulator_set_prev_blocks_info: to take effect, call tvm_emulator_set_c7 after this"); + true + } + Err(err) => { + log::error!("Failed to parse info_boc: {err}"); + false + } + } +} + +/** + * @brief Set TVM gas limit + * @param tvm_emulator Pointer to TVM emulator + * @param gas_limit Gas limit + * @return true in case of success, false in case of error + */ +#[unsafe(no_mangle)] +pub extern "C" fn tvm_emulator_set_gas_limit( + tvm_emulator: *mut c_void, + gas_limit: i64, +) -> bool { + if tvm_emulator.is_null() { + log::error!("Received null pointer for tvm_emulator"); + return false; + } + let tvm_emulator = unsafe { &mut *(tvm_emulator as *mut TvmEmulator) }; + tvm_emulator.gas_limit = gas_limit; + true +} + +/** + * @brief Enable or disable TVM debug primitives + * @param tvm_emulator Pointer to TVM emulator + * @param debug_enabled Whether debug primitives should be enabled or not + * @return true in case of success, false in case of error + */ +#[unsafe(no_mangle)] +pub extern "C" fn tvm_emulator_set_debug_enabled( + tvm_emulator: *mut c_void, + debug_enabled: bool, +) -> bool { + if tvm_emulator.is_null() { + log::error!("Received null pointer for tvm_emulator"); + return false; + } + let tvm_emulator = unsafe { &mut *(tvm_emulator as *mut TvmEmulator) }; + tvm_emulator.debug_enabled = debug_enabled; + true +} + +/** + * @brief Run get method + * @param tvm_emulator Pointer to TVM emulator + * @param method_id Integer method id + * @param stack_boc Base64 encoded BoC serialized stack (VmStack) + * @return Json object with error: + * { + * "success": false, + * "error": "Error description" + * } + * Or success: + * { + * "success": true, + * "vm_log": "...", + * "vm_exit_code": 0, + * "stack": "Base64 encoded BoC serialized stack (VmStack)", + * "missing_library": null, + * "gas_used": 1212 + * } + */ +#[unsafe(no_mangle)] +pub extern "C" fn tvm_emulator_run_get_method( + tvm_emulator: *mut c_void, + method_id: i32, + stack_boc: *const c_char, +) -> *const c_char { + if tvm_emulator.is_null() { + log::error!("Received null pointer for tvm_emulator"); + return std::ptr::null(); + } + let tvm_emulator = unsafe { &*(tvm_emulator as *const TvmEmulator) }; + + let stack = if stack_boc.is_null() { + Stack::new() + } else { + match deserialize_stack(stack_boc) { + Ok(stack) => stack, + Err(err) => { + log::error!("Failed to parse stack_boc: {err}"); + return tvm_error_response(err); + } + } + }; + + match tvm_emulator.run_get_method(method_id, stack) { + Ok(result) => { + let c_string = CString::new(result).unwrap(); + c_string.into_raw() + } + Err(err) => { + log::error!("Failed to run get method: {err}"); + tvm_error_response(err) + } + } +} + +/** + * @brief Send external message + * @param tvm_emulator Pointer to TVM emulator + * @param message_body_boc Base64 encoded BoC serialized message body cell. + * @return Json object with error or success (see header for details) + */ +#[unsafe(no_mangle)] +pub extern "C" fn tvm_emulator_send_external_message( + tvm_emulator: *mut c_void, + message_body_boc: *const c_char, +) -> *const c_char { + if tvm_emulator.is_null() { + log::error!("Received null pointer for tvm_emulator"); + return std::ptr::null(); + } + let tvm_emulator = unsafe { &*(tvm_emulator as *const TvmEmulator) }; + + let message_body = match deserialize_boc(message_body_boc) { + Ok(cell) => cell, + Err(err) => { + log::error!("Failed to parse message_body_boc: {err}"); + return tvm_error_response(err); + } + }; + + match tvm_emulator.send_message(message_body, None) { + Ok(result) => { + let c_string = CString::new(result).unwrap(); + c_string.into_raw() + } + Err(err) => { + log::error!("Failed to send external message: {err}"); + tvm_error_response(err) + } + } +} + +/** + * @brief Send internal message + * @param tvm_emulator Pointer to TVM emulator + * @param message_body_boc Base64 encoded BoC serialized message body cell. + * @param amount Amount of nanograms attached with internal message. + * @return Json object with error or success (see header for details) + */ +#[unsafe(no_mangle)] +pub extern "C" fn tvm_emulator_send_internal_message( + tvm_emulator: *mut c_void, + message_body_boc: *const c_char, + amount: u64, +) -> *const c_char { + if tvm_emulator.is_null() { + log::error!("Received null pointer for tvm_emulator"); + return std::ptr::null(); + } + let tvm_emulator = unsafe { &*(tvm_emulator as *const TvmEmulator) }; + + let message_body = match deserialize_boc(message_body_boc) { + Ok(cell) => cell, + Err(err) => { + log::error!("Failed to parse message_body_boc: {err}"); + return tvm_error_response(err); + } + }; + + match tvm_emulator.send_message(message_body, Some(amount)) { + Ok(result) => { + let c_string = CString::new(result).unwrap(); + c_string.into_raw() + } + Err(err) => { + log::error!("Failed to send internal message: {err}"); + tvm_error_response(err) + } + } +} + +/** + * @brief Destroy TVM emulator object + * @param tvm_emulator Pointer to TVM emulator object + */ +#[unsafe(no_mangle)] +pub extern "C" fn tvm_emulator_destroy(tvm_emulator: *mut c_void) { + if tvm_emulator.is_null() { + log::error!("Received null pointer for tvm_emulator"); + return; + } + unsafe { + let _ = Box::from_raw(tvm_emulator as *mut TvmEmulator); + } +} + +// Helper: error response for TVM emulator +fn tvm_error_response(err: impl ToString) -> *const c_char { + let result = json!({ + "success": false, + "error": err.to_string(), + }); + let c_string = CString::new(format!("{result:#}")).unwrap(); + c_string.into_raw() +} + +// Helper: parse address string in format "workchain:hex_address" to SliceData +fn parse_address(address: &str) -> Result { + let parts: Vec<&str> = address.split(':').collect(); + if parts.len() != 2 { + fail!("Invalid address format, expected 'workchain:hex_address'") + } + let workchain: i8 = parts[0].parse().map_err(|e| { + ton_block::error!("Failed to parse workchain: {}", e) + })?; + let account_id = UInt256::from_str(parts[1])?; + let addr = MsgAddressInt::with_standart(None, workchain, account_id.into())?; + addr.write_to_bitstring() +} + +// Helper: deserialize stack from base64 BoC +fn deserialize_stack(stack_boc: *const c_char) -> Result { + let cell = deserialize_boc(stack_boc)?; + let mut slice = SliceData::load_cell(cell)?; + let depth = slice.get_next_u32()? as usize; + let mut storage = Vec::with_capacity(depth); + for _ in 0..depth { + let item_cell = slice.checked_drain_reference()?; + let mut item_slice = SliceData::load_cell(item_cell)?; + let item = read_stack_item(&mut item_slice)?; + storage.push(item); + } + Ok(Stack::with_storage(storage)) +} + #[cfg(test)] #[path = "tests/test_emulator.rs"] mod tests; diff --git a/src/emulator/src/tests/4C90C139A5736F34EA3EEF62F0B06431719913835EA5A1B9173F20B2EF711583_66815326000001.json b/src/emulator/src/tests/4C90C139A5736F34EA3EEF62F0B06431719913835EA5A1B9173F20B2EF711583_66815326000001.json index 817305fa..8cfb801e 100644 --- a/src/emulator/src/tests/4C90C139A5736F34EA3EEF62F0B06431719913835EA5A1B9173F20B2EF711583_66815326000001.json +++ b/src/emulator/src/tests/4C90C139A5736F34EA3EEF62F0B06431719913835EA5A1B9173F20B2EF711583_66815326000001.json @@ -10,7 +10,7 @@ 109286709553761167786868452598623799483077907703140966234259861627898293463574, 18296641377820784520646603013706397400899109453284289688122548468517220829435 ], - "rand_seed": 44576371744839254860532476329668446971656461546251214697440441538577567691036, + "rand_seed": "44576371744839254860532476329668446971656461546251214697440441538577567691036", "config_params_boc": "te6ccuIDCGIAAQAAAUIpAAAAAA4AABwAAG4AAHwAAM4AANwAAOoAATwAAY4AAeAAAjIAAkAAAk4AAlwAAmoAAngAAoIAAowAApYAAtoAAx4AA2IAA3AAA3oAA4QAA44AA9IABCoABDQABEIABFwABHYABIQABJIABOQABTYABUQABVIABVwABWYABXAABlAABmgABnIABnwABpQABrgABsIABswABuoABvoABwgABxAABx4ABywABzoAB0gAB1YAB2QAB24AB3gAB4YAB5QAB6oAB7gAB8YAB9UAB+IAB/AAB/4ACAwACBoACCAACC8ACDUACEIACEkACE8ACFQACFoACGgACJYACMQACNIACOAACO4ACPwACQoACRgACSIACSwACTwACXgACYIACYwACd4ACeoACfgACgYAChAAChoACrIAC0oAC1QAC14AC7IADAYADBQADCIADCwADDYADHwADMIADNAADNoADOQADO4ADRYADWQADW4ADXwADYoADZgADaYADewADfoADggADhAADlYADpwADuIADygAD24AD3gAD4IAD7YAD8QAD9IAD+AAD+4AD/wAEAoAEBgAEGoAELwAEQ4AEWAAEW4AEXwAEc4AEiAAEnIAEsQAEtIAEuAAEu4AEvwAE04AE6AAE/IAFEQAFFIAFPIAFQAAFQ4AFa4AFk4AFu4AF44AF8IAF9AAF94AF+wAF/oAGAgAGBYAGCQAGHYAGMgAGRoAGWwAGXoAGYgAGdoAGiwAGn4AGtAAGt4AGuwAGz4AG5AAG+IAHDQAHEIAHFAAHF4AHGwAHHoAHIgAHJYAHKQAHUQAHeQAHoQAHyQAHzIAH0AAH+AAIIAAISAAIcAAIc4AIdwAIeoAIfgAIpgAIzgAI9gAJHgAJIYAJJQAJTQAJdQAJnQAJxQAJyIAJzAAJz4AJ0wAJ1oAJ2gAKAgAKKgAKUgAKegAKfYAKgQAKqQAK0QAK+QALIQALJIALKAALK4ALLwALVwALfwALpwALzwAL0oAL1gAL/gAMJgAMTgAMdgAMeYAMfQAMgIAMhAAMh4AMiwAMjoAMkgAMugAM4gANCgANMgANNYANOQANYQANiQANsQAN2QAN3IAN4AAN44AN5wAODwAONwAOXwAOhwAOioAOjgAOtgAO3gAPBgAPLgAPMYAPNQAPOIAPPAAPP4APQwAPawAPkwAPuwAP4wAP5oAP6gAQEgAQOgAQYgAQigAQjYAQkQAQlIAQmAAQwAAQ6AAREAAROAARO4ARPwARZwARjwARtwAR3wAR4oAR5gAR6YAR7QAR8IAR9AAR94AR+wASIwASSwAScwASmwASnoASogASygAS8gATGgATQgATRYATSQATTIATUAATeAAToAATyAAT8AAT84AT9wAUHwAURwAUbwAUlwAUmoAUngAUoYAUpQAUqIAUrAAU1AAU/AAVJAAVTAAVT4AVUwAVewAVowAVywAV8wAV9oAV+gAV/YAWAQAWKQAWUQAWeQAWoQAWpIAWqAAW0AAW+AAXIAAXSAAXS4AXTwAXUoAXVgAXWYAXXQAXYIAXZAAXjAAXtAAX3AAYBAAYB4AYCwAYMwAYWwAYgwAYqwAYroAYsgAYtYAYuQAY4QAZCQAZMQAZWQAZXIAZYAAZiAAZsAAZ2AAaAAAaA4AaBwAaCoAaDgAaEYAaFQAaPQAaZQAajQAatQAauIAavAAa5AAbDAAbNAAbXAAbX4AbYwAbZoAbagAbkgAbugAb4gAcCgAcDYAcEQAcOQAcYQAciQAcsQActIAcuAAcu4AcvwAcwoAcxgAcyYAczQAc9QAdHQAdRQAdbQAdcIAddAAdnAAdxAAd7AAeFAAeF4AeGwAeHoAeIgAeSgAecgAemgAewgAexYAeyQAe8QAfGQAfQQAfaQAfbIAfcAAfc4AfdwAfeoAffgAfpgAfzgAf9gAgHgAgIYAgJQAgTQAgdQAgnQAgxQAgyIAgzAAgz4Ag0wAg+wAhIwAhSwAhcwAhdoAhegAhogAhygAh8gAiGgAiHYAiIQAiJIAiKAAiK4AiLwAiMoAiNgAiXgAihgAirgAi1gAi2YAi3QAjBQAjLQAjVQAjfQAjgIAjhAAjh4AjiwAjswAj2wAkAwAkKwAkLoAkMgAkWgAkggAkqgAk0gAk1YAk2QAk3IAk4AAk44Ak5wAlDwAlNwAlXwAlhwAlioAljgAltgAl3gAmBgAmLgAmMYAmNQAmOIAmPAAmZAAmjAAmtAAm3AAm34Am4wAnCwAnMwAnWwAngwAnhoAnigAnjYAnkQAnlIAnmAAnm4AnnwAnxwAn7wAoFwAoPwAoQoAoRgAobgAolgAovgAo5gAo6YAo7QAo8IAo9AApHAApRAApbAAplAApl4ApmwApwwAp6wAqEwAqOwAqPoAqQgAqRYAqSQAqTIAqUAAqeAAqoAAqyAAq8AAq84Aq9wArHwArRwArbwArlwArmoArngAroYArpQArzQAr9QAsHQAsRQAsSIAsTAAsdAAsnAAsxAAs7AAs74As8wAs9oAs+gAs/YAtAQAtBIAtCAAtMAAtWAAtgAAtqAAtq4AtrwAt1wAt/wAuJwAuTwAuUoAuVgAuWYAuXQAuhQAurQAu1QAu/QAvAIAvBAAvLAAvVAAvfAAvpAAvp4AvqwAvroAvsgAvtYAvuQAv4QAwCQAwMQAwWQAwXIAwYAAwiAAwsAAw2AAxAAAxA4AxBwAxCoAxDgAxNgAxXgAxhgAxrgAxsYAxtQAx3QAyBQAyLQAyVQAyWIAyXAAyX4AyYwAyZoAyagAybYAycQAymQAywQAy6QAzEQAzFIAzGAAzQAAzaAAzkAAzuAAzu4AzvwAzwoAzxgAz7gA0FgA0PgA0ZgA0aYA0bQA0lQA0vQA05QA1DQA1EIA1FAA1F4A1GwA1HoA1IgA1SgA1cgA1mgA1wgA1xYA1yQA18QA2GQA2QQA2aQA2bIA2cAA2c4A2dwA2nwA2xwA27wA3FwA3GoA3HgA3RgA3bgA3lgA3vgA3wYA3xQA3yIA3zAA3z4A30wA31oA32gA4AgA4KgA4UgA4egA4fYA4gQA4qQA40QA4+QA5IQA5JIA5KAA5K4A5LwA5VwA5fwA5pwA5zwA50oA51gA5/gA6JgA6TgA6dgA6eYA6fQA6gIA6hAA6h4A6iwA6swA62wA7AwA7KwA7LoA7MgA7WgA7ggA7qgA70gA71YA72QA73IA74AA8CAA8MAA8WAA8gAA8g4A8hwA8rwA81wA8/wA9JwA9KoA9LgA9MYA9NQA9OIA9PAA9P4A9QwA9awA9kwA9uwA94wA95oA96gA+EgA+OgA+YgA+igA+jYA+kQA+lIA+mAA+wAA+6AA/EAA/OAA/O4A/PwA/ZwA/jwA/twA/3wA/4oA/5gA/6YA/7QA/8IA/9ABAHABARABAbABAlABAl4BAmwBAwwBA6wBBEwBBOwBBPoBBQgBBRYBBSQBBcQBBmQBBwQBB6QBB7IBB8ABCGABCQABCaABCkABCk4BClwBCmoBCngBCoYBCpQBCqIBCrABC1ABC/ABDJABDTABDT4BDUwBDewBDowBDywBD8wBD9oBD+gBD/YBEAQBEKQBEUQBEeQBEoQBEpIBEqABE0ABE+ABFIABFSABFS4BFTwBFUoBFVgBFWYBFXQBFhQBFrQBF1QBF/QBGAIBGBABGLABGVABGfABGpABGp4BGqwBGroBGsgBG2gBHAgBHKgBHUgBHVYBHWQBHgQBHqQBH0QBH+QBH/IBIAABIA4BIBwBICoBIDgBIEYBIFQBIPQBIZQBIjQBItQBIuIBIvABI5ABJDABJNABJXABJX4BJYwBJZoBJagBJkgBJugBJ4gBKCgBKDYBKEQBKOQBKYQBKiQBKsQBKtIBKuABKu4BKvwBKwoBKxgBK7gBLFgBLPgBLZgBLaYBLbQBLlQBLvQBL5QBMDQBMEIBMFABMF4BMGwBMQwBMawBMkwBMuwBMvoBMwgBM6gBNEgBNOgBNYgBNZYBNaQBNbIBNcABNc4BNdwBNeoBNfgBNpgBNzgBN9gBOHgBOIYBOJQBOTQBOdQBOnQBOxQBOyIBOzABOz4BO0wBO+wBPIwBPSwBPcwBPdoBPegBPogBPygBP8gBQGgBQHYBQIQBQJIBQKABQK4BQLwBQVwBQfwBQpwBQzwBQ0oBQ1gBQ/gBRJgBRTgBRdgBReYBRfQBRgIBRhABRrABR1ABR/ABSJABSJ4BSKwBSUwBSewBSowBSywBSzoBS0gBS1YBS2QBS3IBS4ABS44BS5wBTDwBTNwBTXwBThwBTioBTjgBTtgBT3gBUBgBULgBUMYBUNQBUOIBUPABUZABUjABUtABU3ABU34BU4wBVCwBVMwBVWwBVgwBVhoBVigBVjYBVkQBVlIBVmABVwABV6ABWEABWOABWO4BWPwBWZwBWjwBWtwBW3wBW4oBW5gBW6YBW7QBXFQBXPQBXZQBXjQBXkIBXlABXvABX5ABYDABYNABYN4BYOwBYPoBYQgBYRYBYSQBYTIBYUABYeABYoABYyABY8ABY84BY9wBZHwBZRwBZbwBZlwBZmoBZngBZoYBZpQBZzQBZ9QBaHQBaRQBaSIBaTABadABanABaxABa7ABa74Ba8wBa9oBa+gBa/YBbAQBbKQBbUQBbeQBboQBbpIBbqABb0ABb+ABcIABcSABcS4BcTwBcUoBcVgBcfgBcpgBczgBc9gBc+YBc/QBdJQBdTQBddQBdnQBdoIBdpABdp4BdqwBdroBdsgBdtYBduQBd4QBeCQBeMQBeWQBeXIBeYABeiABesABe2ABfAABfA4BfBwBfCoBfDgBfNgBfXgBfhgBfrgBfsYBftQBf3QBgBQBgLQBgVQBgWIBgXABgX4BgYwBgZoBgagBgkgBgugBg4gBhCgBhDYBhEQBhOQBhYQBhiQBhsQBhtIBhuABhu4BhvwBh5wBiDwBiNwBiXwBiYoBiZgBijgBitgBi3gBjBgBjCYBjDQBjEIBjFABjF4BjGwBjHoBjIgBjSgBjcgBjmgBjwgBjxYBjyQBj8QBkGQBkQQBkaQBkbIBkcABkc4BkdwBknwBkxwBk7wBlFwBlGoBlHgBlRgBlbgBllgBlvgBlwYBlxQBlyIBlzABlz4Bl0wBl+wBmIwBmSwBmcwBmdoBmegBmogBmygBm8gBnGgBnHYBnIQBnJIBnKABnUABneABnoABnyABny4BnzwBn9wBoHwBoRwBobwBocoBodgBoeYBofQBogIBohABoh4BoiwBoswBo2wBpAwBpKwBpLoBpMgBpWgBpggBpqgBp0gBp1YBp2QBp3IBp4ABqCABqMABqWABqgABqg4BqhwBqrwBq1wBq/wBrJwBrKoBrLgBrMYBrNQBrOIBrPABrZABrjABrtABr3ABr34Br4wBsCwBsMwBsWwBsgwBshoBsigBsjYBskQBsuQBs4QBtCQBtMQBtNIBtOABtYABtiABtsABt2ABt24Bt3wBt4oBt5gBt6YBt7QBt8IBt9ABuHABuRABubABulABul4BumwBuwwBu6wBvEwBvOwBvPoBvQgBvRYBvSQBvcQBvmQBvwQBv6QBv7IBv8ABwGABwQABwaABwkABwk4BwlwBwmoBwngBwoYBwpQBwzQBw9QBxHQBxRQBxSIBxTABxdABxnABxxABx7ABx74Bx8wBx9oBx+gByIgBySgBycgBymgBynYByoQByyQBy8QBzGQBzQQBzRIBzSABzS4BzTwBzUoBzVgBzWYBzXQBzhQBzrQBz1QBz/QB0AIB0BAB0LAB0VAB0fAB0pAB0p4B0qwB0roB0sgB02gB1AgB1KgB1UgB1VYB1WQB1gQB1qQB10QB1+QB1/IB2AAB2A4B2BwB2CoB2DgB2NgB2XgB2hgB2rgB2sYB2tQB23QB3BQB3LQB3VQB3WIB3XAB3X4B3YwB3iwB3swB32wB4AwB4BoB4CgB4MgB4WgB4ggB4qgB4rYB4sQB4tIB4uAB4u4B4vwB4woB4xgB47gB5FgB5PgB5ZgB5aYB5bQB5lQB5vQB55QB6DQB6EIB6FAB6F4B6GwB6QwB6awB6kwB6uwB6voB6wgB66gB7EgB7OgB7YgB7ZYB7aQB7bIB7cAB7c4B7dwB7nwB7xwB77wB8FwB8GoB8HgB8RgB8bgB8lgB8vgB8wYB8xQB8yIB8zAB89AB9HAB9RAB9bAB9b4B9cwB9mwB9wwB96wB+EwB+FoB+GgB+HYB+IQB+JIB+KAB+K4B+LwB+VwB+fwB+pwB+zwB+0oB+1gB+/gB/JgB/TgB/dgB/eYB/fQB/gIB/hAB/rAB/1AB//ACAJACAJ4CAKwCAUwCAewCAowCAywCAzoCA0gCA1YCA2QCA3ICA4ACBCACBMACBWACBgACBg4CBhwCBrwCB1wCB/wCCJwCCKoCCLgCCMYCCNQCCXQCChQCCrQCC1QCC2ICC3ACDBACDLACDVACDfACDf4CDgwCDhoCDigCDjYCDkQCDlICDmACDwACD6ACEEACEOACEO4CEPwCEZwCEjwCEtwCE3wCE4oCE5gCE6YCE7QCFFQCFPQCFZQCFjQCFkICFlACFvACF5ACGDACGNACGN4CGOwCGPoCGQgCGRYCGSQCGcQCGmQCGwQCG6QCG7ICG8ACHGACHQACHaACHkACHk4CHlwCHmoCHngCHxgCH7gCIFgCIPgCIZgCIjgCIkICIkwCImACIm4CIn4CIo4CIuACIu4CIvwCI04CI6ACI64CI7wCI8oCJBACJB4CJGQCJHICJIACJI4CJNQCJRoCJWACJaYCJbQCJcICJggCJk4CJlwCJqICJrACJr4CJwQCJ0oCJ1gCJ54CJ+QCKCoCKHwCKM4CKNoCKTQCKUICKVACKV4CKbACKb4CKcwCKdoCKegCKfYCKjwCKkQCKooCKpgCKqYCKuwCKzICK0ACK4YCK8wCLBICLCACLC4CLHQCLLoCLMgCLQ4CLRwCLSoCLXACLbYCLfwCLkICLpQCLuYCLvQCLwICLxACLx4CLywCL3ICL4ACL44CL9ICMBYCMCQCMDYCMHwCMMICMQYCMUoCMZACMZ4CMeQCMfICMjgCMn4CMowCMpoCMqgCMrYCMvwCMwoCM1ACM5YCM9wCNCICNGgCNK4CNLwCNMoCNNgCNR4CNWQCNXICNbgCNf4CNgwCNhoCNioCNjgCNnwCNsACNwYCN0wCN1oCN2gCN3YCN4QCN8oCOBACOFYCOJwCOKoCOLgCOP4COQwCOVACOZQCOdoCOiACOi4COjwCOkoCOlgCOmYCOnQCOoICOpACOtYCOxwCOyoCO3ACO34CO8QCPAgCPEwCPJICPNgCPOYCPPQCPToCPUgCPY4CPdQCPeICPfACPf4CPkQCPooCPtACPxYCP1wCP2oCP3gCP4YCP5QCP9oCQCACQC4CQHQCQLoCQQACQQ4CQRwCQWACQaQCQegCQiwCQjoCQkgCQlYCQmQCQnICQoACQo4CQpwCQuACQyQCQ2oCQ7ACQ74CQ8wCRBICRFgCRJ4CRKwCRPACRTQCRUICRYgCRc4CRhQCRiICRjACRj4CRkwCRpICRqACRq4CRvQCRzgCR3wCR8ICSAgCSE4CSF4CSKICSOYCSPQCSQICSRACSR4CSSwCSToCSYACSY4CSZwCSeICSiYCSmoCSrACSr4CSwQCSxICS1YCS5oCS6gCS7YCS8QCS9YCTBwCTGICTKYCTOoCTTACTT4CTYQCTcoCTdgCTeYCTfQCTgICThICTlgCTpwCTuACTu4CTv4CT0QCT1ICT5YCT9oCUB4CUGICUHACUH4CUIwCUNICURgCUSYCUWoCUa4CUfQCUjoCUkgCUlYCUmQCUnICUoACUsYCUtQCUxoCU2ACU6YCU7QCU8ICVAgCVE4CVFwCVGoCVLACVPYCVTwCVYICVZACVZ4CVawCVboCVgACVkYCVowCVtICVuACVyYCVzQCV3oCV8ACV84CV9wCWCICWGgCWHYCWLoCWP4CWQwCWRoCWSgCWTYCWUQCWVICWZgCWaYCWewCWfoCWj4CWoICWsgCWw4CW1QCW5oCW6gCW7YCW/wCXAoCXBgCXCYCXGwCXLICXMICXNACXRQCXVgCXZ4CXeQCXfICXjgCXkYCXlQCXpoCXuACXyYCX2wCX3YCX4QCYE4CYFgCYGICYSwCYf4CYgwCYkACYk4CYtYCYuQCYvICYwACY4YCZAwCZBoCZCgCZK4CZTQCZboCZcgCZk4CZtQCZ1oCZ2oCZ3oCZ4QCZ44CZ5YCZ7ICZ8ACaBICaCACaPYCaf4CalICawQCawwCa1ACa1wCa2gCa74CbJ4CbWYCbe4CbrgCb4YCcBACcB8CcCwCcDoCcEgCcFYCcGQCcOoCcXACcfYCcnwCcwICc4gCc5YCdBwCdCoCdLACdTYCdUQCdVICdWACdWoCdXgCdYYCdZQCdcwCdtQCdv4Cd4gCeBYCeFgCeSQCeigCelQCe1YCfDICfJACfLECfYUCfnICf0QCf8oCf/sCgGUCgVoCgYoCgeoCgfgCgmoCgtACgt4CgzcCg0wCg4wCg/kChCEChFMCASAAAQACAgLYAAMABBICT3p1jrCgs8LRqiyotYiapObcMe+RWveViyzcYYmNvSAAEPUIEggTAgEgAAUABhIBESoFVqCR3E9yvTH/J5B4P7MjjOKqQeHBN0JNJ5Zk1+MACmIH+Qf6AgEgAAcACAIBSAAJAAoSAX6HX0WXr23wc30pbW0RExvovCthnHdxnW8728uFDN69AAwgAAsADBIBaBCFiJbfa94gWmTGU0uCbLUqjYYdwkPPKcA1HzgMJr8ACSAAUwBUEgEgk3ZRZRmX5YGT/oCgTOMYm0eCtFN82anVTj6H/sXWNQAMSACFAIYSASxg3yrVxWTBpXF7A5btaVwOsAwzEwoSc2ZQJh980+wVAA5qBo0GjgIBIAANAA4CASAAIAAhAgEgAA8AEAIBIAAWABcCASAAEQASAQFIABUBASAAEwEBIAAUAEBVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVQBAMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgEgABgAGQEBWAAcAQEgABoBASAAGwBA5WdU+DQm9psJJnvYdqyXxEghNFt+JmvZVqe/v7mN81wAUwH//////////////////////////////////////////4AAAACAAAABQAEBwAAdAgEgAB4AHwAVvgAAA7yzZw3BVVAAFb////+8vRqUogAQAgEgACIAIwIBIAAkACUSAQpCuc461Da+q19S3F+B+aviJs+oKzYrDiSXcejnfBygAAggAC8AMBIBh9rfuzrpVOf1RyxGpyntgK0IfF2c67jWRNFt1z+I3zkACSAAOwA8AgEgACYAJwIBIAArACwBASAAKAEBIAAqAQHAACkA29BTrudOzwAAAnAAKtiftocOhhpk4QsHt8jHSWwV/O7nxvFyZKUf75zoqiN3Bfb/JZk7D9mvTw7EDHU5BlaNBz2ml2s54kRzl0iBoQAAAAAP////+AAAAAAAAAAAAAAAMgAAADIAAAAPAAAB9AJAABMaQ7msoAEBIB9IAQEgAC0BASAALgAUa0ZVPxAEO5rKAAAgAAEAAAAAgAAAACAAAACAAAEBIAAxAQEgADIAGsQAAAAMAAAAAAAAAe4CA81AADMANAIBIABCADUAA6igAgEgADYANwIBIAA4ADkCASAAOgBMAgEgAEkATQIBIABJAEkCAUgASgBKAQEgAD0BASAAUAIBIAA+AD8CAtkAQABBAgm3///wYABOAE8CASAAQgBDAgFiAEsATAIBIABEAEUCAc4ASgBKAgHUAEoASgIBIABGAEcCASAASABNAgEgAE0ASQABWAIBIABKAEoAASACASAATQBNAAHUAAFIAAH8AAHcAgKRAFEAUgAqNgIGAgUAD0JAAJiWgAAAAAEAAAH0ACo2BAcDBQBMS0ABMS0AAAAAAgAAA+gCASAAVQBWAgEgAGsAbAIBIABXAFgCASAAYQBiAgEgAFkAWgIBIABdAF4BASAAWwEBIABcAAwBkABkAEsAN3ARDZMW7AAHI4byb8EAAIAQp0GkYngAAAAwAAgBASAAXwEBIABgAE3QZgAAAAAAAAAAAAAAAIAAAAAAAAD6AAAAAAAAAfQAAAAAAAPQkEAACP///xECASAAYwBkAgEgAGcAaAEBIABlAQEgAGYAlNEAAAAAAAAAZAAAAAAAD0JA3gAAAAAnEAAAAAAAAAAPQkAAAAAABCwdgAAAAAAAACcQAAAAAAAmJaAAAAAABfXhAAAAAAA7msoAAJTRAAAAAAAAAGQAAAAAAACcQN4AAAAAAZAAAAAAAAAAD0JAAAAAAAAPQkAAAAAAAAAnEAAAAAAAmJaAAAAAAAX14QAAAAAAO5rKAAEBIABpAQEgAGoAUF3DAAIAAAAIAAAAEAAAwwADDUAAD0JAACYloMMAAAPoAAATiAAAJxAAUF3DAAQAAAAQAAAAIAAAwwAehIAAmJaAATEtAMMAAAPoAAATiAAAJxACAUgAbQBuAgEgAHEAcgEBIABvAQEgAHAAQuoAAAAAAJiWgAAAAAAnEAAAAAAAD0JAAAAAAYAAVVVVVQBC6gAAAAAABhqAAAAAAAGQAAAAAAAAnEAAAAABgABVVVVVAgEgAHMAdAEBWAB3AQEgAHUBASAAdgAkwgEAAAD6AAAA+gAAA+gAAAAXAErZAQMAAAfQAAA+gAAAAAMAAAAIAAAABAAgAAAAIAAAAAUAACcQAQHAAHgCASAAeQB6AgEgAHsAfAIBWACDAIQCASAAfQB+AEK/jVwCELNdrdqiGfrEWdug/e+x+uTpeg0Hl3Of4FDWlMoCAUgAfwCAAgFYAIEAggAD33AAQb716//OU4cDdPEVRJF61zqQjU61GlQEp0cKw9sDXt2zFABBvtmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmcAEG+3N3+hWqZxcuAeEGZwHcL6jHyjg1zOPc3hEgN70TNkBQAQb96SYlD5XEfFuCmona5jYtGN4iWVOW5abGAZxXh4ab9iwBBv1WvtHE3vGL4v2ULAPnKD3VaY4a/yqaWeIMPC9ID7JjRAQFIAIcBAUgAqQErEmmLTwhpjE8IAYUAZA////////89wACIAgLHAIkAigIBIACLAIwCASAAmQCaAgEgAI0AjgIBIACTAJQCASAAjwCQAgEgAJEAkhIBgaD5y4/oSa9K1glwI6xZqxb+gFdHwoQXhfy/0VER1MQABSAAwQDCEgHwR0XNKH3X8Dd4+uQxCr6IygJE1I1vpN237tTT3E8SrwAFIAD/AQASAZK9jXXfZ22FoK/qZo7ZA1LstgsL2OBwaZ+YPwgIIczWAAUgAT0BPhIBD+5PjobGole5/riDoZCBS+7CN2WX+0516C+wYIpHXd8ABSABewF8AgEgAJUAlgIBIACXAJgSAQPVOrjm4EHRZntpS4absU8x2zmARvJyZaM8mW6stBUcAAUgAbkBuhIBb3CYlm447fMa9kNzepNVZjeBfXYxbN95tOjDM6BFdcQABSAB9wH4EgH07hoVTZ1XCazjJRqqc6RRfwzShvUaJdAsvnYiNYcPlgAFIAI1AjYSAegDPYBzohKJRzOdOPYn7IxeKVLmH5PPjGQOBC+/MbV0AAUgAnMCdAIBIACbAJwCAdIAoQCiAgEgAJ0AngIBIACfAKASATwblmYYb+bsv/8uGl84o/jlAEoIsOL6UcTCFKzB1pe5AAUgArECshIBg/YiX4PSeANitfApY0uTl+ZA6GASz4G01sPieloSJfwABSAC7wLwEgEOhAeHH8JM4U0ptdgqMTGFq3qvTPkKs3H1PFZ0hIIwhQAFIAMtAy4SAUeV/9yTKwWoRuqDfsD5G8pNB+NYlDpKDS7q3OtCC2s9AAUgA2sDbAIBIACjAKQAm9OcdAk8UD225STKM+zXgoux6/wTL5HHAGvl1y1/iBpzYF6uC5iYADP4GEQS3lawRLUJdMHCg2NJPoHSyX6IlSJrsoH1Zl0UeZNcUG3W9AIBIAClAKYCASAApwCoAJsc46BJ4qTmHeXjCdu27MZ5lzT7qeFMXBP2K0CR5o9jSgRlv3POwAGmzKixQYysFXz/0sQOnvlOttXilOm1Yj1anBGZ3HlxBbDDFvsmh2AAmxzjoEnioGAjtpnTDjINaHT0ueAgwOt5t0IttFX86AAOXhiVj6bAAaZ46wW7m54gIq9S7Tk/+hUDOUX8iu0cU6q9i8iEg7bejWuRMyOAoACbHOOgSeKoF7OgwetXNqZWt/oWsrTBpqoyDZdS4C8R1z3u1b0LawABpgrxO1cj50oTNa8IAvfePQ18kmnbzdofeNetS0yytSIksmpFxC2gAJsc46BJ4on9vkiIyovLIHnpJ4M+HBzE6c9lQzz4m2kDPWAh6vW5gAGlTImYhG25MvhYKG2PQj0PEiK248i9It6Apkgo4vKqXIXT/+XR7mABKxJpjE8IaY1PCAF+AGQP////////QsAAqgICxwCrAKwCASAArQCuAgFIALsAvAIBIACvALACASAAtQC2AgEgALEAsgIBIACzALQSAZ77zpLmRtNmq05nXT2r+D0NU31iy01m0HZZwBpJToGwAAUgA6kDqhIB+pW8HayQet87VkJ43bPd+WhmMZIaimlWpQkJmpoZWRwABSAD5wPoEgEscC7wXDhsT2spdNDF7NLanyXZdFErIeoy7m1Iv8paZgAFIAQlBCYSAdHR7Kr6suvTz2VGLfat8caTkFCh5GM0AhaD+JkHTabDAAUgBGMEZAIBIAC3ALgCASAAuQC6EgFQ04moy7B7MehJgEdBDrfnnuyxoywJzPiY7co5QUv6hgAFIAShBKISAXC1ix2CWEGBuaLlXo6njfKVXDXiAH19kMVJVFnwiCYVAAUgBN8E4BIBOEgBreJcejN/vix9UsF7nKhzFQcGGCi+F7Sw2qWZJIAABSAFHQUeEgE68WdbjcMWg+yAVBgKG9qLlhvDUaUFEBZIscZv1dE8PQAFIAVbBVwCASAAvQC+AgEgAL8AwBIByuJCATnWvbHGlDBgwG3NNEXYk0p305PK3fbVfo3Mp7AABSAFmQWaEgEc3aw90AxDw346G9gu+JEKNsMQ/H+xWwUYRKAR7Vna/gAFIAXXBdgSARCy/4mmGUP207D3NGvAOoIg2ZQM5IqTYAKuEj/ZejDnAAUgBhUGFhIBJg5NY1H2cy2s4/RZJQEdBo/1qipDMwVHPDD4Y4XTNVsABSAGUwZUAgEgAMMAxAIBIADhAOICASAAxQDGAgEgANMA1AIBIADHAMgCASAAzQDOAgEgAMkAygIBIADLAMwAmxzjoEniiF2dk7O92P5Uo9IqnaFK+YZW2KlIWjKsUDAh6vLQniAABN9CRmHE2Dqkvu1F5YoLj+0VXGY8SswIIy5S+qVVITp7AcV/xfSIYACbHOOgSeK4vK5RBp/JDOKwuUMv9J5bS7cHktrnIUbhurx2GEm060AE30JGYcTYBq0knT8xxkHCC7FgHmE6DLl4TKiuIwNk8/vJwvz0Vd8gAJsc46BJ4pImljWSe3v1ONxZTig4Y26Ut8U6RIAWU/xn1mxO9UQDwATfQkZhxNggi1waJSyOQHPV0r7hNq2RoGLoHrhosSFJxkwMCCvINiAAmxzjoEnipXMA5FRGhFCoM0ms2QnVcjcJAE4n0n9hapkRilye1eyABN9CRmHE2AJJnK5pdTZPaF+zVpCkwON4FqHpSTyj4JjITE9cgXlKYAIBIADPANACASAA0QDSAJsc46BJ4oO/+LA+XxEcfi/Ec5CrEz2KF6G9MZD72f/4f24mvUOUQATfQkZhxNgVmO0RSRL1JjKgUI9PMY36Lc1+XDlxUn2ZUqQnksTgwWAAmxzjoEnily3tPgW8et++2rlL9IO4Y6IVQACJOjYcKM9zaz5PuMfABN9CRmHE2D4KQXzFhofcQi0o4B/xclwsrW0XlghnAM/FhRYLd6qxYACbHOOgSeKVr0hVBVQzUZVZ7rEnloRaXu72bNPdGpIDTNWLgaWjzUAE30JGYcTYJU0PAn11PGDDIrkyFd8Zu53n6cj0MjRCsr/rJ80ax7KgAJsc46BJ4rTayYpkegge4TU6MGmtvwCDCW2LxXHPVr6kLQFi188rwATfQkZhxNgOnQYbNX2Fd06emNwr32DqXSI/9LfMctOiT46Qo6PscuACASAA1QDWAgEgANsA3AIBIADXANgCASAA2QDaAJsc46BJ4osh7AxsivhKqlLlFC/4NePmw87O8TVmPJH5fsuy+faZgATfQkZhxNgyydjwz9WQ0ewwwZyLSNjy6GNpdb5+7sOFVChZib1zgmAAmxzjoEniohekd2lqwi/bP36rkmsB3p1qgS+cevWC/RxiC09q2GFABHTuJ62qSCwblwmcFXGQEnYla+jFkEsLHRKWM2+qa7Qvz7s3ZiYAYACbHOOgSeKpEZxBRqTi8BTax+IlrFHBogXexnPJtSXmCIKfQeemfAAEdO4nrapIIsRdpoFJAbM0/CeZ1/xJQNE4Ajx6e3ExvxqwOLEeeiSgAJsc46BJ4p2a0/tHe9mk+RFkbNxzAJcxTfa2xn3hFS13S/Qbrzb6gAR07gLoeRestvCc6gvB+hjyX9m0wkSEHnchBzvq3Rt+IypHmN9uOGACASAA3QDeAgEgAN8A4ACbHOOgSeKduPcGHCqsKwTBwNwJ2ruhKVj5GoCrr28GPjJx0EvgoYAEdO3eI0fnEHWns+PHudcsn1ZgpFEncsAnlrJamGYSbU1Fb3XrcqtgAJsc46BJ4qiLrrOeHnbFUoKFsOIyihcktXOi6DlxD5lwuH5TAXSyAAR07SZJUfSg6lngraTlZGU9H6spUd3jhdfbp7EY7dzIm+zrsbH6ASAAmxzjoEnijBQaoFIHw1ZB2LNTesQrDN/wpE2DxG/W2T80hgubgJFABHQ6wZisrZxEPLufR+rwvspaDiklsfq9uNRkANVfqzVa+tNuDhuBIACbHOOgSeK5p9Gh4WxZF0u0o96L4x5AvTZTtOh+Y8xfdJ+ScM1eg8AEdDrBmKytpiU7LFAtOwUDTgw8XoB41wWvNZ7liapsBERE2RJJ4hYgAgEgAOMA5AIBIADxAPICASAA5QDmAgEgAOsA7AIBIADnAOgCASAA6QDqAJsc46BJ4oIZIXIYFKoENLOLtxMBwKvjGjkW7D61ZRXTyLiomJNAgAR0OsGYrK2bgqydrCcT+hUwwikC4WBIbx8o/f7b//IDmqnqcOKMz6AAmxzjoEniqlTPEXYDFJmL7HO6ws69buwmGkwOXh+9NKCZ50W1aNTABHQ6wZisrZugSZtTkjYaNwjDgyCFH+rMYfzVDf7mP11X4n71dLMyIACbHOOgSeKBKBoPTulWt710OYr3+5FN7wOC74sPmcFYlIx9hH0XK0AEdDrBmKytn1xd3no4iexUvlItgpXBcAMegPoFMeLNcwvpvHbIgBtgAJsc46BJ4r+D3bE4UymQL7hFDHqUeTO/cj9DBMZ2oBhQem2xuDVvwAR0EKvnYCyh/b66K3ldy+DDXj3M6BrE3ikZT5LPflckRWt3dht9GuACASAA7QDuAgEgAO8A8ACbHOOgSeKatchEItaCG3oX5E/o14mw1eprckCXLANsPjNkyImAO8AEdBCr52AsvPVAOFGONVL/GOJZsAh20zyk7eXi9ljMlojkVGTCLlPgAJsc46BJ4rPiCIlQVfnqwD/zWLGUlwavbdAdNYr9RgGoyH8Wj7XfgAR0EKvnYCyuWUb+36ZY3QPkNee0WBt2i1OvIlhE2vKlcTmbl8AQ7+AAmxzjoEnis/bzAAbAQuWvv0UGgmCFhgvQUta6BBZepGgDQLltbZ9ABHQQq+dgLJAgSPh0i/I9P8NRSssuw6PvrVYIzi0CDLJsACdE1oET4ACbHOOgSeKBIaezZs4HuA87rQPcLCDq7Gl74++BYr3KzREhxI5biwAEdBCHIi78Bv15jHsV3/kRoe6hMTQCTDDFrleE+dAbXjGuBJH6HjcgAgEgAPMA9AIBIAD5APoCASAA9QD2AgEgAPcA+ACbHOOgSeK5yjeYwYIbdJz9j54E3UmByXT1Z2gaPUpt4ifOOVWdJEAEdAOZzuPvgdAHUXGawj3e7deSTsxQeB70EdJNC0vwP6mUXWMlSbsgAJsc46BJ4rISzjc9wCNXBGWHruFlGfwbpNLP9s9QoHe1TKkeQ8+NwAR0A5nO4++J9srTEC1uRVFybatoQ04gSTG2Z9OeX7wxwg2TXYsLZ2AAmxzjoEnimzhgUV36xe1lj5feAJ9bioqNMQGxtc9NoUoEhe2mT/XABHQDmc7j7689TRhPMAbCAXKgYfkzMNd8J+y/TyIeawtzRe7aJMD3IACbHOOgSeKUU+g+yuyQEzGGZ7+6Gi/KruLB0qsSoIwjCHTG10JH4sAEdAOZzuPvqXK8qGUhfpzU2YhkW/2+OioHvJTOiKOURbqqaDWAqnugAgEgAPsA/AIBIAD9AP4AmxzjoEninZH7CF8mskLXiWqV5pmnjP3TsrZ8umK10XKqfVX+rtqABHQDmc7j74hKJtzAHi8+27bNerXDXvuEoqkK01Hlu5hv8jcXiBT/IACbHOOgSeKMrcqnC/HNPnV9+sHhRQiUXccO/8SGQC/Z06dz2OegFMAEdAOZzuPvjZte+uXhz4XfhMqe38uy3VgSWcA+6PYvtpDNTAMRKS0gAJsc46BJ4qtDHtDY4AWIv0ZWpYe7uBBTGVZ8pN7ysCIhjIiDQUrRQAR0A5nO4++/ysxQuRJxNUmwZFk+Q8jsZs2p66fkhd5ls5fgTYe3qqAAmxzjoEnihk/6Zlaegw4LX88xvz/PRqXKe0OCOlKa4jp24FGX9ZRABHQDmc7j76pv1qgidtXugKzijnUQ47cqIlRBDpqeKOdDucchS2uKIAIBIAEBAQICASABHwEgAgEgAQMBBAIBIAERARICASABBQEGAgEgAQsBDAIBIAEHAQgCASABCQEKAJsc46BJ4q/CZJnggs2HPbQ8rpJt6BJkQvL4yZuwA8Cg/Tr0sPRCgAR0A1BEgY6qSjy5KdvblDGcKmQR2Aifc9XscJMjtz0cigrRDA2gcSAAmxzjoEniks9cKn7ZHGYbm28fhSpDAHsyhG8TVFqEilsqKIE7ONGABHNEbJAkzJ/moI4dXEUPQOBhRSd+jHWgPB/W75yktuEysdxUp3hsoACbHOOgSeKkE9xPOFoBMCDI4q1muv0Mao+BG32LFgp5e4d6iuUCxUAEc0RskCTMh+KKqVgBH44LsFShaievL1IZkZpj4IwewmZwSuyWXEDgAJsc46BJ4rTnM8Z/w8EOFO3qmvWup3xhX36iO4pFWjawcxEj12XVQARzRGyQJMy1+pnNRz/xrsGEA+iF6HekQv8m0/7QDyqmU6mQjikA7+ACASABDQEOAgEgAQ8BEACbHOOgSeKesdYsJO1p9PT79joDcKo6aS1h48qW8pGtY9Xzr8Gix0AEc0RskCTMnEN+Ezq0xrIQJIjNq78KDjAaj7uUM2o7dfuLEyoNF22gAJsc46BJ4or0hdCZfK83wX7LUDwfkGqZxx1kuaZPK78KPFmZ3GSdAARzRGyQJMy/FRWeknhUszxG+KFe8yGAPCgcDR7t0JF0q5VJ+iHx12AAmxzjoEnitx1igyNa/1KqubOG8mVSV6DqZ9LGTnwh8tiyJueG6K2ABHNEbJAkzL9KsceXTCnsdWc56cWh5HQ4bIMsZuygs90Db9UDhQOQoACbHOOgSeKHIQzg6XnymBLlXe43OPqtkFNQxj7z592Mn9j2fjlqloAEc0RskCTMnqfzJkVkCpk5xEeEYlMj8Z4X8ENAvLv27KDSTKbnjEsgAgEgARMBFAIBIAEZARoCASABFQEWAgEgARcBGACbHOOgSeKFTlMiTwNsaoOoHllV+Z3YYU4YtuAcv0JMVCRNU0tF+QAEc0RskCTMuptQZUjFs6CWKd3CwAo8x+4SykJD1pxkRJ5asL8HKnJgAJsc46BJ4octbHgIIpk7oEqHxaAeqGHCVDJPtMLW2t+juXRcDEjXwARzRGyQJMy5Bsvyo+ykmc/pB9PUgqMjVxj2Te3O5YdGGrZKUBg8NOAAmxzjoEnikn3fgybIJU0Nr327esxjMo6kNPPaEgGOsPaPHa+DQ2jABHNEbJAkzKs2ypd/J7Lxv5mwZpFm+cpAYcWoceIZ7JCiGZXJED2O4ACbHOOgSeKMdOc8EqVlsNVqjS0tEHXaFojnf7kZf03OxU43c2MIJUAEc0RskCTMgegnCfVjmZ8+AVp0oCVdRFwpHd+zRsY9+uaQN7K1vvvgAgEgARsBHAIBIAEdAR4AmxzjoEnisp6Vhz9aKjVoZ/lMGp+XEV952swHgYI70x1x6HkKeJMABHNEbJAkzLlvnEiyd63TubZg4TCeYHvmPVw5OxpHhW23yLwio7j3YACbHOOgSeKueL6NrBXMPWucbevghuQWbx8JstIX1k05tMXecZ6u90AEc0RskCTMhL8ysIF+tMDNBQC7cdUJp1q8azeJQHCcS190KEuYA/OgAJsc46BJ4pxAXVpzz0LJrFMs7AwLp12lV/va9sepBRqa6QuWE8BBAARzRGyQJMyoG8xl9fXWYAZklRLGox3dOAZNswzeh4sYvGu/znc49SAAmxzjoEnipjWake9aYoILeMMn3GSMBzoUZgCVQkdqSkT66Hqs4BmABHNEbJAkzIb7IlR93scyY6xwQ31pdbrU4IQJkIOESXCcNubCXZ1aIAIBIAEhASICASABLwEwAgEgASMBJAIBIAEpASoCASABJQEmAgEgAScBKACbHOOgSeKOKCTAor2fvHPunGQ0EJj7yGguMQG+zuVx67wWTZaVsQAEcIcPaE+A/GgpBU4V+U4WITk785Q+rvABmL1QTmljK1tzpdSnzX1gAJsc46BJ4rRL1WmN4pp1QJn42d3MhSUyEqe9fMsGrJpCmS+cJ3rGgARwhw9oT4DugFeSH5y1e3JgND7/LNsjElyddV+EbUUiDmvim0ATUqAAmxzjoEniliqNbl8OLmr9cLDJg7vv33BgKMR1JWCCR41FuZ15rg/ABGZm5iGlylCj5A5AgGzvvkIwGSUOLy8/3XAv5I4JQ9bd0j6WAM4q4ACbHOOgSeKISLoguCytsZ3gmr0TeBkW5FEenHYMpVAMKdsJ9iUJdkAEY4cHaQQ6rF6tA2Dw9WYemtWKvyiIpjlZOhJGdq6tf8k5FjIFNnrgAgEgASsBLAIBIAEtAS4AmxzjoEnisMwL+lexazXBPgZarfWhndYg/4WFpkPRslV1XGJ32oKABGOGG63l9b0KK4st8RYxw10f4cK+QsGhA6Ph+0x2UuXb0cj3DqhiIACbHOOgSeKnkGS2h0g5qxOoaNwl8xvlrrNP1Lm6x2zTLe17FDKOIcAELVec9Piw5R9n0QEp6zU2CK1kScS5XCxV5KMK1EZNzAIF/5RNA2ogAJsc46BJ4oHRmP2FPaQF1mmznqnXS3i9MBZu250W+mHLPnha6l1QQAQqi7v5mZqiJCHDA9GqnNpt63nAnuhtT5QFqgo5SX+01ac2zxwqj2AAmxzjoEniiwhvXh/Ta7nBYMPSxMcNY0ZE2Z8RzQEYuXZ3UeT+emUABCqKcyIakoBhx38d8bH8ArlJEbdS+msb+9dglynKWJ/eLbnyH970oAIBIAExATICASABNwE4AgEgATMBNAIBIAE1ATYAmxzjoEnilXi43ScOLqdOk3raD6H4H9HUtaWxBQcV57CcGqDD4ZGABCqAjUQ3k9WgtQS9L7RJ/xZVLjeiuX4QLAi3m5BoZWCi2n9CHGM/IACbHOOgSeKu8DigV6L2I2K1RryWzaXPqYFjUa2zB5zNxeHJpx2XHIAEKoA93klYUZflNpsM+qxD6pNq304Ej4ZqidWhTVdnJ/ybruiaO4ggAJsc46BJ4ob3K8SMdmem5rScFOAbi2wWN2BPJFYgz5I9M7l306ZNwAQqgAOrbRYx3c8OaaRuTuDceVK+omtv1GBLelXc9mFpWmB0mVSN6+AAmxzjoEniqBJQ/rzr9Fu6kM9rfPJx4NdB9nryrCbek8fT7xzrd3bABB/G1gGh6L5KvNCxE3XZQnCjJlbHFuH5JowKFFw1MRRQZlcxe2cooAIBIAE5AToCASABOwE8AJsc46BJ4oDH9MvjQDoMUlLf3YDYEhGBG5MI3zfZwxvaxbg7qX6cQAP1Mlarnu8JJTdyw0HTMvZlt/L1n9J7y1SJHNZzpBexbEJ9PSUkh6AAmxzjoEninkCkvnuh4QrYAP7QY2pKYjB08qwS1pXqsymsTS87H5/AA/JuChR4OZ/Pk2gRfBYelrCaJOx9CCjQ/tOUV5OM/cZCKILQVUhuYACbHOOgSeKf7Vv/N8Kz2s9l2PwYE911URpImx+fvEF/P8pPzn/MpwAD8mpKnfzzGZ6JcdpM4WWEdiHZDQuVwvs5nkri3sA1715Bc39h+AAgAJsc46BJ4qs0BbH78gF1rL0DwF8WC2gESyKfnXeE/BOSCLiSmwy6QAPSaQMTZbATG+bEJZ0wMan0Qg21CU6hVeCm8RRAQZ+eTgCgBvnbnKACASABPwFAAgEgAV0BXgIBIAFBAUICASABTwFQAgEgAUMBRAIBIAFJAUoCASABRQFGAgEgAUcBSACbHOOgSeKTwJvuSpkD4Vg8rOk/tQRzmz4lwVpMYTaGVWZBwL6ENIADvmEjYABrjV4OPoegvR9QJhlWzBN3xGv0EctlhyLcy+ifNgFgZcWgAJsc46BJ4pjyk5CSKqqDA9J51EYfhAIoMT+KYS3ijzUcNcO1l6TogAO1y+VKqF6otDCBNXtIhffWpnp2KogQHjECYDHPbsa8H+kpdgNc2KAAmxzjoEnigxIhf4UvGDIzaqGPwVuDq1lJyGGdwr8AqF5oI68c5QjAA7G8D2cvcMmQcwBgyv8/hYRBP29oCv5jhF3WJaNNWv4OBhS1UHpcYACbHOOgSeK+JPW+EXFs9l715hTUOLW2IqENFmgvA4rDPbOW8ffN3oADsbvqof5AYd4aAkC2GxAlQ0EHedbedPO6pBRQhEUZDYAvJC5ZD9xgAgEgAUsBTAIBIAFNAU4AmxzjoEniifKBcQ/ZgDnqlvBLobLiqoRDIYZBQDXU60RgoQqc3PEAA7GHokANTDeuED4UVbti3r18kA4yRo55JTpuFNJWz1EZrToDlNON4ACbHOOgSeKwvJjxbkfW++zAIUpuNgcTy5qnvNtr/CNxSzmawqksM8ADqlb3FrKz0QSB2/SoD856QqHo646JKZZSMeAj0Hab2sruZ+Ofvf3gAJsc46BJ4pSIN8TK9GlLtrqC4gY634asfvGI0ndV9lsb4yX3djKvQANuDF2Kor+hDm+vcZxOeL5yknGz0g2QUutpB9Qg/0MKf2W9tasu6WAAmxzjoEnioJlrbSSYcGSONRRC2tLzDdgMB855/4MD0Xr/ZE7m5lgAA2kJvCP4bS7Qf8xRkV1vk94G1+ERr7Uv6OwSx8jEYdCsESHsyd3D4AIBIAFRAVICASABVwFYAgEgAVMBVAIBIAFVAVYAmxzjoEnih6EMKImVKqXpJ5FV01iAEDSzZhh494lidcEMWR/0rHFAA2kJTHrBnYTXg0ClSk87tS8GgefgsozUTa1OcO74FC3N/mFQ8+46IACbHOOgSeKvpcmYteC9udJs1/KD+ayd3FH2cfpvnXzeZWldD2tToAADaQkEsz4arG9pYZlr9twbjmePpSwXf8Ensab4Sz0T6jYvdaI7XRtgAJsc46BJ4pHV0/HgJh7dIu0f90Lovg7zOy0mct7AdM0tbTp+ge07gANgHA4Ij2r8AgNQy2nETUHokT8bB/VU4vEwNo9XCbu7Oeq3+Mpip+AAmxzjoEnijTxPajk4uedHypu1T1Nr3uX0eT9eWz1AvH1IYWGjlxYAA11Ru6P4O2sGUKR3PEy5bg12dEN7AIT4283eiloG2k9VOBAn7oQHYAIBIAFZAVoCASABWwFcAJsc46BJ4paeEa4JaxfzCmsqrVSDVit4EgV3P5PbjAF6xzQ94OUZgANaJS0N8OWISMx3G7yDYdhvOBGH23uzX4P+itgkHTO4wsmsr1lyO2AAmxzjoEninnPauiqQU4n7zbQF2sOAuziJ9nH6DgNwZcH2ja1fjt1AAzkPaKGoMehHIhHfAlCsZRteGvcL/btIvLXTCGU65LJZ00GsTRTY4ACbHOOgSeK5Zb/zffL+GjU7ncseq+k4JY4AwjE3bd3ibdx5UHro6cADJyg9UEiwgahp9Wk75FGnlLkr9Ib0D7GJKvHeBWcPJv8UgNTdjQLgAJsc46BJ4qedrs+4Ih+jD6jps1JdgmdC2SeISNjEhRRnEpJxZp/EAAMkEAmic1n4tWqO4tMMgkbj8mawyjyaWkvxTVyOoiEPKe8JefdREeACASABXwFgAgEgAW0BbgIBIAFhAWICASABZwFoAgEgAWMBZAIBIAFlAWYAmxzjoEniiGDs0MNmG/Pc3YQ5nr4Mu+D7/3o+qmLR0DJOlyYvJ2aAAx5iWOj5kcaL7QSdNS/s5Y+omwDJPVWm0Z3Id+XzJvuUD0wGYjWyoACbHOOgSeK+ig2yOt7/qTLhCcZPZp/m2hK50RnhiT+9cGLzl/901QADFQbvn1DnKDAK9m3uawyzdL0OEbghjmvDXq9HjZVxs+YUnPLMzjGgAJsc46BJ4rDiGDLGnkVoKSv/wYRKpZQ5rOjcE1tUNsiMeCt4U9wbwAMUFDkk0z0C14cSNFRdUvm7QFMWVnexYdx8paSgqRRNAHiz4VHBtOAAmxzjoEnihEwz3o0H+AvbZkLpCUERcV3Tl4k+PEiio7LFHQzUWOrAAxMwcZPHF/rs/Q6dpo1D6W7NZDAfQt6h/EGtBlaA6jQZvIbyiJF0YAIBIAFpAWoCASABawFsAJsc46BJ4rTEVlii/3MZ+fPwZ+n1eHN16nFJ7Odlr0cpWtM6JH+kAAMSrXtbKTqjI3HSX9CzltodoetdrTsfbM3a6T7KrF5lRpNLneSwayAAmxzjoEniqDOMSSPpC7vsg2cuaCyCDOssROnDINs4llINac4p240AAws4H6qmL4+nzh8jeUlgPjHHdbNBrZLa6xXugyXzO0FloLyK7FNWIACbHOOgSeKlbF1eS4hB3VfHzGcFf/TlIE8ehtA4Rw5xF4BdOGKqLkADCzgfqqX29ZvkzaSakaZm+OFZkM4hFRDdTPYgcfiK2zeH/ZKQ1SJgAJsc46BJ4pHjhAVhQsfd3QYgq+ReQeu2xUQ7XBg7y0YOiVGwz7ykwAMLOB+qpYfGQAf9oVGjeIcQbgPC7tIMuXQnU5ywrRPjOC0fR2yK/qACASABbwFwAgEgAXUBdgIBIAFxAXICASABcwF0AJsc46BJ4oIlFtTwq3uOGXlwe/mBNNZhfcrzXnqdXqlB1CVM7jfAwAMLOB+qpYf4otE22eKBeyJYEWeCzIrOZyJKYvGTVBbSb2lwHGw7FWAAmxzjoEnir7FiytTzn/M7ed/BwtvUYbYHyO/GSTzWpQvDxaUgfNSAAws4H6qlh3HUaCYSzUoAkv8QWaRjJqfe5W84F9VEhO0tVLuP5lyzYACbHOOgSeKno8GomMfJINh6GHHJb2/wdSx36TJIBIsPCZKScM2J1UADCzgfqqUXn0Gioo8V08GpWMfhLdr1nDAkfrX5MPuzh/DP3OYb6zagAJsc46BJ4q8m5NOwGfv7Ui6wDcrs3OSLV1CxQFMKAocFLlnkm6nMQAMLOB+qpOAJrnSl6QZbYLb33/QKa/5+sCBY5H/8gaIwrYN8X2nPweACASABdwF4AgEgAXkBegCbHOOgSeKwszV/PGlKjbYx2kV3ksav3jcm//wR0nQLlsaCScUTekADCzgfqqOQiwsY/ZPLWeDeSGEnCbRz8w6lkNBmA66+umBLc+lAsexgAJsc46BJ4qCSBjLfkeVA362RPQqBGPvoZvOZxlLIGV/aUW3n7gCpgAMLOB+qokD4OHtJ3Yuj4NOHnobPj3qTf+eb3PhRHI0fhxW9uqiK2WAAmxzjoEnitaryJOa/MUprxjDIII6YY6/iVBcyfskwODqZBUaldYSAAws4H5eFsfme9vcRfw7EJREAI2vZLGAdMs1TQyyOQJpaVRuKi5C+YACbHOOgSeKCkMbMscWABXk/CNYMKvkyqd8r9zaZ93KSGgGhZgAgUcADCqxWcFQARCT14oOtw+jaUskKLcvQfjEcgm28S2PdgZkPtstzCbxgAgEgAX0BfgIBIAGbAZwCASABfwGAAgEgAY0BjgIBIAGBAYICASABhwGIAgEgAYMBhAIBIAGFAYYAmxzjoEnipARehjeJhdsOxLcclMLUdHyMfyRJ14+aVTQSqi3eqfUAAvhgPa7LRI7D2HsOTxLl6XUU0buYLzXS/7c4nXfsV+XY0jxgAiRkYACbHOOgSeKUThTNnXKqhph3zW56mIRcdVEDjmgHCtXGRh0Fk7arvkAC+C+bWne5g5S365E5TpFq2J1l7qiDnnTe/536a+vYUGmEniDUbx5gAJsc46BJ4rf8S1QTvAUamHEOhXPA4dfx5o7KqP8PI85/Mok557UywALyFAIQw4xbOR/uGYEBFc93o5wShc/sNhaq8g0DpPrKt63R3maF+KAAmxzjoEnimOJOojTqYFPfNRV54xnDUl2FRJ5e1aLYW+RzLEEuWkoAAu/VePAt0CYk3Sgl5EFOBADQ3LHEiQJ5Xv5peqGnQLB3tjaOW27doAIBIAGJAYoCASABiwGMAJsc46BJ4paSh9CXLkDcoEw5AYEALmOzOOTvdOSzHpu2lVPZVu3ngALv1XjwLdA4en4aR9DuGsik/pGbFQXUKkUmo/Do8dbo2qFHqdDuP+AAmxzjoEnioFtW8DWSKUj74dvjwSTdoL8GS8ov4OfOHdc28k+IDigAAuw8C0D07E2uaD4novL+49yawV93R9dFRfvmJf8talR+Tt+45Dn5IACbHOOgSeKjsU7BpCSjKsfjBFioJ1wH7IremjJgjiSykku4ODhVrwAC509i0RfvYjmi0rvP3Ld76R++NMcjDOPLJw7EE9Ulfdz/w13IwGcgAJsc46BJ4qttAJBNHf4o8E+KNxOEXoVTNN+Fy1gXLzVz7YxEunB8QALYtfL3syanCRPXVJGtJcjBLcB7uFlNPXsBLxb19m/OEYs1cSMtC+ACASABjwGQAgEgAZUBlgIBIAGRAZICASABkwGUAJsc46BJ4oOxNkl3sJ/TCfA0x8D1hr8tuQ5IIQkDC+GVf2WJ2EeuAALYsnh8bL2Vk2QsFdgKyz4rvEjd4Cw2DbBG9/XAJ1qRoXGYN4qRMGAAmxzjoEniq8L+a/QCMzUDJ9aSi6h8E6hGg8eHTp94podgMaIgSb7AAtfF4CwuIjscbT5/vGi+JjB6Iu4EdOe4B0tF8zaSZHqln9Hzwl1iIACbHOOgSeKBhQ/eYhLsWXCoARbojYh4TGs3tsKfFfcoozytex1AcYAC13h0/Z0HKhJTYqw58hv5WDy+DY5/66KD+lN91UdNnSImrNoCFZpgAJsc46BJ4qqVJVTWzxoTvx4rxMF30d1880DIlUOmCCBQbFGq9nAHwALXdk1vuy/7FpF7PR6aaS8eANY3EfGHOGkIEoJ5Yp0+4Ch+mysZxCACASABlwGYAgEgAZkBmgCbHOOgSeKgiJz7LpYspgzwz2bPkT1/YACTp6UNdPci0x3xrk3Dt8AC13UKtWP5uWZnt88IogPZs+/aP0wJb/vlHaUS07gDqLR/aMD+iukgAJsc46BJ4pF674RCmJVK1i2hnW+C23Lfp2Ll9dUsCvouOn+eowcAAALVPTmUcqZQYLkhy3R3w1EAS6hNM7bB1b2TNieoe6RZ51en9tM0cuAAmxzjoEnilqoLBG5ling522ffYlJ2hCB4l5+z42/olBfA3paXtDYAAsor4gS9ZYPQmd4btHUFWFkmCGuOy5DNXgESeiLCRKAH+bHP4500YACbHOOgSeKpfwjfmJnsu+Z2dT+hcOLNOA9/z5F0fovb+jS4skS654ACyiviBLz2Fb/jsrYOlahVq8LPyUh1vR12fhVD1nHtrL+LVQ/37ingAgEgAZ0BngIBIAGrAawCASABnwGgAgEgAaUBpgIBIAGhAaICASABowGkAJsc46BJ4rasCmkgN/3lcdBbC98qtkpubr4UCNO+ShMKpq58IszwwALKK+IEvPYJHJFqpQqqOrXm0RPtGV4yc5r1jH+iPsd9EdgQbuvrZqAAmxzjoEnithTfiKvjSLarpzNQdL2VvzFRih/UIKM7ASlTGTVrVjJAAsor4gS8Fpmqa/0zC/RdjvtRDaIUpK7HejaGY6bnUWoNKw05ebTcIACbHOOgSeKNzqOhw8yUHj0ypRvT8B/VqALFGPYLkrZGEY3y9R1UfAACyiviBLwWgiwMaHoa/eRKIZorHkDFB3ItgnPUPGzh+YlJxNmzfhSgAJsc46BJ4oN/jcU5cuECbuuQIvxeNL9LjNVvxOzaHIBv6PSodUJNwALKK+IEuQfMfJjMKY2dxFapXmyfMOmZhvq6gflwiiq9pHBer2SelKACASABpwGoAgEgAakBqgCbHOOgSeKJXx6WM0fK4MWGga/zq8sTQCePFv18AVCrp/q0P7KrxcACyiviBLag0qDLlr7N+5ITWNDfAEOiFyDM2wFWqwiAZ50w4zurr0HgAJsc46BJ4qmBeYfW7M2YKvEw96vX+t0YoQeyXudpI2BCxTYkwlumgALKK+IAa77CF3QgGopykI6l2p2vW+8DDs6RAJxbXsikRoaoLwzjWeAAmxzjoEniujUB9rhlWJCgALl90FEmeoyqNgfc9TNUjpzj/QrzHv5AAraWwIUGO1jloY+uMQWkfFCFnlqA5/l6VZBRhje3WYv4/2GxIBKQIACbHOOgSeKg25CPQfkltISw6ymw1rSYeD1UtBNHjgUBgaXKST6EwkACtMAi24FtnqugWBSnaL8Jt1inYMOQU7gxkh/ZSYXZC9hQllG6RwfgAgEgAa0BrgIBIAGzAbQCASABrwGwAgEgAbEBsgCbHOOgSeKI4fhW+zh83DEuLyYlvglqvfZM9A9QnTfV0qHqMzUREEACsz0Coc2rBwFTgqigPxz+ZhV6BEVFgbYJaicRLVGzeR20p2N7nZzgAJsc46BJ4oGSLBKspvS/rSFTW4xDO0PKkepQVbYKiPGmz2ajxmtIQAKmodA2OqbI2iRNodC073JfZ2Lzqa6ZA+tn85saaYcZGhCts4K4DKAAmxzjoEnitjrKF7h7tKf3DB4GDeDn/ooR/4NVKPSikzD4WoqgnIWAAqaWiDEAGpSUrwviev7Xqw1SOB1DvgDP0heZ7pJ8r0RkUjkmppKTIACbHOOgSeKr+vk+t7LPpR7bhLoUTevaRLnzcYMDkGlvwiYJGtxQk0ACmU594eokL0s2WdqTM6taGSr+kdif6aM0oF/4RKHYjki7QF0W2BLgAgEgAbUBtgIBIAG3AbgAmxzjoEniiQwPt1uJW6ZfOm1AglRZiRzu3nfhu9x4sEKsc4qAvByAApZmWyo3QQXIWL+juQAfac3h4tyVmgb/85uqZaMcfyxRddrz2NsT4ACbHOOgSeKqU7hqbTL9ut/slTm/Sjm6yjH30MfInOKbf/i92xqi9IAClmOxQtrNJvyR6CQVojlmAwtNXO2gYHFnUGIvCtUiyBFlwVF4orQgAJsc46BJ4qlo9jp23nsIjoS75CjrO5n620QpLWwvHQwAg2iJpk0iwAKWY7E6X7gUv6vuuKiA7zNog+EhbSx/u7rLbbggpwm4S7PnyXVhkmAAmxzjoEnivJvYu+/kd72DIhEY8PJRTrItwqoeVf9mcEZt6W8mSDDAAo4gKnU32/qE+eAKWs+1qYwDzwQIVqO7BmAuvDODiHfprXGFRzKmIAIBIAG7AbwCASAB2QHaAgEgAb0BvgIBIAHLAcwCASABvwHAAgEgAcUBxgIBIAHBAcICASABwwHEAJsc46BJ4puicVaNsGrR9dJz7PZSvnCD6+vZwJIHUuKKTkZYYoNUQAKNCWh0JK/kUwKHjm+JR/vR5PVYRzwcebXKkOSx2WehnI3RmlsBM2AAmxzjoEnin+LaSzkOW2XY8vDzHTwSFOh/XAgL9BG3iLkta5Lf5i0AAo0JaHQkr+uCFUSYWPFdm1F/9GEOjIh2n8F3M22LoguCcyD+XK1KYACbHOOgSeKeBGGM5cjxbdVKkvZwZroBNmR/kcoNOggzEmXAjyjmgUACjLdBnwQdSNgLAvVblGYkPBQksOXngJ0jubAuDjTYc3HM3VBGKy3gAJsc46BJ4pvW/hswh7YzJ5nBpVzKp0oLcF1OWLbnqZk15+SW08xtAAKMt0GfBB1MXInxuVkaVLtGOAVtw9q4AjLdTYf7T6c7AWuAoczv7GACASABxwHIAgEgAckBygCbHOOgSeKyhqn3Kf1S3lvVoSLhR2F5/c6duHU4/w+PptCIeTC0f8ACjLdBnwOtyBprPgWXH0NBzElpRPMgIpnJotOwnqAVx5jGidb4EdCgAJsc46BJ4rqmfML4lMNns37SIwFrhkOwHe+KEWbZj62VM2NpEOOcwAKMt0GfA63xfAScuaOvUGMOmN+W+2ROxv0HmLQ5ulP8YAvZCuOrj6AAmxzjoEnisR4r23kpZyr/WgzfU0jOIfDA1tfmFTWehw21ID5W5auAAoy3QZ8DdbCtuFkIXoRWkuKUeJPntwfl1qzGJnTvDs/gEbwXqyojIACbHOOgSeKWW6WZ/oYdyKM1fu6gWHKIfdx1Lu3Zq7fE/MICRBv1TYACjLdBnvwLft4pnpf0wGtzyPpgdWRFExJm2C9GSoXLYlVCPfEfH5vgAgEgAc0BzgIBIAHTAdQCASABzwHQAgEgAdEB0gCbHOOgSeKa3+5V5t4YHxCU1a5eKr8JvYbRnPNlcxYyBUwlWuWxGsACiB9RbLe6HtMBYwMP3RISyx8rUmD7WUGPzc7wZ8T/NMW5oo5mhKCgAJsc46BJ4pAUStpR5NKBP8ACnQz2a0gJ1wyotsrF3o3sjhaEm+K3QAKA9z0uqAUs+KMK782IMX5G4wVI1gSPoQVhqgmfQ0XTZsJOtugSKWAAmxzjoEninQ3+zWhjoZ+N8TcAZuW2RJNGMEDFd9vvtuLoTmFWbOFAAncig5obPS5hxKQ1ptPLWQvnQkcLGezQ8gjHMtvsNvx64mP+xI35oACbHOOgSeKVGLqJvNCrY9HKNrHqaMCat3x7avu/WN6MzeiYSr0Mc8ACcjy7z9yr1wEgdL4ADP4Of0VTE5QszjG3gpbfhngLBaiB7NmkMN4gAgEgAdUB1gIBIAHXAdgAmxzjoEnilMy7PEgumEHtZNmqIpt1SThfqlpijTTPc11qjgJPnmjAAnFDGLVz+nzduRhSAU8RsTMeQ1XJvZJW96H2JiFbDJcFvsNXrX+m4ACbHOOgSeKpOrcOT/LHjmFBXtb+8Ts2w9gm3YDWyeQwIzjHSdzMj4ACbKsIEwBWFguKeyHFfSfwkx6ObP233da05fJ5n32MyrMdV4zGZ+QgAJsc46BJ4rRW9hpuFThJI35JoWU1AurPr/pimufnN7Urk6eGc/+3QAJohtMr3ociCe9SpSZ2NJ6QhSNAFIda8hFShpk/0Supf9GvVE2eQaAAmxzjoEnivq3tX0iAptADLeLmKuwoNVSKLnGmyCjfk4Gyo7kuohZAAmfEPNAHdTfXY61UbcOsIE5E+OygzPGMa+ZX0l1eqBMwhutzZ1ALYAIBIAHbAdwCASAB6QHqAgEgAd0B3gIBIAHjAeQCASAB3wHgAgEgAeEB4gCbHOOgSeKqNos8HqY4FMlLcnYJwZZyKZfCyDiCtfsKByOCginnzIACZ8Q80Ad1LHs7ckSzvc1YnkEjVUzsAkwbLV6E8OCp/t7NE1luIzDgAJsc46BJ4rKpWPCeT/KneYqlx20H52PW6GEz4DShrvc+F71XnFEbgAJfeob5gSzbfIGUfYWBKh2OIKFbtw0hN9rZRPpks3oSnG8HRx1pyuAAmxzjoEnin/5D+GB9v7B3dDC5S1ORfu4GbmgDkqcxPELqZF6srDyAAl5DOsKjv8I/75z0kUmy4qP9fex92jofDRIM3SYvbO2bcr6Zl4XLYACbHOOgSeK89mMtCdEy+1PDkleQsiE6Lt7B6DowzodngeC0lgcB9IACXacX19Fujm7L6gk6FR8FksBSL0DUpkIxWGIJyWJeQLIko14QpoagAgEgAeUB5gIBIAHnAegAmxzjoEnihfEFAc7lw50/dMCp+oQ4cTvzTWSyMjVt0jHIJcU9siMAAl2nF9fRboRS66/YVUm5ChcteE4Q8iB5eoMrR+dJtIiAeoUBYlDzYACbHOOgSeKuei9gNldE7a3fPQNIzDI9YZ8A7REvT44xgAERhXs8/cACXabzEqA+KR1yqeQm+jkrdbH+Q+XEGzgTwmnhjKRugOx4oLpEBI2gAJsc46BJ4q/PXMXItosQW4aVV3L/EWfK/TRX4iidKlK3iiPknKz/gAJahkjAdp4Qls7eDgTSy+mPN48h23+bX0H92CkzBBdWNo/GQ3MEV6AAmxzjoEnikdnSI1zTl5bCupUd8d1YbYaOo2KoF6SUb/zmil2qmTAAAlqGSETXxAdAINSD8Pqc8KXz4AcZb4kpmXwQkeSoR1a43HHgVsKDYAIBIAHrAewCASAB8QHyAgEgAe0B7gIBIAHvAfAAmxzjoEniteXDO4c5trLlRC+voWUr6LYw2O4r7055fMIWqldIWxNAAlp6CsP3334C6dnfH5hal2j7pNgGBwe8e8GLJZpICDo1i5iba6vx4ACbHOOgSeKzrqWcqYQxyYHVtSalr1owSD7uGA0O+NvhGNBcC1dUocACWnoKTP7/RN+hr/Ri1AM2pHciMTBkQNnZxAcCC0Vj3ZNDRUlq/wIgAJsc46BJ4p8R2LMTFNalY7XBe4ZltrmxxPJXqYpi0G2usXLMpsvOAAJaegotzFcqsLU6VDOABibbNLp+eJYduCC0jr4Ohd9gn/K2JGPMWOAAmxzjoEnisGJ+gBs/2xBK8dkP7OjXsV7YPS7YsJ6IKCVzrIP/ZgmAAlp6CifPAOrwnlUc7m3ivC90pO0QoNmQpRinhXR4Xu1+0jrTkDstoAIBIAHzAfQCASAB9QH2AJsc46BJ4o+/5/cUNMvtp4wE7XD8Bo0fK4zR3i62+y0XWz0S5TLbAAJaeTwgeY6hSFnaSN6y6xVGRuhbOn1Ta7PIMBSEPZ+6jxVfqNB4biAAmxzjoEniltQFD3ECYeHRAMz93/jV13770cI3ZpFqaqoWIL3g9/TAAlp5OrX8CtuYC+pd75WpxFMe531okWsR2PRhDSRe7QtAMChCojN0oACbHOOgSeKIiIOgMgnRPcU3hFLUWIG9yK4ip0GjlOQslQ9nstwfGoACWmWtTtRG2o5bSWw//gLXnzVZrkHR/WB5cqszjUza6SdBXqi9wqzgAJsc46BJ4pyZv1SFN4D/31wWEAVL1wJm7D2K4AGJVQXyK6iq1JApwAJaYImisPojtK1wOdAKDWrNSbbXmiVR593OtIabxsTA+p9KIHTBZuACASAB+QH6AgEgAhcCGAIBIAH7AfwCASACCQIKAgEgAf0B/gIBIAIDAgQCASAB/wIAAgEgAgECAgCbHOOgSeKfcCM8NdRvO/gdcmh44jhKMjC2vdMVm/0KfOfdFUx9VwACWl9s8lCZtSd2IKdiXv+GvWYHOAJMX9f6gKvxRe3uUWF8tYDildjgAJsc46BJ4oZ77vn8lvA3rrbXcFeoDhv1Z9BLlsf/f3NnAmKyNf8OwAJaHVZyJNyBpJFA0+JerkoQrhr7i8tayVDgmvDSb4Yo8Ik0Igg6kKAAmxzjoEnipjYkYfMBGCGraHHMqMrXFjhfWj25MFIC1jPOUQCJgudAAljPjqI8e6uxffshQfw7oDfyT5wQK1Bmz8DzK2ANLBAifxz3KRUu4ACbHOOgSeKHaKPCGKGMJf23+yVv7oqfLzJxB59atEnznND0eAnLl0ACWM+CDre/jvsNCHCDtV4WCG7tzs9BNJQ0mzA6tE6W/LpNuK7FMBcgAgEgAgUCBgIBIAIHAggAmxzjoEnikRuN5WZR6gjnwiUK4ZzzNYJhzrxiAAevBCe+Wzspy9mAAljPcsHBLT8FssGtewVwnHyoUwSdM8Nq5eiKg6FKuAwDWua9S+aaIACbHOOgSeK5JKgGF+Pu29qhQpGZ/plXVPCDw7q7YO//MfZpPV6vKkACWL8uPElSywJghCzudmkg8guQPzwuwezLjYa/eadnEZnO/fGkxrZgAJsc46BJ4om/HUyGIYYkbZ6Ak/c03T9rM4RuJ+JWB8K+9QK9EFEpAAJYvBlZdk/h60rKeTOPzG6VqyXJzdUhfYBrUZhyfwp0VUFjUOgshGAAmxzjoEnivQXztc9Ej81sITieyrctWKR3KX7Eex+tnLq+4qMV6BfAAliysDLymTS3NlY/o7v69easUv4za26Q48yGGy93lHvgrJhR5CQwYAIBIAILAgwCASACEQISAgEgAg0CDgIBIAIPAhAAmxzjoEniiAw73uDVEUL8bR5bDVgg0JIrrsoV113khp8V61Vxcr0AAliyruQLPRP/Wv/twToUpLPFpLfABVannPvKrAC2dYlETjfPxsO9oACbHOOgSeKJoeUPwdkmb8oTLrBtdLVenzrrLgQt4Mag77tJJZUPzQACWLKrGKoXsGiovrWOHysUPHMNVaTcr7nR5rttcxtfQgIi56oCTLbgAJsc46BJ4pbR6DUkbxE4s/We14sVhJr8OvHZo4chMxJklvOpm2FMQAJYsqnW77N4zgAqSHKM+GEq/FYQnvqQaMnTm4gs/rkP0oLSJ46t7GAAmxzjoEniuvrHWIhdeNQ0v/ZKrkCp/n5w/t+jGS9gEwEKwrYg7PuAAliykRRvs8PQyFCA/ONqno3a5D/jVgWC/2/YhXzvj7u50htBLr02IAIBIAITAhQCASACFQIWAJsc46BJ4pnIYA9R0X8vcp+pbD8jbbW5VTo6O+BmzqhIYcPpCF9vgAJYslfuQY2ktfvgtIz+bcvn+P8OXLKU41W41ZxPCCzuldxj60QbuKAAmxzjoEnigZCM0lkYaYuSozz3QnLgzrHmKkXn7yIybs4dUmBv7AAAAlhLcdemGbCvILnQRv7NfoCHak7dFJBDGjQyzn8HwHutjcHL0j7s4ACbHOOgSeKjJg1BQG/7Gr9uW4TV3vDsYf1pSWjPCjhaPwS4HMrUKgACVJixlPfiKwRdNQ8vw2XrpDIo6cL2J9zYEWnaq19kcAbZRGox2SdgAJsc46BJ4qGDqi6PP5UxHUwqWYJyLxyTsPW2snvgAqE8DjVharJ8QAJTSLFz0EBkLzim6e/yeQ61gti2m3QcWEREz2ueQ3Ohbn3mM+Ec82ACASACGQIaAgEgAicCKAIBIAIbAhwCASACIQIiAgEgAh0CHgIBIAIfAiAAmxzjoEniug02IYlFUgOfI6McGGvaRDpaGGYwYmb2FlkQpHS7pS+AAlMNGsjdXnT39q3bua7QUVujfqEvK13IlIbtbaI7Lv6kVI/SK3rzIACbHOOgSeKfaQlmWg3QbcdDsQ1slomhXeeeMTnLS3CJ7UgigqHYwsACUw0DiwprDWHye3J+CjMi8bc+nK5U5ZuHxtaqyqPcIJHFkPPV4rxgAJsc46BJ4obNT8bTUclO2EFLen0VWwoBv91qan2WvBET3DssBkueQAJTCgTxCecgo7khp1zuGeMjvq9wmviSgwC/0Zoyp9non+BCBpb3XOAAmxzjoEnihf6dWQ4TdlJP3GkW4Eivgd19E1PCpIJT3/WbTsxkMnjAAlMJ2hxPpjH5NdfEKSiEANLzC49igccrHQh4nAxjtIAfHPq83G47IAIBIAIjAiQCASACJQImAJsc46BJ4o/kvaqQx1QjEcDZU9eiwUq7kMJuLEIrRyK5ZVRD2hJCwAJTBrx7D61lqzESNg0xkGjhi/kerRPWFnGy/FXBMR2kVzmdLVyTB2AAmxzjoEniojMWFy4S6s9QvH5dmiMjOrRG8I/c10rtAYjPPBYKbeyAAlL/qs8df/kVuehALAcXnAmjVp0OOFJk89SFAW9VTzuEPZ7RpeU8oACbHOOgSeKVG/kWogad872UH/DW7t6uasIyTE+fFbSHdtbsTZmjEQACUpWgXO7C8WnhRNRyWIZLeNsTRT3xIurBbL0fiYfRpDY7Mp2YAb1gAJsc46BJ4rASq+9ziO39wWFq8fxrwswN13HotmsVuUbPat62MN+rQAJSlaBc7sL6WxB0+YgPDbA6qs4++JOnuMFgWPqQWbs1VxyeDHh6pqACASACKQIqAgEgAi8CMAIBIAIrAiwCASACLQIuAJsc46BJ4qJuWZmQjSli0tIWqLbAgSiyzsKZZkJ1f6fMXr/zoGCswAJQJ/qVUuRRdGcDC86KYER/698kAgaoTxftQz2vODQIAS0rnlQkrmAAmxzjoEnim16D9dN4/oPQwVsKGKyDkEWkX5mOeOo49+UZUfVzXwyAAk+GZCWTfOo0yjkJ2xw5t0aFZYMLYDmxVTvEIV1cjeCsfVQjfKN/oACbHOOgSeKwOk9o9y9vpnLdbmuQG6XnK1YyIRK/iaeZ5FOsTW1VeEACT4Y/YGJMWGte73pCXR+ROhiAPmlFW7gGCgTZsjoEMpcRKYJTiXzgAJsc46BJ4q+1d1rL8amPfHAyiQtBHTdZbqt00vFv2S4g6COyg8cFAAJOuFRCkVLJACTH/OYV3DZU+IsLh5Jb0pSk2N3cwwX6srjZYbAGXGACASACMQIyAgEgAjMCNACbHOOgSeKfrBrcbZaEBdP7nWAWospq3gvil+4QTbiolcvvieEdikACTrhUQpDlJbH3BfrL34xUviQCvN0tFeUsr+lWtbe+vRTEX1jomDigAJsc46BJ4qKmtRKtzqwWMDQ7+awBjRc0yUfSHrVP32E7FsBxQgjRQAJOuFRCjk/CDYiRuzBizLWz1Wz005Feo4/HLTaOYTQXpiyCkMBUUuAAmxzjoEnimiSkBebpi8JPy8VCUx5voI2dUDrG8k9EbIjeXcj7MXjAAk2ZH5IXyPR+FDEjSGN6s6KWKDRWoa6I+j9EIkdAwEwEmZrlkhfKIACbHOOgSeKcHNrpyuCMnru+qqjn4n8VURSwwQslDNcTa8btMvq8/cACTL63IHT8n9x6WxmEaeacUYE+gl3AOlFfhV/zuMye2DPnepTeaDYgAgEgAjcCOAIBIAJVAlYCASACOQI6AgEgAkcCSAIBIAI7AjwCASACQQJCAgEgAj0CPgIBIAI/AkAAmxzjoEniu+lxnC48lFOO7axyTuQtsaGqRsFws6lgm58M83woGvEAAksXmMVtc5BqSSy1m+9MmrUt7yXhQEQrvp8m5j5xrnh6mn+/oaqIYACbHOOgSeKfVpFNe1r6Z018FQubuQLUii3pRC5aJ4JOCJRU76pCGwACRmPbwpcgxzziRnV67XK4zBeywO5n9gQ9VuFEPCAiA+vSUFmUTXAgAJsc46BJ4pr/Bnnpg0SUiiXX5QeQFT/uRSfA3d0S8+VdDRhMjCcfwAJBFyOkVnXq5KYZLveuEfAie7M8qtVx1ko+cnLLE6St078opEdf72AAmxzjoEniiotSSXipZF/37BUByDhSZpQhG57mMwuXhYMhDs0Q6wYAAkEXHXurJdOGmovidtUGnCjy7TmPukKs6Rfc4xhKy/wGkRt4RGvv4AIBIAJDAkQCASACRQJGAJsc46BJ4pmkLq1lENqB2BbRKLJ9mhLCs0w6wFAKpB8HJkIcS6FEgAJBFxmPeziP+j4FoQGfnTdxyN1y/HM/DlP04yoIpHyRTel/h2qeQSAAmxzjoEnioW4v9Tq7G0MqHcfkkUWnmxfLOoM9IXmwHsAXvGSuNE3AAkEXGY9qzkhHlNaQapFwl9T2OrbhYaH292v9OiORuW+kpRivosrvoACbHOOgSeKnddwfHWGSLzK6SdGS0TgNMuTcWnwNstqHH+JiwlgWcwACQRcZjB+R6PaxG3dTDKnGAGu1Ycfroh9KKBRh3ZU9bVIZHqNDpEqgAJsc46BJ4or9RH2mcSj3iQuf7W5YRvi+niWDws+cavObAwl1xtOSQAJBFxcUhrOwysFzszpVTdMMDS9OpVprqIxrWQS0qRsAcKK2vid1CmACASACSQJKAgEgAk8CUAIBIAJLAkwCASACTQJOAJsc46BJ4qE9eS1zn4ygda2XaLZhLj+nwkdYY9tANhOYVw9vN31aAAI83bOGJPe46oipOrD7iZL8qPA8UOoJyw6JYSIPSE3RbwDq3dKzUeAAmxzjoEnihGzyr/T8aOihBub6sy9KhfR+XhhMb1ntq9cYdL1a3C9AAjzds4Yk94erW/2TPUrzwsJMzq6pCDyG9lnwViO2/x6LfL6zpDv6YACbHOOgSeKER0MSGqMvU9l0s7lxRao0Rlk/OL2tBhm+vEcEMNU2OgACPNzW5v3Ug7bTNjnVCfRZJ++wkqmpmZcGRpuwaR5n2f/UpJ0D7OZgAJsc46BJ4rXrct204gEh/6LmBEuP70wDmP56NPLHIUxASmMUYv7YAAI83Nbm/dSPbl4GFO1eJAFdQB8FK5ViRZaFtIDXMF0ahZvZiIO/NuACASACUQJSAgEgAlMCVACbHOOgSeKs2Xjz6V6rIyI2tvUikjxot2FXLDWWKyiSCDfj83EkUkACPNzW5v3UjNrx1FsEjhLe5WOYSVYwSZubWe64yHT38CgS5vD3DCQgAJsc46BJ4q06LgyZO3aSuFal8LhDvx0ehNNyFO9+5yDC7SzHs9SZAAI83Nbm/dS6fW9bfFjp9N/DLhWrlqzBNRgXyUmn0wmsyzOzYAtPj2AAmxzjoEnimKSXwVWSAb6G4xXWGwhIQMq3DCzaS8rJpdyqPl6c7yTAAjzc1ub91LQlVzp7ECyncf2zaZUEPR2a4oD35q9j8KpkqAQp0w3JYACbHOOgSeKmtKu234inn75qk3og8dv6/4gk6PY24BEuttwEa1H9iQACPNzW5v3Uo1OFA5t6KLSDEn5O2dBfD9HBNUgndA2O1xuWByislVegAgEgAlcCWAIBIAJlAmYCASACWQJaAgEgAl8CYAIBIAJbAlwCASACXQJeAJsc46BJ4qjfEUishaAXDmCKJSEZvCgk9WPSzJoqIU5lrD7a6djRAAI83Nbm/dSTFmL6Bdl7dwLCtOYlVVz4G4zeTafRwMUBBBPGH91QWyAAmxzjoEnirrMMKFf12Ra35xBQPk2rY4eIb7fqoVNSJtEuh7pqfSiAAjzc1ub91IuwAQj/gYQYBjzgmVlLf7OoAoet6NBweuPXZbT01cI6YACbHOOgSeKnjctvEFs3h95Zi4M4fPX4yFuvzSOJsa4PsZJReR0uu0ACPNpBKvMhS8px6FbH/Ml3YR05LvBAJdPMykpbuECuwR5Vaq7GDx/gAJsc46BJ4rEDwCi/a/ikWdEZke1RzFH1ZmNztnsNtbBR0AMpB++gwAI8pY2Qc3D6qoPwC9BR+7VTZRe7WpFlN7zAPieoen7ArxlD+iOfNCACASACYQJiAgEgAmMCZACbHOOgSeK1+DT6rQvHdCbysjXJNfZBCHHxZKYw4vSswTBoFQM8wMACOsc9TisVl/9d6Gji1NsoYPDa0zKVz0uDi41vHWYYWQBwezClrW+gAJsc46BJ4r9UmtzFTqweHboUsu0rzbsJY4P8pneE37zQxDZvm1nfwAI6xz1OKxWf0DLsnYghCuEUMIFX3GAQqBp+d5gbDWGstfBU8RbUSaAAmxzjoEniqKTQXrbJO/wFaC0fPGnrL3p+fJS5Bu0YHh2T13mj/LHAAjrHPU4rFY5oxpD38+nk2V/lJgyQic6/X0PuaeZtFyhlqc46PxQZ4ACbHOOgSeKL3yJGMXYs3qC4slMzrSzCalTmPEAIESViekGsHr88rsACOsc9TisVlwOlMFe4dEoVZeF8rwfnFGyK8eS+TQx0A9z0BrUFQGlgAgEgAmcCaAIBIAJtAm4CASACaQJqAgEgAmsCbACbHOOgSeKfQEioU9F8SUmvleW4giZBjEpSNgwH1n7OdqAYuKBspkACOsc9TisVm5sPEFHWdvB3OcZqYOdg5jd04x2ITVyIqANTsfPiM1ZgAJsc46BJ4oCLMb23tuUBEJjlVaGh53X3FXKk+K93tH+k/qAbsvOQQAI6xxiI+eUXFujrVai0a99T8KSWVxBvMq/EQZcA9frOgu3rLfzRQ+AAmxzjoEnihmOzpsfCI9xy/7guERbSBm8cA0s+JzEd9+BJcwZOhxHAAjrHGIj55TYDvQAxP/8+9DXJqz92zTPJ6ZHQNqHrHbjXNYsvNCPuYACbHOOgSeKKBFOMePT7ctfOgCghLxvpPQvmKQEmu5dTTlQ0GuY0TEACOscYiPnlM0dGSwCkpdVoYXEiqjwvRWLpPmoeOnOZpNgoSTUtL8XgAgEgAm8CcAIBIAJxAnIAmxzjoEnisOfFRUFbqFFt1zji4niwhb/LBXvL0s9hZB6utpq4P4hAAjrHGIj55R9PiRVImkzzHjx42EVy0e0M02mqFkSpqi5mn7sL+OiC4ACbHOOgSeKqjR0pNB4mjnh6kp8YRIQITbWGtRB1Mtf3vuFQTuUuJAACOqSfqtxuDyL3G6wAgIi2KEUoLEFYzfYFmBnZ2LuV7t7bYKQ4gJCgAJsc46BJ4p8bzwrCI3muBxpy7UFAPADYlkMe0R7zQoCl3xTNatx6gAI5vhddd2O6QshXA7JPTqxGIoKy9EUy7ngM7eY8uOxSdPu2zwWyfGAAmxzjoEnirvJseGCsHX0XQXAM4H/j+TKzmXcIlnYvJTPKH1kXHBTAAjWWnzqijI9SxAhDtyPKANR0jLQ3mV679DMyfgw79etssRJfbg6EYAIBIAJ1AnYCASACkwKUAgEgAncCeAIBIAKFAoYCASACeQJ6AgEgAn8CgAIBIAJ7AnwCASACfQJ+AJsc46BJ4rBoejzQpMBrZWjQkeFPtTha+psp9bsVPV5yvgYMZJVhwAIzf+JtgZH9a7ekD4EmdzJfQ4QKV00CXEHYWqOsDZfFtan+NOUYqeAAmxzjoEnivuQUtmOMRGHQCeAnArdVF8i3mLPmwGOwOuS+dqTtLo7AAjHY/f6aXlkPJriyI4M61hCKRO0RdbPe955W7ZZ1kJksGEUp0/2IIACbHOOgSeKJ0IKj6k8G3D5xv5OmlCazFuM0L/zbvV6xKAftxX1gfsACMdV8XyxBkO8eP9PexgQPS9+Gl0nDUPON7Z6+7GVsE8tVlyW8EaxgAJsc46BJ4pwBkhaBCwf8oLl1irgsyQhJ4LsNx3F2EuuXMVgGU4GugAIxsUdloHpEqcQNpC0arW8N2hPKofb4IBYkkwl5iOkWcRMRviCVMiACASACgQKCAgEgAoMChACbHOOgSeKud7q1enqFNy7ufPspXQYXROPrjmSeyka/oprIzlyhywACMawNzTXf7+/lMGYrpAJIO+gSyKv1rTOavg12rM50C0XvDdzX+4SgAJsc46BJ4rg3uJykBWkO67+VFv99s4fMJvvshm9DITbF811LMCIZAAIxnb76h+a1m421JiOo5iC37/jMcS0NYYVhfe02bv8q+Lxh+5LldKAAmxzjoEnioUpN5iEi2nIGJrwpoYKiG2qRVPWYOBqs7P4JXAAzM/KAAjGNBzNU566bWm1S8mQoqrkO3wtD9r8mbrqk25kM9MhENWuH7LCoIACbHOOgSeKvivaTEqVYdfwSfkIMLFTiIsmpt+GpHpa5ybvC1ROLOEACMT47yKRYYiqeQF4zIJz+LbrZbSn8b9dmVvpKbzZF+X8F4yYt8C0gAgEgAocCiAIBIAKNAo4CASACiQKKAgEgAosCjACbHOOgSeKoDG5dYej/FaiJ2Gfm+ul8IXiao4x13ADxR9Sy1c90a8ACMRHxP+EFMQLBNazngDYzQlv3XmdEkgApdX5qzALDrsna0feSzisgAJsc46BJ4qs7MPfi4oxek0Rvw5Rldyewe8XxY7Uhg2q54CQmnBEegAIxEenSOdTz7blr1FFCFJ+3IvVc7PvnuoJ3XIn2fMVDU47R9yH8Z+AAmxzjoEniuebWJfn9m43qVTjZDG1TXInSfe2I3etSmPpUqVHQglgAAjERxQ0IpFAN5zTdBwabCzMlhcsFelUGuqd6u+Zwp8hyT9w8sFIT4ACbHOOgSeKBbrlUxsq1Wqa3UB+Ra/sGonMTUQ+YTww3LE5dKff8iMACMLmbZUrPCYMEWAUQj/jP1tqwXvCbGhB09Cmgmn+aouRU1EgSpbGgAgEgAo8CkAIBIAKRApIAmxzjoEniikaNyH1FZdAV5y4l2b96BceQJlNkCyKcn/n9WwxRR8EAAipH0/BM+OIaKaxPNXzBtNyv6NivROkPgcesB6tXU3FOZM0J9E0SIACbHOOgSeKOTfqcJQPQrF17LxedfHLIv7eNfkhwijqdmry8G+uEWMACKh+/G566yysvYg2K3VOhdaFNZRznCJe5BfpRPGx0f9Ygd8CsEyrgAJsc46BJ4oTRIEXQYAyaWQzWuyrSmMMRRudCLkqKNzg3SCKeO1HKwAIo2SFowFjkYm8ft3OK6udHlTKPuoxAPOqzFnGkHLcXUY0myPstPyAAmxzjoEnir7Cq3+FGC6vq5rtxGq2T2hzdLPXvlfC/oWvlsAo3P56AAicl63SMXOcGiKWGo3m5ns86jGIz/eGoAmlv+T++UASGaofB6zkIYAIBIAKVApYCASACowKkAgEgApcCmAIBIAKdAp4CASACmQKaAgEgApsCnACbHOOgSeKW+rIbYQHel/HT8JbdO5LK+NBR9pxIskkHaFbeC3n38MACJyXrdIxc+4+iuV93cEGCNt1hiJAzMCa09gtOKn4p3+gKycZR75wgAJsc46BJ4pVbE+vb658K3KThGYsBtkhbdJauG+coI7xGhMVjvYAwQAInJet0jFzjwjXUEms64jzJAftvXBLhHH8br1TxuBuNeZQkLLAsP2AAmxzjoEnig3zuEwLkrNjOTi3TI0WHGiTqBpmX+Z+gqJ46qVqy3xrAAicl63SMXPo35RuKB7dmW92R/vd7tuOGvPPu2jxD6/7OloGan+4PIACbHOOgSeKtsv63s5GzK6895T19FaxowtbQhAwerymP+ycIik2SjYACI92pb+jiT5bzODpZKHz0cz88qyHQ2ml9EarzS9DD9bdSXAADwBIgAgEgAp8CoAIBIAKhAqIAmxzjoEnigKCkhgqNO1Y9NOIU/lxXjCljVGaR9sdnRJUC6Qoh2oXAAiPdqW/o4mVxIftMKurxlYH8SNfXSDKNmTlbUwUPl7Fetlc3isQGYACbHOOgSeKQcpwZ4x5sm/JSHGmvEvDlUDrCbEZes1aub93CQOVONwACI92pb+jiZQpo8we4gi4+VUrdZONgCmrZ9LUaeN67yOZQ/Zsli/2gAJsc46BJ4phueQGj6gXs8s2ENUH418UbbHALBv+Y8K0f6qvCmeB/wAIj3alv6OJv0LlvbBIBFtyP1XMZ3CSlZZa4smPpMlWURXfxhrSVoiAAmxzjoEnip8JSzRPSSB7CDYPkK/7YW3jt3T20Ej70gELWq4GfyOVAAiPdqW/o4lFeR7z5uC0A7TNPLkxOnHtVb+UCNDTLd1g55QnTC4/MoAIBIAKlAqYCASACqwKsAgEgAqcCqAIBIAKpAqoAmxzjoEniqDuUmdiE6L9MoEk8jAXIRL8daABlFtAKQSQ5ddeKfAxAAiPdqW/o4nLhbdxJP4tVKL+DDu/ZLYZO2iG+xeeTVpqesDLBL3d14ACbHOOgSeKTbnZWrmw4jBBSb23rcVjjZrv9P920Htkd3dt58miYJAACI92pb+jiY7k8L/PfvOuN8CGDoEI0t66zJeHICHTQYIyWMKHHGMCgAJsc46BJ4pROhoo4PM2sl8TqoRe0BOAhk7zd3holXjeSd1Fxz3OPQAIj3alv6OJE4aznnNPQSDACczoLtJEIvzAhn48nFoopqErivxA0iiAAmxzjoEniknulE5JdCKVB0QMJ8a+PZKGGLPxqCfO8Y/8huhvBA05AAiMc96GKPPwmzbzKDc/zYdRg8YdjIG0ZrBJoBnTfX50JlgsSj8c6IAIBIAKtAq4CASACrwKwAJsc46BJ4q5ADAJbE5ZRkpTrIVzhniGrZIYO4PZaWmvVUj2o3RlKQAIfz7vzztjcpRZBtGNjUq1/NZDVfHsr1JzHcECMUTilMMxXPUg+peAAmxzjoEnisNzVEriTae3Xl1NQRZcsiBCB6k4K8o9Gg9EKPW2AWukAAh6OBfMNtBTX2AcLrlaUhfUzJW+B3Z73u/2NXQ4wDudO4WyI/t18YACbHOOgSeKuX+7f1JjsuQ90libHKYE84e02ZD6tYTMHK+NLMZ6RaEACG95HplK/ZEOFwicZI9wL1Nn+ecPdSGrdsOqthJm5lHHH0jIrYyFgAJsc46BJ4r9pveEp+K12O1fipvmErEv9JzkFLyV61CwvZWTYyqxqgAIYm+9F4UXSO+0mCJfa5Z6Syf3EKGhdaJAupyAbHoLttwkHyq12ouACASACswK0AgEgAtEC0gIBIAK1ArYCASACwwLEAgEgArcCuAIBIAK9Ar4CASACuQK6AgEgArsCvACbHOOgSeKgt5kLXA9ZAKp1yn7Igay3buuq70mZM0iApUDcz8u8AwACGJo15ihKSftueWu4zFqQIWU6z9bJUavfG1RSprKDeTmv/VzsJ/MgAJsc46BJ4ohyAC9ZPjKiVYM8ovaRXuehTBRXcp3Pt9hxS3BLrOnxQAIYmjXmKEpduwM/XSMkuCDFSO0rdkJW2vSMBfnN54BPEol4x3bGV+AAmxzjoEnimT1jL2z8sHsWiANqGUdJhJULlDaqF8L+NLmZqGBq+PdAAhiaNeYoSnmF0f7/AXUe3gQVHNu1mTHT0stuX+cw9SMZ6GyZ/uJiIACbHOOgSeKkHXEdMRG8ASa3pF7AQ0iRYh2dGxggW6LBuVCLYaZr+UACGJZ53yldg5nQrMlYOh094K+LSpJNymkovDAJQ5Vqs7YbF+f03vegAgEgAr8CwAIBIALBAsIAmxzjoEnitxJrgPpbmMgcIsKE1iUqblUQC8nXQ8OCHcJwqwDQvMlAAhiWed8pXakguoQA5APte6SbJQpkPZm3P0iITeqGaY64S7tNXTEF4ACbHOOgSeKpYQj8deDIgUeXPwsKhA9RPTgzHUKJ6h2kot6GmQjtJQACGHJsqVmG0zpzt/ucrLP7S5IvUC1X8MCQDUkwE7NY+Gqwe8yxLQ3gAJsc46BJ4rca1vNYAZDCzoU78h9OkqumLlgp1ykmXMzqmKttCcTegAIYTcw9WjiwmHgzRqovLMqs+LyLMVQ2j6KO2jLL73cAF6J0vbTMUeAAmxzjoEniiB+LSftWblqc3KTFPHpyXpy17j18tBssop80yRW81o+AAhhMytkB5STozL6ZbNbzGwmwzhDwQ1y5UQbONuGax9hwbJKhuOlPYAIBIALFAsYCASACywLMAgEgAscCyAIBIALJAsoAmxzjoEninPL3B2uy9cjIJTNqd3DMPDWPvklzVQb+udPSVipi66mAAhfMq6AyNc3nxN3YhNz3anogcu8NrNUiKXrWV0HMjdr1Btj0ccxt4ACbHOOgSeKAmLAA1DizTX5Kx0e8TdJlf2CpJmIi7iNOUEa2RIYTsMACF8yroDI1zyPM6SE9HQq4PGeCGqAN6EhLPqE4RtLyVRzP1kRluASgAJsc46BJ4pbV6FciYuEs5qKxVE6x2OIlmLyDWbVyxysnS88pUKVpAAIXzKugMjXsyA7B3j9WeGETWPi4GRtetSe1C+kUQRMWq4PK7faZByAAmxzjoEnisdsY3GFMx77+2TvTara6mMbBt1Iivy2p3ZZlGWlTHGUAAhfMq6AyNdGgszZGIjMjCYc6HNd1MQ8HmfeOVhud9yDQO97eAVcCoAIBIALNAs4CASACzwLQAJsc46BJ4r75a85Dzc1aAZmKqyQ7ZQg7fNs/GrnHCzwa/St3+fXwgAIXzKugMjX+tFs06sl1lFwfLO4YL0uxlPsUOZQKz1Q8g6LXpaPyT6AAmxzjoEnin1teEV72m2IYq31tfxKgqUV3uir2kFPXrbnvsI5AxAAAAhfJ8P2LnLfze9n+lSQaXx4qkwFgWmGmFxxCBEG9Df7RbZ90KciAYACbHOOgSeKhD6VoCmLvS3/bc9mcIkx/j+f8S2FM7KnHOBA5qMo3PoACF8nw/Yuckqjg6kimIfrjmKahI4NVnyFcVXKhz/AmIr8O+aGRQ7DgAJsc46BJ4q6QExGlQ2jPfOLqBK1mNBGtQ4z8jXklrXPOreD2ZHRmwAIXyfD9i5ykQcaSuA5haa0i3tIbfbC13gD213WWEQcTuYxotxW9v6ACASAC0wLUAgEgAuEC4gIBIALVAtYCASAC2wLcAgEgAtcC2AIBIALZAtoAmxzjoEniva9PqyMXxPR/37cnvVSVnAV9xf5FvepNXxokhjrEIdSAAhfJ8P2LnKxSAyBWnwP6CQpJejKpTdxGClXtXqAhZ8/9X0yDJk5qoACbHOOgSeKGGjesBWWEAZNCJsxDorqhlTXnFxBUND+6qMuQ21tQW0ACFlEpPk8/bW4LFM/OXfZeT+6AM76sxSrD0c6agbOZtNCW+pcFLfzgAJsc46BJ4p6p8ch3qoM9X9sEz+OmleZhFgYrrMR+pgXFGIFFv4bWwAIT8d5Fyp/ariMMAPECrWy2ma4JoUZRIB0K/DhZ7MM4kOq574HCveAAmxzjoEniuD8Hb/YJ05JJSscX4GC72JhMDcjVMBXZr3gi+oQlvsmAAhPx1Xx/ZBgse2ZEEFLiiHussK2PYqiKq4L9j9D5yVlII02TbsSDIAIBIALdAt4CASAC3wLgAJsc46BJ4rr7nYU+baGfwr40gZxrqvbDcblQ/sEajFFRlbf5/by6gAITKoqjc93C/CBuh5ywS2QeiUMFgNCh/GePMT473qOTQkd4H1f+KuAAmxzjoEnilhDQ/lxDRqMqK+H2JW9ptNdQqyYq5StNjHZNHWe9AMBAAhET2MJ53hoT8R/zGAp7PdFugzw6QRyc0XyIWcDCiAmMgPqAtHtnoACbHOOgSeKxR0XJAG1tzGPPhi+86cLChuwM56nAykW2aQo4zVRTwAACEGo7j24OEfuJH0CzhHFfEqn+WlKYbzUENwoj/j6a0Og4JG/Om1ggAJsc46BJ4oFCuiteCjFVIbtQl2Pdq7csakk5HNe41gXo8IzCsxs8wAIOSKPG0B8Nzl6GtupkfnNnh9j59wqmK8dwA2kLU9hqPW1rgVTs4iACASAC4wLkAgEgAukC6gIBIALlAuYCASAC5wLoAJsc46BJ4pmIw3t6tji/oYChPM8vV2r9ZH3LBmPsYd1qyLiPttWLQAINW1k66gAjpJr39Yn+XDaFB7Z6L7vfKEhq+TcsQqZPkTAXzWmb+iAAmxzjoEnip9OX02ix7H1JVnPfi/uZI/Tkrc/qZgZSD0OBGLYs8leAAgwkreVj+reaPtCOopMxq/6tTT0FpkGgnWofQ/NOw3LfbZDVdElYYACbHOOgSeKOo/V2FQyQIgYSfOYurFYrYwqSr+aujgtFbY/D9sF8ocACCHLYtxNNOZwb61xY+S0ZjXLjKpJQ4GqFzEIjmy9f8xuuK6e6tsUgAJsc46BJ4rmPUdkmckeTYHbeBGYWYwbyE9kQL4OjHa1YekyCWZWfQAIG+xmoa74TnCosPvdwdpFe1WQnTxfJRvX+kFcTEGejjzZ/oRPRzuACASAC6wLsAgEgAu0C7gCbHOOgSeKvifp0gAQfXSiVO7IayVP/MPc04siKR9s4tr8sf1gytQACBvsZqGu+NoIZq9QtoqXP/kqPKq7+Lu5SJ2wrWHiUw+3fb3I2PnDgAJsc46BJ4qCJ0NW/nhuvefDCvTn0OUYVSBz19ukMh/I+uTY6zE7+AAIG+xmoa74bfQDfiZvYo2dRVKgysziier4TDof3jp7zmG8U5RJ+omAAmxzjoEniu+QWe+03SS2JP4MamaREs2N6L/SGv9K0jnnC+FBqL3gAAgb7GahrvhJCk7ePWVEiGVHBb2JUamLlpRRwqcAoqXb2uX1qma5CoACbHOOgSeK0aF09NX+o06ASYd3m9oTatCdeAJJzlM+EEmGwvx3RzQACBvsZqGu+DKcL/F2rKUkghDINnORwnI9hgw7WfJYKQGDB0GlttE4gAgEgAvEC8gIBIAMPAxACASAC8wL0AgEgAwEDAgIBIAL1AvYCASAC+wL8AgEgAvcC+AIBIAL5AvoAmxzjoEnin/WT5IjiLUNPe/Je/celsF1H//gXMVs7hkwctSbTV7qAAga3kFPgOsNTba4a8fwJUTF2r/fHnWOO6Zrpdf2WS/lC230PuRt3oACbHOOgSeKi7LRQkZSq8H+0iHAVOi1tSMtnMYTLXjeI9F1X8Uv/RkACBgbk4Yk5xIkhRV2lslO/CgNz6UDasfYsM9sbbDjiwlCekLGNbYtgAJsc46BJ4opWXs5Vc6ADf+nGokPFwPbZbPssIVcShiIiQmPiSAscgAIE4Dq2tmdLtU9msxEFQ9i4T1cWR0gUjIW3IGI7t7ZJiaeTk+doCSAAmxzjoEnirttc8dVFp/yOfdXds2s5BaEpRQjB2k8ZVeR0h5vzXV6AAgOfmGwI4QtE3vdP+s4/l2yFWc2003+XBo3/VVE6v1elt5OTfvbI4AIBIAL9Av4CASAC/wMAAJsc46BJ4rYMdGCfAbMO7dayB7KYct47dlvzJs4Nxt9xUv60MQt/QAIDNbVLxRQDxE7bfWganu+57nK2bsh0wtzbvv70+c0OyRMcbjK6BCAAmxzjoEnikxMgFK8flGIzyQVYZxr9vtuVaAOfcrBDV9b9s+W8fctAAf+5/0w3LxjzNiCaqqs97Df3B6YO/XqvCtUBiMB14zM+UTA/rLJmIACbHOOgSeKnTRbHCloAnsbyAOYHb2xTSrC0qmnnyLoX4t/f9VdbEwAB/7LRsEkXwi4GAd38ywaQiDcFGB+/SmiKT9C0JJQaWaDdC61+p2AgAJsc46BJ4puVkxg1FsMq+ufRDls83p5Qc0aXQTuShdesUgfmAKxLQAH8d7tPGfHmUQ3yfqtQDQqWl8Bsp7wezL19sIgS5/GVk2a7fCvnAqACASADAwMEAgEgAwkDCgIBIAMFAwYCASADBwMIAJsc46BJ4r7RF3FcbJ3HGdR1E1VP0hDCDc7/y1U2BsbSHCWPy68kQAH8bfyNcedt1ufyxx07+6iEjoWry5/qnrm5i5t/eeXveQ6e0W0eVqAAmxzjoEnislkjEhggzORrrMMxtCjnH/6EwKIkLXCT2i51VcgNHTtAAfwyIIG+OQgr1vNSijl/9rVMcVd1lqJf8qIFcpEeeeFlSH9z7a6IIACbHOOgSeKuU6rAv7BfuIGC88qoB37nCqbVwO+N2Mmcc96H/SUQYgAB/CiS+vgYUDwzaR3orNFHg9CFwkZkTOUSFwK2fF07WEf9M4ku6cQgAJsc46BJ4rrfBXk1LmksTJfM3ff9XeP/eGLgSRbevtJe2SUTv0ybgAH8BESq9SNO2vyABS90EQNFiTiwyZW4He4L3QReITVftnt2KeTgH2ACASADCwMMAgEgAw0DDgCbHOOgSeKZiMDT3emElR4WTasX3Q5CNPkCmgnxDzo2nhb0ck1+yAAB+rjplN2SkILYwFwQ8QSrJZCttRYB9254da70Vh+gXWftXildZljgAJsc46BJ4p2ixnk2eCYDs2G3BLfzrD+h28kYgXrUq6Ll+6ba7UW5gAH6t5X3HnN0drJnV/giA4iP3e9ofTqSgvqoxXTqmhuXeI0/AvB/sKAAmxzjoEnikrOMJfsNWsntGqETNBXQVkJg1ZEo7Jxmz61kM3bF6IPAAfq0XpvFy2Yj/YUwbgOg+LdFRUOr9amPGPr0krarEdoQfdC5CGHhYACbHOOgSeK05KXbIHT5nZ01rNT6l++12ShtfrU21FWnyXGaD0/YRwAB+pLRv38KU3ZPIp0ciMIrBu8HXiGxyPDHcbbI4zrd21EQuajGVmbgAgEgAxEDEgIBIAMfAyACASADEwMUAgEgAxkDGgIBIAMVAxYCASADFwMYAJsc46BJ4ojZ3WjbnQnH30o/W6zfnq1US21VXepShKD3fQJl/9JdAAH6MGCIJ1PJ81+KPdJN8nEozab7sbO9sv14izX8KPxbn0459LhlKaAAmxzjoEnihXXCLG30HeofFAr+rJI52wWbvhYuoyzgF+JnAN1tykpAAfbLCzLq8EgeR1jxQ7ZHRPisfXWhYnVzJoQuBq3dcNUO9+5rHTwDIACbHOOgSeKrCZRLdEKQ3CenO0TTkqVbFFUkJVmAW5WaVecMFvYSukAB89y6RYP7cSIQF5BdYmmq5KtK2y/XANMfAebRKMqa0X3tC9QHmKygAJsc46BJ4ow1BVchcEudYO6jrDnZ4S5JwcrGeSZUPK5cIkvosK53QAHzLWm2F+M9cU95qJyjI4xcbkpIsXJespTxXLrm/CtXPjytaW/wtCACASADGwMcAgEgAx0DHgCbHOOgSeKEbmkbiOIgGYFGQCN8VIWVDvENK+UGk+WsQbAwFwki4cAB8ojAZMwyxtkxHGsY1hJ2/QPQJ1jxEKTmlpCYsm37yRA8MBT+GOtgAJsc46BJ4pq4MjrAC3Xn1zvN/RxRQXb/eggMLFZRWh2Cn8fYGwjEwAHuAz9YuL9h4QgoxZPh9CMutTLSWVVnDyWWM8pVMMn7zpCKtPuKQeAAmxzjoEniqtJ9676B6E10TpZHtGwQEjd7jZW6XoEG5NjWPjW8pWXAAe31PC30eQdwVQx4j73omfEN3ceqM3K75Y6bBcOXU02dIn3lz1d6oACbHOOgSeKNpEzkaCuwHS/J7Rk2siJAVgBpdFeDf2FxSFq8tFx0tcAB6jY8Df6eDeO/XVrFuPxN0qKrPxgq0IhgQq+ZDrXGNq76hRoPclugAgEgAyEDIgIBIAMnAygCASADIwMkAgEgAyUDJgCbHOOgSeKlFRxCJWirwgcs0790GdxM9D7hX4ZNEHqAGjqn8jyUTcAB6jY8Df5msp2ETCKIvWuJ/O6zLe14GSdXtEJsFHT59GoD3saVTdAgAJsc46BJ4pBQf7B2WvYEB02VEEm1QCtxUQB38KzOYnQsv1YluuvqQAHqNjwN/fZhe1bPoaGzg9VZi6VWzGoMGSIcrrO5g0EtVV4nvtngH6AAmxzjoEnir0aeVb24hwqhv0RuPydlGO7cD4f07y6cJTXJgr2oBAMAAeo2PA39vtdsElHvKWG1x+eYOP3Srjo0npiuNwAB44sCW/eG8573IACbHOOgSeKHFPhTonDf1DAHjPYgZiDLqQ3CmPWwWhQTmohaORq0vkAB6jY8Df0WeEktsF57IdjgVlhoKsbUVeRo+czrA3UJNXvY2Jq+gUDgAgEgAykDKgIBIAMrAywAmxzjoEnij/rSZvX8x7IGu3JErswL3/UpGd43T1YLBIpYdXHcs4fAAeo2PA37V8CpIX2BKzupA2Hihs12iuK1DPm+McM3C8FQ4h+JbwuzYACbHOOgSeKlnFrm25UITBUlOBzKS19YYvOGRQWKomrvFkgXKW7D9QAB6jY8Dfp302Cn9nlFFmFbpT39u8fq1ZrLXW+PF6XikTyWVXzRKjsgAJsc46BJ4qYP5z8PMlJugYd/MWon5jf+YPUQkdlQhk9eENePl/5AgAHqNjwN+dCBvL5Xz3pp8CeShKRi/jKCf9elP5woTTCANNSA2YkCb6AAmxzjoEninrKcF7dMIyYnwDvrUKNZXUeurG+VLKJXJGSE2g3cENVAAeo2PA35mIgy0CBL8gRzRgUIRss1glku6f0CAV2HnFJZBEblzQ744AIBIAMvAzACASADTQNOAgEgAzEDMgIBIAM/A0ACASADMwM0AgEgAzkDOgIBIAM1AzYCASADNwM4AJsc46BJ4pmKCyBEzb4Z0IwBNTxQMuY6tXUXEnWX2s41unJpBitjAAHqNjwN+LiGcYOCAd9tO0r/6vR5SYGhPtj2UBqhKOl1LvCmsk8GyqAAmxzjoEnipjXteNzBNVDPZHjZMQO2BfmVbvaYQhU5Mxh+7Oo8gzGAAeo2PA332X8hBm38jLyxUL8Ua5ufF4pBoszRCEZeLOccoEbJTs/AIACbHOOgSeKH/aQlBw/hjOqkGXGGhZ25YaWvXTPMZiX0/pOaiN71XYAB6jY8CCBjjAqfv6fp5mFSmq9Mv+ufS7WTLUGLuJvgTz8fU/orXDHgAJsc46BJ4omGnvGBkxzAQkIcKuU4f7cVlZH+9Uy94n7Of+xbO+MqQAHnQ02XDwiBTD8wphpg6XWfkaruIwrwat2ejXQYOx9oCjdVLvuClmACASADOwM8AgEgAz0DPgCbHOOgSeK8MgMvF57rUlg18vOHb6+M2EZTVABVECfHKaqDd8LnCQAB5xFYzFXvU8EtyxkoYdMVrJZmxEgk5FEGGf+mdkQkm9nZz8QlhwKgAJsc46BJ4o67i+1B5XPuCccqkpXom27KsC2uMgfwRjV0fQY6WZ9vwAHnEVjMVe9bpPEzi15TLCNKaottZ5Mm9wj+Pa73nRWRSTrwL592ImAAmxzjoEniqggVJb5jQPdft81uRm4ak5YxtZ9xg3ouP0mpHwXOu+gAAecRWMxV72oXr1WAdE02F0NQxpeV/dnQcIkn5cIii9jfWifWEcxdoACbHOOgSeK57M07ooubfuMFVNMWqTJ9b950FmB4zyKK/6yXQz067kAB5xFYzFXvZOv6c5CMVCt8krt7J6VZQseuJWlwh1kmnpIyDcC6zbzgAgEgA0EDQgIBIANHA0gCASADQwNEAgEgA0UDRgCbHOOgSeKGv6+Tt/EZnwd82On8bIQFfnwgwUglVLdYekJAFNSKn8AB5nJ1kZXxfwMQJbn4sDQRpeZ9T730MooOFlaxu7eg+QZkh/xsJkQgAJsc46BJ4o8jphnC9jWf7AWfL9nuxXoKCgkSBuHZSj9gsgVGRAeYAAHl57zGNW2pZ67fRId09N7B1xGEgw6HKzCiEaDp7rFkvK8G2fjJ4yAAmxzjoEnil5xIxKg6vPFsPrBSyRKD+uYVWIzqmdLrrfCZHit+ZF7AAeTloJPsBAM2fT2FYul/cx1rTvmM2kKTeAc9RLnX1LrpWtXc2kcr4ACbHOOgSeK8Kn8+2UdL7TYhaHg3kdWEzbpEXH8wHx7ac9EZwYS1g0AB47zj7j2D01cZQFwmou0yNStwBXq+9gtpBIHGi4h61DEYqkJ1vhEgAgEgA0kDSgIBIANLA0wAmxzjoEnikTy5g+2MHOJoulCzDKCLSlTdC52JciTH9mBzwVA/5zHAAeLNTFhyq353nBYQo7zcbpGD9hbInXoKOl73+JZ97zHEczWXta7sYACbHOOgSeKIlp+hjrDc8161U75gD9XVS0R5Ysq4UvBNSKu0Pbe8K4AB4nquIrpET5O26yVP2M+FifxcQ6Yi3VsG63kqv5VA05b6H6AU+MqgAJsc46BJ4oAHlv4Dt85v61iMCjTkBP4pZ8ldYNqoPV32Tj7/Bm/fQAHhUokcwiIHRj2dV+hCpmI8u7VUG5vHk7oynKfq4mjLlPrcDhsk6yAAmxzjoEnikUC3GD0Je31C1gv6e133Aj7mSWNbu+Ok3FBqjVVRD5yAAeBuj2CWBf3BL7yuh3ztrEFfsjaPNcrECeNLRksu40ethUgJqZauYAIBIANPA1ACASADXQNeAgEgA1EDUgIBIANXA1gCASADUwNUAgEgA1UDVgCbHOOgSeKDhYLY5MC0il4GDR+oo7EqJWj86vbDwdHoJeFOW/K8yUAB4E716lBY1jZTKV16CrP/5wqOObQxBGyT5aUZduww8XyBFRootiQgAJsc46BJ4rBTa3+Uq79wIgQUkBLyddOEjckQxdmOIYPW04C7KQ1agAHd3bjg5r3DA5Y7VYMNLShTNhE0t2GKtDUou9r2h6adJoZxQXkv/KAAmxzjoEnilVptIsGxV9TA9/IUefd36xVRxPFPdZTkhvGpguLa/+UAAd3L6V0TQEBEj2SnnDLeBsNnH5eOWhAj3EWuoA8702oJHWtkWN+YIACbHOOgSeKPkUNQcjOyhznXwhaPpHpriZ+f20CQiHxulvH4IsLoQIAB3Oja+mpvGifvwJ7pVCuQXMkJyXe7bGQDdYKdsFQFt/vHkKLFQ/bgAgEgA1kDWgIBIANbA1wAmxzjoEniud7ksDw4oOEKNsOpiI+VY9fcaCR1vaHiW4dwpwH8Tq0AAdzo2vpqbwF2mbdDF7Ks4DFrFpJCL/ABsML+51worZXPenLVnFmjIACbHOOgSeKqeFOzEh+3b3l0Gm8gqgC34fM+FSvSndujs5DaQomNJ0AB3BggVBqCXrc9YRdmHjjwhqhjEJYGH3O6qMpRgQghd/53Pt6uBs0gAJsc46BJ4pJaZIrKl2J95BfoPxG5P4eSFPVDYiebOWVafb3k1OVtQAHbst1Ho/VHon27Gbo1O1cZkfZb/+Wu0fR2DsG14v+yPclDDjoL4iAAmxzjoEniiZY0V5g9ptIkhHxVs+vzBYhCSSJTwjRtoBMl1sGEJCRAAdtnK1dhILDPdP59UUqiJAm9/qn/3/jXkodId5ZAlPWDPZHrXktE4AIBIANfA2ACASADZQNmAgEgA2EDYgIBIANjA2QAmxzjoEniqxaRJfZgVYdY8AIxrsRnbH/Vtu3sNNycX3FdVGGkqKGAAdqoRa4kaEOUNSX4Fh+K7C+1NTNfwruxqwtHaBkDy0R8ymmCTxuc4ACbHOOgSeKw9lvKhdG+njI+sfr22OFnsiVrSD8Rjwblb2fE2NpZG8AB1ibIzSCBYSTnqkMWzwqmEGNGGv/4hnCuIddhMQVWzBOSzSfV3EdgAJsc46BJ4oRcYzdoDKdaFNWDZWLqiMONfz7i//lt/Xmt3y1Prhs9AAHUUBFKOkBI4G3ZhR9vnP7RB+shRN1yHRAQnr5GzI3rHjxLSvEAQGAAmxzjoEnivWvy9KLAX6RtCGzhFXRl16IdFvqe+oHv2l3JqYVmw5oAAdI0SpIkXD6DSPSL2bjO+2b+c35EBOt5ghOu2U7ac3/uHDJKBjLEYAIBIANnA2gCASADaQNqAJsc46BJ4q/PMMP97Bg632sKMdUyUJ7fB/YqSIBqrAxsZxlXKg1rgAHRsC1XBUSbwfCNB3qlL8WpaTYbtWqTc62E3C438qbBMcPa8ZVt9uAAmxzjoEnikxo3qFuQJm38xGfl9TcCvchPApJ8Lahi9twxlLMUKo9AAc4KRPevkdR/paqCe38Htpzrs0F7SoGMhBsgrgmJYtT0uj+EqUvtYACbHOOgSeKMxxZfHqSGf+XPSclD8b4hrmquo7GMca6q8jCcoSEVVYABzgpE96+R29BDgEt0SthH/jBqMPWoI98LJNTGW1+enQVRFCEmQQLgAJsc46BJ4qE2pDB2m1Cfj/aqJUwIa4s/Rg6IFyKAI+icnkgdTYGKAAHNv932J3FKneC1ybYGs8WOEHugmGzag0gsnkWoyU1mCH7/PNH1baACASADbQNuAgEgA4sDjAIBIANvA3ACASADfQN+AgEgA3EDcgIBIAN3A3gCASADcwN0AgEgA3UDdgCbHOOgSeKPoxkkTYtlKaUo13B/Y6cOlBLqngSrtvKsYdcQ/409MwABzbiKrVrINuHC9GNmA9CJEZLLS8KoMIJr7XCwssGm56V9uM5JdJ0gAJsc46BJ4rlxiTDD+GmL+rXVl4YMgsXYMJj6CkNfv4husjTgjpEwQAHNjr6GcKgoLzhEyA+QRkGDTpye3zALeBgloy3QRHZJ0jAk1EKp3qAAmxzjoEnin8C90Bi2mGxBVTeInX/mWD/an9UiaIeyX6nBXzU7tSTAAc0g3UJyvU2RPutcaD3zoM9IiIWQj2ZTHhNnsJ5vT1gSp2oTrqp3IACbHOOgSeK9tOnQYaXi14iDbHhXnMe9vVk/YHJfDIdKAOD229fCH0ABzEmrAHsVeXWHkc6gBA3iiK4gBk/pZSesbnqWmjLOkFiTkU+VKswgAgEgA3kDegIBIAN7A3wAmxzjoEnilTKn0j/bgx0lvnnMDlMeVlBChk6UJA4NI5F1+KaQ6f6AAcfelWh2LSzusuqpOJ3OGlgJ7i75dBhBUbj6BGl1y47s21whclzvoACbHOOgSeKb05TS9HS0F20fI2uGl4CaWT3BYlCQIC1g98FhDceM7gABx7PHlf4a5/RdxUlFzhcFr16RBpAj8LscYDEFS9/btF6n+NBaWC4gAJsc46BJ4r6ASHjHe7TydGX5OC1KGWcb/RAm2bz+f36LEI+svt3xQAHHs8eV/aqdukk7eCv5IfC4rrayr1QsYzdvd5vrPu05KARoccMzOeAAmxzjoEnirKwHSD5IeJhGTAfDmwdAJyR/DH3z8aNr+yUkPQPjAFAAAcezx5X9O495zCi1s0xphSzZukHU44hQ20/5pJnp3yEBJbG4s7c74AIBIAN/A4ACASADhQOGAgEgA4EDggIBIAODA4QAmxzjoEnisP1VQfXbfJnTG52x8LbdSY7b87YmCJcXHoCEGwikDNFAAcezx5X8JDRtXPjmjTI5OqDTcAxJhutRzevOtJ4LRR6UZF7YuYJr4ACbHOOgSeKdTO/H2m/4s4afpoOJGY0CBgW8KfSAJbPi1ctrtH8ax0ABx7PHkCHX5gR3sPmJriGvGXmoG3T8wnsYE7lZGjemPF2jnvc/6rlgAJsc46BJ4r0WN9gLL5p0o7BKEdaYWsMeVC65LracJx8N25nWrcaVwAHA3ps91BcwRFZuhW4IqyrpJ0gdwTCSZ71RVzHJ5FSAWqWjCrqqIGAAmxzjoEnihWTDeuqZe5XxgVSl4yqJPDMChY12qVhtOATWr8jO+U5AAcBPdRisxEFTlaFpb/RN9nOKBfR1jlvWIEA4/9oJmWaDWvwk4aa34AIBIAOHA4gCASADiQOKAJsc46BJ4q/pAjrN6jbcUWMQQlL5D9S+i9Pj5U0vVklnIGwhfcOwgAG/y0Kce/Ip5fwQKpwVP7VvBP/H+jabGwuVHf8BqMnmJIn4UZMXmKAAmxzjoEniio9EFoG00IVO9bn6vykzFsKo5zGeYqrb2pwxTuDYp2DAAb7yfPVMnIbbNsNlBtTXRHkbwuJNMLswL4597X2SmMMtQ8dk96ju4ACbHOOgSeK5OyX4O6F+haM8mLEg3bKlBt7nlC4X7SeNGX5mtUiu1UABvqipCIk+GAhHpv7l9vgmrOsMBY+2WNxGSZ56RY0PacFlDqBx+ZCgAJsc46BJ4pPtNdTplU1vQ07xb5kTL8JuTmJNxUmnOtxfaoAM1UUtwAG+DNFHDrTrP/FbV3HoqoLnE+L/OUOWling9k4N22gWXRkMJVfOW2ACASADjQOOAgEgA5sDnAIBIAOPA5ACASADlQOWAgEgA5EDkgIBIAOTA5QAmxzjoEniu2dSDBlKMYrR2lRtvo6Q3QVCGigwVMJGifg+ZCvDj5SAAbzxK0TODcH4mpsuLtMMyWsGXbVy9dPiROaVqeTdplJKeDGcqdMR4ACbHOOgSeKeT1KP4gFAF1c+oBs8u8iWpzQi83I2tLJf51oynRX634ABvD6hzveWa/RdL3UJLFrbU72/vDbKl+SNIn4fVxBxWYTPGd6wop4gAJsc46BJ4rQgiodII/MElFm8ViWwdMfpl2oOjd/9ZuHQEbNIEvPWQAG6kE4LTAstKvyjwIo0JUP1hUe4PkYbZYpiirRaCv46gKLbkHybuaAAmxzjoEnimi3MWdJ3kpbdEi81aCqJSzXGJ7/bMsKEUlqXPl9ZwqPAAbpRK5N10aMieS5p94nrTctxKfA8UfFK7pefX91QdwByd7VHaBtGoAIBIAOXA5gCASADmQOaAJsc46BJ4o+35dvi3eQdDX/eb0YG8656CvK/kHJlfEO8e85WYmUjQAG54EItv/LdNRiOgNH0FkRnbpuO0xNWoXN7BzJ+X1nplOKWtcApE+AAmxzjoEnilV6PX1MNmrRT/MGBJrRJi5YgmLvd92ljugBK7JwVai6AAbm1jOeoiRzcNjdMljV1EOjjkAjC3eLEqZ4Ga2Y3Y4r8NkxMprHR4ACbHOOgSeKV5N82zSLzQJNjmwOVRrih+HS5oUjz71pF9F0CAqPAIcABuHCmqHC+8Ov2SCpPyRi1gBXTcpVKBRxJGXHJt+o/SSWDjRa6kTzgAJsc46BJ4p21kx4EWuERwFlhuRHK580BiJrjLADpQ3HOuJOAoXO2QAG4X+x8Uyd+L8EQlfEDVVh1P0vf0kLksC1DQLy7vV9Z58Dz5HB6iCACASADnQOeAgEgA6MDpAIBIAOfA6ACASADoQOiAJsc46BJ4pPy8YymotWtM0/GRlvvXWpb0Sl3wNn0x96i9oCBYHJqAAG3wxy6rLjiQydtqNFkZJXEwxEEGs+FznU8ij4WCx5Ar6fRciln2CAAmxzjoEnisySAi2Wy+RL48a56/iURr6YwLQRxQf7oxTz1iGwz8KlAAbbAKzV4pvTTtvaPbpSZH/XTHcp43Lvy9F7k5Vn0GEj9rlKpx+1E4ACbHOOgSeKxuiGZCvSiYOtDfowlejAK9iiXr+OM8RdrgE+h5+SJOAABsFDvztw+nLb9B/g2JF62YXhvL0tb/Vkr70y++riw3Ar9et9nVArgAJsc46BJ4qrJMrx6ZiIJH/V/Y6co0Z87PdwlzVEZmyRb2Bh5lhm5wAGv11M2IcDlE/Uvy6HJiWIeGQx27cZEuDI3eVWbgEAz9QBClCcPUOACASADpQOmAgEgA6cDqACbHOOgSeK1cCMIkxDkfqkRnRXBDWiSBate/K8jic0Jx9UnCtIMwMABrwNhN33RUJfVxau8kyZ+D50wMmL/WK/e8dON0PNe4Pw4hZFhRNdgAJsc46BJ4rAtDQ96QfzLQ+EQfwBUrfJPuEkXJbgoWWvOB6vW3UpcwAGqac2cyOZsJOEKfHUKpfyeI5tr2BWo5AavhF7n7bzQ0oUjbCvz/aAAmxzjoEnigoFRRDU6zwV0vmoNg6YVJXha+cOOtfpa01tW07IGH+JAAamEgi9rtRbtDRbAzkTB+lAnwmNl7dt4WBGyztFoam+Vk2BAPyR8YACbHOOgSeK0Kiv0vYgRpcUiU+KFDSoMFmI6DocYx5Gg6a2hPsdFGEABqBrExrrrqDerRyIoQHMjwf0wvLJ6gNNiaTxc+LbuD5lXVYS9B3qgAgEgA6sDrAIBIAPJA8oCASADrQOuAgEgA7sDvAIBIAOvA7ACASADtQO2AgEgA7EDsgIBIAOzA7QAmxzjoEnikl3E06vBTfITO1nqTo80k0R6oJsktsCcrszFTYIY1kqABL2GWmZawgatJJ0/McZBwguxYB5hOgy5eEyoriMDZPP7ycL89FXfIACbHOOgSeKyJUrRQdz7vdKirCwpFFrnzZkH9vcBgoIHQu5JljoLekAEvYZaZlrCIItcGiUsjkBz1dK+4TatkaBi6B64aLEhScZMDAgryDYgAJsc46BJ4opdQPxLAUnSWJ8loq7A1tRp3GumZAtNmd52SSBgPDVfQAS9hlpmWsI6pL7tReWKC4/tFVxmPErMCCMuUvqlVSE6ewHFf8X0iGAAmxzjoEningQFzf9cbkQEb9Xac/PuBq9shK7a3pC4yLQ43T9aJHEABL2GWmZawig3q0ciKEBzI8H9MLyyeoDTYmk8XPi27g+ZV1WEvQd6oAIBIAO3A7gCASADuQO6AJsc46BJ4pkUfj2l2bQVCIYIS4o0Zsicd8ujMz5fwRDt3NKDFMwjwAS9hlpmWsIVmO0RSRL1JjKgUI9PMY36Lc1+XDlxUn2ZUqQnksTgwWAAmxzjoEnisZsh7Hdt3mfwOkolP6RtOU1doElacmrKj+rQi5DNc/tABL2GWmZawgJJnK5pdTZPaF+zVpCkwON4FqHpSTyj4JjITE9cgXlKYACbHOOgSeKBb8swQuxyoU8K6lG6iKyOK0fw3o/wj2e1RHcTdLB7XwAEvYZaZlrCPgpBfMWGh9xCLSjgH/FyXCytbReWCGcAz8WFFgt3qrFgAJsc46BJ4qLm3xKJ4hLHOuoWAMzMbVhK6liq5ouC9A2neP92maHkQAS9hlpmWsIlTQ8CfXU8YMMiuTIV3xm7nefpyPQyNEKyv+snzRrHsqACASADvQO+AgEgA8MDxAIBIAO/A8ACASADwQPCAJsc46BJ4qUG12EdVBrirvWl4qd4351UjPBIYAOt6h0/NbHqSu/UwAS9hlpmWsIOnQYbNX2Fd06emNwr32DqXSI/9LfMctOiT46Qo6PscuAAmxzjoEnimPZIoBFmb1vrpIzCf77Gew9d+9fUVpplcGag+/5Mp3xABL2GWmZawjLJ2PDP1ZDR7DDBnItI2PLoY2l1vn7uw4VUKFmJvXOCYACbHOOgSeKZ1SEKemlsR9kx++GrsK1+bE8zL0DPDH5JQ+JlcJFYl8AEvYZaZlrCIQ5vr3GcTni+cpJxs9INkFLraQfUIP9DCn9lvbWrLulgAJsc46BJ4o2MpM6dDfGWo+vsEJ57kAWVsex5cIbXqNChpcqJl5sLgASIAwuHGlog6lngraTlZGU9H6spUd3jhdfbp7EY7dzIm+zrsbH6ASACASADxQPGAgEgA8cDyACbHOOgSeKbTcjYmbWEhFqGIIYJPCrwW0xiCv55+xzmkJcNEyFRLUAEiAJQcYUVLBuXCZwVcZASdiVr6MWQSwsdEpYzb6prtC/PuzdmJgBgAJsc46BJ4r4Lqn2kZWhvtdrWFBdRYt5V4NjrWyppCUyMBEO3+HpQAASIAlBxhRUixF2mgUkBszT8J5nX/ElA0TgCPHp7cTG/GrA4sR56JKAAmxzjoEnii8EjVwKmWZozqDOB61kVRAPLZeX+Ld1OfYRy2Iwc1UnABIgCUHGFFSy28JzqC8H6GPJf2bTCRIQedyEHO+rdG34jKkeY3244YACbHOOgSeKpLHG+DCAENtN7/bfNWH6E5O3Gf7V8GE8PvBQEM1aIHYAEiAFKhoDn0HWns+PHudcsn1ZgpFEncsAnlrJamGYSbU1Fb3XrcqtgAgEgA8sDzAIBIAPZA9oCASADzQPOAgEgA9MD1AIBIAPPA9ACASAD0QPSAJsc46BJ4o43+3wUUXIM0oZue/WEdxXn6jUGnQ1F+L0WvzVhYGZSgASHZOZ7uTk/FRWeknhUszxG+KFe8yGAPCgcDR7t0JF0q5VJ+iHx12AAmxzjoEniuet3dCZJ2O7bKKrGK7OcP1TG52Y210G9On4+rJlce66ABIdk5nu5OT9KsceXTCnsdWc56cWh5HQ4bIMsZuygs90Db9UDhQOQoACbHOOgSeKIF+R1ki+vFBHuu1qa8zxNO5V2az5rDCh4Q+DnvnvtqQAEh2Tme7k5HqfzJkVkCpk5xEeEYlMj8Z4X8ENAvLv27KDSTKbnjEsgAJsc46BJ4qvcjoRqzqagQ7mKBLkdQUCfjfiBNaGSXXyHDaPid3FaAASHZOZ7uTk6m1BlSMWzoJYp3cLACjzH7hLKQkPWnGREnlqwvwcqcmACASAD1QPWAgEgA9cD2ACbHOOgSeKR31n9JbA+RifPGeCrEqYbEpc68wOu/DWW6q7xBc3l7IAEh2Tme7k5OQbL8qPspJnP6QfT1IKjI1cY9k3tzuWHRhq2SlAYPDTgAJsc46BJ4q2HLp5uky8EevM+rLYozHLq39Qn3i4PPq4MzW8Ye373wASHZOZ7uTkrNsqXfyey8b+ZsGaRZvnKQGHFqHHiGeyQohmVyRA9juAAmxzjoEnipEHZxfP+rlGUjAfk28ckhKuuKFGY+M/QUSjjwcaAK7iABIdk5nu5OQHoJwn1Y5mfPgFadKAlXURcKR3fs0bGPfrmkDeytb774ACbHOOgSeKSuMuefkzgmZMC0UIfdncvyogn8t3NaDKciNBYF6hstMAEh2Tme7k5OW+cSLJ3rdO5tmDhMJ5ge+Y9XDk7GkeFbbfIvCKjuPdgAgEgA9sD3AIBIAPhA+ICASAD3QPeAgEgA98D4ACbHOOgSeKSY2Qi+OJVxww4YDpNNUDoAqV0kodbmDT1Oyg+eH8wE8AEh2Tme7k5BL8ysIF+tMDNBQC7cdUJp1q8azeJQHCcS190KEuYA/OgAJsc46BJ4rjhDVBBjpw2nIKjDz7EcIGASB7OujzXmfXSSTJWA7ktAASHZOZ7uTkoG8xl9fXWYAZklRLGox3dOAZNswzeh4sYvGu/znc49SAAmxzjoEnikIf9Vb11KsBYJvSGQV2vKw+T2j5+/4hTps5bU9yaBOpABIdk5nu5OQb7IlR93scyY6xwQ31pdbrU4IQJkIOESXCcNubCXZ1aIACbHOOgSeK6muWHARgeJx03Cjo1tMjqpforr2Gb0Lvsd0ABhG0TIsAEh2Tme7k5H+agjh1cRQ9A4GFFJ36MdaA8H9bvnKS24TKx3FSneGygAgEgA+MD5AIBIAPlA+YAmxzjoEnit/L+TDdxyuf1FJRZZIoMEJ1fSoRdN9uj0zaa4y3etCRABIdk5nu5OQfiiqlYAR+OC7BUoWonry9SGZGaY+CMHsJmcErsllxA4ACbHOOgSeKwa3T3xJHH8bR3yQ0LNE92Wom7WBu78bdnIeRCNPfbIAAEh2Tme7k5NfqZzUc/8a7BhAPoheh3pEL/JtP+0A8qplOpkI4pAO/gAJsc46BJ4qU7UQ6onYeYDnu+C34+KZ235ENcQAmiLwt4JF1PSl2YQASHZOZ7uTkcQ34TOrTGshAkiM2rvwoOMBqPu5Qzajt1+4sTKg0XbaAAmxzjoEnipJ+rwhdyuqUJOf9eqVLFwtBEdoyB3dNxp/lNZaliFvPABIYdpiE366YlOyxQLTsFA04MPF6AeNcFrzWe5YmqbARERNkSSeIWIAIBIAPpA+oCASAEBwQIAgEgA+sD7AIBIAP5A/oCASAD7QPuAgEgA/MD9AIBIAPvA/ACASAD8QPyAJsc46BJ4rMqF4tgkvPWREWuNk0UtEvCsUD+edRcK+eLWn19eYLNgASGHaYhN+ubgqydrCcT+hUwwikC4WBIbx8o/f7b//IDmqnqcOKMz6AAmxzjoEnirnq8idKnl3XB8p1XlSp0qobnmhtgMBP6pCaCE8/g8zTABIYdpiE365ugSZtTkjYaNwjDgyCFH+rMYfzVDf7mP11X4n71dLMyIACbHOOgSeKhJcwGmvb2LOcXv8knTg7JdKW+G9TtDz0rXRww8gw6CcAEhh2mITfrn1xd3no4iexUvlItgpXBcAMegPoFMeLNcwvpvHbIgBtgAJsc46BJ4rlyUYKurnHpMM/kKWp5/35nsPPy1H9T//I/AglmvQDLgASGHaYhN+ucRDy7n0fq8L7KWg4pJbH6vbjUZADVX6s1WvrTbg4bgSACASAD9QP2AgEgA/cD+ACbHOOgSeKgYn7xBUmEtymA6k6pXeeRVWpVIDqARkCfwB1wUwXFRgAEha5r5d9+4f2+uit5Xcvgw149zOgaxN4pGU+Sz35XJEVrd3YbfRrgAJsc46BJ4qcvCyVUn+P5bWd5Ie2ULXb70jw+9hiZ5WgMlk9EeIkNgASFrmvl33789UA4UY41Uv8Y4lmwCHbTPKTt5eL2WMyWiORUZMIuU+AAmxzjoEnisZb7UF0PBidsa1AkcC/qSD0e1sY8xRo7CJTvvv7q5G6ABIWua+Xffu5ZRv7fpljdA+Q157RYG3aLU68iWETa8qVxOZuXwBDv4ACbHOOgSeKPM2BDHfhsr30ccgY+spzZUwv+hnomrzPZROSZb6hmSwAEha5r5d9+0CBI+HSL8j0/w1FKyy7Do++tVgjOLQIMsmwAJ0TWgRPgAgEgA/sD/AIBIAQBBAICASAD/QP+AgEgA/8EAACbHOOgSeKcr/2ZF7Vh2QKc4tR6Gx3rzsVAePfmwU0NbjAp9j2v2gAEha5GeygKhv15jHsV3/kRoe6hMTQCTDDFrleE+dAbXjGuBJH6HjcgAJsc46BJ4q4EYZiO4FbyY6g+PBc4c8PEXKnTYP0eH6IUHFT4VcwLwASFigcZb3jqSjy5KdvblDGcKmQR2Aifc9XscJMjtz0cigrRDA2gcSAAmxzjoEnit7LNkwew0yDL1QrbDRvxQ3y3+NqMGv1RTfnLtjryaYnABIWJvEQAkEhKJtzAHi8+27bNerXDXvuEoqkK01Hlu5hv8jcXiBT/IACbHOOgSeKhOrfJDojNj31+JrzlwjdvrxTAh6WuEf/hGIR2u3vbigAEhYm8RACQTZte+uXhz4XfhMqe38uy3VgSWcA+6PYvtpDNTAMRKS0gAgEgBAMEBAIBIAQFBAYAmxzjoEniiRl6yxyeGhgKBOh0wXdEXLvHbUGfsVJrnzidyuje4bwABIWJvEQAkH/KzFC5EnE1SbBkWT5DyOxmzanrp+SF3mWzl+BNh7eqoACbHOOgSeKg43+guw+XrSiBcWuBCVlj/jFjPChOu0dR4ELjQCHkUsAEhYm8RACQam/WqCJ21e6ArOKOdRDjtyoiVEEOmp4o50O5xyFLa4ogAJsc46BJ4rP1DMdYkQiB7K0Q8vplkL67ryvX1TwvNwRr1n+4uAliQASFibxEAJBB0AdRcZrCPd7t15JOzFB4HvQR0k0LS/A/qZRdYyVJuyAAmxzjoEnihHpBTiNl/Dy+ZtmZW1k4+jhSvcPRUvdWQhd+nNw7WEQABIWJvEQAkEn2ytMQLW5FUXJtq2hDTiBJMbZn055fvDHCDZNdiwtnYAIBIAQJBAoCASAEFwQYAgEgBAsEDAIBIAQRBBICASAEDQQOAgEgBA8EEACbHOOgSeKZWct+/kSzh3ImeFHfSjUzEE5ZGlR/Rw71LE9zIt26NsAEhYm8RACQbz1NGE8wBsIBcqBh+TMw13wn7L9PIh5rC3NF7tokwPcgAJsc46BJ4pB+DQKPM8JBviQmRopmUHBJC+1Y0+uKOrnVNgmQKW37QASFibxEAJBpcryoZSF+nNTZiGRb/b46Kge8lM6Io5RFuqpoNYCqe6AAmxzjoEnikWGC2+zV5q9PODGA4aAPMLSMd4lKqNQ2ZMQOXBapuNsABISbWX80YG6AV5IfnLV7cmA0Pv8s2yMSXJ11X4RtRSIOa+KbQBNSoACbHOOgSeKBiXd0Ha5gDU2Fxl1yCEcht15ICbXsECSSUQz/Yoy9j0AEhJtZfzRgfGgpBU4V+U4WITk785Q+rvABmL1QTmljK1tzpdSnzX1gAgEgBBMEFAIBIAQVBBYAmxzjoEnipUZbq/cls66vdY8TZjwv9ss70MFuzGqFPYYeDosMBZ+ABHpNUI78xRCj5A5AgGzvvkIwGSUOLy8/3XAv5I4JQ9bd0j6WAM4q4ACbHOOgSeK/xrMHkRoYdn+Rb1x6mOxK2GbgzPqcFtD/e0IpqYcMccAEd3TyvTV6rF6tA2Dw9WYemtWKvyiIpjlZOhJGdq6tf8k5FjIFNnrgAJsc46BJ4rLfg2RiZf39FLqrQPT89kKNFY76ksEuNxhJp2eUm/QQwARAKBy09mGlH2fRASnrNTYIrWRJxLlcLFXkowrURk3MAgX/lE0DaiAAmxzjoEnipCYf3Ns1T+ZMLVBAtTNBZePjfmQt4/eamWbZbo/CKP1ABD3q4rmv0/Wv0uwEIMFMYrAjTGIdfe7u8fCod5jzxikjy+lw8zef4AIBIAQZBBoCASAEHwQgAgEgBBsEHAIBIAQdBB4AmxzjoEnitr1/P/ShA0ON0zU8pOvGo/tnoFB/5fXaHXfzzKYjRKwABD1NZEFnOHHdzw5ppG5O4Nx5Ur6ia2/UYEt6Vdz2YWlaYHSZVI3r4ACbHOOgSeK1TZW5lr1XA2/FAuaU/MGkGf1zi1ecjFOGTeLHUVaSBwAEPUyc5Njj3iZ8Ppih4koyHEf4kCH+OaeJPVSFOTBQXW4tpXji2rvgAJsc46BJ4pLDPF3NiN8vyqOtRfn8NFrpqBc5BcXzmTFUAJUr9JmjgAQ9SrGmyzzVoLUEvS+0Sf8WVS43orl+ECwIt5uQaGVgotp/QhxjPyAAmxzjoEniu24DZK4iHhenXmzGt9Pg9s9NCsNj8QHzf0GT0kMrWfNABD1A9H+HaqIkIcMD0aqc2m3recCe6G1PlAWqCjlJf7TVpzbPHCqPYAIBIAQhBCICASAEIwQkAJsc46BJ4p2H5NsEwdfLPYhVQ35Qoc1X2r1V5XIDFrrI1nS+f1mwQAQybd1c9NQ+SrzQsRN12UJwoyZWxxbh+SaMChRcNTEUUGZXMXtnKKAAmxzjoEniktG17XmDuvNrsgvqF81C91Q2b+nmB8mDI3L/fJsHK+UABAQmt5kRWN/Pk2gRfBYelrCaJOx9CCjQ/tOUV5OM/cZCKILQVUhuYACbHOOgSeKwQnDtYxYeuvaPzEXGhyJvUJd/W4uBN6Q7y8ZVB7I378AEBB/eZP0rWZ6JcdpM4WWEdiHZDQuVwvs5nkri3sA1715Bc39h+AAgAJsc46BJ4rBfZcJ1NRFeX3Lb10Gg/wou2++fvu4bipR1+hIvt7Q0wAPW1Qn599NTG+bEJZ0wMan0Qg21CU6hVeCm8RRAQZ+eTgCgBvnbnKACASAEJwQoAgEgBEUERgIBIAQpBCoCASAENwQ4AgEgBCsELAIBIAQxBDICASAELQQuAgEgBC8EMACbHOOgSeK9xhAUCO2UgWp98aDxLrm9gxTZgL5TMVFmW+L9OWmJ6EADz0+tyfqeTV4OPoegvR9QJhlWzBN3xGv0EctlhyLcy+ifNgFgZcWgAJsc46BJ4o60pNpKnzp/KlwEBkV6c1O+7NMJIVud/vBkWe7E9qqaAAPFFlPAIsRdxH6smLGDg5FD84o6Lyp1gr7rwzXo+5tu5U7NUzweDWAAmxzjoEninGLxF9ayP7WuGDqpYEbFD+mpv+DsHtpvHMTxtdA8b7+AA8JxYwIl0omQcwBgyv8/hYRBP29oCv5jhF3WJaNNWv4OBhS1UHpcYACbHOOgSeKPRFePz2zzwYcihCCnekpQqBl00yCNH/Lcn2YEm5yI3sADwnE9l25eYd4aAkC2GxAlQ0EHedbedPO6pBRQhEUZDYAvJC5ZD9xgAgEgBDMENAIBIAQ1BDYAmxzjoEnij6EA/ALhNYx5adroH+KUDqcmbvfRWRoyYrLyDu9NkTZAA7wiLUTQrHeuED4UVbti3r18kA4yRo55JTpuFNJWz1EZrToDlNON4ACbHOOgSeKC/YP8pDjLEl/1U79DlQqYFOzhr42qUCqWMYTSRt86rIADr1h+ZggEEQSB2/SoD856QqHo646JKZZSMeAj0Hab2sruZ+Ofvf3gAJsc46BJ4prAa2rNeJwzGgwxyfvp0TgLAvGfxpmgeRP9vmfHUqAfgAOPowmlmnMJACTH/OYV3DZU+IsLh5Jb0pSk2N3cwwX6srjZYbAGXGAAmxzjoEniu4MrazoQkZnJtPsTV2nbwR2Z/BhvEWnRYwZR8AyPb41AA4+jCaWaA2Wx9wX6y9+MVL4kArzdLRXlLK/pVrW3vr0UxF9Y6Jg4oAIBIAQ5BDoCASAEPwRAAgEgBDsEPAIBIAQ9BD4AmxzjoEnitvYHntyqpOuIHj1oR5yXHqTgBNcr7/9bhAPw19mfPSNAA4+jCaWUGQINiJG7MGLMtbPVbPTTkV6jj8ctNo5hNBemLIKQwFRS4ACbHOOgSeKly4Odb3iB/OKFF5wSgZFX7gFSXolFfYXELj32BSCDBIADhwdam2U6awZQpHc8TLluDXZ0Q3sAhPjbzd6KWgbaT1U4ECfuhAdgAJsc46BJ4qWnh/gevhLzLj23UUBeOqJTedYotq1IiIQmbn2gVWj/QAOBUYeHQ566qoPwC9BR+7VTZRe7WpFlN7zAPieoen7ArxlD+iOfNCAAmxzjoEnigxp3Ry3kZgOAGWxQzm8UDrHSsYsBDkRUH6rlF0/gBsNAA38AsxzUp7EiEBeQXWJpquSrStsv1wDTHwHm0SjKmtF97QvUB5isoAIBIARBBEICASAEQwREAJsc46BJ4pU9LvIlc8PLIZ2F0ZogFxybuFpWIGPvv0eYetPD/Gq1AANvYC+Jajj8AgNQy2nETUHokT8bB/VU4vEwNo9XCbu7Oeq3+Mpip+AAmxzjoEninVIky7vQkA6FxfTpDFEUv9c9hv19MFu3N6BRmwJk6ARAA2UjrH++Nii0MIE1e0iF99amenYqiBAeMQJgMc9uxrwf6Sl2A1zYoACbHOOgSeK8z96XlPKVLQj4YgwRIstxoy7vCA0q2twEulhSI6a/4wADZSLuyQGlvQoriy3xFjHDXR/hwr5CwaEDo+H7THZS5dvRyPcOqGIgAJsc46BJ4oeRVprNlyheuQiSMgKSPFyuFUyUCB1NAYHPu4xC6QmRgANFbrrLmzeISMx3G7yDYdhvOBGH23uzX4P+itgkHTO4wsmsr1lyO2ACASAERwRIAgEgBFUEVgIBIARJBEoCASAETwRQAgEgBEsETAIBIARNBE4AmxzjoEnirRNwtrEWj/rY6aq2zFsxNJeyL5by32QkNAfJvuIp49+AAzNjG84folDHzGIPrnqS6QzTL+W+vxCAGqhK/ckamPk7AolAoiMzYACbHOOgSeK4JdNLAGylRx+lLITv+ISGAovQk+bERTds1yToGQhIRAADK4ZnisZRuDh7Sd2Lo+DTh56Gz496k3/nm9z4URyNH4cVvbqoitlgAJsc46BJ4qzIVB+4Q+dXT2otdtCvpJ4d0p5n+RMsclWeLrmpn7r2QAMrhmeKxlEGQAf9oVGjeIcQbgPC7tIMuXQnU5ywrRPjOC0fR2yK/qAAmxzjoEnit8DWGksahXLm6ZRDGrIxCHj+UnaNpIEx9wl3PSP5kzvAAyuGZ4rF3vii0TbZ4oF7IlgRZ4LMis5nIkpi8ZNUFtJvaXAcbDsVYAIBIARRBFICASAEUwRUAJsc46BJ4onnf+J13kgHAoZr9vi2jxFZdTeQBqguNN79nu1QDZBjQAMrhmeKxaZx1GgmEs1KAJL/EFmkYyan3uVvOBfVRITtLVS7j+Zcs2AAmxzjoEnisFXkrmNzcyMmFrzv8kDrRSlgTDvZ1sQRUpbCHQIKJxrAAyuGZ4rFpkmudKXpBltgtvff9Apr/n6wIFjkf/yBojCtg3xfac/B4ACbHOOgSeK/Ry0OH7kJjMwup/iS03kZnLBKjWeDv0kLlztsNMiOpMADK4ZnisVtCwsY/ZPLWeDeSGEnCbRz8w6lkNBmA66+umBLc+lAsexgAJsc46BJ4qJ2goJ+1aiX5Ed7h0hPHt4TCdKJJ79HH9ZS2qKJvFilQAMrhmeKxTVPp84fI3lJYD4xx3WzQa2S2usV7oMl8ztBZaC8iuxTViACASAEVwRYAgEgBF0EXgIBIARZBFoCASAEWwRcAJsc46BJ4qQoCgej+czL9HljGVWjkYFZ8e7KndGEoJgN/8eFy90cgAMrhmeKxTS5nvb3EX8OxCURACNr2SxgHTLNU0MsjkCaWlUbiouQvmAAmxzjoEniu8oW11StfRPlpvzbfKxw/mg+ArkWs3MPXZ8yV8zcl7tAAyuGZ4rEirWb5M2kmpGmZvjhWZDOIRUQ3Uz2IHH4its3h/2SkNUiYACbHOOgSeKTo25Z/5lDA1vVk8q9jdsCYc8OiobBuywcWHQPkHOnCoADK4ZnisLC30Gioo8V08GpWMfhLdr1nDAkfrX5MPuzh/DP3OYb6zagAJsc46BJ4ryLz8LspmrJbjzCImqPxhChVDjzguHLQmtt/LCGERhQQAMrhmd3TQ+89dQK869izO/vTYvGHjz0eAIr/SYU1Bdk1QWBg96w9iACASAEXwRgAgEgBGEEYgCbHOOgSeKTQLHQxKO02L9Hda04T2guCEun2Tf20mpF5bB3tU52WMADKw9u3nBIMbBBLvbEL1IUR8GKDtfS6kqKxtYnGJaXijO/WySIIZxgAJsc46BJ4oFDZw1BL20rFudaerDkeRl3YlaLYDTlrY/95c93H3rVAAMiE5b3qMEjI3HSX9CzltodoetdrTsfbM3a6T7KrF5lRpNLneSwayAAmxzjoEnikzR4MwSEPiGZRDDnEKZXqFqpnLM6ZCs7qEn7AZsr26cAAyHv030XQgLXhxI0VF1S+btAUxZWd7Fh3HylpKCpFE0AeLPhUcG04ACbHOOgSeKNotFpuXJxfEAy1+RsxJx6Me/9imy5ude997+S0AGEzMADIY7F3K+juuz9Dp2mjUPpbs1kMB9C3qH8Qa0GVoDqNBm8hvKIkXRgAgEgBGUEZgIBIASDBIQCASAEZwRoAgEgBHUEdgIBIARpBGoCASAEbwRwAgEgBGsEbAIBIARtBG4AmxzjoEnio5FxEC/p88ZihKDrxezZSYAFkoXtKHPIteYMoDeAf6DAAwWd3uS/AMOUt+uROU6RatidZe6og5503v+d+mvr2FBphJ4g1G8eYACbHOOgSeKVbEbSKt+vYl8mqR7/O+NN99As7fQizgYH7ixkdNmw0oAC/vH3b/2TrW4LFM/OXfZeT+6AM76sxSrD0c6agbOZtNCW+pcFLfzgAJsc46BJ4pl8TGUrCtPn6wiMNUzBu/KZ5UZgFAxanGRNrBEk0pbQAALs7MJ0gFdiOaLSu8/ct3vpH740xyMM48snDsQT1SV93P/DXcjAZyAAmxzjoEniki/sYQrf+5SXwF6bcPDywKzPLA9zGMANeExi/jjtgpYAAuk4yeBCDq9LNlnakzOrWhkq/pHYn+mjNKBf+ESh2I5Iu0BdFtgS4AIBIARxBHICASAEcwR0AJsc46BJ4qCSQYLGHQaYMkjXkseVOG04xqzJyK8Z+Q0pa5lXODXoAALpDu3MlZkEJPXig63D6NpSyQoty9B+MRyCbbxLY92BmQ+2y3MJvGAAmxzjoEniug+Ja9W6I7UOoB7N/ZdvZB0abiSgHOGQO5Uvx5cJ5zPAAuX/UJEDfZWTZCwV2ArLPiu8SN3gLDYNsEb39cAnWpGhcZg3ipEwYACbHOOgSeKGAoG9Cz4hdNyPbMdz6yv0Y9B7iUPAq+sie+60CPhywEAC5aysUde65wkT11SRrSXIwS3Ae7hZTT17AS8W9fZvzhGLNXEjLQvgAJsc46BJ4rxkYHrzre2uPOscijlr7Woc91F25f/ujRNb1gUpNeR7gALkj/WuNu97FpF7PR6aaS8eANY3EfGHOGkIEoJ5Yp0+4Ch+mysZxCACASAEdwR4AgEgBH0EfgIBIAR5BHoCASAEewR8AJsc46BJ4qhUCto9RucI8CGrsELaYnhRYXzMZIy+spoGWKcGmH92wALkj2ADWR5qElNirDnyG/lYPL4Njn/rooP6U33VR02dIias2gIVmmAAmxzjoEnig42oaT1n28HxWXLAplBwhPUtAo6PY94vtaAN/vAx78iAAuINS71AGJBguSHLdHfDUQBLqE0ztsHVvZM2J6h7pFnnV6f20zRy4ACbHOOgSeKW16138Sa9eRx/rQuSV3p368D+hXUOws99gjfupXqZ7kAC2U1BR3caQ9CZ3hu0dQVYWSYIa47LkM1eARJ6IsJEoAf5sc/jnTRgAJsc46BJ4oeBjDD/bob1Nro6LrAJjdQMscA4fLJM0/acmCS+o3lPAALZTUFHdxpMfJjMKY2dxFapXmyfMOmZhvq6gflwiiq9pHBer2SelKACASAEfwSAAgEgBIEEggCbHOOgSeKYX+TJMFecFCESHzJIx4uZzSXAuuzARTq3c7WeSCiO6MAC2U1BR3bh1b/jsrYOlahVq8LPyUh1vR12fhVD1nHtrL+LVQ/37ingAJsc46BJ4qW2VtkrAg8ZwcPMjvD4gdXgjmUH62X41vJmKxK51VPBQALZTUFHduHZqmv9Mwv0XY77UQ2iFKSux3o2hmOm51FqDSsNOXm03CAAmxzjoEnilnGxn+RQIUHS6QEnwC+00jN+pCY2XJTzBue+7W3m96TAAtlNQUd24ckckWqlCqo6tebRE+0ZXjJzmvWMf6I+x30R2BBu6+tmoACbHOOgSeK+j1GM3IfWHMXA6HK5bGDGBv1iz2UJ4vm7WDGXNtukkwAC2U1BR3bh0qDLlr7N+5ITWNDfAEOiFyDM2wFWqwiAZ50w4zurr0HgAgEgBIUEhgIBIASTBJQCASAEhwSIAgEgBI0EjgIBIASJBIoCASAEiwSMAJsc46BJ4qS7ww8h5pZIN4DUTuq0+NuQgagC3zuuPrIz9Guu54WDQALZTUFHdODCLAxoehr95EohmiseQMUHci2Cc9Q8bOH5iUnE2bN+FKAAmxzjoEnip4ls5rm0fjsv8F44aoEVuG5lJ+H5yk8Mb6e6gL4r8nHAAtlNQUMQc4IXdCAainKQjqXana9b7wMOzpEAnFteyKRGhqgvDONZ4ACbHOOgSeKHyJhzXXpJmFfDZn2HMprSzl77Ug7bVYEZkqubTxItkAAC18WDrybHAi4GAd38ywaQiDcFGB+/SmiKT9C0JJQaWaDdC61+p2AgAJsc46BJ4oQxQk8/vJcP9eImKM5jrRuZ2mDzTD7TF8UDtEGIo0ITgAK/ZK1HB64HAVOCqKA/HP5mFXoERUWBtglqJxEtUbN5HbSnY3udnOACASAEjwSQAgEgBJEEkgCbHOOgSeKCo43eodjY+NEd+/jsL3FL9wxEdal4lsSfC8p4jiSSWMACuRzrqj2K0YOzQ2p8k9zEumTYDTci7CSWOnYo80Yl/ruo1n23/sRgAJsc46BJ4p6EQ9wRcK25Q7IiA+Opj2DkcKEbrnrTjACsmd4u3e+rQAKpUbpSRnRcZAmT62U5P2EGuHbILTH/iLGxT6MwsLGUj+mZ06Qw9mAAmxzjoEnim4O2gj8kuHpUlKv3OGwYr9qzbUxzHrE6EYQm003xwuwAAqJ9EfaruoXIWL+juQAfac3h4tyVmgb/85uqZaMcfyxRddrz2NsT4ACbHOOgSeKIk/8Osk58neFE0Lqg/0848xIprCWmM/42f+Z4hmgIqwACol7wpmin1L+r7riogO8zaIPhIW0sf7u6y224IKcJuEuz58l1YZJgAgEgBJUElgIBIASbBJwCASAElwSYAgEgBJkEmgCbHOOgSeKN3axqT76RzSMLaEN4gArtL3te4i5bei/t+5X6sT/LSoACok/fB1s4ZvyR6CQVojlmAwtNXO2gYHFnUGIvCtUiyBFlwVF4orQgAJsc46BJ4rEtV6Hns8SlsvnV4UM2tYa1R5MqJS3MMKIIE4JLatnBAAKeQ+Q34XgzOueg5BT3g9P20svZJoorZ8TZRZOe2ff4vziQ4e2q5qAAmxzjoEnimS3NsTwF+9K8HSr+UaJgZ7jgyeePRlOIYt4hGgCF0jEAAprTzLC/k0jaJE2h0LTvcl9nYvOprpkD62fzmxpphxkaEK2zgrgMoACbHOOgSeK9yUhaxGqilYP/yBPmBzeKZGk/IKbQ6gBI2yJgaL/XysACmJL+AtF9pFMCh45viUf70eT1WEc8HHm1ypDksdlnoZyN0ZpbATNgAgEgBJ0EngIBIASfBKAAmxzjoEnigPIpTcWKiBSUO0yaISH0MSIR51lfNeMby5iQZQ4BgZ1AApiS/gLRfauCFUSYWPFdm1F/9GEOjIh2n8F3M22LoguCcyD+XK1KYACbHOOgSeKSnBrTW5ecsmgoi0R9Li62kw1IfS9TH7VjYkpn+ZoS8wACjnLfI8aF8K24WQhehFaS4pR4k+e3B+XWrMYmdO8Oz+ARvBerKiMgAJsc46BJ4pDiV/c4neoE8nZYio99MOFE2yrIu15FUoox1dLFiXVAwAKOct8jwvg+3imel/TAa3PI+mB1ZEUTEmbYL0ZKhctiVUI98R8fm+AAmxzjoEnih7cRxKAwANkmzfxT/c9yGuhfvdis50kE2TrcKkCYdkpAAozJaqumrjlmZ7fPCKID2bPv2j9MCW/75R2lEtO4A6i0f2jA/orpIAIBIASjBKQCASAEwQTCAgEgBKUEpgIBIASzBLQCASAEpwSoAgEgBK0ErgIBIASpBKoCASAEqwSsAJsc46BJ4oAXl76xX1YXc0fSvQmfJXBJgAEsNQfPKJ8WcZmtslk8wAKMPJl8WlTs+KMK782IMX5G4wVI1gSPoQVhqgmfQ0XTZsJOtugSKWAAmxzjoEnioMCJri0KNlLCR5s8/K/e79hNBr7YnBnb+/ZLWVsd/7IAAodKvZrTqVxrPugwZGac0NuTPX12ZocVDnshVSKfjO6E9WozvTBrIACbHOOgSeKeXCg/HzWnGrxQKtFf6x828WmoKG04i22ZKeDp6YzZ5IAChyjUwpE3ntMBYwMP3RISyx8rUmD7WUGPzc7wZ8T/NMW5oo5mhKCgAJsc46BJ4rnmZIJYpFXdQt7j43nnKG2LSWRbk6kPdEW2e/wDCXrdwAKCSOuYF72uYcSkNabTy1kL50JHCxns0PIIxzLb7Db8euJj/sSN+aACASAErwSwAgEgBLEEsgCbHOOgSeKu3EQOafm2lHFV2iAySm33owPA1pqbB4AJsX8+ICambcACfd5h9YjWSDLQIEvyBHNGBQhGyzWCWS7p/QIBXYecUlkERuXNDvjgAJsc46BJ4pgNdbJj221lXko5w7o4ORt3JVOH7xPkD5azai5uQ0LGAAJ93mH1iJ0GcYOCAd9tO0r/6vR5SYGhPtj2UBqhKOl1LvCmsk8GyqAAmxzjoEnitQfbmD0BHzKrDMHKUGENYASbip1TK1NWuFoPK1O5L7UAAn3eYfWIZA3jv11axbj8TdKiqz8YKtCIYEKvmQ61xjau+oUaD3JboACbHOOgSeKmkLFne1x4krxG/8KVGFpEg8JbMOyhHytyDb9HMjqkSoACfd5h9YbWgKkhfYErO6kDYeKGzXaK4rUM+b4xwzcLwVDiH4lvC7NgAgEgBLUEtgIBIAS7BLwCASAEtwS4AgEgBLkEugCbHOOgSeKghzkml+eQkVscwu5A2RXBMCQxl9ASpg6f9OeI3lmMQsACfd5h9YLWMp2ETCKIvWuJ/O6zLe14GSdXtEJsFHT59GoD3saVTdAgAJsc46BJ4q050QjyxgxRe4+qfiCo2PCyB0MQyekqT5V0dFCo90gZwAJ93mH1gbp/IQZt/Iy8sVC/FGubnxeKQaLM0QhGXiznHKBGyU7PwCAAmxzjoEnihJLEblaVHby3EUJEU9EGBDihueyvMJy31mSih6u7yB6AAn3eYfWBgJdsElHvKWG1x+eYOP3Srjo0npiuNwAB44sCW/eG8573IACbHOOgSeK5FwdR6icCbucguxq4uqJxeZSzPET5+aYtnhTI1KyyOcACfd5h9YArIXtWz6Ghs4PVWYulVsxqDBkiHK6zuYNBLVVeJ77Z4B+gAgEgBL0EvgIBIAS/BMAAmxzjoEnijL4Bpe64BEzkNGaclghjVHhJDcZR6sf/MYrTvHGQX5xAAn3eYfV/gFNgp/Z5RRZhW6U9/bvH6tWay11vjxel4pE8llV80So7IACbHOOgSeKnQHST8DBsiZfI2uJCZoQC86H+MUeA2NVv5mYvlH6ZJUACfd5h9X1HuEktsF57IdjgVlhoKsbUVeRo+czrA3UJNXvY2Jq+gUDgAJsc46BJ4qe8ke+QPRtL8gMWSurdKmqSiRtU68RtZoY2JWaKv3geAAJ93mH1fQ8BvL5Xz3pp8CeShKRi/jKCf9elP5woTTCANNSA2YkCb6AAmxzjoEnikUhNEGyFCLW/nyTL/VSmEsrxmP+JqFrtvnTUFn1+uoVAAn3eYe+ThwwKn7+n6eZhUpqvTL/rn0u1ky1Bi7ib4E8/H1P6K1wx4AIBIATDBMQCASAE0QTSAgEgBMUExgIBIATLBMwCASAExwTIAgEgBMkEygCbHOOgSeKDOAnGjpzW/5voYmNMi6kHPiYYGKAgCjZsqHBvgLgUXEACeuGFuwFygfpd497GFrmMlqeMpSkwqkRCq8Rv27N1cuplLz/8aJ7gAJsc46BJ4ovxKVz9vFK/0yz4IweG77zN6pW4NgXBuSau6MJkyVSfAAJ6qyaobJfXASB0vgAM/g5/RVMTlCzOMbeClt+GeAsFqIHs2aQw3iAAmxzjoEnipRJd9H3OT89WZOefjX/74OismbE09I8tiFcv71s7P0tAAnBY4KFs0shS97RnApxZtXVz9m018SOU55VGqOHJY/cJ4iXcno4BoACbHOOgSeKjuulAwsXUWBwtgeVrptqs2EVrvrDpUVncOtmIkm8iL4ACcFjgoWzS4EuCITvRTG7T6B8H881usGvZi+c1tXvdrQ0YasK/VRWgAgEgBM0EzgIBIATPBNAAmxzjoEnigojo70IUyCW8Ek2npQRh0CxFhJxBiNtB4AhhNacbfMTAAnAOxkgZsTfXY61UbcOsIE5E+OygzPGMa+ZX0l1eqBMwhutzZ1ALYACbHOOgSeKCAznOiX6IMRo9w/q+uxESBpARA/5Bxo8PlENFZ8jl8MACcA7GSBmxLHs7ckSzvc1YnkEjVUzsAkwbLV6E8OCp/t7NE1luIzDgAJsc46BJ4qalpwcbOgye6R/B4nQf2gjYLHqcpwZ1bzAlBbNHp5EfQAJq6nYoQOyj6p54ZTCfq6TzPrZFPX1Jd3fUcWe8aCQN6oPlC8l2FOAAmxzjoEnio9TibKUxu9RPa3cFYM5sUJcDtZ6f3/fMaO/PzTi6oKAAAmhaWd1cU45uy+oJOhUfBZLAUi9A1KZCMVhiCcliXkCyJKNeEKaGoAIBIATTBNQCASAE2QTaAgEgBNUE1gIBIATXBNgAmxzjoEnimTD+6pf+OvmD3Kh4bzl0MMJoCddSTM2n/WuZzRyCh1KAAmhaWd1cU4RS66/YVUm5ChcteE4Q8iB5eoMrR+dJtIiAeoUBYlDzYACbHOOgSeKyKr4hzEsAwGb/B70bixBQeymYqGEpe73Ou8OhhB0Fs8ACaFpZ3VxTqR1yqeQm+jkrdbH+Q+XEGzgTwmnhjKRugOx4oLpEBI2gAJsc46BJ4qYVeyYUgtHAvym8f7dWjl/0GmuxLwGq7oBdCSZT1rv/AAJldbydIxrajltJbD/+AtefNVmuQdH9YHlyqzONTNrpJ0FeqL3CrOAAmxzjoEnivGjXQrD1zXvyBRroon9F5PlpH50czZVelTv/p1LY5GCAAmVtiPKqE8dAINSD8Pqc8KXz4AcZb4kpmXwQkeSoR1a43HHgVsKDYAIBIATbBNwCASAE3QTeAJsc46BJ4rs/6u2raIkZofHWJ0HJP+Zf+f1JwoNIE4XolOFtcznKQAJlbYjt8ozQls7eDgTSy+mPN48h23+bX0H92CkzBBdWNo/GQ3MEV6AAmxzjoEnihYV/tRhSZpDEmqPmnxcncOIKOkA+9Zl31Kqf8NVn+NcAAmVhASJUcurwnlUc7m3ivC90pO0QoNmQpRinhXR4Xu1+0jrTkDstoACbHOOgSeK5O9P45tWvT9LsMPHniKxF9kDEB+Jl58agBj+pW/1rxgACZWEBHoMJPgLp2d8fmFqXaPuk2AYHB7x7wYslmkgIOjWLmJtrq/HgAJsc46BJ4qLmj9+u7XLTdoB4mXdVI5AGOn0U53Q48cOvus6sSu9EAAJlYQEd1GLqsLU6VDOABibbNLp+eJYduCC0jr4Ohd9gn/K2JGPMWOACASAE4QTiAgEgBP8FAAIBIATjBOQCASAE8QTyAgEgBOUE5gIBIATrBOwCASAE5wToAgEgBOkE6gCbHOOgSeK9RnCwO33ikjqt8eMx60Iy4+junaLLJ9c7FiNFk/hXXsACZWEBHbbbhN+hr/Ri1AM2pHciMTBkQNnZxAcCC0Vj3ZNDRUlq/wIgAJsc46BJ4pn3Dxr3zqhihthC0srB/e68MjnXZtc0oKqut/5hVDT7AAJlWtXLYzcjtK1wOdAKDWrNSbbXmiVR593OtIabxsTA+p9KIHTBZuAAmxzjoEnioCLkNA5nBhm5hvKhrO7fkxL5zCGNIOkkYXWh7aRwVogAAmVC3XupuLUndiCnYl7/hr1mBzgCTF/X+oCr8UXt7lFhfLWA4pXY4ACbHOOgSeKLuiag7ZtFmwRkAdQwFEbWhGV0GIdCkLRyG19I8zXBFEACZLPOc1AIAaSRQNPiXq5KEK4a+4vLWslQ4Jrw0m+GKPCJNCIIOpCgAgEgBO0E7gIBIATvBPAAmxzjoEnirZyM2nA9+OCIErMJUzmY2FEkOr00onMd9/QTOacBfL4AAmPyHvqqW78FssGtewVwnHyoUwSdM8Nq5eiKg6FKuAwDWua9S+aaIACbHOOgSeKA8zHH5JB0GI2AQeYg9Q0L2WDDSkyOJY1T26gqBdd/vIACY9LBaHKU8K8gudBG/s1+gIdqTt0UkEMaNDLOfwfAe62NwcvSPuzgAJsc46BJ4oVxoLLvBn7JjaGRiCswx8lYJPOX1lXbVj7PyNZu+Q6/QAJj0sFl0oP4zgAqSHKM+GEq/FYQnvqQaMnTm4gs/rkP0oLSJ46t7GAAmxzjoEnis50hFEhuJWOQleJl8n5ElkKl0BUq9ngKknhJ8aiko2DAAmOY9GPMxGuxffshQfw7oDfyT5wQK1Bmz8DzK2ANLBAifxz3KRUu4AIBIATzBPQCASAE+QT6AgEgBPUE9gIBIAT3BPgAmxzjoEnitrtcDptPhWzjWo6JoQFRCL9IhBzn2ZeV8Cwtim4kHREAAmOY6rvYB7S3NlY/o7v69easUv4za26Q48yGGy93lHvgrJhR5CQwYACbHOOgSeKmy0QtVVXsa35hfFJQmN+KvghcHGxjJ9oMojqG8PV9PkACY5jqFYfHE/9a/+3BOhSks8Wkt8AFVqec+8qsALZ1iURON8/Gw72gAJsc46BJ4q0jxzGByKant01tHS2zbe0GrGuTFMHLWqUQ+1cux1WiwAJjmORfzuVh60rKeTOPzG6VqyXJzdUhfYBrUZhyfwp0VUFjUOgshGAAmxzjoEnisGITIx9zgJ0skbUeY1bqSO+tncdVfvUV5MQkRzNXrhBAAmOYyIygTeS1++C0jP5ty+f4/w5cspTjVbjVnE8ILO6V3GPrRBu4oAIBIAT7BPwCASAE/QT+AJsc46BJ4rrxIluM6mfi2Gvpy06uhZfpVnjUoCg5SumaKARDMnLBQAJjmMEjuBEO+w0IcIO1XhYIbu3Oz0E0lDSbMDq0Tpb8uk24rsUwFyAAmxzjoEnimJ3vDsUlI6WPUwtvU1ZnLaBh6RAlepB376vOMdUHh3yAAmOYPEqxcXBoqL61jh8rFDxzDVWk3K+50ea7bXMbX0ICIueqAky24ACbHOOgSeKe2S8htWA/RDPnCiIRUjK7FTlOOyAYVotMKlehwbnUPQACY0GMUScIywJghCzudmkg8guQPzwuwezLjYa/eadnEZnO/fGkxrZgAJsc46BJ4oq1/n4Rk7cmpnvggi+0SCybTAwKCh6G/EsJpxq+S5R0QAJfGjnE7fxdukk7eCv5IfC4rrayr1QsYzdvd5vrPu05KARoccMzOeACASAFAQUCAgEgBQ8FEAIBIAUDBQQCASAFCQUKAgEgBQUFBgIBIAUHBQgAmxzjoEnilE0It+yFn1+awZSUw9VF/3QdJNsv3iqK4Yb+SIKyDRrAAl8aOb78dKYEd7D5ia4hrxl5qBt0/MJ7GBO5WRo3pjxdo573P+q5YACbHOOgSeKoz2x4iWgzp2XCZKrZd72021eOY51qZhDcC3K88oFqboACXsQizlnvKwRdNQ8vw2XrpDIo6cL2J9zYEWnaq19kcAbZRGox2SdgAJsc46BJ4qsq5HC3EQ4dhcXLbgMkt/KlKyuylXzSZgu9ea92rSOZgAJdh2nHjfsv2dRGjROyV3/jV+V+fIkScPmi+Ofje7KPTvmB4GO0J+AAmxzjoEnireKhDO/9eusIzv+muiTz3HFpdCzupMbFz/M5Z4vMF2cAAl2EQQ0KjU1h8ntyfgozIvG3PpyuVOWbh8bWqsqj3CCRxZDz1eK8YAIBIAULBQwCASAFDQUOAJsc46BJ4qL9jpD/5s8TdrsseVDrAKx6yMT0CicHIz27uXn148neAAJdhDq8TEolqzESNg0xkGjhi/kerRPWFnGy/FXBMR2kVzmdLVyTB2AAmxzjoEninx9Qfx4qmaKioRlijUPz1VxPkvuOAbeIZTiuXQXnvetAAl2EKGXmuLkVuehALAcXnAmjVp0OOFJk89SFAW9VTzuEPZ7RpeU8oACbHOOgSeKKGM+5G1SBu8T0avnEQ6qP1o1qP66o85a4H1PTxNYMHUACXYOQigKREoHFOWtnfEDLLKwQU7nKoNleEHjXOnmg5DkOwNHDomygAJsc46BJ4qtOlCFbok21pYINzLyarNyj212VGfInJoXr9H8WPEyAgAJdeTEOfyfx+TXXxCkohADS8wuPYoHHKx0IeJwMY7SAHxz6vNxuOyACASAFEQUSAgEgBRcFGAIBIAUTBRQCASAFFQUWAJsc46BJ4qPGT0DKWDX7ctVLOj83kz7t88rtMrJLMEpEXdTCeOdCQAJddhkSSkjgo7khp1zuGeMjvq9wmviSgwC/0Zoyp9non+BCBpb3XOAAmxzjoEniqjzsDqrJHDJscHYNpGFFYwXzaVMDkGxK/+FC18pb/jBAAl0s1mlujnFp4UTUcliGS3jbE0U98SLqwWy9H4mH0aQ2OzKdmAG9YACbHOOgSeKgkGEdsk03BjEjF1l1csvTEMc+moZ/3XSBiQENIg4M34ACXSzWaW6OelsQdPmIDw2wOqrOPviTp7jBYFj6kFm7NVccngx4eqagAJsc46BJ4qBFeEH0uZtzfKIcDJ37gYinmgFEmXEKx8gXx7BwUpj6QAJZ+cJzg/yqNMo5CdscObdGhWWDC2A5sVU7xCFdXI3grH1UI3yjf6ACASAFGQUaAgEgBRsFHACbHOOgSeKAu2rbkmWWpiERDaC9ZcNAd1zuGwJYLDahfNDXVEDDNUACWfmdCMyIWGte73pCXR+ROhiAPmlFW7gGCgTZsjoEMpcRKYJTiXzgAJsc46BJ4rfmwMUpYXOVzGD2ZliphVpfmY1CaDjOmqV3F51bUytLAAJYq7yy/JvD0MhQgPzjap6N2uQ/41YFgv9v2IV874+7udIbQS69NiAAmxzjoEnilIJJbh2YUEO7S213nmL8071qnbobTF7PcrmDV2tZh8JAAlggyVqJ/9F0ZwMLzopgRH/r3yQCBqhPF+1DPa84NAgBLSueVCSuYACbHOOgSeKNiOucp/UQ7HO0nzAPOHFqnx3X1gms34r7oyY2vqPF0oACVd5CZkInUGpJLLWb70yatS3vJeFARCu+nybmPnGueHqaf7+hqohgAgEgBR8FIAIBIAU9BT4CASAFIQUiAgEgBS8FMAIBIAUjBSQCASAFKQUqAgEgBSUFJgIBIAUnBSgAmxzjoEnihRus0Pu/05td0RSBTyScJZnLGxnb4wPq3O4SHM1KgPCAAlUrzAAXtFylFkG0Y2NSrX81kNV8eyvUnMdwQIxROKUwzFc9SD6l4ACbHOOgSeKF282mAsN8xGxO9d9EFYunNwNqLGkDgbNUX5oyzM+B3IACUroWakGFNH4UMSNIY3qzopYoNFahroj6P0QiR0DATASZmuWSF8ogAJsc46BJ4qt2eYfjzjFcOpFpgAEUNy/gg349J2EW93GSq9DZq+XBAAJQoYkdjjgHPOJGdXrtcrjMF7LA7mf2BD1W4UQ8ICID69JQWZRNcCAAmxzjoEnis2NXiILpJd2iHLq7wFvCyRrrn/zv0TUGvcEZPqgNwQDAAkuvh69O9Q/3yYeJHuWedHpiz+dKV4Jfiylg/dtylCXuCHcsmwdY4AIBIAUrBSwCASAFLQUuAJsc46BJ4rY8QkweQVtobAgCJLHNidY2/9zvIQdZLqTR5x1aPEYdwAJLlL6ooPto9rEbd1MMqcYAa7Vhx+uiH0ooFGHdlT1tUhkeo0OkSqAAmxzjoEnilnBj9XjJrhCfPCpsLd+r48u6LUVmq4/pIod7QhcF9zkAAkuT5HKdpqrkphku964R8CJ7szyq1XHWSj5ycssTpK3TvyikR1/vYACbHOOgSeKJcx3v2S/45BY0rc6I+NNpLSKzAH0pOkhJaCOBGLx1lwACS5Pd/lEXk4aai+J21QacKPLtOY+6QqzpF9zjGErL/AaRG3hEa+/gAJsc46BJ4qgRpoV12lBqmpfAqTqD9uma/53JnAnklEkK2NG//Z6MwAJLk9m+kc8IR5TWkGqRcJfU9jq24WGh9vdr/TojkblvpKUYr6LK76ACASAFMQUyAgEgBTcFOAIBIAUzBTQCASAFNQU2AJsc46BJ4q4bK2ge84PglBMpEuQ8+LQkIEW8un5qdRMZvrYJTwUIAAJLk9S/7V8wysFzszpVTdMMDS9OpVprqIxrWQS0qRsAcKK2vid1CmAAmxzjoEnisOmCjMgcYpa1tjnQBPA0XynazDoO4BaAEGR+jXwOCN8AAkt6735YPM/6PgWhAZ+dN3HI3XL8cz8OU/TjKgikfJFN6X+Hap5BIACbHOOgSeKDy3KkUdSmXpBXwEM8vcM4yxqRmrhATuyRd7eSNyyrMgACRuz/cODay8px6FbH/Ml3YR05LvBAJdPMykpbuECuwR5Vaq7GDx/gAJsc46BJ4pyzkmPkX3WwIujSZZYN19l8ZkUYyHfi7vAz9kiMDWxIQAJBWlVR+hwXFujrVai0a99T8KSWVxBvMq/EQZcA9frOgu3rLfzRQ+ACASAFOQU6AgEgBTsFPACbHOOgSeKaTuQJdX8Ghl7F62w+OMP2Tk9wJrAZJek9061l1T+At4ACQVpVUfocNgO9ADE//z70NcmrP3bNM8npkdA2oesduNc1iy80I+5gAJsc46BJ4rEpfDhQlWcSAJVEgsQJ1Q2Ynwc8W6aOQIx/rUB4gwhZgAJBWlVR+hwzR0ZLAKSl1WhhcSKqPC9FYuk+ah46c5mk2ChJNS0vxeAAmxzjoEnindhVILIIdswt5Elr7DqyR4dD9QTaxf/M2m4tmh4c6eOAAkFaVVH6HB9PiRVImkzzHjx42EVy0e0M02mqFkSpqi5mn7sL+OiC4ACbHOOgSeKKPlY/KlQTwZQYpG8OhZ9lF5W1+YAzf6ohtDH0I5K5f4ACQVov50Kn1/9d6Gji1NsoYPDa0zKVz0uDi41vHWYYWQBwezClrW+gAgEgBT8FQAIBIAVNBU4CASAFQQVCAgEgBUcFSAIBIAVDBUQCASAFRQVGAJsc46BJ4oL6GGGEXUnA9/Uy2rJJMUYL2tejS4x0ltXU3PMuQJZ2wAJBWi/nQqff0DLsnYghCuEUMIFX3GAQqBp+d5gbDWGstfBU8RbUSaAAmxzjoEnills5+qgZ1Jr91KlKgy6Ux4gwD8e6Qxu1YoZtyx0PZ0yAAkFaL+dCp85oxpD38+nk2V/lJgyQic6/X0PuaeZtFyhlqc46PxQZ4ACbHOOgSeK0skqCByZCWimnbW0Mb8VXHCI4lGs0ju++JQEhpCSlIkACQVov50Kn1wOlMFe4dEoVZeF8rwfnFGyK8eS+TQx0A9z0BrUFQGlgAJsc46BJ4oCGYKLwxKB2VTKEG+RKSdaNxbFAwfJ63UGRCRgR0D+qQAJBWi/nQqfbmw8QUdZ28Hc5xmpg52DmN3TjHYhNXIioA1Ox8+IzVmACASAFSQVKAgEgBUsFTACbHOOgSeK8z5JylfrldO5YTTiZ7yZ1WJGdFyJ3KSUNvRDmk+Cv58ACP7dHoMcSj1LECEO3I8oA1HSMtDeZXrv0MzJ+DDv162yxEl9uDoRgAJsc46BJ4oMXVrSDSFg4SU1078wuCb6YY2kiBSgfTaNz2i7xAfaEwAI/I9GQXsIPbl4GFO1eJAFdQB8FK5ViRZaFtIDXMF0ahZvZiIO/NuAAmxzjoEniqOdbjaUoiCWvjc7lO591js0wpoS1gFtpOmdrGYV/6jIAAj8j0ZBewgza8dRbBI4S3uVjmElWMEmbm1nuuMh09/AoEubw9wwkIACbHOOgSeKtfp7PCPPDQK+qOTN4z06Gajzn0cARSC72PMQF3K7cacACPyPRkF7COn1vW3xY6fTfwy4Vq5aswTUYF8lJp9MJrMszs2ALT49gAgEgBU8FUAIBIAVVBVYCASAFUQVSAgEgBVMFVACbHOOgSeKnRDBp+21MO0wqte14Y6f+V6S4qMut/ApyZuRnfbcnUUACPyPRkF7CNCVXOnsQLKdx/bNplQQ9HZrigPfmr2PwqmSoBCnTDclgAJsc46BJ4okAWqPuxjiQMwf2nahFw66iNBNgt6NKlNZiZa5YCOBggAI/I9GQXsIjU4UDm3ootIMSfk7Z0F8P0cE1SCd0DY7XG5YHKKyVV6AAmxzjoEniuzicCXZNrrB5DHYyNa94TdA9U8W8XbTaXUzkdpKtdlYAAj8j0ZBewhMWYvoF2Xt3AsK05iVVXPgbjN5Np9HAxQEEE8Yf3VBbIACbHOOgSeKD8Yb9qyX1IydXGTtqtgEPqQgHF5LhEuJVmNZ6yd0T+8ACPyPRkF7CC7ABCP+BhBgGPOCZWUt/s6gCh63o0HB649dltPTVwjpgAgEgBVcFWAIBIAVZBVoAmxzjoEnipVNteFiTCRaCeAv5jIzj6miuk5JFjEg/sjkNlPURBPEAAj8j0ZBewgO20zY51Qn0WSfvsJKpqZmXBkabsGkeZ9n/1KSdA+zmYACbHOOgSeKO+gdikekabGj1usmCPDgaF7vXKqUORAFwnGV37i5yP0ACPyLLpVqUuOqIqTqw+4mS/KjwPFDqCcsOiWEiD0hN0W8A6t3Ss1HgAJsc46BJ4qHaXOGC+NzXdt9O8puFdSsAKOAC+959VR0gyJa/nTdIAAI/IsulWpSHq1v9kz1K88LCTM6uqQg8hvZZ8FYjtv8ei3y+s6Q7+mAAmxzjoEnitKffhdPX6qhTLhTWPqcHZMgXajD/7DWSwaQ8sqOl09eAAjweol13lAmDBFgFEI/4z9basF7wmxoQdPQpoJp/mqLkVNRIEqWxoAIBIAVdBV4CASAFewV8AgEgBV8FYAIBIAVtBW4CASAFYQViAgEgBWcFaAIBIAVjBWQCASAFZQVmAJsc46BJ4qSkj6RT01cbojGUis1Pq1elnKskQ2vjtVqTm6L+0PvyAAI7nYmIDSGv7+UwZiukAkg76BLIq/WtM5q+DXasznQLRe8N3Nf7hKAAmxzjoEniqn1tyC8LOm9ooe0sbXLryEHQERjqGq+mbGq6UecTvizAAjuKcEFydoSpxA2kLRqtbw3aE8qh9vggFiSTCXmI6RZxExG+IJUyIACbHOOgSeK2GI9lxIT/OIfwcnW7u4wDPvuBbdE/LBAyxP6bfHpYVgACO4kyyi0cdZuNtSYjqOYgt+/4zHEtDWGFYX3tNm7/Kvi8YfuS5XSgAJsc46BJ4poO+murb3lloAPaVEeZAfoUVWcQddiQsl0su8FulHDSgAI7g14HgbmZDya4siODOtYQikTtEXWz3veeVu2WdZCZLBhFKdP9iCACASAFaQVqAgEgBWsFbACbHOOgSeKvo4B3SeE78jY9mLhWaguEWD25PIgZomhuVp0KkP60X4ACOu+lV+zDcQLBNazngDYzQlv3XmdEkgApdX5qzALDrsna0feSzisgAJsc46BJ4o9R0fjt9Rrix/NT9IgTpC1zLk2tvoRsOqLoQndmuxsLAAI6753I1SBz7blr1FFCFJ+3IvVc7PvnuoJ3XIn2fMVDU47R9yH8Z+AAmxzjoEnig5S8t29qsD3dDqEE8V20haBp/lBw1HJNFDuhBDmOczKAAjrveF4drBAN5zTdBwabCzMlhcsFelUGuqd6u+Zwp8hyT9w8sFIT4ACbHOOgSeKCEpb5pAjV/qjh1+PLgN3AbienFT71DSorBv17lAMJjEACOradKS3gLptabVLyZCiquQ7fC0P2vyZuuqTbmQz0yEQ1a4fssKggAgEgBW8FcAIBIAV1BXYCASAFcQVyAgEgBXMFdACbHOOgSeKfo4jABhfp4EZyFzsqXzTpG+7g/X61y67f3veIiR5cHIACOn45udNkTyL3G6wAgIi2KEUoLEFYzfYFmBnZ2LuV7t7bYKQ4gJCgAJsc46BJ4olpnY8zPY3E4QBNZzMKcYwd0hhrPvYMu3CdwGl51f7sQAI1UXZjQEQiKp5AXjMgnP4tutltKfxv12ZW+kpvNkX5fwXjJi3wLSAAmxzjoEnigWaUlSgImUvPS7koIthRRdRNMYYrPyUll1hXg6ED5epAAjOn43h9Cnb5vYXVsAFvbV36mdI+taxLFXWvBdsd7dapo58XExP8YACbHOOgSeKMfDB4f/21gj3luuuZYIbFEJMOZGAOuKpdpSf8x32XpQACMqu67hokJGJvH7dziurnR5Uyj7qMQDzqsxZxpBy3F1GNJsj7LT8gAgEgBXcFeAIBIAV5BXoAmxzjoEniitOWIq5KNwiw6/oljkXhXLh6UGQKpJ25KWW7bkEG9sWAAjGRBReFheIaKaxPNXzBtNyv6NivROkPgcesB6tXU3FOZM0J9E0SIACbHOOgSeKoC0nXAmh4N8mFg32SiSKxSBvaxYpu/3AiaUbTY1VyzwACMOKmxpkCe4+iuV93cEGCNt1hiJAzMCa09gtOKn4p3+gKycZR75wgAJsc46BJ4q644SrwO8x1bPmSIldrCAC6EKWZ8IaLGr8kGVn7vJH0AAIw4qbGmQJjwjXUEms64jzJAftvXBLhHH8br1TxuBuNeZQkLLAsP2AAmxzjoEniqNqEu6G8604a+FSU9gMthQbvbAWDpj0hsvqTFIuJ8sfAAjDipsaZAno35RuKB7dmW92R/vd7tuOGvPPu2jxD6/7OloGan+4PIAIBIAV9BX4CASAFiwWMAgEgBX8FgAIBIAWFBYYCASAFgQWCAgEgBYMFhACbHOOgSeKYH/GNpvFD7JBGFh7s5sI2iawgDXHSq4lvnSZ0sKo7yUACMOKmxpkCZwaIpYajebmezzqMYjP94agCaW/5P75QBIZqh8HrOQhgAJsc46BJ4qqv468n/H0QR1tJrixz7p5T1TaDTIo2+Wc7amLpR66sQAIumwk/JYzC/CBuh5ywS2QeiUMFgNCh/GePMT473qOTQkd4H1f+KuAAmxzjoEninp8OBy+qSdMaTzbqy/lQcLDV3oyKGkksoUj5CCphQAOAAi3qXBsewgsrL2INit1ToXWhTWUc5wiXuQX6UTxsdH/WIHfArBMq4ACbHOOgSeK7nM1z3S8FacSwHwBBLbj6wrftpQlBLgYaFV95CPWBsAACLYueRGTHZQpo8we4gi4+VUrdZONgCmrZ9LUaeN67yOZQ/Zsli/2gAgEgBYcFiAIBIAWJBYoAmxzjoEnihuLULn6p5bp9FA2h574cSSpV6FQSqsl6AuXeJwNjFi9AAi2LnkRkx2/QuW9sEgEW3I/VcxncJKVllriyY+kyVZRFd/GGtJWiIACbHOOgSeKZmNJJN921pc6Epz8VRAV3OwQSC+kfG7raNLW5Fb6wXYACLYueRGTHUV5HvPm4LQDtM08uTE6ce1Vv5QI0NMt3WDnlCdMLj8ygAJsc46BJ4qVyGpJiG8mg/Bw7WLOIbaM5llTgkQ/lGgtFaE7Ew8StwAIti55EZMdy4W3cST+LVSi/gw7v2S2GTtohvsXnk1aanrAywS93deAAmxzjoEnikA8EjaKBYfz2UvzA8AaFpB7jIRTkLkuX4Qwf07s5oJqAAi2LnkRkx2O5PC/z37zrjfAhg6BCNLeusyXhyAh00GCMljChxxjAoAIBIAWNBY4CASAFkwWUAgEgBY8FkAIBIAWRBZIAmxzjoEnigtND7tIorfnXeFLjOVZw3q8lPCCsr9jYQWBLM0JUQYwAAi2LnkRkx0ThrOec09BIMAJzOgu0kQi/MCGfjycWiimoSuK/EDSKIACbHOOgSeKYGhZ2gk6ZQJCuIMfw79PwST4Rd9IWCKvQ1z/7X2tJY4ACLYueRGTHT5bzODpZKHz0cz88qyHQ2ml9EarzS9DD9bdSXAADwBIgAJsc46BJ4oztoH7XVEkK3ZR83S18Cdkzcx6Rcc9erMhecWJV5JpOQAIti55EZMdlcSH7TCrq8ZWB/EjX10gyjZk5W1MFD5exXrZXN4rEBmAAmxzjoEnipgpbSuaSh6HZN1TRIdNAnIzxYqiL5YWvFzZnHRZ0qBpAAigYYOeRwxTX2AcLrlaUhfUzJW+B3Z73u/2NXQ4wDudO4WyI/t18YAIBIAWVBZYCASAFlwWYAJsc46BJ4oO1t9xeKjrWKbaWcwoEALwpgLtKblHAwqyz5z8fNV7kQAInNFOMNx1Y8zYgmqqrPew39wemDv16rwrVAYjAdeMzPlEwP6yyZiAAmxzjoEnimi9yNDujDmRGVqwGPI3Q2B+ulHEXo3/WYNixGl0yiBcAAiQtDR41ESYj/YUwbgOg+LdFRUOr9amPGPr0krarEdoQfdC5CGHhYACbHOOgSeKgex5Jd/pfCMQStmr+8LAeIDZLNSeWO6CPJUtGk7ZCckACIjHRgVR5CftueWu4zFqQIWU6z9bJUavfG1RSprKDeTmv/VzsJ/MgAJsc46BJ4oYdyCfXaqjAzTFpRZtDAfgkIF5WI76ZPh3miB5GObFWgAIiMdGBVHkduwM/XSMkuCDFSO0rdkJW2vSMBfnN54BPEol4x3bGV+ACASAFmwWcAgEgBbkFugIBIAWdBZ4CASAFqwWsAgEgBZ8FoAIBIAWlBaYCASAFoQWiAgEgBaMFpACbHOOgSeKeP2RTYgc1RZqbo5kNHGA0oOpSw5u4LxUFmMMPSRH1e4ACIjHRgVR5OYXR/v8BdR7eBBUc27WZMdPSy25f5zD1IxnobJn+4mIgAJsc46BJ4rk7lhaS7av8/GKRHk8Wz78QR+YvluDwkEx+m/ye69gMgAIiHxwlml9DmdCsyVg6HT3gr4tKkk3KaSi8MAlDlWqzthsX5/Te96AAmxzjoEnikQBl8WZ6rZ75cUaiN2yMb+DRKsFB5kjqvcesGE0nSVDAAiIfHCWaX2kguoQA5APte6SbJQpkPZm3P0iITeqGaY64S7tNXTEF4ACbHOOgSeKAIAyH8lRFKO8PzrgBQ+bU1niAoRW6KFDSXULug4IC3cACIhbs73oXUjvtJgiX2uWeksn9xChoXWiQLqcgGx6C7bcJB8qtdqLgAgEgBacFqAIBIAWpBaoAmxzjoEnimvjW7CGr00anvM0Ktxg981+q4gyJ8ySPjBmtQz/2UCFAAiHsr3Zf6VM6c7f7nKyz+0uSL1AtV/DAkA1JMBOzWPhqsHvMsS0N4ACbHOOgSeKnz0ka1ALgDN9h/rHxKZ4t8hRlcexKWh5ySfNG0dG2rEACIcdqKaMqcJh4M0aqLyzKrPi8izFUNo+ijtoyy+93ABeidL20zFHgAJsc46BJ4rSaOmlyE9sLuevvnBAxD2DoG8hGQlQGW23dVt60SQ7XwAIhxmQ+nvzk6My+mWzW8xsJsM4Q8ENcuVEGzjbhmsfYcGySobjpT2AAmxzjoEnigOiVt6yAlmvVyb3+5ictcbl3qGO9FF5MSS1axoH8lynAAiFdAo3vlM3nxN3YhNz3anogcu8NrNUiKXrWV0HMjdr1Btj0ccxt4AIBIAWtBa4CASAFswW0AgEgBa8FsAIBIAWxBbIAmxzjoEninEbCcs/ajrNWV5Js3f4SyZyGk3SgzDGqhQxDZmDr6+LAAiFdAo3vlM8jzOkhPR0KuDxnghqgDehISz6hOEbS8lUcz9ZEZbgEoACbHOOgSeKEyY3+867NM8jqNNELIoDf6mwUtscsQVchA4N7v6YlfwACIV0Cje+U7MgOwd4/VnhhE1j4uBkbXrUntQvpFEETFquDyu32mQcgAJsc46BJ4oPhSJP8AGXLprDWM95GShS7ekqmGtLrXvGEcxYlBvWKwAIhXQKN75TRoLM2RiIzIwmHOhzXdTEPB5n3jlYbnfcg0Dve3gFXAqAAmxzjoEnih9MMrihrFay87VYSm9wxykyOBBllQgxZyfz3T9/aqdnAAiFdAo3vlP60WzTqyXWUXB8s7hgvS7GU+xQ5lArPVDyDotelo/JPoAIBIAW1BbYCASAFtwW4AJsc46BJ4qhTiH0iBwKOk5j0ZTM7tntalA+FdVQSBiJEkoxMj9z4QAIhRoBbk64383vZ/pUkGl8eKpMBYFphphccQgRBvQ3+0W2fdCnIgGAAmxzjoEnipv9Y4fNcftdw9XFpuAbOpI3Hjj/X5qIFiJnN5swhk8EAAiFGgFuTrhKo4OpIpiH645imoSODVZ8hXFVyoc/wJiK/DvmhkUOw4ACbHOOgSeKsNFeIT2xDz+41v5mryRRtyMws3vM/PitEo3oxODAYsoACIUaAW5OuJEHGkrgOYWmtIt7SG32wtd4A9td1lhEHE7mMaLcVvb+gAJsc46BJ4osiKAKH1nLCnlne4F8xSukQ3QBEGdmxWekpAknCzkYdgAIhRoBbk64sUgMgVp8D+gkKSXoyqU3cRgpV7V6gIWfP/V9MgyZOaqACASAFuwW8AgEgBckFygIBIAW9Bb4CASAFwwXEAgEgBb8FwAIBIAXBBcIAmxzjoEnisG+2Cct0t8IK7iaMe3z+dIl7OVGXw5a6ZtCHyJtbo1qAAh9ph22wxX1rt6QPgSZ3Ml9DhApXTQJcQdhao6wNl8W1qf405Rip4ACbHOOgSeKFS0XazSF1KnYcbOLuSsmyLmAuaBp9lhbRhbyEIgRklgACHYdS8+fnmq4jDADxAq1stpmuCaFGUSAdCvw4WezDOJDque+Bwr3gAJsc46BJ4phCHLY0UCrodRNdNaDOZQaJjrJX2WHzk+hbYpH5N4IsgAIdh1Lyar/YLHtmRBBS4oh7rLCtj2KoiquC/Y/Q+clZSCNNk27EgyAAmxzjoEnihVracM/35kTdFkueIHgrqrc8lNao6O65In7JPiEmUy7AAh1aUU3b5GOkmvf1if5cNoUHtnovu98oSGr5NyxCpk+RMBfNaZv6IAIBIAXFBcYCASAFxwXIAJsc46BJ4qJwCYrVxYXH8ug1O3ORIxdTFmE9ZCiEbeHR0gn7jV4DAAIag/RiKPzaE/Ef8xgKez3RboM8OkEcnNF8iFnAwogJjID6gLR7Z6AAmxzjoEnijX+K3UhP2rZj90l1nSCnvMc3Qd2nOT4ym48iwAtx5RxAAheJv+muZY3OXoa26mR+c2eH2Pn3CqYrx3ADaQtT2Go9bWuBVOziIACbHOOgSeKEfoBlxtuh1AngY1Em7HWVOPYMvbdnVhZdonq8eyeQn0ACFlgFzDZnTJhqLefmobH7Cn5LuUtHrkoc7Co/b0czFweXUllrfepgAJsc46BJ4qi8xcgMlTwSyHYyjtnuqnpY7MECckyajy7gn1gE89u+wAIV5oNz+bZ3mj7QjqKTMav+rU09BaZBoJ1qH0PzTsNy322Q1XRJWGACASAFywXMAgEgBdEF0gIBIAXNBc4CASAFzwXQAJsc46BJ4rPSDJkYzSDR5Cpn1YklHM+S+kfVLdIXcnpKwF87RSmbwAIVn4AzDllDU22uGvH8CVExdq/3x51jjuma6XX9lkv5Qtt9D7kbd6AAmxzjoEniiad20bsqjV0++yPUbUrvh5IqghVUsKBrcvHpqAl6QRjAAhToXN8imcSJIUVdpbJTvwoDc+lA2rH2LDPbG2w44sJQnpCxjW2LYACbHOOgSeKVQatlGpCm1XA/TE4HNbYoz65wMccXOZiZLF/jvMuxRMACEgIEoXAyQ8RO231oGp7vue5ytm7IdMLc277+9PnNDskTHG4yugQgAJsc46BJ4owq+9up7IOcW3ucSmNxPv1OXYz17QFxjpyJOPUSlhS3AAIRmbBq3Jr5nBvrXFj5LRmNcuMqklDgaoXMQiObL1/zG64rp7q2xSACASAF0wXUAgEgBdUF1gCbHOOgSeKJTBOBKRMCGYVVfiyU1rtz/Pyrm1pnIqfUYw68q8WyCkACETZM84/ybSr8o8CKNCVD9YVHuD5GG2WKYoq0Wgr+OoCi25B8m7mgAJsc46BJ4p/bQ/hzt4uoqe4/GMfvgf0gnKceQW5s6pynZaPYJ6TSgAIQJnGWp6zTnCosPvdwdpFe1WQnTxfJRvX+kFcTEGejjzZ/oRPRzuAAmxzjoEnigbHiskkDyqRrnJUcO0vs+5T+Fsl01Y6vCJTKAqV1DYfAAhAmcZanrPaCGavULaKlz/5Kjyqu/i7uUidsK1h4lMPt329yNj5w4ACbHOOgSeKL7fkCi1ZcRVK1fm9O696utjPNFrpyu5LpFpatSqeplMACECZxlqes230A34mb2KNnUVSoMrM4onq+Ew6H946e85hvFOUSfqJgAgEgBdkF2gIBIAX3BfgCASAF2wXcAgEgBekF6gIBIAXdBd4CASAF4wXkAgEgBd8F4AIBIAXhBeIAmxzjoEnit7xRkjUmhuNTdHXYCUAuY006w8WIabpgEe3oD1ysjhPAAhAmcZanrNJCk7ePWVEiGVHBb2JUamLlpRRwqcAoqXb2uX1qma5CoACbHOOgSeKT7EYgY+87yaV/biHKCzLZ9z1Uo7n+Aj3lYNG316BswYACECZxlqeszKcL/F2rKUkghDINnORwnI9hgw7WfJYKQGDB0GlttE4gAJsc46BJ4rcU4LhuRpA/Pi0p9/esn14HmY8Rr/OS3Fh6M/BcuR4GwAIQIxMfSD4iuuTOnKOyfEtXxb/UyR7RH2BN84A88L7dtEN7Y8fM+2AAmxzjoEnir0exSY+Nb1LkEICmpMzVgnP9sAMI8rRSX4hPJv66Px5AAg4QFx3I6ou1T2azEQVD2LhPVxZHSBSMhbcgYju3tkmJp5OT52gJIAIBIAXlBeYCASAF5wXoAJsc46BJ4qCtJtZzmImDlmwDbWaE8hPrkxCdxEUOO5lH4HJhDlJ/QAII5WowHmMf7gwWph+DZwCcqms3Id15rY2NcTMT8I6brJiHa9oovuAAmxzjoEnipzPVF2dQzvuKu2K9ATz4mMwzEpPBEiibEsxgXOF+0QkAAgV1uIQeYaZRDfJ+q1ANCpaXwGynvB7MvX2wiBLn8ZWTZrt8K+cCoACbHOOgSeK4I3kYIcj+cTLGR7ec5fJ1b74ctqgQxC+o+8B9SuQwkEACBUlAw6qPjtr8gAUvdBEDRYk4sMmVuB3uC90EXiE1X7Z7dink4B9gAJsc46BJ4p91BV6AEN1yyx+nitm8kzBhXAbJvcf5i0qEKuW37AhrwAIFFqtX8pfIK9bzUoo5f/a1THFXdZaiX/KiBXKRHnnhZUh/c+2uiCACASAF6wXsAgEgBfEF8gIBIAXtBe4CASAF7wXwAJsc46BJ4pLjBoMj51v0snm1OwnSkiLUfDthKXZ9lKr+W2Jt7VBLwAIE7ubBiQcQPDNpHeis0UeD0IXCRmRM5RIXArZ8XTtYR/0ziS7pxCAAmxzjoEnitSh075sKlDJpILx9AoODB2MQXS4javY6d1IwTOJ+4xAAAgTQrc5KP+3W5/LHHTv7qISOhavLn+qeubmLm3955e95Dp7RbR5WoACbHOOgSeK5yIjDzgIQL8fjeHG1zS8+BNCHFbwP2ZnZjXsk5x60HcACA6o5k7Ye0ILYwFwQ8QSrJZCttRYB9254da70Vh+gXWftXildZljgAJsc46BJ4oH2zjbag93M5ikJhQb2+2MYU073muWkOJD3q/TH3tweQAIDlbAjGZ9Tdk8inRyIwisG7wdeIbHI8MdxtsjjOt3bURC5qMZWZuACASAF8wX0AgEgBfUF9gCbHOOgSeKAGa51oHtrMMxKSjB9i49U5XM1ZROOA4rRnoGYz/j6uoACAzuGQlPfEZflNpsM+qxD6pNq304Ej4ZqidWhTVdnJ/ybruiaO4ggAJsc46BJ4pkhOH44LLfOO+UKbJXgc9V9zKqNeuBvprIntKjzJiJvgAIDF+TH+88J81+KPdJN8nEozab7sbO9sv14izX8KPxbn0459LhlKaAAmxzjoEniqce+y+gOTSAgxapbd4W4TNJRRsqYvm0aca+3YunDx1EAAgGB/bfMyE7D2HsOTxLl6XUU0buYLzXS/7c4nXfsV+XY0jxgAiRkYACbHOOgSeKESZ7hx1aE4AQ13r2anMlA8+LY831Fsxmkukstdv4VbwAB+9Ldf3TdPXFPeaicoyOMXG5KSLFyXrKU8Vy65vwrVz48rWlv8LQgAgEgBfkF+gIBIAYHBggCASAF+wX8AgEgBgEGAgIBIAX9Bf4CASAF/wYAAJsc46BJ4q1iWxBeTxdTuP9ZP/dhrFD6ZzmtjuaDjh8HiVEkIAeuAAH7EG6CCruDlDUl+BYfiuwvtTUzX8K7sasLR2gZA8tEfMppgk8bnOAAmxzjoEnisroH0fWZjV0okIJoA2/ennozTHZc8mF/efldTPbdfv4AAflEYTNDX8bZMRxrGNYSdv0D0CdY8RCk5paQmLJt+8kQPDAU/hjrYACbHOOgSeKqqQ/VB3ZErAOI4x9pkxWJ/lCegm7PSk2Uex25N0JMfUAB9vya0nwVkLMikhbifh+UCEcNNUMRrk6dLm+9nPBt3tyP3iM0nBqgAJsc46BJ4qVAIhBd333FxFoz9gigQfJaP0/I7asqqy9bz1Azd2gcgAH2vZwnn3Mh4QgoxZPh9CMutTLSWVVnDyWWM8pVMMn7zpCKtPuKQeACASAGAwYEAgEgBgUGBgCbHOOgSeKia0aQ9Bc6hyC8qVebmgem6jdcn/t5ZxoUDLL8iZCiAkAB9bl02AnzR3BVDHiPveiZ8Q3dx6ozcrvljpsFw5dTTZ0ifeXPV3qgAJsc46BJ4rtkGxeugd8n9LS0Grr8bdHLympExE1zF72a1/wnB0o9QAHv5rAYqnuBTD8wphpg6XWfkaruIwrwat2ejXQYOx9oCjdVLvuClmAAmxzjoEnivQ2XdiR5kKpbPxRR6Qj8zVaP4rtcXR3DqXik4/EZ/wDAAe8APcATwj8DECW5+LA0EaXmfU+99DKKDhZWsbu3oPkGZIf8bCZEIACbHOOgSeKCuk1aA6r2A/zZ8qx0FFoybpxRI1o+NxU3UbBAZU/4E4AB7qNQDWWSb/O/TzOMKqi5EEJ2BYs3nlWQ32HgX8LCA9dHVXXGW3fgAgEgBgkGCgIBIAYPBhACASAGCwYMAgEgBg0GDgCbHOOgSeKkIGKX1T3bElPYDk8qA4s2RmE35RO2QStxxB4Yc5Pn40AB7oaE7jkm6Weu30SHdPTewdcRhIMOhyswohGg6e6xZLyvBtn4yeMgAJsc46BJ4qNs/aArw+JWIbu5u850pd1u6X4VKAajjHHqOGvvrbDfQAHubWE69xQHRj2dV+hCpmI8u7VUG5vHk7oynKfq4mjLlPrcDhsk6yAAmxzjoEnij2oZ1GXlfa1BHKDpGMy4TiROMQ9jZQCDLnaXdSSZ+B4AAelDxoo6VV63PWEXZh448IaoYxCWBh9zuqjKUYEIIXf+dz7ergbNIACbHOOgSeK4IRc5mfmrIwHgwSRe2xQF1NXpl0bGkjqpkIJQVOgmQgAB6TkbG+oyz5O26yVP2M+FifxcQ6Yi3VsG63kqv5VA05b6H6AU+MqgAgEgBhEGEgIBIAYTBhQAmxzjoEnitmbCOGexVY5GX8dnT3E5QpV/CXUazJMibgSDRqvOVDKAAekrg1dE/BY2Uyldegqz/+cKjjm0MQRsk+WlGXbsMPF8gRUaKLYkIACbHOOgSeKfKiLiPiR5j0220igaSZF/fBYnA8jzZnZcpqdpmyzqpUAB6ROSZtUK08EtyxkoYdMVrJZmxEgk5FEGGf+mdkQkm9nZz8QlhwKgAJsc46BJ4qkqhP6g2ycpvOYxjjMpvcfQU5pAGB9MyQLqb3eL97ItgAHpE5Jm1QrbpPEzi15TLCNKaottZ5Mm9wj+Pa73nRWRSTrwL592ImAAmxzjoEniptNjoe1x60ItfwlZC6Qzdg1bru2YKFuvdkhgmvGMzmbAAekTkmbVCuoXr1WAdE02F0NQxpeV/dnQcIkn5cIii9jfWifWEcxdoAIBIAYXBhgCASAGNQY2AgEgBhkGGgIBIAYnBigCASAGGwYcAgEgBiEGIgIBIAYdBh4CASAGHwYgAJsc46BJ4pqvP2UB7SSuTqVT0iegOsX2icJusA0InJe85ioTojkDwAHpE5Jm1Qrk6/pzkIxUK3ySu3snpVlCx64laXCHWSaekjINwLrNvOAAmxzjoEniv0V/c5pNwot0vNErSIBUvv9zVBiyVL/dCnFTTxD5GzsAAejZXxCH40eifbsZujU7VxmR9lv/5a7R9HYOwbXi/7I9yUMOOgviIACbHOOgSeKFoOL/4kOk1ZjOFPN63E5CnbPdslmb8f/l65Z6sfjcKwAB6I9EtzTBsM90/n1RSqIkCb3+qf/f+NeSh0h3lkCU9YM9keteS0TgAJsc46BJ4oy3j3QAlEBBwubBCRaTbbCO5hpyhGxsKTz6utZyhNZVQAHoJlNorNl6SAdezXQdUP7hVDGNw8Fr2jaARrq89NCukGGeEKOye+ACASAGIwYkAgEgBiUGJgCbHOOgSeKi4qG39eVgCgLgtFGYveD3RUH+C7EB8x2OKmLo9j2KO8AB5oueBvtdfcEvvK6HfO2sQV+yNo81ysQJ40tGSy7jR62FSAmplq5gAJsc46BJ4pdGW2j5vyjzQO75hMEF236zQMVGhR3uQRQBm4LC7xKeAAHlpkr4nC5ARI9kp5wy3gbDZx+XjloQI9xFrqAPO9NqCR1rZFjfmCAAmxzjoEniqHuynpn5NTRKgP67YPg+cz3nv5VpTcRgUwy+O+lswp9AAeVLtBPhAFon78Ce6VQrkFzJCcl3u2xkA3WCnbBUBbf7x5CixUP24ACbHOOgSeKhvY08kyY4H53KbBjxnIIUoAX6Xhd62LiWodqXYVZgFYAB5Uu0E+EAQXaZt0MXsqzgMWsWkkIv8AGwwv7nXCitlc96ctWcWaMgAgEgBikGKgIBIAYvBjACASAGKwYsAgEgBi0GLgCbHOOgSeKrUBYUQB7nKlajQTS3eLnosmyLBiH+5QkziwzIirn+WoAB4++FjVOLgwOWO1WDDS0oUzYRNLdhirQ1KLva9oemnSaGcUF5L/ygAJsc46BJ4pGnqLjMSE6rq3RTnMw3pxgYUYHXCQWffHQlDreFKyyLgAHedSYweclhJOeqQxbPCqYQY0Ya//iGcK4h12ExBVbME5LNJ9XcR2AAmxzjoEnips/IJwGd8/15qYWqd2gx2CVpo5ydC26F7mM3LeTP0WYAAdv33T7wPkjgbdmFH2+c/tEH6yFE3XIdEBCevkbMjesePEtK8QBAYACbHOOgSeKN1kyDBATt6mx0rR421gKGxNHCURA7Uv9s835Ph8inVMAB2eCC1xA2G8HwjQd6pS/FqWk2G7Vqk3OthNwuN/KmwTHD2vGVbfbgAgEgBjEGMgIBIAYzBjQAmxzjoEnigeu+8b8rZcT57m5oKRkwlDm0voWKX4HhEsHmIlA7gQ2AAdhLn4Xlkx/celsZhGnmnFGBPoJdwDpRX4Vf87jMntgz53qU3mg2IACbHOOgSeKWAwKIWFhwXxgCIMBzlEZzN5vsNyG0KrthPRRCTRC88IAB1iouZ57k29BDgEt0SthH/jBqMPWoI98LJNTGW1+enQVRFCEmQQLgAJsc46BJ4p7ZtcOWRjpYO0w95ZFb1KGUn4R+kOB0nurQMSmxSYRnAAHWKi5nnuTUf6Wqgnt/B7ac67NBe0qBjIQbIK4JiWLU9Lo/hKlL7WAAmxzjoEnik4gSmUTvwi9DH9r/0yc6Kq3DyOFUZ6oaPqOgfS0joSxAAdYhh0A/ej6DSPSL2bjO+2b+c35EBOt5ghOu2U7ac3/uHDJKBjLEYAIBIAY3BjgCASAGRQZGAgEgBjkGOgIBIAY/BkACASAGOwY8AgEgBj0GPgCbHOOgSeKuWNQT5p3HEl/EoqCg6YnaxAu7ect/XH/QKHS/Cd6RzgAB1d54eGnEyp3gtcm2BrPFjhB7oJhs2oNILJ5FqMlNZgh+/zzR9W2gAJsc46BJ4qFOL9lzgM1irf7e4UI9E7UyVB7SYlVDezHM56V+ururAAHV1wQ13Z724cL0Y2YD0IkRkstLwqgwgmvtcLCywabnpX24zkl0nSAAmxzjoEnihcVrf/UqsxTWPIZbYjzdymOJTphyGL1v61zjKPIoHNKAAdWse+dUiGgvOETID5BGQYNOnJ7fMAt4GCWjLdBEdknSMCTUQqneoACbHOOgSeKL/VLqN4w5ZFzMpHxXqlyl+R4B6kwMVFsY9lb6c3PLFcAB1TysAR5KzZE+61xoPfOgz0iIhZCPZlMeE2ewnm9PWBKnahOuqncgAgEgBkEGQgIBIAZDBkQAmxzjoEnio7AiarBxiBzcxLlKCeKdVlRSR4KQxSMfBad32tWZqJAAAdSudUPYgASst/rMTIUKz4y1Ek+9VdtjWqAzl51/5zUgenqXwnygYACbHOOgSeKC6T5ciGD4T4YNg+gjUnWTXUNmxX5rAh4bPS+pjgBblIAB08cbbODjeXWHkc6gBA3iiK4gBk/pZSesbnqWmjLOkFiTkU+VKswgAJsc46BJ4oZrAc0gqjFGRDowMUq41IkVKdPPBfqMKd+cQZ51N55mwAHRUfJZSZO/1IKeztUzSj/lzF7+2L8XpamHe9DymfqiyrIRpQXslmAAmxzjoEnirqUtdTv9SrjuC5CxoEDfFsTuYOg18mnlQNX2Zi+7Rk/AAc/it8JEzWzusuqpOJ3OGlgJ7i75dBhBUbj6BGl1y47s21whclzvoAIBIAZHBkgCASAGTQZOAgEgBkkGSgIBIAZLBkwAmxzjoEniiU6+6pTw+6bwTw2ZhKIGz00VBtVfXLoAN5gsUarkR5pAAcdqjnjh4IbbNsNlBtTXRHkbwuJNMLswL4597X2SmMMtQ8dk96ju4ACbHOOgSeKe85l7GBUfX1sqPcQ86wO7Ee47rcoKfuKxzqPNt6a2fcABx2K8jO6w5RP1L8uhyYliHhkMdu3GRLgyN3lVm4BAM/UAQpQnD1DgAJsc46BJ4pLzcL69TCcUuWYpecB3fQXB67u5yyanoRjAGmPWP38zgAHGL3ck8b+c3DY3TJY1dRDo45AIwt3ixKmeBmtmN2OK/DZMTKax0eAAmxzjoEnioL94NeWia9uBlPFXaD4F77XfNg2iFx5lK6dOFcYzPV0AAcXkv7OqTSs/8VtXceiqgucT4v85Q5aWKeD2Tg3baBZdGQwlV85bYAIBIAZPBlACASAGUQZSAJsc46BJ4pflF8Ey7lMWVkbytkbTUtiduFP51FL1MwX5P8Iz/OSJwAHDySCl6ngYCEem/uX2+Cas6wwFj7ZY3EZJnnpFjQ9pwWUOoHH5kKAAmxzjoEnivWZAwQC6uhGXGvQgFFP2oZw+nfh3FpFGC1T4Dlk0N4rAAcN+eA7QBUH4mpsuLtMMyWsGXbVy9dPiROaVqeTdplJKeDGcqdMR4ACbHOOgSeKvq/oAW6li4kpvaAoYgtXaM50TcjzPeQaDU9FLsULq24ABwoojXiWi+jvXLNuq3NCe04u3BQNzYpVifAvlWQSRezrtYmXNTtggAJsc46BJ4rw+g7bl/eaepZFhhtweWQhufhJWz1FrpauzF618FwHswAHCiiNeJL8Z8uFPOO7OSwN+YA3DB6F9RtGRDxPi3EtTLoQ0vaQICyACASAGVQZWAgEgBnMGdAIBIAZXBlgCASAGZQZmAgEgBlkGWgIBIAZfBmACASAGWwZcAgEgBl0GXgCbHOOgSeKKDjr0ILzyNftOpLk16wocOX74lpqlmoz/bK/3So7SmAABwoojXiBNuGrSTJzhtr/5zhRb6WQAIvbu40Fh2pA9O0IJrHTPHnIgAJsc46BJ4owg3CmmXvJJ5Cahe2OOwTEgebH3yxtmFLsBXFze+quNAAHCiiNeHPhVn79cfWGtBXUzCDJvH7qy1JM46YNLaHnAU0n2PrUXVOAAmxzjoEniu7w1Mqd913iD105/054RcWiWyEejSuT4/lJp8/lG3z1AAcKKI14cTT8wwvpZf5puwAhvNaBoKkwZkrkW2bblUyC6P5zRbgXZIACbHOOgSeKwAtdtKGzo8EhSOjOEmhf5OLI9hTKzE/vZ7GZZHJDwAIABwoojXhqGoRoMMCMszjql7gf71ofdFBNXIR5Djiyn3Nn/cea3fS7gAgEgBmEGYgIBIAZjBmQAmxzjoEnikP/FkkJkt/7YmXvCRREbDonLzJhHi/EiRSLR1lASILDAAcKKI1gv4UFTlaFpb/RN9nOKBfR1jlvWIEA4/9oJmWaDWvwk4aa34ACbHOOgSeKPRftQfY5raUUOwE2QxDnrslrjX334zhjVUgHQNqohQgABwonMXTNQXPFHwy5vd1nwGiSTvMDajvKvxRxh2O2hKlxwogh74csgAJsc46BJ4q8J0XXr9FVlGUe8BX8RrYe+AtI7W4HJl929cxJVwSg8wAHCLswfRdRuYqy9C12tzqGjfUf1QAeBa9gO9+DwP+VBjxVlLDKpaWAAmxzjoEnik9TAQi/q7pTfTh+e5SAunWNCk3vRY7MnKD7BHh5DmKaAAcIuzB8+DSZTM2NI+27Bu2q2HExbPL+CB3jQM42HwXeH5kLpG7VOYAIBIAZnBmgCASAGbQZuAgEgBmkGagIBIAZrBmwAmxzjoEnirnSYKlzphrWS+Vf8h25PIGV6nvlE67v+bWVjdGBo9q0AAcIuzB85YkVqqOd+b/3fFH4Ln5qdxDABGokkmpm/FN4pLSjZ34t+YACbHOOgSeK7JM8n4ccLSGKLe96IOPlemiyeJ1nbVz1cturQnStwaMABwi7MHzh/Pi/f4f07KS7cNJ7YqY9pb+S3E++74mUOcs9mnxLysJYgAJsc46BJ4qJg08BDmmLwk+vwTqK0d8DEez2erUpodv3jCXHd6WIaAAHCLswfNkZfm58LOnylVaaibbQF0DqhgnBKjMOoONuJ8LPltR/oJGAAmxzjoEnip0BGsV58kJy03R49fuB971qRDvy8i+1a1Sf3ki1zae+AAcIuzB81mxvSUKWN89osdCJVARSwhl2KrQif7adtcoTW6QXgt25yYAIBIAZvBnACASAGcQZyAJsc46BJ4rTE27A1xvlbCOh9m2d/+ecl8xgjUbeh/FqCOUsJgwUJQAHCLswZTr10drJnV/giA4iP3e9ofTqSgvqoxXTqmhuXeI0/AvB/sKAAmxzjoEnitJ0zNiBCmJnnJFguS0Lmq0SKtVzJobUOrPwudF7kIr7AAcIgRUHMdGv0XS91CSxa21O9v7w2ypfkjSJ+H1cQcVmEzxnesKKeIACbHOOgSeK0DOLTv3WnTZWp2mGfWYiDsfWXfdqjHUaAMMSM5itog4ABwgfAhmdGoyJ5Lmn3ietNy3Ep8DxR8Urul59f3VB3AHJ3tUdoG0agAJsc46BJ4oidS2oWdHAXEBbL5K5Nu/MJg30NYp57PmjzEpCzhFtCwAHB/VlqsVNdNRiOgNH0FkRnbpuO0xNWoXN7BzJ+X1nplOKWtcApE+ACASAGdQZ2AgEgBoMGhAIBIAZ3BngCASAGfQZ+AgEgBnkGegIBIAZ7BnwAmxzjoEnimPFjgr8E1FUK4GAoHaKfvXY4IO5/1cnYDF5tUpKU/ZVAAcG/ziDU3/BEVm6FbgirKuknSB3BMJJnvVFXMcnkVIBapaMKuqogYACbHOOgSeKooNMGaHp0oXyznPBgtIDjTNiFqGU9H8PPZXJI9RrKowABwKwAgpNZKeX8ECqcFT+1bwT/x/o2mxsLlR3/AajJ5iSJ+FGTF5igAJsc46BJ4olrDx0gUJsPdDzoQV37ER8pJVAva1iaB/j1T/goIhlOwAG/5nbyL4X+L8EQlfEDVVh1P0vf0kLksC1DQLy7vV9Z58Dz5HB6iCAAmxzjoEniqRTFc0mmA4FJaPlkTRynazaNgSy8RCbPfvQQRxJ8GCcAAbv8S3t/KaJDJ22o0WRklcTDEQQaz4XOdTyKPhYLHkCvp9FyKWfYIAIBIAZ/BoACASAGgQaCAJsc46BJ4rjgCTDdU7w7GqCygcSyXTitOlomo9vFoV8gUjLJg/c+wAG6l7HECh++d5wWEKO83G6Rg/YWyJ16Cjpe9/iWfe8xxHM1l7Wu7GAAmxzjoEnilQoU49I44PLMhS4FQn5wrtyOSwvEf0YKe5HaXOMetj6AAbfoLgbZN9y2/Qf4NiRetmF4by9LW/1ZK+9Mvvq4sNwK/XrfZ1QK4ACbHOOgSeK3HrLBHyj5iAOztDw+EKZYVganovD4Ti3h6uJooHaBiUABtmOMqcTOEJfVxau8kyZ+D50wMmL/WK/e8dON0PNe4Pw4hZFhRNdgAJsc46BJ4rYfLKN0xwF/TcBqdUSgADSS/bpgrVmqmT/5rTNzOGZygAG0S8UpZw1kqdshrvye/JsAw9AOzJusjDI43DN8CEdF927Q53P/ACACASAGhQaGAgFIBosGjAIBIAaHBogCASAGiQaKAJsc46BJ4oT1cos0ITcOmkrSHCD7eVUuIIFdZJaIaRZ8FLTZi0MAAAG0SdwnqQIQ/vNAZeDAEKVJphAh2bFoXCpd4uXQRbnJPteWuw488qAAmxzjoEnivOr/Wq7gmJIbLwdPBJvXm6l8RMiQP0lLjoBMcbET982AAbDmS2aKHBbtDRbAzkTB+lAnwmNl7dt4WBGyztFoam+Vk2BAPyR8YACbHOOgSeKBA6vPxTdriyp3ryyd7d9zwF0dGwJ36y1CkM8n5ZlcTwABq9kfT2jrniAir1LtOT/6FQM5RfyK7RxTqr2LyISDtt6Na5EzI4CgAJsc46BJ4oT43ViJy1H7jlxPTx3er3s6ZgRKMYdBeYo8GOHDa0MoQAGYyiOe73srqqnxHqfNZmpx8oRxV5fiBcaCcgNDDeDOSaG/puAS/qAAmxzjoEnip6uCusaI5e5Vt5OQ+BKhLd0THMelA+UwtPOKLMJJ4tmAAZjDAZ7ovNqC7MonmM6cP4PEcXbReeuQ57qTx53DuTwVitQgVJB7oACbHOOgSeKIDuYtFTgIEstWe0+yDcuEJMnuq4zRj1CFkruImAxgm4ABlIIeIh5AvsTeZ3kMyFV8eO5GRzAsGAW6UxyRLqYKrBm2zNx2VNcgAQEgBo8BASAGtQELALW9PrBABpACASAGkQaSAgPB+AaTBpQCA+H4BrMGtBIB2w3BLrpRrt3HiqjKb+f0jAp46ATy+mDvHYXc2NuDFXEACSAGtwa4AgEgBpUGlgIBIAaXBpgSAUCdul4O51WuhoLP8w6HaCjI4Ncark8Jwt9VKyR9WuY9AAYgB3MHdBIBRriA/eC727ezGMBYjwjURVHD5U7GemHL7nool1TDZt0ABiAHSwdMAgEgBpkGmgIBIAabBpwCASAGpQamAEG+3naR+cW7qomTakxvR+35UziHzYmLQ8SOQB+E+huLXFQCASAGnQaeAEG+lOEb059genvvJ5pRL/3maEc9WCq96sg7nRE43KzBYCgCASAGnwagAgEgBqEGogIBIAajBqQAQb4LpDeHB2qpRbmsCb/0xmsYVNx1NgeYrvHGT1TDrHkDoABBviu1NcQChKmgRGaKo6cgJ70sfGfY3z03gEf2p0eWsb5gAEG+LRKWyiWrpXrzmF0D6pZoIjIBw1Ogul+ykcaRcsz39GAAQb428y49GdaLncoclv0ISdDlMUY/cxDPGNWFCPT8t4GuoAIBaganBqgCASAGqQaqAEG+CZk8qaskh1TFSTB1rKW98a7Ni63cuHifjO0MaW0uHCAAQb4Dm/DvuCGRFFqrZ0RkPCaTJDAaHKWcpP3aN3f/TGJ1YAIBIAarBqwAQb6kHmdd0D9JbM8TSrd/NHwlrmlfeL8Av237qpq5YNf3yAIBIAatBq4CASAGrwawAEG+BtqYegEv5g//nCL+GiGJtc+YwIAlv00wxK+9soFzj+AAQb4QWZHVFsnNc3YPRYafUErFg/i0slwoSiyTojBd61TaoAIBIAaxBrIAQb4bGLqI2XPdKGJzNlkPnOnB3Ykw0QQ9lIMZCZW5GWvpoABBvcAVW6oBrMdT6IOXZJg8lJeFSHtWTBNgRA2OszDaEGLAAEG90eKG7apl329R9jcXRJang7lg+HfmO96MzSe3ROIxn0ASAVU0iPE53qKJF8IQA5uhNMr8vcLE9X6+ogi7OZ6itTJxAAggB6sHrBIB/AzDrp7qUPdzJYrzXyuD5IUog6iTMKRJ9wP2Erdn63kABiAH0wfUAQPAwAa2AFWgESjR4FjxyuEAXHMvOQot+HG+D9TtSQavwKbeV09n3G92AAAAAAAAAH0QAgEgBrkGugIBIAbXBtgCASAGuwa8EgEGeMM7roDkUvV8o8tidrw9UFooNrzNWEHlcFsNKuDifAAGIAbZBtoCASAGvQa+AgEgBssGzAIBIAa/BsACASAGwwbEAgFiBsEGwgBBvraf/eo9gmHLiERpH5Y5ebr/z4pX4NysAmPMcHa9SXaoAAPe8ABBvfaORpLiO6cHef4OC7fmrx4d9ZeVqDU53WyYHXUyQYnAAgFIBsUGxgIBIAbHBsgAQb4CCoyXV4NKR60SHw4GC0NtHSFOphGw2tRcbVF8vQeq4ABBvgnr9hHEf6mN5TGGd7SKIx0ebPsFskn8DYO12YD9t8GgAgEgBskGygBBvn2RnznfnBxsdNXHfPsUAMFI3yP1awDbH1T8NY2RSYUwAEG+MtpT3R2VD5uveWfm4dGdXXLWuMV1+35enZXNklzpYiAAQb4X1uRKGZfyPIwEaIXrR0ZOqadct5q10dvKxWIxx7SQoAIBagbNBs4CASAGzwbQAEG+MxPjXn/NDvXS2cvdR3z4jm+hBEPGKslisiFPinmmCyAAQb4D3Fni9I6j8XeSIl+wAGBEhqhame6OtAY0GScKT0D9YAIBIAbRBtIAQb6HwDR+zxtnnk3V+Va9mVHm8Qn8CcswQhOKK4lFUVN4yAIBIAbTBtQCASAG1QbWAEG+G7QwmRBkQDl2gelsFahc2E3dc2YMqdeQSLsvZ9NvZOAAQb4pn/eynVlf7Ii2d6jP/p1URPrdF9F3S7DiudQyelkj4ABBvgkK4JQ0A3At2+pU2iK9rVT0UeEZcVQMMWDXBfugZL2gAEG+JjC/d8b1E/ogQyazn4YkRkrN7znMxMvQyQG7gm+2lOASAdNVWax5P/C8yynPq5RrwP3zinKDM86FDHeHmLz7em6EAAYgBvsG/BIBEfC1nZhy54s9/FZX7s44bQa8AlNXDEJY1WGrVwckLnEAByAHGwccAgEgBtsG3AIBIAbvBvACASAG3QbeAgFYBukG6gIBIAbfBuAAQb6L1UE7T5lmGOuEiyPgykuqAW0ENCaxjsi4fdzZq2D0GAICcAbhBuICASAG4wbkAD+9QolK/7nMhu3MO9bzK31P7DqSFoQkLyeYP3RWz5f3KwA/vVaiOV3iXF+2BW0R7uGwqmnXP7y0cjEHibQT6v4MssECASAG5QbmAgV/rWAG5wboAEG96YUi7d3rhTwVGwv/pocif6dNQ6DcZ3JVzvqdhFltQ0AAQb3zT7C1dlWQlR1QmfrLfaGi5Sj94Guq/gLQXakuFmoVwAA/u8n6yK+GpbUUdG9dja4DHHLGGEu5ZXb6rUHFOFMS7kAAP7v3dUiUhgaZGC+mdUGyJEzagm0IMNe3d2Q1lCRBTK5AAEG+co6LJmQv3h46OSV3KsT2gWyv6MLPKOrfIXFt86dsXVACASAG6wbsAEG+KQF+kzAAZybpH/1z1zYof09WYAAY6MbQHDj3AO9dCGACASAG7QbuAEG9xJZFhUbajV1FgRPu0X8LSHY3DIBRmI4wC6uLpNG5lkAAQb3/+UXNzozn7Eb1PsCLs8NaD2VhG+9qBBlvLJG76KkTQAIBIAbxBvICASAG+Qb6AgEgBvMG9AIBYgb3BvgAQb5l6UC6/ZmwRTHlWwthzsJcYx+8Vj2vmom9/nu617FmkAIBIAb1BvYAQb4J64Df7Vfb8/jmlGnsZByGAdCsEWA/FfWXyVEU5d6CoABBvhv0Q/VEAfHxjnYRJRxb6xtGetqoO1OgjstzC/3Ok41gAEG964EWqVOQS0JWHUcxnAz6STWs7+BsROmocJCo+xmqe0AAQb3vR9oRALXcwLQPRb70F/gP7SAVWqyMgCIasOqw+b47wABBvpbvxWd5+q2vJUVqR9AlbEIfdFysLR0PXGgVlBf8x5hYAEG+j9bgcxjKxRmfMrJEC6BbHTCQ+WNXqC3H+z591gZw0AgCASAG/Qb+AgEgBwMHBAIBSAb/BwAAQb7KkreZXaSZXSPGxbgwuJddzpWJly3MFNYwALkyQcIdDABBvnLW0BTZocy0D6h48ehPtgqA0XqNxrqB86bTTks9uvuQAgEgBwEHAgBBvjYzcOXWIfykHqSDt3m92Hacz/XRoWD5F4yy0AQ/E0ogAEG+AShOVhiiJZ6Itzjs8O75CiiF+eXloz74MSVsHpPAMiACASAHBQcGAgEgBwsHDAIDeuAHBwcIAgFYBwkHCgA/vVuDIbt91w2Z2FpLSOsyAUPo2ovei28SxaHKDSUdRz0AP71qm4D4evL40x1qJi6AGLh6oOBtxFr5bgc8Xr8jaeWRAEG+HzK7ymUhDh5PL//pLHqwaYidq3sym7hIWC32Rqol+mAAQb41DOvSox2jnjN40ZFtUSQhSJMCyEWhBRdRERRSltibIAIBIAcNBw4CASAHEwcUAgFYBw8HEAIBIAcRBxIAQb3cHJ+brtBSsROnSioWNJqFxZ+5hIGX7ta5KuhleBFnwABBvf/lQA5TJrGDmv6EqacNl5j6ktTzbQOEGqpl45xcekNAAEG+Nve9GdRJhn/t0fgYe7d1pkTBxa2AfiXcWeRYqE1K3yAAQb4jrXHoxDyh1ZYGBdBoQgLaScxW6pZR1hEhJC8BqF+5IAIBIAcVBxYCAVgHGQcaAEG+CdErMSfFYmEK9J9XimJDXyszQjtVELtHIXQt7AvQjKACAUgHFwcYAEC9ivFB4bA7PAP0VXnTs784TO/4CoWLb1QqRdyr0orLAgBAvb5z8xm2yt/HlB1G9TB2Qna4rVgzGxI/n4z3UYr3a7gAQb3f0PQO3/nU5ypuXD5/SaZboj2RhZjd5z47o7VM8AjDwABBvfGIqWXxgi7mCltWrYf4pQa2aRZPFvMA8LBV1hmpauDAAgEgBx0HHgIBIAc7BzwCASAHHwcgAgEgBy0HLgIBIAchByICAVgHKwcsAgFIByMHJAIBIAclByYAQb33dj2qlHUSOf2DkiVrVwhcqy3SkE9YbBfnzU07vK+uwABBvdxiQ8Yt/Lb9BztkNe9dyXuUyTOcKJRlF9BteI2LK99AAgEgBycHKABBvjxAsXZAtTQoMwJV27nrzNCyFum1aU1fbygeFMFuYX9gAgFIBykHKgBBvdroodCnIayUb5VXYFh23qJGAE4Oed7iqqU/L0iFAPpAAD+9QlUpU0rFnXRmWi3ZnIsFtIIm3JDSdtVPEGqGefBt/wA/vWGl+1GrGASEj3GaAizvMOXDl69yZpcU2YUtCHfGjLUAQb4d/oR88TrfAGcKrMn44T3wBnbh3TWVQWr8rVq0bYTnYABBvhpY6fA3+apwMQXdpEMu8s8uFXf+625mtfciMt0dh4LgAgEgBy8HMAIBIAczBzQAQb5d0CvPvsyCZxuTbUe5O2PtTudCwtgc3Ou4DMuX2WizEAIBSAcxBzIAQb3BrlEdo+Hw0uZZJxCgCdxWs/njs6bTHuprY7HtqNl0QABBvcSsc0L20So00ByQZ2oo0aUWf4BlreuHcpYkR/C5Av7AAgEgBzUHNgIBIAc5BzoCASAHNwc4AEG+ErNElODwkPB+KvEKqCtCz8CS5HCcsC8/VoJGV5f0+uAAQb3FCW/Cy20jtvAS0j4k9eQvRg9tcpaQgFnHc5cB7FdvwABBvc5nMn9h2c6FeqzonvA74SwaTxZXTgLEXOKOIFOki9BAAEG+NkNRDvICKDQNaqBlpx1LnSn5qpShA00BPg8Tfv+LHaAAQb4+0zsN9j+Lxs1EvbGG0fMwbeeqbWlxTzyjV4LE+0uJYAIBIAc9Bz4CAUgHRQdGAgEgBz8HQAIBIAdBB0IAQb5O+6O6Y7dWb4HOnMBK4fZ7QNo9woEzBIeKd5+K08xlkABBvlwlLor18dZ5/O3AomXxI5hxYM4oJ1Xrrx0JChLVxHpQAgFYB0MHRABBvn9hAM+g43TTR8vOvZfnhX3kPBCgPp3T0+YF+Ai6RFHwAEG99KmZCgwzysLzIR2TNaJdbyX4lKduOMlCmhCp4L9gJEAAQb3NtnmmW4yzmAdiAYg7sNjoD8sCiWIvgvkpuYpTXcyiQAIBZgdHB0gCAW4HSQdKAEC9hzviVxD170gIZfsWPGFKfbOB6LCP5YhH7I7fWz7wdwBAvaey9kbu3gkPDYYEraB8b3sFUrCgg4ask3C+O8UJ1mkAQL2wAL6FGQaCTbDdEwGUJ82TDpVMLoNr4ZGZWxcofghZAEC9lqzgehIXoMRj58vAWaHnNAi6UXEU5Ce942dJqf4HawIBIAdNB04CASAHYwdkAgEgB08HUAIBIAdfB2ACASAHUQdSAgEgB1cHWAIBagdTB1QCASAHVQdWAEC9syAieemf3vF3umY0lCaQxLhwvbTFuL8eQxPYrpeZ8ABAvbl6reyIsCKH2fq2I8+oEnkS4xYy3RUH/7ka152WrisAQb4CJHgAcs+wQzgf/9IPKdknw/ej0Z+Q+n3BtSEKi0hIoABBvgqovnD/owP5nsA4G62765H5klOyA1TV+7jriGf2CtjgAgFYB1kHWgIBIAdbB1wAQb3dAG8Nta3/iYiTymgGxV0CfKQlN6UlidHeNgbvtMT9wABBve7An2cFgShRoZx3xA7hUDRtwbcLae0x4dPQQlAH8o3AAEG+HDeG9ZNvkzq3wDDpGt0cb5cHHFQ0itHD3s5R2YHy8eACAWIHXQdeAD+9ewqjet2JVaCzHa8NXfnW3ZtLEzEASpk9eicyztCrvwA/vXDzaFNMjF1BnqMojulsIHfT2Dj1ltCTVvoe8wu+GKcCASAHYQdiAEG+un2oV7CbmRhYGc7tLiCXj/L40+4ZlzvlmEnZPxyuQrgAQb5ElmikSUchX0lT+0ASVhwF0OBnUB8X4TD4m4/v2Dfl0ABBvlBR7mcUQO8IfN+DkkDYHF1reSJZhv08w6k+JIA6ITiwAgEgB2UHZgIBIAdvB3ACAVgHZwdoAgEgB20HbgBBvhX0m4apMW/GEDxtnd+z0ug75voHd+OibSQbA2+tUPigAgEgB2kHagIBWAdrB2wAQb3WKikPb9a/J2tiV6yOhNUW5BivimV3gM+EI3VAxst6QAA/vUeSH4ZL+7V8eQBEF/0lm/ouIJ+wQs5QTzBpsSHSXLcAP71t4YT+jYHLpx5Gv3HFoOzL5rhg0Ukud8G3adF8AYlRAEG+Zf0nTrwaPPTPlLjegNsGkoz7UV5wz7oYQet9+SNmRfAAQb5m0tqyXFYp4ntucDLTwJV1gxwoh6JoJL1Y0rfwfLQhUABBvqSCHVak+jIc9ANutTAfHpZNM3YdGky7yaDzsTrg0WhIAgN9eAdxB3IAP70AGCAXHtaQJNqiST0rNTs8mUZSo5H6vM7gvA+3q7+iAD+9FgzFlOZUrfRtonCQzjDSFzrRv4l/94TFs9oi+RQ6kgIBIAd1B3YCASAHkQeSAgEgB3cHeAIBIAeFB4YCASAHeQd6AgEgB38HgABBvqg93lUVxmlCEks5kL8jTFcqg8lElfAi8dSee8j2jFDIAgEgB3sHfAICcwd9B34AQb5gqEQiOqBKE6++9fJCR6LRVtNCcE9MFknXFlF0leXQMAA/vWDgwPyHRVDvZl2iYgjJ3nWePRW2wjoUWAxrbgzB5a8AP71vi5ua8R9Xas7ZJOxnHw9u9q/5yyOmKiac4YXhpzZdAEG+s1A7ERdFjokIunFCSgeOxki+V8FwbGaF2nFzHDuF3TgCASAHgQeCAEG+VoZmB1FqSlGFLPm5r9LBLAX67F6BFQLDlwahNArjz1ACAnIHgweEAD+9QiJtY3MezTL7KB0xvFikeKH4EL/XSXL0b7P1FoVCXwA/vWinW8a2SNxgyMi+e0ML00BiBRy4kZh/JQrAHMZZ3Y0CASAHhweIAgEgB40HjgIBWAeJB4oCBX+rYAeLB4wAQb4MUGwt25IQd3/yHjI03F71G8Kp2GMaMEv2TiWoTKbs4ABBvjfgYNaJyJijra4RuhLyyPeGUpRcBZhwzdStzQ2MIyDgAD+8XsswC94XkGKDsoUR3B73WxXRX2LdrWSok77uwX/c8AA/vF/xbT+aFbepxFKzgZQ9HbF9uy1KEVspm2/20klhldAAQb6ORoMEHrkmcAR+9ntDkAj0Hq6gLGUT0ceglU8Tm9jfuAIBIAePB5AAQb5A/TMaqnaKx2BBvcxafTpwUxZYRXcKXTAZj80OapRScABBvm8iGJqmHDhbx34EGjoh2YHhU4mpC/HVkmnz7NBQA0LwAgEgB5MHlAIBIAehB6ICASAHlQeWAgEgB5kHmgIDeqAHlweYAEG+rC9orZ39Jto92k4zrR5989Z4qySyANXAU8TLG5+0zfgAP71bgmShTXyEATbw0sECEmtwNtuzKI+S3DHEAPCPRhvTAD+9YC74p2ZuEIcz5A4sE69a7MTFuARvrmQnzUDgc7Mo3QIBIAebB5wCA3jgB58HoABBvlnOv0cNQ7XgFJEwo9boghCVUHzfZ+urQtJh6esRW5xQAgFqB50HngBAvYY1sTf2ZnuWrkRZ+aijWbaH+q5ZMHkghn/Ys+tCZhoAQL2mLfoqMZw77ln7oAn0Cna+Bkp/snNwxHgR2MTl/uqVAD+9XiSecyAvpnbNK3Z28HAfLhXvbXN59PmK+A7M2VDdAwA/vVcEpETq6AblfmVHtN91B7GNEyGglVc2447ooPciTZMCAUgHowekAgEgB6kHqgIBIAelB6YAQb5J79ZyWgm+nqrXs6x0I4wkPiKQBH28C7RWNfPTqAfu8ABBvga7i8W/V7fCfyaKf+LLs48ld6A5hMVDltkVnlrlk+IgAgFYB6cHqABAvZIZkLzw7YHDbLe+Scl63uhdXfRwOUa0JHwJvuhGG3kAQL2a+QtRGkljjF6hjiME0j7LnnMjJkDh6mYBahv3SgufAEG+q3Z1cONnEXUOq6coX7x0RaK8l2WJj/QViIJee2G6qcgAQb6p4a4p479AeC04K9HUR0x8B9TDrIBoSgVyWXe7xEjGWAIBIAetB64CASAHvwfAAgEgB68HsAIBIAe1B7YCAUgHsQeyAEG/JvWFCk64ubdT7k9fADlAADZW2oUeE0F//hNAx5vmQ24CASAHswe0AEG+ortA8RL/qsRfVCCcmhh9yV+abEsHsmRmSDIyM5jiKZgAQb52rnetuJmLxwetwRXlQ8SwkzMrIHn9f1t+3vxypn8ikABBvlRRrWQUSUCo75+dTtj6fP1UVTmV5DEujv1TIAc3ZLZQAgFYB7cHuAIBIAe5B7oAQb6OgDPbFGfKzqixWPD2Hmgt4G6KWUdQTJBPH3A9K+TZ6ABBvoMGKypw006AeRYqimLjmY2Ufp+SHk8C0ZJBNgVBlzw4AgFqB7sHvAIBWAe9B74AQb4FNJ5NJO4+0QwlVAWckUZXdk+PfYDexDZ1+ju9SxhF4ABBvjxQpfN455vPpJ/T+t2rtlKCE9X6KviHFRV802gCPe5gAEG+eMP12XnWn0wTl6XmbgClnjYFM2JY2UAZYhUaknKJf3AAQb5WLKPfVeykQ1NoeXCT+51aWRbOsYTKmyd3AQSzEZ39EAIBIAfBB8ICASAHxwfIAgFYB8MHxAIBIAfFB8YAQb68pxxyoAcWOvpflv3VjfgrRk9v44uazdxMziPqfc1hGABBvqK0CHqoBidcEUJHx4naV3TtgmUv1oEhGpt3DFLGnncoAEG+xnddXOiUNI6DJEK4qY1Cxoa8Hl6iQkWXMWUwTPToH6wAQb72G1Ke4q6X03mCI87z+qVMO/gd+xvXv6SSwdWpfbnvjAIBIAfJB8oAQb8B8+e/xOcnn+D3yL8SGkEf/SXAx3pRSH/Lf3UDC6zxGgIBIAfLB8wAQb7an34AE4Mg4PeqZAW6F6j/JbgFl8egPBFDGYC5dIgrvABBvpMd78gzSiVsK0zz0AHtEja8x1UoB/NDZMjn+l86NQK4AgFYB80HzgIBIAfPB9AAQb4zj6RBc4mQ6p3ng7mGJ7tp7MbzERhe7obkM9A0wnCCIABBvcdlWZEG0Xj7uGgLfagzT4G4zmtS/JDEdPQBzOA0r99AAgEgB9EH0gBAvYD00VNmocZyrS8LPuogdwJgYw9wWC7QCKaicnWos7IAQL2UR4JVcHfZibOIOqdJm+OTPN6Z1z0bykKu09Up+xc/AgEgB9UH1gIBIAfjB+QCASAH1wfYAgEgB+EH4gIBWAfZB9oCASAH3wfgAEG+pJiW3Qo4nq8pKjVzzfs3/0uJxMmWXYyDsduLHtuy8ggCASAH2wfcAEG+VOzUzgqzn6yjJdPd2lOP2LQqiZF7O2/LbcmLzMf+hfACAnIH3QfeAD+9bmuGAYNACsk0M2FDu866cYUghqLilNK52oLflBoKXQA/vU+cjkDnrb+NojfOEJpwm2m9hlmHmr3HOWwyl4LEIcEAQb7xrpmUHCzHHfaaDbiK66LDRKeKblhi4QoTVRthJ2OzbABBvu6d/bOGE/iiKiKq5AGCvcetA3Izw45ihY196+ey/BbcAEG/IPVJM6fGP9OC+PczMUdiKPNfwkUrt4eslgzXXEY0qCIAQb8FwRfn4LbYMTzpLsSBuEI3vAaLitADflpdxp+M5JVWtgIBIAflB+YCASAH8QfyAEG/OXz/ktGTHClb8arzLt3XEjlJTw9LEYxjGvSJNff79loCASAH5wfoAgFIB+kH6gIBIAfrB+wAQb5bNqQnT8GAdHDnixf9NzTB5VYvmnvaYs6m53KwbxMzsABBvlGslmQWFAphVxFAGGIJvfuk/oBpngdzy0sJ8WxmWNSQAgN+ugftB+4CAW4H7wfwAD+84Hccb00HqhGM3lRQZIZ3QmOuWlRDBQ9+uXRKu1L+hAA/vOLc2o+R4+ofOAQzeQiU06F6MN1nTGWWJ0eurH869zQAQb36Q2nDRQfZx/XsGJ+z0zYtk4S6OXPZcUASOm420y1FQABBvd9bukINCpKmNEXeA+ve7Mnhp8WSt+MPJFDCUYjDLZ1AAgEgB/MH9ABBvzD0lLSsv1PiWQ0jVDajeXFbJ/TkSakvdy+g0TPR27KGAgFYB/UH9gIBWAf3B/gAQb53taVCRMwrV1sky/EE45BOJoTTJ0d6vkLZIb6j4k+G0ABBvlKuPPc+sdv9ffRS/Kj+bSQKZFE7fT/jbtog/5dYYCCQAEG+ZZdBcxF7VCWJS+ti78o7J2qY+aXyKipCl2P0CfXeUhAAQb5gdZIvzW7H8KDz4y1oKMiuAzlXY+TF7PGVAwUvGCn0UAEB/Af7AgEgB/wH/QHB3STEofK4j4twU1E7XMbFoxvESypy3LTYwDOK8PDTfsU7m7/QrVM4uXAPCDM4DuF9Rj5Rwa5nHubwiQG96JmyAoAAAAAAAAAAAAAAACwWw5UNhKfiR67xjp25+WzfI+94wAgqAQHUB/4BAfQH/wHBTVwCELNdrdqiGfrEWdug/e+x+uTpeg0Hl3Of4FDWlMoOvX/5ynDgbp4iqJIvWudSEanWo0qAlOjhWHtga9u2YoAAAAAAAAAAAAAAADtTy9LN0WC7k0S0u1vZuj3+jpEHwAgqAsUBtSXrWzxfbm3NYGvue6B6DsgwNSEoSbfgVZSZwPa61U0hHxV0v2I9FHh3CMX91WXjKaJav6SQlemEQm8ZvPBJdIAAAAAAAAAAAAAAAABZkbSVtqbctXj6lyJM0V6G9s154sAIAAgBAgEgCAIIAwAwQ7msoAQ7msoAN6EgA+ThwEBfXhADmJaAAgEgCAQIBQCDv9Puq7M91Ok9wKCG3vFOmiL6D1LDuC2RgNLJo6HSodzQAAAAAAAAAAAAAAAANq8bD78K9dOfIMgnp9lT6WUCKLFAAgEgCAYIBwIBIAgOCA8CASAICAgJAIG/XBp3bLBOEu23FTSBzBa5IlK4s1p0+byPcnzmCBHOOQYAAAAAAAAAAAAAAAHXEuss214ZDOQ4KXF2+/cT+XczlQCBvwm4MIVDGJ9sh1N+N3XHsypL5nt3MhSQe0h1WNxV4VPYAAAAAAAAAAAAAAACLBqXTdiX0HunZ9UNIK2Vixlfqb4CASAICggLAgEgCAwIDQCBvuPG9uJvTJvcMq9AENwcv+F2Ds2MK6qNRDT23yGCaFWgAAAAAAAAAAAAAAAEQakxkag0h3kXzSwHNaCeOj4A/ZQAgb6wTxxyKMBuaRoElV/J+Cpjml/hBI75zkgUZUL1bCVj8AAAAAAAAAAAAAAAB6DTxC95W6LbcH1CGt0x3tqfH+wYAIG+rHBg7ICT4fRgYFzvSBkUlzqipS9wfLBT7Ik0F9I2H4AAAAAAAAAAAAAAAAMVTmQMVtAjqYiQQmok0ady9aOLKAIBIAgQCBEAgb9pzGGGv53OeG2mkZUKD6QWqMvrms510efWbDJGPWtiBAAAAAAAAAAAAAAAAJF+lPB9n2/zVZVtGlFg37X+b1iHAIG/D1+FOb82pREFPgW7AlzNlZ7f0XnvmGakW23wpWeILAgAAAAAAAAAAAAAAAEOTG4wp40qMFmlUCM1WMn9RHPCGgCBvxG4PesUPI1Sm5e0ECdZPKQpUC5jtQouvJ7jX2y3ZvbkAAAAAAAAAAAAAAACVSuZLsCaLBv/vu29FSGel8ssxd4CA6AyCBQIFQIDe2AIIQgiAQEgCBYBASAIIAEACBcBFP8A9KQT9LzyyAsIGAIBIAgZCBoSARSBLpNQdt9VeMLbJ8fnbEcjlS06HHk1LlyuKq9IzGmLAApICDsIPAIC8QgbCBwBzQw7UTQ1NMf0//0BNGAIIAkU1H0anAhbpJsIY43IdAg10nCJ44p0wfXCx/4I7sBwBKwjhcwgCJYUWb0blRVIfRuMIAkQBX0WjADf5JsIeKTE18D4uKOgts83wPIzBLLH8v/9ADJ7VSAIHQP3IMI1xgg0x/TH9MfAfgjufJjINdkgwa88mftRNDU0x/T//QE0VFSuvKhBYIQVm90ZbqPRwLTD9P/0SHbPDDTBwGA37DAU/Kp0x8BghCOgSeKuvKp0//TPzBImfkR8qL4AAKkqTgfVRIDyMwSyx/L//QAye1U+A9Y2zww4IAhOCE8IHwFM+BAhgwf0fW+lkVvhUgLbPI4RIG6XMAGDB/RbMJUCgwf0FuKRW+IIHgOiMds8MAH5ACLbPDMl+CO7lF8JbX/gJrqTXwdw4DdUEGbbPG0Fc6m0ASFulF8HbX/gEDUQJBA2RgaAzsjKBxbLHxTMEsoA9ADKP8v/Ac8WydB/CFMIYAhUAARfBwBAy7nRBilUQ5qDqR8ng1+50uPnmJEDVmUMPEk8lGI0ZGgBA6NACCMBA6TACCkEQgG8U8dY3AQUYtTZihfOohh+9FF0IJJx5lOM4EwuPVyHPQgkCCUIJggnAdeAF1R8jFwhujuPricm0e1gz71xFVC1unmSMBNTF5DwvU4BDrFcx0GoFlHaqvGlh6lN1nFJt0CeG6d8qLwhz6AYlxGhIrjWXD2ZaHuQ7wBDTpHEg8CnJYx3Bz6a8tDGhyV9YAAQAAnEAAAE4ggIKADDn/1a+0cTe8Yvi/ZQsA+coPdVpjhr/KppZ4gw8L0gPsmNEfCgEGzuZMqQvsD2k9B5c90vwjHcHRXzqvvOffh1fQ+epla70YPN+ugAErvNTnNi3/joMgXek2GU0P1nbg2uAXgAg4AHYldUpSX+OnMGEmrzFbDaDndofbVWwipsELsyEFBh7VwMyVoe1bm3g+ofLtd9oI5jtHH7FMyRcCRcz4sgn8+ZqADFgAzR40sWE+ZDiVtMPp0luvRhPSDmUFJbPnCVn8SljhP8MALqj5GLhDdHcfXE5No9rBn3riKqFrdPMkYCamLyHhepwNRlkzQtSe1JZIAh3XgS5jXa20urpZimQbG1DVZHG6T+AMoAAA3XAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGB3STEofK4j4twU1E7XMbFoxvESypy3LTYwDOK8PDTfsUrV4RD7BD+j/C+Xsu8FBO9BOOOwISjNPbBC8tcq688GcAIKgIBIAgrCCwCASAILQguAgFYCDUINgIBIAgvCDACAW4IMwg0AgFICDEIMgCBv19AAsPwOQTxQe6TMMZhucVFQUwZxXSXRDTzz6eDEyMMAAAAAAAAAAAAAAAAZCxZVdpO3O/exjKQQLDZKEATUsUAgb7b5zYalZtWfXVNf/eJjajDkigrZBF6MOoqRryqRa1d8AAAAAAAAAAAAAAABnpT4TDDVSCchxI30CCK0CSoQtXMAIG+yVVjwR8uIEXcrCnU8xqsZA3AnT4W7vNmb8SpRACLwyAAAAAAAAAAAAAAAAC+5VjYpAsIe2PT1MZ4G4bgdjglNACBvv0SlrVQ6nXApJnTklLM8G4Ym1fiFlc8/w/ytGnq4YuAAAAAAAAAAAAAAAAH+iD8xE1SOuzp2OMcYs3CYovMI2wAgb7BfO7Uh+H3EB0m1yBz06mQbBZzUT+0G1yNEV2s9+jiyAAAAAAAAAAAAAAAB+LjUWgNTCXU9Vvnw9NotNVLkGBkAIG/X7BE4d+cHa1Ku+INz+IhIOcCQYgWeItfGbthwsz7nP4AAAAAAAAAAAAAAAGJk3sG1XFojKMubCzSM8esSSPAgwIBSAg3CDgAgb7Sh7LpRZwVdThtIdwoxok0VwOBgOviYK5sYcUz2FIYmAAAAAAAAAAAAAAAAEmbnDTO45niNQamX17RfCFw1j7MAgFYCDkIOgCBvmmMMnQNMca8fZIP+x0yN8gWr6U5ByGQu8VgDeEvwxEgAAAAAAAAAAAAAAAP5XdVgp4eMGnNoEM/EKtL7DP8WJAAgb5Eqppp0KeN70d/E180uKVPT4rZhmsU5SS3wy97lJEAYAAAAAAAAAAAAAAAAHPp0QyGV6nnlqDF8ww9/eftW0UQAgLFCD0IPgIBIAhYCFkCAc0IPwhAAAaqglsCASAIQQhCAgFICFYIVwIBSAhDCEQAM/aGmDgOAJeUTpj+mP6Yfph5gQYQB5RN95RMBPMAdDTA/pAMCD6RCKNCGAB/R0aKXd3vhRm8waIinYt5LIpyc1W2i2RJQbcs7lykeTHBQLA/1IgsbMEcbAUsSTHALGSXwXgA9Mf0z8ighBuQ1NsvVJgsPJlIoIQTlZTVLrjAjQhghBuQ1NsuuMCNCCCEG5WUFK64wI0I4AhFCEYIRwhIACU7UTQ1FAzgCD0FcjMAc8Wye1UgAIYyNDQD1NFx+DMgbpIwf5TQ1wv/4gJwA7qcMSDwByH4I7wCvLAB3gGfgCQB8AGCEO52T0uAQPAI4DCCEO52T2+AQPAIAIo1W9TSH/pA0SLXOTEj12Ui+kRbAcAAAcAAsCKFCbojgfv/urFQBbAUsJ4B8AEBghDvdk9LgEDwCOBbAYIQ73ZPb4BA8AgBOjAD2zyAQCGjIsL/nFt0+wKCEO5WUFKDBpEy4vAICEkCwIIQVm90ZbqPSjODCNcYINMf0w/T/9ECghBWb3RFuvKlINs8MNMHAYDfsMBT8qnTHwGCEI6BJ4q68qnT/9M/MERV+RHyogLbPIIQ1nRSQKCAQPAI4F8DIMAAAYMesLHypQhOCE8D9AHTH9TSADAiqx2VAvgjoQLeIds8IoUJuiOB+/+6sZhfB4IXPI2WquAgwv+OFyL4MyBukjBwkvkA4iG9lzCCFx2bnKrejhV5+DNSMIAg9AxvoTGXMIIXMq+RlN7iIddlgwe+lzCCFz2em6reIMH/kmxh4CORMuMOIcH/CGEISghLACh6+DMTgCD0DG+hMZeCFzyNlqwy3gTukxVfBeAxIYAL+DPbPDQ0NVKAuZhfCYIXOoePl+BQc7YIA4MJ+UEygwmgF6gGpgISqBWgUwGoAvgjoO1E0NTTH9P/9ATRKPkAUwGDB/QOb6HjAjA2Uaahgx25mF8KghcPnobc4Ns8MHOptAFwbQP5ABBXEEsaQzAIXAhMCFMITQHUODk5Bds8Uk29mF8Pghc8jZar4FNYvphfD4IXPpONu+BShqGDDaAZqFHdoYMduZhfDYIXD56G3OAQVkAUUHcDgM7IygcWyx8UzBLKAPQAyj/L/1AEzxZARYMH9EMTA8jMEssfy//0AMntVAhgAFqAzsjKBxbLHxTMEsoA9ADKP8v/F8sHFMsPQBaDB/RDEgPIzBLLH8v/9ADJ7VQBGNs8MlmAEPQOb6EwAQhTA8TtRNDU0x/T//QE0UYTUFTbPFRzVCUDyMwSyx/L//QAye1UIW6SbFGPOHYhoURA2zxUcmUmA8jMEssfy//0AMntVCGOl/gPECMQJds8RAMDyMwSyx/L//QAye1UlBBGXwbi4ghQCFEIUgTaUyODB/QOb6GUXwRtf+HbPDAB+QAC2zwm+CO7ml8LAYMH9FswbX/gUxi9jowxMiLbPG0Fc6m0ARWSNzfiJW6aXwkBgwf0WzBtf+BTgYAQ9A5voTGUXwptfuD4I8jLH1CSgBD0QydQh6FSB7LC/whTCGAIVAhVAcoB2zxTJIAg9GogbpIwcJL5AOIhvQHC/7CUXwNwbeAhhQm6IoH7/7qxlF8DcG3geSSAIPRqUiCAIPQMb6ExIW6wlF8DcG3geiSAIPRqUiCAIPQMb6ExUAO5k1twbeBUYQSAIPQVWQhhAIIhgfwZup1sISBukjBwlNDXC//i4CBukVvgIYH8GLqOFDHQ1CH7BO1DAtDtHu1TAfEGgvIA4AGB/Be6k9DwC5Ew4gAsgCL4MyDQ0wcBwBLyqIBg1yHTP/QE0QFigAv4M9s8EEdfBwLTB9MH0wcwA8L/E6FSBLyTXwNt4KUgwQCTXwNt4MjLB8sHywfJ0AhcAe6OH1UjgM7IygcWyx8UzBLKAPQAyj/L/wHPFgKDB/RDbXLgIIAL+DPbPBBXXwcE0wfTB9MHMAGkUge+jhBbUFZfBVAjgwf0WzB2WKES4BBFEDQQI0h2gM7IygcWyx8UzBLKAPQAyj/L/xLLBxLLB8sHAoMH9ENtcghcACtHCAGMjLBVAFzxYUy27LH8s/yQH7AIAFtXH4M9DXC//4I4IQTkNvZHCCAMT/yMsQFMv/gx36AhPLahLLH8s/Ac8WyXD7AIAgEgCFoIWwFpvRwXaiaGppj+n/+gJothjCf7bHTqiJQYP6PzfSkEdGAW2eKQg3gSgBt4EBSJlxANmJczYQwIXwFdulRe1E0NdMgAsBgCD0ahTbPGxEUlS5k18Gf+BQRLYIAoMJoBOoA6YCEqgSoAGogIXAIBIAhdCF4AVNDTBwGBAJG68qwBktQx3tdM0NMHAcA28qzTB9MH0wfTB9Mf0x/TH9Mf0QARtZL9qJoa4WPwATe2EX2omhqaY/p//oCaLYYwYP6BzfQyRg28O2eQCF8CYNs8bYMfjhIlgBD0fm+lMiGVUgNvAgLeAbPmMDTTB9MH0wfRB9s8bwMGBxA1EDRvCQhgCGEAJNIHAcDO8qzTH9TSAPQE0j/T/wAu0NIHAcDz8qzSH/QE0gABktP/kn8B4tGYBL48", "config_params_boc_error": "to_boc_returned_str", "libs_boc": null, diff --git a/src/emulator/src/tests/test_emulator.rs b/src/emulator/src/tests/test_emulator.rs index 4c44ebab..3fb76130 100644 --- a/src/emulator/src/tests/test_emulator.rs +++ b/src/emulator/src/tests/test_emulator.rs @@ -8,7 +8,8 @@ */ use super::*; use ton_block::{ - base64_decode, base64_encode, read_single_root_boc, write_boc, Serializable, Transaction, + Account, Deserializable, Serializable, Transaction, base64_decode, base64_encode, + read_single_root_boc, write_boc, }; fn cell_to_base64(cell: &Cell) -> String { @@ -64,16 +65,17 @@ fn test_transaction() { CString::new(json["prev_blocks_info_boc"].as_str().unwrap()).unwrap(); let expected_tx_hash = json["tx_hash"].as_str().unwrap(); - // 5. Create emulator - let p = transaction_emulator_create(config_params_boc.as_ptr(), 5); + // 5. Block parameters from JSON + let now = json["now"].as_u64().unwrap() as u32; + let lt = json["lt"].as_u64().unwrap(); + let rand_seed_hex = CString::new(json["rand_seed"].as_str().unwrap()).unwrap(); - // 6. Set block parameters - transaction_emulator_set_unixtime(p, 1770822950); - transaction_emulator_set_lt(p, 66815326000001); + // 6. Create emulator + let p = transaction_emulator_create(config_params_boc.as_ptr(), 5); - // rand_seed - let rand_seed_hex = - CString::new("628d5512834b482d4982d69d445da5f63e79de5f45f7ac52b25a9efc9a0db11c").unwrap(); + // 7. Set block parameters + transaction_emulator_set_unixtime(p, now); + transaction_emulator_set_lt(p, lt); transaction_emulator_set_rand_seed(p, rand_seed_hex.as_ptr()); // 7. Set prev blocks info @@ -97,3 +99,311 @@ fn test_transaction() { transaction_emulator_destroy(p); } + +// ===== TVM Emulator tests ===== + +/// Helper: extract code and data cells from an account BoC file +fn load_account_code_data(path: &str) -> (Cell, Cell) { + let account_root = Cell::read_from_file(path); + let account = Account::construct_from_cell(account_root).unwrap(); + let code = account.get_code().expect("Account has no code"); + let data = account.get_data().unwrap_or_default(); + (code, data) +} + +#[test] +fn test_tvm_emulator_create_destroy() { + let (code, data) = load_account_code_data("../executor/real_boc/simple_account_old.boc"); + let code_boc = CString::new(cell_to_base64(&code)).unwrap(); + let data_boc = CString::new(cell_to_base64(&data)).unwrap(); + + let p = tvm_emulator_create(code_boc.as_ptr(), data_boc.as_ptr(), 0); + assert!(!p.is_null(), "tvm_emulator_create returned null"); + tvm_emulator_destroy(p); +} + +#[test] +fn test_tvm_emulator_set_gas_limit() { + let (code, data) = load_account_code_data("../executor/real_boc/simple_account_old.boc"); + let code_boc = CString::new(cell_to_base64(&code)).unwrap(); + let data_boc = CString::new(cell_to_base64(&data)).unwrap(); + + let p = tvm_emulator_create(code_boc.as_ptr(), data_boc.as_ptr(), 0); + assert!(!p.is_null()); + + let ok = tvm_emulator_set_gas_limit(p, 500_000); + assert!(ok, "tvm_emulator_set_gas_limit failed"); + + let ok = tvm_emulator_set_debug_enabled(p, true); + assert!(ok, "tvm_emulator_set_debug_enabled failed"); + + tvm_emulator_destroy(p); +} + +#[test] +fn test_tvm_emulator_set_c7() { + let (code, data) = load_account_code_data("../executor/real_boc/simple_account_old.boc"); + let code_boc = CString::new(cell_to_base64(&code)).unwrap(); + let data_boc = CString::new(cell_to_base64(&data)).unwrap(); + + let p = tvm_emulator_create(code_boc.as_ptr(), data_boc.as_ptr(), 0); + assert!(!p.is_null()); + + let address = + CString::new("0:1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef").unwrap(); + let rand_seed = + CString::new("628d5512834b482d4982d69d445da5f63e79de5f45f7ac52b25a9efc9a0db11c").unwrap(); + + let ok = tvm_emulator_set_c7( + p, + address.as_ptr(), + 1700000000, + 1_000_000_000, + rand_seed.as_ptr(), + std::ptr::null(), // no config + ); + assert!(ok, "tvm_emulator_set_c7 failed"); + + tvm_emulator_destroy(p); +} + +#[test] +fn test_tvm_emulator_set_c7_with_config() { + let (code, data) = load_account_code_data("../executor/real_boc/simple_account_old.boc"); + let code_boc = CString::new(cell_to_base64(&code)).unwrap(); + let data_boc = CString::new(cell_to_base64(&data)).unwrap(); + + let config = ConfigParams::construct_from_file("../executor/real_boc/config.boc").unwrap(); + let config_boc = CString::new(cell_to_base64(config.root().unwrap())).unwrap(); + + let p = tvm_emulator_create(code_boc.as_ptr(), data_boc.as_ptr(), 0); + assert!(!p.is_null()); + + let address = + CString::new("0:1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef").unwrap(); + let rand_seed = + CString::new("628d5512834b482d4982d69d445da5f63e79de5f45f7ac52b25a9efc9a0db11c").unwrap(); + + let ok = tvm_emulator_set_c7( + p, + address.as_ptr(), + 1700000000, + 1_000_000_000, + rand_seed.as_ptr(), + config_boc.as_ptr(), + ); + assert!(ok, "tvm_emulator_set_c7 with config failed"); + + tvm_emulator_destroy(p); +} + +#[test] +fn test_tvm_emulator_set_libraries() { + let (code, data) = load_account_code_data("../executor/real_boc/simple_account_old.boc"); + let code_boc = CString::new(cell_to_base64(&code)).unwrap(); + let data_boc = CString::new(cell_to_base64(&data)).unwrap(); + + let p = tvm_emulator_create(code_boc.as_ptr(), data_boc.as_ptr(), 0); + assert!(!p.is_null()); + + // Passing null should return false + let ok = tvm_emulator_set_libraries(p, std::ptr::null()); + assert!(!ok, "tvm_emulator_set_libraries should fail with null"); + + tvm_emulator_destroy(p); +} + +#[test] +fn test_tvm_emulator_run_get_method_simple() { + let (code, data) = load_account_code_data("../executor/real_boc/simple_account_old.boc"); + let code_boc = CString::new(cell_to_base64(&code)).unwrap(); + let data_boc = CString::new(cell_to_base64(&data)).unwrap(); + + let p = tvm_emulator_create(code_boc.as_ptr(), data_boc.as_ptr(), 4); + assert!(!p.is_null()); + + // Set c7 so the emulator has basic context + let address = + CString::new("0:1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef").unwrap(); + let rand_seed = + CString::new("628d5512834b482d4982d69d445da5f63e79de5f45f7ac52b25a9efc9a0db11c").unwrap(); + tvm_emulator_set_c7( + p, + address.as_ptr(), + 1700000000, + 1_000_000_000, + rand_seed.as_ptr(), + std::ptr::null(), + ); + + // Run get method with empty stack (null stack_boc) + // seqno get method id = 85143 + let result = tvm_emulator_run_get_method(p, 85143, std::ptr::null()); + assert!(!result.is_null(), "tvm_emulator_run_get_method returned null"); + + let result_str = unsafe { CString::from_raw(result as *mut c_char) }; + let result_json: serde_json::Value = serde_json::from_slice(result_str.as_bytes()).unwrap(); + println!("run_get_method result: {}", result_json); + + // The result should have the expected fields + assert_eq!(result_json["vm_exit_code"].as_i64().unwrap(), 0); + assert_eq!(result_json["gas_used"].as_i64().unwrap(), 571); + + tvm_emulator_destroy(p); +} + +#[test] +fn test_tvm_emulator_run_get_method_with_json_data() { + // Use the same JSON test data as transaction test to get a real account + let json_path = "src/tests/4C90C139A5736F34EA3EEF62F0B06431719913835EA5A1B9173F20B2EF711583_66815326000001.json"; + let json_str = std::fs::read_to_string(json_path).unwrap(); + let json: serde_json::Value = serde_json::from_str(&json_str).unwrap(); + + // Extract account from shard_account_boc + let shard_account_boc_str = json["shard_account_boc"].as_str().unwrap(); + let shard_account_cell = + read_single_root_boc(base64_decode(shard_account_boc_str).unwrap()).unwrap(); + let shard_acc = ShardAccount::construct_from_cell(shard_account_cell).unwrap(); + let account = shard_acc.read_account().unwrap(); + + let code = account.get_code().expect("Account has no code"); + let data = account.get_data().unwrap_or_default(); + + let code_boc = CString::new(cell_to_base64(&code)).unwrap(); + let data_boc = CString::new(cell_to_base64(&data)).unwrap(); + let config_params_boc = CString::new(json["config_params_boc"].as_str().unwrap()).unwrap(); + + let p = tvm_emulator_create(code_boc.as_ptr(), data_boc.as_ptr(), 4); + assert!(!p.is_null()); + + // Set c7 with config + let address = account.get_addr().unwrap(); + let address_str = + CString::new(format!("{}:{:x}", address.workchain_id(), address.address())).unwrap(); + let rand_seed = CString::new(json["rand_seed"].as_str().unwrap()).unwrap(); + + tvm_emulator_set_c7( + p, + address_str.as_ptr(), + json["now"].as_u64().unwrap_or(1700000000) as u32, + 1_000_000_000, + rand_seed.as_ptr(), + config_params_boc.as_ptr(), + ); + + tvm_emulator_set_gas_limit(p, 1_000_000); + + // Try running seqno (method_id = 85143) + let result = tvm_emulator_run_get_method(p, 85143, std::ptr::null()); + assert!(!result.is_null()); + + let result_str = unsafe { CString::from_raw(result as *mut c_char) }; + let result_json: serde_json::Value = serde_json::from_slice(result_str.as_bytes()).unwrap(); + println!("run_get_method (json data) result: {}", result_json); + + assert_eq!(result_json["vm_exit_code"].as_i64().unwrap(), 0); + assert_eq!(result_json["gas_used"].as_i64().unwrap(), 571); + + tvm_emulator_destroy(p); +} + +#[test] +fn test_tvm_emulator_send_internal_message() { + let (code, data) = load_account_code_data("../executor/real_boc/simple_account_old.boc"); + let code_boc = CString::new(cell_to_base64(&code)).unwrap(); + let data_boc = CString::new(cell_to_base64(&data)).unwrap(); + + let p = tvm_emulator_create(code_boc.as_ptr(), data_boc.as_ptr(), 4); + assert!(!p.is_null()); + + let address = + CString::new("0:1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef").unwrap(); + let rand_seed = + CString::new("0000000000000000000000000000000000000000000000000000000000000000").unwrap(); + tvm_emulator_set_c7( + p, + address.as_ptr(), + 1700000000, + 1_000_000_000, + rand_seed.as_ptr(), + std::ptr::null(), + ); + + // Create an empty message body cell + let empty_body = Cell::default(); + let body_boc = CString::new(cell_to_base64(&empty_body)).unwrap(); + + let result = tvm_emulator_send_internal_message(p, body_boc.as_ptr(), 1_000_000); + assert!(!result.is_null(), "tvm_emulator_send_internal_message returned null"); + + let result_str = unsafe { CString::from_raw(result as *mut c_char) }; + let result_json: serde_json::Value = serde_json::from_slice(result_str.as_bytes()).unwrap(); + println!("send_internal_message result: {}", result_json); + + assert!(result_json.get("vm_exit_code").is_some()); + assert!(result_json.get("gas_used").is_some()); + + tvm_emulator_destroy(p); +} + +#[test] +fn test_tvm_emulator_send_external_message() { + let (code, data) = load_account_code_data("../executor/real_boc/simple_account_old.boc"); + let code_boc = CString::new(cell_to_base64(&code)).unwrap(); + let data_boc = CString::new(cell_to_base64(&data)).unwrap(); + + let p = tvm_emulator_create(code_boc.as_ptr(), data_boc.as_ptr(), 4); + assert!(!p.is_null()); + + let address = + CString::new("0:1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef").unwrap(); + let rand_seed = + CString::new("0000000000000000000000000000000000000000000000000000000000000000").unwrap(); + tvm_emulator_set_c7( + p, + address.as_ptr(), + 1700000000, + 1_000_000_000, + rand_seed.as_ptr(), + std::ptr::null(), + ); + + let empty_body = Cell::default(); + let body_boc = CString::new(cell_to_base64(&empty_body)).unwrap(); + + let result = tvm_emulator_send_external_message(p, body_boc.as_ptr()); + assert!(!result.is_null(), "tvm_emulator_send_external_message returned null"); + + let result_str = unsafe { CString::from_raw(result as *mut c_char) }; + let result_json: serde_json::Value = serde_json::from_slice(result_str.as_bytes()).unwrap(); + println!("send_external_message result: {}", result_json); + + assert!(result_json.get("vm_exit_code").is_some()); + assert!(result_json.get("gas_used").is_some()); + + tvm_emulator_destroy(p); +} + +#[test] +fn test_tvm_emulator_null_safety() { + // All functions should handle null pointers gracefully + assert!(tvm_emulator_create(std::ptr::null(), std::ptr::null(), 0).is_null()); + assert!(!tvm_emulator_set_gas_limit(std::ptr::null_mut(), 100)); + assert!(!tvm_emulator_set_debug_enabled(std::ptr::null_mut(), true)); + assert!(!tvm_emulator_set_libraries(std::ptr::null_mut(), std::ptr::null())); + assert!(!tvm_emulator_set_c7( + std::ptr::null_mut(), + std::ptr::null(), + 0, + 0, + std::ptr::null(), + std::ptr::null(), + )); + assert!(tvm_emulator_run_get_method(std::ptr::null_mut(), 0, std::ptr::null()).is_null()); + assert!(tvm_emulator_send_external_message(std::ptr::null_mut(), std::ptr::null()).is_null()); + assert!( + tvm_emulator_send_internal_message(std::ptr::null_mut(), std::ptr::null(), 0).is_null() + ); + // destroy with null should not crash + tvm_emulator_destroy(std::ptr::null_mut()); +} From d4fa52c85e05935b46899b66a25cf645245f570d Mon Sep 17 00:00:00 2001 From: yaroslavser Date: Mon, 13 Apr 2026 14:50:53 +0300 Subject: [PATCH 2/2] fix formatting --- src/emulator/src/lib.rs | 44 +++++++++---------------- src/emulator/src/tests/test_emulator.rs | 8 ++--- 2 files changed, 19 insertions(+), 33 deletions(-) diff --git a/src/emulator/src/lib.rs b/src/emulator/src/lib.rs index e78c1454..24758b5b 100644 --- a/src/emulator/src/lib.rs +++ b/src/emulator/src/lib.rs @@ -7,12 +7,14 @@ * This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND. */ use serde_json::json; -use std::ffi::{c_char, c_void, CStr, CString}; -use std::str::FromStr; +use std::{ + ffi::{c_char, c_void, CStr, CString}, + str::FromStr, +}; use ton_block::{ - base64_decode, base64_encode, fail, read_single_root_boc, write_boc, BuilderData, Cell, - ConfigParams, Deserializable, HashUpdate, HashmapE, IBitstring, MsgAddressInt, Result, - Serializable, ShardAccount, SliceData, TransactionTickTock, UInt256, + base64_decode, base64_encode, error, fail, read_single_root_boc, write_boc, BuilderData, Cell, + ConfigParams, CurrencyCollection, Deserializable, HashUpdate, HashmapE, IBitstring, + MsgAddressInt, Result, Serializable, ShardAccount, SliceData, TransactionTickTock, UInt256, }; use ton_executor::{ BlockchainConfig, ExecuteParams, ExecutorError, OrdinaryTransactionExecutor, @@ -22,9 +24,7 @@ use ton_vm::{ error::tvm_exception_or_custom_code, executor::{gas::gas_state::Gas, BehaviorModifiers, Engine}, smart_contract_info::{PrevBlocksInfo, SmartContractInfo}, - stack::{ - integer::IntegerData, read_stack_item, savelist::SaveList, Stack, StackItem, - }, + stack::{integer::IntegerData, read_stack_item, savelist::SaveList, Stack, StackItem}, }; include!("../../common/src/log.rs"); @@ -562,9 +562,7 @@ impl TvmEmulator { ) -> StackItem { let mut smc_info = SmartContractInfo { unix_time: unixtime, - balance: ton_block::CurrencyCollection::from_coins( - ton_block::Coins::new(balance), - ), + balance: CurrencyCollection::with_coins(balance), myself: address.clone(), rand_seed, mycode: self.code.clone(), @@ -590,10 +588,7 @@ impl TvmEmulator { libraries.push(HashmapE::with_hashmap(256, Some(libs.clone()))); } - let caps = self - .config_params - .as_ref() - .map_or(0, |cp| cp.capabilities()); + let caps = self.config_params.as_ref().map_or(0, |cp| cp.capabilities()); let mut vm = Engine::with_capabilities(caps).setup_checked( self.code.clone(), ctrls, @@ -646,11 +641,7 @@ impl TvmEmulator { Ok(format!("{result:#}")) } - fn send_message( - &self, - message_body: Cell, - amount: Option, - ) -> Result { + fn send_message(&self, message_body: Cell, amount: Option) -> Result { let is_external = amount.is_none(); let msg_balance = amount.unwrap_or(0); let function_selector = StackItem::int(if is_external { -1i32 } else { 0i32 }); @@ -896,7 +887,9 @@ pub extern "C" fn tvm_emulator_set_prev_blocks_info( // which is complex. The user should call set_c7 after this. match deserialize_boc(info_boc) { Ok(_info_cell) => { - log::warn!("tvm_emulator_set_prev_blocks_info: to take effect, call tvm_emulator_set_c7 after this"); + log::warn!( + "tvm_emulator_set_prev_blocks_info: to take effect, call tvm_emulator_set_c7 after this" + ); true } Err(err) => { @@ -913,10 +906,7 @@ pub extern "C" fn tvm_emulator_set_prev_blocks_info( * @return true in case of success, false in case of error */ #[unsafe(no_mangle)] -pub extern "C" fn tvm_emulator_set_gas_limit( - tvm_emulator: *mut c_void, - gas_limit: i64, -) -> bool { +pub extern "C" fn tvm_emulator_set_gas_limit(tvm_emulator: *mut c_void, gas_limit: i64) -> bool { if tvm_emulator.is_null() { log::error!("Received null pointer for tvm_emulator"); return false; @@ -1109,9 +1099,7 @@ fn parse_address(address: &str) -> Result { if parts.len() != 2 { fail!("Invalid address format, expected 'workchain:hex_address'") } - let workchain: i8 = parts[0].parse().map_err(|e| { - ton_block::error!("Failed to parse workchain: {}", e) - })?; + let workchain: i8 = parts[0].parse().map_err(|e| error!("Failed to parse workchain: {}", e))?; let account_id = UInt256::from_str(parts[1])?; let addr = MsgAddressInt::with_standart(None, workchain, account_id.into())?; addr.write_to_bitstring() diff --git a/src/emulator/src/tests/test_emulator.rs b/src/emulator/src/tests/test_emulator.rs index 3fb76130..e5a61b6a 100644 --- a/src/emulator/src/tests/test_emulator.rs +++ b/src/emulator/src/tests/test_emulator.rs @@ -8,8 +8,8 @@ */ use super::*; use ton_block::{ - Account, Deserializable, Serializable, Transaction, base64_decode, base64_encode, - read_single_root_boc, write_boc, + base64_decode, base64_encode, read_single_root_boc, write_boc, Account, Deserializable, + Serializable, Transaction, }; fn cell_to_base64(cell: &Cell) -> String { @@ -401,9 +401,7 @@ fn test_tvm_emulator_null_safety() { )); assert!(tvm_emulator_run_get_method(std::ptr::null_mut(), 0, std::ptr::null()).is_null()); assert!(tvm_emulator_send_external_message(std::ptr::null_mut(), std::ptr::null()).is_null()); - assert!( - tvm_emulator_send_internal_message(std::ptr::null_mut(), std::ptr::null(), 0).is_null() - ); + assert!(tvm_emulator_send_internal_message(std::ptr::null_mut(), std::ptr::null(), 0).is_null()); // destroy with null should not crash tvm_emulator_destroy(std::ptr::null_mut()); }