diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index a191e2323..88f376c15 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -105,8 +105,7 @@ jobs: run: | gnome-keyring-daemon --components=secrets --daemonize --unlock <<< 'foobar' export CARGO_INCREMENTAL=0 - cargo test --locked -- --skip scenario_tests::scenarios::tests - cargo test --locked --jobs 1 scenario_tests::scenarios::tests + cargo test --locked working-directory: crates env: RUST_MIN_STACK: 8388608 @@ -233,8 +232,7 @@ jobs: export CARGO_INCREMENTAL=0 cargo test -p goose --no-default-features --features ${{ matrix.tls-feature }},code-mode,tree-sitter,live-voice,scheduler,platform-apps,chat-recall,acp-http cargo test -p goose-providers --no-default-features --features ${{ matrix.tls-feature }},live-websocket - cargo test -p goose-cli --no-default-features --features ${{ matrix.tls-feature }},code-mode,tree-sitter,live-voice,scheduler,platform-apps,chat-recall,acp-http -- --skip scenario_tests::scenarios::tests - cargo test -p goose-cli --no-default-features --features ${{ matrix.tls-feature }},code-mode,tree-sitter,live-voice,scheduler,platform-apps,chat-recall,acp-http --jobs 1 scenario_tests::scenarios::tests + cargo test -p goose-cli --no-default-features --features ${{ matrix.tls-feature }},code-mode,tree-sitter,live-voice,scheduler,platform-apps,chat-recall,acp-http env: RUST_MIN_STACK: 8388608 diff --git a/Cargo.lock b/Cargo.lock index b2af27095..acd552713 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -5203,7 +5203,6 @@ dependencies = [ "cliclack", "comfy-table", "console", - "dotenvy", "env-lock", "etcetera", "fs2", diff --git a/crates/goose-cli/Cargo.toml b/crates/goose-cli/Cargo.toml index c7f53d614..5b66a7b4a 100644 --- a/crates/goose-cli/Cargo.toml +++ b/crates/goose-cli/Cargo.toml @@ -35,7 +35,6 @@ clap = { workspace = true } cliclack = { version = "0.5", default-features = false } console = { version = "0.16", default-features = false, features = ["std"] } unicode-segmentation = { version = "1.12", default-features = false } -dotenvy = { workspace = true } bat = { version = "0.26", default-features = false, features = ["regex-onig"] } anyhow = { workspace = true } serde_json = { workspace = true } diff --git a/crates/goose-cli/src/lib.rs b/crates/goose-cli/src/lib.rs index d6c810e48..3fef38e38 100644 --- a/crates/goose-cli/src/lib.rs +++ b/crates/goose-cli/src/lib.rs @@ -10,7 +10,6 @@ pub mod cli; pub mod commands; pub mod logging; pub mod recipes; -pub mod scenario_tests; pub mod session; pub mod signal; diff --git a/crates/goose-cli/src/scenario_tests/message_generator.rs b/crates/goose-cli/src/scenario_tests/message_generator.rs deleted file mode 100644 index 7384e7592..000000000 --- a/crates/goose-cli/src/scenario_tests/message_generator.rs +++ /dev/null @@ -1,33 +0,0 @@ -//! 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; -use goose::conversation::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/mock_client.rs b/crates/goose-cli/src/scenario_tests/mock_client.rs deleted file mode 100644 index 3030cf1cb..000000000 --- a/crates/goose-cli/src/scenario_tests/mock_client.rs +++ /dev/null @@ -1,169 +0,0 @@ -//! 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 goose::agents::mcp_client::{Error, McpClientTrait}; -use rmcp::{ - model::{ - CallToolResult, ContentBlock, ErrorData, GetPromptResult, ListPromptsResult, - ListResourcesResult, ListToolsResult, ReadResourceResult, ServerNotification, Tool, - }, - object, -}; -use serde_json::Value; -use std::collections::HashMap; -use tokio::sync::mpsc::{self, Receiver}; -use tokio_util::sync::CancellationToken; - -type Handler = Box Result, ErrorData> + Send + Sync>; - -pub struct MockClient { - tools: HashMap, - handlers: HashMap, -} - -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, ErrorData> + Send + Sync + 'static, - { - let tool_name = tool.name.to_string(); - 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 list_resources( - &self, - _session_id: &str, - _next_cursor: Option, - _cancel_token: CancellationToken, - ) -> Result { - Ok(ListResourcesResult { - resources: vec![], - next_cursor: None, - meta: None, - ..Default::default() - }) - } - - fn get_info(&self) -> std::option::Option<&rmcp::model::InitializeResult> { - None - } - - async fn read_resource( - &self, - _session_id: &str, - _uri: &str, - _cancel_token: CancellationToken, - ) -> Result { - Err(Error::UnexpectedResponse) - } - - async fn list_tools( - &self, - _session_id: &str, - _: Option, - _cancel_token: CancellationToken, - ) -> Result { - let rmcp_tools: Vec = self - .tools - .values() - .map(|tool| { - rmcp::model::Tool::new( - tool.name.to_string(), - tool.description.clone().unwrap_or_default(), - tool.input_schema.clone(), - ) - }) - .collect(); - - Ok(ListToolsResult { - tools: rmcp_tools, - next_cursor: None, - meta: None, - ..Default::default() - }) - } - - async fn call_tool( - &self, - _ctx: &goose::agents::ToolCallContext, - name: &str, - arguments: Option>, - _cancel_token: CancellationToken, - ) -> Result { - if let Some(handler) = self.handlers.get(name) { - match handler(&Value::Object(arguments.unwrap_or_default())) { - Ok(content) => Ok(CallToolResult::success(content)), - Err(_e) => Err(Error::UnexpectedResponse), - } - } else { - Err(Error::UnexpectedResponse) - } - } - - async fn list_prompts( - &self, - _session_id: &str, - _next_cursor: Option, - _cancel_token: CancellationToken, - ) -> Result { - Ok(ListPromptsResult::with_all_items(vec![])) - } - - async fn get_prompt( - &self, - _session_id: &str, - _name: &str, - _arguments: Value, - _cancel_token: CancellationToken, - ) -> Result { - Err(Error::UnexpectedResponse) - } - - 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", - object!({ - "type": "object", - "required": ["location"], - "properties": { - "location": { - "type": "string", - "description": "The city and state, e.g. San Francisco, CA" - } - } - }), - ); - - 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![ContentBlock::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 deleted file mode 100644 index b299e65bb..000000000 --- a/crates/goose-cli/src/scenario_tests/mod.rs +++ /dev/null @@ -1,10 +0,0 @@ -#[cfg(test)] -mod message_generator; -#[cfg(test)] -mod mock_client; -#[cfg(test)] -mod provider_configs; -#[cfg(test)] -mod scenario_runner; -#[cfg(test)] -mod scenarios; diff --git a/crates/goose-cli/src/scenario_tests/provider_configs.rs b/crates/goose-cli/src/scenario_tests/provider_configs.rs deleted file mode 100644 index badedfa00..000000000 --- a/crates/goose-cli/src/scenario_tests/provider_configs.rs +++ /dev/null @@ -1,108 +0,0 @@ -//! Providers for the scenario tests. Keep in sync with -//! goose/crates/goose/src/providers/factory.rs - -use std::collections::HashMap; -use std::sync::LazyLock; - -#[derive(Debug, Clone)] -pub struct ProviderConfig { - pub name: &'static str, - pub model_name: &'static str, - pub required_env_vars: &'static [&'static str], - pub env_modifications: Option>>, - pub skip_reason: Option<&'static str>, -} - -impl ProviderConfig { - 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()); - - Self { - name, - model_name, - required_env_vars, - env_modifications: None, - skip_reason, - } - } - - pub fn simple(name: &'static str, model_name: &'static str) -> Self { - Self::simple_skip(name, model_name, None) - } - - pub fn is_skipped(&self) -> bool { - self.skip_reason.is_some() - } -} - -static PROVIDER_CONFIGS: LazyLock> = LazyLock::new(|| { - vec![ - ProviderConfig::simple("openai", "gpt-4o"), - ProviderConfig::simple("anthropic", "claude-sonnet-4-20250514"), - ProviderConfig { - name: "azure_openai", - model_name: "gpt-4o", - required_env_vars: &[ - "AZURE_OPENAI_API_KEY", - "AZURE_OPENAI_ENDPOINT", - "AZURE_OPENAI_DEPLOYMENT_NAME", - ], - env_modifications: None, - skip_reason: None, - }, - ProviderConfig { - name: "aws_bedrock", - model_name: "anthropic.claude-sonnet-4-20250514:0", - required_env_vars: &["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"], - 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_skip( - "openrouter", - "anthropic/claude-sonnet-4", - Some("Key is no longer valid"), - ), - ProviderConfig::simple_skip( - "claude-code", - "claude-sonnet-4-20250514", - Some("No keys available"), - ), - ProviderConfig::simple_skip("cursor-agent", "gpt-5", 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")), - ] -}); - -pub fn get_provider_configs() -> Vec<&'static ProviderConfig> { - PROVIDER_CONFIGS - .iter() - .filter(|config| !config.is_skipped()) - .collect() -} 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 deleted file mode 100644 index abc04fb90..000000000 --- a/crates/goose-cli/src/scenario_tests/recordings/anthropic/context_length_exceeded.json +++ /dev/null @@ -1,286 +0,0 @@ -{ - "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945": { - "input": { - "system": "You are a general-purpose AI agent called goose, created by Block, the parent company of Square, CashApp, and Tidal.\ngoose is being developed as an open-source software project.\n\nThe current date is 2025-10-15 21:59:27.\n\ngoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o,\nclaude-sonnet-4, 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\nmonths 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\ntools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level\nproblems 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\nextensions, use the enable_extension tool and provide the extension_name. You should only enable extensions found from\nthe 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\n## weather_extension\n\n\n\n\n\n\n\n\n\n# Suggestion\n\n\"\"\n\n\n\n\n# sub agents\n\nExecute self contained tasks where step-by-step visibility is not important through subagents.\n\n- Delegate via `dynamic_task__create_task` for: result-only operations, parallelizable work, multi-part requests,\n verification, exploration\n- Parallel subagents for multiple operations, single subagents for independent work\n- Explore solutions in parallel — launch parallel subagents with different approaches (if non-interfering)\n- Provide all needed context — subagents cannot see your context\n- Use extension filters to limit resource access\n- Use return_last_only when only a summary or simple answer is required — inform subagent of this choice.\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\n 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\n 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": [], - "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": "Create tasks with instructions or prompt. For simple tasks, only include the instructions field. Extensions control: omit field = use all current extensions; empty array [] = no extensions; array with names = only those extensions. Specify extensions as shortnames (the prefixes for your tools). Specify return_last_only as true and have your subagent summarize its work in its last message to conserve your own context. Optional: title, description, extensions, settings, retry, response schema, context, activities. Arrays for multiple tasks.", - "inputSchema": { - "properties": { - "execution_mode": { - "description": "How to execute multiple tasks (default: parallel for multiple tasks, sequential for single task)", - "enum": [ - "sequential", - "parallel" - ], - "type": "string" - }, - "task_parameters": { - "description": "Array of tasks. Each task must have either 'instructions' OR 'prompt' field (at least one is required).", - "items": { - "properties": { - "activities": { - "items": { - "type": "string" - }, - "type": "array" - }, - "context": { - "items": { - "type": "string" - }, - "type": "array" - }, - "description": { - "type": "string" - }, - "extensions": { - "items": { - "type": "object" - }, - "type": "array" - }, - "instructions": { - "description": "Task instructions (required if prompt is not provided)", - "type": "string" - }, - "parameters": { - "items": { - "type": "object" - }, - "type": "array" - }, - "prompt": { - "description": "Initial prompt (required if instructions is not provided)", - "type": "string" - }, - "response": { - "type": "object" - }, - "retry": { - "type": "object" - }, - "return_last_only": { - "description": "If true, return only the last message from the subagent (default: false, returns full conversation)", - "type": "boolean" - }, - "settings": { - "type": "object" - }, - "title": { - "type": "string" - } - }, - "type": "object" - }, - "minItems": 1, - "type": "array" - } - }, - "required": [ - "task_parameters" - ], - "type": "object" - }, - "annotations": { - "title": "Create Dynamic Tasks", - "readOnlyHint": false, - "destructiveHint": false, - "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": 1760565573, - "content": [ - { - "type": "text", - "text": "I understand. How can I help you today?" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - "usage": { - "model": "claude-sonnet-4-20250514", - "usage": { - "input_tokens": 2702, - "output_tokens": 13, - "total_tokens": 2715 - } - } - } - } -} \ 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 deleted file mode 100644 index 0184429be..000000000 --- a/crates/goose-cli/src/scenario_tests/recordings/anthropic/image_analysis.json +++ /dev/null @@ -1,307 +0,0 @@ -{ - "c848f22f273e158c32435d3e72cc999c046dc1a9afdc3efda68ff451f833a185": { - "input": { - "system": "You are a general-purpose AI agent called goose, created by Block, the parent company of Square, CashApp, and Tidal.\ngoose is being developed as an open-source software project.\n\nThe current date is 2025-10-15 21:57:45.\n\ngoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o,\nclaude-sonnet-4, 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\nmonths 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\ntools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level\nproblems 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\nextensions, use the enable_extension tool and provide the extension_name. You should only enable extensions found from\nthe 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\n## weather_extension\n\n\n\n\n\n\n\n\n\n# Suggestion\n\n\"\"\n\n\n\n\n# sub agents\n\nExecute self contained tasks where step-by-step visibility is not important through subagents.\n\n- Delegate via `dynamic_task__create_task` for: result-only operations, parallelizable work, multi-part requests,\n verification, exploration\n- Parallel subagents for multiple operations, single subagents for independent work\n- Explore solutions in parallel — launch parallel subagents with different approaches (if non-interfering)\n- Provide all needed context — subagents cannot see your context\n- Use extension filters to limit resource access\n- Use return_last_only when only a summary or simple answer is required — inform subagent of this choice.\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\n 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\n 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": 1760565465, - "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" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - } - ], - "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": "Create tasks with instructions or prompt. For simple tasks, only include the instructions field. Extensions control: omit field = use all current extensions; empty array [] = no extensions; array with names = only those extensions. Specify extensions as shortnames (the prefixes for your tools). Specify return_last_only as true and have your subagent summarize its work in its last message to conserve your own context. Optional: title, description, extensions, settings, retry, response schema, context, activities. Arrays for multiple tasks.", - "inputSchema": { - "properties": { - "execution_mode": { - "description": "How to execute multiple tasks (default: parallel for multiple tasks, sequential for single task)", - "enum": [ - "sequential", - "parallel" - ], - "type": "string" - }, - "task_parameters": { - "description": "Array of tasks. Each task must have either 'instructions' OR 'prompt' field (at least one is required).", - "items": { - "properties": { - "activities": { - "items": { - "type": "string" - }, - "type": "array" - }, - "context": { - "items": { - "type": "string" - }, - "type": "array" - }, - "description": { - "type": "string" - }, - "extensions": { - "items": { - "type": "object" - }, - "type": "array" - }, - "instructions": { - "description": "Task instructions (required if prompt is not provided)", - "type": "string" - }, - "parameters": { - "items": { - "type": "object" - }, - "type": "array" - }, - "prompt": { - "description": "Initial prompt (required if instructions is not provided)", - "type": "string" - }, - "response": { - "type": "object" - }, - "retry": { - "type": "object" - }, - "return_last_only": { - "description": "If true, return only the last message from the subagent (default: false, returns full conversation)", - "type": "boolean" - }, - "settings": { - "type": "object" - }, - "title": { - "type": "string" - } - }, - "type": "object" - }, - "minItems": 1, - "type": "array" - } - }, - "required": [ - "task_parameters" - ], - "type": "object" - }, - "annotations": { - "title": "Create Dynamic Tasks", - "readOnlyHint": false, - "destructiveHint": false, - "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": 1760565468, - "content": [ - { - "type": "text", - "text": "I don't see any image in our conversation. It appears you may have intended to share an image, but it wasn't included in your message.\n\nCould you please try uploading the image again? Once you share it, I'll be happy to describe what I see in it." - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - "usage": { - "model": "claude-sonnet-4-20250514", - "usage": { - "input_tokens": 2708, - "output_tokens": 61, - "total_tokens": 2769 - } - } - } - } -} \ 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 deleted file mode 100644 index 68ce092dc..000000000 --- a/crates/goose-cli/src/scenario_tests/recordings/anthropic/weather_tool.json +++ /dev/null @@ -1,673 +0,0 @@ -{ - "1b90ffd4b16eab7aef1c24e9b61f6b6cc6f0d9b04e8a4f4344454a45b0793284": { - "input": { - "system": "You are a general-purpose AI agent called goose, created by Block, the parent company of Square, CashApp, and Tidal.\ngoose is being developed as an open-source software project.\n\ngoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o,\nclaude-sonnet-4, 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\nmonths 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\ntools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level\nproblems using the tools in these extensions, and can interact with multiple at once.\n\nIf the Extension Manager extension is enabled, you can use the search_available_extensions tool to discover additional\nextensions that can help with your task. To enable or disable extensions, use the manage_extensions tool with the\nextension_name. You should only enable extensions found from the search_available_extensions tool.\nIf Extension Manager is not available, you can only work with currently enabled extensions and cannot dynamically load\nnew ones.\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# 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\n 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\n 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.", - "messages": [ - { - "id": "msg_20251211_27_0", - "role": "user", - "created": 1765495263, - "content": [ - { - "type": "text", - "text": "tell me what the weather is in Berlin, Germany" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - { - "id": "msg_9076da8a-a3b1-4cfc-b5d9-0ffc2a7879c9", - "role": "assistant", - "created": 1765495266, - "content": [ - { - "type": "toolRequest", - "id": "toolu_01CDkt9pjh8oC9C1984uhvuG", - "toolCall": { - "status": "success", - "value": { - "name": "weather_extension__get_weather", - "arguments": { - "location": "Berlin, Germany" - } - } - } - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - { - "id": "msg_d7b3db5e-0402-42a8-937c-2ccf68a3e4e0", - "role": "user", - "created": 1765495266, - "content": [ - { - "type": "toolResponse", - "id": "toolu_01CDkt9pjh8oC9C1984uhvuG", - "toolResult": { - "status": "success", - "value": { - "content": [ - { - "type": "text", - "text": "The weather in Berlin, Germany is cloudy and 18°C" - } - ] - } - } - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - } - ], - "tools": [ - { - "name": "dynamic_task__create_task", - "description": "Create tasks with instructions or prompt. For simple tasks, only include the instructions field. Extensions control: omit field = use all current extensions; empty array [] = no extensions; array with names = only those extensions. Specify extensions as shortnames (the prefixes for your tools). Specify return_last_only as true and have your subagent summarize its work in its last message to conserve your own context. Optional: title, description, extensions, settings, retry, response schema, activities. Arrays for multiple tasks.", - "inputSchema": { - "$defs": { - "TaskParameter": { - "description": "Parameters for a single task", - "properties": { - "activities": { - "items": { - "type": "string" - }, - "type": [ - "array", - "null" - ] - }, - "description": { - "type": [ - "string", - "null" - ] - }, - "extensions": { - "items": { - "additionalProperties": true, - "type": "object" - }, - "type": [ - "array", - "null" - ] - }, - "instructions": { - "type": [ - "string", - "null" - ] - }, - "parameters": { - "items": { - "additionalProperties": true, - "type": "object" - }, - "type": [ - "array", - "null" - ] - }, - "prompt": { - "type": [ - "string", - "null" - ] - }, - "response": { - "additionalProperties": true, - "type": [ - "object", - "null" - ] - }, - "retry": { - "additionalProperties": true, - "type": [ - "object", - "null" - ] - }, - "return_last_only": { - "description": "If true, return only the last message from the subagent (default: false, returns full conversation)", - "type": [ - "boolean", - "null" - ] - }, - "settings": { - "additionalProperties": true, - "type": [ - "object", - "null" - ] - }, - "title": { - "type": [ - "string", - "null" - ] - } - }, - "type": "object" - } - }, - "$schema": "https://json-schema.org/draft/2020-12/schema", - "properties": { - "execution_mode": { - "description": "How to execute multiple tasks (default: parallel for multiple tasks, sequential for single task)", - "type": [ - "string", - "null" - ] - }, - "task_parameters": { - "description": "Array of tasks. Each task must have either 'instructions' OR 'prompt' field (at least one is required).", - "items": { - "$ref": "#/$defs/TaskParameter" - }, - "minItems": 1, - "type": "array" - } - }, - "required": [ - "task_parameters" - ], - "title": "CreateDynamicTaskParams", - "type": "object" - }, - "annotations": { - "title": "Create Dynamic Tasks", - "readOnlyHint": false, - "destructiveHint": false, - "idempotentHint": false, - "openWorldHint": true - } - }, - { - "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" - }, - "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": "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 - } - }, - { - "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" - } - } - ] - }, - "output": { - "message": { - "id": null, - "role": "assistant", - "created": 1765495269, - "content": [ - { - "type": "text", - "text": "# Weather in Berlin, Germany\n\nThe current weather in Berlin, Germany is:\n- **Conditions**: Cloudy\n- **Temperature**: 18°C (64°F)\n\nIt's a mild day with overcast conditions in Berlin!" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - "usage": { - "model": "claude-sonnet-4-20250514", - "usage": { - "input_tokens": 2406, - "output_tokens": 55, - "total_tokens": 2461 - } - } - } - }, - "8b1b8633232ca390cb3ff37a48daf74168b58f13e2943efcb17957129ee34d1a": { - "input": { - "system": "Reply with only a description in four words or less", - "messages": [ - { - "id": null, - "role": "user", - "created": 1765495263, - "content": [ - { - "type": "text", - "text": "Here are the first few user messages:\ntell me what the weather is in Berlin, Germany\n\nBased on the conversation so far, provide a concise description of this session in 4 words or less. This will be used for finding the session later in a UI with limited space - reply *ONLY* with the description" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - } - ], - "tools": [] - }, - "output": { - "message": { - "id": null, - "role": "assistant", - "created": 1765495265, - "content": [ - { - "type": "text", - "text": "Berlin weather inquiry" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - "usage": { - "model": "claude-sonnet-4-20250514", - "usage": { - "input_tokens": 84, - "output_tokens": 6, - "total_tokens": 90 - } - } - } - }, - "1bc400a528c54b25f4f1f609481e98e44222b3deaf7eee2c9e640e6345c73861": { - "input": { - "system": "You are a general-purpose AI agent called goose, created by Block, the parent company of Square, CashApp, and Tidal.\ngoose is being developed as an open-source software project.\n\ngoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o,\nclaude-sonnet-4, 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\nmonths 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\ntools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level\nproblems using the tools in these extensions, and can interact with multiple at once.\n\nIf the Extension Manager extension is enabled, you can use the search_available_extensions tool to discover additional\nextensions that can help with your task. To enable or disable extensions, use the manage_extensions tool with the\nextension_name. You should only enable extensions found from the search_available_extensions tool.\nIf Extension Manager is not available, you can only work with currently enabled extensions and cannot dynamically load\nnew ones.\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# 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\n 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\n 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.", - "messages": [ - { - "id": "msg_20251211_27_0", - "role": "user", - "created": 1765495263, - "content": [ - { - "type": "text", - "text": "tell me what the weather is in Berlin, Germany" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - } - ], - "tools": [ - { - "name": "dynamic_task__create_task", - "description": "Create tasks with instructions or prompt. For simple tasks, only include the instructions field. Extensions control: omit field = use all current extensions; empty array [] = no extensions; array with names = only those extensions. Specify extensions as shortnames (the prefixes for your tools). Specify return_last_only as true and have your subagent summarize its work in its last message to conserve your own context. Optional: title, description, extensions, settings, retry, response schema, activities. Arrays for multiple tasks.", - "inputSchema": { - "$defs": { - "TaskParameter": { - "description": "Parameters for a single task", - "properties": { - "activities": { - "items": { - "type": "string" - }, - "type": [ - "array", - "null" - ] - }, - "description": { - "type": [ - "string", - "null" - ] - }, - "extensions": { - "items": { - "additionalProperties": true, - "type": "object" - }, - "type": [ - "array", - "null" - ] - }, - "instructions": { - "type": [ - "string", - "null" - ] - }, - "parameters": { - "items": { - "additionalProperties": true, - "type": "object" - }, - "type": [ - "array", - "null" - ] - }, - "prompt": { - "type": [ - "string", - "null" - ] - }, - "response": { - "additionalProperties": true, - "type": [ - "object", - "null" - ] - }, - "retry": { - "additionalProperties": true, - "type": [ - "object", - "null" - ] - }, - "return_last_only": { - "description": "If true, return only the last message from the subagent (default: false, returns full conversation)", - "type": [ - "boolean", - "null" - ] - }, - "settings": { - "additionalProperties": true, - "type": [ - "object", - "null" - ] - }, - "title": { - "type": [ - "string", - "null" - ] - } - }, - "type": "object" - } - }, - "$schema": "https://json-schema.org/draft/2020-12/schema", - "properties": { - "execution_mode": { - "description": "How to execute multiple tasks (default: parallel for multiple tasks, sequential for single task)", - "type": [ - "string", - "null" - ] - }, - "task_parameters": { - "description": "Array of tasks. Each task must have either 'instructions' OR 'prompt' field (at least one is required).", - "items": { - "$ref": "#/$defs/TaskParameter" - }, - "minItems": 1, - "type": "array" - } - }, - "required": [ - "task_parameters" - ], - "title": "CreateDynamicTaskParams", - "type": "object" - }, - "annotations": { - "title": "Create Dynamic Tasks", - "readOnlyHint": false, - "destructiveHint": false, - "idempotentHint": false, - "openWorldHint": true - } - }, - { - "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" - }, - "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": "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 - } - }, - { - "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" - } - } - ] - }, - "output": { - "message": { - "id": null, - "role": "assistant", - "created": 1765495266, - "content": [ - { - "type": "text", - "text": "I'll get the current weather information for Berlin, Germany for you." - }, - { - "type": "toolRequest", - "id": "toolu_01CDkt9pjh8oC9C1984uhvuG", - "toolCall": { - "status": "success", - "value": { - "name": "weather_extension__get_weather", - "arguments": { - "location": "Berlin, Germany" - } - } - } - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - "usage": { - "model": "claude-sonnet-4-20250514", - "usage": { - "input_tokens": 2320, - "output_tokens": 74, - "total_tokens": 2394 - } - } - } - } -} \ 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 deleted file mode 100644 index d55f2d9ae..000000000 --- a/crates/goose-cli/src/scenario_tests/recordings/anthropic/what_is_your_name.json +++ /dev/null @@ -1,302 +0,0 @@ -{ - "1b998117eba523901ae6a4dbf8caa81a95ea88ef7a84d0434c9b41a26164a2b9": { - "input": { - "system": "You are a general-purpose AI agent called goose, created by Block, the parent company of Square, CashApp, and Tidal.\ngoose is being developed as an open-source software project.\n\nThe current date is 2025-10-15 21:57:44.\n\ngoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o,\nclaude-sonnet-4, 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\nmonths 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\ntools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level\nproblems 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\nextensions, use the enable_extension tool and provide the extension_name. You should only enable extensions found from\nthe 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\n## weather_extension\n\n\n\n\n\n\n\n\n\n# Suggestion\n\n\"\"\n\n\n\n\n# sub agents\n\nExecute self contained tasks where step-by-step visibility is not important through subagents.\n\n- Delegate via `dynamic_task__create_task` for: result-only operations, parallelizable work, multi-part requests,\n verification, exploration\n- Parallel subagents for multiple operations, single subagents for independent work\n- Explore solutions in parallel — launch parallel subagents with different approaches (if non-interfering)\n- Provide all needed context — subagents cannot see your context\n- Use extension filters to limit resource access\n- Use return_last_only when only a summary or simple answer is required — inform subagent of this choice.\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\n 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\n 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": 1760565464, - "content": [ - { - "type": "text", - "text": "what is your name" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - } - ], - "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": "Create tasks with instructions or prompt. For simple tasks, only include the instructions field. Extensions control: omit field = use all current extensions; empty array [] = no extensions; array with names = only those extensions. Specify extensions as shortnames (the prefixes for your tools). Specify return_last_only as true and have your subagent summarize its work in its last message to conserve your own context. Optional: title, description, extensions, settings, retry, response schema, context, activities. Arrays for multiple tasks.", - "inputSchema": { - "properties": { - "execution_mode": { - "description": "How to execute multiple tasks (default: parallel for multiple tasks, sequential for single task)", - "enum": [ - "sequential", - "parallel" - ], - "type": "string" - }, - "task_parameters": { - "description": "Array of tasks. Each task must have either 'instructions' OR 'prompt' field (at least one is required).", - "items": { - "properties": { - "activities": { - "items": { - "type": "string" - }, - "type": "array" - }, - "context": { - "items": { - "type": "string" - }, - "type": "array" - }, - "description": { - "type": "string" - }, - "extensions": { - "items": { - "type": "object" - }, - "type": "array" - }, - "instructions": { - "description": "Task instructions (required if prompt is not provided)", - "type": "string" - }, - "parameters": { - "items": { - "type": "object" - }, - "type": "array" - }, - "prompt": { - "description": "Initial prompt (required if instructions is not provided)", - "type": "string" - }, - "response": { - "type": "object" - }, - "retry": { - "type": "object" - }, - "return_last_only": { - "description": "If true, return only the last message from the subagent (default: false, returns full conversation)", - "type": "boolean" - }, - "settings": { - "type": "object" - }, - "title": { - "type": "string" - } - }, - "type": "object" - }, - "minItems": 1, - "type": "array" - } - }, - "required": [ - "task_parameters" - ], - "type": "object" - }, - "annotations": { - "title": "Create Dynamic Tasks", - "readOnlyHint": false, - "destructiveHint": false, - "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": 1760565467, - "content": [ - { - "type": "text", - "text": "My name is **goose**. I'm a general-purpose AI agent created by Block, the parent company of Square, CashApp, and Tidal. I'm being developed as an open-source software project and can help you with various tasks using different extensions and tools.\n\nIs there something specific you'd like help with today?" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - "usage": { - "model": "claude-sonnet-4-20250514", - "usage": { - "input_tokens": 2704, - "output_tokens": 74, - "total_tokens": 2778 - } - } - } - } -} \ 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 deleted file mode 100644 index 9e26dfeeb..000000000 --- a/crates/goose-cli/src/scenario_tests/recordings/azure_openai/context_length_exceeded.json +++ /dev/null @@ -1 +0,0 @@ -{} \ 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 deleted file mode 100644 index 105749bcd..000000000 --- a/crates/goose-cli/src/scenario_tests/recordings/azure_openai/weather_tool.json +++ /dev/null @@ -1,669 +0,0 @@ -{ - "8b1b8633232ca390cb3ff37a48daf74168b58f13e2943efcb17957129ee34d1a": { - "input": { - "system": "Reply with only a description in four words or less", - "messages": [ - { - "id": null, - "role": "user", - "created": 1765495269, - "content": [ - { - "type": "text", - "text": "Here are the first few user messages:\ntell me what the weather is in Berlin, Germany\n\nBased on the conversation so far, provide a concise description of this session in 4 words or less. This will be used for finding the session later in a UI with limited space - reply *ONLY* with the description" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - } - ], - "tools": [] - }, - "output": { - "message": { - "id": null, - "role": "assistant", - "created": 1765495270, - "content": [ - { - "type": "text", - "text": "Weather inquiry for Berlin" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - "usage": { - "model": "gpt-4o-mini-2024-07-18", - "usage": { - "input_tokens": 84, - "output_tokens": 5, - "total_tokens": 89 - } - } - } - }, - "1bc400a528c54b25f4f1f609481e98e44222b3deaf7eee2c9e640e6345c73861": { - "input": { - "system": "You are a general-purpose AI agent called goose, created by Block, the parent company of Square, CashApp, and Tidal.\ngoose is being developed as an open-source software project.\n\ngoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o,\nclaude-sonnet-4, 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\nmonths 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\ntools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level\nproblems using the tools in these extensions, and can interact with multiple at once.\n\nIf the Extension Manager extension is enabled, you can use the search_available_extensions tool to discover additional\nextensions that can help with your task. To enable or disable extensions, use the manage_extensions tool with the\nextension_name. You should only enable extensions found from the search_available_extensions tool.\nIf Extension Manager is not available, you can only work with currently enabled extensions and cannot dynamically load\nnew ones.\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# 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\n 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\n 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.", - "messages": [ - { - "id": "msg_20251211_28_0", - "role": "user", - "created": 1765495269, - "content": [ - { - "type": "text", - "text": "tell me what the weather is in Berlin, Germany" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - } - ], - "tools": [ - { - "name": "dynamic_task__create_task", - "description": "Create tasks with instructions or prompt. For simple tasks, only include the instructions field. Extensions control: omit field = use all current extensions; empty array [] = no extensions; array with names = only those extensions. Specify extensions as shortnames (the prefixes for your tools). Specify return_last_only as true and have your subagent summarize its work in its last message to conserve your own context. Optional: title, description, extensions, settings, retry, response schema, activities. Arrays for multiple tasks.", - "inputSchema": { - "$defs": { - "TaskParameter": { - "description": "Parameters for a single task", - "properties": { - "activities": { - "items": { - "type": "string" - }, - "type": [ - "array", - "null" - ] - }, - "description": { - "type": [ - "string", - "null" - ] - }, - "extensions": { - "items": { - "additionalProperties": true, - "type": "object" - }, - "type": [ - "array", - "null" - ] - }, - "instructions": { - "type": [ - "string", - "null" - ] - }, - "parameters": { - "items": { - "additionalProperties": true, - "type": "object" - }, - "type": [ - "array", - "null" - ] - }, - "prompt": { - "type": [ - "string", - "null" - ] - }, - "response": { - "additionalProperties": true, - "type": [ - "object", - "null" - ] - }, - "retry": { - "additionalProperties": true, - "type": [ - "object", - "null" - ] - }, - "return_last_only": { - "description": "If true, return only the last message from the subagent (default: false, returns full conversation)", - "type": [ - "boolean", - "null" - ] - }, - "settings": { - "additionalProperties": true, - "type": [ - "object", - "null" - ] - }, - "title": { - "type": [ - "string", - "null" - ] - } - }, - "type": "object" - } - }, - "$schema": "https://json-schema.org/draft/2020-12/schema", - "properties": { - "execution_mode": { - "description": "How to execute multiple tasks (default: parallel for multiple tasks, sequential for single task)", - "type": [ - "string", - "null" - ] - }, - "task_parameters": { - "description": "Array of tasks. Each task must have either 'instructions' OR 'prompt' field (at least one is required).", - "items": { - "$ref": "#/$defs/TaskParameter" - }, - "minItems": 1, - "type": "array" - } - }, - "required": [ - "task_parameters" - ], - "title": "CreateDynamicTaskParams", - "type": "object" - }, - "annotations": { - "title": "Create Dynamic Tasks", - "readOnlyHint": false, - "destructiveHint": false, - "idempotentHint": false, - "openWorldHint": true - } - }, - { - "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" - }, - "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": "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 - } - }, - { - "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" - } - } - ] - }, - "output": { - "message": { - "id": null, - "role": "assistant", - "created": 1765495270, - "content": [ - { - "type": "toolRequest", - "id": "call_JJok3ApyTL54ohjLX8tTYVHC", - "toolCall": { - "status": "success", - "value": { - "name": "weather_extension__get_weather", - "arguments": { - "location": "Berlin, Germany" - } - } - } - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - "usage": { - "model": "gpt-4o-mini-2024-07-18", - "usage": { - "input_tokens": 1492, - "output_tokens": 20, - "total_tokens": 1512 - } - } - } - }, - "e020c157caa13bad743162d7079a04ddafca2d075469124a0162c5562a2cf21b": { - "input": { - "system": "You are a general-purpose AI agent called goose, created by Block, the parent company of Square, CashApp, and Tidal.\ngoose is being developed as an open-source software project.\n\ngoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o,\nclaude-sonnet-4, 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\nmonths 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\ntools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level\nproblems using the tools in these extensions, and can interact with multiple at once.\n\nIf the Extension Manager extension is enabled, you can use the search_available_extensions tool to discover additional\nextensions that can help with your task. To enable or disable extensions, use the manage_extensions tool with the\nextension_name. You should only enable extensions found from the search_available_extensions tool.\nIf Extension Manager is not available, you can only work with currently enabled extensions and cannot dynamically load\nnew ones.\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# 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\n 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\n 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.", - "messages": [ - { - "id": "msg_20251211_28_0", - "role": "user", - "created": 1765495269, - "content": [ - { - "type": "text", - "text": "tell me what the weather is in Berlin, Germany" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - { - "id": "msg_1d08355f-6d2d-413e-a3b5-787d635f9c6e", - "role": "assistant", - "created": 1765495270, - "content": [ - { - "type": "toolRequest", - "id": "call_JJok3ApyTL54ohjLX8tTYVHC", - "toolCall": { - "status": "success", - "value": { - "name": "weather_extension__get_weather", - "arguments": { - "location": "Berlin, Germany" - } - } - } - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - { - "id": "msg_929b0769-72dd-46f8-9027-31d1c09d4f08", - "role": "user", - "created": 1765495270, - "content": [ - { - "type": "toolResponse", - "id": "call_JJok3ApyTL54ohjLX8tTYVHC", - "toolResult": { - "status": "success", - "value": { - "content": [ - { - "type": "text", - "text": "The weather in Berlin, Germany is cloudy and 18°C" - } - ] - } - } - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - } - ], - "tools": [ - { - "name": "dynamic_task__create_task", - "description": "Create tasks with instructions or prompt. For simple tasks, only include the instructions field. Extensions control: omit field = use all current extensions; empty array [] = no extensions; array with names = only those extensions. Specify extensions as shortnames (the prefixes for your tools). Specify return_last_only as true and have your subagent summarize its work in its last message to conserve your own context. Optional: title, description, extensions, settings, retry, response schema, activities. Arrays for multiple tasks.", - "inputSchema": { - "$defs": { - "TaskParameter": { - "description": "Parameters for a single task", - "properties": { - "activities": { - "items": { - "type": "string" - }, - "type": [ - "array", - "null" - ] - }, - "description": { - "type": [ - "string", - "null" - ] - }, - "extensions": { - "items": { - "additionalProperties": true, - "type": "object" - }, - "type": [ - "array", - "null" - ] - }, - "instructions": { - "type": [ - "string", - "null" - ] - }, - "parameters": { - "items": { - "additionalProperties": true, - "type": "object" - }, - "type": [ - "array", - "null" - ] - }, - "prompt": { - "type": [ - "string", - "null" - ] - }, - "response": { - "additionalProperties": true, - "type": [ - "object", - "null" - ] - }, - "retry": { - "additionalProperties": true, - "type": [ - "object", - "null" - ] - }, - "return_last_only": { - "description": "If true, return only the last message from the subagent (default: false, returns full conversation)", - "type": [ - "boolean", - "null" - ] - }, - "settings": { - "additionalProperties": true, - "type": [ - "object", - "null" - ] - }, - "title": { - "type": [ - "string", - "null" - ] - } - }, - "type": "object" - } - }, - "$schema": "https://json-schema.org/draft/2020-12/schema", - "properties": { - "execution_mode": { - "description": "How to execute multiple tasks (default: parallel for multiple tasks, sequential for single task)", - "type": [ - "string", - "null" - ] - }, - "task_parameters": { - "description": "Array of tasks. Each task must have either 'instructions' OR 'prompt' field (at least one is required).", - "items": { - "$ref": "#/$defs/TaskParameter" - }, - "minItems": 1, - "type": "array" - } - }, - "required": [ - "task_parameters" - ], - "title": "CreateDynamicTaskParams", - "type": "object" - }, - "annotations": { - "title": "Create Dynamic Tasks", - "readOnlyHint": false, - "destructiveHint": false, - "idempotentHint": false, - "openWorldHint": true - } - }, - { - "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" - }, - "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": "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 - } - }, - { - "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" - } - } - ] - }, - "output": { - "message": { - "id": null, - "role": "assistant", - "created": 1765495271, - "content": [ - { - "type": "text", - "text": "### Current Weather in Berlin, Germany\n\n- **Condition:** Cloudy\n- **Temperature:** 18°C\n\nIf you need more information or a forecast, let me know!" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - "usage": { - "model": "gpt-4o-mini-2024-07-18", - "usage": { - "input_tokens": 1534, - "output_tokens": 38, - "total_tokens": 1572 - } - } - } - } -} \ 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 deleted file mode 100644 index 77256c16d..000000000 --- a/crates/goose-cli/src/scenario_tests/recordings/azure_openai/what_is_your_name.json +++ /dev/null @@ -1,302 +0,0 @@ -{ - "1b998117eba523901ae6a4dbf8caa81a95ea88ef7a84d0434c9b41a26164a2b9": { - "input": { - "system": "You are a general-purpose AI agent called goose, created by Block, the parent company of Square, CashApp, and Tidal.\ngoose is being developed as an open-source software project.\n\nThe current date is 2025-10-15 21:57:47.\n\ngoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o,\nclaude-sonnet-4, 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\nmonths 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\ntools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level\nproblems 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\nextensions, use the enable_extension tool and provide the extension_name. You should only enable extensions found from\nthe 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\n## weather_extension\n\n\n\n\n\n\n\n\n\n# Suggestion\n\n\"\"\n\n\n\n\n# sub agents\n\nExecute self contained tasks where step-by-step visibility is not important through subagents.\n\n- Delegate via `dynamic_task__create_task` for: result-only operations, parallelizable work, multi-part requests,\n verification, exploration\n- Parallel subagents for multiple operations, single subagents for independent work\n- Explore solutions in parallel — launch parallel subagents with different approaches (if non-interfering)\n- Provide all needed context — subagents cannot see your context\n- Use extension filters to limit resource access\n- Use return_last_only when only a summary or simple answer is required — inform subagent of this choice.\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\n 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\n 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": 1760565467, - "content": [ - { - "type": "text", - "text": "what is your name" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - } - ], - "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": "Create tasks with instructions or prompt. For simple tasks, only include the instructions field. Extensions control: omit field = use all current extensions; empty array [] = no extensions; array with names = only those extensions. Specify extensions as shortnames (the prefixes for your tools). Specify return_last_only as true and have your subagent summarize its work in its last message to conserve your own context. Optional: title, description, extensions, settings, retry, response schema, context, activities. Arrays for multiple tasks.", - "inputSchema": { - "properties": { - "execution_mode": { - "description": "How to execute multiple tasks (default: parallel for multiple tasks, sequential for single task)", - "enum": [ - "sequential", - "parallel" - ], - "type": "string" - }, - "task_parameters": { - "description": "Array of tasks. Each task must have either 'instructions' OR 'prompt' field (at least one is required).", - "items": { - "properties": { - "activities": { - "items": { - "type": "string" - }, - "type": "array" - }, - "context": { - "items": { - "type": "string" - }, - "type": "array" - }, - "description": { - "type": "string" - }, - "extensions": { - "items": { - "type": "object" - }, - "type": "array" - }, - "instructions": { - "description": "Task instructions (required if prompt is not provided)", - "type": "string" - }, - "parameters": { - "items": { - "type": "object" - }, - "type": "array" - }, - "prompt": { - "description": "Initial prompt (required if instructions is not provided)", - "type": "string" - }, - "response": { - "type": "object" - }, - "retry": { - "type": "object" - }, - "return_last_only": { - "description": "If true, return only the last message from the subagent (default: false, returns full conversation)", - "type": "boolean" - }, - "settings": { - "type": "object" - }, - "title": { - "type": "string" - } - }, - "type": "object" - }, - "minItems": 1, - "type": "array" - } - }, - "required": [ - "task_parameters" - ], - "type": "object" - }, - "annotations": { - "title": "Create Dynamic Tasks", - "readOnlyHint": false, - "destructiveHint": false, - "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": 1760565468, - "content": [ - { - "type": "text", - "text": "My name is Goose. I'm an AI agent created by Block, the parent company of Square, CashApp, and Tidal. How can I assist you today?" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - "usage": { - "model": "gpt-4o-mini-2024-07-18", - "usage": { - "input_tokens": 1702, - "output_tokens": 35, - "total_tokens": 1737 - } - } - } - } -} \ 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 deleted file mode 100644 index fea4fe308..000000000 --- a/crates/goose-cli/src/scenario_tests/recordings/google/what_is_your_name.json +++ /dev/null @@ -1,302 +0,0 @@ -{ - "1b998117eba523901ae6a4dbf8caa81a95ea88ef7a84d0434c9b41a26164a2b9": { - "input": { - "system": "You are a general-purpose AI agent called goose, created by Block, the parent company of Square, CashApp, and Tidal.\ngoose is being developed as an open-source software project.\n\nThe current date is 2025-10-15 21:57:49.\n\ngoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o,\nclaude-sonnet-4, 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\nmonths 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\ntools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level\nproblems 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\nextensions, use the enable_extension tool and provide the extension_name. You should only enable extensions found from\nthe 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\n## weather_extension\n\n\n\n\n\n\n\n\n\n# Suggestion\n\n\"\"\n\n\n\n\n# sub agents\n\nExecute self contained tasks where step-by-step visibility is not important through subagents.\n\n- Delegate via `dynamic_task__create_task` for: result-only operations, parallelizable work, multi-part requests,\n verification, exploration\n- Parallel subagents for multiple operations, single subagents for independent work\n- Explore solutions in parallel — launch parallel subagents with different approaches (if non-interfering)\n- Provide all needed context — subagents cannot see your context\n- Use extension filters to limit resource access\n- Use return_last_only when only a summary or simple answer is required — inform subagent of this choice.\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\n 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\n 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": 1760565469, - "content": [ - { - "type": "text", - "text": "what is your name" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - } - ], - "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": "Create tasks with instructions or prompt. For simple tasks, only include the instructions field. Extensions control: omit field = use all current extensions; empty array [] = no extensions; array with names = only those extensions. Specify extensions as shortnames (the prefixes for your tools). Specify return_last_only as true and have your subagent summarize its work in its last message to conserve your own context. Optional: title, description, extensions, settings, retry, response schema, context, activities. Arrays for multiple tasks.", - "inputSchema": { - "properties": { - "execution_mode": { - "description": "How to execute multiple tasks (default: parallel for multiple tasks, sequential for single task)", - "enum": [ - "sequential", - "parallel" - ], - "type": "string" - }, - "task_parameters": { - "description": "Array of tasks. Each task must have either 'instructions' OR 'prompt' field (at least one is required).", - "items": { - "properties": { - "activities": { - "items": { - "type": "string" - }, - "type": "array" - }, - "context": { - "items": { - "type": "string" - }, - "type": "array" - }, - "description": { - "type": "string" - }, - "extensions": { - "items": { - "type": "object" - }, - "type": "array" - }, - "instructions": { - "description": "Task instructions (required if prompt is not provided)", - "type": "string" - }, - "parameters": { - "items": { - "type": "object" - }, - "type": "array" - }, - "prompt": { - "description": "Initial prompt (required if instructions is not provided)", - "type": "string" - }, - "response": { - "type": "object" - }, - "retry": { - "type": "object" - }, - "return_last_only": { - "description": "If true, return only the last message from the subagent (default: false, returns full conversation)", - "type": "boolean" - }, - "settings": { - "type": "object" - }, - "title": { - "type": "string" - } - }, - "type": "object" - }, - "minItems": 1, - "type": "array" - } - }, - "required": [ - "task_parameters" - ], - "type": "object" - }, - "annotations": { - "title": "Create Dynamic Tasks", - "readOnlyHint": false, - "destructiveHint": false, - "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": 1760565470, - "content": [ - { - "type": "text", - "text": "My name is Goose." - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - "usage": { - "model": "gemini-2.5-flash", - "usage": { - "input_tokens": 2140, - "output_tokens": 5, - "total_tokens": 2145 - } - } - } - } -} \ 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 deleted file mode 100644 index d32272fda..000000000 --- a/crates/goose-cli/src/scenario_tests/recordings/groq/weather_tool.json +++ /dev/null @@ -1,669 +0,0 @@ -{ - "075d1e65f3a25bbdfc21aee19a1119b43fd4241f8643e646c9eb928a431975d4": { - "input": { - "system": "You are a general-purpose AI agent called goose, created by Block, the parent company of Square, CashApp, and Tidal.\ngoose is being developed as an open-source software project.\n\ngoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o,\nclaude-sonnet-4, 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\nmonths 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\ntools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level\nproblems using the tools in these extensions, and can interact with multiple at once.\n\nIf the Extension Manager extension is enabled, you can use the search_available_extensions tool to discover additional\nextensions that can help with your task. To enable or disable extensions, use the manage_extensions tool with the\nextension_name. You should only enable extensions found from the search_available_extensions tool.\nIf Extension Manager is not available, you can only work with currently enabled extensions and cannot dynamically load\nnew ones.\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# 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\n 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\n 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.", - "messages": [ - { - "id": "msg_20251211_40_0", - "role": "user", - "created": 1765495334, - "content": [ - { - "type": "text", - "text": "tell me what the weather is in Berlin, Germany" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - { - "id": "msg_6147fd68-5a38-4528-9924-d4dbaf5e7f44", - "role": "assistant", - "created": 1765495335, - "content": [ - { - "type": "toolRequest", - "id": "zemx6n94z", - "toolCall": { - "status": "success", - "value": { - "name": "weather_extension__get_weather", - "arguments": { - "location": "Berlin, Germany" - } - } - } - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - { - "id": "msg_0fac763c-62c3-4a33-a15b-27d605c5b81d", - "role": "user", - "created": 1765495335, - "content": [ - { - "type": "toolResponse", - "id": "zemx6n94z", - "toolResult": { - "status": "success", - "value": { - "content": [ - { - "type": "text", - "text": "The weather in Berlin, Germany is cloudy and 18°C" - } - ] - } - } - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - } - ], - "tools": [ - { - "name": "dynamic_task__create_task", - "description": "Create tasks with instructions or prompt. For simple tasks, only include the instructions field. Extensions control: omit field = use all current extensions; empty array [] = no extensions; array with names = only those extensions. Specify extensions as shortnames (the prefixes for your tools). Specify return_last_only as true and have your subagent summarize its work in its last message to conserve your own context. Optional: title, description, extensions, settings, retry, response schema, activities. Arrays for multiple tasks.", - "inputSchema": { - "$defs": { - "TaskParameter": { - "description": "Parameters for a single task", - "properties": { - "activities": { - "items": { - "type": "string" - }, - "type": [ - "array", - "null" - ] - }, - "description": { - "type": [ - "string", - "null" - ] - }, - "extensions": { - "items": { - "additionalProperties": true, - "type": "object" - }, - "type": [ - "array", - "null" - ] - }, - "instructions": { - "type": [ - "string", - "null" - ] - }, - "parameters": { - "items": { - "additionalProperties": true, - "type": "object" - }, - "type": [ - "array", - "null" - ] - }, - "prompt": { - "type": [ - "string", - "null" - ] - }, - "response": { - "additionalProperties": true, - "type": [ - "object", - "null" - ] - }, - "retry": { - "additionalProperties": true, - "type": [ - "object", - "null" - ] - }, - "return_last_only": { - "description": "If true, return only the last message from the subagent (default: false, returns full conversation)", - "type": [ - "boolean", - "null" - ] - }, - "settings": { - "additionalProperties": true, - "type": [ - "object", - "null" - ] - }, - "title": { - "type": [ - "string", - "null" - ] - } - }, - "type": "object" - } - }, - "$schema": "https://json-schema.org/draft/2020-12/schema", - "properties": { - "execution_mode": { - "description": "How to execute multiple tasks (default: parallel for multiple tasks, sequential for single task)", - "type": [ - "string", - "null" - ] - }, - "task_parameters": { - "description": "Array of tasks. Each task must have either 'instructions' OR 'prompt' field (at least one is required).", - "items": { - "$ref": "#/$defs/TaskParameter" - }, - "minItems": 1, - "type": "array" - } - }, - "required": [ - "task_parameters" - ], - "title": "CreateDynamicTaskParams", - "type": "object" - }, - "annotations": { - "title": "Create Dynamic Tasks", - "readOnlyHint": false, - "destructiveHint": false, - "idempotentHint": false, - "openWorldHint": true - } - }, - { - "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" - }, - "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": "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 - } - }, - { - "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" - } - } - ] - }, - "output": { - "message": { - "id": null, - "role": "assistant", - "created": 1765495335, - "content": [ - { - "type": "text", - "text": "The current weather in Berlin, Germany is cloudy with a temperature of 18°C." - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - "usage": { - "model": "llama-3.3-70b-versatile", - "usage": { - "input_tokens": 2299, - "output_tokens": 18, - "total_tokens": 2317 - } - } - } - }, - "8b1b8633232ca390cb3ff37a48daf74168b58f13e2943efcb17957129ee34d1a": { - "input": { - "system": "Reply with only a description in four words or less", - "messages": [ - { - "id": null, - "role": "user", - "created": 1765495334, - "content": [ - { - "type": "text", - "text": "Here are the first few user messages:\ntell me what the weather is in Berlin, Germany\n\nBased on the conversation so far, provide a concise description of this session in 4 words or less. This will be used for finding the session later in a UI with limited space - reply *ONLY* with the description" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - } - ], - "tools": [] - }, - "output": { - "message": { - "id": null, - "role": "assistant", - "created": 1765495334, - "content": [ - { - "type": "text", - "text": "Berlin weather" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - "usage": { - "model": "llama-3.3-70b-versatile", - "usage": { - "input_tokens": 108, - "output_tokens": 3, - "total_tokens": 111 - } - } - } - }, - "1bc400a528c54b25f4f1f609481e98e44222b3deaf7eee2c9e640e6345c73861": { - "input": { - "system": "You are a general-purpose AI agent called goose, created by Block, the parent company of Square, CashApp, and Tidal.\ngoose is being developed as an open-source software project.\n\ngoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o,\nclaude-sonnet-4, 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\nmonths 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\ntools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level\nproblems using the tools in these extensions, and can interact with multiple at once.\n\nIf the Extension Manager extension is enabled, you can use the search_available_extensions tool to discover additional\nextensions that can help with your task. To enable or disable extensions, use the manage_extensions tool with the\nextension_name. You should only enable extensions found from the search_available_extensions tool.\nIf Extension Manager is not available, you can only work with currently enabled extensions and cannot dynamically load\nnew ones.\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# 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\n 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\n 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.", - "messages": [ - { - "id": "msg_20251211_40_0", - "role": "user", - "created": 1765495334, - "content": [ - { - "type": "text", - "text": "tell me what the weather is in Berlin, Germany" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - } - ], - "tools": [ - { - "name": "dynamic_task__create_task", - "description": "Create tasks with instructions or prompt. For simple tasks, only include the instructions field. Extensions control: omit field = use all current extensions; empty array [] = no extensions; array with names = only those extensions. Specify extensions as shortnames (the prefixes for your tools). Specify return_last_only as true and have your subagent summarize its work in its last message to conserve your own context. Optional: title, description, extensions, settings, retry, response schema, activities. Arrays for multiple tasks.", - "inputSchema": { - "$defs": { - "TaskParameter": { - "description": "Parameters for a single task", - "properties": { - "activities": { - "items": { - "type": "string" - }, - "type": [ - "array", - "null" - ] - }, - "description": { - "type": [ - "string", - "null" - ] - }, - "extensions": { - "items": { - "additionalProperties": true, - "type": "object" - }, - "type": [ - "array", - "null" - ] - }, - "instructions": { - "type": [ - "string", - "null" - ] - }, - "parameters": { - "items": { - "additionalProperties": true, - "type": "object" - }, - "type": [ - "array", - "null" - ] - }, - "prompt": { - "type": [ - "string", - "null" - ] - }, - "response": { - "additionalProperties": true, - "type": [ - "object", - "null" - ] - }, - "retry": { - "additionalProperties": true, - "type": [ - "object", - "null" - ] - }, - "return_last_only": { - "description": "If true, return only the last message from the subagent (default: false, returns full conversation)", - "type": [ - "boolean", - "null" - ] - }, - "settings": { - "additionalProperties": true, - "type": [ - "object", - "null" - ] - }, - "title": { - "type": [ - "string", - "null" - ] - } - }, - "type": "object" - } - }, - "$schema": "https://json-schema.org/draft/2020-12/schema", - "properties": { - "execution_mode": { - "description": "How to execute multiple tasks (default: parallel for multiple tasks, sequential for single task)", - "type": [ - "string", - "null" - ] - }, - "task_parameters": { - "description": "Array of tasks. Each task must have either 'instructions' OR 'prompt' field (at least one is required).", - "items": { - "$ref": "#/$defs/TaskParameter" - }, - "minItems": 1, - "type": "array" - } - }, - "required": [ - "task_parameters" - ], - "title": "CreateDynamicTaskParams", - "type": "object" - }, - "annotations": { - "title": "Create Dynamic Tasks", - "readOnlyHint": false, - "destructiveHint": false, - "idempotentHint": false, - "openWorldHint": true - } - }, - { - "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" - }, - "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": "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 - } - }, - { - "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" - } - } - ] - }, - "output": { - "message": { - "id": null, - "role": "assistant", - "created": 1765495335, - "content": [ - { - "type": "toolRequest", - "id": "zemx6n94z", - "toolCall": { - "status": "success", - "value": { - "name": "weather_extension__get_weather", - "arguments": { - "location": "Berlin, Germany" - } - } - } - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - "usage": { - "model": "llama-3.3-70b-versatile", - "usage": { - "input_tokens": 2258, - "output_tokens": 20, - "total_tokens": 2278 - } - } - } - } -} \ 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 deleted file mode 100644 index 28cabb791..000000000 --- a/crates/goose-cli/src/scenario_tests/recordings/groq/what_is_your_name.json +++ /dev/null @@ -1,302 +0,0 @@ -{ - "1b998117eba523901ae6a4dbf8caa81a95ea88ef7a84d0434c9b41a26164a2b9": { - "input": { - "system": "You are a general-purpose AI agent called goose, created by Block, the parent company of Square, CashApp, and Tidal.\ngoose is being developed as an open-source software project.\n\nThe current date is 2025-10-15 21:57:50.\n\ngoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o,\nclaude-sonnet-4, 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\nmonths 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\ntools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level\nproblems 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\nextensions, use the enable_extension tool and provide the extension_name. You should only enable extensions found from\nthe 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\n## weather_extension\n\n\n\n\n\n\n\n\n\n# Suggestion\n\n\"\"\n\n\n\n\n# sub agents\n\nExecute self contained tasks where step-by-step visibility is not important through subagents.\n\n- Delegate via `dynamic_task__create_task` for: result-only operations, parallelizable work, multi-part requests,\n verification, exploration\n- Parallel subagents for multiple operations, single subagents for independent work\n- Explore solutions in parallel — launch parallel subagents with different approaches (if non-interfering)\n- Provide all needed context — subagents cannot see your context\n- Use extension filters to limit resource access\n- Use return_last_only when only a summary or simple answer is required — inform subagent of this choice.\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\n 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\n 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": 1760565470, - "content": [ - { - "type": "text", - "text": "what is your name" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - } - ], - "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": "Create tasks with instructions or prompt. For simple tasks, only include the instructions field. Extensions control: omit field = use all current extensions; empty array [] = no extensions; array with names = only those extensions. Specify extensions as shortnames (the prefixes for your tools). Specify return_last_only as true and have your subagent summarize its work in its last message to conserve your own context. Optional: title, description, extensions, settings, retry, response schema, context, activities. Arrays for multiple tasks.", - "inputSchema": { - "properties": { - "execution_mode": { - "description": "How to execute multiple tasks (default: parallel for multiple tasks, sequential for single task)", - "enum": [ - "sequential", - "parallel" - ], - "type": "string" - }, - "task_parameters": { - "description": "Array of tasks. Each task must have either 'instructions' OR 'prompt' field (at least one is required).", - "items": { - "properties": { - "activities": { - "items": { - "type": "string" - }, - "type": "array" - }, - "context": { - "items": { - "type": "string" - }, - "type": "array" - }, - "description": { - "type": "string" - }, - "extensions": { - "items": { - "type": "object" - }, - "type": "array" - }, - "instructions": { - "description": "Task instructions (required if prompt is not provided)", - "type": "string" - }, - "parameters": { - "items": { - "type": "object" - }, - "type": "array" - }, - "prompt": { - "description": "Initial prompt (required if instructions is not provided)", - "type": "string" - }, - "response": { - "type": "object" - }, - "retry": { - "type": "object" - }, - "return_last_only": { - "description": "If true, return only the last message from the subagent (default: false, returns full conversation)", - "type": "boolean" - }, - "settings": { - "type": "object" - }, - "title": { - "type": "string" - } - }, - "type": "object" - }, - "minItems": 1, - "type": "array" - } - }, - "required": [ - "task_parameters" - ], - "type": "object" - }, - "annotations": { - "title": "Create Dynamic Tasks", - "readOnlyHint": false, - "destructiveHint": false, - "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": 1760565471, - "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." - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - "usage": { - "model": "llama-3.3-70b-versatile", - "usage": { - "input_tokens": 2692, - "output_tokens": 33, - "total_tokens": 2725 - } - } - } - } -} \ 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 deleted file mode 100644 index 6223f7dc4..000000000 --- a/crates/goose-cli/src/scenario_tests/recordings/openai/image_analysis.json +++ /dev/null @@ -1,128 +0,0 @@ -{ - "c848f22f273e158c32435d3e72cc999c046dc1a9afdc3efda68ff451f833a185": { - "input": { - "system": "You are a general-purpose AI agent called goose, created by Block, the parent company of Square, CashApp, and Tidal.\ngoose is being developed as an open-source software project.\n\ngoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o,\nclaude-sonnet-4, 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\nmonths 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\ntools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level\nproblems using the tools in these extensions, and can interact with multiple at once.\n\nIf the Extension Manager extension is enabled, you can use the search_available_extensions tool to discover additional\nextensions that can help with your task. To enable or disable extensions, use the manage_extensions tool with the\nextension_name. You should only enable extensions found from the search_available_extensions tool.\nIf Extension Manager is not available, you can only work with currently enabled extensions and cannot dynamically load\nnew ones.\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# 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\n 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\n 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\n\n### Global Hints\nThese are my global goose hints.\nThese are my global goose hints.", - "messages": [ - { - "id": "msg_20260207_1_1a01be5d-1611-436d-a85b-0d56aee554e3", - "role": "user", - "created": 1770423951, - "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" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - } - ], - "tools": [ - { - "name": "subagent", - "description": "Delegate a task to a subagent that runs independently with its own context.\n\nModes:\n1. Ad-hoc: Provide `instructions` for a custom task\n2. Predefined: Provide `subrecipe` name to run a predefined task\n3. Augmented: Provide both `subrecipe` and `instructions` to add context\n\nThe subagent has access to the same tools as you by default. Use `extensions` to limit which extensions the subagent can use.\n\nFor parallel execution, make multiple `subagent` tool calls in the same message.", - "inputSchema": { - "type": "object", - "properties": { - "instructions": { - "type": "string", - "description": "Instructions for the subagent. Required for ad-hoc tasks. For predefined tasks, adds additional context." - }, - "subrecipe": { - "type": "string", - "description": "Name of a predefined subrecipe to run." - }, - "parameters": { - "type": "object", - "additionalProperties": true, - "description": "Parameters for the subrecipe. Only valid when 'subrecipe' is specified." - }, - "extensions": { - "type": "array", - "items": { - "type": "string" - }, - "description": "Extensions to enable. Omit to inherit all, empty array for none." - }, - "settings": { - "type": "object", - "properties": { - "provider": { - "type": "string", - "description": "Override LLM provider" - }, - "model": { - "type": "string", - "description": "Override model" - }, - "temperature": { - "type": "number", - "description": "Override temperature" - }, - "max_turns": { - "type": "number", - "description": "Override max turns" - } - }, - "description": "Override model/provider/settings." - }, - "summary": { - "type": "boolean", - "default": true, - "description": "If true (default), return only the subagent's final summary." - } - } - } - }, - { - "name": "weather_extension__get_weather", - "description": "Get the weather for a location", - "inputSchema": { - "type": "object", - "required": [ - "location" - ], - "properties": { - "location": { - "type": "string", - "description": "The city and state, e.g. San Francisco, CA" - } - } - } - } - ] - }, - "output": { - "message": { - "id": null, - "role": "assistant", - "created": 1770423954, - "content": [ - { - "type": "text", - "text": "This is a photo of a goose standing near water. If you have any questions or need more information, feel free to ask!" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - "usage": { - "model": "gpt-4o-2024-08-06", - "usage": { - "input_tokens": 1069, - "output_tokens": 27, - "total_tokens": 1096 - } - } - } - } -} \ 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 deleted file mode 100644 index ebd53b4d8..000000000 --- a/crates/goose-cli/src/scenario_tests/recordings/openai/weather_tool.json +++ /dev/null @@ -1,303 +0,0 @@ -{ - "24095cf8d18f13d750138a81eb3dc7d598d461b643a3b51d7aa8feb5ab598c46": { - "input": { - "system": "You are a general-purpose AI agent called goose, created by Block, the parent company of Square, CashApp, and Tidal.\ngoose is being developed as an open-source software project.\n\ngoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o,\nclaude-sonnet-4, 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\nmonths 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\ntools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level\nproblems using the tools in these extensions, and can interact with multiple at once.\n\nIf the Extension Manager extension is enabled, you can use the search_available_extensions tool to discover additional\nextensions that can help with your task. To enable or disable extensions, use the manage_extensions tool with the\nextension_name. You should only enable extensions found from the search_available_extensions tool.\nIf Extension Manager is not available, you can only work with currently enabled extensions and cannot dynamically load\nnew ones.\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# 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\n 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\n 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\n\n### Global Hints\nThese are my global goose hints.\nThese are my global goose hints.", - "messages": [ - { - "id": "msg_20260207_1_2bc5e542-e0c9-471c-a682-1a9476dd2856", - "role": "user", - "created": 1770423951, - "content": [ - { - "type": "text", - "text": "tell me what the weather is in Berlin, Germany" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - { - "id": "msg_097c7c4b-cd02-46b4-99e8-a6932032e66d", - "role": "assistant", - "created": 1770423953, - "content": [ - { - "type": "toolRequest", - "id": "call_NwyWutYuGQ8wujr6Ae3dO6tL", - "toolCall": { - "status": "success", - "value": { - "name": "weather_extension__get_weather", - "arguments": { - "location": "Berlin, Germany" - } - } - } - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - { - "id": "msg_5e059d80-a4e1-4d8c-ab35-f18d5f597437", - "role": "user", - "created": 1770423953, - "content": [ - { - "type": "toolResponse", - "id": "call_NwyWutYuGQ8wujr6Ae3dO6tL", - "toolResult": { - "status": "success", - "value": { - "content": [ - { - "type": "text", - "text": "The weather in Berlin, Germany is cloudy and 18°C" - } - ] - } - } - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - } - ], - "tools": [ - { - "name": "subagent", - "description": "Delegate a task to a subagent that runs independently with its own context.\n\nModes:\n1. Ad-hoc: Provide `instructions` for a custom task\n2. Predefined: Provide `subrecipe` name to run a predefined task\n3. Augmented: Provide both `subrecipe` and `instructions` to add context\n\nThe subagent has access to the same tools as you by default. Use `extensions` to limit which extensions the subagent can use.\n\nFor parallel execution, make multiple `subagent` tool calls in the same message.", - "inputSchema": { - "type": "object", - "properties": { - "instructions": { - "type": "string", - "description": "Instructions for the subagent. Required for ad-hoc tasks. For predefined tasks, adds additional context." - }, - "subrecipe": { - "type": "string", - "description": "Name of a predefined subrecipe to run." - }, - "parameters": { - "type": "object", - "additionalProperties": true, - "description": "Parameters for the subrecipe. Only valid when 'subrecipe' is specified." - }, - "extensions": { - "type": "array", - "items": { - "type": "string" - }, - "description": "Extensions to enable. Omit to inherit all, empty array for none." - }, - "settings": { - "type": "object", - "properties": { - "provider": { - "type": "string", - "description": "Override LLM provider" - }, - "model": { - "type": "string", - "description": "Override model" - }, - "temperature": { - "type": "number", - "description": "Override temperature" - }, - "max_turns": { - "type": "number", - "description": "Override max turns" - } - }, - "description": "Override model/provider/settings." - }, - "summary": { - "type": "boolean", - "default": true, - "description": "If true (default), return only the subagent's final summary." - } - } - } - }, - { - "name": "weather_extension__get_weather", - "description": "Get the weather for a location", - "inputSchema": { - "type": "object", - "required": [ - "location" - ], - "properties": { - "location": { - "type": "string", - "description": "The city and state, e.g. San Francisco, CA" - } - } - } - } - ] - }, - "output": { - "message": { - "id": null, - "role": "assistant", - "created": 1770423954, - "content": [ - { - "type": "text", - "text": "The current weather in Berlin, Germany is cloudy with a temperature of 18°C." - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - "usage": { - "model": "gpt-4o-2024-08-06", - "usage": { - "input_tokens": 866, - "output_tokens": 18, - "total_tokens": 884 - } - } - } - }, - "1bc400a528c54b25f4f1f609481e98e44222b3deaf7eee2c9e640e6345c73861": { - "input": { - "system": "You are a general-purpose AI agent called goose, created by Block, the parent company of Square, CashApp, and Tidal.\ngoose is being developed as an open-source software project.\n\ngoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o,\nclaude-sonnet-4, 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\nmonths 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\ntools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level\nproblems using the tools in these extensions, and can interact with multiple at once.\n\nIf the Extension Manager extension is enabled, you can use the search_available_extensions tool to discover additional\nextensions that can help with your task. To enable or disable extensions, use the manage_extensions tool with the\nextension_name. You should only enable extensions found from the search_available_extensions tool.\nIf Extension Manager is not available, you can only work with currently enabled extensions and cannot dynamically load\nnew ones.\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# 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\n 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\n 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\n\n### Global Hints\nThese are my global goose hints.\nThese are my global goose hints.", - "messages": [ - { - "id": "msg_20260207_1_2bc5e542-e0c9-471c-a682-1a9476dd2856", - "role": "user", - "created": 1770423951, - "content": [ - { - "type": "text", - "text": "tell me what the weather is in Berlin, Germany" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - } - ], - "tools": [ - { - "name": "subagent", - "description": "Delegate a task to a subagent that runs independently with its own context.\n\nModes:\n1. Ad-hoc: Provide `instructions` for a custom task\n2. Predefined: Provide `subrecipe` name to run a predefined task\n3. Augmented: Provide both `subrecipe` and `instructions` to add context\n\nThe subagent has access to the same tools as you by default. Use `extensions` to limit which extensions the subagent can use.\n\nFor parallel execution, make multiple `subagent` tool calls in the same message.", - "inputSchema": { - "type": "object", - "properties": { - "instructions": { - "type": "string", - "description": "Instructions for the subagent. Required for ad-hoc tasks. For predefined tasks, adds additional context." - }, - "subrecipe": { - "type": "string", - "description": "Name of a predefined subrecipe to run." - }, - "parameters": { - "type": "object", - "additionalProperties": true, - "description": "Parameters for the subrecipe. Only valid when 'subrecipe' is specified." - }, - "extensions": { - "type": "array", - "items": { - "type": "string" - }, - "description": "Extensions to enable. Omit to inherit all, empty array for none." - }, - "settings": { - "type": "object", - "properties": { - "provider": { - "type": "string", - "description": "Override LLM provider" - }, - "model": { - "type": "string", - "description": "Override model" - }, - "temperature": { - "type": "number", - "description": "Override temperature" - }, - "max_turns": { - "type": "number", - "description": "Override max turns" - } - }, - "description": "Override model/provider/settings." - }, - "summary": { - "type": "boolean", - "default": true, - "description": "If true (default), return only the subagent's final summary." - } - } - } - }, - { - "name": "weather_extension__get_weather", - "description": "Get the weather for a location", - "inputSchema": { - "type": "object", - "required": [ - "location" - ], - "properties": { - "location": { - "type": "string", - "description": "The city and state, e.g. San Francisco, CA" - } - } - } - } - ] - }, - "output": { - "message": { - "id": null, - "role": "assistant", - "created": 1770423953, - "content": [ - { - "type": "toolRequest", - "id": "call_NwyWutYuGQ8wujr6Ae3dO6tL", - "toolCall": { - "status": "success", - "value": { - "name": "weather_extension__get_weather", - "arguments": { - "location": "Berlin, Germany" - } - } - } - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - "usage": { - "model": "gpt-4o-2024-08-06", - "usage": { - "input_tokens": 824, - "output_tokens": 19, - "total_tokens": 843 - } - } - } - } -} \ 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 deleted file mode 100644 index ec2915b34..000000000 --- a/crates/goose-cli/src/scenario_tests/recordings/openai/what_is_your_name.json +++ /dev/null @@ -1,123 +0,0 @@ -{ - "1b998117eba523901ae6a4dbf8caa81a95ea88ef7a84d0434c9b41a26164a2b9": { - "input": { - "system": "You are a general-purpose AI agent called goose, created by Block, the parent company of Square, CashApp, and Tidal.\ngoose is being developed as an open-source software project.\n\ngoose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o,\nclaude-sonnet-4, 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\nmonths 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\ntools.\nYou are capable of dynamically plugging into new extensions and learning how to use them. You solve higher level\nproblems using the tools in these extensions, and can interact with multiple at once.\n\nIf the Extension Manager extension is enabled, you can use the search_available_extensions tool to discover additional\nextensions that can help with your task. To enable or disable extensions, use the manage_extensions tool with the\nextension_name. You should only enable extensions found from the search_available_extensions tool.\nIf Extension Manager is not available, you can only work with currently enabled extensions and cannot dynamically load\nnew ones.\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# 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\n 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\n 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\n\n### Global Hints\nThese are my global goose hints.\nThese are my global goose hints.", - "messages": [ - { - "id": "msg_20260207_1_084e0e53-1342-4e74-abad-41bac54e11b4", - "role": "user", - "created": 1770423951, - "content": [ - { - "type": "text", - "text": "what is your name" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - } - ], - "tools": [ - { - "name": "subagent", - "description": "Delegate a task to a subagent that runs independently with its own context.\n\nModes:\n1. Ad-hoc: Provide `instructions` for a custom task\n2. Predefined: Provide `subrecipe` name to run a predefined task\n3. Augmented: Provide both `subrecipe` and `instructions` to add context\n\nThe subagent has access to the same tools as you by default. Use `extensions` to limit which extensions the subagent can use.\n\nFor parallel execution, make multiple `subagent` tool calls in the same message.", - "inputSchema": { - "type": "object", - "properties": { - "instructions": { - "type": "string", - "description": "Instructions for the subagent. Required for ad-hoc tasks. For predefined tasks, adds additional context." - }, - "subrecipe": { - "type": "string", - "description": "Name of a predefined subrecipe to run." - }, - "parameters": { - "type": "object", - "additionalProperties": true, - "description": "Parameters for the subrecipe. Only valid when 'subrecipe' is specified." - }, - "extensions": { - "type": "array", - "items": { - "type": "string" - }, - "description": "Extensions to enable. Omit to inherit all, empty array for none." - }, - "settings": { - "type": "object", - "properties": { - "provider": { - "type": "string", - "description": "Override LLM provider" - }, - "model": { - "type": "string", - "description": "Override model" - }, - "temperature": { - "type": "number", - "description": "Override temperature" - }, - "max_turns": { - "type": "number", - "description": "Override max turns" - } - }, - "description": "Override model/provider/settings." - }, - "summary": { - "type": "boolean", - "default": true, - "description": "If true (default), return only the subagent's final summary." - } - } - } - }, - { - "name": "weather_extension__get_weather", - "description": "Get the weather for a location", - "inputSchema": { - "type": "object", - "required": [ - "location" - ], - "properties": { - "location": { - "type": "string", - "description": "The city and state, e.g. San Francisco, CA" - } - } - } - } - ] - }, - "output": { - "message": { - "id": null, - "role": "assistant", - "created": 1770423954, - "content": [ - { - "type": "text", - "text": "My name is goose, and I'm an AI agent created by Block. How can I assist you today?" - } - ], - "metadata": { - "userVisible": true, - "agentVisible": true - } - }, - "usage": { - "model": "gpt-4o-2024-08-06", - "usage": { - "input_tokens": 818, - "output_tokens": 22, - "total_tokens": 840 - } - } - } - } -} \ No newline at end of file diff --git a/crates/goose-cli/src/scenario_tests/scenario_runner.rs b/crates/goose-cli/src/scenario_tests/scenario_runner.rs deleted file mode 100644 index 365266add..000000000 --- a/crates/goose-cli/src/scenario_tests/scenario_runner.rs +++ /dev/null @@ -1,364 +0,0 @@ -use dotenvy::dotenv; -use goose::conversation::Conversation; - -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::CliSession; -use anyhow::Result; -use goose::agents::{Agent, AgentConfig, GoosePlatform}; -use goose::config::permission::PermissionManager; -use goose::config::GooseMode; -use goose::providers::{create, testprovider::TestProvider}; -use goose::session::session_manager::SessionType; -use goose::session::SessionManager; -use std::collections::{HashMap, HashSet}; -use std::path::{Path, PathBuf}; -use std::sync::Arc; -use tempfile::TempDir; -use tokio_util::sync::CancellationToken; - -pub const SCENARIO_TESTS_DIR: &str = "src/scenario_tests"; - -#[derive(Debug, Clone)] -pub struct ScenarioResult { - pub messages: Conversation, - 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 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, - message_generator: MessageGenerator<'_>, - providers_to_skip: Option<&[&str]>, - validator: F, -) -> Result<()> -where - F: Fn(&ScenarioResult) -> Result<()> + Send + Sync + 'static, -{ - 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, &message_generator, &validator) - .await?; - return Ok(()); - } - - let excluded_providers: HashSet<_> = providers_to_skip - .into_iter() - .flatten() - .map(|name| name.to_lowercase()) - .collect(); - - let all_configs = get_provider_configs(); - - 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")); - } - } - - let mut failures = Vec::new(); - - 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) => { - 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, - message_generator: &MessageGenerator<'_>, - validator: &F, -) -> Result<()> -where - F: Fn(&ScenarioResult) -> Result<()>, -{ - use goose::config::ExtensionConfig; - - goose::agents::moim::SKIP.with(|f| f.set(true)); - - if let Ok(path) = dotenv() { - println!("Loaded environment from {:?}", path); - } - - let factory_name = config.name.to_lowercase(); - let manifest_dir = env!("CARGO_MANIFEST_DIR"); - let file_path = format!( - "{}/{}/recordings/{}/{}.json", - manifest_dir, - SCENARIO_TESTS_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, Vec::new()).await?; - - let test_provider = Arc::new(TestProvider::new_recording(inner_provider, &file_path)); - ( - test_provider.clone(), - Some(test_provider), - Some(original_env), - ) - }; - - let messages = vec![message_generator(&*provider_arc)]; - - let mock_client = weather_client(); - - let temp_dir = TempDir::new()?; - let session_manager = Arc::new(SessionManager::new(temp_dir.path().to_path_buf())); - let permission_manager = Arc::new(PermissionManager::new(temp_dir.path().to_path_buf())); - let agent_config = AgentConfig::new( - session_manager, - permission_manager, - None, - GooseMode::Auto, - true, - GoosePlatform::GooseCli, - ); - let agent = Agent::with_config(agent_config); - let session = agent - .config - .session_manager - .create_session( - PathBuf::default(), - "scenario-runner".to_string(), - SessionType::Hidden, - GooseMode::default(), - ) - .await?; - agent - .extension_manager - .add_client( - ExtensionConfig::Builtin { - name: "weather_extension".to_string(), - display_name: None, - description: "".to_string(), - timeout: None, - bundled: None, - available_tools: vec![], - }, - Arc::new(mock_client), - None, - ) - .await; - - let scenario_model_config = - goose::model_config::model_config_from_user_config(&factory_name, config.model_name)?; - agent - .update_provider( - provider_arc as Arc, - scenario_model_config, - &session.id, - ) - .await?; - - let mut cli_session = CliSession::new( - Arc::new(agent), - session.id, - false, - None, - None, - None, - None, - "text".to_string(), - false, - false, - None, - ) - .await; - - let mut error = None; - for message in &messages { - if let Err(e) = cli_session - .process_message(message.clone(), CancellationToken::default(), false) - .await - { - error = Some(e.to_string()); - break; - } - } - let updated_messages = cli_session.message_history(); - - 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: updated_messages, - error, - }; - - validator(&result)?; - - drop(cli_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 deleted file mode 100644 index c52df9753..000000000 --- a/crates/goose-cli/src/scenario_tests/scenarios.rs +++ /dev/null @@ -1,98 +0,0 @@ -//! 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}; - 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", - 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", - text("tell me what the weather is in Berlin, Germany"), - Some(&["Google"]), - |result| { - assert!(result.error.is_none()); - - let last_message = result.last_message()?.to_lowercase(); - - 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 - } - - #[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 - } - - // #[tokio::test] - // async fn test_context_length_exceeded_error() -> Result<()> { - // run_scenario( - // "context_length_exceeded", - // Box::new(|provider| { - // let model_config = resolve_global_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| { - // assert_eq!(result.messages.len(), 2, "One message after compaction"); - // 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 deleted file mode 100644 index 5e929886b..000000000 Binary files a/crates/goose-cli/src/scenario_tests/test_data/test_image.jpg and /dev/null differ