From 569eab58802cbc6ea3385c246faf68237d134d21 Mon Sep 17 00:00:00 2001 From: "NGnius (Graham)" Date: Sun, 11 Sep 2022 23:45:31 -0400 Subject: [PATCH] Complete proof of concept --- .gitignore | 4 +- {server => backend}/Cargo.lock | 33 ++- {server => backend}/Cargo.toml | 7 +- {server => backend}/Cross.toml | 0 backend/build.sh | 12 + backend/src/api/about.rs | 25 +++ backend/src/api/get_display.rs | 72 ++++++ backend/src/api/get_item.rs | 26 +++ backend/src/api/mod.rs | 13 ++ backend/src/api/on_update.rs | 34 +++ backend/src/api/reload.rs | 26 +++ backend/src/config/about.rs | 24 ++ {server => backend}/src/config/action.rs | 0 backend/src/config/base.rs | 52 +++++ {server => backend}/src/config/button.rs | 0 {server => backend}/src/config/element.rs | 6 +- {server => backend}/src/config/mod.rs | 13 +- {server => backend}/src/config/reading.rs | 0 backend/src/config/result_display.rs | 8 + {server => backend}/src/config/slider.rs | 0 {server => backend}/src/config/toggle.rs | 3 +- backend/src/consts.rs | 6 + backend/src/main.rs | 34 +++ backend/src/runtime/actor.rs | 68 ++++++ backend/src/runtime/command_actor.rs | 61 +++++ backend/src/runtime/communication.rs | 26 +++ backend/src/runtime/executor.rs | 121 ++++++++++ backend/src/runtime/mod.rs | 14 ++ backend/src/runtime/periodic_actor.rs | 57 +++++ backend/src/runtime/primitive_utils.rs | 84 +++++++ backend/src/runtime/result_router.rs | 133 +++++++++++ kaylon.json | 57 +++++ main.py | 4 +- package.json | 2 +- server/build.sh | 6 - server/src/config/about.rs | 11 - server/src/config/base.rs | 13 -- server/src/main.rs | 27 --- src/backend.ts | 22 +- src/index.tsx | 257 +++++++++++++++++----- src/usdpl_front/README.md | 9 + src/usdpl_front/package.json | 2 +- src/usdpl_front/usdpl_front.d.ts | 25 ++- src/usdpl_front/usdpl_front.js | 180 +++++++++++++-- src/usdpl_front/usdpl_front_bg.wasm | Bin 78248 -> 93759 bytes src/usdpl_front/usdpl_front_bg.wasm.d.ts | 5 +- 46 files changed, 1413 insertions(+), 169 deletions(-) rename {server => backend}/Cargo.lock (98%) rename {server => backend}/Cargo.toml (68%) rename {server => backend}/Cross.toml (100%) create mode 100755 backend/build.sh create mode 100644 backend/src/api/about.rs create mode 100644 backend/src/api/get_display.rs create mode 100644 backend/src/api/get_item.rs create mode 100644 backend/src/api/mod.rs create mode 100644 backend/src/api/on_update.rs create mode 100644 backend/src/api/reload.rs create mode 100644 backend/src/config/about.rs rename {server => backend}/src/config/action.rs (100%) create mode 100644 backend/src/config/base.rs rename {server => backend}/src/config/button.rs (100%) rename {server => backend}/src/config/element.rs (73%) rename {server => backend}/src/config/mod.rs (79%) rename {server => backend}/src/config/reading.rs (100%) create mode 100644 backend/src/config/result_display.rs rename {server => backend}/src/config/slider.rs (100%) rename {server => backend}/src/config/toggle.rs (74%) create mode 100644 backend/src/consts.rs create mode 100644 backend/src/main.rs create mode 100644 backend/src/runtime/actor.rs create mode 100644 backend/src/runtime/command_actor.rs create mode 100644 backend/src/runtime/communication.rs create mode 100644 backend/src/runtime/executor.rs create mode 100644 backend/src/runtime/mod.rs create mode 100644 backend/src/runtime/periodic_actor.rs create mode 100644 backend/src/runtime/primitive_utils.rs create mode 100644 backend/src/runtime/result_router.rs create mode 100644 kaylon.json delete mode 100755 server/build.sh delete mode 100644 server/src/config/about.rs delete mode 100644 server/src/config/base.rs delete mode 100644 server/src/main.rs create mode 100644 src/usdpl_front/README.md diff --git a/.gitignore b/.gitignore index 08fb4c6..d76d9aa 100644 --- a/.gitignore +++ b/.gitignore @@ -42,8 +42,8 @@ yalc.lock .vscode/settings.json # ignore Rust compiler files -/server/target -backend +/backend/target +/backend/out /bin # packaged teasers diff --git a/server/Cargo.lock b/backend/Cargo.lock similarity index 98% rename from server/Cargo.lock rename to backend/Cargo.lock index 7c22aad..1411f60 100644 --- a/server/Cargo.lock +++ b/backend/Cargo.lock @@ -2,6 +2,28 @@ # It is not intended for manual editing. version = 3 +[[package]] +name = "async-recursion" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2cda8f4bcc10624c4e85bc66b3f452cca98cfa5ca002dc83a16aad2367641bea" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "async-trait" +version = "0.1.57" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76464446b8bc32758d7e88ee1a804d9914cd9b1cb264c029899680b0be29826f" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "autocfg" version = "1.1.0" @@ -349,10 +371,12 @@ checksum = "112c678d4050afce233f4f2852bb2eb519230b3cf12f33585275537d7e41578d" name = "kaylon" version = "0.1.0" dependencies = [ + "async-trait", "log", "serde", "serde_json", "simplelog", + "tokio", "usdpl-back", ] @@ -959,11 +983,12 @@ dependencies = [ [[package]] name = "usdpl-back" -version = "0.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cbbc0781e83ba990f8239142e33173a2d2548701775f3db66702d1af4fd0319a" +version = "0.7.0" dependencies = [ + "async-recursion", + "async-trait", "bytes", + "log", "tokio", "usdpl-core", "warp", @@ -972,8 +997,6 @@ dependencies = [ [[package]] name = "usdpl-core" version = "0.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "862153581fac266458521f49e5906a71c1eee1665cb4c7d71e9586bd34b45394" dependencies = [ "base64", ] diff --git a/server/Cargo.toml b/backend/Cargo.toml similarity index 68% rename from server/Cargo.toml rename to backend/Cargo.toml index 149dc12..8f61ea2 100644 --- a/server/Cargo.toml +++ b/backend/Cargo.toml @@ -6,8 +6,13 @@ edition = "2021" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -usdpl-back = { version = "0.6.0", features = ["decky"] } +usdpl-back = { version = "0.7.0", features = ["decky"], path = "../../usdpl-rs/usdpl-back" } +# async +tokio = { version = "*", features = ["sync", "time"] } +async-trait = "0.1.57" + +# json serde = { version = "1.0", features = ["derive"] } serde_json = "1.0" diff --git a/server/Cross.toml b/backend/Cross.toml similarity index 100% rename from server/Cross.toml rename to backend/Cross.toml diff --git a/backend/build.sh b/backend/build.sh new file mode 100755 index 0000000..37223e7 --- /dev/null +++ b/backend/build.sh @@ -0,0 +1,12 @@ +#!/bin/bash + +#cargo build --release --target x86_64-unknown-linux-musl +cargo build --target x86_64-unknown-linux-musl +#cross build --release + +mkdir -p ../bin +#cp ./target/x86_64-unknown-linux-musl/release/kaylon ../bin/backend +cp ./target/x86_64-unknown-linux-musl/debug/kaylon ../bin/backend +#cp ./target/release/kaylon ../bin/backend + +cp ../kaylon.json ../bin/kaylon.json diff --git a/backend/src/api/about.rs b/backend/src/api/about.rs new file mode 100644 index 0000000..410cf70 --- /dev/null +++ b/backend/src/api/about.rs @@ -0,0 +1,25 @@ +use std::sync::{Mutex, mpsc::{Sender, channel}}; + +use super::ApiParameterType; + +use crate::runtime::{QueueAction, QueueItem}; + +pub fn get_about(sender: Sender) -> impl Fn(ApiParameterType) -> ApiParameterType { + let sender = Mutex::new(sender); + move |_| { + log::debug!("API: get_about"); + let (rx, tx) = channel(); + sender.lock().unwrap().send( + QueueItem { + action: QueueAction::GetAbout { + respond_to: rx, + } + } + ).unwrap(); + vec![ + usdpl_back::core::serdes::Primitive::Json( + serde_json::to_string(&tx.recv().unwrap()).unwrap() + ) + ] + } +} diff --git a/backend/src/api/get_display.rs b/backend/src/api/get_display.rs new file mode 100644 index 0000000..10233d1 --- /dev/null +++ b/backend/src/api/get_display.rs @@ -0,0 +1,72 @@ +use std::sync::{Mutex, mpsc::{Sender, channel, self}}; + +use usdpl_back::core::serdes::Primitive; +use usdpl_back::AsyncCallable; + +use super::ApiParameterType; + +use crate::runtime::{QueueAction, QueueItem}; + +pub struct GetDisplayEndpoint { + //sender: tokio::sync::mpsc::Sender, + //receiver: Mutex>>, + sync_sender: Mutex>, +} + +impl GetDisplayEndpoint { + pub fn new(sender: Sender) -> Self { + //let (async_tx, async_rx) = tokio::sync::mpsc::channel::(64); + Self { + //sender: async_tx, + //receiver: Mutex::new(Some(async_rx)), + sync_sender: Mutex::new(sender), + } + } +} + +#[async_trait::async_trait] +impl AsyncCallable for GetDisplayEndpoint { + async fn call(&self, params: ApiParameterType) -> ApiParameterType { + log::debug!("API: get_display"); + if let Some(Primitive::F64(index)) = params.get(0) { + let index = *index as usize; + let (respond_to, receiver) = channel(); + log::info!("requesting display for item #{}", index); + let send_result = self.sync_sender.lock().unwrap().send( + QueueItem { + action: QueueAction::SetCallback { + index, + respond_to, + } + } + ); + if let Ok(_) = send_result { + // TODO: don't poll for response + log::info!("waiting for display for item #{}", index); + let sleep_duration = std::time::Duration::from_millis(10); + let receiver = Mutex::new(receiver); + loop { + let received = receiver.lock().unwrap().try_recv(); + match received { + Err(mpsc::TryRecvError::Disconnected) => { + log::info!("Failed to response for get_display for #{}", index); + return vec![Primitive::Empty]; + }, + Err(_) => {}, + Ok(x) => { + log::debug!("got display for item #{}", index); + return vec![x]; + }, + } + tokio::time::sleep(sleep_duration).await; + } + } else { + log::info!("Failed to get_display for #{}", index); + vec![Primitive::Empty] + } + + } else { + vec![Primitive::Empty] + } + } +} diff --git a/backend/src/api/get_item.rs b/backend/src/api/get_item.rs new file mode 100644 index 0000000..b9b8c39 --- /dev/null +++ b/backend/src/api/get_item.rs @@ -0,0 +1,26 @@ +use std::sync::{Mutex, mpsc::{Sender, channel}}; + +use super::ApiParameterType; + +use crate::runtime::{QueueAction, QueueItem}; + +pub fn get_items(sender: Sender) -> impl Fn(ApiParameterType) -> ApiParameterType { + let sender = Mutex::new(sender); + move |_| { + log::debug!("API: get_items"); + let (rx, tx) = channel(); + sender.lock().unwrap().send( + QueueItem { + action: QueueAction::DoReload { + respond_to: rx, + } + } + ).unwrap(); + log::info!("waiting for items"); + vec![ + usdpl_back::core::serdes::Primitive::Json( + serde_json::to_string(&tx.recv().unwrap()).unwrap() + ) + ] + } +} diff --git a/backend/src/api/mod.rs b/backend/src/api/mod.rs new file mode 100644 index 0000000..b2a8844 --- /dev/null +++ b/backend/src/api/mod.rs @@ -0,0 +1,13 @@ +mod about; +mod get_display; +mod get_item; +mod on_update; +mod reload; + +pub use about::get_about; +pub use get_display::GetDisplayEndpoint; +pub use get_item::get_items; +pub use on_update::on_update; +pub use reload::reload; + +pub(super) type ApiParameterType = Vec; diff --git a/backend/src/api/on_update.rs b/backend/src/api/on_update.rs new file mode 100644 index 0000000..d0beb68 --- /dev/null +++ b/backend/src/api/on_update.rs @@ -0,0 +1,34 @@ +use std::sync::{Mutex, mpsc::Sender}; + +use usdpl_back::core::serdes::Primitive; + +use super::ApiParameterType; + +use crate::runtime::{QueueAction, QueueItem}; + +pub fn on_update(sender: Sender) -> impl Fn(ApiParameterType) -> ApiParameterType { + let sender = Mutex::new(sender); + move |mut params: ApiParameterType| { + log::debug!("API: on_update"); + if params.len() == 2 { + if let Primitive::F64(index) = params.remove(0) { + let index = index as usize; + let val = params.remove(0); + sender.lock().unwrap().send( + QueueItem { + action: QueueAction::DoUpdate { + index, + value: val, + } + } + ).unwrap(); + log::info!("Sent update for #{}", index); + vec![true.into()] + } else { + vec![false.into()] + } + } else { + vec![false.into()] + } + } +} diff --git a/backend/src/api/reload.rs b/backend/src/api/reload.rs new file mode 100644 index 0000000..869211e --- /dev/null +++ b/backend/src/api/reload.rs @@ -0,0 +1,26 @@ +use std::sync::{Mutex, mpsc::{Sender, channel}}; + +use super::ApiParameterType; + +use crate::runtime::{QueueAction, QueueItem}; + +pub fn reload(sender: Sender) -> impl Fn(ApiParameterType) -> ApiParameterType { + let sender = Mutex::new(sender); + move |_| { + log::debug!("API: reload"); + let (rx, tx) = channel(); + sender.lock().unwrap().send( + QueueItem { + action: QueueAction::DoReload { + respond_to: rx, + } + } + ).unwrap(); + log::info!("waiting for JSON reload"); + vec![ + usdpl_back::core::serdes::Primitive::Json( + serde_json::to_string(&tx.recv().unwrap()).unwrap() + ) + ] + } +} diff --git a/backend/src/config/about.rs b/backend/src/config/about.rs new file mode 100644 index 0000000..7a90230 --- /dev/null +++ b/backend/src/config/about.rs @@ -0,0 +1,24 @@ +use serde::{Serialize, Deserialize}; + +#[derive(Serialize, Deserialize, Clone)] +pub struct AboutConfig { + pub name: String, + pub version: String, + pub description: String, + pub url: Option, + pub authors: Vec, + pub license: Option, +} + +impl Default for AboutConfig { + fn default() -> Self { + Self { + name: env!("CARGO_PKG_NAME").to_owned(), + version: env!("CARGO_PKG_VERSION").to_owned(), + description: env!("CARGO_PKG_DESCRIPTION").to_owned(), + url: Some(env!("CARGO_PKG_HOMEPAGE").to_owned()), + authors: env!("CARGO_PKG_AUTHORS").split(':').map(|x| x.to_owned()).collect(), + license: Some(env!("CARGO_PKG_LICENSE").to_owned()) + } + } +} diff --git a/server/src/config/action.rs b/backend/src/config/action.rs similarity index 100% rename from server/src/config/action.rs rename to backend/src/config/action.rs diff --git a/backend/src/config/base.rs b/backend/src/config/base.rs new file mode 100644 index 0000000..157df98 --- /dev/null +++ b/backend/src/config/base.rs @@ -0,0 +1,52 @@ +use serde::{Serialize, Deserialize}; + +use super::{ElementConfig, AboutConfig}; + +#[derive(Serialize, Deserialize, Clone)] +#[serde(tag = "api-version")] +pub enum BaseConfig { + #[serde(rename = "v0.0.0")] + V0 { + items: Vec, + about: AboutConfig, + }, +} + +impl BaseConfig { + pub fn load>(path: P) -> Self { + //let path = std::path::Path::new("./").join(path); + let path = path.as_ref(); + match std::fs::File::open(&path) { + Ok(file) => { + let reader = std::io::BufReader::new(file); + match serde_json::from_reader(reader) { + Ok(conf) => return conf, + Err(e) => log::error!("Failed to deserialize {}: {}", path.display(), e), + } + }, + Err(e) => log::error!("Failed to open {}: {}", path.display(), e), + } + panic!("Cannot open {}", path.display()) + } + + #[inline] + pub fn get_about(&self) -> &AboutConfig { + match self { + Self::V0 {about, ..} => about, + } + } + + #[inline] + pub fn get_item(&self, index: usize) -> Option<&ElementConfig> { + match self { + Self::V0 {items, ..} => items.get(index), + } + } + + #[inline] + pub fn items(&self) -> &Vec { + match self { + Self::V0 {items, ..} => items, + } + } +} diff --git a/server/src/config/button.rs b/backend/src/config/button.rs similarity index 100% rename from server/src/config/button.rs rename to backend/src/config/button.rs diff --git a/server/src/config/element.rs b/backend/src/config/element.rs similarity index 73% rename from server/src/config/element.rs rename to backend/src/config/element.rs index 09bb59b..0d10d13 100644 --- a/server/src/config/element.rs +++ b/backend/src/config/element.rs @@ -1,6 +1,6 @@ use serde::{Serialize, Deserialize}; -use super::{ButtonConfig, ToggleConfig, SliderConfig, ReadingConfig}; +use super::{ButtonConfig, ToggleConfig, SliderConfig, ReadingConfig, ResultDisplayConfig}; #[derive(Serialize, Deserialize, Clone)] #[serde(tag = "element")] @@ -12,5 +12,7 @@ pub enum ElementConfig { #[serde(rename = "slider")] Slider(SliderConfig), #[serde(rename = "reading")] - Reading(ReadingConfig), + ReadingDisplay(ReadingConfig), + #[serde(rename = "result-display")] + ResultDisplay(ResultDisplayConfig), } diff --git a/server/src/config/mod.rs b/backend/src/config/mod.rs similarity index 79% rename from server/src/config/mod.rs rename to backend/src/config/mod.rs index 32f9b4f..d922af5 100644 --- a/server/src/config/mod.rs +++ b/backend/src/config/mod.rs @@ -4,6 +4,7 @@ mod base; mod button; mod element; mod reading; +mod result_display; mod slider; mod toggle; @@ -13,6 +14,7 @@ pub use base::BaseConfig; pub use button::ButtonConfig; pub use element::ElementConfig; pub use reading::ReadingConfig; +pub use result_display::ResultDisplayConfig; pub use slider::SliderConfig; pub use toggle::ToggleConfig; @@ -31,8 +33,7 @@ mod test { ElementConfig::Toggle(ToggleConfig { title: "Test Toggle".into(), description: Some("Toggle description".into()), - on_enable: ActionConfig::Command(CommandAction{run: "echo 'hello toggle 1'".into()}), - on_disable: ActionConfig::Command(CommandAction{run: "echo 'hello toggle 0'".into()}), + on_toggle: ActionConfig::Command(CommandAction{run: "echo 'hello toggle $KAYLON_VALUE'".into()}), }), ElementConfig::Slider(SliderConfig { title: "Test Slider".into(), @@ -41,18 +42,22 @@ mod test { notches: None, on_set: ActionConfig::Command(CommandAction{run: "echo 'hello slider'".into()}), }), - ElementConfig::Reading(ReadingConfig { + ElementConfig::ReadingDisplay(ReadingConfig { title: "Test Reading".into(), period_ms: 10000, on_period: ActionConfig::Command(CommandAction{run: "echo 'hello reading'".into()}) }), + ElementConfig::ResultDisplay(ResultDisplayConfig { + title: "Test Reading".into(), + result_of: 1, + }), ], about: AboutConfig { name: "Test name".into(), version: "v0.42.0".into(), description: "Test description".into(), url: Some("https://github.com/NGnius/kaylon".into()), - author: Some("NGnius ".into()), + authors: vec!["NGnius ".into()], license: Some("MIT".into()), }, }; diff --git a/server/src/config/reading.rs b/backend/src/config/reading.rs similarity index 100% rename from server/src/config/reading.rs rename to backend/src/config/reading.rs diff --git a/backend/src/config/result_display.rs b/backend/src/config/result_display.rs new file mode 100644 index 0000000..d2e9146 --- /dev/null +++ b/backend/src/config/result_display.rs @@ -0,0 +1,8 @@ +use serde::{Serialize, Deserialize}; + +#[derive(Serialize, Deserialize, Clone)] +pub struct ResultDisplayConfig { + pub title: String, + /// index of element who's action's result will be used + pub result_of: usize, +} diff --git a/server/src/config/slider.rs b/backend/src/config/slider.rs similarity index 100% rename from server/src/config/slider.rs rename to backend/src/config/slider.rs diff --git a/server/src/config/toggle.rs b/backend/src/config/toggle.rs similarity index 74% rename from server/src/config/toggle.rs rename to backend/src/config/toggle.rs index 871ae13..ffb57e3 100644 --- a/server/src/config/toggle.rs +++ b/backend/src/config/toggle.rs @@ -6,6 +6,5 @@ use super::ActionConfig; pub struct ToggleConfig { pub title: String, pub description: Option, - pub on_enable: ActionConfig, - pub on_disable: ActionConfig, + pub on_toggle: ActionConfig, } diff --git a/backend/src/consts.rs b/backend/src/consts.rs new file mode 100644 index 0000000..66a88b6 --- /dev/null +++ b/backend/src/consts.rs @@ -0,0 +1,6 @@ +pub const PORT: u16 = 25717; + +pub const PACKAGE_NAME: &'static str = env!("CARGO_PKG_NAME"); +pub const PACKAGE_VERSION: &'static str = env!("CARGO_PKG_VERSION"); + +pub const FILEPATH: &'static str = "./bin/kaylon.json"; diff --git a/backend/src/main.rs b/backend/src/main.rs new file mode 100644 index 0000000..aaf4245 --- /dev/null +++ b/backend/src/main.rs @@ -0,0 +1,34 @@ +mod api; +mod config; +mod consts; +mod runtime; + +use simplelog::{WriteLogger, LevelFilter}; + +use usdpl_back::Instance; +use usdpl_back::core::serdes::Primitive; + +fn main() -> Result<(), ()> { + let log_filepath = format!("/tmp/{}.log", consts::PACKAGE_NAME); + WriteLogger::init( + #[cfg(debug_assertions)]{LevelFilter::Debug}, + #[cfg(not(debug_assertions))]{LevelFilter::Info}, + Default::default(), + std::fs::File::create(&log_filepath).unwrap() + ).unwrap(); + + let kaylon_conf = config::BaseConfig::load(consts::FILEPATH); + let (executor, sender) = runtime::RuntimeExecutor::new(kaylon_conf); + + log::info!("Starting back-end ({} v{})", consts::PACKAGE_NAME, consts::PACKAGE_VERSION); + println!("Starting back-end ({} v{})", consts::PACKAGE_NAME, consts::PACKAGE_VERSION); + let instance = Instance::new(consts::PORT) + .register("hello", |_: Vec| vec![format!("Hello {}", consts::PACKAGE_NAME).into()]) + .register_blocking("get_about", api::get_about(sender.clone())) + .register_async("get_display", api::GetDisplayEndpoint::new(sender.clone())) + .register_blocking("get_items", api::get_items(sender.clone())) + .register("on_update", api::on_update(sender.clone())) + .register_blocking("reload", api::reload(sender.clone())); + let _exec_handle = executor.spawn(); + instance.run_blocking() +} diff --git a/backend/src/runtime/actor.rs b/backend/src/runtime/actor.rs new file mode 100644 index 0000000..52695d8 --- /dev/null +++ b/backend/src/runtime/actor.rs @@ -0,0 +1,68 @@ +use usdpl_back::core::serdes::Primitive; + +use crate::config::{ElementConfig, ActionConfig}; + +pub type ActError = String; + +pub trait Act: Sized { + type Param; + type Config: ?Sized; + type Return; + fn build(config: &Self::Config, parameter: Self::Param) -> Result; + fn run(self) -> Self::Return; +} + +pub struct Actor { + actor_type: ActorType, + index: usize, +} + +impl Act for Actor { + type Param = (usize, Primitive); + type Config = ElementConfig; + type Return = Primitive; + + fn build(config: &ElementConfig, parameter: Self::Param) -> Result { + let a_type = match config { + ElementConfig::Button(b) => ActorType::build(&b.on_click, parameter.1), + ElementConfig::Toggle(t) => ActorType::build(&t.on_toggle, parameter.1), + ElementConfig::Slider(s) => ActorType::build(&s.on_set, parameter.1), + ElementConfig::ReadingDisplay(r) => ActorType::build(&r.on_period, parameter.1), + ElementConfig::ResultDisplay(_) => Err(format!("Item #{} is a ResultDisplay, which can't act", parameter.0)), + }?; + Ok(Self { + actor_type: a_type, + index: parameter.0, + }) + } + + fn run(self) -> Self::Return { + log::info!("Running act for item {}", self.index); + let result = self.actor_type.run(); + log::info!("Completed act for item {}", self.index); + result + } +} + +pub enum ActorType { + Command(super::CommandActor), +} + +impl Act for ActorType { + type Param = Primitive; + type Config = ActionConfig; + type Return = Primitive; + + fn build(config: &Self::Config, parameter: Self::Param) -> Result { + Ok(match config { + ActionConfig::Command(c) => + Self::Command(super::CommandActor::build(c, parameter)?), + }) + } + + fn run(self) -> Self::Return { + match self { + Self::Command(c) => c.run().into(), + } + } +} diff --git a/backend/src/runtime/command_actor.rs b/backend/src/runtime/command_actor.rs new file mode 100644 index 0000000..a4ec49c --- /dev/null +++ b/backend/src/runtime/command_actor.rs @@ -0,0 +1,61 @@ +use std::process::Command; + +use usdpl_back::core::serdes::Primitive; + +use crate::config::CommandAction; +use super::{Act, ActError}; + +const VALUE_ENV_VAR: &str = "KAYLON_VALUE"; + +pub struct CommandActor { + shell: String, + run: String, + variable: String, +} + +impl CommandActor { + fn primitive_to_string(obj: Primitive) -> String { + match obj { + Primitive::Empty => String::new(), + Primitive::String(s) => s, + Primitive::F32(f) => f.to_string(), + Primitive::F64(f) => f.to_string(), + Primitive::I32(i) => i.to_string(), + Primitive::I64(i) => i.to_string(), + Primitive::U32(u) => u.to_string(), + Primitive::U64(u) => u.to_string(), + Primitive::Bool(b) => b.to_string().to_uppercase(), + Primitive::Json(j) => j, + } + } +} + +impl Act for CommandActor { + type Param = Primitive; + type Config = CommandAction; + type Return = String; + + fn build(config: &CommandAction, parameter: Primitive) -> Result { + Ok( + Self { + shell: "bash".to_owned(), + run: config.run.clone(), + variable: Self::primitive_to_string(parameter), + } + ) + } + + fn run(self) -> Self::Return { + let output = Command::new(&self.shell) + .args(["-c", &self.run]) + .env(VALUE_ENV_VAR, &self.variable) + .output() + .expect(&format!("Cannot run `{}`", &self.run)); + if !output.stderr.is_empty() { + log::error!("Error running `{}`: {}", &self.run, String::from_utf8(output.stderr).unwrap_or_else(|_| "".to_owned())) + } + let result = String::from_utf8(output.stdout).expect(&format!("Cannot parse stdout from `{}` as UTF-8", self.run)); + log::debug!("CommandActor ran `{}` (${}=\"{}\") -> `{}`", &self.run, VALUE_ENV_VAR, &self.variable, &result); + result + } +} diff --git a/backend/src/runtime/communication.rs b/backend/src/runtime/communication.rs new file mode 100644 index 0000000..5eff8fe --- /dev/null +++ b/backend/src/runtime/communication.rs @@ -0,0 +1,26 @@ +use std::sync::mpsc::Sender; + +use usdpl_back::core::serdes::Primitive; + +use crate::config::{AboutConfig, ElementConfig}; + +pub enum QueueAction { + GetAbout { + respond_to: Sender, + }, + DoUpdate { + index: usize, + value: Primitive, + }, + DoReload { + respond_to: Sender> + }, + SetCallback { + index: usize, + respond_to: Sender, + } +} + +pub struct QueueItem { + pub action: QueueAction, +} diff --git a/backend/src/runtime/executor.rs b/backend/src/runtime/executor.rs new file mode 100644 index 0000000..33a576f --- /dev/null +++ b/backend/src/runtime/executor.rs @@ -0,0 +1,121 @@ +use std::thread; +use std::sync::mpsc::{self, Receiver, Sender}; + +use crate::config::{BaseConfig, ElementConfig}; +use super::{QueueItem, QueueAction, Act}; +use super::{ResultRouter, RouterCommand}; + +pub struct RuntimeExecutor { + config_data: BaseConfig, + tasks_receiver: Receiver +} + +impl RuntimeExecutor { + pub fn new(conf: BaseConfig) -> (Self, Sender) { + let (tx, rx) = mpsc::channel(); + (Self { + config_data: conf, + tasks_receiver: rx, + }, tx) + } + + pub fn spawn(self) -> thread::JoinHandle<()> { + thread::spawn(move || self.run_loop()) + } + + fn run_loop(self) { + let (mut state, tasks_receiver) = self.split(); + state.populate_router(); + for item in tasks_receiver.iter() { + state.handle_item(item); + } + } + + fn split(self) -> (ExecutorState, Receiver) { + ( + ExecutorState { + result_handler: ExecutorState::build_router(self.config_data.items().len()), + config_data: self.config_data, + }, + self.tasks_receiver + ) + } +} + +struct ExecutorState { + config_data: BaseConfig, + result_handler: Sender, +} + +impl ExecutorState { + fn handle_item(&mut self, item: QueueItem) { + match item.action { + QueueAction::GetAbout { respond_to } => { + respond_to.send(self.config_data.get_about().clone()).unwrap_or(()); + }, + QueueAction::DoUpdate { index, value } => { + if let Some(item) = self.config_data.get_item(index) { + match super::Actor::build(item, (index, value)) { + Ok(act) => { + let respond_to = self.result_handler.clone(); + thread::spawn(move || { + let result = act.run(); + match respond_to.send(RouterCommand::HandleResult{index, result}) { + Ok(_) => {}, + Err(_) => log::warn!("Failed to send DoUpdate response for item #{}", index), + } + }); + }, + Err(e) => log::error!("Failed to build DoUpdate actor for item #{}: {}", index, e) + } + } else { + log::warn!("Received DoUpdate on non-existent item #{} with value `{}`", index, super::primitive_utils::debug(&value)) + } + }, + QueueAction::DoReload { respond_to } => { + self.config_data = BaseConfig::load(crate::consts::FILEPATH); + self.populate_router(); + respond_to.send(self.config_data.items().clone()).unwrap_or(()); + }, + QueueAction::SetCallback { index, respond_to } => { + if let Some(elem) = self.config_data.get_item(index) { + let display_of = match elem { + ElementConfig::ResultDisplay(c) => c.result_of, + _ => index, + }; + if let Err(_) = self.result_handler.send( + RouterCommand::AddSender { + index: display_of, + sender: respond_to, + }) { + log::warn!("Failed to send to ResultRouter, rebuilding router"); + self.result_handler = ExecutorState::build_router(self.config_data.items().len()); + } + } + } + } + } + + fn build_router(items_len: usize) -> Sender { + let router = ResultRouter::build(&(), items_len).unwrap(); + let result = router.run(); + result + } + + fn populate_router(&mut self) { + if let Err(_) = self.result_handler.send(RouterCommand::Clear{}) { + return; + } + // start reading displays with periodic actions + for (index, item) in self.config_data.items().iter().enumerate() { + match item { + ElementConfig::ReadingDisplay(r) => { + if let Ok(actor) = super::PeriodicActor::build(r, (index, self.result_handler.clone())) { + actor.run(); + } + }, + _ => {} + } + } + } +} diff --git a/backend/src/runtime/mod.rs b/backend/src/runtime/mod.rs new file mode 100644 index 0000000..53e89cb --- /dev/null +++ b/backend/src/runtime/mod.rs @@ -0,0 +1,14 @@ +mod actor; +mod command_actor; +mod communication; +mod executor; +mod periodic_actor; +mod primitive_utils; +mod result_router; + +pub use actor::{Actor, Act, ActError, ActorType}; +pub use command_actor::CommandActor; +pub use communication::{QueueItem, QueueAction}; +pub use executor::RuntimeExecutor; +pub use periodic_actor::PeriodicActor; +pub use result_router::{ResultRouter, RouterCommand}; diff --git a/backend/src/runtime/periodic_actor.rs b/backend/src/runtime/periodic_actor.rs new file mode 100644 index 0000000..3109519 --- /dev/null +++ b/backend/src/runtime/periodic_actor.rs @@ -0,0 +1,57 @@ +use std::sync::mpsc::Sender; +use std::time::Duration; + +use usdpl_back::core::serdes::Primitive; + +use crate::config::ReadingConfig; +use super::{Act, ActError, ActorType, RouterCommand}; + +pub struct PeriodicActor { + config: ReadingConfig, + result_handler: Sender, + index: usize, +} + +impl Act for PeriodicActor { + type Param = (usize, Sender); + type Config = ReadingConfig; + type Return = (); + + fn build(config: &Self::Config, parameter: Self::Param) -> Result { + ActorType::build(&config.on_period, Primitive::Empty)?; + Ok( + Self { + config: config.clone(), + result_handler: parameter.1, + index: parameter.0, + } + ) + } + + fn run(self) -> Self::Return { + std::thread::spawn(move || { + let sleep_duration = Duration::from_millis(self.config.period_ms); + loop { + let actor = match ActorType::build(&self.config.on_period, Primitive::Empty) { + Ok(x) => x, + Err(e) => { + log::error!("PeriodicActor failed to build for item #{}: {}", self.index, e); + break; + } + }; + let result = actor.run(); + match self.result_handler.send(RouterCommand::HandleResult { + index: self.index, result + }) { + Ok(_) => {}, + Err(_e) => { + log::warn!("PeriodicActor failed to handle result for item #{}", self.index); + break; + } + } + std::thread::sleep(sleep_duration); + } + log::info!("PeriodicActor completed for #{}", self.index); + }); + } +} diff --git a/backend/src/runtime/primitive_utils.rs b/backend/src/runtime/primitive_utils.rs new file mode 100644 index 0000000..715d2a5 --- /dev/null +++ b/backend/src/runtime/primitive_utils.rs @@ -0,0 +1,84 @@ +use usdpl_back::core::serdes::Primitive; + +//use super::ActError; + +/*macro_rules! map_primitive_number_impl { + ($type:ty, $type_name:literal, $fn_name:ident) => { + pub fn $fn_name (param: Primitive) -> Result<$type, ActError> { + match param { + Primitive::I64(a) => Ok(a as $type), + Primitive::I32(a) => Ok(a as $type), + Primitive::U64(a) => Ok(a as $type), + Primitive::U32(a) => Ok(a as $type), + Primitive::F64(a) => Ok(a as $type), + Primitive::F32(a) => Ok(a as $type), + _ => Err(format!("Parameter must be {} type", $type_name)) + } + } + } +}*/ + +/*macro_rules! map_primitive_impl { + ($type:ty, $primitive:ident, $type_name:literal, $fn_name:ident) => { + pub fn $fn_name (param: Primitive) -> Result<$type, ActError> { + match param { + Primitive::$primitive(a) => Ok(a), + _ => Err(format!("Parameter must be {} type", $type_name)) + } + } + } +}*/ + +//map_primitive_impl!{bool, Bool, "boolean", try_primitive_bool} + +//map_primitive_impl!{String, String, "string", try_primitive_string} + +//map_primitive_number_impl!{usize, "uinteger", try_primitive_usize} + +#[inline] +pub fn debug(primitive: &Primitive) -> String { + match primitive { + Primitive::Empty => "Primitive::Empty".to_owned(), + Primitive::String(x) => format!("Primitive::String(`{}`)", x), + Primitive::F32(x) => format!("Primitive::F32(`{}`)", x), + Primitive::F64(x) => format!("Primitive::F64(`{}`)", x), + Primitive::U32(x) => format!("Primitive::U32(`{}`)", x), + Primitive::U64(x) => format!("Primitive::U64(`{}`)", x), + Primitive::I32(x) => format!("Primitive::I32(`{}`)", x), + Primitive::I64(x) => format!("Primitive::I64(`{}`)", x), + Primitive::Bool(x) => format!("Primitive::Bool(`{}`)", x), + Primitive::Json(x) => format!("Primitive::Json(`{}`)", x), + } +} + +/*#[inline] +pub fn display(primitive: Primitive) -> String { + match primitive { + Primitive::Empty => "".to_owned(), + Primitive::String(x) => x, + Primitive::F32(x) => x.to_string(), + Primitive::F64(x) => x.to_string(), + Primitive::U32(x) => x.to_string(), + Primitive::U64(x) => x.to_string(), + Primitive::I32(x) => x.to_string(), + Primitive::I64(x) => x.to_string(), + Primitive::Bool(x) => x.to_string(), + Primitive::Json(x) => x, + } +}*/ + +#[inline] +pub fn clone(primitive: &Primitive) -> Primitive { + match primitive { + Primitive::Empty => Primitive::Empty, + Primitive::String(x) => Primitive::String(x.clone()), + Primitive::F32(x) => Primitive::F32(*x), + Primitive::F64(x) => Primitive::F64(*x), + Primitive::U32(x) => Primitive::U32(*x), + Primitive::U64(x) => Primitive::U64(*x), + Primitive::I32(x) => Primitive::I32(*x), + Primitive::I64(x) => Primitive::I64(*x), + Primitive::Bool(x) => Primitive::Bool(*x), + Primitive::Json(x) => Primitive::Json(x.clone()), + } +} diff --git a/backend/src/runtime/result_router.rs b/backend/src/runtime/result_router.rs new file mode 100644 index 0000000..8f0ad4f --- /dev/null +++ b/backend/src/runtime/result_router.rs @@ -0,0 +1,133 @@ +use std::sync::mpsc::{self, Receiver, Sender}; + +use usdpl_back::core::serdes::Primitive; + +//use crate::config::ElementConfig; +use super::{Act, ActError}; + +const MAX_HANDLERS_PER_ITEM: usize = 8; + +pub enum RouterCommand { + AddSender { + index: usize, + sender: Sender, + }, + HandleResult { + index: usize, + result: Primitive, + }, + Clear{} +} + +pub struct ResultRouter { + comm: Receiver, + senders: Vec<[Option>; MAX_HANDLERS_PER_ITEM]>, + comm_tx: Option>, + cache: Vec>, +} + +impl ResultRouter { + fn all_senders_none(senders: &[Option>]) -> bool { + let mut all_none = true; + for s in senders.iter() { + all_none &= s.is_none(); + } + all_none + } +} + +impl Act for ResultRouter { + type Param = usize; + type Config = (); + type Return = Sender; + + fn build(_config: &Self::Config, parameter: Self::Param) -> Result { + let (tx, rx) = mpsc::channel(); + let mut cache_vec = Vec::with_capacity(parameter); + for _ in 0..parameter { + cache_vec.push(None); + } + Ok(Self { + comm: rx, + senders: vec![[(); MAX_HANDLERS_PER_ITEM].map(|_| None); parameter], + comm_tx: Some(tx), + cache: cache_vec, + }) + } + + fn run(mut self) -> Self::Return { + let result = self.comm_tx.take().unwrap(); + std::thread::spawn(move || { + log::debug!("ResultRouter starting"); + for command in self.comm.iter() { + match command { + RouterCommand::AddSender { index, sender } => { + log::debug!("Handling AddSender for item #{}", index); + if let Some(senders) = self.senders.get_mut(index) { + // send cached value, if available + if self.cache[index].is_some() { + log::debug!("Routing cached result for item #{}", index); + let result = self.cache[index].take().unwrap(); + match sender.send(result) { + Ok(_) => {}, + Err(e) => { + self.cache[index] = Some(e.0); + log::debug!("ResultRouter ignoring AddSender since sending cached value failed"); + continue; + }, + } + } + // save sender for future results + let mut was_set = false; + 'inner_loop: for sender_opt in senders { + if sender_opt.is_none() { + *sender_opt = Some(sender); + was_set = true; + break 'inner_loop; + } + } + if !was_set { + log::warn!("ResultRouter could not add another sender for index {}", index); + } + } else { + log::warn!("ResultRouter got AddSender command for invalid index {} (max: {})", index, self.senders.len()); + } + } + RouterCommand::HandleResult {index, result} => { + log::debug!("Handling HandleResult for item #{}", index); + if let Some(senders) = self.senders.get_mut(index) { + if Self::all_senders_none(senders) { + self.cache[index] = Some(result); + log::debug!("Cached result for item #{}", index); + } else { + for (i, sender_opt) in senders.iter_mut().enumerate() { + if let Some(sender) = sender_opt { + match sender.send(super::primitive_utils::clone(&result)) { + Ok(_) => {}, + Err(_) => { + log::debug!("Removing sender {} because it seems closed", i); + *sender_opt = None; + } + } + } + } + log::debug!("Routed result for item #{}", index); + } + } else { + log::warn!("ResultRouter got AddSender command for invalid index {} (max: {})", index, self.senders.len()); + } + }, + RouterCommand::Clear {} => { + log::debug!("Handling Clear"); + for i in 0..self.senders.len() { + self.senders[i] = [(); MAX_HANDLERS_PER_ITEM].map(|_| None); + self.cache[i] = None; + } + } + } + } + log::warn!("ResultRouter completed"); + }); + result + } +} diff --git a/kaylon.json b/kaylon.json new file mode 100644 index 0000000..42a0d6f --- /dev/null +++ b/kaylon.json @@ -0,0 +1,57 @@ +{ + "api-version": "v0.0.0", + "items": [ + { + "element": "button", + "title": "Test Button", + "on_click": { + "action": "command", + "run": "echo 'hello button'" + } + }, + { + "element": "toggle", + "title": "Test Toggle", + "description": "Toggle description", + "on_toggle": { + "action": "command", + "run": "echo 'hello toggle ${KAYLON_VALUE}'" + } + }, + { + "element": "slider", + "title": "Test Slider", + "min": 0, + "max": 3, + "notches": null, + "on_set": { + "action": "command", + "run": "echo 'hello slider'" + } + }, + { + "element": "reading", + "title": "Test Reading", + "period_ms": 10000, + "on_period": { + "action": "command", + "run": "echo 'hello reading'" + } + }, + { + "element": "result-display", + "title": "Test Result", + "result_of": 1 + } + ], + "about": { + "name": "Test name", + "version": "v0.42.0", + "description": "Test description", + "url": "https://github.com/NGnius/kaylon", + "authors": [ + "NGnius " + ], + "license": "MIT" + } +} diff --git a/main.py b/main.py index e7435f5..6c1ab39 100644 --- a/main.py +++ b/main.py @@ -11,6 +11,6 @@ class Plugin: # Asyncio-compatible long-running code, executed in a task when the plugin is loaded async def _main(self): # startup - self.backend_proc = subprocess.Popen([PARENT_DIR + "/bin/backend"]) + #self.backend_proc = subprocess.Popen([PARENT_DIR + "/bin/backend"]) while True: - asyncio.sleep(1) + await asyncio.sleep(1) diff --git a/package.json b/package.json index 83cb20c..730b5b1 100644 --- a/package.json +++ b/package.json @@ -38,7 +38,7 @@ "typescript": "^4.6.4" }, "dependencies": { - "decky-frontend-lib": "^1.0.1", + "decky-frontend-lib": "*", "react-icons": "^4.3.1", "usdpl-front": "file:./src/usdpl_front" }, diff --git a/server/build.sh b/server/build.sh deleted file mode 100755 index d9b898f..0000000 --- a/server/build.sh +++ /dev/null @@ -1,6 +0,0 @@ -#!/bin/bash - -cargo build --release -mkdir ../bin -# TODO replace "backend" \/ with binary name -cp ./target/release/backend ../bin/backend diff --git a/server/src/config/about.rs b/server/src/config/about.rs deleted file mode 100644 index 0144937..0000000 --- a/server/src/config/about.rs +++ /dev/null @@ -1,11 +0,0 @@ -use serde::{Serialize, Deserialize}; - -#[derive(Serialize, Deserialize, Clone)] -pub struct AboutConfig { - pub name: String, - pub version: String, - pub description: String, - pub url: Option, - pub author: Option, - pub license: Option, -} diff --git a/server/src/config/base.rs b/server/src/config/base.rs deleted file mode 100644 index f2665d1..0000000 --- a/server/src/config/base.rs +++ /dev/null @@ -1,13 +0,0 @@ -use serde::{Serialize, Deserialize}; - -use super::{ElementConfig, AboutConfig}; - -#[derive(Serialize, Deserialize, Clone)] -#[serde(tag = "api-version")] -pub enum BaseConfig { - #[serde(rename = "v0.0.0")] - V0 { - items: Vec, - about: AboutConfig, - }, -} diff --git a/server/src/main.rs b/server/src/main.rs deleted file mode 100644 index 747e6f5..0000000 --- a/server/src/main.rs +++ /dev/null @@ -1,27 +0,0 @@ -mod config; - -use simplelog::{WriteLogger, LevelFilter}; - -use usdpl_back::Instance; -use usdpl_back::core::serdes::Primitive; - -const PORT: u16 = 54321; // TODO replace with something unique - -const PACKAGE_NAME: &'static str = env!("CARGO_PKG_NAME"); -const PACKAGE_VERSION: &'static str = env!("CARGO_PKG_VERSION"); - -fn main() -> Result<(), ()> { - let log_filepath = format!("/tmp/{}.log", PACKAGE_NAME); - WriteLogger::init( - #[cfg(debug_assertions)]{LevelFilter::Debug}, - #[cfg(not(debug_assertions))]{LevelFilter::Info}, - Default::default(), - std::fs::File::create(&log_filepath).unwrap() - ).unwrap(); - - log::info!("Starting back-end ({} v{})", PACKAGE_NAME, PACKAGE_VERSION); - println!("Starting back-end ({} v{})", PACKAGE_NAME, PACKAGE_VERSION); - Instance::new(PORT) - .register("hello", |_: Vec| vec![format!("Hello {}", PACKAGE_NAME).into()]) - .run_blocking() -} diff --git a/src/backend.ts b/src/backend.ts index c27ec8b..7012d34 100644 --- a/src/backend.ts +++ b/src/backend.ts @@ -1,4 +1,4 @@ -import {init_usdpl, target, init_embedded, call_backend} from "usdpl-front"; +import {init_usdpl, target_usdpl, init_embedded, call_backend} from "usdpl-front"; const USDPL_PORT: number = 25717; @@ -20,7 +20,7 @@ export async function initBackend() { // init usdpl await init_embedded(); init_usdpl(USDPL_PORT); - console.log("USDPL started for framework: " + target()); + console.log("USDPL started for framework: " + target_usdpl()); //setReady(true); } @@ -29,7 +29,7 @@ export type CAbout = { version: string; description: string; url: string | null; - author: string | null; + authors: string[]; license: string | null; } @@ -58,18 +58,24 @@ export type CReading = { period_ms: number; } -export type CElement = CButton | CToggle | CSlider | CReading; +export type CResultDisplay = { + element: string; // "result-display" + title: string; + result_of: number; +} + +export type CElement = CButton | CToggle | CSlider | CReading | CResultDisplay; export async function getElements(): Promise { - return await call_backend("get_items", []); + return (await call_backend("get_items", []))[0]; } export async function onUpdate(index: number, value: any): Promise { return (await call_backend("on_update", [index, value]))[0]; } -export async function getReading(index: number): Promise { - return (await call_backend("get_reading", [index]))[0]; +export async function getDisplay(index: number): Promise { + return (await call_backend("get_display", [index]))[0]; } export async function getAbout(): Promise { @@ -77,5 +83,5 @@ export async function getAbout(): Promise { } export async function reload(): Promise { - return await call_backend("reload", []); + return (await call_backend("reload", []))[0]; } diff --git a/src/index.tsx b/src/index.tsx index f3a910a..42f3347 100755 --- a/src/index.tsx +++ b/src/index.tsx @@ -1,7 +1,7 @@ import { ButtonItem, definePlugin, - DialogButton, + //DialogButton, //Menu, //MenuItem, PanelSection, @@ -19,72 +19,93 @@ import { import { VFC, useState } from "react"; import { GiWashingMachine } from "react-icons/gi"; -import { call_backend } from "usdpl-front"; +import { get_value, set_value } from "usdpl-front"; import * as backend from "./backend"; -// interface AddMethodArgs { -// left: number; -// right: number; -// } - const FieldWithSeparator = joinClassNames(gamepadDialogClasses.Field, gamepadDialogClasses.WithBottomSeparatorStandard); +const DISPLAY_KEY = "display"; +const VALUE_KEY = "value"; + let items: backend.CElement[] = []; +let about: backend.CAbout | null = null; + +let update = () => {}; + +function displayCallback(index: number) { + return (newVal: any) => { + set_value(DISPLAY_KEY + index.toString(), newVal); + backend.resolve(backend.getDisplay(index), displayCallback(index)); + console.log("Got display for " + index.toString(), newVal); + update(); + } +} + +// init USDPL WASM frontend +// this is required to interface with the backend +(async () => { + await backend.initBackend(); + let about_promise = backend.getAbout(); + let elements_promise = backend.getElements(); + about = await about_promise; + console.log("KAYLON: got about", about); + let result = await elements_promise; + console.log("KAYLON: got elements", result); + if (result != null) { + items = await backend.getElements(); + for (let i = 0; i < items.length; i++) { + console.log("KAYLON: req display for item #" + i.toString()); + backend.resolve(backend.getDisplay(i), displayCallback(i)); + } + } else { + console.warn("KAYLON: backend connection failed"); + } +})(); const Content: VFC<{ serverAPI: ServerAPI }> = ({}) => { - // const [result, setResult] = useState(); - - // const onClick = async () => { - // const result = await serverAPI.callPluginMethod( - // "add", - // { - // left: 2, - // right: 2, - // } - // ); - // if (result.success) { - // setResult(result.result); - // } - // }; const [triggerInternal, updateInternal] = useState(false); - function update() { + update = () => { updateInternal(!triggerInternal); } function updateIdc(_: any) { update(); } - - // call hello callback on backend - (async () => { - let response = await call_backend("hello", []); - console.log("Backend says:", response); - })(); return ( - + {items.map( (elem, i) => { return {buildHtmlElement(elem, i, updateIdc)} }) } + { about != null && buildAbout() } + + { + backend.resolve(backend.reload(), + (reload_items: backend.CElement[]) => { + items = reload_items; + console.log("KAYLON: got elements", reload_items); + update(); + }); + backend.resolve(backend.getAbout(), + (new_about: backend.CAbout) => { + about = new_about; + console.log("KAYLON: got about", about); + update(); + }); + }}> + Reload + + ); }; -const DeckyPluginRouterTest: VFC = () => { - return ( -
- Hello World! - {}}> - Go to Store - -
- ); -}; - function buildHtmlElement(element: backend.CElement, index: number, updateIdc: any) { switch (element.element) { case "button": @@ -95,8 +116,11 @@ function buildHtmlElement(element: backend.CElement, index: number, updateIdc: a return buildToggle(element as backend.CToggle, index, updateIdc); case "reading": return buildReading(element as backend.CReading, index, updateIdc); + case "result-display": + return buildResultDisplay(element as backend.CResultDisplay, index, updateIdc); } - return "Unsupported"; + console.error("KAYLON: Unsupported element", element); + return
Unsupported
; } function buildButton(element: backend.CButton, index: number, updateIdc: any) { @@ -110,62 +134,175 @@ function buildButton(element: backend.CButton, index: number, updateIdc: any) { } function buildSlider(element: backend.CSlider, index: number, updateIdc: any) { + const KEY = VALUE_KEY + index.toString(); + if (get_value(KEY) == null) { + set_value(KEY, element.min); + } return ( { - backend.resolve(backend.onUpdate(index, value), updateIdc) + backend.resolve(backend.onUpdate(index, value), updateIdc); + set_value(KEY, value); }} /> ); } function buildToggle(element: backend.CToggle, index: number, updateIdc: any) { + const KEY = VALUE_KEY + index.toString(); + if (get_value(KEY) == null) { + set_value(KEY, false); + } return ( { - backend.resolve(backend.onUpdate(index, value), updateIdc) + backend.resolve(backend.onUpdate(index, value), updateIdc); + set_value(KEY, value); }} /> ); } -function buildReading(element: backend.CReading, _index: number, _updateIdc: any) { +function buildReading(element: backend.CReading, index: number, _updateIdc: any) { return (
{element.title}
-
{"idk"}
+
{get_value(DISPLAY_KEY + index.toString())}
); } -export default definePlugin((serverApi: ServerAPI) => { - serverApi.routerHook.addRoute("/decky-plugin-test", DeckyPluginRouterTest, { - exact: true, - }); - - // init USDPL WASM frontend - // this is required to interface with the backend - (async () => { - await backend.initBackend(); - items = await backend.getElements(); - })(); +function buildResultDisplay(element: backend.CResultDisplay, index: number, _updateIdc: any) { + return ( +
+
+
{element.title}
+
{get_value(DISPLAY_KEY + index.toString())}
+
+
+ ); +} +function buildAbout() { + if (about == null) { + return []; + } else { + let elements = [ +
+ About +
, + +
+
+
Name
+
{about.name}
+
+
+ , + +
+
+
Version
+
{about.version}
+
+
+ , + +
+
+
Description
+
{about.description}
+
+
+ + ]; + if (about.url != null) { + elements.push( + +
+
+
URL
+
{about.url}
+
+
+ + ); + } + if (about.authors.length > 1) { + let authors = about.authors.map((elem, i) => { + if (i == about!.authors.length - 1) { + return

{elem}

; + } else { + return {elem}; + } + }); + elements.push( + +
+
+
Authors
+
{authors}
+
+
+ + ); + } else if (about.authors.length == 1) { + elements.push( + +
+
+
Author
+
{about.authors[0]}
+
+
+ + ); + } else { + elements.push( + +
+
+
Author
+
NGnius
+
+
+ + ); + } + + if (about.license != null) { + elements.push( + +
+
+
License
+
{about.license}
+
+
+ + ); + } + return elements; + } +} + +export default definePlugin((serverApi: ServerAPI) => { return { - title:
Example Plugin
, + title:
{about == null? "Kaylon": about.name}
, content: , icon: , onDismount() { - serverApi.routerHook.removeRoute("/decky-plugin-test"); + //serverApi.routerHook.removeRoute("/decky-plugin-test"); }, }; }); diff --git a/src/usdpl_front/README.md b/src/usdpl_front/README.md new file mode 100644 index 0000000..fd771f8 --- /dev/null +++ b/src/usdpl_front/README.md @@ -0,0 +1,9 @@ +[![Crates.io](https://img.shields.io/crates/v/usdpl-front?style=flat-square)](https://crates.io/crates/usdpl-front) + +# usdpl-front-front + +Front-end library to be called from Javascript. +Targets WASM. + +In true Javascript tradition, this part of the library does not support error handling. + diff --git a/src/usdpl_front/package.json b/src/usdpl_front/package.json index bd572fc..fd8c535 100644 --- a/src/usdpl_front/package.json +++ b/src/usdpl_front/package.json @@ -4,7 +4,7 @@ "NGnius (Graham) " ], "description": "Universal Steam Deck Plugin Library front-end designed for WASM", - "version": "0.6.0", + "version": "0.6.2", "license": "GPL-3.0-only", "repository": { "type": "git", diff --git a/src/usdpl_front/usdpl_front.d.ts b/src/usdpl_front/usdpl_front.d.ts index 5ca612b..b986bed 100644 --- a/src/usdpl_front/usdpl_front.d.ts +++ b/src/usdpl_front/usdpl_front.d.ts @@ -9,7 +9,25 @@ export function init_usdpl(port: number): void; * Get the targeted plugin framework, or "any" if unknown * @returns {string} */ -export function target(): string; +export function target_usdpl(): string; +/** +* Get the UDSPL front-end version +* @returns {string} +*/ +export function version_usdpl(): string; +/** +* Get the targeted plugin framework, or "any" if unknown +* @param {string} key +* @param {any} value +* @returns {any} +*/ +export function set_value(key: string, value: any): any; +/** +* Get the targeted plugin framework, or "any" if unknown +* @param {string} key +* @returns {any} +*/ +export function get_value(key: string): any; /** * Call a function on the back-end. * Returns null (None) if this fails for any reason. @@ -24,7 +42,10 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl export interface InitOutput { readonly memory: WebAssembly.Memory; readonly init_usdpl: (a: number) => void; - readonly target: (a: number) => void; + readonly target_usdpl: (a: number) => void; + readonly version_usdpl: (a: number) => void; + readonly set_value: (a: number, b: number, c: number) => number; + readonly get_value: (a: number, b: number) => number; readonly call_backend: (a: number, b: number, c: number, d: number) => number; readonly __wbindgen_export_0: (a: number) => number; readonly __wbindgen_export_1: (a: number, b: number, c: number) => number; diff --git a/src/usdpl_front/usdpl_front.js b/src/usdpl_front/usdpl_front.js index 0610e88..3cd2e54 100644 --- a/src/usdpl_front/usdpl_front.js +++ b/src/usdpl_front/usdpl_front.js @@ -21,6 +21,15 @@ function takeObject(idx) { return ret; } +function addHeapObject(obj) { + if (heap_next === heap.length) heap.push(heap.length + 1); + const idx = heap_next; + heap_next = heap[idx]; + + heap[idx] = obj; + return idx; +} + let WASM_VECTOR_LEN = 0; let cachedUint8Memory0; @@ -104,15 +113,6 @@ function getStringFromWasm0(ptr, len) { return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len)); } -function addHeapObject(obj) { - if (heap_next === heap.length) heap.push(heap.length + 1); - const idx = heap_next; - heap_next = heap[idx]; - - heap[idx] = obj; - return idx; -} - let cachedFloat64Memory0; function getFloat64Memory0() { if (cachedFloat64Memory0.byteLength === 0) { @@ -121,6 +121,71 @@ function getFloat64Memory0() { return cachedFloat64Memory0; } +function debugString(val) { + // primitive types + const type = typeof val; + if (type == 'number' || type == 'boolean' || val == null) { + return `${val}`; + } + if (type == 'string') { + return `"${val}"`; + } + if (type == 'symbol') { + const description = val.description; + if (description == null) { + return 'Symbol'; + } else { + return `Symbol(${description})`; + } + } + if (type == 'function') { + const name = val.name; + if (typeof name == 'string' && name.length > 0) { + return `Function(${name})`; + } else { + return 'Function'; + } + } + // objects + if (Array.isArray(val)) { + const length = val.length; + let debug = '['; + if (length > 0) { + debug += debugString(val[0]); + } + for(let i = 1; i < length; i++) { + debug += ', ' + debugString(val[i]); + } + debug += ']'; + return debug; + } + // Test for built-in + const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val)); + let className; + if (builtInMatches.length > 1) { + className = builtInMatches[1]; + } else { + // Failed to match the standard '[object ClassName]' + return toString.call(val); + } + if (className == 'Object') { + // we're a user defined class or Object + // JSON.stringify avoids problems with cycles, and is generally much + // easier than looping through ownProperties of `val`. + try { + return 'Object(' + JSON.stringify(val) + ')'; + } catch (_) { + return 'Object'; + } + } + // errors + if (val instanceof Error) { + return `${val.name}: ${val.message}\n${val.stack}`; + } + // TODO we could test for more things here, like `Set`s and `Map`s. + return className; +} + function makeMutClosure(arg0, arg1, dtor, f) { const state = { a: arg0, b: arg1, cnt: 1, dtor }; const real = (...args) => { @@ -145,7 +210,7 @@ function makeMutClosure(arg0, arg1, dtor, f) { return real; } -function __wbg_adapter_26(arg0, arg1, arg2) { +function __wbg_adapter_28(arg0, arg1, arg2) { wasm.__wbindgen_export_3(arg0, arg1, addHeapObject(arg2)); } @@ -161,10 +226,10 @@ export function init_usdpl(port) { * Get the targeted plugin framework, or "any" if unknown * @returns {string} */ -export function target() { +export function target_usdpl() { try { const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); - wasm.target(retptr); + wasm.target_usdpl(retptr); var r0 = getInt32Memory0()[retptr / 4 + 0]; var r1 = getInt32Memory0()[retptr / 4 + 1]; return getStringFromWasm0(r0, r1); @@ -174,6 +239,48 @@ export function target() { } } +/** +* Get the UDSPL front-end version +* @returns {string} +*/ +export function version_usdpl() { + try { + const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); + wasm.version_usdpl(retptr); + var r0 = getInt32Memory0()[retptr / 4 + 0]; + var r1 = getInt32Memory0()[retptr / 4 + 1]; + return getStringFromWasm0(r0, r1); + } finally { + wasm.__wbindgen_add_to_stack_pointer(16); + wasm.__wbindgen_export_4(r0, r1); + } +} + +/** +* Get the targeted plugin framework, or "any" if unknown +* @param {string} key +* @param {any} value +* @returns {any} +*/ +export function set_value(key, value) { + const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.set_value(ptr0, len0, addHeapObject(value)); + return takeObject(ret); +} + +/** +* Get the targeted plugin framework, or "any" if unknown +* @param {string} key +* @returns {any} +*/ +export function get_value(key) { + const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.get_value(ptr0, len0); + return takeObject(ret); +} + let cachedUint32Memory0; function getUint32Memory0() { if (cachedUint32Memory0.byteLength === 0) { @@ -214,7 +321,7 @@ function handleError(f, args) { wasm.__wbindgen_export_5(addHeapObject(e)); } } -function __wbg_adapter_54(arg0, arg1, arg2, arg3) { +function __wbg_adapter_69(arg0, arg1, arg2, arg3) { wasm.__wbindgen_export_6(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3)); } @@ -255,6 +362,16 @@ function getImports() { imports.wbg.__wbindgen_object_drop_ref = function(arg0) { takeObject(arg0); }; + imports.wbg.__wbindgen_object_clone_ref = function(arg0) { + const ret = getObject(arg0); + return addHeapObject(ret); + }; + imports.wbg.__wbg_log_191da5bcf5c562e5 = function(arg0, arg1) { + console.log(getStringFromWasm0(arg0, arg1)); + }; + imports.wbg.__wbg_error_2ef4335ee3b7ff61 = function(arg0, arg1) { + console.error(getStringFromWasm0(arg0, arg1)); + }; imports.wbg.__wbindgen_string_get = function(arg0, arg1) { const obj = getObject(arg1); const ret = typeof(obj) === 'string' ? obj : undefined; @@ -290,6 +407,24 @@ function getImports() { const ret = getObject(arg0) === undefined; return ret; }; + imports.wbg.__wbg_new_693216e109162396 = function() { + const ret = new Error(); + return addHeapObject(ret); + }; + imports.wbg.__wbg_stack_0ddaca5d1abfb52f = function(arg0, arg1) { + const ret = getObject(arg1).stack; + const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1); + const len0 = WASM_VECTOR_LEN; + getInt32Memory0()[arg0 / 4 + 1] = len0; + getInt32Memory0()[arg0 / 4 + 0] = ptr0; + }; + imports.wbg.__wbg_error_09919627ac0992f5 = function(arg0, arg1) { + try { + console.error(getStringFromWasm0(arg0, arg1)); + } finally { + wasm.__wbindgen_export_4(arg0, arg1); + } + }; imports.wbg.__wbg_instanceof_Window_a2a08d3918d7d4d0 = function(arg0) { const ret = getObject(arg0) instanceof Window; return ret; @@ -317,10 +452,6 @@ function getImports() { const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2)); return addHeapObject(ret); }, arguments) }; - imports.wbg.__wbindgen_object_clone_ref = function(arg0) { - const ret = getObject(arg0); - return addHeapObject(ret); - }; imports.wbg.__wbindgen_cb_drop = function(arg0) { const obj = takeObject(arg0).original; if (obj.cnt-- == 1) { @@ -380,7 +511,7 @@ function getImports() { const a = state0.a; state0.a = 0; try { - return __wbg_adapter_54(a, state0.b, arg0, arg1); + return __wbg_adapter_69(a, state0.b, arg0, arg1); } finally { state0.a = a; } @@ -415,11 +546,18 @@ function getImports() { const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2)); return ret; }, arguments) }; + imports.wbg.__wbindgen_debug_string = function(arg0, arg1) { + const ret = debugString(getObject(arg1)); + const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1); + const len0 = WASM_VECTOR_LEN; + getInt32Memory0()[arg0 / 4 + 1] = len0; + getInt32Memory0()[arg0 / 4 + 0] = ptr0; + }; imports.wbg.__wbindgen_throw = function(arg0, arg1) { throw new Error(getStringFromWasm0(arg0, arg1)); }; - imports.wbg.__wbindgen_closure_wrapper631 = function(arg0, arg1, arg2) { - const ret = makeMutClosure(arg0, arg1, 71, __wbg_adapter_26); + imports.wbg.__wbindgen_closure_wrapper365 = function(arg0, arg1, arg2) { + const ret = makeMutClosure(arg0, arg1, 78, __wbg_adapter_28); return addHeapObject(ret); }; @@ -475,7 +613,7 @@ export default init; // USDPL customization -const encoded = "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"; +const encoded = "AGFzbQEAAAABmwEXYAJ/fwF/YAJ/fwBgAX8AYAN/f38Bf2ADf39/AGAEf39/fwBgAX8Bf2AAAX9gAABgBH9/f38Bf2AFf39/f38AYAF/AX5gBX9/f39/AX9gBn9/f39/fwBgBn9/f39/fwF/YAV/f31/fwBgBX9/fH9/AGAEf31/fwBgBH98f38AYAJ+fwBgB39/f39/f38Bf2ADfn9/AX9gAXwBfwKUCyoDd2JnGl9fd2JpbmRnZW5fb2JqZWN0X2Ryb3BfcmVmAAIDd2JnG19fd2JpbmRnZW5fb2JqZWN0X2Nsb25lX3JlZgAGA3diZxpfX3diZ19sb2dfMTkxZGE1YmNmNWM1NjJlNQABA3diZxxfX3diZ19lcnJvcl8yZWY0MzM1ZWUzYjdmZjYxAAEDd2JnFV9fd2JpbmRnZW5fc3RyaW5nX2dldAABA3diZxVfX3diaW5kZ2VuX3N0cmluZ19uZXcAAAN3YmcVX193YmluZGdlbl9udW1iZXJfbmV3ABYDd2JnFl9fd2JpbmRnZW5fYm9vbGVhbl9nZXQABgN3YmcVX193YmluZGdlbl9udW1iZXJfZ2V0AAEDd2JnEl9fd2JpbmRnZW5faXNfbnVsbAAGA3diZxdfX3diaW5kZ2VuX2lzX3VuZGVmaW5lZAAGA3diZxpfX3diZ19uZXdfNjkzMjE2ZTEwOTE2MjM5NgAHA3diZxxfX3diZ19zdGFja18wZGRhY2E1ZDFhYmZiNTJmAAEDd2JnHF9fd2JnX2Vycm9yXzA5OTE5NjI3YWMwOTkyZjUAAQN3YmcoX193YmdfaW5zdGFuY2VvZl9XaW5kb3dfYTJhMDhkMzkxOGQ3ZDRkMAAGA3diZxxfX3diZ19mZXRjaF8yMzUwNzM2OGVlZDhkODM4AAADd2JnKl9fd2JnX2luc3RhbmNlb2ZfUmVzcG9uc2VfZTkyOGM1NGMxMDI1NDcwYwAGA3diZxpfX3diZ191cmxfMGY4MjAzMGU3MjQ1OTU0YwABA3diZxtfX3diZ190ZXh0XzVjYjc4ODMwYzFhMTFjNWIABgN3YmcoX193YmdfbmV3d2l0aHN0cmFuZGluaXRfNDFjODZlODIxZjc3MWIyNAADA3diZxJfX3diaW5kZ2VuX2NiX2Ryb3AABgN3YmcgX193YmdfbmV3bm9hcmdzX2ZjNTM1NjI4OTIxOWI5M2IAAAN3YmcbX193YmdfY2FsbF80NTczZjYwNWNhNGI1ZjEwAAADd2JnGl9fd2JnX25ld18zMDZjZThkNTc5MTllNmFlAAcDd2JnFF9fd2JpbmRnZW5faXNfc3RyaW5nAAYDd2JnG19fd2JnX3NlbGZfYmExZGRhZmU5ZWE3YTNhMgAHA3diZx1fX3diZ193aW5kb3dfYmUzY2M0MzAzNjRmZDMyYwAHA3diZyFfX3diZ19nbG9iYWxUaGlzXzU2ZDljOWY4MTRkYWVlZWUABwN3YmcdX193YmdfZ2xvYmFsXzhjMzVhZWVlNGFjNzdmMmIABwN3YmckX193YmdfbmV3d2l0aGxlbmd0aF81MWJkMDhhZWQzNGVjNmEzAAYDd2JnGl9fd2JnX3NldF9jMWQwNGY4YjQ1YTAzNmU3AAQDd2JnG19fd2JnX2NhbGxfOTg1NWE0NjEyZWI0OTZjYgADA3diZxpfX3diZ19uZXdfNzg0MDNiMTM4NDI4YjY4NAAAA3diZx5fX3diZ19yZXNvbHZlX2YyNjljZTE3NGY4OGIyOTQABgN3YmcbX193YmdfdGhlbl8xYzY5OGVlZGNhMTVlZWQ2AAADd2JnG19fd2JnX3RoZW5fNGRlYmM0MWQ0ZmM5MmNlNQADA3diZxxfX3diZ19wYXJzZV81YjgyM2I4Njg2ODE3ZWI4AAADd2JnIF9fd2JnX3N0cmluZ2lmeV9jZjIwZGM5NmJlZTM0YTY2AAYDd2JnGl9fd2JnX3NldF9iMTJjZDBhYjgyOTAzYzJmAAMDd2JnF19fd2JpbmRnZW5fZGVidWdfc3RyaW5nAAEDd2JnEF9fd2JpbmRnZW5fdGhyb3cAAQN3YmcdX193YmluZGdlbl9jbG9zdXJlX3dyYXBwZXIzNjUAAwOYA5YDBQYJBAIFAwIABAMOBAkEAwUEBAQDBAgBAQUEAgELBAEABgQTAAQAAA0GFAwEAAcGBAEBAxUABAAEAQIABwIABgABAgUBAAQEAQQGAgAGAAQEAAEGCQIABQQBBAEAAAAEBQQCBAQEBQQKBQMIBQgGBAQBAQUFAgIBAAUFBAUCAgIAAAICAAQFBQEGBgYKAQQCBQUNAgIBBAIFAgoDBgABAgYAAAACAQEBBAAAAQMCAQQCAAEAAAEAAQAAAgABAQACBQIIAgICBQQCAgEBAQQCAgIBAQMCAgUBCAMCAQQBAQEEBgIBAQMDCQEEAQEGBAQCCgcEAQIGCAgBAQQBAgECAgEBAQEIAQICAgYBBgEAAgAAAQEBAgIBAQECAgUEBAEBAgICBAEGAwQADgEKDwwQCQECBQEEAwICBgYGBgUCAgEGAQAAAAQACQMBAAAGAAMFAgMCAAADAAAABAQCAAEGAAMGBgEGAAAABAMABgQEAgACAQAAAQAGBgYGAQEBAQMAAAADAwYBAQcAAAYGAgECBgsLCwsCBAQHAXABmwGbAQUDAQARBgkBfwFBgIDAAAsHpQIPBm1lbW9yeQIACmluaXRfdXNkcGwAtgMMdGFyZ2V0X3VzZHBsAPMBDXZlcnNpb25fdXNkcGwA7wEJc2V0X3ZhbHVlAMUBCWdldF92YWx1ZQDHAQxjYWxsX2JhY2tlbmQAfhNfX3diaW5kZ2VuX2V4cG9ydF8wALMCE19fd2JpbmRnZW5fZXhwb3J0XzEA0AITX193YmluZGdlbl9leHBvcnRfMgEAE19fd2JpbmRnZW5fZXhwb3J0XzMA3gIfX193YmluZGdlbl9hZGRfdG9fc3RhY2tfcG9pbnRlcgCVAxNfX3diaW5kZ2VuX2V4cG9ydF80APMCE19fd2JpbmRnZW5fZXhwb3J0XzUAhQMTX193YmluZGdlbl9leHBvcnRfNgDcAgmvAgIAQQELVNoBUL4DmQGZAa4DmAP0AvUCsAO6A+kCsAO/A7kCigNq5QHuAr4D+AL+AtsBgAGCA5EDgAOUA64BmAPmArsBuQOvA/kCQ5oB+gK6AaYBuQOWA5cDwgGlAVq+A7cDtwO3A+cC/wJ44wG7ArsCmAOKA2qZA5oD+wJovgO+A/ICZd0BnAO+A4YBvgP2Ad0CuwPeAt4CyQK+A+0C7AK4A7YCbgBB1gALRb4D/AKiAo4CowKNAuICtALyAf8BygLkAt8C3ALVAtUC1gLYAtUC1wLXArwB0wK+A4AD0gL0AoID3wG+A48ChgPeAbcCnwPMArwDuwO4AnKhAaoChwO+AroCvgOQAo8D4AGJA8sBSpADzQH3Av0C0wG+A70DOXvoAaoDkwN24gGrA6kDbwreyQSWA/QeAhB/CH4gAygCCCENAkACQAJAAkACQAJAAkAgAhDPAiIMrUIGfiIUQiCIpw0AIBSnIgogDWoiCCAKSQ0AAkAgCCANTQRAIAMgCDYCCAwBCyADIAggDWsQ3AEgAygCCCEICyAIIA1JDQEgAygCACERQYS0wAAoAgAhBgJAAkACQAJAAkACQCACQQdxIgsOBgABAgMEAQULQQghCwwEC0IBIRQgAkUNCiABIAJBf2oiAmotAAAiAUE9Rg0KIAEgBmotAABB/wFHDQogAa1CCIYgAq1CIIaEIRQMCgtBCiELDAILQQshCwwBC0EMIQsLIAggDWshDkEAIQpBACACIAtrIgQgBCACSxsiCEFgaiIQIAhLBEBBACELDAYLIA0gEWohEkEAIQsCQAJAA0AgB0FgRg0FIAdBIGoiCiACSw0GIAtBGmogDksNBwJAAkAgBiABIAdqIgktAAAiBWoxAAAiFEL/AVENACAGIAlBAWotAAAiBWoxAAAiFUL/AVEEQCAHQQFqIQcMAQsgBiAJQQJqLQAAIgVqMQAAIhZC/wFRBEAgB0ECaiEHDAELIAYgCUEDai0AACIFajEAACIXQv8BUQRAIAdBA2ohBwwBCyAGIAlBBGotAAAiBWoxAAAiGEL/AVEEQCAHQQRqIQcMAQsgBiAJQQVqLQAAIgVqMQAAIhlC/wFRBEAgB0EFaiEHDAELIAYgCUEGai0AACIFajEAACIaQv8BUQRAIAdBBmohBwwBCyAGIAlBB2otAAAiBWoxAAAiG0L/AVINASAHQQdqIQcLIAWtQgiGIAetQiCGhCEUDAoLIAsgEmoiDyAVQjSGIBRCOoaEIBZCLoaEIBdCKIaEIBhCIoaEIBlCHIaEIBpCFoaEIBtCEIaEIhRCOIYgFEIohkKAgICAgIDA/wCDhCAUQhiGQoCAgICA4D+DIBRCCIZCgICAgPAfg4SEIBRCCIhCgICA+A+DIBRCGIhCgID8B4OEIBRCKIhCgP4DgyAUQjiIhISENwAAQQghBSAGIAlBCGotAAAiBGoxAAAiFEL/AVENAkEJIQUgBiAJQQlqLQAAIgRqMQAAIhVC/wFRDQJBCiEFIAYgCUEKai0AACIEajEAACIWQv8BUQ0CQQshBSAGIAlBC2otAAAiBGoxAAAiF0L/AVENAkEMIQUgBiAJQQxqLQAAIgRqMQAAIhhC/wFRDQJBDSEFIAYgCUENai0AACIEajEAACIZQv8BUQ0CQQ4hBSAGIAlBDmotAAAiBGoxAAAiGkL/AVENAkEPIQUgBiAJQQ9qLQAAIgRqMQAAIhtC/wFRDQIgD0EGaiAVQjSGIBRCOoaEIBZCLoaEIBdCKIaEIBhCIoaEIBlCHIaEIBpCFoaEIBtCEIaEIhRCOIYgFEIohkKAgICAgIDA/wCDhCAUQhiGQoCAgICA4D+DIBRCCIZCgICAgPAfg4SEIBRCCIhCgICA+A+DIBRCGIhCgID8B4OEIBRCKIhCgP4DgyAUQjiIhISENwAAQRAhBQJAIAYgCUEQai0AACIEajEAACIUQv8BUQ0AQREhBSAGIAlBEWotAAAiBGoxAAAiFUL/AVENAEESIQUgBiAJQRJqLQAAIgRqMQAAIhZC/wFRDQBBEyEFIAYgCUETai0AACIEajEAACIXQv8BUQ0AQRQhBSAGIAlBFGotAAAiBGoxAAAiGEL/AVENAEEVIQUgBiAJQRVqLQAAIgRqMQAAIhlC/wFRDQBBFiEFIAYgCUEWai0AACIEajEAACIaQv8BUQ0AQRchBSAGIAlBF2otAAAiBGoxAAAiG0L/AVENACAPQQxqIBVCNIYgFEI6hoQgFkIuhoQgF0IohoQgGEIihoQgGUIchoQgGkIWhoQgG0IQhoQiFEI4hiAUQiiGQoCAgICAgMD/AIOEIBRCGIZCgICAgIDgP4MgFEIIhkKAgICA8B+DhIQgFEIIiEKAgID4D4MgFEIYiEKAgPwHg4QgFEIoiEKA/gODIBRCOIiEhIQ3AABBGCEFIAYgCUEYai0AACIEajEAACIUQv8BUQ0CQRkhBSAGIAlBGWotAAAiBGoxAAAiFUL/AVENAkEaIQUgBiAJQRpqLQAAIgRqMQAAIhZC/wFRDQJBGyEFIAYgCUEbai0AACIEajEAACIXQv8BUQ0CQRwhBSAGIAlBHGotAAAiBGoxAAAiGEL/AVENAkEdIQUgBiAJQR1qLQAAIgRqMQAAIhlC/wFRDQJBHiEFIAYgCUEeai0AACIEajEAACIaQv8BUQ0CQR8hBSAGIAlBH2otAAAiBGoxAAAiG0L/AVENAiAPQRJqIBVCNIYgFEI6hoQgFkIuhoQgF0IohoQgGEIihoQgGUIchoQgGkIWhoQgG0IQhoQiFEI4hiAUQiiGQoCAgICAgMD/AIOEIBRCGIZCgICAgIDgP4MgFEIIhkKAgICA8B+DhIQgFEIIiEKAgID4D4MgFEIYiEKAgPwHg4QgFEIoiEKA/gODIBRCOIiEhIQ3AAAgDEF8aiEMIAtBGGohCyAKIgcgEEsNCQwBCwsgBK1CCIYgBSAHcq1CIIaEIRQMCAsgBK1CCIYgBSAHcq1CIIaEIRQMBwsgBK1CCIYgBSAHcq1CIIaEIRQMBgtBmJrAAEEuQciawAAQkgMACyANIAgQpQMAC0FgQQAQpwMACyAHQSBqIAIQpgMACyALQRpqIA4QpgMACwJAIAhBeGoiBSAISyAKIAVPckUEQCANIBFqIQkCQAJAAkACQAJAA0AgCkF4Rg0CIApBCGoiBCACSw0DIAtBd0sNBCALQQhqIA5LDQUgBiABIApqIgctAAAiCGoxAAAiFEL/AVENASAGIAdBAWotAAAiCGoxAAAiFUL/AVEEQCAKQQFyIQoMAgsgBiAHQQJqLQAAIghqMQAAIhZC/wFRBEAgCkECciEKDAILIAYgB0EDai0AACIIajEAACIXQv8BUQRAIApBA3IhCgwCCyAGIAdBBGotAAAiCGoxAAAiGEL/AVEEQCAKQQRyIQoMAgsgBiAHQQVqLQAAIghqMQAAIhlC/wFRBEAgCkEFciEKDAILIAYgB0EGai0AACIIajEAACIaQv8BUQRAIApBBnIhCgwCCyAGIAdBB2otAAAiCGoxAAAiG0L/AVIEQCAJIAtqIBVCNIYgFEI6hoQgFkIuhoQgF0IohoQgGEIihoQgGUIchoQgGkIWhoQgG0IQhoQiFEI4hiAUQiiGQoCAgICAgMD/AIOEIBRCGIZCgICAgIDgP4MgFEIIhkKAgICA8B+DhIQgFEIIiEKAgID4D4MgFEIYiEKAgPwHg4QgFEIoiEKA/gODIBRCOIiEhIQ3AAAgDEF/aiEMIAtBBmohCyAEIQogBCAFTw0IDAELCyAKQQdyIQoLIAqtQiCGIAitQgiGhCEUDAYLQXggCkEIahCnAwALIApBCGogAhCmAwALIAsgC0EIahCnAwALIAtBCGogDhCmAwALIAohBAsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAMQQJJBEAgCyEKDAELIAxBf2ohByACIARrIQggDSARaiEJA0AgBCACSw0CIAtBeUsNAyALQQZqIgogDksNBCACIARGDQUgBiABIARqIgwtAAAiBWoxAAAiFEL/AVENFCAIQQJJDQYgBiAMQQFqLQAAIgVqMQAAIhVC/wFRDRIgCEECTQ0HIAYgDEECai0AACIFajEAACIWQv8BUQ0IIAhBA00NCSAGIAxBA2otAAAiBWoxAAAiF0L/AVENCiAIQQRNDQsgBiAMQQRqLQAAIgVqMQAAIhhC/wFRDQwgCEEFTQ0NIAYgDEEFai0AACIFajEAACIZQv8BUQ0OIAhBBk0NDyAGIAxBBmotAAAiBWoxAAAiGkL/AVENECAIQQdNDREgBiAMQQdqLQAAIgVqMQAAIhtC/wFRDRMgCSALaiILQQRqIBVCNIYgFEI6hoQgFkIuhoQgF0IohoQgGEIihoQgGUIchoQgGkIWhoQgG0IQhoQiFEIYhkKAgICAgOA/gyAUQgiGQoCAgIDwH4OEQiCIPQAAIAsgFEIIiEKAgID4D4MgFEIYiEKAgPwHg4QgFEIoiEKA/gODIBRCOIiEhD4AACAIQXhqIQggBEEIaiEEIAohCyAHQX9qIgcNAAsLIAQgAk0EQCACIARGBEBBACEMQgAhFEEAIQVBACEHQQAhAgwWCyABIAJqIRIgASAEaiELQgAhFEEAIQJBACEBQQAhB0EAIQVBACEQAkACQAJAA0BBACEIA0AgCCAQaiEPIAcgCGohCSAIIAtqIhMtAAAiDEE9RwRAIAlBAEoNBCAGIAxqMQAAIhVC/wFRDQUgD0EBaiEQIBUgBUEBaiIFQXpsQT5xrYYgFIQhFCAMIQIgCSEHIBNBAWoiCyASRw0CDBoLIA9BAnFFDQIgASAPIAkbIQEgCyAIQQFqIghqIBJHDQALCyACIQwMFwsgASAPIAcgCGpBAEobIARqrUIghkKA+gCEIRQMGAsgASAEaq1CIIZCgPoAhCEUDBcLIAytQgiGIAQgEGogCGqtQiCGhCEUDBYLIAQgAhClAwALIAQgAhClAwALIAsgC0EGahCnAwALIAtBBmogDhCmAwALQQBBAEGsl8AAENIBAAtBAUEBQbyXwAAQ0gEAC0ECQQJBzJfAABDSAQALIARBAmohBAwLC0EDQQNB3JfAABDSAQALIARBA2ohBAwJC0EEQQRB7JfAABDSAQALIARBBGohBAwHC0EFQQVB/JfAABDSAQALIARBBWohBAwFC0EGQQZBjJjAABDSAQALIARBBmohBAwDC0EHQQdBnJjAABDSAQALIARBAWohBAwBCyAEQQdqIQQLIAWtQgiGIAStQiCGhCEUDAILQQAhBwJ/AkACQAJAAkACQAJAAkAgBSICDgkIAAECAwAEBQYACxChAgALQQgMBQtBEAwEC0EYDAMLQSAMAgtBKAwBC0EwCyECQQEhBwsCQEEBQQBCfyACrYggFINCAFIbRQRAIAcEQCAKIA4gCiAOSxshASANIBFqIQRBACEIQTghBwNAIAEgCkYNAyAEIApqIBQgB0E4ca2IPAAAIAdBeGohByAKQQFqIQogCEEIaiIIIAJJDQALCyADKAIIIAogDWoiAU8EQCADIAE2AggLIABBAzoAAA8LIAQgBWpBf2qtQiCGIAytQv8Bg0IIhoRCAoQhFAwBCyABIA5BiJrAABDSAQALIAAgFDcCAAvQIAIPfwF+IwBBEGsiCSQAAkACQAJAAkACQAJAIABB9QFPBEBBgIB8QQhBCBDwAkEUQQgQ8AJqQRBBCBDwAmprQXdxQX1qIgFBAEEQQQgQ8AJBAnRrIgMgAyABSxsgAE0NBiAAQQRqQQgQ8AIhBEGc/8AAKAIARQ0FQQAgBGshAgJ/QQAgBEGAAkkNABpBHyAEQf///wdLDQAaIARBBiAEQQh2ZyIAa3ZBAXEgAEEBdGtBPmoLIgdBAnRBqIHBAGooAgAiAQ0BQQAhAEEAIQMMAgtBECAAQQRqQRBBCBDwAkF7aiAASxtBCBDwAiEEAkACQAJAAn8CQAJAQZj/wAAoAgAiBSAEQQN2IgF2IgBBA3FFBEAgBEGogsEAKAIATQ0LIAANAUGc/8AAKAIAIgBFDQsgABCLA2hBAnRBqIHBAGooAgAiARCgAyAEayECIAEQ5QIiAARAA0AgABCgAyAEayIDIAIgAyACSSIDGyECIAAgASADGyEBIAAQ5QIiAA0ACwsgASIAIAQQsgMhBSAAEGcgAkEQQQgQ8AJJDQUgACAEEI0DIAUgAhDrAkGogsEAKAIAIgFFDQQgAUEDdiIGQQN0QaD/wABqIQFBsILBACgCACEDQZj/wAAoAgAiB0EBIAZ0IgZxRQ0CIAEoAggMAwsCQCAAQX9zQQFxIAFqIgBBA3QiAkGo/8AAaigCACIBQQhqKAIAIgMgAkGg/8AAaiICRwRAIAMgAjYCDCACIAM2AggMAQtBmP/AACAFQX4gAHdxNgIACyABIABBA3QQ2gIgARC0AyECDAsLAkBBASABQR9xIgF0EPYCIAAgAXRxEIsDaCIAQQN0IgJBqP/AAGooAgAiA0EIaigCACIBIAJBoP/AAGoiAkcEQCABIAI2AgwgAiABNgIIDAELQZj/wABBmP/AACgCAEF+IAB3cTYCAAsgAyAEEI0DIAMgBBCyAyIFIABBA3QgBGsiBBDrAkGogsEAKAIAIgAEQCAAQQN2IgJBA3RBoP/AAGohAEGwgsEAKAIAIQECf0GY/8AAKAIAIgZBASACdCICcQRAIAAoAggMAQtBmP/AACACIAZyNgIAIAALIQIgACABNgIIIAIgATYCDCABIAA2AgwgASACNgIIC0GwgsEAIAU2AgBBqILBACAENgIAIAMQtAMhAgwKC0GY/8AAIAYgB3I2AgAgAQshBiABIAM2AgggBiADNgIMIAMgATYCDCADIAY2AggLQbCCwQAgBTYCAEGogsEAIAI2AgAMAQsgACACIARqENoCCyAAELQDIgINBQwECyAEIAcQ6gJ0IQZBACEAQQAhAwNAAkAgARCgAyIFIARJDQAgBSAEayIFIAJPDQAgASEDIAUiAg0AQQAhAiABIQAMAwsgAUEUaigCACIFIAAgBSABIAZBHXZBBHFqQRBqKAIAIgFHGyAAIAUbIQAgBkEBdCEGIAENAAsLIAAgA3JFBEBBACEDQQEgB3QQ9gJBnP/AACgCAHEiAEUNAyAAEIsDaEECdEGogcEAaigCACEACyAARQ0BCwNAIAAgAyAAEKADIgEgBE8gASAEayIBIAJJcSIFGyEDIAEgAiAFGyECIAAQ5QIiAA0ACwsgA0UNAEGogsEAKAIAIgAgBE9BACACIAAgBGtPGw0AIAMiACAEELIDIQEgABBnAkAgAkEQQQgQ8AJPBEAgACAEEI0DIAEgAhDrAiACQYACTwRAIAEgAhBjDAILIAJBA3YiAkEDdEGg/8AAaiEDAn9BmP/AACgCACIFQQEgAnQiAnEEQCADKAIIDAELQZj/wAAgAiAFcjYCACADCyECIAMgATYCCCACIAE2AgwgASADNgIMIAEgAjYCCAwBCyAAIAIgBGoQ2gILIAAQtAMiAg0BCwJAAkACQAJAAkACQAJAAkBBqILBACgCACIBIARJBEBBrILBACgCACIAIARLDQIgCUEIQQgQ8AIgBGpBFEEIEPACakEQQQgQ8AJqQYCABBDwAhCsAiAJKAIAIgMNAUEAIQIMCQtBsILBACgCACEAIAEgBGsiAUEQQQgQ8AJJBEBBsILBAEEANgIAQaiCwQAoAgAhAUGogsEAQQA2AgAgACABENoCIAAQtAMhAgwJCyAAIAQQsgMhA0GogsEAIAE2AgBBsILBACADNgIAIAMgARDrAiAAIAQQjQMgABC0AyECDAgLIAkoAgghBkG4gsEAIAkoAgQiBUG4gsEAKAIAaiIANgIAQbyCwQBBvILBACgCACIBIAAgASAASxs2AgACQAJAQbSCwQAoAgAEQEHAgsEAIQADQCAAEI4DIANGDQIgACgCCCIADQALDAILQdSCwQAoAgAiAEUgAyAASXINAwwHCyAAEKIDDQAgABCjAyAGRw0AIAAiASgCACICQbSCwQAoAgAiB00EfyACIAEoAgRqIAdLBUEACw0DC0HUgsEAQdSCwQAoAgAiACADIAMgAEsbNgIAIAMgBWohAUHAgsEAIQACQAJAA0AgASAAKAIARwRAIAAoAggiAA0BDAILCyAAEKIDDQAgABCjAyAGRg0BC0G0gsEAKAIAIQJBwILBACEAAkADQCAAKAIAIAJNBEAgABCOAyACSw0CCyAAKAIIIgANAAtBACEACyACIAAQjgMiD0EUQQgQ8AIiDmtBaWoiABC0AyIBQQgQ8AIgAWsgAGoiACAAQRBBCBDwAiACakkbIgcQtAMhASAHIA4QsgMhAEEIQQgQ8AIhCkEUQQgQ8AIhC0EQQQgQ8AIhDEG0gsEAIAMgAxC0AyIIQQgQ8AIgCGsiDRCyAyIINgIAQayCwQAgBUEIaiAMIAogC2pqIA1qayIKNgIAIAggCkEBcjYCBEEIQQgQ8AIhC0EUQQgQ8AIhDEEQQQgQ8AIhDSAIIAoQsgNB0ILBAEGAgIABNgIAIA0gDCALQQhramo2AgQgByAOEI0DQcCCwQApAgAhECABQQhqQciCwQApAgA3AgAgASAQNwIAQcyCwQAgBjYCAEHEgsEAIAU2AgBBwILBACADNgIAQciCwQAgATYCAANAIABBBBCyAyEBIABBBzYCBCAPIAEiAEEEaksNAAsgAiAHRg0HIAIgByACayIAIAIgABCyAxDRAiAAQYACTwRAIAIgABBjDAgLIABBA3YiAUEDdEGg/8AAaiEAAn9BmP/AACgCACIDQQEgAXQiAXEEQCAAKAIIDAELQZj/wAAgASADcjYCACAACyEBIAAgAjYCCCABIAI2AgwgAiAANgIMIAIgATYCCAwHCyAAKAIAIQIgACADNgIAIAAgACgCBCAFajYCBCADELQDIgBBCBDwAiEBIAIQtAMiBUEIEPACIQYgAyABIABraiIDIAQQsgMhASADIAQQjQMgAiAGIAVraiIAIAMgBGprIQQgAEG0gsEAKAIARwRAQbCCwQAoAgAgAEYNBCAAKAIEQQNxQQFHDQUCQCAAEKADIgJBgAJPBEAgABBnDAELIABBDGooAgAiBSAAQQhqKAIAIgZHBEAgBiAFNgIMIAUgBjYCCAwBC0GY/8AAQZj/wAAoAgBBfiACQQN2d3E2AgALIAIgBGohBCAAIAIQsgMhAAwFC0G0gsEAIAE2AgBBrILBAEGsgsEAKAIAIARqIgA2AgAgASAAQQFyNgIEIAMQtAMhAgwHC0GsgsEAIAAgBGsiATYCAEG0gsEAQbSCwQAoAgAiACAEELIDIgM2AgAgAyABQQFyNgIEIAAgBBCNAyAAELQDIQIMBgtB1ILBACADNgIADAMLIAAgACgCBCAFajYCBEG0gsEAKAIAQayCwQAoAgAgBWoQyAEMAwtBsILBACABNgIAQaiCwQBBqILBACgCACAEaiIANgIAIAEgABDrAiADELQDIQIMAwsgASAEIAAQ0QIgBEGAAk8EQCABIAQQYyADELQDIQIMAwsgBEEDdiICQQN0QaD/wABqIQACf0GY/8AAKAIAIgVBASACdCICcQRAIAAoAggMAQtBmP/AACACIAVyNgIAIAALIQIgACABNgIIIAIgATYCDCABIAA2AgwgASACNgIIIAMQtAMhAgwCC0HYgsEAQf8fNgIAQcyCwQAgBjYCAEHEgsEAIAU2AgBBwILBACADNgIAQaz/wABBoP/AADYCAEG0/8AAQaj/wAA2AgBBqP/AAEGg/8AANgIAQbz/wABBsP/AADYCAEGw/8AAQaj/wAA2AgBBxP/AAEG4/8AANgIAQbj/wABBsP/AADYCAEHM/8AAQcD/wAA2AgBBwP/AAEG4/8AANgIAQdT/wABByP/AADYCAEHI/8AAQcD/wAA2AgBB3P/AAEHQ/8AANgIAQdD/wABByP/AADYCAEHk/8AAQdj/wAA2AgBB2P/AAEHQ/8AANgIAQez/wABB4P/AADYCAEHg/8AAQdj/wAA2AgBB6P/AAEHg/8AANgIAQfT/wABB6P/AADYCAEHw/8AAQej/wAA2AgBB/P/AAEHw/8AANgIAQfj/wABB8P/AADYCAEGEgMEAQfj/wAA2AgBBgIDBAEH4/8AANgIAQYyAwQBBgIDBADYCAEGIgMEAQYCAwQA2AgBBlIDBAEGIgMEANgIAQZCAwQBBiIDBADYCAEGcgMEAQZCAwQA2AgBBmIDBAEGQgMEANgIAQaSAwQBBmIDBADYCAEGggMEAQZiAwQA2AgBBrIDBAEGggMEANgIAQbSAwQBBqIDBADYCAEGogMEAQaCAwQA2AgBBvIDBAEGwgMEANgIAQbCAwQBBqIDBADYCAEHEgMEAQbiAwQA2AgBBuIDBAEGwgMEANgIAQcyAwQBBwIDBADYCAEHAgMEAQbiAwQA2AgBB1IDBAEHIgMEANgIAQciAwQBBwIDBADYCAEHcgMEAQdCAwQA2AgBB0IDBAEHIgMEANgIAQeSAwQBB2IDBADYCAEHYgMEAQdCAwQA2AgBB7IDBAEHggMEANgIAQeCAwQBB2IDBADYCAEH0gMEAQeiAwQA2AgBB6IDBAEHggMEANgIAQfyAwQBB8IDBADYCAEHwgMEAQeiAwQA2AgBBhIHBAEH4gMEANgIAQfiAwQBB8IDBADYCAEGMgcEAQYCBwQA2AgBBgIHBAEH4gMEANgIAQZSBwQBBiIHBADYCAEGIgcEAQYCBwQA2AgBBnIHBAEGQgcEANgIAQZCBwQBBiIHBADYCAEGkgcEAQZiBwQA2AgBBmIHBAEGQgcEANgIAQaCBwQBBmIHBADYCAEEIQQgQ8AIhAUEUQQgQ8AIhAkEQQQgQ8AIhBkG0gsEAIAMgAxC0AyIAQQgQ8AIgAGsiAxCyAyIANgIAQayCwQAgBUEIaiAGIAEgAmpqIANqayIBNgIAIAAgAUEBcjYCBEEIQQgQ8AIhA0EUQQgQ8AIhAkEQQQgQ8AIhBSAAIAEQsgNB0ILBAEGAgIABNgIAIAUgAiADQQhramo2AgQLQQAhAkGsgsEAKAIAIgAgBE0NAEGsgsEAIAAgBGsiATYCAEG0gsEAQbSCwQAoAgAiACAEELIDIgM2AgAgAyABQQFyNgIEIAAgBBCNAyAAELQDIQILIAlBEGokACACC8QRAg9/An4jAEGgCGsiByQAIAdBCGpBAEGACBCtAxogACwABEECdEHss8AAaigCACEFIAAoAgAhDiAAQQVqLQAAIQ8CQAJAA0AgBCACSSIQBEACQAJAAkACQCACIARrIgAgDiAOIABLGyIIIARqIgsgCE8EQCALIAJLDQFBACEGIAEgBGohDCAIQRtJBEBBACEADAULQQAgCEFmaiIAIAAgCEsbIQ1BACEAA0AgBkEaaiAISw0DIABB4QdPDQQgB0GICGogBiAMaiIJEM4CIActAIgIDQkgB0EIaiAAaiIEIAUgBykAiQgiE0I4hiIUQjqIp2otAAA6AAAgBEEBaiAFIBQgE0IohkKAgICAgIDA/wCDhCIUQjSIp0E/cWotAAA6AAAgBEECaiAFIBQgE0IYhkKAgICAgOA/gyATQgiGQoCAgIDwH4OEhCIUQi6Ip0E/cWotAAA6AAAgBEEDaiAFIBRCKIinQT9xai0AADoAACAEQQRqIAUgFEIiiKdBP3FqLQAAOgAAIARBBmogBSATQgiIQoCAgPgPgyATQhiIQoCA/AeDhCATQiiIQoD+A4MgE0I4iISEIhOnIgpBFnZBP3FqLQAAOgAAIARBB2ogBSAKQRB2QT9xai0AADoAACAEQQVqIAUgEyAUhEIciKdBP3FqLQAAOgAAIAdBiAhqIAlBBmoQzgIgBy0AiAgNCSAEQQhqIAUgBykAiQgiE0I4hiIUQjqIp2otAAA6AAAgBEEJaiAFIBQgE0IohkKAgICAgIDA/wCDhCIUQjSIp0E/cWotAAA6AAAgBEEKaiAFIBQgE0IYhkKAgICAgOA/gyATQgiGQoCAgIDwH4OEhCIUQi6Ip0E/cWotAAA6AAAgBEELaiAFIBRCKIinQT9xai0AADoAACAEQQxqIAUgFEIiiKdBP3FqLQAAOgAAIARBDmogBSATQgiIQoCAgPgPgyATQhiIQoCA/AeDhCATQiiIQoD+A4MgE0I4iISEIhOnIgpBFnZBP3FqLQAAOgAAIARBD2ogBSAKQRB2QT9xai0AADoAACAEQQ1qIAUgEyAUhEIciKdBP3FqLQAAOgAAIAdBiAhqIAlBDGoQzgIgBy0AiAgNCSAEQRBqIAUgBykAiQgiE0I4hiIUQjqIp2otAAA6AAAgBEERaiAFIBQgE0IohkKAgICAgIDA/wCDhCIUQjSIp0E/cWotAAA6AAAgBEESaiAFIBQgE0IYhkKAgICAgOA/gyATQgiGQoCAgIDwH4OEhCIUQi6Ip0E/cWotAAA6AAAgBEETaiAFIBRCKIinQT9xai0AADoAACAEQRRqIAUgFEIiiKdBP3FqLQAAOgAAIARBFmogBSATQgiIQoCAgPgPgyATQhiIQoCA/AeDhCATQiiIQoD+A4MgE0I4iISEIhOnIgpBFnZBP3FqLQAAOgAAIARBF2ogBSAKQRB2QT9xai0AADoAACAEQRVqIAUgEyAUhEIciKdBP3FqLQAAOgAAIAdBiAhqIAlBEmoQzgIgBy0AiAgNCSAEQRhqIAUgBykAiQgiE0I4hiIUQjqIp2otAAA6AAAgBEEZaiAFIBQgE0IohkKAgICAgIDA/wCDhCIUQjSIp0E/cWotAAA6AAAgBEEaaiAFIBQgE0IYhkKAgICAgOA/gyATQgiGQoCAgIDwH4OEhCIUQi6Ip0E/cWotAAA6AAAgBEEbaiAFIBRCKIinQT9xai0AADoAACAEQRxqIAUgFEIiiKdBP3FqLQAAOgAAIARBHmogBSATQgiIQoCAgPgPgyATQhiIQoCA/AeDhCATQiiIQoD+A4MgE0I4iISEIhOnIglBFnZBP3FqLQAAOgAAIARBH2ogBSAJQRB2QT9xai0AADoAACAEQR1qIAUgEyAUhEIciKdBP3FqLQAAOgAAIABBIGohACAGQRhqIgYgDU0NAAsMBAsgBCALEKcDAAsgCyACEKYDAAsgBkEaaiAIEKYDAAtBoAhBgAgQpgMACwJAAkACQAJAAkACQAJAAkACQAJAAkAgBiAIIAhBA3AiCmsiCUkEQANAIAZBA2oiBCAISw0CIABB/QdPDQMgB0EIaiAAaiINIAUgBiAMaiIGLQAAIhFBAnZqLQAAOgAAIA1BA2ogBSAGQQJqLQAAIhJBP3FqLQAAOgAAIA1BAWogBSARQQR0IAZBAWotAAAiBkEYdEEcdnJBP3FqLQAAOgAAIA1BAmogBSAGQQJ0IBJBGHRBHnZyQT9xai0AADoAACAAQQRqIQAgBCIGIAlJDQALCwJAAkAgCkF/ag4CAAEMCyAJIAhPDQMgAEGACE8NBCAHQQhqIABqIAUgCSAMai0AACIGQQJ2ai0AADoAACAAQf8HRg0FIABBAWohBCAGQQR0QTBxIQZBAiEIDAoLIAkgCE8NBiAAQYAITw0HIAdBCGogAGogBSAJIAxqLQAAIgRBAnZqLQAAOgAAIAlBAWoiBiAITw0IIABB/wdPDQUgACAHakEJaiAFIARBBHQgBiAMai0AACIGQRh0QRx2ckE/cWotAAA6AAAgAEECaiEEIABB/gdHBEAgBkECdEE8cSEGQQMhCAwKCyAEQYAIQYyOwAAQ0gEACyAGQQNqIAgQpgMACyAAQQRqQYAIEKYDAAsgCSAIQZyNwAAQ0gEACyAAQYAIQayNwAAQ0gEAC0GACEGACEG8jcAAENIBAAtBgAhBgAhB/I3AABDSAQALIAkgCEHMjcAAENIBAAsgAEGACEHcjcAAENIBAAsgBiAIQeyNwAAQ0gEACyAHQQhqIARqIAUgBmotAAA6AAAgACAIaiEACwJAIA9FIAsgAklyDQAgAEGBCEkEQCACIAdBCGogAGpBgAggAGsQ/QEgAGohAAwBCyAAQYAIEKUDAAsgAEGBCE8NAiALIQQgAyAHQQhqIAAQ1gFFDQELCyAHQaAIaiQAIBAPCyAAQYAIEKYDAAtBtIrAAEErIAdBmAhqQeCKwABBnI7AABDEAQALpg4CB38BfiMAQZACayIDJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQBgQQFrDgQBAAMEAgsAC0HwkMAAQSNBoJzAABCkAgALIANByABqIAFBKBCsAxogASABLwFcOwFeIAEQFzYCKCABQShqIgUQwQEgBRDDASADQYwBaiIGQRw2AgAgAyABQd4AajYCiAEgA0EZNgKEASADQeycwAA2AoABIANBxAFqIghBAjYCACADQgM3ArQBIANByJzAADYCsAEgAyADQYABajYCwAEgA0GAAmogA0GwAWoQRiABQTRqIANBiAJqIgkoAgA2AgAgASADKQOAAjcCLCADQbABaiADQcgAakEoEKwDGiADQYABaiADQbABahB8IAMoAoQBIQQgAygCgAENCSADQYgBaiIHKQMAIQogASADQZABaigCADYCRCABQTxqIAo3AgAgASAENgI4IANBgAFqIAQgCkIgiKcQPyADQbgBaiIEIAcpAwA3AwAgAyADKQOAATcDsAEgAUHIAGoiByADQbABahC/ASAGQRo2AgAgAyABQcQAajYCiAEgA0EbNgKEASADIAc2AoABIAhBAjYCACADQgI3ArQBIANBjJ3AADYCsAEgAyADQYABajYCwAEgA0GAAmogA0GwAWoQRiADQfABaiAJKAIAIgY2AgAgAyADKQOAAiIKNwPoASAKpyAGEAIgA0HoAWoQqQIgBCABQdAAaigCADYCACADIAEpAkg3A7ABIAMgA0GwAWoQlgI2AoABIAUgA0GAAWoQsgEgAygCgAEiBEEkTwRAIAQQAAsgA0FAayABKAIsIAFBNGooAgAgBRDwASADKAJEIQQgAygCQA0IIAEgBDYCVCADQThqEPkBIAMoAjhFDQQgASADKAI8NgJYIAEgAUHYAGooAgAgAUHUAGooAgAQDxBLNgJoCyADQTBqIAFB6ABqIgUgAhCRAUEDIQQgAygCMCIGQQJGDQQgAygCNCEEIAUQrAEgBg0GIANBKGogBBD7ASADKAIsIQQgAygCKA0GIAEgBDYCaCADQSBqIAUQ9QEgAygCICEEIAEgAygCJCIFNgJwIAEgBEEARzYCbCAEDQEgASAFEEs2AnQLIANBGGogAUH0AGoiBiACEJEBQQQhBCADKAIYIgJBAkYNAyADKAIcIQUgBhCsASACDQAgA0EQaiAFEPwBIAMoAhQhBSADKAIQRQ0BCyAFIQQgASgCaCICQSRJDQQgAhAADAQLIANBCGogBRAEIAMoAggiAkUEQCADQQA2ArABDAMLIAMgAygCDCIENgK4ASADIAQ2ArQBIAMgAjYCsAEgAyADQbABahC9AiADQbABaiADKAIAIAMoAgQQ7wIgAygCsAFFDQIgA0H4AGoiAiADQbgBaiIEKAIAIgY2AgAgAyADKQOwATcDcCADQYwBakEaNgIAIANBGzYChAEgAyAGNgLoASADIANB6AFqNgKIASADIANB8ABqNgKAASADQcQBakECNgIAIANCAjcCtAEgA0HQncAANgKwASADIANBgAFqNgLAASADQYACaiADQbABahBGIAMoAoACIAMoAogCEAIgA0GAAmoQqQIgA0GwAWogAygCcCACKAIAEI0BAn8CQCADKAKwAUUEQCADQYABaiAEQTAQrAMaQQEhAiADKAKAASIGQQFHDQEgA0GUAWopAgAhCkEAIQIgA0GQAWooAgAMAgsgAyADKQK0ATcDgAIgA0GAAmoQswEhBCADQfAAahCpAiAFQSRPBEAgBRAACyABKAJoIgJBJE8EQCACEAALIAEoAlgiAkEkTwRAIAIQAAsgASgCVCICQSRPBEAgAhAACyABQThqEKkCIAFBLGoQqQIgASgCKCICQSRJDQggAhAADAgLIANBgAJqIAFB6ABqEPQBIANBGzYC/AEgAyADQYACajYC+AEgA0HEAWpBATYCACADQgI3ArQBIANBmJ7AADYCsAEgAyADQfgBajYCwAEgA0HoAWogA0GwAWoQRiADQYACahCpAiADQegBahCWAgshBCADQfAAahCpAiAFQSRPBEAgBRAACyABKAJoIgVBJE8EQCAFEAALIAEoAlgiBUEkTwRAIAUQAAsgASgCVCIFQSRPBEAgBRAACyABQThqEKkCIAFBLGoQqQIgASgCKCIFQSRPBEAgBRAACyAGQQFGDQcgA0GAAWoQ5AEMBwtByJPAAEErQZydwAAQpAIACyAAQQI2AgAgASAEOgBgDAYLQciTwABBK0GsncAAEKQCAAsgASgCWCICQSRPBEAgAhAACyABKAJUIgJBJEkNACACEAALIAFBOGoQqQILIAFBLGoQqQIgASgCKCICQSRJDQAgAhAAC0EBIQILIAAgBDYCBCAAIAI2AgAgAUEBOgBgIABBCGogCjcCAAsgA0GQAmokAAvICgIQfwF+IwBBMGsiCSQAIAACf0Gc/sAAKAIAIgpBAWoiASAKSQRAEIICIAkoAgghBCAJKAIMDAELAkACQAJAAkAgAUGQ/sAAKAIAIgYgBkEBaiIFQQN2QQdsIAZBCEkbIgtBAXZLBEAgASALQQFqIgIgASACSxsiAUEISQ0BIAFB/////wFxIAFHDQJBfyABQQN0QQduQX9qZ3ZBAWohAQwDC0GU/sAAKAIAIQNBACEBA0ACQAJ/IAJBAXEEQCABQQdqIgIgAUkgAiAFT3INAiABQQhqDAELIAEgBUkiCEUNASABIQIgASAIagshASACIANqIgIgAikDACIRQgeIQn+FQoGChIiQoMCAAYMgEUL//v379+/fv/8AhHw3AwBBASECDAELCwJAAkAgBUEITwRAIAMgBWogAykAADcAAAwBCyADQQhqIAMgBRA7IAVFDQELIANBcGohDkEAIQEgAyEIA0ACQCADIAEiBWoiDC0AAEGAAUcNACAOIAVBBHRrIQ8gAyAFQX9zQQR0aiENAkADQCAGIA8QR6ciBHEiByECIAMgB2opAABCgIGChIiQoMCAf4MiEVAEQEEIIQEgByECA0AgASACaiECIAFBCGohASADIAIgBnEiAmopAABCgIGChIiQoMCAf4MiEVANAAsLIAMgEXqnQQN2IAJqIAZxIgFqLAAAQX9KBEAgAykDAEKAgYKEiJCgwIB/g3qnQQN2IQELIAEgB2sgBSAHa3MgBnFBCEkNASADIAFBf3NBBHRqIQIgASADaiIHLQAAIAcgBEEZdiIEOgAAIAFBeGogBnEgA2pBCGogBDoAAEH/AUcEQCACQRBqIQdBcCEBA0AgASAIaiICLQAAIQQgAiABIAdqIgItAAA6AAAgAiAEOgAAIAFBAWoiAiABSSACIQFFDQALDAELCyAMQf8BOgAAIAVBeGogBnEgA2pBCGpB/wE6AAAgAkEIaiANQQhqKQAANwAAIAIgDSkAADcAAAwBCyAMIARBGXYiAToAACAFQXhqIAZxIANqQQhqIAE6AAALIAVBAWohASAIQXBqIQggBSAGRw0ACwtBmP7AACALIAprNgIADAMLQQRBCCABQQRJGyEBDAELEIICIAkoAhAhBCAJKAIUDAILIAlBGGogARBrIAkoAhwhBCAJQSBqKAIAIgEgCSgCGA0BGiAJQSRqKAIAIAFB/wEgBEEJahCtAyEDIAprIQpBlP7AACgCACEHAkAgBUUEQEGY/sAAIAo2AgBBlP7AACADNgIAQZD+wAAgBDYCAAwBCyAHQXBqIQsDQCAHIAhqLAAAQQBOBEAgAyAEIAsgCEEEdGsQR6ciDHEiAmopAABCgIGChIiQoMCAf4MiEVAEQEEIIQEDQCABIAJqIQIgAUEIaiEBIAMgAiAEcSICaikAAEKAgYKEiJCgwIB/gyIRUA0ACwsgAyAReqdBA3YgAmogBHEiAWosAABBf0oEQCADKQMAQoCBgoSIkKDAgH+DeqdBA3YhAQsgASADaiAMQRl2IgI6AAAgAUF4aiAEcSADakEIaiACOgAAIAMgAUF/c0EEdGoiAUEIaiAHIAhBf3NBBHRqIgJBCGopAAA3AAAgASACKQAANwAACyAGIAhGIAhBAWohCEUNAAtBmP7AACAKNgIAQZT+wAAgAzYCAEGQ/sAAIAQ2AgAgBkUNAQsCQCAFIAVB/////wBxRw0AIAYgBUEEdCIEakEJaiIBIARJDQAgAUUNAUEAIARrIQMLIAMgB2oQMQtBgYCAgHgLNgIEIAAgBDYCACAJQTBqJAALrwkBBX8jAEHwAGsiBCQAIAQgAzYCDCAEIAI2AggCQAJAAkAgBAJ/AkAgAUGBAk8EQAJ/QQMgACwAgAJBv39KDQAaQQIgACwA/wFBv39KDQAaIAAsAP4BQb9/SgtB/QFqIgUgAUkNASABIAVHDQMLIAQgATYCFCAEIAA2AhAgBEHc3sAANgIYQQAMAQsgACAFaiwAAEG/f0wNASAEIAU2AhQgBCAANgIQIARBp+jAADYCGEEFCzYCHAJAIAIgAUsiBSADIAFLckUEQAJ/AkACQCACIANNBEACQAJAIAJFDQAgAiABTwRAIAEgAkYNAQwCCyAAIAJqLAAAQUBIDQELIAMhAgsgBCACNgIgIAIgASIDSQRAIAJBAWoiBUEAIAJBfWoiAyADIAJLGyIDSQ0GAkAgAyAFRg0AIAAgBWogACADaiIHayEFIAAgAmoiCCwAAEG/f0oEQCAFQX9qIQYMAQsgAiADRg0AIAhBf2oiAiwAAEG/f0oEQCAFQX5qIQYMAQsgAiAHRg0AIAhBfmoiAiwAAEG/f0oEQCAFQX1qIQYMAQsgAiAHRg0AIAhBfWoiAiwAAEG/f0oEQCAFQXxqIQYMAQsgAiAHRg0AIAVBe2ohBgsgAyAGaiEDCwJAIANFDQAgAyABTwRAIAEgA0YNAQwKCyAAIANqLAAAQb9/TA0JCyABIANGDQcCQCAAIANqIgEsAAAiAEF/TARAIAEtAAFBP3EhBSAAQR9xIQIgAEFfSw0BIAJBBnQgBXIhAgwECyAEIABB/wFxNgIkQQEMBAsgAS0AAkE/cSAFQQZ0ciEFIABBcE8NASAFIAJBDHRyIQIMAgsgBEHkAGpBhwE2AgAgBEHcAGpBhwE2AgAgBEHUAGpBGjYCACAEQcQAakEENgIAIARCBDcCNCAEQZzpwAA2AjAgBEEaNgJMIAQgBEHIAGo2AkAgBCAEQRhqNgJgIAQgBEEQajYCWCAEIARBDGo2AlAgBCAEQQhqNgJIIARBMGpBvOnAABCvAgALIAJBEnRBgIDwAHEgAS0AA0E/cSAFQQZ0cnIiAkGAgMQARg0FCyAEIAI2AiRBASACQYABSQ0AGkECIAJBgBBJDQAaQQNBBCACQYCABEkbCyEBIAQgAzYCKCAEIAEgA2o2AiwgBEHEAGpBBTYCACAEQewAakGHATYCACAEQeQAakGHATYCACAEQdwAakGIATYCACAEQdQAakGJATYCACAEQgU3AjQgBEGQ6sAANgIwIARBGjYCTCAEIARByABqNgJAIAQgBEEYajYCaCAEIARBEGo2AmAgBCAEQShqNgJYIAQgBEEkajYCUCAEIARBIGo2AkggBEEwakG46sAAEK8CAAsgBCACIAMgBRs2AiggBEHEAGpBAzYCACAEQdwAakGHATYCACAEQdQAakGHATYCACAEQgM3AjQgBEHQ6MAANgIwIARBGjYCTCAEIARByABqNgJAIAQgBEEYajYCWCAEIARBEGo2AlAgBCAEQShqNgJIIARBMGpB6OjAABCvAgALIAMgBRCnAwALIAAgAUEAIAUQxQIAC0Hc3sAAQStBzOnAABCkAgALIAAgASADIAEQxQIAC98JAgx/AX5BASEJAkACQCACKAIYIghBIiACQRxqKAIAIgwoAhAiChEAAA0AAkAgAUUEQAwBCyAAIAFqIQ4gACEHAkADQAJ/IAcsAAAiAkF/SgRAIAJB/wFxIQQgB0EBagwBCyAHLQABQT9xIQUgAkEfcSEEIAJBX00EQCAEQQZ0IAVyIQQgB0ECagwBCyAHLQACQT9xIAVBBnRyIQUgAkFwSQRAIAUgBEEMdHIhBCAHQQNqDAELIARBEnRBgIDwAHEgBy0AA0E/cSAFQQZ0cnIiBEGAgMQARg0CIAdBBGoLIQ1BMCEFQQIhAgJAAkACQAJAAkACQAJAAkACQCAEDiMGAQEBAQEBAQECBAEBAwEBAQEBAQEBAQEBAQEBAQEBAQEBBQALIARB3ABGDQQLIAQQU0UEQCAEEH0NBgsgBEEBcmdBAnZBB3OtQoCAgIDQAIQhD0EDIQIgBCEFDAQLQfQAIQUMAwtB8gAhBQwCC0HuACEFDAELIAQhBQsgBiADSQ0BAkAgA0UNACADIAFPBEAgASADRg0BDAMLIAAgA2osAABBQEgNAgsCQCAGRQ0AIAYgAU8EQCABIAZHDQMMAQsgACAGaiwAAEG/f0wNAgsgCCAAIANqIAYgA2sgDCgCDBEDAARAQQEPCwJAIAVBgIDEAEYEQANAIAJBf2ohBUHcACEDQQEhAgJAAkAgBUEBaw4CAQAECwJAAkACQAJAAkAgD0IgiKdB/wFxQQFrDgUEAwIBAAgLIA9C/////49gg0KAgICAwACEIQ9BAyECDAQLIA9C/////49gg0KAgICAMIQhD0EDIQJB9QAhAwwDCyAPQv////+PYINCgICAgCCEIQ9BAyECQfsAIQMMAgtBgIDEACAPpyICQQJ0dkEBcUEwciEDIAIEQCAPQn98Qv////8PgyAPQoCAgIBwg4QhD0EDIQIMAgsgD0L/////j2CDQoCAgIAQhCEPQQMhAgwBCyAPQv////+PYIMhD0EDIQJB/QAhAwsgCCADIAoRAABFDQAMCAsACwNAIAIhC0HcACEDQQEhAgJAAkACQAJAAkAgC0EBaw4DAQQABgsCQAJAAkACQCAPQiCIp0H/AXFBAWsOBQUDAAECCQsgD0L/////j2CDQoCAgIAghCEPQQMhAkH7ACEDDAYLIA9C/////49gg0KAgICAMIQhD0EDIQJB9QAhAwwFCyAPQv////+PYINCgICAgMAAhCEPQQMhAgwEC0EwQdcAIAUgD6ciC0ECdHZBD3EiAkEKSRsgAmohAyALRQ0CIA9Cf3xC/////w+DIA9CgICAgHCDhCEPQQMhAgwDC0EAIQIgBSEDDAILIA9C/////49ggyEPQQMhAkH9ACEDDAELIA9C/////49gg0KAgICAEIQhD0EDIQILIAggAyAKEQAARQ0ACwwGCyAGAn9BASAEQYABSQ0AGkECIARBgBBJDQAaQQNBBCAEQYCABEkbCyICaiEDCyAGIAdrIA1qIQYgDSIHIA5HDQEMAgsLIAAgASADIAYQxQIACyADRQRAQQAhAwwBCyADIAFPBEAgASADRg0BDAMLIAAgA2osAABBv39MDQILIAggACADaiABIANrIAwoAgwRAwANACAIQSIgChEAAA8LIAkPCyAAIAEgAyABEMUCAAuHBwEFfyAAELUDIgAgABCgAyIBELIDIQICQAJAAkAgABChAw0AIAAoAgAhAwJAIAAQjANFBEAgASADaiEBIAAgAxCzAyIAQbCCwQAoAgBHDQEgAigCBEEDcUEDRw0CQaiCwQAgATYCACAAIAEgAhDRAg8LIAEgA2pBEGohAAwCCyADQYACTwRAIAAQZwwBCyAAQQxqKAIAIgQgAEEIaigCACIFRwRAIAUgBDYCDCAEIAU2AggMAQtBmP/AAEGY/8AAKAIAQX4gA0EDdndxNgIACwJAIAIQiAMEQCAAIAEgAhDRAgwBCwJAAkACQEG0gsEAKAIAIAJHBEAgAkGwgsEAKAIARw0BQbCCwQAgADYCAEGogsEAQaiCwQAoAgAgAWoiATYCACAAIAEQ6wIPC0G0gsEAIAA2AgBBrILBAEGsgsEAKAIAIAFqIgE2AgAgACABQQFyNgIEIABBsILBACgCAEYNAQwCCyACEKADIgMgAWohAQJAIANBgAJPBEAgAhBnDAELIAJBDGooAgAiBCACQQhqKAIAIgJHBEAgAiAENgIMIAQgAjYCCAwBC0GY/8AAQZj/wAAoAgBBfiADQQN2d3E2AgALIAAgARDrAiAAQbCCwQAoAgBHDQJBqILBACABNgIADAMLQaiCwQBBADYCAEGwgsEAQQA2AgALQdCCwQAoAgAgAU8NAUGAgHxBCEEIEPACQRRBCBDwAmpBEEEIEPACamtBd3FBfWoiAEEAQRBBCBDwAkECdGsiASABIABLG0UNAUG0gsEAKAIAIgFFDQFBCEEIEPACIQBBFEEIEPACIQJBEEEIEPACIQMCf0EAQayCwQAoAgAiBCADIAIgAEEIa2pqIgNNDQAaQcCCwQAiAiEAAkADQCAAKAIAIAFNBEAgABCOAyABSw0CCyAAKAIIIgANAAtBACEAC0EAIAAQogMNABogAEEMaigCABpBAAwAC0EAEGZrRw0BQayCwQAoAgBB0ILBACgCAE0NAUHQgsEAQX82AgAPCyABQYACSQ0BIAAgARBjQdiCwQBB2ILBACgCAEF/aiIANgIAIAANABBmGg8LDwsgAUEDdiICQQN0QaD/wABqIQECf0GY/8AAKAIAIgNBASACdCICcQRAIAEoAggMAQtBmP/AACACIANyNgIAIAELIQIgASAANgIIIAIgADYCDCAAIAE2AgwgACACNgIIC/8HAQh/AkACQCAAQQNqQXxxIgIgAGsiAyABSyADQQRLcg0AIAEgA2siBkEESQ0AIAZBA3EhB0EAIQECQCADRQ0AIANBA3EhCAJAIAIgAEF/c2pBA0kEQCAAIQIMAQsgA0F8cSEEIAAhAgNAIAEgAiwAAEG/f0pqIAJBAWosAABBv39KaiACQQJqLAAAQb9/SmogAkEDaiwAAEG/f0pqIQEgAkEEaiECIARBfGoiBA0ACwsgCEUNAANAIAEgAiwAAEG/f0pqIQEgAkEBaiECIAhBf2oiCA0ACwsgACADaiEAAkAgB0UNACAAIAZBfHFqIgIsAABBv39KIQUgB0EBRg0AIAUgAiwAAUG/f0pqIQUgB0ECRg0AIAUgAiwAAkG/f0pqIQULIAZBAnYhAyABIAVqIQQDQCAAIQEgA0UNAiADQcABIANBwAFJGyIFQQNxIQYgBUECdCEHAkAgBUH8AXEiCEECdCIARQRAQQAhAgwBCyAAIAFqIQlBACECIAEhAANAIAIgACgCACICQX9zQQd2IAJBBnZyQYGChAhxaiAAQQRqKAIAIgJBf3NBB3YgAkEGdnJBgYKECHFqIABBCGooAgAiAkF/c0EHdiACQQZ2ckGBgoQIcWogAEEMaigCACICQX9zQQd2IAJBBnZyQYGChAhxaiECIAkgAEEQaiIARw0ACwsgASAHaiEAIAMgBWshAyACQQh2Qf+B/AdxIAJB/4H8B3FqQYGABGxBEHYgBGohBCAGRQ0ACyABIAhBAnRqIQAgBkH/////A2oiA0H/////A3EiAUEBaiICQQNxAkAgAUEDSQRAQQAhAgwBCyACQfz///8HcSEBQQAhAgNAIAIgACgCACICQX9zQQd2IAJBBnZyQYGChAhxaiAAQQRqKAIAIgJBf3NBB3YgAkEGdnJBgYKECHFqIABBCGooAgAiAkF/c0EHdiACQQZ2ckGBgoQIcWogAEEMaigCACICQX9zQQd2IAJBBnZyQYGChAhxaiECIABBEGohACABQXxqIgENAAsLBEAgA0GBgICAfGohAQNAIAIgACgCACICQX9zQQd2IAJBBnZyQYGChAhxaiECIABBBGohACABQX9qIgENAAsLIAJBCHZB/4H8B3EgAkH/gfwHcWpBgYAEbEEQdiAEag8LIAFFBEBBAA8LIAFBA3EhAgJAIAFBf2pBA0kEQAwBCyABQXxxIQEDQCAEIAAsAABBv39KaiAAQQFqLAAAQb9/SmogAEECaiwAAEG/f0pqIABBA2osAABBv39KaiEEIABBBGohACABQXxqIgENAAsLIAJFDQADQCAEIAAsAABBv39KaiEEIABBAWohACACQX9qIgINAAsLIAQLiQkCB38BfiMAQdAAayIDJAACfwJ/AkACQAJAAkACQAJAIAEtALYBQQFrDgMDAAIBCwALIAEgASkDeDcDkAEgASABKQKEATcCnAEgAUGYAWogAUGAAWooAgA2AgAgAUGkAWoiBSABQYwBaigCADYCACADQTRqQRo2AgAgA0EbNgIsIAMgAUGQAWoiBjYCKCADIAUoAgA2AhQgAyADQRRqNgIwIANBzABqIgdBAjYCACADQgM3AjwgA0GYn8AANgI4IAMgA0EoajYCSCADQRhqIANBOGoQRiADKAIYIAMoAiAQAiADQRhqEKkCQej9wABB6P3AACkDACIKQgF8NwMAIANBCGogBSgCABCbASADKAIIIQQgAUEANgKwASABQawBaiADKAIMNgIAIAEgBDYCqAEgASgCoAEhCCADIAEoApwBIgQgBSgCACIJQQJ0ajYCNCADIAQ2AjAgAyAINgIsIAMgBDYCKCABQagBaiEFIAkEQANAIAMgBEEEajYCMCADQThqIAQoAgAQSSABKAKwASIEIAEoAqwBRgRAIAUgBBCHAiABKAKwASEECyABKAKoASAEQQR0aiIEIAMpAzg3AwAgBEEIaiADQUBrKQMANwMAIAEgASgCsAFBAWo2ArABIAMoAjAiBCADKAI0Rw0ACwsgA0EoahDJASABQfD9wAAvAQA7AbQBIANBHDYCHCADIAFBtAFqNgIYIAdBATYCACADQgE3AjwgA0HAn8AANgI4IAMgA0EYajYCSCADQShqIANBOGoQRiADKAIoIAMoAjAQAiADQShqEKkCIANBKGogBhDhASABIAo3AwggAUEANgIAIAFBADoAYCABIAMpAyg3AxAgAUEYaiADQTBqKAIANgIAIAEgBSkCADcCHCABQSRqIAVBCGooAgA2AgAgASABLwG0ATsBXAsgA0E4aiABIAIQLSADKAI4IgJBAkcEQCADQUBrKQMAIQogAygCPCEEIAEQpwEgAg0CIAMgCkIgiKciBRAdNgIYIAMgBCAFQQR0IgJqNgI0IAMgBDYCMCADIAo+AiwgAyAENgIoIAVFDQNBACEGIANBOGpBAXIiB0EHaiEIA0AgAyAEQRBqIgU2AjAgBC0AACIJQQpGDQQgByAEQQFqKQAANwAAIAggBEEIaikAADcAACADIAk6ADggA0E4ahBZIQQgA0EYaigCACAGIAQQHiAGQQFqIQYgBSEEIAJBcGoiAg0ACwwDCyABQQM6ALYBQQAMBAtB8JDAAEEjQeyewAAQpAIACyADIAQ2AhQgA0E0akEdNgIAIANBGzYCLCADIAFBkAFqIgY2AiggAyADQRRqNgIwIANBzABqQQI2AgAgA0ICNwI8IANB7J/AADYCOCADIANBKGo2AkggA0EYaiADQThqEEYgAygCGCADKAIgEAMgA0EYahCpAiADKAIUIgJBJE8EQCACEAALQSEMAQsgAUGQAWohBiADQShqEL4BIAMoAhgLIQQgBhCpAiABQQE6ALYBQQELIQEgACAENgIEIAAgAUU2AgAgA0HQAGokAAvyBgEGfwJAAkACQAJAAkAgACgCCCIIQQFHQQAgACgCECIEQQFHG0UEQCAEQQFHDQMgASACaiEHIABBFGooAgAiBg0BIAEhBAwCCyAAKAIYIAEgAiAAQRxqKAIAKAIMEQMAIQMMAwsgASEEA0AgBCIDIAdGDQICfyADQQFqIAMsAAAiBEF/Sg0AGiADQQJqIARBYEkNABogA0EDaiAEQXBJDQAaIARB/wFxQRJ0QYCA8ABxIAMtAANBP3EgAy0AAkE/cUEGdCADLQABQT9xQQx0cnJyQYCAxABGDQMgA0EEagsiBCAFIANraiEFIAZBf2oiBg0ACwsgBCAHRg0AIAQsAAAiA0F/SiADQWBJciADQXBJckUEQCADQf8BcUESdEGAgPAAcSAELQADQT9xIAQtAAJBP3FBBnQgBC0AAUE/cUEMdHJyckGAgMQARg0BCwJAAkAgBUUEQEEAIQQMAQsgBSACTwRAQQAhAyAFIAIiBEYNAQwCC0EAIQMgBSIEIAFqLAAAQUBIDQELIAQhBSABIQMLIAUgAiADGyECIAMgASADGyEBCyAIRQ0BIABBDGooAgAhBwJAIAJBEE8EQCABIAIQMiEEDAELIAJFBEBBACEEDAELIAJBA3EhBQJAIAJBf2pBA0kEQEEAIQQgASEDDAELIAJBfHEhBkEAIQQgASEDA0AgBCADLAAAQb9/SmogA0EBaiwAAEG/f0pqIANBAmosAABBv39KaiADQQNqLAAAQb9/SmohBCADQQRqIQMgBkF8aiIGDQALCyAFRQ0AA0AgBCADLAAAQb9/SmohBCADQQFqIQMgBUF/aiIFDQALCyAHIARLBEBBACEDIAcgBGsiBCEGAkACQAJAQQAgAC0AICIFIAVBA0YbQQNxQQFrDgIAAQILQQAhBiAEIQMMAQsgBEEBdiEDIARBAWpBAXYhBgsgA0EBaiEDIABBHGooAgAhBCAAKAIEIQUgACgCGCEAAkADQCADQX9qIgNFDQEgACAFIAQoAhARAABFDQALQQEPC0EBIQMgBUGAgMQARg0BIAAgASACIAQoAgwRAwANAUEAIQMDQCADIAZGBEBBAA8LIANBAWohAyAAIAUgBCgCEBEAAEUNAAsgA0F/aiAGSQ8LDAELIAMPCyAAKAIYIAEgAiAAQRxqKAIAKAIMEQMAC6MHAQZ/An8gAQRAQStBgIDEACAAKAIAIgFBAXEiBxshCiAFIAdqDAELIAAoAgAhAUEtIQogBUEBagshBwJAIAFBBHFFBEBBACECDAELAkAgA0EQTwRAIAIgAxAyIQYMAQsgA0UEQAwBCyADQQNxIQgCQCADQX9qQQNJBEAgAiEBDAELIANBfHEhCSACIQEDQCAGIAEsAABBv39KaiABQQFqLAAAQb9/SmogAUECaiwAAEG/f0pqIAFBA2osAABBv39KaiEGIAFBBGohASAJQXxqIgkNAAsLIAhFDQADQCAGIAEsAABBv39KaiEGIAFBAWohASAIQX9qIggNAAsLIAYgB2ohBwsCQAJAIAAoAghFBEBBASEBIAAgCiACIAMQkQINAQwCCwJAAkACQAJAIABBDGooAgAiBiAHSwRAIAAtAABBCHENBEEAIQEgBiAHayIGIQdBASAALQAgIgggCEEDRhtBA3FBAWsOAgECAwtBASEBIAAgCiACIAMQkQINBAwFC0EAIQcgBiEBDAELIAZBAXYhASAGQQFqQQF2IQcLIAFBAWohASAAQRxqKAIAIQggACgCBCEGIAAoAhghCQJAA0AgAUF/aiIBRQ0BIAkgBiAIKAIQEQAARQ0AC0EBDwtBASEBIAZBgIDEAEYNASAAIAogAiADEJECDQEgACgCGCAEIAUgACgCHCgCDBEDAA0BIAAoAhwhAiAAKAIYIQBBACEBAn8DQCAHIAEgB0YNARogAUEBaiEBIAAgBiACKAIQEQAARQ0ACyABQX9qCyAHSSEBDAELIAAoAgQhCSAAQTA2AgQgAC0AICELQQEhASAAQQE6ACAgACAKIAIgAxCRAg0AQQAhASAGIAdrIgIhAwJAAkACQEEBIAAtACAiByAHQQNGG0EDcUEBaw4CAAECC0EAIQMgAiEBDAELIAJBAXYhASACQQFqQQF2IQMLIAFBAWohASAAQRxqKAIAIQcgACgCBCECIAAoAhghBgJAA0AgAUF/aiIBRQ0BIAYgAiAHKAIQEQAARQ0AC0EBDwtBASEBIAJBgIDEAEYNACAAKAIYIAQgBSAAKAIcKAIMEQMADQAgACgCHCEBIAAoAhghBEEAIQgCQANAIAMgCEYNASAIQQFqIQggBCACIAEoAhARAABFDQALQQEhASAIQX9qIANJDQELIAAgCzoAICAAIAk2AgRBAA8LIAEPCyAAKAIYIAQgBSAAQRxqKAIAKAIMEQMAC7oHAwV/AX4BfSMAQTBrIgMkACADQf8BOgAPIANBEGogASADQQ9qQQEgAigCICIGEQUAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADLQAQQQRHBEAgAykDECIIp0H/AXFBBkcNAQsgAy0AD0F/ag4KFBACAwQFBgcJCAELIAAgCDcCBAwUCyAAQQU6AAQMEwsgA0F/NgIoIANBEGogASADQShqQQQgBhEFACADLQAQQQRHBEAgAy0AEEEGRw0NCyADKgIoIQlBBCEFQQIhBAwRCyADQn83AyggA0EQaiABIANBKGpBCCAGEQUAIAMtABBBBEcEQCADLQAQQQZHDQsLIAMpAyghCEEIIQVBAyEEDBALIANBfzYCKCADQRBqIAEgA0EoakEEIAYRBQAgAy0AEEEERwRAIAMtABBBBkcNCQsgAyoCKCEJQQQhBEEEIQUMDwsgA0J/NwMoIANBEGogASADQShqQQggBhEFACADLQAQQQRHBEAgAykDECIIp0H/AXFBBkcNBwsgAykDKCEIQQghBUEFIQQMDgsgA0F/NgIoIANBEGogASADQShqQQQgBhEFACADLQAQQQRHBEAgAy0AEEEGRw0FCyADKgIoIQlBBCEFQQYhBAwNCyADQn83AyggA0EQaiABIANBKGpBCCAGEQUAIAMtABBBBEcEQCADKQMQIginQf8BcUEGRw0DCyADKQMoIQhBCCEFQQchBAwMCyADQRBqIAEgAhBMIAMoAhANCCADQRhqKQMAIQggA0EgaigCACEFIAMqAhQhCUEJIQQMCwsgA0EQaiABIAIQwAEgAygCEEUNCSAAIAMpAhQ3AgQMCwsgACAINwIEDAoLIAAgAzUCECADNQIUQiCGhDcCBAwJCyAAIAg3AgQMCAsgACADNQIQIAM1AhRCIIaENwIEDAcLIAAgAzUCECADNQIUQiCGhDcCBAwGCyAAIAM1AhAgAzUCFEIghoQ3AgQMBQsgA0EQaiABIAIQTCADKAIQRQ0BIAAgAykCFDcCBAwECyAAIAMpAhQ3AgQMAwsgA0EYaikDACEIIANBIGooAgAhBSADKgIUIQlBASEEDAELQQghBCADQRhqKAIAIQUgAy0AFCEHCyAAQQA2AgAgAEELaiAHQRB2OgAAIABBCWogBzsAACAAQRhqIAVBAWo2AgAgAEEQaiAINwIAIABBDGogCTgCACAAQQhqIAQ6AAAMAQsgAEEBNgIACyADQTBqJAALgwcBBn8CQAJAAkAgAkEJTwRAIAMgAhBOIgINAUEADwtBACECQYCAfEEIQQgQ8AJBFEEIEPACakEQQQgQ8AJqa0F3cUF9aiIBQQBBEEEIEPACQQJ0ayIFIAUgAUsbIANNDQFBECADQQRqQRBBCBDwAkF7aiADSxtBCBDwAiEFIAAQtQMiASABEKADIgYQsgMhBAJAAkACQAJAAkACQAJAIAEQjANFBEAgBiAFTw0BIARBtILBACgCAEYNAiAEQbCCwQAoAgBGDQMgBBCIAw0HIAQQoAMiByAGaiIIIAVJDQcgCCAFayEGIAdBgAJJDQQgBBBnDAULIAEQoAMhBCAFQYACSQ0GIAQgBUEEak9BACAEIAVrQYGACEkbDQUgASgCACIGIARqQRBqIQcgBUEfakGAgAQQ8AIhBEEAIgVFDQYgBSAGaiIBIAQgBmsiAEFwaiICNgIEIAEgAhCyA0EHNgIEIAEgAEF0ahCyA0EANgIEQbiCwQBBuILBACgCACAEIAdraiIANgIAQdSCwQBB1ILBACgCACICIAUgBSACSxs2AgBBvILBAEG8gsEAKAIAIgIgACACIABLGzYCAAwJCyAGIAVrIgRBEEEIEPACSQ0EIAEgBRCyAyEGIAEgBRDIAiAGIAQQyAIgBiAEEEEMBAtBrILBACgCACAGaiIGIAVNDQQgASAFELIDIQQgASAFEMgCIAQgBiAFayIFQQFyNgIEQayCwQAgBTYCAEG0gsEAIAQ2AgAMAwtBqILBACgCACAGaiIGIAVJDQMCQCAGIAVrIgRBEEEIEPACSQRAIAEgBhDIAkEAIQRBACEGDAELIAEgBRCyAyIGIAQQsgMhByABIAUQyAIgBiAEEOsCIAcgBygCBEF+cTYCBAtBsILBACAGNgIAQaiCwQAgBDYCAAwCCyAEQQxqKAIAIgkgBEEIaigCACIERwRAIAQgCTYCDCAJIAQ2AggMAQtBmP/AAEGY/8AAKAIAQX4gB0EDdndxNgIACyAGQRBBCBDwAk8EQCABIAUQsgMhBCABIAUQyAIgBCAGEMgCIAQgBhBBDAELIAEgCBDIAgsgAQ0DCyADECsiBUUNASAFIAAgAyABEKADQXhBfCABEIwDG2oiASABIANLGxCsAyAAEDEPCyACIAAgAyABIAEgA0sbEKwDGiAAEDELIAIPCyABEIwDGiABELQDC4cGAQh/AkAgAkUNAEEAIAJBeWoiBCAEIAJLGyEJIAFBA2pBfHEgAWshCkEAIQQDQAJAAkACQAJAAkACQAJAAkACQCABIARqLQAAIgdBGHRBGHUiCEEATgRAIAogBGtBA3EgCkF/RnINASAEIAlJDQIMCAtBASEGQQEhAwJAAkACQAJAAkACQAJAAkAgB0GM5sAAai0AAEF+ag4DAAECDgsgBEEBaiIFIAJJDQZBACEDDA0LQQAhAyAEQQFqIgUgAk8NDCABIAVqLAAAIQUgB0GgfmoiA0UNASADQQ1GDQIMAwsgBEEBaiIDIAJPBEBBACEDDAwLIAEgA2osAAAhBQJAAkACQCAHQZB+ag4FAQAAAAIACyAIQQ9qQf8BcUECSwRAQQEhAwwOCyAFQX9MDQlBASEDDA0LIAVB8ABqQf8BcUEwSQ0JDAsLIAVBj39KDQoMCAsgBUFgcUGgf0cNCQwCCyAFQaB/Tg0IDAELAkAgCEEfakH/AXFBDE8EQCAIQX5xQW5HBEBBASEDDAsLIAVBf0wNAUEBIQMMCgsgBUG/f0oNCAwBC0EBIQMgBUFATw0IC0EAIQMgBEECaiIFIAJPDQcgASAFaiwAAEG/f0wNBUEBIQNBAiEGDAcLIAEgBWosAABBv39KDQUMBAsgBEEBaiEEDAcLA0AgASAEaiIDKAIAQYCBgoR4cQ0GIANBBGooAgBBgIGChHhxDQYgBEEIaiIEIAlJDQALDAULQQEhAyAFQUBPDQMLIARBAmoiAyACTwRAQQAhAwwDCyABIANqLAAAQb9/SgRAQQIhBkEBIQMMAwtBACEDIARBA2oiBSACTw0CIAEgBWosAABBv39MDQBBAyEGQQEhAwwCCyAFQQFqIQQMAwtBASEDCyAAIAQ2AgQgAEEJaiAGOgAAIABBCGogAzoAACAAQQE2AgAPCyAEIAJPDQADQCABIARqLAAAQQBIDQEgAiAEQQFqIgRHDQALDAILIAQgAkkNAAsLIAAgATYCBCAAQQhqIAI2AgAgAEEANgIAC90FAQl/AkAgAgRAIAAoAgQhCCAAKAIAIQkgACgCCCEHA0ACQCAHLQAARQ0AIAlB/OHAAEEEIAgoAgwRAwBFDQBBAQ8LQQAhBiACIQMCQANAAkAgASAGaiEEAkACQAJAAkAgA0EITwRAIARBA2pBfHEgBGsiAEUEQCADQXhqIQpBACEFDAMLIAMgACAAIANLGyEFQQAhAANAIAAgBGotAABBCkYNBSAAQQFqIgAgBUcNAAsMAQsgA0UNBEEAIQAgBC0AAEEKRg0DIANBAUYNBEEBIQAgBC0AAUEKRg0DIANBAkYNBEECIQAgBC0AAkEKRg0DIANBA0YNBEEDIQAgBC0AA0EKRg0DIANBBEYNBEEEIQAgBC0ABEEKRg0DIANBBUYNBEEFIQAgBC0ABUEKRg0DIANBBkYNBEEGIQAgBC0ABkEKRw0EDAMLIAUgA0F4aiIKSw0BCwNAAkAgBCAFaiILKAIAIgBBf3MgAEGKlKjQAHNB//37d2pxQYCBgoR4cQ0AIAtBBGooAgAiAEF/cyAAQYqUqNAAc0H//ft3anFBgIGChHhxDQAgBUEIaiIFIApNDQELCyAFIANNDQAgBSADEKUDAAsgAyAFRg0BIAUgA2shAyAEIAVqIQRBACEAA0AgACAEai0AAEEKRwRAIAMgAEEBaiIAag0BDAMLCyAAIAVqIQALAkAgACAGaiIAQQFqIgYgAEkgAiAGSXINACAAIAFqLQAAQQpHDQAgB0EBOgAAAkAgAiAGTQRAIAYgAiIARg0FDAELIAEgBmosAABBv39MDQAgBiEADAQLIAEgAkEAIAYQxQIACyACIAZrIQMgAiAGTw0BCwsgB0EAOgAAIAIhAAsgCSABIAAgCCgCDBEDAARAQQEPCwJAIAIgAE0EQCAAIAJGDQEMBAsgACABaiwAAEG/f0wNAwsgACABaiEBIAIgAGsiAg0ACwtBAA8LIAEgAiAAIAIQxQIAC5wGAgR/AX4jAEEwayIEJAAgBCABLQAAIgZBAWo6AAggBEEgaiACIARBCGpBASADKAIMIgURBQACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBCgCIEUEQCAEKAIkIQcgBkEBaw4JAgMEBQYHCAkKAQsgBCkCJCEIIABBATYCACAAIAg3AgQMCwsgBEIANwMIDAkLIARBCGogAUEEaiACIAMQsAEMCAsgBCABQQRqKAIANgIYIARBIGogAiAEQRhqQQQgBREFACAEAn8gBCgCIEUEQCAEIAQoAiQ2AgxBAAwBCyAEIAQpAiQ3AgxBAQs2AggMBwsgBCABQQhqKwMAOQMYIARBIGogAiAEQRhqQQggBREFACAEAn8gBCgCIEUEQCAEIAQoAiQ2AgxBAAwBCyAEIAQpAiQ3AgxBAQs2AggMBgsgBCABQQRqKAIANgIYIARBIGogAiAEQRhqQQQgBREFACAEAn8gBCgCIEUEQCAEIAQoAiQ2AgxBAAwBCyAEIAQpAiQ3AgxBAQs2AggMBQsgBCABQQhqKQMANwMYIARBIGogAiAEQRhqQQggBREFACAEAn8gBCgCIEUEQCAEIAQoAiQ2AgxBAAwBCyAEIAQpAiQ3AgxBAQs2AggMBAsgBCABQQRqKAIANgIYIARBIGogAiAEQRhqQQQgBREFACAEAn8gBCgCIEUEQCAEIAQoAiQ2AgxBAAwBCyAEIAQpAiQ3AgxBAQs2AggMAwsgBCABQQhqKQMANwMYIARBIGogAiAEQRhqQQggBREFACAEAn8gBCgCIEUEQCAEIAQoAiQ2AgxBAAwBCyAEIAQpAiQ3AgxBAQs2AggMAgsgBCABLQABOgAYQQEhASAEQSBqIAIgBEEYakEBIAURBQACQCAEKAIgRQRAIAQgBCgCJDYCDEEAIQEMAQsgBCAEKQIkNwIMCyAEIAE2AggMAQsgBEEIaiABQQRqIAIgAxCwAQsgBCgCCEUEQCAEKAIMIQEgAEEANgIAIAAgASAHajYCBAwBCyAEKQIMIQggAEEBNgIAIAAgCDcCBAsgBEEwaiQAC5IFAQd/AkACQAJ/AkAgACABayACSQRAIAEgAmohBSAAIAJqIQMgAkEPSw0BIAAMAgsgAkEPTQRAIAAhAwwDCyAAQQAgAGtBA3EiBWohBCAFBEAgACEDIAEhAANAIAMgAC0AADoAACAAQQFqIQAgA0EBaiIDIARJDQALCyAEIAIgBWsiAkF8cSIGaiEDAkAgASAFaiIFQQNxIgAEQCAGQQFIDQEgBUF8cSIHQQRqIQFBACAAQQN0IghrQRhxIQkgBygCACEAA0AgBCAAIAh2IAEoAgAiACAJdHI2AgAgAUEEaiEBIARBBGoiBCADSQ0ACwwBCyAGQQFIDQAgBSEBA0AgBCABKAIANgIAIAFBBGohASAEQQRqIgQgA0kNAAsLIAJBA3EhAiAFIAZqIQEMAgsgA0F8cSEAQQAgA0EDcSIGayEHIAYEQCABIAJqQX9qIQQDQCADQX9qIgMgBC0AADoAACAEQX9qIQQgACADSQ0ACwsgACACIAZrIgZBfHEiAmshA0EAIAJrIQICQCAFIAdqIgVBA3EiBARAIAJBf0oNASAFQXxxIgdBfGohAUEAIARBA3QiCGtBGHEhCSAHKAIAIQQDQCAAQXxqIgAgBCAJdCABKAIAIgQgCHZyNgIAIAFBfGohASAAIANLDQALDAELIAJBf0oNACABIAZqQXxqIQEDQCAAQXxqIgAgASgCADYCACABQXxqIQEgACADSw0ACwsgBkEDcSIARQ0CIAIgBWohBSADIABrCyEAIAVBf2ohAQNAIANBf2oiAyABLQAAOgAAIAFBf2ohASAAIANJDQALDAELIAJFDQAgAiADaiEAA0AgAyABLQAAOgAAIAFBAWohASADQQFqIgMgAEkNAAsLC+gEAgR/Bn4gACAAKAI4IAJqNgI4AkAgAAJ/AkACQAJAIAAoAjwiBUUEQAwBCwJ+QQggBWsiBCACIAQgAkkbIgZBA00EQEIADAELQQQhAyABNQAACyEHIAAgACkDMCADQQFyIAZJBEAgASADajMAACADQQN0rYYgB4QhByADQQJyIQMLIAMgBkkEfiABIANqMQAAIANBA3SthiAHhAUgBwsgBUEDdEE4ca2GhCIHNwMwIAQgAksNASAAQSBqIgMgAEEoaiIFKQMAIAeFIgggAEEYaiIGKQMAfCIKIAMpAwAiCUINiSAJIAApAxB8IgmFIgt8IgwgC0IRiYU3AwAgBiAMQiCJNwMAIAUgCiAIQhCJhSIIQhWJIAggCUIgiXwiCIU3AwAgACAHIAiFNwMQCyACIARrIgJBB3EhAyAEIAJBeHEiAkkEQCAAQRhqKQMAIQggAEEgaikDACEHIABBKGopAwAhCiAAKQMQIQkDQCAIIAEgBGopAAAiCyAKhSIIfCIKIAcgCXwiCSAHQg2JhSIHfCIMIAdCEYmFIQcgCEIQiSAKhSIIQhWJIAggCUIgiXwiCYUhCiAMQiCJIQggCSALhSEJIARBCGoiBCACSQ0ACyAAIAc3AyAgACAJNwMQIAAgCjcDKCAAIAg3AxgLIANBA0sNAUIAIQdBAAwCCyACIAVqIQMMAgsgASAEajUAACEHQQQLIgJBAXIgA0kEQCABIAIgBGpqMwAAIAJBA3SthiAHhCEHIAJBAnIhAgsgAiADSQR+IAEgAiAEamoxAAAgAkEDdK2GIAeEBSAHCzcDMAsgACADNgI8C58FAgZ/AX4jAEHQAGsiAyQAIANB/wE6AAcgA0EgaiABIANBB2pBASACKAIgEQUAAkACQAJAAkACQAJAAkACQCADLQAgQQRHBEAgAykDICIJp0H/AXFBBkcNAQtBAiEEAkACQAJAAkACQAJAAkACQCADLQAHQX9qDggHBg4ABQECBAMLQQMhBAwMC0EFIQQMCwsgAEEFOgAEDAkLIABBBToABAwICyADQSBqIAEgAhBPIAMpAiQhCSADKAIgBEAgACAJNwIEDAgLIAlCIIinIQYgA0EwaigCACEFIANBLGooAgAhByAJpyEIQQchBAwJCyADQSBqIAEgAhBMIAMpAiQhCSADKAIgRQ0FIAAgCTcCBAwGCyADQSBqIAEgAhCLASADKAIgRQ0DIAAgAykCJDcCBAwFCyADQSBqIAEgAhBgIAMoAiBFDQEgACADKQIkNwIEDAQLIABBATYCACAAIAk3AgQMBgsgA0EQaiADQThqKQMANwMAIANBGGogA0FAaykDADcDACADIANBMGopAwA3AwggA0EsaigCACEHIANBKGooAgAhBiADQcgAaigCACEFQQAhBAwECyADQRBqIANBOGopAwA3AwAgAyADQTBqKQMANwMIIANBLGooAgAhByADQShqKAIAIQYgA0FAaygCACEFQQEhBAwDCyAJQiCIpyEGIANBMGooAgAhBSADQSxqKAIAIQcgCachCEEEIQQMAgsgAEEBNgIADAILCyAAQQA2AgAgAEEYaiADKQMINwIAIABBMGogBUEBajYCACAAQRRqIAc2AgAgAEEQaiAGNgIAIABBDGogCDYCACAAQQhqIAQ2AgAgAEEoaiADQRhqKQMANwIAIABBIGogA0EQaikDADcCAAsgA0HQAGokAAuABQEKfyMAQTBrIgMkACADQSRqIAE2AgAgA0EDOgAoIANCgICAgIAENwMIIAMgADYCICADQQA2AhggA0EANgIQAkACQAJAIAIoAggiCkUEQCACQRRqKAIAIgRFDQEgAigCACEBIAIoAhAhACAEQX9qQf////8BcUEBaiIHIQQDQCABQQRqKAIAIgUEQCADKAIgIAEoAgAgBSADKAIkKAIMEQMADQQLIAAoAgAgA0EIaiAAQQRqKAIAEQAADQMgAEEIaiEAIAFBCGohASAEQX9qIgQNAAsMAQsgAkEMaigCACIARQ0AIABBBXQhCyAAQX9qQf///z9xQQFqIQcgAigCACEBA0AgAUEEaigCACIABEAgAygCICABKAIAIAAgAygCJCgCDBEDAA0DCyADIAQgCmoiBUEcai0AADoAKCADIAVBBGopAgBCIIk3AwggBUEYaigCACEGIAIoAhAhCEEAIQlBACEAAkACQAJAIAVBFGooAgBBAWsOAgACAQsgBkEDdCAIaiIMKAIEQYoBRw0BIAwoAgAoAgAhBgtBASEACyADIAY2AhQgAyAANgIQIAVBEGooAgAhAAJAAkACQCAFQQxqKAIAQQFrDgIAAgELIABBA3QgCGoiBigCBEGKAUcNASAGKAIAKAIAIQALQQEhCQsgAyAANgIcIAMgCTYCGCAIIAUoAgBBA3RqIgAoAgAgA0EIaiAAKAIEEQAADQIgAUEIaiEBIAsgBEEgaiIERw0ACwtBACEAIAcgAigCBEkiAUUNASADKAIgIAIoAgAgB0EDdGpBACABGyIBKAIAIAEoAgQgAygCJCgCDBEDAEUNAQtBASEACyADQTBqJAAgAAvfBAEGfyMAQUBqIgMkACADQQhqIAEgAhCDAyADIAMoAgggAygCDBCDAyADIAMpAwA3AxAgA0EwaiADQRBqEEICQAJAAkACQAJAIAMoAjAiBgRAIAMoAjQhASADQTxqKAIADQIgACAGNgIEDAELIABBpN3AADYCBEEAIQELIABBADYCACAAQQhqIAE2AgAMAQsCQCACRQRAQQEhBQwBCyACQX9MDQMgAkEBEIEDIgVFDQILIANBADYCICADIAU2AhggAyACNgIcIAEgAksEQCADQRhqQQAgARCEASADKAIYIQUgAygCICEECyAEIAVqIAYgARCsAxogAyABIARqIgI2AiAgAygCHCACa0ECTQRAIANBGGogAkEDEIQBIAMoAiAhAgsgAygCGCIEIAJqIgFB2N7AAC8AACIGOwAAIAFBAmpB2t7AAC0AACIHOgAAIAMgAkEDaiICNgIgIAMgAykDEDcDKCADQTBqIANBKGoQQiADKAIwIgUEQANAIAMoAjwgAygCHCACayADKAI0IgFJBEAgA0EYaiACIAEQhAEgAygCGCEEIAMoAiAhAgsgAiAEaiAFIAEQrAMaIAMgASACaiICNgIgBEAgAygCHCACa0ECTQRAIANBGGogAkEDEIQBIAMoAiAhAgsgAygCGCIEIAJqIgEgBjsAACABQQJqIAc6AAAgAyACQQNqIgI2AiALIANBMGogA0EoahBCIAMoAjAiBQ0ACwsgACADKQMYNwIEIABBATYCACAAQQxqIANBIGooAgA2AgALIANBQGskAA8LIAJBARCkAwALEK4CAAukBQEFfyMAQSBrIgAkAAJAAkACQAJAAkACQAJAQdyCwQAoAgBFBEBB3ILBAEF/NgIAQeCCwQAoAgAiAUUEQEHggsEAIAEQdCIBNgIACyABIAEoAgAiAkEBajYCACACQX9MDQFB3ILBAEHcgsEAKAIAQQFqNgIAIAFFDQIgAUEAIAEoAhgiAiACQQJGIgIbNgIYIAAgATYCACACRQRAIAEtABwhAiABQQE6ABwgACACQQFxIgI6AAQgAg0EIAFBHGohAkH4/sAAKAIAQf////8HcQRAELEDQQFzIQQLIAItAAENBSABIAEoAhgiA0EBIAMbNgIYIANFDQggA0ECRw0GIAEoAhghAyABQQA2AhggACADNgIEIANBAkcNBwJAIAQNAEH4/sAAKAIAQf////8HcUUNABCxAw0AIAJBAToAAQsgAkEAOgAACyAAKAIAIgEgASgCACIBQX9qNgIAIAFBAUYEQCAAEOsBCyAAQSBqJAAPC0HwxsAAQRAgAEEIakGAx8AAQdjRwAAQxAEACwALQebHwABB3gBB5MjAABCSAwALIABBHGpBADYCACAAQRhqQfDGwAA2AgAgAEIBNwIMIABBuNXAADYCCCAAQQRqIABBCGoQ2AEACyAAIAQ6AAwgACACNgIIQazGwABBKyAAQQhqQYjWwABBzNbAABDEAQALIABBHGpBADYCACAAQfDGwAA2AhggAEIBNwIMIABB9NbAADYCCCAAQQhqQfzWwAAQrwIACyAAQRxqQQA2AgAgAEEYakHwxsAANgIAIABCATcCDCAAQazXwAA2AgggAEEEaiAAQQhqQbTXwAAQ2QEACyAAQRxqQQA2AgAgAEHwxsAANgIYIABCATcCDCAAQcTUwAA2AgggAEEIakGE1cAAEK8CAAvXBAEEfyAAIAEQsgMhAgJAAkACQCAAEKEDDQAgACgCACEDAkAgABCMA0UEQCABIANqIQEgACADELMDIgBBsILBACgCAEcNASACKAIEQQNxQQNHDQJBqILBACABNgIAIAAgASACENECDwsgASADakEQaiEADAILIANBgAJPBEAgABBnDAELIABBDGooAgAiBCAAQQhqKAIAIgVHBEAgBSAENgIMIAQgBTYCCAwBC0GY/8AAQZj/wAAoAgBBfiADQQN2d3E2AgALIAIQiAMEQCAAIAEgAhDRAgwCCwJAQbSCwQAoAgAgAkcEQCACQbCCwQAoAgBHDQFBsILBACAANgIAQaiCwQBBqILBACgCACABaiIBNgIAIAAgARDrAg8LQbSCwQAgADYCAEGsgsEAQayCwQAoAgAgAWoiATYCACAAIAFBAXI2AgQgAEGwgsEAKAIARw0BQaiCwQBBADYCAEGwgsEAQQA2AgAPCyACEKADIgMgAWohAQJAIANBgAJPBEAgAhBnDAELIAJBDGooAgAiBCACQQhqKAIAIgJHBEAgAiAENgIMIAQgAjYCCAwBC0GY/8AAQZj/wAAoAgBBfiADQQN2d3E2AgALIAAgARDrAiAAQbCCwQAoAgBHDQFBqILBACABNgIACw8LIAFBgAJPBEAgACABEGMPCyABQQN2IgJBA3RBoP/AAGohAQJ/QZj/wAAoAgAiA0EBIAJ0IgJxBEAgASgCCAwBC0GY/8AAIAIgA3I2AgAgAQshAiABIAA2AgggAiAANgIMIAAgATYCDCAAIAI2AggLngQBB38gASgCBCIGBEAgASgCACEEA0ACQCADQQFqIQICfyACIAMgBGotAAAiB0EYdEEYdSIIQQBODQAaAkACQAJAAkACQAJAAkAgB0GM5sAAai0AAEF+ag4DAAECCAsgAiAEakGt38AAIAIgBkkbLQAAQcABcUGAAUcNByADQQJqDAYLIAIgBGpBrd/AACACIAZJGywAACEFIAdBoH5qIgdFDQEgB0ENRg0CDAMLIAIgBGpBrd/AACACIAZJGywAACEFAkACQAJAAkAgB0GQfmoOBQEAAAACAAsgBUF/SiAIQQ9qQf8BcUECS3IgBUFAT3INCAwCCyAFQfAAakH/AXFBME8NBwwBCyAFQY9/Sg0GCyAEIANBAmoiAmpBrd/AACACIAZJGy0AAEHAAXFBgAFHDQUgBCADQQNqIgJqQa3fwAAgAiAGSRstAABBwAFxQYABRw0FIANBBGoMBAsgBUFgcUGgf0cNBAwCCyAFQaB/Tg0DDAELIAhBH2pB/wFxQQxPBEAgCEF+cUFuRyAFQX9KciAFQUBPcg0DDAELIAVBv39KDQILIAQgA0ECaiICakGt38AAIAIgBkkbLQAAQcABcUGAAUcNASADQQNqCyIDIgIgBkkNAQsLIAAgAzYCBCAAIAQ2AgAgASAGIAJrNgIEIAEgAiAEajYCACAAQQxqIAIgA2s2AgAgAEEIaiADIARqNgIADwsgAEEANgIAC/kDAQd/IwBBIGsiCCQAAkACQAJAAkAgA0UEQAwBCyACQQRqIQQgA0F/akH/////AXFBAWohBgJAA0AgBCgCAA0BIARBCGohBCAGIAVBAWoiBUcNAAsgBiEFCyAFIANLDQELIAMgBWsiCUUNASACIAVBA3RqIQcDQCAHIAlBA3QiAmohBkEAIQUgB0EEaiIDIQQDQCAEKAIAIAVqIQUgBEEIaiEEIAJBeGoiAg0ACyABIAUQ1AIgByEEA0AgASAEKAIAIARBBGooAgAQhAMgBEEIaiIEIAZHDQALIAVFBEAgAEECNgIAIABBBGpByJHAADYCAAwECyAJQX9qQf////8BcUEBaiEKQQAhBEEAIQICQANAIAMoAgAgAmoiBiAFSw0BIANBCGohAyAGIQIgCiAEQQFqIgRHDQALIAohBAsgCSAETwRAAkACQCAJIARrIglFBEAgAiAFRw0BDAYLIAcgBEEDdCIEaiIGKAIEIgMgBSACayICTw0BIAIgAxClAwALIAhBHGpBADYCACAIQYiSwAA2AhggCEIBNwIMIAhBnJPAADYCCCAIQQhqQaSTwAAQrwIACyAGQQRqIAMgAms2AgAgBCAHaiIHIAcoAgAgAmo2AgAMAQsLIAQgCRClAwALIAUgAxClAwALIABBBDoAAAsgCEEgaiQAC44EAQp/IwBBQGoiAyQAIAIoAgQhCCACKAIIIQcgA0E4aiEJIANBMGohCiADQShqIQsDQCACKAIIIgQgAigCBCIGRgRAIAJBIBDUAiACKAIEIQYgAigCCCEECyADIAU2AhQgA0EANgIQIAMgBiAEazYCDCADIAIoAgAgBGo2AgggA0EYaiABIANBCGoQpQECQAJAAkACQAJAIAMtABgiBEEERgRAIAMoAhAiBg0BIABBADYCACAAIAIoAgggB2s2AgQMBQsCfwJAAkACQAJAIARBAWsOAwECAwALIAMoAhwaQSgMAwsgAy0AGQwCCyADKAIcLQAIDAELIAMoAhwtAAgLQf8BcUEjRg0BIAAgAykDGDcCBCAAQQE2AgAMBAsgAiACKAIIIAZqIgQ2AgggAygCFCEMIAQgAigCBCIFRyAFIAhHcg0CIAlCADcDACAKQgA3AwAgC0IANwMAIANCADcDICADIAEQgQIgAygCACEFIAMoAgQiBEEgIARBIEkbIgRBAUYEQCAFLQAAIQUgASABKQMAIAStfDcDACADIAU6ACAMAgsgA0EgaiAFIAQQrAMaIAEgASkDACAErXw3AwAgBA0BIABBADYCACAAIAIoAgggB2s2AgQMAwsgAyADKQMYNwMgIANBIGoQhAIMAwsgAiADQSBqIAQQhAMLIAwgBmshBQwBCwsgA0FAayQAC9YEAQV/IwBBIGsiASQAIAFBAnIhBUGk/sAAKAIAIQIDQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAg4EAAIBBAELQaT+wABBAkGk/sAAKAIAIgMgAiADRiIEGzYCACAEDQIgAyECDAoLIAJBA3FBAkYEQANAQdyCwQAoAgANBUHcgsEAQX82AgBB4ILBACgCACIERQRAQeCCwQAgAhB0IgQ2AgALIAQgBCgCACIDQQFqNgIAIANBf0wNBkHcgsEAQdyCwQAoAgBBAWo2AgAgBEUNByACIQNBpP7AACAFQaT+wAAoAgAiAiACIANGGzYCACABQQA6AAggASAENgIAIAEgA0F8cTYCBCACIANGBEAgAS0ACEUNCQwKCwJAIAEoAgAiA0UNACADIAMoAgAiA0F/ajYCACADQQFHDQAgARDrAQsgAkEDcUECRg0ADAoLAAtBjNDAAEHAAEGkgcAAEKQCAAsgAUEUakEANgIAIAFB8MbAADYCECABQgE3AgQgAUH40MAANgIAIAFBpIHAABCvAgALIAFBpP7AADYCGCABQQM2AgAgASACQQFGOgAEIAAgAUHEk8AAKAIAEQEAIAEgASgCADYCHCABQRhqEIwBCyABQSBqJAAPC0HwxsAAQRAgAUEYakGAx8AAQdjRwAAQxAEACwALQebHwABB3gBB5MjAABCSAwALA0AQQCABLQAIRQ0ACwsgASgCACICRQ0AIAIgAigCACICQX9qNgIAIAJBAUcNACABEOsBQaT+wAAoAgAhAgwBC0Gk/sAAKAIAIQIMAAsAC+EDAQh/IwBBMGsiBCQAIAFBFGooAgAhCSABKAIAIQUCQCABQQRqKAIAIgdBA3RFBEAMAQsgB0F/akH/////AXEiAkEBaiIDQQdxIQYCfyACQQdJBEBBACEDIAUMAQsgBUE8aiECIANB+P///wNxIQhBACEDA0AgAigCACACQXhqKAIAIAJBcGooAgAgAkFoaigCACACQWBqKAIAIAJBWGooAgAgAkFQaigCACACQUhqKAIAIANqampqampqaiEDIAJBQGshAiAIQXhqIggNAAsgAkFEagsgBkUNAEEEaiECA0AgAigCACADaiEDIAJBCGohAiAGQX9qIgYNAAsLAkACQAJAIAlFBEAgAyECDAELAkAgB0UNACAFKAIEDQAgA0EQSQ0CCyADIANqIgIgA0kNAQsgAkUNAAJAIAJBf0oEQCACQQEQgQMiA0UNAQwDCxCuAgALIAJBARCkAwALQQEhA0EAIQILIABBADYCCCAAIAI2AgQgACADNgIAIAQgADYCDCAEQSBqIAFBEGopAgA3AwAgBEEYaiABQQhqKQIANwMAIAQgASkCADcDECAEQQxqQYzdwAAgBEEQahA+BEBB7N3AAEEzIARBKGpBoN7AAEHI3sAAEMQBAAsgBEEwaiQAC+MDAgV/Bn4jAEHQAGsiASQAIAFBQGsiAkIANwMAIAFBMGoiA0GI/sAAKQMAIgZC88rRy6eM2bL0AIU3AwAgAUEoaiIEIAZC7d6R85bM3LfkAIU3AwAgAUEgaiIFQYD+wAApAwAiB0Lh5JXz1uzZvOwAhTcDACABQgA3AzggASAGNwMQIAEgBzcDCCABIAdC9crNg9es27fzAIU3AxggAUEIaiAAKAIAIAAoAggQPCABQf8BOgBPIAFBCGogAUHPAGpBARA8IAI1AgAhByABKQM4IQggAykDACAFKQMAIQogBCkDACEGIAEpAxghCyABQdAAaiQAIAggB0I4hoQiB4UiCEIQiSAIIAp8IgiFIgkgBiALfCIKQiCJfCILIAeFIAggBkINiSAKhSIGfCIHIAZCEYmFIgZ8IgggBkINiYUiBiAJQhWJIAuFIgkgB0IgiUL/AYV8Igd8IgogBkIRiYUiBkINiSAGIAlCEIkgB4UiByAIQiCJfCIIfCIGhSIJQhGJIAkgB0IViSAIhSIHIApCIIl8Igh8IgmFIgpCDYkgCiAHQhCJIAiFIgcgBkIgiXwiBnyFIgggB0IViSAGhSIGIAlCIIl8Igd8IgkgBkIQiSAHhUIViYUgCEIRiYUgCUIgiYUL8AMCCH8BfiMAQdAAayIDJAAgA0F/NgIMIANBMGogASADQQxqQQQgAigCIBEFAAJAAkACQCADLQAwQQRHBEAgAykDMCILp0H/AXFBBkcNAQsgAyADKAIMIgUQmwEgA0EANgIYIAMgAykDADcDECAFRQRAQQQhBgwCCyADQTxqIQdBBCEGA0ACQCADQTBqIAEgAhA2IAMoAjANACADQShqIAdBCGooAgAiBDYCACADIAcpAgAiCzcDICADKAI4IQggAygCSCEJIANBOGoiCiAENgIAIAMgCzcDMCADKAIYIgQgAygCFEYEQCADQRBqIAQQhwIgAygCGCEECyAGIAlqIQYgAygCECAEQQR0aiIEIAMpAzA3AgQgBCAINgIAIARBDGogCigCADYCACADIAMoAhhBAWo2AhggBUF/aiIFDQEMAwsLIAMpAjQhCyAAQQE2AgAgACALNwIEIAMoAhgiAARAIAMoAhAhBCAAQQR0IQUDQCAELQAAIgBBfmpBB0kgAEVyRQRAIARBBGoQqQILIARBEGohBCAFQXBqIgUNAAsLIANBEGoQsQIMAgsgAEEBNgIAIAAgCzcCBAwBCyAAIAMpAxA3AgQgAEEANgIAIABBEGogBjYCACAAQQxqIANBGGooAgA2AgALIANB0ABqJAAL3AMDA38BfgF8IwBB4ABrIgIkACACIAE2AiwCQAJAQQFBAiABEAciA0EBRhtBACADGyIDQQJHBEAgAEEIOgAAIAAgAzoAAQwBCyACQRhqIAEQCCACKAIYBEAgAisDICEGIABBAzoAACAAQQhqIAY5AwAMAQsgAkEQaiABEAQCQCACKAIQIgNFBEAgAkEANgIwDAELIAIgAigCFCIENgJYIAIgBDYCVCACIAM2AlAgAkEIaiACQdAAahC9AiACQTBqIAIoAgggAigCDBDvAiACKAIwRQ0AIABBAToAACAAQQRqIAIpAzA3AgAgAEEMaiACQThqKAIANgIADAELAkACQAJAAkAgARAJQQFGDQAgARAKQQFGDQAgAiACQSxqEJ0CIAIoAgQhASACKAIARQ0BIABBADoAACABQSRPDQIMAwsgAEEAOgAADAILIAIgATYCPCACQdAAaiACQTxqENUBIAIoAlBFDQMgAkHIAGogAkHYAGooAgAiAzYCACACIAIpA1AiBTcDQCAAQQxqIAM2AgAgAEEEaiAFNwIAIABBCToAACABQSRJDQELIAEQAAsgAigCLCEBCyABQSRPBEAgARAACyACQeAAaiQADwtByJPAAEErQcSewAAQpAIAC6sEAgV/AX5BASEDAkAgASgCGCIEQScgAUEcaigCACgCECIFEQAADQBBAiEBQTAhAgJAAn4CQAJAAkACQAJAAkACQCAAKAIAIgAOKAgBAQEBAQEBAQIEAQEDAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQUACyAAQdwARg0ECyAAEFNFDQQgAEEBcmdBAnZBB3OtQoCAgIDQAIQMBQtB9AAhAgwFC0HyACECDAQLQe4AIQIMAwsgACECDAILIAAQfQRAQQEhASAAIQIMAgsgAEEBcmdBAnZBB3OtQoCAgIDQAIQLIQdBAyEBIAAhAgsDQCABIQZBACEBIAIhAAJAAkACQAJAAkAgBkEBaw4DBAIAAQsCQAJAAkACQAJAIAdCIIinQf8BcUEBaw4FAAQBAgMFCyAHQv////+PYIMhB0H9ACEAQQMhAQwHCyAHQv////+PYINCgICAgCCEIQdB+wAhAEEDIQEMBgsgB0L/////j2CDQoCAgIAwhCEHQfUAIQBBAyEBDAULIAdC/////49gg0KAgICAwACEIQdB3AAhAEEDIQEMBAtBMEHXACACIAenIgFBAnR2QQ9xIgBBCkkbIABqIQAgAUUNAiAHQn98Qv////8PgyAHQoCAgIBwg4QhB0EDIQEMAwsgBEEnIAURAAAhAwwEC0HcACEAQQEhAQwBCyAHQv////+PYINCgICAgBCEIQdBAyEBCyAEIAAgBREAAEUNAAsLIAML3gMBA38jAEGAAWsiASQAIAEgADYCFCABQTBqQQA2AgAgAUEoakEANgIAIAFCgICAgCA3AxggAUEYahC1AiIAIAAoAgAiAkEBaiIDNgIAAkACQCADIAJJDQAgAUEIaiAAEMECIAEoAggiAkGQwMAAEJ0DIQMgAUHQAGpBkMDAADYCACABIAI2AkwgASADNgJIIAAgACgCACICQQFqIgM2AgAgAyACSQ0AIAEgABDCAiABKAIAIgJBpMDAABCdAyEDIAFB4ABqQaTAwAA2AgAgASACNgJcIAEgAzYCWCABQRRqKAIAIAFByABqKAIAIAFB2ABqKAIAECMiAkEkTwRAIAIQAAsgAUEgaiICIAFB0ABqKAIANgIAIAFBLGogAUHgAGooAgA2AgAgASABKQNYNwIkIAFB8ABqIgMgAikDADcDACABQfgAaiICIAFBKGopAwA3AwAgASABKQNINwNoIAAoAggNASAAQX82AgggAEEcahDhAiAAQSxqIAIpAwA3AgAgAEEkaiADKQMANwIAIAAgASkDaDcCHCAAIAAoAghBAWo2AgggASgCFCICQSRPBEAgAhAACyABQYABaiQAIAAPCwALQfC/wABBECABQRhqQYDAwABBuMHAABDEAQALywMCBX8BfiMAQUBqIgMkACADQX82AhQgA0EoaiABIANBFGpBBCACKAIgIgcRBQACQAJAIAMtAChBBEcEQCADKQMoIginQf8BcUEGRw0BC0EAIQIgA0EIaiADKAIUIgYQ5gEgA0EANgIgIAMgAygCDCIFNgIcIAMgAygCCCIENgIYIANB/wE6ACcCQAJAIANBKGogBgRAIAYhBANAIANBKGogASADQSdqQQEgBxEFACADLQAoQQRHBEAgAykDKCIIp0H/AXFBBkcNAwsgAy0AJyEFIAMoAiAiAiADKAIcRgR/IANBGGogAhCIAiADKAIgBSACCyADKAIYaiAFOgAAIAMgAygCIEEBaiICNgIgIARBf2oiBA0ACyADKAIcIQUgAygCGCEECyAEIAIQOCADKAIoDQEgAEEANgIAIABBEGogBkEEajYCACAAQQxqIAI2AgAgACAErSAFrUIghoQ3AgQMAwsgAEEBNgIAIAAgCDcCBCADQRhqEKkCDAILIAMgAykCLDcCNCADIAI2AjAgAyAErSAFrUIghoQ3AyggA0EoahCpAiAAQQE2AgAgAEIFNwIEDAELIABBATYCACAAIAg3AgQLIANBQGskAAvTAwEHfyMAQRBrIgYkAEGU/sAAKAIAIgRBkP7AACgCACIFIACnIgdxIgNqKQAAQoCBgoSIkKDAgH+DIgBQBEBBCCECA0AgAiADaiEDIAJBCGohAiAEIAMgBXEiA2opAABCgIGChIiQoMCAf4MiAFANAAsLAkBBmP7AACgCACAEIAB6p0EDdiADaiAFcSICaiwAACIDQX9KBH8gBCAEKQMAQoCBgoSIkKDAgH+DeqdBA3YiAmotAAAFIAMLQQFxIghFcg0AIAZBCGoQLkGU/sAAKAIAIgRBkP7AACgCACIFIAdxIgNqKQAAQoCBgoSIkKDAgH+DIgBQBEBBCCECA0AgAiADaiEDIAJBCGohAiAEIAMgBXEiA2opAABCgIGChIiQoMCAf4MiAFANAAsLIAQgAHqnQQN2IANqIAVxIgJqLAAAQX9MDQAgBCkDAEKAgYKEiJCgwIB/g3qnQQN2IQILIAIgBGogB0EZdiIDOgAAIAJBeGogBXEgBGpBCGogAzoAAEGY/sAAQZj+wAAoAgAgCGs2AgBBnP7AAEGc/sAAKAIAQQFqNgIAIAQgAkEEdGtBcGoiAkEIaiABQQhqKQIANwIAIAIgASkCADcCACAGQRBqJAALgwMBA38CQAJAAkACQCABQQlPBEBBEEEIEPACIAFLDQEMAgsgABArIQMMAgtBEEEIEPACIQELQYCAfEEIQQgQ8AJBFEEIEPACakEQQQgQ8AJqa0F3cUF9aiIEQQBBEEEIEPACQQJ0ayICIAIgBEsbIAFrIABNDQAgAUEQIABBBGpBEEEIEPACQXtqIABLG0EIEPACIgRqQRBBCBDwAmpBfGoQKyICRQ0AIAIQtQMhAAJAIAFBf2oiAyACcUUEQCAAIQEMAQsgAiADakEAIAFrcRC1AyECQRBBCBDwAiEDIAAQoAMgAkEAIAEgAiAAayADSxtqIgEgAGsiAmshAyAAEIwDRQRAIAEgAxDIAiAAIAIQyAIgACACEEEMAQsgACgCACEAIAEgAzYCBCABIAAgAmo2AgALIAEQjAMNASABEKADIgJBEEEIEPACIARqTQ0BIAEgBBCyAyEAIAEgBBDIAiAAIAIgBGsiBBDIAiAAIAQQQQwBCyADDwsgARC0AyABEIwDGgudAwIHfwF+IwBBgAFrIgMkACADQX82AhQgA0HIAGogASADQRRqQQQgAigCIBEFAAJAAkACQCADLQBIQQRHBEAgAykDSCIKp0H/AXFBBkcNAQsgA0EIaiADKAIUIgYQnAEgA0EANgIgIAMgAykDCDcDGCAGRQRAQQQhBQwCCyADQdQAaiEHQQQhBQNAAkAgA0HIAGogASACED0gAygCSA0AIAMoAlAhCCADQSRqIAdBJBCsAxogAygCeCEJIANByABqIANBJGpBJBCsAxogAygCICIEIAMoAhxGBEAgA0EYaiAEEIkCIAMoAiAhBAsgBSAJaiEFIAMoAhggBEEobGoiBCAINgIAIARBBGogA0HIAGpBJBCsAxogAyADKAIgQQFqNgIgIAZBf2oiBg0BDAMLCyADKQJMIQogAEEBNgIAIAAgCjcCBCADQRhqEL0BIANBGGoQsAIMAgsgAEEBNgIAIAAgCjcCBAwBCyAAIAMpAxg3AgQgAEEANgIAIABBEGogBTYCACAAQQxqIANBIGooAgA2AgALIANBgAFqJAALtAMBBH8jAEEgayICJAACQAJAAkACQAJAAkAgAC0A+AVBAWsOAwMAAgELAAsgAEH4AmogAEH4AhCsAxoLIAJBEGogAEH4AmoiAyABEK8BQQMhAQJAIAIoAhAiBEECRiIFDQAgAigCFCEBAkACQAJAIAAtAOgFDgQBAgIAAgsgAEGwBGohAwsgAxCmAgsCQCAERQRAIAIgATYCGCACQSA2AhwgAiAAQfAFaiACQRxqIAJBGGoQgAIgAigCAA0EIAIoAgQiAUEkTwRAIAEQAAsgAigCHCIBQSRPBEAgARAACyACKAIYIgFBJEkNASABEAAMAQsgAiABNgIYIAJBIDYCHCACQQhqIABB9AVqIAJBHGogAkEYahCAAiACKAIIDQQgAigCDCIBQSRPBEAgARAACyACKAIcIgFBJE8EQCABEAALIAIoAhgiAUEkSQ0AIAEQAAsgACgC8AUiAUEkTwRAIAEQAAtBASEBIAAoAvQFIgNBJEkNACADEAALIAAgAToA+AUgAkEgaiQAIAUPC0HwkMAAQSNB1JDAABCkAgALQYCAwABBFRCeAwALQYCAwABBFRCeAwALsQMBAX8jAEFAaiICJAACQAJAAkACQAJAAkAgAC0AAEEBaw4DAQIDAAsgAiAAQQRqKAIANgIEQRRBARCBAyIARQ0EIABBEGpBpNTAACgAADYAACAAQQhqQZzUwAApAAA3AAAgAEGU1MAAKQAANwAAIAJClICAgMACNwIMIAIgADYCCCACQTxqQQI2AgAgAkEkakHvADYCACACQgM3AiwgAkHYz8AANgIoIAJB8AA2AhwgAiACQRhqNgI4IAIgAkEEajYCICACIAJBCGo2AhggASACQShqENQBIQAgAigCDEEBSA0DIAIoAggQMQwDCyAALQABIQAgAkE8akEBNgIAIAJCATcCLCACQdTJwAA2AiggAkHxADYCDCACIABBIHNBP3FBAnQiAEGI2MAAaigCADYCHCACIABBiNrAAGooAgA2AhggAiACQQhqNgI4IAIgAkEYajYCCCABIAJBKGoQ1AEhAAwCCyAAQQRqKAIAIgAoAgAgACgCBCABEKgDIQAMAQsgAEEEaigCACIAKAIAIAEgACgCBCgCEBEAACEACyACQUBrJAAgAA8LQRRBARCkAwALvwIBAX8jAEHwAGsiBiQAIAYgATYCDCAGIAA2AgggBiADNgIUIAYgAjYCECAGQc3gwAA2AhggBkECNgIcAkAgBCgCAEUEQCAGQcwAakGNATYCACAGQcQAakGNATYCACAGQewAakEDNgIAIAZCBDcCXCAGQbDhwAA2AlggBkGHATYCPCAGIAZBOGo2AmgMAQsgBkEwaiAEQRBqKQIANwMAIAZBKGogBEEIaikCADcDACAGIAQpAgA3AyAgBkHsAGpBBDYCACAGQdQAakGOATYCACAGQcwAakGNATYCACAGQcQAakGNATYCACAGQgQ3AlwgBkGM4cAANgJYIAZBhwE2AjwgBiAGQThqNgJoIAYgBkEgajYCUAsgBiAGQRBqNgJIIAYgBkEIajYCQCAGIAZBGGo2AjggBkHYAGogBRCvAgAL+gIBBX8gAEELdCEEQSAhAkEgIQMCQANAAkACQEF/IAJBAXYgAWoiAkECdEGU98AAaigCAEELdCIFIARHIAUgBEkbIgVBAUYEQCACIQMMAQsgBUH/AXFB/wFHDQEgAkEBaiEBCyADIAFrIQIgAyABSw0BDAILCyACQQFqIQELAkACQCABQR9NBEAgAUECdCEFQcMFIQMgAUEfRwRAIAVBmPfAAGooAgBBFXYhAwtBACECIAFBf2oiBCABTQRAIARBIE8NAiAEQQJ0QZT3wABqKAIAQf///wBxIQILIAMgBUGU98AAaigCAEEVdiIBQX9zakUNAiAAIAJrIQQgAUHDBSABQcMFSxshAiADQX9qIQBBACEDA0ACQCABIAJHBEAgAyABQZT4wABqLQAAaiIDIARNDQEMBQsgAkHDBUHY/cAAENIBAAsgACABQQFqIgFHDQALIAAhAQwCCyABQSBB2P3AABDSAQALIARBIEGU9sAAENIBAAsgAUEBcQvXAgEHf0EBIQkCQAJAIAJFDQAgASACQQF0aiEKIABBgP4DcUEIdiELIABB/wFxIQ0CQANAIAFBAmohDCAHIAEtAAEiAmohCCALIAEtAAAiAUcEQCABIAtLDQMgCCEHIAwiASAKRw0BDAMLIAggB08EQCAIIARLDQIgAyAHaiEBAkADQCACRQ0BIAJBf2ohAiABLQAAIAFBAWohASANRw0AC0EAIQkMBQsgCCEHIAwiASAKRw0BDAMLCyAHIAgQpwMACyAIIAQQpgMACyAGRQ0AIAUgBmohAyAAQf//A3EhAQNAAkAgBUEBaiEAAn8gACAFLQAAIgJBGHRBGHUiBEEATg0AGiAAIANGDQEgBS0AASAEQf8AcUEIdHIhAiAFQQJqCyEFIAEgAmsiAUEASA0CIAlBAXMhCSADIAVHDQEMAgsLQdzewABBK0Hw6sAAEKQCAAsgCUEBcQuSAwIFfwJ+IwBBQGoiBSQAQQEhBwJAIAAtAAQNACAALQAFIQggACgCACIGKAIAIglBBHFFBEAgBigCGEGF4sAAQYfiwAAgCBtBAkEDIAgbIAZBHGooAgAoAgwRAwANASAGKAIYIAEgAiAGKAIcKAIMEQMADQEgBigCGEHQ4cAAQQIgBigCHCgCDBEDAA0BIAMgBiAEKAIMEQAAIQcMAQsgCEUEQCAGKAIYQYDiwABBAyAGQRxqKAIAKAIMEQMADQEgBigCACEJCyAFQQE6ABcgBUE0akHk4cAANgIAIAVBEGogBUEXajYCACAFIAk2AhggBSAGKQIYNwMIIAYpAgghCiAGKQIQIQsgBSAGLQAgOgA4IAUgBigCBDYCHCAFIAs3AyggBSAKNwMgIAUgBUEIajYCMCAFQQhqIAEgAhA5DQAgBUEIakHQ4cAAQQIQOQ0AIAMgBUEYaiAEKAIMEQAADQAgBSgCMEGD4sAAQQIgBSgCNCgCDBEDACEHCyAAQQE6AAUgACAHOgAEIAVBQGskACAAC9oCAgp/BX4jAEEQayIEJAAgARBHIQ5BlP7AACgCACIFQXBqIQdBkP7AACgCACIGIA6ncSEDIA5CGYhC/wCDQoGChIiQoMCAAX4hECABKAIIIQggASgCACEJAn8DQCADIAVqKQAAIg8gEIUiDUJ/hSANQv/9+/fv37//fnyDQoCBgoSIkKDAgH+DIQ0DQCANUARAIA8gD0IBhoNCgIGChIiQoMCAf4NQBEAgAyAKQQhqIgpqIAZxIQMMAwsgBEEIaiABQQhqKAIANgIAIAQgAjYCDCAEIAEpAgA3AwAgDiAEEE1BAAwDCyANeiERIA1Cf3wgDYMhDSAJIAggByARp0EDdiADaiAGcSILQQR0ayIMKAIAIAwoAggQ2QJFDQALCyAFQQAgC2tBBHRqQXxqIgUoAgAhAyAFIAI2AgAgARCpAkEBCyEBIAAgAzYCBCAAIAE2AgAgBEEQaiQAC/sCAQN/IwBBQGoiAiQAQQEhAwJAIAEoAhgiBEGM4MAAQQwgAUEcaigCACIBKAIMEQMADQACQCAAKAIIIgMEQCACIAM2AgwgAkGLATYCFCACIAJBDGo2AhBBASEDIAJBPGpBATYCACACQgI3AiwgAkGc4MAANgIoIAIgAkEQajYCOCAEIAEgAkEoahA+RQ0BDAILIAAoAgAiAyAAKAIEKAIMEQsAQovk55XyuI/XuH9SDQAgAiADNgIMIAJBjAE2AhQgAiACQQxqNgIQQQEhAyACQTxqQQE2AgAgAkICNwIsIAJBnODAADYCKCACIAJBEGo2AjggBCABIAJBKGoQPg0BCyAAKAIMIQAgAkEkakEaNgIAIAJBHGpBGjYCACACIABBDGo2AiAgAiAAQQhqNgIYIAJBhwE2AhQgAiAANgIQIAJBPGpBAzYCACACQgM3AiwgAkH038AANgIoIAIgAkEQajYCOCAEIAEgAkEoahA+IQMLIAJBQGskACADC80CAQZ/IwBBMGsiASQAEBkhACABQShqEMsCAkACQAJAIAEoAihFDQAgASgCLCEDEBohACABQSBqEMsCIAEoAiAhAiABKAIkIANBJE8EQCADEAALIAJFDQAgACACGyEDEBshACABQRhqEMsCIAEoAhghAiABKAIcIANBJE8EQCADEAALIAJFDQAgACACGyECEBwhACABQRBqEMsCIAEoAhQhAyABKAIQIAJBJE8EQCACEAALQQEhAg0BCyAAEApBAUcNAUEAIQIgAEEkTwRAIAAQAAsgACEDC0GUw8AAQQsQFSIEQSAQFiEAIAFBCGoQywIgASgCDCAAIAEoAggiBRshAAJAIAVFBEBBACEFDAELQQEhBSAAQSRJDQAgABAACyAEQSRPBEAgBBAAC0EgIAAgBRshACACIANBI0txRQ0AIAMQAAsgAUEwaiQAIAAL2gICA38BfiMAQSBrIgIkAEEhIQECQAJAAkACQAJAAkACQAJAAkACQCAALQAAQQFrDgkAAQIDBAUGBwgJCyACQRhqIABBDGooAgAiATYCACACIABBBGopAgAiBDcDECAEpyABEAUhASACQRBqEKkCDAgLIABBBGoqAgC7EAYhAQwHCyAAQQhqKwMAEAYhAQwGCyAAQQRqKAIAuBAGIQEMBQsgAEEIaikDALoQBiEBDAQLIABBBGooAgC3EAYhAQwDCyAAQQhqKQMAuRAGIQEMAgtBIkEjIAAtAAEbIQEMAQsgAkEYaiAAQQxqKAIAIgM2AgAgAiAAQQRqKQIAIgQ3AxAgAkEIaiAEpyIAIAMQnAIgAigCDCEBAkAgAigCCARAIAFBJE8EQCABEAALIAAgAxAFIQEMAQsgACADEAUiAEEkSQ0AIAAQAAsgAkEQahCpAgsgAkEgaiQAIAELygIBBH8jAEEQayIDJAACQAJAAkAgAigCBCIEIAIoAggiBUcEQANAIAUgBEsNAyADQQhqIAEgAhClAQJ/IAMtAAgiBEEERgRAIAIoAggiBiACKAIEIgRLDQYgBiAFIAZHDQEaIAMQ7QEgA0EIaiADKAIAEKsCIAAgAykDCDcCAAwECwJ/AkACQAJAAkAgBEEBaw4DAQIDAAsgAygCDBpBKAwDCyADLQAJDAILIAMoAgwtAAgMAQsgAygCDC0ACAtB/wFxQSNHBEAgACADKQMINwIADAQLIAMtAAhBA0YEQCADKAIMIgQoAgAgBCgCBCgCABECACAEKAIEIgUoAgQEQCAFKAIIGiAEKAIAEDELIAQQMQsgAigCBCEEIAIoAggLIgUgBEcNAAsLIABBBDoAAAsgA0EQaiQADwsgBSAEEKYDAAsgBiAEEKYDAAvPAgECfyMAQRBrIgIkAAJAAn8CQCABQYABTwRAIAJBADYCDCABQYAQTw0BIAIgAUE/cUGAAXI6AA0gAiABQQZ2QcABcjoADEECDAILIAAoAggiAyAAKAIERgRAIAAgAxCDASAAKAIIIQMLIAAgA0EBajYCCCAAKAIAIANqIAE6AAAMAgsgAUGAgARPBEAgAiABQT9xQYABcjoADyACIAFBBnZBP3FBgAFyOgAOIAIgAUEMdkE/cUGAAXI6AA0gAiABQRJ2QQdxQfABcjoADEEEDAELIAIgAUE/cUGAAXI6AA4gAiABQQx2QeABcjoADCACIAFBBnZBP3FBgAFyOgANQQMLIQEgAEEEaigCACAAKAIIIgNrIAFJBEAgACADIAEQggEgACgCCCEDCyAAKAIAIANqIAJBDGogARCsAxogACABIANqNgIICyACQRBqJAALzwIBAn8jAEEQayICJAACQAJ/AkAgAUGAAU8EQCACQQA2AgwgAUGAEE8NASACIAFBP3FBgAFyOgANIAIgAUEGdkHAAXI6AAxBAgwCCyAAKAIIIgMgACgCBEYEQCAAIAMQhQEgACgCCCEDCyAAIANBAWo2AgggACgCACADaiABOgAADAILIAFBgIAETwRAIAIgAUE/cUGAAXI6AA8gAiABQQZ2QT9xQYABcjoADiACIAFBDHZBP3FBgAFyOgANIAIgAUESdkEHcUHwAXI6AAxBBAwBCyACIAFBP3FBgAFyOgAOIAIgAUEMdkHgAXI6AAwgAiABQQZ2QT9xQYABcjoADUEDCyEBIABBBGooAgAgACgCCCIDayABSQRAIAAgAyABEIQBIAAoAgghAwsgACgCACADaiACQQxqIAEQrAMaIAAgASADajYCCAsgAkEQaiQAC7ECAQd/AkAgAkEPTQRAIAAhAwwBCyAAQQAgAGtBA3EiBmohBCAGBEAgACEDIAEhBQNAIAMgBS0AADoAACAFQQFqIQUgA0EBaiIDIARJDQALCyAEIAIgBmsiCEF8cSIHaiEDAkAgASAGaiIGQQNxIgIEQCAHQQFIDQEgBkF8cSIFQQRqIQFBACACQQN0IglrQRhxIQIgBSgCACEFA0AgBCAFIAl2IAEoAgAiBSACdHI2AgAgAUEEaiEBIARBBGoiBCADSQ0ACwwBCyAHQQFIDQAgBiEBA0AgBCABKAIANgIAIAFBBGohASAEQQRqIgQgA0kNAAsLIAhBA3EhAiAGIAdqIQELIAIEQCACIANqIQIDQCADIAEtAAA6AAAgAUEBaiEBIANBAWoiAyACSQ0ACwsgAAvAAgIFfwF+IwBBMGsiBSQAQSchAwJAIABCkM4AVARAIAAhCAwBCwNAIAVBCWogA2oiBEF8aiAAIABCkM4AgCIIQpDOAH59pyIGQf//A3FB5ABuIgdBAXRBtuLAAGovAAA7AAAgBEF+aiAGIAdB5ABsa0H//wNxQQF0QbbiwABqLwAAOwAAIANBfGohAyAAQv/B1y9WIAghAA0ACwsgCKciBEHjAEsEQCADQX5qIgMgBUEJamogCKciBCAEQf//A3FB5ABuIgRB5ABsa0H//wNxQQF0QbbiwABqLwAAOwAACwJAIARBCk8EQCADQX5qIgMgBUEJamogBEEBdEG24sAAai8AADsAAAwBCyADQX9qIgMgBUEJamogBEEwajoAAAsgAiABQdzewABBACAFQQlqIANqQScgA2sQNSAFQTBqJAALuwIBA38jAEGAAWsiBCQAAkACQAJAAkAgASgCACICQRBxRQRAIAJBIHENASAAMQAAQQEgARBeIQAMBAsgAC0AACECQQAhAANAIAAgBGpB/wBqQTBB1wAgAkEPcSIDQQpJGyADajoAACAAQX9qIQAgAiIDQQR2IQIgA0EPSw0ACyAAQYABaiICQYEBTw0BIAFBAUG04sAAQQIgACAEakGAAWpBACAAaxA1IQAMAwsgAC0AACECQQAhAANAIAAgBGpB/wBqQTBBNyACQQ9xIgNBCkkbIANqOgAAIABBf2ohACACIgNBBHYhAiADQQ9LDQALIABBgAFqIgJBgQFPDQEgAUEBQbTiwABBAiAAIARqQYABakEAIABrEDUhAAwCCyACQYABEKUDAAsgAkGAARClAwALIARBgAFqJAAgAAvOAgIEfwJ+IwBBMGsiAyQAIANCfzcDCCADQRhqIAEgA0EIakEIIAIoAiARBQACQAJAAkACQCADLQAYQQRHBEAgAykDGCIHp0H/AXFBBkcNAQsgAykDCCEIIANBGGogASACEEwgAykCHCEHIAMoAhgNASADQShqIgQoAgAhBSADIANBJGoiBigCADYCECADIAc3AwggA0EYaiABIAIQSCADKQIcIQcgAygCGA0CIAQoAgAhASAGKAIAIQIgAEEYaiADQRBqKAIANgIAIABBEGogAykDCDcDACAAQSRqIAI2AgAgAEEcaiAHNwIAIABBCGogCDcDACAAQQA2AgAgAEEoaiABIAVqQQhqNgIADAMLIABBATYCACAAIAc3AgQMAgsgAEEBNgIAIAAgBzcCBAwBCyAAQQE2AgAgACAHNwIEIANBCGoQqQILIANBMGokAAu3AgEDfyMAQYABayIEJAACQAJAAkACQCABKAIAIgJBEHFFBEAgAkEgcQ0BIAA1AgBBASABEF4hAAwECyAAKAIAIQBBACECA0AgAiAEakH/AGpBMEHXACAAQQ9xIgNBCkkbIANqOgAAIAJBf2ohAiAAQQ9LIABBBHYhAA0ACyACQYABaiIAQYEBTw0BIAFBAUG04sAAQQIgAiAEakGAAWpBACACaxA1IQAMAwsgACgCACEAQQAhAgNAIAIgBGpB/wBqQTBBNyAAQQ9xIgNBCkkbIANqOgAAIAJBf2ohAiAAQQ9LIABBBHYhAA0ACyACQYABaiIAQYEBTw0BIAFBAUG04sAAQQIgAiAEakGAAWpBACACaxA1IQAMAgsgAEGAARClAwALIABBgAEQpQMACyAEQYABaiQAIAAL2AICBH8CfiMAQUBqIgMkACAAAn8gAC0ACARAIAAoAgQhBUEBDAELIAAoAgQhBSAAKAIAIgQoAgAiBkEEcUUEQEEBIAQoAhhBheLAAEGf4sAAIAUbQQJBASAFGyAEQRxqKAIAKAIMEQMADQEaIAEgBCACKAIMEQAADAELIAVFBEAgBCgCGEGd4sAAQQIgBEEcaigCACgCDBEDAARAQQAhBUEBDAILIAQoAgAhBgsgA0EBOgAXIANBNGpB5OHAADYCACADQRBqIANBF2o2AgAgAyAGNgIYIAMgBCkCGDcDCCAEKQIIIQcgBCkCECEIIAMgBC0AIDoAOCADIAQoAgQ2AhwgAyAINwMoIAMgBzcDICADIANBCGo2AjBBASABIANBGGogAigCDBEAAA0AGiADKAIwQYPiwABBAiADKAI0KAIMEQMACzoACCAAIAVBAWo2AgQgA0FAayQAC64CAQV/IABCADcCECAAAn9BACABQYACSQ0AGkEfIAFB////B0sNABogAUEGIAFBCHZnIgJrdkEBcSACQQF0a0E+agsiAjYCHCAAIQQgAkECdEGogcEAaiEDAkACQAJAAkBBnP/AACgCACIFQQEgAnQiBnEEQCADKAIAIQMgAhDqAiECIAMQoAMgAUcNASADIQIMAgtBnP/AACAFIAZyNgIAIAAgAzYCGCADIAA2AgAMAwsgASACdCEFA0AgAyAFQR12QQRxakEQaiIGKAIAIgJFDQIgBUEBdCEFIAIiAxCgAyABRw0ACwsgAigCCCIBIAQ2AgwgAiAENgIIIAQgAjYCDCAEIAE2AgggAEEANgIYDwsgBiAANgIAIAAgAzYCGAsgBCAENgIIIAQgBDYCDAvgAgECfyMAQSBrIgEkACAAKAIAIQIgAEECNgIAAkACQAJAAkACQCACDgMCAQIACyABQRxqQQA2AgAgAUHwxsAANgIYIAFCATcCDCABQeDXwAA2AgggAUEIakHo18AAEK8CAAsgAC0ABCECIABBAToABCABIAJBAXEiAjoAByACDQEgAEEEaiEAQQAhAgJAAn8CQEH4/sAAKAIAQf////8HcQRAELEDIQIgAC0AAUUNASACQQFzIQIMBgsgAC0AAQ0FIABBAWoMAQsgAkUNASAAQQFqC0H4/sAAKAIAQf////8HcUUNABCxAw0AQQE6AAALIABBADoAAAsgAUEgaiQADwsgAUEcakEANgIAIAFBGGpB8MbAADYCACABQgE3AgwgAUG41cAANgIIIAFBB2ogAUEIahDYAQALIAEgAjoADCABIAA2AghBrMbAAEErIAFBCGpBiNbAAEH418AAEMQBAAujAgECfyMAQRBrIgIkAAJAIAAoAgAiACACQQxqAn8CQCABQYABTwRAIAJBADYCDCABQYAQTw0BIAIgAUE/cUGAAXI6AA0gAiABQQZ2QcABcjoADEECDAILIAAoAggiAyAAKAIERgR/IAAgAxCFAiAAKAIIBSADCyAAKAIAaiABOgAAIAAgACgCCEEBajYCCAwCCyABQYCABE8EQCACIAFBP3FBgAFyOgAPIAIgAUEGdkE/cUGAAXI6AA4gAiABQQx2QT9xQYABcjoADSACIAFBEnZBB3FB8AFyOgAMQQQMAQsgAiABQT9xQYABcjoADiACIAFBDHZB4AFyOgAMIAIgAUEGdkE/cUGAAXI6AA1BAwsgAkEMamoQkwILIAJBEGokAEEAC28BDH9ByILBACgCACICRQRAQdiCwQBB/x82AgBBAA8LQcCCwQAhBgNAIAIiASgCCCECIAEoAgQhAyABKAIAIQQgAUEMaigCABogASEGIAVBAWohBSACDQALQdiCwQAgBUH/HyAFQf8fSxs2AgAgCAuuAgEFfyAAKAIYIQQCQAJAIAAgACgCDEYEQCAAQRRBECAAQRRqIgEoAgAiAxtqKAIAIgINAUEAIQEMAgsgACgCCCICIAAoAgwiATYCDCABIAI2AggMAQsgASAAQRBqIAMbIQMDQCADIQUgAiIBQRRqIgIgAUEQaiACKAIAGyIDKAIAIgINAAsgBUEANgIACwJAIARFDQACQCAAIAAoAhwiAkECdEGogcEAaiIDKAIARwRAIARBEEEUIAQoAhAgAEYbaiABNgIAIAENAQwCCyADIAE2AgAgAQ0AQZz/wABBnP/AACgCAEF+IAJ3cTYCAA8LIAEgBDYCGCAAKAIQIgIEQCABIAI2AhAgAiABNgIYCyAAQRRqKAIAIgBFDQAgAUEUaiAANgIAIAAgATYCGAsLngIBAn8jAEEQayICJAACQCAAIAJBDGoCfwJAIAFBgAFPBEAgAkEANgIMIAFBgBBPDQEgAiABQT9xQYABcjoADSACIAFBBnZBwAFyOgAMQQIMAgsgACgCCCIDIAAoAgRGBH8gACADEIUCIAAoAggFIAMLIAAoAgBqIAE6AAAgACAAKAIIQQFqNgIIDAILIAFBgIAETwRAIAIgAUE/cUGAAXI6AA8gAiABQQZ2QT9xQYABcjoADiACIAFBDHZBP3FBgAFyOgANIAIgAUESdkEHcUHwAXI6AAxBBAwBCyACIAFBP3FBgAFyOgAOIAIgAUEMdkHgAXI6AAwgAiABQQZ2QT9xQYABcjoADUEDCyACQQxqahCTAgsgAkEQaiQAQQALswICCn8EfkGU/sAAKAIABEBBICECAkBBnP7AACgCAEUNACAAEEchC0GU/sAAKAIAIgNBcGohBUGQ/sAAKAIAIgQgC6dxIQEgC0IZiEL/AINCgYKEiJCgwIABfiENIAAoAgghBiAAKAIAIQcDQCABIANqKQAAIgwgDYUiC0J/hSALQv/9+/fv37//fnyDQoCBgoSIkKDAgH+DIQsDQCALUARAIAwgDEIBhoNCgIGChIiQoMCAf4NQRQ0DIAEgCEEIaiIIaiAEcSEBDAILIAt6IQ4gC0J/fCALgyELIAcgBiAFIA6nQQN2IAFqIARxIglBBHRrIgooAgAgCigCCBDZAkUNAAsLIANBACAJa0EEdGpBfGooAgAQASECCyAAEKkCIAIPC0GoiMAAQStBgInAABCkAgALmAIBAn8jAEEQayICJAACQCAAIAJBDGoCfwJAIAFBgAFPBEAgAkEANgIMIAFBgBBPDQEgAiABQT9xQYABcjoADSACIAFBBnZBwAFyOgAMQQIMAgsgACgCCCIDIAAoAgRGBH8gACADEIgCIAAoAggFIAMLIAAoAgBqIAE6AAAgACAAKAIIQQFqNgIIDAILIAFBgIAETwRAIAIgAUE/cUGAAXI6AA8gAiABQQZ2QT9xQYABcjoADiACIAFBDHZBP3FBgAFyOgANIAIgAUESdkEHcUHwAXI6AAxBBAwBCyACIAFBP3FBgAFyOgAOIAIgAUEMdkHgAXI6AAwgAiABQQZ2QT9xQYABcjoADUEDCxCEAwsgAkEQaiQAQQAL4AECBH8BfiMAQSBrIgQkACAAAn8CQAJAIAGtQhB+IgZCIIinDQAgBqciAkEHaiIDIAJJDQAgASADQXhxIgNqQQhqIgIgA0kNAAwBCxCCAiAAIAQpAwg3AgRBAQwBCwJAAkAgAkEATgRAIAJFDQEgAkEIEIEDIgUNAiACQQgQpAMACxCCAiAAIAQpAxA3AgRBAQwCC0EIIQULIABBEGpBADYCACAAQQhqIAMgBWo2AgAgACABQX9qIgI2AgQgAEEMaiACIAFBA3ZBB2wgAkEISRs2AgBBAAs2AgAgBEEgaiQAC58CAQF/AkACQAJAIAAtALYBDgQBAgIAAgsCQAJAAkACQAJAIAAtAGAOBQMEBAABBAsgAEHoAGoQrAEMAQsgAEH0AGoQrAEgACgCaCIBQSRJDQAgARAACyAAKAJYIgFBJE8EQCABEAALIAAoAlQiAUEkTwRAIAEQAAsgAEE4ahCpAiAAQSxqEKkCIAAoAigiAUEkSQ0BIAEQAAwBCwJAAkACQAJAIAAoAgAOBwECBAQDBAQACyAAQQRqIgEQvQEgARCwAgwDCyAAQRBqEKkCIABBHGoiARD4ASABELECDAILIABBEGoiARD4ASABELECDAELIABBBGoQqQILIABBkAFqEKkCDwsgAEH4AGoQqQIgAEGEAWoiABCeAiAAEKgCCwu8AgIDfwF+IwBBIGsiBCQAIAQgASgCACIFQQFqOgAPIARBEGogAiAEQQ9qQQEgAygCDBEFAAJAAkACQAJAAkACQAJAAkACQAJAIAQoAhBFBEAgBCgCFCEGIAVBAWsOBwIDBAUGBwgBCyAEKQIUIQcgAEEBNgIAIAAgBzcCBAwJCyAEQRBqIAFBCGogAiADEJMBDAcLIARBEGogAUEIaiACIAMQsQEMBgsgBEIANwMQDAULIARCADcDEAwECyAEQRBqIAFBBGogAiADELABDAMLIARCADcDEAwCCyAAQQE2AgAgAEEFOgAEDAILIARBEGogAUEEaiACIAMQnQELIAQoAhBFBEAgBCgCFCEBIABBADYCACAAIAEgBmo2AgQMAQsgBCkCFCEHIABBATYCACAAIAc3AgQLIARBIGokAAuaAgEDfyMAQRBrIgMkACAAKAIAIgBBHGpBADoAAAJAIAAoAggiAkH/////B0kEQCAAQRhqKAIAQX9qIABBEGooAgAgAEEMaigCAGtxIgRFDQEgAkUEQANAIABBfzYCCAJAIAAoAgwiAiAAKAIQRwRAIAAgACgCGEF/aiACQQFqcTYCDCAAKAIUIAJBAnRqKAIAIgINAQsgAEEANgIIDAQLIABBADYCCCADIAI2AgQgAkEIahCtASADQQRqELkBIARBf2oiBEUNAyAAKAIIRQ0ACwtB0LnAAEEQIANBCGpB4LnAAEHUvcAAEMQBAAtB8LnAAEEYIANBCGpBiLrAAEHEvcAAEMQBAAsgAUEkTwRAIAEQAAsgA0EQaiQAC5cCAQJ/IwBBIGsiAiQAAn8gACgCACIDLQAARQRAIAEoAhhByfbAAEEEIAFBHGooAgAoAgwRAwAMAQtBASEAIAIgA0EBajYCDCACIAEoAhhBxfbAAEEEIAFBHGooAgAoAgwRAwA6ABggAiABNgIQIAJBADoAGSACQQA2AhQgAkEQaiACQQxqQaTiwAAQYiACLQAYIQECQCACKAIUIgNFBEAgASEADAELIAENACACKAIQIQECQCADQQFHDQAgAi0AGUUNACABLQAAQQRxDQAgASgCGEGg4sAAQQEgAUEcaigCACgCDBEDAA0BCyABKAIYQYffwABBASABQRxqKAIAKAIMEQMAIQALIABB/wFxQQBHCyACQSBqJAALiAIBBX8jAEEgayIDJAACQAJAAkAgASgCBCACTwRAIANBCGogARCtAiADKAIQIgRFDQIgAkF/c0EfdiEFIAMoAgwhByADKAIIIQYgAkUEQCAHRQ0CIAYQMQwCCwJAAkAgBCAFRwRAIAIgBRCBAyIERQ0CIAQgBiACEKwDIQUgBw0BDAQLQQEhBCAGIAdBASACEPECIgUNAwwFCyAGEDEMAgsgBSEEDAMLIANBHGpBADYCACADQYygwAA2AhggA0IBNwIMIANBsKDAADYCCCADQQhqQYShwAAQrwIACyABIAI2AgQgASAFNgIAC0GBgICAeCEECyAAIAQ2AgQgACACNgIAIANBIGokAAuIAgEFfyMAQSBrIgMkAAJAAkACQCABKAIEIAJPBEAgA0EIaiABEK0CIAMoAhAiBEUNAiACQX9zQR92IQUgAygCDCEHIAMoAgghBiACRQRAIAdFDQIgBhAxDAILAkACQCAEIAVHBEAgAiAFEIEDIgRFDQIgBCAGIAIQrAMhBSAHDQEMBAtBASEEIAYgB0EBIAIQ8QIiBQ0DDAULIAYQMQwCCyAFIQQMAwsgA0EcakEANgIAIANBiMXAADYCGCADQgE3AgwgA0GsxcAANgIIIANBCGpBgMbAABCvAgALIAEgAjYCBCABIAU2AgALQYGAgIB4IQQLIAAgBDYCBCAAIAI2AgAgA0EgaiQAC4sCAgR/AX4jAEEwayICJAAgAUEEaiEEIAEoAgRFBEAgASgCACEDIAJBEGoiBUEANgIAIAJCATcDCCACIAJBCGo2AhQgAkEoaiADQRBqKQIANwMAIAJBIGogA0EIaikCADcDACACIAMpAgA3AxggAkEUakHYxsAAIAJBGGoQPhogBEEIaiAFKAIANgIAIAQgAikDCDcCAAsgAkEgaiIDIARBCGooAgA2AgAgAUEMakEANgIAIAQpAgAhBiABQgE3AgQgAiAGNwMYQQxBBBCBAyIBRQRAQQxBBBCkAwALIAEgAikDGDcCACABQQhqIAMoAgA2AgAgAEHM08AANgIEIAAgATYCACACQTBqJAALhwIBB38jAEEgayIEJAACQAJAIAEoAgQiAyACTwRAQYGAgIB4IQcgA0UNAiABKAIAIQYgA0H/////AUsNAiADQQJ0IQggAkGAgICAAkkiCUECdCEFIAJBAnQiA0UEQCAIRQ0CIAYQMQwCCwJAIAlFBEAgAyAFEIEDIgVFDQEgBSAGIAMQrAMaIAhFDQMgBhAxDAMLIAYgCEEEIAMQ8QIiBQ0CQQQhBwwDC0EAIQcMAgsgBEEcakEANgIAIARBiMXAADYCGCAEQgE3AgwgBEGsxcAANgIIIARBCGpBgMbAABCvAgALIAEgAjYCBCABIAU2AgALIAAgBzYCBCAAIAM2AgAgBEEgaiQAC7cCAgJ/AX4jAEEgayIBJAACQAJAAkBBIEEIEIEDIgIEQCACQQA2AhAgAkKBgICAEDcDACACQRRqIAA2AgBB5P7AAC0AACEAQeT+wABBAToAACABIAA6AAcgAA0BQfj9wAApAwAiA0J/UQ0CQfj9wAAgA0IBfDcDACADUA0DIAJBADYCGCACIAM3AwggAkEcakEAOwEAQeT+wABBADoAACABQSBqJAAgAg8LQSBBCBCkAwALIAFBHGpBADYCACABQRhqQfDGwAA2AgAgAUIBNwIMIAFBuNXAADYCCCABQQdqIAFBCGoQ2AEAC0Hk/sAAQQA6AAAgAUEcakEANgIAIAFB8MbAADYCGCABQgE3AgwgAUGsycAANgIIIAFBCGpBtMnAABCvAgALQbDHwABBK0HEycAAEKQCAAuNAgEDfyMAQdAAayIBJAAgAUEANgIQIAFCATcDCCABQShqIAFBCGpBlKHAABDGAiAAIAFBKGoQV0UEQCABQQhqQdCiwABB2qLAABCTAiABEAsiAhAMIAEgASgCBCIANgIgIAEgADYCHCABIAEoAgAiAzYCGCABQQhqIAMgACADahCTAiABQQhqQdqiwABB3KLAABCTAiABQTBqIAFBEGooAgAiADYCACABIAEpAwg3AyggASgCLCAASwRAIAFBKGogABCSAiABKAIwIQALIAEoAiggABANIAFBGGoQ4AIgAkEkTwRAIAIQAAsgAUHQAGokAA8LQayhwABBNyABQRhqQeShwABBwKLAABDEAQAL5QEBAX8jAEEQayICJAAgACgCACACQQA2AgwgAkEMagJ/IAFBgAFPBEAgAUGAEE8EQCABQYCABE8EQCACIAFBP3FBgAFyOgAPIAIgAUEGdkE/cUGAAXI6AA4gAiABQQx2QT9xQYABcjoADSACIAFBEnZBB3FB8AFyOgAMQQQMAwsgAiABQT9xQYABcjoADiACIAFBDHZB4AFyOgAMIAIgAUEGdkE/cUGAAXI6AA1BAwwCCyACIAFBP3FBgAFyOgANIAIgAUEGdkHAAXI6AAxBAgwBCyACIAE6AAxBAQsQOSACQRBqJAAL+gECA38BfiMAQTBrIgEkAAJAIAAEQCAAKQIAIQQgAEEANgIAIAFBKGoiAiAAQRBqKAIANgIAIAFBIGoiAyAAQQhqKQIANwMAIAEgBDcDGCAEpwRAIAFBEGogAigCADYCACABQQhqIAMpAwA3AwAgASABKQMYNwMADAILIAFBGGoQwwILIAEQfwtBqP7AACkCACEEQaj+wAAgASkDADcCACABQShqQbj+wAAoAgA2AgAgAUEgakGw/sAAKQIANwMAQbD+wAAgAUEIaikDADcCAEG4/sAAIAFBEGooAgA2AgAgASAENwMYIAFBGGoQwwIgAUEwaiQAQaj+wAAL7AEBAX8jAEEQayICJAAgAkEANgIMAn8gAUGAAU8EQCABQYAQTwRAIAFBgIAETwRAIAIgAUE/cUGAAXI6AA8gAiABQQZ2QT9xQYABcjoADiACIAFBDHZBP3FBgAFyOgANIAIgAUESdkEHcUHwAXI6AAxBBAwDCyACIAFBP3FBgAFyOgAOIAIgAUEMdkHgAXI6AAwgAiABQQZ2QT9xQYABcjoADUEDDAILIAIgAUE/cUGAAXI6AA0gAiABQQZ2QcABcjoADEECDAELIAIgAToADEEBCyEBIAAoAgAgAkEMaiABEIQDIAJBEGokAEEAC+sBAQV/IwBBMGsiAyQAIAACf0EAIAJBAWoiBCACSQ0AGiABKAIEIgJBAXQiBSAEIAUgBEsbIgRBBCAEQQRLGyIEQQR0IQUgBEGAgIDAAElBA3QhBiADIAIEfyABKAIAIQcgAyACQQR0NgIkIAMgBzYCICACQYCAgMAASUEDdAVBAAs2AiggA0EQaiAFIAYgA0EgahCjASADKAIUIQIgAygCEEUEQCABIAQ2AgQgASACNgIAQYGAgIB4DAELIANBCGogAiADQRhqKAIAEIMDIAMoAgghBCADKAIMCzYCBCAAIAQ2AgAgA0EwaiQAC+kBAQV/IwBBMGsiAyQAIAACf0EAIAJBAWoiBCACSQ0AGiABKAIEIgJBAXQiBSAEIAUgBEsbIgRBBCAEQQRLGyIEQShsIQUgBEG05swZSUEDdCEGIAMgAgR/IAEoAgAhByADIAJBKGw2AiQgAyAHNgIgIAJBtObMGUlBA3QFQQALNgIoIANBEGogBSAGIANBIGoQowEgAygCFCECIAMoAhBFBEAgASAENgIEIAEgAjYCAEGBgICAeAwBCyADQQhqIAIgA0EYaigCABCDAyADKAIIIQQgAygCDAs2AgQgACAENgIAIANBMGokAAviAQEBfyMAQRBrIgIkACACQQA2AgwgACACQQxqAn8gAUGAAU8EQCABQYAQTwRAIAFBgIAETwRAIAIgAUE/cUGAAXI6AA8gAiABQQZ2QT9xQYABcjoADiACIAFBDHZBP3FBgAFyOgANIAIgAUESdkEHcUHwAXI6AAxBBAwDCyACIAFBP3FBgAFyOgAOIAIgAUEMdkHgAXI6AAwgAiABQQZ2QT9xQYABcjoADUEDDAILIAIgAUE/cUGAAXI6AA0gAiABQQZ2QcABcjoADEECDAELIAIgAToADEEBCxA5IAJBEGokAAvbAQEGfyMAQUBqIgIkACACQRBqQYAIEOYBIAJBADYCICACIAIpAxA3AxggAkEoaiABIAJBGGoQjwECQCACKAIoRQRAIAIoAiwhBSACKAIYIQMgAkEIaiACKAIgIgQQ5gEgAigCDCEGIAIoAgggAyAEEKwDIQMgAEEQaiAFNgIAIABBDGogBDYCACAAQQhqIAY2AgAgACADNgIEIAJBGGoQqQIMAQsgAiACKQIsNwM4IAAgAkE4ahC0ATYCBCACQRhqEKkCQQEhBwsgARDkASAAIAc2AgAgAkFAayQAC9YBAAJAIABBIEkNAAJAAn9BASAAQf8ASQ0AGiAAQYCABEkNAQJAIABBgIAITwRAIABBtdlzakG12ytJIABB4ot0akHiC0lyDQQgAEGfqHRqQZ8YSSAAQd7idGpBDklyDQQgAEF+cUGe8ApGDQQgAEFgcUHgzQpHDQEMBAsgAEGf8MAAQSpB8/DAAEHAAUGz8sAAQbYDEFQPC0EAIABBx5F1akEHSQ0AGiAAQYCAvH9qQfCDdEkLDwsgAEGA68AAQShB0OvAAEGgAkHw7cAAQa8CEFQPC0EAC/kBAQF/IwBBoARrIgQkACAEIAE2ArABIAQgATYCrAEgBCAANgKoASAEQQhqIARBqAFqEL0CIARBmAFqIAQoAgggBCgCDBDvAiAEIAM2ArABIAQgAzYCrAEgBCACNgKoASAEIARBqAFqELwCIAQoAgAhASAEKAIEIQAgBEGoAmogBEGgAWooAgA2AgAgBCAEKQOYATcDoAIgBEEQaiAEQagBakGEARCsAxogBEGoAWogBEEQakGEARCsAxogBEG0AmogADYCACAEQbACaiAANgIAIARBADoAmAQgBEEAOgDeAiAEIAE2AqwCIARBqAFqEJ8CIARBoARqJAAL3QEBBX8jAEEgayIBJAAgARCgASABQRBqQQA2AgAgAUEUaiABKQMANwIAIAFBADoAHCABQgA3AwggAUEIahCLAiEDIAFBIDYCCCABQQhqKAIAECEhBSADIAMoAgAiAkEBaiIENgIAAkAgBCACTwRAQQRBBBCBAyICRQ0BIAIgAzYCACACQfS9wAAQnQMhBCAAQRBqQfS9wAA2AgAgAEEMaiACNgIAIAAgBDYCCCAAIAU2AgQgACADNgIAIAEoAggiAEEkTwRAIAAQAAsgAUEgaiQADwsAC0EEQQQQpAMAC+cBAQJ/IwBBIGsiAiQAIAIgADYCDCACIAEoAhhBtPbAAEERIAFBHGooAgAoAgwRAwA6ABggAiABNgIQIAJBADoAGSACQQA2AhQgAkEQaiACQQxqQaT2wAAQYgJ/IAItABgiASACKAIUIgNFDQAaIAFB/wFxIQBBASAADQAaIAIoAhAhAAJAIANBAUcNACACLQAZRQ0AIAAtAABBBHENAEEBIAAoAhhBoOLAAEEBIABBHGooAgAoAgwRAwANARoLIAAoAhhBh9/AAEEBIABBHGooAgAoAgwRAwALIAJBIGokAEH/AXFBAEcL1QEBBH8jAEEwayIEJAAgAAJ/QQAgAiADaiIDIAJJDQAaIANBAnQhBSADQYCAgIACSUECdCEGIAQCf0EAIAEoAgQiAkUNABogASgCACEHIAQgAkECdDYCJCAEIAc2AiAgAkGAgICAAklBAnQLNgIoIARBEGogBSAGIARBIGoQowEgBCgCFCECIAQoAhBFBEAgASADNgIEIAEgAjYCAEGBgICAeAwBCyAEQQhqIAIgBEEYaigCABCDAyAEKAIIIQMgBCgCDAs2AgQgACADNgIAIARBMGokAAvMAQECfyMAQSBrIgMkAAJAAkAgASACaiICIAFJDQAgAEEEaigCACIBQQF0IgQgAiAEIAJLGyICQQggAkEISxsiAkF/c0EfdiEEIAMgAQR/IAMgACgCADYCECADIAE2AhQgAUF/c0EfdgVBAAs2AhggAyACIAQgA0EQahCkASADKAIEIQEgAygCAEUEQCAAIAE2AgAgAEEEaiACNgIADAILIANBCGooAgAiAEGBgICAeEYNASAARQ0AIAEgABCkAwALEK4CAAsgA0EgaiQAC8wBAQN/IwBBIGsiAiQAAkACQCABQQFqIgMgAUkNACAAQQRqKAIAIgFBAXQiBCADIAQgA0sbIgNBCCADQQhLGyIDQX9zQR92IQQgAiABBH8gAiAAKAIANgIQIAIgATYCFCABQX9zQR92BUEACzYCGCACIAMgBCACQRBqEKQBIAIoAgQhASACKAIARQRAIAAgATYCACAAQQRqIAM2AgAMAgsgAkEIaigCACIAQYGAgIB4Rg0BIABFDQAgASAAEKQDAAsQrgIACyACQSBqJAALzAEBAn8jAEEgayIDJAACQAJAIAEgAmoiAiABSQ0AIABBBGooAgAiAUEBdCIEIAIgBCACSxsiAkEIIAJBCEsbIgJBf3NBH3YhBCADIAEEfyADIAAoAgA2AhAgAyABNgIUIAFBf3NBH3YFQQALNgIYIAMgAiAEIANBEGoQlgEgAygCBCEBIAMoAgBFBEAgACABNgIAIABBBGogAjYCAAwCCyADQQhqKAIAIgBBgYCAgHhGDQEgAEUNACABIAAQpAMACxCuAgALIANBIGokAAvMAQEDfyMAQSBrIgIkAAJAAkAgAUEBaiIDIAFJDQAgAEEEaigCACIBQQF0IgQgAyAEIANLGyIDQQggA0EISxsiA0F/c0EfdiEEIAIgAQR/IAIgACgCADYCECACIAE2AhQgAUF/c0EfdgVBAAs2AhggAiADIAQgAkEQahCWASACKAIEIQEgAigCAEUEQCAAIAE2AgAgAEEEaiADNgIADAILIAJBCGooAgAiAEGBgICAeEYNASAARQ0AIAEgABCkAwALEK4CAAsgAkEgaiQAC+8BAQF/IwBBEGsiAiQAIAIgADYCACACIABBBGo2AgQgASgCGEHl9sAAQQkgAUEcaigCACgCDBEDACEAIAJBADoADSACIAA6AAwgAiABNgIIIAJBCGpB7vbAAEELIAJB0PbAABBVQfn2wABBCSACQQRqQYT3wAAQVRoCfyACLQAMIgEgAi0ADUUNABogAUH/AXEhAEEBIAANABogAigCCCIALQAAQQRxRQRAIAAoAhhBm+LAAEECIABBHGooAgAoAgwRAwAMAQsgACgCGEGN4sAAQQEgAEEcaigCACgCDBEDAAsgAkEQaiQAQf8BcUEARwvsAQECfyMAQTBrIgIkAAJ/AkACQAJAIAAtAABBfGoiA0ECIANB/wFxQQJJG0H/AXFBAWsOAgECAAsgAkEkakEANgIAIAJB9KLAADYCICACQgE3AhQgAkHQo8AANgIQIAEgAkEQahDUAQwCCyACQSRqQQA2AgAgAkH0osAANgIgIAJCATcCFCACQayjwAA2AhAgASACQRBqENQBDAELIAIgADYCDCACQSRqQQE2AgAgAkICNwIUIAJBhKPAADYCECACQcUANgIsIAIgAkEoajYCICACIAJBDGo2AiggASACQRBqENQBCyACQTBqJAAL7AEBAn8jAEEwayICJAACfwJAAkACQCAALQAAQXxqIgNBAiADQf8BcUECSRtB/wFxQQFrDgIBAgALIAJBJGpBADYCACACQfSiwAA2AiAgAkIBNwIUIAJBtKTAADYCECABIAJBEGoQ1AEMAgsgAkEkakEANgIAIAJB9KLAADYCICACQgE3AhQgAkGQpMAANgIQIAEgAkEQahDUAQwBCyACIAA2AgwgAkEkakEBNgIAIAJCAjcCFCACQeijwAA2AhAgAkHFADYCLCACIAJBKGo2AiAgAiACQQxqNgIoIAEgAkEQahDUAQsgAkEwaiQAC98BAgJ/AX4jAEEgayIDJAAgACgCAEUEQCAAQX82AgAgA0EYaiAAQSRqKQIANwMAIANBEGogAEEcaikCADcDACAAQRRqKQIAIQUgAEEYakEANgIAIAMgBTcDCCADQQhqEOECAkAgACgCBEECRg0AIABBBGooAgQiBEEkSQ0AIAQQAAsgACACNgIIIAAgATYCBCAAKAIQIQEgAEEANgIQIAAgACgCAEEBajYCACABBEAgACgCDCABKAIEEQIACyADQSBqJAAPC0Hwv8AAQRAgA0EIakGAwMAAQcjBwAAQxAEAC7sBAQJ/IwBBIGsiBCQAIAACf0EAIAIgA2oiAyACSQ0AGiABKAIEIgJBAXQiBSADIAUgA0sbIgNBCCADQQhLGyIFQX9zQR92IQMgBCACBH8gBCABKAIANgIQIAQgAjYCFCACQX9zQR92BUEACzYCGCAEIAUgAyAEQRBqEKMBIAQoAgQhAyAEKAIABEAgBEEIaigCAAwBCyABIAU2AgQgASADNgIAQYGAgIB4CzYCBCAAIAM2AgAgBEEgaiQAC7wBAgF/An4jAEEgayIDJAAgA0J/NwMYIAMgASADQRhqQQggAigCIBEFACAAAn8CQCADLQAAQQRHBEAgAykDACIEp0H/AXFBBkcNAQsgAykDGCEFIAMgASACEEggAykCBCEEIAMoAgANACADQQxqKAIAIQEgAEEgaiADQRBqKAIAQQhqNgIAIABBGGogATYCACAAQRBqIAQ3AwAgAEEIaiAFNwMAQQAMAQsgACAENwIEQQELNgIAIANBIGokAAvJAQEDfyMAQSBrIgEkACAAKAIAIgIoAgAhAyACIAAoAgQ2AgAgASADQQNxIgA2AgQgAEECRgRAAkAgA0F+aiIABEADQCAAKAIEIAAoAgAhAiAAQQA2AgAgAkUNAiAAQQE6AAggASACNgIIIAJBGGoQZCACIAIoAgAiAEF/ajYCACAAQQFGBEAgAUEIahDrAQsiAA0ACwsgAUEgaiQADwtBsMfAAEErQZTRwAAQpAIACyABQQA2AgggAUEEaiABQQhqQYTRwAAQ2QEAC7QBAQF/IwBBQGoiAyQAIANBCGpBgAgQ5gEgA0EANgIYIAMgAykDCDcDECADQSBqIAEgAiADQRBqECoCQCADLQAgQQNGBEAgA0EwaiADQRhqKAIANgIAIAMgAykDEDcDKCADQgA3AyAgACADQSBqQbCPwAAQPSADQShqEKkCDAELIANCBTcDICADQThqIANBIGoQmwMgACADKQM4NwIEIABBATYCACADQRBqEKkCCyADQUBrJAAL0wEBAn8jAEEwayIDJAAgAyABNgIIIAMgASgCCCIENgIMIANBEGogAiABEEQgASgCCCICIARPBEAgA0EgaiABKAIAIARqIAIgBGsQOAJAIAMoAiBFBEAgACADKQMQNwIAIABBCGogA0EYaigCADYCACADIAEoAgg2AgwMAQsCQCADKAIQRQRAIABBAjYCBCAAQQhqQZCKwAA2AgAMAQsgACADKQIUNwIECyAAQQE2AgALIANBCGoiACgCACAAKAIENgIIIANBMGokAA8LIAQgAhClAwALtQEBAn8jAEEwayIDJAAgA0GACBDmASADQQA2AhAgAyADKQMANwMIIANBGGogASADQQhqQayOwAAQbQJAAkAgAygCGEUEQCADKAIQIgQgAygCHCIBSQ0CIAMoAgggASACEPcBIABBADYCACAAIAE2AgQMAQsgAyADKQIcNwMYIANBKGogA0EYahCbAyAAIAMpAyg3AgQgAEEBNgIACyADQQhqEKkCIANBMGokAA8LIAEgBBCmAwALtwEBAX8jAEEwayIEJAAgAAJ/QQAgAiADaiIDIAJJDQAaIAEoAgQhAiAEQSBqIAEQrQIgBEEQaiACQQF0IgIgAyACIANLGyICQQggAkEISxsiAyADQX9zQR92IARBIGoQowEgBCgCFCECIAQoAhBFBEAgASADNgIEIAEgAjYCAEGBgICAeAwBCyAEQQhqIAIgBEEYaigCABCDAyAEKAIIIQMgBCgCDAs2AgQgACADNgIAIARBMGokAAvVAQEFfyMAQRBrIgMkACABKAIAIgEoAghFBEAgAUF/NgIIIAFBDGoiBCgCACEFIARBAjYCACABQRBqKAIAIQZBACEEIAEgBUECRgR/IAMgAigCACICKAIAIAIoAgQoAgARAQAgAygCACECIAMoAgQhBCABKAIYIgcEQCABKAIUIAcoAgwRAgALIAEgBDYCGCABIAI2AhQgASgCCEEBagUgBAs2AgggACAGNgIEIAAgBTYCACADQRBqJAAPC0Hwv8AAQRAgA0EIakGAwMAAQdjBwAAQxAEAC+8BAQN/IwBBIGsiBSQAQfj+wABB+P7AACgCACIHQQFqNgIAQeSCwQBB5ILBACgCAEEBaiIGNgIAAkACQCAHQQBIIAZBAktyDQAgBSAEOgAYIAUgAzYCFCAFIAI2AhBB7P7AACgCACICQX9MDQBB7P7AACACQQFqIgI2AgBB7P7AAEH0/sAAKAIAIgMEf0Hw/sAAKAIAIAUgACABKAIQEQEAIAUgBSkDADcDCCAFQQhqIAMoAhQRAQBB7P7AACgCAAUgAgtBf2o2AgAgBkEBSw0AIAQNAQsACyMAQRBrIgIkACACIAE2AgwgAiAANgIIAAuoAQEDfyMAQSBrIgQkACAEIAEpAwA3AxggBEEIaiACIARBGGpBCCADKAIMEQUAIAACfyAEKAIIRQRAAkAgBCgCDCEFIARBCGogAUEIaiACIAMQsAEgBCgCCA0AIAQoAgwhBiAEQQhqIAFBFGogAiADEJ4BIAQoAghFBEAgACAEKAIMIAUgBmpqNgIEQQAMAwsLCyAAIAQpAgw3AgRBAQs2AgAgBEEgaiQAC6sBAQN/AkAgAkEPTQRAIAAhAwwBCyAAQQAgAGtBA3EiBGohBSAEBEAgACEDA0AgAyABOgAAIANBAWoiAyAFSQ0ACwsgBSACIARrIgJBfHEiBGohAyAEQQBKBEAgAUH/AXFBgYKECGwhBANAIAUgBDYCACAFQQRqIgUgA0kNAAsLIAJBA3EhAgsgAgRAIAIgA2ohAgNAIAMgAToAACADQQFqIgMgAkkNAAsLIAAL2QEBA38jAEEgayIAJAACQEH4/sAAKAIAQf////8HcQRAELEDRQ0BC0Hs/sAAKAIAQez+wABBfzYCAEUEQEH0/sAAKAIAIQFB9P7AAEGUkcAANgIAQfD+wAAoAgAhAkHw/sAAQQE2AgBB7P7AAEEANgIAAkAgAUUNACACIAEoAgARAgAgAUEEaigCAEUNACABQQhqKAIAGiACEDELIABBIGokAA8LAAsgAEEcakEANgIAIABB8MbAADYCGCAAQgE3AgwgAEH40sAANgIIIABBCGpBnNPAABCvAgALqgEAIAACfwJAAkAgAgRAIAFBAE4NAQwCCyAAIAE2AgQMAQsCQAJAAn8gAygCCARAIAMoAgQiAkUEQCABRQRAQQEhAgwECyABQQEQgQMMAgsgAygCACACQQEgARDxAgwBCyABRQRAQQEhAgwCCyABQQEQgQMLIgJFDQELIAAgAjYCBEEADAILIAAgATYCBEEBIQFBAQwBC0EAIQFBAQs2AgAgAEEIaiABNgIAC8gBAgV/AX4jAEEQayICJABBnP7AACgCACIDBEBBlP7AACgCACIBQQhqIQAgASkDAEJ/hUKAgYKEiJCgwIB/gyEFA0AgBVAEQANAIAFBgH9qIQEgACkDACAAQQhqIgQhAEKAgYKEiJCgwIB/gyIFQoCBgoSIkKDAgH9RDQALIAVCgIGChIiQoMCAf4UhBSAEIQALIAIgASAFeqdBAXRB8AFxazYCDCAFQn98IAWDIQUgAkEMahC/AiADQX9qIgMNAAsLIAJBEGokAAvDAQECfyMAQRBrIgIkACAAAn9BASAALQAEDQAaIAAoAgAhASAALQAFRQRAIAEoAhhBlOLAAEEHIAFBHGooAgAoAgwRAwAMAQsgAS0AAEEEcUUEQCABKAIYQY7iwABBBiABQRxqKAIAKAIMEQMADAELIAJBAToADyACQQhqIAJBD2o2AgAgAiABKQIYNwMAQQEgAkGK4sAAQQMQOQ0AGiABKAIYQY3iwABBASABKAIcKAIMEQMACyIAOgAEIAJBEGokACAAC74BAQJ/IwBBgANrIgMkACAAKAIAIgAtALYBIQQgAEEEOgC2AQJAIARBBEcEQCADQcgBaiAAQbYBEKwDGiADQQdqIABBtwFqQcEBEKwDGkGABkEIEIEDIgBFDQEgACADQcgBakG2ARCsAyIAIAQ6ALYBIABBtwFqIANBB2pBwQEQrAMaIABBADoA+AUgACACNgL0BSAAIAE2AvAFIAAQqQEgA0GAA2okAA8LQdyPwABBFRCeAwALQYAGQQgQpAMAC6wBAQF/IwBBMGsiAyQAIANBBDoADCADIAE2AgggA0EoaiACQRBqKQIANwMAIANBIGogAkEIaikCADcDACADIAIpAgA3AxgCQCADQQhqQdSRwAAgA0EYahA+BEAgAy0ADEEERgRAIABBAjYCACAAQQRqQfyRwAA2AgAMAgsgACADKQIMNwIADAELIABBBDoAACADLQAMQQRGDQAgA0EIakEEchCEAgsgA0EwaiQAC5oBAQR/IwBBEGsiAiQAAkAgAUUEQEEIIQMMAQsCQAJAIAFB////P0sNACABQQR0IgRBAEgEQCACQQhqIAFBABCDAyACKAIMQYGAgIB4Rw0BCyABQYCAgMAASUEDdCEFIAQEQCAEIAUQgQMiAw0DDAILIAUhAwwCCxCuAgALIAQgBRCkAwALIAAgATYCBCAAIAM2AgAgAkEQaiQAC5kBAQR/IwBBEGsiAiQAAkAgAUUEQEEIIQMMAQsCQAJAIAFBs+bMGUsNACABQShsIgRBAEgEQCACQQhqIAFBABCDAyACKAIMQYGAgIB4Rw0BCyABQbTmzBlJQQN0IQUgBARAIAQgBRCBAyIDDQMMAgsgBSEDDAILEK4CAAsgBCAFEKQDAAsgACABNgIEIAAgAzYCACACQRBqJAALtQECA38BfiMAQSBrIgQkACAEIAEoAggiBTYCDCAEQRBqIAIgBEEMakEEIAMoAgwRBQACQAJAIAQoAhANACAEKAIUIQYgBQRAIAEoAgAhASAFQShsIQUDQCAEQRBqIAEgAiADEG0gBCgCEA0CIAFBKGohASAEKAIUIAZqIQYgBUFYaiIFDQALCyAAQQA2AgAgACAGNgIEDAELIAQpAhQhByAAQQE2AgAgACAHNwIECyAEQSBqJAALtQECA38BfiMAQSBrIgQkACAEIAEoAggiBTYCDCAEQRBqIAIgBEEMakEEIAMoAgwRBQACQAJAIAQoAhANACAEKAIUIQYgBQRAIAEoAgAhASAFQQR0IQUDQCAEQRBqIAEgAiADEDogBCgCEA0CIAFBEGohASAEKAIUIAZqIQYgBUFwaiIFDQALCyAAQQA2AgAgACAGNgIEDAELIAQpAhQhByAAQQE2AgAgACAHNwIECyAEQSBqJAALpwEBBX8gAEEIaiAAQQxqIgEoAgAiAiACEPEBIAEoAgAiBSACQQF0RgRAIAAoAgAiAyAAKAIEIgFLBEAgASACIANrIgRPBEAgACgCCCICIAUgBGsiAUECdGogAiADQQJ0aiAEQQJ0EKwDGiAAIAE2AgAPCyAAKAIIIgMgAkECdGogAyABQQJ0EKwDGiAAIAEgAmo2AgQLDwtBmbvAAEErQcS7wAAQpAIACzcBAn8jAEEQayIBJABBIEEEEIEDIgJFBEBBIEEEEKQDAAsgAEEINgIEIAAgAjYCACABQRBqJAALrAEBA38jAEEwayICJAAgAUEEaiEDIAEoAgRFBEAgASgCACEBIAJBEGoiBEEANgIAIAJCATcDCCACIAJBCGo2AhQgAkEoaiABQRBqKQIANwMAIAJBIGogAUEIaikCADcDACACIAEpAgA3AxggAkEUakHYxsAAIAJBGGoQPhogA0EIaiAEKAIANgIAIAMgAikDCDcCAAsgAEHM08AANgIEIAAgAzYCACACQTBqJAALvgEBAX8jAEEgayICJAACfwJAAkACQCAALQAAQQFrDgIBAgALIAJBHGpBADYCACACQbykwAA2AhggAkIBNwIMIAJB5KTAADYCCCABIAJBCGoQ1AEMAgsgAkEcakEANgIAIAJBvKTAADYCGCACQgE3AgwgAkHYpMAANgIIIAEgAkEIahDUAQwBCyACQRxqQQA2AgAgAkG8pMAANgIYIAJCATcCDCACQcikwAA2AgggASACQQhqENQBCyACQSBqJAALqQEBAn8CQAJAAkAgAgRAQQEhBCABQQBODQEMAgsgACABNgIEQQEhBAwBCwJAAkACQAJAIAMoAggEQCADKAIEIgVFBEAgAQ0CDAQLIAMoAgAgBSACIAEQ8QIiA0UNAgwECyABRQ0CCyABIAIQgQMiAw0CCyAAIAE2AgQgAiEBDAMLIAIhAwsgACADNgIEQQAhBAwBC0EAIQELIAAgBDYCACAAQQhqIAE2AgALngEBAn8CQAJ/AkACQAJAAn8gAgRAQQEiBCABQQBIDQEaIAMoAghFDQMgAygCBCIFDQIgAQ0EIAIMBQsgACABNgIEQQELIQRBACEBDAQLIAMoAgAgBSACIAEQ8QIMAgsgAQ0AIAIMAQsgASACEIEDCyIDBEAgACADNgIEQQAhBAwBCyAAIAE2AgQgAiEBCyAAIAQ2AgAgAEEIaiABNgIAC5YBAQR/IwBBEGsiBSQAIAIoAgghAyAFQQhqIAEQgQIgAigCBCIEIANJBEAgAyAEEKUDAAsgAigCACADaiAFKAIIIAUoAgwiBiAEIANrIgQgBCAGSxsiBBCsAxogAiADIARqIgM2AgggAEEEOgAAIAEgASkDACAErXw3AwAgAiACKAIMIgAgAyAAIANLGzYCDCAFQRBqJAALkgEBBH8jAEEQayIEJAAgA0EDdCEDIAACfwJAA0AgA0UNASAEIAEgAigCACACKAIEELoBIAQoAgQhBiAEKAIARQRAIANBeGohAyAFIAZqIQUgAigCBCEHIAJBCGohAiAGIAdPDQEMAgsLIAAgBq0gBDUCCEIghoQ3AgRBAQwBCyAAIAU2AgRBAAs2AgAgBEEQaiQAC5gBAQF/AkACQAJAAkACQCAALQBgDgUDBAQAAQQLIABB6ABqEKwBDAELIABB9ABqEKwBIABB6ABqKAIAIgFBJEkNACABEAALIABB2ABqKAIAIgFBJE8EQCABEAALIABB1ABqKAIAIgFBJE8EQCABEAALIABBOGoQqQIgAEEsahCpAiAAKAIoIgBBJEkNASAAEAAPCyAAEOQBCwuVAQEEfyMAQRBrIgEkACABIAAoAgggAEEMaigCACAAKAIEIAAoAgAQtgEgAUEMaigCACEEIAEoAgghACABKAIEIgMEQCABKAIAIQIgA0ECdCEDA0AgAhC5ASACQQRqIQIgA0F8aiIDDQALCyAEBEAgBEECdCECA0AgABC5ASAAQQRqIQAgAkF8aiICDQALCyABQRBqJAALqQEBBH8jAEEgayICJAAgAkIANwMIIAJBAToAHCACQQhqEIsCIgEgASgCACIDQQFqIgQ2AgACQCAEIANPBEAgASgCCA0BIAFBfzYCCCABQQxqEIwCIAFB8MLAADYCGCABIAFBCGo2AhQgAUGYgMAANgIQIAEgADYCDCABQQA2AgggARD+ASACQSBqJAAPCwALQfC/wABBECACQQhqQYDAwABB3MLAABDEAQALhwEBA38jAEGAAWsiAyQAIAAoAgAhAANAIAIgA2pB/wBqQTBB1wAgAEEPcSIEQQpJGyAEajoAACACQX9qIQIgAEEPSyAAQQR2IQANAAsgAkGAAWoiAEGBAU8EQCAAQYABEKUDAAsgAUEBQbTiwABBAiACIANqQYABakEAIAJrEDUgA0GAAWokAAuGAQEDfyMAQYABayIDJAAgACgCACEAA0AgAiADakH/AGpBMEE3IABBD3EiBEEKSRsgBGo6AAAgAkF/aiECIABBD0sgAEEEdiEADQALIAJBgAFqIgBBgQFPBEAgAEGAARClAwALIAFBAUG04sAAQQIgAiADakGAAWpBACACaxA1IANBgAFqJAALkQEBAX8gACgCACIAIAAoAgBBf2oiATYCAAJAIAENAAJAIABBDGooAgBBAkYNACAAQRBqKAIAIgFBJEkNACABEAALIABBGGooAgAiAQRAIABBFGooAgAgASgCDBECAAsgAEEgaigCAARAIABBHGoQ6AIgAEEoahDoAgsgACAAKAIEQX9qIgE2AgQgAQ0AIAAQMQsLmwEBA38jAEEQayIBJAAgACgCAEUEQCAAQX82AgAgACAAKAIEIgMEfyAAQQA6ABQgASAAQQRqIgJBACADGyIDQQhqNgIEIAMoAgAgAUEEaiADKAIEKAIMEQAARQRAIAIQjAIgAkEANgIACyAAKAIAQQFqBSACCzYCACABQRBqJAAPC0Hwv8AAQRAgAUEIakGAwMAAQYDDwAAQxAEAC5cBAQF/IwBBQGoiAiQAIAJCADcDOCACQThqIAAoAgAQJyACQRxqQQE2AgAgAiACKAI8IgA2AjAgAiAANgIsIAIgAigCODYCKCACQe4ANgIkIAJCAjcCDCACQZzGwAA2AgggAiACQShqNgIgIAIgAkEgajYCGCABIAJBCGoQ1AEgAigCLEEBTgRAIAIoAigQMQsgAkFAayQAC6ABAQN/IwBBEGsiAyQAAn8CQAJAAkACQAJAIAEtAPACQQFrDgMDAAIBCwALIAFBuAFqIAFBuAEQrAMaCyADQQhqIAFBuAFqIgQgAhAzIAMoAghFDQFBAyEEQQIMAgtB8JDAAEEjQfyfwAAQpAIACyADKAIMIQUgBBCmAkEBIQRBAAshAiABIAQ6APACIAAgBTYCBCAAIAI2AgAgA0EQaiQAC5sBAgN/AX4jAEEgayIEJAAgASgCACEFIAQgASgCCCIBNgIMIARBEGogAiAEQQxqQQQgAygCDCIDEQUAAkACQCAEKAIQDQAgBCgCFCEGIARBEGogAiAFIAEgAxEFACAEKAIQDQAgBCgCFCEBIABBADYCACAAIAEgBmo2AgQMAQsgBCkCFCEHIABBATYCACAAIAc3AgQLIARBIGokAAuDAQECfyMAQSBrIgQkACAEIAEpAwA3AxggBEEIaiACIARBGGpBCCADKAIMEQUAIAACfyAEKAIIRQRAIAQoAgwhBSAEQQhqIAFBCGogAiADEJ4BIAQoAghFBEAgACAEKAIMIAVqNgIEQQAMAgsLIAAgBCkCDDcCBEEBCzYCACAEQSBqJAALhAEBAX8jAEEQayICJAAgAkH0t8AAQQQQBTYCCCACIAEEfyABKAIAEAEFQSALNgIMIAIgACACQQhqIAJBDGoQ6gEgAigCDCIAQSRPBEAgABAACyACKAIIIgBBJE8EQCAAEAALAkAgAi0AAEUNACACKAIEIgBBJEkNACAAEAALIAJBEGokAAuPAQECfyMAQUBqIgEkACABQQA2AgggAUIBNwMAIAFBEGogAUHUlMAAEMYCIAAgAUEQahCHAUUEQCABQRhqIAFBCGooAgA2AgAgASABKQMANwMQIAFBEGoQ4wIgAC0AAEEGcUEERwRAIAAQhAILIAFBQGskAA8LQeyUwABBNyABQThqQaSVwABBgJbAABDEAQALjwEBAn8jAEFAaiIBJAAgAUEANgIIIAFCATcDACABQRBqIAFB1JTAABDGAiAAIAFBEGoQiAFFBEAgAUEYaiABQQhqKAIANgIAIAEgASkDADcDECABQRBqEOMCIAAtAABBBnFBBEcEQCAAEIQCCyABQUBrJAAPC0HslMAAQTcgAUE4akGklcAAQYCWwAAQxAEAC5UBAgF/An4jAEEQayIBJAACf0GA/8AAKQMAUARAAn4CQCAARQ0AIAApAwAgAEIANwMAQgFSDQAgACkDCCECIAApAxAMAQsgAUICNwMIIAFCATcDACABKQMAIQIgASkDCAshA0GI/8AAIAI3AwBBgP/AAEIBNwMAQZD/wAAgAzcDAEGI/8AADAELQYj/wAALIAFBEGokAAuNAQEBfyMAQRBrIgUkAAJAAkAgBCADSwRAIAIgBEkNAiAAIAEgBEECdGo2AgAgAiAEayEEDAELIAVBCGogASACIAQgAxCaAiAFKAIMIQQgACAFKAIINgIAQQAhAwsgACABNgIIIAAgBDYCBCAAQQxqIAM2AgAgBUEQaiQADwtBmLrAAEEjQcy8wAAQpAIAC5UBAQN/IwBBEGsiAyQAIAAoAgAiAigCCEUEQCACQX82AgggAkEMaiABEOcBIAJBHGoiAS0AACEEIAFBAToAACACIAIoAghBAWo2AggCQCAEQQFxDQAgAEEEaigCACAAQQhqKAIAECIiAEEkSQ0AIAAQAAsgA0EQaiQADwtB0LnAAEEQIANBCGpB4LnAAEHkvcAAEMQBAAugAQECfyMAQRBrIgMkACAAQRRqKAIAIQQCQAJ/AkACQCAAQQRqKAIADgIAAQMLIAQNAkEAIQBB8MbAAAwBCyAEDQEgACgCACIEKAIEIQAgBCgCAAshBCADIAA2AgQgAyAENgIAIANBgNTAACABKAIIIAIgAS0AEBCSAQALIANBADYCBCADIAA2AgAgA0Hs08AAIAEoAgggAiABLQAQEJIBAAuFAQEBfyAAKAIAIgAgACgCAEF/aiIBNgIAAkAgAQ0AIABBDGooAgAiAQRAIAEgAEEQaiIBKAIAKAIAEQIAIAEoAgAiASgCBARAIAEoAggaIAAoAgwQMQsgAEEUaigCACAAQRhqKAIAKAIMEQIACyAAIAAoAgRBf2oiATYCBCABDQAgABAxCwuHAQEDfyMAQRBrIgUkACAFQQhqIAEQgQIgBSgCCCEGAkACQCAFKAIMIgQgAyAEIANJGyIEQQFHBEAgAiAGIAQQrAMaDAELIANFDQEgAiAGLQAAOgAACyAAIAQ2AgQgAEEANgIAIAEgASkDACAErXw3AwAgBUEQaiQADwtBAEEAQayDwAAQ0gEAC3sBA38CQCADQQN0IgUEQCACIAVqIQYgAkEEaiEDA0AgAygCACAEaiEEIANBCGohAyAFQXhqIgUNAAsgASAEENQCA0AgASACKAIAIAJBBGooAgAQhAMgAkEIaiICIAZHDQALDAELIAFBABDUAgsgAEEANgIAIAAgBDYCBAuEAQEBfyMAQSBrIgYkACABBEAgBiABIAMgBCAFIAIoAhARCgAgBkEYaiAGQQhqKAIAIgE2AgAgBiAGKQMANwMQIAYoAhQgAUsEQCAGQRBqIAEQlAIgBigCGCEBCyAGKAIQIQIgACABNgIEIAAgAjYCACAGQSBqJAAPC0Gfw8AAQTAQngMAC5ABAQJ/IAAoAggiAgRAIAAoAgAhACACQShsIQIDQAJAAkACQAJAAkAgACgCAA4HAQIEBAMEBAALIABBBGoiARC9ASABELACDAMLIABBEGoQqQIgAEEcaiIBEPgBIAEQsQIMAgsgAEEQaiIBEPgBIAEQsQIMAQsgAEEEahCpAgsgAEEoaiEAIAJBWGoiAg0ACwsLcgEEfyMAQRBrIgMkACAAKAIMIAAoAggiAWsiAgRAIAJBBHZBBHQhAgNAIAEtAAAiBEF+akEHSSAERXJFBEAgAUEEahCpAgsgAUEQaiEBIAJBcGoiAg0ACwsgAyAAKQIANwMIIANBCGoQsQIgA0EQaiQAC4kBAQJ/IAFBCGooAgAhAiABKAIEIQMCQAJAAkAgASgCAEUEQAJAIAJFBEBBASEBDAELIAJBf0wNAyACQQEQgQMiAUUNBAsgACABIAMgAhCsAzYCACACIQEMAQsgAUEMaigCACEBIAAgAzYCAAsgACABNgIIIAAgAjYCBA8LEK4CAAsgAkEBEKQDAAuEAQIBfwF+IwBBEGsiAyQAIANB/wE6AAcgA0EIaiABIANBB2pBASACKAIgEQUAAkACQCADLQAIQQRHBEAgAykDCCIEp0H/AXFBBkcNAQsgAEEANgIAIABBCGpBATYCACAAIAMtAAdBAEc6AAQMAQsgAEEBNgIAIAAgBDcCBAsgA0EQaiQAC34BAX8jAEEQayIBJAAgAUH4t8AAQQYQBTYCCCABQbCcwABBBBAFNgIMIAEgACABQQhqIAFBDGoQ6gEgASgCDCIAQSRPBEAgABAACyABKAIIIgBBJE8EQCAAEAALAkAgAS0AAEUNACABKAIEIgBBJEkNACAAEAALIAFBEGokAAt5AQJ/IwBBEGsiBCQAIARBCGogARCBAgJAIAQoAgwgA08EQCAEKAIIIQUCQCADQQFHBEAgAiAFIAMQrAMaDAELIAIgBS0AADoAAAsgAEEEOgAAIAEgASkDACADrXw3AwAMAQsgAEKCgICAwKqACDcCAAsgBEEQaiQAC34BAX8jAEEQayIBJAAgAUH+t8AAQQQQBTYCCCABQZS4wABBBBAFNgIMIAEgACABQQhqIAFBDGoQ6gEgASgCDCIAQSRPBEAgABAACyABKAIIIgBBJE8EQCAAEAALAkAgAS0AAEUNACABKAIEIgBBJEkNACAAEAALIAFBEGokAAuAAQEBfyMAQUBqIgUkACAFIAE2AgwgBSAANgIIIAUgAzYCFCAFIAI2AhAgBUEsakECNgIAIAVBPGpBjQE2AgAgBUICNwIcIAVB1OHAADYCGCAFQYcBNgI0IAUgBUEwajYCKCAFIAVBEGo2AjggBSAFQQhqNgIwIAVBGGogBBCvAgALbAEBfyMAQTBrIgMkACADIAE2AiggAyABNgIkIAMgADYCICADQQhqIANBIGoQvQIgA0EQaiADKAIIIAMoAgwQ7wIgA0EoaiADQRhqKAIANgIAIAMgAykDEDcDICADQSBqIAIQzAEgA0EwaiQAC3wBAX8gAC0ABCEBIAAtAAUEQCABQf8BcSEBIAACf0EBIAENABogACgCACIBLQAAQQRxRQRAIAEoAhhBm+LAAEECIAFBHGooAgAoAgwRAwAMAQsgASgCGEGN4sAAQQEgAUEcaigCACgCDBEDAAsiAToABAsgAUH/AXFBAEcLaQEBfyMAQTBrIgIkACACIAE2AiggAiABNgIkIAIgADYCICACQQhqIAJBIGoQvQIgAkEQaiACKAIIIAIoAgwQ7wIgAkEoaiACQRhqKAIANgIAIAIgAikDEDcDICACQSBqEGkgAkEwaiQAC3wBA38gACAAELQDIgBBCBDwAiAAayICELIDIQBBrILBACABIAJrIgE2AgBBtILBACAANgIAIAAgAUEBcjYCBEEIQQgQ8AIhAkEUQQgQ8AIhA0EQQQgQ8AIhBCAAIAEQsgNB0ILBAEGAgIABNgIAIAQgAyACQQhramo2AgQLZgEEfyMAQRBrIgIkACAAKAIMIAAoAggiA2siAQRAIAFBAnZBAnQhAQNAIAMoAgAiBEEkTwRAIAQQAAsgA0EEaiEDIAFBfGoiAQ0ACwsgAiAAKQIANwMIIAJBCGoQqAIgAkEQaiQAC3cBAX8CQAJAIABFDQAgACgCACEBIABBADYCACAAKAIEIQACQCABDgIBAgALIABBJEkNACAAEAALEFghAAtBwP7AACgCACEBQcD+wAAgADYCAEG8/sAAKAIAQbz+wABBATYCAEUgAUEkSXJFBEAgARAAC0HA/sAAC28BBH8jAEEgayICJABBASEDAkAgACABEGENACABQRxqKAIAIQQgASgCGCACQRxqQQA2AgAgAkHc3sAANgIYIAJCATcCDCACQYzfwAA2AgggBCACQQhqED4NACAAQQRqIAEQYSEDCyACQSBqJAAgAwtpAQF/IwBBIGsiAiQAQZT+wAAoAgBFBEBBqIjAAEErQfCIwAAQpAIACyACQRhqIABBCGooAgA2AgAgAiAAKQIANwMQIAJBCGogAkEQaiABEFYgAigCCCEAIAIoAgwgAkEgaiQAQSEgABsLWwECfyMAQSBrIgIkACABQRxqKAIAIQMgASgCGCACQRhqIAAoAgAiAEEQaikCADcDACACQRBqIABBCGopAgA3AwAgAiAAKQIANwMIIAMgAkEIahA+IAJBIGokAAuRAQIBfwJ+IwBBEGsiASQAEKACQfD9wAAgADsBAEHo/cAAQgE3AwAgARDuASABKQMIIQIgASkDACEDQZT+wAAoAgAEQEGQ/sAAKAIABEAQlwEQ7AELC0GY/sAAQgA3AwBBlP7AAEH4m8AANgIAQYD+wAAgAzcDAEGI/sAAIAI3AwBBkP7AAEEANgIAIAFBEGokAAtwAQF/IwBBMGsiAiQAIAIgATYCBCACIAA2AgAgAkEcakECNgIAIAJBLGpBGjYCACACQgI3AgwgAkHY5MAANgIIIAJBGjYCJCACIAJBIGo2AhggAiACQQRqNgIoIAIgAjYCICACQQhqQYjlwAAQrwIAC3ABAX8jAEEwayICJAAgAiABNgIEIAIgADYCACACQRxqQQI2AgAgAkEsakEaNgIAIAJCAjcCDCACQezlwAA2AgggAkEaNgIkIAIgAkEgajYCGCACIAJBBGo2AiggAiACNgIgIAJBCGpB/OXAABCvAgALcAEBfyMAQTBrIgIkACACIAE2AgQgAiAANgIAIAJBHGpBAjYCACACQSxqQRo2AgAgAkICNwIMIAJBqOXAADYCCCACQRo2AiQgAiACQSBqNgIYIAIgAkEEajYCKCACIAI2AiAgAkEIakG45cAAEK8CAAttAQF/IwBBMGsiAyQAIAMgATYCBCADIAA2AgAgA0EcakECNgIAIANBLGpBGjYCACADQgI3AgwgA0Hg38AANgIIIANBGjYCJCADIANBIGo2AhggAyADNgIoIAMgA0EEajYCICADQQhqIAIQrwIAC1YBAn8jAEEgayICJAAgAUEcaigCACEDIAEoAhggAkEYaiAAQRBqKQIANwMAIAJBEGogAEEIaikCADcDACACIAApAgA3AwggAyACQQhqED4gAkEgaiQAC1YBAn8jAEEgayICJAAgAEEcaigCACEDIAAoAhggAkEYaiABQRBqKQIANwMAIAJBEGogAUEIaikCADcDACACIAEpAgA3AwggAyACQQhqED4gAkEgaiQAC2kBAn8jAEEgayICJAAgAkEIaiABKAIAEAQCQCACKAIIIgEEQCACIAIoAgwiAzYCGCACIAM2AhQgAiABNgIQIAIgAkEQahC9AiAAIAIoAgAgAigCBBDvAgwBCyAAQQA2AgALIAJBIGokAAtnAQF/IwBBIGsiAyQAIAAoAgAgA0EIaiABIAIQOCADKAIIBEAgAyADKQIMNwMYQYS1wABBKyADQRhqQbC1wABBpLbAABDEAQALIAMoAgwiACAAIANBEGooAgBqEJgCIANBIGokAEEAC20BBH8jAEEQayIBJAACQEEAQezCwAAoAgARBgAiAgRAIAAoAgAoAgAiACAAKAIAIgNBAWoiBDYCACAEIANJDQEgAiAAELcBIAFBEGokAA8LQbi+wABBxgAgAUEIakGAv8AAQeC/wAAQxAEACwALZgEBfyMAQSBrIgIkACACQZTVwAA2AgQgAiAANgIAIAJBGGogAUEQaikCADcDACACQRBqIAFBCGopAgA3AwAgAiABKQIANwMIIAJBoMfAACACQQRqQaDHwAAgAkEIakH41cAAEFIAC2MBAX8jAEEgayIDJAAgA0GA0cAANgIEIAMgADYCACADQRhqIAFBEGopAgA3AwAgA0EQaiABQQhqKQIANwMAIAMgASkCADcDCCADQZDHwAAgA0EEakGQx8AAIANBCGogAhBSAAtwAQF/AkACQAJAAkAgAC0A+AUOBAECAgACCyAAQfgCahDbAiAAKALwBSIBQSRPBEAgARAACyAAKAL0BSIAQSNNDQEMAgsgABDbAiAAKALwBSIBQSRPBEAgARAACyAAKAL0BSIAQSNLDQELDwsgABAAC1kBAX8jAEEgayICJAAgAiAAKAIANgIEIAJBGGogAUEQaikCADcDACACQRBqIAFBCGopAgA3AwAgAiABKQIANwMIIAJBBGpBnIrAACACQQhqED4gAkEgaiQAC2EBA38gACABENQCIAAoAgAiBCAAKAIIIgJqIQMCQAJAIAFBAk8EQCADQQAgAUF/aiIBEK0DGiAEIAEgAmoiAmohAwwBCyABRQ0BCyADQQA6AAAgAkEBaiECCyAAIAI2AggLWQEBfyMAQSBrIgIkACACIAAoAgA2AgQgAkEYaiABQRBqKQIANwMAIAJBEGogAUEIaikCADcDACACIAEpAgA3AwggAkEEakHcosAAIAJBCGoQPiACQSBqJAALWQEBfyMAQSBrIgIkACACIAAoAgA2AgQgAkEYaiABQRBqKQIANwMAIAJBEGogAUEIaikCADcDACACIAEpAgA3AwggAkEEakHYxsAAIAJBCGoQPiACQSBqJAALaAAjAEEwayIBJABBoP7AAC0AAARAIAFBHGpBATYCACABQgI3AgwgAUGM0sAANgIIIAFBGjYCJCABIAA2AiwgASABQSBqNgIYIAEgAUEsajYCICABQQhqQbTSwAAQrwIACyABQTBqJAALWQEBfyMAQSBrIgIkACACIAAoAgA2AgQgAkEYaiABQRBqKQIANwMAIAJBEGogAUEIaikCADcDACACIAEpAgA3AwggAkEEakGM3cAAIAJBCGoQPiACQSBqJAALaAECfyABKAIAIQMCQAJAAkAgAUEIaigCACIBRQRAQQEhAgwBCyABQX9MDQEgAUEBEIEDIgJFDQILIAIgAyABEKwDIQIgACABNgIIIAAgATYCBCAAIAI2AgAPCxCuAgALIAFBARCkAwALWQEBfyMAQSBrIgIkACACIAAoAgA2AgQgAkEYaiABQRBqKQIANwMAIAJBEGogAUEIaikCADcDACACIAEpAgA3AwggAkEEakGA5MAAIAJBCGoQPiACQSBqJAALVgEBfyMAQSBrIgIkACACIAA2AgQgAkEYaiABQRBqKQIANwMAIAJBEGogAUEIaikCADcDACACIAEpAgA3AwggAkEEakGcisAAIAJBCGoQPiACQSBqJAALYAACQAJAAkACQAJAIAAoAgAOBwECAwMEAwMACyAAQQRqIgAQvQEgABCwAg8LIABBEGoQqQIgAEEcaiIAEPgBIAAQsQIPCyAAQRBqIgAQ+AEgABCxAgsPCyAAQQRqEKkCC1YBAX8jAEEgayICJAAgAiAANgIEIAJBGGogAUEQaikCADcDACACQRBqIAFBCGopAgA3AwAgAiABKQIANwMIIAJBBGpB3KLAACACQQhqED4gAkEgaiQAC0gBAn8CQCABRQRAQQEhAgwBCyABQQBOBEAgASABQX9zQR92IgMQgQMiAg0BIAEgAxCkAwALEK4CAAsgACABNgIEIAAgAjYCAAtdAQJ/IABBDGooAgAiAiACQX9qIgMgACgCBCICIAAoAgBrcWtBAUYEQCAAEJ8BIAAoAgxBf2ohAyAAKAIEIQILIAAgAkEBaiADcTYCBCAAKAIIIAJBAnRqIAE2AgALVgEBfyMAQSBrIgIkACACIAA2AgQgAkEYaiABQRBqKQIANwMAIAJBEGogAUEIaikCADcDACACIAEpAgA3AwggAkEEakGA5MAAIAJBCGoQPiACQSBqJAALYgEBfyMAQUBqIgEkACABQQA6AA8gAEEANgIIIABCATcCACABQRBqIABB7IbAABDGAiABQQ9qIAFBEGoQogEEQEGEh8AAQTcgAUE4akG8h8AAQZiIwAAQxAEACyABQUBrJAALXQEBfyMAQRBrIgQkACABKAIAIAIoAgAgAygCABAmIQIgBEEIahDLAiAAAn8gBCgCCEUEQCAAIAJBAEc6AAFBAAwBCyAAQQRqIAQoAgw2AgBBAQs6AAAgBEEQaiQAC1YBAX8CQCAAKAIAIgBBEGooAgAiAUUNACABQQA6AAAgAEEUaigCAEUNACAAKAIQEDELAkAgAEF/Rg0AIAAgACgCBCIBQX9qNgIEIAFBAUcNACAAEDELC1UBA38CQAJAAkBBkP7AACgCACIBQQFqIgBB/////wBxIABGBEAgASAAQQR0IgBqQQlqIgIgAE8NAQsMAQsgAkUNAUGU/sAAKAIAIABrIQELIAEQMQsLYAECfyMAQRBrIgEkACABQaSCwABBFRCXAkEMQQQQgQMiAkUEQEEMQQQQpAMACyACIAEpAwA3AgAgAkEIaiABQQhqKAIANgIAIABBiIXAADYCBCAAIAI2AgAgAUEQaiQAC2QCAn8BfiMAQRBrIgIkAEEAQbSBwAAoAgARBgAiAQRAIAEgASkDACIDQgF8NwMAIAAgASkDCDcDCCAAIAM3AwAgAkEQaiQADwtBtIXAAEHGACACQQhqQfyFwABB3IbAABDEAQALVAEBfyMAQTBrIgEkACABQRBqQdOIwABBBRCXAiABQShqIAFBGGooAgA2AgAgASABKQMQNwMgIAFBCGogAUEgahC9AiAAIAEpAwg3AwAgAUEwaiQAC1ABAX8jAEEQayIEJAAgASACIAMoAgAQEyECIARBCGoQywICf0EAIAQoAghFDQAaIAQoAgwhAkEBCyEBIAAgAjYCBCAAIAE2AgAgBEEQaiQAC1oBAX8jAEEQayIDJAACQAJAIAAoAgQgAWsgAk8NACADQQhqIAAgASACEIEBIAMoAgwiAEGBgICAeEYNACAARQ0BIAMoAgggABCkAwALIANBEGokAA8LEK4CAAtQAQJ/IwBBEGsiASQAIAEgAEF4ajYCCCAAQRRqIgAtAAAgAEEBOgAAIAEgAUEIajYCDEEBcUUEQCABQQxqENcBCyABQQhqELkBIAFBEGokAAtNAQF/IwBBMGsiASQAIAFBEGoQ6QEgAUEoaiABQRhqKAIANgIAIAEgASkDEDcDICABQQhqIAFBIGoQvQIgACABKQMINwMAIAFBMGokAAtaAQJ/IwBBIGsiAiQAIAJBCGogASgCABARIAIoAgghASACIAIoAgwiAzYCGCACIAM2AhQgAiABNgIQIAIgAkEQahC9AiAAIAIoAgAgAigCBBDvAiACQSBqJAALTAECfyMAQRBrIgIkACABKAIAEBIhASACQQhqEMsCAn9BACACKAIIRQ0AGiACKAIMIQFBAQshAyAAIAE2AgQgACADNgIAIAJBEGokAAtWAQJ/IAEoAgAhAiABQQA2AgACQCACBEAgASgCBCEDQQhBBBCBAyIBRQ0BIAEgAzYCBCABIAI2AgAgAEHkt8AANgIEIAAgATYCAA8LAAtBCEEEEKQDAAtnAQF/IwBBIGsiAyQAIAMgAjYCDCADQRBqIgJBgAI7AQQgAkEGakEAOgAAIAJB/QU2AgAgA0EQaiAAIAEgA0EMahAsBEBB6JrAAEEiIANBGGpBkJbAAEHkm8AAEMQBAAsgA0EgaiQAC0wBAn8gACgCCCIBBEAgACgCACEAIAFBBHQhAQNAIAAtAAAiAkF+akEHSSACRXJFBEAgAEEEahCpAgsgAEEQaiEAIAFBcGoiAQ0ACwsLUQEDfyMAQRBrIgEkACABQQhqEJsCEMACIAEoAgwhAgJAIAEoAghFBEBBASEDDAELIAJBJEkNACACEAALIAAgAjYCBCAAIAM2AgAgAUEQaiQAC2wBA38jAEEQayIBJAACQCAAKAIMIgIEQCAAKAIIIgNFDQEgASACNgIIIAEgADYCBCABIAM2AgAgASgCACABKAIEIAEoAggQuAEAC0Gwx8AAQStBvNPAABCkAgALQbDHwABBK0Gs08AAEKQCAAtIAQN/IwBBEGsiAiQAIAIgATYCDEEBIQEgAkEMaigCABAQQQBHIAIoAgwhAwRAQQAhAQsgACADNgIEIAAgATYCACACQRBqJAALSAEDfyMAQRBrIgIkACACIAE2AgxBASEBIAJBDGooAgAQGEEBRiACKAIMIQMEQEEAIQELIAAgAzYCBCAAIAE2AgAgAkEQaiQAC0sBAX8CQCAAQQNwQQNzQQNwIgMEQEEAIQADQCAAIAJGDQIgACABakE9OgAAIAMgAEEBaiIARw0ACwsgAw8LIAIgAkH0tMAAENIBAAtYAQJ/IwBBEGsiASQAIAEgADYCBEEAQezCwAAoAgARBgAiAgRAIAIgABC3ASABQRBqJAAPCyABQQRqELkBQbi+wABBxgAgAUEIakGAv8AAQeC/wAAQxAEAC0gBAn8jAEEQayIBJAAgASAAQXhqNgIIIABBFGoiAC0AACAAQQE6AAAgASABQQhqNgIMQQFxRQRAIAFBDGoQ1wELIAFBEGokAAtRAQF/IwBBEGsiBCQAIAEoAgAgAigCACADKAIAEB8hASAEQQhqEMsCIAQoAgwhAiAAIAQoAggiA0EARzYCACAAIAIgASADGzYCBCAEQRBqJAALSAICfwJ+IAFBEGooAgAiAiACrSIEIAEpAwAiBSAFIARWG6ciA0kEQCADIAIQpQMACyAAIAIgA2s2AgQgACABKAIIIANqNgIAC0ABAX8jAEEgayIAJAAgAEEcakEANgIAIABBiNzAADYCGCAAQgE3AgwgAEGk3MAANgIIIABBCGpB/NzAABCvAgALQwEDfwJAIAJFDQADQCAALQAAIgQgAS0AACIFRgRAIABBAWohACABQQFqIQEgAkF/aiICDQEMAgsLIAQgBWshAwsgAwtIAQJ/IAAtAABBA0YEQCAAQQRqKAIAIgEoAgAgASgCBCgCABECACABKAIEIgIoAgQEQCACKAIIGiABKAIAEDELIAAoAgQQMQsLSwEBfyMAQRBrIgIkACACQQhqIAAgAUEBEJABAkAgAigCDCIAQYGAgIB4RwRAIABFDQEgAigCCCAAEKQDAAsgAkEQaiQADwsQrgIAC0sBAX8jAEEQayIDJAAgA0EIaiAAIAEgAhCQAQJAIAMoAgwiAEGBgICAeEcEQCAARQ0BIAMoAgggABCkAwALIANBEGokAA8LEK4CAAtIAQF/IwBBEGsiAiQAIAJBCGogACABEHkCQCACKAIMIgBBgYCAgHhHBEAgAEUNASACKAIIIAAQpAMACyACQRBqJAAPCxCuAgALSwEBfyMAQRBrIgIkACACQQhqIAAgAUEBEIoBAkAgAigCDCIAQYGAgIB4RwRAIABFDQEgAigCCCAAEKQDAAsgAkEQaiQADwsQrgIAC0gBAX8jAEEQayICJAAgAkEIaiAAIAEQegJAIAIoAgwiAEGBgICAeEcEQCAARQ0BIAIoAgggABCkAwALIAJBEGokAA8LEK4CAAtLAQF/IwBBEGsiAyQAIANBCGogACABIAIQigECQCADKAIMIgBBgYCAgHhHBEAgAEUNASADKAIIIAAQpAMACyADQRBqJAAPCxCuAgALUAEBf0EgQQQQgQMiAUUEQEEgQQQQpAMACyABQoGAgIAQNwIAIAEgACkCADcCCCABQRBqIABBCGopAgA3AgAgAUEYaiAAQRBqKQIANwIAIAELSwEBfyAAKAIAIgEEQCABIAAoAgQoAgARAgAgACgCBCIBKAIEBEAgASgCCBogACgCABAxCyAAQQhqKAIAIABBDGooAgAoAgwRAgALC04BAn8jAEEQayICJAAgACgCACEDIABBADYCACADRQRAQbjAwABBHBCeAwALIAIgAzYCDCADQQhqQQEgARCJASACQQxqEKwBIAJBEGokAAtOAQJ/IwBBEGsiAiQAIAAoAgAhAyAAQQA2AgAgA0UEQEG4wMAAQRwQngMACyACIAM2AgwgA0EIakEAIAEQiQEgAkEMahCsASACQRBqJAALSwEBfyAAKAIAIgBBBGooAgAgACgCCCIDayACSQRAIAAgAyACEIIBIAAoAgghAwsgACgCACADaiABIAIQrAMaIAAgAiADajYCCEEAC0sBAX8gACgCACIAQQRqKAIAIAAoAggiA2sgAkkEQCAAIAMgAhCEASAAKAIIIQMLIAAoAgAgA2ogASACEKwDGiAAIAIgA2o2AghBAAtLAAJAAn8gAUGAgMQARwRAQQEgACgCGCABIABBHGooAgAoAhARAAANARoLIAINAUEACw8LIAAoAhggAiADIABBHGooAgAoAgwRAwALSAEBfyMAQRBrIgIkACACQQhqIAAgARBwAkAgAigCDCIAQYGAgIB4RwRAIABFDQEgAigCCCAAEKQDAAsgAkEQaiQADwsQrgIAC0gBAX8gACgCBCAAKAIIIgNrIAIgAWsiAkkEfyAAIAMgAhCGAiAAKAIIBSADCyAAKAIAaiABIAIQrAMaIAAgACgCCCACajYCCAtIAQF/IwBBEGsiAiQAIAJBCGogACABEHMCQCACKAIMIgBBgYCAgHhHBEAgAEUNASACKAIIIAAQpAMACyACQRBqJAAPCxCuAgALSAEBfyMAQRBrIgIkACACQQhqIAAgARBxAkAgAigCDCIAQYGAgIB4RwRAIABFDQEgAigCCCAAEKQDAAsgAkEQaiQADwsQrgIAC0ACAn8BfiMAQRBrIgEkACABQQhqIABBCGooAgAiAjYCACABIAApAgAiAzcDACADpyACEAUgARCpAiABQRBqJAALRwECfyMAQRBrIgMkACADQQhqIAIQ5gEgAygCCCEEIAAgAygCDDYCBCAAIAQ2AgAgBCABIAIQrAMaIAAgAjYCCCADQRBqJAALRgEBfyAAKAIEIAAoAggiA2sgAiABayICSQRAIAAgAyACEIoCIAAoAgghAwsgACgCACADaiABIAIQrAMaIAAgAiADajYCCAtGAQF/IAAoAgAiACAAKAIAQX9qIgE2AgACQCABDQAgAEEMahCoASAAQRRqELICIAAgACgCBEF/aiIBNgIEIAENACAAEDELCzwAAkAgBCADTwRAIAQgAksNASAAIAQgA2s2AgQgACABIANBAnRqNgIADwsgAyAEEKcDAAsgBCACEKYDAAtJAQJ/IwBBEGsiASQAQQBBkMPAACgCABEGACIABEAgACgCABABIAFBEGokAA8LQc/DwABBxgAgAUEIakGYxMAAQfjEwAAQxAEAC0YBAn8jAEEQayIDJAAgASACECQhASADQQhqEMsCIAMoAgwhAiAAIAMoAggiBEEARzYCACAAIAIgASAEGzYCBCADQRBqJAALRwEDfyMAQRBrIgIkACABKAIAECUhASACQQhqEMsCIAIoAgwhAyAAIAIoAggiBEEARzYCACAAIAMgASAEGzYCBCACQRBqJAALQAECfyAAKAIIIgEEQCAAKAIAIQAgAUECdCEBA0AgACgCACICQSRPBEAgAhAACyAAQQRqIQAgAUF8aiIBDQALCwtGAQF/IwBBgANrIgEkACABIABB+AIQrAMiACAANgL8AiAAQfwCakGogMAAECAgAC0AtgFBBEcEQCAAENsCCyAAQYADaiQACzoBAX8jAEEQayIAJABBpP7AACgCAEEDRwRAIABBAToACyAAIABBC2o2AgwgAEEMahBFCyAAQRBqJAALTgEBfyMAQSBrIgAkACAAQRRqQQE2AgAgAEIBNwIEIABBzJbAADYCACAAQRk2AhwgAEHwmcAANgIYIAAgAEEYajYCECAAQfiZwAAQrwIAC0UBAX8jAEEQayICJAAgACgCACIARQRAQbjAwABBHBCeAwALIAIgADYCDCAAQQhqQQAgARCJASACQQxqEKwBIAJBEGokAAtFAQF/IwBBEGsiAiQAIAAoAgAiAEUEQEG4wMAAQRwQngMACyACIAA2AgwgAEEIakEBIAEQiQEgAkEMahCsASACQRBqJAALSAEBfyMAQSBrIgMkACADQRRqQQA2AgAgA0Hc3sAANgIQIANCATcCBCADIAE2AhwgAyAANgIYIAMgA0EYajYCACADIAIQrwIAC0kBAX8jAEEgayICJAAgAkEUakEBNgIAIAJCATcCBCACQazgwAA2AgAgAkGHATYCHCACIAA2AhggAiACQRhqNgIQIAIgARCvAgALQAACQAJAAkAgAC0AtgEOBAECAgACCyAAEKcBIABBkAFqEKkCDwsgAEH4AGoQqQIgAEGEAWoiABCeAiAAEKgCCws9AQF/IAACf0EAIAEoAgQiAkUNABogASgCACEBIAAgAkECdDYCBCAAIAE2AgAgAkGAgICAAklBAnQLNgIICzUBAX8jAEEQayIBJAAgASAAEKcCAkAgASgCCEUNACABKAIERQ0AIAEoAgAQMQsgAUEQaiQACzUBAX8jAEEQayIBJAAgASAAEK0CAkAgASgCCEUNACABKAIERQ0AIAEoAgAQMQsgAUEQaiQAC0YBAn8gASgCBCECIAEoAgAhA0EIQQQQgQMiAUUEQEEIQQQQpAMACyABIAI2AgQgASADNgIAIABB3NPAADYCBCAAIAE2AgALPwEBf0EMQQQQgQMiAkUEQEEMQQQQpAMACyACQSU6AAggAkGIhcAANgIEIAIgATYCACAAIAKtQiCGQgOENwIACzkBAX8gAUEQdkAAIQIgAEEANgIIIABBACABQYCAfHEgAkF/RiIBGzYCBCAAQQAgAkEQdCABGzYCAAsyAQF/IAACf0EAIAEoAgQiAkUNABogACACNgIEIAAgASgCADYCACACQX9zQR92CzYCCAtAAQF/IwBBIGsiACQAIABBHGpBADYCACAAQaTdwAA2AhggAEIBNwIMIABB1N3AADYCCCAAQQhqQdzdwAAQrwIACz8BAX8jAEEgayICJAAgAkEBOgAYIAIgATYCFCACIAA2AhAgAkG04MAANgIMIAJB3N7AADYCCCACQQhqEPoBAAspAQF/AkAgACgCBCIBRQ0AIAAoAgAgAUEobEUgAUGz5swZS3INABAxCwspAQF/AkAgACgCBCIBRQ0AIAAoAgAgAUEEdEUgAUH///8/S3INABAxCwsqAQF/AkAgACgCBCIBRQ0AIAAoAgAgAUECdEUgAUH/////AUtyDQAQMQsLMwACQCAAQfz///8HSw0AIABFBEBBBA8LIAAgAEH9////B0lBAnQQgQMiAEUNACAADwsACzQBAn8gAUF4aiICIAIoAgAiAkEBaiIDNgIAIAMgAkkEQAALIABB8MLAADYCBCAAIAE2AgALMwEBf0E0QQQQgQMiAUUEQEE0QQQQpAMACyABQoGAgIAQNwIAIAFBCGogAEEsEKwDGiABCy8BAX8jAEEQayICJAAgAiAAKAIANgIMIAJBDGogARBuIAJBDGoQmQIgAkEQaiQACz4AIAAoAgAhACABLQAAQRBxQQR2RQRAIAEtAABBIHFBBXZFBEAgACABEJEDDwsgACABEKsBDwsgACABEKoBCyIBAX8CQCAAKAIEIgFFDQAgAEEIaigCAEEBSA0AIAEQMQsLKQAjAEEQayIAJAAgAEEIaiABQdvHwAAQxwIgAEEIahDGASAAQRBqJAALKQAjAEEQayIAJAAgAEEIaiABQaTRwAAQxwIgAEEIahCYASAAQRBqJAALLQAgACgCACIALQAAIABBADoAAEEBcUUEQEHIk8AAQStBwJTAABCkAgALEJUBCzIBAX8gACABKAIEIAEoAggiAksEfyABIAIQlAIgASgCCAUgAgs2AgQgACABKAIANgIACzIBAX8gACABKAIEIAEoAggiAksEfyABIAIQlQIgASgCCAUgAgs2AgQgACABKAIANgIACzoBAX8gACgCACEBAkAgAC0ABA0AQfj+wAAoAgBB/////wdxRQ0AELEDDQAgAUEBOgABCyABQQA6AAALIwAgACgCACIAQXBqEKkCIABBfGooAgAiAEEkTwRAIAAQAAsLIwEBfwJ/QQEgARAORQ0AGkEACyECIAAgATYCBCAAIAI2AgALMQEBf0EEQQQQgQMiAkUEQEEEQQQQpAMACyACIAE2AgAgAEGQwMAANgIEIAAgAjYCAAsxAQF/QQRBBBCBAyICRQRAQQRBBBCkAwALIAIgATYCACAAQaTAwAA2AgQgACACNgIACyoBAX8gACgCAARAIAAQmQIgACgCBCIBQSRPBEAgARAACyAAQQhqEOgCCwsuAQF/IAAoAgAgACgCBCgCABECACAAKAIEIgEoAgQEQCABKAIIGiAAKAIAEDELC0ABAX8jAEEQayIEJAAgBCADNgIMIAQgAjYCCCAEIAE2AgQgBCAANgIAIAQoAgAgBCgCBCAEKAIIIAQoAgwQLwALNAAgAEEDOgAgIABCgICAgIAENwIAIAAgATYCGCAAQQA2AhAgAEEANgIIIABBHGogAjYCAAswACABKAIYIAJBCyABQRxqKAIAKAIMEQMAIQIgAEEAOgAFIAAgAjoABCAAIAE2AgALJwAgACAAKAIEQQFxIAFyQQJyNgIEIAAgAWoiACAAKAIEQQFyNgIECyYAAkAgAEUNACAAIAEoAgARAgAgASgCBEUNACABKAIIGiAAEDELCyYBAX8jAEEQayIBJAAgASAAQXhqNgIMIAFBDGoQuQEgAUEQaiQACzoBAn9B3P7AAC0AACEBQdz+wABBADoAAEHg/sAAKAIAIQJB4P7AAEEANgIAIAAgAjYCBCAAIAE2AgALFwAgAEEEaigCAEEBTgRAIAAoAgAQMQsLJgEBfyMAQRBrIgMkACADIAE2AgwgAyAANgIIIANBCGogAhClAgALEwAgACABKQAANwABIABBADoAAAsmAQF/IABBB2oiASAASQRAQbS2wABBM0HAt8AAEJIDAAsgAUEDdgsjAAJAIAFB/P///wdNBEAgACABQQQgAhDxAiIADQELAAsgAAsjACACIAIoAgRBfnE2AgQgACABQQFyNgIEIAAgAWogATYCAAseACAAKAIAIgCtQgAgAKx9IABBf0oiABsgACABEF4LJQAgAEUEQEGfw8AAQTAQngMACyAAIAIgAyAEIAUgASgCEBEMAAsgAQF/IAAoAgQgACgCCCICayABSQRAIAAgAiABEIoCCwsjACAARQRAQZ/DwABBMBCeAwALIAAgAiADIAQgASgCEBEFAAsjACAARQRAQZ/DwABBMBCeAwALIAAgAiADIAQgASgCEBERAAsjACAARQRAQZ/DwABBMBCeAwALIAAgAiADIAQgASgCEBEJAAsjACAARQRAQZ/DwABBMBCeAwALIAAgAiADIAQgASgCEBESAAsXACABIANGBH8gACACIAEQgwJFBUEACwseACAAIAFBA3I2AgQgACABaiIAIAAoAgRBAXI2AgQLJQACQAJAAkAgAC0A8AIOBAECAgACCyAAQbgBahBsDwsgABBsCwshACAARQRAQZ/DwABBMBCeAwALIAAgAiADIAEoAhARBAALHQAgASgCAEUEQAALIABB5LfAADYCBCAAIAE2AgALHwAgAEUEQEGIvsAAQTAQngMACyAAIAIgASgCEBEBAAsfACAARQRAQZ/DwABBMBCeAwALIAAgAiABKAIQEQAACxQAIAAoAgRBAU4EQCAAKAIAEDELCxcAIAAoAgQEQCAAEOgCIABBDGoQ6AILCx0BAX9BqP7AACEBQaj+wAAoAgAEfyABBSAAEHcLCxUBAX8gACgCACAAKAIIEAUgABDgAgseAQF/QcD+wAAhAUG8/sAAKAIABH8gAQUgABDKAQsLGQEBfyAAKAIQIgEEfyABBSAAQRRqKAIACwsZACABIAIgAxCEAyAAQQA2AgAgACADNgIECxUAIAAtAARBBEcEQCAAQQRqEIQCCwsUACAAKAIAEBQEQCAAQQRqEMQCCwsZACAAIAFBCGooAgA2AgQgACABKAIANgIACxIAQQBBGSAAQQF2ayAAQR9GGwsWACAAIAFBAXI2AgQgACABaiABNgIACxwAIAEoAhhBlN/AAEELIAFBHGooAgAoAgwRAwALHAAgASgCGEGf38AAQQ4gAUEcaigCACgCDBEDAAscACABKAIYQeD2wABBBSABQRxqKAIAKAIMEQMACxcAIAAgAjYCCCAAIAI2AgQgACABNgIACxAAIAAgAWpBf2pBACABa3ELDAAgACABIAIgAxA3CxMAIAAoAgAgASABIAJqEJMCQQALCwAgAQRAIAAQMQsLFAAgACgCACAAQQhqKAIAIAEQqAMLEwAgACgCACAAQQhqKAIAIAEQMAsPACAAQQF0IgBBACAAa3ILFQAgASAAKAIAIgAoAgAgACgCBBA0CxMAIAAoAgAoAgAgASACEIQDQQALEgAgASACIAMQhAMgAEEEOgAACwoAIABBCGoQqQILEAAgACABIAEgAmoQkwJBAAsPACAAKAIABEAgABCsAQsLFAAgACgCACABIAAoAgQoAgwRAAALDgAgACgCACABEHgaQQALEAAgACgCACABIAIQhANBAAsRACAAKAIAIAAoAgggARCoAwsIACAAIAEQTgsRACAAKAIAIAAoAgQgARCoAwsQACAAIAI2AgQgACABNgIACw4AIAAgASABIAJqEJgCCxYAQeD+wAAgADYCAEHc/sAAQQE6AAALDQAgACgCACABEFtBAAsTACAAQdzTwAA2AgQgACABNgIACw0AIAAtAARBAnFBAXYLEAAgASAAKAIAIAAoAgQQNAsNACAAIAEgAhCEA0EACwoAQQAgAGsgAHELCwAgAC0ABEEDcUULDAAgACABQQNyNgIECw0AIAAoAgAgACgCBGoLDQAgACgCACABEFxBAAsOACAAKAIAGgNADAALAAsNACAANQIAQQEgARBeCwwAIAAgASACEM0CAAsNACAAKAIAIAEgAhA5Cw0AIAAzAQBBASABEF4LCwAgACMAaiQAIwALCgAgACABIAIQRAsLACAAIAIgARCOAQsHACAAEKkCCw0AIAFB0JTAAEECEDQLBwAgABDgAgsMACAAIAEpAgA3AgALCwAgACgCACABEFELCwAgACABQdUAECkLCQAgACABECgACykAAn8gACgCAC0AAEUEQCABQZzkwABBBRA0DAELIAFBmOTAAEEEEDQLCwoAIAAoAgRBeHELCgAgACgCBEEBcQsKACAAKAIMQQFxCwoAIAAoAgxBAXYLGgAgACABQej+wAAoAgAiAEHyACAAGxEBAAALCgAgACABEM8BAAsKACAAIAEQ0QEACwoAIAAgARDQAQALCgAgAiAAIAEQNAsLACAAKAIAIAEQYQsLACAAKAIAIAEQXwsNACABQaHkwABBAhA0CwoAIAAgASACEF0LCwAgACABIAIQlAELBwAgABC1AQsJACAAQQQ6AAALCQAgAEEANgIACwsAQeSCwQAoAgBFCwcAIAAgAWoLBwAgACABawsHACAAQQhqCwcAIABBeGoLBwAgABDOAQsGACABEHULBwAgABCZAgsEAEEBCw0AQrbC0e/0t9L96QALDQBCi+TnlfK4j9e4fwsMAEK1oZLQws6BwTYLDABCzYve/MCC+5coCwMAAQsDAAELC8Z9BQBBgIDAAAvhEGB1bndyYXBfdGhyb3dgIGZhaWxlZAAAAAEAAAAAAwAACAAAAAIAAAADAAAABAAAAAQAAAAEAAAABQAAAC9ob21lL25nbml1cy8uY2FyZ28vcmVnaXN0cnkvc3JjL2dpdGh1Yi5jb20tMWVjYzYyOTlkYjllYzgyMy9jb25zb2xlX2Vycm9yX3BhbmljX2hvb2stMC4xLjcvc3JjL2xpYi5ycwAAPAAQAGYAAACVAAAADgAAAAYAAAAvcnVzdGMvMjBmZmVhNjkzOGI1ODM5YzM5MDI1MmUwNzk0MGI5OWUzYjZhODg5YS9saWJyYXJ5L3N0ZC9zcmMvaW8vbW9kLnJzAAAAuAAQAEkAAAA2AwAAHwAAALgAEABJAAAAPQMAABAAAABmYWlsZWQgdG8gZmlsbCBidWZmZXJmYWlsZWQgdG8gZmlsbCB3aG9sZSBidWZmZXI5ARAAGwAAACUAAAAvcnVzdGMvMjBmZmVhNjkzOGI1ODM5YzM5MDI1MmUwNzk0MGI5OWUzYjZhODg5YS9saWJyYXJ5L3N0ZC9zcmMvaW8vaW1wbHMucnMAYAEQAEsAAADyAAAADQAAAC9ydXN0Yy8yMGZmZWE2OTM4YjU4MzljMzkwMjUyZTA3OTQwYjk5ZTNiNmE4ODlhL2xpYnJhcnkvc3RkL3NyYy9pby9jdXJzb3IucnO8ARAATAAAAOsAAAAKAAAAL3J1c3RjLzIwZmZlYTY5MzhiNTgzOWMzOTAyNTJlMDc5NDBiOTllM2I2YTg4OWEvbGlicmFyeS9zdGQvc3JjL2lvL3JlYWRidWYucnMAAAAYAhAATQAAAOQAAAArAAAABwAAAAwAAAAEAAAACAAAAAcAAAAMAAAABAAAAAkAAAAIAAAAeAIQAAoAAAALAAAADAAAAA0AAAAOAAAAY2Fubm90IGFjY2VzcyBhIFRocmVhZCBMb2NhbCBTdG9yYWdlIHZhbHVlIGR1cmluZyBvciBhZnRlciBkZXN0cnVjdGlvbgAAAwAAAAAAAAABAAAADwAAAC9ydXN0Yy8yMGZmZWE2OTM4YjU4MzljMzkwMjUyZTA3OTQwYjk5ZTNiNmE4ODlhL2xpYnJhcnkvc3RkL3NyYy90aHJlYWQvbG9jYWwucnMADAMQAE8AAAClAQAACQAAAAcAAAAMAAAABAAAABAAAAARAAAAEgAAAGEgRGlzcGxheSBpbXBsZW1lbnRhdGlvbiByZXR1cm5lZCBhbiBlcnJvciB1bmV4cGVjdGVkbHkAAwAAAAAAAAABAAAAEwAAAC9ydXN0Yy8yMGZmZWE2OTM4YjU4MzljMzkwMjUyZTA3OTQwYjk5ZTNiNmE4ODlhL2xpYnJhcnkvYWxsb2Mvc3JjL3N0cmluZy5ycwDMAxAASwAAALkJAAAJAAAAY2FsbGVkIGBPcHRpb246OnVud3JhcCgpYCBvbiBhIGBOb25lYCB2YWx1ZTAuNi4ydXNkcGwtZnJvbnQvc3JjL2xpYi5ycwAAWAQQABYAAABgAAAAGAAAAFgEEAAWAAAAaAAAABgAAAAvcnVzdGMvMjBmZmVhNjkzOGI1ODM5YzM5MDI1MmUwNzk0MGI5OWUzYjZhODg5YS9saWJyYXJ5L3N0ZC9zcmMvaW8vbW9kLnJzAAAAkAQQAEkAAABQAQAAGAAAAHN0cmVhbSBkaWQgbm90IGNvbnRhaW4gdmFsaWQgVVRGLTgAAOwEEAAiAAAAFQAAABQAAAAEAAAABAAAABUAAAAWAAAAFwAAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAFAAAAAAAAAABAAAAGAAAAC9ob21lL25nbml1cy8uY2FyZ28vcmVnaXN0cnkvc3JjL2dpdGh1Yi5jb20tMWVjYzYyOTlkYjllYzgyMy9iYXNlNjQtMC4xMy4wL3NyYy9jaHVua2VkX2VuY29kZXIucnMAAABwBRAAYQAAAC0AAAAaAAAAcAUQAGEAAAA3AAAARAAAAHAFEABhAAAAOgAAACcAAAAvaG9tZS9uZ25pdXMvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9naXRodWIuY29tLTFlY2M2Mjk5ZGI5ZWM4MjMvYmFzZTY0LTAuMTMuMC9zcmMvZW5jb2RlLnJzBAYQAFgAAAC2AAAAIAAAAAQGEABYAAAAtwAAACUAAAAEBhAAWAAAAPwAAAAcAAAABAYQAFgAAAD9AAAAIQAAAAQGEABYAAAAEwEAAC4AAAAEBhAAWAAAABMBAAAJAAAABAYQAFgAAAAUAQAACQAAAAQGEABYAAAACwEAAC4AAAAEBhAAWAAAAAsBAAAJAAAABAYQAFgAAAANAQAADwAAAAQGEABYAAAADAEAAAkAAAAEBhAAWAAAAA8BAAAJAAAABAYQAFgAAACgAAAAKgAAAB4AAAAMAAAABAAAAB8AAAAgAAAAIQAAACIAAAAjAAAAJAAAACUAAAAvaG9tZS9uZ25pdXMvRG9jdW1lbnRzL2dpdC1yZXBvcy91c2RwbC1ycy91c2RwbC1jb3JlL3NyYy9zZXJkZXMvdHJhaXRzLnJzAAAAVAcQAEkAAAB2AAAAHAAAACYAAAAYAAAACAAAACcAAAAoAAAAKQAAACoAAAArAAAALAAAAC0AAAAuAAAAYHVud3JhcF90aHJvd2AgZmFpbGVkL2hvbWUvbmduaXVzLy5jYXJnby9yZWdpc3RyeS9zcmMvZ2l0aHViLmNvbS0xZWNjNjI5OWRiOWVjODIzL3dhc20tYmluZGdlbi1mdXR1cmVzLTAuNC4zMS9zcmMvbGliLnJz8QcQAGMAAADaAAAAIABB8JDAAAucVmBhc3luYyBmbmAgcmVzdW1lZCBhZnRlciBjb21wbGV0aW9uAC8AAAAAAAAAAQAAADAAAAAxAAAAMgAAAGZhaWxlZCB0byB3cml0ZSB3aG9sZSBidWZmZXKsCBAAHAAAABcAAAAzAAAADAAAAAQAAAA0AAAANQAAADYAAABmb3JtYXR0ZXIgZXJyb3IA7AgQAA8AAAAoAAAAL3J1c3RjLzIwZmZlYTY5MzhiNTgzOWMzOTAyNTJlMDc5NDBiOTllM2I2YTg4OWEvbGlicmFyeS9zdGQvc3JjL2lvL21vZC5ycwAAAAgJEABJAAAAGgUAABYAAAAICRAASQAAAB4FAAANAAAAYWR2YW5jaW5nIGlvIHNsaWNlcyBiZXlvbmQgdGhlaXIgbGVuZ3RoAHQJEAAnAAAACAkQAEkAAAAcBQAADQAAAC8AAAAEAAAABAAAADcAAAA4AAAAY2FsbGVkIGBPcHRpb246OnVud3JhcCgpYCBvbiBhIGBOb25lYCB2YWx1ZS9ydXN0Yy8yMGZmZWE2OTM4YjU4MzljMzkwMjUyZTA3OTQwYjk5ZTNiNmE4ODlhL2xpYnJhcnkvc3RkL3NyYy9zeW5jL29uY2UucnMA8wkQAEwAAAAUAQAAKQAAACgpAAA5AAAADAAAAAQAAAA6AAAAOwAAABIAAABhIERpc3BsYXkgaW1wbGVtZW50YXRpb24gcmV0dXJuZWQgYW4gZXJyb3IgdW5leHBlY3RlZGx5AC8AAAAAAAAAAQAAABMAAAAvcnVzdGMvMjBmZmVhNjkzOGI1ODM5YzM5MDI1MmUwNzk0MGI5OWUzYjZhODg5YS9saWJyYXJ5L2FsbG9jL3NyYy9zdHJpbmcucnMAtAoQAEsAAAC5CQAACQAAAC8AAAAAAAAAAQAAADwAAABpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiAAACALEAAqAAAAL2hvbWUvbmduaXVzLy5jYXJnby9yZWdpc3RyeS9zcmMvZ2l0aHViLmNvbS0xZWNjNjI5OWRiOWVjODIzL2Jhc2U2NC0wLjEzLjAvc3JjL2RlY29kZS5yc1QLEABYAAAA0gEAAB8AAABUCxAAWAAAANgBAAAfAAAAVAsQAFgAAADhAQAAHwAAAFQLEABYAAAA6gEAAB8AAABUCxAAWAAAAPMBAAAfAAAAVAsQAFgAAAD8AQAAHwAAAFQLEABYAAAABQIAAB8AAABUCxAAWAAAAA4CAAAfAAAAVAsQAFgAAAADAQAAJAAAAFQLEABYAAAABAEAACkAAABUCxAAWAAAACoBAAAWAAAAVAsQAFgAAAAtAQAAGgAAAFQLEABYAAAAQQEAAA4AAABUCxAAWAAAAEQBAAASAAAAVAsQAFgAAABYAQAAEwAAAEltcG9zc2libGU6IG11c3Qgb25seSBoYXZlIDAgdG8gOCBpbnB1dCBieXRlcyBpbiBsYXN0IGNodW5rLCB3aXRoIG5vIGludmFsaWQgbGVuZ3Roc5wMEABUAAAAVAsQAFgAAACdAQAADgAAAFQLEABYAAAAsQEAAAkAAABPdmVyZmxvdyB3aGVuIGNhbGN1bGF0aW5nIG91dHB1dCBidWZmZXIgbGVuZ3RoAABUCxAAWAAAAJYAAAAKAAAAVAsQAFgAAACbAAAAIQAAAFdyaXRpbmcgdG8gYSBTdHJpbmcgc2hvdWxkbid0IGZhaWwvaG9tZS9uZ25pdXMvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9naXRodWIuY29tLTFlY2M2Mjk5ZGI5ZWM4MjMvYmFzZTY0LTAuMTMuMC9zcmMvZW5jb2RlLnJzAACKDRAAWAAAAFMAAAAOAAAAAAAAAP//////////dXNkcGwtZnJvbnQvc3JjL2Nvbm5lY3Rpb24ucnMAAAAADhAAHQAAABgAAAAmAAAAUE9TVGh0dHA6Ly86L3VzZHBsL2NhbGwANA4QAAcAAAA7DhAAAQAAADwOEAALAAAAbG9jYWxob3N0AAAAYA4QAAkAAABEdW1wZWQgYmFzZTY0IGBgIGxlbjoAAAB0DhAADwAAAIMOEAAGAAAAAA4QAB0AAAArAAAAJAAAAAAOEAAdAAAAMgAAACcAAABSZWNlaXZlZCBiYXNlNjQgYAAAALwOEAARAAAAgw4QAAYAAABFeHBlY3RlZCBjYWxsIHJlc3BvbnNlIG1lc3NhZ2UgZnJvbSAsIGdvdCBzb21ldGhpbmcgZWxzZeAOEAAkAAAABA8QABQAAAB1c2RwbC1mcm9udC9zcmMvY29udmVydC5ycwAAKA8QABoAAAAgAAAAJwAAAHVzZHBsLWZyb250L3NyYy9saWIucnMAAFQPEAAWAAAAbwAAAE4AAABjYWxsX2JhY2tlbmQoLCBbcGFyYW1zOyBdKQAAfA8QAA0AAACJDxAACwAAAJQPEAACAAAAVVNEUEw6IEdvdCBwb3J0ILAPEAAQAAAAVVNEUEw6IEdvdCBlcnJvciB3aGlsZSBjYWxsaW5nIDogAAAAyA8QAB8AAADnDxAAAgAAAFQPEAAWAAAAbgAAAAEAAABUcmllZCB0byBzaHJpbmsgdG8gYSBsYXJnZXIgY2FwYWNpdHkMEBAAJAAAAC9ydXN0Yy8yMGZmZWE2OTM4YjU4MzljMzkwMjUyZTA3OTQwYjk5ZTNiNmE4ODlhL2xpYnJhcnkvYWxsb2Mvc3JjL3Jhd192ZWMucnM4EBAATAAAAKoBAAAJAAAAPQAAAAwAAAAEAAAAPgAAAD8AAAASAAAAYSBEaXNwbGF5IGltcGxlbWVudGF0aW9uIHJldHVybmVkIGFuIGVycm9yIHVuZXhwZWN0ZWRseQBAAAAAAAAAAAEAAAATAAAAL3J1c3RjLzIwZmZlYTY5MzhiNTgzOWMzOTAyNTJlMDc5NDBiOTllM2I2YTg4OWEvbGlicmFyeS9hbGxvYy9zcmMvc3RyaW5nLnJzAPQQEABLAAAAuQkAAAkAAAAKClN0YWNrOgoKCgpBAAAABAAAAAQAAABCAAAAQwAAAEQAAABMb2FkRXJyb3I6IElvKCkAdBEQAA4AAACCERAAAQAAAExvYWRFcnJvcjogSW52YWxpZERhdGEAAJQREAAWAAAATG9hZEVycm9yOiBUb29TbWFsbEJ1ZmZlcgAAALQREAAZAAAARHVtcEVycm9yOiBJbygAANgREAAOAAAAghEQAAEAAABEdW1wRXJyb3I6IFVuc3VwcG9ydGVkAAD4ERAAFgAAAER1bXBFcnJvcjogVG9vU21hbGxCdWZmZXIAAAAYEhAAGQAAAGNyYW5rc2hhZnQAADwSEAAKAAAAZGVja3kAAABQEhAABQAAAGFueQBgEhAAAwAAACEiIyQlJicoKSorLC0wMTIzNDU2Nzg5QEFCQ0RFRkdISUpLTE1OUFFSU1RVVlhZWltgYWJjZGVoaWprbG1wcXJBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWmFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6MDEyMzQ1Njc4OSssLi9BQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWmFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6MDEyMzQ1Njc4OS4vMDEyMzQ1Njc4OUFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWmFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6MDEyMzQ1Njc4OS1fQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVphYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ejAxMjM0NTY3ODkrL////////////////////////////////////////////wABAgMEBQYHCAkKCwz//w0ODxAREhMUFRb///////8XGBkaGxwdHh8gISIjJCX/JicoKSorLP8tLi8w/////zEyMzQ1Nv//Nzg5Ojs8//89Pj//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////Pj////80NTY3ODk6Ozw9/////////wABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZ////////GhscHR4fICEiIyQlJicoKSorLC0uLzAxMjP//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wABNjc4OTo7PD0+P/////////8CAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaG////////xwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAQIDBAUGBwgJCgv/////////DA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCX///////8mJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8+//80NTY3ODk6Ozw9/////////wABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZ/////z//GhscHR4fICEiIyQlJicoKSorLC0uLzAxMjP//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////z7///8/NDU2Nzg5Ojs8Pf////////8AAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGf///////xobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIz/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////6wTEABsExAALBMQAOwSEACsEhAAbBIQAOwYEADsFxAA7BYQAOwVEADsFBAA7BMQAC9ob21lL25nbml1cy8uY2FyZ28vcmVnaXN0cnkvc3JjL2dpdGh1Yi5jb20tMWVjYzYyOTlkYjllYzgyMy9iYXNlNjQtMC4xMy4wL3NyYy9lbmNvZGUucnMcGhAAWAAAADsBAAAJAAAAY2FsbGVkIGBSZXN1bHQ6OnVud3JhcCgpYCBvbiBhbiBgRXJyYCB2YWx1ZQBGAAAACAAAAAQAAABHAAAAL2hvbWUvbmduaXVzLy5jYXJnby9yZWdpc3RyeS9zcmMvZ2l0aHViLmNvbS0xZWNjNjI5OWRiOWVjODIzL2Jhc2U2NC0wLjEzLjAvc3JjL2NodW5rZWRfZW5jb2Rlci5ycwAAAMAaEABhAAAAaAAAADAAAABPdmVyZmxvdyB3aGVuIGNhbGN1bGF0aW5nIG51bWJlciBvZiBjaHVua3MgaW4gaW5wdXQvaG9tZS9uZ25pdXMvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9naXRodWIuY29tLTFlY2M2Mjk5ZGI5ZWM4MjMvYmFzZTY0LTAuMTMuMC9zcmMvZGVjb2RlLnJzAGcbEABYAAAAvAAAAAoAAABIAAAACAAAAAQAAABJAAAASgAAAEgAAAAIAAAABAAAAEsAAABib2R5bWV0aG9kbW9kZXNhbWUtb3JpZ2lubm8tY29yc2NvcnNuYXZpZ2F0ZWF0dGVtcHRlZCB0byBjb252ZXJ0IGludmFsaWQgUmVxdWVzdE1vZGUgaW50byBKU1ZhbHVlL2hvbWUvbmduaXVzLy5jYXJnby9yZWdpc3RyeS9zcmMvZ2l0aHViLmNvbS0xZWNjNjI5OWRiOWVjODIzL3dlYi1zeXMtMC4zLjU4L3NyYy9mZWF0dXJlcy9nZW5fUmVxdWVzdE1vZGUucnNVHBAAawAAAAMAAAABAAAAYWxyZWFkeSBib3Jyb3dlZE8AAAAAAAAAAQAAAFAAAABhbHJlYWR5IG11dGFibHkgYm9ycm93ZWRPAAAAAAAAAAEAAABRAAAAYXNzZXJ0aW9uIGZhaWxlZDogbWlkIDw9IHNlbGYubGVuKCkvcnVzdGMvMjBmZmVhNjkzOGI1ODM5YzM5MDI1MmUwNzk0MGI5OWUzYjZhODg5YS9saWJyYXJ5L2FsbG9jL3NyYy9jb2xsZWN0aW9ucy92ZWNfZGVxdWUvbW9kLnJzYXNzZXJ0aW9uIGZhaWxlZDogc2VsZi5jYXAoKSA9PSBvbGRfY2FwICogMjsdEABeAAAA3QgAAAkAAAAvcnVzdGMvMjBmZmVhNjkzOGI1ODM5YzM5MDI1MmUwNzk0MGI5OWUzYjZhODg5YS9saWJyYXJ5L2FsbG9jL3NyYy9jb2xsZWN0aW9ucy92ZWNfZGVxdWUvcmluZ19zbGljZXMucnMAANQdEABmAAAAIAAAAA4AAADUHRAAZgAAACMAAAARAAAAL2hvbWUvbmduaXVzLy5jYXJnby9yZWdpc3RyeS9zcmMvZ2l0aHViLmNvbS0xZWNjNjI5OWRiOWVjODIzL3dhc20tYmluZGdlbi1mdXR1cmVzLTAuNC4zMS9zcmMvcXVldWUucnMAAABcHhAAZQAAABoAAAAuAAAAXB4QAGUAAAAdAAAAKQAAAFweEABlAAAAMgAAABoAAABSAAAABAAAAAQAAABTAAAAVAAAAGNsb3N1cmUgaW52b2tlZCByZWN1cnNpdmVseSBvciBkZXN0cm95ZWQgYWxyZWFkeWNhbm5vdCBhY2Nlc3MgYSBUaHJlYWQgTG9jYWwgU3RvcmFnZSB2YWx1ZSBkdXJpbmcgb3IgYWZ0ZXIgZGVzdHJ1Y3Rpb24AAFYAAAAAAAAAAQAAAA8AAAAvcnVzdGMvMjBmZmVhNjkzOGI1ODM5YzM5MDI1MmUwNzk0MGI5OWUzYjZhODg5YS9saWJyYXJ5L3N0ZC9zcmMvdGhyZWFkL2xvY2FsLnJzAJAfEABPAAAApQEAAAkAAABhbHJlYWR5IGJvcnJvd2VkVgAAAAAAAAABAAAAUAAAAFcAAAAEAAAABAAAAFgAAABZAAAAVwAAAAQAAAAEAAAAWgAAAFsAAABGbk9uY2UgY2FsbGVkIG1vcmUgdGhhbiBvbmNlL2hvbWUvbmduaXVzLy5jYXJnby9yZWdpc3RyeS9zcmMvZ2l0aHViLmNvbS0xZWNjNjI5OWRiOWVjODIzL3dhc20tYmluZGdlbi1mdXR1cmVzLTAuNC4zMS9zcmMvbGliLnJzAFQgEABjAAAApQAAAA8AAABUIBAAYwAAAIUAAAAnAAAAVCAQAGMAAACvAAAAJAAAAC9ob21lL25nbml1cy8uY2FyZ28vcmVnaXN0cnkvc3JjL2dpdGh1Yi5jb20tMWVjYzYyOTlkYjllYzgyMy93YXNtLWJpbmRnZW4tZnV0dXJlcy0wLjQuMzEvc3JjL3Rhc2svc2luZ2xldGhyZWFkLnJzAAAA6CAQAHEAAAAhAAAAFQAAAFwAAABdAAAAXgAAAF8AAABgAAAA6CAQAHEAAABVAAAAJQAAAGEAAAByZXR1cm4gdGhpc2Nsb3N1cmUgaW52b2tlZCByZWN1cnNpdmVseSBvciBkZXN0cm95ZWQgYWxyZWFkeWNhbm5vdCBhY2Nlc3MgYSBUaHJlYWQgTG9jYWwgU3RvcmFnZSB2YWx1ZSBkdXJpbmcgb3IgYWZ0ZXIgZGVzdHJ1Y3Rpb24AAABtAAAAAAAAAAEAAAAPAAAAL3J1c3RjLzIwZmZlYTY5MzhiNTgzOWMzOTAyNTJlMDc5NDBiOTllM2I2YTg4OWEvbGlicmFyeS9zdGQvc3JjL3RocmVhZC9sb2NhbC5ycwAoIhAATwAAAKUBAAAJAAAAVHJpZWQgdG8gc2hyaW5rIHRvIGEgbGFyZ2VyIGNhcGFjaXR5iCIQACQAAAAvcnVzdGMvMjBmZmVhNjkzOGI1ODM5YzM5MDI1MmUwNzk0MGI5OWUzYjZhODg5YS9saWJyYXJ5L2FsbG9jL3NyYy9yYXdfdmVjLnJztCIQAEwAAACqAQAACQAAAEpzVmFsdWUoKQAAABAjEAAIAAAAGCMQAAEAAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlAHMAAAAEAAAABAAAAHQAAAB1AAAAdgAAAGFscmVhZHkgYm9ycm93ZWRzAAAAAAAAAAEAAABQAAAAcwAAAAQAAAAEAAAAdwAAAHMAAAAEAAAABAAAAHgAAABjYWxsZWQgYE9wdGlvbjo6dW53cmFwKClgIG9uIGEgYE5vbmVgIHZhbHVlQWNjZXNzRXJyb3J1c2Ugb2Ygc3RkOjp0aHJlYWQ6OmN1cnJlbnQoKSBpcyBub3QgcG9zc2libGUgYWZ0ZXIgdGhlIHRocmVhZCdzIGxvY2FsIGRhdGEgaGFzIGJlZW4gZGVzdHJveWVkbGlicmFyeS9zdGQvc3JjL3RocmVhZC9tb2QucnMAAABEJBAAHQAAAKkCAAAFAAAAZmFpbGVkIHRvIGdlbmVyYXRlIHVuaXF1ZSB0aHJlYWQgSUQ6IGJpdHNwYWNlIGV4aGF1c3RlZAB0JBAANwAAAEQkEAAdAAAAFwQAABEAAABEJBAAHQAAAB0EAAAWAAAAcCMQAAAAAAB1bmNhdGVnb3JpemVkIGVycm9yb3RoZXIgZXJyb3JvdXQgb2YgbWVtb3J5dW5leHBlY3RlZCBlbmQgb2YgZmlsZXVuc3VwcG9ydGVkb3BlcmF0aW9uIGludGVycnVwdGVkYXJndW1lbnQgbGlzdCB0b28gbG9uZ2ludmFsaWQgZmlsZW5hbWV0b28gbWFueSBsaW5rc2Nyb3NzLWRldmljZSBsaW5rIG9yIHJlbmFtZWRlYWRsb2NrZXhlY3V0YWJsZSBmaWxlIGJ1c3lyZXNvdXJjZSBidXN5ZmlsZSB0b28gbGFyZ2VmaWxlc3lzdGVtIHF1b3RhIGV4Y2VlZGVkc2VlayBvbiB1bnNlZWthYmxlIGZpbGVubyBzdG9yYWdlIHNwYWNld3JpdGUgemVyb3RpbWVkIG91dGludmFsaWQgZGF0YWludmFsaWQgaW5wdXQgcGFyYW1ldGVyc3RhbGUgbmV0d29yayBmaWxlIGhhbmRsZWZpbGVzeXN0ZW0gbG9vcCBvciBpbmRpcmVjdGlvbiBsaW1pdCAoZS5nLiBzeW1saW5rIGxvb3ApcmVhZC1vbmx5IGZpbGVzeXN0ZW0gb3Igc3RvcmFnZSBtZWRpdW1kaXJlY3Rvcnkgbm90IGVtcHR5aXMgYSBkaXJlY3Rvcnlub3QgYSBkaXJlY3RvcnlvcGVyYXRpb24gd291bGQgYmxvY2tlbnRpdHkgYWxyZWFkeSBleGlzdHNicm9rZW4gcGlwZW5ldHdvcmsgZG93bmFkZHJlc3Mgbm90IGF2YWlsYWJsZWFkZHJlc3MgaW4gdXNlbm90IGNvbm5lY3RlZGNvbm5lY3Rpb24gYWJvcnRlZG5ldHdvcmsgdW5yZWFjaGFibGVob3N0IHVucmVhY2hhYmxlY29ubmVjdGlvbiByZXNldGNvbm5lY3Rpb24gcmVmdXNlZHBlcm1pc3Npb24gZGVuaWVkZW50aXR5IG5vdCBmb3VuZCAob3MgZXJyb3IgKQAAAHAjEAAAAAAAyScQAAsAAADUJxAAAQAAAGxpYnJhcnkvc3RkL3NyYy9zeW5jL29uY2UucnNhc3NlcnRpb24gZmFpbGVkOiBzdGF0ZV9hbmRfcXVldWUuYWRkcigpICYgU1RBVEVfTUFTSyA9PSBSVU5OSU5HT25jZSBpbnN0YW5jZSBoYXMgcHJldmlvdXNseSBiZWVuIHBvaXNvbmVkAABMKBAAKgAAAAIAAADwJxAAHAAAAP8BAAAJAAAA8CcQABwAAAAMAgAAHgAAAFBvaXNvbkVycm9ybGlicmFyeS9zdGQvc3JjL3N5c19jb21tb24vdGhyZWFkX2luZm8ucnOvKBAAKQAAABYAAAAzAAAAbWVtb3J5IGFsbG9jYXRpb24gb2YgIGJ5dGVzIGZhaWxlZAoA6CgQABUAAAD9KBAADgAAAGxpYnJhcnkvc3RkL3NyYy9hbGxvYy5ycxwpEAAYAAAAUgEAAAkAAABjYW5ub3QgbW9kaWZ5IHRoZSBwYW5pYyBob29rIGZyb20gYSBwYW5pY2tpbmcgdGhyZWFkRCkQADQAAABsaWJyYXJ5L3N0ZC9zcmMvcGFuaWNraW5nLnJzgCkQABwAAAB9AAAACQAAAIApEAAcAAAARwIAAA8AAACAKRAAHAAAAEYCAAAPAAAAeQAAAAwAAAAEAAAAegAAAHMAAAAIAAAABAAAAHsAAAB8AAAAEAAAAAQAAAB9AAAAfgAAAHMAAAAIAAAABAAAAH8AAACAAAAAb3BlcmF0aW9uIHN1Y2Nlc3NmdWxjb25kdmFyIHdhaXQgbm90IHN1cHBvcnRlZAAAKCoQABoAAABsaWJyYXJ5L3N0ZC9zcmMvc3lzL3dhc20vLi4vdW5zdXBwb3J0ZWQvbG9ja3MvY29uZHZhci5yc0wqEAA4AAAAFQAAAAkAAAAAY2Fubm90IHJlY3Vyc2l2ZWx5IGFjcXVpcmUgbXV0ZXgAAACVKhAAIAAAAGxpYnJhcnkvc3RkL3NyYy9zeXMvd2FzbS8uLi91bnN1cHBvcnRlZC9sb2Nrcy9tdXRleC5ycwAAwCoQADYAAAAYAAAACQAAAIEAAAAIAAAABAAAAIIAAABsaWJyYXJ5L3N0ZC9zcmMvc3lzX2NvbW1vbi90aHJlYWRfcGFya2VyL2dlbmVyaWMucnMAGCsQADMAAAAnAAAAFQAAAGluY29uc2lzdGVudCBwYXJrIHN0YXRlAFwrEAAXAAAAGCsQADMAAAA1AAAAFwAAAHBhcmsgc3RhdGUgY2hhbmdlZCB1bmV4cGVjdGVkbHkAjCsQAB8AAAAYKxAAMwAAADIAAAARAAAAaW5jb25zaXN0ZW50IHN0YXRlIGluIHVucGFya8QrEAAcAAAAGCsQADMAAABsAAAAEgAAABgrEAAzAAAAegAAAA4AAAAOAAAAEAAAABYAAAAVAAAACwAAABYAAAANAAAACwAAABMAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAARAAAAEgAAABAAAAAQAAAAEwAAABIAAAANAAAADgAAABUAAAAMAAAACwAAABUAAAAVAAAADwAAAA4AAAATAAAAJgAAADgAAAAZAAAAFwAAAAwAAAAJAAAACgAAABAAAAAXAAAAGQAAAA4AAAANAAAAFAAAAAgAAAAbAAAAYyUQAFMlEAA9JRAAKCUQAB0lEAAHJRAA+iQQAO8kEADcJBAAuScQALknEAC5JxAAuScQALknEAC5JxAAuScQALknEAC5JxAAuScQALknEAC5JxAAuScQALknEAC5JxAAuScQALknEAC5JxAAuScQALknEAC5JxAAuScQALknEAC5JxAAqCcQAJYnEACGJxAAdicQAGMnEABRJxAARCcQADYnEAAhJxAAFScQAAonEAD1JhAA4CYQANEmEADDJhAAsCYQAIomEABSJhAAOSYQACImEAAWJhAADSYQAAMmEADzJRAA3CUQAMMlEAC1JRAAqCUQAJQlEACMJRAAcSUQAEhhc2ggdGFibGUgY2FwYWNpdHkgb3ZlcmZsb3cILhAAHAAAAC9jYXJnby9yZWdpc3RyeS9zcmMvZ2l0aHViLmNvbS0xZWNjNjI5OWRiOWVjODIzL2hhc2hicm93bi0wLjEyLjMvc3JjL3Jhdy9tb2QucnMALC4QAE8AAABaAAAAKAAAAIMAAAAEAAAABAAAAIQAAACFAAAAhgAAAGxpYnJhcnkvYWxsb2Mvc3JjL3Jhd192ZWMucnNjYXBhY2l0eSBvdmVyZmxvdwAAAMAuEAARAAAApC4QABwAAAAGAgAABQAAAGEgZm9ybWF0dGluZyB0cmFpdCBpbXBsZW1lbnRhdGlvbiByZXR1cm5lZCBhbiBlcnJvcgCDAAAAAAAAAAEAAAATAAAAbGlicmFyeS9hbGxvYy9zcmMvZm10LnJzMC8QABgAAABkAgAACQAAAO+/vQBjYWxsZWQgYE9wdGlvbjo6dW53cmFwKClgIG9uIGEgYE5vbmVgIHZhbHVlKS4uAACILxAAAgAAAEJvcnJvd0Vycm9yQm9ycm93TXV0RXJyb3IAaW5kZXggb3V0IG9mIGJvdW5kczogdGhlIGxlbiBpcyAgYnV0IHRoZSBpbmRleCBpcyCuLxAAIAAAAM4vEAASAAAAOgAAAFwvEAAAAAAA8C8QAAEAAADwLxAAAQAAAHBhbmlja2VkIGF0ICcnLCAYMBAAAQAAABkwEAADAAAAXC8QAAAAAACPAAAAAAAAAAEAAACQAAAAbWF0Y2hlcyE9PT1hc3NlcnRpb24gZmFpbGVkOiBgKGxlZnQgIHJpZ2h0KWAKICBsZWZ0OiBgYCwKIHJpZ2h0OiBgYDogAAAATzAQABkAAABoMBAAEgAAAHowEAAMAAAAhjAQAAMAAABgAAAATzAQABkAAABoMBAAEgAAAHowEAAMAAAArDAQAAEAAAA6IAAAXC8QAAAAAADQMBAAAgAAAI8AAAAMAAAABAAAAJEAAACSAAAAkwAAACAgICAgewosCiwgIHsgLi4KfSwgLi4gfSB7IC4uIH0gfSgKKCwAAACPAAAABAAAAAQAAACUAAAAMHgwMDAxMDIwMzA0MDUwNjA3MDgwOTEwMTExMjEzMTQxNTE2MTcxODE5MjAyMTIyMjMyNDI1MjYyNzI4MjkzMDMxMzIzMzM0MzUzNjM3MzgzOTQwNDE0MjQzNDQ0NTQ2NDc0ODQ5NTA1MTUyNTM1NDU1NTY1NzU4NTk2MDYxNjI2MzY0NjU2NjY3Njg2OTcwNzE3MjczNzQ3NTc2Nzc3ODc5ODA4MTgyODM4NDg1ODY4Nzg4ODk5MDkxOTI5Mzk0OTU5Njk3OTg5OQAAjwAAAAQAAAAEAAAAlQAAAJYAAACXAAAAdHJ1ZWZhbHNlKClyYW5nZSBzdGFydCBpbmRleCAgb3V0IG9mIHJhbmdlIGZvciBzbGljZSBvZiBsZW5ndGggACMyEAASAAAANTIQACIAAABsaWJyYXJ5L2NvcmUvc3JjL3NsaWNlL2luZGV4LnJzAGgyEAAfAAAANAAAAAUAAAByYW5nZSBlbmQgaW5kZXggmDIQABAAAAA1MhAAIgAAAGgyEAAfAAAASQAAAAUAAABzbGljZSBpbmRleCBzdGFydHMgYXQgIGJ1dCBlbmRzIGF0IADIMhAAFgAAAN4yEAANAAAAaDIQAB8AAABcAAAABQAAAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAEHO58AACzMCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDAwMDAwMDAwMDAwMDAwMDBAQEBAQAQYzowAAL2RVsaWJyYXJ5L2NvcmUvc3JjL3N0ci9tb2QucnNbLi4uXWJ5dGUgaW5kZXggIGlzIG91dCBvZiBib3VuZHMgb2YgYAAAACw0EAALAAAANzQQABYAAACsMBAAAQAAAAw0EAAbAAAAawAAAAkAAABiZWdpbiA8PSBlbmQgKCA8PSApIHdoZW4gc2xpY2luZyBgAAB4NBAADgAAAIY0EAAEAAAAijQQABAAAACsMBAAAQAAAAw0EAAbAAAAbwAAAAUAAAAMNBAAGwAAAH0AAAAOAAAAIGlzIG5vdCBhIGNoYXIgYm91bmRhcnk7IGl0IGlzIGluc2lkZSAgKGJ5dGVzICkgb2YgYCw0EAALAAAA3DQQACYAAAACNRAACAAAAAo1EAAGAAAArDAQAAEAAAAMNBAAGwAAAH8AAAAFAAAAbGlicmFyeS9jb3JlL3NyYy91bmljb2RlL3ByaW50YWJsZS5ycwAAAEg1EAAlAAAAGgAAACgAAAAAAQMFBQYGAgcGCAcJEQocCxkMGg0QDg0PBBADEhITCRYBFwQYARkDGgcbARwCHxYgAysDLQsuATADMQIyAacCqQKqBKsI+gL7Bf0C/gP/Ca14eYuNojBXWIuMkBzdDg9LTPv8Li8/XF1f4oSNjpGSqbG6u8XGycre5OX/AAQREikxNDc6Oz1JSl2EjpKpsbS6u8bKzs/k5QAEDQ4REikxNDo7RUZJSl5kZYSRm53Jzs8NESk6O0VJV1tcXl9kZY2RqbS6u8XJ3+Tl8A0RRUlkZYCEsry+v9XX8PGDhYukpr6/xcfOz9rbSJi9zcbOz0lOT1dZXl+Jjo+xtre/wcbH1xEWF1tc9vf+/4Btcd7fDh9ubxwdX31+rq9/u7wWFx4fRkdOT1haXF5+f7XF1NXc8PH1cnOPdHWWJi4vp6+3v8fP19+aQJeYMI8f0tTO/05PWlsHCA8QJy/u725vNz0/QkWQkVNndcjJ0NHY2ef+/wAgXyKC3wSCRAgbBAYRgawOgKsFHwmBGwMZCAEELwQ0BAcDAQcGBxEKUA8SB1UHAwQcCgkDCAMHAwIDAwMMBAUDCwYBDhUFTgcbB1cHAgYWDVAEQwMtAwEEEQYPDDoEHSVfIG0EaiWAyAWCsAMaBoL9A1kHFgkYCRQMFAxqBgoGGgZZBysFRgosBAwEAQMxCywEGgYLA4CsBgoGLzFNA4CkCDwDDwM8BzgIKwWC/xEYCC8RLQMhDyEPgIwEgpcZCxWIlAUvBTsHAg4YCYC+InQMgNYaDAWA/wWA3wzynQM3CYFcFIC4CIDLBQoYOwMKBjgIRggMBnQLHgNaBFkJgIMYHAoWCUwEgIoGq6QMFwQxoQSB2iYHDAUFgKYQgfUHASAqBkwEgI0EgL4DGwMPDQAGAQEDAQQCBQcHAggICQIKBQsCDgQQARECEgUTERQBFQIXAhkNHAUdCCQBagRrAq8DvALPAtEC1AzVCdYC1wLaAeAF4QLnBOgC7iDwBPgC+gL7AQwnOz5OT4+enp97i5OWorK6hrEGBwk2PT5W89DRBBQYNjdWV3+qrq+9NeASh4mOngQNDhESKTE0OkVGSUpOT2RlXLa3GxwHCAoLFBc2OTqoqdjZCTeQkagHCjs+ZmmPkm9fv+7vWmL0/P+amy4vJyhVnaCho6SnqK26vMQGCwwVHTo/RVGmp8zNoAcZGiIlPj/n7O//xcYEICMlJigzODpISkxQU1VWWFpcXmBjZWZrc3h9f4qkqq+wwNCur25vk14iewUDBC0DZgMBLy6Agh0DMQ8cBCQJHgUrBUQEDiqAqgYkBCQEKAg0C05DgTcJFgoIGDtFOQNjCAkwFgUhAxsFAUA4BEsFLwQKBwkHQCAnBAwJNgM6BRoHBAwHUEk3Mw0zBy4ICoEmUk4oCCoWGiYcFBcJTgQkCUQNGQcKBkgIJwl1Cz9BKgY7BQoGUQYBBRADBYCLYh5ICAqApl4iRQsKBg0TOgYKNiwEF4C5PGRTDEgJCkZFG0gIUw1JgQdGCh0DR0k3Aw4ICgY5BwqBNhmAtwEPMg2Dm2Z1C4DEikxjDYQvj9GCR6G5gjkHKgRcBiYKRgooBROCsFtlSwQ5BxFABQsCDpf4CITWKgmi54EzLQMRBAiBjIkEawUNAwkHEJJgRwl0PID2CnMIcBVGgJoUDFcJGYCHgUcDhUIPFYRQH4DhK4DVLQMaBAKBQB8ROgUBhOCA9ylMBAoEAoMRREw9gMI8BgEEVQUbNAKBDiwEZAxWCoCuOB0NLAQJBwIOBoCag9gFEAMNA3QMWQcMBAEPDAQ4CAoGKAgiToFUDBUDBQMHCR0DCwUGCgoGCAgHCYDLJQqEBmxpYnJhcnkvY29yZS9zcmMvdW5pY29kZS91bmljb2RlX2RhdGEucnMAAADpOhAAKAAAAFIAAAA+AAAAjwAAAAQAAAAEAAAAmAAAAFRyeUZyb21TbGljZUVycm9yU29tZU5vbmUAAACPAAAABAAAAAQAAACZAAAARXJyb3JVdGY4RXJyb3J2YWxpZF91cF90b2Vycm9yX2xlbgAAjwAAAAQAAAAEAAAAmgAAAAADAACDBCAAkQVgAF0ToAASFyAfDCBgH+8soCsqMCAsb6bgLAKoYC0e+2AuAP4gNp7/YDb9AeE2AQohNyQN4TerDmE5LxihOTAc4UfzHiFM8GrhT09vIVCdvKFQAM9hUWXRoVEA2iFSAODhUzDhYVWu4qFW0OjhViAAblfwAf9XAHAABwAtAQEBAgECAQFICzAVEAFlBwIGAgIBBCMBHhtbCzoJCQEYBAEJAQMBBSsDPAgqGAEgNwEBAQQIBAEDBwoCHQE6AQEBAgQIAQkBCgIaAQICOQEEAgQCAgMDAR4CAwELAjkBBAUBAgQBFAIWBgEBOgEBAgEECAEHAwoCHgE7AQEBDAEJASgBAwE3AQEDBQMBBAcCCwIdAToBAgECAQMBBQIHAgsCHAI5AgEBAgQIAQkBCgIdAUgBBAECAwEBCAFRAQIHDAhiAQIJCwZKAhsBAQEBATcOAQUBAgULASQJAWYEAQYBAgICGQIEAxAEDQECAgYBDwEAAwADHQIeAh4CQAIBBwgBAgsJAS0DAQF1AiIBdgMEAgkBBgPbAgIBOgEBBwEBAQECCAYKAgEwHzEEMAcBAQUBKAkMAiAEAgIBAzgBAQIDAQEDOggCApgDAQ0BBwQBBgEDAsZAAAHDIQADjQFgIAAGaQIABAEKIAJQAgABAwEEARkCBQGXAhoSDQEmCBkLLgMwAQIEAgInAUMGAgICAgwBCAEvATMBAQMCAgUCAQEqAggB7gECAQQBAAEAEBAQAAIAAeIBlQUAAwECBQQoAwQBpQIABAACmQsxBHsBNg8pAQICCgMxBAICBwE9AyQFAQg+AQwCNAkKBAIBXwMCAQECBgGgAQMIFQI5AgEBAQEWAQ4HAwXDCAIDAQEXAVEBAgYBAQIBAQIBAusBAgQGAgECGwJVCAIBAQJqAQEBAgYBAWUDAgQBBQAJAQL1AQoCAQEEAZAEAgIEASAKKAYCBAgBCQYCAy4NAQIABwEGAQFSFgIHAQIBAnoGAwEBAgEHAQFIAgMBAQEAAgAFOwcAAT8EUQEAAgAuAhcAAQEDBAUICAIHHgSUAwA3BDIIAQ4BFgUBDwAHARECBwECAQUABwABPQQAB20HAGCA8AAA6ToQACgAAAA3AQAACQBB6P3AAAsRAQAAAAAAAABpegAAAAAAAAEARwlwcm9kdWNlcnMBDHByb2Nlc3NlZC1ieQIGd2FscnVzBjAuMTkuMAx3YXNtLWJpbmRnZW4SMC4yLjgxICgwNjJhYTVmNzAp"; function asciiToBinary(str) { if (typeof atob === 'function') { diff --git a/src/usdpl_front/usdpl_front_bg.wasm b/src/usdpl_front/usdpl_front_bg.wasm index 8c70a8b27d36007435981c242fef4e034f60f1b5..b7ceffef23008f38b2cad045897dbbaf699f1ebe 100644 GIT binary patch literal 93759 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 VS{gc=!}_N7mRxS-){drS{})HSj#U5v delta 33170 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