From bb54396cc99290164f6f7f04562ad7d5522f06e1 Mon Sep 17 00:00:00 2001
From: Joao Moura <joaomdmoura@gmail.com>
Date: Sun, 1 Mar 2026 02:25:07 -0800
Subject: [PATCH 1/4] feat: implement native tool calling in LiteAgent

- Added support for native function calling in the LiteAgent class, allowing it to utilize LLM's built-in capabilities for structured tool calls.
- Introduced a new execution mode that determines whether to use native tools or fallback to the ReAct text pattern based on LLM capabilities.
- Updated system prompts to accommodate the new native tools functionality.
- Enhanced the agent's invocation loop to handle native tool calls effectively, improving overall performance and response accuracy.
---
 lib/crewai/src/crewai/lite_agent.py           |  535 ++-
 lib/crewai/src/crewai/translations/en.json    |    1 +
 lib/crewai/tests/agents/test_lite_agent.py    |  183 +
 ...gent_hooks_integration_with_real_tool.yaml | 2969 ++++++++++++++++-
 4 files changed, 3583 insertions(+), 105 deletions(-)

diff --git a/lib/crewai/src/crewai/lite_agent.py b/lib/crewai/src/crewai/lite_agent.py
index 66b7108901..1d932a8f3d 100644
--- a/lib/crewai/src/crewai/lite_agent.py
+++ b/lib/crewai/src/crewai/lite_agent.py
@@ -69,7 +69,9 @@
 from crewai.tools.base_tool import BaseTool
 from crewai.tools.structured_tool import CrewStructuredTool
 from crewai.utilities.agent_utils import (
+    convert_tools_to_openai_schema,
     enforce_rpm_limit,
+    extract_tool_call_info,
     format_message_for_llm,
     get_llm_response,
     get_tool_names,
@@ -80,6 +82,7 @@
     handle_unknown_error,
     has_reached_max_iterations,
     is_context_length_exceeded,
+    parse_tool_call_args,
     parse_tools,
     process_llm_response,
     render_text_description_and_args,
@@ -88,6 +91,7 @@
     Converter,
     ConverterError,
 )
+from crewai.utilities.string_utils import sanitize_tool_name
 from crewai.utilities.guardrail import process_guardrail
 from crewai.utilities.guardrail_types import GuardrailCallable, GuardrailType
 from crewai.utilities.i18n import I18N, get_i18n
@@ -274,6 +278,7 @@ class LiteAgent(FlowTrackable, BaseModel):
     _printer: Printer = PrivateAttr(default_factory=Printer)
     _guardrail: GuardrailCallable | None = PrivateAttr(default=None)
     _guardrail_retry_count: int = PrivateAttr(default=0)
+    _use_native_tools: bool = PrivateAttr(default=False)
     _callbacks: list[TokenCalcHandler] = PrivateAttr(default_factory=list)
     _before_llm_call_hooks: list[BeforeLLMCallHookType | BeforeLLMCallHookCallable] = (
         PrivateAttr(default_factory=get_before_llm_call_hooks)
@@ -517,6 +522,16 @@ def kickoff(
             self._iterations = 0
             self.tools_results = []
 
+            # Determine execution mode before building the system prompt so
+            # native mode gets a clean prompt without ReAct format instructions.
+            llm = cast(LLM, self.llm)
+            self._use_native_tools = bool(
+                hasattr(llm, "supports_function_calling")
+                and callable(getattr(llm, "supports_function_calling", None))
+                and llm.supports_function_calling()
+                and self._parsed_tools
+            )
+
             # Format messages for the LLM
             self._messages = self._format_messages(
                 messages, response_format=response_format, input_files=input_files
@@ -793,9 +808,18 @@ def _get_default_system_prompt(
             response_format: Optional response format to use instead of self.response_format
         """
         base_prompt = ""
-        if self._parsed_tools:
-            # Use the prompt template for agents with tools
-            base_prompt = self.i18n.slice("lite_agent_system_prompt_with_tools").format(
+        if self._parsed_tools and self._use_native_tools:
+            base_prompt = self.i18n.slice(
+                "lite_agent_system_prompt_native_tools"
+            ).format(
+                role=self.role,
+                backstory=self.backstory,
+                goal=self.goal,
+            )
+        elif self._parsed_tools:
+            base_prompt = self.i18n.slice(
+                "lite_agent_system_prompt_with_tools"
+            ).format(
                 role=self.role,
                 backstory=self.backstory,
                 goal=self.goal,
@@ -803,7 +827,6 @@ def _get_default_system_prompt(
                 tool_names=get_tool_names(self._parsed_tools),
             )
         else:
-            # Use the prompt template for agents without tools
             base_prompt = self.i18n.slice(
                 "lite_agent_system_prompt_without_tools"
             ).format(
@@ -860,8 +883,508 @@ def _format_messages(
     def _invoke_loop(
         self, response_model: type[BaseModel] | None = None
     ) -> AgentFinish:
+        """Run the agent's thought process until it reaches a conclusion or max iterations.
+
+        Checks if the LLM supports native function calling and uses that
+        approach if available, otherwise falls back to the ReAct text pattern.
+
+        Args:
+            response_model: Optional Pydantic model for native structured output.
+
+        Returns:
+            AgentFinish: The final result of the agent execution.
+        """
+        if self._use_native_tools:
+            return self._invoke_loop_native_tools(response_model=response_model)
+
+        return self._invoke_loop_react(response_model=response_model)
+
+    def _invoke_loop_native_tools(
+        self, response_model: type[BaseModel] | None = None
+    ) -> AgentFinish:
+        """Execute agent loop using native function calling.
+
+        Uses the LLM's native tool/function calling capability instead of the
+        text-based ReAct pattern. The LLM directly returns structured tool
+        calls which are executed and results fed back.
+
+        Args:
+            response_model: Optional Pydantic model for native structured output.
+
+        Returns:
+            AgentFinish: The final result of the agent execution.
+        """
+        openai_tools, available_functions = convert_tools_to_openai_schema(
+            self.tools
+        )
+
+        original_tools_by_name: dict[str, BaseTool] = {
+            sanitize_tool_name(t.name): t for t in self.tools
+        }
+
+        while True:
+            try:
+                if has_reached_max_iterations(self._iterations, self.max_iterations):
+                    formatted_answer = handle_max_iterations_exceeded(
+                        None,
+                        printer=self._printer,
+                        i18n=self.i18n,
+                        messages=self._messages,
+                        llm=cast(LLM, self.llm),
+                        callbacks=self._callbacks,
+                        verbose=self.verbose,
+                    )
+                    self._show_logs(formatted_answer)
+                    return formatted_answer
+
+                enforce_rpm_limit(self.request_within_rpm_limit)
+
+                answer = get_llm_response(
+                    llm=cast(LLM, self.llm),
+                    messages=self._messages,
+                    callbacks=self._callbacks,
+                    printer=self._printer,
+                    tools=openai_tools,
+                    available_functions=None,
+                    from_agent=self,
+                    executor_context=self,
+                    response_model=response_model,
+                    verbose=self.verbose,
+                )
+
+                if (
+                    isinstance(answer, list)
+                    and answer
+                    and self._is_tool_call_list(answer)
+                ):
+                    tool_finish = self._handle_native_tool_calls(
+                        answer, available_functions, original_tools_by_name
+                    )
+                    if tool_finish is not None:
+                        return tool_finish
+                    continue
+
+                if isinstance(answer, BaseModel):
+                    output_json = answer.model_dump_json()
+                    formatted_answer = AgentFinish(
+                        thought="", output=answer, text=output_json
+                    )
+                    self._append_message(output_json)
+                    self._show_logs(formatted_answer)
+                    return formatted_answer
+
+                answer_str = str(answer) if not isinstance(answer, str) else answer
+                formatted_answer = AgentFinish(
+                    thought="", output=answer_str, text=answer_str
+                )
+                self._append_message(answer_str)
+                self._show_logs(formatted_answer)
+                return formatted_answer
+
+            except Exception as e:
+                if e.__class__.__module__.startswith("litellm"):
+                    raise e
+                if is_context_length_exceeded(e):
+                    handle_context_length(
+                        respect_context_window=self.respect_context_window,
+                        printer=self._printer,
+                        messages=self._messages,
+                        llm=cast(LLM, self.llm),
+                        callbacks=self._callbacks,
+                        i18n=self.i18n,
+                        verbose=self.verbose,
+                    )
+                    continue
+                handle_unknown_error(self._printer, e, verbose=self.verbose)
+                raise e
+            finally:
+                self._iterations += 1
+
+    @staticmethod
+    def _is_tool_call_list(response: list[Any]) -> bool:
+        """Check if a response is a list of native tool calls.
+
+        Supports OpenAI, Anthropic, Bedrock, and Gemini formats.
+        """
+        if not response:
+            return False
+        first_item = response[0]
+        if hasattr(first_item, "function") or (
+            isinstance(first_item, dict) and "function" in first_item
+        ):
+            return True
+        if (
+            hasattr(first_item, "type")
+            and getattr(first_item, "type", None) == "tool_use"
+        ):
+            return True
+        if hasattr(first_item, "name") and hasattr(first_item, "input"):
+            return True
+        if (
+            isinstance(first_item, dict)
+            and "name" in first_item
+            and "input" in first_item
+        ):
+            return True
+        if hasattr(first_item, "function_call") and first_item.function_call:
+            return True
+        return False
+
+    def _handle_native_tool_calls(
+        self,
+        tool_calls: list[Any],
+        available_functions: dict[str, Callable[..., Any]],
+        original_tools_by_name: dict[str, BaseTool],
+    ) -> AgentFinish | None:
+        """Execute native tool calls and feed results back into message history.
+
+        Uses parallel execution via ``ThreadPoolExecutor`` when safe (no
+        ``result_as_answer`` or ``max_usage_count`` tools in the batch).
+        Falls back to sequential execution otherwise.
+
+        Args:
+            tool_calls: Tool call objects from the LLM response.
+            available_functions: Mapping of sanitized tool names to callables.
+            original_tools_by_name: Mapping of sanitized tool names to original
+                BaseTool instances.
+
+        Returns:
+            AgentFinish if a tool with result_as_answer=True was called,
+            None otherwise (loop continues).
+        """
+        from concurrent.futures import ThreadPoolExecutor, as_completed
+
+        parsed_calls = [
+            parsed
+            for tc in tool_calls
+            if (parsed := extract_tool_call_info(tc)) is not None
+        ]
+        if not parsed_calls:
+            return None
+
+        # Single assistant message with all tool calls (matches OpenAI API spec)
+        self._messages.append({
+            "role": "assistant",
+            "content": None,
+            "tool_calls": [
+                {
+                    "id": call_id,
+                    "type": "function",
+                    "function": {
+                        "name": func_name,
+                        "arguments": func_args
+                        if isinstance(func_args, str)
+                        else json.dumps(func_args),
+                    },
+                }
+                for call_id, func_name, func_args in parsed_calls
+            ],
+        })
+
+        # Determine if parallel execution is safe for this batch.
+        # Usage counters are not thread-safe, and result_as_answer requires
+        # immediate return, so both force sequential execution.
+        can_parallelize = len(parsed_calls) > 1 and not any(
+            (
+                original_tools_by_name.get(fn)
+                and (
+                    getattr(original_tools_by_name.get(fn), "result_as_answer", False)
+                    or getattr(original_tools_by_name.get(fn), "max_usage_count", None)
+                    is not None
+                )
+            )
+            for _, fn, _ in parsed_calls
+        )
+
+        if can_parallelize:
+            execution_plan = [
+                (cid, fn, fa, original_tools_by_name.get(fn))
+                for cid, fn, fa in parsed_calls
+            ]
+            max_workers = min(8, len(execution_plan))
+            ordered_results: list[dict[str, Any] | None] = [None] * len(
+                execution_plan
+            )
+            with ThreadPoolExecutor(max_workers=max_workers) as pool:
+                futures = {
+                    pool.submit(
+                        self._execute_native_tool_call,
+                        call_id=cid,
+                        func_name=fn,
+                        func_args=fa,
+                        available_functions=available_functions,
+                        original_tool=ot,
+                    ): idx
+                    for idx, (cid, fn, fa, ot) in enumerate(execution_plan)
+                }
+                for future in as_completed(futures):
+                    ordered_results[futures[future]] = future.result()
+
+            for exec_result in ordered_results:
+                if exec_result is None:
+                    continue
+                self._messages.append({
+                    "role": "tool",
+                    "tool_call_id": exec_result["call_id"],
+                    "name": exec_result["func_name"],
+                    "content": exec_result["result"],
+                })
+                if self.verbose:
+                    cache_tag = " (from cache)" if exec_result["from_cache"] else ""
+                    self._printer.print(
+                        content=f"Tool {exec_result['func_name']} executed{cache_tag}: {exec_result['result'][:200]}",
+                        color="green",
+                    )
+                orig = original_tools_by_name.get(exec_result["func_name"])
+                if orig and getattr(orig, "result_as_answer", False):
+                    finished = AgentFinish(
+                        thought="", output=exec_result["result"], text=exec_result["result"]
+                    )
+                    self._show_logs(finished)
+                    return finished
+        else:
+            # Sequential execution: process each call one at a time.
+            for call_id, func_name, func_args in parsed_calls:
+                exec_result = self._execute_native_tool_call(
+                    call_id=call_id,
+                    func_name=func_name,
+                    func_args=func_args,
+                    available_functions=available_functions,
+                    original_tool=original_tools_by_name.get(func_name),
+                )
+
+                self._messages.append({
+                    "role": "tool",
+                    "tool_call_id": exec_result["call_id"],
+                    "name": exec_result["func_name"],
+                    "content": exec_result["result"],
+                })
+                if self.verbose:
+                    cache_tag = " (from cache)" if exec_result["from_cache"] else ""
+                    self._printer.print(
+                        content=f"Tool {exec_result['func_name']} executed{cache_tag}: {exec_result['result'][:200]}",
+                        color="green",
+                    )
+
+                original_tool = original_tools_by_name.get(func_name)
+                if original_tool and getattr(original_tool, "result_as_answer", False):
+                    finished = AgentFinish(
+                        thought="", output=exec_result["result"], text=exec_result["result"]
+                    )
+                    self._show_logs(finished)
+                    return finished
+
+        reasoning_prompt = self.i18n.slice("post_tool_reasoning")
+        self._messages.append({"role": "user", "content": reasoning_prompt})
+        return None
+
+    def _execute_native_tool_call(
+        self,
+        *,
+        call_id: str,
+        func_name: str,
+        func_args: str | dict[str, Any],
+        available_functions: dict[str, Callable[..., Any]],
+        original_tool: BaseTool | None = None,
+    ) -> dict[str, Any]:
+        """Execute a single native tool call.
+
+        Handles argument parsing, usage-limit checks, caching, and hook
+        invocation.
+
+        Args:
+            call_id: The tool call ID from the LLM.
+            func_name: Sanitized tool function name.
+            func_args: Raw arguments (JSON string or dict).
+            available_functions: Mapping of tool names to callables.
+            original_tool: The original BaseTool instance, if available.
+
+        Returns:
+            Dict with keys ``call_id``, ``func_name``, ``result``,
+            ``from_cache``, and ``original_tool``.
         """
-        Run the agent's thought process until it reaches a conclusion or max iterations.
+        from datetime import datetime
+
+        from crewai.events.types.tool_usage_events import (
+            ToolUsageErrorEvent,
+            ToolUsageFinishedEvent,
+            ToolUsageStartedEvent,
+        )
+        from crewai.hooks.tool_hooks import (
+            ToolCallHookContext,
+            get_after_tool_call_hooks,
+            get_before_tool_call_hooks,
+        )
+
+        args_dict, parse_error = parse_tool_call_args(
+            func_args, func_name, call_id, original_tool
+        )
+        if parse_error is not None:
+            return {
+                "call_id": call_id,
+                "func_name": func_name,
+                "result": cast(str, parse_error["result"]),
+                "from_cache": False,
+                "original_tool": original_tool,
+            }
+
+        if (
+            original_tool
+            and getattr(original_tool, "max_usage_count", None) is not None
+            and getattr(original_tool, "current_usage_count", 0)
+            >= original_tool.max_usage_count
+        ):
+            return {
+                "call_id": call_id,
+                "func_name": func_name,
+                "result": (
+                    f"Tool '{func_name}' has reached its usage limit of "
+                    f"{original_tool.max_usage_count} times and cannot be used anymore."
+                ),
+                "from_cache": False,
+                "original_tool": original_tool,
+            }
+
+        from_cache = False
+        result: str = f"Tool '{func_name}' not found"
+        input_str = json.dumps(args_dict) if args_dict else ""
+
+        if self._cache_handler:
+            cached = self._cache_handler.read(tool=func_name, input=input_str)
+            if cached is not None:
+                result = str(cached) if not isinstance(cached, str) else cached
+                from_cache = True
+
+        started_at = datetime.now()
+        crewai_event_bus.emit(
+            self,
+            event=ToolUsageStartedEvent(
+                tool_name=func_name,
+                tool_args=args_dict,
+                from_agent=self,
+                agent_key=self.key,
+            ),
+        )
+
+        structured_tool: CrewStructuredTool | None = next(
+            (t for t in self._parsed_tools if sanitize_tool_name(t.name) == func_name),
+            None,
+        )
+
+        hook_blocked = False
+        before_ctx = ToolCallHookContext(
+            tool_name=func_name,
+            tool_input=args_dict,
+            tool=structured_tool,  # type: ignore[arg-type]
+            agent=self,
+            task=None,
+            crew=None,
+        )
+        try:
+            for hook in get_before_tool_call_hooks():
+                if hook(before_ctx) is False:
+                    hook_blocked = True
+                    break
+        except Exception as hook_err:
+            if self.verbose:
+                self._printer.print(
+                    content=f"Error in before_tool_call hook: {hook_err}",
+                    color="red",
+                )
+
+        error_event_emitted = False
+        if hook_blocked:
+            result = f"Tool execution blocked by hook. Tool: {func_name}"
+        elif not from_cache and func_name in available_functions:
+            try:
+                raw_result = available_functions[func_name](**(args_dict or {}))
+                result = str(raw_result) if not isinstance(raw_result, str) else raw_result
+
+                if self._cache_handler:
+                    should_cache = True
+                    if (
+                        original_tool
+                        and hasattr(original_tool, "cache_function")
+                        and callable(original_tool.cache_function)
+                    ):
+                        should_cache = original_tool.cache_function(args_dict, raw_result)
+                    if should_cache:
+                        self._cache_handler.add(
+                            tool=func_name, input=input_str, output=raw_result
+                        )
+            except Exception as e:
+                result = f"Error executing tool '{func_name}': {e}"
+                error_event_emitted = True
+                crewai_event_bus.emit(
+                    self,
+                    event=ToolUsageErrorEvent(
+                        tool_name=func_name,
+                        tool_args=args_dict,
+                        from_agent=self,
+                        agent_key=self.key,
+                        error=e,
+                    ),
+                )
+
+        after_ctx = ToolCallHookContext(
+            tool_name=func_name,
+            tool_input=args_dict,
+            tool=structured_tool,  # type: ignore[arg-type]
+            agent=self,
+            task=None,
+            crew=None,
+            tool_result=result,
+        )
+        try:
+            for after_hook in get_after_tool_call_hooks():
+                after_result = after_hook(after_ctx)
+                if after_result is not None:
+                    result = after_result
+                    after_ctx.tool_result = result
+        except Exception as hook_err:
+            if self.verbose:
+                self._printer.print(
+                    content=f"Error in after_tool_call hook: {hook_err}",
+                    color="red",
+                )
+
+        if original_tool:
+            original_tool.current_usage_count += 1
+
+        if not error_event_emitted:
+            crewai_event_bus.emit(
+                self,
+                event=ToolUsageFinishedEvent(
+                    output=result,
+                    tool_name=func_name,
+                    tool_args=args_dict,
+                    from_agent=self,
+                    agent_key=self.key,
+                    started_at=started_at,
+                    finished_at=datetime.now(),
+                ),
+            )
+
+        self.tools_results.append({
+            "result": result,
+            "tool_name": func_name,
+            "tool_args": args_dict,
+        })
+
+        return {
+            "call_id": call_id,
+            "func_name": func_name,
+            "result": result,
+            "from_cache": from_cache,
+            "original_tool": original_tool,
+        }
+
+    def _invoke_loop_react(
+        self, response_model: type[BaseModel] | None = None
+    ) -> AgentFinish:
+        """Execute agent loop using the ReAct text-based pattern.
+
+        This is the fallback when the LLM does not support native function calling.
 
         Args:
             response_model: Optional Pydantic model for native structured output.
@@ -869,7 +1392,6 @@ def _invoke_loop(
         Returns:
             AgentFinish: The final result of the agent execution.
         """
-        # Execute the agent loop
         formatted_answer: AgentAction | AgentFinish | None = None
         while not isinstance(formatted_answer, AgentFinish):
             try:
@@ -949,7 +1471,6 @@ def _invoke_loop(
 
             except Exception as e:
                 if e.__class__.__module__.startswith("litellm"):
-                    # Do not retry on litellm errors
                     raise e
                 if is_context_length_exceeded(e):
                     handle_context_length(
diff --git a/lib/crewai/src/crewai/translations/en.json b/lib/crewai/src/crewai/translations/en.json
index 1eb02c7462..732666e738 100644
--- a/lib/crewai/src/crewai/translations/en.json
+++ b/lib/crewai/src/crewai/translations/en.json
@@ -30,6 +30,7 @@
     "conversation_history_instruction": "You are a member of a crew collaborating to achieve a common goal. Your task is a specific action that contributes to this larger objective. For additional context, please review the conversation history between you and the user that led to the initiation of this crew. Use any relevant information or feedback from the conversation to inform your task execution and ensure your response aligns with both the immediate task and the crew's overall goals.",
     "feedback_instructions": "User feedback: {feedback}\nInstructions: Use this feedback to enhance the next output iteration.\nNote: Do not respond or add commentary.",
     "lite_agent_system_prompt_with_tools": "You are {role}. {backstory}\nYour personal goal is: {goal}\n\nYou ONLY have access to the following tools, and should NEVER make up tools that are not listed here:\n\n{tools}\n\nIMPORTANT: Use the following format in your response:\n\n```\nThought: you should always think about what to do\nAction: the action to take, only one name of [{tool_names}], just the name, exactly as it's written.\nAction Input: the input to the action, just a simple JSON object, enclosed in curly braces, using \" to wrap keys and values.\nObservation: the result of the action\n```\n\nOnce all necessary information is gathered, return the following format:\n\n```\nThought: I now know the final answer\nFinal Answer: the final answer to the original input question\n```",
+    "lite_agent_system_prompt_native_tools": "You are {role}. {backstory}\nYour personal goal is: {goal}",
     "lite_agent_system_prompt_without_tools": "You are {role}. {backstory}\nYour personal goal is: {goal}\n\nTo give my best complete final answer to the task respond using the exact following format:\n\nThought: I now can give a great answer\nFinal Answer: Your final answer must be the great and the most complete as possible, it must be outcome described.\n\nI MUST use these formats, my job depends on it!",
     "lite_agent_response_format": "Format your final answer according to the following OpenAPI schema: {response_format}\n\nIMPORTANT: Preserve the original content exactly as-is. Do NOT rewrite, paraphrase, or modify the meaning of the content. Only structure it to match the schema format.\n\nDo not include the OpenAPI schema in the final output. Ensure the final output does not include any code block markers like ```json or ```python.",
     "knowledge_search_query": "The original query is: {task_prompt}.",
diff --git a/lib/crewai/tests/agents/test_lite_agent.py b/lib/crewai/tests/agents/test_lite_agent.py
index ac03ffc28b..ae355b3383 100644
--- a/lib/crewai/tests/agents/test_lite_agent.py
+++ b/lib/crewai/tests/agents/test_lite_agent.py
@@ -1160,3 +1160,186 @@ def test_lite_agent_memory_instance_recall_and_save_called():
     mock_memory.remember_many.assert_called_once_with(
         ["Fact one.", "Fact two."], agent_role="Test"
     )
+
+
+# ---------------------------------------------------------------------------
+# Native tool calling tests
+# ---------------------------------------------------------------------------
+
+
+class _NativeToolCallLLM(BaseLLM):
+    """Fake LLM that supports native function calling and returns tool calls."""
+
+    def __init__(self, tool_calls=None, final_answer="42"):
+        super().__init__(model="fake-native-fc-model")
+        self._tool_calls = tool_calls or []
+        self._final_answer = final_answer
+        self._call_index = 0
+
+    def call(
+        self,
+        messages,
+        tools=None,
+        callbacks=None,
+        available_functions=None,
+        from_task=None,
+        from_agent=None,
+        response_model=None,
+    ):
+        idx = self._call_index
+        self._call_index += 1
+        if idx < len(self._tool_calls):
+            return self._tool_calls[idx]
+        return self._final_answer
+
+    def supports_function_calling(self) -> bool:
+        return True
+
+    def supports_stop_words(self) -> bool:
+        return False
+
+    def get_context_window_size(self) -> int:
+        return 8192
+
+
+class _ReactOnlyLLM(BaseLLM):
+    """Fake LLM that does NOT support function calling."""
+
+    def __init__(self, response="Thought: done\nFinal Answer: hello"):
+        super().__init__(model="fake-react-only-model")
+        self._response = response
+
+    def call(self, messages, **kwargs):
+        return self._response
+
+    def supports_function_calling(self) -> bool:
+        return False
+
+    def supports_stop_words(self) -> bool:
+        return True
+
+    def get_context_window_size(self) -> int:
+        return 8192
+
+
+def test_lite_agent_native_mode_detection_with_fc_llm():
+    """LiteAgent should set _use_native_tools=True when LLM supports function calling and tools exist."""
+    llm = _NativeToolCallLLM(final_answer="done")
+    agent = LiteAgent(
+        role="Tester", goal="Test", backstory="Test agent",
+        llm=llm, tools=[SecretLookupTool()],
+    )
+    agent.kickoff("test")
+    assert agent._use_native_tools is True
+
+
+def test_lite_agent_native_mode_detection_without_fc_llm():
+    """LiteAgent should set _use_native_tools=False when LLM does not support function calling."""
+    llm = _ReactOnlyLLM()
+    agent = LiteAgent(
+        role="Tester", goal="Test", backstory="Test agent",
+        llm=llm, tools=[SecretLookupTool()],
+    )
+    agent.kickoff("test")
+    assert agent._use_native_tools is False
+
+
+def test_lite_agent_native_mode_detection_no_tools():
+    """LiteAgent should set _use_native_tools=False when there are no tools."""
+    llm = _NativeToolCallLLM(final_answer="no tools needed")
+    agent = LiteAgent(
+        role="Tester", goal="Test", backstory="Test agent",
+        llm=llm, tools=[],
+    )
+    agent.kickoff("test")
+    assert agent._use_native_tools is False
+
+
+def test_lite_agent_native_mode_system_prompt_has_no_react_instructions():
+    """In native mode the system prompt should NOT contain ReAct Action/Action Input instructions."""
+    llm = _NativeToolCallLLM(final_answer="result")
+    agent = LiteAgent(
+        role="Calculator", goal="Compute things", backstory="A math agent",
+        llm=llm, tools=[CalculatorTool()],
+    )
+    agent.kickoff("What is 1+1?")
+
+    system_msg = agent._messages[0]
+    assert system_msg["role"] == "system"
+    content = system_msg["content"]
+    assert "Action:" not in content
+    assert "Action Input:" not in content
+    assert "Observation:" not in content
+    assert "Calculator" in content
+    assert "Compute things" in content
+
+
+def test_lite_agent_react_mode_system_prompt_has_react_instructions():
+    """In ReAct mode the system prompt SHOULD contain Action/Action Input instructions."""
+    llm = _ReactOnlyLLM()
+    agent = LiteAgent(
+        role="Calculator", goal="Compute things", backstory="A math agent",
+        llm=llm, tools=[CalculatorTool()],
+    )
+    agent.kickoff("What is 1+1?")
+
+    system_msg = agent._messages[0]
+    content = system_msg["content"]
+    assert "Action:" in content
+    assert "Action Input:" in content
+
+
+def _make_openai_tool_call(call_id, name, arguments):
+    """Helper to create an OpenAI-style tool call object."""
+    tc = Mock()
+    tc.id = call_id
+    func = Mock()
+    func.name = name
+    func.arguments = arguments
+    tc.function = func
+    return tc
+
+
+def test_lite_agent_native_tool_execution():
+    """Verify LiteAgent executes native tool calls and feeds results back to the LLM."""
+    tool_call = [_make_openai_tool_call("call_1", "calculate", '{"expression": "6*7"}')]
+
+    llm = _NativeToolCallLLM(tool_calls=[tool_call], final_answer="The answer is 42")
+    agent = LiteAgent(
+        role="Calculator", goal="Compute", backstory="Math agent",
+        llm=llm, tools=[CalculatorTool()],
+    )
+    result = agent.kickoff("What is 6 * 7?")
+
+    assert "42" in result.raw
+    assert len(agent.tools_results) == 1
+    assert agent.tools_results[0]["tool_name"] == "calculate"
+
+
+def test_lite_agent_native_parallel_tool_calls():
+    """When LLM returns multiple tool calls, they should all be executed."""
+    tool_calls = [
+        _make_openai_tool_call("call_1", "calculate", '{"expression": "2+3"}'),
+        _make_openai_tool_call("call_2", "calculate", '{"expression": "4+5"}'),
+    ]
+
+    llm = _NativeToolCallLLM(tool_calls=[tool_calls], final_answer="5 and 9")
+    agent = LiteAgent(
+        role="Calculator", goal="Compute", backstory="Math agent",
+        llm=llm, tools=[CalculatorTool()],
+    )
+    result = agent.kickoff("What is 2+3 and 4+5?")
+
+    assert len(agent.tools_results) == 2
+    tool_names = [r["tool_name"] for r in agent.tools_results]
+    assert tool_names == ["calculate", "calculate"]
+
+    tool_messages = [m for m in agent._messages if m.get("role") == "tool"]
+    assert len(tool_messages) == 2
+
+    assistant_tc_messages = [
+        m for m in agent._messages
+        if m.get("role") == "assistant" and m.get("tool_calls")
+    ]
+    assert len(assistant_tc_messages) == 1
+    assert len(assistant_tc_messages[0]["tool_calls"]) == 2
diff --git a/lib/crewai/tests/cassettes/hooks/TestToolHooksIntegration.test_lite_agent_hooks_integration_with_real_tool.yaml b/lib/crewai/tests/cassettes/hooks/TestToolHooksIntegration.test_lite_agent_hooks_integration_with_real_tool.yaml
index f69c7df52f..79e3e4837e 100644
--- a/lib/crewai/tests/cassettes/hooks/TestToolHooksIntegration.test_lite_agent_hooks_integration_with_real_tool.yaml
+++ b/lib/crewai/tests/cassettes/hooks/TestToolHooksIntegration.test_lite_agent_hooks_integration_with_real_tool.yaml
@@ -1,94 +1,1368 @@
 interactions:
+- request:
+    body: ''
+    headers:
+      accept:
+      - '*/*'
+      accept-encoding:
+      - gzip, deflate, zstd
+      connection:
+      - keep-alive
+      host:
+      - raw.githubusercontent.com
+      user-agent:
+      - python-httpx/0.28.1
+    method: GET
+    uri: https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAA+y9eZPruJEv+v/9FIzyzLM9r0Fx09bx/Ga6vU2/6fZ4xmPPveFwVFASqsR7KFJN
+        Uqpz+oa/+wNIagMBEqBIcVGesM+pLoILcvllIjOR+D//QyN/XmJ3t/fxa7zH65evtf+T/jK9sA43
+        +NULEhztI0z+fl2HcfK6Jz/EOI69MCDDDd346vqO3f5ARx5ieif5+XKP+ek1CT/hIC6/Kzwkkrdt
+        MPmstZuQD3nduAkmA17ov9rHFgdassXajkzA11aYvADH2mk83mhedv0tjHZuov0v8gf98AP6zW9e
+        rh7/5lGiYDdab2++Zu36fvFjuKPfV+k/G/dLYTxDHPew8cJsolVD+YN8L8G+v3vdR+HR2+CIEiMM
+        sBa+adsk2cdfTyabcB3r+Tjd9dL/npzGx9dT37mfc+6dSU9/p6W/07LffaV5bykRT0/QqAB5bx6h
+        tJfo9GoQJoTob+7Bpzdp9Kn585h35Ty/fVn2yxbednnN97/9/Te//l/a3o3cHRVwXYvx+eabj6Iv
+        ELz6u9+lr76685p0X4nvvPkuIqkXln2trbdu8pWGdyu82XjB+1ca1REfU1knT9y57/j1HQc4crPf
+        5OITuUG8jrz99S/JK/F6y7uJvvP0c0R+Cj59pWUSfP1lrD5G2I3DgHyTQBDZ8fxRZ00h6PL5avSP
+        Bxx9uUEh3vDY+wm/br33Lftc4WA//JAeu8Mb77DLhp9H//364w/7fRgRHCHEeCfko7L019vnvvvh
+        yvVfmLcdYvSB4wRZ7AV8yC6Y7AV3j2JC0S0hOv9qQD7kdPV88W/Fj41ziEllk3xvEh2weFTGxJJh
+        b4dgnQIvRUMiDCVDqXb5PvaV7omIuBOxcNfb8oFnaSwdE+8Jkwg8r7d455aMjL/ECd4RAYhjoixx
+        ycijl9s/0YAPvMrNQXHQEa+TkBhR8hcWG4t0fC52L6ZhOegzov9MpgYin7mPJwQconD9aeLu3J/C
+        QA/Co4vWbnB0Y3Q0vzZujTnPQOQPqIB+a2YYHKhiAaUMNNKx2bRm1fOKE3flke/9otOffIw23tvb
+        gRIcffbJ1Jqa2Hwusgy3V+6bsCOc8IboAcIEDW7mw5j7vfcZ+2SEqS8xMhZVJn+PA9fjWRaVrz+9
+        s0wKCb1Gya7FzYyt6YxMmPytxixLdxzTIfyad8qvqWmRryd/S+tWY6DxGGaZC8F8lbg10xezznXr
+        8u3SmjUwZtm30O96lqn/bwvtvE0BJARLHlO3poRR0wpGyU16YS7NinUIZ4jwWk4b6riX0YOdCpck
+        ZAkTufJEWSxGQ5RsKhyiuLuVi0w0Rb4bvWOOfyOgjkWeN2uENMQIGLeOEIc43EElVxUJRKnD06Iz
+        dXZe4KkRp8pCDYc4qb0VEccLYuKFrxN54kwbI87cqKaNYyxnIsqw1xTpMmcmUrHcYSi48wXGlEcP
+        OvyGGDhxN27iFlf0QZikb3z5zTfff49+q1na0XO1b76b/PC99s0fv9OQ9p/Y96jR0+jKHCUhSk2J
+        dmV2uIvzO42UdU1psvSO1unTbmJodJbu3tPX4W7yUiQs3rziYLMPvSDhRAYmR3OSvi+eXD4uvlq7
+        C+lvt0l/u0D/f/Xet+jHg0v9j8fyYGr1jwdv/uEzIqRuhQe/Iw/XfoOPhOrkb+yH+x0OEu2II+rr
+        aeE+8XbeT3hDA9Ya/kzI5dEB7XFgNu0vB8itusSassCGJmXyEVPMvMCHT3RmP2qiESbYEu/a06g/
+        RiHRKPL3W5aucn30HrkbrLEoliWKWtEkp4f2hFJ/ssHH58Ay2+4pBz5lSQdEfL3JjX1tVyMothDm
+        /DbYusGa8OHEmQ8v2RLNoK8hv127+yz2QJNVbrDRZp+1N5f4i5HmBW84wuRems7CmzaYZhpOz5lG
+        URqYNgy/bRKvtwFhR3ss+lP2AsKh3xFyFywLg3rtcaCPavMehu8+zu4KkKMbeXgrv58sTo067lw1
+        Z75L36iRN2p/pm/Ufp+/MV/g/HEb0gwcdUISb110ClLdoiUjXpwtQjWiQORzaLaxDebNF2rMI/8S
+        HypX6zgjMErlLWaJzpD8gWwP3CBEK5f847a2fPo9pmEvsoSlSJlyXfvFH8h7tW/T99Jf/5Lw+5vN
+        MQNP0WI24/g5pZwiqPNv5Bdx6B/SATmxWjF5S8U1lwT731PCIJtSPpst+QkfPfzRtgQMNyN9iPWP
+        yKPFQHvX330hWvPZUYio6lP5gDMtO6GGHFdM17QW1QHEhbm0mCHCa6pheSa9UKsKZPN2U3tSRfOp
+        PM1n8oFaaYobhkTMtkWSzxgpapzkIOMPlnEQ8McK+LUJogRTI3dVLYAiuW0ZapucMeKLivS2dLYc
+        pQmKc8fI1+7J1uXdVNsJuWyJ+Ew/BdNSwc01X1IakYHzFM6uGS6QC7srNZw5JYJRuKgsGCya90Aw
+        mizqpLyprnuVFTHqSec+NLIMa2qSv5RFbqo7s8WcTTALza2ZjZ2Jx2aer8odtxsOuHeMQ75Nfc7W
+        DIGA3wr43l3rDQDpIitpkkFSfaxYWlAikLUqWQNEHZiUA6JWSTk+AJ4CnnYiaYCmA5NxQNMqGT/E
+        gKaApp1IGqDpwGQc0FQtnLU7+IlHiOz66NxsoNlc7cKcl+QQ5rwcwvlLXqr1xdTtCs06ZXpnjFww
+        wzK6Zs1NiLxvXrKCmrInZ1pVvMV0JCSV2zXhtDPc+4l+sW3MyyuqDjHKtv7r5PVx6GPd/ThDGK0R
+        OO0Q34Y7/M9Zs4JfnW/62SStFkBrN3H98H0S44houY/jeCItJDzZO4/JgapKVuVGycl9scmBUPh3
+        3pqgu3RWyC6kCR6V9Ww1L2Q2kxe6L+cj5NFehUOL5r227vN2ts7uYOyBPWssb5e1nalm8aktDIVX
+        UwzIfGxVsF2bcH2g1eiv6+0h+BTfvNssMJkVFqtaVnhj0heUD5G4mDUPufl+6nuaPAObkV1G/Nhd
+        6jnfEi9xg8wY5HVlFZuVJY1wDVWuRlihat5eqq4z/DnPZP1c82LNvW4u9uZhf6Nrf46x9vNyo0ju
+        DeKELBv08opCrkN0h2NBG3i06licu4r9c+pi/OpGbDKBycv0woiKTjtuRJXkpnWgsrvsG5PIGkU1
+        jfN/yvZiEBHHevhO8j6Qh6iHmDwc8ZVBvvIuadc1/IuqcYSqeOcddjedUCpvclfhEb8Sg/DqBpv0
+        37QVSXzv/el/8r7IqiEPokpeBXaU93zpGTuoqKUETH+owxDeE3rHkgoUAaa0wpTkA/tH7LurWN+5
+        EQ7ewxzbLTSXX1bNG2suo9hmqG2vpyVH4xDr7RD+QQErsW7err1ADsrlAB9ADkAOblB4j9/dmCyT
+        TMTLIkny1VlKTH+uskeDZ1nY+FRJHLYE/Z5gwrdq/gQTvnH10lUi/kzcmjiWb1hnN9aUzZGIuXFC
+        7MJr6unGYke2An3yegUp4iiUHjRAmrJU7J2ZWE43tgJhUm8YR130ZJOhjlokVll0pkXRCZJtFO69
+        tb72iY3GyEZTtHW9TwdafeAQgyWuPlhHODsKgVOBYDL6VlEpI1cm01yM1up4L5ojyrC4cezFRFoT
+        um5789IOEk10RO8mG5OEof+63oZeGust4jorfJngOUQE09IX4vXVE76s8Epe/thQa0lEtuECFilB
+        bLV+pVCgVQjNM4F4d0UehcgvJx/kFTEK8MeEsmtiGpOcj84ZRM4sRtkTEEc/awn/9QkuvdSRJitw
+        inrE96L4JwSkd9ODbvLum/kkLnbFqbAJZ7X8l5NagkaCRoJGtqmRvMcFRL+O5KaEzGV3mUm1Q0cm
+        HuAk9eiMmWUolCA1tmySq9RssSdx5v0+okzzUVLE41meDSAgdnWIGdv5gEsi7p02Q7IKpOc+oxg2
+        KIF+4ffPlb/C3EYlb5e4m/stRTGqtn52sQy+3PrZxZVshVpnC7VC1qutb6u2zI9GjjYbtYiRY1T2
+        EVBr7KhVBSlzCU+hGlIcFdKlEMSSSlgQzcrEcCNAps4eoTJOUOnY6VaR+KlhmctaEt8DI9ro8haM
+        6djl/hLiN2xDoTIg6930wCB8qyvCQlBqkEvCKl6H+0OcsdqyePgmTJo2d/JZ16yeN7L475SL156Z
+        Eh+bW4l1zcWRhHDKOU33Z5BfymbvG9y3IukZtHUUX9YvkovGqnnEFPEcWhJDvbqFwet8KpO0WBS2
+        dldkLQornyawtVHXrtUKAw7MNnnq+pV0CUefj12XGXx97rp5Hs45eB2c044yIeZ0KaXqqaJPTV5P
+        aVD08xhQdFD0wphhKXpeGmTWLA2aqRYiSDbRaaG3TfeFCBZoOWh5J1o+Kyx/7lBttcQP58R3NYRQ
+        zROxNUySCCOdR2PPmXhY2y1uq5mSq3ejk0KGkNO0a8zQ9ub6MWDbY8so3/1w5fo6QBxA3PkqQJx4
+        MEDc4CCOdi9tFN6KTULr4ZutGM+ZFtKayhCny4KcVOio5B3jBLoCw+SRztHNgj0DqAOoaxTqaNt7
+        gDqAOoA6gLqRQ50LUAdQB1AHUPcEUMfiXF5lR5BOFeaENeAt7jt5KVaS37tLRbKIsPYunlEkRotV
+        HfK4ZhWDr6OGNciq9ibzAOAG4AbgBuA2aHDj5RzqA9tplXEvsi1U68qKR/4pg5v8ttn6AKey43ZI
+        EDe7B+Oc58qsAsj1ItsAIJc+AUAOQA5Abgwg5+7dNcAcwBzAHMDcmGFOiHB3bVp8VM+ZB/Tr4kSN
+        +tGyaywnlAPEAcQ1CXGV27jOEJdt1zSW3IYlAHIjAbk+eIGAcYBxD8U4hQY9TTbCrdCy1hv0VDQR
+        PVpfPyld5ESUod6XmKggnvzr4f2dqMXv3DX+V2fyE95vv0RovkIrzBwPXt5npArWT++rIujMXjgV
+        9OSNEV+sheZsB+ycVmt6vrfv7tzJr8lP39OfkO2s0HdBTAi8TtD2TY5kEgIoSTBOz7NHtkXDxVOd
+        Smg1N56dVteaWjhbYxOuaYY5m0t6vAYxu0cPf0xwsNmHXpDEk/QoscsZuJNc3/EGpYfPxxe6IzHd
+        +Rx7D8N3+g/e0VtWyEser/+c9q8P7xA7b59JGanRNan5PNkRFEaZGmWstJBprxCdkKwCyfVNHYQK
+        WWXgzCEVlXsVUo0La+TJpEil8QhUqbW/otQP9Mfc3hOp+vaMpo8Wq47x8TEm7EJ4JCa8Gs8WqiwD
+        o9YY2xbVXPPIZdd3vckP2U9ofrkHHQ1d9qzdEa5EHsC3E/WRkPoKkZxqDn9O37H4bFl1mLxsjsWz
+        6dSuMj68MeKLiixm5/IABouJ3wqPQY+70WMh/WtzOa2YyQ5+DMKjezrnW7IT/CwtHllUsFQx9m9L
+        bTTljBFfVF+QWCxzu490y0axS1rDs9zeeesoVGj8nx4V3zC7uVuGH8puU3fYpve12H0fK8s5tVfh
+        0yKNHzeckuteLW3dZrOlI1LLnh6zCkd0FEfefUSHDMNHfAAnHBnWL2hqS57hTLCxngnGZXjG7nNH
+        faNmR/1TWx55AMsa3khAWLH7zihqlYq9goprUfcjPjmUdCHqrsjDEPnl5IO8JEYBWZRSrk1MY5Kz
+        kzIyY+mZ0yh7AuKo3jgRdDjVRXJ7YeDUt6dyKWFjwBPVzMLGACiaHZ1ZKxTNxjHerfwvrjdZ4bg8
+        6xtjwuxNFjiybYmWiJeHv3CUgCCqF74mkRvE68jbU86V6cT57US2RFMI3CCUmwJ5CPGnDWteFX19
+        0BzK2gncuUVDvOtWfrvsIza73rcptP19xJL7gkexAuLs2QXLA5an0QXVT4cIT9yNZPm8TKqbPrG6
+        yEh1lwGBf7zZUCJLKE4B2NNZ0mrjz2jnBR4PvMUwPJc83LB42mld+khBD3c/R8nVnJAnSYxlCCnI
+        TOHN6znXT0b99RYZJkdzcnnL+drfuM8hn+USMnmY8yAKLC8M7Hg79x1XPTSfTuWzyx6jhiduRMZg
+        fyQYlIPHDscxoXbc5go/18zdzg02KEJ7/xA3FriRUTWpRH2vwjZF+r0Sp5uNVqv6p5yIvpwzZ24p
+        rS210LYkoMry+JVZF/TRmRPmS8ATahNbrnTjdDSyqmrUPk4wUw322IKHHaQ8GNXgHKAMytGNcjDd
+        xCSlT56xbctpQ0d1DH2Z3XNQK1VvOOCjgwA0Hw2UDzEy80OM1GOCmVix8eyqCgmZ04S4TnbbOGRb
+        JTBUuKhoL+dgLzu3l5e8gKqO1D4kIlMRNiTzsCrIwbiTz1IIOQj1eNwZKqAeoB49Ug8Fb4yflDkR
+        GJE7Ub7FTmp11lRoVGIruGlY4r2IzDX1EmO+mELygRlaK/nA6pFw1TX0zEKQuF6QCv21GSLCSMSd
+        aBdRLApiV8Uhcf5Esri2lbXoWsj5BvJ9n6AwjpFpGSspdS7uyS3L1kmlZ6vNlGmbxrxS+3mDSq6K
+        gi3Fsm76kXq6jzMO35K0thsHBAgn+8hbE1mcbDBha9pB6j0gSnYkHgeOjkRW4km4x4Hrnf57orKL
+        uCntusew8KUm3Tb9GoXUIEhKDbtbUpgsryMxLbDywrP4hmk0OYgD6hS8/M53E41OQAvftH8wdNPR
+        yEy0H7SUCFometpbGGnf0Ndq33yn/S48BJvoi/YDJaD2nykByfC3yM12mtOv0/4cY23vJuRS8LXG
+        pfnk/9ngvR9+oV+CAneH/1/tY4vJK5hfa16sfSFEyD/gclX7Bdbf9a+yp2e74FH26F9ygGKCDylQ
+        OGFa046MBTHpt3wnj47wOvOIN26SEp2MnSHDQtb8hoAVQZTixhThDqbCyFbTri23OmBjmJ3Z3p4s
+        31ihM03yr6zQ2cgwi0JXsSOKbW4KctdXq3SfONGaqxzI5shc8EICInhaFJpxCA3eTKoTyyCEpFjQ
+        CuB0K01EXvzE251XxjlkWcicS0Sc8orx8nLrO8uzr97BVXth9xlpN76npU23E7cK63hxtnjmCItk
+        0mdWRYeyUdnzG4pJ1VChe9a4pYIvkHmDmt5aMl/kTbnMcwxxqdBn+zvMaqEv7vUdttCnE7csKaEX
+        hLlA5stkXoTzV5LLlXe1LTiq8u4UWtw/ibwvpCFeHNRVDcamX9BUMFb52aCeSb4lLg1OVCkjN+Qg
+        taeiGJ2ovatizinKaKmATHn1V53VoK9Ik0I+plyPWZmlY1Zust7yLjxZSiRwaUz4NU6ICO5g60b7
+        y7LpeY1fAw9yMyuxyLeKm7GGjAaZOay1wQrQANCgv2jANk+u8gfYXJXYG5A5D2so6g/OQKPPBkzo
+        OSakJ7f0HRjkgv8ADAAMAAzNAQNtzdB3ZGjTZVDqynAHPAxDw0GZW1BmYYVnO9qs3GjF0hejCgIo
+        qfQdkQBQaVBpdmjDsT3a0a9mbC/LdC2rtTobWNkIcCBLe6fgn4AHf3k2gMEQnfXQlE++MzV8hV4D
+        5UV8Uju1O+yhplbG1+sa4yal46rMc0mkREVEZrohnRG22L5Q3HanKUTimP/sVoNDrR7D6OgLtkiO
+        37L1Mn9LdwTOZX/E8CxgqUsjlLCbIiBlIesEh6RExrbms4VIZAoXx4dCUuy3r3PMJrKVckwDAZg+
+        WK2GIaZRB0nRXInE6d0PV66P6F73jRttqvZaVcUiC7AivzlLGOMY0Y6XvqPPo7cylEkfZ9NVg9LH
+        7tIC6RvNbiuBUBWjsNLbzIfL8642T3XD88ftFJZ1nwE/7pelnluvpncKg9CB0MkJnXJxoSW/8BvV
+        VgMoIYISopFnJW5hoUZ9YQfY0IsCQ8AGwIYnwwb1EsOROQ5qNYZQYQj63K9yJJ5C16gylN5qOL4i
+        QygxBJ3umU4TZbb1KUoO0ar80OBznWBDWukYy3mFTrZ+7Nu9JRlSzRpuSIwM02JOLBBE6qY0UmfL
+        ZIsayxtwImqDY0kdQKjBRi/I2pciY2k6UnqjcDrpKwPVkuojvHZixHnZKG2sRHQAwGgbMOrgxRTw
+        omd4ceaizbaIE3PRQqYtUyMwCrXqqjCyBgtnhC3NsrC5A6uBiXJMNE3J5Ly89yV9SG6/0XRAPJx9
+        kvI7GjuhmjBm2h1jhC1Za1GOA2NPSr5WZfS0PHjalcGTL5DkZsyettniQVEtalgTmxukNcxJF0RK
+        x3GxmZShdXoVSUvvLLSjZlxA8hWpS51XkPx+Sr5tyTmlrMjUZQlvw9oDOZI1lrfuJ5o8ZADlrign
+        H30FDHgYBmSOb7YLgO6OBf50wh/eKJk06ImB2VgwtC1RWa16XLICjI1eVWwYbixmZzjz6ZzlxkM3
+        l7PN9ap2CgviIVB5OqQCluZ3ibRaHMob8IFXrzF2IyIvJdvEM8DIWw6QFRATVxFucjJNMlx+kxOg
+        TP57QBlAmadFGdVSVlMONWQa5V638miqOqN71DDTxjcquLGApn2AG8WR/ceN1l0UAJv89wA2ADZP
+        DDa0FbCKkyK930YGYK6Up6lmwT1ADhYzK5utAW4AbhRHPnx/7RUitO5+AIycfw8wAjAyOhgRlFSV
+        g4KdHQQicd72XJcZeKUcnEcPt5tUlvOvPJ/7avpFej0qnzoWiVZykqHJ2cBFrEnBySs4pkiyMOmh
+        AtH6frpeC0QLbIZ2nQAqD5O2nvTpnI9I3ERHMT63wLmHjXc5McxalBqydPDNMlbCox8DZt1OfMFM
+        vP3efQ2vwNPptNSFr/rZvV6WC7voXLfvKRnEarBwaGtrnbK8QKbtxH9DZz+l3HUFjQeNv//ZoPEd
+        a/yl8MA0CsuYUpVnJbpkz82wT6S4nbYlqfCW3lwBI6g8qHwTKk/WkJnW35zBxzkLFGw92HpQ/FEp
+        vmpl8lw6W5+dszlsG3/2VvSuzp3qdSzICa8PBp4jcwGiBKJ0lyiBI6IiVOCIgCMyIkcEkcn4ibfD
+        lQCQWZY1GZ8SNFPIK2041xExWFtRdVReYdj/QEcLOfyGwxxx/sCqLvnZqOzxJcNaNpn3KINA1M8i
+        LkqhyYo2S+By0WZHl4q2rbN8ZoZnFZnFApWSrUNNGFpb4rSN1lVgprMORvm+oZpH7WRS0k4pbc/M
+        LiBChghlaTZAhWwQoAKgwnOhQmkqrh0/eFYel1Hyg0+gwG6Jbdld7gUoPCApCJAgGDVCSDitkpPI
+        DeJ15K2wQlSMbboujLU2dxrurFoFWS3N1Sz/9Hyee9m+2YJTW6q1KH3f5OZ918GtKn6kj60u568b
+        cbwhSrzH+Gb/XQUGmQWvjR0f43UYbF7yzURWqxHEjND5HBqGrKbQiX2OmPuCcJWB2CN5ZM00yyqZ
+        nbPS/nu2V6waAoa+64Qza0tCplnag9WpknNRWLYheZXM44xLXGVzOAJpHWDSBdSrlj/HtiRqP8v5
+        cHfuTi+jhjt34QTaeG7k/QQc6ZIj01ODVtMsbJmV2rMmGfIglPfCyEu+nNkjEamQ3BZXfHYTrG/z
+        4PG6+zH5nQeup99Y3cFXxTHD6D6i/OxeFSUM6XTz+6oWYhwdyYhXwsqoZJhMZRMFMSrAgGQ9K54C
+        HCs+9LE4JixCagjIhM8fIZIJ5yqNUURtPgNIPdzduih8r7BqGDgErlMLgCOEkubKvS+Ac5XeVkWd
+        YudISdBxZHceyKFT8dFNZLB7gzns2SSVmGMX+mUD6gDq3I7sBnXu9Gnaz5n3Ma7T6PIGuseC5j++
+        Z+f0XG1vKGUsAQNuqQ0YABgwXAxIhb/v2t+/eGgcHqKU+i/bJNnHX08m6Tz0nbeOwjh8S3Si7xMc
+        oEM8Wfnhe05tL0DpOOR66C08BJvoC0q2GL0dEvrb8I1ecPf7GLnBBhExIJiC4sQl/ERbTJj2AvgD
+        +DM2/EG+m+AYYAhcEICAZ4QAGvPsvfL3JvRYGwNAjUGNmZFNqrFq1yzpM66KCYc+6rCsCWczB2DC
+        L88G3R+w7tcMJwIMXBMcYABgYLgwoHpaLlXoZbXmN3VqZR/0nj22EvT+8mzQ+wHrfU3zDxAAEHD1
+        bICAgUIAmeyLTL+H4rGHfVRlpYBc1kPgejt9MTvoYzcKuNnBjIiXfODklBek3+LHRN+DNd4n8ST7
+        bxSH/gZtvAivE/8LWn3JEor/vPeOYRL/KssuhnscuN7/lbir+FfvfrhyfZpEDDZutEFu6Hr/aP36
+        /N9pAuYKVMg15pafZWViEHJspwM1IAlTBK3iPowuFQCZQPFDYUPpU+LBmGqUABQAFAAUGtsp1XtU
+        6M0iBaoGQJH7uPvosufRBW0GbQZtHok2P3cx0F17iUGZQZlvR3akzJaaQZ5LG+T5EAyy9KK7cMoF
+        LLvveDZAQo+X3VbelcRCpmKYvgAOkm1JbPleSAVUqepLYg+iF1J9HKpuhKSzrZUBuu54NkDX8PtS
+        WjWyDePGth7seuwdsg0DwACreodVKiAEvhbgEeAR4FEv8Eg92zqycJBafqZ+TAhUGVSZGdmkKtug
+        yqDKN88GVR6oKlvSmy4snS0YGLxaZpsuZos6ejnwuCQobL8VljfgA69eY+xGRO5ktFq49AcFBwUH
+        BR+wgqeCgqoCeukoXoXUtWstVSBZEqO7eslLsaSwZCN27dO6sze+4wBHbtXxirdfV9sHTx8TTy7v
+        5MbP8lF44yUVRzBuNxOTHvT7GdF/JkSTfYSRXYrSe+8z9smIuT6zlrU2steg3xWOlk9jvrTUpjHT
+        p3aPpkG+vxY3+jQN7317I1ZCpBDMxdSnS2tmz0yzVnFkjQmd3kwm1JBalqvdNYWm9qwOhRZLZzo3
+        l6OmECHNHTI0bgr54cedSmY4S8Mx548CjQ7pU0/FDHNuTa3ZmOlzl4KNmz474j4ddnepmEMWfVPH
+        tsznIFEdLXsWEt2haGMn0RU9ZDbaCBeTkiUiL9kWlZL8z+1arbhSFUWtullLLurut2l6LXnFR73q
+        GDYeExuOB4iW+KXMZon5IB7aeu1DXFvl4iVwOwOGDpShJesEDtwKbJClG/OpuZzapsW2OByLGSpZ
+        LwCdWDrx3RklOtnO1JhaxsIeKZ3K1w/ypFroxnQ2c4zZaCWqfBkBlCpS6l71m+vLOVm5G445m4+U
+        VGVBaHlC2bo5txfWIoPzMa6+ykLRQCeWTvcqHqHTdD5NzZ49UkLtvDiJXB/5bkRoYzmGVUqZ+xz1
+        YsWHzSn4EF9UPeZCVD0prGOoJBDvsMCnJ1GotEVoLhuhabBbs2FI1BXxBpVcVaT0TJHOvKG16mSa
+        rIFppoI0NGmkwkkjFUr9+kF0QHSUuzvNyDpDulmb+ch9grMpcVBEUlO4qHrQg75w+LHmYcnNWSLS
+        rkNikcggxVgSVFGRjqn8ttMxycbTiMY+wkcPf/TcykiJhG3NbyqSGUeQufiMNkZBIGrCBcjGI2Xj
+        0SXe1fJjqwiLpGWpl4nup6taO739BC2dyh7TmC4JezN2tBeiIbffzk94cwq57Q0miL5OQ12vGzdJ
+        pZWMneVjvwJlBWUFZX2wsm4w3iPy3tOeJMVWzDL+1QDiO0pbDqGPK5yRNoqNhkT9VUN0HQRh+mB/
+        S8IwwzAA4mXSOSRHfDYT2UoJIpCGVqWhOR5LdwCR2N37mpqoFMNGZ9rZ7nv8hn0XAoArMBi/XDiy
+        p475ub2HMUOmAdoL2nv9INDePmuvU+NgI/nmeU/hSoES9k8Je7myKddBYTAa1LGbcoNxSlucuMHG
+        jbhNf8rLdPlFxB01mCmbhly3HFtfmM6sJ/1yCtNR7mHk6Pa0d5Op28moR5Oh1g3h3QpvNkSRkZ3V
+        bEstckzdbuhkx4W5NEVIyl7LKXD+5AanHu8IE1+kM6W2cf3ukpWgOpt7SiJ34yJDcrdDvcZWfZl4
+        vMd4vZ2k/4GS1PEVT5nY9MhdJ+mc6tYw5Z/uHjZe+Jq9/fp6HB6i1C6+bJNkH389yT5N33nrKIzD
+        t0Qn/vcEB+gQT/aRtyaTnxBTvz74bhJGkxeJKaLtRnqW9kDmSKdV3oKkLd6JPqYbKnO+hhCR7u9y
+        dPPimTuS4GeaZLhCmYhscsLS2VKRqsBZcwXGhjOfztnq4YeWDC50trikMmwGa/YxdOWVX28NI8kt
+        Sn9dQc5tRKAl3MnQQQJ3Mj2qGnileBlQNeHe9AB3TH0+UwSeDKrmADwAPLcjew88gRuErQNPVpG3
+        qAYeOYS6Urx6rSh7CTtF0K1CnSLqAupcng2o87DjfE54EuY7ohbEesrGjSxkzVVcGFvq5M6Xc6Zk
+        LCd2sjURPdxc99jMBiN0Jl23ywqdjQyzKHRrInXpYL7gsatRkLs25a47cbraCT5H5uJFITu70Nke
+        P0JHZ8bGgIYrJDN9xvdDAJxyaSLy4ifeDt/uHBb2LmGAKAtd3giaXcg1lQtmcTwjmFfv4Kq9QI6L
+        rG9VjB1jKWxowF6TFOLbiVuFLq7irkczYUVC9syqDR/ZqOz5JcNaVqF7fMVSwRfIvEFNby2ZL/JG
+        qlSmxGTf8j47sM2sFvrpY4+Cb13o04lblpTQC5ocg8yXybxEjyquvKsdmKYq706hb9uTyLtUNXaZ
+        tNcIbaRf0FRoQ/nZoJ4Jylvb0+CEUsO4U8hBquSyGJ3o4zmmd6/+IMA4pADjk24+LoOCq3yrKh7k
+        ZlZikc+p1R4yGhSrUQANLs8GNBguGlwlQVXRIPONl9VgMC3kQIeMBcVkJWDB5dmABYPFAl2pzYQp
+        VSj1wk0fDVn9YWHQ6LMBE3qOCShVjJ4Dg1wiEIABgAGAoTlgIAryue/I0KbLoNQH5Q54GIaGgzK3
+        oMzCnfntaHONFimLUQUElVT6jqggqDSoNDu0MZWufUDUQvpY6ryIr++dytTK+HpdY9ykdNxx4M9d
+        x0FV7WgpPnvIhwQVDpCq3tTiCAxKf8SwsrFpJmH3HRPTCQ714KCY/qOQFPsfcNpE/TYCQzZTxbYA
+        EGK6PLsxb/X5WqVlWntH0/GBuAV9UOKGHYM+Njen4nRXq0dbtl1Dg2eO9lQ2AMBkAOxj68WEkBUd
+        nmK8DgPadCnb76AsNDf9lJLIDeJ15O2ruu4xby1+/avrTX4dbnGEswZr6GgjHLz7Xrwtnc5ZCWTR
+        kbyoQgmmpiUSbuZSzQZrxVFHvE5CQiXvJ5yqkHW9H0/QCGznRp9wsvfdNb8n2NX1ibvfx8TzoeTV
+        13wqo/DtDUf/nLirX/3RJ1z9Jtj8MaICyRPF84xfs9aL14EnOd7uDn7iUXU8uD4weAQM/t33f/6f
+        yNTN4pEe0pyq0c0zc55TopdTNMHrLSHd7hB4yReGnCs/fM8b/7keegsPwSb6gtLfrgh1P5FfESxP
+        kO+uYvTmHz4jE30Kg7QbJD0NwQ026a9NlM4eBeEHco+uR8b7GHkBujx74ji2M5suOUSvXr+kk40n
+        F8pcr0XEXCE8+bfL1/aQNxXSvk/QKpKTdkdByFuhNxUD3eornT09ayGZYsjnvU/EekLf6MdXHz45
+        4og6GhO65n334iT6knPIR6k6ZNpAleFRVP3ed3cussn3mea36C+pH4S+C8inHdaJlPWw9Xlz9kMq
+        SmYZjjBIxl5T9JCLk6lhQYoKtcMJ4UxApIT+hPyM6IgSfYUy55OAWUb0Kz37dyIv6fnodzrsjTjB
+        t9KyNOpJi0U0SXZF1X9x4cymXXlZGoOUFxvNibwoCcq8sEYfsJwUJ9OwmJwkhBJ69VjRKOO8g35w
+        yYs94uiZ828RYcNvz1KAfvfHhZQkmLojHYSREAVDKhDTZlcXu5BeUGlInTrPxAeIws2BdqZGyRbn
+        COEg4rBtbt3i3OWmjnT2y41L5IGyJJ70DCcc9Kc1oVkmKrPfKhqWBtHC6F5G5sW+p08uIz9QS5gb
+        FHVzotC/u1pAFuaSDXN066OqovM1Lcka1jGmiuSc6rY9HjfOLGbGG4obCRy5lORcO10dP6rJY2WN
+        sfSZdJV0/1lMbG4DnroajwWuWGssXihyWPpQnf6zd9aEg63G3UXLzP3j1iPv2eGNd9hRz/nT+XWS
+        Bu/RYZkWugtd2HuPN3Q6wmVDGOj55L8pZfmOTTMZ6gL7nC6Zx+ELsE6CdbS+oI7ePRpWW2TetNgH
+        fUDMU9e6BlnXrdYNlnHpyXi11E66iKv/aldo+jsk3nXKOYmVOfCN4Zs+RT+Ev1VlmnR34gGoW7Hl
+        zlAYl9o58E8GyDkmiwe86wvvylfkjiSjrCbdEU6i4aHJiOp0VWUN2C6t+8U+diNa25vVhb29hdEm
+        r+QKwmNasoIOwRGn5Ytp0iLnMwrf0D5zMvxdjMiwrLgGueR/KKa5zTWeOOZ05iynD05ZVCi7UwOk
+        5/It7STExzaNeYdeEYtZNaTnmzQr9c136E8Zp+OshNAlUkPYSuUjwB+pgJzkBe/24QeO6I9fyPvQ
+        6hAT8Ytj9OEl29xT9V1aI/uOc1maOPZyapqWiviUsp3W4abbiuSYz/QQl9uhyPZHGLKcSBiEAUiK
+        XD9wBTiStUznA1HO2yeqgebJxEfen7hKi+c8P9+llBIv45caq5r1KXg7jR/p/PWQVfVdAXbLEp/p
+        O1rwS4zBJlwfdjhIaOmFNTWmL7XKmcN1dCHr/lymbNgcrpCxteqJ6X3n3/6tlF0bfKRAGzMcyxkz
+        +SByEafQyy08Obwf4iTdzDf5GY9MvyBf8kv0j7+1/nFh/OPSSR0+HPkUpcnz8sdwzp6nZCfPIYMo
+        Ub13HBAvcR/h1cHzE6p/m2aJb067ob6SspwJe0MVZer5LjGXSaP0M5+HeqfHAP3K6PcDceR+8yf0
+        n+X7Lq/CI9JnhDQUH+HEm4XXlOMjkgUr7RjJevu5+WzMNxJFOHKDT7LbT388YILpGa5e01HA/Nu9
+        gQ9P3KVfK1fqInCdMupIboOUpLP0VlAg9t3E1qdA4VYp7OhGcfdfGZUlDmBrjMwy6yneGIbQZUsu
+        Uf+ndij95sbl4aquBHrYlN5gvI8xTgHDKqXvxQ9gC6juTSVIbWwQdyEpXFWvthb0mYpf3Tgmyz83
+        IHdE+M3z/WZCaC13sZFgNYr3eO25PgaePwXPI1iyaNwlS61M4RVZkbejlMEbRN78FkY7l6wf0dZ7
+        JxYM+d7OS+J0I1PaP2fvRnSpeVoMOfZiZs/mra93rjRfUgrMR2+KblEKHH06a0cMrrI4VySm2WDu
+        XrZ3L9keVjRZYxDO31WMf/06w7ZkqwCArd2wtYUNzXnPH+QgQ5L5Te5IrdduvunmSvZtgm847WbO
+        hOigxWidjk/vfrhy/cl7FH5Cciakyd2YMolc7qCSq8r+Itt3WTnldIUqGR0z8Mh+TFPlHIC5O2FY
+        7Ex4Z0P+D7x6jQlarrfyEsM5Z0O4ybPJOrVeCI41r7RSPZWcOn0vHyRdAEQl4nRPFoZSdrigA2gj
+        gTY9EI+eI4vccgqQpQ/Icl+llJJUpDkIFBBjq1Ypxy68ZIvQBiJQA+Uj8BBUXSQi9HTATErkwuZN
+        hlZ6Ywp670V0Ih//2/ViZBsrzkHR4kyzYVvNSIfEfuIWQ650Jsu5WVsuaPe3JBWIfIfUtXCc2hPf
+        EljEhN3KVdvC1CAwzyWa8bVYq353t7VP3s5Dn6yKAqHT6xrcWG3NLNOp2jnIHVRytcburztzBoUs
+        QPrbnKpomjaF9wJ0vvMs4Y6ztGzLfNR+wA2u3vcjsZmHLqezEnh7JSUxToObeDreFMxOpZE2uWRG
+        iPxfvyYsshzT6LA/7mmXg+9G73I1IQ2mEm2JE46J6TJFTGavqUdNGjiIsBalCduNuRS5pQ/2679S
+        Vadt71KqjLwEni8U7otikb8TXFHHCAwfE8PlkhQNOqfWdNYxmN6zdiw0imaoyfWrULgnd6/dfdq6
+        gebG6E66L/QsH5QvOmgjh48w+uSH7qZHPaRPs8vbMhZ3X5bY3kfGG1qUF+FJjy2VYaqqcYB35SX+
+        t4L/SK60iNjFybSC2ZS4yLRWKWZL9qtV2th+elHaNkGOjaNxawsr3QdoS9aeguCYZKHpg9tH1axb
+        q91ZpgPbsnJXK9oZxDDktnPImJL0QLnLadqpvW2kS1QdBDt/huz6fX5LH7yJwvWnyT9NTLQLg2RL
+        J7bzEroH+FL5t9tRN8L33rcJSmd/NMuTwjennppLoyrem39GL5u2ls1FFhlUyKxMYLPqLNuhUPdm
+        IuqknbUnwaZjVlnBoRC5MJk2CK1O4tnMsKqAdzAkZiejSmJ3jwIyfovTnCsPM8hCYBuFe2+tr333
+        sMFp9of8khBdHjec+bQRinPPRX+Aa1cymQdQXIHSznQ8hCZzaYyC1tdPS8PmZJWDxk2gg0Hm6YyG
+        4uxsHkBzBVpb04ZsXx9ITSfTGA1VEGJ0VGxOXusCwqU03JKp7+03ec8VI/q0EJRvmLySZJU5wW0Y
+        NLXSveUNWjV1KACiVhL1tH9Xl25vMi8cvnAHOXvQ6YIAmTDF0vCejfLQZTF/8BHr7s79KQyy0qqc
+        g6fy0RcZ/tISGkIvPf8X7SxdTmdsqQNDJNm8lEu5tlWWaepOoc9FDRbHX+IE7153OI7d93S/cZ8Y
+        HYZBvA0T19NPhXbJ1gs+ydbvz6WOqpDjdy/KGHWjifxOaadgaVZIVpLOpVoQDIkHhcKWDtWOmxpq
+        XS9//MCBTv+y000TEQpoU4Km6ooblAXAXzU+A+B2B7i1EfbBOtUByQvCvffdhLbd0k9E07M+1/Hk
+        /UCmfFWW/+PBW3+KEzdqYPditTPcPKzfV85/hd+EiMmWGnKcuHp6gLR9ezb40fxarqmQrZvNLT67
+        3dvkpM7JTIVmi3oka05Ju6VY7s5VUQyW4ONbgp+1AZbfI3X/rpl8tycoU+Y3HLfE0pdN8Ft26S1m
+        Ayy7e6Buj1t2nwQBltwjx9w0tGKD4zRWxynnLzhPT6LIYLnBcp+FAaz3SJV+7aI1DtJdUM2E1gyZ
+        kxiGEChy8jiuGtlqRtdkNmEOgWgzfSmMruFDloOD6Nr4nMQr3oKDOFZbcc1kcA6f2DkkgnCxfm3t
+        eprZ49lIwkxGtTxUmd4qe57M8ZCZzKUh+inteBoXBZuS07b2Oy2NhT0aerOzaZ3iKrudbGM8gk0n
+        0xAFlfY6jY2GTcnq/TudnPFsIFnotvBcz0aI+6z7nOqQCvYv3Sl9EAAYcQDgwmZICYyXyx842zNz
+        dz7A0hdsfGSooW1bny+E+QA+zWomA5qLkHWdDJiWJQNOBANzMXogAVsxchZbjeSOnfHkjrPWFQo0
+        q2krliOxFXN9UWkrrPq2wtHZ82eGbCsKPtWYgKS+rchlaCTWYsRMtk+dl88ttefX6Gd8LVcT0pyf
+        3HHPa6vgydYIwAgoez5dwpI3K6ZusBGhwdLW1k3Vc3KkKfw5pfDiMyO9ciZp2qDt7pjGy8JeqRry
+        C7vznmCxALuBRs5jLziS6RXTKjaaEuYHASYunkGs0cwyFJY5jS0LLZlUi0rbabKC27iJezON9EoQ
+        JikzXr45kUI7eq72XUofLSLvxNomxLFGBmrrQxThIPG/aDmztP3mTUu/XX85P/fvdwlb4Zz0WuWm
+        zZ5eW934IXbRqYHT3QEGZzwBhqm+EAej+TSrFWAYS1068WhNCXpBXfrI6tKvVAHcypG6HFc8hu5f
+        nXX/KuMC7A3ogbI9aG/ARQ5gjTdSwD3EJxa3tfejmZOy+lAze9dZWWqEViHwmE4UmvPLPBWJp1LV
+        PTLyNSKhbW33mI0IDJjJtEtspT01N6f2DpzIZDJNkE8FEEZHwEak9N49Hs1l8/tRYX/P/o4Sqj7r
+        5o6WqAn7P+6hZxMl47OxROmzvi78oDOfZPWqAEcSpJ8JKwCviNVE4ZDZYL+drkuH7iy8EFO2TuFQ
+        c5jYNVnFkKhSNMSj7l1FQ854JJctyK0vuepZu1mDkeY+ZO1MfSE8KnGAWbtrtambtRtRzq6JhGxf
+        I8j3puzGdXaMpbehxsoseM5ze3qkZQ/K1V1koH6urjl/pPtc3XiB1gInaaxO0h274sBJuh3aV90F
+        J6ljJ4nHAnCSnstJumdnKjhJ7YhAYxx+D4/njFB2exAeXUT4Ix/8XDZYKGzLpIRMzhjxReXcxaKJ
+        yrX95q3y+E9Cnt2efIK73ja1/aR6YwmX6YmXuAHCOzIIJUS5ZXOrzR0VV0N108/dUMpJsNXQjeKo
+        I14nYfQaez/RB5pTW5iykiGZJZvoGxXRDMtRJVpKLvx5T8Q6lpY0vbnNcI5MAqAEYthryqZkXpYd
+        LaUanbQsyZpb5cgQzCkhGHtNtatMWX60lFxExHYecVg62PclQzNeJkp8sdbORykxa3bTaqH6v+Vt
+        q+12I2lg96iML/D4HaaVMrB1vU+HTABsY95FWUbju5brqdATsD9neq70DtF/wvepsbSWKorf4/3q
+        ypyfCfeNu3HspfWcZF74zfP9Ej6QxRh5PnnwIS5jV3cLi+qYbtei2bfKumq5tAxnIYxEMdfqVdbJ
+        CIYiabuuwOuUrBwJqUXXvO0nhFKeKZRyy3QIpUiEUqpIBqEUSaJBKKVqjSukGoRSlMgFoRQpMSsu
+        o+dXoZSpYZm8FRW1W/h1Tdzx1CZezT/9mJdTAfS10mb3kFs2vPHF7i3PHa6BRdtjFm1iPYCQ4rOE
+        FMUyACHFJwgp5uyHkCKEFHsqmhBSbD6k2NgxUBBSPNO1p+La573lPRTD/u4tz08egW5mPAo22c1M
+        gdDQzewe4kE3s/skFLqZVdP6/m5mCsSGbmb3kQ+6md0rpdDN7OJFN9DNTERV6GbWKDWhm9k99IRu
+        U413mxJQFrpNNdJtqkBd6Db1qaluUzltoZHC+Bop3Hu8MDRSuB3au/29JwZDI4XOGikIWQCNFDrW
+        ssc1Urj7iG9opNCOCDTFYZ1b8HQpdzENi+fgV9f9mUpVf3RlcJ20bD0k03U1lTAgo1JR0f+9CBXO
+        +hpHeBW58STNeCJbT/PEcmtJqaXO6QVVTpwlkXPnDiq52gm+KBHc1k1pestY8wFRm53OQ2i9kCO1
+        zI6aAZFaeNR8C6R+3ycojGNkWpJibTcKI7ZpzKtqJmxrPhPW7hQuqkZNCtMpegofHx/6aUK6601W
+        fvg+Cfc4cD10TT8UHYIYvbnEYSFOYBggHhVq2SI3ImOw33TsoXmzRF1e4hDZlpwwyZwsPCDFZb2t
+        oih5wRuZTrDGaBOu4xupyml9ckDvlZl6sSc+V3+igu7vkKPPbtm6wcTnWmcu7cZN0qkSJ3iGDJM4
+        w9dTEJarWTLlagOSAUufF2IOlYjSa57PpVQZONk3TpJpopUXp/EOMf/IsMhdJyl3rIIxFCb8LBkv
+        4IijBH9+JZKUfgxlgF/FeYkiyhZK96+pwM6sZP1R7Tus/fCw0d/D8N3HaZwhowkiovKOAxwR7Dxi
+        +l/UHkx87EbBJKPTz97CQ7DJsLVIOXUpIEb506AkQTKf1nTA4UlE4V8Mozy3B+LwLOJARKE8Cdg3
+        UQAb0Z4kMKAg8PCnyHCQsSzx8EFmRi8zm9Dfb71y91IlrRX4+9d0XjIVIlVrA84Y8UXFlcG0sNWG
+        3klDQU6IfJeGf6SJUrVgyuJMTSyXWt/rfPdW9xphrkbTNK2mm2/kJZeVJHKDeB15K4w2nhtl3YHE
+        cuMeNl54E5GfVWNqsQaivphJVO4IGrDkn57Pd0+5KxsK54gV3rziYLMPvSCh7/zreUA6aHI0J+n7
+        Jjfvi1/Ow/52q7yiPO5LIylc4R2v7io84ldzG3G4qZb+FZpp00DEuauWEplE8TnzPbRUMbF+6y0Z
+        F9D+RpfxPx5w9OWGx7zhtGfX69Z7375k+6++qh7thx/yg3d44x12+fjz8L/z8GTsqe5KDOUN+MCr
+        14yuxUHpKw70YzJkz2dxVSLjlCMBz5hL4EAxFtoeFLDZwruhgEWxIUNBIYALUABQoAIFGQycetqY
+        hUhJ62DA1riogUFfVHxW1umwcPFeJW9ZSST78oy42Q6rHKAToBOgE6L2h6raYRcTz+25j+zGHnHA
+        dybnPsr0cRuK+1gS1wIHTN63MqdLCVWpE3Hpp6rIrrRGrirPuNbqfc/GAS3JqmGjXnimn6AB9lUD
+        0ADQaA00Ct35xwAbBDMsZJbVYXQGG60ubwE4hgEcHS/QHw8u4JEAtAC0PBe01EaN20MylEGD0eN2
+        EUOi2UCxzLN1JGi1pq2Qo2g9+Nc3j7x2/US4P8SZYFuWsqNt6os5i8Et1k8U6uPEvvZUsoKiYEKG
+        rAjzxwfBh6YH9nJaogd1i4h6qQVEBWzQAtACeS1wztZgakxNpzk9kJfl/khoq6dXcmQUli6wdGl+
+        6eLcxFJrKHXtgAfRkE+Xz5urnpXKXTJxR3PfJ3vSqgT8CJ/fVCQl61Les1AKdySXFHk/CQAzADN2
+        VBch3svhlo1BnSxItQ0yd+lk66gthcMQcQakeyakq1yJObNyEDuf0AtoBmgGaAZoNni/rQryZo0h
+        HSxRx5zshxUqIN0A/LZaRwyA89aN89bgCQuPdt0AEPoYf08Tag6qsRf9vpyyDXk4yMMBDvQOBzK3
+        YGHU2Ig/EEAQ12QtyMAXgA7BcIAOgI4y6Gi+KmcwwDFFZNoAHILhABwAHGXAkTfEMtUbYs3ua/7D
+        tgQtRw7JxtMyLVKHE9W0AAsACx6JBQABAAEAAc8MAcrp1doQcBt+N+vmAZpAEtVcAdtiUBKJpNMp
+        7GzaLx9u/Qi2+unZPNn1NBD45voxYGDr+dmr0Se1eo33eO29eetXHCQ8QTpkSMUKAT0pNkVC48Lt
+        MoilK66ZYalHeQFrAWvPvwesBawFrNUEWHsuteEHxuWjyT1v+gOVPK2WYfdy892oIRkiAB1EAMLD
+        5s13Izz5l/XbZIcTd+L77s5FFpqvsrMZ3/YmExoQZu6WlkwjsctLq86LNeZVBz5yhgivKWtfPh1l
+        inlBsuiGYpbhLCooxhkivNYKxYjeR65/+pcSzQvIj4d1go6GXn6MbWuEkzhbtNUmulWE275Nki1e
+        +eSGyZoe+ZmK3DXt3I8fuyEdp2PLQ3t8cUlHnpKdh1tKkwedcEs/hlpJuWNuZ6ZTeTSqYYlPRmWu
+        Pf0xt2dR6NOZ6b0QCeIb+LjqHM9hCIaA5YTjwO2n4fa/FM52A3aPm92A5U/B7ne8/hRKerftck9i
+        gTUT8m5Wn3O94wa3JSYwpVumVBpA4MjjOVJuo4AjD+NIGpvrVVAg/SIICnQTFLiIA+rRMlFeJHh7
+        UR4Qs3wimejTAgPkoh9y0acYA5iPvojEAGECRKJNkZBYHYNUPIdUZOnu80/IctjyXwGvDd2oYPP5
+        oc24BKaIrew1xRzt7USKXKLE1/N6AJ0wY+3u3ZVHJuzhOCXc64lZYTDhskGlnKgGyxRiXcC0rpj2
+        Ge28wCs5qkdYWJlVcUqhr8wWw3CPA9drYn+hyRtUcjVn8anaLJbhM1v2mZMcb15xsNmHXpDQd/31
+        PCAdNDmak8tbztf+xn0O+Sw3k4vig2gA6+orM+Lv3Hdc9dB8OpXPLnuMWs0gMVG+j/2R1BnmBYI7
+        HMeE2rGS6vFG3VQkMrq5xVFqfXdusEG+975NssDlka3NLilpbqZBX7e1Smx5sjy63VAwQnv/EHPa
+        R0pWhNcnH3f/ykOLvYTdDVVJKE09GXd7SNTjnoapRj0l5ZWzmUNQX+s+6uEdmSTCwbvvxVt0tOWo
+        15j0TU1hxI+5lJMl/d4NtTfq3uKJMudnvKZG/cYYimm0O/iJR03rgfjeQCgxoY6OJIiRxXK7MFZy
+        9X4q5aOOeJ2EUbrVhL5oanOVUZGSkxMl9SYpmT37qQipR2SxF3wi+oqmFVJ52q1EPs64VqjaS2qB
+        4JIl6mGHyfpyvT0En+Kbd5sFytdYfvPGpC8oHyJxMf3W2+8X4k9GeElpYDiXGnRpgK3cMyAj9i0Z
+        caVqBIuzYyDzbVx6OC7dOSpFFEvKucnI8sr6GbyowHQmEfQpkag7d5CzW+LrLJQrvaGrdWBjyz95
+        Eg91CZhRLaBU87+Axl5IEiksQ5oTo64Xc0JBal5TI9qhmUCiynoPCF2L0DSw04nh6ZrKDzQ8efhM
+        RaaB2vWpPV8h03pe+MiTS9e1t4Jc2iXINjlaWUL6iojcDFqj7NrTHgvoEGO0j/DRwx/Szlllz82f
+        Dk1swG6h8OB2Vc9RCUiDMUNrpcHYFJew+dJQc1yE+j7CqLwMLGNougq3KjSGk0LOJTqLxVxS6xxc
+        qJbZ9CHx5PKUmBW+q1F44yVl149u5OUPuUgZjzrlgdwr6ji9o45oYhjvY4w/pQVWLwolB5a+YIyC
+        0PNYSJjD03dU2ULbrO6o0mKbC6cQOy2aQnfvodQcnuaUGsQfD97602ucuFEy2Ufemol+SrOWfunk
+        svAsx2wlXAzSUjLyiYTluwdAaLfoyNeCDL1xNBJNmE1vI+O3W6LYi0+oC0Iz3pAyCJ8/sJqZdB6M
+        RYy38ZrYscmPHzhIi3TlwlgysdDzw5vpWTqzF2K3m714f0lCQQs+Pj504tyu3JWblfNSJdhifz/B
+        ebEuipPDxgsnJXW6ClArIzNViHjL3jef/Pcte+/h23I5X04rG6NZ85mwz1fhooBtQ2XG1SiyJooI
+        Fp6AkkXC24aJ6R0ldUBXNKsUbedWU8/jIzdI/dy/Fi7RP0bxDvonywtddT49/fnbzW/+/lXNyRX2
+        H1ROjymGkZzeaR78WeaAVD1N4TqjqHZpLo9MDVkL0EDQQA008IEaSEReMujLVqHfo52072cHG2DP
+        CSPdeQKfRjpT5TTpsVrLYgz4wQ5roQp0pMzNDaeJJEthHs7nVvuxPhmXnYJ71Bcut6LNZ1rezKuy
+        +f0zSsYcSdb5g2Q8nWTAkmroSyrREklZLYR3CtXjfEcvl2Piz60mTaGYoJI4Nrv+kSTOQxdzV6q/
+        RKYJqg+qX34nqL4EcYaj+rzGCqD2oPag9mNV++QQreTabrMlrmNZ/Mk2o6qu5RgG4lRKQ1rITbw/
+        JNloulHBkKpXaDEs+FRcVokKPp7LoP8dSYZCKzSQivFLhY1sY4Vce9XcuuBx9n+U/EhrCTspOWuk
+        XnaoPLlrrVZeIs0USJ/vkisRPQ+XrsE831FrnZb2tGhgmVZOk0IbliqqKFfX1KRKPn3B+izdjNg6
+        cRRJs1AkjSgQUE6Y09xbXt2XU0YU/ZCtS6qkzXIA6/obG9FdMg/MRTaqsdDeSID/KQD8GaD4KUG1
+        WBcJQNpbIK3wMRWdBUWp7iX4VnndIoAS6vpCVdd7DNoVbeTVSGMrEqbQ+1iSNL3wu2dqtFE1ELNa
+        lOnKPFxcbgssxUAsxZgx/ymw+zlQ+InwlGAXv1HVPShqTRcS5+QCiqajmkNR6dKbKoHuI45a7H7A
+        ytmJy4kASSuRVI6Z8iAD4ALgko0HcAFwaQpcfpTfQC3V9kp2lbiwjQ731RakdbBIxTA2cVcEqD7F
+        k8uPaPWOke9G5O907jJdEIh0sQ2esrGb1YE33rGYJZdAOE7f1NjJNzhx6VNvppVeCcIkbYz18h19
+        9CQTBI1+ukY+XUufp3mxRiaU/faftH8gGjU3vtJWbow3Whhol+/VvvfdnavZuqnNjW/JDcERR7QH
+        p6794bBbkQfm89xob2GkRfiNGI1gjb/Sfv5PHJr9XDvQV3iB5q6Tg+trRDrWBz/t8ahf2p/9nSPh
+        9x+6wmWhzPEst8VQfIW5kCxVF0KVzWF9bg83uZxli3INwtGRTkZCjNe+e9hgZKM5InoSYLnaP0tf
+        0j/G+Q+7ObZErh3dWkznTD/euwRb7rBNxeN4mteBh0u1Qpu2lIc33JzKyzi5wXSsRTXwV8gx+W/y
+        IyF89AUJZZoH4CpHzfbBduRKt3W9TwfkILkOHKn9UFE0akAWs4cr2swp0bPCxSdSs2nKQLajeplu
+        zXUz8wGmoFpqqhXuDzGSPpKgHP1KVIwPfu3rmNqxY0+kY/OMmfaJl+xRGFWWzDTmVOVA3eqoG5Lb
+        NAYKBwoHCteIwsl5jnzHo0TLuH4HeI6dKZmVKZlZf4FmT4ma2aBlalqWRUQk/cgBxkRA4SAi0kuF
+        k/QkQeVA5UDlGlI52SOxQeVA5UDlaqncO955gYcsNOXt4BcVR1BCm8vLH/bI4iqNu7q10XyyaThE
+        nauODqdFTVOh9rEXn0j7LN0hDFkopANsna7iOk0HNHckbaWGkG+UDCdaTlGyS/Ni84bNkLwmyNf+
+        PZEmLBmfgnUpKs0QtULT6lY8A1aKnYtsZForSY2gdv0K9dkasxLlsNLQH2NtmjMZMsd1Q6y9LIHM
+        bFutzB+zYd+HVxi97xPpCofOkdyac4QPSolGCeWysiud1gTpBentn/RSh1oytEPkd36J7BgKC810
+        adKkpwCifG9sh0ryFTcFB90InMBFxs7HLDSlRTlwA7k1oaNnTm/x4HGhnyS1DQOE9yHCa1PhXVwh
+        0VzB6Z3qc9O5upeFpc7lOIxjspQzBr+Ws01jXtWSgjuo5OoTCfmUCrmKYC84NraT1RwVYFn5ncuj
+        cKP+A0jnvRBckXUok9SqtMPjpTZR3qxn3WQ5C2GX0nVdtqxrTJZVtmzC1r0yqR7V1j2fsgBZaG6s
+        UKrW0rWgCsLMCyHeJcyOsaxKlHCGCK89nbyrJfftC4KpBDOsxjYeKSVSamVHMjVw0M4lLCG/GYYa
+        SGVCml8i/uYi0ZtwfdjhIEmZowXhx0mEY20VJlvtN9/+OVWMWPsFhya/1NxgQ55BqB9lw37BjgBB
+        VhNkyr5cmm1kIseYrpAXxOTutQK2d1vn35FYPzXGd1/A9XDdWChqRn+jKNC74D4VcChnr4yDUqhw
+        RlusNB0qvMelvxFzO/Xs1S3AE7o1T43/z+YaKWtFDzpngF48trS2YpNCZfCSLcvoq154n5PI9dHi
+        83xolgLiQI+yEaoKwEW/virAPkmPqByaPeCE9O9p1AjS/7TSPzjgB9F/jOjXzXX1QtYJDWMcTmLs
+        RuvybXI/HnD0JQ9n2RIymj35hUPY/GXMt5BZrD1EMERKu1ik4X1Fgj8niBBx7+OUYOEeB65XtYDg
+        nIh8j790EqbzZ0j51XR2t/TBeP8eubsJVZlSCsWY6MzmHHc0FnYlt/Jnv0ip+5UC0ZupKpvWdDIz
+        tOzNsfarVL/zd6cYkH/TV7dPCiPv3Qtc/9SdPP38nRccEpx9PnluqYa6tH/xK3HMg3gdefsq6l5T
+        plQPTwTJNTBrnV5UMLx5xcFmH3pBQjl/2wr7ZXI0J+kHTm4+ML6Azt/EHEY57qVkdn23vLAYWD4G
+        lr8RwgRrUO7xc/odBzhyfeD06Dm9w8TmpxtVgdPj5vR+GwaY7ksGXo+e15Q55ftjgM+j4DNdOe9c
+        D3R61LzGwZY63hsVLjvmrHIX291cdvhcpu++i8vOM3O5zjoLuD1YbtdYawG3B8vtGust4PZguV1r
+        zQX8Hhq/g/DoynF4rhMCy5QP3Mtgw7F5DDbmdzKYPPdJGYzK837A4jGwGLnJGtj8BGw+JOEuTLyj
+        5CoLuD1kbtfLVQPPh8zzTUSUO9lGB2D2+JmtFDEDVg+Z1UrhMmD1kFmtFCsDVg+Z1YqBMmD2kJmt
+        UJ0AjB40o9XKE4DZw2W2DSwePYvB934eVu/wxlvLsnqhzx7E6qnFZfVidsNq7Re7g5949ASeg+v/
+        Up3zU+tZOQ8q/iSMhhXXM7D6Y+vF+5QzsuUnZqMMvrSbzG/7eaxtyYvxRvv3PQ6++U777+wLtXSz
+        cKwhLaeRtnO/aBvv7Y1ce4vCnRa4NF2nnR6U31C+Q3rUTEWKO22Bs4PhbNqhHFg7RtZSx/qwA96O
+        kbfxTq3UE1g7GNYmXvAFODsSznrBW+ROfh992W/x5IcvyTb8wf2MvreQaTNn2ZR2TmmilZ2gewx7
+        ZJnwnEJmnEjW0hm/cHjL9hCSbs1zJuMfwkP8nzhrmTP5VxztcIxs9H3WolNPu5d/W0JU7sk7jRzh
+        I+r5xm8BVjmuh6SdG72irM1vuFw5ri3Kvrl+LCLtf3zggPz1H8i2ekVDU59KUlHqnMJ25TMnIg4s
+        fYrm1rfoO27/OebY7vlsUU5Q3pDi0eC3Y8SnN8kKpb7sG0F7SE9H0i6xbQU7VPGMmH/5nmq6DEG5
+        vZcbaeJc0ilORkLZc9falE/eqKMXZ3FaGQG2kemUASt1gyqIzBvC86YkSDyTFFtL7xOq2siyp9+i
+        b6xSE/VYSpo6e2CG+FTLntLyDALImhrzEspaM8t02FaL7KkdvDEsbQuDBMRlvfk+IIEKYf9r6wWf
+        yCKud4SV9UwtnT2gslvS2gahrN0f7Zddllq9cqbsCif/wQgqLYss0nZLw1+Th0bIWaQiOZVypR6u
+        56zFETcDlzq6qXPaov86RKuwTxQuaraYxjItkB9H4z/QZssZhfspvGbBYRKT1ukvaU9OAJC2Nmn/
+        5Iam8W+T7220+BZ9fwjcyIvR0axEA063/Ltb7t8ZCJg+KEBdFgg4kzMLmaLfHqIvro/R0dKtEmo+
+        PPY3k479zQsju6WrzdLVBrrWp6vr+/QcgEno7/791/9J44BkmlP0uz8uyqjKORagxskB7BihGyA4
+        XVEQ0H4EoJaSNEi2Ubj31pO17x42mB4eh+IwCHCCfDfBcaknwDuZs87pnYVBouWqzp6zUuLITpmq
+        zLW73uLXCLub629Mbz0/uuNVRYEbDgr3h7hPLOAQVsSDhW6xQ/tB00y++0TVuwS7A6LSn2KMPyGC
+        xrRk4k/05/80q2C4KnvAG8MFYgmSyuKw1QfHVkBPwmer0rY9kqiy/oKlm6x1K4ffHoTEy3hQucJ4
+        cPZWEiykTiXrhqq/8eLE8/28aKNnBRt9yzyWeXBVBKaRiL4Vc8h7ycWRPZLhKlB4fPx8yKDwl9K1
+        8aMtnS2dz130IacjoCgybMvpE1kt6ZDDog9pHgFZ9V55ugoxByWfjDhxXZfWkE8ji7UsaF6HTei/
+        cEQ3O5YtoYFfjarMexi++3jyjgndPWTpBnrz3XiLDINRmg3eR3id7nF93bjpdtQXy7BmBLOQbb58
+        JWKXIbE45w8qMKww6s7UdA9WMSz5pxn5y+S/A4LK1508KkiqRFLy8p4R1MxibbL1+x2Hjy4UpQX7
+        yLRWyCstPX30AoXNznVdzitPS2veN1rKFu9ltSf9oqbTN2LKppfZgrQOSEm37SGfhncmp505FjLN
+        b9Ff0nppqZLzh5NXl5XW4sgugj9cGsuV8XQSVJOqkeyl6GaZ/F7StZC57LF7WknZyqBaBzvPpPfv
+        9SESVKCwg35wjzjy1p+QOf+WOFuL316oXVE7YTiL6bxiby9/UNGTZUfdvdGvB+4Ch9h/WpPvzSg9
+        +630RrWK1QJ3DDd51GCxeg8KIgr0/f3BjTaI1v/1CSKmuuyCoTiyF25DRlaHgEMpXR8dKZPfVFUc
+        2TFdf6A/5iaOVqtKAMEDq1RthQ1V/fHFrmmal6z20SGTLanulztWQtwe+mRD2iskJrIcLnTSr6JP
+        Nez30rZ/8iu7FmY50QWFvXUUxuFbMvlv7yfiJXz/A7LQ4nP53uvZdGpXLBt4Q1hysmOEURtZN6E4
+        shM34UzS/dZDlfl5CYdLxt+qpuNcOlLbB9PlEeWmh9ZNfsh+Qn/Au/BqD7tTutW6tyrPRnh7Qdo/
+        0QZ+hKS3PQLKqiAeWxApu/zqQ1hcQFwauWUJPCsT4Ee3Y5lLL3LZ8smOqfw5pfLi81XfIHQ0Smt4
+        Ht88aCgLhjAM4m2YEML+m7fz0L9ZvfRgpevUu68uKKEoMpbGtISsD98uXJesva/9D8iLvEtKwkx9
+        iSQKg94GGdjgd4+D5Axx7Qtx/3SgLWSd5bfoaOplkt7bAEN/ZPcPf/nuN999c6HtH9wgRJSyvdrK
+        Ld0nrw/FIOE+3W78vk9QGMfItIyyLri9LVJyHrZ5W56WPSOlvFj2gJQ/uR4Ko/fJ77//ATn9gs2B
+        9BmiteKXovH0STdEzPyVNXFY0upkjs9y28K7qi6bXXYKKznY6BRv4Gv2tq3Hf7aIkHSqbFF1HVHg
+        5KCE1wSsEgMVu3Is9kZ39x7ahOtYP80pbZL+48Fbf3qNEzdK7mqYTr90Qh649zHbLJ0nam4ck3Wm
+        G5BpRPjNS884EG1leDsE61Sa6NlSlx0NvKFZL3oyHSJRu/KhezeiXTF8lccTydjtk1SMygdGON4T
+        IpAvIQK3c0tGxl/iBO9edziO3fe0Jb9opLp2hpuKc5rEYclK9cluaUp9ZKItnE74wmuK6lOEj7YF
+        VVqSlLkemVIsnxbssSTLZUy4BMtlkhgtAqalm2xfzt6wnN261YxYpA9l8eCZzC9P4sQXwQCXCnma
+        pGvRAguf36gWtW+m+cnMW9U82m360GxqUnprZaUKs08erjUwdXa/aG+MgTLQH222BWFfQbtWvWNF
+        WaUqbPfV7WvQB9CPNjqaXxuSbqFMmccKb6KQWK11GBxxFOMmOE1VWMjowkVlBZ8tRBquwL5muSKp
+        p7OCa/EolrSsfKa+YHfePo4p5Z7aR6y7O/enMEhdtJy2J/ds8nLL0dDfE22WUy8JTgb+/nXth4eN
+        DAtlOFjKQB7/zk6kDBfTKXFFnJgiZCFralpsvYuAOrduDY82x9Bf4+DdC6rke7mwjSri8OoQxBcV
+        hZs5qXBEduXd3yEHzVPGWnIQ1iBjLcNZVBfm8NaDJVeBtzlvP9E6ik8WSi7Hrpim4TycydbSrtwX
+        B+pbzwEJDys3RHhHrNqm0FS/fd6qhHGrj6/9y/m12m/SiWnniWUH0WpIowzbuNFGo44RYYj24SVb
+        zZrODG3j7cibb8MlvPNqL9RSlp181BGvkzB6jb2f6APpy0u5InFe+yh4k06TYQxB+O4YQ14uwRiU
+        0PMpLEITczp+Jl1N9pZV9HWdsYq+XJ5VU2P6PKxKJzsorTqJ2Px5mJROts82CX92X11vkh0WfcsV
+        HsGz4byCk/wJV1cSD0d483rKd7AJjVvi8uTgxwOOvmTzum7JdcPFCMcHnzpNbpCa0r8WhtE/RvFu
+        +seaFn79t5vf/P2r+p9s3ffJ1oz/zaZhVH30/7j9/YnVb16E15H74Utz+3xHBww3ZxwCKNDPFJGv
+        RZYbtm3d99GCr7Za/WpnubhPVAVfbbf61bOZc9dX24Kvdlr96oV910c7go+etvrRy+V9ujgVfPWs
+        za82zdl9yjgTfPW81a+2rfuUcS746kWrX+0s71PGheCrl61+9Z0mZim0MQomWs3z/N3JImuZ+dVy
+        Y/u19g8LW3sLI/ryrwzD0NbEFHtJ/JVmnX7UyPTJZS2fnK79mtBE+5W2xh4NXf3C93ZeMjGNX2r/
+        RG76J+0fqOoTwLryUG/8CfK4vY8/e8kXrkMh58xx/Y7Lk0scj5tvob/7HLxLezb5eDm/RjwTNeb9
+        iTz5f/7h95oXa26g0ZJ/lKWlNHpzztBsXaFrv4sw1pJQO8RY+9jigDDcf0Nb8hF4oxE+H2K62tgf
+        Vr631ryAxr/WONZFzMI+PuLAd1fxJF5H3gq/HsvzNTFeh8HmhaYmTZmeuJcXvEhRZe3664OfVr/Q
+        24mwWdZkS8hBJDKVPHs2m9Dm5Ak+/YbYfNNMpTj7OO0XOEiIqEQeoVGuCL98+UpA/d+mH/g9+UDt
+        TykFtKOZBQ4TjMI3lGwxcqNEi/cYEz4QPQvfA49+X76mS1dvy6XmE1A4uO9Yy6Ox7BvDyCMsdP2T
+        I5ySk84slRnLKl3wuYeNF74mBHgom/ZVCbozl5hYdiHbeWGP7oV31aClXzi5+cLrOrRKqXvFn8mX
+        0/Vv4voggto1OYg84mBLNfkSyA7fNCKa2s71gtNdqTyC2MmIXfbjK1t+x0jaeutG7jrBUW6gDLOq
+        /ul+WTMXEzM11Kd3x9ov/kSGETkiCHMSpq80M7ffqdSdB0sJWfajdrSJXO2osSeyRqx/7B2x9l//
+        9adrXJsb//cZ2Kh52mgpwbXEfY/PQCchQhl6vjxUKPJ3SgvDjrg/qctzINrCbgB9Ksn44YoS2tEi
+        YrLBby75JSse1vJKOoYtDjSiioiX5XvxFvne+zahJw/LVc7JNLRfh1scVZZmGZa4ZIe5VjMUXD1r
+        +7lm/Xgu19jN1OR8q/jr7dx0dZvhmnjB06kcVC+rfn6uikgnlL3s5+kqSzudokP8qTcP+xtd+zNx
+        1C53nMnN3EvWU9jd6K0lZ8o/4EVc+FEcxZGAawPXgdiXlOzwC3YaEPrbKY8R2VSlp4pIikagABLj
+        pdXhVBcchEcX0XnK19bPpXZPKBZy29KHIYnpylxULJWzdbOw961ODdzmrRLhWth/fUyPVJHgddp6
+        Up7Zji7TAVq1al+qK12bzDb1hXDPzOM20pfxaa/CJVM3ZI5JG5xOZttRb3ZWKG9yGKM+B8k2Cvfe
+        Wl/7ZEGIkY2maOt6nw7IItaFWBhLXnaKB7KWiE5lVbuExLS6AbJwCF7rNc/dyEdFdTRPSDIBcYio
+        ECGZEtU0OUJSvWnX1O05S+TyrbvZttSqHZrngdcPFh4RahrInL40i3dS0jtzSvCucFFRfqeF0y4r
+        8c5d0dNmyC8nH+QlMQrwx4Tyd2Iak5zxzhkdzjKBsicgjlrXUhi61+qQkJkcYt7OtO71qslN9HIn
+        F98g+NWA9O4DfU+2Fz+fxMXqOrNKVaZ4TyYU4CQFfGNmGfKAL3P8e4Nw32K/m6wZ2/QBktaqcKiy
+        O7PvVj/Z3ap1F7J7VFjVrajNr0RtaljmsrfIAqI2dLMoIY6XZY1hG/MeL2tatXPiZc3IDF24P8QZ
+        ty1LAXmK+jpcbs8b8Wq6ZuS1e6rESnBPb4f2X2tTnXWQmXkMC2NaM66wmLP0qoorsKjYBDo0Gi2w
+        rZJoQeHi/UCRFtjSGdC9ecV6Xia/zAynG+het947LS6mteNfVY/2ww/5wTu88Q67fPx5+N95AghO
+        ViexB3O6lNX2VNenpgO6DroOuj5SXc+duDu13dYVEwbsueOSniK376O7Co/4lWjfp6swPXMjV+m4
+        d1rZSqyIW8L5cx8zL6BZCUGEU2i6l57Ref6D4zEDygHKPQrlssyoseQuV6txztHNQpymAuh0WajT
+        64Nd4aQVFbhzBH6aGt4tigEsZcCTOg9qcBlfU58B5AHkNQl5nAQyLTHX00PSaStTc4W88zGo8hFW
+        FqrqB+a6PielOJc6AlbVIb9Ad7se3Zcjojs7l7bonh3+q+/zo3+zDmo0namQQGq+oLJr+rOOQBvU
+        J7+h3bZWkedO0gZhSYjSavRJoVE4tx9TejuvaUFW0v6OAxy5VZt3r7b92Nedf+T32aVPiCeX1wl3
+        4uYTJv8g+o9/+Exrd8kz2POlHzJdp7PJooNPdK2DKXMkut0pT4iBD7DvdzBXw37kZFdfyMPpVv1J
+        jAnSYXc3Odq3Wt2FRndDgk12EpBLSKCbz0UEMovwPUq5P3b9Tu8LnAlZsRw9/DF+g8VMmPw6TjqY
+        tdXlnJ/CcqVdtd6SXiD4Y0U8TtyVj9HGe3s70CU1OtpTdI5jjG/y2E22OPJxHKdEuPwnJcZ/fODo
+        0xc0t76VmPvNk6p2i3HOMWhqbaM+v//4+A9kD3iOXoQ/wugTnRJydHNF1dWcMUeml6xcqwIG5xcw
+        kxYeNFo4HufmE6ez7Avnkp9oFjb2NfGR+VPFn5kGlqXpKBN4Uf3EZTkd8940Up9X3Ttc9ePYvgM3
+        n3Zpcm5OjR3ltk3+leS2zCbi66+9elvaoidu8PMP+1RUZT+ebnZfdvrpuxDnHz2VlFyZ0mdV4Sge
+        kHXzkdkHOr1EKGom/pu2bfgu/ua7yZ+/+S36Pg0I/kXuPK+GxZdjV6amcCMDc6mBbhGFHYXnL9cJ
+        nU7NqcSUdNfr8ED8lMt9k2ySzJHt6Gid490PMAo1j2Nt9Tjl4owkqS8ZpBUeL1w3F8WJ5yqyXvLc
+        dpkqbwVOS0XW0zPXRKwuXFRkdeFczvqM7pJ5yJhai044OJNpNsEbVHL1SXm4cmNvLecoSO2SGpQi
+        Wrq5HAMfK/q5NrFIqcu/FjdeFhLEw2QdMmxL7rjJpvnXgwORFXmYU+9CzgId+8bdvZyPM5UqWRuQ
+        cvKOH79HP9utqbqbySjBEe2NHgO3x89tuROgm2dyD/BandFlkE0oKbl67arYso6o0F+cpoAqGqq3
+        ZNo5qj5Mx+xBu9jrsDk9FH4vd3ZnN2un5axkBVy42PraqYAEJwqOEAPyqSHXi6QExNLviXP3UkAW
+        ae/fchxwo8R7I9rv+m7g+l9i71pQUhqijIajFZFZTfxQUMs7JckyqChVhmk4g0quCmTpUZair9Iw
+        v5WGRra+NuyFPlIcxEKumCsRmJ75KCVpn6AwjpFpGbIFFk07J7ZpzKv8T+6gkqs19i904YP2Vx5k
+        xWGqmMAegDAUmvU/rTB88nYe+qSYbG86jiElETRSURrGuMt+VPdOLrcfBToObPHKfj8ylobcUrZp
+        d2JmmQ7L6GK7nJJDdAoXWxAGd7/X1QQiI+hApSLZesGn7NP6KRDcQSVX28aHHoSweKM+8Or1fAb0
+        nULBRroqenB1szbpgeywtS79l5w6QpFuVM8yX44xXan5E10UdLXqTzwdzxeKHJc5WU41E9Ylw9n5
+        jLVU88xyC5nmCmVtRtRY33Rcu2vWt7uWbIf1vGHivr01ZAPgYHAycSfLbWD5s7F8adSzAG2ULXbJ
+        +r7UnbaH6g7auUdMvvvTJZ4hXyjefC67ByFkmWx2f8uNc67Ga3oAXA2WQoqoZwzdeYFHqIF2Fltg
+        XJ0zvg6WlqzQG80ZOzI5Y86gkqtt768rhHhvaD6wtfsu7263+GxZV60Ft2+S6g+7LYcZs/nxAwcW
+        mluK3nrDLptML4xWczztVqT2x1tP2b2f5puq7Y7Zzmlv8sAOls/C8y9e1rNUisMNh947V+x2I++P
+        ZjIUAUIRoIrdh9Rsj8DisayHBSAsAItSEYQ7b43OP6Stf1DawvEotw+50Q5WchvThNd60L+ojJ66
+        XL0cUPSGoskWBz55/uQ9wTQAKee2tk3EQTXVuiGhvOsPrcneIg8HG9+j2I4TF2W5LVs30dxQXClL
+        eUfn1/V6t24hDF7Dmu3diIzBfjsWMD+8ZofjmDa2vcNWCgWglYKmYfC/kMkeMf+Tr1fuakUeggxD
+        bmO+WTgSjXua2spNyCxSP1VCMlIPgh5j5eO0SUC4x0Ejee864bTzZ0j2f5A6IY6hB8uFjXv0grWn
+        wAWLOfmsggumRJxryFxgyVHFBbPY7Dj5mu4Ms/UpSg7RKpTig9TJgldvLdTR8/ggTfdpC3SveRxS
+        Fb0LoYY2sOyGf8gwLbkViUwMeIg8eQSNZ6b9WBp3m0PpgMSmacj1RAAxVqSxoya+0yZoK+Hatkza
+        m+NSz4vGfycf/813WoDxJtaSUHM3Gy1fM2pvYaQlWy/W3hItXfd+pX14vq+tsHbYb9wEb7QPsgSn
+        95AfV1+07GG69pusIz99BnkkDW5k92sNRZIbF4iQHmJMxGKBWJ2rSCHoi8Ix7SJJKh7oXuk0FB9e
+        X7c73xtUPKe8ynconvj+qCVZw+fgPmJ9xxtVUgR7K/imSf7lCX7Z0d33Cf+oJBnkUhVvaQopB905
+        Mhc82RODLluDK5m7k1qkVYUsBiOjbJKvCm27Cn+ORaZ1iqHWFBkETh0VeZ6ryHNHQQfDmU/nVeuv
+        Vguc1EM9TZzcXEughyGsJwSuIbFsaLckWamAv05j6Nu9tNrK8FsMKIO83shr4AZhTXllO3lJ7tCW
+        CK2PRV5ZVa2SVlZXQVZTWQ0dBlbVoglyiylHPQ/XiBNgGTKnDfEGlVxVb7uu6AUUurQ3LKnC0mgF
+        UX1g2ew7TgXU1A1EPvClLAZKeBK56ySVEOJ9VTipV6f1EuGvluKKx1HRDNOfYrwOg83pyRWCfMRR
+        gj/Tkh3fDd4PNMEtVbFD8bODYyOuSZzHSGR6Gxc9+2IV0NoPDxv9PQzffayvw90kIw2t4Tudh3zE
+        6FIh9LNs6GuRXI/CdiXJRYbBFHJu8D7C6yxaRYPTlBgnHDaWL2JRAzl/CjnfhOt44mM3CvKC5p+9
+        hYdgkwnMcKTeAqkHqX8yqT/nMcTOyr0CWi5uebcXgbDRV8fp0zOfj/KQXc3VqJ6iGz1EEsm5lumU
+        j4P3hHa5ZIU5vcx+5V2e+DNKKW+UOMvGFeMGPRcQehD6Pgv9wU8iF9aY8iVAKtLfnRPyTayFb9r/
+        dwi+opuXHV37ry2OsObFWhBq7tH1fHflY43ItxYGWkYuzfXOdUWshFBE1LU/x8w1QvPTLbr2+zDR
+        LuTQvOAt1Ohbv9bGq3elalU0I6BaoFqgWveo1hS9+W68lfXOlsgq887cw8ZjdICNxVfc8equwiN+
+        Na3Fp6tS0PJn3Kp9VqFVkvs6D+e+y6oqTTjBRsWulHSYcDYScJPVSFTl8LhvqMiqcJCqYjLsHVLz
+        ugvtMrnIvNzXLQGLFPN01pe+iA/f2RW47XYxYVNIUMqkfjggTGt7Yu8n/LpbpS+SDbAUPXt2IlzP
+        vk5m6VpfilImHM0XNenTCdnSNH4Wi/eO6maNQ0frPtbLsiZCZRE/RZYDZgLMBJgJMBNgJp7NTEjn
+        65ZgJsBMPIeZcBbV5Y5gJgZvJgpxFbAS6ZCClcCf90RQLKbfKQSeemAqHH22YJuugbGANUXTxoKn
+        MWrmIs9AlD3gWqjTwcuqwdw3LXW7cDesLzqxHMRCHD38QRSe3RED1qMH1gMWGmA7ipfBdozddnRi
+        EQr7eZo0AbZuWmzXizpmYKZXPea2qsKsKlwpF+yZUuGLYVtEtuvYg/Tu2bTs5kv5hyXVCEhs2NTM
+        gszEpGwDb45NFvFYxnJuTjtoAMuplCrbuS3je1Tu/H7JSqiqd4iLfAN+O6+xAKhMU5CeO+iKm9TU
+        s8QAyQDJLUNybQ8aIHl0kDwIuG0x2wpwC3ALHvAzwC2zpgasTYcwWHuOPFvmVAF0IezQEejO9UU2
+        qXrRaH06q5rSkJH32RxdnoQrVI0UxRv83QY6iIkg1jGWALEAsQCxALFPCrE1gbPVqggATgBOAE4A
+        zl4DZ9O+qaUbvE3yFf3CC2VQAhyeIcNGtlmJw2fgKNf6c8CRGTbwqqbxbp84FxlVarDrndR3g4/n
+        HqbWqyHaaYA3VF9dwnovVYO/nkeko+gZmFd3ZdKU2kHmlylf2V+mBHg5/+5v3Nfnk633FWXPjnNh
+        q0qYZ6OyzygZ9lwtvHmjDhEZFAYpNyRDpbwBH3hF/AY3Wm9lALVYLFAOqpyavYZQVbIPudx5OYCr
+        PcLVBrd7iY/yewKkBQxVSyQ1gI748/5OdKxe0Rvyo/krQbklvMww1eef1+y1lup1wF56fV7ydN6y
+        /N7VONij/tsjkTaohRTK7hRZPPlAwvXTwU4WvwLsZC/tJMU8FUPJ2zzUVHRGavcbdyAg99falH3N
+        o1cLbFuJNoqsLvHEIQMkYGFvsVA1rAJ4CHgIeAh4OE48JNJ3qSpDbFmZzDnVlRGVa20piSKfAhYy
+        h1q/1Ok3zz74CSB0Np3a01IMFUcDePc+CmCZ9IPcSd8vxb4k0X7HfoISRqeofAvUqTigCL/hCAdr
+        PMl06ozWqES1uAiKg80+9IKEg5yTozmhlJqQj9r7mMJYzKJ0OubqcgVeD8RccF/4cBsiseW4ozNd
+        h5LfvBqUpKpoTWnlUrlROilNKnvopH3scW/Cwj3TRObNTj7VUhQoMHmiwDMUmECBSQ8AuGnHPiEz
+        /UQmW8ySinGT+C6WPG4aukJy9AVSqZybTthTNQSSqGDLZGzZ45KolWPaTKCOPFRW2xiDme3UzCLD
+        RJZsdycwtqIbwdg+m7GlgUZ2jEqQkr0XzC2Y20ea2zfXj2XtrXBsywa3TvBR+K39tcp0r29qiol5
+        ZZrQVFUHV26ivcpGKDSrsgyjdM/joPG9dnuqASymriO5laknLrOzCumGmlKVVo1CDonzFTIYXhW/
+        7EFT20GsqqhKVk2kKZTnnsldge4qGR7JzW5s7c+ggXzc1QRn9+dSJyDde6A4siozlAuqu89dZ9Zp
+        Zk5qeQiicy6v3IQo2vNAfS13vcdg/4zlBKUGAZ0iR2AWmjILtjWfLZghrFHgjSm9WGExmjIKWZDw
+        qnqkBOyv+hvZZafYZM+8ZnXZyqBZs3MqZWM6/6hao1PdgkB7wBgJX9/PgFKPLdSYrA/LkqyabZE1
+        4pIwS2dvTyY9NKOpJHMqnx5SLMSuMGVFlJOIio3K7g17OdRHy1d1h2hcQ1YP1mBg9sDsNVTDXWL1
+        7DQDU2LxShqLmteAJ7AyFefOZkYx1aqUoKyha7IJJy/zfN/a6C74Nm2natwlnUz7k5pWyXjFnTdX
+        JJ/dGS17ZJ7jsYjcHc4q5aG7BLpmIkK2bla73mUdjqc1th+OGFqM2bwMK26xZabg6JXjhGpq9OTd
+        CZvwAoAAgJQDyAbjPSLflQ64aRxvWojWbYIzA84MODOARY9zZi6xCuU+Xqq9GWBb65CifOpFD+wW
+        16a2wkKw7eHBtnKIHGdcDQoeeBbh0mJkyfFQwUKAhTj//pEWgtgF7Ifknji3FCs/fE9X8TiYUE3x
+        ggPdN5eEaBXRH76EB0SeQiQiwXGSywP68JItcgPk7aj84A06t9k56YAbbK61IcI+mRWegJERvx6M
+        DBgZeSNzh31ptiwBKg1uxgzTwjRbeA1WJv0DVgaszCCtTNojsWhqgjy1Q3n/ALsj2XAU7M5g7E5T
+        7UP7HO8fB/pzXyhjEgbSeQ5KyxRtwmSspiGbF9iBIdqBZvfegHkA8wDmoTjgrspjUVZkhsz5i3zj
+        6EVrjaNlu8vAKmMo1gUy7MxlCEux44ZlPyAsJUx+OAUz0sxpw4q5j6c8YX089sGWzn5Un8sOFuL0
+        O7AQYCHaxP4psox2lhCQIAcTAZ3J2MtgJNhxYCSGuowgZFNZNuS9ha/Ru+SGkhbDxSesySNSeaj5
+        FOiG/NymCvohP4EparIf8vMYlUf2P7avtyWrmBbrTrvCxqxbtSpSW6NFX9nVnmqwPw+xP5K7uPkW
+        aNH4DvBeWixYVYEpY0Z2a8p4g7Jartc4ISTZcQnCRW+iR2HkJV/SeDqrn3KG4voZc501NnxMuLrF
+        0k2pNjflL7Z1y2GeUmaTC9OubcyLs59zRQtHRyIsr0QPozKHRDfBJQGX5F6XZIgHwPXDJSlp3MU0
+        xoEeW/kocGXAlWnUlZELK4PDM0KHB60PcRLuqEzG4PyA8wPODzg/4PyA8wPOz+0ogfNzY2HP0D6B
+        bEfX1nW41hSyG+X3QnYDrCJYRchuwGK/ZLHPcUVui2MVnJGKIu8T9ld4C+W14GDLe2fLmz/iAqyr
+        +PVgXcG6qljXpTTaXt+V+dhK9nSqs8s0SUO4ZMzGHbYLcvSwkIawNISlwUUAF+FZXATIyT/lMh2y
+        8+D2gNsDbg+4PeD2sGPA7QG3ZxRuz22HAYQ/75FhI8XTv9roNQBdAiD3AV0CwAkYULuasTkFZYbi
+        3NOsaCzEPc0sZFjyPc0eYVYKfd1ljAuYITBDzZoh6K52+l2PjRV0V3ukSWvFWE0J7oKxAmMFxgqM
+        FeczRmCsyGMi/J5SoXDzux+uXB9s3XPYuhnR475F8cCCXQ0BCwYW7GYMWDAwQWMyQUmiVCnzeAM0
+        h5wTWJ+eWR+mKIXRKb7xuXfFIAHb8gdmdo/bQ8jYNIG3UbgKE28dIxwhM5UT5U0ZRjX6sYfANLeZ
+        sArsGsMe8UVFYKg+U0XmHJb7HNIbrqPpQ93SR3ifmaPJdUmfyvtkUUz4If12LWuck8LBusmwIY9/
+        ZDvgG+Bb/kvAtyfCNymH72pQdmS5NTVul2dR+mtTeIg5FexDQrToEF+OMTcNRNObt4DZ/3VvzdWq
+        tSiOKQCqUxwjvtirlaR09WIKs9fyUHMdycW3h6DW6eNf6cc3UjDY6pqOp5N4t8KbDfkoZBimpAKq
+        HdJ8eYPUgsoiDodI8Nlrudyf3yAj/EZxzBGvkzBKA0GpBs8b2sqTCrhP8DPIvYkXHgeyOD7+TD7S
+        2+Egcf1SNhAlj9x1klJZwms0GgM71i80jGoYW5hLS8RM9pokiInmL8Pve3m5O/iJl2LGyV28YZuk
+        7gt9ijoeSxEGeDJWOKexRKg4EW9m9PW+N2taLYMVj8sCqfSnGBOnZXN6ckuSa1vzWcdya+tzlibi
+        HY/VC5kG9gu07llLyykgISBhyxJ2dorEsnUvxJULWPYBCqsKkw3AsDI4sxdsuo2VQBXHqpjeYoWX
+        m966Z03SJM4VHK+fvYWHYJMV1Ap3VHeAgfdEHdvy3KXCgn3z0k9hh1sgVo35nT8x/lkqJYgIWMyE
+        6PLAR476vDjH6bHmqUjnRa6421gia/lSjTVzXabjZr5+N61FYf1eTwKGkeXn2FnZJD/n1i56alZ6
+        hVzOstu2M4Ww1PShIf+wfynsTGcdeZUtYmpFi5uXYs6lqrBoMWf1WAwNU2Q5AA2XYQANw4SGAZfB
+        1MEQq08YsgQMuRkGGAIY0nsMWawaXj1URcq47K+KnYFKax2pdGXgr5Kf0VkmQZVbVuWsk9XCmoNO
+        19fpmtF20GlY/Sur6pJ4zKCqYH5HqqpPZX7B9l6GgEK3rdAQec8GqOupT7QwjW5BzuxqCGgsBLVG
+        oOKFQsS7NdsuFI5Ia/a8qU1SlrGcm1NWER5QAnap7DDYwnx5NbB0dkPApZoCTJiyfBdTx3endUHG
+        xyXjzwP2xRzo3flJUAZQhoEqQxaCkDcP4AI9pUaMRdCHHGvrm3g3FZcCia4n0a1EpfoA3LVDRA0D
+        d/UxWQDc7Ym5pRu8vQoVp4gWgqoCjZjRE1lss0Qj6rVAhLisrE52EJdlz4itt0Xn1HnQejUy+SxK
+        /3A6zHK/ouzZskdSMe1zGmhEMYBV2cOa3Ejs9Trjp2jjCGAoYChgaPqnIwxttrlY/+Hx0cBH1vwq
+        wGfoJav5C2hcWoLIj65cCtdrJHEepvr8czOBiiGqz20sLCLRkEV+NBQ8DcLEyHYPkZf69kNXpTbv
+        ju4QhUXwcxvI51g+NGAfFeIqiKKein1U2NupvDSQKobjDnw67J6yr+m6vK1WvXjleQ43Ujpk9AOg
+        K4zqAOguB75ZhQPfmjvctAiQAHtjdlnLIXFWGRVp0EN8MqCEkEkrIROfypt8uSgFyKU8QFbi3S08
+        ZqnUkmT0KYxROfA2va3W+bX48LFh71DPIbuVlkXloRyX/D47Umo5r3QcJipoFBcbB3gwx8PjBTXO
+        VGvCjX6eYy0ffDaHlCE6ueupCKKTM8T2yBUbJhOZjrxhKuY8IZM5dp8dMplyX/H/s/emTa7jxprw
+        X6kovx8NipuW6k/u9jYOd9+x3R7HREw4KigJVaKLItUkparTEf7vL0BSGwiSCRJchY57z5EPwQX5
+        ZCYSiVwgildFgwzAdo8JJT5o9eXcuacsB4c6IVUnpNNYuui2hR0jsuVh71VnpOqMtJ+lVy2q9wPk
+        Hh3crqlIN5Ap4hlTKyvvRrWyqpVVraxlY9TK+sgr65A9hZ2tvpeU3fxpvVpI1UI67oW0dur2CLyr
+        41tGJbXWLUvYhTlJ+zuc6m85oUxZNRF5ftTSRYfbGq18sbFEDo2gIQoTPzQaa7DBxTC7CU+BBhzk
+        R94cNkkMOrhULM1OTzuJOeBcXjsxkcUK+30k2wehnYKUqLQafTxVsAIzSsKasYKvGehsij/0ysFl
+        IFYi6i8vtEs62+GVXVx4Y0ovVqw8shaXdB92E8VSsmjcNHq2XqrG3YFfVmlskMtXLunjXp7U6lX4
+        +pHlpve/pKnlihWvi5EIOdBa0MMvY95aqPdIlrhH3RwNcf2quqNonNp6qcVLLV5jW7ys5EioZOEq
+        OhzRdN241XsFK4sJKXuZCFdC1/opQcy6wDvybraraaSyDcuuGnd1wBPS6oZZMv6acGNCamLeHRBW
+        PfYGjAUDRs1tyARVdn+KmKMsC5Vxr5pQXHvxtNQW4wMin5eMS1TVOYHFMBENCFPKSikrpayUshqC
+        ssrtWYQrAYls7dk9+4Mmyw11ay9+7skmzgkm2M0bKL+iTXdx7YtRa8TOd9yPuLlWh53PoMzsObea
+        0gvHulWLh1o8elk8yJKBvYA8JsoWkbUXvCdRe9ifUTly/SNN5okDtA7pj2/BEZGnZL1UULq8oE83
+        3iHHR+6e8g/eoktRj7MMOP72VhpC7JGJ4plagopfr5YgtQTJWoIarD7qXPKx1x8JUS9qDVJrkFqD
+        HnMNygSO03pPLTtq2VHLzq3AqWVHLTtq2ZG57FCBE197BIsbKpfbxNYe5XK7+U+tO/mvUOuOWnfE
+        Tn0WyFg+wyvxrlqrxFtRzl0tVmqxUsEFaplRy8xIlpnLCmPnVpiKhGpNrPUS0MNm5BqGqKVjqEuH
+        BfaxLQpKv7eweHSZDqaWiXrLxOOo/J6U+RyZejvbBXWu8tg6X0YRC6X1b/9Naf3Jaf0hG/pxIgbF
+        qXENVXKmWFL+iQ4Yb3ZlCqZYWQD7ANWS+OTrZtnXcQWhKNnsrMIqSE6IJLKXMjST3fWU3JCV2TR1
+        /abMplnVaPEm244ldUmtWd5LKm8l0AShG39r8rbbh+Rfq+yDYdgHt2ZeZWkQLkul+/3qe295qt7L
+        7tmSfWtWmlZa/+Cy6rQRDk9kAXklq3NYqP6V3VLfbhlu4d8hWy2dFQdeQQpnUc49xjhEx+h6Dmbo
+        1bn97Sx0Ain89dYJc5Ufk1sm7PyY4os96nCgNi3f691ywHg3dp2ovTOpXimppOi9rhxhQI1g3Zb4
+        EDGtzYZ2NXvs2aRASNHzO6ksogzhTgzhXC0TETW6At1bXNqkOyNWncUrs5UZ8yBmq4Dzw9JYARX3
+        fSw1dmmp3B+bmrFovkW2NNNmnlK2duamXXvRzc9+yWWj/Ca61H64PycQsCDaOO9SMQ7DXMb5RW8h
+        p13suFo7oGy9vTCtWniLXz/ccy4VBNfz2dhlkJ9Ysq9RTEiy5xKk5sr+Ur4rvFkT7r3OK9G1fK6x
+        G0TgIvzCrFp1103NUDvvh9l5j7GN8Kh23iLBLazoKVug8PVqE973qt7BJlzQgmht7Ve7esCNHe3q
+        71Uk2hyjONhTjmVinJSloiwVZakk45WloiyV3FBlqeRGKUtFWSrNLZUxHjykp8Gvjos8x38/0gZQ
+        qb4fr7nw2GcR6thhmAu4OnZ41GMHdb5wnyyD8NcB6RYSKy2ta1XWEGgQd6N1f9sUt9BjXBP5oMK3
+        z/f3pVvh8go2g4yVe5wlcrh73AnvXwVyS2+9rxz9XVx1wES6Ca860EWC5P1+atlHNqVaZoa1zMhP
+        iTEaNkHPVpnf8EWQv/hMaDkYckGCEZeYMfTKduA5ZT8nqkspe6XslbJXyl4p+wm5seovCQsiBCL+
+        G6XolaJXil4peqXo86OGrOhzJcSUmldqXqn5ftR8cz2dLgLdK+rhK+Fu1Cs9+zQMw36GVDUCHmYa
+        5ur22GvCamplvJg1tRTn1sZKCsfO1omdOyyTK34QJxz5/A8nxk+eu3fj6In84xNRDcc9Jiv99ukt
+        CJ8YptCevo+iI40ieIqcPX5yovMII1UfGmu+lfD4ZeB/G+hV6MlrMQtetamAMi0rqCegdYanTO5K
+        jVapCZN1uio1YeovS2POCvIjqQnCFEpNKDWR4k3+2jvIROZyjdwYpCysBj1XAHJWeE04b0avLhIN
+        jtdJLHKP2G7+OZvlLTj62/T4Kh/vXIeJZACeRmFwpALAAi+KAx6UA3L1x8G4g40F1sciUCD1fv22
+        zOWiqvBptzwFX65Mjc27CA/bzGrJQ2YtmngPUo6c5WkqnTGznatZsdJQ38WFdUfCa/rSrOI1k2w7
+        i3iNvTZeXpualizlVrIaWhCD6LpHifAm8LflGyl2dKVBy9xPuCZ0NnHCvpBhos9PT3yqh4g+V9oe
+        k7kp3VRBqc+OlrijZf1QlkHURvcrVBF/FI6rJEF7ezXeYhbFVEBudAxXT7TgWW6yeSt8fw0lxdNG
+        icT5yNJ09OZEMcqULdHsunGvm8Qa7qSSfFbd5BNKIL0oBk03SzEUTn6omHHPk7X7mqz5DO/Fpz+L
+        66yxkMV+OK63H4nr6WSPXhw6fU9ZkoOgbMqJReztz+5V6ojFoUsdtI6nbExlY9ZwgiyZIcrEnKaJ
+        KXEbzNNMJxwgU8aywzuRN9ljvcJrGQemIgTT4FeR1KzyrNxyT1kawJgnXjfhNGz4ZBFG+S0At0ZM
+        qbFo1jAW+4S13BaZCqoPBOjyEeTUgMjpCMAyHgOs0eP0CFqSlakxGimPJk9jxGiqsuTGu+OazPjg
+        ekE823hkj4PRznE/jsjW5gCY7h5QBRekOamxKGlOmrtYsEGtXzKnjOCtF1Ir2ZRxgQoOx0jhNBqc
+        FslipcAaA1iQJUoEppU+cpREyRgFvo9jZCt2Zwg5MHY/46RWkcEidZ/o1wdMUjrGD5WuJU3BFXUb
+        UPcQk33fHMXHcC2daRfWit35sVS19Rc26a/wWk2agqeP9IVhPSYNZBsA9IiTDawd4rTbgHw0c29L
+        nfI0ZQ8EqKNLK4mmyd5yAA2wvBYpvtjz2gM/LhdapQjpUXJ0ptuIzZ9XKHSGgoHOFG2CwJk4Fyv/
+        ufLFsq2TEWup5igGVJRsWthT+vKn6ErousoVTO2EroPVUFDCGVTHK8LJZcnkjE4JuRjBMkFeImOl
+        aAelXT/eSd6gkqvS/ZO/zY85W189Oy9bMgLnbaiU6Tnh2qJ+P3tQmaRXQgaCmWy1tvgLEUqPSK9e
+        UamD+9QxNZXoPgLMViq6SmxHjycN8EN4v8bbLXk3slC0J58hGdiV8cKWlSu8luF1+aRSzxn/65Hr
+        v+EQ+0l85Bjn4WydfKb1gL6eqkCiCM46H6oMstuUFuhfCzAIdopdreW6GXIPtmbfoytkZysZHTqK
+        INfEuMV1QiC+u+9Oon3+TH78nvxAJvrRjRnLBNTvmW8ApI+XAXSLhQnvJ1IHP37qeSWpf2J1nqJ0
+        PUo35/q/Aet4KijageKPZ1s+6haGuVFIYOZSbtMhTORs1Alv4iBMCqI/p0l4VSRBpiJKjihUeP/R
+        LV1qHAzKpow5XzC1N/fuzPHjXUh22ZvyrLcC8oDaK+2rEk3p/Cv1mWWWWGu5i4Iazcw1E6qj1Up0
+        FY/SRbkhRaV5J0LrfOOmDmmtKN02pVP9AaJz/vvGSullB5QODtin1e94jq1CAi+noqENzRakcDkB
+        DSABc80HR0tAmeRTxKtPPDYguoB6wN6VlcQDFcaWEkYpi3iNVCM3bLJ0/ansWTACEi+Yecgn8Rbj
+        Q4TxBy25+gfy+2f6+18WcCEytZUcSlM6dRITXERpW5DSUEIi3TJhVtN0aLnKzUSYmmlhIECucREx
+        5ehYcK/eQh9A7qKwfWS2rmZZYr95TrQTIrckfds/udktonxi74PAj3ZBTNTEX929i/5qon/uXP8j
+        fWY1qeUoCXNhGnZVHnS71kPC2IscfX4iPPiT8/X9X86/0E8m0Kq35HDhy2KhV+UL90Kav39iP/nD
+        Qv/6EZnW/Af0vWn+gP7iR4TVNjH6099WHRJqCDxkF8lruRD+6rgoCN9nf/7xJ2RrSzDhWCuhJuF0
+        c1nZM7VVwnH4K63Ed+7XZJjg9oUv5FmrCpqs8TYMNh/kZv+EwwgP/CDM1F6KDBgpJ1z3tBZoFmpq
+        ENEdGbWtYnOxBWrbYGLb02PsFTOlFgj9SnZBswg74WZXSuVfjjj89pwccFW7ii9P5iWtZy+7/xYv
+        WDuedvFia8x5AZontQv0F/MFnYzvmBTXjbPZ4ddNiNNC4TcgJt+f8GzOA5veRO7Zcm8AtF/k2J8l
+        bTdMXb9p1rAQaG14f6eZuvPmuakUzp/7mGXOr1VCkMIpSFZtSV/CTrIxBM5qEnalM6BB1HmBYHqS
+        M8OTnuk7932Xis5NDHThaC/4hA/e46173GfjL8P/y9METhS5UUxEjCCE39wkCL9Ia9BQ1iNtYXKM
+        yvpriMTHbd9StMvGJP3fXykjVgXOOUQzyAqua9hSk959pO9JdXI2iavP216IqbpE0c0NWym66So6
+        Q1eaTmm6iWk6Y/4C0nRZ5fXMpiOiYNRSdZxzzXJVZ8BUHds5ehJ2DUspTnn/z0hz9s6vgZ/0+SOK
+        8Bgj8o+zT/KKCPn4c0bhmhn6OcSEIphieYEYpU9AGX24VQOUdA7KDkkh94OTg0xEeb1QGIvkKl1h
+        V9WS1YYzpP+FNB8hMDG+TLuJVH1ciaOhuEZug/OpNNgAcLg6r2AOCbWCym2sxqwBhb1J+8RixJBu
+        mPAwZAVbk4yw3qG22LZFpTE7VWYSCGwCVlU31xaxZiMPhgNFrrLyw0IxIgEyDLZwZUELywXSX5C5
+        uqVLg/3IGLSqFHhHqFONxQdIjiHpDmPAufCMfwBAwLWqQqNlNNwsCkbiGpdUublW4UAgfDjHtzLg
+        uVbmhqpGAK3ImsGWbh8qwVg7ovCaRILB08qqTrD75ByBWPOmcab96AA72VEKNfwm1pKFzAXQWpKC
+        Lij2o0V8WTadtrlEeMICqrapy29vAORMowJhnJOhtD5/tTBOHaoRiBXdkCpVW47vo6nahCdSf70Q
+        a5A7TZjgT581pJ7XNMGXN6r8LMZGlglzSbCKrzaMHfV0K6nKout3ZW96l0ECAdzkUTi0iwPUKaRw
+        aA0H+OHw9NeWts2OMS9dqUMsbS5E/u9FsYxiGRDLiORHK36ZCr9w2EFtfB5248MmppfHNbLhTGV5
+        A4fQDUI3pmHyqzQFAxBpzJ6Ic5Mq1k5MXhs95wMBuMNvPsSSFxhi6PayutQDz6otvlgjF7I6keRK
+        Lfbgkz/+hlyFpc3klP9Pvqx+XwDyEYRiDkHQxZyvoCd57MPdPZGpqodmZKl8dtljhJYTn2jXE36N
+        YiJI+4GvPPAYWdmKLMLhiYx4JYiETfRdYctvMdXXjgJ7ZHWkdMv12Uq3jFO35Cv8iSVgAQ0qA2xQ
+        sfVeKvSRCRl+8yFLafHt/esvQ4Nl5l6pxVb9qDSo0gp5SukppTc1pVfTqgImoDbUYo+tlZSKuT5b
+        qZhxqhjf8QMRvWLmEnCBlhUwbxeit25EEvLUOzthQgqM1d1V6oude6VRpfSd0nd3Ayei72qaVHnV
+        144Oe2SdpFTM9dlKxYxRxRQkm1RURkvdTvNq3ZJvO1ShXTiPbveguNXqxGk02VxAw8jp0/TAcgFm
+        +GxZNZG5bMj7xckgS7pmKylRUjIyKRHaY4tVm7t3gxu5WwvrhUMG3p6o5r+qardtw9qBjUSq2Hir
+        Kplipw6IClkqIezfhDuH/M4RMFRfUJCAkpcP8+pOjloveCW+NglJkqktcgV9RylLXS9TGeuvEFta
+        SHjFanHZeeA1ZJRMPJEFwaARbkoqlFQoqUilwjluXViySzLyzkkMcHXB2uEOnMXvZ76CMDpHIC6Y
+        pI+r4sF0VPrwkmEtS4vcXBqG3TKVrKOKIqKK8xTntcJ5JjKWivMU53XMeWlBpHK/hOI8xXnNOC+Z
+        kgCPWblW1I/DZYtcLp8gn8kJdrjGNHAvOl7s7nFxlMTl3+UEQqQMVPFQaCCE8LP7k9y2Qy3YzeWb
+        40UFu8trW46SQewWtHBoa47I5I18BYQMrbwZhFJCfSohpTKUyhicykhN5BVtd6A0R/rvw9McynxR
+        uugBdFE+Z7lUC7HyVVIYUE4Ky0A0EKt7i5vftVrYQGkgpYGmqIFSk4ielCyUMlLKSCkjpYx6V0Ym
+        MkQ8O0oZ8UcrZaSUkVJG7KgKZWTzNmaiXcfB5aRMYDmpNCxaIGsY1gn9PihaXtPk3kMGWV1fFTLI
+        9oOvTsZQMYZDiDE8Gw12kvu3aia17cneA0tShJ1wsyPjfbqiXu/75YjDb3d48YZH7q/4dee+756T
+        tEXrt9WjveAzHWzOAaP3eOse99kNy/nlhv8q2c6P7EG26wYRA/cEedkeoajW2xWwgt27Bdt7WBOX
+        5+rFcyr2U+xXl/3OW+aySiEbMij5xpQLbiC41E2AV7jljB6fv6WFnFTJ3hbF2jnWLlSuissVl4+W
+        y9N9Rp1CT2pPqvakak/aptO3aMAnXr+mWIhJdxZRaCFDqKGTEvRuBF1JSW0pKRSAOHT8aBO6ayyw
+        IbZglQ6kFi5YVHOvyQzJ+DP79myiB8oFEHYtKDxQfcyavG92977bAPpiKJIHVpcgqh2YfEeP6IDx
+        XcXUClvSyMVNs+MjTBa+7XNWks5sNcw4pXE2hyttuY/q69CZfQ4PeIh7oLxGcYkc1soNHX3xqXp5
+        oSxzqw0QhzsLCzFAd/gslaUyeFoJ8+E4PNW2isWlsniRE0vp4gacqnSxZEblFohQjKoYtU9Gre8w
+        VTX0uqqhJ9NlCnGCXlymEP/qrcfUUg7TwThMpfhKlYyrOpmDFxEe99dylLJdJzsoNdC5n7ShDw/u
+        J00aLuXrxOT0TTIu73cAtlgQ0lHNHLHph75jH4dOXWozH3Yz9+fqZvL3o/OVMcBQJg+KZteplFeM
+        AaxIrFop5oZrmllVGXPFGFNnDGJnzgzqwPlC9K9Zidrg0Sfzpr20AlwTmv22cBSxlePuaDq3FvVo
+        aliKpixNCTEb8ami6R1N021jc/G3bEXWYrLW1gA12q09AFWb6gBF1VuqUqdUYwVgWEqvFhK1rvib
+        iqQ5kjaUfUXSW5JGseNvnXCrzP+2Cav2ALIJqzYCUgmrNEA79FSCL4meSt6l0rPU6VfoHVbiL8P/
+        V4O8invz5C3SCIq8bXsFa1BYOQjLKCxDRSivFo/AEpWEIvAtgcvdhuLkVR5EEQ+iOH2V5ytPXXnK
+        QVH3lrrVfkW1w2jfxajs4Pa9jYrGrTkelYpozQepuLY1d6QirYw41apoZV6AKbAI2uubh7+eaVs3
+        s2bN8nyZcHgpD242xv0XVVa6yX2KlBh4c8lGuPOSN3gZHiVXW0nfyMjFzryyYHnteFxIC4i0kwPn
+        wrU3RJnQ1Ki4kWqQiodC2zyUC/SAmjDITZy59mkYXnKNlCLSc61OohlUlbapFB9dy3WluMahn4Sf
+        rZTWqJVWZkYbyBAq1KD0l9JfSn8p/dW//qKsizwnxoleUgpsbDUClPpq9Gyu+ipscCdJfxU+f4IK
+        rHCuVarJFFNHy5rqyIKro6WoOrImZk9pbMGwapWksdW2lDOrwbOVsTVmY8u8nrkIOruUclPK7XpB
+        KTel3Aao3GrvJCeu3QawkxycbhuHClPaanDaqloNkYk+lwW0XMvysQ6WQdovV0kBCHpaJH+xqiO2
+        Izc3lKwOW1Z5A6oL02YCXbhxUrKtZFvJ9khlG7xUp531qjoV5DrrdWe9c5VEydX68l/ZCuaGCou6
+        FrxSF4XqovjoRumLLvRFZgnoRLqV6lCqQ6kOpTpAqiPtZ7FCulDjL5WxMfQtlMrYeGSVqjZvzMgu
+        j3ySA5+G2hSu3sZ8/KK0gzztoGLz8iO7js2TGDSsFIBSAIWPUQpgsAqASMDX8EV/MIc3tTXARIVY
+        2fjsyLwIFwqnnEgJQ4oQTyvpZ7D6oj0PhFIwSsGwQ6UqGETEQ1kKylJQgjx6QXZ9V0SS04W5xjGI
+        nbuxMM5L9FjDzt0xfpXBtrmtNBYsjW1drbSM0jL3IzvXMmad/cjEU0cGo2K6zSBRSkYpGXaoHCVj
+        KSWjlIxSMkrJtKhkWt4nZTFKRu0gM9m7q/sPmuBmDHrMC9uHncnV4aZNHSMrPTnaKDOqTWuG7yrF
+        erlDKValWJViVYo1GZIqVt/xAxFtSlXKi5guTRXdS7VGhCjO+4dWjh5fhABUHdqMbi9VhyYzWOm2
+        67OVbhucboMorZrW4HD1l9JGShspbTQ6bZT1UqvQQWnrM86+dAHTRc/cQCdGwdy85DkfQ1SitGoY
+        RYCWbqwOuP881ssPVgKNGsAVwQdx1xZiCDwV4mi+UgDzDFLkSegJwlXdHbNcCAmxvdjdYx58G3Ix
+        0Wgp6Zzj1g3uIWFXrnIA2dEMIjfPT3wKbEAuD2+ODBbgbMvav1gAg8HWXxbMkMJrQGPhnjoL2EFf
+        ovlqV6K48EYraz7zj8n8WqqcW/3sKKNv1aqcjko/o2SYiC1Qw35oskgXagDa0lRpAaUFbv5TWuDx
+        tECRLVetBqwqNQC4p1QZAI3yhayDG1Dac+tCzirAwiMejVVuSsSViPNE/Oz8M1dqvVfr/c1/Shk8
+        hjIIna2LfSLb7oxQdO2sHfTLJ/YtZJnre5XAk5eb21mhubrVdXsFYPf6zuumzFnOFpwaD8UU9ONd
+        GBzcDdp4hFEwslBwOEbP9Wpr1iW4oZtN6qsscx8yTWi0Odo57scRhM4KYEh2gE1ts25syESB7+MY
+        BI0FWNc7gCYvvxMFZ6nAGQg4W4wPEcYfKDTQ1o1i1/OQ5zl7By31NQieF+1FkmJreO6d/5ApAJSA
+        YaHVGrl+RGyvDUxo2NOtupjM76pU14kTnSYgmkUFRAyTBSgIWKI9XARL/kOmAMyeqC+yDUI+3gcX
+        YJBps0FJJctM/xLDfsUUgEk9Iog6jWwmwLX2Wg4sADk58nEc6oqGYBoGFnjxlGNx6s1MmtpRHWOA
+        gsPKhX4NNoekN0Ts+sciA8PEI8uk72zx7O+Jr+73hBAhsvQf0PfWD+gv5+Xzz3/+P38CYaRXoHN+
+        XSE0lrm866XGi65dmIbNFgVm3ea55wgirPOIKeBXhQdHVvhVLwBRzR9EETKJwbn/ejvYw0LFsAx9
+        aT4sKsYZFoXKAFD5M97vHWQhm+zNutReK+OFJXad43/2MaPHI11c7JsVxZzry2GJymMtK87e+TXw
+        kR+cnBn9g5hhmzBAJ1gjVwuUK5O+45U+XkovANZoy5l0jfy6bEhBrRNYeH4FD8dyhCiJoQAtpMJj
+        5ezlruEx5cAjN0UGKorF6So5jA8h3rvEAgfCDMugFZBDvXeks6QazglL+1AXFiBqCWuwvoUcGo9J
+        nNOILM7+edzi/B4Gv6QnA8jSjPNpjePDDgYgSyp9g4y1lGOoyrI+V8w05Jg5ArXBiiFJT2tOOIyc
+        2PUwDBXgwaYcXHh2qjTjc1l0NNonNu/JVm1JN2pdSglHAB5bRvY4dtIz/0xc3o9OuEU2MtjwvUZn
+        zQMHJpkEgDg22jtEj7ibD2QQ3iWyjds4ma9WKhD/Tov0YtMiut7T1lifOVhGGzK/FMiFII7pocQE
+        kLSk7LC6xjIgL9sFsePOPty9iz7M65G//qLPYRBCKpM95yPQqsuaSGALkFdKSpfEXt1RCZrpmeCd
+        S/2Zk0tSRPEltM6fAYzAkSOz1GorzODIXexB/9ZJG5BbHwSmCyr6yXM4SJCBrLTeN4CD8qzWNge1
+        tikoCDVSHJRwUOS84dQQFuelIbLSYj63CpVR7mIPrDRQtjh4zjfHRXFcnoJDKBU6mzjBDJaEUw1r
+        W766NP8sOmBM5p2fMc3dmhUkcBV6o2W5SiwDMGneoJKrgsyc9/t0x86NNvKfO5eAGiLPCd8xOpXH
+        ukV4E/jbRF/pK6sOx95xUxw6frQJ3UNV2aLLe3VNr54Cio/hOoBNhGzIDDanv4+J7LYzmmqCvhD9
+        a7YlrIIwKkfj4H5hL1kTFuZLvWKENUpInd9aMoPliyk2g4U2t4YxA/LptTAYyAxwGHwcZ5ckUG6m
+        Ie+z0hsL4yGAmeN1VJ60jOL83NN0MaIWYhzFjWkAdJgMigb8lLmHmLz9UFN333d360dhYcuCUha6
+        ZixKCmSc9Y2hzV/MhbUwIF5M6aouT5halQovg/5dTEOys6lBQ7OkaMgNCVcv9nxpQIzfUZKQ0K4+
+        Gz48Cb+R160Dz93M/ic4Rv/A6U5z9r9wSNQEUek/XuIFlvoPoH2WoUFOj64vrqxCk3cvPYQLSp62
+        vmJMI13JH38nm2YYmFKhBPmAuINKrsrJ9h0zmtg3tTlamtf45T7kdAjgTlBUU3CzxKeeIVaquA18
+        LWRa8x/Q96aASq6KqR2V1EoJthwIqpdSJY47+wP5/TP9/Q9YGC0b4TBuWZUSET9sVJE+Z+tJlkbC
+        T2qtzU9pcgj/C56JPx25nZKBXIAq0i3TVip51NDexEmeXRQmspR9PGWAaYKE2uROFOSf6M8MaYXz
+        Y+CsGcjW50ppPwDOfUu0grkTmFcK5emgfE1f+StNX/mrKYatclQODdz/mMhz33fySlo7rmn0kzF5
+        KVEHlcoFS4m9u4WpKEC45kjokEyFpcPRi0MHqKwhUeNjoUU6mXtqOPu1k28K2MDvByCGOV9Uh5Nz
+        B5VcleUZqlIoZ4KlwdDSloWRkK2g9Kko2X6n68CCOop0V9KBK7MqOWWoJsRvinKEcmmqh6EtlJjW
+        IRusuL0iW0Y2KqNCzKZk9Eo1OK89OtVc30EhDh3/g5b0M9HaiTDak+2AS/ejR8cDbgrYckE8WtKX
+        cWqeb4PNcU/LoW92R/8jSh78yxGH357z/UN4yadmZe2J/JDCaxndU5LAthDJ1O+petAuvaS0LDck
+        Swyy0TzpQ6q/mC/oZHyn39OX24o0edU5a9vWDJOtqFiV513RbfiyQ9bY7T5v4KuzDk741dT1jysZ
+        F0nfzcoSJdx7Tc1esnvKCjpwn7PSRAhTMo0qnbDG2zDYfJDH+LRQW66kL6sfILUMF3aJeshdFC5Y
+        ucgVrExC/OkUaIX+6y1nwbvyJG945P6KX2nmxXOSnmD8tnq0F3zCB+/x1j3us/GX4f/lKTgnityk
+        gCGBCL+5nvdc7BmjzoFjTGZ5jMqS7fur79h9YYG76kU3A5K7j/Q9qd8xm8TVR24vKlVekgd60XgG
+        2XDU0niGZi3FNF6+4lVpaawqe3N08j7P1dyNgmOY8MHzLo4P0XezmfMZaWk9Vo2IxYxow2OMyD/O
+        PslLIuTjzxlFbWbo1+zGLLUXXRslZhVjMwpxcxOVgA5CQD1iH2+du06Ktw3ipBnMl/eM4CxnyKWp
+        pJ33cIAPRaKWFeZTwXyxNGByDqnlPSbM2fk8CuYngShnJedyMG8Bz12Sh23RMDklvxPBEmpywWKj
+        xgTm6KOj8mCuoMXnIHUUx4SlLaFI/ECw9N72RMEChXJiIjn6dK97GJdKHMePY2UPA/R2gO1gO0e5
+        xRL4rOaZAMINOhtIRZZToF4BWxvYLK1nLS6uavMyfGRpjyphYNVWZgzQrtaCXYKUFTUCVH28D+Iw
+        8JXkTlVyTWQYa5SeFor2h5qaBOd10hjw5Y0qbi7FYQBLUHUr4IcBfDmultLZk9PZtGmJOUebrKKj
+        oNxOTWontPe9dKMZrndqomB2e9YefDYsfa8bN3GwxUXHdftFtw22T9cEao7fUrBe4XvdKIlUv6Gg
+        sTTn5mKiFGxU9/7hKXjcu35wjJKkF5CyhrSfcjx82L063mHnFPb3YNNa6hU0SNI15sVTQjSmPgxg
+        KTxZZ8k2Zwf1v2QZLgUzw18x4QAMq9tgw6oVdAWZrb0AZiaE21xbmAMBbqEZq2XJ/IgIh3gPkzQi
+        /DpRPINBLv2eF7N8akLIJY80Kcn6hy79FltfMBMk7yDrC/lzNtcRMZ4O0SyKnbVLPvObRn95GG3d
+        t7dj4nb68tCJSe8oyaeoMGaXy6K53l+pscLcLIHWomC+9NcUJ7w07yecZFo1NWbt2x1DgSFhExab
+        25ZpTM+QYIhY055dWIqI+6Ym7YMTsWRjWl0r5YaMleZEPbp0u5EUm3FVFuCwZsyXkonOuHyREpr0
+        ndtlTJNuwtvGaKS5fBGY7qS9PaB4Gtu6vUp+T5h859er45Jn01oehIR0hl7UvDJfjZIaVVuR29nl
+        iwzmE5g3XnDcau9B8O7hJIU5nS5t83Cm+QnT/7UNNtHMw07oz9Lp/+YtOPrbNN88TxCoDzhF7VKp
+        AA5b1ZlcXdggdW9biGC8w60y7bx/1GJHS05WTWRYa0Rnh06wSmhLUAMf2GaP7W7NwYozpPBajUOa
+        RSFd6HmzCF2M1KsFLKMwaMKY2nxRQhsLsVGt+YIWhX46C1LbDEYkw1xVl5hok3+SOjlznvwJHNnd
+        i+qb40VFskrpfhcFASb7iwZp2CuR6pyKVbKcdPm5tE/1VR2im6DYk3EQPT+XtomeRvKJU92SuDz1
+        rWDyc5FEdd6w4iA7BpY6qEByBceBiYzIDjE5sGoRfEJikJ9L+0R/qbXOTse2kdHgQarisWqaPkuR
+        VRha3KxvdPKTalsi6hHfTEsuyhGJllolCK3FxVuiWiYiG8w7VuIkZWYKSMNkL9dhIrauL7cg69qJ
+        N7sknBEW9D0ykX/Rlsyk+LVlr2SwtVXBuom31HfkEKq4mOO3pRVIbz4pJXniUr7827+5D82+SPTZ
+        NAC89NEtabXbrOs6FhYLSAVbrkCJJiNjy3yt4Cq2zBdiVlyZcuUrvMcrj3Ouj5DDM2ahM4G9VsAz
+        eb938nXaFp+wFxDe0BJZpP7vxM9d6M+GcIYkJmgJcK5pm8O7sGWggntqcNvop6tV9AOt6fLHC/bo
+        T39bycRfh5RiHhsDtLkS9MgVP2cWCWGJRdscoVhigCzh+uS7v7Tsb7Q3ZW8kpVqWbdYC0gp9UPwM
+        tgo6arBj3DYo+QJojdMPJXtI6q+qwZ8Rd3YgiyP5otkzD9dZdMB4s0O6iXblOTC3gRlp+kIFuNkb
+        eBFRznHrBq/pq2tFQyUPyL69MA4qN8P4GK4D8CTZM+kRzNHUFlOHkU5xujj+RP7+iWjZn+pqWbjq
+        qujyxHhYqvuqZBl/VSq/hNI5m0eKVcAbJbVFR6U+r72VoMtVJZuk7bezb5THMKmzWDHM5BgG1oha
+        6ZVHZxOlVxTDCDCM0irTZRJQCzoOj0Rx6Hja3nlPf6FoTyiCaLdSELcIBF6NxxeTa6VXg23q48wH
+        iDB5CpCFDFu0YOv0QJIRElST/MI1F6dHfRlxoTWpL1qsWCg2dDT0lxIkKoRASv+74BH9O5hFITM8
+        1zJBhDdKCG+0oXYqTzru6ZhkfiLT1k14DM5KWnBh30RMthciqUQwWi7FYhE7jF1ukZgv0mOXgQS3
+        0GI5r1HGdJKquJ3zplIUMkNdSIUItL4etgph5bemAvlKKLn6YpY1mFvfns6yxgZ3imqGU5BSkhpq
+        1D4m28cljIY9BYm2qBAKe0mkh1TJ18rRBGeqnzWBAN0nuCcprBUum+4zGiyb6mCifWGueojizR4/
+        bE1RqHidKCLf7/hkeIjfXM8r9Y1Eh8Cnjew3O7x3Glsmt4jMdVgRbkjoCwwRcw6IeOEOKrlawwq8
+        Y/5c4MlZaTjuzMef0R3JiMLieklFMBVyjbUGv+fEOIK7ZZRIdoDJ3tmvHRFkTJBhNR7hzM+nVDxj
+        vNn5gRe8f5s1lkogWFt8yrBKahuJ2W9ygAKZD9xBJVeb5gFXatEz4UatPi/oX85+4EbNdMDP2Y+P
+        Cr68HYQCf1zgC1pP01mhq+GnCRvaDQ+kuRs56aHGtGGOmic8Zx2hnFYwgEc9ii0myhaXKQkoCXnW
+        4RC4ob51SBjg5K4x2njuNHgg2yYoVlCsAF4aFAdMiwOuIYNXp8EC5t+R5nmzQYm9JXyQuyjIBrmz
+        30o2uJCtW/CrgxE7YRBYUKlikMdgkIw9gk3INSWAsJPbr3Q/XHtd3PrUHd8P4jTQnDfU4iBMHlsr
+        lZDed/nXf0OhzxKAf+McXJT9ZnOB80Sjnjp009RMUa+SeqxOEjmWUFrpIbRSPhUCZtbIO7TqnT84
+        QW2i4vdobCKgSBSjPBSjZGyC92tgB1t5TtQa4VbJZ24LF9Drsb7AfCSe57c+I4Hjz0FPK59pAPbS
+        TCIqJk1P5SYZjMbDkktwAEEIyW0Yz8lsYX7DWFE0YNHl8nYbQ0BxMS0Ue9k1Khyl42h1bK+DTi5a
+        XRSrzfWCI202+WtUJ9q8USWdOBheATR8vIZ6LqdiQK20XGvHQQQW36OCTAt4/qig6Rwa6E5KYhSx
+        ZehLQG+QNvPDJ7E+9hnhoUCUBGLimezY5TSAZBh+FuAYsesnIldBKAfC2PW/AU0TeVuM3mt7FFam
+        6dU0CQ7YR0xOWufYDCJwbfDJaAlU14JDSoIGJEFnWHy8Ly/uXaTMx+3+EkoTkik67aMpdr6gIB0s
+        pOeaNqYJVJ3SvCKLuWWxrfc6VJyj900zAAKXPrZ2z2gXvsIiRGPB75BBZ5hrqk1hsc4yowiGoE9L
+        SlMOEEfeqOqDgTPQ6kj3gWBWZ77TAzog79kFsfbh7l30YaJ45/of0G4KbC/gCdRQM4uLWcqqZ56R
+        3HHPRAc2O2mB2ubCNGy7yh3DG1RyteVClnCySxKY0q2RWDe7DPrZWdr0pWEgojpOLv6854HyThJ5
+        E6MBz5y/SsaZFHdQydXm0plD5ECWqbcg3GsX3Ua2rUm30TMo9G2/ecc+DpOMHpTEd6AME+6uVnqz
+        jE+8fo2wE252ZSriyicv+nwsfDIEnfKofJK0HGyVUQzNYEk7cl5hi8o/BKewJkcFdzykEskZJgKM
+        8X4kE76I5Rz9cnQ3H2SnEHbUjInSu7rib/W+IJ0Cb+MnSZ+ANorjMVAkLDtdMYgI9Ihsyz4U/o+L
+        v2W2Az+oBDEMfstcLlYV6PPGFF/scL0YMvYtSr4ka4HjD+q4EdukcD/7AMey4xyC4u9rxwnFtNC1
+        Ozw4h2D7P6wD4Sz6iSdBeRCUByHHKucf6GRwtgXKzO9tyYfBhXTbgrVKU5gNBrN0lefbYwq9sRnZ
+        t/DmNtZqozxUSSRQwZWnwmsQeNVQnAq54WtNAatTuZj6k0BRa1Nh1StWNa1MhdqANaVzjGFpamq/
+        0LkUhofdLPkTnSz05gBDq1cgkSNPrUIJkInLG1N8sVZ9Qmjo55vjRVwyH5yQDMKe0E11A0YLH3gR
+        y2REGdBJLD0Iabal7YiRLqxhOC2kj17sEuI43rU0aRnQhH6hs4kTJNmVlBnq7q/V5u8q0wO1BDMs
+        jQ+ivyK8Cfzt+clz+C2vzjo44VdjHhF+I3M4OV72FFP4IavcM4wKvj/hMMZfr46LLqROfeZR1YGB
+        bhdut9hruTqzAF7X82NOeBMHZMbur/Rx9zu6/Lq08YLjVnsPgncPJzHl6VQRWZ3O5wMnjM5rlYed
+        0J/lZ56xa3W7gcvkooKuA5cHJYztxi7mPIl84K0mSKFPWJb5x4QBbt5UJT+/I6ygZEjJkJKh6z+W
+        ypAfkUURz/7+iX3yx9+RZf4Ac3tpEMMyffozB2CRjRago2T6ogS7BCPXf8Mh9jd4FhEWx6FH1vOM
+        WWebY0guxb+hn3Bm4BKaYN/U5uj3ZFxIqYP+4kfEJNjArG8a57B6NCIJ0sjohEYW85Z+abRUNLqn
+        0dpzNh+IbLBpCCHtqDv704//5/9qBoo2Ox9XFOU7uF/YS5QSncFLbTol6vP1GlZRRrPzO8nK2Q7F
+        ko/hLLDgZSZ5QDS7TieqWAS2GB8ijD/oSvcH8vtn+vsfBvqDG8Wu56EfPWfvoKUOWyEsbQkp1MBB
+        A8fO1onvq42l3xnEyUr4/LfU5fLkkS/D2ycnevr/dPK6mfHTU2pZkL9ix9Oevo+i456MmOuzuf4U
+        HcgXPBEme0q+eZZiql3J8t8mwpOfb4fyA8NuBYMuDWeroW9qIqf3i1x+ugMCjq4byNDmMOReOsXN
+        WPWKGzvZwaFmw0Bbdgua3Sto7GSHBhp8A9Tt6mbpvcLGqVI0MOCWwLWtU9TsflHrcWNIKYY8anXM
+        UtvDIsb8SnDbw25IWjZDFv0akP1pRg5YFjX0xdBSotUTWjb6eUO+ExnLH5Cx+KMYajVNRmEbmz2e
+        7JJgaekw2pvnttoncjM6oRMxi8D+vK5Y3NDMflmcnWyHiEWxs3bJ1L4RzOhvD6Ot+/Z2TCKOvjy0
+        diJMdkXlsWJnF41yCqWDBJ1ChDauo9FSx3FIqO47fpBU6jwB2wdNr9pbTiDEowaK47G49H4Bkxty
+        0jAycptaYWcLQOE8Lj0tZOmwKsEt0BOUfNgqPdmWQ30Wz2tWGy9g1uvybNNlLj+3dFc/r8Cd1p12
+        3MpTb0CvcYM3qORqDYXF7egrgHetMKrD9q2ynBCh6P5APpog12UX8laLPzI8ikzdtMmiSSxzxa79
+        s2vhPYpbE27du74rwqdzgSR+QLw4iE9BRsliPs81Vii+KMiltsb2fG+HkSqhSrWL/oLYhp5bfAjx
+        JjHvX8m+M5kdGTtHho7M5e0cIUUaAHoI0kF9JOimYeZcLdS5mijlgBrVdvpYV0CItprVWLiqDBLP
+        QqFW0I4YWlhSVRppXBIQnEK+dmLCCtEF9cHbf2dzJ4JgmhBhUTXwhgjJDVYdZxjvuy4Xkxe0E6Bb
+        8dBswpXPLnuMkM3sJwHOr1FMOH3fIKtG2deVegAldphuIQPW7UipBKUSlEqYqkqwhHbbzF67ZPTr
+        m4e/nnmtUctuOoRuELoxbcG8ygezAhPBueop+xzWCcAde/MVVs6oHaQuq1v4j6/FMlqxPgb+4Bti
+        GYlbgmMNN1R6dHazDZFED6fnhbwx5ZcfSG9OzVsOU3H0wJqMeCUUDmtqwswwspGxaKIUG5SrGK0e
+        UXKu5Hw8ck6DeRH5sHPpWLCo54sslyTLCeyYRmFjCO2XWEOgartU4PGuVigQnZEqBc6F65QeQmNw
+        dlQDPsMc4mbpXnVkBsMCmUIGg9IiSosoLfLIWmQMUQ5D2GaUxDm0bigP2QguqeiVcVe2NBnIEopS
+        VIymGA3OaNBDZXZZrrBjWLNnkJwlZMesBO2Ydtyoyjcycd9Iqc1xPfldIANe4VrJrZJbJbfsmM7k
+        1hbeK5j5c1PAMa2hWUK33Zz61bYYy85pYYbo7WdM6nwlb4+WntSaucLUlWe1BSc4Slo7OIGwb7do
+        oseNHPlWezTFsx3xbO2jM5mxPPcm5+AZXNjkFIkzLJAJ5fJWLu8Bubx52qPm6ZlSJEqRKEXyqIpk
+        4ya1pzTvUtDN1ufXMkogt5ah6QvWs8OV942U9DO7RNTZa8KZovmZ5KtafH5+akHobLJKP04Yu2/u
+        xnU8RNsvEJ56T0r+3PcZuPtfKLMfZTWayrMW53yBhdpEL/r63PJNCHCQa2DwYFc3fJsI0LTun6BI
+        LzVIrafhY5yfx0RRJgahc8Lk9R/IWK5pz3B8rYX3dlh1ivrcMBXq3aAeZVUiCeQL3JOMvyi020P7
+        y3G19zD4QBYIVFDZjmpIB9C/M1/VYJqwwvt+guJRR4Gt+SjY5g8bS+RWgioeALbVReUngyxcdCFF
+        hscBb86tNUV47S7XWsgWiTuo5Kpaa29g3QQ7HCZfvXf8LfKcGAPFltBlMQlfB2cilQgnLTRnuYaZ
+        l+Kt/aDn0Eor9KSjWwDNOaCFtgIQAODBO0ZKBkcEYdqWYkNm+47xF2xpvK+Wz8UreWwFZLxKcx1W
+        12Zq/pcQuIJs+73TJdk4JJFBtcuRJJB2RfRIp9AhPWz9hS0umpf73JDCazLpcemDtUmayJ7MpA/G
+        AzKLgCaD0VHIF/po+gpORkoLxZMyiakYswktT5ZmfLdYGmuU2EZdEtFYWCu7cqfOG1RytXNKvh9i
+        FETRd4ap90HDAbiw5NFQkbA2CanTKPS9vfk6RwkZ6ZuVRoQTMPkT1khq2GY0nGLFZECEbuQtQYg7
+        FcUBbyxSunxnWLDeWMMmiAwW+W4JbBP2CKRQlEj+hMVUDHtTI4MMwFapUyGEjJXX6lqf9E61ElKs
+        FCWyhsQToEPHXpKMcGh5bU0Ob948bEp2ppEKaNjp7gCyoWq1c5A8MnpO+H4TPm3a+rJLSvKaoY2M
+        Ha8t2XuUaggdW208J5OSfarHCYh2EG4ceDTmsDc+MtwDv3xi30oPJr6zV324MUGts7mDSq52zlcn
+        d3P0Oz3MNnW7ShY5QwqvyWGqve8i+qgw6VB6aXjIZqLXpwwkVRyipgpPZniHMtcZySCKQMzTIxEk
+        CR9Nk+EfljDJN2vZqRJKTuaM72A1BY1cYS8eVdZ4GwabD3K7f8JhhEcQk8yGzNeLb2u3NFAZiiIg
+        LslcV9ODkE1qGRuEkfOG349OuE1EcuDi2OKOsFAU+YUqYCSFUrQv2WiRnrl8VUF6huTBOJw5frwL
+        g4O7mW0857jFyEI7x/04lpI1reOS9dO8tZ2Laj2AGPr6VSzpbwzPhvXqDM1kMyDrKJTGJVPKANDm
+        iGgrH8PMPFACUSFl6xRKapGpOTlEZ2I6UeRGMaEWmRl+cz2vhPB0I0Jn+3qMyvBpF/CbAcndR7q2
+        pLKZlfu56pL5iwB7LCHscSuid5u1wbBR9+low2AliDEyHHYLDseoIpWxkNXSmnEbMuGENJy6cYa2
+        WrIwlVeaM8B9msANr+WxtMUpYlF8UbhExUAZWmqR1aFxfoWTvBXeL7zr1VkHJ/xq7MJMYyu5UXIz
+        NLlJjZP21gwrrbW9EBYbwkcf1yktcwJRLkCsH6KsED/vfez+F2iHcUukFj2/urQo704z3RNJE/m0
+        VGqVzC/KsmRzF6di/E1U5rO1ksmnr5blRX47LqXQMLTr5kiWME6pI8XO7bMztwT26NkZpp5b3p0r
+        jm7O0Za9EDbKWBXdgVkGNagGbRC1bmGCbMYu5J47quyyMs0GvZYlpzl1bDPOUUmFiwHYAalz24w7
+        SN6ZUuGBkuJnID+XrGTrbzHeOrQo3NFFsRNGiCgQBMw9Yzmymf6EpEzXiZqre+Cbq/t0nYrmuDPn
+        4NJmHvQ1XlRMRxjaRfCcSyrc1KmA5mAbSeswafD0HPBuaquiA3mwIDYlOzpZSLdMWHUtRf4WyA8M
+        qWdFmWvTpovtzo2zG6riV+CKbAAlSArRElkzh7MYwhmF8AgsoyrP0dVcktwyKT5hddRD8QnCXwel
+        T6bDJ4WtTJswSghbcoC9m2+ZRLqFYPVrIRgvMjZqY1QmoYH0uQnr36PYRMp+fvhs8h4E7x6ttZ72
+        vdZ09OY50Q7pOqNRtphMd5P6ibZOnJDT1M0FLaJtGc/FvOIct25wjcOAu4fqM1P6Sg/77/HudUd2
+        yAlLaGz2XzqMvjYlPn0vy5bUFR7dj7HybqSck9VezZc1+Jd2iYzcX/Hrfp28CMre5Boly3nOnIkk
+        l5mJGO2stQlV09vkiMYg210Wi9A8FaFSPVtLKECdXZRQ9CgUZu6wR4nFVSwIjeULBeeAQsnF0OTC
+        KDzse2ypsKhMkP/HJxd/PnOO5opO2di9vuiZMrt61znZzudzlTgmah3esx2iuDeKd4ofsx6gHvZ5
+        TUXAu7dzTZC02JxXjeSyg6GxHbX59145ItclJZVVvH3F/vYQuGmxAKavPD0vo9OZXStZRDdTu44p
+        v5x8RVWb+8r+9syD09Ac5h8TlmT/MUGu6vUZ/Sq/ouwxZyWesLOkvTBh6KrHSd0v97loUPmrmmzR
+        kfplwCdev0bYCTc7wfUn3e3XWIHmjPO41JZjNTPQ66QU+HAU+EWMCmPyymo33I4LD/vnNODmlpNz
+        cQw01T9hVm2LT5c+VWfG5UQsKK3egla/mOaFxxYiet0JyRjsqbWAO+oYerTuRIKNzLXgZlCcyN4q
+        CXYrXCLCb4cdnu2/xbuAqBDkmQha+/2czVjfCpflwed9SQ33+J4GS4WzT+ycki+HHLEtGjokriRo
+        GJHI+ZI6JMCxg25qNBOjYamvxXoPzbUXOaU/GnLFMvcddQhCFiDyUee/0R4ayjFvZt9wqvcBgl45
+        g0quCkuZzm7uR3T2lRXpddwZsTDSer3m3ChH85IbAfFMysUbUuWy1SK0Muqo5aAWCIcoXQ05fTN5
+        SFOhTaG21nLR7jzKuOXGTOyEBoU2TKyvYK8kg92DaLdcwDY/pVEDbthyEWcd7qPHu7By3JjQvi2y
+        LxPtiUq3dDutH7yXgrsPQ2sWOSFvT1pYxrSO0XrH/iBCrOTsS5sXMrCLzoOb0CHaEwZGlmYg0xbl
+        EDn80ZQwrbDHmSymIktKlmtHEUFyLGQVMG28ESu21QRIEgR+tAtiQpMPd++iD5OfHdww0Vdq9voQ
+        llL2OKMqA5NL54YLcWtni0XMktZeTroV08q08TFcl8dyFRseNWXG1l/mDVArdFPBBYZHA2QsPkB0
+        aFZZ9S5FxmpABjaiphkZYDmmbInCfoyvRXOT43bmbI6nlAo/LJM2rPRhL6uPo1tttsTam52dGcL9
+        yYMOFrxnOE7TKSkrtNTEnQFwnaEVhH0pvqvHd77jByJ8lwaGAsqNy/WZ9895hTkxiu+E+Q5mXuYT
+        LprxEKSdR4sdxgvj5FtmoLYwzNq3zZFhgeCcFpjFNc5GCeecU9Wnqty4CbR8G2fx1ME+qTdQttNq
+        5HHnY187OvDyb23G/MmNr7jnHUK/r3Ewj7nklPHNMU/LjUsU+9yyj2bWYaAlmIEaRi0OkYGKDlke
+        lYWU7lG6p97SJep3Ae9/m3bEGyDvFPjZH5Z3RH0nlCFeqjmHZbDR802B6+RR+aaiPCAvlEkZQzWM
+        oSGFqUvZo1NDuar27pi4ZwAb+W55pz2+qCq/IhINq7E24uhVRNLF2Lhz/7cbItmfkqDdswXakLMV
+        aNvPbGj9UFqkgjqPcE2ZpIZPt/Pu9Xy+gbKN3NqyvTNNLhlGjGkek2cCoRiZfKOc0pCybnuTGoB+
+        OA3YqzA4SR0ciyxugcXx1RRykdQWNCA7tdXsTFsrDO4bgJqRmc15jzbaue/lxTYV5KOH/JdP7Cd/
+        JIUk6VFQiCzR+H3JpqxlLXOFFXNGCWdM8UXxGhfN0wCulD156OAdI5h5p0mN3eKUqMxF9bfXU2kh
+        kpdVe426ENpK+RdIZ+mJp9U1I3iDSq4KUvsln7xSYUznKFcfqQIVB8DMtOZr5NCcIXOuL0HgLRMh
+        keemH0Dyi+g+qJiADRetGgru9hNiYu9+kDfAwTTkarwhgJmr51EHzHtKNkRV7oFK9OnGm11SEG6W
+        gQLKkpV7KjuEWh5W3lCswJpDu2ZgHP2t+zKfhXi/R5GHw0NPdcUWTRPppdQV+0LUOxQGHwI5VPJO
+        5OYLQLtU3qCSq82DYys48pZkvagZ3ihw3dVfk6/39vmG8l1k5Zi6WV0rjGqZEh9X7qow4nnBqYD8
+        jmhNd7n91Bi7ncJ3+MvZxLDEBltyaNAgGCDXeksA/zPxxskGX64T7GnxgX2ATiagQcxlt8TsIArj
+        rnKVDat7e+saPALgfmz7pq+UI/32Uush3HHv2QIxY6kP7EYaYFsWdgkpX4vzLd6HyDu6uZxXGdML
+        u0SN5S4Om3eaxxkU9auDsJmAoloCFZVg55E+WQ1wLpgrbVOn7s0oWa2IffLVcaHtsDW241OxvmKj
+        jAfMRBxdpPRVmb6iBfgpZV+PEa7BbHMQs7EO/2JWY48MqwIl5fqOXhYLnT32aOWIsbKKEY/Sw2M/
+        uKlV9CgR9rv56RyBGzsdwHWS17CS+t/QwJV+4YVHn1TqIVivonzlLAALvIUYVoaxBxYo54CpMgAA
+        tHWw/bY+uh70QLZT7JqEPN/P/bTbeMFxO/sDxoefaTPwfxjoD2RbQLYD6Mekq8NS/wFEgEXOTONO
+        MXsh4Gykb7dUfkL5tfDSV4gshVoyMY3MUPNxPKOv86K7LuvbjLBeRtjGsZ/dxnGeeSXlC1pPdfUD
+        +ov0uqHj4ZDqQ+9q/ji3TjFoKfpL1FJjvpCN+U+02UsG/KtBlYIY8ko7cNG/9tBJWOCufw6QB0ry
+        SFgmAFbl5pi2XDawFBu0wQZWLTboUBWcq61fsUcnXYMVcpK5AphLSHIYZ1DJ1R5WAE71ekJPbifD
+        gSD/P3gfXLE3bXCkFKjcPhB9A5L/yRtUcrV53f4G+PuUqu4dVQfLAT/f1I6/UQPmXIcFMbCnl43U
+        AIQRWi5ukQ+4bsAIWWF+ZN4V5k+J2yNHCO6qryxzrqvPLBgw738+BrsBr/BOZVo5uRGIKK/FKBeS
+        3q8ZRgtGI4xBSmzGv39inyZn/D5LzhA0GVcyTcbeGSA/mzoMQGNtTcTNdxkwA/zrR7QURf8FFl09
+        EvTzs2mC/onYjIOBvubq8PckapwoBZgukGc29M4LppSl4JeMfiN1JQpXnZDIAUNwH+SqW9VggToF
+        KBoVH2lhiRCtImFPiw04PTYbMMKI+cDznJODToa2QDdukd0biCnyoa7jXh9yLcnrHS8Qgvr4K74h
+        6Cgthb2zXzuJxXtxP4I3kYZMzhhGlowM5siRdD20TeTB8fYzShS0dqOEQSBg52r08tCmj26efd5q
+        m4DcPPIgp7i+B8G7h7VNsJ+dcBjjNCUK+zh0YveE6f/aBhuiDbAT+hn6v3kLjv42jYtM/+W5jPRI
+        16Gypsgvi/y01OhQOd/QzeI8DObamfTB/uBhOuXxATBM/n80ECLnDcffUPAGswgVFu1jEeKNGyd3
+        KVj6gSWr0kST888Zx8UY/HLE4bfntKypXQnA5dHPHDJlb6v4msrysrdf9NLCF+GQgPnlxt9m1NLN
+        oixEO15boPj967uqnA6cLMZWMh2LmTYp/FBNqbtYFGi+13TolJ7sFtIppZGZUKmyvHYrFOJYwB0a
+        ySDy0EhRYTaCVOSDs9EASq0YMEKtBOkEKQM2KjolE6qmE7FAnBDtju8YGebqAwW+5/pMmsUWH4h1
+        ki6dZAVNPsPUzTnSTWSatx9T0k1DHhOaSwBxeYNKrgoSdw5jwpS4nhOeqZvXbY1p+6gCnqNtK5wr
+        l7oD4Fwh6qYRVG1x7mOr3BvatsK5cqk7AM4tpS4n+BdsQ1YdgI7KhiyhECfYTdHojkaHg/el9iAV
+        tOFpK4Y6If7liM+lHu6K0BVlfVZWhJgSEQX5S5rsAbx8nCGF19qQPcVeTWiYWBY9uAXab5d6V9Uu
+        8U6ScT71oucdoNfZ84ZH7q/4NWtpQPjCuGHpwuFe8JlntsLRe7x1j/vshtVl/H9vpwCrb8lCi2gW
+        NAoxzz99Pj3gG06Ati/ssCGyxCWc6upQZr66MGC8TSYCsUUDJpqXMxEkyEyQ0dLXw9cpttT1uL3V
+        RvkqfkeiVtYreWIIyekqldSmAVYASladbBXJeiPSgMrPlSmxxkmPuQLNUtc1W0glLQRVkiF1WbtV
+        YNOyXXIVmXvEWLbt0sKyc3kkWCeMwWrpxAbpV+Bb4IXUQdrPTrl3CwSy0csopAwQYUIe1567SZtw
+        RBGNFnLILfExEj41BjgWsncNOkb3fhr5qKuD58RvQbjXzrPRNkESYdU4xL0ycL0QKuFICIVVV1g5
+        bkQe5ZC78OzPeL930M9//B79+Jf//T/oZCOT1i/4p4JMImQ100cvgP3w8+/Rj/+cRQ49o/S3oXNX
+        RIc+JULG4qNbzCBrsAJt9v2Pf/ke2TfK8PXvq1ddideAkKKhtrSh7v/29gEtSyZYu0EaTLwO7gqn
+        u0Mo6luPZ29OFCOek13AFs6Ic87h408ityXiDUo/qmQApOlmfpJkDpOfY8l5yZSm6WxPjr/B27Lz
+        oUnMN+tMTjP055o5gAlC/B5N5mgMbI6Fm4MGk0y6zE90no4f78Lg4G5mG885bjEKDmTvaqPFg813
+        /ijzJW/wcfxIM9457sdxwhNOkw1n75iqKWK+U7uJrGsnF38+yIyTJmUPNWdaZi93AjXhuXLa0E1m
+        tl+XtsbIQMnOzg/8oiPnycy6PCpw5NPkOZppBcQ7P3NSIbVjP7PysIh6wv65c/2OHcsKpLJS1OyO
+        FgQklTWF5JiQpAVPtbTqaVr92F7pa+RY8zU6Gd/Bzg9MDZJktsbbMNh80NCSEw4jXBWXtwCEDEhp
+        yVgRs9gQIwn9zW8wMikwjmmuafn6Zf8QARqMt5trucq3CugdpKyMeCJHAmIE62k6QozYoPD+EaIl
+        3vvFBZan3GZo2fBQScqqpssPrGxxO8hAGqC0mB+X77pdB5noWxTj/eseR5HzjqMKyp+868oCovwc
+        1EZkZJQ3tcWiNdLzRhaX6c2tJlQ2YMj0tIaMVCLEzeqcee98Rpqzd34N/KQSXUbc2SF0N+SLZvfl
+        00K8CZ23eJb9fQIcXmZDed4Yd0+m8nqueFdeXy8Zm+5WTLN0Qp+fn1r2Ui0rofebbDacHQvevl5K
+        I5On/L/LgGTQ7GTMkjdHs+tnZiX36H//LqWO1Qd17MES50B3jzFO+hteaqUZ0MUSoBgurxh09nOu
+        PCTQ1CgmIDy9QFGxgIpLYKuJBchmGwcJTW2ZS+xqTEWBZFtFyjJSAi1ZQL7QWEgoW6QFeFGRsYCM
+        Vk+ase8iL3LF2RLP81HkLCPnqnvtuNJXVWLNGVJ4rW+xFs0RVKS8I2VaqI/soPj9utmoXrXs1CUq
+        uKuTomURLfntgYFkhThKx0HWXAEuYaLehnvDtttpMwhIZSeDKaMCp3MBGeo4GS8NFQTuufMCt+m5
+        LO8nxofsBjGRhpJsQ/oi0CwNUjGqddgApyVXJs5FPtvaPI1+BnuQIPwMKZau+FmsPx6h3f5AaO1s
+        dgXxMFeY3fUevYeOT8g+y/5GliZu91lAUcgvWsMXhRvtYAPr9GhKn/fH/0RduUFqVFSOSnEB4R/Y
+        nNythurPrhiXLwHJ3iGPYSBhDnXkJjAE6KaBKafVoF3unjFQD0g4tsBeWURM2bg82dg7hk+0VFWL
+        sB27KkHjiZS+lmF/z2gQyIwN/rzsQmkUKHDdXdhAIA1NZ8Nghm+J5I3yLAUTbKOBbJKcLlFc3q1V
+        TisbRBh/JL0dz7/ZOJFCXWaDjc/80MZIc/w5vPj1BscK3UuZpS2VnE1RzjhIKyfHg8AsItD5g8mS
+        dJqlkup+4ebUMIBZj2CMTYVwG7sArs9ZLbwDBLCpiN7u04EnjFDpZNMZFbRSZPMeMeQ7PkypsqHE
+        ZZ7Q3h0rtX1NmoCPE+6hGISDYtKsPIczMhs4MklG5pWnKz3jgjAypGuFYmNhNgYVNmp8QJkfqeCT
+        rYVozIkBDToxcrUAiqBbgsohDEsXFXg+gTbiQluyUy7ma92Qvr4WFXavbArCG1R8tQ4K0o/arpXG
+        QNAsc+mt5dFSve/OmrNtCAydFPAuCZ/dSo8v6dC/L41lQ8f/QNh/99xoh05E8ktxOTekot2Dbr+r
+        dn2nTbDDYTtBr8m3XkeYus1WiKoKi02pAywAVUpXS9FVJl33Ry92qY46Op5i2laJqzhXKnEJPcvj
+        3hU9YfT0yQRd59V397P0J/kLpY/7xUHn7Bd7XRUacENvGdS+fha/dqq86WZZaK8mup24QSZcnjg1
+        vgnTR9A6KvcT1yY6cWqr7Z0PHCbJhog24byWBkGiNT+q53F5Xz+ZR8H+4OGq2iyNaYXepkEteD3S
+        GnSCpqkPnkod8BRNRldcBaKUYio4qR6eo/Zrxw9OzuwPGB9+po6if8BTl6vclZenV9AEUkyaN6b4
+        oiBZlmyaba4G2cYLjlvtMiFah+zgOX50rjn3XE1W9AdiI7ueh35MuG+p/wAi9BLgNocSGlYCtd3S
+        tEYu76UFav/LQrplwpzBbKDOqDnZzp2Q1aAuz7fZbYnaK6SpsNjoJ+eEyed9IGP5AzLM1R/FOnku
+        QNVTe5Ujsk5tndi5m05yxQ/ixJn8/KcgfErPEZ8oX3jRb5/SWoZPToif0tKiMd4+xcHTwrbMp+Sr
+        n9JXPjn+Nhm2JiqIjHHIBcJTT84+OPrxtQDifxuJdq58ew/MBw0Rgx2jFheMzfPozxtCmZRBF4L8
+        CQnUgHKn5MJJ4+dLdgkdF1cWMN1P1K79MXPNGMjW54LNjWVacJCO4a2WVmePFqcI8UoQYEjh1NEA
+        zIZSTA9gExmCANuA8lGjAXjFTEberoChsiVIZfbDmlC552pSudI/LRGZ1o4UpDIkl31c29xcBf2J
+        aaw/H51wS6sywvwYUvdffSsrdjLy5Ojvn3+nPd3AFtxkSJordSeRpNg30fe0xA7teyhsJMsice+u
+        X1035OujfIGjEhgsMG8PeENcw7Dp23KV6JC78bGygdDlnkw53tKG2ZZ5/yicsSTG89ZrI9mKdiyO
+        +a8wiGTZXQpROYj6weeb53zgS10BxM9X5pLnfHOVldBNu7ALvegh8DEmaB8jvlq6TLow0L3JdCEK
+        SuZ0S/vGXuf6jvf0AHEtb6Itwlowh/9QtkaGNkeeEyZ9oCRNxZwvepxMPmNxnHPh11sd21ySOI+i
+        Fj9NJgMw5duYCqezybikPpsF2wpjjJNIz1wkTqTVXpxVU5HKV73ORCZv9TgRExlTmQgbOT3SiUhW
+        vn3M5NqjRKaN3Ns0JFuOfc8E0Jh22Mx1bdoyalBC/OGgTRCOm7WSWXCKcDRiK13vfB6XX8gJN7G7
+        GbMRf52Ldxu4M2prOD+nse5SYmftkg/9Nou2FuDzz8N5HsWafbAXdyFMqVdIZj/ruymCl89pTBTF
+        x3Ad9DNdu8vZ7vHWPe77majVJa4CvsOxs/B5qo/CxNST+hhsTH55GCW3oqNHDOh+ZrzqasJkcXfI
+        E6XMknBI6Qn8zfz0JojS9wCmRl/fy9yaSCZwbgTgSI6iHRhoESbbih1y/C2ipaeczfRnuQm8IJzi
+        LEO8D04YrZ3Nx3sYHP3tNCeZcOnNLDNYPfd9173uabJwQJn3A8cbiBdjdFimZ6xHkKdphJP75k13
+        YoiYan70hrtXpB1I3JsTda9JOGUXZc9rQ6PhwxOxVU+dc2YHRtomxL1MjdOhXL7M3eyTgL75NjaG
+        HW2TNOrIOe/5T8Z3evV013gbBpu7ClgcZ+pyyVwvuNJwN1kyq8nNieXMEc7NLp/brdpEx0O0cbw2
+        Z1lTDVVNIlOOw53AonwCdFEe7sfrVvnXn50jA/zyCrqfJduPw8BD6WZkgLNYCs3ivPEY60QSfxQK
+        1v/BmyGyFGgOmSt0rJ+f87aMdSKZcyxzjI1+Fql7aKyzSPbW70fygeObwr1jYIDfL2TDAvJoRmTD
+        3pywjc9AN8QmNy7k8pPzt064nRm6aaMvRP+abR3PQxgxYTlM5uDB/cLeM+1hsjLsxQugbEfa9qip
+        f+D83lxxTXYmyxdTbCa2Zs2HNA8ygVqIDGMenut/HA/ZWVjpd9/2BJivqtLQ0+fyvjp7VfFXIJq2
+        CP2U+Woh91Ni5+R630QJUgVi+tRa34Cc7cnxN3gL/RijKu9X8GPwV4zWbpQU/Cv+gM3OCZ1NnLwh
+        33mQ9xlJAbyvV8dNKhGjtEpe86oFZQ0g2GtCZZVvZ8jOryhROW0BqJEXzNLp0v5TZ4klGwXajSrY
+        RDOPEN6fpST4zRvdOCQS/ZoRpQAQy/xogElRhTTN7BE9qkeL0GOvSUOvpF7RYID+na6Xd5ZQYE8E
+        bIJ0ebnxwajaXvDrDZQm4qdAkQzK9ZPJzy1OMsZml1/ItPXyDldnqa9uYlD4OjnpTUYRVuy1ui0g
+        SlGixNeyhDtaS2XjHNJttIujhJw324uZOAyeE2M2akIB0QYQeL/G263rvyNdZ0r8b/EhxJtUnra0
+        iSh5rambC6QbyLBvP75SpQGKTkEK7F413/WzQeqvhm1/eQMIpfyYE97EQfgaub/Sx92XvpGp9Sow
+        LddmCqmhIMXNICs0vtmSmbyBr2sn3uySovKLHLRAhxHXkBBVeGL4aByECifGHX2Pp6UvzXLCR3vH
+        80CENwECcvN1xsMS3ZhbizKiO1sHVRnGIupmuFSsRZeqZpBFpKngx+kqgTKapjFy+OuAdIuQa2Tr
+        YY1sbLnroXVfYLKzBZHYnicXfyLd1l9AwrBI/TAvIHl4DfEvR7ILOIvFS1v4WSV10dlrw7ZnuIUy
+        Lx6IrBmgXiFg8F0bSBFBakqyWzj+hYz216kA9VQpNaRuY6dAkPSI/eEJctuj/nazJuop7HtxeqzN
+        WgFsMhYqteRIdPEefXcThOWnzrfiMQcDMQ5/+2W3mnQQhDTyahuKypMpBUcXcFz1yDvefASliAxv
+        sXlwtcaAd7caKSSngmSNM3yF5pDQVACOH8DyOFwF4JAADN5xvMMhuRmZhmaskc2W+i5AhO0kxY0c
+        yJ7+yo+jFmpaVfjZNv1qttB6yQFURx9tln90QusVW5q04LNfuvvsl9LPXtGvNoEcAmmyWPTV97sH
+        nedIEmqPWDyjBAjDACKR7yrfIhbZywq//armjLmxR3GArLm+B85jATjMqpiH6JkUYCLHA52GAZ3G
+        CuAH6mIS5NmztUP/eKdJqBFG2EcnQ4PFwjWZRX41mxvNF6zqk1iyZBVS4ofvv/+LogRl7JSdbaBu
+        6U7LG4U6keJHm2OmjUq1OVqa1y6l6J+wiq+CX1mnxd2BGJGeh71eWhAXE0vRCkQrC5nW/Af0vXnL
+        XOZcXyLKr62bcpyTmAUbrCooUYvKjsGfn5/a+YNopGlqjs9+OZNjjRzTXF+anaXkeDuspo3+P3eu
+        /0FXfjpdEPALUJC/APS5XnA1DEwp0Md3tJg07ISv+xJ1m20bUkPSy1MwgHBfaABE+s3xImGoC2+6
+        RzAZBoHw9/T4HtkrnQBJ0bxo7z/9bQUGs+7+qQXhZT9HEM3NmRwEUwrspVXlVKT30sqW/L502/4H
+        7DSSVYzNoAa1kaJRE4XhKLmLgryyZHllgsAifW4KqOa55MU4D7KoPGvGS12RvmnbnJFhFwbH952A
+        jh4n7P8q99hfnUYmpL05HO3FfG611fUK5F/LzWeK2Gowbc3aNbXdtU1F2NByilZYgk8WMvqR2fum
+        6Q0R3ePYSVuZzX7MGpqZyFJOBkGa0SZw5UQr8kdqXR5z5V72CDigP4UYGNHcDQz6ZAGw0U/OCYfu
+        5gMZyx8QUdR/rLF/S7RzZyKRK3gwMUR+3pC5p3AsrmgAzbEOldNcYw+hp4LET/Tnj7ctUGstFZbW
+        xDYWdTnmXjZRNNS6PSAwVrWw6FRN5V82bizSwiTk109Zc/bbE8aTzm7tHt72z9HrZ1qcAJn2/Tnj
+        eMlWkxhfCTFWX+Xs04JnoOnhyqi5MSCP3AUx+flXd++iv5qCBl6HBkVdj8sHndiHOb2DjzQ7dvZ+
+        iFEQRWSzBI4QHJhHvPZ55d3UJworFFVI6Y8uTzmaYjolSM+/aTrhMcbhjJ5RZ1arvS5QudNc8n91
+        XBSE77M///gTsrU5+t4NhQ7mB6S2DI1d/uBM7u2RjebIccPJMPk9sovW7TZesQI2cIZ7/s4ZVHJV
+        +HS3drxGyhSLCRwK3bMCLGjOlh00NwRmaMYKPUXYyT0fzO0wgIH2bYdQ8riBN0hiIFcuM0d4DzNv
+        yhF55HijTm7kJk0doExSZ4OJ9BdgJeYmu0xuILVhc4s9dLUTTSY+bDPtJp7yf2gNjjSa8gdB74Bs
+        ld4UOSN/KCEWTOmntKChlBOMpCwC/RwBr0C/RsCPG/Q4QvAaBikBq4r2FDejco5bN3iNDhhvdhyy
+        VXcETx4wyx5wufzv/JTQrrwV0u2srOHPyfkkfBJ4XtLPPekpBp6dDVgyL4/vcoKlYki+SHP2zq+B
+        n9QQSOeeVaVkSttfaePjYyhQICfNK65CfiK08QL/Hb0FYXmu8i15aMsy3XgM6lwrU0jVGqOmzvEy
+        0g9ODqLz4zQALXHnVPmgs1aa5Gb/hMMIV1Y+AWzjjbJdfO6i8LbNlnHkt31Lp1Y2Jgz2B/IFzmYn
+        yxC428mVAb13N2EAR9oC9RsQxBqUP9Mq1oYcrJvhWAbTIcR7l9ssuTAYEhL0JQqU3rtUZpkR8z7E
+        sjBjsQW5PIhIJSSMaXT618p71Keif32avnVwN9rGI8s6Rhaao53jfhyRqZu2oZsmB3v6efh1E+K0
+        ZtYNXgntOP6y9A5yw5Y3egWrbybAWzI88y0mVbF7owtYThS5dKdFhof4zU1axhQBO3zWq/AB8Pgv
+        5T16MEn4b04E16jHf5q1ZFedch5Mj1JBXUkhzmBBHQdiyIVdouNyF4Vj16t9VIwR76xpWD75x9kn
+        eUmEfPw5o6jNDH2WwWlf1MkFaZQ+AXEktZYYnCMaXo9R2YFCf9JSfZjVRKIqVf7NgOTuI33PtyjG
+        +/MkriutvagUULpAkAn5OE5WCH1h6gI2O1xyZAiMrb+wmbOF12q5dLuw/VplDlG4U4PAFFfIliao
+        jyHd57rnqFYTrQs5alLqsF9uXt5w81w3jZda5sUAuFmqZaHYeuyrPID1r9s63dKXov6bDjderS7b
+        cqpZjGDdDg7HKEXbNHlarvTwvOqAYRxoL6UYaX0DeWttC0GprO37ocOX2kRmbWSk1slKn9d0fqyW
+        LL2qnB+sVpShHaSaKBZbe/SuAUHDwqQcRYGdcLOjM6DtG653/HLE4bc7QHjDadXj1537vntOjrNv
+        DrMLR3vBJ3zwHm/d4z4bfxn+X2VkDcaVYsxfKqU9U+xnZ6f+wlXu1fJua0bOqqnYjoCau18GVimG
+        V2cdnPArEcKPG4ekxpb75fdY5t1ranaBBiukA/c5q7y5V0KYkmlIPtLq391raAul8pTKk6nyWO+x
+        c1THO4ORd87xjhKXQYlLyX4gsQ7mhq12A2o3oJbGEco6ZDeQyXq2Mho1V8ZFJu3wlTFfnbq0jPXk
+        VkZTy6lHJe5K3GWK+7sXrB2vPZEX3P1D5X2a0q6EXQl7m8KOOdteJehK0CsGK0Efm6CXuvQbbdm7
+        Ci+C+/IbePJzSTJ1HPnL3N5D2I8v34sPy0Fq2Y2vtJzSci1ruXPDGC3k2S2FvkGrjbQ/SH5mi4Eo
+        c60wdUekr6B4hat878FbYE6WZoJQWWiQCoaioCyslV2ZoMcbVHJVvKa5jMA+CaXHiP0vjssyl/U7
+        EVzI+i8jd1ICLkReaNV+Lanab6GkicVNJ2GwYptrFqQ9Jyywrm99li9FUgcdgKq6J/1Sr0P5l1x7
+        lZYJT3thFhGevSZI+PxcOiH8qg7dTZFFY+B0z8+lA7qbyDDqEN6SGHnft6bJz0US4SuN3wpk6gDD
+        xpKMFxZ2Jp1Ig1WL5hMShvxcOqH7S61ldzrWjgxLVLYGsmoaQ8tWdnI9A5SfVOtyYaP9td9jPeuI
+        3bpx3aprJ97scELkKSL3kut4yfcRX8lgpzt2Dth4+0pe7xCquJhTgo56E28+KSX53nnHBbXoLg/N
+        vkj02RtKirJHt8mcUdb6st6KyWJSwZmr3kqqtciZ+QD+Ks7MZ0coxkwZM22Wph2yVmmeE75j2iqO
+        VySquTUxGg5rx6y4o/5Jn510ZGg62peX4C066+PR+aRLKYfIG1RytZ/czxrFrrMTkj2OIiLEERg9
+        8VzQM7pz5ImUOK+KvK7Ed25w4qhZfLmDSq72kqQ9FnyV9E4QXRxuyLc57uu7E+NP59uMLONrZ+0k
+        1fvJDs+wYQ302DqIXNTZl1UwAV3bQGdAhSzAXqxXvFiMYqY1h5EMspUaHckW4gSzoJ03p0gvqwa9
+        zEenl1SDVVAnWojuXUIQApCDcVEE8h1deIFbi7lVuGXIXax18Cp31wABIam9ObsU1gchAKmpL4oA
+        qKhzi2XJSkrqV7Yea1w7SACkpCg+zGQEOW9EcQLZkK2Wj5NRDr8xDAcgCJAS1WMTlZLq50MRldiN
+        HR/h/RpvEfWUoRMs7MpsQWKqkCrcazXZZumaXkWpc6j67L4g4LNobDrD4dWB6YDK7rASg8KrfO9V
+        y4qLDcqUHNj+tZ585bmG5jKJMk3vNQjGxjolTrHRco42r6dxeusl0QrT9NFVYswsk2ZUCa9SPRZo
+        HhvblLhox8s4S8U4/aSfjZ11bGXgXHeeHVdZGj/vKKXTq9Jp1XWa3wop66RX66TnDOHhtTwRYtpL
+        Px/FvYp7R8O9yq7veYkdDdsOqSEPgLWzysjaXHzrIVgVCloIeZKcPdQqyJPl67T0mdpP97mfVrzd
+        Jm9rhuJuxd2T5W5hg6TPMpXjM0g4dSoVY3fC2AvF2IqxJ8XY5+qjyjminCOTZGxxY2RMrD3MerIT
+        5G35HLsJdjjE5K/93vG3yHmGVQ5pZeWfLwBHHiU81DTjs5XDWbiKEkMKloMEqz3VSm5Fy3ULOk8D
+        Y+mPDh4bbtOpuPQNQjviAgMhTZg42Rq0nkwb2bYDzZc41/C9/EChAaJSvp/WFPKwTM14KTo6EWY/
+        Hm3RllgXxKpASeEjWhQNRO1lO9S2DH3JkjKXossbVHJ1ABVipa6keRRPFggzSBXfsclHIVbCwvEe
+        BO8enr3jveu7yNR09OY50e6esltMjPBNuuvZOkke77OpmwukW8gybj+4W4tGt1fzJbtUdghDoUkz
+        kpDSAvA5udqNOWDZTr5w3xxQWNtgpBww54l/iVNCvkiDnBLzsloJ7MVanuQxZzblQYUmlLe06QFJ
+        aaugFu57RglpspPako9Bug7bJrSzAEvdTF0mJWdHdaUYse9N9NJfgSfO8tPlVqqfFQqGTlI94Zab
+        5wJqatClFNrh5oRe+6NHtq7k0UfHuyMesArFwxHP9Tf4QDl5tifXjuG3tB4UivZOcq4ApZn0UiuA
+        cpitVuZKgm4riEfLQ89SL4kF9pPMQb1zxqVIl8UeEmH1d0fUFZCmLUhtvxRliyfIoadmCLjz2ljv
+        +3YOlbQ1aErYHlmVejirtWW7TtJChm278NQdDEl/J6DVD+lDOzb+zs9qGDYtC1J/JT97RwhQIZWh
+        lgXl6Cked8lp0CRDs7yolXPomgVuhT8cSB1hcG3i1JtPCXRk3MfJVzO6Jv2H+ls2eyZqT4dJVQCl
+        bXhm1GeS/ALh08bhECjWsCxetWG4ajsREqLkT11+PVpLAw2hOhNqi08pneDuvWVfpaxbbodiamzh
+        yYEda50x2zvv6S+0x1v3uAevq73EZ/ZTMmCoiMHFrLetWwdJDCKQQUns+hmJgZtjuy811uKay86p
+        0zX3igDQ8dmbM6dFBAp7dg/CKs3+FjGKHs8kOhMp6aDZ29oKOe5skY976YDDIhA5aweZwAZt+RNH
+        OTAsF6sKGHhjii/WO0gVpRzYzGhDwHvm3XZaaMk3CrNOvasv07y2kAZuVdtQObyYQhY2U7cLWZ29
+        Jt6Sox3T8NwS2YD2leszo7A9y6T42GQkYZ0snv0u0H3jWbhCjwXNgNyyC2LHnX24exd9wALyWkrh
+        AyWVtduKVVT7yTG5gvCwS/9EJwu9ORFsBWqlmRrA1mo3wi/FQIxkcC3Ul33aMs1eADQLDtgngv5+
+        iJPGMfExXMNyLFoRdjLleQXNWm091o7XsgYEolZnG/kugKjKFsGACPwN5WwB1mWzaKZQEcHqJzNI
+        ACDxip+6dktQKVXjWrE3dXtZnRfWqi9iNXKT855PEHVYt8kswGLebTTRHgCzlHTRHie7+I4ftMku
+        +VSjLs9N+meYTpp+d8QurTIKp6vA8MoytZ6KNeYE5TtWaX0dyleTGJ7js1V2GXvlkYxdglZN2+UI
+        ytgbvEElV2vwyQTUSmBNdAs0BB6ZyB4osFpfdvKe+kKF0ls/o5aZxdYK+34Pixvs1rnBTIs9K3aY
+        gvZgKpGIHIIYWhvJDkMuqFFEM4GCGg9WgoRPMWfrgMu2DD5sUTLFyOiDh7/c+NssCnwHWDm7Fd/A
+        svcK51XnOSyxwAXf+uuC2yLB0t2cKMluS/k/JqfN63DahWzwIoMTJN0KQLr0X2YnHRmajvawaPVW
+        On9A3Fet9tcrafzR67HrLUTzEUDU6mHXMCH6ol7mMPhAwGp3bYADCa1rOSOn8yYOV7qjC/595ZH0
+        nMDQ01kNFCCrP601gEYGJXqrG+rDI05bOckcAAQlvRjrpT3cEDfv1OuwAMUQiCujUlQT7k4KUINZ
+        vJX6cwNAoR0nOBQFGywBvbR74w4quToODf8rpb63z7eFfDDW7ymt44b8yHFh7sDeyp+9lAlA7qIw
+        /7POp44BYFpZC1O1KhYMGmWaO42t64zkDiq5KgxY7og9OIYJ3Z93cXyIvptlngdtE+xnjouuiTlb
+        7EUXsjeE/OCEZAyBRSqbxPiL4Dzb7NzwUCqVhFyhs4kTBmGj7gt4KH32M4f2znHrBq/RAePN7rmU
+        shsvOG61tIB+Qt/kECYOUHrz7BC6G+bUIps93r5if3sIXD+mfPD/LgOSQbOTMUu+YpZ9xeXyv4tI
+        lLYXttAc7Rz34wjSYUBHc/oKdOll/JqyjhRXfXsV7wrThkTa/4pIwPYtJYEUjmfg/J2pm7ahm/Dz
+        PIXrgHFNMEU2mlNc50au0051MAknqllKesVjsU61Qk/niqh9gn0cEjxOmP6vbbCJZmTRi8k/omwp
+        TcGdXcDlrqk9cqnUzuP8gBiYcPBG+QlpX6OYvHxf/urSduZ5BUqm4mOYSwG4rR0n95fsbUWYkkgF
+        eTx57jEqw7N1DSuNM9AJtqoq5nhM5hCzvRSXPCCXJCyiL0xY93nFIgMw0Btjv7zBfq6bxouoCW+l
+        Md5wE549diponDwnz0Q6pHGyYsSh6qpBm+pFoQjJ3Uf6nm9RjPfnSVzd2/OXKqGC+67AbRNb5N5W
+        y97k9vdt69EWdOTVd6Vb+lLhOhVcg8MxAqEJzn4dJ5rLzo2dlsBMZdQ0XxSqE0F1VF6v1uvHTQJM
+        MSFVqA4bVap22WgryLnPaslOvSrmQXalihZZptXMEI5ex0642ZGRPj24v97xyxGH3+6g4Q2P3F/x
+        68593z0nSYfGb6tHe8EnfPClXxEdfxn+X7WjHc+ONhVyVON4t0Mx5w18XTsxeV30zCt1M3m9wB15
+        Q5LMdTeB9QcZqf9ypc8VjyoeHSaPCrPmQjQ6BlhspX8ma7XdHCe5RhlIykDqwEDKAuEM8UA4Jerp
+        RSXqStT7FnXe4wri+kBaYSFNGRTe9OqsA/J5RCA/bqaSPgZu2LI6pWQ0/4UwsxhiPRc+vzXHTlro
+        rfd21DD7mEcdnqU8ZWX45niR0obtakPLzpXs4au4323xm3P0YqXqlKpTqk6pugmquiySuoYfp3GI
+        JPBsFKxd2CYtcMkzixStmL7OOzpFFTBbO6DCswpuYzbWnXDe11zlWc1joPaeLaggoFIR3iQWKpUW
+        JZGjmtqQW5mq7UHFHKi7lcT3bnSM3YaFGk3pAe0LG/alrCdlPY1HrSrriTemG10qwxefKqG5oQIW
+        VcBi4WB1SNe3qDc+jz+bHcrWGJ6t0YMru2PbQak3pd46UW+1zRml55SeU3pO6bmh6rk9gSN0PKrx
+        CJcmv5H5u1yBwRItBJfE7F1AOQT1tW735PwFd1Hf/rziXOmvaN8f7RXv90B/rhZSKPQnBXOgEACr
+        2o+V/Kyl2Q35f2fabHadIn+H5PecGAN7yigA5AGwxfgQYfyBbn+fLM1Ae8eBlg+yxM7Pzu8BQrKw
+        VnavnRDn+R7n9WtSZ90GfnNflprffCDE7wRuOgWm9cAxQp9EWsyblgNNN34iOzqZu7XGnGrCOXWu
+        CZ4Mm0njDriuGRtnG9qC7UxSdTK8SoRhqYRheMIQGkifm6vBaO7F3LLY2kJdNhLoRW1PjNHecdLv
+        z9Tm6M1zoh1y9847fuY45Mt866tilZv28blwJCyoQGwD6jn++5F8NQc0ym/pF3jYf493rzvCIpma
+        4w6jX5EiQb+W5X9Km+h+jJU3FRkxkd/OllykXtfUT7xOPoK5TKl0njNnIsllZiIGz6ZNZvx6FpXA
+        L5PLM+fomm69VI27g7oscunC7dftQe6sozxJ53ZkeNg/n48j5CiOpAfJ/ujFLqGZ482S2aErxX6D
+        t26MHD8TLO7SV9GEiirEGXXcezhOlsjfcsaUX07W99IFlHxGMgE3djHnO+jBBPtgdkbJPyZixP5j
+        wm9Vr89QrPcVFbZBItvpC55LEpJa7rUm+agEegySnV/scRRR/SW0bPBGHUPvfFZVMqoyEO4Tr1/T
+        ky8OJHEiqKv03LB87bIQoVkqXuQXPrn4s9Q6utFTunGrGUvcEZWnwjfRpkIWV8XalbO45pUWV60N
+        RT09b1h21bgLFSm1dcMsGX+1Wk3BaFb2+D2vzqmW1gR1etaaMWGy2Q2TPVewo2bcmlLCLKnPgZm5
+        0gykYTOZvliWcc09ly0gnPOcj/SQsHPI4M9IXLKvQ0RzJ2ovYamMPZBhIhoOozSX0lyda67k4pWE
+        v9N1WAfgjBNSPcdhg2Zyb0qVz9K5+0Rr60nT+7PlTnBhT+segwgDm7/d4/yZw/LCTj+GgQz9Gaw4
+        p0KpjXNw1i6Z67dp8UqiQ5PHzpK9u0s2WWGMgvV/8CYuXNkzwthKj6REGNj8O5UOOv+jF4fO0Kgg
+        1+QtosJ/nP3aQYbWRriF45oGMHNsvqg+6ucOKrkqeESRO0oT9s9faEns7ZB1zAPN/ilRlD3ObExR
+        cGiioiqMqnTToQRfouBTggpxqSJqYUgsjp2Z5zl7J3HT2fp8Tc07cscmFggzEfOT0NdJjE4zdbvQ
+        ScJeEw8XYXNk8kZC4EcBtQ+KjYXDce250Q6HUUrwZO7o3Qm32L9Q30Qv+hqlhwQMBl2cYUCKHDHc
+        stTrMAuxuqbIKvfTUmxyZZPVlLmETHXrxM5zLjvOD+KE3M//Sr7z+788RTGN+H2KCUM9/XOHn36k
+        n/1EKPT0/d/IVRyeCOmf3oLwqUTEnhx/+1RM2ycnxE+u/5Sw0uYp86UnN5G3+sETJbR2PRz+r+J4
+        6Rxf8r2K8+8437zjfDe64dGn7TEkO2qGkX+bcPKn63lPa/xEd92YMHb0ROj3tA0INUJEfiLjJ5R+
+        Nn3gn79X/N4iv9vky8gFd/OBjOUaETbDNZjeEuyvLML4sOrI3FFll4VNSSNXYaqbOGL58UP1Y5No
+        +ktFaFIrmX/F/LpQ7KrYdcjsGm3IxzfRraK968WZFcitVezaqChZPzkailkLmbWWYlW8qni1E161
+        6vo6W9qe8So2dlrVsXJ300LiUC3cBuV1VLBBYRuSF1ChVl4mxSeq/+v6C+0FUo5FS6UkbwCu4C+L
+        hV6VOMYdVHJVeF/EHnt3g14rq2EQ+NEuiMnPD3fvog8TxTvX/yCPh+MtVibv/MrxnLHmU+ZGADhv
+        1F12UQlX/EpgCsL32bu3R7a2bIsTyGskFrxuvbnZ4KVeahL0LQ/MORxQUSodVlxULLtiVPxitcEv
+        FAw5vNJPZn1WlwilhTyRBVIqbIhL16WPVsYLmyteeE1UqRTFmLVY++5CfHD8lAJAdvFBJQeDhEFJ
+        RE8qKYk6RqZttBF2PCry55IfOyM/LQa5VOTvkfyGkU+JURB0CIFgPU4FgDwAfLwP4BqILVUwsWqo
+        uUoMnSEgIAGG4Dnt6FDIT7ATHKI9eSYtjA3bFYi5UEYHQjuiwBsFCnrMYQTeMrSIE+Qsq8X1ohdt
+        FWxCSn8mnbaUqLycYfKYuyluwuv8Drf1h/IfXV2jjj788q93AQ7VnsA7/x9yDge0ProemVJVojG3
+        SiqlVt6F25RawOM/+DlaIfmtum7UCmIFB+xTZ+shRkEUIcPU1yKVZMUWwPRlQNVrGfqSLRLbaZnk
+        XEX2hsHuGanvwt3zdOfpBtYDDcNSCMq0VdhqolCyAjl4KH/5JE+kf1jItOZr5JjmTegIUfsCR5Ki
+        4YT0tcBTpoVp2GzF3Jx5ROudF1pH7EVRC1X6CRM/bLCwDPm7F6wdr4covhsOoXGEIbJXhO8cq1Y8
+        n5hpJplBWpV8+cXAR8ggPv6KUcoetbijXwXCHVRydQDBTGPnEfEIKMUjU+WREw6Q2aB0V1LlG1YO
+        1NDNYkuBuZYhmJa0h5W8ijCx8rbJjsoqL2fhuGcgt/h0LuHrHLIqcGndci58lSkAZfjBMgnYqukl
+        sOXLV3LLDpeWMDThJQwHibTxMEg/MMjldfwmhHGjIpKDhO4B5XMKsD2IxBkVWnVyyNWoKY5C/IZD
+        7G8wJdpYcAXYRSMEt0KbPgy6D6RrHwbTh7N9pops8I1WUQ/JBPwPYO950OFU8twqcAHJdLwxvxxx
+        +K18SPHFjEvSGQNTY8tIhuj0QXQzZdENEpBXSbWyOJmCKBlpNAPWHZfGaHXTqxmS1crAlki0Hlht
+        1JRL/wJqNTZHsDbJ7JKpsteymeL9Gm+3jB+63mRhYXqLNvmjEliZ0xUoum/AWomPZNqDUAWdzhm4
+        akyHtwej8bucNQ2ggKpsDVRLv64pWmlDyp41MMR6Omosa1Hb/cQNs7SiWu6q/Km/ub5Ddobdc3rf
+        mGfJlY8m4J7z+YCTdqlzCJ6RIMn+fmHbmBZea2vK5iWy65H2HvujF7uJKwqs0Ues1j4df7vmxezf
+        T/1e5njR13UitHODiuvVGZBuy0znOR4MyXx5eRhJ4FY1aYZHGVAfaqYzoxTKnKsZ/fnHn5DNbmt6
+        J8scRhbpVPk7DYD8+znO/gf0vWn+gP5yG2dfQihu0KGU6MUSyYKxj9EioX5/Djcn5KI0+wt32emb
+        UjBC3Smq9jjqn+d4WsVRF0LdFF78Ky28+FcTwkncZFspWbvAgn7wEolyqIRjJ63qOvvx2vAIJHSd
+        k4ouWyaMm0zpmvw26/MP5PfP9Pe/CLUGRiHgSmcspGsmLoX+YSB9bq7KiLQwqonEG5M/VjWARDIs
+        GJHmdkdchHTLtAdGI8MG0chcSmckjk6iFckHq5SWwCVuKX+NYyllo5+z5hA/IGPxRwjFFpwNNkMw
+        3hCWXuyYEoMAstzRzZv8xc7dhEEUvMWzv+1c2qSIho3yvRq9M9XdyUcJlSyp4hdHgf81c9f72Xvo
+        +NTvc1dUHuQBgfg/sjdVBYUYL5V7QPFgKpE6fdzaNM5x6wbpt5Jhb44XcTOg0mHp08vGidSUdUIy
+        Bnu8ewqfL1CINjoQmxm/Rpsd3jslI1trh5dMgsuT+ZqS8FNySDErGEfC/BJtZ6RzaqUoruyFK9fu
+        e7Rxk3jIfayjry8PGVaZT5Cj0sSVHjOkZBGBugMB/sC8eBRwbhkLFbNDHR4CALQJQmybs/84bkSR
+        QcnHKniGAk8afDx78xwfxXNExGco0gP1y0AaMowVnVs78Cw86GQqgIYK0KX2hgJpmCBZZfupvkBi
+        NzrQDVGLINUxNRuYcbcQ2WiXVp8sAYe2aa/wB/CG5E5RmDHA6M/yI4LpI/R+dMKtSywGC5nIHIi9
+        wMa7lO3fHkHT3YBEVd4wQBqgpusVpDjeI+olQy8LFJaZDHOjAqL8ABah+xFFnppcPGxhyUVQ5Oxk
+        QJpbCwXSwEEixFMYDRijdLiyGnqBKFcB7uLYv55hpg3uKT6GsT7DNcTzOStnaRdL19htckHgQJvb
+        zgEboJx1vIHiomUNFC2weMHKgk4IsRd90Iox12+gZINV50R2KKiJKEUauzRMOVtqUL2YHzk2xATk
+        zEZ754RDd/OBjGVpgsdw7Q5DYyuTTxiwxNdE5OxqNY4TtE6Nxc7t/KKmsPkmQz3jBVzD2EicCQlY
+        DqqilmnlKYmwlMaq2jsNTXq2N8v0YSKKEJn2fT8XhdsQcTu4XwluhrkmiOkvg1KDatmiYIklQ3fp
+        OgTjM+XgimjruM7MoXYg0XoGzKHRKUorqDmRGzklnD53bkRmm5VKOVkoPobr4LksevumkClRWGU5
+        NsUjBUmYBkcTlexHm9A9sKVWrzVKK/pSJs+Z3T0nKipXeqZMeUkRsSmmSqvGDOGUbYUWX1TThgG0
+        aivEi/TF0EFWrYGKkgayovqlN+H9xGuCqhNudrxV7woAWekMhULvKAi0C1c4tIgDz63E4ODu0366
+        LA6twsVrbpjfmLXYALE7rO5sdQlgcjRcQROjBa1+Za6ei0FV2I8Me4BeVZiOA1PGtUUzCjHtg7y9
+        pW0y0edzH+plNZyQnNGRrKbJlMtbQXxphJrOwf1NcfNIIQ7IJ20Wbh6lLtQWWuPYUQyhGOLCEElb
+        F1GuMDSTLbdUwBaQqkzjYAvz8diCZwUoxnhsxhDnCbWETJwlaJ0gcYa4tcJrbyxFTkPHwTqsrHTB
+        OE4U+ENmrppWq+IwxWFQDqP2jpihA1zUIKfL4+AbNmJS8U3GNzW2T4p5FPO49TdZin0U+7i1t2Kr
+        as5R1s40OYepotzqRtycA5r9cgeVXG1hI07bN2sJE1wbOUdNmUAuaulKcctYFZ23AejoyX9adREe
+        /rjyAQUwAeuO8Ia9OuvghF8Nc/VxfbcNDPEEhYJy32AwolCuX1ntOmJm8wN/OAwnRvUHZs9xMpy+
+        ZGP7gQsTGInFhFc0OLdYk1gLBWL+FL8ofkGGsHMPuEmSti6MyIIbzBJ2j+6NqcLjlfvi70Uc1foe
+        7/9v79p6XNet83t/hbHThwQobV18mwIFkiBBETQFip70qQgGtEyP1ZElHUn2zGwg/72kZHssiqKW
+        JVkmbeLg7H2ORcvSt65cXBc1EsIEmBnZMLJhZEOIWYsomxERIyJPICKSCIGRjweTjzKtB5IRnfjf
+        mAkjBk8lBtWch4dP9BUcJilf/ePRd7w6/uG000y6B8nuEEiHOIJVhmkgNd8rwRD7oYlNyefMDMUf
+        neLHytxGu3uqyx20Duf6hkDSjkOPa5h/Yn/8FuzQdLwAeU+QFL4VWSeR906/HB5IkhKQR9/kSol6
+        pUmuXl0zxdeD30q8+pp6WlEY+CMd4x3+GYVjL9pNjkSYHJPIJj94sk+EZC80tUffJH9ngbaG50HY
+        lS7EQKaCU0nEfj+Be8irOa7PVoXwcbptNHazZfnJLMvbnmKWTujuNDn45OPEK3WsMjesYlgFxiqc
+        /6cIMUENNyu9U3uk5WDwH3rFH9brUHv8G12qHgmEPkEUqnJ+HY2W45dnoFGfJMB+AiMCWEz4qK4h
+        QTMJYIJQxba2NKeyuTZUkFEBuc4KWVN7itgJBYwYUIEAbBYNIS7EYRPgdAsigQWA3zLQy6GnFzPy
+        +UqXFwGSVxz7UvR/3ZPk60fRXtduGiZxvruose+BeFmUvKb0D1J+qGMHcy8KM+yHhDNRLM5KqZSR
+        JE4I/fP72VKSHt0W+nRuw7PVdxzOqSZ6oDRKMN/o97pbsyXR6xuhL4WbOhkXa7mexraU+HGAs02U
+        7MbFE+RRkDx2SqmKErIhCQk9MsnvLIqkkvUrfVJM38nP4zJcc2RKy0t2Ltgjj22eP/u78KbHV5Pd
+        O3+mpvskJI2CfdGQuXKHhWN9Mmnln5B99kkv1rVwLhEXUTrelcCuIfDNCYy2/tuWwpXeldLyNP6n
+        pjSb8P1pL16cCqnpZ5/sah2t8c99QsCKOl99Bz2d/+5453tJlEabLCcuCdE+pUY6Wu+9jJLZRykz
+        3B414fkvIPHTXEFuFSjbVoYv6QrT0bejrVxFG9p2pe0V6vl2RJZr5+clcnvVnOzDD/y1CyYUh+mr
+        YJqKiMCnL92ExpBKujU5jE8PkZP5uK06Hyo+muk9CSv3hGfhFt6cDbhcYy4NIr9CIduRkB1w/ZiN
+        vISs/SwdUTqMCjqMfj/6Z0oIO/+ouDz6t/yj2cWq7x/9h4SlcEDi7Z1ZyjYsNSRL2VfxlH0tT7nY
+        6KnSZ0/BVLfWU6d0sA4sld+ihqVqks84NuIZr2bZQ3Ab6D6tuM1+Yexm9chu9EfiUf7AoygZLUvX
+        2A+dLlb5cTz6n5RiP/q+329z/vzdCKejFU7JKM80gbNoH7qvHaM6MEZ1DKMOyahOiRkLNvwtDr9G
+        30/0u3o96Xx/q5EHSUAOJHzd7YPMZ8cjexy8HgDxHBknFmVAaUyIt5VwobfFCfay/H58y70eeAwE
+        9J/TjOJEaZ1LbC6761EUjtIMh2ucrEd/+9svo+Pdx6P/zn/6P/862qckHf05h+6veJWOioTpcR3a
+        Gz8hH1HynrLTH+x50T6k29bzp6dyq18/qB+UJ7cnaLq0Vgi7M9DMUmfu2NOp/HRNuKaSis4vqjkQ
+        nILny8KyeS4Bqj0nEh3Z8WlobWDfBPtP9B6FTN1UA14loKfWy1wOs2AFDzK3pA5irk5B1hx02RHe
+        iuloA+Mvv/wJ2X9UAzx7TBWKDTm2rq68G4DeNonCKEVbkuxIms8r5jXxvfCEJiVBqmZAst4KP1YV
+        xIY9Y4adBDh77i4btKVoSSURl1vzONhBbI4BsQnE+Cvb8mNBDYRgCN2pOjL8AsSOX3dH7NSTYR1B
+        VEyGdYNwYclkeEAHRkPgIAJsEJQi2Ci9Br96/NSxvrp5LgsFja+GGCpme/VBkMURkR3P5DI8n83c
+        BuUnWsKjx6/RHb03sqPs58iQEzRz6NwRYoDilwFgkzLcgLBpwm1vfhah+cJmgT4U202qjq+NEem6
+        xupxflFtBBVaC1pdeQ8UDzaKE8Kqb067N6n/IuqV1kvTNb3lWAylfBc3OJaaeNJiLJdKQamTnryA
+        snBw5PFBAyUcSlfq7hgBbzw1pm+rRpRhCTw15tfd7dBzvUo+Ibtl11nM+TFXHIiiJdXy4fIa3b2f
+        NSFxSsj7MWuEepIshUWZPbMWbg+Hoavi+acWKpEDctHIjCaDAQIgNdfxzKDYAcWTOBskOyF5cBD7
+        eZCJGTJWAc1F5NepgCXU0hg86/Bkv5YDqhKE+jmQiY2smbNEaz/N/CBARTKyCVd0QvQEpomj9Y+m
+        Yc1ewDSxtN7BjGdKoanXJpxH08QmewRTntRjxFyG5cljz++kkKupl7d+cKQ7cBPmrYHvQLeJOEDp
+        DlNZdmaWDESjFIUYRqvVF9r5oY/2IetuT9YoDvbpKV8A2calbIvqGdATlm6efxuSD5UA1YRNg5iC
+        iRz0Qv9lVttBC+MDtccxnlOh/8y15/JT6gANa3y0sNskCX2CpvEMOTarR1+hWJF6BC12Nd/wuRar
+        558uDIBXAbjBCUGOiZtdDxz94NT6HB1kqaVG6wnBo57MoamQ3JwXVnErmtujyEvQYS7BzmSDV7HL
+        P0A4TVCAE75x2b04rzy0vA678qo2yBVdg6ifFqZe4setM8rKQKrSQUM7FFl6o43W5KAGfnp4K2fQ
+        EJuokURBSDK6OfZVKUJl6LwAUXxRAMVNvFQDuBmwnRC/7m55tUcQU28b0gdQA0SdZPgInDoc6I6h
+        PFhdeTcuPBVTIl+26TX1lCLUXOQsGoAzW996+EwpagvIlJFTfVBz0IuB7TrY2PzBmJ8afOccmXuc
+        BF983mtD07c4Q1GaohRvyNseJ2tkKxZC1ebgvQqlYkhqEU89djQtRg7t/CKVQaGjOC3UZj6HMzwE
+        LnLleQqmMK0euoWBri10CiGnhbz+H45xSFKC0gyvAoLW/mazZ0Nz0acq8Rgdu2S/46wooZJgOHg/
+        fC1EmSHHgqomo7o9dgtnhchnbPC7Er8iL/DoQctNidku10PnIlsp2dUinFoG0OT4tgTw4JhsmNaw
+        NVWNGOxqsFOmg7hGqq6ArYnlHGvaEGERrKg4yOUl+rsoDDtFOE4zQTU6rh10LrTZ/4COsU4CW8YP
+        bTcGwushNDuydqipx3daIRjbaGpdzLhEQZSffCpgQnTy9xiOQCNiwlNX4CiPthhmrAUxJLsoS6LQ
+        cGUvgDom7NcJPTMLoD164O2JkeFaHIvYs4krXIfbAaMvv2EMqBngVoaNtTehr4h2Nlpa72oAp4W+
+        OwOnSL2gCwXtvvmRDLYinc9F9sXQWeTMbBmSzmxuWQ1dsoRrKgFofpHOSu8STVdhMLWR6BOYS4XB
+        1IQzTdJuN9y+GXAqs8sGQxCGByuWCbFBEYaiazBsiaFhwLbg5a1NqE2WV1YP79PoUpJ0wpHFWIv5
+        MM7UWsgCM86yEUrhmkpghl/0COyYw/jtHBoo20N5bE5b3gZa6vQe0ySCc+pV6Ujz9Icd362RdryA
+        DxK2Njg24KjQlk+LYtdL5NSbbKkvhPIMG4NiFcWvbBuxmHZgMvevQ+6cvhDiMMoz+KktOahStalD
+        8DWM9inycPy1wkneWOZgxy/KiK8eTMggPHdOKKnEdRwpg6UWqrCMpTlV7gBfntBgDEpnAJUpbNKV
+        A006zTX40Z/wMSo7NrlXIx2basphoVi+GChbQBnFJGRfRm48Q5ZtzU3bxmvhu/AQzRF9VxApFxoY
+        28MYJV5D41UDXAW4eOujhhT1AUu1tYguMMjcYpSf7SzflcxO1wjIg5+3JYNC6TrWvKG5lmhJVYbL
+        azSX4XCdtyU7TUCcrlDM4q8Nw5dMx0EYlgbEPkCUblAMiBUQA/z1ltCL6/wMwHKm8SfCJM22JPM9
+        NaIPWvZwLAM7M9D2CC01Oj5moR01/EktzDebsot+/fiVtcZEcUIOvnRwsclaEiPIZruXqoCUwVAf
+        LswxlG6hTSSxDjybQec09qEy4itEz0Eq5itpw3wOOgQIlnI4LIJaBCLOCC5UhFAjGT4ERow7IcgO
+        ouKZghDqI8eFF2hcmLbYGfbrCqEZcdAJO/W4TysEF4b7umBnuK8bggoCqJX9zacL5U6gMvhpZXy/
+        8VOPETUEUu5KGzluhk89NtQRR6MPO+OnHiNqCKR8b2ccw2b4LvpbO0tZMyqzVbkST9d5R0kUE8Og
+        PQE6lzZLG7Z3g45YqqMqdbQ0xmD3AaMpCOiGnnpMqBWMO5xtoWFFU3YrxvAQQI8FBu+Qph2OasKo
+        lUjD80QMOzbhqCaM2rCji6x43tSJoAE50RKRUXmUzuwFbvK49rCwacRudqxWdrBOHEehY22H0TrB
+        G+lo5LljTxuKoYRrKjUS/KJHAxEVbGIYsg8sc2WljE7UCEfHna0QlvfLHT7ncAy1KsvxUiEMS82b
+        Zc2wB9eS2iKabf3w3Q/fDKLdEHUtCqhiwxzH0AaIc2XwU1fCtWgmWcZSWdnWJhLhPn269sXn6T6O
+        oyRLXxOC0yj083HoVFhJe3TNPrsdauqqSY1gXD4x891WrI9n1JxJV4lNtfKNCjiny4th12i1secN
+        7NvMvQDmVdAktQeS7FZkvWYeUUNkfNgza2sM6eRSXtUGvfPr9wKhQrZbDwCVgQsaPrs3YAXHheQz
+        Q0u4LTGqrxHF08bQoHgliglJcPielxApdLI6lPor3r4P+J7QdvQHnkL7Fm3AYw1wKqcIKm1INAt3
+        l/AEmBODZyOeZrvcP5YqcqZ2WJr85E74LVWDT5MQ7a9Pf/bSBrckCnYo8hIZcCZjVgBcGtL/I8HF
+        kBUUYz9JdkqNNNQDygyvAoLW/mazz8c3fAZ5H210sFFTEtlAOlDLBtoFrnnnfFVGHGqRiUdxS46d
+        DqRRGzPDqw43M/qsDWwOsqWNSYada6EbdvJkukGh00vLNcwfNVxXgS6L4vgL7Uw5+JW4fWz9lD4M
+        OrhqeCNDhaPxfu1Hr3SbEKZe4setHbpv/FC2T1aybYZBsRZFMzO9FWDIsax35OH4a4UTLIGPrmuM
+        FwjXVCKk/KIHALFhoIdhvQpqjQfnJgz6jddPEm+/8k4rK5LJhPSZvJOQfjnDkzUhcUrI+/k/qB0d
+        c/Weoh8svg5Jja09W5xDhW3KratztptUp6hXWO3Fc0bvZh96zKy+ejgIvhN7RUtjagOCgATXfCeL
+        ouDV20a+RySr0q80I7vXHUlT/EZSycqEpHEUpuQ19bZkh6srPUwvsDzl9SWIOepFpG7KH62JKPha
+        3Gbr130JlhF95EI26pdS4/Q32jljewAedKFb0vwcvEGnsnl5zdF+0VlK/dUnZUJGlyYFWmLA/Asi
+        xvqJfRQlb5O3YIem48UAPMWfN9dqdcNTAys2PrAEUGv8V65Sap8+jnY+/SeasD/YKNRNgNPtAEwI
+        jbXxCrBt2obrVDcutReflAGda5Ua/4WrmO+k+PA+i5jyi7dRSNDLCu32QeYz5PY4GMLE5ok6SwAv
+        UieCzyETsGObfq8wP+/gs2PWqzlF6M5ElE+2UUZ3Je9UAaB3pyaJ6s4WaAawQK2ytuTJYQ+rADr6
+        vMbj1Y43buHHtmWoGK/XASn+PP5P5CXoMISa522VLJbREGFpc24mPZu7hYYXh00Q+YwHCZ0soJGT
+        igdrYieDKXiWvArP9L8Jp7xU0vJrdwLjF4A3AEoFFYVIay92Fc6u/nERGJgfFLK9fFh0WDooIbK9
+        MkOnXdussn9pNOLVr3ThzAEYcwYupjBBq0cPWr1/YD/2gyibvOPs2DSDMptC6hG2NZnNW6TeyzP8
+        n5QH59fqv3ldMP7CIQL0I7hNYBSs6mxIdOTR7XBXJruGCwZ0iw0XaLGBqm6yKzVZN7NEkGAGv66X
+        pH1ZVYBqXjQ4MmKjjCQ7P9ynSoVHbCPbQyaWtMkr6ZRWUheBGdDhgHu1xtDcR2FdMAmFahD9ZPOK
+        p76txrSvM7onDuCKqJ6+f7F8yUliH6aIkXkIwrdsWTEsyRUWVbFvYVyKxxJXpV0KQWqH9WLNBuBB
+        k9Zxd6Nx4SpctBPGzK9U0qV0je8wCBvIu47dhAkW0ISLiuUSZgAACs+e2CKJmCCKSUiNwFucoShN
+        ke1YqwHIDk2mdCoRzid0RIY8Re7qRAyoOmZgZ9aBWJB27cGe6bgXupVBlutM1drNjG3AYSsogUy4
+        qP7qY3HAIFsaEZuVk0nU2qZAOAuiW16WrlW7S+EvasZXqqWHXLi+oPGHd90A9WW8NHaB+k2a3JEM
+        oyDAOzzJ/0TsZK+2NetdE815R3nQRHN4HvlbFL0FZPJGdgxNuougYA7iA0KLsnraRTzYITdnVofI
+        HobaVTtP+W5Qe5Aqunasr4TWUyd9eHgLzcUlhglLTME1nvcNS6jHPt29L8kUy9vUlEAtcKX2pHXw
+        QF9NNEzoILHR2k8zPwgQ4w5k853clMiibGAFSGeldpygdpajwKl20cIaOC26Enbo0owJJNSO4Myh
+        /qoOYi1V2cgZz9Bi4OQzcPkfgKqiHh99uPkKE7Sbnj4OQaDO2GkcQkh2Q1TSwL0xwNng3HKWzWpZ
+        JsrzGkm+J2Xylgs5ZY7NF2y0tN6H2Hj3W2tnW5CeoVOZquUv6iuYbSoKqOtkzZzlAJSHH7pBMoEh
+        Ry5PErfs1mquIo/NTToqX+nOgyX3vTKy6e5R9CYbMYWkj7RpEaab6z5wNBxq6fl1w1UqXdE0y/eS
+        KI022eTD/4mTdbBDDlp+OoMIwxw86bK6sia+OmtCUyIPdZXHXRrUHC0dKuJH/Pzbm8WsIezJh5RE
+        Bg8yS62djhnAxTip90JLLAaJyUK3foAo3V2rGBVS7gNHZWaVk4A6Gi7GgA08hIotdJISebjf4fBN
+        PIQzD56L3EwWyCRxaaysNlR248P/KdrhA0l87x3ZixWiGpp8H0YMRAZwJtsSdPJkTZezRdPBaBtV
+        12dz0SodUo8+Y0GEORk2bgy1MrNxX22t2qaS9kiCMNqnVE0RnHjbyZYk9CvUV6XIou9twCDo81q/
+        PtLXk31Q1spL7QMLvR+CoaPvPTpgbaaO3LTtngjuFEe29T4JCj+J7JMvHBB0GGaUA+VwPu9FIgyA
+        FJkbSYPC0TURTVfYX+8nJAl9whKdkGP/cehmPfBKp77yDdqVu/XrbX0L03KFgn2IEz8dYsvRX3rl
+        w5kTKgvedo/D83+gnTNQrBYqA/y6oX2s9oqFmuepM6V7uCk/P/Q2gVNwvM8eO5DzGMcF9BtsdUw6
+        cGNcnjD0vQqqoKKl+CC7OqjrVORK9kIbWeiQv6iAMqqGGRkJ2BhUB80X9lBKqccDTcA5tnBR/dUu
+        6Tou0+wDRTGgUb4pJIahSzjpEulj+fwwaEPzVx8Kba7OxFkMVGdCFTR0yiPgWE1U6afFaAjRZOqb
+        HQj31hsEcqzfzqfRbBcsPNMbiqS9mtmnJGlbpfkL24P/x+SvdA/+R/RLtiVhNNR03GH34Q83vk9o
+        ApOveEsmu69sG7GUz8BBtjuEnwx1OABZEIC53YxcMlL2vm13loP373Yrh0mSsTZ3DQoqISM61LNR
+        Rho2dW55hYY1fZTuXmKNsD9E6/fCL+4voeDZ+5d0UAd3aKoHjQlDWuoZnXDThK8LBhnQ8QAfGpjO
+        M/dmkGgX+ndhEXCB1wuo/M506ri5aypag/drPyqI0YLfhrRZht9U57cqL9WvKrCGsBzaZSgOBpqo
+        A+WxBcgrBjTeum2tUX0YY5A9BjRKPxsDRkG4gIPTNnn9jyev1yc/HNPdBmCKfrPcREeOD8MTrU7z
+        l0MdL7uV6b+SMzgQLQGFbyocMV+APR0MbCDUgEl9+uGcN5RRcugAIA0R0k3m4Y6lum1uBY2iHDTs
+        ZgMqb4BjSVhJw4MxgIis50xvm6+bGOKg2dRN3NrzILsVWa9Ze2xrPO/kSp7v1KOq5sXrJoVHYIS6
+        lc0pio/g0L50TbwRwf5k9UbQzh0KEfuKltDdU05eZElG+cUGpklIgsN3knTkmeI2w2bk3Jxpztgc
+        nI4MBIanT+7pvnctoZM7S284I6Wm9WVUZDao7eENd5ueXSoRHc9vCnEI2phWgLNaRZs5qaqgDW2Y
+        xGeHqI/2qcck3REerLHbCXCIgoLhDS1tqHYIVh9xcSOlu0EN7/rJh5/Vh3odBfHW7442KMgDgxua
+        P6YjZ1+muUsRF53k9HCg2FGZ8FkaCgF+ddBPTBSq5Jn26UaZVr33H1kaOhCHTd3Ik0yo080XMN/N
+        Ijw7UU5B8mJIrzJkgXZFtCs16gqRpUlJFZjPx1LUBZvcFqkC3F2eEHUG9rG1pIF7KMc/r1hQRKXA
+        R7FU+88rhLdoZSkDpD7ScGjgfceadq+t4m6irJvaL7p50Tg71Fdl6wUNmSkcxGlLizDa+V5xYIIy
+        8pl1IgkMbejETasL0t8HFVKdW39SVDF0DQc3/BIFXz7FyQHvJsVfaFd+32IggUc94ZwPBZMNLh+p
+        YfUrXkUH8mpvE+H36mYnAPBrwqV4uR9X8WnnTIE68YYQF7YHybIU2ci2rXmZahxK9AES7GU5FIUJ
+        nzXgVUx3FDFRkT6cxoR4W4HOIutXEq7jyA8zBsn/nhfkiyYHe5LfYHK8wfny3wXvtV1f92qu+i/G
+        xmVOI8TGASH2ko7lzJDl0r+lb3lWE5XeC/28I8+Rxbqy7zyTrE+JF4VrxsJjKgKObOml9zLrEWbh
+        reh7Y4qQTwT3ys3av5Q/y+/ddNPjG8nuzd+nmQdsB9kzwwNPyQMJDlMv8VcEqg7KpOE77NTu3SoN
+        BoGMI9q/w3JYa9nv9M4x8xMgtpF/9CtZpfR7aRuqNAuoocrtqDJDRRd0hGNf5KDWz8V2IHO3eiaE
+        swBkHQs3qpKrVzqTNbr15hmO8XrTWIJGAd3FWT7srK9NLTwRuqeCoA+yei14UuSY8zx71CEWsqeG
+        fQ376sC+lCeDzN+Rwhye+Jffjgl3/BeW8MTJfLuTCt+3+U5pNX8SILXOPHtxi/0dpcKP6sgEySFE
+        U4QVZsEhwcumlM0WUlcGp8nT/96JTNva/xNz9e28F4S7kUffbrfQoS77DvqviyICqZCqG21UiFEh
+        RoUYFVJRIWmUYAQoTquPdbEl0esbCUmCm/a0xVoukmVfPna0T/IH/bHNsjj918kkDnC2iZLduHiC
+        sRftJuvISyfM40/IhiQk9Mgkv3Mqjim3487ujJg/U9N9qP8aBftic165A90kfDJlwz8h++yTXqzb
+        zhdUZWME7kpZ11D2dpRFW/9tS3FK70rimSFxHYlty5l+2osXp0Jj+tknu1pHZOYHMN8ufxdEMSQp
+        lx1Q8bHypWVPq3qIAQqESAKqFz/S7JzVxS+vY9DiJ2EMWn68aduDj/w26eT7N1OegBeryNrP6qOq
+        pHDKxxbaBDjdIvIZH4l68UaQAylr3HT6XvxWxXHNnzK/VRFR+VE0GZL7t72PKGxNzeLV3ReAm1uG
+        qKqLqPopJmeM1+QwiRPf42pp769z2t1blm1UcMXEMOLpomHEwRjxYkEWs5QnZ8Z11Unyj20LxLKM
+        15BlcQNIm0zacsEX265JnBCviIOsWRYXJY1jOXN2JuzakvLo8u57UekNVdedoLIQLjXFTwYkfMu2
+        r1vKSXkK1ZhP6y6WlWTL7kX+Wg/RZiH+1P9JXncst2/G/0zhShbvJXjYwh/kXqjLSQcfoioYj5uf
+        0iSpR46krmvhwx4l9zdCTu1TnoWxDO5DkLsKlXy5kN8gAvKIhz0V9cfYje9ncOad2ZF3QqqYDgTl
+        GAs9/8Z4KSAhgheHK8x4T/qh9tqVgl3d43Syt3cKh2ob+byCl6nRPfjkA1kv+SGFYWrD1I/D1LZj
+        mPr4uWFqXZh6YpwPw9Ias3RP8QXjrRgpMFJg3BsjBc8qBRfsf+L4LEul3N6Rga8sE7sPk4FqLQsA
+        j3FPyEF1JXXwqmTAm+oUPaLtrAnbjFtTDre7tSUDou8OFYs/F1lL2BnO+Cdx5uc0XBnDZw8fpL+p
+        0wOt5IYBMfEoVAGpzR5ouLzCWf9FlzocJmxwkN4jn7LnkpTmmXT3O8nYJ3RRFB47jtzwvGNZf95x
+        caJ7vdHg2043lohCSruM0dDEaEDnrfHrjgZDnq/YzljUn/caS2EshbEUjZai2KyJDAXLc25hIaol
+        vZIvHDsmOZb1flGfW+mtBy8KFq2U/EhTcqyxO98Xh04c4nOcheuEtK32gCosED/pqmKDvCDar09m
+        iCXMHwjVop8I++eUZBag8zvt7a+1PM9jYJp0uzEVYiPA5LLpZXvbVAhMxcRYDGMxjMUwFsNYDGMx
+        jhSUW4y8CMZ2xN1WzImFUenmxOJyjYlDmTjUg8ehRCcWhS/1Sr0nL6CkJ4gCFZIMTdH892uywftA
+        uNGQdfN2xwtxZXZTU++yv7i4sr77ij49wt/j2+dIrFmrvc0csLM5UwPhMNsmUex7r4VGbOq3x+td
+        oaGaVtfUX7x2Y1Bx7+FbA6fYMgqb9eE09dOMwkGBIhs/CCQiwJT4PqM/tU9lAvcYaqhbYVf+7T37
+        nUKbHV/iu7J4WsrDyfXKSUt9k/TXPUm+SvpBtDx3hFg7jx959fCFQ1O7Oog+4It3ZO3vd8f15+X/
+        KOm59d57Z/++RZOzkmxoK/L9FVFy0/Eu9ZrghE25XnpHMrzGGa6CFkZZbkx+/In+Jvv336PRX8Kc
+        9Ud/CNMPkoz+8F9/GfnpaJMQMsLherSOSDqi3xsl5Ne9n7AP8zXv5Gv8gwfin/7xT/8Pg0DBamWt
+        FAA=
+    headers:
+      Accept-Ranges:
+      - bytes
+      Access-Control-Allow-Origin:
+      - '*'
+      Cache-Control:
+      - max-age=300
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Length:
+      - '67661'
+      Content-Security-Policy:
+      - default-src 'none'; style-src 'unsafe-inline'; sandbox
+      Content-Type:
+      - text/plain; charset=utf-8
+      Cross-Origin-Resource-Policy:
+      - cross-origin
+      Date:
+      - Sun, 01 Mar 2026 08:56:38 GMT
+      ETag:
+      - W/"75f3774b8a8cfbb51843538461ef3d432db2f2189d8fbe95e640da721367e0a8"
+      Expires:
+      - Sun, 01 Mar 2026 09:01:38 GMT
+      Source-Age:
+      - '13'
+      Strict-Transport-Security:
+      - max-age=31536000
+      Vary:
+      - Authorization,Accept-Encoding
+      Via:
+      - 1.1 varnish
+      X-Cache:
+      - HIT
+      X-Cache-Hits:
+      - '2'
+      X-Content-Type-Options:
+      - nosniff
+      X-Fastly-Request-ID:
+      - 502bad0eb9a027dfa16e61ce00ddd4b428f85917
+      X-Frame-Options:
+      - deny
+      X-GitHub-Request-Id:
+      - C88F:3EDCFF:29149D:540B3D:69A381B4
+      X-Served-By:
+      - cache-pao-kpao1770073-PAO
+      X-Timer:
+      - S1772355398.133577,VS0,VE0
+      X-XSS-Protection:
+      - 1; mode=block
+    status:
+      code: 200
+      message: OK
+- request:
+    body: null
+    headers:
+      Connection:
+      - close
+      Host:
+      - api.scarf.sh
+      User-Agent:
+      - CrewAI-Python/1.10.1a1
+    method: GET
+    uri: https://api.scarf.sh/v2/packages/CrewAI/crewai/docs/00f2dad1-8334-4a39-934e-003b2e1146db
+  response:
+    body:
+      string: ''
+    headers:
+      Connection:
+      - close
+      Date:
+      - Sun, 01 Mar 2026 08:56:40 GMT
+      Strict-Transport-Security:
+      - max-age=15724800; includeSubDomains
+      Transfer-Encoding:
+      - chunked
+      x-scarf-request-id:
+      - a6812904-3a96-47d8-8600-a2e465aed2db
+    status:
+      code: 401
+      message: Unauthorized
 - request:
     body: '{"messages":[{"role":"system","content":"You are Calculator Assistant.
       You are a helpful calculator assistant\nYour personal goal is: Help with math
-      calculations\n\nYou ONLY have access to the following tools, and should NEVER
-      make up tools that are not listed here:\n\nTool Name: calculate_sum\nTool Arguments:
-      {\n  \"properties\": {\n    \"a\": {\n      \"title\": \"A\",\n      \"type\":
-      \"integer\"\n    },\n    \"b\": {\n      \"title\": \"B\",\n      \"type\":
-      \"integer\"\n    }\n  },\n  \"required\": [\n    \"a\",\n    \"b\"\n  ],\n  \"title\":
-      \"Calculate_Sum\",\n  \"type\": \"object\",\n  \"additionalProperties\": false\n}\nTool
-      Description: Add two numbers together.\n\nIMPORTANT: Use the following format
-      in your response:\n\n```\nThought: you should always think about what to do\nAction:
-      the action to take, only one name of [calculate_sum], just the name, exactly
-      as it''s written.\nAction Input: the input to the action, just a simple JSON
-      object, enclosed in curly braces, using \" to wrap keys and values.\nObservation:
-      the result of the action\n```\n\nOnce all necessary information is gathered,
-      return the following format:\n\n```\nThought: I now know the final answer\nFinal
-      Answer: the final answer to the original input question\n```"},{"role":"user","content":"What
-      is 5 + 3? Use the calculate_sum tool."}],"model":"gpt-4.1-mini"}'
+      calculations"},{"role":"user","content":"What is 5 + 3? Use the calculate_sum
+      tool."}],"model":"gpt-4.1-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"calculate_sum","description":"Add
+      two numbers together.","strict":true,"parameters":{"properties":{"a":{"title":"A","type":"integer"},"b":{"title":"B","type":"integer"}},"required":["a","b"],"type":"object","additionalProperties":false}}}]}'
     headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
       accept:
       - application/json
       accept-encoding:
-      - ACCEPT-ENCODING-XXX
+      - gzip, deflate, zstd
       authorization:
       - AUTHORIZATION-XXX
       connection:
       - keep-alive
       content-length:
-      - '1356'
+      - '568'
       content-type:
       - application/json
       host:
       - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.83.0
       x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
+      - arm64
       x-stainless-async:
       - 'false'
       x-stainless-lang:
       - python
       x-stainless-os:
-      - X-STAINLESS-OS-XXX
+      - MacOS
       x-stainless-package-version:
       - 1.83.0
       x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
+      - '600'
       x-stainless-retry-count:
       - '0'
       x-stainless-runtime:
       - CPython
       x-stainless-runtime-version:
-      - 3.13.3
+      - 3.13.5
     method: POST
     uri: https://api.openai.com/v1/chat/completions
   response:
     body:
-      string: "{\n  \"id\": \"chatcmpl-D2gSz7JfTi4NQ2QRTANg8Z2afJI8b\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1769532269,\n  \"model\": \"gpt-4.1-mini-2025-04-14\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"```\\nThought: I need to use the calculate_sum
-        tool to find the sum of 5 and 3\\nAction: calculate_sum\\nAction Input: {\\\"a\\\":5,\\\"b\\\":3}\\n```\",\n
-        \       \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\":
-        null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
-        295,\n    \"completion_tokens\": 41,\n    \"total_tokens\": 336,\n    \"prompt_tokens_details\":
-        {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
-        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
-        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
-        \"default\",\n  \"system_fingerprint\": \"fp_376a7ccef1\"\n}\n"
+      string: !!binary |
+        H4sIAAAAAAAA/41TTY+bMBC98yuQz2EFISjbHFfdSqm0lbZqtYdmZTlmADfGtvzRNo3y32tMAiSb
+        lcoBzLyZN29mPIcojhEr0SpGtCGWtoonHx9f7NN6/zcvXp5V/azXlIDSn3ePRd3maNZFyO1PoPYc
+        dUeljwPLpOhhqoFY6Fiz5XKeF8UiTQPQyhJ4F1YrmyzusqRlgiXzdF4k6SLJFqfwRjIKxvv98L9x
+        fAjvTqgo4Y83B7JgacEYUoO3nZ28UUveWRAxhhlLhEWzEaRSWBCdduE4nwBWSo4p4XxM3D+HyXns
+        lnfEu98ZEUAWbvntS9l8elibp+zh+9f9JF9PvVdBUOUEHbo0wQf76iqZxwRp4ZSQOu7bio1rrwi8
+        G9G1a31dnXh02CCyQatitkFb/82P6ML9GN06v056oaFyhvC3TSJCSEs6raFLryfkOAyEy1ppuTVX
+        oajygzYN9hfDhDqn7Y7OQoIE5C4mijxdqyy2cgch6f2yJ0XjrRvB7P4EWi+TT+xpMbtBh0uwhIWJ
+        D5eMEtpAOYaOl424kskJEE1Kf6vmFndfPhP1/9CPAKWg/D5hpaFk9LLi0U1Dt5TvuQ1NDoKRAf3L
+        Lxm2DHQ3jhIq4ni/KcjsjYUW+5nVoJVmYV1QpTDJP2TVnAKkKDpG/wDAsN1TPQQAAA==
     headers:
       CF-RAY:
-      - CF-RAY-XXX
+      - 9d56f32499ad8f74-SJC
       Connection:
       - keep-alive
+      Content-Encoding:
+      - gzip
       Content-Type:
       - application/json
       Date:
-      - Tue, 27 Jan 2026 16:44:30 GMT
+      - Sun, 01 Mar 2026 08:56:40 GMT
       Server:
       - cloudflare
-      Set-Cookie:
-      - SET-COOKIE-XXX
       Strict-Transport-Security:
-      - STS-XXX
+      - max-age=31536000; includeSubDomains; preload
       Transfer-Encoding:
       - chunked
       X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
+      - nosniff
       access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
+      - X-Request-ID
       alt-svc:
       - h3=":443"; ma=86400
       cf-cache-status:
@@ -96,25 +1370,29 @@ interactions:
       openai-organization:
       - OPENAI-ORG-XXX
       openai-processing-ms:
-      - '827'
+      - '479'
       openai-project:
       - OPENAI-PROJECT-XXX
       openai-version:
       - '2020-10-01'
+      set-cookie:
+      - SET-COOKIE-XXX
+        HttpOnly; Secure; Path=/; Domain=api.openai.com; Expires=Sun, 01 Mar 2026
+        09:26:40 GMT
       x-openai-proxy-wasm:
       - v0.1
       x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      - '30000'
       x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      - '150000000'
       x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      - '29999'
       x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      - '149999955'
       x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
+      - 2ms
       x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
+      - 0s
       x-request-id:
       - X-REQUEST-ID-XXX
     status:
@@ -123,95 +1401,1590 @@ interactions:
 - request:
     body: '{"messages":[{"role":"system","content":"You are Calculator Assistant.
       You are a helpful calculator assistant\nYour personal goal is: Help with math
-      calculations\n\nYou ONLY have access to the following tools, and should NEVER
-      make up tools that are not listed here:\n\nTool Name: calculate_sum\nTool Arguments:
-      {\n  \"properties\": {\n    \"a\": {\n      \"title\": \"A\",\n      \"type\":
-      \"integer\"\n    },\n    \"b\": {\n      \"title\": \"B\",\n      \"type\":
-      \"integer\"\n    }\n  },\n  \"required\": [\n    \"a\",\n    \"b\"\n  ],\n  \"title\":
-      \"Calculate_Sum\",\n  \"type\": \"object\",\n  \"additionalProperties\": false\n}\nTool
-      Description: Add two numbers together.\n\nIMPORTANT: Use the following format
-      in your response:\n\n```\nThought: you should always think about what to do\nAction:
-      the action to take, only one name of [calculate_sum], just the name, exactly
-      as it''s written.\nAction Input: the input to the action, just a simple JSON
-      object, enclosed in curly braces, using \" to wrap keys and values.\nObservation:
-      the result of the action\n```\n\nOnce all necessary information is gathered,
-      return the following format:\n\n```\nThought: I now know the final answer\nFinal
-      Answer: the final answer to the original input question\n```"},{"role":"user","content":"What
-      is 5 + 3? Use the calculate_sum tool."},{"role":"assistant","content":"```\nThought:
-      I need to use the calculate_sum tool to find the sum of 5 and 3\nAction: calculate_sum\nAction
-      Input: {\"a\":5,\"b\":3}\n```\nObservation: 8"}],"model":"gpt-4.1-mini"}'
+      calculations"},{"role":"user","content":"What is 5 + 3? Use the calculate_sum
+      tool."},{"role":"assistant","content":null,"tool_calls":[{"id":"call_kw1anea4u7TNdhFBIsM1BURy","type":"function","function":{"name":"calculate_sum","arguments":"{\"a\":5,\"b\":3}"}}]},{"role":"tool","tool_call_id":"call_kw1anea4u7TNdhFBIsM1BURy","name":"calculate_sum","content":"8"},{"role":"user","content":"Analyze
+      the tool result. If requirements are met, provide the Final Answer. Otherwise,
+      call the next tool. Deliver only the answer without meta-commentary."}],"model":"gpt-4.1-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"calculate_sum","description":"Add
+      two numbers together.","strict":true,"parameters":{"properties":{"a":{"title":"A","type":"integer"},"b":{"title":"B","type":"integer"}},"required":["a","b"],"type":"object","additionalProperties":false}}}]}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate, zstd
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '1028'
+      content-type:
+      - application/json
+      cookie:
+      - __cf_bm=Hu8cFIzAIrNKkL_knpDrgF.pP.gIkJEWZyXaa._.ma8-1772355400.416349-1.0.1.1-HKC5orWTR15NxmVk.ZTMoqXHaSwM5YIWx1cLpnlzvxXQ1r65BJUVP1vX6bCcWK7V41hYyewlcqm.HI79ImWmsmnV1.4nhPNWP6k3V4Ex0851jZjwmiNXUlLYV4zggFTO
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.83.0
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - '600'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.5
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAA/41SwUrEMBC99ytKzq203VZdj7LCouBFwYNIyabTNmuaxGQqiuy/m7S7tuoKXgKZ
+        N2/y3st8BGFIeEUuQsJaiqzTIl5dPeDtts22d+L1/qW5Wa0vC7F+W25OT6+BRJ6hNltgeGCdMOV4
+        gFzJEWYGKIKfmp6dZYuiyJN0ADpVgfC0RmOcn6RxxyWPsyQr4iSP03xPbxVnYF3fo7uG4cdweqGy
+        gjdXTqJDpQNraQOudmhyRaOErxBqLbdIJZJoApmSCHLQfj6vG6h7S7042QsxA6iUCqk3Nyh62iO7
+        Lw1CNdqojf1BJbXzZtvSZWFdMO49i0qTAd2582nw2n+TT9ygTmOJ6hmG59J8Oc4jU8YTmu0xdALF
+        jFSk0ZFxZQVIubCzsAijrIVqok7J0r7iagYEM9O/xRybPRrnsvnP+AlgDLRbnlIbqDj7bnhqM+A3
+        8K+2r5AHwcSCeXUbVSIH4z+igpr2YlwLYt8tQle632rAaMPH3ah1SRfLtM4YQEKCXfAJgIJT3CoD
+        AAA=
+    headers:
+      CF-RAY:
+      - 9d56f3285f248f74-SJC
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Sun, 01 Mar 2026 08:56:41 GMT
+      Server:
+      - cloudflare
+      Strict-Transport-Security:
+      - max-age=31536000; includeSubDomains; preload
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '284'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - '30000'
+      x-ratelimit-limit-tokens:
+      - '150000000'
+      x-ratelimit-remaining-requests:
+      - '29999'
+      x-ratelimit-remaining-tokens:
+      - '149999915'
+      x-ratelimit-reset-requests:
+      - 2ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+- request:
+    body: ''
     headers:
+      accept:
+      - '*/*'
+      accept-encoding:
+      - gzip, deflate, zstd
+      connection:
+      - keep-alive
+      host:
+      - raw.githubusercontent.com
+      user-agent:
+      - python-httpx/0.28.1
+    method: GET
+    uri: https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAA+y9eZPruJEv+v/9FIzyzLM9r0Fx09bx/Ga6vU2/6fZ4xmPPveFwVFASqsR7KFJN
+        Uqpz+oa/+wNIagMBEqBIcVGesM+pLoILcvllIjOR+D//QyN/XmJ3t/fxa7zH65evtf+T/jK9sA43
+        +NULEhztI0z+fl2HcfK6Jz/EOI69MCDDDd346vqO3f5ARx5ieif5+XKP+ek1CT/hIC6/Kzwkkrdt
+        MPmstZuQD3nduAkmA17ov9rHFgdassXajkzA11aYvADH2mk83mhedv0tjHZuov0v8gf98AP6zW9e
+        rh7/5lGiYDdab2++Zu36fvFjuKPfV+k/G/dLYTxDHPew8cJsolVD+YN8L8G+v3vdR+HR2+CIEiMM
+        sBa+adsk2cdfTyabcB3r+Tjd9dL/npzGx9dT37mfc+6dSU9/p6W/07LffaV5bykRT0/QqAB5bx6h
+        tJfo9GoQJoTob+7Bpzdp9Kn585h35Ty/fVn2yxbednnN97/9/Te//l/a3o3cHRVwXYvx+eabj6Iv
+        ELz6u9+lr76685p0X4nvvPkuIqkXln2trbdu8pWGdyu82XjB+1ca1REfU1knT9y57/j1HQc4crPf
+        5OITuUG8jrz99S/JK/F6y7uJvvP0c0R+Cj59pWUSfP1lrD5G2I3DgHyTQBDZ8fxRZ00h6PL5avSP
+        Bxx9uUEh3vDY+wm/br33Lftc4WA//JAeu8Mb77DLhp9H//364w/7fRgRHCHEeCfko7L019vnvvvh
+        yvVfmLcdYvSB4wRZ7AV8yC6Y7AV3j2JC0S0hOv9qQD7kdPV88W/Fj41ziEllk3xvEh2weFTGxJJh
+        b4dgnQIvRUMiDCVDqXb5PvaV7omIuBOxcNfb8oFnaSwdE+8Jkwg8r7d455aMjL/ECd4RAYhjoixx
+        ycijl9s/0YAPvMrNQXHQEa+TkBhR8hcWG4t0fC52L6ZhOegzov9MpgYin7mPJwQconD9aeLu3J/C
+        QA/Co4vWbnB0Y3Q0vzZujTnPQOQPqIB+a2YYHKhiAaUMNNKx2bRm1fOKE3flke/9otOffIw23tvb
+        gRIcffbJ1Jqa2Hwusgy3V+6bsCOc8IboAcIEDW7mw5j7vfcZ+2SEqS8xMhZVJn+PA9fjWRaVrz+9
+        s0wKCb1Gya7FzYyt6YxMmPytxixLdxzTIfyad8qvqWmRryd/S+tWY6DxGGaZC8F8lbg10xezznXr
+        8u3SmjUwZtm30O96lqn/bwvtvE0BJARLHlO3poRR0wpGyU16YS7NinUIZ4jwWk4b6riX0YOdCpck
+        ZAkTufJEWSxGQ5RsKhyiuLuVi0w0Rb4bvWOOfyOgjkWeN2uENMQIGLeOEIc43EElVxUJRKnD06Iz
+        dXZe4KkRp8pCDYc4qb0VEccLYuKFrxN54kwbI87cqKaNYyxnIsqw1xTpMmcmUrHcYSi48wXGlEcP
+        OvyGGDhxN27iFlf0QZikb3z5zTfff49+q1na0XO1b76b/PC99s0fv9OQ9p/Y96jR0+jKHCUhSk2J
+        dmV2uIvzO42UdU1psvSO1unTbmJodJbu3tPX4W7yUiQs3rziYLMPvSDhRAYmR3OSvi+eXD4uvlq7
+        C+lvt0l/u0D/f/Xet+jHg0v9j8fyYGr1jwdv/uEzIqRuhQe/Iw/XfoOPhOrkb+yH+x0OEu2II+rr
+        aeE+8XbeT3hDA9Ya/kzI5dEB7XFgNu0vB8itusSassCGJmXyEVPMvMCHT3RmP2qiESbYEu/a06g/
+        RiHRKPL3W5aucn30HrkbrLEoliWKWtEkp4f2hFJ/ssHH58Ay2+4pBz5lSQdEfL3JjX1tVyMothDm
+        /DbYusGa8OHEmQ8v2RLNoK8hv127+yz2QJNVbrDRZp+1N5f4i5HmBW84wuRems7CmzaYZhpOz5lG
+        URqYNgy/bRKvtwFhR3ss+lP2AsKh3xFyFywLg3rtcaCPavMehu8+zu4KkKMbeXgrv58sTo067lw1
+        Z75L36iRN2p/pm/Ufp+/MV/g/HEb0gwcdUISb110ClLdoiUjXpwtQjWiQORzaLaxDebNF2rMI/8S
+        HypX6zgjMErlLWaJzpD8gWwP3CBEK5f847a2fPo9pmEvsoSlSJlyXfvFH8h7tW/T99Jf/5Lw+5vN
+        MQNP0WI24/g5pZwiqPNv5Bdx6B/SATmxWjF5S8U1lwT731PCIJtSPpst+QkfPfzRtgQMNyN9iPWP
+        yKPFQHvX330hWvPZUYio6lP5gDMtO6GGHFdM17QW1QHEhbm0mCHCa6pheSa9UKsKZPN2U3tSRfOp
+        PM1n8oFaaYobhkTMtkWSzxgpapzkIOMPlnEQ8McK+LUJogRTI3dVLYAiuW0ZapucMeKLivS2dLYc
+        pQmKc8fI1+7J1uXdVNsJuWyJ+Ew/BdNSwc01X1IakYHzFM6uGS6QC7srNZw5JYJRuKgsGCya90Aw
+        mizqpLyprnuVFTHqSec+NLIMa2qSv5RFbqo7s8WcTTALza2ZjZ2Jx2aer8odtxsOuHeMQ75Nfc7W
+        DIGA3wr43l3rDQDpIitpkkFSfaxYWlAikLUqWQNEHZiUA6JWSTk+AJ4CnnYiaYCmA5NxQNMqGT/E
+        gKaApp1IGqDpwGQc0FQtnLU7+IlHiOz66NxsoNlc7cKcl+QQ5rwcwvlLXqr1xdTtCs06ZXpnjFww
+        wzK6Zs1NiLxvXrKCmrInZ1pVvMV0JCSV2zXhtDPc+4l+sW3MyyuqDjHKtv7r5PVx6GPd/ThDGK0R
+        OO0Q34Y7/M9Zs4JfnW/62SStFkBrN3H98H0S44houY/jeCItJDzZO4/JgapKVuVGycl9scmBUPh3
+        3pqgu3RWyC6kCR6V9Ww1L2Q2kxe6L+cj5NFehUOL5r227vN2ts7uYOyBPWssb5e1nalm8aktDIVX
+        UwzIfGxVsF2bcH2g1eiv6+0h+BTfvNssMJkVFqtaVnhj0heUD5G4mDUPufl+6nuaPAObkV1G/Nhd
+        6jnfEi9xg8wY5HVlFZuVJY1wDVWuRlihat5eqq4z/DnPZP1c82LNvW4u9uZhf6Nrf46x9vNyo0ju
+        DeKELBv08opCrkN0h2NBG3i06licu4r9c+pi/OpGbDKBycv0woiKTjtuRJXkpnWgsrvsG5PIGkU1
+        jfN/yvZiEBHHevhO8j6Qh6iHmDwc8ZVBvvIuadc1/IuqcYSqeOcddjedUCpvclfhEb8Sg/DqBpv0
+        37QVSXzv/el/8r7IqiEPokpeBXaU93zpGTuoqKUETH+owxDeE3rHkgoUAaa0wpTkA/tH7LurWN+5
+        EQ7ewxzbLTSXX1bNG2suo9hmqG2vpyVH4xDr7RD+QQErsW7err1ADsrlAB9ADkAOblB4j9/dmCyT
+        TMTLIkny1VlKTH+uskeDZ1nY+FRJHLYE/Z5gwrdq/gQTvnH10lUi/kzcmjiWb1hnN9aUzZGIuXFC
+        7MJr6unGYke2An3yegUp4iiUHjRAmrJU7J2ZWE43tgJhUm8YR130ZJOhjlokVll0pkXRCZJtFO69
+        tb72iY3GyEZTtHW9TwdafeAQgyWuPlhHODsKgVOBYDL6VlEpI1cm01yM1up4L5ojyrC4cezFRFoT
+        um5789IOEk10RO8mG5OEof+63oZeGust4jorfJngOUQE09IX4vXVE76s8Epe/thQa0lEtuECFilB
+        bLV+pVCgVQjNM4F4d0UehcgvJx/kFTEK8MeEsmtiGpOcj84ZRM4sRtkTEEc/awn/9QkuvdSRJitw
+        inrE96L4JwSkd9ODbvLum/kkLnbFqbAJZ7X8l5NagkaCRoJGtqmRvMcFRL+O5KaEzGV3mUm1Q0cm
+        HuAk9eiMmWUolCA1tmySq9RssSdx5v0+okzzUVLE41meDSAgdnWIGdv5gEsi7p02Q7IKpOc+oxg2
+        KIF+4ffPlb/C3EYlb5e4m/stRTGqtn52sQy+3PrZxZVshVpnC7VC1qutb6u2zI9GjjYbtYiRY1T2
+        EVBr7KhVBSlzCU+hGlIcFdKlEMSSSlgQzcrEcCNAps4eoTJOUOnY6VaR+KlhmctaEt8DI9ro8haM
+        6djl/hLiN2xDoTIg6930wCB8qyvCQlBqkEvCKl6H+0OcsdqyePgmTJo2d/JZ16yeN7L475SL156Z
+        Eh+bW4l1zcWRhHDKOU33Z5BfymbvG9y3IukZtHUUX9YvkovGqnnEFPEcWhJDvbqFwet8KpO0WBS2
+        dldkLQornyawtVHXrtUKAw7MNnnq+pV0CUefj12XGXx97rp5Hs45eB2c044yIeZ0KaXqqaJPTV5P
+        aVD08xhQdFD0wphhKXpeGmTWLA2aqRYiSDbRaaG3TfeFCBZoOWh5J1o+Kyx/7lBttcQP58R3NYRQ
+        zROxNUySCCOdR2PPmXhY2y1uq5mSq3ejk0KGkNO0a8zQ9ub6MWDbY8so3/1w5fo6QBxA3PkqQJx4
+        MEDc4CCOdi9tFN6KTULr4ZutGM+ZFtKayhCny4KcVOio5B3jBLoCw+SRztHNgj0DqAOoaxTqaNt7
+        gDqAOoA6gLqRQ50LUAdQB1AHUPcEUMfiXF5lR5BOFeaENeAt7jt5KVaS37tLRbKIsPYunlEkRotV
+        HfK4ZhWDr6OGNciq9ibzAOAG4AbgBuA2aHDj5RzqA9tplXEvsi1U68qKR/4pg5v8ttn6AKey43ZI
+        EDe7B+Oc58qsAsj1ItsAIJc+AUAOQA5Abgwg5+7dNcAcwBzAHMDcmGFOiHB3bVp8VM+ZB/Tr4kSN
+        +tGyaywnlAPEAcQ1CXGV27jOEJdt1zSW3IYlAHIjAbk+eIGAcYBxD8U4hQY9TTbCrdCy1hv0VDQR
+        PVpfPyld5ESUod6XmKggnvzr4f2dqMXv3DX+V2fyE95vv0RovkIrzBwPXt5npArWT++rIujMXjgV
+        9OSNEV+sheZsB+ycVmt6vrfv7tzJr8lP39OfkO2s0HdBTAi8TtD2TY5kEgIoSTBOz7NHtkXDxVOd
+        Smg1N56dVteaWjhbYxOuaYY5m0t6vAYxu0cPf0xwsNmHXpDEk/QoscsZuJNc3/EGpYfPxxe6IzHd
+        +Rx7D8N3+g/e0VtWyEser/+c9q8P7xA7b59JGanRNan5PNkRFEaZGmWstJBprxCdkKwCyfVNHYQK
+        WWXgzCEVlXsVUo0La+TJpEil8QhUqbW/otQP9Mfc3hOp+vaMpo8Wq47x8TEm7EJ4JCa8Gs8WqiwD
+        o9YY2xbVXPPIZdd3vckP2U9ofrkHHQ1d9qzdEa5EHsC3E/WRkPoKkZxqDn9O37H4bFl1mLxsjsWz
+        6dSuMj68MeKLiixm5/IABouJ3wqPQY+70WMh/WtzOa2YyQ5+DMKjezrnW7IT/CwtHllUsFQx9m9L
+        bTTljBFfVF+QWCxzu490y0axS1rDs9zeeesoVGj8nx4V3zC7uVuGH8puU3fYpve12H0fK8s5tVfh
+        0yKNHzeckuteLW3dZrOlI1LLnh6zCkd0FEfefUSHDMNHfAAnHBnWL2hqS57hTLCxngnGZXjG7nNH
+        faNmR/1TWx55AMsa3khAWLH7zihqlYq9goprUfcjPjmUdCHqrsjDEPnl5IO8JEYBWZRSrk1MY5Kz
+        kzIyY+mZ0yh7AuKo3jgRdDjVRXJ7YeDUt6dyKWFjwBPVzMLGACiaHZ1ZKxTNxjHerfwvrjdZ4bg8
+        6xtjwuxNFjiybYmWiJeHv3CUgCCqF74mkRvE68jbU86V6cT57US2RFMI3CCUmwJ5CPGnDWteFX19
+        0BzK2gncuUVDvOtWfrvsIza73rcptP19xJL7gkexAuLs2QXLA5an0QXVT4cIT9yNZPm8TKqbPrG6
+        yEh1lwGBf7zZUCJLKE4B2NNZ0mrjz2jnBR4PvMUwPJc83LB42mld+khBD3c/R8nVnJAnSYxlCCnI
+        TOHN6znXT0b99RYZJkdzcnnL+drfuM8hn+USMnmY8yAKLC8M7Hg79x1XPTSfTuWzyx6jhiduRMZg
+        fyQYlIPHDscxoXbc5go/18zdzg02KEJ7/xA3FriRUTWpRH2vwjZF+r0Sp5uNVqv6p5yIvpwzZ24p
+        rS210LYkoMry+JVZF/TRmRPmS8ATahNbrnTjdDSyqmrUPk4wUw322IKHHaQ8GNXgHKAMytGNcjDd
+        xCSlT56xbctpQ0d1DH2Z3XNQK1VvOOCjgwA0Hw2UDzEy80OM1GOCmVix8eyqCgmZ04S4TnbbOGRb
+        JTBUuKhoL+dgLzu3l5e8gKqO1D4kIlMRNiTzsCrIwbiTz1IIOQj1eNwZKqAeoB49Ug8Fb4yflDkR
+        GJE7Ub7FTmp11lRoVGIruGlY4r2IzDX1EmO+mELygRlaK/nA6pFw1TX0zEKQuF6QCv21GSLCSMSd
+        aBdRLApiV8Uhcf5Esri2lbXoWsj5BvJ9n6AwjpFpGSspdS7uyS3L1kmlZ6vNlGmbxrxS+3mDSq6K
+        gi3Fsm76kXq6jzMO35K0thsHBAgn+8hbE1mcbDBha9pB6j0gSnYkHgeOjkRW4km4x4Hrnf57orKL
+        uCntusew8KUm3Tb9GoXUIEhKDbtbUpgsryMxLbDywrP4hmk0OYgD6hS8/M53E41OQAvftH8wdNPR
+        yEy0H7SUCFometpbGGnf0Ndq33yn/S48BJvoi/YDJaD2nykByfC3yM12mtOv0/4cY23vJuRS8LXG
+        pfnk/9ngvR9+oV+CAneH/1/tY4vJK5hfa16sfSFEyD/gclX7Bdbf9a+yp2e74FH26F9ygGKCDylQ
+        OGFa046MBTHpt3wnj47wOvOIN26SEp2MnSHDQtb8hoAVQZTixhThDqbCyFbTri23OmBjmJ3Z3p4s
+        31ihM03yr6zQ2cgwi0JXsSOKbW4KctdXq3SfONGaqxzI5shc8EICInhaFJpxCA3eTKoTyyCEpFjQ
+        CuB0K01EXvzE251XxjlkWcicS0Sc8orx8nLrO8uzr97BVXth9xlpN76npU23E7cK63hxtnjmCItk
+        0mdWRYeyUdnzG4pJ1VChe9a4pYIvkHmDmt5aMl/kTbnMcwxxqdBn+zvMaqEv7vUdttCnE7csKaEX
+        hLlA5stkXoTzV5LLlXe1LTiq8u4UWtw/ibwvpCFeHNRVDcamX9BUMFb52aCeSb4lLg1OVCkjN+Qg
+        taeiGJ2ovatizinKaKmATHn1V53VoK9Ik0I+plyPWZmlY1Zust7yLjxZSiRwaUz4NU6ICO5g60b7
+        y7LpeY1fAw9yMyuxyLeKm7GGjAaZOay1wQrQANCgv2jANk+u8gfYXJXYG5A5D2so6g/OQKPPBkzo
+        OSakJ7f0HRjkgv8ADAAMAAzNAQNtzdB3ZGjTZVDqynAHPAxDw0GZW1BmYYVnO9qs3GjF0hejCgIo
+        qfQdkQBQaVBpdmjDsT3a0a9mbC/LdC2rtTobWNkIcCBLe6fgn4AHf3k2gMEQnfXQlE++MzV8hV4D
+        5UV8Uju1O+yhplbG1+sa4yal46rMc0mkREVEZrohnRG22L5Q3HanKUTimP/sVoNDrR7D6OgLtkiO
+        37L1Mn9LdwTOZX/E8CxgqUsjlLCbIiBlIesEh6RExrbms4VIZAoXx4dCUuy3r3PMJrKVckwDAZg+
+        WK2GIaZRB0nRXInE6d0PV66P6F73jRttqvZaVcUiC7AivzlLGOMY0Y6XvqPPo7cylEkfZ9NVg9LH
+        7tIC6RvNbiuBUBWjsNLbzIfL8642T3XD88ftFJZ1nwE/7pelnluvpncKg9CB0MkJnXJxoSW/8BvV
+        VgMoIYISopFnJW5hoUZ9YQfY0IsCQ8AGwIYnwwb1EsOROQ5qNYZQYQj63K9yJJ5C16gylN5qOL4i
+        QygxBJ3umU4TZbb1KUoO0ar80OBznWBDWukYy3mFTrZ+7Nu9JRlSzRpuSIwM02JOLBBE6qY0UmfL
+        ZIsayxtwImqDY0kdQKjBRi/I2pciY2k6UnqjcDrpKwPVkuojvHZixHnZKG2sRHQAwGgbMOrgxRTw
+        omd4ceaizbaIE3PRQqYtUyMwCrXqqjCyBgtnhC3NsrC5A6uBiXJMNE3J5Ly89yV9SG6/0XRAPJx9
+        kvI7GjuhmjBm2h1jhC1Za1GOA2NPSr5WZfS0PHjalcGTL5DkZsyettniQVEtalgTmxukNcxJF0RK
+        x3GxmZShdXoVSUvvLLSjZlxA8hWpS51XkPx+Sr5tyTmlrMjUZQlvw9oDOZI1lrfuJ5o8ZADlrign
+        H30FDHgYBmSOb7YLgO6OBf50wh/eKJk06ImB2VgwtC1RWa16XLICjI1eVWwYbixmZzjz6ZzlxkM3
+        l7PN9ap2CgviIVB5OqQCluZ3ibRaHMob8IFXrzF2IyIvJdvEM8DIWw6QFRATVxFucjJNMlx+kxOg
+        TP57QBlAmadFGdVSVlMONWQa5V638miqOqN71DDTxjcquLGApn2AG8WR/ceN1l0UAJv89wA2ADZP
+        DDa0FbCKkyK930YGYK6Up6lmwT1ADhYzK5utAW4AbhRHPnx/7RUitO5+AIycfw8wAjAyOhgRlFSV
+        g4KdHQQicd72XJcZeKUcnEcPt5tUlvOvPJ/7avpFej0qnzoWiVZykqHJ2cBFrEnBySs4pkiyMOmh
+        AtH6frpeC0QLbIZ2nQAqD5O2nvTpnI9I3ERHMT63wLmHjXc5McxalBqydPDNMlbCox8DZt1OfMFM
+        vP3efQ2vwNPptNSFr/rZvV6WC7voXLfvKRnEarBwaGtrnbK8QKbtxH9DZz+l3HUFjQeNv//ZoPEd
+        a/yl8MA0CsuYUpVnJbpkz82wT6S4nbYlqfCW3lwBI6g8qHwTKk/WkJnW35zBxzkLFGw92HpQ/FEp
+        vmpl8lw6W5+dszlsG3/2VvSuzp3qdSzICa8PBp4jcwGiBKJ0lyiBI6IiVOCIgCMyIkcEkcn4ibfD
+        lQCQWZY1GZ8SNFPIK2041xExWFtRdVReYdj/QEcLOfyGwxxx/sCqLvnZqOzxJcNaNpn3KINA1M8i
+        LkqhyYo2S+By0WZHl4q2rbN8ZoZnFZnFApWSrUNNGFpb4rSN1lVgprMORvm+oZpH7WRS0k4pbc/M
+        LiBChghlaTZAhWwQoAKgwnOhQmkqrh0/eFYel1Hyg0+gwG6Jbdld7gUoPCApCJAgGDVCSDitkpPI
+        DeJ15K2wQlSMbboujLU2dxrurFoFWS3N1Sz/9Hyee9m+2YJTW6q1KH3f5OZ918GtKn6kj60u568b
+        cbwhSrzH+Gb/XQUGmQWvjR0f43UYbF7yzURWqxHEjND5HBqGrKbQiX2OmPuCcJWB2CN5ZM00yyqZ
+        nbPS/nu2V6waAoa+64Qza0tCplnag9WpknNRWLYheZXM44xLXGVzOAJpHWDSBdSrlj/HtiRqP8v5
+        cHfuTi+jhjt34QTaeG7k/QQc6ZIj01ODVtMsbJmV2rMmGfIglPfCyEu+nNkjEamQ3BZXfHYTrG/z
+        4PG6+zH5nQeup99Y3cFXxTHD6D6i/OxeFSUM6XTz+6oWYhwdyYhXwsqoZJhMZRMFMSrAgGQ9K54C
+        HCs+9LE4JixCagjIhM8fIZIJ5yqNUURtPgNIPdzduih8r7BqGDgErlMLgCOEkubKvS+Ac5XeVkWd
+        YudISdBxZHceyKFT8dFNZLB7gzns2SSVmGMX+mUD6gDq3I7sBnXu9Gnaz5n3Ma7T6PIGuseC5j++
+        Z+f0XG1vKGUsAQNuqQ0YABgwXAxIhb/v2t+/eGgcHqKU+i/bJNnHX08m6Tz0nbeOwjh8S3Si7xMc
+        oEM8Wfnhe05tL0DpOOR66C08BJvoC0q2GL0dEvrb8I1ecPf7GLnBBhExIJiC4sQl/ERbTJj2AvgD
+        +DM2/EG+m+AYYAhcEICAZ4QAGvPsvfL3JvRYGwNAjUGNmZFNqrFq1yzpM66KCYc+6rCsCWczB2DC
+        L88G3R+w7tcMJwIMXBMcYABgYLgwoHpaLlXoZbXmN3VqZR/0nj22EvT+8mzQ+wHrfU3zDxAAEHD1
+        bICAgUIAmeyLTL+H4rGHfVRlpYBc1kPgejt9MTvoYzcKuNnBjIiXfODklBek3+LHRN+DNd4n8ST7
+        bxSH/gZtvAivE/8LWn3JEor/vPeOYRL/KssuhnscuN7/lbir+FfvfrhyfZpEDDZutEFu6Hr/aP36
+        /N9pAuYKVMg15pafZWViEHJspwM1IAlTBK3iPowuFQCZQPFDYUPpU+LBmGqUABQAFAAUGtsp1XtU
+        6M0iBaoGQJH7uPvosufRBW0GbQZtHok2P3cx0F17iUGZQZlvR3akzJaaQZ5LG+T5EAyy9KK7cMoF
+        LLvveDZAQo+X3VbelcRCpmKYvgAOkm1JbPleSAVUqepLYg+iF1J9HKpuhKSzrZUBuu54NkDX8PtS
+        WjWyDePGth7seuwdsg0DwACreodVKiAEvhbgEeAR4FEv8Eg92zqycJBafqZ+TAhUGVSZGdmkKtug
+        yqDKN88GVR6oKlvSmy4snS0YGLxaZpsuZos6ejnwuCQobL8VljfgA69eY+xGRO5ktFq49AcFBwUH
+        BR+wgqeCgqoCeukoXoXUtWstVSBZEqO7eslLsaSwZCN27dO6sze+4wBHbtXxirdfV9sHTx8TTy7v
+        5MbP8lF44yUVRzBuNxOTHvT7GdF/JkSTfYSRXYrSe+8z9smIuT6zlrU2steg3xWOlk9jvrTUpjHT
+        p3aPpkG+vxY3+jQN7317I1ZCpBDMxdSnS2tmz0yzVnFkjQmd3kwm1JBalqvdNYWm9qwOhRZLZzo3
+        l6OmECHNHTI0bgr54cedSmY4S8Mx548CjQ7pU0/FDHNuTa3ZmOlzl4KNmz474j4ddnepmEMWfVPH
+        tsznIFEdLXsWEt2haGMn0RU9ZDbaCBeTkiUiL9kWlZL8z+1arbhSFUWtullLLurut2l6LXnFR73q
+        GDYeExuOB4iW+KXMZon5IB7aeu1DXFvl4iVwOwOGDpShJesEDtwKbJClG/OpuZzapsW2OByLGSpZ
+        LwCdWDrx3RklOtnO1JhaxsIeKZ3K1w/ypFroxnQ2c4zZaCWqfBkBlCpS6l71m+vLOVm5G445m4+U
+        VGVBaHlC2bo5txfWIoPzMa6+ykLRQCeWTvcqHqHTdD5NzZ49UkLtvDiJXB/5bkRoYzmGVUqZ+xz1
+        YsWHzSn4EF9UPeZCVD0prGOoJBDvsMCnJ1GotEVoLhuhabBbs2FI1BXxBpVcVaT0TJHOvKG16mSa
+        rIFppoI0NGmkwkkjFUr9+kF0QHSUuzvNyDpDulmb+ch9grMpcVBEUlO4qHrQg75w+LHmYcnNWSLS
+        rkNikcggxVgSVFGRjqn8ttMxycbTiMY+wkcPf/TcykiJhG3NbyqSGUeQufiMNkZBIGrCBcjGI2Xj
+        0SXe1fJjqwiLpGWpl4nup6taO739BC2dyh7TmC4JezN2tBeiIbffzk94cwq57Q0miL5OQ12vGzdJ
+        pZWMneVjvwJlBWUFZX2wsm4w3iPy3tOeJMVWzDL+1QDiO0pbDqGPK5yRNoqNhkT9VUN0HQRh+mB/
+        S8IwwzAA4mXSOSRHfDYT2UoJIpCGVqWhOR5LdwCR2N37mpqoFMNGZ9rZ7nv8hn0XAoArMBi/XDiy
+        p475ub2HMUOmAdoL2nv9INDePmuvU+NgI/nmeU/hSoES9k8Je7myKddBYTAa1LGbcoNxSlucuMHG
+        jbhNf8rLdPlFxB01mCmbhly3HFtfmM6sJ/1yCtNR7mHk6Pa0d5Op28moR5Oh1g3h3QpvNkSRkZ3V
+        bEstckzdbuhkx4W5NEVIyl7LKXD+5AanHu8IE1+kM6W2cf3ukpWgOpt7SiJ34yJDcrdDvcZWfZl4
+        vMd4vZ2k/4GS1PEVT5nY9MhdJ+mc6tYw5Z/uHjZe+Jq9/fp6HB6i1C6+bJNkH389yT5N33nrKIzD
+        t0Qn/vcEB+gQT/aRtyaTnxBTvz74bhJGkxeJKaLtRnqW9kDmSKdV3oKkLd6JPqYbKnO+hhCR7u9y
+        dPPimTuS4GeaZLhCmYhscsLS2VKRqsBZcwXGhjOfztnq4YeWDC50trikMmwGa/YxdOWVX28NI8kt
+        Sn9dQc5tRKAl3MnQQQJ3Mj2qGnileBlQNeHe9AB3TH0+UwSeDKrmADwAPLcjew88gRuErQNPVpG3
+        qAYeOYS6Urx6rSh7CTtF0K1CnSLqAupcng2o87DjfE54EuY7ohbEesrGjSxkzVVcGFvq5M6Xc6Zk
+        LCd2sjURPdxc99jMBiN0Jl23ywqdjQyzKHRrInXpYL7gsatRkLs25a47cbraCT5H5uJFITu70Nke
+        P0JHZ8bGgIYrJDN9xvdDAJxyaSLy4ifeDt/uHBb2LmGAKAtd3giaXcg1lQtmcTwjmFfv4Kq9QI6L
+        rG9VjB1jKWxowF6TFOLbiVuFLq7irkczYUVC9syqDR/ZqOz5JcNaVqF7fMVSwRfIvEFNby2ZL/JG
+        qlSmxGTf8j47sM2sFvrpY4+Cb13o04lblpTQC5ocg8yXybxEjyquvKsdmKYq706hb9uTyLtUNXaZ
+        tNcIbaRf0FRoQ/nZoJ4Jylvb0+CEUsO4U8hBquSyGJ3o4zmmd6/+IMA4pADjk24+LoOCq3yrKh7k
+        ZlZikc+p1R4yGhSrUQANLs8GNBguGlwlQVXRIPONl9VgMC3kQIeMBcVkJWDB5dmABYPFAl2pzYQp
+        VSj1wk0fDVn9YWHQ6LMBE3qOCShVjJ4Dg1wiEIABgAGAoTlgIAryue/I0KbLoNQH5Q54GIaGgzK3
+        oMzCnfntaHONFimLUQUElVT6jqggqDSoNDu0MZWufUDUQvpY6ryIr++dytTK+HpdY9ykdNxx4M9d
+        x0FV7WgpPnvIhwQVDpCq3tTiCAxKf8SwsrFpJmH3HRPTCQ714KCY/qOQFPsfcNpE/TYCQzZTxbYA
+        EGK6PLsxb/X5WqVlWntH0/GBuAV9UOKGHYM+Njen4nRXq0dbtl1Dg2eO9lQ2AMBkAOxj68WEkBUd
+        nmK8DgPadCnb76AsNDf9lJLIDeJ15O2ruu4xby1+/avrTX4dbnGEswZr6GgjHLz7Xrwtnc5ZCWTR
+        kbyoQgmmpiUSbuZSzQZrxVFHvE5CQiXvJ5yqkHW9H0/QCGznRp9wsvfdNb8n2NX1ibvfx8TzoeTV
+        13wqo/DtDUf/nLirX/3RJ1z9Jtj8MaICyRPF84xfs9aL14EnOd7uDn7iUXU8uD4weAQM/t33f/6f
+        yNTN4pEe0pyq0c0zc55TopdTNMHrLSHd7hB4yReGnCs/fM8b/7keegsPwSb6gtLfrgh1P5FfESxP
+        kO+uYvTmHz4jE30Kg7QbJD0NwQ026a9NlM4eBeEHco+uR8b7GHkBujx74ji2M5suOUSvXr+kk40n
+        F8pcr0XEXCE8+bfL1/aQNxXSvk/QKpKTdkdByFuhNxUD3eornT09ayGZYsjnvU/EekLf6MdXHz45
+        4og6GhO65n334iT6knPIR6k6ZNpAleFRVP3ed3cussn3mea36C+pH4S+C8inHdaJlPWw9Xlz9kMq
+        SmYZjjBIxl5T9JCLk6lhQYoKtcMJ4UxApIT+hPyM6IgSfYUy55OAWUb0Kz37dyIv6fnodzrsjTjB
+        t9KyNOpJi0U0SXZF1X9x4cymXXlZGoOUFxvNibwoCcq8sEYfsJwUJ9OwmJwkhBJ69VjRKOO8g35w
+        yYs94uiZ828RYcNvz1KAfvfHhZQkmLojHYSREAVDKhDTZlcXu5BeUGlInTrPxAeIws2BdqZGyRbn
+        COEg4rBtbt3i3OWmjnT2y41L5IGyJJ70DCcc9Kc1oVkmKrPfKhqWBtHC6F5G5sW+p08uIz9QS5gb
+        FHVzotC/u1pAFuaSDXN066OqovM1Lcka1jGmiuSc6rY9HjfOLGbGG4obCRy5lORcO10dP6rJY2WN
+        sfSZdJV0/1lMbG4DnroajwWuWGssXihyWPpQnf6zd9aEg63G3UXLzP3j1iPv2eGNd9hRz/nT+XWS
+        Bu/RYZkWugtd2HuPN3Q6wmVDGOj55L8pZfmOTTMZ6gL7nC6Zx+ELsE6CdbS+oI7ePRpWW2TetNgH
+        fUDMU9e6BlnXrdYNlnHpyXi11E66iKv/aldo+jsk3nXKOYmVOfCN4Zs+RT+Ev1VlmnR34gGoW7Hl
+        zlAYl9o58E8GyDkmiwe86wvvylfkjiSjrCbdEU6i4aHJiOp0VWUN2C6t+8U+diNa25vVhb29hdEm
+        r+QKwmNasoIOwRGn5Ytp0iLnMwrf0D5zMvxdjMiwrLgGueR/KKa5zTWeOOZ05iynD05ZVCi7UwOk
+        5/It7STExzaNeYdeEYtZNaTnmzQr9c136E8Zp+OshNAlUkPYSuUjwB+pgJzkBe/24QeO6I9fyPvQ
+        6hAT8Ytj9OEl29xT9V1aI/uOc1maOPZyapqWiviUsp3W4abbiuSYz/QQl9uhyPZHGLKcSBiEAUiK
+        XD9wBTiStUznA1HO2yeqgebJxEfen7hKi+c8P9+llBIv45caq5r1KXg7jR/p/PWQVfVdAXbLEp/p
+        O1rwS4zBJlwfdjhIaOmFNTWmL7XKmcN1dCHr/lymbNgcrpCxteqJ6X3n3/6tlF0bfKRAGzMcyxkz
+        +SByEafQyy08Obwf4iTdzDf5GY9MvyBf8kv0j7+1/nFh/OPSSR0+HPkUpcnz8sdwzp6nZCfPIYMo
+        Ub13HBAvcR/h1cHzE6p/m2aJb067ob6SspwJe0MVZer5LjGXSaP0M5+HeqfHAP3K6PcDceR+8yf0
+        n+X7Lq/CI9JnhDQUH+HEm4XXlOMjkgUr7RjJevu5+WzMNxJFOHKDT7LbT388YILpGa5e01HA/Nu9
+        gQ9P3KVfK1fqInCdMupIboOUpLP0VlAg9t3E1qdA4VYp7OhGcfdfGZUlDmBrjMwy6yneGIbQZUsu
+        Uf+ndij95sbl4aquBHrYlN5gvI8xTgHDKqXvxQ9gC6juTSVIbWwQdyEpXFWvthb0mYpf3Tgmyz83
+        IHdE+M3z/WZCaC13sZFgNYr3eO25PgaePwXPI1iyaNwlS61M4RVZkbejlMEbRN78FkY7l6wf0dZ7
+        JxYM+d7OS+J0I1PaP2fvRnSpeVoMOfZiZs/mra93rjRfUgrMR2+KblEKHH06a0cMrrI4VySm2WDu
+        XrZ3L9keVjRZYxDO31WMf/06w7ZkqwCArd2wtYUNzXnPH+QgQ5L5Te5IrdduvunmSvZtgm847WbO
+        hOigxWidjk/vfrhy/cl7FH5Cciakyd2YMolc7qCSq8r+Itt3WTnldIUqGR0z8Mh+TFPlHIC5O2FY
+        7Ex4Z0P+D7x6jQlarrfyEsM5Z0O4ybPJOrVeCI41r7RSPZWcOn0vHyRdAEQl4nRPFoZSdrigA2gj
+        gTY9EI+eI4vccgqQpQ/Icl+llJJUpDkIFBBjq1Ypxy68ZIvQBiJQA+Uj8BBUXSQi9HTATErkwuZN
+        hlZ6Ywp670V0Ih//2/ViZBsrzkHR4kyzYVvNSIfEfuIWQ650Jsu5WVsuaPe3JBWIfIfUtXCc2hPf
+        EljEhN3KVdvC1CAwzyWa8bVYq353t7VP3s5Dn6yKAqHT6xrcWG3NLNOp2jnIHVRytcburztzBoUs
+        QPrbnKpomjaF9wJ0vvMs4Y6ztGzLfNR+wA2u3vcjsZmHLqezEnh7JSUxToObeDreFMxOpZE2uWRG
+        iPxfvyYsshzT6LA/7mmXg+9G73I1IQ2mEm2JE46J6TJFTGavqUdNGjiIsBalCduNuRS5pQ/2679S
+        Vadt71KqjLwEni8U7otikb8TXFHHCAwfE8PlkhQNOqfWdNYxmN6zdiw0imaoyfWrULgnd6/dfdq6
+        gebG6E66L/QsH5QvOmgjh48w+uSH7qZHPaRPs8vbMhZ3X5bY3kfGG1qUF+FJjy2VYaqqcYB35SX+
+        t4L/SK60iNjFybSC2ZS4yLRWKWZL9qtV2th+elHaNkGOjaNxawsr3QdoS9aeguCYZKHpg9tH1axb
+        q91ZpgPbsnJXK9oZxDDktnPImJL0QLnLadqpvW2kS1QdBDt/huz6fX5LH7yJwvWnyT9NTLQLg2RL
+        J7bzEroH+FL5t9tRN8L33rcJSmd/NMuTwjennppLoyrem39GL5u2ls1FFhlUyKxMYLPqLNuhUPdm
+        IuqknbUnwaZjVlnBoRC5MJk2CK1O4tnMsKqAdzAkZiejSmJ3jwIyfovTnCsPM8hCYBuFe2+tr333
+        sMFp9of8khBdHjec+bQRinPPRX+Aa1cymQdQXIHSznQ8hCZzaYyC1tdPS8PmZJWDxk2gg0Hm6YyG
+        4uxsHkBzBVpb04ZsXx9ITSfTGA1VEGJ0VGxOXusCwqU03JKp7+03ec8VI/q0EJRvmLySZJU5wW0Y
+        NLXSveUNWjV1KACiVhL1tH9Xl25vMi8cvnAHOXvQ6YIAmTDF0vCejfLQZTF/8BHr7s79KQyy0qqc
+        g6fy0RcZ/tISGkIvPf8X7SxdTmdsqQNDJNm8lEu5tlWWaepOoc9FDRbHX+IE7153OI7d93S/cZ8Y
+        HYZBvA0T19NPhXbJ1gs+ydbvz6WOqpDjdy/KGHWjifxOaadgaVZIVpLOpVoQDIkHhcKWDtWOmxpq
+        XS9//MCBTv+y000TEQpoU4Km6ooblAXAXzU+A+B2B7i1EfbBOtUByQvCvffdhLbd0k9E07M+1/Hk
+        /UCmfFWW/+PBW3+KEzdqYPditTPcPKzfV85/hd+EiMmWGnKcuHp6gLR9ezb40fxarqmQrZvNLT67
+        3dvkpM7JTIVmi3oka05Ju6VY7s5VUQyW4ONbgp+1AZbfI3X/rpl8tycoU+Y3HLfE0pdN8Ft26S1m
+        Ayy7e6Buj1t2nwQBltwjx9w0tGKD4zRWxynnLzhPT6LIYLnBcp+FAaz3SJV+7aI1DtJdUM2E1gyZ
+        kxiGEChy8jiuGtlqRtdkNmEOgWgzfSmMruFDloOD6Nr4nMQr3oKDOFZbcc1kcA6f2DkkgnCxfm3t
+        eprZ49lIwkxGtTxUmd4qe57M8ZCZzKUh+inteBoXBZuS07b2Oy2NhT0aerOzaZ3iKrudbGM8gk0n
+        0xAFlfY6jY2GTcnq/TudnPFsIFnotvBcz0aI+6z7nOqQCvYv3Sl9EAAYcQDgwmZICYyXyx842zNz
+        dz7A0hdsfGSooW1bny+E+QA+zWomA5qLkHWdDJiWJQNOBANzMXogAVsxchZbjeSOnfHkjrPWFQo0
+        q2krliOxFXN9UWkrrPq2wtHZ82eGbCsKPtWYgKS+rchlaCTWYsRMtk+dl88ttefX6Gd8LVcT0pyf
+        3HHPa6vgydYIwAgoez5dwpI3K6ZusBGhwdLW1k3Vc3KkKfw5pfDiMyO9ciZp2qDt7pjGy8JeqRry
+        C7vznmCxALuBRs5jLziS6RXTKjaaEuYHASYunkGs0cwyFJY5jS0LLZlUi0rbabKC27iJezON9EoQ
+        JikzXr45kUI7eq72XUofLSLvxNomxLFGBmrrQxThIPG/aDmztP3mTUu/XX85P/fvdwlb4Zz0WuWm
+        zZ5eW934IXbRqYHT3QEGZzwBhqm+EAej+TSrFWAYS1068WhNCXpBXfrI6tKvVAHcypG6HFc8hu5f
+        nXX/KuMC7A3ogbI9aG/ARQ5gjTdSwD3EJxa3tfejmZOy+lAze9dZWWqEViHwmE4UmvPLPBWJp1LV
+        PTLyNSKhbW33mI0IDJjJtEtspT01N6f2DpzIZDJNkE8FEEZHwEak9N49Hs1l8/tRYX/P/o4Sqj7r
+        5o6WqAn7P+6hZxMl47OxROmzvi78oDOfZPWqAEcSpJ8JKwCviNVE4ZDZYL+drkuH7iy8EFO2TuFQ
+        c5jYNVnFkKhSNMSj7l1FQ854JJctyK0vuepZu1mDkeY+ZO1MfSE8KnGAWbtrtambtRtRzq6JhGxf
+        I8j3puzGdXaMpbehxsoseM5ze3qkZQ/K1V1koH6urjl/pPtc3XiB1gInaaxO0h274sBJuh3aV90F
+        J6ljJ4nHAnCSnstJumdnKjhJ7YhAYxx+D4/njFB2exAeXUT4Ix/8XDZYKGzLpIRMzhjxReXcxaKJ
+        yrX95q3y+E9Cnt2efIK73ja1/aR6YwmX6YmXuAHCOzIIJUS5ZXOrzR0VV0N108/dUMpJsNXQjeKo
+        I14nYfQaez/RB5pTW5iykiGZJZvoGxXRDMtRJVpKLvx5T8Q6lpY0vbnNcI5MAqAEYthryqZkXpYd
+        LaUanbQsyZpb5cgQzCkhGHtNtatMWX60lFxExHYecVg62PclQzNeJkp8sdbORykxa3bTaqH6v+Vt
+        q+12I2lg96iML/D4HaaVMrB1vU+HTABsY95FWUbju5brqdATsD9neq70DtF/wvepsbSWKorf4/3q
+        ypyfCfeNu3HspfWcZF74zfP9Ej6QxRh5PnnwIS5jV3cLi+qYbtei2bfKumq5tAxnIYxEMdfqVdbJ
+        CIYiabuuwOuUrBwJqUXXvO0nhFKeKZRyy3QIpUiEUqpIBqEUSaJBKKVqjSukGoRSlMgFoRQpMSsu
+        o+dXoZSpYZm8FRW1W/h1Tdzx1CZezT/9mJdTAfS10mb3kFs2vPHF7i3PHa6BRdtjFm1iPYCQ4rOE
+        FMUyACHFJwgp5uyHkCKEFHsqmhBSbD6k2NgxUBBSPNO1p+La573lPRTD/u4tz08egW5mPAo22c1M
+        gdDQzewe4kE3s/skFLqZVdP6/m5mCsSGbmb3kQ+6md0rpdDN7OJFN9DNTERV6GbWKDWhm9k99IRu
+        U413mxJQFrpNNdJtqkBd6Db1qaluUzltoZHC+Bop3Hu8MDRSuB3au/29JwZDI4XOGikIWQCNFDrW
+        ssc1Urj7iG9opNCOCDTFYZ1b8HQpdzENi+fgV9f9mUpVf3RlcJ20bD0k03U1lTAgo1JR0f+9CBXO
+        +hpHeBW58STNeCJbT/PEcmtJqaXO6QVVTpwlkXPnDiq52gm+KBHc1k1pestY8wFRm53OQ2i9kCO1
+        zI6aAZFaeNR8C6R+3ycojGNkWpJibTcKI7ZpzKtqJmxrPhPW7hQuqkZNCtMpegofHx/6aUK6601W
+        fvg+Cfc4cD10TT8UHYIYvbnEYSFOYBggHhVq2SI3ImOw33TsoXmzRF1e4hDZlpwwyZwsPCDFZb2t
+        oih5wRuZTrDGaBOu4xupyml9ckDvlZl6sSc+V3+igu7vkKPPbtm6wcTnWmcu7cZN0qkSJ3iGDJM4
+        w9dTEJarWTLlagOSAUufF2IOlYjSa57PpVQZONk3TpJpopUXp/EOMf/IsMhdJyl3rIIxFCb8LBkv
+        4IijBH9+JZKUfgxlgF/FeYkiyhZK96+pwM6sZP1R7Tus/fCw0d/D8N3HaZwhowkiovKOAxwR7Dxi
+        +l/UHkx87EbBJKPTz97CQ7DJsLVIOXUpIEb506AkQTKf1nTA4UlE4V8Mozy3B+LwLOJARKE8Cdg3
+        UQAb0Z4kMKAg8PCnyHCQsSzx8EFmRi8zm9Dfb71y91IlrRX4+9d0XjIVIlVrA84Y8UXFlcG0sNWG
+        3klDQU6IfJeGf6SJUrVgyuJMTSyXWt/rfPdW9xphrkbTNK2mm2/kJZeVJHKDeB15K4w2nhtl3YHE
+        cuMeNl54E5GfVWNqsQaivphJVO4IGrDkn57Pd0+5KxsK54gV3rziYLMPvSCh7/zreUA6aHI0J+n7
+        Jjfvi1/Ow/52q7yiPO5LIylc4R2v7io84ldzG3G4qZb+FZpp00DEuauWEplE8TnzPbRUMbF+6y0Z
+        F9D+RpfxPx5w9OWGx7zhtGfX69Z7375k+6++qh7thx/yg3d44x12+fjz8L/z8GTsqe5KDOUN+MCr
+        14yuxUHpKw70YzJkz2dxVSLjlCMBz5hL4EAxFtoeFLDZwruhgEWxIUNBIYALUABQoAIFGQycetqY
+        hUhJ62DA1riogUFfVHxW1umwcPFeJW9ZSST78oy42Q6rHKAToBOgE6L2h6raYRcTz+25j+zGHnHA
+        dybnPsr0cRuK+1gS1wIHTN63MqdLCVWpE3Hpp6rIrrRGrirPuNbqfc/GAS3JqmGjXnimn6AB9lUD
+        0ADQaA00Ct35xwAbBDMsZJbVYXQGG60ubwE4hgEcHS/QHw8u4JEAtAC0PBe01EaN20MylEGD0eN2
+        EUOi2UCxzLN1JGi1pq2Qo2g9+Nc3j7x2/US4P8SZYFuWsqNt6os5i8Et1k8U6uPEvvZUsoKiYEKG
+        rAjzxwfBh6YH9nJaogd1i4h6qQVEBWzQAtACeS1wztZgakxNpzk9kJfl/khoq6dXcmQUli6wdGl+
+        6eLcxFJrKHXtgAfRkE+Xz5urnpXKXTJxR3PfJ3vSqgT8CJ/fVCQl61Les1AKdySXFHk/CQAzADN2
+        VBch3svhlo1BnSxItQ0yd+lk66gthcMQcQakeyakq1yJObNyEDuf0AtoBmgGaAZoNni/rQryZo0h
+        HSxRx5zshxUqIN0A/LZaRwyA89aN89bgCQuPdt0AEPoYf08Tag6qsRf9vpyyDXk4yMMBDvQOBzK3
+        YGHU2Ig/EEAQ12QtyMAXgA7BcIAOgI4y6Gi+KmcwwDFFZNoAHILhABwAHGXAkTfEMtUbYs3ua/7D
+        tgQtRw7JxtMyLVKHE9W0AAsACx6JBQABAAEAAc8MAcrp1doQcBt+N+vmAZpAEtVcAdtiUBKJpNMp
+        7GzaLx9u/Qi2+unZPNn1NBD45voxYGDr+dmr0Se1eo33eO29eetXHCQ8QTpkSMUKAT0pNkVC48Lt
+        MoilK66ZYalHeQFrAWvPvwesBawFrNUEWHsuteEHxuWjyT1v+gOVPK2WYfdy892oIRkiAB1EAMLD
+        5s13Izz5l/XbZIcTd+L77s5FFpqvsrMZ3/YmExoQZu6WlkwjsctLq86LNeZVBz5yhgivKWtfPh1l
+        inlBsuiGYpbhLCooxhkivNYKxYjeR65/+pcSzQvIj4d1go6GXn6MbWuEkzhbtNUmulWE275Nki1e
+        +eSGyZoe+ZmK3DXt3I8fuyEdp2PLQ3t8cUlHnpKdh1tKkwedcEs/hlpJuWNuZ6ZTeTSqYYlPRmWu
+        Pf0xt2dR6NOZ6b0QCeIb+LjqHM9hCIaA5YTjwO2n4fa/FM52A3aPm92A5U/B7ne8/hRKerftck9i
+        gTUT8m5Wn3O94wa3JSYwpVumVBpA4MjjOVJuo4AjD+NIGpvrVVAg/SIICnQTFLiIA+rRMlFeJHh7
+        UR4Qs3wimejTAgPkoh9y0acYA5iPvojEAGECRKJNkZBYHYNUPIdUZOnu80/IctjyXwGvDd2oYPP5
+        oc24BKaIrew1xRzt7USKXKLE1/N6AJ0wY+3u3ZVHJuzhOCXc64lZYTDhskGlnKgGyxRiXcC0rpj2
+        Ge28wCs5qkdYWJlVcUqhr8wWw3CPA9drYn+hyRtUcjVn8anaLJbhM1v2mZMcb15xsNmHXpDQd/31
+        PCAdNDmak8tbztf+xn0O+Sw3k4vig2gA6+orM+Lv3Hdc9dB8OpXPLnuMWs0gMVG+j/2R1BnmBYI7
+        HMeE2rGS6vFG3VQkMrq5xVFqfXdusEG+975NssDlka3NLilpbqZBX7e1Smx5sjy63VAwQnv/EHPa
+        R0pWhNcnH3f/ykOLvYTdDVVJKE09GXd7SNTjnoapRj0l5ZWzmUNQX+s+6uEdmSTCwbvvxVt0tOWo
+        15j0TU1hxI+5lJMl/d4NtTfq3uKJMudnvKZG/cYYimm0O/iJR03rgfjeQCgxoY6OJIiRxXK7MFZy
+        9X4q5aOOeJ2EUbrVhL5oanOVUZGSkxMl9SYpmT37qQipR2SxF3wi+oqmFVJ52q1EPs64VqjaS2qB
+        4JIl6mGHyfpyvT0En+Kbd5sFytdYfvPGpC8oHyJxMf3W2+8X4k9GeElpYDiXGnRpgK3cMyAj9i0Z
+        caVqBIuzYyDzbVx6OC7dOSpFFEvKucnI8sr6GbyowHQmEfQpkag7d5CzW+LrLJQrvaGrdWBjyz95
+        Eg91CZhRLaBU87+Axl5IEiksQ5oTo64Xc0JBal5TI9qhmUCiynoPCF2L0DSw04nh6ZrKDzQ8efhM
+        RaaB2vWpPV8h03pe+MiTS9e1t4Jc2iXINjlaWUL6iojcDFqj7NrTHgvoEGO0j/DRwx/Szlllz82f
+        Dk1swG6h8OB2Vc9RCUiDMUNrpcHYFJew+dJQc1yE+j7CqLwMLGNougq3KjSGk0LOJTqLxVxS6xxc
+        qJbZ9CHx5PKUmBW+q1F44yVl149u5OUPuUgZjzrlgdwr6ji9o45oYhjvY4w/pQVWLwolB5a+YIyC
+        0PNYSJjD03dU2ULbrO6o0mKbC6cQOy2aQnfvodQcnuaUGsQfD97602ucuFEy2Ufemol+SrOWfunk
+        svAsx2wlXAzSUjLyiYTluwdAaLfoyNeCDL1xNBJNmE1vI+O3W6LYi0+oC0Iz3pAyCJ8/sJqZdB6M
+        RYy38ZrYscmPHzhIi3TlwlgysdDzw5vpWTqzF2K3m714f0lCQQs+Pj504tyu3JWblfNSJdhifz/B
+        ebEuipPDxgsnJXW6ClArIzNViHjL3jef/Pcte+/h23I5X04rG6NZ85mwz1fhooBtQ2XG1SiyJooI
+        Fp6AkkXC24aJ6R0ldUBXNKsUbedWU8/jIzdI/dy/Fi7RP0bxDvonywtddT49/fnbzW/+/lXNyRX2
+        H1ROjymGkZzeaR78WeaAVD1N4TqjqHZpLo9MDVkL0EDQQA008IEaSEReMujLVqHfo52072cHG2DP
+        CSPdeQKfRjpT5TTpsVrLYgz4wQ5roQp0pMzNDaeJJEthHs7nVvuxPhmXnYJ71Bcut6LNZ1rezKuy
+        +f0zSsYcSdb5g2Q8nWTAkmroSyrREklZLYR3CtXjfEcvl2Piz60mTaGYoJI4Nrv+kSTOQxdzV6q/
+        RKYJqg+qX34nqL4EcYaj+rzGCqD2oPag9mNV++QQreTabrMlrmNZ/Mk2o6qu5RgG4lRKQ1rITbw/
+        JNloulHBkKpXaDEs+FRcVokKPp7LoP8dSYZCKzSQivFLhY1sY4Vce9XcuuBx9n+U/EhrCTspOWuk
+        XnaoPLlrrVZeIs0USJ/vkisRPQ+XrsE831FrnZb2tGhgmVZOk0IbliqqKFfX1KRKPn3B+izdjNg6
+        cRRJs1AkjSgQUE6Y09xbXt2XU0YU/ZCtS6qkzXIA6/obG9FdMg/MRTaqsdDeSID/KQD8GaD4KUG1
+        WBcJQNpbIK3wMRWdBUWp7iX4VnndIoAS6vpCVdd7DNoVbeTVSGMrEqbQ+1iSNL3wu2dqtFE1ELNa
+        lOnKPFxcbgssxUAsxZgx/ymw+zlQ+InwlGAXv1HVPShqTRcS5+QCiqajmkNR6dKbKoHuI45a7H7A
+        ytmJy4kASSuRVI6Z8iAD4ALgko0HcAFwaQpcfpTfQC3V9kp2lbiwjQ731RakdbBIxTA2cVcEqD7F
+        k8uPaPWOke9G5O907jJdEIh0sQ2esrGb1YE33rGYJZdAOE7f1NjJNzhx6VNvppVeCcIkbYz18h19
+        9CQTBI1+ukY+XUufp3mxRiaU/faftH8gGjU3vtJWbow3Whhol+/VvvfdnavZuqnNjW/JDcERR7QH
+        p6794bBbkQfm89xob2GkRfiNGI1gjb/Sfv5PHJr9XDvQV3iB5q6Tg+trRDrWBz/t8ahf2p/9nSPh
+        9x+6wmWhzPEst8VQfIW5kCxVF0KVzWF9bg83uZxli3INwtGRTkZCjNe+e9hgZKM5InoSYLnaP0tf
+        0j/G+Q+7ObZErh3dWkznTD/euwRb7rBNxeN4mteBh0u1Qpu2lIc33JzKyzi5wXSsRTXwV8gx+W/y
+        IyF89AUJZZoH4CpHzfbBduRKt3W9TwfkILkOHKn9UFE0akAWs4cr2swp0bPCxSdSs2nKQLajeplu
+        zXUz8wGmoFpqqhXuDzGSPpKgHP1KVIwPfu3rmNqxY0+kY/OMmfaJl+xRGFWWzDTmVOVA3eqoG5Lb
+        NAYKBwoHCteIwsl5jnzHo0TLuH4HeI6dKZmVKZlZf4FmT4ma2aBlalqWRUQk/cgBxkRA4SAi0kuF
+        k/QkQeVA5UDlGlI52SOxQeVA5UDlaqncO955gYcsNOXt4BcVR1BCm8vLH/bI4iqNu7q10XyyaThE
+        nauODqdFTVOh9rEXn0j7LN0hDFkopANsna7iOk0HNHckbaWGkG+UDCdaTlGyS/Ni84bNkLwmyNf+
+        PZEmLBmfgnUpKs0QtULT6lY8A1aKnYtsZForSY2gdv0K9dkasxLlsNLQH2NtmjMZMsd1Q6y9LIHM
+        bFutzB+zYd+HVxi97xPpCofOkdyac4QPSolGCeWysiud1gTpBentn/RSh1oytEPkd36J7BgKC810
+        adKkpwCifG9sh0ryFTcFB90InMBFxs7HLDSlRTlwA7k1oaNnTm/x4HGhnyS1DQOE9yHCa1PhXVwh
+        0VzB6Z3qc9O5upeFpc7lOIxjspQzBr+Ws01jXtWSgjuo5OoTCfmUCrmKYC84NraT1RwVYFn5ncuj
+        cKP+A0jnvRBckXUok9SqtMPjpTZR3qxn3WQ5C2GX0nVdtqxrTJZVtmzC1r0yqR7V1j2fsgBZaG6s
+        UKrW0rWgCsLMCyHeJcyOsaxKlHCGCK89nbyrJfftC4KpBDOsxjYeKSVSamVHMjVw0M4lLCG/GYYa
+        SGVCml8i/uYi0ZtwfdjhIEmZowXhx0mEY20VJlvtN9/+OVWMWPsFhya/1NxgQ55BqB9lw37BjgBB
+        VhNkyr5cmm1kIseYrpAXxOTutQK2d1vn35FYPzXGd1/A9XDdWChqRn+jKNC74D4VcChnr4yDUqhw
+        RlusNB0qvMelvxFzO/Xs1S3AE7o1T43/z+YaKWtFDzpngF48trS2YpNCZfCSLcvoq154n5PI9dHi
+        83xolgLiQI+yEaoKwEW/virAPkmPqByaPeCE9O9p1AjS/7TSPzjgB9F/jOjXzXX1QtYJDWMcTmLs
+        RuvybXI/HnD0JQ9n2RIymj35hUPY/GXMt5BZrD1EMERKu1ik4X1Fgj8niBBx7+OUYOEeB65XtYDg
+        nIh8j790EqbzZ0j51XR2t/TBeP8eubsJVZlSCsWY6MzmHHc0FnYlt/Jnv0ip+5UC0ZupKpvWdDIz
+        tOzNsfarVL/zd6cYkH/TV7dPCiPv3Qtc/9SdPP38nRccEpx9PnluqYa6tH/xK3HMg3gdefsq6l5T
+        plQPTwTJNTBrnV5UMLx5xcFmH3pBQjl/2wr7ZXI0J+kHTm4+ML6Azt/EHEY57qVkdn23vLAYWD4G
+        lr8RwgRrUO7xc/odBzhyfeD06Dm9w8TmpxtVgdPj5vR+GwaY7ksGXo+e15Q55ftjgM+j4DNdOe9c
+        D3R61LzGwZY63hsVLjvmrHIX291cdvhcpu++i8vOM3O5zjoLuD1YbtdYawG3B8vtGust4PZguV1r
+        zQX8Hhq/g/DoynF4rhMCy5QP3Mtgw7F5DDbmdzKYPPdJGYzK837A4jGwGLnJGtj8BGw+JOEuTLyj
+        5CoLuD1kbtfLVQPPh8zzTUSUO9lGB2D2+JmtFDEDVg+Z1UrhMmD1kFmtFCsDVg+Z1YqBMmD2kJmt
+        UJ0AjB40o9XKE4DZw2W2DSwePYvB934eVu/wxlvLsnqhzx7E6qnFZfVidsNq7Re7g5949ASeg+v/
+        Up3zU+tZOQ8q/iSMhhXXM7D6Y+vF+5QzsuUnZqMMvrSbzG/7eaxtyYvxRvv3PQ6++U777+wLtXSz
+        cKwhLaeRtnO/aBvv7Y1ce4vCnRa4NF2nnR6U31C+Q3rUTEWKO22Bs4PhbNqhHFg7RtZSx/qwA96O
+        kbfxTq3UE1g7GNYmXvAFODsSznrBW+ROfh992W/x5IcvyTb8wf2MvreQaTNn2ZR2TmmilZ2gewx7
+        ZJnwnEJmnEjW0hm/cHjL9hCSbs1zJuMfwkP8nzhrmTP5VxztcIxs9H3WolNPu5d/W0JU7sk7jRzh
+        I+r5xm8BVjmuh6SdG72irM1vuFw5ri3Kvrl+LCLtf3zggPz1H8i2ekVDU59KUlHqnMJ25TMnIg4s
+        fYrm1rfoO27/OebY7vlsUU5Q3pDi0eC3Y8SnN8kKpb7sG0F7SE9H0i6xbQU7VPGMmH/5nmq6DEG5
+        vZcbaeJc0ilORkLZc9falE/eqKMXZ3FaGQG2kemUASt1gyqIzBvC86YkSDyTFFtL7xOq2siyp9+i
+        b6xSE/VYSpo6e2CG+FTLntLyDALImhrzEspaM8t02FaL7KkdvDEsbQuDBMRlvfk+IIEKYf9r6wWf
+        yCKud4SV9UwtnT2gslvS2gahrN0f7Zddllq9cqbsCif/wQgqLYss0nZLw1+Th0bIWaQiOZVypR6u
+        56zFETcDlzq6qXPaov86RKuwTxQuaraYxjItkB9H4z/QZssZhfspvGbBYRKT1ukvaU9OAJC2Nmn/
+        5Iam8W+T7220+BZ9fwjcyIvR0axEA063/Ltb7t8ZCJg+KEBdFgg4kzMLmaLfHqIvro/R0dKtEmo+
+        PPY3k479zQsju6WrzdLVBrrWp6vr+/QcgEno7/791/9J44BkmlP0uz8uyqjKORagxskB7BihGyA4
+        XVEQ0H4EoJaSNEi2Ubj31pO17x42mB4eh+IwCHCCfDfBcaknwDuZs87pnYVBouWqzp6zUuLITpmq
+        zLW73uLXCLub629Mbz0/uuNVRYEbDgr3h7hPLOAQVsSDhW6xQ/tB00y++0TVuwS7A6LSn2KMPyGC
+        xrRk4k/05/80q2C4KnvAG8MFYgmSyuKw1QfHVkBPwmer0rY9kqiy/oKlm6x1K4ffHoTEy3hQucJ4
+        cPZWEiykTiXrhqq/8eLE8/28aKNnBRt9yzyWeXBVBKaRiL4Vc8h7ycWRPZLhKlB4fPx8yKDwl9K1
+        8aMtnS2dz130IacjoCgybMvpE1kt6ZDDog9pHgFZ9V55ugoxByWfjDhxXZfWkE8ji7UsaF6HTei/
+        cEQ3O5YtoYFfjarMexi++3jyjgndPWTpBnrz3XiLDINRmg3eR3id7nF93bjpdtQXy7BmBLOQbb58
+        JWKXIbE45w8qMKww6s7UdA9WMSz5pxn5y+S/A4LK1508KkiqRFLy8p4R1MxibbL1+x2Hjy4UpQX7
+        yLRWyCstPX30AoXNznVdzitPS2veN1rKFu9ltSf9oqbTN2LKppfZgrQOSEm37SGfhncmp505FjLN
+        b9Ff0nppqZLzh5NXl5XW4sgugj9cGsuV8XQSVJOqkeyl6GaZ/F7StZC57LF7WknZyqBaBzvPpPfv
+        9SESVKCwg35wjzjy1p+QOf+WOFuL316oXVE7YTiL6bxiby9/UNGTZUfdvdGvB+4Ch9h/WpPvzSg9
+        +630RrWK1QJ3DDd51GCxeg8KIgr0/f3BjTaI1v/1CSKmuuyCoTiyF25DRlaHgEMpXR8dKZPfVFUc
+        2TFdf6A/5iaOVqtKAMEDq1RthQ1V/fHFrmmal6z20SGTLanulztWQtwe+mRD2iskJrIcLnTSr6JP
+        Nez30rZ/8iu7FmY50QWFvXUUxuFbMvlv7yfiJXz/A7LQ4nP53uvZdGpXLBt4Q1hysmOEURtZN6E4
+        shM34UzS/dZDlfl5CYdLxt+qpuNcOlLbB9PlEeWmh9ZNfsh+Qn/Au/BqD7tTutW6tyrPRnh7Qdo/
+        0QZ+hKS3PQLKqiAeWxApu/zqQ1hcQFwauWUJPCsT4Ee3Y5lLL3LZ8smOqfw5pfLi81XfIHQ0Smt4
+        Ht88aCgLhjAM4m2YEML+m7fz0L9ZvfRgpevUu68uKKEoMpbGtISsD98uXJesva/9D8iLvEtKwkx9
+        iSQKg94GGdjgd4+D5Axx7Qtx/3SgLWSd5bfoaOplkt7bAEN/ZPcPf/nuN999c6HtH9wgRJSyvdrK
+        Ld0nrw/FIOE+3W78vk9QGMfItIyyLri9LVJyHrZ5W56WPSOlvFj2gJQ/uR4Ko/fJ77//ATn9gs2B
+        9BmiteKXovH0STdEzPyVNXFY0upkjs9y28K7qi6bXXYKKznY6BRv4Gv2tq3Hf7aIkHSqbFF1HVHg
+        5KCE1wSsEgMVu3Is9kZ39x7ahOtYP80pbZL+48Fbf3qNEzdK7mqYTr90Qh649zHbLJ0nam4ck3Wm
+        G5BpRPjNS884EG1leDsE61Sa6NlSlx0NvKFZL3oyHSJRu/KhezeiXTF8lccTydjtk1SMygdGON4T
+        IpAvIQK3c0tGxl/iBO9edziO3fe0Jb9opLp2hpuKc5rEYclK9cluaUp9ZKItnE74wmuK6lOEj7YF
+        VVqSlLkemVIsnxbssSTLZUy4BMtlkhgtAqalm2xfzt6wnN261YxYpA9l8eCZzC9P4sQXwQCXCnma
+        pGvRAguf36gWtW+m+cnMW9U82m360GxqUnprZaUKs08erjUwdXa/aG+MgTLQH222BWFfQbtWvWNF
+        WaUqbPfV7WvQB9CPNjqaXxuSbqFMmccKb6KQWK11GBxxFOMmOE1VWMjowkVlBZ8tRBquwL5muSKp
+        p7OCa/EolrSsfKa+YHfePo4p5Z7aR6y7O/enMEhdtJy2J/ds8nLL0dDfE22WUy8JTgb+/nXth4eN
+        DAtlOFjKQB7/zk6kDBfTKXFFnJgiZCFralpsvYuAOrduDY82x9Bf4+DdC6rke7mwjSri8OoQxBcV
+        hZs5qXBEduXd3yEHzVPGWnIQ1iBjLcNZVBfm8NaDJVeBtzlvP9E6ik8WSi7Hrpim4TycydbSrtwX
+        B+pbzwEJDys3RHhHrNqm0FS/fd6qhHGrj6/9y/m12m/SiWnniWUH0WpIowzbuNFGo44RYYj24SVb
+        zZrODG3j7cibb8MlvPNqL9RSlp181BGvkzB6jb2f6APpy0u5InFe+yh4k06TYQxB+O4YQ14uwRiU
+        0PMpLEITczp+Jl1N9pZV9HWdsYq+XJ5VU2P6PKxKJzsorTqJ2Px5mJROts82CX92X11vkh0WfcsV
+        HsGz4byCk/wJV1cSD0d483rKd7AJjVvi8uTgxwOOvmTzum7JdcPFCMcHnzpNbpCa0r8WhtE/RvFu
+        +seaFn79t5vf/P2r+p9s3ffJ1oz/zaZhVH30/7j9/YnVb16E15H74Utz+3xHBww3ZxwCKNDPFJGv
+        RZYbtm3d99GCr7Za/WpnubhPVAVfbbf61bOZc9dX24Kvdlr96oV910c7go+etvrRy+V9ujgVfPWs
+        za82zdl9yjgTfPW81a+2rfuUcS746kWrX+0s71PGheCrl61+9Z0mZim0MQomWs3z/N3JImuZ+dVy
+        Y/u19g8LW3sLI/ryrwzD0NbEFHtJ/JVmnX7UyPTJZS2fnK79mtBE+5W2xh4NXf3C93ZeMjGNX2r/
+        RG76J+0fqOoTwLryUG/8CfK4vY8/e8kXrkMh58xx/Y7Lk0scj5tvob/7HLxLezb5eDm/RjwTNeb9
+        iTz5f/7h95oXa26g0ZJ/lKWlNHpzztBsXaFrv4sw1pJQO8RY+9jigDDcf0Nb8hF4oxE+H2K62tgf
+        Vr631ryAxr/WONZFzMI+PuLAd1fxJF5H3gq/HsvzNTFeh8HmhaYmTZmeuJcXvEhRZe3664OfVr/Q
+        24mwWdZkS8hBJDKVPHs2m9Dm5Ak+/YbYfNNMpTj7OO0XOEiIqEQeoVGuCL98+UpA/d+mH/g9+UDt
+        TykFtKOZBQ4TjMI3lGwxcqNEi/cYEz4QPQvfA49+X76mS1dvy6XmE1A4uO9Yy6Ox7BvDyCMsdP2T
+        I5ySk84slRnLKl3wuYeNF74mBHgom/ZVCbozl5hYdiHbeWGP7oV31aClXzi5+cLrOrRKqXvFn8mX
+        0/Vv4voggto1OYg84mBLNfkSyA7fNCKa2s71gtNdqTyC2MmIXfbjK1t+x0jaeutG7jrBUW6gDLOq
+        /ul+WTMXEzM11Kd3x9ov/kSGETkiCHMSpq80M7ffqdSdB0sJWfajdrSJXO2osSeyRqx/7B2x9l//
+        9adrXJsb//cZ2Kh52mgpwbXEfY/PQCchQhl6vjxUKPJ3SgvDjrg/qctzINrCbgB9Ksn44YoS2tEi
+        YrLBby75JSse1vJKOoYtDjSiioiX5XvxFvne+zahJw/LVc7JNLRfh1scVZZmGZa4ZIe5VjMUXD1r
+        +7lm/Xgu19jN1OR8q/jr7dx0dZvhmnjB06kcVC+rfn6uikgnlL3s5+kqSzudokP8qTcP+xtd+zNx
+        1C53nMnN3EvWU9jd6K0lZ8o/4EVc+FEcxZGAawPXgdiXlOzwC3YaEPrbKY8R2VSlp4pIikagABLj
+        pdXhVBcchEcX0XnK19bPpXZPKBZy29KHIYnpylxULJWzdbOw961ODdzmrRLhWth/fUyPVJHgddp6
+        Up7Zji7TAVq1al+qK12bzDb1hXDPzOM20pfxaa/CJVM3ZI5JG5xOZttRb3ZWKG9yGKM+B8k2Cvfe
+        Wl/7ZEGIkY2maOt6nw7IItaFWBhLXnaKB7KWiE5lVbuExLS6AbJwCF7rNc/dyEdFdTRPSDIBcYio
+        ECGZEtU0OUJSvWnX1O05S+TyrbvZttSqHZrngdcPFh4RahrInL40i3dS0jtzSvCucFFRfqeF0y4r
+        8c5d0dNmyC8nH+QlMQrwx4Tyd2Iak5zxzhkdzjKBsicgjlrXUhi61+qQkJkcYt7OtO71qslN9HIn
+        F98g+NWA9O4DfU+2Fz+fxMXqOrNKVaZ4TyYU4CQFfGNmGfKAL3P8e4Nw32K/m6wZ2/QBktaqcKiy
+        O7PvVj/Z3ap1F7J7VFjVrajNr0RtaljmsrfIAqI2dLMoIY6XZY1hG/MeL2tatXPiZc3IDF24P8QZ
+        ty1LAXmK+jpcbs8b8Wq6ZuS1e6rESnBPb4f2X2tTnXWQmXkMC2NaM66wmLP0qoorsKjYBDo0Gi2w
+        rZJoQeHi/UCRFtjSGdC9ecV6Xia/zAynG+het947LS6mteNfVY/2ww/5wTu88Q67fPx5+N95AghO
+        ViexB3O6lNX2VNenpgO6DroOuj5SXc+duDu13dYVEwbsueOSniK376O7Co/4lWjfp6swPXMjV+m4
+        d1rZSqyIW8L5cx8zL6BZCUGEU2i6l57Ref6D4zEDygHKPQrlssyoseQuV6txztHNQpymAuh0WajT
+        64Nd4aQVFbhzBH6aGt4tigEsZcCTOg9qcBlfU58B5AHkNQl5nAQyLTHX00PSaStTc4W88zGo8hFW
+        FqrqB+a6PielOJc6AlbVIb9Ad7se3Zcjojs7l7bonh3+q+/zo3+zDmo0namQQGq+oLJr+rOOQBvU
+        J7+h3bZWkedO0gZhSYjSavRJoVE4tx9TejuvaUFW0v6OAxy5VZt3r7b92Nedf+T32aVPiCeX1wl3
+        4uYTJv8g+o9/+Exrd8kz2POlHzJdp7PJooNPdK2DKXMkut0pT4iBD7DvdzBXw37kZFdfyMPpVv1J
+        jAnSYXc3Odq3Wt2FRndDgk12EpBLSKCbz0UEMovwPUq5P3b9Tu8LnAlZsRw9/DF+g8VMmPw6TjqY
+        tdXlnJ/CcqVdtd6SXiD4Y0U8TtyVj9HGe3s70CU1OtpTdI5jjG/y2E22OPJxHKdEuPwnJcZ/fODo
+        0xc0t76VmPvNk6p2i3HOMWhqbaM+v//4+A9kD3iOXoQ/wugTnRJydHNF1dWcMUeml6xcqwIG5xcw
+        kxYeNFo4HufmE6ez7Avnkp9oFjb2NfGR+VPFn5kGlqXpKBN4Uf3EZTkd8940Up9X3Ttc9ePYvgM3
+        n3Zpcm5OjR3ltk3+leS2zCbi66+9elvaoidu8PMP+1RUZT+ebnZfdvrpuxDnHz2VlFyZ0mdV4Sge
+        kHXzkdkHOr1EKGom/pu2bfgu/ua7yZ+/+S36Pg0I/kXuPK+GxZdjV6amcCMDc6mBbhGFHYXnL9cJ
+        nU7NqcSUdNfr8ED8lMt9k2ySzJHt6Gid490PMAo1j2Nt9Tjl4owkqS8ZpBUeL1w3F8WJ5yqyXvLc
+        dpkqbwVOS0XW0zPXRKwuXFRkdeFczvqM7pJ5yJhai044OJNpNsEbVHL1SXm4cmNvLecoSO2SGpQi
+        Wrq5HAMfK/q5NrFIqcu/FjdeFhLEw2QdMmxL7rjJpvnXgwORFXmYU+9CzgId+8bdvZyPM5UqWRuQ
+        cvKOH79HP9utqbqbySjBEe2NHgO3x89tuROgm2dyD/BandFlkE0oKbl67arYso6o0F+cpoAqGqq3
+        ZNo5qj5Mx+xBu9jrsDk9FH4vd3ZnN2un5axkBVy42PraqYAEJwqOEAPyqSHXi6QExNLviXP3UkAW
+        ae/fchxwo8R7I9rv+m7g+l9i71pQUhqijIajFZFZTfxQUMs7JckyqChVhmk4g0quCmTpUZair9Iw
+        v5WGRra+NuyFPlIcxEKumCsRmJ75KCVpn6AwjpFpGbIFFk07J7ZpzKv8T+6gkqs19i904YP2Vx5k
+        xWGqmMAegDAUmvU/rTB88nYe+qSYbG86jiElETRSURrGuMt+VPdOLrcfBToObPHKfj8ylobcUrZp
+        d2JmmQ7L6GK7nJJDdAoXWxAGd7/X1QQiI+hApSLZesGn7NP6KRDcQSVX28aHHoSweKM+8Or1fAb0
+        nULBRroqenB1szbpgeywtS79l5w6QpFuVM8yX44xXan5E10UdLXqTzwdzxeKHJc5WU41E9Ylw9n5
+        jLVU88xyC5nmCmVtRtRY33Rcu2vWt7uWbIf1vGHivr01ZAPgYHAycSfLbWD5s7F8adSzAG2ULXbJ
+        +r7UnbaH6g7auUdMvvvTJZ4hXyjefC67ByFkmWx2f8uNc67Ga3oAXA2WQoqoZwzdeYFHqIF2Fltg
+        XJ0zvg6WlqzQG80ZOzI5Y86gkqtt768rhHhvaD6wtfsu7263+GxZV60Ft2+S6g+7LYcZs/nxAwcW
+        mluK3nrDLptML4xWczztVqT2x1tP2b2f5puq7Y7Zzmlv8sAOls/C8y9e1rNUisMNh947V+x2I++P
+        ZjIUAUIRoIrdh9Rsj8DisayHBSAsAItSEYQ7b43OP6Stf1DawvEotw+50Q5WchvThNd60L+ojJ66
+        XL0cUPSGoskWBz55/uQ9wTQAKee2tk3EQTXVuiGhvOsPrcneIg8HG9+j2I4TF2W5LVs30dxQXClL
+        eUfn1/V6t24hDF7Dmu3diIzBfjsWMD+8ZofjmDa2vcNWCgWglYKmYfC/kMkeMf+Tr1fuakUeggxD
+        bmO+WTgSjXua2spNyCxSP1VCMlIPgh5j5eO0SUC4x0Ejee864bTzZ0j2f5A6IY6hB8uFjXv0grWn
+        wAWLOfmsggumRJxryFxgyVHFBbPY7Dj5mu4Ms/UpSg7RKpTig9TJgldvLdTR8/ggTfdpC3SveRxS
+        Fb0LoYY2sOyGf8gwLbkViUwMeIg8eQSNZ6b9WBp3m0PpgMSmacj1RAAxVqSxoya+0yZoK+Hatkza
+        m+NSz4vGfycf/813WoDxJtaSUHM3Gy1fM2pvYaQlWy/W3hItXfd+pX14vq+tsHbYb9wEb7QPsgSn
+        95AfV1+07GG69pusIz99BnkkDW5k92sNRZIbF4iQHmJMxGKBWJ2rSCHoi8Ix7SJJKh7oXuk0FB9e
+        X7c73xtUPKe8ynconvj+qCVZw+fgPmJ9xxtVUgR7K/imSf7lCX7Z0d33Cf+oJBnkUhVvaQopB905
+        Mhc82RODLluDK5m7k1qkVYUsBiOjbJKvCm27Cn+ORaZ1iqHWFBkETh0VeZ6ryHNHQQfDmU/nVeuv
+        Vguc1EM9TZzcXEughyGsJwSuIbFsaLckWamAv05j6Nu9tNrK8FsMKIO83shr4AZhTXllO3lJ7tCW
+        CK2PRV5ZVa2SVlZXQVZTWQ0dBlbVoglyiylHPQ/XiBNgGTKnDfEGlVxVb7uu6AUUurQ3LKnC0mgF
+        UX1g2ew7TgXU1A1EPvClLAZKeBK56ySVEOJ9VTipV6f1EuGvluKKx1HRDNOfYrwOg83pyRWCfMRR
+        gj/Tkh3fDd4PNMEtVbFD8bODYyOuSZzHSGR6Gxc9+2IV0NoPDxv9PQzffayvw90kIw2t4Tudh3zE
+        6FIh9LNs6GuRXI/CdiXJRYbBFHJu8D7C6yxaRYPTlBgnHDaWL2JRAzl/CjnfhOt44mM3CvKC5p+9
+        hYdgkwnMcKTeAqkHqX8yqT/nMcTOyr0CWi5uebcXgbDRV8fp0zOfj/KQXc3VqJ6iGz1EEsm5lumU
+        j4P3hHa5ZIU5vcx+5V2e+DNKKW+UOMvGFeMGPRcQehD6Pgv9wU8iF9aY8iVAKtLfnRPyTayFb9r/
+        dwi+opuXHV37ry2OsObFWhBq7tH1fHflY43ItxYGWkYuzfXOdUWshFBE1LU/x8w1QvPTLbr2+zDR
+        LuTQvOAt1Ohbv9bGq3elalU0I6BaoFqgWveo1hS9+W68lfXOlsgq887cw8ZjdICNxVfc8equwiN+
+        Na3Fp6tS0PJn3Kp9VqFVkvs6D+e+y6oqTTjBRsWulHSYcDYScJPVSFTl8LhvqMiqcJCqYjLsHVLz
+        ugvtMrnIvNzXLQGLFPN01pe+iA/f2RW47XYxYVNIUMqkfjggTGt7Yu8n/LpbpS+SDbAUPXt2IlzP
+        vk5m6VpfilImHM0XNenTCdnSNH4Wi/eO6maNQ0frPtbLsiZCZRE/RZYDZgLMBJgJMBNgJp7NTEjn
+        65ZgJsBMPIeZcBbV5Y5gJgZvJgpxFbAS6ZCClcCf90RQLKbfKQSeemAqHH22YJuugbGANUXTxoKn
+        MWrmIs9AlD3gWqjTwcuqwdw3LXW7cDesLzqxHMRCHD38QRSe3RED1qMH1gMWGmA7ipfBdozddnRi
+        EQr7eZo0AbZuWmzXizpmYKZXPea2qsKsKlwpF+yZUuGLYVtEtuvYg/Tu2bTs5kv5hyXVCEhs2NTM
+        gszEpGwDb45NFvFYxnJuTjtoAMuplCrbuS3je1Tu/H7JSqiqd4iLfAN+O6+xAKhMU5CeO+iKm9TU
+        s8QAyQDJLUNybQ8aIHl0kDwIuG0x2wpwC3ALHvAzwC2zpgasTYcwWHuOPFvmVAF0IezQEejO9UU2
+        qXrRaH06q5rSkJH32RxdnoQrVI0UxRv83QY6iIkg1jGWALEAsQCxALFPCrE1gbPVqggATgBOAE4A
+        zl4DZ9O+qaUbvE3yFf3CC2VQAhyeIcNGtlmJw2fgKNf6c8CRGTbwqqbxbp84FxlVarDrndR3g4/n
+        HqbWqyHaaYA3VF9dwnovVYO/nkeko+gZmFd3ZdKU2kHmlylf2V+mBHg5/+5v3Nfnk633FWXPjnNh
+        q0qYZ6OyzygZ9lwtvHmjDhEZFAYpNyRDpbwBH3hF/AY3Wm9lALVYLFAOqpyavYZQVbIPudx5OYCr
+        PcLVBrd7iY/yewKkBQxVSyQ1gI748/5OdKxe0Rvyo/krQbklvMww1eef1+y1lup1wF56fV7ydN6y
+        /N7VONij/tsjkTaohRTK7hRZPPlAwvXTwU4WvwLsZC/tJMU8FUPJ2zzUVHRGavcbdyAg99falH3N
+        o1cLbFuJNoqsLvHEIQMkYGFvsVA1rAJ4CHgIeAh4OE48JNJ3qSpDbFmZzDnVlRGVa20piSKfAhYy
+        h1q/1Ok3zz74CSB0Np3a01IMFUcDePc+CmCZ9IPcSd8vxb4k0X7HfoISRqeofAvUqTigCL/hCAdr
+        PMl06ozWqES1uAiKg80+9IKEg5yTozmhlJqQj9r7mMJYzKJ0OubqcgVeD8RccF/4cBsiseW4ozNd
+        h5LfvBqUpKpoTWnlUrlROilNKnvopH3scW/Cwj3TRObNTj7VUhQoMHmiwDMUmECBSQ8AuGnHPiEz
+        /UQmW8ySinGT+C6WPG4aukJy9AVSqZybTthTNQSSqGDLZGzZ45KolWPaTKCOPFRW2xiDme3UzCLD
+        RJZsdycwtqIbwdg+m7GlgUZ2jEqQkr0XzC2Y20ea2zfXj2XtrXBsywa3TvBR+K39tcp0r29qiol5
+        ZZrQVFUHV26ivcpGKDSrsgyjdM/joPG9dnuqASymriO5laknLrOzCumGmlKVVo1CDonzFTIYXhW/
+        7EFT20GsqqhKVk2kKZTnnsldge4qGR7JzW5s7c+ggXzc1QRn9+dSJyDde6A4siozlAuqu89dZ9Zp
+        Zk5qeQiicy6v3IQo2vNAfS13vcdg/4zlBKUGAZ0iR2AWmjILtjWfLZghrFHgjSm9WGExmjIKWZDw
+        qnqkBOyv+hvZZafYZM+8ZnXZyqBZs3MqZWM6/6hao1PdgkB7wBgJX9/PgFKPLdSYrA/LkqyabZE1
+        4pIwS2dvTyY9NKOpJHMqnx5SLMSuMGVFlJOIio3K7g17OdRHy1d1h2hcQ1YP1mBg9sDsNVTDXWL1
+        7DQDU2LxShqLmteAJ7AyFefOZkYx1aqUoKyha7IJJy/zfN/a6C74Nm2natwlnUz7k5pWyXjFnTdX
+        JJ/dGS17ZJ7jsYjcHc4q5aG7BLpmIkK2bla73mUdjqc1th+OGFqM2bwMK26xZabg6JXjhGpq9OTd
+        CZvwAoAAgJQDyAbjPSLflQ64aRxvWojWbYIzA84MODOARY9zZi6xCuU+Xqq9GWBb65CifOpFD+wW
+        16a2wkKw7eHBtnKIHGdcDQoeeBbh0mJkyfFQwUKAhTj//pEWgtgF7Ifknji3FCs/fE9X8TiYUE3x
+        ggPdN5eEaBXRH76EB0SeQiQiwXGSywP68JItcgPk7aj84A06t9k56YAbbK61IcI+mRWegJERvx6M
+        DBgZeSNzh31ptiwBKg1uxgzTwjRbeA1WJv0DVgaszCCtTNojsWhqgjy1Q3n/ALsj2XAU7M5g7E5T
+        7UP7HO8fB/pzXyhjEgbSeQ5KyxRtwmSspiGbF9iBIdqBZvfegHkA8wDmoTjgrspjUVZkhsz5i3zj
+        6EVrjaNlu8vAKmMo1gUy7MxlCEux44ZlPyAsJUx+OAUz0sxpw4q5j6c8YX089sGWzn5Un8sOFuL0
+        O7AQYCHaxP4psox2lhCQIAcTAZ3J2MtgJNhxYCSGuowgZFNZNuS9ha/Ru+SGkhbDxSesySNSeaj5
+        FOiG/NymCvohP4EparIf8vMYlUf2P7avtyWrmBbrTrvCxqxbtSpSW6NFX9nVnmqwPw+xP5K7uPkW
+        aNH4DvBeWixYVYEpY0Z2a8p4g7Jartc4ISTZcQnCRW+iR2HkJV/SeDqrn3KG4voZc501NnxMuLrF
+        0k2pNjflL7Z1y2GeUmaTC9OubcyLs59zRQtHRyIsr0QPozKHRDfBJQGX5F6XZIgHwPXDJSlp3MU0
+        xoEeW/kocGXAlWnUlZELK4PDM0KHB60PcRLuqEzG4PyA8wPODzg/4PyA8wPOz+0ogfNzY2HP0D6B
+        bEfX1nW41hSyG+X3QnYDrCJYRchuwGK/ZLHPcUVui2MVnJGKIu8T9ld4C+W14GDLe2fLmz/iAqyr
+        +PVgXcG6qljXpTTaXt+V+dhK9nSqs8s0SUO4ZMzGHbYLcvSwkIawNISlwUUAF+FZXATIyT/lMh2y
+        8+D2gNsDbg+4PeD2sGPA7QG3ZxRuz22HAYQ/75FhI8XTv9roNQBdAiD3AV0CwAkYULuasTkFZYbi
+        3NOsaCzEPc0sZFjyPc0eYVYKfd1ljAuYITBDzZoh6K52+l2PjRV0V3ukSWvFWE0J7oKxAmMFxgqM
+        FeczRmCsyGMi/J5SoXDzux+uXB9s3XPYuhnR475F8cCCXQ0BCwYW7GYMWDAwQWMyQUmiVCnzeAM0
+        h5wTWJ+eWR+mKIXRKb7xuXfFIAHb8gdmdo/bQ8jYNIG3UbgKE28dIxwhM5UT5U0ZRjX6sYfANLeZ
+        sArsGsMe8UVFYKg+U0XmHJb7HNIbrqPpQ93SR3ifmaPJdUmfyvtkUUz4If12LWuck8LBusmwIY9/
+        ZDvgG+Bb/kvAtyfCNymH72pQdmS5NTVul2dR+mtTeIg5FexDQrToEF+OMTcNRNObt4DZ/3VvzdWq
+        tSiOKQCqUxwjvtirlaR09WIKs9fyUHMdycW3h6DW6eNf6cc3UjDY6pqOp5N4t8KbDfkoZBimpAKq
+        HdJ8eYPUgsoiDodI8Nlrudyf3yAj/EZxzBGvkzBKA0GpBs8b2sqTCrhP8DPIvYkXHgeyOD7+TD7S
+        2+Egcf1SNhAlj9x1klJZwms0GgM71i80jGoYW5hLS8RM9pokiInmL8Pve3m5O/iJl2LGyV28YZuk
+        7gt9ijoeSxEGeDJWOKexRKg4EW9m9PW+N2taLYMVj8sCqfSnGBOnZXN6ckuSa1vzWcdya+tzlibi
+        HY/VC5kG9gu07llLyykgISBhyxJ2dorEsnUvxJULWPYBCqsKkw3AsDI4sxdsuo2VQBXHqpjeYoWX
+        m966Z03SJM4VHK+fvYWHYJMV1Ap3VHeAgfdEHdvy3KXCgn3z0k9hh1sgVo35nT8x/lkqJYgIWMyE
+        6PLAR476vDjH6bHmqUjnRa6421gia/lSjTVzXabjZr5+N61FYf1eTwKGkeXn2FnZJD/n1i56alZ6
+        hVzOstu2M4Ww1PShIf+wfynsTGcdeZUtYmpFi5uXYs6lqrBoMWf1WAwNU2Q5AA2XYQANw4SGAZfB
+        1MEQq08YsgQMuRkGGAIY0nsMWawaXj1URcq47K+KnYFKax2pdGXgr5Kf0VkmQZVbVuWsk9XCmoNO
+        19fpmtF20GlY/Sur6pJ4zKCqYH5HqqpPZX7B9l6GgEK3rdAQec8GqOupT7QwjW5BzuxqCGgsBLVG
+        oOKFQsS7NdsuFI5Ia/a8qU1SlrGcm1NWER5QAnap7DDYwnx5NbB0dkPApZoCTJiyfBdTx3endUHG
+        xyXjzwP2xRzo3flJUAZQhoEqQxaCkDcP4AI9pUaMRdCHHGvrm3g3FZcCia4n0a1EpfoA3LVDRA0D
+        d/UxWQDc7Ym5pRu8vQoVp4gWgqoCjZjRE1lss0Qj6rVAhLisrE52EJdlz4itt0Xn1HnQejUy+SxK
+        /3A6zHK/ouzZskdSMe1zGmhEMYBV2cOa3Ejs9Trjp2jjCGAoYChgaPqnIwxttrlY/+Hx0cBH1vwq
+        wGfoJav5C2hcWoLIj65cCtdrJHEepvr8czOBiiGqz20sLCLRkEV+NBQ8DcLEyHYPkZf69kNXpTbv
+        ju4QhUXwcxvI51g+NGAfFeIqiKKein1U2NupvDSQKobjDnw67J6yr+m6vK1WvXjleQ43Ujpk9AOg
+        K4zqAOguB75ZhQPfmjvctAiQAHtjdlnLIXFWGRVp0EN8MqCEkEkrIROfypt8uSgFyKU8QFbi3S08
+        ZqnUkmT0KYxROfA2va3W+bX48LFh71DPIbuVlkXloRyX/D47Umo5r3QcJipoFBcbB3gwx8PjBTXO
+        VGvCjX6eYy0ffDaHlCE6ueupCKKTM8T2yBUbJhOZjrxhKuY8IZM5dp8dMplyX/H/s/emTa7jxprw
+        X6kovx8NipuW6k/u9jYOd9+x3R7HREw4KigJVaKLItUkparTEf7vL0BSGwiSCRJchY57z5EPwQX5
+        ZCYSiVwgildFgwzAdo8JJT5o9eXcuacsB4c6IVUnpNNYuui2hR0jsuVh71VnpOqMtJ+lVy2q9wPk
+        Hh3crqlIN5Ap4hlTKyvvRrWyqpVVraxlY9TK+sgr65A9hZ2tvpeU3fxpvVpI1UI67oW0dur2CLyr
+        41tGJbXWLUvYhTlJ+zuc6m85oUxZNRF5ftTSRYfbGq18sbFEDo2gIQoTPzQaa7DBxTC7CU+BBhzk
+        R94cNkkMOrhULM1OTzuJOeBcXjsxkcUK+30k2wehnYKUqLQafTxVsAIzSsKasYKvGehsij/0ysFl
+        IFYi6i8vtEs62+GVXVx4Y0ovVqw8shaXdB92E8VSsmjcNHq2XqrG3YFfVmlskMtXLunjXp7U6lX4
+        +pHlpve/pKnlihWvi5EIOdBa0MMvY95aqPdIlrhH3RwNcf2quqNonNp6qcVLLV5jW7ys5EioZOEq
+        OhzRdN241XsFK4sJKXuZCFdC1/opQcy6wDvybraraaSyDcuuGnd1wBPS6oZZMv6acGNCamLeHRBW
+        PfYGjAUDRs1tyARVdn+KmKMsC5Vxr5pQXHvxtNQW4wMin5eMS1TVOYHFMBENCFPKSikrpayUshqC
+        ssrtWYQrAYls7dk9+4Mmyw11ay9+7skmzgkm2M0bKL+iTXdx7YtRa8TOd9yPuLlWh53PoMzsObea
+        0gvHulWLh1o8elk8yJKBvYA8JsoWkbUXvCdRe9ifUTly/SNN5okDtA7pj2/BEZGnZL1UULq8oE83
+        3iHHR+6e8g/eoktRj7MMOP72VhpC7JGJ4plagopfr5YgtQTJWoIarD7qXPKx1x8JUS9qDVJrkFqD
+        HnMNygSO03pPLTtq2VHLzq3AqWVHLTtq2ZG57FCBE197BIsbKpfbxNYe5XK7+U+tO/mvUOuOWnfE
+        Tn0WyFg+wyvxrlqrxFtRzl0tVmqxUsEFaplRy8xIlpnLCmPnVpiKhGpNrPUS0MNm5BqGqKVjqEuH
+        BfaxLQpKv7eweHSZDqaWiXrLxOOo/J6U+RyZejvbBXWu8tg6X0YRC6X1b/9Naf3Jaf0hG/pxIgbF
+        qXENVXKmWFL+iQ4Yb3ZlCqZYWQD7ANWS+OTrZtnXcQWhKNnsrMIqSE6IJLKXMjST3fWU3JCV2TR1
+        /abMplnVaPEm244ldUmtWd5LKm8l0AShG39r8rbbh+Rfq+yDYdgHt2ZeZWkQLkul+/3qe295qt7L
+        7tmSfWtWmlZa/+Cy6rQRDk9kAXklq3NYqP6V3VLfbhlu4d8hWy2dFQdeQQpnUc49xjhEx+h6Dmbo
+        1bn97Sx0Ain89dYJc5Ufk1sm7PyY4os96nCgNi3f691ywHg3dp2ovTOpXimppOi9rhxhQI1g3Zb4
+        EDGtzYZ2NXvs2aRASNHzO6ksogzhTgzhXC0TETW6At1bXNqkOyNWncUrs5UZ8yBmq4Dzw9JYARX3
+        fSw1dmmp3B+bmrFovkW2NNNmnlK2duamXXvRzc9+yWWj/Ca61H64PycQsCDaOO9SMQ7DXMb5RW8h
+        p13suFo7oGy9vTCtWniLXz/ccy4VBNfz2dhlkJ9Ysq9RTEiy5xKk5sr+Ur4rvFkT7r3OK9G1fK6x
+        G0TgIvzCrFp1103NUDvvh9l5j7GN8Kh23iLBLazoKVug8PVqE973qt7BJlzQgmht7Ve7esCNHe3q
+        71Uk2hyjONhTjmVinJSloiwVZakk45WloiyV3FBlqeRGKUtFWSrNLZUxHjykp8Gvjos8x38/0gZQ
+        qb4fr7nw2GcR6thhmAu4OnZ41GMHdb5wnyyD8NcB6RYSKy2ta1XWEGgQd6N1f9sUt9BjXBP5oMK3
+        z/f3pVvh8go2g4yVe5wlcrh73AnvXwVyS2+9rxz9XVx1wES6Ca860EWC5P1+atlHNqVaZoa1zMhP
+        iTEaNkHPVpnf8EWQv/hMaDkYckGCEZeYMfTKduA5ZT8nqkspe6XslbJXyl4p+wm5seovCQsiBCL+
+        G6XolaJXil4peqXo86OGrOhzJcSUmldqXqn5ftR8cz2dLgLdK+rhK+Fu1Cs9+zQMw36GVDUCHmYa
+        5ur22GvCamplvJg1tRTn1sZKCsfO1omdOyyTK34QJxz5/A8nxk+eu3fj6In84xNRDcc9Jiv99ukt
+        CJ8YptCevo+iI40ieIqcPX5yovMII1UfGmu+lfD4ZeB/G+hV6MlrMQtetamAMi0rqCegdYanTO5K
+        jVapCZN1uio1YeovS2POCvIjqQnCFEpNKDWR4k3+2jvIROZyjdwYpCysBj1XAHJWeE04b0avLhIN
+        jtdJLHKP2G7+OZvlLTj62/T4Kh/vXIeJZACeRmFwpALAAi+KAx6UA3L1x8G4g40F1sciUCD1fv22
+        zOWiqvBptzwFX65Mjc27CA/bzGrJQ2YtmngPUo6c5WkqnTGznatZsdJQ38WFdUfCa/rSrOI1k2w7
+        i3iNvTZeXpualizlVrIaWhCD6LpHifAm8LflGyl2dKVBy9xPuCZ0NnHCvpBhos9PT3yqh4g+V9oe
+        k7kp3VRBqc+OlrijZf1QlkHURvcrVBF/FI6rJEF7ezXeYhbFVEBudAxXT7TgWW6yeSt8fw0lxdNG
+        icT5yNJ09OZEMcqULdHsunGvm8Qa7qSSfFbd5BNKIL0oBk03SzEUTn6omHHPk7X7mqz5DO/Fpz+L
+        66yxkMV+OK63H4nr6WSPXhw6fU9ZkoOgbMqJReztz+5V6ojFoUsdtI6nbExlY9ZwgiyZIcrEnKaJ
+        KXEbzNNMJxwgU8aywzuRN9ljvcJrGQemIgTT4FeR1KzyrNxyT1kawJgnXjfhNGz4ZBFG+S0At0ZM
+        qbFo1jAW+4S13BaZCqoPBOjyEeTUgMjpCMAyHgOs0eP0CFqSlakxGimPJk9jxGiqsuTGu+OazPjg
+        ekE823hkj4PRznE/jsjW5gCY7h5QBRekOamxKGlOmrtYsEGtXzKnjOCtF1Ir2ZRxgQoOx0jhNBqc
+        FslipcAaA1iQJUoEppU+cpREyRgFvo9jZCt2Zwg5MHY/46RWkcEidZ/o1wdMUjrGD5WuJU3BFXUb
+        UPcQk33fHMXHcC2daRfWit35sVS19Rc26a/wWk2agqeP9IVhPSYNZBsA9IiTDawd4rTbgHw0c29L
+        nfI0ZQ8EqKNLK4mmyd5yAA2wvBYpvtjz2gM/LhdapQjpUXJ0ptuIzZ9XKHSGgoHOFG2CwJk4Fyv/
+        ufLFsq2TEWup5igGVJRsWthT+vKn6ErousoVTO2EroPVUFDCGVTHK8LJZcnkjE4JuRjBMkFeImOl
+        aAelXT/eSd6gkqvS/ZO/zY85W189Oy9bMgLnbaiU6Tnh2qJ+P3tQmaRXQgaCmWy1tvgLEUqPSK9e
+        UamD+9QxNZXoPgLMViq6SmxHjycN8EN4v8bbLXk3slC0J58hGdiV8cKWlSu8luF1+aRSzxn/65Hr
+        v+EQ+0l85Bjn4WydfKb1gL6eqkCiCM46H6oMstuUFuhfCzAIdopdreW6GXIPtmbfoytkZysZHTqK
+        INfEuMV1QiC+u+9Oon3+TH78nvxAJvrRjRnLBNTvmW8ApI+XAXSLhQnvJ1IHP37qeSWpf2J1nqJ0
+        PUo35/q/Aet4KijageKPZ1s+6haGuVFIYOZSbtMhTORs1Alv4iBMCqI/p0l4VSRBpiJKjihUeP/R
+        LV1qHAzKpow5XzC1N/fuzPHjXUh22ZvyrLcC8oDaK+2rEk3p/Cv1mWWWWGu5i4Iazcw1E6qj1Up0
+        FY/SRbkhRaV5J0LrfOOmDmmtKN02pVP9AaJz/vvGSullB5QODtin1e94jq1CAi+noqENzRakcDkB
+        DSABc80HR0tAmeRTxKtPPDYguoB6wN6VlcQDFcaWEkYpi3iNVCM3bLJ0/ansWTACEi+Yecgn8Rbj
+        Q4TxBy25+gfy+2f6+18WcCEytZUcSlM6dRITXERpW5DSUEIi3TJhVtN0aLnKzUSYmmlhIECucREx
+        5ehYcK/eQh9A7qKwfWS2rmZZYr95TrQTIrckfds/udktonxi74PAj3ZBTNTEX929i/5qon/uXP8j
+        fWY1qeUoCXNhGnZVHnS71kPC2IscfX4iPPiT8/X9X86/0E8m0Kq35HDhy2KhV+UL90Kav39iP/nD
+        Qv/6EZnW/Af0vWn+gP7iR4TVNjH6099WHRJqCDxkF8lruRD+6rgoCN9nf/7xJ2RrSzDhWCuhJuF0
+        c1nZM7VVwnH4K63Ed+7XZJjg9oUv5FmrCpqs8TYMNh/kZv+EwwgP/CDM1F6KDBgpJ1z3tBZoFmpq
+        ENEdGbWtYnOxBWrbYGLb02PsFTOlFgj9SnZBswg74WZXSuVfjjj89pwccFW7ii9P5iWtZy+7/xYv
+        WDuedvFia8x5AZontQv0F/MFnYzvmBTXjbPZ4ddNiNNC4TcgJt+f8GzOA5veRO7Zcm8AtF/k2J8l
+        bTdMXb9p1rAQaG14f6eZuvPmuakUzp/7mGXOr1VCkMIpSFZtSV/CTrIxBM5qEnalM6BB1HmBYHqS
+        M8OTnuk7932Xis5NDHThaC/4hA/e46173GfjL8P/y9METhS5UUxEjCCE39wkCL9Ia9BQ1iNtYXKM
+        yvpriMTHbd9StMvGJP3fXykjVgXOOUQzyAqua9hSk959pO9JdXI2iavP216IqbpE0c0NWym66So6
+        Q1eaTmm6iWk6Y/4C0nRZ5fXMpiOiYNRSdZxzzXJVZ8BUHds5ehJ2DUspTnn/z0hz9s6vgZ/0+SOK
+        8Bgj8o+zT/KKCPn4c0bhmhn6OcSEIphieYEYpU9AGX24VQOUdA7KDkkh94OTg0xEeb1QGIvkKl1h
+        V9WS1YYzpP+FNB8hMDG+TLuJVH1ciaOhuEZug/OpNNgAcLg6r2AOCbWCym2sxqwBhb1J+8RixJBu
+        mPAwZAVbk4yw3qG22LZFpTE7VWYSCGwCVlU31xaxZiMPhgNFrrLyw0IxIgEyDLZwZUELywXSX5C5
+        uqVLg/3IGLSqFHhHqFONxQdIjiHpDmPAufCMfwBAwLWqQqNlNNwsCkbiGpdUublW4UAgfDjHtzLg
+        uVbmhqpGAK3ImsGWbh8qwVg7ovCaRILB08qqTrD75ByBWPOmcab96AA72VEKNfwm1pKFzAXQWpKC
+        Lij2o0V8WTadtrlEeMICqrapy29vAORMowJhnJOhtD5/tTBOHaoRiBXdkCpVW47vo6nahCdSf70Q
+        a5A7TZjgT581pJ7XNMGXN6r8LMZGlglzSbCKrzaMHfV0K6nKout3ZW96l0ECAdzkUTi0iwPUKaRw
+        aA0H+OHw9NeWts2OMS9dqUMsbS5E/u9FsYxiGRDLiORHK36ZCr9w2EFtfB5248MmppfHNbLhTGV5
+        A4fQDUI3pmHyqzQFAxBpzJ6Ic5Mq1k5MXhs95wMBuMNvPsSSFxhi6PayutQDz6otvlgjF7I6keRK
+        Lfbgkz/+hlyFpc3klP9Pvqx+XwDyEYRiDkHQxZyvoCd57MPdPZGpqodmZKl8dtljhJYTn2jXE36N
+        YiJI+4GvPPAYWdmKLMLhiYx4JYiETfRdYctvMdXXjgJ7ZHWkdMv12Uq3jFO35Cv8iSVgAQ0qA2xQ
+        sfVeKvSRCRl+8yFLafHt/esvQ4Nl5l6pxVb9qDSo0gp5SukppTc1pVfTqgImoDbUYo+tlZSKuT5b
+        qZhxqhjf8QMRvWLmEnCBlhUwbxeit25EEvLUOzthQgqM1d1V6oude6VRpfSd0nd3Ayei72qaVHnV
+        144Oe2SdpFTM9dlKxYxRxRQkm1RURkvdTvNq3ZJvO1ShXTiPbveguNXqxGk02VxAw8jp0/TAcgFm
+        +GxZNZG5bMj7xckgS7pmKylRUjIyKRHaY4tVm7t3gxu5WwvrhUMG3p6o5r+qardtw9qBjUSq2Hir
+        Kplipw6IClkqIezfhDuH/M4RMFRfUJCAkpcP8+pOjloveCW+NglJkqktcgV9RylLXS9TGeuvEFta
+        SHjFanHZeeA1ZJRMPJEFwaARbkoqlFQoqUilwjluXViySzLyzkkMcHXB2uEOnMXvZ76CMDpHIC6Y
+        pI+r4sF0VPrwkmEtS4vcXBqG3TKVrKOKIqKK8xTntcJ5JjKWivMU53XMeWlBpHK/hOI8xXnNOC+Z
+        kgCPWblW1I/DZYtcLp8gn8kJdrjGNHAvOl7s7nFxlMTl3+UEQqQMVPFQaCCE8LP7k9y2Qy3YzeWb
+        40UFu8trW46SQewWtHBoa47I5I18BYQMrbwZhFJCfSohpTKUyhicykhN5BVtd6A0R/rvw9McynxR
+        uugBdFE+Z7lUC7HyVVIYUE4Ky0A0EKt7i5vftVrYQGkgpYGmqIFSk4ielCyUMlLKSCkjpYx6V0Ym
+        MkQ8O0oZ8UcrZaSUkVJG7KgKZWTzNmaiXcfB5aRMYDmpNCxaIGsY1gn9PihaXtPk3kMGWV1fFTLI
+        9oOvTsZQMYZDiDE8Gw12kvu3aia17cneA0tShJ1wsyPjfbqiXu/75YjDb3d48YZH7q/4dee+756T
+        tEXrt9WjveAzHWzOAaP3eOse99kNy/nlhv8q2c6P7EG26wYRA/cEedkeoajW2xWwgt27Bdt7WBOX
+        5+rFcyr2U+xXl/3OW+aySiEbMij5xpQLbiC41E2AV7jljB6fv6WFnFTJ3hbF2jnWLlSuissVl4+W
+        y9N9Rp1CT2pPqvakak/aptO3aMAnXr+mWIhJdxZRaCFDqKGTEvRuBF1JSW0pKRSAOHT8aBO6ayyw
+        IbZglQ6kFi5YVHOvyQzJ+DP79myiB8oFEHYtKDxQfcyavG92977bAPpiKJIHVpcgqh2YfEeP6IDx
+        XcXUClvSyMVNs+MjTBa+7XNWks5sNcw4pXE2hyttuY/q69CZfQ4PeIh7oLxGcYkc1soNHX3xqXp5
+        oSxzqw0QhzsLCzFAd/gslaUyeFoJ8+E4PNW2isWlsniRE0vp4gacqnSxZEblFohQjKoYtU9Gre8w
+        VTX0uqqhJ9NlCnGCXlymEP/qrcfUUg7TwThMpfhKlYyrOpmDFxEe99dylLJdJzsoNdC5n7ShDw/u
+        J00aLuXrxOT0TTIu73cAtlgQ0lHNHLHph75jH4dOXWozH3Yz9+fqZvL3o/OVMcBQJg+KZteplFeM
+        AaxIrFop5oZrmllVGXPFGFNnDGJnzgzqwPlC9K9Zidrg0Sfzpr20AlwTmv22cBSxlePuaDq3FvVo
+        aliKpixNCTEb8ami6R1N021jc/G3bEXWYrLW1gA12q09AFWb6gBF1VuqUqdUYwVgWEqvFhK1rvib
+        iqQ5kjaUfUXSW5JGseNvnXCrzP+2Cav2ALIJqzYCUgmrNEA79FSCL4meSt6l0rPU6VfoHVbiL8P/
+        V4O8invz5C3SCIq8bXsFa1BYOQjLKCxDRSivFo/AEpWEIvAtgcvdhuLkVR5EEQ+iOH2V5ytPXXnK
+        QVH3lrrVfkW1w2jfxajs4Pa9jYrGrTkelYpozQepuLY1d6QirYw41apoZV6AKbAI2uubh7+eaVs3
+        s2bN8nyZcHgpD242xv0XVVa6yX2KlBh4c8lGuPOSN3gZHiVXW0nfyMjFzryyYHnteFxIC4i0kwPn
+        wrU3RJnQ1Ki4kWqQiodC2zyUC/SAmjDITZy59mkYXnKNlCLSc61OohlUlbapFB9dy3WluMahn4Sf
+        rZTWqJVWZkYbyBAq1KD0l9JfSn8p/dW//qKsizwnxoleUgpsbDUClPpq9Gyu+ipscCdJfxU+f4IK
+        rHCuVarJFFNHy5rqyIKro6WoOrImZk9pbMGwapWksdW2lDOrwbOVsTVmY8u8nrkIOruUclPK7XpB
+        KTel3Aao3GrvJCeu3QawkxycbhuHClPaanDaqloNkYk+lwW0XMvysQ6WQdovV0kBCHpaJH+xqiO2
+        Izc3lKwOW1Z5A6oL02YCXbhxUrKtZFvJ9khlG7xUp531qjoV5DrrdWe9c5VEydX68l/ZCuaGCou6
+        FrxSF4XqovjoRumLLvRFZgnoRLqV6lCqQ6kOpTpAqiPtZ7FCulDjL5WxMfQtlMrYeGSVqjZvzMgu
+        j3ySA5+G2hSu3sZ8/KK0gzztoGLz8iO7js2TGDSsFIBSAIWPUQpgsAqASMDX8EV/MIc3tTXARIVY
+        2fjsyLwIFwqnnEgJQ4oQTyvpZ7D6oj0PhFIwSsGwQ6UqGETEQ1kKylJQgjx6QXZ9V0SS04W5xjGI
+        nbuxMM5L9FjDzt0xfpXBtrmtNBYsjW1drbSM0jL3IzvXMmad/cjEU0cGo2K6zSBRSkYpGXaoHCVj
+        KSWjlIxSMkrJtKhkWt4nZTFKRu0gM9m7q/sPmuBmDHrMC9uHncnV4aZNHSMrPTnaKDOqTWuG7yrF
+        erlDKValWJViVYo1GZIqVt/xAxFtSlXKi5guTRXdS7VGhCjO+4dWjh5fhABUHdqMbi9VhyYzWOm2
+        67OVbhucboMorZrW4HD1l9JGShspbTQ6bZT1UqvQQWnrM86+dAHTRc/cQCdGwdy85DkfQ1SitGoY
+        RYCWbqwOuP881ssPVgKNGsAVwQdx1xZiCDwV4mi+UgDzDFLkSegJwlXdHbNcCAmxvdjdYx58G3Ix
+        0Wgp6Zzj1g3uIWFXrnIA2dEMIjfPT3wKbEAuD2+ODBbgbMvav1gAg8HWXxbMkMJrQGPhnjoL2EFf
+        ovlqV6K48EYraz7zj8n8WqqcW/3sKKNv1aqcjko/o2SYiC1Qw35oskgXagDa0lRpAaUFbv5TWuDx
+        tECRLVetBqwqNQC4p1QZAI3yhayDG1Dac+tCzirAwiMejVVuSsSViPNE/Oz8M1dqvVfr/c1/Shk8
+        hjIIna2LfSLb7oxQdO2sHfTLJ/YtZJnre5XAk5eb21mhubrVdXsFYPf6zuumzFnOFpwaD8UU9ONd
+        GBzcDdp4hFEwslBwOEbP9Wpr1iW4oZtN6qsscx8yTWi0Odo57scRhM4KYEh2gE1ts25syESB7+MY
+        BI0FWNc7gCYvvxMFZ6nAGQg4W4wPEcYfKDTQ1o1i1/OQ5zl7By31NQieF+1FkmJreO6d/5ApAJSA
+        YaHVGrl+RGyvDUxo2NOtupjM76pU14kTnSYgmkUFRAyTBSgIWKI9XARL/kOmAMyeqC+yDUI+3gcX
+        YJBps0FJJctM/xLDfsUUgEk9Iog6jWwmwLX2Wg4sADk58nEc6oqGYBoGFnjxlGNx6s1MmtpRHWOA
+        gsPKhX4NNoekN0Ts+sciA8PEI8uk72zx7O+Jr+73hBAhsvQf0PfWD+gv5+Xzz3/+P38CYaRXoHN+
+        XSE0lrm866XGi65dmIbNFgVm3ea55wgirPOIKeBXhQdHVvhVLwBRzR9EETKJwbn/ejvYw0LFsAx9
+        aT4sKsYZFoXKAFD5M97vHWQhm+zNutReK+OFJXad43/2MaPHI11c7JsVxZzry2GJymMtK87e+TXw
+        kR+cnBn9g5hhmzBAJ1gjVwuUK5O+45U+XkovANZoy5l0jfy6bEhBrRNYeH4FD8dyhCiJoQAtpMJj
+        5ezlruEx5cAjN0UGKorF6So5jA8h3rvEAgfCDMugFZBDvXeks6QazglL+1AXFiBqCWuwvoUcGo9J
+        nNOILM7+edzi/B4Gv6QnA8jSjPNpjePDDgYgSyp9g4y1lGOoyrI+V8w05Jg5ArXBiiFJT2tOOIyc
+        2PUwDBXgwaYcXHh2qjTjc1l0NNonNu/JVm1JN2pdSglHAB5bRvY4dtIz/0xc3o9OuEU2MtjwvUZn
+        zQMHJpkEgDg22jtEj7ibD2QQ3iWyjds4ma9WKhD/Tov0YtMiut7T1lifOVhGGzK/FMiFII7pocQE
+        kLSk7LC6xjIgL9sFsePOPty9iz7M65G//qLPYRBCKpM95yPQqsuaSGALkFdKSpfEXt1RCZrpmeCd
+        S/2Zk0tSRPEltM6fAYzAkSOz1GorzODIXexB/9ZJG5BbHwSmCyr6yXM4SJCBrLTeN4CD8qzWNge1
+        tikoCDVSHJRwUOS84dQQFuelIbLSYj63CpVR7mIPrDRQtjh4zjfHRXFcnoJDKBU6mzjBDJaEUw1r
+        W766NP8sOmBM5p2fMc3dmhUkcBV6o2W5SiwDMGneoJKrgsyc9/t0x86NNvKfO5eAGiLPCd8xOpXH
+        ukV4E/jbRF/pK6sOx95xUxw6frQJ3UNV2aLLe3VNr54Cio/hOoBNhGzIDDanv4+J7LYzmmqCvhD9
+        a7YlrIIwKkfj4H5hL1kTFuZLvWKENUpInd9aMoPliyk2g4U2t4YxA/LptTAYyAxwGHwcZ5ckUG6m
+        Ie+z0hsL4yGAmeN1VJ60jOL83NN0MaIWYhzFjWkAdJgMigb8lLmHmLz9UFN333d360dhYcuCUha6
+        ZixKCmSc9Y2hzV/MhbUwIF5M6aouT5halQovg/5dTEOys6lBQ7OkaMgNCVcv9nxpQIzfUZKQ0K4+
+        Gz48Cb+R160Dz93M/ic4Rv/A6U5z9r9wSNQEUek/XuIFlvoPoH2WoUFOj64vrqxCk3cvPYQLSp62
+        vmJMI13JH38nm2YYmFKhBPmAuINKrsrJ9h0zmtg3tTlamtf45T7kdAjgTlBUU3CzxKeeIVaquA18
+        LWRa8x/Q96aASq6KqR2V1EoJthwIqpdSJY47+wP5/TP9/Q9YGC0b4TBuWZUSET9sVJE+Z+tJlkbC
+        T2qtzU9pcgj/C56JPx25nZKBXIAq0i3TVip51NDexEmeXRQmspR9PGWAaYKE2uROFOSf6M8MaYXz
+        Y+CsGcjW50ppPwDOfUu0grkTmFcK5emgfE1f+StNX/mrKYatclQODdz/mMhz33fySlo7rmn0kzF5
+        KVEHlcoFS4m9u4WpKEC45kjokEyFpcPRi0MHqKwhUeNjoUU6mXtqOPu1k28K2MDvByCGOV9Uh5Nz
+        B5VcleUZqlIoZ4KlwdDSloWRkK2g9Kko2X6n68CCOop0V9KBK7MqOWWoJsRvinKEcmmqh6EtlJjW
+        IRusuL0iW0Y2KqNCzKZk9Eo1OK89OtVc30EhDh3/g5b0M9HaiTDak+2AS/ejR8cDbgrYckE8WtKX
+        cWqeb4PNcU/LoW92R/8jSh78yxGH357z/UN4yadmZe2J/JDCaxndU5LAthDJ1O+petAuvaS0LDck
+        Swyy0TzpQ6q/mC/oZHyn39OX24o0edU5a9vWDJOtqFiV513RbfiyQ9bY7T5v4KuzDk741dT1jysZ
+        F0nfzcoSJdx7Tc1esnvKCjpwn7PSRAhTMo0qnbDG2zDYfJDH+LRQW66kL6sfILUMF3aJeshdFC5Y
+        ucgVrExC/OkUaIX+6y1nwbvyJG945P6KX2nmxXOSnmD8tnq0F3zCB+/x1j3us/GX4f/lKTgnityk
+        gCGBCL+5nvdc7BmjzoFjTGZ5jMqS7fur79h9YYG76kU3A5K7j/Q9qd8xm8TVR24vKlVekgd60XgG
+        2XDU0niGZi3FNF6+4lVpaawqe3N08j7P1dyNgmOY8MHzLo4P0XezmfMZaWk9Vo2IxYxow2OMyD/O
+        PslLIuTjzxlFbWbo1+zGLLUXXRslZhVjMwpxcxOVgA5CQD1iH2+du06Ktw3ipBnMl/eM4CxnyKWp
+        pJ33cIAPRaKWFeZTwXyxNGByDqnlPSbM2fk8CuYngShnJedyMG8Bz12Sh23RMDklvxPBEmpywWKj
+        xgTm6KOj8mCuoMXnIHUUx4SlLaFI/ECw9N72RMEChXJiIjn6dK97GJdKHMePY2UPA/R2gO1gO0e5
+        xRL4rOaZAMINOhtIRZZToF4BWxvYLK1nLS6uavMyfGRpjyphYNVWZgzQrtaCXYKUFTUCVH28D+Iw
+        8JXkTlVyTWQYa5SeFor2h5qaBOd10hjw5Y0qbi7FYQBLUHUr4IcBfDmultLZk9PZtGmJOUebrKKj
+        oNxOTWontPe9dKMZrndqomB2e9YefDYsfa8bN3GwxUXHdftFtw22T9cEao7fUrBe4XvdKIlUv6Gg
+        sTTn5mKiFGxU9/7hKXjcu35wjJKkF5CyhrSfcjx82L063mHnFPb3YNNa6hU0SNI15sVTQjSmPgxg
+        KTxZZ8k2Zwf1v2QZLgUzw18x4QAMq9tgw6oVdAWZrb0AZiaE21xbmAMBbqEZq2XJ/IgIh3gPkzQi
+        /DpRPINBLv2eF7N8akLIJY80Kcn6hy79FltfMBMk7yDrC/lzNtcRMZ4O0SyKnbVLPvObRn95GG3d
+        t7dj4nb68tCJSe8oyaeoMGaXy6K53l+pscLcLIHWomC+9NcUJ7w07yecZFo1NWbt2x1DgSFhExab
+        25ZpTM+QYIhY055dWIqI+6Ym7YMTsWRjWl0r5YaMleZEPbp0u5EUm3FVFuCwZsyXkonOuHyREpr0
+        ndtlTJNuwtvGaKS5fBGY7qS9PaB4Gtu6vUp+T5h859er45Jn01oehIR0hl7UvDJfjZIaVVuR29nl
+        iwzmE5g3XnDcau9B8O7hJIU5nS5t83Cm+QnT/7UNNtHMw07oz9Lp/+YtOPrbNN88TxCoDzhF7VKp
+        AA5b1ZlcXdggdW9biGC8w60y7bx/1GJHS05WTWRYa0Rnh06wSmhLUAMf2GaP7W7NwYozpPBajUOa
+        RSFd6HmzCF2M1KsFLKMwaMKY2nxRQhsLsVGt+YIWhX46C1LbDEYkw1xVl5hok3+SOjlznvwJHNnd
+        i+qb40VFskrpfhcFASb7iwZp2CuR6pyKVbKcdPm5tE/1VR2im6DYk3EQPT+XtomeRvKJU92SuDz1
+        rWDyc5FEdd6w4iA7BpY6qEByBceBiYzIDjE5sGoRfEJikJ9L+0R/qbXOTse2kdHgQarisWqaPkuR
+        VRha3KxvdPKTalsi6hHfTEsuyhGJllolCK3FxVuiWiYiG8w7VuIkZWYKSMNkL9dhIrauL7cg69qJ
+        N7sknBEW9D0ykX/Rlsyk+LVlr2SwtVXBuom31HfkEKq4mOO3pRVIbz4pJXniUr7827+5D82+SPTZ
+        NAC89NEtabXbrOs6FhYLSAVbrkCJJiNjy3yt4Cq2zBdiVlyZcuUrvMcrj3Ouj5DDM2ahM4G9VsAz
+        eb938nXaFp+wFxDe0BJZpP7vxM9d6M+GcIYkJmgJcK5pm8O7sGWggntqcNvop6tV9AOt6fLHC/bo
+        T39bycRfh5RiHhsDtLkS9MgVP2cWCWGJRdscoVhigCzh+uS7v7Tsb7Q3ZW8kpVqWbdYC0gp9UPwM
+        tgo6arBj3DYo+QJojdMPJXtI6q+qwZ8Rd3YgiyP5otkzD9dZdMB4s0O6iXblOTC3gRlp+kIFuNkb
+        eBFRznHrBq/pq2tFQyUPyL69MA4qN8P4GK4D8CTZM+kRzNHUFlOHkU5xujj+RP7+iWjZn+pqWbjq
+        qujyxHhYqvuqZBl/VSq/hNI5m0eKVcAbJbVFR6U+r72VoMtVJZuk7bezb5THMKmzWDHM5BgG1oha
+        6ZVHZxOlVxTDCDCM0irTZRJQCzoOj0Rx6Hja3nlPf6FoTyiCaLdSELcIBF6NxxeTa6VXg23q48wH
+        iDB5CpCFDFu0YOv0QJIRElST/MI1F6dHfRlxoTWpL1qsWCg2dDT0lxIkKoRASv+74BH9O5hFITM8
+        1zJBhDdKCG+0oXYqTzru6ZhkfiLT1k14DM5KWnBh30RMthciqUQwWi7FYhE7jF1ukZgv0mOXgQS3
+        0GI5r1HGdJKquJ3zplIUMkNdSIUItL4etgph5bemAvlKKLn6YpY1mFvfns6yxgZ3imqGU5BSkhpq
+        1D4m28cljIY9BYm2qBAKe0mkh1TJ18rRBGeqnzWBAN0nuCcprBUum+4zGiyb6mCifWGueojizR4/
+        bE1RqHidKCLf7/hkeIjfXM8r9Y1Eh8Cnjew3O7x3Glsmt4jMdVgRbkjoCwwRcw6IeOEOKrlawwq8
+        Y/5c4MlZaTjuzMef0R3JiMLieklFMBVyjbUGv+fEOIK7ZZRIdoDJ3tmvHRFkTJBhNR7hzM+nVDxj
+        vNn5gRe8f5s1lkogWFt8yrBKahuJ2W9ygAKZD9xBJVeb5gFXatEz4UatPi/oX85+4EbNdMDP2Y+P
+        Cr68HYQCf1zgC1pP01mhq+GnCRvaDQ+kuRs56aHGtGGOmic8Zx2hnFYwgEc9ii0myhaXKQkoCXnW
+        4RC4ob51SBjg5K4x2njuNHgg2yYoVlCsAF4aFAdMiwOuIYNXp8EC5t+R5nmzQYm9JXyQuyjIBrmz
+        30o2uJCtW/CrgxE7YRBYUKlikMdgkIw9gk3INSWAsJPbr3Q/XHtd3PrUHd8P4jTQnDfU4iBMHlsr
+        lZDed/nXf0OhzxKAf+McXJT9ZnOB80Sjnjp009RMUa+SeqxOEjmWUFrpIbRSPhUCZtbIO7TqnT84
+        QW2i4vdobCKgSBSjPBSjZGyC92tgB1t5TtQa4VbJZ24LF9Drsb7AfCSe57c+I4Hjz0FPK59pAPbS
+        TCIqJk1P5SYZjMbDkktwAEEIyW0Yz8lsYX7DWFE0YNHl8nYbQ0BxMS0Ue9k1Khyl42h1bK+DTi5a
+        XRSrzfWCI202+WtUJ9q8USWdOBheATR8vIZ6LqdiQK20XGvHQQQW36OCTAt4/qig6Rwa6E5KYhSx
+        ZehLQG+QNvPDJ7E+9hnhoUCUBGLimezY5TSAZBh+FuAYsesnIldBKAfC2PW/AU0TeVuM3mt7FFam
+        6dU0CQ7YR0xOWufYDCJwbfDJaAlU14JDSoIGJEFnWHy8Ly/uXaTMx+3+EkoTkik67aMpdr6gIB0s
+        pOeaNqYJVJ3SvCKLuWWxrfc6VJyj900zAAKXPrZ2z2gXvsIiRGPB75BBZ5hrqk1hsc4yowiGoE9L
+        SlMOEEfeqOqDgTPQ6kj3gWBWZ77TAzog79kFsfbh7l30YaJ45/of0G4KbC/gCdRQM4uLWcqqZ56R
+        3HHPRAc2O2mB2ubCNGy7yh3DG1RyteVClnCySxKY0q2RWDe7DPrZWdr0pWEgojpOLv6854HyThJ5
+        E6MBz5y/SsaZFHdQydXm0plD5ECWqbcg3GsX3Ua2rUm30TMo9G2/ecc+DpOMHpTEd6AME+6uVnqz
+        jE+8fo2wE252ZSriyicv+nwsfDIEnfKofJK0HGyVUQzNYEk7cl5hi8o/BKewJkcFdzykEskZJgKM
+        8X4kE76I5Rz9cnQ3H2SnEHbUjInSu7rib/W+IJ0Cb+MnSZ+ANorjMVAkLDtdMYgI9Ihsyz4U/o+L
+        v2W2Az+oBDEMfstcLlYV6PPGFF/scL0YMvYtSr4ka4HjD+q4EdukcD/7AMey4xyC4u9rxwnFtNC1
+        Ozw4h2D7P6wD4Sz6iSdBeRCUByHHKucf6GRwtgXKzO9tyYfBhXTbgrVKU5gNBrN0lefbYwq9sRnZ
+        t/DmNtZqozxUSSRQwZWnwmsQeNVQnAq54WtNAatTuZj6k0BRa1Nh1StWNa1MhdqANaVzjGFpamq/
+        0LkUhofdLPkTnSz05gBDq1cgkSNPrUIJkInLG1N8sVZ9Qmjo55vjRVwyH5yQDMKe0E11A0YLH3gR
+        y2REGdBJLD0Iabal7YiRLqxhOC2kj17sEuI43rU0aRnQhH6hs4kTJNmVlBnq7q/V5u8q0wO1BDMs
+        jQ+ivyK8Cfzt+clz+C2vzjo44VdjHhF+I3M4OV72FFP4IavcM4wKvj/hMMZfr46LLqROfeZR1YGB
+        bhdut9hruTqzAF7X82NOeBMHZMbur/Rx9zu6/Lq08YLjVnsPgncPJzHl6VQRWZ3O5wMnjM5rlYed
+        0J/lZ56xa3W7gcvkooKuA5cHJYztxi7mPIl84K0mSKFPWJb5x4QBbt5UJT+/I6ygZEjJkJKh6z+W
+        ypAfkUURz/7+iX3yx9+RZf4Ac3tpEMMyffozB2CRjRago2T6ogS7BCPXf8Mh9jd4FhEWx6FH1vOM
+        WWebY0guxb+hn3Bm4BKaYN/U5uj3ZFxIqYP+4kfEJNjArG8a57B6NCIJ0sjohEYW85Z+abRUNLqn
+        0dpzNh+IbLBpCCHtqDv704//5/9qBoo2Ox9XFOU7uF/YS5QSncFLbTol6vP1GlZRRrPzO8nK2Q7F
+        ko/hLLDgZSZ5QDS7TieqWAS2GB8ijD/oSvcH8vtn+vsfBvqDG8Wu56EfPWfvoKUOWyEsbQkp1MBB
+        A8fO1onvq42l3xnEyUr4/LfU5fLkkS/D2ycnevr/dPK6mfHTU2pZkL9ix9Oevo+i456MmOuzuf4U
+        HcgXPBEme0q+eZZiql3J8t8mwpOfb4fyA8NuBYMuDWeroW9qIqf3i1x+ugMCjq4byNDmMOReOsXN
+        WPWKGzvZwaFmw0Bbdgua3Sto7GSHBhp8A9Tt6mbpvcLGqVI0MOCWwLWtU9TsflHrcWNIKYY8anXM
+        UtvDIsb8SnDbw25IWjZDFv0akP1pRg5YFjX0xdBSotUTWjb6eUO+ExnLH5Cx+KMYajVNRmEbmz2e
+        7JJgaekw2pvnttoncjM6oRMxi8D+vK5Y3NDMflmcnWyHiEWxs3bJ1L4RzOhvD6Ot+/Z2TCKOvjy0
+        diJMdkXlsWJnF41yCqWDBJ1ChDauo9FSx3FIqO47fpBU6jwB2wdNr9pbTiDEowaK47G49H4Bkxty
+        0jAycptaYWcLQOE8Lj0tZOmwKsEt0BOUfNgqPdmWQ30Wz2tWGy9g1uvybNNlLj+3dFc/r8Cd1p12
+        3MpTb0CvcYM3qORqDYXF7egrgHetMKrD9q2ynBCh6P5APpog12UX8laLPzI8ikzdtMmiSSxzxa79
+        s2vhPYpbE27du74rwqdzgSR+QLw4iE9BRsliPs81Vii+KMiltsb2fG+HkSqhSrWL/oLYhp5bfAjx
+        JjHvX8m+M5kdGTtHho7M5e0cIUUaAHoI0kF9JOimYeZcLdS5mijlgBrVdvpYV0CItprVWLiqDBLP
+        QqFW0I4YWlhSVRppXBIQnEK+dmLCCtEF9cHbf2dzJ4JgmhBhUTXwhgjJDVYdZxjvuy4Xkxe0E6Bb
+        8dBswpXPLnuMkM3sJwHOr1FMOH3fIKtG2deVegAldphuIQPW7UipBKUSlEqYqkqwhHbbzF67ZPTr
+        m4e/nnmtUctuOoRuELoxbcG8ygezAhPBueop+xzWCcAde/MVVs6oHaQuq1v4j6/FMlqxPgb+4Bti
+        GYlbgmMNN1R6dHazDZFED6fnhbwx5ZcfSG9OzVsOU3H0wJqMeCUUDmtqwswwspGxaKIUG5SrGK0e
+        UXKu5Hw8ck6DeRH5sHPpWLCo54sslyTLCeyYRmFjCO2XWEOgartU4PGuVigQnZEqBc6F65QeQmNw
+        dlQDPsMc4mbpXnVkBsMCmUIGg9IiSosoLfLIWmQMUQ5D2GaUxDm0bigP2QguqeiVcVe2NBnIEopS
+        VIymGA3OaNBDZXZZrrBjWLNnkJwlZMesBO2Ydtyoyjcycd9Iqc1xPfldIANe4VrJrZJbJbfsmM7k
+        1hbeK5j5c1PAMa2hWUK33Zz61bYYy85pYYbo7WdM6nwlb4+WntSaucLUlWe1BSc4Slo7OIGwb7do
+        oseNHPlWezTFsx3xbO2jM5mxPPcm5+AZXNjkFIkzLJAJ5fJWLu8Bubx52qPm6ZlSJEqRKEXyqIpk
+        4ya1pzTvUtDN1ufXMkogt5ah6QvWs8OV942U9DO7RNTZa8KZovmZ5KtafH5+akHobLJKP04Yu2/u
+        xnU8RNsvEJ56T0r+3PcZuPtfKLMfZTWayrMW53yBhdpEL/r63PJNCHCQa2DwYFc3fJsI0LTun6BI
+        LzVIrafhY5yfx0RRJgahc8Lk9R/IWK5pz3B8rYX3dlh1ivrcMBXq3aAeZVUiCeQL3JOMvyi020P7
+        y3G19zD4QBYIVFDZjmpIB9C/M1/VYJqwwvt+guJRR4Gt+SjY5g8bS+RWgioeALbVReUngyxcdCFF
+        hscBb86tNUV47S7XWsgWiTuo5Kpaa29g3QQ7HCZfvXf8LfKcGAPFltBlMQlfB2cilQgnLTRnuYaZ
+        l+Kt/aDn0Eor9KSjWwDNOaCFtgIQAODBO0ZKBkcEYdqWYkNm+47xF2xpvK+Wz8UreWwFZLxKcx1W
+        12Zq/pcQuIJs+73TJdk4JJFBtcuRJJB2RfRIp9AhPWz9hS0umpf73JDCazLpcemDtUmayJ7MpA/G
+        AzKLgCaD0VHIF/po+gpORkoLxZMyiakYswktT5ZmfLdYGmuU2EZdEtFYWCu7cqfOG1RytXNKvh9i
+        FETRd4ap90HDAbiw5NFQkbA2CanTKPS9vfk6RwkZ6ZuVRoQTMPkT1khq2GY0nGLFZECEbuQtQYg7
+        FcUBbyxSunxnWLDeWMMmiAwW+W4JbBP2CKRQlEj+hMVUDHtTI4MMwFapUyGEjJXX6lqf9E61ElKs
+        FCWyhsQToEPHXpKMcGh5bU0Ob948bEp2ppEKaNjp7gCyoWq1c5A8MnpO+H4TPm3a+rJLSvKaoY2M
+        Ha8t2XuUaggdW208J5OSfarHCYh2EG4ceDTmsDc+MtwDv3xi30oPJr6zV324MUGts7mDSq52zlcn
+        d3P0Oz3MNnW7ShY5QwqvyWGqve8i+qgw6VB6aXjIZqLXpwwkVRyipgpPZniHMtcZySCKQMzTIxEk
+        CR9Nk+EfljDJN2vZqRJKTuaM72A1BY1cYS8eVdZ4GwabD3K7f8JhhEcQk8yGzNeLb2u3NFAZiiIg
+        LslcV9ODkE1qGRuEkfOG349OuE1EcuDi2OKOsFAU+YUqYCSFUrQv2WiRnrl8VUF6huTBOJw5frwL
+        g4O7mW0857jFyEI7x/04lpI1reOS9dO8tZ2Laj2AGPr6VSzpbwzPhvXqDM1kMyDrKJTGJVPKANDm
+        iGgrH8PMPFACUSFl6xRKapGpOTlEZ2I6UeRGMaEWmRl+cz2vhPB0I0Jn+3qMyvBpF/CbAcndR7q2
+        pLKZlfu56pL5iwB7LCHscSuid5u1wbBR9+low2AliDEyHHYLDseoIpWxkNXSmnEbMuGENJy6cYa2
+        WrIwlVeaM8B9msANr+WxtMUpYlF8UbhExUAZWmqR1aFxfoWTvBXeL7zr1VkHJ/xq7MJMYyu5UXIz
+        NLlJjZP21gwrrbW9EBYbwkcf1yktcwJRLkCsH6KsED/vfez+F2iHcUukFj2/urQo704z3RNJE/m0
+        VGqVzC/KsmRzF6di/E1U5rO1ksmnr5blRX47LqXQMLTr5kiWME6pI8XO7bMztwT26NkZpp5b3p0r
+        jm7O0Za9EDbKWBXdgVkGNagGbRC1bmGCbMYu5J47quyyMs0GvZYlpzl1bDPOUUmFiwHYAalz24w7
+        SN6ZUuGBkuJnID+XrGTrbzHeOrQo3NFFsRNGiCgQBMw9Yzmymf6EpEzXiZqre+Cbq/t0nYrmuDPn
+        4NJmHvQ1XlRMRxjaRfCcSyrc1KmA5mAbSeswafD0HPBuaquiA3mwIDYlOzpZSLdMWHUtRf4WyA8M
+        qWdFmWvTpovtzo2zG6riV+CKbAAlSArRElkzh7MYwhmF8AgsoyrP0dVcktwyKT5hddRD8QnCXwel
+        T6bDJ4WtTJswSghbcoC9m2+ZRLqFYPVrIRgvMjZqY1QmoYH0uQnr36PYRMp+fvhs8h4E7x6ttZ72
+        vdZ09OY50Q7pOqNRtphMd5P6ibZOnJDT1M0FLaJtGc/FvOIct25wjcOAu4fqM1P6Sg/77/HudUd2
+        yAlLaGz2XzqMvjYlPn0vy5bUFR7dj7HybqSck9VezZc1+Jd2iYzcX/Hrfp28CMre5Boly3nOnIkk
+        l5mJGO2stQlV09vkiMYg210Wi9A8FaFSPVtLKECdXZRQ9CgUZu6wR4nFVSwIjeULBeeAQsnF0OTC
+        KDzse2ypsKhMkP/HJxd/PnOO5opO2di9vuiZMrt61znZzudzlTgmah3esx2iuDeKd4ofsx6gHvZ5
+        TUXAu7dzTZC02JxXjeSyg6GxHbX59145ItclJZVVvH3F/vYQuGmxAKavPD0vo9OZXStZRDdTu44p
+        v5x8RVWb+8r+9syD09Ac5h8TlmT/MUGu6vUZ/Sq/ouwxZyWesLOkvTBh6KrHSd0v97loUPmrmmzR
+        kfplwCdev0bYCTc7wfUn3e3XWIHmjPO41JZjNTPQ66QU+HAU+EWMCmPyymo33I4LD/vnNODmlpNz
+        cQw01T9hVm2LT5c+VWfG5UQsKK3egla/mOaFxxYiet0JyRjsqbWAO+oYerTuRIKNzLXgZlCcyN4q
+        CXYrXCLCb4cdnu2/xbuAqBDkmQha+/2czVjfCpflwed9SQ33+J4GS4WzT+ycki+HHLEtGjokriRo
+        GJHI+ZI6JMCxg25qNBOjYamvxXoPzbUXOaU/GnLFMvcddQhCFiDyUee/0R4ayjFvZt9wqvcBgl45
+        g0quCkuZzm7uR3T2lRXpddwZsTDSer3m3ChH85IbAfFMysUbUuWy1SK0Muqo5aAWCIcoXQ05fTN5
+        SFOhTaG21nLR7jzKuOXGTOyEBoU2TKyvYK8kg92DaLdcwDY/pVEDbthyEWcd7qPHu7By3JjQvi2y
+        LxPtiUq3dDutH7yXgrsPQ2sWOSFvT1pYxrSO0XrH/iBCrOTsS5sXMrCLzoOb0CHaEwZGlmYg0xbl
+        EDn80ZQwrbDHmSymIktKlmtHEUFyLGQVMG28ESu21QRIEgR+tAtiQpMPd++iD5OfHdww0Vdq9voQ
+        llL2OKMqA5NL54YLcWtni0XMktZeTroV08q08TFcl8dyFRseNWXG1l/mDVArdFPBBYZHA2QsPkB0
+        aFZZ9S5FxmpABjaiphkZYDmmbInCfoyvRXOT43bmbI6nlAo/LJM2rPRhL6uPo1tttsTam52dGcL9
+        yYMOFrxnOE7TKSkrtNTEnQFwnaEVhH0pvqvHd77jByJ8lwaGAsqNy/WZ9895hTkxiu+E+Q5mXuYT
+        LprxEKSdR4sdxgvj5FtmoLYwzNq3zZFhgeCcFpjFNc5GCeecU9Wnqty4CbR8G2fx1ME+qTdQttNq
+        5HHnY187OvDyb23G/MmNr7jnHUK/r3Ewj7nklPHNMU/LjUsU+9yyj2bWYaAlmIEaRi0OkYGKDlke
+        lYWU7lG6p97SJep3Ae9/m3bEGyDvFPjZH5Z3RH0nlCFeqjmHZbDR802B6+RR+aaiPCAvlEkZQzWM
+        oSGFqUvZo1NDuar27pi4ZwAb+W55pz2+qCq/IhINq7E24uhVRNLF2Lhz/7cbItmfkqDdswXakLMV
+        aNvPbGj9UFqkgjqPcE2ZpIZPt/Pu9Xy+gbKN3NqyvTNNLhlGjGkek2cCoRiZfKOc0pCybnuTGoB+
+        OA3YqzA4SR0ciyxugcXx1RRykdQWNCA7tdXsTFsrDO4bgJqRmc15jzbaue/lxTYV5KOH/JdP7Cd/
+        JIUk6VFQiCzR+H3JpqxlLXOFFXNGCWdM8UXxGhfN0wCulD156OAdI5h5p0mN3eKUqMxF9bfXU2kh
+        kpdVe426ENpK+RdIZ+mJp9U1I3iDSq4KUvsln7xSYUznKFcfqQIVB8DMtOZr5NCcIXOuL0HgLRMh
+        keemH0Dyi+g+qJiADRetGgru9hNiYu9+kDfAwTTkarwhgJmr51EHzHtKNkRV7oFK9OnGm11SEG6W
+        gQLKkpV7KjuEWh5W3lCswJpDu2ZgHP2t+zKfhXi/R5GHw0NPdcUWTRPppdQV+0LUOxQGHwI5VPJO
+        5OYLQLtU3qCSq82DYys48pZkvagZ3ihw3dVfk6/39vmG8l1k5Zi6WV0rjGqZEh9X7qow4nnBqYD8
+        jmhNd7n91Bi7ncJ3+MvZxLDEBltyaNAgGCDXeksA/zPxxskGX64T7GnxgX2ATiagQcxlt8TsIArj
+        rnKVDat7e+saPALgfmz7pq+UI/32Uush3HHv2QIxY6kP7EYaYFsWdgkpX4vzLd6HyDu6uZxXGdML
+        u0SN5S4Om3eaxxkU9auDsJmAoloCFZVg55E+WQ1wLpgrbVOn7s0oWa2IffLVcaHtsDW241OxvmKj
+        jAfMRBxdpPRVmb6iBfgpZV+PEa7BbHMQs7EO/2JWY48MqwIl5fqOXhYLnT32aOWIsbKKEY/Sw2M/
+        uKlV9CgR9rv56RyBGzsdwHWS17CS+t/QwJV+4YVHn1TqIVivonzlLAALvIUYVoaxBxYo54CpMgAA
+        tHWw/bY+uh70QLZT7JqEPN/P/bTbeMFxO/sDxoefaTPwfxjoD2RbQLYD6Mekq8NS/wFEgEXOTONO
+        MXsh4Gykb7dUfkL5tfDSV4gshVoyMY3MUPNxPKOv86K7LuvbjLBeRtjGsZ/dxnGeeSXlC1pPdfUD
+        +ov0uqHj4ZDqQ+9q/ji3TjFoKfpL1FJjvpCN+U+02UsG/KtBlYIY8ko7cNG/9tBJWOCufw6QB0ry
+        SFgmAFbl5pi2XDawFBu0wQZWLTboUBWcq61fsUcnXYMVcpK5AphLSHIYZ1DJ1R5WAE71ekJPbifD
+        gSD/P3gfXLE3bXCkFKjcPhB9A5L/yRtUcrV53f4G+PuUqu4dVQfLAT/f1I6/UQPmXIcFMbCnl43U
+        AIQRWi5ukQ+4bsAIWWF+ZN4V5k+J2yNHCO6qryxzrqvPLBgw738+BrsBr/BOZVo5uRGIKK/FKBeS
+        3q8ZRgtGI4xBSmzGv39inyZn/D5LzhA0GVcyTcbeGSA/mzoMQGNtTcTNdxkwA/zrR7QURf8FFl09
+        EvTzs2mC/onYjIOBvubq8PckapwoBZgukGc29M4LppSl4JeMfiN1JQpXnZDIAUNwH+SqW9VggToF
+        KBoVH2lhiRCtImFPiw04PTYbMMKI+cDznJODToa2QDdukd0biCnyoa7jXh9yLcnrHS8Qgvr4K74h
+        6Cgthb2zXzuJxXtxP4I3kYZMzhhGlowM5siRdD20TeTB8fYzShS0dqOEQSBg52r08tCmj26efd5q
+        m4DcPPIgp7i+B8G7h7VNsJ+dcBjjNCUK+zh0YveE6f/aBhuiDbAT+hn6v3kLjv42jYtM/+W5jPRI
+        16Gypsgvi/y01OhQOd/QzeI8DObamfTB/uBhOuXxATBM/n80ECLnDcffUPAGswgVFu1jEeKNGyd3
+        KVj6gSWr0kST888Zx8UY/HLE4bfntKypXQnA5dHPHDJlb6v4msrysrdf9NLCF+GQgPnlxt9m1NLN
+        oixEO15boPj967uqnA6cLMZWMh2LmTYp/FBNqbtYFGi+13TolJ7sFtIppZGZUKmyvHYrFOJYwB0a
+        ySDy0EhRYTaCVOSDs9EASq0YMEKtBOkEKQM2KjolE6qmE7FAnBDtju8YGebqAwW+5/pMmsUWH4h1
+        ki6dZAVNPsPUzTnSTWSatx9T0k1DHhOaSwBxeYNKrgoSdw5jwpS4nhOeqZvXbY1p+6gCnqNtK5wr
+        l7oD4Fwh6qYRVG1x7mOr3BvatsK5cqk7AM4tpS4n+BdsQ1YdgI7KhiyhECfYTdHojkaHg/el9iAV
+        tOFpK4Y6If7liM+lHu6K0BVlfVZWhJgSEQX5S5rsAbx8nCGF19qQPcVeTWiYWBY9uAXab5d6V9Uu
+        8U6ScT71oucdoNfZ84ZH7q/4NWtpQPjCuGHpwuFe8JlntsLRe7x1j/vshtVl/H9vpwCrb8lCi2gW
+        NAoxzz99Pj3gG06Ati/ssCGyxCWc6upQZr66MGC8TSYCsUUDJpqXMxEkyEyQ0dLXw9cpttT1uL3V
+        RvkqfkeiVtYreWIIyekqldSmAVYASladbBXJeiPSgMrPlSmxxkmPuQLNUtc1W0glLQRVkiF1WbtV
+        YNOyXXIVmXvEWLbt0sKyc3kkWCeMwWrpxAbpV+Bb4IXUQdrPTrl3CwSy0csopAwQYUIe1567SZtw
+        RBGNFnLILfExEj41BjgWsncNOkb3fhr5qKuD58RvQbjXzrPRNkESYdU4xL0ycL0QKuFICIVVV1g5
+        bkQe5ZC78OzPeL930M9//B79+Jf//T/oZCOT1i/4p4JMImQ100cvgP3w8+/Rj/+cRQ49o/S3oXNX
+        RIc+JULG4qNbzCBrsAJt9v2Pf/ke2TfK8PXvq1ddideAkKKhtrSh7v/29gEtSyZYu0EaTLwO7gqn
+        u0Mo6luPZ29OFCOek13AFs6Ic87h408ityXiDUo/qmQApOlmfpJkDpOfY8l5yZSm6WxPjr/B27Lz
+        oUnMN+tMTjP055o5gAlC/B5N5mgMbI6Fm4MGk0y6zE90no4f78Lg4G5mG885bjEKDmTvaqPFg813
+        /ijzJW/wcfxIM9457sdxwhNOkw1n75iqKWK+U7uJrGsnF38+yIyTJmUPNWdaZi93AjXhuXLa0E1m
+        tl+XtsbIQMnOzg/8oiPnycy6PCpw5NPkOZppBcQ7P3NSIbVjP7PysIh6wv65c/2OHcsKpLJS1OyO
+        FgQklTWF5JiQpAVPtbTqaVr92F7pa+RY8zU6Gd/Bzg9MDZJktsbbMNh80NCSEw4jXBWXtwCEDEhp
+        yVgRs9gQIwn9zW8wMikwjmmuafn6Zf8QARqMt5trucq3CugdpKyMeCJHAmIE62k6QozYoPD+EaIl
+        3vvFBZan3GZo2fBQScqqpssPrGxxO8hAGqC0mB+X77pdB5noWxTj/eseR5HzjqMKyp+868oCovwc
+        1EZkZJQ3tcWiNdLzRhaX6c2tJlQ2YMj0tIaMVCLEzeqcee98Rpqzd34N/KQSXUbc2SF0N+SLZvfl
+        00K8CZ23eJb9fQIcXmZDed4Yd0+m8nqueFdeXy8Zm+5WTLN0Qp+fn1r2Ui0rofebbDacHQvevl5K
+        I5On/L/LgGTQ7GTMkjdHs+tnZiX36H//LqWO1Qd17MES50B3jzFO+hteaqUZ0MUSoBgurxh09nOu
+        PCTQ1CgmIDy9QFGxgIpLYKuJBchmGwcJTW2ZS+xqTEWBZFtFyjJSAi1ZQL7QWEgoW6QFeFGRsYCM
+        Vk+ase8iL3LF2RLP81HkLCPnqnvtuNJXVWLNGVJ4rW+xFs0RVKS8I2VaqI/soPj9utmoXrXs1CUq
+        uKuTomURLfntgYFkhThKx0HWXAEuYaLehnvDtttpMwhIZSeDKaMCp3MBGeo4GS8NFQTuufMCt+m5
+        LO8nxofsBjGRhpJsQ/oi0CwNUjGqddgApyVXJs5FPtvaPI1+BnuQIPwMKZau+FmsPx6h3f5AaO1s
+        dgXxMFeY3fUevYeOT8g+y/5GliZu91lAUcgvWsMXhRvtYAPr9GhKn/fH/0RduUFqVFSOSnEB4R/Y
+        nNythurPrhiXLwHJ3iGPYSBhDnXkJjAE6KaBKafVoF3unjFQD0g4tsBeWURM2bg82dg7hk+0VFWL
+        sB27KkHjiZS+lmF/z2gQyIwN/rzsQmkUKHDdXdhAIA1NZ8Nghm+J5I3yLAUTbKOBbJKcLlFc3q1V
+        TisbRBh/JL0dz7/ZOJFCXWaDjc/80MZIc/w5vPj1BscK3UuZpS2VnE1RzjhIKyfHg8AsItD5g8mS
+        dJqlkup+4ebUMIBZj2CMTYVwG7sArs9ZLbwDBLCpiN7u04EnjFDpZNMZFbRSZPMeMeQ7PkypsqHE
+        ZZ7Q3h0rtX1NmoCPE+6hGISDYtKsPIczMhs4MklG5pWnKz3jgjAypGuFYmNhNgYVNmp8QJkfqeCT
+        rYVozIkBDToxcrUAiqBbgsohDEsXFXg+gTbiQluyUy7ma92Qvr4WFXavbArCG1R8tQ4K0o/arpXG
+        QNAsc+mt5dFSve/OmrNtCAydFPAuCZ/dSo8v6dC/L41lQ8f/QNh/99xoh05E8ktxOTekot2Dbr+r
+        dn2nTbDDYTtBr8m3XkeYus1WiKoKi02pAywAVUpXS9FVJl33Ry92qY46Op5i2laJqzhXKnEJPcvj
+        3hU9YfT0yQRd59V397P0J/kLpY/7xUHn7Bd7XRUacENvGdS+fha/dqq86WZZaK8mup24QSZcnjg1
+        vgnTR9A6KvcT1yY6cWqr7Z0PHCbJhog24byWBkGiNT+q53F5Xz+ZR8H+4OGq2iyNaYXepkEteD3S
+        GnSCpqkPnkod8BRNRldcBaKUYio4qR6eo/Zrxw9OzuwPGB9+po6if8BTl6vclZenV9AEUkyaN6b4
+        oiBZlmyaba4G2cYLjlvtMiFah+zgOX50rjn3XE1W9AdiI7ueh35MuG+p/wAi9BLgNocSGlYCtd3S
+        tEYu76UFav/LQrplwpzBbKDOqDnZzp2Q1aAuz7fZbYnaK6SpsNjoJ+eEyed9IGP5AzLM1R/FOnku
+        QNVTe5Ujsk5tndi5m05yxQ/ixJn8/KcgfErPEZ8oX3jRb5/SWoZPToif0tKiMd4+xcHTwrbMp+Sr
+        n9JXPjn+Nhm2JiqIjHHIBcJTT84+OPrxtQDifxuJdq58ew/MBw0Rgx2jFheMzfPozxtCmZRBF4L8
+        CQnUgHKn5MJJ4+dLdgkdF1cWMN1P1K79MXPNGMjW54LNjWVacJCO4a2WVmePFqcI8UoQYEjh1NEA
+        zIZSTA9gExmCANuA8lGjAXjFTEberoChsiVIZfbDmlC552pSudI/LRGZ1o4UpDIkl31c29xcBf2J
+        aaw/H51wS6sywvwYUvdffSsrdjLy5Ojvn3+nPd3AFtxkSJordSeRpNg30fe0xA7teyhsJMsice+u
+        X1035OujfIGjEhgsMG8PeENcw7Dp23KV6JC78bGygdDlnkw53tKG2ZZ5/yicsSTG89ZrI9mKdiyO
+        +a8wiGTZXQpROYj6weeb53zgS10BxM9X5pLnfHOVldBNu7ALvegh8DEmaB8jvlq6TLow0L3JdCEK
+        SuZ0S/vGXuf6jvf0AHEtb6Itwlowh/9QtkaGNkeeEyZ9oCRNxZwvepxMPmNxnHPh11sd21ySOI+i
+        Fj9NJgMw5duYCqezybikPpsF2wpjjJNIz1wkTqTVXpxVU5HKV73ORCZv9TgRExlTmQgbOT3SiUhW
+        vn3M5NqjRKaN3Ns0JFuOfc8E0Jh22Mx1bdoyalBC/OGgTRCOm7WSWXCKcDRiK13vfB6XX8gJN7G7
+        GbMRf52Ldxu4M2prOD+nse5SYmftkg/9Nou2FuDzz8N5HsWafbAXdyFMqVdIZj/ruymCl89pTBTF
+        x3Ad9DNdu8vZ7vHWPe77majVJa4CvsOxs/B5qo/CxNST+hhsTH55GCW3oqNHDOh+ZrzqasJkcXfI
+        E6XMknBI6Qn8zfz0JojS9wCmRl/fy9yaSCZwbgTgSI6iHRhoESbbih1y/C2ipaeczfRnuQm8IJzi
+        LEO8D04YrZ3Nx3sYHP3tNCeZcOnNLDNYPfd9173uabJwQJn3A8cbiBdjdFimZ6xHkKdphJP75k13
+        YoiYan70hrtXpB1I3JsTda9JOGUXZc9rQ6PhwxOxVU+dc2YHRtomxL1MjdOhXL7M3eyTgL75NjaG
+        HW2TNOrIOe/5T8Z3evV013gbBpu7ClgcZ+pyyVwvuNJwN1kyq8nNieXMEc7NLp/brdpEx0O0cbw2
+        Z1lTDVVNIlOOw53AonwCdFEe7sfrVvnXn50jA/zyCrqfJduPw8BD6WZkgLNYCs3ivPEY60QSfxQK
+        1v/BmyGyFGgOmSt0rJ+f87aMdSKZcyxzjI1+Fql7aKyzSPbW70fygeObwr1jYIDfL2TDAvJoRmTD
+        3pywjc9AN8QmNy7k8pPzt064nRm6aaMvRP+abR3PQxgxYTlM5uDB/cLeM+1hsjLsxQugbEfa9qip
+        f+D83lxxTXYmyxdTbCa2Zs2HNA8ygVqIDGMenut/HA/ZWVjpd9/2BJivqtLQ0+fyvjp7VfFXIJq2
+        CP2U+Woh91Ni5+R630QJUgVi+tRa34Cc7cnxN3gL/RijKu9X8GPwV4zWbpQU/Cv+gM3OCZ1NnLwh
+        33mQ9xlJAbyvV8dNKhGjtEpe86oFZQ0g2GtCZZVvZ8jOryhROW0BqJEXzNLp0v5TZ4klGwXajSrY
+        RDOPEN6fpST4zRvdOCQS/ZoRpQAQy/xogElRhTTN7BE9qkeL0GOvSUOvpF7RYID+na6Xd5ZQYE8E
+        bIJ0ebnxwajaXvDrDZQm4qdAkQzK9ZPJzy1OMsZml1/ItPXyDldnqa9uYlD4OjnpTUYRVuy1ui0g
+        SlGixNeyhDtaS2XjHNJttIujhJw324uZOAyeE2M2akIB0QYQeL/G263rvyNdZ0r8b/EhxJtUnra0
+        iSh5rambC6QbyLBvP75SpQGKTkEK7F413/WzQeqvhm1/eQMIpfyYE97EQfgaub/Sx92XvpGp9Sow
+        LddmCqmhIMXNICs0vtmSmbyBr2sn3uySovKLHLRAhxHXkBBVeGL4aByECifGHX2Pp6UvzXLCR3vH
+        80CENwECcvN1xsMS3ZhbizKiO1sHVRnGIupmuFSsRZeqZpBFpKngx+kqgTKapjFy+OuAdIuQa2Tr
+        YY1sbLnroXVfYLKzBZHYnicXfyLd1l9AwrBI/TAvIHl4DfEvR7ILOIvFS1v4WSV10dlrw7ZnuIUy
+        Lx6IrBmgXiFg8F0bSBFBakqyWzj+hYz216kA9VQpNaRuY6dAkPSI/eEJctuj/nazJuop7HtxeqzN
+        WgFsMhYqteRIdPEefXcThOWnzrfiMQcDMQ5/+2W3mnQQhDTyahuKypMpBUcXcFz1yDvefASliAxv
+        sXlwtcaAd7caKSSngmSNM3yF5pDQVACOH8DyOFwF4JAADN5xvMMhuRmZhmaskc2W+i5AhO0kxY0c
+        yJ7+yo+jFmpaVfjZNv1qttB6yQFURx9tln90QusVW5q04LNfuvvsl9LPXtGvNoEcAmmyWPTV97sH
+        nedIEmqPWDyjBAjDACKR7yrfIhbZywq//armjLmxR3GArLm+B85jATjMqpiH6JkUYCLHA52GAZ3G
+        CuAH6mIS5NmztUP/eKdJqBFG2EcnQ4PFwjWZRX41mxvNF6zqk1iyZBVS4ofvv/+LogRl7JSdbaBu
+        6U7LG4U6keJHm2OmjUq1OVqa1y6l6J+wiq+CX1mnxd2BGJGeh71eWhAXE0vRCkQrC5nW/Af0vXnL
+        XOZcXyLKr62bcpyTmAUbrCooUYvKjsGfn5/a+YNopGlqjs9+OZNjjRzTXF+anaXkeDuspo3+P3eu
+        /0FXfjpdEPALUJC/APS5XnA1DEwp0Md3tJg07ISv+xJ1m20bUkPSy1MwgHBfaABE+s3xImGoC2+6
+        RzAZBoHw9/T4HtkrnQBJ0bxo7z/9bQUGs+7+qQXhZT9HEM3NmRwEUwrspVXlVKT30sqW/L502/4H
+        7DSSVYzNoAa1kaJRE4XhKLmLgryyZHllgsAifW4KqOa55MU4D7KoPGvGS12RvmnbnJFhFwbH952A
+        jh4n7P8q99hfnUYmpL05HO3FfG611fUK5F/LzWeK2Gowbc3aNbXdtU1F2NByilZYgk8WMvqR2fum
+        6Q0R3ePYSVuZzX7MGpqZyFJOBkGa0SZw5UQr8kdqXR5z5V72CDigP4UYGNHcDQz6ZAGw0U/OCYfu
+        5gMZyx8QUdR/rLF/S7RzZyKRK3gwMUR+3pC5p3AsrmgAzbEOldNcYw+hp4LET/Tnj7ctUGstFZbW
+        xDYWdTnmXjZRNNS6PSAwVrWw6FRN5V82bizSwiTk109Zc/bbE8aTzm7tHt72z9HrZ1qcAJn2/Tnj
+        eMlWkxhfCTFWX+Xs04JnoOnhyqi5MSCP3AUx+flXd++iv5qCBl6HBkVdj8sHndiHOb2DjzQ7dvZ+
+        iFEQRWSzBI4QHJhHvPZ55d3UJworFFVI6Y8uTzmaYjolSM+/aTrhMcbhjJ5RZ1arvS5QudNc8n91
+        XBSE77M///gTsrU5+t4NhQ7mB6S2DI1d/uBM7u2RjebIccPJMPk9sovW7TZesQI2cIZ7/s4ZVHJV
+        +HS3drxGyhSLCRwK3bMCLGjOlh00NwRmaMYKPUXYyT0fzO0wgIH2bYdQ8riBN0hiIFcuM0d4DzNv
+        yhF55HijTm7kJk0doExSZ4OJ9BdgJeYmu0xuILVhc4s9dLUTTSY+bDPtJp7yf2gNjjSa8gdB74Bs
+        ld4UOSN/KCEWTOmntKChlBOMpCwC/RwBr0C/RsCPG/Q4QvAaBikBq4r2FDejco5bN3iNDhhvdhyy
+        VXcETx4wyx5wufzv/JTQrrwV0u2srOHPyfkkfBJ4XtLPPekpBp6dDVgyL4/vcoKlYki+SHP2zq+B
+        n9QQSOeeVaVkSttfaePjYyhQICfNK65CfiK08QL/Hb0FYXmu8i15aMsy3XgM6lwrU0jVGqOmzvEy
+        0g9ODqLz4zQALXHnVPmgs1aa5Gb/hMMIV1Y+AWzjjbJdfO6i8LbNlnHkt31Lp1Y2Jgz2B/IFzmYn
+        yxC428mVAb13N2EAR9oC9RsQxBqUP9Mq1oYcrJvhWAbTIcR7l9ssuTAYEhL0JQqU3rtUZpkR8z7E
+        sjBjsQW5PIhIJSSMaXT618p71Keif32avnVwN9rGI8s6Rhaao53jfhyRqZu2oZsmB3v6efh1E+K0
+        ZtYNXgntOP6y9A5yw5Y3egWrbybAWzI88y0mVbF7owtYThS5dKdFhof4zU1axhQBO3zWq/AB8Pgv
+        5T16MEn4b04E16jHf5q1ZFedch5Mj1JBXUkhzmBBHQdiyIVdouNyF4Vj16t9VIwR76xpWD75x9kn
+        eUmEfPw5o6jNDH2WwWlf1MkFaZQ+AXEktZYYnCMaXo9R2YFCf9JSfZjVRKIqVf7NgOTuI33PtyjG
+        +/MkriutvagUULpAkAn5OE5WCH1h6gI2O1xyZAiMrb+wmbOF12q5dLuw/VplDlG4U4PAFFfIliao
+        jyHd57rnqFYTrQs5alLqsF9uXt5w81w3jZda5sUAuFmqZaHYeuyrPID1r9s63dKXov6bDjderS7b
+        cqpZjGDdDg7HKEXbNHlarvTwvOqAYRxoL6UYaX0DeWttC0GprO37ocOX2kRmbWSk1slKn9d0fqyW
+        LL2qnB+sVpShHaSaKBZbe/SuAUHDwqQcRYGdcLOjM6DtG653/HLE4bc7QHjDadXj1537vntOjrNv
+        DrMLR3vBJ3zwHm/d4z4bfxn+X2VkDcaVYsxfKqU9U+xnZ6f+wlXu1fJua0bOqqnYjoCau18GVimG
+        V2cdnPArEcKPG4ekxpb75fdY5t1ranaBBiukA/c5q7y5V0KYkmlIPtLq391raAul8pTKk6nyWO+x
+        c1THO4ORd87xjhKXQYlLyX4gsQ7mhq12A2o3oJbGEco6ZDeQyXq2Mho1V8ZFJu3wlTFfnbq0jPXk
+        VkZTy6lHJe5K3GWK+7sXrB2vPZEX3P1D5X2a0q6EXQl7m8KOOdteJehK0CsGK0Efm6CXuvQbbdm7
+        Ci+C+/IbePJzSTJ1HPnL3N5D2I8v34sPy0Fq2Y2vtJzSci1ruXPDGC3k2S2FvkGrjbQ/SH5mi4Eo
+        c60wdUekr6B4hat878FbYE6WZoJQWWiQCoaioCyslV2ZoMcbVHJVvKa5jMA+CaXHiP0vjssyl/U7
+        EVzI+i8jd1ICLkReaNV+Lanab6GkicVNJ2GwYptrFqQ9Jyywrm99li9FUgcdgKq6J/1Sr0P5l1x7
+        lZYJT3thFhGevSZI+PxcOiH8qg7dTZFFY+B0z8+lA7qbyDDqEN6SGHnft6bJz0US4SuN3wpk6gDD
+        xpKMFxZ2Jp1Ig1WL5hMShvxcOqH7S61ldzrWjgxLVLYGsmoaQ8tWdnI9A5SfVOtyYaP9td9jPeuI
+        3bpx3aprJ97scELkKSL3kut4yfcRX8lgpzt2Dth4+0pe7xCquJhTgo56E28+KSX53nnHBbXoLg/N
+        vkj02RtKirJHt8mcUdb6st6KyWJSwZmr3kqqtciZ+QD+Ks7MZ0coxkwZM22Wph2yVmmeE75j2iqO
+        VySquTUxGg5rx6y4o/5Jn510ZGg62peX4C066+PR+aRLKYfIG1RytZ/czxrFrrMTkj2OIiLEERg9
+        8VzQM7pz5ImUOK+KvK7Ed25w4qhZfLmDSq72kqQ9FnyV9E4QXRxuyLc57uu7E+NP59uMLONrZ+0k
+        1fvJDs+wYQ302DqIXNTZl1UwAV3bQGdAhSzAXqxXvFiMYqY1h5EMspUaHckW4gSzoJ03p0gvqwa9
+        zEenl1SDVVAnWojuXUIQApCDcVEE8h1deIFbi7lVuGXIXax18Cp31wABIam9ObsU1gchAKmpL4oA
+        qKhzi2XJSkrqV7Yea1w7SACkpCg+zGQEOW9EcQLZkK2Wj5NRDr8xDAcgCJAS1WMTlZLq50MRldiN
+        HR/h/RpvEfWUoRMs7MpsQWKqkCrcazXZZumaXkWpc6j67L4g4LNobDrD4dWB6YDK7rASg8KrfO9V
+        y4qLDcqUHNj+tZ585bmG5jKJMk3vNQjGxjolTrHRco42r6dxeusl0QrT9NFVYswsk2ZUCa9SPRZo
+        HhvblLhox8s4S8U4/aSfjZ11bGXgXHeeHVdZGj/vKKXTq9Jp1XWa3wop66RX66TnDOHhtTwRYtpL
+        Px/FvYp7R8O9yq7veYkdDdsOqSEPgLWzysjaXHzrIVgVCloIeZKcPdQqyJPl67T0mdpP97mfVrzd
+        Jm9rhuJuxd2T5W5hg6TPMpXjM0g4dSoVY3fC2AvF2IqxJ8XY5+qjyjminCOTZGxxY2RMrD3MerIT
+        5G35HLsJdjjE5K/93vG3yHmGVQ5pZeWfLwBHHiU81DTjs5XDWbiKEkMKloMEqz3VSm5Fy3ULOk8D
+        Y+mPDh4bbtOpuPQNQjviAgMhTZg42Rq0nkwb2bYDzZc41/C9/EChAaJSvp/WFPKwTM14KTo6EWY/
+        Hm3RllgXxKpASeEjWhQNRO1lO9S2DH3JkjKXossbVHJ1ABVipa6keRRPFggzSBXfsclHIVbCwvEe
+        BO8enr3jveu7yNR09OY50e6esltMjPBNuuvZOkke77OpmwukW8gybj+4W4tGt1fzJbtUdghDoUkz
+        kpDSAvA5udqNOWDZTr5w3xxQWNtgpBww54l/iVNCvkiDnBLzsloJ7MVanuQxZzblQYUmlLe06QFJ
+        aaugFu57RglpspPako9Bug7bJrSzAEvdTF0mJWdHdaUYse9N9NJfgSfO8tPlVqqfFQqGTlI94Zab
+        5wJqatClFNrh5oRe+6NHtq7k0UfHuyMesArFwxHP9Tf4QDl5tifXjuG3tB4UivZOcq4ApZn0UiuA
+        cpitVuZKgm4riEfLQ89SL4kF9pPMQb1zxqVIl8UeEmH1d0fUFZCmLUhtvxRliyfIoadmCLjz2ljv
+        +3YOlbQ1aErYHlmVejirtWW7TtJChm278NQdDEl/J6DVD+lDOzb+zs9qGDYtC1J/JT97RwhQIZWh
+        lgXl6Cked8lp0CRDs7yolXPomgVuhT8cSB1hcG3i1JtPCXRk3MfJVzO6Jv2H+ls2eyZqT4dJVQCl
+        bXhm1GeS/ALh08bhECjWsCxetWG4ajsREqLkT11+PVpLAw2hOhNqi08pneDuvWVfpaxbbodiamzh
+        yYEda50x2zvv6S+0x1v3uAevq73EZ/ZTMmCoiMHFrLetWwdJDCKQQUns+hmJgZtjuy811uKay86p
+        0zX3igDQ8dmbM6dFBAp7dg/CKs3+FjGKHs8kOhMp6aDZ29oKOe5skY976YDDIhA5aweZwAZt+RNH
+        OTAsF6sKGHhjii/WO0gVpRzYzGhDwHvm3XZaaMk3CrNOvasv07y2kAZuVdtQObyYQhY2U7cLWZ29
+        Jt6Sox3T8NwS2YD2leszo7A9y6T42GQkYZ0snv0u0H3jWbhCjwXNgNyyC2LHnX24exd9wALyWkrh
+        AyWVtduKVVT7yTG5gvCwS/9EJwu9ORFsBWqlmRrA1mo3wi/FQIxkcC3Ul33aMs1eADQLDtgngv5+
+        iJPGMfExXMNyLFoRdjLleQXNWm091o7XsgYEolZnG/kugKjKFsGACPwN5WwB1mWzaKZQEcHqJzNI
+        ACDxip+6dktQKVXjWrE3dXtZnRfWqi9iNXKT855PEHVYt8kswGLebTTRHgCzlHTRHie7+I4ftMku
+        +VSjLs9N+meYTpp+d8QurTIKp6vA8MoytZ6KNeYE5TtWaX0dyleTGJ7js1V2GXvlkYxdglZN2+UI
+        ytgbvEElV2vwyQTUSmBNdAs0BB6ZyB4osFpfdvKe+kKF0ls/o5aZxdYK+34Pixvs1rnBTIs9K3aY
+        gvZgKpGIHIIYWhvJDkMuqFFEM4GCGg9WgoRPMWfrgMu2DD5sUTLFyOiDh7/c+NssCnwHWDm7Fd/A
+        svcK51XnOSyxwAXf+uuC2yLB0t2cKMluS/k/JqfN63DahWzwIoMTJN0KQLr0X2YnHRmajvawaPVW
+        On9A3Fet9tcrafzR67HrLUTzEUDU6mHXMCH6ol7mMPhAwGp3bYADCa1rOSOn8yYOV7qjC/595ZH0
+        nMDQ01kNFCCrP601gEYGJXqrG+rDI05bOckcAAQlvRjrpT3cEDfv1OuwAMUQiCujUlQT7k4KUINZ
+        vJX6cwNAoR0nOBQFGywBvbR74w4quToODf8rpb63z7eFfDDW7ymt44b8yHFh7sDeyp+9lAlA7qIw
+        /7POp44BYFpZC1O1KhYMGmWaO42t64zkDiq5KgxY7og9OIYJ3Z93cXyIvptlngdtE+xnjouuiTlb
+        7EUXsjeE/OCEZAyBRSqbxPiL4Dzb7NzwUCqVhFyhs4kTBmGj7gt4KH32M4f2znHrBq/RAePN7rmU
+        shsvOG61tIB+Qt/kECYOUHrz7BC6G+bUIps93r5if3sIXD+mfPD/LgOSQbOTMUu+YpZ9xeXyv4tI
+        lLYXttAc7Rz34wjSYUBHc/oKdOll/JqyjhRXfXsV7wrThkTa/4pIwPYtJYEUjmfg/J2pm7ahm/Dz
+        PIXrgHFNMEU2mlNc50au0051MAknqllKesVjsU61Qk/niqh9gn0cEjxOmP6vbbCJZmTRi8k/omwp
+        TcGdXcDlrqk9cqnUzuP8gBiYcPBG+QlpX6OYvHxf/urSduZ5BUqm4mOYSwG4rR0n95fsbUWYkkgF
+        eTx57jEqw7N1DSuNM9AJtqoq5nhM5hCzvRSXPCCXJCyiL0xY93nFIgMw0Btjv7zBfq6bxouoCW+l
+        Md5wE549diponDwnz0Q6pHGyYsSh6qpBm+pFoQjJ3Uf6nm9RjPfnSVzd2/OXKqGC+67AbRNb5N5W
+        y97k9vdt69EWdOTVd6Vb+lLhOhVcg8MxAqEJzn4dJ5rLzo2dlsBMZdQ0XxSqE0F1VF6v1uvHTQJM
+        MSFVqA4bVap22WgryLnPaslOvSrmQXalihZZptXMEI5ex0642ZGRPj24v97xyxGH3+6g4Q2P3F/x
+        68593z0nSYfGb6tHe8EnfPClXxEdfxn+X7WjHc+ONhVyVON4t0Mx5w18XTsxeV30zCt1M3m9wB15
+        Q5LMdTeB9QcZqf9ypc8VjyoeHSaPCrPmQjQ6BlhspX8ma7XdHCe5RhlIykDqwEDKAuEM8UA4Jerp
+        RSXqStT7FnXe4wri+kBaYSFNGRTe9OqsA/J5RCA/bqaSPgZu2LI6pWQ0/4UwsxhiPRc+vzXHTlro
+        rfd21DD7mEcdnqU8ZWX45niR0obtakPLzpXs4au4323xm3P0YqXqlKpTqk6pugmquiySuoYfp3GI
+        JPBsFKxd2CYtcMkzixStmL7OOzpFFTBbO6DCswpuYzbWnXDe11zlWc1joPaeLaggoFIR3iQWKpUW
+        JZGjmtqQW5mq7UHFHKi7lcT3bnSM3YaFGk3pAe0LG/alrCdlPY1HrSrriTemG10qwxefKqG5oQIW
+        VcBi4WB1SNe3qDc+jz+bHcrWGJ6t0YMru2PbQak3pd46UW+1zRml55SeU3pO6bmh6rk9gSN0PKrx
+        CJcmv5H5u1yBwRItBJfE7F1AOQT1tW735PwFd1Hf/rziXOmvaN8f7RXv90B/rhZSKPQnBXOgEACr
+        2o+V/Kyl2Q35f2fabHadIn+H5PecGAN7yigA5AGwxfgQYfyBbn+fLM1Ae8eBlg+yxM7Pzu8BQrKw
+        VnavnRDn+R7n9WtSZ90GfnNflprffCDE7wRuOgWm9cAxQp9EWsyblgNNN34iOzqZu7XGnGrCOXWu
+        CZ4Mm0njDriuGRtnG9qC7UxSdTK8SoRhqYRheMIQGkifm6vBaO7F3LLY2kJdNhLoRW1PjNHecdLv
+        z9Tm6M1zoh1y9847fuY45Mt866tilZv28blwJCyoQGwD6jn++5F8NQc0ym/pF3jYf493rzvCIpma
+        4w6jX5EiQb+W5X9Km+h+jJU3FRkxkd/OllykXtfUT7xOPoK5TKl0njNnIsllZiIGz6ZNZvx6FpXA
+        L5PLM+fomm69VI27g7oscunC7dftQe6sozxJ53ZkeNg/n48j5CiOpAfJ/ujFLqGZ482S2aErxX6D
+        t26MHD8TLO7SV9GEiirEGXXcezhOlsjfcsaUX07W99IFlHxGMgE3djHnO+jBBPtgdkbJPyZixP5j
+        wm9Vr89QrPcVFbZBItvpC55LEpJa7rUm+agEegySnV/scRRR/SW0bPBGHUPvfFZVMqoyEO4Tr1/T
+        ky8OJHEiqKv03LB87bIQoVkqXuQXPrn4s9Q6utFTunGrGUvcEZWnwjfRpkIWV8XalbO45pUWV60N
+        RT09b1h21bgLFSm1dcMsGX+1Wk3BaFb2+D2vzqmW1gR1etaaMWGy2Q2TPVewo2bcmlLCLKnPgZm5
+        0gykYTOZvliWcc09ly0gnPOcj/SQsHPI4M9IXLKvQ0RzJ2ovYamMPZBhIhoOozSX0lyda67k4pWE
+        v9N1WAfgjBNSPcdhg2Zyb0qVz9K5+0Rr60nT+7PlTnBhT+segwgDm7/d4/yZw/LCTj+GgQz9Gaw4
+        p0KpjXNw1i6Z67dp8UqiQ5PHzpK9u0s2WWGMgvV/8CYuXNkzwthKj6REGNj8O5UOOv+jF4fO0Kgg
+        1+QtosJ/nP3aQYbWRriF45oGMHNsvqg+6ucOKrkqeESRO0oT9s9faEns7ZB1zAPN/ilRlD3ObExR
+        cGiioiqMqnTToQRfouBTggpxqSJqYUgsjp2Z5zl7J3HT2fp8Tc07cscmFggzEfOT0NdJjE4zdbvQ
+        ScJeEw8XYXNk8kZC4EcBtQ+KjYXDce250Q6HUUrwZO7o3Qm32L9Q30Qv+hqlhwQMBl2cYUCKHDHc
+        stTrMAuxuqbIKvfTUmxyZZPVlLmETHXrxM5zLjvOD+KE3M//Sr7z+788RTGN+H2KCUM9/XOHn36k
+        n/1EKPT0/d/IVRyeCOmf3oLwqUTEnhx/+1RM2ycnxE+u/5Sw0uYp86UnN5G3+sETJbR2PRz+r+J4
+        6Rxf8r2K8+8437zjfDe64dGn7TEkO2qGkX+bcPKn63lPa/xEd92YMHb0ROj3tA0INUJEfiLjJ5R+
+        Nn3gn79X/N4iv9vky8gFd/OBjOUaETbDNZjeEuyvLML4sOrI3FFll4VNSSNXYaqbOGL58UP1Y5No
+        +ktFaFIrmX/F/LpQ7KrYdcjsGm3IxzfRraK968WZFcitVezaqChZPzkailkLmbWWYlW8qni1E161
+        6vo6W9qe8So2dlrVsXJ300LiUC3cBuV1VLBBYRuSF1ChVl4mxSeq/+v6C+0FUo5FS6UkbwCu4C+L
+        hV6VOMYdVHJVeF/EHnt3g14rq2EQ+NEuiMnPD3fvog8TxTvX/yCPh+MtVibv/MrxnLHmU+ZGADhv
+        1F12UQlX/EpgCsL32bu3R7a2bIsTyGskFrxuvbnZ4KVeahL0LQ/MORxQUSodVlxULLtiVPxitcEv
+        FAw5vNJPZn1WlwilhTyRBVIqbIhL16WPVsYLmyteeE1UqRTFmLVY++5CfHD8lAJAdvFBJQeDhEFJ
+        RE8qKYk6RqZttBF2PCry55IfOyM/LQa5VOTvkfyGkU+JURB0CIFgPU4FgDwAfLwP4BqILVUwsWqo
+        uUoMnSEgIAGG4Dnt6FDIT7ATHKI9eSYtjA3bFYi5UEYHQjuiwBsFCnrMYQTeMrSIE+Qsq8X1ohdt
+        FWxCSn8mnbaUqLycYfKYuyluwuv8Drf1h/IfXV2jjj788q93AQ7VnsA7/x9yDge0ProemVJVojG3
+        SiqlVt6F25RawOM/+DlaIfmtum7UCmIFB+xTZ+shRkEUIcPU1yKVZMUWwPRlQNVrGfqSLRLbaZnk
+        XEX2hsHuGanvwt3zdOfpBtYDDcNSCMq0VdhqolCyAjl4KH/5JE+kf1jItOZr5JjmTegIUfsCR5Ki
+        4YT0tcBTpoVp2GzF3Jx5ROudF1pH7EVRC1X6CRM/bLCwDPm7F6wdr4covhsOoXGEIbJXhO8cq1Y8
+        n5hpJplBWpV8+cXAR8ggPv6KUcoetbijXwXCHVRydQDBTGPnEfEIKMUjU+WREw6Q2aB0V1LlG1YO
+        1NDNYkuBuZYhmJa0h5W8ijCx8rbJjsoqL2fhuGcgt/h0LuHrHLIqcGndci58lSkAZfjBMgnYqukl
+        sOXLV3LLDpeWMDThJQwHibTxMEg/MMjldfwmhHGjIpKDhO4B5XMKsD2IxBkVWnVyyNWoKY5C/IZD
+        7G8wJdpYcAXYRSMEt0KbPgy6D6RrHwbTh7N9pops8I1WUQ/JBPwPYO950OFU8twqcAHJdLwxvxxx
+        +K18SPHFjEvSGQNTY8tIhuj0QXQzZdENEpBXSbWyOJmCKBlpNAPWHZfGaHXTqxmS1crAlki0Hlht
+        1JRL/wJqNTZHsDbJ7JKpsteymeL9Gm+3jB+63mRhYXqLNvmjEliZ0xUoum/AWomPZNqDUAWdzhm4
+        akyHtwej8bucNQ2ggKpsDVRLv64pWmlDyp41MMR6Omosa1Hb/cQNs7SiWu6q/Km/ub5Ddobdc3rf
+        mGfJlY8m4J7z+YCTdqlzCJ6RIMn+fmHbmBZea2vK5iWy65H2HvujF7uJKwqs0Ues1j4df7vmxezf
+        T/1e5njR13UitHODiuvVGZBuy0znOR4MyXx5eRhJ4FY1aYZHGVAfaqYzoxTKnKsZ/fnHn5DNbmt6
+        J8scRhbpVPk7DYD8+znO/gf0vWn+gP5yG2dfQihu0KGU6MUSyYKxj9EioX5/Djcn5KI0+wt32emb
+        UjBC3Smq9jjqn+d4WsVRF0LdFF78Ky28+FcTwkncZFspWbvAgn7wEolyqIRjJ63qOvvx2vAIJHSd
+        k4ouWyaMm0zpmvw26/MP5PfP9Pe/CLUGRiHgSmcspGsmLoX+YSB9bq7KiLQwqonEG5M/VjWARDIs
+        GJHmdkdchHTLtAdGI8MG0chcSmckjk6iFckHq5SWwCVuKX+NYyllo5+z5hA/IGPxRwjFFpwNNkMw
+        3hCWXuyYEoMAstzRzZv8xc7dhEEUvMWzv+1c2qSIho3yvRq9M9XdyUcJlSyp4hdHgf81c9f72Xvo
+        +NTvc1dUHuQBgfg/sjdVBYUYL5V7QPFgKpE6fdzaNM5x6wbpt5Jhb44XcTOg0mHp08vGidSUdUIy
+        Bnu8ewqfL1CINjoQmxm/Rpsd3jslI1trh5dMgsuT+ZqS8FNySDErGEfC/BJtZ6RzaqUoruyFK9fu
+        e7Rxk3jIfayjry8PGVaZT5Cj0sSVHjOkZBGBugMB/sC8eBRwbhkLFbNDHR4CALQJQmybs/84bkSR
+        QcnHKniGAk8afDx78xwfxXNExGco0gP1y0AaMowVnVs78Cw86GQqgIYK0KX2hgJpmCBZZfupvkBi
+        NzrQDVGLINUxNRuYcbcQ2WiXVp8sAYe2aa/wB/CG5E5RmDHA6M/yI4LpI/R+dMKtSywGC5nIHIi9
+        wMa7lO3fHkHT3YBEVd4wQBqgpusVpDjeI+olQy8LFJaZDHOjAqL8ABah+xFFnppcPGxhyUVQ5Oxk
+        QJpbCwXSwEEixFMYDRijdLiyGnqBKFcB7uLYv55hpg3uKT6GsT7DNcTzOStnaRdL19htckHgQJvb
+        zgEboJx1vIHiomUNFC2weMHKgk4IsRd90Iox12+gZINV50R2KKiJKEUauzRMOVtqUL2YHzk2xATk
+        zEZ754RDd/OBjGVpgsdw7Q5DYyuTTxiwxNdE5OxqNY4TtE6Nxc7t/KKmsPkmQz3jBVzD2EicCQlY
+        DqqilmnlKYmwlMaq2jsNTXq2N8v0YSKKEJn2fT8XhdsQcTu4XwluhrkmiOkvg1KDatmiYIklQ3fp
+        OgTjM+XgimjruM7MoXYg0XoGzKHRKUorqDmRGzklnD53bkRmm5VKOVkoPobr4LksevumkClRWGU5
+        NsUjBUmYBkcTlexHm9A9sKVWrzVKK/pSJs+Z3T0nKipXeqZMeUkRsSmmSqvGDOGUbYUWX1TThgG0
+        aivEi/TF0EFWrYGKkgayovqlN+H9xGuCqhNudrxV7woAWekMhULvKAi0C1c4tIgDz63E4ODu0366
+        LA6twsVrbpjfmLXYALE7rO5sdQlgcjRcQROjBa1+Za6ei0FV2I8Me4BeVZiOA1PGtUUzCjHtg7y9
+        pW0y0edzH+plNZyQnNGRrKbJlMtbQXxphJrOwf1NcfNIIQ7IJ20Wbh6lLtQWWuPYUQyhGOLCEElb
+        F1GuMDSTLbdUwBaQqkzjYAvz8diCZwUoxnhsxhDnCbWETJwlaJ0gcYa4tcJrbyxFTkPHwTqsrHTB
+        OE4U+ENmrppWq+IwxWFQDqP2jpihA1zUIKfL4+AbNmJS8U3GNzW2T4p5FPO49TdZin0U+7i1t2Kr
+        as5R1s40OYepotzqRtycA5r9cgeVXG1hI07bN2sJE1wbOUdNmUAuaulKcctYFZ23AejoyX9adREe
+        /rjyAQUwAeuO8Ia9OuvghF8Nc/VxfbcNDPEEhYJy32AwolCuX1ntOmJm8wN/OAwnRvUHZs9xMpy+
+        ZGP7gQsTGInFhFc0OLdYk1gLBWL+FL8ofkGGsHMPuEmSti6MyIIbzBJ2j+6NqcLjlfvi70Uc1foe
+        7/9v79p6XNet83t/hbHThwQobV18mwIFkiBBETQFip70qQgGtEyP1ZElHUn2zGwg/72kZHssiqKW
+        JVkmbeLg7H2ORcvSt65cXBc1EsIEmBnZMLJhZEOIWYsomxERIyJPICKSCIGRjweTjzKtB5IRnfjf
+        mAkjBk8lBtWch4dP9BUcJilf/ePRd7w6/uG000y6B8nuEEiHOIJVhmkgNd8rwRD7oYlNyefMDMUf
+        neLHytxGu3uqyx20Duf6hkDSjkOPa5h/Yn/8FuzQdLwAeU+QFL4VWSeR906/HB5IkhKQR9/kSol6
+        pUmuXl0zxdeD30q8+pp6WlEY+CMd4x3+GYVjL9pNjkSYHJPIJj94sk+EZC80tUffJH9ngbaG50HY
+        lS7EQKaCU0nEfj+Be8irOa7PVoXwcbptNHazZfnJLMvbnmKWTujuNDn45OPEK3WsMjesYlgFxiqc
+        /6cIMUENNyu9U3uk5WDwH3rFH9brUHv8G12qHgmEPkEUqnJ+HY2W45dnoFGfJMB+AiMCWEz4qK4h
+        QTMJYIJQxba2NKeyuTZUkFEBuc4KWVN7itgJBYwYUIEAbBYNIS7EYRPgdAsigQWA3zLQy6GnFzPy
+        +UqXFwGSVxz7UvR/3ZPk60fRXtduGiZxvruose+BeFmUvKb0D1J+qGMHcy8KM+yHhDNRLM5KqZSR
+        JE4I/fP72VKSHt0W+nRuw7PVdxzOqSZ6oDRKMN/o97pbsyXR6xuhL4WbOhkXa7mexraU+HGAs02U
+        7MbFE+RRkDx2SqmKErIhCQk9MsnvLIqkkvUrfVJM38nP4zJcc2RKy0t2Ltgjj22eP/u78KbHV5Pd
+        O3+mpvskJI2CfdGQuXKHhWN9Mmnln5B99kkv1rVwLhEXUTrelcCuIfDNCYy2/tuWwpXeldLyNP6n
+        pjSb8P1pL16cCqnpZ5/sah2t8c99QsCKOl99Bz2d/+5453tJlEabLCcuCdE+pUY6Wu+9jJLZRykz
+        3B414fkvIPHTXEFuFSjbVoYv6QrT0bejrVxFG9p2pe0V6vl2RJZr5+clcnvVnOzDD/y1CyYUh+mr
+        YJqKiMCnL92ExpBKujU5jE8PkZP5uK06Hyo+muk9CSv3hGfhFt6cDbhcYy4NIr9CIduRkB1w/ZiN
+        vISs/SwdUTqMCjqMfj/6Z0oIO/+ouDz6t/yj2cWq7x/9h4SlcEDi7Z1ZyjYsNSRL2VfxlH0tT7nY
+        6KnSZ0/BVLfWU6d0sA4sld+ihqVqks84NuIZr2bZQ3Ab6D6tuM1+Yexm9chu9EfiUf7AoygZLUvX
+        2A+dLlb5cTz6n5RiP/q+329z/vzdCKejFU7JKM80gbNoH7qvHaM6MEZ1DKMOyahOiRkLNvwtDr9G
+        30/0u3o96Xx/q5EHSUAOJHzd7YPMZ8cjexy8HgDxHBknFmVAaUyIt5VwobfFCfay/H58y70eeAwE
+        9J/TjOJEaZ1LbC6761EUjtIMh2ucrEd/+9svo+Pdx6P/zn/6P/862qckHf05h+6veJWOioTpcR3a
+        Gz8hH1HynrLTH+x50T6k29bzp6dyq18/qB+UJ7cnaLq0Vgi7M9DMUmfu2NOp/HRNuKaSis4vqjkQ
+        nILny8KyeS4Bqj0nEh3Z8WlobWDfBPtP9B6FTN1UA14loKfWy1wOs2AFDzK3pA5irk5B1hx02RHe
+        iuloA+Mvv/wJ2X9UAzx7TBWKDTm2rq68G4DeNonCKEVbkuxIms8r5jXxvfCEJiVBqmZAst4KP1YV
+        xIY9Y4adBDh77i4btKVoSSURl1vzONhBbI4BsQnE+Cvb8mNBDYRgCN2pOjL8AsSOX3dH7NSTYR1B
+        VEyGdYNwYclkeEAHRkPgIAJsEJQi2Ci9Br96/NSxvrp5LgsFja+GGCpme/VBkMURkR3P5DI8n83c
+        BuUnWsKjx6/RHb03sqPs58iQEzRz6NwRYoDilwFgkzLcgLBpwm1vfhah+cJmgT4U202qjq+NEem6
+        xupxflFtBBVaC1pdeQ8UDzaKE8Kqb067N6n/IuqV1kvTNb3lWAylfBc3OJaaeNJiLJdKQamTnryA
+        snBw5PFBAyUcSlfq7hgBbzw1pm+rRpRhCTw15tfd7dBzvUo+Ibtl11nM+TFXHIiiJdXy4fIa3b2f
+        NSFxSsj7MWuEepIshUWZPbMWbg+Hoavi+acWKpEDctHIjCaDAQIgNdfxzKDYAcWTOBskOyF5cBD7
+        eZCJGTJWAc1F5NepgCXU0hg86/Bkv5YDqhKE+jmQiY2smbNEaz/N/CBARTKyCVd0QvQEpomj9Y+m
+        Yc1ewDSxtN7BjGdKoanXJpxH08QmewRTntRjxFyG5cljz++kkKupl7d+cKQ7cBPmrYHvQLeJOEDp
+        DlNZdmaWDESjFIUYRqvVF9r5oY/2IetuT9YoDvbpKV8A2calbIvqGdATlm6efxuSD5UA1YRNg5iC
+        iRz0Qv9lVttBC+MDtccxnlOh/8y15/JT6gANa3y0sNskCX2CpvEMOTarR1+hWJF6BC12Nd/wuRar
+        558uDIBXAbjBCUGOiZtdDxz94NT6HB1kqaVG6wnBo57MoamQ3JwXVnErmtujyEvQYS7BzmSDV7HL
+        P0A4TVCAE75x2b04rzy0vA678qo2yBVdg6ifFqZe4setM8rKQKrSQUM7FFl6o43W5KAGfnp4K2fQ
+        EJuokURBSDK6OfZVKUJl6LwAUXxRAMVNvFQDuBmwnRC/7m55tUcQU28b0gdQA0SdZPgInDoc6I6h
+        PFhdeTcuPBVTIl+26TX1lCLUXOQsGoAzW996+EwpagvIlJFTfVBz0IuB7TrY2PzBmJ8afOccmXuc
+        BF983mtD07c4Q1GaohRvyNseJ2tkKxZC1ebgvQqlYkhqEU89djQtRg7t/CKVQaGjOC3UZj6HMzwE
+        LnLleQqmMK0euoWBri10CiGnhbz+H45xSFKC0gyvAoLW/mazZ0Nz0acq8Rgdu2S/46wooZJgOHg/
+        fC1EmSHHgqomo7o9dgtnhchnbPC7Er8iL/DoQctNidku10PnIlsp2dUinFoG0OT4tgTw4JhsmNaw
+        NVWNGOxqsFOmg7hGqq6ArYnlHGvaEGERrKg4yOUl+rsoDDtFOE4zQTU6rh10LrTZ/4COsU4CW8YP
+        bTcGwushNDuydqipx3daIRjbaGpdzLhEQZSffCpgQnTy9xiOQCNiwlNX4CiPthhmrAUxJLsoS6LQ
+        cGUvgDom7NcJPTMLoD164O2JkeFaHIvYs4krXIfbAaMvv2EMqBngVoaNtTehr4h2Nlpa72oAp4W+
+        OwOnSL2gCwXtvvmRDLYinc9F9sXQWeTMbBmSzmxuWQ1dsoRrKgFofpHOSu8STVdhMLWR6BOYS4XB
+        1IQzTdJuN9y+GXAqs8sGQxCGByuWCbFBEYaiazBsiaFhwLbg5a1NqE2WV1YP79PoUpJ0wpHFWIv5
+        MM7UWsgCM86yEUrhmkpghl/0COyYw/jtHBoo20N5bE5b3gZa6vQe0ySCc+pV6Ujz9Icd362RdryA
+        DxK2Njg24KjQlk+LYtdL5NSbbKkvhPIMG4NiFcWvbBuxmHZgMvevQ+6cvhDiMMoz+KktOahStalD
+        8DWM9inycPy1wkneWOZgxy/KiK8eTMggPHdOKKnEdRwpg6UWqrCMpTlV7gBfntBgDEpnAJUpbNKV
+        A006zTX40Z/wMSo7NrlXIx2basphoVi+GChbQBnFJGRfRm48Q5ZtzU3bxmvhu/AQzRF9VxApFxoY
+        28MYJV5D41UDXAW4eOujhhT1AUu1tYguMMjcYpSf7SzflcxO1wjIg5+3JYNC6TrWvKG5lmhJVYbL
+        azSX4XCdtyU7TUCcrlDM4q8Nw5dMx0EYlgbEPkCUblAMiBUQA/z1ltCL6/wMwHKm8SfCJM22JPM9
+        NaIPWvZwLAM7M9D2CC01Oj5moR01/EktzDebsot+/fiVtcZEcUIOvnRwsclaEiPIZruXqoCUwVAf
+        LswxlG6hTSSxDjybQec09qEy4itEz0Eq5itpw3wOOgQIlnI4LIJaBCLOCC5UhFAjGT4ERow7IcgO
+        ouKZghDqI8eFF2hcmLbYGfbrCqEZcdAJO/W4TysEF4b7umBnuK8bggoCqJX9zacL5U6gMvhpZXy/
+        8VOPETUEUu5KGzluhk89NtQRR6MPO+OnHiNqCKR8b2ccw2b4LvpbO0tZMyqzVbkST9d5R0kUE8Og
+        PQE6lzZLG7Z3g45YqqMqdbQ0xmD3AaMpCOiGnnpMqBWMO5xtoWFFU3YrxvAQQI8FBu+Qph2OasKo
+        lUjD80QMOzbhqCaM2rCji6x43tSJoAE50RKRUXmUzuwFbvK49rCwacRudqxWdrBOHEehY22H0TrB
+        G+lo5LljTxuKoYRrKjUS/KJHAxEVbGIYsg8sc2WljE7UCEfHna0QlvfLHT7ncAy1KsvxUiEMS82b
+        Zc2wB9eS2iKabf3w3Q/fDKLdEHUtCqhiwxzH0AaIc2XwU1fCtWgmWcZSWdnWJhLhPn269sXn6T6O
+        oyRLXxOC0yj083HoVFhJe3TNPrsdauqqSY1gXD4x891WrI9n1JxJV4lNtfKNCjiny4th12i1secN
+        7NvMvQDmVdAktQeS7FZkvWYeUUNkfNgza2sM6eRSXtUGvfPr9wKhQrZbDwCVgQsaPrs3YAXHheQz
+        Q0u4LTGqrxHF08bQoHgliglJcPielxApdLI6lPor3r4P+J7QdvQHnkL7Fm3AYw1wKqcIKm1INAt3
+        l/AEmBODZyOeZrvcP5YqcqZ2WJr85E74LVWDT5MQ7a9Pf/bSBrckCnYo8hIZcCZjVgBcGtL/I8HF
+        kBUUYz9JdkqNNNQDygyvAoLW/mazz8c3fAZ5H210sFFTEtlAOlDLBtoFrnnnfFVGHGqRiUdxS46d
+        DqRRGzPDqw43M/qsDWwOsqWNSYada6EbdvJkukGh00vLNcwfNVxXgS6L4vgL7Uw5+JW4fWz9lD4M
+        OrhqeCNDhaPxfu1Hr3SbEKZe4setHbpv/FC2T1aybYZBsRZFMzO9FWDIsax35OH4a4UTLIGPrmuM
+        FwjXVCKk/KIHALFhoIdhvQpqjQfnJgz6jddPEm+/8k4rK5LJhPSZvJOQfjnDkzUhcUrI+/k/qB0d
+        c/Weoh8svg5Jja09W5xDhW3KratztptUp6hXWO3Fc0bvZh96zKy+ejgIvhN7RUtjagOCgATXfCeL
+        ouDV20a+RySr0q80I7vXHUlT/EZSycqEpHEUpuQ19bZkh6srPUwvsDzl9SWIOepFpG7KH62JKPha
+        3Gbr130JlhF95EI26pdS4/Q32jljewAedKFb0vwcvEGnsnl5zdF+0VlK/dUnZUJGlyYFWmLA/Asi
+        xvqJfRQlb5O3YIem48UAPMWfN9dqdcNTAys2PrAEUGv8V65Sap8+jnY+/SeasD/YKNRNgNPtAEwI
+        jbXxCrBt2obrVDcutReflAGda5Ua/4WrmO+k+PA+i5jyi7dRSNDLCu32QeYz5PY4GMLE5ok6SwAv
+        UieCzyETsGObfq8wP+/gs2PWqzlF6M5ElE+2UUZ3Je9UAaB3pyaJ6s4WaAawQK2ytuTJYQ+rADr6
+        vMbj1Y43buHHtmWoGK/XASn+PP5P5CXoMISa522VLJbREGFpc24mPZu7hYYXh00Q+YwHCZ0soJGT
+        igdrYieDKXiWvArP9L8Jp7xU0vJrdwLjF4A3AEoFFYVIay92Fc6u/nERGJgfFLK9fFh0WDooIbK9
+        MkOnXdussn9pNOLVr3ThzAEYcwYupjBBq0cPWr1/YD/2gyibvOPs2DSDMptC6hG2NZnNW6TeyzP8
+        n5QH59fqv3ldMP7CIQL0I7hNYBSs6mxIdOTR7XBXJruGCwZ0iw0XaLGBqm6yKzVZN7NEkGAGv66X
+        pH1ZVYBqXjQ4MmKjjCQ7P9ynSoVHbCPbQyaWtMkr6ZRWUheBGdDhgHu1xtDcR2FdMAmFahD9ZPOK
+        p76txrSvM7onDuCKqJ6+f7F8yUliH6aIkXkIwrdsWTEsyRUWVbFvYVyKxxJXpV0KQWqH9WLNBuBB
+        k9Zxd6Nx4SpctBPGzK9U0qV0je8wCBvIu47dhAkW0ISLiuUSZgAACs+e2CKJmCCKSUiNwFucoShN
+        ke1YqwHIDk2mdCoRzid0RIY8Re7qRAyoOmZgZ9aBWJB27cGe6bgXupVBlutM1drNjG3AYSsogUy4
+        qP7qY3HAIFsaEZuVk0nU2qZAOAuiW16WrlW7S+EvasZXqqWHXLi+oPGHd90A9WW8NHaB+k2a3JEM
+        oyDAOzzJ/0TsZK+2NetdE815R3nQRHN4HvlbFL0FZPJGdgxNuougYA7iA0KLsnraRTzYITdnVofI
+        HobaVTtP+W5Qe5Aqunasr4TWUyd9eHgLzcUlhglLTME1nvcNS6jHPt29L8kUy9vUlEAtcKX2pHXw
+        QF9NNEzoILHR2k8zPwgQ4w5k853clMiibGAFSGeldpygdpajwKl20cIaOC26Enbo0owJJNSO4Myh
+        /qoOYi1V2cgZz9Bi4OQzcPkfgKqiHh99uPkKE7Sbnj4OQaDO2GkcQkh2Q1TSwL0xwNng3HKWzWpZ
+        JsrzGkm+J2Xylgs5ZY7NF2y0tN6H2Hj3W2tnW5CeoVOZquUv6iuYbSoKqOtkzZzlAJSHH7pBMoEh
+        Ry5PErfs1mquIo/NTToqX+nOgyX3vTKy6e5R9CYbMYWkj7RpEaab6z5wNBxq6fl1w1UqXdE0y/eS
+        KI022eTD/4mTdbBDDlp+OoMIwxw86bK6sia+OmtCUyIPdZXHXRrUHC0dKuJH/Pzbm8WsIezJh5RE
+        Bg8yS62djhnAxTip90JLLAaJyUK3foAo3V2rGBVS7gNHZWaVk4A6Gi7GgA08hIotdJISebjf4fBN
+        PIQzD56L3EwWyCRxaaysNlR248P/KdrhA0l87x3ZixWiGpp8H0YMRAZwJtsSdPJkTZezRdPBaBtV
+        12dz0SodUo8+Y0GEORk2bgy1MrNxX22t2qaS9kiCMNqnVE0RnHjbyZYk9CvUV6XIou9twCDo81q/
+        PtLXk31Q1spL7QMLvR+CoaPvPTpgbaaO3LTtngjuFEe29T4JCj+J7JMvHBB0GGaUA+VwPu9FIgyA
+        FJkbSYPC0TURTVfYX+8nJAl9whKdkGP/cehmPfBKp77yDdqVu/XrbX0L03KFgn2IEz8dYsvRX3rl
+        w5kTKgvedo/D83+gnTNQrBYqA/y6oX2s9oqFmuepM6V7uCk/P/Q2gVNwvM8eO5DzGMcF9BtsdUw6
+        cGNcnjD0vQqqoKKl+CC7OqjrVORK9kIbWeiQv6iAMqqGGRkJ2BhUB80X9lBKqccDTcA5tnBR/dUu
+        6Tou0+wDRTGgUb4pJIahSzjpEulj+fwwaEPzVx8Kba7OxFkMVGdCFTR0yiPgWE1U6afFaAjRZOqb
+        HQj31hsEcqzfzqfRbBcsPNMbiqS9mtmnJGlbpfkL24P/x+SvdA/+R/RLtiVhNNR03GH34Q83vk9o
+        ApOveEsmu69sG7GUz8BBtjuEnwx1OABZEIC53YxcMlL2vm13loP373Yrh0mSsTZ3DQoqISM61LNR
+        Rho2dW55hYY1fZTuXmKNsD9E6/fCL+4voeDZ+5d0UAd3aKoHjQlDWuoZnXDThK8LBhnQ8QAfGpjO
+        M/dmkGgX+ndhEXCB1wuo/M506ri5aypag/drPyqI0YLfhrRZht9U57cqL9WvKrCGsBzaZSgOBpqo
+        A+WxBcgrBjTeum2tUX0YY5A9BjRKPxsDRkG4gIPTNnn9jyev1yc/HNPdBmCKfrPcREeOD8MTrU7z
+        l0MdL7uV6b+SMzgQLQGFbyocMV+APR0MbCDUgEl9+uGcN5RRcugAIA0R0k3m4Y6lum1uBY2iHDTs
+        ZgMqb4BjSVhJw4MxgIis50xvm6+bGOKg2dRN3NrzILsVWa9Ze2xrPO/kSp7v1KOq5sXrJoVHYIS6
+        lc0pio/g0L50TbwRwf5k9UbQzh0KEfuKltDdU05eZElG+cUGpklIgsN3knTkmeI2w2bk3Jxpztgc
+        nI4MBIanT+7pvnctoZM7S284I6Wm9WVUZDao7eENd5ueXSoRHc9vCnEI2phWgLNaRZs5qaqgDW2Y
+        xGeHqI/2qcck3REerLHbCXCIgoLhDS1tqHYIVh9xcSOlu0EN7/rJh5/Vh3odBfHW7442KMgDgxua
+        P6YjZ1+muUsRF53k9HCg2FGZ8FkaCgF+ddBPTBSq5Jn26UaZVr33H1kaOhCHTd3Ik0yo080XMN/N
+        Ijw7UU5B8mJIrzJkgXZFtCs16gqRpUlJFZjPx1LUBZvcFqkC3F2eEHUG9rG1pIF7KMc/r1hQRKXA
+        R7FU+88rhLdoZSkDpD7ScGjgfceadq+t4m6irJvaL7p50Tg71Fdl6wUNmSkcxGlLizDa+V5xYIIy
+        8pl1IgkMbejETasL0t8HFVKdW39SVDF0DQc3/BIFXz7FyQHvJsVfaFd+32IggUc94ZwPBZMNLh+p
+        YfUrXkUH8mpvE+H36mYnAPBrwqV4uR9X8WnnTIE68YYQF7YHybIU2ci2rXmZahxK9AES7GU5FIUJ
+        nzXgVUx3FDFRkT6cxoR4W4HOIutXEq7jyA8zBsn/nhfkiyYHe5LfYHK8wfny3wXvtV1f92qu+i/G
+        xmVOI8TGASH2ko7lzJDl0r+lb3lWE5XeC/28I8+Rxbqy7zyTrE+JF4VrxsJjKgKObOml9zLrEWbh
+        reh7Y4qQTwT3ys3av5Q/y+/ddNPjG8nuzd+nmQdsB9kzwwNPyQMJDlMv8VcEqg7KpOE77NTu3SoN
+        BoGMI9q/w3JYa9nv9M4x8xMgtpF/9CtZpfR7aRuqNAuoocrtqDJDRRd0hGNf5KDWz8V2IHO3eiaE
+        swBkHQs3qpKrVzqTNbr15hmO8XrTWIJGAd3FWT7srK9NLTwRuqeCoA+yei14UuSY8zx71CEWsqeG
+        fQ376sC+lCeDzN+Rwhye+Jffjgl3/BeW8MTJfLuTCt+3+U5pNX8SILXOPHtxi/0dpcKP6sgEySFE
+        U4QVZsEhwcumlM0WUlcGp8nT/96JTNva/xNz9e28F4S7kUffbrfQoS77DvqviyICqZCqG21UiFEh
+        RoUYFVJRIWmUYAQoTquPdbEl0esbCUmCm/a0xVoukmVfPna0T/IH/bHNsjj918kkDnC2iZLduHiC
+        sRftJuvISyfM40/IhiQk9Mgkv3Mqjim3487ujJg/U9N9qP8aBftic165A90kfDJlwz8h++yTXqzb
+        zhdUZWME7kpZ11D2dpRFW/9tS3FK70rimSFxHYlty5l+2osXp0Jj+tknu1pHZOYHMN8ufxdEMSQp
+        lx1Q8bHypWVPq3qIAQqESAKqFz/S7JzVxS+vY9DiJ2EMWn68aduDj/w26eT7N1OegBeryNrP6qOq
+        pHDKxxbaBDjdIvIZH4l68UaQAylr3HT6XvxWxXHNnzK/VRFR+VE0GZL7t72PKGxNzeLV3ReAm1uG
+        qKqLqPopJmeM1+QwiRPf42pp769z2t1blm1UcMXEMOLpomHEwRjxYkEWs5QnZ8Z11Unyj20LxLKM
+        15BlcQNIm0zacsEX265JnBCviIOsWRYXJY1jOXN2JuzakvLo8u57UekNVdedoLIQLjXFTwYkfMu2
+        r1vKSXkK1ZhP6y6WlWTL7kX+Wg/RZiH+1P9JXncst2/G/0zhShbvJXjYwh/kXqjLSQcfoioYj5uf
+        0iSpR46krmvhwx4l9zdCTu1TnoWxDO5DkLsKlXy5kN8gAvKIhz0V9cfYje9ncOad2ZF3QqqYDgTl
+        GAs9/8Z4KSAhgheHK8x4T/qh9tqVgl3d43Syt3cKh2ob+byCl6nRPfjkA1kv+SGFYWrD1I/D1LZj
+        mPr4uWFqXZh6YpwPw9Ias3RP8QXjrRgpMFJg3BsjBc8qBRfsf+L4LEul3N6Rga8sE7sPk4FqLQsA
+        j3FPyEF1JXXwqmTAm+oUPaLtrAnbjFtTDre7tSUDou8OFYs/F1lL2BnO+Cdx5uc0XBnDZw8fpL+p
+        0wOt5IYBMfEoVAGpzR5ouLzCWf9FlzocJmxwkN4jn7LnkpTmmXT3O8nYJ3RRFB47jtzwvGNZf95x
+        caJ7vdHg2043lohCSruM0dDEaEDnrfHrjgZDnq/YzljUn/caS2EshbEUjZai2KyJDAXLc25hIaol
+        vZIvHDsmOZb1flGfW+mtBy8KFq2U/EhTcqyxO98Xh04c4nOcheuEtK32gCosED/pqmKDvCDar09m
+        iCXMHwjVop8I++eUZBag8zvt7a+1PM9jYJp0uzEVYiPA5LLpZXvbVAhMxcRYDGMxjMUwFsNYDGMx
+        jhSUW4y8CMZ2xN1WzImFUenmxOJyjYlDmTjUg8ehRCcWhS/1Sr0nL6CkJ4gCFZIMTdH892uywftA
+        uNGQdfN2xwtxZXZTU++yv7i4sr77ij49wt/j2+dIrFmrvc0csLM5UwPhMNsmUex7r4VGbOq3x+td
+        oaGaVtfUX7x2Y1Bx7+FbA6fYMgqb9eE09dOMwkGBIhs/CCQiwJT4PqM/tU9lAvcYaqhbYVf+7T37
+        nUKbHV/iu7J4WsrDyfXKSUt9k/TXPUm+SvpBtDx3hFg7jx959fCFQ1O7Oog+4It3ZO3vd8f15+X/
+        KOm59d57Z/++RZOzkmxoK/L9FVFy0/Eu9ZrghE25XnpHMrzGGa6CFkZZbkx+/In+Jvv336PRX8Kc
+        9Ud/CNMPkoz+8F9/GfnpaJMQMsLherSOSDqi3xsl5Ne9n7AP8zXv5Gv8gwfin/7xT/8Pg0DBamWt
+        FAA=
+    headers:
+      Accept-Ranges:
+      - bytes
+      Access-Control-Allow-Origin:
+      - '*'
+      Cache-Control:
+      - max-age=300
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Length:
+      - '67661'
+      Content-Security-Policy:
+      - default-src 'none'; style-src 'unsafe-inline'; sandbox
+      Content-Type:
+      - text/plain; charset=utf-8
+      Cross-Origin-Resource-Policy:
+      - cross-origin
+      Date:
+      - Sun, 01 Mar 2026 08:56:57 GMT
+      ETag:
+      - W/"75f3774b8a8cfbb51843538461ef3d432db2f2189d8fbe95e640da721367e0a8"
+      Expires:
+      - Sun, 01 Mar 2026 09:01:57 GMT
+      Source-Age:
+      - '32'
+      Strict-Transport-Security:
+      - max-age=31536000
+      Vary:
+      - Authorization,Accept-Encoding
+      Via:
+      - 1.1 varnish
+      X-Cache:
+      - HIT
+      X-Cache-Hits:
+      - '2'
+      X-Content-Type-Options:
+      - nosniff
+      X-Fastly-Request-ID:
+      - 3b3dc3f5fd6aebdc6c7fda65f845ae2912d78d14
+      X-Frame-Options:
+      - deny
+      X-GitHub-Request-Id:
+      - C88F:3EDCFF:29149D:540B3D:69A381B4
+      X-Served-By:
+      - cache-pao-kpao1770062-PAO
+      X-Timer:
+      - S1772355418.570059,VS0,VE0
+      X-XSS-Protection:
+      - 1; mode=block
+    status:
+      code: 200
+      message: OK
+- request:
+    body: null
+    headers:
+      Connection:
+      - close
+      Host:
+      - api.scarf.sh
       User-Agent:
-      - X-USER-AGENT-XXX
+      - CrewAI-Python/1.10.1a1
+    method: GET
+    uri: https://api.scarf.sh/v2/packages/CrewAI/crewai/docs/00f2dad1-8334-4a39-934e-003b2e1146db
+  response:
+    body:
+      string: ''
+    headers:
+      Connection:
+      - close
+      Date:
+      - Sun, 01 Mar 2026 08:56:59 GMT
+      Strict-Transport-Security:
+      - max-age=15724800; includeSubDomains
+      Transfer-Encoding:
+      - chunked
+      x-scarf-request-id:
+      - ebfe5663-7885-41e5-a6c2-70f2ffae60c1
+    status:
+      code: 401
+      message: Unauthorized
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Calculator Assistant.
+      You are a helpful calculator assistant\nYour personal goal is: Help with math
+      calculations"},{"role":"user","content":"What is 5 + 3? Use the calculate_sum
+      tool."}],"model":"gpt-4.1-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"calculate_sum","description":"Add
+      two numbers together.","strict":true,"parameters":{"properties":{"a":{"title":"A","type":"integer"},"b":{"title":"B","type":"integer"}},"required":["a","b"],"type":"object","additionalProperties":false}}}]}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate, zstd
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '568'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.83.0
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - '600'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.5
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAA/41T246bMBB95yuQn2EVSGgub1ttW7WVGq3UzXbVrCxjBnBrbGSbvSjKv68xCZBs
+        KpUHMHPmcuaMZ+f5PmIZWvmIlsTQqubhzad7k39NH9Y3108v339tNnf18rZ8KPQXIWIUtBEy/QPU
+        HKOuqLRxYJgUHUwVEANt1mg+j6dJMouWDqhkBrwNK2oTzq6isGKChfEkTsLJLIxmh/BSMgra+v22
+        v76/c++WqMjgxZonwdFSgdakAGs7Olmjkry1IKI104YIg4IBpFIYEC130XA+AoyUHFPC+VC4e3aj
+        86CWdcTXH5/zdVqtf27u5Lf5IrvdpM+fP/y4H9XrUr/WjlDeCNqrNMJ7++qsmMUEqeBQkDbcyop1
+        U50lsG5EFU1l+2rJo90WkS1aJcEWpfY73aMT97136fw40kJB3mjC34tEhJCGtFydSo8HZN8PhMui
+        VjLVZ6Eot4PWJbYXQ7s+x3J7RyKOAmpOJopsuqo22Mi/4Iou5l1SNNy6AYwWB9BYmnxknyTBhXQ4
+        A0OYm3h/ySihJWRD6HDZSJMxOQK8Uevv2VzK3bXPRPE/6QeAUqjtPuFaQcboaceDm4J2Kf/l1ovs
+        CCMN6skuGTYMVDuODHLS8G5TkH7VBipsZ1aAqhVz64LyGpPpMspjCjBB3t57A/YiIKU9BAAA
+    headers:
+      CF-RAY:
+      - 9d56f39d4b2ade03-SJC
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Sun, 01 Mar 2026 08:57:00 GMT
+      Server:
+      - cloudflare
+      Strict-Transport-Security:
+      - max-age=31536000; includeSubDomains; preload
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '408'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      set-cookie:
+      - SET-COOKIE-XXX
+        HttpOnly; Secure; Path=/; Domain=api.openai.com; Expires=Sun, 01 Mar 2026
+        09:27:00 GMT
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - '30000'
+      x-ratelimit-limit-tokens:
+      - '150000000'
+      x-ratelimit-remaining-requests:
+      - '29999'
+      x-ratelimit-remaining-tokens:
+      - '149999957'
+      x-ratelimit-reset-requests:
+      - 2ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Calculator Assistant.
+      You are a helpful calculator assistant\nYour personal goal is: Help with math
+      calculations"},{"role":"user","content":"What is 5 + 3? Use the calculate_sum
+      tool."},{"role":"assistant","content":null,"tool_calls":[{"id":"call_ABwfObmOTVUoJ78dQVbwF6NW","type":"function","function":{"name":"calculate_sum","arguments":"{\"a\":5,\"b\":3}"}}]},{"role":"tool","tool_call_id":"call_ABwfObmOTVUoJ78dQVbwF6NW","name":"calculate_sum","content":"8"},{"role":"user","content":"Analyze
+      the tool result. If requirements are met, provide the Final Answer. Otherwise,
+      call the next tool. Deliver only the answer without meta-commentary."}],"model":"gpt-4.1-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"calculate_sum","description":"Add
+      two numbers together.","strict":true,"parameters":{"properties":{"a":{"title":"A","type":"integer"},"b":{"title":"B","type":"integer"}},"required":["a","b"],"type":"object","additionalProperties":false}}}]}'
+    headers:
       accept:
       - application/json
       accept-encoding:
-      - ACCEPT-ENCODING-XXX
+      - gzip, deflate, zstd
       authorization:
       - AUTHORIZATION-XXX
       connection:
       - keep-alive
       content-length:
-      - '1544'
+      - '1028'
       content-type:
       - application/json
       cookie:
-      - COOKIE-XXX
+      - __cf_bm=z4wwr2pSbTZ_rFqW8pPkkJu.veqgEXMDuPiziGlyc6s-1772355419.7287207-1.0.1.1-AAqPzh9YBZdyrQ28dJK5Aa.eBFkGhwgtN_0ruqdsbAByvgIw3B1ZxDy.iiqnluwplfavtE.q7YhJR1pJE2JXT155o7U238B4.Jk5e4cAE56SrBLRr0tOP7htt5rr8IfD
       host:
       - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.83.0
       x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
+      - arm64
       x-stainless-async:
       - 'false'
       x-stainless-lang:
       - python
       x-stainless-os:
-      - X-STAINLESS-OS-XXX
+      - MacOS
       x-stainless-package-version:
       - 1.83.0
       x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
+      - '600'
       x-stainless-retry-count:
       - '0'
       x-stainless-runtime:
       - CPython
       x-stainless-runtime-version:
-      - 3.13.3
+      - 3.13.5
     method: POST
     uri: https://api.openai.com/v1/chat/completions
   response:
     body:
-      string: "{\n  \"id\": \"chatcmpl-D2gT0RU66XqjAUOXnGmokD1Q8Fman\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1769532270,\n  \"model\": \"gpt-4.1-mini-2025-04-14\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"```\\nThought: I now know the final
-        answer\\nFinal Answer: 8\\n```\",\n        \"refusal\": null,\n        \"annotations\":
-        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
-        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 345,\n    \"completion_tokens\":
-        18,\n    \"total_tokens\": 363,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
-        0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
-        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
-        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
-        \"default\",\n  \"system_fingerprint\": \"fp_376a7ccef1\"\n}\n"
+      string: !!binary |
+        H4sIAAAAAAAA/41SQW7CMBC884rIZ4JICKX0VoneObTiUKHIOJvg4tjG3qBWiL/XdoCElkq9WPLO
+        znhmvcdBFBFekKeIsC1FVmsRL15WWPEHxYx8na0O++Vm//acLZpdKmBJhp6hNh/A8MIaMeV4gFzJ
+        FmYGKIJXTWazdDKdZuk4ALUqQHhapTHORklcc8njdJxO43EWJ9mZvlWcgXV97+4aRcdweqOygE9X
+        DmKhUoO1tAJXuzS5olHCVwi1llukEsmwA5mSCDJ4f+zXDZSNpd6cbIToAVRKhdSHC47WZ+R09SBU
+        pY3a2B9UUrpsdpu7WVg3GPeeRaVJQE/uXIeszY194oRqjTmqHYTnkmze6pFuxh2anjF0BkWPNE2G
+        d+TyApByYXvDIoyyLRQdtZssbQquesCgF/q3mXvabXAuq//IdwBjoN3y5NpAwdlt4K7NgN/Av9qu
+        Qw6GiQVzcBuVIwfjP6KAkjaiXQtivyxCnbvfqsBow9vdKHVOJ/OkTBnAmAxOg29isiP6KgMAAA==
     headers:
       CF-RAY:
-      - CF-RAY-XXX
+      - 9d56f3a0b95fde03-SJC
       Connection:
       - keep-alive
+      Content-Encoding:
+      - gzip
       Content-Type:
       - application/json
       Date:
-      - Tue, 27 Jan 2026 16:44:31 GMT
+      - Sun, 01 Mar 2026 08:57:00 GMT
       Server:
       - cloudflare
       Strict-Transport-Security:
-      - STS-XXX
+      - max-age=31536000; includeSubDomains; preload
       Transfer-Encoding:
       - chunked
       X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
+      - nosniff
       access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
+      - X-Request-ID
       alt-svc:
       - h3=":443"; ma=86400
       cf-cache-status:
@@ -219,7 +2992,7 @@ interactions:
       openai-organization:
       - OPENAI-ORG-XXX
       openai-processing-ms:
-      - '606'
+      - '312'
       openai-project:
       - OPENAI-PROJECT-XXX
       openai-version:
@@ -227,17 +3000,17 @@ interactions:
       x-openai-proxy-wasm:
       - v0.1
       x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      - '30000'
       x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      - '150000000'
       x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      - '29999'
       x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      - '149999915'
       x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
+      - 2ms
       x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
+      - 0s
       x-request-id:
       - X-REQUEST-ID-XXX
     status:

From 28d460c651bf3415f4af9c67a961d6f51d7a7410 Mon Sep 17 00:00:00 2001
From: Joao Moura <joaomdmoura@gmail.com>
Date: Sun, 1 Mar 2026 02:39:20 -0800
Subject: [PATCH 2/4] fix

---
 lib/crewai/src/crewai/lite_agent.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/crewai/src/crewai/lite_agent.py b/lib/crewai/src/crewai/lite_agent.py
index 1d932a8f3d..22509f50e6 100644
--- a/lib/crewai/src/crewai/lite_agent.py
+++ b/lib/crewai/src/crewai/lite_agent.py
@@ -914,7 +914,7 @@ def _invoke_loop_native_tools(
         Returns:
             AgentFinish: The final result of the agent execution.
         """
-        openai_tools, available_functions = convert_tools_to_openai_schema(
+        openai_tools, available_functions, _ = convert_tools_to_openai_schema(
             self.tools
         )
 

From 690d00198cf13fa4557d635a5ad885bfea90ccc9 Mon Sep 17 00:00:00 2001
From: Joao Moura <joaomdmoura@gmail.com>
Date: Sun, 1 Mar 2026 03:03:31 -0800
Subject: [PATCH 3/4] refactor: streamline LiteAgent tool handling and enhance
 after-LLM call hooks

- Simplified the conversion of tools to OpenAI schema by removing redundant mapping.
- Updated the after-LLM call hooks to support list-type answers, ensuring native tool calls are returned unchanged.
- Added tests to verify correct usage count for native tools and ensure proper handling of duplicate tool names.
- Enhanced existing tests to confirm functionality with after-LLM hooks active, addressing previous issues with tool call processing.
---
 lib/crewai/src/crewai/lite_agent.py           |  11 +-
 .../src/crewai/utilities/agent_utils.py       |  19 ++-
 lib/crewai/tests/agents/test_lite_agent.py    | 129 ++++++++++++++++++
 3 files changed, 146 insertions(+), 13 deletions(-)

diff --git a/lib/crewai/src/crewai/lite_agent.py b/lib/crewai/src/crewai/lite_agent.py
index 22509f50e6..8093a06d3c 100644
--- a/lib/crewai/src/crewai/lite_agent.py
+++ b/lib/crewai/src/crewai/lite_agent.py
@@ -914,14 +914,10 @@ def _invoke_loop_native_tools(
         Returns:
             AgentFinish: The final result of the agent execution.
         """
-        openai_tools, available_functions, _ = convert_tools_to_openai_schema(
-            self.tools
+        openai_tools, available_functions, original_tools_by_name = (
+            convert_tools_to_openai_schema(self.tools)
         )
 
-        original_tools_by_name: dict[str, BaseTool] = {
-            sanitize_tool_name(t.name): t for t in self.tools
-        }
-
         while True:
             try:
                 if has_reached_max_iterations(self._iterations, self.max_iterations):
@@ -1348,9 +1344,6 @@ def _execute_native_tool_call(
                     color="red",
                 )
 
-        if original_tool:
-            original_tool.current_usage_count += 1
-
         if not error_event_emitted:
             crewai_event_bus.emit(
                 self,
diff --git a/lib/crewai/src/crewai/utilities/agent_utils.py b/lib/crewai/src/crewai/utilities/agent_utils.py
index e4f3d3fee1..2077b595c5 100644
--- a/lib/crewai/src/crewai/utilities/agent_utils.py
+++ b/lib/crewai/src/crewai/utilities/agent_utils.py
@@ -1245,26 +1245,34 @@ def _setup_before_llm_call_hooks(
 
 def _setup_after_llm_call_hooks(
     executor_context: CrewAgentExecutor | AgentExecutor | LiteAgent | None,
-    answer: str | BaseModel,
+    answer: str | BaseModel | list[Any],
     printer: Printer,
     verbose: bool = True,
-) -> str | BaseModel:
+) -> str | BaseModel | list[Any]:
     """Setup and invoke after_llm_call hooks for the executor context.
 
     Args:
         executor_context: The executor context to setup the hooks for.
-        answer: The LLM response (string or Pydantic model).
+        answer: The LLM response (string, Pydantic model, or list of native
+            tool calls).
         printer: Printer instance for error logging.
         verbose: Whether to print output.
 
     Returns:
-        The potentially modified response (string or Pydantic model).
+        The potentially modified response. List-type answers (native tool
+        calls) are always returned unchanged so that callers can rely on
+        ``isinstance(answer, list)`` checks.
     """
     if executor_context and executor_context.after_llm_call_hooks:
         from crewai.hooks.llm_hooks import LLMCallHookContext
 
         original_messages = executor_context.messages
 
+        # Native tool-call lists must survive hooks unchanged.  We provide a
+        # stringified representation to hook context for observability but
+        # always return the original list so callers can detect tool calls.
+        is_tool_call_list = isinstance(answer, list)
+
         # For Pydantic models, serialize to JSON for hooks
         if isinstance(answer, BaseModel):
             pydantic_answer = answer
@@ -1303,6 +1311,9 @@ def _setup_after_llm_call_hooks(
             else:
                 executor_context.messages = []
 
+        if is_tool_call_list:
+            return answer
+
         # If hooks modified the response, update answer accordingly
         if pydantic_answer is not None:
             # For Pydantic models, reparse the JSON if it was modified
diff --git a/lib/crewai/tests/agents/test_lite_agent.py b/lib/crewai/tests/agents/test_lite_agent.py
index ae355b3383..b795b06533 100644
--- a/lib/crewai/tests/agents/test_lite_agent.py
+++ b/lib/crewai/tests/agents/test_lite_agent.py
@@ -1343,3 +1343,132 @@ def test_lite_agent_native_parallel_tool_calls():
     ]
     assert len(assistant_tc_messages) == 1
     assert len(assistant_tc_messages[0]["tool_calls"]) == 2
+
+
+def test_lite_agent_native_tool_usage_count_no_double_increment():
+    """current_usage_count must increment exactly once per native tool call.
+
+    BaseTool.run() already increments the counter internally, so the native
+    tool call handler must not add a second increment.
+    """
+    tool_call = [_make_openai_tool_call("call_1", "calculate", '{"expression": "1+1"}')]
+
+    llm = _NativeToolCallLLM(tool_calls=[tool_call], final_answer="2")
+    calc_tool = CalculatorTool()
+    assert calc_tool.current_usage_count == 0
+
+    agent = LiteAgent(
+        role="Calculator", goal="Compute", backstory="Math agent",
+        llm=llm, tools=[calc_tool],
+    )
+    agent.kickoff("What is 1+1?")
+
+    assert calc_tool.current_usage_count == 1
+
+
+def test_lite_agent_native_tool_max_usage_count_respected():
+    """A tool with max_usage_count=1 should be usable exactly once, not blocked after 1 call."""
+    call_round_1 = [_make_openai_tool_call("c1", "calculate", '{"expression": "1+1"}')]
+    call_round_2 = [_make_openai_tool_call("c2", "calculate", '{"expression": "2+2"}')]
+
+    llm = _NativeToolCallLLM(
+        tool_calls=[call_round_1, call_round_2], final_answer="done"
+    )
+    calc_tool = CalculatorTool()
+    calc_tool.max_usage_count = 2
+
+    agent = LiteAgent(
+        role="Calculator", goal="Compute", backstory="Math agent",
+        llm=llm, tools=[calc_tool],
+    )
+    agent.kickoff("Compute 1+1 then 2+2")
+
+    executed = [r for r in agent.tools_results if "usage limit" not in r["result"]]
+    assert len(executed) == 2
+    assert calc_tool.current_usage_count == 2
+
+
+def test_lite_agent_native_tool_calls_with_after_llm_hook():
+    """Native tool calls must be processed even when after_llm_call hooks are active.
+
+    Regression test: _setup_after_llm_call_hooks was converting the list of
+    tool calls to a string via str(), causing isinstance(answer, list) to fail
+    in _invoke_loop_native_tools and silently returning the stringified list as
+    the agent's final answer.
+    """
+    hook_called = {"count": 0}
+
+    def after_hook(context):
+        hook_called["count"] += 1
+        return None
+
+    tool_call = [_make_openai_tool_call("call_1", "calculate", '{"expression": "6*7"}')]
+
+    llm = _NativeToolCallLLM(tool_calls=[tool_call], final_answer="The answer is 42")
+    agent = LiteAgent(
+        role="Calculator", goal="Compute", backstory="Math agent",
+        llm=llm, tools=[CalculatorTool()],
+    )
+    agent._after_llm_call_hooks.append(after_hook)
+
+    result = agent.kickoff("What is 6 * 7?")
+
+    assert hook_called["count"] >= 1
+    assert len(agent.tools_results) == 1
+    assert agent.tools_results[0]["tool_name"] == "calculate"
+    assert "42" in result.raw
+
+
+def test_lite_agent_native_parallel_tool_calls_with_after_llm_hook():
+    """Multiple native tool calls in a single response must work with hooks active."""
+    hook_called = {"count": 0}
+
+    def after_hook(context):
+        hook_called["count"] += 1
+        return None
+
+    tool_calls = [
+        _make_openai_tool_call("call_1", "calculate", '{"expression": "2+3"}'),
+        _make_openai_tool_call("call_2", "calculate", '{"expression": "4+5"}'),
+    ]
+
+    llm = _NativeToolCallLLM(tool_calls=[tool_calls], final_answer="5 and 9")
+    agent = LiteAgent(
+        role="Calculator", goal="Compute", backstory="Math agent",
+        llm=llm, tools=[CalculatorTool()],
+    )
+    agent._after_llm_call_hooks.append(after_hook)
+
+    result = agent.kickoff("What is 2+3 and 4+5?")
+
+    assert hook_called["count"] >= 1
+    assert len(agent.tools_results) == 2
+    tool_names = [r["tool_name"] for r in agent.tools_results]
+    assert tool_names == ["calculate", "calculate"]
+
+
+def test_lite_agent_native_duplicate_tool_names_resolved():
+    """Two tools with the same sanitized name should both be usable via dedup suffixes.
+
+    convert_tools_to_openai_schema renames duplicates (e.g. calculate -> calculate_2).
+    The original_tools_by_name mapping must honour these deduplicated names so
+    result_as_answer, max_usage_count, and usage tracking work for every tool.
+    """
+    tool_a = CalculatorTool()
+    tool_a.result_as_answer = True
+
+    tool_b = CalculatorTool()
+
+    tool_call = [
+        _make_openai_tool_call("c1", "calculate_2", '{"expression": "9+1"}'),
+    ]
+    llm = _NativeToolCallLLM(tool_calls=[tool_call], final_answer="fallback")
+    agent = LiteAgent(
+        role="Calculator", goal="Compute", backstory="Math agent",
+        llm=llm, tools=[tool_a, tool_b],
+    )
+    result = agent.kickoff("What is 9+1?")
+
+    assert len(agent.tools_results) == 1
+    assert agent.tools_results[0]["tool_name"] == "calculate_2"
+    assert "10" in agent.tools_results[0]["result"]

From d2a5256ca3271c0e5ec230f0c6bea6cfe6d6d334 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jo=C3=A3o=20Moura?= <joaomdmoura@gmail.com>
Date: Sun, 1 Mar 2026 15:21:08 -0300
Subject: [PATCH 4/4] Potential fix for pull request finding 'Unused local
 variable'

Co-authored-by: Copilot Autofix powered by AI <223894421+github-code-quality[bot]@users.noreply.github.com>
---
 lib/crewai/tests/agents/test_lite_agent.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/crewai/tests/agents/test_lite_agent.py b/lib/crewai/tests/agents/test_lite_agent.py
index b795b06533..7525e60dec 100644
--- a/lib/crewai/tests/agents/test_lite_agent.py
+++ b/lib/crewai/tests/agents/test_lite_agent.py
@@ -1439,7 +1439,7 @@ def after_hook(context):
     )
     agent._after_llm_call_hooks.append(after_hook)
 
-    result = agent.kickoff("What is 2+3 and 4+5?")
+    agent.kickoff("What is 2+3 and 4+5?")
 
     assert hook_called["count"] >= 1
     assert len(agent.tools_results) == 2