diff --git a/autogen/agentchat/groupchat.py b/autogen/agentchat/groupchat.py
index 5dc64e7f8076..8b9f5d0b4931 100644
--- a/autogen/agentchat/groupchat.py
+++ b/autogen/agentchat/groupchat.py
@@ -2,16 +2,27 @@
 import random
 import re
 import sys
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Dict, List, Optional, Union, Tuple
 
+
 from ..code_utils import content_str
 from .agent import Agent
 from .conversable_agent import ConversableAgent
+from ..graph_utils import check_graph_validity, invert_disallowed_to_allowed, has_self_loops
+
 
 logger = logging.getLogger(__name__)
 
 
+class NoEligibleSpeakerException(Exception):
+    """Exception raised for early termination of a GroupChat."""
+
+    def __init__(self, message="No eligible speakers."):
+        self.message = message
+        super().__init__(self.message)
+
+
 @dataclass
 class GroupChat:
     """(In preview) A group chat class that contains the following data fields:
@@ -30,7 +41,10 @@ class GroupChat:
         - "manual": the next speaker is selected manually by user input.
         - "random": the next speaker is selected randomly.
         - "round_robin": the next speaker is selected in a round robin fashion, i.e., iterating in the same order as provided in `agents`.
-    - allow_repeat_speaker: whether to allow the same speaker to speak consecutively. Default is True, in which case all speakers are allowed to speak consecutively. If allow_repeat_speaker is a list of Agents, then only those listed agents are allowed to repeat. If set to False, then no speakers are allowed to repeat.
+
+    - allow_repeat_speaker: whether to allow the same speaker to speak consecutively. Default is True, in which case all speakers are allowed to speak consecutively. If allow_repeat_speaker is a list of Agents, then only those listed agents are allowed to repeat. If set to False, then no speakers are allowed to repeat. allow_repeat_speaker and allowed_or_disallowed_speaker_transitions are mutually exclusive.
+    - allowed_or_disallowed_speaker_transitions: a dictionary of keys and list as values. The keys are the source agents, and the values are the agents that the key agent can transition to. Default is None, in which case a fully connected allowed_speaker_transitions_dict is assumed. allow_repeat_speaker and allowed_or_disallowed_speaker_transitions are mutually exclusive.
+    - speaker_transitions_type: whether the speaker_transitions_type is a dictionary containing lists of allowed agents or disallowed agents. allowed means the allowed_or_disallowed_speaker_transitions is a dictionary containing lists of allowed agents. If set to disallowed, then the allowed_or_disallowed_speaker_transitions is a dictionary containing lists of disallowed agents. Must be supplied if allowed_or_disallowed_speaker_transitions is not None.
     - enable_clear_history: enable possibility to clear history of messages for agents manually by providing
         "clear history" phrase in user prompt. This is experimental feature.
         See description of GroupChatManager.clear_agents_history function for more info.
@@ -42,10 +56,95 @@ class GroupChat:
     admin_name: Optional[str] = "Admin"
     func_call_filter: Optional[bool] = True
     speaker_selection_method: Optional[str] = "auto"
-    allow_repeat_speaker: Optional[Union[bool, List[Agent]]] = True
+    allow_repeat_speaker: Optional[
+        Union[bool, List[Agent]]
+    ] = True  # It would be set to True if allowed_or_disallowed_speaker_transitions is None
+    allowed_or_disallowed_speaker_transitions: Optional[Dict] = None
+    speaker_transitions_type: Optional[str] = None
     enable_clear_history: Optional[bool] = False
 
     _VALID_SPEAKER_SELECTION_METHODS = ["auto", "manual", "random", "round_robin"]
+    _VALID_SPEAKER_TRANSITIONS_TYPE = ["allowed", "disallowed", None]
+
+    allowed_speaker_transitions_dict: Dict = field(init=False)
+
+    def __post_init__(self):
+        # Post init steers clears of the automatically generated __init__ method from dataclass
+        # Here, we create allowed_speaker_transitions_dict from the supplied allowed_or_disallowed_speaker_transitions and is_allowed_graph, and lastly checks for validity.
+
+        # Check input
+        if self.speaker_transitions_type is not None:
+            self.speaker_transitions_type = self.speaker_transitions_type.lower()
+
+        assert self.speaker_transitions_type in self._VALID_SPEAKER_TRANSITIONS_TYPE, (
+            f"GroupChat speaker_transitions_type is set to '{self.speaker_transitions_type}'. "
+            f"It should be one of {self._VALID_SPEAKER_TRANSITIONS_TYPE} (case insensitive). "
+        )
+
+        # If both self.allowed_or_disallowed_speaker_transitions is None and self.allow_repeat_speaker is None, set allow_repeat_speaker to True to ensure backward compatibility
+        # Discussed in https://github.com/microsoft/autogen/pull/857#discussion_r1451541204
+        if self.allowed_or_disallowed_speaker_transitions is None and self.allow_repeat_speaker is None:
+            self.allow_repeat_speaker = True
+
+        # self.allowed_or_disallowed_speaker_transitions and self.allow_repeat_speaker are mutually exclusive parameters.
+        # Discussed in https://github.com/microsoft/autogen/pull/857#discussion_r1451266661
+        if self.allowed_or_disallowed_speaker_transitions is not None and self.allow_repeat_speaker is not None:
+            raise ValueError(
+                "Don't provide both allowed_or_disallowed_speaker_transitions and allow_repeat_speaker in group chat. "
+                "Please set one of them to None."
+            )
+
+        # Asks the user to specify whether the speaker_transitions_type is allowed or disallowed if speaker_transitions_type is supplied
+        # Discussed in https://github.com/microsoft/autogen/pull/857#discussion_r1451259524
+        if self.allowed_or_disallowed_speaker_transitions is not None and self.speaker_transitions_type is None:
+            raise ValueError(
+                "GroupChat allowed_or_disallowed_speaker_transitions is not None, but speaker_transitions_type is None. "
+                "Please set speaker_transitions_type to either 'allowed' or 'disallowed'."
+            )
+
+        # Inferring self.allowed_speaker_transitions_dict
+        # Create self.allowed_speaker_transitions_dict if allowed_or_disallowed_speaker_transitions is None, using allow_repeat_speaker
+        if self.allowed_or_disallowed_speaker_transitions is None:
+            self.allowed_speaker_transitions_dict = {}
+
+            # Create a fully connected allowed_speaker_transitions_dict not including self loops
+            for agent in self.agents:
+                self.allowed_speaker_transitions_dict[agent] = [
+                    other_agent for other_agent in self.agents if other_agent != agent
+                ]
+
+            # If self.allow_repeat_speaker is True, add self loops to all agents
+            if self.allow_repeat_speaker:
+                for agent in self.agents:
+                    self.allowed_speaker_transitions_dict[agent].append(agent)
+
+            # Else if self.allow_repeat_speaker is a list of Agents, add self loops to the agents in the list
+            elif isinstance(self.allow_repeat_speaker, list):
+                for agent in self.allow_repeat_speaker:
+                    self.allowed_speaker_transitions_dict[agent].append(agent)
+
+        # Create self.allowed_speaker_transitions_dict if allowed_or_disallowed_speaker_transitions is not None, using allowed_or_disallowed_speaker_transitions
+        else:
+            # Process based on is_allowed_graph
+            if self.speaker_transitions_type == "allowed":
+                self.allowed_speaker_transitions_dict = self.allowed_or_disallowed_speaker_transitions
+            else:
+                # Logic for processing disallowed allowed_or_disallowed_speaker_transitions to allowed_speaker_transitions_dict
+                self.allowed_speaker_transitions_dict = invert_disallowed_to_allowed(
+                    self.allowed_or_disallowed_speaker_transitions, self.agents
+                )
+
+        # Inferring self.allow_repeat_speaker from allowed_speaker_transitions_dict using has_self_loops
+        # Finally, self.allow_repeat_speaker shouldn't be None, so it is set from the the graph.
+        if self.allow_repeat_speaker is None:
+            self.allow_repeat_speaker = has_self_loops(self.allowed_speaker_transitions_dict)
+
+        # Check for validity
+        check_graph_validity(
+            allowed_speaker_transitions_dict=self.allowed_speaker_transitions_dict,
+            agents=self.agents,
+            allow_repeat_speaker=self.allow_repeat_speaker,
+        )
 
     @property
     def agent_names(self) -> List[str]:
@@ -134,6 +233,12 @@ def manual_select_speaker(self, agents: Optional[List[Agent]] = None) -> Union[A
                 print(f"Invalid input. Please enter a number between 1 and {_n_agents}.")
         return None
 
+    def random_select_speaker(self, agents: Optional[List[Agent]] = None) -> Union[Agent, None]:
+        """Randomly select the next speaker."""
+        if agents is None:
+            agents = self.agents
+        return random.choice(agents)
+
     def _prepare_and_select_agents(
         self, last_speaker: Agent
     ) -> Tuple[Optional[Agent], List[Agent], Optional[List[Dict]]]:
@@ -198,13 +303,40 @@ def _prepare_and_select_agents(
         # remove the last speaker from the list to avoid selecting the same speaker if allow_repeat_speaker is False
         agents = agents if allow_repeat_speaker else [agent for agent in agents if agent != last_speaker]
 
+        # Filter agents with allowed_speaker_transitions_dict
+
+        is_last_speaker_in_group = last_speaker in self.agents
+
+        # this condition means last_speaker is a sink in the graph, then no agents are eligible
+        if last_speaker not in self.allowed_speaker_transitions_dict and is_last_speaker_in_group:
+            raise NoEligibleSpeakerException(
+                f"Last speaker {last_speaker.name} is not in the allowed_speaker_transitions_dict."
+            )
+        # last_speaker is not in the group, so all agents are eligible
+        elif last_speaker not in self.allowed_speaker_transitions_dict and not is_last_speaker_in_group:
+            graph_eligible_agents = []
+        else:
+            # Extract agent names from the list of agents
+            graph_eligible_agents = [
+                agent for agent in agents if agent in self.allowed_speaker_transitions_dict[last_speaker]
+            ]
+
+        # If there is only one eligible agent, just return it to avoid the speaker selection prompt
+        if len(graph_eligible_agents) == 1:
+            return graph_eligible_agents[0], graph_eligible_agents, None
+
+        # If there are no eligible agents, return None, which means all agents will be taken into consideration in the next step
+        if len(graph_eligible_agents) == 0:
+            graph_eligible_agents = None
+
+        # Use the selected speaker selection method
         select_speaker_messages = None
         if self.speaker_selection_method.lower() == "manual":
-            selected_agent = self.manual_select_speaker(agents)
+            selected_agent = self.manual_select_speaker(graph_eligible_agents)
         elif self.speaker_selection_method.lower() == "round_robin":
-            selected_agent = self.next_agent(last_speaker, agents)
+            selected_agent = self.next_agent(last_speaker, graph_eligible_agents)
         elif self.speaker_selection_method.lower() == "random":
-            selected_agent = random.choice(agents)
+            selected_agent = self.random_select_speaker(graph_eligible_agents)
         else:
             selected_agent = None
             select_speaker_messages = self.messages.copy()
@@ -214,11 +346,11 @@ def _prepare_and_select_agents(
             if select_speaker_messages[-1].get("tool_calls", False):
                 select_speaker_messages[-1] = dict(select_speaker_messages[-1], tool_calls=None)
             select_speaker_messages = select_speaker_messages + [
-                {"role": "system", "content": self.select_speaker_prompt(agents)}
+                {"role": "system", "content": self.select_speaker_prompt(graph_eligible_agents)}
             ]
-        return selected_agent, agents, select_speaker_messages
+        return selected_agent, graph_eligible_agents, select_speaker_messages
 
-    def select_speaker(self, last_speaker: Agent, selector: ConversableAgent):
+    def select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Agent:
         """Select the next speaker."""
         selected_agent, agents, messages = self._prepare_and_select_agents(last_speaker)
         if selected_agent:
@@ -228,7 +360,7 @@ def select_speaker(self, last_speaker: Agent, selector: ConversableAgent):
         final, name = selector.generate_oai_reply(messages)
         return self._finalize_speaker(last_speaker, final, name, agents)
 
-    async def a_select_speaker(self, last_speaker: Agent, selector: ConversableAgent):
+    async def a_select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Agent:
         """Select the next speaker."""
         selected_agent, agents, messages = self._prepare_and_select_agents(last_speaker)
         if selected_agent:
@@ -238,7 +370,7 @@ async def a_select_speaker(self, last_speaker: Agent, selector: ConversableAgent
         final, name = await selector.a_generate_oai_reply(messages)
         return self._finalize_speaker(last_speaker, final, name, agents)
 
-    def _finalize_speaker(self, last_speaker: Agent, final: bool, name: str, agents: List[Agent]) -> Agent:
+    def _finalize_speaker(self, last_speaker: Agent, final: bool, name: str, agents: Optional[List[Agent]]) -> Agent:
         if not final:
             # the LLM client is None, thus no reply is generated. Use round robin instead.
             return self.next_agent(last_speaker, agents)
@@ -272,7 +404,7 @@ def _participant_roles(self, agents: List[Agent] = None) -> str:
             roles.append(f"{agent.name}: {agent.description}".strip())
         return "\n".join(roles)
 
-    def _mentioned_agents(self, message_content: Union[str, List], agents: List[Agent]) -> Dict:
+    def _mentioned_agents(self, message_content: Union[str, List], agents: Optional[List[Agent]]) -> Dict:
         """Counts the number of times each agent is mentioned in the provided message content.
 
         Args:
@@ -282,6 +414,9 @@ def _mentioned_agents(self, message_content: Union[str, List], agents: List[Agen
         Returns:
             Dict: a counter for mentioned agents.
         """
+        if agents is None:
+            agents = self.agents
+
         # Cast message content to str
         if isinstance(message_content, dict):
             message_content = message_content["content"]
@@ -387,6 +522,10 @@ def run_chat(
                 else:
                     # admin agent is not found in the participants
                     raise
+            except NoEligibleSpeakerException:
+                # No eligible speaker, terminate the conversation
+                break
+
             if reply is None:
                 # no reply is generated, exit the chat
                 break
diff --git a/autogen/graph_utils.py b/autogen/graph_utils.py
new file mode 100644
index 000000000000..e89b6d86031a
--- /dev/null
+++ b/autogen/graph_utils.py
@@ -0,0 +1,138 @@
+from typing import Dict, List, Optional, Union
+import logging
+
+from autogen.agentchat.groupchat import Agent
+
+
+def has_self_loops(allowed_speaker_transitions: dict) -> bool:
+    """
+    Returns True if there are self loops in the allowed_speaker_transitions_dict.
+    """
+    return any([key in value for key, value in allowed_speaker_transitions.items()])
+
+
+def check_graph_validity(
+    allowed_speaker_transitions_dict: dict,
+    agents: List[Agent],
+    allow_repeat_speaker: Optional[Union[bool, List[Agent]]] = True,
+):
+    """
+    allowed_speaker_transitions_dict: A dictionary of keys and list as values. The keys are the names of the agents, and the values are the names of the agents that the key agent can transition to.
+    agents: A list of Agents
+    allow_repeat_speaker: A boolean indicating whether the same agent can speak twice in a row.
+
+    Checks for the following:
+        Errors
+        1. The dictionary must have a structure of keys and list as values
+        2. Every key exists in agents.
+        3. Every value is a list of Agents (not string).
+
+        Warnings
+        1. Warning if there are isolated agent nodes
+        2. Warning if the set of agents in allowed_speaker_transitions do not match agents
+        3. Warning if there are duplicated agents in any values of `allowed_speaker_transitions_dict`
+    """
+
+    ### Errors
+
+    # Check 1. The dictionary must have a structure of keys and list as values
+    if not isinstance(allowed_speaker_transitions_dict, dict):
+        raise ValueError("allowed_speaker_transitions_dict must be a dictionary.")
+
+    # All values must be lists of Agent or empty
+    if not all([isinstance(value, list) or value == [] for value in allowed_speaker_transitions_dict.values()]):
+        raise ValueError("allowed_speaker_transitions_dict must be a dictionary of keys and list as values.")
+
+    # Check 2. Every key exists in agents
+    if not all([key in agents for key in allowed_speaker_transitions_dict.keys()]):
+        raise ValueError("allowed_speaker_transitions_dict has keys not in agents' names.")
+
+    # Check 3. Every value is a list of Agents or empty list (not string).
+    if not all(
+        [all([isinstance(agent, Agent) for agent in value]) for value in allowed_speaker_transitions_dict.values()]
+    ):
+        raise ValueError("allowed_speaker_transitions_dict has values that are not lists of Agents.")
+
+    # Warnings
+    # Warning 1. Warning if there are isolated agent nodes, there are not incoming nor outgoing edges
+    # Concat keys if len(value) is positive
+    has_outgoing_edge = []
+    for key, agent_list in allowed_speaker_transitions_dict.items():
+        if len(agent_list) > 0:
+            has_outgoing_edge.append(key)
+    no_outgoing_edges = [agent for agent in agents if agent not in has_outgoing_edge]
+
+    # allowed_speaker_transitions_dict.values() is a list of list of Agents
+    # values_all_agents is a list of all agents in allowed_speaker_transitions_dict.values()
+    has_incoming_edge = []
+    for agent_list in allowed_speaker_transitions_dict.values():
+        if len(agent_list) > 0:
+            has_incoming_edge.extend(agent_list)
+
+    no_incoming_edges = [agent for agent in agents if agent not in has_incoming_edge]
+
+    isolated_agents = set(no_incoming_edges).intersection(set(no_outgoing_edges))
+    if len(isolated_agents) > 0:
+        logging.warning(
+            f"""Warning: There are isolated agent nodes, there are not incoming nor outgoing edges. Isolated agents: {[agent.name for agent in isolated_agents]}"""
+        )
+
+    # Warning 2. Warning if the set of agents in allowed_speaker_transitions do not match agents
+    # Get set of agents
+    agents_in_allowed_speaker_transitions = set(has_incoming_edge).union(set(has_outgoing_edge))
+    full_anti_join = set(agents_in_allowed_speaker_transitions).symmetric_difference(set(agents))
+    if len(full_anti_join) > 0:
+        logging.warning(
+            f"""Warning: The set of agents in allowed_speaker_transitions do not match agents. Offending agents: {[agent.name for agent in full_anti_join]}"""
+        )
+
+    # Warning 3. Warning if there are duplicated agents in any values of `allowed_speaker_transitions_dict`
+    for key, values in allowed_speaker_transitions_dict.items():
+        duplicates = [item for item in values if values.count(item) > 1]
+        unique_duplicates = list(set(duplicates))
+        if unique_duplicates:
+            logging.warning(
+                f"Agent '{key.name}' has duplicate elements: {[agent.name for agent in unique_duplicates]}. Please remove duplicates manually."
+            )
+
+
+def invert_disallowed_to_allowed(disallowed_speaker_transitions_dict: dict, agents: List[Agent]) -> dict:
+    """
+    Start with a fully connected allowed_speaker_transitions_dict of all agents. Remove edges from the fully connected allowed_speaker_transitions_dict according to the disallowed_speaker_transitions_dict to form the allowed_speaker_transitions_dict.
+    """
+    # Create a fully connected allowed_speaker_transitions_dict of all agents
+    allowed_speaker_transitions_dict = {agent: [other_agent for other_agent in agents] for agent in agents}
+
+    # Remove edges from allowed_speaker_transitions_dict according to the disallowed_speaker_transitions_dict
+    for key, value in disallowed_speaker_transitions_dict.items():
+        allowed_speaker_transitions_dict[key] = [
+            agent for agent in allowed_speaker_transitions_dict[key] if agent not in value
+        ]
+
+    return allowed_speaker_transitions_dict
+
+
+def visualize_speaker_transitions_dict(speaker_transitions_dict: dict, agents: List[Agent]):
+    """
+    Visualize the speaker_transitions_dict using networkx.
+    """
+    try:
+        import networkx as nx
+        import matplotlib.pyplot as plt
+    except ImportError as e:
+        logging.fatal("Failed to import networkx or matplotlib. Try running 'pip install autogen[graphs]'")
+        raise e
+
+    G = nx.DiGraph()
+
+    # Add nodes
+    G.add_nodes_from([agent.name for agent in agents])
+
+    # Add edges
+    for key, value in speaker_transitions_dict.items():
+        for agent in value:
+            G.add_edge(key.name, agent.name)
+
+    # Visualize
+    nx.draw(G, with_labels=True, font_weight="bold")
+    plt.show()
diff --git a/notebook/agentchat_graph_modelling_language_using_select_speaker.ipynb b/notebook/agentchat_graph_modelling_language_using_select_speaker.ipynb
index 894232bbb7b6..abe4249f918e 100644
--- a/notebook/agentchat_graph_modelling_language_using_select_speaker.ipynb
+++ b/notebook/agentchat_graph_modelling_language_using_select_speaker.ipynb
@@ -33,14 +33,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
     "# %pip install \"pyautogen>=0.2.3\"\n",
-    "%pip install networkX~=3.2.1\n",
-    "%pip install matplotlib~=3.8.1"
+    "%pip install pyautogen[graph]"
    ]
   },
   {
@@ -56,7 +55,8 @@
     "\n",
     "import autogen  # noqa E402\n",
     "from autogen.agentchat.assistant_agent import AssistantAgent  # noqa E402\n",
-    "from autogen.agentchat.groupchat import GroupChat  # noqa E402"
+    "from autogen.agentchat.groupchat import GroupChat, Agent  # noqa E402\n",
+    "from autogen.graph_utils import visualize_speaker_transitions_dict  # noqa E402"
    ]
   },
   {
@@ -68,7 +68,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "0.2.3\n"
+      "0.2.5\n"
      ]
     }
    ],
@@ -89,12 +89,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# The default config list in notebook.\n",
+    "config_list_gpt4 = autogen.config_list_from_json(\n",
+    "    \"OAI_CONFIG_LIST\",\n",
+    "    filter_dict={\n",
+    "        \"model\": [\"gpt-4\", \"gpt-4-0314\", \"gpt4\", \"gpt-4-32k\", \"gpt-4-32k-0314\", \"gpt-4-32k-v0314\"],\n",
+    "    },\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -104,37 +119,30 @@
     }
    ],
    "source": [
-    "# Create an empty directed graph\n",
-    "graph = nx.DiGraph()\n",
-    "\n",
-    "# Add 5 nodes to the graph using a for loop\n",
-    "for node_id in range(5):\n",
-    "    graph.add_node(node_id, label=str(node_id))\n",
-    "\n",
-    "# Add edges between all nodes using a nested for loop\n",
-    "for source_node in range(5):\n",
-    "    for target_node in range(5):\n",
-    "        if source_node != target_node:  # To avoid self-loops\n",
-    "            graph.add_edge(source_node, target_node)\n",
+    "agents = [Agent(name=f\"Agent{i}\") for i in range(5)]\n",
+    "allowed_speaker_transitions_dict = {agent: [other_agent for other_agent in agents] for agent in agents}\n",
     "\n",
-    "nx.draw(graph, with_labels=True, font_weight=\"bold\")"
+    "visualize_speaker_transitions_dict(allowed_speaker_transitions_dict, agents)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Possibly interesting transition paths"
+    "### Possibly interesting transition paths\n",
+    "1. Hub and Spoke\n",
+    "2. Sequential Team Operations\n",
+    "3. Think aloud and debate"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -144,33 +152,33 @@
     }
    ],
    "source": [
-    "# Hub and Spoke\n",
-    "# Create an empty directed graph\n",
-    "graph = nx.DiGraph()\n",
-    "\n",
-    "# Add 5 nodes to the graph using a for loop\n",
-    "for node_id in range(5):\n",
-    "    graph.add_node(node_id, label=str(node_id))\n",
-    "\n",
-    "# Add edges between all nodes using a nested for loop\n",
-    "for source_node in range(5):\n",
-    "    target_node = 0\n",
-    "    if source_node != target_node:  # To avoid self-loops\n",
-    "        graph.add_edge(source_node, target_node)\n",
-    "        graph.add_edge(target_node, source_node)\n",
-    "\n",
-    "\n",
-    "nx.draw(graph, with_labels=True, font_weight=\"bold\")"
+    "agents = [Agent(name=f\"Agent{i}\") for i in range(5)]\n",
+    "allowed_speaker_transitions_dict = {\n",
+    "    agents[0]: [agents[1], agents[2], agents[3], agents[4]],\n",
+    "    agents[1]: [agents[0]],\n",
+    "    agents[2]: [agents[0]],\n",
+    "    agents[3]: [agents[0]],\n",
+    "    agents[4]: [agents[0]],\n",
+    "}\n",
+    "\n",
+    "visualize_speaker_transitions_dict(allowed_speaker_transitions_dict, agents)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<autogen.agentchat.agent.Agent object at 0x7fbf958831c0>\n"
+     ]
+    },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAApQAAAHzCAYAAACe1o1DAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAACdWUlEQVR4nOzdd1gUx+MG8HfvDo7emyigCGLv2Bt6aOzRaOwxReM3xfxMT0wxVVNMNMZUE6NRE1ssMTEWFBUbYseGoDRF6SBwcHV/fyCnJ0XK0d/P8/CE2zI7S3R9mdmZEURRFEFEREREVEmS2q4AEREREdVvDJREREREVCUMlERERERUJQyURERERFQlDJREREREVCUMlERERERUJQyURERERFQlDJREREREVCUMlERERERUJQyURERERFQlDJREREREVCUMlERERERUJQyURERERFQlDJREREREVCUMlERERERUJQyURERERFQlDJREREREVCUMlERERERUJQyURERERFQlDJREREREVCUMlERERERUJQyURERERFQlDJREREREVCUMlERERERUJQyURERERFQlDJREREREVCUMlERERERUJQyURERERFQlDJREREREVCUMlERERERUJQyURERERFQlDJREREREVCUMlERERERUJQyURERERFQlDJREREREVCUMlERERERUJQyURERERFQlstquAN2Tp9IiLj0Paq0e5jIJmjtbw1rO/0VERERUtzGt1LLo5BysC09AaFQKEjKUEO/bJwDwdrJCUIAbpvX0hr+7bW1Vk4iIiKhUgiiK4sMPI1NLzFBi/tZIhMWkQSoRoNOX/r+haH9/PxcsHNcBXk5WNVhTIiIiorIxUNaC9REJWPD3RWj1YplB8kFSiQCZRMCHY9phcqB3NdaQiIiIqPwYKGvY8tBoLN5ztcrlvDa0FV4M8jdBjYiIiIiqhqO8a9D6iASThEkAWLznKjZEJJikLCIiIqKqYAtlDUnMUEKx5CBUWj306gLknt0F5dVj0KQlQK8pgNTGCeYu3rBqMwDWbfpB1GqQeWAV1ElR0N5JhV6VB0FmDjOnprBq1Qe2gWNhaWmJkJcH8p1KIiIiqlUMlDVkxq/hOHo9Hfkp8Ujd/BG0WbdLPbbJU8sgsbTDze+fLPUYixZd4DnlE/TxdcaaZ3pWQ42JiIiIyofTBtWA6OQchMWkQZefg5SNC6C7kwoAkNo4wa7nYzBz9YGozkdBwgXkRoYAAASpFFat+sCiRRfI7N0AUUTe5TDkXdgHACiIPYOC1ESE6UXEpOTAz41TChEREVHtYKCsAevCEyCVCMg8scUQJgW5NTxmfg2ZrYvhOKtWvWHfeyIgkUJqaQvX8fONyrFs2R350cehV+UBAPTqfEglAtYeT8AHY9rV3A0RERER3YeDcmpAaFQKdHoRysthhm12gWONwmQRqbUDpJbFWxv1BbnIObfbECYlVg4wc/GGTi8i9GpK9VWeiIiI6CHYQlnNclVaJGQooVfnG703KW9WvhbFzAOrcOf4ZqNtZq7N4Tx8LiRmcgBAQroSeSotl2kkIiKiWsEWymoWn54HETC0LBaR2TpVukxBagZRrzd8FgHEpeeVfgIRERFRNWKgrGZqbWHwk8itjbZrczLKdb5tlxFwn/YZXMe/A+t2QYVl3o5Gyob3oMvNLHYdIiIioprGQFnNzGWFP2KJuSVkDh6G7aqbl8p1vszeDRZe7WHVqjdcRr8KuVd7AICoKYAyJrzYdYiIiIhqGlNINWvubA3h7vdWbfobtuec2AZtTnqx43V5WdDl50CvUT20bH1BLgBAuHsdAMjLy0NkZCS2b9+O7777DsnJyVW+ByIiIqKycBRHNbOWy+DtZIX4DCXseoxH3sUD0N1d+eb276/Crsc4mLk2vzsPZSRyI0PgMXUR7pzaAV1uBqz8ekDm4AFRp4Xy6jGoEi8Yyjb38AMAaLNuo3mzJtBoNMjOzja6vr29PaZPn14j95qn0iIuPQ9qrR7mMgmaO1tzoBAREVEjwH/ta0BQgBvWhMcDlrZwe/xDw0o5upw0ZO5bUfJJej0Krp9CwfVTJe62atMfls07Q4AI5bWTyEhLK3aMRCLB0KFDTXkrxUQn52BdeAJCo1KQkKHE/csuCQC8nawQFOCGaT294e/OydeJiIgaIi69WAOik3MQvPSQ4fO9tbyPQpOWCL0mH1JrR5g5e8G67UBYtx2AgvjzyD0fAvXtGOiUWRC1akgsbWHu5gvrdoNg3W4QBKHwjYU/Z7TFxKH9kZSUhPv/d5qbm+PFF1/EO++8Ayenyo8qL0lihhLzt0YiLCYNUokAnb70P0ZF+/v7uWDhuA5ce5yIiKiBYaCsIUVreZcVvCpKKhEMa3knJSWhX79+SEhIgE6nAwCYmZlBo9EAAJo3b44ZM2bg9ddfh61t8ZZCjUaDLVu2YNy4cTA3Ny/zuusjErDg74vQ6sUK3Y9UIkAmEfDhmHaYHOhdgTslIiKiuoyDcmrIwnEdIJMIDz+wAmQSAQvHdQAAeHp64tChQ2jatGnhPpkMycnJ2L17NwYPHoxbt27h448/hr29PVq1aoVFixahoKDAUNa6deswefJkPP7444YQWpLlodF4a0skVFp9hcOxTi9CpdXjrS2RWB4aXYk7JiIiorqIgbKG5KUkAKc2mrTMj8a0M+o+btasGcLCwtCsWTOMHTsWjo6OGDp0KPbt24eCggJs2bIFffr0QVxcHObPnw8rKyu0b98ey5Ytw9q1ayEIAv7++29MnjwZWq222PXWRyRg8Z6rJqn74j1XsSEiwSRlERERUe1il3c1unPnDrZt24aVK1fi4MGDAIA3Vu3Dhiv5VShVBCDg9aEBeCHIr8QjVCoVRFGEhYVFifv1ej3+/PNPfPPNNzh9+rShi7yIIAiYOHEi1q1bB5mscNxWYoYSiiUHodLq73sH9Bg0aQnQawogtXGCuYs3rNoMgHWbfhCkZgCAvMuHkHNyB9QpsQAAc7cWsO0+BtZt+kMukyDk5YF8p5KIiKieY6CsBn///TdWr16Nf/75B2q12rC9Y8eOOHfuXKXfQYSoh16rQUf1ZWxZ/PpD33UsD61Wi5kzZ+KPP/4otq9Pnz44cOAAzMzMDO+A5qfEG0apl6bJU8tg7u6LrLB1yD7yZ4nH2PefDuf+UwzvgBIREVH9xWmDTOz69esYO3YsBEHAg1n99ddfBwBMDvRG35YuFR4l3cXTCv+8Pw2J2cnw3/4zvvrqKzz22GMQhMq/mymTyZCYmFhifY8ePQpXV1e89tFihN1qAl1+DlI2LoDuTmphvWycYNfzMZi5+tydR/MCciNDAADq5OvIProBACCYW8JJ8SwAICPkZ4jqfGQf/gNW/j0RphcRk5IDPzdOKURERFRfsYWyGnz66ad49913jbZJpVKkpqbC0dHRaHvRPI5/HDgLlbm9UTgUAHg7WyGolRum9/KGr4s1zM3NjbqoAwMDsWTJEvTt27dSdRVFEfb29sjJyYGtrS1atGiB1q1bw8vLC/Hx8ZBIJEh064VkuwCkha7CnWObCusmt4bnrO8gs3UxKk+XlwVIpMg6tAa5Z3YCABwGzoR974kAgOxjm5B1cDUAwLbrKLg+8hxm9PTBB2PaVar+REREVPsYKKuBWq2Gu7s7srKyABROMD548GDs3bu3xONTU1Ph7u4OyOQ4fTURokRa6kozrVu3RlRUlOGzVCqFTqfD8uXL8cILL1SqvmlpaZBKpcXCbpGBX4YiPkOJmz/OMnR12/ebCod+U0stM+nXF6FJjQMAuE/9DBbehWuQFyRcQPIfbwEAzNxawPPpb+HjbIWDrwVVqu5ERERU+zjK28S0Wi3atGmDrKwsDBkyBEDhIJjHHnus1HOee+45iKIIUVOAhPNH0cXbEe087UtctrB169ZGn0VRhLu7O3r2rPx7iC4uLqWGyVyVFgkZSujV+UbvTcqbld2iqM2+t4a41Nrhvu/tix2TkK5Enqr4qHIiIiKqHxgoTUir1aJ9+/a4fv065s6di5CQEPz0009o3rw5xo0bV+I5mzZtwl9//WX4vHbt2jKv0apVK8PIawCwtbXF5cuX0b17d9PcxAPi0/MgAtCr8oy2y2zLXnlH1KjufZDeF4zvjv4GAFFdOA+mCCAu3bh8IiIiqj8YKE1Er9ejS5cuiIqKwuzZs7Fs2TIAwLPPPovY2NjCLu0HpKam4tlnnzV6b3L79u3Iyckp9Tp+fn7QarWws7NDr169kJ2dje+//970N3SXWqsHAEjk1kbbtTkZZZ4nmMnvfdBpSvxeML83rVHRdYiIiKj+YaA0Ab1ejx49euDChQuYMWMGfv7553Kd9/zzzyMrK8todLVarca2bdtKPefRRx/Fq6++ikuXLuHIkSNwdnbG+++/j2vXrlWq7tevX0f79u0xYcIEfPPNNzh16pTRpObmssI/IhJzS8gcPAzbVTcvlVmuzP5egNblZd37PjezxGOKrkNERET1D/8VryK9Xo9+/frh1KlTmDhxIn7//fdynxsREWH0WSqVAkCJc0IWcXNzw+LFi9G0aVNIJBLs2rULoigiKKhyg1p0Oh0uXryILVu24OWXX0b37t1hY2ODFi1aoG3btpgzdTwKO6UBqzb9DeflnNgGbU568fLysqDLz4G8WVvDNtXNy/e+T7pi+N7i7nuYAoDmzsYtoERERFR/MFBW0PHjx41GWQ8ZMgTHjh3DmDFjsHFjxZZWvH79Om7cuGEYvLNgwQLMnj0bY8eOLXcZ3bt3x4svvojExETMnTu3QtcHCrvQ7e3tCwcF3W0pValUiIuLw+XLl+FsbwN368J3IO16jIfUzhVA4TuVt39/FXcitiM/7hyUV48jI2QFbv48B7o7qbDtNAwQCv94ZR/bhNxze5B7fi+y7047BEECm87DABROjVTSACQiIiKqHzhtUAVotVq4ublBo9Fg7969+OCDD7B7924MHToUu3fvrnS5PXv2xOnTp6HRaB5+cCl8fHyQmJiI8PBwBAYGlnqcXq/HgQMH8Mcff+DQoUOIi4srdl1BEODh4YHQ0FAEBATgg78vYk14PHR6Eeq0BJOtlOPQdzKkEoHzUBIREdVzDJQVcODAAQQFBUEQBEgkEuh0OgwcOBAHDhyoUrne3t7Izc1FRkbZA13Kcu3aNbRq1QoODg5ITk42jATXarXYtm0bNm7ciOPHj+PmzZvQ6wsHwFhYWMDf3x+Ojo4ICwuDKIoQBAEDBw7Eli1bDFMJRSfnIHjpIcO17q3lfRSatEToNfmQWjvCzNkL1m0HwrrtgAfW8v4b6pQ4AIC5W3PYdh8L6/u6z0NeHsCVcoiIiOox9jNWwNatWyGTyaDVaqHT6SAIQrEVcSojIyMDnp6eVSqjZcuW+PTTT/H222+jR48ecHd3x+nTp5Gammroyra1tUVgYCAeeeQRzJw5Ey1atAAAnDlzBl27dgUAzJkzB8uWLYOZ2b3pffzdbdHfzwVHr6dDpxchMbeAXY9HYdfj0YfWy7rNAFi3GVDiPqlEQB9fZ4ZJIiKieq7Rt1DmqbSIS8+DWqsvdXUaoHAC8aZNm+LWrVuGbYIgwMzMDKGhoejTp0+l6yCVSjFw4EDs37+/wufevn0bq1atws6dOxEZGWlYnQcAnJyc0LlzZ4wePRpPPPEEnJxKnjtSp9Nh1KhRGDlyJF544YUS1wZPzFBCseQgVCac3kcukyDk5YHwcrIyWZlERERU8xplC2XR+tmhUSlIyFDi/kQtAPB2skJQgBum9fSGv3th69np06eNwmTRkocymaxKXdUZGRnQ6/Xw8/Mr1/GXL1/GqlWrEBISgitXrkCpVBbW++57jz179kRISAjkcjkSExNhZfXwsCaVSvHff/+VeUxB+k1ow/8Auk0uVz3L46Mx7RgmiYiIGoBGFSgTM5SYvzUSYTFpkEoE6PTFG2dFAPEZSqwJj8eqY3Ho7+eCheM64MUXXzQcY2ZmhlGjRmHatGkYMWIELC0tK12n48ePAwA6dOhQ4v4jR45g7dq1OHDgAK5fvw61Wg2gMAR6e3ujT58+mDx5MkaMGAGJpHBU9erVq/Hkk09ixIgRVXq/MyMjAzt27MCKFStw5MgRmJmZ4Z1nX8Rvp9IqXWaR14cGYFKgd5XLISIiotrXaALl+ogELPj7IrR3Q2RJYfJ+RfuPXk/H4K/247bSDtbW1li2bBkmTJgAOzs7k9Tr9OnTAAqn/9HpdPj333+xfv16HD16FDdu3IBOpwMAyOVytGzZEkFBQZgxYwZ69epVapkzZ87Eb7/9hoMHD+K3337DU089Ve765OTk4I8//sDGjRtx8OBBw/UBYN68eVgwoScCfO79LB/2c7yfVCJAJhHw0Zh2DJNEREQNSKN4h3J5aDQW77la+QJEERAEvDLEDy8pAkxWL6VSicGDByM8PBxubm5GA2isra3RunVrDB06FDNnzkRAQMWuq1Qq4erqCo1Gg6SkJLi4uJTrvAULFuCjjz6CIAhGK/hIpVKkpqYaRn6Xp7XXcO7d/UWtvezmJiIialgafKBcH5GAt7ZEmqy8z8d3KLF17a+//sKHH36InTt3olmzZiWem5aWhtWrV+Off/7BuXPnkJl5bxlCBwcHdOzYESNHjsQTTzwBDw+PEsuoiP/++w8jRoxAhw4dcP78+XKdk5qaiv79+yM6OtowvZBEIsHw4cPxzz//FDve8D7q1RQkpBu/jwoAtijAY71bY3ovb47mJiIiaqAadKC8f2TyvbkTj0GTlgC9pgBSGyeYu3jDqs0AWLfpB0FqhjvhW1CQEAlVUhT0+XcAAFI7NzR7fiWA4iOTRVHEwoULDdMH/fzzz5g9ezaAwrkhV61ahd27d+Py5cvIzc0FUDiAxs3NDd26dcPx48eh0+mMRmeb0sSJE7F582YsXLgQb7/9drnO2bhxIyZNmmS0bd26dZg6dWqZ5+WptOjQZzCSbqfg+JHDmDVlLE4dP4oVK1Zg1qxZlb4HIiIiqtsadKCc8Ws4jl5PR35KfLlXd0lYMgmiKs9o3/2BsmjuxDXP9ERBQQGefvpp/Pln4WowEokE/v7+kMlkiImJgUqlMmxv1qwZevfujYkTJ2Ls2LGGicdtbGzg6emJq1er0CVfBq1WC3d3d2RlZeHq1ato2bJlmcf/999/GDVqFKRSKdzc3HDz5k3I5XKkpaXBxsamzHOzs7Ph5OQEvV6PpUuXYsmSJYiPj4dEIsHOnTsxbNgwU94aERER1RENdlBOdHIOwmLSoMvPQcrGBdDdSQUASG2cYNfzMZi5+kBU56Mg4QJyI0MM55m7tYCZizdkdi7IOvh7sXJ1ehFhMWk4dvE6nhw/3CgI6vV6REVFwczMDC1atMDAgQMxffp09OvXzzAC+0H5+fmldpGbgkwmw+7du9GjRw8MHjwY8fHxpR77999/Y9y4cTAzM8PJkyfh6OiI/v37o1+/fg8NkwCwYsUKQzf5ggULkJ2dDaDw5/Loo4/iyJEjhgnUiYiIqOFosIFyXXgCpBIBmSe2GMKkILeGx8yvIbO9N0DFqlVv2PeeCEikAACPaZ8BADTpiSUGSgCAqMeoeV8go5RWxWvXrsHLy+uhdazoHJSV1b17d7zwwgtYvnw55s6di2+//bbYMX/99RcmTpwIuVyO06dPo02bNgCAq1evojyN2Gq1GosXLzZ8zsnJMdqv0WgwdOhQnDx5Es2bN6/aDREREVGdUnKzWQMQGpUCnV6E8nKYYZtd4FijMFlEau0AqWUFBowIEji264dOnToZDZ6RSgtDaVhYWGlnGimag7J9+/blv3Ylffvtt/D29sZ3332HiIgIo30bNmzAxIkTYWFhgfPnzxvCJFDYwnn/Moyl2bBhA5KTkw2fi1oqi+h0OqSnp2PixIlVvBMiIiKqaxpkC2WuSouEDCX06nyj9yblzdqZ7Bo6S0ccCT8Ja7kMSUlJOHLkCA4fPowTJ06gSZMm5SrjzJkzAApbEGvC/v370apVKzzyyCNITk6GTCbDunXrMGPGDFhaWuLChQuG9b0rQhRFfPbZZyXuK5p+SCKRoHfv3hWaE5OIiIjqhwYZKOPT8yAC0D8wuEZmW/Ja1pUhAohLz0M7T3t4enpi4sSJFW59u3TpEgDU2HuFLVu2xCeffIL58+djypQpGDlyJJ566ilYW1vj4sWL8PHxqVS5er0eOTk5sLGxgU6nQ35+PmxtbaFWq9G1a1dcu3YN48ePxw8//GDiOyIiIqK6oEF2eau1d+dPlFsbbdfmVH7N7bKuU1nXr1+HTCaDhYWFiWr0cG+//TY6dOiAzZs346mnnoKtrS2uXLlS6TAJFHb1JyQkICcnB++88w4AYO/evSgoKMDRo0cxevRoHDp0yFS3QERERHVMgwyU5rLC25KYW0LmcO8dR9XNS9VyncpKSkoq1+hpU5s2bZrh+zNnzph0lHnRkpT3T9oeHByMS5cu4ebNmya7DhEREdUdDTJQNne2hnD3e6s2/Q3bc05sgzYnvdjxurws6PJzim0vi3D3OlWRkZFR7iURTeWbb77BW2+9BSurwonZn3nmGZOWXxQoi6YMAoDBgwcDAPbt22fSaxEREVHd0CADpbVcBu+7K9nY9RgPqZ0rgMJ3Km///iruRGxHftw5KK8eR0bICtz8eY5haqH8ayeRd+Uw8mPPGMoTtSrkXTmMvCuHoboVDQDwdraCtbxqr6AqlcpqnYPyQYsXL8a8efPg5OSE+Ph4DBw4EAcPHsRvv/1msms4ODgAMA6Urq6u6Ny5M0JCQko5i4iIiOqzBjkoBwCCAtywJjwesLSF2+MfGlbK0eWkIXPfilLPS9/9PXR3Uoy26ZXZSNtWOIrZuv0QyEe8hKSTezF16goUFBQgLS0N6enpyMrKQvfu3bF9+/aH1q+m5qAssmjRIsyfPx8uLi6IioqCk5MTdu7cCVdXV8yZMwejR482SWupo6MjAONACRR2e69duxaiKEIQhJJOJSIionqqQbZQAsC0nt7Q6Qsn5DZ38UaTp5fDcfAsyJu1hcTCFpDKILVzhUWLrnAe+TLMXB4+EbmBRIq4kDX4888/sXXrVoSFheHSpUtISkoqNv9iacLDwwHUzByUH330EebPnw83NzdER0fDyalwtLuVlRU2bdoEjUZj6JauqqIWygcnNlcoFLh165ZhZDsRERE1HA22hdLf3Rb9/Vxw9Ho6dHoREnML2PV4FHY9Hi3zvKI1u0sjlQjo1cIJV3zccDr9RrH9L774Yrnqd/r0aQDVPwfle++9h08++QQeHh6IiooyvONYZMSIEXjsscfw119/YdGiRXj77berdL2isPpgoOzXrx/Mzc0REhKCdu1MNx8oERER1b4G20IJAAvHdYBMYtruVZlEwGfjO2L//v0ICAgwrI5TZNSoURg/fjwSEhLKLKeopa5bt24mrd/93n77bXzyySfw9PREdHR0sTBZZP369XBycsK7776La9euVemapQVKKysr9O3bl+9REhERNUANOlB6OVnhwzGmbQ37aEw7eDlZwd7eHrt374aDgwMkEgkEQcDjjz8OT09PbN26FT4+PmjXrh22bt1aYjnVPQflq6++is8++wzNmjVDdHR0mdMTyWQy7Nq1C6IoVrnru2j0eG5ubrF9wcHBOHDgADQaTZWuQURERHVLgw6UADA50BuvDW1VxVIK38V8fWgAJgV6G7b6+Phg586dMDMzg4WFBVasWIH4+HicOXMGgwYNwpUrVzB+/Hg4Ojri9ddfR0FBgeHc6pyD8v/+7//w9ddfw8fHB9HR0YaQV5bAwEC88MILSEhIwNy5c6tcB6VSWWybQqFAbm6u4f1RIiIiahgafKAEgBeD/PHZ+A6QyySQVrQLXNRDr1GjU0Eknu1XfDWZHj16YM+ePfjzzz8NXcqdO3dGaGgosrOz8dJLL0Gv12Px4sWwsbFBcHAwLl68WG1zUD733HNYtmwZfH19cfXq1Qq1gH777bfw8vLCd999h4iIiErXQSKRIC8vr9j2rl27wtHRkd3eREREDYwgiqJY25WoKYkZSszfGomwmDRIJYJhFHhJivZ3b2qN7e9OhjY7Gc2aNcOnn36KadOmFXt38mE2bNiABQsWICoqyrAtICAAly5dgkRimlw/a9Ys/Prrr/D398eFCxdgbm5e4TKuXbuGVq1awcHBAcnJyZDJKj5uy8zMDIGBgTh69GixfRMmTMCtW7dw5MiRCpdLREREdVOjaKEs4uVkhTXP9MTeeQMwo6cPfJyt8GB7pQDAx9kKM3r6IOTlAdj84iDItYXvA964cQMzZ85EmzZtsHnz5nJPEQQAkyZNwpUrVxATE4OhQ4cCAKKiomBra4vZs2cjKyurSvc2c+ZM/Prrr2jTpg0uXbpUqTAJAC1btsRHH32EjIwMTJkypVJlSKVSo+79+ykUCoSHh+POnTuVKpuIiIjqnkbVQlmSPJUWcel5UGv1MJdJ0NzZutgKOAMHDsShQ4cMnwVBgCiKePnll/H1119X+Jq7du3C8OHDMWzYMJw6dQppaWkQBAE9e/bE4sWL0bdv3wqVN2XKFKxfvx7t27fH2bNnK9x6WpIOHTrgwoUL2LlzJ4YPH16hc62treHt7Y3Lly8X2xcTEwN/f3/8/fffGD16dJXrSURERLWvUbVQlsRaLkM7T3t08XZEO0/7EpdT7NixI8zMzAyfJRIJXFxcMGHChEpds2gOynfffRepqanYs2cPOnfujOPHj6Nfv37w9PTEl19+Wa4W0IkTJ2L9+vXo3Lkzzp07Z5IwCQD79++HmZkZJk6cWOIAm7LIZDKo1eoS97Vs2RLNmzfne5REREQNSKMPlOXRtm1baLVaw2dBEHDmzBn06dOnQuXk5ORAFEXDHJRFk5oHBwfj9OnTuHXrFqZOnYqMjAy88cYbsLS0xOOPP46kpKQSy3v00UexefNmdO/eHadOnTLZu5hA4frbP/74I/Ly8jBixIgKnWtmZoaCggLk5+cXW4JREAQoFArs3bvXZHUlIiKi2sVAWQ7t2rWDKIqQyWQYM2YMtFotnn766QqVceLECdjb28PCwgKbN28GAMybNw+fffaZITB6eHhg3bp1UCqVWLp0KVxdXbFp0yY0bdoUHTt2xM6dOw3ljRgxAtu3b0evXr0QHh5u0jBZ5Omnn8aAAQNw8OBBrFq1qsxjjxw5Ai8vLzg4OCA9PR1JSUmwsrKCg4MD/vzzT6NjFQoFLl++jJs3b5q8zkRERFTzGv07lOVRUFCAN954A08++SS6du2Kfv364ciRI/jpp5/w7LPPlquMtLQ0eHh4QKfTGbZJpVLodDosWbIE8+bNK/G8iIgIvPLKKzhy5AhEUYSTkxPs7OwQFxeH/v3748CBA9USJosolUq4urpCo9EgKSkJLi4u0Gg0UKvVsLa2Nhx3/vx5dO7cGSX9cbp48SLatm1r+JyWlgZXV1esXr0aTzzxRLXVnYiIiGoGWyjLwcLCAsuWLUPXrl0BACEhIbC1tcXzzz+P+Ph4REZGYsiQIThw4ECpZbi4uGDYsGHF3nH08fHB7NmzSz0vMDAQYWFhyMrKwv/+9z9kZ2cjLi4OQOHgl+jo6CrfX1msrKywadMmaDQaDB48GCdOnEDr1q0xZMgQo+M6duyI6dOnG92fVCrF8OHDjcIkUPiz6NKlC7u9iYiIGggGykqwsLDAzp07odPp0KVLF3Tt2hX79+/H9u3byzxv+vTpRi2UOp0Ov//+u1FL3/3uX77QxsYGFy5cgE6nQ/v27eHn54ddu3ahdevW8Pf3x7p160xzcyUYMWIExo0bh8jISPTq1QvXr1/H2bNniw0a+uSTT4xaS3U6Hd54440Sy1QoFAgJCSmxRZOIiIjqFwbKSmrbti18fX2RmZlpGLATGRlZ5jljxoyBXC43fJ47dy4GDBhQ4rFhYWFwcHDAzz//DL1ejz59+uDw4cMYMWIEIiMjER0djStXruCRRx5BbGwspk+fDltbW7zwwgslrqNdFVeuXEFsbCwAGAKgSqUqNljI29vbqOu+c+fOGDhwYIllKhQK3L592zBAiYiIiOoxkSosOjpa9PDwEKVSqYjChb5FAKKbm9tDzx00aJAIQHR0dBRzc3NLPe7pp582lOvj4yMCEMeOHVvisSqVSnz77bdFJycnEYAokUjE/v37ixEREZW9RQOlUina2NgY3WfRV2hoaLHjMzMzDT+X9evXl1muXC4XlyxZUuU6EhERUe1iC2UlZGZmIjc3t1h3bUpKykNXvCl6D3PRokWldnWr1Wps2rTJ8Dk+Ph6BgYHYtm1bicebm5tj4cKFSE9Px44dO9CuXTuEhYUhMDAQXl5e+Oabbyq0qs/9LC0tsXDhQtja2hZ7/7Ok9zcdHBzQq1cvCIKAxx57rMxy+/bty/koiYiIGgAGykoIDAxEQkIC3n77bVhYWEAQ7i3gWFoXbp5Ki4tJ2bDxaQ+LJn6YPH1mqeXv2bMHOTk5RttOnjxZrvckR40ahfPnzyMxMRETJ05ESkoK5s2bBysrK0ybNg0pKSnlvMt75s6di7i4OMybN89obe/Dhw+XePxjk6bCpllrRCbl4GJSNvJU2hKPUygUOHDgADQaTYXrRERERHUHpw2qopSUFCxatAjffPMNRFHEY489ZphnMjo5B+vCExAalYKEDCXu/0ELALydrBAU4IZpPb3h725r2Dd16tRiczcCgLOzM1JTU40C7MPo9Xp89dVXWLJkCW7dugUA6NKlCz7//HMEBwdX+H7j4uIwd+5c/PPPP7CyskJOTg4kEkml7vXkyZMIDAzEoUOH0L9//wrXhYiIiOoGBkoTSUxMRNeuXaFWqxF64jyWHL6NsJg0SCUCdPrSf8RF+/v7uWDhuA6wl2nh4OBg1J3eqlUrTJo0CVOmTEGbNm0qXccjR47gtddeQ3h4OERRhIuLC1544QW8++67Ri2P27Ztw/r16/Hbb7/B0tKyxLIWLlyId955B9/8shYR8KvUvXray+Hq6oq5c+fiww8/rPR9ERERUe1ioDShtLQ0DH/xY2T7DYNORJnh6kFSiQCZRIDj9b0I/2MJnJyc8Oqrr2L8+PFo3bq1SeuZmZmJ119/HX/++SeUSiVkMhmGDx+OpUuXokWLFvD398e1a9cM64SXNnH681+tw94MB+hRdpB8UNG9fjimHTZ//gpu3bqFI0eOmOr2iIiIqIYxUJrQ8tBoLN5ztcrlDHbJw8pXHzdBjcqm1+uxcuVKfPrpp4bJ0r28vJCYmGg4Zv78+fj000+LnWuqex3gkI0/3nkCGRkZsLOzq3J5REREVPM4KMdE1kckmCRgAcD+NGtsiEgwSVllkUgkmDVrFmJjYw2r/dwfJoHCru0H1/E25b0eyrKHZbvBZa4yRERERHUbWyhNIDFDCcWSg1Bp9dCrC5B7dheUV49Bk5YAvaYAUhsnmLt4w6rNAFi36QdBamZ0fvbxzcg6sMrw2WnY83AJHIWQlwfCy8mqxu4jLi4OLVq0KHHfihUrMGvWrArfqy4/B3kX9qMg/hw0GUnQ52UCEinMXLxh2/kR2HQMBrRqDFEfx6/ffF5j90pERESmI3v4IfQw87dGQqsXoU5LQOrmj6DNum20X5edjPzsZORfi4C5qw/M3X0N+zSZScg+XHxEt1YvYv7WSKx5pme117/IypUrAQAymQyCIECr1RoGB82ePRv79++HOPCFCt2rJj3RKCwXUSdFIT0pCuqUWDgPmYXQXPdqvz8iIiKqHgyUVRSdnIOwmDTo8nOQsnEBdHdSAQBSGyfY9XwMZq4+ENX5KEi4gNzI4pN4p/+3HKJWBUFmDlGrNmzX6UWExaQhJiUHfm62xc6rDn379sWMGTPg6OgIR0dHODg4wNHREWq1GhcvXkT45Xjcisuq8L0KMnNYtx0Ey5bdAakZcs/8i/xrJwEAOSd3wLb7GJi5BeDw+Rj06+hXI/dKREREpsNAWUXrwhMglQjIPLHFELAEuTU8Zn4Nma2L4TirVr1h33siILm32kzOud1QJZyHmasPzFybQ3npoFHZUomAtccT8MGYdkbbc3Nz8fvvv6Nfv37o2LGjSe5DFEWcPXsWc+bMQd++fUs85oO/L2JNeHyF7lWQmsHz2Z8hs7u337J5Z9z44Sno87IAiFDfiobMzhXf7jrLQElERFQPcVBOFYVGpUCnF6G8HGbYZhc41ihgFZFaO0BqWdjaqM3NQNb+lYAggfPwlyBIimd7nV5E6NV7K9vk5ubi888/h5eXF1544QWsWLHCZPdx69YtvPXWW+jXrx+CgoJKXAWnMvdq5uJlFCYBQJCZQWbneu+zmQUEiRTnUkpeUYeIiIjqNgbKKshVaZGQoYRenW/0LqG8WbsyziqUuedH6FV5sO02GnLPgFKPS0hXIiUzG1988QW8vLzw9ttvIysrC1KptNha4qYSFhaG/v37Y9CgQQgLKwyPVbnXB2mybkOdfB0AIJhbwsKrsIx8mQ1yC7gMIxERUX3DLu8qiE/PgwhAr8oz2i6zdSrzPGXUUSivHoXU3h0OA2aUeawIoFnrLtCkxBpt1+l0+OmnnwwDaUo9vxyhUxRFo+N0Oh0A4ODBgxgwYADkcjn8ewRB7Ptihe/1Qbr8O0j96xNAX3gNh4FPQCIvHMkuCAL2n4jEmAFdK1QmERER1S4GyipQa/UAAInc2mi7NicDZs5epZ6XsfdHAIDzIy9AYm7x0OtYWNmgpHY7W1tbNGnSBACM1vcu+r60Nb9LOlaj0eDSpUvFjpVKpWjbti269emHvaj4vRodm5uBlPXvQpNWOMembeCjsOs22uiYI+HhDJRERET1DANlFZjLCt8YkJhbQubgYegKVt28BMvmnUo9T5ebAQBI2fB+ifszdn+PjN3fw2veekgsbHDscBhuXzmJ9957D8eOHTN0d0+ZMgXfffedSe7l1q1b8PT0LLwfiQS2trZ466238OKLL8LGxgYXk7Kx99vDFb7XItrsFCT/+Q60WbcAAHa9JsBx0JPFjjsZfhzAcya5JyIiIqoZfIeyCpo7W6Oorc+qTX/D9pwT26DNSS92vC6vcMqdihAANHexxpAhQ3DkyBHs27cPPXv2hF6vh7m5eRVqb0wul0MQBNjb2+OTTz5BYmIi3nrrLdjY2ACo2r1q0m/g9ro3DWHSYeDMEsMkICJ83z9Qq9Ul7CMiIqK6iivlVNHAL0MRn6GELj8Ht3576d7cjLYusOsxDmauze/OzRiJ3MgQeExdhIKEyGLl5F06APWtaACAVet+kDdtA9suI9Dc3R4HXwsyOlYURURERMDHxwfu7qabEPzEiRNo06YNbG1LnveyMvcqyMxxe91b0CuzAADW7QbBpvNwo3LNnJpCau0AD2spwt8bjkOHDqF///4PXp6IiIjqKHZ5V1FQgBvWhMcDlrZwe/xDw+oxupw0ZO4reVofu8Cxxbapk68bAqWFT0fYdhkBqURAUCu3YscKgoAePXqY9kaAh5ZZmXtV3bxiCJMAkHfxAPIuHjA6xnnEPNh3DsbQDk0R7eSEkJAQBkoiIqJ6hF3eVTStpzd0+sJGXnMXbzR5ejkcB8+CvFlbSCxsAakMUjtXWLToCueRL8PMpXwDWIDCeSin9/KurqpXWHXf6xO9m2Pw4MHYu3dvdd0CERERVQN2eZvAjF/DcfR6uiFsmYJUIqCPr3ONruVdHtV9rz/99BNeeOEFpKenw97e3mTXICIiourDFkoTWDiuA2SSkqfoqSyZRMDCcR1MWqYpVPe9KhQK6HQ6HDx48CFnERERUV3BQGkCXk5W+HBMxVeMKctHY9rBy8nKpGWaQnXfa8uWLdGiRQt2exMREdUjDJQmMjnQG68NbWWSsl4fGoBJgXXn3ckHVfe9KhQKhISEmKR8IiIiqn4MlCb0YpA/PhvfAXKZBNIKdgtLJQLkMgk+H98BLwT5VVMNTac671WhUODKlSu4ceOGqapLRERE1YiDcqpBYoYS87dGIiwmDVKJUOYAlqL9/f1csHBchzrZzV2W6rjXtLQ0uLm5YeXKlXjyySerqeZERERkKgyU1Sg6OQfrwhMQejUFCelK3P+DFgB4O1shqJUbpvfyhp9byZOJ1xemvtdu3bqhTZs2WLt2bbXVmYiIiEyDgbKG5Km0iEvPg1qrh7lMgubO1rCWN8x55U1xr2+++SZWr16NW7duQRBMO6qciIiITIuBkuqkkJAQBAcHIzIyEu3bt6/t6hAREVEZOCiH6qS+fftCLpdz+iAiIqJ6gIGS6iRLS0v069eP0wcRERHVAwyUVGcFBwfj4MGDUKvVtV0VIiIiKgMDJdVZCoUCeXl5OH78eG1XhYiIiMrAQEl1VufOneHk5MRubyIiojqOgZLqLKlUisGDBzNQEhER1XEMlFSnBQcH48SJE8jOzq7tqhAREVEpGCipTlMoFNDpdDhw4EBtV4WIiIhKwUBJdZqvry9atGjBbm8iIqI6jIGS6rzg4GAGSiIiojqMgZLqPIVCgStXruDGjRu1XRUiIiIqAQMl1XmDBw+GIAhspSQiIqqjGCipznN2dkbXrl0ZKImIiOooBkqqFxQKBUJCQiCKYm1XhYiIiB7AQEn1gkKhQHJyMi5cuFDbVSEiIqIHMFBSvdC3b1/I5XJ2exMREdVBDJRUL1haWqJ///7Yu3dvbVeFiIiIHsBASfWGQqHAwYMHoVara7sqREREdB8GSqo3FAoFlEoljh8/XttVISIiovswUFK90aVLFzg5ObHbm4iIqI5hoKR6QyKRYMiQIRyYQ0REVMcwUFK9olAocOLECWRnZ9d2VYiIiOguBkqqV4KDg6HX63HgwIHargoRERHdxUBJ9UqLFi3g6+vL9yiJiIjqEAZKqneKlmEkIiKiuoGBkuqd4OBgREVFITExsbarQkRERGCgpHooKCgIgiCwlZKIiKiOYKCkesfZ2Rldu3ZloCQiIqojGCipXip6j1IUxdquChERUaPHQEn1UnBwMFJSUhAZGVnbVSEiImr0GCipXurbty8sLCzY7U1ERFQHMFBSvWRhYYF+/foxUBIREdUBDJRUbwUHB+PgwYNQqVS1XRUiIqJGjYGS6i2FQgGlUonjx4/XdlWIiIgaNQZKqrc6d+4MZ2dndnsTERHVMgZKqrckEgmGDBnCQElERFTLGCipXlMoFDhx4gSysrJquypERESNFgMl1WsKhQJ6vR4HDhyo7aoQERE1WgyUVK+1aNECvr6+7PYmIiKqRQyUVO8FBwdj7969tV0NIiKiRouBkuo9hUKBq1evIiEhobarQkRE1CgxUFK9FxQUBEEQsG/fvtquChERUaPEQEn1nrOzM7p168ZubyIiolrCQEkNgkKhQEhICPR6fW1XhYiIqNFhoKQGQaFQIDU1FRcuXKjtqhARETU6DJTUIPTt2xcWFhacPoiIiKgWMFBSg2BhYYH+/fvzPUoiIqJawEBJDYZCocChQ4egUqlquypERESNCgMlNRjBwcFQKpU4duxYbVeFiIioUWGgpAajU6dOcHZ25nuURERENYyBkhoMiUSCIUOGMFASERHVMAZKalAUCgUiIiKQlZVV21UhIiJqNBgoqUEJDg6GXq9HaGhobVeFiIio0WCgpAalefPmaNmyJbu9iYiIahADJTU4RcswEhERUc1goKQGJzg4GFevXkVCQkJtV4WIiKhRYKCkBicoKAiCILCVkoiIqIYwUFKD4+TkhG7dujFQEhER1RAGSmqQgoODERISAr1eX9tVISIiavAYKKlBUigUSE1NRWRkZG1XhYiIqMFjoKQGqU+fPrCwsGC3NxERUQ1goKQGycLCAv3792egJCIiqgEMlNRgBQcH4+DBg1CpVLVdFSIiogaNgZIaLIVCgfz8fBw7dqy2q0JERNSgMVBSg9WpUye4uLiw25uIiKiaMVBSgyWRSDBkyBDs3bu3tqtCRETUoDFQUoOmUChw8uRJZGZm1nZViIiIGiwGSmrQFAoF9Ho9Dhw4UNtVISIiarAYKKlBa968Ofz8/PgeJRERUTVioKQGT6FQ8D1KIiKiasRASQ2eQqFAdHQ04uPja7sqREREDRIDJTV4gwcPhiAI2LdvX21XhYiIqEFioKQGz9HREd27d2e3NxERUTVhoKRGQaFQYN++fdDr9bVdFSIiogaHgZIaBYVCgdTUVERGRtZ2VYiIiBocBkpqFPr06QNLS0t2exMREVUDBkpqFCwsLNC/f3/OR0lERFQNGCip0VAoFDh06BBUKlVtV4WIiKhBYaCkRiM4OBj5+fk4duxYbVeFiIioQWGgpEajY8eOcHFx4XuUREREJsZASY2GRCLBkCFD+B4lERGRiTFQUqMSHByMkydPIjMzs7arQkRE1GAwUFKjolAooNfrERoaWttVISIiajAYKKlR8fHxgZ+fH7u9iYiITIiBkhodhULBQElERGRCDJTU6AQHByM6Ohrx8fG1XRUiIqIGgYGSGp2goCAIgsBWSiIiIhNhoKRGx9HREd27d2egJCIiMhEGSmqUgoODsW/fPuj1+tquChERUb3HQEmNkkKhQGpqKs6fP1/bVSEiIqr3GCipUerTpw8sLS3Z7U1ERGQCDJTUKMnlcgwYMICBkoiIyAQYKKnRUigUOHToEAoKCmq7KkRERPUaAyU1WgqFAvn5+Th27FhtV4WIiKheY6CkRqtjx45wdXVltzcREVEVMVBSoyWRSDBkyBDs3bu3tqtCRERUrzFQUqOmUChw8uRJZGZm1nZViIiI6i0GSmrUFAoFRFFEaGhobVeFiIio3mKgpEbNx8cH/v7+7PYmIiKqAgZKavQUCgUH5hAREVUBAyU1egqFAjExMYiLi6vtqhAREdVLDJTU6AUFBUEikWDfvn21XRUiIqJ6iYGSGj1HR0d0796d71ESERFVEgMlEQq7vfft2we9Xl/bVSEiIqp3GCiJUBgo09LScP78+dquChERUb3DQEkEoE+fPrC0tGS3NxERUSUwUBIBkMvlGDBgAKcPIiIiqgQGSqK7FAoFwsLCUFBQUNtVISIiqlcYKInuCg4ORn5+Po4ePVrbVSEiIqpXGCiJ7urQoQNcXV3Z7U1ERFRBDJREd0kkEgwZMoSBkoiIqIIYKInuExwcjJMnTyIzM7O2q0JERFRvMFAS3UehUEAURezfv7+2q0JERFRvMFAS3cfb2xv+/v7s9iYiIqoABkqiBwQHBzNQEhERVQADJdEDFAoFYmJiEBcXV9tVISIiqhcYKIkeMGjQIEgkErZSEhERlRMDJdEDHB0d0b17dwZKIiKicmKgJCpBcHAw9u3bB71eX9tVISIiqvMYKIlKoFAokJaWhnPnztV2VYiIiOo8BkqiEvTu3RtWVlbs9iYiIioHBkqiEsjlcgwYMICBkoiIqBwYKIlKoVAocOjQIRQUFNR2VYiIiOo0BkqiUigUChQUFODo0aO1XRUiIqI6jYGSqBQdOnSAm5sbu72JiIgegoGSqBQSiQRDhgzB3r17a7sqREREdRoDJVEZFAoFTp06hYyMjNquChERUZ3FQElUBoVCAVEUERoaWttVISIiqrMYKInK4O3tjVatWrHbm4iIqAwMlEQPoVAoODCHiIioDAyURA+hUChw7do1xMbG1nZViIiI6iQGSqKHCAoKgkQiYSslERFRKRgoiR7CwcEBgYGBDJRERESlYKAkKgeFQoF9+/ZBr9fXdlWIiIjqHAZKonIIDg5Geno6zp07V9tVISIiqnMYKInKoVevXrCysuL0QURERCVgoCQqB7lcjgEDBvA9SiIiohIwUBKVk0KhQFhYGAoKCmq7KkRERHUKAyVROQUHB6OgoABHjhyp7aoQERHVKQyUROXUvn17uLm5sdubiIjoAQyUROUkkUgwZMgQBkoiIqIHMFASVUBwcDBOnTqF9PT02q4KERFRncFASVQBQ4YMgSiKCA0Nre2qEBER1RkMlEQV4O3tjVatWrHbm4iI6D4MlEQVFBwczEBJRER0HwZKogpSKBS4du0aYmNja7sqREREdQIDJVEFDRo0CBKJhK2UREREdzFQElWQg4MDevTowUBJRER0FwMlUSUoFArs27cPer2+tqtCRERU6xgoiSpBoVAgPT0dZ8+ere2qEBER1ToGSqJK6NWrF6ysrNjtTUREBAZKokqRy+UYOHAg9u7dW9tVISIiqnUMlESVpFAoEBYWhvz8/NquChERUa1ioCSqJIVCAZVKhaNHj9Z2VYiIiGoVAyVRJXXo0AFubm4ICQlBnkqLi0nZOJOQiYtJ2chTaWu7ekRERDVGEEVRrO1KENVH0ck5eOLjFUg1c4fOwgH3/0USAHg7WSEowA3TenrD3922tqpJRERU7RgoiSooMUOJ+VsjERaTBqkA6Mr4GySVCNDpRfT3c8HCcR3g5WRVcxUlIiKqIQyURBWwPiIBC/6+CK1ehE5f/r86UokAmUTAh2PaYXKgdzXWkIiIqOYxUBKV0/LQaCzec7XK5bw2tBVeDPI3QY2IiIjqBg7KISqH9REJJgmTALB4z1VsiEgwSVlERER1AVsoiR4iMUOJzo/ORkbYH8Y7BAkklrYwd/WBdYdg2LQPMtqtyUxCVtg6FMSdg16VC5mtC6wC+sK+zyRYWtsg5OWBfKeSiIgaBLZQEj3E/K2RKPF1SVEPvTIbBfHnkf7PV8gO32LYpU6+jlurXoby0kHolVmATgtt1m3cCf8Lt9e9BXV+HuZvjayxeyAiIqpODJREZYhOzkFYTBrub8i38O0G92mfw23yJ7Bs1duwPefUP4bv03d+A1GVBwCw6fwIXB97D3Kv9gAATcp1ZIT9ibCYNMSk5NTQnRAREVUfBkqiMqwLT4BUIhhtk1o5wMKrHSybd4ZD/+mG7bq8TACAKikK6uRrAAAzZy84DXsBVv494TL2DRTOUAnknt8DiajD2uN8l5KIiOo/BkqiMoRGpZQ6PZCo0yA/+rjhs7mrDwBAdePSvW2eARCEwhAps3GCzN4NAKAvyEVBSjxCr6ZUV9WJiIhqjKy2K0BUV+WqtEjIUBbbnndhH/Iu7DPaJrGyh6NiDgBAm30vJEqtHYyPs3YAspMLj8u6jYR0X+SptLCW868iERHVX2yhJCpFfHoeyjsFgiAzh6guDJ96TcG97VIz4+Mk94KjXqOCCCAuPa+qVSUiIqpVDJREpVBr9SVuLxqU4z5lIez7TwMgQHcnFalbFkKXmwmJmYXhWFGnMTpX1GsN30vM5KVe5/bt29i3bx/0+pLrQEREVJewn42oFOaykn/fKhqUAwAWPh2hunkFBddPQdSqoIwJN7wnCQC6vCyjc3W5mYbvZQ4ehuvk5+cjLCwMe/fuxb///ovLly8DAC5evIi2bdua8raIiIhMjoGSqBTNna0hAA/v9r5vSiF9fg4sfDoaPqtuXoEoihAEAdqcNOjupAIAJBY2MHPxhgBg5IAeSIyNgV6vh1QqhU6nKzxGIkHz5s1Nek9ERETVgV3eRKWwlsvgXcJKNjplFgoSL6Ig/jyyj25EQdxZwz4zp6aQewbA3L0lAECbcQMZu5ZDGR2OtL8Xoyie2nQcCkEqg5eTJXKz0g1d20VhEgDs7e3x999/Izo6ml3fRERUp7GFkqgMQQFuWBMeb7St4PopFFw/VexYc/eWsPTrAQBwHvF/uP3H2xBVecg9txu553YbjjNz84V938mQSgQMDnDHnhs38NJLL2HFihWGYwRBgFqtxpQpUwAAdnZ26Nq1K7p162b48vPzg0TC3wmJiKj2cS1vojJEJ+cgeOkhZIWtQ/aRP4vtF2RyyBw9YOnfC/Y9H4NEfq9FU5NxE1mH/7i3lreNM6xa94N9n0mG40JeHgA/N1sAwKpVqzBnzhzodDro9Xp88803mDJlCk6fPo1Tp04ZvuLi4gAUhswuXboYhUx/f3+GTCIiqnEMlEQPMePXcBy9nl7qBOeVIZUI6OPrjDXP9DTafvbsWYwZMwaJiYk4cuQI+vTpU+zc9PT0YiEzNjYWAGBra1ssZLZq1Yohk4iIqhUDJdFDJGYooVhyEKpSphGqDLlMgpCXB8KrhHc0MzMzsXPnTkydOtWwys7DZGRkFAuZ169fBwDY2NiUGDKlUqnJ7oeIiBo3BkqiclgfkYC3tkSarLzPx3fApEBvk5VXkszMzGIh89q1wjXGra2ti4XMgIAAhkwiIqoUBkqicloeGo3Fe65WuZzXhwbghSA/E9So4rKysoqFzJiYGACFIbNz585GIbN169YMmURE9FAMlEQVsD4iAQv+vgitXqzYO5V6HSSCiEWPdan2lsmKys7OxpkzZ4xC5tWrhcHZysrKEDKLRpm3adMGMhkniCAionsYKIkqKDFDiflbIxEWkwapRCgzWAoQIUJAc3k+jix9EX07t8aOHTtga2tbgzWuuDt37pQYMkVRhKWlJTp16mTUktm2bVuGTCKiRoyBkqiSopNzsC48AfuvJCM+Q2k8gEYUgdxUaBLO4cCKj+HtYA4Li8I1vl1cXAxTApV30E1dcOfOHZw9e9YoZEZFRUEURVhYWJQYMs3MzGq72kREVAMYKImqaM2aNZj5zLNYtPwXDH1kBMxlEowc0APx1wq7jceOHYutW7fC3t4eOTk5hvP69OmD77//Hp06daqtqldZTk5OsZB55coVQ8js2LGjUchs164dQyYRUQPEQElUBVqtFl5eXrh9+zb+97//4YcffgAAODs7IyMjw3Dcm2++if/++w/nz583bJNKpdDr9fjtt98wc+bMGq97dcnNzS0xZOr1esjl8hJDprm5eW1Xm4iIqoCBkqgKFi5ciHfeeQcA0KpVK0RFRSEzMxNOTk7Fjm3VqhWio6NR9FdOKpXC2toa27ZtQ1BQUI3Wu6bl5eUVC5mXL1+GXq+Hubl5sZDZvn17hkwionqEgZKokiIjI9G1a1dotVrDtvPnzyM2NhZjx44t8RyJRAJRFCGKIlxcXHDhwgW4u7vXVJXrlLy8PJw7d84oZF66dMkQMjt06FAsZMrl8tquNhERlYCBkqgSNBoNunXrhkuXLkGn0wEobHF8/fXXUVBQgOXLlxsFzfs5OjrC3d0dV65cwbZt20oNn42RUqksMWTqdDqYmZkVC5kdOnRgyCQiqgMYKIkqYenSpXj55ZeLbW/WrBns7e1x8eLFYvtsbW3RvXt3rF27FtbW1nBzc4OZmRkyMjLYvVuG/Px8nDt3zmhC9gsXLhhCZvv27YuFzKIR9UREVDMYKIkqYffu3fjqq68QHR2NuLg4o30ymcyoddLJyQkZGRk4deoUunbtatj+ww8/4Pnnn8e4ceOwZcuWmqp6g1BQUIDz588btWReuHABWq0WMpnMKGR27doVnTp1YsgkIqpGDJREVRAfH4/mzZvj6aefxtNPP407d+7AxcUFTk5OEEUR/v7+eOyxx/DXX3/hiSeewOrVq43O79ixIyIjI3Ho0CH079+/lu6iYSgoKEBkZKRRyIyMjIRWq4VUKkW7du2MWjI7deoES0vL2q42EVGDwEBJVAV//vknpk6dipUrV+Kpp54qtt/CwgItW7bEzZs3YW5ujpSUFKP9SUlJ8Pb2hr29PVJTUyGRSGqq6o2CSqUqMWRqNBpIpVK0bdu2WMi0srKq7WoTEdU7XCuNqArOnDkDAOjVq1eJ+318fHD9+nUMHz4cW7duxY0bN9CsWTPDfk9PT7z//vtYsGAB5syZgxUrVtRIvRsLuVyO7t27o3v37oZtKpUKFy5cMAqZf/zxB9RqNaRSKdq0aWMUMjt37syQSUT0EGyhJKqC0aNH459//oFOpyuxdXHmzJn4/fffsWPHDowePRpz587FsmXLih3XokULxMfH4/z582jfvn1NVJ3uo1ari4XM8+fPQ61WQyKRlBgyra2ta7vaRER1BgMlURV07NgRV69eRUFBQYn7t27divHjx2PJkiV455134OTkhMTExGLHRUVFoU2bNmjatGmJ+6nmqdVqXLx4sVjIVKlUkEgkaN26dbGQaWNjU9vVJiKqFQyURFXg5uYGiUSC27dvl7hfrVZDLpdj2LBh0Ov12Lt3LzIyMuDo6Fjs2Llz52L58uV4++23sXDhwuquOlWCRqMpFjLPnTsHlUoFQRCKhcwuXbowZBJRo8BASVQFcrkcbdq0wdmzZ0s9xsnJCXK5HCtWrMDo0aPx7rvv4uOPPy52nF6vR5MmTZCWlobY2Fh4e3tXY83JVDQaDS5dulQsZBYUFEAQBAQEBBRrybSzs6vtahNRBeSptIhLz4Naq4e5TILmztawlnMYyv0YKIkqSa/XQyqVYuzYsdi2bVupx/Xv3x9HjhyBVquFpaUlvL29ER0dXeKx4eHh6NWrF1q3bo3Lly9XU82pumm1WkPILJqQ/ezZs8jPz4cgCPD39zcKmV27dmXIJKpjopNzsC48AaFRKUjIUOL+sCQA8HayQlCAG6b19Ia/u21tVbPOYLwmqqQLFy4AANq0aVPmcUOGDMHhw4dx+PBhdO/eHceOHUNBQUGJE2337NkTkyZNwoYNG7B06VLMmzevOqpO1Uwmk6Fjx47o2LGjYToprVaLK1euGLVkbt++HUqlEgBKDJn29va1eRtEjVJihhLzt0YiLCYNUokAnb54u5sIID5DiTXh8Vh1LA79/VywcFwHeDk13hkh2EJJVEkrVqzAs88+iw0bNuDxxx8v9bioqCi0bt0aL774IgIDAzFz5kwsXrwYr776aonHa7VaODs7Iz8/H7dv34aTk1N13QLVMp1OVyxknjlzxhAy/fz8ioVMBweH2q00UQO2PiIBC/6+CK1eLDFIlkYqESCTCPhwTDtMDmycrysxUBJVUtEgmsTERKO5JUtibm6Otm3b4vTp04bvz58/X+rx//33H0aMGIEePXogPDzc1FWnOkyn0yEqKqpYyMzLywMAtGzZsljILGmQFxFVzPLQaCzec7XK5bw2tBVeDPI3QY3qFwZKokoaOnQoQkJCoNfrH3qsr68vUlJSkJubi86dOyMyMhIqlQoyWelvnQwdOhR79+7F2rVrMW3aNFNWneoZnU6Hq1evFguZubm5AAr/fD0YMtmyTVR+6yMS8NaWSJOV9/n4DpjUyFoqGSiJKql169ZITEw0tByVZfLkydiwYQMyMjLw+++/Y968efj111/x9NNPl3qOUqmEs7MzACA9PZ2rtZARvV5fYsjMyckBUDhZ/oMhs+jPExHdk5ihhGLJQai0eqTvWo7cs7sM+xwGzoR974lGxxckXEDOqR1QJ1+HTpkFUauGxNIWcg8/2HYbDUvfbpDLJAh5eWCjeqeSgZKokpycnGBlZYUbN2489Nh169Zh+vTp+PHHH/HUU0/BwsICPXr0wPHjx8s8b+3atZgxYwaGDh2K3bt3m6rq1EDp9XpER0cbhczTp08bQmbz5s2NQma3bt0YMqnRm/FrOI5eT4dWo8GN5U9An3/HsM/MrQU8n/7W6PisI+uRHba21PJcRr8Guw5B6OPrjDXP9Ky2etc1DJRElWRmZoYuXbrgxIkTDz1WqVTC2toaY8aMwfbt2xEQEIDY2FgUFBSUuGTj/Xr06IGIiAjs3LkTw4cPN1X1qZHQ6/WIiYkpFjLv3Cn8R9Pb27tYyHR1da3lWhPVjOjkHAQvPQQAyL8WgZRNHxY7xnP2DzBz9jJ8zj2/F+qUWMg9AyCxcoAuNwN3jm2EJr1wlTNzzwA0eeIrAEDIywPg59Y4phTitEFElaBWq6HVatGyZctyHW9lZQU7OzucPn0aADBlyhR8+OGH2LFjB8aOHVvmuTt37kSTJk0wefJkpKenl/neJdGDJBIJWrVqhVatWmHKlCkACkPmtWvXjELml19+iezsbACAl5dXsZDp5uZWm7dBVC3WhScYpgbKu3TIsN2qzQAoLxd+zrt0CA79773HbtMxuFg5EnMLpG75FAAgqvMBFI78Xns8AR+MaVedt1BnlN00QkQlioiIAAC0a1f+B0VAQABu3boFAHj55ZcBAMuWLXvoeS4uLvj8889x584dzJgxoxK1JTImkUjg7++PyZMn48svv8T+/fuRmZmJ6OhorF+/HpMnT0ZOTg6++uorjBgxAu7u7vDy8sKjjz6Kjz/+GDt37kRycnJt34bJ5am0uJiUjTMJmbiYlI08lba2q0TVLDQqBTq9CFGrhjK68BUkiZU9nBSzAYkUAJB3OazU80W9Dpqs28iN3GfYZuHdEQCg04sIvZpSjbWvW9jUQVQJRYGyW7du5T4nKCgIERERiIiIQGBgILy9vXHs2LFynfvKK69gxYoVWL9+PV555RUEBgZWqt5EpREEAX5+fvDz88OkSZMAAKIoIjY21qglc8mSJcjMzAQANG3atFhLpoeHR23eRoVxNZSaVdNLGHbr1g329vaYO3cuRo8ebdTDk6vSIiGjcM5XZcwJQ8uilX8vSK0dYeHdAQVxZ6HNuAH17Wsw9zDukUr8djr0eVn3NkiksG4zAA6DZho2JaQrkafSNoplGhv+HRJVg6I5JHv37l3ucyZNmoQvvvgCGzduRGBgIMaPH4+lS5fi0KFDGDBgwEPP37VrF3x9fTFq1CjcunXroe9eElWVIAjw9fWFr68vJk4sHOkqiiLi4uKMQuY333yDjIwMAICnp2exkNmkSZPavI0ScTWUmlOboT0mJgZ37txBaGgoPDw88MILL2DWrFnw8PBAfHqeoS5F3dsAYNW6b+F/A/qiIO4sACDv8qFigbIYQVLYqnnf0BQRQFx6Htp5NvxVrzgoh6gSBgwYgCNHjkCn01XoPJlMhi5duiAiIgJJSUlo2rSpYaBOebz99tv47LPPMHfu3HJ1lxPVBFEUER8fbxQyT506hfT0dABAkyZNioVMT0/PWqsvV0OpGeUJ7UWK9psitGu1Wty8eROxsbGYMGGC4c/h/RwdHdFFMQ7XWo6HXqXEjW+nF07/Y2GLZi+thSCRQqfMxo1vZwCiHlI7NzR97lcIgmAoQ5UUBVGjgibrNnIitkGTlgAAsAroA9dx8w3HbX2uD7p4N/zFBxgoiSrB19cXaWlphpGy5eXt7Y3s7GzD4AcPDw/k5+cbPpeHl5cXbt68icuXLyMgIKBC1yeqKaIoIiEhoVjITEtLA1D4Z7+kkHn/P9jVgauh1AxThPZHO7ghPj4ecXFxSExMxM2bN3H79m2kpKQgPT0dmZmZuHPnDvLy8qBUKg2DJcsTayQSCQaMnYrYgMnIvbAf6f98/dBz3Kd/CYtmbUrcp8m6jaQfZ939JMD7tb8gyMwBAP/O7dcoWijZ5U1UCWlpaZWav69r167Yvn078vLyYG1tjREjRuC3335DZGQkOnToUK4ydu7ciU6dOmH48OG4fv16hetAVBMEQYCPjw98fHwwfvx4AIUhMzEx0Shg/vDDD0hNTQUAuLu7o2vXrkYhs1mzZiYLmesjEkwSJgFg8Z6rcLWRN7rVUMqjKqFdpxeh1enx1pZIzPm/33Hn2MYSj5NIJDAzM4OFhQWsrKzg6ekJe3t7ODk5wcXFBe7u7mjSpAnee+89qFQqo3Otra3h7OwMXdZtQBSRd+lgueqmvHwIFs3aQK9RQWImN9on4P4/oyL0KiWkMnMIAJo7W1fkR1BvsYWSqBKkUin69OmDsLDSR/+V5JdffsHs2bOxevVqPPHEE4iKikLr1q0xbdo0rF1b+kS5D5o1axZ+/fVXfPzxx3j33XcrWn2iOkMURdy4caNYS2ZKSuHoWFdX12ItmV5eXhUOmRVdDQUA9Colso9ugDLqCLQ5aZDIbWDZojPs+02DmWOTRrUail6vR1paGmJjYxEfH48bN27g1q1bSE5ORmpqKjIyMpCdnY1c906Q9XnCZNcN1F9FP08JmjVrBh8fH/j6+sLJyQmxsbGYPXs2Xn75ZYwcObLU85s3b474+PgS97Vq1Qrmo97FhaVPAXodBHNLOAx8oO46LTL3/woAkFo7oumLq3Hjm6mwbhcE8yatILVxhO5OGu5EbIUmtfA6UjtXNH1uZeEvVc5WOPhakGl+GHUcAyVRBd25cwf29vZ48skn8dtvv1Xq3AkTJmDTpk0ACt/lkUqlhq7A8tDr9XB1dUV2djYSEhJq9X00IlMTRRE3b94sFjKLpipycXEpFjK9vb3LDJkVXQ1Fr1Li9to3oEmNK1aWxMIG7lM/g6VHizJXQ9Fqtbh16xa8vLxK3F8bdDodbty4gfj4eCQkJBiCYUpKCtLS0pCZmVkYDHNzoVQqoVKpoNFooNfrSy1TEARIpVJYujaD47SvIUjNkL77u3IsYRgJZdRRqG5ehjYnDfr8XEgtbSH3ag/7Po/D3K1FiaH90KFDGDt2LLKysjBp0iSsX78eQOFzcffu3di4cSOOHDmCuLg4aDSaYvU1MzPDmjVrMGnSJIx6fgH+/eEjAMXffSyStPIlaFIKe4PcJn+ClPVl/BIvkcF13Nuw8u8JqUTAjJ4+jWYeSnZ5E1VQ0VQ/5e2ivp+dnR2sra1x8uRJwzaFQoHNmzcjPj4ePj4+5SpHIpFg69atGDhwIIYPH45z585VuC5EdZUgCGjWrBmaNWtmmPhfFEUkJSUZBcyVK1di4cKFAABnZ+diIdPHxweCICA6OQdhMYW/sBXEnTEKkwCgSYmFJj3RaDWUrMPrDGFS7tUedoGPIv/6SeSe3QV9QS7S//sGTWYuQVhMGmJScoqthnLo0CH873//Q0xMDFJTU2Fvb9p36AoKCkz+fqEgCDAzM4O5uTmsrKzg4uICOzs7ODg4wMXFBW5ubmjSpAmaNm0Kb29vNG/eHF5eXjA3L3xX8P7Qrow6alR23uVDxQJl9rFNKIg9bbRNl5cJ5ZUw5MeEw33Kp5B6tcX8rZGG0P7LL7/gueeeMwTc//77DyNHjsTp06eRnJxsuD8LCwsEBASgS5cuWLNmDYDCniV3d3fDa0MAkHp2v+Haln4l/2Jg5dcD2XcDpfLyIdj3nYKChEhoM5OgU96BIJFCausMC6/2sO0+GuZuLQrvRS9ieq/G80oEWyiJKujTTz/Fu+++i7CwMPTr16/C53fp0gUXLlww/OZ84sQJ9OzZE8899xy+//77CpU1btw4bNu2DT/++CPmzJlT4boQ1XcPhsxTp04ZFhBwdnZG165dIXR/HDFoAp0IpO34CnkXQwEYr4Zi33eKYTUUUafBjWXToVflARDQ9MXVkNk4FYbaX56DNv0GAMDjyaWw8vQ3aoW6efMmXn31VWzYsAGCIEAURRw9erTUKcbu3LmDuLg4xMXF4caNG7h586ahGzk9PR1ZWVmGYFhQUGAIhmV58P1CGxubEt8vbNasGby9vdGiRQt4eHhUaSqyyixhmLzhfWgzk2DTaSjMPfyhvZOK7LC10OUWTkEl92oPj2mfAQB2ze2LRW//H37//fcSr+/o6Ij27dtj2LBheOKJJ4xahT08PJCcnIxevXph+/btxVZ9KgrCFRk89DBSidDo1vJmCyVRBV28eBEA0L1790qd379/f5w9exaXLl1C27Zt0aNHD1hbW2P79u0VDpQbNmyAk5MTXnrpJUyZMgV2dnaVqhNRfeXp6QlPT0+MHj3asO3WrVs4ffq0IWCezzGDaIMSV0NRRh0B9DrkXQ4zBEp1avzdMAnI7N0gs3ECUNiCJ/dsbQiUqsSLkHv4IfRqCl5Mc8eCBQuwYsUKQ+Araq+ZOHEibGxskJOTA6VSiYKCAmg0modOOyaVSmFubm4Ihm5ubnBwcICTkxNcXV3h7u4OT0/PYu8XmppOp8OgQYPQsWNHvPvuuyXOK1qZJQztej4GC+/2EO6uSAMAUks7pG75BACgvhUNABBEPQY88w5Sd5UcJletWoWZM2eWuA8AXn31VSQmJuLLL7+EXC4vtn/huA5QLDlo0kApkwhYOK7ivVj1GQMlUQVdu3YNMpkMFhYWlTp/0qRJ+Pbbb/Hnn3/i448/BlAYMnft2oW0tDS4uLiUuyxzc3OsWbMG48ePx6hRo3Do0KGHn0TUwDVp0gQjR47EyJEjkavSosMHuwGUfzUUXfa95fIk1g5GZUvv+6zNug0AiEvLg5unF0RNQYn1uXXrFiwtLWFhYQF7e3t4eXnBwcEBzs7OcHV1hYeHBzw9PeHl5QUfHx80b94cNjY2JvyJVE1BQQEOHz6Mw4cP45dffsHcuXPx1ltvGT2rylrCsKTQDgCWzTsVu5bM6d774MLdkdSiIIF96z5wiQ9FdnY2kpKSCo+VyaDVahEREVFmoHz99dfLvD8vJyt8OKYd3toSWY6fRvl8NKZdoxisdT8GSqIKSkpKgq1t5Vdz6N27NyQSCfbv328IlPPmzcOuXbvw1VdfYdGiRRUqb9y4cRgwYAAOHTqEzZs3Y8KECZWuG1FDU5nVUPT3BUNBamZUniC598+mqCmcjkYQBMgcm0CTEltqPbRareF9xrS0NEgkEgiCAIlEUuxLKpUafV/0VfRZJpMZthV9L5PJDN+bmZkV+97MzKzE783NzQ2fi743Nzc3fJmZmRkNbFGr1fj666/x3Xff4emnn8arr74KW0eXKi1heD9l1BHD95a+95a21Vo44OyZ87CWy5CSkoLDhw/j0KFD2L9/v0mW+5wc6I20XJVJppV6fWhAo5xOioGSqIIyMjLQrFmzSp8vkUjg7u6Oy5cvG7YNGzYMcrkcGzdurHCgBIAdO3bAzc0NTz75JMaMGWN4SZ6osVNrCwdv6FVK5F8rHAwnsbCFhU9h65hVQB9k7PkBEPWFLWiDnoTE7F7vg6gzHiUs6u+9vyjcNxfho+MnYM+fP5e4SIGTkxOaNWsGnU5n9KXX642+L/pcNKpaFEXD9qLvRVEs9n1R1/qD/60uoiiioKAA33//Pb7//nuYu/uiyVOFK3dVZQnD/GsRyD66AUDh/yOHATPuXRP3ljB0c3PD+PHjDfObmsqLQf4oyErDt0duQWpmDj3KPzVV0YTsH41p1yjDJMBASVRh+fn5VZ4GpFOnTti1axfUarUh/AUGBuLIkSNQKpWwsqpYV4mdnR2WLVuGOXPmYOLEieVeypGooTOXFQ40UUYfh6hVAwD0BTlI+GJssWN1d1KgunkFUvt7gzZ0eVnGx+RmGr6XOdxrGVvw3jvY8P3n+O+///DWW28hMvJe9+kbb7zx0G7X6qTT6aBWq6FSqQwDe1QqFVQqleF7tVpd6ld6ejrefPNNQ3lFg428vb0xYcIENO3YF8uuVCy0PzjFU96VI0jb8SWg00Iwt4TbxPchszcePFP0y0F1OXjwIN6aOAQ27j4Y+cFaHLmeUe4lI/v4Ojf6dd4ZKIkqICkpCaIoVnnJw+HDh2PXrl34+++/DV3Uzz33HA4fPoxvv/3W6OFdXs8++yy+//57/P333zhw4AAGDRpUpToSNQTNna0hABVaDcVx8NMQ5NYQVXnQZadAm5MGma0LRFGEKinKcKzc6+78gqKI52dMhKWZBCkpKYiKijIq09LS0lS3UylSqRSWlpaVrkdSUhLefPNNQ5AcOXIk3nvvPfTo0QMAcDEpG8uuHK5QaL9/CcPcyH1I3/kNIOohkVvD7fEPIG9afInDol8OTC0zMxNvvvkmVqxYAQDo0sob62b3RnRyDtaFJyD0agoS0pW4P1YKALydrRDUyg3Te3kXmzaqMaqe/ztEDdTRo4VzqxXNYVZZkydPBgBs27bNaJtUKjXMmVYZu3btglQqxfjx48uciJiosbCWy9BErjF0uQrmlnAMnmP8NfgZw/HKK4cBiRQ2HRV3t4hI2/4llNHhyNj9HbQZhSO8zT38IffwAwDICrJwaP9e7N69G2fOnIFarTaUZ25ujlmzZqE+s7OzQ5MmTTBhwgScO3cOO3bsMIRJoHKhvUjOqX+Q/u/SwjBp5QD3qYtKDJPVsYShKIr4888/4efnh19//dWwffjw4QAAf3dbfDCmHQ6+FoQLHwzDv3P7YarLTSStnItnnaNw8LUgfDCmHcPkXWyhJKqAM2fOAAB69qza3GJubm6wtLTEiRMnDNskEgk6deqEs2fPQqvVQiar+F9PDw8PfPTRR3jnnXfwzDPPVHglH6KGyCnlDKAvnKLHskUX2HUbXeyY3Auh0KRchy4vEwXx5+HQbxoK4s5BkxoH1Y2LSL1x0XCsRG4N5xH/B6Cwy3P64C7oNqSwt+H+MAkUrt4yceJEzJ49G6NGjarSXI+1xcbGxjCyuiRFoT3uvtBe1hKGyiuH4aiYjZyIv5G5/5fC/VIzOA58Anp1PgoS7/2sLe62Ans7W8FabrrIIooixo0bh+3btxtaXos8OE9l0T2287RHTHgINCmx+OLTjzHvhedqvfW5Lql/f7KJatGlS5cAVG6VnAf5+voWW2P26aefhl6vx8qVKytd7vz58+Hr64vVq1fj7NmzVawlUf1X3tVQiigvH4JEbgWP6V/Arud4yOzdAakMEisHWLUdCI8nl8DcrTmAwtVQHm3vjNGjRyMiIgIuLi5GvwzK5XL8888/GDt2LMzNzdG2bVvMnz/fMPl6Q1FSaDf66jEOZm6+AGAI7UXTCxVu1CD9v2VIXvem0RdQGNqDWhUPeVVVNA/og4OYSgqUQOEI9z179gAAsrKy8OGHxSdvb8y4Ug5RBXTp0gWXLl2CSqWqclnPPvssVqxYgdjYWDRv3hxA4QPLwsIC3bp1Q0RERKXLjo6ORkBAADw9PXHjxo0q15WovquO1VAEiFDGnkXKhvdgbm6OJk2awNHREVFRUcjPL5w6JzY2FnZ2dli+fDn++usvXL582TANj6OjI/r06YPZs2dj9OjR9bL1skjPPv1x4thhAIDzyJdh02FIsWOyDq1F9tHCdbdtOg2FJiMJqsQLZZbr89Y/AICQlweYvGtZFEWsXbsWTzxh3JoaERFR4sIV27dvx6OPPmr4LJFIEBERga5du5q0XvUVAyVRBXh4eECv1yMlJeXhBz/Enj17MGzYMHzyySd45513DNvbtGmDmJgYqFSqKv0DM2/ePHzzzTd4/fXX8cUXX1S5vkT1WWKGEoolB6Ey4UhhuUyCp9xu4O2XnjXaXtSFamFhYQiW99u3bx9++OEHHDp0CKmpqQAKB874+/tj7NixeOmll+Dp6VnsvLquWpYwFIA+LV2qbQnDouVrg4ODERISAlEUERcXBx8fnxKP3bFjh6FlUyqVok2bNjh9+jTMzMyKHd/Y1N9fh4hqQXZ2Ntzd3U1SlkKhgCAICAkJMdo+bdo0aLVabNmypUrlf/311/Dw8MBXX32F2NjSJ1wmagyKVkMxpY/GtMNbc2djzpw5RtPgFLXTbNy4scTzhgwZgs2bNyMlJQXp6en45JNP0KFDB1y7dg2ff/45mjZtCkdHR4wYMQJ//fVXvRlgt3BcB8gk5Z+78WFEUYRGrcKF397B8uXLERYWhqysLJOVf/LkSWzbtg3t27fHnj17cPr0aSxevBje3sXnkUxPT8c///xjtFymTqfDhQsXSl1fvLFhCyVROen1ekilUowcORL//POPScp0c3ODKIqGVgoAyM3Nha2tLQYOHIgDBw5UqfyTJ08iMDAQrVq1KjaVCVFjtDw02mSrobwQVDjKOysrC/7+/khPTzeESUEQsHjxYrzyyisVKvfAgQP4/vvvcfDgQUNPiFQqhZ+fH8aMGYOXXnqpSgsrVLf1EQkmXcIwY9e3yDm722hbkyZN0LVrVyxZsgT+/v6VLtvb2xs3btxAbGxsiS2S9wsLC8OAAQMAFP7/0Ol0GDVqFLy9vTF37ly0bt260vVoKNhCSVRO0dHRAGDSB0eHDh2Qnp4Orfbe6hs2NjZo3rw5wsPDq1x+9+7dMW3aNFy9ehVffvlllcsjqu9eDPLHZ+M7QC6TQFrB1jSpRIBcJsHn4zsYwiQAODg44LvvvjOESblcDisrK7z66qto0aIFzp8/X+5rDBo0CBs3bkRycjIyMzOxcOFCdOzYEbGxsfjyyy8N64APHz4cmzdvrnOtl5MDvfHa0FYmKev1oQFY9n+Ti22/desW/v33X6NfxCtq0aJFSExMxJw5cx4aJgGgf//+uHXrFvLz8zFy5EgAhe9UfvfddwyTdzFQEpXT8eOFIxK7dOlisjKDg4MhiiL27t1rtH3ChAkoKCjAvn37qnyNVatWwd7eHvPnz0daWlqVyyOq7yYHeiPk5YHo4+sMAA8NlkX7+/g6I+TlgSUurTdx4kQMGzYMAPDFF18gKysLTz31FOLj49GpUyc8/vjjxaYUehgHBwe8/fbbOH36NFQqFQ4ePIhJkyZBLpdj165dmDhxIszMzBAQEIDXX38dCQkJFSq/upgytE+fPh2+vr7Fjnv11VfRp0+fStUvKysLCxYsMPwiUF4eHh6wsLAw1CcxMbFS12+oGCiJyqloCp7evXubrMypU6cCAP766y+j7UXLtC1ZsqTK15DJZNi0aRO0Wi0eeeSRKpdH1BB4OVlhzTM9sXfeAMzo6QMfZ6tiKzcLAHycrTCjpw9CXh6ANc/0LHVpPUEQsHLlSnz55Zd4/vnnIZPJsHLlSkRFRaF169bYtGkTHBwcsHr16krXecCAAVi/fr2h9XLRokXo3Lkz4uLisHjxYvj4+MDBwQGPPPIINmzYUKutl6YK7TKZDB999FGx4w8ePAilUlmpuo0fPx4ajQZr1qyp1MDHohbJkydPVur6DRXfoSQqp6LlEvV6fbF1aKui6DfeojkuizRp0gR5eXm4c+eOSa5TVP9Vq1Zh5syZJimTqCHJU2kRl54HtVYPc5kEzZ2tTTaZ9i+//IKXXnoJ+fn5aNeuHXbs2IEWLVqYpGwAOHz4ML777juEhoYiOTkZQOG0Ni1btsSoUaPwf//3f+Xq2q0OVV3CUKfTISAgANeuXYOtrS0CAwOxf/9+2NjYYM+ePRX6JX/fvn1QKBTo3bu3YeWzijp+/Dh69+6NDz/8EO+//36lymiQRCIqlzZt2ogWFhYmL7dVq1Ylljt79mwRgHj69GmTXCc/P1+0tLQULSwsxJycHJOUSUTll5+fL44fP14EIAqCIM6ePVvU6XQmv052drb4xRdfiN26dRPlcrkIQAQg2tnZicHBweIff/xRLdctj9wCjXjhZpbo0LKzaObWQoy7catc561fv14UBEHctm2bKIqi+PPPP4tSqVQUBEF89913y1WGTqcTnZ2dRalUKqamplb6HpRKpQhAnDZtWqXLaIgYKInKydnZWWzSpInJy33iiSdEAGJSUpLR9piYGBGAOHnyZJNd688//xQBiEOGDDFZmURUMadPnxa9vb0NIa8oJFWXw4cPi1OnThU9PDwM4VIikYh+fn7ivHnzxOvXr1fr9R+UkJBgqMfUqVPLfV5aWprR55iYGMM9devWTczNzS3z/FdeeUUEUO4AWhaJRCL269evyuU0JAyUROVkZmYmdu3a1eTlbtmyRQQgfv3118X2OTk5iU5OTia9Xq9evUQA4o4dO0xaLhFVzOeffy6amZmJAMTAwEDx1q3ytdZVRU5Ojrh48WKxe/fuRq2Xtra2okKhENeuXStqNJpqrcPHH39suC4Acc+ePZUuS6fTiWPHjhUBiNbW1mJYWFiJx928eVOUSCSih4dHpa91P2tra9Hf398kZTUUDJRE5aDRaEQA4mOPPWbystVqtQhAHDp0aLF9kyZNEgGI165dM9n10tPTRTMzM9HW1rba/+EgorJlZ2eLCoVCBCBKpVLxjTfeqNHu6KNHj4rTpk0TmzRpYtR62bJlS/Gll14SY2JiTHo9nU5naJ0tupaPj4+oVCqrVO6vv/5q6AJ/++23i+3v1q2bCEA8fPhwla5TpGnTpib/Zb++Y6AkKocTJ06IAMT33nuvWsp3cnIq8TfnkydPigDEZ5991qTXW7ZsmQhAnDhxoknLJaLKOXjwoOjm5iYCEF1dXcXQ0NAar0NOTo741VdfiT169CjWejl48GDx999/r/IvoaGhoUatk0Wh8q233qpy/a9fv24Ixp07dza8K75p0yYRgDhs2LAqX6NI586dRXNzc5OV1xAwUBKVw/Lly0UA1fauU79+/URBEEpsmbCxsTGEzejoaJO1VrZt21YEIB49etQk5RFR1eh0OvGtt94SpVKpCEAcPHiwmJ2dXWv1CQ8PF2fMmCF6enoawp8gCKKvr6/44osvilevXq1wmTNmzDCUUxQmAYjm5uaiXq+vcp11Op1h4JO1tbUYEhIi2traiubm5iYZjKjX68WsrCxxwIABIgDxp59+EhcsWMBXiEQGSqJymTNnjghATE5OrpbyFyxYIAIQDxw4YLRdr9eL/fr1EwGIfn5+hnetTCExMVGUSCSiq6trrY34JKLikpOTxZ49e4oARDMzM3HRokW1XSUxLy9PXLp0qdizZ0/RwsLCEDBtbGzEoKAgcdWqVeVqvZw/f77YvXt3ccyYMYaWxF9//VU8ceKESeu7atUqUSaTGeq5ZMmSKpep1WqNuuvv/xo9enTVK13PMVASlUNQUJAoCEK1lR8VFSUCEJ9//nnDthUrVojNmjUr9uB69NFHTXbdd999VwQgPvfccyYrk4hMY/v27aK9vb0IQPTy8hJPnTpV21UyiIiIEGfOnCk2bdrUqPWyRYsW4vPPPy9euXLloWUIgiAOHjy42up4f/d6x44dTdLaO2DAAEPr6v1f69atM0GN6zcGSqJy8PPzE62trav1GmZmZmLHjh0Nn4taRe//MjMzK/GF86rw9vYWBUEQL126ZNJyiajqdDqdOGfOHEOIefTRR8X8/PzarpaRvLw8cdmyZWKvXr2MWi+tra3FQYMGiStXrhTVanWx8ywsLMS2bdtWW70CAgIMAx4BiFZWVuL+/furVGZ0dLRobm5u9Fy2srIS8/LyTFTr+ouBkqgc7O3tRW9v72q9hq+vr1FoValU4siRIw3vGBV9rV692qTXvXDhgigIgujj42PSconIdGJjY8X27duLAEQLCwvxp59+qu0qlerUqVPiU089ZdTDIgiC2Lx5c/F///ufePnyZVEURdHFxcVk0/g86KeffhIBiJMmTRJFURTXrl1r6AJ/5ZVXqlT2l19+aXRfTz31lCmqXO8xUBKVg1QqFXv37l2t1yiaIig9Pd2wraCgQAwODjbqYgkPDzf5tYtaQxcsWGDysonIdFavXi1aWVmJAMSAgIBKDYypSfn5+eLy5cvFPn36iJaWlkatlxYWFqJcLhdVKpXJr2lhYSFaWVkZlR0fHy96eXmJAMT27duLmZmZlSpfo9GInTp1MtzLwYMHTVTz+o2Bkugh8vLyRADijBkzqvU6a9euFQGIP/zwg9F2pVIpDhw40PDwysrKMvm1dTqd6OLiIkqlUjExMdHk5ROR6ahUKnHy5MmGFrKZM2fWmzllz5w5Iz7zzDOGYFd0Dz4+PuKcOXPECxcuVPkaRROd//7778X26XQ6ccqUKSIA0dLSUty7d68oioXP+eDgYHHt2rXlusbZs2cNc4dyUGMhBkqih9i3b58IQPzss8+q9TpF68OOGjWq2L7c3FzRxsZGBCBqtVrDerin4zPECzezxNyCqv9jcvjwYRGA2K5duyqXRUTVLzIyUvT19TWMtt6wYUNtV6lCiqb36d27t1HrpZWVldi/f3/xp59+qnDrZUREhAhA7NChQ5nHrV+/3rBK0UsvvSQ+9dRTIgDRxcWl3JOs+7VuJ7bsNtCkz+H6TBBFUQQRleqLL77Am2++iZCQEAwZMqRar2Vvbw9bW1vcuHGj2L51/+zH3G82wH/Ao0hR6nH/X1wBgLeTFYIC3DCtpzf83W0rdf0JEybgr7/+wrfffosXX3yxcjdBRDXqm2++wRtvvAG1Wo0uXbpgx44daNq0aW1X66Fef/11LF68GFeuXEFAQADOnz+Pb7/9Frt378aNGzcgiiIEQYCXlxeGDRuGl156Ce3bty+zTC8vLyQlJeH69evw8fEp89ibN2+iT58+SEhIMGwTBAFff/015s2bV+I50ck5WBeegNCoFMRn5KHw6Xv3XJjmOVxfMVASPcQTTzyBNWvWICcnBzY2NtV6rZ49e+LUqVPQarWGbYkZSszfGomwmDQIECHe9wB7kFQiQKcX0d/PBQvHdYCXk1WFrq9Wq+Hi4oKCggKkpKTAwcGhsrdCRDUoNzcXjz/+OP777z9IJBK89NJL+OqrryCRSGq7aqX6+eefMWfOHGzevBmPPfaY0b6CggKsXr0aa9euxenTp6FUKgEAVlZW6NKlC6ZPn44nn3wSFhYWhnMWLlyId955B8899xy+//77ctXh0qVL6NixI3Q6nWGbi4sLEhISYGlpadh2/3O46Dlbmqo+h+uruvsnjaiOiImJgVQqrfYwCQCDBg2CTqdDREQEAGB9RAIUSw7i6PV0ACgzTAIwPOSOXk+HYslBrI9IKPP4B5mbm+OPP/6ARqPByJEjK3EHRFQbbGxssHPnThw+fBju7u5YunQp3NzcsGfPntquWqnatm0LALh69WqxfRYWFpgzZw7CwsKQl5eHyMhIzJkzB66urjh69Ciee+45WFlZwdvbG7NmzcLhw4fxwQcfwMHBAcuXLy/X9VUqFSZMmAC9Xm+0PS0tDT/++KPh84PP4bLC5P37K/scrq/YQkn0ED4+PsjOzkZWVla1X+vMmTPo2rUrXn31VTQfOQeL9xR/0FbUa0Nb4cUg/wqdM2TIEOzfvx/r16/HpEmTqlwHIqpZ77//PhYtWgStVov+/ftj27ZtcHJyqu1qGcnKyoKjoyNmzZqFFStWlPs8tVqN33//HWvWrMGpU6eQl5dn2Ne6dWvMnTsXTz/9tFHrZUni4uLQs2dPpKSkAACkUqmhpVIikeDWrVvYeDG71p7D9Q0DJdFD2NjYwMPDAzExMTVyPZlMhtYjn0Zu27EmK/Pz8R0wKdC73Mfn5ubCxcUFEokEGRkZD30wE1Hdk5aWhkcffRRHjhyBTCbDe++9h/fff7+2q2VEIpFg6NCh2LVrV6XLWLlyJZ555hmYm5tDo9EY3r1s2rQpgoOD8dJLL6Fz585G54iiCH9/f3h4eODHH39EXFwczp8/j3PnzuG///5DTk4OfAZPAXpMq+Id3lPR53B9w0BJ9BBSqRQDBgxAaGhojVzPu00XZDu2wp1jG413CBJILG1h7uoD6w7BsGkfZNiVe2E/CuLOQn07BrqcdOi1KshsXWHZsjvs+06GlZ0jQl4eWKF3eX777Tc8/fTTGDFiBP79919T3R4R1bD//vsP06ZNQ2ZmJjw9PbFlyxb07NmztqsFoLBru3Xr1jh79mylztfr9XBzc0NWVhZu374NOzs7rFmzBmvWrMHJkycNrZeWlpbo3Lkzpk6dilmzZiE6OhodO3aEIAho164dQkJC4O7ubih377EzmL01HpDKkL7rO+SevRd4HQbOhH3viUb10GYl486pv6G6eQXq5GuArvA9ePu+U+DQvzCUymWSCj+H6xO+Q0lUhrS0NOj1evj711xXhb3if4BQwruSoh56ZTYK4s8j/Z+vkB2+xbAr/b9vkXdhPzRpCdCr8gCdFtqsW8g5tQO3V78CVd4dzN8aWaF6PPXUU+jWrRt27tyJffv2VfW2iKiWDB8+HGlpaZg7dy5u376NXr16YdSoUYaBLrXJysoK6enplT7/9ddfR3p6OubPnw8XFxeYm5vjmWeewYEDB5Cbm4tLly7hueeeg7u7O44fP465c+fC0tIS/fr1A1DYUnn58mX07NkT169fN5T7+yU1pGbmEHU6KKOOGl0z7/KhYvVQp1xHTsR2qJOiDGHyQVq9WOHncH3CQElUhqNHCx8kHTt2rJHrRSfnIMemGQTh3l9NC99ucJ/2OdwmfwLLVr0N23NO/WP4XhAEyJu1hdOwF+A2+RPY958OSGUAAG12MrJObEdYTBpiUnIqVJ+dO3dCJpOV+OI6EdUfEokEy5YtQ2xsLDp16oR///0XTk5O5R7AUl0cHBxw586dSp2blJSEpUuXwsPDAx999FGJx7Rp0wbff/89YmNjoVarsWrVKgQFBSE3N9dwjE6nQ3x8PDp27Ijw8HBEJ+cgLCYNOr2Igrgz0Ocb10+TEgtNeqLRNsHMAhbNu8C+7xRY+vcqsS46vVip53B9wUBJVIbTp08DQI11D60LT4D0gcZJqZUDLLzawbJ5Zzj0n27YrsvLNHzv+ti78Jj+BWy7DC88ru9k2Ha5N0pbdesqpBIBa49XbLShm5sbPv30U2RlZeHJJ5+s1D0RUd3h7e2Ns2fP4o8//oBMJsPcuXPh5+eHS5cu1Up9XF1dK91SOmbMGOj1emzevLlcx8tkMsycORPbt28vcTqlvLw89OrVC1Pe/x6Su8/hvEv3WiOt2gy4d+wl41ZKyxZd4D75Yzj0nwYz52al1qEyz+H6goGSqAwXL14EAHTp0qVGrhcalQJdKW81izoN8qOPGz6bu96btNeyRddix5s5eRq+l5hZQKcXEXo1pcJ1euONN+Dv7481a9YYAjYR1W9TpkxBVlYWZsyYgevXr6N9+/aYNm0aNBpNjdajSZMm0Gq1SEtLw8WLF5GWllau8zZv3oxTp07hkUceQd++fSt0zbCwMKO5fmUyGdq3b48BAwagd+/eyLJqCr0IiFo1lHefuRIrezgpZgMSKQAg73JYha5ZpLLP4fqAgZKoDLGxsTAzM4NMJqv2a+WqtEjIKP6bet6FfYj/bBQSvhyHrENrABQ+3BwVc8os7/73fix9uwEAEtKVyFOV/H5PWXbv3g2JRIKRI0ey65uogZDJZPj9999x8eJF+Pn54Y8//oCjoyPWrVtXrdcVRRHPPfccAgMDERISAqCwpbJ9+/aYMGHCQ8/XarV4+umnIZfLsWnTpgpfv3Pnznj33XexevVqnDt3zjDP5cGDB7En9BB0Fo4AAGXMCYjqfACAlX8vSK0dYeHdobAOGTegvn2twtcGKv8crusYKInKkJSUBDs7uxq5Vnx6Hso75YIgM4eoLr2bKPPQGhTEnwMAmHsGwLpD4ZKRIoC49LxSzytNixYt8Morr+D27dt47bXXKnw+EdVdbdq0wdWrV/Hdd99Bq9Vi+vTp6NSpE+Lj46vleoIgYNeuXUajsIsEBQWVeM7PP/+Mn3/+GTqdDrNmzUJOTg4+//zzSi044enpiY8//hhPPPEEOnbsCHNzc8O++5/DyvsG31i1LmwFtQq41xpa0uCc8qjsc7iuY6AkKkNWVhbc3Nxq5Fpqbcktf0WDctynLIR9/2kABOjupCJ1y0LocjOLHZ+5/1fcOboBACBzbga3Ce9DuNtNU9Z1HubLL7+Ep6cnli5dimvXKvebORHVXc8//zwyMjIwevRonD9/Hr6+vnjhhReqpVfi559/LrZNEIRS39VesGAB5syZg/bt2+P333+Hr68v/u///s/k9Sp6PupVSuRfOwkAkFjYwsKnEwDAKqAPcHfQZN7lMFR25sXKPofrMgZKojLk5+fDx8fn4QeagLms5L+ORYNyLHw6wqHvFFj4Fr4vKWpVUMaEG44TRT3Sdy3HnRNbAQBmrs3hMXURpFb25bpOeRTNR/nII49UugwiqrusrKzw999/48SJE/D09MT3338PZ2dnk89FGxwcjClTphgNjgkKCirxeSuKIjIyMgAAV65cgSiK6NGjR7WsXlb0fFRGH4eoVQMA9AU5SPhiLOI/G4Uby6YBYmEY1N1JgermlSpdpyFpeHdEZCKxsbEAgICAgBq5XnNn64es1H3Xfb8R6/MLp58Q9Tqk7fjKMPmuuWcA3Kd9Bqm1o9Gpwt3rVFbnzp3xxBNPICYmBp999tnd6ohGU3AQUf0XGBiIxMREfPzxx8jNzcWoUaPQt2/fcg+aKY+lS5fC1tbW8Hn27NklHpebmwu1Wm20bePGjfDz88PNmzdNVh/g3nM479LBch2vrES3d1Wfw3UVAyVRKYrmoOzUqVONXM9aLoN3CSso6JRZKEi8iIL488g+uhEFcWcN+8ycmgIAUrcshPLuA1Bq5wqHflOhSY0vPC/xItQpcQAAb2crWMurNsBo5cqVcHR0xHvvvYczZ85gzJgxcHZ2NqyHS0QNx7vvvovU1FQMHDgQR48ehYeHB9577z2TlO3m5oavv/4aQOE8mY8++miJx5X0bNHr9fDx8TEKpBWRk5ODgoKCYtut5TI0kWsMz1nB3BKOwXOMvwY/YzheeeUwRFEPnTIbeVcOI+/KYWjSbxj2a9ITDdt1ymwApnkO10UN746ITKRoKbBevUqepLY6BAW4YU248YvwBddPoeD6qWLHmru3hKVfDwBA/n1d37o7qUjZuMDoWLlXezSd8TmCWlX9fVCJRIJNmzZBoVCge/fuAAof7jExMTX2vikR1RwHBwccOHAAISEhmDx5Mj755BP88ssv2LRpk2HFGaCwt+LmzZto1qz0eRgf9NRTT+GFF16Ak5MTLCwsSjzm/kApkUhgaWmJL774AnPmzIFUKi3xnLIUFBTAxcUFarUa9vb2aNKkCXx8fGBnZ4erV6/ipswD0OsAFM4vaddtdLEyci+EQpNyHbq8TBTEn4cgSJC27bNixymvHIbyymEAgPuUhTBv0ckkz+G6iIGSqBRXrhS+G1NTXd4AMK2nN1Ydiyt1vyCTQ+boAUv/XrDv+RgEafn/Cuv0IpIObcBOWS9IpVLo9XrDl0wmw5AhQ4xGO5YmOjoaH3zwAQAYvax/48aNUs4gooZAoVAgJSUFr7/+OpYuXYr+/ftj2LBh2Lx5M2xsbLBw4UK89957OHz4MPr06VOuMgVBwJjxE3ErR4szCZkwl0nQ3NnaqAWvqLcIAMaPH49vvvkGnp6eJRVXLnK5HL6+vrhy5Qqys7ORnZ1teN4DgJXtvV/qLf1KXtTCyq8HslMKl2pUXj4E67aDynVtnV7E9F7ela57XSaIlR2iRNTAdejQAdHR0SV2i1SnR5eG4HxyAfTle6OyXKQCYJYZi6gf55Z6zPbt2zFmzJiHltWlSxdD620RQRCwePFivPLKK1WtKhHVA0lJSRgzZgxOnToFc3NzvPbaa1i8eDHUajVat26N8+fPw8zMrNTzo5NzsC48AaFRKYh/YP5dAYC3kxWCAtwwrac3Zo4bhuPHj2PlypUmW7Fr5syZ+P3334ttnzNnDn788UfM+DUcR6+nQ6c3XUSSSgT08XXGmmdqZuW1msZASVQKNzc3SCQS3L59u1rKV6lUSExMRFxcHOLi4nD16lWsWbMG6SoBTWd9D1Fa+sO4ouQyCUJeHohZU8Zhz549xfY7OzsjISEBVlbF3+F80MmTJzFr1iycO3fOsE0QBMybN8/wPhQRNQ5//fUXnnrqKeTk3FufWhAELFq0CG+++Wax4xMzlJi/NRJhMWmQSoQyA1vR/vzYM3h/uB9emDm5zLpoNBpkZWXB1dW1xP1RUVF45513sHPnTuTn5xvtEwQB//vf//Ddd99BEAQkZiihWHIQKhNO71P0HPYq4V35hoCDcohKkZ2dDQ8Pj2ope/bs2bC0tIS/vz+Cg4Mxe/ZsfPnll7h9+zZ83ezw8biOJr3eR2PawcvJCjt27EBgYGCxdWy9vb2NliIrS/fu3XHq1Cn8/PPPcHBwAFD47lR4eHixY/NUWlxMysaZhExcTMpukKtDEDVmjz32GH799VejbaIo4v3338f169eNtq+PSIBiyUEcvZ4OAA9t/Svab+PbBcti7LE+ovQ1sPPz8xEUFIR27doZjQhXKpV477330LRpU7Ru3Rp//fUXHBwc8Pbbb2Po0KGQSCQQBAGPP/44li9fDkEo7BnycrLCh2Palf8HUQ5Fz+GGiu9QEt3n008/xd69e+Hr6wu1Wg2ZTIZjx46hdevWcHR0fHgB5eTj41PihLg2NjY4ceIE7OzskFWgw+I9VyGKouEhVxmvDw3ApMDCd3bMzc3x119/oWPHjrhz5w70ej0EQcCZM2fg5OSE8ePHGwVFoPC3/k2bNmHcuHGwtLQEAEilUsyePRuPPfYY3nzzTfzyyy84ceIEdDodrqcpDV1ZCRlKo9V/HuzK8nev3AhNIqob8vPzS5xgXK1WY/To0bhw4QIEQcDy0Ggs3nO1UtfQiYBOq8dbWyKRlqvCi0H+Rvs1Gg0mTJiAY8eOQa/X499//4Ver8eiRYtw+vRpiKIICwsLjBs3Dp9++inatGkDoLB1dc+ePRg2bBjWrFlT7BftyYHeSMtVVbre97v/OdxQscub6D7Tp0/HunXrIJVKodPpDNttbW2RlZVV7IFTWRqNBn5+fkhIMP6N+5dffsEzz9ybkuLP8Hi8uekUJDIzw+oM5SGVCJBJBHw0pl2JD7Fdu3ZhxIgREEURCxcuRMeOHTF37lzExsZCIpFg9OjR+OWXX+Di4oIffvgBzz//PJ555hn88ssvJV5v2bJleHXBIvR7eTli8y3K3ZXV388FC8d1aNC/tRM1ZGlpaejduzfi4+Oh0WiK7R88eDCmvvcdPt5tutW1Ph/fwfBc0+v1mD59OtavX2/45VsQBMMvy507d8abb76JSZMmFStHp9Nhy5YtGDlyZJmv+6yPSMCCvy9Cqxcr9E7lw57DDQ0DJdF9du7ciZEjRxptEwQBM2bMwOrVq01yDaVSiZEjR+LAgQOGbVKpFG3atMHZs2eLTYPh7tsWZn2fgKxZB5MGtY8//hg///wzLl68aFivPCQkBM8//zyio6MhCAKGDRuGM2fOIDk5GQCwatUqzJw5s1hZ6yMS8O7Wc9CLElTkjaOiB+6HY9phciN44BI1VKIo4s6dO0hJSUFqaipu3LiBn376CScvx8LliaXQCVKk71puWHwBABwGzoR974mll6nT4taqedCkxhm2eb+2BRYWFgh5eSCaOVrif//7X4nLOL700kv49NNPK7XWd0kq8+5nY/uFmYGS6D4ajQaurq7Izi6cgFYQBLi6uiIqKsqoG7iyNm7ciCeffBL5+fno168fBg0ahE8++QQAEBoaikGDBhU7Z8iQIQgNDcXFGxnYcPImQq+mICG9hK5kZysEtXLD9F7e8HMrX1eyTqcrcR63Q4cOYc6cOUZTaQCF021ERESgQ4cOhm1V6cq632tDWxXryiKi+m3yT0cQEZ8FrVaLG8ufgD7/jmGfmVsLeD79bannZh/dgKxDa4y2eb+2BTJzOTq6yxH141xcvny5xHO/+uqrapl1wjA63YTP4YaC71AS3cfMzAyTJk3CihUrIIoiRFHEqlWrqhwm72+VlMvlWLt2LaZNmwaNRoM9e/agZcuWJYZJABg2bBj279+P62eO4IMxI/EB2iFPpUVceh6mTn8Cybdu4trZ45VaeaG0SYEHDBiA8+fPo1mzZkaTCqtUKowaNQoXLlyAra0t1kckmCRMAsDiPVfhaiNvFF1DRI1BdHIOjsdlAQAK4s4YhUkA0KTEQpOeCDNnr2LnatJvIOv/27v3qKjqtQ/g371nmBkucr8ICBgCWoiaLI6IlZHaxdSOeCoVOi9Zreq1TsfyLM1aafXmyrc6dMr3dDqdbpKXLsuOvinqSQlBk9e8pAkGyHG4eEGuDjPMwMzs94+RLSODgDMqMt/PPzJ77/n99iyX48Pv2b/n2bMBglIl99TuZLFKOHTaiPrmdnh5eUGlUkGn09k9pvTdd99dlYAyPmwIVsxKtPsebjdbHdbPdDfu+8mJepCZmSmnUBYsWID77rvPqfEuXZXcunWr3C7Mw8MDe/fuveyzmfPmzcOSJUvkZ30AW3uwUWE+KC3KQ0dHB8pLf8G4ceOcus9LrV+/3mHLs6qqKiQkJGBb0X4sfOFFNBaus79AECF6DoEqJAbeSdPgMzrd4fgdzWdw+uNnIHXY6nyqIkbiFWUO0kYEu02KiGgwW1tcJad/9SUXe1573XyH3ANbX7Ib/rdn2r1PkiQ05L0PWDrgN/n3aC7oXi9SFIBFf92I139rq4hhtVpx7tw51NbWora2FrGxsVfxk9l4q5VIjPC76vPcKFg2iOgSt912GwRBgCiKfa6rKEkSdu3a1a1cxV133YWHH34YVqsVubm5KCws7NZ7VqFQXHYXd1RUFNRqtV23CMD2vGfnQ/DPPvusw13jzjCbzQgLC0N4eDgiIiIwbNgwDB06FCqVCmfPnsV9r6yB1dGckhVWQwuM2iNo+O4dtBRvdDh+47b/kYNJeU6rhGXfHnXp5yCi6yP/1zpYrBIkczsM5fsAAKKXHwKnPgGItuyIvrSw2/taD+fBVHMMHqE3wXfCHIdjWyVgd0WD/FoURYSFhWH8+PGYOXMmEhNdW/KHeseAkuiCzpqJP9e0IHTkeMx+cC78/Pr22+eXX36JKVOm4MUXXwQAfPPNNwgODkZ+fj4mTZqEuro6ZGVlXfG9xcTE4OTJk3bHcnJy5J+LioqwcaPjwO1KLViwAGfOnMGpU6dQW1uL6upqnD59GiaTCftKT0IVPRZd40lNbDLCMlchdO5/wTNhonxcd+C7bmO3Ht0J48lDEJT2rR4tVgmFFfWoqNN1ew8R3ThaTWZUXeiAY6j4P0jttkLiXvGpUHgHQBNtew7b3FiD9jMXd4CbdfVo+uEzQBARNP05CGLPvbqrGgysbTuAMOVNbq1r+6+uNRM1v30VPwGY/FZ+rzUT29ra5Gd1cnJyUFBQgAMHDkCtVmPNmjV45JFHnL7P1NRUlJWV4dSpU4iIiEBJSQny8/Pl86Io4o9//CPuv/9+aDQap+frzdZfdVCI9quqCi9/aKJsqwIK7wC0lf0IALDom+yus+ib0bTzHwAE+KU93O2he4Uo4It9VVjh4qLCRHTtaBv08vdpZ3obALxGTbL9OXISjCcPAwD0pbuhGjoCANC4/QNIJgN8J2RAPTTusnNIAE426Jl2HiC4QkluqbrRgEc+Lsa0d3cjt1gL7SUFuDtpGw3ILdZi2ru78cjHxai+pOcsALz99ttye0ZJknDgwAGkpqairq7OJcEkAGRkZACwPdcI2Oo+dt1QY7VaUVNTg3fffdcl8/WmM5XliGTpQNuF9BYAqEJi7M43fv8hrEYdhoyfDnXkzd3eb7FKyC/r/uwmEd042i+0LLSaDGg78RMAQNQMgSZmLADAa2SaXFtXX1oISZLQ9u+DaKsohtI/HH63ZToeuId56PrjCiW5na5FaoG+t//aW9mAqTkFdjUTa2tr8cYbb9g9vygIAtLS0uTajq7QuRlnx44deOGFF7B27Vq7HY2dtm/fjqVLlzo9X0VFBXbt2oWMjAwEBwfbneuayupK/8tO6H/ZaXdM9PJDwNQn5deG8mIYSguh8A2B/+T/QPuZCofzd6ay3HnHJNGNTKW0BYuG8n3yLm2rUYeq/36g27WW83Uw1R6HRdcIADA3n0b1O46fnax6OwOe8akInfOy3Tx0/fFvgtzK6vxyLN14FCaztV8dDwBbYGm60P5rdX45AGD+/PkwmUx210mShJycnB7ro10JpVKJwMBA/PzzzwCADRs24PPPP8eTT9qCtZycHFRUVCAvL88l8+Xm5uLJJ59EeHg45syZg23btskBbNdUVm8EpQpSuy34tJoMaNzxAQAg6J7/hKjueSd3ZyqLiG5Mw4O8IQDQlxT06fquafG+Ei7MQwMDf/0nt+Hqmonf/++32L374pegIAgIDQ3FTTfdhJtvvhmBgYEumavTLbfcgj179sBqtcorlj4+Pvjwww/h7e2NESNGuGyukJAQALad3ps2bcLGjRsREBCAlJQUjJ+WAWBYt/doYpPhN/EhwGqBseYYWgrXwXL+HM5tXInIp/6B8wc2w6Krh9ctk+E5IqXXe2Aqi+jG5a1WIlzdgZMXnpMUVJ7wn/x7+4ssZjTt+hgAYDheBJ9b70PAlCe6jdW08yP5Z//0BfAIjARgKyLOLMbAwb8JcgvVjYZ+10w0Vh1F6y+7YKothbmhFriwLhc2byU0MUk4KMYh7e5ZWLLwMSQmJiIqKgoqlf2uZVeaOnUqioqKsHv3brkIekREBAA4rBfZG4PBgJKSEpSWlqK8vBxarRY1NTWoq6tDbW2tfF3nymRTUxN27NiB/MPlDrtbdN2Uo4kZA1PtcRgrD0Aym2CoKJbTWYaSAmgdrFq0n/oV2jdnIGDKE/BNeYCpLKIbXGDdIcBq+/7wvOlW+CbP7HZN6y/56KirhEXfBEtrI3xTuqfEuwaUvskzIChVUIgC0hNCr97NU78xoCS3sOzbo3CY4e5SM9GoPQKLvgl+E2wbYAxlP0J/5F89jCjAQ6VG7EPLMGvWhKt2313Nnz8fK1aswNdff90toKyvrwdg25xTXV2NY8eOoaysDCdOnJDL/dTX16O5uRkGgwEmk8lh3UpBEKBWq6FWq7sdFwQB8+bNw2srV2HKB4d7T3t3Gd/a1r8yQExlEd34zh3eJf/sGef4e9Ir7jdoqasEYEt7ew4f16exLVYJWansqjWQMKCkQa/8rA6FFfV2AVRnelaydEB3cItc4kZ34Ds5oFR4+8Nr5CSoI0dBd3gbzI21duNaJMg1Ey/t2VpQUICnnnoK06ZNw3vvvef0Z2htbUVTUxMUCgW+/vpr6HQ61NTU4OzZswCA1atXY/Xq1TCbHddkUyqV8PT0hK+vLyIjIxEWFoZhw4Zh+PDhiIuLQ2JiIkaNGiWXHDpx4gTi4i6W7EhLS8NHH32Em2+27cqODiyD9pKNORZDM4zVxwCrxbY6eSHVBQAegZFQDR0BVZh99wpz0ynoDm4BACh8Q+Gb8gA0UaOZyiIaBIr3FuKRj4uxt7Khx2fW/e/Igv8dl6/RG7PUvpatQhSQFhvkdr2yBzp+Y9Og19n+q6u+1Ez0m/iQ/LP+eJHDsS+tmdjQ0IDFixfjs88+A4DL7vS2Wq3QarU4duwYfv31V1RWVqKmpkZeTWxpaYFer0d7e7tdMHzu3Dnk5uZCFEU5xa5SqTB27FiEh4cjOjoasbGxGDVqFBITExEeHn7ZTjyOhIeHQ6FQwMfHBzk5OcjOzrYbI31kKHKLtXbvMVYegLHyQLexVGEj4Bn3GwgKJTxvGm//Hu2RiwGlTwB8Ux5gKotoEFk5OwlTcwr6vQnycpSigJWzk1w2HrkGA0oa9JypmdibzpqJy6VbkJubi+eeew463cX0bmlpKTIzM3Hq1CnU1dWhsbEROp0ORqPRYdkfwNbfu3M1cdiwYXariXl5edi3bx9qa2vldLdSqURycrLdBiFneXl5oaCgAAkJCfIGna4yJ0Tjsx9P9vh+QamGMmAoPONT4TdhDgRF379qmMoiGjyiAr3w6qxELN3oupaqr81KRFRgz1Ui6PpgQEmDmjM1E/tKW6+Hj38QDOebup3T6XRYt24dRFGEWq2Gj48PIiIiEBISgvDwcMTExGDEiBEYOXIkEhMTMXTo0MvOFR8fj3379mHTpk14+umnAdgCyvPnz/f7vnszadKknu8jbAhujwvGXjEL/rf3rQCxI5qYMXbpLKayiAafuSnRqG81uaTKxp/uHomHU/gL50DEgJIGtSutmdgvgoAhEbFo0x10uNGlvr4eQUFB/R/XgdmzZwMAtm7dKgeUKpUKra2tLhm/P1bOTsJdb++CRQLQz5R6T5jKIhqcnkmPR7CPWm4q0Z8UuEIUoBQFvDYrkcHkAMa6HDSo9VTLUBObjLDMVQibtxJ+t2cCEOSaiZbW7iuNvcnb/i/odDp8+umnmDhxIgDIzxw2NDRc8f13u2+NBn5+fjh06JB8TK1Ww2C4gkD4CkiShPLycvz9739H2tiROLPlfZcFkwBTWUSD2dyUaHy/aDLSYm2/YF/6bPulOs+nxQbh+0WTGUwOcFyhpEGtp1qGvdVMHDLu3n7P4+3tjezsbGRnZ6OsrAyffPIJfvjhB5etTnYaNWoU9u/fL7/29PS8qiuULS0tWL9+PX744Qfs3LlTLlEEAOEWC16YGo93vi93eh6msogGv6hAL+Q+NgHlZ3VYW1yF/LI6VDUY7DJJAmxFy9MTQpGVGs1HYG4QDChpUOts/3WtayYmJCTgzTff7Nc4fXXnnXeiuLgY+/fvR0pKCry9vV26Cnqp1atX4+WXX4YoirBa7Vd8N23ahJSUBIT4apjKIqI+iw8bghWzErECidCbzDjZoEe72QqVUsTwIG+WDbsBMeVNg5q3WoloBynUzpqJRu0RtOz9qlvNRABor6+C/ngR9MeL7IJMY/Uv8nHg2rf/mjdvHgBbP28AGDJkCDo6Oq7afAsXLkR8fHy348nJyUhJsbVQZCqLiK6Ut1qJxAg/3BodgMQIPwaTNyj+rdGgdyU1EwHAUFqIlj3ru13TUnSxfaPvsi3XvGbi2LFjoVAoUFBga1/o6+vbY0FzV/D390dWVhaWL19ud3zRokV2r5nKIiJyXwwoadC72jUTH0oOd8Fd9k9kZCRKSkqwaNEiHD16FJIkYdmyZWhpacHUqVPl3eCu8PTTT+Nvf/sbfHx8YDQaYTabERQUhAcffNDh9UxlERG5H0FyVOeEaJDprf3XlRAgwfDvQ6j78hV4eHjA19cXarUanp6e8PLyQlJSEtauXeuy+SRJwpo1a7BlyxZs3rwZJpPJ7rxSqYTZbEZWVhZyc3Odns9qtSI9PR27d+9GXFwcDh06hM2bNyMzMxPLly/HihUrnJ6DiIgGBwaU5BaqGw2YmlMAUw9lhK6EWiliQVgtlj77hMPzSUlJOHLkiMvms1gsCAwM7LWIeWFhIW677Tan5mpubsa4ceOg1Wpxzz33YOvWrRBF2yPXhw4dwujRo+Hh4eHUHERENHhwUw65hc72X6702qxELHnm8R53c7/11lsunU+hUGDt2rWX7cudlJR02Q43fVFSUoLo6GhotVo8//zz2LZtmxxMAsCtt97KYJKIiOwwoCS3MTclGovvTnDJWF1rJi5evBhpaWlQKBR21yxcuBDFxcUuma/TjBkz8Prrr/d4/vnnn79swNmbzZs3Y+zYsdDr9fjkk0/wzjvvXPFYRETkPhhQklt5Jj0eb2YkQa0Uey1tcymFKECtFLEqIwkL0+MuHr+wcqhWq+VjU6ZMQWVlJVJTU5GamgqtVutoyCuybNkyZGRkyK9VKhUAW4HzuXPn9nmcb7/9FnPmzJG77KxatQoPPPAAlEolCgsL8eijj7rsnomIaHDjM5TklqobDVj27VEUVtRDIQqX3azTef72uGCsnJ3UY2vAzz//HNnZ2Zg7dy7Wr1+PmpoazJ8/H4WFhRAEATNnzkRubi58fX2dvv/W1lZER0ejqakJ9913H/Ly8jBp0iQUFRX16f1WqxXx8fGorKxERkYGNBoN1q1bh5CQEBw8eBDDhg1z+h6JiMh9MKAkt+bKmomSJOGrr77ClClTEBwcLB8/fPgw5s+fj9LSUigUCjzxxBN4//33oVQ6Vz4nLy8P06dPx3t//RAvrHgTL/xpCbLmz+1TaZ7t27fj3nvt20uOGTMGxcXF0Gg0Tt0XERG5HwaURBdc7ZqJW7duxeOPP47Tp0/D09MTr7zyCpYuXSqfz87ORmRkJN54441exyo/q8MXxVp8vuMnYEgwbOGvjQAgOtAL6SNDkTkhGvFh3QPh6dOnY8eOHbBYLPKxTz/9FNnZ2c58RCIiclMMKImusQ8++ABLliyBTqdDYGAgVq9ejZCQEEybNg0AsGXLFkyfPt3he12Rqj9x4gTi4uK6Xa9UKrFv3z4kJye74FMSEZE7YUBJdB1YrVa89NJL+POf/4z29nZ4eHjAbDZDEAQEBASgtLQUISEhdu/ZsL8Kyzcfg9kq9atAu0IUoBQFvDorEXNTojF9+nTk5eXZzikU8irl8OHDsWHDBkyYMMF1H5SIiNwCA0qi68hoNGLq1KnYs2ePfEwURcyYMQP//Oc/5RJAq/PL8faOMqfnuz/Kir8unAUAiIqKwv3334/Jkydj8uTJCA+/9i0kiYhocGBASXQdmUwmxMXFoaamptu59957D88++yw27K/C0o1HXTZn6L93YO3rzyA+Pt5lYxIRkXtz3Y4DIuq3bdu2ycGkIAgQBAFWq6095B/+8Ac0tYv4y6a9aCxcZ/9GQYToOQSqkBh4J02Dz+h0+ZTu5+0wHC9CR301rG3nIUkSFD6B0ESNht/E36El/l5ogiKv2WckIqLBjyuURNeR0WjE5s2bodPpYDQa0dbWhra2Nhw/fhz5+fmw3PE0TDWlaNmz/rLj+KcvgN8EW7Hzs+tfglH7s8PrBJUnIh/9C+5MGYPcx/isJBERuQZXKImuI41Gg4ceesjhufKzOkx7dzdMNaUXr49Nht/EhyBZOqA7uAVtZT8CAHQHvpMDSo/Qm6COHg1VcAwEtRc66qvQXPgFJJMBUnsbzv+8A4UBEaio0/VaW5OIiKgvGFASDVBri6u6tYdUePlDE5Vo+9k7QA4oLfom+ZrAKY/bvcdz+DiYm89A99NmAIDU3gaFKOCLfVVYMSvxan4EIiJyE+zlTTRA5f9a12N5IMnSgbbyffJrVUiM4+vMHTCdqUDbiZ/kY+roMbBYJeSX1bn2homIyG1xhZJoAGo1mVHVaOh2XP/LTuh/2Wl3TPTyQ8DUJ+2OdTRU49RHT9tfp/aGb+rv4D1qEgCgqsEAvcns0m5ARETknrhCSTQAaRv06OtuOUGpgtTePfjsRlQAXUaVAJxs0F/J7REREdnh0gTRANRutjo83rkpB1YLjDXH0FK4Dpbz53Bu40pEPvUPKHwCAAAK31CEZa6CZDah/Wwlzu/7Bta282guWANB5Qnf5JmXnYeIiKg/uEJJNACplI7/aXZuytHEjIH/pHnQxI4HAEhmEwwVxfJ1oocamqhEeN40Hn6pv0PAXY/J5wwlBb3OQ0RE1B/834RoABoe5A2h98uALmVkrW06SOYOOC4te3E0q1EvHxke5O3UfRIREQFMeRMNSN5qJaIDvaC9ZGOOxdAMY/UxwGqBqfY4jCcPy+c8AiNhqi1FQ9778B6dDo/gGIhqL3ScO4mWvV/J16mGjgAARAd5cUMOERG5BP83IRqg0keGIrdYa3fMWHkAxsoD3a5VhY2AZ9xvYKopgbn5NFqK1nW7BrDVrvS7PQsKUUB6QuhVuW8iInI/DCiJBqjMCdH47MeTPZ4XlGooA4bCMz4VfhPmQFAooQyMxJDkmbbA8vw5WI2tEDzU8AiIgCZ2PHxTfguFlx8sVglZqdHX7sMQEdGgxl7eRAPYIx8XY29lQ48Fzq+EQhSQFhvEXt5EROQy3JRDNICtnJ0Epdin7Tl9phQFrJyd5NIxiYjIvTGgJBrAogK98KqL+22/NisRUYFeLh2TiIjcGwNKogFubko0Ft+d4JKx/nT3SDycwmcniYjItfgMJdENYsP+KizffAxmq9SvZyoVogClKOC1WYkMJomI6KpgQEl0A6luNGDZt0dRWFEPhShcNrDsPH97XDBWzk5impuIiK4aBpREN6DyszqsLa5CflkdqhoM6PqPWICtaHl6QiiyUqMRFzrket0mERG5CQaURDc4vcmMkw16tJutUClFDA/yZgccIiK6phhQEhEREZFTuMubiIiIiJzCgJKIiIiInMKAkoiIiIicwoCSiIiIiJzCgJKIiIiInMKAkoiIiIicwoCSiIiIiJzCgJKIiIiInMKAkoiIiIicwoCSiIiIiJzCgJKIiIiInMKAkoiIiIicwoCSiIiIiJzCgJKIiIiInMKAkoiIiIicwoCSiIiIiJzCgJKIiIiInMKAkoiIiIicwoCSiIiIiJzCgJKIiIiInMKAkoiIiIicwoCSiIiIiJzCgJKIiIiInMKAkoiIiIicwoCSiIiIiJzCgJKIiIiInMKAkoiIiIicwoCSiIiIiJzCgJKIiIiInMKAkoiIiIicwoCSiIiIiJzCgJKIiIiInMKAkoiIiIicwoCSiIiIiJzCgJKIiIiInMKAkoiIiIicwoCSiIiIiJzy//jWFYcGNOunAAAAAElFTkSuQmCC",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -182,38 +190,46 @@
    "source": [
     "# Sequential Team Operations\n",
     "# Create an empty directed graph\n",
-    "graph = nx.DiGraph()\n",
     "\n",
-    "# Outer loop for prefixes 'A', 'B', 'C'\n",
-    "for prefix in [\"A\", \"B\", \"C\"]:\n",
-    "    # Add 5 nodes with each prefix to the graph using a for loop\n",
-    "    for i in range(5):\n",
-    "        node_id = f\"{prefix}{i}\"\n",
-    "        graph.add_node(node_id, label=node_id)\n",
+    "speaker_transitions_dict = {}\n",
+    "teams = [\"A\", \"B\", \"C\"]\n",
+    "team_size = 5\n",
     "\n",
-    "    # Add edges between nodes with the same prefix using a nested for loop\n",
-    "    for source_node in range(5):\n",
-    "        source_id = f\"{prefix}{source_node}\"\n",
-    "        for target_node in range(5):\n",
-    "            target_id = f\"{prefix}{target_node}\"\n",
-    "            if source_node != target_node:  # To avoid self-loops\n",
-    "                graph.add_edge(source_id, target_id)\n",
     "\n",
-    "graph.add_edge(\"A0\", \"B0\")\n",
-    "graph.add_edge(\"B0\", \"C0\")\n",
+    "def get_agent_of_name(agents, name) -> Agent:\n",
+    "    for agent in agents:\n",
+    "        if agent.name == name:\n",
+    "            return agent\n",
+    "\n",
+    "\n",
+    "# Create a list of 15 agents 3 teams x 5 agents\n",
+    "agents = [Agent(name=f\"{team}{i}\") for team in teams for i in range(team_size)]\n",
+    "\n",
+    "# Loop through each team and add members and their connections\n",
+    "for team in teams:\n",
+    "    for i in range(team_size):\n",
+    "        member = f\"{team}{i}\"\n",
+    "        # Connect each member to other members of the same team\n",
+    "        speaker_transitions_dict[get_agent_of_name(agents, member)] = [\n",
+    "            get_agent_of_name(agents, name=f\"{team}{j}\") for j in range(team_size) if j != i\n",
+    "        ]\n",
     "\n",
-    "# Draw the graph\n",
-    "nx.draw(graph, with_labels=True, font_weight=\"bold\")"
+    "# Team leaders connection\n",
+    "print(get_agent_of_name(agents, name=\"B0\"))\n",
+    "speaker_transitions_dict[get_agent_of_name(agents, \"A0\")].append(get_agent_of_name(agents, name=\"B0\"))\n",
+    "speaker_transitions_dict[get_agent_of_name(agents, \"B0\")].append(get_agent_of_name(agents, name=\"C0\"))\n",
+    "\n",
+    "visualize_speaker_transitions_dict(speaker_transitions_dict, agents)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -223,18 +239,13 @@
     }
    ],
    "source": [
-    "# Think aloud and debate\n",
-    "graph = nx.DiGraph()\n",
-    "\n",
-    "for source_node in range(2):\n",
-    "    graph.add_node(source_node, label=source_node)\n",
-    "\n",
-    "# Add edges between nodes with the same prefix using a nested for loop\n",
-    "for source_node in range(2):\n",
-    "    for target_node in range(2):\n",
-    "        graph.add_edge(source_node, target_node)\n",
+    "agents = [Agent(name=f\"Agent{i}\") for i in range(2)]\n",
+    "allowed_speaker_transitions_dict = {\n",
+    "    agents[0]: [agents[0], agents[1]],\n",
+    "    agents[1]: [agents[0], agents[1]],\n",
+    "}\n",
     "\n",
-    "nx.draw(graph, with_labels=True, font_weight=\"bold\")"
+    "visualize_speaker_transitions_dict(allowed_speaker_transitions_dict, agents)"
    ]
   },
   {
@@ -249,15 +260,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
     "# The default config list in notebook.\n",
-    "config_list_gpt4 = autogen.config_list_from_json(\n",
+    "config_list = autogen.config_list_from_json(\n",
     "    \"OAI_CONFIG_LIST\",\n",
+    "    file_location=\".\",\n",
     "    filter_dict={\n",
-    "        \"model\": [\"gpt-4\", \"gpt-4-0314\", \"gpt4\", \"gpt-4-32k\", \"gpt-4-32k-0314\", \"gpt-4-32k-v0314\"],\n",
+    "        \"model\": [\"gpt-3.5-turbo\", \"gpt-35-turbo\", \"gpt-35-turbo-0613\", \"gpt-4\", \"gpt4\", \"gpt-4-32k\"],\n",
     "    },\n",
     ")"
    ]
@@ -301,127 +313,16 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We are printing out debug messages so that the reader can understand the conversation flow and select_speaker method better.\n",
-    "\n",
-    "Overrides the `select_speaker` method with custom logic including:\n",
-    "  - Handling of `NEXT:` and `TERMINATE` tags in the last message.\n",
-    "  - Selection of the first-round speaker based on the `first_round_speaker` attribute in the graph nodes.\n",
-    "  - Selection of subsequent speakers based on the successors in the graph of the previous speaker.\n",
-    "  - Random selection of the next speaker from the eligible candidates."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class CustomGroupChat(GroupChat):\n",
-    "    def __init__(self, agents, messages, max_round=10, graph=None):\n",
-    "        super().__init__(agents, messages, max_round)\n",
-    "        self.previous_speaker = None  # Keep track of the previous speaker\n",
-    "        self.graph = graph  # The graph depicting who are the next speakers available\n",
-    "\n",
-    "    def select_speaker(self, last_speaker, selector):\n",
-    "        self.previous_speaker = last_speaker\n",
-    "\n",
-    "        # Check if last message suggests a next speaker or termination\n",
-    "        last_message = self.messages[-1] if self.messages else None\n",
-    "        suggested_next = None\n",
-    "\n",
-    "        if last_message:\n",
-    "            if \"NEXT:\" in last_message[\"content\"]:\n",
-    "                suggested_next = last_message[\"content\"].split(\"NEXT: \")[-1].strip()\n",
-    "                # Strip full stop and comma\n",
-    "                suggested_next = suggested_next.replace(\".\", \"\").replace(\",\", \"\")\n",
-    "                print(f\"Suggested next speaker from the last message: {suggested_next}\")\n",
-    "\n",
-    "            elif \"TERMINATE\" in last_message[\"content\"]:\n",
-    "                try:\n",
-    "                    return self.agent_by_name(\"User_proxy\")\n",
-    "                except ValueError:\n",
-    "                    print(f\"agent_by_name failed suggested_next: {suggested_next}\")\n",
-    "\n",
-    "        # Debugging print for the current previous speaker\n",
-    "        if self.previous_speaker is not None:\n",
-    "            print(\"Current previous speaker:\", self.previous_speaker.name)\n",
-    "\n",
-    "        # Selecting first round speaker\n",
-    "        if self.previous_speaker is None and self.graph is not None:\n",
-    "            eligible_speakers = [\n",
-    "                agent for agent in agents if self.graph.nodes[agent.name].get(\"first_round_speaker\", False)\n",
-    "            ]\n",
-    "            print(\"First round eligible speakers:\", [speaker.name for speaker in eligible_speakers])\n",
-    "\n",
-    "        # Selecting successors of the previous speaker\n",
-    "        elif self.previous_speaker is not None and self.graph is not None:\n",
-    "            eligible_speaker_names = [target for target in self.graph.successors(self.previous_speaker.name)]\n",
-    "            eligible_speakers = [agent for agent in agents if agent.name in eligible_speaker_names]\n",
-    "            print(\"Eligible speakers based on previous speaker:\", eligible_speaker_names)\n",
-    "\n",
-    "        else:\n",
-    "            eligible_speakers = agents\n",
-    "\n",
-    "        # Debugging print for the next potential speakers\n",
-    "        print(\n",
-    "            f\"Eligible speakers based on graph and previous speaker {self.previous_speaker.name if self.previous_speaker else 'None'}: {[speaker.name for speaker in eligible_speakers]}\"\n",
-    "        )\n",
-    "\n",
-    "        # Three attempts at getting the next_speaker\n",
-    "        # 1. Using suggested_next if suggested_next is in the eligible_speakers.name\n",
-    "        # 2. Using LLM to pick from eligible_speakers, given that there is some context in self.message\n",
-    "        # 3. Random (catch-all)\n",
-    "        next_speaker = None\n",
-    "\n",
-    "        if eligible_speakers:\n",
-    "            print(\"Selecting from eligible speakers:\", [speaker.name for speaker in eligible_speakers])\n",
-    "            # 1. Using suggested_next if suggested_next is in the eligible_speakers.name\n",
-    "            if suggested_next in [speaker.name for speaker in eligible_speakers]:\n",
-    "                print(\"suggested_next is in eligible_speakers\")\n",
-    "                next_speaker = self.agent_by_name(suggested_next)\n",
-    "\n",
-    "            else:\n",
-    "                msgs_len = len(self.messages)\n",
-    "                print(f\"msgs_len is now {msgs_len}\")\n",
-    "                if len(self.messages) > 1:\n",
-    "                    # 2. Using LLM to pick from eligible_speakers, given that there is some context in self.message\n",
-    "                    print(\n",
-    "                        f\"Using LLM to pick from eligible_speakers: {[speaker.name for speaker in eligible_speakers]}\"\n",
-    "                    )\n",
-    "                    selector.update_system_message(self.select_speaker_msg(eligible_speakers))\n",
-    "                    _, name = selector.generate_oai_reply(\n",
-    "                        self.messages\n",
-    "                        + [\n",
-    "                            {\n",
-    "                                \"role\": \"system\",\n",
-    "                                \"content\": f\"Read the above conversation. Then select the next role from {[agent.name for agent in eligible_speakers]} to play. Only return the role.\",\n",
-    "                            }\n",
-    "                        ]\n",
-    "                    )\n",
-    "\n",
-    "                    # If exactly one agent is mentioned, use it. Otherwise, leave the OAI response unmodified\n",
-    "                    mentions = self._mentioned_agents(name, eligible_speakers)\n",
-    "                    if len(mentions) == 1:\n",
-    "                        name = next(iter(mentions))\n",
-    "                        next_speaker = self.agent_by_name(name)\n",
-    "\n",
-    "                if next_speaker is None:\n",
-    "                    # 3. Random (catch-all)\n",
-    "                    next_speaker = random.choice(eligible_speakers)\n",
-    "\n",
-    "            print(f\"Selected next speaker: {next_speaker.name}\")\n",
-    "\n",
-    "            return next_speaker\n",
-    "        else:\n",
-    "            # Cannot return next_speaker with no eligible speakers\n",
-    "            raise ValueError(\"No eligible speakers found based on the graph constraints.\")"
+    "## Demonstration"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Demonstration"
+    "`GroupChat` now takes in two optional arguments.\n",
+    "- speaker_transitions_dict: a dictionary of keys and list as values. The keys are the names of the agents, and the values are the agents that the key agent can transition to. Default is None, in which case a fully connected graph is assumed.\n",
+    "- is_allowed_graph: whether the speaker_transitions_dict is a list of allowed agents or disallowed agents. Default is True, in which case the speaker_transitions_dict is a list of allowed agents. If set to False, then the speaker_transitions_dict is a list of disallowed agents."
    ]
   },
   {
@@ -433,12 +334,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAABMQAAAP7CAYAAAC0u1IMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdfVzP9+L/8eenkiIJISRRSAgxDobm2hgaMzZsjquzzdfsbOM4Znbsd2bYxs6ur87BsZmZq+ZqDLFmF65SlEqSiyTVKkmlPp/fH9HBzFxU7099HvfbrZvP+937/Xo/P50z6tnr/XqbLBaLRQAAAAAAAICNsDM6AAAAAAAAAFCWKMQAAAAAAABgUyjEAAAAAAAAYFMoxAAAAAAAAGBTKMQAAAAAAABgUyjEAAAAAAAAYFMoxAAAAAAAAGBTKMQAAAAAAABgUyjEAAAAAAAAYFMoxAAAAAAAAGBTKMQAAAAAAABgUyjEAAAAAAAAYFMoxAAAAAAAAGBTKMQAAAAAAABgUyjEAAAAAAAAYFMoxAAAAAAAAGBTKMQAAAAAAABgUyjEAAAAAAAAYFMoxAAAAAAAAGBTKMQAAAAAAABgUyjEAAAAAAAAYFMoxAAAAAAAAGBTKMQAAAAAAABgUyjEAAAAAAAAYFMoxAAAAAAAAGBTKMQAAAAAAABgUyjEAAAAAAAAYFMoxAAAAAAAAGBTKMQAAAAAAABgUyjEAAAAAAAAYFMoxAAAAAAAAGBTKMQAAAAAAABgUyjEAAAAAAAAYFMoxAAAAAAAAGBTKMQAAAAAAABgUyjEAAAAAAAAYFMoxAAAAAAAAGBTKMQAAAAAAABgUyjEAAAAAAAAYFMoxAAAAAAAAGBTKMQAAAAAAABgUyjEAAAAgHLi/Pnzeuqpp+Tl5aXKlSvLw8ND/fr10w8//GB0NHl7e2vx4sV3fF5ubq6efPJJtW7dWg4ODho6dGiJZwMA4EYORgcAAAAAcHuGDRum/Px8LV26VE2aNNG5c+e0fft2paWlldo18/Pz5ejoWGrjFxYWytnZWVOnTtXq1atL7ToAAFyLGWIAAABAOZCRkaHvv/9e8+fP1wMPPKBGjRqpY8eOmjlzpgYPHnzdcRMmTFDt2rXl6uqqnj176tChQ9eN9c033+i+++6Tk5OT3N3dFRwcXPw5b29vvfrqqxo7dqxcXV01adIkSVJYWJi6desmZ2dnNWzYUFOnTtXFixclSUFBQUpMTNRzzz0nk8kkk8l02++ratWq+uCDDzRx4kR5eHjcy5cIAIDbRiEGAAAAlAMuLi5ycXHRunXrlJeX97vHPfLII0pJSdHmzZu1f/9+BQYGqlevXkpPT5ckbdy4UcHBwXrwwQd18OBBbd++XR07drxujDfeeENt2rTRwYMHNXv2bMXHx6t///4aNmyYIiIitHLlSoWFhWnKlCmSpDVr1sjT01Nz587V2bNndfbs2eKxTCaTlixZUvJfEAAA7oHJYrFYjA4BAAAA4I+tXr1aEydO1KVLlxQYGKgePXpo5MiRCggIkFQ0i2vgwIFKSUlR5cqVi8/z9fXV9OnTNWnSJHXp0kVNmjTR8uXLb3oNb29vtWvXTmvXri3eN2HCBNnb2+ujjz4q3hcWFqYePXro4sWLcnJykre3t6ZNm6Zp06ZdN56fn5/mzZt33Sy03/Pkk08qIyND69atu4OvCgAAd44ZYgAAAEA5MWzYMCUlJSkkJET9+/dXaGioAgMDi2dgHTp0SNnZ2apVq1bxjDIXFxclJCQoPj5ekhQeHq5evXrd8jodOnS4bvvQoUNasmTJdWP269dPZrNZCQkJtxzr6NGjt1WGAQBQllhUHwAAAChHnJyc1KdPH/Xp00ezZ8/WhAkTNGfOHD355JPKzs5WvXr1FBoa+pvz3NzcJEnOzs5/eI2qVatet52dna3Jkydr6tSpvznWy8vrrt4HAABGohADAAAAyjF/f//iWwwDAwOVnJwsBwcHeXt73/T4gIAAbd++XePGjbvtawQGBioqKkq+vr6/e4yjo6MKCwvvJDoAAIbhlkkAAACgHEhLS1PPnj21fPlyRUREKCEhQatWrdKCBQs0ZMgQSVLv3r3VuXNnDR06VFu3btWJEye0Z88ezZo1S/v27ZMkzZkzRytWrNCcOXMUHR2tyMhIzZ8//5bXnjFjhvbs2aMpU6YoPDxccXFxWr9+ffGi+lLR2mO7d+/WmTNnlJqaWrzfz8/vuvXIbiYqKkrh4eFKT09XZmamwsPDFR4efpdfKQAA/hgzxAAAAIBywMXFRZ06ddKiRYsUHx+vy5cvq2HDhpo4caL+/ve/Syp6ouOmTZs0a9YsjRs3TufPn5eHh4e6d++uunXrSpKCgoK0atUqvfrqq3r99dfl6uqq7t273/LaAQEB2rVrl2bNmqVu3brJYrHIx8dHjz76aPExc+fO1eTJk+Xj46O8vDxdfXZXTEyMMjMzbzn+gw8+qMTExOLtdu3aSZJ4/hcAoLTwlEkAAAAAAADYFG6ZBAAAAAAAgE2hEAMAAAAAAIBNoRADAAAAAACATaEQAwAAAAAAgE2hEAMAAAAAAIBNoRADAAAAAACATaEQAwAAAAAAgE2hEAMAAAAAAIBNoRADAAAAAACATaEQAwAAAAAAgE2hEAMAAAAAAIBNoRADAAAAAACATaEQAwAAAAAAgE2hEAMAAAAAAIBNoRADAAAAAACATaEQAwAAAAAAgE2hEAMAAAAAAIBNoRADAAAAAACATaEQAwAAAAAAgE2hEAMAAAAAAIBNoRADAAAAAACATaEQAwAAAAAAgE2hEAMAAAAAAIBNoRADAAAAAACATaEQAwAAAAAAgE2hEAMAAAAAAIBNoRADAAAAAACATaEQAwAAAAAAgE2hEAMAAAAAAIBNoRADAAAAAACATXEwOgAAAAAA62GxWBR6IlSb4jbpl6RfdCTliHILclXJvpJ8avioU4NOeqDxAxrcfLAc7R2NjgsAwF0xWSwWi9EhAAAAABjLYrHoP+H/0byweTqWfkwOdg4qMBf85rhKdpV02XxZtZxraWqnqZredbqcHJwMSAwAwN2jEAMAAABsXGJGop5c/6RCT4TKJJMsur0fEexMdmpSo4mWBy9XJ89OpZwSAICSQyEGAAAA2LBDyYfUc2lPZeVn3XRG2B+xN9nLZDJp5fCVerjFw6WQEACAkkchBgAAANiouLQ4dfq0k7LyslRoKbzrcUwyyc5kpw2PbVB/3/4lmBAAgNJBIQYAAADYoAJzgf706Z8Unhx+T2XYVSaZ5ObkppgpMapdtXYJJAQAoPTwlEkAAADABi36cZEOnD1QtF7YN5L2X/PJXpK63XDCr5J+lnRKUrKkqx1aD0kPSBZZlJWXpSmbpmjlIytLOz4AAPfEzugAAAAAAMpWbkGuXgt7ragMK5QUdcMBh29yUrKknySd0f/KsBsUWgr1VdRXik2LLcm4AACUOAoxAAAAwMZ8HfW1MnIzijbiJV264YBzks7fsM9RUhMVzQhr/vtjO5gc9MHeD0omKAAApYRCDAAAALAxq6NWy8505UeBa2eDtbrm9Y2zxHwkjZX0gCT33x+7wFKgL498WRIxAQAoNRRiAAAAgI356cxPMlvM0mVJR6/srCKpv/73E8LNbpu8TcnZyTp/8cYpZgAAWA8KMQAAAMCGZORmKDk7uWgjVlL+lU/4SXKR5H1lO03S2bu/TsS5iLs/GQCAUkYhBgAAANiQC3kX/rdx7Sww/xv+vPHzdygrL+vuTwYAoJRRiAEAAAA2xN7OvuhFnqS4KzudJTW+8rqFJNOV14clWe7uOg52DneZEACA0se/UgAAAIANqV2lthzsHFRwtEAquLLzkqRXb3JwpqRTkrzu/DoNXBvcdUYAAEobhRgAAABgQyrZV1Kr2q0UHhl+eycc1h0XYvYme/m7+ysvL0+xsbGKjo4u/khISNCnn36q1q1b32l0AABKDIUYAAAAYGM61uyo8OPhRRuOknrdcEChpK1XXkep6OmTlySduLIv7Zpjz0s6cuW1t2SqalLhyUJVqVxFFsv/7rd0cHBQYWGhLBaLLl68WGLvBQCAu0EhBgAAANiYuol1JfOVDR9JnW5yUISkZEnZKirCTJJW3eS4qCsfkvSEZGls0YxeM/TBqg+UlfW/hfULCoruz6xVq5Y6duxYEm8DAIC7xqL6AAAAgI3ZvXH3/zaa/85Bza55fQdPm3RzctOc4XN07tw5DRgwQCaT6brPp6WlycPDQ2PHjtXhw/fwGEsAAO6ByXLtPGYAAAAANiE8OVwdPu6gQkthiY67bOgyjWkzRpKUn5+vkSNHat26dcW3T3bu3FlRUVHKzMyUJFWrVk3du3fXc889p169brx3E/if8+fP6+WXX9bGjRt17tw51ahRQ23atNHLL7+srl27GprN29tb06ZN07Rp0+7ovNDQUC1atEi//PKLsrKy1LRpU7344ot6/PHHSycogGLMEAMAAABsUFuPtprdfbZMMv3xwbfB3mSvgU0HanTA6OJ9jo6O+uqrrzRy5EhJUtWqVRUaGqqMjAxFRUVp3LhxqlKlijZu3KjevXvLyclJ3bp10+effy6z2fx7l4KNGjZsmA4ePKilS5cqNjZWISEhCgoKUlpa2h+ffJfy8/NLbWxJ2rNnjwICArR69WpFRERo3LhxGjt2rDZs2FCq1wXADDEAAADAZpktZo1eM1pfHv5SFt39jwX2Jnu1qtNKu8ftlmtl1998vrCwUNOnT1fNmjU1a9as33z+3LlzevPNN7V69WolJCTIYrHI3t5eLVu21BNPPKGnn35aTk5Od50P5V9GRoZq1Kih0NBQ9ejR45bHvfDCC1q/fr3y8vLUoUMHLVq0SG3atCk+5ptvvtHcuXMVGRkpFxcXdevWTWvXrpVUNNNr/PjxiouL07p16/Twww9ryZIlCgsL08yZM7Vv3z65u7srODhY8+bNU9WqVRUUFKRdu3Zdl+NefsweOHCg6tatq3//+993PQaAP8YMMQAAAMBG2Zns9N/g/2pyh8nF23fjfq/7Ffpk6E3LMEmyt7fXm2++edMyTJLq1q2rBQsWKD4+XtnZ2VqwYIH8/f115MgRPf/886pSpYp8fX01c+ZMpaam3lVGlG8uLi5ycXHRunXrlJeX97vHPfLII0pJSdHmzZu1f/9+BQYGqlevXkpPT5ckbdy4UcHBwXrwwQd18OBBbd++/TcPeXjjjTfUpk0bHTx4ULNnz1Z8fLz69++vYcOGKSIiQitXrlRYWJimTJkiSVqzZo08PT01d+5cnT17VmfPni0ey2QyacmSJXf0XjMzM1WzZs07OgfAnWOGGAAAAABtjN2oP4f8WSkXU2QnO5l161sW7Ux2crR31MI+C/X0fU/fdZl2K2azWcuXL9dHH32k/fv3Fxch9erV08CBAzV9+nQ1bdq0xK8L67R69WpNnDhRly5dUmBgoHr06KGRI0cqICBAkhQWFqaBAwcqJSVFlStXLj7P19dX06dP16RJk9SlSxc1adJEy5cvv+k1vL291a5du+IZY5I0YcIE2dvb66OPPireFxYWph49eujixYtycnL63TXE/Pz8NG/ePAUHB9/We/zqq680ZswYHThwQC1btrzdLw2Au8AMMQAAAAAa2Gygjk89rk8e+kT+dfz/9wmz5GDnIAc7h+Jd9avV16sPvKoTz57QlI5TSqUMkyQ7OzuNHTtWP/zwg3Jzc7VlyxYNGDBAFy5c0KeffqpmzZqpRo0aGjZsmH744YdSyQDrMWzYMCUlJSkkJET9+/dXaGioAgMDi2dgHTp0SNnZ2apVq1bxjDIXFxclJCQoPj5ekhQeHv6HD2/o0KHDdduHDh3SkiVLrhuzX79+MpvNSkhIuOVYR48eve0ybOfOnRo3bpw++eQTyjCgDDj88SEAAAAAbEFVx6qaEDhBEwInKDk7WXM/masPvv5A0+dMV7Uq1eRTw0ft67dXY7fGMplKZjH+O9GvXz/169dPUlGxsXDhQm3dulVr1qzRmjVr5OzsrM6dO+uZZ57R0KFDZWfH7/8rGicnJ/Xp00d9+vTR7NmzNWHCBM2ZM0dPPvmksrOzVa9ePYWGhv7mPDc3N0mSs7PzH16jatWq121nZ2dr8uTJmjp16m+O9fLyuqv3caNdu3bpoYce0qJFizR27NgSGRPArVGIAQAAAPgNDxcPrV2wVkqWJjWfpEaNGhkd6Tpt27bV559/Lkk6efKk3njjDa1bt047duzQjh075ODgoDZt2mj8+PEaP368HB0dDU6M0uDv769169ZJkgIDA5WcnCwHBwd5e3vf9PiAgABt375d48aNu+1rBAYGKioqSr6+vr97jKOjowoLC+8kerHQ0FANGjRI8+fP16RJk+5qDAB3jl+ZAAAAAPiNkJAQJScnS5KWLVtmcJpb8/Ly0r/+9S+dPHlSmZmZ+sc//iFfX18dPHiw+AmVfn5++sc//qGMjAyj4+IupKWlqWfPnlq+fLkiIiKUkJCgVatWacGCBRoyZIgkqXfv3urcubOGDh2qrVu36sSJE9qzZ49mzZqlffv2SZLmzJmjFStWaM6cOYqOjlZkZKTmz59/y2vPmDFDe/bs0ZQpUxQeHq64uDitX7++eFF9qWjtsd27d+vMmTPXPfjBz8/vuvXIbrRz504NHDhQU6dO1bBhw5ScnKzk5OTihwAAKD0UYgAAAACuc+HCBU2ePLl4+5NPPpHZfOtF9q2Fq6urXn75ZUVHR+vSpUv68MMP1aFDBx0/flyvvPKKatSoIS8vL/3f//2fTp48aXRc3CYXFxd16tRJixYtUvfu3dWqVSvNnj1bEydO1Lvvviup6ImOmzZtUvfu3TVu3Dg1a9ZMI0eOVGJiourWrStJCgoK0qpVqxQSEqK2bduqZ8+e+uWXX2557YCAAO3atUuxsbHq1q2b2rVrp5dffln169cvPmbu3Lk6ceKEfHx8VLt27eL9MTExyszM/N2xly5dqpycHM2bN0/16tUr/nj44Yfv5csF4DbwlEkAAAAA13n22Wf17rvvXleC7dixQw888ICBqe6N2WzWN998o3fffVd79uxRTk6OJKlWrVrq27evXnjhBQUGBhqcEgBQVijEAAAAABTbt2+fOnbsqGt/THBwcNCjjz6q5cuXG5isZP3444968803tWPHDv3666+SimYh3X///Xr22WfVv39/gxMCAEoThRgAAACAYhMmTNBnn31WvG0ymWSxWOTo6Kjz58/L1dXVwHSlIz4+XgsWLNA333yjs2fPSipaJL19+/aaPHmyHn/8cTk48DwyAKhIKMQAAAAAFPv111/1ww8/6NixY3ruuefUokULNW3aVJcvX9bKlStVrVo1oyOWqtTUVL311ltatWqV4uPjZbFYZGdnJ39/f40ZM0ZTpkxRlSpVjI4JALhHFGIAAAAAfuP7779X9+7d9dprr2nmzJlGxzFEbm6uPvzwQy1dulSRkZEqLCyUyWRSo0aNNHz4cD3//PPy8PAwOiYA4C7wlEkAAAAAvxEdHS1Jat68ucFJjOPk5KRp06bp4MGDys/P1xdffKFu3bopOTlZb7zxhurVqycPDw+NGzeu+OsFACgfKMQAAAAA/EZcXJwkqVWrVgYnsQ52dnYaNWqUdu3apUuXLmn79u0aPHiwLl26pCVLlsjf31/Vq1fX0KFDtXv3bqPjAgD+AIUYAAAAgN9ITEyUJPn6+hqcxDr17NlT69evV2Zmpg4fPqwnnnhCTk5OWr9+vXr06CFnZ2cFBQVp5cqVMpvNRscFANyANcQAAAAA/EbXrl31888/q6CgwOgo5UpSUpLefPNNrV69urhUdHBwUOvWrfXkk0/qL3/5ixwdHQ1OCQCgEAMAAADwG82aNVNSUpKys7ONjlJuZWdn691339Xy5csVHR0ts9ksk8kkX19fjRgxQn/9619Vs2ZNo2MCgE2iEAMAAADwG7Vr15aDg4POnj1rdJQKoaCgQMuWLdMnn3yiAwcOKD8/X5JUv359DR48WNOnT1fjxo0NTgkAtoNCDAAAAMBvODs7q0mTJjpy5IjRUSqkTZs26V//+pfCwsJ08eJFSVLNmjXVq1cvvfjii7rvvvsMTggAFRuL6gMAAAD4jby8PNWtW9foGBXWgw8+qC1btig7O1v79u3TyJEjZTKZtGrVKnXs2FEuLi7q27evvvnmGxblB4BSQCEGAAAA4Dq5ubmyWCxq2LCh0VFsQvv27bVixQqlpqbqxIkTevrpp1WjRg1t27ZNgwcPlpOTkzp16qRPPvmEhxwAQAmhEAMAAABwncOHD0sSa1oZoFGjRnrvvfd06tQp/frrr3r55ZfVuHFj7d27V5MmTVLlypXl7++vf/7znzzwAADuAYUYAAAAgOtERUVJkpo2bWpwEtvm5uamf/zjH4qJiVFubq7ee+89tWvXTnFxcXrppZdUrVo1NWrUSM8995zOnDljdFwAKFcoxAAAAABcJzY2VpLUsmVLg5PgKkdHRz399NPat2+f8vLy9PXXX+uBBx7Q+fPntXjxYnl6eqpOnToaO3Zs8Qw/AMDvoxADAAAAcJ0TJ05Ikvz9/Y0Ngpuys7PTsGHDtGPHDuXk5CgsLEzBwcG6fPmy/vvf/6p169ZydXXVoEGDtH37dqPjAoBVMlksFovRIQAAAABYj6CgIH3//fcqLCw0OgruUExMjBYuXKiNGzcqOTlZklS5cmXdd999mjx5sh577DHZ2TEvAgAoxAAAAABcx9/fXydOnFBOTo7RUXAPUlJS9Oabb+rrr79WQkKCLBaL7O3t1bJlS40dO1ZPP/20nJ2djY4JAIagEAMAAABwHQ8PD5nNZqWkpBgdBSUkJydHH3zwgZYtW6YjR46osLBQJpNJjRs31iOPPKIXXnhB7u7uRscEgDJDIQYAAADgOlWrVpWnp6diYmKMjoJSYDab9cUXX+ijjz7S3r17lZeXJ6moCB04cKBmzJjBE0YBVHgUYgAAAACu4+DgoM6dO+v77783OgrKwLZt2/T2229r9+7dunDhgiTJzc1NDzzwgJ5//nl17drV4IQAUPJYTREAAABAsYKCAhUWFqpBgwZGR0EZ6dOnjzZs2KCsrCwdOnRIo0ePVqVKlbR27Vrdf//9qlKlinr27KnVq1fLbDYbHRcASgSFGAAAAIBisbGxkiRvb29jg8AQAQEB+u9//6uUlBSdOnVKU6dOVe3atbVz504NHz5clStXVocOHfT+++8rPz/f6LgAcNcoxAAAAAAUO3LkiCSxhhTk6empt99+W4mJicrMzNSrr76qpk2b6uDBg3rmmWfk5OQkPz8/vfLKK8rIyDA6LgDcEQoxAAAAAMWuzhBr0aKFwUlgTVxdXfXSSy8pKipKeXl5+uijj3Tffffp+PHj+sc//qEaNWqoYcOGeuaZZ5SYmGh0XAD4QxRiAAAAAIrFx8dLklq3bm1wElgrBwcHTZo0ST///LNyc3O1fv169enTR+np6Xr//ffl7e0td3d3jRo1SgcOHDA6LgDcFIUYAAAAgGKnT5+WyWRStWrVjI6CcsDOzk6DBw/W1q1bdfHiRf3000965JFHZDab9eWXX6p9+/ZycXFR//79tXnzZqPjAkAxk8VisRgdAgAAAIB1CAgIUGxsrHJzc42OgnIuISFBCxYsUEhIiJKSkiRJjo6OCgwM1KRJkzRmzBg5ODgYnBKAraIQAwAAAFDM09NTly5dUlpamtFRUIGkp6dr0aJFWrlypY4dOyaLxSI7Ozu1aNFCo0eP1pQpU+Ti4mJ0TAA2hEIMAAAAQDFXV1fVrl27eC0xoKTl5ubq448/1pIlSxQREaHCwkJJkre3tx5++GG9+OKL8vDwMCxfXFqcdifu1r6kfTr+63HlFeapqmNVtazdUh3qd1DPxj3lXsXdsHwASgaFGAAAAIBilSpVUvv27fXTTz8ZHQU2wGw2a9WqVfrggw+KF+mXpDp16mjAgAF68cUX1bJly1LPYbFY9E3sN3rrx7e0K3GXJKmSXSVdNl8uPubqdiW7Snq01aN6ofMLauPRptSzASgdFGIAAAAAJBWVE/b29goODtaaNWuMjgMbFBoaqsWLF2vnzp3KysqSVDRrMSgoSM8995yCgoJK/JpnL5zVpA2TtCF2g+xN9iq0FP7hOQ52DjJbzPpb17/p5R4vq7JD5RLPBaB08ZRJAAAAAJKkU6dOSZIaNWpkcBLYqqCgIK1bt06ZmZk6cuSInnzySTk7OyskJEQPPPCAnJ2d1aNHD3355Zcym823HKugoEB/NP9jf9J+tXy/pTbHFT0B83bKMEkqMBfIbDFrXtg8df13V6XlsOYeUN5QiAEAAACQJEVEREiSfHx8DE4CSP7+/vrPf/6j5ORknT17Vi+88II8PDy0e/dujRo1So6OjmrXrp0WL15806eiPvTQQ+rUqZN+/fXXm44fcS5CDyx9QFl5WbddhN3IIovCk8PVc1lPZeVl3dUYAIxBIQYAAABAkhQTEyNJatGihcFJgOt5eHho4cKFSkhI0MWLFzV//ny1aNFCEREReu6551SlShU1bdpUs2bNUnp6us6fP69vv/1We/fuVffu3XX+/Pnrxsu5nKMhXw5RzuWcuy7Driq0FOpIyhE9s/GZexoHQNliDTEAAAAAkqSnnnpKH374oc6dO6c6deoYHQf4QwUFBfr888/10Ucfaf/+/crPz5ckVa9eXZmZmZIke3t7+fj4aNeuXcVPr/zrt3/V2z+/LbPFLH0jaf81g/aS1O2GC52QFC3ppKQsSZckVZHU6MqxVx6KGTIyRA81f6g03iqAEkYhBgAAAECSNGjQIG3cuPEP110CrNXmzZv1r3/9S9u2bVNh4f9mfplMJtWrV08///yz5Co1WtyoqAwrlPSGigquq+pKeuqGgf8rKf53Luog6QnJ1NCkprWa6ugzR2UymUrwXQEoDdwyCQAAAECSdPbsWVWqVMnoGMBdGzBggFatWiU7u+t/1LVYLEpKSpKXl5ceX/T4/z4Rr+vLMEk6J+m8fquGimaPjZE0WJLLlf0Fkr4rWk8sNi1WuxN3l8h7AVC6HIwOAAAAAMA6pKamqkqVKkbHAO5JaGioLl++fN2+atWqqWrVqiosLNT3Wd/L4nplFuThaw5qdc32YUkPXPO5riq6PdL+mn1VJH155fWZoj8c7By0PGK5enj3KJH3AqD0UIgBAAAAkCRlZmaqevXqRscA7knbtm01c+ZMNWrUSC1atFCLFi1Uu3ZtSVJaTprcF7oXHXhZ0tErJ1WR1F9SlCSzfluINbnJhWpe89qx6I8Cc4H2nN5TYu8FQOmhEAMAAAAgScrJyZGPj4/RMYB74unpqddee+2mnwtPDv/fRqyk/Cuv/VR0C6S3pOOS0iSdlVTvFheKvua17/9exqTGKK8gT5UdKt9hcgBliTXEAAAAAEiSLl++rHr1btUAAOVbak7q/zauvV3S/4Y/b/z8jWIlXV0qzFlSz/99qtBSqAv5F+4hJYCyQCEGAAAAQOfPF60i3rBhQ4OTAKWn+OmPeZLirux0ltT4yusWkq4+IPKwpJs9cDVK0koVPaHSUdJjktxuuI54yiRg7bhlEgAAAIAiIiIkiVsmUaHVrlK0lpiOqujpkFLRUyZfvcnBmZJOSfK6Zl+4pPUqKsqcJD0u6YYO2cHOQdUqVyuxzABKBzPEAAAAACg6umhBpObNmxucBCg9bT3aFr2IvM0Trr1t8hdJ61RUhlWV9KR+U4ZJkr+7vxztHe82IoAywgwxAAAAAIqPj5cktW7d2uAkQOmp4VxDXpW8dPL4yaIdjpJ63XBQoaStV15Hqejpkz9L+vbKPvsr5+RJSrzmvEZFs8O6NOxSOuEBlCgKMQAAAABKTCz6yd7Ly+sPjgTKtzZpbXTSfKUQ85HU6SYHRUhKlpQt6YSKbrG8qlBSyE3OeUUqMBdoTJsxJZgWQGnhlkkAAAAASkpKkoODg+zs+BEBFVvqL9c8afL37hBuds3rWz1t8hp2Jju1rN1SnT073200AGXIZLFYbvbcDAAAAAA2xMfHR+fPn1dWVpbRUYBS9/ftf9frYa/LctPHSN69b0d/q74+fUt0TAClg1//AAAAAFBGRoZcXV2NjgGUiTk95qhpraayN9mXyHj2JntNCJxAGQaUIxRiAAAAAHTx4kXVrFnT6BhAmbCXvTrFd1JhTqHs7vHHYnuTvdrXb6/F/RaXTDgAZYJCDAAAAIDy8/Pl4eFhdAyg1OTm5mrDhg0aN26cnJ2d9d/F/1Xn6M6qXbX2Xc8UM8mkLg27aNuYbarqWLWEEwMoTTxlEgAAALBxFy5ckMVikaenp9FRgBL33Xff6eOPP9aGDRt06dIlmUwmWSwWmUwmfbv8W112uKypm6fq88jP5WDnoAJzwR+O6WBX9KP0/3vg/+n5Ls8XbwMoP/ivFgAAALBxkZGRkqQmTZoYnAQoeU8//bTi4uKKt68+V27EiBGqVq2aJGn5w8v153Z/1uKfFmtD7AZZZFElu0oqMBfIIovsTHYyyaRCS6GcHZw1ru04PfunZ9WsVrObXhOA9aMQAwAAAGxcdHS0JKlZM364R8WzatUqdevWTRcuXLhu/+jRo6/b7tm4p3o27qkzWWf0w6kftD9pv45nHFd+Yb6qVqoq/9r+al+vve73ul/VKlcry7cAoBRQiAEAAAA27ursmZYtWxqcBCh5rVu3lqenZ3HxK0murq7q2/fmT4Rs4NpAI1qO0IiWI8oqIgADsKg+AAAAYONOnDghSWrevLmxQYASVlBQoLZt2yo6OlpBQUFydnaWJD366KNydHQ0OB0AI1GIAQAAADbuzJkzsrOzk4MDN5Cg4igoKFDr1q0VGRmpxx9/XDt37tSWLVvk5eWlSZMmGR0PgMFMlqsrCgIAAACwSc2bN9fp06d18eJFo6MAJSI/P1/+/v6Kj4/X+PHj9emnnxodCYCVYYYYAAAAYON+/fXX4qftAeVdbm6umjVrpvj4eD399NOUYQBuikIMAAAAsHHZ2dmqWbOm0TGAe5adnS1fX18lJibqhRde0HvvvWd0JABWikIMAAAAsHF5eXmqU6eO0TGAe5KVlSVfX1+dOXNGL730khYuXGh0JABWjFUzAQAAABuWn58vs9ksT09Po6MAdy09PV3NmjVTWlqaXn31Vb300ktGRwJg5SjEAAAAABsWFRUlSfL29jY2CHCXUlJS5Ofnp19//VULFizQiy++aHQkAOUAhRgAAABgw44cOSJJatq0qcFJgDuXlJSkFi1aKCsrS//617/0f//3f0ZHAlBOUIgBAAAANiwuLk6S5O/vb3AS4M4kJiaqVatWys7O1kcffaRJkyYZHQlAOUIhBgAAANiwhIQESVKrVq0MTgLcvvj4eAUEBOjSpUtaunSpxo4da3QkAOUMhRgAAABgw06fPi2TySRnZ2ejowC3JTo6WoGBgcrLy9OXX36pESNGGB0JQDlEIQYAAADYsHPnzqly5cpGxwBuS3h4uP70pz/p8uXLWrt2rYYMGWJ0JADlFIUYAAAAYMPS09Pl4uJidAzgD+3du1ddu3ZVYWGhNmzYoAEDBhgdCUA5Zmd0AAAAAADGycrKUo0aNYyOAdzSDz/8oC5dushsNmvbtm2UYQDuGYUYAAAAYMNyc3NVu3Zto2MAv2vHjh3q0aOHJGnXrl3q2bOnwYkAVAQUYgAAAICNMpvNKiwsVP369Y2OAtzU5s2b1adPH9nZ2WnPnj3q2rWr0ZEAVBAUYgAAAICNOnbsmCTJ29vb2CDATaxfv16DBg1SpUqVtG/fPt13331GRwJQgVCIAQAAADbq8OHDkiRfX1+DkwDX++qrrxQcHCxHR0cdPHhQAQEBRkcCUMFQiAEAAAA2KiYmRpLUokULg5MA/7Ns2TKNHDlSzs7OOnz4MP//BFAqKMQAAAAAG5WQkCBJzL6B1fj444/1xBNPqGrVqoqKipKPj4/RkQBUUBRiAAAAgI06deqUTCaT3NzcjI4C6J133tHkyZPl6uqqmJgYNWrUyOhIACowCjEAAADARiUnJ6tSpUpGxwC0cOFCTZ06VTVq1FBcXBxPPgVQ6ijEAAAAABuVmpqqqlWrGh0DNu7//b//p+nTp8vd3V3Hjh1TnTp1jI4EwAY4GB0AAAAAgDGysrJUs2ZNo2PAhs2aNUuvvfaa6tatq9jYWLm6uhodCYCNYIYYAAAAYKNycnJUu3Zto2PARj3//PN67bXX1KBBAx07dowyDECZYoYYAAAAYIPMZrMKCgpUr149o6PABj3zzDN6//331ahRIx09elROTk5GRwJgYyjEAAAAABuUlJQkSfLy8jI4CWzNhAkT9Nlnn8nX11dHjhyRo6Oj0ZEA2CAKMQAAAMAGRUZGSpJ8fHwMTgJbMnr0aH3++efy8/NTZGSkHBz4kRSAMfjbBwAAALBBMTExkiQ/Pz+Dk8BWDB8+XKtXr1ZAQIAOHjwoOzuWtAZgHAoxAAAAwAbFx8dLklq3bm1wEtiCQYMGaePGjerQoYN+/vlnyjAAhuNvIQAAAMAGnTx5UpJUv359g5OgouvTp482btyorl27UoYBsBr8TQQAAADYoKSkJFWqVEkmk8noKKigzGazunfvru+++049e/ZUWFgYZRgAq8HfRgAAAIANSk1NlbOzs9ExUEGZzWZ17txZ33//vQYMGKDt27cbHQkArkMhBgAAANigzMxMVa9e3egYqIDMZrPat2+vX375RcHBwdq0aZPRkQDgNyjEAAAAABt08eJF1apVy+gYqGAKCgrUunVrhYeHa9SoUVqzZo3RkQDgpijEAAAAABuUn58vDw8Po2OgAsnPz5e/v7+ioqL05JNP6osvvjA6EgD8LgoxAAAAwMakp6dLkho2bGhwElQUubm5at68ueLi4vSXv/xF//nPf4yOBAC3RCEGAAAA2JjIyEhJUpMmTQxOgoogJydHTZs21YkTJ/Tcc8/pgw8+MDoSAPwhCjEAAADAxkRHR0uSmjdvbnASlHdZWVny8fHR6dOnNXPmTL311ltGRwKA20IhBgAAANiYY8eOSZJatWplcBKUZ+np6fL19VVycrJeeeUVvfbaa0ZHAoDb5mB0AAAAAABlKzExUZLk4+NjcBKUVykpKWrRooXS09M1f/58TZ8+3ehIAHBHKMQAAAAAG5OUlCR7e3vZ2XHDCO5cUlKS/P39lZmZqcWLF+vZZ581OhIA3DEKMQAAAMDGpKSkyNnZ2egYKIdOnjypli1bKjs7Wx9++KEmT55sdCQAuCsUYgAAAICN+fXXX1WtWjWjY6CciY+PV0BAgC5duqQlS5boiSeeMDoSANw15kgDAAAANubixYuqWbOm0TFQjsTExKh169a6dOmSPv/8c8owAOUeM8QAAAAAG5OXl6e6desaHQPlxOHDh9WhQwfl5+dr9erVCg4ONjoSANwzZogBAAAANiQnJ0cWi0Wenp5GR0E5sG/fPrVv316XL1/Whg0bKMMAVBjMEAMAAABsyJEjRyRJjRs3NjgJrN2PP/6o7t27y2KxaOvWrerVq5fRkQCgxDBDDAAAALAhUVFRkqTmzZsbnATWLDQ0VN26dSt+TRkGoKKhEAMAAABsSGxsrCSpZcuWBieBtfr222/Vu3dv2dnZKSwsTPfff7/RkQCgxFGIAQAAADbkxIkTkiQ/Pz9jg8AqhYSE6MEHH5S9vb1++eUXderUyehIAFAqKMQAAAAAG3LmzBnZ2dnJ0dHR6CiwMl9//bWGDh0qR0dHHThwQG3btjU6EgCUGgoxAAAAwIacO3dOlStXNjoGrMznn3+uESNGyMnJSREREdxSC6DCoxADAAAAbMivv/6qatWqGR0DVuSzzz7T6NGjVaVKFUVHR6tp06ZGRwKAUkchBgAAANiQCxcuqEaNGkbHgJV4//33NWHCBFWrVk1Hjx5Vo0aNjI4EAGWCQgwAAACwIbm5uapTp47RMWAF3nrrLT3zzDNyc3NTbGysPD09jY4EAGWGQgwAAACwEZcvX5bZbFaDBg2MjgKD/fOf/9Tzzz+vmjVrKi4uTh4eHkZHAoAyRSEGAAAA2IiYmBhJkre3t7FBYKiXX35ZL730kurUqaP4+Hi5u7sbHQkAypyD0QEAAAAAlI0jR45Iknx9fQ1OAqNMnz5dCxcuVL169RQbGysXFxejIwGAISjEAAAAABsRGxsrSfL39zc4CYwwdepUvfPOO2rYsKGOHj2qKlWqGB0JAAxDIQYAAADYiISEBElS69atDU6CsjZp0iR98sknatKkiaKjo+Xo6Gh0JAAwFIUYAAAAYCNOnTolk8nEbXI25oknntCyZcvUvHlzRUREUIYBgCjEAAAAAJtx7tw5yhAbM2LECK1atUqtWrXSwYMH5eDAj4AAIFGIAQAAADYjLS2N2WE2ZMiQIQoJCVFgYKD27t0rOzs7oyMBgNXgb0QAAADARmRlZcnNzc3oGCgD/fr1U0hIiDp37kwZBgA3wd+KAAAAgI3Izc1V7dq1jY6BUmQ2mxUUFKStW7cqKChIYWFhlGEAcBPcMgkAAADYALPZrIKCAtWrV8/oKCglZrNZXbt21U8//aR+/fppy5YtRkcCAKvFrwoAAAAAG5CYmChJ8vb2NjYISoXZbNZ9992nn376SUOGDKEMA4A/QCEGAAAA2IDIyEhJkq+vr8FJUNIKCgrUpk0bHThwQCNGjNC6deuMjgQAVo9CDAAAALABMTExkiQ/Pz+Dk6Ak5efnq1WrVjp8+LDGjh2rlStXGh0JAMoFCjEAAADABhw/flySFBAQYHASlJTc3Fy1aNFCMTExmjhxopYuXWp0JAAoNyjEAAAAABtw8uRJSZK7u7vBSVAScnJy1KxZMx0/flxTp07Vxx9/bHQkAChXKMQAAAAAG5CcnCxHR0ejY6AEZGdny9fXV6dOndL06dP19ttvGx0JAModCjEAAADABqSmpqpKlSpGx8A9ysjIkI+Pj86ePavZs2dr/vz5RkcCgHLJwegAAAAAAEpfZmam3NzcjI6Be5CamqrmzZsrPT1dr732mmbOnGl0JAAot5ghBgAAANiAnJwc1g8rx5KTk9W0aVOlp6frzTffpAwDgHvEDDEAAADABly+fFkeHh5Gx8BdOH36tPz9/XXhwgW99957evrpp42OBADlHoUYAAAAUMGdO3dOkuTl5WVwEtyphIQEtW7dWhcvXtSnn36q8ePHGx0JACoECjEAAACggouMjJQk+fj4GJwEdyI2NlZt27ZVbm6uli9frscff9zoSABQYVCIAQAAABVcdHS0JKl58+YGJ8HtOnLkiDp06KC8vDytWrVKw4YNMzoSAFQoLKoPAAAAVHDx8fGSpNatWxucBLfjwIEDCgwMVH5+vtatW0cZBgClgBliAAAAQAWXmJgoSWrYsKHBSfBHfv75Z3Xr1k1ms1lbtmxRnz59jI4EABUShRgAAABQwSUlJcnBwUF2dtwgYs12796tXr16yWKxaMeOHerevbvRkQCgwuJfRAAAAKCCS01NlbOzs9ExcAvbt29Xz549JUnff/89ZRgAlDIKMQAAAKCCy8jIkKurq9Ex8Ds2bdqkvn37yt7eXj///LM6d+5sdCQAqPAoxAAAAIAK7uLFi6pVq5bRMXATa9eu1aBBg1SpUiXt379fgYGBRkcCAJtAIQYAAABUcPn5+fLw8DA6Bm6wYsUKDRs2TE5OTjp06JBatWpldCQAsBkUYgAAAEAFlpWVJYvFwhMmrcx//vMfPf7446pSpYoiIyPVvHlzoyMBgE2hEAMAAAAqsMjISElS48aNDU6Cqz744AP9+c9/louLi6KiouTj42N0JACwORRiAAAAQAUWHR0tScxAshKLFy/W008/rerVq+vo0aPy8vIyOhIA2CQKMQAAAKACi4uLkyS1bNnS4CRYsGCBnnvuOdWsWVPHjh1T/fr1jY4EADaLQgwAAACowBITEyVJTZs2NTiJbfvHP/6hGTNmqHbt2oqPj5e7u7vRkQDApjkYHQAAAABA6Tlz5ozs7e3l4MC3/kaZOXOmXn/9dXl4eCgmJkaurq5GRwIAm8e/igAAAEAFlpKSIicnJ6Nj2KznnntOixcvlqenp2JiYlSlShWjIwEARCEGAAAAVGi//vqrqlWrZnQMm/TUU0/pww8/lLe3t6KjoykmAcCKsIYYAAAAUIFlZ2erRo0aRsewOePGjdOHH36opk2bKiYmhjIMAKwMM8QAAACACiwvL09169Y1OoZNGTVqlL788kv5+/vr0KFDrN8GAFaIv5kBAACACiovL09ms1kNGjQwOorNCA4O1rp169S2bVvt379fdnbclAMA1ohCDAAAAKigoqKiJEmNGzc2OIltGDBggLZs2aKOHTvqxx9/pAwDACvG39AAAABABXW1EGvWrJnBSSo2s9msnj17asuWLerevTtlGACUA8wQAwAAACqo2NhYSZK/v7/BSSous9msbt26ac+ePerdu7e2bdtmdCQAwG3g1xYAAABABZWQkCBJatmypcFJKiaz2ayOHTtqz549GjRoEGUYAJQjFGIAAABABXX69GnZ2dnJycnJ6CgVTkFBQfHC+cOHD9c333xjdCQAwB2gEAMAAAAqqHPnzsnR0dHoGBVOQUGBWrdurcjISD3++ONatWqV0ZEAAHeIQgwAAACooNLT0+Xi4mJ0jAolPz9ffn5+Onr0qMaPH6/ly5cbHQkAcBcoxAAAAIAK6sKFC6pRo4bRMSqM3NxcNWvWTPHx8Xr66af16aefGh0JAHCXKMQAAACACio3N1e1a9c2OkaFkJ2dLV9fXyUmJuqFF17Qe++9Z3QkAMA9oBADAAAAKiCz2azCwkI1aNDA6CjlXlZWlnx9fXXmzBm99NJLWrhwodGRAAD3yMHoAAAAAABKXlxcnCTJ29vb2CDlXHp6upo1a6a0tDS9+uqreumll4yOBAAoARRiAAAAQAV0+PBhSZKvr6/BScqvlJQUNW/eXBkZGVqwYIFefPFFoyMBAEoIhRgAAABQAcXGxkqS/P39DU5SPp05c0b+/v7KysrSO++8oylTphgdCQBQgijEAAAAgAro+PHjkqRWrVoZnKT8SUxMVKtWrZSdna2PP/5YEydONDoSAKCEUYgBAAAAFdCpU6dkMpnk5uZmdJRy5dixY2rTpo0uXbqkZcuWacyYMUZHAgCUAgoxAAAAoAJKTk6Wo6Oj0THKlaioKLVv3155eXn68ssvNWLECKMjAQBKCYUYAAAAUAGlpaWpSpUqRscoN8LDw/WnP/1Jly9f1tq1azVkyBCjIwEAShGFGAAAAFABZWVlqVatWkbHKBf27t2rrl27qrCwUBs3blT//v2NjgQAKGV2RgcAAAAAUPJycnLk7u5udAyr98MPP6hLly4ym83atm0bZRgA2AgKMQAAAKCCMZvNKigoUP369Y2OYtV27NihHj16SJJ27dqlnj17GpwIAFBWKMQAAACACiYpKUmS1KhRI4OTWK/NmzerT58+srOz0549e9S1a1ejIwEAyhCFGAAAAFDBREZGSpJ8fHwMTmKd1q9fr0GDBqlSpUrat2+f7rvvPqMjAQDKGIUYAAAAUMEcPXpUkuTn52dwEuvz1VdfKTg4WI6Ojjp48KACAgKMjgQAMACFGAAAAFDBHDt2TJLUunVrg5NYl2XLlmnkyJFydnbW4cOH1aJFC6MjAQAMQiEGAAAAVDAnT56UJNWrV8/gJNbj448/1hNPPKGqVasqKiqK20kBwMZRiAEAAAAVzNmzZ1WpUiWjY1iNd955R5MnT5arq6tiYmJ42AAAgEIMAAAAqGhSU1Pl7OxsdAyrsHDhQk2dOlU1atRQXFyc6tevb3QkAIAVoBADAAAAKpjMzExVr17d6BiGe/XVVzV9+nS5u7vr2LFjqlOnjtGRAABWgkIMAAAAqGBycnJUq1Yto2MYatasWXr55ZdVt25dxcfHq2bNmkZHAgBYEQejAwAAAAAoWfn5+Ta9oP7zzz+vt956Sw0aNNDRo0fl4uJidCQAgJWhEAMAAAAqkPT0dEmSl5eXwUmM8cwzz+j9999Xo0aNdPToUTk5ORkdCQBghSjEAAAAgAokIiJCktSkSRODk5S9CRMm6LPPPpOvr6+OHDkiR0dHoyMBAKwUhRgAAABQgURHR0uSmjdvbnCSsjV69Gh9/vnn8vPzU2RkpBwc+FEHAPD7+FcCAAAAqECOHTsmSWrVqpXBScrO8OHDtXr1agUEBOjgwYOys+PZYQCAW6MQAwAAACqQxMRESVLjxo0NTlI2Bg0apI0bN6pDhw76+eefKcMAALeFQgwAAACoQJKSkmRvb28TxVDv3r21fft2de3aVbt377aJ9wwAKBn8iwEAAABUIOfPn5ezs7PRMUqV2WxWt27dtH37dvXs2VNhYWGUYQCAO8K/GgAAAEAF8uuvv6patWpGxyg1ZrNZnTt3VlhYmAYMGKDt27cbHQkAUA5RiAEAAAAVyMWLF1WrVi2jY5QKs9ms9u3b65dfflFwcLA2bdpkdCQAQDlFIQYAAABUIHl5eapbt67RMUpcQUGBWrdurfDwcI0aNUpr1qwxOhIAoByjEAMAAAAqiJycHFksFjVs2NDoKCUqPz9f/v7+ioqK0rhx4/TFF18YHQkAUM5RiAEAAAAVxJEjRyRJjRs3NjhJycnNzVXz5s0VFxenv/zlL/r3v/9tdCQAQAVAIQYAAABUEFcLsWbNmhmcpGTk5OSoadOmOnHihKZNm6YPPvjA6EgAgAqCQgwAAACoIOLi4iRJLVu2NDjJvcvKypKPj49Onz6tv/3tb1q0aJHRkQAAFQiFGAAAAFBBJCQkSJL8/PwMTnJv0tPT5evrq+TkZL3yyiuaN2+e0ZEAABUMhRgAAABwj86fP6+nnnpKXl5eqly5sjw8PNSvXz/98MMPZZrjzJkzsrOzU6VKlYr3eXt7a/Hixfc07rFjx1StWjW5ubndW8DbcP78eTVt2lTnz5/X66+/rjlz5pT6NQEAtsfB6AAAAABAeTds2DDl5+dr6dKlatKkic6dO6ft27crLS2t1K6Zn58vR0fH6/alpKTIycmpRK9z+fJljRo1St26ddOePXtKdOwbJSUlyd/fX5mZmVq8eLGeffbZUr0eAMB2MUMMAAAAuAcZGRn6/vvvNX/+fD3wwANq1KiROnbsqJkzZ2rw4MHXHTdhwgTVrl1brq6u6tmzpw4dOnTdWN98843uu+8+OTk5yd3dXcHBwcWf8/b21quvvqqxY8fK1dVVkyZNkiSFhYWpW7ducnZ2VmxsrCwWiy5evChJCgoKUmJiop577jmZTCaZTKY7fn8vvfSS/Pz8NGLEiLv58ty2kydPqnnz5srMzNSHH35IGQYAKFUUYgAAAMA9cHFxkYuLi9atW6e8vLzfPe6RRx5RSkqKNm/erP379yswMFC9evVSenq6JGnjxo0KDg7Wgw8+qIMHD2r79u3q2LHjdWO88cYbatOmjQ4ePKjZs2crPj5e/fv317BhwxQREaFKlSrJbDZrypQpkqQ1a9bI09NTc+fO1dmzZ3X27NnisUwmk5YsWXLL97Zjxw6tWrVK77333l1+dW5PfHy8WrRooYsXL2rJkiWaPHlyqV4PAACTxWKxGB0CAAAAKM9Wr16tiRMn6tKlSwoMDFSPHj00cuRIBQQESCqaxTVw4EClpKSocuXKxef5+vpq+vTpmjRpkrp06aImTZpo+fLlN72Gt7e32rVrp7Vr1xbvmzBhguzt7fXRRx9Jkuzt7dW6dWtFRkbq4sWLcnJykre3t6ZNm6Zp06ZdN56fn5/mzZt33Sy0a6Wlpaldu3Zavny5unfvriVLlmjatGnKyMi4h6/Ubx09elSBgYHKzc3VF198oZEjR5bo+AAA3AwzxAAAAIB7NGzYMCUlJSkkJET9+/dXaGioAgMDi2dgHTp0SNnZ2apVq1bxjDIXFxclJCQoPj5ekhQeHq5evXrd8jodOnS4bvvQoUNasmRJ8Xhms1mHDx+W2WwufuLk7zl69OjvlmGSNHHiRD322GPq3r37bXwF7k5kZKTatm2r3NxcrV69mjIMAFBmKMQAAACAEuDk5KQ+ffpo9uzZ2rNnj5588sniJyRmZ2erXr16Cg8Pv+4jJiZGL774oiTJ2dn5D69RtWrV67azs7M1efJkhYeH66uvvpJUNGssLi5OPj4+9/R+duzYoTfeeEMODg5ycHDQ+PHjlZmZKQcHB/373/++p7Elad++ferQoYMuX76sDRs23LKcAwCgpPGUSQAAAKAU+Pv7a926dZKkwMBAJScny8HBQd7e3jc9PiAgQNu3b9e4ceNu+xqBgYGKioqSr6+v9u/fL0nq1KmTfH19i49xdHRUYWHhHef/8ccfrztv/fr1mj9/vvbs2aMGDRrc8Xg3jt29e3dZLBZt3br1D2fGAQBQ0pghBgAAANyDtLQ09ezZU8uXL1dERIQSEhK0atUqLViwQEOGDJEk9e7dW507d9bQoUO1detWnThxQnv27NGsWbO0b98+SdKcOXO0YsUKzZkzR9HR0YqMjNT8+fNvee0ZM2Zoz549mjJlikJDQyVJqampxYvqS0Vrj+3evVtnzpxRampq8X4/P7/r1iO7UYsWLdSqVavijwYNGsjOzk6tWrVSjRo17vbLpV27dqlbt26SpNDQUMowAIAhKMQAAACAe+Di4qJOnTpp0aJF6t69u1q1aqXZs2dr4sSJevfddyUVPdFx06ZN6t69u8aNG6dmzZpp5MiRSkxMVN26dSVJQUFBWrVqlUJCQtS2bVv17NlTv/zyyy2vHRAQoF27dik2NlaffvqpJGnZsmWqX79+8TFz587ViRMn5OPjo9q1axfvj4mJUWZmZkl/OW7p6mwwOzs7hYWF6f777y/T6wMAcBVPmQQAAAAqgD59+mj79u0ym81GR7mpkJAQBQcHy8HBQT///LPatm1rdCQAgA1jhhgAAABQAZw7d06VK1c2OsZNff311xo6dKgcHR114MAByjAAgOEoxAAAAIAKIC0t7TdPobQGn3/+uUaMGCEnJydFRESoZcuWRkcCAIBCDAAAAKgIsrKy5ObmZnSM63z22WcaPXq0qlSpoqioKDVt2tToSAAASKIQAwAAACqE3Nxc1alTx+gYxd5//31NmDBB1apV09GjR+Xt7W10JAAAilGIAQAAAOWc2WxWQUHBdU+XNNKbb76pZ555Rm5uboqNjZWnp6fRkQAAuA6FGAAAAFDOJSYmSpIaNWpkcBLptdde0wsvvKBatWopLi5OHh4eRkcCAOA3KMQAAACAci4yMlKS5OPjY2iOl19+WbNmzVKdOnV07Ngxubu7G5oHAIDf42B0AAAAAAD35ujRo5KkFi1aGJZhxowZWrBggerVq6fY2Fi5uLgYlgUAgD9CIQYAAACUc8ePH5ckBQQEGHL9Z599Vv/617/k5eWl6OhoValSxZAcAADcLgoxAAAAoJw7deqUJKlWrVplfu1Jkybpk08+UZMmTRQVFaXKlSuXeQYAAO4UhRgAAABQzp09e1aOjo5lft0nnnhCy5YtU7NmzXT48GFVqlSpzDMAAHA3KMQAAACAci41NbXMb1McMWKEVq1apVatWungwYNycOBHCwBA+cG/WgAAAEA5l5WVJTc3tzK73pAhQxQSEqLAwEDt3btXdnY8vB4AUL7wLxcAAABQzuXk5Mjd3b1MrtWvXz+FhISoc+fOlGEAgHKLf70AAACAcu7y5cuqV69eqV7DbDYrKChIW7duVVBQkMLCwijDAADlFrdMAgAAAOVYcnKyJMnLy6vUrmE2m3X//ffrxx9/VL9+/bRly5ZSuxYAAGWBX+kAAAAA5VhkZKQkycfHp1TGN5vN6tChg3788UcNGTKEMgwAUCFQiAEAAADl2NGjRyVJfn5+JT52QUGBAgICdPDgQY0YMULr1q0r8WsAAGAECjEAAACgHDt27JgkqVWrViU67uXLl9WyZUsdOXJEY8aM0cqVK0t0fAAAjEQhBgAAAJRjJ0+elCR5enqW2Ji5ubny8/NTbGysJk2apGXLlpXY2AAAWAMKMQAAAKAcS0pKkoODQ4k98TEnJ0fNmjXT8ePHNXXqVH300UclMi4AANaEQgwAAAAox1JTU1WlSpUSGSs7O1u+vr46deqUpk+frrfffrtExgUAwNpQiAEAAADlWEZGhlxdXUtkHB8fH509e1azZ8/W/PnzSyAdAADWiUIMAAAAKGdWrlypHj166LHHHlNmZqYKCwv1+eef6+eff76r8VJTU+Xr66uUlBS99tprmjt3bgknBgDAujgYHQAAAADAnYmPj9fu3btlZ2cns9mss2fPavTo0ZKkmJgYNWvW7LbHSk5OVosWLZSRkaE333xTf/3rX0srNgAAVsNksVgsRocAAAAAcPtOnz4tLy8vXfutvL29vXr06KHvvvtOJpPptsfx9/fXhQsX9N577+npp58urcgAAFgVbpkEAAAAyhlPT0/17t37uidL2tvb6+OPP77tMiwhIUF+fn66cOGCPv30U8owAIBNoRADAAAAyqFJkybJbDYXb7/yyivy8fG56bEWi0UTJkzQunXrJEmxsbFq2bKlcnJytHz5co0fP74sIgMAYDW4ZRIAAAAoh/Ly8lS9enXl5eWpcePGiomJUaVKlW567I8//qguXbrI3t5eb731lmbMmKG8vDytWrVKw4YNK+PkAAAYjxliAAAAQDlUuXJleXt7S5KWLVv2u2WYJH3xxRdycHCQ2WzWs88+q7y8PK1fv54yDABgs3jKJAAAAFBe5ORI4eFFH2lperNGDW1zdtb9Tk5SXp5UufJvTikoKNCKFStUUFBQvM/e3l7Ozs5llxsAACvDLZMAAACANbNYpNBQ6b33pHXrpMJCyWSS7O1lNptlMptlkiRHR+mxx6Snn5buu6/49O+++059+vT5zbCVK1dWbGysvLy8yuqdAABgNbhlEgAAALBWJ09KffpIPXtK69cXlWFSUUlWUCC7q2WYJOXnS8uXSx07SqNGSampkqSFCxcWD2dvby9JcnFx0YgRI+Tm5lZ27wUAACvCDDEAAADAGq1fXzTjKz9fuuZ2x9tiby9Vr64T77yjxo8/Lklyc3PTo48+qocfflhBQUFydHQshdAAAJQPFGIAAACAtVm9Whoxomgm2F1+u26xs1Oe2axH3Nz06Dvv6LHHHpOdHTeIAAAgUYgBAAAA1iUiQmrfvuj2yHv8Vt1sMklVq8ru6FGpQYMSCggAQPnHr4gAAAAAa3H5sjR6dPHMsL9IMl3z8frvnJYlaYYkH0mVJdWVNFpSgsUiu0uXpIkT77lcAwCgImGGGAAAAGAt3n9fmjJFslh0WVI9SWnXfLqNpPAbTsmS1E1SxE2GqyFpl6TWkrRhgzRwYIlHBgCgPGKGGAAAAGANLBbp7beLN7fp+jJMkg5JOnrDvlf0vzKsu6R1kiZf2f5V0nipaJH9d94p0bgAAJRnFGIAAACANfjpJyk2tvjWxi+v+dTIa15fuz9f0n+uvDZd+dwQSR9I8ruyf6+k/YWF0tat0qlTpZEcAIByh0IMAAAAsAY//CBdeQpkropmeklSbUmLJTlc2b62EDssKePKa28V3WIpFZVjna857nupqGj76acSjQwAQHlFIQYAAABYg/37JZNJkrRB0oUru4eqaJH8oCvbMZIOXnl94prT694wXJ1rXidIUqVKRdcAAAAUYgAAAIBVOHFCKiyUdP0ssOE3/Hnt5y9es8/xhuGu3b4oSWazdPr0PccEAKAioBADAAAArMGVMuyCpI1XdtWU1PPK64cl2V95vVKSRVLVa07Pu2G4/GteV5WKbpksKCi5vAAAlGMOf3wIAAAAgFLn5iapaO2w3Cu70iVVusmhiZJ+VNG6YVedu+GY5GteN5aKnjTp6nrPMQEAqAiYIQYAAABYgzZtpEqVtOI2D/9SUitJ1a9sJ0o6c+W1RdK1y+d3k4pmhwUElERSAADKPWaIAQAAANagQwelXb6sbVc2q0l67YZD8iU9f+X1KhU9ffLPkhapqAQbJekFFd1yGXN1WEntpaJbJtu3L630AACUKyaLxWIxOgQAAABg8zIy9FHt2vrLlXW+hkn6+iaHtZMUfuX1d5LuU9EMsIibHOsmabek1pLk4SGdOiU58DtxAAC4ZRIAAACwBm5uWuHuXrw5+HcOe+ia119KcpX0vaQXVbRWmKOkOpIek7RXV8owOzvpmWcowwAAuIIZYgAAAICVOLZpkxoNGqRKJfktuslUtGB/bKx0TeEGAIAt41dEAAAAQBkym83asGGDYmNjderUKSUmJurYsWOKiYlRQUGBXnV11aysLJlK6oIWi/Thh5RhAABcgxliAAAAQBmKjIxUQECATCaTHBwcdPny5eLPOTo6KunUKdUaO1batk0ym+/tYiaTNH689Mkn95gaAICKhTXEAAAAgDLUqlUrDRo0SHZ2dteVYZK0atUq1apTR1qzRurZs6jQuhdjxhTNDgMAANehEAMAAADKkMlkUlBQkAoLC4v32dvbq1evXnrooStL5lepIm3cKL30UtGC+Pb2t38BBwfJyUl6+23pP/+5s3MBALAR3DIJAAAAlJHU1FT1799f+/fvl6Ojo/Lz8yUVFWKRkZFq0aLFb086cECaPVvavLmoHLNYfnMrZaGdneylos8PHy69+qrk61v6bwgAgHKKGWIAAABAGXj77bdVv3597d+/X/3791dGRoZ69uwpSfq///u/m5dhkhQYWDRb7Phx6Z//lIKDpYYNJRcXydVV2XXr6kuzWZmvvCKdPi2tWEEZBgDAH2CGGAAAAFCKkpKS1K9fPx0+fFjVqlXTypUrNWDAAEnSqVOn9Prrr+u1115T9erV72r8Xbt2KSgoSAMHDtSGDRtKMjoAABUWM8QAAACAUvLPf/5TXl5eOnz4sIYNG6b09PTiMkySGjZsqPfee++uyzBJio2NlSRt3LhR33///T1nBgDAFjgYHQAAAACoaBISEtS3b18dO3ZMNWrU0Lp169S9e/dSuda2bduKXz/88MOKjIyUh4dHqVwLAICKghliAAAAQAmaOXOmfH19dezYMY0dO1apqamlVoYVFhbq22+/Ld7+9ddfNXz4cF2+fLlUrgcAQEVBIQYAAACUgKioKHl5een111+Xu7u79u7dq6VLl8rOrvS+5T5w4ICysrKKtwsLC7Vnzx797W9/K7VrAgBQEVCIAQAAAPfAbDbrmWeeUatWrXT69Gk9/fTTOnv2rDp06FDq1966det123Z2drJYLPrwww9VWFhY6tcHAKC8Yg0xAAAA4C7t27dPgwYN0rlz59SwYUNt3rxZLVu2LLPrR0VFSZJcXFyUnZ0tT09PLVy4UF26dJG9vX2Z5QAAoLwxWSwWi9EhAAAAgPLEbDZr3LhxWrZsmezs7PTCCy9o/vz5ZZ4jKytLqampaty4sdzd3eXo6KizZ8+WeQ4AAMobCjEAAADgDuzevVvBwcFKT0+Xr6+vtm7dqsaNGxsdS3/605+0d+9ebpUEAOA2sIYYAAAAcBsKCgo0fPhw9ejRQ5mZmXr11VcVFxdnFWWYJHXp0kVms1mHDx82OgoAAFaPQgwAAAD4A1u2bFGtWrW0evVqtWzZUidOnNBLL71kdKzrDB48WJK0evVqg5MAAGD9KMQAAACA35Gbm6sHH3xQAwYMUE5OjhYvXqzDhw/L09PT6Gi/0b17d5lMJu3evdvoKAAAWD3WEAMAAABuYvXq1Ro7dqxycnLUvn17bdmyRe7u7kbHuqWaNWuqcuXKLKwPAMAfYIYYAAAAcI3s7GwFBQVp+PDhKiws1Keffqp9+/ZZfRkmSU2bNtX58+eNjgEAgNWjEAMAAACuWLp0qWrXrq1du3bp/vvvV0pKisaPH290rNvWpUsXFRYW6siRI0ZHAQDAqlGIAQAAwOalp6erY8eOevLJJ2UymfTll1/q+++/l6urq9HR7shDDz0kiYX1AQD4IxRiAAAAsGnvv/++PDw8tHfvXvXt21epqal69NFHjY51V4KCglhYHwCA2+BgdAAAAADACMnJyerbt68iIyPl4uKiNWvWaNCgQUbHuid2dnZyc3NTVFSU0VEAALBqzBADAACAzXn99dfl6empyMhIDR06VGlpaeW+DLvK19dXKSkpRscAAMCqUYgBAADAZiQmJqpZs2aaOXOmqlWrph07dmjt2rVydHQ0OlqJ6dy5swoLCxUdHW10FAAArBaFGAAAAGzCrFmz1KRJE8XFxenxxx9XWlqaHnjgAaNjlbjBgwdLYmF9AABuxWSxWCxGhwAAAABKS3R0tAYMGKDExETVrl1b33zzjTp16mR0rFJjNptlb2+v3r17a9u2bUbHAQDAKjFDDAAAABWS2WzWs88+q5YtW+rkyZOaPHmykpOTK3QZJv1vYf0jR44YHQUAAKvFUyYBAABQ4Rw4cEADBw5UcnKyGjRooC1btqhVq1ZGxyozvr6+OnjwoNExAACwWswQAwAAQIVhNpv15z//We3bt9e5c+f0wgsv6PTp0zZVhkn/W1g/JibG6CgAAFglCjEAAABUCD/88IPq1Kmj//znP2rSpIliYmK0cOFCo2MZ4qGHHpIkff311wYnAQDAOlGIAQAAoFwrKCjQiBEjdP/99ysjI0OvvPKK4uPj1bRpU6OjGebq0zN37dplcBIAAKwTT5kEAABAubVt2zYNHz5cWVlZatGihbZu3SpPT0+jY1mFGjVqqEqVKjpz5ozRUQAAsDrMEAMAAEC5k5+fr0GDBqlv377KycnRm2++qaioKMqwa/j4+OjcuXNGxwAAwCpRiAEAAKBcWbt2rWrWrKmNGzcqMDBQZ86c0V//+lejY1mdqwvrx8XFGR0FAACrQyEGAACAciE7O1s9e/bUww8/rMuXL+ujjz7S/v37VadOHaOjWaVBgwZJYmF9AABuhkIMAAAAVm/58uWqXbu2du7cqS5duujcuXOaNGmS0bGsWq9evSRJoaGhxgYBAMAKUYgBAADAamVkZKhz584aM2aMJOmLL77QDz/8IDc3N2ODlQMODg6qXr26jhw5YnQUAACsDoUYAAAArNIHH3ygunXr6qefflLv3r2VlpamUaNGGR2rXPH19WVhfQAAboJCDAAAAFYlJSVFbdu21dNPP61KlSpp/fr12rZtm6pUqWJ0tHKnU6dOKigoYGF9AABuQCEGAAAAq7Fw4UI1aNBAhw4d0uDBg5Wenq7BgwcbHavcurqw/urVqw1OAgCAdTFZLBaL0SEAAABg206ePKl+/frp6NGjql69ulavXl28KDzuXkFBgSpVqqR+/fppy5YtRscBAMBqMEMMAAAAhnr55ZfVuHFjHT16VKNGjVJqaiplWAm5urD+4cOHjY4CAIBVcTA6AAAAAGxTXFyc+vbtqxMnTsjd3V0hISHq3Lmz0bEqHB8fH0VERBgdAwAAq8IMMQAAAJQps9msv/71r2revLkSExM1YcIEnTt3jjKslFxdWD8+Pt7oKAAAWA0KMQAAAJSZiIgIeXp6atGiRfLw8NCBAwf0ySefyM6Ob0tLCwvrAwDwW3znAQAAgFJnNps1adIktW3bVsnJyXruued0+vRptW3b1uhoFV7fvn0lSTt37jQ4CQAA1oOnTAIAAKBU/fjjjxo8eLBSU1Pl7e2tLVu2qHnz5kbHsinVq1eXq6urTp06ZXQUAACsAjPEAAAAUCoKCgr02GOPqUuXLkpPT9fs2bOVkJBAGWYAHx8fJScnGx0DAACrQSEGAACAErd9+3a5u7trxYoVat68uY4fP665c+caHctmXV1YPyEhwegoAABYBQoxAAAAlJj8/HwNGTJEvXv31sWLF7VgwQIdPXpUjRo1MjqaTRs4cKAk6euvvzY4CQAA1oE1xAAAAFAiQkJC9Nhjj+nixYtq06aNtmzZIg8PD6NjQUVFZeXKlTVgwABt2rTJ6DgAABiOGWIAAAC4Jzk5OerTp4+GDBmiy5cv6/3331d4eDhlmBVxdHSUq6urDh8+bHQUAACsAoUYAAAA7tqKFSvk7u6u7777Tn/605907tw5PfXUU0bHwk00adJEZ8+eNToGAABWgUIMAAAAdywjI0Ndu3bVY489JovFov/+97/68ccf5ebmZnQ0/I6rC+snJiYaHQUAAMNRiAEAAOCOfPrpp6pbt6727NmjBx54QOfPn9fo0aONjoU/8OCDD0piYX0AACQKMQAAANymlJQUBQYGauLEiapUqZLWrFmjHTt2yMXFxehouA39+/eXJO3YscPgJAAAGI9CDAAAAH/orbfeUoMGDXTw4EENHDhQqampCg4ONjoW7oCjo6OqVaumyMhIo6MAAGA4B6MDAAAAwHqdPn1affv2VXR0tFxdXfXVV1+pX79+RsfCXWrSpImioqKMjgEAgOGYIQYAAICbmjt3rry9vRUdHa1HH31UaWlplGHlXMeOHXX58mWdPHnS6CgAABiKQgwAAADXiY+Pl4+Pj+bMmaPq1avr+++/15dffikHB24uKO8GDRokiYX1AQCgEAMAAECxF198Uc2aNVNCQoLGjRun8+fP6/777zc6FkoIC+sDAFDEZLFYLEaHAAAAgLEOHz6s/v3768yZM/Lw8NDGjRsVGBhodCyUAldXV9WoUUOJiYlGRwEAwDDMEAMAALBhZrNZTz31lAICApSUlKSpU6fqzJkzlGEVWJMmTXT27FmjYwAAYCgWggAAALBRe/fu1cCBA3X+/Hk1atRImzdvVosWLYyOhVLWsWNHHTp0SCdPnpSXl5fRcQAAMAQzxAAAAGyM2WzW6NGj1bFjR6Wlpenvf/+7Tpw4QRlmIwYOHChJWr16tcFJAAAwDmuIAQAA2JDQ0FAFBwcrIyNDTZs21bZt29SoUSOjY6EM5efnq3Llyho0aJC++eYbo+MAAGAIZogBAADYgPz8fD388MN64IEHdOHCBb322muKjY2lDLNBjo6OqlatmiIiIoyOAgCAYVhDDAAAoILbuHGjRo4cqezsbLVu3Vrffvut6tWrZ3QsGKhx48aKjo42OgYAAIZhhhgAAEAFlZOTo379+mnQoEHKy8vTO++8o4iICMowqGPHjrp8+bJOnjxpdBQAAAxBIQYAAFABrVy5Uu7u7tq6davuu+8+JScna8qUKUbHgpV48MEHJUlr1qwxOAkAAMagEAMAAKhAsrKy1K1bN40cOVJms1lLlizRL7/8opo1axodDVZkwIABkqTt27cbnAQAAGNQiAEAAFQQn332merUqaOwsDD16NFDqampeuKJJ4yOBSvk5OQkFxcXRUZGGh0FAABDUIgBAACUc6mpqerQoYMmTJgge3t7rVq1SqGhoXJxcTE6GqxY48aNlZSUZHQMAAAMQSEGAABQjr399tuqX7++9u/frwEDBigtLU3Dhw83OhbKgasL658+fdroKAAAlDkKMQAAgHIoKSlJrVq10rRp0+Tk5KRNmzZp06ZNcnJyMjoayomr64itXr3a4CQAAJQ9CjEAAIBy5p///Ke8vLx05MgRDRs2TOnp6cXlBnC7Bg4cKEnasWOHwUkAACh7JovFYjE6BAAAAP5YQkKC+vbtq2PHjqlGjRpat26dunfvbnQslGPVqlVTrVq1dOLECaOjAABQppghBgAAUA787W9/k6+vr44dO6YnnnhCqamplGG4Z40bN9bZs2eNjgEAQJlzMDoAAAAAft+RI0c0YMAAnTp1SnXr1tWGDRvUoUMHo2OhgujQoYMiIyOVlJSk+vXrGx0HAIAywwwxAAAAK2Q2m/XMM8+odevWOn36tJ555hklJSVRhqFEPfjgg5JYWB8AYHtYQwwAAMDK7Nu3T4MGDdK5c+fUsGFDbd68WS1btjQ6Fiqg3NxcOTs7a8iQIVq3bp3RcQAAKDPMEAMAALASZrNZTzzxhO677z6dP39eM2bM0MmTJynDUGqcnJxUtWpVHTp0yOgoAACUKdYQAwAAsAK7d+9WcHCw0tPT5evrq61bt6px48ZGx4INaNy4sWJjY42OAQBAmWKGGAAAgIEKCgo0fPhw9ejRQ5mZmfp//+//KS4ujjIMZaZDhw7Kz89XUlKS0VEAACgzFGIAAAAG2bx5s2rVqqXVq1erZcuWSkxM1KxZs4yOBRszYMAASdKaNWsMTgIAQNmhEAMAAChjubm5GjBggB588EFdunRJixcv1uHDh9WgQQOjo8EGDRo0SJK0fft2g5MAAFB2WEMMAACgDK1evVpjx45VTk6O2rdvry1btsjd3d3oWLBhVapUYWF9AIDNYYYYAABAGcjOzlZQUJCGDx+uwsJCffrpp9q3bx9lGKyCt7e3zpw5Y3QMAADKDIUYAABAKVu6dKnc3d21a9cu3X///UpJSdH48eONjgUUu7qwfnJystFRAAAoExRiAAAApSQ9PV2dOnXSk08+KTs7O3355Zf6/vvv5erqanQ04DosrA8AsDUUYgAAAKXg3XfflYeHh3755Rf16dNHqampevTRR42OBdzUQw89JEn67rvvDE4CAEDZYFF9AACAEpScnKy+ffsqMjJSLi4uWrNmTfFT/ABrxcL6AABbwwwxAACAEvL666/L09NTkZGRGjp0qNLS0ijDUG40atSIhfUBADaDQgwAAOAeJSYmqlmzZpo5c6aqVaumnTt3au3atXJ0dDQ6GnDbOnTooLy8PKWkpBgdBQCAUkchBgAAcA9mzZqlJk2aKC4uTo8//rjS0tIUFBRkdCzgjvXv31+StHr1aoOTAABQ+kwWi8VidAgAAIDyJjo6Wv3799fJkydVu3ZtbdiwQR07djQ6FnDXsrOzVa1aNT388MOUYgCACo8ZYgAAAHfAbDZr6tSpatmypU6dOqW//OUvSk5OpgxDuefi4qIqVaooPDzc6CgAAJQ6njIJAABwmw4cOKCBAwcqOTlZDRo00JYtW9SqVSujYwElplGjRjp+/LjRMQAAKHXMEAMAAPgDZrNZf/7zn9W+fXulpKTohRde0OnTpynDUOGwsD4AwFZQiAEAANzCDz/8oDp16ug///mPmjRpotjYWC1cuNDoWECp6NevnyRp7dq1BicBAKB0UYgBAADcREFBgUaMGKH7779fGRkZeuWVVxQfHy8fHx+jowGlZsiQIZKkbdu2GZwEAIDSxRpiAAAAN9i2bZuGDx+urKwstWjRQlu3bpWnp6fRsYBSx8L6AABbwQyxEnb+/Hk99dRT8vLyUuXKleXh4aF+/frphx9+MDqavL29tXjx4js+LzQ0VEOGDFG9evVUtWpVtW3bVp9//nnJBwQAwGB5eXkaNGiQ+vbtq5ycHL355puKioqiDINN8fLy0unTp42OAQBAqWKGWAkbNmyY8vPztXTpUjVp0kTnzp3T9u3blZaWVmrXzM/Pl6OjY6mNv2fPHgUEBGjGjBmqW7euNmzYoLFjx6p69eoaNGhQqV0XAICytHbtWo0ZM0YXL15UYGCgNm/erDp16hgdCyhz7du319GjR5Wamip3d3ej4wAAUCpMFovFYnSIiiIjI0M1atRQaGioevToccvjXnjhBa1fv155eXnq0KGDFi1apDZt2hQf880332ju3LmKjIyUi4uLunXrVry4qbe3t8aPH6+4uDitW7dODz/8sJYsWaKwsDDNnDlT+/btk7u7u4KDgzVv3jxVrVpVQUFB2rVr13U57uV/+oEDB6pu3br697//fddjAABgDbKzszV48GDt3LlTjo6OeueddzRp0iSjYwGGWb58ucaMGaOPPvqI/xYAABUWt0yWIBcXF7m4uGjdunXKy8v73eMeeeQRpaSkaPPmzdq/f78CAwPVq1cvpaenS5I2btyo4OBgPfjggzp48KC2b9+ujh07XjfGG2+8oTZt2ujgwYOaPXu24uPj1b9/fw0bNkwRERFauXKlwsLCNGXKFEnSmjVr5Onpqblz5+rs2bM6e/Zs8Vgmk0lLliy5o/eamZmpmjVr3tE5AABYm+XLl6t27drauXOnunTponPnzlEAwOYNHjxYEgvrAwAqNmaIlbDVq1dr4sSJunTpkgIDA9WjRw+NHDlSAQEBkqSwsDANHDhQKSkpqly5cvF5vr6+mj59uiZNmqQuXbqoSZMmWr58+U2v4e3trXbt2l33OOwJEybI3t5eH330UfG+sLAw9ejRQxcvXpSTk5O8vb01bdo0TZs27brx/Pz8NG/ePAUHB9/We/zqq680ZswYHThwQC1btrzdLw0AAFYjIyNDAwYM0E8//SQnJyf9+9//1qhRo4yOBViNKlWqqEGDBoqLizM6CgAApYIZYiVs2LBhSkpKUkhIiPr376/Q0FAFBgYWz8A6dOiQsrOzVatWreIZZS4uLkpISFB8fLwkKTw8XL169brldTp06HDd9qFDh7RkyZLrxuzXr5/MZrMSEhJuOdbRo0dvuwzbuXOnxo0bp08++YQyDABQLn3wwQeqW7eufvrpJ/Xu3VtpaWmUYcANGjVqxML6AIAKjUX1S4GTk5P69OmjPn36aPbs2ZowYYLmzJmjJ598UtnZ2apXr55CQ0N/c56bm5skydnZ+Q+vUbVq1eu2s7OzNXnyZE2dOvU3x3p5ed3V+7jRrl279NBDD2nRokUaO3ZsiYwJAEBZOXfunPr166dDhw6patWqWrVqVfGtYQCuFxgYqKNHjyo9PZ1lMgAAFRIzxMqAv7+/Ll68KKnom4vk5GQ5ODjI19f3uo+rT/EJCAjQ9u3b7+gagYGBioqK+s2Yvr6+xU+gdHR0VGFh4V29h9DQUA0cOFDz589nbRUAQLmzcOFCeXp66tChQxo8eLDS09Mpw4Bb6Nevn6SidWgBAKiIKMRKUFpamnr27Knly5crIiJCCQkJWrVqlRYsWKAhQ4ZIknr37q3OnTtr6NCh2rp1q06cOKE9e/Zo1qxZ2rdvnyRpzpw5WrFihebMmaPo6GhFRkZq/vz5t7z2jBkztGfPHk2ZMkXh4eGKi4vT+vXrixfVl4rWHtu9e7fOnDmj1NTU4v1+fn7XrUd2o507d2rgwIGaOnWqhg0bpuTkZCUnJxc/BAAAAGt18uRJ+fn5afr06apataq+++47rV+/vviXRQBubujQoZKkrVu3GhsEAIBSQiFWglxcXNSpUyctWrRI3bt3V6tWrTR79mxNnDhR7777rqSiJzpu2rRJ3bt317hx49SsWTONHDlSiYmJqlu3riQpKChIq1atUkhIiNq2bauePXvql19+ueW1AwICtGvXLsXGxqpbt25q166dXn75ZdWvX7/4mLlz5+rEiRPy8fFR7dq1i/fHxMQoMzPzd8deunSpcnJyNG/ePNWrV6/44+GHH76XLxcAAKXq5ZdfVuPGjRUTE6NRo0YpNTX1D9foBFDE1dVVzs7OCg8PNzoKAAClgqdMAgCACiUmJkb9+/fXiRMn5O7urpCQEHXu3NnoWEC54+fnp8TERF26dMnoKAAAlDhmiAEAgArBbDbrr3/9q1q0aKHExERNmDBB586dowwD7lJgYKByc3NZJgMAUCFRiAEAgHLv0KFD8vT01KJFi+Th4aGDBw/qk08+kZ0d3+oAd+vqwvq3WmsWAIDyiu8SAQBAuWU2mzVx4kS1a9dOycnJeu6553T69Gm1adPG6GhAuXf1oVDbtm0zOAkAACXPwegAAAAAd+PHH3/U4MGDlZqaKm9vb23ZskXNmzc3OhZQYbi5ucnZ2VkHDhwwOgoAACWOGWIAAKBcKSgo0KhRo9SlSxelp6dr9uzZSkhIoAwDSkHDhg116tQpo2MAAFDimCEGAADKje3bt2vYsGHKzMyUn5+fvv32W3l5eRkdC6iwAgMDFRsbq4yMDLm5uRkdBwCAEsMMMQAAYPXy8/M1ZMgQ9e7dWxcvXtSCBQsUHR1NGQaUsr59+0piYX0AQMVDIQYAAKxaSEiIatasqZCQELVt21anT5/Wiy++aHQswCYEBwdLkrZu3WpwEgAAShaFGAAAsEo5OTnq3bu3hgwZosuXL+v999/XwYMHVbduXaOjATbDzc1NTk5OLKwPAKhwWEMMAABYnRUrVmj8+PG6dOmS/vSnP2nz5s2sXwQYhIX1AQAVETPEAACA1cjIyFDXrl312GOPyWKx6L///a9+/PFHyjDAQIGBgbp06ZIyMjKMjgIAQImhEAMAAFbh448/Vt26dbVnzx717NlT58+f1+jRo42OBdi8Pn36SJLWr19vcBIAAEoOhRgAADBUSkqKAgMDNXnyZFWqVElr1qzR9u3b5eLiYnQ0APrfwvrffvutwUkAACg5FGIAAMAwb731lho0aKCDBw9q4MCBSk1NLf7hG4B1qFmzJgvrAwAqHBbVBwAAZe706dPq27evoqOj5erqqq+//rr4tiwA1qdhw4Y6efKk0TEAACgxzBADAABl6h//+Ie8vb0VHR2tRx99VGlpaZRhgJVr27atLl26pKysLKOjAABQIijEAABAmYiPj5ePj49eeeUVubm5KSwsTF9++aUcHJiwDli7vn37SpLWrVtnbBAAAEoIhRgAACh1L774opo1a6aEhASNGzdOKSkp6tq1q9GxANymhx9+WBIL6wMAKg5+JQsAAErN4cOH1b9/f505c0YeHh7auHGjAgMDjY4F4A6xsD4AoKJhhhgAAChxZrNZTz31lAICApSUlKSpU6fqzJkzlGFAOebp6anExESjYwAAUCKYIQYAAErUL7/8okGDBun8+fNq1KiRNm/erBYtWhgdC8A9atu2rY4dO6asrCy5uroaHQcAgHvCDDEAAFAizGazRo8erU6dOiktLU1///vfdeLECcowoIK4+jTYkJAQg5MAAHDvKMQAAFbn/Pnzeuqpp+Tl5aXKlSvLw8ND/fr10w8//GB0NHl7e2vx4sV3fF5oaKiGDBmievXqqWrVqmrbtq0+//zzkg9okNDQUNWqVUuff/65mjZtquPHj+uf//yn0bEAlKCrC+tv2bLF4CQAANw7bpkEAFidYcOGKT8/X0uXLlWTJk107tw5bd++XWlpaaV2zfz8fDk6Opba+Hv27FFAQIBmzJihunXrasOGDRo7dqyqV6+uQYMGldp1S1t+fr4effRRrVu3Tvb29po3b57+9re/GR0LQClwd3dX5cqVtX//fqOjAABwz0wWi8VidAgAAK7KyMhQjRo1FBoaqh49etzyuBdeeEHr169XXl6eOnTooEWLFqlNmzbFx3zzzTeaO3euIiMj5eLiom7dumnt2rWSimZ6jR8/XnFxcVq3bp0efvhhLVmyRGFhYZo5c6b27dsnd3d3BQcHa968eapataqCgoK0a9eu63Lcyz+jAwcOVN26dfXvf//7rscw0oYNGzRq1ChlZ2erdevW2rp1qzw8PIyOBaAU+fr66uzZs7p48aLRUQAAuCfcMgkAsCouLi5ycXHRunXrlJeX97vHPfLII0pJSdHmzZu1f/9+BQYGqlevXkpPT5ckbdy4UcHBwXrwwQd18OBBbd++XR07drxujDfeeENt2rTRwYMHNXv2bMXHx6t///4aNmyYIiIitHLlSoWFhWnKlCmSpDVr1sjT01Nz587V2bNndfbs2eKxTCaTlixZckfvNTMzUzVr1ryjc6xBTk6O+vXrp4ceekh5eXl65513FBERQRkG2IB27dopJydH2dnZRkcBAOCeMEMMAGB1Vq9erYkTJ+rSpUsKDAxUjx49NHLkSAUEBEiSwsLCNHDgQKWkpKhy5crF5/n6+mr69OmaNGmSunTpoiZNmmj58uU3vYa3t7fatWtXPGNMkiZMmCB7e3t99NFHxfvCwsLUo0cPXbx4UU5OTvL29ta0adM0bdq068bz8/PTvHnzFBwcfFvv8auvvtKYMWN04MABtWzZ8na/NIZbuXKlxo0bp0uXLqljx47avHlzuSz1ANydjz/+WJMnT9by5cv1+OOPGx0HAIC7xgwxAIDVGTZsmJKSkhQSEqL+/fsrNDRUgYGBxTOwDh06pOzsbNWqVat4RpmLi4sSEhIUHx8vSQoPD1evXr1ueZ0OHTpct33o0CEtWbLkujH79esns9mshISEW4519OjR2y7Ddu7cqXHjxumTTz4pN2VYVlaWunXrppEjR8psNmvJkiX6+eefKcMAG3N1Yf1vv/3W4CQAANwbFtUHAFglJycn9enTR3369NHs2bM1YcIEzZkzR08++aSys7NVr149hYaG/uY8Nzc3SZKzs/MfXqNq1arXbWdnZ2vy5MmaOnXqb4718vK6q/dxo127dumhhx7SokWLNHbs2BIZs7R99tlneuaZZ5SXl6cePXpow4YNcnFxMToWAANcXVh/3759RkcBAOCeUIgBAMoFf39/rVu3TpIUGBio5ORkOTg4yNvb+6bHBwQEaPv27Ro3btxtXyMwMFBRUVHy9fX93WMcHR1VWFh4J9GLhYaGatCgQZo/f74mTZp0V2OUpdTUVPXv31/79+9XlSpVtGrVKg0fPtzoWAAM5unpqcTERKNjAABwT7hlshy6mH9RyyOWa8qmKer4SUc1eKuB6r9ZX/7v+Wvs2rH618//0ums00bHBIC7kpaWpp49e2r58uWKiIhQQkKCVq1apQULFmjIkCGSpN69e6tz584aOnSotm7dqhMnTmjPnj2aNWtW8ayFOXPmaMWKFZozZ46io6MVGRmp+fPn3/LaM2bM0J49ezRlyhSFh4crLi5O69evL15UXypae2z37t06c+aMUlNTi/f7+fldtx7ZjXbu3KmBAwdq6tSpGjZsmJKTk5WcnFz8EABr8/bbb6t+/frav3+/BgwYoLS0NMowAJKktm3bsrA+AKDcoxArR85fPK9pW6ap7ht1NWbtGH28/2PtTdqrpAtJOpt9VtGp0VpxeIWe+/Y5NVrcSMErgxWeHG50bAC4Iy4uLurUqZMWLVqk7t27q1WrVpo9e7YmTpyod999V1LREx03bdqk7t27a9y4cWrWrJlGjhypxMRE1a1bV5IUFBSkVatWKSQkRG3btlXPnj31yy+/3PLaAQEB2rVrl2JjY9WtWze1a9dOL7/8surXr198zNy5c3XixAn5+Piodu3axftjYmKUmZn5u2MvXbpUOTk5mjdvnurVq1f8cXU9HmuRlJSkVq1aadq0aXJyctKmTZu0adMmOTk5GR0NgJXo06ePJCkkJMTgJAAA3D2eMllOfB31tSZ9M0lZeVkqtNzerToOdg6yWCx6qftL+nu3v8vR3rGUUwIAyrN//vOfmjNnjgoLCzV8+HCtWLFCDg6srgDgeqmpqapdu7bGjBmjZcuWGR0HAIC7QiFm5SwWi+aEztGru1+VSSZZdOf/c5lk0gPeDyhkVIiqOlb94xMAADYlPj5e/fr1U3x8vGrUqKF169ape/fuRscCYMWcnJzUpEkTRUVFGR0FAIC7wi2TVu6171/Tq7tflaS7KsOunrcrcZeGfDlElwsvl2Q8AEA5N2PGDDVr1kzx8fF64oknlJqaShkG4A81aNCAhfUBAOUahZgV+z7xe83eObtExiq0FGpHwg69HvZ6iYwHACjfjhw5Ii8vLy1YsEC1a9fW3r17tWTJEtn9f/buPT7n+v/j+OO6dtlmtpmZ2ZzmfFwOcyjnc4SfQ+igwgohRCpfOSQdRESUFMWKnEKUHErIKTnOeRgzzAyzzTY7Xtfvj2lZzozPDs/77bab67o+n+vzeX6WZnvt9X59zPrWQETuTIP1RUQku9N3vVnU1eSrdP+pO2bTtf9EScA24FtgPPA+MAWYBwQCKdfeuBX44do+Y659TE7bZMPG2D/Hsu/8vkdyDSIikvVYrVZee+01HnvsMc6cOcOAAQMICwujVq1aRkcTkWykRYsWAPz8888GJxEREbk/KohlUfP2zyMkKiRtgH4E8CWwBggFrgKpQBRwDFgGXLj2xo3A0Wv73IwtbRmmiIjkPjt37sTb25vp06dTrFgx9u/fz7Rp09QVJiL3rHPnzgCsXr3a4CQiIiL3R98BZ0E2m43Ptn+GGTPEk9YFdvnaRhegFdAdeBZ4AnC47s1eQC2g+c2PnWJLYcnhJYTHhj+k9CIiktVYrVZ69OhB7dq1uXjxIv/73/8IDQ2lSpUqRkcTkWzK09MTBwcHdu7caXQUERGR+6J7qWdBJy6f4EDEgbQnW4HoaxscgN6A63U7VwIa8G9p0//anxeAdTc/fqo1leVHlvNqrVczM7aIiGRBf/75J506dSIyMpKyZcuydu1aSpUqZXQsEckBNFhfRESyM3WIZUE7w677TdvB6zbUJWMx7B/OgNPdH9/ObMeuc7vuL5yIiGQLKSkpdOnShcaNGxMdHc0HH3zAsWPHVAwTkUxTrVo14uLiiI+PNzqKiIjIPVNBLAsKPB9IHnMeSOTfpZIAJTLn+CnWFHaF3VgQCwsL4+OPP6ZLly4kJiZmzslEROSRW7VqFe7u7ixZsgRfX19CQ0MZMWKE0bFEJIfRYH0REcnOVBDLgqITrq2R/G9NyiXzznE5Ia3SlpSUxLJly2jbti3FihVj+PDhLFmyhKioqMw7mYiIPBIJCQk89dRTtGnThoSEBKZMmcL+/fspUqSI0dFEJAd6+umngbQivIiISHajGWJZkJ3ZLu2Bw382XAEKZc45Lpy/QOnSpTl9+jQpKSmYTCZsNhsAJpOJQoUy6UQiIvJI/Pjjj/To0YP4+Hhq1qzJ6tWr8fDwMDqWiORgXl5e2Nvba7C+iIhkSyqIZUHezt5Ybda0glgB/l02eRoonTnnyHM1D6dOncJqtQKkF8P+eZwnTx4cHBxwcXGhQIECFCpUiKJFi+Lj40O5cuWoVKkSjz32GK6uNxtqJiIij0psbCzt2rVj48aNODg4MGvWLF555RWjY4lILlG0aFFCQkKMjiEiInLPVBDLgmoWqUmqLTXtSRVg87UN24Aa3DhYP5a0xa93OVg/jzkPvdv0ZuzHY/n44495//33sdls6cUxNzc3qlatSkREBJcvX+b06dMcP36c1NTUG45lMpmwt7fHycmJ/PnzU6hQIby9vSlRogRlypShQoUKVKlShWLFimE2a4WuiEhmCggI4NVXXyUxMZGGDRvyyy+/6BcVIvJIVatWjZ9++on4+HicnO7hLk8iIiIGM9mubw2SLCHyaiSen3imFcXiga+Aa2PFcAXqAZ5AEhAC7AF6At7AsWuvXwFWX3uPE9D22mM3oCgse3YZHSt2BCAoKIjevXuzadMmANq0acPKlStvyJWSksKxY8c4ePAgQUFBnDx5kjNnzhAeHs6lS5eIiYnh6tWrJCcn3/S6LBYLefPmxdXVFXd3d7y8vChWrBilSpWifPnyVKlShYoVK2KxqE4rInI7kZGRtG7dmh07dpA3b17mzJnDM888Y3QsEcmFPv/8cwYOHMjChQv1dUhERLIVFcSyqK6LuvJT0E+kWFMgAphPxjtO/terpBXEJvNv8exmqkHBbgUJGxqGvZ19+ss2m42AgAAGDx7Mq6++yvjx4x8of1hYGPv37ycoKIjg4GBCQ0MJCwvj4sWLREVFERcXR1JSEjf762c2m3F0dMTZ2ZkCBQrg6emZvlyzbNmyWq4pIrna559/zhtvvEFycjJPPvkky5YtU1eGiBgmPDwcb29vevbsyezZs42OIyIictdUEMuiNoZspElAk39fSAJ2AYeBC9ee5yNtyP5jgC9pC2DvUBAzVTcxYtII3m/2/k23JyUlYTabH1mX1pUrVzhw4ACHDx/m+PHjhISEcPbs2fTlmleuXCEhISF9Oef1rl+u6ebmhoeHxw3LNR977DGKFCmi5Zoiku2dO3eOVq1asX//fpydnVm4cCFt2rQxOpaICA4ODpQvX579+/cbHUVEROSuqSCWRdlsNjov6syKoBX/zhN7QGaTGS9nLw6/dhhXh+zVXZWSksLRo0c5dOhQ+nLN06dPc/78+fTlmvHx8aSkpNz0/dcv1yxYsCBeXl4ULVqU0qVLU758eSpXrqzlmiKSZX388ceMHDmS1NRUOnXqxIIFC7C3t7/zG0VEHoFSpUpx4cIFYmNjjY4iIiJy11QQy8Ii4iKo+HlFYhJjMq0otvbFtbQs0zJTjpUV2Ww2wsLCOHDgAEeOHElfrnnu3LkHWq5ZsmTJ9OWavr6+Wq4pIo/EqVOnaNmyJceOHaNAgQIsXbqUJk2aGB1LRCSDjh07snz5cq5evYqjo6PRcURERO6KCmJZ3F9n/qJZQDOSUpMeuCg2udVkBj8xOHOC5QAxMTEcPHiQQ4cOpS/XDAsLIyIigsjISGJjY++4XDNfvnzkz58fDw8PihQpQokSJShdurSWa4rIAxsxYgQff/wxVquVl156iTlz5ujriYhkSdOmTWPQoEEsXryYLl26GB1HRETkrqgglg38deYv2s5rS3Ri9D0XxexMdgBMfWoq/Wv3fxjxcryUlBSCgoI4ePAgx44dS1+uGR4eTmRk5F0t13RycsLFxSV9uWaxYsUoXbo05cqVo0qVKlSoUEHLNUUEgMOHD9O6dWtCQ0MpVKgQK1eupHbt2kbHEhG5pbCwMIoWLYq/vz/ffvut0XFERETuigpi2cTF+Iu8tvI1Fh1ahMVsSbv75G3YmexItaVSpVAV5j49l+pe1R9N0FzMarVmWK554sSJDHfXjI6Ovuvlmu7u7hQqVCjDcs3KlSvj6+uLi4uLAVcnIg+b1Wpl8ODBfP755wC8+uqrfPHFF+oKE5FswcHBgQoVKrBv3z6jo4iIiNwVFcSyma2nt/LFji9YdHARKdYUzCZzeheYzWYjxZZWKGtQvAEDHx9Ip4qdyGOXx8jIchMxMTG3vbvm3S7XvN3dNb29vfWDtEg2sXv3btq2bUt4eDhFixZl9erV+Pr6Gh1LROSulSxZkkuXLnHlyhWjo4iIiNwVFcSyqSuJV9gTvoddYbs4H3eeVGsqrg6ufDToI+r61OWPFX8YHVEyQXJyMkePHuXgwYMcPXqUEydOcPbsWcLDw9Pvrnn16tU7Ltd0dXXF3d0dLy8vihcvTqlSpdLvrqnlmiLGsVqtvPLKK+nzwd544w0++eQTo2OJiNyzDh06sGLFCg3WFxGRbEMFsRzEZrNhsViwWq0EBgZStWpVoyPJI/LPcs39+/cTFBREcHAwp0+fTl+uGRUVRXx8/B2Xa7q4uGS4u6aPj0/6cs3HHnsMZ2dnA65OJGfasmUL7du3JzIyktKlS7N27VrKlCljdCwRkfvy2WefMXjwYH788Uc6d+5sdBwREZE7UkEsBwkODqZs2bIAFC9enL179+Lu7m5wKslqYmJi2L9/P0eOHMm05Zo+Pj6ULl2aihUrpi/XNJlMBlydSNaXkpJCt27dWLx4MXZ2dowePZrRo0cbHUtE5IGcOXOG4sWL88orrzBr1iyj44iIiNyRCmI5yNdff82rr74KpHX8NGvWjNWrV2NnZ2dwMsmOkpKS0pdrHjt2jBMnTnDmzBnOnz9/z8s1r7+7ZqlSpahQoQKVK1emfPnyWq4pucqaNWt45plniImJoVKlSqxdu5ZixYoZHUtEJFPY29tTsWJFDdYXEZFsQQWxHOSZZ55h6dKlpKamAmndPP/73//46KOPDE4mOZnVauXs2bMcOHAgfblmaGgo586de6DlmiVLlqRcuXJUqlQJX19fLdeUbC0hIYHOnTvz66+/YrFYGD9+PG+88YbRsUREMpUG64uISHaiglgOYbVaKViwIFFRUTdsW7duHc2aNXv0oUT+45/lmocPH+bYsWOcOnWKsLCw9OWaV65cITEx8a6XaxYpUiT97poVK1bE19eXIkWKGHBlIre2bNkyXnrpJeLi4vDz82PVqlV4enoaHUtEJNP93//9H7/88osG64uISLagtUo5xIEDB4iKisJsNqcXExwdHfHz86NAgQIGpxNJ4+rqSv369alfv/5t97t+uWZQUBAhISGcOXOG8PBwIiMjuXDhAqGhofz99983fX+ePHnImzdvhuWa199ds0qVKpQrV07LNeWhio2NpX379qxfvx57e3u++uor+vTpY3QsEZGHpnnz5vzyyy+sWrWKTp06GR1HRETkttQhlkOcPHmSnj17UqFCBfbs2cPOnTu5ePEiBQsWNDqayENjtVo5c+ZM+nLNEydOEBoamn53zejo6Nsu17Szs8PBwSF9uWbhwoXT765Zrlw5KleuTJUqVbRcMxew2qzEJ8eTak3FKY8Teezy3PV7Y2JieOmllxg2bBj16tUDYO7cufTu3ZuEhATq1avHypUrcXNze0jpRUSyhtDQUHx8fOjVqxczZ840Oo6IiMhtqSCWAwUEBNCzZ0+++eYbXn75ZaPjiGQJUVFRHDhwgCNHjqQv1/zn7ppRUVH3tFyzUKFCeHt7U6JECcqWLZu+XNPb29uAK5P7FXQxiNl7Z7M5dDN7wvcQnxwPgNlkpqJHReoWq8szVZ6hRekWmE3mWx7nrbfeYuLEifj4+LB161aefvpptm/fTt68efnmm294/vnnH9UliYgYzt7enkqVKhEYGGh0FBERkdtSQSwHunLlCq6urnTu3Jkff/zR6Dgi2UpSUhJBQUEcOnSIoKAgTp48mX53zcjIyDveXfP65ZoeHh4ULlyY4sWLU7p0acqXL0/lypW1XNNggeGBDFkzhPUh67GYLaRYb3Gn1GvbSrqV5IOmH9DtsW6YTKYM+xw9epQqVaqk/334Z9l6ixYtWL58OU5OTg/9ekREshIfHx8uX75MTEyM0VFERERuSwWxHMrZ2RlPT09OnDhhdBSRHOn65ZpHjhzhxIkTnD59OsNyzbi4OJKTk2+5XNPR0RFnZ+cMyzX/e3fNfPnyGXB1OVOqNZWPNn3EexvfS3tuS72r95kwYcNGu/Lt+Kb9N3jm+3cgfps2bVi7dm363X0BJkyYwFtvvZW54UVEsol27dqxcuVKEhMTsbe3NzqOiIjILakglkNVq1aNw4cPk5SUZHQUkVzvn+Wahw4dIjg4OMNyzcuXLxMbG3tPyzX/e3fNxx57DC8vLwOuLPtIsabw4tIXWXRwETbu7589i8lCsfzF2NhzIyXyl2DVqlW0adMmwz5ms5kyZcqwf/9+HBwcMiO6iEi28umnnzJ06FB++uknOnToYHQcERGRW1JBLIfq27cvX331FcHBwZQuXdroOCJyF5KSkjhy5AiHDh3i6NGjGZZrXrp0iStXrtzVcs38+fOn312zWLFi6cs1fX19KVu2LHZ2do/4yoz3yvJXmL139n0Xw/5hMVso7lqcNU+voUqZKiQnJwOkf07/6RT7/fffad68+YOFFhHJhv4ZrN+7d2++/vpro+OIiIjckgpiOdSaNWto3bo1H330EcOHDzc6johkIqvVyunTpzl48CBHjhwhODiY0NBQwsPD72m55j931/T09Exfrlm+fPn05Zo5Zf7Vj4d+pOvirpl2PLPJjP0RexLmJ5A/f34aNmxIqVKlKFGiBCVKlKBUqVLUqlXrhnljIiK5hb29PZUrV2bv3r1GRxEREbklFcRyqJSUFOzt7WnWrBm///670XFExCCXL1/m4MGDHDp0iOPHj3Pq1CnCwsLuermmg4ND+nJNDw8PihQpgo+PD6VLl04vnGXl5ZpRCVGU/qw0UQlRad1hScAu4DBwgbTnLkAhwBeoAvxzv4MDwHYg/NpzL+Dxa/sBAS0D6F6v+yO6EhGR7KNEiRJERUVpsL6IiGRpKojlYB4eHlgsFsLDw++8s4jkav8s1zx48CDHjh3LlOWaxYsXp1SpUunLNcuVK4fZbM7U3BcuXGDixIm89tprlChR4obtk7dNZujaoWnFsAhgPnD5Ngd8FfAG1gMbb7FPU7BrYkf9EvXZ2PNWO4mI5F5t27bl119/1WB9ERHJ0lQQy8EaNGjAtm3bSE5OzvQfQkUkd/pnueb+/fsJCgrixIkThIaGcu7cOS5dukRUVBTx8fF3vVzzv3fXrFy5MlWqVLnr5Zpz5szB398fR0dHxo0bx4ABA7BY0lq8rDYrZaeWJSQqBFu8Db4Coq+90QWoBxQGEoFTwB6g57XtXwM2wB546tprq0jrKDORVjjzgoP9D1K5UOV7/CyKiORskyZN4s0332T58uW0b9/e6DgiIiI3ZbnzLpJdNWnShC1btrB9+3bq1q1rdBwRyQHMZjM+Pj74+PjQrl272+4bGRnJwYMHOXz4MMePHyckJISwsDAuXLjA5cuXCQkJISgo6K6WaxYqVAhvb298fHwoU6ZM+nLNc+fOYWdnR0JCAkOGDGH27Nl8++231KxZk6OXjnIy6mTaAbfybzHMAegNuF53wkpAA8AM/AHps/cbAjWuPY4F1l3bthvs2tqx8uhKFcRERP6jS5cuvPnmm/z6668qiImISJalglgO9swzz/Dhhx/y448/qiAmIo+cu7s7DRs2pGHDhrfdLykpicOHD9/07pqRkZGcP3+eU6dO3XK55vX27dtHrVq1qFq1Ki2Htvx3w8HrdqpLxmLYP5yv/Rl63WvFb/H4VNofu87tumMmEZHcxsfHB4vFwvbt242OIiIicksqiOVgVatWxc7Ojk2bNhkdRUTkluzt7alWrRrVqlW77X43W665bNkyzp07d8O++/btY993+zDVN2FLtmWcG3bjqLGMoq577Hzd43wZ90m1pbI3fO8dDiYikjt5e3tz4sQJo2OIiIjckgpiOZyXlxdHjx41OoaIyAO72XLN3bt3py+bTE1NpVChQvTq1YuuXbsy9ehU5h2dR3JscsYDudzhRNfvbneLx0lpf8Qlxd3n1YiI5Gy+vr6sWrWKpKQkDdYXEZEsSZPWc7jq1asTHR1NQkKC0VFERDJdQkICdnZ2/N///R+//PILYWFhfPTRR9SoUYOCBQqm7eTwnzdducNB81z3+PpVmqnXPb72s53FTr9XEhG5maZNmwKwdu1ag5OIiIjcnApiOdyTTz4JwMqVKw1OIiKS+f4pgi1btoy2bdum32ESoJRbKVKsKWkFsQLXven0HQ7qdt3j6xvAYjPuY8JEOfdyGd5qs9k4ceIES5cuZfny5fdyKSIiOUqXLl0AfQ8qIiJZl361ncM988wzvP766/z888907tzZ6DgiIpmqaNGit9xWs0hNbP/cLrIKsPnahm2k3Tnyv4P1Y0n7NVEJIOLaa6eBktcen7luXx8w2Uxc2neJF154ARcXl7S5Zfv2EReXVkVzc3Pj8uXrh5eJiOQepUqV0mB9ERHJ0lQQy+G8vLxwcHDQNyMikmOdO3cOs9mMm5sbDg7/ro+s7lWdvHZ5uZp6FeoB+4FoIAGYRdprnqTNAwsB9gA9gZrALsAGbCJtmL7p2mOuPfYDq8nKwVUH2X1w9w2ZzGYzjRs3fghXKyKSfXh5eREcHGx0DBERkZvSkslcwMfHh5CQEKNjiIhkuqNHj1KkSBG8vLxwdHTE0dERDw8PChQogKuTK1e3XsVkM4ET8AL/Lp2MAVYD3wELgL+AxGvbvIFG1x4nASuA5aQP0qcJ4AXFXYsTtSuKli1b3pDLarWyZ88eJkyYQExMTOZfuIhINuDr60tMTAwpKSl33llEROQRU0EsF6hTpw4JCQlcuHDB6CgiIpmqVKlSFCpUKP15YmIily5dIioqiuTkZP7X/H9pHV2Q1g3WD2hF2rLIvKTdOdIVKAN0BP45VFOgC1CMtCH7ea497gI0TpsfNviJwTg6OLJmzRpGjx59Q7YzZ84wbNgw8ufPj5eXF88//zybN2++YT8RkZxKg/VFRCQrU0EsF2jXrh0AixcvNjiJiEjmsrOz44knnrjhdbPZzMaNGxk3dBxv1XsLs+naP3f2QF3gZWAYMAp4A3gJqE7GQQK+QC9gxLWPXmmv2ZnsqFyoMgPqDADAZDLx3nvvMW3aNEymtOpbhQoVSE5OZvHixbRu3ZqEhAQWLFhAw4YNcXBwoGbNmnz88cfqHhORHO2f+bW//PKLwUlERERupIJYLtC+fXsA1qxZY3ASEZHMERkZib+/P87Ozvz88883bA8ICKBRo7R1j+81fY9y7uWwmB58bKYJEyaTie87fY+9nX2GbQMGDOCHH37AYrHQuXNnzGYzXbp0YdWqVURFRXHq1CneeustSpUqxd69exk+fDj58+encOHCPPfcc/z5558PnE9EJCspU6aMBuuLiEiWZbLZbDajQ8jDlz9/fvLnz09oaKjRUURE7tvmzZsZOnQoO3bswGaz4enpycCBAzlw4ACLFy/GarUyatQoxo4dm+F9p6NPU+/beoTHhpNivb9ZNiZM2Jnt+LHrj3So2OGW+4WGhlK4cOEMA/7/y2q1smzZMr755hu2bdtGVFQUAPb29lSpUoWuXbvSr18/3Nzc7iuriEhWUaxYMWJjY9O/zomIiGQVKojlEjVr1mTfvn0kJycbHUVE5J5YrVYmTJjAZ599Rnh4OCaTCT8/PyZMmECzZs0A2LZtG/Xq1eO5557jhx9+SF+6eL2zMWdpv6A9e87twca9/dNnZ7LDxcGFBZ0X0Kpsq0y5ruudOXOGadOmsXz5co4fP05qaioAnp6eNG7cmP79+9OkSZNMP6+IyMPWunVr1qxZQ3JyMhaLbnAvIiJZh5ZM5hINGjQgJSWFQ4cOGR1FROSunDlzhi5dupA3b16GDx9OVFQU3bt3JyIigp07d6YXwwDq1q3Ljh07CAgIuGkxDKCoa1G299rOuObjsLez/3eu2G1YzGk/vHWs2JGgAUEPpRgGaR0U48eP58iRIyQlJbF06VLatGlDUlISixcvpmnTptjb21OjRg0+/PBDdVqISLbxTzH/t99+MzaIiIjIf6hDLJfYtGkTjRo14t1332XMmDFGxxERuaUVK1YwYsQIDhw4AEDx4sX53//+R9++fTGbM+f3OBfjLzJ7z2y+3vU1xy8fv+k+bo5udPPtRr/a/fD19M2U896Ps2fPpnePHTt2LL17rFChQjRu3Jh+/fplKA6KiGQlx44do3z58vTv358vvvjC6DgiIiLpVBDLJaxWKxaLhYYNG7Jx40aj44iIZJCQkMCYMWP4+uuvuXz5MmazmQYNGjBp0iRq1ar1UM99+epldp/bTXhsOKm2VNwc3ahWuBol8pe4ZbeZUaxWKytWrGDWrFls2bIlvVMsT548VK5cma5du9K/f38KFChgbFARkevkyZOHatWqsXPnTqOjiIiIpFNBLBfx9PTEZrNx4cIFo6OIiABw+PBhhgwZwu+//05qaiouLi706NGDcePG4ezsbHS8LC8sLCy9e+zo0aM3dI/17duX5s2bG5xSRHI7DdYXEZGsSAWxXKRp06Zs3LiRlJSUTFt2JCJyP7777jvGjh1LcHAwAOXKlePdd9/lhRdeMDhZ9mW1Wvnll1+YOXMmW7Zs4fLly8C/3WOdO3fmtddew93d3eCkIpLbtGrVirVr12qwvoiIZCmqiuQizZo1w2azsX79eqOjiEguFBMTQ79+/XB2dqZHjx6cOnWKNm3acPToUY4ePapi2AMym820b9+en3/+mcjISMLCwnjnnXcoW7YsBw4cYPTo0RQsWJBChQrRpUsXfv/9d6Mji0gu8c9g/XXr1hkbRERE5DoqiOUizz33HADLli0zOImI5CY7duygQYMGuLm5MWPGDBwdHRk5ciRxcXGsXLmScuXKGR0xR/L29ubDDz/k0KFDJCUlsXz5ctq1a0dqaipLliyhZcuW2NvbU61aNcaOHculS5eMjiwiOVSXLl0A+OWXXwxOIiIi8i8tmcxl7O3tqVKlCnv27DE6iojkYFarlalTpzJx4kTOnj0LQNWqVRk3bhxt2rQxOJ2Eh4czbdo0fvrpJ4KCgtJnj3l4eNCwYUP69etHy5YtDU4pIjmJxWKhevXqGqwvIiJZhgpiuUzJkiW5dOkSV65cMTqKiORA4eHhDB06lCVLlpCYmIi9vT2dOnXi008/pUiRIkbHk5uwWq38+uuvzJw5k82bNxMZGQmk/fBaqVIlnn76aQYMGICHh4fBSUUkOytatCjx8fHp8w1FRESMpoJYLtOpUyd++ukn4uLicHJyMjqOiOQQv/32G8OGDUvvPvX29mbo0KEMGTJEN/HIZsLDw/niiy9YtmwZQUFBpKSkAFCwYEEaNWrEq6++SsuWLfXfVUTuyZNPPslvv/2mwfoiIpJl6LvZXOapp54CNEdMRB5ccnIyY8aMoVChQjz55JPs3buXunXrsnXrVsLCwhg6dKiKJtmQl5cX77//PgcOHCAxMZGVK1fSoUMHbDYby5Yto3Xr1jg4OFC1alXGjBnDxYsXjY4sItnAP4P1dXMnERHJKtQhlstERkZSsGBBnn/+eX744Qej44hINhQcHMzgwYNZvXo1KSkpODk58cILLzBhwgTc3NyMjicPUUREBJ9//jnLli3jyJEjGbrHGjZsSJ8+fWjVqpUKoSJyg6NHj1KhQgUGDhzI1KlTjY4jIiKiglhulC9fPooUKcKxY8eMjiIi2ciiRYsYPXo0QUFBAJQqVYqRI0fi7++PyWQyOJ08alarlTVr1vD111+zadOm9LtUWiwWKlasSKdOnRgwYACenp4GJxWRrMJisVCjRg127NhhdBQREREVxHKjKlWqEBwcTEJCgtFRRCSLi4+P55133mH27NnExMRgNptp1qwZkydPxtfX1+h4koVEREQwffp0li5dyuHDh9O7x9zd3dO7x1q3bq3uMZFcTIP1RUQkK9F3pbnQE088QWJiImfOnDE6iohkUfv27aNZs2a4uLjw2WefYTabefPNN4mLi+O3335TMUxu4OnpyZgxY9i3bx+JiYmsXr2aTp06YTKZWL58OW3btsXBwQFfX19GjRpFRESE0ZFF5BGrUqUKUVFRWK1Wo6OIiIioIJYbdejQAUhb/iQi8g+r1cpXX31FyZIlqVatGuvXr6dixYosXbqUy5cv88knn+Do6Gh0TMkGzGYzrVq1YunSpVy8eJELFy4wZswYKlWqRFBQEB988AGFCxemYMGCdOjQgV9++UU/IIvkAo0bNwY0WF9ERLIGLZnMhZKSknBwcKB169asWrXK6DgiYrDIyEiGDh3KwoULuXr1Knny5KFt27ZMmTIFHx8fo+NJDmOz2fjtt9+YMWMGmzZtSr9LpZ2dHRUqVKBjx44MHDgQLy8vg5OKSGYLCgqiYsWKDBo0iM8++8zoOCIiksupIJZLFShQACcnJ86ePWt0FBExyJ9//smbb77Jzp07sdlseHp6MmjQIIYNG4bFYjE6nuQSFy9eZPr06SxZsoTDhw+TnJwMpP07Vb9+fXr37k27du00e0wkh7BYLPj5+fH3338bHUVERHI5FcRyqbp16/L333+TmppqdBQReYRSUlL45JNP+Oyzzzh//jwmkwk/Pz8mTJhAs2bNjI4nwu+//86MGTPYuHFjhu6x8uXL07FjRwYNGqTuMZFsrEiRIiQkJBAZGWl0FBERyeX069ZcqlGjRlitVnbu3Gl0FBF5BM6cOUOXLl1wcnLinXfeITo6mu7duxMREcHOnTtVDJMso0WLFvz4449cuHCBS5cuMXbsWHx9fTl+/Djjxo3D29sbd3d32rVrx/LlyzV7TCSb0WB9ERHJKlQQy6W6dOkCwJIlSwxOIiIP04oVK3jssccoXrw4S5YswcvLiy+++IK4uDgCAgLw8PAwOqLILbm7uzNq1Cj27t1LUlISv//+O126dMFisbBy5Uo6duyIvb09lSpVYvjw4YSFhRkdWUTuoHHjxthsNjZs2GB0FBERyeW0ZDKXstlsWCwWHn/8cbZu3Wp0HBHJRAkJCbz77rvMnDmTy5cvYzabadCgAZ9++ik1a9Y0Op5IpoiMjOTLL7/kxx9/5ODBg+mzx9zc3Khfvz69evWiffv2mj0mksUcPnyYypUrM3jwYCZPnmx0HBERycVUEMvFvL29SUxM1AwHkRzi8OHDDB48mHXr1pGamoqLiws9evRg3LhxODs7Gx1P5KH6448/mDFjBhs2bODChQtA2uyxcuXK0aFDBwYNGkSRIkUMTikikDZYv2bNmmzfvt3oKCIikoupIJaLtWrVirVr15KcnKw7yolkYwEBAYwdO5YTJ04AUK5cOd59911eeOEFg5OJGOPy5ct8+eWXLF68+IbusXr16vHKK6/QsWNHdY+JGESD9UVEJCvQd4K5WMuWLQFYvXq1wUlE5F7FxMTQr18/nJ2d6dmzJ6GhobRp04ajR49y9OhRFcMkVytQoADvvPMOe/bsISkpifXr19O1a1fs7e359ddf6dy5M/b29lSsWJFhw4Zx5swZoyOL5CqVK1fWYH0RETGcCmK52DPPPAPA8uXLDU4iIndr+/btNGjQADc3N2bMmIGjoyMjR44kLi6OlStXUq5cOaMjimQ5TZo0YdGiRZw/f57Lly/z0UcfUbVqVU6ePMmECRMoXrw4bm5utGnThiVLluiHdJGHrFGjRhqsLyIihtOSyVzOwcGB8uXLs3//fqOjiMgtWK1Wpk6dysSJEzl79iwA1apVY9y4cTz11FMGpxPJ3jZu3MiXX37J+vXriYiIANJmj5UpU4b27dszaNAgihcvbnBKkZzl4MGD+Pr6arC+iIgYSgWxXK5s2bKcO3eOuLg4o6OIyH+Eh4fzxhtvsHTpUhITE7G3t6dTp058+umnGg4u8hBERUUxY8YMFi9ezIEDB0hKSgIgf/781K1bl1deeYWnn35as8dEMoEG64uIiNFUEMvlnn32WRYtWsTly5dxc3MzOo6IAGvXrmXYsGHs3bsXSLsj7NChQxkyZIh+EBd5hDZt2sT06dNZv34958+fB8BsNlO2bFnat2/PwIEDKVGihMEpRbIn3e1cRESMpp+scrl27doBsGTJEoOTiORuSUlJvPvuuxQqVIhWrVoRGBhI3bp12bp1K2FhYQwdOlTFMJFHrGHDhsyfP5/w8HCio6MZP348NWrUICQkhIkTJ+Lj44ObmxutW7dm0aJFmj0mcg80WF9ERIymn65yuU6dOgGwatUqg5OI5E7BwcH83//9H/ny5WPs2LHEx8fTu3dvIiMj2bp1K3Xr1jU6oogArq6uvP322+zcuZPExEQ2bdrE888/T968eVmzZg3PPvssefLkoXz58gwdOpRTp04ZHVkkS/tnsP6ff/5pdBQREcmltGRScHFxwcPDg5MnTxodRSTXWLRoEaNHjyYoKAiAUqVKMXLkSPz9/TGZTAanE5F7ERMTw4wZM1i0aBH79+9Pnz3m6urKE088wcsvv0zXrl3V5SlynQMHDvDYY48xZMgQPv30U6PjiIhILqSCmFC9enUOHTqU/g28iDwc8fHxDB8+nDlz5hATE4PZbKZZs2ZMnjwZX19fo+OJSCbZsmUL06dP548//iA8PBxImz1WpkwZ2rVrx+uvv46Pj4/BKUWMZ2dnR+3atfnrr7+MjiIiIrmQCmJCv379mDFjBsePH6dMmTJGxxHJcfbu3cuQIUP4888/sVqtuLm50atXL95//30cHR2NjiciD9GVK1f46quvWLhwIfv37ycxMRFI6x57/PHH8ff359lnn1X3mORK3t7eJCUlcenSJaOjiIhILqTvvoSnn34aSFvCJSKZw2q1MmPGDHx8fKhRowYbNmygYsWKLF26lMuXL/PJJ5+oGCaSC7i4uPDmm2+yY8cOEhIS2Lp1Ky+88AJOTk789ttvdOvWjTx58lCuXDmGDBmi8QWSq1SqVInLly9rsL6IiBhCBTGhefPmmEwmfv/9d6OjiGR7kZGR+Pv74+zsTL9+/Th37hwdO3YkJCSEgwcPpt/IQkRyp7p16zJ37lzOnTvHlStXmDhxIjVr1uT06dNMmTKF0qVL4+rqSsuWLZk3bx4pKSlGRxZ5aP4ZrL9582ajo4iISC6kJZMCgIeHBxaLJX3WiYjcmz///JM333yTnTt3YrPZ8PT0ZNCgQQwbNgyLxWJ0PBHJBv766y+++OIL1q1bx7lz54C02WOlSpWibdu2DB48mFKlShmcUiTz7Nu3j2rVqvHGG28wadIko+OIiEguo4KYANCwYUO2bNlCSkqK5piI3KWUlBQ++eQTPvvsM86fP4/JZMLPz48JEybQrFkzo+OJSDYWGxvLzJkzWbBgAYGBgemzx1xcXKhTpw49e/bkueeeU8Fdsj07Ozvq1KnDtm3bjI4iIiK5jCofAkDTpk2x2Wz6ZkTkLpw+fZrOnTvj5OTEO++8Q3R0NN27dyciIoKdO3eqGCYiD8zZ2ZkhQ4awfft2EhIS2L59Oy+99BIuLi6sW7eOl156CQcHB8qUKcPrr79OcHCw0ZFF7kuhQoU4evSo0TFERCQXUkFMAHjmmWcAWLJkicFJRLKuFStW4OvrS4kSJVi6dCleXl588cUXxMXFERAQgIeHh9ERRSSHqlOnDt999x1nz54lNjaWyZMnU7t2bcLCwpg6dSply5bF1dWV5s2b8/3332v2mDx0Fy5coF+/fpQoUQIHBwe8vLxo1aoVW7ZsuafjPIzB+iVLlmTKlCn3/L6QkBBMJtMNH3/99VemZRMRkaxDBTEBwNfXFzs7OzZt2mR0FJEsJSEhgWHDhuHu7k6HDh04fPgwjRo1YufOnYSGhtK/f38tMxaRRypfvnwMHjyYv/76i6tXr/L333/TvXt3XFxc+OOPP+jevTv29vaUKVOGgQMHcuzYMaMjSw7UuXNn9uzZQ0BAAEePHmXFihU0adKES5cu3dNxGjZsiM1mY+vWrXfcNykp6X7j3pPff/+dc+fOpX/UrFnzkZxXREQeLc0Qk3TFixcnJiaG6Ohoo6OIGO7w4cMMHjyYdevWkZqaiouLCz169GDcuHE4OzsbHU9E5Kbi4+OZNWsWP/zwA4GBgSQkJABpSzBr165Njx49eOGFFzR7TB5IVFQUBQoUYMOGDTRu3Pi2+7355pssX76cxMREatWqxeTJk6lWrVr6Pp999hmDBw/Gzs4ONzc3GjZsyLJly4C0Tq9XXnmFY8eO8dNPP/H0008zZ84cNm/ezPDhw9m5cyceHh506tSJcePGkS9fPpo0acLGjRsz5LjbH3dCQkIoVaoUe/bsoXr16vf+iRERkWxFbQ2Srnr16sTExKR/8yySGwUEBFCmTBkqV67M2rVrKVOmDPPmzSMmJoZp06apGCYiWZqTkxODBg1K7x7buXMnPXv2JH/+/Kxfv56ePXtib29P6dKl1T0m983Z2RlnZ2d++umn9Bs+3EzXrl2JiIhg1apV7Nq1Cz8/P5o3b05kZCQAK1euZOjQoUDaaoV169ZRp06dDMeYOHEi1apVY8+ePYwaNYrg4GBat25N586d2bdvHwsXLmTz5s0MGDAAgKVLl1KsWDHGjh2b3uH1D5PJxJw5c+54fe3bt8fT05MGDRqwYsWKe/30iIhINqEOMUk3bdo0Bg0axOLFi+nSpYvRcUQemZiYGN5++23mzp1LXFwcFouFJ598kilTplCuXDmj44mIZIr4+Hi++eYbfvjhB/bu3avuMXkgS5YsoXfv3ly9ehU/Pz8aN27Mc889R9WqVQHYvHkzbdu2JSIiAgcHh/T3lS1blrfffps+ffpQr149SpcuzW+//UZqaioXL17McI6SJUtSo0aN9I4xgF69emFnZ8dXX32V/trmzZtp3LgxcXFxODo6UrJkSQYPHszgwYMzHK9ixYqMGzeOTp063fSaLl68yHfffUf9+vUxm80sWbKECRMm8NNPP9G+ffsH/ZSJiEgWow4xSffPYP2ff/7Z4CQij8b27dupX78+bm5ufPXVVzg6OjJy5Eji4uJYuXKlimEikqM4OTkxcOBAtm3bxtWrV9m1a9ctu8dee+01goKCjI4sWVjnzp0JCwtjxYoVtG7dmg0bNuDn55fegRUYGEhsbCwFCxZM7yhzdnbm5MmT6XdF3bt3L82bN6dSpUpERkbedLB+rVq1MjwPDAxkzpw5GY7ZqlUrrFYrJ0+evG3mI0eO3LIYBuDh4cEbb7zB448/Tu3atfn444958cUX+eSTT+7xsyMiItmBCmKSrnDhwjg6OvL3338bHUXkobFarUyePJmiRYvyxBNPsHXrVqpWrcqvv/7KxYsXef/997G3tzc6pojIQ+fn58fs2bM5c+YM8fHxTJs2jSeeeILw8HCmT59OxYoVcXZ2pmnTpsyePVt3rpQbODo60rJlS0aNGsXWrVvp2bMn7777LgCxsbF4e3uzd+/eDB9BQUG89dZbAOTNmxf4d7D+tm3bbjhHvnz5MjyPjY3l1VdfzXDMwMBAjh07RpkyZTL9Gh9//HGOHz+e6ccVERHjqSAmGfj4+BASEmJ0DJFMFx4eTrdu3XBycuKNN97g4sWLPPvss5w9e5a9e/fy1FNPGR1RRMQwefPmZcCAAWzdupX4+Hh2796Nv79/+uD0l19+GXt7e0qVKkX//v3VPSY3VblyZeLi4oC0gmt4eDgWi4WyZctm+PDw8ACgatWqrFu3Lr1ra/ny5Xc8h5+fH4cOHbrhmGXLlk3/hZa9vT2pqamZck179+7F29s7U44lIiJZiwpikkGdOnVISEggIiLC6CgimWLNmjXUqFEDb29v5s+fj7u7OxMnTuTq1assWLCAIkWKGB1RRCTLqVGjBt9++y2nT5/m6tWrfPHFF9StW5fz58/z5ZdfpnePNWnShG+++YakpCSjI8sjdOnSJZo1a8bcuXPZt28fJ0+eZPHixUyYMIEOHToA0KJFC+rWrUvHjh1Zu3YtISEhbN26lREjRrBz504A3n33XebPn8/y5csxmUysXbuW8ePH3/bcw4YNY+vWrQwYMIC9e/dy7Ngxli9fnj5UH9Jmj/3555+cPXs2w1yyihUrZphH9l8BAQHMnz+fI0eOcOTIET766CO+/fZbBg4c+CCfLhERyaJUEJMM/u///g+ARYsWGZxE5P4lJSUxevRoPDw8aN26NYGBgdStW5etW7cSFhbG0KFDMZv15U9E5G44OjrSv39/tmzZQnx8PHv37uXll1+mQIEC/Pnnn/Tq1St9kHm/fv04fPiw0ZHlIXN2dubxxx9n8uTJNGrUCF9fX0aNGkXv3r35/PPPgbQ7Ov766680atQIf39/ypcvz3PPPcepU6coXLgwAE2aNGHx4sWsWLECm83Gvn377ji6o2rVqmzcuJGjR4/SsGFDatSowejRozP8gmvs2LGEhIRQpkwZChUqlP56UFAQ0dHRtz3++++/T82aNXn88cdZvnw5CxcuxN/f/34/VSIikoXpLpOSQUJCAnnz5qVdu3Yari/ZTnBwMIMHD2b16tWkpKTg5OTECy+8wIQJE3BzczM6nohIjpOQkMC3337LvHnz2LNnD1evXgXS5j7VrFmTl156ie7du2s2o9xR48aN2bRpEykpKfqllYiIPBL610YycHR0xNXVlcDAQKOjiNy1hQsXUqFCBcqWLcsvv/xC8eLF+eabb4iNjeXrr79WMUxE5CH5b/dYYGAgr7zyCu7u7mzatInevXund4/17duXgwcPGh1ZsqgGDRpgs9nYvn270VFERCSXUIeY3KBWrVoEBgaSnJxsdBSRW4qLi+Odd95hzpw5xMTEYGdnR9OmTZk8eTK+vr5GxxMRyfUSEhKYM2cOc+fOZc+ePcTHxwPg5OREzZo1efHFF+nZs6e6xwSAnTt3Urt2bd5+++07zhETERHJDOoQkxs0bNiQlJQU/RZXsqS9e/fStGlTXF1dmTp1KmazmTfffJPY2Fh+++03FcNERLIIR0dH+vbty+bNm4mLi2Pfvn307t0bDw8PNm/ezKuvvoqjoyM+Pj706dOHAwcOGB1ZDOTn54fZbGbLli1GRxERkVxCHWJyg82bN9OwYUNGjx7Ne++9Z3QcEaxWK1999RUff/wxoaGhQNqt3T/44IP0W7WLiEj2kZiYSEBAAN9//z27d+/O0D3m5+fHiy++iL+/v7rHchlPT09sNhsXLlwwOoqIiOQCKojJDaxWKxaLhQYNGvDnn38aHUdysUuXLjF06FAWLVrE1atXyZMnD23btmXKlCn4+PgYHU9ERDLJgQMHmDZtGqtXr+b06dPYbDZMJhPFihWjVatWvP766+oAzgUaNWrE5s2bNVhfREQeCf1LIzcwm80UKlSIQ4cOGR1FcqmNGzdSp04dChUqREBAAC4uLnzwwQfEx8ezbNkyFcNERHIYX19fvvrqK06dOkVCQgJff/01DRo04NKlS8yaNYvHHnsMJycnGjRowJdffklCQoLRkeUh+Gew/o4dO4yOIiIiuYAKYnJTVapUITIyEqvVanQUySVSUlL46KOP8PLyokmTJuzcuZOaNWvyxx9/cP78eUaMGIHFYjE6poiIPGT29vb07t2bP//8k7i4OA4cOMCrr76Kp6cnW7dupX///jg5OVGiRAl69erFvn37jI4smeSfMQg//fSTsUFERCRXUEFMbqp58+bYbDbWr19vdBTJ4UJDQ+ncuTNOTk6MGDGC6OhounfvTkREBDt27KBp06ZGRxQREQNVqVKFGTNmEBISQkJCArNmzaJhw4ZERkbyzTffUK1aNZycnKhfvz7Tp09X91g2VrNmTUwmE5s3bzY6ioiI5AKaISY3FRwcTNmyZenfvz9ffPGF0XEkB1q+fDkjRoxIv5tp8eLF+d///kffvn01N0RERO7K4cOHmTp1KqtXr+bUqVPps8eKFi1Ky5YtGTRoENWrVzc6ptwDT09PACIiIgxOIiIiOZ0KYnJL9vb2VKlShT179hgdRXKIhIQERo8ezcyZM4mKisJsNtOwYUM+/fRT/Pz8jI4nIiLZWFJSEnPnzuW7775j586dxMXFAZA3b16qV69Ot27d6NWrF46OjgYnldtp2LAhW7Zs0WB9ERF56PSvjNxS0aJFOX78uNExJAc4dOgQrVq1wtnZmU8++YTU1FQGDBhAdHQ0GzZsUDFMREQemL29PS+//DIbNmwgNjaWQ4cO0a9fPwoXLsxff/3FwIEDyZs3L8WLF+fll1/WL/yyqH8G6+/atcvoKCIiksOpICa3VKNGDWJjY4mNjTU6imRTAQEBlClThipVqrB27VrKlCnDvHnziImJYdq0aTg7OxsdUUREcqhKlSoxffp0Tp48SWJiIt9++y1NmjTh8uXLzJ49Gz8/P/LmzUu9evX4/PPPNXssi+jYsSMAy5YtMzaIiIjkeCqIyS099dRTgO70I/cmOjqavn374uzsTM+ePQkNDaVt27YcPXqUoKAgunXrZnREERHJZfLkyYO/vz/r168nNjaWI0eO0L9/f7y9vTN0jxUrVgx/f392795tdORcq3bt2hqsLyIij4RmiMktRUVFUaBAAZ577jnmz59vdBzJ4rZv384bb7zBtm3bsNlsFCxYkP79+zNy5Ejs7e2NjiciInJTKSkpzJs3j4CAAHbs2JHeGe/o6Jg+e+yVV17BycnJ4KS5R6FChTCZTBqsLyIiD5UKYnJb+fLlw9vbW7PE5KasVitTpkxh0qRJhIWFAVCtWjXGjRuX3mEoIiKSnRw9epSpU6eyatUqTp48yT/fKhctWpQWLVowYMAAatWqZXDKnK1BgwZs27aN5ORkDdYXEZGHRv/C5FAXLlygX79+lChRAgcHB7y8vGjVqhVbtmy5p+OUKlWK06dPZ2q2kiVLMmXKlHt+X0hICCaT6YaPv/76K1PzyZ2Fh4fz/PPP4+TkxNChQ7l48SLPPvssZ8+eZe/evSqGiYhItlW+fHk+//xzgoODSUpKIiAggKZNmxIdHU1AQAC1a9cmb968PPHEE3z22WfEx8cbHTnHqV+/PlarVUtXRUTkoVJBLIfq3Lkze/bsISAggKNHj7JixQqaNGnCpUuX7uk4TzzxBElJSXdVFEtKSrrfuPfk999/59y5c+kfNWvWfCTnFVizZg01atTA29ubBQsWULBgQSZOnMjVq1dZsGABRYoUMTqiiIhIprFYLHTv3p0//viDK1eucOzYMQYMGECRIkX4+++/GTx4MPny5aNo0aL06NGDHTt2GB05R9BgfREReRRUEMuBoqKi2LRpE+PHj6dp06b4+PhQp04dhg8fTvv27TPs16tXLwoVKoSrqyvNmjUjMDAww7G8vb0BKF26NB4eHnTq1Cl9W8mSJXn//ffp3r07rq6u9OnTB4DNmzfTsGHD9FubDxo0iLi4OACaNGnCqVOnGDJkSHqH170qWLAgXl5e6R958uS552PI3UtKSmL06NF4eHjQunVrAgMDqVevHlu3buXs2bMMHTpUyxlERCRXKFu2LNOmTUvvHvvuu+9o1qwZV65c4bvvvqNOnTrkzZuXxx9/nClTpqh77D49/vjjGqwvIiIPnX6KzYGcnZ1xdnbmp59+IjEx8Zb7de3alYiICFatWsWuXbvw8/OjefPmREZGArBy5UrGjRsHpH1jsm7dOurUqZPhGBMnTqRatWrs2bOHUaNGERwcTOvWrencuTP79u1j4cKFbN68mQEDBgCwdOlSihUrxtixY9M7vP5hMpmYM2fOHa+vffv2eHp60qBBA1asWHGvnx65S8HBwbRr1458+fLx/vvvc/XqVfr06UNkZCRbtmyhbt26RkcUERExjMVi4aWXXmLdunXExMRw/PhxBg0aRNGiRdm5cydDhgwhX758FClShO7du6t77B6YzWbc3d05cuSI0VFERCQH01D9HGrJkiX07t2bq1ev4ufnR+PGjXnuueeoWrUqkNbF1bZtWyIiInBwcEh/X9myZXn77bfp06cP9erVo3Tp0vz66684OjqmD03/R8mSJalRo0aGdvZevXphZ2fHV199lf7a5s2bady4MXFxcTg6OlKyZEkGDx7M4MGDMxyvYsWKjBs3LkMX2vUuXrzId999R/369TGbzSxZsoQJEybw008/Zeh8kwezcOFCRo8ezdGjR4G07sCRI0fi7+9vcDIREZHsISUlhYULFzJ79mz+/vtvrly5AoCDgwNVq1blueeeo0+fPjg7OxucNOuqX78+f/31F6mpqUZHERGRHEodYjlU586dCQsLY8WKFbRu3ZoNGzbg5+eX3oEVGBhIbGwsBQsWTO8oc3Z25uTJkwQHBwOwd+9emjdvTsWKFTl//vxNz/PfuywFBgYyZ86cDMds1aoVVquVkydP3jbzkSNHblkMA/Dw8OCNN97g8ccfp3bt2nz88ce8+OKLfPLJJ/fwmZGbiY2NZdCgQbi6uvLcc88RHBxMy5YtOXDgAMHBwSqGiYiI3AOLxcILL7zA77//TkxMDMHBwbz++usUK1aMXbt2MXToUFxcXChSpAgvvvgi27dvNzpylqPB+iIi8rCpIJaDOTo60rJlS0aNGsXWrVvp2bMn7777LpBWAPH29mbv3r0ZPoKCgnjrrbcAyJs3LwCNGjXCarWyc+fOG86RL1++DM9jY2N59dVXMxwzMDCQY8eOUaZMmUy/xscff5zjx49n+nFzi71799K0aVPy58/PtGnTsLOz46233iI2Npa1a9dSpUoVoyOKiIhke6VLl2bKlCkcP36cxMRE5s2bR4sWLYiLi2PevHk88cQTODo6Urt2bSZNmkRsbKzRkQ3XoUMHQIP1RUTk4VFBLBepXLly+nB7Pz8/wsPDsVgslC1bNsOHh4cHAFWrVmXdunV07doVgMWLF9/xHH5+fhw6dOiGY5YtWxZ7e3sA7O3tM639fe/evemD/+XuWK1WvvzyS3x8fKhRowYbNmygYsWKLFu2jMuXLzNhwgQcHR2NjikiIpIjWSwWunXrxm+//UZ0dDQnTpxg8ODBFC9enN27d/Pmm2/i4uKCt7c3L7zwAtu2bTM6siHq1q2LyWRi06ZNWK1WQkNDtXxSREQylQpiOdClS5do1qwZc+fOZd++fZw8eZLFixczYcKE9N+2tWjRgrp169KxY0fWrl1LSEgIW7duZcSIEemdYO+++y7z589nxYoVmEwmVq9ezfjx42977mHDhrF161YGDBjA3r17OXbsGMuXL08fqg9ps8f+/PNPzp49y8WLF9Nf/6cocysBAQHMnz+fI0eOcOTIET766CO+/fZbBg4c+CCfrlzj4sWL9OzZE2dnZ/r378+5c+fo1KkTISEhHDx4MP0W5yIiIvLolCpVismTJ3Ps2DGSkpKYP38+Tz75JPHx8fzwww/Uq1cPR0dHatWqxSeffEJMTIzRkR+64OBgFi5ciIODA1u3biV//vz4+Pjw5ZdfGh1NRERyEIvRASTzOTs78/jjjzN58mSCg4NJTk6mePHi9O7dm3feeQdIu6Pjr7/+yogRI/D39+fChQt4eXnRqFEjChcuDECTJk1YvHgx77//Pjabjf379/P333/f9txVq1Zl48aNjBgxgoYNG2Kz2ShTpgzPPvts+j5jx47l1VdfpUyZMiQmJvLPfR2CgoKIjo6+7fHff/99Tp06hcVioWLFiixcuJAuXbo8yKcrx9uwYQNvvfUWu3btwmaz4enpyYgRIxg2bBgWi74EiIiIZBV2dnY899xzPPfccwCcOnWKqVOn8vPPP7Nnzx527drF22+/jZeXF02bNuW1116jfv36BqfOXPv27aNatWoZXktOTgagQoUKRkQSEZEcSneZlLvy1FNPsXr1apKTk1VEyQZSUlIYP34806ZN4/z585hMJmrWrMknn3xCkyZNjI4nIiIi98hqtbJ48WJmz57Ntm3b0jvF7O3teeyxx3jmmWfo27cvrq6uBid9MElJSTRo0IDdu3dnWCJpb29PVFRU+oxbERGRB6Ulk3JXWrRoAcCqVasMTiK3ExoaytNPP42TkxMjR44kOjqaHj16EBERwY4dO1QMExERyabMZjPPPvssq1evJjo6mpCQEN544w1KlizJnj17GDZsGPnz58fLy4vnn3+ezZs3Gx35vtjb27N06VJcXV0xmUzprzds2FDFMBERyVQqiMldeeaZZwBYvny5wUnkZpYvX06VKlXw8fFh2bJleHt788UXXxAXF8ecOXPSb5QgIiIiOYOPjw+TJk0iKCiI5ORkFi1aRKtWrUhISGDBggU0bNgQBwcHatasyccff5ytZo8VK1aMH3/8kesXsjz11FMGJhIRkZxISyblrjk4OFCuXDkOHDhgdBQBEhISGD16NDNnziQqKgqz2UzDhg2ZPHkyNWrUMDqeiIiIGCQ0NJRp06axYsUKjh8/jtVqBcDT05OmTZvSv39/GjVqZHDKO/v4448ZPnw4kDZb7LHHHjM4kYiI5CQqiMldK1u2LOfOnSMuLs7oKLnawYMHGTJkCH/88Qepqam4uLjg7+/Phx9+iLOzs9HxREREJAuxWq0sXbqUb775hm3btqXfwMje3p4qVarQtWtX+vfvT/78+Q1OeiOr1YqnpyeXLl3CarVmWEIpIiLyoFQQk7v2/PPPs2DBAi5fvoybm5vRcXKdOXPm8P7773PixAkAypcvz5gxY3j++ecNTiYiIiLZxenTp9O7x44dO5ahe6xJkyb079+fxo0bG5wyzYnLJxg9fzTz1s/Dp54PcSlxmE1miroUpU7ROtQtVpfOlTvjbK9fCIqIyL1TQUzu2rx583jxxRf5+uuv6d27t9FxcoWoqCiGDRvGvHnziIuLw2Kx0KpVKz777DPKlCljdDwRERHJxqxWK8uWLUvvHouKigIgT548GbrHHvUvQref2c6YDWNYE7wGk8mEzWrDZsr4I0secx6Srck45XHilRqvMLrxaDycNDNVRETungpictfi4uJwdnamU6dOLF261Og4Odr27dt544032LZtGzabjYIFC9K/f39GjhyJvb290fFEREQkBzpz5gzTpk1j+fLlHD9+nNTUVAAKFSpEkyZN6NevH02bNn1o509ISWD0+tFM3DoRs8lMqi31rt5nZ7LD1cGVmf83k86VOz+0fCIikrOoICb3xMXFhYIFCxISEmJ0lBzHarUyZcoUJk2aRFhYGADVq1dn3LhxtG7d2uB0IiIikptYrVaWL1/OrFmz2Lp16w3dY126dOG1117LtO6x6IRonpr3FNvPbsdqs97z+02YsGFjTOMxjG48WvPGRETkjlQQk3tSo0YNDh48SFJSktFRcozw8HCGDBnCsmXLSExMxMHBgU6dOjFp0iSKFClidDwRERERzp49m949duzYsQzdY40bN6Zfv340a9bspu/9/fffmTt3LlOnTsXV1fWG7QkpCTQLaMbfZ/++666w2xnXfBz/a/C/Bz6OiIjkbGajA0j2Uq9ePZKTkwkODjY6Sra3evVqqlevjre3NwsWLKBgwYJMmjSJ+Ph45s+fr2KYiIiIZBlFixbl448/5vDhwyQlJbFs2TLatm1LcnIyP/74I82bN8fe3p7q1avzwQcfEBkZmf7eTz/9lICAABo2bEhERMQNxx6zYQzbz27PlGIYwDvr3mHb6W2ZciwREcm51CEm92TdunW0aNGCDz74gBEjRhgdJ9tJSkrigw8+YPr06Vy6dAmTyUTdunWZOHEidevWNTqeiIiIyD0LCwtL7x47evRohu6x+vXrs3LlSpKTk7Gzs6N48eKsX7+ekiVLArDj7A7qvFAHNv7noCYgL1AYqA5U+8/2S8AG4ASQALgClYGGYJfXjpJuJTnQ/wCOFseHcs0iIpL9qSAm98RqtWKxWGjSpAl//PGH0XGyjeDgYF5//XXWrFlDSkoK+fLl48UXX+Tjjz9+5HduEhEREXlYrFYrv/zyCzNnzmTLli1cvnw5w3aTyUTBggX5448/eOyxx/i/+f/Hyq9XYttwhx9JWgL1rz0OB2YDiTfZzwvwBxwgoGMA3at1f9BLEhGRHEoFMblnhQoVwmw2c/78eaOjZHkLFizg3Xff5ejRowCULl2akSNH4u/vb3AyERERkYevT58+fPPNN1itNw7K79a/G/M952Nbb/u3Q6ws0BBIBf4Gjlx7PT8w5NrjGaQVxQBqAuWAbcCpa6/VA3MrMzW8arCzz85MvyYREckZNENM7lmlSpW4cOHCTb+xEYiNjWXQoEG4urry/PPPExwczJNPPsmBAwcIDg5WMUxERERyjXXr1qWvMLj+zo9ms5n5e+Zzw+/m8wE+QGng+hn9sdf+PMO/xTAPoB1QEehy3b67wZpiZde5XZyOPp2ZlyMiIjmICmJyz5o2bYrNZmPr1q1GR8lSdu/eTZMmTcifPz/Tpk3Dzs6Ot956i9jYWNasWUOVKlWMjigiIiLySBUuXBg/Pz9efvllvvjiC7Zt20ZsbCypqak8O/hZ7Mx2N39jCv92hwF4Xvsz9LrXipE2awzABXC79jgBuDa7f9e5XZlxGSIikgNZjA4g2c+zzz7L2LFjWbJkCQ0aNDA6jqGsViszZsxg/PjxhIamfYdWpUoVPvzwQzp06GBwOhERERFj3e4XqIEXAm+8s2TgtY/rOQFPXXscdd3rzv/ZL99126PAUtRCYHggHSt2vIfEIiKSW6ggJvescuXKWCwWNm3aZHQUw1y8eJE333yTRYsWcfXqVfLkycPTTz/N5MmTKVGihNHxRERERLK86ITou9sxD5B07XHyda//t7ns+udJYMJETGLMfecTEZGcTUsm5b54e3tz7Ngxo2M8chs2bKB27dp4enoSEBCAq6srH330EfHx8SxZskTFMBEREZG7ZDbf5EeRsqTdJbIH0PTaa9HAAuAKacWxf6T8573XN5vZp/1xyyWZIiKS66kgJvelevXqxMTEkJCQYHSUhy4lJYUPP/yQwoUL07RpU3bt2kWtWrXYuHEj4eHhDB8+HItFzZYiIiIi96KE601+kfjPUP1SQGPSCmSQVvwK4t85YQBx/3lv7HWP3SDVlkoRlyKZE1ZERHIcFcTkvrRq1QqAFStWGJzk4QkNDeXpp5/GycmJkSNHcuXKFXr27ElERAR///03jRo1MjqiiIiISLZVu2ht8pjz3H6n629CeRW4voZ2+rrtMaR1kgE4Ap5gtVmp6V0zc8KKiEiOo4KY3JeuXbsC8MsvvxicJPMtX76cKlWq4OPjw7Jly/D29mb69OnExsYye/ZsPDw8jI4oIiIiku3VK16PZGtyxhfjgFPASeBP4MR12wqSdmdJr2vPLwE/k3Y3yiXX7ecH2EEecx5qeNd4KNlFRCT70zovuS+enp44Ojry999/Gx0lUyQkJDB69GhmzpxJVFQUZrOZJk2aMHnyZKpXr250PBEREZEcp32F9uR3yE801w3XP37t47+8gQrXHncA5gCJwO5rH//wAhqDHXZ0LNsRZ/v/3opSREQkjclms9nuvJvIjSpVqsTJkyf54Ycf+Pvvv3n88cfp1KmT0bHuycGDBxkyZAh//PEHqampuLq60rNnTz788EOcnfUNlIiIiMjD9L/f/8eEDydg23CTH0ksgDtphbD6pC2F/MclYANpHWQJgAtQBWj4736mWSaco52pUqUKzs7O2NnZYTabMZlMPPnkk7z++usP7bpERCTrU0FM7onNZmPWrFn88ssvrFmzhsTExPRtzzzzDAsXLjQw3d2bPXs2H3zwASdOpPXhV6hQgffee49nn33W4GQiIiIiuUdUQhQVP6/IhfgLWG3WTDmmncmOrhW6EvheIIcPH77pPl27dmXRokWZcj4REcmeVBCTe2Kz2ShSpAjh4eEZXjeZTEyfPp2+ffsalOzOoqKiePvtt/nhhx+Ii4vDYrHQunVrpkyZQpkyZYyOJyIiIpIrrTq2ijY/tMmUY9mZ7CjoVJAjrx3BJY8LtWrVIjAw8Ib9AgMDqVq1aqacU0REsicN1Zd7YjKZWLBgAWZzxr86NpuNZs2aGZTq9rZv3069evVwd3dn5syZODo6MmrUKOLi4vj5559VDBMREREx0FPlnmJiy4kPfBw7kx158+Rl9QurKZC3ABaLhZ9//pn8+fNjMpky7Dt48GBCQ0Mf+JwiIpJ9qSAm96xx48Z8+umnGV4rXLgw5cqVMyjRjaxWK59++ilFixbliSeeYNu2bVSrVo3Vq1dz8eJFxo4di729vdExRURERAQYWm8o056ahp3JDjuT3T2/385kh4eTB5v8N2W4s2Tx4sX57rvv+GdRjMlkomLFiqxfv56SJUvy5JNPEhYWlmnXISIi2YcKYnJfBg0aRLdu3dKft27d+obfvBkhPDyc559/HicnJ4YOHcqlS5d4/vnnOXfuHHv27KFVq1ZGRxQRERGRmxhQZwA7++ykokdFgLsqjP2zz1NFnuLIgCNU96p+wz7t27dPH6D/7LPPcvjwYXbu3Imvry+//fYbxYoVo02bNkRERGTexYiISJangpjcF5PJxMyZM/Hw8AAwvDts1apVVK9eHW9vbxYsWICHhweTJ08mPj6eH374AS8vL0PziYiIiMidVfeqzp5X97CoyyLql6if/rqdyY485jzkMefBRNovYR3sHHip6kvkX5CfP17/g6uXr97yuBMmTODdd99lwoQJANSsWZN9+/bx119/UalSJVatWoWXlxft27fn4sWLD/ciRUQkS9BQfXkga9asoXW71oz8fCS+9X1JtibjbO9MlUJVKONeBrPp4dVck5KSeP/99/nyyy+5dOkSJpOJevXqMWnSJB5//PGHdl4REREReTQi4iLYfW43geGBRCVEYWe2w9vZm5pFalKtcDXy5slLrVq12LVrF05OTixatIi2bdve83k2b95Mr169CAoKwmw206FDB7799lvc3Nwy/6JERCRLUEFM7kt8cjwLDixg+o7p7Dq766a9hs72zrSv0J7Xar9G3WJ1M21J5fHjxxk8eDBr1qwhJSWFfPny8eKLLzJhwgRcXV0z5RwiIiIikj28+eabTJo0Kf35wIEDmTBhAo6Ojvd8rD/++INXX32V48ePYzab6dKlCzNnztT3mCIiOZCWTMo9sdlszN8/n2KfFuOVFa+wJ3zPLf8WxSbFsujgIup/W59GcxpxPPL4HY8fFBREVFTUTbfNnz+fChUqUK5cOVauXEmJEiX49ttviY2NZcaMGfpGRURERCQXsre3z3AH9C+++IJatWpx+PDhez5Ws2bNOHbsGGvWrMHHx4dFixbh7u7Oiy++SGxsbGbGFhERg6kgJnctLimOpxc9Tbel3YhKiALAarPe9j0p1hQA/jrzF77Tffl2z7e33Hf79u1UrVqVnj17pr8WGxvLoEGDcHV1pVu3bgQHB/Pkk09y6NAhgoOD8ff3f+DrEhEREZHsy2KxYGf37wB+q9XKwYMHGTJkyH0f88knn+TEiRP8/PPPFC1alHnz5uHm5oa/vz/x8fGZEVtERAymgpjcldikWFp834Kfg34GwMa9rbRNsaaQmJrIKyteYcpfU27YHhISQps2bUhKSmLFihX8+uuvNGnShPz58zNt2jQsFgtvv/02sbGxrFmzhkqVKmXGZYmIiIhINmexWPjvFJgePXrw9ddfP/Cx27Vrx6lTp1i6dCleXl7MmTOH/Pnz06dPHxISEh74+CIiYhzNEJM7stlsdFjQgV+P/UqqLTVTjrns2WV0rNgRgOjoaOrUqUNwcDCpqRmP7+vrywcffECHDh0y5bwiIiIikrOMGzeOd955B0hbPmmz2YiJibmvGWJ3smjRIgYPHsy5c+fIkycPvXv3ZvLkydjb22f6uURE5OFSQUzu6PvA7+n+U/e0J0nALuAwcOHacxegEOALVAGuAoHASeASEEtaL6InUBNMNUwUyFuAoAFB5M+Tn+bNm7N58+YMv9nLkycPBw8epFy5co/oKkVEREQkO9qxYweff/45gwcP5tChQ7z44ou8/PLLfPPNNw/tnPPmzWPo0KGcP38ee3t7+vXrx8SJE7FYLA/tnCIikrlUEJPbupJ4hWKTi3El8Qq2CBvMBy7f5g2vAheBJbfZ53Gwa2NHlzJd2PbONkJDQ2+625w5c+jRo8f9hxcRERGRXKdYsWKEh4cTGRn50G+6NHv2bN5++20uXryIg4MDAwcOZNy4cSqMiYhkA5ohJrc1b/+8tGJYvA3m8W8xzAVoBXQHngWeAByue6MFqAE8A3QDrm/02g6pl1JZeGQhZyPP4ujoSMGCBcmXL1+Gc//5558P56JEREREJMeaMWMGqampvPLKKw/9XP7+/ly4cIGvvvqKfPnyMXHiRFxcXHjnnXewWm9/8ykRETGWOsTkth6b/hgHLxzE9rsNNl970QF4DfjvL9z+WRoZB9gD+a/blgJMvrYNoAuYfE2Mbzaetxq+lb5bamoqMTExXL58maJFi+LgcH2VTURERETkzsqWLcvJkyc5d+4cnp6ej+y8n3/+OaNGjSIqKgonJyfeeustRo8ejdmsPgQRkaxGX5nllqITojlw4UDaHSUPXrehLjcWwwCcASfS5onl/882y39esweTycS2sG0ZdrOzs6NAgQKULl1axTARERERuS/ffvstVqv1kY/fGDBgAJcvX2bSpElYLBbee+89XF1d+fDDD9UxJiKSxaggJre0+9zutAeJZJwbVuI+DnYZCL/22D7tGFable1ntz9IRBERERGRGzRq1AhfX1/WrFnDqVOnHvn533jjDS5fvsz48eMxmUyMHDkSNzc3PvnkExXGRESyCBXE5JZOXD6R9iDxPxtc7vFA8cAC4J9/+5sD1+6CHXYljFRr6v1GFBERERG5qe+//x6bzcaLL75oyPnNZjNvv/020dHRvP/++1itVt5++23c3d357LPPDMkkIiL/UkFMbinZmpz24L8rF6/cw0GuALOB89ee1wUez7hLijXlfuKJiIiIiNxS9erVqVOnDps3b+bgwYN3fsNDYjabGTlyJDExMYwaNYqkpCQGDx6Mu7s706dPNyyXiEhup4KY3FK+PNfu+ugAFLhuw+m7PEAU8C1w4drzBqTdmfI6ZpMZezv7+w8pIiIiInILc+fOBaB79+4GJ0krjI0dO5bY2Fj+97//cfXqVV577TU8PDyYNWuW0fFERHIdFcTklqp4VrnuyXUbtgExN3lDLGnLIwEuklYM+2f2WHOgxY1vqVCwAiaT6YGzioiIiIj8V7ly5WjatCm7d+9mx44dRscB0gpj48aN48qVK7zxxhvExsbSu3dvPD09+e6774yOJyKSa6ggJrfk6+mLxWxJe1KPf+8SmQDMAv4CTgBHgNXANCCatGLYbP4tmj1G2iD+U9d9xILFbOGJYk88iksRERERkVzq+++/x2QyZYkusetZLBYmTZpETEwMAwcOJDo6mh49euDl5cX8+fONjicikuOpICa3ZG9nT8vSLbEz2YET8AL/Lp2MIa0I9h1pA/P/4t/h+6eBuOsOtJ+0Atn1H8fSZoe1Ldf24V+IiIiIiORaRYsWpV27dhw5coR169YZHecG9vb2TJ06lStXrtC3b18iIyPp1q0bRYsWZcmSJUbHExHJsUw2m81mdAjJun499ittf7iuaJUE7AIOkzYbLAnIBxQirRPMl7QC2PI7HLgDeDbw5MyQM+Sxy/MQkouIiIiIpImMjKRQoUKUKFGCkydPGh3nthISEhgwYAABAQGkpKRQrFgxvvjiC9q3b290NBGRHEUFMbmtVGsqVWdUJehiEKm21Ew99qQnJ/FG3Tcy9ZgiIiIiIjfzwgsv8MMPP/Djjz/SuXNno+PcUXx8PP369WPevHmkpqbi4+PDl19+yVNPPWV0NBGRHEEFMbmjPef2UGtmLaw2a6Ycz85kRw2vGvzV6y/szHaZckwRERERkduJi4vDzc0NDw8Pzp07Z3ScuxYbG0ufPn1YtGgRqamplC5dmq+//prmzZsbHU1EJFvTDDG5oxreNRjXfFymHMvOZIdTHifmPj1XxTAREREReWTy5ctHr169CA8P59tvvzU6zl1zdnbmhx9+4NKlS3Tt2pWQkBBatGhB+fLl2bhxo9HxRESyLXWIyV2x2WyM/GMkH23+6L6P8U8x7Pfuv1OnaJ1MTCciIiIicmdJSUm4urqSL18+Ll26ZHSc+xIZGUmvXr1Yvnw5VquVihUrMmvWLOrXr290NBGRbEUdYnJXTCYTHzb/kFn/NwunPE5YzJZ7ez8mqhauyvZe21UMExERERFD2NvbM3jwYCIjI/n000+NjnNf3N3dWbp0KefPn6ddu3YEBQXRoEEDfH192bFjh9HxRESyDXWIyT0LjQ5lyJoh/HTkJ0yYsNqs2Ljxr5GdyY5UWyoFHAswrP4whtYbes+FNBERERGRzGS1WnFxccFsNhMdHY3ZnL17BMLDw/H392fNmjXYbDaqVq1KQEAA1atXNzqaiEiWpoKY3LczMWeYvWc2G09tZMfZHcQkxaRvK+lWkieKPsH/Vfg/OlfqjIPFwcCkIiIiIiL/GjduHO+88w6jRo1i7NixRsfJFGfOnMHf359169Zhs9nw8/MjICAAX19fo6OJiGRJKohJprDZbFxJukKKNQWnPE44WhyNjiQiIiIiclNWqxV3d3cSExO5cuUKFkvOWcUQGhpKjx492LBhAwC1a9cmICCASpUqGRtMRCSLyd79wZJlmEwmXB1ccc/rrmKYiIiIiGRpZrOZcePGkZCQwNChQ42Ok6lKlCjB+vXrOXHiBA0aNGDHjh1UrlyZevXqcezYMaPjiYhkGeoQExERERGRXMnT05OoqChiYmJwdMyZv9Q9evQoPXr04K+//gKgYcOGBAQEUKpUKYOTiYgYSx1iIiIiIiKSK02dOpXk5GT69u1rdJSHpnz58mzbto0DBw5Qq1YtNm3aROnSpWnWrBmhoaFGxxMRMYw6xEREREREJNcqUaIEYWFhREZG4urqanSch27fvn307NmTPXv2YDKZaNGiBXPmzKFIkSJGRxMReaTUISYiIiIiIrnWV199RWpqKv7+/kZHeSSqVq3K7t272bVrF76+vvz2228UK1aMNm3aEBERYXQ8EZFHRh1iIiIiIiKSq5UvX57jx48THh6Op6en0XEeqe3bt/Pyyy9z6NAhTCYT//d//8c333yDh4eH0dFERB4qdYiJiIiIiEiuNnv2bGw2Gy+99JLRUR65xx9/nIMHD7Jp0ybKly/PihUrKFy4ME8//TRRUVFGxxMReWjUISYiIiIiIrletWrV2L9/PydOnKBkyZJGxzHMhg0b6N27N8ePH8dsNtO5c2dmzZqVK+ariUjuog4xERERERHJ9b7//ntsNhsvvPCC0VEM1aRJE44dO8batWvx8fFh8eLFuLu788ILLxAbG2t0PBGRTKOCmIiIiIiI5HpVq1bliSeeYOvWrRw4cMDoOIZr2bIlJ06cYOXKlRQrVowffvgBNzc3evbsSXx8vNHxREQemJZMioiIiIiIAMHBwZQtW5bq1auzZ88eo+NkKcuXL2fAgAGcOXMGi8WCv78/U6dOxdHR0ehoIiL3RR1iIiIiIiIiQJkyZWjevDl79+5l27ZtRsfJUjp06MDp06dZvHgxhQoVYubMmbi6uvLaa6+RlJRkdDwRkXumDjEREREREZFrwsLCKFasGOXLl+fIkSNGx8my5s2bx9ChQzl//jz29vb07duXSZMmYbFYjI4mInJX1CEmIiIiIiJyTZEiRWjfvj1BQUGsXbvW6DhZ1gsvvEB4eDizZ88mf/78TJ06FWdnZ9566y1SUlKMjicickfqEBMREREREblOVFQUHh4eFC1alFOnThkdJ1v4+uuvGT58OJGRkTg6OjJkyBA++OADzGb1YIhI1qSvTiIiIiIiItdxc3OjW7duhIaGsmjRIqPjZAt9+vTh0qVLTJs2DUdHR8aNG4eLiwtjxozBarUaHU9E5AbqEBMREREREfmP+Ph48ufPT8GCBQkPDzc6TrYzefJkxowZQ0xMDPny5WP48OEMHz5cHWMikmXoq5GIiIiIiMh/ODk50adPH86fP8+sWbOMjpPtDBkyhMuXLzN+/HhMJhMjR47Ezc2NTz75RB1jIpIlqENMRERERETkJlJSUnBxcSFv3rxERkYaHSfbslqtfPTRR3z88cfExcWRP39+3nvvPV5//XWjo4lILqYOMRERERERkZuwWCzpnU6ffPKJ0XGyLbPZzMiRI4mJiWHUqFEkJSUxePBg3N3dmT59utHxRCSXUoeYiIiIiIjILVitVlxdXQGIiYnRDKxMYLVaGTFiBFOmTCEhIYGCBQvy8ccf06tXL6OjiUguoq/mIiIiIiIit2A2mxk9ejRxcXGMGjXK6Dg5gtlsZty4cVy5coWhQ4cSGxtL79698fT0JCAgwOh4IpJLqENMRERERETkNmw2G+7u7ly9epXY2FgsFovRkXKUlJQUhg4dyowZM0hKSqJw4cJMnjyZ559/3uhoIpKDqUNMRERERETkNkwmE+PHjycxMZHBgwcbHSfHsVgsfPbZZ1y5coV+/foRGRlJt27dKFq0KEuWLDE6nojkUOoQExERERERuQteXl5ERkYSFRWFk5OT0XFyrISEBAYOHMicOXNISUmhWLFifPHFF7Rv397oaCKSg6hDTERERERE5C5MnTqV5ORk+vbta3SUHM3R0ZGZM2cSHR1Njx49OHfuHB06dKBkyZKsWrXK6HgikkOoQ0xEREREROQu+fj4cPbsWS5evIibm5vRcXKF2NhYXn31VRYuXEhqaiqlS5fm66+/pnnz5kZHE5FsTB1iIiIiIiIid+nrr78mNTUVf39/o6PkGs7OzsybN4/IyEi6du1KSEgILVq0oHz58mzcuNHoeCKSTalDTERERERE5B5UqFCBY8eOcfbsWby9vY2Ok+tERkbSq1cvli9fjtVqpWLFinzzzTfUq1fP6Ggiko2oQ0xEREREROQezJkzB5vNxksvvWR0lFzJ3d2dpUuXcv78edq1a0dQUBD169fH19eXHTt2GB1PRLIJdYiJiIiIiIjcoxo1arB3716OHz9OmTJljI6Tq4WHh+Pv78+aNWuw2WxUrVqVOXPmUKNGDaOjiUgWpg4xERERERGRe/T9998D8OKLLxqcRLy8vFi1ahWhoaG0aNGC/fv34+fnR82aNTlw4IDR8UQki1JBTERERERE5B75+vpSr149/vrrL/bt22d0HAGKFSvGb7/9RkhICE2aNGH37t089thj1KlTh8OHDxsdT0SyGC2ZFBERERERuQ8nT56kdOnSVK1alcDAQKPjyH+cPHmS7t27s3nzZgDq1q1LQEAA5cqVMziZiGQF6hATERERERG5D6VKlaJly5bs27ePLVu2GB1H/qNUqVJs2rSJo0ePUrduXbZt20b58uVp2LAhJ0+eNDqeiBhMHWIiIiIiIiL3KTw8nCJFilC2bFmOHj1qdBy5jcOHD9OjR4/0O1E2bdqUOXPmUKJECYOTiYgR1CEmIiIiIiJyn7y8vOjYsSPHjh1j1apVRseR26hUqRJ///03gYGB1KhRg/Xr11OyZEmefPJJwsLCjI4nIo+YOsREREREREQeQFRUFB4eHhQpUoTQ0FCj48hd2r17N/7+/uzbtw+TyUTr1q2ZPXs2hQsXNjqaiDwC6hATERERERF5AG5ubrz44oucPn2aBQsWGB1H7pKfnx+BgYH89ddfVK5cmVWrVuHt7U379u25ePGi0fFE5CFTh5iIiIiIiMgDSkhIwNXVlQIFCnD+/Hmj48h92LJlC7169eLIkSOYzWY6dOjAt99+i5ubm9HRROQhUIeYiIiIiIjIA3J0dKRv375EREQwY8YMo+PIfahfvz6HDx9m/fr1lClThmXLllGwYEGeffZZYmJijI4nIplMHWIiIiIiIiKZICUlBRcXFxwcHIiMjMRsVv9Bdvbbb7/Rt29fTpw4gZ2dHc899xwzZszA2dnZ6Ggikgn0FVpERERERCQTWCwW3nzzTaKjo5kwYYLRceQBtWzZkuDgYFauXEmxYsWYN28ebm5u+Pv7Ex8fb3Q8EXlA6hATERERERHJJFarlfz582O1Wrly5Yq6xHKQ5cuXM2DAAM6cOYPFYsHf35+pU6fi6OhodDQRuQ/66iwiIiIiIpJJzGYz7733HvHx8bzzzjtGx5FM1KFDB06fPs3ixYspVKgQM2fOxNXVlddee42kpCSj44nIPVKHmIiIiIiISCZzd3cnPj6emJgY7O3tjY4jD8G8efMYOnQo58+fx97enn79+jFx4kQsFovR0UTkLqhDTEREREREJJN98sknJCYm8vrrrxsdRR6SF154gfDwcObMmUP+/Pn57LPPcHZ25q233iIlJcXoeCJyB+oQExEREREReQi8vb25ePEi0dHRODk5GR1HHrKvv/6a4cOHExkZiaOjI0OGDOGDDz7QHDmRLEr/Z4qIiIiIiDwEn3/+OSkpKfTu3dvoKPII9OnTh0uXLjFt2jQcHR0ZN24cLi4ujBkzBqvVanQ8EfkPdYiJiIiIiIg8JCVLluT06dNcuHABd3d3o+PIIzR58mTGjBlDTEwM+fLlY/jw4QwfPlwdYyJZhP5PFBEREREReUi++eYbrFYr/v7+RkeRR2zIkCFcvnyZ8ePHYzKZGDlyJG5ubnzyySfqGBPJAtQhJiIiIiIi8hBVqlSJoKAgTp8+TdGiRY2OIwawWq189NFHfPzxx8TFxZE/f37ee+893XRBxEDqEBMREREREXmI5syZg81m46WXXjI6ihjEbDYzcuRIYmJiGDVqFElJSQwePBh3d3emT59udDyRXEkdYiIiIiIiIg+Zn58fe/bs4ejRo5QrV87oOGIwq9XKiBEjmDJlCgkJCRQsWJCPP/6YXr16GR1NJNdQh5iIiIiIiMhD9v333wPw4osvGpxEsgKz2cy4ceO4cuUKQ4cOJTY2lt69e+Pp6cl3331ndDyRXEEFMRERERERkYesSpUqNGjQgL///pu9e/caHUeyCIvFwsSJE4mNjWXQoEFER0fTo0cPvLy8mD9/vtHxsrwLFy7Qr18/SpQogYODA15eXrRq1YotW7YYHY2SJUsyZcqUBzrG8ePHcXFxwc3NLVMySUYqiImIiIiIiDwCc+fOxWQy0b17d6OjSBZjsVj47LPPuHLlCv369SMyMpJu3bpRtGhRlixZYnS8LKtz587s2bOHgIAAjh49yooVK2jSpAmXLl16aOdMSkp6aMe+XnJyMs8//zwNGzZ8JOfLjVQQExEREREReQR8fHx48skn2b9/P5s2bTI6jmRB9vb2TJ8+nZiYGF555RUiIiLo0qULxYsXZ8WKFUbHy1KioqLYtGkT48ePp2nTpvj4+FCnTh2GDx9O+/btM+zXq1cvChUqhKurK82aNSMwMDDDsX7++Wdq166No6MjHh4edOrUKX1byZIlef/99+nevTuurq706dMHgM2bN9OwYUPy5s1L8eLFGTRoEHFxcQA0adKEU6dOMWTIEEwmEyaT6Z6vb+TIkVSsWJFnnnnmfj49chdUEBMREREREXlEvvvuO8xmM/7+/kZHkSzM0dGRWbNmpS+hPHfuHB06dKBkyZKsWrXK6HhZgrOzM87Ozvz0008kJibecr+uXbsSERHBqlWr2LVrF35+fjRv3pzIyEgAVq5cSadOnWjTpg179uxh3bp11KlTJ8MxJk6cSLVq1dizZw+jRo0iODiY1q1b07lzZ/bt28fChQvZvHkzAwYMAGDp0qUUK1aMsWPHcu7cOc6dO5d+LJPJxJw5c257bX/88QeLFy/miy++uM/PjtwN3WVSRERERETkEerSpQtLlizh559/pl27dkbHkWwgNjaWV199lYULF5Kamkrp0qX5+uuvad68udHRDLVkyRJ69+7N1atX8fPzo3Hjxjz33HNUrVoVSOviatu2LRERETg4OKS/r2zZsrz99tv06dOHevXqUbp0aebOnXvTc5QsWZIaNWqwbNmy9Nd69eqFnZ0dX331VfprmzdvpnHjxsTFxeHo6EjJkiUZPHgwgwcPznC8ihUrMm7cuAxdaNe7dOkSNWrUYO7cuTRq1Ig5c+YwePBgoqKi7vOzJLeiDjEREREREZFH6Ntvv8XOzo6+ffsaHUWyCWdnZ+bNm0dkZCRdu3YlJCSEFi1aUL58eTZu3Gh0PMN07tyZsLAwVqxYQevWrdmwYQN+fn7pHViBgYHExsZSsGDB9I4yZ2dnTp48SXBwMAB79+69Y2GxVq1aGZ4HBgYyZ86cDMds1aoVVquVkydP3vZYR44cuWUxDKB3795069aNRo0a3cVnQB6ECmIiIiIiIiKPkKurK927d+fs2bPMmzfP6DiSjbi6urJo0SIuXLhAp06dCA4OpkmTJlSqVImtW7caHc8Qjo6OtGzZklGjRrF161Z69uzJu+++C6R11nl7e7N3794MH0FBQbz11lsA5M2b947nyJcvX4bn/3TsXX/MwMBAjh07RpkyZR7oev744w8mTpyIxWLBYrHwyiuvEB0djcVi4dtvv32gY0tGKoiJiIiIiIg8YtOnT8fe3p4hQ4YYHUWyIXd3d5YuXcr58+dp164dQUFB1K9fH19fX3bs2GF0PENVrlw5fbi9n58f4eHhWCwWypYtm+HDw8MDgKpVq7Ju3bp7Ooefnx+HDh264Zhly5bF3t4eSLtBQmpq6j3n37ZtW4ZC29ixY3FxcWHv3r237SyTe6eCmIiIiIiIyCPm6OhI//79uXDhggZny33z8PDg559/JiwsjNatW3Po0CHq1KlD9erV2bt3r9HxHqpLly7RrFkz5s6dy759+zh58iSLFy9mwoQJdOjQAYAWLVpQt25dOnbsyNq1awkJCWHr1q2MGDGCnTt3AvDuu+8yf/583n33XQ4fPsz+/fsZP378bc89bNgwtm7dyoABA9i7dy/Hjh1j+fLl6UP1IW322J9//snZs2e5ePFi+usVK1bMMI/svypVqoSvr2/6R9GiRTGbzfj6+lKgQIEH+ZTJf6ggJiIiIiIiYoBPPvmEvHnz8s4772C1Wo2OI9mYl5cXq1atIjQ0lBYtWrBv3z5q1KhBzZo1OXDggNHxHgpnZ2cef/xxJk+eTKNGjfD19WXUqFH07t2bzz//HEi7o+Ovv/5Ko0aN8Pf3p3z58jz33HOcOnWKwoULA9CkSRMWL17MihUrqF69Os2aNePvv/++7bmrVq3Kxo0bOXr0KA0bNqRGjRqMHj2aIkWKpO8zduxYQkJCKFOmDIUKFUp/PSgoiOjo6IfwGZF7pbtMioiIiIiIGGTMmDG89957fPDBB4wYMcLoOJJDhIaG0qNHDzZs2ABA7dq1CQgIoFKlSsYGE8lCVBATERERERExiNVqxc3NjdTUVK5cuYLZrEU8knlOnjxJ9+7d2bx5MwB169YlICCAcuXKGZxMxHj6aisiIiIiImIQs9nM2LFjiY+PZ9iwYUbHkRymVKlSbNq0iaCgIJ544gm2bdtG+fLladSoESEhIUbHEzGUOsREREREREQMVrBgQWJjY7ly5Ur6XepEMtvBgwfp2bNn+kD5pk2bMmfOHEqUKGFwMpFHTx1iIiIiIiIiBvv0009JSkrKcJc6kcxWpUoVduzYQWBgIDVq1GD9+vWULFmSJ598krCwMKPjiTxS6hATERERERHJAooUKcKFCxe4fPkyzs7ORseRXGD37t307NmT/fv3YzKZaN26NXPmzMHT09PoaCIPnTrEREREREREsoDp06eTkpJC7969jY4iuYSfnx/79u3jr7/+olKlSqxatQovLy86dOjAxYsXjY4n8lCpQ0xERERERCSLKF26NKdOnSIiIoKCBQsaHUdymc2bN9OrVy+CgoIwm8107NiRb775Bjc3N6OjiWQ6dYiJiIiIiIhkEbNmzcJqtdKjRw+jo0gu1KBBA44cOcL69espXbo0S5cupWDBgjz77LPExMQYHU8kU6lDTEREREREJAupXLkyR44cITQ0lGLFihkdR3Kx3377jVdffZWTJ09iZ2fHc889x4wZMzTjTnIEdYiJiIiIiIhkId999x02m40XX3zR6CiSy7Vs2ZITJ07wyy+/ULRoUebNm4ebmxv+/v7Ex8cbHU/kgahDTEREREREJIupVasWu3bt4siRI1SoUMHoOCIALF++nAEDBnDmzBksFgv+/v5MnToVR0dHo6OJ3DN1iImIiIiIiGQxc+fOBVCXmGQpHTp04PTp0yxevJhChQoxc+ZMXF1dee2110hKSjI6nsg9UUFMREREREQki6lYsSKNGjVi586d7Nq1y+g4Ihl06dKFsLAw5s6di7u7O9OnT8fFxYXBgweTkpJidDyRu6IlkyIiIiIiIllQaGgoJUuWpFKlShw8eNDoOCK3NHv2bIYNG8aFCxdwcHBg4MCBjBs3DovFYnQ0kVtSh5iIiIiIiEgWVKJECVq3bs2hQ4fYsGGD0XFEbsnf35+IiAi++uor8uXLx8SJE3FxcWHEiBFYrVaj44nclDrEREREREREsqiLFy9SuHBhSpYsSXBwsNFxRO7K559/zqhRo4iKisLJyYm33nqL0aNHYzarJ0eyDv1tFBERERERyaI8PDzo0qULJ06cYPny5UbHEbkrAwYM4PLly0yaNAmLxcJ7772Hq6srH374oTrGJMtQh5iIiIiIiEgWFhsbS4ECBfD09OTs2bNGxxG5J1arlYkTJ/L+++8TGxuLi4sLo0aNYujQoeoYE0Ppb5+IiIiIiEgW5uzsTI8ePQgLCyMgIMDoOCL3xGw28/bbbxMdHc3777+P1Wrl7bffxt3dnc8++8zoeJKLqUNMREREREQki0tMTMTV1RUXFxcuXrxodByR+2a1WhkzZgwTJ07k6tWrFChQgA8//JB+/foZHU1yGXWIiYiIiIiIZHEODg4MGDCAS5cuqatGsjWz2czYsWOJjY3lf//7H1evXqV///54eHgwa9Yso+NJLqIOMRERERERkWwgJSUFV1dX8uTJw+XLlzV/SXKElJQUhg0bxhdffEFiYiKFChVi4sSJdO/e3ehoksPpK6iIiIiIiEg2YLFYGD58ODExMXzwwQdGxxHJFBaLhUmTJhETE8PAgQOJjo6mR48eeHt7s2DBAqPjSQ6mDjEREREREZFswmq1UqBAAZKTk4mJicFisRgdSSRTJSUl8frrr/PNN9+QnJxMkSJFmDp1Kp07dzY6muQw6hATERERERHJJsxmMx988AFXr15l2LBhRscRyXT29vZ8+eWXxMTE8MorrxAREUGXLl0oUaIEK1asMDqe5CDqEBMREREREclmPDw8uHLlCtHR0Tg6OhodR+ShiY+Pp1+/fsybN4/U1FR8fHz48ssveeqpp4yOJtmcOsRERERERESymSlTppCUlMSAAQOMjiLyUDk5OREQEEBUVBTPP/88Z86coU2bNpQpU4Z169YZHU+yMXWIiYiIiIiIZENFixbl/PnzREZG4urqanQckUciOjqa3r17s2TJEqxWK+XKlWPWrFk0atTI6GiSzahDTEREREREJBv68ssvSU1NpVevXkZHEXlk8ufPz6JFi7hw4QIdO3YkODiYxo0bU6lSJbZt22Z0PMlG1CEmIiIiIiKSTZUpU4aQkBDCw8MpVKiQ0XFEHrmLFy/i7+/PypUrsdlsVKlShdmzZ1O7du1MP1dEXATRCdGYTWY883ni4uCS6eeQR0cFMRERERERkWxq48aNNGnShKeeeopff/3V6DgihgkPD8ff3581a9Zgs9moVq0ac+bMoXr16hn2u3LlCgkJCXdVQE5MSeTHQz8y/8B8tp/dzsX4ixm2l3IrRSOfRvhX96eRTyNMJlNmXpI8ZCqIiYiIiIiIZGO+vr4cOnSIkJAQSpQoYXQcEUOdOXMGf39/1q1bh81mw8/Pj4CAAHx9fbHZbDRu3JgjR45w4MABPD09b3oMq83KtO3TGLNxDFEJUZhNZqw26033tZgtpFhTqFCwAp+3+ZwWpVs8zMuTTKSCmIiIiIiISDa2e/duatasScOGDfnzzz+NjiOSJZw6dYoePXqwceNGAOrUqUPfvn15+eWXMZlMtGjRgtWrV2M2ZxytHhIVQrcl3dh25t7mkf1TNOtTsw+ftf4MR4tjpl2LPBwqiImIiIiIiGRzderUYceOHRw6dIhKlSoZHUckyzhx4gQ9evRg8+bNN2wbP348b7/9dvrzoItBNJrTiEvxl0i1pd7X+cwmMw1KNGDVC6twyuN037nl4VNBTEREREREJJs7evQoFSpUoGbNmuzcudPoOCJZzqxZs+jdu3eG10wmE1u2bKFu3bpExEVQbUY1LsZfJMWa8kDnMpvMtC7Tml+6/aK5YlmY+c67iIiIiIiISFZWvnx5mjRpwq5du9ixY4fRcUSyFJvNxpdffnlDccpms9GkSROCgoLo+0tfLsRdeOBiGKTNIPv1+K98vevrBz6WPDzqEBMREREREckBzpw5Q4kSJahYsSKHDh0yOo5IlhEXF4enpyfx8fE33Z7nsTwkuyfDxv9sMAF5gcJAdaDaddtCgEDgNHD9zSd7AKXSHua15CV4UDDeLt4PfhGS6dQhJiIiIiIikgMUK1aMNm3acPjwYdatW2d0HJEsI1++fFy4cIELFy5w/vx5wsPDCQsL48yZM/z999+4t3e/+RttQDxwElgGbLlu22FgDxmLYf+RmJqoLrEsTB1iIiIiIiIiOURkZCSFChWiRIkSnDx50ug4IlnevvP7qDajGqzn3w6xskBDIBX4Gzhy7fX8wJBrjzcB54BiwC7g0rXXr+sQA/DM58nZN85iMVse4lXI/VCHmIiIiIiISA7h7u7OM888Q0hICMuWLTM6jkiWt+b4Gsym/5RG8gE+QGmg2XWvx173uCHwDFAPcLz18SPiIjgQcSBzwkqmUkFMREREREQkB5k5cyYWi4XXXnvN6CgiWd6uc7swcYs7Qabwb3cYgOf9nWNnmO78mhWpICYiIiIiIpKDODs788orr3Du3Dlmz55tdByRLG3f+X2k2lIzvhgIjAE+AP649poT8NS9Hz+POQ+HLxx+kIjykKggJiIiIiIiksNMnToVBwcH3nzzTaOjiGRp8ck3v/PkDfIASfd3joSUhPt7ozxUKoiJiIiIiMj/t3enQVYVBtqA326aRURAaRUJGlCMSBLigktQ3IJKRFzCuLIIjktiGYyxMimLSjA4ZTSSTMb5HEfjuEQzkcQVo4hEJRFXXMBdkeAKCtrsTdN03/5+iAQUFRC43dznqaK4fe/pc9/mR1fx1nvPYTPTokWLjBgxIlVVVfnNb35T7DjQaLWqWMMFwLolGZ6PLpB/6IrnFiS5JcmidX+PFs1arG88NiKFGAAAwGbo0ksvTevWrTNq1KgUCoVix4FGqXtl98++qH7XJAfno4Is+eiaYq+u2/nrCnXptk23Lz6QTU4hBgAAsBkqLy/PyJEjs3jx4owePbrYcaBR6tWp12dfVP9jDas8Xrpu529IQ3p16rXOudj4yhoaGhq++DAAAACamkKhkG222SbLli3LokWLUlFRUexI0Kg8+vajOeC6A5KHkvxtxZPdkvRJUkjydj567ePm5MQkPZLMSTJ3xXMPJKla8fiQJNuuePz1pG2Ltnn/J++v+aOZFJWFGAAAwGaqvLw8l1xySWpqanLBBRcUOw40Ot/u/O3sXrn76k++nuT6JDfmo7tMflyG7ZBktxWPX0zy5xV/qlb53kn/fL5ZWbOcsdcZyrBGSiEGAACwGTvnnHOy7bbb5qqrrkpNjbvdwarKyspywbc/pyyuSLJdPlqMnZak2bqd+wf7/ODLBWSjsZcFAADYzP32t7/NoEGD8oMf/CDXX399seNA0RQKhcyePTtvvPFG3njjjTzyyCO5ZewtyXFJ+aHlKWQtb0BxaP55B8o1KEtZfn7Qz11QvxFzDTEAAIASsOOOO2b27NmpqqpK27Ztix0HNqm33norRxxxRGbMmJG6urpPvT7qP0dlzOIxWVq3NIWGL3dX1oqyivTcvmceP+PxNG/W/Eudi43HRyYBAABKwNVXX536+vqcfvrpxY4Cm9yWW26Z9957b41l2PDhw3PRiIsyYfCEtGzWMs3K1uFzkZ/QrKxZdtlml9w3+D5lWCNnIQYAAFAidt1118yYMSPvvfdetttuu2LHgU3q//7v/zJo0KDVnmvXrl1mzpyZrbfeOkny1KynMvBPA/POwnfWaynWt2vf3PIvt6RD6w4bJDMbj4UYAABAibj++uvT0NCQoUOHFjsKbFJPPfVUzjvvvE89/8tf/nJlGZYkvTr1ykvnvJRz9zk3zcqapbzs82uTj19v17Jdfjfgd7l/yP3KsCbCQgwAAKCE9OzZMy+88EJmzpyZr371q8WOAxtVoVDIGWeckeuvvz7l5eU577zzct1112XBggXp3r17nn/++VRUrPl+g+8tfi/XPnNtbn7u5kyvmv6pxVjLZi3Tq1OvnLHXGTnp6ydli+ZbbIofiQ1EIQYAAFBCpk2blj322CMHHHBAJk+eXOw4sNFMmTIl/fv3z9y5c7PLLrtk4sSJ6dq1a2655ZYMGTIk48ePT9++fdfqXEtql+SFOS9kfs38NCtvlo5tOqZ7ZfdUlK+5TKPxU4gBAACUmP333z9PPPFEXnjhhXz9618vdhzYoAqFQv71X/81N9xwQ8rLy/Ozn/0sF1100WrHLFiwIO3atStOQBoFhRgAAECJmTFjRrp165Y999wzzzzzTLHjwAbz5JNPpn///vnggw/SrVu3TJw4MV26dCl2LBohF9UHAAAoMbvssksOO+ywPPvss3n88ceLHQe+tEKhkOHDh2e//fZLVVVVRo0alenTpyvD+EwWYgAAACVo1qxZ6dy5c772ta/llVdeKXYcWG9PPPFEjj766JWrsL/+9a9uGMEXshADAAAoQZ06dcqAAQPy6quvZuLEicWOA+usUChk2LBh2X///VNVVZWLLroo06dPV4axVizEAAAAStS8efNSWVmZHXfcMW+88Uax48Bae+yxxzJgwIB8+OGH2XXXXTNx4kRFGOvEQgwAAKBEbb311jnllFPy5ptv5tZbby12HPhChUIhp512Wnr37p358+dn9OjRee2115RhrDMLMQAAgBJWXV2ddu3apbKyMrNnzy52HPhMVmFsSBZiAAAAJax169Y588wz89577+Xaa68tdhz4lEKhkKFDh65chV188cVWYXxpFmIAAAAlrra2Nm3btk3r1q1TVVVV7Diw0mOPPZajjz46VVVV+drXvpaJEydmp512KnYsNgMWYgAAACWuRYsWOf/88zNv3rxcfvnlxY4DKRQKGTx4cHr37p0FCxbk3//93/Pqq68qw9hgLMQAAABIoVBI27ZtkyQLFy5Mebn9BMXxyCOP5JhjjklVVVV222233H///YowNji/4QAAAEh5eXl+/vOfZ8mSJRk1alSx41CCPl6FHXjggStXYa+88ooyjI3CQgwAAIAkHxUSHTp0SE1NTRYtWpSKiopiR6JEWIWxqVmIAQAAkOSjldhll12WmpqanH/++cWOQwkoFAoZNGjQylXYJZdcYhXGJmEhBgAAwGq23377zJs3L/Pnz0/r1q2LHYfN1OTJk3PMMcdk3rx56d69eyZOnJjOnTsXOxYlwkIMAACA1VxxxRVZvnx5fvCDHxQ7CpuhQqGQU089NX369MnChQtzySWX5OWXX1aGsUlZiAEAAPApO+20U2bNmpUPPvgg7du3L3YcNhNWYTQWFmIAAAB8yjXXXJP6+vqcfvrpxY7CZqCuri6nnHLKylXYpZdeahVGUVmIAQAAsEa77bZbpk+fnlmzZqVjx47FjkMT9fe//z3HHnts5s+fn9133z0TJ07MV77ylWLHosRZiAEAALBG119/fRoaGjJkyJBiR6EJqqury8knn5yDDz44ixYtymWXXZaXXnpJGUajYCEGAADAZ9pjjz0ybdq0/OMf/0jXrl2LHYcmYtVVWI8ePTJx4sR06tSp2LFgJQsxAAAAPtNNN92UJBk0aFCRk9AUfHIV9qtf/SovvviiMoxGx0IMAACAz9W7d+889thjmTZtWnr27FnsODRSkyZNyvHHH28VRpNgIQYAAMDn+sMf/pAkGTp0aJGT0BjV1dXlxBNPzKGHHmoVRpNhIQYAAMAXOvzww/PXv/41jzzySHr37l3sODQSkyZNynHHHZcFCxbk61//eu6//35FGE2ChRgAAABf6KabbkpZWVmGDx9e7Cg0AnV1dTnhhBNy6KGHZsmSJRkzZkxeeOEFZRhNhkIMAACAL9SxY8cce+yxee211zJ+/Phix6GIHnzwwVRWVubWW2/NN77xjbz99tu54IILih0L1omPTAIAALBW5s+fn8rKynTq1ClvvfVWseOwiX18B8nbbrstFRUVueyyy/LjH/+42LFgvViIAQAAsFbat2+fQYMG5e23387YsWOLHYdN6ONV2G233bZyFaYMoymzEAMAAGCtVVdXp3379tl6663z/vvvFzsOG1ldXV1OOumk3H777VZhbFYsxAAAAFhrrVu3ztlnn505c+bkmmuuKXYcNqIHHnggHTp0yO23355vfvObVmFsVizEAAAAWCd1dXXZaqut0qpVq3z44YcpL7e12Jx8chV2+eWX50c/+lGxY8EG5bcWAAAA66SioiIXXHBB5s+fnzFjxhQ7DhvQJ1dh77zzjjKMzZKFGAAAAOusUCikbdu2SZKFCxdaiTVxdXV1OfHEE3PHHXekoqIiY8aMyXnnnVfsWLDR+I0FAADAOisvL88vfvGLLFmyJCNHjix2HL6EiRMnpkOHDrnjjjvSs2fPvPvuu8owNnsWYgAAAKy3bbbZJtXV1Vm4cGFatGhR7Disg+XLl+fEE0/MnXfeaRVGybEQAwAAYL1dfvnlWbZsmetMNTETJ05MZWVl7rzzznzrW9+yCqPkKMQAAABYb8ccc0y22GKLXHXVVWnZsmU6duyYI488Mo888kixo6VLly757W9/u87fV1NTk2HDhuWb3/xmKioqctxxx23wbMVSW1ub4447LkcccUSqq6tzxRVXZOrUqdluu+2KHQ02KYUYAAAA623gwIHp3LlzkuS73/1uxo0bl0MOOSQffvjhRnvP2trajXbuJKmvr88WW2yRESNGpG/fvhv1vTalCRMmpLKyMnfdddfKVdgPf/jDYseColCIAQAAsF7mz5+fhx9+OL/73e/y1a9+NXfffXd23XXXXHjhhTnmmGNWO+6MM87Itttum7Zt2+awww7LtGnTVjvX3XffnX322SetWrVKZWVljj/++JWvdenSJRdffHGGDh2atm3b5qyzzkqSTJ48OX369MkWW2yRHXfcMSNGjMiSJUuSJIccckjefPPNnH/++SkrK0tZWdla/1xbbrllrrrqqpx55pnp2LHjl/knahRqa2tz7LHHpl+/flm6dKlVGEQhBgAAwHpq06ZN2rRpkzvvvDNXXnllCoVChg0b9qnjTjjhhMyZMyfjx4/P008/nb322ivf+c53UlVVlSS55557cvzxx+eoo47Ks88+mwceeCD77rvvaucYM2ZMvvWtb+XZZ5/Nz372s8yYMSP9+vXLwIED89xzz2Xs2LGZPHlyzj333CTJ7bffns6dO2f06NGZPXt2Zs+evfJcZWVlueGGGzbav0tj8vEqbNy4cdlzzz0ze/ZsqzCIu0wCAADwJdx2220588wzs3Tp0iQfXX9r4sSJKz9qOHny5PTv3z9z5sxJy5YtV35ft27d8m//9m8566yz0rt37+y88865+eab1/geXbp0yZ577pk77rhj5XNnnHFGmjVrlquvvnrlc5MnT87BBx+cJUuWpFWrVunSpUt+9KMffeqC/927d88vf/nL1VZon2XYsGGZP39+7rzzzrX9J2kUamtrc8IJJ2TcuHFp3rx5fvOb36wsCwELMQAAAL6EgQMHZtasWRk3blyGDh2aJDniiCNWLrCmTZuWxYsXp0OHDisXZW3atMnMmTMzY8aMJMnUqVPzne9853Pfp1evXqt9PW3atNxwww2rnfPII49MoVDIzJkzP/dcr7zyylqVYU3V+PHjV1uFzZo1SxkGn1BR7AAAAAA0ba1atcrhhx+eww8/PFOmTMmzzz6bkSNHZtiwYVm8eHF22GGHTJo06VPf1759+yTJFlts8YXvseWWW6729eLFi3P22WdnxIgRnzp2p512Wq+fo6mrra3NwIED85e//CXNmzfPlVdemXPOOafYsaBRUogBAACwwdx00035xje+kTlz5iRJ9tprr7z33nupqKhIly5d1vg9PXv2zAMPPJDhw4ev9fvstddeeemll9KtW7fPPKZFixapr69fp/xN1fjx43PiiSdm8eLF2WuvvVZeOwxYMx+ZBAAAYL18+OGHOeyww3LzzTfnueeey8yZM/PSSy+lefPmqaury7Rp09K3b998+9vfznHHHZf7778/b7zxRh599NGMHDkyTz31VJJk1KhR+eMf/5hRo0bl5ZdfzvPPP5/LLrvsc9/7pz/9aR599NGce+65mTp1aqZPn5677rprtY8GdunSJX//+9/z7rvv5oMPPlj5fPfu3Ve7HtmavPTSS5k6dWqqqqqyYMGCTJ06NVOnTl3/f6yNpLa2NkcffXSOOuqoLFu2LFdeeWWefvppZRh8AQsxAAAA1kubNm2y33775T/+4z8yY8aMLF++PDvuuGO+//3v57/+678yZMiQPPfcc7n33nszcuTIDB8+PHPnzk3Hjh1z0EEHZfvtt0+SHHLIIfnzn/+ciy++OJdeemnatm2bgw466HPfu2fPnvnb3/6WkSNHpk+fPmloaMguu+ySk046aeUxo0ePztlnxywrbAAADsBJREFUn51ddtkly5Yty8f3lHv11VezYMGCzz3/UUcdlTfffHPl13vuuWeSpDHdl+7ee+/NSSedlMWLF2fvvffOfffdpwiDteQukwAAAGxw/fr1y4QJE/Lwww/nwAMPLHaczUptbW2+973v5Z577knz5s1zxRVX5Pvf/36xY0GTohADAABgg5szZ0522GGH7Lzzzpk+fXqx42w2PrkKmzBhQjp06FDsWNDkuIYYAAAAG9x2222X448/Pq+//nruvffeYsdp8mpra9O/f//0798/y5Yty//8z//kqaeeUobBerIQAwAAYKNYuHBhttlmm+ywww55++23ix2nyfrLX/6Sk08+OUuWLMnee++d+++/P9tss02xY0GTZiEGAADARtG2bdsMGTIk77zzTv74xz8WO06Ts2zZshx11FEZMGBAamtrV67ClGHw5VmIAQAAsNHU1NSkbdu2ad++febMmVPsOE3GqquwXr16ZcKECYow2IAsxAAAANhoWrVqlXPOOSdz587Nf//3fxc7TqNXU1OT7373uxkwYECWL1+eq6++OlOmTFGGwQZmIQYAAMBGVVdXl6222iotW7ZMVVVVysttM9Zk3LhxOfXUU7NkyZLss88+ue+++xRhsJH4LQQAAMBGVVFRkZ/+9KdZsGBBLrvssmLHaXQ+XoUde+yxWb58ea655po8+eSTyjDYiCzEAAAA2OgKhULat2+f+vr6LFq0yEpshVVXYfvuu2/Gjx+vCINNwG8gAAAANrry8vKMHj061dXVufDCC4sdp+hqamrSr1+/lauw3/3ud3niiSeUYbCJWIgBAACwyXTo0CFLlizJwoUL06JFi2LHKYq77rorp556aqqrq7PvvvtmwoQJad++fbFjQUmxEAMAAGCT+fWvf51ly5ZlxIgRxY6yydXU1OTII4/Mcccdl7q6ulx77bV54oknlGFQBBZiAAAAbFKdOnXK3LlzM2/evLRp06bYcTaJO++8M4MGDUp1dXX222+/3HfffYowKCILMQAAADapK6+8MnV1dTnrrLOKHWWjq6mpyRFHHJHjjz8+dXV1+d///d88/vjjyjAoMgsxAAAANrmuXbvmrbfeyty5czfbC8nfcccdGTx4cKqrq7P//vtn/PjxijBoJCzEAAAA2OSuvfbaFAqFnHbaacWOssEtXbo0hx9+eL73ve+lrq4u1113XR577DFlGDQiFmIAAAAURY8ePfLKK6/krbfeSufOnYsdZ4O4/fbbM2TIEKswaOQsxAAAACiKG2+8MQ0NDRkyZEixo3xp1dXV6du3bwYOHJj6+vrccMMNVmHQiFmIAQAAUDS9evXK008/nddeey277rprseOsl9tuuy1DhgzJ0qVL07t379x7771p165dsWMBn8NCDAAAgKK56aabkiSDBg0qcpJ19/Eq7F/+5V9SKBRyww035JFHHlGGQROgEAMAAKBodt999/Tp0ydTpkzJM888U+w4a+3WW29NZWVlHnjggfTu3Ttz5szZLG8QAJsrH5kEAACgqN5666106dIlPXr0yAsvvFDsOJ+ruro6AwYMyIMPPpiWLVvmmmuuydChQ4sdC1hHFmIAAAAU1U477ZR+/frlxRdfzN/+9rdix/lMf/7zn1NZWZkHH3xw5SpMGQZNk4UYAAAARffBBx9k++23T9euXfP6668XO85qqqurc/TRR+ehhx6yCoPNhIUYAAAARVdZWZmBAwdmxowZGTduXJ5//vmcffbZee6554qa609/+lMqKyvz0EMP5YADDrAKg82EhRgAAACNwuLFi9O+ffu0aNEiNTU1aWhoyJgxY3LBBRds8izV1dXp379/Jk2alJYtW+baa6/N4MGDN3kOYOOwEAMAAKDo3n333VxwwQUpFApZunRpGhoa0qxZsyxfvnyTZxk7dmwqKyszadKkHHjggZk7d64yDDYzFcUOAAAAAEOHDs2DDz642nNlZWWpq6vbZBkWL16cAQMGZNKkSWnVqlVuvvnmDBo0aJO9P7DpWIgBAABQdL/+9a+z8847p7z8n/9NbWho2GQLsbFjx2bbbbddbRWmDIPNl0IMAACAottjjz0ybdq0nHbaaSufq6+vT21t7QZ7j0KhkEmTJq22Olu8eHEOOeSQnHzyyUmSm2++OQ8//HDatGmzwd4XaHxcVB8AAIBG5U9/+lMGDx6c5cuX58ADD8zDDz+c5fXL8+LcF/PM7Gcye9HsFBoKadeqXfbouEf27Lhntmq51Ree9/rrr8/pp5+eiy66KKNGjcrYsWMzbNiw1NTU5KCDDso999yjCIMSoRADAACg0fnHP/6R3XffPVvtslVOuPyE3Dj1xiytW5okqSivSFnKUt9Qn0JDIWUpS79u/XLuvuemX7d+KS/79IehFi1alJ133jkffPBBysvLs8cee+SZZ55Jq1atct111+WUU07Z1D8iUEQKMQAAABqdhcsWZvCNg3P37LvTrKxZ6hvqP/f4j4/Zp9M++f3xv0/3yu6rvX7hhRfmV7/6VQqFwsrn+vTpk3vvvdcqDEqQa4gBAADQqDz3/nPpcWWP3PPePUnyhWXYqsc8+96z6XlVz9w49caVr82cOTNjxoxZrQxLkr59+yrDoERZiAEAANBoPPf+c+lzfZ8sqV2yVkXY57n66Ktz1t5nZd99982UKVM+9XqzZs3y+uuvp0uXLl/qfYCmp6LYAQAAACBJ5i2dlyNuOmKDlGFJ8v2/fD93XXfXamVYWVlZKisr07Vr1/To0SNbbfXFF+MHNj8WYgAAADQKw+4clt//5+/TMOkT/00tS7JFku2T7JHkW6u8Ni3JP5LMSrIoyfIkbZN8LclBSeqSA6cemJ/86Cfp0aNHdtxxx7Rs2XJj/yhAI2chBgAAQNE9+e6TuXHajcmaJhsNSaqTzFzxZ3GSA1a8Ni7JJ8dk85I8keTVpOzssvT9ed8cc8gxGyk50BS5qD4AAABF9/+e/H+pKP/EZqNbkuFJhiZZ9aaRT67yuCzJTkmOTjIkyaFJmq14bX7S8HhDrpxyZZbXL984wYEmyUIMAACAolq0bFFueeGW1BXqVn9hyyRfXfG4TZJXVjxevMoxJ+ej4uxjuyRZmuTxFV+/m8ytnpt7p9+bY7sfu6GjA02UhRgAAABF9fTsp7O88DkLrrr8swxLku1Wedwtn7bNKo9bJM3Lm+fRtx/9UhmBzYuFGAAAAEX19KynU15WnkJDYfUXpq34s6rWSb77BSd8eZXH3ZLlheWZMmvKZx4OlB4LMQAAAIrqnYXvpFlZsy8+MEmaJ6n9nNcfyEcX3k+Szll5R8o3F7y53vmAzY9CDAAAgKKqb/jkbSJX+Pii+qflo4vlJ8mCJLckWbSG4yckeXjF48okp2TlBfY/dX0yoKQpxAAAACiqrVpsteYXPr6oftckB+ef1wurS/LqKscVktyd5LEVX2+fZNiK71+hXct2Gywv0PS5hhgAAABF1XP7np9/Uf2PNazyeOmKv+uT3Jnk+RVfd04yKMkW/zy0orwie+2w15cPCmw2FGIAAAAUVa9Ovdb8wpIkb+ajBdjbSf6xymsdVvz9p/xzLdY2ySFJ5qxyXKukfvv67L3D3hsuMNDkKcQAAAAoqp233jk9tu2Rl+e+nIZVZ2Cvr/jzSTsk2W3F41U/Orkwyc2fOParSYYnx3Y/dsMFBpo81xADAACgqMrKyjJi3xGff1BFku2S9MlHF9lfy5tSpiw5+mtHZ6d2O32pjMDmpayhoaHhiw8DAACAjWdJ7ZJ0v7J7Zi+a/dl3nVwPZSnL42c8nn2/su8GOyfQ9FmIAQAAUHRbttgyNx534wYtw8rLyvOT3j9RhgGfohADAACgUTis62EZ2WfkBjlXs7Jm6dWpV35x6C82yPmAzYtCDAAAgEbj4kMvzo/3/3GSjz7uuD7Ky8qz9w57Z8LgCWlV0WpDxgM2EwoxAAAAGo2ysrKMOWJMbjj2hmzZYstUlFWs9fc2K2uWspTlh/v+MA8NeyjtW7XfeEGBJs1F9QEAAGiU3l34bn720M/yh+f/kOX1y9OsvFnqCnWrHVNeVp6ylKW+oT6Hdjk0ow8dnQN3OrBIiYGmQiEGAABAo1a1tCpjXxibx999PI+/83jeX/x+6hvq07Zl2/TaoVf2+co+OaHHCdmtcrdiRwWaCIUYAAAAACXFNcQAAAAAKCkKMQAAAABKikIMAAAAgJKiEAMAAACgpCjEAAAAACgpCjEAAAAASopCDAAAAICSohADAAAAoKQoxAAAAAAoKQoxAAAAAEqKQgwAAACAkqIQAwAAAKCkKMQAAAAAKCkKMQAAAABKikIMAAAAgJKiEAMAAACgpCjEAAAAACgpCjEAAAAASopCDAAAAICSohADAAAAoKQoxAAAAAAoKQoxAAAAAEqKQgwAAACAkqIQAwAAAKCkKMQAAAAAKCkKMQAAAABKikIMAAAAgJKiEAMAAACgpCjEAAAAACgpCjEAAAAASopCDAAAAICSohADAAAAoKQoxAAAAAAoKQoxAAAAAEqKQgwAAACAkqIQAwAAAKCkKMQAAAAAKCkKMQAAAABKikIMAAAAgJKiEAMAAACgpCjEAAAAACgpCjEAAAAASopCDAAAAICSohADAAAAoKQoxAAAAAAoKQoxAAAAAEqKQgwAAACAkqIQAwAAAKCkKMQAAAAAKCkKMQAAAABKikIMAAAAgJKiEAMAAACgpCjEAAAAACgpCjEAAAAASopCDAAAAICSohADAAAAoKQoxAAAAAAoKQoxAAAAAEqKQgwAAACAkqIQAwAAAKCkKMQAAAAAKCkKMQAAAABKikIMAAAAgJKiEAMAAACgpCjEAAAAACgpCjEAAAAASopCDAAAAICSohADAAAAoKQoxAAAAAAoKQoxAAAAAEqKQgwAAACAkqIQAwAAAKCkKMQAAAAAKCkKMQAAAABKikIMAAAAgJKiEAMAAACgpCjEAAAAACgpCjEAAAAASopCDAAAAICSohADAAAAoKQoxAAAAAAoKQoxAAAAAEqKQgwAAACAkvL/ATruflXziQQ/AAAAAElFTkSuQmCC",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1200x1000 with 1 Axes>"
       ]
@@ -452,9 +353,9 @@
     "llm_config = {\"config_list\": config_list_gpt4, \"cache_seed\": 100}\n",
     "\n",
     "# Create an empty directed graph\n",
-    "graph = nx.DiGraph()\n",
-    "\n",
     "agents = []\n",
+    "speaker_transitions_dict = {}\n",
+    "secret_values = {}\n",
     "\n",
     "# Outer loop for prefixes 'A', 'B', 'C'\n",
     "for prefix in [\"A\", \"B\", \"C\"]:\n",
@@ -462,7 +363,7 @@
     "    for i in range(3):\n",
     "        node_id = f\"{prefix}{i}\"\n",
     "        secret_value = random.randint(1, 5)  # Generate a random secret value\n",
-    "        graph.add_node(node_id, label=node_id, secret_value=secret_value)\n",
+    "        secret_values[node_id] = secret_value\n",
     "\n",
     "        # Create an AssistantAgent for each node (assuming AssistantAgent is a defined class)\n",
     "        agents.append(\n",
@@ -496,6 +397,7 @@
     "                llm_config=llm_config,\n",
     "            )\n",
     "        )\n",
+    "        speaker_transitions_dict[agents[-1]] = []\n",
     "\n",
     "    # Add edges between nodes with the same prefix using a nested for loop\n",
     "    for source_node in range(3):\n",
@@ -503,26 +405,33 @@
     "        for target_node in range(3):\n",
     "            target_id = f\"{prefix}{target_node}\"\n",
     "            if source_node != target_node:  # To avoid self-loops\n",
-    "                graph.add_edge(source_id, target_id)\n",
+    "                speaker_transitions_dict[get_agent_of_name(agents, source_id)].append(\n",
+    "                    get_agent_of_name(agents, name=target_id)\n",
+    "                )\n",
+    "\n",
     "\n",
     "# Adding edges between teams\n",
-    "graph.add_edge(\"A0\", \"B0\")\n",
-    "graph.add_edge(\"A0\", \"C0\")\n",
-    "graph.add_edge(\"B0\", \"A0\")\n",
-    "graph.add_edge(\"B0\", \"C0\")\n",
-    "graph.add_edge(\"C0\", \"A0\")\n",
-    "graph.add_edge(\"C0\", \"B0\")\n",
+    "speaker_transitions_dict[get_agent_of_name(agents, \"A0\")].append(get_agent_of_name(agents, name=\"B0\"))\n",
+    "speaker_transitions_dict[get_agent_of_name(agents, \"A0\")].append(get_agent_of_name(agents, name=\"C0\"))\n",
+    "speaker_transitions_dict[get_agent_of_name(agents, \"B0\")].append(get_agent_of_name(agents, name=\"A0\"))\n",
+    "speaker_transitions_dict[get_agent_of_name(agents, \"B0\")].append(get_agent_of_name(agents, name=\"C0\"))\n",
+    "speaker_transitions_dict[get_agent_of_name(agents, \"C0\")].append(get_agent_of_name(agents, name=\"A0\"))\n",
+    "speaker_transitions_dict[get_agent_of_name(agents, \"C0\")].append(get_agent_of_name(agents, name=\"B0\"))\n",
+    "\n",
+    "\n",
+    "# Visualization only\n",
     "\n",
+    "graph = nx.DiGraph()\n",
     "\n",
-    "# Updating node A0\n",
-    "graph.nodes[\"A0\"][\"first_round_speaker\"] = True\n",
+    "# Add nodes\n",
+    "graph.add_nodes_from([agent.name for agent in agents])\n",
     "\n",
+    "# Add edges\n",
+    "for key, value in speaker_transitions_dict.items():\n",
+    "    for agent in value:\n",
+    "        graph.add_edge(key.name, agent.name)\n",
     "\n",
-    "def get_node_color(node):\n",
-    "    if graph.nodes[node].get(\"first_round_speaker\", False):\n",
-    "        return \"red\"\n",
-    "    else:\n",
-    "        return \"green\"\n",
+    "# Visualize\n",
     "\n",
     "\n",
     "# Draw the graph with secret values annotated\n",
@@ -530,11 +439,11 @@
     "pos = nx.spring_layout(graph)  # positions for all nodes\n",
     "\n",
     "# Draw nodes with their colors\n",
-    "nx.draw(graph, pos, with_labels=True, font_weight=\"bold\", node_color=[get_node_color(node) for node in graph])\n",
+    "nx.draw(graph, pos, with_labels=True, font_weight=\"bold\")\n",
     "\n",
     "# Annotate secret values\n",
     "for node, (x, y) in pos.items():\n",
-    "    secret_value = graph.nodes[node][\"secret_value\"]\n",
+    "    secret_value = secret_values[node]\n",
     "    plt.text(x, y + 0.1, s=f\"Secret: {secret_value}\", horizontalalignment=\"center\")\n",
     "\n",
     "plt.show()"
@@ -542,7 +451,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -570,9 +479,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:root:Warning: There are agents in self.agents not in graph.\n"
+     ]
+    },
     {
      "name": "stdout",
      "output_type": "stream",
@@ -580,196 +496,141 @@
       "\u001b[33mA0\u001b[0m (to chat_manager):\n",
       "\n",
       "\n",
-      "                        There are 9 players in this game, split equally into Teams A, B, C. Therefore each team has 3 players, including the team leader. \n",
-      "                        The task is to find out the sum of chocolate count from all nine players. I will now start with my team. \n",
+      "                        There are 9 players in this game, split equally into Teams A, B, C. Therefore each team has 3 players, including the team leader.\n",
+      "                        The task is to find out the sum of chocolate count from all nine players. I will now start with my team.\n",
       "                        NEXT: A1\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "Suggested next speaker from the last message: A1\n",
-      "Current previous speaker: A0\n",
-      "Eligible speakers based on previous speaker: ['A1', 'A2', 'B0', 'C0']\n",
-      "Eligible speakers based on graph and previous speaker A0: ['A1', 'A2', 'B0', 'C0']\n",
-      "Selecting from eligible speakers: ['A1', 'A2', 'B0', 'C0']\n",
-      "suggested_next is in eligible_speakers\n",
-      "Selected next speaker: A1\n",
       "\u001b[33mA1\u001b[0m (to chat_manager):\n",
       "\n",
-      "As A1 I have 1 chocolate right now. Our team leader A0, please note my count.\n",
-      "\n",
-      "NEXT: A2\n",
+      "Sure, I, A1, have 3 chocolates. NEXT: A2\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "Suggested next speaker from the last message: A2\n",
-      "Current previous speaker: A1\n",
-      "Eligible speakers based on previous speaker: ['A0', 'A2']\n",
-      "Eligible speakers based on graph and previous speaker A1: ['A0', 'A2']\n",
-      "Selecting from eligible speakers: ['A0', 'A2']\n",
-      "suggested_next is in eligible_speakers\n",
-      "Selected next speaker: A2\n",
       "\u001b[33mA2\u001b[0m (to chat_manager):\n",
       "\n",
-      "As part of Team A, I have 2 chocolates at the moment.\n",
+      "As A2, I have 5 chocolates.\n",
       "\n",
-      "Now that each member of Team A has reported their tally, our team leader A0 should be able to calculate and report our team's total sum to the other team leaders. \n",
-      "\n",
-      "NEXT: A0.\n",
+      "So currently our tally is:\n",
+      "A0:?, A1:3, A2:5, B0:?, B1:?, B2:?, C0:?, C1:?, C2:?\n",
+      "  \n",
+      "NEXT: A0\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "Suggested next speaker from the last message: A0\n",
-      "Current previous speaker: A2\n",
-      "Eligible speakers based on previous speaker: ['A0', 'A1']\n",
-      "Eligible speakers based on graph and previous speaker A2: ['A0', 'A1']\n",
-      "Selecting from eligible speakers: ['A0', 'A1']\n",
-      "suggested_next is in eligible_speakers\n",
-      "Selected next speaker: A0\n",
       "\u001b[33mA0\u001b[0m (to chat_manager):\n",
       "\n",
-      "I, A0, have 4 chocolates, A1 reported having 1 chocolate, and A2 reported having 2 chocolates. So the total chocolate count for Team A is 4 + 1 + 2 = 7 chocolates. \n",
+      "Okay, as A0, I have 1 chocolate.\n",
+      "\n",
+      "Therefore, total chocolate count of team A is: \n",
+      "1 (A0's chocolates) + 3 (A1's chocolates) + 5 (A2's chocolates) = 9 chocolates \n",
       "\n",
-      "I'm saving this in our JSON format as: \n",
-      "A0:4, A1:1, A2:2,\n",
-      "B0:?, B1:?, B2:?,\n",
+      "The running tally is:\n",
+      "A0:1, A1:3, A2:5, \n",
+      "B0:?, B1:?, B2:?, \n",
       "C0:?, C1:?, C2:?\n",
       "\n",
-      "Let's move on to Team B for their counts.\n",
-      "NEXT: B0.\n",
+      "I suggest we move on to the next team. \n",
+      "\n",
+      "NEXT: B0\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "Suggested next speaker from the last message: B0\n",
-      "Current previous speaker: A0\n",
-      "Eligible speakers based on previous speaker: ['A1', 'A2', 'B0', 'C0']\n",
-      "Eligible speakers based on graph and previous speaker A0: ['A1', 'A2', 'B0', 'C0']\n",
-      "Selecting from eligible speakers: ['A1', 'A2', 'B0', 'C0']\n",
-      "suggested_next is in eligible_speakers\n",
-      "Selected next speaker: B0\n",
       "\u001b[33mB0\u001b[0m (to chat_manager):\n",
       "\n",
-      "As B0, the team leader of Team B, I already have my count which is 5 chocolates. Now, I will ask the other members of my team to report their counts. \n",
+      "As B0, I need to gather the count from my team members. \n",
       "\n",
       "NEXT: B1\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "Suggested next speaker from the last message: B1\n",
-      "Current previous speaker: B0\n",
-      "Eligible speakers based on previous speaker: ['B1', 'B2', 'A0', 'C0']\n",
-      "Eligible speakers based on graph and previous speaker B0: ['A0', 'B1', 'B2', 'C0']\n",
-      "Selecting from eligible speakers: ['A0', 'B1', 'B2', 'C0']\n",
-      "suggested_next is in eligible_speakers\n",
-      "Selected next speaker: B1\n",
       "\u001b[33mB1\u001b[0m (to chat_manager):\n",
       "\n",
-      "As B1, I have 4 chocolates currently. It's now time for our team member B2 to report their count. \n",
+      "As B1, I have 1 chocolate. \n",
       "\n",
-      "NEXT: B2.\n",
+      "NEXT: B2\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "Suggested next speaker from the last message: B2\n",
-      "Current previous speaker: B1\n",
-      "Eligible speakers based on previous speaker: ['B0', 'B2']\n",
-      "Eligible speakers based on graph and previous speaker B1: ['B0', 'B2']\n",
-      "Selecting from eligible speakers: ['B0', 'B2']\n",
-      "suggested_next is in eligible_speakers\n",
-      "Selected next speaker: B2\n",
       "\u001b[33mB2\u001b[0m (to chat_manager):\n",
       "\n",
-      "As B2, I have 1 chocolate right now. Our team leader B0, please note my count.\n",
+      "As B2, I have 4 chocolates. \n",
       "\n",
-      "NEXT: B0.\n",
+      "So currently, our team B tally is:\n",
+      "B0:?, B1:1, B2:4 \n",
+      "\n",
+      "NEXT: B0\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "Suggested next speaker from the last message: B0\n",
-      "Current previous speaker: B2\n",
-      "Eligible speakers based on previous speaker: ['B0', 'B1']\n",
-      "Eligible speakers based on graph and previous speaker B2: ['B0', 'B1']\n",
-      "Selecting from eligible speakers: ['B0', 'B1']\n",
-      "suggested_next is in eligible_speakers\n",
-      "Selected next speaker: B0\n",
       "\u001b[33mB0\u001b[0m (to chat_manager):\n",
       "\n",
-      "As B0, I acknowledge receipt of both B1 and B2's counts. I have 5 chocolates, B1 has 4 and B2 has 1. Adding these counts together, Team B has a total of 5 + 4 + 1 = 10 chocolates.\n",
+      "As B0, I have 1 chocolate. So, the total chocolate count for team B is:\n",
+      "1 (B0's chocolates) + 1 (B1's chocolates) + 4 (B2's chocolates) = 6 chocolates.\n",
       "\n",
-      "Updating the JSON tally:\n",
-      "A0:4, A1:1, A2:2,\n",
-      "B0:5, B1:4, B2:1,\n",
+      "The updated tally is:\n",
+      "A0:1, A1:3, A2:5, \n",
+      "B0:1, B1:1, B2:4, \n",
       "C0:?, C1:?, C2:?\n",
       "\n",
-      "Now it's time for Team C to share their counts. \n",
+      "I suggest we move on to the next team.\n",
       "\n",
-      "NEXT: C0.\n",
+      "NEXT: C0\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "Suggested next speaker from the last message: C0\n",
-      "Current previous speaker: B0\n",
-      "Eligible speakers based on previous speaker: ['B1', 'B2', 'A0', 'C0']\n",
-      "Eligible speakers based on graph and previous speaker B0: ['A0', 'B1', 'B2', 'C0']\n",
-      "Selecting from eligible speakers: ['A0', 'B1', 'B2', 'C0']\n",
-      "suggested_next is in eligible_speakers\n",
-      "Selected next speaker: C0\n",
       "\u001b[33mC0\u001b[0m (to chat_manager):\n",
       "\n",
-      "As C0, I currently have 2 chocolates. I will need the counts from C1 and C2 to complete our team's tally. \n",
+      "As C0, I will now gather the count from my team members. \n",
       "\n",
-      "NEXT: C1.\n",
+      "NEXT: C1\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "Suggested next speaker from the last message: C1\n",
-      "Current previous speaker: C0\n",
-      "Eligible speakers based on previous speaker: ['C1', 'C2', 'A0', 'B0']\n",
-      "Eligible speakers based on graph and previous speaker C0: ['A0', 'B0', 'C1', 'C2']\n",
-      "Selecting from eligible speakers: ['A0', 'B0', 'C1', 'C2']\n",
-      "suggested_next is in eligible_speakers\n",
-      "Selected next speaker: C1\n",
       "\u001b[33mC1\u001b[0m (to chat_manager):\n",
       "\n",
-      "As C1, I have 2 chocolates. C2, please share your count so that our team leader, C0, can calculate our team's total.\n",
+      "As C1, I have 2 chocolates.\n",
       "\n",
-      "NEXT: C2.\n",
+      "NEXT: C2\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "Suggested next speaker from the last message: C2\n",
-      "Current previous speaker: C1\n",
-      "Eligible speakers based on previous speaker: ['C0', 'C2']\n",
-      "Eligible speakers based on graph and previous speaker C1: ['C0', 'C2']\n",
-      "Selecting from eligible speakers: ['C0', 'C2']\n",
-      "suggested_next is in eligible_speakers\n",
-      "Selected next speaker: C2\n",
       "\u001b[33mC2\u001b[0m (to chat_manager):\n",
       "\n",
-      "As C2, I have 5 chocolates. Now our team leader, C0, can calculate our team's total sum.\n",
+      "As C2, I have 1 chocolate.\n",
+      "\n",
+      "So currently, our team C tally is:\n",
+      "C0:?, C1:2, C2:1\n",
       "\n",
-      "NEXT: C0.\n",
+      "NEXT: C0\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "Suggested next speaker from the last message: C0\n",
-      "Current previous speaker: C2\n",
-      "Eligible speakers based on previous speaker: ['C0', 'C1']\n",
-      "Eligible speakers based on graph and previous speaker C2: ['C0', 'C1']\n",
-      "Selecting from eligible speakers: ['C0', 'C1']\n",
-      "suggested_next is in eligible_speakers\n",
-      "Selected next speaker: C0\n",
       "\u001b[33mC0\u001b[0m (to chat_manager):\n",
       "\n",
-      "As C0, I have 2 chocolates, C1 reported having 2 chocolates, and C2 reported having 5 chocolates. So, the total chocolate count for Team C is 2 + 2 + 5 = 9 chocolates.\n",
+      "As C0, I'm the team leader and I have 1 chocolate. So, the total chocolate count for team C is:\n",
+      "1 (C0's chocolates) + 2 (C1's chocolates) + 1 (C2's chocolates) = 4 chocolates.\n",
       "\n",
-      "Updating the JSON tally:\n",
-      "A0:4, A1:1, A2:2,\n",
-      "B0:5, B1:4, B2:1,\n",
-      "C0:2, C1:2, C2:5\n",
+      "The final tally is:\n",
+      "A0:1, A1:3, A2:5, \n",
+      "B0:1, B1:1, B2:4, \n",
+      "C0:1, C1:2, C2:1\n",
       "\n",
-      "Let's sum up all the team totals. \n",
+      "Now, the sum of chocolates from all nine players is:\n",
+      "9 (team A's chocolates) + 6 (team B's chocolates) + 4 (team C's chocolates) = 19 chocolates.\n",
       "\n",
       "TERMINATE.\n",
       "\n",
+      "\n",
       "--------------------------------------------------------------------------------\n"
      ]
     }
    ],
    "source": [
-    "group_chat = CustomGroupChat(agents=agents, messages=[], max_round=20, graph=graph)  # Include all agents\n",
+    "group_chat = GroupChat(\n",
+    "    agents=agents,\n",
+    "    messages=[],\n",
+    "    max_round=20,\n",
+    "    allow_repeat_speaker=None,\n",
+    "    allowed_or_disallowed_speaker_transitions=speaker_transitions_dict,\n",
+    "    speaker_transitions_type=\"allowed\",\n",
+    ")\n",
     "\n",
     "\n",
     "# Create the manager\n",
-    "manager = autogen.GroupChatManager(groupchat=group_chat, llm_config=llm_config)\n",
+    "manager = autogen.GroupChatManager(\n",
+    "    groupchat=group_chat, llm_config=llm_config, code_execution_config=False, is_termination_msg=is_termination_msg\n",
+    ")\n",
     "\n",
     "\n",
     "# Initiates the chat with Alice\n",
@@ -799,7 +660,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.13"
+   "version": "3.11.7"
   }
  },
  "nbformat": 4,
diff --git a/notebook/agentchat_hierarchy_flow_using_select_speaker.ipynb b/notebook/agentchat_hierarchy_flow_using_select_speaker.ipynb
deleted file mode 100644
index f14b9e769145..000000000000
--- a/notebook/agentchat_hierarchy_flow_using_select_speaker.ipynb
+++ /dev/null
@@ -1,406 +0,0 @@
-{
- "cells": [
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a href=\"https://colab.research.google.com/github/microsoft/autogen/blob/main/notebook/agentchat_hierarchy_flow_using_select_speaker.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
-   ]
-  },
-  {
-   "attachments": {
-    "e6173a72-fa95-49db-83c8-899608860952.png": {
-     "image/png": "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"
-    }
-   },
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Auto Generated Agent Chat: Hierarchy flow using select_speaker\n",
-    "\n",
-    "AutoGen offers conversable agents powered by LLM, tool, or human, which can be used to perform tasks collectively via automated chat. This framework allows tool use and human participation through multi-agent conversation.\n",
-    "Please find documentation about this feature [here](https://microsoft.github.io/autogen/docs/Use-Cases/agent_chat).\n",
-    "\n",
-    "This notebook is about restricting the transition paths within agents. Suppose we have the following setup:\n",
-    "\n",
-    "![image.png](attachment:e6173a72-fa95-49db-83c8-899608860952.png)\n",
-    "\n",
-    "Constraints:\n",
-    "- Team leaders can talk amongst themselves\n",
-    "- A team can talk amongst themselves\n",
-    "\n",
-    "Benefits\n",
-    "- By limiting team members can talk to team members, we bring focus to the team.\n",
-    "- Information flow from Team A to Team B is made more efficient to let the X1s talk amongst themselves. It is more efficient as group members can only pass their turns to their group-mates, keeping the discussion tight.\n",
-    "\n",
-    "\n",
-    "## Requirements\n",
-    "\n",
-    "AutoGen requires `Python>=3.8`. To run this notebook example, please install:\n",
-    "```bash\n",
-    "pip install pyautogen\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%%capture --no-stderr\n",
-    "# %pip install \"pyautogen>=0.2.3\""
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Set your API Endpoint\n",
-    "\n",
-    "The [`config_list_from_json`](https://microsoft.github.io/autogen/docs/reference/oai/openai_utils#config_list_from_json) function loads a list of configurations from an environment variable or a json file."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "0.2.3\n"
-     ]
-    }
-   ],
-   "source": [
-    "import random\n",
-    "from typing import Dict, List\n",
-    "\n",
-    "import autogen\n",
-    "from autogen.agentchat.agent import Agent\n",
-    "from autogen.agentchat.assistant_agent import AssistantAgent\n",
-    "from autogen.agentchat.groupchat import GroupChat\n",
-    "\n",
-    "print(autogen.__version__)\n",
-    "\n",
-    "# The default config list in notebook.\n",
-    "config_list_gpt4 = autogen.config_list_from_json(\n",
-    "    \"OAI_CONFIG_LIST\",\n",
-    "    filter_dict={\n",
-    "        \"model\": [\"gpt-4\", \"gpt4\", \"gpt-4-32k\", \"gpt-4-32k-0314\", \"gpt-4-32k-v0314\"],\n",
-    "    },\n",
-    ")\n",
-    "\n",
-    "# Contributor's config - Please replace with your own, I have replaced mine with an Azure OpenAI endpoint.\n",
-    "config_list_gpt4 = autogen.config_list_from_json(\n",
-    "    \"OAI_CONFIG_LIST\",\n",
-    "    filter_dict={\n",
-    "        \"model\": [\"gpt-4\"],\n",
-    "    },\n",
-    ")"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "It first looks for environment variable \"OAI_CONFIG_LIST\" which needs to be a valid json string. If that variable is not found, it then looks for a json file named \"OAI_CONFIG_LIST\". It filters the configs by models (you can filter by other keys as well). Only the gpt-4 models are kept in the list based on the filter condition.\n",
-    "\n",
-    "The config list looks like the following:\n",
-    "```python\n",
-    "config_list = [\n",
-    "    {\n",
-    "        'model': 'gpt-4',\n",
-    "        'api_key': '<your OpenAI API key here>',\n",
-    "    },\n",
-    "    {\n",
-    "        'model': 'gpt-4',\n",
-    "        'api_key': '<your Azure OpenAI API key here>',\n",
-    "        'base_url': '<your Azure OpenAI API base here>',\n",
-    "        'api_type': 'azure',\n",
-    "        'api_version': '2023-06-01-preview',\n",
-    "    },\n",
-    "    {\n",
-    "        'model': 'gpt-4-32k',\n",
-    "        'api_key': '<your Azure OpenAI API key here>',\n",
-    "        'base_url': '<your Azure OpenAI API base here>',\n",
-    "        'api_type': 'azure',\n",
-    "        'api_version': '2023-06-01-preview',\n",
-    "    },\n",
-    "]\n",
-    "```\n",
-    "\n",
-    "If you open this notebook in colab, you can upload your files by clicking the file icon on the left panel and then choosing \"upload file\" icon.\n",
-    "\n",
-    "You can set the value of config_list in other ways you prefer, e.g., loading from a YAML file."
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Extending GroupChat\n",
-    "\n",
-    "\n",
-    "Custom Speaker Selection Logic: The CustomGroupChat class allows us to define our own logic for selecting the next speaker in the group chat. The base GroupChat class has a default logic that may not be suitable for all scenarios.\n",
-    "\n",
-    "\n",
-    "Content-Driven Speaker Selection: This custom class lets us select the next speaker based on the content of the last message, like \"NEXT: A2\" or \"TERMINATE\". The base GroupChat class does not have this capability.\n",
-    "\n",
-    "Team-Based Logic: The custom class enables team-based logic for speaker selection. It allows the next speaker to be chosen from the same team as the last speaker or from a pool of team leaders, which is something the base GroupChat class does not offer.\n",
-    "\n",
-    "Previous Speaker Exclusion: The CustomGroupChat class includes logic to prevent the last speaker and the previous speaker from being selected again immediately, which adds more dynamism to the conversation.\n",
-    "\n",
-    "Flexibility: Extending the base GroupChat class allows us to preserve the existing functionalities and methods while adding new features specific to our needs. This makes the code more modular and easier to maintain.\n",
-    "\n",
-    "Special Cases Handling: The custom class can also handle special cases, like terminating the chat or transitioning to a 'User_proxy', directly within its select_speaker method.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "llm_config = {\"config_list\": config_list_gpt4, \"cache_seed\": 42}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class CustomGroupChat(GroupChat):\n",
-    "    def __init__(self, agents, messages, max_round=10):\n",
-    "        super().__init__(agents, messages, max_round)\n",
-    "        self.previous_speaker = None  # Keep track of the previous speaker\n",
-    "\n",
-    "    def select_speaker(self, last_speaker: Agent, selector: AssistantAgent):\n",
-    "        # Check if last message suggests a next speaker or termination\n",
-    "        last_message = self.messages[-1] if self.messages else None\n",
-    "        if last_message:\n",
-    "            if \"NEXT:\" in last_message[\"content\"]:\n",
-    "                suggested_next = last_message[\"content\"].split(\"NEXT: \")[-1].strip()\n",
-    "                print(f\"Extracted suggested_next = {suggested_next}\")\n",
-    "                try:\n",
-    "                    return self.agent_by_name(suggested_next)\n",
-    "                except ValueError:\n",
-    "                    pass  # If agent name is not valid, continue with normal selection\n",
-    "            elif \"TERMINATE\" in last_message[\"content\"]:\n",
-    "                try:\n",
-    "                    return self.agent_by_name(\"User_proxy\")\n",
-    "                except ValueError:\n",
-    "                    pass  # If 'User_proxy' is not a valid name, continue with normal selection\n",
-    "\n",
-    "        team_leader_names = [agent.name for agent in self.agents if agent.name.endswith(\"1\")]\n",
-    "\n",
-    "        if last_speaker.name in team_leader_names:\n",
-    "            team_letter = last_speaker.name[0]\n",
-    "            possible_next_speakers = [\n",
-    "                agent\n",
-    "                for agent in self.agents\n",
-    "                if (agent.name.startswith(team_letter) or agent.name in team_leader_names)\n",
-    "                and agent != last_speaker\n",
-    "                and agent != self.previous_speaker\n",
-    "            ]\n",
-    "        else:\n",
-    "            team_letter = last_speaker.name[0]\n",
-    "            possible_next_speakers = [\n",
-    "                agent\n",
-    "                for agent in self.agents\n",
-    "                if agent.name.startswith(team_letter) and agent != last_speaker and agent != self.previous_speaker\n",
-    "            ]\n",
-    "\n",
-    "        self.previous_speaker = last_speaker\n",
-    "\n",
-    "        if possible_next_speakers:\n",
-    "            next_speaker = random.choice(possible_next_speakers)\n",
-    "            return next_speaker\n",
-    "        else:\n",
-    "            return None"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Termination message detection\n",
-    "\n",
-    "\n",
-    "def is_termination_msg(content) -> bool:\n",
-    "    have_content = content.get(\"content\", None) is not None\n",
-    "    if have_content and \"TERMINATE\" in content[\"content\"]:\n",
-    "        return True\n",
-    "    return False"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u001b[33mB2\u001b[0m (to chat_manager):\n",
-      "\n",
-      "Find the product of x and y, the other agents know x and y.\n",
-      "\n",
-      "--------------------------------------------------------------------------------\n",
-      "\u001b[33mB1\u001b[0m (to chat_manager):\n",
-      "\n",
-      "NEXT: A1\n",
-      "Can you or any of your team members provide the values for x and y? B2 needs these values to complete a task.\n",
-      "\n",
-      "--------------------------------------------------------------------------------\n",
-      "Extracted suggested_next = A1\n",
-      "Can you or any of your team members provide the values for x and y? B2 needs these values to complete a task.\n",
-      "\u001b[33mA1\u001b[0m (to chat_manager):\n",
-      "\n",
-      "Sure B1, let me check with my team. \n",
-      "\n",
-      "NEXT: A2, A3\n",
-      "Could either of you provide the values for x and y? B2 needs these values to complete a task.\n",
-      "\n",
-      "--------------------------------------------------------------------------------\n",
-      "Extracted suggested_next = A2, A3\n",
-      "Could either of you provide the values for x and y? B2 needs these values to complete a task.\n",
-      "\u001b[33mA2\u001b[0m (to chat_manager):\n",
-      "\n",
-      "Sure, I hold the value for x. We know x is equal to 9. A3, could you please provide the value of y?\n",
-      "\n",
-      "--------------------------------------------------------------------------------\n",
-      "\u001b[33mA3\u001b[0m (to chat_manager):\n",
-      "\n",
-      "Sure, the value of y that I hold is 5.\n",
-      "\n",
-      "--------------------------------------------------------------------------------\n",
-      "\u001b[33mA1\u001b[0m (to chat_manager):\n",
-      "\n",
-      "NEXT: B1\n",
-      "The values we have for x and y are x=9, y=5. Could you pass this information to B2 to complete the task?\n",
-      "\n",
-      "--------------------------------------------------------------------------------\n",
-      "Extracted suggested_next = B1\n",
-      "The values we have for x and y are x=9, y=5. Could you pass this information to B2 to complete the task?\n",
-      "\u001b[33mB1\u001b[0m (to chat_manager):\n",
-      "\n",
-      "Absolutely, A1.\n",
-      "\n",
-      "NEXT: B2\n",
-      "The values for x and y are x=9, y=5. Could you please compute the product of x and y?\n",
-      "\n",
-      "--------------------------------------------------------------------------------\n",
-      "Extracted suggested_next = B2\n",
-      "The values for x and y are x=9, y=5. Could you please compute the product of x and y?\n",
-      "\u001b[33mB2\u001b[0m (to chat_manager):\n",
-      "\n",
-      "Sure, the product of x and y, where x=9 and y=5, is 45.\n",
-      "\n",
-      "TERMINATE.\n",
-      "\n",
-      "--------------------------------------------------------------------------------\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Initialization\n",
-    "agents_A = [\n",
-    "    AssistantAgent(\n",
-    "        name=\"A1\",\n",
-    "        system_message=\"You are a team leader A1, your team consists of A2, A3. You can talk to the other team leader B1, whose team member is B2.\",\n",
-    "        llm_config=llm_config,\n",
-    "    ),\n",
-    "    AssistantAgent(\n",
-    "        name=\"A2\",\n",
-    "        system_message=\"You are team member A2, you know the secret value of x but not y, x = 9. Tell others x to cooperate.\",\n",
-    "        llm_config=llm_config,\n",
-    "    ),\n",
-    "    AssistantAgent(\n",
-    "        name=\"A3\",\n",
-    "        system_message=\"You are team member A3, You know the secret value of y but not x, y = 5. Tell others y to cooperate.\",\n",
-    "        llm_config=llm_config,\n",
-    "    ),\n",
-    "]\n",
-    "\n",
-    "agents_B = [\n",
-    "    AssistantAgent(\n",
-    "        name=\"B1\",\n",
-    "        system_message=\"You are a team leader B1, your team consists of B2. You can talk to the other team leader A1, whose team member is A2, A3. Use NEXT: A1 to suggest talking to A1.\",\n",
-    "        llm_config=llm_config,\n",
-    "    ),\n",
-    "    AssistantAgent(\n",
-    "        name=\"B2\",\n",
-    "        system_message=\"You are team member B2. Your task is to find out the value of x and y and compute the product. Once you have the answer, say out the answer and append a new line with TERMINATE.\",\n",
-    "        llm_config=llm_config,\n",
-    "    ),\n",
-    "]\n",
-    "\n",
-    "# Terminates the conversation when TERMINATE is detected.\n",
-    "user_proxy = autogen.UserProxyAgent(\n",
-    "    name=\"User_proxy\",\n",
-    "    system_message=\"Terminator admin.\",\n",
-    "    code_execution_config=False,\n",
-    "    is_termination_msg=is_termination_msg,\n",
-    "    human_input_mode=\"NEVER\",\n",
-    ")\n",
-    "\n",
-    "list_of_agents = agents_A + agents_B\n",
-    "list_of_agents.append(user_proxy)\n",
-    "\n",
-    "# Create CustomGroupChat\n",
-    "group_chat = CustomGroupChat(\n",
-    "    agents=list_of_agents,  # Include all agents\n",
-    "    messages=[\n",
-    "        'Everyone cooperate and help agent B2 in his task. Team A has A1, A2, A3. Team B has B1, B2. Only members of the same team can talk to one another. Only team leaders (names ending with 1) can talk amongst themselves. You must use \"NEXT: B1\" to suggest talking to B1 for example; You can suggest only one person, you cannot suggest yourself or the previous speaker; You can also dont suggest anyone.'\n",
-    "    ],\n",
-    "    max_round=30,\n",
-    ")\n",
-    "\n",
-    "\n",
-    "# Create the manager\n",
-    "llm_config = {\n",
-    "    \"config_list\": config_list_gpt4,\n",
-    "    \"cache_seed\": None,\n",
-    "}  # cache_seed is None because we want to observe if there is any communication pattern difference if we reran the group chat.\n",
-    "manager = autogen.GroupChatManager(groupchat=group_chat, llm_config=llm_config)\n",
-    "\n",
-    "\n",
-    "# Initiates the chat with B2\n",
-    "agents_B[1].initiate_chat(manager, message=\"Find the product of x and y, the other agents know x and y.\")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.13"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/setup.py b/setup.py
index 3dbdfad05159..e3300d790c47 100644
--- a/setup.py
+++ b/setup.py
@@ -51,7 +51,7 @@
         "autobuild": ["chromadb", "sentence-transformers", "huggingface-hub"],
         "teachable": ["chromadb"],
         "lmm": ["replicate", "pillow"],
-        "graphs": ["networkx~=3.2.1", "matplotlib~=3.8.1"],
+        "graph": ["networkx", "matplotlib"],
         "websurfer": ["beautifulsoup4", "markdownify", "pdfminer.six", "pathvalidate"],
         "redis": ["redis"],
     },
diff --git a/test/agentchat/test_groupchat.py b/test/agentchat/test_groupchat.py
index 5ad4843088ab..eb614325649f 100644
--- a/test/agentchat/test_groupchat.py
+++ b/test/agentchat/test_groupchat.py
@@ -3,6 +3,8 @@
 import builtins
 import autogen
 import json
+import sys
+from autogen import Agent, GroupChat
 
 
 def test_func_call_groupchat():
@@ -199,27 +201,11 @@ def _test_n_agents_less_than_3(method):
             "This is bob speaking.",
         ] * 3
 
-    # test one agent
-    groupchat = autogen.GroupChat(
-        agents=[agent1],
-        messages=[],
-        max_round=6,
-        speaker_selection_method="round_robin",
-        allow_repeat_speaker=False,
-    )
-    with pytest.raises(ValueError):
-        group_chat_manager = autogen.GroupChatManager(groupchat=groupchat, llm_config=False)
-        agent1.initiate_chat(group_chat_manager, message="This is alice speaking.")
-
     # test zero agent
-    groupchat = autogen.GroupChat(
-        agents=[],
-        messages=[],
-        max_round=6,
-        speaker_selection_method="round_robin",
-        allow_repeat_speaker=False,
-    )
     with pytest.raises(ValueError):
+        groupchat = autogen.GroupChat(
+            agents=[], messages=[], max_round=6, speaker_selection_method="round_robin", allow_repeat_speaker=False
+        )
         group_chat_manager = autogen.GroupChatManager(groupchat=groupchat, llm_config=False)
         agent1.initiate_chat(group_chat_manager, message="This is alice speaking.")
 
@@ -504,6 +490,104 @@ def test_selection_helpers():
         groupchat.manual_select_speaker()
 
 
+def test_init_default_parameters():
+    agents = [Agent(name=f"Agent{i}") for i in range(3)]
+    group_chat = GroupChat(agents=agents, messages=[], max_round=3)
+    for agent in agents:
+        assert set([a.name for a in group_chat.allowed_speaker_transitions_dict[agent]]) == set(
+            [a.name for a in agents]
+        )
+
+
+def test_graph_parameters():
+    agents = [Agent(name=f"Agent{i}") for i in range(3)]
+    with pytest.raises(ValueError):
+        GroupChat(
+            agents=agents,
+            messages=[],
+            max_round=3,
+            allow_repeat_speaker=None,
+            allowed_or_disallowed_speaker_transitions={agents[0]: [agents[1]], agents[1]: [agents[2]]},
+        )
+
+    with pytest.raises(AssertionError):
+        GroupChat(
+            agents=agents,
+            messages=[],
+            max_round=3,
+            allow_repeat_speaker=None,
+            allowed_or_disallowed_speaker_transitions={agents[0]: [agents[1]], agents[1]: [agents[2]]},
+            speaker_transitions_type="a",
+        )
+
+    group_chat = GroupChat(
+        agents=agents,
+        messages=[],
+        max_round=3,
+        allow_repeat_speaker=None,
+        allowed_or_disallowed_speaker_transitions={agents[0]: [agents[1]], agents[1]: [agents[2]]},
+        speaker_transitions_type="allowed",
+    )
+    assert "Agent0" in group_chat.agent_names
+
+
+def test_graph_validity_check():
+    agents = [Agent(name=f"Agent{i}") for i in range(3)]
+    invalid_transitions = {agents[0]: []}
+    with pytest.raises(ValueError):
+        GroupChat(
+            agents=agents,
+            messages=[],
+            allowed_or_disallowed_speaker_transitions=invalid_transitions,
+            speaker_transitions_type="allowed",
+        )
+
+
+def test_graceful_exit_before_max_round():
+    agent1 = autogen.ConversableAgent(
+        "alice",
+        max_consecutive_auto_reply=10,
+        human_input_mode="NEVER",
+        llm_config=False,
+        default_auto_reply="This is alice speaking.",
+    )
+    agent2 = autogen.ConversableAgent(
+        "bob",
+        max_consecutive_auto_reply=10,
+        human_input_mode="NEVER",
+        llm_config=False,
+        default_auto_reply="This is bob speaking.",
+    )
+    agent3 = autogen.ConversableAgent(
+        "sam",
+        max_consecutive_auto_reply=10,
+        human_input_mode="NEVER",
+        llm_config=False,
+        default_auto_reply="This is sam speaking. TERMINATE",
+    )
+
+    # This speaker_transitions limits the transition to be only from agent1 to agent2, and from agent2 to agent3 and end.
+    allowed_or_disallowed_speaker_transitions = {agent1: [agent2], agent2: [agent3]}
+
+    # Test empty is_termination_msg function
+    groupchat = autogen.GroupChat(
+        agents=[agent1, agent2, agent3],
+        messages=[],
+        speaker_selection_method="round_robin",
+        max_round=10,
+        allow_repeat_speaker=None,
+        allowed_or_disallowed_speaker_transitions=allowed_or_disallowed_speaker_transitions,
+        speaker_transitions_type="allowed",
+    )
+
+    group_chat_manager = autogen.GroupChatManager(groupchat=groupchat, llm_config=False, is_termination_msg=None)
+
+    agent1.initiate_chat(group_chat_manager, message="'None' is_termination_msg function.")
+
+    # Note that 3 is much lower than 10 (max_round), so the conversation should end before 10 rounds.
+    assert len(groupchat.messages) == 3
+
+
 def test_clear_agents_history():
     agent1 = autogen.ConversableAgent(
         "alice",
@@ -604,4 +688,5 @@ def test_clear_agents_history():
     # test_termination()
     # test_next_agent()
     # test_invalid_allow_repeat_speaker()
+    # test_graceful_exit_before_max_round()
     test_clear_agents_history()
diff --git a/test/test_graph_utils.py b/test/test_graph_utils.py
new file mode 100644
index 000000000000..4411a1612781
--- /dev/null
+++ b/test/test_graph_utils.py
@@ -0,0 +1,165 @@
+import sys
+import pytest
+import logging
+from autogen.agentchat import Agent
+import autogen.graph_utils as gru
+
+
+class TestHelpers:
+    def test_has_self_loops(self):
+        # Setup test data
+        agents = [Agent(name=f"Agent{i}") for i in range(3)]
+        allowed_speaker_transitions = {
+            agents[0]: [agents[1], agents[2]],
+            agents[1]: [agents[2]],
+            agents[2]: [agents[0]],
+        }
+        allowed_speaker_transitions_with_self_loops = {
+            agents[0]: [agents[0], agents[1], agents[2]],
+            agents[1]: [agents[1], agents[2]],
+            agents[2]: [agents[0]],
+        }
+
+        # Testing
+        assert not gru.has_self_loops(allowed_speaker_transitions)
+        assert gru.has_self_loops(allowed_speaker_transitions_with_self_loops)
+
+
+class TestGraphUtilCheckGraphValidity:
+    def test_valid_structure(self):
+        agents = [Agent("agent1"), Agent("agent2"), Agent("agent3")]
+        valid_speaker_transitions_dict = {agent: [other_agent for other_agent in agents] for agent in agents}
+        gru.check_graph_validity(allowed_speaker_transitions_dict=valid_speaker_transitions_dict, agents=agents)
+
+    def test_graph_with_invalid_structure(self):
+        agents = [Agent("agent1"), Agent("agent2"), Agent("agent3")]
+        unseen_agent = Agent("unseen_agent")
+        invalid_speaker_transitions_dict = {unseen_agent: ["stranger"]}
+        with pytest.raises(ValueError):
+            gru.check_graph_validity(invalid_speaker_transitions_dict, agents)
+
+    def test_graph_with_invalid_string(self):
+        agents = [Agent("agent1"), Agent("agent2"), Agent("agent3")]
+        invalid_speaker_transitions_dict = {
+            agent: ["agent1"] for agent in agents
+        }  # 'agent1' is a string, not an Agent. Therefore raises an error.
+        with pytest.raises(ValueError):
+            gru.check_graph_validity(invalid_speaker_transitions_dict, agents)
+
+    def test_graph_with_unauthorized_self_loops(self):
+        agents = [Agent("agent1"), Agent("agent2"), Agent("agent3")]
+        # Creating a subset of agents allowed to have self-loops
+        allowed_repeat_speakers = agents[: len(agents) // 2]
+
+        # Constructing a speaker transitions dictionary with self-loops for all agents
+        # Ensuring at least one agent outside the allowed_repeat_speakers has a self-loop
+        speaker_transitions_dict_with_self_loop = {agent: agent for agent in agents}
+
+        # Testing the function with the constructed speaker transitions dict
+        with pytest.raises(ValueError):
+            gru.check_graph_validity(
+                speaker_transitions_dict_with_self_loop, agents, allow_repeat_speaker=allowed_repeat_speakers
+            )
+
+    # Test for Warning 1: Isolated agent nodes
+    def test_isolated_agent_nodes_warning(self, caplog):
+        agents = [Agent("agent1"), Agent("agent2"), Agent("agent3")]
+        # Create a speaker_transitions_dict where at least one agent is isolated
+        speaker_transitions_dict_with_isolation = {agents[0]: [agents[0], agents[1]], agents[1]: [agents[0]]}
+        # Add an isolated agent
+        speaker_transitions_dict_with_isolation[agents[2]] = []
+
+        with caplog.at_level(logging.WARNING):
+            gru.check_graph_validity(
+                allowed_speaker_transitions_dict=speaker_transitions_dict_with_isolation, agents=agents
+            )
+        assert "isolated" in caplog.text
+
+    # Test for Warning 2: Warning if the set of agents in allowed_speaker_transitions do not match agents
+    def test_warning_for_mismatch_in_agents(self, caplog):
+        agents = [Agent("agent1"), Agent("agent2"), Agent("agent3")]
+
+        # Test with missing agents in allowed_speaker_transitions_dict
+
+        unknown_agent_dict = {
+            agents[0]: [agents[0], agents[1], agents[2]],
+            agents[1]: [agents[0], agents[1], agents[2]],
+            agents[2]: [agents[0], agents[1], agents[2], Agent("unknown_agent")],
+        }
+
+        with caplog.at_level(logging.WARNING):
+            gru.check_graph_validity(allowed_speaker_transitions_dict=unknown_agent_dict, agents=agents)
+
+        assert "allowed_speaker_transitions do not match agents" in caplog.text
+
+    # Test for Warning 3: Warning if there is duplicated agents in allowed_speaker_transitions_dict
+    def test_warning_for_duplicate_agents(self, caplog):
+        agents = [Agent("agent1"), Agent("agent2"), Agent("agent3")]
+
+        # Construct an `allowed_speaker_transitions_dict` with duplicated agents
+        duplicate_agents_dict = {
+            agents[0]: [agents[0], agents[1], agents[2]],
+            agents[1]: [agents[0], agents[1], agents[2], agents[1]],
+            agents[2]: [agents[0], agents[1], agents[2], agents[0], agents[2]],
+        }
+
+        with caplog.at_level(logging.WARNING):
+            gru.check_graph_validity(allowed_speaker_transitions_dict=duplicate_agents_dict, agents=agents)
+
+        assert "duplicate" in caplog.text
+
+
+class TestGraphUtilInvertDisallowedToAllowed:
+    def test_basic_functionality(self):
+        agents = [Agent("agent1"), Agent("agent2"), Agent("agent3")]
+        disallowed_graph = {agents[0]: [agents[1]], agents[1]: [agents[0], agents[2]], agents[2]: []}
+        expected_allowed_graph = {
+            agents[0]: [agents[0], agents[2]],
+            agents[1]: [agents[1]],
+            agents[2]: [agents[0], agents[1], agents[2]],
+        }
+
+        # Compare names of agents
+        inverted = gru.invert_disallowed_to_allowed(disallowed_graph, agents)
+        assert inverted == expected_allowed_graph
+
+    def test_empty_disallowed_graph(self):
+        agents = [Agent("agent1"), Agent("agent2"), Agent("agent3")]
+        disallowed_graph = {}
+        expected_allowed_graph = {
+            agents[0]: [agents[0], agents[1], agents[2]],
+            agents[1]: [agents[0], agents[1], agents[2]],
+            agents[2]: [agents[0], agents[1], agents[2]],
+        }
+
+        # Compare names of agents
+        inverted = gru.invert_disallowed_to_allowed(disallowed_graph, agents)
+        assert inverted == expected_allowed_graph
+
+    def test_fully_disallowed_graph(self):
+        agents = [Agent("agent1"), Agent("agent2"), Agent("agent3")]
+
+        disallowed_graph = {
+            agents[0]: [agents[0], agents[1], agents[2]],
+            agents[1]: [agents[0], agents[1], agents[2]],
+            agents[2]: [agents[0], agents[1], agents[2]],
+        }
+        expected_allowed_graph = {agents[0]: [], agents[1]: [], agents[2]: []}
+
+        # Compare names of agents
+        inverted = gru.invert_disallowed_to_allowed(disallowed_graph, agents)
+        assert inverted == expected_allowed_graph
+
+    def test_disallowed_graph_with_nonexistent_agent(self):
+        agents = [Agent("agent1"), Agent("agent2"), Agent("agent3")]
+
+        disallowed_graph = {agents[0]: [Agent("nonexistent_agent")]}
+        # In this case, the function should ignore the nonexistent agent and proceed with the inversion
+        expected_allowed_graph = {
+            agents[0]: [agents[0], agents[1], agents[2]],
+            agents[1]: [agents[0], agents[1], agents[2]],
+            agents[2]: [agents[0], agents[1], agents[2]],
+        }
+        # Compare names of agents
+        inverted = gru.invert_disallowed_to_allowed(disallowed_graph, agents)
+        assert inverted == expected_allowed_graph
diff --git a/website/docs/Examples.md b/website/docs/Examples.md
index 7a829fe2063b..d727ee07ed91 100644
--- a/website/docs/Examples.md
+++ b/website/docs/Examples.md
@@ -20,7 +20,6 @@ Links to notebook examples:
    - Automated Data Visualization by Group Chat (with 3 group member agents and 1 manager agent) - [View Notebook](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_groupchat_vis.ipynb)
    - Automated Complex Task Solving by Group Chat (with 6 group member agents and 1 manager agent) - [View Notebook](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_groupchat_research.ipynb)
    - Automated Task Solving with Coding & Planning Agents - [View Notebook](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_planning.ipynb)
-   - Automated Task Solving with agents divided into 2 groups - [View Notebook](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_hierarchy_flow_using_select_speaker.ipynb)
    - Automated Task Solving with transition paths specified in a graph - [View Notebook](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_graph_modelling_language_using_select_speaker.ipynb)
    - Running a group chat as an inner-monolgue via the SocietyOfMindAgent - [View Notebook](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_society_of_mind.ipynb)
 
diff --git a/website/docs/Use-Cases/agent_chat.md b/website/docs/Use-Cases/agent_chat.md
index dbdc6a952073..cfe0fb529d06 100644
--- a/website/docs/Use-Cases/agent_chat.md
+++ b/website/docs/Use-Cases/agent_chat.md
@@ -313,12 +313,17 @@ On the one hand, one can achieve fully autonomous conversations after an initial
 
 #### Static and dynamic conversations
 
-By adopting the conversation-driven control with both programming language and natural language, AutoGen inherently allows dynamic conversation. Dynamic conversation allows the agent topology to change depending on the actual flow of conversation under different input problem instances, while the flow of a static conversation always follows a pre-defined topology. The dynamic conversation pattern is useful in complex applications where the patterns of interaction cannot be predetermined in advance. AutoGen provides two general approaches to achieving dynamic conversation:
+AutoGen, by integrating conversation-driven control utilizing both programming and natural language, inherently supports dynamic conversations. This dynamic nature allows the agent topology to adapt based on the actual conversation flow under varying input problem scenarios. Conversely, static conversations adhere to a predefined topology. Dynamic conversations are particularly beneficial in complex settings where interaction patterns cannot be predetermined.
 
-- Registered auto-reply. With the pluggable auto-reply function, one can choose to invoke conversations with other agents depending on the content of the current message and context. A working system demonstrating this type of dynamic conversation can be found in this code example, demonstrating a [dynamic group chat](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_groupchat.ipynb). In the system, we register an auto-reply function in the group chat manager, which lets LLM decide who the next speaker will be in a group chat setting.
+1. Registered auto-reply
+With the pluggable auto-reply function, one can choose to invoke conversations with other agents depending on the content of the current message and context. For example:
+- Hierarchical chat like in [OptiGuide](https://github.com/microsoft/optiguide).
+- [Dynamic Group Chat](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_groupchat.ipynb) which is a special form of hierarchical chat. In the system, we register a reply function in the group chat manager, which broadcasts messages and decides who the next speaker will be in a group chat setting.
+- [Finite state machine (FSM) based group chat](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_graph_modelling_language_using_select_speaker.ipynb) which is a special form of dynamic group chat. In this approach, a directed transition matrix is fed into group chat. Users can specify legal transitions or specify disallowed transitions.
+- Nested chat like in [conversational chess](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_chess.ipynb).
 
-- LLM-based function call. In this approach, LLM decides whether or not to call a particular function depending on the conversation status in each inference call.
-  By messaging additional agents in the called functions, the LLM can drive dynamic multi-agent conversation. A working system showcasing this type of dynamic conversation can be found in the [multi-user math problem solving scenario](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_two_users.ipynb), where a student assistant would automatically resort to an expert using function calls.
+2. LLM-Based Function Call
+Another approach involves LLM-based function calls, where LLM decides if a specific function should be invoked based on the conversation's status during each inference. This approach enables dynamic multi-agent conversations, as seen in scenarios like [multi-user math problem solving scenario](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_two_users.ipynb), where a student assistant automatically seeks expertise via function calls.
 
 ### LLM Caching
 
diff --git a/website/docs/installation/Optional-Dependencies.md b/website/docs/installation/Optional-Dependencies.md
index 33e859332532..601266397e2a 100644
--- a/website/docs/installation/Optional-Dependencies.md
+++ b/website/docs/installation/Optional-Dependencies.md
@@ -107,3 +107,14 @@ pip install "pyautogen[mathchat]<0.2"
 Example notebooks:
 
 [Using MathChat to Solve Math Problems](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_MathChat.ipynb)
+
+## Graph
+
+To use a graph in `GroupChat`, particularly for graph visualization, please install AutoGen with the [graph] option.
+
+
+```bash
+pip install "pyautogen[graph]"
+```
+
+Example notebook:  [Graph Modeling Language with using select_speaker](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_graph_modelling_language_using_select_speaker.ipynb)