From 7c60fce27684b0a35aa57d3f85fe446e9ab5276f Mon Sep 17 00:00:00 2001 From: Douwe Osinga Date: Thu, 24 Jul 2025 18:55:06 +0200 Subject: [PATCH 01/18] WIP --- Cargo.lock | 1 + crates/goose-cli/Cargo.toml | 23 +- crates/goose-cli/src/scenario_tests/mod.rs | 191 +++- .../goose-cli/src/scenario_tests/scenarios.rs | 7 +- crates/goose/tests/providers.rs | 844 +++++++++--------- 5 files changed, 629 insertions(+), 437 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index ad6b9772759c..da2fb1f8f4bf 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3533,6 +3533,7 @@ dependencies = [ "cliclack", "console", "dirs 5.0.1", + "dotenvy", "etcetera", "futures", "goose", diff --git a/crates/goose-cli/Cargo.toml b/crates/goose-cli/Cargo.toml index 502e9a09d787..050c15c1585e 100644 --- a/crates/goose-cli/Cargo.toml +++ b/crates/goose-cli/Cargo.toml @@ -25,6 +25,7 @@ rmcp = { workspace = true } clap = { version = "4.4", features = ["derive"] } cliclack = "0.3.5" console = "0.15.8" +dotenvy = "0.15.7" bat = "0.24.0" anyhow = "1.0" serde_json = "1.0" @@ -36,17 +37,17 @@ serde_yaml = "0.9" tempfile = "3" etcetera = "0.8.0" reqwest = { version = "0.12.9", features = [ - "rustls-tls-native-roots", - "json", - "cookies", - "gzip", - "brotli", - "deflate", - "zstd", - "charset", - "http2", - "stream" - ], default-features = false } + "rustls-tls-native-roots", + "json", + "cookies", + "gzip", + "brotli", + "deflate", + "zstd", + "charset", + "http2", + "stream" +], default-features = false } rand = "0.8.5" rustyline = "15.0.0" tracing = "0.1" diff --git a/crates/goose-cli/src/scenario_tests/mod.rs b/crates/goose-cli/src/scenario_tests/mod.rs index 036c07e3b761..b91d488ac405 100644 --- a/crates/goose-cli/src/scenario_tests/mod.rs +++ b/crates/goose-cli/src/scenario_tests/mod.rs @@ -2,14 +2,68 @@ mod scenarios; use crate::session::Session; use anyhow::Result; +use dotenvy::dotenv; use goose::agents::Agent; use goose::config::Config; use goose::message::Message; use goose::model::ModelConfig; use goose::providers::{create, testprovider::TestProvider}; +use std::collections::HashMap; +use std::future::Future; use std::path::Path; use std::sync::Arc; +#[derive(Debug, Clone)] +struct ProviderConfig { + name: &'static str, + factory_name: &'static str, + required_env_vars: &'static [&'static str], + env_modifications: Option>>, +} + +static PROVIDER_CONFIGS: &[ProviderConfig] = &[ + ProviderConfig { + name: "OpenAI", + factory_name: "openai", + required_env_vars: &["OPENAI_API_KEY"], + env_modifications: None, + }, + ProviderConfig { + name: "Anthropic", + factory_name: "anthropic", + required_env_vars: &["ANTHROPIC_API_KEY"], + env_modifications: None, + }, + ProviderConfig { + name: "Azure", + factory_name: "azure_openai", + required_env_vars: &[ + "AZURE_OPENAI_API_KEY", + "AZURE_OPENAI_ENDPOINT", + "AZURE_OPENAI_DEPLOYMENT_NAME", + ], + env_modifications: None, + }, + ProviderConfig { + name: "Bedrock", + factory_name: "aws_bedrock", + required_env_vars: &["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"], + env_modifications: None, + }, + ProviderConfig { + name: "Google", + factory_name: "google", + required_env_vars: &["GOOGLE_API_KEY"], + env_modifications: None, + }, + ProviderConfig { + name: "Groq", + factory_name: "groq", + required_env_vars: &["GROQ_API_KEY"], + env_modifications: None, + }, +]; + #[derive(Debug, Clone)] pub struct ScenarioResult { pub messages: Vec, @@ -26,11 +80,106 @@ impl ScenarioResult { } } +async fn run_all_providers_scenario(test_name: &str, test_fn: F) -> Result<()> +where + F: Fn(String, String) -> Fut, + Fut: Future>, +{ + for config in PROVIDER_CONFIGS { + if let Err(e) = run_provider_scenario(config, &test_fn, test_name).await { + println!("Failed {} for {}: {:?}", test_name, config.name, e); + } + } + Ok(()) +} + +async fn run_provider_scenario( + config: &ProviderConfig, + test_fn: &F, + test_name: &str, +) -> Result +where + F: Fn(&str, &str) -> Fut, + Fut: Future>, +{ + if let Ok(path) = dotenv() { + println!("Loaded environment from {:?}", path); + } + + let mut original_env = HashMap::new(); + + for &var in config.required_env_vars { + if let Ok(val) = std::env::var(var) { + original_env.insert(var, val); + } + } + + if let Some(mods) = &config.env_modifications { + for &var in mods.keys() { + if let Ok(val) = std::env::var(var) { + original_env.insert(var, val); + } + } + } + + if let Some(mods) = &config.env_modifications { + for (&var, value) in mods.iter() { + match value { + Some(val) => std::env::set_var(var, val), + None => std::env::remove_var(var), + } + } + } + + let missing_vars = config + .required_env_vars + .iter() + .any(|var| std::env::var(var).is_err()); + + if missing_vars { + println!( + "Skipping {} scenario - credentials not configured", + config.name + ); + return Ok(ScenarioResult { + messages: vec![], + error: Some("Skipped - credentials not configured".to_string()), + }); + } + + std::env::set_var("GOOSE_PROVIDER", config.factory_name); + + let result = test_fn(test_name.to_string(), config.name.to_string()).await; + + for (&var, value) in original_env.iter() { + std::env::set_var(var, value); + } + if let Some(mods) = &config.env_modifications { + for &var in mods.keys() { + if !original_env.contains_key(var) { + std::env::remove_var(var); + } + } + } + + result +} + pub async fn run_test_scenario(test_name: &str, inputs: &[&str]) -> Result { + run_single_provider_scenario(test_name, "default", inputs).await +} + +async fn run_single_provider_scenario( + test_name: &str, + provider_name: &str, + inputs: &[&str], +) -> Result { let manifest_dir = env!("CARGO_MANIFEST_DIR"); let file_path = format!( - "{}/src/scenario_tests/recordings/{}.json", - manifest_dir, test_name + "{}/src/scenario_tests/recordings/{}/{}.json", + manifest_dir, + provider_name.to_lowercase(), + test_name ); if let Some(parent) = Path::new(&file_path).parent() { @@ -46,8 +195,8 @@ pub async fn run_test_scenario(test_name: &str, inputs: &[&str]) -> Result { let _ = std::fs::remove_file(&file_path); return Err(anyhow::anyhow!( - "Test replay failed for '{}': {}. File deleted - re-run test to record fresh data.", - test_name, e + "Test replay failed for '{}' ({}): {}. File deleted - re-run test to record fresh data.", + test_name, provider_name, e )); } } @@ -72,7 +221,6 @@ pub async fn run_test_scenario(test_name: &str, inputs: &[&str]) -> Result Result( + test_name: &str, + inputs: &[&str], + validator: F, +) -> Result<()> +where + F: Fn(&ScenarioResult) -> Result<()> + Send + Sync + 'static, +{ + let inputs_owned: Vec = inputs.iter().map(|s| s.to_string()).collect(); + let test_name_owned = test_name.to_string(); + + run_all_providers_scenario(&test_name_owned, |name, provider| { + let inputs = inputs_owned.clone(); + let validator = &validator; + async move { + let result = run_single_provider_scenario( + name, + provider, + &inputs.iter().map(|s| s.as_str()).collect::>(), + ) + .await?; + + validator(&result)?; + Ok(result) + } + }) + .await +} diff --git a/crates/goose-cli/src/scenario_tests/scenarios.rs b/crates/goose-cli/src/scenario_tests/scenarios.rs index 7a32df0a713a..7e1aa90d16a3 100644 --- a/crates/goose-cli/src/scenario_tests/scenarios.rs +++ b/crates/goose-cli/src/scenario_tests/scenarios.rs @@ -1,6 +1,6 @@ #[cfg(test)] mod tests { - use crate::scenario_tests::run_test_scenario; + use crate::scenario_tests::{run_multi_provider_scenario, run_test_scenario}; use anyhow::Result; #[tokio::test] @@ -19,4 +19,9 @@ mod tests { Ok(()) } + + #[tokio::test] + async fn test_multi_provider_basic_greeting() -> Result<()> { + run_multi_provider_scenario("multi_basic_greeting", &["hello", "goodbye"]).await + } } diff --git a/crates/goose/tests/providers.rs b/crates/goose/tests/providers.rs index 0225c88a733e..5c8af870489e 100644 --- a/crates/goose/tests/providers.rs +++ b/crates/goose/tests/providers.rs @@ -1,15 +1,13 @@ use anyhow::Result; use dotenvy::dotenv; use goose::message::{Message, MessageContent}; +use goose::model::ModelConfig; use goose::providers::base::Provider; use goose::providers::errors::ProviderError; -use goose::providers::{ - anthropic, azure, bedrock, databricks, google, groq, litellm, ollama, openai, openrouter, - snowflake, xai, -}; use mcp_core::tool::Tool; use rmcp::model::{AnnotateAble, Content, RawImageContent}; use std::collections::HashMap; +use std::future::Future; use std::sync::Arc; use std::sync::Mutex; @@ -30,6 +28,150 @@ impl std::fmt::Display for TestStatus { } } +#[derive(Debug, Clone)] +struct ProviderConfig { + name: &'static str, + factory_name: &'static str, + required_env_vars: &'static [&'static str], + env_modifications: Option>>, +} + +// Configuration for all providers +static PROVIDER_CONFIGS: &[ProviderConfig] = &[ + ProviderConfig { + name: "OpenAI", + factory_name: "openai", + required_env_vars: &["OPENAI_API_KEY"], + env_modifications: None, + }, + ProviderConfig { + name: "Anthropic", + factory_name: "anthropic", + required_env_vars: &["ANTHROPIC_API_KEY"], + env_modifications: None, + }, + ProviderConfig { + name: "Azure", + factory_name: "azure_openai", + required_env_vars: &[ + "AZURE_OPENAI_API_KEY", + "AZURE_OPENAI_ENDPOINT", + "AZURE_OPENAI_DEPLOYMENT_NAME", + ], + env_modifications: None, + }, + ProviderConfig { + name: "Bedrock", + factory_name: "aws_bedrock", + required_env_vars: &["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"], + env_modifications: None, + }, + ProviderConfig { + name: "Bedrock AWS Profile", + factory_name: "aws_bedrock", + required_env_vars: &["AWS_PROFILE"], + env_modifications: Some({ + let mut map = HashMap::new(); + map.insert("AWS_ACCESS_KEY_ID", None); + map.insert("AWS_SECRET_ACCESS_KEY", None); + map + }), + }, + ProviderConfig { + name: "Databricks", + factory_name: "databricks", + required_env_vars: &["DATABRICKS_HOST", "DATABRICKS_TOKEN"], + env_modifications: None, + }, + ProviderConfig { + name: "Databricks OAuth", + factory_name: "databricks", + required_env_vars: &["DATABRICKS_HOST"], + env_modifications: Some({ + let mut map = HashMap::new(); + map.insert("DATABRICKS_TOKEN", None); + map + }), + }, + ProviderConfig { + name: "Google", + factory_name: "google", + required_env_vars: &["GOOGLE_API_KEY"], + env_modifications: None, + }, + ProviderConfig { + name: "GCP Vertex AI", + factory_name: "gcp_vertex_ai", + required_env_vars: &["GOOGLE_APPLICATION_CREDENTIALS"], + env_modifications: None, + }, + ProviderConfig { + name: "Groq", + factory_name: "groq", + required_env_vars: &["GROQ_API_KEY"], + env_modifications: None, + }, + ProviderConfig { + name: "LiteLLM", + factory_name: "litellm", + required_env_vars: &[], + env_modifications: Some({ + let mut map = HashMap::new(); + map.insert("LITELLM_HOST", Some("http://localhost:4000".to_string())); + map.insert("LITELLM_API_KEY", Some("".to_string())); + map + }), + }, + ProviderConfig { + name: "Ollama", + factory_name: "ollama", + required_env_vars: &["OLLAMA_HOST"], + env_modifications: None, + }, + ProviderConfig { + name: "OpenRouter", + factory_name: "openrouter", + required_env_vars: &["OPENROUTER_API_KEY"], + env_modifications: None, + }, + ProviderConfig { + name: "SageMaker TGI", + factory_name: "sagemaker_tgi", + required_env_vars: &["SAGEMAKER_ENDPOINT_NAME"], + env_modifications: None, + }, + ProviderConfig { + name: "Snowflake", + factory_name: "snowflake", + required_env_vars: &["SNOWFLAKE_HOST", "SNOWFLAKE_TOKEN"], + env_modifications: None, + }, + ProviderConfig { + name: "Venice", + factory_name: "venice", + required_env_vars: &["VENICE_API_KEY"], + env_modifications: None, + }, + ProviderConfig { + name: "XAI", + factory_name: "xai", + required_env_vars: &["XAI_API_KEY"], + env_modifications: None, + }, + ProviderConfig { + name: "Claude Code", + factory_name: "claude-code", + required_env_vars: &["ANTHROPIC_API_KEY"], + env_modifications: None, + }, + ProviderConfig { + name: "Gemini CLI", + factory_name: "gemini-cli", + required_env_vars: &["GOOGLE_API_KEY"], + env_modifications: None, + }, +]; + struct TestReport { results: Mutex>, } @@ -76,25 +218,141 @@ lazy_static::lazy_static! { static ref ENV_LOCK: Mutex<()> = Mutex::new(()); } -/// Generic test harness for any Provider implementation -struct ProviderTester { - provider: Arc, - name: String, +fn load_env() { + if let Ok(path) = dotenv() { + println!("Loaded environment from {:?}", path); + } } -impl ProviderTester { - fn new(provider: T, name: String) -> Self { - Self { - provider: Arc::new(provider), - name, +/// Helper function that runs a test function against all available providers +async fn run_all_providers(test_name: &str, test_fn: F) -> Result<()> +where + F: Fn(Arc, &str) -> Fut, + Fut: Future>, +{ + let mut results = Vec::new(); + + for config in PROVIDER_CONFIGS { + let result = run_provider_test(config, &test_fn).await; + results.push((config.name, result)); + } + + // Report results to the global test report + for (name, result) in &results { + match result { + Ok(_) => TEST_REPORT.record_pass(&format!("{} - {}", test_name, name)), + Err(_) => TEST_REPORT.record_fail(&format!("{} - {}", test_name, name)), } } - async fn test_basic_response(&self) -> Result<()> { + // Report any failures + let failures: Vec<_> = results + .iter() + .filter(|(_, result)| result.is_err()) + .collect(); + + if !failures.is_empty() { + println!("Failed providers for {}:", test_name); + for (name, error) in failures { + println!(" {}: {:?}", name, error); + } + } + + Ok(()) +} + +async fn run_provider_test(config: &ProviderConfig, test_fn: &F) -> Result<()> +where + F: Fn(Arc, &str) -> Fut, + Fut: Future>, +{ + // Take exclusive access to environment modifications + let lock = ENV_LOCK.lock().unwrap(); + + load_env(); + + // Save current environment state + let mut original_env = HashMap::new(); + for &var in config.required_env_vars { + if let Ok(val) = std::env::var(var) { + original_env.insert(var, val); + } + } + if let Some(mods) = &config.env_modifications { + for &var in mods.keys() { + if let Ok(val) = std::env::var(var) { + original_env.insert(var, val); + } + } + } + + // Apply environment modifications + if let Some(mods) = &config.env_modifications { + for (&var, value) in mods.iter() { + match value { + Some(val) => std::env::set_var(var, val), + None => std::env::remove_var(var), + } + } + } + + // Check if required environment variables are available + let missing_vars = config + .required_env_vars + .iter() + .any(|var| std::env::var(var).is_err()); + if missing_vars { + println!( + "Skipping {} tests - credentials not configured", + config.name + ); + TEST_REPORT.record_skip(&format!("skipped - {}", config.name)); + return Ok(()); // Skip, don't fail + } + + // Special case for LiteLLM - skip if host not set + if config.factory_name == "litellm" && std::env::var("LITELLM_HOST").is_err() { + println!("LITELLM_HOST not set, skipping test"); + TEST_REPORT.record_skip(&format!("skipped - {}", config.name)); + return Ok(()); + } + + // Create provider using factory + let model_config = ModelConfig::default(); + let provider = match goose::providers::create(config.factory_name, model_config) { + Ok(p) => p, + Err(e) => { + println!("Failed to create provider {}: {}", config.name, e); + return Err(e); + } + }; + + // Restore original environment + for (&var, value) in original_env.iter() { + std::env::set_var(var, value); + } + if let Some(mods) = &config.env_modifications { + for &var in mods.keys() { + if !original_env.contains_key(var) { + std::env::remove_var(var); + } + } + } + + std::mem::drop(lock); + + // Run the actual test + test_fn(provider, config.name).await +} + +// Individual test functions + +#[tokio::test] +async fn test_basic_response() -> Result<()> { + run_all_providers("basic_response", |provider, provider_name| async move { let message = Message::user().with_text("Just say hello!"); - let (response, _) = self - .provider + let (response, _) = provider .complete("You are a helpful assistant.", &[message], &[]) .await?; @@ -102,19 +360,25 @@ impl ProviderTester { assert_eq!( response.content.len(), 1, - "Expected single content item in response" + "Expected single content item in response for {}", + provider_name ); // Verify we got a text response assert!( matches!(response.content[0], MessageContent::Text(_)), - "Expected text response" + "Expected text response for {}", + provider_name ); Ok(()) - } + }) + .await +} - async fn test_tool_usage(&self) -> Result<()> { +#[tokio::test] +async fn test_tool_usage() -> Result<()> { + run_all_providers("tool_usage", |provider, provider_name| async move { let weather_tool = Tool::new( "get_weather", "Get the weather for a location", @@ -133,8 +397,7 @@ impl ProviderTester { let message = Message::user().with_text("What's the weather like in San Francisco?"); - let (response1, _) = self - .provider + let (response1, _) = provider .complete( "You are a helpful weather assistant.", &[message.clone()], @@ -142,7 +405,7 @@ impl ProviderTester { ) .await?; - println!("=== {}::reponse1 ===", self.name); + println!("=== {}::response1 ===", provider_name); dbg!(&response1); println!("==================="); @@ -152,7 +415,8 @@ impl ProviderTester { .content .iter() .any(|content| matches!(content, MessageContent::ToolRequest(_))), - "Expected tool request in response" + "Expected tool request in response for {}", + provider_name ); let id = &response1 @@ -178,8 +442,7 @@ impl ProviderTester { ); // Verify we construct a valid payload including the request/response pair for the next inference - let (response2, _) = self - .provider + let (response2, _) = provider .complete( "You are a helpful weather assistant.", &[message, response1, weather], @@ -187,7 +450,7 @@ impl ProviderTester { ) .await?; - println!("=== {}::reponse2 ===", self.name); + println!("=== {}::response2 ===", provider_name); dbg!(&response2); println!("==================="); @@ -196,21 +459,30 @@ impl ProviderTester { .content .iter() .any(|content| matches!(content, MessageContent::Text(_))), - "Expected text for final response" + "Expected text for final response for {}", + provider_name ); Ok(()) - } - - async fn test_context_length_exceeded_error(&self) -> Result<()> { - // Google Gemini has a really long context window - let large_message_content = if self.name.to_lowercase() == "google" { - "hello ".repeat(1_300_000) - } else { - "hello ".repeat(300_000) - }; + }) + .await +} - let messages = vec![ +#[tokio::test] +async fn test_context_length_exceeded_error() -> Result<()> { + run_all_providers( + "context_length_exceeded", + |provider, provider_name| async move { + // Google Gemini has a really long context window + let large_message_content = if provider_name.to_lowercase().contains("google") + || provider_name.to_lowercase().contains("gemini") + { + "hello ".repeat(1_300_000) + } else { + "hello ".repeat(300_000) + }; + + let messages = vec![ Message::user().with_text("hi there. what is 2 + 2?"), Message::assistant().with_text("hey! I think it's 4."), Message::user().with_text(&large_message_content), @@ -223,407 +495,143 @@ impl ProviderTester { ), ]; - // Test that we get ProviderError::ContextLengthExceeded when the context window is exceeded - let result = self - .provider - .complete("You are a helpful assistant.", &messages, &[]) - .await; - - // Print some debug info - println!("=== {}::context_length_exceeded_error ===", self.name); - dbg!(&result); - println!("==================="); - - // Ollama truncates by default even when the context window is exceeded - if self.name.to_lowercase() == "ollama" { - assert!( - result.is_ok(), - "Expected to succeed because of default truncation" - ); - return Ok(()); - } - - assert!( - result.is_err(), - "Expected error when context window is exceeded" - ); - assert!( - matches!(result.unwrap_err(), ProviderError::ContextLengthExceeded(_)), - "Expected error to be ContextLengthExceeded" - ); - - Ok(()) - } - - async fn test_image_content_support(&self) -> Result<()> { - use base64::{engine::general_purpose::STANDARD as BASE64, Engine as _}; - use std::fs; - - // Try to read the test image - let image_path = "crates/goose/examples/test_assets/test_image.png"; - let image_data = match fs::read(image_path) { - Ok(data) => data, - Err(_) => { - println!( - "Test image not found at {}, skipping image test", - image_path + // Test that we get ProviderError::ContextLengthExceeded when the context window is exceeded + let result = provider + .complete("You are a helpful assistant.", &messages, &[]) + .await; + + // Print some debug info + println!("=== {}::context_length_exceeded_error ===", provider_name); + dbg!(&result); + println!("==================="); + + // Ollama truncates by default even when the context window is exceeded + if provider_name.to_lowercase().contains("ollama") { + assert!( + result.is_ok(), + "Expected to succeed because of default truncation for {}", + provider_name ); return Ok(()); } - }; - - let base64_image = BASE64.encode(image_data); - let image_content = RawImageContent { - data: base64_image, - mime_type: "image/png".to_string(), - } - .no_annotation(); - // Test 1: Direct image message - let message_with_image = - Message::user().with_image(image_content.data.clone(), image_content.mime_type.clone()); - - let result = self - .provider - .complete( - "You are a helpful assistant. Describe what you see in the image briefly.", - &[message_with_image], - &[], - ) - .await; - - println!("=== {}::image_content_support ===", self.name); - let (response, _) = result?; - println!("Image response: {:?}", response); - // Verify we got a text response - assert!( - response - .content - .iter() - .any(|content| matches!(content, MessageContent::Text(_))), - "Expected text response for image" - ); - println!("==================="); - - // Test 2: Tool response with image (this should be handled gracefully) - let screenshot_tool = Tool::new( - "get_screenshot", - "Get a screenshot of the current screen", - serde_json::json!({ - "type": "object", - "properties": {} - }), - None, - ); - - let user_message = Message::user().with_text("Take a screenshot please"); - let tool_request = Message::assistant().with_tool_request( - "test_id", - Ok(mcp_core::tool::ToolCall::new( - "get_screenshot", - serde_json::json!({}), - )), - ); - let tool_response = Message::user().with_tool_response( - "test_id", - Ok(vec![Content::image( - image_content.data.clone(), - image_content.mime_type.clone(), - )]), - ); - - let result2 = self - .provider - .complete( - "You are a helpful assistant.", - &[user_message, tool_request, tool_response], - &[screenshot_tool], - ) - .await; - - println!("=== {}::tool_image_response ===", self.name); - let (response, _) = result2?; - println!("Tool image response: {:?}", response); - println!("==================="); - - Ok(()) - } - - /// Run all provider tests - async fn run_test_suite(&self) -> Result<()> { - self.test_basic_response().await?; - self.test_tool_usage().await?; - self.test_context_length_exceeded_error().await?; - self.test_image_content_support().await?; - Ok(()) - } -} - -fn load_env() { - if let Ok(path) = dotenv() { - println!("Loaded environment from {:?}", path); - } -} - -/// Helper function to run a provider test with proper error handling and reporting -async fn test_provider( - name: &str, - required_vars: &[&str], - env_modifications: Option>>, - provider_fn: F, -) -> Result<()> -where - F: FnOnce() -> T, - T: Provider + Send + Sync + 'static, -{ - // We start off as failed, so that if the process panics it is seen as a failure - TEST_REPORT.record_fail(name); - - // Take exclusive access to environment modifications - let lock = ENV_LOCK.lock().unwrap(); - - load_env(); - - // Save current environment state for required vars and modified vars - let mut original_env = HashMap::new(); - for &var in required_vars { - if let Ok(val) = std::env::var(var) { - original_env.insert(var, val); - } - } - if let Some(mods) = &env_modifications { - for &var in mods.keys() { - if let Ok(val) = std::env::var(var) { - original_env.insert(var, val); - } - } - } - - // Apply any environment modifications - if let Some(mods) = &env_modifications { - for (&var, value) in mods.iter() { - match value { - Some(val) => std::env::set_var(var, val), - None => std::env::remove_var(var), - } - } - } - - // Setup the provider - let missing_vars = required_vars.iter().any(|var| std::env::var(var).is_err()); - if missing_vars { - println!("Skipping {} tests - credentials not configured", name); - TEST_REPORT.record_skip(name); - return Ok(()); - } - - let provider = provider_fn(); - - // Restore original environment - for (&var, value) in original_env.iter() { - std::env::set_var(var, value); - } - if let Some(mods) = env_modifications { - for &var in mods.keys() { - if !original_env.contains_key(var) { - std::env::remove_var(var); - } - } - } - - std::mem::drop(lock); + assert!( + result.is_err(), + "Expected error when context window is exceeded for {}", + provider_name + ); + assert!( + matches!(result.unwrap_err(), ProviderError::ContextLengthExceeded(_)), + "Expected error to be ContextLengthExceeded for {}", + provider_name + ); - let tester = ProviderTester::new(provider, name.to_string()); - match tester.run_test_suite().await { - Ok(_) => { - TEST_REPORT.record_pass(name); Ok(()) - } - Err(e) => { - println!("{} test failed: {}", name, e); - TEST_REPORT.record_fail(name); - Err(e) - } - } -} - -#[tokio::test] -async fn test_openai_provider() -> Result<()> { - test_provider( - "OpenAI", - &["OPENAI_API_KEY"], - None, - openai::OpenAiProvider::default, - ) - .await -} - -#[tokio::test] -async fn test_azure_provider() -> Result<()> { - test_provider( - "Azure", - &[ - "AZURE_OPENAI_API_KEY", - "AZURE_OPENAI_ENDPOINT", - "AZURE_OPENAI_DEPLOYMENT_NAME", - ], - None, - azure::AzureProvider::default, - ) - .await -} - -#[tokio::test] -async fn test_bedrock_provider_long_term_credentials() -> Result<()> { - test_provider( - "Bedrock", - &["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"], - None, - bedrock::BedrockProvider::default, - ) - .await -} - -#[tokio::test] -async fn test_bedrock_provider_aws_profile_credentials() -> Result<()> { - let env_mods = HashMap::from_iter([ - // Ensure to unset long-term credentials to use AWS Profile provider - ("AWS_ACCESS_KEY_ID", None), - ("AWS_SECRET_ACCESS_KEY", None), - ]); - - test_provider( - "Bedrock AWS Profile Credentials", - &["AWS_PROFILE"], - Some(env_mods), - bedrock::BedrockProvider::default, - ) - .await -} - -#[tokio::test] -async fn test_databricks_provider() -> Result<()> { - test_provider( - "Databricks", - &["DATABRICKS_HOST", "DATABRICKS_TOKEN"], - None, - databricks::DatabricksProvider::default, - ) - .await -} - -#[tokio::test] -async fn test_databricks_provider_oauth() -> Result<()> { - let mut env_mods = HashMap::new(); - env_mods.insert("DATABRICKS_TOKEN", None); - - test_provider( - "Databricks OAuth", - &["DATABRICKS_HOST"], - Some(env_mods), - databricks::DatabricksProvider::default, - ) - .await -} - -#[tokio::test] -async fn test_ollama_provider() -> Result<()> { - test_provider( - "Ollama", - &["OLLAMA_HOST"], - None, - ollama::OllamaProvider::default, - ) - .await -} - -#[tokio::test] -async fn test_groq_provider() -> Result<()> { - test_provider("Groq", &["GROQ_API_KEY"], None, groq::GroqProvider::default).await -} - -#[tokio::test] -async fn test_anthropic_provider() -> Result<()> { - test_provider( - "Anthropic", - &["ANTHROPIC_API_KEY"], - None, - anthropic::AnthropicProvider::default, + }, ) .await } #[tokio::test] -async fn test_openrouter_provider() -> Result<()> { - test_provider( - "OpenRouter", - &["OPENROUTER_API_KEY"], - None, - openrouter::OpenRouterProvider::default, - ) - .await -} +async fn test_image_content_support() -> Result<()> { + run_all_providers( + "image_content_support", + |provider, provider_name| async move { + use base64::{engine::general_purpose::STANDARD as BASE64, Engine as _}; + use std::fs; + + // Try to read the test image + let image_path = "crates/goose/examples/test_assets/test_image.png"; + let image_data = match fs::read(image_path) { + Ok(data) => data, + Err(_) => { + println!( + "Test image not found at {}, skipping image test for {}", + image_path, provider_name + ); + return Ok(()); + } + }; -#[tokio::test] -async fn test_google_provider() -> Result<()> { - test_provider( - "Google", - &["GOOGLE_API_KEY"], - None, - google::GoogleProvider::default, - ) - .await -} + let base64_image = BASE64.encode(image_data); + let image_content = RawImageContent { + data: base64_image, + mime_type: "image/png".to_string(), + } + .no_annotation(); + + // Test 1: Direct image message + let message_with_image = Message::user() + .with_image(image_content.data.clone(), image_content.mime_type.clone()); + + let result = provider + .complete( + "You are a helpful assistant. Describe what you see in the image briefly.", + &[message_with_image], + &[], + ) + .await; + + println!("=== {}::image_content_support ===", provider_name); + let (response, _) = result?; + println!("Image response: {:?}", response); + // Verify we got a text response + assert!( + response + .content + .iter() + .any(|content| matches!(content, MessageContent::Text(_))), + "Expected text response for image for {}", + provider_name + ); + println!("==================="); -#[tokio::test] -async fn test_snowflake_provider() -> Result<()> { - test_provider( - "Snowflake", - &["SNOWFLAKE_HOST", "SNOWFLAKE_TOKEN"], - None, - snowflake::SnowflakeProvider::default, - ) - .await -} + // Test 2: Tool response with image (this should be handled gracefully) + let screenshot_tool = Tool::new( + "get_screenshot", + "Get a screenshot of the current screen", + serde_json::json!({ + "type": "object", + "properties": {} + }), + None, + ); -#[tokio::test] -async fn test_sagemaker_tgi_provider() -> Result<()> { - test_provider( - "SageMakerTgi", - &["SAGEMAKER_ENDPOINT_NAME"], - None, - goose::providers::sagemaker_tgi::SageMakerTgiProvider::default, - ) - .await -} + let user_message = Message::user().with_text("Take a screenshot please"); + let tool_request = Message::assistant().with_tool_request( + "test_id", + Ok(mcp_core::tool::ToolCall::new( + "get_screenshot", + serde_json::json!({}), + )), + ); + let tool_response = Message::user().with_tool_response( + "test_id", + Ok(vec![Content::image( + image_content.data.clone(), + image_content.mime_type.clone(), + )]), + ); -#[tokio::test] -async fn test_litellm_provider() -> Result<()> { - if std::env::var("LITELLM_HOST").is_err() { - println!("LITELLM_HOST not set, skipping test"); - TEST_REPORT.record_skip("LiteLLM"); - return Ok(()); - } + let result2 = provider + .complete( + "You are a helpful assistant.", + &[user_message, tool_request, tool_response], + &[screenshot_tool], + ) + .await; - let env_mods = HashMap::from_iter([ - ("LITELLM_HOST", Some("http://localhost:4000".to_string())), - ("LITELLM_API_KEY", Some("".to_string())), - ]); + println!("=== {}::tool_image_response ===", provider_name); + let (response, _) = result2?; + println!("Tool image response: {:?}", response); + println!("==================="); - test_provider( - "LiteLLM", - &[], // No required environment variables - Some(env_mods), - litellm::LiteLLMProvider::default, + Ok(()) + }, ) .await } -#[tokio::test] -async fn test_xai_provider() -> Result<()> { - test_provider("Xai", &["XAI_API_KEY"], None, xai::XaiProvider::default).await -} - // Print the final test report #[ctor::dtor] fn print_test_report() { From 554342215c705ddb676e27fff7bfa1b9effddb24 Mon Sep 17 00:00:00 2001 From: Douwe Osinga Date: Thu, 24 Jul 2025 19:29:05 +0200 Subject: [PATCH 02/18] WIP --- crates/goose-cli/src/scenario_tests/mod.rs | 59 ++++++++++++++++--- .../goose-cli/src/scenario_tests/scenarios.rs | 14 ++++- 2 files changed, 63 insertions(+), 10 deletions(-) diff --git a/crates/goose-cli/src/scenario_tests/mod.rs b/crates/goose-cli/src/scenario_tests/mod.rs index b91d488ac405..484d7815ac5a 100644 --- a/crates/goose-cli/src/scenario_tests/mod.rs +++ b/crates/goose-cli/src/scenario_tests/mod.rs @@ -1,8 +1,8 @@ mod scenarios; +use dotenvy::dotenv; use crate::session::Session; use anyhow::Result; -use dotenvy::dotenv; use goose::agents::Agent; use goose::config::Config; use goose::message::Message; @@ -85,11 +85,53 @@ where F: Fn(String, String) -> Fut, Fut: Future>, { + // Check if we should only run a specific provider + if let Ok(only_provider) = std::env::var("GOOSE_TEST_PROVIDER") { + let config = PROVIDER_CONFIGS + .iter() + .find(|c| c.name.to_lowercase() == only_provider.to_lowercase()) + .ok_or_else(|| { + anyhow::anyhow!( + "Provider '{}' not found. Available: {}", + only_provider, + PROVIDER_CONFIGS + .iter() + .map(|c| c.name) + .collect::>() + .join(", ") + ) + })?; + + println!("Running test '{}' for provider: {}", test_name, config.name); + return run_provider_scenario(config, &test_fn, test_name) + .await + .map(|_| ()); + } + + let mut failures = Vec::new(); + for config in PROVIDER_CONFIGS { - if let Err(e) = run_provider_scenario(config, &test_fn, test_name).await { - println!("Failed {} for {}: {:?}", test_name, config.name, e); + match run_provider_scenario(config, &test_fn, test_name).await { + Ok(_) => println!("✅ {} - {}", test_name, config.name), + Err(e) => { + println!("❌ {} - {} FAILED: {}", test_name, config.name, e); + failures.push((config.name, e)); + } + } + } + + if !failures.is_empty() { + println!("\n=== Test Failures for {} ===", test_name); + for (provider, error) in &failures { + println!("❌ {}: {}", provider, error); } + return Err(anyhow::anyhow!( + "Test '{}' failed for {} provider(s)", + test_name, + failures.len() + )); } + Ok(()) } @@ -99,10 +141,10 @@ async fn run_provider_scenario( test_name: &str, ) -> Result where - F: Fn(&str, &str) -> Fut, + F: Fn(String, String) -> Fut, Fut: Future>, { - if let Ok(path) = dotenv() { + if let Ok(path) = dotenvy::dotenv() { println!("Loaded environment from {:?}", path); } @@ -262,15 +304,14 @@ where F: Fn(&ScenarioResult) -> Result<()> + Send + Sync + 'static, { let inputs_owned: Vec = inputs.iter().map(|s| s.to_string()).collect(); - let test_name_owned = test_name.to_string(); - run_all_providers_scenario(&test_name_owned, |name, provider| { + run_all_providers_scenario(test_name, |name, provider| { let inputs = inputs_owned.clone(); let validator = &validator; async move { let result = run_single_provider_scenario( - name, - provider, + &name, + &provider, &inputs.iter().map(|s| s.as_str()).collect::>(), ) .await?; diff --git a/crates/goose-cli/src/scenario_tests/scenarios.rs b/crates/goose-cli/src/scenario_tests/scenarios.rs index 7e1aa90d16a3..49c6a46dc20b 100644 --- a/crates/goose-cli/src/scenario_tests/scenarios.rs +++ b/crates/goose-cli/src/scenario_tests/scenarios.rs @@ -22,6 +22,18 @@ mod tests { #[tokio::test] async fn test_multi_provider_basic_greeting() -> Result<()> { - run_multi_provider_scenario("multi_basic_greeting", &["hello", "goodbye"]).await + run_multi_provider_scenario("multi_basic_greeting", &["hello", "goodbye"], |result| { + assert!(result + .message_contents() + .iter() + .any(|msg| msg.contains("Hello"))); + assert!(result + .message_contents() + .iter() + .any(|msg| msg.contains("Goodbye"))); + assert!(result.error.is_none()); + Ok(()) + }) + .await } } From bdf2d00f9d3bb649778bcd67a223db767ba9ebe2 Mon Sep 17 00:00:00 2001 From: Douwe Osinga Date: Fri, 25 Jul 2025 12:28:16 +0200 Subject: [PATCH 03/18] Make it run --- crates/goose-cli/src/scenario_tests/mod.rs | 49 +++++++++++++++++----- crates/goose/src/providers/anthropic.rs | 13 ++++++ crates/goose/src/providers/testprovider.rs | 26 ++++-------- 3 files changed, 60 insertions(+), 28 deletions(-) diff --git a/crates/goose-cli/src/scenario_tests/mod.rs b/crates/goose-cli/src/scenario_tests/mod.rs index 484d7815ac5a..dae7299c07a3 100644 --- a/crates/goose-cli/src/scenario_tests/mod.rs +++ b/crates/goose-cli/src/scenario_tests/mod.rs @@ -85,7 +85,6 @@ where F: Fn(String, String) -> Fut, Fut: Future>, { - // Check if we should only run a specific provider if let Ok(only_provider) = std::env::var("GOOSE_TEST_PROVIDER") { let config = PROVIDER_CONFIGS .iter() @@ -208,14 +207,27 @@ where } pub async fn run_test_scenario(test_name: &str, inputs: &[&str]) -> Result { - run_single_provider_scenario(test_name, "default", inputs).await + let (result, provider_for_saving) = + run_single_provider_scenario(test_name, "default", inputs).await?; + + if let Some(provider) = provider_for_saving { + if result.error.is_none() { + if result.error.is_none() { + Arc::try_unwrap(provider) + .map_err(|_| anyhow::anyhow!("Failed to unwrap provider for recording"))? + .finish_recording()?; + } + } + } + + Ok(result) } async fn run_single_provider_scenario( test_name: &str, provider_name: &str, inputs: &[&str], -) -> Result { +) -> Result<(ScenarioResult, Option>)> { let manifest_dir = env!("CARGO_MANIFEST_DIR"); let file_path = format!( "{}/src/scenario_tests/recordings/{}/{}.json", @@ -229,11 +241,9 @@ async fn run_single_provider_scenario( } let replay_mode = Path::new(&file_path).exists(); - let provider = if replay_mode { + let (provider_arc, provider_for_saving) = if replay_mode { match TestProvider::new_replaying(&file_path) { - Ok(test_provider) => { - Arc::new(test_provider) as Arc - } + Ok(test_provider) => (Arc::new(test_provider), None), Err(e) => { let _ = std::fs::remove_file(&file_path); return Err(anyhow::anyhow!( @@ -264,11 +274,14 @@ async fn run_single_provider_scenario( let model_config = ModelConfig::new(model_name); let inner_provider = create(&provider_name, model_config)?; - Arc::new(TestProvider::new_recording(inner_provider, &file_path)) + let test_provider = Arc::new(TestProvider::new_recording(inner_provider, &file_path)); + (test_provider.clone(), Some(test_provider)) }; let agent = Agent::new(); - agent.update_provider(provider).await?; + agent + .update_provider(provider_arc as Arc) + .await?; let mut session = Session::new(agent, None, false, None, None, None, None); @@ -292,7 +305,8 @@ async fn run_single_provider_scenario( } } - Ok(ScenarioResult { messages, error }) + let result = ScenarioResult { messages, error }; + Ok((result, provider_for_saving)) } pub async fn run_multi_provider_scenario( @@ -309,7 +323,7 @@ where let inputs = inputs_owned.clone(); let validator = &validator; async move { - let result = run_single_provider_scenario( + let (result, provider_for_saving) = run_single_provider_scenario( &name, &provider, &inputs.iter().map(|s| s.as_str()).collect::>(), @@ -317,6 +331,19 @@ where .await?; validator(&result)?; + + if let Some(provider) = provider_for_saving { + if result.error.is_none() { + if result.error.is_none() { + Arc::try_unwrap(provider) + .map_err(|_| { + anyhow::anyhow!("Failed to unwrap provider for recording") + })? + .finish_recording()?; + } + } + } + Ok(result) } }) diff --git a/crates/goose/src/providers/anthropic.rs b/crates/goose/src/providers/anthropic.rs index 58b4c299b75f..4f504f00625f 100644 --- a/crates/goose/src/providers/anthropic.rs +++ b/crates/goose/src/providers/anthropic.rs @@ -80,6 +80,9 @@ impl AnthropicProvider { ProviderError::RequestFailed(format!("Failed to construct endpoint URL: {e}")) })?; + let url_as_str = url.as_str(); + tracing::debug!("🔍 Sending request to Anthropic: {}", url_as_str); + let response = self .client .post(url) @@ -91,6 +94,16 @@ impl AnthropicProvider { let status = response.status(); let payload: Option = response.json().await.ok(); + let payload_str = payload + .as_ref() + .map(|p| serde_json::to_string(p).unwrap_or_else(|_| "Invalid JSON".to_string())); + + tracing::debug!( + "🔍 Received response from Anthropic: status={}, payload={:?}", + status, + payload_str + ); + // https://docs.anthropic.com/en/api/errors match status { StatusCode::OK => payload.ok_or_else( || ProviderError::RequestFailed("Response body is not valid JSON".to_string()) ), diff --git a/crates/goose/src/providers/testprovider.rs b/crates/goose/src/providers/testprovider.rs index 9016bdcf9612..820b1623464a 100644 --- a/crates/goose/src/providers/testprovider.rs +++ b/crates/goose/src/providers/testprovider.rs @@ -58,6 +58,13 @@ impl TestProvider { }) } + pub fn finish_recording(self) -> Result<()> { + if self.inner.is_some() { + self.save_records()?; + } + Ok(()) + } + fn hash_input(messages: &[Message]) -> String { let stable_messages: Vec<_> = messages .iter() @@ -68,6 +75,7 @@ impl TestProvider { hasher.update(serialized.as_bytes()); format!("{:x}", hasher.finalize()) } + fn load_records(file_path: &str) -> Result> { if !Path::new(file_path).exists() { return Ok(HashMap::new()); @@ -113,7 +121,6 @@ impl Provider for TestProvider { let hash = Self::hash_input(messages); if let Some(inner) = &self.inner { - // Recording mode let (message, usage) = inner.complete(system, messages, tools).await?; let record = TestRecord { @@ -135,7 +142,6 @@ impl Provider for TestProvider { Ok((message, usage)) } else { - // Replay mode let records = self.records.lock().unwrap(); if let Some(record) = records.get(&hash) { Ok((record.output.message.clone(), record.output.usage.clone())) @@ -153,16 +159,6 @@ impl Provider for TestProvider { } } -impl Drop for TestProvider { - fn drop(&mut self) { - if self.inner.is_some() { - if let Err(e) = self.save_records() { - eprintln!("Failed to save test records: {}", e); - } - } - } -} - #[cfg(test)] mod tests { use super::*; @@ -231,7 +227,6 @@ mod tests { response: "Hello, world!".to_string(), }); - // Record phase { let test_provider = TestProvider::new_recording(mock, &temp_file); @@ -244,11 +239,10 @@ mod tests { assert_eq!(content.text, "Hello, world!"); } - test_provider.save_records().unwrap(); assert_eq!(test_provider.get_record_count(), 1); + test_provider.finish_recording().unwrap(); } - // Replay phase { let replay_provider = TestProvider::new_replaying(&temp_file).unwrap(); @@ -262,7 +256,6 @@ mod tests { } } - // Cleanup let _ = fs::remove_file(temp_file); } @@ -286,7 +279,6 @@ mod tests { .to_string() .contains("No recorded response found")); - // Cleanup let _ = fs::remove_file(temp_file); } } From 3bf4753fae5d7802bfd286251317df50eb8ee711 Mon Sep 17 00:00:00 2001 From: Douwe Osinga Date: Fri, 25 Jul 2025 12:52:03 +0200 Subject: [PATCH 04/18] Check point --- crates/goose-cli/src/scenario_tests/mod.rs | 87 +++++++++++----------- 1 file changed, 43 insertions(+), 44 deletions(-) diff --git a/crates/goose-cli/src/scenario_tests/mod.rs b/crates/goose-cli/src/scenario_tests/mod.rs index dae7299c07a3..5bd2689131ac 100644 --- a/crates/goose-cli/src/scenario_tests/mod.rs +++ b/crates/goose-cli/src/scenario_tests/mod.rs @@ -16,53 +16,52 @@ use std::sync::Arc; #[derive(Debug, Clone)] struct ProviderConfig { name: &'static str, - factory_name: &'static str, + factory_name: Option<&'static str>, required_env_vars: &'static [&'static str], env_modifications: Option>>, } -static PROVIDER_CONFIGS: &[ProviderConfig] = &[ - ProviderConfig { - name: "OpenAI", - factory_name: "openai", - required_env_vars: &["OPENAI_API_KEY"], - env_modifications: None, - }, - ProviderConfig { - name: "Anthropic", - factory_name: "anthropic", - required_env_vars: &["ANTHROPIC_API_KEY"], - env_modifications: None, - }, - ProviderConfig { - name: "Azure", - factory_name: "azure_openai", - required_env_vars: &[ - "AZURE_OPENAI_API_KEY", - "AZURE_OPENAI_ENDPOINT", - "AZURE_OPENAI_DEPLOYMENT_NAME", - ], - env_modifications: None, - }, - ProviderConfig { - name: "Bedrock", - factory_name: "aws_bedrock", - required_env_vars: &["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"], - env_modifications: None, - }, - ProviderConfig { - name: "Google", - factory_name: "google", - required_env_vars: &["GOOGLE_API_KEY"], - env_modifications: None, - }, - ProviderConfig { - name: "Groq", - factory_name: "groq", - required_env_vars: &["GROQ_API_KEY"], - env_modifications: None, - }, -]; +impl ProviderConfig { + fn simple(name: &'static str) -> Self { + let key = format!("{}_API_KEY", name.to_uppercase()); + let required_env_vars = + Box::leak(vec![Box::leak(key.into_boxed_str()) as &str].into_boxed_slice()); + + Self { + name, + factory_name: None, + required_env_vars, + env_modifications: None, + } + } +} + +use std::sync::LazyLock; + +static PROVIDER_CONFIGS: LazyLock> = LazyLock::new(|| { + vec![ + ProviderConfig::simple("OpenAI"), + ProviderConfig::simple("Anthropic"), + ProviderConfig { + name: "Azure", + factory_name: Some("azure_openai"), + required_env_vars: &[ + "AZURE_OPENAI_API_KEY", + "AZURE_OPENAI_ENDPOINT", + "AZURE_OPENAI_DEPLOYMENT_NAME", + ], + env_modifications: None, + }, + ProviderConfig { + name: "Bedrock", + factory_name: Some("aws_bedrock"), + required_env_vars: &["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"], + env_modifications: None, + }, + ProviderConfig::simple("Google"), + ProviderConfig::simple("Groq"), + ] +}); #[derive(Debug, Clone)] pub struct ScenarioResult { @@ -109,7 +108,7 @@ where let mut failures = Vec::new(); - for config in PROVIDER_CONFIGS { + for config in &*PROVIDER_CONFIGS { match run_provider_scenario(config, &test_fn, test_name).await { Ok(_) => println!("✅ {} - {}", test_name, config.name), Err(e) => { From 31b72e882f0590c673dc4e2aef3fa01024a1e728 Mon Sep 17 00:00:00 2001 From: Douwe Osinga Date: Fri, 25 Jul 2025 14:02:19 +0200 Subject: [PATCH 05/18] Check point --- crates/goose-cli/src/scenario_tests/mod.rs | 65 ++++++------------- .../goose-cli/src/scenario_tests/scenarios.rs | 19 +----- 2 files changed, 21 insertions(+), 63 deletions(-) diff --git a/crates/goose-cli/src/scenario_tests/mod.rs b/crates/goose-cli/src/scenario_tests/mod.rs index 5bd2689131ac..fcf6bc84fcc5 100644 --- a/crates/goose-cli/src/scenario_tests/mod.rs +++ b/crates/goose-cli/src/scenario_tests/mod.rs @@ -11,7 +11,7 @@ use goose::providers::{create, testprovider::TestProvider}; use std::collections::HashMap; use std::future::Future; use std::path::Path; -use std::sync::Arc; +use std::sync::{Arc, LazyLock}; #[derive(Debug, Clone)] struct ProviderConfig { @@ -34,9 +34,11 @@ impl ProviderConfig { env_modifications: None, } } -} -use std::sync::LazyLock; + fn name_for_factory(&self) -> &str { + self.factory_name.unwrap_or(&self.name.to_lowercase()) + } +} static PROVIDER_CONFIGS: LazyLock> = LazyLock::new(|| { vec![ @@ -81,7 +83,7 @@ impl ScenarioResult { async fn run_all_providers_scenario(test_name: &str, test_fn: F) -> Result<()> where - F: Fn(String, String) -> Fut, + F: Fn(String, String, String) -> Fut, Fut: Future>, { if let Ok(only_provider) = std::env::var("GOOSE_TEST_PROVIDER") { @@ -139,7 +141,7 @@ async fn run_provider_scenario( test_name: &str, ) -> Result where - F: Fn(String, String) -> Fut, + F: Fn(String, String, String) -> Fut, Fut: Future>, { if let Ok(path) = dotenvy::dotenv() { @@ -187,9 +189,12 @@ where }); } - std::env::set_var("GOOSE_PROVIDER", config.factory_name); - - let result = test_fn(test_name.to_string(), config.name.to_string()).await; + let result = test_fn( + test_name.to_string(), + config.name.to_string(), + config.name_for_factory().to_string(), + ) + .await; for (&var, value) in original_env.iter() { std::env::set_var(var, value); @@ -205,33 +210,16 @@ where result } -pub async fn run_test_scenario(test_name: &str, inputs: &[&str]) -> Result { - let (result, provider_for_saving) = - run_single_provider_scenario(test_name, "default", inputs).await?; - - if let Some(provider) = provider_for_saving { - if result.error.is_none() { - if result.error.is_none() { - Arc::try_unwrap(provider) - .map_err(|_| anyhow::anyhow!("Failed to unwrap provider for recording"))? - .finish_recording()?; - } - } - } - - Ok(result) -} - async fn run_single_provider_scenario( test_name: &str, - provider_name: &str, + factory_name: &str, inputs: &[&str], ) -> Result<(ScenarioResult, Option>)> { let manifest_dir = env!("CARGO_MANIFEST_DIR"); let file_path = format!( "{}/src/scenario_tests/recordings/{}/{}.json", manifest_dir, - provider_name.to_lowercase(), + factory_name.to_lowercase(), test_name ); @@ -247,7 +235,7 @@ async fn run_single_provider_scenario( let _ = std::fs::remove_file(&file_path); return Err(anyhow::anyhow!( "Test replay failed for '{}' ({}): {}. File deleted - re-run test to record fresh data.", - test_name, provider_name, e + test_name, factory_name, e )); } } @@ -259,20 +247,7 @@ async fn run_single_provider_scenario( file_path ); } - let config = Config::global(); - - let (provider_name, model_name): (String, String) = match ( - config.get_param::("GOOSE_PROVIDER"), - config.get_param::("GOOSE_MODEL"), - ) { - (Ok(provider), Ok(model)) => (provider, model), - _ => { - panic!("Provider or model not configured. Run 'goose configure' first"); - } - }; - - let model_config = ModelConfig::new(model_name); - let inner_provider = create(&provider_name, model_config)?; + let inner_provider = create(factory_name, ModelConfig::default())?; let test_provider = Arc::new(TestProvider::new_recording(inner_provider, &file_path)); (test_provider.clone(), Some(test_provider)) }; @@ -299,7 +274,7 @@ async fn run_single_provider_scenario( let _ = std::fs::remove_file(&file_path); return Err(anyhow::anyhow!( "Test replay failed for '{}' ({}) - missing recorded interaction: {}. File deleted - re-run test to record fresh data.", - test_name, provider_name, err_msg + test_name, factory_name, err_msg )); } } @@ -318,13 +293,13 @@ where { let inputs_owned: Vec = inputs.iter().map(|s| s.to_string()).collect(); - run_all_providers_scenario(test_name, |name, provider| { + run_all_providers_scenario(test_name, |name, provider, factory_name| { let inputs = inputs_owned.clone(); let validator = &validator; async move { let (result, provider_for_saving) = run_single_provider_scenario( &name, - &provider, + &factory_name, &inputs.iter().map(|s| s.as_str()).collect::>(), ) .await?; diff --git a/crates/goose-cli/src/scenario_tests/scenarios.rs b/crates/goose-cli/src/scenario_tests/scenarios.rs index 49c6a46dc20b..22d0e16e4937 100644 --- a/crates/goose-cli/src/scenario_tests/scenarios.rs +++ b/crates/goose-cli/src/scenario_tests/scenarios.rs @@ -1,27 +1,10 @@ #[cfg(test)] mod tests { - use crate::scenario_tests::{run_multi_provider_scenario, run_test_scenario}; + use crate::scenario_tests::run_multi_provider_scenario; use anyhow::Result; #[tokio::test] async fn test_basic_greeting() -> Result<()> { - let result = run_test_scenario("basic_greeting", &["hello", "goodbye"]).await?; - - assert!(result - .message_contents() - .iter() - .any(|msg| msg.contains("Hello"))); - assert!(result - .message_contents() - .iter() - .any(|msg| msg.contains("Goodbye"))); - assert!(result.error.is_none()); - - Ok(()) - } - - #[tokio::test] - async fn test_multi_provider_basic_greeting() -> Result<()> { run_multi_provider_scenario("multi_basic_greeting", &["hello", "goodbye"], |result| { assert!(result .message_contents() From 77df0439d4ff211809df7d8744c4be280e941c22 Mon Sep 17 00:00:00 2001 From: Douwe Osinga Date: Fri, 25 Jul 2025 19:01:59 +0200 Subject: [PATCH 06/18] Check point --- crates/goose-cli/src/scenario_tests/mod.rs | 51 +- .../recordings/basic_greeting.json | 474 ------------------ .../goose-cli/src/scenario_tests/scenarios.rs | 2 +- 3 files changed, 39 insertions(+), 488 deletions(-) delete mode 100644 crates/goose-cli/src/scenario_tests/recordings/basic_greeting.json diff --git a/crates/goose-cli/src/scenario_tests/mod.rs b/crates/goose-cli/src/scenario_tests/mod.rs index fcf6bc84fcc5..c9fe63f0b088 100644 --- a/crates/goose-cli/src/scenario_tests/mod.rs +++ b/crates/goose-cli/src/scenario_tests/mod.rs @@ -4,7 +4,6 @@ use dotenvy::dotenv; use crate::session::Session; use anyhow::Result; use goose::agents::Agent; -use goose::config::Config; use goose::message::Message; use goose::model::ModelConfig; use goose::providers::{create, testprovider::TestProvider}; @@ -17,12 +16,13 @@ use std::sync::{Arc, LazyLock}; struct ProviderConfig { name: &'static str, factory_name: Option<&'static str>, + model_name: &'static str, required_env_vars: &'static [&'static str], env_modifications: Option>>, } impl ProviderConfig { - fn simple(name: &'static str) -> Self { + fn simple(name: &'static str, model_name: &'static str) -> Self { let key = format!("{}_API_KEY", name.to_uppercase()); let required_env_vars = Box::leak(vec![Box::leak(key.into_boxed_str()) as &str].into_boxed_slice()); @@ -30,23 +30,27 @@ impl ProviderConfig { Self { name, factory_name: None, + model_name, required_env_vars, env_modifications: None, } } - fn name_for_factory(&self) -> &str { - self.factory_name.unwrap_or(&self.name.to_lowercase()) + fn name_for_factory(&self) -> String { + self.factory_name + .map(|s| s.to_string()) + .unwrap_or_else(|| self.name.to_lowercase()) } } static PROVIDER_CONFIGS: LazyLock> = LazyLock::new(|| { vec![ - ProviderConfig::simple("OpenAI"), - ProviderConfig::simple("Anthropic"), + ProviderConfig::simple("OpenAI", "gpt-4o"), + ProviderConfig::simple("Anthropic", "claude-3-5-sonnet-20241022"), ProviderConfig { name: "Azure", factory_name: Some("azure_openai"), + model_name: "gpt-4o", required_env_vars: &[ "AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT", @@ -57,11 +61,12 @@ static PROVIDER_CONFIGS: LazyLock> = LazyLock::new(|| { ProviderConfig { name: "Bedrock", factory_name: Some("aws_bedrock"), + model_name: "anthropic.claude-3-5-sonnet-20241022-v2:0", required_env_vars: &["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"], env_modifications: None, }, - ProviderConfig::simple("Google"), - ProviderConfig::simple("Groq"), + ProviderConfig::simple("Google", "gemini-1.5-pro"), + ProviderConfig::simple("Groq", "llama-3.1-70b-versatile"), ] }); @@ -83,7 +88,7 @@ impl ScenarioResult { async fn run_all_providers_scenario(test_name: &str, test_fn: F) -> Result<()> where - F: Fn(String, String, String) -> Fut, + F: Fn(String, String, String, String) -> Fut, Fut: Future>, { if let Ok(only_provider) = std::env::var("GOOSE_TEST_PROVIDER") { @@ -141,7 +146,7 @@ async fn run_provider_scenario( test_name: &str, ) -> Result where - F: Fn(String, String, String) -> Fut, + F: Fn(String, String, String, String) -> Fut, Fut: Future>, { if let Ok(path) = dotenvy::dotenv() { @@ -192,7 +197,8 @@ where let result = test_fn( test_name.to_string(), config.name.to_string(), - config.name_for_factory().to_string(), + config.name_for_factory(), + config.model_name.to_string(), ) .await; @@ -213,6 +219,7 @@ where async fn run_single_provider_scenario( test_name: &str, factory_name: &str, + model_name: &str, inputs: &[&str], ) -> Result<(ScenarioResult, Option>)> { let manifest_dir = env!("CARGO_MANIFEST_DIR"); @@ -247,7 +254,7 @@ async fn run_single_provider_scenario( file_path ); } - let inner_provider = create(factory_name, ModelConfig::default())?; + let inner_provider = create(factory_name, ModelConfig::new(model_name.to_string()))?; let test_provider = Arc::new(TestProvider::new_recording(inner_provider, &file_path)); (test_provider.clone(), Some(test_provider)) }; @@ -283,6 +290,23 @@ async fn run_single_provider_scenario( Ok((result, provider_for_saving)) } +pub async fn run_test_scenario(test_name: &str, inputs: &[&str]) -> Result { + let (result, provider_for_saving) = + run_single_provider_scenario(test_name, "default", "default", inputs).await?; + + if let Some(provider) = provider_for_saving { + if result.error.is_none() { + if result.error.is_none() { + Arc::try_unwrap(provider) + .map_err(|_| anyhow::anyhow!("Failed to unwrap provider for recording"))? + .finish_recording()?; + } + } + } + + Ok(result) +} + pub async fn run_multi_provider_scenario( test_name: &str, inputs: &[&str], @@ -293,13 +317,14 @@ where { let inputs_owned: Vec = inputs.iter().map(|s| s.to_string()).collect(); - run_all_providers_scenario(test_name, |name, provider, factory_name| { + run_all_providers_scenario(test_name, |name, provider, factory_name, model_name| { let inputs = inputs_owned.clone(); let validator = &validator; async move { let (result, provider_for_saving) = run_single_provider_scenario( &name, &factory_name, + &model_name, &inputs.iter().map(|s| s.as_str()).collect::>(), ) .await?; diff --git a/crates/goose-cli/src/scenario_tests/recordings/basic_greeting.json b/crates/goose-cli/src/scenario_tests/recordings/basic_greeting.json deleted file mode 100644 index a3fcbd60c7b3..000000000000 --- a/crates/goose-cli/src/scenario_tests/recordings/basic_greeting.json +++ /dev/null @@ -1,474 +0,0 @@ -{ - "d2c95695a2c9ad5d95248955d850d147d76e209f537dab9bcc70fc815f2d8de7": { - "input": { - "system": "You are a general-purpose AI agent called Goose, created by Block, the parent company of Square, CashApp, and Tidal. Goose is being developed as an open-source software project.\n\nThe current date is 2025-07-22 15:02:47.\n\nGoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o, claude-3.5-sonnet, o1, llama-3.2, deepseek-r1, etc).\nThese models have varying knowledge cut-off dates depending on when they were trained, but typically it's between 5-10 months prior to the current date.\n\n# Extensions\n\nExtensions allow other applications to provide context to Goose. Extensions connect Goose to different data sources and tools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level problems using the tools in these extensions, and can interact with multiple at once.\nUse the search_available_extensions tool to find additional extensions to enable to help with your task. To enable extensions, use the enable_extension tool and provide the extension_name. You should only enable extensions found from the search_available_extensions tool.\n\n\nNo extensions are defined. You should let the user know that they should add extensions.\n\n\n\n# Suggestion\n\"\"\n\n\n\n\n# Response Guidelines\n\n- Use Markdown formatting for all responses.\n- Follow best practices for Markdown, including:\n - Using headers for organization.\n - Bullet points for lists.\n - Links formatted correctly, either as linked text (e.g., [this is linked text](https://example.com)) or automatic links using angle brackets (e.g., ).\n- For code examples, use fenced code blocks by placing triple backticks (` ``` `) before and after the code. Include the language identifier after the opening backticks (e.g., ` ```python `) to enable syntax highlighting.\n- Ensure clarity, conciseness, and proper formatting to enhance readability and usability.\n\n# Additional Instructions:\n\nRight now you are *NOT* in the chat only mode and have access to tool use and system.", - "messages": [ - { - "id": null, - "role": "user", - "created": 1753196567, - "content": [ - { - "type": "text", - "text": "hello" - } - ] - }, - { - "id": null, - "role": "assistant", - "created": 1753196578, - "content": [ - { - "type": "text", - "text": "Hello! I'm Goose, an AI agent created by Block. I'm here to help you with various tasks and questions.\n\nI notice that you don't currently have any extensions enabled. Extensions allow me to connect to different data sources and tools to help you accomplish more complex tasks. \n\nHere's what I can help you with right now:\n- **General conversation and questions**\n- **Task management** - I can create and execute dynamic tasks\n- **Scheduling** - I can manage scheduled recipe execution\n- **Extension management** - I can search for and enable additional capabilities\n\nTo get the most out of our interaction, you might want to:\n1. Let me search for available extensions that could help with your specific needs\n2. Tell me what kind of tasks you're looking to accomplish\n\nWhat would you like to do today?" - } - ] - }, - { - "id": null, - "role": "user", - "created": 1753196578, - "content": [ - { - "type": "text", - "text": "goodbye" - } - ] - } - ], - "tools": [ - { - "name": "platform__search_available_extensions", - "description": "Searches for additional extensions available to help complete tasks.\n Use this tool when you're unable to find a specific feature or functionality you need to complete your task, or when standard approaches aren't working.\n These extensions might provide the exact tools needed to solve your problem.\n If you find a relevant one, consider using your tools to enable it.", - "inputSchema": { - "properties": {}, - "required": [], - "type": "object" - }, - "annotations": { - "title": "Discover extensions", - "readOnlyHint": true, - "destructiveHint": false, - "idempotentHint": false, - "openWorldHint": false - } - }, - { - "name": "platform__manage_extensions", - "description": "Tool to manage extensions and tools in goose context.\n Enable or disable extensions to help complete tasks.\n Enable or disable an extension by providing the extension name.\n ", - "inputSchema": { - "properties": { - "action": { - "description": "The action to perform", - "enum": [ - "enable", - "disable" - ], - "type": "string" - }, - "extension_name": { - "description": "The name of the extension to enable", - "type": "string" - } - }, - "required": [ - "action", - "extension_name" - ], - "type": "object" - }, - "annotations": { - "title": "Enable or disable an extension", - "readOnlyHint": false, - "destructiveHint": false, - "idempotentHint": false, - "openWorldHint": false - } - }, - { - "name": "platform__manage_schedule", - "description": "Manage scheduled recipe execution for this Goose instance.\n\nActions:\n- \"list\": List all scheduled jobs\n- \"create\": Create a new scheduled job from a recipe file\n- \"run_now\": Execute a scheduled job immediately \n- \"pause\": Pause a scheduled job\n- \"unpause\": Resume a paused job\n- \"delete\": Remove a scheduled job\n- \"kill\": Terminate a currently running job\n- \"inspect\": Get details about a running job\n- \"sessions\": List execution history for a job\n- \"session_content\": Get the full content (messages) of a specific session\n", - "inputSchema": { - "properties": { - "action": { - "enum": [ - "list", - "create", - "run_now", - "pause", - "unpause", - "delete", - "kill", - "inspect", - "sessions", - "session_content" - ], - "type": "string" - }, - "cron_expression": { - "description": "A cron expression for create action. Supports both 5-field (minute hour day month weekday) and 6-field (second minute hour day month weekday) formats. 5-field expressions are automatically converted to 6-field by prepending '0' for seconds.", - "type": "string" - }, - "execution_mode": { - "default": "background", - "description": "Execution mode for create action: 'foreground' or 'background'", - "enum": [ - "foreground", - "background" - ], - "type": "string" - }, - "job_id": { - "description": "Job identifier for operations on existing jobs", - "type": "string" - }, - "limit": { - "default": 50, - "description": "Limit for sessions list", - "type": "integer" - }, - "recipe_path": { - "description": "Path to recipe file for create action", - "type": "string" - }, - "session_id": { - "description": "Session identifier for session_content action", - "type": "string" - } - }, - "required": [ - "action" - ], - "type": "object" - }, - "annotations": { - "title": "Manage scheduled recipes", - "readOnlyHint": false, - "destructiveHint": true, - "idempotentHint": false, - "openWorldHint": false - } - }, - { - "name": "dynamic_task__create_task", - "description": "Use this tool to create one or more dynamic tasks from a shared text instruction and varying parameters.How it works:\n - Provide a single text instruction\n - Use the 'task_parameters' field to pass an array of parameter sets\n - Each resulting task will use the same instruction with different parameter values\n This is useful when performing the same operation across many inputs (e.g., getting weather for multiple cities, searching multiple slack channels, iterating through various linear tickets, etc).\n Once created, these tasks should be passed to the 'subagent__execute_task' tool for execution. Tasks can run sequentially or in parallel.\n ---\n What is a 'subagent'?\n A 'subagent' is a stateless sub-process that executes a single task independently. Use subagents when:\n - You want to parallelize similar work across different inputs\n - You are not sure your search or operation will succeed on the first try\n Each subagent receives a task with a defined payload and returns a result, which is not visible to the user unless explicitly summarized by the system.\n ---\n Examples of 'task_parameters' for a single task:\n text_instruction: Search for the config file in the root directory.\n Examples of 'task_parameters' for multiple tasks:\n text_instruction: Get weather for Melbourne.\n timeout_seconds: 300\n text_instruction: Get weather for Los Angeles.\n timeout_seconds: 300\n text_instruction: Get weather for San Francisco.\n timeout_seconds: 300\n ", - "inputSchema": { - "properties": { - "task_parameters": { - "description": "Array of parameter sets for creating tasks. For a single task, provide an array with one element. For multiple tasks, provide an array with multiple elements, each with different parameter values. If there is no parameter set, provide an empty array.", - "items": { - "properties": { - "text_instruction": { - "description": "The text instruction to execute", - "type": "string" - }, - "timeout_seconds": { - "description": "Optional timeout for the task in seconds (default: 300)", - "minimum": 1, - "type": "integer" - } - }, - "required": [ - "text_instruction" - ], - "type": "object" - }, - "type": "array" - } - }, - "type": "object" - }, - "annotations": { - "title": "Dynamic Task Creation", - "readOnlyHint": false, - "destructiveHint": true, - "idempotentHint": false, - "openWorldHint": true - } - }, - { - "name": "subagent__execute_task", - "description": "Only use the subagent__execute_task tool when you execute sub recipe task or dynamic task.\nEXECUTION STRATEGY DECISION:\n1. If the tasks are created with execution_mode, use the execution_mode.\n2. Execute tasks sequentially unless user explicitly requests parallel execution. PARALLEL: User uses keywords like 'parallel', 'simultaneously', 'at the same time', 'concurrently'\n\nIMPLEMENTATION:\n- Sequential execution: Call this tool multiple times, passing exactly ONE task per call\n- Parallel execution: Call this tool once, passing an ARRAY of all tasks\n\nEXAMPLES:\nUser Intent Based:\n- User: 'get weather and tell me a joke' → Sequential (2 separate tool calls, 1 task each)\n- User: 'get weather and joke in parallel' → Parallel (1 tool call with array of 2 tasks)\n- User: 'run these simultaneously' → Parallel (1 tool call with task array)\n- User: 'do task A then task B' → Sequential (2 separate tool calls)", - "inputSchema": { - "properties": { - "execution_mode": { - "default": "sequential", - "description": "Execution strategy for multiple tasks. Use 'sequential' (default) unless user explicitly requests parallel execution with words like 'parallel', 'simultaneously', 'at the same time', or 'concurrently'.", - "enum": [ - "sequential", - "parallel" - ], - "type": "string" - }, - "task_ids": { - "items": { - "description": "Unique identifier for the task", - "type": "string" - }, - "type": "array" - } - }, - "required": [ - "task_ids" - ], - "type": "object" - }, - "annotations": { - "title": "Run tasks in parallel", - "readOnlyHint": false, - "destructiveHint": true, - "idempotentHint": false, - "openWorldHint": true - } - } - ] - }, - "output": { - "message": { - "id": null, - "role": "assistant", - "created": 1753196580, - "content": [ - { - "type": "text", - "text": "Goodbye! It was nice chatting with you. Feel free to come back anytime if you need help with tasks, have questions, or want to explore what extensions might be useful for your work. Have a great day! 👋" - } - ] - }, - "usage": { - "model": "us.anthropic.claude-sonnet-4-20250514-v1:0", - "usage": { - "input_tokens": 2700, - "output_tokens": 52, - "total_tokens": 2752 - } - } - } - }, - "205407e3c76ac3acb35d9da9f560058217d3b267873f8e0a715a1946e2714ddd": { - "input": { - "system": "You are a general-purpose AI agent called Goose, created by Block, the parent company of Square, CashApp, and Tidal. Goose is being developed as an open-source software project.\n\nThe current date is 2025-07-22 15:02:47.\n\nGoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o, claude-3.5-sonnet, o1, llama-3.2, deepseek-r1, etc).\nThese models have varying knowledge cut-off dates depending on when they were trained, but typically it's between 5-10 months prior to the current date.\n\n# Extensions\n\nExtensions allow other applications to provide context to Goose. Extensions connect Goose to different data sources and tools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level problems using the tools in these extensions, and can interact with multiple at once.\nUse the search_available_extensions tool to find additional extensions to enable to help with your task. To enable extensions, use the enable_extension tool and provide the extension_name. You should only enable extensions found from the search_available_extensions tool.\n\n\nNo extensions are defined. You should let the user know that they should add extensions.\n\n\n\n# Suggestion\n\"\"\n\n\n\n\n# Response Guidelines\n\n- Use Markdown formatting for all responses.\n- Follow best practices for Markdown, including:\n - Using headers for organization.\n - Bullet points for lists.\n - Links formatted correctly, either as linked text (e.g., [this is linked text](https://example.com)) or automatic links using angle brackets (e.g., ).\n- For code examples, use fenced code blocks by placing triple backticks (` ``` `) before and after the code. Include the language identifier after the opening backticks (e.g., ` ```python `) to enable syntax highlighting.\n- Ensure clarity, conciseness, and proper formatting to enhance readability and usability.\n\n# Additional Instructions:\n\nRight now you are *NOT* in the chat only mode and have access to tool use and system.", - "messages": [ - { - "id": null, - "role": "user", - "created": 1753196567, - "content": [ - { - "type": "text", - "text": "hello" - } - ] - } - ], - "tools": [ - { - "name": "platform__search_available_extensions", - "description": "Searches for additional extensions available to help complete tasks.\n Use this tool when you're unable to find a specific feature or functionality you need to complete your task, or when standard approaches aren't working.\n These extensions might provide the exact tools needed to solve your problem.\n If you find a relevant one, consider using your tools to enable it.", - "inputSchema": { - "properties": {}, - "required": [], - "type": "object" - }, - "annotations": { - "title": "Discover extensions", - "readOnlyHint": true, - "destructiveHint": false, - "idempotentHint": false, - "openWorldHint": false - } - }, - { - "name": "platform__manage_extensions", - "description": "Tool to manage extensions and tools in goose context.\n Enable or disable extensions to help complete tasks.\n Enable or disable an extension by providing the extension name.\n ", - "inputSchema": { - "properties": { - "action": { - "description": "The action to perform", - "enum": [ - "enable", - "disable" - ], - "type": "string" - }, - "extension_name": { - "description": "The name of the extension to enable", - "type": "string" - } - }, - "required": [ - "action", - "extension_name" - ], - "type": "object" - }, - "annotations": { - "title": "Enable or disable an extension", - "readOnlyHint": false, - "destructiveHint": false, - "idempotentHint": false, - "openWorldHint": false - } - }, - { - "name": "platform__manage_schedule", - "description": "Manage scheduled recipe execution for this Goose instance.\n\nActions:\n- \"list\": List all scheduled jobs\n- \"create\": Create a new scheduled job from a recipe file\n- \"run_now\": Execute a scheduled job immediately \n- \"pause\": Pause a scheduled job\n- \"unpause\": Resume a paused job\n- \"delete\": Remove a scheduled job\n- \"kill\": Terminate a currently running job\n- \"inspect\": Get details about a running job\n- \"sessions\": List execution history for a job\n- \"session_content\": Get the full content (messages) of a specific session\n", - "inputSchema": { - "properties": { - "action": { - "enum": [ - "list", - "create", - "run_now", - "pause", - "unpause", - "delete", - "kill", - "inspect", - "sessions", - "session_content" - ], - "type": "string" - }, - "cron_expression": { - "description": "A cron expression for create action. Supports both 5-field (minute hour day month weekday) and 6-field (second minute hour day month weekday) formats. 5-field expressions are automatically converted to 6-field by prepending '0' for seconds.", - "type": "string" - }, - "execution_mode": { - "default": "background", - "description": "Execution mode for create action: 'foreground' or 'background'", - "enum": [ - "foreground", - "background" - ], - "type": "string" - }, - "job_id": { - "description": "Job identifier for operations on existing jobs", - "type": "string" - }, - "limit": { - "default": 50, - "description": "Limit for sessions list", - "type": "integer" - }, - "recipe_path": { - "description": "Path to recipe file for create action", - "type": "string" - }, - "session_id": { - "description": "Session identifier for session_content action", - "type": "string" - } - }, - "required": [ - "action" - ], - "type": "object" - }, - "annotations": { - "title": "Manage scheduled recipes", - "readOnlyHint": false, - "destructiveHint": true, - "idempotentHint": false, - "openWorldHint": false - } - }, - { - "name": "dynamic_task__create_task", - "description": "Use this tool to create one or more dynamic tasks from a shared text instruction and varying parameters.How it works:\n - Provide a single text instruction\n - Use the 'task_parameters' field to pass an array of parameter sets\n - Each resulting task will use the same instruction with different parameter values\n This is useful when performing the same operation across many inputs (e.g., getting weather for multiple cities, searching multiple slack channels, iterating through various linear tickets, etc).\n Once created, these tasks should be passed to the 'subagent__execute_task' tool for execution. Tasks can run sequentially or in parallel.\n ---\n What is a 'subagent'?\n A 'subagent' is a stateless sub-process that executes a single task independently. Use subagents when:\n - You want to parallelize similar work across different inputs\n - You are not sure your search or operation will succeed on the first try\n Each subagent receives a task with a defined payload and returns a result, which is not visible to the user unless explicitly summarized by the system.\n ---\n Examples of 'task_parameters' for a single task:\n text_instruction: Search for the config file in the root directory.\n Examples of 'task_parameters' for multiple tasks:\n text_instruction: Get weather for Melbourne.\n timeout_seconds: 300\n text_instruction: Get weather for Los Angeles.\n timeout_seconds: 300\n text_instruction: Get weather for San Francisco.\n timeout_seconds: 300\n ", - "inputSchema": { - "properties": { - "task_parameters": { - "description": "Array of parameter sets for creating tasks. For a single task, provide an array with one element. For multiple tasks, provide an array with multiple elements, each with different parameter values. If there is no parameter set, provide an empty array.", - "items": { - "properties": { - "text_instruction": { - "description": "The text instruction to execute", - "type": "string" - }, - "timeout_seconds": { - "description": "Optional timeout for the task in seconds (default: 300)", - "minimum": 1, - "type": "integer" - } - }, - "required": [ - "text_instruction" - ], - "type": "object" - }, - "type": "array" - } - }, - "type": "object" - }, - "annotations": { - "title": "Dynamic Task Creation", - "readOnlyHint": false, - "destructiveHint": true, - "idempotentHint": false, - "openWorldHint": true - } - }, - { - "name": "subagent__execute_task", - "description": "Only use the subagent__execute_task tool when you execute sub recipe task or dynamic task.\nEXECUTION STRATEGY DECISION:\n1. If the tasks are created with execution_mode, use the execution_mode.\n2. Execute tasks sequentially unless user explicitly requests parallel execution. PARALLEL: User uses keywords like 'parallel', 'simultaneously', 'at the same time', 'concurrently'\n\nIMPLEMENTATION:\n- Sequential execution: Call this tool multiple times, passing exactly ONE task per call\n- Parallel execution: Call this tool once, passing an ARRAY of all tasks\n\nEXAMPLES:\nUser Intent Based:\n- User: 'get weather and tell me a joke' → Sequential (2 separate tool calls, 1 task each)\n- User: 'get weather and joke in parallel' → Parallel (1 tool call with array of 2 tasks)\n- User: 'run these simultaneously' → Parallel (1 tool call with task array)\n- User: 'do task A then task B' → Sequential (2 separate tool calls)", - "inputSchema": { - "properties": { - "execution_mode": { - "default": "sequential", - "description": "Execution strategy for multiple tasks. Use 'sequential' (default) unless user explicitly requests parallel execution with words like 'parallel', 'simultaneously', 'at the same time', or 'concurrently'.", - "enum": [ - "sequential", - "parallel" - ], - "type": "string" - }, - "task_ids": { - "items": { - "description": "Unique identifier for the task", - "type": "string" - }, - "type": "array" - } - }, - "required": [ - "task_ids" - ], - "type": "object" - }, - "annotations": { - "title": "Run tasks in parallel", - "readOnlyHint": false, - "destructiveHint": true, - "idempotentHint": false, - "openWorldHint": true - } - } - ] - }, - "output": { - "message": { - "id": null, - "role": "assistant", - "created": 1753196578, - "content": [ - { - "type": "text", - "text": "Hello! I'm Goose, an AI agent created by Block. I'm here to help you with various tasks and questions.\n\nI notice that you don't currently have any extensions enabled. Extensions allow me to connect to different data sources and tools to help you accomplish more complex tasks. \n\nHere's what I can help you with right now:\n- **General conversation and questions**\n- **Task management** - I can create and execute dynamic tasks\n- **Scheduling** - I can manage scheduled recipe execution\n- **Extension management** - I can search for and enable additional capabilities\n\nTo get the most out of our interaction, you might want to:\n1. Let me search for available extensions that could help with your specific needs\n2. Tell me what kind of tasks you're looking to accomplish\n\nWhat would you like to do today?" - } - ] - }, - "usage": { - "model": "us.anthropic.claude-sonnet-4-20250514-v1:0", - "usage": { - "input_tokens": 2517, - "output_tokens": 179, - "total_tokens": 2696 - } - } - } - } -} \ No newline at end of file diff --git a/crates/goose-cli/src/scenario_tests/scenarios.rs b/crates/goose-cli/src/scenario_tests/scenarios.rs index 22d0e16e4937..13edcae35d9d 100644 --- a/crates/goose-cli/src/scenario_tests/scenarios.rs +++ b/crates/goose-cli/src/scenario_tests/scenarios.rs @@ -5,7 +5,7 @@ mod tests { #[tokio::test] async fn test_basic_greeting() -> Result<()> { - run_multi_provider_scenario("multi_basic_greeting", &["hello", "goodbye"], |result| { + run_multi_provider_scenario("basic_greeting", &["hello", "goodbye"], |result| { assert!(result .message_contents() .iter() From 92e3b787798be307fd6899103362c26d4b4f0152 Mon Sep 17 00:00:00 2001 From: Douwe Osinga Date: Fri, 25 Jul 2025 19:31:59 +0200 Subject: [PATCH 07/18] Simplify --- crates/goose-cli/src/scenario_tests/mod.rs | 18 ++++++------------ 1 file changed, 6 insertions(+), 12 deletions(-) diff --git a/crates/goose-cli/src/scenario_tests/mod.rs b/crates/goose-cli/src/scenario_tests/mod.rs index c9fe63f0b088..b488260ddaf1 100644 --- a/crates/goose-cli/src/scenario_tests/mod.rs +++ b/crates/goose-cli/src/scenario_tests/mod.rs @@ -296,11 +296,9 @@ pub async fn run_test_scenario(test_name: &str, inputs: &[&str]) -> Result Date: Sat, 26 Jul 2025 18:03:17 +0200 Subject: [PATCH 08/18] Check point --- crates/goose-cli/src/scenario_tests/mod.rs | 145 +++++++----------- .../goose-cli/src/scenario_tests/scenarios.rs | 10 +- 2 files changed, 59 insertions(+), 96 deletions(-) diff --git a/crates/goose-cli/src/scenario_tests/mod.rs b/crates/goose-cli/src/scenario_tests/mod.rs index b488260ddaf1..de1ede262555 100644 --- a/crates/goose-cli/src/scenario_tests/mod.rs +++ b/crates/goose-cli/src/scenario_tests/mod.rs @@ -8,7 +8,6 @@ use goose::message::Message; use goose::model::ModelConfig; use goose::providers::{create, testprovider::TestProvider}; use std::collections::HashMap; -use std::future::Future; use std::path::Path; use std::sync::{Arc, LazyLock}; @@ -86,11 +85,16 @@ impl ScenarioResult { } } -async fn run_all_providers_scenario(test_name: &str, test_fn: F) -> Result<()> +pub async fn run_multi_provider_scenario( + test_name: &str, + inputs: &[&str], + validator: F, +) -> Result<()> where - F: Fn(String, String, String, String) -> Fut, - Fut: Future>, + F: Fn(&ScenarioResult) -> Result<()> + Send + Sync + 'static, { + let inputs_owned: Vec = inputs.iter().map(|s| s.to_string()).collect(); + if let Ok(only_provider) = std::env::var("GOOSE_TEST_PROVIDER") { let config = PROVIDER_CONFIGS .iter() @@ -108,15 +112,16 @@ where })?; println!("Running test '{}' for provider: {}", test_name, config.name); - return run_provider_scenario(config, &test_fn, test_name) - .await - .map(|_| ()); + run_provider_scenario_with_validation(config, test_name, &inputs_owned, &validator).await?; + return Ok(()); } let mut failures = Vec::new(); for config in &*PROVIDER_CONFIGS { - match run_provider_scenario(config, &test_fn, test_name).await { + match run_provider_scenario_with_validation(config, test_name, &inputs_owned, &validator) + .await + { Ok(_) => println!("✅ {} - {}", test_name, config.name), Err(e) => { println!("❌ {} - {} FAILED: {}", test_name, config.name, e); @@ -140,16 +145,16 @@ where Ok(()) } -async fn run_provider_scenario( +async fn run_provider_scenario_with_validation( config: &ProviderConfig, - test_fn: &F, test_name: &str, -) -> Result + inputs: &[String], + validator: &F, +) -> Result<()> where - F: Fn(String, String, String, String) -> Fut, - Fut: Future>, + F: Fn(&ScenarioResult) -> Result<()>, { - if let Ok(path) = dotenvy::dotenv() { + if let Ok(path) = dotenv() { println!("Loaded environment from {:?}", path); } @@ -188,40 +193,10 @@ where "Skipping {} scenario - credentials not configured", config.name ); - return Ok(ScenarioResult { - messages: vec![], - error: Some("Skipped - credentials not configured".to_string()), - }); + return Ok(()); } - let result = test_fn( - test_name.to_string(), - config.name.to_string(), - config.name_for_factory(), - config.model_name.to_string(), - ) - .await; - - for (&var, value) in original_env.iter() { - std::env::set_var(var, value); - } - if let Some(mods) = &config.env_modifications { - for &var in mods.keys() { - if !original_env.contains_key(var) { - std::env::remove_var(var); - } - } - } - - result -} - -async fn run_single_provider_scenario( - test_name: &str, - factory_name: &str, - model_name: &str, - inputs: &[&str], -) -> Result<(ScenarioResult, Option>)> { + let factory_name = config.name_for_factory(); let manifest_dir = env!("CARGO_MANIFEST_DIR"); let file_path = format!( "{}/src/scenario_tests/recordings/{}/{}.json", @@ -240,6 +215,16 @@ async fn run_single_provider_scenario( Ok(test_provider) => (Arc::new(test_provider), None), Err(e) => { let _ = std::fs::remove_file(&file_path); + for (&var, value) in original_env.iter() { + std::env::set_var(var, value); + } + if let Some(mods) = &config.env_modifications { + for &var in mods.keys() { + if !original_env.contains_key(var) { + std::env::remove_var(var); + } + } + } return Err(anyhow::anyhow!( "Test replay failed for '{}' ({}): {}. File deleted - re-run test to record fresh data.", test_name, factory_name, e @@ -254,7 +239,10 @@ async fn run_single_provider_scenario( file_path ); } - let inner_provider = create(factory_name, ModelConfig::new(model_name.to_string()))?; + let inner_provider = create( + &factory_name, + ModelConfig::new(config.model_name.to_string()), + )?; let test_provider = Arc::new(TestProvider::new_recording(inner_provider, &file_path)); (test_provider.clone(), Some(test_provider)) }; @@ -279,6 +267,16 @@ async fn run_single_provider_scenario( if let Some(ref err_msg) = error { if err_msg.contains("No recorded response found") { let _ = std::fs::remove_file(&file_path); + for (&var, value) in original_env.iter() { + std::env::set_var(var, value); + } + if let Some(mods) = &config.env_modifications { + for &var in mods.keys() { + if !original_env.contains_key(var) { + std::env::remove_var(var); + } + } + } return Err(anyhow::anyhow!( "Test replay failed for '{}' ({}) - missing recorded interaction: {}. File deleted - re-run test to record fresh data.", test_name, factory_name, err_msg @@ -287,12 +285,8 @@ async fn run_single_provider_scenario( } let result = ScenarioResult { messages, error }; - Ok((result, provider_for_saving)) -} -pub async fn run_test_scenario(test_name: &str, inputs: &[&str]) -> Result { - let (result, provider_for_saving) = - run_single_provider_scenario(test_name, "default", "default", inputs).await?; + validator(&result)?; if let Some(provider) = provider_for_saving { if result.error.is_none() { @@ -302,43 +296,16 @@ pub async fn run_test_scenario(test_name: &str, inputs: &[&str]) -> Result( - test_name: &str, - inputs: &[&str], - validator: F, -) -> Result<()> -where - F: Fn(&ScenarioResult) -> Result<()> + Send + Sync + 'static, -{ - let inputs_owned: Vec = inputs.iter().map(|s| s.to_string()).collect(); - - run_all_providers_scenario(test_name, |name, provider, factory_name, model_name| { - let inputs = inputs_owned.clone(); - let validator = &validator; - async move { - let (result, provider_for_saving) = run_single_provider_scenario( - &name, - &factory_name, - &model_name, - &inputs.iter().map(|s| s.as_str()).collect::>(), - ) - .await?; - - validator(&result)?; - - if let Some(provider) = provider_for_saving { - if result.error.is_none() { - Arc::try_unwrap(provider) - .map_err(|_| anyhow::anyhow!("Failed to unwrap provider for recording"))? - .finish_recording()?; - } + for (&var, value) in original_env.iter() { + std::env::set_var(var, value); + } + if let Some(mods) = &config.env_modifications { + for &var in mods.keys() { + if !original_env.contains_key(var) { + std::env::remove_var(var); } - - Ok(result) } - }) - .await + } + + Ok(()) } diff --git a/crates/goose-cli/src/scenario_tests/scenarios.rs b/crates/goose-cli/src/scenario_tests/scenarios.rs index 13edcae35d9d..fb82469bc1bb 100644 --- a/crates/goose-cli/src/scenario_tests/scenarios.rs +++ b/crates/goose-cli/src/scenario_tests/scenarios.rs @@ -4,16 +4,12 @@ mod tests { use anyhow::Result; #[tokio::test] - async fn test_basic_greeting() -> Result<()> { - run_multi_provider_scenario("basic_greeting", &["hello", "goodbye"], |result| { + async fn test_what_is_your_name() -> Result<()> { + run_multi_provider_scenario("what_is_your_name", &["what is your name"], |result| { assert!(result .message_contents() .iter() - .any(|msg| msg.contains("Hello"))); - assert!(result - .message_contents() - .iter() - .any(|msg| msg.contains("Goodbye"))); + .any(|msg| msg.to_lowercase().contains("goose"))); assert!(result.error.is_none()); Ok(()) }) From ca73fb52d683f5b0be9c18c4231efebca56adacb Mon Sep 17 00:00:00 2001 From: Douwe Osinga Date: Sat, 26 Jul 2025 19:13:56 +0200 Subject: [PATCH 09/18] Checkpoint --- crates/goose-cli/src/scenario_tests/mod.rs | 189 +++++++----------- .../src/scenario_tests/provider_configs.rs | 81 ++++++++ 2 files changed, 148 insertions(+), 122 deletions(-) create mode 100644 crates/goose-cli/src/scenario_tests/provider_configs.rs diff --git a/crates/goose-cli/src/scenario_tests/mod.rs b/crates/goose-cli/src/scenario_tests/mod.rs index de1ede262555..3a273c9b509b 100644 --- a/crates/goose-cli/src/scenario_tests/mod.rs +++ b/crates/goose-cli/src/scenario_tests/mod.rs @@ -1,6 +1,9 @@ +mod provider_configs; mod scenarios; + use dotenvy::dotenv; +use crate::scenario_tests::provider_configs::{ProviderConfig, PROVIDER_CONFIGS}; use crate::session::Session; use anyhow::Result; use goose::agents::Agent; @@ -9,65 +12,7 @@ use goose::model::ModelConfig; use goose::providers::{create, testprovider::TestProvider}; use std::collections::HashMap; use std::path::Path; -use std::sync::{Arc, LazyLock}; - -#[derive(Debug, Clone)] -struct ProviderConfig { - name: &'static str, - factory_name: Option<&'static str>, - model_name: &'static str, - required_env_vars: &'static [&'static str], - env_modifications: Option>>, -} - -impl ProviderConfig { - fn simple(name: &'static str, model_name: &'static str) -> Self { - let key = format!("{}_API_KEY", name.to_uppercase()); - let required_env_vars = - Box::leak(vec![Box::leak(key.into_boxed_str()) as &str].into_boxed_slice()); - - Self { - name, - factory_name: None, - model_name, - required_env_vars, - env_modifications: None, - } - } - - fn name_for_factory(&self) -> String { - self.factory_name - .map(|s| s.to_string()) - .unwrap_or_else(|| self.name.to_lowercase()) - } -} - -static PROVIDER_CONFIGS: LazyLock> = LazyLock::new(|| { - vec![ - ProviderConfig::simple("OpenAI", "gpt-4o"), - ProviderConfig::simple("Anthropic", "claude-3-5-sonnet-20241022"), - ProviderConfig { - name: "Azure", - factory_name: Some("azure_openai"), - model_name: "gpt-4o", - required_env_vars: &[ - "AZURE_OPENAI_API_KEY", - "AZURE_OPENAI_ENDPOINT", - "AZURE_OPENAI_DEPLOYMENT_NAME", - ], - env_modifications: None, - }, - ProviderConfig { - name: "Bedrock", - factory_name: Some("aws_bedrock"), - model_name: "anthropic.claude-3-5-sonnet-20241022-v2:0", - required_env_vars: &["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"], - env_modifications: None, - }, - ProviderConfig::simple("Google", "gemini-1.5-pro"), - ProviderConfig::simple("Groq", "llama-3.1-70b-versatile"), - ] -}); +use std::sync::Arc; #[derive(Debug, Clone)] pub struct ScenarioResult { @@ -158,44 +103,6 @@ where println!("Loaded environment from {:?}", path); } - let mut original_env = HashMap::new(); - - for &var in config.required_env_vars { - if let Ok(val) = std::env::var(var) { - original_env.insert(var, val); - } - } - - if let Some(mods) = &config.env_modifications { - for &var in mods.keys() { - if let Ok(val) = std::env::var(var) { - original_env.insert(var, val); - } - } - } - - if let Some(mods) = &config.env_modifications { - for (&var, value) in mods.iter() { - match value { - Some(val) => std::env::set_var(var, val), - None => std::env::remove_var(var), - } - } - } - - let missing_vars = config - .required_env_vars - .iter() - .any(|var| std::env::var(var).is_err()); - - if missing_vars { - println!( - "Skipping {} scenario - credentials not configured", - config.name - ); - return Ok(()); - } - let factory_name = config.name_for_factory(); let manifest_dir = env!("CARGO_MANIFEST_DIR"); let file_path = format!( @@ -210,21 +117,11 @@ where } let replay_mode = Path::new(&file_path).exists(); - let (provider_arc, provider_for_saving) = if replay_mode { + let (provider_arc, provider_for_saving, original_env) = if replay_mode { match TestProvider::new_replaying(&file_path) { - Ok(test_provider) => (Arc::new(test_provider), None), + Ok(test_provider) => (Arc::new(test_provider), None, None), Err(e) => { let _ = std::fs::remove_file(&file_path); - for (&var, value) in original_env.iter() { - std::env::set_var(var, value); - } - if let Some(mods) = &config.env_modifications { - for &var in mods.keys() { - if !original_env.contains_key(var) { - std::env::remove_var(var); - } - } - } return Err(anyhow::anyhow!( "Test replay failed for '{}' ({}): {}. File deleted - re-run test to record fresh data.", test_name, factory_name, e @@ -239,12 +136,20 @@ where file_path ); } + + let original_env = setup_environment(config)?; + let inner_provider = create( &factory_name, ModelConfig::new(config.model_name.to_string()), )?; + let test_provider = Arc::new(TestProvider::new_recording(inner_provider, &file_path)); - (test_provider.clone(), Some(test_provider)) + ( + test_provider.clone(), + Some(test_provider), + Some(original_env), + ) }; let agent = Agent::new(); @@ -267,16 +172,6 @@ where if let Some(ref err_msg) = error { if err_msg.contains("No recorded response found") { let _ = std::fs::remove_file(&file_path); - for (&var, value) in original_env.iter() { - std::env::set_var(var, value); - } - if let Some(mods) = &config.env_modifications { - for &var in mods.keys() { - if !original_env.contains_key(var) { - std::env::remove_var(var); - } - } - } return Err(anyhow::anyhow!( "Test replay failed for '{}' ({}) - missing recorded interaction: {}. File deleted - re-run test to record fresh data.", test_name, factory_name, err_msg @@ -288,6 +183,8 @@ where validator(&result)?; + drop(session); + if let Some(provider) = provider_for_saving { if result.error.is_none() { Arc::try_unwrap(provider) @@ -296,6 +193,56 @@ where } } + if let Some(env) = original_env { + restore_environment(config, &env); + } + + Ok(()) +} + +fn setup_environment(config: &ProviderConfig) -> Result> { + let mut original_env = HashMap::new(); + + for &var in config.required_env_vars { + if let Ok(val) = std::env::var(var) { + original_env.insert(var, val); + } + } + + if let Some(mods) = &config.env_modifications { + for &var in mods.keys() { + if let Ok(val) = std::env::var(var) { + original_env.insert(var, val); + } + } + } + + if let Some(mods) = &config.env_modifications { + for (&var, value) in mods.iter() { + match value { + Some(val) => std::env::set_var(var, val), + None => std::env::remove_var(var), + } + } + } + + let missing_vars = config + .required_env_vars + .iter() + .any(|var| std::env::var(var).is_err()); + + if missing_vars { + println!( + "Skipping {} scenario - credentials not configured", + config.name + ); + return Err(anyhow::anyhow!("Missing required environment variables")); + } + + Ok(original_env) +} + +fn restore_environment(config: &ProviderConfig, original_env: &HashMap<&'static str, String>) { for (&var, value) in original_env.iter() { std::env::set_var(var, value); } @@ -306,6 +253,4 @@ where } } } - - Ok(()) } diff --git a/crates/goose-cli/src/scenario_tests/provider_configs.rs b/crates/goose-cli/src/scenario_tests/provider_configs.rs new file mode 100644 index 000000000000..f5388ff3f09f --- /dev/null +++ b/crates/goose-cli/src/scenario_tests/provider_configs.rs @@ -0,0 +1,81 @@ +use std::collections::HashMap; +use std::sync::LazyLock; + +#[derive(Debug, Clone)] +pub struct ProviderConfig { + pub name: &'static str, + pub factory_name: Option<&'static str>, + pub model_name: &'static str, + pub required_env_vars: &'static [&'static str], + pub env_modifications: Option>>, + pub skip: bool, +} + +impl ProviderConfig { + fn simple(name: &'static str, model_name: &'static str) -> Self { + let key = format!("{}_API_KEY", name.to_uppercase()); + let required_env_vars = + Box::leak(vec![Box::leak(key.into_boxed_str()) as &str].into_boxed_slice()); + + Self { + name, + factory_name: None, + model_name, + required_env_vars, + env_modifications: None, + skip: false, + } + } + + fn simple_skip(name: &'static str, model_name: &'static str) -> Self { + let mut config = Self::simple(name, model_name); + config.skip = true; + config + } + + pub fn name_for_factory(&self) -> String { + self.factory_name + .map(|s| s.to_string()) + .unwrap_or_else(|| self.name.to_lowercase()) + } +} + +static PROVIDER_CONFIGS: LazyLock> = LazyLock::new(|| { + vec![ + ProviderConfig::simple("OpenAI", "gpt-4o"), + ProviderConfig::simple("Anthropic", "claude-3-5-sonnet-20241022"), + ProviderConfig { + name: "Azure", + factory_name: Some("azure_openai"), + model_name: "gpt-4o", + required_env_vars: &[ + "AZURE_OPENAI_API_KEY", + "AZURE_OPENAI_ENDPOINT", + "AZURE_OPENAI_DEPLOYMENT_NAME", + ], + env_modifications: None, + skip: false, + }, + ProviderConfig { + name: "Bedrock", + factory_name: Some("aws_bedrock"), + model_name: "anthropic.claude-3-5-sonnet-20241022-v2:0", + required_env_vars: &["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"], + env_modifications: None, + skip: false, + }, + ProviderConfig::simple("Google", "gemini-2.5-flash"), + ProviderConfig::simple_skip("Groq", "llama-3.1-70b-versatile"), + ] +}); + +pub fn get_provider_configs() -> &'static [ProviderConfig] { + &PROVIDER_CONFIGS +} + +pub fn get_active_provider_configs() -> Vec<&'static ProviderConfig> { + PROVIDER_CONFIGS + .iter() + .filter(|config| !config.skip) + .collect() +} From 5fbea04176bc4cb349e1d2f662c3142685cb16eb Mon Sep 17 00:00:00 2001 From: Douwe Osinga Date: Sat, 26 Jul 2025 20:28:04 +0200 Subject: [PATCH 10/18] Checkpoint --- .gitignore | 1 + crates/goose-cli/src/scenario_tests/mod.rs | 255 +----------------- .../src/scenario_tests/provider_configs.rs | 29 +- .../src/scenario_tests/scenario_runners.rs | 250 +++++++++++++++++ .../goose-cli/src/scenario_tests/scenarios.rs | 4 +- crates/goose/src/providers/groq.rs | 7 +- 6 files changed, 269 insertions(+), 277 deletions(-) create mode 100644 crates/goose-cli/src/scenario_tests/scenario_runners.rs diff --git a/.gitignore b/.gitignore index 41f629f09366..8c6129ab3b22 100644 --- a/.gitignore +++ b/.gitignore @@ -58,3 +58,4 @@ do_not_version/ /temporal.db /ui/desktop/src/bin/goose-scheduler-executor /ui/desktop/src/bin/goose +/.env diff --git a/crates/goose-cli/src/scenario_tests/mod.rs b/crates/goose-cli/src/scenario_tests/mod.rs index 3a273c9b509b..f440aba83523 100644 --- a/crates/goose-cli/src/scenario_tests/mod.rs +++ b/crates/goose-cli/src/scenario_tests/mod.rs @@ -1,256 +1,3 @@ mod provider_configs; +mod scenario_runners; mod scenarios; - -use dotenvy::dotenv; - -use crate::scenario_tests::provider_configs::{ProviderConfig, PROVIDER_CONFIGS}; -use crate::session::Session; -use anyhow::Result; -use goose::agents::Agent; -use goose::message::Message; -use goose::model::ModelConfig; -use goose::providers::{create, testprovider::TestProvider}; -use std::collections::HashMap; -use std::path::Path; -use std::sync::Arc; - -#[derive(Debug, Clone)] -pub struct ScenarioResult { - pub messages: Vec, - pub error: Option, -} - -impl ScenarioResult { - pub fn message_contents(&self) -> Vec { - self.messages - .iter() - .flat_map(|msg| &msg.content) - .map(|content| content.as_text().unwrap_or("").to_string()) - .collect() - } -} - -pub async fn run_multi_provider_scenario( - test_name: &str, - inputs: &[&str], - validator: F, -) -> Result<()> -where - F: Fn(&ScenarioResult) -> Result<()> + Send + Sync + 'static, -{ - let inputs_owned: Vec = inputs.iter().map(|s| s.to_string()).collect(); - - if let Ok(only_provider) = std::env::var("GOOSE_TEST_PROVIDER") { - let config = PROVIDER_CONFIGS - .iter() - .find(|c| c.name.to_lowercase() == only_provider.to_lowercase()) - .ok_or_else(|| { - anyhow::anyhow!( - "Provider '{}' not found. Available: {}", - only_provider, - PROVIDER_CONFIGS - .iter() - .map(|c| c.name) - .collect::>() - .join(", ") - ) - })?; - - println!("Running test '{}' for provider: {}", test_name, config.name); - run_provider_scenario_with_validation(config, test_name, &inputs_owned, &validator).await?; - return Ok(()); - } - - let mut failures = Vec::new(); - - for config in &*PROVIDER_CONFIGS { - match run_provider_scenario_with_validation(config, test_name, &inputs_owned, &validator) - .await - { - Ok(_) => println!("✅ {} - {}", test_name, config.name), - Err(e) => { - println!("❌ {} - {} FAILED: {}", test_name, config.name, e); - failures.push((config.name, e)); - } - } - } - - if !failures.is_empty() { - println!("\n=== Test Failures for {} ===", test_name); - for (provider, error) in &failures { - println!("❌ {}: {}", provider, error); - } - return Err(anyhow::anyhow!( - "Test '{}' failed for {} provider(s)", - test_name, - failures.len() - )); - } - - Ok(()) -} - -async fn run_provider_scenario_with_validation( - config: &ProviderConfig, - test_name: &str, - inputs: &[String], - validator: &F, -) -> Result<()> -where - F: Fn(&ScenarioResult) -> Result<()>, -{ - if let Ok(path) = dotenv() { - println!("Loaded environment from {:?}", path); - } - - let factory_name = config.name_for_factory(); - let manifest_dir = env!("CARGO_MANIFEST_DIR"); - let file_path = format!( - "{}/src/scenario_tests/recordings/{}/{}.json", - manifest_dir, - factory_name.to_lowercase(), - test_name - ); - - if let Some(parent) = Path::new(&file_path).parent() { - std::fs::create_dir_all(parent)?; - } - - let replay_mode = Path::new(&file_path).exists(); - let (provider_arc, provider_for_saving, original_env) = if replay_mode { - match TestProvider::new_replaying(&file_path) { - Ok(test_provider) => (Arc::new(test_provider), None, None), - Err(e) => { - let _ = std::fs::remove_file(&file_path); - return Err(anyhow::anyhow!( - "Test replay failed for '{}' ({}): {}. File deleted - re-run test to record fresh data.", - test_name, factory_name, e - )); - } - } - } else { - if std::env::var("GITHUB_ACTIONS").is_ok() { - panic!( - "Test recording is not supported on CI. \ - Did you forget to add the file {} to the repository and were expecting that to replay?", - file_path - ); - } - - let original_env = setup_environment(config)?; - - let inner_provider = create( - &factory_name, - ModelConfig::new(config.model_name.to_string()), - )?; - - let test_provider = Arc::new(TestProvider::new_recording(inner_provider, &file_path)); - ( - test_provider.clone(), - Some(test_provider), - Some(original_env), - ) - }; - - let agent = Agent::new(); - agent - .update_provider(provider_arc as Arc) - .await?; - - let mut session = Session::new(agent, None, false, None, None, None, None); - - let mut error = None; - for input in inputs { - if let Err(e) = session.headless(input.to_string()).await { - error = Some(e.to_string()); - break; - } - } - - let messages = session.message_history().to_vec(); - - if let Some(ref err_msg) = error { - if err_msg.contains("No recorded response found") { - let _ = std::fs::remove_file(&file_path); - return Err(anyhow::anyhow!( - "Test replay failed for '{}' ({}) - missing recorded interaction: {}. File deleted - re-run test to record fresh data.", - test_name, factory_name, err_msg - )); - } - } - - let result = ScenarioResult { messages, error }; - - validator(&result)?; - - drop(session); - - if let Some(provider) = provider_for_saving { - if result.error.is_none() { - Arc::try_unwrap(provider) - .map_err(|_| anyhow::anyhow!("Failed to unwrap provider for recording"))? - .finish_recording()?; - } - } - - if let Some(env) = original_env { - restore_environment(config, &env); - } - - Ok(()) -} - -fn setup_environment(config: &ProviderConfig) -> Result> { - let mut original_env = HashMap::new(); - - for &var in config.required_env_vars { - if let Ok(val) = std::env::var(var) { - original_env.insert(var, val); - } - } - - if let Some(mods) = &config.env_modifications { - for &var in mods.keys() { - if let Ok(val) = std::env::var(var) { - original_env.insert(var, val); - } - } - } - - if let Some(mods) = &config.env_modifications { - for (&var, value) in mods.iter() { - match value { - Some(val) => std::env::set_var(var, val), - None => std::env::remove_var(var), - } - } - } - - let missing_vars = config - .required_env_vars - .iter() - .any(|var| std::env::var(var).is_err()); - - if missing_vars { - println!( - "Skipping {} scenario - credentials not configured", - config.name - ); - return Err(anyhow::anyhow!("Missing required environment variables")); - } - - Ok(original_env) -} - -fn restore_environment(config: &ProviderConfig, original_env: &HashMap<&'static str, String>) { - for (&var, value) in original_env.iter() { - std::env::set_var(var, value); - } - if let Some(mods) = &config.env_modifications { - for &var in mods.keys() { - if !original_env.contains_key(var) { - std::env::remove_var(var); - } - } - } -} diff --git a/crates/goose-cli/src/scenario_tests/provider_configs.rs b/crates/goose-cli/src/scenario_tests/provider_configs.rs index f5388ff3f09f..b812fcb8b771 100644 --- a/crates/goose-cli/src/scenario_tests/provider_configs.rs +++ b/crates/goose-cli/src/scenario_tests/provider_configs.rs @@ -8,7 +8,7 @@ pub struct ProviderConfig { pub model_name: &'static str, pub required_env_vars: &'static [&'static str], pub env_modifications: Option>>, - pub skip: bool, + pub skip_reason: Option<&'static str>, } impl ProviderConfig { @@ -23,21 +23,19 @@ impl ProviderConfig { model_name, required_env_vars, env_modifications: None, - skip: false, + skip_reason: None, } } - fn simple_skip(name: &'static str, model_name: &'static str) -> Self { - let mut config = Self::simple(name, model_name); - config.skip = true; - config - } - pub fn name_for_factory(&self) -> String { self.factory_name .map(|s| s.to_string()) .unwrap_or_else(|| self.name.to_lowercase()) } + + pub fn is_skipped(&self) -> bool { + self.skip_reason.is_some() + } } static PROVIDER_CONFIGS: LazyLock> = LazyLock::new(|| { @@ -54,7 +52,7 @@ static PROVIDER_CONFIGS: LazyLock> = LazyLock::new(|| { "AZURE_OPENAI_DEPLOYMENT_NAME", ], env_modifications: None, - skip: false, + skip_reason: None, }, ProviderConfig { name: "Bedrock", @@ -62,20 +60,17 @@ static PROVIDER_CONFIGS: LazyLock> = LazyLock::new(|| { model_name: "anthropic.claude-3-5-sonnet-20241022-v2:0", required_env_vars: &["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"], env_modifications: None, - skip: false, + skip_reason: Some("No valid keys around"), }, ProviderConfig::simple("Google", "gemini-2.5-flash"), - ProviderConfig::simple_skip("Groq", "llama-3.1-70b-versatile"), + ProviderConfig::simple("Groq", "llama-3.3-70b-versatile"), + ProviderConfig::simple("OpenRouter", "anthropic/claude-3.5-sonnet"), ] }); -pub fn get_provider_configs() -> &'static [ProviderConfig] { - &PROVIDER_CONFIGS -} - -pub fn get_active_provider_configs() -> Vec<&'static ProviderConfig> { +pub fn get_provider_configs() -> Vec<&'static ProviderConfig> { PROVIDER_CONFIGS .iter() - .filter(|config| !config.skip) + .filter(|config| !config.is_skipped()) .collect() } diff --git a/crates/goose-cli/src/scenario_tests/scenario_runners.rs b/crates/goose-cli/src/scenario_tests/scenario_runners.rs new file mode 100644 index 000000000000..e76eb41e2681 --- /dev/null +++ b/crates/goose-cli/src/scenario_tests/scenario_runners.rs @@ -0,0 +1,250 @@ +use dotenvy::dotenv; + +use crate::scenario_tests::provider_configs::{get_provider_configs, ProviderConfig}; +use crate::session::Session; +use anyhow::Result; +use goose::agents::Agent; +use goose::message::Message; +use goose::model::ModelConfig; +use goose::providers::{create, testprovider::TestProvider}; +use std::collections::HashMap; +use std::path::Path; +use std::sync::Arc; + +#[derive(Debug, Clone)] +pub struct ScenarioResult { + pub messages: Vec, + pub error: Option, +} + +impl ScenarioResult { + pub fn message_contents(&self) -> Vec { + self.messages + .iter() + .flat_map(|msg| &msg.content) + .map(|content| content.as_text().unwrap_or("").to_string()) + .collect() + } +} + +pub async fn run_scenario(test_name: &str, inputs: &[&str], validator: F) -> Result<()> +where + F: Fn(&ScenarioResult) -> Result<()> + Send + Sync + 'static, +{ + let inputs_owned: Vec = inputs.iter().map(|s| s.to_string()).collect(); + + if let Ok(only_provider) = std::env::var("GOOSE_TEST_PROVIDER") { + let active_providers = get_provider_configs(); + let config = active_providers + .iter() + .find(|c| c.name.to_lowercase() == only_provider.to_lowercase()) + .ok_or_else(|| { + anyhow::anyhow!( + "Provider '{}' not found. Available: {}", + only_provider, + get_provider_configs() + .iter() + .map(|c| c.name) + .collect::>() + .join(", ") + ) + })?; + + println!("Running test '{}' for provider: {}", test_name, config.name); + run_provider_scenario_with_validation(config, test_name, &inputs_owned, &validator).await?; + return Ok(()); + } + + let mut failures = Vec::new(); + + for config in get_provider_configs() { + match run_provider_scenario_with_validation(config, test_name, &inputs_owned, &validator) + .await + { + Ok(_) => println!("✅ {} - {}", test_name, config.name), + Err(e) => { + println!("❌ {} - {} FAILED: {}", test_name, config.name, e); + failures.push((config.name, e)); + } + } + } + + if !failures.is_empty() { + println!("\n=== Test Failures for {} ===", test_name); + for (provider, error) in &failures { + println!("❌ {}: {}", provider, error); + } + return Err(anyhow::anyhow!( + "Test '{}' failed for {} provider(s)", + test_name, + failures.len() + )); + } + + Ok(()) +} + +async fn run_provider_scenario_with_validation( + config: &ProviderConfig, + test_name: &str, + inputs: &[String], + validator: &F, +) -> Result<()> +where + F: Fn(&ScenarioResult) -> Result<()>, +{ + if let Ok(path) = dotenv() { + println!("Loaded environment from {:?}", path); + } + + let factory_name = config.name_for_factory(); + let manifest_dir = env!("CARGO_MANIFEST_DIR"); + let file_path = format!( + "{}/src/scenario_tests/recordings/{}/{}.json", + manifest_dir, + factory_name.to_lowercase(), + test_name + ); + + if let Some(parent) = Path::new(&file_path).parent() { + std::fs::create_dir_all(parent)?; + } + + let replay_mode = Path::new(&file_path).exists(); + let (provider_arc, provider_for_saving, original_env) = if replay_mode { + match TestProvider::new_replaying(&file_path) { + Ok(test_provider) => (Arc::new(test_provider), None, None), + Err(e) => { + let _ = std::fs::remove_file(&file_path); + return Err(anyhow::anyhow!( + "Test replay failed for '{}' ({}): {}. File deleted - re-run test to record fresh data.", + test_name, factory_name, e + )); + } + } + } else { + if std::env::var("GITHUB_ACTIONS").is_ok() { + panic!( + "Test recording is not supported on CI. \ + Did you forget to add the file {} to the repository and were expecting that to replay?", + file_path + ); + } + + let original_env = setup_environment(config)?; + + let inner_provider = create( + &factory_name, + ModelConfig::new(config.model_name.to_string()), + )?; + + let test_provider = Arc::new(TestProvider::new_recording(inner_provider, &file_path)); + ( + test_provider.clone(), + Some(test_provider), + Some(original_env), + ) + }; + + let agent = Agent::new(); + agent + .update_provider(provider_arc as Arc) + .await?; + + let mut session = Session::new(agent, None, false, None, None, None, None); + + let mut error = None; + for input in inputs { + if let Err(e) = session.headless(input.to_string()).await { + error = Some(e.to_string()); + break; + } + } + + let messages = session.message_history().to_vec(); + + if let Some(ref err_msg) = error { + if err_msg.contains("No recorded response found") { + let _ = std::fs::remove_file(&file_path); + return Err(anyhow::anyhow!( + "Test replay failed for '{}' ({}) - missing recorded interaction: {}. File deleted - re-run test to record fresh data.", + test_name, factory_name, err_msg + )); + } + } + + let result = ScenarioResult { messages, error }; + + validator(&result)?; + + drop(session); + + if let Some(provider) = provider_for_saving { + if result.error.is_none() { + Arc::try_unwrap(provider) + .map_err(|_| anyhow::anyhow!("Failed to unwrap provider for recording"))? + .finish_recording()?; + } + } + + if let Some(env) = original_env { + restore_environment(config, &env); + } + + Ok(()) +} + +fn setup_environment(config: &ProviderConfig) -> Result> { + let mut original_env = HashMap::new(); + + for &var in config.required_env_vars { + if let Ok(val) = std::env::var(var) { + original_env.insert(var, val); + } + } + + if let Some(mods) = &config.env_modifications { + for &var in mods.keys() { + if let Ok(val) = std::env::var(var) { + original_env.insert(var, val); + } + } + } + + if let Some(mods) = &config.env_modifications { + for (&var, value) in mods.iter() { + match value { + Some(val) => std::env::set_var(var, val), + None => std::env::remove_var(var), + } + } + } + + let missing_vars = config + .required_env_vars + .iter() + .any(|var| std::env::var(var).is_err()); + + if missing_vars { + println!( + "Skipping {} scenario - credentials not configured", + config.name + ); + return Err(anyhow::anyhow!("Missing required environment variables")); + } + + Ok(original_env) +} + +fn restore_environment(config: &ProviderConfig, original_env: &HashMap<&'static str, String>) { + for (&var, value) in original_env.iter() { + std::env::set_var(var, value); + } + if let Some(mods) = &config.env_modifications { + for &var in mods.keys() { + if !original_env.contains_key(var) { + std::env::remove_var(var); + } + } + } +} diff --git a/crates/goose-cli/src/scenario_tests/scenarios.rs b/crates/goose-cli/src/scenario_tests/scenarios.rs index fb82469bc1bb..84644486bfc8 100644 --- a/crates/goose-cli/src/scenario_tests/scenarios.rs +++ b/crates/goose-cli/src/scenario_tests/scenarios.rs @@ -1,11 +1,11 @@ #[cfg(test)] mod tests { - use crate::scenario_tests::run_multi_provider_scenario; + use crate::scenario_tests::scenario_runners::run_scenario; use anyhow::Result; #[tokio::test] async fn test_what_is_your_name() -> Result<()> { - run_multi_provider_scenario("what_is_your_name", &["what is your name"], |result| { + run_scenario("what_is_your_name", &["what is your name"], |result| { assert!(result .message_contents() .iter() diff --git a/crates/goose/src/providers/groq.rs b/crates/goose/src/providers/groq.rs index c508d290df33..8b95988d110e 100644 --- a/crates/goose/src/providers/groq.rs +++ b/crates/goose/src/providers/groq.rs @@ -88,10 +88,9 @@ impl GroqProvider { Err(ProviderError::ServerError(format!("{:?}", payload))) } _ => { - tracing::debug!( - "{}", format!("Provider request failed with status: {}. Payload: {:?}", status, payload) - ); - Err(ProviderError::RequestFailed(format!("Request failed with status: {}", status))) + let error_msg = format!("Provider request failed with status: {}. Payload: {:?}", status, payload); + tracing::debug!(error_msg); + Err(ProviderError::RequestFailed(error_msg)) } } } From 6fda2dbfced474876e24655acc3c8793c2acd936 Mon Sep 17 00:00:00 2001 From: Douwe Osinga Date: Sun, 27 Jul 2025 19:31:19 +0200 Subject: [PATCH 11/18] Now we have tool calling --- .../src/scenario_tests/mock_client.rs | 146 ++++++++++++++++++ crates/goose-cli/src/scenario_tests/mod.rs | 3 +- .../src/scenario_tests/provider_configs.rs | 18 ++- ...scenario_runners.rs => scenario_runner.rs} | 16 ++ .../goose-cli/src/scenario_tests/scenarios.rs | 36 ++++- crates/goose/src/agents/agent.rs | 2 +- crates/goose/src/agents/extension_manager.rs | 10 +- crates/goose/src/agents/reply_parts.rs | 4 +- 8 files changed, 219 insertions(+), 16 deletions(-) create mode 100644 crates/goose-cli/src/scenario_tests/mock_client.rs rename crates/goose-cli/src/scenario_tests/{scenario_runners.rs => scenario_runner.rs} (93%) diff --git a/crates/goose-cli/src/scenario_tests/mock_client.rs b/crates/goose-cli/src/scenario_tests/mock_client.rs new file mode 100644 index 000000000000..876d246e959b --- /dev/null +++ b/crates/goose-cli/src/scenario_tests/mock_client.rs @@ -0,0 +1,146 @@ +use mcp_client::client::{ClientCapabilities, ClientInfo, Error, McpClientTrait}; +use mcp_core::protocol::{ + CallToolResult, GetPromptResult, Implementation, InitializeResult, ListPromptsResult, + ListResourcesResult, ListToolsResult, ReadResourceResult, ServerCapabilities, ToolsCapability, +}; +use mcp_core::{Tool, ToolError}; +use rmcp::model::{Content, JsonRpcMessage}; +use serde_json::Value; +use std::collections::HashMap; +use tokio::sync::mpsc::{self, Receiver}; + +// MockClient is a mock implementation of the McpClientTrait for testing purposes. +// add a tool and then add the client to the extension router +pub struct MockClient { + tools: HashMap, + handlers: HashMap Result, ToolError> + Send + Sync>>, +} + +impl MockClient { + pub(crate) fn new() -> Self { + Self { + tools: HashMap::new(), + handlers: HashMap::new(), + } + } + + pub(crate) fn add_tool(mut self, tool: Tool, handler: F) -> Self + where + F: Fn(&Value) -> Result, ToolError> + Send + Sync + 'static, + { + let tool_name = tool.name.clone(); + self.tools.insert(tool_name.clone(), tool); + self.handlers.insert(tool_name, Box::new(handler)); + self + } +} + +#[async_trait::async_trait] +impl McpClientTrait for MockClient { + async fn initialize( + &mut self, + _: ClientInfo, + _: ClientCapabilities, + ) -> Result { + Ok(InitializeResult { + protocol_version: "2024-11-05".to_string(), + capabilities: ServerCapabilities { + prompts: None, + resources: None, + tools: Some(ToolsCapability { list_changed: None }), + }, + server_info: Implementation { + name: "MockClient".to_string(), + version: "1.0.0".to_string(), + }, + instructions: None, + }) + } + + async fn list_resources( + &self, + _next_cursor: Option, + ) -> Result { + Ok(ListResourcesResult { + resources: vec![], + next_cursor: None, + }) + } + + async fn read_resource(&self, _uri: &str) -> Result { + Err(Error::UnexpectedResponse( + "Resources not supported by mock client".to_string(), + )) + } + + async fn list_tools(&self, _: Option) -> Result { + Ok(ListToolsResult { + tools: self.tools.values().cloned().collect(), + next_cursor: None, + }) + } + + async fn call_tool(&self, name: &str, arguments: Value) -> Result { + if let Some(handler) = self.handlers.get(name) { + match handler(&arguments) { + Ok(content) => Ok(CallToolResult { + content, + is_error: None, + }), + Err(e) => Err(Error::UnexpectedResponse(e.to_string())), + } + } else { + Err(Error::UnexpectedResponse(format!( + "Tool '{}' not found", + name + ))) + } + } + + async fn list_prompts(&self, _next_cursor: Option) -> Result { + Ok(ListPromptsResult { prompts: vec![] }) + } + + async fn get_prompt(&self, _name: &str, _arguments: Value) -> Result { + Err(Error::UnexpectedResponse( + "Prompts not supported by mock client".to_string(), + )) + } + + async fn subscribe(&self) -> Receiver { + mpsc::channel(1).1 + } +} + +pub const WEATHER_TYPE: &str = "cloudy"; + +pub fn weather_client() -> MockClient { + let weather_tool = Tool::new( + "get_weather", + "Get the weather for a location", + serde_json::json!({ + "type": "object", + "required": ["location"], + "properties": { + "location": { + "type": "string", + "description": "The city and state, e.g. San Francisco, CA" + } + } + }), + None, + ); + + let mock_client = MockClient::new().add_tool(weather_tool, |args| { + let location = args + .get("location") + .and_then(|v| v.as_str()) + .unwrap_or("unknown location"); + + Ok(vec![Content::text(format!( + "The weather in {} is {} and 18°C", + location, WEATHER_TYPE + ))]) + }); + mock_client +} diff --git a/crates/goose-cli/src/scenario_tests/mod.rs b/crates/goose-cli/src/scenario_tests/mod.rs index f440aba83523..ac26984d02ec 100644 --- a/crates/goose-cli/src/scenario_tests/mod.rs +++ b/crates/goose-cli/src/scenario_tests/mod.rs @@ -1,3 +1,4 @@ +mod mock_client; mod provider_configs; -mod scenario_runners; +mod scenario_runner; mod scenarios; diff --git a/crates/goose-cli/src/scenario_tests/provider_configs.rs b/crates/goose-cli/src/scenario_tests/provider_configs.rs index b812fcb8b771..779e64b4f52a 100644 --- a/crates/goose-cli/src/scenario_tests/provider_configs.rs +++ b/crates/goose-cli/src/scenario_tests/provider_configs.rs @@ -12,7 +12,11 @@ pub struct ProviderConfig { } impl ProviderConfig { - fn simple(name: &'static str, model_name: &'static str) -> Self { + fn simple_skip( + name: &'static str, + model_name: &'static str, + skip_reason: Option<&'static str>, + ) -> Self { let key = format!("{}_API_KEY", name.to_uppercase()); let required_env_vars = Box::leak(vec![Box::leak(key.into_boxed_str()) as &str].into_boxed_slice()); @@ -23,10 +27,14 @@ impl ProviderConfig { model_name, required_env_vars, env_modifications: None, - skip_reason: None, + skip_reason, } } + pub fn simple(name: &'static str, model_name: &'static str) -> Self { + Self::simple_skip(name, model_name, None) + } + pub fn name_for_factory(&self) -> String { self.factory_name .map(|s| s.to_string()) @@ -64,7 +72,11 @@ static PROVIDER_CONFIGS: LazyLock> = LazyLock::new(|| { }, ProviderConfig::simple("Google", "gemini-2.5-flash"), ProviderConfig::simple("Groq", "llama-3.3-70b-versatile"), - ProviderConfig::simple("OpenRouter", "anthropic/claude-3.5-sonnet"), + ProviderConfig::simple_skip( + "OpenRouter", + "anthropic/claude-3.5-sonnet", + Some("Key is no longer valid"), + ), ] }); diff --git a/crates/goose-cli/src/scenario_tests/scenario_runners.rs b/crates/goose-cli/src/scenario_tests/scenario_runner.rs similarity index 93% rename from crates/goose-cli/src/scenario_tests/scenario_runners.rs rename to crates/goose-cli/src/scenario_tests/scenario_runner.rs index e76eb41e2681..3ea74467324b 100644 --- a/crates/goose-cli/src/scenario_tests/scenario_runners.rs +++ b/crates/goose-cli/src/scenario_tests/scenario_runner.rs @@ -1,5 +1,6 @@ use dotenvy::dotenv; +use crate::scenario_tests::mock_client::weather_client; use crate::scenario_tests::provider_configs::{get_provider_configs, ProviderConfig}; use crate::session::Session; use anyhow::Result; @@ -25,6 +26,14 @@ impl ScenarioResult { .map(|content| content.as_text().unwrap_or("").to_string()) .collect() } + + pub fn last_message(&self) -> Result { + let message_contents = self.message_contents(); + message_contents + .last() + .cloned() + .ok_or_else(|| anyhow::anyhow!("No messages found in scenario result")) + } } pub async fn run_scenario(test_name: &str, inputs: &[&str], validator: F) -> Result<()> @@ -146,7 +155,14 @@ where ) }; + let mock_client = weather_client(); + let agent = Agent::new(); + { + let mut extension_manager = agent.extension_manager.write().await; + extension_manager.add_client("weather_extension".to_string(), Box::new(mock_client)); + } + agent .update_provider(provider_arc as Arc) .await?; diff --git a/crates/goose-cli/src/scenario_tests/scenarios.rs b/crates/goose-cli/src/scenario_tests/scenarios.rs index 84644486bfc8..08e96c7b269d 100644 --- a/crates/goose-cli/src/scenario_tests/scenarios.rs +++ b/crates/goose-cli/src/scenario_tests/scenarios.rs @@ -1,18 +1,44 @@ #[cfg(test)] mod tests { - use crate::scenario_tests::scenario_runners::run_scenario; + use crate::scenario_tests::mock_client::WEATHER_TYPE; + use crate::scenario_tests::scenario_runner::run_scenario; use anyhow::Result; #[tokio::test] async fn test_what_is_your_name() -> Result<()> { run_scenario("what_is_your_name", &["what is your name"], |result| { - assert!(result - .message_contents() - .iter() - .any(|msg| msg.to_lowercase().contains("goose"))); assert!(result.error.is_none()); + result.last_message()?.to_lowercase().contains("goose"); Ok(()) }) .await } + + #[tokio::test] + async fn test_weather_tool() -> Result<()> { + run_scenario( + "weather_tool", + &["tell me what the weather is in Berlin, Germany"], + |result| { + assert!(result.error.is_none()); + + let last_message = result.last_message()?; + + assert!( + last_message.contains("Berlin"), + "Last message should contain 'Berlin': {}", + last_message + ); + assert!( + last_message.contains(WEATHER_TYPE), + "Last message should contain '{}': {}", + WEATHER_TYPE, + last_message + ); + + Ok(()) + }, + ) + .await + } } diff --git a/crates/goose/src/agents/agent.rs b/crates/goose/src/agents/agent.rs index 0742ba33fe1d..9f41cd0c8a34 100644 --- a/crates/goose/src/agents/agent.rs +++ b/crates/goose/src/agents/agent.rs @@ -61,7 +61,7 @@ const DEFAULT_MAX_TURNS: u32 = 1000; /// The main goose Agent pub struct Agent { pub(super) provider: Mutex>>, - pub(super) extension_manager: Arc>, + pub extension_manager: Arc>, pub(super) sub_recipe_manager: Mutex, pub(super) tasks_manager: TasksManager, pub(super) final_output_tool: Arc>>, diff --git a/crates/goose/src/agents/extension_manager.rs b/crates/goose/src/agents/extension_manager.rs index 732401a021e8..f1f198fc4c22 100644 --- a/crates/goose/src/agents/extension_manager.rs +++ b/crates/goose/src/agents/extension_manager.rs @@ -292,12 +292,16 @@ impl ExtensionManager { .insert(sanitized_name.clone()); } - self.clients - .insert(sanitized_name.clone(), Arc::new(Mutex::new(client))); - + self.add_client(sanitized_name, client); Ok(()) } + pub fn add_client(&mut self, client_name: String, client: Box) { + let sanitized_name = normalize(client_name); + self.clients + .insert(sanitized_name, Arc::new(Mutex::new(client))); + } + /// Get extensions info pub async fn get_extensions_info(&self) -> Vec { self.clients diff --git a/crates/goose/src/agents/reply_parts.rs b/crates/goose/src/agents/reply_parts.rs index 64bd196d4074..f343ba1f67e1 100644 --- a/crates/goose/src/agents/reply_parts.rs +++ b/crates/goose/src/agents/reply_parts.rs @@ -34,9 +34,7 @@ async fn toolshim_postprocess( impl Agent { /// Prepares tools and system prompt for a provider request - pub(crate) async fn prepare_tools_and_prompt( - &self, - ) -> anyhow::Result<(Vec, Vec, String)> { + pub async fn prepare_tools_and_prompt(&self) -> anyhow::Result<(Vec, Vec, String)> { // Get tool selection strategy from config let config = Config::global(); let router_tool_selection_strategy = config From 15fba92b71b86c1bcbadb1cace388b9d43ba0a28 Mon Sep 17 00:00:00 2001 From: Douwe Osinga Date: Mon, 28 Jul 2025 11:48:15 +0200 Subject: [PATCH 12/18] Use a provider dependent generator --- .../src/scenario_tests/message_generator.rs | 30 ++++++++ crates/goose-cli/src/scenario_tests/mod.rs | 1 + .../src/scenario_tests/provider_configs.rs | 14 +--- .../src/scenario_tests/scenario_runner.rs | 68 ++++++++++++++---- .../goose-cli/src/scenario_tests/scenarios.rs | 48 ++++++++++--- .../scenario_tests/test_data/test_image.jpg | Bin 0 -> 85798 bytes crates/goose-cli/src/session/mod.rs | 21 +++--- crates/goose/src/providers/groq.rs | 15 ++-- crates/goose/src/providers/openrouter.rs | 7 ++ 9 files changed, 154 insertions(+), 50 deletions(-) create mode 100644 crates/goose-cli/src/scenario_tests/message_generator.rs create mode 100644 crates/goose-cli/src/scenario_tests/test_data/test_image.jpg diff --git a/crates/goose-cli/src/scenario_tests/message_generator.rs b/crates/goose-cli/src/scenario_tests/message_generator.rs new file mode 100644 index 000000000000..2024be76cb0a --- /dev/null +++ b/crates/goose-cli/src/scenario_tests/message_generator.rs @@ -0,0 +1,30 @@ +use crate::scenario_tests::scenario_runner::SCENARIO_TESTS_DIR; +use base64::engine::general_purpose; +use base64::Engine; +use goose::message::Message; +use goose::providers::base::Provider; + +pub type MessageGenerator<'a> = Box Message + 'a>; + +pub fn text(text: &str) -> MessageGenerator<'static> { + let text = text.to_string(); + Box::new(move |_provider| Message::user().with_text(&text)) +} + +pub fn image(text: &str, image_name: &str) -> MessageGenerator<'static> { + let text = text.to_string(); + let image_name = image_name.to_string(); + Box::new(move |_provider| { + let manifest_dir = env!("CARGO_MANIFEST_DIR"); + let image_path = format!( + "{}/{}/test_data/{}.jpg", + manifest_dir, SCENARIO_TESTS_DIR, image_name + ); + + let image_data = std::fs::read(image_path).expect("Failed to read image"); + let base64_data = general_purpose::STANDARD.encode(&image_data); + Message::user() + .with_text(&text) + .with_image(base64_data, "image/jpeg") + }) +} diff --git a/crates/goose-cli/src/scenario_tests/mod.rs b/crates/goose-cli/src/scenario_tests/mod.rs index ac26984d02ec..6678a5ff1a27 100644 --- a/crates/goose-cli/src/scenario_tests/mod.rs +++ b/crates/goose-cli/src/scenario_tests/mod.rs @@ -1,3 +1,4 @@ +mod message_generator; mod mock_client; mod provider_configs; mod scenario_runner; diff --git a/crates/goose-cli/src/scenario_tests/provider_configs.rs b/crates/goose-cli/src/scenario_tests/provider_configs.rs index 779e64b4f52a..f8705e411bb1 100644 --- a/crates/goose-cli/src/scenario_tests/provider_configs.rs +++ b/crates/goose-cli/src/scenario_tests/provider_configs.rs @@ -4,7 +4,6 @@ use std::sync::LazyLock; #[derive(Debug, Clone)] pub struct ProviderConfig { pub name: &'static str, - pub factory_name: Option<&'static str>, pub model_name: &'static str, pub required_env_vars: &'static [&'static str], pub env_modifications: Option>>, @@ -23,7 +22,6 @@ impl ProviderConfig { Self { name, - factory_name: None, model_name, required_env_vars, env_modifications: None, @@ -35,12 +33,6 @@ impl ProviderConfig { Self::simple_skip(name, model_name, None) } - pub fn name_for_factory(&self) -> String { - self.factory_name - .map(|s| s.to_string()) - .unwrap_or_else(|| self.name.to_lowercase()) - } - pub fn is_skipped(&self) -> bool { self.skip_reason.is_some() } @@ -51,8 +43,7 @@ static PROVIDER_CONFIGS: LazyLock> = LazyLock::new(|| { ProviderConfig::simple("OpenAI", "gpt-4o"), ProviderConfig::simple("Anthropic", "claude-3-5-sonnet-20241022"), ProviderConfig { - name: "Azure", - factory_name: Some("azure_openai"), + name: "azure_openai", model_name: "gpt-4o", required_env_vars: &[ "AZURE_OPENAI_API_KEY", @@ -63,8 +54,7 @@ static PROVIDER_CONFIGS: LazyLock> = LazyLock::new(|| { skip_reason: None, }, ProviderConfig { - name: "Bedrock", - factory_name: Some("aws_bedrock"), + name: "aws_bedrock", model_name: "anthropic.claude-3-5-sonnet-20241022-v2:0", required_env_vars: &["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"], env_modifications: None, diff --git a/crates/goose-cli/src/scenario_tests/scenario_runner.rs b/crates/goose-cli/src/scenario_tests/scenario_runner.rs index 3ea74467324b..b17eb9ff1def 100644 --- a/crates/goose-cli/src/scenario_tests/scenario_runner.rs +++ b/crates/goose-cli/src/scenario_tests/scenario_runner.rs @@ -1,5 +1,6 @@ use dotenvy::dotenv; +use crate::scenario_tests::message_generator::MessageGenerator; use crate::scenario_tests::mock_client::weather_client; use crate::scenario_tests::provider_configs::{get_provider_configs, ProviderConfig}; use crate::session::Session; @@ -8,10 +9,12 @@ use goose::agents::Agent; use goose::message::Message; use goose::model::ModelConfig; use goose::providers::{create, testprovider::TestProvider}; -use std::collections::HashMap; +use std::collections::{HashMap, HashSet}; use std::path::Path; use std::sync::Arc; +pub const SCENARIO_TESTS_DIR: &str = "src/scenario_tests"; + #[derive(Debug, Clone)] pub struct ScenarioResult { pub messages: Vec, @@ -36,12 +39,15 @@ impl ScenarioResult { } } -pub async fn run_scenario(test_name: &str, inputs: &[&str], validator: F) -> Result<()> +pub async fn run_scenario( + test_name: &str, + message_generator: MessageGenerator<'_>, + providers_to_skip: Option<&[&str]>, + validator: F, +) -> Result<()> where F: Fn(&ScenarioResult) -> Result<()> + Send + Sync + 'static, { - let inputs_owned: Vec = inputs.iter().map(|s| s.to_string()).collect(); - if let Ok(only_provider) = std::env::var("GOOSE_TEST_PROVIDER") { let active_providers = get_provider_configs(); let config = active_providers @@ -60,15 +66,39 @@ where })?; println!("Running test '{}' for provider: {}", test_name, config.name); - run_provider_scenario_with_validation(config, test_name, &inputs_owned, &validator).await?; + run_provider_scenario_with_validation(config, test_name, &message_generator, &validator) + .await?; return Ok(()); } + let configs_to_test: Vec<_> = if let Some(to_skip) = providers_to_skip { + let excluded_providers: HashSet = + to_skip.iter().map(|name| name.to_lowercase()).collect(); + + let filtered: Vec<_> = get_provider_configs() + .into_iter() + .filter(|c| !excluded_providers.contains(&c.name.to_lowercase())) + .collect(); + + if filtered.len() != get_provider_configs().len() - to_skip.len() { + return Err(anyhow::anyhow!("Some providers in skip list don't exist")); + } + + filtered + } else { + get_provider_configs() + }; + let mut failures = Vec::new(); - for config in get_provider_configs() { - match run_provider_scenario_with_validation(config, test_name, &inputs_owned, &validator) - .await + for config in configs_to_test { + match run_provider_scenario_with_validation( + config, + test_name, + &message_generator, + &validator, + ) + .await { Ok(_) => println!("✅ {} - {}", test_name, config.name), Err(e) => { @@ -96,7 +126,7 @@ where async fn run_provider_scenario_with_validation( config: &ProviderConfig, test_name: &str, - inputs: &[String], + message_generator: &MessageGenerator<'_>, validator: &F, ) -> Result<()> where @@ -106,11 +136,12 @@ where println!("Loaded environment from {:?}", path); } - let factory_name = config.name_for_factory(); + let factory_name = config.name.to_lowercase(); let manifest_dir = env!("CARGO_MANIFEST_DIR"); let file_path = format!( - "{}/src/scenario_tests/recordings/{}/{}.json", + "{}/{}/recordings/{}/{}.json", manifest_dir, + SCENARIO_TESTS_DIR, factory_name.to_lowercase(), test_name ); @@ -155,6 +186,9 @@ where ) }; + // Generate messages using the provider + let messages = vec![message_generator(&*provider_arc)]; + let mock_client = weather_client(); let agent = Agent::new(); @@ -170,14 +204,15 @@ where let mut session = Session::new(agent, None, false, None, None, None, None); let mut error = None; - for input in inputs { - if let Err(e) = session.headless(input.to_string()).await { + for message in &messages { + if let Err(e) = session.process_message(message.clone()).await { error = Some(e.to_string()); break; } } - let messages = session.message_history().to_vec(); + // Rest of the function remains the same... + let updated_messages = session.message_history().to_vec(); if let Some(ref err_msg) = error { if err_msg.contains("No recorded response found") { @@ -189,7 +224,10 @@ where } } - let result = ScenarioResult { messages, error }; + let result = ScenarioResult { + messages: updated_messages, + error, + }; validator(&result)?; diff --git a/crates/goose-cli/src/scenario_tests/scenarios.rs b/crates/goose-cli/src/scenario_tests/scenarios.rs index 08e96c7b269d..4f58fc562f7e 100644 --- a/crates/goose-cli/src/scenario_tests/scenarios.rs +++ b/crates/goose-cli/src/scenario_tests/scenarios.rs @@ -1,31 +1,45 @@ #[cfg(test)] mod tests { + use crate::scenario_tests::message_generator::{image, text}; + /// This module contains tests for the scenario runner and various scenarios. + /// You can set the GOOSE_TEST_PROVIDER to just run a specific provider. use crate::scenario_tests::mock_client::WEATHER_TYPE; use crate::scenario_tests::scenario_runner::run_scenario; use anyhow::Result; #[tokio::test] async fn test_what_is_your_name() -> Result<()> { - run_scenario("what_is_your_name", &["what is your name"], |result| { - assert!(result.error.is_none()); - result.last_message()?.to_lowercase().contains("goose"); - Ok(()) - }) + run_scenario( + "what_is_your_name", + text("what is your name"), + None, + |result| { + assert!(result.error.is_none()); + assert!( + result.last_message()?.to_lowercase().contains("goose"), + "Response should contain 'goose': {}", + result.last_message()? + ); + Ok(()) + }, + ) .await } #[tokio::test] async fn test_weather_tool() -> Result<()> { + // Google tells me it only knows about the weather in the US, so we skip it. run_scenario( "weather_tool", - &["tell me what the weather is in Berlin, Germany"], + text("tell me what the weather is in Berlin, Germany"), + Some(&["Google"]), |result| { assert!(result.error.is_none()); - let last_message = result.last_message()?; + let last_message = result.last_message()?.to_lowercase(); assert!( - last_message.contains("Berlin"), + last_message.contains("berlin"), "Last message should contain 'Berlin': {}", last_message ); @@ -41,4 +55,22 @@ mod tests { ) .await } + + #[tokio::test] + async fn test_image_analysis() -> Result<()> { + // Google says it doesn't know about images, the other providers complain about + // the image format, so we only run this for OpenAI and Anthropic. + run_scenario( + "image_analysis", + image("What do you see in this image?", "test_image"), + Some(&["Google", "azure_openai", "groq"]), + |result| { + assert!(result.error.is_none()); + let last_message = result.last_message()?; + assert!(!last_message.is_empty()); + Ok(()) + }, + ) + .await + } } diff --git a/crates/goose-cli/src/scenario_tests/test_data/test_image.jpg b/crates/goose-cli/src/scenario_tests/test_data/test_image.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5e929886bc7ee4934a22d4d55843510de6489dfd GIT binary patch literal 85798 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 Result<()> { - self.push_message(Message::user().with_text(&message)); + pub(crate) async fn process_message(&mut self, message: Message) -> Result<()> { + let message_text = message.as_concat_text(); + + self.push_message(message); // Get the provider from the agent for description generation let provider = self.agent.provider().await?; @@ -392,9 +394,10 @@ impl Session { .and_then(|s| s.to_str()) .map(|s| s.to_string()); - if let Err(e) = - crate::project_tracker::update_project_tracker(Some(&message), session_id.as_deref()) - { + if let Err(e) = crate::project_tracker::update_project_tracker( + Some(&message_text), + session_id.as_deref(), + ) { eprintln!( "Warning: Failed to update project tracker with instruction: {}", e @@ -406,9 +409,10 @@ impl Session { } /// Start an interactive session, optionally with an initial message - pub async fn interactive(&mut self, message: Option) -> Result<()> { + pub async fn interactive(&mut self, prompt: Option) -> Result<()> { // Process initial message if provided - if let Some(msg) = message { + if let Some(prompt) = prompt { + let msg = Message::user().with_text(&prompt); self.process_message(msg).await?; } @@ -835,7 +839,8 @@ impl Session { } /// Process a single message and exit - pub async fn headless(&mut self, message: String) -> Result<()> { + pub async fn headless(&mut self, prompt: String) -> Result<()> { + let message = Message::user().with_text(&prompt); self.process_message(message).await } diff --git a/crates/goose/src/providers/groq.rs b/crates/goose/src/providers/groq.rs index 8b95988d110e..a6abc0fc31eb 100644 --- a/crates/goose/src/providers/groq.rs +++ b/crates/goose/src/providers/groq.rs @@ -70,25 +70,26 @@ impl GroqProvider { .await?; let status = response.status(); - let payload: Option = response.json().await.ok(); + let response_payload: Option = response.json().await.ok(); + let formatted_payload = format!("{:?}", response_payload); match status { - StatusCode::OK => payload.ok_or_else( || ProviderError::RequestFailed("Response body is not valid JSON".to_string()) ), + StatusCode::OK => response_payload.ok_or_else( || ProviderError::RequestFailed("Response body is not valid JSON".to_string()) ), StatusCode::UNAUTHORIZED | StatusCode::FORBIDDEN => { Err(ProviderError::Authentication(format!("Authentication failed. Please ensure your API keys are valid and have the required permissions. \ - Status: {}. Response: {:?}", status, payload))) + Status: {}. Response: {:?}", status, response_payload))) } StatusCode::PAYLOAD_TOO_LARGE => { - Err(ProviderError::ContextLengthExceeded(format!("{:?}", payload))) + Err(ProviderError::ContextLengthExceeded(formatted_payload)) } StatusCode::TOO_MANY_REQUESTS => { - Err(ProviderError::RateLimitExceeded(format!("{:?}", payload))) + Err(ProviderError::RateLimitExceeded(formatted_payload)) } StatusCode::INTERNAL_SERVER_ERROR | StatusCode::SERVICE_UNAVAILABLE => { - Err(ProviderError::ServerError(format!("{:?}", payload))) + Err(ProviderError::ServerError(formatted_payload)) } _ => { - let error_msg = format!("Provider request failed with status: {}. Payload: {:?}", status, payload); + let error_msg = format!("Provider request failed with status: {}. Payload: {:?}", status, response_payload); tracing::debug!(error_msg); Err(ProviderError::RequestFailed(error_msg)) } diff --git a/crates/goose/src/providers/openrouter.rs b/crates/goose/src/providers/openrouter.rs index 21fd1e5e3b3d..7830e93a13ce 100644 --- a/crates/goose/src/providers/openrouter.rs +++ b/crates/goose/src/providers/openrouter.rs @@ -93,6 +93,13 @@ impl OpenRouterProvider { .await .map_err(|e| ProviderError::RequestFailed(format!("Failed to parse response: {e}")))?; + let _debug = format!( + "OpenRouter request with payload: {} and response: {}", + serde_json::to_string_pretty(payload).unwrap_or_else(|_| "Invalid JSON".to_string()), + serde_json::to_string_pretty(&response_body) + .unwrap_or_else(|_| "Invalid JSON".to_string()) + ); + // OpenRouter can return errors in 200 OK responses, so we have to check for errors explicitly // https://openrouter.ai/docs/api-reference/errors if let Some(error_obj) = response_body.get("error") { From f2b894c7577a078dd4233b89d1a5989ce32951f7 Mon Sep 17 00:00:00 2001 From: Douwe Osinga Date: Mon, 28 Jul 2025 13:34:03 +0200 Subject: [PATCH 13/18] Some more --- .../goose-cli/src/scenario_tests/scenarios.rs | 33 +- crates/goose/tests/providers.rs | 849 +++++++++--------- 2 files changed, 451 insertions(+), 431 deletions(-) diff --git a/crates/goose-cli/src/scenario_tests/scenarios.rs b/crates/goose-cli/src/scenario_tests/scenarios.rs index 4f58fc562f7e..3be5668313c9 100644 --- a/crates/goose-cli/src/scenario_tests/scenarios.rs +++ b/crates/goose-cli/src/scenario_tests/scenarios.rs @@ -1,11 +1,13 @@ +//! This module contains tests for the scenario runner and various scenarios. +//! You can set the GOOSE_TEST_PROVIDER to just run a specific provider. + #[cfg(test)] mod tests { use crate::scenario_tests::message_generator::{image, text}; - /// This module contains tests for the scenario runner and various scenarios. - /// You can set the GOOSE_TEST_PROVIDER to just run a specific provider. use crate::scenario_tests::mock_client::WEATHER_TYPE; use crate::scenario_tests::scenario_runner::run_scenario; use anyhow::Result; + use goose::message::Message; #[tokio::test] async fn test_what_is_your_name() -> Result<()> { @@ -73,4 +75,31 @@ mod tests { ) .await } + + #[tokio::test] + async fn test_context_length_exceeded_error() -> Result<()> { + run_scenario( + "context_length_exceeded", + Box::new(|provider| { + let model_config = provider.get_model_config(); + let context_length = model_config.context_limit.unwrap_or(300_000); + // "hello " is only one token in most models, since the hello and space often + // occur together in the training data. + let large_message = "hello ".repeat(context_length + 100); + Message::user().with_text(&large_message) + }), + Some(&["OpenAI"]), + |result| { + // this is unfortunate; we don't seem to actually catch the errors in this path, + // but instead eat it: + assert_eq!( + result.messages.len(), + 0, + "Expected no messages due to compaction" + ); + Ok(()) + }, + ) + .await + } } diff --git a/crates/goose/tests/providers.rs b/crates/goose/tests/providers.rs index 5c8af870489e..f0ac979edcc2 100644 --- a/crates/goose/tests/providers.rs +++ b/crates/goose/tests/providers.rs @@ -1,13 +1,16 @@ use anyhow::Result; use dotenvy::dotenv; use goose::message::{Message, MessageContent}; -use goose::model::ModelConfig; use goose::providers::base::Provider; use goose::providers::errors::ProviderError; -use mcp_core::tool::Tool; +use goose::providers::{ + anthropic, azure, bedrock, databricks, google, groq, litellm, ollama, openai, openrouter, + snowflake, xai, +}; +use rmcp::model::Tool; use rmcp::model::{AnnotateAble, Content, RawImageContent}; +use rmcp::object; use std::collections::HashMap; -use std::future::Future; use std::sync::Arc; use std::sync::Mutex; @@ -28,150 +31,6 @@ impl std::fmt::Display for TestStatus { } } -#[derive(Debug, Clone)] -struct ProviderConfig { - name: &'static str, - factory_name: &'static str, - required_env_vars: &'static [&'static str], - env_modifications: Option>>, -} - -// Configuration for all providers -static PROVIDER_CONFIGS: &[ProviderConfig] = &[ - ProviderConfig { - name: "OpenAI", - factory_name: "openai", - required_env_vars: &["OPENAI_API_KEY"], - env_modifications: None, - }, - ProviderConfig { - name: "Anthropic", - factory_name: "anthropic", - required_env_vars: &["ANTHROPIC_API_KEY"], - env_modifications: None, - }, - ProviderConfig { - name: "Azure", - factory_name: "azure_openai", - required_env_vars: &[ - "AZURE_OPENAI_API_KEY", - "AZURE_OPENAI_ENDPOINT", - "AZURE_OPENAI_DEPLOYMENT_NAME", - ], - env_modifications: None, - }, - ProviderConfig { - name: "Bedrock", - factory_name: "aws_bedrock", - required_env_vars: &["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"], - env_modifications: None, - }, - ProviderConfig { - name: "Bedrock AWS Profile", - factory_name: "aws_bedrock", - required_env_vars: &["AWS_PROFILE"], - env_modifications: Some({ - let mut map = HashMap::new(); - map.insert("AWS_ACCESS_KEY_ID", None); - map.insert("AWS_SECRET_ACCESS_KEY", None); - map - }), - }, - ProviderConfig { - name: "Databricks", - factory_name: "databricks", - required_env_vars: &["DATABRICKS_HOST", "DATABRICKS_TOKEN"], - env_modifications: None, - }, - ProviderConfig { - name: "Databricks OAuth", - factory_name: "databricks", - required_env_vars: &["DATABRICKS_HOST"], - env_modifications: Some({ - let mut map = HashMap::new(); - map.insert("DATABRICKS_TOKEN", None); - map - }), - }, - ProviderConfig { - name: "Google", - factory_name: "google", - required_env_vars: &["GOOGLE_API_KEY"], - env_modifications: None, - }, - ProviderConfig { - name: "GCP Vertex AI", - factory_name: "gcp_vertex_ai", - required_env_vars: &["GOOGLE_APPLICATION_CREDENTIALS"], - env_modifications: None, - }, - ProviderConfig { - name: "Groq", - factory_name: "groq", - required_env_vars: &["GROQ_API_KEY"], - env_modifications: None, - }, - ProviderConfig { - name: "LiteLLM", - factory_name: "litellm", - required_env_vars: &[], - env_modifications: Some({ - let mut map = HashMap::new(); - map.insert("LITELLM_HOST", Some("http://localhost:4000".to_string())); - map.insert("LITELLM_API_KEY", Some("".to_string())); - map - }), - }, - ProviderConfig { - name: "Ollama", - factory_name: "ollama", - required_env_vars: &["OLLAMA_HOST"], - env_modifications: None, - }, - ProviderConfig { - name: "OpenRouter", - factory_name: "openrouter", - required_env_vars: &["OPENROUTER_API_KEY"], - env_modifications: None, - }, - ProviderConfig { - name: "SageMaker TGI", - factory_name: "sagemaker_tgi", - required_env_vars: &["SAGEMAKER_ENDPOINT_NAME"], - env_modifications: None, - }, - ProviderConfig { - name: "Snowflake", - factory_name: "snowflake", - required_env_vars: &["SNOWFLAKE_HOST", "SNOWFLAKE_TOKEN"], - env_modifications: None, - }, - ProviderConfig { - name: "Venice", - factory_name: "venice", - required_env_vars: &["VENICE_API_KEY"], - env_modifications: None, - }, - ProviderConfig { - name: "XAI", - factory_name: "xai", - required_env_vars: &["XAI_API_KEY"], - env_modifications: None, - }, - ProviderConfig { - name: "Claude Code", - factory_name: "claude-code", - required_env_vars: &["ANTHROPIC_API_KEY"], - env_modifications: None, - }, - ProviderConfig { - name: "Gemini CLI", - factory_name: "gemini-cli", - required_env_vars: &["GOOGLE_API_KEY"], - env_modifications: None, - }, -]; - struct TestReport { results: Mutex>, } @@ -218,141 +77,25 @@ lazy_static::lazy_static! { static ref ENV_LOCK: Mutex<()> = Mutex::new(()); } -fn load_env() { - if let Ok(path) = dotenv() { - println!("Loaded environment from {:?}", path); - } -} - -/// Helper function that runs a test function against all available providers -async fn run_all_providers(test_name: &str, test_fn: F) -> Result<()> -where - F: Fn(Arc, &str) -> Fut, - Fut: Future>, -{ - let mut results = Vec::new(); - - for config in PROVIDER_CONFIGS { - let result = run_provider_test(config, &test_fn).await; - results.push((config.name, result)); - } - - // Report results to the global test report - for (name, result) in &results { - match result { - Ok(_) => TEST_REPORT.record_pass(&format!("{} - {}", test_name, name)), - Err(_) => TEST_REPORT.record_fail(&format!("{} - {}", test_name, name)), - } - } - - // Report any failures - let failures: Vec<_> = results - .iter() - .filter(|(_, result)| result.is_err()) - .collect(); - - if !failures.is_empty() { - println!("Failed providers for {}:", test_name); - for (name, error) in failures { - println!(" {}: {:?}", name, error); - } - } - - Ok(()) +/// Generic test harness for any Provider implementation +struct ProviderTester { + provider: Arc, + name: String, } -async fn run_provider_test(config: &ProviderConfig, test_fn: &F) -> Result<()> -where - F: Fn(Arc, &str) -> Fut, - Fut: Future>, -{ - // Take exclusive access to environment modifications - let lock = ENV_LOCK.lock().unwrap(); - - load_env(); - - // Save current environment state - let mut original_env = HashMap::new(); - for &var in config.required_env_vars { - if let Ok(val) = std::env::var(var) { - original_env.insert(var, val); - } - } - if let Some(mods) = &config.env_modifications { - for &var in mods.keys() { - if let Ok(val) = std::env::var(var) { - original_env.insert(var, val); - } - } - } - - // Apply environment modifications - if let Some(mods) = &config.env_modifications { - for (&var, value) in mods.iter() { - match value { - Some(val) => std::env::set_var(var, val), - None => std::env::remove_var(var), - } - } - } - - // Check if required environment variables are available - let missing_vars = config - .required_env_vars - .iter() - .any(|var| std::env::var(var).is_err()); - if missing_vars { - println!( - "Skipping {} tests - credentials not configured", - config.name - ); - TEST_REPORT.record_skip(&format!("skipped - {}", config.name)); - return Ok(()); // Skip, don't fail - } - - // Special case for LiteLLM - skip if host not set - if config.factory_name == "litellm" && std::env::var("LITELLM_HOST").is_err() { - println!("LITELLM_HOST not set, skipping test"); - TEST_REPORT.record_skip(&format!("skipped - {}", config.name)); - return Ok(()); - } - - // Create provider using factory - let model_config = ModelConfig::default(); - let provider = match goose::providers::create(config.factory_name, model_config) { - Ok(p) => p, - Err(e) => { - println!("Failed to create provider {}: {}", config.name, e); - return Err(e); - } - }; - - // Restore original environment - for (&var, value) in original_env.iter() { - std::env::set_var(var, value); - } - if let Some(mods) = &config.env_modifications { - for &var in mods.keys() { - if !original_env.contains_key(var) { - std::env::remove_var(var); - } +impl ProviderTester { + fn new(provider: T, name: String) -> Self { + Self { + provider: Arc::new(provider), + name, } } - std::mem::drop(lock); - - // Run the actual test - test_fn(provider, config.name).await -} - -// Individual test functions - -#[tokio::test] -async fn test_basic_response() -> Result<()> { - run_all_providers("basic_response", |provider, provider_name| async move { + async fn test_basic_response(&self) -> Result<()> { let message = Message::user().with_text("Just say hello!"); - let (response, _) = provider + let (response, _) = self + .provider .complete("You are a helpful assistant.", &[message], &[]) .await?; @@ -360,29 +103,23 @@ async fn test_basic_response() -> Result<()> { assert_eq!( response.content.len(), 1, - "Expected single content item in response for {}", - provider_name + "Expected single content item in response" ); // Verify we got a text response assert!( matches!(response.content[0], MessageContent::Text(_)), - "Expected text response for {}", - provider_name + "Expected text response" ); Ok(()) - }) - .await -} + } -#[tokio::test] -async fn test_tool_usage() -> Result<()> { - run_all_providers("tool_usage", |provider, provider_name| async move { + async fn test_tool_usage(&self) -> Result<()> { let weather_tool = Tool::new( "get_weather", "Get the weather for a location", - serde_json::json!({ + object!({ "type": "object", "required": ["location"], "properties": { @@ -392,12 +129,12 @@ async fn test_tool_usage() -> Result<()> { } } }), - None, ); let message = Message::user().with_text("What's the weather like in San Francisco?"); - let (response1, _) = provider + let (response1, _) = self + .provider .complete( "You are a helpful weather assistant.", &[message.clone()], @@ -405,7 +142,7 @@ async fn test_tool_usage() -> Result<()> { ) .await?; - println!("=== {}::response1 ===", provider_name); + println!("=== {}::reponse1 ===", self.name); dbg!(&response1); println!("==================="); @@ -415,8 +152,7 @@ async fn test_tool_usage() -> Result<()> { .content .iter() .any(|content| matches!(content, MessageContent::ToolRequest(_))), - "Expected tool request in response for {}", - provider_name + "Expected tool request in response" ); let id = &response1 @@ -442,7 +178,8 @@ async fn test_tool_usage() -> Result<()> { ); // Verify we construct a valid payload including the request/response pair for the next inference - let (response2, _) = provider + let (response2, _) = self + .provider .complete( "You are a helpful weather assistant.", &[message, response1, weather], @@ -450,7 +187,7 @@ async fn test_tool_usage() -> Result<()> { ) .await?; - println!("=== {}::response2 ===", provider_name); + println!("=== {}::reponse2 ===", self.name); dbg!(&response2); println!("==================="); @@ -459,30 +196,21 @@ async fn test_tool_usage() -> Result<()> { .content .iter() .any(|content| matches!(content, MessageContent::Text(_))), - "Expected text for final response for {}", - provider_name + "Expected text for final response" ); Ok(()) - }) - .await -} + } -#[tokio::test] -async fn test_context_length_exceeded_error() -> Result<()> { - run_all_providers( - "context_length_exceeded", - |provider, provider_name| async move { - // Google Gemini has a really long context window - let large_message_content = if provider_name.to_lowercase().contains("google") - || provider_name.to_lowercase().contains("gemini") - { - "hello ".repeat(1_300_000) - } else { - "hello ".repeat(300_000) - }; - - let messages = vec![ + async fn test_context_length_exceeded_error(&self) -> Result<()> { + // Google Gemini has a really long context window + let large_message_content = if self.name.to_lowercase() == "google" { + "hello ".repeat(1_300_000) + } else { + "hello ".repeat(300_000) + }; + + let messages = vec![ Message::user().with_text("hi there. what is 2 + 2?"), Message::assistant().with_text("hey! I think it's 4."), Message::user().with_text(&large_message_content), @@ -495,143 +223,406 @@ async fn test_context_length_exceeded_error() -> Result<()> { ), ]; - // Test that we get ProviderError::ContextLengthExceeded when the context window is exceeded - let result = provider - .complete("You are a helpful assistant.", &messages, &[]) - .await; - - // Print some debug info - println!("=== {}::context_length_exceeded_error ===", provider_name); - dbg!(&result); - println!("==================="); - - // Ollama truncates by default even when the context window is exceeded - if provider_name.to_lowercase().contains("ollama") { - assert!( - result.is_ok(), - "Expected to succeed because of default truncation for {}", - provider_name + // Test that we get ProviderError::ContextLengthExceeded when the context window is exceeded + let result = self + .provider + .complete("You are a helpful assistant.", &messages, &[]) + .await; + + // Print some debug info + println!("=== {}::context_length_exceeded_error ===", self.name); + dbg!(&result); + println!("==================="); + + // Ollama truncates by default even when the context window is exceeded + if self.name.to_lowercase() == "ollama" { + assert!( + result.is_ok(), + "Expected to succeed because of default truncation" + ); + return Ok(()); + } + + assert!( + result.is_err(), + "Expected error when context window is exceeded" + ); + assert!( + matches!(result.unwrap_err(), ProviderError::ContextLengthExceeded(_)), + "Expected error to be ContextLengthExceeded" + ); + + Ok(()) + } + + async fn test_image_content_support(&self) -> Result<()> { + use base64::{engine::general_purpose::STANDARD as BASE64, Engine as _}; + use std::fs; + + // Try to read the test image + let image_path = "crates/goose/examples/test_assets/test_image.png"; + let image_data = match fs::read(image_path) { + Ok(data) => data, + Err(_) => { + println!( + "Test image not found at {}, skipping image test", + image_path ); return Ok(()); } + }; - assert!( - result.is_err(), - "Expected error when context window is exceeded for {}", - provider_name - ); - assert!( - matches!(result.unwrap_err(), ProviderError::ContextLengthExceeded(_)), - "Expected error to be ContextLengthExceeded for {}", - provider_name - ); + let base64_image = BASE64.encode(image_data); + let image_content = RawImageContent { + data: base64_image, + mime_type: "image/png".to_string(), + } + .no_annotation(); + + // Test 1: Direct image message + let message_with_image = + Message::user().with_image(image_content.data.clone(), image_content.mime_type.clone()); + + let result = self + .provider + .complete( + "You are a helpful assistant. Describe what you see in the image briefly.", + &[message_with_image], + &[], + ) + .await; + + println!("=== {}::image_content_support ===", self.name); + let (response, _) = result?; + println!("Image response: {:?}", response); + // Verify we got a text response + assert!( + response + .content + .iter() + .any(|content| matches!(content, MessageContent::Text(_))), + "Expected text response for image" + ); + println!("==================="); + + // Test 2: Tool response with image (this should be handled gracefully) + let screenshot_tool = Tool::new( + "get_screenshot", + "Get a screenshot of the current screen", + object!({ + "type": "object", + "properties": {} + }), + ); + let user_message = Message::user().with_text("Take a screenshot please"); + let tool_request = Message::assistant().with_tool_request( + "test_id", + Ok(mcp_core::tool::ToolCall::new( + "get_screenshot", + serde_json::json!({}), + )), + ); + let tool_response = Message::user().with_tool_response( + "test_id", + Ok(vec![Content::image( + image_content.data.clone(), + image_content.mime_type.clone(), + )]), + ); + + let result2 = self + .provider + .complete( + "You are a helpful assistant.", + &[user_message, tool_request, tool_response], + &[screenshot_tool], + ) + .await; + + println!("=== {}::tool_image_response ===", self.name); + let (response, _) = result2?; + println!("Tool image response: {:?}", response); + println!("==================="); + + Ok(()) + } + + /// Run all provider tests + async fn run_test_suite(&self) -> Result<()> { + self.test_basic_response().await?; + self.test_tool_usage().await?; + self.test_context_length_exceeded_error().await?; + self.test_image_content_support().await?; + Ok(()) + } +} + +fn load_env() { + if let Ok(path) = dotenv() { + println!("Loaded environment from {:?}", path); + } +} + +/// Helper function to run a provider test with proper error handling and reporting +async fn test_provider( + name: &str, + required_vars: &[&str], + env_modifications: Option>>, + provider_fn: F, +) -> Result<()> +where + F: FnOnce() -> T, + T: Provider + Send + Sync + 'static, +{ + // We start off as failed, so that if the process panics it is seen as a failure + TEST_REPORT.record_fail(name); + + // Take exclusive access to environment modifications + let lock = ENV_LOCK.lock().unwrap(); + + load_env(); + + // Save current environment state for required vars and modified vars + let mut original_env = HashMap::new(); + for &var in required_vars { + if let Ok(val) = std::env::var(var) { + original_env.insert(var, val); + } + } + if let Some(mods) = &env_modifications { + for &var in mods.keys() { + if let Ok(val) = std::env::var(var) { + original_env.insert(var, val); + } + } + } + + // Apply any environment modifications + if let Some(mods) = &env_modifications { + for (&var, value) in mods.iter() { + match value { + Some(val) => std::env::set_var(var, val), + None => std::env::remove_var(var), + } + } + } + + // Setup the provider + let missing_vars = required_vars.iter().any(|var| std::env::var(var).is_err()); + if missing_vars { + println!("Skipping {} tests - credentials not configured", name); + TEST_REPORT.record_skip(name); + return Ok(()); + } + + let provider = provider_fn(); + + // Restore original environment + for (&var, value) in original_env.iter() { + std::env::set_var(var, value); + } + if let Some(mods) = env_modifications { + for &var in mods.keys() { + if !original_env.contains_key(var) { + std::env::remove_var(var); + } + } + } + + std::mem::drop(lock); + + let tester = ProviderTester::new(provider, name.to_string()); + match tester.run_test_suite().await { + Ok(_) => { + TEST_REPORT.record_pass(name); Ok(()) - }, + } + Err(e) => { + println!("{} test failed: {}", name, e); + TEST_REPORT.record_fail(name); + Err(e) + } + } +} + +#[tokio::test] +async fn test_openai_provider() -> Result<()> { + test_provider( + "OpenAI", + &["OPENAI_API_KEY"], + None, + openai::OpenAiProvider::default, ) .await } #[tokio::test] -async fn test_image_content_support() -> Result<()> { - run_all_providers( - "image_content_support", - |provider, provider_name| async move { - use base64::{engine::general_purpose::STANDARD as BASE64, Engine as _}; - use std::fs; - - // Try to read the test image - let image_path = "crates/goose/examples/test_assets/test_image.png"; - let image_data = match fs::read(image_path) { - Ok(data) => data, - Err(_) => { - println!( - "Test image not found at {}, skipping image test for {}", - image_path, provider_name - ); - return Ok(()); - } - }; +async fn test_azure_provider() -> Result<()> { + test_provider( + "Azure", + &[ + "AZURE_OPENAI_API_KEY", + "AZURE_OPENAI_ENDPOINT", + "AZURE_OPENAI_DEPLOYMENT_NAME", + ], + None, + azure::AzureProvider::default, + ) + .await +} - let base64_image = BASE64.encode(image_data); - let image_content = RawImageContent { - data: base64_image, - mime_type: "image/png".to_string(), - } - .no_annotation(); - - // Test 1: Direct image message - let message_with_image = Message::user() - .with_image(image_content.data.clone(), image_content.mime_type.clone()); - - let result = provider - .complete( - "You are a helpful assistant. Describe what you see in the image briefly.", - &[message_with_image], - &[], - ) - .await; - - println!("=== {}::image_content_support ===", provider_name); - let (response, _) = result?; - println!("Image response: {:?}", response); - // Verify we got a text response - assert!( - response - .content - .iter() - .any(|content| matches!(content, MessageContent::Text(_))), - "Expected text response for image for {}", - provider_name - ); - println!("==================="); +#[tokio::test] +async fn test_bedrock_provider_long_term_credentials() -> Result<()> { + test_provider( + "Bedrock", + &["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"], + None, + bedrock::BedrockProvider::default, + ) + .await +} - // Test 2: Tool response with image (this should be handled gracefully) - let screenshot_tool = Tool::new( - "get_screenshot", - "Get a screenshot of the current screen", - serde_json::json!({ - "type": "object", - "properties": {} - }), - None, - ); +#[tokio::test] +async fn test_bedrock_provider_aws_profile_credentials() -> Result<()> { + let env_mods = HashMap::from_iter([ + // Ensure to unset long-term credentials to use AWS Profile provider + ("AWS_ACCESS_KEY_ID", None), + ("AWS_SECRET_ACCESS_KEY", None), + ]); + + test_provider( + "Bedrock AWS Profile Credentials", + &["AWS_PROFILE"], + Some(env_mods), + bedrock::BedrockProvider::default, + ) + .await +} - let user_message = Message::user().with_text("Take a screenshot please"); - let tool_request = Message::assistant().with_tool_request( - "test_id", - Ok(mcp_core::tool::ToolCall::new( - "get_screenshot", - serde_json::json!({}), - )), - ); - let tool_response = Message::user().with_tool_response( - "test_id", - Ok(vec![Content::image( - image_content.data.clone(), - image_content.mime_type.clone(), - )]), - ); +#[tokio::test] +async fn test_databricks_provider() -> Result<()> { + test_provider( + "Databricks", + &["DATABRICKS_HOST", "DATABRICKS_TOKEN"], + None, + databricks::DatabricksProvider::default, + ) + .await +} - let result2 = provider - .complete( - "You are a helpful assistant.", - &[user_message, tool_request, tool_response], - &[screenshot_tool], - ) - .await; +#[tokio::test] +async fn test_databricks_provider_oauth() -> Result<()> { + let mut env_mods = HashMap::new(); + env_mods.insert("DATABRICKS_TOKEN", None); + + test_provider( + "Databricks OAuth", + &["DATABRICKS_HOST"], + Some(env_mods), + databricks::DatabricksProvider::default, + ) + .await +} - println!("=== {}::tool_image_response ===", provider_name); - let (response, _) = result2?; - println!("Tool image response: {:?}", response); - println!("==================="); +#[tokio::test] +async fn test_ollama_provider() -> Result<()> { + test_provider( + "Ollama", + &["OLLAMA_HOST"], + None, + ollama::OllamaProvider::default, + ) + .await +} - Ok(()) - }, +#[tokio::test] +async fn test_groq_provider() -> Result<()> { + test_provider("Groq", &["GROQ_API_KEY"], None, groq::GroqProvider::default).await +} + +#[tokio::test] +async fn test_anthropic_provider() -> Result<()> { + test_provider( + "Anthropic", + &["ANTHROPIC_API_KEY"], + None, + anthropic::AnthropicProvider::default, ) .await } +#[tokio::test] +async fn test_openrouter_provider() -> Result<()> { + test_provider( + "OpenRouter", + &["OPENROUTER_API_KEY"], + None, + openrouter::OpenRouterProvider::default, + ) + .await +} + +#[tokio::test] +async fn test_google_provider() -> Result<()> { + test_provider( + "Google", + &["GOOGLE_API_KEY"], + None, + google::GoogleProvider::default, + ) + .await +} + +#[tokio::test] +async fn test_snowflake_provider() -> Result<()> { + test_provider( + "Snowflake", + &["SNOWFLAKE_HOST", "SNOWFLAKE_TOKEN"], + None, + snowflake::SnowflakeProvider::default, + ) + .await +} + +#[tokio::test] +async fn test_sagemaker_tgi_provider() -> Result<()> { + test_provider( + "SageMakerTgi", + &["SAGEMAKER_ENDPOINT_NAME"], + None, + goose::providers::sagemaker_tgi::SageMakerTgiProvider::default, + ) + .await +} + +#[tokio::test] +async fn test_litellm_provider() -> Result<()> { + if std::env::var("LITELLM_HOST").is_err() { + println!("LITELLM_HOST not set, skipping test"); + TEST_REPORT.record_skip("LiteLLM"); + return Ok(()); + } + + let env_mods = HashMap::from_iter([ + ("LITELLM_HOST", Some("http://localhost:4000".to_string())), + ("LITELLM_API_KEY", Some("".to_string())), + ]); + + test_provider( + "LiteLLM", + &[], // No required environment variables + Some(env_mods), + litellm::LiteLLMProvider::default, + ) + .await +} + +#[tokio::test] +async fn test_xai_provider() -> Result<()> { + test_provider("Xai", &["XAI_API_KEY"], None, xai::XaiProvider::default).await +} + // Print the final test report #[ctor::dtor] fn print_test_report() { From ef87ad34f0da7ba27bd5319aa7d155c66ad5096a Mon Sep 17 00:00:00 2001 From: Douwe Osinga Date: Mon, 28 Jul 2025 13:58:11 +0200 Subject: [PATCH 14/18] Merge after merge --- .../src/scenario_tests/message_generator.rs | 3 ++ .../src/scenario_tests/mock_client.rs | 37 ++++++++++++++----- .../src/scenario_tests/provider_configs.rs | 3 ++ crates/goose/src/providers/factory.rs | 12 +++--- 4 files changed, 40 insertions(+), 15 deletions(-) diff --git a/crates/goose-cli/src/scenario_tests/message_generator.rs b/crates/goose-cli/src/scenario_tests/message_generator.rs index 2024be76cb0a..d8b463007915 100644 --- a/crates/goose-cli/src/scenario_tests/message_generator.rs +++ b/crates/goose-cli/src/scenario_tests/message_generator.rs @@ -1,3 +1,6 @@ +//! Message generator for scenario tests with convenience methods to +//! just generate an image or text message. + use crate::scenario_tests::scenario_runner::SCENARIO_TESTS_DIR; use base64::engine::general_purpose; use base64::Engine; diff --git a/crates/goose-cli/src/scenario_tests/mock_client.rs b/crates/goose-cli/src/scenario_tests/mock_client.rs index 876d246e959b..cdc35ef8e9ff 100644 --- a/crates/goose-cli/src/scenario_tests/mock_client.rs +++ b/crates/goose-cli/src/scenario_tests/mock_client.rs @@ -1,16 +1,17 @@ +//! MockClient is a mock implementation of the McpClientTrait for testing purposes. +//! add a tool you want to have around and then add the client to the extension router + use mcp_client::client::{ClientCapabilities, ClientInfo, Error, McpClientTrait}; use mcp_core::protocol::{ - CallToolResult, GetPromptResult, Implementation, InitializeResult, ListPromptsResult, - ListResourcesResult, ListToolsResult, ReadResourceResult, ServerCapabilities, ToolsCapability, + CallToolResult, Implementation, InitializeResult, ListPromptsResult, ListResourcesResult, + ListToolsResult, ReadResourceResult, ServerCapabilities, ToolsCapability, }; use mcp_core::{Tool, ToolError}; -use rmcp::model::{Content, JsonRpcMessage}; +use rmcp::model::{Content, GetPromptResult, ServerNotification}; use serde_json::Value; use std::collections::HashMap; use tokio::sync::mpsc::{self, Receiver}; -// MockClient is a mock implementation of the McpClientTrait for testing purposes. -// add a tool and then add the client to the extension router pub struct MockClient { tools: HashMap, handlers: HashMap Result, ToolError> + Send + Sync>>, @@ -28,7 +29,7 @@ impl MockClient { where F: Fn(&Value) -> Result, ToolError> + Send + Sync + 'static, { - let tool_name = tool.name.clone(); + let tool_name = tool.name.to_string(); self.tools.insert(tool_name.clone(), tool); self.handlers.insert(tool_name, Box::new(handler)); self @@ -74,8 +75,26 @@ impl McpClientTrait for MockClient { } async fn list_tools(&self, _: Option) -> Result { + let rmcp_tools: Vec = self + .tools + .values() + .map(|tool| { + let input_schema = if let serde_json::Value::Object(obj) = &tool.input_schema { + std::sync::Arc::new(obj.clone()) + } else { + std::sync::Arc::new(serde_json::Map::new()) + }; + + rmcp::model::Tool::new( + tool.name.to_string(), + tool.description.to_string(), + input_schema, + ) + }) + .collect(); + Ok(ListToolsResult { - tools: self.tools.values().cloned().collect(), + tools: rmcp_tools, next_cursor: None, }) } @@ -107,7 +126,7 @@ impl McpClientTrait for MockClient { )) } - async fn subscribe(&self) -> Receiver { + async fn subscribe(&self) -> Receiver { mpsc::channel(1).1 } } @@ -128,7 +147,7 @@ pub fn weather_client() -> MockClient { } } }), - None, + None, // ToolAnnotations ); let mock_client = MockClient::new().add_tool(weather_tool, |args| { diff --git a/crates/goose-cli/src/scenario_tests/provider_configs.rs b/crates/goose-cli/src/scenario_tests/provider_configs.rs index f8705e411bb1..c972c2b47e05 100644 --- a/crates/goose-cli/src/scenario_tests/provider_configs.rs +++ b/crates/goose-cli/src/scenario_tests/provider_configs.rs @@ -1,3 +1,6 @@ +//! Providers for the scenario tests. Keep in sync with +//! + use std::collections::HashMap; use std::sync::LazyLock; diff --git a/crates/goose/src/providers/factory.rs b/crates/goose/src/providers/factory.rs index 27545c3a2191..b3b8b044c8c2 100644 --- a/crates/goose/src/providers/factory.rs +++ b/crates/goose/src/providers/factory.rs @@ -152,23 +152,23 @@ fn create_lead_worker_from_env( fn create_provider(name: &str, model: ModelConfig) -> Result> { // We use Arc instead of Box to be able to clone for multiple async tasks match name { - "openai" => Ok(Arc::new(OpenAiProvider::from_env(model)?)), "anthropic" => Ok(Arc::new(AnthropicProvider::from_env(model)?)), - "azure_openai" => Ok(Arc::new(AzureProvider::from_env(model)?)), "aws_bedrock" => Ok(Arc::new(BedrockProvider::from_env(model)?)), + "azure_openai" => Ok(Arc::new(AzureProvider::from_env(model)?)), "claude-code" => Ok(Arc::new(ClaudeCodeProvider::from_env(model)?)), "databricks" => Ok(Arc::new(DatabricksProvider::from_env(model)?)), + "gcp_vertex_ai" => Ok(Arc::new(GcpVertexAIProvider::from_env(model)?)), "gemini-cli" => Ok(Arc::new(GeminiCliProvider::from_env(model)?)), + // "github_copilot" => Ok(Arc::new(GithubCopilotProvider::from_env(model)?)), + "google" => Ok(Arc::new(GoogleProvider::from_env(model)?)), "groq" => Ok(Arc::new(GroqProvider::from_env(model)?)), "litellm" => Ok(Arc::new(LiteLLMProvider::from_env(model)?)), "ollama" => Ok(Arc::new(OllamaProvider::from_env(model)?)), + "openai" => Ok(Arc::new(OpenAiProvider::from_env(model)?)), "openrouter" => Ok(Arc::new(OpenRouterProvider::from_env(model)?)), - "gcp_vertex_ai" => Ok(Arc::new(GcpVertexAIProvider::from_env(model)?)), - "google" => Ok(Arc::new(GoogleProvider::from_env(model)?)), "sagemaker_tgi" => Ok(Arc::new(SageMakerTgiProvider::from_env(model)?)), - "venice" => Ok(Arc::new(VeniceProvider::from_env(model)?)), "snowflake" => Ok(Arc::new(SnowflakeProvider::from_env(model)?)), - // "github_copilot" => Ok(Arc::new(GithubCopilotProvider::from_env(model)?)), + "venice" => Ok(Arc::new(VeniceProvider::from_env(model)?)), "xai" => Ok(Arc::new(XaiProvider::from_env(model)?)), _ => Err(anyhow::anyhow!("Unknown provider: {}", name)), } From 41d030973897388b06fe67bdc86a8b4e03ba5532 Mon Sep 17 00:00:00 2001 From: Douwe Osinga Date: Mon, 28 Jul 2025 14:07:17 +0200 Subject: [PATCH 15/18] Add the recordings --- .../src/scenario_tests/provider_configs.rs | 38 +- .../anthropic/context_length_exceeded.json | 1 + .../recordings/anthropic/image_analysis.json | 537 ++++++++++++++++++ .../recordings/anthropic/weather_tool.json | 531 +++++++++++++++++ .../anthropic/what_is_your_name.json | 238 ++++++++ .../azure_openai/context_length_exceeded.json | 1 + .../recordings/azure_openai/weather_tool.json | 523 +++++++++++++++++ .../azure_openai/what_is_your_name.json | 238 ++++++++ .../google/context_length_exceeded.json | 1 + .../recordings/google/what_is_your_name.json | 238 ++++++++ .../groq/context_length_exceeded.json | 1 + .../recordings/groq/weather_tool.json | 523 +++++++++++++++++ .../recordings/groq/what_is_your_name.json | 238 ++++++++ .../recordings/openai/image_analysis.json | 243 ++++++++ .../recordings/openai/weather_tool.json | 523 +++++++++++++++++ .../recordings/openai/what_is_your_name.json | 238 ++++++++ crates/goose/src/providers/factory.rs | 2 - 17 files changed, 4106 insertions(+), 8 deletions(-) create mode 100644 crates/goose-cli/src/scenario_tests/recordings/anthropic/context_length_exceeded.json create mode 100644 crates/goose-cli/src/scenario_tests/recordings/anthropic/image_analysis.json create mode 100644 crates/goose-cli/src/scenario_tests/recordings/anthropic/weather_tool.json create mode 100644 crates/goose-cli/src/scenario_tests/recordings/anthropic/what_is_your_name.json create mode 100644 crates/goose-cli/src/scenario_tests/recordings/azure_openai/context_length_exceeded.json create mode 100644 crates/goose-cli/src/scenario_tests/recordings/azure_openai/weather_tool.json create mode 100644 crates/goose-cli/src/scenario_tests/recordings/azure_openai/what_is_your_name.json create mode 100644 crates/goose-cli/src/scenario_tests/recordings/google/context_length_exceeded.json create mode 100644 crates/goose-cli/src/scenario_tests/recordings/google/what_is_your_name.json create mode 100644 crates/goose-cli/src/scenario_tests/recordings/groq/context_length_exceeded.json create mode 100644 crates/goose-cli/src/scenario_tests/recordings/groq/weather_tool.json create mode 100644 crates/goose-cli/src/scenario_tests/recordings/groq/what_is_your_name.json create mode 100644 crates/goose-cli/src/scenario_tests/recordings/openai/image_analysis.json create mode 100644 crates/goose-cli/src/scenario_tests/recordings/openai/weather_tool.json create mode 100644 crates/goose-cli/src/scenario_tests/recordings/openai/what_is_your_name.json diff --git a/crates/goose-cli/src/scenario_tests/provider_configs.rs b/crates/goose-cli/src/scenario_tests/provider_configs.rs index c972c2b47e05..1e8f8019070e 100644 --- a/crates/goose-cli/src/scenario_tests/provider_configs.rs +++ b/crates/goose-cli/src/scenario_tests/provider_configs.rs @@ -1,5 +1,5 @@ //! Providers for the scenario tests. Keep in sync with -//! +//! goose/crates/goose/src/providers/factory.rs use std::collections::HashMap; use std::sync::LazyLock; @@ -43,8 +43,8 @@ impl ProviderConfig { static PROVIDER_CONFIGS: LazyLock> = LazyLock::new(|| { vec![ - ProviderConfig::simple("OpenAI", "gpt-4o"), - ProviderConfig::simple("Anthropic", "claude-3-5-sonnet-20241022"), + ProviderConfig::simple("openai", "gpt-4o"), + ProviderConfig::simple("anthropic", "claude-3-5-sonnet-20241022"), ProviderConfig { name: "azure_openai", model_name: "gpt-4o", @@ -63,13 +63,39 @@ static PROVIDER_CONFIGS: LazyLock> = LazyLock::new(|| { env_modifications: None, skip_reason: Some("No valid keys around"), }, - ProviderConfig::simple("Google", "gemini-2.5-flash"), - ProviderConfig::simple("Groq", "llama-3.3-70b-versatile"), + ProviderConfig::simple("google", "gemini-2.5-flash"), + ProviderConfig::simple("groq", "llama-3.3-70b-versatile"), ProviderConfig::simple_skip( - "OpenRouter", + "openrouter", "anthropic/claude-3.5-sonnet", Some("Key is no longer valid"), ), + ProviderConfig::simple_skip( + "claude-code", + "claude-3-5-sonnet", + Some("No keys available"), + ), + ProviderConfig::simple_skip( + "databricks", + "databricks-dbrx-instruct", + Some("No keys available"), + ), + ProviderConfig::simple_skip( + "gcp_vertex_ai", + "gemini-2.5-flash", + Some("No keys available"), + ), + ProviderConfig::simple_skip("gemini-cli", "gemini-2.5-flash", Some("No keys available")), + ProviderConfig::simple_skip("litellm", "gpt-4o", Some("No keys available")), + ProviderConfig::simple_skip("ollama", "qwen3", Some("Ollama not supported")), + ProviderConfig::simple_skip( + "sagemaker_tgi", + "meta-llama/Llama-2-7b-chat-hf", + Some("No keys available"), + ), + ProviderConfig::simple_skip("snowflake", "claude-3-7-sonnet", Some("No keys available")), + ProviderConfig::simple_skip("venice", "llama-3.3-70b", Some("No keys available")), + ProviderConfig::simple_skip("xai", "grok-3", Some("No keys available")), ] }); diff --git a/crates/goose-cli/src/scenario_tests/recordings/anthropic/context_length_exceeded.json b/crates/goose-cli/src/scenario_tests/recordings/anthropic/context_length_exceeded.json new file mode 100644 index 000000000000..9e26dfeeb6e6 --- /dev/null +++ b/crates/goose-cli/src/scenario_tests/recordings/anthropic/context_length_exceeded.json @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/crates/goose-cli/src/scenario_tests/recordings/anthropic/image_analysis.json b/crates/goose-cli/src/scenario_tests/recordings/anthropic/image_analysis.json new file mode 100644 index 000000000000..a2ae52c0ed68 --- /dev/null +++ b/crates/goose-cli/src/scenario_tests/recordings/anthropic/image_analysis.json @@ -0,0 +1,537 @@ +{ + "c848f22f273e158c32435d3e72cc999c046dc1a9afdc3efda68ff451f833a185": { + "input": { + "system": "You are a general-purpose AI agent called Goose, created by Block, the parent company of Square, CashApp, and Tidal. Goose is being developed as an open-source software project.\n\nThe current date is 2025-07-28 12:04:16.\n\nGoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o, claude-3.5-sonnet, o1, llama-3.2, deepseek-r1, etc).\nThese models have varying knowledge cut-off dates depending on when they were trained, but typically it's between 5-10 months prior to the current date.\n\n# Extensions\n\nExtensions allow other applications to provide context to Goose. Extensions connect Goose to different data sources and tools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level problems using the tools in these extensions, and can interact with multiple at once.\nUse the search_available_extensions tool to find additional extensions to enable to help with your task. To enable extensions, use the enable_extension tool and provide the extension_name. You should only enable extensions found from the search_available_extensions tool.\n\n\nBecause you dynamically load extensions, your conversation history may refer\nto interactions with extensions that are not currently active. The currently\nactive extensions are below. Each of these extensions provides tools that are\nin your tool specification.\n\n\n## weather_extension\n\n\n\n\n\n\n\n# Suggestion\n\"\"\n\n\n\n\n# Response Guidelines\n\n- Use Markdown formatting for all responses.\n- Follow best practices for Markdown, including:\n - Using headers for organization.\n - Bullet points for lists.\n - Links formatted correctly, either as linked text (e.g., [this is linked text](https://example.com)) or automatic links using angle brackets (e.g., ).\n- For code examples, use fenced code blocks by placing triple backticks (` ``` `) before and after the code. Include the language identifier after the opening backticks (e.g., ` ```python `) to enable syntax highlighting.\n- Ensure clarity, conciseness, and proper formatting to enhance readability and usability.\n\n# Additional Instructions:\n\nRight now you are *NOT* in the chat only mode and have access to tool use and system.", + "messages": [ + { + "id": null, + "role": "user", + "created": 1753704256, + "content": [ + { + "type": "text", + "text": "What do you see in this image?" + }, + { + "type": "image", + "data": "/9j/4Q/+RXhpZgAATU0AKgAAAAgABgESAAMAAAABAAEAAAEaAAUAAAABAAAAVgEbAAUAAAABAAAAXgEoAAMAAAABAAIAAAITAAMAAAABAAEAAIdpAAQAAAABAAAAZgAAAAAAAABIAAAAAQAAAEgAAAABAAeQAAAHAAAABDAyMjGRAQAHAAAABAECAwCgAAAHAAAABDAxMDCgAQADAAAAAQABAACgAgAEAAAAAQAAAgCgAwAEAAAAAQAAAgCkBgADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/9sAhAABAQEBAQECAQECAwICAgMEAwMDAwQGBAQEBAQGBwYGBgYGBgcHBwcHBwcHCAgICAgICQkJCQkLCwsLCwsLCwsLAQICAgMDAwUDAwULCAYICwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwv/3QAEACD/wAARCAIAAgADASIAAhEBAxEB/8QBogAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoLEAACAQMDAgQDBQUEBAAAAX0BAgMABBEFEiExQQYTUWEHInEUMoGRoQgjQrHBFVLR8CQzYnKCCQoWFxgZGiUmJygpKjQ1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4eLj5OXm5+jp6vHy8/T19vf4+foBAAMBAQEBAQEBAQEAAAAAAAABAgMEBQYHCAkKCxEAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD8ZJJccH9KqSXBHANabaROBxkYqpLpU+3pivifqx6zZjvPg4qESZHsK0W0m46MKRdLl6DtVewsQU9xHeovPUcVbl0+VT8vaqD2Nz0xTVETJ/PBbOc0pmHY1AthMuKY9lN26U/q47im4z36VHvDdfwpv2OQ9qlWymONwxT9iCZFvB+7UbjPPWtFLKQjG3BFI1jLwMUvZjM6HLNmupsB8oLHrWfDp0wA+Wt+106YNnaaUqZUTo7WNdgxWmqKowtU7WzuMDIrQNjOFHtXM6RpoU7hwowK47U7oJkZrqLyyuApJBzXC6pZXL8Eda1p0TKTOeursbsGs0Xag4zSXNhcKTVAaZc7hXUqRzm2lwHGBxSE/wAQNJaaZMoG7mtH+zpccCpdM0SOenIYcGsuVh1ziuom02TjA4rLfTZcdKaiDiYu/A61B5w6GtF7GRe1Z89pKvOMGtYxI2HibeuSal+0DHBrFcOvAFN8yToRWqgNVDUaZSOfpWbLKOajRHxzUn2d24xxWigHOYN0ok5rIuLRm4Fdi9g/TbUMlkw/hrVIxkrnCJbFPwrYhyg5rV/s9+oGKQ2Mi9uKbRmoEMZORg8VZVt1N+yOO1PWBwQNtRyFJFsSYxg85pzTgcZqi8TAZHFQSM+OlS4DsaJnypqm90cHmqLB+9Upd+aFATiWJ50zTVuxnFYkxkwewqEuwx2+lWoE2R1y3oBFWBdrgdq4rz39elS/aWx83Wo9mM6d7petZs90DwT0rINwdoBqrNK/arjATsXHvM05bw5yT0rAZ3BpvmOD8ta+zMrnWxXpGOfpVj7fjGDXHJI/en+c6j1p+zDnO8i1EDrT5NSDCuB+1MBxTHvZce3tS9kQ5nTvqQyQD0qMaiAPeuM+0P3yKi8+XrS9iQdz/aQxnPFSjUAcHNcKs8mfl7Vbjnk6Gj2I4s7FL7OATjFWYbpWGRXGxzMavRTyAdafs7G0ZHSTXGOR0FUJphWe1w2AT0qCSRj26UuQGyxJclSP6VW+3bckHjtWbMTVB3m69MVtGBm2b41Bh1OBR/ap+6DXKM79s1G3mDFXyCuf/9D84m8OqM7lzVCbw6MFdvWvdG0bnG36VSk0QckpmvmT0bnhx8PRgcjp7UxtBiA+70r2SXRR/dqm+j842/pRoK54tP4eVuFX9Kz28PdcrXtsmlY4IFUZtKXHzDimrE3PFX0Lb0XpVZ9BA7fpXscmlrjgYz0qo+lxnGR+nSi6Fc8iGgg4yOlW18PqFyFr0yLSxzx0p6aYcHHFA7nmp0Veu3p2qEaLyARXqD6co/hzn9Kg/s1UxnvWehXMcNbaHjjHeujtNDTpjjtXRwWSjjFblrbKuO1Gg0zDttERcYFaTaKmOFrq4YUxg96trbxsuay0NOY8zvdEXbjFcdf6GmDlele0XVuuMFevSuXvoUHAFaRaRnJnh13oS7uVFZ40L5h8vA9q9PmtUDdMCoxar0xWlzI4WHRlTjbV7+yUAxiu2jt0HIWrQtUA6VDNYux5rLohZsbcVmz6IeEC/SvV5LReOKoT2S+nSpQ+Y8cm0XsB0rEutFUDbjFexz2XcL17VhXFkh4xWiMmzxW50Yg8DiqH9jkdB7V7Bcacp6D2rPfTUA6VrzGZ5rDpHbb+FaEekhVBxxXfJp6d6kNio6CqUwOG/speMion0pO1ds9qFzVIxhDjrV8wrnHnRwMcZ/Cof7HB7YrttqD7wp2xBzjGBT5gucEdGBbpUJ0lR2rvykZ9KrPCD0ouK55/JpAqo2kDGccCvRTZFjnFMNkOhX+lPmC55lJozDoMYrOm0l+mM169LYgADFZ81gvYUcwHjsmjNu4HT+VVzoj5zXsD6XntTRpIBzT5kSeQL4fYjgCmt4e+UYFe2DSVAHFQyaMCcYFHMB4t/YLdW6U06DnqPwr2N9JVSOOB+FUZdNRMfLT5yWeQyaAeuKiGiHqB0r1htNU9qi/s9OgH0qvaEWPLf7FOKcdBLHdivUf7Nx2qRdMUnOOKXtBWPK10JuhHSn/2AccCvVk01O4p/wDZikdB6Cn7QXKePt4dy3AqsfDRx06V7M2np0xTTYR4246Ue0DlPGR4dK8Ypf7A2jFewf2dHjgVE1imM4FNVB8p5QNGK4wKsJpODyK9IbTlz8tOXTlPAFVzodjz86SRwBUD6Q/TFenLpqkcDikOnDAyKSmhWPKjobMw4qFvD7dxXrR0uPjA/pTTpygfdq1Mix5P/wAI7v4xUi+Gefug16ulkuMgVYjsVJ+7T5wsf//R88l8ITLyw4rNm8JzD7y19ST6EMfdHFZD6CCPu181yHbc+YJPCspX7nFZcvhSboq//qr6kl0FeV2/p0rOfw8o4xQqYrnzC3hC4LZ21XPgqbgla+ohoEZ+UADFPGhqDhgKfsxXPlGXwTM3Rf0qg/gmcn5R0r63bw+hPSqsmgRkdMe1P2YHyK3g+4jHyjP4YqCbwxLxgdK+pp9FiRSAlYVxoQzyMAdqhwC581TeG5B8u2s6Xw7MOcYr6Rl0OEEkrWTPpER5K4qOQZ4JF4dmLfdrctPD0w6rzXqseigOCBzW9Z6KCOmKXINM8wtPDkg+9FWrH4bZuAtezWeiKMLiursfDSHG5R+VCpjufMd14RnZSAnNcjfeDJsH5cfSvt0+FUZMBP0rnbvwlFjlKtUiWz4Yu/CMqNwtYr+GZhkbcY7Yr7RvvCEI58uuWuvCqcgJxQ4E3PlCTRZ4+NuKYNKnJxivo258KpnhKpDwur8FAPwqOUdz5+Ojyn+HFVW0qbONtfS1l4HutRuVsdPt3nmfO1Ixk8dfoB3PQV6npvwX8M6cXj8X3vm3irkWdmwRQw/hkmZSQOgO1Ac8AkjhqFzSnTlLY+BLvTPKj3T4jHqxwKpW/hvUNVfytKtpbx8AhbeNpmIPtGGOPwr9JtL8SeEPCmpR2/gvRNOXCgtK1uGkbkNu8x1kkOFB4MqccccY7+2+LaSxXBtJxFCZT5awT/K2cZztVR0xwM/XihrlOyGBb3kfl7H8EvitfAfY/C2sMW+6psJ0Jx7MgrRT9m745y25uR4O1coP4ltiR/j+nFfovP40uNZd4pAN/wBw7DGo2xryQ2XPOM5ZlHv2HCP4psVRZ7Z4TPG4j8i3MkjggZ2ltw4xjDkBSf4azlUsjeOVxfU/OvxJ8PPFHgwr/wAJlpN5pCvja97byW6N7K8iqp+gJrm5tJKgAAj8K/U/RvjTr+nI2ZJJUnjKNAlwwEuMriSI5TgFfu5ySAcV5n4i+HHwq8fWtze20EXhm/O51uYn8q2yvaa0K7VXPBkjKvkc7ulZLEpbkVMpklemz83LiwcfdGAKyH01/SvbPF/g3VvB2vTeHvEEKxXEQVxsYSRyRPzHJGw4aNx91h6EEBgVHHyWQxu6V1xqXR40oOLszzs6e/cUgsmB6YrtnssHgVAbMA80+ck5UWBGDTxYFR611a2QParUNiueR+lPnKscb/Z7g8CrEeksenSvQbawRgNy1sQaUhOVFO47Hlp0Rvu4/pVdvD7+mK9sXSFOPl61GdHQn5RTvYLHiZ8Pv0xR/YDDtivcF0dc7dv5VJ/Yi9CtHMHKeHnw9IANoNI+gSdMGvd/7GiHG2qk+loOABS5g5TwCfQXj6isqTSHB5XivcbvTx0rn7iwycBeKXMS4nkp0gdMYxUI0fdjjFemy2I9OKbHYKTwPpTUibHncehqeBU50AlsjgDoK9Oi0xX/AIauf2SO60XK5TyddDk6jtxTn0N0GVxXqZ0r5umPSozpuO1O4uU8m/sVy3zVH/Yz4wP5V6k2nNnpVR9OfPApcwcp5k+isMFvpSDRX+6elelLpXPtUw0kjtmjnGonmJ0KQ9OMelTR6DIMYHAr1CLRyR8w4FWotKHGB+lHOHKeVLokgyGWon0WRe1evHS0x8wqhLpy54FHtCnA8nGkv1po0iTPAr0xrAKcAfkKadPAwcc1oqhnynnK6QT0FXoNHYY2rXcf2cchttXIbDjG2n7QnlP/0vrq40HcMBcD6ViXWhDGTx9K9nuLFsdv5Vyl7p7Y5xivBsdljyabS4h8tZb2MAOPSu9vrJv++a5a4h29e1USzn5bKFRvBwaqLBEvU1p3CKFzmscxOzfLQSWHhg2c1lyQ268j0rR+zydGNZl1EwHy9PSpbsUjDuDAvPH4ViSCLngVdubWbJwaxpbaRW+du1ZuQFG7WFRuPeucnZMnH+Fa8sT4+c1hSxYOV6dqych2JolRm64rp9PijHXtXJW6EPxXYaZbMWyTkZpKQ7HZafbKSCMV2un6fHhWY5H0rB020bCknFdrY2bNt5raIWLyWUO30NY99YxAHaK65LGXb8v8qxtR06fHX2rQTPNNRtoQM4HFcdexQ8lq9A1S1mVWJ615pqdvOWIXP5VDZJzN2kOSOwrLhiSSZIoRuZyFVfUngCmahDcKuWNQaFd/2PcXGuTDcbOMeSvPM0h2p06BcFvwrLfQqELtI7u+1bw74XWTSTPtRUZbuSNf3rso9ScJEvuPTjJzXjfjT4zWcDpa6LD+9JYfKM79jMhTgAmLPYZJGM9cDy74gfELTNMtpbWK8WJI2Uu8eMxxjkYOF+ZuOvQfQmvF9I123v8AVBcWiRxS3kywwfxHbEoO9i3zbRnjH3sjNXUlyo9mlCysj3fRNW1nTI0SWY3Gogeb5QO2zs0KvGpkWIDcRu4Hr8o/iNeuxWylks9Ku5ZXGWkcKI1xyQu0bFTJ5GOdvXOQK+bPDvitvDkMMBm2Btyt5e5nO48ktxjnPzdPpXb2/jw/b1jvBieQqM78kFwemMAKOBjj0PWuCpVud9KCR9CXHgu11N0DiK3nCIpVCVjR84BUBVI6Zct2AGOc1yfiBbjTdJ8y0nuGhVCdzQqi7Aed0YAKDPA+bOMkYrd8PeObyfR/LiuGt+Nu9juO9VGSykYIUHA5xkEk8DHk3jvxR4q8SeHdU1Lwh4d13XNB0+b/AImGr2lnK9hby5+ZTOiiN5FIwVQl14JVVK1wVKmmr0O2MOyOFvPG/wDZ+qLBqNo0wLqTv5USZwDhQ8w2/dzg8YAOKXSfiFJa3fk2sMbQp8qILuSWWNg2UktpZNkgU9Cr71G7aRtwa+Qk+KOleJohdWU/k5JBjeRj5bDgrIMRSKQRghvmU9emK7Lwzq194s8QhiLucodv2mDEshb7rDbKHB4+8rbeMGokhKSZ9ueK7CP4l+FILa9mU6rCxfTJGXyhIWyZ4HBCqm9tu3k4kA7FjXyCyLtDY7dMY/T+lfSfhG9+y2sqyLJHcjYzwqm1G8vOJEjBBSUZJLKenGDwK89+K2im28UvqkSIkepL9oIiBCCU/wCswDyAxw49d3Htrg63/LtnkZzhFZV4ryf6f5Hj7RIBiovJXGK1WtWXPFQ+W3GBjFehc+dsVxGp+UCr8FspxUMcbbsVsWsTD3J4qlKw0i1DAoIAH6V0drbDr0rNt4X+XiuktFKEbhjFacwyZLBD/DU4swOCPyq+kqAcipGlUH5eaOYZnpYL/d/CpUs07AVb35HzDj2qRHB4PtTUhFF7FdvPWse5s0CkseRXRSzrg4xxXP31wgyaTYXOUv7cL14rlriNOgrdv5DJkrXPzQzFjgVNxNmVJEM8D8KWJVBGRV8Wlwx4StG30y5Zs+X0qkSQW0KnoOK2YrQBQAK29P0SVhzGcV0K6C7DIQ00UcI1jhQcflVN7IDg16DNpLRj7rZFY8ungdjTA482ijiojZjpXVfYB0ZcYp66dGx5FFho5VLNRSm0AGMZFdjFpkZ659qt/wBkK3HpSK0OEFsOrCp4rY4rtG0KP+A4HWnxeHz2J9uPSkxnESWmFrJltRnOOK9Mn0R1Hy8/pWPcaPKGC7KgbR579m546CrP2MYHy9RXWJpM38KGrY0h9mdlbRMWcOlmN2FWriWmFxium/smXpjj6YqxHpbhenFAj//T/UW50pF6MK5C90kkMYz+Ve73GlJg8VzN1pMQzgYHpXkSpHUmfN2raVcqSUNcDe6dJkjNfTuo6UpHC/pXE3eiKx+59OKz5QPnuXTXGcZpkGnSFh6DgV7e+i7eQB+VV00Urx5Y9qOUk8k/s8jrxWXeafGycHnoO1e6/wBhgjlf0rKu9BiUfdBzScBnznfaeckdu3auXudNcjOOK9/1LR1UHCdq46fRn3Y28e1YygUeOy6YzfeFY82i7zgA165c6W8ZLMMViSW3z5XmsnALnAWmgNuB5rudJ0CYEbAeK2bG0ywUY/KvQ9Js1fjGKqNMZl6Zos6hRtyK9B03SJguQp//AFVqaZacgYr0HT7Ln7v5VtGCQHFrp0ioCynisa/tXwQUr3JdKDJkr09qx9Q0VSh+Xr7VYHyzrkbDPy15fqZC5G3pX074k8PqEJGOK8e1rRI+V9v5VDiQ0eCX8qJlSnFfLfxx8V2vh/S20ueQI2oRZxz8qRbxuOBgZLHA/i29MCvsHWdIiGW/u+or5u0r9mvxd8cvj5H44VYLfwj4eu00++ubm5WCN54o1fy40IZpHDsCQq44wSM4OVVqmuZ7Hbl1GVaqqcFqfkn49+JV+NbtrRlTybf5ywKnzSp+YgrxyRgntnA4FUND+IINtbOjAtA775FYqdozntwMnPOMBRjiv0o+NH7CVrrcI0nQYRbO10IvtNpIC0cWMgIkgZW3/NknG3j0rxHUP2H/ABH9kj0/w35SXKtEyRzSAF1Aw5OASVHACgD5iTzwK82ebYWUfjR9Qsgx0Zfw39x4pdfFzStOsLOwsrgo7MTKqJ2O35CScbeAMelbWifFGI6rHe6lMPLWEnbuyIwT15LYI9RjG72qj+0X+yd4s+DHgxvGmqjEEMm6QIu0MJV3bhubIii4TqS2B0+7XifgLTtF1O5tvN+bKYHHb35+vv04rOFWlVhz03dGVfDVsPU9nWjZn03L8VPFnjnUtL8NaHNe2ljcXEX2u4VQZTbQ7pphCh4LeUjbP4Q2CQw4p3xM/wCCuviL/hbK6d4c8a614e8B+EZ303RvCugSfZrdbayBh2TBsxTG4O8O8pZH8xnOGCsvs+k+HtM0HV9G1d7SUwq6I7soC/N8jqCemUZlB+706CviH4xf8EsoY/ixceKPDviU/wDCMX0094YV06Rr5Hc7/KiUlYCXcts82RPK4DCRBvZ4GrQp4n2tZbLTS9u/z8+2nUxx+HxFSgqdHvr0/peXoeofD7wL4I+L2v3vin4RNexeG9WVLixi1QQperDLPLGkc3kl4yyrGF3qxDY3fxYH6r/Bb9mTSdPS1mvrfyjGm11twVXKDaGGNpPPGR0659PCP2XfgzrmgXUUOmWttp2j28cFtBYo7TvbWtmgRFY7MuwOXdyRl2bHYV+rWiWmtSiCDTlfAIXGNroFVccYHOM56dcVw15805cvw9PQ9GhS5YR5tzMvvgZ4G1O0/s8wwldm1JGIkKkjgfM24hD0Dc88e3xZ8cvhFq3hWOKaYfabZWzBcoSybDw8WTnlWwy552kg5Ir9KpNVls7dfImVyz4MR2/cPA+6doBGOvGf05LVrTwv478PSeFPFjxJA0TLKzKyzxtzsaPdwpQ8jCrz1O01hTl7Oan2KxND21GVNdV/wx+M8miIuDgGq58PxtyF9vSvX/E/g/UvCmuXXhvWF/0izkMTkDCtjo6j+6y4ZfY1hx2WCFI+lfSRSauj4CUHF2ZwNv4bjyAF+ldXp3hOKTGE/Cuws7FCw4ru9J0xHxtAqlFBY4Sy8ERPj5AMV0EfgNAB8v5V7Tp+gLgbQBXSx6CoByPpWiggPnKXwZGg+7WRN4V2DHUfSvp650KLqyj0rmbnQ0T+Cm6SGfOzaBtJx9KqNoLY3mvd5tDjDbsVUfR0zgD9KnkEeEzaDHGuCTzXOXuix8jca+ibnSYmXaRg/SuK1LSE6ipcRWPn670lVzzWX/Z53fL0r1TUNKjU81y8lmsfHX6UlETOehsCOBW9Y6bLvGO1WraELjdXZaVBGZF4rRREXNF0h5RtxXcwaE5Ubl/wrovD+mxMgO0flXpFro8WASMiqUTRLQ8Tn0Jtv3a5ubQj3X9K+lLvQYimQv6Vzs2hhWzj8K15CGeADw+M5Knj2qX/AIRzkBh9OK9y/slEJ4qSPS4ccDNS4oaR4mnhhCOV/SrK+GE2j5OntXt0ekxnkdu2Ks/2VF6Co5Uacp4Z/wAI2nGE/TFKvh9BgHt7V7edIjx8lB0aILtxUOJSPBpND28ovP0rIuND3HaBgemK+iJtFg9BXNX+jocdqSiDZ4MNEYfKOhqcaM+B7fyr1KTRABtHQ1XOkFRjOK1UTFo8uOlYHFEej5PSu/fTMMSG/AVHb6e2/GeD7fypNDsf/9T91rmwBBGK5K90kDI9K9WuYJCNuK5q4tH5PPFcMomyZ5DfaWN1YEmkjduxwK9Xu7NupFc/JYlDtI61lyFHmsujryDjIqg+ljIAXpXdzweWSSKzJBs4C9afKgOYTSl7D9Kp3WkIRwK7SOP+6KbPDLs+UD8qLIDxnUtFTBIXp7Vxk+mRISCte4X9nK+QBXLXWhFm+X8qxkho8P1PTY9uNtckdH8x8Lj0zivdtR0E7duPwrmZdFaNxgVHKBw9hoSKQSgPpXpeh6FAVHy9eKSz0glxjivQ9IsAf8KrlQE2m6BbqAcYxXeadpFqqLkU3TrRABkf4V3FlAi4wKaRRVg0y1CgEflVG90i1K7wvXtXdRRLtxiqF7b7gflq1EVzwrXtDtyrbVrwPxNoKoW2AV9a6tYSFWAXArxzXtILg5WnyEHxtr2kyJvwKoaleXnhL4O2HhvRk8qGXU9R1K5JJy66hfTNtU8YYoQfbgCvaPEehiFWklGFXk/QV5Z8fILrwzoGi+DoPnu0Q3lzHnHzyAbE6D/VptHbGG+teHn0ZOgox6n2PAygsc5z6L+vyPIXvdWvdVSSyGfLcbEcgkjbtXHXlRiptGt3nvV1G4Agk3/TeFwM8DoSMgVmC4j8EaTDol60kOrap8wVTloY3HfoRn06AD8K3JodWtp4bmXc8SDah9gNuPQgc1+MZ5iIYaThf18j+gsIva01JR9DxT9u911/9lnW5tYt2fTdFeG+mAVGI8nmMsG5xvCbduMNg+1fhx4A8WWNjqzSw26+QPlVZOecnHzcc8Y96/e/4tpJqfwk8Z+EEhVv7V0S+DbsH5liJXHYY6/yr+a3wajXGqSxjKlDk56grwM59SOmOtfU+H+PWKy+pH+WTR+ZeIOH9jjaU11j+R+5Pws+Iui3unRvq1pHeRsFfy5HO0bMAZUcD0Ax/gfs/wALavceI9KMM8QMPEgjkYLtGMYXcoAG35iVH06nH5TfA7w/r1xCl20yWdug3uduDxgkfUdAMfjX6h/D3UNSt9OeGaXzY9hBBHlou4jLDDH0yCPwxX0tSNnofM0ZaanceFUsrXWFg0tY1s4oQYwTkF8j5mPOQuABnAzxjFe13XiKO3eKJYQZ/M3gynbtLAHACkg8kc5xgdeteRaEJ9clns7G4jit2iLRbRtRN2CVbkL82cYxj8c1zusa9ptptL/vJkaNS42BfMUFl+RT1AJw6H6+lZNmp9GaXqz6jaTm4YJM7qzI2MsABk7SAeAPl4yB0zjJ5XxP5k8IutBnkbyZd8camOJGGfmKupYrkfxBVII+bgc+TaX4vm1myi+zfMHwfu4IbryTkYC8gr2PcdOwmnhgsmvy7ossib2hfoQmSpDYUtwOuHBIxXPOZrGBwHxk0seItPs/FcX2hrq1YWVybhVWXYwLR7tihSUYMhIyDkYwMAfPbaTc+n5V9TXGraprbX2iazDHKt1Buivk2upe32yRhiAsiF0GB5gIJ6Ed/OJtGZDkCvocoqe0oW7aHx2fUPZ4nmWzX/APPbHQ5ycgenavQNE0eZdo29PSrtnZujAKv0ruNJi2bfl716VjxzR0rR59oBOK6iPR5wnBNbWk7GwAp4rt7a2DR4xWsUUkeTXGj3JTIya5qbSLrPzKa+gZtMcpjFc7caXyBinYdjxf/hGJZsZBAqeLwccYwfXpXrsdkiHla0UtodvKinykHhF14PPHyVwuq+FmQFWQ47DFfVs8UQXbt6VzN9YwzLt2c/SplBAonxXqnhtF3EjH4VwVzo8UbbMfpjivsbWdBUt9wV5nqOgwIxYx8VEYETR4Pa6XaMQrL7V6Hofh6z3KdnFb9vp1tv2iID/61eiaBpcEpB2DitlTIRd8PaHahV7V6Ta6PaDADgHvWzoWhW2wLt/SvR7Lw1augKrQom6PIL3Sk2bQa5WfS5VPDV9BXnhaIrwhIrlLnwvbq2Chq0iWjxR9KuD93H4ihNIuOBtX8q9jXw1Dj5Vq+nh6HOCvSk4jR4+uluF+dR+FE2kqPvL0r1/+xYwMYqneaGn8Pas3E0R401gnoag+xqDxXpFx4fOfpWe+hygYA6Vm0Wjzqe32r8o/SuTvomXlR0r2O50eTHK1y15oknRR+OKIomSPKnSRhj8KhML4LentXo6aGzNgL+lPk8PMF4jxit+XQwPI3tjkY71Lb2bI/wA4yO1d5LoTJIB5fGanh0dtwJTtWEl2N4x0P//V/okuVBGFFc/NDv5OBiu5uLddtYk8KAZxWLiXc4K5g5PSudvIyDnH0rvLqFQTkVzl1Co56Vk4D5jzm8WROAM1hyxSE5K49q724gTPrWUtsjNwuKlxGpHPR2LMoJFW/sPy9K6eLT92AvFWm0xTnArNotM88uNOycise50wjPy/lXps1oVyNtYVzZOR0x6VLiB5HqOmS5wtcff6bKp3IK9d1GwuR26dK4W8sbtWIwaiwjjYre5R+ld/pEE2AAOnHSqVrZz54B9K9A0nTJwAKqwF/T4WwC4xXZ2ka4BxxTtP0Uj8K7Oy0XjGP8iixaMNV24IHb6VTvJmHG3iu+GiFh0rNutDJUgjHatIxJkeM6tesinaucdq8g1vUGUsuP0r6M1bQwN2FrxjxDoW5mVEGewrSxmeHJdWX2xtW1ZEe0sMSGJ2CrLJyY4zn+FiuX9I1b2r4n+KXjo2WvHxy7y6hfyqfIe4haBLq4dVZ38hiGEMJJxvGWIHbaB9zeHPsnim8u/NtA8FjqDWNqrYEckqBmedvoqjaOgBSvzy/aG8U+HvhXc+Kfi14gsm1C38G2Tz29nIdqXd07pHbW+8biqS3Uy73I+RFbIr814jzydStDB4T7XXsv8AhtvkfuPBnCXsKbr4pe8um/orLtt9/kZXwP8Agx4n1rxDfeKPG8r3F/cAzv5sgec7hyWGeMLz6Ae1fWegfDxri8ubCVD5dnkRf3scdc+9fFn/AATx8OfGFLvXPj5+0xcsNWZ2uzapCtvHEs6t5MHk4Hlk7lKoxLiMZk+bNfbfh74tWWmqb+5O7zi+85wCW5PH8hX5nntHDUv3N1pe7ve/nsj9Hpxrqzt0WlkreWl0fMXxKuI7rxa2haDErTbmt8Yyp3KUbI9Oea/lphsdQ0rx1e2NkAq295La9N214WKMvGfu4K49B09P6jL7UrE+ObnXYfld33xhcA5PT8q/Br9tz4CeOP2fviZd/GnR7NbXRfFFxLcCSJAbeK4eQEjJ4BkkZiO+XOOOK6/CnMKca+IwcnrOzj203/T7j47xKwM5YejiorSG/o7H058II9Q/ss3bAkIm3YwVCU6ckMFGOOvPvX1loniyDR5rgPbvmNUSLkpGXB+X7uQNp4yQQPfkV+Mvw9+OUV3DGkkxk8vqrnEg456d+fTnGPQ19seBfio99KtzaOUM6ABSMr8o64XDcn1JGevrX6tiKTi7NH5hh6qktD9R/BPxVsh4eGnsqyRbCN7kA7l5UhtiEsuMr8/Poelcr4s8WW13px1FpI2ETAtuYq0UhHy7ccKM4z1GWI+Uivkex8QXUNzJNDIZBKhB3PuCnnayhuMZB+UYIOQQetU7/wAdGDRp1e5aON22FFJCM5PyffP3d2B7dOlcFtdDu59D7N0jVb+DUY5njVbWZFEqvjCgg7Wzgk4O8HaBk9s8D3Q+M7ax0uSF/wB9FcRwD98275VCBCVYdArhSQpUg525HP5oeB/iDLbWi67HGb6D7kse/aSm0noNrfLjg9M8dq9R8K6lo/i3X9Q+Gvj3z10u/V4QY5TFIPusGibHyuu1WKZUEj1OK5KqOik10PqHwRYQw+K1nsrZ9N+0PMEgWTem4Z80KvzBfv4+Q7cAZVa9Bn09QM+grwP4IWvjXwt8V5/h54maS702+lkvtEvWY+Z5kavE4+bBCzqjggfxYHXk/Ud7od4p3RqdtfQ8PfBU+R8vxLpUp+jMGx0wM2eK9C0XRFDDjj3rnrHTr6PA28V6Ho9tcqRkEV7vKfOo7PTNGhVAxUV3NjpduBtPtiuf0uKUKuAcV2tpDKcZ47Vdi0RDRLI/KcVmTeHrXNdrFZnABFSjS1k6ZquUDzkeGbdz8pApf+EXhVcKcV6cnh5m7/SpP+EckUFg351ookHk03haFlx3rJuvDEWOa9pn8PuAWRqxJ9EmCkHPFRKK7DR896p4VXoB9K871Hwrb4/eda+jdW0iVFOfoK87vdCZzsP4Y4pRgiajPFE8I2vmgLjr9OK77w/4atgy8LXWQeE0Zv8AOK7vQPCMW4ba6OQxRq+HfDMSxqU7dq9JstBhjQbhj8K0dD8OJEgVR09K9Dt9AiWPDdqjl7HTHY8wudHhVRgDmuUn0OJjjGK9uuPDcbKdua5m58LndhCc00hSR5JNpCKAQv6VANGjTqR+Verr4dcYHrU39hLkhVoaEjxqXSYcAkdPasmbRoXOele2voQ6bcVVbw3HjAXmsnEs+frrRgp+Xp1FZLadIo6c+mK+hZvDFuOq/nWLNoMKZ2ris3AuLPCJbFm+Up+dY9xYpnlcV7ldaasa4Kg1z13psPQKKqCJkeRRabASeAK010eB15rt47G2R8COtmCwt+pjx7V1KJgeNz6BAXKkcCp7fw9bsN23mvZf7Kt2OQgpY9KtwPLxxWEoG0Wf/9b+k+UjGBWPc7B0Fa5iJqnJbnHX8KLBc4+8MIJrnLsRtnqPau6m04vk+ntWTNpQPNTZAcDJboTt/So0sICd1ddNpTZNV00zj0+lS4AmZQto1p0sQj4rcTTRjnoOKSTTMis3AtM4+4idR/hWHdwOoyOfau9k03OOPyqm2nKcgiocCrnk90Jic9qxpYAxO9K9cudKVlCkYrEm0lV+8KXIK5wtpZ269V/Ku30uOzXb2/Co00wA4ArTtrPn5Vxily2BM6/TVscD5q7CxhtRjmuHtLbYFH+eK6y1TaASelTYu518FlCV56VFeWVrsz0x2qlDOwGc8US3O47cdeBit40yHI43WLOAocD6f/qr518R3emR3E+nqv2i7wYwqybVjzwSSOSw7KvA7ntUnj/4u3eras3h/wAETQxwpIYGumbBlkHUR/7I6ZHX2FcANKvdEXzbyVUMg3BwuR8p5z2yMdPpXiZpmKpxcKb16n3HC2QQrVY1sQv8Mf6/I5HUdC0/Q9EtPDvhWN41sC0nmAdXbk8n+JjjK8Er9BXzNffCHxB4i03ULazigW5uVtnX7WFkjjkguoZRMc5H7v5mB9QD2r6t03xpNrTONFje4hjJxMyDZkcZAbsPWuI8S+NNMs/tHiXWrmFbWzX53UbI5G6ZJ/i9B27CvyXHYGDxX1u/S34W0+R/QOErvD01Bbqz+e55JafDyxsNJtvCy37f2SJnmImUrNd3MpzLPIx53Ofup/CoA9q474iX37P3gCyUeMNQtrVolMnkiXzJ2VBy/lr6ds4x9KydU8IftB/tHNLr1lfyeBfCreYsNzLaE6hKN21nW3k2GCMKOGfDseRtX73g2vfDD9mf4TiS08R6/d6vPGySXO+5aNZZ05UuY/lPJLbDu5I9BjhlkuGmuevJRv3V38l08vyPGxmc4jmaoRcmvNJff/wDw7xx+2f4X+H+kSeK/h14J1DxBZ+e0UVwECK5EZlwkkrJGcIpdirMqj5c54r8of2z/wBsD4w/tNaNovw31zw3D4W8O6pv1OSzZy120tmA0asAV8sBiCQRyVHQDn9HPjB+1j4c8M3El78MbLTdKj2+UbprZGu5AOSvn3OZGBOflUAD16GvxX/aj+OWvfF/4gafrNxK850oPGHiBm2tIQThgccBQOPTvX1nDeT4KhVU8PS1X2np06JW+X5n53xLm+Lq0nSrVVZ291dvN/0vI8i+HeoXPh5XTSodtxbkEzAbvLJIx0z1HB4ww4I4Ffa/hHVIoYomvGx5HKtHz8j9SBz97odvB4IxytfHul/ECDSDdLcaMyPJEyt5aqNxbguVbGD03AYBxnrWW/xL1cyn+z28kEgA5AK46YC8DHbivra9KdR6I+Lo1I01a5+kkHxHtrkNZ6nOlosP71Wckbto/gwMcg47D1wa8p1j4z22p6k0OmszW0Rkz5mDvGMDIPJ2r0+nBr4Z1jxxrAtkmllFw24AHPc9SO3+cVqQ64nipra20dm+0SZWQY+Zx6cdfQDvXOsDbVmzxl9Efcdr8XLTwHo41LVgb20tjF58kIBC24YKxcdWAypOPmFdt8W/i7f+AdZ8HftJfDa9i1nwXr00djqMcREsENyoz5cqZ3AsBtHOTjGc4FfG3wh8TaNpPxjh+GnxIto73RdfVITlvlQzDyzxjkBsZU4wPfgbPw+8E+I9B8M/G/8AZGeOGWTR9OufEVtE6t5hl0lEuPkJIZZI4QAo537cFSDwvqdNS97y9HF6X8uVlrFT5bQ+Xk1rb0aP6Df2b74XnxB0Gw0zVxq+j2drLr/h1bs+bcr4e197WXaJDtYmwv1aIHGY4SFbmv0/kh02U5ki69q/Ab9ljxQdd+I37N3j/wAJTxrFeaL4hs7nbnyjcaffxx3YXd0SZZVfYcgfe+bg1/Q3LpQDsAg2it+H6bhKrFrXT/25focnEU1NUZR21/T9DnI9M0oD7orf0/TtPzsVR+VTvo25chK2NO0UtKOo6V9JynzNzotL0mzLABR+Vd9a6Ja4A2jHpWTpekvHivQtOs5GAO3pV8qBMyf7IhT5REMVMunLFjEYGK7BdMmZc4qb+yZlAGzipsWcxHAw4MY9qmaAlfliUCunXTXK/cIqX+zZV/h6U0gZws+lSMARGK5660W7IJAx7V6tcafKByOn4VzF5ayRg5OKmSHE8b1Lw3P1b16Vwt/oLRsSq9PavX9TkmjzsJwK871S8uz91j74pRRMzlI9OuN4GCO3Suy0TT7gOuQcfSubSW7Zx855/OvQNFF44XnpWjIiep6DpcroNw6Y7V3sWkqYgpFcloRuyo3Z4xXfRG5VQw5FZm6MmXTMDGOnpXOS2GJAu3pXaTfaCfSs8W9z5nQVUUKTMGPTwE+ZRUT2kYH3OvpXaR28nAIBoa2Vv4cVdiTziWwDHCiof7NXHtXoh0rcc4qpJpAA5FZ8pZ59JpMZwuBisW70Ndvb+lekz6Ww6H6VgXVhLghs4qXEEeV3+iRn73AHSuUutAjlPBxXrVxpcgGQKx5NHY84IojAJM8oTw2oOFrfsvD8gRVxxXVDSHBx0rWt9NuEHGeOlb20MTipvDUnTFS23hwK2cfQV6A1hcDrmpItNuO4/CspGsUf/9f+lTejd8VGWTHX8KzTI3OPSmGVjz6UNCTLkjIe9Zs20Dg1KzYHFULhmbk1FhlOZ8deapG4I6/pRc4Iz6VnHOcGrsK5ejnLHA6VZ+YjioLcY4bmtLy94xU8ozMlX26VnyliPkG2ugaIkcdKga33cg5xUyQzi7kSoCQf0rnJxPzjt2xXpk1oG4IrBuLEPxUgzio4p8jGa3rO1uGOcVqQ2jBhmuns4RgEYpMaRQsrKXjIrpreyfGAKvWvlY5rfhMXGOKlFHPmycD7teBftK+Nbr4a/CDVfEdiuJ5I2t0bONm5HZj9dqnH19q+qv3G0Ia8a+N/wm0b40/DHVvhtqsv2T+0Yj9muh/y7XSqRDL7qpOHXoyFhSrc7pSVL4raGmH5I1YOp8N1f0Pwt0rxwq3lmZZiVtjv4Pfufz/wr7NsvEkPivw7G7zFYhImVz8oOO5PsAfQYr8Gbn4oeLvhh45f4S/E6wm0nxnYOYbvRZEY3fmIdhMUeA80LsP3MsalJVwyEgiv0C+F/wANP2z/AI7WUGmeF/Dk/gnw/IN0mt+J4pbCL0zDYMFvblh2QxwxHvKMAV+UUqGMq1ZQhSbb3X+fY/Z6GNwuH5atWooxjs/8rb/I9e+Ovx68E+BNL+xarcRxafAm5Yojgl0/iIHZeMZ4HXtX5waP+1B8bf2ifEX9k/st6HqHij+zziKfTLU3ghmTH8Sf6NE+04D3MkYGcrjqP2e+G/8AwTI/Zj8Jzx+IvipYyfE3X1PmNd+Jv31ksjEEmDTgfsqYI+VpRPKB1evu2Kxt7DTYtI0+KO3tIAFjt4UWKFFHACxoFQY9lr6GjwZKsk8ZUt/dj/n/AJHl5n4lwh+7y+lf+9LT7l2+5+h+BPhz9lb/AIKXfGRlHxd8TWPgPS5Qd32y9Oq6njj5WtLErAD25vMDuDX0v4Z/4Ja/s/Wdq0PxD1bxR4wnJ3GS41P+ylAxjaq6akD7OuA0zdec4Ffqk1mzsAFH5VE+nMeOK+gwnDOXYbWnRV+71f4nw2N4uzTFfHWaXaPu/kfzlf8ABTv/AIJ//sY/Cf8AZvufib4W8DW+m6xHqGnWUNzBc3ktxIJ5dpQeZcOGyv3iVPyjPGM1/KFq1n4nhjeBb5442WdzGJt8MMcL7TGSB8xU4Q44DEjsa/st/wCC1l/eab4O8AWF+yQaPFe317cyth5Xn8oW8MFtF1M8glcmTG2KBZMldwr+RP4jvaeJ73SfCnh1xajxTcxQwrjH2XR7ZtyN/wBtyHuGbqy7Aa1nCKquKWit6L+v0OSnOToqUnq/+GPmu/1LXLx0/tm5kd2RSgbHKnoeB/8AXxWjDelLowq/ysu7n1pt1FNrWvajHYxmaHSgxBxwFLYX9Bx9KZa6Ld6p4fXxDZxnbaq0kx9FU88e1U4r0EmzT1e6u9IfFyD5KMFkkxwPM+77Yz3rqPGemXHw38ReHvFNkzx6bdfLuB+VJUIJwR2OMj0xWvrEWmp4et7fVsnStbsmVJ8bvJntmwc+mOq9MjpxWjoOt2XxE/Zb1nQNVZftPh7UdPkgbHa4l8pvp1zkdjWC2Ta02fz0/Bm1tXHra6+Wv5HpHx9s7Hwh8SPBnxjtv3mk+KrPzpwcFRcWu2C62rjGNrRuAON2eOa9r/a41rUfhH+0t4G/aZ+GFzJHf+MNLt9RngT54pLy2jW1nU5O147hcKydFycHJBHzn8aPCHjXTvhD4J+E+rI8uq6PLq+o6SxPL2beS0sG3uwKK6YGNoI4qx8ZfGMHxN/Zp+DXiDSov+JlocutaFcyRNl4zHNbz2qHgBWaIuy9c1zQo8zpPdWlB+mtvyOmdXlVRbP3ZLyel/zP3j/Ys8LeD5vjVq3gPwywh0XT9V07xrolqcPCumeLbJoNludxYxpN5YxhQoIBGVFf0Hf2LcysSDX4cf8ABO7wt4f8U6h8Nvi/pqStNqOgR2zGKQCOO0lKsEeDgj7PdWTKjLwiuoxg5r+giEWpbc/Ujp6VOQpP20vNL7lqRn7/AIUfJ29On4afI5mz8PTORk11th4WXOWPNa9h9kVueK7CyNkRlele/ZHgIx7Pw+6fLzxXYadpLqB83StG3jtSA4Jro7JIF46UFJFe204IMk1opp47mtJIYyPk6CrKRoAD/KgoyF04LVkWAA6dBW/FCD2xVtLWIjkfSmBwl3p0bKecVw2paTE4+9x2Fe4TaZCV2kVzN9o0bLnpT5Sbnz5feHYCCOce3FcLd+FLR5sDPNfR17ogOcc+lcvPovzYOAKcYENnjtp4PtFIwCfwrvtK8K28e1Rnj2rpodJdGGNtdXYWM6rjqDVSSsKI/StDiVcKOOK6+PRQI+tWLC1nCjPFdTFa5XnisbI2RyDeH1k+7Vf/AIRzHPIrvTb4+70pphdehxTSsM4Y+H/K5BNRrozqeAea7VxKFCCs2WWVMhT0pMRzbaRIPuis2bSHHqK683s44GOKrTXEjD5gKFErmR51c6dOrHbxWFNZTv0zxXo0rMe1ZkqqqkAYo5SbnnMtoScMOlZUtoR716JPFGTt9KzZLOFuc9PanGImzhI7Nozgj9K04IDgAoBXQi1ROCKtpbQhtpGM1oSjBijA52/pUvkqzcLjFdJHbwcDB/Kr62cZwAuM1k4miZ//0P6OglIFGemKZ5uO1NMihs1q4mCkSMMj6VWliVhn/OKc0gPFRly3FTyF85QlteelMFoOoqy0hJ5FV2uSowKfKLmLMcAHGac21MetZU19In41Sk1E9D2pqmL2iRti4iXmnrcwr36dK5V7lwflqLz39afsbk+3R1E93DjP8qx5rqM/KP0rKeeVuegqlIX3dMVPsR+2OgSVSwxzWxAwPpXGQtLkZyK6C03AfNxij2Y1UOjjY8AVdil2jaazoHUqCePar6BM88VDgiuc1I5QB0qNi2CoqHfwCO9I0mDg0rWK5hsk9xHh4nZGRQqsvDKo7BhyB7A4rlL12klLucuepPJP1NdDN8y1zN1ESTxjmtYoyk7GXLIozng1Qe6tk71amtJD3rDmsJMnHFXymXMW2vYMcHFMa7tz3/Ks0WUhPtT001mdY+u4gcdeahxKjI/mI/4LGeJ7vxh8fp4vHBaTwn4JsY0SxhkAdo3AeQ4XcfN1KY/ZIVwpWGKeQEHbX88fjm6PhLxDqevapZQXOvpZMdWvoflgtZrhPlgiXoscKDyo1HJCFj7/ALf/ALaPiHW/iF+0F4pNnFZ3UtrrU1zbpnzbWCXP2b7XM3AeUQoltAoACoj7SQxY/i54huNGFxB8Opv+JjoOhzXeravf3ACnU7+ZsRRybcArny0wuQEQx4618vGfNOT/AKt/XQ+o5OWnFLseIfD3wvq+n+Dxr+oRtB/ac32ht+ATG7BI/lOPvDLDrx6V2/gvwnFoGv32g3h26XrKyW67hzG0iEqPfOQQPaui8TWXizW9Y06TUdsVvO0LQQuoR2VYxuaRP+WZbPC+46Vc8OQWnjbxJfeHdTR45rZ8RmNynkuFLB+Bgr2z2AP4KrNtN/0v+GKpQSsuxwvwQbTm8Gf8Iv41fCtqZ0meNxhY5dhaIjpndgrwQegr5p8V6P4r+CPinWfAN4zpDNOkUnGBNFA4licex+UjHTp7V7bqWiCH4Eah47imEeoR3aRzsfl82S1uMB07bsL79cV6d8V/Bv8Aw0L8DLX406M6jW/Dlqyaom/74hQuz4z1KKGA/DHet6dRQqXl8Ldn5Nbf16GU6blTSj8SV16Hpf7RnxD1W5+EPwf+Mfgy8X7fo93cw2rMmN+6GNghzjKnZscd844ry7xfY2/w/wD+Fk+AvB1rHfaJcWGk+LLG1JBk06cSRsksRxgRxJO8MmAN0DKCw25OLo+uaN44/Ys1Tw9fXJiu/CmpWGo20QKjebiQWcmOMkbJCfYj06ejWMV1ffGv4Y2mvJ5lp8RPBdvoV+0ZKvLFiSB2ULypJjQZHoeOeOanajDke0eb8Gpflc6J/vJKS3ly/K6cfzsf0if8EpPBx0rwLoE8M0d3p7afq9/pzx5jMceqTWdyyNGc4KPLIo54O7AxX7LC2m6rxX5V/wDBHrQdUs/2Z/D+p6lI10U0WCDzi+/dIbmcSKPTYYdvPOAOmK/X+F37rmujJsO/q7k93KX52/Q4c4rJ4my2UYr8EY9vFehwuOK73SorrAzUNtJuOFj6dK7rSo+h8r8q9VUmeXzou6ba3BVcEiuusbNmODmrGn7dv+rxXUWXlqR8uKXIzRNFa00tuh6VeTTXFb0EsQAFXjLF0U/pRYNDl1sWX5h0pFheMgeldESh4qo0eH4qkGhS8tyPSsa9tm2nHNbzJODntWXcrMRT1CxwV/DIudv6Vyz2chbbzkV315DcnOBmsIwXSv0+lOKIZh21jPvGc4rtdO06UqM1UgjuA+3b9K6G2eVRyMUSTCNjorGxkUAVtxxMmR0rIs5XPB4rVM7447VnyM0uhXVg22qb+aRgj8MVZDlutWYhu7dKfLYLmC5lHAWsudJW5x0r0OKyVx7U6XRopBllpXHY8oYPHUYZx1r0S40WJOo+lZUunQKPujHpVqxFjlVhD9aYbGJxhgK6B7OFeF4+lMMG3G3pT5QOcfRoH6CqzaAvYV1qpjgEDFNbgfeppAch/Y6pzinDS1yAfTiulCO4x1FSqhbtjFSxoxodIQY3Dirn9iq33RWwkTbcg1djg7CsWaxR/9H+icTBuvFNMq8CsQXRAo+0kEV2cpwcxt71H4UwSAc4rJFwegqX7RS5SuYulifu8VTkzgY4pvn56dqZ5haiwXK0yHqaiMYxzirDvx0qsxx05qkQxyxIeaFhQ1TeVugqNZ265q7EGj9lj7nGKjeGDOag87iq0l0CM0rDTNBfKToAKvRTIlcwblW6cVct52Y46VDRSZ1sU3GKvRN0xWLbP+layuCMVmaotAnIqNnbHXpTTOoODUTyK3zUDFZievfpVZ1DDrTHkHT0qnJckDINAEkkSkbazpYAOtD3uB16dqoSXWRWiM2SvEvIWvA/2mfibN8IfgvrPijSpIo9UlT7Hp3m9DczjAYKMFvLQNIQOy9hXtzXSQRPcXDrHHGpZnYhVVV6kk8AAdSeBX4s/tmfG+5+LHi1tC8IzLHo+iwsIbhxhHLnEsu0As5baPLT5V2rls9K4cwxCo0n3eiOzL8P7Wquy/qx+H/xrh0dbIeBtKuJZb7V7trm6ZSBOqbVXzJ9nyxKF7fwj+83FfJeq+EvAmhQjxUkIiu4pHGnWEPVU8vZAFQ5LyPu3bnHDEdME191fELUPDugxXVhp9sLG0kb5d+G+1yt1mnmxl2GPu/wjj2r49tLm2W7m13w/ZS6rqNxduJNSwSx2rjEWeFjwNoA5K/Mea+TjK2x9W4HivjbTLy68V6Zp98GJRHuNz/JufiMDqMoDtxj8q574JnUfDv7TV34b1mI29zewR28DMu4Os48tHHp8y7QR0r3nV/h54g1K6F5ALhfsmVEUhHmnjJC7Q2RjJB7Hr7Jq+kW2qfGDw149htgt9pFmLR/MfAlLkqqybuvlnO0NgYbpkCh1FyuPkxxpvmUuzR4Z+zt8KJfjR8NvF3wFmBsLv7dMsbPhiksUrAI/Y7HIfqMkYBqn+xrc3Xh7xF4m+GF3JCmpR6fqtpNE+CJJLSOSNgucfeUuMYzjoOK+hXk/wCFFft1tP5J/sXxssOtx7/l8pnUxzgMowdkgLbh/CQOec+ceOvh5pPgrxV8WtEsZ/L1rTtMuNas7yMfvbiO7j+0E8HA/e71I7beMA0Tq8/NDpLlkvLo/wBAhS5OWa3jeL9Ft+B8PeAPC95P+z/481gIiPp1noU4Eg5dJ73Yuz05PJ9P0+n/AAJpOtfEa7+EvxN00Nb3Wh+INI0KxRixSeG033xlXjZHI00bo6jkYBxiuP8AhRLeePP2Q/iL4dit5IZ/C9pBcCeFkHnwQ3JuBG+cHbERuUemdvPFevfskwagPh38PZrFvPW2+KunmaLhlhiWwZpHI4wAjE9skHBzWuNrSUKjW6k18uRE4LDxlOnHo4r/ANKt+H6H9a//AAT20nRPAv7OVh4t8RCDQ28VLHrP2JuZIvtameRSFznEszqpUAMqg45r7Vb44fC3T/lnlumx3WzlI/8AQa/JIeI9N8MwJ4f/AOEYvjb6av2QTx6nLF8lv+6UKFj2gALwM4FFj4u+FkOnrOt94m0S43H97JP9vi/KN0kAH+7U4fMK9KjGlTikkvX9SquWUKlWVWo9X8vJdOx+nWtftb/BvRGxDe27vnGy5ke1b8mjrnI/26dGhmVNG0rS7lTxn+2FU/kYhX5aeL/jH8SPCOgy658PdfXX9JjXMtxay/bDD7T284Z4/wAVwK+NdT+K6/HvTNUhaysrTxRptrLd201ootYbxYRl43jHyByvKsuM+lRLNcUl8Wnov8jSOT4TZR/P/M/o/T9vWbTsC98GPP0/489St349hJsrq9F/4KMfBiS4S18W6RrmhM3G6a1E0Y/4FCz/AMq/mK/ZL8YeM/jP4ki+HOhW97q0U643RAyx2rEZUtLjZEP99gK/SP4c/sfftJazY3Wq+KL3TdOsLIkNa/aF1S8YL629mXAyP9sH6VEc6xCvrt5L/gFyyTDNK2iP32+H/wC0N8EPicfK8EeJrK6nx/qGfyph/wAAfa36V7eq70Dx8jsR0r+cOH4Cfs+2usxrrXjTXtKuY15tLqyOn2vmDq0crLdOi+xxivtj4U+Pr34F6E1/p95r2taQ4Aiu/t8Os2Q99qLAy/Q7a9Cjneyqx+7/AC/4JwVsi/59S+/+v0P1jxJjaB9KgeOYivzRl/bM8Ya/P5Xw717SdVuSfk057IWt23qFWW5XcR6DNcRaf8FN7zwrrjeH/iloLWc8ZKuvkPE6465QuT+n6V1xzjDbO/3HHLJsRbSx+sB8/GGpGHy4PNfB3hf9vrwl4wt3u/DGgya1HEpd0029gM8cYGSzQXDQvgd9u7FdzpH7bnwK1JF/tRtS0vd3lsmuEH/A7UzKK6qeY4Se01+Ry1MtxcN6b+X/AAD6wZIv4hnFVXijycKPSuG8HfGH4N/EG4+y+C/E+nahcf8APuk6pOP+2T7X/wDHa9MltGi4kUr7Hiu2EoSV4O68jilGUXaSsZkcUQ9KvpbxsAMVRbKt8tXYHOe4qnElSNaGzT+EVdFkKpwyFOCat/aABkmoaLT0JEgA4xSDbH+FVjdEHg8VUZ3J+ajkDmOkjuAMc8VYe8Xb1rllMn0qT5yc81k6RamX57jPTisWZnc4q/5ZY46VILIN1pcth3OZn3LzWXLJIDxXby6Ynes46coOemKuMkS4nKLNOPvVPEXbnpXSCyh6EUp0+MYx2/KqYkjGiztyxq8gGP6VppYo1Xo7Adh0rNotGHGrfdNa0CP+ta8Ok7myorVj0ggggVztG0T/0v6AQpGcUbcgY6CpgEUc9PSguoHPGK7rnnqI1FP5VKEx7VH56ntTxOrcVNykkP8AK4x2FHlrmgsuKZ5qg0DsOljXg1ReNQPl9aseYmM0fIflNFxWMwqe4qIRN9a18ITz+lKqLT5ieQyPKK4pr2bsMAVv+WnXpTdo3YA6elPmDkOVFm44H4VZit2U5HNdD5SU0RoOe4pcwchRjZwKuid+KmAC8CmPtUbaXMVyjftLr0NPa8JA96pOynjoajHynJpaBqXfNcrzUL8igMCM0MQDzTEZswJIJqpfz2Wm2Umo6jIIYIhlmbt9Mck9gByTwKt6reWOl2j6jqD7Ioxk8ZPsFHcnsK+E/iz8R9T8bzvpViJIYbY7o4gxjVcdyw+83bjj6DmufFYuNGPmdGGwjqvyMH4+/FjU/FdhPpOlJNZ6PAVLybgm/jK+Yo7cEhMjGPXmvy18Z67pGjX8z3ILQXALpDCdtvLJuA6A5Uv15OOK+ofFOpatq00Uem33krF8rrBkBR3AxuJyRgkenGAK+dfi/wCDpfEVv/wkOuJEdRhEcQ8vLIE/h3YHpgDuBXymJqSqPnb1PqMPSjTXJFaHwt8V0XxFdTXeqj/QXwrpKBHGmznAzncfXOFzgAcVgwWkuuauLjTtMiGlooVXEv2fcU5bbgqG4Hccn6Yr6MtPCAn0h9J1SxMl1JtgE1wUmgXA3HCKy5wOOnGawtG+GsjX7aONLhlKFXWJmWKHb32c7egwMEYxXnSlY9GMb7HzX/Ytj8OvEtz4ilkkiswvmbYcSJ+73ZXI4GRhR93nr2qn8Xr7RrL4Pr4xthEl/K0MU7j95JLbSsELMFHOzA3KvIXJ9h9DN4fnuWEeiWUURSFo2t5trIuSAu1gQOdpGCM4x0zXUav8JdANmk2k6bDbLPgSxQ3fkbxgPkRkGMfTGQc4rnlUSaZ0xpNpo/LL9s3Q7iPR/hT+0Boky3Umlq2laiPulTMfMtnZQMbXQOvmDjfsGM8Vu/Gfxb4N8GeM/h9+1QkMi2fim0uNC8QROGKRlEXblemwxebnYT06cCvr39oL9nl9c+ANuZ9LWZIWeHl1Bii6xkEdTGyrxjOBkY4FcRp37PVz8c/2LPE3wrtLyOPVtNkjvdNM8Xm4mtsSqAwACCYKY2K8rkHDA4rSNem401PZXi/R/wCW/wAjOVCalNw3smvVf5rQ/PPwP4ci+B9h8X/gp4riFxax2mk3MEuQrT6PLdeVJcxsACyi1uVLYBXKketen/s7+F5PhraH4f61ETFofj3R4dUbcPMFrcubHzVZcYBjmilz15A4Feda94f8Q+P/ANgnTvixpEQu5fCzTaPqrM/+kDRLwxzpyPmCx3ChFGSqK5XG2vqJ9F8m4tdQvZTcReMfDSyzSwbY7i5a1t33smfl81BCu4feG0cY2mjGVVyPm6vVecUl+K1+40wdH3o8uySt6Sbf4Oy+R+pUfxiu7zU7zSLrwzBeyWtzLCWhkntyTGxXdlSw5xnkCulm8K3Gu6V/aGlRnQ76dwj2kjm+TYw4cFFVx/ulaual+0f4k04y6d4fnTRzA4BNzbxJDIOhIUfMFP8AfOax9E8RapqWqnxJqHjXSGVjn7Da28c0zLjAbbdNFGRxjjJPtW8ZLlTSsZNO9mc34K/ZZ03w340j8ba145ure7UH5NO0Znb5uNj7piWU9Cu2vTbD9k39n/wD4sX4jabc6tYsTIFuLvwnfy2ETFDuLYkaONNp+8yhB09qr/EfxVN4N+H8PxY0i60Lxlo1lKIr6w1PQILSay3HB2yWjtHgdM5BHv0rjfCfxe+EXgH4p6J4x8Lw3sPh7xFbFb7TrO4Yy28MoMcsbby0dxFk5RXVX4wG4Fc1Rrc6Kd9ke1Q+L9V+FWteGpY9C8M674avrhY9PuNMBEXmqQNpjURqkq8HDJnHQ11fxs8IeIvhbr0/xo/Zo1aCHRbu4Z/Ms5QHhlBy0BXIUhTuPzk59DXE+HvhFrfw6+OF54G8LAa74Y1HTm1XQb9oy1u4nHlxlWwfLZGbbIMbhjHQg18e/CT4sar+zT8X7r4TfESOPVvDV44tr23kXCNF0DqMnYy9Qc5xweDXNvzPdLp/kdG3Ktn+XkfdXhr4v/DP9rTS5vB3xFktdH8ZONsF/EoSOeUcDzCnQ56D7voK+JPE2sftAfsoePZj5kum7H2rPCzPHMB3Yj5Sp/2uO1df+0X8H9I+CPxSfxrpFlNq2iXaw39neveNFHJFONyMog2jjG0jjB4xXaXninwZ+1V8NbjRtNYWvirTIfMSK42Sx3MMQyyLMYmmV1H3Vbg9NwoWmj+B7Deuq0kjT8a+Iov2lfg//wAJ18NtHGn+NbBx/aMdk6Qw3cBX/WKrKSGBGW2/hXzJ8NP2tvEMGrx/DD9oAT6ppySrEyXjJLPa+8ZcMBj/ACRXzd4S8beI/hD8RY7uE/Zrm1fBUkr8h4K444I4Ir7F+N3gPw58TvCek/GbwGGdLlDb3li8vmtb3ECgnywx3iNl5XOVGMZHSjb93L5B/wBPI/NHX/EHS/EPws+IWla54F1SaysdTX7do94vzwvGh+pII4DbXO3uMVr+LPiJ4O8V+Iri4uLm40aS5fzPPtQtzB5jgFz5PyOE35/1UmfRe1eR/An4h2GqWz/Aj4sJPceHb+dXt5VfdLpd391biFW6cHbJGfkdeuOteW/GTwJ4s+EPjDUPDGok3cFpMyLPGjLG6fwuBztDLgjlgOmTUU5O77mkktNPdPofX7/4ueCbC31yS9Gt6NOxWzvoJBeWjlOq/vVLRyAdY3VHHoQM19E/A/8A4KEfE/wpcxaFLrktggOAk4NzZf8AA4ZCzRj3hZQP7tfBXwo+J/8AZNxLo+uZu9N1BRFe2rHAljHoeMSJ96JxyjAY4yKq/FTwRN4X8VNYWl6moW1xBHeadeL8huLSflGIwAHXBSRegdTgYxThipJ+67SXbQKmGi0uZXj5n9F3w6/4KQ+Gnu10f4xaX/Z5yFN/p/76DnozRZLBT2KFhj0r9G/C/izw1400WDxH4RvoNS0+4AMU9s4kRh+HQ+x5Ffx3fDpdc8S6dPoerX1rp11p0StaSXxMcEsO4B43kVWIwSCjbSB0OBg16x4M+Nv7Qn7Omq/8JF4euLrTrWYhnkgK3NjPj+8ULRn8drV7uCz6pH3a2q/E8DG5BCXvUPd/L/gH9bv2hlG3/Ipv2gjkjjpX5Ffs/f8ABU34d+L5IPDfxujXw7qEmEXUApFjIf8AazzCfrlfev1c03UrDV7SLUNLmjubadQ8csTB0ZT3VhwR9K+nw2Lo11ek/l2PmMThatB8tSNvyNyKVjytasUfALCsqJhGB6D0rQiuUAA9K1k30MopGrHCPu1ZAtVOSBWS12oHB4qublOg71nZsq6R0O63UjpioDdRrwnQVgGYHj1qMzDp6VXsxe0NqW6B59KpNIrkmsiS4Gc/lUH21BjdxVKmL2iN0bR+VTlE7VgR38XTPFPa+Vud1HKHMjfVu1XbclX57VzYulxjP/1qupdbcYORUuJSkj0C2lVMFq1BdoMMtecR6ky81OupTDoOlYcjNeZH/9P97DfEdaiN5n7p6VnSRHHFVniYH0r0eU8y7NU3nOeKkF1IOBgVhqkn5VOAyjrRyoVzW+2vjGaX7UelZSjnmnL6Y4osh3ZrJdg8LxVhLgDAFY6tjryKnjbGMGlyjUjXWfHQUqz5PWqCsKlXaMCp5Srlwzt3pn2naKqsxb2qq0fHJoUUHMaS3YFL9qySnpWdsAqVUHenyoXMaK3WOnantOh61RVV61MAuKnlQ0xTNH2HSnrJGRxVYKqjI4qnIdp+SiwNm6NnFRTCKNDLIQqgZJ9AKzUuSg+Y88CvHfiD40aWSTw/p5G6NVlYk7QxBH6Dp9enthXrKlHmZtQpOpLlRwPxJ8Z65ezzvo8gkis3Ktbr1Cjjgj+I4+b2+UY618l6tdQanJI95/q5gokfGzZxwi7T8voSOnQEdvWdY8UaFFPLHdb7OZsFS42bs9OB19/rXnOueGdJnk+13kaSLM4YyW7AEHHHyj8ulfNVqjk+Y+io01BcqR52/gS11CWTVorprWQKcvbN82Og6/Lxj5QK8a8S/DzTJ4Y3ju5Fcn7jjerHg5IXg54Htg4r6ittB1LR7RbG2vmljnYjyyqFgv8AF1GcAH04x64rmb/wzK7prOiyS741KiN1G0u3TgEbRj24rjnHyO2Ej5KuvBfhuyt54biFG8sfeh3fNz3DBgPl6e/auXv/AAz4Pn0yRILNLVJ1ZULDfktuxggcY5OPQ19W2ujeJkuC+r6bLdIx2jaq7Cp6DnkcdOOtVbrwmkllLI1vPpcO7+CMSZcY6DHt0rjqQbWh2U52ep8rWXgTVr3QDDp0NnqCh9jiIFGHGARuGAcDBH+Rmaj8KPEzRmac2YVk3tGqCSWL5Bkb8joSSD0I4Ir7Ts/BGheUNSa2vLl2xIsy/KMEAnjA9vy4rzXXLaO2vfKWznuDktmZwI0Bx2cY7Y71wTjY9CnJM8nTwFpD6FfaZ/aV3K19blVaFY5grjPWP5xjgH36dq+RvhBNq/ww1u48NXbxfZ543WaSImBW2Ftp8tuhXt1/kK++vDHiLWLSL7FeaPDDEJMefbADIxuYFhtIIA6Y/SvC/iN4AOo6+usfZJLyORzII2k+XaP4lDYHI98H1rl7xZ1W2kj87/FHwz0j4P8Axj1X4V394n/CD/GK3vfsV9IgVbPVJkzJBOv3XR3G4YCh0dvlBQ1zms/CjW/Avwt+H+lLIU1XwbrUkZhK72mswku+EMMnKxghW/iCbT1GP0Q+K/hCe5+DKXV3oVvbXWlSibAYyJIh+VSqgfKyEDI+6AevFfPOkXMmv6fINZXcYpnuYCvOx0BXI3DjcrH5Txjiuatip6NfP7rfkddHDQV0/l5Le337fcPjuPAHi/xJf6fr10lrKZzGJRK6wqzH5N0sZLQduseztWD4s+HFvZ3d9H4U1O/h1bRV33GnOyTziIj/AFsTKp8+PHJAwQvTPSvkDxKNW8GePF8ZRTCS1uyyPETlQ0R2SxNxzkY4PbGOnHuWmeO5bfxl4a8UR3Mkf9halHpySNk+ZYThZItxz1jUlPcCvei7U4tbWPBlbnlG3U9A+DP7Qur2WrX3wv8AFMkb3N5E0cZlVWtbpHX5RIBhZEceoyDjBrc/4QzwR8TbVLD4ewJpPi3RY/LXT0dRb3qRf88e5k4zjOG6A18zftTeG08E+NdE+Ifh1Ps6f2hNasV4DNFIZY5VxwA6MCccA9hXb/Frx1DpXxS8P6/4ck+x3dzawXZKkKFmOCGAAGM/kaiUesS4S6S9D6N8cftNanD+yla+Dr7UJV1TTPEUC2Cozh1VYZHmBUfLtjYJjdwrkAfMRjpJPh5d/tR+GvCfxvllt7aZfOg1yZ5VR3kgAYFQfvSyAYC9B17V7r+0l8IfCP7Qfwx8/wCHMH2XxHNLY6w1mvlqssuo2yySbQzA5CqzHg5HQDpXwj8N/ipr3hL4k+H/AINhFsdD0SVtwD73nuZ8CW5kOB8/yhY0VcRIMDO4mudWcE4fP0OhtqbUvKx9Q6X4uuf2gfDutfB69iS21XSwf7KtPNBh8iAf6ls5ywT5lYL8zdq/Orwf8RNa+GvjcfZk+yXNnLteGVQpUqeVZSAR7jivWPHWu6z4S/aOuPFlmX03yLxRNOZVk5jO1WBCoBlcYAXin/tNeHLLw58UpviBf3f9sjxJHHqsEkcX2eJUkAT/AFSsWJBQ7mJ5bsOgv2e9NbdBKb0n1Kf7X1mza/4V+JXhZJm0zxfpa3ODmVILyJ9k0ay5I2vkPGj4kHz8FQMfV37Puh+HvE/wtg+CvxUt7jTbnUZv7QtLmaPyngl2bIgu/nBHXgDng1Z/ZR+JN78V/APib4My3Ut1d3tjPd6MqTyQyxalbIWi8vBKg4BXaVCkfLkV8K2fxf8AEGjeJRqqXkpkYh9zsSTnB5Y55/M1ioucfOJteMJa7M9c8Rt4k+Enju50PxjZGSaxkAiklUSE4xj5up4x3r37x98QtO+N/hq48bWsv2PWYEjGo2qR/ubiNVCCdAM+W6gDzF+6w+YYOQen+Ll3p/7Rf7OOm/GNoUOtaBMmlanIrcsJF3W05TgZ4MTsoyQFLdOPhz4f+Kz4Q8W295NtAicblUbldOjgqeoIyMdKzcnpUj/XkbKK/hy+X6Fa6uZbO4yrbwP4TwD2+g/IV7RdeFbH41eALKSDUpdH1HwfBcHYF80XFncSK7nORzC3Kr6M2K8k+KWhWPhbxrqPh2zm/wCPaQNGjZVjbTLvhbHBw0ZGD0446V6r+yx4lt7L4p6ZoWvJFPpupyiwuo5x8jQ3P7phkYOMN1GCpwe1TXtFqa/pFUbyXIyp4bTV/CelPDa3/wDbGV8tekTY7/K2QT0xzXonhr4pSaQzpo8rWm8bLiJujD+7JGflI7EEV4Jrtnq3gvxNd6PKDItlcTWxYHeriFymf/HaW8vLK6i+3+WDKn3Wydw+jDBx7VpOn0iZwqW+I+yP7O0bxLB/aOlrBaxOv760RQ0HPG+MHkA91z8p6HBFe4/BT9pH4rfsh3Im8Nyf294QeT/S9GkkJSEHq0DEfum/AKehX+KvzU8D/FvWfBd44u83VtcRNG0cmGXn8Bwe4r3m+8bstlD4g0GQy2c6fu93LIcfNG3GG29P9pccVFCrVpTTg7NbFV6VKtTcZrQ/qf8AgF+0f8L/ANpLwkPFXw0vvNMWFurKTCXVq5/hkTt7MPlYdDXvCTOODX8Zfgf4q+L/AIZeO7b4k/BW9/sfXbblrSP/AFF0nG5FQ4BB7wtw38O1sV/Tf+xl+2P4B/a58DHUtLK2XiPTVVdV0sn54m6eYmeWiYg4OMqflYAgivt8szqNe1KrpP8AB/8AB8vu8vhszyaWH/eUtYfkfaUJkPOakeKXOV5/So0lt4ztz0FI94gP0/CvX9p2PJVPQi+zS44PFPEbjhqRr3ANZ0l+P8KtTZLgkaywg9/bFIbMOOKxhqig4q7DqUb4LHpV3ZK5RJbEgZU81VNtOuMDNbiTxOM57cVKURhtHOaz9pYtUkYKC4QkDp0q9HPLwxHStPyEPHWo/sq5yKPaJh7OxDHfvnpV+G83cGoPsfOR2pwt2bjFQ5RLUZH/1P3WkuFGAartOgPtWO87ZwKaHZhx254r0rHk3NdpRjimG6TpkVnYc80xoixpjNIXag4FP+0xkfSsny5NvHanbWXk9KLAaqXYVttSC7Qen/6qxCGGCaFBDD/OKLCudMk69jzUwuFUc1zyM/Wpk3MTipsWbBuOPlqDzn6DtVZY2HFPX5ePWkInWZiKl84k1SZj91e1Tr0wKBouC6FWFn5yKyHbjIpVmAGT9KTRSNsTg8Gh5IyNv8qxvtIWs/UdWj06xlvZPm8scKO57CpdkrscdXZGZ4v8Uafp3l6Gkuy7u0OOcFEHf8eg/wD1V8u3N2gU2ur5FwCRHjjO0YX2AUEYHb69LfiC/wBT8RXTeINNkE8uCShOFPTjtjoAB2WqSeJLfVrIwaknkzJniRcYbjAHuQfy/Gvm8TiPayu9uh9Dh6Hs4pI4yfStbn8u61+3ivY5BsBwN4yc4wP4fp2FZ48JWUk51DRndX8wAxHkAAdF9PT2z9K9Vt9XvGRDOqKkOP3iMONoxj+X4gVfv98k0Y06WIMAiMBgkbvvY+nauOUUzqjJo8UW3l1NWXxBCd0K4MgjIKlhjAx1wBx2qvJoZ1SQjT4rpIVDfM/IOeTg+vGK9A1vSPE814GBgitoud0RYNz7cjnnpjArLvLGxCRRX2pXA2DKJt+U7j04+n8qyZtGxSs/AV3/AGZLL9uZScbEB5+XAG446E9vpXP6jJoenXFrb6bNJfSQSBpVJPIA6n07Dp2r0kWXhBoHzNPJF/AGYxgsPm6DHH6YFZVrbR6HP52mC0ZfLyhIPmnnPLDt/DnFS4lRlY4i0v8AxfqehR/YbRY5JF2NukJ8vYecccEDkVk678N5rWL7Tq4gvJ2UukZmYA47YIPUYPHYEV6G2s69M0lraXqxmQcAKCN7DbgfN/kVWfSNZv0eTVdReDG7cgxtPTOBjtxwOa4qsE9DupTa8jyk+CtMvtLNxrsH9nLH9y4lly2BxlArA8DGN2D0ry/XbTQNTBsLOwutRmQgJICI1kXuBuwQB0woPfvX05NpOg6dCuswSF4Yxlnch84wOAT6degwQcccY+p6tp2maW9/pkaW9okRxdMixlF/2FA3Yx+YPHYV5dWlY9WlVTPijXfBuo6JotzBqUX+gXD5gsXkIkUAZGTz/EOBj5eOlfF3xBtI/A4vr20tY5YX8tHydjguMsqA/LuXOcjoD06iv0U1HQLz4lXqatpN4sguSUleZDG0agHcPm+g2kZz17V8reNdM0fVrSeSzh+z2OnLJAobH76V2wTubg46bu+4HgGuFUbvXY7nWtHQ/NnxpPpGn6As2pRKbGXUPInK4O2OeMc9GAAI3fhU+meG9CuvDV74X8SjyI7aZPOMTsZ4ZoBiFygBGxlYbcY4IpnjS0eL4W6xFGjulrMiyBU37xF+7bOATkDjJwBSaXp9zYXmj+Lbxmks7y3Onam8fVok4ilB7MF49iPSvch7sUjw5e9JsoePrjxF4t8PW/wb8TvDPfxyDUtIv4yQl2vlldjgqBv2cK3ByArZFUvjHpmq+LT8M7PRoHl8RarYw2Kx7RuZ2kEdupK9vmJYkDaoJPyjjvvFNq/hvQtJn1Flku/D+tRra3QQgyWsxDA5HT3Hr0xXtd9458bedY6z8HZNIXxFpsMvmHMcmqxWrzM0aQeZmOPKEiRQPM2MFyOhTm7pRQ4xVtT1/wCBPxP0DQ/jrq2laxcO2j3DWunxXkBDFDp6LBHcxdVZdysRniSM+jV4n+3B8Grv4e/FPTvi94XtrZdF1e4ktnfT2zarf2p/ehMneqygeag/u5APFeh+FvE3wa/aNsTovxVsY/AviiNmT+29IhWGPzQetzbKNhBP32i2n0xXjPxD1z46/st67dfCD4sWcOseH9VQXCJKv2rTNVtEIKXEJ4+6SDuQrJC3XtmIwSb5PuNJT0XN954P+2Gttb/Fyw8S2syM+saVZ30ny7R5h3IQRyNwCDJXjp3r3XW9GvvjB+xw3ii5UXV58P5kf59m4aZdMBL82N37qQiTrjZnuK8d/a80Dw78QPBmgftBfCWORvDmiWiabrdvLL5lzo7mTMMkhODJbPu2eeFwjACQDlh6L+z54gv9e+C3jXwBpJT/AImGjzkDd5aSG3Xf5UmARtdcrlvlGRng05p8tOXy/QcGr1I/15Hn37H/AIo1jwR8ddBmtnaBre9hcnORhXGVGRjpwP5V5v8AtNPa+Df2j/GWgWxijit9d1FYxbsXiCNcO4UDoNqsBgYAIwBjFcD8KvEc8nj20uYGMLeckkJbgDaQRn0/p9Kt/tlpqKftb/EI6wS122tFpm2BG3NBCwz6/KVxu5xgglSDTpwXtpryQVJ/uoH6OfsfalJ4k+EPxD8ERFWjuNOg1FPmztm0+Tf90YBDKSDkjHv0r4i1PXbK51APDt2sQQ68gjr0/wDrV037PniPxL4C+Dvjn4leHJJUm0rT7ezZ4ly0S6pOLZG74XOQ2cqvp0I+R4fFHm6izSH5XP3u34isadP3ZW7/AKI3nUs4+n+Z+pHxi1rU/FnwI8B6xrMjyx2Fnc6XayOquqCCRWEYbG8YUjCbsY5UDmvnv4U6xq0HiywOmhWuluYjCrfMrSBhtGBjPPHGD2Br0/WNdku/2OdNMjIfI8T7QrDORNYyEgdRs/dj0IbjpxXkHwS02wvfGOnSSyGCKCVZ2ZsuFSA7y3qdoXkda42r0LeqOqMrVvu/I7X4ueO9Jm+MPiV9IVk0x9SuJIoJCGaLLfOucDIEu4LwpC4VvmBqrp8761p8n9l4aaJGkUAYdwBkoffAyvvx3ryr4weILXxj4qv/AIh2wKSX1xLdXkYwDE8zk71x/C2eR/CeuQasfCPxFcR+LbSTPmK0yLs6EjIG3HHbsK1q3iuZdDOk1L3WUL7xDE2CknyvzxxkV738DLlPH41D4TvcfZbzVIv9AmJxEl4nMLMB2J+Rx3B618OePZ5/CvxB1vw4NyQW2o3cMcT/APLJUmYLHk8/IuFBPOAM8133wl8V3+heLtN8UWj7ZbO6jOD/ALJz079K0xNK0eaPyMsNVTlys9Ej8T3bXlxYXSm1v7GV45oCfmSWMlWH4FSOOhFe3/Dz44eMPg1450r9oP4Y3b2mq6dOE1GJT8k8cny7mXur42SL0PytwRmvCP2psr8Tdb8faEAEW+k+2qnYSkMso9ucP+B7Vy3wo8VGS9bT78CWGYGKRezI/H8qGvdVRCum3Skf1GeCf+CxfwVtdb0rwz8cV/4R2XW4BPp94Dm2uFGFcD0eNvldeo47EV+ovgn4p+B/iVpEWu+B9Vt9StZQGVoXDcHp0r+EbxV4H8IfGDwfffAP4kXEls2nXYvdKvUTzJIZUUhhs/jWaI8p6gYGcVwHwcsv23/2SLVfin+yF40i8beFbZwXt7G4+0wFU6o8LHMZHQhSuD27V9RluaTlD95K7XfT0s9vvPlsyy2MJ/u42Xl/l5H+hrHMJDgmoXQt3r8R/wDgnv8A8FhvhR+1Ylv8NviVnwj4/hjAm029+QSkcFoWIG9c+wI7gV+1cN4kirKpBBGRjpX0VKtCa90+fnScdx7wOpzmocSrxV2SdGT61W6t6npxWymZuBahuJoyK0I9UmQ+1ZqBcZqyiIcZ5pNoaTRrprZHXIq1DrKlhWalojjGKP7LwcpkGs2oGi5zrINRiJzV2K8hPA6V5/LbzwjCMeKQT3SfKSTWboroWqrW6P/V/bR07Uq/Lz0q0wXjBpREG6V6PMeZyEYcjvS+cKsfZdy81UlhK0rofKxTKM00yrVRww684quSw4YVRJol0HX8KRHRazNzbQpGP5UKX9OlNiRurLH7VIJ0/grBDyZwBxT0aQ/yqbDNwXQB60/7Yh7VhAtninHcOOtIDfE6ZwKJJlByKxEMg+arg3HikUTvMM5FU5J9vPpTynGRSGAOCPSmBWFw+cjpXkfxW8T32m2ATT0LmLAZB1JcfpgfzNena9eQaFo9zq8uCtuhYA926KPxOBXyDq3jGa68SS216rSJcASof4H/AIQpPoSRx6V5eZV0oqmup6OX0Ly53siG08OaoYm1LTb3bJPjdGpwCT/CPQdAMdqhW9XWr2fRtbRXaM/NIhwMegPXkgj6LmqF3PeaKjX2k5uLeNQiDP3Qx659+gxXMN44trtoGa3WASEEsPkYsAOp+mcfpXgNWPbTOmbw3ZJcSy2F6yw8n9/x069fU9q6LTNP0vSnW903UUjf5QQ3zKOPWg69o99py6fqCLMvzs3zDOeucV59qF54GtctaSSxB2DKkYLAduQPw/KoaS2Li29Ge0r4yts+THKbl4wGJgBAJ6Y/z9K5S71y2bV0nS3utwuNpTgqqlgwPze3p3rjIdetrTba6TcMV3YRim3coBI/x/KvT7bVNQvI47mACfdhB0QgD/OOlF2yrJFFPFWpapbyGNQ32f8AgZdg3dgRj24p93LpGqwRJJEqsB5edpTDMfbsDgdvXpXHa3cPEq3FxbGGO4A37JMHMh2g8eo4x0BrJs/C2n6hbvdDUXt2Z8uGfd83BP5dD6fhWbuWkjv7K48HeG7h5NQi/etgkAhhtG0jaBx17n1H4cxqPifw7rjPAYJ7vD5CRbkTHv0/DPTArasdD8N6Pbm+817uXkoUTcipjDAkD/OPpWQ+saVpURjllRlkBVljHO5unHb+H9OBzWE9EdMLXOS1aa9vGjsvCEaQs+ADcbZGQg+g4GfckewFaun+ALyfzZ/H8/7hUyGZxFbqw5G3r0/ToPdNS8bX2jWLXPh/SmuJ3QITL+6XpwM7SzdMcdhnvXOW194m19h4l8fQxpDCm2NOUiix/DtOTz1H88dOGrFHdSkcV401nXtI1aw0rwJGllaXcjrtlVZN0bdxzjPp0HTp0r44+MdnLpWi2Oh6HLItkLiOPyTgpKVyZWAGWUBsfICArAj2r7ys4r6FJ/E91YLECPLhD/M+ScgvjjHpjgDnivkG40qx8c/EWPzbd7nSbaCZl29ZCo5cY4OT0GM9/SuaNLW50Sq6WPgGbw3b6nH4w8PXReOGWTaSm4q3mEEj5Pm25PQj1zXmE39q+F9Et9PlkKw6dKlvMkpwdpHyvg/wke9et65o+t6R4LHiiPfC82rsWg2jDxLJgYJCsMY6D8jW3feFmuPGWmmaFZLXWYGsblP7sicIWBUrjBGCfSuvZWZxrV6HJXNlL47+GupeHbCHGr2UPnW5H3JkXlQDng4HGM+nNY/7PXjbw38WZ7D4ceN1+yanbNt0zU8FZbSUZ2o4G0vEx6g9K6X4W/2n4Uv9U+H2rL5WveELlym/70tqcNjjjphl9OnHSvOfjF4Ej+Efxf0r4h+Frd4dO8SDz1j+6IbxSDLH+J+YD9Kz6OPVGltU+h7rd+B/CzeK5tbsGkstU0e7FhrFom3yo5uNjdQdjcYIweRkjqPrfwvr/hPxHa3v7Mfxht49R0DUz5+kGZVX7Jc4ziIr80Qzx+72le2K+U/jprOn6F8YvCPjed2S0+IOhmxv/mAjMtvwp4wQ43dx0HtXfX+o3/xe+CEOvaDKseq+DGIeRGaSdxDwqjaMDjngFm6AColfS3yNY2tZnlfib4Wv+zN8Y7PWPBtzPFoupod1reItzGqP8stq4fBliYcEPklDyQQK8z8W/Ca2/Z80X4t+JfAh+yeGV8N/2l4dV42H2a6v3SKG1jJbJ8uXciSJjERUAfKTX2F8dtXsPjZ+zRpPxDso5P7Ts5IxdPGF3Fo/4jnlQ3csfxFc38Lvh/bfti/s865+zTrUyxa0qrf+H7yYAfZr6A71Q4+9DMV2uuQMHII60vaWcZPa6v8AJlxjo4rdJ2+4/Iz9l/TbvxJ8XNNtiVWFrlC0shEaom4FmJJCjaMnBIB9QOatftH63YfGP9pDxl8RtMKWtlqWqyiBFU4ljtgtsjjJOA6wh8gbeRtBHJ91bwt4r/Ys8EyeIfGVs/h3x9rIks9J06+izc21vjZc3SlcorIP3UT7trFtybk+98M+H9RGsarHZWCIkK7AkUa42IOAu3+6AO3Sto6uVVen3Gb0UaTP0Y+Hfhc6b+yD8QvEVop+zizt7MyfIJY7m7lVInVWX51RwPMUP9w8givzh0/RLq9vpH0gq+7koGwQO4H0r7R/aV+J1j4L+Fvhb9n7RWLX2lmTW9e8yIKRe3sYjggQ5JdYbblzwvmSYGSCF+QvAtwNS1yK7tATIWGEQbt7HgAe56D3wKigpRoc8uuv9fIqs4utyR6WR9eeKro6N8DfCGmyzzoFuL/UHtwFUhxst0fnGVKhwNrEZ3fLnFbXw58R+HL/AMH6leaJCouTH5N8SF3mCQhS67VG0Zwr8ZAI5xmuN/a+1FNM8baf4Usbgy2+h6Hp+ivubIW6sYz5+PT53K9iSmCMg1wn7M9hNqviq90SDaF1DTLyFwQSMiIuGVeOQU+XHPYdcGYwSpRk0U5t1ZRXp9ysZXilzpl4/wBkx8oIHGMr02kdxiofhFJDq3xF0rT4chZb60RAvVGaZFH5E8flWD4kvJblSXZQx52ryD06HuP/ANVdT8C1tbDxJceN9TYxWmh20t/OwBP+oXKBdvzby+wKByfTPFViV7jROGfvo5/9om5s9W+L3ijU7CPymbV9SRlz8rGK6lQsM/wtjcO4zjJGK5n4f3c7X8FrBy8ssUY/3i2Of0FZGttdXumjUbuTzbqEb5GP8ZP32446/Nxwa634Z32n+G9SuPH2pJug0YRSCM/8tLmRtsC/TeNx9FWrqr93yr0M6T/ecx7X4+1SH/hYuuRp++tZrmW2lUj5W2YQ8dvu/pXhHh+yufDPihtHRmKhgYGPdG+7+I6fhVDTPEs+pXDG8k3yszOzHqxJ3FvzP4V6hLpUmr2VrqtqrNNDKoYoM/u24zx2U49gKzn7i5TSHvvmPb/F3w/1a88X+HtZhYWc2pWQMUxO1JJLZyhIPTIO1T6HFYXxF8Ban4X+Jb+KvAV1P4G8aXSK8t3bjy7S7mI2tFdR/wCrkyecOM85XB5r374w6vofgvUfD/wy8RRs8drpkd5e7B5lxpl7fuZBsHBIWMIZocfMGVl+YYb0jx3rGjWvw+8M+IfiPZrf6RqJl0wapppWWaOWJRLGwQ/Lc20kJ3beHjKsq8/KJwdSUeVrqv60/Q0xlOEuZdmfll44/ak0bQvES+Ff2uvhmbbW7Qi4t9Z0KY2l1uXpLAWKEccgpNx6V/Rt+wd/wWW/ZP1rwdZ/DX4jeOXjv7XZFb3Gsr9lmlUjChtwVGf1KcHtX5t+OPhZ4F+JXw9i0XxxDb+LPB0vy2mo2TfvbWT0ikb5oXXoYZcc8A1+MH7UH7BPxC+BdtJ408BzN4q8Gvz9ut0/e2/+xcwgZUj1Ax6gV9NgcVS5l9mX4P8ArsfL47CVVG696P4r7vzP9JTwf8S/BXjvTotS8Iata6hBIMoYZFbI9sV1zXBjIzx6V/lXfCL9pv48/Am8S7+EfizU9B8vdiO1nPkZJz/qW3Rdf9iv2a+A/wDwcRftXfDsQ6Z8U9PsfFVmhVS65tp9vfg70J/FBX0MavdHgOD6H92/2uTPynircN+6nk8elfzsfAT/AIOHf2SPiRe2ulfEy3vPB9xO3lmW7TNup9TKheMD3LCv3E8DfFb4f/FDRoPEHgDWLbU7S4XcjwSK2QfTH9K1UoS0MtUe+22rRIME/hWourQnoa8jaeVKEvJh7UOjEarM9eN7DLyTnNMLQsBXlQ1GcNxwB6VZj1icNtJxS9lbYr2x/9b9rPtQBzmrCXqKMVxTXLH71AumwMV6XIeUpne/2igHFV3v1auN82VsAHFKPMqeRFc7OoNwrE7aF2tzj6Vz6M4OfTpV1LjYaNho3Y4kfAq19jjxn8qxIb0YGTWh/aCrjvmp1KVi6tsh56cU8W8a+grO/tKPaTnio21NWHBpcrHdGiY16CoAibuuKzjqHGAaqvf7enenysTkjexEPu9PpTt+0c1gLeNnrirH2gtyafKK5rGYGoxc4P8AhWYZGpyyf3qVho8l+NviOHTtLsNKkJ8u8mYy7OyKhVT+DsD9RXyPPqQ1Cxa0vJTG9sxjh55ySecewAr1D4p+KbfVviPN4ellxF5Btoj0VZbdg7fiXOMf7NfM/i6GYXdneXa+VPbsglbPy7mHp69PpXy+Nq81WT6LT7j6LB0+Wkl1O/g8Ralpth9jMjOgPGBuPsCf8/SvNpfGvhjXbldP1C3lQxkudi7AMHAz7gAfn7VvaT4u02/to1baw3YO08jaB+ec9vSq2vwQWK/2vbgMwxlSOWDZP9a42/PQ6kvI6C3tbDSEk+x3h2MGZA4BwMYA9cY6fSrl/LKlzHfQsuV3opXGPkx/Ir2/rXztqPi/Rbi9T5DKoHzIR0kOAo4+vp2r0LS9V8N+JtLjSBJDtUybQxUjdtx6Y9x+FRfojSx6De6xdavZn7Hauk0A3g7MfInYHI5O2jw/dSX8TQxIsWzY6vypZecfy4+tcynjS00e2exu1nEUCCcEuOSAQR1/u54/CvPLHx5rFhqrXGkWRvIlwEWTOQrMWQnHHR1GO1JvS41roj2q+tb3VoXjd3WDhdg+ZmwEJ6DgB8j8M96pwalrMVq2j2cLRyQnfnZtZ2j4bOeeQeawNN8aeLNY8kafp+HCESh8qM46r+GPxFWn0rxTqSm+1q+Wzk37CE+b14/AHFYyl2NoLudhZJqmp6WdU1K/lsEB27Gl2s25eMfXB7+1bukaZD4bRb3wyiXt7OVVjdISdmf4eeo5xn0x2ryK0vfDuizvDdW19c3fJViAUAPcY55GMjHHFbZn8Z+KPKitrk6dbgkSKmBI3TOH6ruGD6dDWDZ0xX3Ho/iG5tNISDVfFty9zJMQIbaBeWZeVIXnbyCOQB2OK5D7c7Xt58QPGU/2e3gGYbVyTGoA+VETnn+6Rlh3qxp0nhWyuIotBjbVpycO5fKMe688rkcjjGeOwqh4q01IvJvPGkpKKB5NpECd209/Xb0zwfYGs5K5rF2RxfjHxPqmrWE8cEp+3aoPLSLCqYLZRjcSeOnHbJ5GMZrjNOubG0uJrDT/ANytsgiUg7kJC/QFR78iui1gxeF4pPE9nKsl7qDG2tt3ysI2XlhjAXb2PQ/xDNeZeG31EeLr7w/EFmg0yzkkuJThQZpVyNwIwpVeCpCn26VPKK54t8SNEsrzwfa+C5tvmXFw9228HcmWyNp2gH5u+Olcl4i0S50zwpqGvSbWOlajHsPZcbfu5Yeoz1+leq67pkreNNGa+HlNb6Wbh45N2zDMcHaAAD/tYJx3ArP8VadFrnwr8V6Pbni2kjupEjfdngHjdxjgcj6VLKjoeV+LH022/aY0rxVdEPaXuj2sd1iPKlpSUGccY9iwx7CuGv8ARvFtn468U/B74hSSyyS7tQ0KaVFOEydixiHamAPlAPOOua968UeFrLVfhfNfwjddLpUTMqKquHt23KeCRz3G3I7YryP9o/VITJ4G+PFnIVlkVNNvdzDY3HBPUr6ds1K1V/60K20PD/EdxrPxd0HR/h3rNpFLJYo3kIyEiKboRJKnGf8ApnvOMZ213/7Fdxqvg74iav8ABHxIwR9VjaJeH+zknjohXI7behPBxWl4uikk0DVbwxRy3Hh26juIZIFMkf2eQK+FPTbzgnHOOa6bxla29p4j8HfF3Qz5cEvlxvN5iDd8wwAgGQB6n6e1RL4NOmxcfiPGJ/jOPgHqviP9nbx1p1/JYyyyxzQlEym7lXTZ5mCBgj5gB6V6H+y78QPDng7x7p/iDQpZ28uXdtnBXan93J45HXOK6/8A4KW+B477S9L+I+nzlf7TtkR1aVgjOo+8RsRemON5+lflr8IfE95o3iG2tiwRVYAhV4qalO8Lx2NaVS0rS6H7Bf8ABRX9lbQvjPoGt/GbQNEf/hMNBtE1iT+yYolfV9EbAbzBszJPY4LJsXJjJXacivw58AavpXgW9GoaPoK3l3EVliudSm8y3t9uG3CCFQJx3AkcIOu1ulf1VfD3xLf6p8I/DvxDtDHNP4YuiJdxBLWMq7JkC4JbKev4V/Ot+3B+z58XvgZ8dtZ8E/Arw5c3HhzUBFf6FeaJo93chrG55jjBiidIpIW3RGPaCAq8DcANsHarHkkZYq9J80PyPnTx7oFx44tH8Q3c7NfO/mtdzDCSSSn5wSML87HIA6HoMV1XwD01fhrDcfGTxHbrKmkcwWchx519x5RIx88K/fk2+i8DJrmdL/ZC/bAv7RviB8X9C13wv4as4TPe6/4nsry102yg7uxkjADcYWIBGd/k+UnNY/xH+Nsfimxs/BfhyGWw8N6UmzTre4WP7U5kG57i6aImN7iY53eXiNE2xoMLubpnT5lyppx/rQ56dRR95qz6GN4w8SSeIyJ9Sme6uWd5JpnO55ZCcs7Z6lick+te6/BNo/CngDxj4wvH8pf7MOnWz/8AT1fkRKpx/DsEhP09QK+ffAHgbxL8SPFeleEPBNq+p6pqUwhtbWMgNLI3IVSeBwCWJwqqCxwqnHTftN+MdN8Patp3wd8IXK3eg+GHkH22NDGNRv50Xz7vDciNcfZ7cf8APNC+WEimsZQ9pJU16/cbKXs4OpL0X9eX+Rna1rsd/fMk5YgHKkHOSP5+le3f2NHa/s1XeoWDCF/EWswabIx6iOyiS9AB7hpdmSBxj1yK+cPBvh7VvG+p22jaBC9zc3DBUijALO2Og7dOv9MV698bdT0zwndaT8J/D1/Hf2/h6CQXN1BL5kD316wkuFjI+VlhxHFvUkMUPpUzV6kYx6ajg+WnKT66L+vQ8i0/Uwqx2N3y8ZywPXrgj0xxXc/FvwVr3gTwtotvf2jW8V3b2tw0n99zH1I/hO0rkcYPYVr/AAR+GEXxu+Jml+EbmRLO3nE02oXMisYorG0head22gnhE2rgHLMo78e7/GnWrbxa+p3MuJI7iTzIkdcfJ0QY/wCueF9uKpS/eWXQXJanc+HfDcGoG6RX+8mcehx/jX6vfA6DT/hd8Of+F1rajVdetYml0+0f5VtU3eSb6ZOPOhhkwhROjMu/anNfO37LvgL4VfFDUdb07x7b3WnJoulXmpS3FgQ+PsiqRtRsgK2cH0yMdhX0Z8aNfbS9e0bx58Ms2Hh+C1Gm6LFIhcWr2ikXFjeKTh5mLs8nIS6gkV4/l5XmxD9rU5GtF/Vjqw69lDnT1/I8RfxPc/E/Vm8M+LJjLr3mzTWGp3En+v8APdpJLS47KN7FrV/ux7jDhU2V9b+Jvg9p+ifstaH4Q8Z3U2ka1q/iC51Owju42VbVLWH7PL5yfeWKZ3wGQEZG/DCvj/8Asu0vtU0z4g+BINlrcXUVsbYHe1neMRiAk8sjZDW7nG+M4PzK1e9fH343an4d/aJ8ceCtRmPiDwtZa3cwQ2M8zN9mMYVJTZzNloG8wP8AKP3XVGT+KlFOVVKPTW34FScY0nzddPkfO+i+I/iD8F/Gtxp8UjaRqJiAnhkUT2t3A/3TJF9y4hYDCsMHGQrKc4+rfhl8cfB/jTW18FLAvhvxFdhhHpUsm/T9RjHOLKdwMtt620o3pg7dyAMfO9U/4Qjx54Ij+0TS6t4bjl8m0vY1CX+j3UgB8qROQjHgmI/uZhhoznFfK/j7wUNNX/hA/HiLc2t4gms722yI5Ap+W4gb7ylT1Xho2GD2J7E4y0kv6/rocbUoax2/r+v6sdf+15+xp8GdQtJ/H62Uvh3fJtl1GyjxDbTn/lne2/8Ayz9pF+XHPAr8h/iB+zT8Q/At4IViW/gk5hmt/mSQdipr9X/hv+2d4z+CmuR/C79qYSeJPDN3EtraeIFiM939nHGy5T/l6jUY3KR5yjkF+3pvxO+Gnh/wRoUPxA8BPDq3w91XbO0cEnnRWkUnAnt27w5++vDR+mK7aWMr4a0W7x6dv+B6HBWwdDEXcVZrdbW/4Hn/AEvwT8U/C34m+AIo7vxlod/pMcgVo5Lm3eKNg3TDkbOfrXpvwG/ax+P/AOzLrMWsfCDxHd6QoYO1srbrSTp96E/Jz6rtb3r+tL9nj9rLwXp3gzTfg5+074ZtPFXhdIxDa6ksStcxQngBxj94AO4+b1XufRviX/wQ1/YX/aY0hfiF8BboaRFfjejadJsi555Rfkz9V4r6HDYmFeN4b9j57E4WdF8s1ofJX7Fv/BxFo+qvZ+Cv2tdMWwkbbF/bFkC9vngZkT78Qz1PzoB1YV/T54A+IHgz4neGLTxl4F1GDU9MvY1khmhYMhVhkcjjpX8jPjn/AINqPi7YX5l8AeL4poVb5ftMKs2O3KFP5V+g/wCwB+w3+3R+wHfRabBrMXiTwhcuWvdJb5fJJ/5aWvJ2d90X3WPK7Tnd1wqyi9nb0OSVO+x/RHHHBwuBU62sJ5wOlYljKbm2julyA6g49M1sxq/TOfauts50j//X/YoWXYdKkWwC1Za5U8joKablSPlFd92edyoiW3VeDTQEXnGKmMqngVWcjjAzRcLdiGWdRwtZ012449KvPGDylVntxjiqViXchN8yn6U/7azd6YLI5z/TFBgEeM/lV6GdmPFy2cmp1u9oye38qomJz04xUQgejQLM1PtyrgLU6XSng96wxbnOemMVpRQSMwIpXKVy952Gq6lxng9KrLbjGT61cW2QDrUNo0SI/tDM2TT5NRhsLeTULriK3RpX/wB2MFj+gpoRBntXnXxU1P8Asv4Y+IbyPrHp0/T3G3+tZVJqMG+xpCN2kfn3PrVz4lvJGuJBFdXC/b4yepedN5C/ixBrKl8dabqdhd6LqkQjlCMCGG7eAByP6D6Vyev64r6bb6jo3y3Glz+Vx8pZEyMD6A9q0Neh8Manp39p3CiOaJ0hV04IKqCwGOw/+tXxfM2fV8qSOXjt/Dekvby28fllD+7VTwEO0EjHoBtA/wBoV6fcfEDw1qVmNP1e1jZNgAcHGFVSBxj6dK+dPFNxqqxx/wBhKtxFAOUPByR1GPbH5CuesTeDStzSSK6hEYPgnnJ/T2qee2liuS530r+E5NQLWCBCzAM2CvPPB/3c/litrStJsNbh/tGxkmtp3UGRVfKqWCn+f6n2r51uL+4spGvA8gKxxybXb/ge3HbjP4cV2nhvxdqkVgsenrGwnPmLKy/dyAwyPw6dqz5u5ol2O98S2Vta3AVLiWcrGUZs7j7Y/wC+uKr+EfiVZrc3FjYMYPKYqySAbv3IA4xx/AfqBxxVrRbHU9VvJrjUJ4pirD5Ex90df6D8K8S8X+GtDk1l9VspDBN5eSMn5pfnQHj1Xp/9elzWGo3PsF/FFtb6eNVSV7sxhyqx9DsBPbrnpXI2/j7xJqY8hbQxKST3fdk55BwBzn8K8t8Cf2loci317qiOjRgFBFnkkAke23GRXrvg7xhAXcP5a/Z32g7c5UDAYZ6/5FZuV9DWMVE6XT7jxJp9pxYfOoVVaWTnIBGcev3R6fKDWTFN4z8SyPbazPDZQKjeZDG5CqueueMhTnA/u8elN+IPjjW3so9O8IpFcyvwZGOAowV2/j2+g9a8v0208TeI7xbjVJlwhX92nCAnjGMfdJwCelYy00RvE9y0/wATeH/D0w0fwxHFdvE/7ySMbl3sP4GxwQP+AnGOoAq3qGtGfRpvFmtD7SZI2VVX7yHG1VI59gO3IxjIx5dqHxG8MeGbJ9A8NRhruEJIkhXPy9Nrn/YOQfb3rj7b/hO/G97bX+pypDBGodIIcrGhztKsmcnByOT7DGMUr2GdCviK/sdIn+IPiwLGltD5NjGAx+c8Bdq8tu43FBuH90gVyvhOy1bw14Tng1yOX+1vF0mzbGRFtDcFVGc8L/AVHbpXbN4str/xXpngvVNqmxfzvlfdHIo4+Y4HIzgYBOODjlWq6Hren+MPjBczW8qfYdA3RJC+0QtM/QAYUZ7BflB7ClbQL6/1sQfEt7KyfUkFz9nNvHZ6Xags0LeYT8wwMLnnptAHY14la61aaYPG3hK7uYriSdhD53yuuQoA5Zyylc4IBPTtXpnxk8PWlv8AFPT9cmPlvHbtdTxk4QsgwoOSMN1AUj6Y6V88eHbDVp9Pi1K7WTzdU1Fppi20tiRsgdOMADp+RqWikdr4Z1a0fxfDolwYlhtbA203k4KnI7jbj643Yr588X29h49/Zf8AGukWox/Y159qgKI/7tojxt2o7EEe35V67pt3bal8TPEF9Y4uobJePNd4lJVPmwRhhzx9wfQV5x4D1iSD9nfxr4n1OARjUJZUjjdlLqh/hUuvQeuBxVxha39dCZT0+RgfBp7HxP8ABjXbq3SW4eXSwsqhC53xDqxMT7P0PtX0n+zTotj8R/2RtRstYiAk0aT7SjQxqZVaPBA3bflA/wCBH2r5L0/S28Lfs3XvjOwt31Awx+a4S1jlXYODudw3lj6Aj2r2r9jX4kalrvgm98MxwWunQakjxyeRaWyOwI6eY6YXj/nmgPuKx5NEa8+56JdfFvQP2hdT/wCFaXssVnpunxrbpcJNNI7ZABLsUttvP8K8f7VfnP8AFH9m7xF8Iviw2h2bSalBuWSG78tUhcPzhcO/A6ctWpo/iKy8I/E/UdM0aQwR2d0UjDykt8p9QEP6V+jPx8ku7rQ/BXxYWJprj93FNIfMMaKOc7iWGfYY+tTrC8EaK0rSPafg94iv/AfwfubDxHDLprTQBI9wkXcW44ESl/ptBrH+EPjK4+IPh27+GmuTTw6jph8/RtRlt3a8TY24BA6iRwxHfn6GvIP279d1HSofC+uxS3n+kRRt5j3w+zsMA48n5zn3ZwPQV5V4a+KFn4Z+K/hXxLf3UU6TeXFNGpyzRt15JcgY9Ao9q51DlX4m7nzdPI/Uz4a/GH4j/FHwxqOreGrrWdA8c+HI3ttS0602tbakQOfPtJXRGLAfxBuK/LLTP2X/ANj39t7xXq3hTU9MPwY+J2n3EpuY/C6Jc6VqhHLN/ZkrMscqnmRbWaItk9SAB9m2N6nwD/bTsPEWkNjw94vjBKbNgjLDjc+7kegyMY/CuI/4KM/CRrCaD9pv4cXy2mpaLdLIxtwUmLkjlNgGTgDGB7ktXVCrJe7F+nocs4RdpNf8A+LPHX7A/wC0r+z74LubX9m7w7H4u0bxBarb3Xj3T9XtpBDYh/39u0T/AGQ6fHMQI7lpI5CIgUaUfeH5cfEX4SeCZtZgs/F3xE8I2d5aKkV2NN1AatFboDjc72iMg8vncFJwBx0xX9O3hH9pTWp/hrpP7VnwsWS7haSK38a6LBI0EzSIOL6wZDuiusE7sKVnX5ZFK9Ok+Pdton7SvgrwzrPwo1OLQ9Zn3XXhbxdBYW39janNIeNP1LEclxZXIxtWRUeKN/m2bP3dOFZacun9ed/+AN03f3tf66Wsfih8CvhBZXU7eE/2bIdT1rTYdLu31LxNHaeVNrFxLaN5NnpynBtrZ52jwHIuZ9p3YjT5/iK8/ZY+MnhPxe/ww+IlhBoF3pqqLl9QnitILZUQEs5DMIkVeSP4QK/ZvxTdftCeKbpfhp8atH1fwh8SdDb/AEDzoHsNL8Qx45+xyx7LMaiBg7LdzBd4325SQvCvzX8GBpXir4lah4d1xSG1nStdtbjcuZI7lLSecSjd83nRTwLuz8wOcjIOMPaVKd33/q/9LysrHTKMJ2Vtv6tYo6Zpfw9/ZI1fxJ8AtcjnvtT1iD+yNc8SCJrcaVb3AjkWSytm3G5gJCSTvuQy2/Nv82FPyb8SdL1/wr4kufCfim3WLULdkR1gk86FhKP3csUgwJIZRhopABuRlOAcqPpLRrPQ/ij4W0X4e3qi18QWcK2nhO7MirDKkhLx6FNITsWJpGJ0l2IWCZvsqssU0aVx/wCzx4/tbj4raD8L/GWj2muQuLrSdMXVoJA+mO4dxE0Xyu8Mc8ZU2sgBgZnVdmNg0inCLcVf+v60/wAiHabSei6eXl/X/DepfBD4K+M/A37P3xH+I2pabMp8SaLLpGmxcCaS386GS/nSP77JBEAH2jqw/DwTTfiWumwXllr6HUdC1Ro4dTs4iFmaNMmK4t2PyrdWxJeBj8jjMT/K+5fSv2pfiN4p8T/EXQ/jJ4X1K4sNMmiWDw/NaKLd9EvbNB9o08gZRZ03ebu2+Xe20iyBZI/MA8Q8WWSfEbQbn4k+E7OGzu7ED/hJtOtRsitnc4TUbWPJIsbk/LKnWzuQVy0Lo6zTptR5p21/4b9LepVSSbUYdNv6/rQ+qf2Nvh/qem/tDRajdXqXnh2PR73WZNQt1Atri20pftccrJJ8o2MmDFIQ0buVyDyfhr4opNr/AIu1b4p+Hb3+2vD/AIo1a+1GO+jyPKfUp3vPJnjPzQyr5mNjjtxmvtP9nzQ/HOufssfFvwV4SZ4pNS/sa28rjF5HdSzC8tBkfent4/ujHmFQp+8K/Oi1uta8M3NxrfhO68ie4iMUsTp5ttdRclUmiON4RjuToynO0rk5eD1lOV9dvkicW7RhG2lv6/JHe+EPHmseBNWOr6DIglkgEE8Uqb7a7g6+TcR8b0zyP4kPKEHr9KaTq/gf4m+Eb1bCCRtIilRtR0x2D3+j3LZWO4hfgSRPyI5eFlXMUoWRSB81+I7XSPE/hCy+J3hGHyrGRxaajahtz6bqAXLQSdCUkX95byYAkjODhlxXm/h/xD4k8IeI7bxl4IultdSs9yReYu+GSN/9ZDKnAkglAAkjOOgKlWVWHU4Ka7P+v6/I5YzcPOP9bf15ensXxE+GdnJZP8O/G+26s9QQz2F/CMK6rwssRPKuh4kjPKH5TxjPyx8Kfiv8Rf2QvHs3hXxJbnVfDd+/+naY5/0a+gb5TLDu4imAPUYBPyvkYYfpd4f1XwN8Y/AUup2KSW2ltOiahYhvOuvD+p4+RgeC8Mg/1UmAJ4vkYLKu2vNPEHwn0jxPo7+EPiDAlxsP7u4jP3XP3XifurDlexHB5pUMVyXpVlddV/l/XoVWwnPy1aTs+j/T+vQ+ufhb8LbD4i/De08U/Blpdc8KXMStExX95brnGxx/DJEflYH0r6C/Z6+NHxY/Zk8ZyDRxLNbRyCG/sJMiOb0Porkfdb8Dxgj8RPiF4Y/aJ/Y0+H8HxP8Agr4q1LSIo9VFlcJYTFA6zx7kaWIgxtgptBKHjpxW1+zF/wAFN/2ita8eWvhr4nSw+IxqEyRmW7tU+fccbZfKVMezgDHpW1DD1uR4jDTTS+TVv+AY4nEUlJYfEws9PQ/vW+E3xj8HfGLwZa+MfC8+FmyssDjbJDKv3kZexBr0wmFxt4r+bL4c+OPFVlrd/q3hq7m0xJA8ji3J/dugyMjo6Y45GQMV9a/DD9u3xDpHkr4qurbWNObAaeA4kj9ynBx9Pyr6LB5pGpBKpoz5zGZfKlJ8mqP2WHkKNgximeeiHr+VeSeDviT4d8caRHrfhy6juYJlDDaQcZrppdYOcLzxzXtKF1dbHkuaXQ//0P1ik1AjHanJfErzWAwwD6VIjMMD9K9OyPKuzqYrs/SpUvE7muVWSQDtUonkx9amxXMdYLiM9TzU4mB4HauRWf1pn29wdtLkK5jtPNT+lVnlj+6MDFcodTYZz0pTqO4gZo5A5kdCZEHK1Atwn/1qxftpkGM8U5SWAx3osK5ui4i6elX47pE5GOOlc5Goz1qRpdtFgudH/aCcCPBpW1FQAOK5fzcdKiknOaXKPmOge9yMV5t8XLsN8LNfLjIFi7EeoQq2P0roWncfyrlvG9t/avgbWdNbJFxYXMfHvGelZ1o3pyXl+hVKVpx+R+X+ly2dhA+jaswkgli82AkdVkUH8CM4rz/W7e4eQ6fpmo/ZSpysTcqQcMDnjqMVyFzqWq32lpp1s3/Ew0rcFJ/5aIT1+n8Q+mKrjxlo3iFGs9ZjMFyBGhJ4ZZB8vB9Mc18LzI+xSYzVb/xZoTRXSx+dA6biYuq7QM9e1X3+JGma7ZMl2vkT26uGEi7DgAjj646dq898U+L9f8KeHpDIgvre04LKw38jAU+orzx/HEGqWUE0IaBZE2zZXOMJkr+pH4VDdi7X6HRzeI7KOZbxn3iJni74G3aoOOnIP61o6Jr9w1rDBZ3kEO55BGpIJVWOVBH0bA9vyrzm71vwpZWM62t7HiUbSg6/IFxgeuAfyrsLLw94Kj8m705vvhZMduCP54J6dqm5Vkeix32vyzvFZXqKXbnYNgyMf0HNcwPBninRZftjamUSU5wfmGBzgZz/ALQ/KuMvNa8Q6dcrb6LD5iyKG3E/cXGB+fQ1s6hrnjTX9Ltobn/RYoACxUYcHgHp1GST9DUFG3eTX+mSxXFrdybUYxy7vlyjqefbDf4V3Fn4/s9Oghmv5EQOqcRsGb5h6D+6CfwFeIw+GLmdY5dVuGucb1O89c4I/DP+eBXoui6L4E+wtLfIkKxKPJZzlvMA4A9weMfSoV+hqrLc948O/EjwbJbtDJB5shU+TsXzCWGDg+hB7+n4VyWs2nifX9Ta8fUhZ2Xzl4toUtGw9sZ9TjjJPArivDF5aatfvp2gYtrdhl3IC7VPVR3+VgRkdvTFalz4B1r7a9pe3jfZVy0bO25RG2Npxx36Ht06YqZN7FpI9u+H+jeCr62D6VceexC+ZJGu5gpz86nvg53IfvAEDlkrM1/xfZeVeaN4ccW00SiMurCSJ26Y3DIbjoRgkHB5UY5DTfHFt4alu9P8LxGdIYtt1hVaMA4DHIOdgIG49UPPGMjm/h34X1HxR4pl1bUTFbm5nDGFvlKKeBnojdskgbhz9FdW0WpVtfI29G0iH4faNeeMvEBJneHzIH4frwGUMDkHp+nHFdT+z5azaB4CgbVIjLd69eSSMqg4KIdziRPmUr2xhyOykcjjPjpqi+K/GNl4eL+RFZMqGFQfllJweTng+oyD1xnk+265daT4K8HJJPMhaK32m3U85fgcZxyRjBxk8J8w2VdtbEN6XPJ/HOrr41+IOsW1jtdrkraEooiaOKPlgVRcc9/lAPfmvBvEC6bcfFvS9L0xlitNJXLiNnZVl6BsyFlU9sADHpXsvgOG8tPAutfE+7JgW73ugjaN3EZwoKq2A6jjHynH97vXx38GLm+1zx7eaxNvunvbx1jl2iNmjBxkgB+w7dKT2ch7NI9+uYLfwxd+JxFJNNPqgAa2WSPzUZlCh8Rk5T1DKre1Y3ij4dDwd+yf4osZI5VW4wHiZ2Qv7L95un+ycV6945ttOPxIt9P09Wgi0ezE7O0KTLvYZ5Ks34Nz+HQeT/HzV9J/4VMmiTCxurrVZk2JFH5cilj9/wCXofYrz/eq1ZP0I6WPn7xnqOlaX+xw2nQg/a5fL2AvLG6gkZChcI3Hrj6V6N/wTrtLPUbqaKf+BSSLoSCM8f7BB/X8K7j4geDNA0f9nyzsJbxrd7uNcxXEQQ/8Bk8yPH/fL/hXN/sVeDv7B1q+1C6txJbxKwUGNJg2f+2i8HsAKym9Io0itZM+QPiFFav8d9eisfskEf251CxxybNu7tlnP4k/gK/Uf46X2mR/APwv4WeXzZXKSb0DttBHsFH55r8+9A8CXcnxq1DXri2txb3GoO0aWUkWV+bhfKLSMp9Rjj2r7Q/a68VeLvDsnhjwvb2UVnaTIiE32l2c7txniUoHX/gK9Kwqayk+yOinpGKM39vu+1a1+Bngi18mJftLRqs3l/MdiZ/iQEZx2P6V8HX/AIg8QLcaHa3nnRSLja0kapnGOmADge5x7V9zfHPXtS1PRPBfg651rSpI4plkMNs5juOAP4A3AH0xXjn7X3gHWtO+I/h3X7Vbye2lgWMy3FzLcfMccL5i4VRjoDj2pR1jbsgej+Z9tfFrS7+/8AfD74n28s9zd6RcwKzs/wB6NyoIURhhnp1xgV9E+PNYt9D8Zt4Q8RyEaV48tvIQkMxSXZgZkwqbT0x83vnpXD6L4ed/hVofnpEspFu20pmRhxnaQMk8cEV8t/8ABRDV9R8N+LPBGs2qNFLBKD5kvzuNuCoDPIXUZHQKM+vaskr7djRu2nmeV/s56nq/7LXx/wBZ/Z0+IKxyeH9cka1dSTNFLbzfLGSwSJXwOGQDZ2KkcV9JfB6+tf2fP2jtd/Y88WXtxbeFvHGZ9Luo3EMtrcv/AKtgECqobAxiMAELgHmvlH9vmfU4vFHgf4hWbCV9QtVd5C7u6sgBCguzbR3woAr2P9pDV7zxr8EfAvxw8OxtDqWkfZ5mltvliWaIjcXzt3sen8qG+3VX+YktNemnyP0e+Fn7QXxU8C3Ws/AP4hCe+k0oubsWZME1/Z5yLu1VMxi6TGZoDGYpuuxDXjfxO1n4DaF8V7D44fHHwrBq3h7xBM8un/FLwvbf2RrWnu1u1uy6vDB+6vBHE7xnzbbzIlx8rMMjzT9pTxjr2had4C/bM8GhBLDHbtchAxaVXGJYhnCRrjP3SWJ7d62tS+J2i/B74qpbajBHJ8NfissKSW8u3yYL64A23IjHy8NwwkO5sFiMKDTjWdvIbp2fn/VjwX4kf8EmvF2kjRPC/wCzD440LxVoniK03aHba9dx6XNdWqJuX7HeQRvZ32EUERoltNGgBKsea80k/ZJ/aa0j4meG/jJ+0R4Qv/DV94f1FJtd1+QRXWk6naWyMRfNd2bzRW11GE8m5S48nz/lmQK/mxj7a0v4jP8As3/EC7/ZC+PmmPefDHX5ftOl6tLbwstreM4k+2BRGISFkIb5QxiIEmSd4HrOhftH/EH4NfFmL4U/HTX7qwSWZDonji0/0WR4lYiAX5Qol5Z/MFzOuwNkDK5rSdTmjaW5EE4yvH+vI/nx07X7PQkuNF8avLqPhDXIIItS/ssrdv5YUvZ6nZ7dwae13blC5E0fmW7KxKBaPw20Txh8PP2ofBVlp8sd3c/2xpUIudPxJaano+sTRxs0W7cs9lfWxbAO4cY4li+T98/iLrHwOl+L138Jf25Ph14CuLq8dF0Pxo2hQwskkyqoF/8AYzBtSaT95HdW7xOoI3R/KWPQ+H/2P/gx8PPELeDvCGh3ejeN/B5fWPDGg6xqjXtlcG6kcj+y9WufLeVJWBc2d0Svm+W6PGS5LrSShaG/6f1/WhdK11z7f1ofhz8avES6/wDB228F+DtKs/DWjeGfEl1dX8GmSSia21Nm8nTrwyMdyxeUm23AwsFwpUFnCMPlLxvcWHj7S9Q+IulwC31zTtkviW1jTajiVto1OBF4EMsmFu1XHkTHzCPLk317V4o0j4m/s3eOrvwB4rsZH1jRIzpmq6fq8bQf2lZyhS8NyOdguFCusibvKch13bSreE/ES01T4WeM9I+LHwomF9pNys0ukzXoBFzZ58q802+QZAkj5trlOQQUmTnbs1o01G0Voun+X9foY1KjleT+f5af1+Z5F4a8cf8ACvvFR1W4tG1HR7+I2euaWhCfbbE87Ub+CeF8S20gwUlXGQrvXUePPBUnha8s5dKuzqui6pbRalo+qBNkeoWE/wDq5cYGyReUnjIUxyqQVA25y/HnhLw7CLDxb4C8+Twvriyzaa1z801uYm2XFlOf+e1nJ+7Y8+YmyQFtxI3/AIT+N9AsNNufgd8UL0Wmg6hc/adA1O4/1OjapKcSLIwGUs775Un6rFKEmx99h0y2vHddP66r/gdjGNk+WWz2/rs/6tqcd4f+IPjP4L+MF+InggJMxQ2t/Zz829/aNyYZgOq55Rh80b/MvcH9mvgN4U+EX7U3hKHxR8LNcslR4ybvR9RnjhvrE5AljkViNyKTlZEyp+8Otfkn8RvAeu+HtSvfDWtWUlpf2JMU8Egw6OnbHToQQRwQQRwRXR/CrwlqPhn4Z+LviO2nRSixtrYWvnj5DczzCLCjHJ2nnHQVz16cK0ItO0tEjehUnQnJWvG12u1j7I/b0i0XwHpfhP4XeGtb0zxDmOS51N7KYXBiltsRQh3QlfmVm4IzxXx18GfCT654qRtH0pWkg/fNtdRHsU5OSOf0rwu81yTW7+Se4ia2uJHLNtXC5PuoBHoOK+iPD/wb/aCntLHwh4Jsby+l8QRLOVhHlSxQnhFMo2kB+u3rivThTjhsOqXMeVVqyxFZ1uXT+kfeM3jjw14NnkuPir4ytNMilJCW3nBNqHsdzenH3RU+k6v8FPFCrD8PrxdXkbmP7PJI6Nn/AG1Xyx+de+fsnf8ABA79oL4hvH4v+Juo6d4OtJQGYR2wvL8ng58yX5F/GNvwr9BPEn/BKH4UeF2/4RdvGeq3c0IGZjNsO7/dj2KPwAqcLR53anr+CMq9VwV5qy/r+tj8/vhD8YfGP7O3imDUZtH1O109v9cvM8Jz3AUlh+AxX75/Djx9oPxS8EWXjXw9KJLe6QE7R0PpX5ga7/wS21OW3C6B491CRR91bqZ5AP8Avomvq39mH4M/Fb4BWLeEPEd3HqWmOcxuvVSetfQ4FV6MuSa908PE+yqK8dz/0f1QJGcCnI8SrzxWE12cZqP7WWU5NelZnl6G+0yL2xVSW6xwaxJbtuSKqs8jNjp0oSFfojZ+1jJzUD3APQ1RSJjz1qdIHPQVQg+09z0prXHIxxUr27MOKqyW8gbihWFYsLqO0+wqwuqqvBzmsRrOXOD+VJ9mkA6HinZAmzoU1dcYz0qUaqXIwa5oW8iHnkVYPy8ipsirs6dZBJjJGOnFWF2da5Nb7y+/T+VEurqnzmlYpSR1ryRA8YqSI27DbMPkPDD1U8H9K4U66jnFWYtULd/wpcgcyPx3+Kemt4a8d614beY219pd1II5NvymHO5e2MdsDpx614j4t1WM2j3F9a7bhCN8sPO7GMHaOgx+X0r7J/bQ8KvYeLrLxzZ/L/asXktnhftFqvI9y8W049I29K/NafUZNAeC+Xe9oy/ZpxJ/rIFTkB+x25Pzdx7V8Djafsa0qfb8uh9lhKntKUZm1da5B4ohbSbWVJkvLYq6Z+YeSoH+A/CvFbbxjdx394LS13Qx7S6RvggkId2D2IyOK9t1nRdLa0tfGOmKscsEwm3oAoO4FXBx1U5NfM/jeSx0bxZFpU+2N7+1cIeMExYEi57Hbhh9K5GdKsew2OlnW0E2paeJRMylGxycHBU+h/un0NXr/QRBaiOK9njt1GVVcrwVP9GxiuK0XxPrVl4dFrGdxglVkLfexkntx0wn4jtV+8+IGoHSo5IIDN5pDKgwSVbr9MAEflS0DXoddo816Z7Sd7t5ZImMcpbjfgZP/fQz+ftXez+Kb1tLNn9ojjBweSGJXqBgdx0x/hXznbXuvTXLy3EC+S2CCeMYA+Yehxjj6ivSLSey0mWe4EcYUhzlyDk9T19cdqFLsO3crXHiDxusbw6ZaSGHnyZZz1Uc7ce3b2rzfRn8bT6qkN7LL9mZjIFZtqrnIx74I/Ku1n+J2jTW9zp+nzI8sXTn+LHAP54HoVx3FeQ6l8StUuN8akwqgB3BMllzkj06Zx0x+lL5lL0P0D8K2d/f20F7qFylvbw5cbMCSMgDkH1+b0557Vq+OfGr3P8AZ/hfTbkSJIhSd1x5gVuSDjheeg7jvXxdo3xI1XxBap4f8P7pFOMSHIYqccc9D/LtX0l4b0rTPB/houyFtQlI+Z9u1WPHzk446qQR/LFG+iL21PpTwroOg+HvBF7c6lGsbCAhWC4wzAjIOMbSCQ235l4JVkJBzvgxrEWj+Fta1M+e6xjasvkmU7T6xLuYgcZ2/gc8H5+k1rx1qlrL4a0y5DqxzGenl4xjDA4AwMj07HgGvfPAt6vgbwbd6Xfzme4m5cop3dMdPT6YP90jvCa0S6F2sm2UfDXh3Tjqa+MobgymWUsuf3iJnnch67D1yMY7qMED0X4nadod74jt7Ceb7Hd3WAfsyKzBNox+7Bj3oRjcgGdvKHACVznwatINY1t9bs5AGgYukcm5Y5ZD0XI43n+EgZPox4rmhKPEfxPku9SdJY7Y5VXwgT/YHIUeuAQpPK4yRT6Ng97HR/GjxRp2heAx4PuNs9vZoMtGiyxFm7SKwEkb9Cr7cH1U18ZeA7xvDMN7468uP7HYh5hFcED5h0+Y9CPfJ9zW38UbzWdf8Sz6dczBlmZYkG7c6oD3+62COOBgdOcVwHxx13VvC3huz+GPh1YBNqarEyGNZGVWPzbf4h/47+NP+72JuejeA/G1zp/wx1T4leKJ4Y31ecrGkoK79xGFBciNiew2g+4rQ13RU8aQ6Vq2oWcbTuyrHIB82zP3TvHK/wDA+PSvNPEWu3fhTSdC8DaPLE0DYSeExKUbI6bgTtx6bQPavaPC0za543tPDQsyDaqgKBR5h442sqjcvsVJzUu9jRJbnV/tM2PibSfDuk+GfD9w0XCedBudNyt2wjfkGTB7HtWdcQj4TfCqMahDc21zf4j80Rk7S2BghdrhfqjAelQeMtXOu/HSDwvAJUOnBVEVzKhiyf7jRmTHvwfQrnJG3+0pquoeOviPofgfQY5Uhs4wZUX592AAOvLbeQNruPR/vIrdtX2RC6JdSr4lg8L+DvCen61dRW1xfzvuC3D7GbgHqQxGexCHHWvGPEHh7Vvjr8XNK1e3020sW06JVYK5Ct+JjSMkepbnpXa/tSeO7Lwn8ONM8J6Ld2NzeXLRCW1uz5c6AddgYMknQYDHevqOBVz4AaJPpuj2+o3qyQG6YHNuCQo/3fMVW9uRWU1ZKPc1g1e/Yr/H/wCHGs/8Lo8KafcTnyoyIh5EabA7YJ5hXLEegZj7V4r+1fot3b/tI6DB9oMsNvaIhWYXFqN4PUKyJnjjcCfrXtWj+F9H8a/tXT63Z2raja2KCFoora3trk7ecyRpI+RzwWxWL480vWPiZ+00gg8NXWl6fo+2CFGtBaGQLySrf6pvTO5vw6VM7Lmt2sON3y3P0t+HGqXepado/h2NFig8hQQiyzR7x0Jlb7v0zX5Z/wDBRjWvFMnxgt9P1HSd2n2gjiS9NvIFx1I85k78cZI9K+4tI1vxD/wubS9OsdD1u2sY4QrNeNviLd9kaFk/4FgZ9K+If2xtCvPEH7Umn2FrfxW7wwoHjWeaByCerI0EYwMdmZayi+Xmv2NZa8ti/wDtN6VYeMPgp4CbTlQXUIAXyJIixVlwRzJu+vApIfHWneEfgZYfAXVYxLqupOspIuIisMZ4wSDIfwIUe9an7RQa28eeC/B8U8Ris7ff2xnjJDB84x2wor5u+M82jH45aaljcsw8hNwMSRoOg4VI0z/3031qYr3deiKvrofqj8QvDWoeDf2Vbb4P+IJIppmilkihHlmMRsAw5MiByM/woQK8t8SeDtE/aF/Ye0/Rdd8z+1/BcxNtJbuAyBFwHG0gYKHa27PsM4r0/wCNHiS7uYvCUdlc3EixW8kQXe0IOYx1dWAHp1zj0rxb9lB59Qn8ceBb9giXEYfYCsmSpzwTvUEf3ucdua54vljFrp+pvJcza8vyN/xX4x8JfHf9izTdQ8SifVfGXhy3Fva7HKqWtwVSebG3AC9UVXaQ8bSOK43wUT+0J+x0bDxs095r/gJ3WGHiGZ4Nv7v7TKyN5axqfLRApkCcBRnI+cvgjrA8B/tJX3w51YpLpeo3UkDQBcRvJJgq7Yw0mwjAVm2e1ejab4ul+Ef7T0nhvUVuU07WD9k1GOYqI2jm+VQoX5Qw4LD+EYARVxnV+6rJax/IyWr8me0fs5+NdB/az+BOtfs8/EPLeMvC1o8+iyzjM81moAaEc73aIBdpzkxEDdgHPXfst+O5Pjt8P9R/YO+Lv2XVtS0lZLvwg+q27SCC4thvks1O6GVVwN8ewq4wVGFwK8A+JWleI/gX+0ppfxW0GXmKaKeKUYG7bwy+pUr8uTzz+A2v2lteb4UftJeHvjD4CtI4GFxBrETbMCRsrJtDH1XKnGOucUnLpD1X+Raire96M77xNG/7Z3g3Wv2X/HIK/FX4cxXb+Cby6lL3N0IRvn0SeWRmdoplUPbF3LxOBnIGG/EjSvEvhZIrzwb47Y2fhvXpIZbm6kiYTaTfxDZDqIjJUjylPlXsfys9tkE5iVT+u/7dVnqnwu/aR0L9pP4d3gFnrv2fWrdp3/dBwVkEBWNAEAGcs2Cc8HivlP8A4KQ/A68t/jh4v8W+AdKubW0uFtvETw+QAG07V1VxdRNHlHENw8kM5XJC7HfHJO+HrJPlb0f4f1pYyrU3bmS1R8MaZay/CvW9X+GfxotpLfQrySP+1Ba5uHsLuNcW2q2YX/WqEOHCgfabRtuMqqVBrfwhurDWU8I+IYoZ/t0aG3nhYTWt5bXA/c3EEnKywTpzG44I+UgMGUejfADwp4o+LWnW/wAJvGGn3k8GkI8GheI7eIyrp9vnd/Z98oAL2iyZNvIm6S1Zim3yCQPtrwD8ELD4FeCJdA+Kc0HiTw/aX32rRdOsZVe+0+ac77oQSkqI7Vh88sUmIxJhk2t12r1nF2hrLy2f+TX9bImhSjKN38P5eXmvT7u3nHwb8OXEfgyy/wCGnNMubrRdFdLPS/EcM0a3S2yFwbS488qs8duqbo5N3mLHlPmwCfi79rT43fCv4z61o/gf4D6lPpHhDw7Hut4763e3+2375WS6YjOBswkSsAVG485XHpP7V3xu8b/EfxdfSfC2Y6hokn7q0sFmt7ux0y1VVXyIo8kSSPtLSzEE5JVTjpz37Gv7JHxy/a7+Mmn/AAp8LeCtM82dllvdRaOSzh060z81zMscnzKMYRBtMr/KMDcy7YWgov6xU+Lt2+RzYzFXX1en8He33ar+tj6H/wCCcX7Gnjj9oX4hqdUt01PTtFC3M8kT+ZDzxFHIfVj82zrtHoRX9h/7K37F3hv4TxPrev26Xd9O/mNIwy49s+g6D0HFet/s0/su/Cb9lb4U2Hwu+HNqlrDaKGurnaBNeXTD95PKR1ZyPoBgDgUnx9/aY8GfBPwrcXrTq00KE7dwHSqnZy9pU+SMoXUeSJ9o23iDwxo9oNP+4oGNo9K+d/ibongDxKkkum6c0t233XjHTHvX4UeOP+Cjfiv4g2Dx+Eb8aIcY3xxmV/bsa1vg34v/AG1vHDHVvD3jVJLVMHF7ZmPPt1HH4V1UKlST/dr7jlrOlFWkfpjFo2raXcjTbi1lUfw5FLeQ3MH7udCmOxGKr/DT4jfG7R0jT4nJY6iVHMkHyn8jXb+LPG0PiNfKitVhHGW6H8q+gwNTFJqNRaHjYqnhmr03Z9j/0v0QF9ng9qsRShzjtXOpEQavxKVHA6V6zseOdEoHFX4YYyMr0rnY2fp6VaS6KKOaho0TOoiji496mAReOMGuU/tEDqenSmtqzYGD0rPlZpzo6oKmc9qnW3jI3CuTi1Vgc5zWnDqa4xmjlYuZGw0EeaieCLPQelUP7QBqQXhYjbSsx6DnttjdOKybm2f+Ht+VanmMwpCC/wDhQmFjk5raTdnGO1ZFzbzjNehCBPT2qpcacJDjFVz2J9nc84RJj3wK04yy/erqv7IUcgfhSjSAcjFVzk+zPD/jH8O4fip8O77we3F022exk6bLuHmI57BuUb/ZY1+Bfi5p9LVrDUYJvMg3ZIX5vl+RlYdjwFYdmFf0wyadjk8dq/IX9u74RXvgrxRH8U9HhZtJ1+XZclBxa3+0nOOmy4C7sdPMB7kV83n+G5orEQ6aP06Ht5NiOWToy2ex+W3/AAlx0+A6LptysUc+dkM+VjII42n+HgfMp49K8h+Lv2u80+w1bBkmsrvzAYmGUDgxkfgcDPoK9b8U6az3saXOzDLvhfqroef/AB0fjj6V498S9G15oEOjQZCKskm4chgPmHHUHAPHcGvlYs+jki74f8a288T20xmhaT5XAHzBuzgfpXXaZoz3cIbSZvMkJOfcdMgdgPTsK+e9L1ifSLhItbgUXGNwZOhUDoffDHBH0r1rw74tgu7dbnTVxIvGE+XLL6dOoBH/AHzQB6va6t4m0yFJtSgXI2qduevYkf8A665O51vxVq8iWohXym6EDaPl4Ct+GMfWmap8R9VtbSOa5sWU8nep+SRTjcMdjkbh9faqz/ECeWZ7bTrYseOWXB2+v157U+YLeRueGtPe6nLTWcaEkgseCQT3OPp/OvSv+Ee0Tb5rokaYJKkYB29R+Ga8l0vxH4hknZ5oUKnrg4yWHX6HH6V1w+06yI7PVpFWSJsjy2+9jFS7IpHsGga74V8O6j9n0RIpbhQNyxgHg984wD3x9Rx8td54hXV/E9q1xp+ETq0cXyPuHIOMc5A5UH3UY+74rpWmaH4XheaJMbj94LnDqOQB0zjGFOMjitfQviFBLqxgt5y0EpX32Fe3POB/DnnHH1TloWke2/D/AFTT/C1u9/qDrBIVI++uD+nB7dPqOuK83jr+2tXGjaZKpBbYCR8uPbHQD+729K8/8W+H7S+1GzltJlnBXdnGSo9CBywwOh5XsSMYn0jU/DGg3KywTKbxBs8uRCCGOMFf734dRyMjcKdrIL6n17qeuWvgrwNCAy2098mCyHjB44LAhlOPmR1dT0INeOWvid/B/hm81zUn3SSZ3SW/By3TgnaQeg5Ct0zkYqa78Uz3emRS6j5f2QruEe44DnuQcjacdWCnGPmkxkea2Xhq6+ImstDYlre3RyohOCMjrhW459B7dOKp2VgV3oUfD2onUhL4i1CKPDuGWRYwD83QFeMLjH94D261xc09x4x+JEEkyZsdH6s46kdhkBgo6ccV6h4zhh0aFfCOloQzFAdiGKRM+oI/oVx6V0um+BIfA+jS3w2zSIhaQudm1iP4vLy4+oVgO9HkJPqfO/jbWrzWPirb/Z3Z0tVBSKbp74JLH82x6ele06PrOoaQbzxXdF4Y41yh/dsiOemfNkKde29DXi/wv8AS33je98YXNvthkkZ0KsuGB/uuvycdua9p8Y2en23gi8v7Waazuc4R490bk903plST0Abg+3WlvIq+lj0X4U3uo+PpL3xg1mLm8EZVokkUZ+gIbqejL0rhPh94e1tvHsx1ezlsblX8xEmLP93+6QsuenYAH0q78JI7bR/hvJaawYnjnXcsVxGPmYduVwfwK47Gtz4Py3Wk2Oo65d31xYWzZVUmd9u7GAo8x9h46DJNZ7pIra582fGvx/4i+K/xhHhS1uor7T9PKKN8DRyeb/GCVm2Pz0IijPtX3FoOtn4aeDV8SWhXzdMt97xWQhEzkDG11uAUHtnK/SvnD4Q+BL+88T6n4oggjuJVlYp5sZYAdPuCPdgHttNc9r3iXxL8XviZJ4Fju7qK1sWEbQWfz2zSDknDJ5uB/sbfoahy1ci0tFE9w+Dvi6Xxh4j1D4m+PolAuXJCtAkcxT+HiDMW7/dTHtXV/CvTvCuo3ut+LtS0+5uYlDmO3nuTvBGc43RRZz2Ai/SsrVYLbwV4Tu/D37q1vLaNf3g+dssOCN8Jxx2KZ9xWr4UE1/8AAnV9Lu7U6nuj82UxkSzoD/0zyw6dMeWx7bulEdGkwe116HAfsxeB/CN/8b9T8QeB/CNnoS5YGSwt1jZpB1dxDHD83rkV0nxT1fVpvije3uumacaSjMkMt8DEG7H5UcoDjp2rb+BOm+Cvhx8INS8QatavcLKjYQbQyZ6H55IyMfQnsK8N+MWoWPg/9ny/8VW9tJJdagdse1tjZk+Vedp9c4IrO3O9ev5Iu/KtOhw3wq+KPiD46fHH+1PFFnBIdOX7OhjuGkhCg/3jkYHriub+MujW9x+0HBNZy2rweZEDbrcrMc5AyEBRsEDsK7D/AIJ7eCb3TvtvjvWlcR2sRkknj8zzE92Pp9SK7fwf4Sf4sftOy+KL6W3uPsjG4aeJC5Cx/dDNG06n6jB/2RUtpKb+SLV3yI+lfjMt3e+LPCmlKzOlrBM+yMswUFAAfL2kD043GvNP2b1K/FTxLYMhKyW/l4ZCm7GP4W2nH6V2PxA8Y6ffeNNU1u6ktVWyX7DE2xTuAG5jm42DI6cD8q479krxINY8b6z4oknIsFGwZMcBx2VQxlQnA6Bq5pR9z7jeMvePj7x9nQf2vFm8kZt7yFjx12sMY74x6V7/APt1WJ0T4h6ZqyWzRHznWDe+CF4PyqpwBz359a+e/jTPHqn7T/2TSpIpRNJEh3K0cqMWAAI/dY/74x3Br6V/4KKKk/jDSo7WS2uDGdowi7yUjXdlhkEAjHrzW0laovQyj8D9T0b9pK5i8T/Bzwn4sZS0k9nAC+FGNnBOByR9OKu/tbWEOp/DTwN4jQKUewsm34xuIjAx6DoeK439ojS73w78D/AunXcxgnhs7eOSDy/vErvPzbu3+5XU/tAQzaV+zJ4Mgu41kNpY232Y48wFXJKbsfd+Q459MVzQ+xY6pfa+RL+1tYTzfsufD/WtS4ka2iAywHEXAOAe4xXaah8c9S8BfCL9n74spq4Wy8QJqfgTX7aSMPmK0k3WsxR/lkSKPfHKOro6kEFADwnx7urzxH+xB8PLeG0SZ2kuY/LZxG6+U7AGPI5+Xtu6dq+JP2h9Vmg/ZH+HngW9EkEhv9X1Mo3AUMghRgvZ8FlJ644pUo8ygvVf19w6kuVyfp+h9P8A7YN1c618HtR+KMdteS6x8Ob9PDPjjRdOmFuikN5VnrEaY+WKddkdyAMA4k4Abd+GXi/4vWXiOG68Mp4WWLS7oqZo4rmaO4fbx+9mRR5i/wDTN49tfsz4X+KmkW37f/8AwiXi2GHUvD3xN0nTdK8RWsqB1nF/pcUUhdTw3+rTKt1H0Fe//wDBMz9i34HfEXxl4q8eeK/DlpqnhzwzPGumXbSSNFfyzosqb4WYr+6jI3gcFz224rvw2J5IKLWujXTf/I83F4dyleD7r7j85v2Ef+CQ/jP9s65i8Z3Ueo+DPBqsudVv4Yna4HdbMcM5A/jZfLHGN3IH9nv7OH7O/wAFP2Qfhba/CT4JadHptjAA01w/7y6u5e8txKfmkc+5wOgrRl8XeHfCeiQQReVbxwRKqQoAqIqj5QFHTjtivNrLx3f6pdyv5nBQSY7Lu+6v5V0qq5NRerOVUYwXMez+LPG4ieSyt23S4ztz2r4P1/4B6P408c/8J346vZdQl37ltW/1CjsNvSveftBeV55jukcnJqNtz8+lfVYDKoRSnWV5fkeBjMxlN8lLSJh6b4L8B6PH5NjpVrGB2EQrpkurSzxHbRrGOmFAArEkWYH5TxVGUzda9tQitjyXJ9TpptaLLhe3pVQaj5n3ciuabzsAE1AGl7cfhV8qFzH/0/0hawGOBSG1Cnb6VvSoQeO1UJI8fjXdzM4OVGeEUDGO1Z1wfLJwa02BK9cVj3Kk8dqES1oZ8s351n+ey/dqxJDtOBVXyQW7AVomZuJYjumA44qZdQCck1Q+zNgY6Cq81owGKLhym7DrCcAmteHU4cDnivOZIJEOU7VYgnkjAU88U7ISuj0uLU49+M1fW/jAyDz2xXly3u09e1aMN67dTkVPIXznosV8m4BqupdoDya4SG7XbVgXxPfsKnlLUjtDdx85x0qOS9VB8nFckt4zd6ZvebIU0uUObsbcmoIM559q4Lx74c8NfEjwhqHgTxdD5+m6lCYZlU7WUHlXQj7rowDIRyGArbazmJ59aZJYSbSTScYyXLLYE5J3R/Nl8ZvhT4r+FHivUfhz4hRJZLX97Ax+WOeJuY7iAj7gkXO5Okbg44Br5n1DxLK0MqSo8nkbUfPyyopxjr3XnB6EFfQ1/Sn+0v8As76d8efBIsIylpr2m7pNNvG4CscbonI5EcmBz/A2GwRkH+d/4g+GvEvg7V7qz1vT5IruwkMF5ZzKFeIrjcPw64yVKnKkoymvgcywMsJVsvhe3+XyPr8Bi414a/Etz5f8eXGm6xajTo8eft3QMPlPy9P07fUdq4jwzb+I9HnH9mXHmQt99G5dR6jHdef0r3LW/B3h7xTE0tuohubdyCh7f4fyrxG98Ny+HLzzUVoVBwHRiGyP0yMf5FcUJK1jrktbn1T4GnuvFWjtbXc0NyYiV3YxnHQ4z7/h0q/q2nObXFugjeDjMQzgc4I/w9B6ivnPwL8QNN0DVPss7+WXYFsEKG6jjHqpwR04HpXt7eJVh1U3NrdeaJVIZT1PQ8j3xkH1yKHoNanNXM+ttfeTA8g52Mp+UHd0HHvjHFdPomnR6SRc3koLZBBDYIwMj9M/hn3rUk1PS75mtpwrMwzu+7weh9vy461xdzfajdTNaW0fnxZ/1ndX6/Mv8J78cH7wIOaWnUevQ94HjCW4tCNOZGcqVxIQUK9sj2PvkHoRWl4J8N6hfX51nU5R5u3B29vw6EV4FZ+CfEFvdLrctwgg4JEfzoc9QygYHbt7cYFfSukXNgqArG6FFwUQjO04xgnqPTcMHswodnotio6G94n8R/2G0MkypHLEm6Mo213KdVOQDuGODwwOMjjI8g0O51XxX4kl1NT5lr5glChSjLk5+50HPUL8ueRwa9C1SxPioeTfFzACWLfdZSOMEHgjHT+Yxitu3CaLpvl6NEu2Abiw+Vl7ZI6ge/3ezdjTbTXKCVtT0OyXVtYtDLKggtIDiOVSY5A2OnBxk98bHI4+YZr0z4Xm20zSZ5bbYsanbDsYLuJH3QX+Qn/YbbnoPQ/Pvh7/AITHxFu0fMiW0gKlwuQR/dI6Y+vbpXSa7r03gvRBommfvFY7FDEJ5gPUL1Q/Tj6elK33C1R7NaSafrXiZbucCQoAu05iKjsPmClP90gJnoaPibf6MkkOimSSBpQAomUbX9Qr8K2McgMD0I4wa8U8E6PPoZbXEu5LS4u/mXB8vC/3cHchGB8yn8iMVVXWLzVPEq6NqU8k9vLKN+xVQcc/Oqgxv7M0Ubr0LkUXVmyktUj32fw/pWgeC/OXToJpzlj5aMJcn3XY6tn1w1cLfeD7nxKljrN0rW0Cr++GTsbn+Pody9Mkcd67LWVi8U3dvpUAUxxxnywTvREX+6H3AY6YVsjpwODjzeJZNIVUbLZ28bfMiO3pz/CR/tbCOx7Ut9A2JPitYW2jeCjBZWdndxSx4khM/kvkcDIK7Sp4xxu44x2qeBNbuNC8CJol5dTRPd4VY4X4Xjptlf7vsCPTNcPqEE/xK8VQXRfLW7HEQXYpB64PHB9OAfc11XjnxBP4KitmvLMPIMRRxh9vPTv1+hGfeob7dBpWO/u7bTPCnw6utQuJoJN67UigWPzN7ccRu6gn8jjpmvPPgT4B1the+KTDKktwf3SIqSO5z0A+Qk+wGa3r3X9U1DRLfVJ7GKDcMYaONhg9iELN+JjI9q9ZTxTBpnw0nivtPiu7eRNv7sKiZI4DeblcewQfhU21UehfRs+RtW1PxZ8QfiTN4c8R37eRZyKPLnR4zEE/hxLI5H/AXC47CvpPxJFouo2mkeCI5rK9nhG0O+PNtc45im5MR7MpYAjqvTPmXwp8J6HLp13rek7NJlmfZbFY44ohJ0VAgMcfpgLKhI+6GPFdp4O0yx8J6NeeLvFd3FBeIWInuoJIkJTsxPlFQvOCSMd9tRy317jvbTsch8bdRvk1TTfhLZurQz4/fxxrMjYPI3iQMv4rnp2qh+0F4J0bxHaaJ4EBjnjQRlgkDuUf+H5kSTaT0x0rA+GVtP478e3vjfU0/wCPZiIUmlE8gT1jJCSMP+2j+zYr3vQ4Ne8Q+MJte1iaCLTtLQeQxjeMHK/xFm2sTxjDHgdTSnbXl9EVHpc4v4iDRPhF8Bv+Fc+F5ls9fugqmK/s45IX3dUEjKj7sdAjqf8AZNb/AMOdNk+AvwlS7DpZ654iO2LzFA5I4WNpiN2BztVmYDtWWza/8TviXDYtbm4g05lJFrIBk+nlyAnPsCf92uijgtfF/wATLm/t71IrTSso8c7xR7nQcDgxq+3HHyrjpxismto9vzNE+v8AVjxjxtqPgjSfDw8Ja1BaXWqT75W320xcO/diYpImznpuRsdM19Efs+eGrnwN8OzY6fCkEmquD5Pkq8ZTGBxtYH2zHz0rw/StN134z/Fz+xbuKaSGyfCmTKSBF/h6ZKnqFO9Om1q+g5/E2nTa9qk8AMWnaDGbGB51C25mVfmVSy7T6FGGeOOBWdTVqC6GkNFzHxDY+C5vGP7VSWmgW6w3CXsZeK2jPlR7DkkLvPlkY5TauP7oFexftUhPiD+0Xonha1QCSN1jB2/J++dVHIJyOM9gOmK9Q/ZX0zVrXTNd+LvjiGJZ4PMjif5oU29zy52/Kfl+fb/dGMCvFf2dbyL4rftM33xH17L2ViZ7rbIAQoiG2IFsDI5z0z7dqJy+KS9EOMfhibX7aepz6n4z0fwLpDmbzrlLeJdwba4xGNvcZ4Hb2rt/28dftbDTtG8DpEuLcxhm2AY8lBGgGMMBlT3xx0rwvwBqT/F/9sW31e2G7RPDUzTfvMqqJB83fI5k2jjAPtXlvxI1K/8AjP8AteweE8OLFbqGJ90m5FgHzzyAgsAAu8nBI449KSXK/wDCgcrrTqz62/a2+INx4H/ZI+GGhaewa5a1t2vP3jxSbzGZPmQHy5Ay8lXXI4K4r4j/AG29Xu7vwd8MdChUpqdv4Wjtp4V/illzInH95S+2vdvj34vsP2mv2h9L8DWEYh8PeHn867mB2otomIkHT7zcRpx/F6CvlrxN4pf4lftYR63qixjS/Dt5iUkhok+yFmGD0KgRg/QfSoorlt/dTf37Iuq+a6XVpfccnfeJ7jQv27PEfi2SP7XD4SmkuvJiUtldP0qKIKijqfOwAB/FwOcV/WP+wp+z037NH7EPgv4c6rFnWfsH2zWGJyX1O7PnXDEnk/OxH4V+BP8AwRu/Z8h/aD+Omt/GvxvbPL4fsr5tVuPtQDCa4eRpbaE7hj7581x1CxR9jX9Wt9qWmXEjnzN6L+CoBXoOP2V0SX3Kxwc99fV/f/wyPBtX+Gut+IIm1vWdRNnaw4bGOW9APwpltNFYJ5NocIOvvj1rqvEviSfWZFtoMrbRfcHc+5ripY/M5xj9K+uyjKoUIqrUXv8A5HzOZY+VV+zp/D+ZtR6tExGTWrb6hbt8u6vP3tJAc+lQ+bcIffivesjx7tHrEcsDptq1FDDIw3YryqDUriOTBrq7PV22jeamUbFxZ2UmmwtywqBtIUnPcVVh1UYHPXmtBNQibg8A1kmzWyP/1P06luoh8p/IUErtzXn0Gpvd3ShW4J7V1DXsf3R24rend7HLJpFy4IBwDgGsh2XHSmy3Rlfy1xWgtuNgyM/SrvYzt2MCeN1PPSs2VWbG0dK6uS3y2CMYNVfsm4dPpVqRLgcznb9zp2p+7cpHf/CugXTs5LcfpVpLCNjzQ5oFBnBTkg5btVDdtXArv7jSo85HGayJ9KLrlBz6e1UpoTgzkY0ld93T2q/EDH81aR0tl+7+lV5bOVTwKrmJ5RrXRQ7RT47o7d3QdKqfZZQ2cZ9KcsDjKgZougNGG7AOc4FdDY3MRHznn2ripVZFPqKSK5kjH5c0ONxp2PUxcQMO3tUoMbDnpXnf29guRx/Kn/2pL/CeKy5DRTOzm2MMp24r4t/at/ZX0v476L/wkHh7y7Hxdp8Wy0uHO2G6iHP2a4x/D/zzkxmIn+4WU/UUN/LyT9KnN3kbW71hXw8K0HSqLQ1p1pU5KcNGfyW+NvhrrGg6vfadqcc9hfWExhmhdSs0Lx8GNwM/dz/3yQRvU5PjOtQQmKQXgl/d9928BgMZHt2r+nX9qL9lrRfjxZf8JV4bMOn+LbOLy4rh/lhvI1+7Bc454/5ZSgbo+mChK1/Ph8Tfh/rHh3Wrnwr4ptbjStVsZCsttcHyp4Wb/a5DBuqnlHHKk18Jj8DUwk+WXw9GfV4TFwxENNH2PibVtW8AzzJb6tBOFHyhwjfu/wAh+or1Dw3ot8LOHVPC7pqEKqGizJuIGOnPUdPpxxWT4g8FCaZ0kv5YXB+64VentisDRzqHhLUEsYLncQONjbR14Ppxxn/CudtOPumyTT1PpaLTTeQR3+pxNDOOVBPCsPQj6fT8q6Ow1iKNGWS32Pjy343Lz0B/2SOh/WuQGuzz6XDPqCxxE/eVWBKuPTb2PUY6dDW5p9/p+ouj2UoRlGD/ABKVPYjHT0Pb2rG5sdBqvjK20i3Et1u8l8Ykj+8B02nHJ28Z/iHuKtaL4wlZg8e2S2I4GOcY7dvqo5HUAjiufu/BvhuWdMs2ZznarbgSOMD69vyr0LRrLRbSJYLLDqw2fON3ToNv8u47VXMOx3ei6mscTTZUpjlQfmXPQYH6fl7VvTXiXM0Z+4U+ZPl7Y7YI7dMduOR04ZPCmi3rR3AaRLhFJUKwb5OpAyPmTvgdPTFPmW8li+yW58tANhABIA4xgHHfkY49h1C0Qz2bQvHmj2FoNKsLhYLojbtxjP8As4JGM/w4OP7hzivRLbStG1qL+2fEVok7OMNKoy2QOAykAnOOG6kdcHLD5MtbvSPDcq311G96+Ry64VR+fr69ema9RtfiFea5Z+Rao2w58woPk2cHGOg+nToRV8wWPSdV8d2V5atolnaie3jIX72VVv8AZfGV5/hYcH7vqYtI0vT7J31G43pM4ARSVJTPYgcEehA6VwZ1IWG25t38yU/JvjyWHH3WBy3THBBGOgIwa0NKg1+7ufMeHZYDL4UqQ2cdAwK/h0P8htdQWmx7ZaazPp8U8mn2qXErZDSojMcr0BEILHp2DlfRcZHlGiwy+I9duNfuoPsVvEd6tafukJzyZNm2M8/x7I89+eT1ErS+NpE0iENstyNuWMRAXoMnJXA4U7sDjBxxXvNvYWnh7TTbQTortHtPn/LL05DBgqv9VYHHQr0J5dBo8HvddM+pppOi28mS4V22Rt6dGUo4PbkHP96teTwvc3WuwyaiXktoCw8sBRGsg6BwrdcdnKt6V0vhbw7pl9qpu53wtvnZ5WDGPoGO5c+nzLjvWVrja74c13+19OkhaVxgeVHl9g/3SHK+x3KO3HRbhsc/468eJo9xb+FNLhjmYcjzIrjZj12MiDA7GOQ/7xxUPi++1u28KWtrFcItnLhXMTSE/wC797I+ik+4qnoHhuC/1869qdtHNJ8zm5gHy4U8gujHp0wW+uK6HxOx8TXv9npGtwCoVNmHjdeoAIY8enLjuMU59WwW1iPw/qthqT2vhXRii2vlp54+Ztyg9PkeM5/2SoGOmetdJ8TYU1PTLfQdEtoo/NYQoFQkqF78hcewz9SOM8LqC6T8PdNFjHZyRX0i8oVMTYPQrt5b8Aa9A8Cx6ZoNg/jHxBMI/NHyFsTL75UKHGOM4XdUN9CiDVLGLwZptt4M09rZ5rkDMTr5UhUjqkMq7Xx1zEx9jWd4lnsvAejjw7o8i3FxdhVYIrKRu657gehDDPrTLTxCdb1B/Ec1xbSWtt9yIOYFb02CVfLyfRthz3atK4ubjxTfQ+JtZgVLO0YtASQHUn0GTj3CuAeoWsm0tvkaJHVaF4T0Pwj4WFukcepXFyNkkLE4G/PHzhsKPRonJ7DFZGoap4d8CeE00Lw0bq2m4TfY3JQqzdMxuksTAHgBiq+i8YDNHks/GOuP4ivbhvselgFFfcoz2A3hTj6MwOO2Kg8T3Oj6k/8AwlmsLapFp6kRSRxoZG9eg3fL6EtkdM1ns9C7aG5PeTfB/wCGtze2kh1DVtQKRi6mgXerTcKsiQxqqAk8ERKv86x/HGg+L/C3w703wroV95Wr6ovmXMUvzNcswyRyckrkcFZfeMrlh518MdHi8deJbr4yeK5NthZfJawybREWTI3AuVQKQARkDnr0GOv8Larfahq2o/E/XvKtlgDx20dxLGUKnoNrs0LZP3SW9g2Kna3L/T/4BWjWv9I1fjJ8T3+CHwu034d6LNHFNJF9kljtnSUiaRMtujyGUc9Fwf8ApmVrB0S18NfAD9ne68Q65cxx6hq8CZhliDMPN/1aP8pIUk5/1bDHPyj5h414d/tL4mfEub4sfECRrzQtHkdbaKRhJGzx8hI/MUOE4+ZQxRcfLxzXI6n4i1j9pv4i3MPieVU0DRZxPIAGjIjX7sWM8K44AyyD78Z2nlSil/hj+LHGT+b/AARseDrg/s6/AF/HWrDfrvjPBWIKcRWzNlA3XG/Bbr0xXk/wDmfwdofif4+6+RJdXqS2VnHIefn+aaTsTgBUz161qfHbx03xg8Ynwy87afpukfNqLBMm2iUfLGu3O7PAUrlSmTjivLBqGl+ONYltdSmbT/DOgxKiEt8sQHGNw4kOfuyfeYHB6Glb3fe+f+Qr+8uXpsdxomu6t4K+B154ltIGuvE3jfUVFtB0chAyQgHsiEtIc8DA9K+dmgg8OeFz8L/Cscuu6nrUraNbQ2zFZ9Tv7sgXXlsOiKNtuj/w5ckgKTXsd/4qsRoDeONZufsGnfZ2ttK3sFNvpMQ2vMT08yY5O8fwAY61+mn/AATK/Y7ms3P7XHxk0trXWdUgNv4S0qYYbS9Kbj7Q6H7s9wvPPzIhxwzMK2w1O95NdfvfRfL+uhjXqWSjHt9y7n6f/si/B7w/+zF8DdI+F8LR/bolFxqc8P3ZL2UDftzzsXAjjBPCKBXtN94ikmBhUbFZjkD9KxLgRq/k2agY9P8APasq6Mgz+HSvsMpyjktVrb9F2PmswzG/7ulsbkeqpj5zU/8AbEfPT1rjgrZGe9IwJ47DjNfRcqPE5mdgNThYANj6VMHSQAjt+lcP823Gaux3L42lqHHsCl3OjJ2+wNTCcJ8w/CsBJSepz7VY3r/nilYdzY+2svTtSLrksb/K3SsZ3BXNUhG2cjr9KLDP/9X7H8GXTzxeZIOorr57nYrEHpxXg3w68ZQGyMkkgHpXc3Xiuxm+SNh82K58HmdD2MXc46tCV9DsrDVkiuhu/irtl1SJowEr52HiGJbwRxt37V6La3JkiBB4PNdlDFUqjaiyXCcVsd5JqiMQuduKmgv4B1NeXXmqLA2AcdsVXvte+zWZdm7VvKcF1JTkevJfQvwpqQTLnnivAtM8ZK0gG7OeK75NaeNBKxAzWcZwkro0u1od7cXKBAajjdXG4HNeZ3HiRWA+bHP4Yro9L1RJ4tyN7UlJN2RT2udWREV4qm0UbPkc5qhJfmM7c9Kh/tJEUHOPWr5RcyLEkESjtVHavBjwKJdSjdeD0rNTUYeWHPpQmIfOoH3qobASAKdPqETDbmpIZIj8pNVzC5So8ZPGOB6UKmcZ5rejgt9vOPaq8sMQPAp8+guUox8DrxT344BqKRW5xxiqEzyRdBgChIGbCTIp4PA6V4D+0L+zr8Pv2iPDn2TXttjrNpGyafqcaBpIc/8ALOQcebAT96M9OqlWANesC6Zhgdqclw3UVFahCrBwqK6HTqypyUoaM/me+NPwI8Z/CLxJJ4R8bWMcFxsL2527re4jHHmW8uPmT1XAZOjKMjPyrrXhmVYWe9tooySDvUDIPs3v2r+ufxx4C8E/FPw1N4P+IGnR6lp83Ox8q8b9A8Trho3HZlIIr8V/2l/2GfiB8JrW68UeBt/iPwuPnkcRb720T/pvEg+dB/z2jXAH30UZaviMxyarhr1KWsPxX9dz6nBZlTre7U0l+B+XFjfaW1v9g1rLv93cyAHPbkcZ9Py9KtaX4U0yyvv7VjEjZfcjxucbvp2B6+mf02ruzbSYjL9iW5gcBx9mIJKnoyjuPpkelZia9pl182nXiqw+/E6NG3Hqh5Rh6gY+orxlLsem42PQ2srbxHC9pcGWxuo13Zj+UsufvDOVyD17fSvQ9PuILO1B1C5aWYAK0y4y4GOWHH48fpXjdj4rsb0CzjuA00YyELbWx0JHHP610+l3dwbny4drIOW5B/H/APVScuhSR7L/AG5bm2MWRKMB/Y+/Tg+4qCy1G1Z8XUjrGp7Hke3fivNbm4WIrcNKz8ZiK8dO3Hykeo/Sp7CK+12F4w/kn7oLc7fb1x7Z47cdDmHY9fa28OatEUnkLmQ/w4TtjIKHqeM5XkcEMOmVNdS6DCuk6BCQvQ7ztIH09PYHHptrhrGC706PZqEqSyD5VfjDH0zxxVW48R3KTfZrq1aE5PIHr69vcA/gaqMmJpHW6RcatAv2zWJEdUJINvkgpngc5wfpgA9FFfQ/hLx9a6hp40lFEPmcB3GVb8/ut+h/Svn7wt4b/tb/AEvUpCFbG0qdrFfTHccfdPPp0xXp7pBabYdMMcixjlXXa+D6H0PbqvpzxTv1BHu41DSdBssxv++QDkcL9QABsI9MKD044zY0uWbR9Im1XVpGmW85jRHKqqDvsK7QPfGB6g14BHf6vq11/ZyDCjqyqWwOnzDG8D1+VsfTiunuLPXYPKtRcxxqB8oIK5B7o4+RvwII7ir5kOx6hoPjCPTm/s7Rcusvz/JyAfcf1U/TFdbqt7oV1FBLc5+1A5C/I4DDt1jkB9Pl3D+96+S+HNO0Pwsr3IbdI/3sRhhz3IA4/LH0Fek6PokSImt3QhZVUSRAzGOMqehDH7o9PmZB0DDoJXkM19fl8V6JZx6loMVss8p+9ceZHI3HZ/lYnH+3kevGKq+AZ/Jlv/Ec8RmllB3xIRKit7kCJs/70RPqe9YetT32rXklnDHJBtx8jlPMVfqQ6OPQ8n0Ndnrlrpuk+F0tp9QWObG/ayMA3TgbSUz7A/gOlW3qSlZHnLz291ek6nc+W4fei7ZNjeh2YdQR3Plv+VWvF1ldaze2smpXTwW5QbTb/vY5FHUN5flqQP7pTK+grkPs/wDaWsxWiO0bR/OyOuB7YZTj9FIr2vU0XQtKV9Y/dnYu7a5jJ6AN8o5477WHbNQ2VY8rkii8wLbvbXdjZ58w+Wcx/TfGksZ7FeR71U17V5vGc0Vhbs8UMTbYYoej9uVOM+wxn8K0rW3gezuNRu7iaSFnYxLOqbzns3lhA4HQN6dahGs6L4Wi3q2zUZ/kCqhUKMcbSRj29vSsJyV9DaMe5ZvXm8N6WllI80fljeViYDC/7XAH/AR19DXnVvYf8LemS0WY2+l2XyF5AIzgdgVKYX/eJXOOBVDxdqX9oWQslltZ7jducyYjI9jtwrDHYg9sYrnNQ8Uw6Ppy6aNTMcsqbZfs7fvnUdUi2kELjjmoXYbPYPHXxBa1mtfhd4ACxQWSj7VcW+9WjUD7pAO5XJ67cIRzg1zuq+I9L8X2EPhzTribSrS0AR5MYBXuobjax6Z5Uj0OK8n0LVbf+wxBplqul2yt2lZ5nHqc5wfYEjtgVwHij4u+GNCMmg+Dka+1iQqpQDdHGM9SzY2nHrx2p8t9Ii5rLU7v4p65eTaR/wAKr+H8mI2CwIkLPEYVBBHUA4TqTgfyzzmlao/w90Sb4P8AwylW41K6+e8uQQBGQBmRyOAoU/IvrxgGvAfEuvpYWiaF4f1VLXVbwE395MQcL1+V8/Lt7IB9DXP2Otapc6SPDfgmT7Dp75+0ak42z3ZxjIDADaeufuqB1q/Z6Lov6/pE+01O8k0qGwM3g3wsz3AOFefI3yXjHe8jZxhVX5WzwmePSvPbq90nVLlfBNuTdeFNGuljujb/ACnVdR4PkRDj5O7Z4SIZOM5Fq7u21nRH8KeFLwaXocbiDUddON9zITzBahvvtkDJ+7zk5Hy1+gX7OX/BP68+JS6dr3xHsZPDPgiziCWmlMCt7fRMdxEinBjikPzSu/76cnDBUGG7MJhJ1pcsFr+Xm/PsjlxGJhSjeW39aLyOZ/Y8/Zx1L9qn4mWXxV+JcaSeCtCmjkt7bb/o+pXdtxGFXA/0GA/c4HnSLkfIPm/o1t7lLeMwx9D+uP5D2rzPwf4U0DwdpcWi+HIFt7WIBVRRtAwMDgcAAcADgCu8iiyPmNfW5flUKCUp/Etuy/rv+h83jMwlWbUNvz/rsdAuoLuAFQzXSyfM1ZvlDA9cVFLC4XIPsMV66sebqXHnT7i1DJKEP5VRCtnJ9KRk3fKDQCHyXfPXioW1EKeuP0p7Wr/j+VYF1bToM1cWiWrHS2+qBh1yamfUtqg4yK4GI3McmCOn8q1VmfaOMUnZDT0OhGsjOwjFWI9WD8Vxc2R24NVZrmaIYTn29qtRTFex/9b5/wBI+Jc+iReQ8u3B+ldTYfF9lYPJKCFzjBxXyF4tmvURJEbINJpdtf3NruRiD1r+fHmGIgklLY9LkXNZI+4dE+Ji32oLMZcDrx2HpX0Ro/xKhmt8yvjb90g+lfk3pet3elXf2UybduK9wtfGs6aeI42w2K68s4hxNCblc6nTpVYclrWPtXxD8SrVCTFKBXN678X7NdKKu+Dj8OlfBWueLtRVS0pIA7+1eb+IfHGqXNqI7ck/TvXrVeJ8TJ3Rx/U+RPQ/SzwB42i1nU1w4KpivbfFfjGGygVInwAvavyf+FfxEu9JaNHYhj1zX0pqvxCj1HTBO75+WtsNxZVjScHua0suU1zH1b4b1qXxAphV8AtgV9BeH7drS1WHrXw98H/FNvCwaRs5NfSEnxEgt7tI1f5W+Wvt8ozmm6XNUep52Iwr0sj2S6nxz6cehrjb/WUR9iHPNZWo+KbdbRZUbIcflXD6TqEepakXlYBB6V7dTMqcnGMGc0aDje6PSUu55LfzM4H8hXF6t40gsz9nEgyOOK0/Eviex0+waKEjITjFfHWpeJHu9cAVsg9KxxmbU6TUbkxoSPrTQ9amvojN1Ge3pXoGnyTNjdx/SuM+H9pAdGjkcDLD+VejwqhXagxjpXoYatGcFImdNotrct/Cc9vpVtLtfuD8a5+Vmi49OntUK3QfKpXZpYy1R0/nREHp2rEu3jc4FZ7LcPnH3fpUsVnITzn0pKyG79iq3BytWLdcdsYxWhHpx3Y6YrRhs0Uc9vSqckSokUcA43KPWtaBGQ5jO1l6YpirGnLY6VKbqGHAFYyl2N4QPgn9pD9gb4cfF15/EfgbyvDXiCQmRikf+g3DnkmSJMeW5/56RY5+8rYr8Ofjp+zp8Uvgne7fiXoclogbbDexYls5ew8q44XnsjlHP92v6tpZt4+XjFY2p6bZavp8umajDHc21wpWWCZBJFIp7MjAqRj1FeHi8ko1nzw92Xlt93+Vj08PmNSl7r1R/Fbrk76ZILhLfy5YSOVHluuPbkf0rs/B3xK0zUiunLIILlyMrIpVJcfT7p+lfvv8av8AgmT8LvHHmar8Jrv/AIRK8bJFq8Zu9OLH0jJEkQ9BG+0f3a/Jr4sf8E6f2nfAU0t43hNNctFyfP0WUXK7R/F5Z2TL9FjOK+dr5ViKWkoXXdans0cfSns7eT0POPtFsrvBPGyIwySBlc++Pun/AGhwfata1vzpsa+S37k8AvwQfTIx+AP4V4xout33h+L/AIR7xPFPpxizGDdROVU/3W43L6cjiuv059dg/wCJlpEyTWjYDRlt8eP9lxkgezDH0rynpoz0FZ7Ho0stvIhe8AEZzkZyD+A6flWjYX9jNYRT6ROhxlEVRyu3sM8Y9gePQVyVzqGnzW2yeRS7fxqcA49P4c/SucgXR7TV/t1hA4lmG2Vk+5J/10TOGI7NjPvSUhtHrdp4j+zN5l3F864BI4P9MfjXb23jCLVY3hktpNsY5kKiJ0Y/j+hyreleVxahaoom8gyNGMc/MQPbnp9KojX7u5PnWKyFAe67UHbrjA9Krn0Fy2Pe9DvdSMjLCvmIozuX5WGP9n29s4+ldbJNFcFJryXzf4goGJAPdh1+mfwrwTTdW1u42CWNrSEDhnI2fkpJ49q6WC4uDIPtG2ZP4X3hgR7EZ4/zinzBY9xPiS0REtorVZEX7pwyOpHPy7cfp19Kr6V8TDrom0SwSVWjY5jUeW+71Bxtz+AJ715TPIpjKXcpaOVSpSGQggfUc4x/dbI7VH4OsfCfhey+wWw+aQsyr9qmd8t2Bk3dPSq59AUT02z8TXNlqg024sXg2HcvAXA9dmRge4IrW1nXLq+1DNqRBGAMmNuGx7Ef41g2kE6RSS3myZnAVWaRskn/AHiOntXqXh22tlt2tbpQfKX5x91UI9SuM/XNQ5lqBzkHiZfDatcywrJdYBUFwu0HgMcYx7VzfiXxT4mvryG81+7aYzsPKtYkAYH8MAdOelXNaeLWNWlmu7wahFjCWqxoI4wcDGFUeh5JJrSk1aDSWeRHM12wxCuwKseRwABkfT6Vk6jeiNlTtqyv4h8Tw+G9Djv9aZZLoAFA52xw/hu4P1/CvniT4karq7NceF7KS9lZj+9/1Man/ZHLH8cV2l3oc1zetqXiI+a55C4yAD/dHAr2T4bQeGbiXylhCcc9se+P8BWkaV0Z+06Hwv4x1DxrDbF9RjkgUHgCI7fp6/jmvHP+Fm3WkkrpWmT3FwThnl4x6HGOce1fvVoPgPwV4hswNTsFlgYkA+XkfXpgYr8+/j34C0LSor6bQLdI5LQ7wpUAmM8ZVsY/HpxWqhbdGcm+jPz9vPiLrniQ+Xr1+Le3BB+zW4ZCPx4PGO2PpWNf6haPvtfDyvCkmP3vnqhb/eBO7FfQngj4d6J4l1VbXWMPvQkZBU+xHbP04r1LTP2Rfh8fFcWpX9pHMLaI3bPK2VVV4yVPTH+1xgV0XjHoYcrZ8dWsT6fp0MurPHfInziz09GlLc/eeTGMfQZPY17d8JfgN8ef2ib4/wDCD+GJTYS/JLf6hMYbOEHAIaTBB4z8sSyN2JWvu74dfBvwrr/i3StNhgDx664EBKAYt7bbvYYwAMsAPpX7R6V4dsdB0q10TSEEFvZxLDFGowFVBjA9K9HKMEsXJynpFf1Y4cyxLw0Uobs+Jv2ZP2Dvhz8ELuDxj4ymXxT4pt40SO4lhEdlYgDG2ytuVjH+226Q926V9+Iq+Zk5PNUViz944qbJUDmvsqWHp0o8tNWR8zOtObvNm1EdoyuKui62jKntXPx3LNgfyqyIml5ziqJNmK9c4JP0FXhMzcEelc/ArDCZ/wD1VoNOEGWHPt7VLLRqfKAAe36UzcikNxgVireM3NVZ76UdOhpJDdjqTdxjhTWZNKjHca5dbycHA/8ArCrX2iXG0ngVahYzctDoYLSGQ5OAa1YtMiZxjoK4j+0ZYeM1oW+tSouGNTKD6FwnHsb8+nRRjIGeaz106F22lcY64rNm1ppRtxxioIr0q2Sc+1JXK90//9f8fL74jT2tuFusbo+o+lek+Ffi54els1hdwHIxivnDxVYQ318IbNNzNz07Vh6D4H1lNUVyNiocg9B9K/CamBTWh7EKdSEtFc+mLi+Ora3mEjHXivUNHhmSZYZuFGDyMZHtXypba5N4b1lTK24jsOcivcofHaX1iAPlcjI4rz44KUTqhh0ruW56n4z0+xu9K8y2I4HAFebeB9E+1PMl+MYxg9q42Pxnd2r7blvl3dc5Feh+CfGGk3VybbzApOM1pyytax0Qqxc1oZGs2UWkam0tocqPu1Le+LHFutvG+QMZFega94LGowNfxElQO39K8DVEtb2QynIjPHviuepRko6kShOLtsme9+E/iLLpsaFnI9vpXotp8YvtF5F5knAOfxr5N0XWbW/3W23DHjHSn3NheRXAawbp0rSjUqw0T0M6kJKKaVz7/u/ifeXdiqK/ygetc3e/GuTw/F5cDEkDmvj+08TanalNMuGPPTNJr4ujbtcxnJPPvXdDNa8U1zGc4Rmrpan1nbfFi68QWO95MluOaz9AuNTuNUFzKfkQ9fQV8peFvED2UAMmVCnNfUnw/wBfttQgM0wABonjatVK8jfBYKlN6n6B/DbXIW0+K1LAlQM17dd+XbwrJkHPpX57WPjtPDT+bv2r+X0r1NfjnYXGlMJJPmIxivrMp4jlTpezmzPH4Cnz+6fUGrXsf9lu0DAtjn8K5zwrfG+ldZMHaa8H8N/ESDWrd7ZZN3brXQ6X4qi0q5cs4+bAr6WnxHScYu55Ly2bd1sfSyXluF5wFXiq7anHu/d4xmvM9N8Qi/G4t16Voy3qr8ucDvXt4HEU5w5+Y5cTFp8qR6Cmqx4wOaedRG3D4GK4hHbG5iB29q344EuIVZD8teipwZycrLkmqpn5fzpFvvMxtPHpWBLNaK3k7vmqGC2kD4QcA/hUqUZPlRVnFXOunu1WMbecVFFfbnVR0rMWBh875GKepMYyR+lacmguY6JJVJAHapZCG4B5GMEda5f+0No9KcuqZwDWTjYuMj8HP+Chn7DWpad8QR8YvhZq8sI1qV5LixMpDCUcsY1PylT6cV+cd94A+I3gfT31a4vBNN6bApOBz0x0r+hr9t6DV9R0rR30e4eCWEuwIAeM56hwe30r8qvii/jZPDqR6xb22Am0NHkL83r17V8Hm1oYicIrRH6Jk2CjUwkKkt3+mh+c1j8aLZ7t9O8XaS0EhbDT2vzrx0LRnaT/AMBr0rTIL7xPpM+ueE4/tdra486e3jkPkg9DINuI/qxxXhnjmyeHVJp5lC54ypyPwr9rf+CMdmo8MeN9bV8EXlva8dCBCrfl81RgsLHFTjGHu/ic2Y3wsJSetj8z/Dsl3E/259VNzbn+FIww/wC+lJB/KvRY/E1jHcDMqRKOSAM59MjpX9BnxQ/ZU/Z1+LE8t54v8LWgvpuDfWObG79v3kBQn8Qa+EfHX/BMCSSZrv4XeLwAp+W21m33sB2UXEODgerRmuvEcP4mGtO0l5aHlUc3oy0lofmLq2ratrubXRJoLeJjtcfdDD3GOPw4rt9KhtdH01LPTHVvMHzNH82Sf9rt+le+eIf2C/2qNFjYx6LZ65jOP7OvYZD/AN8zCA1wJ/Zx/absgFu/AuubV/gFtCQPxRzxXlVMFiY6Om/uf+R3wxNF6qa+9GBploUKTMnmMP4cgqB68/59qtv4h03QmE2pt9iGfk2AuxB/2cHbn6V11t8EP2l5kWOHwBrcmOBmBIh+bsBXe6H+yf8AtXa7L5beCZLJTj95fXdtGD9dsrN+lTHC4h/8u5fc/wDIp4iivtr70cjpXjDSdRZWjidAFCiRwVZv0U/THSt7V/GOn2mif8IxoeJJpABLtcqq5/vMBn8K+gfC3/BO/wCNWrR48Ravo/h9DyfKaS9lAPsgiH/j9fWnw8/4J7/AjwxbD/hNJLvxPOTlluG+zW2f+uMRBb/tozV10smxlT7PKvP+r/gYzzTDw2d/Q/Iqf4l6JobNptjNHu6eXBgE/UdSPwrgNX+LqRNvW6j3/wAI3jd+X/1q/po8K/CT4R+ArMWfgnw5pelxqDxb2saH88Z/WujNro8cmY7a3U+0KD+lelT4aklrU/D/AIKOGed3ekD+VW28deJ9ZmVdOW9uZBzsggknyB6bVY/pxXovhPxx/ZGoLaeK4J7OYN9y6jaB/oAyhh+Vf04q1rF88KohPHCgcD6Yrj/G/h7wV450yTSfGel2uqwSKUK3MSycY7E8g+nNbSyB29ypr6ERzez96Gh+SPgL4u6Pp0RdrxhLGhC4OJOOnAOCAPYZFfJnxy+J3g5/Hun31xNHHaa1ObLUNhwqvcKQjleAquRg4x83r1ql/wAFDPg14c/Z4m06/wDA1zPFp2ot9nijdt7x3aqZCyN1RQo6dO1fmpq7zeJ7Vb/xVIZkkUKZVUhtqnPX2PTivLeGlTlyVen9aHp+3U4KVNH1V4Q8X3ul3F9oN7y+m3Mlt5ucFkU4RgOx2EEH0NfcWiWV3408Hz+HdSuU01b+e3udfvpchLXS4OVhDdPMlAA2j+H3Ir8+Pgp8LNW+IXjSw/sSO4v7++niihaXhXb7qbvoBk+2fpX9LPwT/Zd8JfDzQbaLxi8eu36ESlXQfZo5PVEP3iP775PHGBV0MHUxM7Udlu+iMqmJhQjep8keQfspeCdX8W+Mrz41alZPp2gWsC6Z4ZtZU2yfZo87p2B7yE5z3yPSvvxYI1ADdq2fMhUBUAAUYXaOMe3tVfC5zxn+VfX4LCxw1L2cD5zFYh16nPIjtrWJ2we3GKZqNrDCBgDPtU4Y25yOnes+5kE7HHb+ldOrZhZJGEk0URyx+UVb/tKJVwCKzJ7c/dxiseezeIZx+PvWqgjFyZ0n9q72ODTPt7OMZ/WuaihfHWru3a2xlpuKEmdTaEE5z1xxitxLW3uRlQK462lkTDsPpW3ZXHTJyf8ACsJXRvC2xpHSlj+ZQB/KlTTiRgDj29qWa9VVyvX/AAqzY6lH0bk/oKz9pIv2cTHutNcHPp6dqh+yLEOTzXQXl9anj8B2rnZ7vf8Acq1Nsl00tisYos59KWBVd88c+nasaaaYdqfppuGbc4+XNU4O24lNLSx//9D4CuPhfo2hXqXd06sxGAOKs6x4csV06Sa1i4PAIrA+I0txFfRQlye59Fx0rrfDXi0XtlHYonmgYDcdBX5FDGU+XVH2McRBux886P4DTxBr8j3OQEPGRXs/iv4aWeheGvt0W0FU4r0T+zLG01NtQshhYVy3FcrBqd94vvZLXUPktBwgPQ/Qe1Y1a9O/KjrgqS92e58vabdaXqUbWWo/LyRz3xVfRvCE9lqf2+0Lbd2BX0XqHwKS41QapAcRA5UDvXpt/wDDE6ZpULWwH09Kz5YrYmeGpy6bHGR+IpYvCyWZZjJjHXmvnZ4ryC/kjv8A5UbkH0Fe96j4M1ltRjmhGEPJ+lclfeFjf+Jbe1lI8vODjtXPWpRlqxVlBxT7HmEuhtbkX+m8Mfm/P2rq9FuLxG8/UBndxwOuK9b1/wAMWNlOlqjADHBFZcPg2B9s8R83+IkHgVzxw8Wc9Pkb0Z4N4t8S+Rfq1pGcqR7V2XhjxIutReTfjaMc5Feh6n4I8PXuxtufXgdvSuU1jQtLtpY7Gxwjn7vaqr4KFtGRVwbUudP5GwfCdjPD/o5AFWfD2qR6Ddiw3cA9jWVHpGt2NusMM5bjnPbPpWRb6fMk8l1csRKDwfauV0JRWqN40ZRs7WPSfG3id5bQC3fO3j0rjtM8R3rw7Zt2PY03QfK1a5+w3oKgcDPatz+zNO0m7+zyN8mMA44FXCnbUwqU5VJc/Q6vwX4q/wCEcErtMQSc8mu6X4mvfqHjkz6Y9K+ZPGujCaVRps+3JxwcAiu40Dw3LpOgi+kkLYHSqfM9EXG6/d9EfUvhf4vz2k/lTyV6jqHxjENvG46H+lfEXh/+z77UFcv0OPxruNQv7Rbj7GzfLgcV20M1r0ockZHO8JCp7zPvLQ/iTb3+mI8hGSAfpmqer/Gmz0iF4Y2/I9PpXwvpniXUtMm2xuRETgZPFbMGoR6hIrXjY3Zx/wDqr0I8SYi3us51lsWvM+1/AnjKPxHeiWZiFzxnuK+obbUdKNqChHy8D2r8voPGX/CN4SzIzjA/GvaPDXxSlmsFSV9p64NfQZXxAuTlqPU86pheR8tj7WudTsuFjIHFZq3VvJJt6gelfIN/8Y7ezu/JklweMeleu+GfGVvqtj9rilByuevQV9Jgc2pVpOKZx1qdj1y8e1VQrYxWVLeW8K5BBxXjsfiiXUb9oFb5VbHpXqFlBa+QDM3NdlHHQm2lsiXSdr2PmD9rNZm8BQ61aR73tJcFT3D9q/F/45+O5ktLa2gMiMUw8bAYGRz0/Sv3g+P0NjrHwg8RaY7FSbMsCn3lKngj0xX82/xWutauNbbT7wRfuVVRInBfsCfSvj+IkvrF49Uv6/A/QuGKr+pcj+y7Hzn4n0uLWkVLM4AKjDDB/H0r9+v+CTXw0m8K/AvVPEE/Ka3qrtHjj5bdViz/AOO1+JH9izi3ZgAzk7QAPvN2Ff1Sfs9eC9H+EvwX8N+BrLkWdlEXJ6tI43OT7kmjhlynWbW0V+ehz8T2jRinvJ/l/SPcY9Iic5P/AOqnS6VCuAB0FQ/2wMBR26Yp0ep+acnivuFKR8NyxI1so9wXH0qZ9NXb8ox+VQR3DmTLLxx0q82ohG6cDmm5sSgjDurB0+8c/SsxFdPlQYxW/dakk7BDWZLMp4IzWkZu2pMoLoV/tV0q8DHWoxNcqu484FaVqYXAWluPKB+X044odRbWF7PzMybVZkjwSfSs9r6cLuFdDHYRSw/KMevFYMlk0cm1elEJxegpQaCO/OApbGAKy9b1vTdF0y41nVZ0tbW1iaaeWQ4SOKMZZj6AAVflt3DZIxivkP8AbdfWIv2YPE/9m8ALam4A4zaidPNB9tvUdMVGIqKnSlUS2X5GmGoupVhTeibSPxv/AGm/ieP2vviVFrFgGh0PTleDSoGHzmJyC00i4yskhAO0/cUAdcivR/2cf2XB4m1OMT3SfZjtQR+Xui+U4I9Rwa8q8Af8IRdanGdZ2xS5yfOTyn57K4xzx2av06+Buj+ENM1C3urTU7xUADRtDdN0OPTcD6Y5r8txtepWm5VHufsWW5bRpwUYR2Pp74a/sq+EPgddWd7p9pAblrx5FlHOxVjY4Hp1FfRsdxMpAGcGrFlq41TS7e7vLprny9/kpIE3YwF3EoozwNtQm/tgwIHP8sV9nwlSVPBNrrJ/ov0PhONV/wAKCh/LFL9f1NS2mmJwTnt7Vth2RV3dDXLW2qx7vkq3Nq+9AOB/hX0jnqfKKGhryt5g9KoFvK+Uj2qkmobxxxUE94mc9x+WaE0LlOks9OW6KtnHapdU0mIKB96sDTdZMPCkfNWs+pm4XkjFL3rle7Y537DIhwo78VbhsHxnGMf/AKq2o9sqqM8EVH5yRtij2jBU0YUlu+78akWPGBjFW2hDyF+3FQzqsC5J6flRzhyFZ1ctsGeD9KaUdc88VSbUIoXGDVa71yNOF709ewtO5vRRdVJ9q0ltFfqOK4uHVgGABzjtWsmvRD5ffHHTipcWUmjpTpMch5Py+wpW01IQSpwKzotZ81SIuKstqG6E7j2qeZorlR//0fzr8I31xqgmk8RIpB6O304xVnSvEWlaDevGijDvwR0ANfAf/C2vFWtTJZwOEto+cqe4qM/GTV7xD4e0tUluOcyOfu496/DVhqt7HsvE2jGKPu/xv491nRbg6Lo4WcXWAxHbNMe5uI9Q0+CxJXy13S9sV8dfD74g3Pgq/e912dbp5evzBsY9M16FP8etOudTcFQTKOq46VDpSizRYhJc83r27H3frPivUNI0GDUrSL93wCew461wul/EbxDrVvcapD81vF2P+FfGmpftEzXI/sS6k8qzYYAzirXhTxT4g13T5o9AuFt9POTljyx+lbKm/iegfXJVZ2p9j6V1Xx7qSuiOWWOThttcL4u8e6b4Y0s36Slrhh8oHXNeQWniG71VZId/763Gz1GKoDQB4+RrHUG2yr930GP5VCjd8hNOtLWB6Dp/xLbW/C0l7POBOM7c1zPhj4t+INPLae0jSGQ7QTzxXF698KZNM09Rp0pQrglTS6T4S1STUBJbguIcYIHpWM8O1sc86VVNWPrjw/dTtb/abh/mIzj61zawJruueTI22XI6entXE2GpeJU1COKeLbFEvPau50zxHY6PerPdxhZZdpH0q6T/AJuh6cMVyWvseiHR10Zg9zMxwM4JyAK8d8dePbKz1EWtjGWXHQV2ev8AiK1vdVhtbqXaki8YNdPafCbwtqlg08cqvIw4B5PNdMKnM7S2OqGKqVHyw2PKfBXidbyb7PLw7Hp6dq9nHhJ9Xh87d0HGDWT4a+ENjbahJ9kflR0NSa/4nn8GXiafJG5A4UgV0exT+FHox5eX94jndU+H+tD5i7bcema6iLVmsNCOmahk4Xbk+1dJ4S8bHWiYruJo1GByK1fF8/htrHyEADMOBisZUrbGEqEIpuDPmDSnuo/EZbTpT5Xfnv7V6yNRMbC7uCfl4+bnNYGkWNjpEv2uJdykmpPH3lQ+Gm1GwcbsbgK8nF0uXVHDKg4QckzsbfxZo9xH5G8bgMYrsPDto2u3QMHEaDrXyd8MvBPiLxxIdVMvl7G459PavqrwXYXnhyV7W4k3Mo4rlpwlHcWGjOfLKS0Ne8+xRaz9guGDEdD1qn4k1NvDFkbm3J2ryPwrldbmvE1wX8ildhz7/lXdalfWHjPREtIEDZAVsV1Rk3sdFWipJ2PlDxN8U7yR/OcsF/hPrXvfwm+OVxb6X5dw5x6e/wDhWD4o+FXhyXTAs+A2MYxXn0/wxfR9Pa50iXO4cAfpXVS9vh5KrCR4v9nVnO+59xeAPiONR1Zpi2U7HoK+hB4+tE+Vph0r8stP8aHwZoTF02yjg44P4Vc034nahrKrKJWVeAAfSuyjntWi9DprUYqEYNan6HeMfGdpe+ENaijfcXtJASvOB9K/D/4t6LIk/wDaEKYWf58Edh+tfpHoGutdaVNpgIkEsTBgeBXyz8StB+1XOZFGyNNvOOM9h7Gul5lLFRU5dND6vhmh+4qev6HzR8NNCttd+IPhnw7Ou4T39pG4HHWRSePoK/ppXTt67YPlVPlA9hwP0r+e/wCFmnNZfHfwzdbPkhvon+gUH+Vfu1c+N7GxtkldwrP6V9DwxioUfapvex5HGFNudLskd5OBbLsc+1aun2zbN7nH/wBavLpfFOnS2yXTSD8+Ku2HjWC/njsrJsg19bWx8I2Se58hRpc26PU5L2K3b19KoPfRSkZGaovbOIhK5yc/hSRLtXcR/wDqrspq6uRNtOxu2lh9rO8fT0rTl0lNm48ACsyy1a1tUKSnBq5NrCCL5COnak3K9kUuWwy20xM5U9fyp0tiYyTnOKz7PVyjYznHpUlxq6ZDEg9sUm2mNJWNKNwqiM8kUx1gbn1rIGpxs2AMmlN2sg2scClysE0QXkZzn07V5f8AFPwXH46+Hmt+CLlA0erafc2ZXpnzYyo/XFesEqZAeKSQqNhHO05H4UnG6sxxlZprofyfeD9c1Xw9qCQ36J5i4SSKT5MOnyspHqGBFfo18C/GNveatAq20du/CqTs3ZHHBZR7d6+e/wBoDwBZaD8efGHha3RFgh1aeSMN2F0FuOG7DMnSvf8A4C6JDp0y3Jj2y/6pXjhBXA92BFflOOmqU3F9NPuP2zKuapCMls0mfq1ol7f6hp6zzvu4CL0A2qBgDHGB2xW09m7qJe3atfTNK+yWMMbLyqjcMY579OnNSTxMIyq/pX6dldH2GEp0V0X49T8hznFfWsdVxHd6ei0X4JHOD90eBjFR/aJ2kyXG3v7VZaOSRioHK0r6bJGoZwRxXoN2R5aRHcaqsKYB7Yqg2rhlznoelYmpeb5uxe2PwrK2vjA5q4JJETbO0sdUVmLsPpWgus/v9mf8+lefKJEGxfw4rX0yFFy0vUdCapysSo30PSrbVFQhd3ao5r8l+DXFvfQofLjOfTFaMLeZgnuPrU3RVuiOuhuyyladMfMXGcDtWLBLHCdmetbAkhLK6sAeKm6RVmYF5bEuQg69qxX06beNy8fSvSre2t5vmb/IrTXTrYjBwQBTVZIXsbnnSaaIVz3x+tZs8JaXCnFekXVnFjaOKyItKzl2wOfzpqogdPocyt5Lafd/Sqsurz4+f9K6uXTVCnjPr2rKk0cOCFGR7U+eJPJJH//S/k70Xwx4xGsDSsyLbbiruuQAPWu6uvhpe6PfeXY6mNsvRgefcV7jqPwb8ZWOjsbfUnH8TkJnAPpXMR6N4S0Tw81tqV9O92WxvYcY/pX5vJtK+nyR71HARtyyRymqeCItGtEuXvhMHUco3QmrvgTwPpc97JLqmp+So6BjwQawNFufBF7qT+FnZ7p2OQwNenaJ4DstklvbymVNw3JjBVaxqUZWt+hcsFS5lK2na5ueLfg1Cmq2lwbk3FoF3J5fcY7muD8T6lrulSJpWiebCmflUdz/AJ7V6/rfibUvCcsS+FsTRwbUdGriLD4h6/fa3Jq13YRqi52hx92uH2ber2Rw4iFGPu09DuPD3hnUtF8O2Pi+JXmkvDsmBPK44rP07V9ZtfFSGYhYlzyOPwqCx8Z+N5XDFQlg7EOEXARfYH2qtryWmh6jFdxSeZDOd8ZboR7fT0rkr05JrlMKmtnT2R7f4q8Qyz2UOm6eyySzkKcdceldCNSu/C9qFgAEjR4Y+lfIyePL221P7dOjZ+bZkZXis/UvjHf+KRJZ6dDJ+5B3kDHT0q4UJyvodEars5deh9QadqereOtUTQtJulicE75Acjj8q6PUPDU2l6gtkbkXLxgF2B9a+DPh/wDE+Lw/rUiGXZJOf4zyK+i/BPxN+xyahPqUondxlWU5z7e1YzwM6bu0bUIwnG0viPpDVvDtpDoSXW7zZ1+ZVJ6e3+FauhajBcWkGoJefZmXiSHOK+RJfiLrN7qRna5byI/3ixL936V1GleNLzUf9PnsxFHLlSx5X61k6FveaLjU5J3ij6lv/Fh0fxJb3um6grq/+tAavQr/AOIXhHUIke9jDyADrg1+dV7pWr6brJutPtpL5SC4CHjHtW5o/jCDU0Gk3UMtteFSEEi/dNdC9pH4SpYytF+8j9BZvE3hoaf9q0eESEgcLyeleUya7fah4kQTRGMMp2+leX/Chp7GF5tQnCBScIWx09K9O134k6AyeTbRAzou1eh56dRXOq0pfEbe0lOKnN28jivE3xPit1k0h7YhA5G8D04riNTuvFGtaRJe6OpkiiOPKB5/wr0NI9Ku9JkHiMJFJK25XPqemO1dJ4W0PS9D0uXUdNvBM5y2wEc/hVSoRlG8jD963yyeh57pHjXxT4T8HxpFC1rLIRn+HGa9D8GeNvFMLtq96vnbR3rj9V8ZWviO5bRLy38naODjHIrqrA6npmiZ0zbdRAYJTG5fwrhq0FtEVOXLNNy0R0Ta9q3i6/dmAhX06Ctjw3qN5oF+2lMTmXJQ/wCFeTafqt7qEvlAqhBycHDdMVNr/ipdFuILi6OJrZvlHqO4zQqfs1qdXtIqHOnc9L1218Qahcn7RIVhBp/hW6jtr7+z52L7jwO1Ubf4naLrultcKwL8Lt9Kv6aml22mPqyOvn84Xv0ro5tkCxeqlA2/Hnh/w55a+ftGSM44z9a5JvC2lS2udNdQ3UYptv4hi8WwvZ6i6pKmQB/9auT0XULnSNa8m8b92pwOQR7Vy16XWxjUxqlUvbQ9e+GtlqI1iTTLtWkjWNuaxfGGkn7bhgFiKsenA/Hpiu8+E9zPdeIL664e3jjHIOMPJ93P4Cl8axqlveuobaISEbsT0rrwdNU6MV3Z99w3D/Y5Siur/wAj5Y8Dx5+JWm6iPl8iReccDIPtX3V4jv5dYsPMtrkjy1JUD1r5B8P6FP8A2st478oyZOfujpXuUfhXVbDT5Lua43pk4OentSrOUZPlZ5vEND3qbktLP8DyrxB8W/Fdjdf2bAzFU4Bz/Svof4HfEi50+EXWsMTIecmvnHW7uxsNhvEVSDwx5/StXw1JdXNyGtAFjxWVHMKtOopp3aPl0qfwn636B8SdM1zT1dnA284rQfx1orHyUcErXwD4W1K9jjNq0uwjoM8itW78S/8ACM7prybfnlRmvqMPxjOnG00byymhKHtOY+n/ABn8R4NPVfIIAx1rW8G+OYdbs9rSemPevia/8YPd2JhYfPL3PbPSvONB+IfiTw54g+zJkQ8U48ZSdVSktDz62DpKygfq9vnhtmmjbp6UzQ0udVkPmn2+mK+UNI+Pzz2ixzphOBntX014e8e+HLfw+L1XXzpB0zX0OE4joYidou1jCWBaWh25sEacRK3zHsKmvdNk09RKxwBwR9K808N+JRdaubp5AE65J4rttT8U2urn7NYkNg4yOlevHHqesXoZPC8q95akkt6Gbjt0A7e1akFwhjzIcnpXMTC00y3M10wB6/hWZp2vLfOVg5QEDPareOpNcqepEcNNPY/Kr49aamr/ALU3iqe0baHu4FAP/TO1iDdsdRX0j8D9BaOey0x4gIzdA8f3V+Y88Y6eleVWOk2/jP4wax4h+0NGdQvrkqyj+AEqp6YxhRX2L8OfCUmk6wguB81vG25umSRjPp0r8srx+s5tGktnP8L3f4H7bQ/2PJJVmtY0/wAbWX4n1I91bPFuXr6Vyd7dIr4/SsM3D2ilmb5R39qxEvm1G+8m2G4DjOfSv1Z1owe5+IuDktju7K4tEO9vvdamv9QtNvyjPHWrMPheT7B9oLc4zXG3ttM0hhAPHH5VSmp6oHTcdGQ/abO6fY3NX49Os5CNoHFc0NOmhlyB+VXreS8/gGPrWzl2ZilboXrnT7VOIxz7f0rDlsQGBPatkRzfec8VHKJGbb1+nApxqA4+Rjrb+Vk/3BnpVf8AtVrc7R+la108qwl9hzjjj8K5Ka3vM7tp/LpVxae5m1YuHVLlieMbq3dJ1e4ZvnXIxXNh2xtZOQOOK2tPIX94qf8A1qqT0sEVqdHdeIZLMZxgUyHxbP5eN35elcpq0hdP3dZemDzZAsnGPSoVuW7Ret7I9QTxI0i7ZMAGtsa5AsXPJryq9/0cAqc8VkveXsw+UED0paS2HqtD2f8A4SC1lXauP6Cr9rf25PqK+eF1KRJCueBwfauih1SfAY/SiULBGR//0/w21v4u+Mj4+svDOn6Xt0t2KmYL+6I9z7Vqap8JLHXr99VsZGWO5RllhGCuemR7fSvaY/CvjK5v126WxshlcRYBBGOeara94F1BLCGbTrYJO8v8MpB2dMbT3zXwDskrH1zR4doPwD+EXg7ybnxHsj1CRtsDFiOffpXQ+F9S0fQbuaGCww3mbGkYZCr0ya6TVPCV7Nb3tp4jXzrK2t/OdXj3qqjoQ/8ACQfyr5u/4QvXtR1a70q01LyIDETHceZwjH7q5ycjHt7Vw1+eTtzowlFppR0R6L4s8JeC/DmqHXb3WjNPdEvsX7qknp+FaMkWh28D6g8bXMKQKI5No2kseCfavP8Awt8HvGmt+GLuHXpWkurWQDytnVcZDg9CPpXZ/Dv4ZSxxTL4u1qfT41i3WzY3RKQ2Nrr0HPAPSub2bi3zPTpY4nCUZ/DvsedeKPCvjXxBdLdaEgtBckLGrHA2j0UV1U3gU+E/B8fhDx5O11dSt51pLtA8hsdCf7p6fpXWpq9/awW2hRGN9QtpXaJpFKmUbgo28dOau+Dd9hrOtw+Ib06vcatJ9jhsgu9YLePmeTk8KOgxznGKr2y5diqclpzI+aPEug6fa2Gnz3NxNKFl2yxxDK4+oq14Z0Hw9fapJalZLNI0dtoG1uOnbHNfRmmQR+E7u5tdMsRdRiNJHEg+RJCcqMnoduOKr3X9qanpza5ewwPJv8mSWDDbAfYV1wqRcbHTCpF6s+aLfw/4I1q4+zRaeUukcrub5WdR35rubLwzpd1KujcWksfAx2X3r2S7+Dvh6XSE8ZHUFSHoGlJiZWXqP8MV4Po2j62NcuP7Aifud7ktkH26mteeFtWatRTWi+RzGtePNO8DXsmn6RZ/a50++7ABcDg1la78Q7nxBb29tGn2XzsEImQPw9/pVm28P3Gq6vc6deurXEMhEhC4GfSvW7P4Y6msBudSEMMMYwkjgbf/AK1EqcLbA02rI4rWPF/xK0eSBNFhLWqxAbmXIXPvXCa743jhV9V1e5e3ueOQB079OlerTaD48jneDRRhCvzeaMo/pjFcxpvwO1m91SOLxO4cvl02D5ST2+ntWCwkZO8l9xM6V9L38jS8R6vD4A1e1bWblp49Qs1uLcbshkOM4x+FZQ+Lq2NksNrZukYY7mbG0jtXpzfCi08Vaba6Dfwo0+l74g4kGUiPIGOwHp6Vk2nwwhttObR9QiW7DyDawPzAdv8A9VY/UqO7MpYd829kbWleP7DWfDR0++xIr/d9QPSovCnjCPSb97fTZWMarllc/wAqop8J5DqYtrS3C4xjcSuM1o6V4Jsv7RuNGuJPszxfKTjr+NYVcHBddDW/LZtbGrc+P9f1HVXfThFMijvjI/KlOv674c1WHUrS58tZBh7boG+lRv8ACf7Jb7/CUp85TtlXcGVj7e1Ld+FfG0SobqwDva/Nufpj6j0rklQUfh2MaqTjtc6qfxlr2tWzajpenRjy+XdDtIx6jvWS9+vimweDSxLcagcAR9gB19qqQXGo+Y+pzGK0ja38r92+PN9Tt9RVrwN4d8faRcxeINJK3tmycGFvmCj+RxWbhFnLCnzSstUcwnim30OOXSzEY5Yf9aB1yKu+HfiaNe1AWIkdEgGf94DsawfGfhe61nUZPFmhxzxadduUmbblklXgj6VV1bwzJo3hxbjSYWeQ4Z3AwzLURwkZa/caUMLUlPl6L8jorzXfEF5dS6vp6vBFCw2sON2Pb0rY0bxFqU14P7Z/1UjD5s4I/D0rzTVNN8banYRXHh/ENtEFWUSnaK5rxfpHizSprfVAMAptxFJu3v2CqOc+ldEcJ7ttjslgKVP4os/Yj9n3Tbq1+E0+tTRjGuahJPCxbduhgAiHToARkVq+LrWQaCLaKPeiz4ZsYy3b/wCtS+EfBnjf4bfDnQU/tgLepZQ5tHUGKPK5ZeOh9a4LxZ4s8X2NnNPq+nxDH7zCtheOmBWNWny8tPsfqOUYeNHBwiuxD4c0aa6mmnygkOU2YwR6dqoeJbjVdNj+ztMwQKXUHodvUfh3rr/hDe3+vMqmPajfvMMM7fbNcJcNb+Kta1vwNrE4SVLyRbZydpjkPQf7p9KznGMvdZyZ3lMsThrQ+Jar/I8ZtdRbx3qR07ywXgUkkHHStP8A4WTpHhbwm8DKIrmFioyecjpXzJf+Htf8EeKb6fWXuYvs7Ok/kEheOn4V0uj+JvCPiDTX0+6i3XikFfMIX5B0A/rXnSwzjoj8rjSn8DVpeZ7lpXxNWy8Px+IbyRlklGVVe3pXJ3HjbxJ4muxr0okktlbhQDzj+lcb4q10W+mW7x6YDaWn3grbtxx2xXqXh345aGnh628PS6VlpwFMUQG6Ncd/an9RUktToo4WUnySnZJH0x8OfEOk67p/laxGAQvGcZGK8/8AFE2gR66I7mfyt7bR9B0rP+HOoeFRaanfeIGayjt3AiZmBLE9hXBeIvsGs6rFLdncE3PHwecVh9Xs0mdtWn+7jse7aPpa+J5DoulzAMq8EcA/StRLXxN4ddtNeaUeWenOMf59K8E8J3XiGXxBFLa/6MD93nbnH+elfS+p/GGHTvDj6frUCRyfwv647/jWvsOVHVhsNBxcpu1ia01vxH5bW/muvlgHK1reDPjLd6BPPZ3YLyRdD68V4V4X+KghupTcvE0N0fKAfjBrJ1v+1PB+uyz3UInsJ8Mk68qN3Y/0rohja1KKVKRlWpwlaSPedb+MXinxDFMWfyYlOBnrj/8AVXYeD/jIT4fv7KDjybd/n75IxxXwD4x8c3ZmW109SyzH6c1678MpJZvCepSXcbYCrGSBk5PJHQ9sVGCxWI+sxfNp19CMDT9tiY0UfS/wP0Q2+qHULX5/LUbl2h/3Z43bcZ4JxwcjFfbJlstAunkeQANbo4H3fvZznP0r5Y/Zo0G81nZ58zxTiItGrFgJfmAAB/hb0HQ+lXv22vEV54M1qy0bQgyTXOmAn2G8jnFPCY2VHG/WLbX/ACsfqXEsYwyaUOnu/mjR8bfEqNVmEMvyjoVr1T4b3gutGN/gbiP1r8m7vx9rkumwWphbzB1GPSvo74WfGnVfDunJpN5GWXrk9q+gwuer6zz1dmfj3s+ZWR+l+jeIruS3aC7b5E496rT6lbyz7BnmvmbRPiLF4iZIY5RCpOWx6V1Nx8RNIs5BZxuCIioLetfUU89w17Rehg8HU5bs96uYrZYPlPOPyrmAQuUT6cVRGtNd6UbpTkqCQB6UnhDWbbVpWjmOw56e1epTxcJNW6nNKn0Lv2+GJRHKD6Cug0uexAE0+B8veqmpQ2sOWgHy1wV3rEf24ab0ZhxW1WpGNr6CjE9Wn1/QoU2kqc/SsSTWLG6bdEoPuK4g6Sc75Bkf5/KtyWW10TTmv7ocIM+nPYCtVGKV7mbnrsLeXlhbPjZhvTvVX7ZGxGAAO1R6HotzqudY1IbQ5yqn0PSuhk0uzV1gJCsegPrThVQODexylyV/i6HkCsyDPm70HGcV2F14emj5ib5BUCaK+1XVcA9a0dRIhUmVfIingx6dMVmZSMeVIPYY/pXXRabDE3lhgFxg8U+8sLeCPcArDtjtWSkr2NXB22PN/wCysyFh0zxmrcQVIihGM9/pXdxW8TxbioPtWNcWUVxn7OeR+WKt1GyORJH/1PgvVviFdarZW9t4Wb7PeEEN5EijPHAO7BBI6cdK8i8cWp1jw5Hpty7adfLL5lwspZzJnhGUr15xkCqPiO3t9Dki0a3nuJhLCHeBIYgvHVgy/MCGwN2cYPNZmsjx5NprWWk65dJFKuVjhjWSWNpeShk2qeuOv3T7V+d1IqUHGx9lON00c/4Jk8c+C9K1G3uroXSXCMEtbuTy0kEq4dC3O1W7Fwp7CvBddY28z3iWsmivE6iCBXWSM855f2HC5Fcb4w8H/FHVvENtJq1vLHDCp/efaX+YHbyQuNz56E8ewr0f4ffAbxbIus63e6eqR2CxzXfnTt5kaO6iJ1GGRmZ2CMvGCcjOMVw/U7Rvf5aHnVMNOaUI30/rsYGk+ONTjv3tv7ZntYU4NvdRsY+e6yJhlI9SrKRxXuvhX4u654Jt7Aa1HBrEhjlRbcgYktmyQUPCknH3SQV7elcDqnh/wPYXJ1fwdO+r6RG4humvTADbSsm9kijhjbKox/dE46ZPpWV4U0fSta8J317o2m3txfaJEZbqeG586NN7D5J4zCqQttIchZshSGHpWNWhO1+iJVKvDrscD48+N0Vx4pu7vwtpgt7gMsZkcti2tm+ddpJ74weOK6fwZ4ge31aPxPAyPMIVRZGdVUQzkMTtPc/d2/7NcPF4g8MyWk11qiQI1uWdobpnucQ8YZD8rnb6qW6/Sq/h7V/gXf2cU51uz0NlkM6iaG4QFhuGAyx4I7quWPtVxpXivdd0cVGnPnTcv0Pp/XdcW1trbwuIPO0+W5NxezRyqk7h1GCwzhSuejFfSuTbxHY+HtB12yu5109ZnTZPIvmAI+FTGM43Y5bpzXlmlaPJq9m83hXXba6vbVnFu0pi+SIYO4x+Wspw3QZII6qMV6VoL+LbmBLD4gKl9e3FwlvBHbWuXe3OFcFkG3AY8O+EA64xmp5dLSOyo77q3Y9G8O+GrvxT4UneOKV7GC2tpI1jkDn/AEk8ugbuMY56Ctvwd4k0L4cakbNtFu9X1C2K2x81lTCMc5JH3SB3rzTwv448M/DG1l0/WtTS6t9LVhpo0m4USwqMsVlkdSPlG0qhBGc9RxXUx6r4Xm8MXPjKC0t9QvjAI55lO9mmcgoELlQ0jqQMYAPXgCqhONrPY3oYmnCKa+Lqjn9U8Uxa7qlwUgntILiYiC0ES+YmehaUYL5PRuBViyP9t3UljrV25jQDbblGXIXrl+mRXaLqHxP1LS3tNH0KzELKC0lw6RW6k44EhO9yBxgBVz04roE8GXXhq2t9X1LWNM1hLwGa6t4RvawMXB8zO0ANwFVc/pXTTrU9zs53JbaeljntL0kw3EUJtpYrWVGVTJ8gQgcZ9ePStnXfhl8QtD8MJ4kt9NuFjOWtpJJNylCPvquc/SuJ+KkOg+H4LW/vdQSMzJm0iLCPb335LY244xge1cVP8c/GHhbwhJoFrqtrdabDFHNFsf7RPEzHLADJKgegP4U3iOa8aQUpUuZxm7WOesTfXdjf6Prc32a53ZgfiMvIegLA8+mMV514f8ceOvD6Xdjq7Nvhk2/MPM+UccdxXovh7Ttb8Xebq+sWqW+nM/nruh2zyMBwyIOcZrd1HRdesVMQv7ZC2Gi8yIFz3ILcEGtI03a0jOuuf4TzC3+MfifRLsG6kRIDwJTllHpu/u13Op/FC3k0uRbi3jBuSS8rcxsQOCrDnB7cVir4Nv8AxPdzWETyGSIlnEFvsyMd2IClf8OK8X1LwhaQ3msaL4m1W4ltNKSNwlnG7ykyt8q7Xwq+56D6Vzywbm/iPLnQr7KWh0+mfGi0TUGt/D1vJ9oTJaONmmI44IAHAz6ius8OfE3xt4lghiW01FpQNsuLWcpn1xtxjscdK+v/ANnN9e0LTbaTSnh0t54hMsUxgW4nBGAzhccAYx1zX1DqelfF+5vIrjTr2Y/IcINkQVvZRwf8KmNCK91RZ7uE4bfs1OWIS8rbfifmDqHgj4leK4Lq3tPCeqGQxeYWhtZVQOOBt3KOGra8JfBP9pLwsl3oWiafqMKCONnlzGiiQjLKu9h9DxX6EyfDP486rP8AaJtTvwJRskIlYbh6YHFUH/Z28eNIY73UXi3DOZGZ29Og6ZrdYCFrNM1hkFGMuZVXfy0PmPTPhV8ek0iCG7jtLNTjdDcX0ICPnqwXcKq6/wDDHWtVs/sHiTxppdo8LHa0LtKU9chFAOO1fXVl+ytcXsqWYvpLu4OCyopyq+p7DHua7Q/s7fCPweN/ihptTu0XJtrZwqDA/icD9FBolhMPR96ei9Tvw+TKXuUuZnwxBpnwxsdKj8P3Wvanrl2WAAsLVYi59FDbmP4CvoLwB+zJcG+i1S/0lPB1hKMvc6hL9q1aRDz+7i58rPf7te3w3/h3wrth8FWVtogcfMbdd8mByMyNlvyxXFeJ/HySQSN5+52PIz1Pv3PvXDUxlNfwYf1/XofS4Xh+nC0q9r/f+J6L458M+DtQUiDUJoDGoUStIVdyP/HeewxivhX4s+L9f8JWN1p6ag8sPl+WMgfxcdD/AJ9K6vxR4/vJLcR2MhG1ceZjJyOwHX+lfD/xrl8Ra3pDjTWm8085z1J7mpwmHdWpeZ15jjYUKXLTWx+kn7F/jO21/wAGGJ7mSe4t3dDjkBR2xXj37S9pq3g343DxfpjeTBqKRXKr93JX5Xz27Cmf8E0bCfRbe50e+bcwBSVejZHNfSf7d3w2TxL8L7fxdo0iR3egSC4YSNtT7NJ8kucDkJwwHtTxGCUajS2POr5hWlglWpr342dvz/A+I/jx8RNZ1/TbHVdMggRbpT9p3sB5hTGw4GR9TXzRqGvtZahDqWsWSm7VNqiM5iOeByP5Vy/i238TeH9Mu5C8Nw0Di0kt4GL7S4DDnG1AQR0qx4dg1PxbpsP2lQ12kJLyQjfF6L5nQIfQ+1QqCiuZ2sfnuIxdSvXk5Qt5dDKTWfGcd9tjv4VikO/ygxwmf73b8K9z0i88RWWk3eupcwJPKojaWIAsc8fKDwM14Rd+AtXjslj0x7NgZvLuojJmUM3AI45Wut8a+HLvRtZl0u2eaQWyRwNiP90uAMFOR07+1a1cLB25bBSpKOtmes+Dn8V22Lya5/tOK0X7QLeQ7WZ/p0P+Fe8+CvE2t6jaSeIPEdkkU8rkQxZ/1QHt6V4H4V8BatffY9P8M3b3V/OuIlVt0kp7gA4AA784FfS2gfA74pWV5ZEaFdXcxcmVUnhk3JjGcB88VxLD/wB3T0O3CYacdk2kW9RvdL8QN5pnmhu4R+62/IhxwTXiPjyXxZqWnJa6jPJ5aMfLeJWJAHQEY/lXqtx8JPj5YWx1O70HUB5MoCJHH5rmM/7K5PHcdq6Oz8CfHzVnRbHw1qMsTSYUfZyuGA9H2gVi4TV1yaehVV+0TjKDV/I8M0vRNdudLtb/AMPxk3SqNy3A4O37zD0FereH/jNe6bLb+HvE2m77S4+WeMDseMr2/DofauwHwc/ajgvZbmXSjY/alEYW7lgtUQep+YkevAqlc/Drwn4IMd78SvEB1i/U4ez0VSqgdwblwBg99qVksBKe0bL7jXB4Gte1GDXysjltZ8CwXEiXHhQtqVuZcxpn51PZCOw+vT8K+qNX0S98DeDtN8MaKXu/sv8ApF61v8wkuJe6dNyr90ew6Vw3wf8ADHj34way76LYSaR4PsfNEjWy/wCskChVjV3/ANZIf4nJwoHY4Fehf2N4t8E6lNZaPJLdxwjdNBdR7ZIWPKgt06dPWrqYRUINRd5P8D7TIcnjQq+3mv8AI+tP2cx4d05xdTpNFFIojuYJPlkgkHzLKn44yDwR9Kg/bla2bxp4binKefeaZcRqWI+9E6kEdODu/DFY/wCzh8XrvXfFjpqPh6eOKJDFJcWyiaMBgB80YPQd8CvKf28vG9jovxS8M39uRMJtGmhtVmH3GabGAT93gDGfSvLVPluepxXVisulfa8fzPKPhxpWmwXIfxDcQXBPHbFN8daxo8+otZeHYYoYoiBlO9eIeHLHSXjtxoFy13cRIGmABCu4HIGe/brXQeFrKfVNSN1qmn/Y2LkeSzYP1pqMbbn5x7amqSikkz6D8KeG10fS4tQuy1xNfTLBbqndn6AewAJPoBXPavImkeKP7P1mYxqjcg8Dj0rhfBXjq7m1K88daS3kw6deW2laYhOUIdh9slxyOVKopxxjjrWf8TfiPB4j8SYjtnuWth84RdzM5+6v/wCulNaKw6VahKm57dvP+rfdY+0NP+JdgmhJaWh3hF2nHSqXg7x5bvrxswfLzyfevHdF/tG88KLqk2nDTRCUX52xz/8ArriPGPi640iaLWdKC7ogAx7V1080xFG0k7pGGIw0OX2j2P0gPijTZ7cpI25zwPY14l4y8Sf2J44sftHCsB9K8C8F/EWbWNCGu3cpVkPCk8nHasPxz4q1DXXXWHJUWYyOOT/+qumtxFiK9uljilTpKHuo/Qrw14ssNWIRSq5XOT2//VUOn+Z431c6i6kaXasVhH/PUjgt9K/Pn4VeK9Turs6VfXLRwzOBL/eVGG4jPqwwPYGv0C1b4m+FvBulwb3RIlVQAP4R6V9jlmfQr017Z2sebOhf31se1W1mTBlsKBjAA6V4X8SPt+n+J9LntnxG5A9OQf8ACu18P/EbS9egVrOQICPxxXG/Eky6laQah9xIJB8zdBXp4jGRlQc6bJcNLI9b1OeNNGa8LZVVB47Cuah1rT7DRjeE5SMcnPHFeY+IPiR4esPDE2iyXqNctF91SCeelfM118UDF8PZbW9lZHJO0/3scfl0rkxOeUKbtzLYjVPY+rP+Eiv9cuA9mNsBHy49q7q0sZFt0N0T618+/AnxBb6v4bs/PmDM+N2R3xXr2qeMIxdvY2pASPhn7A1pg8wToqtUZ0ez57cqNbVZ2srNiDtzkD6Vl+F7h0uCbldwb1rIs9e07WboaeJBMSQM17Na2OhwqEaRd+B06fhXoU8XTqK8ZaGHs3e9j//V+ArL4UjVLmKF2upJJi3llYSLdFx8x+ZsF9wXgE429OKZqXgXxRf6w8t7aTyIsUUIngBUvxs3Bo2wqkZOGUEV22iWOgW+m3Vpomsw3zLF5ax2+ozwyRAD5tjPkDyz87lWBUjaSelJa2MVjb+fZ6vLLY3rb0864ImnWQ/vGQlRwO+xic/KcYOPzZTbV0j7eNmj5d8dN/wh32O906F76WOQvdmKATeTEvQKoIOMY57e9U9L1Dw9418FX3gbTNRkivtZ8UWem3kMrtJO0NrbvcxttUu3yzPGCxKguv8ACFzXvWt+P/hjput2WiaNpVtNqa+bLAlzcs0rHC/JsOSx29dp4YEEGuS1zWfC7XqWmp2sVgLIlE2COz8uPAAK+ZtX1AK7lHbGMmrNrYdrbHy5e/ADwR4FmBnXV/EM3nuRaS30mkQO6gqoT7KxmI3DlgWyBxjNbXiX4Wa/430yyt/HWq6ZZ+HNOO+30nTG+xWMROHOy3jLKZSwyHkMk24k5HSvsKye11bTZLWOWa2KwKslvHKJlYlyQ0XyeYw2sp2GXAwdpP3a8hXw/oPhXSZtJeR0uDMPMEqhFfcPlkxEhDFl4ADDKghuMVLqVE1/VjGVNWslp/X3nzbrH7PXh/TLWSbXlubm1jkhC28lwjQ+qiSSXc4w2APKxnHzcdOO1XwVYaRexDR/CtlrQ1DdJO0c8lwSAP3mY4pJEj5GNr4AGCSO30XrN/8ADfwrZL4gtjaDeWRxGqxAbDlmKghlIbcp39DwM4q1pGu2JliaLzLLTcPFqMVreXNnNNDKNyr9phxx93ERUrIdqyLsYmtI3kt9DP2VNq0T5QvdanjSz8KX3g5dQhmbdBH5MaWkSKfmQS8uoReNxYDHHStzRtXTUPhRrHg7wldHw5e6xexaho72dwjrbyaXFOJlTc4/dFZGKRo+9pY8kGMGuk8UaA2v+GL2eR7uxB3yiO8T7I0+zGWikjcIVPTa3LAY5FcNeWOoaaml6VFaQSQ30LXV6zMW3TTAlGV9hyEQBdxCq+8gkGnGjFarf+vkciw/I9GUNZtPE8l6mp+FEFzpl1P5el2sl6Lm+8pfLQxNguZXdjk4fK8qCcVw/hDxh4X8O6pdN8UNOiCxK4RZm8lpzIrxqYt5Ox4eHQk4wORXos3wi0fRb46taWLWkcD5I8tbMwGLgeW+cNtA+UrnBGD6ViahoCX2mP4b1LUZSyRtHbeYI5HiJJO4MzB2K4HHIVeoHFZ+xp3M3hFGXN1/AZd+O/D6S/bdkFnczk2sIjvDcQYiHdZGdoh1+TIB/vdKqa54juNe8O2liL2SPUHkby47Mp5Dxn7ohOPlfOFwzZH8Nc/D8JvE17bJfWiNdGO1itvOkDqC02cRPsIYjaSuGyFAyduK6bSP2fbr4kaabhdQe0k0yFC6sPOFwsI/1MDRtEFlEamRA4+ZVwDkCqnQpae8RUwc5/CZvgjwF4/0q6PiHUdINiIcxvC4H2hc/MDNJNtxwB29B04r6y0rT4PEdpFrF7pyNfbsXWycPPK5+Uj90gRVAH3AMHivDf8AhFdQ8mHTfFmsW0Rt90cMGubZZraKJtrEvGpxuZRggspBXB2kE9b4W8CgXEuseHNfuZ7CKVN6W0dxc2yNwoVRCY9h3EZBIzkYFZJRu/e+7Y0wlFU9Ee8f2dDbRmxzNYyxIUjmZw4hjbldjAbUPt+def2vi7UtHsLi2W2stQlmOZpZgJXPoqJt4OeuCOa7Pw74qvPBuoz+FPI1a7vX8wyPq1vJaSFGzgJHchNyAfKgjZmbHGTVDwX4NZ7a4TSrJtMimudtw/zu8e/nkkHAB+8OgA25BFaas9Bb2I4tS8Ui3V4mDmGPyvsaEBY5G5Clu+088ZxXknjrwJD8RIL++8bzeXcLGqTPHc7rh1UDggAAAc4A9K9j1b4ez6A9zND5E8JlWZvJ3OkgOACB+6QjaQ3qBxXHLY6JqmjRyCw1zU5jM4MFhCsBlAORs8xULAcdG2gZxk8UknuiJ0uZcrPkCf8AZq0me9j8bXMs955aosCRpLJct5a/KwkYBYlHG0bsDHArvPB2p/Gv4X6ib7RfFGuaSZ8SRxXF3FdjHRR5NyWTy8cnZhuwrv8Ax98QLP4e6OttqHgq8vZJtwitSxkaEYy/mK2XVsD5QEI9TXLWmrTeOPAza3P4Z1COZQT5KlYkAAxGsjMPMHoAFyCNuK6eetypyem3QzjQhB+47Ndro+5f2Yf21PE3ivUNR8D/ABpawtLvSbOTUItatpGs7K4t4SPN+0RyfLA6BlIO/DjOAMYr9B/+Fi/Da08GweNLmW41TzZnt41IMMBKgZY5bzWjbPy8Ln0FfzdaR/ws7wr4tmtdE0WC81JArJaMXmkt+pjWKNh5bSscDzZB+6AJGOTXvcH7Qv7RHgdmnl8LQLqcb+WkeoXjNLvAzvSPYfMPfC44HAxTxDqNKNGyb81+X9I9rKsfSjri9beT+Wx+7tl8adA1WxNgz28EcOGWG1jwT2x8owRjHrivEPE2uajqF5L/AGTZyRFgMuV4/AdMY6c1+Sp/bh/bV1D7TqFpJYaZDBGGklnhfbExGPmKgbckjGVAwMVyR/bS/bYlS6fVPE2kRSwQGTy/sLPK2OAI03Ae5LbcAjjtXAsu5n+8lr/Xa57j4qw0FyUlZeS/4Y/UC/0TXLuQSRhspj5i4Ax9P6VlXXgbVZ5DJK0a7hnHDfy/yK/Hsf8ABQD9s5Cn226sfMj6eZpgAI6/eDAduB1xXQ6R+2x+19rLxw217omXxsjltBHlsbuP3oAyOnP1wOa7/wCylDe33/8AAOGpxPSn1f3f8E/Vhfh7CyLLNh5MfeIxz9M8D8KxtS+FVvqVqdkZQJkkngD06f8A6q/OGx/bA/bEvLcJZnwtPNID5aPGmXyCdqn7Vt3AKTt64HGeK93T9qr9p7Q7Oy1Pxf4CtLrT9QgYpeaNer/D8rNErMynBIOyQpycYyKuNKFPS8fvX62OGrneGm7cz+7/ACPvf9nrw14R8BeL7mPV72DTI7iIyK102PM3cHYAOoxz6CvoXx1B4e1PwHqtvqcqpZ/Z5YpWl/1XlSIQSDxng8fl1r8aNF+I+sC9j+P/AIn0+4u7fWrFrbYT8yqp8sxtD91drJvDq2evYV23xw+N/wAS/HMdn4C1LzLDymk+32UBErvIn7yPZgh2T5TgkYyMDd0rzq9S9RpWsvzX+RtTzzC08NLmeu1j5s8J6nc2V0PC+n21pZeb5SiNvl84R4RPNDfeDYwTx2FdhrPw61e+8QXP2iP+zEaTLxpP5fkOBkxyAdcY+VSuce9bVj9rsra0jX7DrNtep9qt0Z8ySIW+ZCwAWPLblXcCjJgNyvH0D4j8UWz3kerJKdUW3htbYgyfZdsjoIwbndhm2qQhXn5o8E8V5/tGpM+Yw9FVIaz0XT+v0PmTSpdP1Lwf/bWh3UN1fm44tMFjKFAzIMAYKfgKavjnwlr3hq5/4TXVZNM1V5EjhlGnSXMUsSn5ziPJEijp2NekX/hvwukc3h/R7yMQXk0tpZQ28+2ScSAFlMgxkA4ABKsOuDgV5F4l+Gus+HtRMdxLqejRWaGOCKKR51toeyu8aPzx8zOd2e/aunDVqcpWZvGo47vbQ5K+/aS8a+HNft/hb8IfDDSNfXC2Vu0yrFJdLM4RSwTcy7zyw446jjFfrV4f/Z4+KECK9lqlrIVUcqGToBwo/ug5wePoK+AP2OPhvot9+03oWr6/qbaudOs7y9RedgvFhC4DN87Mu9tuBgnoOK/oI8K+Cb1YzJGvzAheHXIwBgEKScgEZGMivQxKoSUZWVkfS5DVruMuV6X0St28v60PlnSfgn8X5YksrvVTE6nGTKcjjjBOCBVLWfhL8RYZzb3eu3CPGMcSt6ex/Kv0D0T4Y6pqkSG6mAtZ1cb+Afl6jHsOM9u4r03SPhJ4T0S3+2X0XmSbN6yO2c8YK98MDyOxrz543DxVoJs+ppYHFyd6kkkflna/sveLfFMomGqSkOQWlkDcDgdzmvoXwL+wL4DN8lx8RZrjUYkwJIJT5cG08ZYLhmXIwfmAHpivuK48Q+H/AApH5NlGsksnyjysYBXjPPXjg5+lcjrPivU9UtVs4CLQR8gAh2x6A9ACOo5rza2LqS0j7q8j1qGDpw+N835fcdNat4d+F+gpoXhKwgt4bVdsMa7UC7Dj5VXomMEAd81+ffx9t4G8OXltaRyLNOzSTzqoDb3OSeDyTgIoHSvq7VvE1vpdu6whmnx8zvkkn/vnj27elfHXxL8SweVPLIwZ2QhpGOSox2449uBWdCi5PUvE4iMItI87/Ydu/EqeK9Xsrm9ukEDZ2BzgErjbnuR0rL/4KD6JpMVxpOreLZN9ncQyWcbn7qSbvN3EjkZx9BXuv7HPhS8stKn8ayQOlvfyjYSAMIP4uuTn04r5m/4Kf69/a+i+Gvh/orzR3l3cz3fmW6ed5aQrtG6PuhLYPfjjpTnh+etybHiZx+8yqcfT8z4Z8Gar8LdOWeXU9TmuLRfmTyJ5IU8zHylTjGR6DrinX/xw1WPRo9Ha4F5EcL5nlFpEVvl5YHKgZ5boO9fIU3gjx1LYXfiPVL29mtI8IYVAUq7cBx/AB7Y9qo+FfiT4k8H2h0TW1e4gkk8uQNbqSufuqY2HzZ77GSt3lN17sk7H5pKg+Tlfu+f9M+27Lxzpuk+ErPQmtnYrMsc0lm2VC2jGeUow43OwUZXouK9j8BeL7Dwz4K0j7bfGxvZ7gz6oqQ77kySHeqKSCSoTau7FfNnhjRrDxt4fEvhL7RYWlpHHHdaVMCUtmmb/AI+LbofKkbCyxuS0Bw3+rwa3b/RfGWo6pNYS6pDJYwyKlxa20ZtG2qwUedzv6/xgmMjnIrzvqTg2rjwsKlJqW+lke+eIfHeh3PmWGmLLma6eYwCQkRQr91pGJwrMf4etemXuheHJ9LtdG1K9hD34MlvDu2FsjoM9fpXhnws+CXhrxF4vXwPbXTaddXh3xxmIyRwptd5DJISVRVVd5fqeAuSQK7Y+DkvfEEPjSRY9Y05kGy2idFS2tVjcIgMhDBiqGTaVDhiM4JAGcsNHZs7/AH7vnS12S2S/r/hjrvAHh3xR4BtprHxBag2txK3ksTt6DccHH90ccH8q7zxXcad4v8TPB4ct2ubNbpfNi4Rvs8w3xsQOFLDIYD5Q6OB8oFeOeAZfEyajBr/iS5ub3TxbO1qZ/wB5bPC6qQeoaJ0JCMcEDpXX6qzeF/ErBLoWMMOj3E12pAMkaW08G05H31/fMBjpk+9c8sPybddv69DCfLCn/d0+7+vwItJ8UeG1t7GKyZY3u4ft0hT7w83JAPpgbVHsK9TuvFGgzaRaya2xl2YBP91cV89eEbHQNW8IaXcRWk4lmWytZnYjbmKBWKqM5xjJbP4UzxJpvxC1i8lstDtA0cTbHdhwoOBkjtgHis3WV24HEq1oaRW2lj698P634QWNvEWkXp+Rf9Sp7DtjtXOfET47+LvGfhZ/CXg3TzEHJElwx4QADhR3kP8A3yo5PVVb5pe+T4YeDLu4YPNLJcCFHddsk0pHCRqevT6KBk8CqEcWvpZ6Zr+s6mftU15AsltbgLHDDI4jCbR94lnHPc9Bmuh4uSha++hm8QkuRRs+tjPj03xL4VkluNS81T13P8241y/ivxbf60YdIBISIjctfTXiiTVvFd/Dol5EkNvacS7iF2gD274/KuV1Dwn4W1Gzhn8LqGEcm+eU8Nhep56D09q5uSHLobVMLFRcI7Gn8MvFV14cvrawunMMNywSJhwN2On1OK9r+InjtpPsfgbRCY5rlgXkHBH418361q+n6neaLZaeh8uW6zC6jA+T5d34k4rq9Z0XVINat9f1O48tbXD8ddv+eKPrD9n7NPRFYRuMJqO2n3H1j4P8J674Q0r+2pYzJGFHJP6/hXpPhWbUtZtJL+UsMnlz/dFeLw+O7o+F/J+1GS3kXOQ3B4456VxXxA+NWr+CPDFr4X8Mwlprtcs46KDXr4bMo0eVdEdmMpUYQ5obH//W/NjRLHw5aaBc3viDxlb6xFpzANex6Q9vefudgh3yOFBmAXYJNjl8DrtrsvDfhzUdat2vfDvjC7vYIxEkw1KZb2GOOJfMXaUkSQAg/wDLROe43DNen6f4O11ovtl/JYSyKFfcsR06WQIvyv8AM0gkDEklNhcYRvk4rp9VgGnwi/0y8jsJIFCxSWq7YzJGfl/1CxpGT32ZAwDgFq/O7eR9xy6HI6Z4b0zS7aXX7SS2kaV1UYS4hSRsZixE9zOUUk4xyRjotYWp6JbaVanV7mbT76O3XzTKS7KjRPj92ciD5GDex6HZgmmeK9ee9lOhs0kkt1KZluYNysZbjasskvO3fIACJAgSMrkFRgDY1a+8VWLQ2OsSQabZXwNtJLejdLvA3KryBTtaSNwf3nIIKjjaKdg0Wh53ceK9JW1kntXitryWfynZh5itI5O99tqPMXYyhNpOQwAPykMeNi+KXgiGWTR7bVdO1WSKb7DJHFdpHdG4RY3KPG6xx5Iy2zPQHaeAK990pPB+jaPGZtQW1vH3i3nCxx+eyBH3ThraBFkdkIjQRDdx97aKxfCXhXwrp2qzXeqyta20Z3QnTIPNZrJiruvnH7olyuWiGxSenIBm6Sux2PN5fDejssV79kW3uJR5ckUijdkZLfOshR8nlQNyHbgY+8MHxB4esdalXQ/ENx/alvL91JREAfl3sVw4VpVUZBLBQMcHrXqXiP4T6FbjbrKFfJDvaqN8TKzAfOS4Rldm3RgRBcHdnHFZmqaHqMcMV14X12WXc0kdzOIR50eeGRImkmMpVDtx8igZAwCFqbCt5HlWoyaDr8t54V09b+107TVa3ng0yzaSFZBudgbkQyoCo2gR72+6cdCBwXifwd4P0STTH0JdQuWvgUt7Tykubx5o8k/u4ITKdsaybuAq4POOa9s+w6jokFpYWevfYrN3O2OGGeWaRllwi+VGGyFdiGCgKFyxKrkVJfJodxrckMPlyRu21TDFcQxLLGqbgr+e+RhGfHIYMSAANtUkS0tj8vPGGleJrfxdBJPez2+mXTB4NP8AsqiB1iYcRrCUK7WIyso27WGCea+mLP4IfGWPwIfHus2+j6dodvbHUTJPqUSyW9qI3ZvtMAiVgkYPmAQPI4woY4+WvsBtKsJPtE9xFDJ9t2+WrI58ryyyZCvh3+71RsLt+U/wVH8R9H8ZLpV58ONN06GAX+kpaSGBFZXtXTaQssLOGUqxIKBmDfexkFStUfuxil/XoEKENXNnwl8JtR02/wDDP/CRWv2q41DTWdGumiCJK05+/AArT/dUc7EO/ao3DNei3/gi4sG/4TjwxZ3EFxKIW+zXETQyGdpVkR4/NgEyTA7WxJtK8jrxXW6H4AvNBXVvC3hm4nn1yK3ksngtJ44ptLWXKvJmOQnz5IsiPaGe0hYsxWQqo5Pw58AJPBet6ZJeDbZmVbny7aS8ufOmjbzop8mILuR1DbpGkO7kMp4pypQls7Iz5LJKxZ8I+PPCMvi660PxZPAWvklk04W8kZurK72MzGASr5pRGBDQqSFj/wBWV2op2vCUfiq9vZJLG+vPDxZwv29URrOKHAKut2FWZsNndJMrKmeRkMB754sutR1zw7eXE89tc6pGZJSiT4kWQYCPOfLR9oxIfmL4P3iwzXGWfxh8OeHtOt4Dc21xcShVW6jWextwdy7f9c0pcFflbhAxwQg4rjcYQJTVN+89DnvEum+PtQQRarfXt1LDBHLPPqGpYiEjnkRsybpFReEZF8tu2O2Zoui376iNS8RafqF7BboPLeK6ZWUL1ykisD1+YSqAP4SADilrvxa8AX8ktmstncad5MaQQ311Ctx8pw8avtkRtvXCbWIzhQQa6Pw38R/C9n4ik0/QtQtHiISMF52NwZZCVLFI5A7ghyfn+cAE5wppOunHlUTF4yEnucZ5tlp2n3EIs59QguTCDD56PMi4LOkkYZirKAQZInbquBjkafgM6RrPnzfarzUZiH+0LKqTzRsT+68ldu4TMV27QBtQkttUZODfeLNLvYm16wuYfENza2YgLabEJfLuCCXkiZXjeRTxg7QH5LR7sZ8Zi+Ien2HjeC88SSvA0drKkcMED2VxHJ5254fLm8pc9UG52GMDOPlPLas9jGpXnTtJbfl9x79eza5rEd1qep6tLplteXPkBPtaQnbGnzQvPlsghdrjuAe4zUvhjXLCxX+w/Ddkn2Fo3El5KSWa8YIBxIwEfAwhZ8HgBQo+b5bPje18X+JIP+EksgbHTdIj1HyUbyLdYGcww+bKCrHMm4fKhZmK5GMmvdtJ8aaHrvh+e7u9I1BLa1Vo4J7WeK2IiyAyKHXGAcdlLdicCr/e8tpIMLiXUbk3ov67aHSeH7eJ7S48Ka79pmtTfIbyZked7crkGBTEqqodiGYMm75c8IprN8dav4d07Q9MbQdEtbi4tHeO48+VpriUuN0UbSTYMaqoJAXATIGM1554n8U/DdYdO/sOXxVqF/Zny/KMURtVlI2SOSkj+bhBw2zn36VpS2tr4FmWzeHUY3aO8awu9UWJfKmjiym1jGryqknzlJcZOHIJUColGV1Lb7zWrVfLeNlHyK+ll5fESarbxWUt3ZOsk0EcJlOV2lppnZ84PJGzABVenboj8NNAmuX1N9HlgjOFiaNzavJiI7RvlR2LElepBOcjJyB4+Ifh/wCKfEVxc6fHBazsizNPZweWnmzEdYovMQ/MWdwYjvLD7uRX1v8AB+/fwTaXM3h7VrTWbxEdpA+mTJaKzbonM1vMEVgpAb5AfmweACKtXjK9/wBCsLq7PU8wPwG0K/06WJJZ7eOa3GEnXzZdrMQWJKP5fQktyMZwMdPG9b+CPihS8WmpfSXMZCLLGhuAAikfIpClygUZLHHHC8CvsHUNc8deItSbZqGoan5wC27LO2y7MXygPJF5EIIH3V6ZfII5NV7zw3qmgXlpq1ywSaCMzNYz3EkVxFF/dkSCXjjjerEkDp8wrrjOa6nTKgpHyT4M8G/Gh7e50bQdM8yzuImW7vJjBapvABCyTMkm0LkHCKrNxwQK4zxd4K1bwhrUWtap4m04aMQpli1CKWSTzMKHaJwiyCZQAY3DMq88YwK+1tSgt9XnlbSFNrZFVaG5tLGNpSUIZFhjmmkEbDays06BijLtYcgfPupfC3xO+qLfC0tZYJHaOcPDJb3ZmJ83Dn7pzw+7LKANuM1K1ldpL5f1Y5MTheaKj2PF/CPiPw/pukr4aW+ZrOPzZYPJVbiFYZmPHlEqpc5PUjGSSMYFd8fBniXXrCx1zwUrarJOhNxerI7x2U0pRvIMMiAI8TDDzNIVjc4iGzJqxF8PtWuJ72bTYTZm2860F4UaJcudmVcKzD5c5Gzp0rqdK+GOp3txZW0uvyWdtaW4tP8ARbmO1gETDCZAlEcy5Jy0iqyD7o54ahTj719fM56OAhGNpK5yafCTxX4Ykvdcns7i5NyCrXELtHmNcEO5JaIFcj7zkscAjuMzQZNXN7cafp863dw1pdROwiF0C0qeYceVwqS7ULrkB+wBwa9s1KPRr28l8Rz2NitxpIhdIjBBdW+9Tt3fMxmLFV4eNvk2gj7wq34r+GieE9ItNH8V+HC0tluW2sr2+Xy4ZZIg0my1tmZQihMMWmTdGNoXkCseRN3vr8v6+RUcEk26exx3hnwjd38i32uabcQ2DWzu88gENvA6YTDLIhzhtiY2+ax+6SeBU8VWckHj1NS1m3CWN7FO43Q/Z7a5niVnVWjQqz4ySgdc7QOMCso/E3V4Rb+Hb3w/pWrJpl1JdW32eeXR4jbOh3SNZu0u9zuzlpmdB8yf3a9Q8NzeJvPTTrbR7aa/CtDNYzfZvMWQxYRpUN4D+8UKBKJASMhym0CpeEdN3/r/AIA3hFZKD/As6T4W+KF7rFv4S/Z8itLjVdqWd1E+231qSZwZGitUnliT7Osa7m8oi4Kj7h4NfTPwk8W+O/hleT+GZbW+0K2vRGlzB9hktbf7XH85l3EKS7qwLZfJAB6V86S6Dcalpd3L4zs7aPw9e3LN/Z8kFvqFuUtxhBc/vhbeY0oLbwrFRzkE16Lpnhr4c6l4O1Pw1o9/4Qe7Cfa5neSGPUAEESFZB5ke5RkRNJ5MqR5RdxAIFVFGpFJvbtse5l2Oq4V+5FX6XPunwT+0Z4NLp4f0Txlp95PbO/yS3Eds8Ur8sBEX8wnpwSBzX0Np/j7xhd6c0k1y4SQLjykEiN1IIYFxyDnjtX406z8ELnWxNoesebeW8kKo7GGB7e4Vz5YjGVMXTG3Dg4CjOBgcJpn7IPiiXxNYWnws09tFd5ZLe7g0uZ9KVliZFd96SJHHuwV3sQyIAwODgKOFobXt/XyPejxLXXx07/h+FmfvFaalaxPHFeSOfM7EgMQPXkEc8Vuf2xbXCGPzjGp5B28jcB2/nX4kav4g/aI8C6dDc/DfxfqNtaQLPi31V/7atHVGwhlFwk8+zafkZJU3gZ61yVr+37+1L4amePxN4X0PxRHvYwmCabSLvyhkLviYTrhwMrwnHVRV08vi17jX5f8AA/E6XxLS2mnH5X/LX8D9wfEV9YsWsIZmMxX5VQgliBxx/hXjcPwL8V+N9VA1RFt9OZmZ0ZgskuMceWCTg9ycccV8AeAf26PC3jLUtNn0q/NkNbs0nvI7U+feWiAfNZQiNcrMxzuYgMiKCvJUj6Yi/bj0Xwt4XmsvhdpV+mrLC0Ed/qMf2a1gEcTFS/murP6HZyxOMjtjWp1KfuRjb9Doo4/C1E6lSfurbzP0du9d8DfCH4ZSar4iuEtIrKH/AFcaDkAcIsaqXZiRhUUZPQCv52v2kfiBr3xJ+KJ+Lts1hFo7CO1s0ur9FBgjJMe5dyhGlLFhlhkYFeman8YNf8RLa6x8V9ah1PULSyJuLjT18/ZcyLslFuZI0XjlQq4O3I3nOR4t4n8S/DFtEsfCPi/Sr/8As+4dp/NmtbC0hHkx7MRLbu7R8P8A8tSN2T9RFGk+a8l5HiZxmiqw9nSdof1b5FK78L+M/CfhCzu9W8NfYbXXr13USXKzRy3ES7Im3wySwiJwWEcYYYIJPSvN9T8G67eK2v8Ahi4W31GzLTXOl3YzK7tgAokiqZVVgE+RTtPHSvbLHw14Rbw3Jp3hq7uTo9y0TWLX8QED2zDDGFhcbBOuXjOU4IVkypArrb+/8UaWtxrl54fsvE1jpKLqdtcXc7affRFgqbbPVDKtxbTsSqyJsmWUHDRHLbVGUue9rf1p/XQ+ZjVk/T8vuX6Fnwxa+EvDd74W8ZazZX2nyzELG+j2sckVzdRqWWSXDJsWRMgopEm5eBgFT6vNp3gPQ9RGs6Q8N1kW5gku93nPHdLtiSWI5CKysFaUMFV09TtHnuj6JpXifxFqni3w/fXUceoW8wuLfxHcQqDceUfLulk04+XE0coDGRLIDYXygaT5Mjxzr2v+D9bgtrBTqZtI55I9QnMMnm2SMjs1u3nyg9AcOeGHABxnCdOpKyexTr1vilHT+un9dj1S7tfCPwZjl8SatDBb+I7tf7OF20TC2tpJwUITOAQnKbiOSF24GTVLULCTw34V0K11V44tWuZp4EiU7nMMbbwUA43BSqnJ5zlSc18++PvEepP401WHXdUez0CTVprwK8E1224tvChbcu5eFSqrDGoAUbh3xxulePPCty2mXGl+LbPU9UsrplsbdUl0+6isYi75S3l5lDoWbawXyCuAG3CsauEqzTl0X6HHi6757xW22q+em78tD6hg8VeG/DujSy6xLcHTLR7w3ElspuZTDbCTagiA+fO2Ryu3kMp5+WvYvFmp+Bfgr4g1/wCG/iTw1Y61rqaPdW+uNqiRz2VlNqFvDcnSLG3dXiaOyQQm5nlDvLctIkflIm0fJfwBv9NXx3q/xU8VCNdE0AQ30MbM1rDeTxbGs7ZeV/11wkZfIYGNJNy8ivHdUs/F+l2L3viS72a9q0F5qE84kWWFrm+DtJcOqAjYxd3kSNtxkYZdaIUbRt9rS3l/WxySq1vZRtHf8lp/w3ofUWjeIdCsvBOiT+F55LeznKPJLdxm4kN15UYCYU7VbavmZ/hXbnG6vY9A8USeJt3h3wOwgsmZ3FxN8p+9s3EbdzyMw2qv8T/KPb5U8N+AfE3h3RtJ0HV7tYdE2NHbRwr51/KoiZBLEvy4ld8ksQq9V+YYI2l+J+seGPh7p/gbwxbvoZ+1eYbmOSCTUpBP+7a4kIYZmmUDyfl8qJMAjlRXBLLOad27JG1Hnpx/e+7FL8raLsvuOs8eXl1rsUba/JJFqNvO8MCvudba0jIMkrFfl82Vto77l5BCBcYniS9s49bgbRrhRpqX9lmZZAqHypYpJGUsV3OCD0+UHgEkV5n9gnsdX1BfEtvZ2D252WllcX0kiafbsNxhQRKZZpTt3PhtxIGcKFFdvpfiW5vWnvPDIhtYNHjE8i20JfeYzsOySYuewG1Pm7diKueCSd+mhwPm5pab/oesX/xI0W5vZ555U0zTIIvNEl0Ghd1PQkyBPv44xnjOKbZw23i6C7XSredvM/dskCNu2AZJCLk4C8kkBQCOa4nxPrvjLwyhu/HkECtFbyJYxRj7ZG8jbPMDlQzMyLIAzHABAVcAkj1/XNO8QWOk6j8Smt5gL+CCe4dnDi+kkQyup2yoVgxsii2LJkBflJzXGsIrnZCnWquTl06WtZHGPOt+2nfYbu2tDaPGihif3SxsWGMcEk4r062Ei2FzFdTnUpv9TtUHOW6Z69MdK+avC+seHNG8YxL4t0y5lubOVi0TsskSOcb5IxgCP5oiNgyCMdDXra+JrzxBommxX0UcNrez3LZiuUhkVEG9DkurHPzZQKrNgKDkVUqKi1Zam+CnCOu/S3b/ACPNv+Er8U2eo2nh6S6jjtFu0ja3jPJ3s67P9n5VJBP5V6X4o1ZE12bWvEUZhRSIIIh82COvT2IP5VHFY+Ej4Ei1mOcjT7iacxhMq9xdMVgMk7MN6pEA3zDhI+V7E83Z6hqWi6dqWg+ILm3vtZtL+5S32OHmxnDyHJwNzDK9SVIbvipr0HGPvF8jpJc793+v6R//2Q==", + "mimeType": "image/jpeg" + } + ] + } + ], + "tools": [ + { + "name": "weather_extension__get_weather", + "description": "Get the weather for a location", + "inputSchema": { + "properties": { + "location": { + "description": "The city and state, e.g. San Francisco, CA", + "type": "string" + } + }, + "required": [ + "location" + ], + "type": "object" + } + }, + { + "name": "platform__search_available_extensions", + "description": "Searches for additional extensions available to help complete tasks.\n Use this tool when you're unable to find a specific feature or functionality you need to complete your task, or when standard approaches aren't working.\n These extensions might provide the exact tools needed to solve your problem.\n If you find a relevant one, consider using your tools to enable it.", + "inputSchema": { + "properties": {}, + "required": [], + "type": "object" + }, + "annotations": { + "title": "Discover extensions", + "readOnlyHint": true, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_extensions", + "description": "Tool to manage extensions and tools in goose context.\n Enable or disable extensions to help complete tasks.\n Enable or disable an extension by providing the extension name.\n ", + "inputSchema": { + "properties": { + "action": { + "description": "The action to perform", + "enum": [ + "enable", + "disable" + ], + "type": "string" + }, + "extension_name": { + "description": "The name of the extension to enable", + "type": "string" + } + }, + "required": [ + "action", + "extension_name" + ], + "type": "object" + }, + "annotations": { + "title": "Enable or disable an extension", + "readOnlyHint": false, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_schedule", + "description": "Manage scheduled recipe execution for this Goose instance.\n\nActions:\n- \"list\": List all scheduled jobs\n- \"create\": Create a new scheduled job from a recipe file\n- \"run_now\": Execute a scheduled job immediately \n- \"pause\": Pause a scheduled job\n- \"unpause\": Resume a paused job\n- \"delete\": Remove a scheduled job\n- \"kill\": Terminate a currently running job\n- \"inspect\": Get details about a running job\n- \"sessions\": List execution history for a job\n- \"session_content\": Get the full content (messages) of a specific session\n", + "inputSchema": { + "properties": { + "action": { + "enum": [ + "list", + "create", + "run_now", + "pause", + "unpause", + "delete", + "kill", + "inspect", + "sessions", + "session_content" + ], + "type": "string" + }, + "cron_expression": { + "description": "A cron expression for create action. Supports both 5-field (minute hour day month weekday) and 6-field (second minute hour day month weekday) formats. 5-field expressions are automatically converted to 6-field by prepending '0' for seconds.", + "type": "string" + }, + "execution_mode": { + "default": "background", + "description": "Execution mode for create action: 'foreground' or 'background'", + "enum": [ + "foreground", + "background" + ], + "type": "string" + }, + "job_id": { + "description": "Job identifier for operations on existing jobs", + "type": "string" + }, + "limit": { + "default": 50, + "description": "Limit for sessions list", + "type": "integer" + }, + "recipe_path": { + "description": "Path to recipe file for create action", + "type": "string" + }, + "session_id": { + "description": "Session identifier for session_content action", + "type": "string" + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "annotations": { + "title": "Manage scheduled recipes", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "dynamic_task__create_task", + "description": "Use this tool to create one or more dynamic tasks from a shared text instruction and varying parameters.How it works:\n - Provide a single text instruction\n - Use the 'task_parameters' field to pass an array of parameter sets\n - Each resulting task will use the same instruction with different parameter values\n This is useful when performing the same operation across many inputs (e.g., getting weather for multiple cities, searching multiple slack channels, iterating through various linear tickets, etc).\n Once created, these tasks should be passed to the 'subagent__execute_task' tool for execution. Tasks can run sequentially or in parallel.\n ---\n What is a 'subagent'?\n A 'subagent' is a stateless sub-process that executes a single task independently. Use subagents when:\n - You want to parallelize similar work across different inputs\n - You are not sure your search or operation will succeed on the first try\n Each subagent receives a task with a defined payload and returns a result, which is not visible to the user unless explicitly summarized by the system.\n ---\n Examples of 'task_parameters' for a single task:\n text_instruction: Search for the config file in the root directory.\n Examples of 'task_parameters' for multiple tasks:\n text_instruction: Get weather for Melbourne.\n text_instruction: Get weather for Los Angeles.\n text_instruction: Get weather for San Francisco.\n ", + "inputSchema": { + "properties": { + "task_parameters": { + "description": "Array of parameter sets for creating tasks. For a single task, provide an array with one element. For multiple tasks, provide an array with multiple elements, each with different parameter values. If there is no parameter set, provide an empty array.", + "items": { + "properties": { + "text_instruction": { + "description": "The text instruction to execute", + "type": "string" + } + }, + "required": [ + "text_instruction" + ], + "type": "object" + }, + "type": "array" + } + }, + "type": "object" + }, + "annotations": { + "title": "Dynamic Task Creation", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + }, + { + "name": "subagent__execute_task", + "description": "Only use the subagent__execute_task tool when you execute sub recipe task or dynamic task.\n EXECUTION STRATEGY DECISION:\n 1. If the tasks are created with execution_mode, use the execution_mode.\n 2. Execute tasks sequentially unless user explicitly requests parallel execution. PARALLEL: User uses keywords like 'parallel', 'simultaneously', 'at the same time', 'concurrently'\n\n IMPLEMENTATION:\n - Sequential execution: Call this tool multiple times, passing exactly ONE task per call\n - Parallel execution: Call this tool once, passing an ARRAY of all tasks\n\n EXAMPLES:\n User Intent Based:\n - User: 'get weather and tell me a joke' → Sequential (2 separate tool calls, 1 task each)\n - User: 'get weather and joke in parallel' → Parallel (1 tool call with array of 2 tasks)\n - User: 'run these simultaneously' → Parallel (1 tool call with task array)\n - User: 'do task A then task B' → Sequential (2 separate tool calls)", + "inputSchema": { + "properties": { + "execution_mode": { + "default": "sequential", + "description": "Execution strategy for multiple tasks. Use 'sequential' (default) unless user explicitly requests parallel execution with words like 'parallel', 'simultaneously', 'at the same time', or 'concurrently'.", + "enum": [ + "sequential", + "parallel" + ], + "type": "string" + }, + "task_ids": { + "items": { + "description": "Unique identifier for the task", + "type": "string" + }, + "type": "array" + } + }, + "required": [ + "task_ids" + ], + "type": "object" + }, + "annotations": { + "title": "Run tasks in parallel", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + } + ] + }, + "output": { + "message": { + "id": null, + "role": "assistant", + "created": 1753704259, + "content": [ + { + "type": "text", + "text": "I apologize, but I don't see any image shared in our conversation. If you'd like me to analyze an image, you'll need to share it first. However, I notice that I don't currently have access to any image analysis tools in my available extensions. Let me search to see if there are any image-related extensions available." + }, + { + "type": "toolRequest", + "id": "toolu_014qhEwCaj8QWwz1s8xtMH7h", + "toolCall": { + "status": "success", + "value": { + "name": "platform__search_available_extensions", + "arguments": {} + } + } + } + ] + }, + "usage": { + "model": "claude-3-5-sonnet-20241022", + "usage": { + "input_tokens": 2560, + "output_tokens": 111, + "total_tokens": 2671 + } + } + } + }, + "78cc474ff2d51b9a24df8c35e5c75f256dafb67ff5489af30fcec95cd87790b8": { + "input": { + "system": "You are a general-purpose AI agent called Goose, created by Block, the parent company of Square, CashApp, and Tidal. Goose is being developed as an open-source software project.\n\nThe current date is 2025-07-28 12:04:16.\n\nGoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o, claude-3.5-sonnet, o1, llama-3.2, deepseek-r1, etc).\nThese models have varying knowledge cut-off dates depending on when they were trained, but typically it's between 5-10 months prior to the current date.\n\n# Extensions\n\nExtensions allow other applications to provide context to Goose. Extensions connect Goose to different data sources and tools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level problems using the tools in these extensions, and can interact with multiple at once.\nUse the search_available_extensions tool to find additional extensions to enable to help with your task. To enable extensions, use the enable_extension tool and provide the extension_name. You should only enable extensions found from the search_available_extensions tool.\n\n\nBecause you dynamically load extensions, your conversation history may refer\nto interactions with extensions that are not currently active. The currently\nactive extensions are below. Each of these extensions provides tools that are\nin your tool specification.\n\n\n## weather_extension\n\n\n\n\n\n\n\n# Suggestion\n\"\"\n\n\n\n\n# Response Guidelines\n\n- Use Markdown formatting for all responses.\n- Follow best practices for Markdown, including:\n - Using headers for organization.\n - Bullet points for lists.\n - Links formatted correctly, either as linked text (e.g., [this is linked text](https://example.com)) or automatic links using angle brackets (e.g., ).\n- For code examples, use fenced code blocks by placing triple backticks (` ``` `) before and after the code. Include the language identifier after the opening backticks (e.g., ` ```python `) to enable syntax highlighting.\n- Ensure clarity, conciseness, and proper formatting to enhance readability and usability.\n\n# Additional Instructions:\n\nRight now you are *NOT* in the chat only mode and have access to tool use and system.", + "messages": [ + { + "id": null, + "role": "user", + "created": 1753704256, + "content": [ + { + "type": "text", + "text": "What do you see in this image?" + }, + { + "type": "image", + "data": "/9j/4Q/+RXhpZgAATU0AKgAAAAgABgESAAMAAAABAAEAAAEaAAUAAAABAAAAVgEbAAUAAAABAAAAXgEoAAMAAAABAAIAAAITAAMAAAABAAEAAIdpAAQAAAABAAAAZgAAAAAAAABIAAAAAQAAAEgAAAABAAeQAAAHAAAABDAyMjGRAQAHAAAABAECAwCgAAAHAAAABDAxMDCgAQADAAAAAQABAACgAgAEAAAAAQAAAgCgAwAEAAAAAQAAAgCkBgADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/9sAhAABAQEBAQECAQECAwICAgMEAwMDAwQGBAQEBAQGBwYGBgYGBgcHBwcHBwcHCAgICAgICQkJCQkLCwsLCwsLCwsLAQICAgMDAwUDAwULCAYICwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwv/3QAEACD/wAARCAIAAgADASIAAhEBAxEB/8QBogAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoLEAACAQMDAgQDBQUEBAAAAX0BAgMABBEFEiExQQYTUWEHInEUMoGRoQgjQrHBFVLR8CQzYnKCCQoWFxgZGiUmJygpKjQ1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4eLj5OXm5+jp6vHy8/T19vf4+foBAAMBAQEBAQEBAQEAAAAAAAABAgMEBQYHCAkKCxEAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD8ZJJccH9KqSXBHANabaROBxkYqpLpU+3pivifqx6zZjvPg4qESZHsK0W0m46MKRdLl6DtVewsQU9xHeovPUcVbl0+VT8vaqD2Nz0xTVETJ/PBbOc0pmHY1AthMuKY9lN26U/q47im4z36VHvDdfwpv2OQ9qlWymONwxT9iCZFvB+7UbjPPWtFLKQjG3BFI1jLwMUvZjM6HLNmupsB8oLHrWfDp0wA+Wt+106YNnaaUqZUTo7WNdgxWmqKowtU7WzuMDIrQNjOFHtXM6RpoU7hwowK47U7oJkZrqLyyuApJBzXC6pZXL8Eda1p0TKTOeursbsGs0Xag4zSXNhcKTVAaZc7hXUqRzm2lwHGBxSE/wAQNJaaZMoG7mtH+zpccCpdM0SOenIYcGsuVh1ziuom02TjA4rLfTZcdKaiDiYu/A61B5w6GtF7GRe1Z89pKvOMGtYxI2HibeuSal+0DHBrFcOvAFN8yToRWqgNVDUaZSOfpWbLKOajRHxzUn2d24xxWigHOYN0ok5rIuLRm4Fdi9g/TbUMlkw/hrVIxkrnCJbFPwrYhyg5rV/s9+oGKQ2Mi9uKbRmoEMZORg8VZVt1N+yOO1PWBwQNtRyFJFsSYxg85pzTgcZqi8TAZHFQSM+OlS4DsaJnypqm90cHmqLB+9Upd+aFATiWJ50zTVuxnFYkxkwewqEuwx2+lWoE2R1y3oBFWBdrgdq4rz39elS/aWx83Wo9mM6d7petZs90DwT0rINwdoBqrNK/arjATsXHvM05bw5yT0rAZ3BpvmOD8ta+zMrnWxXpGOfpVj7fjGDXHJI/en+c6j1p+zDnO8i1EDrT5NSDCuB+1MBxTHvZce3tS9kQ5nTvqQyQD0qMaiAPeuM+0P3yKi8+XrS9iQdz/aQxnPFSjUAcHNcKs8mfl7Vbjnk6Gj2I4s7FL7OATjFWYbpWGRXGxzMavRTyAdafs7G0ZHSTXGOR0FUJphWe1w2AT0qCSRj26UuQGyxJclSP6VW+3bckHjtWbMTVB3m69MVtGBm2b41Bh1OBR/ap+6DXKM79s1G3mDFXyCuf/9D84m8OqM7lzVCbw6MFdvWvdG0bnG36VSk0QckpmvmT0bnhx8PRgcjp7UxtBiA+70r2SXRR/dqm+j842/pRoK54tP4eVuFX9Kz28PdcrXtsmlY4IFUZtKXHzDimrE3PFX0Lb0XpVZ9BA7fpXscmlrjgYz0qo+lxnGR+nSi6Fc8iGgg4yOlW18PqFyFr0yLSxzx0p6aYcHHFA7nmp0Veu3p2qEaLyARXqD6co/hzn9Kg/s1UxnvWehXMcNbaHjjHeujtNDTpjjtXRwWSjjFblrbKuO1Gg0zDttERcYFaTaKmOFrq4YUxg96trbxsuay0NOY8zvdEXbjFcdf6GmDlele0XVuuMFevSuXvoUHAFaRaRnJnh13oS7uVFZ40L5h8vA9q9PmtUDdMCoxar0xWlzI4WHRlTjbV7+yUAxiu2jt0HIWrQtUA6VDNYux5rLohZsbcVmz6IeEC/SvV5LReOKoT2S+nSpQ+Y8cm0XsB0rEutFUDbjFexz2XcL17VhXFkh4xWiMmzxW50Yg8DiqH9jkdB7V7Bcacp6D2rPfTUA6VrzGZ5rDpHbb+FaEekhVBxxXfJp6d6kNio6CqUwOG/speMion0pO1ds9qFzVIxhDjrV8wrnHnRwMcZ/Cof7HB7YrttqD7wp2xBzjGBT5gucEdGBbpUJ0lR2rvykZ9KrPCD0ouK55/JpAqo2kDGccCvRTZFjnFMNkOhX+lPmC55lJozDoMYrOm0l+mM169LYgADFZ81gvYUcwHjsmjNu4HT+VVzoj5zXsD6XntTRpIBzT5kSeQL4fYjgCmt4e+UYFe2DSVAHFQyaMCcYFHMB4t/YLdW6U06DnqPwr2N9JVSOOB+FUZdNRMfLT5yWeQyaAeuKiGiHqB0r1htNU9qi/s9OgH0qvaEWPLf7FOKcdBLHdivUf7Nx2qRdMUnOOKXtBWPK10JuhHSn/2AccCvVk01O4p/wDZikdB6Cn7QXKePt4dy3AqsfDRx06V7M2np0xTTYR4246Ue0DlPGR4dK8Ypf7A2jFewf2dHjgVE1imM4FNVB8p5QNGK4wKsJpODyK9IbTlz8tOXTlPAFVzodjz86SRwBUD6Q/TFenLpqkcDikOnDAyKSmhWPKjobMw4qFvD7dxXrR0uPjA/pTTpygfdq1Mix5P/wAI7v4xUi+Gefug16ulkuMgVYjsVJ+7T5wsf//R88l8ITLyw4rNm8JzD7y19ST6EMfdHFZD6CCPu181yHbc+YJPCspX7nFZcvhSboq//qr6kl0FeV2/p0rOfw8o4xQqYrnzC3hC4LZ21XPgqbgla+ohoEZ+UADFPGhqDhgKfsxXPlGXwTM3Rf0qg/gmcn5R0r63bw+hPSqsmgRkdMe1P2YHyK3g+4jHyjP4YqCbwxLxgdK+pp9FiRSAlYVxoQzyMAdqhwC581TeG5B8u2s6Xw7MOcYr6Rl0OEEkrWTPpER5K4qOQZ4JF4dmLfdrctPD0w6rzXqseigOCBzW9Z6KCOmKXINM8wtPDkg+9FWrH4bZuAtezWeiKMLiursfDSHG5R+VCpjufMd14RnZSAnNcjfeDJsH5cfSvt0+FUZMBP0rnbvwlFjlKtUiWz4Yu/CMqNwtYr+GZhkbcY7Yr7RvvCEI58uuWuvCqcgJxQ4E3PlCTRZ4+NuKYNKnJxivo258KpnhKpDwur8FAPwqOUdz5+Ojyn+HFVW0qbONtfS1l4HutRuVsdPt3nmfO1Ixk8dfoB3PQV6npvwX8M6cXj8X3vm3irkWdmwRQw/hkmZSQOgO1Ac8AkjhqFzSnTlLY+BLvTPKj3T4jHqxwKpW/hvUNVfytKtpbx8AhbeNpmIPtGGOPwr9JtL8SeEPCmpR2/gvRNOXCgtK1uGkbkNu8x1kkOFB4MqccccY7+2+LaSxXBtJxFCZT5awT/K2cZztVR0xwM/XihrlOyGBb3kfl7H8EvitfAfY/C2sMW+6psJ0Jx7MgrRT9m745y25uR4O1coP4ltiR/j+nFfovP40uNZd4pAN/wBw7DGo2xryQ2XPOM5ZlHv2HCP4psVRZ7Z4TPG4j8i3MkjggZ2ltw4xjDkBSf4azlUsjeOVxfU/OvxJ8PPFHgwr/wAJlpN5pCvja97byW6N7K8iqp+gJrm5tJKgAAj8K/U/RvjTr+nI2ZJJUnjKNAlwwEuMriSI5TgFfu5ySAcV5n4i+HHwq8fWtze20EXhm/O51uYn8q2yvaa0K7VXPBkjKvkc7ulZLEpbkVMpklemz83LiwcfdGAKyH01/SvbPF/g3VvB2vTeHvEEKxXEQVxsYSRyRPzHJGw4aNx91h6EEBgVHHyWQxu6V1xqXR40oOLszzs6e/cUgsmB6YrtnssHgVAbMA80+ck5UWBGDTxYFR611a2QParUNiueR+lPnKscb/Z7g8CrEeksenSvQbawRgNy1sQaUhOVFO47Hlp0Rvu4/pVdvD7+mK9sXSFOPl61GdHQn5RTvYLHiZ8Pv0xR/YDDtivcF0dc7dv5VJ/Yi9CtHMHKeHnw9IANoNI+gSdMGvd/7GiHG2qk+loOABS5g5TwCfQXj6isqTSHB5XivcbvTx0rn7iwycBeKXMS4nkp0gdMYxUI0fdjjFemy2I9OKbHYKTwPpTUibHncehqeBU50AlsjgDoK9Oi0xX/AIauf2SO60XK5TyddDk6jtxTn0N0GVxXqZ0r5umPSozpuO1O4uU8m/sVy3zVH/Yz4wP5V6k2nNnpVR9OfPApcwcp5k+isMFvpSDRX+6elelLpXPtUw0kjtmjnGonmJ0KQ9OMelTR6DIMYHAr1CLRyR8w4FWotKHGB+lHOHKeVLokgyGWon0WRe1evHS0x8wqhLpy54FHtCnA8nGkv1po0iTPAr0xrAKcAfkKadPAwcc1oqhnynnK6QT0FXoNHYY2rXcf2cchttXIbDjG2n7QnlP/0vrq40HcMBcD6ViXWhDGTx9K9nuLFsdv5Vyl7p7Y5xivBsdljyabS4h8tZb2MAOPSu9vrJv++a5a4h29e1USzn5bKFRvBwaqLBEvU1p3CKFzmscxOzfLQSWHhg2c1lyQ268j0rR+zydGNZl1EwHy9PSpbsUjDuDAvPH4ViSCLngVdubWbJwaxpbaRW+du1ZuQFG7WFRuPeucnZMnH+Fa8sT4+c1hSxYOV6dqych2JolRm64rp9PijHXtXJW6EPxXYaZbMWyTkZpKQ7HZafbKSCMV2un6fHhWY5H0rB020bCknFdrY2bNt5raIWLyWUO30NY99YxAHaK65LGXb8v8qxtR06fHX2rQTPNNRtoQM4HFcdexQ8lq9A1S1mVWJ615pqdvOWIXP5VDZJzN2kOSOwrLhiSSZIoRuZyFVfUngCmahDcKuWNQaFd/2PcXGuTDcbOMeSvPM0h2p06BcFvwrLfQqELtI7u+1bw74XWTSTPtRUZbuSNf3rso9ScJEvuPTjJzXjfjT4zWcDpa6LD+9JYfKM79jMhTgAmLPYZJGM9cDy74gfELTNMtpbWK8WJI2Uu8eMxxjkYOF+ZuOvQfQmvF9I123v8AVBcWiRxS3kywwfxHbEoO9i3zbRnjH3sjNXUlyo9mlCysj3fRNW1nTI0SWY3Gogeb5QO2zs0KvGpkWIDcRu4Hr8o/iNeuxWylks9Ku5ZXGWkcKI1xyQu0bFTJ5GOdvXOQK+bPDvitvDkMMBm2Btyt5e5nO48ktxjnPzdPpXb2/jw/b1jvBieQqM78kFwemMAKOBjj0PWuCpVud9KCR9CXHgu11N0DiK3nCIpVCVjR84BUBVI6Zct2AGOc1yfiBbjTdJ8y0nuGhVCdzQqi7Aed0YAKDPA+bOMkYrd8PeObyfR/LiuGt+Nu9juO9VGSykYIUHA5xkEk8DHk3jvxR4q8SeHdU1Lwh4d13XNB0+b/AImGr2lnK9hby5+ZTOiiN5FIwVQl14JVVK1wVKmmr0O2MOyOFvPG/wDZ+qLBqNo0wLqTv5USZwDhQ8w2/dzg8YAOKXSfiFJa3fk2sMbQp8qILuSWWNg2UktpZNkgU9Cr71G7aRtwa+Qk+KOleJohdWU/k5JBjeRj5bDgrIMRSKQRghvmU9emK7Lwzq194s8QhiLucodv2mDEshb7rDbKHB4+8rbeMGokhKSZ9ueK7CP4l+FILa9mU6rCxfTJGXyhIWyZ4HBCqm9tu3k4kA7FjXyCyLtDY7dMY/T+lfSfhG9+y2sqyLJHcjYzwqm1G8vOJEjBBSUZJLKenGDwK89+K2im28UvqkSIkepL9oIiBCCU/wCswDyAxw49d3Htrg63/LtnkZzhFZV4ryf6f5Hj7RIBiovJXGK1WtWXPFQ+W3GBjFehc+dsVxGp+UCr8FspxUMcbbsVsWsTD3J4qlKw0i1DAoIAH6V0drbDr0rNt4X+XiuktFKEbhjFacwyZLBD/DU4swOCPyq+kqAcipGlUH5eaOYZnpYL/d/CpUs07AVb35HzDj2qRHB4PtTUhFF7FdvPWse5s0CkseRXRSzrg4xxXP31wgyaTYXOUv7cL14rlriNOgrdv5DJkrXPzQzFjgVNxNmVJEM8D8KWJVBGRV8Wlwx4StG30y5Zs+X0qkSQW0KnoOK2YrQBQAK29P0SVhzGcV0K6C7DIQ00UcI1jhQcflVN7IDg16DNpLRj7rZFY8ungdjTA482ijiojZjpXVfYB0ZcYp66dGx5FFho5VLNRSm0AGMZFdjFpkZ659qt/wBkK3HpSK0OEFsOrCp4rY4rtG0KP+A4HWnxeHz2J9uPSkxnESWmFrJltRnOOK9Mn0R1Hy8/pWPcaPKGC7KgbR579m546CrP2MYHy9RXWJpM38KGrY0h9mdlbRMWcOlmN2FWriWmFxium/smXpjj6YqxHpbhenFAj//T/UW50pF6MK5C90kkMYz+Ve73GlJg8VzN1pMQzgYHpXkSpHUmfN2raVcqSUNcDe6dJkjNfTuo6UpHC/pXE3eiKx+59OKz5QPnuXTXGcZpkGnSFh6DgV7e+i7eQB+VV00Urx5Y9qOUk8k/s8jrxWXeafGycHnoO1e6/wBhgjlf0rKu9BiUfdBzScBnznfaeckdu3auXudNcjOOK9/1LR1UHCdq46fRn3Y28e1YygUeOy6YzfeFY82i7zgA165c6W8ZLMMViSW3z5XmsnALnAWmgNuB5rudJ0CYEbAeK2bG0ywUY/KvQ9Js1fjGKqNMZl6Zos6hRtyK9B03SJguQp//AFVqaZacgYr0HT7Ln7v5VtGCQHFrp0ioCynisa/tXwQUr3JdKDJkr09qx9Q0VSh+Xr7VYHyzrkbDPy15fqZC5G3pX074k8PqEJGOK8e1rRI+V9v5VDiQ0eCX8qJlSnFfLfxx8V2vh/S20ueQI2oRZxz8qRbxuOBgZLHA/i29MCvsHWdIiGW/u+or5u0r9mvxd8cvj5H44VYLfwj4eu00++ubm5WCN54o1fy40IZpHDsCQq44wSM4OVVqmuZ7Hbl1GVaqqcFqfkn49+JV+NbtrRlTybf5ywKnzSp+YgrxyRgntnA4FUND+IINtbOjAtA775FYqdozntwMnPOMBRjiv0o+NH7CVrrcI0nQYRbO10IvtNpIC0cWMgIkgZW3/NknG3j0rxHUP2H/ABH9kj0/w35SXKtEyRzSAF1Aw5OASVHACgD5iTzwK82ebYWUfjR9Qsgx0Zfw39x4pdfFzStOsLOwsrgo7MTKqJ2O35CScbeAMelbWifFGI6rHe6lMPLWEnbuyIwT15LYI9RjG72qj+0X+yd4s+DHgxvGmqjEEMm6QIu0MJV3bhubIii4TqS2B0+7XifgLTtF1O5tvN+bKYHHb35+vv04rOFWlVhz03dGVfDVsPU9nWjZn03L8VPFnjnUtL8NaHNe2ljcXEX2u4VQZTbQ7pphCh4LeUjbP4Q2CQw4p3xM/wCCuviL/hbK6d4c8a614e8B+EZ303RvCugSfZrdbayBh2TBsxTG4O8O8pZH8xnOGCsvs+k+HtM0HV9G1d7SUwq6I7soC/N8jqCemUZlB+706CviH4xf8EsoY/ixceKPDviU/wDCMX0094YV06Rr5Hc7/KiUlYCXcts82RPK4DCRBvZ4GrQp4n2tZbLTS9u/z8+2nUxx+HxFSgqdHvr0/peXoeofD7wL4I+L2v3vin4RNexeG9WVLixi1QQperDLPLGkc3kl4yyrGF3qxDY3fxYH6r/Bb9mTSdPS1mvrfyjGm11twVXKDaGGNpPPGR0659PCP2XfgzrmgXUUOmWttp2j28cFtBYo7TvbWtmgRFY7MuwOXdyRl2bHYV+rWiWmtSiCDTlfAIXGNroFVccYHOM56dcVw15805cvw9PQ9GhS5YR5tzMvvgZ4G1O0/s8wwldm1JGIkKkjgfM24hD0Dc88e3xZ8cvhFq3hWOKaYfabZWzBcoSybDw8WTnlWwy552kg5Ir9KpNVls7dfImVyz4MR2/cPA+6doBGOvGf05LVrTwv478PSeFPFjxJA0TLKzKyzxtzsaPdwpQ8jCrz1O01hTl7Oan2KxND21GVNdV/wx+M8miIuDgGq58PxtyF9vSvX/E/g/UvCmuXXhvWF/0izkMTkDCtjo6j+6y4ZfY1hx2WCFI+lfSRSauj4CUHF2ZwNv4bjyAF+ldXp3hOKTGE/Cuws7FCw4ru9J0xHxtAqlFBY4Sy8ERPj5AMV0EfgNAB8v5V7Tp+gLgbQBXSx6CoByPpWiggPnKXwZGg+7WRN4V2DHUfSvp650KLqyj0rmbnQ0T+Cm6SGfOzaBtJx9KqNoLY3mvd5tDjDbsVUfR0zgD9KnkEeEzaDHGuCTzXOXuix8jca+ibnSYmXaRg/SuK1LSE6ipcRWPn670lVzzWX/Z53fL0r1TUNKjU81y8lmsfHX6UlETOehsCOBW9Y6bLvGO1WraELjdXZaVBGZF4rRREXNF0h5RtxXcwaE5Ubl/wrovD+mxMgO0flXpFro8WASMiqUTRLQ8Tn0Jtv3a5ubQj3X9K+lLvQYimQv6Vzs2hhWzj8K15CGeADw+M5Knj2qX/AIRzkBh9OK9y/slEJ4qSPS4ccDNS4oaR4mnhhCOV/SrK+GE2j5OntXt0ekxnkdu2Ks/2VF6Co5Uacp4Z/wAI2nGE/TFKvh9BgHt7V7edIjx8lB0aILtxUOJSPBpND28ovP0rIuND3HaBgemK+iJtFg9BXNX+jocdqSiDZ4MNEYfKOhqcaM+B7fyr1KTRABtHQ1XOkFRjOK1UTFo8uOlYHFEej5PSu/fTMMSG/AVHb6e2/GeD7fypNDsf/9T91rmwBBGK5K90kDI9K9WuYJCNuK5q4tH5PPFcMomyZ5DfaWN1YEmkjduxwK9Xu7NupFc/JYlDtI61lyFHmsujryDjIqg+ljIAXpXdzweWSSKzJBs4C9afKgOYTSl7D9Kp3WkIRwK7SOP+6KbPDLs+UD8qLIDxnUtFTBIXp7Vxk+mRISCte4X9nK+QBXLXWhFm+X8qxkho8P1PTY9uNtckdH8x8Lj0zivdtR0E7duPwrmZdFaNxgVHKBw9hoSKQSgPpXpeh6FAVHy9eKSz0glxjivQ9IsAf8KrlQE2m6BbqAcYxXeadpFqqLkU3TrRABkf4V3FlAi4wKaRRVg0y1CgEflVG90i1K7wvXtXdRRLtxiqF7b7gflq1EVzwrXtDtyrbVrwPxNoKoW2AV9a6tYSFWAXArxzXtILg5WnyEHxtr2kyJvwKoaleXnhL4O2HhvRk8qGXU9R1K5JJy66hfTNtU8YYoQfbgCvaPEehiFWklGFXk/QV5Z8fILrwzoGi+DoPnu0Q3lzHnHzyAbE6D/VptHbGG+teHn0ZOgox6n2PAygsc5z6L+vyPIXvdWvdVSSyGfLcbEcgkjbtXHXlRiptGt3nvV1G4Agk3/TeFwM8DoSMgVmC4j8EaTDol60kOrap8wVTloY3HfoRn06AD8K3JodWtp4bmXc8SDah9gNuPQgc1+MZ5iIYaThf18j+gsIva01JR9DxT9u911/9lnW5tYt2fTdFeG+mAVGI8nmMsG5xvCbduMNg+1fhx4A8WWNjqzSw26+QPlVZOecnHzcc8Y96/e/4tpJqfwk8Z+EEhVv7V0S+DbsH5liJXHYY6/yr+a3wajXGqSxjKlDk56grwM59SOmOtfU+H+PWKy+pH+WTR+ZeIOH9jjaU11j+R+5Pws+Iui3unRvq1pHeRsFfy5HO0bMAZUcD0Ax/gfs/wALavceI9KMM8QMPEgjkYLtGMYXcoAG35iVH06nH5TfA7w/r1xCl20yWdug3uduDxgkfUdAMfjX6h/D3UNSt9OeGaXzY9hBBHlou4jLDDH0yCPwxX0tSNnofM0ZaanceFUsrXWFg0tY1s4oQYwTkF8j5mPOQuABnAzxjFe13XiKO3eKJYQZ/M3gynbtLAHACkg8kc5xgdeteRaEJ9clns7G4jit2iLRbRtRN2CVbkL82cYxj8c1zusa9ptptL/vJkaNS42BfMUFl+RT1AJw6H6+lZNmp9GaXqz6jaTm4YJM7qzI2MsABk7SAeAPl4yB0zjJ5XxP5k8IutBnkbyZd8camOJGGfmKupYrkfxBVII+bgc+TaX4vm1myi+zfMHwfu4IbryTkYC8gr2PcdOwmnhgsmvy7ossib2hfoQmSpDYUtwOuHBIxXPOZrGBwHxk0seItPs/FcX2hrq1YWVybhVWXYwLR7tihSUYMhIyDkYwMAfPbaTc+n5V9TXGraprbX2iazDHKt1Buivk2upe32yRhiAsiF0GB5gIJ6Ed/OJtGZDkCvocoqe0oW7aHx2fUPZ4nmWzX/APPbHQ5ycgenavQNE0eZdo29PSrtnZujAKv0ruNJi2bfl716VjxzR0rR59oBOK6iPR5wnBNbWk7GwAp4rt7a2DR4xWsUUkeTXGj3JTIya5qbSLrPzKa+gZtMcpjFc7caXyBinYdjxf/hGJZsZBAqeLwccYwfXpXrsdkiHla0UtodvKinykHhF14PPHyVwuq+FmQFWQ47DFfVs8UQXbt6VzN9YwzLt2c/SplBAonxXqnhtF3EjH4VwVzo8UbbMfpjivsbWdBUt9wV5nqOgwIxYx8VEYETR4Pa6XaMQrL7V6Hofh6z3KdnFb9vp1tv2iID/61eiaBpcEpB2DitlTIRd8PaHahV7V6Ta6PaDADgHvWzoWhW2wLt/SvR7Lw1augKrQom6PIL3Sk2bQa5WfS5VPDV9BXnhaIrwhIrlLnwvbq2Chq0iWjxR9KuD93H4ihNIuOBtX8q9jXw1Dj5Vq+nh6HOCvSk4jR4+uluF+dR+FE2kqPvL0r1/+xYwMYqneaGn8Pas3E0R401gnoag+xqDxXpFx4fOfpWe+hygYA6Vm0Wjzqe32r8o/SuTvomXlR0r2O50eTHK1y15oknRR+OKIomSPKnSRhj8KhML4LentXo6aGzNgL+lPk8PMF4jxit+XQwPI3tjkY71Lb2bI/wA4yO1d5LoTJIB5fGanh0dtwJTtWEl2N4x0P//V/okuVBGFFc/NDv5OBiu5uLddtYk8KAZxWLiXc4K5g5PSudvIyDnH0rvLqFQTkVzl1Co56Vk4D5jzm8WROAM1hyxSE5K49q724gTPrWUtsjNwuKlxGpHPR2LMoJFW/sPy9K6eLT92AvFWm0xTnArNotM88uNOycise50wjPy/lXps1oVyNtYVzZOR0x6VLiB5HqOmS5wtcff6bKp3IK9d1GwuR26dK4W8sbtWIwaiwjjYre5R+ld/pEE2AAOnHSqVrZz54B9K9A0nTJwAKqwF/T4WwC4xXZ2ka4BxxTtP0Uj8K7Oy0XjGP8iixaMNV24IHb6VTvJmHG3iu+GiFh0rNutDJUgjHatIxJkeM6tesinaucdq8g1vUGUsuP0r6M1bQwN2FrxjxDoW5mVEGewrSxmeHJdWX2xtW1ZEe0sMSGJ2CrLJyY4zn+FiuX9I1b2r4n+KXjo2WvHxy7y6hfyqfIe4haBLq4dVZ38hiGEMJJxvGWIHbaB9zeHPsnim8u/NtA8FjqDWNqrYEckqBmedvoqjaOgBSvzy/aG8U+HvhXc+Kfi14gsm1C38G2Tz29nIdqXd07pHbW+8biqS3Uy73I+RFbIr814jzydStDB4T7XXsv8AhtvkfuPBnCXsKbr4pe8um/orLtt9/kZXwP8Agx4n1rxDfeKPG8r3F/cAzv5sgec7hyWGeMLz6Ae1fWegfDxri8ubCVD5dnkRf3scdc+9fFn/AATx8OfGFLvXPj5+0xcsNWZ2uzapCtvHEs6t5MHk4Hlk7lKoxLiMZk+bNfbfh74tWWmqb+5O7zi+85wCW5PH8hX5nntHDUv3N1pe7ve/nsj9Hpxrqzt0WlkreWl0fMXxKuI7rxa2haDErTbmt8Yyp3KUbI9Oea/lphsdQ0rx1e2NkAq295La9N214WKMvGfu4K49B09P6jL7UrE+ObnXYfld33xhcA5PT8q/Br9tz4CeOP2fviZd/GnR7NbXRfFFxLcCSJAbeK4eQEjJ4BkkZiO+XOOOK6/CnMKca+IwcnrOzj203/T7j47xKwM5YejiorSG/o7H058II9Q/ss3bAkIm3YwVCU6ckMFGOOvPvX1loniyDR5rgPbvmNUSLkpGXB+X7uQNp4yQQPfkV+Mvw9+OUV3DGkkxk8vqrnEg456d+fTnGPQ19seBfio99KtzaOUM6ABSMr8o64XDcn1JGevrX6tiKTi7NH5hh6qktD9R/BPxVsh4eGnsqyRbCN7kA7l5UhtiEsuMr8/Poelcr4s8WW13px1FpI2ETAtuYq0UhHy7ccKM4z1GWI+Uivkex8QXUNzJNDIZBKhB3PuCnnayhuMZB+UYIOQQetU7/wAdGDRp1e5aON22FFJCM5PyffP3d2B7dOlcFtdDu59D7N0jVb+DUY5njVbWZFEqvjCgg7Wzgk4O8HaBk9s8D3Q+M7ax0uSF/wB9FcRwD98275VCBCVYdArhSQpUg525HP5oeB/iDLbWi67HGb6D7kse/aSm0noNrfLjg9M8dq9R8K6lo/i3X9Q+Gvj3z10u/V4QY5TFIPusGibHyuu1WKZUEj1OK5KqOik10PqHwRYQw+K1nsrZ9N+0PMEgWTem4Z80KvzBfv4+Q7cAZVa9Bn09QM+grwP4IWvjXwt8V5/h54maS702+lkvtEvWY+Z5kavE4+bBCzqjggfxYHXk/Ud7od4p3RqdtfQ8PfBU+R8vxLpUp+jMGx0wM2eK9C0XRFDDjj3rnrHTr6PA28V6Ho9tcqRkEV7vKfOo7PTNGhVAxUV3NjpduBtPtiuf0uKUKuAcV2tpDKcZ47Vdi0RDRLI/KcVmTeHrXNdrFZnABFSjS1k6ZquUDzkeGbdz8pApf+EXhVcKcV6cnh5m7/SpP+EckUFg351ookHk03haFlx3rJuvDEWOa9pn8PuAWRqxJ9EmCkHPFRKK7DR896p4VXoB9K871Hwrb4/eda+jdW0iVFOfoK87vdCZzsP4Y4pRgiajPFE8I2vmgLjr9OK77w/4atgy8LXWQeE0Zv8AOK7vQPCMW4ba6OQxRq+HfDMSxqU7dq9JstBhjQbhj8K0dD8OJEgVR09K9Dt9AiWPDdqjl7HTHY8wudHhVRgDmuUn0OJjjGK9uuPDcbKdua5m58LndhCc00hSR5JNpCKAQv6VANGjTqR+Verr4dcYHrU39hLkhVoaEjxqXSYcAkdPasmbRoXOele2voQ6bcVVbw3HjAXmsnEs+frrRgp+Xp1FZLadIo6c+mK+hZvDFuOq/nWLNoMKZ2ris3AuLPCJbFm+Up+dY9xYpnlcV7ldaasa4Kg1z13psPQKKqCJkeRRabASeAK010eB15rt47G2R8COtmCwt+pjx7V1KJgeNz6BAXKkcCp7fw9bsN23mvZf7Kt2OQgpY9KtwPLxxWEoG0Wf/9b+k+UjGBWPc7B0Fa5iJqnJbnHX8KLBc4+8MIJrnLsRtnqPau6m04vk+ntWTNpQPNTZAcDJboTt/So0sICd1ddNpTZNV00zj0+lS4AmZQto1p0sQj4rcTTRjnoOKSTTMis3AtM4+4idR/hWHdwOoyOfau9k03OOPyqm2nKcgiocCrnk90Jic9qxpYAxO9K9cudKVlCkYrEm0lV+8KXIK5wtpZ269V/Ku30uOzXb2/Co00wA4ArTtrPn5Vxily2BM6/TVscD5q7CxhtRjmuHtLbYFH+eK6y1TaASelTYu518FlCV56VFeWVrsz0x2qlDOwGc8US3O47cdeBit40yHI43WLOAocD6f/qr518R3emR3E+nqv2i7wYwqybVjzwSSOSw7KvA7ntUnj/4u3eras3h/wAETQxwpIYGumbBlkHUR/7I6ZHX2FcANKvdEXzbyVUMg3BwuR8p5z2yMdPpXiZpmKpxcKb16n3HC2QQrVY1sQv8Mf6/I5HUdC0/Q9EtPDvhWN41sC0nmAdXbk8n+JjjK8Er9BXzNffCHxB4i03ULazigW5uVtnX7WFkjjkguoZRMc5H7v5mB9QD2r6t03xpNrTONFje4hjJxMyDZkcZAbsPWuI8S+NNMs/tHiXWrmFbWzX53UbI5G6ZJ/i9B27CvyXHYGDxX1u/S34W0+R/QOErvD01Bbqz+e55JafDyxsNJtvCy37f2SJnmImUrNd3MpzLPIx53Ofup/CoA9q474iX37P3gCyUeMNQtrVolMnkiXzJ2VBy/lr6ds4x9KydU8IftB/tHNLr1lfyeBfCreYsNzLaE6hKN21nW3k2GCMKOGfDseRtX73g2vfDD9mf4TiS08R6/d6vPGySXO+5aNZZ05UuY/lPJLbDu5I9BjhlkuGmuevJRv3V38l08vyPGxmc4jmaoRcmvNJff/wDw7xx+2f4X+H+kSeK/h14J1DxBZ+e0UVwECK5EZlwkkrJGcIpdirMqj5c54r8of2z/wBsD4w/tNaNovw31zw3D4W8O6pv1OSzZy120tmA0asAV8sBiCQRyVHQDn9HPjB+1j4c8M3El78MbLTdKj2+UbprZGu5AOSvn3OZGBOflUAD16GvxX/aj+OWvfF/4gafrNxK850oPGHiBm2tIQThgccBQOPTvX1nDeT4KhVU8PS1X2np06JW+X5n53xLm+Lq0nSrVVZ291dvN/0vI8i+HeoXPh5XTSodtxbkEzAbvLJIx0z1HB4ww4I4Ffa/hHVIoYomvGx5HKtHz8j9SBz97odvB4IxytfHul/ECDSDdLcaMyPJEyt5aqNxbguVbGD03AYBxnrWW/xL1cyn+z28kEgA5AK46YC8DHbivra9KdR6I+Lo1I01a5+kkHxHtrkNZ6nOlosP71Wckbto/gwMcg47D1wa8p1j4z22p6k0OmszW0Rkz5mDvGMDIPJ2r0+nBr4Z1jxxrAtkmllFw24AHPc9SO3+cVqQ64nipra20dm+0SZWQY+Zx6cdfQDvXOsDbVmzxl9Efcdr8XLTwHo41LVgb20tjF58kIBC24YKxcdWAypOPmFdt8W/i7f+AdZ8HftJfDa9i1nwXr00djqMcREsENyoz5cqZ3AsBtHOTjGc4FfG3wh8TaNpPxjh+GnxIto73RdfVITlvlQzDyzxjkBsZU4wPfgbPw+8E+I9B8M/G/8AZGeOGWTR9OufEVtE6t5hl0lEuPkJIZZI4QAo537cFSDwvqdNS97y9HF6X8uVlrFT5bQ+Xk1rb0aP6Df2b74XnxB0Gw0zVxq+j2drLr/h1bs+bcr4e197WXaJDtYmwv1aIHGY4SFbmv0/kh02U5ki69q/Ab9ljxQdd+I37N3j/wAJTxrFeaL4hs7nbnyjcaffxx3YXd0SZZVfYcgfe+bg1/Q3LpQDsAg2it+H6bhKrFrXT/25focnEU1NUZR21/T9DnI9M0oD7orf0/TtPzsVR+VTvo25chK2NO0UtKOo6V9JynzNzotL0mzLABR+Vd9a6Ja4A2jHpWTpekvHivQtOs5GAO3pV8qBMyf7IhT5REMVMunLFjEYGK7BdMmZc4qb+yZlAGzipsWcxHAw4MY9qmaAlfliUCunXTXK/cIqX+zZV/h6U0gZws+lSMARGK5660W7IJAx7V6tcafKByOn4VzF5ayRg5OKmSHE8b1Lw3P1b16Vwt/oLRsSq9PavX9TkmjzsJwK871S8uz91j74pRRMzlI9OuN4GCO3Suy0TT7gOuQcfSubSW7Zx855/OvQNFF44XnpWjIiep6DpcroNw6Y7V3sWkqYgpFcloRuyo3Z4xXfRG5VQw5FZm6MmXTMDGOnpXOS2GJAu3pXaTfaCfSs8W9z5nQVUUKTMGPTwE+ZRUT2kYH3OvpXaR28nAIBoa2Vv4cVdiTziWwDHCiof7NXHtXoh0rcc4qpJpAA5FZ8pZ59JpMZwuBisW70Ndvb+lekz6Ww6H6VgXVhLghs4qXEEeV3+iRn73AHSuUutAjlPBxXrVxpcgGQKx5NHY84IojAJM8oTw2oOFrfsvD8gRVxxXVDSHBx0rWt9NuEHGeOlb20MTipvDUnTFS23hwK2cfQV6A1hcDrmpItNuO4/CspGsUf/9f+lTejd8VGWTHX8KzTI3OPSmGVjz6UNCTLkjIe9Zs20Dg1KzYHFULhmbk1FhlOZ8deapG4I6/pRc4Iz6VnHOcGrsK5ejnLHA6VZ+YjioLcY4bmtLy94xU8ozMlX26VnyliPkG2ugaIkcdKga33cg5xUyQzi7kSoCQf0rnJxPzjt2xXpk1oG4IrBuLEPxUgzio4p8jGa3rO1uGOcVqQ2jBhmuns4RgEYpMaRQsrKXjIrpreyfGAKvWvlY5rfhMXGOKlFHPmycD7teBftK+Nbr4a/CDVfEdiuJ5I2t0bONm5HZj9dqnH19q+qv3G0Ia8a+N/wm0b40/DHVvhtqsv2T+0Yj9muh/y7XSqRDL7qpOHXoyFhSrc7pSVL4raGmH5I1YOp8N1f0Pwt0rxwq3lmZZiVtjv4Pfufz/wr7NsvEkPivw7G7zFYhImVz8oOO5PsAfQYr8Gbn4oeLvhh45f4S/E6wm0nxnYOYbvRZEY3fmIdhMUeA80LsP3MsalJVwyEgiv0C+F/wANP2z/AI7WUGmeF/Dk/gnw/IN0mt+J4pbCL0zDYMFvblh2QxwxHvKMAV+UUqGMq1ZQhSbb3X+fY/Z6GNwuH5atWooxjs/8rb/I9e+Ovx68E+BNL+xarcRxafAm5Yojgl0/iIHZeMZ4HXtX5waP+1B8bf2ifEX9k/st6HqHij+zziKfTLU3ghmTH8Sf6NE+04D3MkYGcrjqP2e+G/8AwTI/Zj8Jzx+IvipYyfE3X1PmNd+Jv31ksjEEmDTgfsqYI+VpRPKB1evu2Kxt7DTYtI0+KO3tIAFjt4UWKFFHACxoFQY9lr6GjwZKsk8ZUt/dj/n/AJHl5n4lwh+7y+lf+9LT7l2+5+h+BPhz9lb/AIKXfGRlHxd8TWPgPS5Qd32y9Oq6njj5WtLErAD25vMDuDX0v4Z/4Ja/s/Wdq0PxD1bxR4wnJ3GS41P+ylAxjaq6akD7OuA0zdec4Ffqk1mzsAFH5VE+nMeOK+gwnDOXYbWnRV+71f4nw2N4uzTFfHWaXaPu/kfzlf8ABTv/AIJ//sY/Cf8AZvufib4W8DW+m6xHqGnWUNzBc3ktxIJ5dpQeZcOGyv3iVPyjPGM1/KFq1n4nhjeBb5442WdzGJt8MMcL7TGSB8xU4Q44DEjsa/st/wCC1l/eab4O8AWF+yQaPFe317cyth5Xn8oW8MFtF1M8glcmTG2KBZMldwr+RP4jvaeJ73SfCnh1xajxTcxQwrjH2XR7ZtyN/wBtyHuGbqy7Aa1nCKquKWit6L+v0OSnOToqUnq/+GPmu/1LXLx0/tm5kd2RSgbHKnoeB/8AXxWjDelLowq/ysu7n1pt1FNrWvajHYxmaHSgxBxwFLYX9Bx9KZa6Ld6p4fXxDZxnbaq0kx9FU88e1U4r0EmzT1e6u9IfFyD5KMFkkxwPM+77Yz3rqPGemXHw38ReHvFNkzx6bdfLuB+VJUIJwR2OMj0xWvrEWmp4et7fVsnStbsmVJ8bvJntmwc+mOq9MjpxWjoOt2XxE/Zb1nQNVZftPh7UdPkgbHa4l8pvp1zkdjWC2Ta02fz0/Bm1tXHra6+Wv5HpHx9s7Hwh8SPBnxjtv3mk+KrPzpwcFRcWu2C62rjGNrRuAON2eOa9r/a41rUfhH+0t4G/aZ+GFzJHf+MNLt9RngT54pLy2jW1nU5O147hcKydFycHJBHzn8aPCHjXTvhD4J+E+rI8uq6PLq+o6SxPL2beS0sG3uwKK6YGNoI4qx8ZfGMHxN/Zp+DXiDSov+JlocutaFcyRNl4zHNbz2qHgBWaIuy9c1zQo8zpPdWlB+mtvyOmdXlVRbP3ZLyel/zP3j/Ys8LeD5vjVq3gPwywh0XT9V07xrolqcPCumeLbJoNludxYxpN5YxhQoIBGVFf0Hf2LcysSDX4cf8ABO7wt4f8U6h8Nvi/pqStNqOgR2zGKQCOO0lKsEeDgj7PdWTKjLwiuoxg5r+giEWpbc/Ujp6VOQpP20vNL7lqRn7/AIUfJ29On4afI5mz8PTORk11th4WXOWPNa9h9kVueK7CyNkRlele/ZHgIx7Pw+6fLzxXYadpLqB83StG3jtSA4Jro7JIF46UFJFe204IMk1opp47mtJIYyPk6CrKRoAD/KgoyF04LVkWAA6dBW/FCD2xVtLWIjkfSmBwl3p0bKecVw2paTE4+9x2Fe4TaZCV2kVzN9o0bLnpT5Sbnz5feHYCCOce3FcLd+FLR5sDPNfR17ogOcc+lcvPovzYOAKcYENnjtp4PtFIwCfwrvtK8K28e1Rnj2rpodJdGGNtdXYWM6rjqDVSSsKI/StDiVcKOOK6+PRQI+tWLC1nCjPFdTFa5XnisbI2RyDeH1k+7Vf/AIRzHPIrvTb4+70pphdehxTSsM4Y+H/K5BNRrozqeAea7VxKFCCs2WWVMhT0pMRzbaRIPuis2bSHHqK683s44GOKrTXEjD5gKFErmR51c6dOrHbxWFNZTv0zxXo0rMe1ZkqqqkAYo5SbnnMtoScMOlZUtoR716JPFGTt9KzZLOFuc9PanGImzhI7Nozgj9K04IDgAoBXQi1ROCKtpbQhtpGM1oSjBijA52/pUvkqzcLjFdJHbwcDB/Kr62cZwAuM1k4miZ//0P6OglIFGemKZ5uO1NMihs1q4mCkSMMj6VWliVhn/OKc0gPFRly3FTyF85QlteelMFoOoqy0hJ5FV2uSowKfKLmLMcAHGac21MetZU19In41Sk1E9D2pqmL2iRti4iXmnrcwr36dK5V7lwflqLz39afsbk+3R1E93DjP8qx5rqM/KP0rKeeVuegqlIX3dMVPsR+2OgSVSwxzWxAwPpXGQtLkZyK6C03AfNxij2Y1UOjjY8AVdil2jaazoHUqCePar6BM88VDgiuc1I5QB0qNi2CoqHfwCO9I0mDg0rWK5hsk9xHh4nZGRQqsvDKo7BhyB7A4rlL12klLucuepPJP1NdDN8y1zN1ESTxjmtYoyk7GXLIozng1Qe6tk71amtJD3rDmsJMnHFXymXMW2vYMcHFMa7tz3/Ks0WUhPtT001mdY+u4gcdeahxKjI/mI/4LGeJ7vxh8fp4vHBaTwn4JsY0SxhkAdo3AeQ4XcfN1KY/ZIVwpWGKeQEHbX88fjm6PhLxDqevapZQXOvpZMdWvoflgtZrhPlgiXoscKDyo1HJCFj7/ALf/ALaPiHW/iF+0F4pNnFZ3UtrrU1zbpnzbWCXP2b7XM3AeUQoltAoACoj7SQxY/i54huNGFxB8Opv+JjoOhzXeravf3ACnU7+ZsRRybcArny0wuQEQx4618vGfNOT/AKt/XQ+o5OWnFLseIfD3wvq+n+Dxr+oRtB/ac32ht+ATG7BI/lOPvDLDrx6V2/gvwnFoGv32g3h26XrKyW67hzG0iEqPfOQQPaui8TWXizW9Y06TUdsVvO0LQQuoR2VYxuaRP+WZbPC+46Vc8OQWnjbxJfeHdTR45rZ8RmNynkuFLB+Bgr2z2AP4KrNtN/0v+GKpQSsuxwvwQbTm8Gf8Iv41fCtqZ0meNxhY5dhaIjpndgrwQegr5p8V6P4r+CPinWfAN4zpDNOkUnGBNFA4licex+UjHTp7V7bqWiCH4Eah47imEeoR3aRzsfl82S1uMB07bsL79cV6d8V/Bv8Aw0L8DLX406M6jW/Dlqyaom/74hQuz4z1KKGA/DHet6dRQqXl8Ldn5Nbf16GU6blTSj8SV16Hpf7RnxD1W5+EPwf+Mfgy8X7fo93cw2rMmN+6GNghzjKnZscd844ry7xfY2/w/wD+Fk+AvB1rHfaJcWGk+LLG1JBk06cSRsksRxgRxJO8MmAN0DKCw25OLo+uaN44/Ys1Tw9fXJiu/CmpWGo20QKjebiQWcmOMkbJCfYj06ejWMV1ffGv4Y2mvJ5lp8RPBdvoV+0ZKvLFiSB2ULypJjQZHoeOeOanajDke0eb8Gpflc6J/vJKS3ly/K6cfzsf0if8EpPBx0rwLoE8M0d3p7afq9/pzx5jMceqTWdyyNGc4KPLIo54O7AxX7LC2m6rxX5V/wDBHrQdUs/2Z/D+p6lI10U0WCDzi+/dIbmcSKPTYYdvPOAOmK/X+F37rmujJsO/q7k93KX52/Q4c4rJ4my2UYr8EY9vFehwuOK73SorrAzUNtJuOFj6dK7rSo+h8r8q9VUmeXzou6ba3BVcEiuusbNmODmrGn7dv+rxXUWXlqR8uKXIzRNFa00tuh6VeTTXFb0EsQAFXjLF0U/pRYNDl1sWX5h0pFheMgeldESh4qo0eH4qkGhS8tyPSsa9tm2nHNbzJODntWXcrMRT1CxwV/DIudv6Vyz2chbbzkV315DcnOBmsIwXSv0+lOKIZh21jPvGc4rtdO06UqM1UgjuA+3b9K6G2eVRyMUSTCNjorGxkUAVtxxMmR0rIs5XPB4rVM7447VnyM0uhXVg22qb+aRgj8MVZDlutWYhu7dKfLYLmC5lHAWsudJW5x0r0OKyVx7U6XRopBllpXHY8oYPHUYZx1r0S40WJOo+lZUunQKPujHpVqxFjlVhD9aYbGJxhgK6B7OFeF4+lMMG3G3pT5QOcfRoH6CqzaAvYV1qpjgEDFNbgfeppAch/Y6pzinDS1yAfTiulCO4x1FSqhbtjFSxoxodIQY3Dirn9iq33RWwkTbcg1djg7CsWaxR/9H+icTBuvFNMq8CsQXRAo+0kEV2cpwcxt71H4UwSAc4rJFwegqX7RS5SuYulifu8VTkzgY4pvn56dqZ5haiwXK0yHqaiMYxzirDvx0qsxx05qkQxyxIeaFhQ1TeVugqNZ265q7EGj9lj7nGKjeGDOag87iq0l0CM0rDTNBfKToAKvRTIlcwblW6cVct52Y46VDRSZ1sU3GKvRN0xWLbP+layuCMVmaotAnIqNnbHXpTTOoODUTyK3zUDFZievfpVZ1DDrTHkHT0qnJckDINAEkkSkbazpYAOtD3uB16dqoSXWRWiM2SvEvIWvA/2mfibN8IfgvrPijSpIo9UlT7Hp3m9DczjAYKMFvLQNIQOy9hXtzXSQRPcXDrHHGpZnYhVVV6kk8AAdSeBX4s/tmfG+5+LHi1tC8IzLHo+iwsIbhxhHLnEsu0As5baPLT5V2rls9K4cwxCo0n3eiOzL8P7Wquy/qx+H/xrh0dbIeBtKuJZb7V7trm6ZSBOqbVXzJ9nyxKF7fwj+83FfJeq+EvAmhQjxUkIiu4pHGnWEPVU8vZAFQ5LyPu3bnHDEdME191fELUPDugxXVhp9sLG0kb5d+G+1yt1mnmxl2GPu/wjj2r49tLm2W7m13w/ZS6rqNxduJNSwSx2rjEWeFjwNoA5K/Mea+TjK2x9W4HivjbTLy68V6Zp98GJRHuNz/JufiMDqMoDtxj8q574JnUfDv7TV34b1mI29zewR28DMu4Os48tHHp8y7QR0r3nV/h54g1K6F5ALhfsmVEUhHmnjJC7Q2RjJB7Hr7Jq+kW2qfGDw149htgt9pFmLR/MfAlLkqqybuvlnO0NgYbpkCh1FyuPkxxpvmUuzR4Z+zt8KJfjR8NvF3wFmBsLv7dMsbPhiksUrAI/Y7HIfqMkYBqn+xrc3Xh7xF4m+GF3JCmpR6fqtpNE+CJJLSOSNgucfeUuMYzjoOK+hXk/wCFFft1tP5J/sXxssOtx7/l8pnUxzgMowdkgLbh/CQOec+ceOvh5pPgrxV8WtEsZ/L1rTtMuNas7yMfvbiO7j+0E8HA/e71I7beMA0Tq8/NDpLlkvLo/wBAhS5OWa3jeL9Ft+B8PeAPC95P+z/481gIiPp1noU4Eg5dJ73Yuz05PJ9P0+n/AAJpOtfEa7+EvxN00Nb3Wh+INI0KxRixSeG033xlXjZHI00bo6jkYBxiuP8AhRLeePP2Q/iL4dit5IZ/C9pBcCeFkHnwQ3JuBG+cHbERuUemdvPFevfskwagPh38PZrFvPW2+KunmaLhlhiWwZpHI4wAjE9skHBzWuNrSUKjW6k18uRE4LDxlOnHo4r/ANKt+H6H9a//AAT20nRPAv7OVh4t8RCDQ28VLHrP2JuZIvtameRSFznEszqpUAMqg45r7Vb44fC3T/lnlumx3WzlI/8AQa/JIeI9N8MwJ4f/AOEYvjb6av2QTx6nLF8lv+6UKFj2gALwM4FFj4u+FkOnrOt94m0S43H97JP9vi/KN0kAH+7U4fMK9KjGlTikkvX9SquWUKlWVWo9X8vJdOx+nWtftb/BvRGxDe27vnGy5ke1b8mjrnI/26dGhmVNG0rS7lTxn+2FU/kYhX5aeL/jH8SPCOgy658PdfXX9JjXMtxay/bDD7T284Z4/wAVwK+NdT+K6/HvTNUhaysrTxRptrLd201ootYbxYRl43jHyByvKsuM+lRLNcUl8Wnov8jSOT4TZR/P/M/o/T9vWbTsC98GPP0/489St349hJsrq9F/4KMfBiS4S18W6RrmhM3G6a1E0Y/4FCz/AMq/mK/ZL8YeM/jP4ki+HOhW97q0U643RAyx2rEZUtLjZEP99gK/SP4c/sfftJazY3Wq+KL3TdOsLIkNa/aF1S8YL629mXAyP9sH6VEc6xCvrt5L/gFyyTDNK2iP32+H/wC0N8EPicfK8EeJrK6nx/qGfyph/wAAfa36V7eq70Dx8jsR0r+cOH4Cfs+2usxrrXjTXtKuY15tLqyOn2vmDq0crLdOi+xxivtj4U+Pr34F6E1/p95r2taQ4Aiu/t8Os2Q99qLAy/Q7a9Cjneyqx+7/AC/4JwVsi/59S+/+v0P1jxJjaB9KgeOYivzRl/bM8Ya/P5Xw717SdVuSfk057IWt23qFWW5XcR6DNcRaf8FN7zwrrjeH/iloLWc8ZKuvkPE6465QuT+n6V1xzjDbO/3HHLJsRbSx+sB8/GGpGHy4PNfB3hf9vrwl4wt3u/DGgya1HEpd0029gM8cYGSzQXDQvgd9u7FdzpH7bnwK1JF/tRtS0vd3lsmuEH/A7UzKK6qeY4Se01+Ry1MtxcN6b+X/AAD6wZIv4hnFVXijycKPSuG8HfGH4N/EG4+y+C/E+nahcf8APuk6pOP+2T7X/wDHa9MltGi4kUr7Hiu2EoSV4O68jilGUXaSsZkcUQ9KvpbxsAMVRbKt8tXYHOe4qnElSNaGzT+EVdFkKpwyFOCat/aABkmoaLT0JEgA4xSDbH+FVjdEHg8VUZ3J+ajkDmOkjuAMc8VYe8Xb1rllMn0qT5yc81k6RamX57jPTisWZnc4q/5ZY46VILIN1pcth3OZn3LzWXLJIDxXby6Ynes46coOemKuMkS4nKLNOPvVPEXbnpXSCyh6EUp0+MYx2/KqYkjGiztyxq8gGP6VppYo1Xo7Adh0rNotGHGrfdNa0CP+ta8Ok7myorVj0ggggVztG0T/0v6AQpGcUbcgY6CpgEUc9PSguoHPGK7rnnqI1FP5VKEx7VH56ntTxOrcVNykkP8AK4x2FHlrmgsuKZ5qg0DsOljXg1ReNQPl9aseYmM0fIflNFxWMwqe4qIRN9a18ITz+lKqLT5ieQyPKK4pr2bsMAVv+WnXpTdo3YA6elPmDkOVFm44H4VZit2U5HNdD5SU0RoOe4pcwchRjZwKuid+KmAC8CmPtUbaXMVyjftLr0NPa8JA96pOynjoajHynJpaBqXfNcrzUL8igMCM0MQDzTEZswJIJqpfz2Wm2Umo6jIIYIhlmbt9Mck9gByTwKt6reWOl2j6jqD7Ioxk8ZPsFHcnsK+E/iz8R9T8bzvpViJIYbY7o4gxjVcdyw+83bjj6DmufFYuNGPmdGGwjqvyMH4+/FjU/FdhPpOlJNZ6PAVLybgm/jK+Yo7cEhMjGPXmvy18Z67pGjX8z3ILQXALpDCdtvLJuA6A5Uv15OOK+ofFOpatq00Uem33krF8rrBkBR3AxuJyRgkenGAK+dfi/wCDpfEVv/wkOuJEdRhEcQ8vLIE/h3YHpgDuBXymJqSqPnb1PqMPSjTXJFaHwt8V0XxFdTXeqj/QXwrpKBHGmznAzncfXOFzgAcVgwWkuuauLjTtMiGlooVXEv2fcU5bbgqG4Hccn6Yr6MtPCAn0h9J1SxMl1JtgE1wUmgXA3HCKy5wOOnGawtG+GsjX7aONLhlKFXWJmWKHb32c7egwMEYxXnSlY9GMb7HzX/Ytj8OvEtz4ilkkiswvmbYcSJ+73ZXI4GRhR93nr2qn8Xr7RrL4Pr4xthEl/K0MU7j95JLbSsELMFHOzA3KvIXJ9h9DN4fnuWEeiWUURSFo2t5trIuSAu1gQOdpGCM4x0zXUav8JdANmk2k6bDbLPgSxQ3fkbxgPkRkGMfTGQc4rnlUSaZ0xpNpo/LL9s3Q7iPR/hT+0Boky3Umlq2laiPulTMfMtnZQMbXQOvmDjfsGM8Vu/Gfxb4N8GeM/h9+1QkMi2fim0uNC8QROGKRlEXblemwxebnYT06cCvr39oL9nl9c+ANuZ9LWZIWeHl1Bii6xkEdTGyrxjOBkY4FcRp37PVz8c/2LPE3wrtLyOPVtNkjvdNM8Xm4mtsSqAwACCYKY2K8rkHDA4rSNem401PZXi/R/wCW/wAjOVCalNw3smvVf5rQ/PPwP4ci+B9h8X/gp4riFxax2mk3MEuQrT6PLdeVJcxsACyi1uVLYBXKketen/s7+F5PhraH4f61ETFofj3R4dUbcPMFrcubHzVZcYBjmilz15A4Feda94f8Q+P/ANgnTvixpEQu5fCzTaPqrM/+kDRLwxzpyPmCx3ChFGSqK5XG2vqJ9F8m4tdQvZTcReMfDSyzSwbY7i5a1t33smfl81BCu4feG0cY2mjGVVyPm6vVecUl+K1+40wdH3o8uySt6Sbf4Oy+R+pUfxiu7zU7zSLrwzBeyWtzLCWhkntyTGxXdlSw5xnkCulm8K3Gu6V/aGlRnQ76dwj2kjm+TYw4cFFVx/ulaual+0f4k04y6d4fnTRzA4BNzbxJDIOhIUfMFP8AfOax9E8RapqWqnxJqHjXSGVjn7Da28c0zLjAbbdNFGRxjjJPtW8ZLlTSsZNO9mc34K/ZZ03w340j8ba145ure7UH5NO0Znb5uNj7piWU9Cu2vTbD9k39n/wD4sX4jabc6tYsTIFuLvwnfy2ETFDuLYkaONNp+8yhB09qr/EfxVN4N+H8PxY0i60Lxlo1lKIr6w1PQILSay3HB2yWjtHgdM5BHv0rjfCfxe+EXgH4p6J4x8Lw3sPh7xFbFb7TrO4Yy28MoMcsbby0dxFk5RXVX4wG4Fc1Rrc6Kd9ke1Q+L9V+FWteGpY9C8M674avrhY9PuNMBEXmqQNpjURqkq8HDJnHQ11fxs8IeIvhbr0/xo/Zo1aCHRbu4Z/Ms5QHhlBy0BXIUhTuPzk59DXE+HvhFrfw6+OF54G8LAa74Y1HTm1XQb9oy1u4nHlxlWwfLZGbbIMbhjHQg18e/CT4sar+zT8X7r4TfESOPVvDV44tr23kXCNF0DqMnYy9Qc5xweDXNvzPdLp/kdG3Ktn+XkfdXhr4v/DP9rTS5vB3xFktdH8ZONsF/EoSOeUcDzCnQ56D7voK+JPE2sftAfsoePZj5kum7H2rPCzPHMB3Yj5Sp/2uO1df+0X8H9I+CPxSfxrpFlNq2iXaw39neveNFHJFONyMog2jjG0jjB4xXaXninwZ+1V8NbjRtNYWvirTIfMSK42Sx3MMQyyLMYmmV1H3Vbg9NwoWmj+B7Deuq0kjT8a+Iov2lfg//wAJ18NtHGn+NbBx/aMdk6Qw3cBX/WKrKSGBGW2/hXzJ8NP2tvEMGrx/DD9oAT6ppySrEyXjJLPa+8ZcMBj/ACRXzd4S8beI/hD8RY7uE/Zrm1fBUkr8h4K444I4Ir7F+N3gPw58TvCek/GbwGGdLlDb3li8vmtb3ECgnywx3iNl5XOVGMZHSjb93L5B/wBPI/NHX/EHS/EPws+IWla54F1SaysdTX7do94vzwvGh+pII4DbXO3uMVr+LPiJ4O8V+Iri4uLm40aS5fzPPtQtzB5jgFz5PyOE35/1UmfRe1eR/An4h2GqWz/Aj4sJPceHb+dXt5VfdLpd391biFW6cHbJGfkdeuOteW/GTwJ4s+EPjDUPDGok3cFpMyLPGjLG6fwuBztDLgjlgOmTUU5O77mkktNPdPofX7/4ueCbC31yS9Gt6NOxWzvoJBeWjlOq/vVLRyAdY3VHHoQM19E/A/8A4KEfE/wpcxaFLrktggOAk4NzZf8AA4ZCzRj3hZQP7tfBXwo+J/8AZNxLo+uZu9N1BRFe2rHAljHoeMSJ96JxyjAY4yKq/FTwRN4X8VNYWl6moW1xBHeadeL8huLSflGIwAHXBSRegdTgYxThipJ+67SXbQKmGi0uZXj5n9F3w6/4KQ+Gnu10f4xaX/Z5yFN/p/76DnozRZLBT2KFhj0r9G/C/izw1400WDxH4RvoNS0+4AMU9s4kRh+HQ+x5Ffx3fDpdc8S6dPoerX1rp11p0StaSXxMcEsO4B43kVWIwSCjbSB0OBg16x4M+Nv7Qn7Omq/8JF4euLrTrWYhnkgK3NjPj+8ULRn8drV7uCz6pH3a2q/E8DG5BCXvUPd/L/gH9bv2hlG3/Ipv2gjkjjpX5Ffs/f8ABU34d+L5IPDfxujXw7qEmEXUApFjIf8AazzCfrlfev1c03UrDV7SLUNLmjubadQ8csTB0ZT3VhwR9K+nw2Lo11ek/l2PmMThatB8tSNvyNyKVjytasUfALCsqJhGB6D0rQiuUAA9K1k30MopGrHCPu1ZAtVOSBWS12oHB4qublOg71nZsq6R0O63UjpioDdRrwnQVgGYHj1qMzDp6VXsxe0NqW6B59KpNIrkmsiS4Gc/lUH21BjdxVKmL2iN0bR+VTlE7VgR38XTPFPa+Vud1HKHMjfVu1XbclX57VzYulxjP/1qupdbcYORUuJSkj0C2lVMFq1BdoMMtecR6ky81OupTDoOlYcjNeZH/9P97DfEdaiN5n7p6VnSRHHFVniYH0r0eU8y7NU3nOeKkF1IOBgVhqkn5VOAyjrRyoVzW+2vjGaX7UelZSjnmnL6Y4osh3ZrJdg8LxVhLgDAFY6tjryKnjbGMGlyjUjXWfHQUqz5PWqCsKlXaMCp5Srlwzt3pn2naKqsxb2qq0fHJoUUHMaS3YFL9qySnpWdsAqVUHenyoXMaK3WOnantOh61RVV61MAuKnlQ0xTNH2HSnrJGRxVYKqjI4qnIdp+SiwNm6NnFRTCKNDLIQqgZJ9AKzUuSg+Y88CvHfiD40aWSTw/p5G6NVlYk7QxBH6Dp9enthXrKlHmZtQpOpLlRwPxJ8Z65ezzvo8gkis3Ktbr1Cjjgj+I4+b2+UY618l6tdQanJI95/q5gokfGzZxwi7T8voSOnQEdvWdY8UaFFPLHdb7OZsFS42bs9OB19/rXnOueGdJnk+13kaSLM4YyW7AEHHHyj8ulfNVqjk+Y+io01BcqR52/gS11CWTVorprWQKcvbN82Og6/Lxj5QK8a8S/DzTJ4Y3ju5Fcn7jjerHg5IXg54Htg4r6ittB1LR7RbG2vmljnYjyyqFgv8AF1GcAH04x64rmb/wzK7prOiyS741KiN1G0u3TgEbRj24rjnHyO2Ej5KuvBfhuyt54biFG8sfeh3fNz3DBgPl6e/auXv/AAz4Pn0yRILNLVJ1ZULDfktuxggcY5OPQ19W2ujeJkuC+r6bLdIx2jaq7Cp6DnkcdOOtVbrwmkllLI1vPpcO7+CMSZcY6DHt0rjqQbWh2U52ep8rWXgTVr3QDDp0NnqCh9jiIFGHGARuGAcDBH+Rmaj8KPEzRmac2YVk3tGqCSWL5Bkb8joSSD0I4Ir7Ts/BGheUNSa2vLl2xIsy/KMEAnjA9vy4rzXXLaO2vfKWznuDktmZwI0Bx2cY7Y71wTjY9CnJM8nTwFpD6FfaZ/aV3K19blVaFY5grjPWP5xjgH36dq+RvhBNq/ww1u48NXbxfZ543WaSImBW2Ftp8tuhXt1/kK++vDHiLWLSL7FeaPDDEJMefbADIxuYFhtIIA6Y/SvC/iN4AOo6+usfZJLyORzII2k+XaP4lDYHI98H1rl7xZ1W2kj87/FHwz0j4P8Axj1X4V394n/CD/GK3vfsV9IgVbPVJkzJBOv3XR3G4YCh0dvlBQ1zms/CjW/Avwt+H+lLIU1XwbrUkZhK72mswku+EMMnKxghW/iCbT1GP0Q+K/hCe5+DKXV3oVvbXWlSibAYyJIh+VSqgfKyEDI+6AevFfPOkXMmv6fINZXcYpnuYCvOx0BXI3DjcrH5Txjiuatip6NfP7rfkddHDQV0/l5Le337fcPjuPAHi/xJf6fr10lrKZzGJRK6wqzH5N0sZLQduseztWD4s+HFvZ3d9H4U1O/h1bRV33GnOyTziIj/AFsTKp8+PHJAwQvTPSvkDxKNW8GePF8ZRTCS1uyyPETlQ0R2SxNxzkY4PbGOnHuWmeO5bfxl4a8UR3Mkf9halHpySNk+ZYThZItxz1jUlPcCvei7U4tbWPBlbnlG3U9A+DP7Qur2WrX3wv8AFMkb3N5E0cZlVWtbpHX5RIBhZEceoyDjBrc/4QzwR8TbVLD4ewJpPi3RY/LXT0dRb3qRf88e5k4zjOG6A18zftTeG08E+NdE+Ifh1Ps6f2hNasV4DNFIZY5VxwA6MCccA9hXb/Frx1DpXxS8P6/4ck+x3dzawXZKkKFmOCGAAGM/kaiUesS4S6S9D6N8cftNanD+yla+Dr7UJV1TTPEUC2Cozh1VYZHmBUfLtjYJjdwrkAfMRjpJPh5d/tR+GvCfxvllt7aZfOg1yZ5VR3kgAYFQfvSyAYC9B17V7r+0l8IfCP7Qfwx8/wCHMH2XxHNLY6w1mvlqssuo2yySbQzA5CqzHg5HQDpXwj8N/ipr3hL4k+H/AINhFsdD0SVtwD73nuZ8CW5kOB8/yhY0VcRIMDO4mudWcE4fP0OhtqbUvKx9Q6X4uuf2gfDutfB69iS21XSwf7KtPNBh8iAf6ls5ywT5lYL8zdq/Orwf8RNa+GvjcfZk+yXNnLteGVQpUqeVZSAR7jivWPHWu6z4S/aOuPFlmX03yLxRNOZVk5jO1WBCoBlcYAXin/tNeHLLw58UpviBf3f9sjxJHHqsEkcX2eJUkAT/AFSsWJBQ7mJ5bsOgv2e9NbdBKb0n1Kf7X1mza/4V+JXhZJm0zxfpa3ODmVILyJ9k0ay5I2vkPGj4kHz8FQMfV37Puh+HvE/wtg+CvxUt7jTbnUZv7QtLmaPyngl2bIgu/nBHXgDng1Z/ZR+JN78V/APib4My3Ut1d3tjPd6MqTyQyxalbIWi8vBKg4BXaVCkfLkV8K2fxf8AEGjeJRqqXkpkYh9zsSTnB5Y55/M1ioucfOJteMJa7M9c8Rt4k+Enju50PxjZGSaxkAiklUSE4xj5up4x3r37x98QtO+N/hq48bWsv2PWYEjGo2qR/ubiNVCCdAM+W6gDzF+6w+YYOQen+Ll3p/7Rf7OOm/GNoUOtaBMmlanIrcsJF3W05TgZ4MTsoyQFLdOPhz4f+Kz4Q8W295NtAicblUbldOjgqeoIyMdKzcnpUj/XkbKK/hy+X6Fa6uZbO4yrbwP4TwD2+g/IV7RdeFbH41eALKSDUpdH1HwfBcHYF80XFncSK7nORzC3Kr6M2K8k+KWhWPhbxrqPh2zm/wCPaQNGjZVjbTLvhbHBw0ZGD0446V6r+yx4lt7L4p6ZoWvJFPpupyiwuo5x8jQ3P7phkYOMN1GCpwe1TXtFqa/pFUbyXIyp4bTV/CelPDa3/wDbGV8tekTY7/K2QT0xzXonhr4pSaQzpo8rWm8bLiJujD+7JGflI7EEV4Jrtnq3gvxNd6PKDItlcTWxYHeriFymf/HaW8vLK6i+3+WDKn3Wydw+jDBx7VpOn0iZwqW+I+yP7O0bxLB/aOlrBaxOv760RQ0HPG+MHkA91z8p6HBFe4/BT9pH4rfsh3Im8Nyf294QeT/S9GkkJSEHq0DEfum/AKehX+KvzU8D/FvWfBd44u83VtcRNG0cmGXn8Bwe4r3m+8bstlD4g0GQy2c6fu93LIcfNG3GG29P9pccVFCrVpTTg7NbFV6VKtTcZrQ/qf8AgF+0f8L/ANpLwkPFXw0vvNMWFurKTCXVq5/hkTt7MPlYdDXvCTOODX8Zfgf4q+L/AIZeO7b4k/BW9/sfXbblrSP/AFF0nG5FQ4BB7wtw38O1sV/Tf+xl+2P4B/a58DHUtLK2XiPTVVdV0sn54m6eYmeWiYg4OMqflYAgivt8szqNe1KrpP8AB/8AB8vu8vhszyaWH/eUtYfkfaUJkPOakeKXOV5/So0lt4ztz0FI94gP0/CvX9p2PJVPQi+zS44PFPEbjhqRr3ANZ0l+P8KtTZLgkaywg9/bFIbMOOKxhqig4q7DqUb4LHpV3ZK5RJbEgZU81VNtOuMDNbiTxOM57cVKURhtHOaz9pYtUkYKC4QkDp0q9HPLwxHStPyEPHWo/sq5yKPaJh7OxDHfvnpV+G83cGoPsfOR2pwt2bjFQ5RLUZH/1P3WkuFGAartOgPtWO87ZwKaHZhx254r0rHk3NdpRjimG6TpkVnYc80xoixpjNIXag4FP+0xkfSsny5NvHanbWXk9KLAaqXYVttSC7Qen/6qxCGGCaFBDD/OKLCudMk69jzUwuFUc1zyM/Wpk3MTipsWbBuOPlqDzn6DtVZY2HFPX5ePWkInWZiKl84k1SZj91e1Tr0wKBouC6FWFn5yKyHbjIpVmAGT9KTRSNsTg8Gh5IyNv8qxvtIWs/UdWj06xlvZPm8scKO57CpdkrscdXZGZ4v8Uafp3l6Gkuy7u0OOcFEHf8eg/wD1V8u3N2gU2ur5FwCRHjjO0YX2AUEYHb69LfiC/wBT8RXTeINNkE8uCShOFPTjtjoAB2WqSeJLfVrIwaknkzJniRcYbjAHuQfy/Gvm8TiPayu9uh9Dh6Hs4pI4yfStbn8u61+3ivY5BsBwN4yc4wP4fp2FZ48JWUk51DRndX8wAxHkAAdF9PT2z9K9Vt9XvGRDOqKkOP3iMONoxj+X4gVfv98k0Y06WIMAiMBgkbvvY+nauOUUzqjJo8UW3l1NWXxBCd0K4MgjIKlhjAx1wBx2qvJoZ1SQjT4rpIVDfM/IOeTg+vGK9A1vSPE814GBgitoud0RYNz7cjnnpjArLvLGxCRRX2pXA2DKJt+U7j04+n8qyZtGxSs/AV3/AGZLL9uZScbEB5+XAG446E9vpXP6jJoenXFrb6bNJfSQSBpVJPIA6n07Dp2r0kWXhBoHzNPJF/AGYxgsPm6DHH6YFZVrbR6HP52mC0ZfLyhIPmnnPLDt/DnFS4lRlY4i0v8AxfqehR/YbRY5JF2NukJ8vYecccEDkVk678N5rWL7Tq4gvJ2UukZmYA47YIPUYPHYEV6G2s69M0lraXqxmQcAKCN7DbgfN/kVWfSNZv0eTVdReDG7cgxtPTOBjtxwOa4qsE9DupTa8jyk+CtMvtLNxrsH9nLH9y4lly2BxlArA8DGN2D0ry/XbTQNTBsLOwutRmQgJICI1kXuBuwQB0woPfvX05NpOg6dCuswSF4Yxlnch84wOAT6degwQcccY+p6tp2maW9/pkaW9okRxdMixlF/2FA3Yx+YPHYV5dWlY9WlVTPijXfBuo6JotzBqUX+gXD5gsXkIkUAZGTz/EOBj5eOlfF3xBtI/A4vr20tY5YX8tHydjguMsqA/LuXOcjoD06iv0U1HQLz4lXqatpN4sguSUleZDG0agHcPm+g2kZz17V8reNdM0fVrSeSzh+z2OnLJAobH76V2wTubg46bu+4HgGuFUbvXY7nWtHQ/NnxpPpGn6As2pRKbGXUPInK4O2OeMc9GAAI3fhU+meG9CuvDV74X8SjyI7aZPOMTsZ4ZoBiFygBGxlYbcY4IpnjS0eL4W6xFGjulrMiyBU37xF+7bOATkDjJwBSaXp9zYXmj+Lbxmks7y3Onam8fVok4ilB7MF49iPSvch7sUjw5e9JsoePrjxF4t8PW/wb8TvDPfxyDUtIv4yQl2vlldjgqBv2cK3ByArZFUvjHpmq+LT8M7PRoHl8RarYw2Kx7RuZ2kEdupK9vmJYkDaoJPyjjvvFNq/hvQtJn1Flku/D+tRra3QQgyWsxDA5HT3Hr0xXtd9458bedY6z8HZNIXxFpsMvmHMcmqxWrzM0aQeZmOPKEiRQPM2MFyOhTm7pRQ4xVtT1/wCBPxP0DQ/jrq2laxcO2j3DWunxXkBDFDp6LBHcxdVZdysRniSM+jV4n+3B8Grv4e/FPTvi94XtrZdF1e4ktnfT2zarf2p/ehMneqygeag/u5APFeh+FvE3wa/aNsTovxVsY/AviiNmT+29IhWGPzQetzbKNhBP32i2n0xXjPxD1z46/st67dfCD4sWcOseH9VQXCJKv2rTNVtEIKXEJ4+6SDuQrJC3XtmIwSb5PuNJT0XN954P+2Gttb/Fyw8S2syM+saVZ30ny7R5h3IQRyNwCDJXjp3r3XW9GvvjB+xw3ii5UXV58P5kf59m4aZdMBL82N37qQiTrjZnuK8d/a80Dw78QPBmgftBfCWORvDmiWiabrdvLL5lzo7mTMMkhODJbPu2eeFwjACQDlh6L+z54gv9e+C3jXwBpJT/AImGjzkDd5aSG3Xf5UmARtdcrlvlGRng05p8tOXy/QcGr1I/15Hn37H/AIo1jwR8ddBmtnaBre9hcnORhXGVGRjpwP5V5v8AtNPa+Df2j/GWgWxijit9d1FYxbsXiCNcO4UDoNqsBgYAIwBjFcD8KvEc8nj20uYGMLeckkJbgDaQRn0/p9Kt/tlpqKftb/EI6wS122tFpm2BG3NBCwz6/KVxu5xgglSDTpwXtpryQVJ/uoH6OfsfalJ4k+EPxD8ERFWjuNOg1FPmztm0+Tf90YBDKSDkjHv0r4i1PXbK51APDt2sQQ68gjr0/wDrV037PniPxL4C+Dvjn4leHJJUm0rT7ezZ4ly0S6pOLZG74XOQ2cqvp0I+R4fFHm6izSH5XP3u34isadP3ZW7/AKI3nUs4+n+Z+pHxi1rU/FnwI8B6xrMjyx2Fnc6XayOquqCCRWEYbG8YUjCbsY5UDmvnv4U6xq0HiywOmhWuluYjCrfMrSBhtGBjPPHGD2Br0/WNdku/2OdNMjIfI8T7QrDORNYyEgdRs/dj0IbjpxXkHwS02wvfGOnSSyGCKCVZ2ZsuFSA7y3qdoXkda42r0LeqOqMrVvu/I7X4ueO9Jm+MPiV9IVk0x9SuJIoJCGaLLfOucDIEu4LwpC4VvmBqrp8761p8n9l4aaJGkUAYdwBkoffAyvvx3ryr4weILXxj4qv/AIh2wKSX1xLdXkYwDE8zk71x/C2eR/CeuQasfCPxFcR+LbSTPmK0yLs6EjIG3HHbsK1q3iuZdDOk1L3WUL7xDE2CknyvzxxkV738DLlPH41D4TvcfZbzVIv9AmJxEl4nMLMB2J+Rx3B618OePZ5/CvxB1vw4NyQW2o3cMcT/APLJUmYLHk8/IuFBPOAM8133wl8V3+heLtN8UWj7ZbO6jOD/ALJz079K0xNK0eaPyMsNVTlys9Ej8T3bXlxYXSm1v7GV45oCfmSWMlWH4FSOOhFe3/Dz44eMPg1450r9oP4Y3b2mq6dOE1GJT8k8cny7mXur42SL0PytwRmvCP2psr8Tdb8faEAEW+k+2qnYSkMso9ucP+B7Vy3wo8VGS9bT78CWGYGKRezI/H8qGvdVRCum3Skf1GeCf+CxfwVtdb0rwz8cV/4R2XW4BPp94Dm2uFGFcD0eNvldeo47EV+ovgn4p+B/iVpEWu+B9Vt9StZQGVoXDcHp0r+EbxV4H8IfGDwfffAP4kXEls2nXYvdKvUTzJIZUUhhs/jWaI8p6gYGcVwHwcsv23/2SLVfin+yF40i8beFbZwXt7G4+0wFU6o8LHMZHQhSuD27V9RluaTlD95K7XfT0s9vvPlsyy2MJ/u42Xl/l5H+hrHMJDgmoXQt3r8R/wDgnv8A8FhvhR+1Ylv8NviVnwj4/hjAm029+QSkcFoWIG9c+wI7gV+1cN4kirKpBBGRjpX0VKtCa90+fnScdx7wOpzmocSrxV2SdGT61W6t6npxWymZuBahuJoyK0I9UmQ+1ZqBcZqyiIcZ5pNoaTRrprZHXIq1DrKlhWalojjGKP7LwcpkGs2oGi5zrINRiJzV2K8hPA6V5/LbzwjCMeKQT3SfKSTWboroWqrW6P/V/bR07Uq/Lz0q0wXjBpREG6V6PMeZyEYcjvS+cKsfZdy81UlhK0rofKxTKM00yrVRww684quSw4YVRJol0HX8KRHRazNzbQpGP5UKX9OlNiRurLH7VIJ0/grBDyZwBxT0aQ/yqbDNwXQB60/7Yh7VhAtninHcOOtIDfE6ZwKJJlByKxEMg+arg3HikUTvMM5FU5J9vPpTynGRSGAOCPSmBWFw+cjpXkfxW8T32m2ATT0LmLAZB1JcfpgfzNena9eQaFo9zq8uCtuhYA926KPxOBXyDq3jGa68SS216rSJcASof4H/AIQpPoSRx6V5eZV0oqmup6OX0Ly53siG08OaoYm1LTb3bJPjdGpwCT/CPQdAMdqhW9XWr2fRtbRXaM/NIhwMegPXkgj6LmqF3PeaKjX2k5uLeNQiDP3Qx659+gxXMN44trtoGa3WASEEsPkYsAOp+mcfpXgNWPbTOmbw3ZJcSy2F6yw8n9/x069fU9q6LTNP0vSnW903UUjf5QQ3zKOPWg69o99py6fqCLMvzs3zDOeucV59qF54GtctaSSxB2DKkYLAduQPw/KoaS2Li29Ge0r4yts+THKbl4wGJgBAJ6Y/z9K5S71y2bV0nS3utwuNpTgqqlgwPze3p3rjIdetrTba6TcMV3YRim3coBI/x/KvT7bVNQvI47mACfdhB0QgD/OOlF2yrJFFPFWpapbyGNQ32f8AgZdg3dgRj24p93LpGqwRJJEqsB5edpTDMfbsDgdvXpXHa3cPEq3FxbGGO4A37JMHMh2g8eo4x0BrJs/C2n6hbvdDUXt2Z8uGfd83BP5dD6fhWbuWkjv7K48HeG7h5NQi/etgkAhhtG0jaBx17n1H4cxqPifw7rjPAYJ7vD5CRbkTHv0/DPTArasdD8N6Pbm+817uXkoUTcipjDAkD/OPpWQ+saVpURjllRlkBVljHO5unHb+H9OBzWE9EdMLXOS1aa9vGjsvCEaQs+ADcbZGQg+g4GfckewFaun+ALyfzZ/H8/7hUyGZxFbqw5G3r0/ToPdNS8bX2jWLXPh/SmuJ3QITL+6XpwM7SzdMcdhnvXOW194m19h4l8fQxpDCm2NOUiix/DtOTz1H88dOGrFHdSkcV401nXtI1aw0rwJGllaXcjrtlVZN0bdxzjPp0HTp0r44+MdnLpWi2Oh6HLItkLiOPyTgpKVyZWAGWUBsfICArAj2r7ys4r6FJ/E91YLECPLhD/M+ScgvjjHpjgDnivkG40qx8c/EWPzbd7nSbaCZl29ZCo5cY4OT0GM9/SuaNLW50Sq6WPgGbw3b6nH4w8PXReOGWTaSm4q3mEEj5Pm25PQj1zXmE39q+F9Et9PlkKw6dKlvMkpwdpHyvg/wke9et65o+t6R4LHiiPfC82rsWg2jDxLJgYJCsMY6D8jW3feFmuPGWmmaFZLXWYGsblP7sicIWBUrjBGCfSuvZWZxrV6HJXNlL47+GupeHbCHGr2UPnW5H3JkXlQDng4HGM+nNY/7PXjbw38WZ7D4ceN1+yanbNt0zU8FZbSUZ2o4G0vEx6g9K6X4W/2n4Uv9U+H2rL5WveELlym/70tqcNjjjphl9OnHSvOfjF4Ej+Efxf0r4h+Frd4dO8SDz1j+6IbxSDLH+J+YD9Kz6OPVGltU+h7rd+B/CzeK5tbsGkstU0e7FhrFom3yo5uNjdQdjcYIweRkjqPrfwvr/hPxHa3v7Mfxht49R0DUz5+kGZVX7Jc4ziIr80Qzx+72le2K+U/jprOn6F8YvCPjed2S0+IOhmxv/mAjMtvwp4wQ43dx0HtXfX+o3/xe+CEOvaDKseq+DGIeRGaSdxDwqjaMDjngFm6AColfS3yNY2tZnlfib4Wv+zN8Y7PWPBtzPFoupod1reItzGqP8stq4fBliYcEPklDyQQK8z8W/Ca2/Z80X4t+JfAh+yeGV8N/2l4dV42H2a6v3SKG1jJbJ8uXciSJjERUAfKTX2F8dtXsPjZ+zRpPxDso5P7Ts5IxdPGF3Fo/4jnlQ3csfxFc38Lvh/bfti/s865+zTrUyxa0qrf+H7yYAfZr6A71Q4+9DMV2uuQMHII60vaWcZPa6v8AJlxjo4rdJ2+4/Iz9l/TbvxJ8XNNtiVWFrlC0shEaom4FmJJCjaMnBIB9QOatftH63YfGP9pDxl8RtMKWtlqWqyiBFU4ljtgtsjjJOA6wh8gbeRtBHJ91bwt4r/Ys8EyeIfGVs/h3x9rIks9J06+izc21vjZc3SlcorIP3UT7trFtybk+98M+H9RGsarHZWCIkK7AkUa42IOAu3+6AO3Sto6uVVen3Gb0UaTP0Y+Hfhc6b+yD8QvEVop+zizt7MyfIJY7m7lVInVWX51RwPMUP9w8givzh0/RLq9vpH0gq+7koGwQO4H0r7R/aV+J1j4L+Fvhb9n7RWLX2lmTW9e8yIKRe3sYjggQ5JdYbblzwvmSYGSCF+QvAtwNS1yK7tATIWGEQbt7HgAe56D3wKigpRoc8uuv9fIqs4utyR6WR9eeKro6N8DfCGmyzzoFuL/UHtwFUhxst0fnGVKhwNrEZ3fLnFbXw58R+HL/AMH6leaJCouTH5N8SF3mCQhS67VG0Zwr8ZAI5xmuN/a+1FNM8baf4Usbgy2+h6Hp+ivubIW6sYz5+PT53K9iSmCMg1wn7M9hNqviq90SDaF1DTLyFwQSMiIuGVeOQU+XHPYdcGYwSpRk0U5t1ZRXp9ysZXilzpl4/wBkx8oIHGMr02kdxiofhFJDq3xF0rT4chZb60RAvVGaZFH5E8flWD4kvJblSXZQx52ryD06HuP/ANVdT8C1tbDxJceN9TYxWmh20t/OwBP+oXKBdvzby+wKByfTPFViV7jROGfvo5/9om5s9W+L3ijU7CPymbV9SRlz8rGK6lQsM/wtjcO4zjJGK5n4f3c7X8FrBy8ssUY/3i2Of0FZGttdXumjUbuTzbqEb5GP8ZP32446/Nxwa634Z32n+G9SuPH2pJug0YRSCM/8tLmRtsC/TeNx9FWrqr93yr0M6T/ecx7X4+1SH/hYuuRp++tZrmW2lUj5W2YQ8dvu/pXhHh+yufDPihtHRmKhgYGPdG+7+I6fhVDTPEs+pXDG8k3yszOzHqxJ3FvzP4V6hLpUmr2VrqtqrNNDKoYoM/u24zx2U49gKzn7i5TSHvvmPb/F3w/1a88X+HtZhYWc2pWQMUxO1JJLZyhIPTIO1T6HFYXxF8Ban4X+Jb+KvAV1P4G8aXSK8t3bjy7S7mI2tFdR/wCrkyecOM85XB5r374w6vofgvUfD/wy8RRs8drpkd5e7B5lxpl7fuZBsHBIWMIZocfMGVl+YYb0jx3rGjWvw+8M+IfiPZrf6RqJl0wapppWWaOWJRLGwQ/Lc20kJ3beHjKsq8/KJwdSUeVrqv60/Q0xlOEuZdmfll44/ak0bQvES+Ff2uvhmbbW7Qi4t9Z0KY2l1uXpLAWKEccgpNx6V/Rt+wd/wWW/ZP1rwdZ/DX4jeOXjv7XZFb3Gsr9lmlUjChtwVGf1KcHtX5t+OPhZ4F+JXw9i0XxxDb+LPB0vy2mo2TfvbWT0ikb5oXXoYZcc8A1+MH7UH7BPxC+BdtJ408BzN4q8Gvz9ut0/e2/+xcwgZUj1Ax6gV9NgcVS5l9mX4P8ArsfL47CVVG696P4r7vzP9JTwf8S/BXjvTotS8Iata6hBIMoYZFbI9sV1zXBjIzx6V/lXfCL9pv48/Am8S7+EfizU9B8vdiO1nPkZJz/qW3Rdf9iv2a+A/wDwcRftXfDsQ6Z8U9PsfFVmhVS65tp9vfg70J/FBX0MavdHgOD6H92/2uTPynircN+6nk8elfzsfAT/AIOHf2SPiRe2ulfEy3vPB9xO3lmW7TNup9TKheMD3LCv3E8DfFb4f/FDRoPEHgDWLbU7S4XcjwSK2QfTH9K1UoS0MtUe+22rRIME/hWourQnoa8jaeVKEvJh7UOjEarM9eN7DLyTnNMLQsBXlQ1GcNxwB6VZj1icNtJxS9lbYr2x/9b9rPtQBzmrCXqKMVxTXLH71AumwMV6XIeUpne/2igHFV3v1auN82VsAHFKPMqeRFc7OoNwrE7aF2tzj6Vz6M4OfTpV1LjYaNho3Y4kfAq19jjxn8qxIb0YGTWh/aCrjvmp1KVi6tsh56cU8W8a+grO/tKPaTnio21NWHBpcrHdGiY16CoAibuuKzjqHGAaqvf7enenysTkjexEPu9PpTt+0c1gLeNnrirH2gtyafKK5rGYGoxc4P8AhWYZGpyyf3qVho8l+NviOHTtLsNKkJ8u8mYy7OyKhVT+DsD9RXyPPqQ1Cxa0vJTG9sxjh55ySecewAr1D4p+KbfVviPN4ellxF5Btoj0VZbdg7fiXOMf7NfM/i6GYXdneXa+VPbsglbPy7mHp69PpXy+Nq81WT6LT7j6LB0+Wkl1O/g8Ralpth9jMjOgPGBuPsCf8/SvNpfGvhjXbldP1C3lQxkudi7AMHAz7gAfn7VvaT4u02/to1baw3YO08jaB+ec9vSq2vwQWK/2vbgMwxlSOWDZP9a42/PQ6kvI6C3tbDSEk+x3h2MGZA4BwMYA9cY6fSrl/LKlzHfQsuV3opXGPkx/Ir2/rXztqPi/Rbi9T5DKoHzIR0kOAo4+vp2r0LS9V8N+JtLjSBJDtUybQxUjdtx6Y9x+FRfojSx6De6xdavZn7Hauk0A3g7MfInYHI5O2jw/dSX8TQxIsWzY6vypZecfy4+tcynjS00e2exu1nEUCCcEuOSAQR1/u54/CvPLHx5rFhqrXGkWRvIlwEWTOQrMWQnHHR1GO1JvS41roj2q+tb3VoXjd3WDhdg+ZmwEJ6DgB8j8M96pwalrMVq2j2cLRyQnfnZtZ2j4bOeeQeawNN8aeLNY8kafp+HCESh8qM46r+GPxFWn0rxTqSm+1q+Wzk37CE+b14/AHFYyl2NoLudhZJqmp6WdU1K/lsEB27Gl2s25eMfXB7+1bukaZD4bRb3wyiXt7OVVjdISdmf4eeo5xn0x2ryK0vfDuizvDdW19c3fJViAUAPcY55GMjHHFbZn8Z+KPKitrk6dbgkSKmBI3TOH6ruGD6dDWDZ0xX3Ho/iG5tNISDVfFty9zJMQIbaBeWZeVIXnbyCOQB2OK5D7c7Xt58QPGU/2e3gGYbVyTGoA+VETnn+6Rlh3qxp0nhWyuIotBjbVpycO5fKMe688rkcjjGeOwqh4q01IvJvPGkpKKB5NpECd209/Xb0zwfYGs5K5rF2RxfjHxPqmrWE8cEp+3aoPLSLCqYLZRjcSeOnHbJ5GMZrjNOubG0uJrDT/ANytsgiUg7kJC/QFR78iui1gxeF4pPE9nKsl7qDG2tt3ysI2XlhjAXb2PQ/xDNeZeG31EeLr7w/EFmg0yzkkuJThQZpVyNwIwpVeCpCn26VPKK54t8SNEsrzwfa+C5tvmXFw9228HcmWyNp2gH5u+Olcl4i0S50zwpqGvSbWOlajHsPZcbfu5Yeoz1+leq67pkreNNGa+HlNb6Wbh45N2zDMcHaAAD/tYJx3ArP8VadFrnwr8V6Pbni2kjupEjfdngHjdxjgcj6VLKjoeV+LH022/aY0rxVdEPaXuj2sd1iPKlpSUGccY9iwx7CuGv8ARvFtn468U/B74hSSyyS7tQ0KaVFOEydixiHamAPlAPOOua968UeFrLVfhfNfwjddLpUTMqKquHt23KeCRz3G3I7YryP9o/VITJ4G+PFnIVlkVNNvdzDY3HBPUr6ds1K1V/60K20PD/EdxrPxd0HR/h3rNpFLJYo3kIyEiKboRJKnGf8ApnvOMZ213/7Fdxqvg74iav8ABHxIwR9VjaJeH+zknjohXI7behPBxWl4uikk0DVbwxRy3Hh26juIZIFMkf2eQK+FPTbzgnHOOa6bxla29p4j8HfF3Qz5cEvlxvN5iDd8wwAgGQB6n6e1RL4NOmxcfiPGJ/jOPgHqviP9nbx1p1/JYyyyxzQlEym7lXTZ5mCBgj5gB6V6H+y78QPDng7x7p/iDQpZ28uXdtnBXan93J45HXOK6/8A4KW+B477S9L+I+nzlf7TtkR1aVgjOo+8RsRemON5+lflr8IfE95o3iG2tiwRVYAhV4qalO8Lx2NaVS0rS6H7Bf8ABRX9lbQvjPoGt/GbQNEf/hMNBtE1iT+yYolfV9EbAbzBszJPY4LJsXJjJXacivw58AavpXgW9GoaPoK3l3EVliudSm8y3t9uG3CCFQJx3AkcIOu1ulf1VfD3xLf6p8I/DvxDtDHNP4YuiJdxBLWMq7JkC4JbKev4V/Ot+3B+z58XvgZ8dtZ8E/Arw5c3HhzUBFf6FeaJo93chrG55jjBiidIpIW3RGPaCAq8DcANsHarHkkZYq9J80PyPnTx7oFx44tH8Q3c7NfO/mtdzDCSSSn5wSML87HIA6HoMV1XwD01fhrDcfGTxHbrKmkcwWchx519x5RIx88K/fk2+i8DJrmdL/ZC/bAv7RviB8X9C13wv4as4TPe6/4nsry102yg7uxkjADcYWIBGd/k+UnNY/xH+Nsfimxs/BfhyGWw8N6UmzTre4WP7U5kG57i6aImN7iY53eXiNE2xoMLubpnT5lyppx/rQ56dRR95qz6GN4w8SSeIyJ9Sme6uWd5JpnO55ZCcs7Z6lick+te6/BNo/CngDxj4wvH8pf7MOnWz/8AT1fkRKpx/DsEhP09QK+ffAHgbxL8SPFeleEPBNq+p6pqUwhtbWMgNLI3IVSeBwCWJwqqCxwqnHTftN+MdN8Patp3wd8IXK3eg+GHkH22NDGNRv50Xz7vDciNcfZ7cf8APNC+WEimsZQ9pJU16/cbKXs4OpL0X9eX+Rna1rsd/fMk5YgHKkHOSP5+le3f2NHa/s1XeoWDCF/EWswabIx6iOyiS9AB7hpdmSBxj1yK+cPBvh7VvG+p22jaBC9zc3DBUijALO2Og7dOv9MV698bdT0zwndaT8J/D1/Hf2/h6CQXN1BL5kD316wkuFjI+VlhxHFvUkMUPpUzV6kYx6ajg+WnKT66L+vQ8i0/Uwqx2N3y8ZywPXrgj0xxXc/FvwVr3gTwtotvf2jW8V3b2tw0n99zH1I/hO0rkcYPYVr/AAR+GEXxu+Jml+EbmRLO3nE02oXMisYorG0head22gnhE2rgHLMo78e7/GnWrbxa+p3MuJI7iTzIkdcfJ0QY/wCueF9uKpS/eWXQXJanc+HfDcGoG6RX+8mcehx/jX6vfA6DT/hd8Of+F1rajVdetYml0+0f5VtU3eSb6ZOPOhhkwhROjMu/anNfO37LvgL4VfFDUdb07x7b3WnJoulXmpS3FgQ+PsiqRtRsgK2cH0yMdhX0Z8aNfbS9e0bx58Ms2Hh+C1Gm6LFIhcWr2ikXFjeKTh5mLs8nIS6gkV4/l5XmxD9rU5GtF/Vjqw69lDnT1/I8RfxPc/E/Vm8M+LJjLr3mzTWGp3En+v8APdpJLS47KN7FrV/ux7jDhU2V9b+Jvg9p+ifstaH4Q8Z3U2ka1q/iC51Owju42VbVLWH7PL5yfeWKZ3wGQEZG/DCvj/8Asu0vtU0z4g+BINlrcXUVsbYHe1neMRiAk8sjZDW7nG+M4PzK1e9fH343an4d/aJ8ceCtRmPiDwtZa3cwQ2M8zN9mMYVJTZzNloG8wP8AKP3XVGT+KlFOVVKPTW34FScY0nzddPkfO+i+I/iD8F/Gtxp8UjaRqJiAnhkUT2t3A/3TJF9y4hYDCsMHGQrKc4+rfhl8cfB/jTW18FLAvhvxFdhhHpUsm/T9RjHOLKdwMtt620o3pg7dyAMfO9U/4Qjx54Ij+0TS6t4bjl8m0vY1CX+j3UgB8qROQjHgmI/uZhhoznFfK/j7wUNNX/hA/HiLc2t4gms722yI5Ap+W4gb7ylT1Xho2GD2J7E4y0kv6/rocbUoax2/r+v6sdf+15+xp8GdQtJ/H62Uvh3fJtl1GyjxDbTn/lne2/8Ayz9pF+XHPAr8h/iB+zT8Q/At4IViW/gk5hmt/mSQdipr9X/hv+2d4z+CmuR/C79qYSeJPDN3EtraeIFiM939nHGy5T/l6jUY3KR5yjkF+3pvxO+Gnh/wRoUPxA8BPDq3w91XbO0cEnnRWkUnAnt27w5++vDR+mK7aWMr4a0W7x6dv+B6HBWwdDEXcVZrdbW/4Hn/AEvwT8U/C34m+AIo7vxlod/pMcgVo5Lm3eKNg3TDkbOfrXpvwG/ax+P/AOzLrMWsfCDxHd6QoYO1srbrSTp96E/Jz6rtb3r+tL9nj9rLwXp3gzTfg5+074ZtPFXhdIxDa6ksStcxQngBxj94AO4+b1XufRviX/wQ1/YX/aY0hfiF8BboaRFfjejadJsi555Rfkz9V4r6HDYmFeN4b9j57E4WdF8s1ofJX7Fv/BxFo+qvZ+Cv2tdMWwkbbF/bFkC9vngZkT78Qz1PzoB1YV/T54A+IHgz4neGLTxl4F1GDU9MvY1khmhYMhVhkcjjpX8jPjn/AINqPi7YX5l8AeL4poVb5ftMKs2O3KFP5V+g/wCwB+w3+3R+wHfRabBrMXiTwhcuWvdJb5fJJ/5aWvJ2d90X3WPK7Tnd1wqyi9nb0OSVO+x/RHHHBwuBU62sJ5wOlYljKbm2julyA6g49M1sxq/TOfauts50j//X/YoWXYdKkWwC1Za5U8joKablSPlFd92edyoiW3VeDTQEXnGKmMqngVWcjjAzRcLdiGWdRwtZ012449KvPGDylVntxjiqViXchN8yn6U/7azd6YLI5z/TFBgEeM/lV6GdmPFy2cmp1u9oye38qomJz04xUQgejQLM1PtyrgLU6XSng96wxbnOemMVpRQSMwIpXKVy952Gq6lxng9KrLbjGT61cW2QDrUNo0SI/tDM2TT5NRhsLeTULriK3RpX/wB2MFj+gpoRBntXnXxU1P8Asv4Y+IbyPrHp0/T3G3+tZVJqMG+xpCN2kfn3PrVz4lvJGuJBFdXC/b4yepedN5C/ixBrKl8dabqdhd6LqkQjlCMCGG7eAByP6D6Vyev64r6bb6jo3y3Glz+Vx8pZEyMD6A9q0Neh8Manp39p3CiOaJ0hV04IKqCwGOw/+tXxfM2fV8qSOXjt/Dekvby28fllD+7VTwEO0EjHoBtA/wBoV6fcfEDw1qVmNP1e1jZNgAcHGFVSBxj6dK+dPFNxqqxx/wBhKtxFAOUPByR1GPbH5CuesTeDStzSSK6hEYPgnnJ/T2qee2liuS530r+E5NQLWCBCzAM2CvPPB/3c/litrStJsNbh/tGxkmtp3UGRVfKqWCn+f6n2r51uL+4spGvA8gKxxybXb/ge3HbjP4cV2nhvxdqkVgsenrGwnPmLKy/dyAwyPw6dqz5u5ol2O98S2Vta3AVLiWcrGUZs7j7Y/wC+uKr+EfiVZrc3FjYMYPKYqySAbv3IA4xx/AfqBxxVrRbHU9VvJrjUJ4pirD5Ex90df6D8K8S8X+GtDk1l9VspDBN5eSMn5pfnQHj1Xp/9elzWGo3PsF/FFtb6eNVSV7sxhyqx9DsBPbrnpXI2/j7xJqY8hbQxKST3fdk55BwBzn8K8t8Cf2loci317qiOjRgFBFnkkAke23GRXrvg7xhAXcP5a/Z32g7c5UDAYZ6/5FZuV9DWMVE6XT7jxJp9pxYfOoVVaWTnIBGcev3R6fKDWTFN4z8SyPbazPDZQKjeZDG5CqueueMhTnA/u8elN+IPjjW3so9O8IpFcyvwZGOAowV2/j2+g9a8v0208TeI7xbjVJlwhX92nCAnjGMfdJwCelYy00RvE9y0/wATeH/D0w0fwxHFdvE/7ySMbl3sP4GxwQP+AnGOoAq3qGtGfRpvFmtD7SZI2VVX7yHG1VI59gO3IxjIx5dqHxG8MeGbJ9A8NRhruEJIkhXPy9Nrn/YOQfb3rj7b/hO/G97bX+pypDBGodIIcrGhztKsmcnByOT7DGMUr2GdCviK/sdIn+IPiwLGltD5NjGAx+c8Bdq8tu43FBuH90gVyvhOy1bw14Tng1yOX+1vF0mzbGRFtDcFVGc8L/AVHbpXbN4str/xXpngvVNqmxfzvlfdHIo4+Y4HIzgYBOODjlWq6Hren+MPjBczW8qfYdA3RJC+0QtM/QAYUZ7BflB7ClbQL6/1sQfEt7KyfUkFz9nNvHZ6Xags0LeYT8wwMLnnptAHY14la61aaYPG3hK7uYriSdhD53yuuQoA5Zyylc4IBPTtXpnxk8PWlv8AFPT9cmPlvHbtdTxk4QsgwoOSMN1AUj6Y6V88eHbDVp9Pi1K7WTzdU1Fppi20tiRsgdOMADp+RqWikdr4Z1a0fxfDolwYlhtbA203k4KnI7jbj643Yr588X29h49/Zf8AGukWox/Y159qgKI/7tojxt2o7EEe35V67pt3bal8TPEF9Y4uobJePNd4lJVPmwRhhzx9wfQV5x4D1iSD9nfxr4n1OARjUJZUjjdlLqh/hUuvQeuBxVxha39dCZT0+RgfBp7HxP8ABjXbq3SW4eXSwsqhC53xDqxMT7P0PtX0n+zTotj8R/2RtRstYiAk0aT7SjQxqZVaPBA3bflA/wCBH2r5L0/S28Lfs3XvjOwt31Awx+a4S1jlXYODudw3lj6Aj2r2r9jX4kalrvgm98MxwWunQakjxyeRaWyOwI6eY6YXj/nmgPuKx5NEa8+56JdfFvQP2hdT/wCFaXssVnpunxrbpcJNNI7ZABLsUttvP8K8f7VfnP8AFH9m7xF8Iviw2h2bSalBuWSG78tUhcPzhcO/A6ctWpo/iKy8I/E/UdM0aQwR2d0UjDykt8p9QEP6V+jPx8ku7rQ/BXxYWJprj93FNIfMMaKOc7iWGfYY+tTrC8EaK0rSPafg94iv/AfwfubDxHDLprTQBI9wkXcW44ESl/ptBrH+EPjK4+IPh27+GmuTTw6jph8/RtRlt3a8TY24BA6iRwxHfn6GvIP279d1HSofC+uxS3n+kRRt5j3w+zsMA48n5zn3ZwPQV5V4a+KFn4Z+K/hXxLf3UU6TeXFNGpyzRt15JcgY9Ao9q51DlX4m7nzdPI/Uz4a/GH4j/FHwxqOreGrrWdA8c+HI3ttS0602tbakQOfPtJXRGLAfxBuK/LLTP2X/ANj39t7xXq3hTU9MPwY+J2n3EpuY/C6Jc6VqhHLN/ZkrMscqnmRbWaItk9SAB9m2N6nwD/bTsPEWkNjw94vjBKbNgjLDjc+7kegyMY/CuI/4KM/CRrCaD9pv4cXy2mpaLdLIxtwUmLkjlNgGTgDGB7ktXVCrJe7F+nocs4RdpNf8A+LPHX7A/wC0r+z74LubX9m7w7H4u0bxBarb3Xj3T9XtpBDYh/39u0T/AGQ6fHMQI7lpI5CIgUaUfeH5cfEX4SeCZtZgs/F3xE8I2d5aKkV2NN1AatFboDjc72iMg8vncFJwBx0xX9O3hH9pTWp/hrpP7VnwsWS7haSK38a6LBI0EzSIOL6wZDuiusE7sKVnX5ZFK9Ok+Pdton7SvgrwzrPwo1OLQ9Zn3XXhbxdBYW39janNIeNP1LEclxZXIxtWRUeKN/m2bP3dOFZacun9ed/+AN03f3tf66Wsfih8CvhBZXU7eE/2bIdT1rTYdLu31LxNHaeVNrFxLaN5NnpynBtrZ52jwHIuZ9p3YjT5/iK8/ZY+MnhPxe/ww+IlhBoF3pqqLl9QnitILZUQEs5DMIkVeSP4QK/ZvxTdftCeKbpfhp8atH1fwh8SdDb/AEDzoHsNL8Qx45+xyx7LMaiBg7LdzBd4325SQvCvzX8GBpXir4lah4d1xSG1nStdtbjcuZI7lLSecSjd83nRTwLuz8wOcjIOMPaVKd33/q/9LysrHTKMJ2Vtv6tYo6Zpfw9/ZI1fxJ8AtcjnvtT1iD+yNc8SCJrcaVb3AjkWSytm3G5gJCSTvuQy2/Nv82FPyb8SdL1/wr4kufCfim3WLULdkR1gk86FhKP3csUgwJIZRhopABuRlOAcqPpLRrPQ/ij4W0X4e3qi18QWcK2nhO7MirDKkhLx6FNITsWJpGJ0l2IWCZvsqssU0aVx/wCzx4/tbj4raD8L/GWj2muQuLrSdMXVoJA+mO4dxE0Xyu8Mc8ZU2sgBgZnVdmNg0inCLcVf+v60/wAiHabSei6eXl/X/DepfBD4K+M/A37P3xH+I2pabMp8SaLLpGmxcCaS386GS/nSP77JBEAH2jqw/DwTTfiWumwXllr6HUdC1Ro4dTs4iFmaNMmK4t2PyrdWxJeBj8jjMT/K+5fSv2pfiN4p8T/EXQ/jJ4X1K4sNMmiWDw/NaKLd9EvbNB9o08gZRZ03ebu2+Xe20iyBZI/MA8Q8WWSfEbQbn4k+E7OGzu7ED/hJtOtRsitnc4TUbWPJIsbk/LKnWzuQVy0Lo6zTptR5p21/4b9LepVSSbUYdNv6/rQ+qf2Nvh/qem/tDRajdXqXnh2PR73WZNQt1Atri20pftccrJJ8o2MmDFIQ0buVyDyfhr4opNr/AIu1b4p+Hb3+2vD/AIo1a+1GO+jyPKfUp3vPJnjPzQyr5mNjjtxmvtP9nzQ/HOufssfFvwV4SZ4pNS/sa28rjF5HdSzC8tBkfent4/ujHmFQp+8K/Oi1uta8M3NxrfhO68ie4iMUsTp5ttdRclUmiON4RjuToynO0rk5eD1lOV9dvkicW7RhG2lv6/JHe+EPHmseBNWOr6DIglkgEE8Uqb7a7g6+TcR8b0zyP4kPKEHr9KaTq/gf4m+Eb1bCCRtIilRtR0x2D3+j3LZWO4hfgSRPyI5eFlXMUoWRSB81+I7XSPE/hCy+J3hGHyrGRxaajahtz6bqAXLQSdCUkX95byYAkjODhlxXm/h/xD4k8IeI7bxl4IultdSs9yReYu+GSN/9ZDKnAkglAAkjOOgKlWVWHU4Ka7P+v6/I5YzcPOP9bf15ensXxE+GdnJZP8O/G+26s9QQz2F/CMK6rwssRPKuh4kjPKH5TxjPyx8Kfiv8Rf2QvHs3hXxJbnVfDd+/+naY5/0a+gb5TLDu4imAPUYBPyvkYYfpd4f1XwN8Y/AUup2KSW2ltOiahYhvOuvD+p4+RgeC8Mg/1UmAJ4vkYLKu2vNPEHwn0jxPo7+EPiDAlxsP7u4jP3XP3XifurDlexHB5pUMVyXpVlddV/l/XoVWwnPy1aTs+j/T+vQ+ufhb8LbD4i/De08U/Blpdc8KXMStExX95brnGxx/DJEflYH0r6C/Z6+NHxY/Zk8ZyDRxLNbRyCG/sJMiOb0Porkfdb8Dxgj8RPiF4Y/aJ/Y0+H8HxP8Agr4q1LSIo9VFlcJYTFA6zx7kaWIgxtgptBKHjpxW1+zF/wAFN/2ita8eWvhr4nSw+IxqEyRmW7tU+fccbZfKVMezgDHpW1DD1uR4jDTTS+TVv+AY4nEUlJYfEws9PQ/vW+E3xj8HfGLwZa+MfC8+FmyssDjbJDKv3kZexBr0wmFxt4r+bL4c+OPFVlrd/q3hq7m0xJA8ji3J/dugyMjo6Y45GQMV9a/DD9u3xDpHkr4qurbWNObAaeA4kj9ynBx9Pyr6LB5pGpBKpoz5zGZfKlJ8mqP2WHkKNgximeeiHr+VeSeDviT4d8caRHrfhy6juYJlDDaQcZrppdYOcLzxzXtKF1dbHkuaXQ//0P1ik1AjHanJfErzWAwwD6VIjMMD9K9OyPKuzqYrs/SpUvE7muVWSQDtUonkx9amxXMdYLiM9TzU4mB4HauRWf1pn29wdtLkK5jtPNT+lVnlj+6MDFcodTYZz0pTqO4gZo5A5kdCZEHK1Atwn/1qxftpkGM8U5SWAx3osK5ui4i6elX47pE5GOOlc5Goz1qRpdtFgudH/aCcCPBpW1FQAOK5fzcdKiknOaXKPmOge9yMV5t8XLsN8LNfLjIFi7EeoQq2P0roWncfyrlvG9t/avgbWdNbJFxYXMfHvGelZ1o3pyXl+hVKVpx+R+X+ly2dhA+jaswkgli82AkdVkUH8CM4rz/W7e4eQ6fpmo/ZSpysTcqQcMDnjqMVyFzqWq32lpp1s3/Ew0rcFJ/5aIT1+n8Q+mKrjxlo3iFGs9ZjMFyBGhJ4ZZB8vB9Mc18LzI+xSYzVb/xZoTRXSx+dA6biYuq7QM9e1X3+JGma7ZMl2vkT26uGEi7DgAjj646dq898U+L9f8KeHpDIgvre04LKw38jAU+orzx/HEGqWUE0IaBZE2zZXOMJkr+pH4VDdi7X6HRzeI7KOZbxn3iJni74G3aoOOnIP61o6Jr9w1rDBZ3kEO55BGpIJVWOVBH0bA9vyrzm71vwpZWM62t7HiUbSg6/IFxgeuAfyrsLLw94Kj8m705vvhZMduCP54J6dqm5Vkeix32vyzvFZXqKXbnYNgyMf0HNcwPBninRZftjamUSU5wfmGBzgZz/ALQ/KuMvNa8Q6dcrb6LD5iyKG3E/cXGB+fQ1s6hrnjTX9Ltobn/RYoACxUYcHgHp1GST9DUFG3eTX+mSxXFrdybUYxy7vlyjqefbDf4V3Fn4/s9Oghmv5EQOqcRsGb5h6D+6CfwFeIw+GLmdY5dVuGucb1O89c4I/DP+eBXoui6L4E+wtLfIkKxKPJZzlvMA4A9weMfSoV+hqrLc948O/EjwbJbtDJB5shU+TsXzCWGDg+hB7+n4VyWs2nifX9Ta8fUhZ2Xzl4toUtGw9sZ9TjjJPArivDF5aatfvp2gYtrdhl3IC7VPVR3+VgRkdvTFalz4B1r7a9pe3jfZVy0bO25RG2Npxx36Ht06YqZN7FpI9u+H+jeCr62D6VceexC+ZJGu5gpz86nvg53IfvAEDlkrM1/xfZeVeaN4ccW00SiMurCSJ26Y3DIbjoRgkHB5UY5DTfHFt4alu9P8LxGdIYtt1hVaMA4DHIOdgIG49UPPGMjm/h34X1HxR4pl1bUTFbm5nDGFvlKKeBnojdskgbhz9FdW0WpVtfI29G0iH4faNeeMvEBJneHzIH4frwGUMDkHp+nHFdT+z5azaB4CgbVIjLd69eSSMqg4KIdziRPmUr2xhyOykcjjPjpqi+K/GNl4eL+RFZMqGFQfllJweTng+oyD1xnk+265daT4K8HJJPMhaK32m3U85fgcZxyRjBxk8J8w2VdtbEN6XPJ/HOrr41+IOsW1jtdrkraEooiaOKPlgVRcc9/lAPfmvBvEC6bcfFvS9L0xlitNJXLiNnZVl6BsyFlU9sADHpXsvgOG8tPAutfE+7JgW73ugjaN3EZwoKq2A6jjHynH97vXx38GLm+1zx7eaxNvunvbx1jl2iNmjBxkgB+w7dKT2ch7NI9+uYLfwxd+JxFJNNPqgAa2WSPzUZlCh8Rk5T1DKre1Y3ij4dDwd+yf4osZI5VW4wHiZ2Qv7L95un+ycV6945ttOPxIt9P09Wgi0ezE7O0KTLvYZ5Ks34Nz+HQeT/HzV9J/4VMmiTCxurrVZk2JFH5cilj9/wCXofYrz/eq1ZP0I6WPn7xnqOlaX+xw2nQg/a5fL2AvLG6gkZChcI3Hrj6V6N/wTrtLPUbqaKf+BSSLoSCM8f7BB/X8K7j4geDNA0f9nyzsJbxrd7uNcxXEQQ/8Bk8yPH/fL/hXN/sVeDv7B1q+1C6txJbxKwUGNJg2f+2i8HsAKym9Io0itZM+QPiFFav8d9eisfskEf251CxxybNu7tlnP4k/gK/Uf46X2mR/APwv4WeXzZXKSb0DttBHsFH55r8+9A8CXcnxq1DXri2txb3GoO0aWUkWV+bhfKLSMp9Rjj2r7Q/a68VeLvDsnhjwvb2UVnaTIiE32l2c7txniUoHX/gK9Kwqayk+yOinpGKM39vu+1a1+Bngi18mJftLRqs3l/MdiZ/iQEZx2P6V8HX/AIg8QLcaHa3nnRSLja0kapnGOmADge5x7V9zfHPXtS1PRPBfg651rSpI4plkMNs5juOAP4A3AH0xXjn7X3gHWtO+I/h3X7Vbye2lgWMy3FzLcfMccL5i4VRjoDj2pR1jbsgej+Z9tfFrS7+/8AfD74n28s9zd6RcwKzs/wB6NyoIURhhnp1xgV9E+PNYt9D8Zt4Q8RyEaV48tvIQkMxSXZgZkwqbT0x83vnpXD6L4ed/hVofnpEspFu20pmRhxnaQMk8cEV8t/8ABRDV9R8N+LPBGs2qNFLBKD5kvzuNuCoDPIXUZHQKM+vaskr7djRu2nmeV/s56nq/7LXx/wBZ/Z0+IKxyeH9cka1dSTNFLbzfLGSwSJXwOGQDZ2KkcV9JfB6+tf2fP2jtd/Y88WXtxbeFvHGZ9Luo3EMtrcv/AKtgECqobAxiMAELgHmvlH9vmfU4vFHgf4hWbCV9QtVd5C7u6sgBCguzbR3woAr2P9pDV7zxr8EfAvxw8OxtDqWkfZ5mltvliWaIjcXzt3sen8qG+3VX+YktNemnyP0e+Fn7QXxU8C3Ws/AP4hCe+k0oubsWZME1/Z5yLu1VMxi6TGZoDGYpuuxDXjfxO1n4DaF8V7D44fHHwrBq3h7xBM8un/FLwvbf2RrWnu1u1uy6vDB+6vBHE7xnzbbzIlx8rMMjzT9pTxjr2had4C/bM8GhBLDHbtchAxaVXGJYhnCRrjP3SWJ7d62tS+J2i/B74qpbajBHJ8NfissKSW8u3yYL64A23IjHy8NwwkO5sFiMKDTjWdvIbp2fn/VjwX4kf8EmvF2kjRPC/wCzD440LxVoniK03aHba9dx6XNdWqJuX7HeQRvZ32EUERoltNGgBKsea80k/ZJ/aa0j4meG/jJ+0R4Qv/DV94f1FJtd1+QRXWk6naWyMRfNd2bzRW11GE8m5S48nz/lmQK/mxj7a0v4jP8As3/EC7/ZC+PmmPefDHX5ftOl6tLbwstreM4k+2BRGISFkIb5QxiIEmSd4HrOhftH/EH4NfFmL4U/HTX7qwSWZDonji0/0WR4lYiAX5Qol5Z/MFzOuwNkDK5rSdTmjaW5EE4yvH+vI/nx07X7PQkuNF8avLqPhDXIIItS/ssrdv5YUvZ6nZ7dwae13blC5E0fmW7KxKBaPw20Txh8PP2ofBVlp8sd3c/2xpUIudPxJaano+sTRxs0W7cs9lfWxbAO4cY4li+T98/iLrHwOl+L138Jf25Ph14CuLq8dF0Pxo2hQwskkyqoF/8AYzBtSaT95HdW7xOoI3R/KWPQ+H/2P/gx8PPELeDvCGh3ejeN/B5fWPDGg6xqjXtlcG6kcj+y9WufLeVJWBc2d0Svm+W6PGS5LrSShaG/6f1/WhdK11z7f1ofhz8avES6/wDB228F+DtKs/DWjeGfEl1dX8GmSSia21Nm8nTrwyMdyxeUm23AwsFwpUFnCMPlLxvcWHj7S9Q+IulwC31zTtkviW1jTajiVto1OBF4EMsmFu1XHkTHzCPLk317V4o0j4m/s3eOrvwB4rsZH1jRIzpmq6fq8bQf2lZyhS8NyOdguFCusibvKch13bSreE/ES01T4WeM9I+LHwomF9pNys0ukzXoBFzZ58q802+QZAkj5trlOQQUmTnbs1o01G0Voun+X9foY1KjleT+f5af1+Z5F4a8cf8ACvvFR1W4tG1HR7+I2euaWhCfbbE87Ub+CeF8S20gwUlXGQrvXUePPBUnha8s5dKuzqui6pbRalo+qBNkeoWE/wDq5cYGyReUnjIUxyqQVA25y/HnhLw7CLDxb4C8+Twvriyzaa1z801uYm2XFlOf+e1nJ+7Y8+YmyQFtxI3/AIT+N9AsNNufgd8UL0Wmg6hc/adA1O4/1OjapKcSLIwGUs775Un6rFKEmx99h0y2vHddP66r/gdjGNk+WWz2/rs/6tqcd4f+IPjP4L+MF+InggJMxQ2t/Zz829/aNyYZgOq55Rh80b/MvcH9mvgN4U+EX7U3hKHxR8LNcslR4ybvR9RnjhvrE5AljkViNyKTlZEyp+8Otfkn8RvAeu+HtSvfDWtWUlpf2JMU8Egw6OnbHToQQRwQQRwRXR/CrwlqPhn4Z+LviO2nRSixtrYWvnj5DczzCLCjHJ2nnHQVz16cK0ItO0tEjehUnQnJWvG12u1j7I/b0i0XwHpfhP4XeGtb0zxDmOS51N7KYXBiltsRQh3QlfmVm4IzxXx18GfCT654qRtH0pWkg/fNtdRHsU5OSOf0rwu81yTW7+Se4ia2uJHLNtXC5PuoBHoOK+iPD/wb/aCntLHwh4Jsby+l8QRLOVhHlSxQnhFMo2kB+u3rivThTjhsOqXMeVVqyxFZ1uXT+kfeM3jjw14NnkuPir4ytNMilJCW3nBNqHsdzenH3RU+k6v8FPFCrD8PrxdXkbmP7PJI6Nn/AG1Xyx+de+fsnf8ABA79oL4hvH4v+Juo6d4OtJQGYR2wvL8ng58yX5F/GNvwr9BPEn/BKH4UeF2/4RdvGeq3c0IGZjNsO7/dj2KPwAqcLR53anr+CMq9VwV5qy/r+tj8/vhD8YfGP7O3imDUZtH1O109v9cvM8Jz3AUlh+AxX75/Djx9oPxS8EWXjXw9KJLe6QE7R0PpX5ga7/wS21OW3C6B491CRR91bqZ5AP8Avomvq39mH4M/Fb4BWLeEPEd3HqWmOcxuvVSetfQ4FV6MuSa908PE+yqK8dz/0f1QJGcCnI8SrzxWE12cZqP7WWU5NelZnl6G+0yL2xVSW6xwaxJbtuSKqs8jNjp0oSFfojZ+1jJzUD3APQ1RSJjz1qdIHPQVQg+09z0prXHIxxUr27MOKqyW8gbihWFYsLqO0+wqwuqqvBzmsRrOXOD+VJ9mkA6HinZAmzoU1dcYz0qUaqXIwa5oW8iHnkVYPy8ipsirs6dZBJjJGOnFWF2da5Nb7y+/T+VEurqnzmlYpSR1ryRA8YqSI27DbMPkPDD1U8H9K4U66jnFWYtULd/wpcgcyPx3+Kemt4a8d614beY219pd1II5NvymHO5e2MdsDpx614j4t1WM2j3F9a7bhCN8sPO7GMHaOgx+X0r7J/bQ8KvYeLrLxzZ/L/asXktnhftFqvI9y8W049I29K/NafUZNAeC+Xe9oy/ZpxJ/rIFTkB+x25Pzdx7V8Djafsa0qfb8uh9lhKntKUZm1da5B4ohbSbWVJkvLYq6Z+YeSoH+A/CvFbbxjdx394LS13Qx7S6RvggkId2D2IyOK9t1nRdLa0tfGOmKscsEwm3oAoO4FXBx1U5NfM/jeSx0bxZFpU+2N7+1cIeMExYEi57Hbhh9K5GdKsew2OlnW0E2paeJRMylGxycHBU+h/un0NXr/QRBaiOK9njt1GVVcrwVP9GxiuK0XxPrVl4dFrGdxglVkLfexkntx0wn4jtV+8+IGoHSo5IIDN5pDKgwSVbr9MAEflS0DXoddo816Z7Sd7t5ZImMcpbjfgZP/fQz+ftXez+Kb1tLNn9ojjBweSGJXqBgdx0x/hXznbXuvTXLy3EC+S2CCeMYA+Yehxjj6ivSLSey0mWe4EcYUhzlyDk9T19cdqFLsO3crXHiDxusbw6ZaSGHnyZZz1Uc7ce3b2rzfRn8bT6qkN7LL9mZjIFZtqrnIx74I/Ku1n+J2jTW9zp+nzI8sXTn+LHAP54HoVx3FeQ6l8StUuN8akwqgB3BMllzkj06Zx0x+lL5lL0P0D8K2d/f20F7qFylvbw5cbMCSMgDkH1+b0557Vq+OfGr3P8AZ/hfTbkSJIhSd1x5gVuSDjheeg7jvXxdo3xI1XxBap4f8P7pFOMSHIYqccc9D/LtX0l4b0rTPB/houyFtQlI+Z9u1WPHzk446qQR/LFG+iL21PpTwroOg+HvBF7c6lGsbCAhWC4wzAjIOMbSCQ235l4JVkJBzvgxrEWj+Fta1M+e6xjasvkmU7T6xLuYgcZ2/gc8H5+k1rx1qlrL4a0y5DqxzGenl4xjDA4AwMj07HgGvfPAt6vgbwbd6Xfzme4m5cop3dMdPT6YP90jvCa0S6F2sm2UfDXh3Tjqa+MobgymWUsuf3iJnnch67D1yMY7qMED0X4nadod74jt7Ceb7Hd3WAfsyKzBNox+7Bj3oRjcgGdvKHACVznwatINY1t9bs5AGgYukcm5Y5ZD0XI43n+EgZPox4rmhKPEfxPku9SdJY7Y5VXwgT/YHIUeuAQpPK4yRT6Ng97HR/GjxRp2heAx4PuNs9vZoMtGiyxFm7SKwEkb9Cr7cH1U18ZeA7xvDMN7468uP7HYh5hFcED5h0+Y9CPfJ9zW38UbzWdf8Sz6dczBlmZYkG7c6oD3+62COOBgdOcVwHxx13VvC3huz+GPh1YBNqarEyGNZGVWPzbf4h/47+NP+72JuejeA/G1zp/wx1T4leKJ4Y31ecrGkoK79xGFBciNiew2g+4rQ13RU8aQ6Vq2oWcbTuyrHIB82zP3TvHK/wDA+PSvNPEWu3fhTSdC8DaPLE0DYSeExKUbI6bgTtx6bQPavaPC0za543tPDQsyDaqgKBR5h442sqjcvsVJzUu9jRJbnV/tM2PibSfDuk+GfD9w0XCedBudNyt2wjfkGTB7HtWdcQj4TfCqMahDc21zf4j80Rk7S2BghdrhfqjAelQeMtXOu/HSDwvAJUOnBVEVzKhiyf7jRmTHvwfQrnJG3+0pquoeOviPofgfQY5Uhs4wZUX592AAOvLbeQNruPR/vIrdtX2RC6JdSr4lg8L+DvCen61dRW1xfzvuC3D7GbgHqQxGexCHHWvGPEHh7Vvjr8XNK1e3020sW06JVYK5Ct+JjSMkepbnpXa/tSeO7Lwn8ONM8J6Ld2NzeXLRCW1uz5c6AddgYMknQYDHevqOBVz4AaJPpuj2+o3qyQG6YHNuCQo/3fMVW9uRWU1ZKPc1g1e/Yr/H/wCHGs/8Lo8KafcTnyoyIh5EabA7YJ5hXLEegZj7V4r+1fot3b/tI6DB9oMsNvaIhWYXFqN4PUKyJnjjcCfrXtWj+F9H8a/tXT63Z2raja2KCFoora3trk7ecyRpI+RzwWxWL480vWPiZ+00gg8NXWl6fo+2CFGtBaGQLySrf6pvTO5vw6VM7Lmt2sON3y3P0t+HGqXepado/h2NFig8hQQiyzR7x0Jlb7v0zX5Z/wDBRjWvFMnxgt9P1HSd2n2gjiS9NvIFx1I85k78cZI9K+4tI1vxD/wubS9OsdD1u2sY4QrNeNviLd9kaFk/4FgZ9K+If2xtCvPEH7Umn2FrfxW7wwoHjWeaByCerI0EYwMdmZayi+Xmv2NZa8ti/wDtN6VYeMPgp4CbTlQXUIAXyJIixVlwRzJu+vApIfHWneEfgZYfAXVYxLqupOspIuIisMZ4wSDIfwIUe9an7RQa28eeC/B8U8Ris7ff2xnjJDB84x2wor5u+M82jH45aaljcsw8hNwMSRoOg4VI0z/3031qYr3deiKvrofqj8QvDWoeDf2Vbb4P+IJIppmilkihHlmMRsAw5MiByM/woQK8t8SeDtE/aF/Ye0/Rdd8z+1/BcxNtJbuAyBFwHG0gYKHa27PsM4r0/wCNHiS7uYvCUdlc3EixW8kQXe0IOYx1dWAHp1zj0rxb9lB59Qn8ceBb9giXEYfYCsmSpzwTvUEf3ucdua54vljFrp+pvJcza8vyN/xX4x8JfHf9izTdQ8SifVfGXhy3Fva7HKqWtwVSebG3AC9UVXaQ8bSOK43wUT+0J+x0bDxs095r/gJ3WGHiGZ4Nv7v7TKyN5axqfLRApkCcBRnI+cvgjrA8B/tJX3w51YpLpeo3UkDQBcRvJJgq7Yw0mwjAVm2e1ejab4ul+Ef7T0nhvUVuU07WD9k1GOYqI2jm+VQoX5Qw4LD+EYARVxnV+6rJax/IyWr8me0fs5+NdB/az+BOtfs8/EPLeMvC1o8+iyzjM81moAaEc73aIBdpzkxEDdgHPXfst+O5Pjt8P9R/YO+Lv2XVtS0lZLvwg+q27SCC4thvks1O6GVVwN8ewq4wVGFwK8A+JWleI/gX+0ppfxW0GXmKaKeKUYG7bwy+pUr8uTzz+A2v2lteb4UftJeHvjD4CtI4GFxBrETbMCRsrJtDH1XKnGOucUnLpD1X+Raire96M77xNG/7Z3g3Wv2X/HIK/FX4cxXb+Cby6lL3N0IRvn0SeWRmdoplUPbF3LxOBnIGG/EjSvEvhZIrzwb47Y2fhvXpIZbm6kiYTaTfxDZDqIjJUjylPlXsfys9tkE5iVT+u/7dVnqnwu/aR0L9pP4d3gFnrv2fWrdp3/dBwVkEBWNAEAGcs2Cc8HivlP8A4KQ/A68t/jh4v8W+AdKubW0uFtvETw+QAG07V1VxdRNHlHENw8kM5XJC7HfHJO+HrJPlb0f4f1pYyrU3bmS1R8MaZay/CvW9X+GfxotpLfQrySP+1Ba5uHsLuNcW2q2YX/WqEOHCgfabRtuMqqVBrfwhurDWU8I+IYoZ/t0aG3nhYTWt5bXA/c3EEnKywTpzG44I+UgMGUejfADwp4o+LWnW/wAJvGGn3k8GkI8GheI7eIyrp9vnd/Z98oAL2iyZNvIm6S1Zim3yCQPtrwD8ELD4FeCJdA+Kc0HiTw/aX32rRdOsZVe+0+ac77oQSkqI7Vh88sUmIxJhk2t12r1nF2hrLy2f+TX9bImhSjKN38P5eXmvT7u3nHwb8OXEfgyy/wCGnNMubrRdFdLPS/EcM0a3S2yFwbS488qs8duqbo5N3mLHlPmwCfi79rT43fCv4z61o/gf4D6lPpHhDw7Hut4763e3+2375WS6YjOBswkSsAVG485XHpP7V3xu8b/EfxdfSfC2Y6hokn7q0sFmt7ux0y1VVXyIo8kSSPtLSzEE5JVTjpz37Gv7JHxy/a7+Mmn/AAp8LeCtM82dllvdRaOSzh060z81zMscnzKMYRBtMr/KMDcy7YWgov6xU+Lt2+RzYzFXX1en8He33ar+tj6H/wCCcX7Gnjj9oX4hqdUt01PTtFC3M8kT+ZDzxFHIfVj82zrtHoRX9h/7K37F3hv4TxPrev26Xd9O/mNIwy49s+g6D0HFet/s0/su/Cb9lb4U2Hwu+HNqlrDaKGurnaBNeXTD95PKR1ZyPoBgDgUnx9/aY8GfBPwrcXrTq00KE7dwHSqnZy9pU+SMoXUeSJ9o23iDwxo9oNP+4oGNo9K+d/ibongDxKkkum6c0t233XjHTHvX4UeOP+Cjfiv4g2Dx+Eb8aIcY3xxmV/bsa1vg34v/AG1vHDHVvD3jVJLVMHF7ZmPPt1HH4V1UKlST/dr7jlrOlFWkfpjFo2raXcjTbi1lUfw5FLeQ3MH7udCmOxGKr/DT4jfG7R0jT4nJY6iVHMkHyn8jXb+LPG0PiNfKitVhHGW6H8q+gwNTFJqNRaHjYqnhmr03Z9j/0v0QF9ng9qsRShzjtXOpEQavxKVHA6V6zseOdEoHFX4YYyMr0rnY2fp6VaS6KKOaho0TOoiji496mAReOMGuU/tEDqenSmtqzYGD0rPlZpzo6oKmc9qnW3jI3CuTi1Vgc5zWnDqa4xmjlYuZGw0EeaieCLPQelUP7QBqQXhYjbSsx6DnttjdOKybm2f+Ht+VanmMwpCC/wDhQmFjk5raTdnGO1ZFzbzjNehCBPT2qpcacJDjFVz2J9nc84RJj3wK04yy/erqv7IUcgfhSjSAcjFVzk+zPD/jH8O4fip8O77we3F022exk6bLuHmI57BuUb/ZY1+Bfi5p9LVrDUYJvMg3ZIX5vl+RlYdjwFYdmFf0wyadjk8dq/IX9u74RXvgrxRH8U9HhZtJ1+XZclBxa3+0nOOmy4C7sdPMB7kV83n+G5orEQ6aP06Ht5NiOWToy2ex+W3/AAlx0+A6LptysUc+dkM+VjII42n+HgfMp49K8h+Lv2u80+w1bBkmsrvzAYmGUDgxkfgcDPoK9b8U6az3saXOzDLvhfqroef/AB0fjj6V498S9G15oEOjQZCKskm4chgPmHHUHAPHcGvlYs+jki74f8a288T20xmhaT5XAHzBuzgfpXXaZoz3cIbSZvMkJOfcdMgdgPTsK+e9L1ifSLhItbgUXGNwZOhUDoffDHBH0r1rw74tgu7dbnTVxIvGE+XLL6dOoBH/AHzQB6va6t4m0yFJtSgXI2qduevYkf8A665O51vxVq8iWohXym6EDaPl4Ct+GMfWmap8R9VtbSOa5sWU8nep+SRTjcMdjkbh9faqz/ECeWZ7bTrYseOWXB2+v157U+YLeRueGtPe6nLTWcaEkgseCQT3OPp/OvSv+Ee0Tb5rokaYJKkYB29R+Ga8l0vxH4hknZ5oUKnrg4yWHX6HH6V1w+06yI7PVpFWSJsjy2+9jFS7IpHsGga74V8O6j9n0RIpbhQNyxgHg984wD3x9Rx8td54hXV/E9q1xp+ETq0cXyPuHIOMc5A5UH3UY+74rpWmaH4XheaJMbj94LnDqOQB0zjGFOMjitfQviFBLqxgt5y0EpX32Fe3POB/DnnHH1TloWke2/D/AFTT/C1u9/qDrBIVI++uD+nB7dPqOuK83jr+2tXGjaZKpBbYCR8uPbHQD+729K8/8W+H7S+1GzltJlnBXdnGSo9CBywwOh5XsSMYn0jU/DGg3KywTKbxBs8uRCCGOMFf734dRyMjcKdrIL6n17qeuWvgrwNCAy2098mCyHjB44LAhlOPmR1dT0INeOWvid/B/hm81zUn3SSZ3SW/By3TgnaQeg5Ct0zkYqa78Uz3emRS6j5f2QruEe44DnuQcjacdWCnGPmkxkea2Xhq6+ImstDYlre3RyohOCMjrhW459B7dOKp2VgV3oUfD2onUhL4i1CKPDuGWRYwD83QFeMLjH94D261xc09x4x+JEEkyZsdH6s46kdhkBgo6ccV6h4zhh0aFfCOloQzFAdiGKRM+oI/oVx6V0um+BIfA+jS3w2zSIhaQudm1iP4vLy4+oVgO9HkJPqfO/jbWrzWPirb/Z3Z0tVBSKbp74JLH82x6ele06PrOoaQbzxXdF4Y41yh/dsiOemfNkKde29DXi/wv8AS33je98YXNvthkkZ0KsuGB/uuvycdua9p8Y2en23gi8v7Waazuc4R490bk903plST0Abg+3WlvIq+lj0X4U3uo+PpL3xg1mLm8EZVokkUZ+gIbqejL0rhPh94e1tvHsx1ezlsblX8xEmLP93+6QsuenYAH0q78JI7bR/hvJaawYnjnXcsVxGPmYduVwfwK47Gtz4Py3Wk2Oo65d31xYWzZVUmd9u7GAo8x9h46DJNZ7pIra582fGvx/4i+K/xhHhS1uor7T9PKKN8DRyeb/GCVm2Pz0IijPtX3FoOtn4aeDV8SWhXzdMt97xWQhEzkDG11uAUHtnK/SvnD4Q+BL+88T6n4oggjuJVlYp5sZYAdPuCPdgHttNc9r3iXxL8XviZJ4Fju7qK1sWEbQWfz2zSDknDJ5uB/sbfoahy1ci0tFE9w+Dvi6Xxh4j1D4m+PolAuXJCtAkcxT+HiDMW7/dTHtXV/CvTvCuo3ut+LtS0+5uYlDmO3nuTvBGc43RRZz2Ai/SsrVYLbwV4Tu/D37q1vLaNf3g+dssOCN8Jxx2KZ9xWr4UE1/8AAnV9Lu7U6nuj82UxkSzoD/0zyw6dMeWx7bulEdGkwe116HAfsxeB/CN/8b9T8QeB/CNnoS5YGSwt1jZpB1dxDHD83rkV0nxT1fVpvije3uumacaSjMkMt8DEG7H5UcoDjp2rb+BOm+Cvhx8INS8QatavcLKjYQbQyZ6H55IyMfQnsK8N+MWoWPg/9ny/8VW9tJJdagdse1tjZk+Vedp9c4IrO3O9ev5Iu/KtOhw3wq+KPiD46fHH+1PFFnBIdOX7OhjuGkhCg/3jkYHriub+MujW9x+0HBNZy2rweZEDbrcrMc5AyEBRsEDsK7D/AIJ7eCb3TvtvjvWlcR2sRkknj8zzE92Pp9SK7fwf4Sf4sftOy+KL6W3uPsjG4aeJC5Cx/dDNG06n6jB/2RUtpKb+SLV3yI+lfjMt3e+LPCmlKzOlrBM+yMswUFAAfL2kD043GvNP2b1K/FTxLYMhKyW/l4ZCm7GP4W2nH6V2PxA8Y6ffeNNU1u6ktVWyX7DE2xTuAG5jm42DI6cD8q479krxINY8b6z4oknIsFGwZMcBx2VQxlQnA6Bq5pR9z7jeMvePj7x9nQf2vFm8kZt7yFjx12sMY74x6V7/APt1WJ0T4h6ZqyWzRHznWDe+CF4PyqpwBz359a+e/jTPHqn7T/2TSpIpRNJEh3K0cqMWAAI/dY/74x3Br6V/4KKKk/jDSo7WS2uDGdowi7yUjXdlhkEAjHrzW0laovQyj8D9T0b9pK5i8T/Bzwn4sZS0k9nAC+FGNnBOByR9OKu/tbWEOp/DTwN4jQKUewsm34xuIjAx6DoeK439ojS73w78D/AunXcxgnhs7eOSDy/vErvPzbu3+5XU/tAQzaV+zJ4Mgu41kNpY232Y48wFXJKbsfd+Q459MVzQ+xY6pfa+RL+1tYTzfsufD/WtS4ka2iAywHEXAOAe4xXaah8c9S8BfCL9n74spq4Wy8QJqfgTX7aSMPmK0k3WsxR/lkSKPfHKOro6kEFADwnx7urzxH+xB8PLeG0SZ2kuY/LZxG6+U7AGPI5+Xtu6dq+JP2h9Vmg/ZH+HngW9EkEhv9X1Mo3AUMghRgvZ8FlJ644pUo8ygvVf19w6kuVyfp+h9P8A7YN1c618HtR+KMdteS6x8Ob9PDPjjRdOmFuikN5VnrEaY+WKddkdyAMA4k4Abd+GXi/4vWXiOG68Mp4WWLS7oqZo4rmaO4fbx+9mRR5i/wDTN49tfsz4X+KmkW37f/8AwiXi2GHUvD3xN0nTdK8RWsqB1nF/pcUUhdTw3+rTKt1H0Fe//wDBMz9i34HfEXxl4q8eeK/DlpqnhzwzPGumXbSSNFfyzosqb4WYr+6jI3gcFz224rvw2J5IKLWujXTf/I83F4dyleD7r7j85v2Ef+CQ/jP9s65i8Z3Ueo+DPBqsudVv4Yna4HdbMcM5A/jZfLHGN3IH9nv7OH7O/wAFP2Qfhba/CT4JadHptjAA01w/7y6u5e8txKfmkc+5wOgrRl8XeHfCeiQQReVbxwRKqQoAqIqj5QFHTjtivNrLx3f6pdyv5nBQSY7Lu+6v5V0qq5NRerOVUYwXMez+LPG4ieSyt23S4ztz2r4P1/4B6P408c/8J346vZdQl37ltW/1CjsNvSveftBeV55jukcnJqNtz8+lfVYDKoRSnWV5fkeBjMxlN8lLSJh6b4L8B6PH5NjpVrGB2EQrpkurSzxHbRrGOmFAArEkWYH5TxVGUzda9tQitjyXJ9TpptaLLhe3pVQaj5n3ciuabzsAE1AGl7cfhV8qFzH/0/0hawGOBSG1Cnb6VvSoQeO1UJI8fjXdzM4OVGeEUDGO1Z1wfLJwa02BK9cVj3Kk8dqES1oZ8s351n+ey/dqxJDtOBVXyQW7AVomZuJYjumA44qZdQCck1Q+zNgY6Cq81owGKLhym7DrCcAmteHU4cDnivOZIJEOU7VYgnkjAU88U7ISuj0uLU49+M1fW/jAyDz2xXly3u09e1aMN67dTkVPIXznosV8m4BqupdoDya4SG7XbVgXxPfsKnlLUjtDdx85x0qOS9VB8nFckt4zd6ZvebIU0uUObsbcmoIM559q4Lx74c8NfEjwhqHgTxdD5+m6lCYZlU7WUHlXQj7rowDIRyGArbazmJ59aZJYSbSTScYyXLLYE5J3R/Nl8ZvhT4r+FHivUfhz4hRJZLX97Ax+WOeJuY7iAj7gkXO5Okbg44Br5n1DxLK0MqSo8nkbUfPyyopxjr3XnB6EFfQ1/Sn+0v8As76d8efBIsIylpr2m7pNNvG4CscbonI5EcmBz/A2GwRkH+d/4g+GvEvg7V7qz1vT5IruwkMF5ZzKFeIrjcPw64yVKnKkoymvgcywMsJVsvhe3+XyPr8Bi414a/Etz5f8eXGm6xajTo8eft3QMPlPy9P07fUdq4jwzb+I9HnH9mXHmQt99G5dR6jHdef0r3LW/B3h7xTE0tuohubdyCh7f4fyrxG98Ny+HLzzUVoVBwHRiGyP0yMf5FcUJK1jrktbn1T4GnuvFWjtbXc0NyYiV3YxnHQ4z7/h0q/q2nObXFugjeDjMQzgc4I/w9B6ivnPwL8QNN0DVPss7+WXYFsEKG6jjHqpwR04HpXt7eJVh1U3NrdeaJVIZT1PQ8j3xkH1yKHoNanNXM+ttfeTA8g52Mp+UHd0HHvjHFdPomnR6SRc3koLZBBDYIwMj9M/hn3rUk1PS75mtpwrMwzu+7weh9vy461xdzfajdTNaW0fnxZ/1ndX6/Mv8J78cH7wIOaWnUevQ94HjCW4tCNOZGcqVxIQUK9sj2PvkHoRWl4J8N6hfX51nU5R5u3B29vw6EV4FZ+CfEFvdLrctwgg4JEfzoc9QygYHbt7cYFfSukXNgqArG6FFwUQjO04xgnqPTcMHswodnotio6G94n8R/2G0MkypHLEm6Mo213KdVOQDuGODwwOMjjI8g0O51XxX4kl1NT5lr5glChSjLk5+50HPUL8ueRwa9C1SxPioeTfFzACWLfdZSOMEHgjHT+Yxitu3CaLpvl6NEu2Abiw+Vl7ZI6ge/3ezdjTbTXKCVtT0OyXVtYtDLKggtIDiOVSY5A2OnBxk98bHI4+YZr0z4Xm20zSZ5bbYsanbDsYLuJH3QX+Qn/YbbnoPQ/Pvh7/AITHxFu0fMiW0gKlwuQR/dI6Y+vbpXSa7r03gvRBommfvFY7FDEJ5gPUL1Q/Tj6elK33C1R7NaSafrXiZbucCQoAu05iKjsPmClP90gJnoaPibf6MkkOimSSBpQAomUbX9Qr8K2McgMD0I4wa8U8E6PPoZbXEu5LS4u/mXB8vC/3cHchGB8yn8iMVVXWLzVPEq6NqU8k9vLKN+xVQcc/Oqgxv7M0Ubr0LkUXVmyktUj32fw/pWgeC/OXToJpzlj5aMJcn3XY6tn1w1cLfeD7nxKljrN0rW0Cr++GTsbn+Pody9Mkcd67LWVi8U3dvpUAUxxxnywTvREX+6H3AY6YVsjpwODjzeJZNIVUbLZ28bfMiO3pz/CR/tbCOx7Ut9A2JPitYW2jeCjBZWdndxSx4khM/kvkcDIK7Sp4xxu44x2qeBNbuNC8CJol5dTRPd4VY4X4Xjptlf7vsCPTNcPqEE/xK8VQXRfLW7HEQXYpB64PHB9OAfc11XjnxBP4KitmvLMPIMRRxh9vPTv1+hGfeob7dBpWO/u7bTPCnw6utQuJoJN67UigWPzN7ccRu6gn8jjpmvPPgT4B1the+KTDKktwf3SIqSO5z0A+Qk+wGa3r3X9U1DRLfVJ7GKDcMYaONhg9iELN+JjI9q9ZTxTBpnw0nivtPiu7eRNv7sKiZI4DeblcewQfhU21UehfRs+RtW1PxZ8QfiTN4c8R37eRZyKPLnR4zEE/hxLI5H/AXC47CvpPxJFouo2mkeCI5rK9nhG0O+PNtc45im5MR7MpYAjqvTPmXwp8J6HLp13rek7NJlmfZbFY44ohJ0VAgMcfpgLKhI+6GPFdp4O0yx8J6NeeLvFd3FBeIWInuoJIkJTsxPlFQvOCSMd9tRy317jvbTsch8bdRvk1TTfhLZurQz4/fxxrMjYPI3iQMv4rnp2qh+0F4J0bxHaaJ4EBjnjQRlgkDuUf+H5kSTaT0x0rA+GVtP478e3vjfU0/wCPZiIUmlE8gT1jJCSMP+2j+zYr3vQ4Ne8Q+MJte1iaCLTtLQeQxjeMHK/xFm2sTxjDHgdTSnbXl9EVHpc4v4iDRPhF8Bv+Fc+F5ls9fugqmK/s45IX3dUEjKj7sdAjqf8AZNb/AMOdNk+AvwlS7DpZ654iO2LzFA5I4WNpiN2BztVmYDtWWza/8TviXDYtbm4g05lJFrIBk+nlyAnPsCf92uijgtfF/wATLm/t71IrTSso8c7xR7nQcDgxq+3HHyrjpxismto9vzNE+v8AVjxjxtqPgjSfDw8Ja1BaXWqT75W320xcO/diYpImznpuRsdM19Efs+eGrnwN8OzY6fCkEmquD5Pkq8ZTGBxtYH2zHz0rw/StN134z/Fz+xbuKaSGyfCmTKSBF/h6ZKnqFO9Om1q+g5/E2nTa9qk8AMWnaDGbGB51C25mVfmVSy7T6FGGeOOBWdTVqC6GkNFzHxDY+C5vGP7VSWmgW6w3CXsZeK2jPlR7DkkLvPlkY5TauP7oFexftUhPiD+0Xonha1QCSN1jB2/J++dVHIJyOM9gOmK9Q/ZX0zVrXTNd+LvjiGJZ4PMjif5oU29zy52/Kfl+fb/dGMCvFf2dbyL4rftM33xH17L2ViZ7rbIAQoiG2IFsDI5z0z7dqJy+KS9EOMfhibX7aepz6n4z0fwLpDmbzrlLeJdwba4xGNvcZ4Hb2rt/28dftbDTtG8DpEuLcxhm2AY8lBGgGMMBlT3xx0rwvwBqT/F/9sW31e2G7RPDUzTfvMqqJB83fI5k2jjAPtXlvxI1K/8AjP8AteweE8OLFbqGJ90m5FgHzzyAgsAAu8nBI449KSXK/wDCgcrrTqz62/a2+INx4H/ZI+GGhaewa5a1t2vP3jxSbzGZPmQHy5Ay8lXXI4K4r4j/AG29Xu7vwd8MdChUpqdv4Wjtp4V/illzInH95S+2vdvj34vsP2mv2h9L8DWEYh8PeHn867mB2otomIkHT7zcRpx/F6CvlrxN4pf4lftYR63qixjS/Dt5iUkhok+yFmGD0KgRg/QfSoorlt/dTf37Iuq+a6XVpfccnfeJ7jQv27PEfi2SP7XD4SmkuvJiUtldP0qKIKijqfOwAB/FwOcV/WP+wp+z037NH7EPgv4c6rFnWfsH2zWGJyX1O7PnXDEnk/OxH4V+BP8AwRu/Z8h/aD+Omt/GvxvbPL4fsr5tVuPtQDCa4eRpbaE7hj7581x1CxR9jX9Wt9qWmXEjnzN6L+CoBXoOP2V0SX3Kxwc99fV/f/wyPBtX+Gut+IIm1vWdRNnaw4bGOW9APwpltNFYJ5NocIOvvj1rqvEviSfWZFtoMrbRfcHc+5ripY/M5xj9K+uyjKoUIqrUXv8A5HzOZY+VV+zp/D+ZtR6tExGTWrb6hbt8u6vP3tJAc+lQ+bcIffivesjx7tHrEcsDptq1FDDIw3YryqDUriOTBrq7PV22jeamUbFxZ2UmmwtywqBtIUnPcVVh1UYHPXmtBNQibg8A1kmzWyP/1P06luoh8p/IUErtzXn0Gpvd3ShW4J7V1DXsf3R24rend7HLJpFy4IBwDgGsh2XHSmy3Rlfy1xWgtuNgyM/SrvYzt2MCeN1PPSs2VWbG0dK6uS3y2CMYNVfsm4dPpVqRLgcznb9zp2p+7cpHf/CugXTs5LcfpVpLCNjzQ5oFBnBTkg5btVDdtXArv7jSo85HGayJ9KLrlBz6e1UpoTgzkY0ld93T2q/EDH81aR0tl+7+lV5bOVTwKrmJ5RrXRQ7RT47o7d3QdKqfZZQ2cZ9KcsDjKgZougNGG7AOc4FdDY3MRHznn2ripVZFPqKSK5kjH5c0ONxp2PUxcQMO3tUoMbDnpXnf29guRx/Kn/2pL/CeKy5DRTOzm2MMp24r4t/at/ZX0v476L/wkHh7y7Hxdp8Wy0uHO2G6iHP2a4x/D/zzkxmIn+4WU/UUN/LyT9KnN3kbW71hXw8K0HSqLQ1p1pU5KcNGfyW+NvhrrGg6vfadqcc9hfWExhmhdSs0Lx8GNwM/dz/3yQRvU5PjOtQQmKQXgl/d9928BgMZHt2r+nX9qL9lrRfjxZf8JV4bMOn+LbOLy4rh/lhvI1+7Bc454/5ZSgbo+mChK1/Ph8Tfh/rHh3Wrnwr4ptbjStVsZCsttcHyp4Wb/a5DBuqnlHHKk18Jj8DUwk+WXw9GfV4TFwxENNH2PibVtW8AzzJb6tBOFHyhwjfu/wAh+or1Dw3ot8LOHVPC7pqEKqGizJuIGOnPUdPpxxWT4g8FCaZ0kv5YXB+64VentisDRzqHhLUEsYLncQONjbR14Ppxxn/CudtOPumyTT1PpaLTTeQR3+pxNDOOVBPCsPQj6fT8q6Ow1iKNGWS32Pjy343Lz0B/2SOh/WuQGuzz6XDPqCxxE/eVWBKuPTb2PUY6dDW5p9/p+ouj2UoRlGD/ABKVPYjHT0Pb2rG5sdBqvjK20i3Et1u8l8Ykj+8B02nHJ28Z/iHuKtaL4wlZg8e2S2I4GOcY7dvqo5HUAjiufu/BvhuWdMs2ZznarbgSOMD69vyr0LRrLRbSJYLLDqw2fON3ToNv8u47VXMOx3ei6mscTTZUpjlQfmXPQYH6fl7VvTXiXM0Z+4U+ZPl7Y7YI7dMduOR04ZPCmi3rR3AaRLhFJUKwb5OpAyPmTvgdPTFPmW8li+yW58tANhABIA4xgHHfkY49h1C0Qz2bQvHmj2FoNKsLhYLojbtxjP8As4JGM/w4OP7hzivRLbStG1qL+2fEVok7OMNKoy2QOAykAnOOG6kdcHLD5MtbvSPDcq311G96+Ry64VR+fr69ema9RtfiFea5Z+Rao2w58woPk2cHGOg+nToRV8wWPSdV8d2V5atolnaie3jIX72VVv8AZfGV5/hYcH7vqYtI0vT7J31G43pM4ARSVJTPYgcEehA6VwZ1IWG25t38yU/JvjyWHH3WBy3THBBGOgIwa0NKg1+7ufMeHZYDL4UqQ2cdAwK/h0P8htdQWmx7ZaazPp8U8mn2qXErZDSojMcr0BEILHp2DlfRcZHlGiwy+I9duNfuoPsVvEd6tafukJzyZNm2M8/x7I89+eT1ErS+NpE0iENstyNuWMRAXoMnJXA4U7sDjBxxXvNvYWnh7TTbQTortHtPn/LL05DBgqv9VYHHQr0J5dBo8HvddM+pppOi28mS4V22Rt6dGUo4PbkHP96teTwvc3WuwyaiXktoCw8sBRGsg6BwrdcdnKt6V0vhbw7pl9qpu53wtvnZ5WDGPoGO5c+nzLjvWVrja74c13+19OkhaVxgeVHl9g/3SHK+x3KO3HRbhsc/468eJo9xb+FNLhjmYcjzIrjZj12MiDA7GOQ/7xxUPi++1u28KWtrFcItnLhXMTSE/wC797I+ik+4qnoHhuC/1869qdtHNJ8zm5gHy4U8gujHp0wW+uK6HxOx8TXv9npGtwCoVNmHjdeoAIY8enLjuMU59WwW1iPw/qthqT2vhXRii2vlp54+Ztyg9PkeM5/2SoGOmetdJ8TYU1PTLfQdEtoo/NYQoFQkqF78hcewz9SOM8LqC6T8PdNFjHZyRX0i8oVMTYPQrt5b8Aa9A8Cx6ZoNg/jHxBMI/NHyFsTL75UKHGOM4XdUN9CiDVLGLwZptt4M09rZ5rkDMTr5UhUjqkMq7Xx1zEx9jWd4lnsvAejjw7o8i3FxdhVYIrKRu657gehDDPrTLTxCdb1B/Ec1xbSWtt9yIOYFb02CVfLyfRthz3atK4ubjxTfQ+JtZgVLO0YtASQHUn0GTj3CuAeoWsm0tvkaJHVaF4T0Pwj4WFukcepXFyNkkLE4G/PHzhsKPRonJ7DFZGoap4d8CeE00Lw0bq2m4TfY3JQqzdMxuksTAHgBiq+i8YDNHks/GOuP4ivbhvselgFFfcoz2A3hTj6MwOO2Kg8T3Oj6k/8AwlmsLapFp6kRSRxoZG9eg3fL6EtkdM1ns9C7aG5PeTfB/wCGtze2kh1DVtQKRi6mgXerTcKsiQxqqAk8ERKv86x/HGg+L/C3w703wroV95Wr6ovmXMUvzNcswyRyckrkcFZfeMrlh518MdHi8deJbr4yeK5NthZfJawybREWTI3AuVQKQARkDnr0GOv8Larfahq2o/E/XvKtlgDx20dxLGUKnoNrs0LZP3SW9g2Kna3L/T/4BWjWv9I1fjJ8T3+CHwu034d6LNHFNJF9kljtnSUiaRMtujyGUc9Fwf8ApmVrB0S18NfAD9ne68Q65cxx6hq8CZhliDMPN/1aP8pIUk5/1bDHPyj5h414d/tL4mfEub4sfECRrzQtHkdbaKRhJGzx8hI/MUOE4+ZQxRcfLxzXI6n4i1j9pv4i3MPieVU0DRZxPIAGjIjX7sWM8K44AyyD78Z2nlSil/hj+LHGT+b/AARseDrg/s6/AF/HWrDfrvjPBWIKcRWzNlA3XG/Bbr0xXk/wDmfwdofif4+6+RJdXqS2VnHIefn+aaTsTgBUz161qfHbx03xg8Ynwy87afpukfNqLBMm2iUfLGu3O7PAUrlSmTjivLBqGl+ONYltdSmbT/DOgxKiEt8sQHGNw4kOfuyfeYHB6Glb3fe+f+Qr+8uXpsdxomu6t4K+B154ltIGuvE3jfUVFtB0chAyQgHsiEtIc8DA9K+dmgg8OeFz8L/Cscuu6nrUraNbQ2zFZ9Tv7sgXXlsOiKNtuj/w5ckgKTXsd/4qsRoDeONZufsGnfZ2ttK3sFNvpMQ2vMT08yY5O8fwAY61+mn/AATK/Y7ms3P7XHxk0trXWdUgNv4S0qYYbS9Kbj7Q6H7s9wvPPzIhxwzMK2w1O95NdfvfRfL+uhjXqWSjHt9y7n6f/si/B7w/+zF8DdI+F8LR/bolFxqc8P3ZL2UDftzzsXAjjBPCKBXtN94ikmBhUbFZjkD9KxLgRq/k2agY9P8APasq6Mgz+HSvsMpyjktVrb9F2PmswzG/7ulsbkeqpj5zU/8AbEfPT1rjgrZGe9IwJ47DjNfRcqPE5mdgNThYANj6VMHSQAjt+lcP823Gaux3L42lqHHsCl3OjJ2+wNTCcJ8w/CsBJSepz7VY3r/nilYdzY+2svTtSLrksb/K3SsZ3BXNUhG2cjr9KLDP/9X7H8GXTzxeZIOorr57nYrEHpxXg3w68ZQGyMkkgHpXc3Xiuxm+SNh82K58HmdD2MXc46tCV9DsrDVkiuhu/irtl1SJowEr52HiGJbwRxt37V6La3JkiBB4PNdlDFUqjaiyXCcVsd5JqiMQuduKmgv4B1NeXXmqLA2AcdsVXvte+zWZdm7VvKcF1JTkevJfQvwpqQTLnnivAtM8ZK0gG7OeK75NaeNBKxAzWcZwkro0u1od7cXKBAajjdXG4HNeZ3HiRWA+bHP4Yro9L1RJ4tyN7UlJN2RT2udWREV4qm0UbPkc5qhJfmM7c9Kh/tJEUHOPWr5RcyLEkESjtVHavBjwKJdSjdeD0rNTUYeWHPpQmIfOoH3qobASAKdPqETDbmpIZIj8pNVzC5So8ZPGOB6UKmcZ5rejgt9vOPaq8sMQPAp8+guUox8DrxT344BqKRW5xxiqEzyRdBgChIGbCTIp4PA6V4D+0L+zr8Pv2iPDn2TXttjrNpGyafqcaBpIc/8ALOQcebAT96M9OqlWANesC6Zhgdqclw3UVFahCrBwqK6HTqypyUoaM/me+NPwI8Z/CLxJJ4R8bWMcFxsL2527re4jHHmW8uPmT1XAZOjKMjPyrrXhmVYWe9tooySDvUDIPs3v2r+ufxx4C8E/FPw1N4P+IGnR6lp83Ox8q8b9A8Trho3HZlIIr8V/2l/2GfiB8JrW68UeBt/iPwuPnkcRb720T/pvEg+dB/z2jXAH30UZaviMxyarhr1KWsPxX9dz6nBZlTre7U0l+B+XFjfaW1v9g1rLv93cyAHPbkcZ9Py9KtaX4U0yyvv7VjEjZfcjxucbvp2B6+mf02ruzbSYjL9iW5gcBx9mIJKnoyjuPpkelZia9pl182nXiqw+/E6NG3Hqh5Rh6gY+orxlLsem42PQ2srbxHC9pcGWxuo13Zj+UsufvDOVyD17fSvQ9PuILO1B1C5aWYAK0y4y4GOWHH48fpXjdj4rsb0CzjuA00YyELbWx0JHHP610+l3dwbny4drIOW5B/H/APVScuhSR7L/AG5bm2MWRKMB/Y+/Tg+4qCy1G1Z8XUjrGp7Hke3fivNbm4WIrcNKz8ZiK8dO3Hykeo/Sp7CK+12F4w/kn7oLc7fb1x7Z47cdDmHY9fa28OatEUnkLmQ/w4TtjIKHqeM5XkcEMOmVNdS6DCuk6BCQvQ7ztIH09PYHHptrhrGC706PZqEqSyD5VfjDH0zxxVW48R3KTfZrq1aE5PIHr69vcA/gaqMmJpHW6RcatAv2zWJEdUJINvkgpngc5wfpgA9FFfQ/hLx9a6hp40lFEPmcB3GVb8/ut+h/Svn7wt4b/tb/AEvUpCFbG0qdrFfTHccfdPPp0xXp7pBabYdMMcixjlXXa+D6H0PbqvpzxTv1BHu41DSdBssxv++QDkcL9QABsI9MKD044zY0uWbR9Im1XVpGmW85jRHKqqDvsK7QPfGB6g14BHf6vq11/ZyDCjqyqWwOnzDG8D1+VsfTiunuLPXYPKtRcxxqB8oIK5B7o4+RvwII7ir5kOx6hoPjCPTm/s7Rcusvz/JyAfcf1U/TFdbqt7oV1FBLc5+1A5C/I4DDt1jkB9Pl3D+96+S+HNO0Pwsr3IbdI/3sRhhz3IA4/LH0Fek6PokSImt3QhZVUSRAzGOMqehDH7o9PmZB0DDoJXkM19fl8V6JZx6loMVss8p+9ceZHI3HZ/lYnH+3kevGKq+AZ/Jlv/Ec8RmllB3xIRKit7kCJs/70RPqe9YetT32rXklnDHJBtx8jlPMVfqQ6OPQ8n0Ndnrlrpuk+F0tp9QWObG/ayMA3TgbSUz7A/gOlW3qSlZHnLz291ek6nc+W4fei7ZNjeh2YdQR3Plv+VWvF1ldaze2smpXTwW5QbTb/vY5FHUN5flqQP7pTK+grkPs/wDaWsxWiO0bR/OyOuB7YZTj9FIr2vU0XQtKV9Y/dnYu7a5jJ6AN8o5477WHbNQ2VY8rkii8wLbvbXdjZ58w+Wcx/TfGksZ7FeR71U17V5vGc0Vhbs8UMTbYYoej9uVOM+wxn8K0rW3gezuNRu7iaSFnYxLOqbzns3lhA4HQN6dahGs6L4Wi3q2zUZ/kCqhUKMcbSRj29vSsJyV9DaMe5ZvXm8N6WllI80fljeViYDC/7XAH/AR19DXnVvYf8LemS0WY2+l2XyF5AIzgdgVKYX/eJXOOBVDxdqX9oWQslltZ7jducyYjI9jtwrDHYg9sYrnNQ8Uw6Ppy6aNTMcsqbZfs7fvnUdUi2kELjjmoXYbPYPHXxBa1mtfhd4ACxQWSj7VcW+9WjUD7pAO5XJ67cIRzg1zuq+I9L8X2EPhzTribSrS0AR5MYBXuobjax6Z5Uj0OK8n0LVbf+wxBplqul2yt2lZ5nHqc5wfYEjtgVwHij4u+GNCMmg+Dka+1iQqpQDdHGM9SzY2nHrx2p8t9Ii5rLU7v4p65eTaR/wAKr+H8mI2CwIkLPEYVBBHUA4TqTgfyzzmlao/w90Sb4P8AwylW41K6+e8uQQBGQBmRyOAoU/IvrxgGvAfEuvpYWiaF4f1VLXVbwE395MQcL1+V8/Lt7IB9DXP2Otapc6SPDfgmT7Dp75+0ak42z3ZxjIDADaeufuqB1q/Z6Lov6/pE+01O8k0qGwM3g3wsz3AOFefI3yXjHe8jZxhVX5WzwmePSvPbq90nVLlfBNuTdeFNGuljujb/ACnVdR4PkRDj5O7Z4SIZOM5Fq7u21nRH8KeFLwaXocbiDUddON9zITzBahvvtkDJ+7zk5Hy1+gX7OX/BP68+JS6dr3xHsZPDPgiziCWmlMCt7fRMdxEinBjikPzSu/76cnDBUGG7MJhJ1pcsFr+Xm/PsjlxGJhSjeW39aLyOZ/Y8/Zx1L9qn4mWXxV+JcaSeCtCmjkt7bb/o+pXdtxGFXA/0GA/c4HnSLkfIPm/o1t7lLeMwx9D+uP5D2rzPwf4U0DwdpcWi+HIFt7WIBVRRtAwMDgcAAcADgCu8iiyPmNfW5flUKCUp/Etuy/rv+h83jMwlWbUNvz/rsdAuoLuAFQzXSyfM1ZvlDA9cVFLC4XIPsMV66sebqXHnT7i1DJKEP5VRCtnJ9KRk3fKDQCHyXfPXioW1EKeuP0p7Wr/j+VYF1bToM1cWiWrHS2+qBh1yamfUtqg4yK4GI3McmCOn8q1VmfaOMUnZDT0OhGsjOwjFWI9WD8Vxc2R24NVZrmaIYTn29qtRTFex/9b5/wBI+Jc+iReQ8u3B+ldTYfF9lYPJKCFzjBxXyF4tmvURJEbINJpdtf3NruRiD1r+fHmGIgklLY9LkXNZI+4dE+Ji32oLMZcDrx2HpX0Ro/xKhmt8yvjb90g+lfk3pet3elXf2UybduK9wtfGs6aeI42w2K68s4hxNCblc6nTpVYclrWPtXxD8SrVCTFKBXN678X7NdKKu+Dj8OlfBWueLtRVS0pIA7+1eb+IfHGqXNqI7ck/TvXrVeJ8TJ3Rx/U+RPQ/SzwB42i1nU1w4KpivbfFfjGGygVInwAvavyf+FfxEu9JaNHYhj1zX0pqvxCj1HTBO75+WtsNxZVjScHua0suU1zH1b4b1qXxAphV8AtgV9BeH7drS1WHrXw98H/FNvCwaRs5NfSEnxEgt7tI1f5W+Wvt8ozmm6XNUep52Iwr0sj2S6nxz6cehrjb/WUR9iHPNZWo+KbdbRZUbIcflXD6TqEepakXlYBB6V7dTMqcnGMGc0aDje6PSUu55LfzM4H8hXF6t40gsz9nEgyOOK0/Eviex0+waKEjITjFfHWpeJHu9cAVsg9KxxmbU6TUbkxoSPrTQ9amvojN1Ge3pXoGnyTNjdx/SuM+H9pAdGjkcDLD+VejwqhXagxjpXoYatGcFImdNotrct/Cc9vpVtLtfuD8a5+Vmi49OntUK3QfKpXZpYy1R0/nREHp2rEu3jc4FZ7LcPnH3fpUsVnITzn0pKyG79iq3BytWLdcdsYxWhHpx3Y6YrRhs0Uc9vSqckSokUcA43KPWtaBGQ5jO1l6YpirGnLY6VKbqGHAFYyl2N4QPgn9pD9gb4cfF15/EfgbyvDXiCQmRikf+g3DnkmSJMeW5/56RY5+8rYr8Ofjp+zp8Uvgne7fiXoclogbbDexYls5ew8q44XnsjlHP92v6tpZt4+XjFY2p6bZavp8umajDHc21wpWWCZBJFIp7MjAqRj1FeHi8ko1nzw92Xlt93+Vj08PmNSl7r1R/Fbrk76ZILhLfy5YSOVHluuPbkf0rs/B3xK0zUiunLIILlyMrIpVJcfT7p+lfvv8av8AgmT8LvHHmar8Jrv/AIRK8bJFq8Zu9OLH0jJEkQ9BG+0f3a/Jr4sf8E6f2nfAU0t43hNNctFyfP0WUXK7R/F5Z2TL9FjOK+dr5ViKWkoXXdans0cfSns7eT0POPtFsrvBPGyIwySBlc++Pun/AGhwfata1vzpsa+S37k8AvwQfTIx+AP4V4xout33h+L/AIR7xPFPpxizGDdROVU/3W43L6cjiuv059dg/wCJlpEyTWjYDRlt8eP9lxkgezDH0rynpoz0FZ7Ho0stvIhe8AEZzkZyD+A6flWjYX9jNYRT6ROhxlEVRyu3sM8Y9gePQVyVzqGnzW2yeRS7fxqcA49P4c/SucgXR7TV/t1hA4lmG2Vk+5J/10TOGI7NjPvSUhtHrdp4j+zN5l3F864BI4P9MfjXb23jCLVY3hktpNsY5kKiJ0Y/j+hyreleVxahaoom8gyNGMc/MQPbnp9KojX7u5PnWKyFAe67UHbrjA9Krn0Fy2Pe9DvdSMjLCvmIozuX5WGP9n29s4+ldbJNFcFJryXzf4goGJAPdh1+mfwrwTTdW1u42CWNrSEDhnI2fkpJ49q6WC4uDIPtG2ZP4X3hgR7EZ4/zinzBY9xPiS0REtorVZEX7pwyOpHPy7cfp19Kr6V8TDrom0SwSVWjY5jUeW+71Bxtz+AJ715TPIpjKXcpaOVSpSGQggfUc4x/dbI7VH4OsfCfhey+wWw+aQsyr9qmd8t2Bk3dPSq59AUT02z8TXNlqg024sXg2HcvAXA9dmRge4IrW1nXLq+1DNqRBGAMmNuGx7Ef41g2kE6RSS3myZnAVWaRskn/AHiOntXqXh22tlt2tbpQfKX5x91UI9SuM/XNQ5lqBzkHiZfDatcywrJdYBUFwu0HgMcYx7VzfiXxT4mvryG81+7aYzsPKtYkAYH8MAdOelXNaeLWNWlmu7wahFjCWqxoI4wcDGFUeh5JJrSk1aDSWeRHM12wxCuwKseRwABkfT6Vk6jeiNlTtqyv4h8Tw+G9Djv9aZZLoAFA52xw/hu4P1/CvniT4karq7NceF7KS9lZj+9/1Man/ZHLH8cV2l3oc1zetqXiI+a55C4yAD/dHAr2T4bQeGbiXylhCcc9se+P8BWkaV0Z+06Hwv4x1DxrDbF9RjkgUHgCI7fp6/jmvHP+Fm3WkkrpWmT3FwThnl4x6HGOce1fvVoPgPwV4hswNTsFlgYkA+XkfXpgYr8+/j34C0LSor6bQLdI5LQ7wpUAmM8ZVsY/HpxWqhbdGcm+jPz9vPiLrniQ+Xr1+Le3BB+zW4ZCPx4PGO2PpWNf6haPvtfDyvCkmP3vnqhb/eBO7FfQngj4d6J4l1VbXWMPvQkZBU+xHbP04r1LTP2Rfh8fFcWpX9pHMLaI3bPK2VVV4yVPTH+1xgV0XjHoYcrZ8dWsT6fp0MurPHfInziz09GlLc/eeTGMfQZPY17d8JfgN8ef2ib4/wDCD+GJTYS/JLf6hMYbOEHAIaTBB4z8sSyN2JWvu74dfBvwrr/i3StNhgDx664EBKAYt7bbvYYwAMsAPpX7R6V4dsdB0q10TSEEFvZxLDFGowFVBjA9K9HKMEsXJynpFf1Y4cyxLw0Uobs+Jv2ZP2Dvhz8ELuDxj4ymXxT4pt40SO4lhEdlYgDG2ytuVjH+226Q926V9+Iq+Zk5PNUViz944qbJUDmvsqWHp0o8tNWR8zOtObvNm1EdoyuKui62jKntXPx3LNgfyqyIml5ziqJNmK9c4JP0FXhMzcEelc/ArDCZ/wD1VoNOEGWHPt7VLLRqfKAAe36UzcikNxgVireM3NVZ76UdOhpJDdjqTdxjhTWZNKjHca5dbycHA/8ArCrX2iXG0ngVahYzctDoYLSGQ5OAa1YtMiZxjoK4j+0ZYeM1oW+tSouGNTKD6FwnHsb8+nRRjIGeaz106F22lcY64rNm1ppRtxxioIr0q2Sc+1JXK90//9f8fL74jT2tuFusbo+o+lek+Ffi54els1hdwHIxivnDxVYQ318IbNNzNz07Vh6D4H1lNUVyNiocg9B9K/CamBTWh7EKdSEtFc+mLi+Ora3mEjHXivUNHhmSZYZuFGDyMZHtXypba5N4b1lTK24jsOcivcofHaX1iAPlcjI4rz44KUTqhh0ruW56n4z0+xu9K8y2I4HAFebeB9E+1PMl+MYxg9q42Pxnd2r7blvl3dc5Feh+CfGGk3VybbzApOM1pyytax0Qqxc1oZGs2UWkam0tocqPu1Le+LHFutvG+QMZFega94LGowNfxElQO39K8DVEtb2QynIjPHviuepRko6kShOLtsme9+E/iLLpsaFnI9vpXotp8YvtF5F5knAOfxr5N0XWbW/3W23DHjHSn3NheRXAawbp0rSjUqw0T0M6kJKKaVz7/u/ifeXdiqK/ygetc3e/GuTw/F5cDEkDmvj+08TanalNMuGPPTNJr4ujbtcxnJPPvXdDNa8U1zGc4Rmrpan1nbfFi68QWO95MluOaz9AuNTuNUFzKfkQ9fQV8peFvED2UAMmVCnNfUnw/wBfttQgM0wABonjatVK8jfBYKlN6n6B/DbXIW0+K1LAlQM17dd+XbwrJkHPpX57WPjtPDT+bv2r+X0r1NfjnYXGlMJJPmIxivrMp4jlTpezmzPH4Cnz+6fUGrXsf9lu0DAtjn8K5zwrfG+ldZMHaa8H8N/ESDWrd7ZZN3brXQ6X4qi0q5cs4+bAr6WnxHScYu55Ly2bd1sfSyXluF5wFXiq7anHu/d4xmvM9N8Qi/G4t16Voy3qr8ucDvXt4HEU5w5+Y5cTFp8qR6Cmqx4wOaedRG3D4GK4hHbG5iB29q344EuIVZD8teipwZycrLkmqpn5fzpFvvMxtPHpWBLNaK3k7vmqGC2kD4QcA/hUqUZPlRVnFXOunu1WMbecVFFfbnVR0rMWBh875GKepMYyR+lacmguY6JJVJAHapZCG4B5GMEda5f+0No9KcuqZwDWTjYuMj8HP+Chn7DWpad8QR8YvhZq8sI1qV5LixMpDCUcsY1PylT6cV+cd94A+I3gfT31a4vBNN6bApOBz0x0r+hr9t6DV9R0rR30e4eCWEuwIAeM56hwe30r8qvii/jZPDqR6xb22Am0NHkL83r17V8Hm1oYicIrRH6Jk2CjUwkKkt3+mh+c1j8aLZ7t9O8XaS0EhbDT2vzrx0LRnaT/AMBr0rTIL7xPpM+ueE4/tdra486e3jkPkg9DINuI/qxxXhnjmyeHVJp5lC54ypyPwr9rf+CMdmo8MeN9bV8EXlva8dCBCrfl81RgsLHFTjGHu/ic2Y3wsJSetj8z/Dsl3E/259VNzbn+FIww/wC+lJB/KvRY/E1jHcDMqRKOSAM59MjpX9BnxQ/ZU/Z1+LE8t54v8LWgvpuDfWObG79v3kBQn8Qa+EfHX/BMCSSZrv4XeLwAp+W21m33sB2UXEODgerRmuvEcP4mGtO0l5aHlUc3oy0lofmLq2ratrubXRJoLeJjtcfdDD3GOPw4rt9KhtdH01LPTHVvMHzNH82Sf9rt+le+eIf2C/2qNFjYx6LZ65jOP7OvYZD/AN8zCA1wJ/Zx/absgFu/AuubV/gFtCQPxRzxXlVMFiY6Om/uf+R3wxNF6qa+9GBploUKTMnmMP4cgqB68/59qtv4h03QmE2pt9iGfk2AuxB/2cHbn6V11t8EP2l5kWOHwBrcmOBmBIh+bsBXe6H+yf8AtXa7L5beCZLJTj95fXdtGD9dsrN+lTHC4h/8u5fc/wDIp4iivtr70cjpXjDSdRZWjidAFCiRwVZv0U/THSt7V/GOn2mif8IxoeJJpABLtcqq5/vMBn8K+gfC3/BO/wCNWrR48Ravo/h9DyfKaS9lAPsgiH/j9fWnw8/4J7/AjwxbD/hNJLvxPOTlluG+zW2f+uMRBb/tozV10smxlT7PKvP+r/gYzzTDw2d/Q/Iqf4l6JobNptjNHu6eXBgE/UdSPwrgNX+LqRNvW6j3/wAI3jd+X/1q/po8K/CT4R+ArMWfgnw5pelxqDxb2saH88Z/WujNro8cmY7a3U+0KD+lelT4aklrU/D/AIKOGed3ekD+VW28deJ9ZmVdOW9uZBzsggknyB6bVY/pxXovhPxx/ZGoLaeK4J7OYN9y6jaB/oAyhh+Vf04q1rF88KohPHCgcD6Yrj/G/h7wV450yTSfGel2uqwSKUK3MSycY7E8g+nNbSyB29ypr6ERzez96Gh+SPgL4u6Pp0RdrxhLGhC4OJOOnAOCAPYZFfJnxy+J3g5/Hun31xNHHaa1ObLUNhwqvcKQjleAquRg4x83r1ql/wAFDPg14c/Z4m06/wDA1zPFp2ot9nijdt7x3aqZCyN1RQo6dO1fmpq7zeJ7Vb/xVIZkkUKZVUhtqnPX2PTivLeGlTlyVen9aHp+3U4KVNH1V4Q8X3ul3F9oN7y+m3Mlt5ucFkU4RgOx2EEH0NfcWiWV3408Hz+HdSuU01b+e3udfvpchLXS4OVhDdPMlAA2j+H3Ir8+Pgp8LNW+IXjSw/sSO4v7++niihaXhXb7qbvoBk+2fpX9LPwT/Zd8JfDzQbaLxi8eu36ESlXQfZo5PVEP3iP775PHGBV0MHUxM7Udlu+iMqmJhQjep8keQfspeCdX8W+Mrz41alZPp2gWsC6Z4ZtZU2yfZo87p2B7yE5z3yPSvvxYI1ADdq2fMhUBUAAUYXaOMe3tVfC5zxn+VfX4LCxw1L2cD5zFYh16nPIjtrWJ2we3GKZqNrDCBgDPtU4Y25yOnes+5kE7HHb+ldOrZhZJGEk0URyx+UVb/tKJVwCKzJ7c/dxiseezeIZx+PvWqgjFyZ0n9q72ODTPt7OMZ/WuaihfHWru3a2xlpuKEmdTaEE5z1xxitxLW3uRlQK462lkTDsPpW3ZXHTJyf8ACsJXRvC2xpHSlj+ZQB/KlTTiRgDj29qWa9VVyvX/AAqzY6lH0bk/oKz9pIv2cTHutNcHPp6dqh+yLEOTzXQXl9anj8B2rnZ7vf8Acq1Nsl00tisYos59KWBVd88c+nasaaaYdqfppuGbc4+XNU4O24lNLSx//9D4CuPhfo2hXqXd06sxGAOKs6x4csV06Sa1i4PAIrA+I0txFfRQlye59Fx0rrfDXi0XtlHYonmgYDcdBX5FDGU+XVH2McRBux886P4DTxBr8j3OQEPGRXs/iv4aWeheGvt0W0FU4r0T+zLG01NtQshhYVy3FcrBqd94vvZLXUPktBwgPQ/Qe1Y1a9O/KjrgqS92e58vabdaXqUbWWo/LyRz3xVfRvCE9lqf2+0Lbd2BX0XqHwKS41QapAcRA5UDvXpt/wDDE6ZpULWwH09Kz5YrYmeGpy6bHGR+IpYvCyWZZjJjHXmvnZ4ryC/kjv8A5UbkH0Fe96j4M1ltRjmhGEPJ+lclfeFjf+Jbe1lI8vODjtXPWpRlqxVlBxT7HmEuhtbkX+m8Mfm/P2rq9FuLxG8/UBndxwOuK9b1/wAMWNlOlqjADHBFZcPg2B9s8R83+IkHgVzxw8Wc9Pkb0Z4N4t8S+Rfq1pGcqR7V2XhjxIutReTfjaMc5Feh6n4I8PXuxtufXgdvSuU1jQtLtpY7Gxwjn7vaqr4KFtGRVwbUudP5GwfCdjPD/o5AFWfD2qR6Ddiw3cA9jWVHpGt2NusMM5bjnPbPpWRb6fMk8l1csRKDwfauV0JRWqN40ZRs7WPSfG3id5bQC3fO3j0rjtM8R3rw7Zt2PY03QfK1a5+w3oKgcDPatz+zNO0m7+zyN8mMA44FXCnbUwqU5VJc/Q6vwX4q/wCEcErtMQSc8mu6X4mvfqHjkz6Y9K+ZPGujCaVRps+3JxwcAiu40Dw3LpOgi+kkLYHSqfM9EXG6/d9EfUvhf4vz2k/lTyV6jqHxjENvG46H+lfEXh/+z77UFcv0OPxruNQv7Rbj7GzfLgcV20M1r0ockZHO8JCp7zPvLQ/iTb3+mI8hGSAfpmqer/Gmz0iF4Y2/I9PpXwvpniXUtMm2xuRETgZPFbMGoR6hIrXjY3Zx/wDqr0I8SYi3us51lsWvM+1/AnjKPxHeiWZiFzxnuK+obbUdKNqChHy8D2r8voPGX/CN4SzIzjA/GvaPDXxSlmsFSV9p64NfQZXxAuTlqPU86pheR8tj7WudTsuFjIHFZq3VvJJt6gelfIN/8Y7ezu/JklweMeleu+GfGVvqtj9rilByuevQV9Jgc2pVpOKZx1qdj1y8e1VQrYxWVLeW8K5BBxXjsfiiXUb9oFb5VbHpXqFlBa+QDM3NdlHHQm2lsiXSdr2PmD9rNZm8BQ61aR73tJcFT3D9q/F/45+O5ktLa2gMiMUw8bAYGRz0/Sv3g+P0NjrHwg8RaY7FSbMsCn3lKngj0xX82/xWutauNbbT7wRfuVVRInBfsCfSvj+IkvrF49Uv6/A/QuGKr+pcj+y7Hzn4n0uLWkVLM4AKjDDB/H0r9+v+CTXw0m8K/AvVPEE/Ka3qrtHjj5bdViz/AOO1+JH9izi3ZgAzk7QAPvN2Ff1Sfs9eC9H+EvwX8N+BrLkWdlEXJ6tI43OT7kmjhlynWbW0V+ehz8T2jRinvJ/l/SPcY9Iic5P/AOqnS6VCuAB0FQ/2wMBR26Yp0ep+acnivuFKR8NyxI1so9wXH0qZ9NXb8ox+VQR3DmTLLxx0q82ohG6cDmm5sSgjDurB0+8c/SsxFdPlQYxW/dakk7BDWZLMp4IzWkZu2pMoLoV/tV0q8DHWoxNcqu484FaVqYXAWluPKB+X044odRbWF7PzMybVZkjwSfSs9r6cLuFdDHYRSw/KMevFYMlk0cm1elEJxegpQaCO/OApbGAKy9b1vTdF0y41nVZ0tbW1iaaeWQ4SOKMZZj6AAVflt3DZIxivkP8AbdfWIv2YPE/9m8ALam4A4zaidPNB9tvUdMVGIqKnSlUS2X5GmGoupVhTeibSPxv/AGm/ieP2vviVFrFgGh0PTleDSoGHzmJyC00i4yskhAO0/cUAdcivR/2cf2XB4m1OMT3SfZjtQR+Xui+U4I9Rwa8q8Af8IRdanGdZ2xS5yfOTyn57K4xzx2av06+Buj+ENM1C3urTU7xUADRtDdN0OPTcD6Y5r8txtepWm5VHufsWW5bRpwUYR2Pp74a/sq+EPgddWd7p9pAblrx5FlHOxVjY4Hp1FfRsdxMpAGcGrFlq41TS7e7vLprny9/kpIE3YwF3EoozwNtQm/tgwIHP8sV9nwlSVPBNrrJ/ov0PhONV/wAKCh/LFL9f1NS2mmJwTnt7Vth2RV3dDXLW2qx7vkq3Nq+9AOB/hX0jnqfKKGhryt5g9KoFvK+Uj2qkmobxxxUE94mc9x+WaE0LlOks9OW6KtnHapdU0mIKB96sDTdZMPCkfNWs+pm4XkjFL3rle7Y537DIhwo78VbhsHxnGMf/AKq2o9sqqM8EVH5yRtij2jBU0YUlu+78akWPGBjFW2hDyF+3FQzqsC5J6flRzhyFZ1ctsGeD9KaUdc88VSbUIoXGDVa71yNOF709ewtO5vRRdVJ9q0ltFfqOK4uHVgGABzjtWsmvRD5ffHHTipcWUmjpTpMch5Py+wpW01IQSpwKzotZ81SIuKstqG6E7j2qeZorlR//0fzr8I31xqgmk8RIpB6O304xVnSvEWlaDevGijDvwR0ANfAf/C2vFWtTJZwOEto+cqe4qM/GTV7xD4e0tUluOcyOfu496/DVhqt7HsvE2jGKPu/xv491nRbg6Lo4WcXWAxHbNMe5uI9Q0+CxJXy13S9sV8dfD74g3Pgq/e912dbp5evzBsY9M16FP8etOudTcFQTKOq46VDpSizRYhJc83r27H3frPivUNI0GDUrSL93wCew461wul/EbxDrVvcapD81vF2P+FfGmpftEzXI/sS6k8qzYYAzirXhTxT4g13T5o9AuFt9POTljyx+lbKm/iegfXJVZ2p9j6V1Xx7qSuiOWWOThttcL4u8e6b4Y0s36Slrhh8oHXNeQWniG71VZId/763Gz1GKoDQB4+RrHUG2yr930GP5VCjd8hNOtLWB6Dp/xLbW/C0l7POBOM7c1zPhj4t+INPLae0jSGQ7QTzxXF698KZNM09Rp0pQrglTS6T4S1STUBJbguIcYIHpWM8O1sc86VVNWPrjw/dTtb/abh/mIzj61zawJruueTI22XI6entXE2GpeJU1COKeLbFEvPau50zxHY6PerPdxhZZdpH0q6T/AJuh6cMVyWvseiHR10Zg9zMxwM4JyAK8d8dePbKz1EWtjGWXHQV2ev8AiK1vdVhtbqXaki8YNdPafCbwtqlg08cqvIw4B5PNdMKnM7S2OqGKqVHyw2PKfBXidbyb7PLw7Hp6dq9nHhJ9Xh87d0HGDWT4a+ENjbahJ9kflR0NSa/4nn8GXiafJG5A4UgV0exT+FHox5eX94jndU+H+tD5i7bcema6iLVmsNCOmahk4Xbk+1dJ4S8bHWiYruJo1GByK1fF8/htrHyEADMOBisZUrbGEqEIpuDPmDSnuo/EZbTpT5Xfnv7V6yNRMbC7uCfl4+bnNYGkWNjpEv2uJdykmpPH3lQ+Gm1GwcbsbgK8nF0uXVHDKg4QckzsbfxZo9xH5G8bgMYrsPDto2u3QMHEaDrXyd8MvBPiLxxIdVMvl7G459PavqrwXYXnhyV7W4k3Mo4rlpwlHcWGjOfLKS0Ne8+xRaz9guGDEdD1qn4k1NvDFkbm3J2ryPwrldbmvE1wX8ildhz7/lXdalfWHjPREtIEDZAVsV1Rk3sdFWipJ2PlDxN8U7yR/OcsF/hPrXvfwm+OVxb6X5dw5x6e/wDhWD4o+FXhyXTAs+A2MYxXn0/wxfR9Pa50iXO4cAfpXVS9vh5KrCR4v9nVnO+59xeAPiONR1Zpi2U7HoK+hB4+tE+Vph0r8stP8aHwZoTF02yjg44P4Vc034nahrKrKJWVeAAfSuyjntWi9DprUYqEYNan6HeMfGdpe+ENaijfcXtJASvOB9K/D/4t6LIk/wDaEKYWf58Edh+tfpHoGutdaVNpgIkEsTBgeBXyz8StB+1XOZFGyNNvOOM9h7Gul5lLFRU5dND6vhmh+4qev6HzR8NNCttd+IPhnw7Ou4T39pG4HHWRSePoK/ppXTt67YPlVPlA9hwP0r+e/wCFmnNZfHfwzdbPkhvon+gUH+Vfu1c+N7GxtkldwrP6V9DwxioUfapvex5HGFNudLskd5OBbLsc+1aun2zbN7nH/wBavLpfFOnS2yXTSD8+Ku2HjWC/njsrJsg19bWx8I2Se58hRpc26PU5L2K3b19KoPfRSkZGaovbOIhK5yc/hSRLtXcR/wDqrspq6uRNtOxu2lh9rO8fT0rTl0lNm48ACsyy1a1tUKSnBq5NrCCL5COnak3K9kUuWwy20xM5U9fyp0tiYyTnOKz7PVyjYznHpUlxq6ZDEg9sUm2mNJWNKNwqiM8kUx1gbn1rIGpxs2AMmlN2sg2scClysE0QXkZzn07V5f8AFPwXH46+Hmt+CLlA0erafc2ZXpnzYyo/XFesEqZAeKSQqNhHO05H4UnG6sxxlZprofyfeD9c1Xw9qCQ36J5i4SSKT5MOnyspHqGBFfo18C/GNveatAq20du/CqTs3ZHHBZR7d6+e/wBoDwBZaD8efGHha3RFgh1aeSMN2F0FuOG7DMnSvf8A4C6JDp0y3Jj2y/6pXjhBXA92BFflOOmqU3F9NPuP2zKuapCMls0mfq1ol7f6hp6zzvu4CL0A2qBgDHGB2xW09m7qJe3atfTNK+yWMMbLyqjcMY579OnNSTxMIyq/pX6dldH2GEp0V0X49T8hznFfWsdVxHd6ei0X4JHOD90eBjFR/aJ2kyXG3v7VZaOSRioHK0r6bJGoZwRxXoN2R5aRHcaqsKYB7Yqg2rhlznoelYmpeb5uxe2PwrK2vjA5q4JJETbO0sdUVmLsPpWgus/v9mf8+lefKJEGxfw4rX0yFFy0vUdCapysSo30PSrbVFQhd3ao5r8l+DXFvfQofLjOfTFaMLeZgnuPrU3RVuiOuhuyyladMfMXGcDtWLBLHCdmetbAkhLK6sAeKm6RVmYF5bEuQg69qxX06beNy8fSvSre2t5vmb/IrTXTrYjBwQBTVZIXsbnnSaaIVz3x+tZs8JaXCnFekXVnFjaOKyItKzl2wOfzpqogdPocyt5Lafd/Sqsurz4+f9K6uXTVCnjPr2rKk0cOCFGR7U+eJPJJH//S/k70Xwx4xGsDSsyLbbiruuQAPWu6uvhpe6PfeXY6mNsvRgefcV7jqPwb8ZWOjsbfUnH8TkJnAPpXMR6N4S0Tw81tqV9O92WxvYcY/pX5vJtK+nyR71HARtyyRymqeCItGtEuXvhMHUco3QmrvgTwPpc97JLqmp+So6BjwQawNFufBF7qT+FnZ7p2OQwNenaJ4DstklvbymVNw3JjBVaxqUZWt+hcsFS5lK2na5ueLfg1Cmq2lwbk3FoF3J5fcY7muD8T6lrulSJpWiebCmflUdz/AJ7V6/rfibUvCcsS+FsTRwbUdGriLD4h6/fa3Jq13YRqi52hx92uH2ber2Rw4iFGPu09DuPD3hnUtF8O2Pi+JXmkvDsmBPK44rP07V9ZtfFSGYhYlzyOPwqCx8Z+N5XDFQlg7EOEXARfYH2qtryWmh6jFdxSeZDOd8ZboR7fT0rkr05JrlMKmtnT2R7f4q8Qyz2UOm6eyySzkKcdceldCNSu/C9qFgAEjR4Y+lfIyePL221P7dOjZ+bZkZXis/UvjHf+KRJZ6dDJ+5B3kDHT0q4UJyvodEars5deh9QadqereOtUTQtJulicE75Acjj8q6PUPDU2l6gtkbkXLxgF2B9a+DPh/wDE+Lw/rUiGXZJOf4zyK+i/BPxN+xyahPqUondxlWU5z7e1YzwM6bu0bUIwnG0viPpDVvDtpDoSXW7zZ1+ZVJ6e3+FauhajBcWkGoJefZmXiSHOK+RJfiLrN7qRna5byI/3ixL936V1GleNLzUf9PnsxFHLlSx5X61k6FveaLjU5J3ij6lv/Fh0fxJb3um6grq/+tAavQr/AOIXhHUIke9jDyADrg1+dV7pWr6brJutPtpL5SC4CHjHtW5o/jCDU0Gk3UMtteFSEEi/dNdC9pH4SpYytF+8j9BZvE3hoaf9q0eESEgcLyeleUya7fah4kQTRGMMp2+leX/Chp7GF5tQnCBScIWx09K9O134k6AyeTbRAzou1eh56dRXOq0pfEbe0lOKnN28jivE3xPit1k0h7YhA5G8D04riNTuvFGtaRJe6OpkiiOPKB5/wr0NI9Ku9JkHiMJFJK25XPqemO1dJ4W0PS9D0uXUdNvBM5y2wEc/hVSoRlG8jD963yyeh57pHjXxT4T8HxpFC1rLIRn+HGa9D8GeNvFMLtq96vnbR3rj9V8ZWviO5bRLy38naODjHIrqrA6npmiZ0zbdRAYJTG5fwrhq0FtEVOXLNNy0R0Ta9q3i6/dmAhX06Ctjw3qN5oF+2lMTmXJQ/wCFeTafqt7qEvlAqhBycHDdMVNr/ipdFuILi6OJrZvlHqO4zQqfs1qdXtIqHOnc9L1218Qahcn7RIVhBp/hW6jtr7+z52L7jwO1Ubf4naLrultcKwL8Lt9Kv6aml22mPqyOvn84Xv0ro5tkCxeqlA2/Hnh/w55a+ftGSM44z9a5JvC2lS2udNdQ3UYptv4hi8WwvZ6i6pKmQB/9auT0XULnSNa8m8b92pwOQR7Vy16XWxjUxqlUvbQ9e+GtlqI1iTTLtWkjWNuaxfGGkn7bhgFiKsenA/Hpiu8+E9zPdeIL664e3jjHIOMPJ93P4Cl8axqlveuobaISEbsT0rrwdNU6MV3Z99w3D/Y5Siur/wAj5Y8Dx5+JWm6iPl8iReccDIPtX3V4jv5dYsPMtrkjy1JUD1r5B8P6FP8A2st478oyZOfujpXuUfhXVbDT5Lua43pk4OentSrOUZPlZ5vEND3qbktLP8DyrxB8W/Fdjdf2bAzFU4Bz/Svof4HfEi50+EXWsMTIecmvnHW7uxsNhvEVSDwx5/StXw1JdXNyGtAFjxWVHMKtOopp3aPl0qfwn636B8SdM1zT1dnA284rQfx1orHyUcErXwD4W1K9jjNq0uwjoM8itW78S/8ACM7prybfnlRmvqMPxjOnG00byymhKHtOY+n/ABn8R4NPVfIIAx1rW8G+OYdbs9rSemPevia/8YPd2JhYfPL3PbPSvONB+IfiTw54g+zJkQ8U48ZSdVSktDz62DpKygfq9vnhtmmjbp6UzQ0udVkPmn2+mK+UNI+Pzz2ixzphOBntX014e8e+HLfw+L1XXzpB0zX0OE4joYidou1jCWBaWh25sEacRK3zHsKmvdNk09RKxwBwR9K808N+JRdaubp5AE65J4rttT8U2urn7NYkNg4yOlevHHqesXoZPC8q95akkt6Gbjt0A7e1akFwhjzIcnpXMTC00y3M10wB6/hWZp2vLfOVg5QEDPareOpNcqepEcNNPY/Kr49aamr/ALU3iqe0baHu4FAP/TO1iDdsdRX0j8D9BaOey0x4gIzdA8f3V+Y88Y6eleVWOk2/jP4wax4h+0NGdQvrkqyj+AEqp6YxhRX2L8OfCUmk6wguB81vG25umSRjPp0r8srx+s5tGktnP8L3f4H7bQ/2PJJVmtY0/wAbWX4n1I91bPFuXr6Vyd7dIr4/SsM3D2ilmb5R39qxEvm1G+8m2G4DjOfSv1Z1owe5+IuDktju7K4tEO9vvdamv9QtNvyjPHWrMPheT7B9oLc4zXG3ttM0hhAPHH5VSmp6oHTcdGQ/abO6fY3NX49Os5CNoHFc0NOmhlyB+VXreS8/gGPrWzl2ZilboXrnT7VOIxz7f0rDlsQGBPatkRzfec8VHKJGbb1+nApxqA4+Rjrb+Vk/3BnpVf8AtVrc7R+la108qwl9hzjjj8K5Ka3vM7tp/LpVxae5m1YuHVLlieMbq3dJ1e4ZvnXIxXNh2xtZOQOOK2tPIX94qf8A1qqT0sEVqdHdeIZLMZxgUyHxbP5eN35elcpq0hdP3dZemDzZAsnGPSoVuW7Ret7I9QTxI0i7ZMAGtsa5AsXPJryq9/0cAqc8VkveXsw+UED0paS2HqtD2f8A4SC1lXauP6Cr9rf25PqK+eF1KRJCueBwfauih1SfAY/SiULBGR//0/w21v4u+Mj4+svDOn6Xt0t2KmYL+6I9z7Vqap8JLHXr99VsZGWO5RllhGCuemR7fSvaY/CvjK5v126WxshlcRYBBGOeara94F1BLCGbTrYJO8v8MpB2dMbT3zXwDskrH1zR4doPwD+EXg7ybnxHsj1CRtsDFiOffpXQ+F9S0fQbuaGCww3mbGkYZCr0ya6TVPCV7Nb3tp4jXzrK2t/OdXj3qqjoQ/8ACQfyr5u/4QvXtR1a70q01LyIDETHceZwjH7q5ycjHt7Vw1+eTtzowlFppR0R6L4s8JeC/DmqHXb3WjNPdEvsX7qknp+FaMkWh28D6g8bXMKQKI5No2kseCfavP8Awt8HvGmt+GLuHXpWkurWQDytnVcZDg9CPpXZ/Dv4ZSxxTL4u1qfT41i3WzY3RKQ2Nrr0HPAPSub2bi3zPTpY4nCUZ/DvsedeKPCvjXxBdLdaEgtBckLGrHA2j0UV1U3gU+E/B8fhDx5O11dSt51pLtA8hsdCf7p6fpXWpq9/awW2hRGN9QtpXaJpFKmUbgo28dOau+Dd9hrOtw+Ib06vcatJ9jhsgu9YLePmeTk8KOgxznGKr2y5diqclpzI+aPEug6fa2Gnz3NxNKFl2yxxDK4+oq14Z0Hw9fapJalZLNI0dtoG1uOnbHNfRmmQR+E7u5tdMsRdRiNJHEg+RJCcqMnoduOKr3X9qanpza5ewwPJv8mSWDDbAfYV1wqRcbHTCpF6s+aLfw/4I1q4+zRaeUukcrub5WdR35rubLwzpd1KujcWksfAx2X3r2S7+Dvh6XSE8ZHUFSHoGlJiZWXqP8MV4Po2j62NcuP7Aifud7ktkH26mteeFtWatRTWi+RzGtePNO8DXsmn6RZ/a50++7ABcDg1la78Q7nxBb29tGn2XzsEImQPw9/pVm28P3Gq6vc6deurXEMhEhC4GfSvW7P4Y6msBudSEMMMYwkjgbf/AK1EqcLbA02rI4rWPF/xK0eSBNFhLWqxAbmXIXPvXCa743jhV9V1e5e3ueOQB079OlerTaD48jneDRRhCvzeaMo/pjFcxpvwO1m91SOLxO4cvl02D5ST2+ntWCwkZO8l9xM6V9L38jS8R6vD4A1e1bWblp49Qs1uLcbshkOM4x+FZQ+Lq2NksNrZukYY7mbG0jtXpzfCi08Vaba6Dfwo0+l74g4kGUiPIGOwHp6Vk2nwwhttObR9QiW7DyDawPzAdv8A9VY/UqO7MpYd829kbWleP7DWfDR0++xIr/d9QPSovCnjCPSb97fTZWMarllc/wAqop8J5DqYtrS3C4xjcSuM1o6V4Jsv7RuNGuJPszxfKTjr+NYVcHBddDW/LZtbGrc+P9f1HVXfThFMijvjI/KlOv674c1WHUrS58tZBh7boG+lRv8ACf7Jb7/CUp85TtlXcGVj7e1Ld+FfG0SobqwDva/Nufpj6j0rklQUfh2MaqTjtc6qfxlr2tWzajpenRjy+XdDtIx6jvWS9+vimweDSxLcagcAR9gB19qqQXGo+Y+pzGK0ja38r92+PN9Tt9RVrwN4d8faRcxeINJK3tmycGFvmCj+RxWbhFnLCnzSstUcwnim30OOXSzEY5Yf9aB1yKu+HfiaNe1AWIkdEgGf94DsawfGfhe61nUZPFmhxzxadduUmbblklXgj6VV1bwzJo3hxbjSYWeQ4Z3AwzLURwkZa/caUMLUlPl6L8jorzXfEF5dS6vp6vBFCw2sON2Pb0rY0bxFqU14P7Z/1UjD5s4I/D0rzTVNN8banYRXHh/ENtEFWUSnaK5rxfpHizSprfVAMAptxFJu3v2CqOc+ldEcJ7ttjslgKVP4os/Yj9n3Tbq1+E0+tTRjGuahJPCxbduhgAiHToARkVq+LrWQaCLaKPeiz4ZsYy3b/wCtS+EfBnjf4bfDnQU/tgLepZQ5tHUGKPK5ZeOh9a4LxZ4s8X2NnNPq+nxDH7zCtheOmBWNWny8tPsfqOUYeNHBwiuxD4c0aa6mmnygkOU2YwR6dqoeJbjVdNj+ztMwQKXUHodvUfh3rr/hDe3+vMqmPajfvMMM7fbNcJcNb+Kta1vwNrE4SVLyRbZydpjkPQf7p9KznGMvdZyZ3lMsThrQ+Jar/I8ZtdRbx3qR07ywXgUkkHHStP8A4WTpHhbwm8DKIrmFioyecjpXzJf+Htf8EeKb6fWXuYvs7Ok/kEheOn4V0uj+JvCPiDTX0+6i3XikFfMIX5B0A/rXnSwzjoj8rjSn8DVpeZ7lpXxNWy8Px+IbyRlklGVVe3pXJ3HjbxJ4muxr0okktlbhQDzj+lcb4q10W+mW7x6YDaWn3grbtxx2xXqXh345aGnh628PS6VlpwFMUQG6Ncd/an9RUktToo4WUnySnZJH0x8OfEOk67p/laxGAQvGcZGK8/8AFE2gR66I7mfyt7bR9B0rP+HOoeFRaanfeIGayjt3AiZmBLE9hXBeIvsGs6rFLdncE3PHwecVh9Xs0mdtWn+7jse7aPpa+J5DoulzAMq8EcA/StRLXxN4ddtNeaUeWenOMf59K8E8J3XiGXxBFLa/6MD93nbnH+elfS+p/GGHTvDj6frUCRyfwv647/jWvsOVHVhsNBxcpu1ia01vxH5bW/muvlgHK1reDPjLd6BPPZ3YLyRdD68V4V4X+KghupTcvE0N0fKAfjBrJ1v+1PB+uyz3UInsJ8Mk68qN3Y/0rohja1KKVKRlWpwlaSPedb+MXinxDFMWfyYlOBnrj/8AVXYeD/jIT4fv7KDjybd/n75IxxXwD4x8c3ZmW109SyzH6c1678MpJZvCepSXcbYCrGSBk5PJHQ9sVGCxWI+sxfNp19CMDT9tiY0UfS/wP0Q2+qHULX5/LUbl2h/3Z43bcZ4JxwcjFfbJlstAunkeQANbo4H3fvZznP0r5Y/Zo0G81nZ58zxTiItGrFgJfmAAB/hb0HQ+lXv22vEV54M1qy0bQgyTXOmAn2G8jnFPCY2VHG/WLbX/ACsfqXEsYwyaUOnu/mjR8bfEqNVmEMvyjoVr1T4b3gutGN/gbiP1r8m7vx9rkumwWphbzB1GPSvo74WfGnVfDunJpN5GWXrk9q+gwuer6zz1dmfj3s+ZWR+l+jeIruS3aC7b5E496rT6lbyz7BnmvmbRPiLF4iZIY5RCpOWx6V1Nx8RNIs5BZxuCIioLetfUU89w17Rehg8HU5bs96uYrZYPlPOPyrmAQuUT6cVRGtNd6UbpTkqCQB6UnhDWbbVpWjmOw56e1epTxcJNW6nNKn0Lv2+GJRHKD6Cug0uexAE0+B8veqmpQ2sOWgHy1wV3rEf24ab0ZhxW1WpGNr6CjE9Wn1/QoU2kqc/SsSTWLG6bdEoPuK4g6Sc75Bkf5/KtyWW10TTmv7ocIM+nPYCtVGKV7mbnrsLeXlhbPjZhvTvVX7ZGxGAAO1R6HotzqudY1IbQ5yqn0PSuhk0uzV1gJCsegPrThVQODexylyV/i6HkCsyDPm70HGcV2F14emj5ib5BUCaK+1XVcA9a0dRIhUmVfIingx6dMVmZSMeVIPYY/pXXRabDE3lhgFxg8U+8sLeCPcArDtjtWSkr2NXB22PN/wCysyFh0zxmrcQVIihGM9/pXdxW8TxbioPtWNcWUVxn7OeR+WKt1GyORJH/1PgvVviFdarZW9t4Wb7PeEEN5EijPHAO7BBI6cdK8i8cWp1jw5Hpty7adfLL5lwspZzJnhGUr15xkCqPiO3t9Dki0a3nuJhLCHeBIYgvHVgy/MCGwN2cYPNZmsjx5NprWWk65dJFKuVjhjWSWNpeShk2qeuOv3T7V+d1IqUHGx9lON00c/4Jk8c+C9K1G3uroXSXCMEtbuTy0kEq4dC3O1W7Fwp7CvBddY28z3iWsmivE6iCBXWSM855f2HC5Fcb4w8H/FHVvENtJq1vLHDCp/efaX+YHbyQuNz56E8ewr0f4ffAbxbIus63e6eqR2CxzXfnTt5kaO6iJ1GGRmZ2CMvGCcjOMVw/U7Rvf5aHnVMNOaUI30/rsYGk+ONTjv3tv7ZntYU4NvdRsY+e6yJhlI9SrKRxXuvhX4u654Jt7Aa1HBrEhjlRbcgYktmyQUPCknH3SQV7elcDqnh/wPYXJ1fwdO+r6RG4humvTADbSsm9kijhjbKox/dE46ZPpWV4U0fSta8J317o2m3txfaJEZbqeG586NN7D5J4zCqQttIchZshSGHpWNWhO1+iJVKvDrscD48+N0Vx4pu7vwtpgt7gMsZkcti2tm+ddpJ74weOK6fwZ4ge31aPxPAyPMIVRZGdVUQzkMTtPc/d2/7NcPF4g8MyWk11qiQI1uWdobpnucQ8YZD8rnb6qW6/Sq/h7V/gXf2cU51uz0NlkM6iaG4QFhuGAyx4I7quWPtVxpXivdd0cVGnPnTcv0Pp/XdcW1trbwuIPO0+W5NxezRyqk7h1GCwzhSuejFfSuTbxHY+HtB12yu5109ZnTZPIvmAI+FTGM43Y5bpzXlmlaPJq9m83hXXba6vbVnFu0pi+SIYO4x+Wspw3QZII6qMV6VoL+LbmBLD4gKl9e3FwlvBHbWuXe3OFcFkG3AY8O+EA64xmp5dLSOyo77q3Y9G8O+GrvxT4UneOKV7GC2tpI1jkDn/AEk8ugbuMY56Ctvwd4k0L4cakbNtFu9X1C2K2x81lTCMc5JH3SB3rzTwv448M/DG1l0/WtTS6t9LVhpo0m4USwqMsVlkdSPlG0qhBGc9RxXUx6r4Xm8MXPjKC0t9QvjAI55lO9mmcgoELlQ0jqQMYAPXgCqhONrPY3oYmnCKa+Lqjn9U8Uxa7qlwUgntILiYiC0ES+YmehaUYL5PRuBViyP9t3UljrV25jQDbblGXIXrl+mRXaLqHxP1LS3tNH0KzELKC0lw6RW6k44EhO9yBxgBVz04roE8GXXhq2t9X1LWNM1hLwGa6t4RvawMXB8zO0ANwFVc/pXTTrU9zs53JbaeljntL0kw3EUJtpYrWVGVTJ8gQgcZ9ePStnXfhl8QtD8MJ4kt9NuFjOWtpJJNylCPvquc/SuJ+KkOg+H4LW/vdQSMzJm0iLCPb335LY244xge1cVP8c/GHhbwhJoFrqtrdabDFHNFsf7RPEzHLADJKgegP4U3iOa8aQUpUuZxm7WOesTfXdjf6Prc32a53ZgfiMvIegLA8+mMV514f8ceOvD6Xdjq7Nvhk2/MPM+UccdxXovh7Ttb8Xebq+sWqW+nM/nruh2zyMBwyIOcZrd1HRdesVMQv7ZC2Gi8yIFz3ILcEGtI03a0jOuuf4TzC3+MfifRLsG6kRIDwJTllHpu/u13Op/FC3k0uRbi3jBuSS8rcxsQOCrDnB7cVir4Nv8AxPdzWETyGSIlnEFvsyMd2IClf8OK8X1LwhaQ3msaL4m1W4ltNKSNwlnG7ykyt8q7Xwq+56D6Vzywbm/iPLnQr7KWh0+mfGi0TUGt/D1vJ9oTJaONmmI44IAHAz6ius8OfE3xt4lghiW01FpQNsuLWcpn1xtxjscdK+v/ANnN9e0LTbaTSnh0t54hMsUxgW4nBGAzhccAYx1zX1DqelfF+5vIrjTr2Y/IcINkQVvZRwf8KmNCK91RZ7uE4bfs1OWIS8rbfifmDqHgj4leK4Lq3tPCeqGQxeYWhtZVQOOBt3KOGra8JfBP9pLwsl3oWiafqMKCONnlzGiiQjLKu9h9DxX6EyfDP486rP8AaJtTvwJRskIlYbh6YHFUH/Z28eNIY73UXi3DOZGZ29Og6ZrdYCFrNM1hkFGMuZVXfy0PmPTPhV8ek0iCG7jtLNTjdDcX0ICPnqwXcKq6/wDDHWtVs/sHiTxppdo8LHa0LtKU9chFAOO1fXVl+ytcXsqWYvpLu4OCyopyq+p7DHua7Q/s7fCPweN/ihptTu0XJtrZwqDA/icD9FBolhMPR96ei9Tvw+TKXuUuZnwxBpnwxsdKj8P3Wvanrl2WAAsLVYi59FDbmP4CvoLwB+zJcG+i1S/0lPB1hKMvc6hL9q1aRDz+7i58rPf7te3w3/h3wrth8FWVtogcfMbdd8mByMyNlvyxXFeJ/HySQSN5+52PIz1Pv3PvXDUxlNfwYf1/XofS4Xh+nC0q9r/f+J6L458M+DtQUiDUJoDGoUStIVdyP/HeewxivhX4s+L9f8JWN1p6ag8sPl+WMgfxcdD/AJ9K6vxR4/vJLcR2MhG1ceZjJyOwHX+lfD/xrl8Ra3pDjTWm8085z1J7mpwmHdWpeZ15jjYUKXLTWx+kn7F/jO21/wAGGJ7mSe4t3dDjkBR2xXj37S9pq3g343DxfpjeTBqKRXKr93JX5Xz27Cmf8E0bCfRbe50e+bcwBSVejZHNfSf7d3w2TxL8L7fxdo0iR3egSC4YSNtT7NJ8kucDkJwwHtTxGCUajS2POr5hWlglWpr342dvz/A+I/jx8RNZ1/TbHVdMggRbpT9p3sB5hTGw4GR9TXzRqGvtZahDqWsWSm7VNqiM5iOeByP5Vy/i238TeH9Mu5C8Nw0Di0kt4GL7S4DDnG1AQR0qx4dg1PxbpsP2lQ12kJLyQjfF6L5nQIfQ+1QqCiuZ2sfnuIxdSvXk5Qt5dDKTWfGcd9tjv4VikO/ygxwmf73b8K9z0i88RWWk3eupcwJPKojaWIAsc8fKDwM14Rd+AtXjslj0x7NgZvLuojJmUM3AI45Wut8a+HLvRtZl0u2eaQWyRwNiP90uAMFOR07+1a1cLB25bBSpKOtmes+Dn8V22Lya5/tOK0X7QLeQ7WZ/p0P+Fe8+CvE2t6jaSeIPEdkkU8rkQxZ/1QHt6V4H4V8BatffY9P8M3b3V/OuIlVt0kp7gA4AA784FfS2gfA74pWV5ZEaFdXcxcmVUnhk3JjGcB88VxLD/wB3T0O3CYacdk2kW9RvdL8QN5pnmhu4R+62/IhxwTXiPjyXxZqWnJa6jPJ5aMfLeJWJAHQEY/lXqtx8JPj5YWx1O70HUB5MoCJHH5rmM/7K5PHcdq6Oz8CfHzVnRbHw1qMsTSYUfZyuGA9H2gVi4TV1yaehVV+0TjKDV/I8M0vRNdudLtb/AMPxk3SqNy3A4O37zD0FereH/jNe6bLb+HvE2m77S4+WeMDseMr2/DofauwHwc/ajgvZbmXSjY/alEYW7lgtUQep+YkevAqlc/Drwn4IMd78SvEB1i/U4ez0VSqgdwblwBg99qVksBKe0bL7jXB4Gte1GDXysjltZ8CwXEiXHhQtqVuZcxpn51PZCOw+vT8K+qNX0S98DeDtN8MaKXu/sv8ApF61v8wkuJe6dNyr90ew6Vw3wf8ADHj34way76LYSaR4PsfNEjWy/wCskChVjV3/ANZIf4nJwoHY4Fehf2N4t8E6lNZaPJLdxwjdNBdR7ZIWPKgt06dPWrqYRUINRd5P8D7TIcnjQq+3mv8AI+tP2cx4d05xdTpNFFIojuYJPlkgkHzLKn44yDwR9Kg/bla2bxp4binKefeaZcRqWI+9E6kEdODu/DFY/wCzh8XrvXfFjpqPh6eOKJDFJcWyiaMBgB80YPQd8CvKf28vG9jovxS8M39uRMJtGmhtVmH3GabGAT93gDGfSvLVPluepxXVisulfa8fzPKPhxpWmwXIfxDcQXBPHbFN8daxo8+otZeHYYoYoiBlO9eIeHLHSXjtxoFy13cRIGmABCu4HIGe/brXQeFrKfVNSN1qmn/Y2LkeSzYP1pqMbbn5x7amqSikkz6D8KeG10fS4tQuy1xNfTLBbqndn6AewAJPoBXPavImkeKP7P1mYxqjcg8Dj0rhfBXjq7m1K88daS3kw6deW2laYhOUIdh9slxyOVKopxxjjrWf8TfiPB4j8SYjtnuWth84RdzM5+6v/wCulNaKw6VahKm57dvP+rfdY+0NP+JdgmhJaWh3hF2nHSqXg7x5bvrxswfLzyfevHdF/tG88KLqk2nDTRCUX52xz/8ArriPGPi640iaLWdKC7ogAx7V1080xFG0k7pGGIw0OX2j2P0gPijTZ7cpI25zwPY14l4y8Sf2J44sftHCsB9K8C8F/EWbWNCGu3cpVkPCk8nHasPxz4q1DXXXWHJUWYyOOT/+qumtxFiK9uljilTpKHuo/Qrw14ssNWIRSq5XOT2//VUOn+Z431c6i6kaXasVhH/PUjgt9K/Pn4VeK9Turs6VfXLRwzOBL/eVGG4jPqwwPYGv0C1b4m+FvBulwb3RIlVQAP4R6V9jlmfQr017Z2sebOhf31se1W1mTBlsKBjAA6V4X8SPt+n+J9LntnxG5A9OQf8ACu18P/EbS9egVrOQICPxxXG/Eky6laQah9xIJB8zdBXp4jGRlQc6bJcNLI9b1OeNNGa8LZVVB47Cuah1rT7DRjeE5SMcnPHFeY+IPiR4esPDE2iyXqNctF91SCeelfM118UDF8PZbW9lZHJO0/3scfl0rkxOeUKbtzLYjVPY+rP+Eiv9cuA9mNsBHy49q7q0sZFt0N0T618+/AnxBb6v4bs/PmDM+N2R3xXr2qeMIxdvY2pASPhn7A1pg8wToqtUZ0ez57cqNbVZ2srNiDtzkD6Vl+F7h0uCbldwb1rIs9e07WboaeJBMSQM17Na2OhwqEaRd+B06fhXoU8XTqK8ZaGHs3e9j//V+ArL4UjVLmKF2upJJi3llYSLdFx8x+ZsF9wXgE429OKZqXgXxRf6w8t7aTyIsUUIngBUvxs3Bo2wqkZOGUEV22iWOgW+m3Vpomsw3zLF5ax2+ozwyRAD5tjPkDyz87lWBUjaSelJa2MVjb+fZ6vLLY3rb0864ImnWQ/vGQlRwO+xic/KcYOPzZTbV0j7eNmj5d8dN/wh32O906F76WOQvdmKATeTEvQKoIOMY57e9U9L1Dw9418FX3gbTNRkivtZ8UWem3kMrtJO0NrbvcxttUu3yzPGCxKguv8ACFzXvWt+P/hjput2WiaNpVtNqa+bLAlzcs0rHC/JsOSx29dp4YEEGuS1zWfC7XqWmp2sVgLIlE2COz8uPAAK+ZtX1AK7lHbGMmrNrYdrbHy5e/ADwR4FmBnXV/EM3nuRaS30mkQO6gqoT7KxmI3DlgWyBxjNbXiX4Wa/430yyt/HWq6ZZ+HNOO+30nTG+xWMROHOy3jLKZSwyHkMk24k5HSvsKye11bTZLWOWa2KwKslvHKJlYlyQ0XyeYw2sp2GXAwdpP3a8hXw/oPhXSZtJeR0uDMPMEqhFfcPlkxEhDFl4ADDKghuMVLqVE1/VjGVNWslp/X3nzbrH7PXh/TLWSbXlubm1jkhC28lwjQ+qiSSXc4w2APKxnHzcdOO1XwVYaRexDR/CtlrQ1DdJO0c8lwSAP3mY4pJEj5GNr4AGCSO30XrN/8ADfwrZL4gtjaDeWRxGqxAbDlmKghlIbcp39DwM4q1pGu2JliaLzLLTcPFqMVreXNnNNDKNyr9phxx93ERUrIdqyLsYmtI3kt9DP2VNq0T5QvdanjSz8KX3g5dQhmbdBH5MaWkSKfmQS8uoReNxYDHHStzRtXTUPhRrHg7wldHw5e6xexaho72dwjrbyaXFOJlTc4/dFZGKRo+9pY8kGMGuk8UaA2v+GL2eR7uxB3yiO8T7I0+zGWikjcIVPTa3LAY5FcNeWOoaaml6VFaQSQ30LXV6zMW3TTAlGV9hyEQBdxCq+8gkGnGjFarf+vkciw/I9GUNZtPE8l6mp+FEFzpl1P5el2sl6Lm+8pfLQxNguZXdjk4fK8qCcVw/hDxh4X8O6pdN8UNOiCxK4RZm8lpzIrxqYt5Ox4eHQk4wORXos3wi0fRb46taWLWkcD5I8tbMwGLgeW+cNtA+UrnBGD6ViahoCX2mP4b1LUZSyRtHbeYI5HiJJO4MzB2K4HHIVeoHFZ+xp3M3hFGXN1/AZd+O/D6S/bdkFnczk2sIjvDcQYiHdZGdoh1+TIB/vdKqa54juNe8O2liL2SPUHkby47Mp5Dxn7ohOPlfOFwzZH8Nc/D8JvE17bJfWiNdGO1itvOkDqC02cRPsIYjaSuGyFAyduK6bSP2fbr4kaabhdQe0k0yFC6sPOFwsI/1MDRtEFlEamRA4+ZVwDkCqnQpae8RUwc5/CZvgjwF4/0q6PiHUdINiIcxvC4H2hc/MDNJNtxwB29B04r6y0rT4PEdpFrF7pyNfbsXWycPPK5+Uj90gRVAH3AMHivDf8AhFdQ8mHTfFmsW0Rt90cMGubZZraKJtrEvGpxuZRggspBXB2kE9b4W8CgXEuseHNfuZ7CKVN6W0dxc2yNwoVRCY9h3EZBIzkYFZJRu/e+7Y0wlFU9Ee8f2dDbRmxzNYyxIUjmZw4hjbldjAbUPt+def2vi7UtHsLi2W2stQlmOZpZgJXPoqJt4OeuCOa7Pw74qvPBuoz+FPI1a7vX8wyPq1vJaSFGzgJHchNyAfKgjZmbHGTVDwX4NZ7a4TSrJtMimudtw/zu8e/nkkHAB+8OgA25BFaas9Bb2I4tS8Ui3V4mDmGPyvsaEBY5G5Clu+088ZxXknjrwJD8RIL++8bzeXcLGqTPHc7rh1UDggAAAc4A9K9j1b4ez6A9zND5E8JlWZvJ3OkgOACB+6QjaQ3qBxXHLY6JqmjRyCw1zU5jM4MFhCsBlAORs8xULAcdG2gZxk8UknuiJ0uZcrPkCf8AZq0me9j8bXMs955aosCRpLJct5a/KwkYBYlHG0bsDHArvPB2p/Gv4X6ib7RfFGuaSZ8SRxXF3FdjHRR5NyWTy8cnZhuwrv8Ax98QLP4e6OttqHgq8vZJtwitSxkaEYy/mK2XVsD5QEI9TXLWmrTeOPAza3P4Z1COZQT5KlYkAAxGsjMPMHoAFyCNuK6eetypyem3QzjQhB+47Ndro+5f2Yf21PE3ivUNR8D/ABpawtLvSbOTUItatpGs7K4t4SPN+0RyfLA6BlIO/DjOAMYr9B/+Fi/Da08GweNLmW41TzZnt41IMMBKgZY5bzWjbPy8Ln0FfzdaR/ws7wr4tmtdE0WC81JArJaMXmkt+pjWKNh5bSscDzZB+6AJGOTXvcH7Qv7RHgdmnl8LQLqcb+WkeoXjNLvAzvSPYfMPfC44HAxTxDqNKNGyb81+X9I9rKsfSjri9beT+Wx+7tl8adA1WxNgz28EcOGWG1jwT2x8owRjHrivEPE2uajqF5L/AGTZyRFgMuV4/AdMY6c1+Sp/bh/bV1D7TqFpJYaZDBGGklnhfbExGPmKgbckjGVAwMVyR/bS/bYlS6fVPE2kRSwQGTy/sLPK2OAI03Ae5LbcAjjtXAsu5n+8lr/Xa57j4qw0FyUlZeS/4Y/UC/0TXLuQSRhspj5i4Ax9P6VlXXgbVZ5DJK0a7hnHDfy/yK/Hsf8ABQD9s5Cn226sfMj6eZpgAI6/eDAduB1xXQ6R+2x+19rLxw217omXxsjltBHlsbuP3oAyOnP1wOa7/wCylDe33/8AAOGpxPSn1f3f8E/Vhfh7CyLLNh5MfeIxz9M8D8KxtS+FVvqVqdkZQJkkngD06f8A6q/OGx/bA/bEvLcJZnwtPNID5aPGmXyCdqn7Vt3AKTt64HGeK93T9qr9p7Q7Oy1Pxf4CtLrT9QgYpeaNer/D8rNErMynBIOyQpycYyKuNKFPS8fvX62OGrneGm7cz+7/ACPvf9nrw14R8BeL7mPV72DTI7iIyK102PM3cHYAOoxz6CvoXx1B4e1PwHqtvqcqpZ/Z5YpWl/1XlSIQSDxng8fl1r8aNF+I+sC9j+P/AIn0+4u7fWrFrbYT8yqp8sxtD91drJvDq2evYV23xw+N/wAS/HMdn4C1LzLDymk+32UBErvIn7yPZgh2T5TgkYyMDd0rzq9S9RpWsvzX+RtTzzC08NLmeu1j5s8J6nc2V0PC+n21pZeb5SiNvl84R4RPNDfeDYwTx2FdhrPw61e+8QXP2iP+zEaTLxpP5fkOBkxyAdcY+VSuce9bVj9rsra0jX7DrNtep9qt0Z8ySIW+ZCwAWPLblXcCjJgNyvH0D4j8UWz3kerJKdUW3htbYgyfZdsjoIwbndhm2qQhXn5o8E8V5/tGpM+Yw9FVIaz0XT+v0PmTSpdP1Lwf/bWh3UN1fm44tMFjKFAzIMAYKfgKavjnwlr3hq5/4TXVZNM1V5EjhlGnSXMUsSn5ziPJEijp2NekX/hvwukc3h/R7yMQXk0tpZQ28+2ScSAFlMgxkA4ABKsOuDgV5F4l+Gus+HtRMdxLqejRWaGOCKKR51toeyu8aPzx8zOd2e/aunDVqcpWZvGo47vbQ5K+/aS8a+HNft/hb8IfDDSNfXC2Vu0yrFJdLM4RSwTcy7zyw446jjFfrV4f/Z4+KECK9lqlrIVUcqGToBwo/ug5wePoK+AP2OPhvot9+03oWr6/qbaudOs7y9RedgvFhC4DN87Mu9tuBgnoOK/oI8K+Cb1YzJGvzAheHXIwBgEKScgEZGMivQxKoSUZWVkfS5DVruMuV6X0St28v60PlnSfgn8X5YksrvVTE6nGTKcjjjBOCBVLWfhL8RYZzb3eu3CPGMcSt6ex/Kv0D0T4Y6pqkSG6mAtZ1cb+Afl6jHsOM9u4r03SPhJ4T0S3+2X0XmSbN6yO2c8YK98MDyOxrz543DxVoJs+ppYHFyd6kkkflna/sveLfFMomGqSkOQWlkDcDgdzmvoXwL+wL4DN8lx8RZrjUYkwJIJT5cG08ZYLhmXIwfmAHpivuK48Q+H/AApH5NlGsksnyjysYBXjPPXjg5+lcjrPivU9UtVs4CLQR8gAh2x6A9ACOo5rza2LqS0j7q8j1qGDpw+N835fcdNat4d+F+gpoXhKwgt4bVdsMa7UC7Dj5VXomMEAd81+ffx9t4G8OXltaRyLNOzSTzqoDb3OSeDyTgIoHSvq7VvE1vpdu6whmnx8zvkkn/vnj27elfHXxL8SweVPLIwZ2QhpGOSox2449uBWdCi5PUvE4iMItI87/Ydu/EqeK9Xsrm9ukEDZ2BzgErjbnuR0rL/4KD6JpMVxpOreLZN9ncQyWcbn7qSbvN3EjkZx9BXuv7HPhS8stKn8ayQOlvfyjYSAMIP4uuTn04r5m/4Kf69/a+i+Gvh/orzR3l3cz3fmW6ed5aQrtG6PuhLYPfjjpTnh+etybHiZx+8yqcfT8z4Z8Gar8LdOWeXU9TmuLRfmTyJ5IU8zHylTjGR6DrinX/xw1WPRo9Ha4F5EcL5nlFpEVvl5YHKgZ5boO9fIU3gjx1LYXfiPVL29mtI8IYVAUq7cBx/AB7Y9qo+FfiT4k8H2h0TW1e4gkk8uQNbqSufuqY2HzZ77GSt3lN17sk7H5pKg+Tlfu+f9M+27Lxzpuk+ErPQmtnYrMsc0lm2VC2jGeUow43OwUZXouK9j8BeL7Dwz4K0j7bfGxvZ7gz6oqQ77kySHeqKSCSoTau7FfNnhjRrDxt4fEvhL7RYWlpHHHdaVMCUtmmb/AI+LbofKkbCyxuS0Bw3+rwa3b/RfGWo6pNYS6pDJYwyKlxa20ZtG2qwUedzv6/xgmMjnIrzvqTg2rjwsKlJqW+lke+eIfHeh3PmWGmLLma6eYwCQkRQr91pGJwrMf4etemXuheHJ9LtdG1K9hD34MlvDu2FsjoM9fpXhnws+CXhrxF4vXwPbXTaddXh3xxmIyRwptd5DJISVRVVd5fqeAuSQK7Y+DkvfEEPjSRY9Y05kGy2idFS2tVjcIgMhDBiqGTaVDhiM4JAGcsNHZs7/AH7vnS12S2S/r/hjrvAHh3xR4BtprHxBag2txK3ksTt6DccHH90ccH8q7zxXcad4v8TPB4ct2ubNbpfNi4Rvs8w3xsQOFLDIYD5Q6OB8oFeOeAZfEyajBr/iS5ub3TxbO1qZ/wB5bPC6qQeoaJ0JCMcEDpXX6qzeF/ErBLoWMMOj3E12pAMkaW08G05H31/fMBjpk+9c8sPybddv69DCfLCn/d0+7+vwItJ8UeG1t7GKyZY3u4ft0hT7w83JAPpgbVHsK9TuvFGgzaRaya2xl2YBP91cV89eEbHQNW8IaXcRWk4lmWytZnYjbmKBWKqM5xjJbP4UzxJpvxC1i8lstDtA0cTbHdhwoOBkjtgHis3WV24HEq1oaRW2lj698P634QWNvEWkXp+Rf9Sp7DtjtXOfET47+LvGfhZ/CXg3TzEHJElwx4QADhR3kP8A3yo5PVVb5pe+T4YeDLu4YPNLJcCFHddsk0pHCRqevT6KBk8CqEcWvpZ6Zr+s6mftU15AsltbgLHDDI4jCbR94lnHPc9Bmuh4uSha++hm8QkuRRs+tjPj03xL4VkluNS81T13P8241y/ivxbf60YdIBISIjctfTXiiTVvFd/Dol5EkNvacS7iF2gD274/KuV1Dwn4W1Gzhn8LqGEcm+eU8Nhep56D09q5uSHLobVMLFRcI7Gn8MvFV14cvrawunMMNywSJhwN2On1OK9r+InjtpPsfgbRCY5rlgXkHBH418361q+n6neaLZaeh8uW6zC6jA+T5d34k4rq9Z0XVINat9f1O48tbXD8ddv+eKPrD9n7NPRFYRuMJqO2n3H1j4P8J674Q0r+2pYzJGFHJP6/hXpPhWbUtZtJL+UsMnlz/dFeLw+O7o+F/J+1GS3kXOQ3B4456VxXxA+NWr+CPDFr4X8Mwlprtcs46KDXr4bMo0eVdEdmMpUYQ5obH//W/NjRLHw5aaBc3viDxlb6xFpzANex6Q9vefudgh3yOFBmAXYJNjl8DrtrsvDfhzUdat2vfDvjC7vYIxEkw1KZb2GOOJfMXaUkSQAg/wDLROe43DNen6f4O11ovtl/JYSyKFfcsR06WQIvyv8AM0gkDEklNhcYRvk4rp9VgGnwi/0y8jsJIFCxSWq7YzJGfl/1CxpGT32ZAwDgFq/O7eR9xy6HI6Z4b0zS7aXX7SS2kaV1UYS4hSRsZixE9zOUUk4xyRjotYWp6JbaVanV7mbT76O3XzTKS7KjRPj92ciD5GDex6HZgmmeK9ee9lOhs0kkt1KZluYNysZbjasskvO3fIACJAgSMrkFRgDY1a+8VWLQ2OsSQabZXwNtJLejdLvA3KryBTtaSNwf3nIIKjjaKdg0Wh53ceK9JW1kntXitryWfynZh5itI5O99tqPMXYyhNpOQwAPykMeNi+KXgiGWTR7bVdO1WSKb7DJHFdpHdG4RY3KPG6xx5Iy2zPQHaeAK990pPB+jaPGZtQW1vH3i3nCxx+eyBH3ThraBFkdkIjQRDdx97aKxfCXhXwrp2qzXeqyta20Z3QnTIPNZrJiruvnH7olyuWiGxSenIBm6Sux2PN5fDejssV79kW3uJR5ckUijdkZLfOshR8nlQNyHbgY+8MHxB4esdalXQ/ENx/alvL91JREAfl3sVw4VpVUZBLBQMcHrXqXiP4T6FbjbrKFfJDvaqN8TKzAfOS4Rldm3RgRBcHdnHFZmqaHqMcMV14X12WXc0kdzOIR50eeGRImkmMpVDtx8igZAwCFqbCt5HlWoyaDr8t54V09b+107TVa3ng0yzaSFZBudgbkQyoCo2gR72+6cdCBwXifwd4P0STTH0JdQuWvgUt7Tykubx5o8k/u4ITKdsaybuAq4POOa9s+w6jokFpYWevfYrN3O2OGGeWaRllwi+VGGyFdiGCgKFyxKrkVJfJodxrckMPlyRu21TDFcQxLLGqbgr+e+RhGfHIYMSAANtUkS0tj8vPGGleJrfxdBJPez2+mXTB4NP8AsqiB1iYcRrCUK7WIyso27WGCea+mLP4IfGWPwIfHus2+j6dodvbHUTJPqUSyW9qI3ZvtMAiVgkYPmAQPI4woY4+WvsBtKsJPtE9xFDJ9t2+WrI58ryyyZCvh3+71RsLt+U/wVH8R9H8ZLpV58ONN06GAX+kpaSGBFZXtXTaQssLOGUqxIKBmDfexkFStUfuxil/XoEKENXNnwl8JtR02/wDDP/CRWv2q41DTWdGumiCJK05+/AArT/dUc7EO/ao3DNei3/gi4sG/4TjwxZ3EFxKIW+zXETQyGdpVkR4/NgEyTA7WxJtK8jrxXW6H4AvNBXVvC3hm4nn1yK3ksngtJ44ptLWXKvJmOQnz5IsiPaGe0hYsxWQqo5Pw58AJPBet6ZJeDbZmVbny7aS8ufOmjbzop8mILuR1DbpGkO7kMp4pypQls7Iz5LJKxZ8I+PPCMvi660PxZPAWvklk04W8kZurK72MzGASr5pRGBDQqSFj/wBWV2op2vCUfiq9vZJLG+vPDxZwv29URrOKHAKut2FWZsNndJMrKmeRkMB754sutR1zw7eXE89tc6pGZJSiT4kWQYCPOfLR9oxIfmL4P3iwzXGWfxh8OeHtOt4Dc21xcShVW6jWextwdy7f9c0pcFflbhAxwQg4rjcYQJTVN+89DnvEum+PtQQRarfXt1LDBHLPPqGpYiEjnkRsybpFReEZF8tu2O2Zoui376iNS8RafqF7BboPLeK6ZWUL1ykisD1+YSqAP4SADilrvxa8AX8ktmstncad5MaQQ311Ctx8pw8avtkRtvXCbWIzhQQa6Pw38R/C9n4ik0/QtQtHiISMF52NwZZCVLFI5A7ghyfn+cAE5wppOunHlUTF4yEnucZ5tlp2n3EIs59QguTCDD56PMi4LOkkYZirKAQZInbquBjkafgM6RrPnzfarzUZiH+0LKqTzRsT+68ldu4TMV27QBtQkttUZODfeLNLvYm16wuYfENza2YgLabEJfLuCCXkiZXjeRTxg7QH5LR7sZ8Zi+Ien2HjeC88SSvA0drKkcMED2VxHJ5254fLm8pc9UG52GMDOPlPLas9jGpXnTtJbfl9x79eza5rEd1qep6tLplteXPkBPtaQnbGnzQvPlsghdrjuAe4zUvhjXLCxX+w/Ddkn2Fo3El5KSWa8YIBxIwEfAwhZ8HgBQo+b5bPje18X+JIP+EksgbHTdIj1HyUbyLdYGcww+bKCrHMm4fKhZmK5GMmvdtJ8aaHrvh+e7u9I1BLa1Vo4J7WeK2IiyAyKHXGAcdlLdicCr/e8tpIMLiXUbk3ov67aHSeH7eJ7S48Ka79pmtTfIbyZked7crkGBTEqqodiGYMm75c8IprN8dav4d07Q9MbQdEtbi4tHeO48+VpriUuN0UbSTYMaqoJAXATIGM1554n8U/DdYdO/sOXxVqF/Zny/KMURtVlI2SOSkj+bhBw2zn36VpS2tr4FmWzeHUY3aO8awu9UWJfKmjiym1jGryqknzlJcZOHIJUColGV1Lb7zWrVfLeNlHyK+ll5fESarbxWUt3ZOsk0EcJlOV2lppnZ84PJGzABVenboj8NNAmuX1N9HlgjOFiaNzavJiI7RvlR2LElepBOcjJyB4+Ifh/wCKfEVxc6fHBazsizNPZweWnmzEdYovMQ/MWdwYjvLD7uRX1v8AB+/fwTaXM3h7VrTWbxEdpA+mTJaKzbonM1vMEVgpAb5AfmweACKtXjK9/wBCsLq7PU8wPwG0K/06WJJZ7eOa3GEnXzZdrMQWJKP5fQktyMZwMdPG9b+CPihS8WmpfSXMZCLLGhuAAikfIpClygUZLHHHC8CvsHUNc8deItSbZqGoan5wC27LO2y7MXygPJF5EIIH3V6ZfII5NV7zw3qmgXlpq1ywSaCMzNYz3EkVxFF/dkSCXjjjerEkDp8wrrjOa6nTKgpHyT4M8G/Gh7e50bQdM8yzuImW7vJjBapvABCyTMkm0LkHCKrNxwQK4zxd4K1bwhrUWtap4m04aMQpli1CKWSTzMKHaJwiyCZQAY3DMq88YwK+1tSgt9XnlbSFNrZFVaG5tLGNpSUIZFhjmmkEbDays06BijLtYcgfPupfC3xO+qLfC0tZYJHaOcPDJb3ZmJ83Dn7pzw+7LKANuM1K1ldpL5f1Y5MTheaKj2PF/CPiPw/pukr4aW+ZrOPzZYPJVbiFYZmPHlEqpc5PUjGSSMYFd8fBniXXrCx1zwUrarJOhNxerI7x2U0pRvIMMiAI8TDDzNIVjc4iGzJqxF8PtWuJ72bTYTZm2860F4UaJcudmVcKzD5c5Gzp0rqdK+GOp3txZW0uvyWdtaW4tP8ARbmO1gETDCZAlEcy5Jy0iqyD7o54ahTj719fM56OAhGNpK5yafCTxX4Ykvdcns7i5NyCrXELtHmNcEO5JaIFcj7zkscAjuMzQZNXN7cafp863dw1pdROwiF0C0qeYceVwqS7ULrkB+wBwa9s1KPRr28l8Rz2NitxpIhdIjBBdW+9Tt3fMxmLFV4eNvk2gj7wq34r+GieE9ItNH8V+HC0tluW2sr2+Xy4ZZIg0my1tmZQihMMWmTdGNoXkCseRN3vr8v6+RUcEk26exx3hnwjd38i32uabcQ2DWzu88gENvA6YTDLIhzhtiY2+ax+6SeBU8VWckHj1NS1m3CWN7FO43Q/Z7a5niVnVWjQqz4ySgdc7QOMCso/E3V4Rb+Hb3w/pWrJpl1JdW32eeXR4jbOh3SNZu0u9zuzlpmdB8yf3a9Q8NzeJvPTTrbR7aa/CtDNYzfZvMWQxYRpUN4D+8UKBKJASMhym0CpeEdN3/r/AIA3hFZKD/As6T4W+KF7rFv4S/Z8itLjVdqWd1E+231qSZwZGitUnliT7Osa7m8oi4Kj7h4NfTPwk8W+O/hleT+GZbW+0K2vRGlzB9hktbf7XH85l3EKS7qwLZfJAB6V86S6Dcalpd3L4zs7aPw9e3LN/Z8kFvqFuUtxhBc/vhbeY0oLbwrFRzkE16Lpnhr4c6l4O1Pw1o9/4Qe7Cfa5neSGPUAEESFZB5ke5RkRNJ5MqR5RdxAIFVFGpFJvbtse5l2Oq4V+5FX6XPunwT+0Z4NLp4f0Txlp95PbO/yS3Eds8Ur8sBEX8wnpwSBzX0Np/j7xhd6c0k1y4SQLjykEiN1IIYFxyDnjtX406z8ELnWxNoesebeW8kKo7GGB7e4Vz5YjGVMXTG3Dg4CjOBgcJpn7IPiiXxNYWnws09tFd5ZLe7g0uZ9KVliZFd96SJHHuwV3sQyIAwODgKOFobXt/XyPejxLXXx07/h+FmfvFaalaxPHFeSOfM7EgMQPXkEc8Vuf2xbXCGPzjGp5B28jcB2/nX4kav4g/aI8C6dDc/DfxfqNtaQLPi31V/7atHVGwhlFwk8+zafkZJU3gZ61yVr+37+1L4amePxN4X0PxRHvYwmCabSLvyhkLviYTrhwMrwnHVRV08vi17jX5f8AA/E6XxLS2mnH5X/LX8D9wfEV9YsWsIZmMxX5VQgliBxx/hXjcPwL8V+N9VA1RFt9OZmZ0ZgskuMceWCTg9ycccV8AeAf26PC3jLUtNn0q/NkNbs0nvI7U+feWiAfNZQiNcrMxzuYgMiKCvJUj6Yi/bj0Xwt4XmsvhdpV+mrLC0Ed/qMf2a1gEcTFS/murP6HZyxOMjtjWp1KfuRjb9Doo4/C1E6lSfurbzP0du9d8DfCH4ZSar4iuEtIrKH/AFcaDkAcIsaqXZiRhUUZPQCv52v2kfiBr3xJ+KJ+Lts1hFo7CO1s0ur9FBgjJMe5dyhGlLFhlhkYFeman8YNf8RLa6x8V9ah1PULSyJuLjT18/ZcyLslFuZI0XjlQq4O3I3nOR4t4n8S/DFtEsfCPi/Sr/8As+4dp/NmtbC0hHkx7MRLbu7R8P8A8tSN2T9RFGk+a8l5HiZxmiqw9nSdof1b5FK78L+M/CfhCzu9W8NfYbXXr13USXKzRy3ES7Im3wySwiJwWEcYYYIJPSvN9T8G67eK2v8Ahi4W31GzLTXOl3YzK7tgAokiqZVVgE+RTtPHSvbLHw14Rbw3Jp3hq7uTo9y0TWLX8QED2zDDGFhcbBOuXjOU4IVkypArrb+/8UaWtxrl54fsvE1jpKLqdtcXc7affRFgqbbPVDKtxbTsSqyJsmWUHDRHLbVGUue9rf1p/XQ+ZjVk/T8vuX6Fnwxa+EvDd74W8ZazZX2nyzELG+j2sckVzdRqWWSXDJsWRMgopEm5eBgFT6vNp3gPQ9RGs6Q8N1kW5gku93nPHdLtiSWI5CKysFaUMFV09TtHnuj6JpXifxFqni3w/fXUceoW8wuLfxHcQqDceUfLulk04+XE0coDGRLIDYXygaT5Mjxzr2v+D9bgtrBTqZtI55I9QnMMnm2SMjs1u3nyg9AcOeGHABxnCdOpKyexTr1vilHT+un9dj1S7tfCPwZjl8SatDBb+I7tf7OF20TC2tpJwUITOAQnKbiOSF24GTVLULCTw34V0K11V44tWuZp4EiU7nMMbbwUA43BSqnJ5zlSc18++PvEepP401WHXdUez0CTVprwK8E1224tvChbcu5eFSqrDGoAUbh3xxulePPCty2mXGl+LbPU9UsrplsbdUl0+6isYi75S3l5lDoWbawXyCuAG3CsauEqzTl0X6HHi6757xW22q+em78tD6hg8VeG/DujSy6xLcHTLR7w3ElspuZTDbCTagiA+fO2Ryu3kMp5+WvYvFmp+Bfgr4g1/wCG/iTw1Y61rqaPdW+uNqiRz2VlNqFvDcnSLG3dXiaOyQQm5nlDvLctIkflIm0fJfwBv9NXx3q/xU8VCNdE0AQ30MbM1rDeTxbGs7ZeV/11wkZfIYGNJNy8ivHdUs/F+l2L3viS72a9q0F5qE84kWWFrm+DtJcOqAjYxd3kSNtxkYZdaIUbRt9rS3l/WxySq1vZRtHf8lp/w3ofUWjeIdCsvBOiT+F55LeznKPJLdxm4kN15UYCYU7VbavmZ/hXbnG6vY9A8USeJt3h3wOwgsmZ3FxN8p+9s3EbdzyMw2qv8T/KPb5U8N+AfE3h3RtJ0HV7tYdE2NHbRwr51/KoiZBLEvy4ld8ksQq9V+YYI2l+J+seGPh7p/gbwxbvoZ+1eYbmOSCTUpBP+7a4kIYZmmUDyfl8qJMAjlRXBLLOad27JG1Hnpx/e+7FL8raLsvuOs8eXl1rsUba/JJFqNvO8MCvudba0jIMkrFfl82Vto77l5BCBcYniS9s49bgbRrhRpqX9lmZZAqHypYpJGUsV3OCD0+UHgEkV5n9gnsdX1BfEtvZ2D252WllcX0kiafbsNxhQRKZZpTt3PhtxIGcKFFdvpfiW5vWnvPDIhtYNHjE8i20JfeYzsOySYuewG1Pm7diKueCSd+mhwPm5pab/oesX/xI0W5vZ555U0zTIIvNEl0Ghd1PQkyBPv44xnjOKbZw23i6C7XSredvM/dskCNu2AZJCLk4C8kkBQCOa4nxPrvjLwyhu/HkECtFbyJYxRj7ZG8jbPMDlQzMyLIAzHABAVcAkj1/XNO8QWOk6j8Smt5gL+CCe4dnDi+kkQyup2yoVgxsii2LJkBflJzXGsIrnZCnWquTl06WtZHGPOt+2nfYbu2tDaPGihif3SxsWGMcEk4r062Ei2FzFdTnUpv9TtUHOW6Z69MdK+avC+seHNG8YxL4t0y5lubOVi0TsskSOcb5IxgCP5oiNgyCMdDXra+JrzxBommxX0UcNrez3LZiuUhkVEG9DkurHPzZQKrNgKDkVUqKi1Zam+CnCOu/S3b/ACPNv+Er8U2eo2nh6S6jjtFu0ja3jPJ3s67P9n5VJBP5V6X4o1ZE12bWvEUZhRSIIIh82COvT2IP5VHFY+Ej4Ei1mOcjT7iacxhMq9xdMVgMk7MN6pEA3zDhI+V7E83Z6hqWi6dqWg+ILm3vtZtL+5S32OHmxnDyHJwNzDK9SVIbvipr0HGPvF8jpJc793+v6R//2Q==", + "mimeType": "image/jpeg" + } + ] + }, + { + "id": null, + "role": "assistant", + "created": 1753704259, + "content": [ + { + "type": "text", + "text": "I apologize, but I don't see any image shared in our conversation. If you'd like me to analyze an image, you'll need to share it first. However, I notice that I don't currently have access to any image analysis tools in my available extensions. Let me search to see if there are any image-related extensions available." + }, + { + "type": "toolRequest", + "id": "toolu_014qhEwCaj8QWwz1s8xtMH7h", + "toolCall": { + "status": "success", + "value": { + "name": "platform__search_available_extensions", + "arguments": {} + } + } + } + ] + }, + { + "id": null, + "role": "user", + "created": 1753704259, + "content": [ + { + "type": "toolResponse", + "id": "toolu_014qhEwCaj8QWwz1s8xtMH7h", + "toolResult": { + "status": "success", + "value": [ + { + "type": "text", + "text": "Extensions available to enable:\n- Codesearch - Query https://codesearch.sqprod.co/ directly from goose\n- google_drive - google_drive\n- Image Generator - Generate images with OpenAI models\n- Linear - Integration to Linear project management tool\n- fetch - Web content fetching and processing capabilities\n- pdfreader - Read and understand large or complex PDFs\n- Data Discovery - Explore data assets, metadata, ownership and lineage\n- gosling - Gosling\n- memory - Memory\n- Web Search - Query the WWW\n- computercontroller - Computer Controller\n- Figma - Interact with Figma and Figjam files\n- Airtable - Interact with Airtable bases and tables\n- Notebook - Control Jupyter notebooks in real time\n- Databricks - Integration to query Databricks data\n- Glean - Search and read internal documents with Glean\n- jetbrains - Jetbrains\n- Regulator - Interact with Regulator\n- blockcell - Deploy static websites to the Blockcell hosting service\n- Blockdata - Querying and analyzing Block data\n- Looker - Explore and talk to data with Looker\n- Snowflake - Integration to query Snowflake data\n- tutorial - Tutorial\n- git - Git version control system integration\n- Gmail - Gmail integration for email management and access\n- QAI Index Search - Search QAI's index directly from goose\n- Google Drive - Google Drive integration for file management and access\n- googlecalendar - Interact with Google Calendar events\n\n\n\nExtensions available to disable:\n- weather_extension\n" + } + ] + } + } + ] + } + ], + "tools": [ + { + "name": "weather_extension__get_weather", + "description": "Get the weather for a location", + "inputSchema": { + "properties": { + "location": { + "description": "The city and state, e.g. San Francisco, CA", + "type": "string" + } + }, + "required": [ + "location" + ], + "type": "object" + } + }, + { + "name": "platform__search_available_extensions", + "description": "Searches for additional extensions available to help complete tasks.\n Use this tool when you're unable to find a specific feature or functionality you need to complete your task, or when standard approaches aren't working.\n These extensions might provide the exact tools needed to solve your problem.\n If you find a relevant one, consider using your tools to enable it.", + "inputSchema": { + "properties": {}, + "required": [], + "type": "object" + }, + "annotations": { + "title": "Discover extensions", + "readOnlyHint": true, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_extensions", + "description": "Tool to manage extensions and tools in goose context.\n Enable or disable extensions to help complete tasks.\n Enable or disable an extension by providing the extension name.\n ", + "inputSchema": { + "properties": { + "action": { + "description": "The action to perform", + "enum": [ + "enable", + "disable" + ], + "type": "string" + }, + "extension_name": { + "description": "The name of the extension to enable", + "type": "string" + } + }, + "required": [ + "action", + "extension_name" + ], + "type": "object" + }, + "annotations": { + "title": "Enable or disable an extension", + "readOnlyHint": false, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_schedule", + "description": "Manage scheduled recipe execution for this Goose instance.\n\nActions:\n- \"list\": List all scheduled jobs\n- \"create\": Create a new scheduled job from a recipe file\n- \"run_now\": Execute a scheduled job immediately \n- \"pause\": Pause a scheduled job\n- \"unpause\": Resume a paused job\n- \"delete\": Remove a scheduled job\n- \"kill\": Terminate a currently running job\n- \"inspect\": Get details about a running job\n- \"sessions\": List execution history for a job\n- \"session_content\": Get the full content (messages) of a specific session\n", + "inputSchema": { + "properties": { + "action": { + "enum": [ + "list", + "create", + "run_now", + "pause", + "unpause", + "delete", + "kill", + "inspect", + "sessions", + "session_content" + ], + "type": "string" + }, + "cron_expression": { + "description": "A cron expression for create action. Supports both 5-field (minute hour day month weekday) and 6-field (second minute hour day month weekday) formats. 5-field expressions are automatically converted to 6-field by prepending '0' for seconds.", + "type": "string" + }, + "execution_mode": { + "default": "background", + "description": "Execution mode for create action: 'foreground' or 'background'", + "enum": [ + "foreground", + "background" + ], + "type": "string" + }, + "job_id": { + "description": "Job identifier for operations on existing jobs", + "type": "string" + }, + "limit": { + "default": 50, + "description": "Limit for sessions list", + "type": "integer" + }, + "recipe_path": { + "description": "Path to recipe file for create action", + "type": "string" + }, + "session_id": { + "description": "Session identifier for session_content action", + "type": "string" + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "annotations": { + "title": "Manage scheduled recipes", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "dynamic_task__create_task", + "description": "Use this tool to create one or more dynamic tasks from a shared text instruction and varying parameters.How it works:\n - Provide a single text instruction\n - Use the 'task_parameters' field to pass an array of parameter sets\n - Each resulting task will use the same instruction with different parameter values\n This is useful when performing the same operation across many inputs (e.g., getting weather for multiple cities, searching multiple slack channels, iterating through various linear tickets, etc).\n Once created, these tasks should be passed to the 'subagent__execute_task' tool for execution. Tasks can run sequentially or in parallel.\n ---\n What is a 'subagent'?\n A 'subagent' is a stateless sub-process that executes a single task independently. Use subagents when:\n - You want to parallelize similar work across different inputs\n - You are not sure your search or operation will succeed on the first try\n Each subagent receives a task with a defined payload and returns a result, which is not visible to the user unless explicitly summarized by the system.\n ---\n Examples of 'task_parameters' for a single task:\n text_instruction: Search for the config file in the root directory.\n Examples of 'task_parameters' for multiple tasks:\n text_instruction: Get weather for Melbourne.\n text_instruction: Get weather for Los Angeles.\n text_instruction: Get weather for San Francisco.\n ", + "inputSchema": { + "properties": { + "task_parameters": { + "description": "Array of parameter sets for creating tasks. For a single task, provide an array with one element. For multiple tasks, provide an array with multiple elements, each with different parameter values. If there is no parameter set, provide an empty array.", + "items": { + "properties": { + "text_instruction": { + "description": "The text instruction to execute", + "type": "string" + } + }, + "required": [ + "text_instruction" + ], + "type": "object" + }, + "type": "array" + } + }, + "type": "object" + }, + "annotations": { + "title": "Dynamic Task Creation", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + }, + { + "name": "subagent__execute_task", + "description": "Only use the subagent__execute_task tool when you execute sub recipe task or dynamic task.\n EXECUTION STRATEGY DECISION:\n 1. If the tasks are created with execution_mode, use the execution_mode.\n 2. Execute tasks sequentially unless user explicitly requests parallel execution. PARALLEL: User uses keywords like 'parallel', 'simultaneously', 'at the same time', 'concurrently'\n\n IMPLEMENTATION:\n - Sequential execution: Call this tool multiple times, passing exactly ONE task per call\n - Parallel execution: Call this tool once, passing an ARRAY of all tasks\n\n EXAMPLES:\n User Intent Based:\n - User: 'get weather and tell me a joke' → Sequential (2 separate tool calls, 1 task each)\n - User: 'get weather and joke in parallel' → Parallel (1 tool call with array of 2 tasks)\n - User: 'run these simultaneously' → Parallel (1 tool call with task array)\n - User: 'do task A then task B' → Sequential (2 separate tool calls)", + "inputSchema": { + "properties": { + "execution_mode": { + "default": "sequential", + "description": "Execution strategy for multiple tasks. Use 'sequential' (default) unless user explicitly requests parallel execution with words like 'parallel', 'simultaneously', 'at the same time', or 'concurrently'.", + "enum": [ + "sequential", + "parallel" + ], + "type": "string" + }, + "task_ids": { + "items": { + "description": "Unique identifier for the task", + "type": "string" + }, + "type": "array" + } + }, + "required": [ + "task_ids" + ], + "type": "object" + }, + "annotations": { + "title": "Run tasks in parallel", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + } + ] + }, + "output": { + "message": { + "id": null, + "role": "assistant", + "created": 1753704262, + "content": [ + { + "type": "text", + "text": "It looks like there isn't currently an image analysis extension available. If you'd like to share an image, you'll need to share it in a way that I can access it, and we may need to enable an appropriate extension for image analysis. For now, I can help you with other tasks using the currently available tools and extensions. Is there something specific you'd like assistance with?" + } + ] + }, + "usage": { + "model": "claude-3-5-sonnet-20241022", + "usage": { + "input_tokens": 3053, + "output_tokens": 82, + "total_tokens": 3135 + } + } + } + } +} \ No newline at end of file diff --git a/crates/goose-cli/src/scenario_tests/recordings/anthropic/weather_tool.json b/crates/goose-cli/src/scenario_tests/recordings/anthropic/weather_tool.json new file mode 100644 index 000000000000..fd377d11d966 --- /dev/null +++ b/crates/goose-cli/src/scenario_tests/recordings/anthropic/weather_tool.json @@ -0,0 +1,531 @@ +{ + "1bc400a528c54b25f4f1f609481e98e44222b3deaf7eee2c9e640e6345c73861": { + "input": { + "system": "You are a general-purpose AI agent called Goose, created by Block, the parent company of Square, CashApp, and Tidal. Goose is being developed as an open-source software project.\n\nThe current date is 2025-07-28 12:04:16.\n\nGoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o, claude-3.5-sonnet, o1, llama-3.2, deepseek-r1, etc).\nThese models have varying knowledge cut-off dates depending on when they were trained, but typically it's between 5-10 months prior to the current date.\n\n# Extensions\n\nExtensions allow other applications to provide context to Goose. Extensions connect Goose to different data sources and tools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level problems using the tools in these extensions, and can interact with multiple at once.\nUse the search_available_extensions tool to find additional extensions to enable to help with your task. To enable extensions, use the enable_extension tool and provide the extension_name. You should only enable extensions found from the search_available_extensions tool.\n\n\nBecause you dynamically load extensions, your conversation history may refer\nto interactions with extensions that are not currently active. The currently\nactive extensions are below. Each of these extensions provides tools that are\nin your tool specification.\n\n\n## weather_extension\n\n\n\n\n\n\n\n# Suggestion\n\"\"\n\n\n\n\n# Response Guidelines\n\n- Use Markdown formatting for all responses.\n- Follow best practices for Markdown, including:\n - Using headers for organization.\n - Bullet points for lists.\n - Links formatted correctly, either as linked text (e.g., [this is linked text](https://example.com)) or automatic links using angle brackets (e.g., ).\n- For code examples, use fenced code blocks by placing triple backticks (` ``` `) before and after the code. Include the language identifier after the opening backticks (e.g., ` ```python `) to enable syntax highlighting.\n- Ensure clarity, conciseness, and proper formatting to enhance readability and usability.\n\n# Additional Instructions:\n\nRight now you are *NOT* in the chat only mode and have access to tool use and system.", + "messages": [ + { + "id": null, + "role": "user", + "created": 1753704256, + "content": [ + { + "type": "text", + "text": "tell me what the weather is in Berlin, Germany" + } + ] + } + ], + "tools": [ + { + "name": "weather_extension__get_weather", + "description": "Get the weather for a location", + "inputSchema": { + "properties": { + "location": { + "description": "The city and state, e.g. San Francisco, CA", + "type": "string" + } + }, + "required": [ + "location" + ], + "type": "object" + } + }, + { + "name": "platform__search_available_extensions", + "description": "Searches for additional extensions available to help complete tasks.\n Use this tool when you're unable to find a specific feature or functionality you need to complete your task, or when standard approaches aren't working.\n These extensions might provide the exact tools needed to solve your problem.\n If you find a relevant one, consider using your tools to enable it.", + "inputSchema": { + "properties": {}, + "required": [], + "type": "object" + }, + "annotations": { + "title": "Discover extensions", + "readOnlyHint": true, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_extensions", + "description": "Tool to manage extensions and tools in goose context.\n Enable or disable extensions to help complete tasks.\n Enable or disable an extension by providing the extension name.\n ", + "inputSchema": { + "properties": { + "action": { + "description": "The action to perform", + "enum": [ + "enable", + "disable" + ], + "type": "string" + }, + "extension_name": { + "description": "The name of the extension to enable", + "type": "string" + } + }, + "required": [ + "action", + "extension_name" + ], + "type": "object" + }, + "annotations": { + "title": "Enable or disable an extension", + "readOnlyHint": false, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_schedule", + "description": "Manage scheduled recipe execution for this Goose instance.\n\nActions:\n- \"list\": List all scheduled jobs\n- \"create\": Create a new scheduled job from a recipe file\n- \"run_now\": Execute a scheduled job immediately \n- \"pause\": Pause a scheduled job\n- \"unpause\": Resume a paused job\n- \"delete\": Remove a scheduled job\n- \"kill\": Terminate a currently running job\n- \"inspect\": Get details about a running job\n- \"sessions\": List execution history for a job\n- \"session_content\": Get the full content (messages) of a specific session\n", + "inputSchema": { + "properties": { + "action": { + "enum": [ + "list", + "create", + "run_now", + "pause", + "unpause", + "delete", + "kill", + "inspect", + "sessions", + "session_content" + ], + "type": "string" + }, + "cron_expression": { + "description": "A cron expression for create action. Supports both 5-field (minute hour day month weekday) and 6-field (second minute hour day month weekday) formats. 5-field expressions are automatically converted to 6-field by prepending '0' for seconds.", + "type": "string" + }, + "execution_mode": { + "default": "background", + "description": "Execution mode for create action: 'foreground' or 'background'", + "enum": [ + "foreground", + "background" + ], + "type": "string" + }, + "job_id": { + "description": "Job identifier for operations on existing jobs", + "type": "string" + }, + "limit": { + "default": 50, + "description": "Limit for sessions list", + "type": "integer" + }, + "recipe_path": { + "description": "Path to recipe file for create action", + "type": "string" + }, + "session_id": { + "description": "Session identifier for session_content action", + "type": "string" + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "annotations": { + "title": "Manage scheduled recipes", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "dynamic_task__create_task", + "description": "Use this tool to create one or more dynamic tasks from a shared text instruction and varying parameters.How it works:\n - Provide a single text instruction\n - Use the 'task_parameters' field to pass an array of parameter sets\n - Each resulting task will use the same instruction with different parameter values\n This is useful when performing the same operation across many inputs (e.g., getting weather for multiple cities, searching multiple slack channels, iterating through various linear tickets, etc).\n Once created, these tasks should be passed to the 'subagent__execute_task' tool for execution. Tasks can run sequentially or in parallel.\n ---\n What is a 'subagent'?\n A 'subagent' is a stateless sub-process that executes a single task independently. Use subagents when:\n - You want to parallelize similar work across different inputs\n - You are not sure your search or operation will succeed on the first try\n Each subagent receives a task with a defined payload and returns a result, which is not visible to the user unless explicitly summarized by the system.\n ---\n Examples of 'task_parameters' for a single task:\n text_instruction: Search for the config file in the root directory.\n Examples of 'task_parameters' for multiple tasks:\n text_instruction: Get weather for Melbourne.\n text_instruction: Get weather for Los Angeles.\n text_instruction: Get weather for San Francisco.\n ", + "inputSchema": { + "properties": { + "task_parameters": { + "description": "Array of parameter sets for creating tasks. For a single task, provide an array with one element. For multiple tasks, provide an array with multiple elements, each with different parameter values. If there is no parameter set, provide an empty array.", + "items": { + "properties": { + "text_instruction": { + "description": "The text instruction to execute", + "type": "string" + } + }, + "required": [ + "text_instruction" + ], + "type": "object" + }, + "type": "array" + } + }, + "type": "object" + }, + "annotations": { + "title": "Dynamic Task Creation", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + }, + { + "name": "subagent__execute_task", + "description": "Only use the subagent__execute_task tool when you execute sub recipe task or dynamic task.\n EXECUTION STRATEGY DECISION:\n 1. If the tasks are created with execution_mode, use the execution_mode.\n 2. Execute tasks sequentially unless user explicitly requests parallel execution. PARALLEL: User uses keywords like 'parallel', 'simultaneously', 'at the same time', 'concurrently'\n\n IMPLEMENTATION:\n - Sequential execution: Call this tool multiple times, passing exactly ONE task per call\n - Parallel execution: Call this tool once, passing an ARRAY of all tasks\n\n EXAMPLES:\n User Intent Based:\n - User: 'get weather and tell me a joke' → Sequential (2 separate tool calls, 1 task each)\n - User: 'get weather and joke in parallel' → Parallel (1 tool call with array of 2 tasks)\n - User: 'run these simultaneously' → Parallel (1 tool call with task array)\n - User: 'do task A then task B' → Sequential (2 separate tool calls)", + "inputSchema": { + "properties": { + "execution_mode": { + "default": "sequential", + "description": "Execution strategy for multiple tasks. Use 'sequential' (default) unless user explicitly requests parallel execution with words like 'parallel', 'simultaneously', 'at the same time', or 'concurrently'.", + "enum": [ + "sequential", + "parallel" + ], + "type": "string" + }, + "task_ids": { + "items": { + "description": "Unique identifier for the task", + "type": "string" + }, + "type": "array" + } + }, + "required": [ + "task_ids" + ], + "type": "object" + }, + "annotations": { + "title": "Run tasks in parallel", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + } + ] + }, + "output": { + "message": { + "id": null, + "role": "assistant", + "created": 1753704259, + "content": [ + { + "type": "text", + "text": "I'll help you check the weather in Berlin, Germany using the weather extension." + }, + { + "type": "toolRequest", + "id": "toolu_01ABW2NhcBGvKL6nBj3T3fhv", + "toolCall": { + "status": "success", + "value": { + "name": "weather_extension__get_weather", + "arguments": { + "location": "Berlin, Germany" + } + } + } + } + ] + }, + "usage": { + "model": "claude-3-5-sonnet-20241022", + "usage": { + "input_tokens": 2562, + "output_tokens": 76, + "total_tokens": 2638 + } + } + } + }, + "d51c15f1ede58b5496bba746a4bdffd8ce84526749ce0021969d6ed6f2538a6d": { + "input": { + "system": "You are a general-purpose AI agent called Goose, created by Block, the parent company of Square, CashApp, and Tidal. Goose is being developed as an open-source software project.\n\nThe current date is 2025-07-28 12:04:16.\n\nGoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o, claude-3.5-sonnet, o1, llama-3.2, deepseek-r1, etc).\nThese models have varying knowledge cut-off dates depending on when they were trained, but typically it's between 5-10 months prior to the current date.\n\n# Extensions\n\nExtensions allow other applications to provide context to Goose. Extensions connect Goose to different data sources and tools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level problems using the tools in these extensions, and can interact with multiple at once.\nUse the search_available_extensions tool to find additional extensions to enable to help with your task. To enable extensions, use the enable_extension tool and provide the extension_name. You should only enable extensions found from the search_available_extensions tool.\n\n\nBecause you dynamically load extensions, your conversation history may refer\nto interactions with extensions that are not currently active. The currently\nactive extensions are below. Each of these extensions provides tools that are\nin your tool specification.\n\n\n## weather_extension\n\n\n\n\n\n\n\n# Suggestion\n\"\"\n\n\n\n\n# Response Guidelines\n\n- Use Markdown formatting for all responses.\n- Follow best practices for Markdown, including:\n - Using headers for organization.\n - Bullet points for lists.\n - Links formatted correctly, either as linked text (e.g., [this is linked text](https://example.com)) or automatic links using angle brackets (e.g., ).\n- For code examples, use fenced code blocks by placing triple backticks (` ``` `) before and after the code. Include the language identifier after the opening backticks (e.g., ` ```python `) to enable syntax highlighting.\n- Ensure clarity, conciseness, and proper formatting to enhance readability and usability.\n\n# Additional Instructions:\n\nRight now you are *NOT* in the chat only mode and have access to tool use and system.", + "messages": [ + { + "id": null, + "role": "user", + "created": 1753704256, + "content": [ + { + "type": "text", + "text": "tell me what the weather is in Berlin, Germany" + } + ] + }, + { + "id": null, + "role": "assistant", + "created": 1753704259, + "content": [ + { + "type": "text", + "text": "I'll help you check the weather in Berlin, Germany using the weather extension." + }, + { + "type": "toolRequest", + "id": "toolu_01ABW2NhcBGvKL6nBj3T3fhv", + "toolCall": { + "status": "success", + "value": { + "name": "weather_extension__get_weather", + "arguments": { + "location": "Berlin, Germany" + } + } + } + } + ] + }, + { + "id": null, + "role": "user", + "created": 1753704259, + "content": [ + { + "type": "toolResponse", + "id": "toolu_01ABW2NhcBGvKL6nBj3T3fhv", + "toolResult": { + "status": "success", + "value": [ + { + "type": "text", + "text": "The weather in Berlin, Germany is cloudy and 18°C" + } + ] + } + } + ] + } + ], + "tools": [ + { + "name": "weather_extension__get_weather", + "description": "Get the weather for a location", + "inputSchema": { + "properties": { + "location": { + "description": "The city and state, e.g. San Francisco, CA", + "type": "string" + } + }, + "required": [ + "location" + ], + "type": "object" + } + }, + { + "name": "platform__search_available_extensions", + "description": "Searches for additional extensions available to help complete tasks.\n Use this tool when you're unable to find a specific feature or functionality you need to complete your task, or when standard approaches aren't working.\n These extensions might provide the exact tools needed to solve your problem.\n If you find a relevant one, consider using your tools to enable it.", + "inputSchema": { + "properties": {}, + "required": [], + "type": "object" + }, + "annotations": { + "title": "Discover extensions", + "readOnlyHint": true, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_extensions", + "description": "Tool to manage extensions and tools in goose context.\n Enable or disable extensions to help complete tasks.\n Enable or disable an extension by providing the extension name.\n ", + "inputSchema": { + "properties": { + "action": { + "description": "The action to perform", + "enum": [ + "enable", + "disable" + ], + "type": "string" + }, + "extension_name": { + "description": "The name of the extension to enable", + "type": "string" + } + }, + "required": [ + "action", + "extension_name" + ], + "type": "object" + }, + "annotations": { + "title": "Enable or disable an extension", + "readOnlyHint": false, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_schedule", + "description": "Manage scheduled recipe execution for this Goose instance.\n\nActions:\n- \"list\": List all scheduled jobs\n- \"create\": Create a new scheduled job from a recipe file\n- \"run_now\": Execute a scheduled job immediately \n- \"pause\": Pause a scheduled job\n- \"unpause\": Resume a paused job\n- \"delete\": Remove a scheduled job\n- \"kill\": Terminate a currently running job\n- \"inspect\": Get details about a running job\n- \"sessions\": List execution history for a job\n- \"session_content\": Get the full content (messages) of a specific session\n", + "inputSchema": { + "properties": { + "action": { + "enum": [ + "list", + "create", + "run_now", + "pause", + "unpause", + "delete", + "kill", + "inspect", + "sessions", + "session_content" + ], + "type": "string" + }, + "cron_expression": { + "description": "A cron expression for create action. Supports both 5-field (minute hour day month weekday) and 6-field (second minute hour day month weekday) formats. 5-field expressions are automatically converted to 6-field by prepending '0' for seconds.", + "type": "string" + }, + "execution_mode": { + "default": "background", + "description": "Execution mode for create action: 'foreground' or 'background'", + "enum": [ + "foreground", + "background" + ], + "type": "string" + }, + "job_id": { + "description": "Job identifier for operations on existing jobs", + "type": "string" + }, + "limit": { + "default": 50, + "description": "Limit for sessions list", + "type": "integer" + }, + "recipe_path": { + "description": "Path to recipe file for create action", + "type": "string" + }, + "session_id": { + "description": "Session identifier for session_content action", + "type": "string" + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "annotations": { + "title": "Manage scheduled recipes", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "dynamic_task__create_task", + "description": "Use this tool to create one or more dynamic tasks from a shared text instruction and varying parameters.How it works:\n - Provide a single text instruction\n - Use the 'task_parameters' field to pass an array of parameter sets\n - Each resulting task will use the same instruction with different parameter values\n This is useful when performing the same operation across many inputs (e.g., getting weather for multiple cities, searching multiple slack channels, iterating through various linear tickets, etc).\n Once created, these tasks should be passed to the 'subagent__execute_task' tool for execution. Tasks can run sequentially or in parallel.\n ---\n What is a 'subagent'?\n A 'subagent' is a stateless sub-process that executes a single task independently. Use subagents when:\n - You want to parallelize similar work across different inputs\n - You are not sure your search or operation will succeed on the first try\n Each subagent receives a task with a defined payload and returns a result, which is not visible to the user unless explicitly summarized by the system.\n ---\n Examples of 'task_parameters' for a single task:\n text_instruction: Search for the config file in the root directory.\n Examples of 'task_parameters' for multiple tasks:\n text_instruction: Get weather for Melbourne.\n text_instruction: Get weather for Los Angeles.\n text_instruction: Get weather for San Francisco.\n ", + "inputSchema": { + "properties": { + "task_parameters": { + "description": "Array of parameter sets for creating tasks. For a single task, provide an array with one element. For multiple tasks, provide an array with multiple elements, each with different parameter values. If there is no parameter set, provide an empty array.", + "items": { + "properties": { + "text_instruction": { + "description": "The text instruction to execute", + "type": "string" + } + }, + "required": [ + "text_instruction" + ], + "type": "object" + }, + "type": "array" + } + }, + "type": "object" + }, + "annotations": { + "title": "Dynamic Task Creation", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + }, + { + "name": "subagent__execute_task", + "description": "Only use the subagent__execute_task tool when you execute sub recipe task or dynamic task.\n EXECUTION STRATEGY DECISION:\n 1. If the tasks are created with execution_mode, use the execution_mode.\n 2. Execute tasks sequentially unless user explicitly requests parallel execution. PARALLEL: User uses keywords like 'parallel', 'simultaneously', 'at the same time', 'concurrently'\n\n IMPLEMENTATION:\n - Sequential execution: Call this tool multiple times, passing exactly ONE task per call\n - Parallel execution: Call this tool once, passing an ARRAY of all tasks\n\n EXAMPLES:\n User Intent Based:\n - User: 'get weather and tell me a joke' → Sequential (2 separate tool calls, 1 task each)\n - User: 'get weather and joke in parallel' → Parallel (1 tool call with array of 2 tasks)\n - User: 'run these simultaneously' → Parallel (1 tool call with task array)\n - User: 'do task A then task B' → Sequential (2 separate tool calls)", + "inputSchema": { + "properties": { + "execution_mode": { + "default": "sequential", + "description": "Execution strategy for multiple tasks. Use 'sequential' (default) unless user explicitly requests parallel execution with words like 'parallel', 'simultaneously', 'at the same time', or 'concurrently'.", + "enum": [ + "sequential", + "parallel" + ], + "type": "string" + }, + "task_ids": { + "items": { + "description": "Unique identifier for the task", + "type": "string" + }, + "type": "array" + } + }, + "required": [ + "task_ids" + ], + "type": "object" + }, + "annotations": { + "title": "Run tasks in parallel", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + } + ] + }, + "output": { + "message": { + "id": null, + "role": "assistant", + "created": 1753704261, + "content": [ + { + "type": "text", + "text": "The current weather in Berlin, Germany is cloudy with a temperature of 18°C (64.4°F)." + } + ] + }, + "usage": { + "model": "claude-3-5-sonnet-20241022", + "usage": { + "input_tokens": 2663, + "output_tokens": 29, + "total_tokens": 2692 + } + } + } + } +} \ No newline at end of file diff --git a/crates/goose-cli/src/scenario_tests/recordings/anthropic/what_is_your_name.json b/crates/goose-cli/src/scenario_tests/recordings/anthropic/what_is_your_name.json new file mode 100644 index 000000000000..e9cc4e74868c --- /dev/null +++ b/crates/goose-cli/src/scenario_tests/recordings/anthropic/what_is_your_name.json @@ -0,0 +1,238 @@ +{ + "1b998117eba523901ae6a4dbf8caa81a95ea88ef7a84d0434c9b41a26164a2b9": { + "input": { + "system": "You are a general-purpose AI agent called Goose, created by Block, the parent company of Square, CashApp, and Tidal. Goose is being developed as an open-source software project.\n\nThe current date is 2025-07-28 12:04:16.\n\nGoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o, claude-3.5-sonnet, o1, llama-3.2, deepseek-r1, etc).\nThese models have varying knowledge cut-off dates depending on when they were trained, but typically it's between 5-10 months prior to the current date.\n\n# Extensions\n\nExtensions allow other applications to provide context to Goose. Extensions connect Goose to different data sources and tools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level problems using the tools in these extensions, and can interact with multiple at once.\nUse the search_available_extensions tool to find additional extensions to enable to help with your task. To enable extensions, use the enable_extension tool and provide the extension_name. You should only enable extensions found from the search_available_extensions tool.\n\n\nBecause you dynamically load extensions, your conversation history may refer\nto interactions with extensions that are not currently active. The currently\nactive extensions are below. Each of these extensions provides tools that are\nin your tool specification.\n\n\n## weather_extension\n\n\n\n\n\n\n\n# Suggestion\n\"\"\n\n\n\n\n# Response Guidelines\n\n- Use Markdown formatting for all responses.\n- Follow best practices for Markdown, including:\n - Using headers for organization.\n - Bullet points for lists.\n - Links formatted correctly, either as linked text (e.g., [this is linked text](https://example.com)) or automatic links using angle brackets (e.g., ).\n- For code examples, use fenced code blocks by placing triple backticks (` ``` `) before and after the code. Include the language identifier after the opening backticks (e.g., ` ```python `) to enable syntax highlighting.\n- Ensure clarity, conciseness, and proper formatting to enhance readability and usability.\n\n# Additional Instructions:\n\nRight now you are *NOT* in the chat only mode and have access to tool use and system.", + "messages": [ + { + "id": null, + "role": "user", + "created": 1753704256, + "content": [ + { + "type": "text", + "text": "what is your name" + } + ] + } + ], + "tools": [ + { + "name": "weather_extension__get_weather", + "description": "Get the weather for a location", + "inputSchema": { + "properties": { + "location": { + "description": "The city and state, e.g. San Francisco, CA", + "type": "string" + } + }, + "required": [ + "location" + ], + "type": "object" + } + }, + { + "name": "platform__search_available_extensions", + "description": "Searches for additional extensions available to help complete tasks.\n Use this tool when you're unable to find a specific feature or functionality you need to complete your task, or when standard approaches aren't working.\n These extensions might provide the exact tools needed to solve your problem.\n If you find a relevant one, consider using your tools to enable it.", + "inputSchema": { + "properties": {}, + "required": [], + "type": "object" + }, + "annotations": { + "title": "Discover extensions", + "readOnlyHint": true, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_extensions", + "description": "Tool to manage extensions and tools in goose context.\n Enable or disable extensions to help complete tasks.\n Enable or disable an extension by providing the extension name.\n ", + "inputSchema": { + "properties": { + "action": { + "description": "The action to perform", + "enum": [ + "enable", + "disable" + ], + "type": "string" + }, + "extension_name": { + "description": "The name of the extension to enable", + "type": "string" + } + }, + "required": [ + "action", + "extension_name" + ], + "type": "object" + }, + "annotations": { + "title": "Enable or disable an extension", + "readOnlyHint": false, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_schedule", + "description": "Manage scheduled recipe execution for this Goose instance.\n\nActions:\n- \"list\": List all scheduled jobs\n- \"create\": Create a new scheduled job from a recipe file\n- \"run_now\": Execute a scheduled job immediately \n- \"pause\": Pause a scheduled job\n- \"unpause\": Resume a paused job\n- \"delete\": Remove a scheduled job\n- \"kill\": Terminate a currently running job\n- \"inspect\": Get details about a running job\n- \"sessions\": List execution history for a job\n- \"session_content\": Get the full content (messages) of a specific session\n", + "inputSchema": { + "properties": { + "action": { + "enum": [ + "list", + "create", + "run_now", + "pause", + "unpause", + "delete", + "kill", + "inspect", + "sessions", + "session_content" + ], + "type": "string" + }, + "cron_expression": { + "description": "A cron expression for create action. Supports both 5-field (minute hour day month weekday) and 6-field (second minute hour day month weekday) formats. 5-field expressions are automatically converted to 6-field by prepending '0' for seconds.", + "type": "string" + }, + "execution_mode": { + "default": "background", + "description": "Execution mode for create action: 'foreground' or 'background'", + "enum": [ + "foreground", + "background" + ], + "type": "string" + }, + "job_id": { + "description": "Job identifier for operations on existing jobs", + "type": "string" + }, + "limit": { + "default": 50, + "description": "Limit for sessions list", + "type": "integer" + }, + "recipe_path": { + "description": "Path to recipe file for create action", + "type": "string" + }, + "session_id": { + "description": "Session identifier for session_content action", + "type": "string" + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "annotations": { + "title": "Manage scheduled recipes", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "dynamic_task__create_task", + "description": "Use this tool to create one or more dynamic tasks from a shared text instruction and varying parameters.How it works:\n - Provide a single text instruction\n - Use the 'task_parameters' field to pass an array of parameter sets\n - Each resulting task will use the same instruction with different parameter values\n This is useful when performing the same operation across many inputs (e.g., getting weather for multiple cities, searching multiple slack channels, iterating through various linear tickets, etc).\n Once created, these tasks should be passed to the 'subagent__execute_task' tool for execution. Tasks can run sequentially or in parallel.\n ---\n What is a 'subagent'?\n A 'subagent' is a stateless sub-process that executes a single task independently. Use subagents when:\n - You want to parallelize similar work across different inputs\n - You are not sure your search or operation will succeed on the first try\n Each subagent receives a task with a defined payload and returns a result, which is not visible to the user unless explicitly summarized by the system.\n ---\n Examples of 'task_parameters' for a single task:\n text_instruction: Search for the config file in the root directory.\n Examples of 'task_parameters' for multiple tasks:\n text_instruction: Get weather for Melbourne.\n text_instruction: Get weather for Los Angeles.\n text_instruction: Get weather for San Francisco.\n ", + "inputSchema": { + "properties": { + "task_parameters": { + "description": "Array of parameter sets for creating tasks. For a single task, provide an array with one element. For multiple tasks, provide an array with multiple elements, each with different parameter values. If there is no parameter set, provide an empty array.", + "items": { + "properties": { + "text_instruction": { + "description": "The text instruction to execute", + "type": "string" + } + }, + "required": [ + "text_instruction" + ], + "type": "object" + }, + "type": "array" + } + }, + "type": "object" + }, + "annotations": { + "title": "Dynamic Task Creation", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + }, + { + "name": "subagent__execute_task", + "description": "Only use the subagent__execute_task tool when you execute sub recipe task or dynamic task.\n EXECUTION STRATEGY DECISION:\n 1. If the tasks are created with execution_mode, use the execution_mode.\n 2. Execute tasks sequentially unless user explicitly requests parallel execution. PARALLEL: User uses keywords like 'parallel', 'simultaneously', 'at the same time', 'concurrently'\n\n IMPLEMENTATION:\n - Sequential execution: Call this tool multiple times, passing exactly ONE task per call\n - Parallel execution: Call this tool once, passing an ARRAY of all tasks\n\n EXAMPLES:\n User Intent Based:\n - User: 'get weather and tell me a joke' → Sequential (2 separate tool calls, 1 task each)\n - User: 'get weather and joke in parallel' → Parallel (1 tool call with array of 2 tasks)\n - User: 'run these simultaneously' → Parallel (1 tool call with task array)\n - User: 'do task A then task B' → Sequential (2 separate tool calls)", + "inputSchema": { + "properties": { + "execution_mode": { + "default": "sequential", + "description": "Execution strategy for multiple tasks. Use 'sequential' (default) unless user explicitly requests parallel execution with words like 'parallel', 'simultaneously', 'at the same time', or 'concurrently'.", + "enum": [ + "sequential", + "parallel" + ], + "type": "string" + }, + "task_ids": { + "items": { + "description": "Unique identifier for the task", + "type": "string" + }, + "type": "array" + } + }, + "required": [ + "task_ids" + ], + "type": "object" + }, + "annotations": { + "title": "Run tasks in parallel", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + } + ] + }, + "output": { + "message": { + "id": null, + "role": "assistant", + "created": 1753704259, + "content": [ + { + "type": "text", + "text": "I am Goose, an AI agent created by Block (the parent company of Square, CashApp, and Tidal). I'm being developed as an open-source software project.\n\nI can help you with various tasks using different tools and extensions. While I have a defined identity as Goose, I aim to be helpful, direct, and efficient in assisting you with your needs. Is there something specific I can help you with today?" + } + ] + }, + "usage": { + "model": "claude-3-5-sonnet-20241022", + "usage": { + "input_tokens": 2556, + "output_tokens": 97, + "total_tokens": 2653 + } + } + } + } +} \ No newline at end of file diff --git a/crates/goose-cli/src/scenario_tests/recordings/azure_openai/context_length_exceeded.json b/crates/goose-cli/src/scenario_tests/recordings/azure_openai/context_length_exceeded.json new file mode 100644 index 000000000000..9e26dfeeb6e6 --- /dev/null +++ b/crates/goose-cli/src/scenario_tests/recordings/azure_openai/context_length_exceeded.json @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/crates/goose-cli/src/scenario_tests/recordings/azure_openai/weather_tool.json b/crates/goose-cli/src/scenario_tests/recordings/azure_openai/weather_tool.json new file mode 100644 index 000000000000..841bcdae8ff2 --- /dev/null +++ b/crates/goose-cli/src/scenario_tests/recordings/azure_openai/weather_tool.json @@ -0,0 +1,523 @@ +{ + "21e33b98670d23e1bad3f21da667502d0930b42e34431395e266a4c524620cf1": { + "input": { + "system": "You are a general-purpose AI agent called Goose, created by Block, the parent company of Square, CashApp, and Tidal. Goose is being developed as an open-source software project.\n\nThe current date is 2025-07-28 12:05:28.\n\nGoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o, claude-3.5-sonnet, o1, llama-3.2, deepseek-r1, etc).\nThese models have varying knowledge cut-off dates depending on when they were trained, but typically it's between 5-10 months prior to the current date.\n\n# Extensions\n\nExtensions allow other applications to provide context to Goose. Extensions connect Goose to different data sources and tools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level problems using the tools in these extensions, and can interact with multiple at once.\nUse the search_available_extensions tool to find additional extensions to enable to help with your task. To enable extensions, use the enable_extension tool and provide the extension_name. You should only enable extensions found from the search_available_extensions tool.\n\n\nBecause you dynamically load extensions, your conversation history may refer\nto interactions with extensions that are not currently active. The currently\nactive extensions are below. Each of these extensions provides tools that are\nin your tool specification.\n\n\n## weather_extension\n\n\n\n\n\n\n\n# Suggestion\n\"\"\n\n\n\n\n# Response Guidelines\n\n- Use Markdown formatting for all responses.\n- Follow best practices for Markdown, including:\n - Using headers for organization.\n - Bullet points for lists.\n - Links formatted correctly, either as linked text (e.g., [this is linked text](https://example.com)) or automatic links using angle brackets (e.g., ).\n- For code examples, use fenced code blocks by placing triple backticks (` ``` `) before and after the code. Include the language identifier after the opening backticks (e.g., ` ```python `) to enable syntax highlighting.\n- Ensure clarity, conciseness, and proper formatting to enhance readability and usability.\n\n# Additional Instructions:\n\nRight now you are *NOT* in the chat only mode and have access to tool use and system.", + "messages": [ + { + "id": null, + "role": "user", + "created": 1753704328, + "content": [ + { + "type": "text", + "text": "tell me what the weather is in Berlin, Germany" + } + ] + }, + { + "id": null, + "role": "assistant", + "created": 1753704329, + "content": [ + { + "type": "toolRequest", + "id": "call_C91rmWZSSnUaKx0AtBdwO4Zw", + "toolCall": { + "status": "success", + "value": { + "name": "weather_extension__get_weather", + "arguments": { + "location": "Berlin, Germany" + } + } + } + } + ] + }, + { + "id": null, + "role": "user", + "created": 1753704329, + "content": [ + { + "type": "toolResponse", + "id": "call_C91rmWZSSnUaKx0AtBdwO4Zw", + "toolResult": { + "status": "success", + "value": [ + { + "type": "text", + "text": "The weather in Berlin, Germany is cloudy and 18°C" + } + ] + } + } + ] + } + ], + "tools": [ + { + "name": "weather_extension__get_weather", + "description": "Get the weather for a location", + "inputSchema": { + "properties": { + "location": { + "description": "The city and state, e.g. San Francisco, CA", + "type": "string" + } + }, + "required": [ + "location" + ], + "type": "object" + } + }, + { + "name": "platform__search_available_extensions", + "description": "Searches for additional extensions available to help complete tasks.\n Use this tool when you're unable to find a specific feature or functionality you need to complete your task, or when standard approaches aren't working.\n These extensions might provide the exact tools needed to solve your problem.\n If you find a relevant one, consider using your tools to enable it.", + "inputSchema": { + "properties": {}, + "required": [], + "type": "object" + }, + "annotations": { + "title": "Discover extensions", + "readOnlyHint": true, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_extensions", + "description": "Tool to manage extensions and tools in goose context.\n Enable or disable extensions to help complete tasks.\n Enable or disable an extension by providing the extension name.\n ", + "inputSchema": { + "properties": { + "action": { + "description": "The action to perform", + "enum": [ + "enable", + "disable" + ], + "type": "string" + }, + "extension_name": { + "description": "The name of the extension to enable", + "type": "string" + } + }, + "required": [ + "action", + "extension_name" + ], + "type": "object" + }, + "annotations": { + "title": "Enable or disable an extension", + "readOnlyHint": false, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_schedule", + "description": "Manage scheduled recipe execution for this Goose instance.\n\nActions:\n- \"list\": List all scheduled jobs\n- \"create\": Create a new scheduled job from a recipe file\n- \"run_now\": Execute a scheduled job immediately \n- \"pause\": Pause a scheduled job\n- \"unpause\": Resume a paused job\n- \"delete\": Remove a scheduled job\n- \"kill\": Terminate a currently running job\n- \"inspect\": Get details about a running job\n- \"sessions\": List execution history for a job\n- \"session_content\": Get the full content (messages) of a specific session\n", + "inputSchema": { + "properties": { + "action": { + "enum": [ + "list", + "create", + "run_now", + "pause", + "unpause", + "delete", + "kill", + "inspect", + "sessions", + "session_content" + ], + "type": "string" + }, + "cron_expression": { + "description": "A cron expression for create action. Supports both 5-field (minute hour day month weekday) and 6-field (second minute hour day month weekday) formats. 5-field expressions are automatically converted to 6-field by prepending '0' for seconds.", + "type": "string" + }, + "execution_mode": { + "default": "background", + "description": "Execution mode for create action: 'foreground' or 'background'", + "enum": [ + "foreground", + "background" + ], + "type": "string" + }, + "job_id": { + "description": "Job identifier for operations on existing jobs", + "type": "string" + }, + "limit": { + "default": 50, + "description": "Limit for sessions list", + "type": "integer" + }, + "recipe_path": { + "description": "Path to recipe file for create action", + "type": "string" + }, + "session_id": { + "description": "Session identifier for session_content action", + "type": "string" + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "annotations": { + "title": "Manage scheduled recipes", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "dynamic_task__create_task", + "description": "Use this tool to create one or more dynamic tasks from a shared text instruction and varying parameters.How it works:\n - Provide a single text instruction\n - Use the 'task_parameters' field to pass an array of parameter sets\n - Each resulting task will use the same instruction with different parameter values\n This is useful when performing the same operation across many inputs (e.g., getting weather for multiple cities, searching multiple slack channels, iterating through various linear tickets, etc).\n Once created, these tasks should be passed to the 'subagent__execute_task' tool for execution. Tasks can run sequentially or in parallel.\n ---\n What is a 'subagent'?\n A 'subagent' is a stateless sub-process that executes a single task independently. Use subagents when:\n - You want to parallelize similar work across different inputs\n - You are not sure your search or operation will succeed on the first try\n Each subagent receives a task with a defined payload and returns a result, which is not visible to the user unless explicitly summarized by the system.\n ---\n Examples of 'task_parameters' for a single task:\n text_instruction: Search for the config file in the root directory.\n Examples of 'task_parameters' for multiple tasks:\n text_instruction: Get weather for Melbourne.\n text_instruction: Get weather for Los Angeles.\n text_instruction: Get weather for San Francisco.\n ", + "inputSchema": { + "properties": { + "task_parameters": { + "description": "Array of parameter sets for creating tasks. For a single task, provide an array with one element. For multiple tasks, provide an array with multiple elements, each with different parameter values. If there is no parameter set, provide an empty array.", + "items": { + "properties": { + "text_instruction": { + "description": "The text instruction to execute", + "type": "string" + } + }, + "required": [ + "text_instruction" + ], + "type": "object" + }, + "type": "array" + } + }, + "type": "object" + }, + "annotations": { + "title": "Dynamic Task Creation", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + }, + { + "name": "subagent__execute_task", + "description": "Only use the subagent__execute_task tool when you execute sub recipe task or dynamic task.\n EXECUTION STRATEGY DECISION:\n 1. If the tasks are created with execution_mode, use the execution_mode.\n 2. Execute tasks sequentially unless user explicitly requests parallel execution. PARALLEL: User uses keywords like 'parallel', 'simultaneously', 'at the same time', 'concurrently'\n\n IMPLEMENTATION:\n - Sequential execution: Call this tool multiple times, passing exactly ONE task per call\n - Parallel execution: Call this tool once, passing an ARRAY of all tasks\n\n EXAMPLES:\n User Intent Based:\n - User: 'get weather and tell me a joke' → Sequential (2 separate tool calls, 1 task each)\n - User: 'get weather and joke in parallel' → Parallel (1 tool call with array of 2 tasks)\n - User: 'run these simultaneously' → Parallel (1 tool call with task array)\n - User: 'do task A then task B' → Sequential (2 separate tool calls)", + "inputSchema": { + "properties": { + "execution_mode": { + "default": "sequential", + "description": "Execution strategy for multiple tasks. Use 'sequential' (default) unless user explicitly requests parallel execution with words like 'parallel', 'simultaneously', 'at the same time', or 'concurrently'.", + "enum": [ + "sequential", + "parallel" + ], + "type": "string" + }, + "task_ids": { + "items": { + "description": "Unique identifier for the task", + "type": "string" + }, + "type": "array" + } + }, + "required": [ + "task_ids" + ], + "type": "object" + }, + "annotations": { + "title": "Run tasks in parallel", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + } + ] + }, + "output": { + "message": { + "id": null, + "role": "assistant", + "created": 1753704331, + "content": [ + { + "type": "text", + "text": "### Current Weather in Berlin, Germany\n\n- **Condition:** Cloudy\n- **Temperature:** 18°C\n\nIf you need more information or forecasts, let me know!" + } + ] + }, + "usage": { + "model": "gpt-4o-mini-2024-07-18", + "usage": { + "input_tokens": 1722, + "output_tokens": 37, + "total_tokens": 1759 + } + } + } + }, + "1bc400a528c54b25f4f1f609481e98e44222b3deaf7eee2c9e640e6345c73861": { + "input": { + "system": "You are a general-purpose AI agent called Goose, created by Block, the parent company of Square, CashApp, and Tidal. Goose is being developed as an open-source software project.\n\nThe current date is 2025-07-28 12:05:28.\n\nGoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o, claude-3.5-sonnet, o1, llama-3.2, deepseek-r1, etc).\nThese models have varying knowledge cut-off dates depending on when they were trained, but typically it's between 5-10 months prior to the current date.\n\n# Extensions\n\nExtensions allow other applications to provide context to Goose. Extensions connect Goose to different data sources and tools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level problems using the tools in these extensions, and can interact with multiple at once.\nUse the search_available_extensions tool to find additional extensions to enable to help with your task. To enable extensions, use the enable_extension tool and provide the extension_name. You should only enable extensions found from the search_available_extensions tool.\n\n\nBecause you dynamically load extensions, your conversation history may refer\nto interactions with extensions that are not currently active. The currently\nactive extensions are below. Each of these extensions provides tools that are\nin your tool specification.\n\n\n## weather_extension\n\n\n\n\n\n\n\n# Suggestion\n\"\"\n\n\n\n\n# Response Guidelines\n\n- Use Markdown formatting for all responses.\n- Follow best practices for Markdown, including:\n - Using headers for organization.\n - Bullet points for lists.\n - Links formatted correctly, either as linked text (e.g., [this is linked text](https://example.com)) or automatic links using angle brackets (e.g., ).\n- For code examples, use fenced code blocks by placing triple backticks (` ``` `) before and after the code. Include the language identifier after the opening backticks (e.g., ` ```python `) to enable syntax highlighting.\n- Ensure clarity, conciseness, and proper formatting to enhance readability and usability.\n\n# Additional Instructions:\n\nRight now you are *NOT* in the chat only mode and have access to tool use and system.", + "messages": [ + { + "id": null, + "role": "user", + "created": 1753704328, + "content": [ + { + "type": "text", + "text": "tell me what the weather is in Berlin, Germany" + } + ] + } + ], + "tools": [ + { + "name": "weather_extension__get_weather", + "description": "Get the weather for a location", + "inputSchema": { + "properties": { + "location": { + "description": "The city and state, e.g. San Francisco, CA", + "type": "string" + } + }, + "required": [ + "location" + ], + "type": "object" + } + }, + { + "name": "platform__search_available_extensions", + "description": "Searches for additional extensions available to help complete tasks.\n Use this tool when you're unable to find a specific feature or functionality you need to complete your task, or when standard approaches aren't working.\n These extensions might provide the exact tools needed to solve your problem.\n If you find a relevant one, consider using your tools to enable it.", + "inputSchema": { + "properties": {}, + "required": [], + "type": "object" + }, + "annotations": { + "title": "Discover extensions", + "readOnlyHint": true, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_extensions", + "description": "Tool to manage extensions and tools in goose context.\n Enable or disable extensions to help complete tasks.\n Enable or disable an extension by providing the extension name.\n ", + "inputSchema": { + "properties": { + "action": { + "description": "The action to perform", + "enum": [ + "enable", + "disable" + ], + "type": "string" + }, + "extension_name": { + "description": "The name of the extension to enable", + "type": "string" + } + }, + "required": [ + "action", + "extension_name" + ], + "type": "object" + }, + "annotations": { + "title": "Enable or disable an extension", + "readOnlyHint": false, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_schedule", + "description": "Manage scheduled recipe execution for this Goose instance.\n\nActions:\n- \"list\": List all scheduled jobs\n- \"create\": Create a new scheduled job from a recipe file\n- \"run_now\": Execute a scheduled job immediately \n- \"pause\": Pause a scheduled job\n- \"unpause\": Resume a paused job\n- \"delete\": Remove a scheduled job\n- \"kill\": Terminate a currently running job\n- \"inspect\": Get details about a running job\n- \"sessions\": List execution history for a job\n- \"session_content\": Get the full content (messages) of a specific session\n", + "inputSchema": { + "properties": { + "action": { + "enum": [ + "list", + "create", + "run_now", + "pause", + "unpause", + "delete", + "kill", + "inspect", + "sessions", + "session_content" + ], + "type": "string" + }, + "cron_expression": { + "description": "A cron expression for create action. Supports both 5-field (minute hour day month weekday) and 6-field (second minute hour day month weekday) formats. 5-field expressions are automatically converted to 6-field by prepending '0' for seconds.", + "type": "string" + }, + "execution_mode": { + "default": "background", + "description": "Execution mode for create action: 'foreground' or 'background'", + "enum": [ + "foreground", + "background" + ], + "type": "string" + }, + "job_id": { + "description": "Job identifier for operations on existing jobs", + "type": "string" + }, + "limit": { + "default": 50, + "description": "Limit for sessions list", + "type": "integer" + }, + "recipe_path": { + "description": "Path to recipe file for create action", + "type": "string" + }, + "session_id": { + "description": "Session identifier for session_content action", + "type": "string" + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "annotations": { + "title": "Manage scheduled recipes", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "dynamic_task__create_task", + "description": "Use this tool to create one or more dynamic tasks from a shared text instruction and varying parameters.How it works:\n - Provide a single text instruction\n - Use the 'task_parameters' field to pass an array of parameter sets\n - Each resulting task will use the same instruction with different parameter values\n This is useful when performing the same operation across many inputs (e.g., getting weather for multiple cities, searching multiple slack channels, iterating through various linear tickets, etc).\n Once created, these tasks should be passed to the 'subagent__execute_task' tool for execution. Tasks can run sequentially or in parallel.\n ---\n What is a 'subagent'?\n A 'subagent' is a stateless sub-process that executes a single task independently. Use subagents when:\n - You want to parallelize similar work across different inputs\n - You are not sure your search or operation will succeed on the first try\n Each subagent receives a task with a defined payload and returns a result, which is not visible to the user unless explicitly summarized by the system.\n ---\n Examples of 'task_parameters' for a single task:\n text_instruction: Search for the config file in the root directory.\n Examples of 'task_parameters' for multiple tasks:\n text_instruction: Get weather for Melbourne.\n text_instruction: Get weather for Los Angeles.\n text_instruction: Get weather for San Francisco.\n ", + "inputSchema": { + "properties": { + "task_parameters": { + "description": "Array of parameter sets for creating tasks. For a single task, provide an array with one element. For multiple tasks, provide an array with multiple elements, each with different parameter values. If there is no parameter set, provide an empty array.", + "items": { + "properties": { + "text_instruction": { + "description": "The text instruction to execute", + "type": "string" + } + }, + "required": [ + "text_instruction" + ], + "type": "object" + }, + "type": "array" + } + }, + "type": "object" + }, + "annotations": { + "title": "Dynamic Task Creation", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + }, + { + "name": "subagent__execute_task", + "description": "Only use the subagent__execute_task tool when you execute sub recipe task or dynamic task.\n EXECUTION STRATEGY DECISION:\n 1. If the tasks are created with execution_mode, use the execution_mode.\n 2. Execute tasks sequentially unless user explicitly requests parallel execution. PARALLEL: User uses keywords like 'parallel', 'simultaneously', 'at the same time', 'concurrently'\n\n IMPLEMENTATION:\n - Sequential execution: Call this tool multiple times, passing exactly ONE task per call\n - Parallel execution: Call this tool once, passing an ARRAY of all tasks\n\n EXAMPLES:\n User Intent Based:\n - User: 'get weather and tell me a joke' → Sequential (2 separate tool calls, 1 task each)\n - User: 'get weather and joke in parallel' → Parallel (1 tool call with array of 2 tasks)\n - User: 'run these simultaneously' → Parallel (1 tool call with task array)\n - User: 'do task A then task B' → Sequential (2 separate tool calls)", + "inputSchema": { + "properties": { + "execution_mode": { + "default": "sequential", + "description": "Execution strategy for multiple tasks. Use 'sequential' (default) unless user explicitly requests parallel execution with words like 'parallel', 'simultaneously', 'at the same time', or 'concurrently'.", + "enum": [ + "sequential", + "parallel" + ], + "type": "string" + }, + "task_ids": { + "items": { + "description": "Unique identifier for the task", + "type": "string" + }, + "type": "array" + } + }, + "required": [ + "task_ids" + ], + "type": "object" + }, + "annotations": { + "title": "Run tasks in parallel", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + } + ] + }, + "output": { + "message": { + "id": null, + "role": "assistant", + "created": 1753704329, + "content": [ + { + "type": "toolRequest", + "id": "call_C91rmWZSSnUaKx0AtBdwO4Zw", + "toolCall": { + "status": "success", + "value": { + "name": "weather_extension__get_weather", + "arguments": { + "location": "Berlin, Germany" + } + } + } + } + ] + }, + "usage": { + "model": "gpt-4o-mini-2024-07-18", + "usage": { + "input_tokens": 1680, + "output_tokens": 20, + "total_tokens": 1700 + } + } + } + } +} \ No newline at end of file diff --git a/crates/goose-cli/src/scenario_tests/recordings/azure_openai/what_is_your_name.json b/crates/goose-cli/src/scenario_tests/recordings/azure_openai/what_is_your_name.json new file mode 100644 index 000000000000..9ea1cda0e9f3 --- /dev/null +++ b/crates/goose-cli/src/scenario_tests/recordings/azure_openai/what_is_your_name.json @@ -0,0 +1,238 @@ +{ + "1b998117eba523901ae6a4dbf8caa81a95ea88ef7a84d0434c9b41a26164a2b9": { + "input": { + "system": "You are a general-purpose AI agent called Goose, created by Block, the parent company of Square, CashApp, and Tidal. Goose is being developed as an open-source software project.\n\nThe current date is 2025-07-28 12:05:25.\n\nGoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o, claude-3.5-sonnet, o1, llama-3.2, deepseek-r1, etc).\nThese models have varying knowledge cut-off dates depending on when they were trained, but typically it's between 5-10 months prior to the current date.\n\n# Extensions\n\nExtensions allow other applications to provide context to Goose. Extensions connect Goose to different data sources and tools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level problems using the tools in these extensions, and can interact with multiple at once.\nUse the search_available_extensions tool to find additional extensions to enable to help with your task. To enable extensions, use the enable_extension tool and provide the extension_name. You should only enable extensions found from the search_available_extensions tool.\n\n\nBecause you dynamically load extensions, your conversation history may refer\nto interactions with extensions that are not currently active. The currently\nactive extensions are below. Each of these extensions provides tools that are\nin your tool specification.\n\n\n## weather_extension\n\n\n\n\n\n\n\n# Suggestion\n\"\"\n\n\n\n\n# Response Guidelines\n\n- Use Markdown formatting for all responses.\n- Follow best practices for Markdown, including:\n - Using headers for organization.\n - Bullet points for lists.\n - Links formatted correctly, either as linked text (e.g., [this is linked text](https://example.com)) or automatic links using angle brackets (e.g., ).\n- For code examples, use fenced code blocks by placing triple backticks (` ``` `) before and after the code. Include the language identifier after the opening backticks (e.g., ` ```python `) to enable syntax highlighting.\n- Ensure clarity, conciseness, and proper formatting to enhance readability and usability.\n\n# Additional Instructions:\n\nRight now you are *NOT* in the chat only mode and have access to tool use and system.", + "messages": [ + { + "id": null, + "role": "user", + "created": 1753704325, + "content": [ + { + "type": "text", + "text": "what is your name" + } + ] + } + ], + "tools": [ + { + "name": "weather_extension__get_weather", + "description": "Get the weather for a location", + "inputSchema": { + "properties": { + "location": { + "description": "The city and state, e.g. San Francisco, CA", + "type": "string" + } + }, + "required": [ + "location" + ], + "type": "object" + } + }, + { + "name": "platform__search_available_extensions", + "description": "Searches for additional extensions available to help complete tasks.\n Use this tool when you're unable to find a specific feature or functionality you need to complete your task, or when standard approaches aren't working.\n These extensions might provide the exact tools needed to solve your problem.\n If you find a relevant one, consider using your tools to enable it.", + "inputSchema": { + "properties": {}, + "required": [], + "type": "object" + }, + "annotations": { + "title": "Discover extensions", + "readOnlyHint": true, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_extensions", + "description": "Tool to manage extensions and tools in goose context.\n Enable or disable extensions to help complete tasks.\n Enable or disable an extension by providing the extension name.\n ", + "inputSchema": { + "properties": { + "action": { + "description": "The action to perform", + "enum": [ + "enable", + "disable" + ], + "type": "string" + }, + "extension_name": { + "description": "The name of the extension to enable", + "type": "string" + } + }, + "required": [ + "action", + "extension_name" + ], + "type": "object" + }, + "annotations": { + "title": "Enable or disable an extension", + "readOnlyHint": false, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_schedule", + "description": "Manage scheduled recipe execution for this Goose instance.\n\nActions:\n- \"list\": List all scheduled jobs\n- \"create\": Create a new scheduled job from a recipe file\n- \"run_now\": Execute a scheduled job immediately \n- \"pause\": Pause a scheduled job\n- \"unpause\": Resume a paused job\n- \"delete\": Remove a scheduled job\n- \"kill\": Terminate a currently running job\n- \"inspect\": Get details about a running job\n- \"sessions\": List execution history for a job\n- \"session_content\": Get the full content (messages) of a specific session\n", + "inputSchema": { + "properties": { + "action": { + "enum": [ + "list", + "create", + "run_now", + "pause", + "unpause", + "delete", + "kill", + "inspect", + "sessions", + "session_content" + ], + "type": "string" + }, + "cron_expression": { + "description": "A cron expression for create action. Supports both 5-field (minute hour day month weekday) and 6-field (second minute hour day month weekday) formats. 5-field expressions are automatically converted to 6-field by prepending '0' for seconds.", + "type": "string" + }, + "execution_mode": { + "default": "background", + "description": "Execution mode for create action: 'foreground' or 'background'", + "enum": [ + "foreground", + "background" + ], + "type": "string" + }, + "job_id": { + "description": "Job identifier for operations on existing jobs", + "type": "string" + }, + "limit": { + "default": 50, + "description": "Limit for sessions list", + "type": "integer" + }, + "recipe_path": { + "description": "Path to recipe file for create action", + "type": "string" + }, + "session_id": { + "description": "Session identifier for session_content action", + "type": "string" + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "annotations": { + "title": "Manage scheduled recipes", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "dynamic_task__create_task", + "description": "Use this tool to create one or more dynamic tasks from a shared text instruction and varying parameters.How it works:\n - Provide a single text instruction\n - Use the 'task_parameters' field to pass an array of parameter sets\n - Each resulting task will use the same instruction with different parameter values\n This is useful when performing the same operation across many inputs (e.g., getting weather for multiple cities, searching multiple slack channels, iterating through various linear tickets, etc).\n Once created, these tasks should be passed to the 'subagent__execute_task' tool for execution. Tasks can run sequentially or in parallel.\n ---\n What is a 'subagent'?\n A 'subagent' is a stateless sub-process that executes a single task independently. Use subagents when:\n - You want to parallelize similar work across different inputs\n - You are not sure your search or operation will succeed on the first try\n Each subagent receives a task with a defined payload and returns a result, which is not visible to the user unless explicitly summarized by the system.\n ---\n Examples of 'task_parameters' for a single task:\n text_instruction: Search for the config file in the root directory.\n Examples of 'task_parameters' for multiple tasks:\n text_instruction: Get weather for Melbourne.\n text_instruction: Get weather for Los Angeles.\n text_instruction: Get weather for San Francisco.\n ", + "inputSchema": { + "properties": { + "task_parameters": { + "description": "Array of parameter sets for creating tasks. For a single task, provide an array with one element. For multiple tasks, provide an array with multiple elements, each with different parameter values. If there is no parameter set, provide an empty array.", + "items": { + "properties": { + "text_instruction": { + "description": "The text instruction to execute", + "type": "string" + } + }, + "required": [ + "text_instruction" + ], + "type": "object" + }, + "type": "array" + } + }, + "type": "object" + }, + "annotations": { + "title": "Dynamic Task Creation", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + }, + { + "name": "subagent__execute_task", + "description": "Only use the subagent__execute_task tool when you execute sub recipe task or dynamic task.\n EXECUTION STRATEGY DECISION:\n 1. If the tasks are created with execution_mode, use the execution_mode.\n 2. Execute tasks sequentially unless user explicitly requests parallel execution. PARALLEL: User uses keywords like 'parallel', 'simultaneously', 'at the same time', 'concurrently'\n\n IMPLEMENTATION:\n - Sequential execution: Call this tool multiple times, passing exactly ONE task per call\n - Parallel execution: Call this tool once, passing an ARRAY of all tasks\n\n EXAMPLES:\n User Intent Based:\n - User: 'get weather and tell me a joke' → Sequential (2 separate tool calls, 1 task each)\n - User: 'get weather and joke in parallel' → Parallel (1 tool call with array of 2 tasks)\n - User: 'run these simultaneously' → Parallel (1 tool call with task array)\n - User: 'do task A then task B' → Sequential (2 separate tool calls)", + "inputSchema": { + "properties": { + "execution_mode": { + "default": "sequential", + "description": "Execution strategy for multiple tasks. Use 'sequential' (default) unless user explicitly requests parallel execution with words like 'parallel', 'simultaneously', 'at the same time', or 'concurrently'.", + "enum": [ + "sequential", + "parallel" + ], + "type": "string" + }, + "task_ids": { + "items": { + "description": "Unique identifier for the task", + "type": "string" + }, + "type": "array" + } + }, + "required": [ + "task_ids" + ], + "type": "object" + }, + "annotations": { + "title": "Run tasks in parallel", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + } + ] + }, + "output": { + "message": { + "id": null, + "role": "assistant", + "created": 1753704327, + "content": [ + { + "type": "text", + "text": "My name is Goose, an AI agent created by Block, the parent company of Square, CashApp, and Tidal. How can I assist you today?" + } + ] + }, + "usage": { + "model": "gpt-4o-mini-2024-07-18", + "usage": { + "input_tokens": 1674, + "output_tokens": 34, + "total_tokens": 1708 + } + } + } + } +} \ No newline at end of file diff --git a/crates/goose-cli/src/scenario_tests/recordings/google/context_length_exceeded.json b/crates/goose-cli/src/scenario_tests/recordings/google/context_length_exceeded.json new file mode 100644 index 000000000000..9e26dfeeb6e6 --- /dev/null +++ b/crates/goose-cli/src/scenario_tests/recordings/google/context_length_exceeded.json @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/crates/goose-cli/src/scenario_tests/recordings/google/what_is_your_name.json b/crates/goose-cli/src/scenario_tests/recordings/google/what_is_your_name.json new file mode 100644 index 000000000000..2e25b6eb61af --- /dev/null +++ b/crates/goose-cli/src/scenario_tests/recordings/google/what_is_your_name.json @@ -0,0 +1,238 @@ +{ + "1b998117eba523901ae6a4dbf8caa81a95ea88ef7a84d0434c9b41a26164a2b9": { + "input": { + "system": "You are a general-purpose AI agent called Goose, created by Block, the parent company of Square, CashApp, and Tidal. Goose is being developed as an open-source software project.\n\nThe current date is 2025-07-28 12:05:27.\n\nGoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o, claude-3.5-sonnet, o1, llama-3.2, deepseek-r1, etc).\nThese models have varying knowledge cut-off dates depending on when they were trained, but typically it's between 5-10 months prior to the current date.\n\n# Extensions\n\nExtensions allow other applications to provide context to Goose. Extensions connect Goose to different data sources and tools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level problems using the tools in these extensions, and can interact with multiple at once.\nUse the search_available_extensions tool to find additional extensions to enable to help with your task. To enable extensions, use the enable_extension tool and provide the extension_name. You should only enable extensions found from the search_available_extensions tool.\n\n\nBecause you dynamically load extensions, your conversation history may refer\nto interactions with extensions that are not currently active. The currently\nactive extensions are below. Each of these extensions provides tools that are\nin your tool specification.\n\n\n## weather_extension\n\n\n\n\n\n\n\n# Suggestion\n\"\"\n\n\n\n\n# Response Guidelines\n\n- Use Markdown formatting for all responses.\n- Follow best practices for Markdown, including:\n - Using headers for organization.\n - Bullet points for lists.\n - Links formatted correctly, either as linked text (e.g., [this is linked text](https://example.com)) or automatic links using angle brackets (e.g., ).\n- For code examples, use fenced code blocks by placing triple backticks (` ``` `) before and after the code. Include the language identifier after the opening backticks (e.g., ` ```python `) to enable syntax highlighting.\n- Ensure clarity, conciseness, and proper formatting to enhance readability and usability.\n\n# Additional Instructions:\n\nRight now you are *NOT* in the chat only mode and have access to tool use and system.", + "messages": [ + { + "id": null, + "role": "user", + "created": 1753704327, + "content": [ + { + "type": "text", + "text": "what is your name" + } + ] + } + ], + "tools": [ + { + "name": "weather_extension__get_weather", + "description": "Get the weather for a location", + "inputSchema": { + "properties": { + "location": { + "description": "The city and state, e.g. San Francisco, CA", + "type": "string" + } + }, + "required": [ + "location" + ], + "type": "object" + } + }, + { + "name": "platform__search_available_extensions", + "description": "Searches for additional extensions available to help complete tasks.\n Use this tool when you're unable to find a specific feature or functionality you need to complete your task, or when standard approaches aren't working.\n These extensions might provide the exact tools needed to solve your problem.\n If you find a relevant one, consider using your tools to enable it.", + "inputSchema": { + "properties": {}, + "required": [], + "type": "object" + }, + "annotations": { + "title": "Discover extensions", + "readOnlyHint": true, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_extensions", + "description": "Tool to manage extensions and tools in goose context.\n Enable or disable extensions to help complete tasks.\n Enable or disable an extension by providing the extension name.\n ", + "inputSchema": { + "properties": { + "action": { + "description": "The action to perform", + "enum": [ + "enable", + "disable" + ], + "type": "string" + }, + "extension_name": { + "description": "The name of the extension to enable", + "type": "string" + } + }, + "required": [ + "action", + "extension_name" + ], + "type": "object" + }, + "annotations": { + "title": "Enable or disable an extension", + "readOnlyHint": false, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_schedule", + "description": "Manage scheduled recipe execution for this Goose instance.\n\nActions:\n- \"list\": List all scheduled jobs\n- \"create\": Create a new scheduled job from a recipe file\n- \"run_now\": Execute a scheduled job immediately \n- \"pause\": Pause a scheduled job\n- \"unpause\": Resume a paused job\n- \"delete\": Remove a scheduled job\n- \"kill\": Terminate a currently running job\n- \"inspect\": Get details about a running job\n- \"sessions\": List execution history for a job\n- \"session_content\": Get the full content (messages) of a specific session\n", + "inputSchema": { + "properties": { + "action": { + "enum": [ + "list", + "create", + "run_now", + "pause", + "unpause", + "delete", + "kill", + "inspect", + "sessions", + "session_content" + ], + "type": "string" + }, + "cron_expression": { + "description": "A cron expression for create action. Supports both 5-field (minute hour day month weekday) and 6-field (second minute hour day month weekday) formats. 5-field expressions are automatically converted to 6-field by prepending '0' for seconds.", + "type": "string" + }, + "execution_mode": { + "default": "background", + "description": "Execution mode for create action: 'foreground' or 'background'", + "enum": [ + "foreground", + "background" + ], + "type": "string" + }, + "job_id": { + "description": "Job identifier for operations on existing jobs", + "type": "string" + }, + "limit": { + "default": 50, + "description": "Limit for sessions list", + "type": "integer" + }, + "recipe_path": { + "description": "Path to recipe file for create action", + "type": "string" + }, + "session_id": { + "description": "Session identifier for session_content action", + "type": "string" + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "annotations": { + "title": "Manage scheduled recipes", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "dynamic_task__create_task", + "description": "Use this tool to create one or more dynamic tasks from a shared text instruction and varying parameters.How it works:\n - Provide a single text instruction\n - Use the 'task_parameters' field to pass an array of parameter sets\n - Each resulting task will use the same instruction with different parameter values\n This is useful when performing the same operation across many inputs (e.g., getting weather for multiple cities, searching multiple slack channels, iterating through various linear tickets, etc).\n Once created, these tasks should be passed to the 'subagent__execute_task' tool for execution. Tasks can run sequentially or in parallel.\n ---\n What is a 'subagent'?\n A 'subagent' is a stateless sub-process that executes a single task independently. Use subagents when:\n - You want to parallelize similar work across different inputs\n - You are not sure your search or operation will succeed on the first try\n Each subagent receives a task with a defined payload and returns a result, which is not visible to the user unless explicitly summarized by the system.\n ---\n Examples of 'task_parameters' for a single task:\n text_instruction: Search for the config file in the root directory.\n Examples of 'task_parameters' for multiple tasks:\n text_instruction: Get weather for Melbourne.\n text_instruction: Get weather for Los Angeles.\n text_instruction: Get weather for San Francisco.\n ", + "inputSchema": { + "properties": { + "task_parameters": { + "description": "Array of parameter sets for creating tasks. For a single task, provide an array with one element. For multiple tasks, provide an array with multiple elements, each with different parameter values. If there is no parameter set, provide an empty array.", + "items": { + "properties": { + "text_instruction": { + "description": "The text instruction to execute", + "type": "string" + } + }, + "required": [ + "text_instruction" + ], + "type": "object" + }, + "type": "array" + } + }, + "type": "object" + }, + "annotations": { + "title": "Dynamic Task Creation", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + }, + { + "name": "subagent__execute_task", + "description": "Only use the subagent__execute_task tool when you execute sub recipe task or dynamic task.\n EXECUTION STRATEGY DECISION:\n 1. If the tasks are created with execution_mode, use the execution_mode.\n 2. Execute tasks sequentially unless user explicitly requests parallel execution. PARALLEL: User uses keywords like 'parallel', 'simultaneously', 'at the same time', 'concurrently'\n\n IMPLEMENTATION:\n - Sequential execution: Call this tool multiple times, passing exactly ONE task per call\n - Parallel execution: Call this tool once, passing an ARRAY of all tasks\n\n EXAMPLES:\n User Intent Based:\n - User: 'get weather and tell me a joke' → Sequential (2 separate tool calls, 1 task each)\n - User: 'get weather and joke in parallel' → Parallel (1 tool call with array of 2 tasks)\n - User: 'run these simultaneously' → Parallel (1 tool call with task array)\n - User: 'do task A then task B' → Sequential (2 separate tool calls)", + "inputSchema": { + "properties": { + "execution_mode": { + "default": "sequential", + "description": "Execution strategy for multiple tasks. Use 'sequential' (default) unless user explicitly requests parallel execution with words like 'parallel', 'simultaneously', 'at the same time', or 'concurrently'.", + "enum": [ + "sequential", + "parallel" + ], + "type": "string" + }, + "task_ids": { + "items": { + "description": "Unique identifier for the task", + "type": "string" + }, + "type": "array" + } + }, + "required": [ + "task_ids" + ], + "type": "object" + }, + "annotations": { + "title": "Run tasks in parallel", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + } + ] + }, + "output": { + "message": { + "id": null, + "role": "assistant", + "created": 1753704329, + "content": [ + { + "type": "text", + "text": "My name is Goose. I am a general-purpose AI agent created by Block, the parent company of Square, CashApp, and Tidal. I am being developed as an open-source software project." + } + ] + }, + "usage": { + "model": "gemini-2.5-flash", + "usage": { + "input_tokens": 1967, + "output_tokens": 41, + "total_tokens": 2038 + } + } + } + } +} \ No newline at end of file diff --git a/crates/goose-cli/src/scenario_tests/recordings/groq/context_length_exceeded.json b/crates/goose-cli/src/scenario_tests/recordings/groq/context_length_exceeded.json new file mode 100644 index 000000000000..9e26dfeeb6e6 --- /dev/null +++ b/crates/goose-cli/src/scenario_tests/recordings/groq/context_length_exceeded.json @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/crates/goose-cli/src/scenario_tests/recordings/groq/weather_tool.json b/crates/goose-cli/src/scenario_tests/recordings/groq/weather_tool.json new file mode 100644 index 000000000000..dc54f6ccf6e0 --- /dev/null +++ b/crates/goose-cli/src/scenario_tests/recordings/groq/weather_tool.json @@ -0,0 +1,523 @@ +{ + "09dddf56be462d1861d5a56de6ec2d79b76e1b6f8f8ba9da8d837aae55c7e70b": { + "input": { + "system": "You are a general-purpose AI agent called Goose, created by Block, the parent company of Square, CashApp, and Tidal. Goose is being developed as an open-source software project.\n\nThe current date is 2025-07-28 12:05:31.\n\nGoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o, claude-3.5-sonnet, o1, llama-3.2, deepseek-r1, etc).\nThese models have varying knowledge cut-off dates depending on when they were trained, but typically it's between 5-10 months prior to the current date.\n\n# Extensions\n\nExtensions allow other applications to provide context to Goose. Extensions connect Goose to different data sources and tools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level problems using the tools in these extensions, and can interact with multiple at once.\nUse the search_available_extensions tool to find additional extensions to enable to help with your task. To enable extensions, use the enable_extension tool and provide the extension_name. You should only enable extensions found from the search_available_extensions tool.\n\n\nBecause you dynamically load extensions, your conversation history may refer\nto interactions with extensions that are not currently active. The currently\nactive extensions are below. Each of these extensions provides tools that are\nin your tool specification.\n\n\n## weather_extension\n\n\n\n\n\n\n\n# Suggestion\n\"\"\n\n\n\n\n# Response Guidelines\n\n- Use Markdown formatting for all responses.\n- Follow best practices for Markdown, including:\n - Using headers for organization.\n - Bullet points for lists.\n - Links formatted correctly, either as linked text (e.g., [this is linked text](https://example.com)) or automatic links using angle brackets (e.g., ).\n- For code examples, use fenced code blocks by placing triple backticks (` ``` `) before and after the code. Include the language identifier after the opening backticks (e.g., ` ```python `) to enable syntax highlighting.\n- Ensure clarity, conciseness, and proper formatting to enhance readability and usability.\n\n# Additional Instructions:\n\nRight now you are *NOT* in the chat only mode and have access to tool use and system.", + "messages": [ + { + "id": null, + "role": "user", + "created": 1753704331, + "content": [ + { + "type": "text", + "text": "tell me what the weather is in Berlin, Germany" + } + ] + }, + { + "id": null, + "role": "assistant", + "created": 1753704331, + "content": [ + { + "type": "toolRequest", + "id": "rnxgf8akg", + "toolCall": { + "status": "success", + "value": { + "name": "weather_extension__get_weather", + "arguments": { + "location": "Berlin, Germany" + } + } + } + } + ] + }, + { + "id": null, + "role": "user", + "created": 1753704331, + "content": [ + { + "type": "toolResponse", + "id": "rnxgf8akg", + "toolResult": { + "status": "success", + "value": [ + { + "type": "text", + "text": "The weather in Berlin, Germany is cloudy and 18°C" + } + ] + } + } + ] + } + ], + "tools": [ + { + "name": "weather_extension__get_weather", + "description": "Get the weather for a location", + "inputSchema": { + "properties": { + "location": { + "description": "The city and state, e.g. San Francisco, CA", + "type": "string" + } + }, + "required": [ + "location" + ], + "type": "object" + } + }, + { + "name": "platform__search_available_extensions", + "description": "Searches for additional extensions available to help complete tasks.\n Use this tool when you're unable to find a specific feature or functionality you need to complete your task, or when standard approaches aren't working.\n These extensions might provide the exact tools needed to solve your problem.\n If you find a relevant one, consider using your tools to enable it.", + "inputSchema": { + "properties": {}, + "required": [], + "type": "object" + }, + "annotations": { + "title": "Discover extensions", + "readOnlyHint": true, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_extensions", + "description": "Tool to manage extensions and tools in goose context.\n Enable or disable extensions to help complete tasks.\n Enable or disable an extension by providing the extension name.\n ", + "inputSchema": { + "properties": { + "action": { + "description": "The action to perform", + "enum": [ + "enable", + "disable" + ], + "type": "string" + }, + "extension_name": { + "description": "The name of the extension to enable", + "type": "string" + } + }, + "required": [ + "action", + "extension_name" + ], + "type": "object" + }, + "annotations": { + "title": "Enable or disable an extension", + "readOnlyHint": false, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_schedule", + "description": "Manage scheduled recipe execution for this Goose instance.\n\nActions:\n- \"list\": List all scheduled jobs\n- \"create\": Create a new scheduled job from a recipe file\n- \"run_now\": Execute a scheduled job immediately \n- \"pause\": Pause a scheduled job\n- \"unpause\": Resume a paused job\n- \"delete\": Remove a scheduled job\n- \"kill\": Terminate a currently running job\n- \"inspect\": Get details about a running job\n- \"sessions\": List execution history for a job\n- \"session_content\": Get the full content (messages) of a specific session\n", + "inputSchema": { + "properties": { + "action": { + "enum": [ + "list", + "create", + "run_now", + "pause", + "unpause", + "delete", + "kill", + "inspect", + "sessions", + "session_content" + ], + "type": "string" + }, + "cron_expression": { + "description": "A cron expression for create action. Supports both 5-field (minute hour day month weekday) and 6-field (second minute hour day month weekday) formats. 5-field expressions are automatically converted to 6-field by prepending '0' for seconds.", + "type": "string" + }, + "execution_mode": { + "default": "background", + "description": "Execution mode for create action: 'foreground' or 'background'", + "enum": [ + "foreground", + "background" + ], + "type": "string" + }, + "job_id": { + "description": "Job identifier for operations on existing jobs", + "type": "string" + }, + "limit": { + "default": 50, + "description": "Limit for sessions list", + "type": "integer" + }, + "recipe_path": { + "description": "Path to recipe file for create action", + "type": "string" + }, + "session_id": { + "description": "Session identifier for session_content action", + "type": "string" + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "annotations": { + "title": "Manage scheduled recipes", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "dynamic_task__create_task", + "description": "Use this tool to create one or more dynamic tasks from a shared text instruction and varying parameters.How it works:\n - Provide a single text instruction\n - Use the 'task_parameters' field to pass an array of parameter sets\n - Each resulting task will use the same instruction with different parameter values\n This is useful when performing the same operation across many inputs (e.g., getting weather for multiple cities, searching multiple slack channels, iterating through various linear tickets, etc).\n Once created, these tasks should be passed to the 'subagent__execute_task' tool for execution. Tasks can run sequentially or in parallel.\n ---\n What is a 'subagent'?\n A 'subagent' is a stateless sub-process that executes a single task independently. Use subagents when:\n - You want to parallelize similar work across different inputs\n - You are not sure your search or operation will succeed on the first try\n Each subagent receives a task with a defined payload and returns a result, which is not visible to the user unless explicitly summarized by the system.\n ---\n Examples of 'task_parameters' for a single task:\n text_instruction: Search for the config file in the root directory.\n Examples of 'task_parameters' for multiple tasks:\n text_instruction: Get weather for Melbourne.\n text_instruction: Get weather for Los Angeles.\n text_instruction: Get weather for San Francisco.\n ", + "inputSchema": { + "properties": { + "task_parameters": { + "description": "Array of parameter sets for creating tasks. For a single task, provide an array with one element. For multiple tasks, provide an array with multiple elements, each with different parameter values. If there is no parameter set, provide an empty array.", + "items": { + "properties": { + "text_instruction": { + "description": "The text instruction to execute", + "type": "string" + } + }, + "required": [ + "text_instruction" + ], + "type": "object" + }, + "type": "array" + } + }, + "type": "object" + }, + "annotations": { + "title": "Dynamic Task Creation", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + }, + { + "name": "subagent__execute_task", + "description": "Only use the subagent__execute_task tool when you execute sub recipe task or dynamic task.\n EXECUTION STRATEGY DECISION:\n 1. If the tasks are created with execution_mode, use the execution_mode.\n 2. Execute tasks sequentially unless user explicitly requests parallel execution. PARALLEL: User uses keywords like 'parallel', 'simultaneously', 'at the same time', 'concurrently'\n\n IMPLEMENTATION:\n - Sequential execution: Call this tool multiple times, passing exactly ONE task per call\n - Parallel execution: Call this tool once, passing an ARRAY of all tasks\n\n EXAMPLES:\n User Intent Based:\n - User: 'get weather and tell me a joke' → Sequential (2 separate tool calls, 1 task each)\n - User: 'get weather and joke in parallel' → Parallel (1 tool call with array of 2 tasks)\n - User: 'run these simultaneously' → Parallel (1 tool call with task array)\n - User: 'do task A then task B' → Sequential (2 separate tool calls)", + "inputSchema": { + "properties": { + "execution_mode": { + "default": "sequential", + "description": "Execution strategy for multiple tasks. Use 'sequential' (default) unless user explicitly requests parallel execution with words like 'parallel', 'simultaneously', 'at the same time', or 'concurrently'.", + "enum": [ + "sequential", + "parallel" + ], + "type": "string" + }, + "task_ids": { + "items": { + "description": "Unique identifier for the task", + "type": "string" + }, + "type": "array" + } + }, + "required": [ + "task_ids" + ], + "type": "object" + }, + "annotations": { + "title": "Run tasks in parallel", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + } + ] + }, + "output": { + "message": { + "id": null, + "role": "assistant", + "created": 1753704332, + "content": [ + { + "type": "text", + "text": "The weather in Berlin, Germany is cloudy with a temperature of 18°C." + } + ] + }, + "usage": { + "model": "llama-3.3-70b-versatile", + "usage": { + "input_tokens": 2856, + "output_tokens": 17, + "total_tokens": 2873 + } + } + } + }, + "1bc400a528c54b25f4f1f609481e98e44222b3deaf7eee2c9e640e6345c73861": { + "input": { + "system": "You are a general-purpose AI agent called Goose, created by Block, the parent company of Square, CashApp, and Tidal. Goose is being developed as an open-source software project.\n\nThe current date is 2025-07-28 12:05:31.\n\nGoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o, claude-3.5-sonnet, o1, llama-3.2, deepseek-r1, etc).\nThese models have varying knowledge cut-off dates depending on when they were trained, but typically it's between 5-10 months prior to the current date.\n\n# Extensions\n\nExtensions allow other applications to provide context to Goose. Extensions connect Goose to different data sources and tools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level problems using the tools in these extensions, and can interact with multiple at once.\nUse the search_available_extensions tool to find additional extensions to enable to help with your task. To enable extensions, use the enable_extension tool and provide the extension_name. You should only enable extensions found from the search_available_extensions tool.\n\n\nBecause you dynamically load extensions, your conversation history may refer\nto interactions with extensions that are not currently active. The currently\nactive extensions are below. Each of these extensions provides tools that are\nin your tool specification.\n\n\n## weather_extension\n\n\n\n\n\n\n\n# Suggestion\n\"\"\n\n\n\n\n# Response Guidelines\n\n- Use Markdown formatting for all responses.\n- Follow best practices for Markdown, including:\n - Using headers for organization.\n - Bullet points for lists.\n - Links formatted correctly, either as linked text (e.g., [this is linked text](https://example.com)) or automatic links using angle brackets (e.g., ).\n- For code examples, use fenced code blocks by placing triple backticks (` ``` `) before and after the code. Include the language identifier after the opening backticks (e.g., ` ```python `) to enable syntax highlighting.\n- Ensure clarity, conciseness, and proper formatting to enhance readability and usability.\n\n# Additional Instructions:\n\nRight now you are *NOT* in the chat only mode and have access to tool use and system.", + "messages": [ + { + "id": null, + "role": "user", + "created": 1753704331, + "content": [ + { + "type": "text", + "text": "tell me what the weather is in Berlin, Germany" + } + ] + } + ], + "tools": [ + { + "name": "weather_extension__get_weather", + "description": "Get the weather for a location", + "inputSchema": { + "properties": { + "location": { + "description": "The city and state, e.g. San Francisco, CA", + "type": "string" + } + }, + "required": [ + "location" + ], + "type": "object" + } + }, + { + "name": "platform__search_available_extensions", + "description": "Searches for additional extensions available to help complete tasks.\n Use this tool when you're unable to find a specific feature or functionality you need to complete your task, or when standard approaches aren't working.\n These extensions might provide the exact tools needed to solve your problem.\n If you find a relevant one, consider using your tools to enable it.", + "inputSchema": { + "properties": {}, + "required": [], + "type": "object" + }, + "annotations": { + "title": "Discover extensions", + "readOnlyHint": true, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_extensions", + "description": "Tool to manage extensions and tools in goose context.\n Enable or disable extensions to help complete tasks.\n Enable or disable an extension by providing the extension name.\n ", + "inputSchema": { + "properties": { + "action": { + "description": "The action to perform", + "enum": [ + "enable", + "disable" + ], + "type": "string" + }, + "extension_name": { + "description": "The name of the extension to enable", + "type": "string" + } + }, + "required": [ + "action", + "extension_name" + ], + "type": "object" + }, + "annotations": { + "title": "Enable or disable an extension", + "readOnlyHint": false, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_schedule", + "description": "Manage scheduled recipe execution for this Goose instance.\n\nActions:\n- \"list\": List all scheduled jobs\n- \"create\": Create a new scheduled job from a recipe file\n- \"run_now\": Execute a scheduled job immediately \n- \"pause\": Pause a scheduled job\n- \"unpause\": Resume a paused job\n- \"delete\": Remove a scheduled job\n- \"kill\": Terminate a currently running job\n- \"inspect\": Get details about a running job\n- \"sessions\": List execution history for a job\n- \"session_content\": Get the full content (messages) of a specific session\n", + "inputSchema": { + "properties": { + "action": { + "enum": [ + "list", + "create", + "run_now", + "pause", + "unpause", + "delete", + "kill", + "inspect", + "sessions", + "session_content" + ], + "type": "string" + }, + "cron_expression": { + "description": "A cron expression for create action. Supports both 5-field (minute hour day month weekday) and 6-field (second minute hour day month weekday) formats. 5-field expressions are automatically converted to 6-field by prepending '0' for seconds.", + "type": "string" + }, + "execution_mode": { + "default": "background", + "description": "Execution mode for create action: 'foreground' or 'background'", + "enum": [ + "foreground", + "background" + ], + "type": "string" + }, + "job_id": { + "description": "Job identifier for operations on existing jobs", + "type": "string" + }, + "limit": { + "default": 50, + "description": "Limit for sessions list", + "type": "integer" + }, + "recipe_path": { + "description": "Path to recipe file for create action", + "type": "string" + }, + "session_id": { + "description": "Session identifier for session_content action", + "type": "string" + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "annotations": { + "title": "Manage scheduled recipes", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "dynamic_task__create_task", + "description": "Use this tool to create one or more dynamic tasks from a shared text instruction and varying parameters.How it works:\n - Provide a single text instruction\n - Use the 'task_parameters' field to pass an array of parameter sets\n - Each resulting task will use the same instruction with different parameter values\n This is useful when performing the same operation across many inputs (e.g., getting weather for multiple cities, searching multiple slack channels, iterating through various linear tickets, etc).\n Once created, these tasks should be passed to the 'subagent__execute_task' tool for execution. Tasks can run sequentially or in parallel.\n ---\n What is a 'subagent'?\n A 'subagent' is a stateless sub-process that executes a single task independently. Use subagents when:\n - You want to parallelize similar work across different inputs\n - You are not sure your search or operation will succeed on the first try\n Each subagent receives a task with a defined payload and returns a result, which is not visible to the user unless explicitly summarized by the system.\n ---\n Examples of 'task_parameters' for a single task:\n text_instruction: Search for the config file in the root directory.\n Examples of 'task_parameters' for multiple tasks:\n text_instruction: Get weather for Melbourne.\n text_instruction: Get weather for Los Angeles.\n text_instruction: Get weather for San Francisco.\n ", + "inputSchema": { + "properties": { + "task_parameters": { + "description": "Array of parameter sets for creating tasks. For a single task, provide an array with one element. For multiple tasks, provide an array with multiple elements, each with different parameter values. If there is no parameter set, provide an empty array.", + "items": { + "properties": { + "text_instruction": { + "description": "The text instruction to execute", + "type": "string" + } + }, + "required": [ + "text_instruction" + ], + "type": "object" + }, + "type": "array" + } + }, + "type": "object" + }, + "annotations": { + "title": "Dynamic Task Creation", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + }, + { + "name": "subagent__execute_task", + "description": "Only use the subagent__execute_task tool when you execute sub recipe task or dynamic task.\n EXECUTION STRATEGY DECISION:\n 1. If the tasks are created with execution_mode, use the execution_mode.\n 2. Execute tasks sequentially unless user explicitly requests parallel execution. PARALLEL: User uses keywords like 'parallel', 'simultaneously', 'at the same time', 'concurrently'\n\n IMPLEMENTATION:\n - Sequential execution: Call this tool multiple times, passing exactly ONE task per call\n - Parallel execution: Call this tool once, passing an ARRAY of all tasks\n\n EXAMPLES:\n User Intent Based:\n - User: 'get weather and tell me a joke' → Sequential (2 separate tool calls, 1 task each)\n - User: 'get weather and joke in parallel' → Parallel (1 tool call with array of 2 tasks)\n - User: 'run these simultaneously' → Parallel (1 tool call with task array)\n - User: 'do task A then task B' → Sequential (2 separate tool calls)", + "inputSchema": { + "properties": { + "execution_mode": { + "default": "sequential", + "description": "Execution strategy for multiple tasks. Use 'sequential' (default) unless user explicitly requests parallel execution with words like 'parallel', 'simultaneously', 'at the same time', or 'concurrently'.", + "enum": [ + "sequential", + "parallel" + ], + "type": "string" + }, + "task_ids": { + "items": { + "description": "Unique identifier for the task", + "type": "string" + }, + "type": "array" + } + }, + "required": [ + "task_ids" + ], + "type": "object" + }, + "annotations": { + "title": "Run tasks in parallel", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + } + ] + }, + "output": { + "message": { + "id": null, + "role": "assistant", + "created": 1753704331, + "content": [ + { + "type": "toolRequest", + "id": "rnxgf8akg", + "toolCall": { + "status": "success", + "value": { + "name": "weather_extension__get_weather", + "arguments": { + "location": "Berlin, Germany" + } + } + } + } + ] + }, + "usage": { + "model": "llama-3.3-70b-versatile", + "usage": { + "input_tokens": 2815, + "output_tokens": 20, + "total_tokens": 2835 + } + } + } + } +} \ No newline at end of file diff --git a/crates/goose-cli/src/scenario_tests/recordings/groq/what_is_your_name.json b/crates/goose-cli/src/scenario_tests/recordings/groq/what_is_your_name.json new file mode 100644 index 000000000000..672238fbeef5 --- /dev/null +++ b/crates/goose-cli/src/scenario_tests/recordings/groq/what_is_your_name.json @@ -0,0 +1,238 @@ +{ + "1b998117eba523901ae6a4dbf8caa81a95ea88ef7a84d0434c9b41a26164a2b9": { + "input": { + "system": "You are a general-purpose AI agent called Goose, created by Block, the parent company of Square, CashApp, and Tidal. Goose is being developed as an open-source software project.\n\nThe current date is 2025-07-28 12:05:29.\n\nGoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o, claude-3.5-sonnet, o1, llama-3.2, deepseek-r1, etc).\nThese models have varying knowledge cut-off dates depending on when they were trained, but typically it's between 5-10 months prior to the current date.\n\n# Extensions\n\nExtensions allow other applications to provide context to Goose. Extensions connect Goose to different data sources and tools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level problems using the tools in these extensions, and can interact with multiple at once.\nUse the search_available_extensions tool to find additional extensions to enable to help with your task. To enable extensions, use the enable_extension tool and provide the extension_name. You should only enable extensions found from the search_available_extensions tool.\n\n\nBecause you dynamically load extensions, your conversation history may refer\nto interactions with extensions that are not currently active. The currently\nactive extensions are below. Each of these extensions provides tools that are\nin your tool specification.\n\n\n## weather_extension\n\n\n\n\n\n\n\n# Suggestion\n\"\"\n\n\n\n\n# Response Guidelines\n\n- Use Markdown formatting for all responses.\n- Follow best practices for Markdown, including:\n - Using headers for organization.\n - Bullet points for lists.\n - Links formatted correctly, either as linked text (e.g., [this is linked text](https://example.com)) or automatic links using angle brackets (e.g., ).\n- For code examples, use fenced code blocks by placing triple backticks (` ``` `) before and after the code. Include the language identifier after the opening backticks (e.g., ` ```python `) to enable syntax highlighting.\n- Ensure clarity, conciseness, and proper formatting to enhance readability and usability.\n\n# Additional Instructions:\n\nRight now you are *NOT* in the chat only mode and have access to tool use and system.", + "messages": [ + { + "id": null, + "role": "user", + "created": 1753704329, + "content": [ + { + "type": "text", + "text": "what is your name" + } + ] + } + ], + "tools": [ + { + "name": "weather_extension__get_weather", + "description": "Get the weather for a location", + "inputSchema": { + "properties": { + "location": { + "description": "The city and state, e.g. San Francisco, CA", + "type": "string" + } + }, + "required": [ + "location" + ], + "type": "object" + } + }, + { + "name": "platform__search_available_extensions", + "description": "Searches for additional extensions available to help complete tasks.\n Use this tool when you're unable to find a specific feature or functionality you need to complete your task, or when standard approaches aren't working.\n These extensions might provide the exact tools needed to solve your problem.\n If you find a relevant one, consider using your tools to enable it.", + "inputSchema": { + "properties": {}, + "required": [], + "type": "object" + }, + "annotations": { + "title": "Discover extensions", + "readOnlyHint": true, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_extensions", + "description": "Tool to manage extensions and tools in goose context.\n Enable or disable extensions to help complete tasks.\n Enable or disable an extension by providing the extension name.\n ", + "inputSchema": { + "properties": { + "action": { + "description": "The action to perform", + "enum": [ + "enable", + "disable" + ], + "type": "string" + }, + "extension_name": { + "description": "The name of the extension to enable", + "type": "string" + } + }, + "required": [ + "action", + "extension_name" + ], + "type": "object" + }, + "annotations": { + "title": "Enable or disable an extension", + "readOnlyHint": false, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_schedule", + "description": "Manage scheduled recipe execution for this Goose instance.\n\nActions:\n- \"list\": List all scheduled jobs\n- \"create\": Create a new scheduled job from a recipe file\n- \"run_now\": Execute a scheduled job immediately \n- \"pause\": Pause a scheduled job\n- \"unpause\": Resume a paused job\n- \"delete\": Remove a scheduled job\n- \"kill\": Terminate a currently running job\n- \"inspect\": Get details about a running job\n- \"sessions\": List execution history for a job\n- \"session_content\": Get the full content (messages) of a specific session\n", + "inputSchema": { + "properties": { + "action": { + "enum": [ + "list", + "create", + "run_now", + "pause", + "unpause", + "delete", + "kill", + "inspect", + "sessions", + "session_content" + ], + "type": "string" + }, + "cron_expression": { + "description": "A cron expression for create action. Supports both 5-field (minute hour day month weekday) and 6-field (second minute hour day month weekday) formats. 5-field expressions are automatically converted to 6-field by prepending '0' for seconds.", + "type": "string" + }, + "execution_mode": { + "default": "background", + "description": "Execution mode for create action: 'foreground' or 'background'", + "enum": [ + "foreground", + "background" + ], + "type": "string" + }, + "job_id": { + "description": "Job identifier for operations on existing jobs", + "type": "string" + }, + "limit": { + "default": 50, + "description": "Limit for sessions list", + "type": "integer" + }, + "recipe_path": { + "description": "Path to recipe file for create action", + "type": "string" + }, + "session_id": { + "description": "Session identifier for session_content action", + "type": "string" + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "annotations": { + "title": "Manage scheduled recipes", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "dynamic_task__create_task", + "description": "Use this tool to create one or more dynamic tasks from a shared text instruction and varying parameters.How it works:\n - Provide a single text instruction\n - Use the 'task_parameters' field to pass an array of parameter sets\n - Each resulting task will use the same instruction with different parameter values\n This is useful when performing the same operation across many inputs (e.g., getting weather for multiple cities, searching multiple slack channels, iterating through various linear tickets, etc).\n Once created, these tasks should be passed to the 'subagent__execute_task' tool for execution. Tasks can run sequentially or in parallel.\n ---\n What is a 'subagent'?\n A 'subagent' is a stateless sub-process that executes a single task independently. Use subagents when:\n - You want to parallelize similar work across different inputs\n - You are not sure your search or operation will succeed on the first try\n Each subagent receives a task with a defined payload and returns a result, which is not visible to the user unless explicitly summarized by the system.\n ---\n Examples of 'task_parameters' for a single task:\n text_instruction: Search for the config file in the root directory.\n Examples of 'task_parameters' for multiple tasks:\n text_instruction: Get weather for Melbourne.\n text_instruction: Get weather for Los Angeles.\n text_instruction: Get weather for San Francisco.\n ", + "inputSchema": { + "properties": { + "task_parameters": { + "description": "Array of parameter sets for creating tasks. For a single task, provide an array with one element. For multiple tasks, provide an array with multiple elements, each with different parameter values. If there is no parameter set, provide an empty array.", + "items": { + "properties": { + "text_instruction": { + "description": "The text instruction to execute", + "type": "string" + } + }, + "required": [ + "text_instruction" + ], + "type": "object" + }, + "type": "array" + } + }, + "type": "object" + }, + "annotations": { + "title": "Dynamic Task Creation", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + }, + { + "name": "subagent__execute_task", + "description": "Only use the subagent__execute_task tool when you execute sub recipe task or dynamic task.\n EXECUTION STRATEGY DECISION:\n 1. If the tasks are created with execution_mode, use the execution_mode.\n 2. Execute tasks sequentially unless user explicitly requests parallel execution. PARALLEL: User uses keywords like 'parallel', 'simultaneously', 'at the same time', 'concurrently'\n\n IMPLEMENTATION:\n - Sequential execution: Call this tool multiple times, passing exactly ONE task per call\n - Parallel execution: Call this tool once, passing an ARRAY of all tasks\n\n EXAMPLES:\n User Intent Based:\n - User: 'get weather and tell me a joke' → Sequential (2 separate tool calls, 1 task each)\n - User: 'get weather and joke in parallel' → Parallel (1 tool call with array of 2 tasks)\n - User: 'run these simultaneously' → Parallel (1 tool call with task array)\n - User: 'do task A then task B' → Sequential (2 separate tool calls)", + "inputSchema": { + "properties": { + "execution_mode": { + "default": "sequential", + "description": "Execution strategy for multiple tasks. Use 'sequential' (default) unless user explicitly requests parallel execution with words like 'parallel', 'simultaneously', 'at the same time', or 'concurrently'.", + "enum": [ + "sequential", + "parallel" + ], + "type": "string" + }, + "task_ids": { + "items": { + "description": "Unique identifier for the task", + "type": "string" + }, + "type": "array" + } + }, + "required": [ + "task_ids" + ], + "type": "object" + }, + "annotations": { + "title": "Run tasks in parallel", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + } + ] + }, + "output": { + "message": { + "id": null, + "role": "assistant", + "created": 1753704329, + "content": [ + { + "type": "text", + "text": "My name is Goose, and I am a general-purpose AI agent developed by Block, the parent company of Square, CashApp, and Tidal." + } + ] + }, + "usage": { + "model": "llama-3.3-70b-versatile", + "usage": { + "input_tokens": 2809, + "output_tokens": 31, + "total_tokens": 2840 + } + } + } + } +} \ No newline at end of file diff --git a/crates/goose-cli/src/scenario_tests/recordings/openai/image_analysis.json b/crates/goose-cli/src/scenario_tests/recordings/openai/image_analysis.json new file mode 100644 index 000000000000..719347920193 --- /dev/null +++ b/crates/goose-cli/src/scenario_tests/recordings/openai/image_analysis.json @@ -0,0 +1,243 @@ +{ + "c848f22f273e158c32435d3e72cc999c046dc1a9afdc3efda68ff451f833a185": { + "input": { + "system": "You are a general-purpose AI agent called Goose, created by Block, the parent company of Square, CashApp, and Tidal. Goose is being developed as an open-source software project.\n\nThe current date is 2025-07-28 12:05:24.\n\nGoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o, claude-3.5-sonnet, o1, llama-3.2, deepseek-r1, etc).\nThese models have varying knowledge cut-off dates depending on when they were trained, but typically it's between 5-10 months prior to the current date.\n\n# Extensions\n\nExtensions allow other applications to provide context to Goose. Extensions connect Goose to different data sources and tools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level problems using the tools in these extensions, and can interact with multiple at once.\nUse the search_available_extensions tool to find additional extensions to enable to help with your task. To enable extensions, use the enable_extension tool and provide the extension_name. You should only enable extensions found from the search_available_extensions tool.\n\n\nBecause you dynamically load extensions, your conversation history may refer\nto interactions with extensions that are not currently active. The currently\nactive extensions are below. Each of these extensions provides tools that are\nin your tool specification.\n\n\n## weather_extension\n\n\n\n\n\n\n\n# Suggestion\n\"\"\n\n\n\n\n# Response Guidelines\n\n- Use Markdown formatting for all responses.\n- Follow best practices for Markdown, including:\n - Using headers for organization.\n - Bullet points for lists.\n - Links formatted correctly, either as linked text (e.g., [this is linked text](https://example.com)) or automatic links using angle brackets (e.g., ).\n- For code examples, use fenced code blocks by placing triple backticks (` ``` `) before and after the code. Include the language identifier after the opening backticks (e.g., ` ```python `) to enable syntax highlighting.\n- Ensure clarity, conciseness, and proper formatting to enhance readability and usability.\n\n# Additional Instructions:\n\nRight now you are *NOT* in the chat only mode and have access to tool use and system.", + "messages": [ + { + "id": null, + "role": "user", + "created": 1753704324, + "content": [ + { + "type": "text", + "text": "What do you see in this image?" + }, + { + "type": "image", + "data": "/9j/4Q/+RXhpZgAATU0AKgAAAAgABgESAAMAAAABAAEAAAEaAAUAAAABAAAAVgEbAAUAAAABAAAAXgEoAAMAAAABAAIAAAITAAMAAAABAAEAAIdpAAQAAAABAAAAZgAAAAAAAABIAAAAAQAAAEgAAAABAAeQAAAHAAAABDAyMjGRAQAHAAAABAECAwCgAAAHAAAABDAxMDCgAQADAAAAAQABAACgAgAEAAAAAQAAAgCgAwAEAAAAAQAAAgCkBgADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/9sAhAABAQEBAQECAQECAwICAgMEAwMDAwQGBAQEBAQGBwYGBgYGBgcHBwcHBwcHCAgICAgICQkJCQkLCwsLCwsLCwsLAQICAgMDAwUDAwULCAYICwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwv/3QAEACD/wAARCAIAAgADASIAAhEBAxEB/8QBogAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoLEAACAQMDAgQDBQUEBAAAAX0BAgMABBEFEiExQQYTUWEHInEUMoGRoQgjQrHBFVLR8CQzYnKCCQoWFxgZGiUmJygpKjQ1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4eLj5OXm5+jp6vHy8/T19vf4+foBAAMBAQEBAQEBAQEAAAAAAAABAgMEBQYHCAkKCxEAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD8ZJJccH9KqSXBHANabaROBxkYqpLpU+3pivifqx6zZjvPg4qESZHsK0W0m46MKRdLl6DtVewsQU9xHeovPUcVbl0+VT8vaqD2Nz0xTVETJ/PBbOc0pmHY1AthMuKY9lN26U/q47im4z36VHvDdfwpv2OQ9qlWymONwxT9iCZFvB+7UbjPPWtFLKQjG3BFI1jLwMUvZjM6HLNmupsB8oLHrWfDp0wA+Wt+106YNnaaUqZUTo7WNdgxWmqKowtU7WzuMDIrQNjOFHtXM6RpoU7hwowK47U7oJkZrqLyyuApJBzXC6pZXL8Eda1p0TKTOeursbsGs0Xag4zSXNhcKTVAaZc7hXUqRzm2lwHGBxSE/wAQNJaaZMoG7mtH+zpccCpdM0SOenIYcGsuVh1ziuom02TjA4rLfTZcdKaiDiYu/A61B5w6GtF7GRe1Z89pKvOMGtYxI2HibeuSal+0DHBrFcOvAFN8yToRWqgNVDUaZSOfpWbLKOajRHxzUn2d24xxWigHOYN0ok5rIuLRm4Fdi9g/TbUMlkw/hrVIxkrnCJbFPwrYhyg5rV/s9+oGKQ2Mi9uKbRmoEMZORg8VZVt1N+yOO1PWBwQNtRyFJFsSYxg85pzTgcZqi8TAZHFQSM+OlS4DsaJnypqm90cHmqLB+9Upd+aFATiWJ50zTVuxnFYkxkwewqEuwx2+lWoE2R1y3oBFWBdrgdq4rz39elS/aWx83Wo9mM6d7petZs90DwT0rINwdoBqrNK/arjATsXHvM05bw5yT0rAZ3BpvmOD8ta+zMrnWxXpGOfpVj7fjGDXHJI/en+c6j1p+zDnO8i1EDrT5NSDCuB+1MBxTHvZce3tS9kQ5nTvqQyQD0qMaiAPeuM+0P3yKi8+XrS9iQdz/aQxnPFSjUAcHNcKs8mfl7Vbjnk6Gj2I4s7FL7OATjFWYbpWGRXGxzMavRTyAdafs7G0ZHSTXGOR0FUJphWe1w2AT0qCSRj26UuQGyxJclSP6VW+3bckHjtWbMTVB3m69MVtGBm2b41Bh1OBR/ap+6DXKM79s1G3mDFXyCuf/9D84m8OqM7lzVCbw6MFdvWvdG0bnG36VSk0QckpmvmT0bnhx8PRgcjp7UxtBiA+70r2SXRR/dqm+j842/pRoK54tP4eVuFX9Kz28PdcrXtsmlY4IFUZtKXHzDimrE3PFX0Lb0XpVZ9BA7fpXscmlrjgYz0qo+lxnGR+nSi6Fc8iGgg4yOlW18PqFyFr0yLSxzx0p6aYcHHFA7nmp0Veu3p2qEaLyARXqD6co/hzn9Kg/s1UxnvWehXMcNbaHjjHeujtNDTpjjtXRwWSjjFblrbKuO1Gg0zDttERcYFaTaKmOFrq4YUxg96trbxsuay0NOY8zvdEXbjFcdf6GmDlele0XVuuMFevSuXvoUHAFaRaRnJnh13oS7uVFZ40L5h8vA9q9PmtUDdMCoxar0xWlzI4WHRlTjbV7+yUAxiu2jt0HIWrQtUA6VDNYux5rLohZsbcVmz6IeEC/SvV5LReOKoT2S+nSpQ+Y8cm0XsB0rEutFUDbjFexz2XcL17VhXFkh4xWiMmzxW50Yg8DiqH9jkdB7V7Bcacp6D2rPfTUA6VrzGZ5rDpHbb+FaEekhVBxxXfJp6d6kNio6CqUwOG/speMion0pO1ds9qFzVIxhDjrV8wrnHnRwMcZ/Cof7HB7YrttqD7wp2xBzjGBT5gucEdGBbpUJ0lR2rvykZ9KrPCD0ouK55/JpAqo2kDGccCvRTZFjnFMNkOhX+lPmC55lJozDoMYrOm0l+mM169LYgADFZ81gvYUcwHjsmjNu4HT+VVzoj5zXsD6XntTRpIBzT5kSeQL4fYjgCmt4e+UYFe2DSVAHFQyaMCcYFHMB4t/YLdW6U06DnqPwr2N9JVSOOB+FUZdNRMfLT5yWeQyaAeuKiGiHqB0r1htNU9qi/s9OgH0qvaEWPLf7FOKcdBLHdivUf7Nx2qRdMUnOOKXtBWPK10JuhHSn/2AccCvVk01O4p/wDZikdB6Cn7QXKePt4dy3AqsfDRx06V7M2np0xTTYR4246Ue0DlPGR4dK8Ypf7A2jFewf2dHjgVE1imM4FNVB8p5QNGK4wKsJpODyK9IbTlz8tOXTlPAFVzodjz86SRwBUD6Q/TFenLpqkcDikOnDAyKSmhWPKjobMw4qFvD7dxXrR0uPjA/pTTpygfdq1Mix5P/wAI7v4xUi+Gefug16ulkuMgVYjsVJ+7T5wsf//R88l8ITLyw4rNm8JzD7y19ST6EMfdHFZD6CCPu181yHbc+YJPCspX7nFZcvhSboq//qr6kl0FeV2/p0rOfw8o4xQqYrnzC3hC4LZ21XPgqbgla+ohoEZ+UADFPGhqDhgKfsxXPlGXwTM3Rf0qg/gmcn5R0r63bw+hPSqsmgRkdMe1P2YHyK3g+4jHyjP4YqCbwxLxgdK+pp9FiRSAlYVxoQzyMAdqhwC581TeG5B8u2s6Xw7MOcYr6Rl0OEEkrWTPpER5K4qOQZ4JF4dmLfdrctPD0w6rzXqseigOCBzW9Z6KCOmKXINM8wtPDkg+9FWrH4bZuAtezWeiKMLiursfDSHG5R+VCpjufMd14RnZSAnNcjfeDJsH5cfSvt0+FUZMBP0rnbvwlFjlKtUiWz4Yu/CMqNwtYr+GZhkbcY7Yr7RvvCEI58uuWuvCqcgJxQ4E3PlCTRZ4+NuKYNKnJxivo258KpnhKpDwur8FAPwqOUdz5+Ojyn+HFVW0qbONtfS1l4HutRuVsdPt3nmfO1Ixk8dfoB3PQV6npvwX8M6cXj8X3vm3irkWdmwRQw/hkmZSQOgO1Ac8AkjhqFzSnTlLY+BLvTPKj3T4jHqxwKpW/hvUNVfytKtpbx8AhbeNpmIPtGGOPwr9JtL8SeEPCmpR2/gvRNOXCgtK1uGkbkNu8x1kkOFB4MqccccY7+2+LaSxXBtJxFCZT5awT/K2cZztVR0xwM/XihrlOyGBb3kfl7H8EvitfAfY/C2sMW+6psJ0Jx7MgrRT9m745y25uR4O1coP4ltiR/j+nFfovP40uNZd4pAN/wBw7DGo2xryQ2XPOM5ZlHv2HCP4psVRZ7Z4TPG4j8i3MkjggZ2ltw4xjDkBSf4azlUsjeOVxfU/OvxJ8PPFHgwr/wAJlpN5pCvja97byW6N7K8iqp+gJrm5tJKgAAj8K/U/RvjTr+nI2ZJJUnjKNAlwwEuMriSI5TgFfu5ySAcV5n4i+HHwq8fWtze20EXhm/O51uYn8q2yvaa0K7VXPBkjKvkc7ulZLEpbkVMpklemz83LiwcfdGAKyH01/SvbPF/g3VvB2vTeHvEEKxXEQVxsYSRyRPzHJGw4aNx91h6EEBgVHHyWQxu6V1xqXR40oOLszzs6e/cUgsmB6YrtnssHgVAbMA80+ck5UWBGDTxYFR611a2QParUNiueR+lPnKscb/Z7g8CrEeksenSvQbawRgNy1sQaUhOVFO47Hlp0Rvu4/pVdvD7+mK9sXSFOPl61GdHQn5RTvYLHiZ8Pv0xR/YDDtivcF0dc7dv5VJ/Yi9CtHMHKeHnw9IANoNI+gSdMGvd/7GiHG2qk+loOABS5g5TwCfQXj6isqTSHB5XivcbvTx0rn7iwycBeKXMS4nkp0gdMYxUI0fdjjFemy2I9OKbHYKTwPpTUibHncehqeBU50AlsjgDoK9Oi0xX/AIauf2SO60XK5TyddDk6jtxTn0N0GVxXqZ0r5umPSozpuO1O4uU8m/sVy3zVH/Yz4wP5V6k2nNnpVR9OfPApcwcp5k+isMFvpSDRX+6elelLpXPtUw0kjtmjnGonmJ0KQ9OMelTR6DIMYHAr1CLRyR8w4FWotKHGB+lHOHKeVLokgyGWon0WRe1evHS0x8wqhLpy54FHtCnA8nGkv1po0iTPAr0xrAKcAfkKadPAwcc1oqhnynnK6QT0FXoNHYY2rXcf2cchttXIbDjG2n7QnlP/0vrq40HcMBcD6ViXWhDGTx9K9nuLFsdv5Vyl7p7Y5xivBsdljyabS4h8tZb2MAOPSu9vrJv++a5a4h29e1USzn5bKFRvBwaqLBEvU1p3CKFzmscxOzfLQSWHhg2c1lyQ268j0rR+zydGNZl1EwHy9PSpbsUjDuDAvPH4ViSCLngVdubWbJwaxpbaRW+du1ZuQFG7WFRuPeucnZMnH+Fa8sT4+c1hSxYOV6dqych2JolRm64rp9PijHXtXJW6EPxXYaZbMWyTkZpKQ7HZafbKSCMV2un6fHhWY5H0rB020bCknFdrY2bNt5raIWLyWUO30NY99YxAHaK65LGXb8v8qxtR06fHX2rQTPNNRtoQM4HFcdexQ8lq9A1S1mVWJ615pqdvOWIXP5VDZJzN2kOSOwrLhiSSZIoRuZyFVfUngCmahDcKuWNQaFd/2PcXGuTDcbOMeSvPM0h2p06BcFvwrLfQqELtI7u+1bw74XWTSTPtRUZbuSNf3rso9ScJEvuPTjJzXjfjT4zWcDpa6LD+9JYfKM79jMhTgAmLPYZJGM9cDy74gfELTNMtpbWK8WJI2Uu8eMxxjkYOF+ZuOvQfQmvF9I123v8AVBcWiRxS3kywwfxHbEoO9i3zbRnjH3sjNXUlyo9mlCysj3fRNW1nTI0SWY3Gogeb5QO2zs0KvGpkWIDcRu4Hr8o/iNeuxWylks9Ku5ZXGWkcKI1xyQu0bFTJ5GOdvXOQK+bPDvitvDkMMBm2Btyt5e5nO48ktxjnPzdPpXb2/jw/b1jvBieQqM78kFwemMAKOBjj0PWuCpVud9KCR9CXHgu11N0DiK3nCIpVCVjR84BUBVI6Zct2AGOc1yfiBbjTdJ8y0nuGhVCdzQqi7Aed0YAKDPA+bOMkYrd8PeObyfR/LiuGt+Nu9juO9VGSykYIUHA5xkEk8DHk3jvxR4q8SeHdU1Lwh4d13XNB0+b/AImGr2lnK9hby5+ZTOiiN5FIwVQl14JVVK1wVKmmr0O2MOyOFvPG/wDZ+qLBqNo0wLqTv5USZwDhQ8w2/dzg8YAOKXSfiFJa3fk2sMbQp8qILuSWWNg2UktpZNkgU9Cr71G7aRtwa+Qk+KOleJohdWU/k5JBjeRj5bDgrIMRSKQRghvmU9emK7Lwzq194s8QhiLucodv2mDEshb7rDbKHB4+8rbeMGokhKSZ9ueK7CP4l+FILa9mU6rCxfTJGXyhIWyZ4HBCqm9tu3k4kA7FjXyCyLtDY7dMY/T+lfSfhG9+y2sqyLJHcjYzwqm1G8vOJEjBBSUZJLKenGDwK89+K2im28UvqkSIkepL9oIiBCCU/wCswDyAxw49d3Htrg63/LtnkZzhFZV4ryf6f5Hj7RIBiovJXGK1WtWXPFQ+W3GBjFehc+dsVxGp+UCr8FspxUMcbbsVsWsTD3J4qlKw0i1DAoIAH6V0drbDr0rNt4X+XiuktFKEbhjFacwyZLBD/DU4swOCPyq+kqAcipGlUH5eaOYZnpYL/d/CpUs07AVb35HzDj2qRHB4PtTUhFF7FdvPWse5s0CkseRXRSzrg4xxXP31wgyaTYXOUv7cL14rlriNOgrdv5DJkrXPzQzFjgVNxNmVJEM8D8KWJVBGRV8Wlwx4StG30y5Zs+X0qkSQW0KnoOK2YrQBQAK29P0SVhzGcV0K6C7DIQ00UcI1jhQcflVN7IDg16DNpLRj7rZFY8ungdjTA482ijiojZjpXVfYB0ZcYp66dGx5FFho5VLNRSm0AGMZFdjFpkZ659qt/wBkK3HpSK0OEFsOrCp4rY4rtG0KP+A4HWnxeHz2J9uPSkxnESWmFrJltRnOOK9Mn0R1Hy8/pWPcaPKGC7KgbR579m546CrP2MYHy9RXWJpM38KGrY0h9mdlbRMWcOlmN2FWriWmFxium/smXpjj6YqxHpbhenFAj//T/UW50pF6MK5C90kkMYz+Ve73GlJg8VzN1pMQzgYHpXkSpHUmfN2raVcqSUNcDe6dJkjNfTuo6UpHC/pXE3eiKx+59OKz5QPnuXTXGcZpkGnSFh6DgV7e+i7eQB+VV00Urx5Y9qOUk8k/s8jrxWXeafGycHnoO1e6/wBhgjlf0rKu9BiUfdBzScBnznfaeckdu3auXudNcjOOK9/1LR1UHCdq46fRn3Y28e1YygUeOy6YzfeFY82i7zgA165c6W8ZLMMViSW3z5XmsnALnAWmgNuB5rudJ0CYEbAeK2bG0ywUY/KvQ9Js1fjGKqNMZl6Zos6hRtyK9B03SJguQp//AFVqaZacgYr0HT7Ln7v5VtGCQHFrp0ioCynisa/tXwQUr3JdKDJkr09qx9Q0VSh+Xr7VYHyzrkbDPy15fqZC5G3pX074k8PqEJGOK8e1rRI+V9v5VDiQ0eCX8qJlSnFfLfxx8V2vh/S20ueQI2oRZxz8qRbxuOBgZLHA/i29MCvsHWdIiGW/u+or5u0r9mvxd8cvj5H44VYLfwj4eu00++ubm5WCN54o1fy40IZpHDsCQq44wSM4OVVqmuZ7Hbl1GVaqqcFqfkn49+JV+NbtrRlTybf5ywKnzSp+YgrxyRgntnA4FUND+IINtbOjAtA775FYqdozntwMnPOMBRjiv0o+NH7CVrrcI0nQYRbO10IvtNpIC0cWMgIkgZW3/NknG3j0rxHUP2H/ABH9kj0/w35SXKtEyRzSAF1Aw5OASVHACgD5iTzwK82ebYWUfjR9Qsgx0Zfw39x4pdfFzStOsLOwsrgo7MTKqJ2O35CScbeAMelbWifFGI6rHe6lMPLWEnbuyIwT15LYI9RjG72qj+0X+yd4s+DHgxvGmqjEEMm6QIu0MJV3bhubIii4TqS2B0+7XifgLTtF1O5tvN+bKYHHb35+vv04rOFWlVhz03dGVfDVsPU9nWjZn03L8VPFnjnUtL8NaHNe2ljcXEX2u4VQZTbQ7pphCh4LeUjbP4Q2CQw4p3xM/wCCuviL/hbK6d4c8a614e8B+EZ303RvCugSfZrdbayBh2TBsxTG4O8O8pZH8xnOGCsvs+k+HtM0HV9G1d7SUwq6I7soC/N8jqCemUZlB+706CviH4xf8EsoY/ixceKPDviU/wDCMX0094YV06Rr5Hc7/KiUlYCXcts82RPK4DCRBvZ4GrQp4n2tZbLTS9u/z8+2nUxx+HxFSgqdHvr0/peXoeofD7wL4I+L2v3vin4RNexeG9WVLixi1QQperDLPLGkc3kl4yyrGF3qxDY3fxYH6r/Bb9mTSdPS1mvrfyjGm11twVXKDaGGNpPPGR0659PCP2XfgzrmgXUUOmWttp2j28cFtBYo7TvbWtmgRFY7MuwOXdyRl2bHYV+rWiWmtSiCDTlfAIXGNroFVccYHOM56dcVw15805cvw9PQ9GhS5YR5tzMvvgZ4G1O0/s8wwldm1JGIkKkjgfM24hD0Dc88e3xZ8cvhFq3hWOKaYfabZWzBcoSybDw8WTnlWwy552kg5Ir9KpNVls7dfImVyz4MR2/cPA+6doBGOvGf05LVrTwv478PSeFPFjxJA0TLKzKyzxtzsaPdwpQ8jCrz1O01hTl7Oan2KxND21GVNdV/wx+M8miIuDgGq58PxtyF9vSvX/E/g/UvCmuXXhvWF/0izkMTkDCtjo6j+6y4ZfY1hx2WCFI+lfSRSauj4CUHF2ZwNv4bjyAF+ldXp3hOKTGE/Cuws7FCw4ru9J0xHxtAqlFBY4Sy8ERPj5AMV0EfgNAB8v5V7Tp+gLgbQBXSx6CoByPpWiggPnKXwZGg+7WRN4V2DHUfSvp650KLqyj0rmbnQ0T+Cm6SGfOzaBtJx9KqNoLY3mvd5tDjDbsVUfR0zgD9KnkEeEzaDHGuCTzXOXuix8jca+ibnSYmXaRg/SuK1LSE6ipcRWPn670lVzzWX/Z53fL0r1TUNKjU81y8lmsfHX6UlETOehsCOBW9Y6bLvGO1WraELjdXZaVBGZF4rRREXNF0h5RtxXcwaE5Ubl/wrovD+mxMgO0flXpFro8WASMiqUTRLQ8Tn0Jtv3a5ubQj3X9K+lLvQYimQv6Vzs2hhWzj8K15CGeADw+M5Knj2qX/AIRzkBh9OK9y/slEJ4qSPS4ccDNS4oaR4mnhhCOV/SrK+GE2j5OntXt0ekxnkdu2Ks/2VF6Co5Uacp4Z/wAI2nGE/TFKvh9BgHt7V7edIjx8lB0aILtxUOJSPBpND28ovP0rIuND3HaBgemK+iJtFg9BXNX+jocdqSiDZ4MNEYfKOhqcaM+B7fyr1KTRABtHQ1XOkFRjOK1UTFo8uOlYHFEej5PSu/fTMMSG/AVHb6e2/GeD7fypNDsf/9T91rmwBBGK5K90kDI9K9WuYJCNuK5q4tH5PPFcMomyZ5DfaWN1YEmkjduxwK9Xu7NupFc/JYlDtI61lyFHmsujryDjIqg+ljIAXpXdzweWSSKzJBs4C9afKgOYTSl7D9Kp3WkIRwK7SOP+6KbPDLs+UD8qLIDxnUtFTBIXp7Vxk+mRISCte4X9nK+QBXLXWhFm+X8qxkho8P1PTY9uNtckdH8x8Lj0zivdtR0E7duPwrmZdFaNxgVHKBw9hoSKQSgPpXpeh6FAVHy9eKSz0glxjivQ9IsAf8KrlQE2m6BbqAcYxXeadpFqqLkU3TrRABkf4V3FlAi4wKaRRVg0y1CgEflVG90i1K7wvXtXdRRLtxiqF7b7gflq1EVzwrXtDtyrbVrwPxNoKoW2AV9a6tYSFWAXArxzXtILg5WnyEHxtr2kyJvwKoaleXnhL4O2HhvRk8qGXU9R1K5JJy66hfTNtU8YYoQfbgCvaPEehiFWklGFXk/QV5Z8fILrwzoGi+DoPnu0Q3lzHnHzyAbE6D/VptHbGG+teHn0ZOgox6n2PAygsc5z6L+vyPIXvdWvdVSSyGfLcbEcgkjbtXHXlRiptGt3nvV1G4Agk3/TeFwM8DoSMgVmC4j8EaTDol60kOrap8wVTloY3HfoRn06AD8K3JodWtp4bmXc8SDah9gNuPQgc1+MZ5iIYaThf18j+gsIva01JR9DxT9u911/9lnW5tYt2fTdFeG+mAVGI8nmMsG5xvCbduMNg+1fhx4A8WWNjqzSw26+QPlVZOecnHzcc8Y96/e/4tpJqfwk8Z+EEhVv7V0S+DbsH5liJXHYY6/yr+a3wajXGqSxjKlDk56grwM59SOmOtfU+H+PWKy+pH+WTR+ZeIOH9jjaU11j+R+5Pws+Iui3unRvq1pHeRsFfy5HO0bMAZUcD0Ax/gfs/wALavceI9KMM8QMPEgjkYLtGMYXcoAG35iVH06nH5TfA7w/r1xCl20yWdug3uduDxgkfUdAMfjX6h/D3UNSt9OeGaXzY9hBBHlou4jLDDH0yCPwxX0tSNnofM0ZaanceFUsrXWFg0tY1s4oQYwTkF8j5mPOQuABnAzxjFe13XiKO3eKJYQZ/M3gynbtLAHACkg8kc5xgdeteRaEJ9clns7G4jit2iLRbRtRN2CVbkL82cYxj8c1zusa9ptptL/vJkaNS42BfMUFl+RT1AJw6H6+lZNmp9GaXqz6jaTm4YJM7qzI2MsABk7SAeAPl4yB0zjJ5XxP5k8IutBnkbyZd8camOJGGfmKupYrkfxBVII+bgc+TaX4vm1myi+zfMHwfu4IbryTkYC8gr2PcdOwmnhgsmvy7ossib2hfoQmSpDYUtwOuHBIxXPOZrGBwHxk0seItPs/FcX2hrq1YWVybhVWXYwLR7tihSUYMhIyDkYwMAfPbaTc+n5V9TXGraprbX2iazDHKt1Buivk2upe32yRhiAsiF0GB5gIJ6Ed/OJtGZDkCvocoqe0oW7aHx2fUPZ4nmWzX/APPbHQ5ycgenavQNE0eZdo29PSrtnZujAKv0ruNJi2bfl716VjxzR0rR59oBOK6iPR5wnBNbWk7GwAp4rt7a2DR4xWsUUkeTXGj3JTIya5qbSLrPzKa+gZtMcpjFc7caXyBinYdjxf/hGJZsZBAqeLwccYwfXpXrsdkiHla0UtodvKinykHhF14PPHyVwuq+FmQFWQ47DFfVs8UQXbt6VzN9YwzLt2c/SplBAonxXqnhtF3EjH4VwVzo8UbbMfpjivsbWdBUt9wV5nqOgwIxYx8VEYETR4Pa6XaMQrL7V6Hofh6z3KdnFb9vp1tv2iID/61eiaBpcEpB2DitlTIRd8PaHahV7V6Ta6PaDADgHvWzoWhW2wLt/SvR7Lw1augKrQom6PIL3Sk2bQa5WfS5VPDV9BXnhaIrwhIrlLnwvbq2Chq0iWjxR9KuD93H4ihNIuOBtX8q9jXw1Dj5Vq+nh6HOCvSk4jR4+uluF+dR+FE2kqPvL0r1/+xYwMYqneaGn8Pas3E0R401gnoag+xqDxXpFx4fOfpWe+hygYA6Vm0Wjzqe32r8o/SuTvomXlR0r2O50eTHK1y15oknRR+OKIomSPKnSRhj8KhML4LentXo6aGzNgL+lPk8PMF4jxit+XQwPI3tjkY71Lb2bI/wA4yO1d5LoTJIB5fGanh0dtwJTtWEl2N4x0P//V/okuVBGFFc/NDv5OBiu5uLddtYk8KAZxWLiXc4K5g5PSudvIyDnH0rvLqFQTkVzl1Co56Vk4D5jzm8WROAM1hyxSE5K49q724gTPrWUtsjNwuKlxGpHPR2LMoJFW/sPy9K6eLT92AvFWm0xTnArNotM88uNOycise50wjPy/lXps1oVyNtYVzZOR0x6VLiB5HqOmS5wtcff6bKp3IK9d1GwuR26dK4W8sbtWIwaiwjjYre5R+ld/pEE2AAOnHSqVrZz54B9K9A0nTJwAKqwF/T4WwC4xXZ2ka4BxxTtP0Uj8K7Oy0XjGP8iixaMNV24IHb6VTvJmHG3iu+GiFh0rNutDJUgjHatIxJkeM6tesinaucdq8g1vUGUsuP0r6M1bQwN2FrxjxDoW5mVEGewrSxmeHJdWX2xtW1ZEe0sMSGJ2CrLJyY4zn+FiuX9I1b2r4n+KXjo2WvHxy7y6hfyqfIe4haBLq4dVZ38hiGEMJJxvGWIHbaB9zeHPsnim8u/NtA8FjqDWNqrYEckqBmedvoqjaOgBSvzy/aG8U+HvhXc+Kfi14gsm1C38G2Tz29nIdqXd07pHbW+8biqS3Uy73I+RFbIr814jzydStDB4T7XXsv8AhtvkfuPBnCXsKbr4pe8um/orLtt9/kZXwP8Agx4n1rxDfeKPG8r3F/cAzv5sgec7hyWGeMLz6Ae1fWegfDxri8ubCVD5dnkRf3scdc+9fFn/AATx8OfGFLvXPj5+0xcsNWZ2uzapCtvHEs6t5MHk4Hlk7lKoxLiMZk+bNfbfh74tWWmqb+5O7zi+85wCW5PH8hX5nntHDUv3N1pe7ve/nsj9Hpxrqzt0WlkreWl0fMXxKuI7rxa2haDErTbmt8Yyp3KUbI9Oea/lphsdQ0rx1e2NkAq295La9N214WKMvGfu4K49B09P6jL7UrE+ObnXYfld33xhcA5PT8q/Br9tz4CeOP2fviZd/GnR7NbXRfFFxLcCSJAbeK4eQEjJ4BkkZiO+XOOOK6/CnMKca+IwcnrOzj203/T7j47xKwM5YejiorSG/o7H058II9Q/ss3bAkIm3YwVCU6ckMFGOOvPvX1loniyDR5rgPbvmNUSLkpGXB+X7uQNp4yQQPfkV+Mvw9+OUV3DGkkxk8vqrnEg456d+fTnGPQ19seBfio99KtzaOUM6ABSMr8o64XDcn1JGevrX6tiKTi7NH5hh6qktD9R/BPxVsh4eGnsqyRbCN7kA7l5UhtiEsuMr8/Poelcr4s8WW13px1FpI2ETAtuYq0UhHy7ccKM4z1GWI+Uivkex8QXUNzJNDIZBKhB3PuCnnayhuMZB+UYIOQQetU7/wAdGDRp1e5aON22FFJCM5PyffP3d2B7dOlcFtdDu59D7N0jVb+DUY5njVbWZFEqvjCgg7Wzgk4O8HaBk9s8D3Q+M7ax0uSF/wB9FcRwD98275VCBCVYdArhSQpUg525HP5oeB/iDLbWi67HGb6D7kse/aSm0noNrfLjg9M8dq9R8K6lo/i3X9Q+Gvj3z10u/V4QY5TFIPusGibHyuu1WKZUEj1OK5KqOik10PqHwRYQw+K1nsrZ9N+0PMEgWTem4Z80KvzBfv4+Q7cAZVa9Bn09QM+grwP4IWvjXwt8V5/h54maS702+lkvtEvWY+Z5kavE4+bBCzqjggfxYHXk/Ud7od4p3RqdtfQ8PfBU+R8vxLpUp+jMGx0wM2eK9C0XRFDDjj3rnrHTr6PA28V6Ho9tcqRkEV7vKfOo7PTNGhVAxUV3NjpduBtPtiuf0uKUKuAcV2tpDKcZ47Vdi0RDRLI/KcVmTeHrXNdrFZnABFSjS1k6ZquUDzkeGbdz8pApf+EXhVcKcV6cnh5m7/SpP+EckUFg351ookHk03haFlx3rJuvDEWOa9pn8PuAWRqxJ9EmCkHPFRKK7DR896p4VXoB9K871Hwrb4/eda+jdW0iVFOfoK87vdCZzsP4Y4pRgiajPFE8I2vmgLjr9OK77w/4atgy8LXWQeE0Zv8AOK7vQPCMW4ba6OQxRq+HfDMSxqU7dq9JstBhjQbhj8K0dD8OJEgVR09K9Dt9AiWPDdqjl7HTHY8wudHhVRgDmuUn0OJjjGK9uuPDcbKdua5m58LndhCc00hSR5JNpCKAQv6VANGjTqR+Verr4dcYHrU39hLkhVoaEjxqXSYcAkdPasmbRoXOele2voQ6bcVVbw3HjAXmsnEs+frrRgp+Xp1FZLadIo6c+mK+hZvDFuOq/nWLNoMKZ2ris3AuLPCJbFm+Up+dY9xYpnlcV7ldaasa4Kg1z13psPQKKqCJkeRRabASeAK010eB15rt47G2R8COtmCwt+pjx7V1KJgeNz6BAXKkcCp7fw9bsN23mvZf7Kt2OQgpY9KtwPLxxWEoG0Wf/9b+k+UjGBWPc7B0Fa5iJqnJbnHX8KLBc4+8MIJrnLsRtnqPau6m04vk+ntWTNpQPNTZAcDJboTt/So0sICd1ddNpTZNV00zj0+lS4AmZQto1p0sQj4rcTTRjnoOKSTTMis3AtM4+4idR/hWHdwOoyOfau9k03OOPyqm2nKcgiocCrnk90Jic9qxpYAxO9K9cudKVlCkYrEm0lV+8KXIK5wtpZ269V/Ku30uOzXb2/Co00wA4ArTtrPn5Vxily2BM6/TVscD5q7CxhtRjmuHtLbYFH+eK6y1TaASelTYu518FlCV56VFeWVrsz0x2qlDOwGc8US3O47cdeBit40yHI43WLOAocD6f/qr518R3emR3E+nqv2i7wYwqybVjzwSSOSw7KvA7ntUnj/4u3eras3h/wAETQxwpIYGumbBlkHUR/7I6ZHX2FcANKvdEXzbyVUMg3BwuR8p5z2yMdPpXiZpmKpxcKb16n3HC2QQrVY1sQv8Mf6/I5HUdC0/Q9EtPDvhWN41sC0nmAdXbk8n+JjjK8Er9BXzNffCHxB4i03ULazigW5uVtnX7WFkjjkguoZRMc5H7v5mB9QD2r6t03xpNrTONFje4hjJxMyDZkcZAbsPWuI8S+NNMs/tHiXWrmFbWzX53UbI5G6ZJ/i9B27CvyXHYGDxX1u/S34W0+R/QOErvD01Bbqz+e55JafDyxsNJtvCy37f2SJnmImUrNd3MpzLPIx53Ofup/CoA9q474iX37P3gCyUeMNQtrVolMnkiXzJ2VBy/lr6ds4x9KydU8IftB/tHNLr1lfyeBfCreYsNzLaE6hKN21nW3k2GCMKOGfDseRtX73g2vfDD9mf4TiS08R6/d6vPGySXO+5aNZZ05UuY/lPJLbDu5I9BjhlkuGmuevJRv3V38l08vyPGxmc4jmaoRcmvNJff/wDw7xx+2f4X+H+kSeK/h14J1DxBZ+e0UVwECK5EZlwkkrJGcIpdirMqj5c54r8of2z/wBsD4w/tNaNovw31zw3D4W8O6pv1OSzZy120tmA0asAV8sBiCQRyVHQDn9HPjB+1j4c8M3El78MbLTdKj2+UbprZGu5AOSvn3OZGBOflUAD16GvxX/aj+OWvfF/4gafrNxK850oPGHiBm2tIQThgccBQOPTvX1nDeT4KhVU8PS1X2np06JW+X5n53xLm+Lq0nSrVVZ291dvN/0vI8i+HeoXPh5XTSodtxbkEzAbvLJIx0z1HB4ww4I4Ffa/hHVIoYomvGx5HKtHz8j9SBz97odvB4IxytfHul/ECDSDdLcaMyPJEyt5aqNxbguVbGD03AYBxnrWW/xL1cyn+z28kEgA5AK46YC8DHbivra9KdR6I+Lo1I01a5+kkHxHtrkNZ6nOlosP71Wckbto/gwMcg47D1wa8p1j4z22p6k0OmszW0Rkz5mDvGMDIPJ2r0+nBr4Z1jxxrAtkmllFw24AHPc9SO3+cVqQ64nipra20dm+0SZWQY+Zx6cdfQDvXOsDbVmzxl9Efcdr8XLTwHo41LVgb20tjF58kIBC24YKxcdWAypOPmFdt8W/i7f+AdZ8HftJfDa9i1nwXr00djqMcREsENyoz5cqZ3AsBtHOTjGc4FfG3wh8TaNpPxjh+GnxIto73RdfVITlvlQzDyzxjkBsZU4wPfgbPw+8E+I9B8M/G/8AZGeOGWTR9OufEVtE6t5hl0lEuPkJIZZI4QAo537cFSDwvqdNS97y9HF6X8uVlrFT5bQ+Xk1rb0aP6Df2b74XnxB0Gw0zVxq+j2drLr/h1bs+bcr4e197WXaJDtYmwv1aIHGY4SFbmv0/kh02U5ki69q/Ab9ljxQdd+I37N3j/wAJTxrFeaL4hs7nbnyjcaffxx3YXd0SZZVfYcgfe+bg1/Q3LpQDsAg2it+H6bhKrFrXT/25focnEU1NUZR21/T9DnI9M0oD7orf0/TtPzsVR+VTvo25chK2NO0UtKOo6V9JynzNzotL0mzLABR+Vd9a6Ja4A2jHpWTpekvHivQtOs5GAO3pV8qBMyf7IhT5REMVMunLFjEYGK7BdMmZc4qb+yZlAGzipsWcxHAw4MY9qmaAlfliUCunXTXK/cIqX+zZV/h6U0gZws+lSMARGK5660W7IJAx7V6tcafKByOn4VzF5ayRg5OKmSHE8b1Lw3P1b16Vwt/oLRsSq9PavX9TkmjzsJwK871S8uz91j74pRRMzlI9OuN4GCO3Suy0TT7gOuQcfSubSW7Zx855/OvQNFF44XnpWjIiep6DpcroNw6Y7V3sWkqYgpFcloRuyo3Z4xXfRG5VQw5FZm6MmXTMDGOnpXOS2GJAu3pXaTfaCfSs8W9z5nQVUUKTMGPTwE+ZRUT2kYH3OvpXaR28nAIBoa2Vv4cVdiTziWwDHCiof7NXHtXoh0rcc4qpJpAA5FZ8pZ59JpMZwuBisW70Ndvb+lekz6Ww6H6VgXVhLghs4qXEEeV3+iRn73AHSuUutAjlPBxXrVxpcgGQKx5NHY84IojAJM8oTw2oOFrfsvD8gRVxxXVDSHBx0rWt9NuEHGeOlb20MTipvDUnTFS23hwK2cfQV6A1hcDrmpItNuO4/CspGsUf/9f+lTejd8VGWTHX8KzTI3OPSmGVjz6UNCTLkjIe9Zs20Dg1KzYHFULhmbk1FhlOZ8deapG4I6/pRc4Iz6VnHOcGrsK5ejnLHA6VZ+YjioLcY4bmtLy94xU8ozMlX26VnyliPkG2ugaIkcdKga33cg5xUyQzi7kSoCQf0rnJxPzjt2xXpk1oG4IrBuLEPxUgzio4p8jGa3rO1uGOcVqQ2jBhmuns4RgEYpMaRQsrKXjIrpreyfGAKvWvlY5rfhMXGOKlFHPmycD7teBftK+Nbr4a/CDVfEdiuJ5I2t0bONm5HZj9dqnH19q+qv3G0Ia8a+N/wm0b40/DHVvhtqsv2T+0Yj9muh/y7XSqRDL7qpOHXoyFhSrc7pSVL4raGmH5I1YOp8N1f0Pwt0rxwq3lmZZiVtjv4Pfufz/wr7NsvEkPivw7G7zFYhImVz8oOO5PsAfQYr8Gbn4oeLvhh45f4S/E6wm0nxnYOYbvRZEY3fmIdhMUeA80LsP3MsalJVwyEgiv0C+F/wANP2z/AI7WUGmeF/Dk/gnw/IN0mt+J4pbCL0zDYMFvblh2QxwxHvKMAV+UUqGMq1ZQhSbb3X+fY/Z6GNwuH5atWooxjs/8rb/I9e+Ovx68E+BNL+xarcRxafAm5Yojgl0/iIHZeMZ4HXtX5waP+1B8bf2ifEX9k/st6HqHij+zziKfTLU3ghmTH8Sf6NE+04D3MkYGcrjqP2e+G/8AwTI/Zj8Jzx+IvipYyfE3X1PmNd+Jv31ksjEEmDTgfsqYI+VpRPKB1evu2Kxt7DTYtI0+KO3tIAFjt4UWKFFHACxoFQY9lr6GjwZKsk8ZUt/dj/n/AJHl5n4lwh+7y+lf+9LT7l2+5+h+BPhz9lb/AIKXfGRlHxd8TWPgPS5Qd32y9Oq6njj5WtLErAD25vMDuDX0v4Z/4Ja/s/Wdq0PxD1bxR4wnJ3GS41P+ylAxjaq6akD7OuA0zdec4Ffqk1mzsAFH5VE+nMeOK+gwnDOXYbWnRV+71f4nw2N4uzTFfHWaXaPu/kfzlf8ABTv/AIJ//sY/Cf8AZvufib4W8DW+m6xHqGnWUNzBc3ktxIJ5dpQeZcOGyv3iVPyjPGM1/KFq1n4nhjeBb5442WdzGJt8MMcL7TGSB8xU4Q44DEjsa/st/wCC1l/eab4O8AWF+yQaPFe317cyth5Xn8oW8MFtF1M8glcmTG2KBZMldwr+RP4jvaeJ73SfCnh1xajxTcxQwrjH2XR7ZtyN/wBtyHuGbqy7Aa1nCKquKWit6L+v0OSnOToqUnq/+GPmu/1LXLx0/tm5kd2RSgbHKnoeB/8AXxWjDelLowq/ysu7n1pt1FNrWvajHYxmaHSgxBxwFLYX9Bx9KZa6Ld6p4fXxDZxnbaq0kx9FU88e1U4r0EmzT1e6u9IfFyD5KMFkkxwPM+77Yz3rqPGemXHw38ReHvFNkzx6bdfLuB+VJUIJwR2OMj0xWvrEWmp4et7fVsnStbsmVJ8bvJntmwc+mOq9MjpxWjoOt2XxE/Zb1nQNVZftPh7UdPkgbHa4l8pvp1zkdjWC2Ta02fz0/Bm1tXHra6+Wv5HpHx9s7Hwh8SPBnxjtv3mk+KrPzpwcFRcWu2C62rjGNrRuAON2eOa9r/a41rUfhH+0t4G/aZ+GFzJHf+MNLt9RngT54pLy2jW1nU5O147hcKydFycHJBHzn8aPCHjXTvhD4J+E+rI8uq6PLq+o6SxPL2beS0sG3uwKK6YGNoI4qx8ZfGMHxN/Zp+DXiDSov+JlocutaFcyRNl4zHNbz2qHgBWaIuy9c1zQo8zpPdWlB+mtvyOmdXlVRbP3ZLyel/zP3j/Ys8LeD5vjVq3gPwywh0XT9V07xrolqcPCumeLbJoNludxYxpN5YxhQoIBGVFf0Hf2LcysSDX4cf8ABO7wt4f8U6h8Nvi/pqStNqOgR2zGKQCOO0lKsEeDgj7PdWTKjLwiuoxg5r+giEWpbc/Ujp6VOQpP20vNL7lqRn7/AIUfJ29On4afI5mz8PTORk11th4WXOWPNa9h9kVueK7CyNkRlele/ZHgIx7Pw+6fLzxXYadpLqB83StG3jtSA4Jro7JIF46UFJFe204IMk1opp47mtJIYyPk6CrKRoAD/KgoyF04LVkWAA6dBW/FCD2xVtLWIjkfSmBwl3p0bKecVw2paTE4+9x2Fe4TaZCV2kVzN9o0bLnpT5Sbnz5feHYCCOce3FcLd+FLR5sDPNfR17ogOcc+lcvPovzYOAKcYENnjtp4PtFIwCfwrvtK8K28e1Rnj2rpodJdGGNtdXYWM6rjqDVSSsKI/StDiVcKOOK6+PRQI+tWLC1nCjPFdTFa5XnisbI2RyDeH1k+7Vf/AIRzHPIrvTb4+70pphdehxTSsM4Y+H/K5BNRrozqeAea7VxKFCCs2WWVMhT0pMRzbaRIPuis2bSHHqK683s44GOKrTXEjD5gKFErmR51c6dOrHbxWFNZTv0zxXo0rMe1ZkqqqkAYo5SbnnMtoScMOlZUtoR716JPFGTt9KzZLOFuc9PanGImzhI7Nozgj9K04IDgAoBXQi1ROCKtpbQhtpGM1oSjBijA52/pUvkqzcLjFdJHbwcDB/Kr62cZwAuM1k4miZ//0P6OglIFGemKZ5uO1NMihs1q4mCkSMMj6VWliVhn/OKc0gPFRly3FTyF85QlteelMFoOoqy0hJ5FV2uSowKfKLmLMcAHGac21MetZU19In41Sk1E9D2pqmL2iRti4iXmnrcwr36dK5V7lwflqLz39afsbk+3R1E93DjP8qx5rqM/KP0rKeeVuegqlIX3dMVPsR+2OgSVSwxzWxAwPpXGQtLkZyK6C03AfNxij2Y1UOjjY8AVdil2jaazoHUqCePar6BM88VDgiuc1I5QB0qNi2CoqHfwCO9I0mDg0rWK5hsk9xHh4nZGRQqsvDKo7BhyB7A4rlL12klLucuepPJP1NdDN8y1zN1ESTxjmtYoyk7GXLIozng1Qe6tk71amtJD3rDmsJMnHFXymXMW2vYMcHFMa7tz3/Ks0WUhPtT001mdY+u4gcdeahxKjI/mI/4LGeJ7vxh8fp4vHBaTwn4JsY0SxhkAdo3AeQ4XcfN1KY/ZIVwpWGKeQEHbX88fjm6PhLxDqevapZQXOvpZMdWvoflgtZrhPlgiXoscKDyo1HJCFj7/ALf/ALaPiHW/iF+0F4pNnFZ3UtrrU1zbpnzbWCXP2b7XM3AeUQoltAoACoj7SQxY/i54huNGFxB8Opv+JjoOhzXeravf3ACnU7+ZsRRybcArny0wuQEQx4618vGfNOT/AKt/XQ+o5OWnFLseIfD3wvq+n+Dxr+oRtB/ac32ht+ATG7BI/lOPvDLDrx6V2/gvwnFoGv32g3h26XrKyW67hzG0iEqPfOQQPaui8TWXizW9Y06TUdsVvO0LQQuoR2VYxuaRP+WZbPC+46Vc8OQWnjbxJfeHdTR45rZ8RmNynkuFLB+Bgr2z2AP4KrNtN/0v+GKpQSsuxwvwQbTm8Gf8Iv41fCtqZ0meNxhY5dhaIjpndgrwQegr5p8V6P4r+CPinWfAN4zpDNOkUnGBNFA4licex+UjHTp7V7bqWiCH4Eah47imEeoR3aRzsfl82S1uMB07bsL79cV6d8V/Bv8Aw0L8DLX406M6jW/Dlqyaom/74hQuz4z1KKGA/DHet6dRQqXl8Ldn5Nbf16GU6blTSj8SV16Hpf7RnxD1W5+EPwf+Mfgy8X7fo93cw2rMmN+6GNghzjKnZscd844ry7xfY2/w/wD+Fk+AvB1rHfaJcWGk+LLG1JBk06cSRsksRxgRxJO8MmAN0DKCw25OLo+uaN44/Ys1Tw9fXJiu/CmpWGo20QKjebiQWcmOMkbJCfYj06ejWMV1ffGv4Y2mvJ5lp8RPBdvoV+0ZKvLFiSB2ULypJjQZHoeOeOanajDke0eb8Gpflc6J/vJKS3ly/K6cfzsf0if8EpPBx0rwLoE8M0d3p7afq9/pzx5jMceqTWdyyNGc4KPLIo54O7AxX7LC2m6rxX5V/wDBHrQdUs/2Z/D+p6lI10U0WCDzi+/dIbmcSKPTYYdvPOAOmK/X+F37rmujJsO/q7k93KX52/Q4c4rJ4my2UYr8EY9vFehwuOK73SorrAzUNtJuOFj6dK7rSo+h8r8q9VUmeXzou6ba3BVcEiuusbNmODmrGn7dv+rxXUWXlqR8uKXIzRNFa00tuh6VeTTXFb0EsQAFXjLF0U/pRYNDl1sWX5h0pFheMgeldESh4qo0eH4qkGhS8tyPSsa9tm2nHNbzJODntWXcrMRT1CxwV/DIudv6Vyz2chbbzkV315DcnOBmsIwXSv0+lOKIZh21jPvGc4rtdO06UqM1UgjuA+3b9K6G2eVRyMUSTCNjorGxkUAVtxxMmR0rIs5XPB4rVM7447VnyM0uhXVg22qb+aRgj8MVZDlutWYhu7dKfLYLmC5lHAWsudJW5x0r0OKyVx7U6XRopBllpXHY8oYPHUYZx1r0S40WJOo+lZUunQKPujHpVqxFjlVhD9aYbGJxhgK6B7OFeF4+lMMG3G3pT5QOcfRoH6CqzaAvYV1qpjgEDFNbgfeppAch/Y6pzinDS1yAfTiulCO4x1FSqhbtjFSxoxodIQY3Dirn9iq33RWwkTbcg1djg7CsWaxR/9H+icTBuvFNMq8CsQXRAo+0kEV2cpwcxt71H4UwSAc4rJFwegqX7RS5SuYulifu8VTkzgY4pvn56dqZ5haiwXK0yHqaiMYxzirDvx0qsxx05qkQxyxIeaFhQ1TeVugqNZ265q7EGj9lj7nGKjeGDOag87iq0l0CM0rDTNBfKToAKvRTIlcwblW6cVct52Y46VDRSZ1sU3GKvRN0xWLbP+layuCMVmaotAnIqNnbHXpTTOoODUTyK3zUDFZievfpVZ1DDrTHkHT0qnJckDINAEkkSkbazpYAOtD3uB16dqoSXWRWiM2SvEvIWvA/2mfibN8IfgvrPijSpIo9UlT7Hp3m9DczjAYKMFvLQNIQOy9hXtzXSQRPcXDrHHGpZnYhVVV6kk8AAdSeBX4s/tmfG+5+LHi1tC8IzLHo+iwsIbhxhHLnEsu0As5baPLT5V2rls9K4cwxCo0n3eiOzL8P7Wquy/qx+H/xrh0dbIeBtKuJZb7V7trm6ZSBOqbVXzJ9nyxKF7fwj+83FfJeq+EvAmhQjxUkIiu4pHGnWEPVU8vZAFQ5LyPu3bnHDEdME191fELUPDugxXVhp9sLG0kb5d+G+1yt1mnmxl2GPu/wjj2r49tLm2W7m13w/ZS6rqNxduJNSwSx2rjEWeFjwNoA5K/Mea+TjK2x9W4HivjbTLy68V6Zp98GJRHuNz/JufiMDqMoDtxj8q574JnUfDv7TV34b1mI29zewR28DMu4Os48tHHp8y7QR0r3nV/h54g1K6F5ALhfsmVEUhHmnjJC7Q2RjJB7Hr7Jq+kW2qfGDw149htgt9pFmLR/MfAlLkqqybuvlnO0NgYbpkCh1FyuPkxxpvmUuzR4Z+zt8KJfjR8NvF3wFmBsLv7dMsbPhiksUrAI/Y7HIfqMkYBqn+xrc3Xh7xF4m+GF3JCmpR6fqtpNE+CJJLSOSNgucfeUuMYzjoOK+hXk/wCFFft1tP5J/sXxssOtx7/l8pnUxzgMowdkgLbh/CQOec+ceOvh5pPgrxV8WtEsZ/L1rTtMuNas7yMfvbiO7j+0E8HA/e71I7beMA0Tq8/NDpLlkvLo/wBAhS5OWa3jeL9Ft+B8PeAPC95P+z/481gIiPp1noU4Eg5dJ73Yuz05PJ9P0+n/AAJpOtfEa7+EvxN00Nb3Wh+INI0KxRixSeG033xlXjZHI00bo6jkYBxiuP8AhRLeePP2Q/iL4dit5IZ/C9pBcCeFkHnwQ3JuBG+cHbERuUemdvPFevfskwagPh38PZrFvPW2+KunmaLhlhiWwZpHI4wAjE9skHBzWuNrSUKjW6k18uRE4LDxlOnHo4r/ANKt+H6H9a//AAT20nRPAv7OVh4t8RCDQ28VLHrP2JuZIvtameRSFznEszqpUAMqg45r7Vb44fC3T/lnlumx3WzlI/8AQa/JIeI9N8MwJ4f/AOEYvjb6av2QTx6nLF8lv+6UKFj2gALwM4FFj4u+FkOnrOt94m0S43H97JP9vi/KN0kAH+7U4fMK9KjGlTikkvX9SquWUKlWVWo9X8vJdOx+nWtftb/BvRGxDe27vnGy5ke1b8mjrnI/26dGhmVNG0rS7lTxn+2FU/kYhX5aeL/jH8SPCOgy658PdfXX9JjXMtxay/bDD7T284Z4/wAVwK+NdT+K6/HvTNUhaysrTxRptrLd201ootYbxYRl43jHyByvKsuM+lRLNcUl8Wnov8jSOT4TZR/P/M/o/T9vWbTsC98GPP0/489St349hJsrq9F/4KMfBiS4S18W6RrmhM3G6a1E0Y/4FCz/AMq/mK/ZL8YeM/jP4ki+HOhW97q0U643RAyx2rEZUtLjZEP99gK/SP4c/sfftJazY3Wq+KL3TdOsLIkNa/aF1S8YL629mXAyP9sH6VEc6xCvrt5L/gFyyTDNK2iP32+H/wC0N8EPicfK8EeJrK6nx/qGfyph/wAAfa36V7eq70Dx8jsR0r+cOH4Cfs+2usxrrXjTXtKuY15tLqyOn2vmDq0crLdOi+xxivtj4U+Pr34F6E1/p95r2taQ4Aiu/t8Os2Q99qLAy/Q7a9Cjneyqx+7/AC/4JwVsi/59S+/+v0P1jxJjaB9KgeOYivzRl/bM8Ya/P5Xw717SdVuSfk057IWt23qFWW5XcR6DNcRaf8FN7zwrrjeH/iloLWc8ZKuvkPE6465QuT+n6V1xzjDbO/3HHLJsRbSx+sB8/GGpGHy4PNfB3hf9vrwl4wt3u/DGgya1HEpd0029gM8cYGSzQXDQvgd9u7FdzpH7bnwK1JF/tRtS0vd3lsmuEH/A7UzKK6qeY4Se01+Ry1MtxcN6b+X/AAD6wZIv4hnFVXijycKPSuG8HfGH4N/EG4+y+C/E+nahcf8APuk6pOP+2T7X/wDHa9MltGi4kUr7Hiu2EoSV4O68jilGUXaSsZkcUQ9KvpbxsAMVRbKt8tXYHOe4qnElSNaGzT+EVdFkKpwyFOCat/aABkmoaLT0JEgA4xSDbH+FVjdEHg8VUZ3J+ajkDmOkjuAMc8VYe8Xb1rllMn0qT5yc81k6RamX57jPTisWZnc4q/5ZY46VILIN1pcth3OZn3LzWXLJIDxXby6Ynes46coOemKuMkS4nKLNOPvVPEXbnpXSCyh6EUp0+MYx2/KqYkjGiztyxq8gGP6VppYo1Xo7Adh0rNotGHGrfdNa0CP+ta8Ok7myorVj0ggggVztG0T/0v6AQpGcUbcgY6CpgEUc9PSguoHPGK7rnnqI1FP5VKEx7VH56ntTxOrcVNykkP8AK4x2FHlrmgsuKZ5qg0DsOljXg1ReNQPl9aseYmM0fIflNFxWMwqe4qIRN9a18ITz+lKqLT5ieQyPKK4pr2bsMAVv+WnXpTdo3YA6elPmDkOVFm44H4VZit2U5HNdD5SU0RoOe4pcwchRjZwKuid+KmAC8CmPtUbaXMVyjftLr0NPa8JA96pOynjoajHynJpaBqXfNcrzUL8igMCM0MQDzTEZswJIJqpfz2Wm2Umo6jIIYIhlmbt9Mck9gByTwKt6reWOl2j6jqD7Ioxk8ZPsFHcnsK+E/iz8R9T8bzvpViJIYbY7o4gxjVcdyw+83bjj6DmufFYuNGPmdGGwjqvyMH4+/FjU/FdhPpOlJNZ6PAVLybgm/jK+Yo7cEhMjGPXmvy18Z67pGjX8z3ILQXALpDCdtvLJuA6A5Uv15OOK+ofFOpatq00Uem33krF8rrBkBR3AxuJyRgkenGAK+dfi/wCDpfEVv/wkOuJEdRhEcQ8vLIE/h3YHpgDuBXymJqSqPnb1PqMPSjTXJFaHwt8V0XxFdTXeqj/QXwrpKBHGmznAzncfXOFzgAcVgwWkuuauLjTtMiGlooVXEv2fcU5bbgqG4Hccn6Yr6MtPCAn0h9J1SxMl1JtgE1wUmgXA3HCKy5wOOnGawtG+GsjX7aONLhlKFXWJmWKHb32c7egwMEYxXnSlY9GMb7HzX/Ytj8OvEtz4ilkkiswvmbYcSJ+73ZXI4GRhR93nr2qn8Xr7RrL4Pr4xthEl/K0MU7j95JLbSsELMFHOzA3KvIXJ9h9DN4fnuWEeiWUURSFo2t5trIuSAu1gQOdpGCM4x0zXUav8JdANmk2k6bDbLPgSxQ3fkbxgPkRkGMfTGQc4rnlUSaZ0xpNpo/LL9s3Q7iPR/hT+0Boky3Umlq2laiPulTMfMtnZQMbXQOvmDjfsGM8Vu/Gfxb4N8GeM/h9+1QkMi2fim0uNC8QROGKRlEXblemwxebnYT06cCvr39oL9nl9c+ANuZ9LWZIWeHl1Bii6xkEdTGyrxjOBkY4FcRp37PVz8c/2LPE3wrtLyOPVtNkjvdNM8Xm4mtsSqAwACCYKY2K8rkHDA4rSNem401PZXi/R/wCW/wAjOVCalNw3smvVf5rQ/PPwP4ci+B9h8X/gp4riFxax2mk3MEuQrT6PLdeVJcxsACyi1uVLYBXKketen/s7+F5PhraH4f61ETFofj3R4dUbcPMFrcubHzVZcYBjmilz15A4Feda94f8Q+P/ANgnTvixpEQu5fCzTaPqrM/+kDRLwxzpyPmCx3ChFGSqK5XG2vqJ9F8m4tdQvZTcReMfDSyzSwbY7i5a1t33smfl81BCu4feG0cY2mjGVVyPm6vVecUl+K1+40wdH3o8uySt6Sbf4Oy+R+pUfxiu7zU7zSLrwzBeyWtzLCWhkntyTGxXdlSw5xnkCulm8K3Gu6V/aGlRnQ76dwj2kjm+TYw4cFFVx/ulaual+0f4k04y6d4fnTRzA4BNzbxJDIOhIUfMFP8AfOax9E8RapqWqnxJqHjXSGVjn7Da28c0zLjAbbdNFGRxjjJPtW8ZLlTSsZNO9mc34K/ZZ03w340j8ba145ure7UH5NO0Znb5uNj7piWU9Cu2vTbD9k39n/wD4sX4jabc6tYsTIFuLvwnfy2ETFDuLYkaONNp+8yhB09qr/EfxVN4N+H8PxY0i60Lxlo1lKIr6w1PQILSay3HB2yWjtHgdM5BHv0rjfCfxe+EXgH4p6J4x8Lw3sPh7xFbFb7TrO4Yy28MoMcsbby0dxFk5RXVX4wG4Fc1Rrc6Kd9ke1Q+L9V+FWteGpY9C8M674avrhY9PuNMBEXmqQNpjURqkq8HDJnHQ11fxs8IeIvhbr0/xo/Zo1aCHRbu4Z/Ms5QHhlBy0BXIUhTuPzk59DXE+HvhFrfw6+OF54G8LAa74Y1HTm1XQb9oy1u4nHlxlWwfLZGbbIMbhjHQg18e/CT4sar+zT8X7r4TfESOPVvDV44tr23kXCNF0DqMnYy9Qc5xweDXNvzPdLp/kdG3Ktn+XkfdXhr4v/DP9rTS5vB3xFktdH8ZONsF/EoSOeUcDzCnQ56D7voK+JPE2sftAfsoePZj5kum7H2rPCzPHMB3Yj5Sp/2uO1df+0X8H9I+CPxSfxrpFlNq2iXaw39neveNFHJFONyMog2jjG0jjB4xXaXninwZ+1V8NbjRtNYWvirTIfMSK42Sx3MMQyyLMYmmV1H3Vbg9NwoWmj+B7Deuq0kjT8a+Iov2lfg//wAJ18NtHGn+NbBx/aMdk6Qw3cBX/WKrKSGBGW2/hXzJ8NP2tvEMGrx/DD9oAT6ppySrEyXjJLPa+8ZcMBj/ACRXzd4S8beI/hD8RY7uE/Zrm1fBUkr8h4K444I4Ir7F+N3gPw58TvCek/GbwGGdLlDb3li8vmtb3ECgnywx3iNl5XOVGMZHSjb93L5B/wBPI/NHX/EHS/EPws+IWla54F1SaysdTX7do94vzwvGh+pII4DbXO3uMVr+LPiJ4O8V+Iri4uLm40aS5fzPPtQtzB5jgFz5PyOE35/1UmfRe1eR/An4h2GqWz/Aj4sJPceHb+dXt5VfdLpd391biFW6cHbJGfkdeuOteW/GTwJ4s+EPjDUPDGok3cFpMyLPGjLG6fwuBztDLgjlgOmTUU5O77mkktNPdPofX7/4ueCbC31yS9Gt6NOxWzvoJBeWjlOq/vVLRyAdY3VHHoQM19E/A/8A4KEfE/wpcxaFLrktggOAk4NzZf8AA4ZCzRj3hZQP7tfBXwo+J/8AZNxLo+uZu9N1BRFe2rHAljHoeMSJ96JxyjAY4yKq/FTwRN4X8VNYWl6moW1xBHeadeL8huLSflGIwAHXBSRegdTgYxThipJ+67SXbQKmGi0uZXj5n9F3w6/4KQ+Gnu10f4xaX/Z5yFN/p/76DnozRZLBT2KFhj0r9G/C/izw1400WDxH4RvoNS0+4AMU9s4kRh+HQ+x5Ffx3fDpdc8S6dPoerX1rp11p0StaSXxMcEsO4B43kVWIwSCjbSB0OBg16x4M+Nv7Qn7Omq/8JF4euLrTrWYhnkgK3NjPj+8ULRn8drV7uCz6pH3a2q/E8DG5BCXvUPd/L/gH9bv2hlG3/Ipv2gjkjjpX5Ffs/f8ABU34d+L5IPDfxujXw7qEmEXUApFjIf8AazzCfrlfev1c03UrDV7SLUNLmjubadQ8csTB0ZT3VhwR9K+nw2Lo11ek/l2PmMThatB8tSNvyNyKVjytasUfALCsqJhGB6D0rQiuUAA9K1k30MopGrHCPu1ZAtVOSBWS12oHB4qublOg71nZsq6R0O63UjpioDdRrwnQVgGYHj1qMzDp6VXsxe0NqW6B59KpNIrkmsiS4Gc/lUH21BjdxVKmL2iN0bR+VTlE7VgR38XTPFPa+Vud1HKHMjfVu1XbclX57VzYulxjP/1qupdbcYORUuJSkj0C2lVMFq1BdoMMtecR6ky81OupTDoOlYcjNeZH/9P97DfEdaiN5n7p6VnSRHHFVniYH0r0eU8y7NU3nOeKkF1IOBgVhqkn5VOAyjrRyoVzW+2vjGaX7UelZSjnmnL6Y4osh3ZrJdg8LxVhLgDAFY6tjryKnjbGMGlyjUjXWfHQUqz5PWqCsKlXaMCp5Srlwzt3pn2naKqsxb2qq0fHJoUUHMaS3YFL9qySnpWdsAqVUHenyoXMaK3WOnantOh61RVV61MAuKnlQ0xTNH2HSnrJGRxVYKqjI4qnIdp+SiwNm6NnFRTCKNDLIQqgZJ9AKzUuSg+Y88CvHfiD40aWSTw/p5G6NVlYk7QxBH6Dp9enthXrKlHmZtQpOpLlRwPxJ8Z65ezzvo8gkis3Ktbr1Cjjgj+I4+b2+UY618l6tdQanJI95/q5gokfGzZxwi7T8voSOnQEdvWdY8UaFFPLHdb7OZsFS42bs9OB19/rXnOueGdJnk+13kaSLM4YyW7AEHHHyj8ulfNVqjk+Y+io01BcqR52/gS11CWTVorprWQKcvbN82Og6/Lxj5QK8a8S/DzTJ4Y3ju5Fcn7jjerHg5IXg54Htg4r6ittB1LR7RbG2vmljnYjyyqFgv8AF1GcAH04x64rmb/wzK7prOiyS741KiN1G0u3TgEbRj24rjnHyO2Ej5KuvBfhuyt54biFG8sfeh3fNz3DBgPl6e/auXv/AAz4Pn0yRILNLVJ1ZULDfktuxggcY5OPQ19W2ujeJkuC+r6bLdIx2jaq7Cp6DnkcdOOtVbrwmkllLI1vPpcO7+CMSZcY6DHt0rjqQbWh2U52ep8rWXgTVr3QDDp0NnqCh9jiIFGHGARuGAcDBH+Rmaj8KPEzRmac2YVk3tGqCSWL5Bkb8joSSD0I4Ir7Ts/BGheUNSa2vLl2xIsy/KMEAnjA9vy4rzXXLaO2vfKWznuDktmZwI0Bx2cY7Y71wTjY9CnJM8nTwFpD6FfaZ/aV3K19blVaFY5grjPWP5xjgH36dq+RvhBNq/ww1u48NXbxfZ543WaSImBW2Ftp8tuhXt1/kK++vDHiLWLSL7FeaPDDEJMefbADIxuYFhtIIA6Y/SvC/iN4AOo6+usfZJLyORzII2k+XaP4lDYHI98H1rl7xZ1W2kj87/FHwz0j4P8Axj1X4V394n/CD/GK3vfsV9IgVbPVJkzJBOv3XR3G4YCh0dvlBQ1zms/CjW/Avwt+H+lLIU1XwbrUkZhK72mswku+EMMnKxghW/iCbT1GP0Q+K/hCe5+DKXV3oVvbXWlSibAYyJIh+VSqgfKyEDI+6AevFfPOkXMmv6fINZXcYpnuYCvOx0BXI3DjcrH5Txjiuatip6NfP7rfkddHDQV0/l5Le337fcPjuPAHi/xJf6fr10lrKZzGJRK6wqzH5N0sZLQduseztWD4s+HFvZ3d9H4U1O/h1bRV33GnOyTziIj/AFsTKp8+PHJAwQvTPSvkDxKNW8GePF8ZRTCS1uyyPETlQ0R2SxNxzkY4PbGOnHuWmeO5bfxl4a8UR3Mkf9halHpySNk+ZYThZItxz1jUlPcCvei7U4tbWPBlbnlG3U9A+DP7Qur2WrX3wv8AFMkb3N5E0cZlVWtbpHX5RIBhZEceoyDjBrc/4QzwR8TbVLD4ewJpPi3RY/LXT0dRb3qRf88e5k4zjOG6A18zftTeG08E+NdE+Ifh1Ps6f2hNasV4DNFIZY5VxwA6MCccA9hXb/Frx1DpXxS8P6/4ck+x3dzawXZKkKFmOCGAAGM/kaiUesS4S6S9D6N8cftNanD+yla+Dr7UJV1TTPEUC2Cozh1VYZHmBUfLtjYJjdwrkAfMRjpJPh5d/tR+GvCfxvllt7aZfOg1yZ5VR3kgAYFQfvSyAYC9B17V7r+0l8IfCP7Qfwx8/wCHMH2XxHNLY6w1mvlqssuo2yySbQzA5CqzHg5HQDpXwj8N/ipr3hL4k+H/AINhFsdD0SVtwD73nuZ8CW5kOB8/yhY0VcRIMDO4mudWcE4fP0OhtqbUvKx9Q6X4uuf2gfDutfB69iS21XSwf7KtPNBh8iAf6ls5ywT5lYL8zdq/Orwf8RNa+GvjcfZk+yXNnLteGVQpUqeVZSAR7jivWPHWu6z4S/aOuPFlmX03yLxRNOZVk5jO1WBCoBlcYAXin/tNeHLLw58UpviBf3f9sjxJHHqsEkcX2eJUkAT/AFSsWJBQ7mJ5bsOgv2e9NbdBKb0n1Kf7X1mza/4V+JXhZJm0zxfpa3ODmVILyJ9k0ay5I2vkPGj4kHz8FQMfV37Puh+HvE/wtg+CvxUt7jTbnUZv7QtLmaPyngl2bIgu/nBHXgDng1Z/ZR+JN78V/APib4My3Ut1d3tjPd6MqTyQyxalbIWi8vBKg4BXaVCkfLkV8K2fxf8AEGjeJRqqXkpkYh9zsSTnB5Y55/M1ioucfOJteMJa7M9c8Rt4k+Enju50PxjZGSaxkAiklUSE4xj5up4x3r37x98QtO+N/hq48bWsv2PWYEjGo2qR/ubiNVCCdAM+W6gDzF+6w+YYOQen+Ll3p/7Rf7OOm/GNoUOtaBMmlanIrcsJF3W05TgZ4MTsoyQFLdOPhz4f+Kz4Q8W295NtAicblUbldOjgqeoIyMdKzcnpUj/XkbKK/hy+X6Fa6uZbO4yrbwP4TwD2+g/IV7RdeFbH41eALKSDUpdH1HwfBcHYF80XFncSK7nORzC3Kr6M2K8k+KWhWPhbxrqPh2zm/wCPaQNGjZVjbTLvhbHBw0ZGD0446V6r+yx4lt7L4p6ZoWvJFPpupyiwuo5x8jQ3P7phkYOMN1GCpwe1TXtFqa/pFUbyXIyp4bTV/CelPDa3/wDbGV8tekTY7/K2QT0xzXonhr4pSaQzpo8rWm8bLiJujD+7JGflI7EEV4Jrtnq3gvxNd6PKDItlcTWxYHeriFymf/HaW8vLK6i+3+WDKn3Wydw+jDBx7VpOn0iZwqW+I+yP7O0bxLB/aOlrBaxOv760RQ0HPG+MHkA91z8p6HBFe4/BT9pH4rfsh3Im8Nyf294QeT/S9GkkJSEHq0DEfum/AKehX+KvzU8D/FvWfBd44u83VtcRNG0cmGXn8Bwe4r3m+8bstlD4g0GQy2c6fu93LIcfNG3GG29P9pccVFCrVpTTg7NbFV6VKtTcZrQ/qf8AgF+0f8L/ANpLwkPFXw0vvNMWFurKTCXVq5/hkTt7MPlYdDXvCTOODX8Zfgf4q+L/AIZeO7b4k/BW9/sfXbblrSP/AFF0nG5FQ4BB7wtw38O1sV/Tf+xl+2P4B/a58DHUtLK2XiPTVVdV0sn54m6eYmeWiYg4OMqflYAgivt8szqNe1KrpP8AB/8AB8vu8vhszyaWH/eUtYfkfaUJkPOakeKXOV5/So0lt4ztz0FI94gP0/CvX9p2PJVPQi+zS44PFPEbjhqRr3ANZ0l+P8KtTZLgkaywg9/bFIbMOOKxhqig4q7DqUb4LHpV3ZK5RJbEgZU81VNtOuMDNbiTxOM57cVKURhtHOaz9pYtUkYKC4QkDp0q9HPLwxHStPyEPHWo/sq5yKPaJh7OxDHfvnpV+G83cGoPsfOR2pwt2bjFQ5RLUZH/1P3WkuFGAartOgPtWO87ZwKaHZhx254r0rHk3NdpRjimG6TpkVnYc80xoixpjNIXag4FP+0xkfSsny5NvHanbWXk9KLAaqXYVttSC7Qen/6qxCGGCaFBDD/OKLCudMk69jzUwuFUc1zyM/Wpk3MTipsWbBuOPlqDzn6DtVZY2HFPX5ePWkInWZiKl84k1SZj91e1Tr0wKBouC6FWFn5yKyHbjIpVmAGT9KTRSNsTg8Gh5IyNv8qxvtIWs/UdWj06xlvZPm8scKO57CpdkrscdXZGZ4v8Uafp3l6Gkuy7u0OOcFEHf8eg/wD1V8u3N2gU2ur5FwCRHjjO0YX2AUEYHb69LfiC/wBT8RXTeINNkE8uCShOFPTjtjoAB2WqSeJLfVrIwaknkzJniRcYbjAHuQfy/Gvm8TiPayu9uh9Dh6Hs4pI4yfStbn8u61+3ivY5BsBwN4yc4wP4fp2FZ48JWUk51DRndX8wAxHkAAdF9PT2z9K9Vt9XvGRDOqKkOP3iMONoxj+X4gVfv98k0Y06WIMAiMBgkbvvY+nauOUUzqjJo8UW3l1NWXxBCd0K4MgjIKlhjAx1wBx2qvJoZ1SQjT4rpIVDfM/IOeTg+vGK9A1vSPE814GBgitoud0RYNz7cjnnpjArLvLGxCRRX2pXA2DKJt+U7j04+n8qyZtGxSs/AV3/AGZLL9uZScbEB5+XAG446E9vpXP6jJoenXFrb6bNJfSQSBpVJPIA6n07Dp2r0kWXhBoHzNPJF/AGYxgsPm6DHH6YFZVrbR6HP52mC0ZfLyhIPmnnPLDt/DnFS4lRlY4i0v8AxfqehR/YbRY5JF2NukJ8vYecccEDkVk678N5rWL7Tq4gvJ2UukZmYA47YIPUYPHYEV6G2s69M0lraXqxmQcAKCN7DbgfN/kVWfSNZv0eTVdReDG7cgxtPTOBjtxwOa4qsE9DupTa8jyk+CtMvtLNxrsH9nLH9y4lly2BxlArA8DGN2D0ry/XbTQNTBsLOwutRmQgJICI1kXuBuwQB0woPfvX05NpOg6dCuswSF4Yxlnch84wOAT6degwQcccY+p6tp2maW9/pkaW9okRxdMixlF/2FA3Yx+YPHYV5dWlY9WlVTPijXfBuo6JotzBqUX+gXD5gsXkIkUAZGTz/EOBj5eOlfF3xBtI/A4vr20tY5YX8tHydjguMsqA/LuXOcjoD06iv0U1HQLz4lXqatpN4sguSUleZDG0agHcPm+g2kZz17V8reNdM0fVrSeSzh+z2OnLJAobH76V2wTubg46bu+4HgGuFUbvXY7nWtHQ/NnxpPpGn6As2pRKbGXUPInK4O2OeMc9GAAI3fhU+meG9CuvDV74X8SjyI7aZPOMTsZ4ZoBiFygBGxlYbcY4IpnjS0eL4W6xFGjulrMiyBU37xF+7bOATkDjJwBSaXp9zYXmj+Lbxmks7y3Onam8fVok4ilB7MF49iPSvch7sUjw5e9JsoePrjxF4t8PW/wb8TvDPfxyDUtIv4yQl2vlldjgqBv2cK3ByArZFUvjHpmq+LT8M7PRoHl8RarYw2Kx7RuZ2kEdupK9vmJYkDaoJPyjjvvFNq/hvQtJn1Flku/D+tRra3QQgyWsxDA5HT3Hr0xXtd9458bedY6z8HZNIXxFpsMvmHMcmqxWrzM0aQeZmOPKEiRQPM2MFyOhTm7pRQ4xVtT1/wCBPxP0DQ/jrq2laxcO2j3DWunxXkBDFDp6LBHcxdVZdysRniSM+jV4n+3B8Grv4e/FPTvi94XtrZdF1e4ktnfT2zarf2p/ehMneqygeag/u5APFeh+FvE3wa/aNsTovxVsY/AviiNmT+29IhWGPzQetzbKNhBP32i2n0xXjPxD1z46/st67dfCD4sWcOseH9VQXCJKv2rTNVtEIKXEJ4+6SDuQrJC3XtmIwSb5PuNJT0XN954P+2Gttb/Fyw8S2syM+saVZ30ny7R5h3IQRyNwCDJXjp3r3XW9GvvjB+xw3ii5UXV58P5kf59m4aZdMBL82N37qQiTrjZnuK8d/a80Dw78QPBmgftBfCWORvDmiWiabrdvLL5lzo7mTMMkhODJbPu2eeFwjACQDlh6L+z54gv9e+C3jXwBpJT/AImGjzkDd5aSG3Xf5UmARtdcrlvlGRng05p8tOXy/QcGr1I/15Hn37H/AIo1jwR8ddBmtnaBre9hcnORhXGVGRjpwP5V5v8AtNPa+Df2j/GWgWxijit9d1FYxbsXiCNcO4UDoNqsBgYAIwBjFcD8KvEc8nj20uYGMLeckkJbgDaQRn0/p9Kt/tlpqKftb/EI6wS122tFpm2BG3NBCwz6/KVxu5xgglSDTpwXtpryQVJ/uoH6OfsfalJ4k+EPxD8ERFWjuNOg1FPmztm0+Tf90YBDKSDkjHv0r4i1PXbK51APDt2sQQ68gjr0/wDrV037PniPxL4C+Dvjn4leHJJUm0rT7ezZ4ly0S6pOLZG74XOQ2cqvp0I+R4fFHm6izSH5XP3u34isadP3ZW7/AKI3nUs4+n+Z+pHxi1rU/FnwI8B6xrMjyx2Fnc6XayOquqCCRWEYbG8YUjCbsY5UDmvnv4U6xq0HiywOmhWuluYjCrfMrSBhtGBjPPHGD2Br0/WNdku/2OdNMjIfI8T7QrDORNYyEgdRs/dj0IbjpxXkHwS02wvfGOnSSyGCKCVZ2ZsuFSA7y3qdoXkda42r0LeqOqMrVvu/I7X4ueO9Jm+MPiV9IVk0x9SuJIoJCGaLLfOucDIEu4LwpC4VvmBqrp8761p8n9l4aaJGkUAYdwBkoffAyvvx3ryr4weILXxj4qv/AIh2wKSX1xLdXkYwDE8zk71x/C2eR/CeuQasfCPxFcR+LbSTPmK0yLs6EjIG3HHbsK1q3iuZdDOk1L3WUL7xDE2CknyvzxxkV738DLlPH41D4TvcfZbzVIv9AmJxEl4nMLMB2J+Rx3B618OePZ5/CvxB1vw4NyQW2o3cMcT/APLJUmYLHk8/IuFBPOAM8133wl8V3+heLtN8UWj7ZbO6jOD/ALJz079K0xNK0eaPyMsNVTlys9Ej8T3bXlxYXSm1v7GV45oCfmSWMlWH4FSOOhFe3/Dz44eMPg1450r9oP4Y3b2mq6dOE1GJT8k8cny7mXur42SL0PytwRmvCP2psr8Tdb8faEAEW+k+2qnYSkMso9ucP+B7Vy3wo8VGS9bT78CWGYGKRezI/H8qGvdVRCum3Skf1GeCf+CxfwVtdb0rwz8cV/4R2XW4BPp94Dm2uFGFcD0eNvldeo47EV+ovgn4p+B/iVpEWu+B9Vt9StZQGVoXDcHp0r+EbxV4H8IfGDwfffAP4kXEls2nXYvdKvUTzJIZUUhhs/jWaI8p6gYGcVwHwcsv23/2SLVfin+yF40i8beFbZwXt7G4+0wFU6o8LHMZHQhSuD27V9RluaTlD95K7XfT0s9vvPlsyy2MJ/u42Xl/l5H+hrHMJDgmoXQt3r8R/wDgnv8A8FhvhR+1Ylv8NviVnwj4/hjAm029+QSkcFoWIG9c+wI7gV+1cN4kirKpBBGRjpX0VKtCa90+fnScdx7wOpzmocSrxV2SdGT61W6t6npxWymZuBahuJoyK0I9UmQ+1ZqBcZqyiIcZ5pNoaTRrprZHXIq1DrKlhWalojjGKP7LwcpkGs2oGi5zrINRiJzV2K8hPA6V5/LbzwjCMeKQT3SfKSTWboroWqrW6P/V/bR07Uq/Lz0q0wXjBpREG6V6PMeZyEYcjvS+cKsfZdy81UlhK0rofKxTKM00yrVRww684quSw4YVRJol0HX8KRHRazNzbQpGP5UKX9OlNiRurLH7VIJ0/grBDyZwBxT0aQ/yqbDNwXQB60/7Yh7VhAtninHcOOtIDfE6ZwKJJlByKxEMg+arg3HikUTvMM5FU5J9vPpTynGRSGAOCPSmBWFw+cjpXkfxW8T32m2ATT0LmLAZB1JcfpgfzNena9eQaFo9zq8uCtuhYA926KPxOBXyDq3jGa68SS216rSJcASof4H/AIQpPoSRx6V5eZV0oqmup6OX0Ly53siG08OaoYm1LTb3bJPjdGpwCT/CPQdAMdqhW9XWr2fRtbRXaM/NIhwMegPXkgj6LmqF3PeaKjX2k5uLeNQiDP3Qx659+gxXMN44trtoGa3WASEEsPkYsAOp+mcfpXgNWPbTOmbw3ZJcSy2F6yw8n9/x069fU9q6LTNP0vSnW903UUjf5QQ3zKOPWg69o99py6fqCLMvzs3zDOeucV59qF54GtctaSSxB2DKkYLAduQPw/KoaS2Li29Ge0r4yts+THKbl4wGJgBAJ6Y/z9K5S71y2bV0nS3utwuNpTgqqlgwPze3p3rjIdetrTba6TcMV3YRim3coBI/x/KvT7bVNQvI47mACfdhB0QgD/OOlF2yrJFFPFWpapbyGNQ32f8AgZdg3dgRj24p93LpGqwRJJEqsB5edpTDMfbsDgdvXpXHa3cPEq3FxbGGO4A37JMHMh2g8eo4x0BrJs/C2n6hbvdDUXt2Z8uGfd83BP5dD6fhWbuWkjv7K48HeG7h5NQi/etgkAhhtG0jaBx17n1H4cxqPifw7rjPAYJ7vD5CRbkTHv0/DPTArasdD8N6Pbm+817uXkoUTcipjDAkD/OPpWQ+saVpURjllRlkBVljHO5unHb+H9OBzWE9EdMLXOS1aa9vGjsvCEaQs+ADcbZGQg+g4GfckewFaun+ALyfzZ/H8/7hUyGZxFbqw5G3r0/ToPdNS8bX2jWLXPh/SmuJ3QITL+6XpwM7SzdMcdhnvXOW194m19h4l8fQxpDCm2NOUiix/DtOTz1H88dOGrFHdSkcV401nXtI1aw0rwJGllaXcjrtlVZN0bdxzjPp0HTp0r44+MdnLpWi2Oh6HLItkLiOPyTgpKVyZWAGWUBsfICArAj2r7ys4r6FJ/E91YLECPLhD/M+ScgvjjHpjgDnivkG40qx8c/EWPzbd7nSbaCZl29ZCo5cY4OT0GM9/SuaNLW50Sq6WPgGbw3b6nH4w8PXReOGWTaSm4q3mEEj5Pm25PQj1zXmE39q+F9Et9PlkKw6dKlvMkpwdpHyvg/wke9et65o+t6R4LHiiPfC82rsWg2jDxLJgYJCsMY6D8jW3feFmuPGWmmaFZLXWYGsblP7sicIWBUrjBGCfSuvZWZxrV6HJXNlL47+GupeHbCHGr2UPnW5H3JkXlQDng4HGM+nNY/7PXjbw38WZ7D4ceN1+yanbNt0zU8FZbSUZ2o4G0vEx6g9K6X4W/2n4Uv9U+H2rL5WveELlym/70tqcNjjjphl9OnHSvOfjF4Ej+Efxf0r4h+Frd4dO8SDz1j+6IbxSDLH+J+YD9Kz6OPVGltU+h7rd+B/CzeK5tbsGkstU0e7FhrFom3yo5uNjdQdjcYIweRkjqPrfwvr/hPxHa3v7Mfxht49R0DUz5+kGZVX7Jc4ziIr80Qzx+72le2K+U/jprOn6F8YvCPjed2S0+IOhmxv/mAjMtvwp4wQ43dx0HtXfX+o3/xe+CEOvaDKseq+DGIeRGaSdxDwqjaMDjngFm6AColfS3yNY2tZnlfib4Wv+zN8Y7PWPBtzPFoupod1reItzGqP8stq4fBliYcEPklDyQQK8z8W/Ca2/Z80X4t+JfAh+yeGV8N/2l4dV42H2a6v3SKG1jJbJ8uXciSJjERUAfKTX2F8dtXsPjZ+zRpPxDso5P7Ts5IxdPGF3Fo/4jnlQ3csfxFc38Lvh/bfti/s865+zTrUyxa0qrf+H7yYAfZr6A71Q4+9DMV2uuQMHII60vaWcZPa6v8AJlxjo4rdJ2+4/Iz9l/TbvxJ8XNNtiVWFrlC0shEaom4FmJJCjaMnBIB9QOatftH63YfGP9pDxl8RtMKWtlqWqyiBFU4ljtgtsjjJOA6wh8gbeRtBHJ91bwt4r/Ys8EyeIfGVs/h3x9rIks9J06+izc21vjZc3SlcorIP3UT7trFtybk+98M+H9RGsarHZWCIkK7AkUa42IOAu3+6AO3Sto6uVVen3Gb0UaTP0Y+Hfhc6b+yD8QvEVop+zizt7MyfIJY7m7lVInVWX51RwPMUP9w8givzh0/RLq9vpH0gq+7koGwQO4H0r7R/aV+J1j4L+Fvhb9n7RWLX2lmTW9e8yIKRe3sYjggQ5JdYbblzwvmSYGSCF+QvAtwNS1yK7tATIWGEQbt7HgAe56D3wKigpRoc8uuv9fIqs4utyR6WR9eeKro6N8DfCGmyzzoFuL/UHtwFUhxst0fnGVKhwNrEZ3fLnFbXw58R+HL/AMH6leaJCouTH5N8SF3mCQhS67VG0Zwr8ZAI5xmuN/a+1FNM8baf4Usbgy2+h6Hp+ivubIW6sYz5+PT53K9iSmCMg1wn7M9hNqviq90SDaF1DTLyFwQSMiIuGVeOQU+XHPYdcGYwSpRk0U5t1ZRXp9ysZXilzpl4/wBkx8oIHGMr02kdxiofhFJDq3xF0rT4chZb60RAvVGaZFH5E8flWD4kvJblSXZQx52ryD06HuP/ANVdT8C1tbDxJceN9TYxWmh20t/OwBP+oXKBdvzby+wKByfTPFViV7jROGfvo5/9om5s9W+L3ijU7CPymbV9SRlz8rGK6lQsM/wtjcO4zjJGK5n4f3c7X8FrBy8ssUY/3i2Of0FZGttdXumjUbuTzbqEb5GP8ZP32446/Nxwa634Z32n+G9SuPH2pJug0YRSCM/8tLmRtsC/TeNx9FWrqr93yr0M6T/ecx7X4+1SH/hYuuRp++tZrmW2lUj5W2YQ8dvu/pXhHh+yufDPihtHRmKhgYGPdG+7+I6fhVDTPEs+pXDG8k3yszOzHqxJ3FvzP4V6hLpUmr2VrqtqrNNDKoYoM/u24zx2U49gKzn7i5TSHvvmPb/F3w/1a88X+HtZhYWc2pWQMUxO1JJLZyhIPTIO1T6HFYXxF8Ban4X+Jb+KvAV1P4G8aXSK8t3bjy7S7mI2tFdR/wCrkyecOM85XB5r374w6vofgvUfD/wy8RRs8drpkd5e7B5lxpl7fuZBsHBIWMIZocfMGVl+YYb0jx3rGjWvw+8M+IfiPZrf6RqJl0wapppWWaOWJRLGwQ/Lc20kJ3beHjKsq8/KJwdSUeVrqv60/Q0xlOEuZdmfll44/ak0bQvES+Ff2uvhmbbW7Qi4t9Z0KY2l1uXpLAWKEccgpNx6V/Rt+wd/wWW/ZP1rwdZ/DX4jeOXjv7XZFb3Gsr9lmlUjChtwVGf1KcHtX5t+OPhZ4F+JXw9i0XxxDb+LPB0vy2mo2TfvbWT0ikb5oXXoYZcc8A1+MH7UH7BPxC+BdtJ408BzN4q8Gvz9ut0/e2/+xcwgZUj1Ax6gV9NgcVS5l9mX4P8ArsfL47CVVG696P4r7vzP9JTwf8S/BXjvTotS8Iata6hBIMoYZFbI9sV1zXBjIzx6V/lXfCL9pv48/Am8S7+EfizU9B8vdiO1nPkZJz/qW3Rdf9iv2a+A/wDwcRftXfDsQ6Z8U9PsfFVmhVS65tp9vfg70J/FBX0MavdHgOD6H92/2uTPynircN+6nk8elfzsfAT/AIOHf2SPiRe2ulfEy3vPB9xO3lmW7TNup9TKheMD3LCv3E8DfFb4f/FDRoPEHgDWLbU7S4XcjwSK2QfTH9K1UoS0MtUe+22rRIME/hWourQnoa8jaeVKEvJh7UOjEarM9eN7DLyTnNMLQsBXlQ1GcNxwB6VZj1icNtJxS9lbYr2x/9b9rPtQBzmrCXqKMVxTXLH71AumwMV6XIeUpne/2igHFV3v1auN82VsAHFKPMqeRFc7OoNwrE7aF2tzj6Vz6M4OfTpV1LjYaNho3Y4kfAq19jjxn8qxIb0YGTWh/aCrjvmp1KVi6tsh56cU8W8a+grO/tKPaTnio21NWHBpcrHdGiY16CoAibuuKzjqHGAaqvf7enenysTkjexEPu9PpTt+0c1gLeNnrirH2gtyafKK5rGYGoxc4P8AhWYZGpyyf3qVho8l+NviOHTtLsNKkJ8u8mYy7OyKhVT+DsD9RXyPPqQ1Cxa0vJTG9sxjh55ySecewAr1D4p+KbfVviPN4ellxF5Btoj0VZbdg7fiXOMf7NfM/i6GYXdneXa+VPbsglbPy7mHp69PpXy+Nq81WT6LT7j6LB0+Wkl1O/g8Ralpth9jMjOgPGBuPsCf8/SvNpfGvhjXbldP1C3lQxkudi7AMHAz7gAfn7VvaT4u02/to1baw3YO08jaB+ec9vSq2vwQWK/2vbgMwxlSOWDZP9a42/PQ6kvI6C3tbDSEk+x3h2MGZA4BwMYA9cY6fSrl/LKlzHfQsuV3opXGPkx/Ir2/rXztqPi/Rbi9T5DKoHzIR0kOAo4+vp2r0LS9V8N+JtLjSBJDtUybQxUjdtx6Y9x+FRfojSx6De6xdavZn7Hauk0A3g7MfInYHI5O2jw/dSX8TQxIsWzY6vypZecfy4+tcynjS00e2exu1nEUCCcEuOSAQR1/u54/CvPLHx5rFhqrXGkWRvIlwEWTOQrMWQnHHR1GO1JvS41roj2q+tb3VoXjd3WDhdg+ZmwEJ6DgB8j8M96pwalrMVq2j2cLRyQnfnZtZ2j4bOeeQeawNN8aeLNY8kafp+HCESh8qM46r+GPxFWn0rxTqSm+1q+Wzk37CE+b14/AHFYyl2NoLudhZJqmp6WdU1K/lsEB27Gl2s25eMfXB7+1bukaZD4bRb3wyiXt7OVVjdISdmf4eeo5xn0x2ryK0vfDuizvDdW19c3fJViAUAPcY55GMjHHFbZn8Z+KPKitrk6dbgkSKmBI3TOH6ruGD6dDWDZ0xX3Ho/iG5tNISDVfFty9zJMQIbaBeWZeVIXnbyCOQB2OK5D7c7Xt58QPGU/2e3gGYbVyTGoA+VETnn+6Rlh3qxp0nhWyuIotBjbVpycO5fKMe688rkcjjGeOwqh4q01IvJvPGkpKKB5NpECd209/Xb0zwfYGs5K5rF2RxfjHxPqmrWE8cEp+3aoPLSLCqYLZRjcSeOnHbJ5GMZrjNOubG0uJrDT/ANytsgiUg7kJC/QFR78iui1gxeF4pPE9nKsl7qDG2tt3ysI2XlhjAXb2PQ/xDNeZeG31EeLr7w/EFmg0yzkkuJThQZpVyNwIwpVeCpCn26VPKK54t8SNEsrzwfa+C5tvmXFw9228HcmWyNp2gH5u+Olcl4i0S50zwpqGvSbWOlajHsPZcbfu5Yeoz1+leq67pkreNNGa+HlNb6Wbh45N2zDMcHaAAD/tYJx3ArP8VadFrnwr8V6Pbni2kjupEjfdngHjdxjgcj6VLKjoeV+LH022/aY0rxVdEPaXuj2sd1iPKlpSUGccY9iwx7CuGv8ARvFtn468U/B74hSSyyS7tQ0KaVFOEydixiHamAPlAPOOua968UeFrLVfhfNfwjddLpUTMqKquHt23KeCRz3G3I7YryP9o/VITJ4G+PFnIVlkVNNvdzDY3HBPUr6ds1K1V/60K20PD/EdxrPxd0HR/h3rNpFLJYo3kIyEiKboRJKnGf8ApnvOMZ213/7Fdxqvg74iav8ABHxIwR9VjaJeH+zknjohXI7behPBxWl4uikk0DVbwxRy3Hh26juIZIFMkf2eQK+FPTbzgnHOOa6bxla29p4j8HfF3Qz5cEvlxvN5iDd8wwAgGQB6n6e1RL4NOmxcfiPGJ/jOPgHqviP9nbx1p1/JYyyyxzQlEym7lXTZ5mCBgj5gB6V6H+y78QPDng7x7p/iDQpZ28uXdtnBXan93J45HXOK6/8A4KW+B477S9L+I+nzlf7TtkR1aVgjOo+8RsRemON5+lflr8IfE95o3iG2tiwRVYAhV4qalO8Lx2NaVS0rS6H7Bf8ABRX9lbQvjPoGt/GbQNEf/hMNBtE1iT+yYolfV9EbAbzBszJPY4LJsXJjJXacivw58AavpXgW9GoaPoK3l3EVliudSm8y3t9uG3CCFQJx3AkcIOu1ulf1VfD3xLf6p8I/DvxDtDHNP4YuiJdxBLWMq7JkC4JbKev4V/Ot+3B+z58XvgZ8dtZ8E/Arw5c3HhzUBFf6FeaJo93chrG55jjBiidIpIW3RGPaCAq8DcANsHarHkkZYq9J80PyPnTx7oFx44tH8Q3c7NfO/mtdzDCSSSn5wSML87HIA6HoMV1XwD01fhrDcfGTxHbrKmkcwWchx519x5RIx88K/fk2+i8DJrmdL/ZC/bAv7RviB8X9C13wv4as4TPe6/4nsry102yg7uxkjADcYWIBGd/k+UnNY/xH+Nsfimxs/BfhyGWw8N6UmzTre4WP7U5kG57i6aImN7iY53eXiNE2xoMLubpnT5lyppx/rQ56dRR95qz6GN4w8SSeIyJ9Sme6uWd5JpnO55ZCcs7Z6lick+te6/BNo/CngDxj4wvH8pf7MOnWz/8AT1fkRKpx/DsEhP09QK+ffAHgbxL8SPFeleEPBNq+p6pqUwhtbWMgNLI3IVSeBwCWJwqqCxwqnHTftN+MdN8Patp3wd8IXK3eg+GHkH22NDGNRv50Xz7vDciNcfZ7cf8APNC+WEimsZQ9pJU16/cbKXs4OpL0X9eX+Rna1rsd/fMk5YgHKkHOSP5+le3f2NHa/s1XeoWDCF/EWswabIx6iOyiS9AB7hpdmSBxj1yK+cPBvh7VvG+p22jaBC9zc3DBUijALO2Og7dOv9MV698bdT0zwndaT8J/D1/Hf2/h6CQXN1BL5kD316wkuFjI+VlhxHFvUkMUPpUzV6kYx6ajg+WnKT66L+vQ8i0/Uwqx2N3y8ZywPXrgj0xxXc/FvwVr3gTwtotvf2jW8V3b2tw0n99zH1I/hO0rkcYPYVr/AAR+GEXxu+Jml+EbmRLO3nE02oXMisYorG0head22gnhE2rgHLMo78e7/GnWrbxa+p3MuJI7iTzIkdcfJ0QY/wCueF9uKpS/eWXQXJanc+HfDcGoG6RX+8mcehx/jX6vfA6DT/hd8Of+F1rajVdetYml0+0f5VtU3eSb6ZOPOhhkwhROjMu/anNfO37LvgL4VfFDUdb07x7b3WnJoulXmpS3FgQ+PsiqRtRsgK2cH0yMdhX0Z8aNfbS9e0bx58Ms2Hh+C1Gm6LFIhcWr2ikXFjeKTh5mLs8nIS6gkV4/l5XmxD9rU5GtF/Vjqw69lDnT1/I8RfxPc/E/Vm8M+LJjLr3mzTWGp3En+v8APdpJLS47KN7FrV/ux7jDhU2V9b+Jvg9p+ifstaH4Q8Z3U2ka1q/iC51Owju42VbVLWH7PL5yfeWKZ3wGQEZG/DCvj/8Asu0vtU0z4g+BINlrcXUVsbYHe1neMRiAk8sjZDW7nG+M4PzK1e9fH343an4d/aJ8ceCtRmPiDwtZa3cwQ2M8zN9mMYVJTZzNloG8wP8AKP3XVGT+KlFOVVKPTW34FScY0nzddPkfO+i+I/iD8F/Gtxp8UjaRqJiAnhkUT2t3A/3TJF9y4hYDCsMHGQrKc4+rfhl8cfB/jTW18FLAvhvxFdhhHpUsm/T9RjHOLKdwMtt620o3pg7dyAMfO9U/4Qjx54Ij+0TS6t4bjl8m0vY1CX+j3UgB8qROQjHgmI/uZhhoznFfK/j7wUNNX/hA/HiLc2t4gms722yI5Ap+W4gb7ylT1Xho2GD2J7E4y0kv6/rocbUoax2/r+v6sdf+15+xp8GdQtJ/H62Uvh3fJtl1GyjxDbTn/lne2/8Ayz9pF+XHPAr8h/iB+zT8Q/At4IViW/gk5hmt/mSQdipr9X/hv+2d4z+CmuR/C79qYSeJPDN3EtraeIFiM939nHGy5T/l6jUY3KR5yjkF+3pvxO+Gnh/wRoUPxA8BPDq3w91XbO0cEnnRWkUnAnt27w5++vDR+mK7aWMr4a0W7x6dv+B6HBWwdDEXcVZrdbW/4Hn/AEvwT8U/C34m+AIo7vxlod/pMcgVo5Lm3eKNg3TDkbOfrXpvwG/ax+P/AOzLrMWsfCDxHd6QoYO1srbrSTp96E/Jz6rtb3r+tL9nj9rLwXp3gzTfg5+074ZtPFXhdIxDa6ksStcxQngBxj94AO4+b1XufRviX/wQ1/YX/aY0hfiF8BboaRFfjejadJsi555Rfkz9V4r6HDYmFeN4b9j57E4WdF8s1ofJX7Fv/BxFo+qvZ+Cv2tdMWwkbbF/bFkC9vngZkT78Qz1PzoB1YV/T54A+IHgz4neGLTxl4F1GDU9MvY1khmhYMhVhkcjjpX8jPjn/AINqPi7YX5l8AeL4poVb5ftMKs2O3KFP5V+g/wCwB+w3+3R+wHfRabBrMXiTwhcuWvdJb5fJJ/5aWvJ2d90X3WPK7Tnd1wqyi9nb0OSVO+x/RHHHBwuBU62sJ5wOlYljKbm2julyA6g49M1sxq/TOfauts50j//X/YoWXYdKkWwC1Za5U8joKablSPlFd92edyoiW3VeDTQEXnGKmMqngVWcjjAzRcLdiGWdRwtZ012449KvPGDylVntxjiqViXchN8yn6U/7azd6YLI5z/TFBgEeM/lV6GdmPFy2cmp1u9oye38qomJz04xUQgejQLM1PtyrgLU6XSng96wxbnOemMVpRQSMwIpXKVy952Gq6lxng9KrLbjGT61cW2QDrUNo0SI/tDM2TT5NRhsLeTULriK3RpX/wB2MFj+gpoRBntXnXxU1P8Asv4Y+IbyPrHp0/T3G3+tZVJqMG+xpCN2kfn3PrVz4lvJGuJBFdXC/b4yepedN5C/ixBrKl8dabqdhd6LqkQjlCMCGG7eAByP6D6Vyev64r6bb6jo3y3Glz+Vx8pZEyMD6A9q0Neh8Manp39p3CiOaJ0hV04IKqCwGOw/+tXxfM2fV8qSOXjt/Dekvby28fllD+7VTwEO0EjHoBtA/wBoV6fcfEDw1qVmNP1e1jZNgAcHGFVSBxj6dK+dPFNxqqxx/wBhKtxFAOUPByR1GPbH5CuesTeDStzSSK6hEYPgnnJ/T2qee2liuS530r+E5NQLWCBCzAM2CvPPB/3c/litrStJsNbh/tGxkmtp3UGRVfKqWCn+f6n2r51uL+4spGvA8gKxxybXb/ge3HbjP4cV2nhvxdqkVgsenrGwnPmLKy/dyAwyPw6dqz5u5ol2O98S2Vta3AVLiWcrGUZs7j7Y/wC+uKr+EfiVZrc3FjYMYPKYqySAbv3IA4xx/AfqBxxVrRbHU9VvJrjUJ4pirD5Ex90df6D8K8S8X+GtDk1l9VspDBN5eSMn5pfnQHj1Xp/9elzWGo3PsF/FFtb6eNVSV7sxhyqx9DsBPbrnpXI2/j7xJqY8hbQxKST3fdk55BwBzn8K8t8Cf2loci317qiOjRgFBFnkkAke23GRXrvg7xhAXcP5a/Z32g7c5UDAYZ6/5FZuV9DWMVE6XT7jxJp9pxYfOoVVaWTnIBGcev3R6fKDWTFN4z8SyPbazPDZQKjeZDG5CqueueMhTnA/u8elN+IPjjW3so9O8IpFcyvwZGOAowV2/j2+g9a8v0208TeI7xbjVJlwhX92nCAnjGMfdJwCelYy00RvE9y0/wATeH/D0w0fwxHFdvE/7ySMbl3sP4GxwQP+AnGOoAq3qGtGfRpvFmtD7SZI2VVX7yHG1VI59gO3IxjIx5dqHxG8MeGbJ9A8NRhruEJIkhXPy9Nrn/YOQfb3rj7b/hO/G97bX+pypDBGodIIcrGhztKsmcnByOT7DGMUr2GdCviK/sdIn+IPiwLGltD5NjGAx+c8Bdq8tu43FBuH90gVyvhOy1bw14Tng1yOX+1vF0mzbGRFtDcFVGc8L/AVHbpXbN4str/xXpngvVNqmxfzvlfdHIo4+Y4HIzgYBOODjlWq6Hren+MPjBczW8qfYdA3RJC+0QtM/QAYUZ7BflB7ClbQL6/1sQfEt7KyfUkFz9nNvHZ6Xags0LeYT8wwMLnnptAHY14la61aaYPG3hK7uYriSdhD53yuuQoA5Zyylc4IBPTtXpnxk8PWlv8AFPT9cmPlvHbtdTxk4QsgwoOSMN1AUj6Y6V88eHbDVp9Pi1K7WTzdU1Fppi20tiRsgdOMADp+RqWikdr4Z1a0fxfDolwYlhtbA203k4KnI7jbj643Yr588X29h49/Zf8AGukWox/Y159qgKI/7tojxt2o7EEe35V67pt3bal8TPEF9Y4uobJePNd4lJVPmwRhhzx9wfQV5x4D1iSD9nfxr4n1OARjUJZUjjdlLqh/hUuvQeuBxVxha39dCZT0+RgfBp7HxP8ABjXbq3SW4eXSwsqhC53xDqxMT7P0PtX0n+zTotj8R/2RtRstYiAk0aT7SjQxqZVaPBA3bflA/wCBH2r5L0/S28Lfs3XvjOwt31Awx+a4S1jlXYODudw3lj6Aj2r2r9jX4kalrvgm98MxwWunQakjxyeRaWyOwI6eY6YXj/nmgPuKx5NEa8+56JdfFvQP2hdT/wCFaXssVnpunxrbpcJNNI7ZABLsUttvP8K8f7VfnP8AFH9m7xF8Iviw2h2bSalBuWSG78tUhcPzhcO/A6ctWpo/iKy8I/E/UdM0aQwR2d0UjDykt8p9QEP6V+jPx8ku7rQ/BXxYWJprj93FNIfMMaKOc7iWGfYY+tTrC8EaK0rSPafg94iv/AfwfubDxHDLprTQBI9wkXcW44ESl/ptBrH+EPjK4+IPh27+GmuTTw6jph8/RtRlt3a8TY24BA6iRwxHfn6GvIP279d1HSofC+uxS3n+kRRt5j3w+zsMA48n5zn3ZwPQV5V4a+KFn4Z+K/hXxLf3UU6TeXFNGpyzRt15JcgY9Ao9q51DlX4m7nzdPI/Uz4a/GH4j/FHwxqOreGrrWdA8c+HI3ttS0602tbakQOfPtJXRGLAfxBuK/LLTP2X/ANj39t7xXq3hTU9MPwY+J2n3EpuY/C6Jc6VqhHLN/ZkrMscqnmRbWaItk9SAB9m2N6nwD/bTsPEWkNjw94vjBKbNgjLDjc+7kegyMY/CuI/4KM/CRrCaD9pv4cXy2mpaLdLIxtwUmLkjlNgGTgDGB7ktXVCrJe7F+nocs4RdpNf8A+LPHX7A/wC0r+z74LubX9m7w7H4u0bxBarb3Xj3T9XtpBDYh/39u0T/AGQ6fHMQI7lpI5CIgUaUfeH5cfEX4SeCZtZgs/F3xE8I2d5aKkV2NN1AatFboDjc72iMg8vncFJwBx0xX9O3hH9pTWp/hrpP7VnwsWS7haSK38a6LBI0EzSIOL6wZDuiusE7sKVnX5ZFK9Ok+Pdton7SvgrwzrPwo1OLQ9Zn3XXhbxdBYW39janNIeNP1LEclxZXIxtWRUeKN/m2bP3dOFZacun9ed/+AN03f3tf66Wsfih8CvhBZXU7eE/2bIdT1rTYdLu31LxNHaeVNrFxLaN5NnpynBtrZ52jwHIuZ9p3YjT5/iK8/ZY+MnhPxe/ww+IlhBoF3pqqLl9QnitILZUQEs5DMIkVeSP4QK/ZvxTdftCeKbpfhp8atH1fwh8SdDb/AEDzoHsNL8Qx45+xyx7LMaiBg7LdzBd4325SQvCvzX8GBpXir4lah4d1xSG1nStdtbjcuZI7lLSecSjd83nRTwLuz8wOcjIOMPaVKd33/q/9LysrHTKMJ2Vtv6tYo6Zpfw9/ZI1fxJ8AtcjnvtT1iD+yNc8SCJrcaVb3AjkWSytm3G5gJCSTvuQy2/Nv82FPyb8SdL1/wr4kufCfim3WLULdkR1gk86FhKP3csUgwJIZRhopABuRlOAcqPpLRrPQ/ij4W0X4e3qi18QWcK2nhO7MirDKkhLx6FNITsWJpGJ0l2IWCZvsqssU0aVx/wCzx4/tbj4raD8L/GWj2muQuLrSdMXVoJA+mO4dxE0Xyu8Mc8ZU2sgBgZnVdmNg0inCLcVf+v60/wAiHabSei6eXl/X/DepfBD4K+M/A37P3xH+I2pabMp8SaLLpGmxcCaS386GS/nSP77JBEAH2jqw/DwTTfiWumwXllr6HUdC1Ro4dTs4iFmaNMmK4t2PyrdWxJeBj8jjMT/K+5fSv2pfiN4p8T/EXQ/jJ4X1K4sNMmiWDw/NaKLd9EvbNB9o08gZRZ03ebu2+Xe20iyBZI/MA8Q8WWSfEbQbn4k+E7OGzu7ED/hJtOtRsitnc4TUbWPJIsbk/LKnWzuQVy0Lo6zTptR5p21/4b9LepVSSbUYdNv6/rQ+qf2Nvh/qem/tDRajdXqXnh2PR73WZNQt1Atri20pftccrJJ8o2MmDFIQ0buVyDyfhr4opNr/AIu1b4p+Hb3+2vD/AIo1a+1GO+jyPKfUp3vPJnjPzQyr5mNjjtxmvtP9nzQ/HOufssfFvwV4SZ4pNS/sa28rjF5HdSzC8tBkfent4/ujHmFQp+8K/Oi1uta8M3NxrfhO68ie4iMUsTp5ttdRclUmiON4RjuToynO0rk5eD1lOV9dvkicW7RhG2lv6/JHe+EPHmseBNWOr6DIglkgEE8Uqb7a7g6+TcR8b0zyP4kPKEHr9KaTq/gf4m+Eb1bCCRtIilRtR0x2D3+j3LZWO4hfgSRPyI5eFlXMUoWRSB81+I7XSPE/hCy+J3hGHyrGRxaajahtz6bqAXLQSdCUkX95byYAkjODhlxXm/h/xD4k8IeI7bxl4IultdSs9yReYu+GSN/9ZDKnAkglAAkjOOgKlWVWHU4Ka7P+v6/I5YzcPOP9bf15ensXxE+GdnJZP8O/G+26s9QQz2F/CMK6rwssRPKuh4kjPKH5TxjPyx8Kfiv8Rf2QvHs3hXxJbnVfDd+/+naY5/0a+gb5TLDu4imAPUYBPyvkYYfpd4f1XwN8Y/AUup2KSW2ltOiahYhvOuvD+p4+RgeC8Mg/1UmAJ4vkYLKu2vNPEHwn0jxPo7+EPiDAlxsP7u4jP3XP3XifurDlexHB5pUMVyXpVlddV/l/XoVWwnPy1aTs+j/T+vQ+ufhb8LbD4i/De08U/Blpdc8KXMStExX95brnGxx/DJEflYH0r6C/Z6+NHxY/Zk8ZyDRxLNbRyCG/sJMiOb0Porkfdb8Dxgj8RPiF4Y/aJ/Y0+H8HxP8Agr4q1LSIo9VFlcJYTFA6zx7kaWIgxtgptBKHjpxW1+zF/wAFN/2ita8eWvhr4nSw+IxqEyRmW7tU+fccbZfKVMezgDHpW1DD1uR4jDTTS+TVv+AY4nEUlJYfEws9PQ/vW+E3xj8HfGLwZa+MfC8+FmyssDjbJDKv3kZexBr0wmFxt4r+bL4c+OPFVlrd/q3hq7m0xJA8ji3J/dugyMjo6Y45GQMV9a/DD9u3xDpHkr4qurbWNObAaeA4kj9ynBx9Pyr6LB5pGpBKpoz5zGZfKlJ8mqP2WHkKNgximeeiHr+VeSeDviT4d8caRHrfhy6juYJlDDaQcZrppdYOcLzxzXtKF1dbHkuaXQ//0P1ik1AjHanJfErzWAwwD6VIjMMD9K9OyPKuzqYrs/SpUvE7muVWSQDtUonkx9amxXMdYLiM9TzU4mB4HauRWf1pn29wdtLkK5jtPNT+lVnlj+6MDFcodTYZz0pTqO4gZo5A5kdCZEHK1Atwn/1qxftpkGM8U5SWAx3osK5ui4i6elX47pE5GOOlc5Goz1qRpdtFgudH/aCcCPBpW1FQAOK5fzcdKiknOaXKPmOge9yMV5t8XLsN8LNfLjIFi7EeoQq2P0roWncfyrlvG9t/avgbWdNbJFxYXMfHvGelZ1o3pyXl+hVKVpx+R+X+ly2dhA+jaswkgli82AkdVkUH8CM4rz/W7e4eQ6fpmo/ZSpysTcqQcMDnjqMVyFzqWq32lpp1s3/Ew0rcFJ/5aIT1+n8Q+mKrjxlo3iFGs9ZjMFyBGhJ4ZZB8vB9Mc18LzI+xSYzVb/xZoTRXSx+dA6biYuq7QM9e1X3+JGma7ZMl2vkT26uGEi7DgAjj646dq898U+L9f8KeHpDIgvre04LKw38jAU+orzx/HEGqWUE0IaBZE2zZXOMJkr+pH4VDdi7X6HRzeI7KOZbxn3iJni74G3aoOOnIP61o6Jr9w1rDBZ3kEO55BGpIJVWOVBH0bA9vyrzm71vwpZWM62t7HiUbSg6/IFxgeuAfyrsLLw94Kj8m705vvhZMduCP54J6dqm5Vkeix32vyzvFZXqKXbnYNgyMf0HNcwPBninRZftjamUSU5wfmGBzgZz/ALQ/KuMvNa8Q6dcrb6LD5iyKG3E/cXGB+fQ1s6hrnjTX9Ltobn/RYoACxUYcHgHp1GST9DUFG3eTX+mSxXFrdybUYxy7vlyjqefbDf4V3Fn4/s9Oghmv5EQOqcRsGb5h6D+6CfwFeIw+GLmdY5dVuGucb1O89c4I/DP+eBXoui6L4E+wtLfIkKxKPJZzlvMA4A9weMfSoV+hqrLc948O/EjwbJbtDJB5shU+TsXzCWGDg+hB7+n4VyWs2nifX9Ta8fUhZ2Xzl4toUtGw9sZ9TjjJPArivDF5aatfvp2gYtrdhl3IC7VPVR3+VgRkdvTFalz4B1r7a9pe3jfZVy0bO25RG2Npxx36Ht06YqZN7FpI9u+H+jeCr62D6VceexC+ZJGu5gpz86nvg53IfvAEDlkrM1/xfZeVeaN4ccW00SiMurCSJ26Y3DIbjoRgkHB5UY5DTfHFt4alu9P8LxGdIYtt1hVaMA4DHIOdgIG49UPPGMjm/h34X1HxR4pl1bUTFbm5nDGFvlKKeBnojdskgbhz9FdW0WpVtfI29G0iH4faNeeMvEBJneHzIH4frwGUMDkHp+nHFdT+z5azaB4CgbVIjLd69eSSMqg4KIdziRPmUr2xhyOykcjjPjpqi+K/GNl4eL+RFZMqGFQfllJweTng+oyD1xnk+265daT4K8HJJPMhaK32m3U85fgcZxyRjBxk8J8w2VdtbEN6XPJ/HOrr41+IOsW1jtdrkraEooiaOKPlgVRcc9/lAPfmvBvEC6bcfFvS9L0xlitNJXLiNnZVl6BsyFlU9sADHpXsvgOG8tPAutfE+7JgW73ugjaN3EZwoKq2A6jjHynH97vXx38GLm+1zx7eaxNvunvbx1jl2iNmjBxkgB+w7dKT2ch7NI9+uYLfwxd+JxFJNNPqgAa2WSPzUZlCh8Rk5T1DKre1Y3ij4dDwd+yf4osZI5VW4wHiZ2Qv7L95un+ycV6945ttOPxIt9P09Wgi0ezE7O0KTLvYZ5Ks34Nz+HQeT/HzV9J/4VMmiTCxurrVZk2JFH5cilj9/wCXofYrz/eq1ZP0I6WPn7xnqOlaX+xw2nQg/a5fL2AvLG6gkZChcI3Hrj6V6N/wTrtLPUbqaKf+BSSLoSCM8f7BB/X8K7j4geDNA0f9nyzsJbxrd7uNcxXEQQ/8Bk8yPH/fL/hXN/sVeDv7B1q+1C6txJbxKwUGNJg2f+2i8HsAKym9Io0itZM+QPiFFav8d9eisfskEf251CxxybNu7tlnP4k/gK/Uf46X2mR/APwv4WeXzZXKSb0DttBHsFH55r8+9A8CXcnxq1DXri2txb3GoO0aWUkWV+bhfKLSMp9Rjj2r7Q/a68VeLvDsnhjwvb2UVnaTIiE32l2c7txniUoHX/gK9Kwqayk+yOinpGKM39vu+1a1+Bngi18mJftLRqs3l/MdiZ/iQEZx2P6V8HX/AIg8QLcaHa3nnRSLja0kapnGOmADge5x7V9zfHPXtS1PRPBfg651rSpI4plkMNs5juOAP4A3AH0xXjn7X3gHWtO+I/h3X7Vbye2lgWMy3FzLcfMccL5i4VRjoDj2pR1jbsgej+Z9tfFrS7+/8AfD74n28s9zd6RcwKzs/wB6NyoIURhhnp1xgV9E+PNYt9D8Zt4Q8RyEaV48tvIQkMxSXZgZkwqbT0x83vnpXD6L4ed/hVofnpEspFu20pmRhxnaQMk8cEV8t/8ABRDV9R8N+LPBGs2qNFLBKD5kvzuNuCoDPIXUZHQKM+vaskr7djRu2nmeV/s56nq/7LXx/wBZ/Z0+IKxyeH9cka1dSTNFLbzfLGSwSJXwOGQDZ2KkcV9JfB6+tf2fP2jtd/Y88WXtxbeFvHGZ9Luo3EMtrcv/AKtgECqobAxiMAELgHmvlH9vmfU4vFHgf4hWbCV9QtVd5C7u6sgBCguzbR3woAr2P9pDV7zxr8EfAvxw8OxtDqWkfZ5mltvliWaIjcXzt3sen8qG+3VX+YktNemnyP0e+Fn7QXxU8C3Ws/AP4hCe+k0oubsWZME1/Z5yLu1VMxi6TGZoDGYpuuxDXjfxO1n4DaF8V7D44fHHwrBq3h7xBM8un/FLwvbf2RrWnu1u1uy6vDB+6vBHE7xnzbbzIlx8rMMjzT9pTxjr2had4C/bM8GhBLDHbtchAxaVXGJYhnCRrjP3SWJ7d62tS+J2i/B74qpbajBHJ8NfissKSW8u3yYL64A23IjHy8NwwkO5sFiMKDTjWdvIbp2fn/VjwX4kf8EmvF2kjRPC/wCzD440LxVoniK03aHba9dx6XNdWqJuX7HeQRvZ32EUERoltNGgBKsea80k/ZJ/aa0j4meG/jJ+0R4Qv/DV94f1FJtd1+QRXWk6naWyMRfNd2bzRW11GE8m5S48nz/lmQK/mxj7a0v4jP8As3/EC7/ZC+PmmPefDHX5ftOl6tLbwstreM4k+2BRGISFkIb5QxiIEmSd4HrOhftH/EH4NfFmL4U/HTX7qwSWZDonji0/0WR4lYiAX5Qol5Z/MFzOuwNkDK5rSdTmjaW5EE4yvH+vI/nx07X7PQkuNF8avLqPhDXIIItS/ssrdv5YUvZ6nZ7dwae13blC5E0fmW7KxKBaPw20Txh8PP2ofBVlp8sd3c/2xpUIudPxJaano+sTRxs0W7cs9lfWxbAO4cY4li+T98/iLrHwOl+L138Jf25Ph14CuLq8dF0Pxo2hQwskkyqoF/8AYzBtSaT95HdW7xOoI3R/KWPQ+H/2P/gx8PPELeDvCGh3ejeN/B5fWPDGg6xqjXtlcG6kcj+y9WufLeVJWBc2d0Svm+W6PGS5LrSShaG/6f1/WhdK11z7f1ofhz8avES6/wDB228F+DtKs/DWjeGfEl1dX8GmSSia21Nm8nTrwyMdyxeUm23AwsFwpUFnCMPlLxvcWHj7S9Q+IulwC31zTtkviW1jTajiVto1OBF4EMsmFu1XHkTHzCPLk317V4o0j4m/s3eOrvwB4rsZH1jRIzpmq6fq8bQf2lZyhS8NyOdguFCusibvKch13bSreE/ES01T4WeM9I+LHwomF9pNys0ukzXoBFzZ58q802+QZAkj5trlOQQUmTnbs1o01G0Voun+X9foY1KjleT+f5af1+Z5F4a8cf8ACvvFR1W4tG1HR7+I2euaWhCfbbE87Ub+CeF8S20gwUlXGQrvXUePPBUnha8s5dKuzqui6pbRalo+qBNkeoWE/wDq5cYGyReUnjIUxyqQVA25y/HnhLw7CLDxb4C8+Twvriyzaa1z801uYm2XFlOf+e1nJ+7Y8+YmyQFtxI3/AIT+N9AsNNufgd8UL0Wmg6hc/adA1O4/1OjapKcSLIwGUs775Un6rFKEmx99h0y2vHddP66r/gdjGNk+WWz2/rs/6tqcd4f+IPjP4L+MF+InggJMxQ2t/Zz829/aNyYZgOq55Rh80b/MvcH9mvgN4U+EX7U3hKHxR8LNcslR4ybvR9RnjhvrE5AljkViNyKTlZEyp+8Otfkn8RvAeu+HtSvfDWtWUlpf2JMU8Egw6OnbHToQQRwQQRwRXR/CrwlqPhn4Z+LviO2nRSixtrYWvnj5DczzCLCjHJ2nnHQVz16cK0ItO0tEjehUnQnJWvG12u1j7I/b0i0XwHpfhP4XeGtb0zxDmOS51N7KYXBiltsRQh3QlfmVm4IzxXx18GfCT654qRtH0pWkg/fNtdRHsU5OSOf0rwu81yTW7+Se4ia2uJHLNtXC5PuoBHoOK+iPD/wb/aCntLHwh4Jsby+l8QRLOVhHlSxQnhFMo2kB+u3rivThTjhsOqXMeVVqyxFZ1uXT+kfeM3jjw14NnkuPir4ytNMilJCW3nBNqHsdzenH3RU+k6v8FPFCrD8PrxdXkbmP7PJI6Nn/AG1Xyx+de+fsnf8ABA79oL4hvH4v+Juo6d4OtJQGYR2wvL8ng58yX5F/GNvwr9BPEn/BKH4UeF2/4RdvGeq3c0IGZjNsO7/dj2KPwAqcLR53anr+CMq9VwV5qy/r+tj8/vhD8YfGP7O3imDUZtH1O109v9cvM8Jz3AUlh+AxX75/Djx9oPxS8EWXjXw9KJLe6QE7R0PpX5ga7/wS21OW3C6B491CRR91bqZ5AP8Avomvq39mH4M/Fb4BWLeEPEd3HqWmOcxuvVSetfQ4FV6MuSa908PE+yqK8dz/0f1QJGcCnI8SrzxWE12cZqP7WWU5NelZnl6G+0yL2xVSW6xwaxJbtuSKqs8jNjp0oSFfojZ+1jJzUD3APQ1RSJjz1qdIHPQVQg+09z0prXHIxxUr27MOKqyW8gbihWFYsLqO0+wqwuqqvBzmsRrOXOD+VJ9mkA6HinZAmzoU1dcYz0qUaqXIwa5oW8iHnkVYPy8ipsirs6dZBJjJGOnFWF2da5Nb7y+/T+VEurqnzmlYpSR1ryRA8YqSI27DbMPkPDD1U8H9K4U66jnFWYtULd/wpcgcyPx3+Kemt4a8d614beY219pd1II5NvymHO5e2MdsDpx614j4t1WM2j3F9a7bhCN8sPO7GMHaOgx+X0r7J/bQ8KvYeLrLxzZ/L/asXktnhftFqvI9y8W049I29K/NafUZNAeC+Xe9oy/ZpxJ/rIFTkB+x25Pzdx7V8Djafsa0qfb8uh9lhKntKUZm1da5B4ohbSbWVJkvLYq6Z+YeSoH+A/CvFbbxjdx394LS13Qx7S6RvggkId2D2IyOK9t1nRdLa0tfGOmKscsEwm3oAoO4FXBx1U5NfM/jeSx0bxZFpU+2N7+1cIeMExYEi57Hbhh9K5GdKsew2OlnW0E2paeJRMylGxycHBU+h/un0NXr/QRBaiOK9njt1GVVcrwVP9GxiuK0XxPrVl4dFrGdxglVkLfexkntx0wn4jtV+8+IGoHSo5IIDN5pDKgwSVbr9MAEflS0DXoddo816Z7Sd7t5ZImMcpbjfgZP/fQz+ftXez+Kb1tLNn9ojjBweSGJXqBgdx0x/hXznbXuvTXLy3EC+S2CCeMYA+Yehxjj6ivSLSey0mWe4EcYUhzlyDk9T19cdqFLsO3crXHiDxusbw6ZaSGHnyZZz1Uc7ce3b2rzfRn8bT6qkN7LL9mZjIFZtqrnIx74I/Ku1n+J2jTW9zp+nzI8sXTn+LHAP54HoVx3FeQ6l8StUuN8akwqgB3BMllzkj06Zx0x+lL5lL0P0D8K2d/f20F7qFylvbw5cbMCSMgDkH1+b0557Vq+OfGr3P8AZ/hfTbkSJIhSd1x5gVuSDjheeg7jvXxdo3xI1XxBap4f8P7pFOMSHIYqccc9D/LtX0l4b0rTPB/houyFtQlI+Z9u1WPHzk446qQR/LFG+iL21PpTwroOg+HvBF7c6lGsbCAhWC4wzAjIOMbSCQ235l4JVkJBzvgxrEWj+Fta1M+e6xjasvkmU7T6xLuYgcZ2/gc8H5+k1rx1qlrL4a0y5DqxzGenl4xjDA4AwMj07HgGvfPAt6vgbwbd6Xfzme4m5cop3dMdPT6YP90jvCa0S6F2sm2UfDXh3Tjqa+MobgymWUsuf3iJnnch67D1yMY7qMED0X4nadod74jt7Ceb7Hd3WAfsyKzBNox+7Bj3oRjcgGdvKHACVznwatINY1t9bs5AGgYukcm5Y5ZD0XI43n+EgZPox4rmhKPEfxPku9SdJY7Y5VXwgT/YHIUeuAQpPK4yRT6Ng97HR/GjxRp2heAx4PuNs9vZoMtGiyxFm7SKwEkb9Cr7cH1U18ZeA7xvDMN7468uP7HYh5hFcED5h0+Y9CPfJ9zW38UbzWdf8Sz6dczBlmZYkG7c6oD3+62COOBgdOcVwHxx13VvC3huz+GPh1YBNqarEyGNZGVWPzbf4h/47+NP+72JuejeA/G1zp/wx1T4leKJ4Y31ecrGkoK79xGFBciNiew2g+4rQ13RU8aQ6Vq2oWcbTuyrHIB82zP3TvHK/wDA+PSvNPEWu3fhTSdC8DaPLE0DYSeExKUbI6bgTtx6bQPavaPC0za543tPDQsyDaqgKBR5h442sqjcvsVJzUu9jRJbnV/tM2PibSfDuk+GfD9w0XCedBudNyt2wjfkGTB7HtWdcQj4TfCqMahDc21zf4j80Rk7S2BghdrhfqjAelQeMtXOu/HSDwvAJUOnBVEVzKhiyf7jRmTHvwfQrnJG3+0pquoeOviPofgfQY5Uhs4wZUX592AAOvLbeQNruPR/vIrdtX2RC6JdSr4lg8L+DvCen61dRW1xfzvuC3D7GbgHqQxGexCHHWvGPEHh7Vvjr8XNK1e3020sW06JVYK5Ct+JjSMkepbnpXa/tSeO7Lwn8ONM8J6Ld2NzeXLRCW1uz5c6AddgYMknQYDHevqOBVz4AaJPpuj2+o3qyQG6YHNuCQo/3fMVW9uRWU1ZKPc1g1e/Yr/H/wCHGs/8Lo8KafcTnyoyIh5EabA7YJ5hXLEegZj7V4r+1fot3b/tI6DB9oMsNvaIhWYXFqN4PUKyJnjjcCfrXtWj+F9H8a/tXT63Z2raja2KCFoora3trk7ecyRpI+RzwWxWL480vWPiZ+00gg8NXWl6fo+2CFGtBaGQLySrf6pvTO5vw6VM7Lmt2sON3y3P0t+HGqXepado/h2NFig8hQQiyzR7x0Jlb7v0zX5Z/wDBRjWvFMnxgt9P1HSd2n2gjiS9NvIFx1I85k78cZI9K+4tI1vxD/wubS9OsdD1u2sY4QrNeNviLd9kaFk/4FgZ9K+If2xtCvPEH7Umn2FrfxW7wwoHjWeaByCerI0EYwMdmZayi+Xmv2NZa8ti/wDtN6VYeMPgp4CbTlQXUIAXyJIixVlwRzJu+vApIfHWneEfgZYfAXVYxLqupOspIuIisMZ4wSDIfwIUe9an7RQa28eeC/B8U8Ris7ff2xnjJDB84x2wor5u+M82jH45aaljcsw8hNwMSRoOg4VI0z/3031qYr3deiKvrofqj8QvDWoeDf2Vbb4P+IJIppmilkihHlmMRsAw5MiByM/woQK8t8SeDtE/aF/Ye0/Rdd8z+1/BcxNtJbuAyBFwHG0gYKHa27PsM4r0/wCNHiS7uYvCUdlc3EixW8kQXe0IOYx1dWAHp1zj0rxb9lB59Qn8ceBb9giXEYfYCsmSpzwTvUEf3ucdua54vljFrp+pvJcza8vyN/xX4x8JfHf9izTdQ8SifVfGXhy3Fva7HKqWtwVSebG3AC9UVXaQ8bSOK43wUT+0J+x0bDxs095r/gJ3WGHiGZ4Nv7v7TKyN5axqfLRApkCcBRnI+cvgjrA8B/tJX3w51YpLpeo3UkDQBcRvJJgq7Yw0mwjAVm2e1ejab4ul+Ef7T0nhvUVuU07WD9k1GOYqI2jm+VQoX5Qw4LD+EYARVxnV+6rJax/IyWr8me0fs5+NdB/az+BOtfs8/EPLeMvC1o8+iyzjM81moAaEc73aIBdpzkxEDdgHPXfst+O5Pjt8P9R/YO+Lv2XVtS0lZLvwg+q27SCC4thvks1O6GVVwN8ewq4wVGFwK8A+JWleI/gX+0ppfxW0GXmKaKeKUYG7bwy+pUr8uTzz+A2v2lteb4UftJeHvjD4CtI4GFxBrETbMCRsrJtDH1XKnGOucUnLpD1X+Raire96M77xNG/7Z3g3Wv2X/HIK/FX4cxXb+Cby6lL3N0IRvn0SeWRmdoplUPbF3LxOBnIGG/EjSvEvhZIrzwb47Y2fhvXpIZbm6kiYTaTfxDZDqIjJUjylPlXsfys9tkE5iVT+u/7dVnqnwu/aR0L9pP4d3gFnrv2fWrdp3/dBwVkEBWNAEAGcs2Cc8HivlP8A4KQ/A68t/jh4v8W+AdKubW0uFtvETw+QAG07V1VxdRNHlHENw8kM5XJC7HfHJO+HrJPlb0f4f1pYyrU3bmS1R8MaZay/CvW9X+GfxotpLfQrySP+1Ba5uHsLuNcW2q2YX/WqEOHCgfabRtuMqqVBrfwhurDWU8I+IYoZ/t0aG3nhYTWt5bXA/c3EEnKywTpzG44I+UgMGUejfADwp4o+LWnW/wAJvGGn3k8GkI8GheI7eIyrp9vnd/Z98oAL2iyZNvIm6S1Zim3yCQPtrwD8ELD4FeCJdA+Kc0HiTw/aX32rRdOsZVe+0+ac77oQSkqI7Vh88sUmIxJhk2t12r1nF2hrLy2f+TX9bImhSjKN38P5eXmvT7u3nHwb8OXEfgyy/wCGnNMubrRdFdLPS/EcM0a3S2yFwbS488qs8duqbo5N3mLHlPmwCfi79rT43fCv4z61o/gf4D6lPpHhDw7Hut4763e3+2375WS6YjOBswkSsAVG485XHpP7V3xu8b/EfxdfSfC2Y6hokn7q0sFmt7ux0y1VVXyIo8kSSPtLSzEE5JVTjpz37Gv7JHxy/a7+Mmn/AAp8LeCtM82dllvdRaOSzh060z81zMscnzKMYRBtMr/KMDcy7YWgov6xU+Lt2+RzYzFXX1en8He33ar+tj6H/wCCcX7Gnjj9oX4hqdUt01PTtFC3M8kT+ZDzxFHIfVj82zrtHoRX9h/7K37F3hv4TxPrev26Xd9O/mNIwy49s+g6D0HFet/s0/su/Cb9lb4U2Hwu+HNqlrDaKGurnaBNeXTD95PKR1ZyPoBgDgUnx9/aY8GfBPwrcXrTq00KE7dwHSqnZy9pU+SMoXUeSJ9o23iDwxo9oNP+4oGNo9K+d/ibongDxKkkum6c0t233XjHTHvX4UeOP+Cjfiv4g2Dx+Eb8aIcY3xxmV/bsa1vg34v/AG1vHDHVvD3jVJLVMHF7ZmPPt1HH4V1UKlST/dr7jlrOlFWkfpjFo2raXcjTbi1lUfw5FLeQ3MH7udCmOxGKr/DT4jfG7R0jT4nJY6iVHMkHyn8jXb+LPG0PiNfKitVhHGW6H8q+gwNTFJqNRaHjYqnhmr03Z9j/0v0QF9ng9qsRShzjtXOpEQavxKVHA6V6zseOdEoHFX4YYyMr0rnY2fp6VaS6KKOaho0TOoiji496mAReOMGuU/tEDqenSmtqzYGD0rPlZpzo6oKmc9qnW3jI3CuTi1Vgc5zWnDqa4xmjlYuZGw0EeaieCLPQelUP7QBqQXhYjbSsx6DnttjdOKybm2f+Ht+VanmMwpCC/wDhQmFjk5raTdnGO1ZFzbzjNehCBPT2qpcacJDjFVz2J9nc84RJj3wK04yy/erqv7IUcgfhSjSAcjFVzk+zPD/jH8O4fip8O77we3F022exk6bLuHmI57BuUb/ZY1+Bfi5p9LVrDUYJvMg3ZIX5vl+RlYdjwFYdmFf0wyadjk8dq/IX9u74RXvgrxRH8U9HhZtJ1+XZclBxa3+0nOOmy4C7sdPMB7kV83n+G5orEQ6aP06Ht5NiOWToy2ex+W3/AAlx0+A6LptysUc+dkM+VjII42n+HgfMp49K8h+Lv2u80+w1bBkmsrvzAYmGUDgxkfgcDPoK9b8U6az3saXOzDLvhfqroef/AB0fjj6V498S9G15oEOjQZCKskm4chgPmHHUHAPHcGvlYs+jki74f8a288T20xmhaT5XAHzBuzgfpXXaZoz3cIbSZvMkJOfcdMgdgPTsK+e9L1ifSLhItbgUXGNwZOhUDoffDHBH0r1rw74tgu7dbnTVxIvGE+XLL6dOoBH/AHzQB6va6t4m0yFJtSgXI2qduevYkf8A665O51vxVq8iWohXym6EDaPl4Ct+GMfWmap8R9VtbSOa5sWU8nep+SRTjcMdjkbh9faqz/ECeWZ7bTrYseOWXB2+v157U+YLeRueGtPe6nLTWcaEkgseCQT3OPp/OvSv+Ee0Tb5rokaYJKkYB29R+Ga8l0vxH4hknZ5oUKnrg4yWHX6HH6V1w+06yI7PVpFWSJsjy2+9jFS7IpHsGga74V8O6j9n0RIpbhQNyxgHg984wD3x9Rx8td54hXV/E9q1xp+ETq0cXyPuHIOMc5A5UH3UY+74rpWmaH4XheaJMbj94LnDqOQB0zjGFOMjitfQviFBLqxgt5y0EpX32Fe3POB/DnnHH1TloWke2/D/AFTT/C1u9/qDrBIVI++uD+nB7dPqOuK83jr+2tXGjaZKpBbYCR8uPbHQD+729K8/8W+H7S+1GzltJlnBXdnGSo9CBywwOh5XsSMYn0jU/DGg3KywTKbxBs8uRCCGOMFf734dRyMjcKdrIL6n17qeuWvgrwNCAy2098mCyHjB44LAhlOPmR1dT0INeOWvid/B/hm81zUn3SSZ3SW/By3TgnaQeg5Ct0zkYqa78Uz3emRS6j5f2QruEe44DnuQcjacdWCnGPmkxkea2Xhq6+ImstDYlre3RyohOCMjrhW459B7dOKp2VgV3oUfD2onUhL4i1CKPDuGWRYwD83QFeMLjH94D261xc09x4x+JEEkyZsdH6s46kdhkBgo6ccV6h4zhh0aFfCOloQzFAdiGKRM+oI/oVx6V0um+BIfA+jS3w2zSIhaQudm1iP4vLy4+oVgO9HkJPqfO/jbWrzWPirb/Z3Z0tVBSKbp74JLH82x6ele06PrOoaQbzxXdF4Y41yh/dsiOemfNkKde29DXi/wv8AS33je98YXNvthkkZ0KsuGB/uuvycdua9p8Y2en23gi8v7Waazuc4R490bk903plST0Abg+3WlvIq+lj0X4U3uo+PpL3xg1mLm8EZVokkUZ+gIbqejL0rhPh94e1tvHsx1ezlsblX8xEmLP93+6QsuenYAH0q78JI7bR/hvJaawYnjnXcsVxGPmYduVwfwK47Gtz4Py3Wk2Oo65d31xYWzZVUmd9u7GAo8x9h46DJNZ7pIra582fGvx/4i+K/xhHhS1uor7T9PKKN8DRyeb/GCVm2Pz0IijPtX3FoOtn4aeDV8SWhXzdMt97xWQhEzkDG11uAUHtnK/SvnD4Q+BL+88T6n4oggjuJVlYp5sZYAdPuCPdgHttNc9r3iXxL8XviZJ4Fju7qK1sWEbQWfz2zSDknDJ5uB/sbfoahy1ci0tFE9w+Dvi6Xxh4j1D4m+PolAuXJCtAkcxT+HiDMW7/dTHtXV/CvTvCuo3ut+LtS0+5uYlDmO3nuTvBGc43RRZz2Ai/SsrVYLbwV4Tu/D37q1vLaNf3g+dssOCN8Jxx2KZ9xWr4UE1/8AAnV9Lu7U6nuj82UxkSzoD/0zyw6dMeWx7bulEdGkwe116HAfsxeB/CN/8b9T8QeB/CNnoS5YGSwt1jZpB1dxDHD83rkV0nxT1fVpvije3uumacaSjMkMt8DEG7H5UcoDjp2rb+BOm+Cvhx8INS8QatavcLKjYQbQyZ6H55IyMfQnsK8N+MWoWPg/9ny/8VW9tJJdagdse1tjZk+Vedp9c4IrO3O9ev5Iu/KtOhw3wq+KPiD46fHH+1PFFnBIdOX7OhjuGkhCg/3jkYHriub+MujW9x+0HBNZy2rweZEDbrcrMc5AyEBRsEDsK7D/AIJ7eCb3TvtvjvWlcR2sRkknj8zzE92Pp9SK7fwf4Sf4sftOy+KL6W3uPsjG4aeJC5Cx/dDNG06n6jB/2RUtpKb+SLV3yI+lfjMt3e+LPCmlKzOlrBM+yMswUFAAfL2kD043GvNP2b1K/FTxLYMhKyW/l4ZCm7GP4W2nH6V2PxA8Y6ffeNNU1u6ktVWyX7DE2xTuAG5jm42DI6cD8q479krxINY8b6z4oknIsFGwZMcBx2VQxlQnA6Bq5pR9z7jeMvePj7x9nQf2vFm8kZt7yFjx12sMY74x6V7/APt1WJ0T4h6ZqyWzRHznWDe+CF4PyqpwBz359a+e/jTPHqn7T/2TSpIpRNJEh3K0cqMWAAI/dY/74x3Br6V/4KKKk/jDSo7WS2uDGdowi7yUjXdlhkEAjHrzW0laovQyj8D9T0b9pK5i8T/Bzwn4sZS0k9nAC+FGNnBOByR9OKu/tbWEOp/DTwN4jQKUewsm34xuIjAx6DoeK439ojS73w78D/AunXcxgnhs7eOSDy/vErvPzbu3+5XU/tAQzaV+zJ4Mgu41kNpY232Y48wFXJKbsfd+Q459MVzQ+xY6pfa+RL+1tYTzfsufD/WtS4ka2iAywHEXAOAe4xXaah8c9S8BfCL9n74spq4Wy8QJqfgTX7aSMPmK0k3WsxR/lkSKPfHKOro6kEFADwnx7urzxH+xB8PLeG0SZ2kuY/LZxG6+U7AGPI5+Xtu6dq+JP2h9Vmg/ZH+HngW9EkEhv9X1Mo3AUMghRgvZ8FlJ644pUo8ygvVf19w6kuVyfp+h9P8A7YN1c618HtR+KMdteS6x8Ob9PDPjjRdOmFuikN5VnrEaY+WKddkdyAMA4k4Abd+GXi/4vWXiOG68Mp4WWLS7oqZo4rmaO4fbx+9mRR5i/wDTN49tfsz4X+KmkW37f/8AwiXi2GHUvD3xN0nTdK8RWsqB1nF/pcUUhdTw3+rTKt1H0Fe//wDBMz9i34HfEXxl4q8eeK/DlpqnhzwzPGumXbSSNFfyzosqb4WYr+6jI3gcFz224rvw2J5IKLWujXTf/I83F4dyleD7r7j85v2Ef+CQ/jP9s65i8Z3Ueo+DPBqsudVv4Yna4HdbMcM5A/jZfLHGN3IH9nv7OH7O/wAFP2Qfhba/CT4JadHptjAA01w/7y6u5e8txKfmkc+5wOgrRl8XeHfCeiQQReVbxwRKqQoAqIqj5QFHTjtivNrLx3f6pdyv5nBQSY7Lu+6v5V0qq5NRerOVUYwXMez+LPG4ieSyt23S4ztz2r4P1/4B6P408c/8J346vZdQl37ltW/1CjsNvSveftBeV55jukcnJqNtz8+lfVYDKoRSnWV5fkeBjMxlN8lLSJh6b4L8B6PH5NjpVrGB2EQrpkurSzxHbRrGOmFAArEkWYH5TxVGUzda9tQitjyXJ9TpptaLLhe3pVQaj5n3ciuabzsAE1AGl7cfhV8qFzH/0/0hawGOBSG1Cnb6VvSoQeO1UJI8fjXdzM4OVGeEUDGO1Z1wfLJwa02BK9cVj3Kk8dqES1oZ8s351n+ey/dqxJDtOBVXyQW7AVomZuJYjumA44qZdQCck1Q+zNgY6Cq81owGKLhym7DrCcAmteHU4cDnivOZIJEOU7VYgnkjAU88U7ISuj0uLU49+M1fW/jAyDz2xXly3u09e1aMN67dTkVPIXznosV8m4BqupdoDya4SG7XbVgXxPfsKnlLUjtDdx85x0qOS9VB8nFckt4zd6ZvebIU0uUObsbcmoIM559q4Lx74c8NfEjwhqHgTxdD5+m6lCYZlU7WUHlXQj7rowDIRyGArbazmJ59aZJYSbSTScYyXLLYE5J3R/Nl8ZvhT4r+FHivUfhz4hRJZLX97Ax+WOeJuY7iAj7gkXO5Okbg44Br5n1DxLK0MqSo8nkbUfPyyopxjr3XnB6EFfQ1/Sn+0v8As76d8efBIsIylpr2m7pNNvG4CscbonI5EcmBz/A2GwRkH+d/4g+GvEvg7V7qz1vT5IruwkMF5ZzKFeIrjcPw64yVKnKkoymvgcywMsJVsvhe3+XyPr8Bi414a/Etz5f8eXGm6xajTo8eft3QMPlPy9P07fUdq4jwzb+I9HnH9mXHmQt99G5dR6jHdef0r3LW/B3h7xTE0tuohubdyCh7f4fyrxG98Ny+HLzzUVoVBwHRiGyP0yMf5FcUJK1jrktbn1T4GnuvFWjtbXc0NyYiV3YxnHQ4z7/h0q/q2nObXFugjeDjMQzgc4I/w9B6ivnPwL8QNN0DVPss7+WXYFsEKG6jjHqpwR04HpXt7eJVh1U3NrdeaJVIZT1PQ8j3xkH1yKHoNanNXM+ttfeTA8g52Mp+UHd0HHvjHFdPomnR6SRc3koLZBBDYIwMj9M/hn3rUk1PS75mtpwrMwzu+7weh9vy461xdzfajdTNaW0fnxZ/1ndX6/Mv8J78cH7wIOaWnUevQ94HjCW4tCNOZGcqVxIQUK9sj2PvkHoRWl4J8N6hfX51nU5R5u3B29vw6EV4FZ+CfEFvdLrctwgg4JEfzoc9QygYHbt7cYFfSukXNgqArG6FFwUQjO04xgnqPTcMHswodnotio6G94n8R/2G0MkypHLEm6Mo213KdVOQDuGODwwOMjjI8g0O51XxX4kl1NT5lr5glChSjLk5+50HPUL8ueRwa9C1SxPioeTfFzACWLfdZSOMEHgjHT+Yxitu3CaLpvl6NEu2Abiw+Vl7ZI6ge/3ezdjTbTXKCVtT0OyXVtYtDLKggtIDiOVSY5A2OnBxk98bHI4+YZr0z4Xm20zSZ5bbYsanbDsYLuJH3QX+Qn/YbbnoPQ/Pvh7/AITHxFu0fMiW0gKlwuQR/dI6Y+vbpXSa7r03gvRBommfvFY7FDEJ5gPUL1Q/Tj6elK33C1R7NaSafrXiZbucCQoAu05iKjsPmClP90gJnoaPibf6MkkOimSSBpQAomUbX9Qr8K2McgMD0I4wa8U8E6PPoZbXEu5LS4u/mXB8vC/3cHchGB8yn8iMVVXWLzVPEq6NqU8k9vLKN+xVQcc/Oqgxv7M0Ubr0LkUXVmyktUj32fw/pWgeC/OXToJpzlj5aMJcn3XY6tn1w1cLfeD7nxKljrN0rW0Cr++GTsbn+Pody9Mkcd67LWVi8U3dvpUAUxxxnywTvREX+6H3AY6YVsjpwODjzeJZNIVUbLZ28bfMiO3pz/CR/tbCOx7Ut9A2JPitYW2jeCjBZWdndxSx4khM/kvkcDIK7Sp4xxu44x2qeBNbuNC8CJol5dTRPd4VY4X4Xjptlf7vsCPTNcPqEE/xK8VQXRfLW7HEQXYpB64PHB9OAfc11XjnxBP4KitmvLMPIMRRxh9vPTv1+hGfeob7dBpWO/u7bTPCnw6utQuJoJN67UigWPzN7ccRu6gn8jjpmvPPgT4B1the+KTDKktwf3SIqSO5z0A+Qk+wGa3r3X9U1DRLfVJ7GKDcMYaONhg9iELN+JjI9q9ZTxTBpnw0nivtPiu7eRNv7sKiZI4DeblcewQfhU21UehfRs+RtW1PxZ8QfiTN4c8R37eRZyKPLnR4zEE/hxLI5H/AXC47CvpPxJFouo2mkeCI5rK9nhG0O+PNtc45im5MR7MpYAjqvTPmXwp8J6HLp13rek7NJlmfZbFY44ohJ0VAgMcfpgLKhI+6GPFdp4O0yx8J6NeeLvFd3FBeIWInuoJIkJTsxPlFQvOCSMd9tRy317jvbTsch8bdRvk1TTfhLZurQz4/fxxrMjYPI3iQMv4rnp2qh+0F4J0bxHaaJ4EBjnjQRlgkDuUf+H5kSTaT0x0rA+GVtP478e3vjfU0/wCPZiIUmlE8gT1jJCSMP+2j+zYr3vQ4Ne8Q+MJte1iaCLTtLQeQxjeMHK/xFm2sTxjDHgdTSnbXl9EVHpc4v4iDRPhF8Bv+Fc+F5ls9fugqmK/s45IX3dUEjKj7sdAjqf8AZNb/AMOdNk+AvwlS7DpZ654iO2LzFA5I4WNpiN2BztVmYDtWWza/8TviXDYtbm4g05lJFrIBk+nlyAnPsCf92uijgtfF/wATLm/t71IrTSso8c7xR7nQcDgxq+3HHyrjpxismto9vzNE+v8AVjxjxtqPgjSfDw8Ja1BaXWqT75W320xcO/diYpImznpuRsdM19Efs+eGrnwN8OzY6fCkEmquD5Pkq8ZTGBxtYH2zHz0rw/StN134z/Fz+xbuKaSGyfCmTKSBF/h6ZKnqFO9Om1q+g5/E2nTa9qk8AMWnaDGbGB51C25mVfmVSy7T6FGGeOOBWdTVqC6GkNFzHxDY+C5vGP7VSWmgW6w3CXsZeK2jPlR7DkkLvPlkY5TauP7oFexftUhPiD+0Xonha1QCSN1jB2/J++dVHIJyOM9gOmK9Q/ZX0zVrXTNd+LvjiGJZ4PMjif5oU29zy52/Kfl+fb/dGMCvFf2dbyL4rftM33xH17L2ViZ7rbIAQoiG2IFsDI5z0z7dqJy+KS9EOMfhibX7aepz6n4z0fwLpDmbzrlLeJdwba4xGNvcZ4Hb2rt/28dftbDTtG8DpEuLcxhm2AY8lBGgGMMBlT3xx0rwvwBqT/F/9sW31e2G7RPDUzTfvMqqJB83fI5k2jjAPtXlvxI1K/8AjP8AteweE8OLFbqGJ90m5FgHzzyAgsAAu8nBI449KSXK/wDCgcrrTqz62/a2+INx4H/ZI+GGhaewa5a1t2vP3jxSbzGZPmQHy5Ay8lXXI4K4r4j/AG29Xu7vwd8MdChUpqdv4Wjtp4V/illzInH95S+2vdvj34vsP2mv2h9L8DWEYh8PeHn867mB2otomIkHT7zcRpx/F6CvlrxN4pf4lftYR63qixjS/Dt5iUkhok+yFmGD0KgRg/QfSoorlt/dTf37Iuq+a6XVpfccnfeJ7jQv27PEfi2SP7XD4SmkuvJiUtldP0qKIKijqfOwAB/FwOcV/WP+wp+z037NH7EPgv4c6rFnWfsH2zWGJyX1O7PnXDEnk/OxH4V+BP8AwRu/Z8h/aD+Omt/GvxvbPL4fsr5tVuPtQDCa4eRpbaE7hj7581x1CxR9jX9Wt9qWmXEjnzN6L+CoBXoOP2V0SX3Kxwc99fV/f/wyPBtX+Gut+IIm1vWdRNnaw4bGOW9APwpltNFYJ5NocIOvvj1rqvEviSfWZFtoMrbRfcHc+5ripY/M5xj9K+uyjKoUIqrUXv8A5HzOZY+VV+zp/D+ZtR6tExGTWrb6hbt8u6vP3tJAc+lQ+bcIffivesjx7tHrEcsDptq1FDDIw3YryqDUriOTBrq7PV22jeamUbFxZ2UmmwtywqBtIUnPcVVh1UYHPXmtBNQibg8A1kmzWyP/1P06luoh8p/IUErtzXn0Gpvd3ShW4J7V1DXsf3R24rend7HLJpFy4IBwDgGsh2XHSmy3Rlfy1xWgtuNgyM/SrvYzt2MCeN1PPSs2VWbG0dK6uS3y2CMYNVfsm4dPpVqRLgcznb9zp2p+7cpHf/CugXTs5LcfpVpLCNjzQ5oFBnBTkg5btVDdtXArv7jSo85HGayJ9KLrlBz6e1UpoTgzkY0ld93T2q/EDH81aR0tl+7+lV5bOVTwKrmJ5RrXRQ7RT47o7d3QdKqfZZQ2cZ9KcsDjKgZougNGG7AOc4FdDY3MRHznn2ripVZFPqKSK5kjH5c0ONxp2PUxcQMO3tUoMbDnpXnf29guRx/Kn/2pL/CeKy5DRTOzm2MMp24r4t/at/ZX0v476L/wkHh7y7Hxdp8Wy0uHO2G6iHP2a4x/D/zzkxmIn+4WU/UUN/LyT9KnN3kbW71hXw8K0HSqLQ1p1pU5KcNGfyW+NvhrrGg6vfadqcc9hfWExhmhdSs0Lx8GNwM/dz/3yQRvU5PjOtQQmKQXgl/d9928BgMZHt2r+nX9qL9lrRfjxZf8JV4bMOn+LbOLy4rh/lhvI1+7Bc454/5ZSgbo+mChK1/Ph8Tfh/rHh3Wrnwr4ptbjStVsZCsttcHyp4Wb/a5DBuqnlHHKk18Jj8DUwk+WXw9GfV4TFwxENNH2PibVtW8AzzJb6tBOFHyhwjfu/wAh+or1Dw3ot8LOHVPC7pqEKqGizJuIGOnPUdPpxxWT4g8FCaZ0kv5YXB+64VentisDRzqHhLUEsYLncQONjbR14Ppxxn/CudtOPumyTT1PpaLTTeQR3+pxNDOOVBPCsPQj6fT8q6Ow1iKNGWS32Pjy343Lz0B/2SOh/WuQGuzz6XDPqCxxE/eVWBKuPTb2PUY6dDW5p9/p+ouj2UoRlGD/ABKVPYjHT0Pb2rG5sdBqvjK20i3Et1u8l8Ykj+8B02nHJ28Z/iHuKtaL4wlZg8e2S2I4GOcY7dvqo5HUAjiufu/BvhuWdMs2ZznarbgSOMD69vyr0LRrLRbSJYLLDqw2fON3ToNv8u47VXMOx3ei6mscTTZUpjlQfmXPQYH6fl7VvTXiXM0Z+4U+ZPl7Y7YI7dMduOR04ZPCmi3rR3AaRLhFJUKwb5OpAyPmTvgdPTFPmW8li+yW58tANhABIA4xgHHfkY49h1C0Qz2bQvHmj2FoNKsLhYLojbtxjP8As4JGM/w4OP7hzivRLbStG1qL+2fEVok7OMNKoy2QOAykAnOOG6kdcHLD5MtbvSPDcq311G96+Ry64VR+fr69ema9RtfiFea5Z+Rao2w58woPk2cHGOg+nToRV8wWPSdV8d2V5atolnaie3jIX72VVv8AZfGV5/hYcH7vqYtI0vT7J31G43pM4ARSVJTPYgcEehA6VwZ1IWG25t38yU/JvjyWHH3WBy3THBBGOgIwa0NKg1+7ufMeHZYDL4UqQ2cdAwK/h0P8htdQWmx7ZaazPp8U8mn2qXErZDSojMcr0BEILHp2DlfRcZHlGiwy+I9duNfuoPsVvEd6tafukJzyZNm2M8/x7I89+eT1ErS+NpE0iENstyNuWMRAXoMnJXA4U7sDjBxxXvNvYWnh7TTbQTortHtPn/LL05DBgqv9VYHHQr0J5dBo8HvddM+pppOi28mS4V22Rt6dGUo4PbkHP96teTwvc3WuwyaiXktoCw8sBRGsg6BwrdcdnKt6V0vhbw7pl9qpu53wtvnZ5WDGPoGO5c+nzLjvWVrja74c13+19OkhaVxgeVHl9g/3SHK+x3KO3HRbhsc/468eJo9xb+FNLhjmYcjzIrjZj12MiDA7GOQ/7xxUPi++1u28KWtrFcItnLhXMTSE/wC797I+ik+4qnoHhuC/1869qdtHNJ8zm5gHy4U8gujHp0wW+uK6HxOx8TXv9npGtwCoVNmHjdeoAIY8enLjuMU59WwW1iPw/qthqT2vhXRii2vlp54+Ztyg9PkeM5/2SoGOmetdJ8TYU1PTLfQdEtoo/NYQoFQkqF78hcewz9SOM8LqC6T8PdNFjHZyRX0i8oVMTYPQrt5b8Aa9A8Cx6ZoNg/jHxBMI/NHyFsTL75UKHGOM4XdUN9CiDVLGLwZptt4M09rZ5rkDMTr5UhUjqkMq7Xx1zEx9jWd4lnsvAejjw7o8i3FxdhVYIrKRu657gehDDPrTLTxCdb1B/Ec1xbSWtt9yIOYFb02CVfLyfRthz3atK4ubjxTfQ+JtZgVLO0YtASQHUn0GTj3CuAeoWsm0tvkaJHVaF4T0Pwj4WFukcepXFyNkkLE4G/PHzhsKPRonJ7DFZGoap4d8CeE00Lw0bq2m4TfY3JQqzdMxuksTAHgBiq+i8YDNHks/GOuP4ivbhvselgFFfcoz2A3hTj6MwOO2Kg8T3Oj6k/8AwlmsLapFp6kRSRxoZG9eg3fL6EtkdM1ns9C7aG5PeTfB/wCGtze2kh1DVtQKRi6mgXerTcKsiQxqqAk8ERKv86x/HGg+L/C3w703wroV95Wr6ovmXMUvzNcswyRyckrkcFZfeMrlh518MdHi8deJbr4yeK5NthZfJawybREWTI3AuVQKQARkDnr0GOv8Larfahq2o/E/XvKtlgDx20dxLGUKnoNrs0LZP3SW9g2Kna3L/T/4BWjWv9I1fjJ8T3+CHwu034d6LNHFNJF9kljtnSUiaRMtujyGUc9Fwf8ApmVrB0S18NfAD9ne68Q65cxx6hq8CZhliDMPN/1aP8pIUk5/1bDHPyj5h414d/tL4mfEub4sfECRrzQtHkdbaKRhJGzx8hI/MUOE4+ZQxRcfLxzXI6n4i1j9pv4i3MPieVU0DRZxPIAGjIjX7sWM8K44AyyD78Z2nlSil/hj+LHGT+b/AARseDrg/s6/AF/HWrDfrvjPBWIKcRWzNlA3XG/Bbr0xXk/wDmfwdofif4+6+RJdXqS2VnHIefn+aaTsTgBUz161qfHbx03xg8Ynwy87afpukfNqLBMm2iUfLGu3O7PAUrlSmTjivLBqGl+ONYltdSmbT/DOgxKiEt8sQHGNw4kOfuyfeYHB6Glb3fe+f+Qr+8uXpsdxomu6t4K+B154ltIGuvE3jfUVFtB0chAyQgHsiEtIc8DA9K+dmgg8OeFz8L/Cscuu6nrUraNbQ2zFZ9Tv7sgXXlsOiKNtuj/w5ckgKTXsd/4qsRoDeONZufsGnfZ2ttK3sFNvpMQ2vMT08yY5O8fwAY61+mn/AATK/Y7ms3P7XHxk0trXWdUgNv4S0qYYbS9Kbj7Q6H7s9wvPPzIhxwzMK2w1O95NdfvfRfL+uhjXqWSjHt9y7n6f/si/B7w/+zF8DdI+F8LR/bolFxqc8P3ZL2UDftzzsXAjjBPCKBXtN94ikmBhUbFZjkD9KxLgRq/k2agY9P8APasq6Mgz+HSvsMpyjktVrb9F2PmswzG/7ulsbkeqpj5zU/8AbEfPT1rjgrZGe9IwJ47DjNfRcqPE5mdgNThYANj6VMHSQAjt+lcP823Gaux3L42lqHHsCl3OjJ2+wNTCcJ8w/CsBJSepz7VY3r/nilYdzY+2svTtSLrksb/K3SsZ3BXNUhG2cjr9KLDP/9X7H8GXTzxeZIOorr57nYrEHpxXg3w68ZQGyMkkgHpXc3Xiuxm+SNh82K58HmdD2MXc46tCV9DsrDVkiuhu/irtl1SJowEr52HiGJbwRxt37V6La3JkiBB4PNdlDFUqjaiyXCcVsd5JqiMQuduKmgv4B1NeXXmqLA2AcdsVXvte+zWZdm7VvKcF1JTkevJfQvwpqQTLnnivAtM8ZK0gG7OeK75NaeNBKxAzWcZwkro0u1od7cXKBAajjdXG4HNeZ3HiRWA+bHP4Yro9L1RJ4tyN7UlJN2RT2udWREV4qm0UbPkc5qhJfmM7c9Kh/tJEUHOPWr5RcyLEkESjtVHavBjwKJdSjdeD0rNTUYeWHPpQmIfOoH3qobASAKdPqETDbmpIZIj8pNVzC5So8ZPGOB6UKmcZ5rejgt9vOPaq8sMQPAp8+guUox8DrxT344BqKRW5xxiqEzyRdBgChIGbCTIp4PA6V4D+0L+zr8Pv2iPDn2TXttjrNpGyafqcaBpIc/8ALOQcebAT96M9OqlWANesC6Zhgdqclw3UVFahCrBwqK6HTqypyUoaM/me+NPwI8Z/CLxJJ4R8bWMcFxsL2527re4jHHmW8uPmT1XAZOjKMjPyrrXhmVYWe9tooySDvUDIPs3v2r+ufxx4C8E/FPw1N4P+IGnR6lp83Ox8q8b9A8Trho3HZlIIr8V/2l/2GfiB8JrW68UeBt/iPwuPnkcRb720T/pvEg+dB/z2jXAH30UZaviMxyarhr1KWsPxX9dz6nBZlTre7U0l+B+XFjfaW1v9g1rLv93cyAHPbkcZ9Py9KtaX4U0yyvv7VjEjZfcjxucbvp2B6+mf02ruzbSYjL9iW5gcBx9mIJKnoyjuPpkelZia9pl182nXiqw+/E6NG3Hqh5Rh6gY+orxlLsem42PQ2srbxHC9pcGWxuo13Zj+UsufvDOVyD17fSvQ9PuILO1B1C5aWYAK0y4y4GOWHH48fpXjdj4rsb0CzjuA00YyELbWx0JHHP610+l3dwbny4drIOW5B/H/APVScuhSR7L/AG5bm2MWRKMB/Y+/Tg+4qCy1G1Z8XUjrGp7Hke3fivNbm4WIrcNKz8ZiK8dO3Hykeo/Sp7CK+12F4w/kn7oLc7fb1x7Z47cdDmHY9fa28OatEUnkLmQ/w4TtjIKHqeM5XkcEMOmVNdS6DCuk6BCQvQ7ztIH09PYHHptrhrGC706PZqEqSyD5VfjDH0zxxVW48R3KTfZrq1aE5PIHr69vcA/gaqMmJpHW6RcatAv2zWJEdUJINvkgpngc5wfpgA9FFfQ/hLx9a6hp40lFEPmcB3GVb8/ut+h/Svn7wt4b/tb/AEvUpCFbG0qdrFfTHccfdPPp0xXp7pBabYdMMcixjlXXa+D6H0PbqvpzxTv1BHu41DSdBssxv++QDkcL9QABsI9MKD044zY0uWbR9Im1XVpGmW85jRHKqqDvsK7QPfGB6g14BHf6vq11/ZyDCjqyqWwOnzDG8D1+VsfTiunuLPXYPKtRcxxqB8oIK5B7o4+RvwII7ir5kOx6hoPjCPTm/s7Rcusvz/JyAfcf1U/TFdbqt7oV1FBLc5+1A5C/I4DDt1jkB9Pl3D+96+S+HNO0Pwsr3IbdI/3sRhhz3IA4/LH0Fek6PokSImt3QhZVUSRAzGOMqehDH7o9PmZB0DDoJXkM19fl8V6JZx6loMVss8p+9ceZHI3HZ/lYnH+3kevGKq+AZ/Jlv/Ec8RmllB3xIRKit7kCJs/70RPqe9YetT32rXklnDHJBtx8jlPMVfqQ6OPQ8n0Ndnrlrpuk+F0tp9QWObG/ayMA3TgbSUz7A/gOlW3qSlZHnLz291ek6nc+W4fei7ZNjeh2YdQR3Plv+VWvF1ldaze2smpXTwW5QbTb/vY5FHUN5flqQP7pTK+grkPs/wDaWsxWiO0bR/OyOuB7YZTj9FIr2vU0XQtKV9Y/dnYu7a5jJ6AN8o5477WHbNQ2VY8rkii8wLbvbXdjZ58w+Wcx/TfGksZ7FeR71U17V5vGc0Vhbs8UMTbYYoej9uVOM+wxn8K0rW3gezuNRu7iaSFnYxLOqbzns3lhA4HQN6dahGs6L4Wi3q2zUZ/kCqhUKMcbSRj29vSsJyV9DaMe5ZvXm8N6WllI80fljeViYDC/7XAH/AR19DXnVvYf8LemS0WY2+l2XyF5AIzgdgVKYX/eJXOOBVDxdqX9oWQslltZ7jducyYjI9jtwrDHYg9sYrnNQ8Uw6Ppy6aNTMcsqbZfs7fvnUdUi2kELjjmoXYbPYPHXxBa1mtfhd4ACxQWSj7VcW+9WjUD7pAO5XJ67cIRzg1zuq+I9L8X2EPhzTribSrS0AR5MYBXuobjax6Z5Uj0OK8n0LVbf+wxBplqul2yt2lZ5nHqc5wfYEjtgVwHij4u+GNCMmg+Dka+1iQqpQDdHGM9SzY2nHrx2p8t9Ii5rLU7v4p65eTaR/wAKr+H8mI2CwIkLPEYVBBHUA4TqTgfyzzmlao/w90Sb4P8AwylW41K6+e8uQQBGQBmRyOAoU/IvrxgGvAfEuvpYWiaF4f1VLXVbwE395MQcL1+V8/Lt7IB9DXP2Otapc6SPDfgmT7Dp75+0ak42z3ZxjIDADaeufuqB1q/Z6Lov6/pE+01O8k0qGwM3g3wsz3AOFefI3yXjHe8jZxhVX5WzwmePSvPbq90nVLlfBNuTdeFNGuljujb/ACnVdR4PkRDj5O7Z4SIZOM5Fq7u21nRH8KeFLwaXocbiDUddON9zITzBahvvtkDJ+7zk5Hy1+gX7OX/BP68+JS6dr3xHsZPDPgiziCWmlMCt7fRMdxEinBjikPzSu/76cnDBUGG7MJhJ1pcsFr+Xm/PsjlxGJhSjeW39aLyOZ/Y8/Zx1L9qn4mWXxV+JcaSeCtCmjkt7bb/o+pXdtxGFXA/0GA/c4HnSLkfIPm/o1t7lLeMwx9D+uP5D2rzPwf4U0DwdpcWi+HIFt7WIBVRRtAwMDgcAAcADgCu8iiyPmNfW5flUKCUp/Etuy/rv+h83jMwlWbUNvz/rsdAuoLuAFQzXSyfM1ZvlDA9cVFLC4XIPsMV66sebqXHnT7i1DJKEP5VRCtnJ9KRk3fKDQCHyXfPXioW1EKeuP0p7Wr/j+VYF1bToM1cWiWrHS2+qBh1yamfUtqg4yK4GI3McmCOn8q1VmfaOMUnZDT0OhGsjOwjFWI9WD8Vxc2R24NVZrmaIYTn29qtRTFex/9b5/wBI+Jc+iReQ8u3B+ldTYfF9lYPJKCFzjBxXyF4tmvURJEbINJpdtf3NruRiD1r+fHmGIgklLY9LkXNZI+4dE+Ji32oLMZcDrx2HpX0Ro/xKhmt8yvjb90g+lfk3pet3elXf2UybduK9wtfGs6aeI42w2K68s4hxNCblc6nTpVYclrWPtXxD8SrVCTFKBXN678X7NdKKu+Dj8OlfBWueLtRVS0pIA7+1eb+IfHGqXNqI7ck/TvXrVeJ8TJ3Rx/U+RPQ/SzwB42i1nU1w4KpivbfFfjGGygVInwAvavyf+FfxEu9JaNHYhj1zX0pqvxCj1HTBO75+WtsNxZVjScHua0suU1zH1b4b1qXxAphV8AtgV9BeH7drS1WHrXw98H/FNvCwaRs5NfSEnxEgt7tI1f5W+Wvt8ozmm6XNUep52Iwr0sj2S6nxz6cehrjb/WUR9iHPNZWo+KbdbRZUbIcflXD6TqEepakXlYBB6V7dTMqcnGMGc0aDje6PSUu55LfzM4H8hXF6t40gsz9nEgyOOK0/Eviex0+waKEjITjFfHWpeJHu9cAVsg9KxxmbU6TUbkxoSPrTQ9amvojN1Ge3pXoGnyTNjdx/SuM+H9pAdGjkcDLD+VejwqhXagxjpXoYatGcFImdNotrct/Cc9vpVtLtfuD8a5+Vmi49OntUK3QfKpXZpYy1R0/nREHp2rEu3jc4FZ7LcPnH3fpUsVnITzn0pKyG79iq3BytWLdcdsYxWhHpx3Y6YrRhs0Uc9vSqckSokUcA43KPWtaBGQ5jO1l6YpirGnLY6VKbqGHAFYyl2N4QPgn9pD9gb4cfF15/EfgbyvDXiCQmRikf+g3DnkmSJMeW5/56RY5+8rYr8Ofjp+zp8Uvgne7fiXoclogbbDexYls5ew8q44XnsjlHP92v6tpZt4+XjFY2p6bZavp8umajDHc21wpWWCZBJFIp7MjAqRj1FeHi8ko1nzw92Xlt93+Vj08PmNSl7r1R/Fbrk76ZILhLfy5YSOVHluuPbkf0rs/B3xK0zUiunLIILlyMrIpVJcfT7p+lfvv8av8AgmT8LvHHmar8Jrv/AIRK8bJFq8Zu9OLH0jJEkQ9BG+0f3a/Jr4sf8E6f2nfAU0t43hNNctFyfP0WUXK7R/F5Z2TL9FjOK+dr5ViKWkoXXdans0cfSns7eT0POPtFsrvBPGyIwySBlc++Pun/AGhwfata1vzpsa+S37k8AvwQfTIx+AP4V4xout33h+L/AIR7xPFPpxizGDdROVU/3W43L6cjiuv059dg/wCJlpEyTWjYDRlt8eP9lxkgezDH0rynpoz0FZ7Ho0stvIhe8AEZzkZyD+A6flWjYX9jNYRT6ROhxlEVRyu3sM8Y9gePQVyVzqGnzW2yeRS7fxqcA49P4c/SucgXR7TV/t1hA4lmG2Vk+5J/10TOGI7NjPvSUhtHrdp4j+zN5l3F864BI4P9MfjXb23jCLVY3hktpNsY5kKiJ0Y/j+hyreleVxahaoom8gyNGMc/MQPbnp9KojX7u5PnWKyFAe67UHbrjA9Krn0Fy2Pe9DvdSMjLCvmIozuX5WGP9n29s4+ldbJNFcFJryXzf4goGJAPdh1+mfwrwTTdW1u42CWNrSEDhnI2fkpJ49q6WC4uDIPtG2ZP4X3hgR7EZ4/zinzBY9xPiS0REtorVZEX7pwyOpHPy7cfp19Kr6V8TDrom0SwSVWjY5jUeW+71Bxtz+AJ715TPIpjKXcpaOVSpSGQggfUc4x/dbI7VH4OsfCfhey+wWw+aQsyr9qmd8t2Bk3dPSq59AUT02z8TXNlqg024sXg2HcvAXA9dmRge4IrW1nXLq+1DNqRBGAMmNuGx7Ef41g2kE6RSS3myZnAVWaRskn/AHiOntXqXh22tlt2tbpQfKX5x91UI9SuM/XNQ5lqBzkHiZfDatcywrJdYBUFwu0HgMcYx7VzfiXxT4mvryG81+7aYzsPKtYkAYH8MAdOelXNaeLWNWlmu7wahFjCWqxoI4wcDGFUeh5JJrSk1aDSWeRHM12wxCuwKseRwABkfT6Vk6jeiNlTtqyv4h8Tw+G9Djv9aZZLoAFA52xw/hu4P1/CvniT4karq7NceF7KS9lZj+9/1Man/ZHLH8cV2l3oc1zetqXiI+a55C4yAD/dHAr2T4bQeGbiXylhCcc9se+P8BWkaV0Z+06Hwv4x1DxrDbF9RjkgUHgCI7fp6/jmvHP+Fm3WkkrpWmT3FwThnl4x6HGOce1fvVoPgPwV4hswNTsFlgYkA+XkfXpgYr8+/j34C0LSor6bQLdI5LQ7wpUAmM8ZVsY/HpxWqhbdGcm+jPz9vPiLrniQ+Xr1+Le3BB+zW4ZCPx4PGO2PpWNf6haPvtfDyvCkmP3vnqhb/eBO7FfQngj4d6J4l1VbXWMPvQkZBU+xHbP04r1LTP2Rfh8fFcWpX9pHMLaI3bPK2VVV4yVPTH+1xgV0XjHoYcrZ8dWsT6fp0MurPHfInziz09GlLc/eeTGMfQZPY17d8JfgN8ef2ib4/wDCD+GJTYS/JLf6hMYbOEHAIaTBB4z8sSyN2JWvu74dfBvwrr/i3StNhgDx664EBKAYt7bbvYYwAMsAPpX7R6V4dsdB0q10TSEEFvZxLDFGowFVBjA9K9HKMEsXJynpFf1Y4cyxLw0Uobs+Jv2ZP2Dvhz8ELuDxj4ymXxT4pt40SO4lhEdlYgDG2ytuVjH+226Q926V9+Iq+Zk5PNUViz944qbJUDmvsqWHp0o8tNWR8zOtObvNm1EdoyuKui62jKntXPx3LNgfyqyIml5ziqJNmK9c4JP0FXhMzcEelc/ArDCZ/wD1VoNOEGWHPt7VLLRqfKAAe36UzcikNxgVireM3NVZ76UdOhpJDdjqTdxjhTWZNKjHca5dbycHA/8ArCrX2iXG0ngVahYzctDoYLSGQ5OAa1YtMiZxjoK4j+0ZYeM1oW+tSouGNTKD6FwnHsb8+nRRjIGeaz106F22lcY64rNm1ppRtxxioIr0q2Sc+1JXK90//9f8fL74jT2tuFusbo+o+lek+Ffi54els1hdwHIxivnDxVYQ318IbNNzNz07Vh6D4H1lNUVyNiocg9B9K/CamBTWh7EKdSEtFc+mLi+Ora3mEjHXivUNHhmSZYZuFGDyMZHtXypba5N4b1lTK24jsOcivcofHaX1iAPlcjI4rz44KUTqhh0ruW56n4z0+xu9K8y2I4HAFebeB9E+1PMl+MYxg9q42Pxnd2r7blvl3dc5Feh+CfGGk3VybbzApOM1pyytax0Qqxc1oZGs2UWkam0tocqPu1Le+LHFutvG+QMZFega94LGowNfxElQO39K8DVEtb2QynIjPHviuepRko6kShOLtsme9+E/iLLpsaFnI9vpXotp8YvtF5F5knAOfxr5N0XWbW/3W23DHjHSn3NheRXAawbp0rSjUqw0T0M6kJKKaVz7/u/ifeXdiqK/ygetc3e/GuTw/F5cDEkDmvj+08TanalNMuGPPTNJr4ujbtcxnJPPvXdDNa8U1zGc4Rmrpan1nbfFi68QWO95MluOaz9AuNTuNUFzKfkQ9fQV8peFvED2UAMmVCnNfUnw/wBfttQgM0wABonjatVK8jfBYKlN6n6B/DbXIW0+K1LAlQM17dd+XbwrJkHPpX57WPjtPDT+bv2r+X0r1NfjnYXGlMJJPmIxivrMp4jlTpezmzPH4Cnz+6fUGrXsf9lu0DAtjn8K5zwrfG+ldZMHaa8H8N/ESDWrd7ZZN3brXQ6X4qi0q5cs4+bAr6WnxHScYu55Ly2bd1sfSyXluF5wFXiq7anHu/d4xmvM9N8Qi/G4t16Voy3qr8ucDvXt4HEU5w5+Y5cTFp8qR6Cmqx4wOaedRG3D4GK4hHbG5iB29q344EuIVZD8teipwZycrLkmqpn5fzpFvvMxtPHpWBLNaK3k7vmqGC2kD4QcA/hUqUZPlRVnFXOunu1WMbecVFFfbnVR0rMWBh875GKepMYyR+lacmguY6JJVJAHapZCG4B5GMEda5f+0No9KcuqZwDWTjYuMj8HP+Chn7DWpad8QR8YvhZq8sI1qV5LixMpDCUcsY1PylT6cV+cd94A+I3gfT31a4vBNN6bApOBz0x0r+hr9t6DV9R0rR30e4eCWEuwIAeM56hwe30r8qvii/jZPDqR6xb22Am0NHkL83r17V8Hm1oYicIrRH6Jk2CjUwkKkt3+mh+c1j8aLZ7t9O8XaS0EhbDT2vzrx0LRnaT/AMBr0rTIL7xPpM+ueE4/tdra486e3jkPkg9DINuI/qxxXhnjmyeHVJp5lC54ypyPwr9rf+CMdmo8MeN9bV8EXlva8dCBCrfl81RgsLHFTjGHu/ic2Y3wsJSetj8z/Dsl3E/259VNzbn+FIww/wC+lJB/KvRY/E1jHcDMqRKOSAM59MjpX9BnxQ/ZU/Z1+LE8t54v8LWgvpuDfWObG79v3kBQn8Qa+EfHX/BMCSSZrv4XeLwAp+W21m33sB2UXEODgerRmuvEcP4mGtO0l5aHlUc3oy0lofmLq2ratrubXRJoLeJjtcfdDD3GOPw4rt9KhtdH01LPTHVvMHzNH82Sf9rt+le+eIf2C/2qNFjYx6LZ65jOP7OvYZD/AN8zCA1wJ/Zx/absgFu/AuubV/gFtCQPxRzxXlVMFiY6Om/uf+R3wxNF6qa+9GBploUKTMnmMP4cgqB68/59qtv4h03QmE2pt9iGfk2AuxB/2cHbn6V11t8EP2l5kWOHwBrcmOBmBIh+bsBXe6H+yf8AtXa7L5beCZLJTj95fXdtGD9dsrN+lTHC4h/8u5fc/wDIp4iivtr70cjpXjDSdRZWjidAFCiRwVZv0U/THSt7V/GOn2mif8IxoeJJpABLtcqq5/vMBn8K+gfC3/BO/wCNWrR48Ravo/h9DyfKaS9lAPsgiH/j9fWnw8/4J7/AjwxbD/hNJLvxPOTlluG+zW2f+uMRBb/tozV10smxlT7PKvP+r/gYzzTDw2d/Q/Iqf4l6JobNptjNHu6eXBgE/UdSPwrgNX+LqRNvW6j3/wAI3jd+X/1q/po8K/CT4R+ArMWfgnw5pelxqDxb2saH88Z/WujNro8cmY7a3U+0KD+lelT4aklrU/D/AIKOGed3ekD+VW28deJ9ZmVdOW9uZBzsggknyB6bVY/pxXovhPxx/ZGoLaeK4J7OYN9y6jaB/oAyhh+Vf04q1rF88KohPHCgcD6Yrj/G/h7wV450yTSfGel2uqwSKUK3MSycY7E8g+nNbSyB29ypr6ERzez96Gh+SPgL4u6Pp0RdrxhLGhC4OJOOnAOCAPYZFfJnxy+J3g5/Hun31xNHHaa1ObLUNhwqvcKQjleAquRg4x83r1ql/wAFDPg14c/Z4m06/wDA1zPFp2ot9nijdt7x3aqZCyN1RQo6dO1fmpq7zeJ7Vb/xVIZkkUKZVUhtqnPX2PTivLeGlTlyVen9aHp+3U4KVNH1V4Q8X3ul3F9oN7y+m3Mlt5ucFkU4RgOx2EEH0NfcWiWV3408Hz+HdSuU01b+e3udfvpchLXS4OVhDdPMlAA2j+H3Ir8+Pgp8LNW+IXjSw/sSO4v7++niihaXhXb7qbvoBk+2fpX9LPwT/Zd8JfDzQbaLxi8eu36ESlXQfZo5PVEP3iP775PHGBV0MHUxM7Udlu+iMqmJhQjep8keQfspeCdX8W+Mrz41alZPp2gWsC6Z4ZtZU2yfZo87p2B7yE5z3yPSvvxYI1ADdq2fMhUBUAAUYXaOMe3tVfC5zxn+VfX4LCxw1L2cD5zFYh16nPIjtrWJ2we3GKZqNrDCBgDPtU4Y25yOnes+5kE7HHb+ldOrZhZJGEk0URyx+UVb/tKJVwCKzJ7c/dxiseezeIZx+PvWqgjFyZ0n9q72ODTPt7OMZ/WuaihfHWru3a2xlpuKEmdTaEE5z1xxitxLW3uRlQK462lkTDsPpW3ZXHTJyf8ACsJXRvC2xpHSlj+ZQB/KlTTiRgDj29qWa9VVyvX/AAqzY6lH0bk/oKz9pIv2cTHutNcHPp6dqh+yLEOTzXQXl9anj8B2rnZ7vf8Acq1Nsl00tisYos59KWBVd88c+nasaaaYdqfppuGbc4+XNU4O24lNLSx//9D4CuPhfo2hXqXd06sxGAOKs6x4csV06Sa1i4PAIrA+I0txFfRQlye59Fx0rrfDXi0XtlHYonmgYDcdBX5FDGU+XVH2McRBux886P4DTxBr8j3OQEPGRXs/iv4aWeheGvt0W0FU4r0T+zLG01NtQshhYVy3FcrBqd94vvZLXUPktBwgPQ/Qe1Y1a9O/KjrgqS92e58vabdaXqUbWWo/LyRz3xVfRvCE9lqf2+0Lbd2BX0XqHwKS41QapAcRA5UDvXpt/wDDE6ZpULWwH09Kz5YrYmeGpy6bHGR+IpYvCyWZZjJjHXmvnZ4ryC/kjv8A5UbkH0Fe96j4M1ltRjmhGEPJ+lclfeFjf+Jbe1lI8vODjtXPWpRlqxVlBxT7HmEuhtbkX+m8Mfm/P2rq9FuLxG8/UBndxwOuK9b1/wAMWNlOlqjADHBFZcPg2B9s8R83+IkHgVzxw8Wc9Pkb0Z4N4t8S+Rfq1pGcqR7V2XhjxIutReTfjaMc5Feh6n4I8PXuxtufXgdvSuU1jQtLtpY7Gxwjn7vaqr4KFtGRVwbUudP5GwfCdjPD/o5AFWfD2qR6Ddiw3cA9jWVHpGt2NusMM5bjnPbPpWRb6fMk8l1csRKDwfauV0JRWqN40ZRs7WPSfG3id5bQC3fO3j0rjtM8R3rw7Zt2PY03QfK1a5+w3oKgcDPatz+zNO0m7+zyN8mMA44FXCnbUwqU5VJc/Q6vwX4q/wCEcErtMQSc8mu6X4mvfqHjkz6Y9K+ZPGujCaVRps+3JxwcAiu40Dw3LpOgi+kkLYHSqfM9EXG6/d9EfUvhf4vz2k/lTyV6jqHxjENvG46H+lfEXh/+z77UFcv0OPxruNQv7Rbj7GzfLgcV20M1r0ockZHO8JCp7zPvLQ/iTb3+mI8hGSAfpmqer/Gmz0iF4Y2/I9PpXwvpniXUtMm2xuRETgZPFbMGoR6hIrXjY3Zx/wDqr0I8SYi3us51lsWvM+1/AnjKPxHeiWZiFzxnuK+obbUdKNqChHy8D2r8voPGX/CN4SzIzjA/GvaPDXxSlmsFSV9p64NfQZXxAuTlqPU86pheR8tj7WudTsuFjIHFZq3VvJJt6gelfIN/8Y7ezu/JklweMeleu+GfGVvqtj9rilByuevQV9Jgc2pVpOKZx1qdj1y8e1VQrYxWVLeW8K5BBxXjsfiiXUb9oFb5VbHpXqFlBa+QDM3NdlHHQm2lsiXSdr2PmD9rNZm8BQ61aR73tJcFT3D9q/F/45+O5ktLa2gMiMUw8bAYGRz0/Sv3g+P0NjrHwg8RaY7FSbMsCn3lKngj0xX82/xWutauNbbT7wRfuVVRInBfsCfSvj+IkvrF49Uv6/A/QuGKr+pcj+y7Hzn4n0uLWkVLM4AKjDDB/H0r9+v+CTXw0m8K/AvVPEE/Ka3qrtHjj5bdViz/AOO1+JH9izi3ZgAzk7QAPvN2Ff1Sfs9eC9H+EvwX8N+BrLkWdlEXJ6tI43OT7kmjhlynWbW0V+ehz8T2jRinvJ/l/SPcY9Iic5P/AOqnS6VCuAB0FQ/2wMBR26Yp0ep+acnivuFKR8NyxI1so9wXH0qZ9NXb8ox+VQR3DmTLLxx0q82ohG6cDmm5sSgjDurB0+8c/SsxFdPlQYxW/dakk7BDWZLMp4IzWkZu2pMoLoV/tV0q8DHWoxNcqu484FaVqYXAWluPKB+X044odRbWF7PzMybVZkjwSfSs9r6cLuFdDHYRSw/KMevFYMlk0cm1elEJxegpQaCO/OApbGAKy9b1vTdF0y41nVZ0tbW1iaaeWQ4SOKMZZj6AAVflt3DZIxivkP8AbdfWIv2YPE/9m8ALam4A4zaidPNB9tvUdMVGIqKnSlUS2X5GmGoupVhTeibSPxv/AGm/ieP2vviVFrFgGh0PTleDSoGHzmJyC00i4yskhAO0/cUAdcivR/2cf2XB4m1OMT3SfZjtQR+Xui+U4I9Rwa8q8Af8IRdanGdZ2xS5yfOTyn57K4xzx2av06+Buj+ENM1C3urTU7xUADRtDdN0OPTcD6Y5r8txtepWm5VHufsWW5bRpwUYR2Pp74a/sq+EPgddWd7p9pAblrx5FlHOxVjY4Hp1FfRsdxMpAGcGrFlq41TS7e7vLprny9/kpIE3YwF3EoozwNtQm/tgwIHP8sV9nwlSVPBNrrJ/ov0PhONV/wAKCh/LFL9f1NS2mmJwTnt7Vth2RV3dDXLW2qx7vkq3Nq+9AOB/hX0jnqfKKGhryt5g9KoFvK+Uj2qkmobxxxUE94mc9x+WaE0LlOks9OW6KtnHapdU0mIKB96sDTdZMPCkfNWs+pm4XkjFL3rle7Y537DIhwo78VbhsHxnGMf/AKq2o9sqqM8EVH5yRtij2jBU0YUlu+78akWPGBjFW2hDyF+3FQzqsC5J6flRzhyFZ1ctsGeD9KaUdc88VSbUIoXGDVa71yNOF709ewtO5vRRdVJ9q0ltFfqOK4uHVgGABzjtWsmvRD5ffHHTipcWUmjpTpMch5Py+wpW01IQSpwKzotZ81SIuKstqG6E7j2qeZorlR//0fzr8I31xqgmk8RIpB6O304xVnSvEWlaDevGijDvwR0ANfAf/C2vFWtTJZwOEto+cqe4qM/GTV7xD4e0tUluOcyOfu496/DVhqt7HsvE2jGKPu/xv491nRbg6Lo4WcXWAxHbNMe5uI9Q0+CxJXy13S9sV8dfD74g3Pgq/e912dbp5evzBsY9M16FP8etOudTcFQTKOq46VDpSizRYhJc83r27H3frPivUNI0GDUrSL93wCew461wul/EbxDrVvcapD81vF2P+FfGmpftEzXI/sS6k8qzYYAzirXhTxT4g13T5o9AuFt9POTljyx+lbKm/iegfXJVZ2p9j6V1Xx7qSuiOWWOThttcL4u8e6b4Y0s36Slrhh8oHXNeQWniG71VZId/763Gz1GKoDQB4+RrHUG2yr930GP5VCjd8hNOtLWB6Dp/xLbW/C0l7POBOM7c1zPhj4t+INPLae0jSGQ7QTzxXF698KZNM09Rp0pQrglTS6T4S1STUBJbguIcYIHpWM8O1sc86VVNWPrjw/dTtb/abh/mIzj61zawJruueTI22XI6entXE2GpeJU1COKeLbFEvPau50zxHY6PerPdxhZZdpH0q6T/AJuh6cMVyWvseiHR10Zg9zMxwM4JyAK8d8dePbKz1EWtjGWXHQV2ev8AiK1vdVhtbqXaki8YNdPafCbwtqlg08cqvIw4B5PNdMKnM7S2OqGKqVHyw2PKfBXidbyb7PLw7Hp6dq9nHhJ9Xh87d0HGDWT4a+ENjbahJ9kflR0NSa/4nn8GXiafJG5A4UgV0exT+FHox5eX94jndU+H+tD5i7bcema6iLVmsNCOmahk4Xbk+1dJ4S8bHWiYruJo1GByK1fF8/htrHyEADMOBisZUrbGEqEIpuDPmDSnuo/EZbTpT5Xfnv7V6yNRMbC7uCfl4+bnNYGkWNjpEv2uJdykmpPH3lQ+Gm1GwcbsbgK8nF0uXVHDKg4QckzsbfxZo9xH5G8bgMYrsPDto2u3QMHEaDrXyd8MvBPiLxxIdVMvl7G459PavqrwXYXnhyV7W4k3Mo4rlpwlHcWGjOfLKS0Ne8+xRaz9guGDEdD1qn4k1NvDFkbm3J2ryPwrldbmvE1wX8ildhz7/lXdalfWHjPREtIEDZAVsV1Rk3sdFWipJ2PlDxN8U7yR/OcsF/hPrXvfwm+OVxb6X5dw5x6e/wDhWD4o+FXhyXTAs+A2MYxXn0/wxfR9Pa50iXO4cAfpXVS9vh5KrCR4v9nVnO+59xeAPiONR1Zpi2U7HoK+hB4+tE+Vph0r8stP8aHwZoTF02yjg44P4Vc034nahrKrKJWVeAAfSuyjntWi9DprUYqEYNan6HeMfGdpe+ENaijfcXtJASvOB9K/D/4t6LIk/wDaEKYWf58Edh+tfpHoGutdaVNpgIkEsTBgeBXyz8StB+1XOZFGyNNvOOM9h7Gul5lLFRU5dND6vhmh+4qev6HzR8NNCttd+IPhnw7Ou4T39pG4HHWRSePoK/ppXTt67YPlVPlA9hwP0r+e/wCFmnNZfHfwzdbPkhvon+gUH+Vfu1c+N7GxtkldwrP6V9DwxioUfapvex5HGFNudLskd5OBbLsc+1aun2zbN7nH/wBavLpfFOnS2yXTSD8+Ku2HjWC/njsrJsg19bWx8I2Se58hRpc26PU5L2K3b19KoPfRSkZGaovbOIhK5yc/hSRLtXcR/wDqrspq6uRNtOxu2lh9rO8fT0rTl0lNm48ACsyy1a1tUKSnBq5NrCCL5COnak3K9kUuWwy20xM5U9fyp0tiYyTnOKz7PVyjYznHpUlxq6ZDEg9sUm2mNJWNKNwqiM8kUx1gbn1rIGpxs2AMmlN2sg2scClysE0QXkZzn07V5f8AFPwXH46+Hmt+CLlA0erafc2ZXpnzYyo/XFesEqZAeKSQqNhHO05H4UnG6sxxlZprofyfeD9c1Xw9qCQ36J5i4SSKT5MOnyspHqGBFfo18C/GNveatAq20du/CqTs3ZHHBZR7d6+e/wBoDwBZaD8efGHha3RFgh1aeSMN2F0FuOG7DMnSvf8A4C6JDp0y3Jj2y/6pXjhBXA92BFflOOmqU3F9NPuP2zKuapCMls0mfq1ol7f6hp6zzvu4CL0A2qBgDHGB2xW09m7qJe3atfTNK+yWMMbLyqjcMY579OnNSTxMIyq/pX6dldH2GEp0V0X49T8hznFfWsdVxHd6ei0X4JHOD90eBjFR/aJ2kyXG3v7VZaOSRioHK0r6bJGoZwRxXoN2R5aRHcaqsKYB7Yqg2rhlznoelYmpeb5uxe2PwrK2vjA5q4JJETbO0sdUVmLsPpWgus/v9mf8+lefKJEGxfw4rX0yFFy0vUdCapysSo30PSrbVFQhd3ao5r8l+DXFvfQofLjOfTFaMLeZgnuPrU3RVuiOuhuyyladMfMXGcDtWLBLHCdmetbAkhLK6sAeKm6RVmYF5bEuQg69qxX06beNy8fSvSre2t5vmb/IrTXTrYjBwQBTVZIXsbnnSaaIVz3x+tZs8JaXCnFekXVnFjaOKyItKzl2wOfzpqogdPocyt5Lafd/Sqsurz4+f9K6uXTVCnjPr2rKk0cOCFGR7U+eJPJJH//S/k70Xwx4xGsDSsyLbbiruuQAPWu6uvhpe6PfeXY6mNsvRgefcV7jqPwb8ZWOjsbfUnH8TkJnAPpXMR6N4S0Tw81tqV9O92WxvYcY/pX5vJtK+nyR71HARtyyRymqeCItGtEuXvhMHUco3QmrvgTwPpc97JLqmp+So6BjwQawNFufBF7qT+FnZ7p2OQwNenaJ4DstklvbymVNw3JjBVaxqUZWt+hcsFS5lK2na5ueLfg1Cmq2lwbk3FoF3J5fcY7muD8T6lrulSJpWiebCmflUdz/AJ7V6/rfibUvCcsS+FsTRwbUdGriLD4h6/fa3Jq13YRqi52hx92uH2ber2Rw4iFGPu09DuPD3hnUtF8O2Pi+JXmkvDsmBPK44rP07V9ZtfFSGYhYlzyOPwqCx8Z+N5XDFQlg7EOEXARfYH2qtryWmh6jFdxSeZDOd8ZboR7fT0rkr05JrlMKmtnT2R7f4q8Qyz2UOm6eyySzkKcdceldCNSu/C9qFgAEjR4Y+lfIyePL221P7dOjZ+bZkZXis/UvjHf+KRJZ6dDJ+5B3kDHT0q4UJyvodEars5deh9QadqereOtUTQtJulicE75Acjj8q6PUPDU2l6gtkbkXLxgF2B9a+DPh/wDE+Lw/rUiGXZJOf4zyK+i/BPxN+xyahPqUondxlWU5z7e1YzwM6bu0bUIwnG0viPpDVvDtpDoSXW7zZ1+ZVJ6e3+FauhajBcWkGoJefZmXiSHOK+RJfiLrN7qRna5byI/3ixL936V1GleNLzUf9PnsxFHLlSx5X61k6FveaLjU5J3ij6lv/Fh0fxJb3um6grq/+tAavQr/AOIXhHUIke9jDyADrg1+dV7pWr6brJutPtpL5SC4CHjHtW5o/jCDU0Gk3UMtteFSEEi/dNdC9pH4SpYytF+8j9BZvE3hoaf9q0eESEgcLyeleUya7fah4kQTRGMMp2+leX/Chp7GF5tQnCBScIWx09K9O134k6AyeTbRAzou1eh56dRXOq0pfEbe0lOKnN28jivE3xPit1k0h7YhA5G8D04riNTuvFGtaRJe6OpkiiOPKB5/wr0NI9Ku9JkHiMJFJK25XPqemO1dJ4W0PS9D0uXUdNvBM5y2wEc/hVSoRlG8jD963yyeh57pHjXxT4T8HxpFC1rLIRn+HGa9D8GeNvFMLtq96vnbR3rj9V8ZWviO5bRLy38naODjHIrqrA6npmiZ0zbdRAYJTG5fwrhq0FtEVOXLNNy0R0Ta9q3i6/dmAhX06Ctjw3qN5oF+2lMTmXJQ/wCFeTafqt7qEvlAqhBycHDdMVNr/ipdFuILi6OJrZvlHqO4zQqfs1qdXtIqHOnc9L1218Qahcn7RIVhBp/hW6jtr7+z52L7jwO1Ubf4naLrultcKwL8Lt9Kv6aml22mPqyOvn84Xv0ro5tkCxeqlA2/Hnh/w55a+ftGSM44z9a5JvC2lS2udNdQ3UYptv4hi8WwvZ6i6pKmQB/9auT0XULnSNa8m8b92pwOQR7Vy16XWxjUxqlUvbQ9e+GtlqI1iTTLtWkjWNuaxfGGkn7bhgFiKsenA/Hpiu8+E9zPdeIL664e3jjHIOMPJ93P4Cl8axqlveuobaISEbsT0rrwdNU6MV3Z99w3D/Y5Siur/wAj5Y8Dx5+JWm6iPl8iReccDIPtX3V4jv5dYsPMtrkjy1JUD1r5B8P6FP8A2st478oyZOfujpXuUfhXVbDT5Lua43pk4OentSrOUZPlZ5vEND3qbktLP8DyrxB8W/Fdjdf2bAzFU4Bz/Svof4HfEi50+EXWsMTIecmvnHW7uxsNhvEVSDwx5/StXw1JdXNyGtAFjxWVHMKtOopp3aPl0qfwn636B8SdM1zT1dnA284rQfx1orHyUcErXwD4W1K9jjNq0uwjoM8itW78S/8ACM7prybfnlRmvqMPxjOnG00byymhKHtOY+n/ABn8R4NPVfIIAx1rW8G+OYdbs9rSemPevia/8YPd2JhYfPL3PbPSvONB+IfiTw54g+zJkQ8U48ZSdVSktDz62DpKygfq9vnhtmmjbp6UzQ0udVkPmn2+mK+UNI+Pzz2ixzphOBntX014e8e+HLfw+L1XXzpB0zX0OE4joYidou1jCWBaWh25sEacRK3zHsKmvdNk09RKxwBwR9K808N+JRdaubp5AE65J4rttT8U2urn7NYkNg4yOlevHHqesXoZPC8q95akkt6Gbjt0A7e1akFwhjzIcnpXMTC00y3M10wB6/hWZp2vLfOVg5QEDPareOpNcqepEcNNPY/Kr49aamr/ALU3iqe0baHu4FAP/TO1iDdsdRX0j8D9BaOey0x4gIzdA8f3V+Y88Y6eleVWOk2/jP4wax4h+0NGdQvrkqyj+AEqp6YxhRX2L8OfCUmk6wguB81vG25umSRjPp0r8srx+s5tGktnP8L3f4H7bQ/2PJJVmtY0/wAbWX4n1I91bPFuXr6Vyd7dIr4/SsM3D2ilmb5R39qxEvm1G+8m2G4DjOfSv1Z1owe5+IuDktju7K4tEO9vvdamv9QtNvyjPHWrMPheT7B9oLc4zXG3ttM0hhAPHH5VSmp6oHTcdGQ/abO6fY3NX49Os5CNoHFc0NOmhlyB+VXreS8/gGPrWzl2ZilboXrnT7VOIxz7f0rDlsQGBPatkRzfec8VHKJGbb1+nApxqA4+Rjrb+Vk/3BnpVf8AtVrc7R+la108qwl9hzjjj8K5Ka3vM7tp/LpVxae5m1YuHVLlieMbq3dJ1e4ZvnXIxXNh2xtZOQOOK2tPIX94qf8A1qqT0sEVqdHdeIZLMZxgUyHxbP5eN35elcpq0hdP3dZemDzZAsnGPSoVuW7Ret7I9QTxI0i7ZMAGtsa5AsXPJryq9/0cAqc8VkveXsw+UED0paS2HqtD2f8A4SC1lXauP6Cr9rf25PqK+eF1KRJCueBwfauih1SfAY/SiULBGR//0/w21v4u+Mj4+svDOn6Xt0t2KmYL+6I9z7Vqap8JLHXr99VsZGWO5RllhGCuemR7fSvaY/CvjK5v126WxshlcRYBBGOeara94F1BLCGbTrYJO8v8MpB2dMbT3zXwDskrH1zR4doPwD+EXg7ybnxHsj1CRtsDFiOffpXQ+F9S0fQbuaGCww3mbGkYZCr0ya6TVPCV7Nb3tp4jXzrK2t/OdXj3qqjoQ/8ACQfyr5u/4QvXtR1a70q01LyIDETHceZwjH7q5ycjHt7Vw1+eTtzowlFppR0R6L4s8JeC/DmqHXb3WjNPdEvsX7qknp+FaMkWh28D6g8bXMKQKI5No2kseCfavP8Awt8HvGmt+GLuHXpWkurWQDytnVcZDg9CPpXZ/Dv4ZSxxTL4u1qfT41i3WzY3RKQ2Nrr0HPAPSub2bi3zPTpY4nCUZ/DvsedeKPCvjXxBdLdaEgtBckLGrHA2j0UV1U3gU+E/B8fhDx5O11dSt51pLtA8hsdCf7p6fpXWpq9/awW2hRGN9QtpXaJpFKmUbgo28dOau+Dd9hrOtw+Ib06vcatJ9jhsgu9YLePmeTk8KOgxznGKr2y5diqclpzI+aPEug6fa2Gnz3NxNKFl2yxxDK4+oq14Z0Hw9fapJalZLNI0dtoG1uOnbHNfRmmQR+E7u5tdMsRdRiNJHEg+RJCcqMnoduOKr3X9qanpza5ewwPJv8mSWDDbAfYV1wqRcbHTCpF6s+aLfw/4I1q4+zRaeUukcrub5WdR35rubLwzpd1KujcWksfAx2X3r2S7+Dvh6XSE8ZHUFSHoGlJiZWXqP8MV4Po2j62NcuP7Aifud7ktkH26mteeFtWatRTWi+RzGtePNO8DXsmn6RZ/a50++7ABcDg1la78Q7nxBb29tGn2XzsEImQPw9/pVm28P3Gq6vc6deurXEMhEhC4GfSvW7P4Y6msBudSEMMMYwkjgbf/AK1EqcLbA02rI4rWPF/xK0eSBNFhLWqxAbmXIXPvXCa743jhV9V1e5e3ueOQB079OlerTaD48jneDRRhCvzeaMo/pjFcxpvwO1m91SOLxO4cvl02D5ST2+ntWCwkZO8l9xM6V9L38jS8R6vD4A1e1bWblp49Qs1uLcbshkOM4x+FZQ+Lq2NksNrZukYY7mbG0jtXpzfCi08Vaba6Dfwo0+l74g4kGUiPIGOwHp6Vk2nwwhttObR9QiW7DyDawPzAdv8A9VY/UqO7MpYd829kbWleP7DWfDR0++xIr/d9QPSovCnjCPSb97fTZWMarllc/wAqop8J5DqYtrS3C4xjcSuM1o6V4Jsv7RuNGuJPszxfKTjr+NYVcHBddDW/LZtbGrc+P9f1HVXfThFMijvjI/KlOv674c1WHUrS58tZBh7boG+lRv8ACf7Jb7/CUp85TtlXcGVj7e1Ld+FfG0SobqwDva/Nufpj6j0rklQUfh2MaqTjtc6qfxlr2tWzajpenRjy+XdDtIx6jvWS9+vimweDSxLcagcAR9gB19qqQXGo+Y+pzGK0ja38r92+PN9Tt9RVrwN4d8faRcxeINJK3tmycGFvmCj+RxWbhFnLCnzSstUcwnim30OOXSzEY5Yf9aB1yKu+HfiaNe1AWIkdEgGf94DsawfGfhe61nUZPFmhxzxadduUmbblklXgj6VV1bwzJo3hxbjSYWeQ4Z3AwzLURwkZa/caUMLUlPl6L8jorzXfEF5dS6vp6vBFCw2sON2Pb0rY0bxFqU14P7Z/1UjD5s4I/D0rzTVNN8banYRXHh/ENtEFWUSnaK5rxfpHizSprfVAMAptxFJu3v2CqOc+ldEcJ7ttjslgKVP4os/Yj9n3Tbq1+E0+tTRjGuahJPCxbduhgAiHToARkVq+LrWQaCLaKPeiz4ZsYy3b/wCtS+EfBnjf4bfDnQU/tgLepZQ5tHUGKPK5ZeOh9a4LxZ4s8X2NnNPq+nxDH7zCtheOmBWNWny8tPsfqOUYeNHBwiuxD4c0aa6mmnygkOU2YwR6dqoeJbjVdNj+ztMwQKXUHodvUfh3rr/hDe3+vMqmPajfvMMM7fbNcJcNb+Kta1vwNrE4SVLyRbZydpjkPQf7p9KznGMvdZyZ3lMsThrQ+Jar/I8ZtdRbx3qR07ywXgUkkHHStP8A4WTpHhbwm8DKIrmFioyecjpXzJf+Htf8EeKb6fWXuYvs7Ok/kEheOn4V0uj+JvCPiDTX0+6i3XikFfMIX5B0A/rXnSwzjoj8rjSn8DVpeZ7lpXxNWy8Px+IbyRlklGVVe3pXJ3HjbxJ4muxr0okktlbhQDzj+lcb4q10W+mW7x6YDaWn3grbtxx2xXqXh345aGnh628PS6VlpwFMUQG6Ncd/an9RUktToo4WUnySnZJH0x8OfEOk67p/laxGAQvGcZGK8/8AFE2gR66I7mfyt7bR9B0rP+HOoeFRaanfeIGayjt3AiZmBLE9hXBeIvsGs6rFLdncE3PHwecVh9Xs0mdtWn+7jse7aPpa+J5DoulzAMq8EcA/StRLXxN4ddtNeaUeWenOMf59K8E8J3XiGXxBFLa/6MD93nbnH+elfS+p/GGHTvDj6frUCRyfwv647/jWvsOVHVhsNBxcpu1ia01vxH5bW/muvlgHK1reDPjLd6BPPZ3YLyRdD68V4V4X+KghupTcvE0N0fKAfjBrJ1v+1PB+uyz3UInsJ8Mk68qN3Y/0rohja1KKVKRlWpwlaSPedb+MXinxDFMWfyYlOBnrj/8AVXYeD/jIT4fv7KDjybd/n75IxxXwD4x8c3ZmW109SyzH6c1678MpJZvCepSXcbYCrGSBk5PJHQ9sVGCxWI+sxfNp19CMDT9tiY0UfS/wP0Q2+qHULX5/LUbl2h/3Z43bcZ4JxwcjFfbJlstAunkeQANbo4H3fvZznP0r5Y/Zo0G81nZ58zxTiItGrFgJfmAAB/hb0HQ+lXv22vEV54M1qy0bQgyTXOmAn2G8jnFPCY2VHG/WLbX/ACsfqXEsYwyaUOnu/mjR8bfEqNVmEMvyjoVr1T4b3gutGN/gbiP1r8m7vx9rkumwWphbzB1GPSvo74WfGnVfDunJpN5GWXrk9q+gwuer6zz1dmfj3s+ZWR+l+jeIruS3aC7b5E496rT6lbyz7BnmvmbRPiLF4iZIY5RCpOWx6V1Nx8RNIs5BZxuCIioLetfUU89w17Rehg8HU5bs96uYrZYPlPOPyrmAQuUT6cVRGtNd6UbpTkqCQB6UnhDWbbVpWjmOw56e1epTxcJNW6nNKn0Lv2+GJRHKD6Cug0uexAE0+B8veqmpQ2sOWgHy1wV3rEf24ab0ZhxW1WpGNr6CjE9Wn1/QoU2kqc/SsSTWLG6bdEoPuK4g6Sc75Bkf5/KtyWW10TTmv7ocIM+nPYCtVGKV7mbnrsLeXlhbPjZhvTvVX7ZGxGAAO1R6HotzqudY1IbQ5yqn0PSuhk0uzV1gJCsegPrThVQODexylyV/i6HkCsyDPm70HGcV2F14emj5ib5BUCaK+1XVcA9a0dRIhUmVfIingx6dMVmZSMeVIPYY/pXXRabDE3lhgFxg8U+8sLeCPcArDtjtWSkr2NXB22PN/wCysyFh0zxmrcQVIihGM9/pXdxW8TxbioPtWNcWUVxn7OeR+WKt1GyORJH/1PgvVviFdarZW9t4Wb7PeEEN5EijPHAO7BBI6cdK8i8cWp1jw5Hpty7adfLL5lwspZzJnhGUr15xkCqPiO3t9Dki0a3nuJhLCHeBIYgvHVgy/MCGwN2cYPNZmsjx5NprWWk65dJFKuVjhjWSWNpeShk2qeuOv3T7V+d1IqUHGx9lON00c/4Jk8c+C9K1G3uroXSXCMEtbuTy0kEq4dC3O1W7Fwp7CvBddY28z3iWsmivE6iCBXWSM855f2HC5Fcb4w8H/FHVvENtJq1vLHDCp/efaX+YHbyQuNz56E8ewr0f4ffAbxbIus63e6eqR2CxzXfnTt5kaO6iJ1GGRmZ2CMvGCcjOMVw/U7Rvf5aHnVMNOaUI30/rsYGk+ONTjv3tv7ZntYU4NvdRsY+e6yJhlI9SrKRxXuvhX4u654Jt7Aa1HBrEhjlRbcgYktmyQUPCknH3SQV7elcDqnh/wPYXJ1fwdO+r6RG4humvTADbSsm9kijhjbKox/dE46ZPpWV4U0fSta8J317o2m3txfaJEZbqeG586NN7D5J4zCqQttIchZshSGHpWNWhO1+iJVKvDrscD48+N0Vx4pu7vwtpgt7gMsZkcti2tm+ddpJ74weOK6fwZ4ge31aPxPAyPMIVRZGdVUQzkMTtPc/d2/7NcPF4g8MyWk11qiQI1uWdobpnucQ8YZD8rnb6qW6/Sq/h7V/gXf2cU51uz0NlkM6iaG4QFhuGAyx4I7quWPtVxpXivdd0cVGnPnTcv0Pp/XdcW1trbwuIPO0+W5NxezRyqk7h1GCwzhSuejFfSuTbxHY+HtB12yu5109ZnTZPIvmAI+FTGM43Y5bpzXlmlaPJq9m83hXXba6vbVnFu0pi+SIYO4x+Wspw3QZII6qMV6VoL+LbmBLD4gKl9e3FwlvBHbWuXe3OFcFkG3AY8O+EA64xmp5dLSOyo77q3Y9G8O+GrvxT4UneOKV7GC2tpI1jkDn/AEk8ugbuMY56Ctvwd4k0L4cakbNtFu9X1C2K2x81lTCMc5JH3SB3rzTwv448M/DG1l0/WtTS6t9LVhpo0m4USwqMsVlkdSPlG0qhBGc9RxXUx6r4Xm8MXPjKC0t9QvjAI55lO9mmcgoELlQ0jqQMYAPXgCqhONrPY3oYmnCKa+Lqjn9U8Uxa7qlwUgntILiYiC0ES+YmehaUYL5PRuBViyP9t3UljrV25jQDbblGXIXrl+mRXaLqHxP1LS3tNH0KzELKC0lw6RW6k44EhO9yBxgBVz04roE8GXXhq2t9X1LWNM1hLwGa6t4RvawMXB8zO0ANwFVc/pXTTrU9zs53JbaeljntL0kw3EUJtpYrWVGVTJ8gQgcZ9ePStnXfhl8QtD8MJ4kt9NuFjOWtpJJNylCPvquc/SuJ+KkOg+H4LW/vdQSMzJm0iLCPb335LY244xge1cVP8c/GHhbwhJoFrqtrdabDFHNFsf7RPEzHLADJKgegP4U3iOa8aQUpUuZxm7WOesTfXdjf6Prc32a53ZgfiMvIegLA8+mMV514f8ceOvD6Xdjq7Nvhk2/MPM+UccdxXovh7Ttb8Xebq+sWqW+nM/nruh2zyMBwyIOcZrd1HRdesVMQv7ZC2Gi8yIFz3ILcEGtI03a0jOuuf4TzC3+MfifRLsG6kRIDwJTllHpu/u13Op/FC3k0uRbi3jBuSS8rcxsQOCrDnB7cVir4Nv8AxPdzWETyGSIlnEFvsyMd2IClf8OK8X1LwhaQ3msaL4m1W4ltNKSNwlnG7ykyt8q7Xwq+56D6Vzywbm/iPLnQr7KWh0+mfGi0TUGt/D1vJ9oTJaONmmI44IAHAz6ius8OfE3xt4lghiW01FpQNsuLWcpn1xtxjscdK+v/ANnN9e0LTbaTSnh0t54hMsUxgW4nBGAzhccAYx1zX1DqelfF+5vIrjTr2Y/IcINkQVvZRwf8KmNCK91RZ7uE4bfs1OWIS8rbfifmDqHgj4leK4Lq3tPCeqGQxeYWhtZVQOOBt3KOGra8JfBP9pLwsl3oWiafqMKCONnlzGiiQjLKu9h9DxX6EyfDP486rP8AaJtTvwJRskIlYbh6YHFUH/Z28eNIY73UXi3DOZGZ29Og6ZrdYCFrNM1hkFGMuZVXfy0PmPTPhV8ek0iCG7jtLNTjdDcX0ICPnqwXcKq6/wDDHWtVs/sHiTxppdo8LHa0LtKU9chFAOO1fXVl+ytcXsqWYvpLu4OCyopyq+p7DHua7Q/s7fCPweN/ihptTu0XJtrZwqDA/icD9FBolhMPR96ei9Tvw+TKXuUuZnwxBpnwxsdKj8P3Wvanrl2WAAsLVYi59FDbmP4CvoLwB+zJcG+i1S/0lPB1hKMvc6hL9q1aRDz+7i58rPf7te3w3/h3wrth8FWVtogcfMbdd8mByMyNlvyxXFeJ/HySQSN5+52PIz1Pv3PvXDUxlNfwYf1/XofS4Xh+nC0q9r/f+J6L458M+DtQUiDUJoDGoUStIVdyP/HeewxivhX4s+L9f8JWN1p6ag8sPl+WMgfxcdD/AJ9K6vxR4/vJLcR2MhG1ceZjJyOwHX+lfD/xrl8Ra3pDjTWm8085z1J7mpwmHdWpeZ15jjYUKXLTWx+kn7F/jO21/wAGGJ7mSe4t3dDjkBR2xXj37S9pq3g343DxfpjeTBqKRXKr93JX5Xz27Cmf8E0bCfRbe50e+bcwBSVejZHNfSf7d3w2TxL8L7fxdo0iR3egSC4YSNtT7NJ8kucDkJwwHtTxGCUajS2POr5hWlglWpr342dvz/A+I/jx8RNZ1/TbHVdMggRbpT9p3sB5hTGw4GR9TXzRqGvtZahDqWsWSm7VNqiM5iOeByP5Vy/i238TeH9Mu5C8Nw0Di0kt4GL7S4DDnG1AQR0qx4dg1PxbpsP2lQ12kJLyQjfF6L5nQIfQ+1QqCiuZ2sfnuIxdSvXk5Qt5dDKTWfGcd9tjv4VikO/ygxwmf73b8K9z0i88RWWk3eupcwJPKojaWIAsc8fKDwM14Rd+AtXjslj0x7NgZvLuojJmUM3AI45Wut8a+HLvRtZl0u2eaQWyRwNiP90uAMFOR07+1a1cLB25bBSpKOtmes+Dn8V22Lya5/tOK0X7QLeQ7WZ/p0P+Fe8+CvE2t6jaSeIPEdkkU8rkQxZ/1QHt6V4H4V8BatffY9P8M3b3V/OuIlVt0kp7gA4AA784FfS2gfA74pWV5ZEaFdXcxcmVUnhk3JjGcB88VxLD/wB3T0O3CYacdk2kW9RvdL8QN5pnmhu4R+62/IhxwTXiPjyXxZqWnJa6jPJ5aMfLeJWJAHQEY/lXqtx8JPj5YWx1O70HUB5MoCJHH5rmM/7K5PHcdq6Oz8CfHzVnRbHw1qMsTSYUfZyuGA9H2gVi4TV1yaehVV+0TjKDV/I8M0vRNdudLtb/AMPxk3SqNy3A4O37zD0FereH/jNe6bLb+HvE2m77S4+WeMDseMr2/DofauwHwc/ajgvZbmXSjY/alEYW7lgtUQep+YkevAqlc/Drwn4IMd78SvEB1i/U4ez0VSqgdwblwBg99qVksBKe0bL7jXB4Gte1GDXysjltZ8CwXEiXHhQtqVuZcxpn51PZCOw+vT8K+qNX0S98DeDtN8MaKXu/sv8ApF61v8wkuJe6dNyr90ew6Vw3wf8ADHj34way76LYSaR4PsfNEjWy/wCskChVjV3/ANZIf4nJwoHY4Fehf2N4t8E6lNZaPJLdxwjdNBdR7ZIWPKgt06dPWrqYRUINRd5P8D7TIcnjQq+3mv8AI+tP2cx4d05xdTpNFFIojuYJPlkgkHzLKn44yDwR9Kg/bla2bxp4binKefeaZcRqWI+9E6kEdODu/DFY/wCzh8XrvXfFjpqPh6eOKJDFJcWyiaMBgB80YPQd8CvKf28vG9jovxS8M39uRMJtGmhtVmH3GabGAT93gDGfSvLVPluepxXVisulfa8fzPKPhxpWmwXIfxDcQXBPHbFN8daxo8+otZeHYYoYoiBlO9eIeHLHSXjtxoFy13cRIGmABCu4HIGe/brXQeFrKfVNSN1qmn/Y2LkeSzYP1pqMbbn5x7amqSikkz6D8KeG10fS4tQuy1xNfTLBbqndn6AewAJPoBXPavImkeKP7P1mYxqjcg8Dj0rhfBXjq7m1K88daS3kw6deW2laYhOUIdh9slxyOVKopxxjjrWf8TfiPB4j8SYjtnuWth84RdzM5+6v/wCulNaKw6VahKm57dvP+rfdY+0NP+JdgmhJaWh3hF2nHSqXg7x5bvrxswfLzyfevHdF/tG88KLqk2nDTRCUX52xz/8ArriPGPi640iaLWdKC7ogAx7V1080xFG0k7pGGIw0OX2j2P0gPijTZ7cpI25zwPY14l4y8Sf2J44sftHCsB9K8C8F/EWbWNCGu3cpVkPCk8nHasPxz4q1DXXXWHJUWYyOOT/+qumtxFiK9uljilTpKHuo/Qrw14ssNWIRSq5XOT2//VUOn+Z431c6i6kaXasVhH/PUjgt9K/Pn4VeK9Turs6VfXLRwzOBL/eVGG4jPqwwPYGv0C1b4m+FvBulwb3RIlVQAP4R6V9jlmfQr017Z2sebOhf31se1W1mTBlsKBjAA6V4X8SPt+n+J9LntnxG5A9OQf8ACu18P/EbS9egVrOQICPxxXG/Eky6laQah9xIJB8zdBXp4jGRlQc6bJcNLI9b1OeNNGa8LZVVB47Cuah1rT7DRjeE5SMcnPHFeY+IPiR4esPDE2iyXqNctF91SCeelfM118UDF8PZbW9lZHJO0/3scfl0rkxOeUKbtzLYjVPY+rP+Eiv9cuA9mNsBHy49q7q0sZFt0N0T618+/AnxBb6v4bs/PmDM+N2R3xXr2qeMIxdvY2pASPhn7A1pg8wToqtUZ0ez57cqNbVZ2srNiDtzkD6Vl+F7h0uCbldwb1rIs9e07WboaeJBMSQM17Na2OhwqEaRd+B06fhXoU8XTqK8ZaGHs3e9j//V+ArL4UjVLmKF2upJJi3llYSLdFx8x+ZsF9wXgE429OKZqXgXxRf6w8t7aTyIsUUIngBUvxs3Bo2wqkZOGUEV22iWOgW+m3Vpomsw3zLF5ax2+ozwyRAD5tjPkDyz87lWBUjaSelJa2MVjb+fZ6vLLY3rb0864ImnWQ/vGQlRwO+xic/KcYOPzZTbV0j7eNmj5d8dN/wh32O906F76WOQvdmKATeTEvQKoIOMY57e9U9L1Dw9418FX3gbTNRkivtZ8UWem3kMrtJO0NrbvcxttUu3yzPGCxKguv8ACFzXvWt+P/hjput2WiaNpVtNqa+bLAlzcs0rHC/JsOSx29dp4YEEGuS1zWfC7XqWmp2sVgLIlE2COz8uPAAK+ZtX1AK7lHbGMmrNrYdrbHy5e/ADwR4FmBnXV/EM3nuRaS30mkQO6gqoT7KxmI3DlgWyBxjNbXiX4Wa/430yyt/HWq6ZZ+HNOO+30nTG+xWMROHOy3jLKZSwyHkMk24k5HSvsKye11bTZLWOWa2KwKslvHKJlYlyQ0XyeYw2sp2GXAwdpP3a8hXw/oPhXSZtJeR0uDMPMEqhFfcPlkxEhDFl4ADDKghuMVLqVE1/VjGVNWslp/X3nzbrH7PXh/TLWSbXlubm1jkhC28lwjQ+qiSSXc4w2APKxnHzcdOO1XwVYaRexDR/CtlrQ1DdJO0c8lwSAP3mY4pJEj5GNr4AGCSO30XrN/8ADfwrZL4gtjaDeWRxGqxAbDlmKghlIbcp39DwM4q1pGu2JliaLzLLTcPFqMVreXNnNNDKNyr9phxx93ERUrIdqyLsYmtI3kt9DP2VNq0T5QvdanjSz8KX3g5dQhmbdBH5MaWkSKfmQS8uoReNxYDHHStzRtXTUPhRrHg7wldHw5e6xexaho72dwjrbyaXFOJlTc4/dFZGKRo+9pY8kGMGuk8UaA2v+GL2eR7uxB3yiO8T7I0+zGWikjcIVPTa3LAY5FcNeWOoaaml6VFaQSQ30LXV6zMW3TTAlGV9hyEQBdxCq+8gkGnGjFarf+vkciw/I9GUNZtPE8l6mp+FEFzpl1P5el2sl6Lm+8pfLQxNguZXdjk4fK8qCcVw/hDxh4X8O6pdN8UNOiCxK4RZm8lpzIrxqYt5Ox4eHQk4wORXos3wi0fRb46taWLWkcD5I8tbMwGLgeW+cNtA+UrnBGD6ViahoCX2mP4b1LUZSyRtHbeYI5HiJJO4MzB2K4HHIVeoHFZ+xp3M3hFGXN1/AZd+O/D6S/bdkFnczk2sIjvDcQYiHdZGdoh1+TIB/vdKqa54juNe8O2liL2SPUHkby47Mp5Dxn7ohOPlfOFwzZH8Nc/D8JvE17bJfWiNdGO1itvOkDqC02cRPsIYjaSuGyFAyduK6bSP2fbr4kaabhdQe0k0yFC6sPOFwsI/1MDRtEFlEamRA4+ZVwDkCqnQpae8RUwc5/CZvgjwF4/0q6PiHUdINiIcxvC4H2hc/MDNJNtxwB29B04r6y0rT4PEdpFrF7pyNfbsXWycPPK5+Uj90gRVAH3AMHivDf8AhFdQ8mHTfFmsW0Rt90cMGubZZraKJtrEvGpxuZRggspBXB2kE9b4W8CgXEuseHNfuZ7CKVN6W0dxc2yNwoVRCY9h3EZBIzkYFZJRu/e+7Y0wlFU9Ee8f2dDbRmxzNYyxIUjmZw4hjbldjAbUPt+def2vi7UtHsLi2W2stQlmOZpZgJXPoqJt4OeuCOa7Pw74qvPBuoz+FPI1a7vX8wyPq1vJaSFGzgJHchNyAfKgjZmbHGTVDwX4NZ7a4TSrJtMimudtw/zu8e/nkkHAB+8OgA25BFaas9Bb2I4tS8Ui3V4mDmGPyvsaEBY5G5Clu+088ZxXknjrwJD8RIL++8bzeXcLGqTPHc7rh1UDggAAAc4A9K9j1b4ez6A9zND5E8JlWZvJ3OkgOACB+6QjaQ3qBxXHLY6JqmjRyCw1zU5jM4MFhCsBlAORs8xULAcdG2gZxk8UknuiJ0uZcrPkCf8AZq0me9j8bXMs955aosCRpLJct5a/KwkYBYlHG0bsDHArvPB2p/Gv4X6ib7RfFGuaSZ8SRxXF3FdjHRR5NyWTy8cnZhuwrv8Ax98QLP4e6OttqHgq8vZJtwitSxkaEYy/mK2XVsD5QEI9TXLWmrTeOPAza3P4Z1COZQT5KlYkAAxGsjMPMHoAFyCNuK6eetypyem3QzjQhB+47Ndro+5f2Yf21PE3ivUNR8D/ABpawtLvSbOTUItatpGs7K4t4SPN+0RyfLA6BlIO/DjOAMYr9B/+Fi/Da08GweNLmW41TzZnt41IMMBKgZY5bzWjbPy8Ln0FfzdaR/ws7wr4tmtdE0WC81JArJaMXmkt+pjWKNh5bSscDzZB+6AJGOTXvcH7Qv7RHgdmnl8LQLqcb+WkeoXjNLvAzvSPYfMPfC44HAxTxDqNKNGyb81+X9I9rKsfSjri9beT+Wx+7tl8adA1WxNgz28EcOGWG1jwT2x8owRjHrivEPE2uajqF5L/AGTZyRFgMuV4/AdMY6c1+Sp/bh/bV1D7TqFpJYaZDBGGklnhfbExGPmKgbckjGVAwMVyR/bS/bYlS6fVPE2kRSwQGTy/sLPK2OAI03Ae5LbcAjjtXAsu5n+8lr/Xa57j4qw0FyUlZeS/4Y/UC/0TXLuQSRhspj5i4Ax9P6VlXXgbVZ5DJK0a7hnHDfy/yK/Hsf8ABQD9s5Cn226sfMj6eZpgAI6/eDAduB1xXQ6R+2x+19rLxw217omXxsjltBHlsbuP3oAyOnP1wOa7/wCylDe33/8AAOGpxPSn1f3f8E/Vhfh7CyLLNh5MfeIxz9M8D8KxtS+FVvqVqdkZQJkkngD06f8A6q/OGx/bA/bEvLcJZnwtPNID5aPGmXyCdqn7Vt3AKTt64HGeK93T9qr9p7Q7Oy1Pxf4CtLrT9QgYpeaNer/D8rNErMynBIOyQpycYyKuNKFPS8fvX62OGrneGm7cz+7/ACPvf9nrw14R8BeL7mPV72DTI7iIyK102PM3cHYAOoxz6CvoXx1B4e1PwHqtvqcqpZ/Z5YpWl/1XlSIQSDxng8fl1r8aNF+I+sC9j+P/AIn0+4u7fWrFrbYT8yqp8sxtD91drJvDq2evYV23xw+N/wAS/HMdn4C1LzLDymk+32UBErvIn7yPZgh2T5TgkYyMDd0rzq9S9RpWsvzX+RtTzzC08NLmeu1j5s8J6nc2V0PC+n21pZeb5SiNvl84R4RPNDfeDYwTx2FdhrPw61e+8QXP2iP+zEaTLxpP5fkOBkxyAdcY+VSuce9bVj9rsra0jX7DrNtep9qt0Z8ySIW+ZCwAWPLblXcCjJgNyvH0D4j8UWz3kerJKdUW3htbYgyfZdsjoIwbndhm2qQhXn5o8E8V5/tGpM+Yw9FVIaz0XT+v0PmTSpdP1Lwf/bWh3UN1fm44tMFjKFAzIMAYKfgKavjnwlr3hq5/4TXVZNM1V5EjhlGnSXMUsSn5ziPJEijp2NekX/hvwukc3h/R7yMQXk0tpZQ28+2ScSAFlMgxkA4ABKsOuDgV5F4l+Gus+HtRMdxLqejRWaGOCKKR51toeyu8aPzx8zOd2e/aunDVqcpWZvGo47vbQ5K+/aS8a+HNft/hb8IfDDSNfXC2Vu0yrFJdLM4RSwTcy7zyw446jjFfrV4f/Z4+KECK9lqlrIVUcqGToBwo/ug5wePoK+AP2OPhvot9+03oWr6/qbaudOs7y9RedgvFhC4DN87Mu9tuBgnoOK/oI8K+Cb1YzJGvzAheHXIwBgEKScgEZGMivQxKoSUZWVkfS5DVruMuV6X0St28v60PlnSfgn8X5YksrvVTE6nGTKcjjjBOCBVLWfhL8RYZzb3eu3CPGMcSt6ex/Kv0D0T4Y6pqkSG6mAtZ1cb+Afl6jHsOM9u4r03SPhJ4T0S3+2X0XmSbN6yO2c8YK98MDyOxrz543DxVoJs+ppYHFyd6kkkflna/sveLfFMomGqSkOQWlkDcDgdzmvoXwL+wL4DN8lx8RZrjUYkwJIJT5cG08ZYLhmXIwfmAHpivuK48Q+H/AApH5NlGsksnyjysYBXjPPXjg5+lcjrPivU9UtVs4CLQR8gAh2x6A9ACOo5rza2LqS0j7q8j1qGDpw+N835fcdNat4d+F+gpoXhKwgt4bVdsMa7UC7Dj5VXomMEAd81+ffx9t4G8OXltaRyLNOzSTzqoDb3OSeDyTgIoHSvq7VvE1vpdu6whmnx8zvkkn/vnj27elfHXxL8SweVPLIwZ2QhpGOSox2449uBWdCi5PUvE4iMItI87/Ydu/EqeK9Xsrm9ukEDZ2BzgErjbnuR0rL/4KD6JpMVxpOreLZN9ncQyWcbn7qSbvN3EjkZx9BXuv7HPhS8stKn8ayQOlvfyjYSAMIP4uuTn04r5m/4Kf69/a+i+Gvh/orzR3l3cz3fmW6ed5aQrtG6PuhLYPfjjpTnh+etybHiZx+8yqcfT8z4Z8Gar8LdOWeXU9TmuLRfmTyJ5IU8zHylTjGR6DrinX/xw1WPRo9Ha4F5EcL5nlFpEVvl5YHKgZ5boO9fIU3gjx1LYXfiPVL29mtI8IYVAUq7cBx/AB7Y9qo+FfiT4k8H2h0TW1e4gkk8uQNbqSufuqY2HzZ77GSt3lN17sk7H5pKg+Tlfu+f9M+27Lxzpuk+ErPQmtnYrMsc0lm2VC2jGeUow43OwUZXouK9j8BeL7Dwz4K0j7bfGxvZ7gz6oqQ77kySHeqKSCSoTau7FfNnhjRrDxt4fEvhL7RYWlpHHHdaVMCUtmmb/AI+LbofKkbCyxuS0Bw3+rwa3b/RfGWo6pNYS6pDJYwyKlxa20ZtG2qwUedzv6/xgmMjnIrzvqTg2rjwsKlJqW+lke+eIfHeh3PmWGmLLma6eYwCQkRQr91pGJwrMf4etemXuheHJ9LtdG1K9hD34MlvDu2FsjoM9fpXhnws+CXhrxF4vXwPbXTaddXh3xxmIyRwptd5DJISVRVVd5fqeAuSQK7Y+DkvfEEPjSRY9Y05kGy2idFS2tVjcIgMhDBiqGTaVDhiM4JAGcsNHZs7/AH7vnS12S2S/r/hjrvAHh3xR4BtprHxBag2txK3ksTt6DccHH90ccH8q7zxXcad4v8TPB4ct2ubNbpfNi4Rvs8w3xsQOFLDIYD5Q6OB8oFeOeAZfEyajBr/iS5ub3TxbO1qZ/wB5bPC6qQeoaJ0JCMcEDpXX6qzeF/ErBLoWMMOj3E12pAMkaW08G05H31/fMBjpk+9c8sPybddv69DCfLCn/d0+7+vwItJ8UeG1t7GKyZY3u4ft0hT7w83JAPpgbVHsK9TuvFGgzaRaya2xl2YBP91cV89eEbHQNW8IaXcRWk4lmWytZnYjbmKBWKqM5xjJbP4UzxJpvxC1i8lstDtA0cTbHdhwoOBkjtgHis3WV24HEq1oaRW2lj698P634QWNvEWkXp+Rf9Sp7DtjtXOfET47+LvGfhZ/CXg3TzEHJElwx4QADhR3kP8A3yo5PVVb5pe+T4YeDLu4YPNLJcCFHddsk0pHCRqevT6KBk8CqEcWvpZ6Zr+s6mftU15AsltbgLHDDI4jCbR94lnHPc9Bmuh4uSha++hm8QkuRRs+tjPj03xL4VkluNS81T13P8241y/ivxbf60YdIBISIjctfTXiiTVvFd/Dol5EkNvacS7iF2gD274/KuV1Dwn4W1Gzhn8LqGEcm+eU8Nhep56D09q5uSHLobVMLFRcI7Gn8MvFV14cvrawunMMNywSJhwN2On1OK9r+InjtpPsfgbRCY5rlgXkHBH418361q+n6neaLZaeh8uW6zC6jA+T5d34k4rq9Z0XVINat9f1O48tbXD8ddv+eKPrD9n7NPRFYRuMJqO2n3H1j4P8J674Q0r+2pYzJGFHJP6/hXpPhWbUtZtJL+UsMnlz/dFeLw+O7o+F/J+1GS3kXOQ3B4456VxXxA+NWr+CPDFr4X8Mwlprtcs46KDXr4bMo0eVdEdmMpUYQ5obH//W/NjRLHw5aaBc3viDxlb6xFpzANex6Q9vefudgh3yOFBmAXYJNjl8DrtrsvDfhzUdat2vfDvjC7vYIxEkw1KZb2GOOJfMXaUkSQAg/wDLROe43DNen6f4O11ovtl/JYSyKFfcsR06WQIvyv8AM0gkDEklNhcYRvk4rp9VgGnwi/0y8jsJIFCxSWq7YzJGfl/1CxpGT32ZAwDgFq/O7eR9xy6HI6Z4b0zS7aXX7SS2kaV1UYS4hSRsZixE9zOUUk4xyRjotYWp6JbaVanV7mbT76O3XzTKS7KjRPj92ciD5GDex6HZgmmeK9ee9lOhs0kkt1KZluYNysZbjasskvO3fIACJAgSMrkFRgDY1a+8VWLQ2OsSQabZXwNtJLejdLvA3KryBTtaSNwf3nIIKjjaKdg0Wh53ceK9JW1kntXitryWfynZh5itI5O99tqPMXYyhNpOQwAPykMeNi+KXgiGWTR7bVdO1WSKb7DJHFdpHdG4RY3KPG6xx5Iy2zPQHaeAK990pPB+jaPGZtQW1vH3i3nCxx+eyBH3ThraBFkdkIjQRDdx97aKxfCXhXwrp2qzXeqyta20Z3QnTIPNZrJiruvnH7olyuWiGxSenIBm6Sux2PN5fDejssV79kW3uJR5ckUijdkZLfOshR8nlQNyHbgY+8MHxB4esdalXQ/ENx/alvL91JREAfl3sVw4VpVUZBLBQMcHrXqXiP4T6FbjbrKFfJDvaqN8TKzAfOS4Rldm3RgRBcHdnHFZmqaHqMcMV14X12WXc0kdzOIR50eeGRImkmMpVDtx8igZAwCFqbCt5HlWoyaDr8t54V09b+107TVa3ng0yzaSFZBudgbkQyoCo2gR72+6cdCBwXifwd4P0STTH0JdQuWvgUt7Tykubx5o8k/u4ITKdsaybuAq4POOa9s+w6jokFpYWevfYrN3O2OGGeWaRllwi+VGGyFdiGCgKFyxKrkVJfJodxrckMPlyRu21TDFcQxLLGqbgr+e+RhGfHIYMSAANtUkS0tj8vPGGleJrfxdBJPez2+mXTB4NP8AsqiB1iYcRrCUK7WIyso27WGCea+mLP4IfGWPwIfHus2+j6dodvbHUTJPqUSyW9qI3ZvtMAiVgkYPmAQPI4woY4+WvsBtKsJPtE9xFDJ9t2+WrI58ryyyZCvh3+71RsLt+U/wVH8R9H8ZLpV58ONN06GAX+kpaSGBFZXtXTaQssLOGUqxIKBmDfexkFStUfuxil/XoEKENXNnwl8JtR02/wDDP/CRWv2q41DTWdGumiCJK05+/AArT/dUc7EO/ao3DNei3/gi4sG/4TjwxZ3EFxKIW+zXETQyGdpVkR4/NgEyTA7WxJtK8jrxXW6H4AvNBXVvC3hm4nn1yK3ksngtJ44ptLWXKvJmOQnz5IsiPaGe0hYsxWQqo5Pw58AJPBet6ZJeDbZmVbny7aS8ufOmjbzop8mILuR1DbpGkO7kMp4pypQls7Iz5LJKxZ8I+PPCMvi660PxZPAWvklk04W8kZurK72MzGASr5pRGBDQqSFj/wBWV2op2vCUfiq9vZJLG+vPDxZwv29URrOKHAKut2FWZsNndJMrKmeRkMB754sutR1zw7eXE89tc6pGZJSiT4kWQYCPOfLR9oxIfmL4P3iwzXGWfxh8OeHtOt4Dc21xcShVW6jWextwdy7f9c0pcFflbhAxwQg4rjcYQJTVN+89DnvEum+PtQQRarfXt1LDBHLPPqGpYiEjnkRsybpFReEZF8tu2O2Zoui376iNS8RafqF7BboPLeK6ZWUL1ykisD1+YSqAP4SADilrvxa8AX8ktmstncad5MaQQ311Ctx8pw8avtkRtvXCbWIzhQQa6Pw38R/C9n4ik0/QtQtHiISMF52NwZZCVLFI5A7ghyfn+cAE5wppOunHlUTF4yEnucZ5tlp2n3EIs59QguTCDD56PMi4LOkkYZirKAQZInbquBjkafgM6RrPnzfarzUZiH+0LKqTzRsT+68ldu4TMV27QBtQkttUZODfeLNLvYm16wuYfENza2YgLabEJfLuCCXkiZXjeRTxg7QH5LR7sZ8Zi+Ien2HjeC88SSvA0drKkcMED2VxHJ5254fLm8pc9UG52GMDOPlPLas9jGpXnTtJbfl9x79eza5rEd1qep6tLplteXPkBPtaQnbGnzQvPlsghdrjuAe4zUvhjXLCxX+w/Ddkn2Fo3El5KSWa8YIBxIwEfAwhZ8HgBQo+b5bPje18X+JIP+EksgbHTdIj1HyUbyLdYGcww+bKCrHMm4fKhZmK5GMmvdtJ8aaHrvh+e7u9I1BLa1Vo4J7WeK2IiyAyKHXGAcdlLdicCr/e8tpIMLiXUbk3ov67aHSeH7eJ7S48Ka79pmtTfIbyZked7crkGBTEqqodiGYMm75c8IprN8dav4d07Q9MbQdEtbi4tHeO48+VpriUuN0UbSTYMaqoJAXATIGM1554n8U/DdYdO/sOXxVqF/Zny/KMURtVlI2SOSkj+bhBw2zn36VpS2tr4FmWzeHUY3aO8awu9UWJfKmjiym1jGryqknzlJcZOHIJUColGV1Lb7zWrVfLeNlHyK+ll5fESarbxWUt3ZOsk0EcJlOV2lppnZ84PJGzABVenboj8NNAmuX1N9HlgjOFiaNzavJiI7RvlR2LElepBOcjJyB4+Ifh/wCKfEVxc6fHBazsizNPZweWnmzEdYovMQ/MWdwYjvLD7uRX1v8AB+/fwTaXM3h7VrTWbxEdpA+mTJaKzbonM1vMEVgpAb5AfmweACKtXjK9/wBCsLq7PU8wPwG0K/06WJJZ7eOa3GEnXzZdrMQWJKP5fQktyMZwMdPG9b+CPihS8WmpfSXMZCLLGhuAAikfIpClygUZLHHHC8CvsHUNc8deItSbZqGoan5wC27LO2y7MXygPJF5EIIH3V6ZfII5NV7zw3qmgXlpq1ywSaCMzNYz3EkVxFF/dkSCXjjjerEkDp8wrrjOa6nTKgpHyT4M8G/Gh7e50bQdM8yzuImW7vJjBapvABCyTMkm0LkHCKrNxwQK4zxd4K1bwhrUWtap4m04aMQpli1CKWSTzMKHaJwiyCZQAY3DMq88YwK+1tSgt9XnlbSFNrZFVaG5tLGNpSUIZFhjmmkEbDays06BijLtYcgfPupfC3xO+qLfC0tZYJHaOcPDJb3ZmJ83Dn7pzw+7LKANuM1K1ldpL5f1Y5MTheaKj2PF/CPiPw/pukr4aW+ZrOPzZYPJVbiFYZmPHlEqpc5PUjGSSMYFd8fBniXXrCx1zwUrarJOhNxerI7x2U0pRvIMMiAI8TDDzNIVjc4iGzJqxF8PtWuJ72bTYTZm2860F4UaJcudmVcKzD5c5Gzp0rqdK+GOp3txZW0uvyWdtaW4tP8ARbmO1gETDCZAlEcy5Jy0iqyD7o54ahTj719fM56OAhGNpK5yafCTxX4Ykvdcns7i5NyCrXELtHmNcEO5JaIFcj7zkscAjuMzQZNXN7cafp863dw1pdROwiF0C0qeYceVwqS7ULrkB+wBwa9s1KPRr28l8Rz2NitxpIhdIjBBdW+9Tt3fMxmLFV4eNvk2gj7wq34r+GieE9ItNH8V+HC0tluW2sr2+Xy4ZZIg0my1tmZQihMMWmTdGNoXkCseRN3vr8v6+RUcEk26exx3hnwjd38i32uabcQ2DWzu88gENvA6YTDLIhzhtiY2+ax+6SeBU8VWckHj1NS1m3CWN7FO43Q/Z7a5niVnVWjQqz4ySgdc7QOMCso/E3V4Rb+Hb3w/pWrJpl1JdW32eeXR4jbOh3SNZu0u9zuzlpmdB8yf3a9Q8NzeJvPTTrbR7aa/CtDNYzfZvMWQxYRpUN4D+8UKBKJASMhym0CpeEdN3/r/AIA3hFZKD/As6T4W+KF7rFv4S/Z8itLjVdqWd1E+231qSZwZGitUnliT7Osa7m8oi4Kj7h4NfTPwk8W+O/hleT+GZbW+0K2vRGlzB9hktbf7XH85l3EKS7qwLZfJAB6V86S6Dcalpd3L4zs7aPw9e3LN/Z8kFvqFuUtxhBc/vhbeY0oLbwrFRzkE16Lpnhr4c6l4O1Pw1o9/4Qe7Cfa5neSGPUAEESFZB5ke5RkRNJ5MqR5RdxAIFVFGpFJvbtse5l2Oq4V+5FX6XPunwT+0Z4NLp4f0Txlp95PbO/yS3Eds8Ur8sBEX8wnpwSBzX0Np/j7xhd6c0k1y4SQLjykEiN1IIYFxyDnjtX406z8ELnWxNoesebeW8kKo7GGB7e4Vz5YjGVMXTG3Dg4CjOBgcJpn7IPiiXxNYWnws09tFd5ZLe7g0uZ9KVliZFd96SJHHuwV3sQyIAwODgKOFobXt/XyPejxLXXx07/h+FmfvFaalaxPHFeSOfM7EgMQPXkEc8Vuf2xbXCGPzjGp5B28jcB2/nX4kav4g/aI8C6dDc/DfxfqNtaQLPi31V/7atHVGwhlFwk8+zafkZJU3gZ61yVr+37+1L4amePxN4X0PxRHvYwmCabSLvyhkLviYTrhwMrwnHVRV08vi17jX5f8AA/E6XxLS2mnH5X/LX8D9wfEV9YsWsIZmMxX5VQgliBxx/hXjcPwL8V+N9VA1RFt9OZmZ0ZgskuMceWCTg9ycccV8AeAf26PC3jLUtNn0q/NkNbs0nvI7U+feWiAfNZQiNcrMxzuYgMiKCvJUj6Yi/bj0Xwt4XmsvhdpV+mrLC0Ed/qMf2a1gEcTFS/murP6HZyxOMjtjWp1KfuRjb9Doo4/C1E6lSfurbzP0du9d8DfCH4ZSar4iuEtIrKH/AFcaDkAcIsaqXZiRhUUZPQCv52v2kfiBr3xJ+KJ+Lts1hFo7CO1s0ur9FBgjJMe5dyhGlLFhlhkYFeman8YNf8RLa6x8V9ah1PULSyJuLjT18/ZcyLslFuZI0XjlQq4O3I3nOR4t4n8S/DFtEsfCPi/Sr/8As+4dp/NmtbC0hHkx7MRLbu7R8P8A8tSN2T9RFGk+a8l5HiZxmiqw9nSdof1b5FK78L+M/CfhCzu9W8NfYbXXr13USXKzRy3ES7Im3wySwiJwWEcYYYIJPSvN9T8G67eK2v8Ahi4W31GzLTXOl3YzK7tgAokiqZVVgE+RTtPHSvbLHw14Rbw3Jp3hq7uTo9y0TWLX8QED2zDDGFhcbBOuXjOU4IVkypArrb+/8UaWtxrl54fsvE1jpKLqdtcXc7affRFgqbbPVDKtxbTsSqyJsmWUHDRHLbVGUue9rf1p/XQ+ZjVk/T8vuX6Fnwxa+EvDd74W8ZazZX2nyzELG+j2sckVzdRqWWSXDJsWRMgopEm5eBgFT6vNp3gPQ9RGs6Q8N1kW5gku93nPHdLtiSWI5CKysFaUMFV09TtHnuj6JpXifxFqni3w/fXUceoW8wuLfxHcQqDceUfLulk04+XE0coDGRLIDYXygaT5Mjxzr2v+D9bgtrBTqZtI55I9QnMMnm2SMjs1u3nyg9AcOeGHABxnCdOpKyexTr1vilHT+un9dj1S7tfCPwZjl8SatDBb+I7tf7OF20TC2tpJwUITOAQnKbiOSF24GTVLULCTw34V0K11V44tWuZp4EiU7nMMbbwUA43BSqnJ5zlSc18++PvEepP401WHXdUez0CTVprwK8E1224tvChbcu5eFSqrDGoAUbh3xxulePPCty2mXGl+LbPU9UsrplsbdUl0+6isYi75S3l5lDoWbawXyCuAG3CsauEqzTl0X6HHi6757xW22q+em78tD6hg8VeG/DujSy6xLcHTLR7w3ElspuZTDbCTagiA+fO2Ryu3kMp5+WvYvFmp+Bfgr4g1/wCG/iTw1Y61rqaPdW+uNqiRz2VlNqFvDcnSLG3dXiaOyQQm5nlDvLctIkflIm0fJfwBv9NXx3q/xU8VCNdE0AQ30MbM1rDeTxbGs7ZeV/11wkZfIYGNJNy8ivHdUs/F+l2L3viS72a9q0F5qE84kWWFrm+DtJcOqAjYxd3kSNtxkYZdaIUbRt9rS3l/WxySq1vZRtHf8lp/w3ofUWjeIdCsvBOiT+F55LeznKPJLdxm4kN15UYCYU7VbavmZ/hXbnG6vY9A8USeJt3h3wOwgsmZ3FxN8p+9s3EbdzyMw2qv8T/KPb5U8N+AfE3h3RtJ0HV7tYdE2NHbRwr51/KoiZBLEvy4ld8ksQq9V+YYI2l+J+seGPh7p/gbwxbvoZ+1eYbmOSCTUpBP+7a4kIYZmmUDyfl8qJMAjlRXBLLOad27JG1Hnpx/e+7FL8raLsvuOs8eXl1rsUba/JJFqNvO8MCvudba0jIMkrFfl82Vto77l5BCBcYniS9s49bgbRrhRpqX9lmZZAqHypYpJGUsV3OCD0+UHgEkV5n9gnsdX1BfEtvZ2D252WllcX0kiafbsNxhQRKZZpTt3PhtxIGcKFFdvpfiW5vWnvPDIhtYNHjE8i20JfeYzsOySYuewG1Pm7diKueCSd+mhwPm5pab/oesX/xI0W5vZ555U0zTIIvNEl0Ghd1PQkyBPv44xnjOKbZw23i6C7XSredvM/dskCNu2AZJCLk4C8kkBQCOa4nxPrvjLwyhu/HkECtFbyJYxRj7ZG8jbPMDlQzMyLIAzHABAVcAkj1/XNO8QWOk6j8Smt5gL+CCe4dnDi+kkQyup2yoVgxsii2LJkBflJzXGsIrnZCnWquTl06WtZHGPOt+2nfYbu2tDaPGihif3SxsWGMcEk4r062Ei2FzFdTnUpv9TtUHOW6Z69MdK+avC+seHNG8YxL4t0y5lubOVi0TsskSOcb5IxgCP5oiNgyCMdDXra+JrzxBommxX0UcNrez3LZiuUhkVEG9DkurHPzZQKrNgKDkVUqKi1Zam+CnCOu/S3b/ACPNv+Er8U2eo2nh6S6jjtFu0ja3jPJ3s67P9n5VJBP5V6X4o1ZE12bWvEUZhRSIIIh82COvT2IP5VHFY+Ej4Ei1mOcjT7iacxhMq9xdMVgMk7MN6pEA3zDhI+V7E83Z6hqWi6dqWg+ILm3vtZtL+5S32OHmxnDyHJwNzDK9SVIbvipr0HGPvF8jpJc793+v6R//2Q==", + "mimeType": "image/jpeg" + } + ] + } + ], + "tools": [ + { + "name": "weather_extension__get_weather", + "description": "Get the weather for a location", + "inputSchema": { + "properties": { + "location": { + "description": "The city and state, e.g. San Francisco, CA", + "type": "string" + } + }, + "required": [ + "location" + ], + "type": "object" + } + }, + { + "name": "platform__search_available_extensions", + "description": "Searches for additional extensions available to help complete tasks.\n Use this tool when you're unable to find a specific feature or functionality you need to complete your task, or when standard approaches aren't working.\n These extensions might provide the exact tools needed to solve your problem.\n If you find a relevant one, consider using your tools to enable it.", + "inputSchema": { + "properties": {}, + "required": [], + "type": "object" + }, + "annotations": { + "title": "Discover extensions", + "readOnlyHint": true, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_extensions", + "description": "Tool to manage extensions and tools in goose context.\n Enable or disable extensions to help complete tasks.\n Enable or disable an extension by providing the extension name.\n ", + "inputSchema": { + "properties": { + "action": { + "description": "The action to perform", + "enum": [ + "enable", + "disable" + ], + "type": "string" + }, + "extension_name": { + "description": "The name of the extension to enable", + "type": "string" + } + }, + "required": [ + "action", + "extension_name" + ], + "type": "object" + }, + "annotations": { + "title": "Enable or disable an extension", + "readOnlyHint": false, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_schedule", + "description": "Manage scheduled recipe execution for this Goose instance.\n\nActions:\n- \"list\": List all scheduled jobs\n- \"create\": Create a new scheduled job from a recipe file\n- \"run_now\": Execute a scheduled job immediately \n- \"pause\": Pause a scheduled job\n- \"unpause\": Resume a paused job\n- \"delete\": Remove a scheduled job\n- \"kill\": Terminate a currently running job\n- \"inspect\": Get details about a running job\n- \"sessions\": List execution history for a job\n- \"session_content\": Get the full content (messages) of a specific session\n", + "inputSchema": { + "properties": { + "action": { + "enum": [ + "list", + "create", + "run_now", + "pause", + "unpause", + "delete", + "kill", + "inspect", + "sessions", + "session_content" + ], + "type": "string" + }, + "cron_expression": { + "description": "A cron expression for create action. Supports both 5-field (minute hour day month weekday) and 6-field (second minute hour day month weekday) formats. 5-field expressions are automatically converted to 6-field by prepending '0' for seconds.", + "type": "string" + }, + "execution_mode": { + "default": "background", + "description": "Execution mode for create action: 'foreground' or 'background'", + "enum": [ + "foreground", + "background" + ], + "type": "string" + }, + "job_id": { + "description": "Job identifier for operations on existing jobs", + "type": "string" + }, + "limit": { + "default": 50, + "description": "Limit for sessions list", + "type": "integer" + }, + "recipe_path": { + "description": "Path to recipe file for create action", + "type": "string" + }, + "session_id": { + "description": "Session identifier for session_content action", + "type": "string" + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "annotations": { + "title": "Manage scheduled recipes", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "dynamic_task__create_task", + "description": "Use this tool to create one or more dynamic tasks from a shared text instruction and varying parameters.How it works:\n - Provide a single text instruction\n - Use the 'task_parameters' field to pass an array of parameter sets\n - Each resulting task will use the same instruction with different parameter values\n This is useful when performing the same operation across many inputs (e.g., getting weather for multiple cities, searching multiple slack channels, iterating through various linear tickets, etc).\n Once created, these tasks should be passed to the 'subagent__execute_task' tool for execution. Tasks can run sequentially or in parallel.\n ---\n What is a 'subagent'?\n A 'subagent' is a stateless sub-process that executes a single task independently. Use subagents when:\n - You want to parallelize similar work across different inputs\n - You are not sure your search or operation will succeed on the first try\n Each subagent receives a task with a defined payload and returns a result, which is not visible to the user unless explicitly summarized by the system.\n ---\n Examples of 'task_parameters' for a single task:\n text_instruction: Search for the config file in the root directory.\n Examples of 'task_parameters' for multiple tasks:\n text_instruction: Get weather for Melbourne.\n text_instruction: Get weather for Los Angeles.\n text_instruction: Get weather for San Francisco.\n ", + "inputSchema": { + "properties": { + "task_parameters": { + "description": "Array of parameter sets for creating tasks. For a single task, provide an array with one element. For multiple tasks, provide an array with multiple elements, each with different parameter values. If there is no parameter set, provide an empty array.", + "items": { + "properties": { + "text_instruction": { + "description": "The text instruction to execute", + "type": "string" + } + }, + "required": [ + "text_instruction" + ], + "type": "object" + }, + "type": "array" + } + }, + "type": "object" + }, + "annotations": { + "title": "Dynamic Task Creation", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + }, + { + "name": "subagent__execute_task", + "description": "Only use the subagent__execute_task tool when you execute sub recipe task or dynamic task.\n EXECUTION STRATEGY DECISION:\n 1. If the tasks are created with execution_mode, use the execution_mode.\n 2. Execute tasks sequentially unless user explicitly requests parallel execution. PARALLEL: User uses keywords like 'parallel', 'simultaneously', 'at the same time', 'concurrently'\n\n IMPLEMENTATION:\n - Sequential execution: Call this tool multiple times, passing exactly ONE task per call\n - Parallel execution: Call this tool once, passing an ARRAY of all tasks\n\n EXAMPLES:\n User Intent Based:\n - User: 'get weather and tell me a joke' → Sequential (2 separate tool calls, 1 task each)\n - User: 'get weather and joke in parallel' → Parallel (1 tool call with array of 2 tasks)\n - User: 'run these simultaneously' → Parallel (1 tool call with task array)\n - User: 'do task A then task B' → Sequential (2 separate tool calls)", + "inputSchema": { + "properties": { + "execution_mode": { + "default": "sequential", + "description": "Execution strategy for multiple tasks. Use 'sequential' (default) unless user explicitly requests parallel execution with words like 'parallel', 'simultaneously', 'at the same time', or 'concurrently'.", + "enum": [ + "sequential", + "parallel" + ], + "type": "string" + }, + "task_ids": { + "items": { + "description": "Unique identifier for the task", + "type": "string" + }, + "type": "array" + } + }, + "required": [ + "task_ids" + ], + "type": "object" + }, + "annotations": { + "title": "Run tasks in parallel", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + } + ] + }, + "output": { + "message": { + "id": null, + "role": "assistant", + "created": 1753704326, + "content": [ + { + "type": "text", + "text": "This is an image of a goose standing by a body of water. If you have any questions or need information related to geese or something else, feel free to ask!" + } + ] + }, + "usage": { + "model": "gpt-4o-2024-08-06", + "usage": { + "input_tokens": 1925, + "output_tokens": 36, + "total_tokens": 1961 + } + } + } + } +} \ No newline at end of file diff --git a/crates/goose-cli/src/scenario_tests/recordings/openai/weather_tool.json b/crates/goose-cli/src/scenario_tests/recordings/openai/weather_tool.json new file mode 100644 index 000000000000..6274e54be56b --- /dev/null +++ b/crates/goose-cli/src/scenario_tests/recordings/openai/weather_tool.json @@ -0,0 +1,523 @@ +{ + "e546a32d4a2c9d41338b6725f317c4d4f462ce7cc04c79f3f24dd47a1a32a795": { + "input": { + "system": "You are a general-purpose AI agent called Goose, created by Block, the parent company of Square, CashApp, and Tidal. Goose is being developed as an open-source software project.\n\nThe current date is 2025-07-28 12:05:24.\n\nGoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o, claude-3.5-sonnet, o1, llama-3.2, deepseek-r1, etc).\nThese models have varying knowledge cut-off dates depending on when they were trained, but typically it's between 5-10 months prior to the current date.\n\n# Extensions\n\nExtensions allow other applications to provide context to Goose. Extensions connect Goose to different data sources and tools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level problems using the tools in these extensions, and can interact with multiple at once.\nUse the search_available_extensions tool to find additional extensions to enable to help with your task. To enable extensions, use the enable_extension tool and provide the extension_name. You should only enable extensions found from the search_available_extensions tool.\n\n\nBecause you dynamically load extensions, your conversation history may refer\nto interactions with extensions that are not currently active. The currently\nactive extensions are below. Each of these extensions provides tools that are\nin your tool specification.\n\n\n## weather_extension\n\n\n\n\n\n\n\n# Suggestion\n\"\"\n\n\n\n\n# Response Guidelines\n\n- Use Markdown formatting for all responses.\n- Follow best practices for Markdown, including:\n - Using headers for organization.\n - Bullet points for lists.\n - Links formatted correctly, either as linked text (e.g., [this is linked text](https://example.com)) or automatic links using angle brackets (e.g., ).\n- For code examples, use fenced code blocks by placing triple backticks (` ``` `) before and after the code. Include the language identifier after the opening backticks (e.g., ` ```python `) to enable syntax highlighting.\n- Ensure clarity, conciseness, and proper formatting to enhance readability and usability.\n\n# Additional Instructions:\n\nRight now you are *NOT* in the chat only mode and have access to tool use and system.", + "messages": [ + { + "id": null, + "role": "user", + "created": 1753704324, + "content": [ + { + "type": "text", + "text": "tell me what the weather is in Berlin, Germany" + } + ] + }, + { + "id": null, + "role": "assistant", + "created": 1753704326, + "content": [ + { + "type": "toolRequest", + "id": "call_5hvVKt0aj0RGRmrKEZECeJKV", + "toolCall": { + "status": "success", + "value": { + "name": "weather_extension__get_weather", + "arguments": { + "location": "Berlin, Germany" + } + } + } + } + ] + }, + { + "id": null, + "role": "user", + "created": 1753704326, + "content": [ + { + "type": "toolResponse", + "id": "call_5hvVKt0aj0RGRmrKEZECeJKV", + "toolResult": { + "status": "success", + "value": [ + { + "type": "text", + "text": "The weather in Berlin, Germany is cloudy and 18°C" + } + ] + } + } + ] + } + ], + "tools": [ + { + "name": "weather_extension__get_weather", + "description": "Get the weather for a location", + "inputSchema": { + "properties": { + "location": { + "description": "The city and state, e.g. San Francisco, CA", + "type": "string" + } + }, + "required": [ + "location" + ], + "type": "object" + } + }, + { + "name": "platform__search_available_extensions", + "description": "Searches for additional extensions available to help complete tasks.\n Use this tool when you're unable to find a specific feature or functionality you need to complete your task, or when standard approaches aren't working.\n These extensions might provide the exact tools needed to solve your problem.\n If you find a relevant one, consider using your tools to enable it.", + "inputSchema": { + "properties": {}, + "required": [], + "type": "object" + }, + "annotations": { + "title": "Discover extensions", + "readOnlyHint": true, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_extensions", + "description": "Tool to manage extensions and tools in goose context.\n Enable or disable extensions to help complete tasks.\n Enable or disable an extension by providing the extension name.\n ", + "inputSchema": { + "properties": { + "action": { + "description": "The action to perform", + "enum": [ + "enable", + "disable" + ], + "type": "string" + }, + "extension_name": { + "description": "The name of the extension to enable", + "type": "string" + } + }, + "required": [ + "action", + "extension_name" + ], + "type": "object" + }, + "annotations": { + "title": "Enable or disable an extension", + "readOnlyHint": false, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_schedule", + "description": "Manage scheduled recipe execution for this Goose instance.\n\nActions:\n- \"list\": List all scheduled jobs\n- \"create\": Create a new scheduled job from a recipe file\n- \"run_now\": Execute a scheduled job immediately \n- \"pause\": Pause a scheduled job\n- \"unpause\": Resume a paused job\n- \"delete\": Remove a scheduled job\n- \"kill\": Terminate a currently running job\n- \"inspect\": Get details about a running job\n- \"sessions\": List execution history for a job\n- \"session_content\": Get the full content (messages) of a specific session\n", + "inputSchema": { + "properties": { + "action": { + "enum": [ + "list", + "create", + "run_now", + "pause", + "unpause", + "delete", + "kill", + "inspect", + "sessions", + "session_content" + ], + "type": "string" + }, + "cron_expression": { + "description": "A cron expression for create action. Supports both 5-field (minute hour day month weekday) and 6-field (second minute hour day month weekday) formats. 5-field expressions are automatically converted to 6-field by prepending '0' for seconds.", + "type": "string" + }, + "execution_mode": { + "default": "background", + "description": "Execution mode for create action: 'foreground' or 'background'", + "enum": [ + "foreground", + "background" + ], + "type": "string" + }, + "job_id": { + "description": "Job identifier for operations on existing jobs", + "type": "string" + }, + "limit": { + "default": 50, + "description": "Limit for sessions list", + "type": "integer" + }, + "recipe_path": { + "description": "Path to recipe file for create action", + "type": "string" + }, + "session_id": { + "description": "Session identifier for session_content action", + "type": "string" + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "annotations": { + "title": "Manage scheduled recipes", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "dynamic_task__create_task", + "description": "Use this tool to create one or more dynamic tasks from a shared text instruction and varying parameters.How it works:\n - Provide a single text instruction\n - Use the 'task_parameters' field to pass an array of parameter sets\n - Each resulting task will use the same instruction with different parameter values\n This is useful when performing the same operation across many inputs (e.g., getting weather for multiple cities, searching multiple slack channels, iterating through various linear tickets, etc).\n Once created, these tasks should be passed to the 'subagent__execute_task' tool for execution. Tasks can run sequentially or in parallel.\n ---\n What is a 'subagent'?\n A 'subagent' is a stateless sub-process that executes a single task independently. Use subagents when:\n - You want to parallelize similar work across different inputs\n - You are not sure your search or operation will succeed on the first try\n Each subagent receives a task with a defined payload and returns a result, which is not visible to the user unless explicitly summarized by the system.\n ---\n Examples of 'task_parameters' for a single task:\n text_instruction: Search for the config file in the root directory.\n Examples of 'task_parameters' for multiple tasks:\n text_instruction: Get weather for Melbourne.\n text_instruction: Get weather for Los Angeles.\n text_instruction: Get weather for San Francisco.\n ", + "inputSchema": { + "properties": { + "task_parameters": { + "description": "Array of parameter sets for creating tasks. For a single task, provide an array with one element. For multiple tasks, provide an array with multiple elements, each with different parameter values. If there is no parameter set, provide an empty array.", + "items": { + "properties": { + "text_instruction": { + "description": "The text instruction to execute", + "type": "string" + } + }, + "required": [ + "text_instruction" + ], + "type": "object" + }, + "type": "array" + } + }, + "type": "object" + }, + "annotations": { + "title": "Dynamic Task Creation", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + }, + { + "name": "subagent__execute_task", + "description": "Only use the subagent__execute_task tool when you execute sub recipe task or dynamic task.\n EXECUTION STRATEGY DECISION:\n 1. If the tasks are created with execution_mode, use the execution_mode.\n 2. Execute tasks sequentially unless user explicitly requests parallel execution. PARALLEL: User uses keywords like 'parallel', 'simultaneously', 'at the same time', 'concurrently'\n\n IMPLEMENTATION:\n - Sequential execution: Call this tool multiple times, passing exactly ONE task per call\n - Parallel execution: Call this tool once, passing an ARRAY of all tasks\n\n EXAMPLES:\n User Intent Based:\n - User: 'get weather and tell me a joke' → Sequential (2 separate tool calls, 1 task each)\n - User: 'get weather and joke in parallel' → Parallel (1 tool call with array of 2 tasks)\n - User: 'run these simultaneously' → Parallel (1 tool call with task array)\n - User: 'do task A then task B' → Sequential (2 separate tool calls)", + "inputSchema": { + "properties": { + "execution_mode": { + "default": "sequential", + "description": "Execution strategy for multiple tasks. Use 'sequential' (default) unless user explicitly requests parallel execution with words like 'parallel', 'simultaneously', 'at the same time', or 'concurrently'.", + "enum": [ + "sequential", + "parallel" + ], + "type": "string" + }, + "task_ids": { + "items": { + "description": "Unique identifier for the task", + "type": "string" + }, + "type": "array" + } + }, + "required": [ + "task_ids" + ], + "type": "object" + }, + "annotations": { + "title": "Run tasks in parallel", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + } + ] + }, + "output": { + "message": { + "id": null, + "role": "assistant", + "created": 1753704328, + "content": [ + { + "type": "text", + "text": "The weather in Berlin, Germany is currently cloudy with a temperature of 18°C." + } + ] + }, + "usage": { + "model": "gpt-4o-2024-08-06", + "usage": { + "input_tokens": 1722, + "output_tokens": 18, + "total_tokens": 1740 + } + } + } + }, + "1bc400a528c54b25f4f1f609481e98e44222b3deaf7eee2c9e640e6345c73861": { + "input": { + "system": "You are a general-purpose AI agent called Goose, created by Block, the parent company of Square, CashApp, and Tidal. Goose is being developed as an open-source software project.\n\nThe current date is 2025-07-28 12:05:24.\n\nGoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o, claude-3.5-sonnet, o1, llama-3.2, deepseek-r1, etc).\nThese models have varying knowledge cut-off dates depending on when they were trained, but typically it's between 5-10 months prior to the current date.\n\n# Extensions\n\nExtensions allow other applications to provide context to Goose. Extensions connect Goose to different data sources and tools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level problems using the tools in these extensions, and can interact with multiple at once.\nUse the search_available_extensions tool to find additional extensions to enable to help with your task. To enable extensions, use the enable_extension tool and provide the extension_name. You should only enable extensions found from the search_available_extensions tool.\n\n\nBecause you dynamically load extensions, your conversation history may refer\nto interactions with extensions that are not currently active. The currently\nactive extensions are below. Each of these extensions provides tools that are\nin your tool specification.\n\n\n## weather_extension\n\n\n\n\n\n\n\n# Suggestion\n\"\"\n\n\n\n\n# Response Guidelines\n\n- Use Markdown formatting for all responses.\n- Follow best practices for Markdown, including:\n - Using headers for organization.\n - Bullet points for lists.\n - Links formatted correctly, either as linked text (e.g., [this is linked text](https://example.com)) or automatic links using angle brackets (e.g., ).\n- For code examples, use fenced code blocks by placing triple backticks (` ``` `) before and after the code. Include the language identifier after the opening backticks (e.g., ` ```python `) to enable syntax highlighting.\n- Ensure clarity, conciseness, and proper formatting to enhance readability and usability.\n\n# Additional Instructions:\n\nRight now you are *NOT* in the chat only mode and have access to tool use and system.", + "messages": [ + { + "id": null, + "role": "user", + "created": 1753704324, + "content": [ + { + "type": "text", + "text": "tell me what the weather is in Berlin, Germany" + } + ] + } + ], + "tools": [ + { + "name": "weather_extension__get_weather", + "description": "Get the weather for a location", + "inputSchema": { + "properties": { + "location": { + "description": "The city and state, e.g. San Francisco, CA", + "type": "string" + } + }, + "required": [ + "location" + ], + "type": "object" + } + }, + { + "name": "platform__search_available_extensions", + "description": "Searches for additional extensions available to help complete tasks.\n Use this tool when you're unable to find a specific feature or functionality you need to complete your task, or when standard approaches aren't working.\n These extensions might provide the exact tools needed to solve your problem.\n If you find a relevant one, consider using your tools to enable it.", + "inputSchema": { + "properties": {}, + "required": [], + "type": "object" + }, + "annotations": { + "title": "Discover extensions", + "readOnlyHint": true, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_extensions", + "description": "Tool to manage extensions and tools in goose context.\n Enable or disable extensions to help complete tasks.\n Enable or disable an extension by providing the extension name.\n ", + "inputSchema": { + "properties": { + "action": { + "description": "The action to perform", + "enum": [ + "enable", + "disable" + ], + "type": "string" + }, + "extension_name": { + "description": "The name of the extension to enable", + "type": "string" + } + }, + "required": [ + "action", + "extension_name" + ], + "type": "object" + }, + "annotations": { + "title": "Enable or disable an extension", + "readOnlyHint": false, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_schedule", + "description": "Manage scheduled recipe execution for this Goose instance.\n\nActions:\n- \"list\": List all scheduled jobs\n- \"create\": Create a new scheduled job from a recipe file\n- \"run_now\": Execute a scheduled job immediately \n- \"pause\": Pause a scheduled job\n- \"unpause\": Resume a paused job\n- \"delete\": Remove a scheduled job\n- \"kill\": Terminate a currently running job\n- \"inspect\": Get details about a running job\n- \"sessions\": List execution history for a job\n- \"session_content\": Get the full content (messages) of a specific session\n", + "inputSchema": { + "properties": { + "action": { + "enum": [ + "list", + "create", + "run_now", + "pause", + "unpause", + "delete", + "kill", + "inspect", + "sessions", + "session_content" + ], + "type": "string" + }, + "cron_expression": { + "description": "A cron expression for create action. Supports both 5-field (minute hour day month weekday) and 6-field (second minute hour day month weekday) formats. 5-field expressions are automatically converted to 6-field by prepending '0' for seconds.", + "type": "string" + }, + "execution_mode": { + "default": "background", + "description": "Execution mode for create action: 'foreground' or 'background'", + "enum": [ + "foreground", + "background" + ], + "type": "string" + }, + "job_id": { + "description": "Job identifier for operations on existing jobs", + "type": "string" + }, + "limit": { + "default": 50, + "description": "Limit for sessions list", + "type": "integer" + }, + "recipe_path": { + "description": "Path to recipe file for create action", + "type": "string" + }, + "session_id": { + "description": "Session identifier for session_content action", + "type": "string" + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "annotations": { + "title": "Manage scheduled recipes", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "dynamic_task__create_task", + "description": "Use this tool to create one or more dynamic tasks from a shared text instruction and varying parameters.How it works:\n - Provide a single text instruction\n - Use the 'task_parameters' field to pass an array of parameter sets\n - Each resulting task will use the same instruction with different parameter values\n This is useful when performing the same operation across many inputs (e.g., getting weather for multiple cities, searching multiple slack channels, iterating through various linear tickets, etc).\n Once created, these tasks should be passed to the 'subagent__execute_task' tool for execution. Tasks can run sequentially or in parallel.\n ---\n What is a 'subagent'?\n A 'subagent' is a stateless sub-process that executes a single task independently. Use subagents when:\n - You want to parallelize similar work across different inputs\n - You are not sure your search or operation will succeed on the first try\n Each subagent receives a task with a defined payload and returns a result, which is not visible to the user unless explicitly summarized by the system.\n ---\n Examples of 'task_parameters' for a single task:\n text_instruction: Search for the config file in the root directory.\n Examples of 'task_parameters' for multiple tasks:\n text_instruction: Get weather for Melbourne.\n text_instruction: Get weather for Los Angeles.\n text_instruction: Get weather for San Francisco.\n ", + "inputSchema": { + "properties": { + "task_parameters": { + "description": "Array of parameter sets for creating tasks. For a single task, provide an array with one element. For multiple tasks, provide an array with multiple elements, each with different parameter values. If there is no parameter set, provide an empty array.", + "items": { + "properties": { + "text_instruction": { + "description": "The text instruction to execute", + "type": "string" + } + }, + "required": [ + "text_instruction" + ], + "type": "object" + }, + "type": "array" + } + }, + "type": "object" + }, + "annotations": { + "title": "Dynamic Task Creation", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + }, + { + "name": "subagent__execute_task", + "description": "Only use the subagent__execute_task tool when you execute sub recipe task or dynamic task.\n EXECUTION STRATEGY DECISION:\n 1. If the tasks are created with execution_mode, use the execution_mode.\n 2. Execute tasks sequentially unless user explicitly requests parallel execution. PARALLEL: User uses keywords like 'parallel', 'simultaneously', 'at the same time', 'concurrently'\n\n IMPLEMENTATION:\n - Sequential execution: Call this tool multiple times, passing exactly ONE task per call\n - Parallel execution: Call this tool once, passing an ARRAY of all tasks\n\n EXAMPLES:\n User Intent Based:\n - User: 'get weather and tell me a joke' → Sequential (2 separate tool calls, 1 task each)\n - User: 'get weather and joke in parallel' → Parallel (1 tool call with array of 2 tasks)\n - User: 'run these simultaneously' → Parallel (1 tool call with task array)\n - User: 'do task A then task B' → Sequential (2 separate tool calls)", + "inputSchema": { + "properties": { + "execution_mode": { + "default": "sequential", + "description": "Execution strategy for multiple tasks. Use 'sequential' (default) unless user explicitly requests parallel execution with words like 'parallel', 'simultaneously', 'at the same time', or 'concurrently'.", + "enum": [ + "sequential", + "parallel" + ], + "type": "string" + }, + "task_ids": { + "items": { + "description": "Unique identifier for the task", + "type": "string" + }, + "type": "array" + } + }, + "required": [ + "task_ids" + ], + "type": "object" + }, + "annotations": { + "title": "Run tasks in parallel", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + } + ] + }, + "output": { + "message": { + "id": null, + "role": "assistant", + "created": 1753704326, + "content": [ + { + "type": "toolRequest", + "id": "call_5hvVKt0aj0RGRmrKEZECeJKV", + "toolCall": { + "status": "success", + "value": { + "name": "weather_extension__get_weather", + "arguments": { + "location": "Berlin, Germany" + } + } + } + } + ] + }, + "usage": { + "model": "gpt-4o-2024-08-06", + "usage": { + "input_tokens": 1680, + "output_tokens": 19, + "total_tokens": 1699 + } + } + } + } +} \ No newline at end of file diff --git a/crates/goose-cli/src/scenario_tests/recordings/openai/what_is_your_name.json b/crates/goose-cli/src/scenario_tests/recordings/openai/what_is_your_name.json new file mode 100644 index 000000000000..8599e3c45084 --- /dev/null +++ b/crates/goose-cli/src/scenario_tests/recordings/openai/what_is_your_name.json @@ -0,0 +1,238 @@ +{ + "1b998117eba523901ae6a4dbf8caa81a95ea88ef7a84d0434c9b41a26164a2b9": { + "input": { + "system": "You are a general-purpose AI agent called Goose, created by Block, the parent company of Square, CashApp, and Tidal. Goose is being developed as an open-source software project.\n\nThe current date is 2025-07-28 12:05:24.\n\nGoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o, claude-3.5-sonnet, o1, llama-3.2, deepseek-r1, etc).\nThese models have varying knowledge cut-off dates depending on when they were trained, but typically it's between 5-10 months prior to the current date.\n\n# Extensions\n\nExtensions allow other applications to provide context to Goose. Extensions connect Goose to different data sources and tools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level problems using the tools in these extensions, and can interact with multiple at once.\nUse the search_available_extensions tool to find additional extensions to enable to help with your task. To enable extensions, use the enable_extension tool and provide the extension_name. You should only enable extensions found from the search_available_extensions tool.\n\n\nBecause you dynamically load extensions, your conversation history may refer\nto interactions with extensions that are not currently active. The currently\nactive extensions are below. Each of these extensions provides tools that are\nin your tool specification.\n\n\n## weather_extension\n\n\n\n\n\n\n\n# Suggestion\n\"\"\n\n\n\n\n# Response Guidelines\n\n- Use Markdown formatting for all responses.\n- Follow best practices for Markdown, including:\n - Using headers for organization.\n - Bullet points for lists.\n - Links formatted correctly, either as linked text (e.g., [this is linked text](https://example.com)) or automatic links using angle brackets (e.g., ).\n- For code examples, use fenced code blocks by placing triple backticks (` ``` `) before and after the code. Include the language identifier after the opening backticks (e.g., ` ```python `) to enable syntax highlighting.\n- Ensure clarity, conciseness, and proper formatting to enhance readability and usability.\n\n# Additional Instructions:\n\nRight now you are *NOT* in the chat only mode and have access to tool use and system.", + "messages": [ + { + "id": null, + "role": "user", + "created": 1753704324, + "content": [ + { + "type": "text", + "text": "what is your name" + } + ] + } + ], + "tools": [ + { + "name": "weather_extension__get_weather", + "description": "Get the weather for a location", + "inputSchema": { + "properties": { + "location": { + "description": "The city and state, e.g. San Francisco, CA", + "type": "string" + } + }, + "required": [ + "location" + ], + "type": "object" + } + }, + { + "name": "platform__search_available_extensions", + "description": "Searches for additional extensions available to help complete tasks.\n Use this tool when you're unable to find a specific feature or functionality you need to complete your task, or when standard approaches aren't working.\n These extensions might provide the exact tools needed to solve your problem.\n If you find a relevant one, consider using your tools to enable it.", + "inputSchema": { + "properties": {}, + "required": [], + "type": "object" + }, + "annotations": { + "title": "Discover extensions", + "readOnlyHint": true, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_extensions", + "description": "Tool to manage extensions and tools in goose context.\n Enable or disable extensions to help complete tasks.\n Enable or disable an extension by providing the extension name.\n ", + "inputSchema": { + "properties": { + "action": { + "description": "The action to perform", + "enum": [ + "enable", + "disable" + ], + "type": "string" + }, + "extension_name": { + "description": "The name of the extension to enable", + "type": "string" + } + }, + "required": [ + "action", + "extension_name" + ], + "type": "object" + }, + "annotations": { + "title": "Enable or disable an extension", + "readOnlyHint": false, + "destructiveHint": false, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "platform__manage_schedule", + "description": "Manage scheduled recipe execution for this Goose instance.\n\nActions:\n- \"list\": List all scheduled jobs\n- \"create\": Create a new scheduled job from a recipe file\n- \"run_now\": Execute a scheduled job immediately \n- \"pause\": Pause a scheduled job\n- \"unpause\": Resume a paused job\n- \"delete\": Remove a scheduled job\n- \"kill\": Terminate a currently running job\n- \"inspect\": Get details about a running job\n- \"sessions\": List execution history for a job\n- \"session_content\": Get the full content (messages) of a specific session\n", + "inputSchema": { + "properties": { + "action": { + "enum": [ + "list", + "create", + "run_now", + "pause", + "unpause", + "delete", + "kill", + "inspect", + "sessions", + "session_content" + ], + "type": "string" + }, + "cron_expression": { + "description": "A cron expression for create action. Supports both 5-field (minute hour day month weekday) and 6-field (second minute hour day month weekday) formats. 5-field expressions are automatically converted to 6-field by prepending '0' for seconds.", + "type": "string" + }, + "execution_mode": { + "default": "background", + "description": "Execution mode for create action: 'foreground' or 'background'", + "enum": [ + "foreground", + "background" + ], + "type": "string" + }, + "job_id": { + "description": "Job identifier for operations on existing jobs", + "type": "string" + }, + "limit": { + "default": 50, + "description": "Limit for sessions list", + "type": "integer" + }, + "recipe_path": { + "description": "Path to recipe file for create action", + "type": "string" + }, + "session_id": { + "description": "Session identifier for session_content action", + "type": "string" + } + }, + "required": [ + "action" + ], + "type": "object" + }, + "annotations": { + "title": "Manage scheduled recipes", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": false + } + }, + { + "name": "dynamic_task__create_task", + "description": "Use this tool to create one or more dynamic tasks from a shared text instruction and varying parameters.How it works:\n - Provide a single text instruction\n - Use the 'task_parameters' field to pass an array of parameter sets\n - Each resulting task will use the same instruction with different parameter values\n This is useful when performing the same operation across many inputs (e.g., getting weather for multiple cities, searching multiple slack channels, iterating through various linear tickets, etc).\n Once created, these tasks should be passed to the 'subagent__execute_task' tool for execution. Tasks can run sequentially or in parallel.\n ---\n What is a 'subagent'?\n A 'subagent' is a stateless sub-process that executes a single task independently. Use subagents when:\n - You want to parallelize similar work across different inputs\n - You are not sure your search or operation will succeed on the first try\n Each subagent receives a task with a defined payload and returns a result, which is not visible to the user unless explicitly summarized by the system.\n ---\n Examples of 'task_parameters' for a single task:\n text_instruction: Search for the config file in the root directory.\n Examples of 'task_parameters' for multiple tasks:\n text_instruction: Get weather for Melbourne.\n text_instruction: Get weather for Los Angeles.\n text_instruction: Get weather for San Francisco.\n ", + "inputSchema": { + "properties": { + "task_parameters": { + "description": "Array of parameter sets for creating tasks. For a single task, provide an array with one element. For multiple tasks, provide an array with multiple elements, each with different parameter values. If there is no parameter set, provide an empty array.", + "items": { + "properties": { + "text_instruction": { + "description": "The text instruction to execute", + "type": "string" + } + }, + "required": [ + "text_instruction" + ], + "type": "object" + }, + "type": "array" + } + }, + "type": "object" + }, + "annotations": { + "title": "Dynamic Task Creation", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + }, + { + "name": "subagent__execute_task", + "description": "Only use the subagent__execute_task tool when you execute sub recipe task or dynamic task.\n EXECUTION STRATEGY DECISION:\n 1. If the tasks are created with execution_mode, use the execution_mode.\n 2. Execute tasks sequentially unless user explicitly requests parallel execution. PARALLEL: User uses keywords like 'parallel', 'simultaneously', 'at the same time', 'concurrently'\n\n IMPLEMENTATION:\n - Sequential execution: Call this tool multiple times, passing exactly ONE task per call\n - Parallel execution: Call this tool once, passing an ARRAY of all tasks\n\n EXAMPLES:\n User Intent Based:\n - User: 'get weather and tell me a joke' → Sequential (2 separate tool calls, 1 task each)\n - User: 'get weather and joke in parallel' → Parallel (1 tool call with array of 2 tasks)\n - User: 'run these simultaneously' → Parallel (1 tool call with task array)\n - User: 'do task A then task B' → Sequential (2 separate tool calls)", + "inputSchema": { + "properties": { + "execution_mode": { + "default": "sequential", + "description": "Execution strategy for multiple tasks. Use 'sequential' (default) unless user explicitly requests parallel execution with words like 'parallel', 'simultaneously', 'at the same time', or 'concurrently'.", + "enum": [ + "sequential", + "parallel" + ], + "type": "string" + }, + "task_ids": { + "items": { + "description": "Unique identifier for the task", + "type": "string" + }, + "type": "array" + } + }, + "required": [ + "task_ids" + ], + "type": "object" + }, + "annotations": { + "title": "Run tasks in parallel", + "readOnlyHint": false, + "destructiveHint": true, + "idempotentHint": false, + "openWorldHint": true + } + } + ] + }, + "output": { + "message": { + "id": null, + "role": "assistant", + "created": 1753704325, + "content": [ + { + "type": "text", + "text": "My name is Goose. I'm an AI agent developed by Block, the parent company of Square, Cash App, and Tidal. How can I assist you today?" + } + ] + }, + "usage": { + "model": "gpt-4o-2024-08-06", + "usage": { + "input_tokens": 1674, + "output_tokens": 34, + "total_tokens": 1708 + } + } + } + } +} \ No newline at end of file diff --git a/crates/goose/src/providers/factory.rs b/crates/goose/src/providers/factory.rs index b3b8b044c8c2..c5eab4cfa08d 100644 --- a/crates/goose/src/providers/factory.rs +++ b/crates/goose/src/providers/factory.rs @@ -71,8 +71,6 @@ pub fn create(name: &str, model: ModelConfig) -> Result> { return create_lead_worker_from_env(name, &model, &lead_model_name); } - - // Default: create regular provider create_provider(name, model) } From 53e9bd5d84664ca7fe4c5ec56677fbac3d1080cf Mon Sep 17 00:00:00 2001 From: Douwe Osinga Date: Mon, 28 Jul 2025 14:11:47 +0200 Subject: [PATCH 16/18] Revert --- crates/goose/src/providers/anthropic.rs | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/crates/goose/src/providers/anthropic.rs b/crates/goose/src/providers/anthropic.rs index 153062ae7f48..508fdd3cb9d3 100644 --- a/crates/goose/src/providers/anthropic.rs +++ b/crates/goose/src/providers/anthropic.rs @@ -80,9 +80,6 @@ impl AnthropicProvider { ProviderError::RequestFailed(format!("Failed to construct endpoint URL: {e}")) })?; - let url_as_str = url.as_str(); - tracing::debug!("🔍 Sending request to Anthropic: {}", url_as_str); - let response = self .client .post(url) @@ -94,16 +91,6 @@ impl AnthropicProvider { let status = response.status(); let payload: Option = response.json().await.ok(); - let payload_str = payload - .as_ref() - .map(|p| serde_json::to_string(p).unwrap_or_else(|_| "Invalid JSON".to_string())); - - tracing::debug!( - "🔍 Received response from Anthropic: status={}, payload={:?}", - status, - payload_str - ); - // https://docs.anthropic.com/en/api/errors match status { StatusCode::OK => payload.ok_or_else( || ProviderError::RequestFailed("Response body is not valid JSON".to_string()) ), From 8dab8a0477815a8a103217e87ef03bba9ec4ee4f Mon Sep 17 00:00:00 2001 From: Douwe Osinga Date: Mon, 28 Jul 2025 17:27:57 +0200 Subject: [PATCH 17/18] make it test only --- crates/goose-cli/src/scenario_tests/mod.rs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/crates/goose-cli/src/scenario_tests/mod.rs b/crates/goose-cli/src/scenario_tests/mod.rs index 6678a5ff1a27..b299e65bb921 100644 --- a/crates/goose-cli/src/scenario_tests/mod.rs +++ b/crates/goose-cli/src/scenario_tests/mod.rs @@ -1,5 +1,10 @@ +#[cfg(test)] mod message_generator; +#[cfg(test)] mod mock_client; +#[cfg(test)] mod provider_configs; +#[cfg(test)] mod scenario_runner; +#[cfg(test)] mod scenarios; From 329f2b8e66a144a5c6ba9ac250d41fc46cb190d3 Mon Sep 17 00:00:00 2001 From: Douwe Osinga Date: Mon, 28 Jul 2025 19:32:24 +0200 Subject: [PATCH 18/18] What Jack & Alex said --- .../src/scenario_tests/scenario_runner.rs | 31 ++++++++++--------- 1 file changed, 16 insertions(+), 15 deletions(-) diff --git a/crates/goose-cli/src/scenario_tests/scenario_runner.rs b/crates/goose-cli/src/scenario_tests/scenario_runner.rs index b17eb9ff1def..51018b983b0c 100644 --- a/crates/goose-cli/src/scenario_tests/scenario_runner.rs +++ b/crates/goose-cli/src/scenario_tests/scenario_runner.rs @@ -71,23 +71,26 @@ where return Ok(()); } - let configs_to_test: Vec<_> = if let Some(to_skip) = providers_to_skip { - let excluded_providers: HashSet = - to_skip.iter().map(|name| name.to_lowercase()).collect(); + let excluded_providers: HashSet<_> = providers_to_skip + .into_iter() + .flatten() + .map(|name| name.to_lowercase()) + .collect(); - let filtered: Vec<_> = get_provider_configs() - .into_iter() - .filter(|c| !excluded_providers.contains(&c.name.to_lowercase())) - .collect(); + let all_configs = get_provider_configs(); - if filtered.len() != get_provider_configs().len() - to_skip.len() { + let all_config_len = all_configs.len(); + + let configs_to_test: Vec<_> = all_configs + .into_iter() + .filter(|c| !excluded_providers.contains(&c.name.to_lowercase())) + .collect(); + + if let Some(to_skip) = providers_to_skip { + if configs_to_test.len() != all_config_len - to_skip.len() { return Err(anyhow::anyhow!("Some providers in skip list don't exist")); } - - filtered - } else { - get_provider_configs() - }; + } let mut failures = Vec::new(); @@ -210,8 +213,6 @@ where break; } } - - // Rest of the function remains the same... let updated_messages = session.message_history().to_vec(); if let Some(ref err_msg) = error {