Repository: microsoft/FLAML (language: python)

Issue:
`infer_lang` in autogen.code_utils
https://github.com/microsoft/FLAML/blob/main/flaml/autogen/code_utils.py#L24

sometimes the sh code would start with "python3 ", so maybe include "python3 " as well?


Discussion / hints:

Fix patch:
diff --git a/.github/workflows/openai.yml b/.github/workflows/openai.yml
index 11b9dcd988..25b162c094 100644
--- a/.github/workflows/openai.yml
+++ b/.github/workflows/openai.yml
@@ -34,6 +34,10 @@ jobs:
           pip install -e .[autogen,blendsearch]
           python -c "import flaml"
           pip install coverage pytest datasets
+      - name: Install packages for test when needed
+        if: matrix.python-version == '3.9'
+        run: |
+          pip install docker
       - name: Install packages for MathChat when needed
         if: matrix.python-version != '3.11'
         run: |
diff --git a/README.md b/README.md
index 73bc50e7b2..a2a1d58c8a 100644
--- a/README.md
+++ b/README.md
@@ -66,10 +66,10 @@ Use the following guides to get started with FLAML in .NET:
 * (New) The [autogen](https://microsoft.github.io/FLAML/docs/Use-Cases/Auto-Generation) package can help you maximize the utility out of the expensive LLMs such as ChatGPT and GPT-4, including:
     - A drop-in replacement of `openai.Completion` or `openai.ChatCompletion` with powerful functionalites like tuning, caching, templating, filtering. For example, you can optimize generations by LLM with your own tuning data, success metrics and budgets.
     ```python
-    from flaml import oai
+    from flaml import autogen
 
     # perform tuning
-    config, analysis = oai.Completion.tune(
+    config, analysis = autogen.Completion.tune(
         data=tune_data,
         metric="success",
         mode="max",
@@ -80,13 +80,13 @@ Use the following guides to get started with FLAML in .NET:
     )
 
     # perform inference for a test instance
-    response = oai.Completion.create(context=test_instance, **config)
+    response = autogen.Completion.create(context=test_instance, **config)
     ```
     - LLM-driven intelligent agents which can collaborately perform tasks autonomously or with human feedback, including tasks that require using tools via code.
     ```python
-    assistant = AssistantAgent("assistant")
-    user_proxy = UserProxyAgent("user_proxy")
-    user_proxy.initiate_chat("Show me the YTD gain of 10 largest technology companies as of today.")
+    assistant = autogen.AssistantAgent("assistant")
+    user_proxy = autogen.UserProxyAgent("user_proxy")
+    user_proxy.initiate_chat(assistant, message="Show me the YTD gain of 10 largest technology companies as of today.")
     ```
 * With three lines of code, you can start using this economical and fast
 AutoML engine as a [scikit-learn style estimator](https://microsoft.github.io/FLAML/docs/Use-Cases/Task-Oriented-AutoML).
diff --git a/flaml/__init__.py b/flaml/__init__.py
index 9fca486499..2349993733 100644
--- a/flaml/__init__.py
+++ b/flaml/__init__.py
@@ -2,7 +2,6 @@
 from flaml.automl import AutoML, logger_formatter
 from flaml.tune.searcher import CFO, BlendSearch, FLOW2, BlendSearchTuner, RandomSearch
 from flaml.onlineml.autovw import AutoVW
-from flaml.autogen import oai
 from flaml.version import __version__
 
 
diff --git a/flaml/autogen/__init__.py b/flaml/autogen/__init__.py
index d13c36540e..949f7d3ce8 100644
--- a/flaml/autogen/__init__.py
+++ b/flaml/autogen/__init__.py
@@ -1,2 +1,3 @@
-DEFAULT_MODEL = "gpt-4"
-FAST_MODEL = "gpt-3.5-turbo"
+from .oai import *
+from .agentchat import *
+from .code_utils import DEFAULT_MODEL, FAST_MODEL
diff --git a/flaml/autogen/agentchat/__init__.py b/flaml/autogen/agentchat/__init__.py
index 694f35cc5a..ec62947dcc 100644
--- a/flaml/autogen/agentchat/__init__.py
+++ b/flaml/autogen/agentchat/__init__.py
@@ -1,7 +1,6 @@
 from .agent import Agent
-from .responsive_agent import ResponsiveAgent
 from .assistant_agent import AssistantAgent
+from .responsive_agent import ResponsiveAgent
 from .user_proxy_agent import UserProxyAgent
 
-
 __all__ = ["Agent", "ResponsiveAgent", "AssistantAgent", "UserProxyAgent"]
diff --git a/flaml/autogen/agentchat/agent.py b/flaml/autogen/agentchat/agent.py
index c62ed29ab4..27c552d1f5 100644
--- a/flaml/autogen/agentchat/agent.py
+++ b/flaml/autogen/agentchat/agent.py
@@ -38,7 +38,7 @@ def generate_reply(
         messages: Optional[List[Dict]] = None,
         default_reply: Optional[Union[str, Dict]] = "",
         sender: Optional["Agent"] = None,
-    ) -> Union[str, Dict]:
+    ) -> Union[str, Dict, None]:
         """(Abstract method) Generate a reply based on the received messages.
 
         Args:
@@ -46,5 +46,5 @@ def generate_reply(
             default_reply (str or dict): the default reply if no other reply is generated.
             sender: sender of an Agent instance.
         Returns:
-            str or dict: the generated reply.
+            str or dict or None: the generated reply. If None, no reply is generated.
         """
diff --git a/flaml/autogen/agentchat/assistant_agent.py b/flaml/autogen/agentchat/assistant_agent.py
index 00f027edb7..f8e48a0f9f 100644
--- a/flaml/autogen/agentchat/assistant_agent.py
+++ b/flaml/autogen/agentchat/assistant_agent.py
@@ -27,7 +27,7 @@ def __init__(
         self,
         name: str,
         system_message: Optional[str] = DEFAULT_SYSTEM_MESSAGE,
-        oai_config: Optional[Union[Dict, bool]] = None,
+        llm_config: Optional[Union[Dict, bool]] = None,
         is_termination_msg: Optional[Callable[[Dict], bool]] = None,
         max_consecutive_auto_reply: Optional[int] = None,
         human_input_mode: Optional[str] = "NEVER",
@@ -37,10 +37,10 @@ def __init__(
         """
         Args:
             name (str): agent name.
-            system_message (str): system message for the oai inference.
+            system_message (str): system message for the ChatCompletion inference.
                 Please override this attribute if you want to reprogram the agent.
-            oai_config (dict): oai inference configuration.
-                Please refer to [oai.Completion.create](/docs/reference/autogen/oai/completion#create)
+            llm_config (dict): llm inference configuration.
+                Please refer to [autogen.Completion.create](/docs/reference/autogen/oai/completion#create)
                 for available options.
             is_termination_msg (function): a function that takes a message in the form of a dictionary
                 and returns a boolean value indicating if this received message is a termination message.
@@ -58,6 +58,6 @@ def __init__(
             max_consecutive_auto_reply,
             human_input_mode,
             code_execution_config=code_execution_config,
-            oai_config=oai_config,
+            llm_config=llm_config,
             **kwargs,
         )
diff --git a/flaml/autogen/agentchat/contrib/math_user_proxy_agent.py b/flaml/autogen/agentchat/contrib/math_user_proxy_agent.py
index 2533f9be41..7b288fc175 100644
--- a/flaml/autogen/agentchat/contrib/math_user_proxy_agent.py
+++ b/flaml/autogen/agentchat/contrib/math_user_proxy_agent.py
@@ -136,6 +136,7 @@ def __init__(
             Callable[[Dict], bool]
         ] = _is_termination_msg_mathchat,  # terminate if \boxed{} in message
         human_input_mode: Optional[str] = "NEVER",  # Fully automated
+        default_auto_reply: Optional[Union[str, Dict, None]] = DEFAULT_REPLY,
         max_invalid_q_per_step=3,  # a parameter needed in MathChat
         **kwargs,
     ):
@@ -153,6 +154,7 @@ def __init__(
                     the number of auto reply reaches the max_consecutive_auto_reply.
                 (3) (Default) When "NEVER", the agent will never prompt for human input. Under this mode, the conversation stops
                     when the number of auto reply reaches the max_consecutive_auto_reply or when is_termination_msg is True.
+            default_auto_reply (str or dict or None): the default auto reply message when no code execution or llm based reply is generated.
             max_invalid_q_per_step (int): (ADDED) the maximum number of invalid queries per step.
             **kwargs (dict): other kwargs in [UserProxyAgent](user_proxy_agent#__init__).
         """
@@ -160,6 +162,7 @@ def __init__(
             name=name,
             is_termination_msg=is_termination_msg,
             human_input_mode=human_input_mode,
+            default_auto_reply=default_auto_reply,
             **kwargs,
         )
 
@@ -220,14 +223,6 @@ def execute_one_python_code(self, pycode):
         return_code, output, _ = execute_code(pycode, **self._code_execution_config, timeout=5)
         is_success = return_code == 0
 
-        # Decode the output
-        if isinstance(output, bytes):
-            try:
-                output = output.decode("utf-8")
-            except UnicodeDecodeError:
-                is_success = False
-                output = "The return cannot be decoded."
-
         if not is_success:
             # Remove the file information from the error string
             pattern = r'File "/[^"]+\.py", line \d+, in .+\n'
@@ -285,11 +280,11 @@ def generate_reply(
         self,
         messages: Optional[List[Dict]] = None,
         default_reply: Optional[Union[str, Dict]] = DEFAULT_REPLY,
-        sender: Optional["Agent"] = None,
-    ) -> Union[str, Dict]:
+        sender: Optional[Agent] = None,
+    ) -> Union[str, Dict, None]:
         """Generate an auto reply."""
         if messages is None:
-            messages = self._oai_conversations[sender.name]
+            messages = self._oai_messages[sender.name]
         message = messages[-1]
         message = message.get("content", "")
         code_blocks = extract_code(message)
diff --git a/flaml/autogen/agentchat/responsive_agent.py b/flaml/autogen/agentchat/responsive_agent.py
index c240052dcb..0552e13cbe 100644
--- a/flaml/autogen/agentchat/responsive_agent.py
+++ b/flaml/autogen/agentchat/responsive_agent.py
@@ -1,10 +1,17 @@
 from collections import defaultdict
 import json
 from typing import Callable, Dict, List, Optional, Union
-from flaml import oai
+from flaml.autogen import oai
 from .agent import Agent
 from flaml.autogen.code_utils import DEFAULT_MODEL, UNKNOWN, execute_code, extract_code, infer_lang
 
+try:
+    from termcolor import colored
+except ImportError:
+
+    def colored(x, *args, **kwargs):
+        return x
+
 
 class ResponsiveAgent(Agent):
     """(Experimental) A class for generic responsive agents which can be configured as assistant or user proxy.
@@ -35,12 +42,13 @@ def __init__(
         human_input_mode: Optional[str] = "TERMINATE",
         function_map: Optional[Dict[str, Callable]] = None,
         code_execution_config: Optional[Union[Dict, bool]] = None,
-        oai_config: Optional[Union[Dict, bool]] = None,
+        llm_config: Optional[Union[Dict, bool]] = None,
+        default_auto_reply: Optional[Union[str, Dict, None]] = "",
     ):
         """
         Args:
             name (str): name of the agent.
-            system_message (str): system message for the oai inference.
+            system_message (str): system message for the ChatCompletion inference.
             is_termination_msg (function): a function that takes a message in the form of a dictionary
                 and returns a boolean value indicating if this received message is a termination message.
                 The dict can contain the following keys: "content", "role", "name", "function_call".
@@ -71,25 +79,25 @@ def __init__(
                     If the code is executed in the current environment,
                     the code must be trusted.
                 - timeout (Optional, int): The maximum execution time in seconds.
-            oai_config (dict or False): oai inference configuration.
-                Please refer to [oai.Completion.create](/docs/reference/autogen/oai/completion#create)
+            llm_config (dict or False): llm inference configuration.
+                Please refer to [autogen.Completion.create](/docs/reference/autogen/oai/completion#create)
                 for available options.
-                To disable oai-based auto reply, set to False.
+                To disable llm-based auto reply, set to False.
+            default_auto_reply (str or dict or None): default auto reply when no code execution or llm-based reply is generated.
         """
         super().__init__(name)
         # a dictionary of conversations, default value is list
-        self._oai_conversations = defaultdict(list)
-        self._system_message = system_message
-        self._oai_system_message = [{"content": self._system_message, "role": "system"}]
+        self._oai_messages = defaultdict(list)
+        self._oai_system_message = [{"content": system_message, "role": "system"}]
         self._is_termination_msg = (
             is_termination_msg if is_termination_msg is not None else (lambda x: x.get("content") == "TERMINATE")
         )
-        if oai_config is False:
-            self.oai_config = False
+        if llm_config is False:
+            self.llm_config = False
         else:
-            self.oai_config = self.DEFAULT_CONFIG.copy()
-            if isinstance(oai_config, dict):
-                self.oai_config.update(oai_config)
+            self.llm_config = self.DEFAULT_CONFIG.copy()
+            if isinstance(llm_config, dict):
+                self.llm_config.update(llm_config)
 
         self._code_execution_config = {} if code_execution_config is None else code_execution_config
         self.human_input_mode = human_input_mode
@@ -98,11 +106,20 @@ def __init__(
         )
         self._consecutive_auto_reply_counter = defaultdict(int)
         self._function_map = {} if function_map is None else function_map
+        self._default_auto_reply = default_auto_reply
+
+    def update_system_message(self, system_message: str):
+        """Update the system message.
+
+        Args:
+            system_message (str): system message for the ChatCompletion inference.
+        """
+        self._oai_system_message[0]["content"] = system_message
 
     @property
-    def oai_conversations(self) -> Dict[str, List[Dict]]:
-        """A dictionary of conversations from name to list of oai messages."""
-        return self._oai_conversations
+    def chat_messages(self) -> Dict[str, List[Dict]]:
+        """A dictionary of conversations from name to list of ChatCompletion messages."""
+        return self._oai_messages
 
     def last_message(self, agent: Optional[Agent] = None) -> Dict:
         """The last message exchanged with the agent.
@@ -116,14 +133,14 @@ def last_message(self, agent: Optional[Agent] = None) -> Dict:
             The last message exchanged with the agent.
         """
         if agent is None:
-            n_conversations = len(self._oai_conversations)
+            n_conversations = len(self._oai_messages)
             if n_conversations == 0:
                 return None
             if n_conversations == 1:
-                for conversation in self._oai_conversations.values():
+                for conversation in self._oai_messages.values():
                     return conversation[-1]
             raise ValueError("More than one conversation is found. Please specify the sender to get the last message.")
-        return self._oai_conversations[agent.name][-1]
+        return self._oai_messages[agent.name][-1]
 
     @property
     def use_docker(self) -> Union[bool, str, None]:
@@ -135,7 +152,7 @@ def use_docker(self) -> Union[bool, str, None]:
     def _message_to_dict(message: Union[Dict, str]):
         """Convert a message to a dictionary.
 
-        The message can be a string or a dictionary. The string with be put in the "content" field of the new dictionary.
+        The message can be a string or a dictionary. The string will be put in the "content" field of the new dictionary.
         """
         if isinstance(message, str):
             return {"content": message}
@@ -143,31 +160,31 @@ def _message_to_dict(message: Union[Dict, str]):
             return message
 
     def _append_oai_message(self, message: Union[Dict, str], role, conversation_id) -> bool:
-        """Append a message to the oai conversation.
+        """Append a message to the ChatCompletion conversation.
 
         If the message received is a string, it will be put in the "content" field of the new dictionary.
         If the message received is a dictionary but does not have any of the two fields "content" or "function_call",
-            this message is not a valid oai message and will be ignored.
+            this message is not a valid ChatCompletion message.
 
         Args:
-            message (dict or str): message to be appended to the oai conversation.
+            message (dict or str): message to be appended to the ChatCompletion conversation.
             role (str): role of the message, can be "assistant" or "function".
             conversation_id (str): id of the conversation, should be the name of the recipient or sender.
 
         Returns:
-            bool: whether the message is appended to the oai conversation.
+            bool: whether the message is appended to the ChatCompletion conversation.
         """
         message = self._message_to_dict(message)
         # create oai message to be appended to the oai conversation that can be passed to oai directly.
-        oai_message = {k: message[k] for k in ("content", "function_call", "name") if k in message}
+        oai_message = {k: message[k] for k in ("content", "function_call", "name", "context") if k in message}
         if "content" not in oai_message and "function_call" not in oai_message:
             return False
 
         oai_message["role"] = "function" if message.get("role") == "function" else role
-        self._oai_conversations[conversation_id].append(oai_message)
+        self._oai_messages[conversation_id].append(oai_message)
         return True
 
-    def send(self, message: Union[Dict, str], recipient: "Agent"):
+    def send(self, message: Union[Dict, str], recipient: Agent):
         """Send a message to another agent.
 
         Args:
@@ -179,16 +196,16 @@ def send(self, message: Union[Dict, str], recipient: "Agent"):
                 - role (str): the role of the message, any role that is not "function"
                     will be modified to "assistant".
                 - context (dict): the context of the message, which will be passed to
-                    [oai.Completion.create](../oai/Completion#create).
+                    [autogen.Completion.create](../oai/Completion#create).
                     For example, one agent can send a message A as:
-            ```python
-            {
-                "content": "{use_tool_msg}",
-                "context": {
-                    "use_tool_msg": "Use tool X if they are relevant."
-                }
+        ```python
+        {
+            "content": "{use_tool_msg}",
+            "context": {
+                "use_tool_msg": "Use tool X if they are relevant."
             }
-            ```
+        }
+        ```
                     Next time, one agent can send a message B with a different "use_tool_msg".
                     Then the content of message A will be refreshed to the new "use_tool_msg".
                     So effectively, this provides a way for an agent to send a "link" and modify
@@ -196,7 +213,7 @@ def send(self, message: Union[Dict, str], recipient: "Agent"):
             recipient (Agent): the recipient of the message.
 
         Raises:
-            ValueError: if the message is not a valid oai message.
+            ValueError: if the message can't be converted into a valid ChatCompletion message.
         """
         # When the agent composes and sends the message, the role of the message is "assistant"
         # unless it's "function".
@@ -204,51 +221,60 @@ def send(self, message: Union[Dict, str], recipient: "Agent"):
         if valid:
             recipient.receive(message, self)
         else:
-            raise ValueError("Message is not a valid oai message. Either content or function_call must be provided.")
+            raise ValueError(
+                "Message can't be converted into a valid ChatCompletion message. Either content or function_call must be provided."
+            )
 
-    def _print_received_message(self, message: Union[Dict, str], sender: "Agent"):
+    def _print_received_message(self, message: Union[Dict, str], sender: Agent):
         # print the message received
-        print(sender.name, "(to", f"{self.name}):\n", flush=True)
+        print(colored(sender.name, "yellow"), "(to", f"{self.name}):\n", flush=True)
         if message.get("role") == "function":
             func_print = f"***** Response from calling function \"{message['name']}\" *****"
-            print(func_print, flush=True)
+            print(colored(func_print, "green"), flush=True)
             print(message["content"], flush=True)
-            print("*" * len(func_print), flush=True)
+            print(colored("*" * len(func_print), "green"), flush=True)
         else:
             if message.get("content") is not None:
                 print(message["content"], flush=True)
             if "function_call" in message:
                 func_print = f"***** Suggested function Call: {message['function_call'].get('name', '(No function name found)')} *****"
-                print(func_print, flush=True)
+                print(colored(func_print, "green"), flush=True)
                 print(
                     "Arguments: \n",
                     message["function_call"].get("arguments", "(No arguments found)"),
                     flush=True,
                     sep="",
                 )
-                print("*" * len(func_print), flush=True)
+                print(colored("*" * len(func_print), "green"), flush=True)
         print("\n", "-" * 80, flush=True, sep="")
 
-    def receive(self, message: Union[Dict, str], sender: "Agent"):
+    def receive(self, message: Union[Dict, str], sender: Agent):
         """Receive a message from another agent.
 
         Once a message is received, this function sends a reply to the sender or stop.
         The reply can be generated automatically or entered manually by a human.
 
         Args:
-            message (dict or str): message from the sender. If the type is dict, it may contain the following reserved fields (All fields are optional).
+            message (dict or str): message from the sender. If the type is dict, it may contain the following reserved fields (either content or function_call need to be provided).
                 1. "content": content of the message, can be None.
                 2. "function_call": a dictionary containing the function name and arguments.
                 3. "role": role of the message, can be "assistant", "user", "function".
                     This field is only needed to distinguish between "function" or "assistant"/"user".
                 4. "name": In most cases, this field is not needed. When the role is "function", this field is needed to indicate the function name.
+                5. "context" (dict): the context of the message, which will be passed to
+                    [autogen.Completion.create](../oai/Completion#create).
             sender: sender of an Agent instance.
+
+        Raises:
+            ValueError: if the message can't be converted into a valid ChatCompletion message.
         """
         message = self._message_to_dict(message)
         # When the agent receives a message, the role of the message is "user". (If 'role' exists and is 'function', it will remain unchanged.)
         valid = self._append_oai_message(message, "user", sender.name)
         if not valid:
-            return
+            raise ValueError(
+                "Received message can't be converted into a valid ChatCompletion message. Either content or function_call must be provided."
+            )
         self._print_received_message(message, sender)
 
         # default reply is empty (i.e., no reply, in this case we will try to generate auto reply)
@@ -290,7 +316,7 @@ def receive(self, message: Union[Dict, str], sender: "Agent"):
 
         # print the no_human_input_msg
         if no_human_input_msg:
-            print(f"\n>>>>>>>> {no_human_input_msg}", flush=True)
+            print(colored(f"\n>>>>>>>> {no_human_input_msg}", "red"), flush=True)
 
         # stop the conversation
         if reply == "exit":
@@ -308,18 +334,20 @@ def receive(self, message: Union[Dict, str], sender: "Agent"):
         # send the auto reply
         self._consecutive_auto_reply_counter[sender.name] += 1
         if self.human_input_mode != "NEVER":
-            print("\n>>>>>>>> USING AUTO REPLY...", flush=True)
-        self.send(self.generate_reply(sender=sender), sender)
+            print(colored("\n>>>>>>>> USING AUTO REPLY...", "red"), flush=True)
+        reply = self.generate_reply(sender=sender, default_reply=self._default_auto_reply)
+        if reply is not None:
+            self.send(reply, sender)
 
     def reset(self):
         """Reset the agent."""
-        self._oai_conversations.clear()
+        self._oai_messages.clear()
         self._consecutive_auto_reply_counter.clear()
 
     def _oai_reply(self, messages: List[Dict]) -> Union[str, Dict]:
         # TODO: #1143 handle token limit exceeded error
         response = oai.ChatCompletion.create(
-            context=messages[-1].get("context"), messages=self._oai_system_message + messages, **self.oai_config
+            context=messages[-1].pop("context", None), messages=self._oai_system_message + messages, **self.llm_config
         )
         return oai.ChatCompletion.extract_text_or_function_call(response)[0]
 
@@ -327,8 +355,8 @@ def generate_reply(
         self,
         messages: Optional[List[Dict]] = None,
         default_reply: Optional[Union[str, Dict]] = "",
-        sender: Optional["Agent"] = None,
-    ) -> Union[str, Dict]:
+        sender: Optional[Agent] = None,
+    ) -> Union[str, Dict, None]:
         """Reply based on the conversation history.
 
         First, execute function or code and return the result.
@@ -342,21 +370,26 @@ def generate_reply(
             sender: sender of an Agent instance.
 
         Returns:
-            str or dict: reply.
+            str or dict or None: reply. None if no reply is generated.
         """
         assert messages is not None or sender is not None, "Either messages or sender must be provided."
         if messages is None:
-            messages = self._oai_conversations[sender.name]
+            messages = self._oai_messages[sender.name]
         message = messages[-1]
         if "function_call" in message:
             _, func_return = self.execute_function(message["function_call"])
             return func_return
         if self._code_execution_config is False:
-            return default_reply if self.oai_config is False else self._oai_reply(messages)
+            return default_reply if self.llm_config is False else self._oai_reply(messages)
         code_blocks = extract_code(message["content"])
         if len(code_blocks) == 1 and code_blocks[0][0] == UNKNOWN:
             # no code block is found, lang should be `UNKNOWN`
-            return default_reply if self.oai_config is False else self._oai_reply(messages)
+            if self.llm_config is False:
+                return default_reply
+            # code_blocks, _ = find_code(messages, sys_msg=self._oai_system_message, **self.llm_config)
+            # if len(code_blocks) == 1 and code_blocks[0][0] == UNKNOWN:
+            #     return code_blocks[0][1]
+            return self._oai_reply(messages)
         # try to execute the code
         exitcode, logs = self.execute_code_blocks(code_blocks)
         exitcode2str = "execution succeeded" if exitcode == 0 else "execution failed"
@@ -387,7 +420,7 @@ def run_code(self, code, **kwargs):
         Returns:
             A tuple of (exitcode, logs, image).
             exitcode (int): the exit code of the code execution.
-            logs (bytes): the logs of the code execution.
+            logs (str): the logs of the code execution.
             image (str or None): the docker image used for the code execution.
         """
         return execute_code(code, **kwargs)
@@ -395,13 +428,13 @@ def run_code(self, code, **kwargs):
     def execute_code_blocks(self, code_blocks):
         """Execute the code blocks and return the result."""
         logs_all = ""
-        for code_block in code_blocks:
+        for i, code_block in enumerate(code_blocks):
             lang, code = code_block
             if not lang:
                 lang = infer_lang(code)
+            print(colored(f"\n>>>>>>>> EXECUTING CODE BLOCK {i} (inferred language is {lang})...", "red"), flush=True)
             if lang in ["bash", "shell", "sh"]:
                 exitcode, logs, image = self.run_code(code, lang=lang, **self._code_execution_config)
-                logs = logs.decode("utf-8")
             elif lang in ["python", "Python"]:
                 if code.startswith("# filename: "):
                     filename = code[11 : code.find("\n")].strip()
@@ -412,7 +445,6 @@ def execute_code_blocks(self, code_blocks):
                     filename=filename,
                     **self._code_execution_config,
                 )
-                logs = logs.decode("utf-8")
             else:
                 # In case the language is not supported, we return an error message.
                 exitcode, logs, image = 1, f"unknown language {lang}", self._code_execution_config["use_docker"]
@@ -481,6 +513,7 @@ def execute_function(self, func_call):
 
             # Try to execute the function
             if arguments:
+                print(colored(f"\n>>>>>>>> EXECUTING FUNCTION {func_name}...", "magenta"), flush=True)
                 try:
                     content = func(**arguments)
                     is_exec_success = True
diff --git a/flaml/autogen/agentchat/user_proxy_agent.py b/flaml/autogen/agentchat/user_proxy_agent.py
index 76e8e61577..c4a4e7bd4b 100644
--- a/flaml/autogen/agentchat/user_proxy_agent.py
+++ b/flaml/autogen/agentchat/user_proxy_agent.py
@@ -6,7 +6,7 @@ class UserProxyAgent(ResponsiveAgent):
     """(Experimental) A proxy agent for the user, that can execute code and provide feedback to the other agents.
 
     UserProxyAgent is a subclass of ResponsiveAgent configured with `human_input_mode` to ALWAYS
-    and `oai_config` to False. By default, the agent will prompt for human input every time a message is received.
+    and `llm_config` to False. By default, the agent will prompt for human input every time a message is received.
     Code execution is enabled by default. LLM-based auto reply is disabled by default.
     To modify auto reply, override `generate_reply` method.
     To modify the way to get human input, override `get_human_input` method.
@@ -23,7 +23,8 @@ def __init__(
         human_input_mode: Optional[str] = "ALWAYS",
         function_map: Optional[Dict[str, Callable]] = None,
         code_execution_config: Optional[Union[Dict, bool]] = None,
-        oai_config: Optional[Union[Dict, bool]] = False,
+        default_auto_reply: Optional[Union[str, Dict, None]] = "",
+        llm_config: Optional[Union[Dict, bool]] = False,
         system_message: Optional[str] = "",
     ):
         """
@@ -59,12 +60,13 @@ def __init__(
                     If the code is executed in the current environment,
                     the code must be trusted.
                 - timeout (Optional, int): The maximum execution time in seconds.
-            oai_config (dict or False): oai inference configuration.
-                Please refer to [oai.Completion.create](/docs/reference/autogen/oai/completion#create)
+            default_auto_reply (str or dict or None): the default auto reply message when no code execution or llm based reply is generated.
+            llm_config (dict or False): llm inference configuration.
+                Please refer to [autogen.Completion.create](/docs/reference/autogen/oai/completion#create)
                 for available options.
-                Default to false, which disables oai-based auto reply.
-            system_message (str): system message for oai inference.
-                Only used when oai_config is not False. Use it to reprogram the agent.
+                Default to false, which disables llm-based auto reply.
+            system_message (str): system message for ChatCompletion inference.
+                Only used when llm_config is not False. Use it to reprogram the agent.
         """
         super().__init__(
             name,
@@ -74,5 +76,6 @@ def __init__(
             human_input_mode,
             function_map,
             code_execution_config,
-            oai_config,
+            llm_config,
+            default_auto_reply,
         )
diff --git a/flaml/autogen/code_utils.py b/flaml/autogen/code_utils.py
index f721e93e0b..d1251a04a3 100644
--- a/flaml/autogen/code_utils.py
+++ b/flaml/autogen/code_utils.py
@@ -8,13 +8,20 @@
 import time
 from hashlib import md5
 import logging
-from flaml.autogen import oai, DEFAULT_MODEL, FAST_MODEL
+from flaml.autogen import oai
 
+try:
+    import docker
+except ImportError:
+    docker = None
+
+DEFAULT_MODEL = "gpt-4"
+FAST_MODEL = "gpt-3.5-turbo"
 # Regular expression for finding a code block
 CODE_BLOCK_PATTERN = r"```(\w*)\n(.*?)\n```"
 WORKING_DIR = os.path.join(os.path.dirname(os.path.realpath(__file__)), "extensions")
 UNKNOWN = "unknown"
-TIMEOUT_MSG = bytes("Timeout", "utf-8")
+TIMEOUT_MSG = "Timeout"
 DEFAULT_TIMEOUT = 600
 
 
@@ -47,6 +54,47 @@ def extract_code(text: str, pattern: str = CODE_BLOCK_PATTERN) -> List[Tuple[str
     return match if match else [(UNKNOWN, text)]
 
 
+# _FIND_CODE_SYS_MSG = [
+#     {
+#         "role": "system",
+#         "content": """In the following conversation, an assistant suggests code and a user is expected to run it.
+# Read the conversation, and then find all the right code blocks for the user to run next in the right order.
+# Only return the code blocks that are expected to run.
+# Don't include code blocks which have been executed unless the user is requested to run the same block again.
+# When the user needs to run multiple blocks in sequence, make sure to output all the blocks to run in a right order.
+# If the line beginning with "# filename" is put before a code block, move it into the code block as the first line.
+# Make sure to add the right "python" or "sh" identifier if the language identifier is missing for a code block.
+# Don't make other changes to the code blocks.
+# Don't reply anything else if at least one code block is expected to run.
+# If no code block is expeted to run, check whether the task has been successfully finished at full satisfaction.
+# If not, reply with the reason why the task is not finished.""",
+#     },
+# ]
+# _FIND_CODE_CONFIG = {
+#     "model": FAST_MODEL,
+# }
+
+
+# def find_code(messages: List[Dict], sys_msg=None, **config) -> Tuple[List[Tuple[str, str]], str]:
+#     """Find code from a list of messages.
+
+#     Args:
+#         messages (str): The list of messages to find code from.
+#         sys_msg (Optional, str): The system message to prepend to the messages.
+#         config (Optional, dict): The configuration for the API call.
+
+#     Returns:
+#         list: A list of tuples, each containing the language and the code.
+#         str: The generated text by llm.
+#     """
+#     params = {**_FIND_CODE_CONFIG, **config}
+#     if sys_msg is None or not sys_msg[0]["content"]:
+#         sys_msg = _FIND_CODE_SYS_MSG
+#     response = oai.ChatCompletion.create(messages=sys_msg + messages, **params)
+#     content = oai.Completion.extract_text(response)[0]
+#     return extract_code(content), content
+
+
 def generate_code(pattern: str = CODE_BLOCK_PATTERN, **config) -> Tuple[str, float]:
     """Generate code.
 
@@ -138,9 +186,9 @@ def execute_code(
     timeout: Optional[int] = None,
     filename: Optional[str] = None,
     work_dir: Optional[str] = None,
-    use_docker: Optional[Union[List[str], str, bool]] = True,
+    use_docker: Optional[Union[List[str], str, bool]] = docker is not None,
     lang: Optional[str] = "python",
-) -> Tuple[int, bytes, str]:
+) -> Tuple[int, str, str]:
     """Execute code in a docker container.
     This function is not tested on MacOS.
 
@@ -169,7 +217,7 @@ def execute_code(
 
     Returns:
         int: 0 if the code executes successfully.
-        bytes: The error message if the code fails to execute; the stdout otherwise.
+        str: The error message if the code fails to execute; the stdout otherwise.
         image: The docker image name after container run when docker is used.
     """
     assert code is not None or filename is not None, "Either code or filename must be provided."
@@ -216,9 +264,15 @@ def execute_code(
                 return 1, TIMEOUT_MSG, None
         if original_filename is None:
             os.remove(filepath)
-        return result.returncode, result.stderr if result.returncode else result.stdout, None
-
-    import docker
+            abs_path = str(pathlib.Path(filepath).absolute())
+        else:
+            abs_path = str(pathlib.Path(work_dir).absolute()) + "/"
+        if result.returncode:
+            logs = result.stderr.decode("utf-8")
+            logs = logs.replace(str(abs_path), "")
+        else:
+            logs = result.stdout.decode("utf-8")
+        return result.returncode, logs, None
 
     # create a docker client
     client = docker.from_env()
@@ -283,7 +337,8 @@ def execute_code(
     # get the container logs
     logs = container.logs().decode("utf-8").rstrip()
     # commit the image
-    container.commit(repository="python", tag=filename.replace("/", ""))
+    tag = filename.replace("/", "")
+    container.commit(repository="python", tag=tag)
     # remove the container
     container.remove()
     # check if the code executed successfully
@@ -296,11 +351,12 @@ def execute_code(
         # remove the exit code from the logs
         logs = pattern.sub("", logs)
 
-    logs = bytes(logs, "utf-8")
     if original_filename is None:
         os.remove(filepath)
+    if exit_code:
+        logs = logs.replace(f"/workspace/{filename if original_filename is None else ''}", "")
     # return the exit code, logs and image
-    return exit_code, logs, f"python:{filename}"
+    return exit_code, logs, f"python:{tag}"
 
 
 _GENERATE_ASSERTIONS_CONFIG = {
diff --git a/flaml/autogen/math_utils.py b/flaml/autogen/math_utils.py
index dc6bcde42c..7fcb42287f 100644
--- a/flaml/autogen/math_utils.py
+++ b/flaml/autogen/math_utils.py
@@ -9,7 +9,7 @@
 
 
 def solve_problem(problem: str, **config) -> str:
-    """(work in progress) Solve the math problem.
+    """(Experimental) Solve the math problem.
 
     Args:
         problem (str): The problem statement.
diff --git a/flaml/autogen/oai/completion.py b/flaml/autogen/oai/completion.py
index 200ecdcaf1..0c16705828 100644
--- a/flaml/autogen/oai/completion.py
+++ b/flaml/autogen/oai/completion.py
@@ -26,7 +26,7 @@
 
     ERROR = None
 except ImportError:
-    ERROR = ImportError("please install flaml[openai] option to use the flaml.oai subpackage.")
+    ERROR = ImportError("please install flaml[openai] option to use the flaml.autogen.oai subpackage.")
     openai_Completion = object
 logger = logging.getLogger(__name__)
 if not logger.handlers:
diff --git a/notebook/autogen_agentchat_MathChat.ipynb b/notebook/autogen_agentchat_MathChat.ipynb
index 8550e67ab7..d6dc1b183d 100644
--- a/notebook/autogen_agentchat_MathChat.ipynb
+++ b/notebook/autogen_agentchat_MathChat.ipynb
@@ -50,9 +50,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from flaml import oai\n",
+    "from flaml import autogen\n",
     "\n",
-    "config_list = oai.config_list_from_json(\n",
+    "config_list = autogen.config_list_from_json(\n",
     "    \"OAI_CONFIG_LIST\",\n",
     "    filter_dict={\n",
     "        \"model\": {\n",
@@ -122,16 +122,15 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from flaml.autogen.agentchat import AssistantAgent\n",
     "from flaml.autogen.agentchat.contrib.math_user_proxy_agent import MathUserProxyAgent\n",
     "\n",
-    "oai.ChatCompletion.start_logging()\n",
+    "autogen.ChatCompletion.start_logging()\n",
     "\n",
     "# 1. create an AssistantAgent instance named \"assistant\"\n",
-    "assistant = AssistantAgent(\n",
+    "assistant = autogen.AssistantAgent(\n",
     "    name=\"assistant\", \n",
     "    system_message=\"You are a helpful assistant.\",\n",
-    "    oai_config={\n",
+    "    llm_config={\n",
     "        \"request_timeout\": 600,\n",
     "        \"seed\": 42,\n",
     "        \"config_list\": config_list,\n",
@@ -856,7 +855,7 @@
     }
    ],
    "source": [
-    "assistant.reset() # clear LLM assistant's message history\n",
+    "assistant.reset()  # clear LLM assistant's message history\n",
     "\n",
     "# The wolfram alpha appid is required for this example (the assistant may choose to query Wolfram Alpha).\n",
     "import os\n",
diff --git a/notebook/autogen_agentchat_auto_feedback_from_code_execution.ipynb b/notebook/autogen_agentchat_auto_feedback_from_code_execution.ipynb
index 4c9ef96ce0..d1d0c444ba 100644
--- a/notebook/autogen_agentchat_auto_feedback_from_code_execution.ipynb
+++ b/notebook/autogen_agentchat_auto_feedback_from_code_execution.ipynb
@@ -64,9 +64,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from flaml import oai\n",
+    "from flaml import autogen\n",
     "\n",
-    "config_list = oai.config_list_from_json(\n",
+    "config_list = autogen.config_list_from_json(\n",
     "    \"OAI_CONFIG_LIST\",\n",
     "    filter_dict={\n",
     "        \"model\": [\"gpt-4\", \"gpt4\", \"gpt-4-32k\", \"gpt-4-32k-0314\"],\n",
@@ -129,61 +129,139 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "user_proxy (to assistant):\n",
+      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
       "\n",
       "What date is today? Compare the year-to-date gain for META and TESLA.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "assistant (to user_proxy):\n",
+      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
+      "\n",
+      "To get the current date and compare the year-to-date gain for META (Facebook) and TESLA, we'll need to fetch stock data. We can use the `yfinance` library for this purpose. First, you'll need to install the library by running the following command:\n",
+      "\n",
+      "```sh\n",
+      "pip install yfinance\n",
+      "```\n",
+      "\n",
+      "After installing the library, execute the following Python code to get the current date and compare the year-to-date gain for META and TESLA:\n",
       "\n",
-      "# filename: stock_comparison.py\n",
       "```python\n",
-      "import datetime\n",
       "import yfinance as yf\n",
+      "from datetime import datetime, timedelta\n",
       "\n",
       "# Get today's date\n",
-      "today = datetime.date.today()\n",
-      "print(\"Today's date:\", today)\n",
+      "today = datetime.now()\n",
+      "print(f\"Today's date is: {today.strftime('%Y-%m-%d')}\")\n",
       "\n",
-      "# Get the start of the year\n",
-      "start_of_year = datetime.date(today.year, 1, 1)\n",
+      "# Calculate the start date for year-to-date\n",
+      "start_date = datetime(today.year, 1, 1)\n",
       "\n",
-      "# Download the historical data for META and TESLA\n",
-      "meta_data = yf.download('META', start=start_of_year, end=today)\n",
-      "tesla_data = yf.download('TSLA', start=start_of_year, end=today)\n",
+      "# Fetch stock data for META (Facebook) and TESLA\n",
+      "meta = yf.Ticker(\"FB\")\n",
+      "tesla = yf.Ticker(\"TSLA\")\n",
       "\n",
-      "# Calculate the year-to-date gain for META and TESLA\n",
-      "meta_gain = (meta_data['Close'][-1] - meta_data['Close'][0]) / meta_data['Close'][0]\n",
-      "tesla_gain = (tesla_data['Close'][-1] - tesla_data['Close'][0]) / tesla_data['Close'][0]\n",
+      "# Get historical stock data\n",
+      "meta_history = meta.history(start=start_date, end=today)\n",
+      "tesla_history = tesla.history(start=start_date, end=today)\n",
       "\n",
-      "# Print the year-to-date gain for META and TESLA\n",
-      "print(\"Year-to-date gain for META:\", round(meta_gain * 100, 2), \"%\")\n",
-      "print(\"Year-to-date gain for TESLA:\", round(tesla_gain * 100, 2), \"%\")\n",
+      "# Calculate year-to-date gain\n",
+      "meta_ytd_gain = (meta_history[\"Close\"][-1] - meta_history[\"Close\"][0]) / meta_history[\"Close\"][0] * 100\n",
+      "tesla_ytd_gain = (tesla_history[\"Close\"][-1] - tesla_history[\"Close\"][0]) / tesla_history[\"Close\"][0] * 100\n",
+      "\n",
+      "# Print the results\n",
+      "print(f\"META year-to-date gain: {meta_ytd_gain:.2f}%\")\n",
+      "print(f\"TESLA year-to-date gain: {tesla_ytd_gain:.2f}%\")\n",
       "```\n",
-      "Please save this code in a file named `stock_comparison.py` and run it. This script will print today's date and compare the year-to-date gain for META and TESLA. It uses the `yfinance` library to download the historical data for the stocks. If you haven't installed `yfinance`, please install it by running `pip install yfinance`.\n",
       "\n",
-      "--------------------------------------------------------------------------------\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "user_proxy (to assistant):\n",
+      "--------------------------------------------------------------------------------\n",
+      "\u001b[31m\n",
+      ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is sh)...\u001b[0m\n",
+      "\u001b[31m\n",
+      ">>>>>>>> EXECUTING CODE BLOCK 1 (inferred language is python)...\u001b[0m\n",
+      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
+      "\n",
+      "exitcode: 1 (execution failed)\n",
+      "Code output: \n",
+      "Defaulting to user installation because normal site-packages is not writeable\n",
+      "Requirement already satisfied: yfinance in /home/vscode/.local/lib/python3.9/site-packages (0.2.26)\n",
+      "Requirement already satisfied: lxml>=4.9.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.9.3)\n",
+      "Requirement already satisfied: requests>=2.31 in /usr/local/lib/python3.9/site-packages (from yfinance) (2.31.0)\n",
+      "Requirement already satisfied: multitasking>=0.0.7 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (0.0.11)\n",
+      "Requirement already satisfied: appdirs>=1.4.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.4.4)\n",
+      "Requirement already satisfied: html5lib>=1.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.1)\n",
+      "Requirement already satisfied: numpy>=1.16.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.25.1)\n",
+      "Requirement already satisfied: pandas>=1.3.0 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.3.3)\n",
+      "Requirement already satisfied: frozendict>=2.3.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2.3.8)\n",
+      "Requirement already satisfied: beautifulsoup4>=4.11.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.12.2)\n",
+      "Requirement already satisfied: pytz>=2022.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2023.3)\n",
+      "Requirement already satisfied: soupsieve>1.2 in /home/vscode/.local/lib/python3.9/site-packages (from beautifulsoup4>=4.11.1->yfinance) (2.4.1)\n",
+      "Requirement already satisfied: webencodings in /home/vscode/.local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (0.5.1)\n",
+      "Requirement already satisfied: six>=1.9 in /usr/local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (1.16.0)\n",
+      "Requirement already satisfied: python-dateutil>=2.7.3 in /home/vscode/.local/lib/python3.9/site-packages (from pandas>=1.3.0->yfinance) (2.8.2)\n",
+      "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2.0.3)\n",
+      "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.2.0)\n",
+      "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2023.5.7)\n",
+      "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.4)\n",
+      "\n",
+      "FB: No timezone found, symbol may be delisted\n",
+      "Traceback (most recent call last):\n",
+      "  File \"\", line 20, in <module>\n",
+      "    meta_ytd_gain = (meta_history[\"Close\"][-1] - meta_history[\"Close\"][0]) / meta_history[\"Close\"][0] * 100\n",
+      "  File \"/home/vscode/.local/lib/python3.9/site-packages/pandas/core/series.py\", line 939, in __getitem__\n",
+      "    return self._values[key]\n",
+      "IndexError: index -1 is out of bounds for axis 0 with size 0\n",
+      "\n",
+      "\n",
+      "--------------------------------------------------------------------------------\n",
+      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
+      "\n",
+      "I apologize for the error. It seems that the stock symbol for Meta Platforms (formerly Facebook) has changed to \"META\" instead of \"FB\". Let's update the code with the correct stock symbol and try again:\n",
+      "\n",
+      "```python\n",
+      "import yfinance as yf\n",
+      "from datetime import datetime, timedelta\n",
+      "\n",
+      "# Get today's date\n",
+      "today = datetime.now()\n",
+      "print(f\"Today's date is: {today.strftime('%Y-%m-%d')}\")\n",
+      "\n",
+      "# Calculate the start date for year-to-date\n",
+      "start_date = datetime(today.year, 1, 1)\n",
+      "\n",
+      "# Fetch stock data for META (Meta Platforms) and TESLA\n",
+      "meta = yf.Ticker(\"META\")\n",
+      "tesla = yf.Ticker(\"TSLA\")\n",
+      "\n",
+      "# Get historical stock data\n",
+      "meta_history = meta.history(start=start_date, end=today)\n",
+      "tesla_history = tesla.history(start=start_date, end=today)\n",
+      "\n",
+      "# Calculate year-to-date gain\n",
+      "meta_ytd_gain = (meta_history[\"Close\"][-1] - meta_history[\"Close\"][0]) / meta_history[\"Close\"][0] * 100\n",
+      "tesla_ytd_gain = (tesla_history[\"Close\"][-1] - tesla_history[\"Close\"][0]) / tesla_history[\"Close\"][0] * 100\n",
+      "\n",
+      "# Print the results\n",
+      "print(f\"META year-to-date gain: {meta_ytd_gain:.2f}%\")\n",
+      "print(f\"TESLA year-to-date gain: {tesla_ytd_gain:.2f}%\")\n",
+      "```\n",
+      "\n",
+      "--------------------------------------------------------------------------------\n",
+      "\u001b[31m\n",
+      ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n",
+      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
       "\n",
       "exitcode: 0 (execution succeeded)\n",
       "Code output: \n",
-      "Today's date: 2023-07-26\n",
-      "[*********************100%***********************]  1 of 1 completed\n",
-      "[*********************100%***********************]  1 of 1 completed\n",
-      "Year-to-date gain for META: 136.07 %\n",
-      "Year-to-date gain for TESLA: 145.4 %\n",
+      "Today's date is: 2023-07-31\n",
+      "META year-to-date gain: 157.94%\n",
+      "TESLA year-to-date gain: 145.71%\n",
       "\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "assistant (to user_proxy):\n",
+      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
+      "\n",
+      "Great! The code executed successfully. Today's date is 2023-07-31. The year-to-date gain for META (Meta Platforms) is 157.94%, and the year-to-date gain for TESLA is 145.71%. \n",
       "\n",
-      "Great! The code executed successfully. Today's date is July 26, 2023. The year-to-date gain for META is 136.07%, and the year-to-date gain for TESLA is 145.4%. Please let me know if you need any further assistance.\n",
+      "If you have any other questions or need further assistance, feel free to ask.\n",
       "\n",
       "TERMINATE\n",
       "\n",
@@ -192,19 +270,17 @@
     }
    ],
    "source": [
-    "from flaml.autogen.agentchat import AssistantAgent, UserProxyAgent\n",
-    "\n",
     "# create an AssistantAgent named \"assistant\"\n",
-    "assistant = AssistantAgent(\n",
+    "assistant = autogen.AssistantAgent(\n",
     "    name=\"assistant\",\n",
-    "    oai_config={\n",
+    "    llm_config={\n",
     "        \"seed\": 42,  # seed for caching and reproducibility\n",
     "        \"config_list\": config_list,  # a list of OpenAI API configurations\n",
     "        \"temperature\": 0,  # temperature for sampling\n",
-    "    },  # configuration for flaml.oai, an enhanced inference API compatible with OpenAI API\n",
+    "    },  # configuration for autogen's enhanced inference API which is compatible with OpenAI API\n",
     ")\n",
     "# create a UserProxyAgent instance named \"user_proxy\"\n",
-    "user_proxy = UserProxyAgent(\n",
+    "user_proxy = autogen.UserProxyAgent(\n",
     "    name=\"user_proxy\",\n",
     "    human_input_mode=\"NEVER\",\n",
     "    max_consecutive_auto_reply=10,\n",
@@ -248,59 +324,126 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "user_proxy (to assistant):\n",
+      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
       "\n",
       "Plot a chart of their stock price change YTD and save to stock_price_ytd.png.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "assistant (to user_proxy):\n",
+      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
+      "\n",
+      "To plot a chart of the stock price change YTD and save it to a file, we'll use the `matplotlib` library. First, you'll need to install the library by running the following command:\n",
+      "\n",
+      "```sh\n",
+      "pip install matplotlib\n",
+      "```\n",
+      "\n",
+      "After installing the library, execute the following Python code to plot the chart and save it to \"stock_price_ytd.png\":\n",
+      "\n",
+      "```python\n",
+      "import matplotlib.pyplot as plt\n",
+      "\n",
+      "# Plot the stock price change YTD\n",
+      "plt.figure(figsize=(10, 5))\n",
+      "plt.plot(meta_history.index, meta_history[\"Close\"], label=\"META\")\n",
+      "plt.plot(tesla_history.index, tesla_history[\"Close\"], label=\"TESLA\")\n",
+      "plt.xlabel(\"Date\")\n",
+      "plt.ylabel(\"Stock Price\")\n",
+      "plt.title(\"Stock Price Change YTD\")\n",
+      "plt.legend()\n",
+      "\n",
+      "# Save the chart to a file\n",
+      "plt.savefig(\"stock_price_ytd.png\")\n",
+      "plt.show()\n",
+      "```\n",
+      "\n",
+      "This code will create a chart of the stock price change YTD for META and TESLA and save it to a file named \"stock_price_ytd.png\".\n",
+      "\n",
+      "--------------------------------------------------------------------------------\n",
+      "\u001b[31m\n",
+      ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is sh)...\u001b[0m\n",
+      "\u001b[31m\n",
+      ">>>>>>>> EXECUTING CODE BLOCK 1 (inferred language is python)...\u001b[0m\n",
+      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
+      "\n",
+      "exitcode: 1 (execution failed)\n",
+      "Code output: \n",
+      "Defaulting to user installation because normal site-packages is not writeable\n",
+      "Requirement already satisfied: matplotlib in /home/vscode/.local/lib/python3.9/site-packages (3.7.2)\n",
+      "Requirement already satisfied: pillow>=6.2.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (10.0.0)\n",
+      "Requirement already satisfied: pyparsing<3.1,>=2.3.1 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (3.0.9)\n",
+      "Requirement already satisfied: fonttools>=4.22.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (4.41.1)\n",
+      "Requirement already satisfied: packaging>=20.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (23.1)\n",
+      "Requirement already satisfied: importlib-resources>=3.2.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (6.0.0)\n",
+      "Requirement already satisfied: python-dateutil>=2.7 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (2.8.2)\n",
+      "Requirement already satisfied: cycler>=0.10 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (0.11.0)\n",
+      "Requirement already satisfied: contourpy>=1.0.1 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (1.1.0)\n",
+      "Requirement already satisfied: kiwisolver>=1.0.1 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (1.4.4)\n",
+      "Requirement already satisfied: numpy>=1.20 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (1.25.1)\n",
+      "Requirement already satisfied: zipp>=3.1.0 in /home/vscode/.local/lib/python3.9/site-packages (from importlib-resources>=3.2.0->matplotlib) (3.16.2)\n",
+      "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.9/site-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)\n",
+      "\n",
+      "Traceback (most recent call last):\n",
+      "  File \"\", line 5, in <module>\n",
+      "    plt.plot(meta_history.index, meta_history[\"Close\"], label=\"META\")\n",
+      "NameError: name 'meta_history' is not defined\n",
+      "\n",
+      "\n",
+      "--------------------------------------------------------------------------------\n",
+      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
+      "\n",
+      "I apologize for the error. It seems I forgot to include the previous code to fetch the stock data. Let's combine the code to fetch the stock data and plot the chart:\n",
       "\n",
-      "# filename: stock_price_chart.py\n",
       "```python\n",
-      "import datetime\n",
       "import yfinance as yf\n",
+      "from datetime import datetime\n",
       "import matplotlib.pyplot as plt\n",
       "\n",
       "# Get today's date\n",
-      "today = datetime.date.today()\n",
+      "today = datetime.now()\n",
       "\n",
-      "# Get the start of the year\n",
-      "start_of_year = datetime.date(today.year, 1, 1)\n",
+      "# Calculate the start date for year-to-date\n",
+      "start_date = datetime(today.year, 1, 1)\n",
       "\n",
-      "# Download the historical data for META and TESLA\n",
-      "meta_data = yf.download('META', start=start_of_year, end=today)\n",
-      "tesla_data = yf.download('TSLA', start=start_of_year, end=today)\n",
+      "# Fetch stock data for META (Meta Platforms) and TESLA\n",
+      "meta = yf.Ticker(\"META\")\n",
+      "tesla = yf.Ticker(\"TSLA\")\n",
       "\n",
-      "# Plot the stock price change YTD for META and TESLA\n",
-      "plt.figure(figsize=(10, 6))\n",
-      "plt.plot(meta_data['Close'], label='META')\n",
-      "plt.plot(tesla_data['Close'], label='TSLA')\n",
-      "plt.xlabel('Date')\n",
-      "plt.ylabel('Stock Price')\n",
-      "plt.title('Stock Price Change YTD for META and TESLA')\n",
+      "# Get historical stock data\n",
+      "meta_history = meta.history(start=start_date, end=today)\n",
+      "tesla_history = tesla.history(start=start_date, end=today)\n",
+      "\n",
+      "# Plot the stock price change YTD\n",
+      "plt.figure(figsize=(10, 5))\n",
+      "plt.plot(meta_history.index, meta_history[\"Close\"], label=\"META\")\n",
+      "plt.plot(tesla_history.index, tesla_history[\"Close\"], label=\"TESLA\")\n",
+      "plt.xlabel(\"Date\")\n",
+      "plt.ylabel(\"Stock Price\")\n",
+      "plt.title(\"Stock Price Change YTD\")\n",
       "plt.legend()\n",
       "\n",
-      "# Save the chart to stock_price_ytd.png\n",
-      "plt.savefig('stock_price_ytd.png')\n",
+      "# Save the chart to a file\n",
+      "plt.savefig(\"stock_price_ytd.png\")\n",
       "plt.show()\n",
       "```\n",
       "\n",
-      "Please save this code in a file named `stock_price_chart.py` and run it. This script will plot the stock price change YTD for META and TESLA and save the chart to a file named `stock_price_ytd.png`. It uses the `matplotlib` library to create the chart. If you haven't installed `matplotlib`, please install it by running `pip install matplotlib`.\n",
+      "This code will fetch the stock data for META and TESLA, create a chart of the stock price change YTD, and save it to a file named \"stock_price_ytd.png\".\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "user_proxy (to assistant):\n",
+      "\u001b[31m\n",
+      ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n",
+      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
       "\n",
       "exitcode: 0 (execution succeeded)\n",
       "Code output: \n",
-      "[*********************100%***********************]  1 of 1 completed\n",
-      "[*********************100%***********************]  1 of 1 completed\n",
-      "Figure(1000x600)\n",
+      "Figure(1000x500)\n",
       "\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "assistant (to user_proxy):\n",
+      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
       "\n",
-      "Great! The code executed successfully, and the chart of the stock price change YTD for META and TESLA has been saved to a file named `stock_price_ytd.png`. You can now view the chart in the saved file. If you need any further assistance, please let me know.\n",
+      "Great! The code executed successfully and created a chart of the stock price change YTD for META and TESLA. The chart has been saved to a file named \"stock_price_ytd.png\".\n",
+      "\n",
+      "If you have any other questions or need further assistance, feel free to ask.\n",
       "\n",
       "TERMINATE\n",
       "\n",
@@ -331,7 +474,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+gAAAH0CAYAAACuKActAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAADEhklEQVR4nOzdd3hU1dbH8e+k9wQCIUBCr0no0qvSRan2BvaC+lquXrGXq9iu7doFaYogiopYEJAmvffeWwghvZc57x8nGQgJIWWSSfl9nmeeOXPKPmtSIGv23mtbDMMwEBERERERERGHcnJ0ACIiIiIiIiKiBF1ERERERESkQlCCLiIiIiIiIlIBKEEXERERERERqQCUoIuIiIiIiIhUAErQRURERERERCoAJegiIiIiIiIiFYASdBEREREREZEKQAm6iIiIiIiISAWgBF1ERERERESkAlCCLiIiIiIiIlIBKEEXERERERERqQCUoIuIiIiIiIhUAErQRURERERERCoAJegiIiIiIiIiFYASdBEREREREZEKQAm6iIiIiIiISAWgBF1ERERERESkAlCCLiIiIiIiIlIBKEEXERERERERqQCUoIuIiIiIiIhUAErQRURERERERCoAJegiIiIiIiIiFYASdBEREREREZEKQAm6iIiIiIiISAWgBF1ERERERESkAlCCLiIiIiIiIlIBKEEXERERERERqQCUoIuIiIiIiIhUAErQRURERERERCoAJegiIiIiIiIiFYASdBEREREREZEKQAm6iIiIiIiISAWgBF1ERERERESkAlCCLiIiIiIiIlIBKEEXERERERERqQCUoIuIiIiIiIhUAErQRUSkWlu6dCkWi4UffvjBIfefOnUqFouFI0eOOOT+RdGvXz8iIiIcHYaIiEiVpwRdRETK3fbt27nuuuto2LAhHh4e1K9fn4EDB/K///0vz3lvvPEGP//8s2OCLIIjR45gsVhsD2dnZxo0aMCoUaPYsmWLo8O7rISEBF555RXatWuHj48Pnp6eRERE8O9//5tTp045OrxykZmZSZs2bWjatCmpqan5jh85cgQvLy+uv/76PN/rwh5Lly7N97Ph6upKrVq16NGjB88++yzHjh1zwLsVEZGKzmIYhuHoIEREpPpYtWoVV155JQ0aNGDs2LEEBwdz/Phx1qxZw8GDBzlw4IDtXB8fH6677jqmTp1aZvEsXbqUK6+8kjlz5nDdddcV69ojR47QuHFjbr75Zq6++mqys7PZvXs3n332Genp6axZs4b27dsX2kZ2djaZmZm4u7tjsVhK8U6K59ChQwwYMIBjx45x/fXX06tXL9zc3Ni2bRvfffcdNWvWZN++fYDZgx4dHc2OHTvKLb7ytHr1anr27MkzzzzDG2+8kefYNddcwz///MPu3btZvHhxnmPTp09n4cKFzJgxI8/+gQMHkpqamudnw2q1Ehsby/r165k7dy4Wi4XJkydz0003lfn7ExGRysPF0QGIiEj18vrrr+Pv78/69esJCAjIcywqKsoxQZVSx44due2222yve/bsyfDhw/nss8/44osvCrwmOTkZb29vnJ2dcXZ2Lq9QAcjKymL06NGcOXOGpUuX0qtXrzzHX3/9dd56661yjcmRunfvzgMPPMC7777LrbfeSnh4OAA//vgjv/32G59++il169bN8z0GWLNmDQsXLsy3H7BNWbj4ZwPg6NGjDBo0iLFjx9K6dWvatWtXNm9MREQqHQ1xFxGRcnXw4EHCw8PzJecAQUFBtm2LxUJycjLTpk2zDRMeN26c7fjmzZsZOnQofn5++Pj40L9/f9asWZOvzbi4OB5//HEaNWqEu7s7ISEh3HHHHURHR18yxvT0dK655hr8/f1ZtWpVsd/jVVddBcDhw4eB8/PMly1bxkMPPURQUBAhISF5jl08B/2PP/6gb9+++Pr64ufnR+fOnZk5c2aec9auXcuQIUPw9/fHy8uLvn37snLlysvG9+OPP7J161aee+65fMk5gJ+fH6+//nq+/bt27eLKK6/Ey8uL+vXr8/bbb+c5npGRwYsvvkinTp3w9/fH29ub3r17s2TJkjzn5Q7/fvfdd/nyyy9p2rQp7u7udO7cmfXr1+e775w5cwgLC8PDw4OIiAh++uknxo0bR6NGjfKcZ7Va+eCDDwgPD8fDw4M6depw//33Exsbe9mvycSJE6lVqxYPPPAAhmGQlJTEY489Zkve7alhw4ZMnTqVjIyMfF9DERGp3tSDLiIi5aphw4asXr2aHTt2FFp4bMaMGdxzzz106dKF++67D4CmTZsCsHPnTnr37o2fnx9PP/00rq6ufPHFF/Tr149ly5bRtWtXAJKSkujduze7d+/mrrvuomPHjkRHRzNv3jxOnDhBrVq18t03NTWVESNGsGHDBhYtWkTnzp2L/R4PHjwIQGBgYJ79Dz30ELVr1+bFF18kOTn5ktdPnTqVu+66i/DwcCZMmEBAQACbN2/mzz//5JZbbgHg77//ZujQoXTq1ImXXnoJJycnpkyZwlVXXcWKFSvo0qXLJdufN28eALfffnuR31NsbCxDhgxh9OjR3HDDDfzwww/8+9//pk2bNgwdOhQw57RPmjSJm2++mXvvvZfExEQmT57M4MGDWbduXb7h/jNnziQxMZH7778fi8XC22+/zejRozl06BCurq4A/Pbbb9x44420adOGiRMnEhsby9133039+vXzxXj//fczdepU7rzzTh599FEOHz7Mxx9/zObNm1m5cqWtzYL4+/vz0Ucfcf311zNp0iR27drFmTNn+OOPP8pk6kH37t1p2rQpCxcutHvbIiJSiRkiIiLl6K+//jKcnZ0NZ2dno3v37sbTTz9tLFiwwMjIyMh3rre3tzF27Nh8+0eOHGm4ubkZBw8etO07deqU4evra/Tp08e278UXXzQAY+7cufnasFqthmEYxpIlSwzAmDNnjpGYmGj07dvXqFWrlrF58+bLvpfDhw8bgPHKK68YZ8+eNSIjI42lS5caHTp0MADjxx9/NAzDMKZMmWIARq9evYysrKw8beQeO3z4sGEYhhEXF2f4+voaXbt2NVJTUwuM2Wq1Gs2bNzcGDx5s22cYhpGSkmI0btzYGDhwYKFxd+jQwfD397/s+8vVt29fAzCmT59u25eenm4EBwcbY8aMse3Lysoy0tPT81wbGxtr1KlTx7jrrrts+3K/boGBgUZMTIxt/y+//GIAxq+//mrb16ZNGyMkJMRITEy07Vu6dKkBGA0bNrTtW7FihQEY3377bZ77//nnnwXuv5RrrrnG8Pf3N5ydnY0JEyYUeu748eONS/0plfse33nnnUteP2LECAMw4uPjixSbiIhUfRriLiIi5WrgwIGsXr2a4cOHs3XrVt5++20GDx5M/fr1bT27hcnOzuavv/5i5MiRNGnSxLa/bt263HLLLfzzzz8kJCQA5lDudu3aMWrUqHztXNwrGh8fz6BBg9izZw9Lly69bHG3C7300kvUrl2b4OBg+vXrx8GDB3nrrbcYPXp0nvPuvffey843X7hwIYmJiTzzzDN4eHgUGPOWLVvYv38/t9xyC+fOnSM6Opro6GiSk5Pp378/y5cvx2q1XvIeCQkJ+Pr6Fvn9gVmw78K51G5ubnTp0oVDhw7Z9jk7O+Pm5gaYw81jYmLIysriiiuuYNOmTfnavPHGG6lRo4btde/evQFsbZ46dYrt27dzxx134OPjYzuvb9++tGnTJk9bc+bMwd/fn4EDB9q+HtHR0XTq1AkfH598w+wv5ZNPPiEjI4PQ0FBeeOGFIl1TUrnvKTExsUzvIyIilYeGuIuISLnr3Lkzc+fOJSMjg61bt/LTTz/x/vvvc91117FlyxbCwsIuee3Zs2dJSUmhZcuW+Y61bt0aq9XK8ePHCQ8P5+DBg4wZM6ZIMT322GOkpaWxefNmW5Gworrvvvu4/vrrcXJyIiAggPDwcNzd3fOd17hx48u2lTs8vrDh//v37wdg7NixlzwnPj4+T/J7IT8/vzyJdVGEhITk+1CjRo0abNu2Lc++adOm8d///pc9e/aQmZlp21/Qe2/QoEG+9gDbnPGjR48C0KxZs3zXNmvWLE/Sv3//fuLj4/PUMbhQUQsQNmjQgKCgIMLDw/H09CzSNSWVlJQEUOwPS0REpOpSgi4iIg7j5uZG586d6dy5My1atODOO+9kzpw5vPTSS+Uey4gRI5g1axZvvvkm06dPx8mp6IPMmjdvzoABAy57nr0Svtze8XfeeeeSPf0X9jhfrFWrVmzevJnjx48TGhpapHtequffuGC11m+++YZx48YxcuRInnrqKYKCgnB2dmbixIm2Dx6K22ZRWa1WgoKC+Pbbbws8Xrt27WK3WdZ27NhBUFAQfn5+jg5FREQqCCXoIiJSIVxxxRUAnD592ravoOJctWvXxsvLi7179+Y7tmfPHpycnGxJZ9OmTYu8dvfIkSMZNGgQ48aNw9fXl88++6wkb6PUcgvh7dixo8Ce4wvP8fPzK9IHAxe79tpr+e677/jmm2+YMGFCyYO9yA8//ECTJk1s63znKukHLg0bNgTgwIED+Y5dvK9p06YsWrSInj17lnnPtz2sXr2agwcPFrhEm4iIVF+agy4iIuVqyZIlBfaQ/v777wB5hq57e3sTFxeX5zxnZ2cGDRrEL7/8kmdpsjNnzjBz5kx69epl65EcM2aMbQj9xQqK4Y477uCjjz7i888/59///ndJ3l6pDRo0CF9fXyZOnEhaWlqeY7kxd+rUiaZNm/Luu+/ahklf6OzZs4Xe47rrrqNNmza8/vrrrF69Ot/xxMREnnvuuWLHntsjfuHXdu3atQXeoyjq1atHREQE06dPz/M+ly1bxvbt2/Oce8MNN5Cdnc1rr72Wr52srKx8P0eOdPToUcaNG4ebmxtPPfWUo8MREZEKRD3oIiJSrh555BFSUlIYNWoUrVq1IiMjg1WrVjF79mwaNWrEnXfeaTu3U6dOLFq0iPfee4969erRuHFjunbtyn/+8x8WLlxIr169eOihh3BxceGLL74gPT09z7rSTz31FD/88APXX389d911F506dSImJoZ58+bx+eef065du3zxPfzwwyQkJPDcc8/h7+/Ps88+Wy5fl1x+fn68//773HPPPXTu3JlbbrmFGjVqsHXrVlJSUpg2bRpOTk5MmjSJoUOHEh4ezp133kn9+vU5efIkS5Yswc/Pj19//fWS93B1dWXu3LkMGDCAPn36cMMNN9CzZ09cXV3ZuXMnM2fOpEaNGgWuhV6Ya665hrlz5zJq1CiGDRvG4cOH+fzzzwkLCyvwg4SieOONNxgxYgQ9e/bkzjvvJDY2lo8//piIiIg8bfbt25f777+fiRMnsmXLFgYNGoSrqyv79+9nzpw5fPjhh1x33XUliqE0Nm3axDfffIPVaiUuLo7169fz448/YrFYmDFjBm3bti33mEREpAJzZAl5ERGpfv744w/jrrvuMlq1amX4+PgYbm5uRrNmzYxHHnnEOHPmTJ5z9+zZY/Tp08fw9PQ0gDxLrm3atMkYPHiw4ePjY3h5eRlXXnmlsWrVqnz3O3funPHwww8b9evXN9zc3IyQkBBj7NixRnR0tGEYeZdZu9DTTz9tAMbHH398yfdSlKW0DOP8Umrr16+/5LHcZdZyzZs3z+jRo4fh6elp+Pn5GV26dDG+++67POds3rzZGD16tBEYGGi4u7sbDRs2NG644QZj8eLFhcaTKzY21njxxReNNm3aGF5eXoaHh4cRERFhTJgwwTh9+rTtvL59+xrh4eH5rh87dmyepc6sVqvxxhtvGA0bNjTc3d2NDh06GPPnz893XmFfN8B46aWX8uybNWuW0apVK8Pd3d2IiIgw5s2bZ4wZM8Zo1apVvuu//PJLo1OnToanp6fh6+trtGnTxnj66aeNU6dOFelrYhiG0bBhQ2PYsGGXPa8oy6zlPlxcXIyaNWsaXbt2NSZMmGAcPXq0yPGIiEj1YTGMElRiEREREXGg9u3bU7t2bRYuXOjoUEREROxGc9BFRESkwsrMzCQrKyvPvqVLl7J161b69evnmKBERETKiHrQRUREpMI6cuQIAwYM4LbbbqNevXrs2bOHzz//HH9/f3bs2EFgYKCjQxQREbEbFYkTERGRCqtGjRp06tSJSZMmcfbsWby9vRk2bBhvvvmmknMREaly1IMuIiIiIiIiUgFoDrqIiIiIiIhIBaAEXURERERERKQC0Bz0asZqtXLq1Cl8fX2xWCyODkdERERERBzEMAwSExOpV68eTk7qu60IlKBXM6dOnSI0NNTRYYiIiIiISAVx/PhxQkJCHB2GoAS92vH19QXMX0I/Pz8HRyMiIiIiIo6SkJBAaGioLUcQx1OCXs3kDmv38/NTgi4iIiIiIpr6WoFoooGIiIiIiIhIBaAEXURERERERKQCUIIuIiIiIiIiUgFoDroUKDs7m8zMTEeHUeW5urri7Ozs6DBERERERKQCUIIueRiGQWRkJHFxcY4OpdoICAggODhYxTlERERERKo5JeiSR25yHhQUhJeXl5LGMmQYBikpKURFRQFQt25dB0ckIiIiIiKOpARdbLKzs23JeWBgoKPDqRY8PT0BiIqKIigoSMPdRURERESqMRWJE5vcOedeXl4OjqR6yf16a86/iIiIiEj1pgRd8tGw9vKlr7eIiIiIiIASdBEREREREZEKQQm6iIiIiIiISAWgBF2qhHHjxmGxWHjggQfyHRs/fjwWi4Vx48blOffix5AhQ1i6dGmBxy58LF26FIATJ07g5uZGREREOb5TERERERGpqlTFXaqM0NBQZs2axfvvv2+rjp6WlsbMmTNp0KBBnnOHDBnClClT8uxzd3fH29ub06dP2/b93//9HwkJCXnOrVmzJgBTp07lhhtuYPny5axdu5auXbuW1VsTEREREZFqQAm6VBkdO3bk4MGDzJ07l1tvvRWAuXPn0qBBAxo3bpznXHd3d4KDgwts58L9np6epKen5zvXMAymTJnCp59+SkhICJMnT1aCLiIiIlJNpWVm882ao3RpXJO2IQGODkcqMSXoUijDMEjNzC73+3q6Opeouvldd93FlClTbAn6119/zZ133mkblm4vS5YsISUlhQEDBlC/fn169OjB+++/j7e3t13vIyIiIiIV369bT/Gf33ZjscC4Ho14clBLfNyVaknx6adGCpWamU3YiwvK/b67Xh2Ml1vxfzxvu+02JkyYwNGjRwFYuXIls2bNypegz58/Hx8fnzz7nn32WZ599tki3Wfy5MncdNNNODs7ExERQZMmTZgzZ45tnruIiIiIVB97IxMBMAyYsvIIC3ZE8trICPq3ruPgyKSyUYIuVUrt2rUZNmwYU6dOxTAMhg0bRq1atfKdd+WVV/LZZ5/l2Zc7t/xy4uLimDt3Lv/8849t32233cbkyZOVoIuIiIhUQ4eikwEY3aE+64/GcDwmlbunbWBY27q8dG0YQb4eDo5QKgsl6FIoT1dndr062CH3Lam77rqLhx9+GIBPPvmkwHO8vb1p1qxZidqfOXMmaWlpeeacG4aB1Wpl3759tGjRokTtioiIiEjldOhsEgDXdQrh9VFt+GDRPib9c5jftp1mxb6zPHt1a27sHFqiKZxSvShBl0JZLJYSDTV3pCFDhpCRkYHFYmHwYPt/uDB58mSefPLJfL3lDz30EF9//TVvvvmm3e8pIiIiIhVTRpaV47GpADSp7YOnmzMTrm7Nte3qMWHudrafjOeZudv5afNJ3hjdhqa1fS7TolRnWgddqhxnZ2d2797Nrl27cHYuuCc+PT2dyMjIPI/o6OjLtr1lyxY2bdrEPffcQ0RERJ7HzTffzLRp08jKyrL3WxIRERGRCupYTDLZVgNvN2fq+Lnb9kfU9+enh3rw/LDWeLo6s/ZwDEM/WMFHi/eTkWV1YMRSkSlBlyrJz88PPz+/Sx7/888/qVu3bp5Hr169Ltvu5MmTCQsLo1WrVvmOjRo1iqioKH7//fdSxS4iIiIilcfBs+b888a1vfMNYXdxduKe3k346/E+9GlRm4xsK+8t3Mc1/1tBUro6dSQ/i2EYhqODkPKTkJCAv78/8fHx+RLYtLQ0Dh8+TOPGjfHwUCGL8qKvu4iIiEjl9dnSg7z15x6Gt6vHRzd3uOR5hmEwb+spXv11F72b1+KDmy59bnkpLDcQx6hck4tFREREREQqkMPRZoG4JrW9Cz3PYrEwon19+jSvXR5hSSWlBF1ERERERKSEDuUMcW9SxOJvNbzdyjIcqeQ0B11ERERERKSEctdAb1Kr8B50kaJQgi4iIiIiIlICcSkZxCRnAJcf4i5SFErQRURERERESiC3gntdfw+83DR7WEpPCbqIiIiIiEgJHDpbtAJxIkWlBF1ERERERKqEtMxsdp9OKLf7nZ9/XrQCcSKXowRdRERERESqhAe+2cjQD1ew5tC5crmfetDF3pSgi4iIiIhIpffP/miW7j0LwIYjMeVyz9wl1hqrgrvYiRJ0qdQsFkuhj5dffpkjR45c8viaNWsAyM7O5s0336RVq1Z4enpSs2ZNunbtyqRJk2z3GjduHCNHjrxsTCdOnMDNzY2IiIiyetsiIiIicgHDMHh7wR7b69zibWUp22pw9FwKAE2LuAa6yOWo1KBUaqdPn7Ztz549mxdffJG9e/fa9vn4+BAdHQ3AokWLCA8Pz3N9YGAgAK+88gpffPEFH3/8MVdccQUJCQls2LCB2NjYYsc0depUbrjhBpYvX87atWvp2rVrSd6aiIiISJWXlW3FAFydS9dv+OeOSLadiLe9Ppgz9LwsnYhNISPbipuLE/UCPMv8flI9KEGXSi04ONi27e/vj8ViybMPsCXogYGB+Y7lmjdvHg899BDXX3+9bV+7du2KHY9hGEyZMoVPP/2UkJAQJk+erARdREREpABZ2VbGfLaKqMR0fn+0NzW83Urczrt/mR00V7cJ5vftkRw6m4xhGFgsFnuGnIdteHugN85OZXcfqV40xF0EM9H/+++/OXv2bKnaWbJkCSkpKQwYMIDbbruNWbNmkZxc9kOsRERERCqbuZtOsvVEPKfj05ix5mip2jl4NpkaXq78Z2QbnJ0sJKVnEZWYbsdo8zuoAnFSBpSgS+EMAzKSy/9hGHZ/Kz169MDHxyfPI9d7773H2bNnCQ4Opm3btjzwwAP88ccfxb7H5MmTuemmm3B2diYiIoImTZowZ84ce74NERERkUovI8vKh4v3215PXXWEtMzsYrez61QC/11o9p4/1K8ZNb3daFDTC4CDUWU7zN22xJoSdLEjDXGXwmWmwBv1yv++z54CN/v+Yzd79mxat25d4LGwsDB27NjBxo0bWblyJcuXL+faa69l3LhxeQrFFSYuLo65c+fyzz//2PbddtttTJ48mXHjxtnjLYiIiIhUCbM3HOdkXCpBvu64uThxIjaVORtPcHu3hkW6PivbyhfLD/HBon1kZhs0qOnF7d3Na5vW9uZwdDIHzybRo1mtMnsPtiXWtAa62JESdKk2QkNDadas2SWPOzk50blzZzp37sxjjz3GN998w+23385zzz1H48aNL9v+zJkzSUtLyzPn3DAMrFYr+/bto0WLFnZ5HyIiIiKVWVpmNh//bfaeP3xVMwwDXpq3k6+WH+KWLg0Knc8dnZTOiv1nmbbqKFuOxwEwMKwOb4xqg4erM2BWVF+0O6rMK7nntt80SAm62I8SdCmcq5fZm+2I+zpYWFgYQJHnkE+ePJknn3wyX2/5Qw89xNdff82bb75p7xBFREREKp1v1hzlTEI69QM8ubFzKNlWgw8W7eNYTAp/7ohkWNu6tnMzsqxsOhbL8n1nWbbvLDtPJdiO+Xq48PK14YzuWD9PMbjcJc/KspJ7fGomZ3PmuDfVEHexIyXoUjiLxe5DzR3l3LlzREZG5tkXEBCAh4cH1113HT179qRHjx4EBwdz+PBhJkyYQIsWLWjVqpXt/Pj4eLZs2ZKnjcDAQM6dO8emTZv49ttv85wPcPPNN/Pqq6/yn//8BxcX/cqJiIhI9ZWcnsXnyw4C8MhVzXB3MXu97+jeiA8X7+fzZQdpU9+fZfvPsnzfWVYdiCY5I+/c9PB6fvRtUZvbuzekrn/+5c1y54QfKsMe9AM589uD/Tzw9XAts/tI9aNsQaqNAQMG5Nv33XffcdNNNzF48GC+++47Jk6cSHx8PMHBwVx11VW8/PLLeZLqpUuX0qFDhzxt3H333Xh6ehIWFpYvOQcYNWoUDz/8ML///jvDhw+3/xsTERERqSQW7T5DdFIGDWp6MaZTiG3/Hd0b8sXyg2w/GU+fd5bkuSbQ243ezWvRt2VtejWrTW1f90LvkduDfjIulZSMLLzc7J/y5Baga6bh7WJnStClyhg3blyBxdgaNWqEcZmq8Pfeey/33ntvoedMnTqVqVOnFjuu4OBgsrOLX5VUREREpKrJHaLer2VtXJ3PLygV6OPObV0bMumfw7g4WejYsAZ9W9Smb4vahNX1w6kY64zX8HajprcbMckZHI5OJryev93fx4GzStClbChBFxERERGRcrHzVDwAYXX98h17ZmgrhrWtS7Mgn1IPG29a25uY5AwOni2bBD23B10F4sTetA66iIiIiIiUOcMw2JXTg15Q0uzi7ESHBjXsMqc7d+mzsloLPbcHXQXixN6UoIuIiIiISJk7HZ9GbEomzk4Wmtcp257npkFm4lwWldzTMrM5HpMCaIi72J8SdBERERERKXO5vefNg3xsa5aXlfNLrdm/kvvh6GSsBvh5uFDbp/CCdSLFpQRdRERERETKXG6BuILmn9tbboJ+ODoJq7XwYsHFdeCCCu4Xrr8uYg9K0CWfy1U8F/vS11tERESqg12ncwrE1Sv7BD2khieuzhbSMq2cik+1a9sHtMSalCEl6GLj6moW5EhJSXFwJNVL7tc79+svIiIiUhXZetDLIUF3cXaiUWDuPHT7DnM/qCXWpAxpmTWxcXZ2JiAggKioKAC8vLw0bKcMGYZBSkoKUVFRBAQE4OxctnOxRERERBwlPjWTE7FmT3Z4Xfsve1aQprV92B+VxMGoJPq2qG23dnN70HOH0YvYkxJ0ySM4OBjAlqRL2QsICLB93UVERESqotwCcfUDPPH3Kp9Rg02DvGEnHIq2XyX3bKvBoWizR1496FIWlKCXk88++4zPPvuMI0eOABAeHs6LL77I0KFDAUhLS+PJJ59k1qxZpKenM3jwYD799FPq1Klja+PYsWM8+OCDLFmyBB8fH8aOHcvEiRNxcbHft9FisVC3bl2CgoLIzMy0W7tSMFdXV/Wci4iISJW363Tu+udlP7w9V24CnfvhgD2ciE0hI8uKm4sTITW87NauSC4l6OUkJCSEN998k+bNm2MYBtOmTWPEiBFs3ryZ8PBwHn/8cX777TfmzJmDv78/Dz/8MKNHj2blypUAZGdnM2zYMIKDg1m1ahWnT5/mjjvuwNXVlTfeeMPu8To7OytxFBERERG72Hmq/ArE5erUoCYA207Ek5yehbd76VOf3OHtTWp54+ykqaBifyoSV06uvfZarr76apo3b06LFi14/fXX8fHxYc2aNcTHxzN58mTee+89rrrqKjp16sSUKVNYtWoVa9asAeCvv/5i165dfPPNN7Rv356hQ4fy2muv8cknn5CRkeHgdyciIiIicmm5vdjh9cpn/jlAaE1P6gd4kmU12Hg01i5tqoK7lDUl6A6QnZ3NrFmzSE5Opnv37mzcuJHMzEwGDBhgO6dVq1Y0aNCA1atXA7B69WratGmTZ8j74MGDSUhIYOfOneX+HkREREREiiI9K9uW2JbnEHeLxUK3JoEArD50zi5t5lZwV4E4KSsa4l6Otm/fTvfu3UlLS8PHx4effvqJsLAwtmzZgpubGwEBAXnOr1OnDpGRkQBERkbmSc5zj+ceu5T09HTS09NtrxMS7DcHR0RERETkcvafSSLLahDg5Updf49yvXf3poH8uOkEqw/aJ0FXD7qUNfWgl6OWLVuyZcsW1q5dy4MPPsjYsWPZtWtXmd5z4sSJ+Pv72x6hoaFlej8RERERkQvlzj8Pr+dX7kv4dm9q9qBvPxlPUnpWqdoyDEMJupQ5JejlyM3NjWbNmtGpUycmTpxIu3bt+PDDDwkODiYjI4O4uLg85585c8a2/FZwcDBnzpzJdzz32KVMmDCB+Ph42+P48eP2fVMiIiIiIoXYmTP/PKxu+Q1vz1U/wJMGNb3IthqsPxxTqraOxaSQkJaFxQKNa3nbKUKRvJSgO5DVaiU9PZ1OnTrh6urK4sWLbcf27t3LsWPH6N69OwDdu3dn+/btedYnX7hwIX5+foSFhV3yHu7u7vj5+eV5iIiIiIiUh7TMbP7YYU7HbB9awyExdLfTPPTPlh4EoEfTQDxctdqRlA3NQS8nEyZMYOjQoTRo0IDExERmzpzJ0qVLWbBgAf7+/tx999088cQT1KxZEz8/Px555BG6d+9Ot27dABg0aBBhYWHcfvvtvP3220RGRvL8888zfvx43N3dHfzuRERERETy+3btMc4mphNSw5OBYXUuf0EZ6N40kNkbjpdqHvrRc8nM2XgCgMcHtLBXaCL5KEEvJ1FRUdxxxx2cPn0af39/2rZty4IFCxg4cCAA77//Pk5OTowZM4b09HQGDx7Mp59+arve2dmZ+fPn8+CDD9K9e3e8vb0ZO3Ysr776qqPekoiIiIjIJaVlZvP5MrPX+eErm+Hm4pjBu7mV3Heeiic+NRN/T9dit/HR4gNkWw36tKjNFY1q2jtEERuLYRiGo4OQ8pOQkIC/vz/x8fEa7i4iIiIiZWbyP4d5bf4uQmp48veT/RyWoANc+e5SDkcnM+mOKxhQzJ78g2eTGPjeMqwG/Dy+J+1DA8omSAdQblDxaA66iIiIiIjYVUXpPc9VmvXQP1y0H6sBA1oHVankXComJegiIiIiImKz42Q8S/ZEXf7EQlw493x0xxA7RVZyucutFXce+r4zify67RQAj2nuuZQDJegiIiIiIgJAbHIGN3+5hjunrmf66iPFvt4wDH7ZcpL//b0fqBi95wDdmpjzxnedTuCGz1czf9spMrOthV6TkWXlqR+2YRgwJDyYiPr+5RGqVHMqEiciIiIiIgBM+ucQielZALw8byfBfh4MCg8u0rWbj8Xy2vxdbDoWB0Drun5l33uenQkLngU3H7jyOXAuOL0J8vXg0aua8cnSg6w7EsO6IzHU8XPnli4NublrKEG+Hvmu+e9fe9l6PA4/DxdeuPbSyxqL2JOKxFUzKgQhIiIiIgWJTc6g11t/k5yRTbvQALYej8PD1Ynv7u1GhwaXXsP8VFwqb/+5h5+3mEPBPV2deahfU+7p3QRPtzJeL/zv/8Dyd8zt8FEwetIlk3SAyPg0Zq47xsy1x4hOSgfA1dnC1W3qckf3RnRsEIDFYmHZvrOM/XodAJ/f1okhEUX7kKKyUW5Q8ShBr2b0SygiIiIiBXlnwR4+WXKQsLp+/PJwT+6bvoEle89S09uNb+/pSuu6ef92TMnI4vNlh/hy+UHSMs3h4td1CuGpwS2p45e/R9rujq2FKUPAsILFGYxsCBsJYyaBc+FLqWVkWfljx2mmrz7KxqOxtv3h9fy4qXMoHy7eT3RSBrd3a8hrIyPK+I04jnKDikcJejWjX0IRERERuVhMcga9c3rPv7i9E4PDg0lOz+KmL9ew/WQ8bi5OPD24JXf1bAzAz1tO8tafeziTYPZCd2lUkxeuCaNNSDnN005PhM97QewRaHuj2Xs++3awZkLYCBjzdaE96RfacTKe6auP8MuWU6RnnZ+X3irYl5/H98TDtYxHATiQcoOKRwl6NaNfQhERERG52Nt/7uHTpWbv+W+P9sJisQBm4v7k91tYsvcsAN2bBJKckcW2E/EAhNTw5NmrWzM0Ith2Tbn4ZTxs/gb8Q+HBleDhD3v/hO9vh+wMuHkWtBxarCZjkzP4fsNxZqw5SkpGNrPv60bzOr5l9AYqBuUGFY+KxImIiIiIVGMxyRlMW3UEgMcGNM+TaNf0duPrcZ2Zue4Y/5m/27aOuI+7C+OvbMadPRuVfw/z7vlmco4FRn1uJucALYdAiyGwex7EHS92szW83bi/b1Pu69MEqwHOTuX4gYNIDiXoIiIiIiLV2FcrDpGckU14PT8GhtXJd9xisXBr14b0aFqLN37fTbCfB4/2b05tX/fyDzYxEuY9Ym73fBQa9cp73MtcTo3UmBLfwmKx4KzcXBxECbqIiIiISDkxDIPl+6Pp0CAAP4/CC5mVh7y95y0KHabeuJY3X91xRTlFVgDDgF8eNpPvOm3MZdUu5pmToKeUPEEXcSQnRwcgIiIiIlJdfL3yCGO/Xsc9UzdgtTq+FNRXKw6RkpFNRH0/BrQOcnQ4hVs/CQ4sBGd3GPMVuBTQg2+HHnQRR1KCLiIiIiJSDuJTMvlo8X4A1h2J4cdNJxwaz7mk9PO95/0L7z13uLP74K8XzO2Br0BQ64LPUw+6VHJK0EVEREREysGnyw4Qn5qJm4v5J/jEP/YQm5xRpGvnbzvFOwv2kJKRVeh5O07G897CfXy/4Tgbj8YU2v5XKw7bes/7V+Te86wMmHsvZKVCk37Q5f5Ln6sedKnkNAddRERERKSMnYxLZcrKIwB8dFMH3l+4j71nEnl7wR4mjm5b6LWZ2Vae/mEbKRnZLNt3lkl3dCbY3yPfeVarwYPfbuR4TGqe/TW93WhSy5smtb1pUtuHJrW8CfLzYPpqM54K33u+7C04vQU8AmDkZ+BUSB+jetClklOCLiIiIiJSxt77ax8ZWVa6Nq7J4PA6BPq4cf3nq/lu3XGu6xRKp4Y1LnntjpPxpGRk52wnMOKTf5h0R2fahPjnOW/NoXMcj0nF282Z9g0COHQ2mdPxacQkZxCTnMGGo7H52m5T379i954fWwP/vGduX/sB+NUr/HxbD3r+9ypSGShBFxEREREpQ7tPJzB3sznffMLVrbFYLHRuVJPrO4UwZ+MJnv95B78+3BMX54J7htceNnuDOzYIIDEti/1RSVz/xSqmjOtC96aBtvO+32Cu/T2iQ33eGNUGgJSMLA6dTeZQdDKHziblbJvPGVlWJgxtVXF7z9MSYO59YFih7U0QPury1+T2oKcnQHYmODu+Ur5IcShBFxEREREppbTMbHadTqBdSADOTucTXsMw+M9vuzAMGNamLu1DA2zHnhnair92nWH36QSmrT7K3b0aF9j2upwE/eo2dbmxcygPz9zMsn1nee7n7Sx4rA+uzk7Ep2byx45IAG68ItR2rZebCxH1/Ymon7e33TAMMrMN23z4CunPCRB3FPwbwNVvF+0ajwveZ2oc+NQuk9BEykoF/o0UEREREanY9p1J5JVfd9L1jcWM/nQVj83egmGcXz7th40nWHngHO4uTjw9pGWeawN93HlmaCsA3vtrL5Hxafnaz7YarM9J0Ls2DsTXw5WPb+lAoLcbh84mM2vdMQDmbT1FepaVlnV8aXvR0PeCWCyWip2c75oHW74BLDDq87yJd2GcXc6fq0JxUglV4N9KEREREZGKJzUjmx83nuC6z1Yx6P3lTFl5hPjUTAB+3XrKVgwuKjGN1+bvAuDxgS1oGOidr60brwilQ4MAkjOybedeaPfpBBLTs/Bxd6F1XV8AfD1ceWxgCwDeX7SfhLRMvl9vDm+//oqQijtkvagSI+HX/zO3e/4fNOpZvOtVKE4qMSXoIiIiIiJFsCcygZd+2UGXNxbx5JytbDgai7OThUFhdZhyZ2eeH2auzf3G77vZcCSGl+ftJCEti4j6ftxzieHrTk4W/jMyAicL/Lb9NMv2nc1zPHf++RWNauSZo35z51Ca1vYmJjmDJ2ZvZfvJeFydLYzqUL/0bzQxEmIOl76dkjAM+GW82fsd3AaufK74bWipNanENAddRERERKq9w9HJBPq44eeRt6hYSkYW87ed5rt1x9h8LM62P6SGJzd3acD1nUII8jOXPOvXojZbT8Tz69ZT3DllPYnpWTg7WXhrTNtLFoADCK/nz7gejfl65WFe+mUHfz7WBw9XZwDWHT4HQJfGNfNc4+LsxLNXt+buaRtYtPsMAANa1yHQx73kX4SsDFj1ISx7B5yc4aHVUKNRydsrifWT4MAicPGA0ZPAxa34bagHXSoxJegiIiIiUq2tOhDNLZPW4unqzLC2dbm5SwM8XJ34bt0xftl8isT0LABcnCwMDKvDzV0a0KtZLZyc8g4lt1gsvDm6DXtOJ7A/KgmA+/s0Ibze5edPPzGoBb9tP8WRcyl8tvQgjw9sgdVq2ArEdW0cmO+aq1oF0b1JIKsPmUn8DZ1D851TZMfXmcPKo3KG2WcD2+dAn6dK3mZxnd0Hfz1vbg94BYJalawd9aBLJaYEXURERESqtT93mtXPUzOz+WHjCX7YeCLP8YaBXtzUuQHXdQqhtm/hPdTe7i58fnsnrvtsFcH+njzav3mRYvBxd+HFa8IZP3MTny09yMgO9cnMthKbkomHqxNt6udP8i0WC88Na82oT1dSL8CTPs1LULE8LQEWv2r2XGOAVyA0GwDbZsO2OdD7X1Aec9oNA359FLLSoMmV0OW+krelHnSpxJSgi4iIiEi1tvaQmcg92r85J2NT+W37KbKtBoPCg7mlSwO6NwnM11temKa1fVj1TH+cnYpXKf3qNsH0bl6LFfujefGXHQwKqwNAp4Y1LtlORH1/FjzWB18P1zzLuxXJnt/gt39B4inzdbtbYPDr5vD2nT9D9F44s8OcC17Wts2GY6vB1QuG/w+cSlEqSz3oUokpQRcRERGRaismOYO9ZxIBGNejETW93fjPyAishoG3e8n/VPZ0cy72NRaLhddGRDDog+Ws2B/N/jPmMPmChrdfqEltn+IHuPIjWPiCuV2jEVzzATS98vzxFoNh9zzY9n3ZJ+ipceeHtvd5CgJKMVQfwLOG+awedKmEVMVdRERERKqt3CJsLer4UNPbLEjm6eZcquS8NBrV8uahfk0BiEww10W/uEBcqVmzYfUn5naX++HB1XmTc4A215vPO34Eq9W+97/Y0omQfBYCm0P3h0vfnq0HPa70bYmUMyXoIiIiIlJtrckZ3t6tSeG91OXpgb5NaRToBYCbsxPtQwPse4Mj/0BSJHgEwKD/gJtX/nOaDwJ3f0g4aQ49LyuR22Hdl+b21e+UrGr7xTw1xF0qLyXoIiIiIlJtrS2kSrqjeLg685+RbXBxstCvZW3bkmt2s+MH8zls+KUTYlcPCLvW3N4+x773v9Af/wbDCuGj8vfil5SGuEslpgRdRERERKqluJQM9kQmAGUwjLyUejWvxYp/X8lHN3ewb8NZGbBrnrkdcV3h5+YOc9/1s3mdvUXtgaMrwckVBr1uv3YvLBJnGPZrV6QcKEEXERERkWpp3eEYDAOa1va+7PJpjlDX39P+vecHF0NaHPgEQ6NehZ/bqDf41IHUWNj7u33jANj+vfncfCD417dfu7lD3LMzICPZfu2KlAMl6CIiIiJSLdmGt1eg+edlbnvO8PbwUeZyaoVxcoa2N5rb8x6BExvtF4dhnB86n9tTby9u3uCcM3Rf89ClklGCLiIiIiLV0tqcCu4VqUBcmcpIPt8TXtSkuN8z0LAnpCfAjFFw0k5J+vF1EHcM3HygxRD7tJnLYjnfi6556FLJKEEXERERkWonPjWTXafM+efd7DH/PDsLDiyCjJTSt1VW9v4BmSlQozHU71i0a9y84ZbvoUEPSI+H6aPg5KbSx5I7vL31tQVXkS8tL1Vyl8pJCbqIiIiIVDsbjsRgNaBxLW+C/DxK3+Cf/4ZvxsDKD0vfVlnJHd4eMcbsZS4qdx+49XsI7WYm6VOHwbbvSx5Hdibs/Mnctvfw9lzqQZdKSgm6iIiIiFQ7aw6Zw9u72qP3/OQmWD/Z3D61ufTtlYWUGLOHH6DNZaq3F8TdF277AZpcafbCz70X5j8OmWnFb+vg35ByDrxrQ+O+xb++KLxyllpLjS2b9kXKiIujAxARERGRyi8pPYvft50mLSvbtq+OnwcR9f2p5++BpTg9tmVs8e4zTFt1FIAezWqVrjGrFX57EshZziv2cOnaKyu7fwVrJgSFQ1DrkrXh7gu3/QjL3oJlb8OGr80PJ26YDjUaFr2d3N73iDHgXEbpSG4PuhJ0qWSUoIuIiIhIqX2wcB+T/ik4Oa3h5Up4PX/C6/sRUc+f8Hp+NAr0xsmp/JP2P7af5pHvNpNlNRgSHszVEcGla3DzdDi1yawanp0BsUfAmn35CunlbUfO8PY2Y0rXjpMzXPkshHSBuffA6S3wRR8Y/SW0GHz569OTLihUd0PpYimMl4a4S+WkBF1ERERESm3J3igAujWpSU1vN6xWOBqTwv4zicSmZPLPgWj+ORBtO9/bzZnwev6E1fOjZbAvoTW8CK3pSb0AT1yd7TsLMzUjm+OxKaw+eI5X5+8i22owvF093ruhHS6luVdKDCx62dzu/5K5nZ0BCSchoIE9QrePxEg4vMLcjihlgp6r+QC4fwXMGWtWdp95A/R+Evo9e+lecavVnKtf3EJ1JeGpInFSOSlBFxEREZFSOR2fysGzyThZ4IvbrsDfy9V2LC0zm31nEtl5KoEdJ+PZcSqBPacTSM7IZt2RGNYdyZtA+bq7MPv+7oTV8yt1XAt3neHleTs5GZeaZ/91nUJ4a0xbnEvbg7/4FXMIdVA4dH0ANk6Bcwcg5lDFStB3/gQYENIZajSyX7sBoXDnH/DX87DuS1jxX3P5tOu+Bp+gvOcaBiyYAJu/AYsTDH69eIXqisszZw66etClklGCLiIiIiKlsvKAWXCtTUhAnuQcwMPVmbYhAbQNCbDty8q2cvBsMjtOxrPzVAKHo5M4HpvKsZgUEtOz+HnLyVIn6PO3neKxWVvIsppzw309XAit4cWg8Do8elXz0g+vP7ERNk4zt4e9a/Ya12ySk6Afhib9Ste+Pdmqt5egONzluLjD1e9AaFeY9ygcWQGf94brp0DDHufP+/s1WPu5uT3iU2g1zP6xXEjLrEklpQRdREREREplZc7Q9V7NAot0vouzEy2DfWkZ7MuYTuf3z9t6ike/28zyfWd59uoSFjIDftp8gie/34rVgFEd6vPyteH5PjgoFWs2/PYEYEC7m88nojWbmM8xh+x3r9KKOQwnN5i91uGjyu4+ba6D4DYw+3aI3gtTrzGT8PRESDoDUbvM865+F9rfXHZx5NIya1JJaZk1ERERESkxwzBsc8t7lrIieu9mtbBYYE9kImcSSrB8F/D9+uM8kZOc33hFKO9e386+yTnAxqlmcTR3fxj46vn9NRqbzxUpQc8tDte4D/jWKdt71W4J9/5trm1uZMPueXBoyfnkfOCr0OXeso0hV2l60LfOhgXPQVa6fWMSKQL1oIuIiIhIie2PSuJsYjoerk50bFCjVG3V8HajbUgAW4/HsWzfWW64IrRY189Yc5QXft4BwG3dGvDq8Aj7V4pPjobFOUn5Vc/nnWud24Mee8S+9yyN7T+az2UxvL0g7j4w+isIH20O9/eubT5qNobApuUTA5zvQU+Lh+ysoi/ndmwt/PwAGFbwDYYej5RdjCIFUIIuIiIiIiX2z36z97xzo5p4uJZ+abG+zWux9Xgcy4uZoE/+5zCvzTd7au/q2ZgXrmldNmuvL3oZ0uLM4dxX3JX32IVD3A2jbIugFcWZnXB2t7kEXOtry+++Fgu0urr87lcQzws+LEqLA+8ijO5IT4Kf7jOTc4Dl70D7W8/3xouUAw1xFxEREZESOz//vHTD23P1aVEbgH8ORJOdU+Dtcj5betCWnD/Yr2nZJefH18PmGeb21f/N3ysb0MCc652ZYs67drTc4nDNBoJngENDKXfOLuYUBDAr7RfFgmfN0Q/+oRAUZva+L3+3zEIUKYgSdBEREREpkcxsK2sOmRXcSzv/PFf70AB8PVyIS8lk24m4Qs81DIMPF+3nrT/3APDYgOY8Pbhl2STntsJwQPvboEHX/Oe4uIF/iLnt6HnohgE7coa3t7HT2ueVjVcxllrb+wdsmgZYYORnMOg/5v51Xxbte5mdZVb13zobTm2BjJSSRi3VnIa4i4iIiEiJbD0eR3JGNjW8XAmrW/p1y8Gs8N6rWS3+2BHJ8n3RdLjEvHbDMHj3r718suQgAE8Nbsn4K5vZJYYCbfgaIreBhz8MePnS59VsAnHHzOrpFy4zVt5ObIC4o+DqDS2GOi4OR/KsafaIX65QXHI0zMuZa959PDTubW437Q8HF8OiV+CGaYW3seMH+PXRC3ZYzBEVtVuZxfNqt8p5tAB335K+I6kG1IMuIiIiIiWSW729R7Nadi3GljvMffn+swUeNwyD13/bbUvOnx/WumyT86SzsPg1c/uqF8Cn9qXPrShLreVWb291Nbh5OTYWR/EqwlJrhgG//h8knzWHtV/1wvljg14zpyzs+tmcLmC1Xrqd42vNZ7/64FULMMwPSPYvgFUfwS8PwaSrYGIIvBcO399R2ncnVZR60EVERESk2AzDYPk+M4G21/zzXLkJ+uZjscSnZOLj4cLCXZGsPHCOPZEJ7I1MJCEtC4BXR4RzR/dGdr1/PotegvR4qNsuf2G4ixWUoJ/dB0f/gY7jwKkc+seys2DHXHO7vKq3V0SeRVhqbcu3sGc+OLnC6C/B1eP8sTrhZpG4zTPgx7th2VvQ7UFodzO4euZt5/RW83nQaxAxxuyVP7sXzu7J+5wUCQknID7Yvu9Vqgwl6CIiIiJSbO8v2s+mY3E4WaB3c/sm6PUDPGkW5MOBqCRe/30X6w7HcORc3jm9nq7OvDI8nBs6F28ptmI7tsZM4gCGvQdOl6lUf/Fa6IYBs2+F6H3gEQARo8ssVJsjKyA5yrxf06vK/n4Vledl5qDHHoE//m1uX/W8WZn/YkPfMqc1bJpufg/nP25++DFu/vlzsjMh0lzej7rtzWfvWuajUc+87aXGmh/YWDNL+q6kilOCLiIiIiLF8sWyg3y0eD8AL10bTkgN+w+h7tO8Ngeikvh+wwkAArxcGd0hhDYhfrSs40fTIG/cXUq/rFuhsrPgtyfN7Y53QMgVl7/G1oN+2EzOj6wwEzsw5zOXR4KeO7w9fKRZuK668iqkB92aDT89ABlJ0KDHpdc7d/OGwa9D33+bH9T89bz5PY07Zs4xB/P7m50Obr7nP6C5FM8aBRcYFMmhBF1ERERECmUYBikZ2SSmZfHb9tNM/MOsmv70kJaM7dGoTO45skM9Zqw5Qi0fd+7p3YSbOofi7V7Of7qunwRndpg90f1fLto1NRqZz+nxZm/p+snnjx1aXvbro2elw65fze3qPLwdzg9xTzmX/9iqj+DYajOpHvX55UdGePiZw9t3/Agn1sORldA+J0HPHd5et235TGGQKk0JuoiIiEg1dCoulcV7okhIzSQxLYvEtEyS0rNs2+bz+f0XL0n+8JXNeKhf2RVmaxsSwMYXBuLp6oyrswOSnsQzsOR1c3vAS+AdWLTr3LzAtx4knjITwD05Q6EtThB/DGIPn+9lLwsHFpkfDvjWdWwV+YogMOfrvO8vcwh6cIT5+vQ2+Dvnezv0TajRsOhtNuxhJuhHV0L7m8+3B2aNApFSUoIuIiIiUg09+t1mNhyNLdY1zk4W/D1dub1bQx4b0LyMIjvPz8O1zO9xSQtfhPQEqNcBOo4t3rU1m5gJ+t+vgzULQjqbRciOrYJDy8o2Qd/2vfkcPvryvcJVXdP+0HywWUn9h7vgvqXmByVz7zPngLe6xiwCVxwNe8LKD+HoqvP7bD3oStCl9JSgi4iIiFQzKRlZbD4eB8DoDvUJ8HLD18Plgocrvh4u+Lib234eLvh4uODp6oylLIdnVxRHVsK2WYAFhv23+IluzUZm1faonebrK+4y5ywfWwWHl8EVd9o7YtO5g7A7Z3h7uxvL5h6VicUCIz+Fz3pC9F5YMAHcfODsbvCuDdd+WPzpBqFdAQvEHITESPAOgkj1oIv9KEEXERERqWa2nYgn22pQx8+d/97Qrnok3UVltcIfT5vbncZB/U7Fb+PCHnIPfwgfBae2wNKJcHi5eY+ymKv8z3tgZEOzgUoWc3nXMpdPmz4CNk49v3/4x+ax4vIMMIfKR243e9GD25qF5lw8IbDsR5VI1acqBiIiIiLVzKZj5tD2Tg1rKDm/2P6/zMJw7n7Q/8WStXFhgt7+VnPN7PqdwNXLLFiW27NuT7FHYessc7vv0/ZvvzJr0hd6P3H+dadx0HJIydtrmLN02tFVcHqLuR0cAc7q+5TSU4IuIiIiUs1sypl73rFBDQdHUs4Mw3wUZtX/zOcr7jy/TFdxXZigX3GX+ezidr5o26FlJWu3MP+8b853b9IPQrvYv/3Krt8EaH0tNOoNg14vXVu538ejqzT/XOxOH/OIiIiIVCOGYbDpWBwAHapTgp6ZCl/2M9e1vvFb8Kub/5yTm8y5404u0OX+kt+rThvocBv4hUCtC4Y9N+5rVlk/vAx6PFzy9i8WfwI2f2Nu91HveYGcXeHGb+zTVoOcBD1q5/n6BErQxU6UoIuIiIhUI0fPpRCTnIGbsxMR9f0cHU75Ob4Ozprrt/P1ILj9Zwhsmvec1R+bzxHXgX/9kt/LyQlGfJJ/f5O+5vPRVZCdaSaN9rDyQ7MqecNe0KinfdqUS/OpDbVaQPQ+FYgTu9MQdxEREZFqZGPO8PaI+n64u1SjZbiOrT6/HXcMvh5sFm67cN/On81te/ZuX6hOG/CsaRYVO7mx9O1lZ8HqT88XP9Pc8/Jz4RrzTq5Qu7XjYpEqRQm6iIiISDWSWyCu2s0/z03Q+z5jVt5OPgtTh8HClyDuOKz53KyA3qQfBLcpmxicnKBxb3O7tPPQj66CL/qYS4dlZ0DLYdC4T+ljlKJpeMFIhTphZo0BETtQgi4iIiJSjeTOP+/UsBol6NlZcHy9uR02HMbNN4uFZSTByg/gw7aw7kvzePdHyjaWJleaz7t/vXzBukvZMRemDDXnQHvWMNfzvvGb4q/pLSV3YQ+6hreLHSlBFxEREakmktKz2BuZAEDH6pSgR26DzGRzTfLarc3nO34xi8U17gOG1ZzDXbs1NOtftrGEjQBndzizveTD3Nd8aj6Hj4JHNpnLhpXFuupyaf4hENDA3FaCLnakInEiIiIi1cTW43FYDagf4EkdPw9Hh1N+jq0xn0O7nU9knZyh9TXmI2o37PnNXIarrHuhvWpCxGjY+h1s+BpCrije9bFH4MR6sDjBkLdKvhSclF6/Z2HbLAgf7ehIpArRR20iIiIi1YRt/fPq1HsOcGyV+dygW8HHg1pDn39B7ZblE0+nO83nHXMhNbZ41+740Xxu1Bt869g3Lime9jebIzH0IYnYkRJ0ERERkWrifIG4AMcGUp4M43wP+oXzhh0ptAsEhUNWKmydXbxrt+ck6G2us39cIuJwStBFREREqgGr1bAViKtWFdxjDpkV253doV4HR0djsljgipxe9I1Til4sLmq3WRjOydUcji8iVY4SdBEREZFqYN2RGOJTM3F3caJ1XT9Hh1N+juYMb6/fEVzcHRvLhdreAK5ecHbP+R7+y9n+g/ncfKBZvV1Eqhwl6OVk4sSJdO7cGV9fX4KCghg5ciR79+7Nc06/fv2wWCx5Hg888ECec44dO8awYcPw8vIiKCiIp556iqysrPJ8KyIiIlLJZGVbeXneTgBGdwzBzaUa/QmYm/w26O7YOC7m4Q8RY8ztDV9f/nzDgB05CXrudSJS5VSjf50da9myZYwfP541a9awcOFCMjMzGTRoEMnJyXnOu/feezl9+rTt8fbbb9uOZWdnM2zYMDIyMli1ahXTpk1j6tSpvPjii+X9dkRERKQSmb76KHsiEwnwcuWpweVUCK2isBWIq2AJOpwf5r7rF0g+V/i5JzeZFdxdvaDl0DIPTUQcQ8uslZM///wzz+upU6cSFBTExo0b6dOnj22/l5cXwcHBBbbx119/sWvXLhYtWkSdOnVo3749r732Gv/+9795+eWXcXNzK9P3ICIiIpVPVEIa7y/cB8DTg1tR07sa/b2QeMacg44FQjs7Opr86nU019A+vRW2zoQej1z63Nze85ZDwc27fOITkXKnHnQHiY+PB6BmzbzLMnz77bfUqlWLiIgIJkyYQEpKiu3Y6tWradOmDXXqnF9SY/DgwSQkJLBz584C75Oenk5CQkKeh4iIiFQfE//YQ2J6Fu1C/Lmxc6ijwylfh5aaz0FhFXPOtsVyfsm1DYUUizMM2DXP3I5Q9XaRqkwJugNYrVYee+wxevbsSUREhG3/LbfcwjfffMOSJUuYMGECM2bM4LbbbrMdj4yMzJOcA7bXkZGRBd5r4sSJ+Pv72x6hodXsP2YREZFqbNXBaH7afBKLBV4dEYGzk8XRIZWfPb/Br/9nbje90rGxFKbNdeDmAzEH4fDygs+JPw4JJ8DJBZr0K9fwRKR8aYi7A4wfP54dO3bwzz//5Nl/33332bbbtGlD3bp16d+/PwcPHqRp06YluteECRN44oknbK8TEhKUpIuIiFQhVqvB5uOxNKnlQ40Lhq8fj0nhkZmbAbi5SwPahQY4KEIHWPMZ/DkBMKDZAOj3jKMjujR3X7Oi+4avzSXXmvTNf87xdeZzcFtw8yrf+ESkXClBL2cPP/ww8+fPZ/ny5YSEhBR6bteuXQE4cOAATZs2JTg4mHXr1uU558yZMwCXnLfu7u6Ou3sFWlJERERE7CI+NZM5G44zY81Rjp5LIdDbjQ9v6kCv5rVISMvkrqnrOZecQXg9P54f1trR4ZYPa7aZmK/7wnzd6U64+l1wruB/8na600zQd8+HpCjwCcp73FaJvlv5xyYi5aqC/2tVdRiGwSOPPMJPP/3E0qVLady48WWv2bJlCwB169YFoHv37rz++utERUURFGT+w71w4UL8/PwICwsrs9hFRESk4th/JpGpq47w0+aTpGRkA+ZU5nPJGdz+9Voeuao5W47HsT8qiTp+7kwe2xkvt2rwJ196Evx4N+zLKcw78FXo8aj5xano6raF+lfAyQ2w+Rvo/UTe48fXms+hXco/NhEpV9XgX+uKYfz48cycOZNffvkFX19f25xxf39/PD09OXjwIDNnzuTqq68mMDCQbdu28fjjj9OnTx/atm0LwKBBgwgLC+P222/n7bffJjIykueff57x48erl1xERKQK+HzZQX7adJI7ezbi+itCbXPGs60Gi3efYdrqI6w8cH45rhZ1fBjboxFDI+ry9p97mLX+OB8t3g+Ap6szk8d2JtjfwyHvpVwlRsLMG8xq6C4eMOoLCB/p6KiK54o7zQR941To+Rg45ZSKSk+EMzvM7VD1oItUdRbDuFS5SLEnyyU+vZ0yZQrjxo3j+PHj3HbbbezYsYPk5GRCQ0MZNWoUzz//PH5+frbzjx49yoMPPsjSpUvx9vZm7NixvPnmm7i4FO2zloSEBPz9/YmPj8/TroiIiDjWqbhU+r6zhMxs80+z8Hp+PD2kFXtOJzBjzVFOxKYC4GSBgWF1GNujEd2bBOb5G+OnzSd4du4O0rKy+fy2TgwOL3gKXJVyZid8e4NZRM0rEG6eVTl7mjNS4L+tID0ebvvRnDsPZiX66SPAvwE8vt2hIUrVo9yg4lEPejm53OcgoaGhLFu27LLtNGzYkN9//91eYYmIiEgF8eXyQ2RmGzQK9OJccgY7TyUw9uvztWcCvFy5sXMot3drSEiNgguFjeoQQo+mtUhMy6RZkG95he44B/+G78dCegIENodbv4eaTRwdVcm4eUG7m8z58xumnE/Qj+UMb2/Q1XGxiUi5UYIuIiIi4mDRSenMWn8MgNdGRhBW14//LtzHDxtO0DTIh3E9GjKifX08XJ0v21YdPw/q+FWDYe2bpsP8x8GaBQ17wo3fgFdNR0dVOlfcaSboe/+AhNPgVxeO5xSIC1WCLlIdKEEXERERcbCv/zlMWqaVdiH+9GpWC4vFwhuj2vD6yAjg0lPlqq2ts2HeI+Z2mxtgxMfgUgXq8QS1hgbd4dhq2DwDej8JJzaYx5Sgi1QLTo4OQERERKQ6i0/NZMbqowCMv7JZnmTcYrEoOS/I1u/M5873wugvq0ZynqvTnebzxmlmcbj0BHDzgSCt2CNSHShBFxERkQotLiWDT5YcoPvExdz4xWqysq2ODsmupq86QmJ6Fi3r+DKgdR1Hh1PxWa1wcqO53fGOyrGMWnGEjQDPGmbRu79fN/eFXFHx13IXEbvQb7qIiIhUSMdjUpj8z2Fmrz9Oaqa53vfp+DR+3HSCGzs3cHB09pGUnsXXKw8D8NCVTXFyqmLJZlmI3mf2Krt6Vc1eZVcPaH8rrP4Y9i8w92l5NZFqQz3oIiIiUqFsOxHHwzM30fedJUxddYTUzGxa1/VjVIf6AHywaD9pOQl7ZffpkgPEpmTSpJY317St5+hwKocT683neh2rbq9yp3F5X1fGZeNEpESq6L9qIiIiUplYrQZL90Xx5fJDrDkUY9vfu3kt7u/TlJ7NAknPsrL20DlOxacxY/VR7u1TSZfTynE8JoVJ/5i95xOubo2zes+LJjdBD7nCsXGUpVrNoVFvOLICsEBIZ0dHJCLlRAm6iIiIOIxhGPy0+SSfLT3I/qgkAFycLAxvV497+zShdV0/27kers48NrAFT/+wjU+WHuDGLqH4ebg6KvRSe/OPPWRkWenZLJABrYMcHU7lYatqXsV7lTvfYybo9TqAh9/lzxeRKkEJuoiIiDhEelY2E+ZuZ+6mkwD4uLtwS9cGjOvRiHoBngVeM7pDfb5cfogDUUl8tfwQTw5qWZ4h2826wzH8tv00ThZ4fliYKrUXVXoiRO0yt+tX4R50MIvFXT8Ngts4OhIRKUdK0IsoLS0NDw8PR4chIiJSJZxLSuf+GRvZcDQWZycL/9e/OeN6Nrpsj7iLsxP/GtSSB77ZyKQVh7m1a0OC/Sv+/8+GYZCQmoWTE7g4OfHq/J0A3NSlQZ5RAnIZJzcCBgQ0AN8qXvHeYoHwkY6OQkTKmRL0QlitVl5//XU+//xzzpw5w759+2jSpAkvvPACjRo14u6773Z0iCIiIpXO8ZgUbpm0huMxqfh6uPDprR3p3bx2ka8fHF6H9qEBbDkex9iv1zHrvm7U8HYrw4hL53hMCuNnbmLbifg8+33dXXhiYAsHRVVJ2eafa062iFRNquJeiP/85z9MnTqVt99+Gze38//xR0REMGnSJAdGJiIiUnlNWXmE4zGpNKjpxU8P9SxWcg5gsVj48Kb2BPm6s/dMIuOmrCMxLbOMoi2dlQeiGf7xP/mSc4Cnh7Sklo+7A6KqxHLnnytBF5EqSj3ohZg+fTpffvkl/fv354EHHrDtb9euHXv27HFgZCIiIpXXmcQ0AO7s2YhmQT4laqNhoDff3tOVG75YzdYT8dw9bQPT7uyCp5uzPUMtMcMw+HrlEd74fTfZVoO2If58emtHavm4k2U1cLKAl5v+DCsWw7igB72KF4gTkWpLPeiFOHnyJM2aNcu332q1kplZMT+pFxERqejiUjIAqOFVumHpzev4MuPurvi6u7DucAzPzN1mj/BKLS0zmye+38pr83eRbTUY3bE+39/fnZAaXni4OuPj7qLkvCRiD0PKOXB2V+E0EamylKAXIiwsjBUrVuTb/8MPP9ChQwcHRCQiIlL5xaWYH3L7e5V+ibSI+v5MHtcZJwv8suUUqw5Gl7rNy0nNyL7ksZNxqVz3+Sp+2nwSZycLL14Txn+vb4eHa8Xo2a/Ucoe3120HLhW35oCISGno49tCvPjii4wdO5aTJ09itVqZO3cue/fuZfr06cyfP9/R4YmIiFRKuQl6gKd91jDv0rgmt3VryPTVR3npl538/n+9cXUumz6I37ef5rHZW+jTvBb/u7ljniH1aw+d46FvN3EuOYMaXq58cmtHejStVSZxVEvH15nPmn8uIlWYetALMWLECH799VcWLVqEt7c3L774Irt37+bXX39l4MCBjg5PRESkUrLXEPcLPTmwJYHebuyPSmLqyiN2a/dCB6IS+decrWRkWVm0O4qxOcXpDMNg2qoj3DppLeeSMwir68e8h3spObc32/zzKr7+uYhUa+pBv4zevXuzcOFCR4chIiJSJWRkWUnOGSIeYIch7rn8vVz595BWPP3jNj5YtI8R7esR5Ge/9dGT0rO4f8ZGUjKyaRviz+Gzyaw7HMOtk9bSoo4vP2w8AcDwdvV4a0zbClOsrsrITIMzO8xt9aCLSBWmHvRCrF+/nrVr1+bbv3btWjZs2OCAiERERCq3uFSz99xiAT8P+yXoANd1CqF9aADJGdm8+MtO4lOKV9A122oQl5LBkehkthyPY9+ZRNIyszEMg2d+3MbBs8nU8XPn63Gd+e6+btT0dmPbiXh+2HgCJws8d3VrPrypvZLzsnBmB1izwLs2+Ic4OhoRkTKjHvRCjB8/nqeffpquXbvm2X/y5EneeuutApN3ERERubTcpNnf0xUnJ4td23ZysvDqiHBGfLKSP3dG8veeKPq1rM2g8GAsQFxqJvEpGcSlZhKXkpnvdUJaJoaRv91aPm5EJ2Xg4mSxLZVWy8ed7+/vxtiv15OSkcVHN3co9nruUgynNpvP9TqYn+6IiFRRStALsWvXLjp27Jhvf4cOHdi1a5cDIhIREanc4lLtWyDuYm1DAvjgxvZ8uuQge88k8teuM/y160yx2vBxd8Hf05WEtEwS07KITjJ7/Z+9ujWdGta0ndcsyJcl/+qHgYG7i3rNy9SFCbqISBWmBL0Q7u7unDlzhiZNmuTZf/r0aVxc9KUTEREprthkM9kNsGOBuIuNaF+fEe3rsycygZ83n2L9kRi83JwJ8HIjwNOVAC9X/D1dba9reLvi7+lGgJcrfh6uuLmYMwANwyAuJZMj55KxGkae5DxX7rlSxpSgi0g1oSyzEIMGDWLChAn88ssv+Pv7AxAXF8ezzz6rKu4iIiIlYOtBt2OBuEtpFezHM0P9Sny9xWKhhrcbNby15rZDZSTD2T3mthJ0EanilKAX4t1336VPnz40bNiQDh3M/xC2bNlCnTp1mDFjhoOjExERqXxyl1grqyHuUgVFbgfDCr71wDfY0dGIiJQpJeiFqF+/Ptu2bePbb79l69ateHp6cuedd3LzzTfj6qo/LERERIorLiW3B1290lJEJzeZz+o9F5FqQAn6ZXh7e3Pfffc5OgwREZEqoTyHuEsVofnnIlKNKEG/yLx58xg6dCiurq7Mmzev0HOHDx9eTlGJiIhUDblD3GuoB12KSgm6iFQjStAvMnLkSCIjIwkKCmLkyJGXPM9isZCdnV1+gYmIiFQB54e4qwddiiAtAc7tN7frtXdoKCIi5UEJ+kWsVmuB2yIiIlJ6uQm6v4rESVGc3mo++zcA71qOjUVEpBxo8c5LyMzMpH///uzfv9/RoYiIiFQZGuIuxWIb3t7eoWGIiJQXJeiX4OrqyrZt2xwdhoiISJWiInFSLJp/LiLVjBL0Qtx2221MnjzZ0WGIiIhUCelZ2aRkmPVbAjzVgy5FoARdRKoZzUEvRFZWFl9//TWLFi2iU6dOeHt75zn+3nvvOSgyERGRyic+Z/65kwV8PfQniFxGSgzEHja3NcRdRKoJ/e9YiB07dtCxY0cA9u3bl+eYxWJxREgiIiKVVu7wdn9PV5yc9P+oXMax1eZzjcbgWcOxsYiIlBMl6IVYsmSJo0MQERGpMmKTVSBOiigzDRa+aG63GOzYWEREypES9EuYPXs28+bNIyMjg/79+/PAAw84OiQREZFKzdaDrgJxcjnL34ZzB8AnGPpNcHQ0IiLlRgl6AT777DPGjx9P8+bN8fT0ZO7cuRw8eJB33nnH0aGJiIhUWrlz0AO0BroUJnI7rPzQ3B72LngGODQcEZHypCruBfj444956aWX2Lt3L1u2bGHatGl8+umnjg5LRETkkqxWA8MwHB1GoWK1BrpcTnYWzHsErFnQeji0vtbREYmIlCsl6AU4dOgQY8eOtb2+5ZZbyMrK4vTp0w6MSkREJL/jMSk8NmszTZ/7nUHvL2fG6iMkpWc5OqwCaYi7XNa6L8yl1dz94WqNXBSR6kdD3AuQnp6eZ0k1Jycn3NzcSE1NdWBUIiIi58WnZvLR4v3MWH2UjGwrAPujknjhl5289edeRneszx3dG9IsyNfBkZ4Xpx50KUzSWVgy0dwe9Cr4Bjs2HhERB1CCfgkvvPACXl5ettcZGRm8/vrr+Pv72/ZpHXQREXGUx2dv4e89UQD0alaL/xvQnJ0n45m+5iiHziYzffVRpq8+SvcmgdzRvSEDw+rg4uzYgXNxuXPQ1YMuBVnyOmQkQt320OEOR0cjIuIQStAL0KdPH/bu3ZtnX48ePTh06JDttdZBFxERR4lKTGPJXjM5/3rcFVzVqg4AnRvVZGyPRqw8cI7pq4+waPcZVh86x+pD56jr78EtXRpwU5cG1PZ1d0jcuQm6v4rEycXO7IRN08ztIRPBSbMwRaR6UoJegKVLlzo6BBERkUtasCMSw4D2oQG25DyXxWKhV/Na9Gpei5Nxqcxce5RZ645zOj6N/y7cx0d/7+fatvW4v29TWgaX7/B3FYmTAhkGLHgODKtZGK5hD0dHJCLiMPp4UkREpJL5fXskAFe3KXyObv0AT54a3IpVE67i/Rvb0aFBAJnZBnM3n2TwB8u5c8o6Nh6NKY+QAXPePGiIu1xk/0I4tASc3WDgq46ORkTEoZSgi4iIVCLRSemsPXwOgKERdYt0jbuLM6M6hPDTQz35ZXxPhrWpi5MFluw9y3Wfr+aXLSfLMmQb2xx0T/WgS47TW+GPp83trg9AzcaOjUdExME0xF1ERKQSWbAzEqsBbUP8Ca3pdfkLLtIuNIBPbu3Ikehk3v1rL/O3neaJ77fi4erM4PCyq5qdlplNamY2AAHe6kGv9pLOwt+vwabpgAG+daHPvxwdlYiIw6kHXUREpAxkWw1+2XKSBTsjOXQ2iaycpdBK6/ftpwG4uk3Res8vpVEtbz66qQNjOoaQbTV4ZOZmlu07a48QC5Q7vN3ZyYKvu/oHqq2sDFj1MfyvY05ROAMiroN7FoOH/2UvFxGp6vQ/ZCEyMzNxdS34U/7o6Ghq1apVzhGJiEhlMW3VEV6dv8v22s3ZiUa1vGgW5EOzIF/zubYPTWp74+HqXKQ2zyWls+aQOWd8aETpe7udnCy8NaYNaZnZ/Lb9NPdN38C393TlikY1S932xXILxAV4umollOpq/0L4cwKc22++rtsOhrwFDbs7Ni4RkQpECXohbrrpJn744Yd8f0icOXOG/v37s2PHDgdFJiIiFUV8aiYuTha8L+gVzsy2MvmfwwA0qOlFVGIaaZlW9p1JYt+ZJCDSdq6TBUJretGstk9O8u5Du9AAWtTJX2H9r11nyLYahNfzo2Ggt13id3F24v0b25Oamc3fe6J44JuN/PpIL+r6e9ql/Vy2JdZUIK76iT4ACybA/r/M1961of+L0P5WcCrah1MiItWFEvRCHDt2jHvuuYfJkyfb9kVGRnLllVcSHh7uwMhEBIDYo3DuADTr7+hIpJr6fv1xnv9lB/X8Pfj1kV74epjJ5+/bT3MyLpVaPm789Xgf3JydOBmXyoGzSRyMSmL/mSQOnE3iQFQS8amZHD2XwtFzKSzeE2Vr+4qGNRjXsxGDw4NxdXaytQulH95+MTcXJz6+pQOjP13FnshEHvhmE9/f3w13F/slT+cLxClBrzbS4mHZ27D2C7BmgpMrdHsA+jyl4ewiIpegBL0Qv//+O3369OGJJ57gvffe49SpU1x55ZW0a9eOWbNmOTo8kerNmg0zRkLMIbj3b6jfydERSTWSnpXNK7/uYubaYwAcOZfC23/u5bWRERiGwVcrDgEwtnsj2/D10JpehNb04sqWQbZ2DMPgbFI6B6LMxP1AlNnDvuFoDBuOxrLhaCyB3m64uzgRl5pJSoZZZM0ew9sv5uXmwpe3X8G1H//D1uNxvPjzTt4c08Zuw9HjtAZ69ZISA1/0hXjzd4Tmg2HwG1CrmWPjEhGp4JSgF6J27dr89ddf9OrVC4D58+fTsWNHvv32W5ycVF9PxKH2LzSTc4ATG5WgS5lLy8xm35lE9pxO5Nt1x9h6PA6LBcZ0DOGHjSeYseYo17arR5bVyo6TCXi4OnFbt4aFtmmxWAjy9SDI14MeTc/XNYlKSOObtceYufYo0UkZea7p3yqIJrV9yuQ9Ngj04n83d2DclHXM3nAcZ2cLrYJ9CfR2x9/TFRdnCy5OFlycnXBxsuDsZLng2QlnZwt+Hi62kQQXikvVEPdqZedPZnLuWw+GfwTNBzo6IhGRSkEJ+mWEhoaycOFCevfuzcCBA5kxY4aK24hUBOu/Or99drfj4pAqxzAMTsSmsicykT2nE9gTmcjuyASORCdjNc6f5+/pykc3d6Bvi9o4WyzM3nCcZ37cRr0Ac+72DVeEUsO7ZL3FQX4ePDGwBeOvbMrW4/G4uzgR4OVKgKcbfp5l+193nxa1eWpwK976c49thEBxODtZmHlPV7o2CcyzP3eIu3rQq4nd88znrvcpORcRKQYl6BepUaNGgQl4SkoKv/76K4GB5//giImJKc/QRCTXuYNwYNH511FK0KX0dp6K57X5u9h5MoHE9KwCz6np7Ubrur6E1fXjju6NbOuQPzusNUv2RnEoOplD0clYLHB3r8aljsndxZkuje1fUf1yHujbhNq+7mw+Fsu5pAzOJaeTkJpFltVKttUgy2qQbTXIzDbItlptrzOyzO1J/xwuIEE/X8VdqriUGDi8wtxuPdyxsYiIVDJK0C/ywQcfODoEEbmc9TmFG2s0htjDELULDAM0ukVKKNtq8H+ztnAgKgkAV2cLzYJ8aR3sS6u6vrQK9qNVXV9q+7gX+CGuv6crr42M4P4ZGwEYEh5styrrjmCxWLiuUwjXdQop1nUHohIZ8N5y/t4TRWR8GsH+HrZjtiJxGuJe9e39HYxsqBMBgU0dHY2ISKWiBP0iY8eOdXQIIlKYjGTY/I25Peg/8P0dZqXgxNPgV8+xsUml9evWUxyISsLf05WZ93alRR1fW+X0ohocHswNV4Qwb+spxl9ZPQthNQvypUvjmqw7HMP3G47zaP/mtmO2ddA1xL3q25UzvD1shGPjEBGphFTprBC///47CxYsyLf/r7/+4o8//nBARCLC9jmQHm/2nre8GgJzEqGoXY6NSyqtrGwrHy7eD8B9fZoQXs+/2Ml5rrfGtGXHy4OJqF99l5C6pUsDAGatO0b2BZP241PVg14tpCXAoSXmtoa3i4gUmxL0QjzzzDNkZ2fn22+1WnnmmWccEJFINWcYsC6nOFznu8HJCYJam681D11KaO7mkxyOTqamtxvjejQqVVsWi1nhvDobEhGMv6crp+LTWL7vLGAW3otJzp2Drh70Km3fAsjOgFotIKiVo6MREal0qvdfEZexf/9+wsLC8u1v1aoVBw4ccEBEItVc1C44swNcPKD9rea+oJzfUSXoUgKZ2VY+yuk9f6BvE7zdNfOrtDxcnRnT0Zy7PnPdMbKyrTz/8w6iEtNxdrJQN8DjMi1IpbbrZ/NZveciIiWiBL0Q/v7+HDp0KN/+AwcO4O1deYv/iFRaZ/eYz3XbgVdOZWtbD/oFQ9yzs+D7sfDTA+a2yCXM2XCCE7Gp1PZ15/ZujRwdTpVxS9dQAP7eE8WdU9fz7dpjWCzw8rVh1PJxd3B0UmYykuHAYnM7TAm6iEhJKEEvxIgRI3jsscc4ePCgbd+BAwd48sknGT5c//GIFFv8SUiMLPn153I+MKt5QVVgWw/6HrBaze0jK8xenK3fwd+vlfx+pZVwCuaMgy3fOS4GuaSziel8uHgfAA/1a4pnejSsnwSZqQ6OrPJrFuRLl0Y1ybYarNgfjbuLE5/d2onbuzdydGhSlvYvhKxUCGgIwW0dHY2ISKWkBL0Qb7/9Nt7e3rRq1YrGjRvTuHFjWrduTWBgIO+++66jwxOpXFJj4fOe8GU/yMooWRsxOQl6YJPz+2o2Bmd384/CuCPmvtwhlgArP4A9v5fsfqX1+1Ow8yf4+QFY+pY5h14qhLTMbO6bsYEzCek0qeXNzV0awJLX4bcn4a8XHB1elXBrN7NYXICXWRl/SESwgyOSMmW1wuqPze2wEVr2UkSkhDTZrhD+/v6sWrWKhQsXsnXrVjw9PWnbti19+vRxdGgilc/uX80kHeDsbnOYenHF5IxmqXlBgu7kDLVbQOR2sxfdv4F5L4DQbnB8jZkg37fMTObLy8G/Yc98wAIYsPQNSImGIW+Zxe2kRKKT0vFxd8HD1bnEbRiGwdM/bGPzsTj8PV2ZNPYKs73TW8wTNk2D3k9o2b5SGt6uHu4uzrQN8adegKejw5Gytv17OLEeXL2h20OOjkZEpNJSgn4ZFouFQYMGMWjQIEeHIlK5bf/h/PapLSVL0M/lJuhN8+4PCstJ0HeBqyeknAOvQLj9J5g+3Pyjcc5YuOsvcC2HAlXZmfBHzkoPXR+AGo3gz3/Dui8hNQ5GfaEkvQS+XXuUl37Zia+HC/f2acLY7o1KVNTtf38fYN7WU7g4Wfjs1o40qe0D1mw4u9c8ITsDVn4IQ9+y8zuoXiwWi3rNq4v0RFj4ornd9ynwq+vYeEREKjH9hXgZy5Yt49prr6VZs2Y0a9aM4cOHs2LFCkeHJVK5JJ4x54XnOrW5+G2kxZs90JC3Bx3yLrW28ydzu/W14OYF108Fz5pweiv8WU7LI677CqL3mh8S9HsGuj0AoyeBk4vZy7Tui/KJo5ysOhDNwbNJZdZ+ZraVF3/ZwXM/7SDLahCbksnbf+6l99tL+GLZQVIyil4IcNXBaN5baM47f21kBD2a1TIPxB6BrLTzJ26cWrp6CSLVyfJ3IemM+W+zes9FREpFCXohvvnmGwYMGICXlxePPvoojz76KJ6envTv35+ZM2c6OjyRymPnT2BYwcnVfJ07lLg4cuefe9cGD7+8x3ILxUVuzxlWDoSNNJ/9Q2DMV4AFNk6BrbOKf+/iSDoLSyea2/1fAs8Ac7vt9TDkTXN74YsQuaNs4ygnO07Gc8uktdw1dT1GGcyxj0/JZNyUdUxffRSApwa35L/Xt6NhoBcxyRlM/GMPfd5ewqQVh0jNyL5se58tNUdh3HhFqDnvPFfuKgB120FoVzNZX/mh3d+PSJVz7iCs+dTcHvwGuKhKv4hIaShBL8Trr7/O22+/zezZs20J+uzZs3nzzTd57TUHVoYWqWx25Axv73yP+XxmZ/ELxV1qeDuc70GP3nt+eHuj3uePNxsAff9tbs9/HM7syt+Gvfz9KqQnmIleh9vyHut8D7QYYg6h/vGeKlEt/K9dZwA4ei6Fk3H2fz+vzN/JygPn8HJz5svbOzH+ymaM6RTC4if68s51bWlQ04vopAz+89tuer+9hMn/HCYts+BEfU9kAiv2R+NkgYevapb3YO7PRFA49H3a3N7wtTn6Q0QKZhjmyKTsDGja3/z3TURESkUJeiEOHTrEtddem2//8OHDOXz4sAMiEqmEYo+Yc8AtTtDrMfAIMP+YiypmkhyT8zsXWECC7h8Kbj7nX7e+Fpwvmpvc92lociVkpsD3d5hzJu3t5CbYNMPcHvq2WcDuQhYLDP8YvIPMQnkLX7J/DOVsyZ4o2/amY3F2bft4TAq/bDkFwLS7ujAo/Px8ZhdnJ66/IpTFT/bl7TFtCanhSXRSOq/N30Wft5cwZWX+RH3SCvNnaEhEMKE1vfLeLPfnMai1mWjUv8LsRV/1kV3fk0iVsvYL2P+XOTpqyJuq3C4iYgdK0AsRGhrK4sWL8+1ftGgRoaGhDohIpBLa8aP53KgX+AZDvfbm6+LOQ7dVcC+gErvFcr4XHSB8VP5znJxhzCTwrQfn9sO8R+y77JlhwB//BgxocwM06FbweT61YeRn5va6L+DIP/aLoZxFJaax/WS87fWmo7F2bX/yP4fJthr0alaLzo1qFniOq7MTN3QO5e8n+zFxdBvqB3gSlZjOK7/uYthHK4hKMOeVRyWk8cuWkwDc07tJ/oaidpvPQWHmz1O/nHoF6yeb0xZEJK8TG+Cv583twa+bq2mIiEipKUEvxJNPPsmjjz7Kgw8+yIwZM5gxYwYPPPAAjz32GP/617+K1dbEiRPp3Lkzvr6+BAUFMXLkSPbu3ZvnnLS0NMaPH09gYCA+Pj6MGTOGM2fyDq88duwYw4YNw8vLi6CgIJ566imysopeIEmk3G3PSdAjrjOf63Uwn4s7D72wIe5wPkH3CoSGvQo+x7uWWTTOycWcF7/uq6LdOynKXB/7+zsg/RLF0LZ9DyfWmUsMDXyl8PaaD4C2N5nbe/8oWgwV0NK9ZuLqlNNptulYyRL0A1FJdJ+4mFd/3WWbx34uKZ1Z648B8GC/S3zPL+Dm4sTNXRqw5F/9eH1UBLV93Tl4NplbJ63lXFI601YfITPboFPDGnRsUCPvxVnpcO6AuZ37c9RsANTrCFmp6kUXuVhKDMwZB9ZMc83zLvc5OiIRkSpDCXohHnzwQWbNmsX27dt57LHHeOyxx9ixYwezZ8/m/vvvL1Zby5YtY/z48axZs4aFCxeSmZnJoEGDSE5Otp3z+OOP8+uvvzJnzhyWLVvGqVOnGD16tO14dnY2w4YNIyMjg1WrVjFt2jSmTp3Kiy++aLf3LGJXUbshaqc5/DFsuLmvbnvz+dSW4rWV24Ne0BB3gMZ9zef2t+Qf3n6hBl1hYE4NiQXPmr1Al5KVbhYK+6gjrJ8Eu36BLd/mP+/CJYb6/Kto62c37G4+n9l5+XMrqKV7zeHtozuGALDrVEKRCrVd7P2F+zgdn8bXKw/z4eL9AExbdYS0TCttQ/zp0TSwyG25uThxa9eG/PBAd4L9PNgflcRtk9fx7Voz2b+3dwEjMKL3g5EN7v7nv3cWy/m6BesnQXJ0sd+XSJVktcLPD0L8cajRGIb/T0PbRUTsSOugX8aoUaMYNaqA4bLF9Oeff+Z5PXXqVIKCgti4cSN9+vQhPj6eyZMnM3PmTK666ioApkyZQuvWrVmzZg3dunXjr7/+YteuXSxatIg6derQvn17XnvtNf7973/z8ssv4+bmVuo4Rexq41TzudkA8MzptcztQT+z00yAi1LxNzXOLP4G+ZdYyxUxBmq3hNqtCz5+oW4PwrHVsHsefD8WHlgBXhcNoU6OhilXm4XnwJw3nhwFG6aYvUUX/kG64r+QFGn+sdp9/OXvD2YxMij+XPwKIjPbyop9ZtJ6a9cGrNh/ljMJ6Ww7EUfXJkVPqA9EJfH7jtO21x8s2o+vhyvTcqq2P9i3KZYS/PHfMNCbb+/tyo1frGH36QQAGtT0YmBYAety24a3t877fW0x2PxA6fQWWP0xDHi52HGIVCnWbJj/GOz7E5zd4YZp4OHv6KhERKoU9aAXokmTJpw7dy7f/ri4OJo0uUSSUETx8ea8zZo1zaRg48aNZGZmMmDAANs5rVq1okGDBqxevRqA1atX06ZNG+rUqWM7Z/DgwSQkJLBzZ+XthZMqKvkcbJxmbne9YPhjQAMzWbdmFj05tS2xFgTuvgWfY7FAcJvCe88vPHfEJ+Zw+YQTMPdes1foQgtfMpNz7yAY8Sk8vA5cvczibsfWnD/v3EFY/Ym5PWRi0ZcYCmplPiedMb9Wlcz6IzEkpmcR6O1Gu5AA27DxjcUc5v7p0gMYBgwMq8MjOZXVX5u/i/jUTJrU8s5TGK64mtb2Yea9XanpbX54eXevxjg7FZDs5/4c1gnLu//CXvR1X5nDekWqq+xMmHsfbJpuFv0c8bG5WoWIiNiVEvRCHDlyhOzs/MM109PTOXnyZInbtVqtPPbYY/Ts2ZOIiAgAIiMjcXNzIyAgIM+5derUITIy0nbOhcl57vHcYwVJT08nISEhz0OkXKz70py/W7edWT09l8VywTD3IhaKy03QLzW8vSQ8/OCG6eDiAQcWmb3guY6vgy3fmNs3fQsdbjU/VIgYY+7bOOX8uQueLdkSQ+6+ENDQ3I6qfB+w5c4/79uyNk5OFjo1NBP0TUfjitzGhVXaH76yGU8MbMF1nUJsx+/v26TghLoYWtTx5aeHevD2mLbc1q1hwSddWCDuYi2Hmh/8ZCSd/yBGpLrJSjdHG+34wazhcd3X0PYGR0clIlIlaYh7AebNm2fbXrBgAf7+54dvZWdns3jxYho1alTi9sePH8+OHTv455+yr948ceJEXnnlMgWrROwtI9msUA7Q6/H88xPrdYBDS4o+Dz03Qb9UgbiSCo6AYe/BLw/Bktch5Apo3Ad+e8I83uE2CO1y/vwr7oTNM2Dnz+aSQic3mkM9nVxKtsRQnQiIO2quwd24j93eVnn4O2d5tataBQHQIacHfdOxWAzDKNKw9M+XHSTbatC7eS3ahQYAMHF0GyxAXGomIzvUt0usDQO9aRjofekTLlxi7WK5veizbzOXlOo+Pv90CJGqLCMFZt8KB/82h7XfOMOc/iEiImVCCXoBRo4cCYDFYmHs2LF5jrm6utKoUSP++9//FnDl5T388MPMnz+f5cuXExJyvqcoODiYjIwM4uLi8vSinzlzhuDgYNs569aty9NebpX33HMuNmHCBJ544gnb64SEBC0RJ2Vv03RIjTXni7cenv94cZdaO1fIEmul1eFWcz765hnw4z3QaRxEbjfnVQ646MOteh0huC1EbjPn1+cWjOv6QMmWGKoTBnt/q3Q96MdjUjgQlYSzk4XezWsDEFHfDzdnJ2KSMzh6LoVGtQpJiIEzCWnM2XACMHvPc7k6O/HO9eU4bDY9yfyQBC5dv6DlMPPDlDM7YM1ncNVz5RefiCOlJcDMG+HYKnOFipu/gyZ9HR2ViEiVpiHuBbBarVitVho0aEBUVJTttdVqJT09nb1793LNNdcUq03DMHj44Yf56aef+Pvvv2ncOG+i0alTJ1xdXfOsu753716OHTtG9+5mtefu3buzfft2oqKibOcsXLgQPz8/wsIKGJoJuLu74+fnl+chUqayM2HVx+Z2j0fN9ccvllsoLmo3ZKZdvs3LVXAvravfgTptICUaVrxr7rvqBXNZtgtZLHDFXeb23/8xl+byrg19ny7ZfXOHVJ+5aC7+whfhy36wb0HJ2i1ji3ebHwx2algDf09XANxdnImob/77srGQ9dBjkjP4Zs1R7pq6noxsK50b1aBrQ39Y/q75wUh5O5tTBNCnDnhforidkxP0ecrcXvu5+eGTSFWXEgPTR5jJubsf3P6TknMRkXKgBL0Qhw8fplatWpc/sQjGjx/PN998w8yZM/H19SUyMpLIyEhSU1MB8Pf35+677+aJJ55gyZIlbNy4kTvvvJPu3bvTrVs3AAYNGkRYWBi33347W7duZcGCBTz//POMHz8ed/ciFqYSKWvbfzALr/nUgXY3F3yOfyh41jQLxR1Zcfk2y2qIey5XT7MasXvOB1jBbc8n4hdrcx24+ZjLcoFZ2bukVYzr5FZy332+SF1KDKz6nzm6YOYN5lrDiWdK1n4ZSMvM5qsVhwEYclEBN9s89IsKxSWnZ/Hz5pPcNXU9XV5fxPM/72DnqQTcXJx4anAr2P0L/P2aWYCqvBU2vP1CrYebH6ikJ5hD3UWqsqQomHoNnNpk/ls99ldziUoRESlzStALsHr1aubPn59n3/Tp02ncuDFBQUHcd999pKenF6vNzz77jPj4ePr160fdunVtj9mzZ9vOef/997nmmmsYM2YMffr0ITg4mLlz59qOOzs7M3/+fJydnenevTu33XYbd9xxB6+++mrp3rCIvZzZBQtfMLe7PQiuHgWfZ7FA/U7m9rfXwRd9zQJciQUUO8yzxFoZDHHPFdjUTNIb94VRnxfc8w9mcbfc4kj1OkK7W0p+z5pNzTmdmckQd8Tct/8vMKxm0m9xhp0/wSedzYr4F1ead4DJ/xzmZFwq9fw9uKVrgzzHbJXcj8aSkWVl4a4zPDxzE53+s5DHZm/h7z1RZFkNwuv58ezVrVj6r350aVwTovaYDUTtMtckL0+FFYi70IW96Gs+hbT4so1LxFHiT8KUoebUG586cOfv56cliYhImdMc9AK8+uqr9OvXzzaMffv27dx9992MGzeO1q1b884771CvXj1efvnlIrdpGMZlz/Hw8OCTTz7hk08uXSm4YcOG/P7770W+r0i5Ob3NHA6ZGmP2QHe+t/DzB75iJsEHFpnrTJ/eAn89D036QdsbodUwMxnOHd7uU+fSS6zZS9OrzMflXPUCeAVCh9vNxK2knF3Mtdsjt5kfbtRsAntzfr873wthw2Heo+bX5tdHYdtsuOaDks13t4Oziel8uuQAAE8PaYWHa94PMTrm9KDvPZNI59cXEZ+aaTvWKNCL4e3rM7xdPZoF+eRtOPd7DLDrF+jzr7J5AwUpag86QNgIqNXSXH5v7Rcln9ogUlHFHIbpwyHumDnS6Y5fym5qkYiIFEg96AXYsmUL/fv3t72eNWsWXbt25auvvuKJJ57go48+4vvvv3dghCIVzKnNMO1aMzmv1xHGzgN3n8KvqRMOt8yGJ/fB1e9CSBez5/jg3/DT/fBOc/jhbtiW87tWVsPbS8KrJlz1PNS4xLJdxWEb5r7LXMrowN/m65ZXm0vU3bMYBr9hrsF+dCV83hOWvmWeW87eX7SP5Ixs2oX4M7xdvXzH6/h5EFrTE8OA+NRMgnzdubtXY34Z35Ml/+rHEwNb5E/O4XwRQDAT9PISc9j88AMu34MO5gdKuUn56k/MAloiVcXZfWbPedwx88PCO/9Qci4i4gDqQS9AbGxsnvXGly1bxtChQ22vO3fuzPHjxx0RmkjFs+c3+OkBc25uSBe47Yfizcn2DoQu95qPmEPmHPZts80CbDt+OH9ezSb2j70isBWK2wlH/oGMRHO0QG4hPWcXc2mvVtfAb0/CgYWw9A3Y8SNc+yE07F4uYe6NTGTWumMAPH9NGE6XWJ/87THtWLo3ir4tatO1SeDl1zE3jLwJeuQ2M3Euy+kMVitsmAwLXzKnF/gEFy1BBwgfBcveguh9sPhVs8BgcZfXE6loTm+DGaPMQpm1W8MdP4NvwavDiIhI2VIPegHq1KnD4cNmEaSMjAw2bdpkK9QGkJiYiKurq6PCE6kYsjNhwXMw6xYzOW/YE26fW/KCaWAm4X2fhoc3wL1/Q9cHzSrpYA59r4rq5CSGUbtg7x/mdosh+YfO12gIt86BMZPNr0n0XpgyxEzardllHuabf+zGasDVbYLp3OjS64B3bxrIhKtb06NZrcsn5wDJZ80PJbBAaE4Rqt2/2ifogqQlmEN4f/+XmZw37AV3/QFuXkW73skZ+r9kbq//CpZOLLtYRcrDiQ0w7RozOa/bDsb9puRcRMSBlKAX4Oqrr+aZZ55hxYoVTJgwAS8vL3r37m07vm3bNpo21bAvqcYSTpkVflfnLKfWbTzc/rP95ojnFpEb+iY8sQee2G1WT6+KgnKGuJ87AHtyilO2vLrgcy0W8+swfp05/x1g/SRzxEEZysiysnx/NABPDLTz/Pdz5px2AkKhzfXmdlkOc1/1kblygKsXDH3HrE5d3NEZra+BIW+Z28vegn8+sHuYIuXi6GqzdkhavPkB2dhfL73coIiIlAsl6AV47bXXcHFxoW/fvnz11Vd89dVXuLm52Y5//fXXDBo0yIERijjQwb/h815wfI25LNkNM2DIG+DidvlrS8LZBfzqVd1hxL7B4FnDnH+feBpcPC+/1rBXTRjxMfTJmQ+948cyDfHouWSyrQY+7i40rX2Z2gLFlTu8vWZTaH0tYIGTG8xK0vaWkQLrJ5vbIz+FrveVvMhftweg/4vm9qKXzrcrUpn8/i/ISDJXr7j9p9KNgBIREbtQgl6AWrVqsXz5cmJjY4mNjWXUqFF5js+ZM4eXXnrJQdGJOIg1G5ZMhBmjzWXPgtvAfUvNSuNSchYL1Ik4/7rpVea67EXR9kbz+eASSD5n/9hyHIhKAqBpbW8s9v6gJLeCe2Az88OKBjnTiXb/atYk+OkBs2BgcRLg9CQ4shJij+bdv/U7s5BhQENzXfPS6v0k9M6pOL/gOfMDAJHKIiUGzuwwt6/7Gty8HRuPiIgAStAL5e/vj7Nz/rWQa9asmadHXaTKSzoL34yGZW8CBnQaB3cvLLDC78Tfd9Pn7SVExqeVe5iV1oUFyloOvfR5F6vVzJwzamTD7rIbFm5L0AuqwF5auUPcc3+WchPn5W/D/64wk+rkKPjtCTMJvngt+Nwic1tnwfwnzNEdb4bC1KvN7dx11a1Wc/1ygG4PXnqd++K66nnwbwBZqXB4uX3aFCkPx1abz7Vagnctx8YiIiI2StBFpHBHV8MXveHQUnPe7qgvzerhBfTynktKZ/I/hzkWk8Lv20+Xf6yVVW6hOCzQYnDxro0YYz7vmGvXkC504KyZoBe4RFppnTtkPucuo9f6WvM55Zz5wUOzAdDjEXPf6o9hzh1mIrziPfjuZninGfyvo7k034bJELndnC7g4mEWL5x1i1kYbv8C88MAd3/ocJv94rdc8D3b96f92hUpa0dXmc8Nezg2DhERyUPLrIlIwQzDLKi16BUzUarVEm6YBkGtL3nJL1tOkWU1AFh96Bx39SrDpbKqkka9wdkdml4JPkHFuzZ8FCx80VyiLeE0+NW1e3i5PejN7D3/3Gq9YIh7ToIeEApXPmcOve02HhrkVHav2x5+ftAc+n5xlXdnN3MkQUgXCO1sPju7wpf9zOXQfnrALIIF0Gms/YoZ5moxxKzovm+B+XtTVeslSNWiBF1EpEJSgi4i+WUkwy/jYedP5us218M1H4B74QnanI0nbNtrD50j22oUbamt6i6wKTy+A9xKkAAHNDCrLx9fC7t+Nodv25HVanCwrHrQE09BVho4uZjzwnP1fTr/uW2uM4sFznvEnOudm4iHdjGTcxf3/NfcOAO+Hgp7fzNfO7lA1/vt+x4AGvUyR5cknjJ78Ou2tf89ROwpPQlObzW3laCLiFQoGuIuIjYxyRksXbcR6+TBZnLu5ALD/gujv7pscr7zVDy7Tyfg5uyEt5szCWlZ7DqVUE6RVwE+QUVfi/tiZTjM/WRcKmmZVtycnWhQs4TxXUpuBfcajcxq/ZfTsAc8shGe3A03TIceD5sJekHJOZhL9V3z3vnX4aPAP6TUYefj6gFNrjS39y2wf/sil5OVDiv+C8fWFO38E+vMkVEBDcrmd0JEREpMCbqI2Hz7869E/DYSpzPbMbxqmWvidr6nSEN2f8jpPR8YVoduTcx1dFcfii7TeCVH2EiwOJl/dF9cubyUcuefN6rlhYuznf/LyC0QVzN/sUG76XCbWWndPxT6PFV299E8dHGkhS/C4lfh2xuKtkRh7vD2Buo9FxGpaJSgi4jNVcf+Ry1LAjutDXmt/qdYQ7sX6bqMLCu/bDkFwHWdQuje1EzQVx0su6W/5AK+dcxh1gA77duLfjCqDAvExeQUiCtgNQC76v+COYWgdsuyu0fzQebzyY2QFFV29xG52L4FsPZzczs9Hn591KyFUJijORXcNbxdRKTCUYIuIqbUWFqlm3MSH8r8P77ensWr83dhXO4PPeDvPVHEJGcQ5OtO7+a1bAn6+sMxZGZbL3O12EXuMPftP9i1Wdv8c3sXiIP8S6xVZn51zUJ2GLB/of3aNQw4uw+s2aVvKyvdTOb+eAYO/l369sTxEiPN4okAYSPMYpMHFsGm6Ze+JisdTqw3t5Wgi4hUOCoSJyKmA4txxso+a326derM0Q3HmbrqCBuPxlLHz50ALzdqeLkS4OVGTe/z2zW83Ji1/hgAozrWx8XZidbBfgR4uRKXksm2E/F0aljDwW+uGggbAb8/ZVY/j9wOwW3s0mzZroGeMwe9LIe4l6cWQ+D0FnOYe4dbS9+e1WoWxdvyDQx4BXo9Vvw2MlLMhG33PDM5T8+pC7FxKty7GOqElz5OcQyr1UzOU85BnTbmEpjrv4K/nocFz5mrQgQ0yH/dyU2QnQ7etSGwWfnHLSIihVKCLiKmvb8DsNDaidu7NySsnh8vzdvJ9pPxbC/ClEaA6zuZxYacnCx0axzInzsjWXPonBL08uBZA1oOhV2/wNZZ9k/Q7d2Dnp0FsUfM7aqSJLQYDMveNHuns9IvXbyuKAwDFr5gJucAm7+Bnv+Xtx7E1tmw40ez+F3E6PP3S0uA/X+ZPwsHFkFmyvlrfOuCRwCc3Q2zb4f7loKHX8njFMdZ86n5s+biCWMmmcUKuz0Eu+fD8TXmShy3/wJOFw2WPJY7/7y7lgQUEamAlKCLCGRlwP5FACzK7sQ1Hi6M7dGIHk0DORCVRGxKJrEpGcSlZBCbkml7NvdlEp+ayZCIYJoFnV9fukczM0FfffAc46+sIglYOZm9/hjztp7Cy80FX3cXfDxc8HF3wdfDFR+PnH3uLvh6uFDT241GtbxxdXaCdjfDrl8wtn3P5paPEejrRcNA7xLHcS4pndiUTCyWMkjQ44+BNRNcPMCvvn3bdpS67cGnDiSdgbebQv2OEHKFWSXbIwA8/MEzwNz2rGG+dnIuuK2VH8Dqj81tizOc2w9ndkJwhLkvM9UcMZEeD/sXmMl8u5sg+oCZtGWnn28roAG0Hm6Osqh/BaTGwhd9zDXo5z0M109TolbZnN4Ki142t4e8AUGtzG0nZxj5KXzeCw4vN3+Gej6a91rb+uc9yy1cEREpOiXoImL2qKTHc9bwY4vRFF8PVwCa1/GleR3fy1wMhmFguegP/O45ldzXH4khPSsbd5dLJCKSh9Vq8J/5u0lMzyryNW7OTrQI9qF5rVq8bPHDPzmKj778krXOnfjj/3rTqFbJkvTc3vP6AZ54utn5+3cup0Bcjcb5e/gqKycns2L84lcgIxEOLzMfhXH3MxN1j4Cc5N3fXN5w18/m8YGvmWvc75lv7stN0HfNM5Nzr1pmz3nCSVj1v/PtBjYzE/LWw8114i/8/fQOhOunwpScERdrP4duD9rtyyBlLCMZfrjb/ICr1TXQ6c68xwObwpCJ8Ov/mT+LjXqaSw6COXLl+Dpzu2HRioCKiEj5UoIuIrD3DwAWZ3fEwAlfj+L903Bxcg5m1e9aPu5EJ6Wz5VgcXXMSdincsZgUEtOzcHNx4uVrw0lKzyQpLYuEtCyS0rNISssiMWdfYnoWUQnpJKVnseNkAjtOJtDWpTt3uixgjPMKlma259mftvPtPV0L/B5dTu4Sa4VWcE8+B9+OMXuPr/2g6I1XpQJxF+p6H3S+G6J2m4W4Tm2G5GhIi4PUOEiLN7czzK8t6QnmI/54/rZ6/p/Z+7n9BzNB3/kTXPmcmWznFgHrej/0etw8vuc3MzFvPRyCWhfeKx7aGQa/Dn88bc5ZbnLl+V5Yqdj+fMYcUeFbF4b/r+Dvc8excHCJ+aHOD3fB/SsgKw1+vMf8efMI+P/27js+ijr/4/hrNz2kkUAaJBB6R4o0sSAoXcCKhyIe4qF46tnu1J966nlwKqhwnnqnomIXFRRFFBBBQKQFCL0FEgiElgak7vf3x6QQaoBNdjd5Px+Pecxk5juz35mvrPuZb4OoNlWdcxERqQAF6CI1nTGwyep/PtfRCX8fu9Vc+iLZbDa6N47g2zV7WbL9kAL0CkramwlAy5gQ/tD1NAM8ncThMKQeOc6GtEy2HzhKgu0uWDCHgb6reZZclmw/xBcrU7m5c9x552V7+lGgeAT3nQshIwUu+UP5gODnF6wgdO9qaHtj2XRv55K+3lpXtwAdrGbG0W2Ka7vvPH2aogIrWC8N2o8Ubxf/XbshtL7eStusrzU696Ft1iCAPoGw61ew2a3y8PKx+qG3HnZ++exyt9UcfssPVhP5EV9c8C1LFVk/o/jljA2GvQWB4adPZ7PB4NesAeGOJMPnt1svjXL2W//9XDflzN0rRETEpRSgi9R0+9dD5m4cXn786mhDcC0fp1368iZ1+HbNXr5fl8aDfZpeUC1uTZO0xxplu01sxQbustttxEcEEh8RaO0wjSGpOfaDm5nYOpk7Elvwwncb6dU8krrB5zdoWUkNetM6fvDpCKvmreAYdBljJdi/AVZOLTth3vPwxx/OXHNrDCQvggUTYNdia1+dSpyb3J15+UCtOtZyLn7B0PSaslp0Uzx1YZM+Vv/2C2WzwbUvWAPJbf0Rts2DJr0v/HpSuTJTrTnOwRrRv9GVZ08fEAY3vgPv9oMdC6x9dVvCze9D3Rr6705ExANUk45/InLBipu3Z8T0JBe/827efjb92kbj72Nna3oOa1IznXbd6mx9cQ16m3qhF3YBm80aLAy44thc2tQLIfN4Ac9+u/68L7W9uA96O69dZdNzzXnCGqDKGJjzuBUsJlxhDfaW8tvp5wA3xgoQpg6A9wdbwbmXL1w65vxrfWuqkueU9BUkfmxtdxx58det08QqB7CaujtjvnVxPkcRfHW31boitqPV1aEi4rrAtc9b4xp0uB3GzFdwLiLi5hSgi9R0xdOrpUX1AigdIM4ZQvx96N8mBoAvVpymj62UY4xh3Z7iAD32AgN0gHY3A2DbvYSX+sfiZbcxa20aX61KrfAljuYVsifjOAANjq4tO1CUD1+MsvpF71hgBdqDJ1vNpQHmP2fNz2zdkNWE+t1+8MEQazBCLz8r7f2JMPBl8A288PusSZr1s16CHNlpNVOuVdfa5wxXPmb1SU7fAKunOeea4lyLJlkvtnyDrCnVvM7je7r7OHhiLwz5t/69iYh4AAXoIjVZzgHYuwqAneFW3+EQJ9agQ9nc6N+s2UtugWrnzmZPxnEyjhXgbbfRLPoipjULrW81ZQVaFmxk7JWNAHh0+lp+SNp31lMzjxWwYHM6L83ZDEBELV8C04pHfe75FwipD4d3wFd3Wfu63QPhCdYx32DYtw42fG01l37nWpg2zKpZ9/KDrmPhgUQY8BKEVpOp1aqKXxA0vbbs75K+584QGA5X/c3anv8PyMt2znXFOVJ+hwXjre0BL1/YuA3e59e9RUREXEd90EVqsuRF1jqqDQcJA/Y6tYk7QLdGEdSvHUDqkePMWb+PIZcoMDuTkv7nzaKCL35auviucGAjpPzGw9cMZF9mHl+uSuXPn6zivyM706t5JA6HYcfBHFbuOsKqXRms3H2kdGq1Eu3rBcPupdYfzQdCs/7W9FymyKrFvfwR61hgOPT4Myz4J3z1J2sKKLBqfTvdaY1IHhJzcfdU07UeBhu/sbY7OKF5+4k6j4bf/2fNjb7yPassxfVys6yR100RtLmxtPuKiIhUXwrQRWqykgC94eVk51rzbgf7Oa+JO1iDmN3YqT6vzt3KFytSzztAz8krZO6G/WTnFpBfZCgsctCrRSTNKjA/u6cp639esQHiziqumxVo7V6G3W7jxRvbkVtYxHdr0xg7bSVdG0WQuPsIWbmnzreeUKcWHeLD6Bhfm+tis+Ddw+AdYM2n7e0L/SZYfdH7TQD/E/La7R5rTu3jxek7/9GaJiw4+uLvR6B5f2ja15pKrU4T517b2xcuudWqQU/f6Nxry4X76SnI2AVh8TBo0tmnzhMRkWpBAbpITbZzobVOuILsHVagFhLg/K+FGzpaAfri7QfZk3GcemEBFTpv16Gj/PG95Ww/cLTc/lfmbuHjMd3oGF/b6Xl1paQ9FzlA3Iniu1rrtEQoyMXLx59Xb7mEvAIHczfuZ+GWAwAE+HjRrn4onRrUpmN8bTrEhxERdEJz2BXvWuv6na0gDqy5vruMOTVY8A+BEdOtvubtboGgyIu/DynjEwAjPq+864cWT+uXsbvyPkMqLvlX6yUbwNA3wN8J3wsiIuL2FKCL1FRZe615lW12aNCD7A3Wj3JnDhJXIi48kB6NI1iy/RBfrkzl/t5Nz3nOsh2HGPvhSo4cKyAy2I/ODWvj42Vnx4GjrNuTyR/fW870sd1pEll9atKT9lpN3FtfzABxJWonQK1IOJpuzVHeoDs+XnZeH9GBqYuTCfDxomN8bVrEBJ993vtdxc3bG/Qov/9MNXn1O1mLeJ6SKdsyKz6YoFSSguPwTXE3g06joGFPl2ZHRESqjgaJE/Fk856H9wbB8SPnf+7O4ubtMe0hIKy0qbOz+6CXuKmz9eP/8xUpFBY5zpr28xUp3PbOMo4cK6B9/VBm/bkn/xnRideGd+CzP3WjfVwYGccKGPnO7+zLzK2U/Fa19KxcDmTnYbdByxgnvHSw2cpq0VN+K93t5+3F2Csbc0ePhrStH3r24BzK+p/Hd7/4PIl7KwnQs/aUjcQvrrFggjUYY3AMXPOcq3MjIiJVSAG6iKcyxurvm7wIfnnp/M9PLm7e3vBygLI+6JVQgw7Qr3UMtQN9SD1ynM9XnL6GrshhGP/9Rh6bvpaCIsPAdjF8end3IkP8S9ME+nozddSlNKpTi72Zudzx7u8cyz+1H7WnSSruf964bhCBvk56SRLXzVrvXnZh52ekQGYK2Lyg/qXOyZO4r5BYq0VNUb7V8kJcY28iLJlibQ+cpKbtIiI1jAJ0EU91/AjkF4+4/ft/4dD28zu/tP/5lQBk51qjbldWDXqArxcPFDdtn/TTZnLyygfVR/MK+dO0lby1cAcA9/duypThHQjwPXU08/Bavrz/xy7UDfZj8/5sPv3d8+dYLxnB3Sn9z0vEFwfoKcusFzrnq6T2PPYSa5ovqd68fKwaW7BezkjVK8yDmfdZo7a3HgYtBrg6RyIiUsUUoIt4qhP7iToKYO4zFT/3SLI1EJTduzSIy67kJu4Af+jagIQ6tTiYk89bv5S9UNibcZwb31zK3I378fW289rwS3jommbY7WcesTguPLA04J+6ZCdFjgsIQN1IyQBxrWOdMIJ7ieh21jRnxw/Dwa3nf/6uJdZazdtrjtA4a52pAN0lFoyH/esgMAL6v+jq3IiIiAsoQBfxVCUBelCU1Sx147dlAdW5lPQ/r9eptGa0pAY9pJKauAP4etv5a78WAPxv0Q7SMo+TmJLBkNcXszEtizpBvnwypluFp2K7oWN9wgJ9SDl8nJ827Ku0fDtLbkERBWfof79+byXUoHv7WmUM5fqhV9juMwwQJ9WXBopznd2/weLXrO3Br2kWBBGRGkoBuoinKqnhiusCHUda23OerNjgTifMf16iKmrQAfq2juLShrXJLXBwz4eruOWtpRzIzqNFdDAzxl1GpwYVnzotwNeL27o2AODtRTsrK8tOkV/oYOjri+n43E/MTNxT7lh6di57Mo4D0MqZNegAccUDxZ1PP/TjGbDjFziwyfpbNeg1R5hq0F0iLxu+/hMYB7T/A7Qc7OociYiIi2iaNRFPVfIDOjQOev4F1k2Hvasg6Utod9OZzzOm3PznAIVFDo7lFwGVN0hcCZvNxpMDWzH09cUkpmQAcHWLSCbf2oEgv/P/ShrZvQFvLdzOil1HSEzJ4JK4MOdm2Enmb9rPpn3ZADzwaSKLth7k/wa25OvVe3j9520ANK5by/ktGEr7oZ+mBj03Ew5shvSNVjBess5OK0tTtwUEhjs3T+K+VIPuGnOetLoehcZB/wmuzo2IiLiQAnQRT5VxQoAeFAk9H4T5/4B5z0LLQeATcPrzDm23AjAvX6v2HcoN2FbZNegAl8SFcWuXOD75PYW7eibw+ICWeJ2lv/nZRIb4M7h9LF+t2sM7v+5kyq0dnJxb5/hsuVVerWJC2LQvi+krU/l69Z7SvvMNIwJ58cZ2zv/gktHXD22DbXNh3zqrK8T+9dZ0WmcSUh8iW0CPPzs/T+K+QuOttQaJqzoHt8Gq9wEbDH1Do7aLiNRwCtBFPFVJDVdJjVe3cbBiqlWz/tsbcPlDpz9vx8/Wun6X0iC+pHm7v4/93PNiO8k/h7XlkWubExHkd9HXGt0zga9W7eH7dWl0bxTB1vRs1qZmkldYRGSwP3WD/IgM8aNusB+Rwda6bpA/kSF++PucOkq8s+3LzOWXLQcA+PcfOnAgO48HP0skLTOXqBA/HujdjJs616+cZx8YbtWCH9gEH95w6vHgWCsQr9uybF23Ofg7uam9eIbSGnQF6FVm6xxr3egqSLj8rElFRKT6U4Au4qlKAvSSPqO+gdD7aasf46JJ0OF2CKp76nkbv7XWza4t3ZVVOsVa5TZvP5HNZnNKcA7QOjaU7o0iWLrjEE98ve6ko1lnPTfYz5u6IX7FQbw/saH+DO1Qj5YxZQGqw2FYuPUAB3PyGdah3nnX9k9fmYLDQJeEcBrVDaJR3SB+ePAKlu88zGVN6px2KjmnajUEftkEAbWhwWXQsCfEdrQC8YCwyv1s8SwlAXpuhtUv2i/YpdmpcgXHz9z66MQ0y9+GZv2gTtOL/8ytP1nrptdc/LVERMTjKUAX8USFeZBTPGp5ybRIAG1vtmrP0xKt6XoGTSp/3rHDkPyrtd1iUOnuqhogrjI92q85f/54NZEhfrSvH8YlcWEE+3tzIDuP9Oy84nVu6d/p2XnkFzrIzisk+0AhOw4cLb3WWwt3cEWzutzVM4Fdh48xdfHO0uMzE/fw2vAOhNfyrVC+HA7DZyus2shbOpeVVWiAD31aRTnxCZzFlX+Dzn+EWpFg19igchb+IVYT69xM6yVgZEtX56hy5R+1vhO3z7eWg1vgqsfhqr+d+Zx5z8Nvr8OqaXDvUrBfxAu2/KOwa7G13UQBuoiIKEAX8UwlfYe9A6z5ckvY7dD3BXhvIKx8D7r+yaolLbHlBzBFENUGIhqX7i4L0KuuBt3ZOsbXZvHfrq5wemMMWbmFHDgpeF+9O4PZSWks3HKAhcXN0sGqaS90GBZtPcjgKb/y1u2dKjQl2m87DpFy+DjBft4MaBtzQfd20ex2CI52zWeL5wmNh9x1Vj/06hagOxzWPOPb58O2eZCyDIryy6dZMB4iW0Gr6049P30jLHvT2j64GZK+OvugnOeyc5H1+WHxzqmNFxERj6cAXcQTlQ4QVx9sJzW3btgTmg+Ezd/Bj0/BiM/LjpU0bz9pCp+yOdBrzleCzWYjNMCH0AAfmkQGlTu2+9Ax3v51B1+uTKVusB+jejTkxs5xpB45xthpK0k+dIzr31hCt0YRNAgPpEFEIHHF6/jwQAJ9y55jSe35dZfEVn5TdhFnCK1vBbHVpR96YR6sn2ENkrjjZzh6oPzx0HhocjU07m1NQfn7f2HGPdbLzRNfcBoDsx+zXnKWtDJYMB5aDwOvC/zu3FbcvL3JNad+l4uISI1Uc36Ni1QnJw8Qd7JrnrMGHto6B3YssAYfysuxao2gXPN2qB5N3J0pPiKQ54a04bkhbcrtbxEdwsz7evLQZ4nM25Rerob9RHWC/IgPD6BBRC1mJ1ldEW65NO60aUXcTnWbam3+87BkStnfPrWsKSYbXw1NekN4o7LguHl/2L8Bdv0Kn46AMfPLBkzcMNOaotLbH+6cDe8NgsPbYd3ncMkfzj9fxsDWH61t9T8XEZFi+jUu4olOHiDuZHWawKV3WU0x5/wf/OkXq/aoMBdqJ0BU63LJS2rQg/08t4l7VQkN8OF/IzuzOuUI29OPsuvwUXYdOsbuw9aScayAgzl5HMzJY9XuDABaRAfTtgLN4UXcQsn3SnWpQd9ePHPFJSOsQLp+F/A+wxgSXj5w03vw3yvh0FZ4f7B1TsIV1lzlAJc9aH2H9nwQfnoafvkXtL3JOvd8HNwKGbutKS8TrrjAmxMRkepGAbqIJ8rcba1Dz1Ire+VfYc0nVlPVNZ+U/UhtOfiUppSqQT8/druNTg3C6dQg/JRjmccL2F0csO86fJT0rDxu7FQfm5qviqeoTjXoxzNg/3pru8/fISjy3OcE1YVbpsHUAdaAm2mJZcdC463AHKyXoEumwJFkSPwYOt1xfnkrad7eoAf41jq/c0VEpNrSr3ERT1TaxP0sAXpgOFzxKPz4f9aow/nFo5S3PHXgo6xqMEicuwgN8KFt/VDa1leNuXio0HhrnVENatBTfgcMhDeuWHBeol4nGLfMata+5UfYvRSMA/r/q2waNt9a0PMhmPM4/PQUpC63uhM1vByCKzBDw9YT+p+LiIgUU4Au4olOHCTubLrcbc3XeyTZ+jso2vrheZLSJu6qQReRku+V7L1QVHjhA6C5g91LrHWD7ud/bu2GcNkD1nI8A44fgfCE8mk6/xFWT4P0DdZ69TRrf90WkHCl1XS94WUQULv8eSdOr6b+5yIicgIP/r+uSA1lzLn7oJfw9rOadX4xyvq75aDTzoOdpSbuIlIiKArsPuAosIL0sHhX5+jC7f7NWsdfQIB+ooAwazmZj781kFzyr7DzF9jxC+xbBwc2Wcvvb4HNDjHtrWC9TnMr0E/fYE2vFhoPdZpdXN5ERKRa0a9xEU9z9AAU5QE2CI49d/pWQ60ml7sWQ7vhp01SVoOuJu4iNZ7dDqH1rJY3mameG6AX5MKeldb2xQboZ+MTYNWCl9SEHztsTde2c6EVsB/aCntXW8vJmvfT9GoiIlKOAnQRT1MysnJw9JlHIj6RzQYjvoDsNGs6odMoGSQuJEBfCSKCNb7FkWSrO00DrDm/D++AmEs8J6Dcu9qqpa4VecbvvkoRGA6thlgLQNZe2LnIqmHP2guBEVCrDgTHQMeRVZcvERHxCPo1LuJpKjJA3Ml8As76A7WkBj1ENegiAmXfL5kp1lRg7w201uGNodMoa8qyWhEuzeI5ndj/3JUvFUJiof0t1iIiInIOp3ZGFRH3VtEB4s6DplkTkXJKxrdIWVYWnAMc3m6NWD6pBUwfbfW9NubiPitzD0xqDZM7wKJJkL3/4q5Xwln9z0VERKqQAnQRT1PRAeIqqLDIwbH8IkB90EWkWMkLwK0/FtecN4L7VsDgyRDbwWo6njTdCt5f7wJLX7f6Xl+IhS9CVqrVhH7es/BKK/h0hDUNmaPowq7pKILdy6zt+G4Xdg0REREXUIAu4mlK+qCfTxP3s8jJKyzdVg26iADlv1/CG8Oo76BOU+h0B9y9wFo63gE+teDgFpjzBExsAV/dXRYYV8SRZFj9obV9xWNQvws4CmHTLPjoRnitPSyYUPZisqLSN0JeJvgGQVTb8ztXRETEhRSgi3gaJwfoJc3b/X3s+HjpK0FEgOh24BtsTQE2apbVj/pEsR3gusnw8CYYOAmi21qzS6z9DN69Fn56GhyOc3/OwpesgLxRL7j6SbjrJ7hnKXQdC/5h1vfdgvHwalv46CbYOAuKCs593d1LrXX9Sz17HncREalx9GtcxNOUDhLnnD7oWZpiTUROVisCHtoA9yw5NTg/kX8IXDoa/rQI7poP7W+19i9+DWbcc/Zg+tB2SPzE2u71RNn+qFbQ/1/w8Ga4/n/QoCcYh9Xc/rMR8J9usDfx7PkvCdAb9DjnrYqIiLgTBeginiT/KBw7ZG07KUDXAHEiclr+IeBVwRd3NhvU7wTD3oQhr4PNC9Z+Ch/fAnk5pz9n4UtgiqDJNRDX5dTjPv7Q7ma48zu4byX0uN+aouzQNni7Dyz5d/la+px0WPs5fDkGNn1v7VP/cxER8TD6RS7iSTL3WGu/EAgIc8olywJ01aCLiBN0uM2ae/yLO2D7PPj2AbjxnfJpDm61msMD9Hr83Nes0wSufR56/gW++bPVR/3HJyHpS+vlwKHtkJtR/pzaCVYTdxEREQ+iGnQRT5JZPNWRU6dYK5kDXe/rRMRJml0Lt35qbW+aBfnHyh//7T9Ws/Vm/aFep4pfNzAcbvnQ6vfu7Q97V8GelWXBeXRb6PkQjPoe7lsOPgFOuR0REZGqol/kIp7kSLK1rt3QaZdUE3cRqRQJV0BovPVicecv0Ly/td9RBBu/tba7jDn/69psVr/3hCth+3wIjoaIxlaNuW+g8/IvIiLiAvpFLuJJKiVALx4kzk9N3EXEiWw2aN4Pfv8vbP6+LEDfvRSOHrBGaU+44sKvX6eJtYiIiFQjauIu4kmO7LLWYQ2cdknVoItIpSkJyrfMKRvQbcM31rrFwIoPQiciIlJDKEAX8SSVUIOepUHiRKSyNOhpzaeesx/2rraC9I3FAXrL61ybNxERETekAF3EUxhTuU3cVYMuIs7m7QtNelvbW2bDnhWQnWYF7Y17uTZvIiIibkgBuoinOH4E8rKs7bB4p11WTdxFpFKVNHPfPBs2zCze1w+8/VyXJxERETelX+QinqKk9jwo2qkjFZfVoKuJu4hUgqbXgs0O+5Os2nNQ83YREZEzUA26iKeohObtUFaDrnnQRaRSBIZDXDdr+9gh8AmEJn1cmycRERE3pQBdxFNkFI/gXtt5I7jDiU3cVYMuIpWkpJk7QNNrNF+5iIjIGShAF/EUlVaDrkHiRKSSnRigq3m7iIjIGekXuYinqIQAPa+wiKP5RYACdBGpRHWaQvMBcGQXNOvn6tyIiIi4Lf0iF/EUlRCgf7EiFYCoED9qB/o67boiIqe49RNX50BERMTtqYl7FVm4cCGDBw8mNjYWm83GjBkzyh0fNWoUNput3NKvX/lahsOHDzNixAhCQkIICwtj9OjR5OTkVOFdiMsUFUJGirV9QoA+dfFOHvx0NSmHj533JfMKi3j9520A3HNlY+x2mzNyKiIiIiIiF0gBehU5evQo7du35/XXXz9jmn79+pGWlla6fPJJ+dqGESNGsH79en766SdmzZrFwoULufvuuys76+IOslLBFIGXnzXNGpB88CjPz9rAjMS9DJy8iDnr953XJT9bnkJaZi7RIf4M7+K8edVFREREROTCqIl7Fenfvz/9+/c/axo/Pz+io6NPe2zjxo388MMPLF++nM6dOwMwZcoUBgwYwMsvv0xsbKzT8yxu5EjxCO5h8WC33qu9tXA7DgM+Xjaycgv507SVjOrRkMcHtMDP2+usl8stKKs9H9erMf4+Z08vIiIiIiKVTzXobmTBggVERkbSvHlz7rnnHg4dOlR6bOnSpYSFhZUG5wB9+vTBbrezbNmyM14zLy+PrKyscot4oJP6n+/PyuXLlXsA+OCPXbn7ikYAvLckmRvfWMquQ0fPerlPf9/N/qw8YkP9ufnSuMrKtYiIiIiInAcF6G6iX79+fPDBB8ybN49//etf/PLLL/Tv35+iImuE7X379hEZGVnuHG9vb8LDw9m378xNm8ePH09oaGjpEhenYMwjnRSgv/PrTvKLHHRpGE73xhE8MaAl747qTO1AH9btyWTQ5F/5bm3aaS+VW1DEfxZsB+DeXk3OWdsuIiIiIiJVQwG6mxg+fDjXXXcdbdu2ZejQocyaNYvly5ezYMGCi7ru448/TmZmZumSkpLinAxL1TohQM88VsBHv1lN3u+5qnFpkqtbRPH9A5fTuUFtsvMKGffxKv5vxjpyC4pK0+QWFPGXzxJJz86jXlgAN3fWCxsREREREXehAN1NNWrUiDp16rBtm9VPODo6mvT09HJpCgsLOXz48Bn7rYPVrz0kJKTcIh7ohAD9/aXJHM0vomVMCFc1r1suWUxoAJ/e3Y17iwP3D3/bzbD/LGHHgRyycwsYNfV3Ziftw9fLzj+GtsHXW18BIiIiIiLuQoPEuanU1FQOHTpETEwMAN27dycjI4OVK1fSqVMnAObPn4/D4aBr166uzKpUheIA/XhwHFMX7wSs2nOb7dSp0by97DzWrwVdG0Xw0GeJbEzLYvCUX4kJC2Bbeg5Bft78d2QnejSuU5V3ICIiIiIi56DqsyqSk5NDYmIiiYmJAOzcuZPExER2795NTk4Ojz76KL/99hvJycnMmzePIUOG0KRJE/r27QtAy5Yt6devH2PGjOH3339n8eLF3HfffQwfPlwjuFd3uVlw/DAAP6T6ceRYAfHhgQxoc+aWEwBXNqvL9w9cTrdG4RzNL2Jbeg51gnz59O5uCs5FRERERNyQatCryIoVK+jVq1fp3w899BAAd9xxB2+88QZr167l/fffJyMjg9jYWK699lqef/55/Pz8Ss/56KOPuO++++jduzd2u50bbriByZMnV/m9SBXLKJ5iLTCC6UkZANzcuT7eXud+vxYV4s9Hd3XjzV+2s2rXEZ4a1IqGdWpVYmZFRERERORC2YwxxtWZkKqTlZVFaGgomZmZ6o/uKTZ+C5/dRn50B5rvehRjYNFjvYgLD3R1zkRERETEgyk2cD9q4i7i7or7n+92RGIMdGkYruBcRERERKQaUhN3EXfiKILcTMjNgH3rYOdC2PQdAMszrbeawzrWc2EGRURERESksihAF3EHaWso+mg49pw0bJza68Rh92VGVgt8vewMaBPjggyKiIiIiEhlU4Au4mIHs45x/P0xxOXuLd131Phx0Dua0Fa9CWvVm1e31mXZkoP0bxlJaKCPC3MrIiIiIiKVRQG6iIs4HIbPVqSw4/vXeJLNZJlAbiz6BzsL61CAN+RB0FpvXmrWjs+S1gMwtIOat4uIiIiIVFcK0EVcYPO+bJ78eh3Ju5KZ7/cx2CCrx1/5se9ocguK2JeZy2PT1/J78mHu+WgVAKEBPlzVvK6Lcy4iIiIiIpVFo7iLVKHj+UVMmL2JgZMXsWLXEf7P7xNCbMcw0e2of82fAfD38aJhnVp8NKYro3smlJ47qF0Mft5ersq6iIiIiIhUMtWgi1SRnzel89TMJFKPHAdgXMJ+hqYtBGzYBr0C9vLBt4+XnacGtaJjfG1mJu5h7JWNXZBrERERERGpKgrQRSrZ/qxcnv12Pd+v2wdAvbAAnh3UjD6/3Ggl6DQK6nc+4/kD28UwsJ1GbhcRERERqe4UoItUoqXbDzHmgxXk5BXiZbcxumcCD/RuSq0V/4EDGyEwAno/7epsioiIiIiIG1CALlJJsnMLeOjzRHLyCrkkLox/DmtLq9gQyNwDCyZYia55DgLDXZtRERERERFxCwrQRSrJ+NmbSMvMJT48kI/HdCXQt/if25zHoeAoxHWD9n9wbSZFRERERMRtaBR3qfGKHAaHwzj1mku2HeTjZbsB+NcN7cqC861zYcNMsHnBwIlg1z9BERERERGxqAZdapwD2Xm8Nm8LOw4cJeXIMdIycvHzttMqNoTWsaG0Ll43jQrCx+v8A+ijeYU89uVaAG7rFk/3xhHWgYJc+P4Ra7vrWIhu46xbEhERERGRakAButQ4z83awLdr9pbbV5hfxPLkIyxPPlK6z9fLTvPoYNrUC6FVbChtYkNoGROCv8/Z5yJ/8YdNpB45Tr2wAP7Wv2XZgcWvwZGdEBwDV/3NqfckIiIiIiKeTwG61ChrUjL4ds1ebDZ47rrWNI8OIS48gOzcQpL2ZLJ+bxZJezLZsDeL7LxC1u3JZN2eTCAFALsNmkQG0To2lA7xYdzcOa5cwL5sxyHeX7oLgAk3tCXIr/if2OEdsGiitd33BfAPqcrbFhERERERD6AAXWoMYwz//H4jAMM61OP27g1Lj8WEQrOoYK7vaP3tcBhSjhwrDdjX781i/d5MDubks2V/Dlv25/D16j3M25jO23d0xsfLzvH8otKm7cMvjePypnVLPhi+fwyK8qDRVdD6+iq8axERERER8RQK0KXGmL8pnWU7D+PrbeeRa5ufNa3dbqNBRC0aRNRiQNsYwArw07PzSCquVX/rlx38suUAf/tyHS/f1I6JP25m16FjRIf488TAE5q2b5oF234CL18YMBFstsq8TRERERER8VAK0KVGKCxyMGH2JgD+eFkCsWEB530Nm81GVIg/USH+9G4ZRbv6oYz5YCVfrkolr7CI79alATD++raE+PtYJ+XlwOzi/uY97oc6TZxyPyIiIiIiUv0oQJdqqbDIwX8WbGd/Vi5Bft4cyMlja3oOtQN9uLdXY6d8xtUtohg/rC2PfbmWWWut4Pz6jvXo1SKyLNHy/0FWKoTFw+UPO+VzRURERESkelKALtXStN92MemnLafs//PVTctqt53g5kvj2JeVy6SftlA32I+nB7Uqn2Ddl9b68ofBN9BpnysiIiIiItWPAnSpdg5k5zHpRys4H9ahHnWCfDmaX0RELV9u797AOR9iDBw9AEGR/PnqJnRuWJvGdYMIC/QtS3NwG+xfB3ZvaHmdcz5XRERERESqLQXoUu3864dNZOcV0qZeCC/f1B4vu5MHZXMUwVdjIOlL6PN3bD3/Qo/GdU5Nt+Fra93oKggMd24eRERERESk2rG7OgMizrRy1xGmr0wF4LkhbZwfnBsD3z1kBecAc5+F7fNPn3b9DGvdaqhz8yAiIiIiItWSatDF7X29OpW3F+0kxN+HOsF+RNTypU6QL3WC/IgI8ivdrl3Ll2e+SQLgpk716Rhf2/mZmf88rHwPsEF8d9i9BL68C/60EELrl6U7sAX2J1nN21sMdH4+RERERESk2lGALm5tW3oOf/tyHXmFjgqfE+zvzV/7t3B+Zpb8GxZNtLYHvQLtb4V3r4W0NfD5HXDnbPAu7oO+YYa1btRLzdtFRERERKRCFKCL2yoscvDwF2vIK3RwWZMIbu4cx8GcfA7m5HEoJ4+DOfml6wM5eeQXB/FPDGhJnSA/52Ym8RP48Ulru/fT0PlOa/vmD+CtK2DPCvj2fhj8Gnj7lTVvbz3MufkQEREREZFqSwG6uK23Fu5gTUoGIf7eTLzpEqJD/c+Y1hjD0fwicguKnB+cb54NM8dZ293vg54PlR2r3RCu/x98fAus+QQOboFeT0L6erD7QIsBzs2LiIiIiIhUWwrQxS1kHMtn6uJk6gb70a5+KMbAq3OtqdKeHdL6rME5gM1mI8jPmyA/J/8nnbwYvhgFpgja/wGueR5sJw0816wv/OEz+Opu2LMSPrze2t+4FwRUQj94ERERERGplhSgi8sVFjm458NVLN1x6JRjfVtHMfSSei7IFZC2Fj4ZDoW50HwAXDcF7GeY+KBZX2uguM9HQlqitU/N20VERERE5DxomjVxuQmzN7F0xyFq+XpxedM6hAX6ABAZ7McLw9piO7nGuioc2m7VhOdlQYPL4MZ3wesc77NqN4A/zrGawTfrB62GVE1eRURERESkWlANurjUzMQ9vP3rTgAm3tyefm1iMMaQeuQ4If4+hBYH61UqKw2mDYWjByCqLdz6CfgEVOxcH3/o+0KlZk9ERERERKonBejiMuv3ZvLXL9cCMK5XY/q1iQGs/uRx4YGuydTxI1bNecZuCG8Et38F/qGuyYuIiIiIiNQoauIuLpGVW8Cfpq0kt8DBlc3q8tA1zV2dJcg/ao3Gnr4BgqLh9q8hKNLVuRIRERERkRpCAbq4RLCfN7d1a0BCnVpMHt4BL3sV9DM3BjJTYdtcWDUNMveUHSvMtwZ4S1lm1Zjf/rU1hZqIiIiIiEgVURN3cQmbzcbYKxszqkdD/H28Kv8Dfx4PS1+H/Oyyfd7+1oBul90Psx6yAnefQBgxHaJaVX6eRERERERETqAAXVyqSoLzwztg4YtgHGD3hvDG4OUL+9fBopdh6b+tqdTs3nDzNIjrUvl5EhEREREROYkCdKn+fn3VCs4bXw23fgbevlZz903fwU9Pw+HtgA2GvQVN+7g6tyIiIiIiUkMpQJfqLXMPJH5sbV/xmBWcA9hs0HIQNOsLSV9CrTrQRMG5iIiIiIi4jgJ0qd6WTAFHATS4DBp0P/W4lw+0H171+RIRERERETmJRnGX6qMwD3YssKZLAzh6EFa+Z21f/rCrciUiIiIiIlIhqkGX6qHgOHx0EyQvAv8w6DQK8rKg8DjEXGL1PxcREREREXFjCtDF8xUVwBd3WsE5QG4GLH617PgVj1h9zkVERERERNyYmriLZ3M4YMY9sGW2Na/5Hd/C8E+g4eXW8dgO0Hyga/MoIiIiIiJSAapBF89lDHz/CKz7ongO8w8g4QrrWIsBkJECAbXBrvdQIiIiIiLi/hSgi+ea/zyseIfSOcyb9S1/PCzOJdkSERERERG5EKpaFM/066uwaKK1PWgStL3RpdkRERERERG5WArQxfOsmApzn7G2+zwLnf/o2vyIiIiIiIg4gQJ08SxJX8Ksv1jbPf8CPR90aXZEREREREScRQG6eI4tP8JXdwPGqjXv/YyrcyQiIiIiIuI0CtDFPRTmw+qP4Njh0x9PXgyf3w6OQmh7EwyYqLnNRURERESkWlGALu5hyWSYeS98fIs1t/mJ9iZa+wtzoVk/GPqGpk4TEREREZFqR1GOuJ7DAaunWdupvxdPnVbs6EH49A+Qnw0NL4eb3gMvH5dkU0REREREpDIpQBfX270EjiSX/T33WcjcA44i+PIuyNoDEU1h+MfgE+CybIqIiIiIiFQmb1dnQITEj631JbfBwc2Quhy+fxSi28COn8EnEG6ZBv4hrs2niIiIiIhIJVKALq6VlwPrZ1jbHW8Hv2B46wrY/J21AAx+DSJbuiyLIiIiIiIiVUFN3MW1NsyAgqMQ0QTiukJUa7jswbLjnUdDu5tdlTsREREREZEqoxp0ca3VH1nrS/5QNm3aFY/C3lXg7Q/9xrsubyIiIiIiIlVIAbq4zqHt1gBxNju0G16238cfbv/adfkSERERERFxATVxF9dZ84m1btQLQuu5Ni8iIiIiIiIupgBdXMNRBInFAXqHEa7Ni4iIiIiIiBtQgC6uYQxc+xy0HAzNB7o6NyIiIiIiIi6nPujiGl7e0OYGaxERERERERHVoIuIiIiIiIi4AwXoIiIiIiIiIm5AAbqIiIiIiIiIG1CALiIiIiIiIuIGFKCLiIiIiIiIuAEF6CIiIiIiIiJuQAF6FVm4cCGDBw8mNjYWm83GjBkzyh03xvD0008TExNDQEAAffr0YevWreXSHD58mBEjRhASEkJYWBijR48mJyenCu9CREREREREKosC9Cpy9OhR2rdvz+uvv37a4y+++CKTJ0/mzTffZNmyZdSqVYu+ffuSm5tbmmbEiBGsX7+en376iVmzZrFw4ULuvvvuqroFERERERERqUQ2Y4xxdSZqGpvNxtdff83QoUMBq/Y8NjaWhx9+mEceeQSAzMxMoqKieO+99xg+fDgbN26kVatWLF++nM6dOwPwww8/MGDAAFJTU4mNja3QZ2dlZREaGkpmZiYhISGVcn8iIiIiIuL+FBu4H9Wgu4GdO3eyb98++vTpU7ovNDSUrl27snTpUgCWLl1KWFhYaXAO0KdPH+x2O8uWLavyPIuIiIiIiIhzebs6AwL79u0DICoqqtz+qKio0mP79u0jMjKy3HFvb2/Cw8NL05xOXl4eeXl5pX9nZWU5K9siIiIiIiLiRKpBr+bGjx9PaGho6RIXF+fqLImIiIiIiMhpKEB3A9HR0QDs37+/3P79+/eXHouOjiY9Pb3c8cLCQg4fPlya5nQef/xxMjMzS5eUlBQn515EREREREScQQG6G0hISCA6Opp58+aV7svKymLZsmV0794dgO7du5ORkcHKlStL08yfPx+Hw0HXrl3PeG0/Pz9CQkLKLSIiIiIiIuJ+1Ae9iuTk5LBt27bSv3fu3EliYiLh4eHEx8fz4IMP8o9//IOmTZuSkJDAU089RWxsbOlI7y1btqRfv36MGTOGN998k4KCAu677z6GDx9e4RHcwRoxHtQXXURERESkpiuJCTSxlxsxUiV+/vlnA5yy3HHHHcYYYxwOh3nqqadMVFSU8fPzM7179zabN28ud41Dhw6ZW2+91QQFBZmQkBBz5513muzs7PPKR0pKymnzoUWLFi1atGjRokWLlpq5pKSkOCvskYukedBrGIfDwd69ewkODsZms1X652VlZREXF0dKSoqa17splZFr6Lm7P5WR+1GZuDeVj3tSubg3V5ePMYbs7GxiY2Ox29X72R2oiXsNY7fbqV+/fpV/rvq/uz+VkWvoubs/lZH7UZm4N5WPe1K5uDdXlk9oaKhLPldOT69JRERERERERNyAAnQRERERERERN6AAXSqVn58fzzzzDH5+fq7OipyBysg19Nzdn8rI/ahM3JvKxz2pXNybykdOpkHiRERERERERNyAatBFRERERERE3IACdBERERERERE3oABdRERERERExA0oQBcRERERERFxAwrQa6jx48dz6aWXEhwcTGRkJEOHDmXz5s3l0uTm5jJu3DgiIiIICgrihhtuYP/+/aXH16xZw6233kpcXBwBAQG0bNmS1157rdw1fv31Vy677DIiIiIICAigRYsWvPLKK+fMnzGGp59+mpiYGAICAujTpw9bt24tl+aFF16gR48eBAYGEhYWduEPww15evkkJyczevRoEhISCAgIoHHjxjzzzDPk5+df5JOpfJ7+7AGuu+464uPj8ff3JyYmhttvv529e/dexFNxH9WhfErk5eVxySWXYLPZSExMPP+H4SaqQ5k0bNgQm81WbpkwYcJFPBX3Uh3KCOC7776ja9euBAQEULt2bYYOHXphD8QNeHqZLFiw4JR/MyXL8uXLL/LpuJ6nlw/Ali1bGDJkCHXq1CEkJISePXvy888/X8RTkSpjpEbq27evmTp1qklKSjKJiYlmwIABJj4+3uTk5JSmGTt2rImLizPz5s0zK1asMN26dTM9evQoPf7OO++Y+++/3yxYsMBs377dTJs2zQQEBJgpU6aUplm1apX5+OOPTVJSktm5c6eZNm2aCQwMNG+99dZZ8zdhwgQTGhpqZsyYYdasWWOuu+46k5CQYI4fP16a5umnnzaTJk0yDz30kAkNDXXew3EDnl4+s2fPNqNGjTJz5swx27dvNzNnzjSRkZHm4YcfdvKTcj5Pf/bGGDNp0iSzdOlSk5ycbBYvXmy6d+9uunfv7sSn5DrVoXxK3H///aZ///4GMKtXr774h+Mi1aFMGjRoYJ577jmTlpZWupyYf09XHcpo+vTppnbt2uaNN94wmzdvNuvXrzefffaZE59S1fL0MsnLyyv37yUtLc3cddddJiEhwTgcDic/rarn6eVjjDFNmzY1AwYMMGvWrDFbtmwx9957rwkMDDRpaWlOfFJSGRSgizHGmPT0dAOYX375xRhjTEZGhvHx8TFffPFFaZqNGzcawCxduvSM17n33ntNr169zvpZw4YNM7fddtsZjzscDhMdHW1eeuml0n0ZGRnGz8/PfPLJJ6eknzp1arUL0E/myeVT4sUXXzQJCQln/Wx3VB2e/cyZM43NZjP5+fln/XxP5Knl8/3335sWLVqY9evXe3yAfjJPLJMGDRqYV1555Vy3Vm14WhkVFBSYevXqmbfffrtC9+eJPK1MTpafn2/q1q1rnnvuubN+tqfytPI5cOCAAczChQtL02RlZRnA/PTTT2e/WXE5NXEXADIzMwEIDw8HYOXKlRQUFNCnT5/SNC1atCA+Pp6lS5ee9Tol1zid1atXs2TJEq688sozptm5cyf79u0r99mhoaF07dr1rJ9dnVWH8jnXZ7srT3/2hw8f5qOPPqJHjx74+Pic8dqeyhPLZ//+/YwZM4Zp06YRGBh47pv0MJ5YJgATJkwgIiKCDh068NJLL1FYWHj2G/VgnlZGq1atYs+ePdjtdjp06EBMTAz9+/cnKSmpYjfsATytTE72zTffcOjQIe68884zXteTeVr5RERE0Lx5cz744AOOHj1KYWEhb731FpGRkXTq1KliNy0u4+3qDIjrORwOHnzwQS677DLatGkDwL59+/D19T2lb3dUVBT79u077XWWLFnCZ599xnfffXfKsfr163PgwAEKCwv5+9//zl133XXG/JRcPyoqqsKfXZ1Vh/LZtm0bU6ZM4eWXXz7jdd2RJz/7v/71r/z73//m2LFjdOvWjVmzZp3zfj2NJ5aPMYZRo0YxduxYOnfuTHJyckVv1yN4YpkA3H///XTs2JHw8HCWLFnC448/TlpaGpMmTarQfXsSTyyjHTt2APD3v/+dSZMm0bBhQyZOnMhVV13Fli1bPPLl74k8sUxO9s4779C3b1/q169/xut6Kk8sH5vNxty5cxk6dCjBwcHY7XYiIyP54YcfqF27doXvXVxDNejCuHHjSEpK4tNPP73gayQlJTFkyBCeeeYZrr322lOOL1q0iBUrVvDmm2/y6quv8sknnwDw0UcfERQUVLosWrTogvNQXXl6+ezZs4d+/fpx0003MWbMmAu+B1fw5Gf/6KOPsnr1an788Ue8vLwYOXIkxpgLvg935InlM2XKFLKzs3n88ccvOM/uzBPLBOChhx7iqquuol27dowdO5aJEycyZcoU8vLyLvg+3JUnlpHD4QDgySef5IYbbqBTp05MnToVm83GF198ccH34S48sUxOlJqaypw5cxg9evQF59+deWL5GGMYN24ckZGRLFq0iN9//52hQ4cyePBg0tLSLvg+pIq4uIm9uNi4ceNM/fr1zY4dO8rtnzdvngHMkSNHyu2Pj483kyZNKrdv/fr1JjIy0jzxxBMV+sznn3/eNGvWzBhj9YfZunVr6XLs2DGzffv20/bJvOKKK8z9999/yvWqcx90Ty+fPXv2mKZNm5rbb7/dFBUVVejz3YWnP/sTpaSkGMAsWbKkQvnwBJ5aPkOGDDF2u914eXmVLoDx8vIyI0eOPI8n4H48tUxOJykpyQBm06ZNFcqHp/DUMpo/f74BzKJFi8ql6dKlS4Xz4a48tUxO9Nxzz5m6detWy3FOPLV85s6da+x2u8nMzCyXpkmTJmb8+PEVyoe4jgL0GsrhcJhx48aZ2NhYs2XLllOOlwx+MX369NJ9mzZtOmXwi6SkJBMZGWkeffTRCn/2s88+axo0aHDWvEVHR5uXX365dF9mZmaNGiSuOpRPamqqadq0qRk+fLgpLCys8Oe7WnV49ifbtWuXAczPP/9c4by4K08vn127dpl169aVLnPmzDGAmT59uklJSalwXtyJp5fJ6Xz44YfGbrebw4cPVzgv7szTy6jk7xMHicvPzzeRkZHnHO3aXXl6mZyYNiEhwSNmaTkfnl4+33zzjbHb7SY7O7vcuc2aNTMvvPBChfMirqEAvYa65557TGhoqFmwYEG5KTKOHTtWmmbs2LEmPj7ezJ8/36xYseKUqZrWrVtn6tata2677bZy10hPTy9N8+9//9t88803ZsuWLWbLli3m7bffNsHBwebJJ588a/4mTJhgwsLCzMyZM83atWvNkCFDTpk+YteuXWb16tXm2WefNUFBQWb16tVm9erVp3wZeSJPL5/U1FTTpEkT07t3b5Oamlru892dpz/73377zUyZMsWsXr3aJCcnm3nz5pkePXqYxo0bm9zcXCc/rarn6eVzsp07d3r8KO6eXiZLliwxr7zyiklMTDTbt283H374oalbt67Ht2g4kaeXkTHGPPDAA6ZevXpmzpw5ZtOmTWb06NEmMjLSY1+iVIcyMcaqqQXMxo0bnfRk3IOnl8+BAwdMRESEuf76601iYqLZvHmzeeSRR4yPj49JTEx08tMSZ1OAXkMBp12mTp1amub48ePm3nvvNbVr1zaBgYFm2LBh5QKsZ5555rTXOPGt3+TJk03r1q1NYGCgCQkJMR06dDD/+c9/ztnc2eFwmKeeespERUUZPz8/07t3b7N58+Zyae64447Tfn51qCX09PKZOnXqGe/B3Xn6s1+7dq3p1auXCQ8PN35+fqZhw4Zm7NixJjU11WnPyJU8vXxOVh0CdE8vk5UrV5quXbua0NBQ4+/vb1q2bGn++c9/VosXWiU8vYyMsWrMH374YRMZGWmCg4NNnz59TFJSklOejytUhzIxxphbb7213Nzf1UV1KJ/ly5eba6+91oSHh5vg4GDTrVs38/333zvl+UjlshlTzUYNEhEREREREfFAGsVdRERERERExA0oQBcRERERERFxAwrQRURERERERNyAAnQRERERERERN6AAXURERERERMQNKEAXERERERERcQMK0EVERERERETcgAJ0ERERERERETegAF1ERMRDjRo1CpvNhs1mw8fHh6ioKK655hreffddHA5Hha/z3nvvERYWVnkZFRERkQpRgC4iIuLB+vXrR1paGsnJycyePZtevXrxwAMPMGjQIAoLC12dPRERETkPCtBFREQ8mJ+fH9HR0dSrV4+OHTvyxBNPMHPmTGbPns17770HwKRJk2jbti21atUiLi6Oe++9l5ycHAAWLFjAnXfeSWZmZmlt/N///ncA8vLyeOSRR6hXrx61atWia9euLFiwwDU3KiIiUgMoQBcREalmrr76atq3b89XX30FgN1uZ/Lkyaxfv57333+f+fPn89hjjwHQo0cPXn31VUJCQkhLSyMtLY1HHnkEgPvuu4+lS5fy6aefsnbtWm666Sb69evH1q1bXXZvIiIi1ZnNGGNcnQkRERE5f6NGjSIjI4MZM2accmz48OGsXbuWDRs2nHJs+vTpjB07loMHDwJWH/QHH3yQjIyM0jS7d++mUaNG7N69m9jY2NL9ffr0oUuXLvzzn/90+v2IiIjUdN6uzoCIiIg4nzEGm80GwNy5cxk/fjybNm0iKyuLwsJCcnNzOXbsGIGBgac9f926dRQVFdGsWbNy+/Py8oiIiKj0/IuIiNRECtBFRESqoY0bN5KQkEBycjKDBg3innvu4YUXXiA8PJxff/2V0aNHk5+ff8YAPScnBy8vL1auXImXl1e5Y0FBQVVxCyIiIjWOAnQREZFqZv78+axbt46//OUvrFy5EofDwcSJE7HbraFnPv/883LpfX19KSoqKrevQ4cOFBUVkZ6ezuWXX15leRcREanJFKCLiIh4sLy8PPbt20dRURH79+/nhx9+YPz48QwaNIiRI0eSlJREQUEBU6ZMYfDgwSxevJg333yz3DUaNmxITk4O8+bNo3379gQGBtKsWTNGjBjByJEjmThxIh06dODAgQPMmzePdu3aMXDgQBfdsYiISPWlUdxFREQ82A8//EBMTAwNGzakX79+/Pzzz0yePJmZM2fi5eVF+/btmTRpEv/6179o06YNH330EePHjy93jR49ejB27FhuueUW6taty4svvgjA1KlTGTlyJA8//DDNmzdn6NChLF++nPj4eFfcqoiISLWnUdxFRERERERE3IBq0EVERERERETcgAJ0ERERERERETegAF1ERERERETEDShAFxEREREREXEDCtBFRERERERE3IACdBERERERERE3oABdRERERERExA0oQBcRERERERFxAwrQRURERERERNyAAnQRERERERERN6AAXURERERERMQNKEAXERERERERcQMK0EVERERERETcgAJ0ERERERERETfw/0V9GGlhPNOWAAAAAElFTkSuQmCC",
       "text/plain": [
        "<IPython.core.display.Image object>"
       ]
@@ -348,6 +491,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -367,7 +511,7 @@
     "from typing import Dict, Union\n",
     "from IPython import get_ipython\n",
     "\n",
-    "class IPythonUserProxyAgent(UserProxyAgent):\n",
+    "class IPythonUserProxyAgent(autogen.UserProxyAgent):\n",
     "    def __init__(self, name: str, **kwargs):\n",
     "        super().__init__(name, **kwargs)\n",
     "        self._ipython = get_ipython()\n",
@@ -377,8 +521,11 @@
     "If you suggest code, the code will be executed in IPython.\"\"\"\n",
     "\n",
     "    def run_code(self, code, **kwargs):\n",
-    "        result = self._ipython.run_cell(code)\n",
-    "        log = str(result.result)\n",
+    "        result = self._ipython.run_cell(\"%%capture --no-display cap\\n\" + code)\n",
+    "        log = self._ipython.ev(\"cap.stdout\")\n",
+    "        log += self._ipython.ev(\"cap.stderr\")\n",
+    "        if result.result is not None:\n",
+    "            log += str(result.result)\n",
     "        exitcode = 0 if result.success else 1\n",
     "        if result.error_before_exec is not None:\n",
     "            log += f\"\\n{result.error_before_exec}\"\n",
@@ -386,10 +533,11 @@
     "        if result.error_in_exec is not None:\n",
     "            log += f\"\\n{result.error_in_exec}\"\n",
     "            exitcode = 1\n",
-    "        return exitcode, bytes(log, \"utf-8\"), None"
+    "        return exitcode, log, None"
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -410,90 +558,73 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "ipython_user_proxy (to assistant):\n",
+      "\u001b[33mipython_user_proxy\u001b[0m (to assistant):\n",
       "\n",
       "Plot a chart of META and TESLA stock price change YTD\n",
       "If you suggest code, the code will be executed in IPython.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "assistant (to ipython_user_proxy):\n",
+      "\u001b[33massistant\u001b[0m (to ipython_user_proxy):\n",
       "\n",
-      "Sure, we can use the `yfinance` library in Python to download the stock price data and `matplotlib` to plot the data. If you don't have `yfinance` installed, you can install it using pip:\n",
+      "To plot a chart of META (Facebook) and TESLA stock price change YTD, you can use the `yfinance` library to fetch the stock data and `matplotlib` to plot the chart. First, you need to install the `yfinance` library if you haven't already:\n",
       "\n",
-      "```python\n",
-      "!pip install yfinance\n",
+      "```sh\n",
+      "pip install yfinance\n",
       "```\n",
       "\n",
-      "Here is the Python code to plot the YTD stock price change for META (Facebook) and TESLA.\n",
+      "Now, you can execute the following Python code to plot the chart:\n",
       "\n",
       "```python\n",
-      "# Python code\n",
       "import yfinance as yf\n",
       "import matplotlib.pyplot as plt\n",
-      "from datetime import datetime\n",
+      "import datetime\n",
+      "\n",
+      "# Get the current date\n",
+      "today = datetime.date.today()\n",
       "\n",
-      "# Define the ticker symbol\n",
-      "tickerSymbols = ['META', 'TSLA']\n",
+      "# Calculate the start date for YTD\n",
+      "start_date = datetime.date(today.year, 1, 1)\n",
       "\n",
-      "# Get data on this ticker\n",
-      "start_date = datetime(datetime.now().year, 1, 1)\n",
-      "end_date = datetime.now()\n",
+      "# Download stock data for META (Facebook) and TESLA\n",
+      "meta_data = yf.download('FB', start=start_date, end=today)\n",
+      "tesla_data = yf.download('TSLA', start=start_date, end=today)\n",
       "\n",
-      "# Fetch the data\n",
-      "data = yf.download(tickerSymbols, start=start_date, end=end_date)\n",
+      "# Calculate the percentage change in stock prices\n",
+      "meta_pct_change = meta_data['Close'].pct_change().cumsum() * 100\n",
+      "tesla_pct_change = tesla_data['Close'].pct_change().cumsum() * 100\n",
       "\n",
-      "# Plot the close prices\n",
-      "plt.figure(figsize=(14,7))\n",
-      "plt.plot(data['Close'])\n",
-      "plt.title('YTD Stock Price Change for META and TESLA')\n",
+      "# Plot the chart\n",
+      "plt.figure(figsize=(12, 6))\n",
+      "plt.plot(meta_pct_change, label='META (Facebook)')\n",
+      "plt.plot(tesla_pct_change, label='TESLA')\n",
       "plt.xlabel('Date')\n",
-      "plt.ylabel('Price (USD)')\n",
-      "plt.legend(tickerSymbols)\n",
-      "plt.grid(True)\n",
+      "plt.ylabel('Percentage Change YTD')\n",
+      "plt.title('META (Facebook) vs TESLA Stock Price Change YTD')\n",
+      "plt.legend()\n",
+      "plt.grid()\n",
       "plt.show()\n",
       "```\n",
       "\n",
-      "This code will plot the closing prices of META and TESLA stocks from the start of this year to the current date. The prices are in USD.\n",
+      "This code will fetch the stock data for META (Facebook) and TESLA, calculate the percentage change in stock prices YTD, and plot the chart.\n",
       "\n",
-      "--------------------------------------------------------------------------------\n"
+      "--------------------------------------------------------------------------------\n",
+      "\u001b[31m\n",
+      ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is sh)...\u001b[0m\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Defaulting to user installation because normal site-packages is not writeable\n",
-      "Requirement already satisfied: yfinance in /home/vscode/.local/lib/python3.9/site-packages (0.2.26)\n",
-      "Requirement already satisfied: pandas>=1.3.0 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2.0.3)\n",
-      "Requirement already satisfied: numpy>=1.16.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.25.1)\n",
-      "Requirement already satisfied: multitasking>=0.0.7 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (0.0.11)\n",
-      "Requirement already satisfied: frozendict>=2.3.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2.3.8)\n",
-      "Requirement already satisfied: requests>=2.31 in /usr/local/lib/python3.9/site-packages (from yfinance) (2.31.0)\n",
-      "Requirement already satisfied: html5lib>=1.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.1)\n",
-      "Requirement already satisfied: appdirs>=1.4.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.4.4)\n",
-      "Requirement already satisfied: lxml>=4.9.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.9.3)\n",
-      "Requirement already satisfied: pytz>=2022.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2023.3)\n",
-      "Requirement already satisfied: beautifulsoup4>=4.11.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.12.2)\n",
-      "Requirement already satisfied: soupsieve>1.2 in /home/vscode/.local/lib/python3.9/site-packages (from beautifulsoup4>=4.11.1->yfinance) (2.4.1)\n",
-      "Requirement already satisfied: six>=1.9 in /usr/local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (1.16.0)\n",
-      "Requirement already satisfied: webencodings in /home/vscode/.local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (0.5.1)\n",
-      "Requirement already satisfied: python-dateutil>=2.8.2 in /home/vscode/.local/lib/python3.9/site-packages (from pandas>=1.3.0->yfinance) (2.8.2)\n",
-      "Requirement already satisfied: tzdata>=2022.1 in /home/vscode/.local/lib/python3.9/site-packages (from pandas>=1.3.0->yfinance) (2023.3)\n",
-      "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2023.5.7)\n",
-      "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2.0.3)\n",
-      "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.4)\n",
-      "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.2.0)\n",
-      "\n",
-      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.0.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m23.2.1\u001b[0m\n",
-      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n",
-      "[*********************100%***********************]  2 of 2 completed\n"
+      "\u001b[31m\n",
+      ">>>>>>>> EXECUTING CODE BLOCK 1 (inferred language is python)...\u001b[0m\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 1400x700 with 1 Axes>"
+       "<Figure size 1200x600 with 1 Axes>"
       ]
      },
      "metadata": {},
@@ -503,61 +634,90 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "ipython_user_proxy (to assistant):\n",
+      "\u001b[33mipython_user_proxy\u001b[0m (to assistant):\n",
       "\n",
       "exitcode: 0 (execution succeeded)\n",
       "Code output: \n",
-      "None\n",
-      "None\n",
+      "Defaulting to user installation because normal site-packages is not writeable\n",
+      "Requirement already satisfied: yfinance in /home/vscode/.local/lib/python3.9/site-packages (0.2.26)\n",
+      "Requirement already satisfied: multitasking>=0.0.7 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (0.0.11)\n",
+      "Requirement already satisfied: numpy>=1.16.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.25.1)\n",
+      "Requirement already satisfied: beautifulsoup4>=4.11.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.12.2)\n",
+      "Requirement already satisfied: lxml>=4.9.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.9.3)\n",
+      "Requirement already satisfied: pandas>=1.3.0 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.3.3)\n",
+      "Requirement already satisfied: requests>=2.31 in /usr/local/lib/python3.9/site-packages (from yfinance) (2.31.0)\n",
+      "Requirement already satisfied: pytz>=2022.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2023.3)\n",
+      "Requirement already satisfied: html5lib>=1.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.1)\n",
+      "Requirement already satisfied: frozendict>=2.3.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2.3.8)\n",
+      "Requirement already satisfied: appdirs>=1.4.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.4.4)\n",
+      "Requirement already satisfied: soupsieve>1.2 in /home/vscode/.local/lib/python3.9/site-packages (from beautifulsoup4>=4.11.1->yfinance) (2.4.1)\n",
+      "Requirement already satisfied: webencodings in /home/vscode/.local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (0.5.1)\n",
+      "Requirement already satisfied: six>=1.9 in /usr/local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (1.16.0)\n",
+      "Requirement already satisfied: python-dateutil>=2.7.3 in /home/vscode/.local/lib/python3.9/site-packages (from pandas>=1.3.0->yfinance) (2.8.2)\n",
+      "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2023.5.7)\n",
+      "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.4)\n",
+      "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.2.0)\n",
+      "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2.0.3)\n",
       "\n",
-      "--------------------------------------------------------------------------------\n",
-      "assistant (to ipython_user_proxy):\n",
+      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.0.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m23.2.1\u001b[0m\n",
+      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n",
+      "Note: you may need to restart the kernel to use updated packages.\n",
+      "\n",
+      "[*********************100%***********************]  1 of 1 completed\n",
+      "[*********************100%***********************]  1 of 1 completed\n",
+      "\n",
+      "1 Failed download:\n",
+      "['FB']: Exception('%ticker%: No timezone found, symbol may be delisted')\n",
       "\n",
-      "It seems like the code executed successfully but didn't produce any output. This could be due to the fact that the IPython environment you're using might not support matplotlib's interactive mode. \n",
       "\n",
-      "Let's try a different approach using pandas' built-in plotting function, which should work in any environment. \n",
+      "--------------------------------------------------------------------------------\n",
+      "\u001b[33massistant\u001b[0m (to ipython_user_proxy):\n",
+      "\n",
+      "I apologize for the issue. It seems that the stock symbol for Meta Platforms (formerly Facebook) has changed from 'FB' to 'META'. Let's update the code with the correct stock symbol and try again:\n",
       "\n",
       "```python\n",
-      "# Python code\n",
       "import yfinance as yf\n",
-      "import pandas as pd\n",
-      "from datetime import datetime\n",
+      "import matplotlib.pyplot as plt\n",
+      "import datetime\n",
       "\n",
-      "# Define the ticker symbol\n",
-      "tickerSymbols = ['META', 'TSLA']\n",
+      "# Get the current date\n",
+      "today = datetime.date.today()\n",
       "\n",
-      "# Get data on this ticker\n",
-      "start_date = datetime(datetime.now().year, 1, 1)\n",
-      "end_date = datetime.now()\n",
+      "# Calculate the start date for YTD\n",
+      "start_date = datetime.date(today.year, 1, 1)\n",
       "\n",
-      "# Fetch the data\n",
-      "data = yf.download(tickerSymbols, start=start_date, end=end_date)\n",
+      "# Download stock data for META (Facebook) and TESLA\n",
+      "meta_data = yf.download('META', start=start_date, end=today)\n",
+      "tesla_data = yf.download('TSLA', start=start_date, end=today)\n",
       "\n",
-      "# Plot the close prices\n",
-      "data['Close'].plot(title='YTD Stock Price Change for META and TESLA', figsize=(14,7), grid=True)\n",
+      "# Calculate the percentage change in stock prices\n",
+      "meta_pct_change = meta_data['Close'].pct_change().cumsum() * 100\n",
+      "tesla_pct_change = tesla_data['Close'].pct_change().cumsum() * 100\n",
+      "\n",
+      "# Plot the chart\n",
+      "plt.figure(figsize=(12, 6))\n",
+      "plt.plot(meta_pct_change, label='META (Facebook)')\n",
+      "plt.plot(tesla_pct_change, label='TESLA')\n",
+      "plt.xlabel('Date')\n",
+      "plt.ylabel('Percentage Change YTD')\n",
+      "plt.title('META (Facebook) vs TESLA Stock Price Change YTD')\n",
+      "plt.legend()\n",
+      "plt.grid()\n",
+      "plt.show()\n",
       "```\n",
       "\n",
-      "This code does the same thing as the previous one, but uses pandas' built-in plot function instead of matplotlib. The plot should appear directly in your IPython environment.\n",
+      "This code should now fetch the stock data for META (Facebook) and TESLA, calculate the percentage change in stock prices YTD, and plot the chart.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "[*********************100%***********************]  2 of 2 completed\n"
+      "\u001b[31m\n",
+      ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n"
      ]
     },
     {
      "data": {
+      "image/png": "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",
       "text/plain": [
-       "<Axes: title={'center': 'YTD Stock Price Change for META and TESLA'}, xlabel='Date'>"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1400x700 with 1 Axes>"
+       "<Figure size 1200x600 with 1 Axes>"
       ]
      },
      "metadata": {},
@@ -567,20 +727,18 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "ipython_user_proxy (to assistant):\n",
+      "\u001b[33mipython_user_proxy\u001b[0m (to assistant):\n",
       "\n",
       "exitcode: 0 (execution succeeded)\n",
       "Code output: \n",
-      "Axes(0.125,0.2;0.775x0.68)\n",
-      "\n",
-      "--------------------------------------------------------------------------------\n",
-      "assistant (to ipython_user_proxy):\n",
+      "[*********************100%***********************]  1 of 1 completed\n",
+      "[*********************100%***********************]  1 of 1 completed\n",
       "\n",
-      "Great! The code executed successfully. The output `Axes(0.125,0.2;0.775x0.68)` is just a representation of the plot object. The actual plot should be displayed in your IPython environment. \n",
       "\n",
-      "The plot should show the YTD stock price change for META and TESLA. The x-axis represents the date and the y-axis represents the closing price in USD. \n",
+      "--------------------------------------------------------------------------------\n",
+      "\u001b[33massistant\u001b[0m (to ipython_user_proxy):\n",
       "\n",
-      "If you can see the plot and it meets your requirements, then we are done here. \n",
+      "I'm glad the code executed successfully and you were able to plot the chart of META (Facebook) and TESLA stock price change YTD. If you have any further questions or need assistance with anything else, please feel free to ask.\n",
       "\n",
       "TERMINATE\n",
       "\n",
diff --git a/notebook/autogen_agentchat_function_call.ipynb b/notebook/autogen_agentchat_function_call.ipynb
index 964879af8e..c9d8f3fde5 100644
--- a/notebook/autogen_agentchat_function_call.ipynb
+++ b/notebook/autogen_agentchat_function_call.ipynb
@@ -66,9 +66,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from flaml import oai\n",
+    "from flaml import autogen\n",
     "\n",
-    "config_list = oai.config_list_from_models(model_list=[\"gpt-4\", \"gpt-3.5-turbo\", \"gpt-3.5-turbo-16k\"], exclude=\"aoai\")"
+    "config_list = autogen.config_list_from_models(model_list=[\"gpt-4\", \"gpt-3.5-turbo\", \"gpt-3.5-turbo-16k\"], exclude=\"aoai\")"
    ]
   },
   {
@@ -117,14 +117,14 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "user_proxy (to chatbot):\n",
+      "\u001b[33muser_proxy\u001b[0m (to chatbot):\n",
       "\n",
       "Draw two agents chatting with each other with an example dialog. Don't add plt.show().\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "chatbot (to user_proxy):\n",
+      "\u001b[33mchatbot\u001b[0m (to user_proxy):\n",
       "\n",
-      "***** Suggested function Call: python *****\n",
+      "\u001b[32m***** Suggested function Call: python *****\u001b[0m\n",
       "Arguments: \n",
       "{\n",
       "  \"cell\": \"\n",
@@ -156,27 +156,29 @@
       "plt.axis('off')\n",
       "\"\n",
       "}\n",
-      "*******************************************\n",
+      "\u001b[32m*******************************************\u001b[0m\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "user_proxy (to chatbot):\n",
+      "\u001b[33muser_proxy\u001b[0m (to chatbot):\n",
       "\n",
-      "***** Response from calling function \"python\" *****\n",
+      "\u001b[32m***** Response from calling function \"python\" *****\u001b[0m\n",
       "Error: Invalid \\escape: line 1 column 785 (char 784)\n",
       " You argument should follow json format.\n",
-      "***************************************************\n",
+      "\u001b[32m***************************************************\u001b[0m\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "chatbot (to user_proxy):\n",
+      "\u001b[33mchatbot\u001b[0m (to user_proxy):\n",
       "\n",
-      "***** Suggested function Call: python *****\n",
+      "\u001b[32m***** Suggested function Call: python *****\u001b[0m\n",
       "Arguments: \n",
       "{\n",
       "  \"cell\": \"import matplotlib.pyplot as plt\\nimport matplotlib.patches as mpatches\\n\\n# Define basic parameters\\nface_color = '#FFDDC1'\\nplt.figure(figsize=(10, 2))\\n\\n# Agent 1\\nagent1 = mpatches.FancyBboxPatch((0.02, 0.4), 0.2, 0.6, boxstyle=mpatches.BoxStyle('Round', pad=0.02))\\nplt.gca().add_artist(agent1)\\nplt.gca().text(0.12, 0.7, 'Agent 1', ha='center', va='center', fontsize=12, color='blue')\\n\\n# Agent 2\\nagent2 = mpatches.FancyBboxPatch((0.45, 0.4), 0.2, 0.6, boxstyle=mpatches.BoxStyle('Round', pad=0.02))\\nplt.gca().add_artist(agent2)\\nplt.gca().text(0.55, 0.7, 'Agent 2', ha='center', va='center', fontsize=12, color='red')\\n\\n# Dialog\\nplt.gca().text(0.12, 0.35, '\\\"Hello, how are you?\\\"', ha='center', va='center', fontsize=10)\\nplt.gca().text(0.55, 0.15, '\\\"I\\\\'m fine, thank you!\\\"', ha='center', va='center', fontsize=10)\\n\\n# Descriptions\\nplt.gca().text(0.12, 0.15, 'Greeting', ha='center', va='center', fontsize=10)\\nplt.gca().text(0.55, 0.35, 'Response', ha='center', va='center', fontsize=10)\\n\\nplt.axis('off')\"\n",
       "}\n",
-      "*******************************************\n",
+      "\u001b[32m*******************************************\u001b[0m\n",
       "\n",
-      "--------------------------------------------------------------------------------\n"
+      "--------------------------------------------------------------------------------\n",
+      "\u001b[35m\n",
+      ">>>>>>>> EXECUTING FUNCTION python...\u001b[0m\n"
      ]
     },
     {
@@ -203,14 +205,14 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "user_proxy (to chatbot):\n",
+      "\u001b[33muser_proxy\u001b[0m (to chatbot):\n",
       "\n",
-      "***** Response from calling function \"python\" *****\n",
+      "\u001b[32m***** Response from calling function \"python\" *****\u001b[0m\n",
       "(0.0, 1.0, 0.0, 1.0)\n",
-      "***************************************************\n",
+      "\u001b[32m***************************************************\u001b[0m\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "chatbot (to user_proxy):\n",
+      "\u001b[33mchatbot\u001b[0m (to user_proxy):\n",
       "\n",
       "TERMINATE\n",
       "\n",
@@ -219,9 +221,7 @@
     }
    ],
    "source": [
-    "from flaml.autogen.agentchat import AssistantAgent, UserProxyAgent\n",
-    "\n",
-    "oai_config = {\n",
+    "llm_config = {\n",
     "    \"functions\": [\n",
     "        {\n",
     "            \"name\": \"python\",\n",
@@ -255,14 +255,14 @@
     "    \"config_list\": config_list,\n",
     "    \"request_timeout\": 120,\n",
     "}\n",
-    "chatbot = AssistantAgent(\n",
+    "chatbot = autogen.AssistantAgent(\n",
     "    name=\"chatbot\",\n",
     "    system_message=\"For coding tasks, only use the functions you have been provided with. Reply TERMINATE when the task is done.\",\n",
-    "    oai_config=oai_config,\n",
+    "    llm_config=llm_config,\n",
     ")\n",
     "\n",
     "# create a UserProxyAgent instance named \"user_proxy\"\n",
-    "user_proxy = UserProxyAgent(\n",
+    "user_proxy = autogen.UserProxyAgent(\n",
     "    name=\"user_proxy\",\n",
     "    is_termination_msg=lambda x: x.get(\"content\", \"\") and x.get(\"content\", \"\").rstrip().endswith(\"TERMINATE\"),\n",
     "    human_input_mode=\"NEVER\",\n",
@@ -314,7 +314,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 4,
    "id": "4a917492",
    "metadata": {},
    "outputs": [
@@ -322,45 +322,47 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "user_proxy (to chatbot):\n",
+      "\u001b[33muser_proxy\u001b[0m (to chatbot):\n",
       "\n",
       "Problem: Find all $x$ that satisfy the inequality $(2x+10)(x+3)<(3x+9)(x+8)$. Express your answer in interval notation.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "chatbot (to user_proxy):\n",
+      "\u001b[33mchatbot\u001b[0m (to user_proxy):\n",
       "\n",
-      "***** Suggested function Call: query_wolfram *****\n",
+      "\u001b[32m***** Suggested function Call: query_wolfram *****\u001b[0m\n",
       "Arguments: \n",
       "{\n",
       "  \"query\": \"solve (2x+10)(x+3)<(3x+9)(x+8) for x\"\n",
       "}\n",
-      "**************************************************\n",
+      "\u001b[32m**************************************************\u001b[0m\n",
       "\n",
-      "--------------------------------------------------------------------------------\n"
+      "--------------------------------------------------------------------------------\n",
+      "\u001b[35m\n",
+      ">>>>>>>> EXECUTING FUNCTION query_wolfram...\u001b[0m\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "user_proxy (to chatbot):\n",
+      "\u001b[33muser_proxy\u001b[0m (to chatbot):\n",
       "\n",
-      "***** Response from calling function \"query_wolfram\" *****\n",
+      "\u001b[32m***** Response from calling function \"query_wolfram\" *****\u001b[0m\n",
       "('Assumption: solve (2 x + 10) (x + 3)<(3 x + 9) (x + 8) for x \\nAnswer: ans 0: x<-14\\nans 1: x>-3\\n', True)\n",
-      "**********************************************************\n",
+      "\u001b[32m**********************************************************\u001b[0m\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "chatbot (to user_proxy):\n",
+      "\u001b[33mchatbot\u001b[0m (to user_proxy):\n",
       "\n",
       "The solution to the inequality $(2x+10)(x+3)<(3x+9)(x+8)$ is $x \\in (-\\infty, -14) \\cup (-3, +\\infty)$. TERMINATE\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "user_proxy (to chatbot):\n",
+      "\u001b[33muser_proxy\u001b[0m (to chatbot):\n",
       "\n",
       "\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "chatbot (to user_proxy):\n",
+      "\u001b[33mchatbot\u001b[0m (to user_proxy):\n",
       "\n",
       "TERMINATE\n",
       "\n",
@@ -370,14 +372,13 @@
    ],
    "source": [
     "import os\n",
-    "from flaml.autogen.agentchat import AssistantAgent, UserProxyAgent\n",
     "from flaml.autogen.agentchat.contrib.math_user_proxy_agent import MathUserProxyAgent\n",
     "\n",
     "# you need to provide a wolfram alpha appid to run this example\n",
     "if not os.environ.get(\"WOLFRAM_ALPHA_APPID\"):\n",
     "    os.environ[\"WOLFRAM_ALPHA_APPID\"] = open(\"wolfram.txt\").read().strip()\n",
     "\n",
-    "oai_config = {\n",
+    "llm_config = {\n",
     "    \"model\": \"gpt-4-0613\",\n",
     "    \"functions\": [\n",
     "        {\n",
@@ -397,15 +398,15 @@
     "    ],\n",
     "    \"config_list\": config_list,\n",
     "}\n",
-    "chatbot = AssistantAgent(\n",
+    "chatbot = autogen.AssistantAgent(\n",
     "    name=\"chatbot\",\n",
     "    system_message=\"Only use the functions you have been provided with. Do not ask user to perform other actions than executing the functions. Reply TERMINATE when the task is done.\",\n",
-    "    oai_config=oai_config,\n",
+    "    llm_config=llm_config,\n",
     ")\n",
     "\n",
     "# the key in `function_map` should match the function name in \"functions\" above\n",
     "# we register a class instance method directly\n",
-    "user_proxy = UserProxyAgent(\n",
+    "user_proxy = autogen.UserProxyAgent(\n",
     "    \"user_proxy\",\n",
     "    max_consecutive_auto_reply=2,\n",
     "    human_input_mode=\"NEVER\",\n",
diff --git a/notebook/autogen_agentchat_human_feedback.ipynb b/notebook/autogen_agentchat_human_feedback.ipynb
index 1bf1fc8046..3d2a4e0122 100644
--- a/notebook/autogen_agentchat_human_feedback.ipynb
+++ b/notebook/autogen_agentchat_human_feedback.ipynb
@@ -64,9 +64,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from flaml import oai\n",
+    "from flaml import autogen\n",
     "\n",
-    "config_list = oai.config_list_from_json(\"OAI_CONFIG_LIST\")"
+    "config_list = autogen.config_list_from_json(\"OAI_CONFIG_LIST\")"
    ]
   },
   {
@@ -139,25 +139,23 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from flaml.autogen.agentchat import AssistantAgent, UserProxyAgent\n",
-    "\n",
     "# create an AssistantAgent instance named \"assistant\"\n",
-    "assistant = AssistantAgent(\n",
+    "assistant = autogen.AssistantAgent(\n",
     "    name=\"assistant\",\n",
-    "    oai_config={\n",
+    "    llm_config={\n",
     "        \"seed\": 41,\n",
     "        \"config_list\": config_list,\n",
     "    }\n",
     ")\n",
     "# create a UserProxyAgent instance named \"user_proxy\"\n",
-    "user_proxy = UserProxyAgent(\n",
+    "user_proxy = autogen.UserProxyAgent(\n",
     "    name=\"user_proxy\",\n",
     "    human_input_mode=\"ALWAYS\",\n",
     "    is_termination_msg=lambda x: x.get(\"content\", \"\").rstrip().endswith(\"TERMINATE\"),\n",
     ")\n",
     "\n",
     "# the purpose of the following line is to log the conversation history\n",
-    "oai.ChatCompletion.start_logging()\n"
+    "autogen.ChatCompletion.start_logging()\n"
    ]
   },
   {
@@ -380,7 +378,7 @@
     "\n",
     "The human user can provide feedback at each step. When the human user didn't provide feedback, the code was executed. The executed results and error messages are returned to the assistant, and the assistant was able to modify the code based on the feedback. In the end, the task is complete and a \"TERMINATE\" signal is sent from the assistant. The user skipped feedback in the end and the conversation is finished.\n",
     "\n",
-    "After the conversation is finished, we can save the log of the conversation between the two agents. The log can be accessed from `oai.ChatCompletion.logged_history`."
+    "After the conversation is finished, we can save the log of the conversation between the two agents. The log can be accessed from `autogen.ChatCompletion.logged_history`."
    ]
   },
   {
@@ -397,7 +395,7 @@
     }
    ],
    "source": [
-    "print(oai.ChatCompletion.logged_history)"
+    "print(autogen.ChatCompletion.logged_history)"
    ]
   },
   {
@@ -408,7 +406,7 @@
    "source": [
     "import json\n",
     "\n",
-    "json.dump(oai.ChatCompletion.logged_history, open(\"conversations.json\", \"w\"), indent=2)"
+    "json.dump(autogen.ChatCompletion.logged_history, open(\"conversations.json\", \"w\"), indent=2)"
    ]
   }
  ],
diff --git a/notebook/autogen_agentchat_planning.ipynb b/notebook/autogen_agentchat_planning.ipynb
index b50d33a217..647f1bac0a 100644
--- a/notebook/autogen_agentchat_planning.ipynb
+++ b/notebook/autogen_agentchat_planning.ipynb
@@ -25,9 +25,9 @@
     "\n",
     "## Requirements\n",
     "\n",
-    "FLAML requires `Python>=3.8`. To run this notebook example, please install flaml with the [autogen] option:\n",
+    "FLAML requires `Python>=3.8`. To run this notebook example, please install flaml with the [autogen] option and docker:\n",
     "```bash\n",
-    "pip install flaml[autogen]\n",
+    "pip install flaml[autogen] docker\n",
     "```"
    ]
   },
@@ -44,7 +44,7 @@
    },
    "outputs": [],
    "source": [
-    "# %pip install flaml[autogen]~=2.0.0rc4"
+    "# %pip install flaml[autogen]~=2.0.0rc4 docker"
    ]
   },
   {
@@ -69,9 +69,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from flaml import oai\n",
+    "from flaml import autogen\n",
     "\n",
-    "config_list = oai.config_list_from_json(\n",
+    "config_list = autogen.config_list_from_json(\n",
     "    \"OAI_CONFIG_LIST\",\n",
     "    filter_dict={\n",
     "        \"model\": [\"gpt-4\", \"gpt4\", \"gpt-4-32k\", \"gpt-4-32k-0314\"],\n",
@@ -123,15 +123,13 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from flaml.autogen.agentchat import AssistantAgent, UserProxyAgent\n",
-    "\n",
-    "planner = AssistantAgent(\n",
+    "planner = autogen.AssistantAgent(\n",
     "    name=\"planner\",\n",
-    "    oai_config={\"config_list\": config_list},\n",
+    "    llm_config={\"config_list\": config_list},\n",
     "    # the default system message of the AssistantAgent is overwritten here\n",
     "    system_message=\"You are a helpful AI assistant. You suggest coding and reasoning steps for another AI assistant to accomplish a task. Do not suggest concrete code. For any action beyond writing code or reasoning, convert it to a step which can be implemented by writing code. For example, the action of browsing the web can be implemented by writing code which reads and prints the content of a web page. Finally, inspect the execution result. If the plan is not good, suggest a better plan. If the execution is wrong, analyze the error and suggest a fix.\"\n",
     ")\n",
-    "planner_user = UserProxyAgent(\n",
+    "planner_user = autogen.UserProxyAgent(\n",
     "    name=\"planner_user\",\n",
     "    max_consecutive_auto_reply=0,  # terminate without auto-reply\n",
     "    human_input_mode=\"NEVER\",\n",
@@ -158,14 +156,14 @@
    "outputs": [],
    "source": [
     "# create an AssistantAgent instance named \"assistant\"\n",
-    "assistant = AssistantAgent(\n",
+    "assistant = autogen.AssistantAgent(\n",
     "    name=\"assistant\",\n",
-    "    oai_config={\n",
+    "    llm_config={\n",
     "        \"temperature\": 0,\n",
     "        \"request_timeout\": 600,\n",
     "        \"seed\": 42,\n",
     "        \"model\": \"gpt-4-0613\",\n",
-    "        \"config_list\": oai.config_list_openai_aoai(exclude=\"aoai\"),\n",
+    "        \"config_list\": autogen.config_list_openai_aoai(exclude=\"aoai\"),\n",
     "        \"functions\": [\n",
     "            {\n",
     "                \"name\": \"ask_planner\",\n",
@@ -186,7 +184,7 @@
     ")\n",
     "\n",
     "# create a UserProxyAgent instance named \"user_proxy\"\n",
-    "user_proxy = UserProxyAgent(\n",
+    "user_proxy = autogen.UserProxyAgent(\n",
     "    name=\"user_proxy\",\n",
     "    human_input_mode=\"TERMINATE\",\n",
     "    max_consecutive_auto_reply=10,\n",
@@ -215,12 +213,12 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "user_proxy (to assistant):\n",
+      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
       "\n",
       "Suggest a fix to an open good first issue of flaml\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "assistant (to user_proxy):\n",
+      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
       "\n",
       "To suggest a fix to an open good first issue of FLAML, we first need to fetch the list of open issues labeled as \"good first issue\" from the FLAML GitHub repository. We can do this using the GitHub API. Here is a Python script that fetches and prints the list of such issues.\n",
       "\n",
@@ -244,15 +242,17 @@
       "Please save this script as `fetch_issues.py` and run it. It will print the list of open issues labeled as \"good first issue\" in the FLAML repository.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "\n",
-      ">>>>>>>> USING AUTO REPLY...\n"
+      "\u001b[31m\n",
+      ">>>>>>>> USING AUTO REPLY...\u001b[0m\n",
+      "\u001b[31m\n",
+      ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "user_proxy (to assistant):\n",
+      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
       "\n",
       "exitcode: 0 (execution succeeded)\n",
       "Code output: \n",
@@ -278,19 +278,21 @@
       "\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "assistant (to user_proxy):\n",
+      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
       "\n",
-      "***** Suggested function Call: ask_planner *****\n",
+      "\u001b[32m***** Suggested function Call: ask_planner *****\u001b[0m\n",
       "Arguments: \n",
       "{\n",
       "  \"message\": \"Here are the open good first issues of FLAML: \\n\\nIssue #1120: use_label_encoder warning with xgboost\\nIssue #1034: Use appropriate wait time for retry based on the error message.\\nIssue #1029: Issues with Adding Custom APIs in Auto Generation\\nIssue #981: Running flaml[tune] using \\\"-O\\\" flag for python interpreter (optimization - disables assertions) crashes\\nIssue #903: Conditional parameter flow2 crash\\nIssue #884: indentation space\\nIssue #882: Check if openml version is required\\nIssue #834: Adjust the indent\\nIssue #821: pip install flaml FAIL\\nIssue #807: Isolate the ensemble part and expose it to users\\nIssue #805: how to pass categorical features names or indices to learner\\nIssue #785: Flaml/LightGBM - Shouldn't I found better/faster or equal results from FLAML than direct LightGBM?\\nIssue #764: Add an announcement of the discord channel\\nIssue #748: Documentation about small budget\\nIssue #737: Make zero-shot automl more discoverable\\nIssue #509: New HCrystalBall release\\nIssue #429: samples about conversion to ONNX\\nIssue #413: support anomaly detection\\nIssue #304: CatBoost Fails with Keyword 'groups'\\n\\nPlease suggest a fix for one of these issues.\"\n",
       "}\n",
-      "************************************************\n",
+      "\u001b[32m************************************************\u001b[0m\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "\n",
-      ">>>>>>>> USING AUTO REPLY...\n",
-      "planner_user (to planner):\n",
+      "\u001b[31m\n",
+      ">>>>>>>> USING AUTO REPLY...\u001b[0m\n",
+      "\u001b[35m\n",
+      ">>>>>>>> EXECUTING FUNCTION ask_planner...\u001b[0m\n",
+      "\u001b[33mplanner_user\u001b[0m (to planner):\n",
       "\n",
       "Here are the open good first issues of FLAML: \n",
       "\n",
@@ -317,7 +319,7 @@
       "Please suggest a fix for one of these issues.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "planner (to planner_user):\n",
+      "\u001b[33mplanner\u001b[0m (to planner_user):\n",
       "\n",
       "Without certain details about the issues, it's a bit challenging to suggest explicit fixes. However, I'll give you a roadmap to tackle some of these:\n",
       "\n",
@@ -354,9 +356,9 @@
       "Remember to thoroughly inspect the execution result for each issue to ensure your fix is effective. If the plan does not appear to fix the issue, adjust your plan based on the error message or unexpected behavior.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "user_proxy (to assistant):\n",
+      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
       "\n",
-      "***** Response from calling function \"ask_planner\" *****\n",
+      "\u001b[32m***** Response from calling function \"ask_planner\" *****\u001b[0m\n",
       "Without certain details about the issues, it's a bit challenging to suggest explicit fixes. However, I'll give you a roadmap to tackle some of these:\n",
       "\n",
       "1. **Issue #1120: use_label_encoder warning with xgboost**\n",
@@ -390,10 +392,10 @@
       "Plan: Inspect the current documentation and functionality. Update the documentation to clarify how to pass these features, and if the functionality is missing, implement the functionality.\n",
       "\n",
       "Remember to thoroughly inspect the execution result for each issue to ensure your fix is effective. If the plan does not appear to fix the issue, adjust your plan based on the error message or unexpected behavior.\n",
-      "********************************************************\n",
+      "\u001b[32m********************************************************\u001b[0m\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "assistant (to user_proxy):\n",
+      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
       "\n",
       "Based on the planner's suggestions, let's tackle the first issue: \"Issue #1120: use_label_encoder warning with xgboost\". \n",
       "\n",
@@ -414,20 +416,20 @@
       "TERMINATE\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "\n",
-      ">>>>>>>> USING AUTO REPLY...\n",
-      "user_proxy (to assistant):\n",
+      "\u001b[31m\n",
+      ">>>>>>>> USING AUTO REPLY...\u001b[0m\n",
+      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
       "\n",
       "\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "assistant (to user_proxy):\n",
+      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
       "\n",
       "TERMINATE\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "\n",
-      ">>>>>>>> NO HUMAN INPUT RECEIVED.\n"
+      "\u001b[31m\n",
+      ">>>>>>>> NO HUMAN INPUT RECEIVED.\u001b[0m\n"
      ]
     }
    ],
diff --git a/notebook/autogen_agentchat_two_users.ipynb b/notebook/autogen_agentchat_two_users.ipynb
index 781ddc124f..92f63d82ec 100644
--- a/notebook/autogen_agentchat_two_users.ipynb
+++ b/notebook/autogen_agentchat_two_users.ipynb
@@ -69,9 +69,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from flaml import oai\n",
+    "from flaml import autogen\n",
     "\n",
-    "config_list = oai.config_list_from_json(\n",
+    "config_list = autogen.config_list_from_json(\n",
     "    \"OAI_CONFIG_LIST\",\n",
     "    filter_dict={\n",
     "        \"model\": [\"gpt-4\", \"gpt4\", \"gpt-4-32k\", \"gpt-4-32k-0314\"],\n",
@@ -123,17 +123,15 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from flaml.autogen.agentchat import AssistantAgent, UserProxyAgent\n",
-    "\n",
     "def ask_expert(message):\n",
-    "    assistant_for_expert = AssistantAgent(\n",
+    "    assistant_for_expert = autogen.AssistantAgent(\n",
     "        name=\"assistant_for_expert\",\n",
-    "        oai_config={\n",
+    "        llm_config={\n",
     "            \"temperature\": 0,\n",
     "            \"config_list\": config_list,\n",
     "        },\n",
     "    )\n",
-    "    expert = UserProxyAgent(\n",
+    "    expert = autogen.UserProxyAgent(\n",
     "        name=\"expert\",\n",
     "        human_input_mode=\"ALWAYS\",\n",
     "        code_execution_config={\"work_dir\": \"expert\"},\n",
@@ -163,14 +161,14 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "assistant_for_student = AssistantAgent(\n",
+    "assistant_for_student = autogen.AssistantAgent(\n",
     "    name=\"assistant_for_student\",\n",
-    "    oai_config={\n",
+    "    llm_config={\n",
     "        \"request_timeout\": 600,\n",
     "        \"seed\": 42,\n",
     "        # Excluding azure openai endpoints from the config list.\n",
     "        # Change to `exclude=\"openai\"` to exclude openai endpoints, or remove the `exclude` argument to include both.\n",
-    "        \"config_list\": oai.config_list_openai_aoai(exclude=\"aoai\"),\n",
+    "        \"config_list\": autogen.config_list_openai_aoai(exclude=\"aoai\"),\n",
     "        \"model\": \"gpt-4-0613\",  # make sure the endpoint you use supports the model\n",
     "        \"temperature\": 0,\n",
     "        \"functions\": [\n",
@@ -192,7 +190,7 @@
     "    }\n",
     ")\n",
     "\n",
-    "student = UserProxyAgent(\n",
+    "student = autogen.UserProxyAgent(\n",
     "    name=\"student\",\n",
     "    human_input_mode=\"TERMINATE\",\n",
     "    max_consecutive_auto_reply=10,\n",
diff --git a/notebook/autogen_agentchat_web_info.ipynb b/notebook/autogen_agentchat_web_info.ipynb
index 079d507f43..75431c6571 100644
--- a/notebook/autogen_agentchat_web_info.ipynb
+++ b/notebook/autogen_agentchat_web_info.ipynb
@@ -30,7 +30,7 @@
     "\n",
     "## Requirements\n",
     "\n",
-    "FLAML requires `Python>=3.8`. To run this notebook example, please install flaml with the [autogen] option:\n",
+    "FLAML requires `Python>=3.8`. To run this notebook example, please install flaml with the [autogen] option and docker:\n",
     "```bash\n",
     "pip install flaml[autogen]\n",
     "```"
@@ -49,7 +49,7 @@
    },
    "outputs": [],
    "source": [
-    "# %pip install flaml[autogen]~=2.0.0rc4"
+    "# %pip install flaml[autogen]~=2.0.0rc4 docker"
    ]
   },
   {
@@ -68,14 +68,22 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from flaml import oai\n",
+    "from flaml import autogen\n",
     "\n",
-    "config_list = oai.config_list_from_json(\n",
+    "config_list = autogen.config_list_from_json(\n",
     "    \"OAI_CONFIG_LIST\",\n",
     "    filter_dict={\n",
     "        \"model\": [\"gpt4\", \"gpt-4-32k\", \"gpt-4-32k-0314\"],\n",
     "    },\n",
-    ")"
+    ")\n",
+    "\n",
+    "llm_config={\n",
+    "    \"request_timeout\": 600,\n",
+    "    \"seed\": 42,\n",
+    "    \"config_list\": config_list,\n",
+    "    \"model\": \"gpt-4-32k\",  # modify if the endpoint you use doesn't support this model\n",
+    "    \"temperature\": 0,\n",
+    "}"
    ]
   },
   {
@@ -130,26 +138,21 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from flaml.autogen.agentchat import AssistantAgent, UserProxyAgent\n",
-    "\n",
     "# create an AssistantAgent instance named \"assistant\"\n",
-    "assistant = AssistantAgent(\n",
+    "assistant = autogen.AssistantAgent(\n",
     "    name=\"assistant\",\n",
-    "    oai_config={\n",
-    "        \"request_timeout\": 600,\n",
-    "        \"seed\": 42,\n",
-    "        \"config_list\": config_list,\n",
-    "        \"model\": \"gpt-4-32k\",  # modify if the endpoint you use doesn't support this model\n",
-    "        \"temperature\": 0,\n",
-    "    }\n",
+    "    llm_config=llm_config,\n",
     ")\n",
     "# create a UserProxyAgent instance named \"user_proxy\"\n",
-    "user_proxy = UserProxyAgent(\n",
+    "user_proxy = autogen.UserProxyAgent(\n",
     "    name=\"user_proxy\",\n",
     "    human_input_mode=\"TERMINATE\",\n",
     "    max_consecutive_auto_reply=10,\n",
     "    is_termination_msg=lambda x: x.get(\"content\", \"\").rstrip().endswith(\"TERMINATE\"),\n",
     "    code_execution_config={\"work_dir\": \"web\"},\n",
+    "    llm_config=llm_config,\n",
+    "    system_message=\"\"\"Reply TERMINATE if the task has been solved at full satisfaction.\n",
+    "Otherwise, reply CONTINUE, or the reason why the task is not solved yet.\"\"\"\n",
     ")"
    ]
   },
@@ -172,14 +175,14 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "user_proxy (to assistant):\n",
+      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
       "\n",
       "\n",
       "Who should read this paper: https://arxiv.org/abs/2306.01337\n",
       "\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "assistant (to user_proxy):\n",
+      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
       "\n",
       "To determine who should read this paper, let's first extract the abstract and analyze its content. We can use Python with the `requests` and `BeautifulSoup` libraries to do this. Please execute the following code:\n",
       "\n",
@@ -197,15 +200,15 @@
       "After executing the code, I will analyze the abstract and suggest who should read the paper.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "\n",
-      ">>>>>>>> USING AUTO REPLY FOR THE USER...\n"
+      "\u001b[31m\n",
+      ">>>>>>>> USING AUTO REPLY...\u001b[0m\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "user_proxy (to assistant):\n",
+      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
       "\n",
       "exitcode: 0 (execution succeeded)\n",
       "Code output: \n",
@@ -223,7 +226,7 @@
       "\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "assistant (to user_proxy):\n",
+      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
       "\n",
       "Based on the abstract, the paper is about using Large Language Models (LLMs), specifically GPT-4, to solve complex mathematical problems. The authors propose a conversational problem-solving framework called MathChat and evaluate it on difficult high school competition problems from the MATH dataset.\n",
       "\n",
@@ -236,7 +239,9 @@
       "\n",
       "If you belong to any of these categories or have a general interest in AI and its applications, you might find this paper valuable. TERMINATE\n",
       "\n",
-      "--------------------------------------------------------------------------------\n"
+      "--------------------------------------------------------------------------------\n",
+      "\u001b[31m\n",
+      ">>>>>>>> NO HUMAN INPUT RECEIVED.\u001b[0m\n"
      ]
     }
    ],
@@ -267,12 +272,12 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "user_proxy (to assistant):\n",
+      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
       "\n",
       "Show me the YTD gain of 10 largest technology companies as of today.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "assistant (to user_proxy):\n",
+      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
       "\n",
       "To get the YTD gain of the 10 largest technology companies, we can use a Python script to fetch the data from a financial API like Yahoo Finance. Please execute the following Python code:\n",
       "\n",
@@ -310,9 +315,9 @@
       "This code will fetch the 10 largest technology companies from TradingView and then calculate their YTD gains using Yahoo Finance data.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "\n",
-      ">>>>>>>> USING AUTO REPLY FOR THE USER...\n",
-      "user_proxy (to assistant):\n",
+      "\u001b[31m\n",
+      ">>>>>>>> USING AUTO REPLY...\u001b[0m\n",
+      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
       "\n",
       "exitcode: 1 (execution failed)\n",
       "Code output: \n",
@@ -325,7 +330,7 @@
       "\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "assistant (to user_proxy):\n",
+      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
       "\n",
       "I apologize for the error. It seems that the website structure has changed, and the script is unable to find the table containing the top technology companies. Let's try an alternative approach using the Yahoo Finance library. Please install the library first by executing:\n",
       "\n",
@@ -360,32 +365,31 @@
       "This code uses a predefined list of the 10 largest technology companies and calculates their YTD gains using the Yahoo Finance library.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "\n",
-      ">>>>>>>> USING AUTO REPLY FOR THE USER...\n",
-      "user_proxy (to assistant):\n",
+      "\u001b[31m\n",
+      ">>>>>>>> USING AUTO REPLY...\u001b[0m\n",
+      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
       "\n",
       "exitcode: 1 (execution failed)\n",
       "Code output: \n",
       "Defaulting to user installation because normal site-packages is not writeable\n",
       "Requirement already satisfied: yfinance in /home/vscode/.local/lib/python3.9/site-packages (0.2.26)\n",
-      "Requirement already satisfied: lxml>=4.9.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.9.3)\n",
-      "Requirement already satisfied: pytz>=2022.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2023.3)\n",
       "Requirement already satisfied: numpy>=1.16.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.25.1)\n",
-      "Requirement already satisfied: html5lib>=1.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.1)\n",
+      "Requirement already satisfied: pandas>=1.3.0 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.3.3)\n",
       "Requirement already satisfied: beautifulsoup4>=4.11.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.12.2)\n",
-      "Requirement already satisfied: multitasking>=0.0.7 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (0.0.11)\n",
+      "Requirement already satisfied: html5lib>=1.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.1)\n",
+      "Requirement already satisfied: pytz>=2022.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2023.3)\n",
       "Requirement already satisfied: appdirs>=1.4.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.4.4)\n",
-      "Requirement already satisfied: pandas>=1.3.0 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2.0.3)\n",
+      "Requirement already satisfied: lxml>=4.9.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.9.3)\n",
       "Requirement already satisfied: requests>=2.31 in /usr/local/lib/python3.9/site-packages (from yfinance) (2.31.0)\n",
       "Requirement already satisfied: frozendict>=2.3.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2.3.8)\n",
+      "Requirement already satisfied: multitasking>=0.0.7 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (0.0.11)\n",
       "Requirement already satisfied: soupsieve>1.2 in /home/vscode/.local/lib/python3.9/site-packages (from beautifulsoup4>=4.11.1->yfinance) (2.4.1)\n",
       "Requirement already satisfied: six>=1.9 in /usr/local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (1.16.0)\n",
       "Requirement already satisfied: webencodings in /home/vscode/.local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (0.5.1)\n",
-      "Requirement already satisfied: python-dateutil>=2.8.2 in /home/vscode/.local/lib/python3.9/site-packages (from pandas>=1.3.0->yfinance) (2.8.2)\n",
-      "Requirement already satisfied: tzdata>=2022.1 in /home/vscode/.local/lib/python3.9/site-packages (from pandas>=1.3.0->yfinance) (2023.3)\n",
-      "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2.0.3)\n",
-      "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2023.5.7)\n",
+      "Requirement already satisfied: python-dateutil>=2.7.3 in /home/vscode/.local/lib/python3.9/site-packages (from pandas>=1.3.0->yfinance) (2.8.2)\n",
       "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.4)\n",
+      "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2023.5.7)\n",
+      "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2.0.3)\n",
       "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.2.0)\n",
       "\n",
       "FB: No timezone found, symbol may be delisted\n",
@@ -396,17 +400,17 @@
       "    ytd_gains = {symbol: get_ytd_gain(symbol) for symbol in top_tech_companies}\n",
       "  File \"/workspaces/FLAML/notebook/web/tmp_code_52c69e134e808cf8ba196ac60faede00.py\", line 13, in get_ytd_gain\n",
       "    ytd_gain = (data[\"Close\"].iloc[-1] - data[\"Close\"].iloc[0]) / data[\"Close\"].iloc[0] * 100\n",
-      "  File \"/home/vscode/.local/lib/python3.9/site-packages/pandas/core/indexing.py\", line 1103, in __getitem__\n",
+      "  File \"/home/vscode/.local/lib/python3.9/site-packages/pandas/core/indexing.py\", line 931, in __getitem__\n",
       "    return self._getitem_axis(maybe_callable, axis=axis)\n",
-      "  File \"/home/vscode/.local/lib/python3.9/site-packages/pandas/core/indexing.py\", line 1656, in _getitem_axis\n",
+      "  File \"/home/vscode/.local/lib/python3.9/site-packages/pandas/core/indexing.py\", line 1566, in _getitem_axis\n",
       "    self._validate_integer(key, axis)\n",
-      "  File \"/home/vscode/.local/lib/python3.9/site-packages/pandas/core/indexing.py\", line 1589, in _validate_integer\n",
+      "  File \"/home/vscode/.local/lib/python3.9/site-packages/pandas/core/indexing.py\", line 1500, in _validate_integer\n",
       "    raise IndexError(\"single positional indexer is out-of-bounds\")\n",
       "IndexError: single positional indexer is out-of-bounds\n",
       "\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "assistant (to user_proxy):\n",
+      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
       "\n",
       "I apologize for the error. It seems that there is an issue with the data for the \"FB\" symbol. Let's add a try-except block to handle this issue. Please execute the following Python code:\n",
       "\n",
@@ -439,83 +443,56 @@
       "        print(f\"{symbol}: Data not available\")\n",
       "```\n",
       "\n",
-      "This code will handle any issues with the data and display \"Data not available\" for any symbols that encounter an error.\n",
+      "This code adds error handling to the `get_ytd_gain` function, so if there is an issue with a specific symbol, it will print an error message and continue with the remaining symbols.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "\n",
-      ">>>>>>>> USING AUTO REPLY FOR THE USER...\n",
-      "user_proxy (to assistant):\n",
+      "\u001b[31m\n",
+      ">>>>>>>> USING AUTO REPLY...\u001b[0m\n",
+      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
       "\n",
       "exitcode: 0 (execution succeeded)\n",
       "Code output: \n",
       "Error fetching data for FB: single positional indexer is out-of-bounds\n",
-      "AAPL: 55.26%\n",
-      "MSFT: 47.19%\n",
-      "GOOGL: 37.13%\n",
-      "GOOG: 36.89%\n",
-      "AMZN: 50.47%\n",
+      "AAPL: 57.03%\n",
+      "MSFT: 41.90%\n",
+      "GOOGL: 48.77%\n",
+      "GOOG: 48.28%\n",
+      "AMZN: 54.06%\n",
       "FB: Data not available\n",
-      "TSLA: 145.40%\n",
-      "NVDA: 219.19%\n",
-      "ASML: 25.70%\n",
-      "ADBE: 55.92%\n",
-      "\n",
-      "\n",
-      "--------------------------------------------------------------------------------\n",
-      "assistant (to user_proxy):\n",
-      "\n",
-      "I'm glad the code executed successfully. Here are the YTD gains for the 10 largest technology companies as of today:\n",
-      "\n",
-      "- AAPL: 55.26%\n",
-      "- MSFT: 47.19%\n",
-      "- GOOGL: 37.13%\n",
-      "- GOOG: 36.89%\n",
-      "- AMZN: 50.47%\n",
-      "- FB: Data not available\n",
-      "- TSLA: 145.40%\n",
-      "- NVDA: 219.19%\n",
-      "- ASML: 25.70%\n",
-      "- ADBE: 55.92%\n",
-      "\n",
-      "Please note that the data for \"FB\" is not available due to an issue with the data source. You may want to check an alternative data source or try again later for the \"FB\" symbol.\n",
-      "\n",
-      "If you have any other questions or need further assistance, feel free to ask. Otherwise, if everything is done, please type \"TERMINATE\".\n",
+      "TSLA: 146.48%\n",
+      "NVDA: 226.67%\n",
+      "ASML: 31.38%\n",
+      "ADBE: 56.97%\n",
       "\n",
-      "--------------------------------------------------------------------------------\n",
-      "\n",
-      ">>>>>>>> USING AUTO REPLY FOR THE USER...\n",
-      "user_proxy (to assistant):\n",
-      "\n",
-      "\n",
-      "\n",
-      "--------------------------------------------------------------------------------\n",
-      "assistant (to user_proxy):\n",
-      "\n",
-      "It seems you didn't provide any input. If you have any other questions or need further assistance, feel free to ask. Otherwise, if everything is done, please type \"TERMINATE\".\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
+      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
       "\n",
-      ">>>>>>>> USING AUTO REPLY FOR THE USER...\n",
-      "user_proxy (to assistant):\n",
+      "I'm glad the code executed successfully. Here are the YTD gains for the 10 largest technology companies, except for Facebook (FB), for which data is not available:\n",
       "\n",
+      "- AAPL: 57.03%\n",
+      "- MSFT: 41.90%\n",
+      "- GOOGL: 48.77%\n",
+      "- GOOG: 48.28%\n",
+      "- AMZN: 54.06%\n",
+      "- TSLA: 146.48%\n",
+      "- NVDA: 226.67%\n",
+      "- ASML: 31.38%\n",
+      "- ADBE: 56.97%\n",
       "\n",
-      "\n",
-      "--------------------------------------------------------------------------------\n",
-      "assistant (to user_proxy):\n",
-      "\n",
-      "I understand that you might be busy or have no further questions. If you need any assistance in the future, feel free to ask. Have a great day!\n",
+      "Please note that these values are subject to change as the market fluctuates. If you need updated values, you can re-run the code.\n",
       "\n",
       "TERMINATE\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "user_proxy (to assistant):\n",
+      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
       "\n",
-      "FB -> META\n",
+      "FB->META\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "assistant (to user_proxy):\n",
+      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
       "\n",
-      "I apologize for the confusion earlier. The \"FB\" symbol has been changed to \"META\" due to the company's rebranding. Let's update the code with the new symbol and execute it again. Please run the following Python code:\n",
+      "I apologize for the confusion. Facebook has changed its stock symbol from \"FB\" to \"META\" due to the company's rebranding. Let's update the code with the new symbol and execute it again:\n",
       "\n",
       "```python\n",
       "import yfinance as yf\n",
@@ -546,72 +523,50 @@
       "        print(f\"{symbol}: Data not available\")\n",
       "```\n",
       "\n",
-      "This code will now use the \"META\" symbol instead of \"FB\" and should provide the YTD gain for Meta Platforms Inc. (formerly Facebook).\n",
+      "This code replaces \"FB\" with \"META\" in the list of top technology companies and calculates the YTD gains for the updated list.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "\n",
-      ">>>>>>>> USING AUTO REPLY FOR THE USER...\n",
-      "user_proxy (to assistant):\n",
+      "\u001b[31m\n",
+      ">>>>>>>> USING AUTO REPLY...\u001b[0m\n",
+      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
       "\n",
       "exitcode: 0 (execution succeeded)\n",
       "Code output: \n",
-      "AAPL: 55.26%\n",
-      "MSFT: 47.19%\n",
-      "GOOGL: 37.13%\n",
-      "GOOG: 36.89%\n",
-      "AMZN: 50.47%\n",
-      "META: 136.07%\n",
-      "TSLA: 145.40%\n",
-      "NVDA: 219.19%\n",
-      "ASML: 25.70%\n",
-      "ADBE: 55.92%\n",
-      "\n",
-      "\n",
-      "--------------------------------------------------------------------------------\n",
-      "assistant (to user_proxy):\n",
-      "\n",
-      "Great! The code executed successfully, and here are the updated YTD gains for the 10 largest technology companies as of today:\n",
-      "\n",
-      "- AAPL: 55.26%\n",
-      "- MSFT: 47.19%\n",
-      "- GOOGL: 37.13%\n",
-      "- GOOG: 36.89%\n",
-      "- AMZN: 50.47%\n",
-      "- META: 136.07% (formerly FB)\n",
-      "- TSLA: 145.40%\n",
-      "- NVDA: 219.19%\n",
-      "- ASML: 25.70%\n",
-      "- ADBE: 55.92%\n",
-      "\n",
-      "If you have any other questions or need further assistance, feel free to ask. Otherwise, if everything is done, please type \"TERMINATE\".\n",
-      "\n",
-      "--------------------------------------------------------------------------------\n",
-      "\n",
-      ">>>>>>>> USING AUTO REPLY FOR THE USER...\n",
-      "user_proxy (to assistant):\n",
-      "\n",
+      "AAPL: 57.03%\n",
+      "MSFT: 41.90%\n",
+      "GOOGL: 48.77%\n",
+      "GOOG: 48.28%\n",
+      "AMZN: 54.06%\n",
+      "META: 160.93%\n",
+      "TSLA: 146.48%\n",
+      "NVDA: 226.67%\n",
+      "ASML: 31.38%\n",
+      "ADBE: 56.97%\n",
       "\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "assistant (to user_proxy):\n",
+      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
       "\n",
-      "It seems you didn't provide any input. If you have any other questions or need further assistance, feel free to ask. Otherwise, if everything is done, please type \"TERMINATE\".\n",
+      "Great! The code executed successfully, and here are the updated YTD gains for the 10 largest technology companies, including Meta Platforms (formerly Facebook):\n",
       "\n",
-      "--------------------------------------------------------------------------------\n",
-      "\n",
-      ">>>>>>>> USING AUTO REPLY FOR THE USER...\n",
-      "user_proxy (to assistant):\n",
+      "- AAPL: 57.03%\n",
+      "- MSFT: 41.90%\n",
+      "- GOOGL: 48.77%\n",
+      "- GOOG: 48.28%\n",
+      "- AMZN: 54.06%\n",
+      "- META: 160.93%\n",
+      "- TSLA: 146.48%\n",
+      "- NVDA: 226.67%\n",
+      "- ASML: 31.38%\n",
+      "- ADBE: 56.97%\n",
       "\n",
-      "\n",
-      "\n",
-      "--------------------------------------------------------------------------------\n",
-      "assistant (to user_proxy):\n",
-      "\n",
-      "I understand that you might be busy or have no further questions. If you need any assistance in the future, feel free to ask. Have a great day!\n",
+      "Please note that these values are subject to change as the market fluctuates. If you need updated values, you can re-run the code.\n",
       "\n",
       "TERMINATE\n",
       "\n",
-      "--------------------------------------------------------------------------------\n"
+      "--------------------------------------------------------------------------------\n",
+      "\u001b[31m\n",
+      ">>>>>>>> NO HUMAN INPUT RECEIVED.\u001b[0m\n"
      ]
     }
    ],
diff --git a/notebook/autogen_chatgpt_gpt4.ipynb b/notebook/autogen_chatgpt_gpt4.ipynb
index 1417d795db..463c559301 100644
--- a/notebook/autogen_chatgpt_gpt4.ipynb
+++ b/notebook/autogen_chatgpt_gpt4.ipynb
@@ -31,7 +31,7 @@
     "\n",
     "## Requirements\n",
     "\n",
-    "FLAML requires `Python>=3.7`. To run this notebook example, please install flaml with the [openai,blendsearch] option:\n",
+    "FLAML requires `Python>=3.8`. To run this notebook example, please install flaml with the [openai,blendsearch] option:\n",
     "```bash\n",
     "pip install flaml[openai,blendsearch]\n",
     "```"
@@ -58,9 +58,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Import the oai and tune subpackages from flaml\n",
-    "\n",
-    "FLAML has provided an API for hyperparameter optimization of OpenAI ChatGPT models: `oai.ChatCompletion.tune` and to make a request with the tuned config: `oai.ChatCompletion.create`. First, we import oai from flaml:"
+    "FLAML has provided an API for hyperparameter optimization of OpenAI ChatGPT models: `autogen.ChatCompletion.tune` and to make a request with the tuned config: `autogen.ChatCompletion.create`. First, we import autogen from flaml:"
    ]
   },
   {
@@ -79,7 +77,7 @@
    },
    "outputs": [],
    "source": [
-    "from flaml import oai"
+    "from flaml import autogen"
    ]
   },
   {
@@ -111,7 +109,7 @@
    },
    "outputs": [],
    "source": [
-    "config_list = oai.config_list_openai_aoai()"
+    "config_list = autogen.config_list_openai_aoai()"
    ]
   },
   {
@@ -360,7 +358,7 @@
    },
    "outputs": [],
    "source": [
-    "oai.ChatCompletion.set_cache(seed)"
+    "autogen.ChatCompletion.set_cache(seed)"
    ]
   },
   {
@@ -443,7 +441,7 @@
     "import logging\n",
     "\n",
     "prompts = [\"{problem} Solve the problem carefully. Simplify your answer as much as possible. Put the final answer in \\\\boxed{{}}.\"]\n",
-    "config, analysis = oai.ChatCompletion.tune(\n",
+    "config, analysis = autogen.ChatCompletion.tune(\n",
     "    data=tune_data,  # the data for tuning\n",
     "    metric=\"success_vote\",  # the metric to optimize\n",
     "    mode=\"max\",  # the optimization mode\n",
@@ -952,8 +950,8 @@
     }
    ],
    "source": [
-    "response = oai.ChatCompletion.create(context=tune_data[1], config_list=config_list, **config)\n",
-    "metric_results = eval_math_responses(oai.ChatCompletion.extract_text(response), **tune_data[1])\n",
+    "response = autogen.ChatCompletion.create(context=tune_data[1], config_list=config_list, **config)\n",
+    "metric_results = eval_math_responses(autogen.ChatCompletion.extract_text(response), **tune_data[1])\n",
     "print(\"response on an example data instance:\", response)\n",
     "print(\"metric_results on the example data instance:\", metric_results)\n"
    ]
@@ -965,7 +963,7 @@
    "source": [
     "### Evaluate the success rate on the test data\n",
     "\n",
-    "You can use flaml's `oai.ChatCompletion.test` to evaluate the performance of an entire dataset with the tuned config. The following code will take a while (30 mins to 1 hour) to evaluate all the test data instances if uncommented and run. It will cost roughly $3. "
+    "You can use `autogen.ChatCompletion.test` to evaluate the performance of an entire dataset with the tuned config. The following code will take a while (30 mins to 1 hour) to evaluate all the test data instances if uncommented and run. It will cost roughly $3. "
    ]
   },
   {
@@ -1190,7 +1188,7 @@
     }
    ],
    "source": [
-    "# result = oai.ChatCompletion.test(test_data, logging_level=logging.INFO, config_list=config_list, **config)\n",
+    "# result = autogen.ChatCompletion.test(test_data, logging_level=logging.INFO, config_list=config_list, **config)\n",
     "# print(\"performance on test data with the tuned config:\", result)"
    ]
   },
@@ -1219,7 +1217,7 @@
     "# the following code will cost roughly $2 if uncommented and run.\n",
     "\n",
     "# default_config = {\"model\": 'gpt-4', \"prompt\": prompts[0]}\n",
-    "# default_result = oai.ChatCompletion.test(test_data, config_list=config_list, **default_config)\n",
+    "# default_result = autogen.ChatCompletion.test(test_data, config_list=config_list, **default_config)\n",
     "# print(\"performance on test data from gpt-4 with a default config:\", default_result)"
    ]
   },
@@ -1259,7 +1257,7 @@
     "# The following evaluation costs $3 and longer than one hour if you uncomment it and run it.\n",
     "\n",
     "# config_n2 = {\"model\": 'gpt-4', \"prompt\": prompts[0], \"n\": 2}\n",
-    "# result_n2 = oai.ChatCompletion.test(test_data, config_list=config_list, **config_n2)\n",
+    "# result_n2 = autogen.ChatCompletion.test(test_data, config_list=config_list, **config_n2)\n",
     "# print(\"performance on test data from gpt-4 with a default config and n=2:\", result_n2)\n"
    ]
   },
@@ -1280,7 +1278,7 @@
     "# The following evaluation costs $8 and longer than one hour if you uncomment it and run it.\n",
     "\n",
     "# config_n5 = {\"model\": 'gpt-4', \"prompt\": prompts[0], \"n\": 5}\n",
-    "# result_n5 = oai.ChatCompletion.test(test_data, config_list=config_list, **config_n5)\n",
+    "# result_n5 = autogen.ChatCompletion.test(test_data, config_list=config_list, **config_n5)\n",
     "# print(\"performance on test data from gpt-4 with a default config and n=5:\", result_n5)"
    ]
   },
diff --git a/notebook/autogen_openai_completion.ipynb b/notebook/autogen_openai_completion.ipynb
index a418db4e8f..225bb1fcc8 100644
--- a/notebook/autogen_openai_completion.ipynb
+++ b/notebook/autogen_openai_completion.ipynb
@@ -29,7 +29,7 @@
     "\n",
     "## Requirements\n",
     "\n",
-    "FLAML requires `Python>=3.7`. To run this notebook example, please install flaml with the [autogen,blendsearch] option:\n",
+    "FLAML requires `Python>=3.8`. To run this notebook example, please install flaml with the [autogen,blendsearch] option:\n",
     "```bash\n",
     "pip install flaml[autogen,blendsearch]\n",
     "```"
@@ -37,7 +37,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 1,
    "metadata": {
     "execution": {
      "iopub.execute_input": "2023-02-24T23:25:36.910966Z",
@@ -48,7 +48,7 @@
    },
    "outputs": [],
    "source": [
-    "# %pip install flaml[autogen,blendsearch] datasets"
+    "# %pip install flaml[autogen,blendsearch]~=2.0.0rc4 datasets"
    ]
   },
   {
@@ -69,7 +69,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 2,
    "metadata": {
     "execution": {
      "iopub.execute_input": "2023-02-24T23:25:36.917301Z",
@@ -80,9 +80,9 @@
    },
    "outputs": [],
    "source": [
-    "from flaml import oai\n",
+    "from flaml import autogen\n",
     "\n",
-    "endpoint_list = oai.config_list_openai_aoai()\n",
+    "endpoint_list = autogen.config_list_openai_aoai()\n",
     "# the endpoint_list looks like this:\n",
     "# endpoint_list = [\n",
     "#     {\n",
@@ -102,7 +102,7 @@
     "#     },  # another Azure OpenAI API endpoint for gpt-4\n",
     "# ]\n",
     "\n",
-    "config_list = oai.config_list_from_json(\n",
+    "config_list = autogen.config_list_from_json(\n",
     "    env_or_file=\"OAI_CONFIG_LIST\",\n",
     "    filter_dict={\n",
     "        \"model\": {\n",
@@ -151,7 +151,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 3,
    "metadata": {
     "execution": {
      "iopub.execute_input": "2023-02-24T23:25:36.931255Z",
@@ -171,7 +171,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "95bea2ebf248403aac1ee64e8bebd5e3",
+       "model_id": "8e08cc907707418a86a3da668e45326b",
        "version_major": 2,
        "version_minor": 0
       },
@@ -228,7 +228,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 4,
    "metadata": {
     "execution": {
      "iopub.execute_input": "2023-02-24T23:25:39.152156Z",
@@ -280,7 +280,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 5,
    "metadata": {
     "execution": {
      "iopub.execute_input": "2023-02-24T23:25:39.158398Z",
@@ -325,7 +325,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 6,
    "metadata": {
     "execution": {
      "iopub.execute_input": "2023-02-24T23:25:39.164187Z",
@@ -337,11 +337,10 @@
    "outputs": [],
    "source": [
     "from functools import partial\n",
-    "from flaml.autogen.code_utils import eval_function_completions, generate_assertions\n",
     "\n",
     "eval_with_generated_assertions = partial(\n",
-    "    eval_function_completions,\n",
-    "    assertions=partial(generate_assertions, config_list=config_list),\n",
+    "    autogen.code_utils.eval_function_completions,\n",
+    "    assertions=partial(autogen.code_utils.generate_assertions, config_list=config_list),\n",
     "    use_docker=False,\n",
     "    # Please set use_docker=True if you have docker available to run the generated code.\n",
     "    # Using docker is safer than running the generated code directly.\n",
@@ -361,16 +360,14 @@
     "\n",
     "## Use the tuning data to find a good configuration\n",
     "\n",
-    "### Import the oai and tune subpackages from flaml.\n",
-    "\n",
-    "FLAML has provided an API for hyperparameter optimization of OpenAI models: `oai.Completion.tune` and to make a request with the tuned config: `oai.Completion.create`.\n",
+    "FLAML has provided an API for hyperparameter optimization of OpenAI models: `autogen.Completion.tune` and to make a request with the tuned config: `autogen.Completion.create`.\n",
     "\n",
     "For (local) reproducibility and cost efficiency, we cache responses from OpenAI with a controllable seed."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 7,
    "metadata": {
     "execution": {
      "iopub.execute_input": "2023-02-24T23:25:40.587815Z",
@@ -384,7 +381,7 @@
    },
    "outputs": [],
    "source": [
-    "oai.Completion.set_cache(seed)"
+    "autogen.Completion.set_cache(seed)"
    ]
   },
   {
@@ -431,7 +428,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 8,
    "metadata": {
     "execution": {
      "iopub.execute_input": "2023-02-24T23:25:40.593603Z",
@@ -445,30 +442,30 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "\u001b[32m[I 2023-07-18 17:50:33,625]\u001b[0m A new study created in memory with name: optuna\u001b[0m\n",
-      "\u001b[32m[I 2023-07-18 17:50:33,628]\u001b[0m A new study created in memory with name: optuna\u001b[0m\n"
+      "\u001b[32m[I 2023-07-30 04:19:08,150]\u001b[0m A new study created in memory with name: optuna\u001b[0m\n",
+      "\u001b[32m[I 2023-07-30 04:19:08,153]\u001b[0m A new study created in memory with name: optuna\u001b[0m\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[flaml.tune.tune: 07-18 17:50:34] {805} INFO - trial 1 config: {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-ada-001', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}\n",
-      "[flaml.tune.tune: 07-18 17:51:28] {197} INFO - result: {'index_selected': 26.0, 'succeed_assertions': 0.0, 'success': 0.0, 'gen_cost': 0.0004240249999999999, 'assertions': 'assert vowels_count(\"abcde\") == 2\\nassert vowels_count(\"ACEDY\") == 3', 'total_cost': 0.0104828, 'cost': 0.0104828, 'inference_cost': 0.00023374, 'training_iteration': 0, 'config': {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-ada-001', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}, 'config/prompt': 1, 'config/stop': 0, 'config/subspace': {'model': 'text-ada-001', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}, 'experiment_tag': 'exp', 'time_total_s': 54.489821434020996}\n",
-      "[flaml.tune.tune: 07-18 17:51:28] {805} INFO - trial 2 config: {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-babbage-001', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}\n",
-      "[flaml.tune.tune: 07-18 17:52:11] {197} INFO - result: {'index_selected': 26.0, 'succeed_assertions': 0.0, 'success': 0.0, 'gen_cost': 0.0004240249999999999, 'assertions': 'assert vowels_count(\"abcde\") == 2\\nassert vowels_count(\"ACEDY\") == 3', 'total_cost': 0.030993300000000005, 'cost': 0.020510499999999997, 'inference_cost': 0.001025525, 'training_iteration': 0, 'config': {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-babbage-001', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}, 'config/prompt': 1, 'config/stop': 0, 'config/subspace': {'model': 'text-babbage-001', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}, 'experiment_tag': 'exp', 'time_total_s': 42.71049189567566}\n",
-      "[flaml.tune.tune: 07-18 17:52:11] {805} INFO - trial 3 config: {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-davinci-003', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}\n",
-      "[flaml.tune.tune: 07-18 17:54:24] {197} INFO - result: {'index_selected': 3.65, 'succeed_assertions': 0.9, 'success': 0.7, 'gen_cost': 0.0004240249999999999, 'assertions': 'assert vowels_count(\"abcde\") == 2\\nassert vowels_count(\"ACEDY\") == 3', 'total_cost': 0.8669533, 'cost': 0.83596, 'inference_cost': 0.041073000000000005, 'training_iteration': 0, 'config': {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-davinci-003', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}, 'config/prompt': 1, 'config/stop': 0, 'config/subspace': {'model': 'text-davinci-003', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}, 'experiment_tag': 'exp', 'time_total_s': 133.33429384231567}\n",
-      "[flaml.tune.tune: 07-18 17:54:24] {805} INFO - trial 4 config: {'prompt': 1, 'stop': 0, 'subspace': {'model': 'gpt-3.5-turbo', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}\n",
-      "[flaml.tune.tune: 07-18 17:55:48] {197} INFO - result: {'index_selected': 16.65, 'succeed_assertions': 0.4, 'success': 0.35, 'gen_cost': 0.0004240249999999999, 'assertions': 'assert vowels_count(\"abcde\") == 2\\nassert vowels_count(\"ACEDY\") == 3', 'total_cost': 0.9311253000000002, 'cost': 0.064172, 'inference_cost': 0.0031784499999999998, 'training_iteration': 0, 'config': {'prompt': 1, 'stop': 0, 'subspace': {'model': 'gpt-3.5-turbo', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}, 'config/prompt': 1, 'config/stop': 0, 'config/subspace': {'model': 'gpt-3.5-turbo', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}, 'experiment_tag': 'exp', 'time_total_s': 83.27373838424683}\n",
-      "[flaml.tune.tune: 07-18 17:55:48] {805} INFO - trial 5 config: {'prompt': 1, 'stop': 0, 'subspace': {'model': 'gpt-4', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}\n",
-      "[flaml.tune.tune: 07-18 17:56:06] {197} INFO - result: {'success': 0, 'total_cost': 1.0261653000000002, 'cost': 0.09504, 'training_iteration': 0, 'config': {'prompt': 1, 'stop': 0, 'subspace': {'model': 'gpt-4', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}, 'config/prompt': 1, 'config/stop': 0, 'config/subspace': {'model': 'gpt-4', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}, 'experiment_tag': 'exp', 'time_total_s': 18.89783787727356}\n",
-      "[flaml.tune.tune: 07-18 17:56:06] {828} WARNING - fail to sample a trial for 100 times in a row, stopping.\n"
+      "[flaml.tune.tune: 07-30 04:19:08] {805} INFO - trial 1 config: {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-ada-001', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}\n",
+      "[flaml.tune.tune: 07-30 04:22:35] {197} INFO - result: {'index_selected': 26.0, 'succeed_assertions': 0.0, 'success': 0.0, 'gen_cost': 0.000460625, 'assertions': 'assert vowels_count(\"abcde\") == 2\\nassert vowels_count(\"ACEDY\") == 3', 'total_cost': 0.010514800000000003, 'cost': 0.010514800000000003, 'inference_cost': 0.00023534000000000003, 'training_iteration': 0, 'config': {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-ada-001', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}, 'config/prompt': 1, 'config/stop': 0, 'config/subspace': {'model': 'text-ada-001', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}, 'experiment_tag': 'exp', 'time_total_s': 207.29033374786377}\n",
+      "[flaml.tune.tune: 07-30 04:22:35] {805} INFO - trial 2 config: {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-babbage-001', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}\n",
+      "[flaml.tune.tune: 07-30 04:23:18] {197} INFO - result: {'index_selected': 26.0, 'succeed_assertions': 0.0, 'success': 0.0, 'gen_cost': 0.000460625, 'assertions': 'assert vowels_count(\"abcde\") == 2\\nassert vowels_count(\"ACEDY\") == 3', 'total_cost': 0.0300243, 'cost': 0.019509500000000003, 'inference_cost': 0.0009754750000000001, 'training_iteration': 0, 'config': {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-babbage-001', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}, 'config/prompt': 1, 'config/stop': 0, 'config/subspace': {'model': 'text-babbage-001', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}, 'experiment_tag': 'exp', 'time_total_s': 42.417603969573975}\n",
+      "[flaml.tune.tune: 07-30 04:23:18] {805} INFO - trial 3 config: {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-davinci-003', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}\n",
+      "[flaml.tune.tune: 07-30 04:24:20] {197} INFO - result: {'index_selected': 2.35, 'succeed_assertions': 0.95, 'success': 0.65, 'gen_cost': 0.000460625, 'assertions': 'assert vowels_count(\"abcde\") == 2\\nassert vowels_count(\"ACEDY\") == 3', 'total_cost': 0.8658043000000002, 'cost': 0.8357800000000002, 'inference_cost': 0.04093000000000001, 'training_iteration': 0, 'config': {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-davinci-003', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}, 'config/prompt': 1, 'config/stop': 0, 'config/subspace': {'model': 'text-davinci-003', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}, 'experiment_tag': 'exp', 'time_total_s': 62.81497287750244}\n",
+      "[flaml.tune.tune: 07-30 04:24:20] {805} INFO - trial 4 config: {'prompt': 1, 'stop': 0, 'subspace': {'model': 'gpt-3.5-turbo', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}\n",
+      "[flaml.tune.tune: 07-30 04:25:39] {197} INFO - result: {'index_selected': 13.95, 'succeed_assertions': 0.55, 'success': 0.5, 'gen_cost': 0.000460625, 'assertions': 'assert vowels_count(\"abcde\") == 2\\nassert vowels_count(\"ACEDY\") == 3', 'total_cost': 0.9462703000000001, 'cost': 0.08046600000000001, 'inference_cost': 0.00399515, 'training_iteration': 0, 'config': {'prompt': 1, 'stop': 0, 'subspace': {'model': 'gpt-3.5-turbo', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}, 'config/prompt': 1, 'config/stop': 0, 'config/subspace': {'model': 'gpt-3.5-turbo', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}, 'experiment_tag': 'exp', 'time_total_s': 79.03474521636963}\n",
+      "[flaml.tune.tune: 07-30 04:25:39] {805} INFO - trial 5 config: {'prompt': 1, 'stop': 0, 'subspace': {'model': 'gpt-4', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}\n",
+      "[flaml.tune.tune: 07-30 04:25:50] {197} INFO - result: {'success': 0, 'total_cost': 1.0053703, 'cost': 0.0591, 'training_iteration': 0, 'config': {'prompt': 1, 'stop': 0, 'subspace': {'model': 'gpt-4', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}, 'config/prompt': 1, 'config/stop': 0, 'config/subspace': {'model': 'gpt-4', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}, 'experiment_tag': 'exp', 'time_total_s': 10.245523691177368}\n",
+      "[flaml.tune.tune: 07-30 04:25:50] {828} WARNING - fail to sample a trial for 100 times in a row, stopping.\n"
      ]
     }
    ],
    "source": [
-    "config, analysis = oai.Completion.tune(\n",
+    "config, analysis = autogen.Completion.tune(\n",
     "    data=tune_data,  # the data for tuning\n",
     "    metric=\"success\",  # the metric to optimize\n",
     "    mode=\"max\",  # the optimization mode\n",
@@ -496,12 +493,12 @@
    "source": [
     "### Output tuning results\n",
     "\n",
-    "After the tuning, we can print out the config and the result found by FLAML:"
+    "After the tuning, we can print out the config and the result found by autogen:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 9,
    "metadata": {
     "execution": {
      "iopub.execute_input": "2023-02-24T23:26:38.352710Z",
@@ -516,7 +513,7 @@
      "output_type": "stream",
      "text": [
       "optimized config {'prompt': '# Python 3{definition}', 'stop': ['\\nclass', '\\ndef', '\\nif', '\\nprint'], 'model': 'text-davinci-003', 'max_tokens': 148, 'n': 27, 'top_p': 0.755486898036596}\n",
-      "best result on tuning data {'index_selected': 3.65, 'succeed_assertions': 0.9, 'success': 0.7, 'gen_cost': 0.0004240249999999999, 'assertions': 'assert vowels_count(\"abcde\") == 2\\nassert vowels_count(\"ACEDY\") == 3', 'total_cost': 0.8669533, 'cost': 0.83596, 'inference_cost': 0.041073000000000005, 'training_iteration': 0, 'config': {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-davinci-003', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}, 'config/prompt': 1, 'config/stop': 0, 'config/subspace': {'model': 'text-davinci-003', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}, 'experiment_tag': 'exp', 'time_total_s': 133.33429384231567}\n"
+      "best result on tuning data {'index_selected': 2.35, 'succeed_assertions': 0.95, 'success': 0.65, 'gen_cost': 0.000460625, 'assertions': 'assert vowels_count(\"abcde\") == 2\\nassert vowels_count(\"ACEDY\") == 3', 'total_cost': 0.8658043000000002, 'cost': 0.8357800000000002, 'inference_cost': 0.04093000000000001, 'training_iteration': 0, 'config': {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-davinci-003', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}, 'config/prompt': 1, 'config/stop': 0, 'config/subspace': {'model': 'text-davinci-003', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}, 'experiment_tag': 'exp', 'time_total_s': 62.81497287750244}\n"
      ]
     }
    ],
@@ -541,7 +538,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 10,
    "metadata": {
     "execution": {
      "iopub.execute_input": "2023-02-24T23:26:38.359902Z",
@@ -560,37 +557,38 @@
      "output_type": "stream",
      "text": [
       "{\n",
-      "  \"id\": \"cmpl-7djA2WbYCudgjWodOG8aAHyEZ2lex\",\n",
+      "  \"id\": \"cmpl-7hsFhPX6faeWYaT4y3C7IkQAgNbZR\",\n",
+      "  \"warning\": \"This model version is deprecated. Migrate before January 4, 2024 to avoid disruption of service. Learn more https://platform.openai.com/docs/deprecations\",\n",
       "  \"object\": \"text_completion\",\n",
-      "  \"created\": 1689702746,\n",
+      "  \"created\": 1690691005,\n",
       "  \"model\": \"text-davinci-003\",\n",
       "  \"choices\": [\n",
       "    {\n",
-      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        result.append(abs(game[i]-guess[i]))\\n    return result\",\n",
+      "      \"text\": \"    results = []\\n    for i in range(len(game)):\\n        if game[i] == guess[i]:\\n            results.append(0)\\n        else:\\n            results.append(abs(game[i]-guess[i]))\\n    return results\",\n",
       "      \"index\": 0,\n",
       "      \"logprobs\": null,\n",
       "      \"finish_reason\": \"stop\"\n",
       "    },\n",
       "    {\n",
-      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        if game[i] == guess[i]:\\n            result.append(0)\\n        else:\\n            result.append(abs(game[i] - guess[i]))\\n    return result\",\n",
+      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        result.append(abs(game[i] - guess[i]))\\n    return result\",\n",
       "      \"index\": 1,\n",
       "      \"logprobs\": null,\n",
       "      \"finish_reason\": \"stop\"\n",
       "    },\n",
       "    {\n",
-      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        if game[i] == guess[i]:\\n            result.append(0)\\n        else:\\n            result.append(abs(game[i] - guess[i]))\\n    return result\",\n",
+      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        result.append(abs(game[i]-guess[i]))\\n    return result\",\n",
       "      \"index\": 2,\n",
       "      \"logprobs\": null,\n",
       "      \"finish_reason\": \"stop\"\n",
       "    },\n",
       "    {\n",
-      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        result.append(abs(game[i] - guess[i]))\\n    return result\",\n",
+      "      \"text\": \"    res = []\\n    for i in range(len(game)):\\n        res.append(abs(game[i]-guess[i]))\\n    return res\",\n",
       "      \"index\": 3,\n",
       "      \"logprobs\": null,\n",
       "      \"finish_reason\": \"stop\"\n",
       "    },\n",
       "    {\n",
-      "      \"text\": \"    results = []\\n    for i in range(len(game)):\\n        diff = abs(game[i] - guess[i])\\n        results.append(diff)\\n    return results\",\n",
+      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        diff = abs(game[i] - guess[i])\\n        result.append(diff)\\n    return result\",\n",
       "      \"index\": 4,\n",
       "      \"logprobs\": null,\n",
       "      \"finish_reason\": \"stop\"\n",
@@ -602,115 +600,115 @@
       "      \"finish_reason\": \"stop\"\n",
       "    },\n",
       "    {\n",
-      "      \"text\": \"    # write your code here\\n    result = []\\n    for i in range(len(game)):\\n        diff = abs(game[i] - guess[i])\\n        result.append(diff)\\n    return result\",\n",
+      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        result.append(abs(game[i] - guess[i]))\\n    return result\",\n",
       "      \"index\": 6,\n",
       "      \"logprobs\": null,\n",
       "      \"finish_reason\": \"stop\"\n",
       "    },\n",
       "    {\n",
-      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        if game[i] == guess[i]:\\n            result.append(0)\\n        else:\\n            result.append(abs(game[i] - guess[i]))\\n    return result\",\n",
+      "      \"text\": \"    results = []\\n    for i in range(len(game)):\\n        results.append(abs(game[i] - guess[i]))\\n    return results\",\n",
       "      \"index\": 7,\n",
       "      \"logprobs\": null,\n",
       "      \"finish_reason\": \"stop\"\n",
       "    },\n",
       "    {\n",
-      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        diff = abs(game[i] - guess[i])\\n        result.append(diff)\\n    return result\",\n",
+      "      \"text\": \"    res = []\\n    for i in range(len(game)):\\n        res.append(abs(game[i]-guess[i]))\\n    return res\",\n",
       "      \"index\": 8,\n",
       "      \"logprobs\": null,\n",
       "      \"finish_reason\": \"stop\"\n",
       "    },\n",
       "    {\n",
-      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        diff = abs(game[i] - guess[i])\\n        result.append(diff)\\n    return result\",\n",
+      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        result.append(abs(game[i]-guess[i]))\\n    return result\",\n",
       "      \"index\": 9,\n",
       "      \"logprobs\": null,\n",
       "      \"finish_reason\": \"stop\"\n",
       "    },\n",
       "    {\n",
-      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        if game[i] == guess[i]:\\n            result.append(0)\\n        else:\\n            result.append(abs(game[i]-guess[i]))\\n    return result\",\n",
+      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        diff = abs(game[i] - guess[i])\\n        result.append(diff)\\n    return result\",\n",
       "      \"index\": 10,\n",
       "      \"logprobs\": null,\n",
       "      \"finish_reason\": \"stop\"\n",
       "    },\n",
       "    {\n",
-      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        diff = abs(game[i] - guess[i])\\n        result.append(diff)\\n    return result\",\n",
+      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        result.append(abs(game[i] - guess[i]))\\n    return result\",\n",
       "      \"index\": 11,\n",
       "      \"logprobs\": null,\n",
       "      \"finish_reason\": \"stop\"\n",
       "    },\n",
       "    {\n",
-      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        result.append(abs(game[i] - guess[i]))\\n    return result\",\n",
+      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        if game[i] == guess[i]:\\n            result.append(0)\\n        else:\\n            result.append(abs(game[i] - guess[i]))\\n    return result\",\n",
       "      \"index\": 12,\n",
       "      \"logprobs\": null,\n",
       "      \"finish_reason\": \"stop\"\n",
       "    },\n",
       "    {\n",
-      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        diff = abs(game[i] - guess[i])\\n        result.append(diff)\\n    return result\",\n",
+      "      \"text\": \"    # set up empty list to store differences\\n    diff = []\\n    # iterate through the game list and guess list\\n    for i in range(len(game)):\\n        # check if the guess is equal to the game\\n        if game[i] == guess[i]:\\n            # if so, append 0 to the diff list\\n            diff.append(0)\\n        # otherwise, calculate the difference between the guess and the game\\n        else:\\n            diff.append(abs(game[i]-guess[i]))\\n    # return the diff list\\n    return diff\",\n",
       "      \"index\": 13,\n",
       "      \"logprobs\": null,\n",
       "      \"finish_reason\": \"stop\"\n",
       "    },\n",
       "    {\n",
-      "      \"text\": \"    #initialize empty list\\n    result = []\\n    #iterate over the two lists\\n    for i in range(len(game)):\\n        #append the absolute difference between the guess and the score to the result list\\n        result.append(abs(game[i]-guess[i]))\\n    #return the result list\\n    return result\",\n",
+      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        result.append(abs(game[i]-guess[i]))\\n    return result\",\n",
       "      \"index\": 14,\n",
       "      \"logprobs\": null,\n",
       "      \"finish_reason\": \"stop\"\n",
       "    },\n",
       "    {\n",
-      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        diff = abs(game[i] - guess[i])\\n        result.append(diff)\\n    return result\",\n",
+      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        if game[i] == guess[i]:\\n            result.append(0)\\n        else:\\n            result.append(abs(game[i] - guess[i]))\\n    return result\",\n",
       "      \"index\": 15,\n",
       "      \"logprobs\": null,\n",
       "      \"finish_reason\": \"stop\"\n",
       "    },\n",
       "    {\n",
-      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        result.append(abs(game[i] - guess[i]))\\n    return result\",\n",
+      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        diff = abs(game[i] - guess[i])\\n        result.append(diff)\\n    return result\",\n",
       "      \"index\": 16,\n",
       "      \"logprobs\": null,\n",
       "      \"finish_reason\": \"stop\"\n",
       "    },\n",
       "    {\n",
-      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        result.append(abs(game[i] - guess[i]))\\n    return result\",\n",
+      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        diff = abs(game[i] - guess[i])\\n        result.append(diff)\\n    return result\",\n",
       "      \"index\": 17,\n",
       "      \"logprobs\": null,\n",
       "      \"finish_reason\": \"stop\"\n",
       "    },\n",
       "    {\n",
-      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        result.append(abs(game[i] - guess[i]))\\n    return result\",\n",
+      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        diff = abs(game[i] - guess[i])\\n        result.append(diff)\\n    return result\",\n",
       "      \"index\": 18,\n",
       "      \"logprobs\": null,\n",
       "      \"finish_reason\": \"stop\"\n",
       "    },\n",
       "    {\n",
-      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        diff = abs(game[i] - guess[i])\\n        result.append(diff)\\n    return result\",\n",
+      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        result.append(abs(game[i] - guess[i]))\\n    return result\",\n",
       "      \"index\": 19,\n",
       "      \"logprobs\": null,\n",
       "      \"finish_reason\": \"stop\"\n",
       "    },\n",
       "    {\n",
-      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        diff = abs(game[i] - guess[i])\\n        result.append(diff)\\n    return result\",\n",
+      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        result.append(abs(game[i] - guess[i]))\\n    return result\",\n",
       "      \"index\": 20,\n",
       "      \"logprobs\": null,\n",
       "      \"finish_reason\": \"stop\"\n",
       "    },\n",
       "    {\n",
-      "      \"text\": \"    res = []\\n    for i in range(len(game)):\\n        diff = abs(game[i] - guess[i])\\n        res.append(diff)\\n    return res\",\n",
+      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        diff = abs(game[i] - guess[i])\\n        result.append(diff)\\n    return result\",\n",
       "      \"index\": 21,\n",
       "      \"logprobs\": null,\n",
       "      \"finish_reason\": \"stop\"\n",
       "    },\n",
       "    {\n",
-      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        diff = abs(game[i] - guess[i])\\n        result.append(diff)\\n    return result\",\n",
+      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        result.append(abs(game[i] - guess[i]))\\n    return result\",\n",
       "      \"index\": 22,\n",
       "      \"logprobs\": null,\n",
       "      \"finish_reason\": \"stop\"\n",
       "    },\n",
       "    {\n",
-      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        diff = abs(game[i] - guess[i])\\n        result.append(diff)\\n    return result\",\n",
+      "      \"text\": \"    # your code here\\n    result = []\\n    for i in range(len(game)):\\n        if game[i] == guess[i]:\\n            result.append(0)\\n        else:\\n            result.append(abs(game[i] - guess[i]))\\n    return result\",\n",
       "      \"index\": 23,\n",
       "      \"logprobs\": null,\n",
       "      \"finish_reason\": \"stop\"\n",
       "    },\n",
       "    {\n",
-      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        diff = abs(game[i] - guess[i])\\n        result.append(diff)\\n    return result\",\n",
+      "      \"text\": \"    results = []\\n    for i in range(len(game)):\\n        diff = abs(game[i] - guess[i])\\n        results.append(diff)\\n    return results\",\n",
       "      \"index\": 24,\n",
       "      \"logprobs\": null,\n",
       "      \"finish_reason\": \"stop\"\n",
@@ -722,7 +720,7 @@
       "      \"finish_reason\": \"stop\"\n",
       "    },\n",
       "    {\n",
-      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        result.append(abs(game[i]-guess[i]))\\n    return result\",\n",
+      "      \"text\": \"    result = []\\n    for i in range(len(game)):\\n        result.append(abs(game[i] - guess[i]))\\n    return result\",\n",
       "      \"index\": 26,\n",
       "      \"logprobs\": null,\n",
       "      \"finish_reason\": \"stop\"\n",
@@ -730,21 +728,21 @@
       "  ],\n",
       "  \"usage\": {\n",
       "    \"prompt_tokens\": 243,\n",
-      "    \"completion_tokens\": 1244,\n",
-      "    \"total_tokens\": 1487\n",
+      "    \"completion_tokens\": 1264,\n",
+      "    \"total_tokens\": 1507\n",
       "  },\n",
-      "  \"cost\": 0.029740000000000003,\n",
+      "  \"cost\": 0.03014,\n",
       "  \"config_id\": 0,\n",
       "  \"pass_filter\": true\n",
       "}\n",
-      "{'index_selected': 0, 'succeed_assertions': True, 'success': True, 'gen_cost': 0.0005660000000000001, 'assertions': 'assert compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) == [0,0,0,0,3,3]\\nassert compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) == [4,4,1,0,0,6]'}\n"
+      "{'index_selected': 0, 'succeed_assertions': True, 'success': True, 'gen_cost': 0.000702, 'assertions': 'assert compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) == [0,0,0,0,3,3]\\nassert compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) == [4,4,1,0,0,6]'}\n"
      ]
     }
    ],
    "source": [
-    "response = oai.Completion.create(context=tune_data[1], config_list=endpoint_list, **config)\n",
+    "response = autogen.Completion.create(context=tune_data[1], config_list=endpoint_list, **config)\n",
     "print(response)\n",
-    "print(eval_with_generated_assertions(oai.Completion.extract_text(response), **tune_data[1]))\n"
+    "print(eval_with_generated_assertions(autogen.Completion.extract_text(response), **tune_data[1]))\n"
    ]
   },
   {
@@ -754,12 +752,12 @@
    "source": [
     "### Evaluate the success rate on the test data\n",
     "\n",
-    "You can use flaml's `oai.Completion.test` to evaluate the performance of an entire dataset with the tuned config. The following code will take a while to evaluate all the 144 test data instances. The cost is about $6 if you uncomment it and run it."
+    "You can use `autogen.Completion.test` to evaluate the performance of an entire dataset with the tuned config. The following code will take a while to evaluate all the 144 test data instances. The cost is about $6 if you uncomment it and run it."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 12,
    "metadata": {
     "execution": {
      "iopub.execute_input": "2023-02-24T23:26:39.347295Z",
@@ -773,12 +771,12 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "performance on test data with the tuned config: {'index_selected': 5.208333333333333, 'succeed_assertions': 0.8402777777777778, 'success': 0.7777777777777778, 'gen_cost': 0.00045375000000000005, 'cost': 5.785519999999999, 'inference_cost': 0.04017722222222222}\n"
+      "performance on test data with the tuned config: {'index_selected': 5.222222222222222, 'succeed_assertions': 0.8402777777777778, 'success': 0.7569444444444444, 'gen_cost': 0.00044632638888888885, 'cost': 5.704979999999999, 'inference_cost': 0.03961791666666666}\n"
      ]
     }
    ],
    "source": [
-    "# result = oai.Completion.test(test_data, **config)\n",
+    "# result = autogen.Completion.test(test_data, config_list=endpoint_list, **config)\n",
     "# print(\"performance on test data with the tuned config:\", result)"
    ]
   },
diff --git a/notebook/research/autogen_code.ipynb b/notebook/research/autogen_code.ipynb
index 4fb0dfd8b0..653bd94393 100644
--- a/notebook/research/autogen_code.ipynb
+++ b/notebook/research/autogen_code.ipynb
@@ -170,7 +170,7 @@
    "outputs": [],
    "source": [
     "from flaml.autogen.code_utils import eval_function_completions, implement\n",
-    "from flaml import oai"
+    "from flaml.autogen import oai"
    ]
   },
   {
@@ -409,7 +409,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.16 (main, Apr 12 2023, 14:54:44) \n[GCC 10.2.1 20210110]"
+   "version": "3.9.16"
   },
   "vscode": {
    "interpreter": {
diff --git a/notebook/research/math_level5counting.ipynb b/notebook/research/math_level5counting.ipynb
index 1f27036d14..17721cbd60 100644
--- a/notebook/research/math_level5counting.ipynb
+++ b/notebook/research/math_level5counting.ipynb
@@ -233,7 +233,7 @@
     }
    },
    "source": [
-    "### Import the oai and tune subpackages from flaml.\n"
+    "### Import the oai subpackage from flaml.\n"
    ]
   },
   {
@@ -252,7 +252,7 @@
    },
    "outputs": [],
    "source": [
-    "from flaml import oai"
+    "from flaml.autogen import oai"
    ]
   },
   {
@@ -313,7 +313,7 @@
    "source": [
     "### Evaluate the success rate on the test data\n",
     "\n",
-    "You can use flaml's `oai.ChatCompletion.test` to evaluate the performance of an entire dataset with a config."
+    "You can use `oai.ChatCompletion.test` to evaluate the performance of an entire dataset with a config."
    ]
   },
   {
diff --git a/setup.py b/setup.py
index 63fc978180..d863b120e4 100644
--- a/setup.py
+++ b/setup.py
@@ -139,8 +139,8 @@
         ],
         "benchmark": ["catboost>=0.26", "psutil==5.8.0", "xgboost==1.3.3", "pandas==1.1.4"],
         "openai": ["openai==0.27.8", "diskcache"],
-        "autogen": ["openai==0.27.8", "diskcache", "docker"],
-        "mathchat": ["openai==0.27.8", "diskcache", "docker", "sympy", "pydantic==1.10.9", "wolframalpha"],
+        "autogen": ["openai==0.27.8", "diskcache", "termcolor"],
+        "mathchat": ["openai==0.27.8", "diskcache", "termcolor", "sympy", "pydantic==1.10.9", "wolframalpha"],
         "synapse": [
             "joblibspark>=0.5.0",
             "optuna==2.8.0",
diff --git a/website/docs/Examples/AutoGen-OpenAI.md b/website/docs/Examples/AutoGen-OpenAI.md
index 97ce73df4b..cc7b208d7f 100644
--- a/website/docs/Examples/AutoGen-OpenAI.md
+++ b/website/docs/Examples/AutoGen-OpenAI.md
@@ -82,9 +82,9 @@ The tuning will be performed under the specified optimization budgets.
 Users can specify tuning data, optimization metric, optimization mode, evaluation function, search spaces etc.
 
 ```python
-from flaml import oai
+from flaml import autogen
 
-config, analysis = oai.Completion.tune(
+config, analysis = autogen.Completion.tune(
     data=tune_data,  # the data for tuning
     metric="success",  # the metric to optimize
     mode="max",  # the optimization mode
@@ -106,7 +106,7 @@ config, analysis = oai.Completion.tune(
 
 #### Output tuning results
 
-After the tuning, we can print out the optimized config and the result found by FLAML:
+After the tuning, we can print out the optimized config and the result:
 
 ```python
 print("optimized config", config)
@@ -118,17 +118,17 @@ print("best result on tuning data", analysis.best_result)
 We can apply the tuned config to the request for an instance:
 
 ```python
-response = oai.Completion.create(context=tune_data[1], **config)
+response = autogen.Completion.create(context=tune_data[1], **config)
 print(response)
-print(eval_with_generated_assertions(oai.Completion.extract_text(response), **tune_data[1]))
+print(eval_with_generated_assertions(autogen.Completion.extract_text(response), **tune_data[1]))
 ```
 
 #### Evaluate the success rate on the test data
 
-You can use flaml's `oai.Completion.test` to evaluate the performance of an entire dataset with the tuned config.
+You can use `autogen.Completion.test` to evaluate the performance of an entire dataset with the tuned config.
 
 ```python
-result = oai.Completion.test(test_data, **config)
+result = autogen.Completion.test(test_data, **config)
 print("performance on test data with the tuned config:", result)
 ```
 
diff --git a/website/docs/Getting-Started.md b/website/docs/Getting-Started.md
index 776c1f9cdf..ce86920045 100644
--- a/website/docs/Getting-Started.md
+++ b/website/docs/Getting-Started.md
@@ -25,10 +25,10 @@ There are several ways of using flaml:
 Maximize the utility out of the expensive LLMs such as ChatGPT and GPT-4, including:
 - A drop-in replacement of `openai.Completion` or `openai.ChatCompletion` with powerful functionalites like tuning, caching, templating, filtering. For example, you can optimize generations by LLM with your own tuning data, success metrics and budgets.
 ```python
-from flaml import oai
+from flaml import autogen
 
 # perform tuning
-config, analysis = oai.Completion.tune(
+config, analysis = autogen.Completion.tune(
     data=tune_data,
     metric="success",
     mode="max",
@@ -39,13 +39,13 @@ config, analysis = oai.Completion.tune(
 )
 
 # perform inference for a test instance
-response = oai.Completion.create(context=test_instance, **config)
+response = autogen.Completion.create(context=test_instance, **config)
 ```
 - LLM-driven intelligent agents which can perform tasks autonomously or with human feedback, including tasks that require using tools via code. For example,
 ```python
-assistant = AssistantAgent("assistant")
-user_proxy = UserProxyAgent("user_proxy")
-user_proxy.initiate_chat("Show me the YTD gain of 10 largest technology companies as of today.")
+assistant = autogen.AssistantAgent("assistant")
+user_proxy = autogen.UserProxyAgent("user_proxy")
+user_proxy.initiate_chat(assistant, message="Show me the YTD gain of 10 largest technology companies as of today.")
 ```
 
 #### [Task-oriented AutoML](/docs/Use-Cases/task-oriented-automl)
diff --git a/website/docs/Use-Cases/Auto-Generation.md b/website/docs/Use-Cases/Auto-Generation.md
index 4baa2281fd..9938164da4 100644
--- a/website/docs/Use-Cases/Auto-Generation.md
+++ b/website/docs/Use-Cases/Auto-Generation.md
@@ -15,22 +15,19 @@ The package is under active development with more features upcoming.
 
 [`flaml.autogen.agentchat`](/docs/reference/autogen/agentchat/agent) contains an experimental implementation of interactive agents which can adapt to human or simulated feedback. This subpackage is under active development.
 
-We have designed different classes of Agents that are capable of communicating with each other through the exchange of messages to collaboratively finish a task. An agent can communicate with other agents and perform actions. Different agents can differ in what actions they perform after receiving messages.
+We have designed a generic `ResponsiveAgent` class for Agents that are capable of communicating with each other through the exchange of messages to collaboratively finish a task. An agent can communicate with other agents and perform actions. Different agents can differ in what actions they perform after receiving messages. Two representative subclasses are `AssistantAgent` and `UserProxyAgent`.
 
-### `AssistantAgent`
+- `AssistantAgent`. Designed to act as an assistant by responding to user requests. It could write Python code (in a Python coding block) for a user to execute when a message (typically a description of a task that needs to be solved) is received. Under the hood, the Python code is written by LLM (e.g., GPT-4). It can also receive the execution results and suggest code with bug fix. Its behavior can be altered by passing a new system message. The LLM [inference](#enhanced-inference) configuration can be configured via `llm_config`.
+- `UserProxyAgent`. Serves as a proxy for the human user. Upon receiving a message, the UserProxyAgent will either solicit the human user's input or prepare an automatically generated reply. The chosen action depends on the settings of the `human_input_mode` and `max_consecutive_auto_reply` when the `UserProxyAgent` instance is constructed, and whether a human user input is available.
+By default, the automatically generated reply is crafted based on automatic code execution. The `UserProxyAgent` triggers code execution automatically when it detects an executable code block in the received message and no human user input is provided. Code execution can be disabled by setting `code_execution_config` to False. LLM-based response is disabled by default. It can be enabled by setting `llm_config` to a dict corresponding to the [inference](#enhanced-inference) configuration.
+When `llm_config` is set to a dict, `UserProxyAgent` can generate replies using an LLM when code execution is not performed.
 
-`AssistantAgent` is an Agent class designed to act as an assistant by responding to user requests. It could write Python code (in a Python coding block) for a user to execute when a message (typically a description of a task that needs to be solved) is received. Under the hood, the Python code is written by LLM (e.g., GPT-4).
-
-### `UserProxyAgent`
-`UserProxyAgent` is an Agent class that serves as a proxy for the human user. Upon receiving a message, the UserProxyAgent will either solicit the human user's input or prepare an automatically generated reply. The chosen action depends on the settings of the `human_input_mode` and `max_consecutive_auto_reply` when the `UserProxyAgent` instance is constructed, and whether a human user input is available.
-
-By default, the automatically generated reply is crafted based on automatic code execution. The `UserProxyAgent` triggers code execution automatically when it detects an executable code block in the received message and no human user input is provided. One can also easily extend it by overriding the `auto_reply` function of the `UserProxyAgent` to add or modify responses.
-For example, `AIUserProxyAgent` is a subclass of `UserProxyAgent` which can generate replies using an LLM when code execution is not performed. Code execution can be disabled by setting `code_execution_config` to False.
-This auto-reply capability allows for more autonomous user-agent communication while retaining the possibility of human intervention.
+The auto-reply capability of `ResponsiveAgent` allows for more autonomous multi-agent communication while retaining the possibility of human intervention.
+One can also easily extend it by overriding the `generate_reply` function of the `UserProxyAgent` to add or modify responses.
 
 Example usage of the agents to solve a task with code:
 ```python
-from flaml.autogen.agent import AssistantAgent, UserProxyAgent
+from flaml.autogen import AssistantAgent, UserProxyAgent
 
 # create an AssistantAgent instance named "assistant"
 assistant = AssistantAgent(name="assistant")
@@ -39,9 +36,6 @@ assistant = AssistantAgent(name="assistant")
 user_proxy = UserProxyAgent(
     name="user_proxy",
     human_input_mode="NEVER",  # in this mode, the agent will never solicit human input but always auto reply
-    max_consecutive_auto_reply=10,  # the maximum number of consecutive auto replies
-    is_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE") or x.get("content", "").rstrip().endswith('"TERMINATE".'),  # the function to determine whether a message is a termination message
-    code_execution_config={"work_dir": "."},
 )
 
 # the assistant receives a message from the user, which contains the task description
@@ -53,7 +47,7 @@ user.initiate_chat(
 In the example above, we create an AssistantAgent named "assistant" to serve as the assistant and a UserProxyAgent named "user_proxy" to serve as a proxy for the human user.
 1. The assistant receives a message from the user_proxy, which contains the task description.
 2. The assistant then tries to write Python code to solve the task and sends the response to the user_proxy.
-3. Once the user_proxy receives a response from the assistant, it tries to reply by either soliciting human input or preparing an automatically generated reply. In this specific example, since `human_input_mode` is set to `"NEVER"`, the user_proxy will not solicit human input but prepare an automatically generated reply (auto reply). More specifically, the user_proxy executes the code and uses the result as the auto-reply.
+3. Once the user_proxy receives a response from the assistant, it tries to reply by either soliciting human input or preparing an automatically generated reply. In this specific example, since `human_input_mode` is set to `"NEVER"`, the user_proxy will not solicit human input but send an automatically generated reply (auto reply). More specifically, the user_proxy executes the code and uses the result as the auto-reply.
 4. The assistant then generates a further response for the user_proxy. The user_proxy can then decide whether to terminate the conversation. If not, steps 3 and 4 are repeated.
 
 Please find a visual illustration of how UserProxyAgent and AssistantAgent collaboratively solve the above task below:
@@ -70,57 +64,80 @@ To leverage [function calling capability of OpenAI's Chat Completions API](https
 
 Example usage of the agents to solve a task with function calling feature:
 ```python
-from flaml.autogen.agent import AssistantAgent, UserProxyAgent
+from flaml.autogen import AssistantAgent, UserProxyAgent
 
 # put the descriptions of functions in config to be passed to OpenAI's API
-oai_config = {
+llm_config = {
     "model": "gpt-4-0613",
     "functions": [
         {
-            "name": "execute_code",
-            "description": "Receive a python code or shell script and return the execution result.",
+            "name": "python",
+            "description": "run cell in ipython and return the execution result.",
             "parameters": {
                 "type": "object",
                 "properties": {
-                    "code_type": {
+                    "cell": {
                         "type": "string",
-                        "description": "Code type, 'python' or 'sh'.",
-                    },
-                    "code": {
+                        "description": "Valid Python cell to execute.",
+                    }
+                },
+                "required": ["cell"],
+            },
+        },
+        {
+            "name": "sh",
+            "description": "run a shell script and return the execution result.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "script": {
                         "type": "string",
-                        "description": "Valid Python code to execute.",
+                        "description": "Valid shell script to execute.",
                     }
                 },
-                "required": ["code_type", "code"],
+                "required": ["script"],
             },
-        }
+        },
     ],
-    "function_call": "auto",
 }
 
 # create an AssistantAgent instance named "assistant"
-chatbot = AssistantAgent("assistant", config_list=config_list, **oai_config)
+chatbot = AssistantAgent("assistant", **llm_config)
 
-# create a UserProxyAgent instance named "user"
-user = UserProxyAgent(
-    "user",
+# create a UserProxyAgent instance named "user_proxy"
+user_proxy = UserProxyAgent(
+    "user_proxy",
     human_input_mode="NEVER",
-    code_execution_config={"work_dir": "coding"},
 )
 
-# define an `execute_code` function according to the function desription
-def execute_code(code_type, code):
-    # here we reuse the method in the user proxy agent
-    # in general, this is not necessary
-    return user.execute_code_blocks([(code_type, code)])
-
-# register the `execute_code` function
-user.register_function(function_map={"execute_code": execute_code})
+# define functions according to the function desription
+from IPython import get_ipython
+
+def exec_python(cell):
+    ipython = get_ipython()
+    result = ipython.run_cell(cell)
+    log = str(result.result)
+    if result.error_before_exec is not None:
+        log += f"\n{result.error_before_exec}"
+    if result.error_in_exec is not None:
+        log += f"\n{result.error_in_exec}"
+    return log
+
+def exec_sh(script):
+    return user_proxy.execute_code_blocks([("sh", script)])
+
+# register the functions
+user_proxy.register_function(
+    function_map={
+        "python": exec_python,
+        "sh": exec_sh,
+    }
+)
 
 # start the conversation
-user.initiate_chat(
-    assistant,
-    message="Draw a rocket and save to a file named 'rocket.svg'",
+user_proxy.initiate_chat(
+    chatbot,
+    message="Draw two agents chatting with each other with an example dialog.",
 )
 ```
 
@@ -131,8 +148,6 @@ user.initiate_chat(
 
 * [Solve Tasks Requiring Web Info](https://github.com/microsoft/FLAML/blob/main/notebook/autogen_agentchat_web_info.ipynb)
 
-* [Using MathChat to Solve Math Problems](https://github.com/microsoft/FLAML/blob/main/notebook/autogen_agentchat_MathChat.ipynb)
-
 * [Use Provided Tools as Functions](https://github.com/microsoft/FLAML/blob/main/notebook/autogen_agentchat_function_call.ipynb)
 
 * [Automated Task Solving with Coding & Planning Agents](https://github.com/microsoft/FLAML/blob/main/notebook/autogen_agentchat_planning.ipynb)
@@ -141,8 +156,8 @@ user.initiate_chat(
 
 ## Enhanced Inference
 
-One can use [`flaml.oai.Completion.create`](/docs/reference/autogen/oai/completion#create) to perform inference.
-There are a number of benefits of using `flaml.oai.Completion.create` to perform inference.
+One can use [`flaml.autogen.Completion.create`](/docs/reference/autogen/oai/completion#create) to perform inference.
+There are a number of benefits of using `autogen` to perform inference.
 
 ### Tune Inference Parameters
 
@@ -222,12 +237,12 @@ The optimization budget refers to the total budget allowed in the tuning process
 
 #### Perform tuning
 
-Now, you can use [`flaml.oai.Completion.tune`](/docs/reference/autogen/oai/completion#tune) for tuning. For example,
+Now, you can use [`flaml.autogen.Completion.tune`](/docs/reference/autogen/oai/completion#tune) for tuning. For example,
 
 ```python
-from flaml import oai
+from flaml import autogen
 
-config, analysis = oai.Completion.tune(
+config, analysis = autogen.Completion.tune(
     data=tune_data,
     metric="success",
     mode="max",
@@ -250,12 +265,12 @@ The tuend config can be used to perform inference.
 
 ### API unification
 
-`flaml.oai.Completion.create` is compatible with both `openai.Completion.create` and `openai.ChatCompletion.create`, and both OpenAI API and Azure OpenAI API. So models such as "text-davinci-003", "gpt-3.5-turbo" and "gpt-4" can share a common API.
-When chat models are used and `prompt` is given as the input to `flaml.oai.Completion.create`, the prompt will be automatically converted into `messages` to fit the chat completion API requirement. One advantage is that one can experiment with both chat and non-chat models for the same prompt in a unified API.
+`flaml.autogen.Completion.create` is compatible with both `openai.Completion.create` and `openai.ChatCompletion.create`, and both OpenAI API and Azure OpenAI API. So models such as "text-davinci-003", "gpt-3.5-turbo" and "gpt-4" can share a common API.
+When chat models are used and `prompt` is given as the input to `flaml.autogen.Completion.create`, the prompt will be automatically converted into `messages` to fit the chat completion API requirement. One advantage is that one can experiment with both chat and non-chat models for the same prompt in a unified API.
 
 For local LLMs, one can spin up an endpoint using a package like [simple_ai_server](https://github.com/lhenault/simpleAI) and [FastChat](https://github.com/lm-sys/FastChat), and then use the same API to send a request. See [here](/blog/2023/07/14/Local-LLMs) for examples on how to make inference with local LLMs.
 
-When only working with the chat-based models, `flaml.oai.ChatCompletion` can be used. It also does automatic conversion from prompt to messages, if prompt is provided instead of messages.
+When only working with the chat-based models, `flaml.autogen.ChatCompletion` can be used. It also does automatic conversion from prompt to messages, if prompt is provided instead of messages.
 
 ### Caching
 
@@ -265,12 +280,12 @@ API call results are cached locally and reused when the same request is issued.
 
 #### Runtime error
 
-It is easy to hit error when calling OpenAI APIs, due to connection, rate limit, or timeout. Some of the errors are transient. `flaml.oai.Completion.create` deals with the transient errors and retries automatically. Initial request timeout, retry timeout and retry time interval can be configured via `request_timeout`, `retry_timeout` and `flaml.oai.Completion.retry_time`.
+It is easy to hit error when calling OpenAI APIs, due to connection, rate limit, or timeout. Some of the errors are transient. `flaml.autogen.Completion.create` deals with the transient errors and retries automatically. Initial request timeout, retry timeout and retry time interval can be configured via `request_timeout`, `retry_timeout` and `flaml.autogen.Completion.retry_time`.
 
 Moreover, one can pass a list of configurations of different models/endpoints to mitigate the rate limits. For example,
 
 ```python
-response = oai.Completion.create(
+response = autogen.Completion.create(
     config_list=[
         {
             "model": "gpt-4",
@@ -306,7 +321,7 @@ Another type of error is that the returned response does not satisfy a requireme
 
 ```python
 def valid_json_filter(context, config, response):
-    for text in oai.Completion.extract_text(response):
+    for text in autogen.Completion.extract_text(response):
         try:
             json.loads(text)
             return True
@@ -314,7 +329,7 @@ def valid_json_filter(context, config, response):
             pass
     return False
 
-response = oai.Completion.create(
+response = autogen.Completion.create(
     config_list=[{"model": "text-ada-001"}, {"model": "gpt-3.5-turbo"}, {"model": "text-davinci-003"}],
     prompt="How to construct a json request to Bing API to search for 'latest AI news'? Return the JSON request.",
     filter_func=valid_json_filter,
@@ -330,7 +345,7 @@ The example above will try to use text-ada-001, gpt-3.5-turbo, and text-davinci-
 If the provided prompt or message is a template, it will be automatically materialized with a given context. For example,
 
 ```python
-response = oai.Completion.create(
+response = autogen.Completion.create(
     context={"problem": "How many positive integers, not exceeding 100, are multiples of 2 or 3 but not 4?"},
     prompt="{problem} Solve the problem carefully.",
     **config
@@ -363,11 +378,11 @@ context = {
     "external_info_0": "Problem 1: ...",
 }
 
-response = oai.ChatCompletion.create(context, messages=messages, **config)
+response = autogen.ChatCompletion.create(context, messages=messages, **config)
 messages.append(
     {
         "role": "assistant",
-        "content": oai.ChatCompletion.extract_text(response)[0]
+        "content": autogen.ChatCompletion.extract_text(response)[0]
     }
 )
 messages.append(
@@ -382,26 +397,26 @@ context.append(
         "external_info_1": "Theorem 1: ...",
     }
 )
-response = oai.ChatCompletion.create(context, messages=messages, **config)
+response = autogen.ChatCompletion.create(context, messages=messages, **config)
 ```
 
 ### Logging (Experimental)
 
-When debugging or diagnosing an LLM-based system, it is often convenient to log the API calls and analyze them. `flaml.oai.Completion` and `flaml.oai.ChatCompletion` offer an easy way to collect the API call histories. For example, to log the chat histories, simply run:
+When debugging or diagnosing an LLM-based system, it is often convenient to log the API calls and analyze them. `flaml.autogen.Completion` and `flaml.autogen.ChatCompletion` offer an easy way to collect the API call histories. For example, to log the chat histories, simply run:
 ```python
-flaml.oai.ChatCompletion.start_logging()
+flaml.autogen.ChatCompletion.start_logging()
 ```
 The API calls made after this will be automatically logged. They can be retrieved at any time by:
 ```python
-flaml.oai.ChatCompletion.logged_history
+flaml.autogen.ChatCompletion.logged_history
 ```
 To stop logging, use
 ```python
-flaml.oai.ChatCompletion.stop_logging()
+flaml.autogen.ChatCompletion.stop_logging()
 ```
 If one would like to append the history to an existing dict, pass the dict like:
 ```python
-flaml.oai.ChatCompletion.start_logging(history_dict=existing_history_dict)
+flaml.autogen.ChatCompletion.start_logging(history_dict=existing_history_dict)
 ```
 By default, the counter of API calls will be reset at `start_logging()`. If no reset is desired, set `reset_counter=False`.
 


Test patch:
diff --git a/test/autogen/extensions/__init__.py b/test/autogen/agentchat/extensions/__init__.py
similarity index 100%
rename from test/autogen/extensions/__init__.py
rename to test/autogen/agentchat/extensions/__init__.py
diff --git a/test/autogen/extensions/tsp.py b/test/autogen/agentchat/extensions/tsp.py
similarity index 100%
rename from test/autogen/extensions/tsp.py
rename to test/autogen/agentchat/extensions/tsp.py
diff --git a/test/autogen/extensions/tsp_api.py b/test/autogen/agentchat/extensions/tsp_api.py
similarity index 100%
rename from test/autogen/extensions/tsp_api.py
rename to test/autogen/agentchat/extensions/tsp_api.py
diff --git a/test/autogen/test_assistant_agent.py b/test/autogen/agentchat/test_assistant_agent.py
similarity index 82%
rename from test/autogen/test_assistant_agent.py
rename to test/autogen/agentchat/test_assistant_agent.py
index 2b194c2663..bc12031a8f 100644
--- a/test/autogen/test_assistant_agent.py
+++ b/test/autogen/agentchat/test_assistant_agent.py
@@ -1,10 +1,10 @@
 import os
 import sys
 import pytest
-from flaml import oai
+from flaml import autogen
 from flaml.autogen.agentchat import AssistantAgent, UserProxyAgent
 
-KEY_LOC = "test/autogen"
+KEY_LOC = "notebook"
 OAI_CONFIG_LIST = "OAI_CONFIG_LIST"
 here = os.path.abspath(os.path.dirname(__file__))
 
@@ -20,16 +20,16 @@ def test_ai_user_proxy_agent():
         return
 
     conversations = {}
-    oai.ChatCompletion.start_logging(conversations)
+    autogen.ChatCompletion.start_logging(conversations)
 
-    config_list = oai.config_list_from_json(
+    config_list = autogen.config_list_from_json(
         OAI_CONFIG_LIST,
         file_location=KEY_LOC,
     )
     assistant = AssistantAgent(
         "assistant",
         system_message="You are a helpful assistant.",
-        oai_config={
+        llm_config={
             "request_timeout": 600,
             "seed": 42,
             "config_list": config_list,
@@ -41,7 +41,7 @@ def test_ai_user_proxy_agent():
         human_input_mode="NEVER",
         max_consecutive_auto_reply=2,
         code_execution_config=False,
-        oai_config={
+        llm_config={
             "config_list": config_list,
         },
         # In the system message the "user" always refers to ther other agent.
@@ -62,7 +62,7 @@ def test_gpt35(human_input_mode="NEVER", max_consecutive_auto_reply=5):
         import openai
     except ImportError:
         return
-    config_list = oai.config_list_from_json(
+    config_list = autogen.config_list_from_json(
         OAI_CONFIG_LIST,
         file_location=KEY_LOC,
         filter_dict={
@@ -75,14 +75,14 @@ def test_gpt35(human_input_mode="NEVER", max_consecutive_auto_reply=5):
             },
         },
     )
+    llm_config = {
+        "seed": 42,
+        "config_list": config_list,
+        "max_tokens": 1024,
+    }
     assistant = AssistantAgent(
         "coding_agent",
-        oai_config={
-            # "request_timeout": 600,
-            "seed": 42,
-            "config_list": config_list,
-            "max_tokens": 1024,
-        },
+        llm_config=llm_config,
     )
     user = UserProxyAgent(
         "user",
@@ -94,6 +94,8 @@ def test_gpt35(human_input_mode="NEVER", max_consecutive_auto_reply=5):
             "use_docker": "python:3",
             "timeout": 60,
         },
+        llm_config=llm_config,
+        system_message="""Reply TERMINATE to end the conversation.""",
     )
     user.initiate_chat(assistant, message="TERMINATE")
     # should terminate without sending any message
@@ -115,16 +117,17 @@ def test_create_execute_script(human_input_mode="NEVER", max_consecutive_auto_re
     except ImportError:
         return
 
-    config_list = oai.config_list_from_json(OAI_CONFIG_LIST, file_location=KEY_LOC)
+    config_list = autogen.config_list_from_json(OAI_CONFIG_LIST, file_location=KEY_LOC)
     conversations = {}
-    oai.ChatCompletion.start_logging(conversations)
+    autogen.ChatCompletion.start_logging(conversations)
+    llm_config = {
+        "request_timeout": 600,
+        "seed": 42,
+        "config_list": config_list,
+    }
     assistant = AssistantAgent(
         "assistant",
-        oai_config={
-            "request_timeout": 600,
-            "seed": 42,
-            "config_list": config_list,
-        },
+        llm_config=llm_config,
     )
     user = UserProxyAgent(
         "user",
@@ -145,10 +148,10 @@ def test_create_execute_script(human_input_mode="NEVER", max_consecutive_auto_re
 ```""",
     )
     print(conversations)
-    oai.ChatCompletion.start_logging(compact=False)
+    autogen.ChatCompletion.start_logging(compact=False)
     user.send("""Execute temp.py""", assistant)
-    print(oai.ChatCompletion.logged_history)
-    oai.ChatCompletion.stop_logging()
+    print(autogen.ChatCompletion.logged_history)
+    autogen.ChatCompletion.stop_logging()
 
 
 def test_tsp(human_input_mode="NEVER", max_consecutive_auto_reply=10):
@@ -157,7 +160,7 @@ def test_tsp(human_input_mode="NEVER", max_consecutive_auto_reply=10):
     except ImportError:
         return
 
-    config_list = oai.config_list_from_json(
+    config_list = autogen.config_list_from_json(
         OAI_CONFIG_LIST,
         file_location=KEY_LOC,
         filter_dict={
@@ -179,19 +182,17 @@ def __init__(self, *args, **kwargs):
         def generate_init_message(self, question) -> str:
             return self._prompt.format(question=question)
 
-    oai.ChatCompletion.start_logging()
-    assistant = AssistantAgent("assistant", oai_config={"temperature": 0, "config_list": config_list})
+    autogen.ChatCompletion.start_logging()
+    assistant = AssistantAgent("assistant", llm_config={"temperature": 0, "config_list": config_list})
     user = TSPUserProxyAgent(
         "user",
         code_execution_config={"work_dir": here},
         human_input_mode=human_input_mode,
         max_consecutive_auto_reply=max_consecutive_auto_reply,
     )
-    # agent.receive(prompt.format(question=hard_questions[0]), user)
-    # agent.receive(prompt.format(question=hard_questions[1]), user)
     user.initiate_chat(assistant, question=hard_questions[2])
-    print(oai.ChatCompletion.logged_history)
-    oai.ChatCompletion.stop_logging()
+    print(autogen.ChatCompletion.logged_history)
+    autogen.ChatCompletion.stop_logging()
 
 
 if __name__ == "__main__":
diff --git a/test/autogen/test_math_user_proxy_agent.py b/test/autogen/agentchat/test_math_user_proxy_agent.py
similarity index 94%
rename from test/autogen/test_math_user_proxy_agent.py
rename to test/autogen/agentchat/test_math_user_proxy_agent.py
index 569e9195f1..83c800a39f 100644
--- a/test/autogen/test_math_user_proxy_agent.py
+++ b/test/autogen/agentchat/test_math_user_proxy_agent.py
@@ -1,14 +1,12 @@
-from flaml import oai
+import pytest
+import sys
+from flaml import autogen
 from flaml.autogen.agentchat.contrib.math_user_proxy_agent import (
     MathUserProxyAgent,
     _remove_print,
     _add_print_to_last_line,
 )
-import pytest
-import sys
-
-KEY_LOC = "test/autogen"
-OAI_CONFIG_LIST = "OAI_CONFIG_LIST"
+from test_assistant_agent import KEY_LOC, OAI_CONFIG_LIST
 
 
 @pytest.mark.skipif(
@@ -24,9 +22,9 @@ def test_math_user_proxy_agent():
     from flaml.autogen.agentchat.assistant_agent import AssistantAgent
 
     conversations = {}
-    oai.ChatCompletion.start_logging(conversations)
+    autogen.ChatCompletion.start_logging(conversations)
 
-    config_list = oai.config_list_from_json(
+    config_list = autogen.config_list_from_json(
         OAI_CONFIG_LIST,
         file_location=KEY_LOC,
         filter_dict={
@@ -36,7 +34,7 @@ def test_math_user_proxy_agent():
     assistant = AssistantAgent(
         "assistant",
         system_message="You are a helpful assistant.",
-        oai_config={
+        llm_config={
             "request_timeout": 600,
             "seed": 42,
             "config_list": config_list,
diff --git a/test/autogen/test_responsive_agent.py b/test/autogen/agentchat/test_responsive_agent.py
similarity index 68%
rename from test/autogen/test_responsive_agent.py
rename to test/autogen/agentchat/test_responsive_agent.py
index 5710a5a27a..20015acc12 100644
--- a/test/autogen/test_responsive_agent.py
+++ b/test/autogen/agentchat/test_responsive_agent.py
@@ -13,16 +13,20 @@ def test_responsive_agent(monkeypatch):
     monkeypatch.setattr(sys, "stdin", StringIO("TERMINATE\n\n"))
     dummy_agent_1.receive(
         {
-            "content": "hello",
+            "content": "hello {name}",
+            "context": {
+                "name": "dummy_agent_2",
+            },
         },
         dummy_agent_2,
     )  # receive a dict
-
+    assert "context" in dummy_agent_1.chat_messages["dummy_agent_2"][-2]
     # receive dict without openai fields to be printed, such as "content", 'function_call'. There should be no error raised.
-    pre_len = len(dummy_agent_1.oai_conversations["dummy_agent_2"])
-    dummy_agent_1.receive({"message": "hello"}, dummy_agent_2)
+    pre_len = len(dummy_agent_1.chat_messages["dummy_agent_2"])
+    with pytest.raises(ValueError):
+        dummy_agent_1.receive({"message": "hello"}, dummy_agent_2)
     assert pre_len == len(
-        dummy_agent_1.oai_conversations["dummy_agent_2"]
+        dummy_agent_1.chat_messages["dummy_agent_2"]
     ), "When the message is not an valid openai message, it should not be appended to the oai conversation."
 
     monkeypatch.setattr(sys, "stdin", StringIO("exit"))
@@ -36,14 +40,18 @@ def test_responsive_agent(monkeypatch):
     )  # send a dict
 
     # send dict with no openai fields
-    pre_len = len(dummy_agent_1.oai_conversations["dummy_agent_2"])
+    pre_len = len(dummy_agent_1.chat_messages["dummy_agent_2"])
     with pytest.raises(ValueError):
         dummy_agent_1.send({"message": "hello"}, dummy_agent_2)
 
     assert pre_len == len(
-        dummy_agent_1.oai_conversations["dummy_agent_2"]
+        dummy_agent_1.chat_messages["dummy_agent_2"]
     ), "When the message is not a valid openai message, it should not be appended to the oai conversation."
 
+    # update system message
+    dummy_agent_1.update_system_message("new system message")
+    assert dummy_agent_1._oai_system_message[0]["content"] == "new system message"
+
 
 if __name__ == "__main__":
     test_responsive_agent(pytest.monkeypatch)
diff --git a/test/autogen/tsp_prompt.txt b/test/autogen/agentchat/tsp_prompt.txt
similarity index 100%
rename from test/autogen/tsp_prompt.txt
rename to test/autogen/agentchat/tsp_prompt.txt
diff --git a/test/autogen/oai/test_completion.py b/test/autogen/oai/test_completion.py
index 97d6042564..65239880e0 100644
--- a/test/autogen/oai/test_completion.py
+++ b/test/autogen/oai/test_completion.py
@@ -5,30 +5,28 @@
 from functools import partial
 import os
 import json
-from flaml import oai
+from flaml import autogen
 from flaml.autogen.code_utils import (
     eval_function_completions,
     generate_assertions,
     implement,
     generate_code,
-    improve_function,
-    improve_code,
 )
 from flaml.autogen.math_utils import eval_math_responses, solve_problem
 
-KEY_LOC = "test/autogen"
+KEY_LOC = "notebook"
 OAI_CONFIG_LIST = "OAI_CONFIG_LIST"
 here = os.path.abspath(os.path.dirname(__file__))
 
 
 def yes_or_no_filter(context, response, **_):
     return context.get("yes_or_no_choice", False) is False or any(
-        text in ["Yes.", "No."] for text in oai.Completion.extract_text(response)
+        text in ["Yes.", "No."] for text in autogen.Completion.extract_text(response)
     )
 
 
 def valid_json_filter(response, **_):
-    for text in oai.Completion.extract_text(response):
+    for text in autogen.Completion.extract_text(response):
         try:
             json.loads(text)
             return True
@@ -43,47 +41,47 @@ def test_filter():
     except ImportError as exc:
         print(exc)
         return
-    response = oai.Completion.create(
+    response = autogen.Completion.create(
         context={"yes_or_no_choice": True},
         config_list=[{"model": "text-ada-001"}, {"model": "gpt-3.5-turbo"}, {"model": "text-davinci-003"}],
         prompt="Is 37 a prime number? Please answer 'Yes.' or 'No.'",
         filter_func=yes_or_no_filter,
     )
     assert (
-        oai.Completion.extract_text(response)[0] in ["Yes.", "No."]
+        autogen.Completion.extract_text(response)[0] in ["Yes.", "No."]
         or not response["pass_filter"]
         and response["config_id"] == 2
     )
-    response = oai.Completion.create(
+    response = autogen.Completion.create(
         context={"yes_or_no_choice": False},
         config_list=[{"model": "text-ada-001"}, {"model": "gpt-3.5-turbo"}, {"model": "text-davinci-003"}],
         prompt="Is 37 a prime number?",
         filter_func=yes_or_no_filter,
     )
     assert response["model"] == "text-ada-001"
-    response = oai.Completion.create(
+    response = autogen.Completion.create(
         config_list=[{"model": "text-ada-001"}, {"model": "gpt-3.5-turbo"}, {"model": "text-davinci-003"}],
         prompt="How to construct a json request to Bing API to search for 'latest AI news'? Return the JSON request.",
         filter_func=valid_json_filter,
     )
     assert response["config_id"] == 2 or response["pass_filter"], "the response must pass filter unless all fail"
-    assert not response["pass_filter"] or json.loads(oai.Completion.extract_text(response)[0])
+    assert not response["pass_filter"] or json.loads(autogen.Completion.extract_text(response)[0])
 
 
 def test_chatcompletion():
-    params = oai.ChatCompletion._construct_params(
+    params = autogen.ChatCompletion._construct_params(
         context=None,
         config={"model": "unknown"},
         prompt="hi",
     )
     assert "messages" in params
-    params = oai.Completion._construct_params(
+    params = autogen.Completion._construct_params(
         context=None,
         config={"model": "unknown"},
         prompt="hi",
     )
     assert "messages" not in params
-    params = oai.Completion._construct_params(
+    params = autogen.Completion._construct_params(
         context=None,
         config={"model": "gpt-4"},
         prompt="hi",
@@ -97,46 +95,13 @@ def test_multi_model():
     except ImportError as exc:
         print(exc)
         return
-    response = oai.Completion.create(
-        config_list=oai.config_list_gpt4_gpt35(KEY_LOC),
+    response = autogen.Completion.create(
+        config_list=autogen.config_list_gpt4_gpt35(KEY_LOC),
         prompt="Hi",
     )
     print(response)
 
 
-def test_improve():
-    try:
-        import openai
-        import diskcache
-    except ImportError as exc:
-        print(exc)
-        return
-    config_list = oai.config_list_openai_aoai(KEY_LOC)
-    improved, _ = improve_function(
-        "flaml/autogen/math_utils.py",
-        "solve_problem",
-        "Solve math problems accurately, by avoiding calculation errors and reduce reasoning errors.",
-        config_list=config_list,
-    )
-    with open(f"{here}/math_utils.py.improved", "w") as f:
-        f.write(improved)
-    suggestion, _ = improve_code(
-        ["flaml/autogen/code_utils.py", "flaml/autogen/math_utils.py"],
-        "leverage generative AI smartly and cost-effectively",
-        config_list=config_list,
-    )
-    print(suggestion)
-    improvement, cost = improve_code(
-        ["flaml/autogen/code_utils.py", "flaml/autogen/math_utils.py"],
-        "leverage generative AI smartly and cost-effectively",
-        suggest_only=False,
-        config_list=config_list,
-    )
-    print(cost)
-    with open(f"{here}/suggested_improvement.txt", "w") as f:
-        f.write(improvement)
-
-
 def test_nocontext():
     try:
         import openai
@@ -144,12 +109,12 @@ def test_nocontext():
     except ImportError as exc:
         print(exc)
         return
-    response = oai.Completion.create(
+    response = autogen.Completion.create(
         model="text-ada-001", prompt="1+1=", max_tokens=1, use_cache=False, request_timeout=10
     )
     print(response)
     code, _ = generate_code(
-        config_list=oai.config_list_from_json(
+        config_list=autogen.config_list_from_json(
             OAI_CONFIG_LIST,
             file_location=KEY_LOC,
             filter_dict={
@@ -175,7 +140,7 @@ def test_nocontext():
     )
     print(code)
 
-    solution, cost = solve_problem("1+1=", config_list=oai.config_list_gpt4_gpt35(KEY_LOC))
+    solution, cost = solve_problem("1+1=", config_list=autogen.config_list_gpt4_gpt35(KEY_LOC))
     print(solution, cost)
 
 
@@ -184,7 +149,7 @@ def test_nocontext():
     reason="do not run on windows",
 )
 def test_humaneval(num_samples=1):
-    gpt35_config_list = oai.config_list_from_json(
+    gpt35_config_list = autogen.config_list_from_json(
         env_or_file="OAI_CONFIG_LIST",
         filter_dict={
             "model": {
@@ -221,17 +186,17 @@ def test_humaneval(num_samples=1):
         }
         for x in range(n_tune_data, len(data))
     ]
-    oai.Completion.clear_cache(cache_path_root="{here}/cache")
-    oai.Completion.set_cache(seed)
+    autogen.Completion.clear_cache(cache_path_root="{here}/cache")
+    autogen.Completion.set_cache(seed)
     try:
         import openai
         import diskcache
     except ImportError as exc:
         print(exc)
         return
-    oai.Completion.clear_cache(400)
+    autogen.Completion.clear_cache(400)
     # no error should be raised
-    response = oai.Completion.create(
+    response = autogen.Completion.create(
         context=test_data[0],
         config_list=[{"model": "gpt-3.5-turbo"}],
         prompt="",
@@ -241,7 +206,7 @@ def test_humaneval(num_samples=1):
     )
     # assert response == -1
     # a minimal tuning example
-    config, _ = oai.Completion.tune(
+    config, _ = autogen.Completion.tune(
         data=tune_data,
         metric="success",
         mode="max",
@@ -249,9 +214,9 @@ def test_humaneval(num_samples=1):
         n=1,
         prompt="{definition}",
     )
-    response = oai.Completion.create(context=test_data[0], **config)
+    response = autogen.Completion.create(context=test_data[0], **config)
     # a minimal tuning example for tuning chat completion models using the Completion class
-    config, _ = oai.Completion.tune(
+    config, _ = autogen.Completion.tune(
         data=tune_data,
         metric="succeed_assertions",
         mode="max",
@@ -260,10 +225,10 @@ def test_humaneval(num_samples=1):
         model="text-davinci-003",
         prompt="{definition}",
     )
-    response = oai.Completion.create(context=test_data[0], **config)
+    response = autogen.Completion.create(context=test_data[0], **config)
     # a minimal tuning example for tuning chat completion models using the ChatCompletion class
-    config_list = oai.config_list_openai_aoai(KEY_LOC)
-    config, _ = oai.ChatCompletion.tune(
+    config_list = autogen.config_list_openai_aoai(KEY_LOC)
+    config, _ = autogen.ChatCompletion.tune(
         data=tune_data,
         metric="expected_success",
         mode="max",
@@ -272,7 +237,7 @@ def test_humaneval(num_samples=1):
         messages=[{"role": "user", "content": "{definition}"}],
         config_list=config_list,
     )
-    response = oai.ChatCompletion.create(context=test_data[0], config_list=config_list, **config)
+    response = autogen.ChatCompletion.create(context=test_data[0], config_list=config_list, **config)
     print(response)
     from openai.error import RateLimitError
 
@@ -289,7 +254,7 @@ def test_humaneval(num_samples=1):
     assert selected == 0
     print(eval_function_completions([code], **tune_data[1]))
     # a more comprehensive tuning example
-    config2, analysis = oai.Completion.tune(
+    config2, analysis = autogen.Completion.tune(
         data=tune_data,
         metric="success",
         mode="max",
@@ -310,12 +275,12 @@ def test_humaneval(num_samples=1):
     print(config2)
     print(analysis.best_result)
     print(test_data[0])
-    response = oai.Completion.create(context=test_data[0], **config2)
+    response = autogen.Completion.create(context=test_data[0], **config2)
     print(response)
-    oai.Completion.data = test_data[:num_samples]
-    result = oai.Completion._eval(analysis.best_config, prune=False, eval_only=True)
+    autogen.Completion.data = test_data[:num_samples]
+    result = autogen.Completion._eval(analysis.best_config, prune=False, eval_only=True)
     print("result without pruning", result)
-    result = oai.Completion.test(test_data[:num_samples], **config2)
+    result = autogen.Completion.test(test_data[:num_samples], **config2)
     print(result)
     try:
         code, cost, selected = implement(
@@ -376,7 +341,7 @@ def test_math(num_samples=-1):
         % data["problem"]
     ]
 
-    oai.Completion.set_cache(seed)
+    autogen.Completion.set_cache(seed)
     vanilla_config = {
         "model": "text-davinci-003",
         "temperature": 1,
@@ -386,8 +351,8 @@ def test_math(num_samples=-1):
         "stop": "###",
     }
     test_data_sample = test_data[0:3]
-    result = oai.Completion.test(test_data_sample, eval_math_responses, **vanilla_config)
-    result = oai.Completion.test(
+    result = autogen.Completion.test(test_data_sample, eval_math_responses, **vanilla_config)
+    result = autogen.Completion.test(
         test_data_sample,
         eval_math_responses,
         agg_method="median",
@@ -400,13 +365,13 @@ def my_median(results):
     def my_average(results):
         return np.mean(results)
 
-    result = oai.Completion.test(
+    result = autogen.Completion.test(
         test_data_sample,
         eval_math_responses,
         agg_method=my_median,
         **vanilla_config,
     )
-    result = oai.Completion.test(
+    result = autogen.Completion.test(
         test_data_sample,
         eval_math_responses,
         agg_method={
@@ -420,7 +385,7 @@ def my_average(results):
 
     print(result)
 
-    config, _ = oai.Completion.tune(
+    config, _ = autogen.Completion.tune(
         data=tune_data,  # the data for tuning
         metric="expected_success",  # the metric to optimize
         mode="max",  # the optimization mode
@@ -433,7 +398,7 @@ def my_average(results):
         stop="###",  # the stop sequence
     )
     print("tuned config", config)
-    result = oai.Completion.test(test_data_sample, config_list=oai.config_list_openai_aoai(KEY_LOC), **config)
+    result = autogen.Completion.test(test_data_sample, config_list=autogen.config_list_openai_aoai(KEY_LOC), **config)
     print("result from tuned config:", result)
     print("empty responses", eval_math_responses([], None))
 
@@ -441,7 +406,7 @@ def my_average(results):
 if __name__ == "__main__":
     import openai
 
-    config_list = oai.config_list_openai_aoai(KEY_LOC)
+    config_list = autogen.config_list_openai_aoai(KEY_LOC)
     assert len(config_list) >= 3, config_list
     openai.api_key = os.environ["OPENAI_API_KEY"]
 
diff --git a/test/autogen/oai/test_utils.py b/test/autogen/oai/test_utils.py
index 2789e5cba8..17ed33d7f6 100644
--- a/test/autogen/oai/test_utils.py
+++ b/test/autogen/oai/test_utils.py
@@ -1,22 +1,21 @@
 import json
 import os
-from flaml import oai
-
-KEY_LOC = "test/autogen"
+from flaml import autogen
+from test_completion import KEY_LOC, OAI_CONFIG_LIST
 
 
 def test_config_list_from_json():
-    config_list = oai.config_list_gpt4_gpt35(key_file_path=KEY_LOC)
+    config_list = autogen.config_list_gpt4_gpt35(key_file_path=KEY_LOC)
     json_file = os.path.join(KEY_LOC, "config_list_test.json")
     with open(json_file, "w") as f:
         json.dump(config_list, f, indent=4)
-    config_list_1 = oai.config_list_from_json(json_file)
+    config_list_1 = autogen.config_list_from_json(json_file)
     assert config_list == config_list_1
     os.environ["config_list_test"] = json.dumps(config_list)
-    config_list_2 = oai.config_list_from_json("config_list_test")
+    config_list_2 = autogen.config_list_from_json("config_list_test")
     assert config_list == config_list_2
-    config_list_3 = oai.config_list_from_json(
-        "OAI_CONFIG_LIST", file_location=KEY_LOC, filter_dict={"model": ["gpt4", "gpt-4-32k"]}
+    config_list_3 = autogen.config_list_from_json(
+        OAI_CONFIG_LIST, file_location=KEY_LOC, filter_dict={"model": ["gpt4", "gpt-4-32k"]}
     )
     assert all(config.get("model") in ["gpt4", "gpt-4-32k"] for config in config_list_3)
     del os.environ["config_list_test"]
@@ -24,7 +23,7 @@ def test_config_list_from_json():
 
 
 def test_config_list_openai_aoai():
-    config_list = oai.config_list_openai_aoai(key_file_path=KEY_LOC)
+    config_list = autogen.config_list_openai_aoai(key_file_path=KEY_LOC)
     assert all(config.get("api_type") in [None, "open_ai", "azure"] for config in config_list)
 
 
diff --git a/test/autogen/test_code.py b/test/autogen/test_code.py
index af7652b8d3..ce4a4e95fc 100644
--- a/test/autogen/test_code.py
+++ b/test/autogen/test_code.py
@@ -1,11 +1,151 @@
 import sys
 import os
 import pytest
-from flaml.autogen.code_utils import UNKNOWN, extract_code, execute_code, infer_lang
+from flaml import autogen
+from flaml.autogen.code_utils import (
+    UNKNOWN,
+    extract_code,
+    execute_code,
+    infer_lang,
+    improve_code,
+    improve_function,
+)
 
+KEY_LOC = "notebook"
+OAI_CONFIG_LIST = "OAI_CONFIG_LIST"
 here = os.path.abspath(os.path.dirname(__file__))
 
 
+# def test_find_code():
+#     try:
+#         import openai
+#     except ImportError:
+#         return
+#     # need gpt-4 for this task
+#     config_list = autogen.config_list_from_json(
+#         OAI_CONFIG_LIST,
+#         file_location=KEY_LOC,
+#         filter_dict={
+#             "model": ["gpt-4", "gpt4", "gpt-4-32k", "gpt-4-32k-0314"],
+#         },
+#     )
+#     # config_list = autogen.config_list_from_json(
+#     #     OAI_CONFIG_LIST,
+#     #     file_location=KEY_LOC,
+#     #     filter_dict={
+#     #         "model": {
+#     #             "gpt-3.5-turbo",
+#     #             "gpt-3.5-turbo-16k",
+#     #             "gpt-3.5-turbo-0301",
+#     #             "chatgpt-35-turbo-0301",
+#     #             "gpt-35-turbo-v0301",
+#     #         },
+#     #     },
+#     # )
+#     seed = 42
+#     messages = [
+#         {
+#             "role": "user",
+#             "content": "Print hello world to a file called hello.txt",
+#         },
+#         {
+#             "role": "user",
+#             "content": """
+# # filename: write_hello.py
+# ```
+# with open('hello.txt', 'w') as f:
+#     f.write('Hello, World!')
+# print('Hello, World! printed to hello.txt')
+# ```
+# Please execute the above Python code to print "Hello, World!" to a file called hello.txt and print the success message.
+# """,
+#         },
+#     ]
+#     codeblocks, _ = find_code(messages, seed=seed, config_list=config_list)
+#     assert codeblocks[0][0] == "python", codeblocks
+#     messages += [
+#         {
+#             "role": "user",
+#             "content": """
+# exitcode: 0 (execution succeeded)
+# Code output:
+# Hello, World! printed to hello.txt
+# """,
+#         },
+#         {
+#             "role": "assistant",
+#             "content": "Great! Can I help you with anything else?",
+#         },
+#     ]
+#     codeblocks, content = find_code(messages, seed=seed, config_list=config_list)
+#     assert codeblocks[0][0] == "unknown", content
+#     messages += [
+#         {
+#             "role": "user",
+#             "content": "Save a pandas df with 3 rows and 3 columns to disk.",
+#         },
+#         {
+#             "role": "assistant",
+#             "content": """
+# ```
+# # filename: save_df.py
+# import pandas as pd
+
+# df = pd.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6]})
+# df.to_csv('df.csv')
+# print('df saved to df.csv')
+# ```
+# Please execute the above Python code to save a pandas df with 3 rows and 3 columns to disk.
+# Before you run the code above, run
+# ```
+# pip install pandas
+# ```
+# first to install pandas.
+# """,
+#         },
+#     ]
+#     codeblocks, content = find_code(messages, seed=seed, config_list=config_list)
+#     assert (
+#         len(codeblocks) == 2
+#         and (codeblocks[0][0] == "sh"
+#         and codeblocks[1][0] == "python"
+#         or codeblocks[0][0] == "python"
+#         and codeblocks[1][0] == "sh")
+#     ), content
+
+#     messages += [
+#         {
+#             "role": "user",
+#             "content": "The code is unsafe to execute in my environment.",
+#         },
+#         {
+#             "role": "assistant",
+#             "content": "please run python write_hello.py",
+#         },
+#     ]
+#     # codeblocks, content = find_code(messages, config_list=config_list)
+#     # assert codeblocks[0][0] != "unknown", content
+#     # I'm sorry, but I cannot execute code from earlier messages. Please provide the code again if you would like me to execute it.
+
+#     messages[-1]["content"] = "please skip pip install pandas if you already have pandas installed"
+#     codeblocks, content = find_code(messages, seed=seed, config_list=config_list)
+#     assert codeblocks[0][0] != "sh", content
+
+#     messages += [
+#         {
+#             "role": "user",
+#             "content": "The code is still unsafe to execute in my environment.",
+#         },
+#         {
+#             "role": "assistant",
+#             "content": "Let me try something else. Do you have docker installed?",
+#         },
+#     ]
+#     codeblocks, content = find_code(messages, seed=seed, config_list=config_list)
+#     assert codeblocks[0][0] == "unknown", content
+#     print(content)
+
+
 def test_infer_lang():
     assert infer_lang("print('hello world')") == "python"
     assert infer_lang("pip install flaml") == "sh"
@@ -59,12 +199,16 @@ def test_execute_code():
         import docker
     except ImportError as exc:
         print(exc)
-        return
-    exitcode, msg, image = execute_code("print('hello world')", filename="tmp/codetest.py")
-    assert exitcode == 0 and msg == b"hello world\n", msg
+        docker = None
+    exit_code, msg, image = execute_code("print('hello world')", filename="tmp/codetest.py")
+    assert exit_code == 0 and msg == "hello world\n", msg
     # read a file
     print(execute_code("with open('tmp/codetest.py', 'r') as f: a=f.read()"))
     # create a file
+    exit_code, msg, image = execute_code(
+        "with open('tmp/codetest.py', 'w') as f: f.write('b=1')", work_dir=f"{here}/my_tmp", filename="tmp2/codetest.py"
+    )
+    assert exit_code and 'File "tmp2/codetest.py"' in msg, msg
     print(execute_code("with open('tmp/codetest.py', 'w') as f: f.write('b=1')", work_dir=f"{here}/my_tmp"))
     # execute code in a file
     print(execute_code(filename="tmp/codetest.py"))
@@ -72,20 +216,53 @@ def test_execute_code():
     # execute code for assertion error
     exit_code, msg, image = execute_code("assert 1==2")
     assert exit_code, msg
+    assert 'File ""' in msg
     # execute code which takes a long time
     exit_code, error, image = execute_code("import time; time.sleep(2)", timeout=1)
-    assert exit_code and error.decode() == "Timeout"
-    assert isinstance(image, str)
+    assert exit_code and error == "Timeout"
+    assert isinstance(image, str) or docker is None or os.path.exists("/.dockerenv")
 
 
 def test_execute_code_no_docker():
     exit_code, error, image = execute_code("import time; time.sleep(2)", timeout=1, use_docker=False)
     if sys.platform != "win32":
-        assert exit_code and error.decode() == "Timeout"
+        assert exit_code and error == "Timeout"
     assert image is None
 
 
+def test_improve():
+    try:
+        import openai
+    except ImportError:
+        return
+    config_list = autogen.config_list_openai_aoai(KEY_LOC)
+    improved, _ = improve_function(
+        "flaml/autogen/math_utils.py",
+        "solve_problem",
+        "Solve math problems accurately, by avoiding calculation errors and reduce reasoning errors.",
+        config_list=config_list,
+    )
+    with open(f"{here}/math_utils.py.improved", "w") as f:
+        f.write(improved)
+    suggestion, _ = improve_code(
+        ["flaml/autogen/code_utils.py", "flaml/autogen/math_utils.py"],
+        "leverage generative AI smartly and cost-effectively",
+        config_list=config_list,
+    )
+    print(suggestion)
+    improvement, cost = improve_code(
+        ["flaml/autogen/code_utils.py", "flaml/autogen/math_utils.py"],
+        "leverage generative AI smartly and cost-effectively",
+        suggest_only=False,
+        config_list=config_list,
+    )
+    print(cost)
+    with open(f"{here}/suggested_improvement.txt", "w") as f:
+        f.write(improvement)
+
+
 if __name__ == "__main__":
     # test_infer_lang()
     # test_extract_code()
     test_execute_code()
+    # test_find_code()
diff --git a/test/autogen/test_function_call.py b/test/autogen/test_function_call.py
index ebce5f018f..f566bfbf8d 100644
--- a/test/autogen/test_function_call.py
+++ b/test/autogen/test_function_call.py
@@ -4,15 +4,14 @@
     openai = None
 import pytest
 import json
-from flaml import oai
+from flaml import autogen
 from flaml.autogen.math_utils import eval_math_responses
-
-KEY_LOC = "test/autogen"
+from test_code import KEY_LOC
 
 
 @pytest.mark.skipif(openai is None, reason="openai not installed")
 def test_eval_math_responses():
-    config_list = oai.config_list_from_models(
+    config_list = autogen.config_list_from_models(
         KEY_LOC, exclude="aoai", model_list=["gpt-4-0613", "gpt-3.5-turbo-0613", "gpt-3.5-turbo-16k"]
     )
     functions = [
@@ -36,7 +35,7 @@ def test_eval_math_responses():
             },
         },
     ]
-    response = oai.ChatCompletion.create(
+    response = autogen.ChatCompletion.create(
         config_list=config_list,
         messages=[
             {
@@ -47,7 +46,7 @@ def test_eval_math_responses():
         functions=functions,
     )
     print(response)
-    responses = oai.ChatCompletion.extract_text_or_function_call(response)
+    responses = autogen.ChatCompletion.extract_text_or_function_call(response)
     print(responses[0])
     function_call = responses[0]["function_call"]
     name, arguments = function_call["name"], json.loads(function_call["arguments"])